From b75023cb19d69c267c29a69e4e36626e35d36bb9 Mon Sep 17 00:00:00 2001 From: Morten Holm Date: Wed, 30 Nov 2022 16:10:25 +0100 Subject: [PATCH 1/2] Cleanup, additions, pipeline implementations --- .../distributions/all_features_1Dhistogram.py | 214 ---- ...rams_Level2_nugen_numu_IC86.2012.011069.sh | 40 - ..._1Dhistograms_moonL4_segspline_exp13_01.sh | 35 - .../analysis/calibration_test.ipynb | 153 +++ .../analysis/classification_calibration.py | 239 ++++ .../analysis/test.ipynb | 514 ++++++++ .../deployment/run_inference_on_sqlite.py | 80 +- .../development_do_not_commit/test.py | 6 + .../train_classification_model.py | 223 ++++ .../development_do_not_commit/unit_test.py | 118 ++ ...model.py => train_classification_model.py} | 234 ++-- ...train_classification_noise_mu_nu_LeonMC.sh | 54 + ..._classification_stopped_through_LeonMC.sh} | 32 +- .../modelling/train_direction_reco.py | 189 --- ...econstruction_individual_azimuth_zenith.py | 268 ---- .../Classification_performance/plot_cm.py | 112 ++ .../Classification_performance/plot_roc.ipynb | 663 ++++++++++ .../Comparison_RD_MC/Comparison_RD_to_MC.py | 107 ++ .../plotting/Comparison_RD_MC/RD_to_MC.ipynb | 547 ++++++++ .../Comparison_RD_MC/Reweight MC data.ipynb | 1107 +++++++++++++++++ .../plotting/Comparison_RD_MC/cm.ipynb | 123 ++ .../plotting/Comparison_RD_MC/logit.ipynb | 678 ++++++++++ .../Comparison_RD_MC/logit_individual.ipynb | 904 ++++++++++++++ .../plotting/Comparison_RD_MC/plot_roc.ipynb | 521 ++++++++ .../distributions/PIDofPrediction.ipynb | 330 ++--- .../distributions/PIDofPrediction2D.ipynb | 18 +- .../distributions/PIDofPredictionMCRD.ipynb | 702 +++++++++++ .../distributions/PIDofPrediction_RD.ipynb | 336 +++++ .../distributions/generic_1Dhistogram.py | 238 ---- .../generic_1Dhistograms_.sh | 40 - ...neric_1Dhistograms_Multiclass_Leon_data.sh | 40 - .../distributions/predictionOfPID.ipynb | 125 ++ .../event_location/moon_position_true.py | 74 -- .../helper_functions/external_functions.py | 18 + .../script_archive/reconstruction.py | 62 - .../script_archive/reconstruction_Leon_MC.py | 57 - .../uncertainty/plot_all_in_folder.sh | 5 +- .../Uncertainty_test_azimuth.py | 266 ---- .../script_archive/Uncertainty_test_zenith.py | 154 --- 39 files changed, 7626 insertions(+), 2000 deletions(-) delete mode 100644 moon_pointing_analysis/plotting/distributions/all_features_1Dhistogram.py delete mode 100644 moon_pointing_analysis/plotting/distributions/all_features_1Dhistograms_Level2_nugen_numu_IC86.2012.011069.sh delete mode 100644 moon_pointing_analysis/plotting/distributions/all_features_1Dhistograms_moonL4_segspline_exp13_01.sh create mode 100644 multi_classification_on_stop_and_track_muons/analysis/calibration_test.ipynb create mode 100644 multi_classification_on_stop_and_track_muons/analysis/classification_calibration.py create mode 100644 multi_classification_on_stop_and_track_muons/analysis/test.ipynb create mode 100644 multi_classification_on_stop_and_track_muons/development_do_not_commit/test.py create mode 100644 multi_classification_on_stop_and_track_muons/development_do_not_commit/train_classification_model.py create mode 100644 multi_classification_on_stop_and_track_muons/development_do_not_commit/unit_test.py rename multi_classification_on_stop_and_track_muons/modelling/{train_multiclass_classification_model.py => train_classification_model.py} (58%) create mode 100755 multi_classification_on_stop_and_track_muons/modelling/train_classification_noise_mu_nu_LeonMC.sh rename multi_classification_on_stop_and_track_muons/modelling/{pipeline_training_LeonMC_data.sh => train_classification_stopped_through_LeonMC.sh} (59%) delete mode 100644 multi_classification_on_stop_and_track_muons/modelling/train_direction_reco.py delete mode 100644 multi_classification_on_stop_and_track_muons/modelling/train_reconstruction_individual_azimuth_zenith.py create mode 100644 multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_cm.py create mode 100644 multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_roc.ipynb create mode 100644 multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/Comparison_RD_to_MC.py create mode 100644 multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/RD_to_MC.ipynb create mode 100644 multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/Reweight MC data.ipynb create mode 100644 multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/cm.ipynb create mode 100644 multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/logit.ipynb create mode 100644 multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/logit_individual.ipynb create mode 100644 multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/plot_roc.ipynb create mode 100644 multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPredictionMCRD.ipynb create mode 100644 multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPrediction_RD.ipynb delete mode 100644 multi_classification_on_stop_and_track_muons/plotting/distributions/generic_1Dhistogram.py delete mode 100644 multi_classification_on_stop_and_track_muons/plotting/distributions/generic_1Dhistograms_.sh delete mode 100644 multi_classification_on_stop_and_track_muons/plotting/distributions/generic_1Dhistograms_Multiclass_Leon_data.sh create mode 100644 multi_classification_on_stop_and_track_muons/plotting/distributions/predictionOfPID.ipynb delete mode 100644 multi_classification_on_stop_and_track_muons/plotting/event_location/moon_position_true.py delete mode 100755 multi_classification_on_stop_and_track_muons/plotting/reconstruction/script_archive/reconstruction.py delete mode 100644 multi_classification_on_stop_and_track_muons/plotting/reconstruction/script_archive/reconstruction_Leon_MC.py delete mode 100644 multi_classification_on_stop_and_track_muons/plotting/uncertainty/script_archive/Uncertainty_test_azimuth.py delete mode 100644 multi_classification_on_stop_and_track_muons/plotting/uncertainty/script_archive/Uncertainty_test_zenith.py diff --git a/moon_pointing_analysis/plotting/distributions/all_features_1Dhistogram.py b/moon_pointing_analysis/plotting/distributions/all_features_1Dhistogram.py deleted file mode 100644 index 3f07893..0000000 --- a/moon_pointing_analysis/plotting/distributions/all_features_1Dhistogram.py +++ /dev/null @@ -1,214 +0,0 @@ -""" This script is meant purely as an investigation tool of features in a dataset. """ - -import os, sys -sys.path.append(os.path.abspath(os.path.join(os.path.dirname( __file__ ), '..'))) -import argparse -import numpy as np -import sqlite3 as sql -import pandas as pd -import io -from pandas import read_sql -from helper_functions.plot_params import * - -def create_save_directory(args, table): - folder_name=args.path_to_db[:-3].split('/')[-1] - save_dir = args.output + folder_name + "/" + table + "/" - os.makedirs(save_dir, exist_ok=True) - return save_dir - -def tune_bins(data,counts,bins,args): - """attempt to tune bins to find a bin with an acceptable range of zeros""" - # track previous bins - list_bin_attempt = [len(counts)] - list_counts = [counts] - list_bins = [bins] - - # too many zeros bins; auto was not able to find anything meaningful. - if zero_ratio(list_counts[-1]) < args.cutoff: - # try to find a bin that is acceptable. - while zero_ratio(list_counts[-1]) < 0.8 or list_counts[-1].size > 30: - list_bin_attempt.append(int(len(bins)/2)) - counts, bins = np.histogram(data, bins=list_bin_attempt[-1]) - list_counts.append(counts) - list_bins.append(bins) - return list_counts[-2], list_bins[-2], list_bin_attempt[-2] - else: - return list_counts[-1], list_bins[-1], list_bin_attempt[-1] - -def outlier(df, feature, sigma): - # calculate summary statistics - data_mean, data_std = df[feature].mean(), df[feature].std() - # identify outliers - cut_off = data_std * sigma - lower, upper = data_mean - cut_off, data_mean + cut_off - - # identify outliers - temp1 = pd.DataFrame({feature+"_no_outliers" : []}) - temp1 = df[feature][df[feature] < lower] - temp2 = pd.DataFrame({feature+"_no_outliers" : []}) - temp2 = df[feature][df[feature] > upper] - df_outliers = pd.concat([temp1, temp2]) - print('Identified outliers: %d' % len(df_outliers)) - - # remove outliers - temp1 = pd.DataFrame({feature+"_no_outliers" : []}) - temp1 = df[feature][df[feature] >= lower] - temp2 = pd.DataFrame({feature+"_no_outliers" : []}) - temp2 = df[feature][df[feature] <= upper] - df_no_outliers = pd.concat([temp1, temp2]) - print('Non-outlier observations: %d' % len(df_no_outliers)) - - return df_outliers, df_no_outliers - -def custom_bin_range(df): - try: - bin_range = int(df.max() - df.min())+1 - if bin_range > 100: - bin_range = 50 - except: - bin_range = 50 - return bin_range - -def zero_ratio(counts): - try: - x = counts[counts != 0].size / counts[counts == 0].size - except ZeroDivisionError: # no zeros - x = 1 - return x - -parser = argparse.ArgumentParser( - description="plotting all the features as 1-d histograms in a given dataset" -) -parser.add_argument( - "-db", - "--database", - dest="path_to_db", - type=str, - help="path to database [str]", - default="/groups/icecube/petersen/GraphNetDatabaseRepository/moon_pointing_analysis/monte_carlo/11069/Level2_nugen_numu_IC86.2012.011069_InIcePulses_InIceDSTPulses_SplitInIcePulses_SplitInIceDSTPulses_SRTInIcePulses.db", -) -parser.add_argument( - "-o", - "--output", - dest="output", - type=str, - help="the output path [str]", - default="/groups/icecube/petersen/GraphNetDatabaseRepository/moon_pointing_analysis/plots/distributions/", -) -parser.add_argument( - "-s", - "--sigma", - dest="sigma", - type=int, - help="the sigma outlier for cutting data; happen if too many bins in dataset. [int]", - default=2, -) -parser.add_argument( - "-c", - "--cutoff", - dest="cutoff", - type=float, - help="the zero ratio cutoff used in bin tuning; how many zeros instances compared to non zero instances. [int]", - default=0.8, -) -parser.add_argument( - "-l", - "--log", - dest="log", - type=int, - help="if a number exceeds the specified, will scale the graph as log. [int]", - default=5000, -) -args = parser.parse_args() - -ext = (args.path_to_db.split('.')[-1]) -if ext == "db": - # find the name of all tables - with sql.connect(args.path_to_db) as con: - table_query = """SELECT name FROM sqlite_master WHERE type='table';""" - tables = read_sql(table_query, con) - - for table in tables.name: - with sql.connect(args.path_to_db) as con: - feature_query = """SELECT * FROM %s; """ % (table) - feature_data = read_sql(feature_query, con) - - # create a folder to save results into - save_dir = create_save_directory(args, table) - - for feature in feature_data: - print(f"plotting {feature} in {table}.") - try: - # preliminary histogram counts and binning - counts, bins = np.histogram(feature_data[feature], bins='auto') - # tuning attempt to reduce excess zeros - counts, bins, _ = tune_bins(data=feature_data[feature], counts=counts, bins=bins, args=args) - - df_outliers, df_no_outliers = outlier(feature_data, feature, sigma=args.sigma) - - fig, ax = plt.subplots(3,1,figsize=(25, 15)) - - ax[0].set_title(f"full data") - ax[0].hist(feature_data[feature], bins=bins) - ax[0].set_xlabel(feature) - ax[0].set_ylabel("count") - if counts.max() > args.log: - ax[0].set_yscale("log") - - bin_range = custom_bin_range(df_no_outliers) - counts1, bins1 = np.histogram(df_no_outliers, bins=bin_range) - ax[1].set_title(f"outliers under {args.sigma} sigmas") - ax[1].hist(df_no_outliers, bins=bins1) - ax[1].set_xlabel(feature) - ax[1].set_ylabel("count") - if counts.max() > args.log: - ax[1].set_yscale("log") - - bin_range = custom_bin_range(df_outliers) - counts2, bins2 = np.histogram(df_outliers, bins=bin_range) - ax[2].set_title(f"outliers over {args.sigma} sigmas") - ax[2].hist(df_outliers, bins=bins2) - ax[2].set_xlabel(feature) - ax[2].set_ylabel("count") - if counts.max() > args.log: - ax[2].set_yscale("log") - - plt.savefig(save_dir+ feature + ".png") - - except Exception as e: - print(f"plotting {feature} in {table} failed") - print(e) - - -elif ext == "csv": - feature_data = pd.read_csv(args.path_to_db) - extra_index = "Unnamed: 0" - # if an extra index is imported, drop it. - if extra_index in feature_data.keys(): - feature_data = feature_data.drop(extra_index, axis=1) - - # create a folder to save results into - folder_name=args.path_to_db[:-4].split('/')[-1] - save_dir = args.output + folder_name + "/" - os.makedirs(save_dir, exist_ok=True) - - for feature in feature_data: - print(f"plotting {feature}.") - try: - x = feature_data[feature] - bin_range = int((max(x)) - min(x))+1 - if bin_range > 50000 and feature_data[feature].all() > 0: - bin_range = 25 - counts, bins = np.histogram(x, bins=bin_range) - - plt.figure() - plt.hist(counts, bins=bins) - plt.title(f"{feature}") - if counts.mean() > 50000: - plt.yscale("log") - plt.savefig(save_dir+ feature + ".png") - plt.close() # plots are saved in memory, closing to conserve - except: - print(f"plotting {feature} failed, data type was of type: {type(feature_data[feature][0])}") - -print("Done plotting.") \ No newline at end of file diff --git a/moon_pointing_analysis/plotting/distributions/all_features_1Dhistograms_Level2_nugen_numu_IC86.2012.011069.sh b/moon_pointing_analysis/plotting/distributions/all_features_1Dhistograms_Level2_nugen_numu_IC86.2012.011069.sh deleted file mode 100644 index 27e3d13..0000000 --- a/moon_pointing_analysis/plotting/distributions/all_features_1Dhistograms_Level2_nugen_numu_IC86.2012.011069.sh +++ /dev/null @@ -1,40 +0,0 @@ -#!/bin/bash -bash_directory=$(dirname -- "$(readlink -f "${BASH_SOURCE}")") # !do not alter! - -## Description: This bash script is meant to plot everything in the folder - -# to recreate the results, follow the steps below. -# (1) designate directory containing database; data described in folder. -database_directory=/groups/icecube/petersen/GraphNetDatabaseRepository/moon_pointing_analysis/monte_carlo/11069/Level2_nugen_numu_IC86.2012.011069_InIcePulses_InIceDSTPulses_SplitInIcePulses_SplitInIceDSTPulses_SRTInIcePulses.db -# (2) to run this shell script; copy file path and execute "bash " - -sigma=2 -cutoff=0.7 -log=5000 - - - - - -## do not alter beyond this point ## -#output directory for created plots. -output_directory=${bash_directory}/test_plot/ -# save the report file to -report_name=plot # overwrites old, thus only keeps the one with error -report_directory=/groups/icecube/${USER}/storage/nohup_reports/ -# if directories does not exist for reporting, create them. -mkdir -p ${output_directory}; -mkdir -p ${report_directory}; - -# save the report file to -report_location=${report_directory}${report_name}.out - -echo "plotting histogram of all features" -nohup python ${bash_directory}/all_features_1Dhistogram.py \ --db ${database_directory} \ --o ${output_directory} \ --s ${sigma} \ --c ${cutoff} \ --l ${log} \ -> ${report_location} \ -2> ${report_directory}${report_name}.err & \ No newline at end of file diff --git a/moon_pointing_analysis/plotting/distributions/all_features_1Dhistograms_moonL4_segspline_exp13_01.sh b/moon_pointing_analysis/plotting/distributions/all_features_1Dhistograms_moonL4_segspline_exp13_01.sh deleted file mode 100644 index e99dfdf..0000000 --- a/moon_pointing_analysis/plotting/distributions/all_features_1Dhistograms_moonL4_segspline_exp13_01.sh +++ /dev/null @@ -1,35 +0,0 @@ -#!/bin/bash -bash_directory=$(dirname -- "$(readlink -f "${BASH_SOURCE}")") # !do not alter! - -## Description: This bash script is meant to plot everything in the folder - -# to recreate the results, follow the steps below. -# (1) designate directory containing database; data described in folder. -database_directory=/groups/icecube/petersen/GraphNetDatabaseRepository/moon_pointing_analysis/real_data/data_with_reco/moonL4_segspline_exp13_01_merged_with_time_and_reco_and_new_pulsemap.db -# (2) to run this shell script; copy file path and execute "bash " - - - - - - - - -## do not alter beyond this point ## -#output directory for created plots. -output_directory=${bash_directory}/test_plot/ -# save the report file to -report_name=plot # overwrites old, thus only keeps the one with error -report_directory=/groups/icecube/${USER}/storage/nohup_reports/ -# if directories does not exist for reporting, create them. -mkdir -p ${output_directory}; -mkdir -p ${report_directory}; - -# save the report file to -report_location=${report_directory}${report_name}.out - -echo "plotting histogram of all features" -nohup python ${bash_directory}/all_features_1Dhistogram.py \ --db ${database_directory} \ --o ${output_directory} \ -> ${report_location} & \ No newline at end of file diff --git a/multi_classification_on_stop_and_track_muons/analysis/calibration_test.ipynb b/multi_classification_on_stop_and_track_muons/analysis/calibration_test.ipynb new file mode 100644 index 0000000..633c122 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/analysis/calibration_test.ipynb @@ -0,0 +1,153 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/groups/icecube/qgf305/anaconda3/envs/graphnet/lib/python3.8/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import sqlite3 as sql\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "from pandas import cut, read_sql\n", + "import pickle as pkl\n", + "from random import choices\n", + "from sklearn import metrics\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors as colors\n", + "from numpy import interp\n", + "\n", + "from torch.nn.functional import one_hot\n", + "import torch\n", + "from sklearn.metrics import auc\n", + "from sklearn.metrics import roc_curve, auc\n", + "from sklearn.multiclass import OneVsRestClassifier\n", + "from sklearn.metrics import roc_auc_score\n", + "from sklearn.preprocessing import label_binarize" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "indir = \"/groups/icecube/peter/storage/Multiclassification/Real/last_one_lvl3MC/dynedge_pid_Real_run_21.5_mill_equal_frac_/results_first.csv\"\n", + "results = pd.read_csv(indir, index_col=[0]).sort_values('event_no').reset_index()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "## transform data\n", + "# remove anti\n", + "results['pid'] = results['pid'].apply(abs)\n", + "# make all neutrinos the same class; to match prediction\n", + "results.loc[results['pid']==14, \"pid\"]=12\n", + "results.loc[results['pid']==16, \"pid\"]=12\n", + "results[\"pid\"] = results[\"pid\"].astype(\"int\")\n", + "np.unique(results[\"pid\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Binarize the output\n", + "pid_true = label_binarize(results[\"pid\"], classes=[1, 12, 13])\n", + "nb_classes = pid_true.shape[1]\n", + "y_test = pid_true \n", + "y_prob = results[[\"pid_noise_pred\",\"pid_muon_pred\",\"pid_neutrino_pred\"]]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig = plt.figure(figsize=(10, 10))\n", + "gs = GridSpec(4, 2)\n", + "colors = plt.cm.get_cmap(\"Dark2\")\n", + "\n", + "ax_calibration_curve = fig.add_subplot(gs[:2, :2])\n", + "calibration_displays = {}\n", + "for i, (clf, name) in enumerate(clf_list):\n", + " clf.fit(X_train, y_train)\n", + " display = CalibrationDisplay.from_estimator(\n", + " clf,\n", + " X_test,\n", + " y_test,\n", + " n_bins=10,\n", + " name=name,\n", + " ax=ax_calibration_curve,\n", + " color=colors(i),\n", + " )\n", + " calibration_displays[name] = display\n", + "\n", + "ax_calibration_curve.grid()\n", + "ax_calibration_curve.set_title(\"Calibration plots (Naive Bayes)\")\n", + "\n", + "# Add histogram\n", + "grid_positions = [(2, 0), (2, 1), (3, 0), (3, 1)]\n", + "for i, (_, name) in enumerate(clf_list):\n", + " row, col = grid_positions[i]\n", + " ax = fig.add_subplot(gs[row, col])\n", + "\n", + " ax.hist(\n", + " calibration_displays[name].y_prob,\n", + " range=(0, 1),\n", + " bins=10,\n", + " label=name,\n", + " color=colors(i),\n", + " )\n", + " ax.set(title=name, xlabel=\"Mean predicted probability\", ylabel=\"Count\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('graphnet')", + "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.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e54c104f54ca5f79eede1c2e02355cc39841da57601eff628eedcebaaa867660" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/multi_classification_on_stop_and_track_muons/analysis/classification_calibration.py b/multi_classification_on_stop_and_track_muons/analysis/classification_calibration.py new file mode 100644 index 0000000..7b7ec32 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/analysis/classification_calibration.py @@ -0,0 +1,239 @@ +"""Example of non-parametric isotonic calibration of a classification Model.""" + +import os +from typing import cast +import numpy as np + +from pytorch_lightning import Trainer +from pytorch_lightning.callbacks import EarlyStopping + +# from pytorch_lightning.loggers import WandbLogger +import torch +from torch.optim.adam import Adam + +from graphnet.training.loss_functions import NLLLoss +from graphnet.data.constants import FEATURES, TRUTH +from graphnet.data.sqlite.sqlite_selection import ( + get_desired_event_numbers, +) +from graphnet.models import StandardModel +from graphnet.models.detector.icecube import IceCubeDeepCore +from graphnet.models.gnn import DynEdge +from graphnet.models.graph_builders import KNNGraphBuilder +from graphnet.models.task.classification import ClassificationTask +from graphnet.training.callbacks import ProgressBar, PiecewiseLinearLR +from graphnet.training.utils import ( + get_predictions, + make_train_validation_dataloader, + make_dataloaders, + save_results, +) +from sklearn.calibration import CalibratedClassifierCV, CalibrationDisplay + +# from graphnet.utilities.logging import get_logger + +# logger = get_logger() + +# Configurations +torch.multiprocessing.set_sharing_strategy("file_system") + +# Constants +features = FEATURES.DEEPCORE +truth = TRUTH.DEEPCORE[:-1] + +# Make sure W&B output directory exists +WANDB_DIR = "./wandb/" +os.makedirs(WANDB_DIR, exist_ok=True) + +# Initialise Weights & Biases (W&B) run +# wandb_logger = WandbLogger( +# project="example-script", +# entity="graphnet-team", +# save_dir=WANDB_DIR, +# log_model=True, +# ) + + +def main() -> None: + """Run example.""" + # logger.info(f"features: {features}") + # logger.info(f"truth: {truth}") + + # single integer definition of class + # class_options = 3 + # list of classes + # class_options = [0,1,2] + # transformation of target to a given class integer + class_options = { + 1: 0, + -1: 0, + 13: 1, + -13: 1, + 12: 2, + -12: 2, + 14: 2, + -14: 2, + 16: 2, + -16: 2, + } + + # Configuration + config = { + "db": "/groups/icecube/petersen/GraphNetDatabaseRepository/Leon_MC_data/last_one_lvl3MC.db", + "pulsemap": "SplitInIcePulses", + "batch_size": 512, + "num_workers": 10, + "accelerator": "cpu", # gpu + "devices": 1, # [0], + "target": "pid", + "classification": class_options, + "n_epochs": 10, + "patience": 5, + } + archive = "/groups/icecube/petersen/GraphNetDatabaseRepository/example_results/train_classification_model" + run_name = "dynedge_{}_example".format(config["target"]) + + # Log configuration to W&B + # wandb_logger.experiment.config.update(config) + + # Common variables + train_selection = get_desired_event_numbers( + database=cast(str, config["db"]), + desired_size=1000, + fraction_noise=float(1 / 3), + fraction_muon=float(1 / 3), + fraction_nu_e=float(1 / 9), + fraction_nu_mu=float(1 / 9), + fraction_nu_tau=float(1 / 9), + ) + + ( + training_dataloader, + validation_dataloader, + test_dataloader + ) = make_dataloaders( + data_path=cast(str, config["db"]), + selection=train_selection, + pulsemaps=cast(str, config["pulsemap"]), + features=features, + truth=truth, + batch_size=cast(int, config["batch_size"]), + num_workers=cast(int, config["num_workers"]), + ) + + # Building model + detector = IceCubeDeepCore( + graph_builder=KNNGraphBuilder(nb_nearest_neighbours=8), + ) + gnn = DynEdge( + nb_inputs=detector.nb_outputs, + global_pooling_schemes=["min", "max", "mean", "sum"], + ) + task = ClassificationTask( + nb_classes=len(np.unique(list(class_options.values()))), + hidden_size=gnn.nb_outputs, + target_labels=config["target"], + loss_function=NLLLoss(options=config["classification"]), + ) + model = StandardModel( + detector=detector, + gnn=gnn, + tasks=[task], + optimizer_class=Adam, + optimizer_kwargs={"lr": 1e-03, "eps": 1e-03}, + scheduler_class=PiecewiseLinearLR, + scheduler_kwargs={ + "milestones": [ + 0, + len(training_dataloader) / 2, + len(training_dataloader) * cast(int, config["n_epochs"]), + ], + "factors": [1e-2, 1, 1e-02], + }, + scheduler_config={ + "interval": "step", + }, + ) + + # Training model + callbacks = [ + EarlyStopping( + monitor="val_loss", + patience=config["patience"], + ), + ProgressBar(), + ] + + trainer = Trainer( + accelerator=config["accelerator"], + devices=config["devices"], + max_epochs=config["n_epochs"], + callbacks=callbacks, + log_every_n_steps=1, + # logger=wandb_logger, + ) + + try: + trainer.fit(model, training_dataloader, validation_dataloader) + except KeyboardInterrupt: + # logger.warning("[ctrl+c] Exiting gracefully.") + pass + + # Saving predictions to file + results = get_predictions( + trainer, + model, + validation_dataloader, + [ + cast(str, config["target"]) + "_noise_pred", + cast(str, config["target"]) + "_muon_pred", + cast(str, config["target"]) + "_neutrino_pred", + ], + additional_attributes=[cast(str, config["target"]), "event_no"], + ) + + #save_results(cast(str, config["db"]), run_name, results, archive, model) + + fig = plt.figure(figsize=(10, 10)) + gs = GridSpec(4, 2) + colors = plt.cm.get_cmap("Dark2") + + ax_calibration_curve = fig.add_subplot(gs[:2, :2]) + calibration_displays = {} + for i, (clf, name) in enumerate(clf_list): + clf.fit(X_train, y_train) + display = CalibrationDisplay.from_estimator( + clf, + X_test, + y_test, + n_bins=10, + name=name, + ax=ax_calibration_curve, + color=colors(i), + ) + calibration_displays[name] = display + + ax_calibration_curve.grid() + ax_calibration_curve.set_title("Calibration plots (Naive Bayes)") + + # Add histogram + grid_positions = [(2, 0), (2, 1), (3, 0), (3, 1)] + for i, (_, name) in enumerate(clf_list): + row, col = grid_positions[i] + ax = fig.add_subplot(gs[row, col]) + + ax.hist( + calibration_displays[name].y_prob, + range=(0, 1), + bins=10, + label=name, + color=colors(i), + ) + ax.set(title=name, xlabel="Mean predicted probability", ylabel="Count") + + plt.tight_layout() + plt.show() + + +if __name__ == "__main__": + main() diff --git a/multi_classification_on_stop_and_track_muons/analysis/test.ipynb b/multi_classification_on_stop_and_track_muons/analysis/test.ipynb new file mode 100644 index 0000000..cf89052 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/analysis/test.ipynb @@ -0,0 +1,514 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.datasets import make_classification\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "X, y = make_classification(\n", + " n_samples=100_000, n_features=20, n_informative=2, n_redundant=10, random_state=42\n", + ")\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " X, y, test_size=0.99, random_state=42\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from matplotlib.gridspec import GridSpec\n", + "\n", + "from sklearn.calibration import CalibratedClassifierCV, CalibrationDisplay\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.naive_bayes import GaussianNB\n", + "\n", + "lr = LogisticRegression(C=1.0)\n", + "gnb = GaussianNB()\n", + "gnb_isotonic = CalibratedClassifierCV(gnb, cv=2, method=\"isotonic\")\n", + "gnb_sigmoid = CalibratedClassifierCV(gnb, cv=2, method=\"sigmoid\")\n", + "\n", + "clf_list = [\n", + " (lr, \"Logistic\"),\n", + " (gnb, \"Naive Bayes\"),\n", + " (gnb_isotonic, \"Naive Bayes + Isotonic\"),\n", + " (gnb_sigmoid, \"Naive Bayes + Sigmoid\"),\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(10, 10))\n", + "gs = GridSpec(4, 2)\n", + "colors = plt.cm.get_cmap(\"Dark2\")\n", + "\n", + "ax_calibration_curve = fig.add_subplot(gs[:2, :2])\n", + "calibration_displays = {}\n", + "for i, (clf, name) in enumerate(clf_list):\n", + " clf.fit(X_train, y_train)\n", + " display = CalibrationDisplay.from_estimator(\n", + " clf,\n", + " X_test,\n", + " y_test,\n", + " n_bins=10,\n", + " name=name,\n", + " ax=ax_calibration_curve,\n", + " color=colors(i),\n", + " )\n", + " calibration_displays[name] = display\n", + "\n", + "ax_calibration_curve.grid()\n", + "ax_calibration_curve.set_title(\"Calibration plots (Naive Bayes)\")\n", + "\n", + "# Add histogram\n", + "grid_positions = [(2, 0), (2, 1), (3, 0), (3, 1)]\n", + "for i, (_, name) in enumerate(clf_list):\n", + " row, col = grid_positions[i]\n", + " ax = fig.add_subplot(gs[row, col])\n", + "\n", + " ax.hist(\n", + " calibration_displays[name].y_prob,\n", + " range=(0, 1),\n", + " bins=10,\n", + " label=name,\n", + " color=colors(i),\n", + " )\n", + " ax.set(title=name, xlabel=\"Mean predicted probability\", ylabel=\"Count\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Brier lossLog lossPrecisionRecallF1Roc auc
Classifier
Logistic0.0989210.3231780.8720090.8514080.8615860.863157
Naive Bayes0.1176080.7822460.8574000.8759410.8665710.865055
Naive Bayes + Isotonic0.0983320.3684120.8830650.8362240.8590070.862690
Naive Bayes + Sigmoid0.1088800.3688960.8611060.8712770.8661610.865300
\n", + "
" + ], + "text/plain": [ + " Brier loss Log loss Precision Recall F1 \\\n", + "Classifier \n", + "Logistic 0.098921 0.323178 0.872009 0.851408 0.861586 \n", + "Naive Bayes 0.117608 0.782246 0.857400 0.875941 0.866571 \n", + "Naive Bayes + Isotonic 0.098332 0.368412 0.883065 0.836224 0.859007 \n", + "Naive Bayes + Sigmoid 0.108880 0.368896 0.861106 0.871277 0.866161 \n", + "\n", + " Roc auc \n", + "Classifier \n", + "Logistic 0.863157 \n", + "Naive Bayes 0.865055 \n", + "Naive Bayes + Isotonic 0.862690 \n", + "Naive Bayes + Sigmoid 0.865300 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from collections import defaultdict\n", + "\n", + "import pandas as pd\n", + "\n", + "from sklearn.metrics import (\n", + " precision_score,\n", + " recall_score,\n", + " f1_score,\n", + " brier_score_loss,\n", + " log_loss,\n", + " roc_auc_score,\n", + ")\n", + "\n", + "scores = defaultdict(list)\n", + "for i, (clf, name) in enumerate(clf_list):\n", + " clf.fit(X_train, y_train)\n", + " y_prob = clf.predict_proba(X_test)\n", + " y_pred = clf.predict(X_test)\n", + " scores[\"Classifier\"].append(name)\n", + "\n", + " for metric in [brier_score_loss, log_loss]:\n", + " score_name = metric.__name__.replace(\"_\", \" \").replace(\"score\", \"\").capitalize()\n", + " scores[score_name].append(metric(y_test, y_prob[:, 1]))\n", + "\n", + " for metric in [precision_score, recall_score, f1_score, roc_auc_score]:\n", + " score_name = metric.__name__.replace(\"_\", \" \").replace(\"score\", \"\").capitalize()\n", + " scores[score_name].append(metric(y_test, y_pred))\n", + "\n", + " score_df = pd.DataFrame(scores).set_index(\"Classifier\")\n", + " score_df.round(decimals=3)\n", + "\n", + "score_df" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "from sklearn.svm import LinearSVC\n", + "\n", + "\n", + "class NaivelyCalibratedLinearSVC(LinearSVC):\n", + " \"\"\"LinearSVC with `predict_proba` method that naively scales\n", + " `decision_function` output for binary classification.\"\"\"\n", + "\n", + " def fit(self, X, y):\n", + " super().fit(X, y)\n", + " df = self.decision_function(X)\n", + " self.df_min_ = df.min()\n", + " self.df_max_ = df.max()\n", + "\n", + " def predict_proba(self, X):\n", + " \"\"\"Min-max scale output of `decision_function` to [0, 1].\"\"\"\n", + " df = self.decision_function(X)\n", + " calibrated_df = (df - self.df_min_) / (self.df_max_ - self.df_min_)\n", + " proba_pos_class = np.clip(calibrated_df, 0, 1)\n", + " proba_neg_class = 1 - proba_pos_class\n", + " proba = np.c_[proba_neg_class, proba_pos_class]\n", + " return proba" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "lr = LogisticRegression(C=1.0)\n", + "svc = NaivelyCalibratedLinearSVC(max_iter=10_000)\n", + "svc_isotonic = CalibratedClassifierCV(svc, cv=2, method=\"isotonic\")\n", + "svc_sigmoid = CalibratedClassifierCV(svc, cv=2, method=\"sigmoid\")\n", + "\n", + "clf_list = [\n", + " (lr, \"Logistic\"),\n", + " (svc, \"SVC\"),\n", + " (svc_isotonic, \"SVC + Isotonic\"),\n", + " (svc_sigmoid, \"SVC + Sigmoid\"),\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(10, 10))\n", + "gs = GridSpec(4, 2)\n", + "\n", + "ax_calibration_curve = fig.add_subplot(gs[:2, :2])\n", + "calibration_displays = {}\n", + "for i, (clf, name) in enumerate(clf_list):\n", + " clf.fit(X_train, y_train)\n", + " display = CalibrationDisplay.from_estimator(\n", + " clf,\n", + " X_test,\n", + " y_test,\n", + " n_bins=10,\n", + " name=name,\n", + " ax=ax_calibration_curve,\n", + " color=colors(i),\n", + " )\n", + " calibration_displays[name] = display\n", + "\n", + "ax_calibration_curve.grid()\n", + "ax_calibration_curve.set_title(\"Calibration plots (SVC)\")\n", + "\n", + "# Add histogram\n", + "grid_positions = [(2, 0), (2, 1), (3, 0), (3, 1)]\n", + "for i, (_, name) in enumerate(clf_list):\n", + " row, col = grid_positions[i]\n", + " ax = fig.add_subplot(gs[row, col])\n", + "\n", + " ax.hist(\n", + " calibration_displays[name].y_prob,\n", + " range=(0, 1),\n", + " bins=10,\n", + " label=name,\n", + " color=colors(i),\n", + " )\n", + " ax.set(title=name, xlabel=\"Mean predicted probability\", ylabel=\"Count\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Brier lossLog lossPrecisionRecallF1Roc auc
Classifier
Logistic0.0989210.3231780.8720090.8514080.8615860.863157
SVC0.1449440.4656470.8722010.8517720.8618650.863420
SVC + Isotonic0.0998270.3745350.8530320.8780410.8653560.863306
SVC + Sigmoid0.0987600.3213060.8737030.8487230.8610320.862957
\n", + "
" + ], + "text/plain": [ + " Brier loss Log loss Precision Recall F1 \\\n", + "Classifier \n", + "Logistic 0.098921 0.323178 0.872009 0.851408 0.861586 \n", + "SVC 0.144944 0.465647 0.872201 0.851772 0.861865 \n", + "SVC + Isotonic 0.099827 0.374535 0.853032 0.878041 0.865356 \n", + "SVC + Sigmoid 0.098760 0.321306 0.873703 0.848723 0.861032 \n", + "\n", + " Roc auc \n", + "Classifier \n", + "Logistic 0.863157 \n", + "SVC 0.863420 \n", + "SVC + Isotonic 0.863306 \n", + "SVC + Sigmoid 0.862957 " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scores = defaultdict(list)\n", + "for i, (clf, name) in enumerate(clf_list):\n", + " clf.fit(X_train, y_train)\n", + " y_prob = clf.predict_proba(X_test)\n", + " y_pred = clf.predict(X_test)\n", + " scores[\"Classifier\"].append(name)\n", + "\n", + " for metric in [brier_score_loss, log_loss]:\n", + " score_name = metric.__name__.replace(\"_\", \" \").replace(\"score\", \"\").capitalize()\n", + " scores[score_name].append(metric(y_test, y_prob[:, 1]))\n", + "\n", + " for metric in [precision_score, recall_score, f1_score, roc_auc_score]:\n", + " score_name = metric.__name__.replace(\"_\", \" \").replace(\"score\", \"\").capitalize()\n", + " scores[score_name].append(metric(y_test, y_pred))\n", + "\n", + " score_df = pd.DataFrame(scores).set_index(\"Classifier\")\n", + " score_df.round(decimals=3)\n", + "\n", + "score_df" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('graphnet')", + "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.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e54c104f54ca5f79eede1c2e02355cc39841da57601eff628eedcebaaa867660" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/multi_classification_on_stop_and_track_muons/deployment/run_inference_on_sqlite.py b/multi_classification_on_stop_and_track_muons/deployment/run_inference_on_sqlite.py index 9a834dd..9f58b5f 100755 --- a/multi_classification_on_stop_and_track_muons/deployment/run_inference_on_sqlite.py +++ b/multi_classification_on_stop_and_track_muons/deployment/run_inference_on_sqlite.py @@ -1,38 +1,39 @@ """Running inference on GraphSAGE-cleaned pulses in IceCube-Upgrade.""" -import logging +import os from pytorch_lightning import Trainer from pytorch_lightning.callbacks import EarlyStopping - -# from pytorch_lightning.loggers import WandbLogger +from pytorch_lightning.loggers import WandbLogger import torch from torch.optim.adam import Adam +from torch.nn.functional import one_hot, softmax -from graphnet.components.loss_functions import ( - LogCoshLoss, - VonMisesFisher2DLoss, -) + +from graphnet.training.loss_functions import CrossEntropyLoss from graphnet.data.constants import FEATURES, TRUTH from graphnet.data.sqlite.sqlite_selection import ( + get_desired_event_numbers, get_equal_proportion_neutrino_indices, ) -from graphnet.models import Model +from graphnet.models import StandardModel from graphnet.models.detector.icecube import IceCubeDeepCore from graphnet.models.gnn import DynEdge from graphnet.models.graph_builders import KNNGraphBuilder -from graphnet.models.task.reconstruction import ( - ZenithReconstructionWithKappa, - AzimuthReconstructionWithKappa, -) -from graphnet.models.training.callbacks import ProgressBar, PiecewiseLinearLR -from graphnet.models.training.utils import ( +from graphnet.models.task.reconstruction import MulticlassClassificationTask +from graphnet.training.callbacks import ProgressBar, PiecewiseLinearLR +from graphnet.training.utils import ( get_predictions, - make_dataloader, # make_train_validation_dataloader + make_train_validation_dataloader, + make_dataloader, save_results, ) from graphnet.utilities.logging import get_logger +import numpy as np +import pandas as pd +import csv + # logger = get_logger(logging.DEBUG) # Configurations @@ -60,17 +61,17 @@ def main( # Configuration config = { "db": input_path, - "pulsemap": "InIceDSTPulses", + "pulsemap": "SplitInIcePulses", "batch_size": 512, "num_workers": 10, "accelerator": "gpu", "devices": [0], - "target": "zenith", - "n_epochs": 1, + "target": "pid", + "n_epochs": 10, "patience": 1, } archive = output_path - run_name = "dynedge_trained_on_leon_MC_{}_predict_azimuth".format( + run_name = "dynedge_trained_on_leon_RD_{}_predict_leon".format( config["target"] ) @@ -95,21 +96,16 @@ def main( ) gnn = DynEdge( nb_inputs=detector.nb_outputs, + global_pooling_schemes=["min", "max", "mean", "sum"], + ) + task = MulticlassClassificationTask( + #nb_inputs=3, + hidden_size=gnn.nb_outputs, + target_labels=config["target"], + loss_function=CrossEntropyLoss(), + transform_inference=lambda x: softmax(x,dim=-1), ) - if config["target"] == "zenith": - task = ZenithReconstructionWithKappa( - hidden_size=gnn.nb_outputs, - target_labels=config["target"], - loss_function=VonMisesFisher2DLoss(), - ) - elif config["target"] == "azimuth": - task = AzimuthReconstructionWithKappa( - hidden_size=gnn.nb_outputs, - target_labels=config["target"], - loss_function=VonMisesFisher2DLoss(), - ) - - model = Model( + model = StandardModel( detector=detector, gnn=gnn, tasks=[task], @@ -133,7 +129,7 @@ def main( max_epochs=config["n_epochs"], callbacks=callbacks, log_every_n_steps=1, - # logger=wandb_logger, + #logger=wandb_logger, ) # Load model @@ -144,21 +140,21 @@ def main( trainer, model, prediction_dataloader, - [config["target"] + "_pred", config["target"] + "_kappa_pred"], + [config["target"] + "_noise_pred", config["target"] + "_muon_pred", config["target"]+ "_neutrino_pred"], additional_attributes=[config["target"], "event_no"], ) - # save_results(config["db"], run_name, results, archive, model) - results.to_csv( - output_folder + "/{}_Leon_MC_results.csv".format(config["target"]) - ) + save_results(config["db"], run_name, results, archive, model) + #results.to_csv( + # output_folder + "/{}_Leon_RD_all.csv".format(config["target"]) + #) # Main function call if __name__ == "__main__": - input_db = "/groups/icecube/peter/storage/MoonPointing/data/Sschindler_data_L4/Merged_database/Merged_database.db" - output_folder = "/groups/icecube/peter/storage/MoonPointing/data/Sschindler_data_L4/Merged_database" - model_path = "/groups/icecube/peter/storage/MoonPointing/Models/Leon_Muon_data_MC/last_one_lvl3MC/dynedge_zenith_Leon_muon_data_MC/dynedge_zenith_Leon_muon_data_MC_state_dict.pth" + input_db = "/groups/icecube/petersen/GraphNetDatabaseRepository/Leon2022_DataAndMC_CSVandDB_StoppedMuons/last_one_lvl3MC.db" + output_folder = "/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/Inference" + model_path = "/groups/icecube/peter/storage/Multiclassification/Real/last_one_lvl3MC/dynedge_pid_Real_run_21.5_mill_equal_frac_second_/dynedge_pid_Real_run_21.5_mill_equal_frac_second__state_dict.pth" main(input_db, output_folder, model_path) diff --git a/multi_classification_on_stop_and_track_muons/development_do_not_commit/test.py b/multi_classification_on_stop_and_track_muons/development_do_not_commit/test.py new file mode 100644 index 0000000..1646ab6 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/development_do_not_commit/test.py @@ -0,0 +1,6 @@ +from torch.nn.functional import one_hot +import torch + +one_hot(torch.arange(0, 5) % 3, num_classes=5) + +test = 2 \ No newline at end of file diff --git a/multi_classification_on_stop_and_track_muons/development_do_not_commit/train_classification_model.py b/multi_classification_on_stop_and_track_muons/development_do_not_commit/train_classification_model.py new file mode 100644 index 0000000..081d4a4 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/development_do_not_commit/train_classification_model.py @@ -0,0 +1,223 @@ +"""Example of training Model.""" + +import os +from typing import cast, Dict, Any +import numpy as np + +from pytorch_lightning import Trainer +from pytorch_lightning.callbacks import EarlyStopping + +#from graphnet.data.dataloader import DataLoader +from pytorch_lightning.loggers import WandbLogger +import torch +from torch.optim.adam import Adam +from torch.nn.functional import softmax + +from graphnet.training.loss_functions import CrossEntropyLoss +from graphnet.data.constants import FEATURES, TRUTH +from graphnet.data.sqlite.sqlite_selection import ( + get_desired_event_numbers, +) +from graphnet.models import StandardModel +from graphnet.models.detector.icecube import IceCubeDeepCore +from graphnet.models.gnn import DynEdge +from graphnet.models.graph_builders import KNNGraphBuilder +from graphnet.models.task.classification import ClassificationTask +from graphnet.training.callbacks import ProgressBar, PiecewiseLinearLR +from graphnet.training.utils import ( + get_predictions, + make_train_validation_dataloader, + save_results, +) + +from graphnet.utilities.logging import get_logger +from graphnet.utilities.config import ( + DatasetConfig, + ModelConfig, + TrainingConfig, +) + +logger = get_logger() + +# Configurations +torch.multiprocessing.set_sharing_strategy("file_system") + +# Constants +features = FEATURES.DEEPCORE +truth = TRUTH.DEEPCORE[:-1] + +# Make sure W&B output directory exists +WANDB_DIR = "./wandb/" +os.makedirs(WANDB_DIR, exist_ok=True) + +# Initialise Weights & Biases (W&B) run +wandb_logger = WandbLogger( + project="example-script", + entity="graphnet-team", + save_dir=WANDB_DIR, + log_model=True, +) + + +def train(config: Dict[str, Any]) -> None: + """Train model with configuration given by `config`.""" + # Log configuration to W&B + wandb_logger.experiment.config.update(config) + + # Construct dataloaders + dataset_config = DatasetConfig.load( + "configs/datasets/classification_last_one_lvl3MC.yml" + ) + # dataloader_test, dataloader_valid, .. + dataloaders = DataLoader.from_dataset_config( + dataset_config, + **config.dataloader, + ) + + # Common variables + # train_selection = get_desired_event_numbers( + # database=cast(str, config["db"]), + # desired_size=100000, + # fraction_noise=float(1 / 3), + # fraction_muon=float(1 / 3), + # fraction_nu_e=float(1 / 9), + # fraction_nu_mu=float(1 / 9), + # fraction_nu_tau=float(1 / 9), + # ) + + logger.info(f"features: {features}") + logger.info(f"truth: {truth}") + + # ( + # training_dataloader, + # validation_dataloader, + # ) = make_train_validation_dataloader( + # cast(str, config["db"]), + # train_selection, + # cast(str, config["pulsemap"]), + # features, + # truth, + # batch_size=cast(int, config["batch_size"]), + # num_workers=cast(int, config["num_workers"]), + # ) + + # Building model + detector = IceCubeDeepCore( + graph_builder=KNNGraphBuilder(nb_nearest_neighbours=8), + ) + gnn = DynEdge( + nb_inputs=detector.nb_outputs, + global_pooling_schemes=["min", "max", "mean", "sum"], + ) + task = ClassificationTask( + nb_classes=len(np.unique(list(config["class_options"].values()))), + hidden_size=gnn.nb_outputs, + target_labels=config["target"], + loss_function=CrossEntropyLoss(options=config["class_options"]), + transform_inference=lambda x: softmax(x, dim=-1), + ) + model = StandardModel( + detector=detector, + gnn=gnn, + tasks=[task], + optimizer_class=Adam, + optimizer_kwargs={"lr": 1e-04, "eps": 1e-03}, + ) + + # Training model + callbacks = [ + EarlyStopping( + monitor="val_loss", + patience=config["patience"], + ), + ProgressBar(), + ] + + trainer = Trainer( + accelerator=config["accelerator"], + devices=config["devices"], + max_epochs=config["n_epochs"], + callbacks=callbacks, + log_every_n_steps=1, + logger=wandb_logger, + ) + + try: + trainer.fit(model, training_dataloader, validation_dataloader) + except KeyboardInterrupt: + logger.warning("[ctrl+c] Exiting gracefully.") + pass + + # Saving predictions to file + results = get_predictions( + trainer, + model, + validation_dataloader, + [ + cast(str, config["target"]) + "_noise_pred", + cast(str, config["target"]) + "_muon_pred", + cast(str, config["target"]) + "_neutrino_pred", + ], + additional_attributes=[cast(str, config["target"]), "event_no"], + ) + + save_results( + cast(str, config["db"]), + config["run_name"], + results, + config["archive"], + model, + ) + + +def main() -> None: + """Run example.""" + # transformation of target to a given class integer + class_options = { + 1: 0, + -1: 0, + 13: 1, + -13: 1, + 12: 2, + -12: 2, + 14: 2, + -14: 2, + 16: 2, + -16: 2, + } + + target = "pid" + + archive = "/groups/icecube/petersen/GraphNetDatabaseRepository/example_results/train_classification_model" + run_name = "dynedge_{}_example".format(target) + + # Configuration + #config = TrainingConfig( + # target="pid", + # early_stopping_patience=5, + # fit={"gpus": [0], "max_epochs": 5}, + # dataloader={"batch_size": 512, "num_workers": 10}, + #) + + # Configuration + config = { + "db": "/groups/icecube/petersen/GraphNetDatabaseRepository/Leon2022_DataAndMC_CSVandDB_StoppedMuons/last_one_lvl3MC.db", + "pulsemap": "SplitInIcePulses", + "batch_size": 512, + "num_workers": 10, + "accelerator": "gpu", + "devices": [1], + "target": target, + "class_options": class_options, + "n_epochs": 50, + "patience": 5, + "archive": archive, + "run_name": run_name, + "max_events": 50000, + "node_pooling": True, + } + train(config) + + +if __name__ == "__main__": + main() diff --git a/multi_classification_on_stop_and_track_muons/development_do_not_commit/unit_test.py b/multi_classification_on_stop_and_track_muons/development_do_not_commit/unit_test.py new file mode 100644 index 0000000..dd42f0b --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/development_do_not_commit/unit_test.py @@ -0,0 +1,118 @@ +from typing import cast +import numpy as np + +from graphnet.models.task.classification import ClassificationTask +from graphnet.training.loss_functions import NLLLoss +from graphnet.data.constants import FEATURES, TRUTH +from graphnet.training.utils import ( + make_train_validation_dataloader, +) +from graphnet.models.detector.icecube import IceCubeDeepCore +from graphnet.models.gnn import DynEdge +from graphnet.models.graph_builders import KNNGraphBuilder +from graphnet.data.sqlite.sqlite_selection import ( + get_desired_event_numbers, +) + +# Constants +features = FEATURES.DEEPCORE +truth = TRUTH.DEEPCORE[:-1] + +class_options = { + 1:0,-1:0, + 13:1,-13:1, + 12:2,-12:2,14:2,-14:2,16:2,-16:2 + } + +config = { + "db": "/groups/icecube/petersen/GraphNetDatabaseRepository/Leon_MC_data/last_one_lvl3MC.db", + "pulsemap": "SplitInIcePulses", + "batch_size": 512, + "num_workers": 10, + "target": "pid", + "classification": class_options, + } +import random +pid_sample = [1,-1,12,-12,13,-13,14,-14,16,-16] +pid_list = random.choices(pid_sample,k=500) +train_selection = pid_list + +# Common variables +train_selection = get_desired_event_numbers( + database = cast(str, config["db"]), + desired_size = 1000, + fraction_noise = 0.2, + fraction_muon = 0.2, + fraction_nu_e = 0.2, + fraction_nu_mu = 0.2, + fraction_nu_tau = 0.2, +) + + +(training_dataloader, validation_dataloader,) = make_train_validation_dataloader( + db = cast(str, config["db"]), + selection = train_selection, + pulsemaps= cast(str, config["pulsemap"]), + features = features, + truth = truth, + batch_size = cast(int, config["batch_size"]), + num_workers = cast(int, config["num_workers"]), +) + +# Building model +detector = IceCubeDeepCore( + graph_builder=KNNGraphBuilder(nb_nearest_neighbours=8), +) +gnn = DynEdge( + nb_inputs=detector.nb_outputs, + global_pooling_schemes=["min", "max", "mean", "sum"], +) +ClassificationTask( + nb_inputs=len(np.unique(list(class_options.values()))), + hidden_size = 128, + target_labels = config["target"], + loss_function = NLLLoss(options=class_options), +) +model = StandardModel( + detector=detector, + gnn=gnn, + tasks=[task], + optimizer_class=Adam, + optimizer_kwargs={"lr": 1e-03, "eps": 1e-03}, + scheduler_class=PiecewiseLinearLR, + scheduler_kwargs={ + "milestones": [ + 0, + len(training_dataloader) / 2, + len(training_dataloader) * cast(int, config["n_epochs"]), + ], + "factors": [1e-2, 1, 1e-02], + }, + scheduler_config={ + "interval": "step", + }, + ) + +# Training model +callbacks = [ + EarlyStopping( + monitor="val_loss", + patience=config["patience"], + ), + ProgressBar(), +] + +trainer = Trainer( + accelerator=config["accelerator"], + devices=config["devices"], + max_epochs=config["n_epochs"], + callbacks=callbacks, + log_every_n_steps=1, + logger=wandb_logger, +) + +try: + trainer.fit(model, training_dataloader, validation_dataloader) +except KeyboardInterrupt: + logger.warning("[ctrl+c] Exiting gracefully.") + pass \ No newline at end of file diff --git a/multi_classification_on_stop_and_track_muons/modelling/train_multiclass_classification_model.py b/multi_classification_on_stop_and_track_muons/modelling/train_classification_model.py similarity index 58% rename from multi_classification_on_stop_and_track_muons/modelling/train_multiclass_classification_model.py rename to multi_classification_on_stop_and_track_muons/modelling/train_classification_model.py index 00d6ace..67738ae 100644 --- a/multi_classification_on_stop_and_track_muons/modelling/train_multiclass_classification_model.py +++ b/multi_classification_on_stop_and_track_muons/modelling/train_classification_model.py @@ -1,43 +1,40 @@ -from distutils.log import debug -import logging +"""Example of training Model.""" + import os +from typing import cast, Dict, Any +import numpy as np from pytorch_lightning import Trainer from pytorch_lightning.callbacks import EarlyStopping -from pytorch_lightning.loggers import WandbLogger +from pytorch_lightning.loggers import WandbLogger import torch from torch.optim.adam import Adam -from torch.nn.functional import one_hot +from torch.nn.functional import softmax from graphnet.training.loss_functions import CrossEntropyLoss from graphnet.data.constants import FEATURES, TRUTH from graphnet.data.sqlite.sqlite_selection import ( get_desired_event_numbers, - get_equal_proportion_neutrino_indices, ) from graphnet.models import StandardModel from graphnet.models.detector.icecube import IceCubeDeepCore from graphnet.models.gnn import DynEdge from graphnet.models.graph_builders import KNNGraphBuilder -from graphnet.models.task.reconstruction import MulticlassClassificationTask -from graphnet.training.callbacks import ProgressBar, PiecewiseLinearLR +from graphnet.models.task.classification import ClassificationTask +from graphnet.training.callbacks import ProgressBar from graphnet.training.utils import ( get_predictions, make_train_validation_dataloader, save_results, ) -from graphnet.utilities.logging import get_logger -import numpy as np +from graphnet.utilities.logging import get_logger -def multiclass_transform(target, num_classes=3): - pid_transform = {1:0,12:2,13:1,14:2,16:2} - return one_hot(torch.tensor([pid_transform[np.abs(value)] for value in target]), num_classes) +import ast +import argparse logger = get_logger() -# set increased verbose information when debugging. -logger.setLevel(logging.DEBUG) # Configurations torch.multiprocessing.set_sharing_strategy("file_system") @@ -52,14 +49,14 @@ def multiclass_transform(target, num_classes=3): # Initialise Weights & Biases (W&B) run wandb_logger = WandbLogger( - project="example-script", + project="Classification", entity="graphnet-team", save_dir=WANDB_DIR, log_model=True, ) import argparse - +print('WandB initialized') parser = argparse.ArgumentParser( description="plotting the predicted zenith and azimuth vs truth." @@ -71,7 +68,6 @@ def multiclass_transform(target, num_classes=3): type=str, help=" path(s) to database [list]", default="/groups/icecube/petersen/GraphNetDatabaseRepository/Leon_MC_data/last_one_lvl3MC.db", - # required=True, ) parser.add_argument( "-o", @@ -79,17 +75,23 @@ def multiclass_transform(target, num_classes=3): dest="output", type=str, help=" the output path [str]", - default="/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/trained_models/" , - # required=True, + default="/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/Datasets/last_one_lvl3MC.db" , ) parser.add_argument( - "-p", - "--pulsemap", - dest="pulsemap", + "-c", + "--class_options", + dest="class_options", type=str, - help=" the pulsemap to use. [str]", - default="SplitInIcePulses", - # required=True, + help="class options as a dict conversion. [str]", + default='{1: 0, -1: 0, 13: 1, -13: 1, 12: 2, -12: 2, 14: 2, -14: 2, 16: 2, -16: 2}', +) +parser.add_argument( + "-t", + "--target", + dest="target", + type=str, + help="target for training on. [str]", + default='pid', ) parser.add_argument( "-n", @@ -97,15 +99,31 @@ def multiclass_transform(target, num_classes=3): dest="event_numbers", type=int, help="the number of muons to train on; if too high will take all available. [int]", - default=100, + default=5000, +) +parser.add_argument( + "-p", + "--pulsemap", + dest="pulsemap", + type=str, + help=" the pulsemap to use. [str]", + default="SplitInIcePulses", +) +parser.add_argument( + "-a", + "--accelerator", + dest="accelerator", + type=str, + help=" the name for the model. [str]", + default="gpu" ) parser.add_argument( "-g", - "--gpu", - dest="gpu", + "--gpu_number", + dest="gpu_number", type=int, help=" the name for the model. [str]", - default=0# required=True, + default=0 ) parser.add_argument( "-b", @@ -113,91 +131,74 @@ def multiclass_transform(target, num_classes=3): dest="batch_size", type=int, help=" the name for the model. [str]", - default=1024, - # required=True, + default=512, ) parser.add_argument( "-e", "--epochs", dest="epochs", type=int, - help=" the name for the model. [str]", + help=" number of epochs. [int]", + default=10, +) +parser.add_argument( + "-s", + "--patience", + dest="patience", + type=int, + help=" number of epochs after early stopping is triggered. [int]", default=10, - # required=True, ) parser.add_argument( "-w", "--workers", dest="workers", type=int, - help=" the number of cpu's to use. [str]", - default=1, - # required=True, + help=" the number of cpu's to use. [int]", + default=10, ) parser.add_argument( "-r", "--run_name", dest="run_name", type=str, - help="the name for the model. [str]", - default="debug" - # required=True, -) -parser.add_argument( - "-a", - "--accelerator", - dest="accelerator", - type=str, - help="the name for the model. [str]", - default="cpu" - # required=True, + help=" the name for the model. [str]", + default="debug_leonMC_5k" ) -args = parser.parse_args() - -# Main function definition -def main(): - logger.info(f"features: {features}") - logger.info(f"truth: {truth}") - - # Configuration - config = { - "db": args.path_to_db, - "pulsemap": args.pulsemap, - "batch_size": args.batch_size, - "num_workers": args.workers, - "accelerator": args.accelerator, - "devices": 1,#[args.gpu], - "target": "pid", - "n_epochs": args.epochs, - "patience": 5, - } - archive = args.output - run_name = "dynedge_{}_".format(config["target"]) + args.run_name +args = parser.parse_args() +def train(config: Dict[str, Any]) -> None: + """Train model with configuration given by `config`.""" # Log configuration to W&B wandb_logger.experiment.config.update(config) - # Common variables - #train_selection, _ = get_equal_proportion_neutrino_indices(config["db"]) - #train_selection = train_selection[0:50000] + # Common variables; equal distribution of pid. train_selection = get_desired_event_numbers( - config["db"], desired_size=args.event_numbers, fraction_muon=0.2, fraction_noise=0.2,fraction_nu_e=0.2,fraction_nu_tau=0.2,fraction_nu_mu=0.2 - ) - + database=cast(str, config["db"]), + desired_size=cast(int, config["event_numbers"]), + fraction_noise=float(1 / 3), + fraction_muon=float(1 / 3), + fraction_nu_e=float(1 / 9), + fraction_nu_mu=float(1 / 9), + fraction_nu_tau=float(1 / 9), + ) + + logger.info(f"features: {features}") + logger.info(f"truth: {truth}") ( training_dataloader, validation_dataloader, ) = make_train_validation_dataloader( - config["db"], + cast(str, config["db"]), train_selection, - config["pulsemap"], + cast(str, config["pulsemap"]), features, truth, - batch_size=config["batch_size"], - num_workers=config["num_workers"], + batch_size=cast(int, config["batch_size"]), + num_workers=cast(int, config["num_workers"]), ) # Building model @@ -208,30 +209,19 @@ def main(): nb_inputs=detector.nb_outputs, global_pooling_schemes=["min", "max", "mean", "sum"], ) - task = MulticlassClassificationTask( - nb_classes=3, + task = ClassificationTask( + nb_classes=len(np.unique(list(config["class_options"].values()))), hidden_size=gnn.nb_outputs, target_labels=config["target"], - loss_function=CrossEntropyLoss(options=({1:0,-1:0,12:2,-12:2,13:1,-13:1,14:2,-14:2,16:2,-16:2})), + loss_function=CrossEntropyLoss(options=config["class_options"]), + transform_inference=lambda x: softmax(x, dim=-1), ) model = StandardModel( detector=detector, gnn=gnn, tasks=[task], optimizer_class=Adam, - optimizer_kwargs={"lr": 1e-03, "eps": 1e-03}, - scheduler_class=PiecewiseLinearLR, - scheduler_kwargs={ - "milestones": [ - 0, - len(training_dataloader) / 2, - len(training_dataloader) * config["n_epochs"], - ], - "factors": [1e-2, 1, 1e-02], - }, - scheduler_config={ - "interval": "step", - }, + optimizer_kwargs={"lr": 1e-04, "eps": 1e-03}, ) # Training model @@ -249,7 +239,7 @@ def main(): max_epochs=config["n_epochs"], callbacks=callbacks, log_every_n_steps=1, - #logger=wandb_logger, + logger=wandb_logger, ) try: @@ -263,13 +253,57 @@ def main(): trainer, model, validation_dataloader, - [config["target"] + "_noise_pred", config["target"] + "_muon_pred", config["target"]+ "_neutrino_pred"], - additional_attributes=[config["target"], "event_no"], + [ + cast(str, config["target"]) + "_noise_pred", + cast(str, config["target"]) + "_muon_pred", + cast(str, config["target"]) + "_neutrino_pred", + ], + additional_attributes=[cast(str, config["target"]), "event_no"], + ) + + save_results( + cast(str, config["db"]), + config["run_name"], + results, + config["archive"], + model, ) - save_results(config["db"], run_name, results, archive, model) + +def main() -> None: + """Run example.""" + # transformation of target to a given class integer + + target = args.target + run_name = "dynedge_{}_{}".format(target, args.run_name) + + if "cpu" in args.accelerator: + device = 1 + elif "gpu" in args.accelerator: + device = [args.gpu_number] + else: + print('Use correct accelerator; "cpu" or "gpu"') + exit + + # Configuration + config = { + "db": args.path_to_db, + "pulsemap": args.pulsemap, + "batch_size": args.batch_size, + "num_workers": args.workers, + "accelerator": args.accelerator, + "devices": device, + "target": target, + "event_numbers": args.event_numbers, + "class_options": ast.literal_eval(args.class_options), + "n_epochs": args.epochs, + "patience": args.patience, + "archive": args.output, + "run_name": run_name, + } + + train(config) -# Main function call if __name__ == "__main__": main() diff --git a/multi_classification_on_stop_and_track_muons/modelling/train_classification_noise_mu_nu_LeonMC.sh b/multi_classification_on_stop_and_track_muons/modelling/train_classification_noise_mu_nu_LeonMC.sh new file mode 100755 index 0000000..704efa8 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/modelling/train_classification_noise_mu_nu_LeonMC.sh @@ -0,0 +1,54 @@ +#!/bin/bash +bash_directory=$(dirname -- "$(readlink -f "${BASH_SOURCE}")") # !do not alter! + +# Warning!: on hep04; Run gpustat or similar before executing this script and make sure no process is running on the selected gpu. +# Description: training the reconstruction of individual azimuth and zenith direction based on a sqlite3 database. +# This bash script only works with gpu; + +database_directory=/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/Datasets/last_one_lvl3MC.db +output_directory=/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/trained_models/ + +pulsemap=SRTInIcePulses + + +accelerator="cpu" # "cpu" or "gpu"; if set to cpu, gpu_number has no effect. +gpu_number=1 # the gpu to use [0,1]; +batch_size=1024 +epochs=100 +patience=10 +workers=10 +event_numbers=5000 #22000000 # if number goes over available events; use all events +run_name=LeonMC_data_5k #22m + +class_options="{1:0,-1:0,13:1,-13:1,12:2,-12:2,14:2,-14:2,16:2,-16:2}" +target='pid' + +# save the report file to +report_name=${run_name} # overwrites old, thus only keeps the one with error +report_directory=/groups/icecube/${USER}/storage/nohup_reports/ + +# if directories does not exist, create them. +mkdir -p ${output_directory}; +mkdir -p ${report_directory}; + +# save the report file to +report_location=${report_directory}${report_name}.out +echo "report location: " ${report_location} ".out" +echo "error report location: " ${report_directory}${report_name}".err" + +python ${bash_directory}/train_classification_model.py \ +-db ${database_directory} \ +-o ${output_directory} \ +-c ${class_options} \ +-t ${target} \ +-n ${event_numbers} \ +-p ${pulsemap} \ +-a ${accelerator} \ +-g ${gpu_number} \ +-b ${batch_size} \ +-e ${epochs} \ +-s ${patience} \ +-w ${workers} \ +-r ${run_name} \ +> ${report_location} \ +2> ${report_directory}${report_name}.err & diff --git a/multi_classification_on_stop_and_track_muons/modelling/pipeline_training_LeonMC_data.sh b/multi_classification_on_stop_and_track_muons/modelling/train_classification_stopped_through_LeonMC.sh similarity index 59% rename from multi_classification_on_stop_and_track_muons/modelling/pipeline_training_LeonMC_data.sh rename to multi_classification_on_stop_and_track_muons/modelling/train_classification_stopped_through_LeonMC.sh index 0ed3246..d0515e1 100755 --- a/multi_classification_on_stop_and_track_muons/modelling/pipeline_training_LeonMC_data.sh +++ b/multi_classification_on_stop_and_track_muons/modelling/train_classification_stopped_through_LeonMC.sh @@ -5,17 +5,23 @@ bash_directory=$(dirname -- "$(readlink -f "${BASH_SOURCE}")") # !do not alter! # Description: training the reconstruction of individual azimuth and zenith direction based on a sqlite3 database. # This bash script only works with gpu; -database_directory=/groups/icecube/petersen/GraphNetDatabaseRepository/Leon_MC_data/last_one_lvl3MC.db -output_directory=/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/trained_models_test/ +database_directory=/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/Datasets/last_one_lvl3MC.db +output_directory=/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/trained_models/ -pulsemap=SplitInIcePulses +pulsemap=SRTInIcePulses -gpu=1 # the gpu to use [0,1] + +accelerator="cpu" # "cpu" or "gpu"; if set to cpu, gpu_number has no effect. +gpu_number=1 # the gpu to use [0,1]; batch_size=1024 epochs=100 -workers=20 -event_numbers=5000 # if number goes over available events; use all events -run_name=LeonMC_data +patience=10 +workers=10 +event_numbers=5000 #22000000 # if number goes over available events; use all events +run_name=LeonMC_data_5k #22m + +class_options="{0:0,1:1}" +target='stopped_muon' # save the report file to report_name=${run_name} # overwrites old, thus only keeps the one with error @@ -23,19 +29,25 @@ report_directory=/groups/icecube/${USER}/storage/nohup_reports/ # if directories does not exist, create them. mkdir -p ${output_directory}; -mkdir -p ${report_directory}; +mkdir -p ${report_directory}; # save the report file to report_location=${report_directory}${report_name}.out +echo "report location: " ${report_location} ".out" +echo "error report location: " ${report_directory}${report_name}".err" -python ${bash_directory}/train_multiclass_classification_model.py \ +python ${bash_directory}/train_classification_model.py \ -db ${database_directory} \ -o ${output_directory} \ +-c ${class_options} \ +-t ${target} \ -n ${event_numbers} \ -p ${pulsemap} \ --g ${gpu} \ +-a ${accelerator} \ +-g ${gpu_number} \ -b ${batch_size} \ -e ${epochs} \ +-s ${patience} \ -w ${workers} \ -r ${run_name} \ > ${report_location} \ diff --git a/multi_classification_on_stop_and_track_muons/modelling/train_direction_reco.py b/multi_classification_on_stop_and_track_muons/modelling/train_direction_reco.py deleted file mode 100644 index 1e66614..0000000 --- a/multi_classification_on_stop_and_track_muons/modelling/train_direction_reco.py +++ /dev/null @@ -1,189 +0,0 @@ -import os -from pytorch_lightning import Trainer -from pytorch_lightning.callbacks import EarlyStopping -from pytorch_lightning.loggers import WandbLogger -import torch -from torch.optim.adam import Adam - -from graphnet.components.loss_functions import VonMisesFisher2DLoss -from graphnet.data.constants import FEATURES, TRUTH -from graphnet.data.sqlite.sqlite_selection import ( - get_equal_proportion_neutrino_indices, - get_desired_event_numbers, -) -from graphnet.models import Model -from graphnet.models.detector.icecube import IceCubeDeepCore -from graphnet.models.gnn.dynedge import DynEdge, DOMCoarsenedDynEdge -from graphnet.models.graph_builders import KNNGraphBuilder -from graphnet.models.task.reconstruction import ( - ZenithReconstructionWithKappa, - AzimuthReconstructionWithKappa, -) -from graphnet.models.training.callbacks import ProgressBar, PiecewiseLinearLR -from graphnet.models.training.utils import ( - get_predictions, - make_train_validation_dataloader, - save_results, -) -from graphnet.utilities.logging import get_logger - -# logger = get_logger() - -# Configurations -torch.multiprocessing.set_sharing_strategy("file_system") - -# Constants -features = FEATURES.DEEPCORE -truth = TRUTH.DEEPCORE[:-1] - -# Make sure W&B output directory exists -WANDB_DIR = "./wandb/" -os.makedirs(WANDB_DIR, exist_ok=True) - -# Initialise Weights & Biases (W&B) run -# wandb_logger = WandbLogger( -# project="example-script", -# entity="graphnet-team", -# save_dir=WANDB_DIR, -# log_model=True, -# ) -# - - -def train(config): - # Log configuration to W&B - # wandb_logger.experiment.config.update(config) - - # Common variables - # train_selection, _ = get_equal_proportion_neutrino_indices(config["db"]) - # train_selection = train_selection[0:]#config["max_events"]] - train_selection = get_desired_event_numbers( - config["db"], desired_size=50000, fraction_muon=1 - ) - # logger.info(f"features: {features}") - # logger.info(f"truth: {truth}") - - ( - training_dataloader, - validation_dataloader, - ) = make_train_validation_dataloader( - config["db"], - train_selection, - config["pulsemap"], - features, - truth, - batch_size=config["batch_size"], - num_workers=config["num_workers"], - ) - - # Building model - detector = IceCubeDeepCore( - graph_builder=KNNGraphBuilder(nb_nearest_neighbours=8), - ) - if config["node_pooling"]: - gnn = DOMCoarsenedDynEdge( - nb_inputs=detector.nb_outputs, - ) - else: - gnn = DynEdge( - nb_inputs=detector.nb_outputs, - ) - if config["target"] == "zenith": - task = ZenithReconstructionWithKappa( - hidden_size=gnn.nb_outputs, - target_labels=config["target"], - loss_function=VonMisesFisher2DLoss(), - ) - elif config["target"] == "azimuth": - task = AzimuthReconstructionWithKappa( - hidden_size=gnn.nb_outputs, - target_labels=config["target"], - loss_function=VonMisesFisher2DLoss(), - ) - - model = Model( - detector=detector, - gnn=gnn, - tasks=[task], - optimizer_class=Adam, - optimizer_kwargs={"lr": 1e-03, "eps": 1e-03}, - scheduler_class=PiecewiseLinearLR, - scheduler_kwargs={ - "milestones": [ - 0, - len(training_dataloader) / 2, - len(training_dataloader) * config["n_epochs"], - ], - "factors": [1e-2, 1, 1e-02], - }, - scheduler_config={ - "interval": "step", - }, - ) - - # Training model - callbacks = [ - EarlyStopping( - monitor="val_loss", - patience=config["patience"], - ), - ProgressBar(), - ] - - trainer = Trainer( - accelerator=config["accelerator"], - devices=config["devices"], - max_epochs=config["n_epochs"], - callbacks=callbacks, - log_every_n_steps=1, - # logger=wandb_logger, - ) - - try: - trainer.fit(model, training_dataloader, validation_dataloader) - except KeyboardInterrupt: - # logger.warning("[ctrl+c] Exiting gracefully.") - pass - - # Saving predictions to file - results = get_predictions( - trainer, - model, - validation_dataloader, - [config["target"] + "_pred", config["target"] + "_kappa_pred"], - additional_attributes=[config["target"], "event_no"], - ) - - save_results( - config["db"], config["run_name"], results, config["archive"], model - ) - - -# Main function definition -def main(): - for target in ["zenith", "azimuth"]: - archive = "/groups/icecube/qgf305/storage/MoonPointing/Models/MC/GenieL2_Muon_Leon" - run_name = "dynedge_{}_GenieL2_Muon_Leon".format(target) - - # Configuration - config = { - "db": "/groups/icecube/leonbozi/work2/data/lvl3_dbs/last_one_lvl3MC/data/last_one_lvl3MC.db", - "pulsemap": "SRTInIcePulses", - "batch_size": 1024, - "num_workers": 10, - "accelerator": "gpu", - "devices": [0], - "target": target, - "n_epochs": 20, - "patience": 5, - "archive": archive, - "run_name": run_name, - "max_events": 500000, - "node_pooling": False, - } - train(config) - - -# Main function call -if __name__ == "__main__": - main() diff --git a/multi_classification_on_stop_and_track_muons/modelling/train_reconstruction_individual_azimuth_zenith.py b/multi_classification_on_stop_and_track_muons/modelling/train_reconstruction_individual_azimuth_zenith.py deleted file mode 100644 index 51379ff..0000000 --- a/multi_classification_on_stop_and_track_muons/modelling/train_reconstruction_individual_azimuth_zenith.py +++ /dev/null @@ -1,268 +0,0 @@ -import os -from pytorch_lightning import Trainer -from pytorch_lightning.callbacks import EarlyStopping -from pytorch_lightning.loggers import WandbLogger -import torch -from torch.optim.adam import Adam - -from graphnet.training.loss_functions import VonMisesFisher2DLoss -from graphnet.data.constants import FEATURES, TRUTH -from graphnet.data.sqlite.sqlite_selection import ( - get_equal_proportion_neutrino_indices, - get_desired_event_numbers, -) -from graphnet.models import Model -from graphnet.models.detector.icecube import IceCubeDeepCore -from graphnet.models.gnn.dynedge import DynEdge -from graphnet.models.graph_builders import KNNGraphBuilder -from graphnet.models.task.reconstruction import ( - ZenithReconstructionWithKappa, - AzimuthReconstructionWithKappa, -) -from graphnet.training.callbacks import ProgressBar, PiecewiseLinearLR -from graphnet.training.utils import ( - get_predictions, - make_train_validation_dataloader, - save_results, -) -from graphnet.utilities.logging import get_logger - -import argparse - - -parser = argparse.ArgumentParser( - description="plotting the predicted zenith and azimuth vs truth." -) -parser.add_argument( - "-db", - "--database", - dest="path_to_db", - type=str, - help=" path(s) to database [list]", - required=True, -) -parser.add_argument( - "-o", - "--output", - dest="output", - type=str, - help=" the output path [str]", - required=True, -) -parser.add_argument( - "-n", - "--event_number", - dest="number", - type=int, - help="the number of muons to train on; if too high will take all available. [int]", - default=50000, -) -parser.add_argument( - "-p", - "--pulsemap", - dest="pulsemap", - type=str, - help=" the pulsemap to use. [str]", - required=True, -) -parser.add_argument( - "-g", - "--gpu", - dest="gpu", - type=int, - help=" the name for the model. [str]", - required=True, -) -parser.add_argument( - "-b", - "--batch_size", - dest="batch_size", - type=int, - help=" the name for the model. [str]", - required=True, -) -parser.add_argument( - "-e", - "--epochs", - dest="epochs", - type=int, - help=" the name for the model. [str]", - required=True, -) -parser.add_argument( - "-w", - "--workers", - dest="workers", - type=int, - help=" the number of cpu's to use. [str]", - required=True, -) -parser.add_argument( - "-r", - "--run_name", - dest="run_name", - type=str, - help=" the name for the model. [str]", - required=True, -) - -args = parser.parse_args() - - - -# logger = get_logger() - -# Configurations -torch.multiprocessing.set_sharing_strategy("file_system") - -# Constants -features = FEATURES.DEEPCORE -truth = TRUTH.DEEPCORE[:-1] - -# Make sure W&B output directory exists -WANDB_DIR = "./wandb/" -os.makedirs(WANDB_DIR, exist_ok=True) - -# Initialise Weights & Biases (W&B) run -# wandb_logger = WandbLogger( -# project="example-script", -# entity="graphnet-team", -# save_dir=WANDB_DIR, -# log_model=True, -# ) -# - - -def train(config): - # Log configuration to W&B - # wandb_logger.experiment.config.update(config) - - # Common variables - #train_selection, _ = get_equal_proportion_neutrino_indices(config["db"]) - # train_selection = train_selection[0:]#config["max_events"]] - train_selection = get_desired_event_numbers( - config["db"], desired_size=args.number, fraction_nu_mu=1 - ) - # logger.info(f"features: {features}") - # logger.info(f"truth: {truth}") - - ( - training_dataloader, - validation_dataloader, - ) = make_train_validation_dataloader( - config["db"], - train_selection, - config["pulsemap"], - features, - truth, - batch_size=config["batch_size"], - num_workers=config["num_workers"], - ) - - # Building model - detector = IceCubeDeepCore( - graph_builder=KNNGraphBuilder(nb_nearest_neighbours=8), - ) - gnn = DynEdge( - nb_inputs=detector.nb_outputs, - ) - if config["target"] == "zenith": - task = ZenithReconstructionWithKappa( - hidden_size=gnn.nb_outputs, - target_labels=config["target"], - loss_function=VonMisesFisher2DLoss(), - ) - elif config["target"] == "azimuth": - task = AzimuthReconstructionWithKappa( - hidden_size=gnn.nb_outputs, - target_labels=config["target"], - loss_function=VonMisesFisher2DLoss(), - ) - - model = Model( - detector=detector, - gnn=gnn, - tasks=[task], - optimizer_class=Adam, - optimizer_kwargs={"lr": 1e-03, "eps": 1e-03}, - scheduler_class=PiecewiseLinearLR, - scheduler_kwargs={ - "milestones": [ - 0, - len(training_dataloader) / 2, - len(training_dataloader) * config["n_epochs"], - ], - "factors": [1e-2, 1, 1e-02], - }, - scheduler_config={ - "interval": "step", - }, - ) - - # Training model - callbacks = [ - EarlyStopping( - monitor="val_loss", - patience=config["patience"], - ), - ProgressBar(), - ] - - trainer = Trainer( - accelerator=config["accelerator"], - devices=config["devices"], - max_epochs=config["n_epochs"], - callbacks=callbacks, - log_every_n_steps=1, - # logger=wandb_logger, - ) - print("model: ", model) - print("training dataloader: ", training_dataloader) - print("validation dataloader: ", validation_dataloader) - try: - trainer.fit(model, training_dataloader, validation_dataloader) - except KeyboardInterrupt: - # logger.warning("[ctrl+c] Exiting gracefully.") - pass - - # Saving predictions to file - results = get_predictions( - trainer, - model, - validation_dataloader, - [config["target"] + "_pred", config["target"] + "_kappa_pred"], - additional_attributes=[config["target"], "event_no"], - ) - - save_results( - config["db"], config["run_name"], results, config["archive"], model - ) - - -# Main function definition -def main(): - for target in ["zenith", "azimuth"]: - run_name = "dynedge_{}_".format(target) + args.run_name - - # Configuration - config = { - "db": args.path_to_db, - "pulsemap": args.pulsemap, - "batch_size": args.batch_size, - "num_workers": args.workers, - "accelerator": "gpu", - "devices": [args.gpu], - "target": target, - "n_epochs": args.epochs, - "patience": 5, - "archive": args.output, - "run_name": run_name, - "max_events": 500000, - "node_pooling": False, - } - train(config) - - -# Main function call -if __name__ == "__main__": - main() diff --git a/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_cm.py b/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_cm.py new file mode 100644 index 0000000..bae4c13 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_cm.py @@ -0,0 +1,112 @@ +import sqlite3 as sql + +import numpy as np +import pandas as pd +from pandas import cut, read_sql +import pickle as pkl +from random import choices +from sklearn import metrics +import matplotlib.pyplot as plt +import matplotlib.colors as colors + +indir = "/groups/icecube/peter/storage/Multiclassification/Real/last_one_lvl3MC/dynedge_pid_Real_run_21.5_mill_equal_frac_second_/results.csv" +outdir = "/groups/icecube/qgf305/workspace/analyses/multi_classification_on_stop_and_track_muons/plotting/distributions/test_plot" + +results = pd.read_csv(indir).sort_values('event_no').reset_index(drop = True) + +#print(results.head(10)) +#Noise = 0, muon =1, Neutrino=2 +pid_transform = {1:0,12:2,13:1,14:2,16:2} + +predictions = [] +truth = [] + +noise = 0 +muons = 0 +neutrinos = 0 + +number = len(results) + +for i in range(number):# range(len(results)): + noise_pred = results['pid_noise_pred'].values[i] + muon_pred = results['pid_muon_pred'].values[i] + neutrino_pred = results['pid_neutrino_pred'].values[i] + predictions.append(np.argmax([noise_pred,muon_pred,neutrino_pred])) + + truth.append(pid_transform[abs(results['pid'].values[i])]) + if pid_transform[abs(results['pid'].values[i])] == 0: + noise+=1 + if pid_transform[abs(results['pid'].values[i])] == 1: + muons+=1 + if pid_transform[abs(results['pid'].values[i])] == 2: + neutrinos+=1 + +print(f'there are {noise} noise, {muons} muons, and {neutrinos} neutrinos') + +confusion_matrix = metrics.confusion_matrix(truth, predictions) +cm_display = metrics.ConfusionMatrixDisplay(confusion_matrix = confusion_matrix, display_labels = ['Noise','Muons','Neutrinos']) +cm_display.plot() +plt.show() +plt.savefig(outdir + 'Confusion_matrix.png') + +bins = 50 + +fig, axs = plt.subplots(3,1,sharex=False,figsize=(8, 16)) + +mask_noise = [True if truth[i] ==0 else False for i in range(len(truth))] +mask_muon = [True if truth[i] ==1 else False for i in range(len(truth))] +mask_neutrino = [True if truth[i] ==2 else False for i in range(len(truth))] + +cd1 = axs[0].hist2d(results['pid_noise_pred'].values[:number][mask_noise],results['pid_neutrino_pred'].values[:number][mask_noise],bins,norm=colors.LogNorm()) +cd2 = axs[1].hist2d(results['pid_noise_pred'].values[:number][mask_muon],results['pid_neutrino_pred'].values[:number][mask_muon],bins,norm=colors.LogNorm()) +cd3 = axs[2].hist2d(results['pid_noise_pred'].values[:number][mask_neutrino],results['pid_neutrino_pred'].values[:number][mask_neutrino],bins,norm=colors.LogNorm()) + + +axs[0].set_ylabel('Noise probability') +axs[1].set_ylabel('Muon probability') +axs[2].set_ylabel('Neutrino probability') + +axs[0].set_xlabel('Noise probability') +axs[1].set_xlabel('Muon probability') +axs[2].set_xlabel('Neutrino probability') + +axs[0].set_title('Noise') +axs[1].set_title('Muons') +axs[2].set_title('Neutrinos') + +fig.colorbar(cd1[3], ax=axs[0]) +fig.colorbar(cd2[3], ax=axs[1]) +fig.colorbar(cd3[3], ax=axs[2]) + + + +fig.tight_layout() + +fig.savefig(outdir + 'prob_heatmaps.png') + + +fpr_neutrino, tpr_neutrino , _ = metrics.roc_curve(truth,results['pid_neutrino_pred'].values,pos_label=2) +fpr_muon, tpr_muon , _ = metrics.roc_curve(truth,results['pid_muon_pred'].values,pos_label=1) +fpr_noise, tpr_noise , _ = metrics.roc_curve(truth,results['pid_noise_pred'].values,pos_label=0) + +auc_neutrino = metrics.auc(fpr_neutrino, tpr_neutrino) +auc_muon = metrics.auc(fpr_muon, tpr_muon) +auc_noise = metrics.auc(fpr_noise, tpr_noise) + + +fig, axs = plt.subplots(figsize=(16, 8)) + +axs.plot(fpr_neutrino, tpr_neutrino, label=f'Neutrino Auc={auc_neutrino}') +axs.plot(fpr_muon, tpr_muon, label=f'Muon Auc={auc_muon}') +axs.plot(fpr_noise, tpr_noise, label=f'Noise Auc={auc_noise}') + +axs.set_xlabel('FPR') +axs.set_ylabel('TPR') +axs.set_title('ROC curves') + + +fig.tight_layout() + +fig.savefig(outdir + 'Roc_curves.png') + + diff --git a/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_roc.ipynb b/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_roc.ipynb new file mode 100644 index 0000000..697c6ea --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_roc.ipynb @@ -0,0 +1,663 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/groups/icecube/qgf305/anaconda3/envs/graphnet/lib/python3.8/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import sqlite3 as sql\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "from pandas import cut, read_sql\n", + "import pickle as pkl\n", + "from random import choices\n", + "from sklearn import metrics\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors as colors\n", + "from numpy import interp\n", + "\n", + "from torch.nn.functional import one_hot\n", + "import torch\n", + "from sklearn.metrics import auc\n", + "from sklearn.metrics import roc_curve, auc\n", + "from sklearn.multiclass import OneVsRestClassifier\n", + "from sklearn.metrics import roc_auc_score\n", + "from sklearn.preprocessing import label_binarize" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def get_roc_and_auc(pred, target, labels=None):\n", + " if labels==None:\n", + " fpr, tpr, _ = roc_curve(pred, target)\n", + " else: \n", + " fpr, tpr, _ = roc_curve(pred, target, pos_label=labels)\n", + " auc_score = auc(fpr,tpr)\n", + " return fpr,tpr,auc_score \n", + "\n", + "def plot_roc(data, target):#, save_dir, save_as_csv = False):\n", + " fpr, tpr, auc = get_roc_and_auc(data, target)\n", + " \n", + " width = 3.176*2\n", + " height = 2.388*2\n", + " fig = plt.figure(figsize = (width,height))\n", + " plt.plot(fpr,tpr, label ='%s'%(round(auc,3)))\n", + " plt.legend()\n", + " plt.title('feature selection: 10^6')\n", + " plt.ylabel('True Positive Rate', fontsize = 12)\n", + " plt.xlabel('False Positive Rate', fontsize = 12)\n", + " return" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "pids = [1,12,13]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "indir = \"/groups/icecube/peter/storage/Multiclassification/Real/last_one_lvl3MC/dynedge_pid_Real_run_21.5_mill_equal_frac_/results_first.csv\"\n", + "results = pd.read_csv(indir, index_col=[0]).sort_values('event_no').reset_index()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-16. -14. -12. -1. 12. 13. 14. 16.]\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
indexpid_noise_predpid_muon_predpid_neutrino_predpidevent_no
051206860.9985000.0000700.001430-1.00.0
142425880.9901030.0012910.008606-1.04.0
217719110.9541510.0022270.043622-1.09.0
355210110.9800690.0004060.019525-1.027.0
428402541.0000000.0000000.000000-1.043.0
.....................
742499558502061.0000000.0000000.000000-1.098614183.0
742499617028961.0000000.0000000.000000-1.098614190.0
742499724388541.0000000.0000000.000000-1.098614194.0
742499822838180.9996850.0000120.000303-1.098614197.0
742499935828761.0000000.0000000.000000-1.098614207.0
\n", + "

7425000 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " index pid_noise_pred pid_muon_pred pid_neutrino_pred pid \\\n", + "0 5120686 0.998500 0.000070 0.001430 -1.0 \n", + "1 4242588 0.990103 0.001291 0.008606 -1.0 \n", + "2 1771911 0.954151 0.002227 0.043622 -1.0 \n", + "3 5521011 0.980069 0.000406 0.019525 -1.0 \n", + "4 2840254 1.000000 0.000000 0.000000 -1.0 \n", + "... ... ... ... ... ... \n", + "7424995 5850206 1.000000 0.000000 0.000000 -1.0 \n", + "7424996 1702896 1.000000 0.000000 0.000000 -1.0 \n", + "7424997 2438854 1.000000 0.000000 0.000000 -1.0 \n", + "7424998 2283818 0.999685 0.000012 0.000303 -1.0 \n", + "7424999 3582876 1.000000 0.000000 0.000000 -1.0 \n", + "\n", + " event_no \n", + "0 0.0 \n", + "1 4.0 \n", + "2 9.0 \n", + "3 27.0 \n", + "4 43.0 \n", + "... ... \n", + "7424995 98614183.0 \n", + "7424996 98614190.0 \n", + "7424997 98614194.0 \n", + "7424998 98614197.0 \n", + "7424999 98614207.0 \n", + "\n", + "[7425000 rows x 6 columns]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(np.unique(results[\"pid\"]))\n", + "results" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1, 12, 13])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## transform data\n", + "# remove anti\n", + "results['pid'] = results['pid'].apply(abs)\n", + "# make all neutrinos the same class; to match prediction\n", + "results.loc[results['pid']==14, \"pid\"]=12\n", + "results.loc[results['pid']==16, \"pid\"]=12\n", + "results[\"pid\"] = results[\"pid\"].astype(\"int\")\n", + "np.unique(results[\"pid\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Binarize the output\n", + "pid_true = label_binarize(results[\"pid\"], classes=[1, 12, 13])\n", + "nb_classes = pid_true.shape[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0, 1])" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_test = pid_true \n", + "y_prob = results[[\"pid_noise_pred\",\"pid_muon_pred\",\"pid_neutrino_pred\"]]\n", + "y_test\n", + "np.unique(y_test[2])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pid_noise_predpid_muon_predpid_neutrino_pred
00.9985000.0000700.001430
10.9901030.0012910.008606
20.9541510.0022270.043622
30.9800690.0004060.019525
41.0000000.0000000.000000
............
74249951.0000000.0000000.000000
74249961.0000000.0000000.000000
74249971.0000000.0000000.000000
74249980.9996850.0000120.000303
74249991.0000000.0000000.000000
\n", + "

7425000 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " pid_noise_pred pid_muon_pred pid_neutrino_pred\n", + "0 0.998500 0.000070 0.001430\n", + "1 0.990103 0.001291 0.008606\n", + "2 0.954151 0.002227 0.043622\n", + "3 0.980069 0.000406 0.019525\n", + "4 1.000000 0.000000 0.000000\n", + "... ... ... ...\n", + "7424995 1.000000 0.000000 0.000000\n", + "7424996 1.000000 0.000000 0.000000\n", + "7424997 1.000000 0.000000 0.000000\n", + "7424998 0.999685 0.000012 0.000303\n", + "7424999 1.000000 0.000000 0.000000\n", + "\n", + "[7425000 rows x 3 columns]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_prob" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "fpr = dict()\n", + "tpr = dict()\n", + "roc_auc = dict()\n", + "for i in range(nb_classes):\n", + " fpr[i], tpr[i], _ = roc_curve(y_test[:, i], y_prob.iloc[:, i])\n", + " roc_auc[i] = auc(fpr[i], tpr[i])\n", + "\n", + "# Compute micro-average ROC curve and ROC area\n", + "fpr[\"micro\"], tpr[\"micro\"], _ = roc_curve(y_test.ravel(), y_prob.values.ravel())\n", + "roc_auc[\"micro\"] = auc(fpr[\"micro\"], tpr[\"micro\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot of a ROC curve for a specific class\n", + "test = 1\n", + "plt.figure()\n", + "plt.plot(fpr[test], tpr[test], label='ROC curve (area = %0.2f)' % roc_auc[test])\n", + "plt.plot([0, 1], [0, 1], 'k--')\n", + "plt.xlim([0.0, 1.0])\n", + "plt.ylim([0.0, 1.05])\n", + "plt.xlabel('False Positive Rate')\n", + "plt.ylabel('True Positive Rate')\n", + "plt.title('Receiver operating characteristic example')\n", + "plt.legend(loc=\"lower right\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_36023/2474506920.py:7: DeprecationWarning: scipy.interp is deprecated and will be removed in SciPy 2.0.0, use numpy.interp instead\n", + " mean_tpr += interp(all_fpr, fpr[i], tpr[i])\n" + ] + } + ], + "source": [ + "# First aggregate all false positive rates\n", + "all_fpr = np.unique(np.concatenate([fpr[i] for i in range(nb_classes)]))\n", + "\n", + "# Then interpolate all ROC curves at this points\n", + "mean_tpr = np.zeros_like(all_fpr)\n", + "for i in range(nb_classes):\n", + " mean_tpr += interp(all_fpr, fpr[i], tpr[i])\n", + "\n", + "# Finally average it and compute AUC\n", + "mean_tpr /= nb_classes\n", + "\n", + "fpr[\"macro\"] = all_fpr\n", + "tpr[\"macro\"] = mean_tpr\n", + "roc_auc[\"macro\"] = auc(fpr[\"macro\"], tpr[\"macro\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot all ROC curves\n", + "plt.figure(figsize=(20,10))\n", + "plt.plot(\n", + " fpr[\"micro\"], tpr[\"micro\"],\n", + " color=\"tab:olive\", linestyle='dashdot',\n", + " label='micro-average ROC curve (area = {0:0.2f})'\n", + " ''.format(roc_auc[\"micro\"]),\n", + " linewidth=2)\n", + "\n", + "plt.plot(\n", + " fpr[\"macro\"], tpr[\"macro\"],\n", + " color=\"tab:purple\", linestyle='dashdot',\n", + " label='macro-average ROC curve (area = {0:0.2f})'\n", + " ''.format(roc_auc[\"macro\"]),\n", + " linewidth=2)\n", + "\n", + "colors=[\"tab:blue\",\"tab:green\",\"tab:orange\"]\n", + "\n", + "for i, item in enumerate([\"noise\", \"muon\", \"neutrino\"]):\n", + " plt.plot(fpr[i], tpr[i], color=colors[i], label='ROC of {0} class (area = {1:0.2f})'\n", + " ''.format(item, roc_auc[i]))\n", + "\n", + "plt.plot([0, 1], [0, 1], 'k--')\n", + "plt.xlim([0.0, 1.0])\n", + "plt.ylim([0.0, 1.05])\n", + "plt.xlabel('False Positive Rate')\n", + "plt.ylabel('True Positive Rate')\n", + "plt.title('Receiver operating characteristic to multi-class')\n", + "plt.legend(loc=\"lower right\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "One-vs-One ROC AUC scores:\n", + "0.605663 (macro),\n", + "0.605656 (weighted by prevalence)\n", + "One-vs-Rest ROC AUC scores:\n", + "0.605663 (macro),\n", + "0.605656 (weighted by prevalence)\n" + ] + } + ], + "source": [ + "macro_roc_auc_ovo = roc_auc_score(y_test, y_prob, multi_class=\"ovo\", average=\"macro\")\n", + "weighted_roc_auc_ovo = roc_auc_score(\n", + " y_test, y_prob, multi_class=\"ovo\", average=\"weighted\"\n", + ")\n", + "macro_roc_auc_ovr = roc_auc_score(y_test, y_prob, multi_class=\"ovr\", average=\"macro\")\n", + "weighted_roc_auc_ovr = roc_auc_score(\n", + " y_test, y_prob, multi_class=\"ovr\", average=\"weighted\"\n", + ")\n", + "print(\n", + " \"One-vs-One ROC AUC scores:\\n{:.6f} (macro),\\n{:.6f} \"\n", + " \"(weighted by prevalence)\".format(macro_roc_auc_ovo, weighted_roc_auc_ovo)\n", + ")\n", + "print(\n", + " \"One-vs-Rest ROC AUC scores:\\n{:.6f} (macro),\\n{:.6f} \"\n", + " \"(weighted by prevalence)\".format(macro_roc_auc_ovr, weighted_roc_auc_ovr)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('graphnet')", + "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.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e54c104f54ca5f79eede1c2e02355cc39841da57601eff628eedcebaaa867660" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/Comparison_RD_to_MC.py b/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/Comparison_RD_to_MC.py new file mode 100644 index 0000000..20b336a --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/Comparison_RD_to_MC.py @@ -0,0 +1,107 @@ +import sqlite3 as sql + +import numpy as np +import pandas as pd +from pandas import cut, read_sql +import pickle as pkl +from random import choices +from sklearn import metrics +import matplotlib.pyplot as plt +import matplotlib.colors as colors +import scipy.optimize as optimize + +indir_RD = "/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/Inference/pid_Leon_RD_results_new_model.csv" +indir_MC = "/groups/icecube/peter/storage/Multiclassification/Real/last_one_lvl3MC/dynedge_pid_Real_run_21.5_mill_equal_frac_second_/results.csv" +outdir = "/groups/icecube/qgf305/workspace/analyses/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/test" + +results_RD = pd.read_csv(indir_RD, index_col=[0]) +results_MC = pd.read_csv(indir_MC, index_col=[0]) + +bins_to_use = np.linspace(0,1,101) +bins_middle = (bins_to_use[1:]+bins_to_use[:-1])/2 + +print(bins_to_use) +print(bins_middle) + +pid_transform = {1:0,12:2,13:1,14:2,16:2} + +truth_MC = [] + +for i in range(len(results_MC)):# range(len(results)): + truth_MC.append(pid_transform[abs(results_MC['pid'].values[i])]) + +mask_noise = [True if truth_MC[i] ==0 else False for i in range(len(truth_MC))] +mask_muon = [True if truth_MC[i] ==1 else False for i in range(len(truth_MC))] +mask_neutrino = [True if truth_MC[i] ==2 else False for i in range(len(truth_MC))] + +fig, axs = plt.subplots(4,1,sharex=False,figsize=(8, 32)) + +counts_neutrino, _,_ = axs[0].hist(results_MC['pid_neutrino_pred'].values[mask_neutrino],bins=bins_to_use,label='MC Neutrinos',density=True) +counts_muon, _,_ = axs[1].hist(results_MC['pid_neutrino_pred'].values[mask_muon],bins=bins_to_use,label='MC muons',density=True) +counts_noise, _,_ = axs[2].hist(results_MC['pid_neutrino_pred'].values[mask_noise],bins=bins_to_use,label='MC Noise',density=True) +counts_RD, _,_ = axs[3].hist(results_RD['pid_neutrino_pred'].values,bins=bins_to_use,label='RD') + +print(counts_noise[:5]) +print(counts_RD[:5]) + +axs[0].set_ylabel('Density') +axs[1].set_ylabel('Density') +axs[2].set_ylabel('Density') +axs[3].set_ylabel('Count') + +axs[0].set_yscale('log') +axs[1].set_yscale('log') +axs[2].set_yscale('log') +axs[3].set_yscale('log') + +axs[0].set_xlabel('Neutrino probability') +axs[1].set_xlabel('Neutrino probability') +axs[2].set_xlabel('Neutrino probability') +axs[3].set_xlabel('Neutrino probability') + +axs[0].set_title('MC Neutrino') +axs[1].set_title('MC Muons') +axs[2].set_title('MC Noise') +axs[3].set_title('RD') + +fig.tight_layout() + +fig.savefig(outdir + 'Neutrino_prob_histograms.png') + +def chi_square(N_scalers): + sum = 0 + for i in range(len(bins_to_use)-1): + sum+= (counts_RD[i] - N_scalers[0]*counts_noise[i] - N_scalers[1]*counts_muon[i] - N_scalers[2]*counts_neutrino[i])**2/counts_RD[i] + return sum + +N_0 = [50000,50000,50000] +res = optimize.minimize(chi_square,N_0,bounds = ((0, None),(0, None), (0, None))) +print(res.x) +print(res.success) + +N_test = [500000,500000,50000] +fig, axs = plt.subplots(figsize=(8, 8)) + +counts_noise_fit = counts_noise*res.x[0]#*N_test[0] +counts_muon_fit = counts_muon*res.x[1]#*N_test[1]# +counts_neutrino_fit = counts_neutrino*res.x[2]#*N_test[2]# + +print('noise:',counts_noise_fit[:10]) +print('muon:',counts_muon_fit[:10]) +print('neutrino:',counts_neutrino_fit[:10]) + +axs.stairs(counts_neutrino_fit, bins_to_use,baseline=(counts_noise_fit+counts_muon_fit),label='Scaled Neutrinos',fill=True,color='green') +axs.stairs(counts_muon_fit, bins_to_use,baseline=counts_noise_fit,label='Scaled Muons',fill=True,color='orange') +axs.stairs(counts_noise_fit, bins_to_use,label='Scaled Noise',fill=True,color='blue') + + +axs.plot(bins_middle,counts_RD,'o',label='Real data') +axs.set_xlabel('Neutrino probability') + +axs.set_ylabel('Count') +axs.set_yscale('log') +axs.legend(loc='upper right') + +fig.tight_layout() + +fig.savefig(outdir + 'Scaled_prob_histograms.png') \ No newline at end of file diff --git a/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/RD_to_MC.ipynb b/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/RD_to_MC.ipynb new file mode 100644 index 0000000..5daa85a --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/RD_to_MC.ipynb @@ -0,0 +1,547 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import sqlite3 as sql\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "from pandas import cut, read_sql\n", + "import pickle as pkl\n", + "from random import choices\n", + "from sklearn import metrics\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors as colors\n", + "import scipy.optimize as optimize" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "def chi_square(N_scalers):\n", + " sum = 0\n", + " for i in range(len(bins_to_use)-1):\n", + " sum+= (counts_RD[i] - N_scalers[0]*counts_noise[i] - N_scalers[1]*counts_muon[i] - N_scalers[2]*counts_neutrino[i])**2/counts_RD[i]\n", + " return sum" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "class display(object):\n", + " \"\"\"Display HTML representation of multiple objects\"\"\"\n", + " template = \"\"\"
\n", + "

{0}

{1}\n", + "
\"\"\"\n", + "\n", + " def __init__(self, *args):\n", + " self.args = args\n", + "\n", + " def _repr_html_(self):\n", + " return '\\n'.join(self.template.format(a, eval(a)._repr_html_())\n", + " for a in self.args)\n", + "\n", + " def __repr__(self):\n", + " return '\\n\\n'.join(a + '\\n' + repr(eval(a))\n", + " for a in self.args)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "indir_RD = \"/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/Inference/pid_Leon_RD_results_new_model.csv\"\n", + "indir_MC = \"/groups/icecube/peter/storage/Multiclassification/Real/last_one_lvl3MC/dynedge_pid_Real_run_21.5_mill_equal_frac_second_/results.csv\"\n", + "outdir = \"/groups/icecube/qgf305/workspace/analyses/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/test\"\n", + "\n", + "results_RD = pd.read_csv(indir_RD, index_col=[0])\n", + "results_MC = pd.read_csv(indir_MC, index_col=[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-16. -14. -12. -1. 12. 13. 14. 16.]\n" + ] + } + ], + "source": [ + "print(np.unique(results_MC.pid))\n", + "pid_transform = {1:0,12:2,13:1,14:2,16:2}" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "

results_RD

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pid_noise_predpid_muon_predpid_neutrino_predpidevent_no
09.100197e-040.9952203.870316e-03-1.00.0
11.982298e-170.9999973.332041e-06-1.01.0
22.132605e-120.9999178.263976e-05-1.02.0
32.653166e-140.9997952.045055e-04-1.03.0
49.950417e-010.0003084.650586e-03-1.04.0
..................
14207049.957962e-010.0006213.582841e-03-1.096917756.0
14207052.507694e-171.0000004.941842e-07-1.096917757.0
14207061.000000e+000.0000000.000000e+00-1.096917758.0
14207079.853759e-010.0011281.349629e-02-1.096917759.0
14207089.903507e-010.0004779.172585e-03-1.096917760.0
\n", + "

1420709 rows × 5 columns

\n", + "
\n", + "
\n", + "
\n", + "

results_MC

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pid_noise_predpid_muon_predpid_neutrino_predpidevent_no
01.000000e+000.0000000.000000-1.023434375.0
11.857092e-180.9996210.00037913.070953235.0
22.644923e-140.9959310.00406913.097961265.0
38.509830e-020.0127910.90211012.033636682.0
44.873881e-040.0020450.99746812.053035643.0
..................
74249951.000000e+000.0000000.000000-1.066993636.0
74249962.241822e-120.9989570.00104313.058567439.0
74249973.683385e-020.0001570.96300916.081515634.0
74249987.042371e-040.0655150.93378016.0221130.0
74249993.246351e-070.2523720.74762713.092196571.0
\n", + "

7425000 rows × 5 columns

\n", + "
\n", + "
" + ], + "text/plain": [ + "results_RD\n", + " pid_noise_pred pid_muon_pred pid_neutrino_pred pid event_no\n", + "0 9.100197e-04 0.995220 3.870316e-03 -1.0 0.0\n", + "1 1.982298e-17 0.999997 3.332041e-06 -1.0 1.0\n", + "2 2.132605e-12 0.999917 8.263976e-05 -1.0 2.0\n", + "3 2.653166e-14 0.999795 2.045055e-04 -1.0 3.0\n", + "4 9.950417e-01 0.000308 4.650586e-03 -1.0 4.0\n", + "... ... ... ... ... ...\n", + "1420704 9.957962e-01 0.000621 3.582841e-03 -1.0 96917756.0\n", + "1420705 2.507694e-17 1.000000 4.941842e-07 -1.0 96917757.0\n", + "1420706 1.000000e+00 0.000000 0.000000e+00 -1.0 96917758.0\n", + "1420707 9.853759e-01 0.001128 1.349629e-02 -1.0 96917759.0\n", + "1420708 9.903507e-01 0.000477 9.172585e-03 -1.0 96917760.0\n", + "\n", + "[1420709 rows x 5 columns]\n", + "\n", + "results_MC\n", + " pid_noise_pred pid_muon_pred pid_neutrino_pred pid event_no\n", + "0 1.000000e+00 0.000000 0.000000 -1.0 23434375.0\n", + "1 1.857092e-18 0.999621 0.000379 13.0 70953235.0\n", + "2 2.644923e-14 0.995931 0.004069 13.0 97961265.0\n", + "3 8.509830e-02 0.012791 0.902110 12.0 33636682.0\n", + "4 4.873881e-04 0.002045 0.997468 12.0 53035643.0\n", + "... ... ... ... ... ...\n", + "7424995 1.000000e+00 0.000000 0.000000 -1.0 66993636.0\n", + "7424996 2.241822e-12 0.998957 0.001043 13.0 58567439.0\n", + "7424997 3.683385e-02 0.000157 0.963009 16.0 81515634.0\n", + "7424998 7.042371e-04 0.065515 0.933780 16.0 221130.0\n", + "7424999 3.246351e-07 0.252372 0.747627 13.0 92196571.0\n", + "\n", + "[7425000 rows x 5 columns]" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "display(\"results_RD\", \"results_MC\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "bins_to_use = np.linspace(0,1,101)\n", + "bins_middle = (bins_to_use[1:]+bins_to_use[:-1])/2" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "truth_MC = []\n", + "\n", + "for i in range(len(results_MC)):# range(len(results)):\n", + " truth_MC.append(pid_transform[abs(results_MC['pid'].values[i])])" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[82.03414252 7.07203354 2.79999564 1.5452585 0.99282344]\n", + "[970923. 127454. 57279. 34445. 23521.]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(4,1,sharex=False,figsize=(8, 32))\n", + "\n", + "mask = dict()\n", + "counts = dict()\n", + "for i, item in enumerate([\"noise\", \"neutrino\", \"muon\"]): # class i; 0,1,2\n", + " mask[item] = [True if truth_MC[j] == i else False for j in range(len(truth_MC))]\n", + " counts[item], _, _ = axs[i].hist(results_MC['pid_neutrino_pred'].values[mask[item]],bins=bins_to_use,label=f'MC {item}',density=True);\n", + " axs[i].set_ylabel('Density')\n", + " axs[i].set_yscale('log')\n", + " axs[i].set_xlabel('Neutrino probability')\n", + " axs[i].set_title(f\"MC {item}\")\n", + "\n", + "counts[\"RD\"], _,_ = axs[3].hist(results_RD['pid_neutrino_pred'].values,bins=bins_to_use,label='RD')\n", + "axs[3].set_ylabel('Count')\n", + "axs[3].set_yscale('log')\n", + "axs[3].set_xlabel('Neutrino probability')\n", + "axs[3].set_title('RD')\n", + "\n", + "fig.tight_layout()\n", + "\n", + "print(counts[\"noise\"][:5])\n", + "print(counts[\"RD\"][:5])" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[12915.90013628 0. 98.27337215]\n", + "True\n", + "noise: [1059544.79259967 91341.67896913 36164.46401813 19958.40448865\n", + " 12823.20834376 8994.14645706 6780.8370034 5225.62309821\n", + " 4229.8686918 3528.45678288]\n", + "neutrino: [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + "muon: [25.04346618 15.6462112 11.08455257 9.43298599 7.84891133 7.13032106\n", + " 6.45143192 6.07030117 5.76460255 5.28818912]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "N_0 = [50000,50000,50000]\n", + "res = optimize.minimize(chi_square,N_0,bounds = ((0, None),(0, None), (0, None)))\n", + "print(res.x)\n", + "print(res.success)\n", + "\n", + "N_test = [500000,500000,50000]\n", + "fig, axs = plt.subplots(figsize=(8, 8))\n", + "\n", + "counts_fit = dict()\n", + "for i, item in enumerate([\"noise\", \"muon\", \"neutrino\"]):\n", + " counts_fit[item] = counts[item]*res.x[i] #*N_test[0]\n", + " print(f\"{item}: \",counts_fit[item][:10])\n", + "\n", + "axs.stairs(counts_fit[\"neutrino\"], bins_to_use,baseline=(counts_fit[\"noise\"]+counts_fit[\"muon\"]),label='Scaled Neutrinos',fill=True,color='green')\n", + "axs.stairs(counts_fit[\"muon\"], bins_to_use,baseline=counts_fit[\"noise\"],label='Scaled Muons',fill=True,color='orange')\n", + "axs.stairs(counts_fit[\"noise\"], bins_to_use,label='Scaled Noise',fill=True,color='blue')\n", + "\n", + "axs.plot(bins_middle, counts[\"RD\"],'o',label='Real data')\n", + "axs.set_xlabel('Neutrino probability')\n", + "\n", + "axs.set_ylabel('Count')\n", + "axs.set_yscale('log')\n", + "axs.legend(loc='upper right')\n", + "\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('graphnet')", + "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.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e54c104f54ca5f79eede1c2e02355cc39841da57601eff628eedcebaaa867660" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/Reweight MC data.ipynb b/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/Reweight MC data.ipynb new file mode 100644 index 0000000..871e953 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/Reweight MC data.ipynb @@ -0,0 +1,1107 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib\n", + "import seaborn as sns\n", + "\n", + "matplotlib.rc('xtick', labelsize=18)\n", + "matplotlib.rc('ytick', labelsize=18)\n", + "matplotlib.rc('axes', labelsize=20) # fontsize of the x and y labels\n", + "matplotlib.rc('font', **{'size' : 18, 'family':'monospace'})\n", + "matplotlib.rcParams['figure.figsize'] = (12, 8)\n", + "matplotlib.rcParams['figure.titlesize'] = 22" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "level3_clean = False" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_19828/4283734702.py:13: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " MC_L3['index'] = MC_L3.index\n" + ] + } + ], + "source": [ + "# Monte Carlo data\n", + "MCfile ='/groups/icecube/leonbozi/work3/stopped_muons_final_reco_MC.csv'\n", + "# Real data\n", + "RDfile ='/groups/icecube/leonbozi/work3/stopped_muons_final_reco_RD.csv'\n", + "\n", + "savepath = '/groups/icecube/debes/work/graphnetgit/graphnet/studies/stmuon/plotting/plots/'\n", + "\n", + "MC_all = pd.read_csv(MCfile)\n", + "RD_all = pd.read_csv(RDfile)\n", + "RD_all['index'] = RD_all.index\n", + "MC_L3 = MC_all[MC_all['stopped_muon'] == 1]\n", + "RD = RD_all[RD_all['stopped_muon'] == -1]\n", + "MC_L3['index'] = MC_L3.index\n", + "\n", + "if level3_clean:\n", + " RD = RD[RD['L3_oscNext_bool'] == -1]\n", + " MC_L3 = MC_L3[MC_L3['L3_oscNext_bool'] == 1]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "#MC_all.to_csv('C:/Users/simon/Documents/IceCube/')\n", + "#RD_all.to_csv('C:/Users/simon/Documents/IceCube/')\n", + "keys = ['energy_pred', 'azimuth_pred', 'zenith_pred','position_z_pred']\n", + "n_bins = 100" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plot distributions" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(2,2, figsize=(14,8))\n", + "ax[0,0].hist(MC_L3[keys[0]], density=1, range=(2.2,2.8), histtype='step', bins=n_bins, label='MC')\n", + "ax[0,0].hist(RD[keys[0]], density=1, range=(2.2,2.8), histtype='step', bins=n_bins, label='RD')\n", + "ax[0,0].set_xlabel(keys[0]), ax[0,0].set_ylabel('Count'), ax[0,0].legend()\n", + "\n", + "ax[0,1].hist(MC_L3[keys[1]], density=1, histtype='step', bins=n_bins, label='MC')\n", + "ax[0,1].hist(RD[keys[1]], density=1, histtype='step', bins=n_bins, label='RD')\n", + "ax[0,1].set_xlabel(keys[1]), ax[0,1].set_ylabel('Count'), ax[0,1].legend(loc='lower right'), ax[0,1].set_ylim(0,0.28)\n", + "\n", + "ax[1,0].hist(MC_L3[keys[2]], density=1, histtype='step', bins=n_bins, label='MC')\n", + "ax[1,0].hist(RD[keys[2]], density=1, histtype='step', bins=n_bins, label='RD')\n", + "ax[1,0].set_xlabel(keys[2]), ax[1,0].set_ylabel('Count'), ax[1,0].legend(loc='upper left')\n", + "\n", + "ax[1,1].hist(MC_L3[keys[3]], density=1, range=(-500, 300), histtype='step', bins=n_bins, label='MC')\n", + "ax[1,1].hist(RD[keys[3]], density=1, range=(-500, 300), histtype='step', bins=n_bins, label='RD')\n", + "ax[1,1].set_xlabel(keys[3]), ax[1,1].set_ylabel('Count'), ax[1,1].legend(), ax[1,1].set_ylim(0,0.0075)\n", + "\n", + "\n", + "plt.suptitle('Uncut data'), plt.tight_layout(),plt.show();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Energy and position_z_pred have large tails, where reweighting doesn't make sense. We cut truncate data such that the ratio of MC to RD is reasonable for all x-values." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# Ranges are found by human estimation\n", + "E_range, A_range, Z_range, pos_range = (2.27,2.55), (0,2*np.pi), (0.05,1.3), (-400,-155)\n", + "ranges=[E_range, A_range, Z_range, pos_range]" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Cut off all outliers\n", + "RD_df = RD[(RD[keys[0]] > ranges[0][0]) & (RD[keys[0]] < ranges[0][1]) & (RD[keys[3]] > ranges[3][0]) & (RD[keys[3]] < ranges[3][1]) & (RD[keys[2]] > ranges[2][0]) & (RD[keys[2]] < ranges[2][1])]\n", + "MC_df = MC_all[(MC_all[keys[0]] > ranges[0][0]) & (MC_all[keys[0]] < ranges[0][1]) & (MC_all[keys[3]] > ranges[3][0]) & (MC_all[keys[3]] < ranges[3][1]) & (MC_all[keys[2]] > ranges[2][0]) & (MC_all[keys[2]] < ranges[2][1])].sample(len(RD_df))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABVQAAAMJCAYAAADsxL03AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeXxU5dn/8e8kJJOEQEIIYYlhkQAKqCBga21ZlFalWiso4IKAFbSKKy5F7YNWEfurC1hxKSoIKKACrctTBZTFR1sFMRawLFGQCEISQvaV5Pz+GDPZZpKZ5MxyZj7v12teTM6c5crJMHOf69z3ddsMwzAEAAAAAAAAAGhRRKADAAAAAAAAAACrIKEKAAAAAAAAAB4ioQoAAAAAAAAAHiKhCgAAAAAAAAAeIqEKAAAAAAAAAB4ioQoAAAAAAAAAHiKhCgAAAAAAAAAeIqEKAAAAAAAAAB4ioQoAAAAAAAAAHiKhCgAAgJAybdo02Ww22Ww2HTx4MNDhAAAAIMS0C3QAAAAAaOrdd9/VmjVr9Omnn+rYsWMqLS1V586dNXjwYI0dO1bXXnutUlNT/RbP0qVLncnJhx56yG/HtZKDBw9q6dKlkqTRo0dr9OjRAY0HAAAAvkFCFQAAIIjs379f119/vf7v//6vyWtHjx7V0aNHtXHjRv3xj3/U8ePH1aFDB7/EtXTpUm3ZskUSCVV3Dh48qIcfftj5MwlVAACA0ERCFQAAIEjs3r1bF1xwgY4dOyZJOuWUU3TVVVdp4MCBstvtOnTokD788EN9+OGHqqqqUnV1dYAjBgAAAMIPCVUAAIAgUFZWpssvv9yZTJ02bZqee+45xcbGNljvvvvu0759+3T77bcHIkwAAAAg7JFQBQAACAKPP/649u/fL0k6//zz9fLLLysiwvX8of3799c///lPGYbhzxABAAAASHLdSgcAAIDfVFVV6YUXXnD+/MQTT7hNptZns9maLBs9erRzhvvmNLfe5s2bna/VPmrrp9Ye19WjdtIqX8vNzdUf/vAHDRw4UO3bt1dSUpJGjRqlVatWebyP8vJy/eMf/9CsWbP005/+VMnJyYqKilKnTp10+umn6/e//73+9a9/NbuP+ufQZrNpzJgxztcefvhhl+do2rRpzf5er7zyiqZMmaIzzzxTCQkJioqKUkpKikaMGKEHHnhAhw4d8vh3BAAAgG/QQxUAACDANmzYoOzsbEnSoEGDNHTo0ABHFLy2bdumcePGKTc317mstLRUW7dudT48MXDgQB04cKDJ8vz8fOXn52vPnj164YUX9Lvf/U4vvviiIiMjTfsdXPn22281YMAAnTx5sslrOTk5ysnJ0fbt2/XUU0/pqaee0u9//3ufxgMAAAD3SKgCAAAEWP2ekOeff34AI3EYPHiw1q1b12DZgw8+qN27d0tSk9dqpaSk+DSuo0eP6qKLLlJeXp4k6Wc/+5muueYaJSUlaffu3Xr++ef1/PPPq1u3bi3uq7S0VDabTSNGjNB5552n008/XZ06dVJFRYX27Nmj119/Xd9++61efvllRUZG6sUXX2yyj0cffbRBYnfXrl364x//KEmaNGmSJk+e3GSbnj17uoynsrJSJ0+eVExMjEaPHq0RI0aob9++io+PV2Fhob744gutWLFCBQUFuvnmm5WQkKCrr77ao/MGAAAAc9kMim8BAAAE1KWXXqp3331XkvTcc8+1qffh6NGjncPzm2vmebpea9f3heuvv15LlixxPn/ppZcalCw4dOiQzj33XB05csS57MCBA+rdu3eTfT311FOaNGmSUlNTXR6rvLxc5557rjIyMmSz2bR3717169ev2fg2b97sHPY/d+5cPfTQQx7/bkeOHNHbb7+ta6+9VvHx8S7X2b9/v4YNG6aioiKlpaXpu+++a7G0AwAAAMxHDVUAAIAAqx3uL0ndu3cPYCTBq6CgQCtXrpQkderUSQsWLGiSTOzZs6f+/Oc/e7S/u+66y20yVZJiYmL0P//zP5IcCeQPPviglZF7pkePHrrpppvcJlMlqV+/fpo+fbokKSsry9ljGAAAAP5FQhUAACDACgoKnM/bt28fwEiC19atW1VeXi7J0aO3Q4cOLte74oorFBcXZ8oxTz/9dOdzf0241ZJgjAkAACDcUEMVAAAAQS8jI8P5fPjw4W7Xi4mJ0RlnnKHPPvusxX0eP35cy5cv1/vvv6/du3crLy9PpaWlLtctLCz0OubW2Ldvn5YuXaqPP/5Y+/btU35+viorKwMaEwAAABoioQoAABBgCQkJzuclJSUBjCR45eTkOJ83N1RfktLS0lpMqK5bt0433HCDc4KrllRVVXm0Xlv88Y9/1OOPP66TJ096tL4/YgIAAEBTJFQBAAACLDk52fn8hx9+CGAkwat+z9GYmJhm123p9U8//VRXXnmlqqurJUlDhgzRb37zG6Wnpys+Pt5ZmzU7O1s33nijJN9PxPX//t//06OPPipJstlsuuiii3T++efrlFNOafD7fPTRR/rrX//ql5gAAADgGglVAACAABsyZIj+93//V5K0Z88evxyzpqbGL8cxS/3asrW1VN0pKytr9vW5c+c6k6l/+ctfdPfdd7tc7+uvv/YyytYpLy/XI488IkmKjY3V+++/r5EjR7pc98iRI36JCQAAAO4xKRUAAECA/fSnP3U+/+ijj9q0r3bt6u6XN5c0PXHiRJuO429du3Z1Pj98+HCz637//fduX6usrNTmzZslSWeddZbbZKokZWVleRdkK/3rX/9ScXGxJGnmzJluk6n+jAkAAADukVAFAAAIsAsvvFCdO3eWJO3atUtfffVVq/cVHx/vfH78+HGX61RUVGj//v1e7Tcioq7ZGIih5meddZbz+fbt292uV15erp07d7p9/fjx484apaeffnqzx9y0aZNXMbb2HB09etT53OyYAAAAYD4SqgAAAAEWHR2tGTNmOH++5557PBqS7ypp17t3b+fzzz//3OV2b731lioqKryKsUOHDs7nnk7kZKaRI0cqNjZWkvTOO++oqKjI5XpvvfVWg3qrjdUvHfDtt9+6Xe/48eN6+eWXvYqxtefI05i2bNnS4mRbAAAA8D0SqgAAAEHgwQcfVJ8+fSRJGzZs0MyZM93WAs3MzNSvf/1rFRQUNHnt3HPPdT5//PHHm8wEf/DgQd17771ex5eenu58vn79eq+3b6sOHTroqquukuQoV3DHHXc0SShnZWXpvvvua3Y/HTt2VP/+/SVJ27Zt0/vvv99knaKiIk2cOFG5ublexdi3b1/nhFYffvihx3Vqhw8f7tzu5Zdfdlkndc+ePbr22mu9igcAAAC+YTOYHhQAACAoZGRkaOzYsc6h+mlpabrqqqs0cOBA2e12HTp0SB999JE2bNigmpoanThxQomJiQ32UVJSot69ezuTgUOGDNHVV1+thIQEff3111qyZIk6dOig5ORkZ2kBT5qDH330kS644AJJUlJSkh566CH99Kc/dfYalaQBAwYoKirKjFPh0tGjRzVo0CBn78+f/exnuvbaa5WUlKTdu3frueee0/Hjx9W9e3f98MMPkqQDBw406LUrSc8//7xuvvlmSY6as9OmTXP+Ljt37tTSpUt19OhR/fa3v9Xf//53SdLUqVO1dOnSFmMcOXKkPv74Y0nSZZddpptuukk9evRwlgPo1KmTUlNTm2w3adIkvfHGG5Ic5/emm27SwIEDVVVVpU8++UTLly9XRUWFLrvsMv3jH/+QJC1ZskTTpk3z6hwCAACg7UioAgAABJGvv/5a06dPdztcv1a7du2Ul5fXYJh5rTVr1mjixIkue0gmJSXp7bff1gMPPKAtW7ZI8rze54QJE7R27Vq3r7tKXprt888/17hx49zWh73ttttUUFCgV1991W1MhmHohhtu0CuvvOL2OFdccYUee+wxZ29WTxOqn332mcaMGeO2d7G7/Zw4cUJjx47Vjh07XG4XGRmpxx9/XMnJyZo+fbokEqoAAACBwpB/AACAIDJw4ED9+9//1t///ndNmTJF/fr1U4cOHdSuXTulpKRo9OjReuyxx3TgwAGXyVTJkfjcvHmzLr74YnXq1El2u119+/bVrbfeqh07dui8885rVWxvvPGGXnjhBY0ePVrJyclq165dW37VVjnnnHO0Z88e3XfffTr99NMVFxenxMREjRo1Sm+88YYWLlzY4j5sNptefvllrVmzRr/61a/UuXNnRUVFqUePHrr44ou1evVqvfnmm63qbfuTn/xEO3bs0IwZMzRgwADFxcV5tF2nTp30ySef6Mknn9SIESMUHx+vmJgY9enTR9ddd50++eQT3X333V7HAwAAAPPRQxUAAAAAAAAAPEQPVQAAAAAAAADwEAlVAAAAAAAAAPAQCVUAAAAAAAAA8BAJVQAAAAAAAADwEAlVAAAAAAAAAPAQCVUAAAAAAAAA8BAJVQAAAAAAAADwEAlVAAAAAAAAAPAQCVUAAAAAAAAA8BAJVQAAAAAAAADwEAlVAAAAAAAAAPAQCVUAAAAAAAAA8BAJVQAAAAAAAADwEAlVAAAAAAAAAPAQCVUAAAAAAAAA8BAJVQAAAAAAAADwEAlVAAAAAAAAAPAQCVUAAAAAAAAA8BAJVQAAAAAAAADwEAlVAAAAAAAAAPAQCVUAAAAAAAAA8BAJVQAAAAAAAADwEAlVAAAAAAAAAPAQCVUAAAAAAAAA8BAJVQAAAAAAAADwEAlVAAAAAAAAAPAQCVUAAAAAAAAA8BAJVQAAAAAAAADwEAlVAAAAAAAAAPAQCVUAAAAAAAAA8BAJVQAAAAAAAADwEAlVAAAAAAAAAPAQCVUAAAAAAAAA8BAJVQAAAAAAAADwEAlVAAAAAAAAAPAQCVUAAAAAAAAA8BAJVQAAAAAAAADwEAlVAAAAAAAAAPAQCVUAAAAAAAAA8BAJVQAAAAAAAADwEAlVAAAAAAAAAPAQCVUAAAAAAAAA8FC7QAcQTGpqanTkyBF16NBBNpst0OEAAAB4xTAMFRUVqUePHoqI4L45vEd7GAAAWJm/2sMkVOs5cuSI0tLSAh0GAABAm2RlZemUU04JdBiwINrDAAAgFPi6PUxCtZ4OHTpIcpz0jh07BjgaAAAA7xQWFiotLc3ZpgG8RXsYAABYmb/awyRU66kd1tSxY0cakAAAwLIYqo3Woj0MAABCga/bwxTXAgAAAAAAAAAPkVAFAAAAAAAAAA+RUAUAAAAAAAAAD5FQBQAAAAAAAAAPkVAFAAAAAAAAAA+1C3QAAAAAAAAAQFDLz5JKjzdcFtdZSkwLTDwIKBKqAAAAAAAAgDv5WdKic6Sq0obLo+KkWz4nqRqGSKgCAAAAAAAA7pQedyRTxy+Wkvs7luXuk9bOcLxGQjXskFAFAAAAAAAAWpLcX+oxJNBRIAiQUAUAwJ98XHvJMAxVVVWppqbGlP3B/yIiIhQVFSWbzRboUAAAANCS3H0Nf6aualggoQoAgL/4sPZSdXW1cnNzVVRUpKqqqjYGikCLiopShw4dlJycrMjIyECHAwAAgMbiOjva8WtnNFxOXdWwQEIVAAB/8VHtperqamVlZamiokIJCQmKj49XZGQkPRwtyDAMVVdXq7i4WPn5+SorK1NaWhpJVQAAgGCTmOZInNYffUZd1bBBQhUAAH8zufZSbm6uKioq1LNnT8XGxpq2XwROfHy8EhISdOjQIeXm5qpr166BDgkAAACNJaaROA1TEYEOAAAAtJ5hGCoqKlJCQgLJ1BATGxurjh07qqioSIZhBDocAAAAAD8ioQoAgIVVVVWpqqpK8fHxgQ4FPtChQwfn3xgAAABAcCChCgCAhdXU1EgSNTZDVO3ftfbvDAAAACDwqKEKAICv5Gc1LVLvI0xAFZr4uwIAAADBh4QqAAC+kJ8lLTpHqiptuDwqTorr3HR9T5KtcZ0peg8AAAAESGZOscqNAufPndpHKzWReQzCEQlVAAB8ofS4I5k6frGU3L9ueeOkaFxnR5J17YyW9xkVJ93yOUlVAAAAwI+yiyuUIun2VRnaXS+hGhsVqY2zR5FUDUMkVAEA8KXk/lKPIe5fT0xzJEnrlwZwJXefI+laepyEKgAAAOBHhWVVSpF0968GqEv/cyRJmdnFumN1hk6UVJJQDUMkVAEACLTENL8kSQ/nl+lESaXPj+NrvhhaVb9W6RNPPKHZs2c3WWfWrFlatGiRJKlXr146ePCgy30dOHBAzz77rD744ANlZWWpvLxc3bt31y9+8QtNmTJFY8eOVUQE84ICAABYTVpSrNJTEwIdBoIACVUAAMLA4fwyjX1yi8qqqgMdSpv5emjVqlWrmiRUq6ur9eabb7a47Ysvvqg77rhD5eXlkiS73a6YmBh99913+u6777RixQodOHBAvXv39kXoAAAAAPyAhCoAAFbSePKqdp7dIT9RUqmyqmotmDRE6SnxPgjMP3w9tKpv377avn27vvnmG/Xt29e5/MMPP1R2drbS09OVmZnpcttly5bppptukiRdeOGFeuyxx3T22WdLko4ePaq33npLf/7zn02PGQAAwGv5WU1LTjEBqnkat9k5tyGHhCoAAFbgbvKqxP7SL1/xeDfpKfEazDAltyZPnqx58+Zp1apVeuCBB5zLV65cKUmaNGmS5s2b12S7Y8eO6bbbbpMkXXTRRXr33XcVGRnpfL1bt26aNWuWrrvuOrVrR/MLAAAEUH6WtOgcxwSq9TEBatu5a7NzbkMOLXoAAKzA1eRVufuk9X+SjJrAxRVixowZo5deeqlBQrWiokLr1q3TsGHDlJ6e7nK7xYsXq6CgQDabTc8880yDZGp9HTt29FnsAAAAHik97kimjl/smEBVYgLUNsjMLq73U0clT9mqbu1K6hZxbkMSCVUAAKzCT5NXhbPIyEhdccUVWrRokb7++msNHDhQ//znP1VQUKBJkya53a62vurw4cPVr18/f4ULAADQesn9pR5DAh2FZXVqH63YqEjdsTqjwXJf1/tHcGCKWQAAgHomT54syTE5leQY7m+z2dwmVEtLS7V7925J0k9+8hP/BAkAAICASk2M1cbZo/TurT93PhZMGqKyqmqdKKkMdHjwMRKqAAAA9Zx33nlKS0vT6tWrVVxcrHfffVfnnnuuevbs6XL97777TtXV1ZKkPn36+DNUAAAABFBqYqwGpyY4H1ae/BXeIaEKAABQj81m08SJE7Vv3z499NBDKi0tdfZadaWgoMD5vEOHDv4IEQAAAEAAkVAFAMDqqqukyjKpstTxOMkQo7aqTaA+/fTTioiI0JVXXul2XcMw/BUWAADhJT9LOpLR8JGfFdiYAEBMSgUAgHfysxwzdLYkd5/vY4nrLLWLdcSTHyG1szmW2yKkLqdL7aJ9H0OIGj58uNLT05WZmakxY8aoW7dubtdNSEhwPi8qKvJHeACAYOKqbRDXmYkk2yo/S1p0jmM2+vqi4qRbPuf8AggoEqoAAHjKXcPenag4xwWVrySmSVe/IWUXSok9pRi7dLJcyv9OqjkpiYRqW8ybN09bt27VZZdd1ux6vXr1UkREhGpqanTgwAE/RQcACAok/Xyn9LjjvI5f7JiNXnLcsF47w/Ea5xZAAJFQBQDAU64a9s3xR++Ujt2l4+VSdKwUHePbY4WZiRMnauLEiS2u1759ew0cOFC7du3SZ5995ofIAABBg6Sf7yX3l3oMCXQUISkzp1jlhqMWfExusdIDHE8oycwudj7n3IYmEqoAAHiLhj0aueKKK7Rr1y5t375d+/btU//+HiTcAQChg7YBLCS7uEIpkm5flaHdPyZUB9kO6D173WtonU7toxUbFak7Vmc4l3FuQxMJVQAAgDaaMWOGnnjiCRUXF+v222/Xe++9p4iIpnN/FhUVKTIyUnFxcQGIEgAAQCosq1KKpLt/NUBd+p8jScrZFy1tqXst3B3OL9OJkrqJXnPyyjzqZZqaGKuNs0c13JZzG5JIqAIAALRRjx499NRTT2nmzJl6//339etf/1qPPfaYhg4dKknKycnRunXr9Nhjj2nz5s3q3bt3YAMGAABhLy0pVumpjsk1M3NjJUn2/EzpSHzdSmE4wdrh/DKNfXKLyqqqncsG2Q5ojF3qGBvV4vapibFKTYx1/lx7bhFaSKgCAACYYMaMGSorK9M999yj999/X++//75iYmJkt9tVUFAQ6PAAAADcqo5JUqlhV9qm26VN9V4IwwnWTpRUqqyqWgsmDVF6iiO5HJObIK2TUuLtAY4OwYKEKgAAgEluu+02XXzxxVq0aJHWr1+vrKwsnTx5UgMGDNDZZ5+t6667Tj179gx0mAAAAA1UxadqbMVftOyqvkrv8mMP1TCfYC09JV6Df+zBK1t88ysj7JBQBQAgFJ0sb/hzdZWkhjOOWpGv4jcMw6P1pk2bpmnTpjW7Tr9+/bRgwYK2BwUAAOBHR5Ss8uQzpB4JgQ4FCHqWT6iuWrVKS5Ys0Y4dO5Sfn6/4+HgNHDhQkyZN0k033aTo6OhAhwgAgP9EtJNsEVL+dw0WdyqrUWxURIMZR60qNipSndrz/Q4AAAAgMCybUK2urtbVV1+tN954w7ksISFBBQUF+vTTT/Xpp59q2bJl2rhxoxITEwMXKAAA/tQuWupyulRzsm7ZyXKl6jttvPUnOlEVGbjYTNKpfXSDQv8AAAAA4E+WTaguXrzYmUydO3eu7rrrLnXs2FHl5eVaunSpZs2apS+++EL333+/nnvuuQBHCwCAH7WLltS0B2dqYoxSo+P8Hw8AAAAAhJCIQAfQWitXrpQkXXjhhXrooYfUsWNHSVJMTIxuuukm/e53v5MkrV27NmAxAgAAAAAAAAgtlk2oHjt2TJJ0xhlnuHz9zDPPlCSVlJT4LSYAAAAAAAAAoc2yCdVTTz1VkvT111+7fH337t2SpGHDhvktJgAAAAAAAAChzbIJ1d///veSpP/93//Vo48+qqKiIklSeXm5Fi9erMWLFysmJkbz588PZJgAAAAAAACwkB7KVUzuTulIhuORuy/QISHIWHZSqksvvVRPPfWU7r33Xv3xj3/UH//4RyUmJqqgoEARERH65S9/qUcffbTZHqoVFRWqqKhw/lxYWOiP0AEAAAAAABCEoooPa6P9HsWtq2j0QpwU1zkwQSHoWDahKkl33nmn0tPTdf311ys3N1f5+fnO1yIiIlRcXNzs9vPnz9fDDz/s4ygBAAAAtNbh/DKdKKlssKxT+2ilJsYGKCIACF2Z2XV5lJjcYqUHMJZAiSzPU5ytQlljFiqt35C6F+I6S4lpAYsLwcWyCdXCwkJNmTJFb7/9tn73u9/pzjvvVJ8+fZSVlaW//e1vWrBggdavX6+lS5fqmmuucbmPOXPm6K677mqwz7Q0/nMAAAAAweBwfpnGPrlFZVXVDZbHRkVq4+xRJFUBwCSd2kcrNipSd6zOcC4bZDug9+xSdnGFUgIXWsBUJKZLPYYEOgwEKcsmVGfOnKm3335bV1xxhV566SXn8gEDBujJJ59UdXW1Fi5cqNtuu02XXnqpOnbs2GQfdrtddrvdn2EDAAAA8NCJkkp1qjqm5y7sobQkR/I0K69MD3xwRCdKKkmoAoBJUhNjtXH2qAYjAnL2RUtbpMKyqrBMqALNsWRC9cCBA1q9erUk6YYbbnC5zk033aSFCxcqLy9PGzdu1Pjx4/0ZIgAgFORnSaXH636mGD0A+JWzjt2Wujp26ZI22u3KKh4hKSFgsQFAqElNjG1woyozl5tWgDuWTKju2rXL+bxnz54u1+nVq5fz+bfffuvzmAAAISY/S1p0jlRV2nA5xegBwG9c1bHL2p+htE23K7I8L7DBAS1pfCOW+osAEDIsmVAtLy93Pj98+LBOP/30Jut8//33zudRUVF+iQsAEEJKjzuSqeMXS8n965ZzMQQAfle/jl1FTvMTzwIBF9fZcQN27YyGy6PipFs+px0BACHAkgnVQYMGOZ+vWLFCY8eObbLOqlWrnM+HDRvml7gAACEouT/F6AEAgOcS0xyJ08Zlg9bOcCwjoQoAlmfJhOrAgQM1cuRIbd26VcuWLVP37t01e/ZsJScnq6ioSC+//LIee+wxSY5k6nnnnRfgiAEAAAAAYSMxjcSpL1FOAUCAWTKhKtX1TN23b58ef/xxPf744+rYsaMKCwud65x66ql68803ZbPZAhgpAAAAAABoM8optE6jiVbt+ZkBDAYIDZZNqKalpenLL7/Uiy++qLVr12r37t0qLCxUQkKCTj/9dF1++eW6+eabFR8fH+hQAQAIDifLG/4c0U5qFx2YWAAAALxFOQXvuZhoNU1SqWFXdUxS4OICLM6yCVVJiouL05133qk777wz0KEAABC8ItpJtgjp+8+l8oJ6L9ikTn2kSItN3uiDYX2bN2/WmDFjmh4qLk6pqan62c9+phtvvFHnnntug9eXLl2q6dOnO39u166dOnXqpLS0NP3iF7/Q1KlTNXToUFNjBULZ4fwynSipdP6ck1em9ADGAyAIUU7BOy4mWs3MKdZ1K7/R3+JTAxwcYF2WTqgCAAAPtIuWojtIb14oVZUFOpq28/Gwvk6dOik62tFz9/jx49q/f7/279+vZcuWac6cOZo3b57L7ZKTk2UYhvLy8pSTk6MdO3Zo4cKFuu666/Tiiy8qJibGJ/ECoeJwfpnGPrlFZVXVzmWDbAc0xi51jLXYjR8ACDb1JlotNwp0RAXNrw+gWSRUAQAIBxWFjmRqbe+Ek+VS/ndSYi+pnYUSfX4Y1rd27VqNHj1aklRdXa0dO3bojjvu0KeffqrHHntMQ4YM0ZVXXtlku23btql3796qqanRzp079corr+jZZ5/VsmXLdPz4cb377rs+iRcIFSdKKlVWVa0Fk4YoPcVRtismN0FaJ6XE2wMcHQAAQB0SqgAAhJPa3gmVpVI7u5Q8QIqOC3RUQSsyMlIjRozQ22+/rf79+ysvL0/PPfecy4RqrYiICJ111llauHChzj77bE2bNk3vvfeeXn31VU2dOtWP0QPWlJ4Sr8GpCY4fbMyHAAAAgk9EoAMAAAAIdp07d9Y555wjSfryyy893m7q1KkaPny4JOmZZ57xSWwAAAAA/IuEKgAAgAfatXMM7Kmurm5hzYYuv/xySdKOHTt05MgR0+MCACCUZeYUa9fhAufjcH4I1IMHYHkM+QcAAGhBcXGxtm3bJkkaMGCAV9ueccYZzudffPGFevToYWpsAACEouziCqVIun1VhnYbdRMoxUZFauPsUUpNjA1ccADCHglVAAAANwzD0H//+1/dfffdOnbsmCTp1ltv9Wofp5xyivP5999/b2p8CC7ffPON5s+fr/Xr1ys7O1tJSUkaNWqU7r33Xg0dOtTUYx09elSrV6/W+vXr9dVXXyknJ0dRUVE69dRTNW7cON1xxx3q1q2bqccEICk/yzExYq3cfYGLJcQVllUpRdLdvxqgLv0dZXcys4t1x+oMnSipJKEaBg7nl+lESWWDZZ3aR1v2b2/Pz5SO1KsNHtfZZ5OswvdIqAIAANQzfvx4RUdHS5Ly8/NVUVEhSbLZbJozZ46uu+46r/bXvn175/PCwkLzAkVQ+fjjjzVu3DgVFxdLkjp27KgffvhBq1at0po1a7RixQpNnDjRtOP17t3b+d6sPV5ZWZl27typnTt3avHixVq7dq1GjRpl2jGBsJefJS06R6oqbbg8Ks6RGIFPpCXFKr12ojqEjcP5ZRr75BaVVTUstWTFHsrVMUkqNexK23S7tKneC1Fx0i2fk1S1KBKqAAAA9Zw4caLJsqFDh2r58uUaNGiQ1/uz2WzO54ZhtCk2BKeCggJNmDBBxcXFGjp0qFavXq1+/frp8OHDmj59ujZs2KCpU6dqxIgR6tOnjynHrK6u1qhRo3TDDTfowgsvVJcuXXTy5Elt2bJFN910kzIzM3XZZZdpz5499FQFzFJ63JFMHb9YSu5ft5xeZoDpTpRUqqyqWgsmDVF6iqNXp1V7KFfFp2psxV8078IeSktyxG3Pz3QkWEuP8/lhUSRUAQAIZyfLmy6LaCe1i/Z/LEFi06ZNGj16tKqrq/Xtt99q3rx5evXVVzVp0iRt3rxZycnJXu2vpKTE+TwhgR42oejZZ59VTk6OYmJitG7dOvXq1UuSlJqaqjfeeEP9+vVTbm6u5s+fr7/97W+mHHPTpk36+c9/3mBZu3btdMEFF2jNmjUaOnSoCgoK9OKLL2ru3LmmHBPAj5L7Sz2GBDqK0NOonII9PzOAwaC+rLwylR+uq2Prz2H36SnxGmzxHsqd2kfrRFRXTf+gUpKjhMEgW7Hes9fVCob1kFAFACAcRbSTbBFS/ndNX7NFSF1OD+ukqiRFRkaqX79+Wrp0qY4dO6b3339fv//97/Xmm296tZ/6dVNTU1PNDhNBYPXq1ZKkSy+91JlMrZWYmKgpU6bo6aef1po1a/T8888rMjKyzcdsnEyt78wzz9Spp56qzMxMffHFF20+VrAK5AU+AJO5KKeQJqnUsKs6JilwcYW5jrFRkqQn1u/V7g/qaplacdh9IKUmxmrj7FEN6sHm7IuWttTVCob1kFAFACActYt2JE1rTjZcfrLckWStOSkpvBOq9S1YsECDBg3SW2+9pY8//li/+MUvPN52586dzufDhg3zRXgIoPz8fOffePTo0S7XOf/88/X0008rLy9Pu3bt0llnneXzuBITEyU1LDkRKrjAB0KQi3IKmTnFum7lN/pbPDcjAyUl3i5JeuGieFUkOnqJZuWV6YEPjlhu2H1zGk9+lZNXpnSTj5GaGNvgfGXmhsa5C2ckVAEACFftokXS1DMDBgzQlVdeqVWrVumBBx7Q1q1bPd523bp1khx1WOmhGnr27t3rfN6/f3+X69RfvmfPHp8nVEtKSvT1119LCs0kfu0F/sLJQ1SefIYk69bV86vGs9NL1P5E8KlXTqHcKNARFTS/PnwrrrMUFeeo9fmjdEkb7XZlFY+QZO2h+JLrya8G2Q5ojL3uBh7gCglVAAAAD8yePVurVq3Sxx9/rA8//FAXXHBBi9u8+uqr2rZtmyTptttu83WICICjR486n9dO/jRz5kytXLlSU6ZM0XPPPafu3bs71zl27JjPY1qwYIFKS0tlt9s1bdq0ZtetqKhQRUWF8+fCwkIfR2ee9C7xUg/rX8z7RXOz0zPDNBAWMnOKVW44EtSZ2cWebZSY5viMqHczJmt/htI23a7I8jxfhOl3ria/islNkNbV3cADXCGhCgAA4IHhw4dr5MiR2rp1q+bOnes2oVpTU6OdO3dqyZIlevbZZyVJF154oaZOnerPcOEn9Scdi42N1fHjx7V48WJJ0vPPP69HH31UHTt2dK5TXOzhRWwrZWRk6NFHH5UkzZkzRz179mx2/fnz5+vhhx/2aUwIAq5mp8/dJ62dwQzTQIirnfTo9lUZ2m3U9fiNjYpUp/YejFRKTGvwGVGR49vvsUBpMPmVLT6wwcASTEmoVldXm1JcHwAAIJjdfffd2rp1qz755BNt2LChwWsjRoyQ5KipefJkXW3aq6++Wi+99FJI1rIMRoFul3bu3FlTpkzRmjVrdO211yopKanB+8GXcnNzNWHCBJWXl+uCCy7Qgw8+2OI2c+bM0V133eX8ubCwUGlpJNdCFrPTB17uvoY/U3ahVer3sIzJLTa93mUoqZ306O5fDVCX/uc4lzORH9A2piRUe/TooWuuuUZTpkzR0KFDzdglAADwhcYXco3VTkp1skJqF+OfmLzRUvw+dskll2jAgAHau3ev5s6dq5kzZzpfy83NVWRkpBITE9WzZ0/9/Oc/19SpU0OyhmUw83e7tH379s7nZWVlkqRly5Zp2bJlTZZLUny8b3q9FBUV6eKLL9a3336rM888U2+99ZZHiWW73S67nSGNYY0En3/8WItSa2c0XE7ZBa90ah+t2KhI3bE6w7lskO2A3rPX9cSEa2lJsUpPpUwKYBZTEqo5OTlauHChFi5cqEGDBmnq1Km65pprnHWkAAAIeo0n6whw4s507i7krCgqzvH7mGj06NEyDKPF9Ww2m/bs2dNgWUs1KuFf/m6X1t/v0aNHNXjw4Cbr/PDDD87nXbt2NT2G8vJyXXbZZdq+fbvS09P1wQcfKDEx0fTjIMSQ4PMvF7UoKbvgvdTEWG2cParhjOz7oqUtdT0xAbTscH5Zg/9HEr2WvWVKQvXSSy/V+++/r6qqKu3atUv33nuv/vCHP2js2LGaNm2afvvb33LnGwAQvJqbrMPkxF3AuLqQc6W2h2pir+DsoSrRewrN8ne7dMCAAc7n+/bt09ixY5uss29f3Q2a0047zbRjS9LJkyc1ceJEbdq0SWlpadq4cSOdGuCZ5hJ8h/7VcDmfu+ZoVIsSrZOaGNsg6ZOZSwII8Mbh/DKNfXKLyqqqGyyPjYrUxtmjSKp6yJSE6j/+8Q+dOHFCb775pl5//XV9/PHHqq6u1vr167V+/Xp17NhRV155pa677jr9/Oc/N+OQAACYx9VkHVLoXUB6ciFXWSq1s0vJA6ToOP/EBZjI3+3SxMREnXHGGdq5c6e2bNmim2++uck6mzZtkiQlJSW57MHaWjU1NZoyZYreeecdde3aVRs3blSvXr1M27+vNe4d4/Gs0zBP4+8Feq0CQMg7UVKpsqpqLZg0ROkpjlJEmdnFumN1hk6UVJJQ9ZApCVVJ6tSpk2bOnKmZM2fq+++/18qVK/Xaa6/pP//5jwoKCvTyyy/r5ZdfVu/evTVlyhRdc8016tevn1mHB9CIqy787tC1H/gRk3UAIcHf7dJJkyZp586devvtt5WVldVgUqeCggKtWLFCkjR+/Phm65rWn7jswIED6t27d7PHvfHGG7Vq1Sp17txZGzduVP/+/ZtdP5g01zvGo1mn4RsMSweAsJGeEq/B1NVtNdMSqvWdcsopuueee3TPPffo66+/1muvvaaVK1fq4MGDOnDggB555BE98sgjGj58uKZMmaLJkycrOTnZF6EAYcndRYo7dO0HAIQqf7RLZ82apYULFyonJ0eXX365Vq1apfT0dB05ckTXX3+9srOzFRMTo/vvv9+03+vOO+/USy+9pISEBK1fv97Unq/+4Kp3jMRNXn9zXUMvWak9SJwCANAcnyRU6xs4cKDmzZunefPm6dNPP9Vrr72mVatW6cSJE9q+fbu2b9+u2bNn6+KLL9YNN9ygX//61w3uzgPwnruLFFfo2g8ACBe+apcmJCTorbfe0rhx4/TFF1+oX79+SkhIUGFhoQzDUFRUlJYuXao+ffqY8nscOnRICxYskCRVVlZq3Lhxza5/9OhRU47rC016x+RnSUdCeILAIEINPQCAr4Xy5Fc+T6jWqqio0OHDh5WVlaWSkhLZbDbnbLpVVVV655139M477yg9PV2vvPKKzjvvPH+FBliKNx9IdOEH3MjPajqcEQ2dLG/4c0Q7qR3DcBEafNEuHTlypL766ivNmzdPGzZsUHZ2trp27aqRI0fqvvvu09lnn21a/DU1Nc7nZWVlKisrM23fARUOEwQGEWroAQB8KdRv3Pk8obpp0yatWLFCa9euVWFhoSTJMAxFR0frkksu0VVXXaVdu3Zp6dKl+u6777R//36NHTtWW7du1YgRI3wdHmAp/vxACuU7SQhzXLA3L6KdZIuQ8r9ruNwWIXU5naQqLM3X7dK+ffvqlVdeaXV8tUndlvTu3dvjdS3F2wkC690Mi8ktVg/l+iHI0MMNeASTzJxilRsFjudeTlRnz8+UjtQbnRdqk4vCZ3ooVzG5OyXbj+8fOluYItRv3Pkkobpr1y6tWLFCr7/+ug4fPiyproE4fPhwTZs2TVdddZU6deokSZowYYL+53/+R6+99ppuu+025efn63/+53/0z3/+0xfhAZblyw+k+g2W4yWVumn5FyF7JwlhztsL9nDTLtqROK05WbfsZLkjwVpzUhIJVVgL7VILammCQBcz0adL2mi3K6t4hCSSg4DVZBdXKEXS7asytPvHhKrk2UR11TFJKjXsStt0u7Sp3gtRcY5J1mjfWULjDj3eJtRbK6r4sDba71HcuopGL4ROZwuzz623na9C9cadaQnVI0eO6PXXX9eKFSu0c+dOSXWN1e7du+vaa6/VtGnTdPrpp7vc3maz6dprr1VFRYVmzJihf//732aFBoQcMz+QOrWPVmxUpO5YndFgeWxUpF69/hx1/rEBU5u43XYgTyeYPAKhoKUL9nDWLlouE6eUAYBF0C61hlb3CHIxE33W/gylbbpdkeV5PogUgK8VllUpRdLdvxqgLv3PcS735FqjKj5VYyv+omVX9VV6l3qfJ2tnOD4nSKgGveZGYraUUG+ryPI8xdkqlDVmodL6Dal7IUQ6W5h9bkN9GL83TEmojh07Vlu2bFFNTY2zsRoTE6PLLrtMU6dO1a9+9StFRER4tK/aGlW1w7AAeKb+XSZv7jilJsZq4+xRLd5hai7xGm4fnEAw8unwX8oABExIDuv2Mdql1tDmHkGJaQ0udCty/NOTKVzUb0vG5BYrPYCxILykJcUqvRUdR44oWeXJZ0g9Qq8XXLDKyitT+eG63sRt6WjjblJlf3beqUhMD8nOFmaf2+ZGzTbufOWvXsaBYkpC9aOPPnI+P/fcczV16lRNmjRJCQnef5hFRUWZERIQEjzpmt9cotPTO06pibEtfpi6SrzSaxUIvNrEUHV1dQtrtgFlAAKm9u/qaQIQtEutItR7BFmVq3blINsBvWevG5INmKLRBKH2/MwABgNvdIx1fDc+sX6vdn9Qd21oRkebUB0aHgzMPrf19+cuJyH5p5dxoJiSUE1LS9OUKVM0depU9evXr0376tu3b4OZS4Fw5WnXfE97mJqhceKVXqtA4EVFRSkqKkrFxcWKj49veYPWclcGAD5VVFTk/BvDM7RLrSVUewRZlat2Zc6+aGlL3ZBsoM1cTBCaJqnUsKs6JilwccEjKfF2SdLCyUMcvYIVWhMNwXvuchJSaHe2MiWhevDgQdlsNjN2BeBH3nTN96SHqS8012uVL1PAP2w2mzp06KD8/HwlJCQoNpb/d6GirKxMhYWFSkxMpJ3lBdqlQNs0bldm5vK9ApO5mCA0M6dY1638Rn+LTw1wcPBUepd4SiyEoMajYj1NiAYqJxFIpiRUabQCvhPswx7C8YMTCDbJyckqKyvToUOH1LFjR3Xo0EGRkZG+/X6urJBOGlJ5hVTDcHSzGIah6upqFRUVqbCwUHa7XcnJyYEOy1JolwK+Yc/PlI40GglBiQa0Rb0JQsuNAh1RQfPrAz9qbdLP1ez0OXll1IkWo09bw5SEKgAACJzIyEilpaUpNzdXRUVFys/P9/1BqyulohypMFKKpBSA2aKiopSYmKjk5GRFRkYGOhwAYaw6Jkmlhl1pm26XNjV6MSpOuuVzkqptlbuv6TKS1UATbUn6uSupN8h2QGPsdbVhwxWjT71HQhUAgBAQGRmprl27KiUlRVVVVb6v+5j9X+n92dLE5VJKH98eK8xEREQoKiqKnpYATJeZU6xyw9EL0NPZl6viUzW24i9adlVfxxDfWrn7pLUzHMO3Sfy1TlxnR1J67Yymr0XFSZOWS3HJDde34rluNAGVywSyCeq/p2Nyi+l1GILakvRzV1IvJjdBWldXGzacMfrUO6YkVM8//3zZbDa98sor6tWrl0fblJeXa9y4cbLZbPrwww9bfWzDMLRy5UqtWLFCX375pfLy8pScnKz09HT98pe/1L333qvoaHrOAFbhahiGFNrFrAEz2Ww2/3zvtbNJxVmOf2NifH88wEOBbJcCwSq7uEIpkm5flaHdRt2wak9nXz6iZMfkM9RLNFdimqOHb/1koySV5kqrp0grJjRcbsUewS4moJLk+F3iOptyCFe9FgfZDug9e917H6GjrUm/JiX1bD6c1BUhzZSE6ubNm2Wz2VRSUuLxNtXV1c7tWqu4uFi//e1vnQ1fm82mhIQEHT16VEeOHNHWrVt10003UXsMQcdV0jDUEoae9Hpo/Du7G4YhUbsFAOCZQLVLgWBWWFalFEl3/2qAuvQ/x7k81NqflpSY5jpB2jjRatUewS4moJKkoyfbK7eko1TiXY9pV1z1WszZFy1tqXvvA4DZLD3k/6qrrtKHH36oxMREPf7447r66qvVoUMHVVVVac+ePVq2bJmiosK7DgaCj7ukYagkDN3VtXGl8e/sbhgGtVsAAADaLi0pVulBPNkp6nGXaLWqehNQ1V0PNRz672mPaVca91rMzOWaATBL/Rsebbn5EWoCllAtKiqSpFZPtPDOO+/o3XffVVRUlDZs2KDhw4c7X4uKitIZZ5yhv/zlL6bECpjJVdIwlBKGru4Qu9Lc79xkGAYAAD7U1nYpAMBz7jpR0GPa+lwl2/i7Wldzk4C19uZHKAlYQvXLL7+UJCUktC5p8sILL0iSZsyY0SCZClhFKCcNKWaNoOKniRAAWFdb26UIHll5ZSo/XNBgGRfz8LVwKOflC6F8PRRumhulGCojMa2i8eeR2eU0JD7fapmaUPWk7lR5ebm2bdumO++8UzabTWeccYbXx6msrNTGjRslSddcc43X2wP+5M0HGl3pAZP5YSIEAMHJX+1SBIeOsY4yX0+s36vdHzS88ONiHr4U6uW8AE+4S7yF0khMK2ju88ischqo06qEqqvhUIZhaPDgwV7va8qUKV5v89///leVlZWKiIjQ0KFDtW7dOj3xxBP6z3/+I0k67bTTNHnyZM2aNUt2u93r/QNm8fQDLZy70pNEhk+5mQhBcZ1Dqy4ZEMYC3S5FcEiJd7T5F04e4piN/kdczMPXQr2cF+ApEm+t03hkRVt6f1JOw79alVA1DMOr5a5ERETolltu0fTp070+flZWliSpU6dOeuGFF3TXXXdJkhITE1VSUqLt27dr+/bteuutt7Rx40a1b9/e62MAZvD0Ay0cu9KHcxIZAVBvIgSYrHEJBZLV8LNAt0sRXNK7xEs9GEIM/2P4OgBvuBtZYUbvdj6P/KNVCdW5c+c2+Pnhhx+WzWbTTTfdpJSUFLfb2Ww2xcTEKC0tTSNHjlRqamprDu+cOKCsrExz5szRhRdeqOeff159+vRRZWWlli9frptvvln//ve/NWfOHD3zzDMu91NRUaGKigrnz4WFha2KB2iJJx9o4XZHLxyTyEBIievsKJ2wdkbD5VFx0i2fk1SF3wS6XQoAAOAtVyMrAt67vfHcExKdJZphWkJVkm655RYNHDiw7VG1oKamRpJUWlqqlJQUrVmzxtkLNTo6Wr/73e+0a9cuLViwQC+99JIef/xxxcXFNdnP/PnznbED8L9wSyIDISUxzZE4bTzh19oZjmU0vOAngW6XAgCCFxPVBSczJ05ytw+r/J2DZmRFc3NP0FnCJVMnpfKX+kP4r7/+epdD+qdNm6YFCxaorKxMX3zxhX7xi180WWfOnDnOcgGSo4dqWhpvEiBYWfVLEghZiWk0rgAAQNDx50R1jZODUphcp7Sy7JPZEyc1V0qOieG84GruCTpLNMuSCdXk5GTn8/79+7tcp3fv3s7nR44ccbmO3W5n0irAAviSBAAAAOApf01U11xyMGSvU9pY9snsiZNclZIL+NB5b9RLTMfkFquHcgMYjJh7wgumJFRrh1o1V6fKTP369XM+t9lsfjkmgMBp7kty24E8nWAGQwDAj/zdLgUAqwqHnpW+Hk7tKjkY8GReozqY9vxMc/dvUtknMydO8rSUXA/lKiZ3p2Sru35s0tPWX1wkptMlbbTblVU8QlIQlAFAs0xNqPpL165d1bt3bx08eFD79rl+8x88eND5nEkGYDZXjQ9XzKgFA4fGX5L0WgUAuOLvdikAWFHY9KxslCzzVQ/AoJlV3UUdzDRJpYZd1TFJ5h3Hy7JP9a+LA3WNHFV8WBvt9yhuXYWLF+McCU5/cpGYztqfobRNtyuyPM+/sbSkleUdQp0lh/xL0m9/+1stWLBAS5Ys0YMPPthk0qmlS5dKctRbHTZsWAAiRKhonDw9XlKpm5Z/0aTx4U5ra8GgeZYf2gEAAGAhjZMgMbnFSg9QLGi7oOxZaSY3w9JDvgegizqYmTnFum7lN/pbvP87mjXXCcbf18iR5XmKs1Uoa8xCpfUb0vDFQCUIGyWmK3L8mGxu1JPZZU/dNpZ3CHWWTajOnj1bL774oo4ePaorr7xSixYtUu/evVVZWanly5frueeekyTdfPPNio21+JcBAqa5O7evXn+OOnvwJRBqw2aCiadDOwAAANA67hIig2wH9J5dyi6uEAU2rCtoelaazdWwdAVxD0Cz1auDWW4U6IgKAhKGq04wUmCvkSsS06kR6qIns6SmPXVNKu8QqgKWUD148KCuv/562Ww2ffjhh15vf8opp2jFihW66qqr9L//+7/q06ePOnXqpJKSElVWOv6znn/++frTn/5kdugII2YXzAYAAMGnre1SIJS5S4jk7IuWtkiFZVWhm1D1pAdXMxr36uUaws9cDEv3aw9ASKITTFBy0ZNZkuueul6WdwgnAUuolpSUaPPmzW2aVGr8+PHasWOHnnjiCX344Yc6duyYYmJiNHz4cF1zzTWaMWOGoqKiTIwa4Spk79wCAABT2qUIEn6qlxhuXCVEMnNDPEHiaQ8uF6j131RmTrHKDUcvSeaZgEuNb2C4E4b1O93N4dLmmzT1ejLDe5Yd8l9r0KBBWrJkSaDDAAAAABAo4VovEb7jTQ+uRqj1X6e2JMTtqzK026gbds48E2jA3Q0MV8Ksfqe7MoRSeN+kCQaWT6gCAODUxqF5AACLCvd6ifCdVvbgYpizQ21JiLt/NUBd+p/jXE75gxDlbmKjlpKf7m5guNp/mNXvdFeGMFxv0gQTEqoAgNDQhqF5AIAQQL1EIGilJcUqnRJqocvdbPCSdz1KPb2B0Thx6yZpW7+8RE5emdJb3nPQ8rQMYQ/lKiZ3p2SrS776pEyCh3+DUOZVQvXUU0+VJNlsNn3zzTdNlnujqqrK620AAHCrDUPzYDIaWPAD2qUAwlKwf8c2Gi1kz88MYDCBFVaTkrkZJWB6j1J3idtGSVtXdYwH2Q5ojF3qGBu68+xEFR/WRvs9iltX0egFE8skNPc3mLRciktuun4wfUaZyKuE6sGDByWpScH+gwcPymazyTAM0wIDAKBVKK4eOB42cgEz0C4FgoM9P1M64uOeULDGd6yL0UJpkkoNu6pjkgIXl5+F7aRk/pgN3lXitjZpe+hfzuWpkjbN6KvcyBTnajG5CdI6KSXe7tsY/axBL9wjhzXAVqGsMQuV1m+IY6GL89Omsmiu/galudLqKdKKCU3XD6bPKJN5lVCdOnVqs69fdtllSkxM9Ghf+fn5+sc//uHN4QGfazx7HjNQAoAXmmvkhlGtK/gH7VKgGX7oJVgdk6RSw660TbdLm+q9EMIXzwFlhe9YF6OFMnOKdd3Kb/S3+NQAB+c/TErmY40Tt25uNnSLilO3+p9F9YfAh4DmeuHau59e18GkuZsxrS2L5ip57o8eykHGq4TqkiVLmn193rx5GjhwoEf72r17Nw1XBBV3s+cxAyUAeMEfvRMA0S4F3PJTL8Gq+FSNrfiLll3VV+ldfkxUhPjFc8BZ5Tu23mihcqNAR1QQ2HgCgEnJ/MgKNxu8lJVXpvLDjv837jp5uUrcu+yF664cg9mjCazy+WQiJqUCfuRu9ryQrnUDAACA0OLHXoJHlKzy5DOkHkw2ZEWNJ6+JyS1WD+UGOCqgFUIkmVdb3/WJ9Xu1+4O6RKm7Tl5NEvfueuGGyPkJNiRUgUY8nT0PwSusCsADAAC4Qi9BNMPV5DXpkjba7coqHiGJ6yHA32p7li6cPMRxs+pHXM8GJ1MSqrfddptsNpuSk5NbXhkAfCRsC8ADAJxolwJAU43ninA1eU3W/gylbbpdkeV5AYoSgCRHGRV6/gc9UxKqCxYs8HqbTp066brrrmsyMysAtBYF4AEAtEsBBLNAjKRyNVeEq8lrKnI8n5D36KH9Kj5xrMEye36mGFQM+FGjCQiVuy9wsTSnXlyhVFokYEP+e/TooaVLlwbq8ABCFAXgAQDeol0KwNcCOZLK1VwRLiev+ZE9P1M64n5G9NzsI+q4bpq62SqavFZq2FV4sr26mRc+AFdcTEAoSYqKc0w4FQziOjviWTvDuSiUSotQQxUAAPhe4zvmZs8sCgBoIDOnWOVG87NEw3+aG0m17UCeTqQ0TGD6oudqg7kiXExeUx2TpFLDrrRNt0ub3O8nWVKp7Pr03L8ppVvdRGdZeWV64IMj+ltkCgnVAOP//4/qtz+Dtfdma7mYgFBScLWxE9OkWz5v0Is2lEqLkFBF2GpcRyisv2gAwFdc3JmW5Fh2y+fB0+ADgBCRXVyhFEm3r8rQbqNuIip3s0TDfxqPpHLXa1UKzBwAVfGpGlvxFy27qq+jhqMc76ffL/9C5SdrGqxb1i5Ry3/ymwbxlR8u0JEP/s9v8aIp/v//qLn2Z7D03vRG46H9Ul2CuN4EhEEpMa1Be9+b0iLBjoQqwpKrOkJSGH7RhJFA1KsCXGl8M0cK8fejizvTyt3naOCWHiehCgAmKyyrUoqku381QF36n+NcHtLfNRblqteqZMIcAI2SLzG5xRpkO+AY5l/bM9VNb70jSnbMLv7jhDjZhwv0RVVug3IBUui9n0Klfcb//x+5an9KwdV701PuhvZL1k0Qhwi/JlQPHDig3Nxc9e3bV0lJSf48NNCAqzpCUhh+0YSBQNarAhpr7mZOSL8fG92ZBoIB7VKEurSkWKWnWrs+XTgwvf6/i+RLuqT37JLWNVrXi2RMg3IBISYU22dB9/8/EKWfrNz+bFyqwNXQfsmaCeIQYkpCtaCgQIsWLZIkXXXVVerTp0+D1zdt2qSZM2fq22+/lSRFRERowoQJeuGFF5SYmGhGCECrhHLDAA7e1KsioQ5fc3Uzp829UAA0QLsUQFhzUVcxM6dYt6/K0MLJQ5xD+SWRjPkR7TMfam7o/aTlUlyy4+dQq2/aWs2dr57n8v81yJiSUH377bf14IMPqnv37rrnnnsavLZ371795je/UWlpqQzDkCRVV1frzTff1KFDh/TJJ5/IZrOZEQYAuORpvSor34WGtXAzB/Ad2qVwJSuvTOWH6+oJchMVIa9eXcVyo0C7jYIGQ/mbU79UVjjNM0H7zAdcDb0vzZVWT5FWTGi4LsPXQ6tUQRgwLaEqSZMnT1ZUVFSD15566imVlJTIZrPp3nvv1bnnnqu1a9dq+fLl+uyzz7Rs2TJNnTrVjDAAwCPN9VrlLjQChTq/gDlol6K+jrGO98AT6/dq9wd13/vcREVrhfLEts11OmCeCfd6KFcxuTvr6tNKvkmAuZqYyAqJNldD70kaumflUgVhxpSE6vbt22Wz2TRq1Kgmr/3jH/+QzWbT7373Oz3++OOSpMsuu0xFRUX6+9//rpUrV9Jwhc+FcsMHrWN6vSqglegxDZiLdinqS4m3S5IWTh7i6J0nbqL6RSDqJfqBlSa2zcwpVvmPs7x7eu3jbpIsbvK6F1V8WBvt9yhuXUWjF+IcSUOz3vfuJiYy+zj+QtIQIcCUhOrRo0clSWlpDf9DHDp0SNnZ2bLZbLrlllsavHbdddfp73//u7766iszQgDcslLDB0DocDVbrKsLGnpMA+aiXQpX0rvEezTUGd6r/90WVRytfu1iFeGq/l+wJ30a9/5zUdPRChPbZhdXKEXS7asytNuoK3Ph6bUPnQ68E1mepzhbhbLGLFRavyGOhbn7HDUwS4+b9553URvXeZxD/3K+d+35meYcD0CLTEmo1tagKi8vb7B827ZtkqTk5GSdddZZDV7r2bOnJCkvL8+MEAC3rNDwQfBg2DVao3Hy9HhJpW5a/kWTGzmS6wsaLl4A89AuBfzD3QiLU6Oe0Kop/Zy9g32SXDJbc73/XNR09FetTU/bpVn7M1SR41g3/7tdSpF0968GqEv/c1rc1hfCsQZrRWK6s2atT9WrjetqAqM0SaWGXdUxSb6PBQhzpiRUU1JSdPjwYe3bt0/nnnuuc/mGDRskST/72c+abFNR4egS36FDBzNCAFpEkXE0h2HXaK3mesG/ev056twoeUqSHvAt2qWAfzQ3wiK7/WlKsVKPYFe9/6SAlSrwtF169GR7dTTsStt0e4P1Sg27Tu/bW938fO1DDVY/czGBUWZOsa5b+Y3+Fp8awMCA8GBKQvUnP/mJ1qxZo2eeeUYTJkxQfHy8Dh48qNWrV8tms+kXv/hFk2327t0rSerevbsZIQBAmzDs2oI8GJrnD/SCB4IL7VLAf0JuhEX93n8B5Gm7NDcyReMr/qJ5F/ZQWlLd3yG+U1d169kvKOKWrN0mCvrRa41qkZYbBTqigmY2AGAWUxKqN9xwg9asWaOMjAz16tVLffv21X//+1+VlJQoOjpakyZNarLNRx99JEk67bTTzAgBANrM3UVB0DekwpGXQ/PM5G6SO3/0gndVl5X3I9AQ7VIAocDTZPURJatL/3OUHiQj8UIlyc7oNQAtMSWheuGFF2rWrFl69tlndeLECW3fvt352p/+9Celpjbsbl5SUuKcZXXMmDFmhAAApqMhFcQCNDQvkJPcNXfsF6YMa1BawDJJ1hCdBRqBRbsUvsbNLcD6svLKVH7Y0ZOTSUMBtIYpCVVJeuaZZ3TxxRfrjTfe0NGjR9WrVy9dddVVGjVqVJN133//fZ166qmSpN/85jdmhQAApqIhZQF+Hprn7+H9jSd1aHzs2smvpr7yeYPtgj7p72ISBUnWmAUalkC7FL7S3M2toP7cRcgIxwmfzNQxNkqS9MT6vdr9QV0b35tJQ+uf95y8MqW3IR5u0ADWZVpCVZIuvvhiXXzxxS2uN2HCBE2YMMHMQwOAT4TKsCWYy9fD+5vrHT2iT1KD96Qlk/4uJlGwxCzQsBTapfAFVzfWLPG5C8tjwidzpMTbJUkvXBSvisS6tlx8p67q1sL/X1d/g0G2Axpjr0vUeoMbNIC1mZpQBYKBu/qGAGAV3kzqYNmkf6NJFADASvxRNxuoLxQnfAqIH0fJpG26veHyqDhp0nIpLrnhuvXaKq7+BjG5CdK6ukStN7hBA1gbCVWElEDWNwQAM1k2UQoAAHyCtoEJXI2SKc2VVk+RVjQareCiFFGTv4EtXm3FDRrAmkioIqT4u74hgNBGj3cAAIAQ42qUjC9KEdWbfDMmt1g9lNu6/QAISiRUEZK4ywegrejxDgDgxhoQJswsReRi8s10SRvtdmUVj5Bk3nUqn1FA4JiaUP3hhx+0du1affnllzp27JhKS0tlGEaz29hsNn344YdmhgEAQJvR4x2wNtqlaCtvb6x5kshw9R3iapZvd+sCsAAXZQWy9mcobdPtiizPM+0w3PwHAsu0hOpjjz2mRx55RJWVdY2B5hqtNptNhmHIZrOZFQIAAKajxztgPbRLYQZPb6y5m33dlcazd7tLiLhaF0AQyM9qWhrAlUY9XityHDdcsvLKVH64QFLbe5Ny8x8ILFMSqq+88ooefPBB58+dOnVSenq64uLizNg9ACDcedp4BRD2aJfCpTbUMmzpxpq72dcbczV7t7uECDN9BweGU6OB/Cxp0TlSVWnD5VFxjmH+zegYGyVJemL9Xu3+oO495ao3aQ/lKmff58rMrfu/b8/PlLuCBNz8BwLDlITqokWLJEnt27fX66+/rksuuSRgd/gvuugiffDBB5KkJUuWaNq0aQGJAwBgkjY0XgGEn2BqlyII+KmWoTezr9dPytU+D7WESP3fMSa3WOkBjKW1GE6NJkqPO9qj4xdLyf3rlsd1brH+akq8XZK0cPIQlSef4VzeuDdpcnW2NtrvUdyWiqaHN+wqPNle3dr4awAwhykJ1T179shms+lPf/qTLr30UjN22Sqvv/66M5mK8MBdYyAMtKHxCgtq3PuYvzO8FCztUgQJL2oZ+rpd6a40QCgl6Fz9joNsB/SeXcourlBK4ELzGsOp4VZyf6nHkFZtmt4lXurh/uZJt3Ylkq1CWWMWqiKx7lZEVl6ZHvjgiO49Hqf0SHNKBgBoG1MSqnFxcSovL9e5555rxu5a5cSJE7rzzjt1+umn67///W/A4oD/cNcYCDNtaLzCAlz0IpPkWHbL5yRV4bFgaJciyLipZVifP9qV7koDtDVB1zgRnJNXFrAeoa5+x5x90dIWqbCsylIJ1Vqh1nsYAebhjeO0fkMatHtj88t04qMtIX1DBrAaUxKqZ511ljZt2qSSkhIzdtcq99xzj7Kzs/Xaa6/pl7/8ZcDigP9w1xgAQoiLXmTK3edIsJYeJ6EKjwVDuxTW4692pTelATzhKhE8yHZAY+x1NRv9rfHvWFsHsv5kPBJtdlhE/QRoW2r4t/HGsa9uyABoPVMSqrfffrs++ugjLVu2TBdccIEZu/TK1q1b9corr2j8+PEaO3as34+PwOKuMQKh8RAbGjMINpZ8jzbqRQa0RqDbpbA2j9qVjSdKlAJWnsRVIjgmN0FaV1ezMdCam4xn4+xRDb6bGve2lXz0/cVkl2hJcwnQ1tTwN+HGsdk3ZAC0jSkJ1UsvvVRz587VI488oqSkJD388MPq2LGjGbtuUWVlpW688UbFxMToqaee8ssxAYSv5uqfNb4ogLWESk1m3qMId4FslyIMNDdRYoDKk/RQrgZHHFC67ceetbYjfo+hObWJ3RcuildFoiNZnZVXpifW71XZd/FSqSPu7OIK3bb8C5WfrGmwfVm7RC2fPcG87y8mu4QnXCVApbbdPOHGMRBSTEmoXn/99ZKkU089Vc8884xeeOEFDR8+XGlpaYqJiWl2W5vNppdffrnVx54/f7727NmjP/3pT+rVq1er9wMAnnA13CYzu1h3rM7QtgN5OlFvmKBkkV6BCKmazM29R0+UVPJ+RMgLZLsUYcDVRIkBLE8SVXzYMSP4ukYzggdTcvDHnn5pm253LkqXNMYuaV3daimS1kRKimy4ealhV9axs6XEgebEw2SX8BQJUADNMCWhunTpUtlsNkmSYRiqqKjQp59+2uJ2hmG0qeG6d+9ezZ8/X6eeeqruueeeVu0D1hEqvcdgfY2H27jrESjRK9AqQq0mM0PCEM4C1S5FmAmSiRIjy/MU9+OM4Gn96sUTTMlBFz39MnOKdfuqDN39qwFKS6qrsfrE+r1aOHmIYyZ0SVn7M5S26XZFlueZH1eQ/A0B0+q0AvArUxKqPXv2dDZc/enGG29URUWFnn766RZ7HLhSUVGhioq6u7mFhYVmhgcThVLvMYQed0Xi6RVoPdRkBqwvUO1SWE/9SZKsfqO+IjE9uJODjXr6xcaV6dt2xZr+QaWk+nVV0xXba5j0Y7upIsfafxegWWbXaQXgV6YkVA8ePGjGbrzyyiuvaMuWLbr44ov1m9/8plX7mD9/vh5++GGTI4MvhFrvMYSe5noEWnJyIACwqEC0S2EtzU2SFGw36ltK9ObklSndT7GYydsZy+35mdKRemWVgqkHLtBavqjTCsBvTEmo+ltOTo7uueceRUdHa+HCha3ez5w5c3TXXXc5fy4sLFRaGh9cwYzeY7ASJgcCTOJq+BsXGwBaqXaSpIWTh6g8+Qzn8jbf8Gz8WdWGz6nmygnVN8h2QGPsdUliK/GkPE11TJJKDbuj/uqmuuU17WIVMWsb3wOwPuq0ApZlyYTq/fffr7y8PP3hD39Qv379Wr0fu90uu91uYmQAUIfJgYA2cjcUTgrojNoAQkN6l3iphwk36psbttv4cyo/y6PeaO56cDYWk5sgratLEoea+K59dEnNU4o9me9clm47rIV6Tnl7tiip5+C6lbnRBgDwI0smVPfv3y9Jevzxx/X444+7XW/69OmaPn26evXqxfAvAAHB5EDBiUnuLMLdULgAzqgNAE24+qyq/Zw69K+65aW50uopjhnm63Nzg8ijNoQtvvnXLS41MVbLZ09o8J19+OA+la5/WUnv39JwZW60AQD8yPSEanZ2tt566y1t27ZN2dnZKisr05IlS9SrVy/nOt99951KSkoUExOjU0891ewQAABwi0nuLIahcGgDf7dLv/nmG82fP1/r169Xdna2kpKSNGrUKN17770aOnRoW3+dJnbs2KF///vf+uyzz/TZZ59p3759MgxDU6dO1dKlS00/HprR+LOquV6r166R4pIdP3ODqEVNE8v9NbbiL1p2VV9HL2PJdQJbotcqAMBnTEuo1tTUaO7cuXriiSdUWem4g2gYhmw2m0pKShqsu2rVKt1///2y2+06fPiwOnXq5NWxNm/e3OzrtTO7LlmyRNOmTfNq3wCAAHI1FNJV/cw2YJI7IPT5s11a6+OPP9a4ceNUXOzo8d6xY0f98MMPWrVqldasWaMVK1Zo4sSJbfvFGjn//PNVUFBg6j7Diok1T5tgshmfOqJkR/3b2pIN3pRdAADABKYlVKdPn64VK1bIMAzFxMQoPT1du3btcrnurFmzNG/ePJWUlGjNmjW64YYbzAoDAGBV+VnSonOaDoWUHBdEcZ1NPVw4TnLXuLQBSWSEKn+3SwsKCjRhwgQVFxdr6NChWr16tfr166fDhw9r+vTp2rBhg6ZOnaoRI0aoT58+bf31nKKjozV8+HD99Kc/1U9/+lM99dRT2rFjh2n7D1n+Sr5508Pe08n3Gt94NPmmo2U1V3aB3r8AAB8wJaH6zjvvaPny5bLZbLrvvvs0d+5cxcTEKCIiwuX67du31xVXXKGlS5dq/fr1JFQBhB0SWy6UHnckU8cvlpL7N3yNHj1t4m626NioSG2cPYr3HkJKINqlzz77rHJychQTE6N169Y5SwqkpqbqjTfeUL9+/ZSbm6v58+frb3/7W5t+v/q+//57RUfXlSpZvHixafsOacGUfPNm8j13Nx59cNPRkigRAwDwI1MSqrUNw9/+9reaP3++R9uMHTtWS5cuVUZGhhkhAIAlkNjyQHJ/qceQQEcRUlzNFp2ZXaw7VmfoREkl7zuElEC0S1evXi1JuvTSSxvUZ5WkxMRETZkyRU8//bTWrFmj559/XpGRka06TmP1k6nwUrAk31qafK9+TdDcfa5vPHLTsXmNe/HSqxcAYAJTEqrbtm2TzWbT1Vdf7fE26enpkqTDhw+bEUIDhmGYvk8AMAOJLQSKR7NFW40v6x/CsvzdLs3Pz9fOnTslSaNHj3a5zvnnn6+nn35aeXl52rVrl8466yyvj4MA8ccQe1fJ3ebKEvQ8l886T7TU+5devQCANjAloXrixAlJ8qomlFl35hF6DueXNUg2SU2HRwNecTXRUQATLyGZ2AL8iclH0Ax/t0v37t3rfN6/f3+X69RfvmfPHhKqVhHIIfZMatV27s6hxHkEALSZKQnVpKQkZWdnKy8vz+NtahufXbp0MSMEhIjD+WUa++QWlVVVN3ktNipSndoztA1eau5iKMgSL9RVBTwUTPUPEXT83S49evSo83m3bt0kSTNnztTKlSs1ZcoUPffcc+revbtznWPHjnl9DF+qqKhQRUWF8+fCwsIARhNk3NX29lcyLljKEgQpj9pNXpzDxp066NABAGiOKQnVs846Sxs2bNB7772nsWPHerTNq6++KpvNpnPOOceMEGBRrhouZVXVWjBpiNJT4husS3IJreLqYijIEi/UVQVagUQD3PB3u7SkpMT5PDY2VsePH3dODvX888/r0UcfVceOHZ3rFBcHV5Jm/vz5evjhhwMdRvCoP6S/9jm1vYOKL9pN7jp10KEDsCbDMFRVVaWamppAh4JGqg2byuPTHP+Wl7tdLyIiQlFRUbLZbH6MzjumJFQnTZqk9evX6/nnn9ell16q888/v9n1//KXv2jDhg2y2WyaOHGiGSHAgppruIzok0QSCeZq7cWQN+UCWllagLqqAGCeQLdLO3furClTpmjNmjW69tprlZSUpJMnT7Z5v74yZ84c3XXXXc6fCwsLlZYWhjcrmislQq3NoOKLdtOJkkqXnTro0AFYS3V1tXJzc1VUVKSqqqpAhwMXqmxxOnDek45/Dxxodt2oqCh16NBBycnJQVk21JSE6tSpU/XXv/5VGRkZuuiii3TLLbfo8ssvd75eWVmpI0eO6LPPPtMLL7ygjRs3OnsBXHHFFWaEAAui4YI283Vt1ObKBUxaLsUl1y0rzZVWT2l1aYGwrKvqj4k+0CJKTSDU+Ltd2r59e+fzsrIySdKyZcu0bNmyJsslKT6+4QicQLPb7bLb7YEOI/CoWWopvmo3pafEa3Bqgun7BeB71dXVysrKUkVFhRISEhQfH6/IyMig7uEYjirKSmQvMlTRoafsse1drmMYhqqrq1VcXKz8/HyVlZUpLS0t6JKqpiRUIyIi9O6772r06NHKzMzUM888o2eeecb5xh02bFiD9Q3DUN++fbVu3TozDg+Lo+ESxlwlRCXPLl48TXY2l6RrKYGXu69puYDaxOmKCU3Xj4qTrl3T8NiuSgsE2SRZARHIiT4giVITCF3+bpfW1k2VHPVUBw8e3GSdH374wfm8a9eurToO/IBSIgBgWbm5uaqoqFDPnj0VG0s7NmjVVCmmzCbZoxUTE9PsqvHx8UpISNChQ4eUm5sbdG0oUxKqktSjRw/t2LFDc+bM0SuvvNLgTnx9drtd06ZN05///OcG9aQAhBl3CTXJs16drmqjukt2Nk7SuRvW50pUnNTz3IaxtGXGWAtNkuVTfpzog0kmXKPUBEKZP9ulAwYMcD7ft2+fy7qt+/bV3cA77bTTWnUcAADgmmEYKioqUkJCAsnUEBMbG6uOHTuqqKhIKSkpQdXj2LSEquTIHv/1r3/VI488oo8++kgZGRnKzc2V5KgnddZZZ+n8889XUlKSmYcFYEXuEmreThjVuDaqJ8P13A3rc8VVgq8tPViamyTr0L+cMcXkFquHclt3DCvx8UQfTDLRvJAsNdG453m49f6Gk7/apYmJiTrjjDO0c+dObdmyRTfffHOTdTZt2iRJSkpKctmDFQAAtF5VVZWqqqqCrqwOzNGhQwfl5+erqqpK0dHBcw1nakK1VmJiosaPH6/x48f7YvcAgp03Q9rdJdRamxTxNNnpz2F9Lc0Y7KLHbLqkjXa7sopHSKIkRmtRqzmMNDehTDj1/kYT/miXTpo0STt37tTbb7+trKysBpM6FRQUaMWKFZKk8ePHN1v/q36viwMHDqh3794+ixkIB41HqdSiHQCElpqaGkkKuhqbMEft37X27xwsfJJQBRDG2jqkvbmkiKe1UYOFpzMGu+gxm7U/Q2mbblfc0c+lDk0vBDw6NgkkJ2o1hwFXPc+97fEOtNKsWbO0cOFC5eTk6PLLL9eqVauUnp6uI0eO6Prrr1d2drZiYmJ0//33m3rc4uJilZeXO3+undG4oqLC2RtXcvTsYOIphBt3o1Qk6oUDoSqYhoPDPMH6d21zQrW6ulrvvPOONm3apIyMDB08eFCFhYUqKSlR+/bt1bFjR/Xq1UtDhgzRmDFjdOmll6pdO/K44Yg6hmGiuSHtniQ1XCVFPK2NGmy8mTG4UY/Z0qJolRp2pW26XdrUimO3tVee2RNnNd6fFRLisB4mlAl7gWqXJiQk6K233tK4ceP0xRdfqF+/fkpISFBhYaEMw1BUVJSWLl2qPn36mPBb1pk1a5ZeffXVJstXrVqlVatWOX9esmSJpk2bZuqxgWDnbpQK9cIBAGZoUwvyhRde0Ny5cxvcAZccBYElxxCnwsJCff/99/rkk0+0aNEide7cWQ8//LB+//vft+XQsBjqGIahttTGdJUU8TQxGWxameCJ79pHl9Q8pdiT+Q2Wx7SL0PNThiklvpmeRm3tlWf2xFnN7S+YE+IALCXQ7dKRI0fqq6++0rx587RhwwZlZ2era9euGjlypO677z6dffbZbT4GAO8xSgUA4AutSqjW1NRo0qRJWrt2rbORWisuLk5xcXGKjY1VeXm5SkpKVFpadxGdm5urWbNmaePGjXrrrbeCtusuzEUdQ0hyXUvUU2HW8yw1MVbLZ09wOQN7dvvTlNLDgwsDT89x48R0W3sZN+ZuAjIrJMQRGpioKqQFU7u0b9++euWVV1q9feP4W7J06VItXbq01ccDAABA67QqofqHP/xBa9askSR1795dN9xwg371q1/ptNNOU+fOTXsbHT9+XHv27NEHH3ygl156SUePHtXf//533XvvvfrLX/7Stt8AlsId4jDlaS1RNNDqGdjdnW933PU8bW0vY3fD+9vSaxloDSaqCgu0SwHUql9SjPJiAABf8jqheujQIT3zzDOy2Wz6zW9+o9dee01xcXHNbtO5c2edd955Ou+883Tfffdp8uTJeu+99/TXv/5Vt956q3r27NnqXwCAj5hZQ9ObWqJoO3fn25XanqeH/lW3fnM9W1vq9Vpb7zZAw/up1YwGmKgq5NEuBSA5Rr3FRkXqjtUZDZY3V16M5CsQnhpfL1iVL0b71h+p88QTT2j27NlN1pk1a5YWLVokSerVq5cOHjzocl8HDhzQs88+qw8++EBZWVkqLy9X9+7d9bNzf6ppvxmpn196qqmxB4LXCdVly5apsrJS3bp108qVKxUTE+PV9u3bt9fq1avVt29fZWdna9myZXrwwQe9DQOAJ1qbFPWmhqankw2F2ZD9gPP0fHvae9ibXq9RcdK1a6S45Ibb+/jvT61m87i6sLRsiRY+e0Ia7VIAkmNUz8bZo5okSVx9d7Um+QogNLi7XrCi2KhIbZw9ymft81WrVjVJqFZXV+vNN99scdsXX3xRd9xxh8rLyyVJdrtdMTEx+u677/Tdd99p5arV2vP1SA043dqjl71OqG7atEk2m03Tp0/3utFaKy4uTtOnT9fjjz+ujz76iIYr4AttTYq6q6FZvydjgHsjhqvGya42Jbo87T3sTa/XAPU8plZz27m7yJR832gDWoN2KYBanpZK8ib5CiC0uLtesJrauTVOlFT65HOrb9++2r59u7755hv17dvXufzDDz9Udna20tPTlZmZ6XLbZcuW6aabbpIkXXjhhXrsscecE3MePXpUK19foaeeeML0mAPB64Rq7Un72c9+1qYDn3feeQ32h9DCsNsg4OnEQs0lXnueW7decz0ZA9AbMRw116OiTYkuT3vwWaSnH7WaW8/dRaavG21Aa9EuBdAara5TDyAkcL3QvMmTJ2vevHlatWqVHnjgAefylStXSpImTZqkefPmNdnu2LFjuu222yRJF110kd59911FRkY6X+/WrZt+f9ON+t2vf6KTnbv4+LfwPa8TqsePO3onpaSktOnAXbt2bbA/hA6G3QaZliYC8nQGduqgBpyrZBeJLpiNi0xYCe1SAAAAc40ZM0YvvfRSg4RqRUWF1q1bp2HDhik9Pd3ldosXL1ZBQYFsNpueeeaZBsnU+jp2iFd5CzXvrcDrhGppaalsNpvat2/fpgPHxjou1mprKiB0MOzWAurXOfVmBnaL9FAMZSS7AKAO7VIAAABzRUZG6oorrtCiRYv09ddfa+DAgfrnP/+pgoICTZo0ye12tfVVhw8frn79+vkr3IDxOqFa68EHH1RiYmKrD5yfn9/qbWENdKMPQp5OQAQAoa7xBHr0trc02qUAAADmmTx5shYtWqRVq1bpT3/6k1auXCmbzaZJkybpo48+arJ+aWmpdu/eLUn6yU9+4u9wA6LVCdV//OMfZsYBwB8Yth+yTJ2oCghlzd1YajxhHyyDdikAAIB5zjvvPKWlpWn16tW699579e677+rcc89Vz549Xa7/3XffqbraUfaxT58+/gw1YFqVUDUMw+w4AHgqP6ttCVGG7YcUn01UBYQqVzeWXE3YB8ugXQoAAGAum82miRMn6sknn9RDDz2k0tJSTZ482e36BQUFzucdOnTwR4gB53VC9cCBA76IA4An8rOkRec4JpGqj55VYYuJqoBW4MZSyKBdCgAA4BuTJ0/Wk08+qaeffloRERG68sor3a4bjje4vU6o9urVyxdxAPBE6XFHMnX8YsckUlJdz6pD/2ra4wphgYmq4C+UlkCwoV0KAADgG8OHD1d6eroyMzM1ZswYdevWze26CQl18+cUFRX5I7yAa3UNVQB+0Hh4f22SNLm/1GOI47m7eoASk00BMAWlJQAAAIDwM2/ePG3dulWXXXZZs+v16tVLERERqqmpCZsRRCRUgWDV3PD++klSdxNNSUw2hZB2OL+sSakD+AalJQAAAIDwM3HiRE2cOLHF9dq3b6+BAwdq165d+uyzz/wQWeCRUEWbkdTwEVfD+yXXSVLqAcIFT/4vWnXI9uH8Mo19covKqqobLI+NilSn9tEBiiq0UVoCAAAAgDtXXHGFdu3ape3bt2vfvn3q379/yxtZGAlVtAlJDT+oP7wf8IC74dmuWHXI9omSSpVVVWvBpCFKT4l3LrdqghhBonHtaXr5AwAAAB6ZMWOGnnjiCRUXF+v222/Xe++9p4iIiCbrFRWXqCq6VDFxHQIQpXlIqKJNSGoAwcfV8GxXQmHIdnpKvAanJrS8InwmJCaqcleLOirOUVKFpCoAAADQrB49euipp57SzJkz9f777+vXv/61HnvsMQ0dOlSSlJOTozdWr9Rf/vy4Pli/XknJXQMccduQUIUpSGoAwYXh2fC1kJqoylUt6tx9jgRr6XESqgAAAIAHZsyYobKyMt1zzz16//339f777ysmJkZ2u10FBQWBDs9UJFSBYJGf1fRiHgCCVMhNVEUtagAAgLBg9Xlfgj3+2267TRdffLEWLVqk9evXKysrSydPntSAAQN01plnaPplo5SWZv12NwlVIBjkZ0mLznFMQlVfVJxjKCoABKGw6AlNXVUAAICQ4M1cE8HOF/PWGIbh0XrTpk3TtGnTml2nX79+WrBgQZPl5aVFisnPVLmL2qpWQ0IVXjmcX9akNxJMUHrckUwdv9gxCVUtLtwBIDCoqwoAABBSPJ1rwgosOW9BiLFsQvXo0aNavXq11q9fr6+++ko5OTmKiorSqaeeqnHjxumOO+5Qt27dAh1mSDmcX6axT25RWVV1g+W+uDMS8twN70/uL/UYEpCQAAD1UFcVAAAg5ITFCCv4hWUTqr1791ZFRYXz544dO6qsrEw7d+7Uzp07tXjxYq1du1ajRo0KYJTW5qo3allVtRZMGqL0lHjncu6MeInh/YBXGn8WSfSOh59QVxUAAACAC5ZNqFZXV2vUqFG64YYbdOGFF6pLly46efKktmzZoptuukmZmZm67LLLtGfPHnqqtkJzvVFH9EkigdoWDO8HPObus0iidzwAAAAAIDAsm1DdtGmTfv7znzdY1q5dO11wwQVas2aNhg4dqoKCAr344ouaO3dugKK0rhMllfRGbY3GQ/kl94lShvcDLXL3WSTxeQQAAAAACAzLJlQbJ1PrO/PMM3XqqacqMzNTX3zxhR+jCj3pKfEanJoQ6DCsobmh/JOWS3HJjp8bzxgNoEV8FgEAAAAAgoVlE6otSUxMlCTZbLbABoLw4Woof2mutHqKtGJCw3Wpl4og4qoeaaB6f7qq3QwAAAAAQDAJyYRqSUmJvv76a0nSsGHDAhwNwk7jofyNZ4mWqJeKoNCpfbRioyJ1x+qMJq/FRkXqhSnD1LlejVJfJ1mbq91MrVQElcYjDfhMBwAAAMJKSCZUFyxYoNLSUtntdk2bNi3Q4SBUNa6X6m4oP7NEI0ilJsZq4+xRDXqEStLxkkrdtPwLTX3l8wbLY6MitXH2KJ8lVandjKAX19kxwmDtjIbLo+IcN8/4rAcAAADCQsglVDMyMvToo49KkubMmaOePXu6XbeiokIVFRXOnwsLC30eH0JEc/VSGcoPC0lNjHWZrGycaM3MLtYdqzO07UCeTvg42Um9VOtrXKohZJLiiWlNRx3k7nMkWEuPk1AFAAAAwkRIJVRzc3M1YcIElZeX64ILLtCDDz7Y7Prz58/Xww8/7KfoYAmNe53Wajyc01W9VFfrARbVONHqrjyAr3utwlrC4n3ibtQBZQAAAACAsBEyCdWioiJdfPHF+vbbb3XmmWfqrbfeUmRkZLPbzJkzR3fddZfz58LCQqWlhefFDxPByH2vU8nR83TSciku2fFz7YVz43qpQIhyVR7An71WYQ3NvU9OlFSG5vuCMgAAAABA2AmJhGp5ebkuu+wybd++Xenp6frggw+UmJjY4nZ2u112u933AQY5JoL5kbtep6W50uop0ooJDddneD/CjNm9VrmRE5rclZEIWZQBAAAAAMKO5ROqJ0+e1MSJE7Vp0yalpaVp48aN6tatW6DDshQmgmnEVa/TxhfLEsM5Efba0huRGzkIKUw+CAAAAIQVSydUa2pqNGXKFL3zzjvq2rWrNm7cqF69egU6LMtiIphmcLEMuNTa3ojcyAk/ITtRFQAAAICwY+mE6o033qhVq1apc+fO2rhxo/r379/yRgCAoMGNnNAXFhNVAQAAAAgrlk2o3nnnnXrppZeUkJCg9evXa/DgwYEOCQDwo5bqoVIvNXyE5URVAAAAAEKaJROqhw4d0oIFCyRJlZWVGjduXLPrHz161A9RwXLys5pOIgKgTdz1RnSFeqnhI+wmqqrl6nuF+tsAAACB0zgPYFW0KQPOkgnVmpoa5/OysjKVlZUFMBpYUn6WtOgcqaq04fKoOMcHE4BWcdUb0R1qaCJkxXV2fJ+sndH0tag4x0SHNIABAAD8y10ewIp80KbcvHmzxowZ02R5XFycUlNT9bOf/Uw33nijzj333AavL126VNOnT3f+3K5dO3Xq1ElpaWn6xS9+oalTp2ro0KGmxRksLJlQ7d27twzDCHQYCFau7jg1vntTetzxITp+sZTc3/16ALwWtr0RgVqJaY4GbuPvotx9jiRr6XG+awAAAPzNXR7AavzQpuzUqZOiox2jCY8fP679+/dr//79WrZsmebMmaN58+a53C45OVmGYSgvL085OTnasWOHFi5cqOuuu04vvviiT2INFEsmVAG3mut56uruTXJ/qccQv4UHAAgTiWkkTQEAAIIReYAWrV27VqNHj5YkVVdXa8eOHbrjjjv06aef6rHHHtOQIUN05ZVXNtlu27Zt6t27t2pqarRz50698sorevbZZ7Vs2TIdP35cb72x0s+/ie9EBDoA+N/h/DLtOlzgfITU5DD17zjN3OJ4jF/sWHboX9KRDMeDeqkAAAAAAADNioyM1IgRI/T2228rKSlJkvTcc881u01ERITOOussLVy4UK+88ook6b333tOKFa/5PF5/oYdqCDucX9akjuHxkkrdtPwLlVVVN1gecpPD1L/j5K6WHfVSASCgGt/Qo64uAAAAEJw6d+6sc845R++//76+/PJLj7ebOnWqnn32WW3fvl3PPf+ibrjkJz6M0n9IqIaow/llGvvkliaJU8mRPH31+nPUuV4C1bIXsY3rpbrqeequlh31UgEgIDq1j1ZsVKTuWJ3RYHlsVKQ2zh5lze8jAAAAIMS1a+dII1ZXN801Nefyyy/X9u3b9WVGho4czVFSYrovwvMrEqoh6kRJpcqqqrVg0hClp8Q3eM2yydPGmquX2rjnKbXsACBopCbGauPsUQ1GUWRmF+uO1Rk6UVIZGt9RAAAAQAgpLi7Wtm3bJEkDBgzwatszzjjD+fyL/3ytX552rqmxBQIJ1RCXnhKvwakJgQ7DHK56o7qaoY+epwAQ9FITY0mcAgAAAEHOMAz997//1d13361jx45Jkm699Vav9nHKKac4n3//Q7ap8QUKCVUEp8bJ09JcafUU171Re55LAhUAAAAAAMAE48ePV3S0o0xkfn6+KioqJEk2m01z5szRdddd59X+2rdv73xeWFxiXqABREIVwae5ofzXrpHikuuW0RsVAAAAAADANCdOnGiybOjQoVq+fLkGDRrk9f5sNpvzuWEYbYotWJBQRfApPc5QfgAAAAAAgADYtGmTRo8ererqan377beaN2+eXn31VU2aNEmbN29WcnJyyzupp6SkrldqQof4Zta0johABwC4ldxf6jGk7kEyFQAAAAAAwC8iIyPVr18/LV26VBdddJF2796t3//+917v5/vvv3c+T+2eYmaIAUNCFQAABI3M7GLtOlzgfBzOLwt0SAAAAEDYW7BggSIjI/XWW2/p448/9mrbnTt3Op8PO+N0s0MLCIb8h4jD+WU6UVLp/DkzuziA0QAA4J1O7aMVGxWpO1ZnNFgeGxWpjbNHKTUxNjCBAQAAANCAAQN05ZVXatWqVXrggQe0detWj7ddt26dJGnIWWcptXuKyn0VpB+RUA0Bh/PLNPbJLSqrqm6wPDYqUp3aRwcoKgAAPJeaGKuNs0c1uTl4x+oMnSipJKEKAAAABNjs2bO1atUqffzxx/rwww91wQUXtLjNq6++qm3btkmSbv79Tb4O0W9IqIaAEyWVKquq1oJJQ5SeUlfct1P7aGtcgOZnOSaiqpW7L3CxAAACJjUx1hrfWwAAAEAYGj58uEaOHKmtW7dq7ty5bhOqNTU12rlzp5YsWaJnn31WknThhRfq2muvlgq+8WfIPkNC1YLcDe9PT4nX4NSEQIXVssaJU0kqzZVWT5GqShsuj4qT4jr7LzYAAAAAAAA06+6779bWrVv1ySefaMOGDQ1eGzFihCQpPz9fJ0+edC6/+uqr9dJLL8lmnFSoIKFqMZYd3p+fJS06p2niVHIkT69dI8Ul1y2L6ywlpvkvPgAAAAAAEPqsPio2wPFfcsklGjBggPbu3au5c+dq5syZztdyc3MVGRmpxMRE9ezZUz//+c81depUDRs2TJJUXloUqLBNR0LVYiw7vL/0uCOZOn6xlNy/4WskTwEAAAAAgC/FdXZ06Fo7I9CRtJ0PRvWOHj1ahmG0uJ7NZtOePXsaLJs2bZqpsVgBCdUgFzLD+2vvoCT3l3oMCUhIAABrqv3uqxX0NxEBAAAQfBLTpFs+b1qK0IromBZwJFSDmGWG9zdOnlIXFQBggk7toxUbFak7Vmc0WB4bFamNs0eRVAUAAIB3EtNIRMIUJFSDmCWG97urjUpdVABAG6Umxmrj7FFNRmrcsTpDJ0oqg+e7EAAAAEBYIaFqAUE9vN9dbVSSpwAAE6QmxpI4BQAAABBUSKjCHNRGBQAAAAAAQBggoRpE3E1AFVTcTTYFAAAAAAAAhAESqkHCEhNQNVcvlcmmAAAAAAAAEAZIqAaIq96oQT8BFfVSAQBBoi2jOILquxUAAACA5ZBQDYDmeqOO6JMUPBd57ob3Uy8VABAgndpHKzYqUneszmj1PmKjIrVx9qjg+b4FAAAAYCkkVAPgREll8PVGbZw8Lc2VVk9heD8AIKikJsZq4+xRDUZ5eCMzu1h3rM7QiZJKEqoAAAAhxDCMQIcAHwjWvysJ1QBKT4nX4NSEQIfRfG3Ua9dIccl1yxjeDwAIsNTEWJKhAAAAkCRFRERIkqqrq1tYE1ZU+3et/TsHCxKqoDYqACDsNK7BSl1VAAAAa4qKilJUVJSKi4sVHx/f8gawlKKiIuffOJiQUA11jYfyu0JtVABAmHBXg5W6qgAAANZks9nUoUMH5efnKyEhQbGxtOdCRVlZmQoLC5WYmCibzRbocBogoRrK3A3ld4XaqACAMOCqBit1VQEAAKwtOTlZZWVlOnTokDp27KgOHTooMjIy6JJw4a6iolI6aTj+jSh3uY5hGKqurlZRUZEKCwtlt9uVnJzsct1AIqEaShr3Rs3d53oovysM7wcAhAl3NVgpAwAAAGBNkZGRSktLU25uroqKipSfnx/okOBCVWW5okpzVBVnU1R0TLPrRkVFKTExUcnJyYqMjPRThJ4joRoqmptYque5JEsBAHCDMgAAAADWFxkZqa5duyolJUVVVVWqqakJdEho5Ls9X6jXJ7P13dgX1avP6W7Xi4iIUFRUVFD3MCahakWu6qK6641Kz1MAAJpFGQAAAIDQYbPZFB0dHegw4EKkzVBMcZbj35jme6gGOxKqVtNcXVR6owIA0CqUAQAAAADgKcsnVL/55hvNnz9f69evV3Z2tpKSkjRq1Cjde++9Gjp0aKDDaztv6qLSGxUAAFM0VwbghSnD1Ll9870eSLyGp0C0S0O+LQwAABCELJ1Q/fjjjzVu3DgVFzt6j3Ts2FE//PCDVq1apTVr1mjFihWaOHFigKP0QuPkaWmutHoKdVEBAPAzV2UAjpdU6qblX2jqK5+3uL2rxGtKSYVSfBItgkEg2qUh1xYGAACwCMsmVAsKCjRhwgQVFxdr6NChWr16tfr166fDhw9r+vTp2rBhg6ZOnaoRI0aoT58+gQ63iR7KVUzuTskW71jQXPL02jVSXHLdMnqiAgDgc67KADROsrriLvE6LOo7rQm+CUphgkC0S63eFgYAALAyyyZUn332WeXk5CgmJkbr1q1Tr169JEmpqal644031K9fP+Xm5mr+/Pn629/+FuBoG4oqPqyN9nsUt66i0QskTwEACGbuaq025mqSq8VvHJBIqIakQLRLrdwWBgAAsLqIQAfQWqtXr5YkXXrppc4GZK3ExERNmTJFkrRmzRpVV1f7Pb7mRJbnKc5WoawxC6WZW+oet3wupY+Vegype5BMBQDAclITYzU4NcH5SE+JD3RI8KFAtEut3BYGAACwOksmVPPz87Vz505J0ujRo12uc/7550uS8vLytGvXLn+F5pWKxHSSpwAAABYWiHZpqLSFAQAArMqSCdW9e/c6n/fv39/lOvWX79mzx+cxAQAAIPwEol1KWxgAACCwLFlD9ejRo87n3bp1kyTNnDlTK1eu1JQpU/Tcc8+pe/fuznWOHTvmcj8VFRWqqKirY1pQUCBJKiws9EXYTkXFJSqsMBz/+vhYAAAg8IqLClVVUaZCGVJRseSj7//adoVhGD7ZP5oyq10aqGPSHgYAAP7ij+9/v7WHDQt67bXXDEmGJCMzM9PIzc11/izJOH78uFFVVeX8ed68eS73M3fu3Abb8eDBgwcPHjx4hMIjKyvLz62z8GVWuzRQx6Q9zIMHDx48ePAIxYev28OW7KHaWOfOnTVlyhStWbNG1157rZKSknTy5MkWt5szZ47uuusu5881NTXKy8tT586dZbPZfBlyyCosLFRaWpqysrLUsWPHQIcT0jjX/sO59i/Ot/9wrv3LH+fbMAwVFRWpR48ePtk/Wtbadmmgjhmo9jCfP23HOTQH57HtOIfm4Dy2HefQHFY/j/5qD1syodq+fXvn87KyMknSsmXLtGzZsibLJSk+3vXMuna7XXa7vcGyxMREEyMNXx07drTkfzwr4lz7D+favzjf/sO59i9fn++EhASf7RtNmdUuDdQxA90e5vOn7TiH5uA8th3n0Bycx7bjHJrDyufRH+1hS05KVVsrSmpYQ6q+H374wfm8a9euPo8JAAAA4ScQ7VLawgAAAIFlyYTqgAEDnM/37dvncp36y0877TSfxwQAAIDwE4h2KW1hAACAwLJkQjUxMVFnnHGGJGnLli0u19m0aZMkKSkpSYMHD/ZbbOHObrdr7ty5TYaOwXyca//hXPsX59t/ONf+xfkOTYFol4ZCW5j/D23HOTQH57HtOIfm4Dy2HefQHJxHz9gMwzACHURrzJs3Tw8++KBiYmK0b98+paWlOV8rKChQ//79lZ2drRtuuEGLFy8OYKQAAAAIZWa1S+tPAnXgwAH17t3b58cEAACA9yzZQ1WSZs2apS5duqi8vFyXX365MjMzJUlHjhzRpEmTlJ2drZiYGN1///0BjhQAAAChLBDtUtrCAAAAgWPZHqqStHXrVo0bN04lJSWSHLN4FRYWyjAMRUVFafny5Zo0aVKAowQAAECoM6Nd6k0PVbOOCQAAAO9ZtoeqJI0cOVJfffWVpk+frlNOOUVlZWXq2rWrJk6cqH//+980IAEAAOAXgWiX0hYGAAAIDEv3UAUAAAAAAAAAf7J0D1V47ujRo1q4cKF+/etf65RTTpHdbld8fLzOPPNM/eEPf9DRo0dNP+Y//vEP3XrrrRo5cqS6d++uqKgoxcfHa/DgwZo9e7YOHTrU4j6++eYb3XDDDerZs6diYmLUo0cPXXXVVfryyy9Nj9csVjvXDz30kGw2W7OPSy65xPSYzRCIc+3ORRdd5DxfS5cubXZdK76vJeudb97b3jHjfFnxvW21c23l9zUgWfNzIpjs2LFDzz33nKZOnarTTjtNERERstlsmjZtWqBDs4xgas9YlRnXeXDNm2sK0C4ym2EYev311zVu3Dh1795ddrtdqampGjVqlB599FFVVlYGOsTgYiAs2O12Q5Lz0bFjRyMqKsr5c1JSkrF582ZTjzlo0KAmx4yOjnb+HB8fb7z33ntut9+6dasRHx/fYPva51FRUcbq1atNjdcsVjvXc+fOdZ7Trl27unxce+21psZrlkCca1dee+21BnEsWbLE7bpWfV8bhvXON+9t77T1fFn1vW21c23l9zVg1c+JYJKQkNDgM6v2MXXq1ECHZhnB0p6xsrZe58E1b64p4EC7yDxFRUXGBRdc4Hz/2Ww2IzEx0YiIiHAuy8nJCXSYQYWEapho166dMWrUKGP58uVGdna2YRiGUVVVZWzcuNFIT083JBkJCQnGDz/8YNox77zzTuOvf/2rsWvXLqOkpMQwDMOoqakxvvzyS2PMmDHOL9vDhw832TY/P9/o0qWLIckYOnSosW/fPsMwDOP77783fvnLXxqSjJiYGOPbb781LV6zWO1c134JjRo1yrR4/CUQ57qxvLw8IyUlxTj99NNbbPxY+X1tGNY737y3vdOW82Xl97bVzrWV39cIb1b+nAgmXbp0MYYPH27MmjXLWLFihXH22WeTUPVSMLRnrK4t1x5wzZs2LurQLjLPJZdcYkgyEhMTjRdeeMEoLCw0DMMwKisrjf/85z/G3XffbeTn5wc4yuBCQjVMfPzxx25f++qrr5x3HR566CG/xFNYWGh06NDBkGT85S9/afL6o48+6mxYHzx4sMFrJ06cMJKTkw1JxowZM/wSrzesdq6t/CUUDOf6d7/7nSHJ2LBhQ4uNHyu/rw3Deueb97Z32nK+rPzettq5tvL7GuHNyp8TwaSioqLBz6NGjSKh6qVgaM+EspauPeCaN21c1KFdZI63337b2dN327ZtgQ7HMqihGiZ+/vOfu33tzDPP1KmnnipJ+uKLL/wST4cOHZSeni7JUUursdWrV0uSLr30UvXq1avBa4mJiZoyZYokac2aNaqurvZxtN6x2rm2skCf661bt+qVV17R+PHjNXbs2BbXt/L7WrLe+bayQJ9rb1n5vW21cw1YlZU/J4JJdHR0oEOwPD73fSuUrz18JZzauAhOL7zwgiRpxowZGj58eICjsQ4SqpDkaMhKks1m88vxsrOztXfvXklSampqg9fy8/O1c+dOSdLo0aNdbn/++edLkvLy8rRr1y7fBeoDwXSuQ50vz3VlZaVuvPFGxcTE6Kmnnmpx/VB/X0vBdb5Dnb8/R5oT6u/tYDrXgFWF+ucEQguf+20TztcerUEbF4FWWVmpjRs3SpKuueaaAEdjLSRUoZKSEn399deSpGHDhvnsOIZh6NixY/r73/+uCy64QKWlpYqJiWnyn7b2C1iS+vfv73Jf9Zfv2bPHNwH7QLCd6/p2796twYMHKzY2Vh06dNBZZ52l+++/X8eOHfNZnL7k63M9f/587dmzR3PmzGnS08aVUH5fS8F3vuvjve0db89XKL+3g+1cm7Ut4G+h/DmB0OKvtnqoac21Bxza0sZFHdpFrfff//5XlZWVioiI0NChQ7Vu3Tqdd9556tChgzp06KARI0boySefVEVFRaBDDTokVKEFCxaotLRUdrtd06ZNM33///73v2Wz2RQREaFu3brp8ssv165du5SSkqK3335bffr0abD+0aNHnc+7desmSZo5c6Y6dOigm2++WZLUvXt35zpW+pAMtnNdX25urvbu3avY2FiVlJToP//5j+bPn6/Bgwfrk08+MT1WX/Plud67d6/mz5+vU089Vffcc49H24Ty+1oKvvNdH+9t73h7vkL5vR1s59qsbQF/C+XPCYQWX3/uh5q2XHug7W1c1KFd1HpZWVmSpE6dOumFF17Q+PHj9emnn6pdu3aqqKjQ9u3bdffdd2v06NEqKSkJcLTBhYRqmMvIyNCjjz4qSZozZ4569uxp+jGio6PVtWtXdenSxTl05rTTTtP777+vX/7yl03Wr/+fNDY2VsePH9fixYtVXFys559/Xnl5eYqNjXWuU1xcbHrMvhCM51py9AhZuHChDh48qPLycuXl5SkvL0+LFi1Shw4dlJubq8suu6zBxVCw8/W5vvHGG1VRUaGnn35aMTExHm0Tqu9rKTjPt8R721utPV+h+t4OxnPd1m2BQAnVzwmEFn+01UNNa649UKe1bVzUoV3UdkVFRZKksrIyzZkzRxdeeKG+/fZbnThxQsXFxXrppZcUHR2tf//735ozZ06Aow0yAZ4UCwGUk5NjnHrqqYYk44ILLjBOnjzp82OWlZUZH374oTFs2DBDknHPPfcY1dXVDdZ57bXXnDMbZmZmGoZhGFOmTDHi4uKMmTNnGoZhGFVVVc515s2b5/O42ypYz3VLtmzZYthsNkOScffdd/soUnP5+ly//PLLhiTj4osvbvKampmRMxTf14YRvOe7Jby3vdPc+QrF93awnmtfbgv4Uih+TgSLUaNGGZKMqVOnBjoUSwvk536oMOPaI5z4qo2LOrSLPLNixQrney4lJcUoLi5uss4dd9xhSDJiY2ONkpKSAEQZnEiohqnCwkJj+PDhhiTjzDPPNE6cOOHX45eVlRlDhgwxJBkLFy5s8Nrf//5353/onTt3uty+sLDQuU7j7YNNMJ9rT1xwwQWGJGPgwIE+iM5cvj7X2dnZRlJSkhEdHW3s27evyevNNX5C7X1tGMF9vj3Be9s77s5XqL23g/lc+3pbwFdC7XMimJBQbbtg+NwPJW299ggHvm7jog7topatW7fO+Z77wx/+4HKdjIwM5zpbt271c4TBiyH/Yai8vFyXXXaZtm/frvT0dH3wwQfO2Sz9JSYmRrfeeqsk6c9//nOD12pra0ly2zX/hx9+cD7v2rWrDyI0R7Cfa0+cffbZkqSDBw+aGZbp/HGu77//fuXl5emuu+5Sv379vNo2lN7XUvCfb0/w3vaOu/MVSu/tYD/Xvt4W8JVQ+pxAaAmWz/1Q0tZrj3Dg6zYu6tAuallycrLzubuJI3v37u18fuTIEV+HZBkkVMPMyZMnNXHiRG3atElpaWnauHFjg0auP51yyimSHP8h8/PzncsHDBjgfL5v3z6X29Zfftppp/kmwDaywrn2RG09pGDmr3O9f/9+SdLjjz8um83W5FFr+vTpstlsDb54QuV9LVnjfHuC97Z33J2vUHlvW+Fc+3pbwFdC5XMCoSWYPvdDTVuuPcKBr9u4qEO7qGX1k/qcL++QUA0jNTU1mjJlit555x117dpVGzduVK9evQIWz6FDh5zPDcNwPk9MTNQZZ5whSdqyZYvLbTdt2iRJSkpK0uDBg30YZetY5Vx7IiMjQ5KCdpbOYDvX7oTC+1qyzvn2BO9t77g7X6Hw3rbKufb1toCvhMLnBEJLsH3uh5q2XHsAZqJd1LKuXbs6k/bubnrW7+Gbmprqh6gsIsAlB+BHN9xwgyHJ6Ny5s9v6VS3Rj3UzJBkHDhxwu15RUVGz+6msrHTWKurbt2+T1x999FFDkhETE2McOnSowWv5+flGSkqKIcm44YYbWvV7+JpVznVLBfc///xzIyIiotl6KoHmz3Pt6X7c1Tuy+vvaMKxzvnlvO3h6rtt6vqz+3rbKuQ6F9zXCl9U/J4IVNVRbx4zP/XDV1us8tKylawo40C4yT+2kU926dXM56VTt6+3btzdKS0sDEGFwIqEaJmr/AyQkJBhffPFFq/fj6QXjkiVLjLPOOstYuHChsXfvXqOmpsYwDMMoLS01Nm3aZPzsZz9z7uf5559vsn1+fr7RpUsXQ5IxbNgwY//+/YZhGMbhw4eNCy+80Nkg//bbb1v9u/iKlc715s2bjVGjRhnLli0zDh8+7FxeVFRkLF261OjcubMhyejatauRk5PT6t/FV/x9rj3dj7vGj5Xf14ZhrfPNe9vB03Pd1vNl5fe2lc611d/XCG9W/pwIJkVFRUZOTo7zUdvOmzx5coPl5eXlgQ41aJn1uR+u2nqdh5aRUPUM7SLzZGVlGbGxsYYkY9y4cc62bEVFhfHSSy8Z0dHRhiTjnnvuCWygQYaEahj47rvvnB/KsbGxRteuXZt9NMebJF/9daOjo42kpKQGy2w2W7P/Ibds2WK0b9/euX5CQoJhs9kMSUZUVJSxatWq1p4Sn7Haud60aVOD9dq3b2907tzZeSdPkpGWlhaUjc1AnOuWeNL4seL72jCsd755bzt4eq7NOF9WfG9b7Vxb+X0NGIY1PyeCzdSpUxt8Drh7kIhxzczP/XBlxnUemsf/Y8/QLjLXmjVrnIlTSUanTp0a/Hz++ecbZWVlgQ4zqLQTQl5NTY3zeVlZmcrKynx+zF//+td66aWXtHXrVmVkZCg7O1vHjx9XXFycTjnlFP385z/XzJkz9ZOf/MTtPkaOHKmvvvpK8+bN04YNG5Sdna2uXbtq5MiRuu+++5wz9gUTq53rwYMH67HHHtOmTZuUmZmpEydOKD8/XwkJCTr99NN12WWX6cYbb1RCQoLPfw9vBeJcm8GK72vJeueb97Z3zDhfVnxvW+1cW/l9DUjW/JxAaLFaeyYYmXGdB5iBdpG5xo8frx07duiJJ57Qhx9+qGPHjikmJkbDhw/XNddcoxkzZigqKirQYQYVm2FQJRoAAAAAAAAAPBER6AAAAAAAAAAAwCpIqAIAAAAAAACAh0ioAgAAAAAAAICHSKgCAAAAAAAAgIdIqAIAAAAAAACAh0ioAgAAAAAAAICHSKgCAAAAAAAAgIdIqAIAAAAAAACAh0ioAgAAAAAAAICHSKgCAEJC7969ZbPZNG3atECHAgAA4LGDBw/KZrPJZrNp6dKlgQ7Hr2i/+Vc4v9cAs5FQBQAAAAAAAAAPkVAFAAAAAACt9tBDDzl7PgJAOGgX6AAAAAAAAAhXvXv3lmEYgQ4DAOAFeqgCAAAAAAAAgIdIqAIAAAAAAACAh0ioAnDpo48+0tVXX61evXopJiZGnTp10nnnnadnnnlGlZWVLreZNm2abDabevfuLUnauXOnrrnmGqWmpsput6tv37564IEHVFpa2uLxCwoK9Oijj+qcc85RUlKSYmJi1Lt3b02bNk3/+c9/PPodGs8aeuDAAc2aNUv9+vVTbGysunbtql/84hdatGiRy+2zsrI0c+ZMpaWlKSYmRr169dKsWbOUm5urpUuXOutEHTx4sMF21157rWw2mzp06NDi7/r0008795ORkeHR7+WpxrN45ubm6rbbbnP+TXv27KkZM2Y0id+TfUnSJ598ogkTJjjPT1pamn7zm99o/fr1LvdRXV2tJUuW6MILL1S3bt0UHR2trl276pJLLtHbb7/dYgyGYWjp0qU677zzlJCQoI4dO+q8887Tm2++6c1pAQAAYe7bb7/VE088oUsuuUQ9e/ZUTEyM4uPjlZ6ert/97nf67LPP3G5bv03U0qO2TdxYfn6+221amnl98+bNznW/+eYbnX/++YqLi1P//v21Zs0aSdLixYvVp08fxcbGauTIkdqzZ0+T/TTXlnV1rM2bNzd4rX7NVJvNpocfftj5mqvfa/To0c3+XrXeeecdjR07VsnJyYqLi9PZZ5+tl19+2aNtW6vxufjqq690xRVXKCUlRXFxcRo0aJDmzp2rkpISr/dlGIZee+01jRo1Sl26dFH79u3Vr18/XX/99dq3b5/LfbT1OqikpEQPPfSQBg0apLi4OHXp0kWXX365vvjiC6/PDYBmGABQT0VFhXHttdcaktw+hgwZYvzwww9Ntp06daohyejVq5fx3nvvGbGxsS63Hzt2rFFTU+M2hi1bthjJyclujx8REWEsWrSoxd+lV69ehiRj6tSpxscff2wkJia63F+vXr2abPv5558bCQkJLtfv06eP8eSTTzp/PnDgQINt169f73zttddeazbGYcOGGZKMM888s8Xfx1sHDhxwxvH4448bPXv2dPn7xMfHG1u3bvV4X0uWLDGeeeYZw2azudzf1KlTm2z//fffG0OHDm32fTVlyhSjqqrK5fFPnjxpTJgwwe22f/rTnxr8vQEAAFz59ttvm22PSDJsNpsxZ84cl9vXbxO19HDVxjQMwzhx4oTbbZYsWdJs/Js2bXKu269fvwbbRkZGGo899liTfZ522mlN2t5Llixx25Z1daxNmzY1eG3u3LkenwdJxqhRo1weo377rbl9PvLII82el7aofy5efvllIyYmxmUM/fv3N44ePerxvvbv329MnjzZq791W6+Djh49agwYMMDltna73fjb3/7m8XsNQPPooQqggalTp2rFihWSpEsvvVRr1qzRF198oXfffVd33XWXoqKilJGRoYkTJ6qmpsblPoqKijR16lSdeeaZevPNN/X5559r2bJl6tOnjyRp48aNeuutt1xum5GRoQsvvFC5ublKSUnRY489po8//lj/+te/tGTJEp155pmqqanRrFmz3PaEbKy4uFgTJ05UVVWV7rvvPm3cuFE7duzQe++9pxtvvFF2u73B+gUFBfrNb36jgoICtWvXTnfffbf+7//+T5988onuvvtuHTp0SI8++qjb411wwQU65ZRTJMl5Ll3Zu3ev807xdddd59Hv0lqPPPKIvv/+e916663asmWL/vWvf+mhhx5STEyMiouL9dvf/lbHjx/3aF/bt2/X7bffrp49e+qpp57S//3f/2n79u1atWqVxo0b12R216KiIo0ZM0ZffvmloqKidOutt+qDDz7Qtm3b9MYbb+i3v/2tJGn58uWaO3euy2P+6U9/cva6OPfcc7V27Vpt375dy5cvV//+/fXwww/r2LFjrT9BAAAgLFRXV0uSzjrrLP3P//yP3n77bW3btk3btm3T66+/rjFjxsgwDM2fP18vvPBCk+1TU1O1c+dOt4/169crLi5OkpztwcY6duzYYJsPPvigVb9Lhw4d9OGHH2rp0qWKjY1VdXW17r//fv3qV7/Sli1b9Nhjj0mS9uzZo88///z/s3en4VFU6d/Hf52QPZCVNYZFAjgKAgJuKCjioIwrKOhoDLgwjqLihuI44o4+jgoqoqKAiEqUgPtfMIrgOOoAioILi4JgWEIIScgeQj0vMmnSSXenO1295vu5rlw01VV1TlV3V5++65z7tKgMR2644QabY/j73/9ufc7eeZk/f77T/X355Zd68MEHdcUVV2jFihX68ssv9a9//ct6Lh966CHl5eWZegz23HzzzYqKitKTTz6pb775Rp9++qm1nb5582ZddtllLu/rmWee0eLFizV06FC9+uqr+u9//6uvvvpKzz//vPr27dtkfTN+B40fP16bNm2SJGVmZurTTz/VN998oyeeeEKRkZG69dZbW3BWANjl74gugMCxZMkS6x3L++67z+46H330kXWdnJwcm+fqe6hKMoYMGWJUVlbaPL9r1y4jNjbWkGSMGTOmyb4PHz5s9OvXz5BkdOrUycjLy2uyTk1NjTF06FCXenXW3/Fu06aNkZqaavz4449212t8V/7ee++1Hse8efOarD9z5kybu7327upPmzbNWvbevXvtlnvfffdZexPY6/HrqcY9KJ544okm6+Tk5Fifnzp1qkv7atOmjXHSSScZJSUlDtdtaPLkydbjXLFihd1t7rrrLkOSERkZ2eRc7Nu3z4iKijIkGYMHDzaqqqqaPJ+Wlua0hywAAIBhGEZhYaHx5ZdfOnz+0KFDxsknn2xIdaOS3FFTU2MMGzbMkGQkJCQYW7ZscWm7xiOBnGnYazQ3N9e6/KqrrrIu37p1q3V5fS/W559/3mY/nvZQbaxh71J31LfXJRk33XRTk+ffffdd6/PPPPOMW/t2VcNzER4ebnz11VdN1rnpppus63z00Ucu7atNmzbGjTfeaHe9mpoa448//rD+34zfQe+9957Tc/nvf//bCAsLo4cqYBJ6qAKweuKJJyRJAwYMcNhT8Nxzz9WwYcMkSW+88YbDfd1///1Nen527txZZ599tiTpu+++a7LN8uXLtWHDBknS7Nmz1aVLlybrtGnTRg899JAk6YcfftDGjRubOywdOnRITzzxhI499li7zzfOb/Xqq69Kkvr166eJEyc2Wf/GG2+0W7eGsrKyrGUvXrzY7jr15+/Pf/6zOnXq5HR/nurcubNuueWWJsvHjBmjQYMGSarrIeoK43+5oNq2bWv3+Ybn88CBA9a8VzfccIP19W9s+vTpio6OVnV1dZPey2+99ZaqqqokSQ888IAiIyNtnk9NTdXUqVNdqjsAAGjdkpKSdOqppzp8Pjw8XFdffbWkuvz7u3btcnnf99xzj1avXi1Jmj9/vjIyMjyrbDP+9Kc/WR/36dNHkhQZGamjjz7aurxnz56SpD/++MOrdfFUZGSkHnzwwSbLzzvvPCUlJUmy//vBbBdffLFOPvnkJsvvv/9+axt04cKFLu2rR48eevrpp+0+16ZNG6WlpVn/b8bvoPq2fGRkpE1O23pDhw7VhRde6FLdATSPgCoASVJBQYF1KNCFF16osDDHl4fjjz9ekrRmzRq7z4eHh2vEiBF2n+vdu7ck2R2e/eGHH0qSoqOjde655zZbvrM6NNS2bVtdfvnlza4n1TWcd+7cKUm64IIL7K7Tpk0bjRo1yul++vTpY22M2Rv2/9///ldbt26VdCT46k3nnHOOIiIi7D43evRoSdLu3btdmqBqxIgR1sZ5cz777DNVVFRIqgveOhITE2P90dH4Nf3yyy8l1TUOzzrrLLvbO3qtAAAAnKmqqtKOHTv0008/aePGjU2CVLt373ZpP++88461c8Jtt92miy++2PS6NpacnGx9XB90TEpKskm/lJCQIKnuJncgGzx4sBITE5ssDwsLs7YRfZHe6fzzz7e7PDk5WSeddJIk6auvvnJpXxMmTHDY/m7MjN9B9W3mk08+2fp+aIw2M2CeNv6uAIDA8P3338swDEl1vQDt3dVsLD8/3+7y1NRURUdH232uPg9SeXl5k+fqZ7mvrKy0rtfSOjQ0cODAJr1lHWk4C6qjHq2SdMwxxzS7r6ysLH399ddas2aNNm/ebA0mS9Lrr78uqa6R64s7xc7q2/C5TZs2OZyRtt4pp5zicrn1r6kknXnmmS5t0/g13bJli6S6nq+OXsdu3bopJibGGrwFAABwpLq6WnPmzNHChQv1ww8/6NChQw7XtddmbezXX3/VhAkTJNX1Anz88cfNqqpTDUft1D9uPJKnPqBXXV3tkzq1VHp6usPnnP1+MFtzbeYvvvhCv//+uyorKx3+3qnXkjZzS38HlZeXW3tTOzuGhr2aAXiGHqoAJNX1UHVXZWWl3eXNNS7MrIMrAbTOnTu7vL+ioiLrY0d3dpt7rt5ll11mDQA2HE5fW1ur7OxsSdK4ceNafL7c4ay+DXsDNDx+R9w5n2a8psXFxZJkt9dCPYvF4vR5AAAASSosLNQpp5yiKVOm6Ntvv3UaTJXkcBLWehUVFRo7dqyKi4vVvn17ZWdnq00b3/RbajiiLDw8vMmyhsubO05/c6U9XN/5w5tcbTPXt0+d8WWbuWF9nLWJXfkNA8A19FAF0MScOXN02mmn+a38fv36Oc3P2lCHDh2aXccbAUtXGnSJiYm68MIL9dZbb+n111+35jz69NNPrUOWfDHc3x3N/WiQWn4+165d61JP4bi4uBbtHwAAoDm33HKLvv32W0nSRRddpJtuukkDBgxQYmKiNRi5cuVKa/qq5tp8N954o77//nuFhYXpzTfftMmLidDlrTaz2b+DAHgPAVUAkqSUlBTr4/j4ePXt29dvdSgvL/dL+ZLtHd3CwkKH67mahyorK0tvvfWWtm3bpi+//FJDhw61Dvfv2bOnhg4d6lF9XeWsvg17pdbn2TJLw/dVx44dddRRR7m9j/rXxFnvWcMwXOpdCwAAWq+DBw9aRwldeumleuutt+yu52qb4pVXXtH8+fMl1aXMcpTrPRA1zLPqSGtMpeTvNnNLfwe5OuIs0HPpAsGEIf8AJNkmOP/mm2/8Uof+/ftLkn777bcWDXsxQ8OcQz/++KPD9X7++WeX9jdq1Ch16tRJUt3kVBUVFVq2bJkk6aqrrvKgpu5xVt+GeWMb5nk1Q/1rKrX8fVVfp+3bt6uqqsruOtu3b2+VjX4AAOC6zZs3q6amRpJ05ZVXOlzvhx9+aHZf69ev1+TJkyVJ5557rv7xj3+YU0kfadh70lFu0h07dri8P1cCtMHAlTZzWlqay3lOXeXp76CYmBhrx4WGbfvGfvrpp5ZVEEATBFQBSKobMjJo0CBJ0ptvvqmSkhKf16F+RkvDMPTiiy/6vHxJ6tGjh7Ux8t5779kd5lVTU6Ply5e7tL/w8HBrg/3tt9/W0qVLdfDgQVksFmVmZppX8WYsX77c+gOisY8++khSXQ/Snj17mlruiBEjrMP8X3jhhRbtoz79RHV1tXJzc+2u895777WsggAAoNVomEfU0VwAtbW1zQ65Lioq0tixY1VZWamuXbtq0aJFQRdQrL/hLzkOwLna3pVcC9AGgw8++MDu8sLCQmvngFNPPdX0cs34HVTfZv76668d9kSlzQyYh4AqAKs77rhDkrR//35dddVVDmcDPXz4sBYvXuywwdFSo0ePts48+fDDD2vVqlUO192xY4fuvvtuU8uvV99z9Mcff9Qrr7zS5Plnn31We/bscXl/9bO+7t+/X7fddpukuhlge/To4XllXbR7927NmjWryfKlS5dq3bp1kqQrrrjC9B8DKSkp1uPPzc11OuttaWmpHnvsMW3bts1m+SWXXGJtpN9///1N3pcFBQV64oknTK03AAAIPRkZGda2Tv3Q/8buuecebd682eE+DMNQVlaWfvvtN0VGRurtt99WcnKyV+rrTf369bPmjJ0/f36TTgSrV6/Wu+++6/L+0tPTrY/XrFljTiX9YNmyZXZHVTVsg3qjU4QZv4PqO3FUV1dr+vTpTZ7/z3/+Q0AVMBE5VAFYXXbZZVq6dKnefvttvfvuu+rfv79uvPFGDRo0SJGRkfrjjz/0xRdfKDs7W3/88YeeffZZU8sPCwvTa6+9pqFDh6qyslIjR45UVlaWLrroIqWlpam0tFQ//PCDPvroIy1fvlyJiYl67LHHTK2DJN1555165ZVXtHfvXl1//fX6+eefdfHFFys8PFzLli3TU089pa5du7o8DOq4447ToEGDtG7dOuXn50tyPszMG+Li4nTXXXdpx44duvTSSxUZGanly5drxowZkupm/PRWgPrxxx9Xbm6ufv31V91999369NNPlZWVpT59+qi2tlZbt25Vbm6ulixZotLSUp133nk226ekpGjq1Kl68MEHtXbtWp1xxhmaOnWqunbtqp9//lkPPvig9uzZo+joaIe9TQAAAFJSUjR69Gh9+OGHWrp0qS655BJNnDhRnTt31vbt2/Xyyy/r//7v/zRw4EB99913dvcxf/58a1Bq0qRJio2N1caNG+2uGxkZ2SSdUk1NjTZt2mSzbNeuXdbHeXl5TfbXo0cP0yftTE5O1llnnaVPPvlEH3zwgc477zxlZmYqJSVFq1ev1tNPP61+/frp+++/d2l/w4YNU1hYmA4fPqxJkybp6aef1sCBA9W2bVtJdaO2YmJiTD0Gb4iOjtaoUaN033336fTTT1dpaakWLFighQsXSpJOP/10nX/++aaXa8bvoL/85S8aPny4Vq1apWeffVbFxcWaMGGC4uPjtXr1aj344IOKiYlRWVmZ6fUHWiUDABqoqqoyJk6caEhq9u/VV1+12TYrK8uQZHTr1s3h/qdPn27d3pEvvvjC6NSpU7Pl9+jRw+mxdOvWzZBkZGVluXMKDMMwjK+//tpo166d3XKPPfZY49lnn7X+f/v27c3u75lnnrGuHxkZaRQWFrpdJ3dt27bNWuYjjzxidOnSxe7xxMXFGZ9//rnL+5o/f77bdcnLyzNOPPHEZl/TyMhIY8uWLU22P3TokDFmzBiH2z3yyCMevd4AAKB12LFjh9G1a1eHbYoRI0YYH3/8sfX/K1eutNm+YVu2uT97beKGbSpX/xrWYeXKlXbb0vPnz7dbZn373F77aP369UZcXJzdMocMGWK8//77Ds+DPTfddJPDYxg+fLjdbVxpvw0fPtzpPjxVf+4kGS+++KIRGRlp9xh69epl7Nq1y+V9bdu2ze26ePo7aPfu3Ubv3r3tbhMdHW288sorHrXpARzBkH8ANiIjIzVv3jx9/fXXuvbaa9W7d2/Fx8crIiJCXbp00dlnn61HH31UmzZt8tqkSqeddpq2bt2qp556SmeeeaY6dOigiIgItW3bVv369dM111yjnJwclyeGaomTTjpJP/zwg6655hqlpaUpMjJS3bp10y233KJ///vfNnmiXOkxcNlll1kfjx49WklJSV6ptyNdunTR2rVrNWnSJB111FGKjIzUUUcdpauvvlobNmzQ8OHDvV7+119/rezsbI0dO1bp6emKjo5WdHS0evbsqbFjx+rFF1/Url27lJGR0WT78PBwLVmyRPPmzdMpp5yitm3bKj4+Xqeeeqrefvtt3XPPPV6tPwAACA3p6elat26dbr/9dmVkZCgyMlJJSUk6+eSTNXv2bK1YscKa/z3U9e/fX19++aUuuOACJSUlKSYmRscee6wefPBBrVq1SvHx8W7tb9asWXr55Zc1fPhwJScnKzw83Es1954///nP+ve//60LLrhAKSkpio6O1jHHHKN//vOf+vbbb9W5c2evlu/p76BOnTrp22+/1fTp0/WnP/1J0dHRSklJ0UUXXaT//Oc/GjFihFfrD7QmFsOwM+MKAMCpxx57TNOmTVNERITKy8vVpo3zDCqff/65zjzzTElSTk6OxowZ4/U6bt++3Zqndf78+dZcpgAAAADqLFiwQBMnTpQkbdu2Td27d/dvhQAEBXqoAkALfPXVV5LqEvo3F0yVZJ3cKiUlpUmOUAAAAAAAEDwIqAKAHZs2bdLhw4ftPvftt9/qo48+klQ3A31zfvvtN+tMspmZmYqMjDSvogAAAAAAwKea71YFAK3QP/7xD61Zs0aXXHKJhg0bpq5du6q8vFyrVq3SE088oUOHDqlLly66/vrr7W6fl5en8vJybdmyRXfeeadqamrUpk0b3XjjjT4+EgAAAAAAYCYCqgDgwI4dO/TUU0/pqaeeavJc+/bt9c477zicXOqKK67QqlWrbJY9/PDDdidcAgAAAAAAwYOAKgDYce+99+q4447TypUrtW3bNuXn5ysqKkoZGRn6y1/+oilTpiglJaXZ/URHR+tPf/qTbr31VmVmZvqg5gAAAAAAwJsshmEY/q4EAKDOww8/rIcfftijfaxYsULDhg0zqUYAAABAYPnzn/+s1atXe7SPyspKk2oDoDUioAoAAaSwsFCFhYUe7SMtLU0xMTEm1QgAAAAILHl5eaqoqPBoH6TiAuAJAqoAAAAAAAAA4KIwf1cAAAAAAAAAAIIFAVUAAAAAAAAAcBEBVQAAAAAAAABwEQFVAAAAAAAAAHARAVUAAAAAAAAAcBEBVQAAAAAAAABwEQFVAAAAAAAAAHARAVUAAAAAAAAAcBEBVQAAAAAAAABwEQFVAAAAAAAAAHARAVUAAAAAAAAAcBEBVQAAAAAAAABwEQFVAAAAAAAAAHARAVUAAAAAAAAAcBEBVQAAAAAAAABwEQFVAAAAAAAAAHARAVUAAAAAAAAAcBEBVQAAAAAAAABwEQFVAAAAAAAAAHARAVUAAAAAAAAAcBEBVQAAAAAAAABwEQFVAAAAAAAAAHARAVUAAAAAAAAAcBEBVQAAAAAAAABwURt/VyCQHD58WLt27VLbtm1lsVj8XR0AAAC3GIahgwcPqkuXLgoL47453Ed7GAAABDNftYcJqDawa9cupaen+7saAAAAHtm5c6eOOuoof1cDQYj2MAAACAXebg8TUG2gbdu2kupOert27fxcGwAAAPeUlJQoPT3d2qYB3EV7GAAABDNftYcJqDZQP6ypXbt2NCABAEDQYqg2Wor2MAAACAXebg+TXAsAAAAAAAAAXERAFQAAAAAAAABcREAVAAAAAAAAAFxEQBUAAAAAAAAAXERAFQAAAAAAAABcREAVAAAAAAAAAFxEQBUAAAAAAAAAXERAFQAAAAAAAABcREAVAAAAAAAAAFzUxt8VCDWGYaimpkaHDx/2d1XQQmFhYYqIiJDFYvF3VQCgWXlFFTpQVm2zLCkuUmmJMX6qEQAAAOA/xGWCXzDEZQiomqS2tlYFBQU6ePCgampq/F0deCgiIkJt27ZVamqqwsPD/V0dALArr6hCI59cpYqaWpvlMRHhyr19OEFVAAAAtBrEZUJLoMdlCKiaoLa2Vjt37lRVVZUSEhIUHx+v8PDwgI6kwz7DMFRbW6vS0lIVFRWpoqJC6enpAfnhBYADZdWqqKnVzPEDlNEhXpK0Nb9UU7LX60BZNQFVAAAAtArEZUJHsMRlCKiaoKCgQFVVVeratatiYvjxGgri4+OVkJCgHTt2qKCgQB07dvR3lQDAoYwO8eqbluDvagAAAAB+QVwm9AR6XIZJqTxkGIYOHjyohIQEPrQhJiYmRu3atdPBgwdlGIa/qwMAAAAAABohLhO6AjkuQw9VD9XU1Kimpkbx8fH+rgq8oG3btioqKlJNTY0iIyP9XR0ArQiTTQEAAADNIy4T2gI1LkNA1UP1s8YFWi4HmKP+dWV2QAC+xGRTAAAAgGuIy4S2QI3LEFA1CYmOQxOvKwB/cDbZ1JpthTrQYBkAAAAAfr+HqkB9XQmoAgDgZ42H99cHShtONpUUF6mYiHBNyV5vs21MRLiS4gJn6AsAAAAAhDoCqgAA+JGz4f0NA6VpiTHKvX04eVUBAAAAwM8IqAIA4Ef2hvdL9gOlaYkxLgdPG6cDIPAKAAAAAOYgoAoAQABoOLzfE85SAzChFQAAAAB4joCqDzXOkResvNHLqWGS4X/961+6/fbbm6wzefJkzZ49W5LUrVs3bd++3e6+tm3bpueee07Lly/Xzp07VVlZqc6dO+v0009XZmamRo4cqbCwMFPrDwCBwl5qgPoJrQ6UVRNQBQAAQKtFXMYx4jLuIaDqI45y5AUjb/dyWrx4cZMPbm1trd5+++1mt33xxRc1ZcoUVVZWSpKioqIUHR2t33//Xb///rsWLVqkbdu2qXv37t6oOgAEBHdSAwAAAACtAXEZ1xGXaR4BVR9xlCMv2Hi7l1PPnj21du1a/frrr+rZs6d1+aeffqr8/HxlZGRo69atdrdduHChrr/+eknSqFGj9Oijj+qEE06QJO3Zs0dLlizR448/bnqdAQAAAABAYCMu4xriMq4hoOpjZuXIC1WXXXaZHnnkES1evFj/+Mc/rMvffPNNSdL48eP1yCOPNNlu7969uvnmmyVJ55xzjj744AOFh4dbn+/UqZMmT56sq666Sm3a8LYHAAAAAKA1Ii7jHHEZ1wR3wgKEnDPPPFMdO3bU4sWLrcuqqqq0bNkyDRo0SBkZGXa3mzt3roqLi2WxWPTMM8/YfGgbateunWJjY71SdwBwRV5RhTbmFVv/tuaX+rtKAAAAACCJuIyrgj8kjJASHh6uSy65RLNnz9ZPP/2kY489Vv/3f/+n4uJijR8/3uF29Xk8Bg8erF69evmqugDgFkd5m2IiwpUUF+mnWgEAAABAHeIyrqGHKgLOZZddJknWuyFvvvmmLBaLww9ueXm5fvzxR0nSSSed5JtKAkALNMzb9MFNp1n/vJlQHgAAAADcQVymeQRUEXCGDh2q9PR0ZWdnq7S0VB988IFOOeUUde3a1e76v//+u2pr63p79ejRw5dVBYAWqc/bVP9HMBUAAMCPinZKu9bb/hXt9G+dAD8iLtM8hvwj4FgsFo0bN05PPvmk7r//fpWXl1vvjthTXFxsfdy2bVtfVBEAAAAAEAqKdkqzT5Rqym2XR8RKN/5XSkxvfvvy/bbLYlOa3w4IYMRlmkdAFQHpsssu05NPPqmnn35aYWFhuvTSSx2uaxiGD2sGAMGr8QRYSXGR9I4FAACtW/n+umDqmLlSau+6ZQWbpaXX1T3nLDDqaTAWCGDEZZwjoIqANHjwYGVkZGjr1q0688wz1alTJ4frJiQkWB8fPHjQF9UDgGblFVXoQFm1zbLGAU1fSYqLVExEuKZkr7dZHhMRTv5WAAAAqS6Y2mWAe9t4EowFAhxxGecIqCJgPfLII1q9erUuvPBCp+t169ZNYWFhOnz4sLZt2+aj2gGAY3lFFRr55CpV1NQ2eS4mIlxJcZE+rU9aYoxybx9uE+Ddml+qKdnrdaCsmoAqAACAJ1oSjAWCAHEZxwioImCNGzdO48aNa3a9uLg4HXvssdq4caO++eYbH9QMAJw7UFatippazRw/QBkd4m2e89cw+7TEGAKnAAAg+JGzFPAZ4jKOEVBFSLjkkku0ceNGrV27Vps3b1bv3r39XSUAUEaHePVNS2h+RQAAADSPnKVAwGptcZkwf1cAMMN1112n+Ph4GYahW265RYcPH7a73sGDB1VeXm73OQBojbbml2pjXrHNX15Rhb+rBQAAUBdA3bX+yN+Or47kLJ20qu5vzNy6ZY17rQLwqdYWlyGgipDQpUsXPfXUU5Kkjz/+WH/5y1/03XffWZ/ft2+fXnrpJfXr10/5+fn+qiYABIyGE1Wd9+y/bf5GPrmKoCoAAPCv+t6oLw0/8rf0urreqF1PqctZ2mXAkcmgAPhVa4vLMOQfIeO6665TRUWF7rzzTn388cf6+OOPFR0draioKBUXF/u7egAQUOxNVCUxWRUAAAgQ5fuP9EZtGDT1Zb7Ugs2ePd+Qvdyv9rhzfOSTRYBpTXEZAqo+tjW/1N9V8Eig1//mm2/Wueeeq9mzZ2vFihXauXOnDh06pD59+uiEE07QVVddpa5du/q7mgAQEJioCgAABLzU3nU9UX0pNqWuJ+zS65pfNyK2bn1nHOV+dbQ/e/lgGwdPywuk7EzyybZAoMc1mhPo9W8tcRkCqj7ScGhlsIuJCFdSXKSp+zQMw6X1JkyYoAkTJjhdp1evXpo5c6bnlQIAAACAAJFXVNFkZElSXCQ3R+s17i3qSU/NxPS6oKRZPUod9bZtrGBzXRC3fL/tPp1NxnVljhSb6nx7SCIu0xziMu4hoOojjoZWBiO+tAEAAADAd/KKKjTyyVWqqKm1WR4TEa7c24e37t9njnqTetpTMzHd/KBkS3vb+ir9QYinECAuAzMRUPUhhlYCAAAAQOvkSQ/TA2XVqqip1czxA5TRIV4Sec+t7PUmDfaemo1729b/35vpD5z1gg2hFALEZWAWAqoAAAAIKb/++qtmzJihFStWKD8/X8nJyRo+fLimTp2qgQMHBlyZnmxrGIbefPNNLVq0SN99950KCwuVmpqqjIwMnX322Zo6daoiI80dEgjAfWb1MM3oEK++aQneqKJvuTJBkzsTPjnqTWpvH4Hc49JZ7lZXcrU64ur5btwLNtgD04AXEVAFAMBDjXucBHqieCCUffHFFxo9erRKS+s+h+3atdPu3bu1ePFi5eTkaNGiRRo3blzAlOnJtqWlpbrooov06aefSpIsFosSEhK0Z88e7dq1S6tXr9b111+v1NRUU48XgPuCpoepi0O+7fW2laTU2nx1alPmfHt3J2hqSRCxucBkoPa4dJa7taWBYHfPd9dTAvPcAAGGgCoAAB5w1uPE7ETxAJwrLi7W2LFjVVpaqoEDByo7O1u9evVSXl6eJk6cqE8++URZWVkaMmSIevTo4fcyPa3v5Zdfrk8//VSJiYl67LHH9Ne//lVt27ZVTU2NfvnlFy1cuFARERGmHCcAc/ikh2lL82C6OOTbUduniwqUG3WnZKlyur3LEzS5Wm97HAUmfdnjsmHvWDN627aUL8430AoRUAUAwAP2epxIwZ8ovnEv22A/HrQOzz33nPbt26fo6GgtW7ZM3bp1kySlpaXprbfeUq9evVRQUKAZM2bopZde8nuZnmz7/vvv64MPPlBERIQ++eQTDR482PpcRESE+vXrpyeeeMKUYwQQ2Bp+Z0eU5qnX2yMUdqjCdiVXemXaC7zZCUA6avvs2/xfxa6q0s4zZym91wDb7Xd8dSS46Yt8oJLzwGRLg52ucDZJVkuH7JvBk/Pd+BwReAUIqAIAYIZQyWmWFBepmIhwTcleb7OcWYQRDLKzsyVJ559/vjU4WS8xMVGZmZl6+umnlZOTozlz5ig8PNyvZXqy7QsvvCBJuu6662yCqQBaD3vf2cdZtunDqAoVnjNbyV371i101CuzcU9WNwKdXVSgvmHblGE5ElDdGZYnSapKzDiyfaAFF31RH0e9Y30ZhDQrYOzsfAVq2gTARwioAgAAq7TEGOXePrxJTtiAy/EGNFJUVKQNGzZIks444wy764wYMUJPP/20CgsLtXHjRvXv399vZXqybXV1tXJzcyVJV1xxhUfHAMC/uqhA0QUbpAaBSUkuBd/sfWfv2xwprZIKY7or2VlQ1NnwfjuBxZ1b1qtqX11P2JI9ecqNulOxy2yH9qdLKjeiVBudfGRhIAQXG/JVfcwetu8qswPG9s4XE1UBkgioAgCARtISYwicIuhs2rTJ+rh3b/s54hou/+WXXzwOqHpSpifb/vzzz6qurlZYWJgGDhyoZcuW6V//+pd++OEHSdIxxxyjyy67TJMnT1ZUVFQLjw6At0WU2g9MStLhNjHaculnqolPk+R4wsvG39lbC1z8/naUV7NRYHHPoTi1M6KUvvIW67IMSeWKUsFFbyq1Q5cjZe8r1VVv/qqp5QmqySu2Lk+KS1ValwAKvPkr2OkL3ggYh/L5AjxAQBUAAABBb8+ePdbHnTp1kiRNmjRJb775pjIzM/X888+rc+fO1nX27t3r1zI92Xbnzp2SpKSkJL3wwgu67bbbJNWlCSgrK9PatWu1du1aLVmyRLm5uYqLi3N4DFVVVaqqOhLMKSkpce8kACHM3kz2ZuYUD68sVKylUc5RSYU7Nir54xt124LP9KNxZEI6r0x42czw/oLwDhpT9YQeGdVF6clHjjs+qaM6de1ls25MbIUORJSSNsjfCIACPkFAFQAAAEGvrKzM+jgmJkb79+/X3LlzJUlz5szRww8/rHbt2lnXKS2139vLV2V6su3BgwclSRUVFZo2bZpGjRqlOXPmqEePHqqurtZrr72mG264QV9//bWmTZumZ555xuExzJgxQw888EBLTwEQshzNZG8vOGgv8NqYox6mkrT1cJqKGwRO91Xs05mS7vhzH7XvfaJ1uafB3IbD9qOKtipddb1KK42GvUmblrFLqWrf+0RlNJMr3lnaoDXbCnUghCbvBAACqgAAAAg5KSkpyszMVE5Ojq688kolJyfr0KFDAVumO9sePnxYklReXq4OHTooJyfH2gs1MjJS11xzjTZu3KiZM2fq5Zdf1mOPPabY2Fi7+5o2bZq1h6tU10M1PZ2eTYC9mezt5RR3FHi1p3EP03YxEZKkf63YpB+XHwlCHmfZpjOjpP4xe5Vs2dZgDymqy1TqHnvD9qW6fKdXvfmrdulIQNXT3qSNUxAw2SWAUEVAFQAAAEGv4bD2iooKSdLChQu1cOHCJsslKT6+0QQwPi7TrG2vvvpqu0P6J0yYoJkzZ6qiokLr1q3T6aefbvcYoqKiyLMKqGkv0/oepRkd4tW3Uc/Mhr1Nt+aXNgm8OtK4V2aH+LrP3qzLBqgytZ91eURpDx1+O0bJH99ou4MWzqzuaNh+bXSyXvpfjtb6Y2ncm9RZz1pXMNklgFBFQBUAAABBrz4PqVSXn7Rv375N1tm9e7f1cceOHf1apifbpqamWh87mtCqe/fu1se7du1ydAgA5Hx4f8Mepc56Ww7pkdzi4GBG+3ipS8OgbYI0eY39mdV3fGW73MFkQzsLK1T5v4mhtuaXujRs39nxeZK7lckuAYQiAqoAAAAIen369LE+3rx5s0aOHNlknc2bN1sfH3PMMX4t05Nte/U6MhGMxWJpQc0BNGRveL/UtEepvd6W9tYzReOJhWJT6nqoLr3Odr1GvVYdpRFwJSjq0+NzkbcnBgtFnDPANwioAgAAIOglJiaqX79+2rBhg1atWqUbbrihyTorV66UJCUnJ9vtEerLMj3ZtmPHjurevbu2b99uE3RtaPv27dbHaWlpdtcBWgN3gkv2hvc35rfelonpdYFTe71Wy/dbA6qO0gi4GlDzZ2/Sxq/V/rJqXf/aOpcmBvOkHMk3AUdflOvOZGoAPENAFQAAACFh/Pjx2rBhg9577z3t3LnTZnKl4uJiLVq0SJI0ZswYhYeHO9xPw16f27Ztsxk+b2aZnmx70UUXaebMmZo/f77uvffeJpNOLViwQFJdvtVBgwY5rD8QykIuuNS416oTTdMIBDZnr9WrV5+olP/1rvU0/6q/3hPOyn0hc5D1+CTPgqyuTqbmFUU7bQP+9RykpQCCHQFVX3J0gQk2XBABAEAAmjx5smbNmqV9+/bp4osv1uLFi5WRkaFdu3bp6quvVn5+vqKjo3XPPfcERJmebHv77bfrxRdf1J49e3TppZdq9uzZ6t69u6qrq/Xaa6/p+eeflyTdcMMNiokJsqAR0AL2ev/ZmzDKK8Ele7/z+M3ULFcm9zK7B6e/Ao72yq3vgZs1778267oT3HVnMjWvKtopzT5Rqilv+lwLJ1PzGuIyMAkBVV9xdoEJNl66IH7++ec688wzmyyPjY1VWlqaTj31VP3tb3/TKaecYvP8ggULNHHiROv/27Rpo6SkJKWnp+v0009XVlaWBg4caGpdAQBA4ElISNCSJUs0evRorVu3Tr169VJCQoJKSkpkGIYiIiK0YMEC9ejRIyDK9GTbo446SosWLdLll1+ujz76SD169FBSUpLKyspUXV3343rEiBF68MEHTTtWIFA56v0neT5hVLMc/c4LtCBSAPHW5F7u8HnA0UG5jXPWuhPcdXUyNZ8o31/3GRgzV0ptMFminbQUfkVcxiliMu4hoOorji4wwcZHF8SkpCRFRtZ9Cezfv19btmzRli1btHDhQk2bNk2PPPKI3e1SU1NlGIYKCwu1b98+ffvtt5o1a5auuuoqvfjii4qOjvZanQG0Do56AgAIDMOGDdP333+vRx55RJ988ony8/PVsWNHDRs2THfddZdOOOGEgCrTk23HjBmjb7/9Vv/617/06aefau/evYqOjtbgwYN1xRVX6LrrrlNERITpxwsEGkeTSkk+yI1p73eer4NIBZvtPw5Qvpr8ylGv5UDiSc5aVydT86nU3lKXAf4p2xXEZVxGTKZ5BFR9LdAvMAFi6dKlOuOMMyRJtbW1+vbbbzVlyhT95z//0aOPPqoBAwbo0ksvbbLdmjVr1L17dx0+fFgbNmzQvHnz9Nxzz2nhwoXav3+/PvjgAx8fCYBQElA9AQA41LNnT82bN6/F2xuG4dMyPdn2uOOO0/z581u0LRBq/NXrUJJ/fufFptT1Ult6ne3yiNi65wKYtye/aq7Xckvbbf6a0MoZV9/3jYPJ/q63XxGXaRYxmeYRUEXACw8P15AhQ/Tee++pd+/eKiws1PPPP2/3w1svLCxM/fv316xZs3TCCSdowoQJ+vDDD/Xqq68qKyvLh7UHEEoCsicAAABonRLT64b8kr/V7ggid3stN9d7tT7nqSsTWgXSiCZnKRY8mhAryHpGo+WIydhHQBVBIyUlRSeeeKI+/vhjfffddy5vl5WVpeeee05r167VM888EzIfXgD+49ceMAAAIDg1ngzHjCBUYnqrC5425mwEkSs5WR0FHO2JiQjXq1efaA1C2st5asaIJlcCsK4Gae2lWPBoQqwg7hkNzxCTsUVAFUGlTZu6t2xtbdOhG85cfPHFWrt2rb799lvt2rVLXbp08Ub1ACCkMVQMABAIAqn3n1MNA6blBVJ2pv3JqwhCecTTEUSOcrra48o+PamPO8FdyfUgrb0UCy2eEIue0a0aMZkjCKgiaJSWlmrNmjWSpD59+ri1bb9+/ayP161bFxIfXgDwFWdDxZrtxQAAgImCIp+5sx58V+ZIsam26xKEMoUnI4i8kdO1JfVxJ7greXZz26Njpmd0q0RMxhYBVQQ8wzD0888/64477tDevXslSTfddJNb+zjqqKOsj//44w9T6wcAoc5e497lXgwAAJgoKPKZ04PP6xr2Sg6EHspm1sfbE3YB7iImYx8BVQSkMWPGKDKy7g5zUVGRqqqqJEkWi0XTpk3TVVdd5db+4uLirI9LSkrMqygAtBI07gEAgSTg85nTg88rnI2a8UcP5UCrT8BqnC+YmwsBj5hM8wioIiAdOHCgybKBAwfqtdde03HHHef2/iwWi/WxYRge1Q0AAABAaOmiAkUXbJAsDWaEJ+gTcBwNifdXD+VAq0/AcZb+YvxrpL8IYMRkmkdAFQFp5cqVOuOMM1RbW6vffvtNjzzyiF599VWNHz9en3/+uVJTU5vfSQNlZWXWxwkJAXwnGwAAAIDXNRyWnbd9s3Kj7lTssirblQj6BKRAGzUTaPUJKPbSX9RP0LZorO26EbF16/L5CgjEZJpHQBUBLTw8XL169dKCBQu0d+9effzxx/r73/+ut99+2639NMzRkZaWZnY1AQAAAHhBXlFFkxzenrA3RPs4yzaNiqpS4Tmzldy1b91Cgj6AOeylv2gcZC3YXNeLtXw/n60AQ0zGMQKqCBozZ87UcccdpyVLluiLL77Q6aef7vK2GzZssD4eNGiQN6oHIASZ/SMOAAC4Lq+oQiOfXKWKmlqb5Z7kp7Q3RDu6IEFaprpgapcBR1Ym6AN4BzmGgxIxGVtBG1Dds2ePsrOztWLFCn3//ffat2+fIiIidPTRR2v06NGaMmWKOnXq5O9qwkR9+vTRpZdeqsWLF+sf//iHVq9e7fK2y5Ytk1SX8yNU7oYA8C5v/IgDAACuO1BWrYqaWs0cP0AZHY7kNvU0P2WTIdoN86Y2RNAHrVDjDgTkg0U9YjK2gjag2r17d+ssY5LUrl07VVRUaMOGDdqwYYPmzp2rpUuXavjw4X6sJcx2++23a/Hixfriiy/06aef6qyzzmp2m1dffVVr1qyRJN18883eriKAEOGtH3EAAMA9GR3i1TctNHLuAYHKXjoMqa4zQe7tw2n/QhIxmYbC/F2BlqqtrdXw4cP12muvKT8/X8XFxSovL1dubq4yMjJUWFioCy+8UHv27PF3VWGiwYMHa9iwYZKk6dOnO1zv8OHD+v777zVlyhRdc801kqRRo0YpKyvLJ/UEEDrqf8TV/9GYBADAc3lFFdqYV2zzl1dU4e9qAa1WfTqMD246zfo3c/wAVdTU2qTIQOtGTOYIU3qo1tbWKjw83IxduWzlypU67bTTbJa1adNGZ511lnJycjRw4EAVFxfrxRdfdPoiI/jccccdWr16tb788kt98sknNs8NGTJEklRUVKRDhw5Zl//1r3/Vyy+/LIvF4tO6AgDQWvmjfQggODhLq0NPOMB/mqTD8LWCzbb/j00h7UYAIiZTx5SAapcuXXTFFVcoMzNTAwcONGOXzWocTG3o+OOP19FHH62tW7dq3bp1PqmPyxpfIIJNANT/vPPOU58+fbRp0yZNnz5dkyZNsj5XUFCg8PBwJSYmqmvXrjrttNOUlZUVMkmPAQAIFv5oHwIIDvbS6mzNL9WU7PU6UFZNQBUIMK7kVW08mauzdZuITZEiYusmfWsoIrZucjizg6oBENfwiJ/rT0ymjikB1X379mnWrFmaNWuWjjvuOGVlZemKK67w66RQiYmJkhQ40W9HF4hgFBFbdzwmO+OMM2QYRrPrWSwW/fLLLzbLJkyYYHp9AABAywVi+xBAYCE3KhDYXM2r6qjXub117UpMrwuclu8/sqxgc138pHy/eQFV4jJOEZNxjykB1fPPP18ff/yxampqtHHjRk2dOlV33323Ro4cqQkTJuiiiy5SVFSUGUW5pKysTD/99JMkBU4U3N4FIljR7R4A8D/MBAtHAq19CCA4NPxeafwdA8C36vOqNux5aq83uaPJXN3qeZ6Y7v04A3EZmMiUgOq7776rAwcO6O2339Ybb7yhL774QrW1tVqxYoVWrFihdu3a6dJLL9VVV13ldKi+WWbOnKny8nJFRUU5jZJXVVWpqqrK+v+SkhLvVswXFwgAAHyAmWDRnEBrHwIIbM6+V5LiIv1TKUcaDrcN9qHDQDPcyasaFL3OicvAJKYEVCUpKSlJkyZN0qRJk/THH3/ozTff1Ouvv64ffvhBxcXFeuWVV/TKK6+oe/fuyszM1BVXXKFevXqZVbzV+vXr9fDDD0uSpk2bpq5duzpcd8aMGXrggQdMrwMAAKHO1R4LaN0CpX0IIPDZ+16RAmzkg7M8j15IiQYEMnqTo7UzLaDa0FFHHaU777xTd955p3766Se9/vrrevPNN7V9+3Zt27ZNDz30kB566CENHjxYmZmZuuyyy5SamupxuQUFBRo7dqwqKyt11lln6d5773W6/rRp03TbbbdZ/19SUqL0dO5UAADgCr/PBIug4q/2IYDg4bPvlaKdTXM1usLRcGGG3qIVCare5IAXeSWg2tCxxx6rRx55RI888oj+85//6PXXX9fixYt14MABrV27VmvXrtXtt9+uc889V9dee63+8pe/tGgiqYMHD+rcc8/Vb7/9puOPP15LlixReHi4022ioqLI3QUAAOBjvmofAkATRTul2SdKNeW2y13tZcpwYbRyQdGbHPABrwdU61VVVSkvL087d+5UWVmZLBaLdfawmpoavf/++3r//feVkZGhefPmaejQoS7vu7KyUhdeeKHWrl2rjIwMLV++XImJiV46EgAAAJjBm+1DALCrfH9dMHXMXCm195Hl9DIFXMYoJcAHAdWVK1dq0aJFWrp0qXXSJ8MwFBkZqfPOO0+XX365Nm7cqAULFuj333/Xli1bNHLkSK1evVpDhgxpdv+HDh3SuHHjtHLlSqWnpys3N1edOnXy9mEBAACghbzdPgSAZqX2lroM8HctAABByisB1Y0bN2rRokV64403lJeXJ0nW3gaDBw/WhAkTdPnllyspKUmSNHbsWN133316/fXXdfPNN6uoqEj33Xef/u///s9pOYcPH1ZmZqbef/99dezYUbm5uerWrZs3DgkAAAAe8FX7EEDgySuqaDKJoeka50WV6HUKAPAa0wKqu3bt0htvvKFFixZpw4YNko40kjt37qwrr7xSEyZM0J/+9Ce721ssFl155ZWqqqrSddddp6+//rrZMv/2t79p8eLFSklJUW5urnr37t3sNgAAAPANf7QPAQSWvKIKjXxylSpqam2WmzqBjbO8qONfk2IbTHDn6gRUAAA4YUpAdeTIkVq1apUOHz5sbSRHR0frwgsvVFZWlv785z8rLCzMpX3V58aqH/7lyK233qqXX35ZCQkJWrFihfr27evZQXio/rgRWnhdAQBoGX+0DwH4VuOep1LTiWkOlFWroqZWM8cPUEaHeIfrecReXtTyAik7U1o0tun6rk5ABSCo8Ps9NAXq62pKQPWzzz6zPj7llFOUlZWl8ePHKyEhwe19RURENLvOjh07NHPmTElSdXW1Ro8e7XT9PXv2uF0PV9X/EKitrW1mTQSj+tfV1R98AACgjq/bhwB8y1nP09zbhzcJlmZ0iFffNPc//25pnBf1xv82TQMgkQoACDHEZUJboMZlTAmopqenKzMzU1lZWerVq5dH++rZs6cOHz7sdJ2Gz1dUVKiiosKjMj0RERGhiIgIlZaWKj4+vvkNEFQOHjxofY0BAIDrfN0+BOBb9nqebs0v1ZTs9VqzrVAHGizzm8R0AqdAK0BcJrQFalzGlIDq9u3bZbFYzNiVS7p37x4wXX4tFovatm2roqIiJSQkKCbGpGEr8LuKigqVlJQoMTHRp+9vAABCga/bhwD8o2HP06S4SMVEhGtK9nqbdUzNlwog6DS+seJWyo/GeY/t9DAnLhO6AjkuY0pANdAOytdSU1NVUVGhHTt2qF27dmrbtq3Cw8Nb/XkJRoZhqLa2VgcPHlRJSYmioqKUmpra/IYAgp5PZiAGWhHaQUDrk5YYo9zbhzebVxVA6+DsJou91CA2YlPq8h0vvc52eURsXTqPRkFV4jKhI1jiMqYEVFu78PBwpaenq6CgQAcPHlRRUZG/qwQPRUREKDExUampqQoPD/d3dQB4mU9mIAYAoBVIS4wheApAkv2bLPWpQQ6UVTu/ViSmN82DXLC5LsBavr9JQJW4TOgJ9LgMAVWThIeHq2PHjurQoYNqamrI8xXEwsLCFBERwZ0soBXxyQzEAAAAQCvj0U0WN/MgE5cJHcEQlzEloDpixAhZLBbNmzdP3bp1c2mbyspKjR49WhaLRZ9++qkZ1QgIFotFkZH0ZgKAYOSTGYiBVoL2IQAA8AfiMvAFUwKqn3/+uSwWi8rKylzepra21rodAAAAQgvtQwBeU7Sz6TBgAEHFo4mqgADAkH8AAAAAQHAo2inNPlGqKbddHhFbN4kNgIDm0URVQADxW0D14MGDkhSQiWUBAADge7QPATSrfH9dMHXMXCm195HlsSlu5VoE4B8eTVQFBBC/BVS/++47SVJCArnqAAAAQPsQCGR5RRVNAiB+ldpb6jLAv3UA0CIeTVQFBAhTA6qu5LuqrKzUmjVrdOutt8pisahfv35mVgEAAAABhPYhEFwaB04laX9Zta5/bZ0qamptlsdEhCspjolfAACtT4sCqvaGYRmGob59+7q9r8zMzJZUAQAAAAGE9iEQ/PKKKjTyyVVNAqdSXfD01atPVEqDACqTyADwi8YT0ZHyA37QooCqYRhuLbcnLCxMN954oyZOnNiSKgAAACCA0D4Egt+BsmpV1NRq5vgByugQb/McwVMA3tY4lUiT605sSt0EdEuvs90wIla68b8EVeFTLQqoTp8+3eb/DzzwgCwWi66//np16NDB4XYWi0XR0dFKT0/XsGHDlJaW1pLiAQDwSMDlgQNCAO1DIHRkdIhX3zRyGQPwjaS4SMVEhGtK9nqb5TER4cq9ffiRoGpiel3gtHz/kZUKNtcFWMv3E1CFT5kWUJWkG2+8Uccee6zntQIAwEscDWckDxzgGdqHAACgJdISY5R7+/AmHR6mZK/XgbJq216qiekEThEQTJ2UCgCAQOdoOCNDGc3T7HAtAAAAoIG0xBjaiwgqBFQBAK0SwxnN5/JwLQAAAAAIYqYEVOuHeDnLjwUAAEKbW8O1EPJoHwIwRdHOpvkSAQDwM1MDqgAAoHVjuBbq0T4E4LGindLsE6WactvlEbF1s30DAOAnDPkHAAAAAASe8v11wdQxc6XU3keWx6YwKQ0AwK8IqAIAAK9joioAQIul9pa6DPB3LQAAsPJbQHX79u26+uqrZbFY9Omnn/qrGgAAwIuYqAruoH0IAACAYOC3gGpZWZk+//xzWSwWf1UBAAB4GRNVwR20DwHfyiuqaHJ99pnGk01JDOUH0ITLo5waT1jH9QRexpB/AADgVUxUBQCBJ6+oQiOfXKWKmlqb5TER4UqKi/Ru4c4mm7rxvwRBALg+yik2pe7asfQ62x1wPYGXEVAFAABASPn11181Y8YMrVixQvn5+UpOTtbw4cM1depUDRw4MODKNLO+55xzjpYvXy5Jmj9/viZMmNDSQ0KIO1BWrYqaWs0cP0AZHeKty32S49reZFMFm+sCIuX7CYAAcH2UU2J6XeC0YY93rifwAQKqAAAACBlffPGFRo8erdLSuiGC7dq10+7du7V48WLl5ORo0aJFGjduXMCUaWZ933jjDWswFXBVRod49U1L8E/h9iabajhst/EQXgCtisujnBLTCZzC59wKqB599NGSJIvFol9//bXJcnfU1NS4vQ0AAAACSyC1D4uLizV27FiVlpZq4MCBys7OVq9evZSXl6eJEyfqk08+UVZWloYMGaIePXp4VJYZZZpZ3wMHDujWW2/Vn/70J/3888+mHBvgU86G7cam+KdOAIIbeVXhRW4FVLdv3y5JTSYK2L59uywWiwzDMK1iAAAACHyB1D587rnntG/fPkVHR2vZsmXq1q2bJCktLU1vvfWWevXqpYKCAs2YMUMvvfSS38s0s7533nmn8vPz9frrr+vss8825dgQWvw6AZUr7A3blQiAAHAfeVXhA24FVLOyspw+f+GFFyoxMdGlfRUVFendd991p3gAAAAEmEBqH2ZnZ0uSzj//fGtwsl5iYqIyMzP19NNPKycnR3PmzFF4eHiLyzKjTLPqu3r1as2bN09jxozRyJEjPT4mhB6/TkDlDobtAnBB4xtCTXI/k1cVPuBWQHX+/PlOn3/kkUd07LHHurSvH3/8kYAqAABAkAuU9mFRUZE2bNggSTrjjDPsrjNixAg9/fTTKiws1MaNG9W/f/8WlWVGmWbVt7q6Wn/7298UHR2tp556yqPjQejy6wRUAGCSpLhIxUSEa0r2epvlMRHhyr19eNOgKoFTeBGTUgEAACDobdq0yfq4d+/edtdpuPyXX37xOKDqSZlm1XfGjBn65Zdf9OCDDzbp5Qo05pMJqIp2MmwfgFekJcYo9/bhTdKXTMlerwNl1dwggk+F+bsCAAAAgKf27NljfdypUydJ0qRJk9S2bVvdcMMNkqTOnTtb19m7d69fyzSjvps2bdKMGTN09NFH684772zRMVRVVamkpMTmD2ixop3S7BOll4bb/s0+UdqaK+1aX/fXeKIYAHBRWmKM+qYlWP8a9roHfMmUHqo333yzLBaLUlNTzdgdAACmCfhJOIAQ5ev2YVlZmfVxTEyM9u/fr7lz50qS5syZo4cffljt2rWzrlNa6vm1wJMyzajv3/72N1VVVenpp59WdHR0i45hxowZeuCBB1q0LdBE+X6pplwaM1dK/V8P6/ICKTtTWjTWdt2I2LqeqwAABCFTAqozZ850e5ukpCRdddVVTWaEBQDALEEzCQcQgvzdPkxJSVFmZqZycnJ05ZVXKjk5WYcOHfJ4v94q091t582bp1WrVuncc8/VBRdc0OI6T5s2Tbfddpv1/yUlJUpPZ2g2PJTaW+oy4Mj/G08OI5EGAAAQ1PyWQ7VLly5asGCBv4oHALQCTMIBBBdP2odxcXHWxxUVFZKkhQsXauHChU2WS1J8vOdDBD0p05Nt9+3bpzvvvFORkZGaNWuWR8cQFRWlqKgoj/YBNIvJYQAAIYYcqgCAkFc/CUf9H8FUIPTU5yGVbPOTNrR7927r444dO/q1TE+2veeee1RYWKjbbrtNvXr1cr/iAAAA8AgBVQAAAAS9Pn36WB9v3mx/wpuGy4855hi/lunJtlu2bJEkPfbYY7JYLE3+6k2cOFEWi0Xdu3d38YgQKvKKKrQxr9j6R/5wAADMRUAVAAAAQS8xMVH9+vWTJK1atcruOitXrpQkJScnq2/fvn4t0x/1RetQnz/8vGf/bf2bkr2e/OEAIEkFm6Vd623/inb6t04ISj7Nobpt2zYVFBSoZ8+eSk5O9mXRAAAACEBmtg/Hjx+vDRs26L333tPOnTttJlcqLi7WokWLJEljxoxReHi4w/007OW5bds2pz08PSmzpdt+/vnnTs7CkfrPnz9fEyZMcLouQg/5wwHAjtgUKSJWWnpd0+ciYusmzyPXM9xgSg/V4uJiPfroo3r00Ue1bdu2Js+vXLlSvXr1UkZGhk4++WR17NhRl112mYqKiswoHgAAAAHGH+3DyZMnq3379qqsrNTFF1+srVu3SpJ27dql8ePHKz8/X9HR0brnnntaXIaZZfqjvmg9yB8OAA0kptcFTSetsv0bM1eqKZfK9/u7hggypvRQfe+993Tvvfeqc+fOuvPOO22e27Rpky644AKVl5fLMAxJUm1trd5++23t2LFDX375pU0vAAAAAAQ/f7QPExIStGTJEo0ePVrr1q1Tr169lJCQoJKSEhmGoYiICC1YsEA9evQw5Rg9LdMf9QUAoNVKTKcXKkxjSg/V9957T5J02WWXKSIiwua5p556SmVlZZKkqVOnatmyZcrMzJRhGPrmm2+0cOFCM6oAAACAAOKv9uGwYcP0/fffa+LEiTrqqKNUUVGhjh07aty4cfr66681fvz4lh+UF8r0R30B0xTttM1DWGB/gjUAAEKNKT1U165dK4vFouHDhzd57t1335XFYtE111yjxx57TJJ04YUX6uDBg3rnnXf05ptvKisry4xqAAAAIED4s33Ys2dPzZs3r8Xb1/ea9VWZnta3sZbUH3Bb0U5p9ol1Q2Ubioity1UIAEAIMyWgumfPHkmySaQvSTt27FB+fr4sFotuvPFGm+euuuoqvfPOO/r+++/NqAIAAAACCO1DIMSV768Lpo6ZK6X2PrI8NoUhtQCCT+Me9lzL0AxTAqr1d8ErKyttlq9Zs0aSlJqaqv79+9s817VrV0lSYWGhGVUAAABAAKF9CLQSqb2lLgP8XQsArdzW/FKb/yfFRbo2GV9sSl3P+qXX2S6PiK2bxIqgKhwwJaDaoUMH5eXlafPmzTrllFOsyz/55BNJ0qmnntpkm6qqKklS27ZtzagCAAAIMi1u+CIo0D4EfCOvqEIHyqqt/298bQWAUJYUF6mYiHBNyV5vszwmIly5tw9vvm2ZmF4XOC3ff2RZwea6AGv5fgKqcMiUgOpJJ52knJwcPfPMMxo7dqzi4+O1fft2ZWdny2Kx6PTTT2+yzaZNmyRJnTt3NqMKAAAgSHjc8EVQoH0IeF9eUYVGPrlKFTW1NstjIsKVFBfpp1oBgO+kJcYo9/bhTW4sTclerwNl1a61KxPTCZzCbaYEVK+99lrl5ORo/fr16tatm3r27Kmff/5ZZWVlioyMtDs76WeffSZJOuaYY8yoAgAACBKmNHwR8GgfAt53oKxaFTW1mjl+gDI6xFuX0+MfQGuSlhjDNQ8+Z0pAddSoUZo8ebKee+45HThwQGvXrrU+9+CDDyotLc1m/bKyMuvsrmeeeaYZVQAAgGGPQYSGb+ijfQj4TkaHePVNS/B3NQAAaDVMCahK0jPPPKNzzz1Xb731lvbs2aNu3brp8ssv1/Dhw5us+/HHH+voo4+WJF1wwQVmVQEA0Iox7BEIPLQPgRBRtNM2v6DUdEZsAAg1ja9zsSmkBoCVaQFVSTr33HN17rnnNrve2LFjNXbsWDOLBgC0cgx7BAIT7UMgyBXtlGafKNWUN30uIrYuwAAAoSQ2pe76tvQ62+URsXUTWBFUhUwOqAIA4G8MewQAwETl++uCqWPmSqm9bZ+jtxaAUJSYXhc4bdgzv2BzXYC1fD/XPUgioAoAAAAAaE5qb6nLAH/XAgB8IzGdwCmcIqAKAAAAAEGAyRcBAAgMBFQBAAAAIMAx+SIABAAmqsL/mBpQ3b17t5YuXarvvvtOe/fuVXl5uQzDcLqNxWLRp59+amY1AAAAECBoHwLm8Nnki0U7m+YNBIAg1LgXv0fXSyaqQiOmBVQfffRRPfTQQ6quPjIExVlj2WKxyDAMWSwWs6oAAACAAEL7EDCfVydfLNopzT6xbhKqhiJi64IJABAEkuIiFRMRrinZ622Wx0SEK/f24S0LqjJRFRoxJaA6b9483Xvvvdb/JyUlKSMjQ7GxsWbsHgCA4NS4l4/EsCC0GrQPgSBUvr8umDpmbt0kVPX47gIQRNISY5R7+/AmOaenZK/XgbLqlvdSZaIqNGBKQHX27NmSpLi4OL3xxhs677zz6FkAAAgM/gpqOuvlw7AgtAK0D4Egltpb6jLA37UAgBZLS4xxOXDaeMI/yc30AORVbZVMCaj+8ssvslgsevDBB3X++eebsUsAADznaVDTk2CsvV4+DAtCK0L7EAAABJrGeVX3l1Xr+tfW2Z3wr9n0AORVbdVMCajGxsaqsrJSp5xyihm7AwDAHO4ENRsHT8sLpOxMz3uY0svHLaZOHgC/on0IAAAChaO8qlJd8PTVq09USlykJDfSA5BXtVUzJaDav39/rVy5UmVlZWbsDgAAc9kLajYcmuMseHpljhSbemQbGkhe4ZXJA+BXtA+BIND4ZmLjYasAECLs5VWt59ENfPKqtlqmBFRvueUWffbZZ1q4cKHOOussM3YJAIB3OBua0zB4Wr+uKw0ke6kB3PlRam97e0I4H5PXJg+A39A+BAKcs7Q4sSn+qRMAeJE7eVWB5pgSUD3//PM1ffp0PfTQQ0pOTtYDDzygdu3ambFrAABc1kUFii7YIFni6xbYC2raG5ojtTxY6egHqeTaj1Jn29vbXwjnY6KRG1poHwIBzl5aHCmkb94BAGAWUwKqV199tSTp6KOP1jPPPKMXXnhBgwcPVnp6uqKjo51ua7FY9Morr5hRDQBAK9J4Ns687ZuVG3WnYpdV2a5oL6jp6dCchoHags32f5BKjn+Uurp9422WXift+Mo2GMwPXwQo2oeAZxp/zzXOMW0acn0DAOA2UwKqCxYskMVikSQZhqGqqir95z//aXY7wzBoMAMA3JZXVKGRT66ymY3zOMs2jYqqUuE5s5Xcte+Rlc0MODpLF9D1lObL8WR7ZhFFkKF9CLScve85qS6vdNL/Jk0BAAD+Y0pAtWvXrtYGMwAA3nagrFoVNbWaOX6AMjrUDe+PLkiQlqkumOqtnjaepgvwZHtmEUWQoX0ItJy97znJw4lTAACAaUwJqG7fvt2M3QAA4JaMDvHqm5ZQ9x9LvPOVzeJpugBPtmcWUQQR2oeA52y+5wAAwaPxXA6k6Qo5pgRUAQAAAAAAgFaNNF2tBgFVAEBgK9rZZIh8dEGpuqjATxUKQNwBBwA0p/H3aePvDgCA50jT1WoQUAUABK6indLsE6WacpvFGZJyo6K0s3SIpFY8FJI74AAAVzj4PlVEbN13CQDAPI7SdNEJIqSYHlDNz8/XkiVLtGbNGuXn56uiokLz589Xt27drOv8/vvvKisrU3R0tI4++mizqwAACBXl++t+/I2ZK6X2ti7euWW90lfeovDKQj9WLgBwBxxBgvYh4GcOvk/5MQ8APkAniJBkWkD18OHDmj59uv71r3+purpakmQYhiwWi8rKymzWXbx4se655x5FRUUpLy9PSUlJZlUDABCKUntLXQZY/1u1r9R/dQk0rk5UZSd1Aj+k4W20D4EA0+j7FADguryiCh0oq7ZZlhQXqbTEGOcb0gkiJJkWUJ04caIWLVokwzAUHR2tjIwMbdy40e66kydP1iOPPKKysjLl5OTo2muvbVGZ3377rb7++mt98803+uabb7R582YZhqGsrCwtWLDAg6NBq0BwAUAoazikqLxAys60P9QzCO6Kb823DaC71HBFQPBH+xCAyJcKACZo2AbdX1at619bp4qaWpt1YiLClXv7cNeCqgHe5oZ7TAmovv/++3rttddksVh01113afr06YqOjlZYWJjd9ePi4nTJJZdowYIFWrFiRYsbzCNGjFBxcbEnVUewa2lQ1FkeqSAILgCoE1W0VdoVX/cffizWcTak6MocKTa17v9BcFc8KS5SMRHhmpK93ma5yw1X+JW/2odAMGrc66nxjSS3kC8VADzirA366tUnKiUuUlLdtXpK9nodKKumXdoKmRJQfemllyRJF110kWbMmOHSNiNHjtSCBQu0fv36FpcbGRmpwYMH6+STT9bJJ5+sp556St9++22L94cg405Q1N5d+sZ5pOqDCzu+ahqk9QS9XgH7POglXhudrHIjSukrb5FWNniCH4v2hxRJQXktSkuMUe7tw5sEGWi4Bgd/tQ+BYJNXVKGRT66y2+sp6X8/2t1CvlQA8Ii9NqjkpVFSTFQVtEwJqK5Zs0YWi0V//etfXd4mIyNDkpSXl9ficv/44w9FRh5pZMydO7fF+0IQstdYtBcUdTbUtespRy5Wjnp1eSoiVhr/2pFeYfVlcZFEa+ZhL/Ga+DSNrHpCCy/vqYz28Uee4LNVJ4SGFKUlxhA4DVL+ah8CweZAWbUqamo1c/wAZXQ48p3m8Q938qUCQIt5vQ3KRFVBz5SA6oEDByRJPXr0cHmb8PBwj8ttGExFK9awsejqUNf6dRtepBz16vJEfTB30dim9SHIitbM1RsiTobx71KqKlP7SV0SfFBhAO7yV/sQCFYZHeLVN43vNABoFZioKuiZElBNTk5Wfn6+CgsLXd5m06ZNkqT27dubUQWEGntDgRuzF2jxdKirN3p1Na6PsyArd6LQ2rh6Q6S1D+MHghDtQwAAACdCaFRZa2RKQLV///765JNP9OGHH2rkyJEubfPqq6/KYrHoxBNPNKMKCCWOhgLbYy/QEmgXJXv14U4UWhtXZht2cENkz6E4FZS1k8qOTELo0WQdAHyC9iEAAGgNGv828UquVQQcUwKq48eP14oVKzRnzhydf/75GjFihNP1n3jiCX3yySeyWCwaN26cGVVAKHGUSN+eYB0m7yjo68os5cF6zGi93JltuNFn48hEHU0/Gy2erAOAT9A+BJrKK6poMskJNwkBIDglxUUqJiJcU7LX2yyPiQhX7u3DCaqGOFMCqllZWXr22We1fv16nXPOObrxxht18cUXW5+vrq7Wrl279M033+iFF15Qbm6utffBJZdcYkYVWqSqqkpVVVXW/5eUlPitLrCjNSXSd2dCLPKvIth4MNuwo4k6JO78AoEuWNuHgLccuUlY2+Q5j24SujIKBABgurTEGOXePtzmRtnW/FJNyV6vA2XV/FYJcaYEVMPCwvTBBx/ojDPO0NatW/XMM8/omWeekcVikSQNGjTIZn3DMNSzZ08tW7bMjOJbbMaMGXrggQf8WoeQYC/fqTsBPhqBrk+IRf5VBDMPbpIwUYcX2bvmcpMGJgjW9iHgLV65SejOKBAAgOnSEmPsXr9JAxD6TAmoSlKXLl307bffatq0aZo3b54qKirsrhcVFaUJEybo8ccfV7t27cwqvkWmTZum2267zfr/kpISpafzA9ItzhpxrgT4aAQe4WruV0f5VxvOjC4REAHgnLOe8dykgUmCsX0IeJupNwk9GAUCADAfaQBaD9MCqpIUHx+vZ599Vg899JA+++wzrV+/XgUFBZKklJQU9e/fXyNGjFBycrKZxbZYVFSUoqKi/F2N4GavEedogiV7PVkLNtMIdFfjwKuzmdEJiABwxFHPeCbJg8mCrX0IBKXWlCoLAAIYaQBaD1MDqvUSExM1ZswYjRkzxhu7RyBqrhHnqCeqVBf463oKP9xbyl5QhIAIfMXTlB/wL1d7xgMmoH0IAABaA0dpAFzWOCUXv68CklcCqkATjoYjSVwczEBQBP7gLGVHw4nTWmNeZAAAAABwB6NPg4rHAdXa2lq9//77WrlypdavX6/t27erpKREZWVliouLU7t27dStWzcNGDBAZ555ps4//3y1aUMct9ViOBIQOuzdKHE2cVpry4sc7LgzDg/QPgQAAHATo0+Dikct1xdeeEHTp0+35sGqZxiGJKm4uFglJSX6448/9OWXX2r27NlKSUnRAw88oL///e+eFC1JKi0tVWVlpfX/NTU1kqSqqiqbOrVt25ZcqWZpPLyXnmcAGt8osZeX08VgXF5RRZN8Q/Ax7ozDQ/5uHwIAAAQtRp8GjRYFVA8fPqzx48dr6dKl1sZxvdjYWMXGxiomJkaVlZUqKytTefmR4aAFBQWaPHmycnNztWTJElkslhZXfvLkyXr11VebLF+8eLEWL15s/f/8+fM1YcKEFpeD/3E2vNdez7OGwVYCr/7h6nmn5xnM1MJGQF5RhUY+uUoVNbU2y2MiwpUUF2lW7dAc7oyjhQKlfQgAAAB4W4sCqnfffbdycnIkSZ07d9a1116rP//5zzrmmGOUktI0sLZ//3798ssvWr58uV5++WXt2bNH77zzjqZOnaonnnjCsyOA7zjKg9o4GOesdxNDfn3D0WvgCD3PEAAOlFWroqZWM8cPUEaHeOvypLhIZsP0Ne6MowVoHwK2GHUBAGio8fcAv3OCm9sB1R07duiZZ56RxWLRBRdcoNdff12xsbFOt0lJSdHQoUM1dOhQ3XXXXbrsssv04Ycf6tlnn9VNN92krl27tqjyCxYs0IIFC1q0LTzQXB5Ue72bJHpB+pKj18Aeep4hwGR0iFfftAR/VwP2kFcVDgRS+xAIBIy6AADUS4qLVExEuKZkr7dZHhMRrtzbhxNUDVJuB1QXLlyo6upqderUSW+++aaio6Pd2j4uLk7Z2dnq2bOn8vPztXDhQt17773uVgO+4Em+VHo3+R+vAcxGDuXWi7yqaAbtQ8CW10Zd8F0MAEEnLTFGubcPbzJqYUr2eh0oqyagGqTcDqiuXLlSFotFEydOdLuxXC82NlYTJ07UY489ps8++4wGcyByN18qgNDGNaF1C8C8qvaGzjJsyn9oHwL2mTrqgu9iAAhaaYkxtFNDjNsB1a1bt0qSTj31VI8KHjp0qM3+EGBczZcKIDTZ6wHDNaF1C5Be746GTEkMm/KnQGsf/vrrr5oxY4ZWrFih/Px8JScna/jw4Zo6daoGDhzo0b69UWZLtt2zZ4+ys7O1YsUKff/999q3b58iIiJ09NFHa/To0ZoyZYo6derkjUOFv9A+BwAgYLgdUN2/v+4HdocOHTwquGPHjjb7Q4BqLl8qQge5EVHPWQ+YrqfwvoAtH1877A2Zkhg25W+B1D784osvNHr0aJWW1vVibteunXbv3q3FixcrJydHixYt0rhx4zyqp5lltnTb7t27q6qqyvr/du3aqaKiQhs2bNCGDRs0d+5cLV26VMOHDzf1WBEAaJ8DQMhweaIqeyle+M3uV24HVMvLy2WxWBQXF+dRwTExdW+QyspKj/YDwEPkRkRj9ICBK/x47WDIVOAJlPZhcXGxxo4dq9LSUg0cOFDZ2dnq1auX8vLyNHHiRH3yySfKysrSkCFD1KNHD4/qakaZnmxbW1ur4cOH69prr9WoUaPUvn17HTp0SKtWrdL111+vrVu36sILL9Qvv/xCT1UAAAKMyxNVOWpzS/xm9zO3A6r17r33XiUmJra44KKiohZvC8BEznIj7vjKdjkBtdaFHjBwJgDzqsL//N0+fO6557Rv3z5FR0dr2bJl6tatmyQpLS1Nb731lnr16qWCggLNmDFDL730kkdlmVGmJ9uuXLlSp512ms2yNm3a6KyzzlJOTo4GDhyo4uJivfjii5o+fbopxwoAAMzh8kRV9trcEu3uANDigOq7775rZj0A+FPj3Ij0Wg1NjfOi1iNQjpYKkLyqCBz+bh9mZ2dLks4//3xrcLJeYmKiMjMz9fTTTysnJ0dz5sxReHi4X8v0ZNvGwdSGjj/+eB199NHaunWr1q1b5/ExAgAA87k86spZm5vUfX7TooCqYRhm1wNAIKHnWehxlBdVqguUj39Nik2t+7+9/DwA0Ax/tw+Lioq0YcMGSdIZZ5xhd50RI0bo6aefVmFhoTZu3Kj+/fv7rUxv17e+p7DFYnF5GwAAECToBOV3bgdUt23b5o16oJXKK6poMrGIwyTM8C16noUWR3lRywuk7Exp0Vjb9SNi676kgZbgTnmrEwjtw02bNlkf9+7d2+46DZf/8ssvHgdUPSnTm/UtKyvTTz/9JEkaNGiQS9sAAIAgQicov3M7oNp4OBLQUnlFFRr55CpV1NTaLG+ShLkF+yVICzhgLy+qvZw8BMDQEtwpb7UCoX24Z88e6+P6SZgmTZqkN998U5mZmXr++efVuXNn6zp79+71a5nerO/MmTNVXl6uqKgoTZgwwem6VVVVqqqqsv6/pKTE5XIAAIAf0QnKr1qcQxWo52oAs/F6W/NLVVFTq5njByijQ7x12ZTs9VqzrVAH/rfM2T7t1cUbQVo0QM+z0MMXMczCnXL4UVlZmfVxTEyM9u/fr7lz50qS5syZo4cffljt2rWzrlNaWurXMr1V3/Xr1+vhhx+WJE2bNk1du3Z1uv6MGTP0wAMPuLRvAADgfVvzbb/z6SAWmAiook7jyWpczKHoagDT2XpDeiRb10uKi1RMRLimZK9vUlZMRLheyByklLhIh/VxFqS1mSkP7nPW86xh/s36dQmc+FcLP9OAxwjQI0CkpKQoMzNTOTk5uvLKK5WcnKxDhw4FbJlm1LegoEBjx45VZWWlzjrrLN17773NbjNt2jTddttt1v+XlJQoPZ3PMAAAvuYoHkIHscBEQBWOJ6txIYfigbJql3qZ2gt0Sk3vtKQlxij39uFNerzuL6vW9a+tU9a8/zZ7OI2DtPW4y+Mhez3PnOXfZHiv7zQOnta/Li34TPuSvV7rANBScXFx1scVFRWSpIULF2rhwoVNlktSfLztSBhfl2l2fQ8ePKhzzz1Xv/32m44//ngtWbJE4eHhzR5DVFSUoqKiml0PAAB4l714CB3EAhcBVTierMZOL0NHAZCMDvHqm5YgyfldFXuBzsbSEmPsrmMv0GpP40Apd3lMZK/nGcN7/cvZDZErcwK257CzXutJTnqhA4Aj9XlIpbr8pH379m2yzu7du62PO3bs6NcyzaxvZWWlLrzwQq1du1YZGRlavny5EhMTXT4OeM6jm4SNb4w6wmgTAAh5juIhCDwEVHFEo8lq8ooqdCCv2Pr/+l6izQVAHPUy9bRHaEsvLNzl8TJXh/fa+7EQQAG+oOXGDZFAYq93u0TP8ZBG/mV4WZ8+fayPN2/erJEjRzZZZ/PmI+/DY445xq9lmlXfQ4cOady4cVq5cqXS09OVm5trE6yF93l0k9DRjVFHAmy0CQAArRUBVdjlrGH46tUn2uQxtRcACbS7Ko7qQxoAH3HWi5LUAOZodEMkWDTs3Y4Q5Sz/shc+/1zXW6/ExET169dPGzZs0KpVq3TDDTc0WWflypWSpOTkZLs9Qn1Zphn1PXz4sDIzM/X++++rY8eOys3NVbdu3Tw+LrjHo5uEjm6MOsLNKAAAAgIBVdgV6r3HSAPgAw17oxVsbvpjgdQALcNkUwg29vIve+Hzz3UdkjR+/Hht2LBB7733nnbu3GkzuVJxcbEWLVokSRozZozT/KIWi8X6eNu2berevbtXyvS0vn/729+0ePFipaSkKDc3V717uxCQg9e4dJPQ0fd4kN4YBQD4hr1UMqESnwlWBFThVKj2HiMNgBc5643W9RSCp57wYAI5wK9cTQ3iAa7rkKTJkydr1qxZ2rdvny6++GItXrxYGRkZ2rVrl66++mrl5+crOjpa99xzT0CU6cm2t956q15++WUlJCRoxYoVpvS4hZfxPQ4AcJOjTgOSk44DpNryCQKqaLVIA+Al9nqjSVzEzRCk+VIBXwm0dDPwvYSEBC1ZskSjR4/WunXr1KtXLyUkJKikpESGYSgiIkILFixQjx49AqLMlm67Y8cOzZw5U5JUXV2t0aNHO63jnj17TDteeIDvcQCAmxzNUWO344CPU221dgRUWyOGDNvlbLjoC5mDms0biwZ80ButVWNYIAA4NGzYMH3//fd65JFH9Mknnyg/P18dO3bUsGHDdNddd+mEE04IqDJbsu3hw4etjysqKlRRUWH6McGxvKKKJr3h3cL3OADADS53GvBRqi3UIaDa2jDUyCF7d372l1Xr+tfWKWvef23WJScffIKbHwDQIj179tS8efNavL1hGD4t091tu3fv3qI6wnPOJm5NanDzHQAAX2g6wjZVaV0InPoCAdXWxsFQoz2H4lRQ1k4qK5bUgjvtIcLenR9y8nmZvSBhqA99axwolZoeMzc/AAAIOKE+cSsAIDgwIav/EVBtrRoMNTpyp902sMWd9jrk5PMSR/ldpNDO8eIsUNrwmMmzhtaAhPkAglSoTtwKAAgOTMjqfwRUwZ12+IejyatCPceLvUBp/THv+OrI+agPNJFnDaGIhPkAAACAR+j85V8EVGHFnXb4XGuevKphoNRZcInh/QhFJMwHAAAAfIeRYaYjoAogMIXKBd+ViaUc9dYN1mO2w+MZkRF6WvMNFQAAAMAXGBnmNQRUgRayFxAiTYIJnF3wx78mxabarhvIXwDuTCwVwsElZkQGAAQrbggCAIIaI8O8hoAq4CZHs+lJzKhnCnsX/PICKTtTWjTWdt1AD7IysZQk8jTD/xoHQHjvAXAFNwQBACEhhDvv+BMBVcBN9mbTk5hRz1T2LvjuBFm9PXSh8TD+eo4CpUwsJYk8zfA9RzfAuPkFwBXcEAQAAI4QUAVawNlsevSE8hJXgqy+GLrgaBi/1LTHrL18qQCcMzF/sr0bYNz8AuAubggCAIIJMQnfIKAKmISeUH7gaOiCKwEZe71MXQncOBrG76zHbON8qSGOfHNoES8lzHd2AwwAAAAIFcQkfIuAKmASekIFAFcDMs4mi3I1cGNvGH/jHrP1dWpF+WrIN4cWI2E+gFDT+OYtI1cAAF5ETMK3CKgCJqInlJ+5GpCx18u0fr0dX9lu705AlGTf5JuDZ/gMAQgVzm7etrKRKwAA33ErJmFiqq3WiIAqgNDiShqA+scNe5k6691KXlS3kW8OANCqOUoRxI9VAIC/eSnVVmtDQLWV2rqvVJVGcd1j8hsilDn7smjYQ8Re71byogIAAE/YSxEEAIA/kWrLFARUW5n80ip1kHTL4vX68X8BVYn8ht7GLHt+ZO/LQrLfQ8Re71byogL+x3AkAAAAoMWaxiRSldaF9rQnCKiGukbJ8Kt2/yxJuuPPfdS+94nW5QT4vINZ9gKEJ3kZyekI+A/DkQAAAIAWIybhPQRUQ5mdZPjpksqNKHXpkqY+5Df0Omez7K3ZVqgDTNqDIJdXVNHk/Q2YhuFIAHyI7zQAQKhxFpM4UFZNDMIDBFRDmZ1k+Fv3leqqN3/VS/Fpfq5c69F4lj3uECFU5BVVaOSTq1RRU2uznBQiMJUrE83VIxUAgBbiOw0AEKoaxyRgDgKqrUGDZPiVRrF2qdj5+vAq7hAhVBwoq1ZFTa1mjh+gDHpbw1ccpQGQSAUAoMU8/k5rlGbL7k0fAAAQMgioAn7g6A4Rk1chGGV0iFdfUojAVxxNNEcqAAAmaNF3mp00W5LqbvLEpphXOQAAEDAIqIaw/NIqdVDdMP9Ko65XKrmgAhNpAADADUwWByCQ2EmzJYk0JAAAhDACqiEqr6hCN7+2Tjnh0i2L1+tH48gwf3JBBR4mrwIAAAhyDdJsAQAQlBqnrOHmoEMEVEPUgbJqVR46LIVLsy4boMrUftbnCMgFJiavAgDfIcUKAAAA8D+O5ilgjgKHCKiGkgbJ8KMLSpVhyZMkZbSPl7qQ3zDYMHkVAJiPm1UAPMYEVACAUGNvngLmKHCKgGqoaJQMP0PSrEjpcJsYhZEMP2g5mrwKANAy3KwC4BEmoAIAhIimI7ZSldaFwKmrCKiGikbJ8LfuK9Uti9frqctHqA93EkIOQ1XhD3lFFU2CUEDAcSHvEzerALQYE1ABAIIcI7bMQUA11PwvGX6lUawfjWLVxKf5u0YwERc++EteUYVGPrlKFTW1NsuZ5A4Bg7xPANzg8U1CJqACAAQpRmyZg4BqiMgvrVIHSVv3larSKKbnWIjiwgd/OVBWrYqaWs0cP0AZHeKty+kdjYBB3icALuImIQCgtWPElucIqIaAvKIK3fzaOuWES7csXq8fjWJJNApDlaMLH2kA4AsZHeLVN41J7hCgEtPtB05dSAMAoPXgJiEAAG6gLW0XAdUQcKCsWpWHDkvh0qzLBqgytZ8kGoWtBWkAAMAB0gAAcMKlm4RFO5v2fAcAoDWgLe0UAdUQk9E+XupC77HWhDQAAOAAaQAAeKJopzT7xLpJqBqKiK37kQkAQCijLe0UAVUgBJD/BGbzeLIOIFA4SgMAAM0p318XTB0zt24SqnoMdQQAhKimqQRTldaF7zx7CKgCIYy8qmgJJutAa8U1E4Bdqb2lLgP8XQsAALyGVILuI6AahPbs2KLSA3ut/99XWKEMS54fa4RAw8UQnmCyDrQ2XDMBSCJfKgCg1SKVoPsIqAaZPTu2qN0rQ9XJUmVdliHpzEjpcJsYhZHPCeJiCHO4NFkHEKwaBErSJK28rqcKwjtYl3HNBEKHS2lsyJcKAGjlSCXoHgKqQab0wF51slRp7QmPK7FbX+vydjER6tChC/mcYOXoYmjvRwQ9D1s38qWiVXEwW2mniFh1YrZSIOS4nMaGfKkAAMANBFSDVGK3vsrof5q/q4Eg4mhIq1T3o+KFzEFKafDDgiBr60C+VLQ6zFYKtCpup7EhXyoAAHABAVWglbCXBkCS9pdV6/rX1ilr3n9tlpM7sHUgXypapcR0AqdAK0MaGwAATNQ4z3grHNFBQBVoRRylASDfKvihCcimYRhdUKouKvBjZQAAAIAA4yB9liJi60aBtaKgKgHVANc4t+G+wgpl+LE+CE0kn24dGl9PJPKlApLsNgwzJOVGRWln6RBJ3GwAAABA62T7m7GdUjNXq1ObsiOLWmn6LAKqAcxebsPjLNt0ZlTdJFQA4CpHuVIl8qUC9vKq7tyyXukrb9GuXXmqiU+zLicdBhAiinY2zaUMAACsHM3DQnrAOgRUA5i93IbRBQnSMqlDfJSfawcgmDjKlSoRIAIkNcmrGlVaJUn614pN+nH5kZ7dNCCBEFC0U5p9olRTbrs8IrauxzoAALA7DwvpAY8goBoEbHIbWuKdrwx4kb0h4wTjAlPj16p+mAa5UgHX1N+4fOGceFUl1n1mdhZW6B/Ld9GABAKYo+8/G+X764KpY+ZKqb2PLG+FE2oAAOCMW+kB7Y32COHvVgKqAa6LChRdsOFIIJXhSPChhj9C9pdV6/rX1jUZMk5vrcDjaHg/Q/sBN/wvr2r6ylusi8irCgQ2t7//UntLXQb4pnIAAIQqRxNVSSE9WRUB1QAWUZqn3Kg7FbusqtETDEeCdznLlfLq1Scq5X8/SujuH5gcDe+nNzHgBvKqAkHH0fdfam2+OpVvkupH+NNBAQAA89hpN0sK+cmqCKgGsPDKQsVaqrTzzFlK7zXgyBMh3GUagcFerhSJoEGgYng/4CXkVQWCks33X9FOafYw8qUCAGCixil1kuJSldbFQZyq8Y3MEIlpEVANAlWJGQxHgs+5kyul6cWUwKuvMLwf8J36vKqzLhugytR+kuipD/iLvbzu5EsFAMC7nI1mbdLBwFEqgBBJA0BAFUCLObuYvpA5yJoaoH5dgg3mY3g/4HsZll3W3ObRYaXqogI/1whoXRzdTOyiAg2KKFOHslRpV90NEGuvGPKlAgDgMXujWR12MLCXCiCE0gAQUA0gje+07yusUIYf6wM0x97FtH7yqqx5/7VZlyGx3sXwfsAH7NxlZ6IqwPfs3UyMKM1Tr7evUdihCumNRhswvB8AANM4Gs1qf+RqetAHTh0hoBog7N1pP86yTWdGSe1iIvxYM8A5exdTR3es1mwr1AF6UXrEUb5UAD7gZKKqg5tWa2tloXV5fFJHderayx+1BFoNm5uJu7ZJhyqaDu2XGN4PAIAXuZUGIIQQUA0QB8qqlVSzV8+P6qL05Lo3W1RRvLTySM42IFg0DrKSGqBlGgdP63v/ki8V8KNGd9kjDsWp/LMoDf72LunbI6uVG1Hac82XBFUBX2NoPwAAPuVWGoAQEvQB1V9//VUzZszQihUrlJ+fr+TkZA0fPlxTp07VwIED/V09l0WU5ik36k7Frqpq9ARDlBD8zEgNYG/yiVAKvroTPH316hMJQgMBolPXXtpzzZfadWCvdVnR7xs1+Nu76pYRUPULf7QPPSnTX9sGC0ZnAAAQ2NyZ1DpUBHVA9YsvvtDo0aNVWlrXqGrXrp12796txYsXKycnR4sWLdK4ceP8XEvXhFcWKtZSpZ1nzlJ6rwFHnmCIEkKEJ6kBnAUXQ2EIgaPJNQieAsGhU9deNoHTrZL0rbSzsEKVecU26/IZ9j5/tA89KdNf2wYLR9+RR0ccUIeyX5pOPgUAAAJG45ug0QWlITNXUNAGVIuLizV27FiVlpZq4MCBys7OVq9evZSXl6eJEyfqk08+UVZWloYMGaIePXr4u7ouq0rMYJgSWg1XUwNITYOLwTyEwF5Pm8aTa0gEXoBgVZ/7/J1PPtPWFZusyw8YbXUgomNI3AgKVP5oH3pSpr+2DSb20mK1qShU19w7FPZGhe3KjOwCACAgOPptf5xlmz6MkvJLq9TBP1UzTdAGVJ977jnt27dP0dHRWrZsmbp16yZJSktL01tvvaVevXqpoKBAM2bM0EsvveTn2jbVOKCyr7AiZKL0QEvZSw1Qz1Fw0ZVhf74ITNpLSWCPs962Q3okE2QBQkCHDl10uE2MZul5m+WHwmM0rOzxoLwRFCz80T70pEx/bRvIGn+f5m3f7Dgt1pU5UmzqkWWM7AIAICA4+m2/b3OktEoqqaghoOov2dnZkqTzzz/f2oCsl5iYqMzMTD399NPKycnRnDlzFB4e7o9q2pVXVKHMJ3MUc6jIuizDkqczI4/0agFaK1dzrzjrzdqYvcmvHO3TldytjTkKkjqrD0P5gRCWmK6wyWuk8v1HlhVsVpul1ynJctB/9WoF/NE+9KRMf20bqOwN7z/Osk2joqpUeM5sJXfte2RlgqcAAAQ0e7/ttxaEzm/eoAyoFhUVacOGDZKkM844w+46I0aM0NNPP63CwkJt3LhR/fv392ENnSvdu00fhN2m2CjbO+2H28SoQ4cufqoVEFyc9WZtyNHkV/Y0Dry6Eyi1FyR1hOAp0AokphPs8TF/tA89KdNf2waUop02Nx4q9pXq6ENbdceoPtbh/VFF8dJK1QVTSYsFAAACRFAGVDdtOpKPrHfv3nbXabj8l19+CahGpKMJqMK40w64xdXerJ4EXl0NlBIkBQD/8kf70JMy/bVtwCjaqcPPDVHYoSN5UDMkfRglaVWjdcmNCgAAAkxQBlT37NljfdypUydJ0qRJk/Tmm28qMzNTzz//vDp37mxdZ+/evT6voyuYgArwDU8CrwRKASA4+KN96EmZ/to2UOTn71KHQxW6pfoGbTXSrMuj24RpTuYgdYiPOrIynQ4AAECACcqAallZmfVxTEyM9u/fr7lz50qS5syZo4cffljt2rWzrlNaan/SmqqqKlVVHRl2X1xcLEkqKSnxRrWtDpaWqaTKqPvXy2UBcF3bMKltW0ujpTUqKanxS30AhJCDpVKVoZqqCpUeLFFJSeNrjTnq2xWGYXhl/4HMrPahr8r017aN+as9nLevSNFVhs4eepIuzxhkXZ4YG6noxBg1KZ02MwAAQc8X8TBftYeDMqDaWEpKijIzM5WTk6Mrr7xSycnJOnToULPbzZgxQw888ECT5enpProD/tg5vikHAAAEiKn65OmpXi/l4MGDSkhI8Ho5gayl7UN/lemvbf3eHtbFPioHAAAEuxPJVQAAKKJJREFUDB/Ew7zdHg7KgGpcXJz1cUVFXd6lhQsXauHChU2WS1J8fLzd/UybNk233Xab9f+HDx9WYWGhUlJSZLHU9RwpKSlRenq6du7caXOnH+7hPJqD82gOzqM5OI/m4Dyag/NYxzAMHTx4UF26tL5JLs1qH/qqTH9t25gr7WFv4DMb2Hh9Ah+vUWDj9Ql8vEaBzZPXx1ft4aAMqNbnipLqckj17du3yTq7d++2Pu7YsaPd/URFRSkqKspmWWJiot1127Vrx4fMBJxHc3AezcF5NAfn0RycR3NwHtVqe6aa1T70VZn+2rYxd9rD3sBnNrDx+gQ+XqPAxusT+HiNAltLXx9ftIfDvF6CF/Tp08f6ePPmzXbXabj8mGOO8XqdAAAA4D/+aB96Uqa/tgUAAIDngjKgmpiYqH79+kmSVq1aZXedlStXSpKSk5Pt3rUHAABA6PBH+9CTMv21LQAAADwXlAFVSRo/frwk6b333tPOnTttnisuLtaiRYskSWPGjFF4eHiLy4mKitL06dObDIWCeziP5uA8moPzaA7Oozk4j+bgPEIyr31osVisf9u3b/damf7aNhDwmQ1svD6Bj9cosPH6BD5eo8AWDK+PxTAMw9+VaIni4mL16tVL+/bt06BBg7R48WJlZGRo165duvrqq7V8+XJFR0frp59+Uo8ePfxdXQAAAHiZWe3DhpMxbdu2Td27d/dKmf7aFgAAAJ4J2oCqJK1evVqjR49WWVmZpLqksyUlJTIMQxEREXrttdesd+8BAAAQ+sxoH7oTUPW0TH9tCwAAgJYL2iH/kjRs2DB9//33mjhxoo466ihVVFSoY8eOGjdunL7++msakAAAAK2MP9qHnpTpr20BAADQckHdQxUAAAAAAAAAfCmoe6g259dff9W1116rrl27Kjo6Wl26dNHll1+u7777LqTK9DZfHtOePXs0a9Ys/eUvf9FRRx2lqKgoxcfH6/jjj9fdd9+tPXv2mF6mrwTCe+Occ86xTrKxYMECn5VrJn+cR8Mw9MYbb2j06NHq3LmzoqKilJaWpuHDh+vhhx9WdXW118r2Fn+cx8WLF2vUqFFq3769IiIilJSUpKFDh+qZZ54JunP47bff6vnnn1dWVpaOOeYYhYWFyWKxaMKECV4tNxCuI2by9XkM5e8YIBC50+7w5PoWatdGs7377ru66aabNGzYMHXu3FkRERGKj49X3759dfvtt2vHjh0Ot73//vttJmmz93feeec5LZ/Xp3mevEb1+Ax5jyftBz5DvmFGG4/PkHe1tN0f0J8hI0StXr3aiI+PNyQZkox27dpZH0dERBjZ2dkhUaa3+fqYoqKirPuvLy8iIsL6/+TkZOPzzz83tUxfCIT3xuuvv25zbufPn+/1Ms3mj/N48OBB46yzzrKWY7FYjMTERCMsLMy6bN++faaX602+Po+HDh0yxo0bZ/P+S0hIMCwWi/X/gwYNMg4cOGBqud6UkJBgczz1f1lZWV4rMxCuI2bz9XkM1e8YIBC50+7w5PoWitdGsx133HFNrn2RkZHW/8fHxxsffvih3W2nT59uPZcdO3a0+3fllVc6LJvXxzWevEaGwWfI2zxpP/AZ8g1P23h8hryvpe3+QP4MhWRAtaioyGjfvr0hyRg4cKCxefNmwzAM448//jDOPvtsQ5IRHR1t/Pbbb0Fdprf545jatGljDB8+3HjttdeM/Px8wzAMo6amxsjNzTUyMjKsgZjdu3ebVqa3BcJ7o7Cw0OjQoYPxpz/9KWgDqv46j+edd54hyUhMTDReeOEFo6SkxDAMw6iurjZ++OEH44477jCKiopMLdOb/HEe58yZY33fTZ8+3SguLjYMwzAqKiqMOXPmGOHh4YYk4+9//7tpZXpb+/btjcGDBxuTJ082Fi1aZJxwwgleDQQGwnXEG3x9HkPxOwYIRO60Ozy5voXqtdFst956q/Hss88aGzduNMrKygzDMIzDhw8b3333nXHmmWdaA3Z5eXlNtq3/ITt8+HC3y+X1cZ0nrxGfIe/zpP3AZ8g3PHmN+Az5Rkvb/YH8GQrJgOrDDz9sPTHbt2+3ee7AgQNGamqqIcm47rrrgrpMb/PHMX3xxRcOn/v++++tvQLvv/9+08r0tkB4b1xzzTWGJOOTTz4J2oCqP87je++9Z71ztWbNGtP260/+OI/Dhg0zJBmjRo2y+/ykSZMMSUbHjh1NK9PbqqqqbP4/fPhwrwYCA+E64g2+Po+h+B0DBCJ32h2eXN9C9droSyUlJUbbtm0NScYTTzzR5HlPfsjy+pijudeIz5D3edJ+4DPkG568RnyGfKOl7f5A/gyFZA7V7OxsSdL555+vbt262TyXmJiozMxMSVJOTo5qa2uDtkxv88cxnXbaaQ6fO/7443X00UdLktatW2dKeb7g7/fG6tWrNW/ePI0ZM0YjR440ff++4o/z+MILL0iSrrvuOg0ePNiUffqbP87j3r17JUn9+vWz+/zxxx8vSSorKzOlPF+IjIz0aXn+vo54i6/PYyh+xwCBxt12hyfXt1C9NvpS27ZtlZGRIakux5yZeH3M0dxrxGfI+/zVfuD1cZ0nrxGfId/wdbtf8v7rE3IB1aKiIm3YsEGSdMYZZ9hdZ8SIEZKkwsJCbdy4MSjL9LZAPabExERJksVi8Ul5nvL3eayurtbf/vY3RUdH66mnnjJ1377kj/NYXV2t3NxcSdIVV1zh8f4Cgb/ej/UNmJ9++snu8z/++KMkadCgQaaUF2r8fR1pTYLtOwYINO62Ozy5vnFtNEd+fr42bdokSUpLSzNtv7w+5nH2GvEZCgzeaD/w+pjL0WvEZyh0+eL1CbmAav2XjST17t3b7joNl//yyy9BWaa3BeIxlZWVWQMywRJ48fd5nDFjhn755RdNmzatyR2ZYOKP8/jzzz+rurpaYWFhGjhwoJYtW6ahQ4eqbdu2atu2rYYMGaInn3xSVVVVHpflK/56P/7973+XJH300Ud6+OGHdfDgQUlSZWWl5s6dq7lz5yo6OlozZswwpbxQ4+/rSGsRjN8xQKBxt93hyfWNa2PLGYahvXv36p133tFZZ52l8vJyRUdHO72B/OOPP6pv376KiYlR27Zt1b9/f91zzz3WUSiN8fp4xtXXiM+Q/7nafuAz5D/OXiM+Q8EjED9DIRdQ3bNnj/Vxp06dJEmTJk1S27ZtdcMNN0iSOnfubF3H0ckP9DK9LRCPaebMmSovL1dUVJQmTJjg9fLM4M/zuGnTJs2YMUNHH3207rzzTtP26w/+OI87d+6UJCUlJemFF17QmDFj9J///Edt2rRRVVWV1q5dqzvuuENnnHFG0AxV99f78fzzz9dTTz2lNm3a6J///KfatWunpKQkxcbG6u9//7tGjhypf//73zrllFNMKS/UBOL1OBQF43cMEEha0u7w5PrGtdF9X3/9tSwWi8LCwtSpUyddfPHF2rhxozp06KD33ntPPXr0cLhtQUGBNm3apJiYGJWVlemHH37QjBkz1LdvX3355ZdN1uf1aRl3XyM+Q/7navuBz5D/OHuN+AwFj0D8DIVcQLVhYCMmJkb79+/X3LlzVVpaqjlz5qiwsFAxMTHWdUpLS4OyTG8LtGNav369Hn74YUnStGnT1LVrV6+WZxZ/nse//e1vqqqq0tNPP63o6GjT9usP/jiP9b0oKyoqNG3aNI0aNUq//fabDhw4oNLSUr388suKjIzU119/rWnTpnlcni/48/146623aunSpUpNTZVUNwTDMAxJUlhYWFBcF/0l0K7HoShYv2OAQNKSdocn1zeuje6LjIxUx44d1b59e+uw12OOOUYff/yxzj77bLvb9O7dW7NmzdL27dtVWVmpwsJCFRYWavbs2Wrbtq0KCgp04YUX2vxwlXh9Wsrd14jPkH+50n7gM+Rfzb1GfIYCXyB/hkIuoNpYSkqKMjMzFRsbq0mTJik5OTkky/Q2fx5TQUGBxo4dq8rKSp111lm69957fVa22Xx1HufNm6dVq1bp3HPP1QUXXOCVMvzJF+fx8OHDkqTy8nIlJCQoJyfH2isgMjJS11xzjfXO1ssvv6zy8nLT6+Btvno/lpSU6MILL9QFF1ygCy+8UBs3blRZWZl++eUX3XLLLfr44481cuRIvf76614pP9SE4neMP4XSdwzgiU6dOslisbj1V8+sdocn17dQvzZ68vrUO+GEE7Rnzx7l5+ervLxcn376qeLi4nTCCSdo6tSp1rZPQ3/961918803q1u3bgoPD5dUl4vwhhtu0AcffCCLxaL9+/frySefdFr/UH99JP+9Rg3xGXLMjNenIVfbD3yGXOev16ghPkOOmf36uCqQP0MhF1CNi4uzPq6oqJAkLVy4UGVlZXrxxRdtlktSfHx8UJbpbYFyTAcPHtS5556r3377Tccff7yWLFli/RAFA3+cx3379unOO+9UZGSkZs2a5fH+AoG/P9dXX321zf/r1Q8ZqaioCIpZwf31uZ40aZLee+89XXLJJXr55Zd13HHHKTY2Vn369NGTTz6pm266SYcOHdLNN9+skpISU8oMJYFyPQ5Fwf4dAwQCT9odnlzfuDZ6Jjo6WiNGjNC///1vDRgwQE888YSee+45t/YxbNgw64QeH330kc1zvD6ec+U14jPkH2a1H/gMeY+rrxGfoeDm789QyAVU63MjSGrS5bfe7t27rY87duwYlGV6WyAcU2VlpS688EKtXbtWGRkZWr58uXV2vmDhj/N4zz33qLCwULfddpt69erl8f4CgT/OY/3QdMlxEuvu3btbH+/atcvjMr3NH+dx27Ztys7OliRde+21dte5/vrrJdXNrpibm+txmaEmEK7HoSgUvmMAM/3000/at2+fW3+SZ+0OT65vre3a2NLXpznR0dG66aabJEmPP/642/U64YQTJEnbt2+3Wd7aXh/JP68RnyHXmfX6mN1+4DN0hD9eIz5DrvPWNc5T/vwMhVxAtU+fPtbHmzdvtrtOw+XHHHNMUJbpbf4+pkOHDmncuHFauXKl0tPTlZuba/OBCBb+OI9btmyRJD322GNOu91PnDhRFovFJigYqPxxHhv+KDRruIK/+eM8bty40frYUV7KhjNB//bbbx6XGWr8fT0ORaHyHQOYKTk5WampqW79SZ61Ozy5vrW2a2NLXx9XHHXUUZLqbg4XFRW5VS9HbaTW9vpI/nmN+Ay5zozXxxvtBz5DR/jjNeIz5DpvXuM84c/PUMgFVBMTE9WvXz9J0qpVq+yus3LlSkl1b4i+ffsGZZne5s9jOnz4sDIzM/X++++rY8eOys3NtQm4BJNQfG/4gz/OY8eOHa0/+hxdgBveBUtLS/O4TG/zx3msrKy0Ps7Ly7O7zh9//GF9HBER4XGZoYbriLlC6TsGCHaeXN+4Nppnx44d1sf1E0a6av369ZLUZPZ5Xh9zOXqN+Az5jrfaD3yGzNOS14jPUPDz62fICEEPP/ywIcmIjo42duzYYfNcUVGR0aFDB0OSce211zrdjyTr37Zt23xSZiDxx3k0DMO49tprDUlGSkqKsWHDBk8OISD46zw2t5/58+e3eB/+4I/zOGXKFEOS0alTJ6OsrMzh83FxcUZ5ebnbx+QPvj6PP/74o3W9rKwsu+s8+OCD1nW++OILdw8pIAwfPtzpMdrT2r9j7PH2eTSM0PuOAQJdc+0OT65vreXa6ImDBw86fb66utoYPHiwIcno2bOnzXOHDh1yuu1///tfIywszJBk3H333U2e5/VxjSevkWHwGfKVlrQf+Az5VkvbeHyG/MOVdn+gf4ZCMqBaVFRktG/f3pBkDBo0yNiyZYthGIaRl5dnjBo1ynpCf/vtN6f7cedHmlllBhJ/nMf6AFVCQoKxbt06sw7Fr/xxHl3ZT7AFVP1xHnfu3GnExMQYkozRo0db16+qqjJefvllIzIy0pBk3HnnnWYcok/44zwOGzbMkGRYLBbj7rvvNvbt22cYhmGUlJQYTz/9tBEdHW2tz+HDh005Tm87ePCgsW/fPuvfqaeeakgyLrvsMpvllZWVDvfR2r9jDMP35zEUv2OAQNdcu8OT61uoXhvNNH/+fKN///7GrFmzjE2bNlm/Z8vLy42VK1dar7uSjDlz5ths+/nnnxvDhw83Fi5caOTl5VmXHzx40FiwYIGRkpJiSDI6duxo/W5viNfHNZ68RobBZ8gXWtp+4DPkO5608fgM+UZL2v2B/hkKyYCqYRjGqlWrjLi4OOuXT0JCgmGxWAxJRkREhLF48eJm9+FuAMuMMgONL8/j77//bl0vJibG6Nixo9O/YOKP92Nz+wm2gKph+Oc85uTkWAOnkoykpCSb/48YMcKoqKgw4eh8x9fncceOHUbv3r1ttmnXrp3N/48++uigamhkZWXZ1N/Rn7PPGd8xvj2PofwdAwQyVz7HnlzfQvHaaKb58+fbXCcjIyON5ORkm2UWi8XuzeGVK1farBcXF2ekpKRYewNJMtLT050GL3h9mufJa1SPz5D3eNJ+4DPkG2a08fgMeV9L2v2B/hkK2YCqYRjG1q1bjYkTJxpHHXWUERkZaXTq1MkYN26cy3csWhLA8rTMQOSr87ht2zaXPmD1f8HGH+9HZ/sJxoCqYfjnPG7cuNGYMGGCkZ6ebkRGRhrt2rUzTj31VGP27NlGdXW1B0fjP74+j2VlZcZTTz1lnHbaaUZSUpIRHh5uJCQkGCeffLLx+OOPNzvcLdD4I6BqGKH3HePL8xjq3zFAoHK13eHJ9S3Uro1mys/PN15++WXjqquuMo4//nijU6dORkREhBEbG2v07t3buPrqq42vv/7a7rb79u0zHn30UePss882evToYSQmJhrh4eFGUlKSceqppxqPP/64UVRU1GwdeH2c8+Q1aojPkHd40n7gM+QbZrXx+Ax5V0va/YH+GbIYhpuZxwEAAAAAAACglQrzdwUAAAAAAAAAIFgQUAUAAAAAAAAAFxFQBQAAAAAAAAAXEVAFAAAAAAAAABcRUAUAAAAAAAAAFxFQBQAAAAAAAAAXEVAFAAAAAAAAABcRUAUAAAAAAAAAFxFQBQAAAAAAAAAXEVAFAAAAAAAAABcRUAUQ8hYsWCCLxSKLxaLt27f7pMwJEybIYrGoe/fuPikPUvfu3WWxWDRhwgR/VwUAAMDKH21Re2grwVd4r6E1IKAKAAAAAAAAAC4ioAoATnz++efWHgWff/65v6sDAACAVoS2KAAEJgKqAELehAkTZBiGDMNgCD4AAAB8KlDaotu3b5dhGFqwYIHf6gAAoYKAKgAAAAAAAAC4iIAqAAAAAAAAALiIgCoAG/UzMrry52iW0traWs2fP1+jRo1Sp06dFBkZqY4dO+q8887Te++951L59TNCvv/++xo5cqRSU1MVGxurE044Qa+88orTfbzzzjtu17lewzxVFotFZ555pvW5M8880+4+XbFhwwZdccUVSktLU1RUlHr27Kl//OMfKi8vd2n7lti+fbu1jgsWLFBBQYFuvvlmdevWTdHR0eratauuu+46l2abbbwvSfryyy81duxYpaenKzo6Wunp6brgggu0YsUKu/vw5H0hyTpEbejQoUpISFC7du00dOhQvf322+6cFgAAEKAWLFhg02b7/vvvdckll6hDhw6KjY3Vcccdp+nTp6usrMzpfgoLC/XPf/5TAwYMULt27RQTE6OePXtq0qRJ+vnnn12qy08//aTrr79exxxzjOLi4hQREaFOnTpp5MiReuqpp7Rt2zaH2wZKW3TAgAF213d35vWff/5ZkyZNUs+ePRUTE6OEhAQNGDBA//znP1VYWOhwu8btx0OHDmnWrFk64YQT1LZtWyUkJOjss8/Wv//9b7fq466G9Wjuz1spGWiXAyHIAIAGunXrZkhy6W/btm1Ntv/jjz+MgQMHOt0uMzPTqKmpcVp+VlaWMX36dIf7eOihhxwew7Jly9yqc0MrV650+fjr/+zJysoyJBndunUzPvzwQyMmJsbutiNHjjQOHz7stE4ttW3bNms5jz32mNG1a1e7dYiPjzdWr17t8r7mz59vPPPMM4bFYrG7v6ysrCbbe/q+OHTokDF27FiH2z744IM27x0AABB85s+fb/1uf+WVV4zo6Gi73/u9e/c29uzZY3cf69atM9q3b++wzdCmTRtj3rx5Tuvx5ptvGhEREU7bLWeddZbD7QOhLWoYhtG/f3+X22qOvPLKK0abNm0clt2+fXtj3bp1drdt2H586aWXjJEjR9rdR0REhPHZZ5+5XCd3NaxHc3/dunXzeh1olwOhoY0AoIEVK1aourra7nO1tbW6/PLL9fPPP1vvKjd08OBBnXnmmdqyZYsiIiJ0/fXX67zzzlNycrK2bdumN954Q++8845ee+01paen65FHHnFYjy+//FILFy7UFVdcoaysLMXFxemrr77Sfffdp/Lycj300EOaOHGi0tLSmmx71llnacOGDdb/v/vuu7r33ntdOv4hQ4bYbLtmzRpdffXVkqR58+ZpyJAhLu2n3sGDB5WVlaXjjz9ed9xxh7p166ZffvlF06dP17Zt25Sbm6slS5bo0ksvdWu/7nrooYdUUVGhm266SZdccokiIyO1fPlyPfbYYyotLdVFF12kzZs3KyUlpdl9rV27Vs8//7y6du2qW265RSeeeKKio6O1detWLVy4sElPCTPeFw8++KBycnIkSaeccoruvPNOde3aVT///LMeeughPfDAA4qIiDDnZAEAAL+7+eabFRUVpUceeUSnnXaaSktL9eqrr2rhwoXavHmzLrvsMq1cudJmm8LCQp177rnat2+f2rRpo5tuukkXXXSRoqOj9eWXX+rhhx9WYWGhrrnmGvXq1UunnXZak3Lz8/N17bXXqqamRh06dNAdd9yhwYMHKzExUfv27dN///tfvfXWW07rHiht0ZycHFVUVFj/P2rUKO3atcvl7b/44gtde+21MgxDKSkpuvfee3XqqaeqsrJS77zzjp555hnt27dPo0eP1k8//aTk5GSH+/rXv/6l33//Xffee6/OPfdcVVRUaNmyZZo9e7Zqamo0efJk/fjjjy7XzR1paWk257Sx3bt366KLLlJ5ebmOOuoor9ShIdrlQIjwd0QXQPCYNm2a9c7jW2+91eT5yZMnG5KM8PBwY8WKFXb3cddddxmSjMjISGP37t1Nnm/YQ/amm25q8vy7775rff6ZZ55xqd4Nezs01yugsYa9BFauXOnydvU9VCUZQ4YMMSorK22e37VrlxEbG2tIMsaMGeNWnVzV+G78E0880WSdnJwc6/NTp051aV9t2rQxTjrpJKOkpMThug15+r7Yt2+fERUVZUgyBg8ebFRVVTV5Pi0trUW9LgAAQOBo2GYLDw83vvrqqybr3HTTTdZ1PvroI5vn7rjjDpuee41t2LDB2ut1yJAhzdZh1apVDuv6448/tui4fNUWtcfdXoODBw82JBmxsbF2j3fu3LnWut15551Nnm/cFs3JyWmyzq233mp9/ocffnD7mDxVU1NjDBs2zJBkJCQkGFu2bPFKObTLgdBDDlUALvnwww/12GOPSarrMdC4R+WBAwesuU1vuOEGnX322Xb3M336dEVHR6u6ulpLlixxWF5kZKQefPDBJsvPO+88JSUlSZK+++67Fh2Lr91///2KioqyWda5c2frOfLFcXTu3Fm33HJLk+VjxozRoEGDJEmvvfaaS/syDEOvv/662rZta/f5hrmnzHhfvPXWW6qqqpIkPfDAA4qMjLR5PjU1VVOnTnWp7gAAIDhcfPHFOvnkk5ssv//++61tgYULF1qXG4Zhbcscf/zxdvOE9u3b19rbc82aNXbzqe7Zs8f6+IQTTnBYv2OPPda1AwlSP//8s9auXStJuvbaa+0e7zXXXKPjjjtOUt1rYRiGw/0NGTJEY8aMabL8qquusj72R9v+nnvu0erVqyVJ8+fPV0ZGhtfLpF0OhAYCqgCatX37dmVmZsowDJ188sn617/+1WSdzz77zDqkyF5jqV5MTIy1obJmzRqH69UPrWosLCzMuv3evXvdOQy/CA8P14gRI+w+17t3b0m+OY5zzjnH4dCb0aNHS6ob7uRKIvwRI0aoZ8+eLpVrxvviyy+/lFQXZD/rrLPsbn/BBRe4VB8AABAczj//fLvLk5OTddJJJ0mSvvrqK+vyX3/91dqmcrStJF100UXWx//5z3+aPN+tWzfr4/fff9+tOoeS+vaX5Ph8WiwWXXjhhZLq2rO//fabw/05Ct7Vt4fr9+FL77zzjp544glJ0m233aaLL77YJ+XSLgdCAwFVAE5VVVXpkksu0YEDB5Samqq33nrLbgNg/fr11seOZiCt/9u4caOkuhxVjqSnpzt8LjY2VpJUXl7ewqPyndTUVEVHR9t9zpfHccwxx7j03KZNm5rd1ymnnOJyuWa8L7Zs2SKp7g57456+9bp166aYmBiX6wUAAAKbK22X33//XZWVlZKkzZs3W5931nu04XMNt6n35z//2Zq7MjMzUxdffLFefvllbdy4UbW1te4dRBAz63zWc9S2r28PS75t2//666/WXsxDhw7V448/7rOyaZcDoYGAKgCnbr75Zq1bt05hYWFatGiRw8ZQQUGB2/tumCS/MUdByIacDSsKFK4chy/Up0mwp2FP4KKiomb31blzZ5fLNeN9UVxcLEl2eyzXs1gsTp8HAADBxdW2S307of7f5rZt+FzDbeqlpKTojTfeUGpqqmpra/XOO+/ouuuuU79+/dS2bVtdfPHFWrFihTuHEpTMOp/1AqltX1FRobFjx6q4uFjt27dXdna22rTx3XzdtMuB0OC7qwaAoLNw4UK99NJLkqR//vOfGjVqlEvbrV271uEdy4bi4uI8qh/Md/jw4WbXaWmQmPcFAAAwmyttF3f9+c9/1m+//aacnBx9+umn+s9//qPffvtNFRUVeuedd/TOO+/o0Ucf1bRp00wvG95344036vvvv1dYWJjefPNNpaWl+btKdtEuBwIbAVUAdm3YsEF///vfJdU1Ku+77z6n69cPjZKkjh076qijjvJq/eCeAwcOOHyu4d3vhIQEU8s1431Rf4fb2V16wzBcuosPAACCg7ttl4ZtGGfbFhYWNtnWnrZt22rChAnWYeHbt2/XokWL9P/+3//TwYMHdd999+mSSy5Rr169mjuUoNT4fDoawu3q+QwUr7zyiubPny+pblIlR3lAvYl2ORAaGPIPoImSkhKNHTtW5eXlOuqoo/T6668rLMz55aJ///7Wx9988423q+gzFovF31Uwhb1ZbOv98ssv1scNJwYwgxnvi/o6bd++3TqraGPbt293mkICAAAEF1faLmlpadYcnA0Dmz/++KPDbRs+504wtHv37rr33nuVnZ0tSTp06JB1dnhv8ldb1Nvn0x/Wr1+vyZMnS5LOPfdc/eMf//BLPWiXA6GBgCqAJq6++mpt2bJFEREReuutt5SamtrsNiNGjLAOG3nhhRe8XUWfaTiMJhgmwXJk+fLlqqmpsfvcRx99JKnuTrWrs4S6yoz3xWmnnSZJqq6uVm5urt113nvvvZZVEAAABKQPPvjA7vLCwkJrMOjUU0+1Ls/IyFCHDh0kOW8XvPPOO9bHDbd3VcNJgFqSk9Jd/mqLNjw3js6nYRh69913JUkdOnQwvR1ppqKiIo0dO1aVlZXq2rWrFi1a5LdgNe1yIDQQUAVg46mnnlJOTo4k6f/9v//n8syRKSkp1iFRubm5TmfKLC0t1WOPPaZt27Z5XF9vazgJ15o1a/xYE8/s3r1bs2bNarJ86dKlWrdunSTpiiuuML1hacb74pJLLrH+mLj//vtVXV1t83xBQYGeeOIJU+sNAAD8a9myZXZ70TVsC2RmZlqXWywWXXnllZKkjRs3at68eU223bBhg3W496BBg+zOXv/ZZ59px44dTutVz+wehPb4qy163HHH6YQTTpBUN0zeXi/VuXPnWntbZmZmBuzILsMwlJWVpd9++02RkZF6++23lZyc7Lf60C4HQgM5VAFYbdq0SXfddZck6aSTTtLIkSO1ceNGh+v36dNHERER1v8//vjjys3N1a+//qq7775bn376qbKystSnTx/V1tZq69atys3N1ZIlS1RaWqrzzjvP9GMoKirSH3/8YbMsLy/P+njz5s0qLS21eb5v374O99elSxf17t1bmzdv1pNPPqnOnTvr7LPPVvv27a3rxMfHm1R774mLi9Ndd92lHTt26NJLL1VkZKSWL1+uGTNmSKqbbfTuu+/2Stmevi9SUlI0depUPfjgg1q7dq3OOOMMTZ06VV27dtXPP/+sBx98UHv27FF0dLQqKyu9cgwAAMC3oqOjNWrUKN133306/fTTVVpaqgULFmjhwoWSpNNPP13nn3++zTbTpk3Ta6+9pv/f3h2EJvnHcRz/iMM9lmOBlKQ2kwq6uENhowKFBhEdBmZ3MdGOnRsL2dCjp4Jwh9wpCKNDp/BQHTwMkUAKYhW4Sx4KpNsKgt//0H/RH7U95Tb3H+8XPKfx/T7fBx70sy+P+vnzZ928eVNv3rxRIpGQZVmq1+sqFAr69u2bHA6HSqVS3/M+ffpU9+7d0+zsrK5evarp6WkdOnRInz590rNnz3T//n1J0tTUlK5cudJTv1ey6Lt373qWXZtPRX758qUn4x85cuTnE76bSqWSLl26pI2NDcXjcS0sLOjixYv6+vWrnjx5ort370qSDh8+vKd/oKtSqfx8ajKXy+nAgQMD/8dxuVw7vignlwP7hAGAf7148cJIsn202+2eHh8/fjTnzp3bstblcpn379/31IdCISPJpFKpgXPG43EjycTj8Z6/VSqVP7oGOy+D1WrVOByOP6pPpVJGkgmFQgP75vN52zP8jXa7/bN/sVg0fr+/7/wHDx40L1++tN2rUqn88SzD3hffv383165dG1hXLBZt3TsAAGDv+jXHlctl43K5+r7vnzp1ynQ6nb49Go2G8Xq9AzOD0+k0y8vLA2e4devWlnnF5/OZZrO55TWMMotu5iK7Rz6f79tneXnZOJ3OgXVer9c0Go2+tXbz41YzDOvXzL3V8bvsPgxyObD/8JF/ANvK7/drdXVVjx49UjKZ1LFjx2RZlizL0okTJ5RMJlUul9XpdHTy5MlRj2vL9evX9fz5cyUSCfn9/v88lft/4ff71Ww2lcvlFAwG5XK5FAwGdePGDb1+/VrxeHzHzz/MfeF0OvX48WM9ePBA58+f18TEhDwejy5cuKBqtar5+fkdnR8AAOyuy5cvq16va25uTl6vV5Zl6fTp07pz545evXqlo0eP9q2LRqNaW1vT/Py8IpGIPB6PxsfHFQ6Hlclk1Gq1lM1mB553cXFRDx8+VDqd1pkzZ+Tz+TQ2NqbJyUnNzMxoaWlJb9++1dmzZ3fq0nuMMotms1m1Wi1lMhmFw2GNj4/L4/EoEono9u3bWltbUzQa3bV59gNyObA/OIwxZtRDAAC23/r6usLhsKQfH3Xa/M4kAACAvWhlZUXpdFqS1G63dfz48dEOBGwTcjmw//CEKgAAAAAAAADYxEIVAAAAAAAAAGxioQoAAAAAAAAANrFQBQAAAAAAAACbWKgCAAAAAAAAgE0OY4wZ9RAAgB8KhYIKhcJQPWq1mmKx2DZNBAAAAOwuy7KGqo/FYqrVakP1IJcD+B0WqgCwh3S7XXW73aF6BAIBud3ubZoIAAAA2F0fPnwYqt7tdisQCAzVg1wO4HdYqAIAAAAAAACATXyHKgAAAAAAAADYxEIVAAAAAAAAAGxioQoAAAAAAAAANrFQBQAAAAAAAACbWKgCAAAAAAAAgE0sVAEAAAAAAADAJhaqAAAAAAAAAGATC1UAAAAAAAAAsOkfTTmYCmnNfvgAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(Text(0.5, 0.98, 'Cut data'), None, None)" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fig, ax = plt.subplots(2,2, figsize=(14,8))\n", + "k = 0\n", + "ax[0,0].hist(MC_df[keys[k]], density=1, histtype='step', bins=n_bins, label='MC')\n", + "ax[0,0].hist(RD_df[keys[k]], density=1, histtype='step', bins=n_bins, label='RD')\n", + "ax[0,0].set_xlabel(keys[k]), ax[0,0].set_ylabel('Density'), ax[0,0].legend()\n", + "\n", + "k = 1\n", + "ax[0,1].hist(MC_df[keys[k]], density=1, histtype='step', bins=n_bins, label='MC')\n", + "ax[0,1].hist(RD_df[keys[k]], density=1, histtype='step', bins=n_bins, label='RD')\n", + "ax[0,1].set_xlabel(keys[k]), ax[0,1].set_ylabel('Density'), ax[0,1].legend(loc='lower right'), ax[0,1].set_ylim(0,0.28)\n", + "\n", + "k = 2\n", + "ax[1,0].hist(MC_df[keys[k]], density=1, histtype='step', bins=n_bins, label='MC')\n", + "ax[1,0].hist(RD_df[keys[k]], density=1, histtype='step', bins=n_bins, label='RD')\n", + "ax[1,0].set_xlabel(keys[k]), ax[1,0].set_ylabel('Density'), ax[1,0].legend(loc='upper left')\n", + "\n", + "k = 3\n", + "\n", + "ax[1,1].hist(MC_df[keys[k]], density=1, histtype='step', bins=n_bins, label='MC')\n", + "ax[1,1].hist(RD_df[keys[k]], density=1, histtype='step', bins=n_bins, label='RD')\n", + "ax[1,1].set_xlabel(keys[k]), ax[1,1].set_ylabel('Density'), ax[1,1].legend(), ax[1,1].set_ylim(0,0.0075)\n", + "\n", + "plt.suptitle('Cut data'), plt.tight_layout(),plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Calculate weights" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we calculate individual weights for each variable, by dividing the height of each bin in the histogram of the real data, with the corresponding bin in MC data. The weighted MC histogram the becomes identical to the RD histogram." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def make_weights(Real_data_df, MC_data_df, columns, ranges, n_bins = 100, normalize = True):\n", + " weights = np.zeros((len(columns), n_bins))\n", + " for i, col in enumerate(columns):\n", + " RD_counts, RD_bin_edges = np.histogram(Real_data_df[col], bins=n_bins, range = ranges[i])\n", + " MC_counts, MC_bin_edges = np.histogram(MC_data_df[col], bins=n_bins, range = ranges[i])\n", + " ratio = RD_counts/MC_counts\n", + " ratio = [x if x != np.inf else 0 for x in ratio] # Handles inf when MC_counts == 0\n", + " if normalize:\n", + " weights[i] = ratio/max(ratio)\n", + " else:\n", + " weights[i] = ratio\n", + " # not sure about the normalization. Have a look yourself\n", + "\n", + " return weights\n", + "\n", + "#####################################################################################################\n", + "\n", + "def make_and_plot(k, hist_ax, ranges, residual_ax, weights = 'individual', normalize_weights = False):\n", + " # Select data within ranges\n", + " RDc = RD_df.copy()\n", + " MCc = MC_df.copy()\n", + " \n", + " # Make sure the two datasets are of equal length\n", + " if len(RDc)>len(MCc): \n", + " RDc = RDc.sample(len(MCc))\n", + " else:\n", + " MCc = MCc.sample(len(RDc))\n", + "\n", + " Weights = make_weights(RDc, MCc, keys, ranges, normalize=normalize_weights)\n", + "\n", + " if weights == 'individual':\n", + " weights = Weights[k] # if weights are 4 sets\n", + " else:\n", + " weights = weights # if weights is 1 set\n", + "\n", + " \n", + "# xmin = min([min(MCc[keys[k]]), min(RDc[keys[k]])])\n", + "# xmax = max([max(MCc[keys[k]]), max(RDc[keys[k]])])\n", + " xmin, xmax = ranges[k]\n", + "\n", + "\n", + " MC_count, MC_bin_edges = np.histogram(MCc[keys[k]], bins=n_bins, range = (xmin, xmax), density=1)\n", + " MC_xax = (MC_bin_edges[1:] + MC_bin_edges[:-1])/2\n", + " MC_width = abs(MC_xax[1]) - abs(MC_xax[0])\n", + "\n", + " RD_count, RD_bin_edges = np.histogram(RDc[keys[k]], bins=n_bins, range = (xmin, xmax), density=1)\n", + " RD_xax = (RD_bin_edges[1:] + RD_bin_edges[:-1])/2\n", + " RD_width = abs(RD_xax[1]) - abs(RD_xax[0])\n", + " \n", + " hist_ax.bar(MC_xax, MC_count, width=MC_width, alpha=1, edgecolor='k',label = 'Reco')\n", + " hist_ax.bar(RD_xax, RD_count, width=RD_width, alpha=0.4, edgecolor='k',label = 'Real data')\n", + " hist_ax.plot(MC_xax, MC_count*weights, ls='', marker='+', c='k', markersize=8, label = 'Reco (weighted)')\n", + " hist_ax.set_ylabel('Normalized count')\n", + " hist_ax.legend(fontsize=14)\n", + " units = ['[log10(GeV)]', '[rad]', '[rad]', '[m]']\n", + " unit = units[k]\n", + " residual_ax.set_xlabel(keys[k] + f' {unit}'), residual_ax.set_ylabel('Ratio')\n", + " residual_ax.hlines(1, min(ranges[k]), max(ranges[k]), 'k','--')\n", + " residual_ax.scatter(MC_xax, weights, c='r', s=20)\n", + " plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "Weights = make_weights(RD_df, MC_df, keys, ranges=ranges)\n", + "weights = Weights[k]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Single nice plot" + ] + }, + { + "cell_type": "code", + "execution_count": 206, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "matplotlib.rc('xtick', labelsize=22)\n", + "matplotlib.rc('ytick', labelsize=22)\n", + "matplotlib.rc('axes', labelsize=26) # fontsize of the x and y labels\n", + "matplotlib.rc('font', **{'size' : 20, 'family':'monospace'})\n", + "matplotlib.rcParams['figure.figsize'] = (12, 5)\n", + "matplotlib.rcParams['figure.titlesize'] = 22\n", + "fig, ax = plt.subplots(nrows=2, ncols=1, sharex=True, gridspec_kw={'height_ratios': [10,2]})\n", + "fig.subplots_adjust(0,0,1,1,0,0)\n", + "\n", + "k = 3\n", + "hist_ax=ax[0]\n", + "residual_ax=ax[1]\n", + "normalize_weights=0\n", + "\n", + "RDc = RD_df.copy()\n", + "MCc = MC_df.copy()\n", + "\n", + "if len(RDc)>len(MCc):\n", + " RDc = RDc.sample(len(MCc))\n", + "else:\n", + " MCc = MCc.sample(len(RDc))\n", + "Weights = make_weights(RDc, MCc, keys, ranges, normalize=normalize_weights)\n", + "weights = Weights[k]\n", + "\n", + "xmin = min([min(MCc[keys[k]]), min(RDc[keys[k]])])\n", + "xmax = max([max(MCc[keys[k]]), max(RDc[keys[k]])])\n", + "xmin, xmax = ranges[k]\n", + "MC_count, MC_bin_edges = np.histogram(MCc[keys[k]], bins=n_bins, range = (xmin, xmax), density=1)\n", + "MC_xax = (MC_bin_edges[1:] + MC_bin_edges[:-1])/2\n", + "MC_width = abs(MC_xax[1]) - abs(MC_xax[0])\n", + "RD_count, RD_bin_edges = np.histogram(RDc[keys[k]], bins=n_bins, range = (xmin, xmax), density=1)\n", + "RD_xax = (RD_bin_edges[1:] + RD_bin_edges[:-1])/2\n", + "RD_width = abs(RD_xax[1]) - abs(RD_xax[0])\n", + "\n", + "hist_ax.bar(MC_xax, MC_count, width=MC_width, alpha=1, edgecolor='k',label = 'Reco')\n", + "hist_ax.bar(RD_xax, RD_count, width=RD_width, alpha=0.4, edgecolor='k',label = 'Real data')\n", + "hist_ax.plot(MC_xax, MC_count*weights, ls='', marker='+', c='k', markersize=8, label = 'Reco (weighted)')\n", + "hist_ax.set_ylabel('Normalized count')\n", + "hist_ax.legend(framealpha=0)\n", + "hist_ax.ticklabel_format(axis=\"y\", style=\"sci\", scilimits=(0,0))\n", + "\n", + "units = ['[log10(GeV)]', '[radians]', '[radians]', '[m]']\n", + "unit = units[k]\n", + "residual_ax.set_xlabel(keys[k] + f' {unit}'), residual_ax.set_ylabel('Ratio')\n", + "residual_ax.hlines(1, min(ranges[k]), max(ranges[k]), 'k','--')\n", + "residual_ax.scatter(MC_xax, weights, c='r', s=20)\n", + "ylims = [(0,15), (0,2), (0,20), (0,2.5)]\n", + "yticks = [(0,10), (0,1), (0,10), (0,1)]\n", + "residual_ax.set_ylim(ylims[k])\n", + "residual_ax.set_yticks(yticks[k])\n", + "#plt.savefig('../plotting/plots/energy_hist.pdf', format='pdf', bbox_inches='tight')\n", + "#plt.savefig('../plotting/plots/azimuth_hist.pdf', format='pdf', bbox_inches='tight')\n", + "#plt.savefig('../plotting/plots/zenith_hist.pdf', format='pdf', bbox_inches='tight')\n", + "plt.savefig('../plotting/plots/position_z_hist.pdf', format='pdf', bbox_inches='tight')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# EFPJWEOPFJ" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABuYAAASNCAYAAAC/o+hyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeVyU5fo/8M8Aw8AwyCCDMCC4pOKSqaidFHGrTjtpWVlZthyl9ZhaZ6nTATr1tdNilicTKzPTVjWXbNUMt1+5bwlGKoIyIgPDMgwzzPb7Y5pxRoZ94Jnl8369eDk8zzMz1zDI3Pd93fd1i6xWqxVERERERERERERERERE1KmChA6AiIiIiIiIiIiIiIiIKBAwMUdERERERERERERERETUBZiYIyIiIiIiIiIiIiIiIuoCTMwRERERERERERERERERdQEm5oiIiIiIiIiIiIiIiIi6ABNzRERERERERERERERERF2AiTkiIiIiIiIiIiIiIiKiLhAidAD+wmKxoLS0FJGRkRCJREKHQ0RERERE7WS1WlFbW4uEhAQEBXEuI7UP+4hERERERP7B031EJuY8pLS0FElJSUKHQUREREREHlJSUoKePXsKHQb5KPYRiYiIiIj8i6f6iEzMeUhkZCQA2xvTrVs3gaMhIiIiIqL2qqmpQVJSkqONT9Qe7CMSEREREfkHT/cRmZjzEHtpkm7durHTRURERETkB1h+kDqCfUQiIiIiIv/iqT4iN0wgIiIiIiIiIiIiIiIi6gJMzBERERERERERERERERF1ASbmiIiIiIiIiIiIiIiIiLoAE3NEREREREREREREREREXYCJOSIiIqIAoVKpkJ2dDZVKJXQoRERERERERF2O/WLyBkzMEREREQUIlUqFnJwcdkCIiIiIiIgoILFfTN4gROgAiIj8kdFohNlsFjoMImqH4OBgiMViocMgIqIAxDYkkW9jO5KIiIhag4k5IiIPqqmpgVqthsFgEDoUIuoAiUQChUKBbt26CR0KEREFALYhifwH25FERETUEsESc9u3bwcAjB49GuHh4a26j8Viwc6dOwEA48eP77TYiIjao6amBufOnYNMJoNCoYBYLIZIJBI6LCJqA6vVCqPRiOrqapw7dw4AOKhCRAGF/bSuxzYkkX9gO5KIiIhaS7DE3MSJExEUFIQjR45g8ODBrbpPfX29434mk6mTIyQiahu1Wg2ZTIaePXtyMIXIh4WHhyMyMhJnz56FWq322QEVlUoFlUoFnU7nWIFx5MgRAEBeXh40Gg0kEgmkUikAQKlUQqlUChYvEXkH9tO6HtuQRP7DX9qRRET+wt4vBuDoG1/aLwbg6BsHBQVh/fr1yMzMZP+YOpWgpSytVmuX3o+IqLMYjUYYDAYoFAoOqBD5AZFIhKioKJw7dw5Go9En9wrJzc1FTk6O23Pz5s1rdCwrKwvZ2dmdHBUR+QL207oO25BE/scf2pFERP6irf3i2bNnY9myZcjIyGBijjqVT+0xZ7FYhA6BiMgts9kMAOx0EfkR+/9ns9nsk/+3MzMzkZ6ejm0bP8boJClkEWE4UngW8974FAvnTkffBAX2lugwKeMeREdHs9NBRO3Gflr7sQ1J5J98vR1JROQvMjMzkZGRAY1G4+gbnypVO/rFV/TvCW2d3tE3NplMWLZsmdBhUwDwqcScvUZ3WFiYwJEQEbnHmc5E/sPX/z8rlUqIxWKc3L8NacN7QCGPRHRkBABgQmoKkuO7o8xyAcOGDYNCoRA4WiLyZeyndZyvf+YQkSv+nyYi8g72LRvUarWjb5wUHwPA1i9OHdgL6qpaR9+4uLhY4IgpUAQJHUBbLF++HADQs2dPgSMhIiIi8k4qlQrZ2dmOOvre+phE5D/YTyMiIiIiImq9Llsx98ILL7g9vmTJEvTo0aPZ++p0Ouzduxc//fQTRCIRJk2a1BkhEhEREfk8lUqFnJwcZGRkIDk5uU33y83NdbvJtfNjsuQlkX9hP42IiIiIAlF5VS0OFJyBprYOhacvYPv27Thz5gwAIC8vDxqNBgAgkUgglUodq++IPKHLEnPZ2dmNlvJbrVa88847rX4Mq9WK6Oho/P3vf/d0eERERO02ZcoU/Prrr8jPz0dIiHBVoidOnIi8vDxYrVaPPN4DDzyADz/8EKdPn0bv3r098pieVlRUhD59+mDmzJlYsWKFyzmj0YiUlBSMHDkSX3zxhTAB+hAm34gCE/tpRMJiO1I4bEcSEQW2dT/ux7Iv8y4eWLrScXPevHmNrs/KykJ2dnYXREaBoEtLWVqtVseXu2NNfUkkEvTr1w+zZ8/Gvn370KdPn64Mm4iIWvDAAw9AJBI5vkJCQqBUKnHHHXdg7969QofXqfLy8rBhwwb8+9//FnQwxZvYfx+KiooEjUMsFuO5557DmjVrsHv3bkFj8RZKRRSyZmVAqYgSOhQi8iLsp5GQ2I5kO9IZ25FERNTZ7P3iR6dNwv6PsrD2lcdw26Th+Pg/f8HCudMBAAvnTseWJU9j/atP4Lm/PoQtW7YgMzNT4MjJn3RZy89isbh8HxQUBJFIhKNHj2Lw4MFdFQYRkc9rrtyc0B588EEkJydDr9fj8OHDWLNmDdavX48NGzbgxhtvFDq8TvH8888jMTER99xzj9ChYOXKldDpdEKH4VVmzpyJZ599Fv/617/w448/Ch2O4JQKObJnTwEAqKtqhQ2GiLwC+2mBhe1I78J2pHdjO5KIyD8594sBICI8FLFyGcYM7YvKWgMAYEJqClIH9oK6qhZllgsYNmwYFAqFQBGTP+KULCIiH+PN5eYeeughjBs3zvH98uXL8fDDD+Opp57yywGVX3/9FTt27MDTTz+N4OBgocNp035igSIkJATTp0/HW2+9hRMnTiAlJUXokDxKpVJBpVJBp9PBYLB1II4cOQLANgu/V69eOFlUgsORBkRHRkCpiIJSIW/2McvLy3HgwIEmH1Oj0Thq7ANgnX0iIh/CdqT3YDvS+/l7O5KIiIiE06WlLImIKLA8+OCDkEqlKCwsREVFhcs5k8mERYsWYfjw4QgPD4dcLkdGRgaOHTvW5OMVFBTggQceQFJSEiQSCZKTk3Hvvffi0KFDja79+uuvMX78eERGRkIqlWL06NFYuXJl4wftgA8++AAAcMcddzQ69/7770MkEuHzzz9v9jEeffRRiEQixwbDgG2gZvr06YiLi4NEIkFKSgr++9//wmw2N7q/fW8g56/mnD59GlOnTkVkZCTkcjlmzJiBAwcOQCQS4YEHHnB7H4PBgGeeeQYJCQkICwtDWlqaI1HjLo4PP/wQANCnTx+XuNyVJPrqq68wefJkREVFQSqV4qqrrsKGDRvcxvH7779j6tSpiIqKQlRUFO655x6Ul5c3+3oB4M477wSARnuH+IPc3FyMHDkS6enpuOaaa3DNNdc4auHPmzcPt99+O155ZyWueew1jLwvB7nrfgIAqNRVOFxYgsLTJdi+fTu2bt2KvDxbbf2FCxc2+5jXXHMN0tPTMXLkSIwcORJ33303VCqVIK+fiIj8F9uRbEeyHUlERET+iivmiIio04hEIscMYLFY7DhuNpsxZcoUbN68GUOGDEFmZia0Wi3WrFmDsWPHYteuXRg6dKjLY23duhUZGRloaGhARkYGUlJSoNFosHnzZojFYpfO8qpVq3D//fcjOjoa999/PyQSCb744gvMnDkTZ8+exbPPPuuR17d161aEhYVhxIgRjc6NHTsWALBnzx5Hh96dPXv2IDExEb169QIAbNu2DTfffDNMJhNuu+02JCYm4pdffsE//vEPFBQUOAZx7CZOnOi4vWLFCpeBmUuVl5cjPT0dpaWluO2229CvXz98++23uO+++5p9nZmZmaisrMT06dNRWFiIr776CjfddBMKCwsRFhbWKI7169fj8OHDmDNnDuRyueO4820A+O9//4t//OMf6NGjB+68806Eh4fjm2++wZQpU/DBBx+4DPCoVCqMGzcO5eXluOOOO9C7d2989dVXuPvuu5uNHQBGjhwJsViMrVu3tnitr8nMzER6ejq2bfwYo5OkkEWE4UjhWcx741MsnDsdMVER2JC3Hw/enIaEHgrH3nK5635CzrsbbQ+y1HWg8fvvv2/0PNddNQTf/fwrFs6djr4JCuwt0WFSxj04f/48ZsyYAZVK5XUrL4iIyLexHcl2JNuRRERE5Les5BHV1dVWANbq6mqhQyEiAdTX11uPHz9ura+v7/Tn2r9/vxWAdf/+/Z3+XK01c+ZMKwDrjh07XI5/+eWXVgDW1NRUl+OLFi2yArDefffdVqPR6Dh+8uRJq1QqtV599dUu19fV1Vnj4uKsISEh1l27drmca2hosG7bts3xfX19vbV79+5WiURiLSwsdBwvLy+39ujRwyoWi62lpaUdfcnW2tpaa1BQkPXKK690e95isVi7d+9uHT9+fJOPodfrrWKx2Dpt2jRH7Eql0hoWFtbo/X300Ufd/oydTZgwwdrcR/tTTz1lBWBdsGCB41hDQ4N1+PDhVgDWmTNnulxvf1/T09OtBoPBcfz++++3ArBu3rzZ7fPY73f69OkmYzlw4IA1KCjIOnDgQGtFRYXjuE6ns44YMcIaFRVlra2tdRy3v/433njDcay+vt46ZMgQt7FfasSIEdbg4GCrTqdr9jpnXfn/uiPKy8utuf99zlr+w5tW697l1v0fZdn+RnyUZS1Y85I1c+o46+n1/2e17l3u+Cr9ZqF17SuPWW+bNNz68X/+Yt2y5GnrwrnTrQCsC+dOt36Y/bD1tknDrZtef9y6/6Ms67eL5zkes/yHN23PV17ulX+PiDyBbXvyhNb8HnX1Z403/t1mO7IxtiPZjiQiIs+6tN/s/OXcby79ZqE1a1aGtfSbhVbr3uUu/V8KbJ7uI7KUJRGRF1OpVDhw4ECjLwBujwtdTm758uXIzs7Gs88+i9tvvx3Tpk1Dz5498f7777tct3TpUgQHB2Px4sUICbm4eLtv376YOnUqfvzxR2g0GsfxDRs2oKysDDNnznTMILYTi8Uus2zz8vJQWVmJ22+/Hf369XMcVygUePjhh2E0GrFp06YOv9bS0lJYLBbExcW5PS8SiXDVVVfhwIEDsFgsAIB3330Xo0aNcpRZOnjwIIxGo+M1bdiwASqVCpmZmUhNTXV5PHspwTVr1rQ75i+++ALh4eF47LHHHMfEYrHL9+7MnTsXoaGhju9vvvlmAEB+fn67Y1m2bBksFgsWLFiA7t27O47b46uursaWLVscx9etWwepVIpZs2Y5joWFheGJJ55o1fPFxcXBbDbj/Pnz7Y7ZnygVcgzpm+jY4Prq0YMxIdW2b8qE1BT86fK+iJXLcPlliUgd2Aux8kiBIyYiorZiO9KG7Ui2I9mOJCIhqFQqZGdnC/75ShdV19Sg5OxZnCkudvk6V1oKg74BgK2vnD17itu92fmekiexlCURkRfLzc1FTk6O23POHUu7rKwsZGdnd3JUTbu0PM7YsWOxceNGxMTEOI7V1taioKAA0dHRWLx4caPHKCoqgtVqxcmTJzFq1CgAwP79+wG4lrlpir2T764skP1YRwYC7Ox7nURHRzd5zdixY/H111/j+PHjuPzyy/Hpp59i//79+Prrr3H55Zdj7969jusAOL4vLi5u9D6aTCYAtv0x2qOqqgrnzp3DkCFD0K1bN5dzl5Z7utSAAQNcvlcoFAAArVbbrliAi691+/btjfZ2sb9G+78ajQZlZWW4/PLLERER4XLtsGHDWvV89kEbtVqNPn36tDtuIiIiX8F2JNuRdmxHsh1JRF1PpVIhJycHGRkZLPvvBc6ePYulS3NxNNGCsBDXPVWr9BacqBShunoikBjf5GPwPSVPYmKOiMiLZWZmIiMjw+XYgQMHMGvWLLz77ruNZsMK3TDYsWMHxo0bh5qaGnzwwQeYO3cupk6dim3btjn2CKmurgZg6yQ3NVgEAHV1dY7bVVVVAID4+KYbSHb2Tr7z7Fk7+8BObW1t615QM8LDwwEAer2+yWvS0tIA2Pb/6NevH3bv3o2bb74ZP/zwA/72t79hz549CAsLc7yP9tf55Zdf4ssvv3T7mM4/l7Zo7ufi7pizSwcxRCJbI9ZqtbYrFuDia33jjTeavMb+Wu3/NveetqS+vh4AIJVK2xImXSK/SAVNbR0KT1/A9u3bHXvR5OXlOVYnSCQSSKVSKJVKwf8mEREFMrYjbdiOvIjtSFdsRxIRBY6KigqYTEZEDL4ashjXNkFDaTEsu3agrk4nUHQUiARPzKlUKqxbtw4HDx5EWVkZdDpdiw00kUjEjXeJKCA0N7CdmpraaEDFW3Tr1g1z5szB6dOn8eabb+K9995DZmYmACAqKgqAbSP1ffv2terx7Ju9t6ZcgEwmAwBUVlY2OmefnRwZ2fGyfLGxsS6P6c6VV16JkJAQ7N27F0lJSZDJZHj++ecxYcIE1NfXY+/evY4N5YGLr3PTpk2OMj+e0tzPxd2xzmZ/rTU1NS2+H615T1tiv6/9ffNnSkUUsmZlQKmIQk1dvccec0LqAMx4ftnFg0tXOm7aS2Q5E3rlBRF1DPtpvo/tSBu2IzuO7cjAaUcSEfm7IKkcIVGuf8+DNNUCRUOBTNDE3P/93//hP//5DxoaGhzHmuvsiUQiWK1WxwwrIiLybs8//zzef/99vPDCC5g5cybCwsIQGRmJlJQUFBQUoLa2tlWDG/ZSRNu2bcN9993X7LWDBg0CYNt341L2UjcDBw5s4ytpLCEhATExMfjtt9+avEYqlWLYsGHYs2cPIiMjce2112L06NHo1q0bNm3ahN9++81lJrv9de7du9fjAypyuRyJiYk4deoUampqXMoQHT582KPPZZ/Vbi+b5M6oUaOwf/9+7Nu3D5MmTWr28eRyORISEnD69GnU1dW5zLy+tHxRUwoKChAXF4cePXq06npfZq+JD6BNibnmEnpKhRyfvPQIVOpqFKnKsfqb3Zg2eRTOV2ox741PsXDudFzRvye0dXrsLdFhUsY9GDx4sCdfFhF1IfbTyBuwHcl2ZFPYjiQiIiJfFyTUEy9fvhz/+te/YDAYYLVaIZfLMWrUKEyYMKHJr/Hjxzv+JSIi7xcTE4PZs2ejtLQUubm5juOzZ89GXV0dnnrqKRiNRpf7GI1GfP/99y7Hbr31VsTFxWHlypXYuXOnyzmTyeRybMKECejevTvWrVuH48ePO46Xlpbi/fffh1gsblTWqT1EIhHS09NRUlLS7AzssWPH4ujRo9i8eTOuv/56iEQiXHfddViwYAGsVqtjXxDn17lw4UK3gxyFhYXNDuC05I477kB9fT3efvttxzGj0Yh33nmn3Y/pjn02cUFBQZPX/OUvf4FIJML8+fOhVqsbnc/Ly3Mpt3Tbbbehrq7OJXaDweDyfVPOnDmDsrIyth9a0Nwm1/bzqQN7YUjfRMTKZRgztC8mpKYAACakpuDq0YORNrw/khOVjj1buDE2ke9hP428BduRbEc2he1IIvI2KpUKBw4cwM6dO7F161Zs3boVeXl5AGx/k7Zu3YqdO3fiwIEDOHDgAPtIPkClrsKBgjM4XFiCwtMl2L59O99T8ijBVszZG0ARERH4+OOPcfPNN3OGJRGRH5o/fz7efvttvPzyy5g9ezbCw8MxZ84cbNmyBcuXL8fOnTsxceJExMTE4Pfff8fWrVsRGxvr0hkPDw/H6tWrkZGRgUmTJiEjIwMDBw5EVVUVvvnmG4wfPx7jxo0DAISFhWHRokWYOXMm0tLSMHXqVISGhmLjxo0oKyvDiy++6LE9VKZOnYr169fjhx9+wP333+/2mrFjx2Lx4sXIz8/Hn//8ZwDADTfcgI8++shx3vl1rlq1ChkZGRg1ahRuuukmpKSkQKfT4ZdffsHevXvxySefYMCAAQCAoqIirFixwnH/oqIiAHApHzhx4kRMnDgRAPDss8/iiy++wHPPPYd9+/ZhwIAB+Pbbbx0lkDzlhhtuwH//+1888sgjmD17tmN28b333uuY2T5q1Ci8+OKLeO6555CSkoIbb7wRSUlJKCsrw08//YRTp05BpVI5ZjU/99xzWLNmDf7+979j9+7dSElJwebNm2EwGFqMxz5AN2XKFI++zs6mUqmQm5uLzMzMRr+zzuc8/f55CjfGJvJN7KeRN2E7ku1ItiOJyBfk5uY2ufcpy/77ptx1PyHn3Y0XD3ArB/IwwRJzBQUFEIlEeOGFF3DLLbcIFQYRkc9RKpXIysrymYHuhIQEzJw5E8uWLcOSJUswf/58BAcHY+PGjcjNzcXKlSuxevVqWK1WJCUlYerUqbj77rsbPc7VV1+Nffv24eWXX8bWrVuxadMmxMXFIT09HXPmzHG59r777kP37t3x8ssv4/PPP4fZbMaQIUOwYMECzJw502Ov7c4778RTTz2FVatWNTmgkpaWBgAYNmwY4uNtGwz/+c9/RlBQEPr06dOoJM4111yD/fv3Y8GCBfjxxx/x9ddfIyYmBikpKXj99ddxzTXXOK4tKipy2/i/9Jh9QCU2NhY7duzAvHnz8P3332Pr1q249dZb8eSTT2L06NEICwtr98/C2YQJE7B06VK89dZbeOmllxyl0K6//nqXklPPPvssUlNT8eabb+Lrr7+GVquFUqnE8OHDkZWVBYVC4bg2Pj4eO3bswNNPP40ff/wRP/74I2688UbMnz8fV155ZbPxfPTRR1AoFLj99ts98vq6SnOJLedzycnJAkVIRP6I/TT/xnYk25F2bEf6dzuSiLpWZmYm0tPTsW3jxxidJIUsIgxHCs86yv73TVA4Sv5HR0f7zOdwoCkvV+NMcTEA4KY/9cfoAbNRcqEKX+/6FXffMMZlKwe+p9RRgiXmpFIp9Ho9xowZI1QIREQ+SalUet0snBUrVrjMuL1Ubm6uSwkiAAgJCcHjjz+Oxx9/vNXPM2jQIHz44Yetuvamm27CTTfd1OrHbo+wsDA89thjePnll3Hq1Cn07du30TVJSUmN9uWJiYmB2Wxu8nEHDRqElStXNnnebuLEic3u+eNOnz598OWXX7oc27JliyNWZ029r6153szMTGRmZrYYz/XXX4/rr7++xesAoF+/fli/fn2j483FcuLECezcuRP//ve/IZFIWvU8RESBjP00/8Z2JNuRdmxH2vhiO7K5qgrkm/ie+j6lUgmxWIyT+7chbXgPKOSRiI60rdqdkJqC5PjuKLNcwLBhw1wmDpB3sDbY9lhfu3YNNm9wrRRRpbfgTKUIg5NvQkrvRAB8T8kzBNtjzr73iHPdbyIiIl/z97//HTExMXjxxReFDqVVzpw54/K9xWJx7A1y3XXXCRFSp3rhhRcQHx+PZ555RuhQ/JJSEYWsWRlQKqKEDoWIPIT9NKKuw3akd/PWdqS9cgL3M/IffE+JhGU121ZnSweMRdSYu1y+pClpsFjMqKvTCRwl+RvBVszNmTMHP/74I1auXImrr75aqDCIiIg6JDIyEh999BH27t0Ls9mM4OBgoUNq1qhRo9C3b1+MHDkSYWFh2L59O/bv34977rkHo0aNEjo8jzIajRg4cCAeeughxx4j5FlKhRzZs6c4NsbW1Nah8PQFbN++3TF4l5eXB41GAwCQSCSQSqVQKpWcDUzkpdhPI+o6bEd6L7YjiYgCT5A0CiFRsa7HNNUCRUP+TrDE3C233IKsrCz85z//Qffu3ZGTk4Nu3boJFQ4REVG7/fnPf8af//xnocNolczMTGzevBmrV6+GXq/HZZddhgULFuDpp58WOjSPE4vFeP7554UOo1VUKpVjhqxOp4PBYMCRI0cAAJs2bcKePXsAwDFoV1ZWBsCW9OrVqxdOFpXgcKQB0ZERUCqioFTIuzR+boxN5D/YTyPqWmxHeidfakcSERGR7xEsMffQQw8BAPr27Yu33noLS5cuxahRo5CUlNTipsEikQjvv/9+V4RJRETkV1588UWfKZcUSHJzc5GTk+P2XHMJLOek1yt//Js1KwPZs6d4LrhWyLxtIjLGj0CRqhyrv9mNaZNHuWyMfUX/ntDW6R2bYw8ePLhL4yOi1mM/jYiawnYkEVHrsey//+F7Sp4kWGJuxYoVEIlsmylarVYYDAbs3r27xftZrVZ2+IiIiMivZGZmIiMjAxqNBts2fozRSVKcKlVj3hufInvWrYiL6YYLlTX46UA+rhk9GEazFdnLNmDh3OmIiYrAhrz9ePDmNCT0UAjSSVAq5FAq5IgID0WsXIYxQ/uistYAwLYxdurAXlBX1XJzbCIfwH4aEZH3aK6qAsuF+ya+p4HDXvYfANRVtcIGQx7B95Q8SbDEXHJysqPDR0RERBTI7B1utVqNk/u3IW14DyTFxwAAbhk/HKkDe+HEGRVKyytwz3VXorLWgOxlGzAhNQUR4aHYffgELr8sEb0T4wV+JUTk69hPIyLyHs1VVWC5cN/E95QAW4I2NzcXmZmZTLwSBSjBEnNFRUVCPTURERERCYgdUSLvxX4aEZH3aK6qAsuF+ya+pwTY+kM5OTnIyMhgf4goQAmWmCMiIiKiwMSOKBEREVHLmquqwHLhvonvqX+rrqlBydkG1NVEuByvrKlDdY1eoKjIE8rL1ThTXOz4nu8pdRQTc0RERETkcdwYm4iIiIiIAsXZs2exdGkujiZaEBbiWhZcb7Ji17kgXDvtISZbfYy1oR4AsHbtGmzecPF95XtKHcXEHBEREZEXai6x5Xyupq5egOha5rwxNhERERERkT+rqKiAyWRExOCrIYtx3fs7uOI8TGe2oqKiQqDoAkdxcTHUanWj44WFhe16PKu5AQAgHTAWkXHJjuN8T6mjmJgjIiIi8kLNJbacz3lrYo6IiIiIiCjQBEnlCImKdXyv1WpRobNCb7Li4MGDAIAjR44AAPLy8qDRaCCRSCCVSgFcLHdKbVdcXIyUgYOgr9e5PZ8cJXJ7vDWCpFEu72tQPctYUscIlpgLDg5u931FIhFMJpMHoyEiIiKizqBSV0Glroamtg6Fpy9g+/btOHPmDICLHVEAjs4oO6JEwmI/jYjIu7FcuP/he+rfDh44il07fwYAPPPMMy7n5s2b1+j6rKwsZGdnd0VofketVkNfr0PMzfMhjklyOVd3YieQv1agyIgaEywxZ7VahXpqIiIiIuoiuet+Qs67Gy8eWLrScZMdUSLvw34aEZF3Y7lw/8P31L+NSB2K7jIxjv+yA0/NnIpBAy7DkcKzmPfGp1g4dzr6Jiiwt0SHSRn3IDo6mpMUPUAckwRJfD+XYwbVCYGiIXJPsMRcVlZWi9fU19ejuLgYP/74Iy5cuIDhw4fj1ltv9VgMn376KT744AMcOHAAVVVVkMlkGDx4MO666y488sgjCA0N9dhzEVFga6rGtTdQKBRITk5u+UIionbIvG0iMsaPQJGqHKu/2Y1pk0fhfKXW0RG9on9PaOv0js7o4MGDhQ6ZKKB5Qz+NXLEdSURE5LtkMhkU3eUIF4uQOiARY0cPRnRkBABgQmoKkuO7o8xyAcOGDYNCoRA4WiLqKl6dmLMzm814+eWX8e9//xtpaWlYvHhxh57bbDbjnnvuweeff+44FhUVherqauzevRu7d+/GypUrsWXLFsjl8g49FxFRSzWuhRYWLsWJgvwODao88MAD+PDDDx3fBwcHIzY2FuPGjcPf/vY3jB492hOhEpEPUirkUCrkiAgPRaxchjFD+6Ky1gDA1hFNHdgL6qpadkaJvISQ/TRqjO1ItiOJiIiIyP8Ilphri+DgYDz33HP47bffsGTJEowdOxZ33313ux/v3XffdSTlsrKyMG/ePHTr1g16vR4rVqzAE088gf379+PZZ5/FkiVLPPUyiChANVfjWmjGihJUfPU61Gq1R2Y7P/jgg0hOToZer8fhw4exZs0arF+/Hhs2bMCNN97ogYiJiIjIW3i6n0aNsR3JdiQRERER+R+fSMzZTZs2DR999BGWLFnSoQ7fJ598AgC47rrrXPYwCQsLwyOPPIKDBw9i2bJlWLduHRNzROQx7mpc+5uHHnoI48aNc3y/fPlyPPzww3jqqac4oEJEROSnPNVPo6axHcl2JBEREbWeSVsJ7aFvIBt+A0Jk3YUOh6iRIKEDaAuRSAQAOHbsWIcep6ysDAAwdOhQt+evuOIKAEBdXV2HnoeIKNA9+OCDkEqlKCwsREVFheO4yWTCokWLMHz4cISHh0MulyMjI6PZv+8FBQV44IEHkJSUBIlEguTkZNx77704dOhQo2u//vprjB8/HpGRkZBKpRg9ejRWrlzZGS+RiIgo4Hmqn0bkjO1IIiLyV0pFFLJmZUCpiBI6FL9l1laietcnMGsrhQ6FyC2fWjG3ZcsWALaGeEf07dsXJ06cwPHjx92e//XXXwEAI0eO7NDzEBEFOpFIhODgYACAWCwGYNuPZsqUKdi8eTOGDBmCzMxMaLVarFmzBmPHjsWuXbsaTZzYunUrMjIy0NDQgIyMDKSkpECj0WDz5s0Qi8VYsWKF49pVq1bh/vvvR3R0NO6//35IJBJ88cUXmDlzJs6ePYtnn322y14/EbnHjiiRf/FUP43IGduRRETkr5QKObJnTwEAqKtqhQ2GiAThE4m5qqoqvP/++1i8eDFEIpFjRVt7Pfroo/jmm2/w9ddf48UXX8ScOXMQGRkJvV6Pjz76CO+++y7CwsKwYMGCJh/DYDDAYDA4vq+pqelQTERE/mj9+vWora1FamoqunXrBgD43//+h82bN+Puu+/GypUrERJi+yh69tlnMXToUMydO9cxwAcAOp0O9957LxoaGpCXl4exY8c6zhmNRuzatcvxvV6vx5w5cxAaGopffvkF/fr1czz2kCFDkJ2djQcffBBKpbIrXj5Ri1QqFXJzc5GZmRlQv5fOHVEi8l2e7qcROWM7koiIiIj8lWCJub59+7bqOp1Oh/LycgCA1WqFSCTC008/3aHnvuWWW7Bw4UL87W9/w/PPP4/nn38ecrkc1dXVCAoKwrXXXosXX3yx2RVzCxYsQE5OTofiICLyN8uXL8eWLVvQ0NCAEydOYMOGDejZsyfef/99xzVLly5FcHAwFi9e7BhMAWyfC1OnTsXHH38MjUaD6OhoAMCGDRtQVlaGhx9+2GUwBbDNnp44caLj+7y8PFRWVuKee+5xDKYAgEKhwMMPP4wFCxZg06ZNmD17dif9BIjaRqVSIScnBxkZGRzoIyKvIGQ/jQIb25FEREREFCgES8wVFRW1+T5yuRyvvvoqpk6d2uHnnzt3Lvr164eHHnoIarUaVVVVjnNBQUHQarXN3v+f//wn5s2b5/i+pqYGSUlJHY6LiMiXffDBBy7fjx07Fhs3bkRMTAwAoLa2FgUFBYiOjsbixYsb3b+oqAhWqxUnT57EqFGjAAD79+8HAJeBk6bk5+cDAEaMGNHonP2Y/RoiIiJqTOh+GgUutiOJiIioPVQqFVQqleNz2lD6G2BusN0uOQaLXgtjxVk0mK0oV2sQJIuGTCYTMmQi4RJzM2fObPEakUiEsLAwxMfHY/jw4bj22msRHh7e4eeuqanBfffdh40bN+Lhhx/G3Llz0adPH5SUlGDZsmVYtGgRvv/+e6xYsQL33nuv28eQSCSQSCQdjoWIyJ/s2LED48aNQ01NDT744APMnTsXU6dOxbZt2xAcHIzq6moAgEajaXbVcV1dneO2feJEfHx8i89vn1TRvXv3RuecB3WIiIjIPSH7aRTY2I4k6rhALZNO5CvKy9U4U1zscqyypg7VNXqBIvIPubm5Lm0DzQ9LLt7+8T3HbS2ALzZuRdq4OqSPH9OVIRI1Ilhi7tLZcF1p9uzZ2LhxI6ZNm4b33rv4nzMlJQWvv/46zGYz3nzzTfz1r3/FLbfc4qhnT0RErdOtWzfMmTMHp0+fxptvvon33nsPmZmZiIqKAgCMHDkS+/bta9VjyeVyALZOZkvsM54qKysbnauoqAAAREZGtup5iYiIApGQ/TQigO1Ioo5gmXQi72RtqAcArF27Bps3iFzO6U1W7DoXhGunPQSFQiFEeD4vMzMTGRkZ2LNnD3KeeRR/Sp+AWiPw45Y8TL5mAnr0UEBTXIjffz2CEWPTEX/ZQKFDJkKQ0AF0tdOnT+Ozzz4DAPzlL39xe80jjzwCwNYgd944moiI2ub555+HTCbDCy+8AL1ej8jISKSkpKCgoKDVM47tpYi2bdvW4rWDBg0CABw8eLDRuUOHDgEABg5kA4yEoVKpcODAARw4cAA7d+7E1q1bkZeXB8C2r83WrVuxfft2nCwqweHCEqjUVcIGTEREJCC2I4mIyF9Y/yirKB0wFlFj7nL5ihg8ESaT0TEJhNpOqVQiNTUV/fv3R2iwCInKWCQnJwIAkpMT0bt3MuJj5QgXixAbI2cZS/IKAZeYO3bsmON2cnKy22t69erluH3q1KlOj4mIyF/FxMRg9uzZKC0tRW5uLgDbquW6ujo89dRTMBqNLtcbjUZ8//33LsduvfVWxMXFYeXKldi5c6fLOZPJ5HJswoQJ6N69O9atW4fjx487jpeWluL999+HWCxGRkaGp18mUavk5uZi5MiRGDlyJNLT03HNNdc49qudN28errnmGtx+++145Z2VuOax15C77idhAyYiImqFS9tznsJ2JBGRbXJfdnZ2q1b+kvcLkkYhJCrW5StIKhc6LCISgGClLIWi11+s2Xvu3DnHrDhnZ8+eddwWi8VdEhcR+T9jRYnQITTSFTHNnz8fb7/9Nl5++WXMnj0bc+bMwZYtW7B8+XLs3LkTEydORExMDH7//Xds3boVsbGxKCgocNw/PDwcq1evRkZGBiZNmoSMjAwMHDgQVVVV+OabbzB+/HiMGzcOABAWFoZFixZh5syZSEtLw9SpUxEaGoqNGzeirKwML774Iku6kGDs5TU0Gg22bfwYo5OkOFWqxrw3PsXCudNxRf+eOHdBgw15+/HgzWkYOfgyoUMWBPdGISJqzJvbkfZ93DoD25FEFOhYntS7OfddiIjawisSc1VVVfjss8+we/du/Pbbb45NnaOiotC/f3+MHTsWd911F6Kjozv8XEOGDHHcXrVqFa655ppG13z66aeO2yNHjuzwcxJRYFMoFAgLl6Liq9eFDsWtsHBpp9YxT0hIwMyZM7Fs2TIsWbIE8+fPx8aNG5Gbm4uVK1di9erVsFqtSEpKwtSpU3H33Xc3eoyrr74a+/btw8svv4ytW7di06ZNiIuLQ3p6OubMmeNy7X333Yfu3bvj5Zdfxueffw6z2YwhQ4ZgwYIFmDlzZqe9TqKWKJVKKJVKqNVqnNy/DWnDeyApPgYAMCE1BakDe+HEGRV2Hz6Byy9LhFIhFzZggXDwgch7dGU/jdzz9nakJCwcl13WeRNJ2I4kappKXQWVuhqa2joUnr6A7du348yZMwBsZdI1Gg0kEgmkUimAi21RIvIc574LEVFbCJ6YW7BgAV588UWXlWxWqxUAIBKJsGfPHqxevRrz5s3Dc889h+eee65Dzzd48GCMHz8e27dvx8qVK6FUKjF//nwoFArU1tbi/fffx//93/8BsCXl0tLSOvR8RETJyck4UZAPtVotdChuKRSKJkv7ttaKFSuwYsWKJs/n5uY6ShABQEhICB5//HE8/vjjrX6OQYMG4cMPP2zVtTfddBNuuummVj82ERERuerqfhq5J2Q7UqvVQnW2GLJukbBAhOqqGkTJuyEkJAQWkxHamlpcPmwE+vXr16HnYTuSqH1y1/2EnHc3XjywdKXjpr1curOsrCxkZ2d3QWRERMKTySKQNu4qyGQRQodC5JagiblHHnkE7777rqODFxISgt69eztmXFZWVqKoqAhmsxl6vR7//ve/UVRUhHfffbdDz2tfKffbb7/h5Zdfxssvv4xu3bqhpqbGcU3fvn3xxRdfQCQSdei5iIgA26BKR5NfRERERF1BqH4auSdUO7KmpgbySCmioqNhgQgV6krEKLpDLBbDbGxAtUaDpKSkLo+LiGwyb5uIjPEjUKQqx+pvdmPa5FE4X6l1lEnvm6DA3hIdJmXcg+joaK6WI6KAIpPJkD5+jNBhEDVJsMTcd999h2XLlgEABg4ciBdeeAE33XQTwsPDXa7T6XTYtGkTsrOzceLECSxfvhy33347rr/++nY/d1JSEg4ePIjc3FysW7cOv/76K2pqahAVFYVBgwZh6tSpeOyxxyCTyTr0GomIiIiIiHyJkP00IiJqPaVCDqVCjojwUMTKZRgztC8qaw0AbGXSk+O7o8xyAcOGDevUrQvIc1pTnhSAo0Qpy5MSEfkuwRJz9s7e0KFDsWvXriaTYFKpFHfddRduvPFGjB07FsePH8eyZcs63OGTSqWYO3cu5s6d26HHISIiImovpSIKWbMyoFRECR2KIDj4QOR9hO6nERERBSqWJ/VuKpUKKpUKOp0OBoMtCX7kyBEAtr6L2WxGg9mKcrUGOoRCJovgog8iapJgibmff/4ZIpEI//jHP1r1RyoyMhLPPvss7r33Xvzyyy9dECERERFR51Iq5MiePUXoMATDwQci78N+GrkTHBQEmSwCwUFBQodCROS3WipPekX/ntDW6R0lSgcPHix0yAElNzcXOTk5bs85912+2LgVAJA27iqWUiSiJgmWmKuoqABgK4/SWvZr7fclIiIiIt/FwQci78N+GrkTFBwMWSRn/RMRdaaWypOmDuwFdVUtS5QKJDMzE+np6di28WOMTpJCFhGGI4VnHX0Xq0mPJavWY8TYdMjikiCTRQgdMhF5McESc5GRkaisrERZWVmr72O/NjIysrPCIiIiIqIuwsEHIu/DflrgMRgMMJlMjY7r9XoBoiGijgj0MulEnUmpVEIsFuPk/m1IG94DCnkkoiNtybcJqSmo0qgRLhYhNkaOqPg4gaMlIm8nWB2Kyy+/HMDFPQxaY+nSpQCAIUOGdEpMREREROS9VCoVsrOzoVKphA6FyG+xnxZYDAYDjv36K/Lz8xt9FRcXCx0eEbWRvUy6UiEXOhQiIiJqhmCJubvuugtWqxUbNmzAww8/DLVa3eS15eXlePDBB7Fx40aIRCJMnz69CyMlIiIiIm+gUqmQk5PDxBxRJ2I/LbCYTCZYLRaERMVBHJPk8hUUES10eEQBi5ORiIh8C/9uU1sJVspy1qxZeP/997F//36sWLECq1atwp/+9CcMHjwY0dG2DoBGo8Gvv/6KPXv2OEprpKamYtasWUKFTURERERE5LfYTwtMopBQiMQS12NGlrIkEop9MlJGRgaUSqXQ4ZCAWJ6UyDfw7za1lWCJueDgYHz//fe48847sXXrVhiNRuzatQu7du1qdK3VagUATJo0CZ9//jmCg4O7OlwiIiIi6gIcfCASFvtpREREXaO6pgYlZxtQVxPhcvxcaTkM+gYAF8uTkndy7rtUaZquMkBEdCnBEnMAEB0djR9++AFff/01PvzwQ+zevRvnzp1zuSYhIQFpaWm47777cPPNNwsUKRERERF1BQ4+EAmP/TQiIiLPUqlUyM3NRWZmJpRKJc6ePYulS3NxNNGCsBCRy7VVegtOVIpQXT0RSIwXJF5qHee+S36hsLEQkW8RNDFnd+ONN+LGG28EANTX16O6uhoAEBUVhfDwcCFDIyIiIiIBqNRVUKmroamtQ+HpC9i+fTvOnDkDAMjLy4NGowEASCQSSKVSKJVKlgwh8jD204iIiDzj0jJ3FRUVMJmMiBh8NWQxrsm3htJiWHbtQF2dTqBoiRorLi5ucu9hhUKB5OTkLo6IyLd5RWLOWXh4ODt5ROR3tFot9Hrv3KcjLCwMMplM6DCIiFzkrvsJOe9uvHhg6UrHzXnz5jW6PisrC9nZ2V0QGVFgYj9NOJ3Zjqyrq0NVVRVCRNJGe8yZdTUI1lXBbLUiWBzqes7YgJqqaii0WnTr1q1TYiPPaGhogFqthkKhQGhoaMt3oC6nUqmgUqkAADqdDgaDAUeOHAFwcTJSdXU1ThaV4HCkAYP7JECpkAsYMXlSkFSOkKhY12OaaoGiIaFdurLSWxQXFyNl4CDo690ni8PCpThRkB8wyTmtVotytQZ6kxUHDx4EgEZ/t+0TSAFwEim55XWJOSIif6PVavH5h8tgqqsUOhS3QiK6486Zs/0mOXfo0CGMGDHC5dgHH3yABx54oFOft6ioCH369MHMmTOxYsWKTn0uokCQedtEZIwfgSJVOVZ/sxvTJo/C+Uot5r3xKRbOnY4r+veEtk6PvSU6TMq4B4MHDxY6ZCLyoJMnT2LBggX4/vvvceHCBXTv3h0TJkzA3/72t0af8x11/vx5fPbZZ/j+++9x+PBhlJeXQywWo2/fvrjxxhvx1FNPIT5emFJind2ObDAaoVZXIDg8Egh2HR6wGg0QGXUIk0ggumT/QKvZDL3BgF8P9cX9s//KdmQHdWY70mg0orS0FFFRUUzMeanc3Fzk5OS4PXfpZKRXAGTNymDZbyI/denKSm+hVquhr9ch5ub5EMckuZwzVpSg4qvXoVarAyYxd/DAUeza+TMA4JlnnnE5x0mk1FpMzBERdTK9Xg9TXSUm95dBHikVOhwXVbU6/FhYCb1e36EBlQceeAAffvih4/vg4GDExsZi3Lhx+Nvf/obRo0d7ItxWiY+PR1ZWFgDb4MqGDRu67Lk9yf4zPX36NHr37i10OERdTqmQQ6mQIyI8FLFyGcYM7YvKWgMAYEJqClIH9oK6qhZllgsYNmwYFAqFwBETkafs2LEDN954I7RaLQCgW7duUKlU+PTTT7F27VqsWrUKd955p8eer3fv3jAYDI7vu3Xrhvr6ehw9ehRHjx7Fu+++i3Xr1mHChAkee87W6ux2pKHBiLIyK4IjoiAKFrucszToEdSgRVh4OIIuScxZzGaUqTU4WFHFdqQXcm5HxsbGtnwHElRmZiYyMjKg0WiwbePHGJ0kxalStctkpHMXNNiQtx8P3pyGkYMvEzpkIgpQ4pgkSOL7CR2G4EakDkV3mRjHf9mBB6ZMQt/kJBScKcN/VnyH5x+4DklxchwrBzLumYXo6GivSrKS9xAsMWexWDBnzhzU1dVh8uTJmDFjRrPXf/755/j2228hk8nw5ptvQiQSNXs9EZG3kUdKoZBHCh2GG1qPPdKDDz6I5ORk6PV6HD58GGvWrMH69euxYcMGxx41nS0+Pt4xE2nFihU+O6BCREQkBKH7adXV1bj99tuh1WoxYsQIfPbZZ+jfvz/OnTuHBx98ED/88ANmzpyJ0aNHo0+fPh16Ljuz2YwJEybgL3/5C6677jrExsbCZDIhLy8PjzzyCH7//XfceuutKCgoEGzlXGe1Iw0NDTDW1yJYJnOTmAtGkMGCcKkUQZesprOYTdDX1wMVnouF7UgKVPYSZ2q1Gif3b0Pa8B5Iio8BcHEy0okzKuw+fAKXX5bIMpY+oDXlSQ8ePIgGsxXlag2CZNF+s/KY2q+wsBCRkbbP+vz8fMdx7t/mfWQyGWJkEoSLRfht/w4UHxZBrbMCAI79vBVFocCuc0F48Ml/YPjw4cIGS15LsMTc2rVr8fbbb0Mul+PVV19t8frrr78eTz75JNRqNdLS0nDXXXd1QZRERNQWDz30EMaNG+f4fvny5Xj44Yfx1FNPddmACpG38dZ9AoiI3BG6n/a///0P5eXlCAsLw5dffolevXoBABITE/H555+jf//+UKvVWLBgAZYtW9ah57Lbtm2bS/sFAEJCQnD11Vdj7dq1GDFiBKqrq5Gbm+tYTUWex3YkUedim7TrtKU86RcbtyJtXB3Sx4/pitDIC1kbbPu2Pfroo45jzhOjAm3/Nl9hNTcAAKQDxiIyLhn68gqg4BvIrrgWEUFGmM5sRUWFB2cwkd8JEuqJP/74Y4hEIsyePRsxMTEtXt+tWzfMnj0bVqsVn3zySRdESEREHfXggw9CKpWisLCwUYPEZDJh0aJFGD58OMLDwyGXy5GRkYFjx441epzffvsNzzzzDEaMGIHo6GiEh4dj8ODBeOGFF1BfX99VL8fh999/x9SpUxEVFYWoqCjcc889KC8vd3ttW2LPzs6GSCSCSCRylHTq06eP45hIJEJRUZHLfZYvX46MjAz06tULEokECoUCGRkZ+OWXXzrltVPb2fcJsM+aJSLyZkL30z777DMAwC233OJIytnJ5XLcd999AGwJRLPZ3OHnA9AoKefsiiuuQN++fQEA+/fv98jz+ROzyYS6urpGX86lQduL7UjPtCNlMhlGjx4NmUyGo0ePora21vE+LVu2jO3IAMI2adfJzMzE/v37sWXLFjz314ew/tUnsHDudADAwrnTsWXJ03j9ySm4LBqYdlM6RqQOFThiEoJWq8X582W4cEENvckK2chbEDlqCgAgctQURF/7GCKvmgZ9vQ47duzg/10nxcXFOHDgQKOvwsLCLo8lSBqFkKhYBMuiAQDBsmgESeVdHgf5HsFWzO3ZswcAcPXVV7f6PhMmTMBLL73kuC8REXk3kUiE4D/2JBGLL5ZHMpvNmDJlCjZv3owhQ4YgMzMTWq0Wa9aswdixY7Fr1y4MHXqxc7Ju3Tq89dZbmDRpEtLS0hAeHo69e/ciKysLu3btwrfffttlJY5VKhXGjRuH8vJy3HHHHejduze++uor3H333W6vb0vsEydOdNxv/fr1OHz4MObMmQO5XO447nwbAB577DEkJydj3LhxSEpKQkVFBdatW4fx48fj22+/xaRJkzz9IyASjFIRhaxZGVAqooQOhchvCdlPq6qqwtGjRwG4fiY6mzx5Mt544w1UVlbi2LFjGDZsWIeeszXsn73cTsGJ1VauqbqmBoWFhY0SS6KgIFw+ZAgkEkm7n4LtyLa3I2tra1FbW4uffvoJhYWFmD59uqMsGgCo1WqXpOlf//pXJCQkYOzYsejVqxfbkUQe0prypCJTPcLFIsTGyFnGMkAdPHAUu3b+fPHA/k2Om7X71rtcO2PGDGRlZTnKLQey4uJipAwcBH29zu355Ci218g3CJaYszfce/To0er7KBQKAOAyUCIiH7F+/XrU1tYiNTUV3bp1cxz/3//+h82bN+Puu+/GypUrERJi+zh69tlnMXToUMydOxdbtmxxXH/rrbfiL3/5i+NzwO6xxx7DO++8g23btmHy5Mld8pr+85//oKysDG+88QaeeuopALYZyqNGjXJ7fVtinzhxomMgsqioCIcPH8ZTTz2F3r17NxnPDz/8gPT0dJdj//rXvzBo0CBkZWVxQIX8ilIhR/bsKUKHQeTXhOynnThxwnF7wIABbq9xPl5QUNDpibm6ujocP34cADBy5MhmrzUYDC5Jj5qamk6NTVi2xFyQRIqQ6ASIu19cXWk1NcBUXQaTydShxBzbkW1vR44dOxZ6vR5/efghFBYW4tn5T6JHXDxKyiqRFNcdEnEI6hosiJR3R3BwML788kvExsZi0KBBiIiIAHCxHfnvf/8bn332GRQKBUJDQzvvh0JucTISkfeqrqlBydkG1NVEuBxXq9VtepwRqUPRf0BfqE/nI//QQQwZNQZaayh+3JKHyddMQI8eCtRr1PhlRx6yXn0Ht956qydfhs9Sq9XQ1+sQc/N8iGOSXM7VndgJ5K8VJC6ZLAJp466CTBYBi7ZBkBjItwiWmOvWrRs0Gg00Gk2r71NVVQUALjO+iIjIeyxfvhxbtmxBQ0MDTpw4gQ0bNqBnz554//33Xa5bunQpgoODsXjxYsdgCgD07dsXU6dOxccffwyNRoPoaFspgEGDBrl9vptuugnvvPMOjh492mUDKuvWrYNUKsWsWbMcx8LCwvDEE0+41IS36+zYL03KAUCvXr0wZMgQx6oDIiKi1hKyn3b+/HnH7fj4eADA7Nmz8cknn+C+++7DkiVLXPZFKisr69DztcaiRYug0+kgkUjwwAMPNHvtggULmtxTyG+JgiASSyAStz8BZ8d2ZMfbkaGhoRCJRAgKsu1aEikNg0waBgCQScMQKg6GESaEh4dDLBZj/PjxyM/Pd3lsezvy2LFjKC0tRVRUFBNzAuBkJCLvdPbsWSxdmoujiRaEhbiuzKrSW9r0WDKZDDKZDFbNWYSLRUhUKlAfYmtLJScnIj4+DjVhIoQGi9C/f3/uDXkJcUwSJPH9XI4ZVCeauLrzyWQyx16RNdrWt6MpcAmWmOvTpw80Gg3y8vKaLFNyqW3btjnuS0RE3ueDDz5w+X7s2LHYuHGjyx41tbW1KCgoQHR0NBYvXtzoMYqKimC1WnHy5EnH7GGLxYL33nsPH374IY4dO4ba2lpY/yihZH/MrqDRaFBWVobLL7/cMavYrqkZ+50d+++//46XXnoJ27ZtQ2lpKYxGo+OcvfwTdR2VSuWo/a/T6WAwGHDkyBEAQF5eHjQaDaqrq3GyqASHIw0Y3CcBSoVcwIiJiFwJ2U+rq6tz3A4PD0dFRQXeffddAMA777yDF1980WXllFar7dDzteTQoUN48cUXAQD//Oc/kZyc3Oz1//znPzFv3jzH9zU1NUhKSmrmHuSM7cjGOjv2kydPIicnB0eOHIFKpWI70o+o1FU4froUhacvYPv27YiKimrUJpVIJJBKpQAull4kouZVVFTAZDIiYvDVkMXEu5zTnzoOqA8KFBkR+RrBEnPXXnst9u/fj8WLF2PWrFlISEho9vqSkhIsXrwYIpEI1157bRdFSUREbbFjxw6MGzcONTU1+OCDDzB37lxMnToV27Ztc3Tuq6urAdgGJ5qbVe48OPfXv/4Vb7/9NuLi4jBt2jQolUqEhISgqKgIH374IUwmU+e+sEti6t69e6NzzoNGzjoz9sLCQlx55ZWorq7G5MmTcdtttzkGLFesWIEzZ860+7GpbVQqFXJzc1FbW4uFCxe6vcZ5sBYAXgGQNSuDs6GJyKt4Uz8tJiYG9913H9auXYsZM2age/fuXfaZr1arcfvtt0Ov1+Pqq6/Gv/71rxbvI5FIOlS6MdCxHdlYZ7cjJ0yYgOrqakyYMAG3334725F+JHfdT8h5d6Ptm6UrXc5d2iYFwL2rukB7ypOWl6txprjY5VhlTR2qa/SeDo/aKEgqR0hUrOuxMO4VSEStJ1hi7rHHHsMbb7wBjUaD8ePH47333mtyRubWrVsxa9YsVFVVISwsDI8//njXBktERG3SrVs3zJkzB6dPn8abb76J9957D5mZmQCAqChbR2TkyJHYt29fi4914cIFLFmyBIMHD8Yvv/zisjH2F198gQ8//LBzXoQb9ueurKxsdM7dvjqdHfuiRYtQVVWF5cuX48EHH3Q598UXX3TosaltVCoVcnJy8O233+Lee++FRqPBto0fY3SSFKdK1Zj3xqdYOHc6rujfE+cuaLAhbz8evDkNIwdfJnTofsOeHM3MzOSMb6IOELKf5ryKqL6+HgCwcuVKrFy5stFxAC6fq55UW1uLG264AadOncIVV1yBNWvWcPVQF2I70sbTsZvMZpjNZugNJmi1WrzyyiuoqqrC888/j8cffxzh4eGOMpifffZZG18deZvM2ybiiv49sfqb3Zg2eRR6xMhxpPCso03aN0GBvSU6TMq4B9HR0Ww7dYG2lCe1Ntg+69auXYPNG1zLJepNVuw6F4Rrpz3UaP9JIiLyHYIl5nr27InXXnsNTz75JE6fPo2rr74a/fr1w1VXXeXYT+D8+fP4+eef8fvvv8NqtUIkEuH1119HYmKiUGETEVEbPP/883j//ffxwgsvYObMmQgLC0NkZCRSUlJQUFCA2traFvejOXXqFKxWK2644YZGA3B79uxp9r7263U6XcdeyB/kcjkSEhJw+vRp1NXVuQwgHjp0qNH1HYndPgDY3EzokydPAgDuuOMOl+OVlZWOc9S1YmNjkZqaCrVajZP7tyFteA8kxdtmwU9ITUHqwF44cUaF3YdP4PLLElnG0oPsydGMjAwOLhF1gJD9NPvj25/j8ssvb3SNvVwwAMTFxXXo+dzR6/W49dZbsW/fPvTr1w/fffcd5HK5x5/HG1ktFlgb6iEKDYfojz3KhMR2ZEfakbb3z2QyQRwSjASFHDXaepRV1gAAysorcOzYMQDANddcg5KSEsd9q6urcerUKcf3Wq0WZrPZZe86sVjMfee8nFIhx5C+iYiVyzBmaF/0ToxHdKTtd25CagqS47ujzHIBw4YNY3LHC1nNDQAA6YCxiIxzLaMcXHEepjNb3Sb0yffJZBFIG3cVZLKIli8m8oDi4mKo1Wq35xQKRYul3Kn9BG1tP/7441i8eDFCQ0NhtVpRWFiIVatW4bXXXsNrr72GVatWobCwEFarFRKJBIsXL3a7ITIRkacUFxfjwIEDbr/+3//7f02eKy0tFTp0rxQTE4PZs2ejtLQUubm5juOzZ89GXV0dnnrqKZe9LADAaDTi+++/d3xvbwTs2bPHZU+NI0eO4J133mn2+fv1s20E/PPPP3f4tdjddtttqKurw9tvv+04ZjAYXL6360jssbG2shgFBQVNXmN//F9++cVxzGw2Y/78+TAYDK14NUSBQaVSITs722VAn4iaJlQ/LSUlxXH7t99+c3uN8/GBAwd2+DmdmUwm3Hnnndi2bRuSkpKwZcsWl2ShLzOaTDA0NDT6cmmHWc2wGOoAq1m4QJ2wHdn+2O2lMQt++x2hIcFIiJUjLiYKl/WMhTxSij4JCqT0s+0JeezYMXSLCAdga0cuWrQIDQ0NjscqKSnBb7/9hhMnTiA/Px/5+flNDuARkWcFSaMQEhXr8hUklQsdFnUimUyG9PFjOq0qAJGz4uJipAwchJEjR7r9Shk4CMWXlNMlzxFsxZzd448/jltuuQWLFy/GN998g/z8fEejUyQSYfDgwbjhhhvw5JNPMkNLRJ3K/oGkr29iVqwoCLBa3J4akDIQa774vNnHr6r1zGxbT+qKmObPn4+3334bL7/8MmbPno3w8HDMmTMHW7ZswfLly7Fz505MnDgRMTEx+P3337F161bExsY6ElIJCQmYOnUqvvzyS4wdOxbp6ekoKSnB+vXrMXnyZHz99ddNPvfw4cNx1VVX4aOPPoLJZMKAAQMAAE899VS7Z78/99xzWLNmDf7+979j9+7dSElJwebNm90mwjoS+w033ID//ve/eOSRRzB79mz06NEDAHDvvfc6ZodnZmbigw8+wJQpUzB9+nRERETgp59+QmVlJYYOHYqjR4+26zUS+RuupiNqOyH6aXK53PH5lZeXh8cee6zRNdu2bQNg26fL3Yq69rJYLLjvvvuwadMmxMXFYcuWLejVq5fHHr+jOtJmM5pMOH/+PJxyO40Em8UAAHOdDsFmMUTBYlga9Ahq0CHMaEXQJaU8LSYjquv0AIJgtZhh1lYiSBoFUZBnS36yHdm+2K+eNAmL/7cEj8x5GrMP3Y8esbYVUbdPvRXi4CDIpBI8mfkwVn/6BZ555hlMm5qB8PBw5O3cjdqaWgwZNBC/5tt+hklx3SERh6CuwYJIeXcEBwdDLBa36/UTkWexlDsFOpO2EtpD30A2/AaEyBrv4UrNU6vV0NfrEHPzfIhjklzOGStKUPHV61Cr1czJdBLBE3OAbSbYq6++ildffRVGoxEajQYAEB0dzQYfEXWZ5j6Q6k/tQ/WOVU1+WBmOroHF4j5pFxYWhpCI7vixsBKAtrPCb7eQiO4ICwvrtMdPSEjAzJkzsWzZMixZsgTz589HcHAwNm7ciNzcXKxcuRKrV6+G1WpFUlISpk6dirvvvtvlMT788EP06tULX375Jd566y1cdtllWLRoEVJSUpodlACAL7/8Ek888QS+++47fPLJJwCABx54oN0DKvHx8dixYweefvpp/Pjjj/jxxx9x4403Yv78+bjyyisbXd/e2CdMmIClS5firbfewksvveSYuXz99dc7EnMjR47Ed999h+effx6fffYZxGIxrr76arz22mu4//772/X6qGUqlcqx8kqn08FgMODIkSMAgLy8PGg0GlRXV+NkUQkORxpgMrv/20BE5O2E6KfdddddOHr0KDZu3IiSkhIkJV1sd1VXV2PVqlUAbCuPmtv3TSS6uCfP6dOn0bt372afNzMzE59++iliYmKwZcsWRxJGaJ5oRzYYjVCrKxEkkTZKnFnNRlga9AgOt608M9fX2m4Hh8BqNEBk1CFMIoEo+NL7maA3NEAU1ROSkBBbYk4SAXg4Mcd2ZPtiHzt2DN5+4xW8nfs+Xnr1DUc7ctLE8QiL6AYAGDliGNZ/vhrPZr+ELzd8BbFYjDFX/Qlv/PcFzHrsKcdjyaRhCBUHwwgTwsPDOUZD5EU4+YwCnVlbiepdnyC835+YmOsAcUwSJPH9hA4j4HhFYs6ZWCx2rAogImqvjtRIdveBZKwoafJcS2QyGe6cORt6vb5N9+sqYWFhHS6TsGLFCqxYsaLJ87m5uS4liAAgJCQEjz/+OB5//PEWHz8yMhJvvPEG3njjjUbnrM1N/4ZtAGTNmjUtPkdb9OvXD+vXr29VLB2JPTMzE5mZmc1eM3nyZEyePLnR8Z9++qnZ+1H75ebmIicnx+25efPmuXz/CoB59/4ZWbMyoFREdUF0gUGlroJKXQ1NbR0KT1/A9u3bcebMGQAXk6MSiQRSqRQAUF5eLmS4RH6hq/ppTzzxBN58802Ul5dj6tSp+PTTT9GvXz+UlpbioYcewoULFxAWFoZnn33WY885d+5cvPfee4iKisL333/v0ZV4HeWJdmRdXR0KCwsREp0AkVgCq8UMS30NgsK7wWqoh7m2HCHRCQAAk6bUcZ1ZV4NgXQW6yaMQLHbdT8xsqEdNjRZiRW9IIyJg1Fe2Oz62I5uOpSOxz3rofjw260GXY/oGI1TqKhgbjIDVirQxf8L777+Pfj1jESQSoaKmDgmxcvz07QbU6RuQf5rl+v2JUhHFNikREZGX8LrEHBFRR7VUkjIsXIoTBfldshTbYDDAZDJBJBIhPDzc5VxISAgkEkmnx0BEnpWZmYmMjAxoNBps2/gxRidJcapUjXlvfIqFc6fjiv49ce6CBhvy9uPBm9MwcvBlUCrkQoftV3LX/YScdzdePLB0pePmpclRwLYfERH5hqioKKxZswY33ngj9u/fj/79+yMqKgo1NTWwWq0Qi8VYsWIF+vTp45HnKy4uxqJFiwAADQ0NuPHGG5u9/vz58x553raQyWQdmkQVHh6O8vJyiLvH2BJzRgOMphqERITDGhYCc7ARwZERgNUKs1WOYJkUohAJLCEWBIeaIesWCXGoxKWcpdlQj+DgEFgiIjzxEqmLmExm6HQ6lDfoIBIBpj8W9avVaohghd4sgtkUCXBVnF9SKuTInj0FAKCuqhU2GCIiIicdWWDhq5iYIyK/I1SNZKPRCJ1OB7PZ7Pj+5MlTsDaxL50oKAiXDxnC5ByRj1EqlVAqlVCr1Ti5fxvShvdAUnwMAGBCagpSB/bCiTMq7D58ApdflsikXCfIvG0iMsaPQJGqHKu/2Y1pk0fhfKUW8974FNmzbkWkVIJDZ+twxVUTIZPJUFZWBsD9ajr7+0lE3mP8+PE4fPgwXnrpJfzwww+4cOEC4uLiMH78ePz9739Hamqqx57LuRR5fX096uvrPfbY3s5UXea4ba65uLLYXHtxUMQCQFNVC5nMAllkxyoskPAsFgtgtSIoTIYgcShEZgsigg0Qh0lgMZsArbbJ8vxE1DrO+76x9CsRUcu8aYFFV2Jijoj8VlfVSDZrNYBI1OTMjpCoOIhCXMv/WE0NMFWXQavVwmQyNb4PV9MRETVJqZBDqZAjIjwUsXIZxgzti8paAwCgVF2FZV/m2S5cu9nlfu5W02VlZSE7O7uzQyaiNrrsssuwfPnydt+/pTJ/dr179271tf4mJCoOFlMDgus1iIiMhNkK1NbUIrJbJMQhITA16GGor4dUJoNYYtuP2GI2w2yxwGIyw2IFrCYD7D89S0M9RBYLrGbbfmZ6vR5isRihoaFNRECCCQqGKFiM4GAgMtTW57AaXP8fiEOCkaCQQxzi2X0Difyd875vycnJqK6pQcnZBtTVuK4wbmr8oClarRZabR3q1BroTVYcPHjQsdeqffIZAMcENE4+I39j3+s9Pz8fAGAo/Q34o81hKDkGi14LY8VZNJitKFdrECSL7vC2LdQ1hFpgITQm5ogoINk/yFs61hoWg9Y28zS8G0Lk8RAFi/84XgezthKikFCIxK5JNqvFtqru9OnTbh+Tq+mIiNrntskjcd2YIY6VdD1i5DhSeNZRarRvggJ7S3SYlHEPoqOjOWBBRAFLFBIKkdUCkQgQi0MQDBEAIDRUDLFYDJHFCKMICAkJdpSx1OnqodXWXXwQp9V1zivtAFs7NyEhAQkJCZ3/YsjjQkOCkRArBwAY/6gIQkRtc/bsWSxdmoujiRaEhYhczlXp27Y69eCBo9i182fH988884zjNiefkSe5KynY3vEyT7p0r3fND0su3v7xPcdtLYAvNm5F2rg6pI8f05Uheq2mykR2xvvakZKUXbXAwlswMUdEPqs9Hyz21W0zZszweDyioGDbAMcfq+NEpoamL/4jMcfVdEREnhUrj0RvZYxjJV3vxHhER9pmKE9ITUFyfHeUWS5g2LBhUCgUAkdLRNS5GhoaoNfrAQAWo962os1kW2FsaaiH1WyE1QqYTCZYIGruoQAAUmk4JGESmAx66HU6hEdEwIwgl5V2FrMJdbW1UPZMhlwu78yXRwJoaGiAWq2GQqHgakiiFlRUVMBkMiJi8NWQxcS7nNOfOg6oD7b6sUakDkX/AX1RUVqC47/swFMzp8Iokrjsc62t0zsmoA0ePNjTL4cCQEslBYVk3+t9z549yHnmUfwpfQJqjcCPW/Iw+ZoJ6NFDAU1xIX7/9QhGjE1H/GUDhQ7ZK3TlexqoJSnbi4k5IvJJ7f1gsa9uc7c8uv7UPlTvWOXJMFvE1XRE/kGpiELWrAwoFVFCh0JEROSgVqtRWloKwHUfOeDiCjf7PnKtERT8x+o5UwOC7CvtRLbVdPaVdmYjIBIBYWFhTNz4IJPJBEOD6wRDs9kCs9m2usdoNKK0tBRRUVF8f4laKUgqR0hUrOuxsLaV2JPJZJDJZBDpaxEuFiF1QCLCIl33uVZX1XICGnVIUyUFhRgvu5S9PKtGo0FosAiJyljoYPscSk5ORHx8HCT15TgnFiE2Rs4yln9orkykp9/X1pSk3LFjBwYNGuRyzhtWZAqBiTki8kkd/WBxtzzaWFHSoZg8tjtJK1bTmUwmJuaIOllb9hxSKuTInj2l84KhFjknR2vq6oUOh4ioTTprnzuFQoGQkBCozhYjIjISQcEhMJpMjhVuIovJsY+cRRSE6qqaTomDvJ/9d1Cj0aCq6tJzgNYIdIvmQH9r+drelSqVCrm5ucjMzGxU5ru5c4HK/jOZMmUKLBYLdDodDAbbauQjR44AsO37ZjabHftd6RAKmSyCyQJql8LCQkRHRzc63lJpwPa6dMyso+NlJLzOGAdty3N1ZgUzX8XEHBH5tK78YGlOTU0NzBYLrGZTo2Rae7lbTUdEXcdoNAKAY1N18m7OyVEm5ojIV9g/Y4xGI8LDwz3++KGhoQgLC7u4j5w4FKKgi3vJwWR17CMnChZDJotAcFCQx+MgH2C1rYgLCotAkNi1P2MxmWBtqIHJZGK7qJV8rR2pUqmQk5ODjIwMt4m5ps4FKvvPRKVSYdmyZW6vcd737YuNWwEAaeOu4p5X1CbWBluVqEcffdTteZYGJF/hbRXMvAETc0REHqDRaHDyQi3iYnUQhYZDJGp5jw4i8l5WqxXV1dWQSCQQi8VCh0MdxFKjROStxGIxJBIJqqurERkZKWgbMig4GLJIruQIeEG2JK0Li2+t/hIa25GB47bbbsOdd96JbRs/xugkKWQRYThSeNax75vVpMeSVesxYmw6ZHFJkMkihA6ZfIzVZCstHP3nRyFRprics5cGVKvVTMyRz/CWBRbegIk5IiIP2XxEhcviuyMOQJBECqvZBACw2jfacNL+c7aZlwaDwWdmXxL5EqvVCqPRiOrqami1WiQmJgodEnmA82o6dSv3USIi6ioKhQLnzp3D2bNnERUVBbFY7NEEXUNDA6xWwGQ2wyoywWy2lU03m82A2QKL/ZzJ5HI/cyvPiYKCIJWGw2qxwmSyPb7VantevV7vsddBrWM0GmE0mqBvsMIcZHE512A0ten9tpgtsFgtsJhMMFuA6upqx++mRqNBfb1thbpIJIJIJEJISEhA7zvHdmTgiY2NRXJyMk7u34a04T2gkEciOtKWfJuQmoIqjRrhf+x3FRUf5/Hn5+SzwCGOTmyUzPB3xcXFUKvVjY4XFhY6bstkEUgbdxWT3p2oqf3fOquMaiBhYo6IyEMOlVThnb0aXNevAZd1D0WQ2QBLfS2C683AJbNOrUY9LPU1bT4HsxHmOg3EYrFHO70mkwkWi8XtuaCgIISE8OOCAotEIkFiYiK6devmOMb9NYiIqDPYP2vUajXOnTvn8cfX6/VQl6uh1ekgCg6G2WxBnbYO9fp6wGJCg94AibYOQZe098zGhradq7b9YzWboavTwSIKRlhYmMdfDzXPbDZDp62FVBKEYJFrWVK9oQGV1bWtfk8N+gbHvlkAUFZ+cYDU3WBpVFQU5HK5B1+Nb3LXjiTqDNznmryJJxM4xcXFSBk4CPp6ndvzyVG2SSIymYzlYTtJS3vCsYxqx3GklYgE19QsGMD3ZmAcudCAIxca0E0SBNGZPaj+6QPETn0WoQrX16D7/RdotrX9XIO6GOVf/h/Wrl2LlBTXMgbtVVpaiilTb4NB735PJklYOL75ejMSEhI88nxE3i44ONht2SHur0FERJ2lW7du6NatG4xGo2NFm6f8v//3/5D19KOY+Oc/Q6ZQQqfT4fjx3zB48ADUnT+NXw/sw8j0iYiM6+Vyv/JTv7brnFatwk/ff4+X3lqOMWM4WNbVNBoN8r76FGN6SRAV4bpvYcGJU3jn029a/Z7qdDrU6XSounAeJ4/sw/1TroVJFIqXV2zGPx64CSm94qCrb8BRVT3+NPlmJCYmokePHl32Wr1RU+1Ib6JSV+H46VIUnr6A7du3IyoqCkeOHAEAbNq0CXv27IHZbHZUaCkrKwMA5OXlQaPRQCKRQCqVAgCUSqXft4tVKhVUKhV0Op0jUW3/eeXl5aFXr144WVSCw5EGREdGoLyLqjOUl6txprjY5VhlTR2qa7hSmbpWZyRw1Go19PU6t/uR1Z3YCeSv7VDM1LLm9oRjGVXPCOjEnNVqxSeffIJVq1bh4MGDqKyshEKhQL9+/XDttdfib3/7W0CXYSDqCi3NgvHVGRg1Bgu0FbWoOHMGBk09JBLXARatun3nDJp6nD9zBgUFBW5LHBkMBkgkErcxNZXkrKqqwm8nCpr8sD3z1euoqqpC3759W/XaiYiIiKh9xGKxxwf1LRYLzpWcQXVVJaxhtlJPKQP7wmwxQVNxAaqzZ1CtqQAiol3u195zNVWVOFdyBhaLhSvmBFBWVoaFr72KtEQLwkJc+wtVegtUakub3tOwsFCILA3QnC/G4PgwhEXG4MyZM7iyXyxSByZBXVWLc9oLGDp0KBQKRZe8RuqY3HU/IefdjbZvlq50OZednd3k/ebNm9foWFZWVrP38Qe5ubnIyclxe875Z/LKH//Onjq+U+OxNtgm1K5duwabN7j+H9ebrNh1LgjXTnuI/x+py3RmAsfdfmQG1YkOxUtt4+49IM8I2MScVqvFlClTsHXrVgC2muhRUVE4f/48SktLsX37djzyyCP8ICPqZM3NguEMjMZamokEURBgdV+SsqUkJz9siYiIiIh8W0VFBUwmIyIGXw1ZTLzLOf2p44D6oECRkbfIvG0irujfE6u/2Y1pk0ehR4wcRwrPYt4bnyJ71q0QiYCfDuTjmtGD0T0qEmWVNchetgEL505H3wQF9pboMCnjHkRHR/v9ajkAyMzMRHp6OrZt/Bijk6SQRYQ5fl4L505HTFQE1nz/M6aOH4IeMXIEiUQIF4tgNmibrAzUEVZzAwBAOmAsIuNc+/bBFedhOrMVFRUVHn9eopZwTImobQI2MXf33Xdj69atkMvlePnll3HPPfcgMjISRqMRBQUFWLlypdeXHyDyJ/wAb53mZiLVn9qH6h2rmOQkImoD7h1IRET+KEgqR0hUrOuxMJlA0ZA3USrkGNI3EbFyGcYM7YveifGIjrStpr1l/HBEhIeitLwC91x3JXonxuNAwRlkL9uACakpSI7vjjLLBQwbNixgJrIrlUqIxWKc3L8NacN7QCGPdPy8JqSmoMFQjzOnTmCb9oTLKtV3f9+NKr37SbOeECSNavx/vJ5lLImIfEVAJuY2bdqEr776CmKxGD/88ANGjRrlOCcWizF06FC8+uqrAkZI5H+a2keuqc1hqXnuEpnGipImzxFR29j3kgDg2E/CeS8JjUaD6upqx34Sg/skQKmQCxgxtRf3DiQiIiKi9tLp6mCxmCEdkN5oBRtXqRKRP7t0TJdjvG0TkIm5pUuXAgBmzZrlkpQjos7R0j5yLXH3h51/7NuHP0ui1mntXhKAbT+JrFkZyJ49pfMDIyIiIhKQUhGFrFkZUCqihA6FyKu4XcHGVarUBZoa01EoFKyYFEA6c0GESVsJ7aFvIBt+A0Jk3VveZodaJeAScw0NDdiyZQsA4N577xU4GqLA0Nw+cvbyi+7wD73n8GdJ1DaZmZnIyMiARqNx7CdxqlTt2Eviiv49ce6CBhvy9uPBm9MwcvBlQodMRETkVQoLCxEdHd3oOAcKfZtSIedkJIEY9A0oLS2F6I89xuzOlZbDoG9o4l5E5K9aGucJC5fiREE+P3MDQEcXRLTErK1E9a5PEN7vTwiRdW9ym53mxnipsYBLzOXn56OhoQFBQUEYMWIEvvzyS7z22muO8lQDBw7E9OnT8cQTT0AikTT5OAaDAQaDwfF9TU1Np8dO5OuaK7/oTmv2U6PW4c+SqG2USiWUSiXUarVjP4mk+BgAtr0kUgf2wokzKuw+fAKXX5bIMpZERER/sDbYBoUeffRRt+c5UEjUdpqqahw4eABLzx1w2ccMAKr0FpyoFKG6eiKQGN+ux3deCVlTV9/kObJx/plUaRqvUCHqDJeuWmpunMdYUYKKr16HWq3m520AaO+CiI66dJy3uTFeaizgEnMlJbZfkOjoaCxdutRRjkoul6Ourg779u3Dvn37sGbNGmzZsgURERFuH2fBggVNlrgiIs9qa0KPmsafJREFMpW6CsdPl6Lw9AVs374dUVFRjfYOlEgkkEqlAC4maImIqPWsJtvKneg/PwqJMsXlHAcKidqnuX3MGkqLYdm1A3V17V8p4bwSsnFi7uI5dVVtu5/Dnzj/TPILhY2FAselq5bs3I3zkHewVw8oLy/HunXrcNtttyE2NrbTqgdwzM+3dHpirm/fvh5/TJFIhJMnT7brvrW1tkZEfX09/vnPf+K6667DO++8gz59+qChoQEfffQRHnvsMfz888/45z//ibfeesvt4/zzn/902WOmpqYGSUlJbq8lIiIiIuHlrvsJOe9utH2zdKXLuUv3DgSArKwsZGdnd0FkRF3P2/pp5H/E0YkcKCTyMLf7mGmqBYqGKDCoVCrk5uYiMzNT6FDIRzRVPWDZsmUAWD2AbDo9MVdUVNSq60QiEaxWa6vOiUQit9e1hsViAQDodDr06NEDa9eudayKCw0NxcMPP4xjx45h0aJFeO+99/Dyyy87Zk07k0gkzZa6JCLyJ9xMmIj8QeZtE3FF/55Y/c1uTJs8Cj1i5DhSeNaxd2DfBAX2lugwKeMeREdHc7Uc+TVv66cRERGRZxQWFsJkMrms0AHYf28vlUqFnJwcZGRkCB1KQLq0hKcvuLR6gL1iQMzN8wHAq6sHmLSVMGsrYaouAwAYSn8D/tjb1FByDBa9Fg3qMwBsq/GCZd195n3xNp2emJs5c2aT5ywWC9atW4e6ujpYrVb06tULgwYNcmwQrdFocPz4cRQXFwMAZDIZpk6diqCgoHbH41ya8qGHHnJbqvKBBx7AokWLUF9fj/379yM9Pb3dz0dE5Mu4mTDRRdxfw/cpFXIM6ZuIWLkMY4b2Re/EeERH2tqCE1JTkBzfHWWWCxg2bBgUCoXA0RJ1Lm/rpxEREVHHuFulY1+hA7D/ThcVFxdDrW68P2JTk7I7qiOTvZsq4ekLLq0ecOn+b95Ie+gbVO/6xPG95oclF2//+J7LtRVfvY7I0VMQFBoO2fAbuixGf9HpibkPPvjA7XGTyYSbbroJdXV1uP766/Hf//4XQ4cOdXvt4cOH8Y9//APfffcd1Go1Nm3a1O54nAdZBgwY4Paa3r17O26Xlpa2+7mIiHxdazYT3rFjBwYNGtTovpyNR/7GeS8JIiJf5239NCIiIuoY51U6QaFSxwodcUxSl+/x2VTiB+BYQWtotVpotXWorayB3mRFQ9lJiIKCAXR81VJxcTFSBg6Cvr79+1K2Fid7+w77ysTw/mMQ3u9PqDuxExHH1uBP6RNQawR+3JKHyddMQI8eCtSpTmPv3gMwjHkMIdHxKP/83wjv9yehX4LP6fTEXFNef/11/PDDD7juuuvw9ddfN3vtsGHD8M033+D666/Ht99+i9dffx3PPPNMu563f//+jtsstULUPk01sNi48l/uNpBlA4uIiMj/CNVPIyIiIs8QRyciKExmu+2mL9/ZWkr8cKygZQcPHMWunT9fPPDTxQlV7lYtRaXdDfm4e1v12Gq1Gvp6ndsJ2PWn9qF6x6r2B36J1kz29taSju2l1WpR7pRQBQBjeREAW1IVwaEALq4iVCqVXrGFgvPKREl8PxhUJxAaLEKiMhY62GJOTk5EfHwcqizVOBwsgqV7guNvDbWdYIm5lStXQiQS4a9//Wur7zNnzhx8//33+PDDD9vd4YuLi0Pv3r1RVFSE3377ze01zvstJCYmtut5iHxdU8k3lUqF26fdAYO+vtE5iSQMa9euafSB0llL4UlYgdjAIiIi8ndC9dOIiAKNSqVCbm4uMjMzvWJQlshTmkv8ePtYgUqlgkqlgk6ng8FgAAAcOXIEAJCXlwez2YwGsxXlag10CIVMFgGZzPOJiRGpQ9F/QF+oT+cj/9BBDBk1BlpraJOrlqQDrmrzc7hL2horSjz1Elp8Ln9lS6rusX3zk2uFCuekqn2Se1ZWFrKzs7sqPPIigiXmTp8+DcCWKGst+7X2+7bXlClTsGjRInzwwQf417/+BalU6nJ+xYoVAGz70Y0cObJDz0Xki1qzrP3SBpb+7K+o+vE93HzzzV0RInmRQGpgUWBwHiQRi8VCh0OdjHsHErkSsp9G/sdeFkk2/Aaf2xeGqLOpVCrk5OQgIyODiblmsCRiy1pT9tBYaduqJz8/v8tW6PjiWEFubi5ycnLcnps3b57j9hcbtwIA0sZdhfTxYzweh0wmg0wmg1VzFuFiERKVCtSHRAJwv2qpqc9YdxPlWzt53vkzvC3nOsKeGLXHaCj9DTDbSrQ6fpcrzjqSo0Gy6E5JjHbEiNShiBYbHAlVaWwCLlxQO5KqkWLglx15yHr1HVx55ZX8+x/ABEvMRUZGwmAw4PDhw0hNTW3VfQ4dOgQAHf4PN3/+fOTm5uL8+fO444478Pbbb6N3795oaGjARx99hCVLbJsaPvbYYwgPD+/QcxH5otYsa7+0gWWsKGly9ZSnl8ITEXUm50ESdvT9n/PegeqqWpdznMlOgUjIfhr5H+eySEzMEVFbsSRi67Sl7OGMGTO4QqcZmZmZSE9Px7aNH2N0khSyiDAcKTyLeW98ioVzp8Nq0mPJqvUYMTYdsrgkyGQRQocMoPFEmJa2HmkN58/wtpzriEsTo5oflly87fS7rIUtOZo2rq5TEqMdIZPJECOPdCRUo3omIyxMAsCWVJWiAaHBIvTv37/VbW1vodPV4/z5siYnAZh0VQAurrxsy96HgUiwxNyYMWOwceNGZGVl4eqrr27xQ7S4uBhZWVkQiUQYM6Zj/+F69uyJVatW4e6778bXX3+NPn36IDo6GnV1dWhosGXhJ0+ejBdeeKFDz0Pk69qzrL0rl8ITERF1Js5kp0AkZD+NiLxbebkaZ4qLXY5V1tShukYvUETk73y5JGJXak3Zw3qN2rFK59ZbbxU6ZK+lVCohFotxcv82pA3vAYU8EtGRtuTbhNQUVGnUCBeLEBsjR1R866sLdLZLJ8I0t/WIN0+ez8zMREZGBvbs2YOcZx7Fn9InoNYIl99lTXEhfv/1CEaMTUf8ZQOFDtknmbSVMGsrYaouA9DyykRZbDzSxl2F06fOYO+eAxcfqIlJABVfvQ4Abdr7MBAJlpibP38+Nm3ahHPnzmHYsGF45JFHcP3112PgwIGQy+UAgKqqKhQUFODrr7/GsmXLUF1djaCgIDz99NMdfv7bbrsNBw4cwGuvvYatW7eirKwMYWFhGDVqFO69917MmjWL5auIiIiIiCigCN1PIyLvY22w7S++du0abN4gcjmnN1mx61wQrp32EBQKhRDhUQDwxZKIXak1ZQ9rwkSOVTqccBY4hJg835Eyl/YyqxqNBqHBIiQqY6FDKICLv8uS+nKc+yM5ymoNjbWmjLj20Deo3vWJ4/uWVybaSrZqtVoMuXxgk5MAIsy1jn0PJQkDAFEQqnau9njJU38hWGIuPT0dr732GubPn4/q6mq88soreOWVV5q83mq1AgBeffVVjBs3ziMxDBkyBB988EHLFxIREREREQUAb+inEZF3sf4xi146YCwi41xXJgVXnIfpzFZUVFQIEZrPsO+bBAA6nQ4GgwFHjhwBAOTl5UGj0aC6uhoni0pwONKAwX0SoFTI2/Qcl65oPFdaDoO+wWOvwR1/Lvt96b7T1TU1KDnbgLoa19KFTe1/R+RpMlkE0sZd5TXlM5vSWWUuqXVaU0ZcNvwGhPf7E+pO7ETEsTWtXpnY0iSAMN0Fx76Hkvh+MJz/vcnfhc7ap9CXCJaYA4C5c+di2LBheOaZZ3Dw4MFmrx01ahT++9//YtKkSV0UHREREfk7+yCJfYAEgMsgSa9evRwDJNGREVAqoto8SEJE5GvYT6P20Gq10Grrmtx3xKLXwlhZCgDIz893zIon3xEkjUJIVKzrsfqLZSz9OUnTUZfum+Rs3rx5Lt+/AiBrVoZjD9yWNLWisUpvwYlKEaqrJwKJ8e2IumX+XPbb+bUFBQVh6dJcHE20ICzEddVold4iUIQUaGQyWaftp9ZcacP63/fAWGM7XlewC4bS32D5Yy8xd/uKmetrmn2eQEzGOCdVLdrmJ0wUFxc3mfBXKBQdKt3r/POXxPeDQXVCsJWJTOAKnJgDbHu57d+/H/n5+di1axcKCwtRXV0NAJDL5RgwYADGjRuHAQMGCBwpERER+ZvWDpLY14q0ZZCEfItKXYXjp0tRePoCtm/fjqioqEYz2SUSCaRSKQBwQJn8Hvtp1FYHDxzFrp0/XzzQxL4jADBjxgxkZWUhOzu7i6KjruDPSZqOsu+bpNFosG3jxxidJMWpUjXmvfEpFs6djiv698S5CxpsyNuPB29Ow8jBl7X6sZta0dhQWgzLrh2oq9N5/PUEmoqKCphMRkQMvhqyGNckp/7UcUDd/CQW8m1KRRSyZmVAqYhClUb4FZKtmQjToD4DwJYsC5Z1b3LllOMxmyltWL3rY8ft2l++cLmfu33FZMOua/J5AjUZ45xUrdFqmryuuLgYKQMHQV/v/u92WLgUJwry252ca81qOuo6gifm7AYNGoRBgwYJHQYREREFkMzMTKSnpzsGSGQRYThSeNYxSBITFeEYIEnooYBSESV0yNRJctf9hJx3N9q+WbrS5dylM9kBcECZAgb7adRaI1KHov+Avk3uO9KjhwL1GjV+2ZGHrFffwa233ip0yH7DeaUaeSf7hB61Wo2T+7chbXgPJMXHAAAmpKYgdWAvnDijwu7DJ3D5ZYntqtBw6YrGIE21p8KnPwRJ5Y1XjYZ55x5XvlL20BcoFXLH5Mz8QmFjAdo2Eabiq9cRlXY35OPubfYxmyttmJZ+FSy1apSc/B19Bw9FWHQsdHU67Nzxs9t9xcz1NdAe/s5jrzeQfpfVajX09TrE3Dwf4pgkl3PGihJUfPU61Gp1h1bNkffwmsQcERERUVdTKpUQi8WOARKFPBLRkbYG/4TUFESEhzoGSHp3Ugkg8g6Zt03EFf17YvU3uzFt8ij0iJG7JGn7Jiiwt0SHSRn3IDo6misBiIgu0dK+I/HxcagJEyE0WIT+/fvz76gHOa9UI/JXziXYuNKjZZ1Z9pCE1ZqJMHWq045kmXTAVS0+Zsgfq+rclTbs378vrJpQ1JaexJCU3ojq2Q/nz5dh546foVB0h7myHhYrYDXWw6LXwqS27XXZ2jKX+fn5jY4VFl7MgAbi77I4JgmS+H4tXmffmsP+M3QuQepu9WSQ1PMTje2JU5FIhHKnVZwAYCwvcsTSlpKngYKJOaIA1lTdYncfikRERP5MqZBjSN9ExMplGDO0L3onxrskaZPju6PMcgHDhg2DQqEQOFoiIiKiriV02e/OLMHW0r7TZrMZDWYrytUa6BAKmSyiU/ZcCiRNjTt1dA+tQNCaiTBVlmocDhbB0j2hUxPZJwoKcfjQMds3Tiv3gJbLXJq1GkAkwowZM9w+dnKUyO1xuujSrTmcS5C6Wz3ZXJnR9q5MtCdOd2z/f9i1c4/tYCt+FyS9RwBwn7RrTflVf+AVibn169fj448/xt69e3HhwgUYDAYcOXIEgwcPdlzz9ddfo6ioCN26dWvyPywRtV5LdYuJiIiIKLCxn0ZETbHvcVSn1kBvsuLgwYMIDrbtcWRP0gBwJGq4N6vv8+ey363dd/qLjVsBAGnjrgq4FTye0lIypqN7aFHXShnYH0nRYsfKPWlsAi5cUDtKYAbVV+HYsQIYh9wCcfckWP5IwDiSMVYrotJnICQqDkHh3RD8x4quuhM7gfy1wr0wL+ac1B4zZgxWrVqFX3/9FR8sXtCoBGlEhBT16lLHexAcZkvg2lfTGSvOOiYdxMmiO/R3bUTqUESLDW5/F3r36YWi02dcrjcU2fbmdJe0a035VX8gaGLuwoULuPPOO7Fjxw4AgNVqBQCIRI0z4rW1tXjiiScgEolw1VVXoV+/lpdzElHTmqtbXH9qH6p3rBIoMiIiIu/nvJ8PBxrJ37CfRkQtuXSPo2eeecZx29eTNF1FqYhC1qwMn9nD2B/Lftvbc1OmTGl232mrSY8lq9ZjxNh0yOKSAmKvq85iMWgBq5V7aPkJqTQc4fJIx8q9qJ7JCAuTAAC0tVocPlRgu3D/Jpf7OSdj7OOPzskYg+pEF0TvW1qzwtC5BKm2VotdO5z2InR6D5x//lrYJh2kjavrUGJOJpMhponfhSv/lIrLe3d3m7Rzt08hREGo2rkasuE3tDseXyBYYs5oNOL666/H4cOHYbVaMX78eFxxxRX43//+5/b6O++8E08//TRKS0uxdu1a/P3vf+/iiIn8k7u6xfalw0Qd5a48BUtTkLdzHiSpqasXOhzyUs77+fjCwBNRa7GfRp7U3rJI1DRvKbln3+OoorQEx3/ZgadmToVRJHEkMq7o3xPaOr0jUeO80pZslAo5smdPETqMVvPmst/NTZhq6Zy9PTds2LAm952u0qgRLhYhNkaOqPi4Lntd/qy1e2iRcJw/w2s1rT9n19xqOnfJmOAAKF3orLCwENHR0S7HmttayDmpDdhWl9kT3O5WGKYM7I8RqVc0uxehprgQv/96BCPGpiP+soGef5F/aC6Bm5yciDDdBUfpVUl8PxjO/+4oXezPBEvMLV26FIcOHUJoaCjWr1+P66+/HgCa7PCJRCJMnz4dr7/+OrZt28YOHxGRF2tuJg9LU5C3cx4kYWIusPnaTHYiT2A/jTzJvu8IeY63lNyz73Ek0tciXCxC6oBEhEXGALAlMlIH9oK6qpb7s1K72BPQ9kFqQ+lvgLnBdttegq2yFIBtILu8vLzJCVOcTEWBoDMmwjh/hte24ZxdW5MxgcLaYNtS6NFHH23X/Z1XmtoT3O5WGEql4YiPj2t2L0JJfTnO/THpgPtmdj3BEnOfffYZRCIRnnzySUdnryXp6el4/fXX8euvv3ZydERE1BFNladgaQoi8iXOSVp1VVNdTiL/wn4akXfLzMxkyT3ye5cmoDU/LLl426kEGwDMmDEDs2fP7rLYiLyRP0yEMWkroT30jd+XL7SabJMMov/8KCTKFJdz3FoosAiWmDt+/DgAYPLkya2+T8+ePQEA5eXlnRITERF5FstTEBER+Rb204i8m1KphFgsZsk98lmt2ac3MzMTGRkZ2LNnD3KeeRR/Sp+AWiNcSrDVa9T4ZUcesl59B3369MGyZcu6+JUQkTutKXPpjllbGRDlC+3E0Yktbi3UnmSlN5URb+/vQqAQLDFXX28rDdWWZeQNDbaMskQi6ZSYiIiIiIgupVJX4fjpUhSevoDt27cjKirKZT8fjUYDiUQCqVQKwNa+Zakk8lXspxER+ZfycjXOFBe7HDtXWg6DvqHDj92est/uSksWFxdDrVajvLwc69atw2233YbY2FgAQGiwCInKWOgQCuBiCbaaMBFCg0Xo379/o32a3CkvL8eBAwdw+vRpx0SSwsJCAMDq1auhVCpx+tcCXBZpQHRkBIKCRI7XVqVRt+nnQhTIWlPmklrHnqwMiU6AqboMQBOlfSvOOvaXjZNFe83qyebLodqSdiKRCOWVNdCbrGgoOwkAMJYXAbC9PgTb/vbbSxv7U19bsMRcXFwcSkpKUFRUhOHDh7fqPvv37wcAJCQkdGJkREREREQX5a77CTnvbrR9s3Slyznn/XzssrKykJ2d3QWREXke+2lE1F7cm9W7WBtsEy3Wrl2DzRtELueq9BacqBShunoikBjf7ufwRNnv4uJipAwcBH29znHMefVbcpRr7DpdPc6fL0OdWgO9yYqDBw8iODgYALBp0ybs2bMHAGA2mxEcHIyyMttg9sKFC/H999+7jWHhwoWO20v+aOplzcpwvLb8wna9NCKv4LzqKkTWvdXnOoPzCiqTruXrA0FrVsVVfPW643ZTpX21sO0vmzaursnEnHetprMl7XZs/3/YtdP2dxs/feByjfPrmzFjBgD/6msLlphLS0vDJ598gg8//BBTpkxp8Xqj0Yi3334bIpEI48eP7/wAifyEfebZpewzDYiIyL8Z9A0oLS2FyOw6K9pTM6UDQeZtE3FF/55Y/c1uTJs8Cj1i5C77+fRNUGBviQ6TMu5BdHS038zgo8DEfhoRtZdzkoaEZ/2j7ScdMBaRca77ezeUFsOyaweKioohl0ldznV1G1GtVkNfr0PMzfMB2Aag7XuV153YCeSvdbn+REEhDh865vj+mWeecdxubrDWXVKuV1I8zpScx8S0kZCIjPj91yN4LvNODBsyiAnmAFddU4OSsw2oq3FNYLgbX/N2ziUiL02+NXeuMzivoKq60OlP5xNaU8Iz5ub5aFCfQcSxNW5L+2qKC/H7r0cwYmw64i8b2OTjeONehCNShyJabED+oYMYMmoMpLEJuHBB7Xh9kWI4yhZfeeWVftXXFiwx95e//AWffPIJNm7ciBdeeAH//ve/m7xWq9Xi/vvvR0FBAUQiEf7yl790YaREvsvdzDMib9BUYlihUCA5OdntOSJqO01VNQ4cPICl5w4gLKRzZkoHAqVCjiF9ExErl2HM0L7onRjvsp9Pcnx3lFkuYNiwYVAoFAJHS9Qx7KcR+QbnQWOzQYs5d06A2aD1yUFj6lxB0iiERMW6HBOVnQfQuavp2kock+RyWxLfDwbViUbXpQzsjxGpV6CitATHf9mBp2ZOhVEkwbw3PkX2rFsRF9MNFyprsOXnoxhzeS80mC1Y9Fkenn/gOogsDVi9aRtGjE2HLC4JOl09znz6JXqnpECkr8W5344iJbkHUgf26rLXTd7n7NmzWLo0F0cTLW77UNRxWq222fKFxuoyR2lGHUIhk0VAJpMJGLGwxDFJsDTomiztK6kvx7k/9pf1tZ+TTCZDjDwS4WIREpUKRPVMRliYrTx+cnIipGhwlC1OTU0VOFrPEiwxN2nSJNx7771YvXo1cnJysHHjRmRkZDjO79y5E4cOHcIvv/yCTz75BBUVFRCJRHjwwQcxevRoocIm8inOM8+cG7kAUH9qH6p3rBIoMgpUZq0GEIkcS9AvFRYuxYmCfCbniDxEp6uDxWKGdEB6kzOl6+o4eYOILmI/jcj7NTVo/O7vuzloTK3SmtV0nmgjqlQqqFQqAIBOp4PBYGi0T699nzdjRQmCpE2vUrOXYOvRQwGZTAaRvhbhYhFSByQiLDIGAHDL+OFIHdgLPx8uwNqNm6E6VgztH4v/jv28FSFBVoT/MXgdFR+H8+fLOvwa/UFTlZYAz0yebU2pvq6gUqmQm5uLzMzMZlfdVFRUwGQyImLw1ZDFuCan9aeOA+qDnR2q3zt44GiL5QvtpRkBIG3cVV630svTzLpql33kLHptk8lKPcQCRkqeIlhiDgCWL18Ok8mEzz77DAcOHMDBgwchEtkalY8++qjjOqvVCgC44447sHTpUkFiJfJl9tlmzowVJQJFQ4HMYtACVqvbZLGxogQVX72OHTt2YNCgQY3uy9V0RO3nbqZ0kKZaoGiIyNuxn0bk3Xxx0Li1A+LUtTq7jZibm4ucnBy35y7dp7fiq9ch6T0CgG0Q2qLXwlhx1jEQHSeLbvXAvPPkNARFAAXfQHbFtUBtmVf+/xBSS5WWPDF5tjWl+rqCSqVCTk4OMjIyGv0dcv4bZRcklTf+/xHmW6uRvFVL5QvFeo2jNKMsLskr9kTrbLrfdqPu8HcAXPeRA9wnK8n3CZqYE4vF+OSTTzBt2jS89tpr2LNnj6Nz52zkyJF4+umncddddwkQJREReZq7ZDFX0xEREXkH9tOIfIMvDRo3NyDuzwI1IWl/3VOmTEFGRgY0Gg22bfwYo5OkOFWqxrw3PsWfrxqC73/+1eV+hiJb0sw+CA1cHIhOG1fX5hUzQdIoBIdEAgCCZdGwGus69sL8UHOVluyTZ9Vqtd/3w53/RvkyrVYLrbYOtU5lIkVBwQCA+t/3wFD6GwznbSVi6wp2ISjEtvLKXTI8SBbdaWURWypfaNVYHaUZo+LjOiUGITRXwjNEFoPwQemQFu3A5SNSIekmh65Oh507fm6UrDQER2DTxm8FfCXkCYIm5uxuv/123H777aioqMDhw4cdy6djYmJwxRVXIDY2toVHICIiX9ea1XSB0CGgruE8SCIWB3YZiPJyNc4UF7scO1daDoO+QaCIfINSEYWsWRlQKpouuUTk69hPIyLqmEBOSNpfd2pqKtRqNU7u34a04T2QFG8rOznv3uuw4PFp2HMkH6+99zmGjBoDrTXUsWKmRw8FNMWFjoHo+MsGejxOe3lMmSwCdfpajz++L3E3eZZ8j61E5M8XDziViaze9bHLtbW/fOG47alkODWvuRKe9venHkDe7gMAgGHDhwJonKwMlsc7/nb5I+e/zRat/45LeEVizi4mJgaTJ08WOgwin9NUPfD8/HwBoiHqGHYIqCs4DxYEarLX2lAPAFi7dg02b2i8qfmJShGqqycCifGN70xQKuTInj0FAKCuCuyBHPJ/7KeRpxUWFiI6OrrRcZYuJwocsfJIpA7shSqN2rFqpv6P1W3JyYmIj4+DpL7cMRDd1Mqd8nI1EkIlmHPnBJgNWpy5ZHzEeYC3VuN6X5lM5kg81LnfYo3Ip4xIHYr+A/pCfTrfUSbSnvBOS78KERFS1J4vRsnJ39F38FBYQiMcK7K6Ihke6NpawlOnq8fhQ0cbPY7z3y5/5Pz6arSaFq72XV6VmCOitmupHjgREfk/g74BpaWlEJldZ5M1tYk7AFj/uFY6YCwi41wHQRtKi2HZtQN1dfxsaatALVlFRNQa1gbb54rzXoXOWLqcAl172nSBynmSWViIbZLZu7/vBmCbZGbnPMDLqVSdT6VSOSaJG0p/s5VH/KNUn6HkGEy6KgC2qjgAECzrjhBZ906JQ6VSAQB0Oh0MBgOOHDkCAMjLy4NGYxvsl0gkkEqlKC8v93gMQpDJZJDJZLBqzjZKePfv3xfx8XFQ5ZtQW3oSQ1J6oz4kEjt3/NymZDi1X1tLeJ4/XyZwxNSZmJgj8nHN1QOvP7UP1TtWCRQZkec1tQqUs6spkGmqqnHg4AEsPXfAMShh5zwo0ZQgaVTj/Wk01R6NMZAEaskqIqLWsJpsyYboPz8KiTLF5RxLl/sPlboKKnU1NLV1KDx9Adu3b8eZM2cAuB8QVyqV/MxEx9t03q66pgYlZxugUtvamarzKpyRitqddGxukpn+1HFAfbBjAVO75ObmIicnBwCg+WGJyznncokVX70OAIhKuxvycfd2ahyXmjdvXqNj1113HQDb3yiz2ezYZ02HUMhkEUxSdYHmVrcS+SPBEnMrV64EAPTs2bPVZVGqq6uxYcMGAMD999/fabER+SJ35f/sM5CIfJ1ZqwFEIsyYMcPtec6upkCm09XBYjFDOiCdgxJE1GHsp1FXEEcnsnS5n3Hes/aNz7bhzc/zLp5cutJx092AeFZWFrKzszs7xE7XmhU61dXVOFlUgsORBgzukwClQu64v6+26ZwTsYd+PYWaFSscP4fVq1djz549KCkpwYr/vYOfelgRFgKkxgfhk5XLIRWLOpx0dDvJLIxJFKFkZmYiPj4eOc88ij+lT0B4tMKlVF+EuRZ79x6AYcxjkCQMQHAnrJazx5GRkQGNRoNtGz/G6CQpTpWqMe+NT/Hnq4bg+59/dbn+u+++A+D6N+qLjVsBAGnjrvLrsoHegqtbG2Oy0r8Jlph74IEHIBLZZgA9/vjjWLhwIUJCmg/n7NmzeOCBBxAUFMQOHxFRALEYtIDV6nZlKGdXU0vsgyT2ARIALoMkvXr1cgyQREdGQKmIchkk6WpNlTA6V1qO2praRufss4w5KEFEnsB+GhG1hbs9a3VGK6YODEGtwYKiGhH+PusO1BqAeW98ioVzp+OK/j2hrdNjb4kOkzLuweDBg4V8CR7TlhU6rwDImpXh2K/Wmbe06ZyTrXbnSsth0Lu2UXPX/YScdzc6HVnnuLVw4UKXa0trgDGjh2Ly1cMcx5yTjs6D0EJx97pZSrT1lEol+vfvj9BgERKVsegWn+RSqi9MdwGHg0WwdE/o1Aka9pW4arUaJ/dvQ9rwHkiKjwEAzLv3Oix4fBqKVOVY/c1uTJs8CucrtY6/UVaTHktWrXfs8yXk7yMFNiYr/ZvgpSytVivefvtt7N27F1988QV69uzZqvsQEVHgcbcylKglrR0keeWPf5saJOkKLZUwyldbsbT8V5dz/lDaiIi8D/tpRNQa7soJRv1xrry0GOd37cDgZAXCIm0D4hNSU5A6sBfUVbUos1zAsGHDoFAohAjd45pboWNPSJ67oMGGvP148OY0jBx8mdAhu+Uu2WpXpbfgRKUI1dUTgcR4AEDmbRORMX4E9hzJx2vvfY7BV1yBWpMYP+3aj4lpIxEbI0fV+WKcKizEiLHpiL9sIEKcygI6Jx2dB6G7Wkuv258474kciGLlkUgd2AsR4aGIlcswZmhfVNbaJnBOSE1BlUaNcKd9vnxdcwlvb0iGBzquigtcgifm7r33XnzyySfYs2cPRowYgVWrVjnq+hIREbUW95+jpmRmZiI9Pd0xQCKLCMORwrOOQZKYqAjHAElCDwWUiqiWH7STtKaE0aX7aAhR2qitq/rs5y6dYe3ruIcO+TP204ioLbhnbfMrdOwJyRNnVNh9+AQuvyxR0AoNzWlu77aG0mJYdu1AXZ3OcUypkEOpkDuSGT179UJ9SCSwaz96p6QgPj4OqmAjVEW/IzZG7rV7dQXSnnXOeyJfyqSthPbQN5ANv8FxjH1t39ZcwlvIZDjZcFVc4BI8MffPf/4TM2bMwIwZM1BRUYGbbroJzz77LHJychwlVIiIiJrC/eeoJUqlEmKx2DFAopBHIjrSNiNwQmoKIsJDHQMkvf+Y+Su05koYXXquM0sbuSvlU3DiNA4c2N+mVX32c5fOsPZ1jUo3BcgeOhQY2E8jIgpsgZps9ZZSokIxaytRvesThPf7E/vaRESdSPDEHABcd9112L9/P+68807s2bMHL730En7++Wd8/PHHflPSgIiIOgf3nyPyvJZK+Visljat6gPcz7D2dfbSTU3tT+Gve+hQ4GA/jXxdcXFxk3tDcaUHEQWiwsJCREZGAmh6JZydp/razqX6TAJ2BZSKKGTNyhC0QgoRkZ1XJOYAIDk5GTt27MDcuXOxZMkSbN26Fampqfjss88wZgyX1BI11alsqSFFFCi4/xyR57SmlE9bVvUB/jnD2l66qan9Kfx1Dx0KLOynka8qLi5GysBB0Ne7HwXmSo+uxQFx/+KuqkJTSXDyDtYG29/CRx991HGsqZVwl2qur+1uTKqwsNDle+dSfVUXLh53LpsZIuveqlg6QqmQN7mXuPPfqCoNf5eJqPN5TWIOAMRiMf73v/8hLS0Ns2fPxtmzZzFx4kS8/PLLmDt3rtDhEQmmpU4lERE15rypuVgsFjocnxTopXyIyIb9NPJFarUa+nodqyp4ieYGxP2ZvyUkW6qqYOe8QoqEpdVqodXWofaCGnqTFbKRt0AkCkbtvvWIHDUFZkMtdEe3wlhRAgAw19e06nFbKnOZHNVy2WvnspmtScx15ipo579R+YXNX0tE5AlelZizu/vuuzFs2DBMmzYNBQUFePrpp7Fr1y7Mnz9f6NCIBNFcp7L+1D5U71glUGRERN7LeVPzSztpzoMkNXX1AkVIRORb2E8jX8SqCiQkf0tItqaqAuC6QoqEdfDAUeza+fPFA/s3OW7W7lvvuF3x1esAAEnvEQAAQ8kxmHRVAOBI2gXLujsSaM2Vuaw7sRPIX+vR18FV0ETkb7wyMQcAgwcPxt69e/Hwww/j888/x5dffomffvpJ6LCIBOWuU2lvIBERUes5D5IIkZgz6BtQWloK0R+DG3YsAURE3o79NCIiYlUF3zEidSj6D+gL9el85B86iCGjxkBrDcWPW/LQu08vFJ0+43K9ociWXNX8+J7jmD1pF5V2N+Tj7nW53j5O5VKWspvr74YncBU0Efkbr03MAUBERAQ+/fRTpKWl4emnn4ZGoxE6JCIiIqIO0VRV48DBA1h67gDCQpouAUS+yd9KVhG5w34aeUJX7y1ERBSIZDIZZDIZrJqzCBeLkKhUoD4kEgBw5Z9ScXnv7o6EnTQ2ARcuqPHjljxMvmYCIsy12Lv3AAxjHoMkYQCCm/lb7VyWsjO1tAraeTsDpVLZqbEQEXWEYIm5+++/HyKRCNHR0S1e++STT2L06NG48847cfbs2S6IjoiIiKhz6HR1sFjMkA5Ib7YEEPmm5kpWcaCAfAH7adRV2rq3UFOa2nMoPz+/I+EREfk9qTQc4fJIR8IuqmcywsIkAIDk5ESE6S7gcLAIlu4JHS4J7NjrrrIGepMVDWUnIQoKBmArm2nRa2GsLAVg+/utVCrb1V523s6gNfd3V8mEVUyIqCsIlphbsWJFm66/6qqrUFxc3DnBEBERkU9TqVRQqVTQ6XQwGAwAgCNHjgAA8vLy0KtXL5wsKsHhSAOiIyOgVERBqZALGDFLAAWitg4UEAmB/TTyJS3tOdTVmkoSAoBCoWCJNSIKWI32uvvpA8dN57KZADBjxgxkZWUhOzu7U2NqqpIJq5gQUVfw6lKWRERERK2Rm5uLnJwct+fmzZvnuP3KH/9mzcpoclUTEdH/Z+/O46Oqz/7/vyf7MiEJSUgCBhBIQASRqFVBllK9Fatota3W6q22Re56e3+/d21tq13AbrT1rtbf3da1Qq17oSpaVxTD4ldBkU2BAAIJJJAMSSb7ZDu/P4YZZmBmss3Mmcm8no/HPJg5y5xPOHPOzOdc53NdAKJDoJpDbZ9/JPu6pwKu729UncPhUHJyss95/gJsvQUJU1LTtHvXToJzAGJSoFp38y6eoxEjctVWb9OH68q0+L6HdMEFF2jJkiUhzTThL5MJWUwAhAOBOQAAEPUWLVqkWbNmac2qZ3ReUZqs6SnatueQ7nzgOd3/veuVk5mul8s+1q1XzNTIEbnU/wIAYAjxVXOo81il12vPmnbdzfWSxaIbb7zR9xta4iTD94gJfwG2QEHCzmOVOvbqH2Sz2QjMwWfqPIn0eQgfqzVdMy+6QFZrupr6USbWdR5NLb5QXfajkiRHVbkzDWXtAefryh3qtB9VR7ehWlu9WpUkqzU9YK270aNHqaAgX40pFiXFO0euffrpp7r33ntVXFysM844I6TpiU/OZEIWEwDhQGAOAABEvcLCQiUmJmrfx2s08+wRys3KUHZGuiRpTulEpacm6f2tuzVl/CiNHVVgcmsBAIgt4aotFIhnTbseR7NkGAFH2g00wOYrSIihrT81ZP2lzpNIn4fwsVqtmjX7QklS0ynzTgTtuk4aAOw6j3Y116ll65uSpPq3/+K1jCstZbOkf6x6R5I086IL3NsLxOhwbvC73/2ue5rfGyjkDBR2N9e5b8RYsWKFu6zB008/rY0bN6q5uVn7P92l8RkOTT59pOnlDADAJaoCc62trfroo48kSbNnzw76+1922WV6803nF8uyZct0yy23BH0bQCAULgcAYGiotjWo2mZXfVOL9uyv0dq1a3Xw4EFJzrqH9fXO25OTk5OVlpYWkovQQLiEup+G6BeJtYWkwCPtAgXYfPXPQt1n8wz+RJvaWpsOnlSLsq6xRfbGdkmBA1sDnRdO/akh6y91nkT6PEQGz6BdQ43vZdJKZiguNUPpO1bo/FlzlJqdq5oamzstZWJ7vfZ+uk3TZ8ySNb9IVmt6n7ZtdDlHkWb/23cVl5SmY6/+wX2ThK/0xM1bXpd9w7Pu10uXLnU/v//++72W/cuTlDMAEFmiKjC3f/9+zZ07V3Fxcerq6grqez/zzDPuoBxghkgrXA4AAAbukX++p3sfW3ViwsNPup961j10CddFaCAUQtlPw9DQ39pCV111ldf6kXIDY68pMEPIM/gTLYyONknSypUr9K+XvUeHtXcZ2nA4Tpd89Vvq6enxG9gKFPTqT0As0pycOk8ifR6iR3xaphKG5Skp3qJRhXkaVlCklBRnXc7Ro0fJqDd0ONGivJwsZRbk9/v9E7NHuY8H100SJ6cnliTr2fOVOuF8texer/QdK3TeeaVq6rDovQ0fa+7Mc5SXk6XGulrt/XSbbv/6v2nWecVeNwmQPhaAmaIqMOdiGEZQ36++vl7f+973Qp6zGAhksIXLAQBA5Fh0zVwtmD1dB6pr9fTr7+ur887Vkbpmd93Ds4pPU3NLuzZVtuqLC27Q5MmTzW4yMGjB7qdh6OhPbaHi4mKvIEsk3cDYlxSYweYKSrquVezcuVNNTScnn4tMxvEaamklM04ZHRZ/7Ii6Dr6jY8eOKTs724zmATCZK22mxWLRkSNHA6Y77rA5M090HquULHFq2/P/ZD17vpILJshRvVtJ8RYVnT5OrUqSNnyssRMnqqAgX0fKt+twuUVb/t+72rVpjdf2SR8LwExRGZgLtrvuuks1NTV6+umndckll5jdHMS4vhQuB9A//m66yM3N9VsfBNGvMDdTixcuUGFuphpb2sK+fUd7h6qqqmQ5flHKJdbvzPSVzupwVa0c7R1+1ohOhblZKszNUnpqkvKyrLpw6jjVNTlrXswpnajSSWNka2jS0Z4aTZs2Tbm5uSa3GAAi00BuYOxqrlOX/agkyVFV7qxhV3vA+bpyh7paGySd6GfFW4crwTq8z20KV5/NV1DSNVpvdKbF32oRx+fosDZnGss9e/YoI8MZpPX8zc7vdMBczc3NqvUIlEnyOo922o+qo9tQra1erUpSa2v/+1uutJnr1v6/Pqc7PvbqH2Sddqmat76p1Ann93ruDnSDAOljAZgp5gNza9eu1RNPPKFrrrlGF198sdnNAQAEUW/phlJS07R71046/UNUYW6Wu4ZAuANz9Q12bf5ksx4+vFkpCd4XzmL1zsxA6awa2nu0u84iu32uNKog/I2LAJFSJwcAIlV/gmGedYfq3/6L1zzPi7zHXv2DJClz5jeUddE3g9ncoPAMSkpy11vqsB2Udq40uXWDY3Q4g43f/e533dM8f7O7fqf74msUoeQdzAvV92p1dbWqq6slOetrOhwObdu2TdKJGrJ2u137DlRqa4ZDk08fqcLcrKBtHwgXZ23Qjc4XHoEy6cR5tFnSP1a9I0madvbUAW+rL+mOW6r3a9OmzXJceLsSsgvUvLV/5YhIHwsg0oQ8MPfkkyfqafz7v/+7z+l9dfjw4aC0yaWjo0OLFi1SSkrKKUVBAQDRL1C6oc5jlTr26h+0bt06nXHGGaesy126GIzW1hb19HQrrWQWd2YeF+hu1Y6qCvVsWKeWFvPTlJklmuvkIDpFcj8NGCzr2fPV092p9B0rdP6sOUrNzlVNjc19kTe9u8l9gTd5ZIlkiVPD+qdlPXu+2U2XdCL44wo49TjapOPfoz2tdhmdDq+RKlZruqzW6LjA3NzcrObmFjXV2NTeZch6zpWyWOLV9NFLSj/rMsWlZqi7tU6t29/Rww8/rORkZ92qV155RRs3blRdXZ1+vnixuj3qWboCeolJyXrxnytVWFio2trakHyvPvLII7r33nt9zju5huzvJS1euMB9oxgQTaaXTlV2osMdKEvLG+l1Hk1sr9feT7dp+oxZsuYXyWKxHD8Xpaupvn/b6ku644Yeu7bGW9QzfCQBNQBDQsgDc7fccossFossFotXh8813UxLly7Vrl279Itf/EJjxowxtS2IHZFSuByIJb7usGY0HcKBOzNP5fP/pN5uUmuA2BXJ/TTEBldtIas1PejvnWAdroRheUqKt2hUYZ6GFRQpJcUZ4Bk9epRSWmvcF3iTCybIcWSv7BueVeqE84PeloE4OfjjOerP10iVmRddoFmzLwxrGwfKOQrHI2Xdx6+4n7Zse8Nr2aVLl7qfL1mypNf37uxw6IorrpAk3XbbbX6XG8xoukWLFmnBggWqr6/XmlXP6LyiNH1eZfOqIXu4pl4vl32sW6+YqXMmj+/X+wORwmq1Kicrwx0oyzxttNd51Kg3dDjRorycLGUW5EuS8vNHSJLMrIIZyu8WAAimsKSyDFQE3KwC4bt379bSpUs1btw43XXXXf1e3+FwyOFwuF83NjYGs3kYoiKpcDkQ6/oyms5msxGYAxA0nnUPgUgQif00xA5XbaFI1tVcp+Ytr8t69vxT6hgFmjdYruDPxo0bde9d39X5s+aoqVN+R6pE0wXoQCnrZs66QOnpaWo+VquKXdt1w5VfVJp1mJY8+rKWLLxK+TnDVL6/Uv947T2NmzxVPUnpWr/uA827eI4yEqUP15Vp8X0P6Qtf+IJqa2v16KOP+mzDYEapFxYWqrCwUDabTfs+XqOZZ49QUUGOpBM1ZHcfrNb7W3dryvhRpLEEBqm1tU1HjhxVk0e9O0tcvCRnrbue9mZ1HjvkHkWcb82O+O8WAJDCEJjbv39/wPlvvfWWiouL+/Reu3fv1mWXXRaMZmnRokVyOBx64IEHlJKS0u/1ly5d6jd9AeDPQAqXAwgtX6PpXPyNZCXNZeTwvOM5MTHR7OYAAXnWPQTMFqn9NGDPnj3Kzs52vzYzs0h3c517JN3JwbdA8wbLFfypr693j/prVZIk/yNVokWglHXFxeNUUJCvowf2qvHgDs2YmK+EtGGSpHNL8jVl3EgNT+rQ22ssOnPiWLUlZGj9ug80evQopalDSfEWFRcXq7S0VJs3bx5Q+6j5CkSW3bv2aOuWHScmeNS786wZ6hpFPPOiFgJzAKJCyANzvaWIHDlyZJ/TSDY3NwejSXriiSdUVlam+fPna8GCBQN6j7vvvtsrf3hjY6OKiooCrAGc0J/C5QDCjzSX0cPzjmf2B6JFta1B1Ta76ptatGd/jdauXauDBw9KksrKylRf7yzMkZycrLS0NPcFWiCYIrGfhthmdDizinz3u981uSWh4y/I6HA43LXUPO3ZsyfUTYpIRkebJGnlyhVqdpbW01//+oRy0yxqaO85ZfnW1ja1tDpH03zyibOO77Zt2ySd+F51fadKUm1trd9tU/MViAyulJQlE8dreulZPkfZzrt4jkaMyFV9xR73KOKC8ZPMbjoA9ElYUllGktraWt11111KSkrSgw8+OOD3SU5O9vnDGQAQ/UhzCSCUHvnne7r3sVUnJjz8pPup541fLosXL+5TbR0AiGZGlzMCk/1v31VcUpqOvfoH5VzxfXXZjwYls4jrIq/FYlGtR0o0SeqsPSDJmRatq7XBOS2IN072dtOXLHGScWrASZJGZ8ZezUej2/lZSCuZIcWlS7tel/WsS5SZl6P2zz+TbJ94Le85oubkUiW+vlcD1Z8D4J9n/bam+lBvyzvdsa9RtqNHj1JBQb6S22rdo4it1tiu5w0gesRcYO6ee+5RXV2dfvzjH/c5NQsAIDYFSnMJSJKjvUNVVVWyHL+A5GKz2UxqEaLBomvmasHs6TpQXaunX39fX513ro7UNevOB57T/d+7XmcVn6bmlnZtqmzVFxfcoMmTJ5vdZAAIm8TsUYpLcV5YPfkGqcFwXeRdt/b/acP6jc6JHinRJO+0aMde/cOAt3Vy/blAN325ShrkXPF9xaUOU2v5+0ormaH4tEy17F4v7Vw54HZEu7i0TMUfvwAfb81WQmae+7PhaeKkYo3OSdNnmzdqXFa8EuOlujZDHxzuUWmBRYlxFu2zW3Tb//2RioqKdPToUUn9H03nDzVkESs8g2VNJrcFAKKdaYE5V4qeYcOGhXW7rlQQv/3tb/Xb3/7W73K33nqrbr31Vo0ZM0YHDhwIU+sAAEC0qG+wa/Mnm/Xw4c1KSfC+m91XmiXApTA3S4W5WUpPTVJellUXTh2nuiaHJGlO6USVThojW0OTjvbUaNq0aers7NSSJUuod4OwMKufBoTL9NKpyk50uFOipeWNVE2NTe+uLtN5XyhVSk+rduzYpc4zr5TFEq+mj15S296NclSVy3FktySpZdcGxSU4a9s6Kneop71ZHTZnSuLOY5Xqbmv0WX8uUEkDV8CuZeubyjh7vpILJshRvdu9XDhHqoSb5982kHkjRuSqyXFMqYkWjTtnpjLyR+to7TF98MLr6ho+Xps/2ytJ+s1vfuO1frBG01FDFgAA9JdpgbnMzP7fSTRx4sRei5QDAIChqbq6WtXV1WptbZXD4QxieNYPGTNmjPYdqNTWDIeyM9JVmJupwtyskLWntbVFPT3dSiuZpYx877SmvtIsAQNFvRuEE/00RDPPkWr+WK1W5WRluFOiZZ42WikpzjIVmzZuPrHgx6+4n9o3POP1Hk0f/sP93HOUneQcaWeddmmf2ugZtOvNUB6pcnLKuoHMc/2fxKVlKiEzT/FtzpukJp01VWNGF+qzD9fpv2/+is4oGa9tew7pzgee05KFVykjLVlbDrXorAvmymq1BhxNFxcXp5deekmLFi1SYmJiEP8HAABArImqVJYJCQl9LkDuz3vvvRdwvsXivON92bJluuWWWwa1LQBAYH25eAK4PPLII7r33nt9zvO84/n3x/9dvHBBWO5edl0A8prmI80SAAxVweinIXY1NzerublFTR513yxx8ZJ813yLtw73G9Dqbq5zj1QbiCsXXCaj6ah7NF2zkaR3V5dp5qwLlJ6epqYjFarct1fjJk9VT1K61q/7QPMunqMRI3LVUr1fmzZtluPC25WQXaDmrW/22sb+BOYwMGlpqUqPy1JqokWlJaM047zJys5wjr6rsjXo0RfLnAuu/JfXev5G0z366KNasGABtaYBEwUaSQsA0SKqAnMAgKFlsBdPzLRz506f03Nzc+moh8iiRYs0a9YsrVn1jM4rSpM1PcV9x/P937teOZnpernsY916xUyNHJFLnY8oVFtr08GKCq9ph6tq5Wjv8LMGgKFq3759Wrp0qd566y3V1NRo+PDhmjNnjn74wx9q+vTpQd/e5s2b9cEHH+jDDz/Uhx9+qPLychmGoZtvvlnLly8P+vZwwiebt2vD+g9OTPCo++ar5lvmzG8o66JvhqQtObnDZcS3ukfTtR2vb1ZcPE4FBfmq3tmlpqp9OnPiWLUlZGj9ug80evQoFRTkq6HHrq3xFvUMH8kNOlHimnnn6NILz3TXex2Rk+X123LcyFx3vdfs7GzV1tbq0UcfNbvZQMwLNJIWAKIFgTkAwKANNCVPNOpurpcsFt14440+56ekpmn3rp0E50KgsLBQiYmJ2vfxGs08e4RyszLcdzzPKZ2o9NQkvb91t6aMH6WxowpMbi36w+hokyStXLlC/3r51Hp9u+ssstvnSkN4vxbmZmrxwgUElAFJ69at0+WXX67m5mZJznp31dXVeu6557Ry5Uo99dRT+vrXvx7Ubc6bN092uz2o74m+mV46VcUl42Tbv/OUkWrzLp6j9O4m90i05JElio+w35qtrW06cuSo3xF/J9efi0tznue7W+1yHNmrLrszdaKjqlzq7vBar/PYIXV0G6q11SvOmi2rlYBfX3mOqGlp9538My8rQ2MLc9z1XseOKvD6bTm6YLi73mtubq42b97s830AAAD6i8AcAGDQIiklz0DSY/YnsNjjaJYMQzlXfF+JOUVe8zqPVerYq3+QzWYjMAf0g3H8QmRayYxT6vV1VFWoZ8M6tbS0mtG0sCnMzdKS265Wta1Bm3cdVH1Ti/bsr9HatWt18KDzgq6r3o0kd82bwsJC6s5hSLHb7br22mvV3Nys6dOn6/nnn1dxcbEOHz6sW2+9VW+//bZuvvlmnXfeeTr99NODtt2kpCSde+65uuCCC3TBBRfo/vvv5yJ8mFitVlmtVhn1h04ZqTZ69CiltNa4R6IlF0xQV3OdGtY/HdRU6J5BnKb6/q27e9cebd2y48QEPyP+JO/6c63l76vFI91l/dt/8bles6R/rHpHMy9qYYRIP3iOqGmxmdwYAACAk0RVYO7AgQP61re+JYvFonfeeSck2zAMIyTvCwAIj0DpMf0F7QYSWEzMKVJywYSgtBmAk896ffWxNYLlkX++p3sfW3ViwsNPup/6qnezePFiLVmyJAwtA/wLZj/tT3/6k2pra5WSkqIXX3zRXbtu1KhReuGFF1RcXCybzaalS5cGNaXcoUOHlJSU5H792GOPBe29EVyu321JIyd5jTbraW9WZ+0B5+vKHeq0H3WPNmtVkqzWdL8jzjyDOL7HVvk3cVKxppee5XPEn6s2XZutSjt27FLnmVcqPsUZdEyw5ij7ktvVfmi70g6s05TppeqOT/KqW1dfsUd7P92m6TNmqWD8pAH9f+FUnqPUG1vafC5T29DkdZNMZmamtm3bJsl5o8yYMWO070CltmY4lJ2RrsLcTBXmZoXxrwAAANEsqgJzLS0teu+992SxWHpfGDBRRUWFbLZTb8vzV5MKiAVdzXUBL550tTZIco46kyRZ4tS25//5vBt6IKPipPDVtKP+XHBVV1frkUce0aJFi5SYmGh2c4CQWnTNXC2YPV0HqmvdNW+O1DW7692cVXyamlva3TVvJk+ebHaTgaD2055//nlJ0pVXXukOyrlkZWXppptu0gMPPKCVK1fqoYceUnx8/KC3KckrKIfo4DnizHO0mXRixJlrtJkkzbzogn6POPMcSedv3ogRuX5H/DU3NWvDOo/6eR+/4n5q3/CM+3mbpLL3N2va2VMlyV23LrmtVocTLcrLySKNZRC5RqlL8huY++e7H+vRF8ucLzxukpG8b5T5/fF/Fy9c4H5PAACA3kRVYA6IBhUVFZo46Qy1tw3tlFuIXuGuB+faXk9Hm5o2vSTJ/8UTyZniR5Ks0y5V89Y3fQbRwhVg683J/5fUnwuN6upq3XvvvVqwYMEp/3d9ueMZiCaFuVkqzM1SemqSu+ZNXZNDkrPeTemkMbI1NHnVvAGGioaGBm3fvl2SNHfuXJ/LzJs3Tw888IDq6uq0Y8cOTZs2LYwtRCRJK5mhuNQMpe9YofNnzVFqdq5qamzu2nSJ7fXu0WbW/CKfwbXeeI6k6888l0Cj6XyNiovLyNXWLdv73U4Ej+u35dVzS3XphWe6b5IZkZOlbXsOuW+UyclM18tlH+vWK2Zq5IhcasQCAIB+iarAXF1dnSQF7a5IYDACjYprb2v1WX+q7fOPZF/3VLiaCPg02HpwXc116j5p9NvJheo9C9x3tzXKvuFZ5X3tXik+we/Fk/TuJm3atFmOC29X8sgSdbc1qtmj7kYkOvn/kvpz4deXO56BocxzRCm15mCWYPXTdu/e7X5eUlLicxnP6bt27YqowJzD4ZDD4XC/bmxsNLE10c1zpFqXn/sd49MylTAsT0nxFo0qzNOwgiKlpCRLco44M+oN92izzIL8MLb+hLS0VBUU5Putn3fyqLi2hFRT2hkramttOlhR4TXtcFWtHO0d7teevy1TkxPdN8mMHVWg7AxncHdO6USlpybp/a27NWX8KI0dVXDKthztHaqqqpKlu8Nruq9rCAAAIPZEVWDu8cedIypGjRplcksQ6/oyKs5X/Sl3ij4gSAaa0rEv7+cvaNe85XXZNzzrfu2vUL3kXeC+t4snKa012hpvUc/wkUoumCDHkb29tre71d6v9JjdbY3u130NLHqm1OxP/bl463C//5dcSAcQLJ4jSjmfwCzB6qcdOXLE/bygwHmh+7bbbtOzzz6rm266SX/5y1+8PudHjx4d1PaCbenSpbr33nvNbsaQ4BqN1tzcrNq6RrV3Geo4uk+SAtaRa23lJh2cyuhwfi5Wrlyhf73snXK3ob1Hu+ssstvnSj4CbANR32DX5k826+HDm5WScOr2AAAAQh6Ye/LJJ3tfKIDOzk5VVVVp1apV2rx5sywWi6699togtQ4YGJvNxqg4RIRgp3Tsy2g669nzlTrhfLXsXu8e/dbUKa+UPC3V+92j3xKyC0I28q0vtUWkE+kxk8dO93p98nr+AouulJr9GWEY6P8y0IV0gnaAb325yx1A30ViP62lpcX9PDU1VceOHdNjjz0mSXrooYf0q1/9SsOGDXMv09zcPKjtBdvdd9/tVXuqsbFRRUVFAdZAbz7ZvF0b1m90vnhvmdc8X3XkXDXazBaoNl0o1kNgxvGb8NJKZigj3ztzRUdVhXo2rFNLS/BKUbS2tqinp1tpJbNO2V77559Jtk+Cti0AABCdQh6Yu+WWW4JSBFySDMPQ1KlT9fOf/zwo7wcMFqPiEEs8R9MlF0yQo3q3e/Rbq5IknUjJ09Bjd49+i0vpvVB9a2ubmvzcDd22d6M6G513xLfs2uAcGXd8JFyCNUepZ8xS2oF1mjK9VMnDstTa0qr16z7Q2NPH6MD+g17bcRwI3AkOd2DRl1gN2rn+tquvvlo9Pc47iVtbW+VwOLRt2zZJUllZmcaMGaN9Byq1NcOh7Ix0FeZmqjA3y8SWI9TCfZd7JPKspQgESzT003JycnTTTTdp5cqVuvHGGzV8+HB1dXUFdRvBlJycrOTkZLObMaRML52q7ESHuz5bWt7IgHXkWlvbIqJGW1/qzwVzPfRNXFqmEjLzvKfV28O7vT70jQAAwNAXtlSWhmEMav3x48frhhtu0I9+9COlpaUFqVUAMLT1tx5cXJr/i759GU3X2tqmI0eOegXZLHHx7u35Sze0e9cebd2yw/kmJ90Nbd/wjPt504f/8DmvTVLZ+5slnbhT+gvnl2rK2OF9upDjiE/XK6veCBhY7G61y3Fkb1D+LwcqnCnrwh0EdP1t1dXVevTRR30u4zkK4ffH/128cIG7DkioUCPEXOG+yz0Seda7AYItkvpp6eknRgm1tTl/Izz55JNeo/tc0yVnEANDm9VqVU5Whrs+W+ZpowPWkWtubnaPOGuqN7nxfjAqLnp53ihDbWMAADAYYQvMvfXWWyouLu73evHx8crOzvbqpAEA+mag9eAGyivAJnkF2XylGzrvC6WaedEFKpk4XkXZiT6DaDNnXaCeJpsq9+3VuMlTlZKd5x4VF+hO6bS0VKX28UJOW0JGr3+bZ9pMKfT/l/0V7ECaWXWrrrnmGi1atEj19fVas+oZnVeUps+rbLrzged0//euV05mul4u+1i3XjFTI0fkhnwEETVCIke473KPRNW2BlXb7KpvatGe/TVau3atDh503hBQVlam+nrnVejk5GSlpaUpLi5OL7300pAcZYvgiaR+mquunOSsNzdlypRTlqmurnY/z8/PD9q2MTR4jjhrMrkt/jAqLnp53ihDYA4AAAxG2AJzI0eO1JgxY8K1OQAYcrpOGvnW097sTvfoqNyhruPpHd3pVC1x6uloU97Xf6H2im2n1IObOesCpaenqc1WpR07dqnzzCsVn5Lhfr+BjACbOKlY00vPkm3/TneQrdlI8ptuyGpNd9/t3lNX6TOIVlw8TkZ9kpqq9unMiWOVedoEHTlyVOvXfeDzTukjR44O+P840Ii/BGuOsi+5Xe2HtrtTZ3bHJ2n9ug8C/l+27d0oR1W5uhprJUkrVqxwp7nydSG9trZ2QG0fKikw8/LyVFpaKpvNpn0fr9HMs0eoqCBHkjSndKLSU5P0/tbdmjJ+lMaGIXUhNUIQSR7553u697FVJyY8fGIUkeeIUpfbbrtNjz76aNgD7IgukdRPmzhxovt5eXm5Lr744lOWKS8vdz+fNGlSWNoFAAAAAMEUtsAcAMQ6zxptA+E5+s1ztJbkPWLr2Kt/kCRZp12q5q1vKn3yXCUMyzulHlxzU7M2rPvgxJt8/IrP93O9Z6ARYK6UPCNG5MpqtcqoP+QOsrlGo/kKokWaQCP+PFNqulJnutJmBvq/9FxPkpYuXep+7utC+qWXOv+fXUE7V8BOUswH7cxEjRBEgkXXzNWC2dN1oLpWT7/+vr4671wdqWt2jyg9q/g0Nbe0a1Nlq7644AZ1dXX5TQ0LRKKsrCxNnTpV27dvV1lZmW6//fZTllmzZo0kafjw4T5H1AEAAABApCMwBwBh4lmjrT9cAb3U4gvV093pHvmWmp3rVTMtvbtJmzZtluPC25U8skTdbY1q9ki9eLJAo9v6Mpqu89ghd724fGt2xKTk8azb0dfaIq51SiaODzjib8SIXNVX7HGP+ovLyNXWLdv79H/ZfKxWFbu268q55yo5LV1/fL5Ms6eN19qt+7za8uabzn0WCUG7QOv4C+b1Zd7VV1+tnh5nGsjW1lY5HA5t27bN62+z2+3ad6BSWzMc6uomZSQgOVNoFeZmKT01SXlZVl04dZzqmhySnCNKSyeNka2hSUd7ajRt2jRVVFSY3GKg/6677jpt375dq1atUmVlpYqKitzz7Ha7nnrqKUnO1Mfx8fF+38diOZF+eP/+/Ro7dmzI2ozwGshvPWCg/NUaPlxVK0d7h5+1AAAAAgt5YG7//v2SpFGjRoV6U0BIVFRUyGazeU3buXOnSa1BLPIM6HmOfBtWUORVMy2ltUZb4y3qGT5SyQUT5DiyN+D7pqWlqqAg3+fotr6OpnPVi5t5UUsEBeb81xbxdyHn5Fof/kb8FRTkK7mt1qM2XaqkwP+XxcXjVFCQryPl29V4cIeaD27RkeN9+PSWA/rKpAQ1OXp0oNGiHy38mpoc0p0PPKd/u+BMvfXBp17tDxS0u+222wb8fyadOK/5C5RJ3uk2A43A621edXW131E8J/9tv5d021dmD+pvAwCcKlL7aXfccYcefPBB1dbW6itf+Yqee+45TZgwQVVVVfrWt76lmpoapaSk6J577gnqdpubm9Xe3u5+3dnZKUlyOBxefYGMjAx3SmqYIxrqyGFo6K3W8O46i+z2uVIY0qsDAIChJeSBuUipVwAMREVFhSZOOkPtba1mNwVD3GDTXAZbb7XiTh45VjA++DVeAt0NPdA7pc28kGMcv8s2rWSGFJcu7XpduaX/pvy8HNVWVejIhnWaPDpXKRnOemp3fvNSLbpmjjtd3YicLG3bc0h3PvCcliy8ShlpydpyqEVnXTBXVqtVR486a+sNdDTdjTfe6HN6KIKA11xzjRYtWqT6+nqtWfWMzitK0+dVNq90fIdr6vVy2ce69YqZOq0g7/hIoUw1trQNatvAUFXb0KTNuw6qvqlFe/bXaO3atTp40Fkn1Nd5obCwkPS1MS5S+2mZmZlasWKFLr/8cn388ccqLi5WZmamGhsbZRiGEhMTtXz5cp1++ulB3e4dd9yhv/3tb6dMf+655/Tcc8+5Xy9btky33HJLULcNIDIFqjXcUVWhng3r1NLCtQIAANB/pLIEArDZbGpva1XOFd9XYs6JNDptn38k+7qnTGwZQs0zUJZgHT6gef0x0DSXLq2tbWqqa1R7l6GOo87UiJ21ByQ5U0922o+6005a0obpvC+UympN9/t+gUaA+Ro5ZrX6r7UViiBapNwp7fm39VVcWqbij/9fxluzlZCZp7h6+ynL5WVlaGxhjjtd3dhRBcrOcG6nytagR18scy648l9e6w00BeZTTz2lgoICv4GyYNatysvLU2lpqWw2m/Z9vEYzzx6hogJnQNKVjm/3wWq9v3W3powfpbGjCnR2ifNiCIE5wLd/vvvxifOCJD38pPupr/PC4sWLtWTJkjC0DOi/2bNna+vWrfr1r3+tt99+WzU1NcrPz9fs2bP1ox/9SKWlpWY3EUAM8Vlr2MfvdwAAgL4iMAf0QWJOkZILJrhfdx6rNLE1CAev9JEnBd/6Mi9p5CR12Z0jmBxV5c6abB6Bsq7WBkknPkvdbY2Dau/uXXu0dcsO54v3lnnNc6WedKWdlHQ8mOQ/mBZMkRJEC4WTU2CGyzXzztGlF57pczRdf1NguoJ2NTU1Sk1NVWdnl6zpKRoxfJgk6lYBka4wN1OLFy7Q1XNLteiauTpQXes+Nxypa3YH2MeNzHUH17Ozsxkth4g3fvx4PfHEEwNe3zCMfi2/fPlyLV++fMDbAwAAAIC+ipjA3JEjR1RdXa3W1lb19PT02pGaPZt6MwAiV2v5+2rZ6gyG1L/9F695njXajr36B0mSdZozONLdag8Y0PMc+daqJFksFs286AKVTByvouxEd9rJtLyRqqmxuVNPJrbXu9NOWvOL/I7wGsgIsKFuoP8ngdYb7P9zoNF0gVJg9jVo93uP+YHS473yyivauHGjJKm7u1vx8fHulJqB5rlG7tntdu07UKmtGQ51dfcM6P8iWBztHaqqqpLleMpRl5NrjAKRpjA3S0tuu9r9Oj01yX1uqGtySHIG2EcXDHcH13Nzc1VdXa0lS5Zo0aJFBOkQEP00ALGgttamgyfdfMbvQAAAECqmB+YeffRR/f73v3cXH+8Li8Wirq6uELYKAAYnrWSG4lIzlL5jhc6fNUep2blegbL07iZt2rRZjgtvV/LIEnW3Nap565t9CuidPPLNNWKrp67SnXYy87TRSklJluRMPWnUG+60k5kF+X7bbdYIsEg20P+TQOv5m1dba9PIpGT936/PUbejWYfr2+Vo7/DxDv4NNGh3//euV05muruum721Uzf+7NGA6fECpcELNO/kkXu/l3TbV8y7kFvfYNfmTzbr4cOblZJg8ZrX0G5uwBB9c/LFtMNVtf0+dmJNdXW17r33Xi1YsIDAHHyinwYgFhgdzjTpK1eu0L9e7v/vQAJ6AABgIEwNzP3kJz/Rb3/7236nGQGASBeflqmEYXlKirdoVGGehhUUuQNlubnD1V3Xph5DMjrb1NPerC6bszOXYM1R6hmzlHZgnaZML1XysCy1trRq/boP+jXyLRQYTRc6nhcEXIGhx/a+r4b2Hu2us8hunyuNKnCnrCvMzRxQrbVAQbs5pROVnprkruvmGmlzzbxz/KbHW7LwKuXnDFNNXaPe27xTF583WZ3dhpY8+nLAea66dYdr6t2BwNMK8lSYm6XC3Myg/J/2R2tri3p6upVWMksZ+aO95rV//plk+yTsbULf+LuYdvKxA6B/6KcBiBXG8WwJaSUz+vU7cLABPQAAENtMC8xt3LjR3dm74IIL9K1vfUuSdNttt8liseidd95RQ0ODtm3bpmeeeUbl5eUqLS3V0qVLlZSUZFazMURVVFT4vKtt586dJrQG4dbVXKfu5jqvFJI63kFr27tRjqpyOY7sliS17NqguITEXuf5SjvZ2ursvAWqB2ff8IzzvSWVvb9ZkjTt7KmS+jfyLRQYTRc6/i4IdFRVqGfDOrW0tEryTlk3kMBcf7iCgGdNOE2FuVk+0+NdOftslU4ao90Hq1VVe0w3XPoF1TU5tOTRlwPOc9Wt232w2h0IHDuqQGeXjO6lVaEVl5aphMw872kp4anFiIHp67EDoO/opwGIRf39HTjQgB4AAIBkYmDu0UcflWEYmjdvnt566y3FxcXp009P1L2ZO3euJOnqq6/WT3/6U91999267777dN9997nr4QDBUFFRoYmTzlB7GxfvhqKu5jo1b3ld1rPnK8E63Oe8no42NW16yT3dM4WkK1Dm0vThP/o0z1faSVeAbeKk4n7Vg2ttbdPWLdsH/p+AqHHyBYG4enuf1x3saLpT38+7bhUQyQZz7AxlnucFoK/opwFA33FjFwAAGAjTAnNlZWWyWCxauHCh4uLiAi4bFxen3/3ud9q+fbvefPNNPfroo1q0aFGYWoqhzmazqb2tVTlXfF+JOUVe89o+/0j2dU+Z1DIEQ3dznewbnlXqhPNPCcy55uV97V6lT56rlt3r3TXhmjqld1eXaeasC5SenqamIxWq3LdX4yZPVU9Sutav+yDgvEABtrS0VKVmZfS5HtyRI0cH9Ld7pp5sqh/0fyUiXKDRdMEO2gGIDq7zQrWtQVv3VGrP/hqtXbtWmZmZ2rZtmyTnb/L6+nolJycrLS3NuV5hIXXnYhj9NAAAAAAILdMCc0eOHJEkFRcXu6f11vFbuHCh3njjDT355JN0+BB0iTlFSi6Y4DWt81ilSa1Bf3mOjOuv+LRMJRdMkKN6t7smXKucqZiKi8epoCBf1Tu71FS1T2dOHKu2hAytX/dBwHm+AmzNzc1hDZR5pp5sCv3mEMEI2gGx7ZF/vqd7H1vlfPHwk17z7rzzzlOWX7x4sZYsWRKGliES0U8DAAAAgNAyLTDX1dV1yjSr9cRw/4aGBmVlZXnNHzt2rCRp9+7doWwagCjkOTIuUg00UMbIN9TW2nSwosJr2uGqWjnaOwb93gOpWxcoPd5A5wEInUXXzNVZxafp6dff11fnnasROVnatueQ7nzgOd3/ves1bmSuNlW26osLblB2djaj5WIc/TQAAAAACC3TAnMjRozQoUOHVF1d7Z6Wn5+vhIQEdXd3a8uWLe76BS6uZVtaWsLZVAAwFSPfYpfR4QyUrVy5Qv962eI1r6G9R7vrLLLb50qjCsLarkD15wY6D0DoFOZm6cxxo5SXZdWFU8dp7KgCZWekS5LmlE7U6ILhOtpTo2nTpik3N9fk1sJs9NMAAAAAILQC5yQJobPOOkuS9NFHH7mnJSUluaf/6U9/OmWdZcuWSZJGjx4dhhYCiEadxyrVZXfWZHNUlctRuUOS1LZ3oxo3v6a2g1skSS27Nqht70bncpU71HZgizqPHVJHt6FaW71aW8Ob0s9zVBzgYnQ7R8SllcxQ5oXXeT3SJs5UT0+3WlpaTW4lgKGmurpaS5Ys8QrMIHbQTwMAAACA0DItMDd37lwZhqFVq1Z5Tb/ppptkGIZefPFFfeMb39Crr76qFStW6Gtf+5pWrlwpi8Wiq666yqRWA4h0x179g+zrnpIk1b/9F9W/+7gkyb7hGdW//Re1bn9HktT04T9k3/CMc7l3H1fN8z9V88ev6Eiz9I9V72j/5wf9BsoCBdEGGmBzjYrzTBUFuMSlZSohM8/rEZdKOkgAoVFdXa17772XwFyMop8GAAAAAKFlWirLa665RnfddZe2bNmiDz74QBdccIEk6fbbb9eTTz6pTz75RC+88IJeeOEFr/VGjx6tH//4x2Y0GUCE6Gqu8xoV19PerM7aA5KkjPOuVlfzMaUdWKcp00vV2iVt2rhZM2ddoPT0NDUdqVDlvr0aN3mqepLStX7dB5p38RyNGJGr+oo92vvpNk2fMUsF4yf5DZJ5ppYMNI+0kwBgrlDWZwSGKvppAAAAABBapgXmTj/9dH3++efq7u5WTk6Oe3piYqJWr16t//N//o9eeOEFdXZ2SpIsFou+/OUv66GHHtLw4cPNajaACNC85XXZNzwryTkqzlPTppckSW2Syt7f7J5eXDxOBQX5qt7ZpaaqfTpz4li1JWRo/boPNHr0KBUU5Cu5rVaHEy3Ky8li5BowBDnaO1RVVSVLt3dQxmazmdQihEqk1meMJIW5mVq8cIEKcxl9C2/00wAAAAAgtEwLzEnS2LFjfU7Pzs7W3//+dz300EMqLy9XV1eXJkyYQEcPgCTJevZ89XR3Kn3HCp0/a45Ss3NVU2PTu6vLNO/iOUpsr3ePfHPEp+uVVW+Y3WQgZPyNCGpqbPIZhIrV0UL1DXZt/mSzHj68WSkJpwZqMLR41mfMyPeuedVRVaGeDetivj5jYW6Wltx2tSTJ1sAYb3ijnwYAAAAAoWNqYK43VqtVpaWlZjcDQ0RFRYXPURE7d+40oTUYiK7mOjVveV3Ws+crYViekuItGlWYp2EFRUpJSZYkjR49Ska94R751paQYXKrgdDobUTQTpuhh2s/9RmEisXRQq2tLerp6VZayaxTAjXtn38m2T4xqWUIJVd9Rq9p9XaTWhOZqm0N+mx/lfbsr9HatWuVmZmpbdu2SZLKyspUX1+v5ORkpaWlSZLi4uL00ksvadGiRSosLDSz6TAR/TQAAAAAGLiIDswBwVJRUaGJk85Qe1ts3x0f7bqb62Tf8KxSJ5xvdlMA0wUaEeQKNDFa6FQ+AzUppK5F7Hrkn+/p3sdWOV88/KTXvDvvvPOU5W+77TY9+uijWrBgAYE5AAAAAAAGwPTA3KZNm7R582YdOnRI9fX16ujoUFdXV8B1LBaL/vrXv4aphRgKbDab2ttalXPF95WYU+Q1r+3zj2Rf95RJLUOoWa3pmnnRBbJa0/s1D4gWgQJNjBYC/POXBjbWUr0uumauzio+TU+//r6+Ou9cjcjJ0rY9h3TnA8/p/u9dr3Ejc7WpslVfXHCDsrOzVVtbq0cffdTsZiMM6KcBAAAAQGiYFpjbvXu3rrnmGu3ateuUeYZh+FzHYrHIMAw6fBiwxJwiJRdM8JrWeazSpNbAF890lcFgtVo1a/aF/Z4HABiaeksDG2upXgtzs3TmuFHKy7LqwqnjNHZUgbIznDeszCmdqNEFw3W0p0bTpk1Tbm6uNm/ebHKLEWr00wAAAAAgtEwLzN12223u2l7FxcUaP368MjMzlZiYqPj4eLOaBSAMAgXfBpqu0nP0W1N9sFoKABhqAqWBjfVUr4BEPw0AAAAAQs20wNymTZtksVj0m9/8Rj/60Y/MagYAE/Ql+NbdaleX/agkyVFVrp72ZnXWHnC+rtyhTvtRdXQbqrXVq1VJslrT3aPfmkL+FwAAoh2pXntX29Ck+qYW7dlfo7Vr1yozM1Pbtm2TJJWVlam+vl7JyclKS0uTJBUWFlJ3bgignwYAAAAAoWVaYC4/P18VFRWaOXOmWU3AEFRRUSGbzXbKdNddvwifwaakbC1/Xy1b35Qk1b/9F6959e8+LklqlvSPVe9IkmZedAFpKQEACKJ/vvuxHn2xzPni4Se95t15552nLL948WItWbIkDC1DKNFPAwAAAIDQMi0wd88992jRokX6zW9+oz//+c86/fTTzWoKhoiKigpNnHSG2ttIPxUJBpqS0iWtZIbiUjOUvmOFzp81R6nZuaqpsend1WWad/EcJbbXa++n2zR9xixZ84tktaYH+S8AACA2FeZmavHCBbp6bqkuvfBMPf36+/rqvHM1IidL2/Yc0p0PPKf7v3e9xo3M1abKVn1xwQ3Kzs5mtNwQQT8NAAAAAELLtMDcwoULdezYMd1zzz2aMGGCkpKSlJ2draSkJMXFxQVc12KxaN++fWFqKSJNoFFx7W2tyrni+0rMKfKa1/b5R7KveypcTUQfBUpX2XWsUkanQ5KUlJiglJRk5eYOlySNHj1KRr2hw4kW5eVkKbMg35T2A4g8jvYOVVVVyXK8jpiLr+8NAL4V5mZpyW1XS5JSkxOVl2XVhVPHaeyoAmVnOG+EmVM6UaMLhutoT42mTZum3NxcVVdXa8mSJVq0aBFBuihGPw0AAAAAQsu0wNw///lP/fznP5fFYpFhGHI4HDpy5Eif1rVYLIPa9pEjR/T888/rrbfe0tatW1VbW6vExESNGzdOl19+uf77v/9bBQUFg9oGQqMvo+ISc4qUXDDBa1rnscpQNy0m9SVdZaDgW9Oml9R+4BNJfUtXOe3sqUH+CwAMJfUNdm3+ZLMePrxZKQnevxUa2ntMahUQO6qrq3XvvfdqwYIFBOaimJn9NAAAAACIBaYF5u6++251dXUpNTVVX/va1zRx4kT3nZjx8fEh3fbYsWPlcDjcr4cNG6a2tjZt375d27dv12OPPaZ//vOfmjNnTkjbgf6z2WyMiosgfUlXGahWnCso52ns6WN0YP9Bn+kqW1vbtHXL9uD+EQCGjNbWFvX0dCutZJYy8kd7zWv//DPJduo5BwDgzcx+GgAAAADEAtMCc4cOHZLFYtHDDz+sm266Kazb7u7u1pw5c/Sd73xHl156qfLy8tTV1aWysjL9x3/8h/bu3aurrrpKu3btYuRchGJUXGQJNCouwZqj1DNmKe3AOk2ZXqrkYVlqbWnV+nUf+A2+Hdh/0Ge6yiNHjpr4VwKIFnFpmUrIzPOelmI1qTUAqqur9cgjj5DiMkqY2U8DAAAAgFhgWmDu/PPPV1lZmYqKinpfOMjWrFmjiy66yGtaQkKCvvSlL2nlypWaPn267Ha7HnnkES1evDjs7QMiiWe6ygTrcJ/LBBoVZ9/wjCSpTVLZ+5slnUhJ2d/gm9WarpkXXSCrNV1N9YP9y4DYVltr08GKCq9ph6tq5Wjv8LMGAEiFuZlavHCBCnMz+7wOKS6ji5n9NAAAAACIBaYF5h5//HHNnz9fd911l+677z5NmjRJw4cPV1JSUsi3fXJQztNZZ52lcePGae/evfr4449D3hYg0nmmq/QXmEsrmaG41Ayl71ih82fNUWp2rmpqbHp3dVlQU1JarVbNmn2hJKlpUH8VELuMjjZJ0sqVK/Svl0+tw7a7ziK7fa40KnJHjDvaO1RVVSVLt3cQ0WazmdQiIHYU5mZpyW1Xq9rWoK17KrVnf43Wrl2rzMxMbdu2TZJUVlam+vp6JScnKy0tTTt37jS51egPM/tpAAAAABALTAvMFRcXu59/6Utf6te6FotFXV1dwW6SW1ZWlns7QCzoy6i47la7HEf2eqWs1PGL4l3HKmV0Ous2JiUmKCUlWbm5zvchJSUQWYzjx21ayYxT6rB1VFWoZ8M6HThQoSxrmte8SBlNV99g1+ZPNuvhw5uVknBqYBFAeDzyz/d072OrnC8eftJr3p133mlCixAskdxPAwAAAIChwLTAnGEYZm06oJaWFn322WeSpHPOOcfk1gDh0ZdRcZ7pKiXvlJX17z4uSWqW9I9V70g6ka6yv0hXCYSHrzpslqNHJAUYTXdM2r37jFNGqoUzaNfa2qKenm6llcw6JbDY/vlnku2TsLQDQxupXnu36Jq5Oqv4ND39+vv66rxzNSInS9v2HNKdDzyn+793vcaNzNWmylZ9ccENOnLkiG688Uazm4w+itR+GgAAAAAMFaYF5tasWWPWpgP64x//qNbWViUnJ+uWW27xu5zD4ZDD4XC/bmxsDEPrAPOklcxQxtnz1bJ7vTtlZVOnBpSuMlDwjXSVgHkCjaZzHNijHttGPf300z5HqoU7BaavwGJcijUs28bQNRRSvYZLYW6Wzhw3SnlZVl04dZzGjipQdka6JGnE8GGypqfI0dEou92umpoaSSdSXEpyp7ksLCyk7lyEidR+GgAAAAAMFaYF5ubMmWPWpv3asmWLfvWrX0mS7r77bo0ePdrvskuXLtW9994brqYBYdFbukpLXLxXysrczGGS+p+ukuAbENl8jqZLco4eitYUmEBf9CXVa0tLqxlNiyo3/uzREy880lz6SnG5ePFiLVmyJAytQl9FYj8NAAAAAIYS0wJzbW1tqq2tlSTl5uYqLS2tlzVCy2az6dprr1V7e7u+9KUv6ac//WnA5e+++26viwuNjY0qKioKdTNjRkVFhWw22ynTd+7caUJrhoa+1JHrS7pK6UTKykDpKklJCQxNA0qBySgjRBmfIzLr7Sa1Jvo89cvblJqc4E5zeaSu2Z3i8qzi09Tc0u5Oczl58mSzm4uTRFo/DQAAAACGGtMCc0uWLNH//M//KC8vT5999pmpHb6mpibNnz9fn3/+uc466yytWLFC8fHxAddJTk5WcnJymFoYWyoqKjRx0hlqb+OO9GBy1ZFLGjlJ3c11PkfFJVhzlH3J7Wo/tF1pB9ZpyvRSdccnaf26DzTv4jkaMSJX9RV73Ckr4zJyA6SrZFQcECtCNcrI0d6hqqoqr5p2vm7aABBZzhhbqPTUJHeay7om52j7OaUTVTppjGwNTTraU6Np06aps7NTS5Ys0aJFi0hpGSEiqZ8GAAAAAEORaYG5N990jsr5z//8Tw0f7nv0Tji0t7frqquu0kcffaQJEybozTffVFZWlmntgfOia3tbq3Ku+L4Sc7xHIbZ9/pHs654yqWVDQ6BRcfYNz7ift0kqe3+ze1Tc6NGjVFCQr+S2WnfKyraE1LC1G0DkC+Yoo/oGuzZ/slkPH97sVdOuob1nUG0EEDqFuZlavHCBCnMz1djS1qd1qqurde+992rBggUE5iJEpPTTAAAAAGCoMi0wV1HhrFUzd+5cs5qgrq4uff3rX9eaNWtUVFSk1atXq6CANFuRIjGnSMkFE7ymdR6rNKk1Q0dayQxlnD1fLbvXK33HCp0/a46aOqV3V5cNYFQc6SoBhEZra4t6erqVVjLLaxRe++efSbZPTGwZYl1trU0Hj/+OdaGWolNhbpaW3Ha1JPU5MIfIEwn9NAAAAAAYykwLzHV1dUmSMjIyTNl+T0+PbrrpJr3yyivKz8/X6tWrNWbMGFPaAvSXZ724/opPy1RywQQ5qncrKd6iUYV5alWSpP6PiiNdJYBQO3kUXlyK1cTWIJYZHc5AE7UUMdSZ3U8DAAAAgKHOtMDcuHHjtH37dlVWVurss88O+/YXLVqk5557Tjk5OVq9erVKSkrC3gZgoFz14lInnO9zfldznd86co7KHeppb1bnsUPq6DZUa6uXJW1Y2NoOIDb5G2XU1Nh0Sh05iVpyiDyhqqUYCzxTXCLymd1PAwAAAIChzrTA3PXXX69t27ZpxYoVuvLKK8O67e9973t6/PHHlZmZqbfeektTpkwJ6/aBUHGNpOvpaFPTppfc0z3ryNW/+7j7ebOkf6x6x11HzhfPdJUA0F+9jTLaaTP0cO2nXnXkXPOASBTMWoqxwpXistrWoM27Dqq+qUV79tdo7dq1OnjwoCSprKxM9fXOvNjJyclKS0tTYWEhdedMYGY/DQAAAABigWmBuTvuuEPPPPOMnn76aS1YsEDXXnttWLZbUVGhP/7xj5Kkjo4OXX755QGXP3LkSBhaBZxqIOkqXSPp8r52r9Inzw1SHbkT6SoBoL8CjTJy1YsLNA/A0PHIP9/TvY+tOjHh4SfdT++8885Tll+8eLGWLFkShpbBk1n9NAAAAACIFaYF5qxWq9566y0tWrRI1113nW6++WYtXLhQ5557rhISQtesnp4Td+C3tbWprY3C9IhMvaWrDKS/deTis3IZFQcgpHyOMjpeLy7QPABDx6Jr5mrB7Ok6UF2rp19/X1+dd66O1DXrzgee0/3fu15nFZ+m5pZ2baps1RcX3KDJkyeb3eSYZFY/DQAAAABihak15lzi4uK0fPlyLV++XImJiRo+fLhSUlL8rmuxWLRv374BbXfs2LEyDGNA6wJm6G61e9WK62lvVmftAefryh3qam2QJHUeqxzwNhgVBwAAQq0wN0uFuVlKT01SXpZVF04dp7omhyRpTulElU4aI1tDk4721GjatGnKzc01ucWxyax+GgAAAADECtMCcwcOHPA5vaOjo9f0kRaLJeB8YChpLX9fLVvflORdK07yrhd37NU/hLVdAAAAGHropwEAAABAaJkWmLv55pvN2jQiREVFhWw22ynTd+7caUJrQidQrbi+1JFLK5mhuNQMd6241Oxc1dTY9O7qMp33hVKl9LRqx45d6jzzSlks8Wr66CU5Knc4R9YdO6SObkO1tnpZ0oaF8s8EACDm1dbadLCiwmva4apaOdo7TGoR0H/00wAAAAAgtEwLzC1btsysTSOM/AXfqqurde1XvyZH+9Cv8ReoVpxrXtLISX7TVXYdq5TR6UzzlJSYoJSUZOXmDpckbdq4+cSbffyK+6nnSLpmSf9Y9Y7O+0IpdeQAAAgBo8P5e2blyhX618veI4Ya2nu0u84iu32uNKog/I0D+ol+GgAAAACEFtW7ETIVFRWaOOkMtbe1+l0m54rvKzGnyGta2+cfyb7uqVA3L6L0JV2lK8AmSdPOnipJunLBZTKajmrnlk905rkXqtlI0ruryzTv4jkaMSJX9RV7tPfTbZo+Y5YKxk+S1WoN3x8FAECMMLqdI+LSSmYoI3+017yOqgr1bFinlhb/v4diWWFuphYvXKDC3EyzmwIAAAAAQFgQmEPI2Gw2tbe1Bgy+JeYUKblggte8zmOV4WxmRAiUrnLexXOU2F7vDrBZ84vU2tqmrVu2Kyd3uIz4VqUmWjSqMFdtCRmSpNGjR6mgIF/JbbU6nGhRXk4WQTkAAEIsLi1TCZl53tPq7Sa1JjoU5mZpyW1Xm90MAAAAAADChsAcQo7gW+/i0zKVMCxPSfEWjSrM07CCIqWkJEtyBtmMesMdYMssyNeRI0dNbjEAAAAAAAAAAOgvAnNAEHU11/mtFde2d6M6G53zWnZtcM5vbXAuW7lDnfaj6ug2VGurV6uS1Nrqv/6e1ZrurhfXVB/SPwkAAAAAAAAAAAQJgTkgiJq3vC77hmclnVorzr7hGffzpg//4TUvUB05X6xWq2bNvtD5XoNuNQAAAAAAAAAACIeICczt3r1b77//vsrLy2W3O2txZGZmqri4WDNmzNCkSZNMbiHQO+vZ89XT3emzVtzMWReop8mmyn17NW7yVKVk56m1pVXr130QsI5cv7bvMZIOAAAAGCz6aQAAAAAQXKYH5t5//33deeed2rRpU8Dlzj33XP3hD3/QRRddFKaWAd66muvUvOV1Wc+eH3Cev1pxxcXjZNQnqalqn86cOFaZp03QkSNHtX7dBz7ryDU3N/c7XaXnSDoAAABgoOinAQAAAEBoxJm58eXLl2v27NnatGmTDMMI+Ni0aZPmzp2rJ554wswmI4Z1N9fJvuFZdTfX9WveQLmCbFarNWjvCQAAAPSGfhoAAAAAhI5pI+Z27dql2267TT09PUpJSdG3vvUtXX311Zo8ebKys7MlSXV1dfr000/14osvavny5XI4HPqP//gPXXjhhTrjjDPMajpOUlFRIZvNdsr0nTt3mtAaAACAyFNba9PBigqvaYerauVo7zCpRYBv9NMAAAAAILRMC8w98MAD6urqUk5Ojt577z2deeaZpywzatQojRo1Sv/2b/+m22+/XV/84hdVX1+vP/7xj3rkkUdMaDVOVlFRoYmTzlB7W6vZTQEAAIg4RkebJGnlyhX618sWr3kN7T3aXWeR3T5XGlUQ/sYBPtBPAwAAAIDQMi0w984778hiseinP/2pz87eyaZOnaqf/OQn+v73v6933nknDC1EX9hsNrW3tSrniu8rMafIa17b5x/Jvu4pk1o2MF614qzDg/KeVmu631pxgeYBAIDoZ3Q7R8SllcxQRv5or3kdVRXq2bBOLS3c4ITIQT8NAAAAAELLtMBcVVWVJGnmzJl9XmfWrFle6yJ8ektXmZhTpOSCCV7zOo9VhqVt/RUo+OaqFZc0cpK6m+vUZT8qSXJUlUvHL6y17d2ozkbn9JZdG+SoKldPa4Nzucod6rQfVUe3oVpbvVqVJKs1XbNmXyhJajqpLa46cr7mAQCAoSMuLVMJmXne0+rtJrUG8I9+GgAAAACElmmBucTERDkcDrW3t/d5HdeyiYmJoWoWfBhq6SpdwbfUCef7HRXXWv6+Wra+6X5d//Zf3M/tG55xP2/68B9e69W/+7gkqVnSP1Y57xieedEF7uAbAAAAEMnopwEAAABAaJkWmBs3bpy2bduml19+WRdddFGf1nnxxRclSaeffnoom4aTDLV0lX2RVjJDGWfPV8vu9UrfsULnz5qjpk7p3dVlmjnrAvU02VS5b6/GTZ6qlOw8tba0av26DzTv4jlKbK/X3k+3afqMWbLmF8lqTTf7zwEAAAD6hH4aAAAAAIRWnFkbvuKKK2QYhv6//+//09///vdel1++fLn+93//VxaLRVdeeWUYWoiTudJVej4SMvPNblZIxKdlOv++YXlKirdoVGGeRo8eJUkqLh6nktNHKivVojMnjlVp6TRNKB4nSRo9epQK8rKUmmhRXk6WCgryZbVazfxTAABAhKuttelgRYXX43BVlRztHWY3DTGIfhoAAAAAhJZpI+buvPNOPfLIIzp27JhuueUW3X///bryyis1efJkZWdnS5Lq6+v16aefatWqVdqxY4cMw1Bubq7uvPNOs5o95PmqJeeqIxdNAtWRc+lutctxZK/POnKOyh3qaW9W57FD7npxlrRhYWs/AAAY+oyONknSypUr9K+XLV7zGtp7tLvOIrt9rjSqIPyNQ8yinwYAAAAAoWVaYC47O1tvvPGG5s+fr9raWm3btk3btm3zu7xhGMrLy9O//vUvd4cQwTWUasm56sgljZyk7uY6n8G3pk0vqf3AJ+51POvIuWrFSSfqxU07e2p4Gg8AAGKCcfw3SVrJDGXkj/aa11FVoZ4N69TSEv2/yxBd6KcBAAAAQGiZFpiTpNLSUu3atUu/+c1v9NRTT+no0aM+lxsxYoRuvPFG3X333crJyQlzK2OHv1py0VxHrrX8fbVsfdP92jP45hmUcxl7+hgd2H9Q8y6eoxEjclVfscddLy4uI1dbt2wPS7sBAEDsiEvLVEJmnve0ertJrQHopwEAAABAKJkamJOcd2Ted999uu+++7Rv3z6Vl5fLbndeiMjMzFRxcbEmTJhgcitji6uWnEvnsUoTW+NfX9JVppXMUMbZ89Wye73Sd6zQ+bPmqKlTend1md/g24H9B5214gryldxWq8PH68XFZ+Vq5kUXyGpNV1O993as1nS/8wAAAIBoQz8NAAAAAELD9MCcp/Hjx2v8+PFmNwMRxjMA58mVrjJ1wvl+A3PxaZlKLpggR/VuJcVbNKowT61KkiSfwbe2hFS/7bBarZo1+0JJUlM/5gEAAADRjH4aAAAAAARPRAXmAF88A3A+57fa5Tiy12cdOUflDvW0N6vz2CF1dBuqtdXLkjYsbG0HAAAAAAAAAABwITAXgyoqKmSz2U6ZvnPnThNaM3iB6sjVv/u4+3mzpH+sekfTzp4azuYBAAAAAAAAAABIClNgbvbs2UF9P4vForKysqC+51DjL/hWXV2ta7/6NTna20xolX/+0lX2xUDqyG3dst3ne3nWigMAADBbba1NBysqvKYdrqpVU2OTqqqqZDmeJcBznqPdexrgD/00AAAAAAi/sATm1q9fL4vFMqB1DcOQJPf6hmEM+L1iRUVFhSZOOkPtba1+l8m54vtKzCnymtb2+Ueyr3sqZO0KFHzrLV2lJHUeq/SZrrLrWKUscfEyOh2SpKTEBOVmOtNV+qojF5+V6zf45lkrDgAAwCxGh/MmqpUrV+hfL3v/9m1o79FOm6GHaz9VSsKp83Yfk3bvPsMraEfADr7QTwMAAACA8AtLYG706NGD7qQdPnxY3d3dQWrR0Gaz2dTe1how+JaYU6Tkggle8zqPVYa0XX0JvnW32r2Cbz3tzeqsPSBJOvbqH9zLDSZdJcE3AAAQ6YzjQbW0khnKyB/tNa/9888k2yc+5zkO7FGPbaOefvppr6BdQ3uPdtdZZLfPlUYVhLr5iBL00wAAAAAg/MISmDtw4MCA1rPb7Xrqqaf0+OOPq6Kiwn1X5mmnnRbE1g1dZgTfBpOSUvKuF+cZfAukv+kqAQAAokVcWqYSMvO8p6VY/c6zJDnTXp4ctOuoqlDPhnVqafGfUQGxh34aAAAAAIRfWAJz/bVu3To9/vjjWrFihdrb22UYhhISEnTFFVfoO9/5ji677DKzmxjTBpuSMpC0khmKS81w14pLzc5VTY3NXS8usb3eHXxzxKfrlVVv+ExX2ZaQOtg/EwAAIGqdHLSLq7eb2BoMFfTTAAAAAGDwIiYwV1tbq7/97W96/PHHtWfPHvddlxMmTNC3v/1t3XLLLcrPzze5lZAGH3wLlK6y61ilV624lJRk5eYOl+SsF2fUGx7Btwy/27Ba0/3WkQMAAIhVtbU2Hayo8JpG/TkEQj8NAAAAAILL9MDcm2++qccff1yvvPKKOjs7ZRiGkpOTdc0112jhwoWaO3eu2U3EAAQKvjVtekntBz6RdGq6Sle9OFetOEkB68X5Qx05AACAE4yONknSypUr9K+XvWuKUX8OvtBPAwAAAIDQMCUwd+jQIT3xxBNatmyZV02CKVOm6Dvf+Y5uuukmZWdnm9E0HBfKWnGuoJynsaeP0YH9B09JV2nNL1Jraxv14gAAAAbB6HaOiDu59pxE/TmcQD8NAAAAAEIvbIG57u5uvfLKK3rsscf01ltvqaenR4ZhyGq16rrrrtN3vvMdnX/+wFIjYmA8g28J1uFe8/qSrjLQqLgEa45Sz5iltAPrNGV6qZKHZam1pVXr133gN/h2YP/BU9JVZhbk68iRoz63T7pKAACA/jm59px0ov4caS5jE/00AAAAAAivsATmfvzjH+vJJ5/U0aPOAIthGPrCF76ghQsX6vrrr1d6OoEVM3gG304OzLmXGWBKSvuGZyRJbZLK3t8s6URKyv4E3yTvAFxTved00lUCAAAMFmkuYxf9NAAAAAAIv7AE5n7/+9/LYrHIMAwlJCTo8ssv11lnnaWDBw/qd7/73YDe8xe/+EWQWzk0BRoV1xeRkJLSMwDX1O+1AQAAEAhpLmMX/TQAAAAACL+w1pizWCzuVCmvvPLKoN6LDl/f9GVUXCBpJTMUl5qh9B0rdP6sOUrNzlVNjU3vri4LWkpKAAAAmI80l7GLfhoAAAAAhE/YAnOuwuHBYLFYel8IfdbdapfjyF6vlJU6fud017FKGZ0OSVJSYoJSUpKVm+sM8AUz+OYvXSUAAADM02uay2PS7t1nyNLtHaA7XFWrpsYmVVVV+ZxHQC9y0E8DAAAAgPAKS2Bu//794dhMv+3bt09Lly7VW2+9pZqaGg0fPlxz5szRD3/4Q02fPt3s5gVVoOCbZ604yTtlZf27j0uSmiX9Y9U7kk7UiuuvQME30lUCAABEnkBpLh0H9qjHtlFPP/20UhJODdrttBl6uPZTn/OoWxcZIrWfJpnTV4ul/iEAAAAA84QlMDdmzJhwbKZf1q1bp8svv1zNzc2SpGHDhqm6ulrPPfecVq5cqaeeekpf//rXTW5l8HjWipO8g2/UigMAAEAgvtJcWpKcqS19Be3aP/9Msn0SsG7dgQMVyrKmec2ra2yRvbE9BH8BfInEfppkTl8t1vqHAAAAAMwT1hpzkcJut+vaa69Vc3Ozpk+frueff17FxcU6fPiwbr31Vr399tu6+eabdd555+n00083u7l9Vl1drerqau3cuVOS96i4BGuOsi+5Xe2HtivtwDpNmV6q7vgkrV/3geZdPEcjRuSqvmKPOwAXl5E7oFpxpKQEAACILT5r06VY/c6zHD0iyXd6zPYuQxsOx+mSr35Lubm5IWw1IpUZfbWh2j8EAAAAEJnizG6AGf70pz+ptrZWKSkpevHFF1VcXCxJGjVqlF544QXl5uaqvb1dS5cuNbml/fPII4/onHPO0Y033ijJOSrOlYrSvuEZ1b/9F7XtXKdjbVLZ+5vV1NQiyVkrbuzY0SrIy1Lq8QBcWlqq3+14Bt9OneccFWe1WkPwFwIAACDaeabHzLzwOq9H+uS56urq1LFjx0xuJcxiRl9tqPYPAQAAAESmmAzMPf/885KkK6+88pT0LVlZWbrpppskSStXrlR3d3fY2zdQixYt0scff6yHHnpIBVbpqvlzNO/iOZKkeRfP0fU3XKtLLzpL47Olr355liZOmjCg7RB8AwAAwGC5RtN5PuLSssxuFkxmRl9tqPYPAQAAAESmmAvMNTQ0aPt2Z320uXPn+lxm3rx5kqS6ujrt2LEjXE0btMLCQpWWlqq4uFhJ8RaNKszT6NGjJPV/VBwAAAAAhJMZfbWh3D8EAAAAEJliLjC3e/du9/OSkhKfy3hO37VrV8jbFIkCpasEAAAAgGAzo69G/xAAAABAuCWY3YBwO3LkiPt5QUGBJOm2227Ts88+q5tuukl/+ctfVFhY6F7m6NGjPt/H4XDI4XC4X9vtdklSY2NjKJrdLy0tLeoxDNlrq9XS5dzFDdWHldDRosb6OnX3GLLbjspIdWj61BI57DbZTpqX1hOnM8bmq72uxmt6Z493LDdW50VKOyJpXqS0I5LmRUo7ImlepLQjWuZFSjsiaV6ktCOS5kVKOyJpXqS0I5LmRUo7epvXZrepxzDU0tJi6u9q17YNwzCtDbEoWH01s7YZqX1Ez/5hR0en17xIOv6j/fzF/wn/J5E2L1LaEUnzIqUdkTQvUtoRSfMipR2RNC9S2hFJ8yKlHZE0byj3D6UQ9BGNGPP0008bkgxJxt69ew2bzeZ+Lck4duyY0dnZ6X7961//2uf7LF682Gs9Hjx48ODBgwcPHjx4DK1HZWVlmHsrsS1YfTWztkkfkQcPHjx48ODBgwePof0IVh8x5kbMnSwnJ0c33XSTVq5cqRtvvFHDhw9XV1dXr+vdfffduvPOO92ve3p6VFdXp5ycHFksllA2GUHS2NiooqIiVVZWatiwYWY3ByHEvo4d7OvYwb6OLezv2BEp+9owDDU1NWnkyJGmtQED76uZtc1I7SNGynGF/mG/RSf2W3Riv0Uf9ll0Yr9FJ/abU7D7iDEXmEtPP1Ezra2tTZL05JNP6sknnzxluiRZrVaf75OcnKzk5GSvaVlZWUFsKcJl2LBhMX1SiSXs69jBvo4d7OvYwv6OHZGwrzMzM03dfiwKVl/NrG1Geh8xEo4r9B/7LTqx36IT+y36sM+iE/stOrHfgttHjOt9kaHFVTdA8q4n4Km6utr9PD8/P+RtAgAAAIBYZ0Zfjf4hAAAAgHCLucDcxIkT3c/Ly8t9LuM5fdKkSSFvEwAAAADEOjP6avQPAQAAAIRbzAXmsrKyNHXqVElSWVmZz2XWrFkjSRo+fLimTJkStrYhvJKTk7V48eJT0s1g6GFfxw72dexgX8cW9nfsYF/HNjP6arHQP+S4ik7st+jEfotO7Lfowz6LTuy36MR+Cw2LYRiG2Y0It1//+tf66U9/qpSUFJWXl6uoqMg9z263q6SkRDU1NfrOd76jxx57zMSWAgAAAEDsCFZfzWKxuJ/v379fY8eODfk2AQAAAKAvYm7EnCTdcccdysvLU3t7u77yla9o7969kqSqqipdd911qqmpUUpKiu655x6TWwoAAAAAscOMvhr9QwAAAADhFJMj5iRp7dq1uvzyy9XS0iJJyszMVGNjowzDUGJiov7+97/ruuuuM7mVAAAAABBbgtFX68+IuWBtEwAAAAD6IiZHzEnS7NmztXXrVt1666067bTT1NbWpvz8fH3961/XBx98QKcLAAAAAExgRl+N/iEAAACAcInZEXMAAAAAAAAAAABAOMXsiDlEriNHjujBBx/Ul7/8ZZ122mlKTk6W1WrVWWedpR//+Mc6cuRI0Lf58ssv67/+6780e/ZsFRYWKjExUVarVVOmTNH3v/99VVRU9Poe+/bt03e+8x2NHj1aKSkpGjlypL7xjW/ok08+CXp7h4po29dLliyRxWIJ+LjiiiuC3uahwIx97c9ll13m3l/Lly8PuCzHdf9F277muB44M/Z1MPYXx/XARNv+5tgGON9Fm82bN+svf/mLbr75Zk2aNElxcXGyWCy65ZZbzG4aAoik377ou2BcA0Jk6E//HuHHb/LoZhiGnnnmGV1++eUqLCxUcnKyRo0apTlz5uhXv/qVOjo6zG5idDOACJOcnGxIcj+GDRtmJCYmul8PHz7ceO+994K6zTPPPPOUbSYlJblfW61W41//+pff9deuXWtYrVav9V3PExMTjeeffz6o7R0qom1fL1682L1P8/PzfT5uvPHGoLZ3qDBjX/vy9NNPe7Vj2bJlfpfluB6YaNvXHNcDZ8a+Huz+4rgeuGjb3xzbiHWc76JPZmam13nW9bj55pvNbhoCiJTfvuifwV4DQmToT/8e5uA3efRqamoyvvSlL7mPL4vFYmRlZRlxcXHuabW1tWY3M6oRmEPESUhIMObMmWP8/e9/N2pqagzDMIzOzk5j9erVxoQJEwxJRmZmplFdXR20bX7ve98z/vd//9fYsWOH0dLSYhiGYfT09BiffPKJ8cUvftH9w+zw4cOnrNvQ0GDk5eUZkozp06cb5eXlhmEYxqFDh4xLLrnEkGSkpKQYn3/+edDaO1RE2752/aCYM2dO0NoTK8zY1yerq6szRowYYZxxxhm9/nDnuB64aNvXHNcDZ8a+Hsz+4rgenGjb3xzbiGWc76JTXl6ece655xp33HGH8dRTTxmlpaUE5qJAJPz2Rf8N5roAIkN/+nwwD7/Jo9cVV1xhSDKysrKMhx9+2GhsbDQMwzA6OjqMbdu2GT/4wQ+MhoYGk1sZ3QjMIeKsW7fO77ytW7e6I/NLliwJS3saGxuNjIwMQ5Jx3333nTL/V7/6lbtze+DAAa959fX1Rm5uriHJWLhwYVjaG02ibV/zg2LgImFff/vb3zYkGW+//XavP9w5rgcu2vY1x/XAmbGvB7O/OK4HJ9r2N8c2Yhnnu+jkcDi8Xs+ZM4fAXBSIhN++CK7ergsgMvSnzwfz8Js8Oq1atco90nHTpk1mN2fIosYcIs5FF13kd95ZZ52lcePGSZI+/vjjsLQnIyNDEyZMkOSs03Cy559/XpJ05ZVXasyYMV7zsrKydNNNN0mSVq5cqe7u7hC3NrpE277GwJm9r9euXasnnnhC11xzjS6++OJel+e4Hrho29cYOLP3dX9xXA9OtO1vIJZxvotOSUlJZjcBA8D349DDdYHIR58PCK2HH35YkrRw4UKde+65Jrdm6CIwh6iTlZUlSbJYLGHZXk1NjXbv3i1JGjVqlNe8hoYGbd++XZI0d+5cn+vPmzdPklRXV6cdO3aErqFDUCTta4RWKPd1R0eHFi1apJSUFN1///29Ls9xHVqRtK8RWuE+hwfCcR16kbS/gVjG+Q6ILHw/Rh+uC0Q2+nxAaHV0dGj16tWSpG9+85smt2ZoIzCHqNLS0qLPPvtMknTOOeeEbDuGYejo0aN66aWX9KUvfUmtra1KSUk55YTk+rEmSSUlJT7fy3P6rl27QtPgISjS9rWnTz/9VFOmTFFqaqoyMjI0bdo03XPPPTp69GjI2jmUhXpfL126VLt27dLdd999yl3jvnBch06k7WtPHNfBFep93d/9xXEdWpG2v4O1LhCNON8BkSNcfVoM3kCuC8Acg+nzwTz8Jo8eO3fuVEdHh+Li4jR9+nS9+OKLmjlzpjIyMpSRkaHzzjtPf/jDH+RwOMxuatQjMIeo8sc//lGtra1KTk7WLbfcEvT3/+CDD2SxWBQXF6eCggJ95Stf0Y4dOzRixAitWrVKp59+utfyR44ccT8vKCiQJN12223KyMjQ7bffLkkqLCx0L8MXTt9F2r72ZLPZtHv3bqWmpqqlpUXbtm3T0qVLNWXKFG3YsCHobR3qQrmvd+/eraVLl2rcuHG66667+rQOx3XoRNq+9sRxHVyhPof3d39xXIdWpO3vYK0LRCPOd0DkCPX3IwZvMNcFEH6D7fPBPPwmjx6VlZWSpOzsbD388MO65ppr9P777yshIUEOh0MfffSRfvCDH2ju3LlqaWkxubXRjcAcosaWLVv0q1/9SpJ09913a/To0UHfRlJSkvLz85WXl+dONTFp0iS98cYbuuSSS05Z3vMElJqaqmPHjumxxx5Tc3OzHnroIdXV1Sk1NdW9THNzc9DbPBRF4r6WnHcXP/jggzpw4IDa29tVV1enuro6/fnPf1ZGRoZsNpuuuuoqrwsiCCzU+3rRokVyOBx64IEHlJKS0qd1OK5DIxL3tcRxHQqh3NcD3V8c16ETift7sOsC0YzzHRAZwtGnxeAN5LoAzDPQPh/Mw2/y6NPU1CRJamtr0913361LL71Un3/+uerr69Xc3KzHH39cSUlJ+uCDD3T33Xeb3NooZwBRoLa21hg3bpwhyfjSl75kdHV1hXybbW1txjvvvGOcc845hiTjrrvuMrq7u72Wefrppw1JhiRj7969hmEYxk033WSkpaUZt912m2EYhtHZ2ele5te//nXI2x3tInVf96asrMywWCyGJOMHP/hBiFo6tIR6X//1r381JBnz588/ZZ7rmFy2bNkp8ziugy9S93VvOK77z4xzuEug/cVxHRqRur9DuS4Q6TjfDR1z5swxJBk333yz2U1BP5n5/YiBC8Z1AYROqPp8MA+/ySPTU0895T6mRowYYTQ3N5+yzH//938bkozU1FSjpaXFhFYODYyYQ8RramrS/Pnz9fnnn+uss87SihUrFB8fH/LtpqSkaN68eVq/fr3OPvts3XffffrTn/7ktUx6err7eVtbmyTpySefVEtLix555BGv6ZJktVpD3u5oFsn7ujezZ8/WvHnzJEmvvfZaKJo5pIR6X9fW1uquu+5SUlKSHnzwwX6ty3EdXJG8r3vDcd0/Zp3DXQLtL47r4Ivk/R3KdYFIx/kOMJfZ348YuGBcF0BohLLPB/Pwmzwyef6W/Na3vuX12sWVnrmtrU0ff/xxuJo25BCYQ0Rrb2/XVVddpY8++kgTJkzQm2++qaysrLC2ISUlRf/1X/8lSfrd737nNc9Vt0GS32HX1dXV7uf5+fkhaOHQEOn7ui9KS0slSQcOHAhms4accOzre+65R3V1dbrzzjtVXFzcr3U5roMn0vd1X3Bc900knMMl//uL4zq4In1/h3pdIJJxvgPMEynfjxicwV4XQPCFus8H8/CbPPLk5ua6n5eUlPhcZuzYse7nVVVVoW7SkEVgDhGrq6tLX//617VmzRoVFRVp9erVXh3NcDrttNMkOU82DQ0N7ukTJ050Py8vL/e5ruf0SZMmhaaBUS4a9nVfuHLSw79w7es9e/ZIkn7729/KYrGc8nC59dZbZbFYvH5UcFwHRzTs677guO5dJJ3D/e0vjuvgiYb9Hep1gUjG+Q4wRyR9P2LwBnNdAMEX6j4fzMNv8sjjGfxm/4QWgTlEpJ6eHt1000165ZVXlJ+fr9WrV2vMmDGmtaeiosL93DAM9/OsrCxNnTpVklRWVuZz3TVr1kiShg8frilTpoSwldEpWvZ1X2zZskWSdPrppwezSUNGpO1rfziuBy9a9nVfcFwHFmn72t/+4rgOjmjZ36FeF4hknO+A8Iu070cM3mCuCwDoO36TR578/Hx3cNvfTV6eIxxHjRoVhlYNTQTmEJEWLVqk5557Tjk5OVq9erXfobOBeN49E2hIdHNzc8D36ezsdNdjGD9+vLKzs73mX3fddZKkVatWqbKy0mue3W7XU089JUm65ppryC3vQ7Ts6+7u7oDrbtq0SatXr5YkXXnllX1seWwJ575+7733ZBiG34fLsmXLZBjGKe/FcT040bKvOa4HL5z7erD7i+N68KJlf3NsI9ZxvgPCKxjfjwifwV4DQvgNtn8Pc/CbPHpdffXVkpzHVGtr6ynzly9fLslZj+6cc84JY8uGGAOIMP/93/9tSDIyMzONjz/+eMDvI8n92L9/v9/lli1bZkybNs148MEHjd27dxs9PT2GYRhGa2ursWbNGmPGjBnu93nooYdOWb+hocHIy8szJBnnnHOOsWfPHsMwDOPw4cPGpZdeakgyUlJSjM8//3zAf8tQFU37+r333jPmzJljPPnkk8bhw4fd05uamozly5cbOTk5hiQjPz/fqK2tHfDfMlSFe1/39X2WLVvmcz7H9cBF077muB6ccO/rwe4vjuvBiab9zbGNWMf5Ljo1NTUZtbW17oerb3L99dd7TW9vbze7qfAQrO9HhM9grwEh8vTWv4c5+E0evSorK43U1FRDknH55Ze7+20Oh8N4/PHHjaSkJEOScdddd5nb0ChHYA4R5eDBg+4v1NTUVCM/Pz/gI5D+BGs8l01KSjKGDx/uNc1isQQ82ZSVlRnp6enu5TMzMw2LxWJIMhITE43nnntuoP8lQ1a07es1a9Z4LZeenm7k5OQYcXFx7mlFRUV0xnwwY1/3pi8/3Dmu+y/a9jXH9cCZsa+Dsb84rgcm2vY3xzbA+S4a3XzzzV7nLn8PLjxHjmB+PyJ8gnENCJGF82Nk4jd5dFu5cqU7ACfJyM7O9no9b948o62tzexmRrUEARGkp6fH/bytrU1tbW0h3+aXv/xlPf7441q7dq22bNmimpoaHTt2TGlpaTrttNN00UUX6bbbbtP555/v9z1mz56trVu36te//rXefvtt1dTUKD8/X7Nnz9aPfvQjlZaWhvzviDbRtq+nTJmi3/zmN1qzZo327t2r+vp6NTQ0KDMzU2eccYauuuoqLVq0SJmZmSH/O6KNGfs6GDiu+y/a9jXH9cCZsa+Dsb84rgcm2vY3xzbA+Q4Ih2j77QunYFwDAtA7fpNHt2uuuUabN2/W//zP/+idd97R0aNHlZKSonPPPVff/OY3tXDhQiUmJprdzKhmMQyqmAIAAAAAAAAAAAChFmd2AwAAAAAAAAAAAIBYQGAOAAAAAAAAAAAACAMCcwAAAAAAAAAAAEAYEJgDAAAAAAAAAAAAwoDAHAAAAAAAAAAAABAGBOYAAAAAAAAAAACAMCAwBwAAAAAAAAAAAIQBgTkAAAAAAAAAAAAgDAjMAQAAAAAAAAAAAGFAYA4AAAAAAAAAAAAIAwJzAAAAAAAAAAAAQBgQmAMAAAAAAAAAAADCgMAcAAAAAAAAAAAAEAYE5gAAAAAAAAAAAIAwIDAHAAAAAAAAAAAAhAGBOQAAAAAAAAAAACAMCMwBAAAAAAAAAAAAYUBgDgAAAAAAAAAAAAgDAnMAAAAAAAAAAABAGBCYAwAAAAAAAAAAAMKAwBwAAAAAAAAAAAAQBgTmAAAAAAAAAAAAgDAgMAcAAAAAAAAAAACEAYE5AAAAAAAAAAAAIAwIzAEAAAAAAAAAAABhQGAOAAAAAAAAAAAACAMCcwAAAAAAAAAAAEAYEJgDAAAAAAAAAAAAwoDAHAAAAAAAAAAAABAGBOYAAAAAAAAAAACAMCAwBwAAAAAAAAAAAIQBgTkAAAAAAAAAAAAgDAjMAQAAAAAAAAAAAGFAYA4AAAAAAAAAAAAIAwJzAAAAAAAAAAAAQBgQmAMAAAAAAAAAAADCgMAcAAAAAAAAAAAAEAYE5gAAAAAAAAAAAIAwIDAHAAAAAAAAAAAAhAGBOQAAAAAAAAAAACAMCMwBAAAAAAAAAAAAYUBgDgAAAAAAAAAAAAgDAnMAAAAAAAAAAABAGBCYAwAAAAAAAAAAAMKAwBwAAAAAAAAAAAAQBgTmAAAAAAAAAAAAgDAgMAcAAAAAAAAAAACEAYE5AAAAAAAAAAAAIAwIzAEAAAAAAAAAAABhQGAOAAAAAAAAAAAACAMCcwAAAAAAAAAAAEAYEJgDAAAAAAAAAAAAwoDAHAAAAAAAAAAAABAGBOYAAAAAAAAAAACAMCAwBwAAAAAAAAAAAIQBgTkAAAAAAAAAAAAgDAjMAQAAAAAAAAAAAGFAYA4AAAAAAAAAAAAIAwJzAAAAAAAAAAAAQBgQmAMAAAAAAAAAAADCgMAcAAAAAAAAAAAAEAYE5gAAAAAAEWHz5s36y1/+optvvlmTJk1SXFycLBaLbrnllpBsb8mSJbJYLAEfV1xxRUi2DQAAACA2JZjdAAAAAAAAJGnevHmy2+1h325iYqKGDx/uc152dnaYWwMAAABgKCMwBwAAAACICElJSTr33HN1wQUX6IILLtD999+vzZs3h3y7M2bM0HvvvRfy7QAAAAAAgbkg6enpUVVVlTIyMmSxWMxuDgAAAIABMgxDTU1NGjlypOLiyP4fTocOHVJSUpL79WOPPWZiawaHPiIAAAAwNAS7j0hgLkiqqqpUVFRkdjMAAAAABEllZaVOO+00s5sRUzyDctGOPiIAAAAwtASrj0hgLkgyMjIkOXfMsGHDTG4NAAAAEAX27pX275fGjZPGjze7NW6NjY0qKipy/8YHBoI+IoABi9DvRwAAYlWw+4gE5oLElZpk2LBhdLoAAACAQOrqpBtukN5888S0Sy+Vnn1Wys42r10nIf1g7Pj00081ZcoU7du3TwkJCRo3bpy+/OUv6//+3/+r/Pz8Ab0nfUQA/RYl348AAMSqYPURKZgAAAAAYPDKy6XXX5f27Ol92RtukFav9p62erX0jW+Epm1AL2w2m3bv3q3U1FS1tLRo27ZtWrp0qaZMmaINGzb06T0cDocaGxu9HgDQL3w/AgAQEwjMAQAAABi4ujrpssukiROlyy+XSkqcr+vrfS9fXu4cCdDd7T29u9s5vS+BPSBISkpK9OCDD+rAgQNqb29XXV2d6urq9Oc//1kZGRmy2Wy66qqrdOTIkV7fa+nSpcrMzHQ/qC8HoF/4fgQAIGYQmAMAAAAwcP29u3/fvsDvt3dvcNoF9MENN9yg//N//o/GjBmj+Ph4SVJWVpZuv/12vfrqq7JYLDp27Jj+8Ic/9Pped999t+x2u/tRWVkZ6uYDGEr4fgQAIGYQmAMAAADQNyenqxzI3f3jxwfexoQJwWkrMEizZ8/WvHnzJEmvvfZar8snJye768lRVw5Av/H9CABAzCAwBwAAACAwf+kqt2wJvJ6vu/tLSqRLL5WOj05yi493Ti8uDlqzgcEqLS2VJB04cMDchgAY+vh+BAAgZhCYAwAAABCYv3SV//u/gdfzd3f/s89KF1/sPe3ii53TgQhisVjMbgKAWML3IwAAMSHB7AYAAAAAiGCudJUn6+6W1q+XZs2S3n/fO51lfLzzQqK/u/uzs6U33nCmuty71xnAYyQAItCW46NCTz/9dHMbAiA28P0IAEBMIDAHAAAAwL99+wLPv+MOKS3NO3jneXd/ebnzPXxdXCwu5oIjgs5zlNv+/fs1duxYn8t1d3cr/uSUcR42bdqk1cdHil555ZVBbSMABMT3IwAAQxqpLAEAAAD4N3584PnTpzvv7i8vl157zfnvG29IhuG7Ll19fXjajajU3Nwsm83mfnR2dkqSHA6H13SHwzHoba1fv15z587V3//+d1VVVXm14W9/+5vmz5+vnp4e5efn6/vf//6gtwcAAAAAEiPmAAAAAARSUiJdeqmzplygdJUn393vry7dN77hDNwBPtxxxx3629/+dsr05557Ts8995z79bJly3TLLbcMaluGYaisrExlZWWSpPT0dKWkpKi+vl49PT2SpKKiIr300kvKzc0d1LYAAAAAwIURcwAAAAACe/ZZZxDOk2e6ypO56tJ5BvIk5+s333TWzgFMNmXKFP3mN7/RJZdcotNPP12JiYlqaGhQZmamZsyYod/97nfavn27SktLzW4qAJxQXi69/jrfpQAARDGLYRiG2Y0YChobG5WZmSm73a5hw4aZ3RwAAAAg+Pbskfbu9V0vztPrrzvTV/rz2mvS/PnBb1+Q8NsewcDnCEBQ1dU5R6N71nS99FLnTTLZ2ea1CwCAGBDs3/aksgQAAADQNyenq/Snt7p0EyYEpz0AAMQKUkQDADBkkMoSAAAAQHC56tLFx3tPj493Tu9LcA8AADiRIhoAgCGFwBwAAACA4OtvXToAAIaaYNWD27cv8Py9e4O7PQAAEFKksgQAAAAQfNnZztRafa1LBwDAUBHsenC9pYjOzZUuu4z6cwAARAlGzAEAAAAIneJiaf58gnIAgNgRqB7cQPSWIvpnPwvu9gAAQEhF1Ii5hoYGPf/883r//fdVXl4uu90uScrMzFRxcbFmzJih6667Ttnc7QMAAAAAYUE/DQACKC93ppp0jQx31YM7mWc9uIHcrPLss85Am+d7X3yx9MtfSl/4QvC3BwAAQsZiGIZhdiMkaenSpfrVr36l9vZ29zRX0ywWi3tacnKyfvKTn+gnP/lJ2NsYSGNjozIzM2W32zVs2DCzmwMAAABggPhtf0K099PMxOcIGOL8pav81rek667zv95rrzlHkg/UySmiX39duvzy0G0PAAAE/bd9RIyY+4//+A899thj7g5eQkKCxo4d677jsq6uTgcOHFB3d7fa29v185//XAcOHNBjjz1mZrMBAAAAYMiinwYAAfhLV9nSEni9CRMGt93iYu8RcL3Vnxvs9gAAQNCZXmPuzTff1KOPPirDMDRp0iS98MILstvtKi8v14cffqgPP/xQe/bskd1u17PPPquJEyfKMAw98cQTeuONN8xuPgAAAAAMOfTTACAAV7rK7m7v6d3d0vr10qxZ/uvBBTutZG/151zbKy93jq7bsye42wcAAP1memDu0UcflSRNnTpVGzdu1Fe/+lWlpqaeslxaWpquu+46bdy4UWeeeabXugAAAACA4KGfBgAB7NsXeP4ddzjrv3m6+GJnnbhQePZZ/9urq5Muu0yaONGZ8rKkxPm6vj40bQEAAL0yPTD3wQcfyGKx6Mc//rGsVmuvy2dkZOiee+6RYRj68MMPw9BCAAAAAIgt9NMAIIDe0kdOny698YZzlNprrzn/feMN6Xgq4KDLzva/PX8pN7/xjdC0BQAA9Mr0GnPHjh2TJE2aNKnP67iWda0LAAAAAAge+mkAEIArfeTq1d7pLOPjnSPVXOkjT64HF2onb8+VcvNk3d3O6Xv29N6+8nLnCMEJE8L7twAAMISZPmIuIyNDknT06NE+r+Na1rUuAAAAgCChBg1EPw0AehUofWRfhOP7treUm3v3+p9HCkwAAELG9MDclClTJPWvDsHDDz8sSe4aBgAAAAAGiQtw8EA/DQB6ESh9ZCDh/L7tLeXmhAn+55ECEwCAkDE9MHfdddfJMAy9/PLL+va3vy2bzeZ32draWt16661atWqVLBaLBbHZFQABAABJREFUrr/++jC2FAAAABjCuAAHD/TTAKCPioul+fP7nuYxnN+3rpSb8fHe0+PjndP9tdmVAtMzTafknQITAAAMmMUwDMPMBnR3d+uCCy7Qxx9/LIvFooSEBJ1//vmaPHmyso/fZVRfX69PP/1UGzduVFdXlwzD0DnnnKMPPvhA8Sf/uDBJY2OjMjMzZbfbNWzYMLObAwAAAPRdebnzzv1A82Oorgy/7YdOP81MfI4AnMKM79v6emfQz7PW3KWXOlNu+hvd9/rrztF8/rz2mjMYCQBAjAj2b/uEILRpUOLj4/XWW2/p61//ut555x11dnZqw4YN2rBhwynLumKIX/ziF/XCCy/Q2QMAAACCoS81aGIoMAf6aQAQEmZ837pSbu7Z43z/CRN638ZgUmACAIBemZ7KUpKys7P19ttv69VXX9XXvvY1jRw5UoZheD0KCwv1ta99TatWrdI777yjnJwcs5sNAAAADA1cgIMP9NMAIMjM/L7tT8rNgabABAAAfWJ6Kkt/2traZLfbJUmZmZlKTU01uUWBkaYEAAAAUaO83HnXvudd85dd5qxx41lPJj5euvhi5532MYTf9v5FWz/NTHyOAPgULd+3A0mBCQDAEDXkUln6k5qaSicPAAAACKa6OumGG3xfZHv22VMvwF18sXM6cBz9NAAYpGj5vh1ICkwAANAnERuYAwAAABBkN9zgvEvf0+rVzguEb7zBBTgAAEIt2gJexcWR3T4AAKIQgTkAAAAgkvlKOznQ9/G8O9+lu9s5fc+eExffuAAHAEBo8X0LAEDMijO7AQPx6aefKi4uTgkJA4srLlmyRBaLJeDjiiuuCHKrAQAAgH6oq3PWoZk4Ubr8cqmkxPm6vn5g77dvX+D5e/cO7H2B4wbbTwMA05WXS6+/7rxZBQAAIESiusdkGMag1k9MTNTw4cN9zsumkC0AAADM1Fvayf4aPz7w/AkT+v+egA+D7acBQNgFqsEaC9eHgjU6HwAA9ElUB+YGa8aMGXrvvffMbgYAAADgra9pJ/ujpMR5kXH1auf7uMTHSxdfzIU4AEDsCvbNMNEi1gOSAACYJCpTWQIAAABDWqjSTj77rDMI5+nii53TAQCIRa6bYTxvWpG8b4YZqgIFJAEAQMiEbcRcRUWF+/no0aN9Tu+rqqqqoLQJAAAAiEh9TTvZ39RT2dnOO//37HEG90hZFfPopwGIeX25GWYofleGYnQ+AADok7AF5k4//XRJksViUVdXl3v62LFjZbFYwtUMAAAAIPL1lnYyJ0e67LKBp54qLuZiGyTRTwOAmK3BGqsBSQAAIkDYUlkahuF+BJrX10cwfPrpp5oyZYpSU1OVkZGhadOm6Z577tHRo0eD8v4AAADAgAVKO9mX1FPl5dLrrw/tFFwYtEjspwFAWLluhomP954eH++cPlSDU7EakAQAIAKEbcTcsmXL/M6zWCz65S9/qVGjRvXpvQ4fPqyf/vSng26TzWZTQ0ODMjIy1NDQoG3btmnbtm167LHH9NJLL2nmzJl+13U4HHI4HO7XjY2Ng24PAAAA4OYv7WRvqac2bZJ+9rOBj6ZDTInEfhoAhN2zzzpvbvH87hzqNVh7G53fl4Bkf1NqAwAASZLFMPm2xri4OFksFm3fvl2TJ0/u0zqffvqppk6dKovFou6Ti/P2wTPPPCObzaarrrpKp512muLj49XQ0KBnnnlGP/7xj9XU1KScnBzt2LFDBQUFPt9jyZIluvfee0+ZbrfbNWzYsH63CQAAAOiT11+XLr/c//zSUmnrVt8X2d54I/TtGwIaGxuVmZkZ07/tzeinDTV8joAoFGs1WOvrTw1I9uVmnro65+h9bgICAMSIYP+2j8nAXCBr167V3LlzZRiGfvCDH+i+++7zuZyvEXNFRUV0ugAAABBa5eXSxIkDXzcWLjQOEgGVyOunRSM+RwCiRn8Dkpdd5n+kHTcBAQCGoGD/tg9bjbloMXv2bM2bN0+S9Nprr/ldLjk5WcOGDfN6AAAAACEXqBZOaWngdffuDV27AABAdCoulubP73v6yjff9A7KSSdSalPbtv+oCwwAMcf0wNyLL76of/7znxozZozZTXErPX5B48CBA+Y2BAAAAPDl2Wedd6V7uvhi6eGHA683YULo2oQhJRL7aQCACLBvX+D53ATUd3V1ztGHEyc605SXlDhf19eb3bKhiQAogAiSYHYDrrrqqn6vc9pppwUsUj5YFoslZO8NAAAADFp2tjNVlK/UU5de6j+9FGks0UeR2E8DAESA8eMDz+cmoL674QbnbzZPq1c76/6REjR4qIkIIAKZXmMuEl166aV66623dOaZZ2rHjh19Wof6AQAAAIgI9fXOCzpcfBgwftsjGPgcAR7Ky50jrfpawwyRLRZqzIX6M9tbzWDqAgdPLHxeAYQcNeYGqbci5Js2bdLq43erXHnlleFoEgAAABA8rtF05eXSa685/33jDYJyAIDwI1Xf0OQvpfazz5rTnmAK12eWlKDhQU1EABEq5gJz69ev19y5c/X3v/9dVVVV7unNzc3629/+pvnz56unp0f5+fn6/ve/b2JLAQAAgEEoLpbmz+duawCIZWbXVAqUqg/RayjfBBSuzywpQcMjGAFQs8+jAIYk02vMhZthGCorK1NZWZkkKT09XSkpKaqvr1dPT48kqaioSC+99JJyc3PNbCoAAABiBSm+AADBZEZNpZO/y1wjVU7mOVKF77zoVlw8tPZhOD+zJSXUBQ6HwQRAqU0HIIRMHzH3i1/8Qr/4xS9ks9n6vE5nZ6d+8Ytf6Je//GW/tzdlyhT95je/0SWXXKLTTz9diYmJamhoUGZmpmbMmKHf/e532r59u0pLS/v93gAAAEC/kOILESrc/TQAQRbOkWr+vsu2bAm8XrSl6mPUzNDX19FVwfosDOWUoJHCFQCNj/eeHh/vnB4oAMqIXwAhZDEMwzCzAXFxcbJYLNq+fbsmT57cp3VaWlqUkZEhi8XSa824cKGwNwAAAPqNYvQRid/2Q6efZiY+RzBNebkzSBZo/kBH4/ga4e3vu+zCC6X160PTjnBi1Ezs6O3Y2bhR+tnPgv9Z2LPHGfQjc0Jo1Nc7g2n92W+hPI8CiErB/m1v+og5AAAAICZRjB4AEArBqKl0Mn+j4jZt8v9dtn69NGvWwEaqhFJ/RzsxaiZ29Da66mc/C81nIVBdYEZqDt5AaiKG4jwKAB6iMjDX0dEhSbJYLCa3BAAAABggOvwYYuinARFiMDWV/PEXnPqP/wi83h13RE6qvoGkj+YmmtjjL73kL38Z3s8C6c6Drz8B0FCcRwHAQ1QG5vYev0iRnp5ucksAAACAAaLDjyGGfhoQIQZTU8mXQMGpzZsDrzt9ev9HqoTKQEa+cRNN7PE3uqq3mqu9fRYYqRmZ/AVA8/KCex4FgJNEXWCura1NixcvliRN4GIFAAAAosXJF2SCfeEUMBH9NCDC+Bv1M5CRar0Fp0pLe/8uCzRSJRwGOvKNm2hi18mf2YF+FhipGdkCBUD7ch4l1SiAAUoI9wbnzZvnc/qtt97a652Vra2t+uyzz9TS0iKLxaIFCxaEookAAABA8NTVOTv9vgrOP/vsqcXozUrxhZhGPw0YYlyjfvbscY7kmTBh4EGx3gISjzwi/fSnkf1d1peRb77+f1w30axe7R0kiY93/o3cRBM7BvpZCBT4eeMN3+sM9POK/nEFQE/mCoDabP7Po4F+35sxIhhA1LEYhmGEc4NxcXGyWCwa7GbPOeccvffeexGTJqWxsVGZmZmy2+0aNmyY2c0BAABApLjsMv8XcVwXZIJx4RRBE4u/7YdqP81Msfg5whAW7d9l5eXOEUuB5vtrc339qTfRcAE+NvX3szDQz91gPq/ou9dfd45i9Oe115yjJn3pyzkRwJAS7N/2YR8xN3v2bK9i4GVlZbJYLDrnnHMCdt4sFotSUlJUVFSkL37xi7r22muVmJgYjiYDAAAAA9Pbnbh79jgvrLgegEnopwEIqC8jvCP5u2wwI9+COfoQ0a2/nwVGaka2gaYn7evve0Sn8nLnscu5HiEW9sDce++95/U6Ls5Z5m758uWaPHlyuJsDAAAAhA6piBAl6KcB8HLyhcmhEJwabProSA48Irz6+lkYTI1C0p2H3kADoMH4fU/wJ/KQnhRhFmd2AwAAAIAhazAXZAAA6IvycmdKtj17Bv9edXXOFG0TJzpTvJWUOF/X1zvnFxc7U7tF44VkV3CxvNyZoq683PmaC67RL5jHQDC5Aj/x8d7T4+Od0/syUjPQ5zVS/+5o8uyzziCcp94CoH39fe9r//R2jkV4+No3gepBBloPGCACcwAAAECoDOaCDAAAgYTiAm9fLkxGu2gOLg4F4Qwkm+Hkv28ggR9Pvj6vkfh3R6uBBOx7+32fk+N//8TCOTaS+Tt2Nm1yjpTzHDkpnUhPumkTxxyCzmIMtrr3IM2dO1cWi0XLly/XmDFjzGzKoFDYGwAAAD7T0tTXn5qKiLQoEY3f9kOnn2YmPkcIucsu85+C7Y03+v9+5eXOi46B5hPMwkCFIk1csI+Bwejt7wtmGthI+rtjVaDf99/4hu/9c+GF0vr1/t+Tc2zo+Tt2pk2TNm/2v15pqbR1K8dcjAv2b3vTA3NDBZ0uAACAGNaXi03RXJcnxvDb3jybN2/WBx98oA8//FAffvihysvLZRiGbr75Zi1fvjxk2923b5+WLl2qt956SzU1NRo+fLjmzJmjH/7wh5o+ffqA3pPPEUIqGEG0k28mef1150gAf157zTlyJ5yowzR0DPVAcriCZZH2d8e6k3/f97Z/AjHjHBtLBrNventfjrmYEOzf9qSyBAAAAAarL2lpSJ0F9GrevHn6z//8Tz355JPavXu3wnEf6bp163T22Wfrr3/9qyorK5WcnKzq6mo999xzOv/88/XCCy+EvA1Av+3bF3j+3r3+5/lL5ZWbG/g9w1kXlVR9Q0t5eeA0cQNJazmYYyDYQvH3+RNJfzdO/X3f2/4JhNrTodXbvikt9Z2etLQ08HoccxggAnMAAABAf3nWDwnnxRhgiEtKStK5556rO+64Q0899ZRKe7sYMkh2u13XXnutmpubNX36dJWXl8tut+vQoUO65JJL1NnZqZtvvln79+8PaTuAfhs/PvD8QBd4/d1M8rOfRU5dVOowDS2hCCb19RgIZk07f8IZLBvMsY/Q623/zJoVGefYWNTbvnnkEd/1IB9+OPB64TzXYEghMAcAAAD0la87+Hu7SMhdlECfHTp0SJs2bdL//u//6pvf/KYyMjJCur0//elPqq2tVUpKil588UUVH78oNmrUKL3wwgvKzc1Ve3u7li5dGtJ2AP1WUjKwIFpvN5P86le+L0w++2zw2t6bYNzwwgXSyBKKYFJvx0BOTvhGXYYzWDbQYz9WmH3s97Z/Xn7Z/HNsrOpt35x7rjPtbHm5M61oebnz9XnnRc65BkNKxATmduzYoW9/+9uaNGmSMjMzlZiYqPj4+ICPhIQEs5sNAACAocpXx97XHfxbtgR+H+5cRhQLdz8tKSkpiK3v3fPPPy9JuvLKKzVmzBiveVlZWbrpppskSStXrlT3yUECwGzPPtv/C7y9jeyprfV9YdJVLzUcQpGmkwuk4XXyb6hQBZMCHQN9GXUZrCBOuINlAzn2h7pIOvYD7Z/sbPPPsbGsL8eOr/IDgz3XAD5YjHAk7e/Fyy+/rOuvv14dHR39qiFgsVgipnNEYW8AAIAhoq7O2cF6880T0y69VPrlL6UvfMH/evHx3nf3x8c7O2xvvBG6tiIk+G3vFAn9tLlz56qsrEw333yzli9fHpT3dGloaFD28Qthf/7zn3X77befssyrr76qK6+8UpK0ZcsWTZs2rc/vP6Q+R+XlzmDJhAmMxohEe/Y4g1V92T/l5c4L14Hmm72P+9pGX5/Lyy5zXhDl+9gc/n5DuS56f+MbvucNNihx8jHQ22do40Zn6tZgtqW+PnR/nz/9OfaHukg89geyf/i+DY+BHjv9PddEwncqgibYv+1NH3J2+PBh3XjjjXI4HMrKytLll1+u9PR0PfbYY7JYLPrZz36mhoYGbdu2TevWrVNPT4+mT5/u7hwBAAAAQeXvrsfa2sDrTZsmbd584nWs37mMqBYL/bTdu3e7n5eUlPhcxnP6rl27+hWYiyQtLS1+58XHxyslJcX3snV10q23Su+8I8mZcifV40JzoPeNi4tTamqq+3Vra6vfAK/FYlFaWtqAlm1ra1NPT4/fdqSnpw9o2fb29oAB5v4sm5aWJovFIklyOBzq6uoKyrKpqamKi4uTiovVMWaMOjs7JT/7xL1sSYk6LrlEne+8I3n+X8TFSV/8ojRypFK6uxV/fORPR0eH8339SElJcS/b2dmpjo4Ov8smJye7R9R6Lbtnj7R/vzRunPNi56hRSr7kEiW8+67U3a0uSQ7PNqakOL9jj38ukyQlHr+BpuvNN53LenKlwNy6VUmTJysxMfH45G61t7f7bW9iYqJ7FG9/lu3p6VFbW1tQlk1ISFBycrIkyTAMtba2BmXZgMf9IJaNu+46pa5Zc2JZSXr7belrX3Om8Fu50nlR+/PPFTdhglKnTnUvO6hzxMiRzockS2ur0jxGXbZJOuWoX7hQ2r5dkuQ+klevVtvXv66el17y+/cFPO6Tkrz+vvQpU9wX5EN2jhg9Wl3H/25fx777uNdJx/LJx1ygZX3wPO7Dco7oZdmuzz6TwzMg6nL82E/67DMlTp7sXLarSw7HKWcJt6SkpOCdIzw+l4kdHYGPe4/v20Q5z2u69FL1PP202jyOv5NF3TnipN8Gpv2OKC52H5/9+h1x2mnq8TzmPv3Ue1mP5+2SunfscH8GAr2v6b8j1PuxbOY5wvP/akgxTPbDH/7QsFgsRklJiXH48GHDMAxjx44dhsViMeLi4ryW3b9/vzFnzhwjLi7O+NnPfmZGc/2y2+2GJMNut5vdFAAAAHjavdswXnvNMMrL+7asNLBHebnz0ddtIWLx2z5y+mlz5swxJBk333xzUN/XMAzjpZdeMiQZkozt27cbhmEYCxcuNKxWq/Hd737XMAzDaGxsdC/z4IMPBny/9vZ2w263ux+VlZUR8zly/Q2+HpdffrnXsmlpaX6XnSMZRny8YVx6qWEYhpGbm+t32XPPPdfrfceMGeN32cmTJ3stO3nyZL/LjhkzxmvZc8891++yubm5Xsu6Pk++HmlpaV7LXn755QH/3zx99atfDbhsc3Oze9mbb7454LI1NTXuZW+//faAy+7fv9+97A9+8IOAy+7YscO97OIf/jDgshs3bnQv+/vf/z7gsmvWrHEv+6c//Sngsq+++qp72WXLlgVc9oUnnnB+ziTjhQDLSTKWuT6XpaXGq70s+6c//cndhjVr1gRc9ve//7172Y0bNwZcdvHixe5ld+zYEXDZH/zgB+5l9+/fH3DZ22+/3b1sTU1NwGU9z5PNzc0Bl/3qV7/q9RkOtGy/zxEej9wA7xvSc4TH77lzA7Qh96T2zgmwbEydIxYvDrhsRJwjXnjBvewLd98dcNll3/uee9lXX3014LIRcY5wfSbj4439s2cHXDbqzhFz5ngtO6R+R8j7fHJ5gP8ziXOE69GXc0SkCHYf0fQac2+99ZYsFou+973vaaSfCLLL2LFj9cYbb2jSpEn69a9/rbfeeitMrQQAAEDU6UutiZNri/RW16a0NHD9EF81CYAoFAv9NM+7tFNTU3Xs2DE99thjam5u1kMPPaS6ujqvO7Wbm5sDvt/SpUuVmZnpfhQVFYWs7aZyjT4abE0mmMfjcx2xrNYTdZjuvrv35bu7vUetI7b5q/kWa957LzbO1fn5g5sfqbq7pbVrzW4FBiI+XsrNNbsViHCm15jLyclRQ0OD3n//fZ1//vmSpM8++0xTpkzxW5vgr3/9qxYuXKgrr7xSL7/8crib7NOQqh8AAAAwFASqNfHMMwOrI7dpk/TTn4a3fgjCjt/2kdNPC2WNuWeeeUbf/OY3JUl79+7V+PHj9e///u9auXKlbrzxRj3yyCPq6upyp7T69a9/rXvuucfv+zkcDq/0WI2NjSoqKoqIz5FXqqiTUpj5TUH11lvSNdd4vU+cJHdI57XX1DJ7tt9tksryhEGloPryl6U1a3ymnUx9662oSEHl4pWm7tNP1TFliv9lP/tMCWecIemk1HM+PpdJkhKPP++aPl2OrVt9p+l8+eXgpqnzs2zMprLcs0dx06fLM+zrteSWLe60iZKfc0R5+SkpFqUBniOO13xre/PNE6ksv/Ql6ec/l+bMcS/vmSCtTVLPSe30FJHniJOX9UiJmCrneVuXXqqOn/9cnTNn+n3f1F27FHe8VlbEnCPKy0/5LPhatqurS47LLvN7rkx6/XX3cR/WVJZ+lj3luD/pvOZOZSlnGta2f/5T+rd/8/m+UXWOUASlsgzm74j6eumWW6R33jlxPrn0UrUvW6buri6vlOCSnOeh5cuVftpp7kn9Pkfs3OnzXOlzWVJZBs2QqzHX1NQkSV4H8MkHnefBIsmd13/Tpk1haCEAAACiTnm5d/DM5f9n777Do6jaNoDfm7pppEIIIaETeklApYamFBEBG0UIReAV9aMo+oKFIgq+KqgIAgrBCApIV1A0AUKXErqQUBKCECAhhfQ63x/rDrvJ9mzP/buuvVh2zsyc2dmZzJlnznPkPT2GDgWOHlWeJh9Xrn9/9QG9Tp1kT/AbOmA4kY2oCe20yjdaACAmJgYxMTFVPgcAT09PjctzdXUVb3hZGw8PD9nNWlUPJPz0k2zMLsWyANC6teaFNm2q142Syr8XY5V106P3lz5lpRrG9KlOWX1+J643b8JV8WaeXEWF7Cbf9evi3yAXFxfxpq82pirr7Ows3tDWWjY1FRpLpqQA/wbmnJycxBvw2n6XTqtXw6nyAzRPPin7nVf6vTo6Our8G9anrIODg0nKSiQSk5QF9LvpqbZshw5VrqE8gEfXUJrG6MzMhLu685OKB590Okf4+gK//w43Vddsaq713LTVU4FVnCNUlX3uOVlPOUWxsXBJT4fGI/nGDVmWCVj4HPHv3yrnvXsfnSO0PATn5OQEp59/BkaOVH3sK6xT6XyihdnOERrOaw6AbLxCHZZt9eeIapa12usIDw/Z+aTSuUYKyB4UrXw8HjgAvPKKrE35L53PEZmZcB01Cq46niv1OZ/Y2nWEPbB4Kkvff380Dx48ED8LUOjqmZSUVGUeeSMxMzPTxLUjIiIiIpugb0rKQ4eUb8YAj4J2CxfKbiAp6tdP1uCRY8pKsnM1oZ1Wt25d8f3du3dVlklLSxPfB9pqKiy5UaMePYAgFxsru5GpirpUcIrpe8m0tP0tu3bNPPUwhSZNNE9X02NJ6+9S/gBNUhKwZ4/s399/Z692c/npJ+3XUKroe37Sh6prNkPrae3kD6apusbVlupV3TFnbob+Fv4NxNrksc+/t6ZRuX1oapXPNZqOR0NTgpvyXElmZ/HAXMt/n4C6cOGC+JmXlxcaNWoEANi4cWOVefb+GxUOYK5WIiIioppDVeNK3Thy1blOTE+33YY9kZHUhHZa2L89AwDVgcbKn7do0cLkdTIZQ28OWermtblvplmLytttaPDKFlTnRrQuv0s+QGMZhgRHTHHz2hT1tAXVHSu5Ooxx3jbGb8FWj317DRZbgi7jjJuDsR+uscS5kkzK4oG57t27QxAE/Pbbb0qfDx8+HIIgYOnSpVi5ciXy8vKQkZGB5cuX44svvoBEIkHv3r0tVGsiIiIiMpimhrs+wbesLPVPDb7/vvobft27a66f/EanrTbsiYygJrTTfHx80LZtWwBAfHy8yjL79+8HAPj5+aGNhvGwrJ6hN4fMffPaWm6mmZu67a5d2757URh6I9pegyr2RJ9rKEv2DLW3az1twfxVq4wf/DHmedueewlrw/OaYVS1Ha2lV5muD9foGtS21uOjpj5MZQyChR0/flyQSCSCs7OzcPPmTfHz+/fvC35+foKDg0OVl0QiEdzd3YVLly5ZsObKcnJyBABCTk6OpatCREREZFyJiYKwZ48gJCVVbzkPHghC//6CADx69e8vCJmZmqf17y8Ijo7K0xwdBaF7d+XPKr9OntR/mf37G+c7I5vGa3vraadFRkYKAISoqCid5wEgvpKTkzWWXbhwoQBAkEqlQmpqqtK07OxsoU6dOgIA4ZVXXtG77lb1O0pM1Hy+rM753Vh/IwShZpybVX1fmrZb/jdL1d8ye5GUZLzfENkeU56faiJdzqPGPOaMed7mb6Fm0+d6Ql3b8cQJ6/oNaTo+NLV/VbHk8aFq3+hbfztg7Gt7iwfmBEEQ1q1bJ3z33XfC33//rfT5qVOnhMaNGwsSiUTpFRgYKOzdu9dCtVXNqhpdREREZNwbhbbEmNut7WJb33VpapgYGnzT9NqzR7ZeVTcfasKNTjIYr+1lLNFOy83NFdLT08VX165dBQDCiBEjlD4vKipSuwx9AnPZ2dlC7dq1BQBCRESEcPXqVUEQBOH27dtC//79xaDdjRs39N4Wq/sdGTvopcsNGX3+Ttj7Ddnq3kRk8IrsmS7np5p6ba8vc17jmuK8XRMe0CBlhgR41P1OwsN1ax+ai6bj0ZDfurmPD0MenrXjY9XY1/YSQRAE8/bR009paSn279+PixcvoqysDM2aNUP//v3h7u5u6aopefjwIby9vZGTk4NatWpZujpERES2JSlJlpqhadOqqWT0nZaZKUtf8e9YRwBk6Z5++ulRKhBD1qdpHlOwhu0eMECW9kMxj72jI9CzJ+Diot+6kpJkKW7MKSlJ+766elWW9sNc+5VsAq/ttTNVO23cuHH4/vvvtZaLjo7GuHHjVE6TSCTi++TkZDRs2FDjsg4ePIhBgwYhPz8fAODt7Y2HDx9CEAQ4Ozvjhx9+wEsvvaTzNshZ3e8oK0uWxknTuVsf6v5G9OsH/Pij9r9Jlf32mywNmjp79shSztkqdd9X+/ZAQoL6+Wx9u4l0oen8JAj6n0/IPNe4pjhvG/tvFVkXfdqc/fo9Su9prHalLu1DU6h8PGrbBnX1NPfxoW7fdOkCHD6sfj5Lfc8mZvRre6OE9yygrKxMiI6OtnQ1RFb3NCQREZG10Tf9gbHTHmpLF6Fu2vXrxu0RYKrvxNjbre0Jfn3XtWmT5uUZ+urRo8Y9qUemx2t7w1W3nRYVFSUA0PrStA7Fctp6zMldu3ZNGD9+vFC/fn3BxcVFqFu3rvDiiy8Kp0+fNnhbrPZ3ZIyeV9p6SRhybrbnHnPats1et5tIX6rOTzWwV4bNMOV5m72Eq9LU5rT2HqWGtjl79NC/XRkebv3njD17NG+DvGefuv1qjuOjOtcu5u6ZaCZ2mcpSH8XFxcLy5cuFhg0bCo6OjpaujshqG11ERESWZmgwyRRpDzXdKFS3TH//6uWF1zf4Zi3brS0NiL7rqk5KSk31Z0pKMgFe2+vPWttplmTXvyNtN5Q0vTTdRLKlG/D63ATV9n3Zwk1EIkuw54C9vbCl87atMvTBTWtiaJvTwUH/dqWmccathbZz24kThm+DsYK0prrWs2F2lcryzJkzSElJQVlZGZo0aYLw8HC1ZfPz87FixQosXboU9+7dgyAIkEgkKFfsSmlBVpemhIiIyBL0SU2hLf2BLejRAzh6VP80XiNH2u93oomm7wtQn8JE/p1pStnBlJRkRDX92t6e2mmWZNe/o+qkkdKU2syUKZoMTZtdmS6po1WtW9P3dfIk8N57TN1GVJm9p7i1Rvqm72fqSdPTlOoR0JwG0hqYYkgDTe1K+XZbe/vQ2PvVkOsTTbTtN132gZ2xi1SWMTExQv369QUHBwelV4sWLYTDhw8rlc3PzxcWLlwo+Pv7Cw4ODuLA4t7e3sLbb79tieqrZNdPQxIRUc2jb5oMQ1NT2PPLFD3HzP1S9QR/5acW9Xlt2qT+yT9der4xpQ2ZSU29trfHdpol2dzvSN8nrA3txa3L8o15vjd2TwNDe4foMh//zhEpY4858zE0E4gcz1+mYQ+pkA3pNa6tzampXWkr1LV/td1DUbdfTdF7VdMya2DmGptPZfnJJ5+IDTx5403x5e7uLpw9e1YQBEHYvXu3UK9ePaWyISEhwmeffSY8fPjQ3FXXyOYaXURERIJQtXFl7PHNDE2HWJ2XPQTErGW71aUB6dOnejdjNTXc2agnK1ATr+3ttZ1mSTbzOzI0DZamGzLWlNrM0LTZqlQnSFADb2ARGYU1nU/smaHjVZNpVSedoLWM86Xtb6eqNqcx2pW2ovI26Dr+nCJTPcTAh2eV2HQqyytXrqBdu3YoLy+HIAjo0aMHHnvsMTg7O+Pq1avYvXs3ioqKMHDgQMyYMQMDBgyAIAgQBAGtW7fG22+/jZEjR8LJyclcVdaZXacpISIi+6MuzUFpKRAfr186heqkXzQ0taGmaZrSHqpLIalpmT4+QHa2+dJOmiLdoyHbrSkNiKaUNZrWZacpLcj+1LRre3tup1mSzfyONKVS0uW8rSpVlC6pzfRNl2aI6qTPSkqS3YJSrKMx0upZe2otImvDVImmZ2sp68zx98NaVPfvmLV8P7pca1T++1jd6xNbpW2fq9qvpk77y2sXADaeynL69OmCRCIRXF1dhV9++aXK9JSUFCEkJERwdXUV2rVrJ0gkEiEoKEj48ccfzVlNg9jM05BERESCoPqJyOqkKNT0UpWaQpf0B4ZOk1P15JYhy7xxQ/8eAdqe8FPXu60634mxt1uXJ2D1XReRjahp1/b23E6zJJv4HZk6TZyqvxPm7HlRnZ4GlXv9Vye9FBFVXw3qlWF21TlXmnN/1NSee9Xt+a1vqurqUrU+Q9qINbldac4e/aQzm05lGR4eLjg4OAgzZsxQWyYmJkaQSCSCg4OD0LhxY+HevXtmrKHhbKLRRURE9kufMeGqk6fekJe6dIi6pj8wRdpDQ5apbxCquvnYrWW7DcWbJ2TDatq1vT230yzJJn5HhqRLqi5zpqWrzjWPsdJfEhFZu+qcK82ZLrGmnn8NfcjS3IFMXdZnSBuxJrYrDQlK1tTjw4xsOpWlr68vHj58iD/++AN9+/ZVWSY1NRUNGzaERCLBqlWr8Morr5iretViM2lKiIjIdqlK2aEuJeVPP8kuxVRNmzABeOkl49ZNl/Qm9pz+wNA0Xvb8nRDZsJp2bW/P7TRLsonfkSHpkmxpfYDmVFhA1WkODkBFhfrlnTwJvPce0+oRkX1Rd67Ulr7fXOkSLfH3w9poajuqmlbdVJD6pgytqaknTUmf+wVM+2tyxr62N+sgAA8fPgQABAYGqi0TEhIivu/QoYOpq0RERGRd9A2+jRolu/hVFBsruyCTv688LT9fcx0cHY0zvpn8c7lmzey3saRq23x9ZQ0QTRfT9vydEJHNYDutBmveXHZNoe7vu7H/Rl2/rnn6tWvGX6e2a5TK0zp0ABIS1C8vPV3733ciIluj6VypaQxpc53/LPH3w9poajtWnpaUpLwv5crLZZ9fvSorr+/9B3UBHl3XR/rR536BLvcfrElNGitSDbMG5gRBgEQigYODg9oyEolEfO/u7m6OahEREZmXsYJvQ4aofnpRfvGrSnm5bB51PdwiIwFnZ91vXsmn2dpFoDkx+EZEVo7ttBpOl4drjKVJE83TmzY1/jq1XaNUniYImntlyOuo6e87bzYRka3RdK40598JdSzx98OWaQtknjkDvPGG/g//quv5xsCp9bCm+w/GCvzaKbMG5oiIiOyKppsu5gi+aUopos3rrwPu7uqDbLrevGIPMCIiIttmzodrzN1DT5E+PQ0MrSNvNhGRrTM0E4gmxnhYwZJ/P2yRtkDm11/LHtRVpMvDv+p6vjFwavuM+VCRoVmfaljKU7OOMefg4ACJRIJnn30WPj4+asutW7dOp3ISiQRr1qwxfkUNYG3jB+RrSFPm6OgIqVSqU1kHBwe4ubkZVLagoADqfl4SiUTpSVt9yhYWFqJCQ85/Dw8Pg8oWFRWhXPGPezXKuru7i08VFxcXo6yszChl3dzcxCeZS0pKUFpaapSyUqkUjo6OepctLS1FSUmJ2rKurq5wcnLSu2xZWRmKi4vVlnVxcYGzs7PeZcvLy1FUVKS2rLOzM1xcXPQuW1FRgcLCQqOUdXJygqurKwDZ0+sFBQVGKavPcW/X54irV+GRliZeaIhlr14FkpOBxo2VLhg9PDzEi5OikBCUN2okm5CZCYwfD8TFPSqrMK5b0UsvoVzxQqNvX2DdOmDcOGD/frhXVEDe76DYwQFljz8OHDumssruwKOyANSfIQA3APK+DiUA1B/JgNuVK3AICwOuXkXJ5csobdBA7cUyzxEyPEfoX9bmzhHgdYQhZY19jlD8rizF2q7tTc2e22mWVNN+Rzqr7hgo5uiNZmgdOb4OEdEjxn5YgWNo6cfQcQM12bMHGDhQv/Xxb6D1MFcPNmsfs9JARr+2F8xIIpEIDg4ORn1Zi5ycHAGAkJOTY+mqCIIgCADUvgYNGqRU1t3dXW3ZyMhIpbIBAQFqy3bq1EmpbIMGDdSWbdWqlVLZVq1aqS3boEEDpbKdOnVSWzYgIECpbGRkpNqy7u7uSmUHDRqk8XtT9Pzzz2ssm5eXJ5aNiorSWPb+/fti2alTp2osm5ycLJZ96623NJa9ePGiWHbu3Lkay544cUIs+7///U9j2f3794tlv/76a41lf/31V7FsdHS0xrKbN28Wy27evFlj2ejoaLHsr7/+qrHs119/LZbdv3+/xrL/+9//xLInTpzQWHbu3Lli2YsXL2os+9Zbb4llk5OTNZadOnWqWPb+/fsay0ZFRYll8/LyNJZ9/vnnlX7Dmsra9TkCEAT5q39/IfLxx9WWdXd3F4T+/cXygzR8ZwAEwdFRVr5/f+F5LWXzFOoRpaXsfYWyU7WUTZaXdXQU3mrYUGNZniNkL54jZC+eI2QvXkc8elnyHGENrO3a3tTsuZ1mSTXtd6S3pCRB2LNH9q8uHjxQujYTILueEzIzH5VJTNRvmcasY2Kict0qv4xVJyIiW9G/v6ydrHgulLebBcHwc7a+fz9qqsxM1X83N23S/PfK0L9l6tan+HeaLEPTNZS241Rf2q6HNL327DHudhuZsa/tzZ7KUjBiBz3FcQ6IiMjOKD7Jow8NvZiUxMYCmv6OFBdX7V6viaZx3apL1XhwmshTeXz9tWnqQ0REdoftNDI7fdNfa0p99OOPpkkhqU8dOb4OEdEjSUmq28fydnPPnsChQ48+1+eczeETdKMuBWlSkub51I1Hry1lKMedt16GDJ2iKXWpJtquhzSpYSlPzZrK8ubNm0ZfZoMGDYy+TENYW5oSpqDSvyxTUDFNHdPU6V9WPO7/DaLl16tX9Q/pv2kiHZo2hVvbtrLPMjNR8NJLEFSlexQESCZMgLvCtIJ+/SBER8ueoamUQlLSrx/cN2+WTRs1CoV796JCcZkffABERorlFROkFQJQf4ZQLlsEQFNYTJ+yKtNTdu0KHD8OKJ6zHBzg3q8fJBs3AiNHonjv3kepLOXfl7zhcu0a3P75Bw7NmwPNmikfy9euATduKKXq5DmialmeI5jKEuB1hCFlmcrS9tlzO82SatrvyKSSkoCwMPXTNd1ENFf6LG11tPL0TERERvXbb8CgQeqnOzgot32Z8tC8NKWd/Oknpgy1J9quTzTRlLrU0PVZwzWbgYx9bW/WwJw9Y6OLiCzCkDE2NM2j7zRNuaj/DZSpnDZypPqLQMC409q3BxISdPtuTE3TBYguF7988oyIyCx4bU/GwN+REWm7wauJOQNiHF+HiEjG0GAAH2IwD13G6+P9B/tgiWsoOw38MjBnpdjoIiIAxg16aZqmy+CsleczNIhm7ABbdQYathaaAmxA9S5AePFLRGRxvLYnY+DvyIjM/bS3oXS50UlEVFOoujlfuadcZeY8ZxPvP9QElujBZqeBXwbmrBQbXaSWIT2a7IEpttuQwJY1BMoMDXoZGhBTN8ZGaSkQH2+8nmi2FGALDwfOnau6DT4+QHa2cQNsgF1egBAR1SS8tidj4O/IyNQ9fa3tmtQSvS94rUdEpPrmfPfu1nfOJrJ3lurBZmfXQwzMWSmbbHQZGjgxV6BD2zRrqYe6aYb0aLKH78QU221I0GvFCmDqVOsIlAHGnabt5oOqp120PZVm706eBN57r+q+++Yb4NVXTRNgs7MLECKimsQmr+3J6vB3ZGSanr7WdC3OFJJERJZVuW3MtL9E5mVrPdistJOL0a/thRrs2rVrwsSJE4WQkBDB1dVVCAoKEkaMGCEkJCTovaycnBwBgJCTk2OCmlZDYqIg7NkjCElJjz578EAQ+vcXBFmYQfbq318QMjMNn8+c065ft456aJvWv78gODoqT3N0lH1uz9+JKbZb0zLVTfP3138eQ6d17678GV/aXz16mG//9O//6DyWlFT13Kbpc23TiIjILlnttT3ZFP6OTETVtZm8zaCqLUFERNaF52zbp+q+MVk/a7+/pUvMwoKMfW1fY3vMHTp0CIMGDUJeXh4AoFatWnj48CEAwNnZGevXr8eLL76o8/Ks7mlITT2MDEmBZ+4eQZqmGZp6zpzTDOnRZA/fiSm225bSJdZEphhrDTD+NI7pQUREerC6a3uySfwdWYA1Pe1NRESa8Zxte3TJkkVkKCvvTctUlkaQk5ODZs2aIT09HR07dsSmTZvQrFkz3L59G+PHj8eff/4JqVSKv//+G40aNdJpmVbX6DI0/766m+wMjhBZF0OPVUdH4wZpTTnWmimmERER6cDqru3JJvF3RERERHbFygMnZMOSkoCwMM3TLXyPj4E5I/joo4/w3nvvQSqV4sqVK2jQoIE4LTs7G82aNUNGRgYmTZqE1atX67RMq2p0afshE5HxGbsXZHUCYup6t0ZGAs7OpumJxkAZERHZEau6tiebxd8RERER2Q0bCJyQDfvtN2DQIPXT9+wBBg40X31UMPa1vYMR6mRzNm3aBAB45plnlIJyAODj44MxY8YAALZu3YpyxRvbtuL6dUvXgABZoMbRUfkzR0ege3fL1MdcTLHd6pbZv7/spWqav7/+81Rn2s6dj4JpcvIA2k8/GX+ar6/saaSkJNkfp6Qk2f99fdXPt2WL+nk0LU/TNLlmzWR/IFVdhGmaRkRERERERERE1k3b/eZr18xTD7JPTZpont60qXnqYUY1LjCXnZ2NCxcuAAB69eqlskyfPn0AAJmZmbh48aK5qmY82n7IhgZODAmOmGKauQMuxg7U7Npl39+JKbbbkKDXyZPWEygzxTQ5VUEvbfMZGkRjgI2IiIiIiIiIqOapgYETMqPmzTXfG7bHe5FCDXP8+HEBgABA+PPPP1WWSUxMFMts3LhRZZmioiIhJydHfN26dUsAIOTk5Jiy+rrr318QHB0FAXj0cnSUfZ6ZKftXcZri54bMZ85pN25YRz20TZNLShKEPXtk/8rZ83diiu3WtExt0wyZpzrTiIiIyObl5ORY17U92ST+joiIiMiuaLpvTFRdutwbtiBjX9vXuDHmdu7ciaFDhwIALly4gDZt2mDy5Mn46aefMGbMGKxYsQK5ublintAvv/wS//d//1dlOfPmzcP8+fOrfG414wdkZRk2JpSh88mZc5q11EPbNE3s+TsxxXYTERERmQHHBiNj4O+IiIiI7Iou942JqstK7w0b+9q+xgXmfvzxR4wePRoAcO3aNfj4+CAgIECc/uDBA9SqVQvOzs4AgI8++ghz5sypspzi4mIUFxeL/8/JyUFoaChu3bplXY2u69eBGzeAxo21dzk2xnxERERERDbu4cOHCAkJQXZ2Nry9vS1dHbJROTk58PHxsb42IhEREVF18L4x1UDGbiM6GaFONs3f3x9jxozB1q1b8fLLL8PPzw9lZWVa53N1dYWrq6v4/4cPHwIAQkJCTFZXIiIiIiIyn9zcXAbmyGC5ubkA2EYkIiIiIrIXxmoj1rjAnIeHh/i+sLAQABATE4OYmJgqnwOAp6enTsutV68ebt26BS8vL0gkEiPVlkxJHuXmE6z2j/u65uC+rjm4r2sW7u+aw1r2tSAIyM3NRb169SxWB7J91tJGtJbjivTD/WabuN9sE/eb7eE+s03cb7aJ+03G2G3EGheYq1u3rvj+7t27aNOmTZUyaWlp4vvAwECdluvg4ID69etXv4JkdrVq1arRJ5WahPu65uC+rjm4r2sW7u+awxr2NXvKUXVZWxvRGo4r0h/3m23ifrNN3G+2h/vMNnG/2SbuN+O2ER2MtiQbERYWJr5PSkpSWUbx8xYtWpi8TkRERERERERERERERGT/alxgzsfHB23btgUAxMfHqyyzf/9+AICfn5/KHnVERERERERERERERERE+qpxgTkAeOmllwAAu3btwq1bt5Sm5eTkYP369QCA4cOHw9HR0ez1I/NwdXXF3Llz4erqaumqkIlxX9cc3Nc1B/d1zcL9XXNwXxMZH48r28T9Zpu432wT95vt4T6zTdxvton7zTQkgiAIlq6EueXk5KBZs2ZIT09HREQENm7ciKZNm+LOnTuYMGEC9u7dC6lUir///huNGjWydHWJiIiIiIiIiIiIiIjIDtTIwBwAHDx4EIMGDUJ+fj4A2cB9Dx8+hCAIcHZ2xg8//CD2rCMiIiIiIiIiIiIiIiKqrhqZyhIAevbsiXPnzmH8+PGoX78+CgsLERgYiBdffBHHjx9nUI6IiIiIiIiIiIiIiIiMqsb2mCMiIiIiIiIiIiIiIiIypxrbY46IiIiIiIiIiIiIiIjInBiYIyIiIiIiIiIiIiIiIjIDBubI6ty9exdffvklnn76adSvXx+urq7w9PREu3bt8N///hd37941+jp37tyJN954Az179kRQUBCcnZ3h6emJNm3a4M0330RqaqrWZVy/fh2vvPIKQkNDIZVKUa9ePYwcORJnzpwxen3tha3t63nz5kEikWh8DR482Oh1tgeW2NfqDBgwQNxf69at01iWx7X+bG1f87g2nCX2tTH2F49rw9ja/uaxTcTzna1JSEjAihUrEBUVhRYtWsDBwQESiQTjxo2zdNVIA2u69iXdGeMeEFkHfdr3ZH68JrdtgiDgxx9/xKBBgxAUFARXV1cEBwcjMjISCxcuRElJiaWraNsEIivj6uoqABBftWrVEpydncX/+/n5CQcOHDDqOlu3bl1lnS4uLuL/PT09hd27d6ud/+DBg4Knp6fS/PL3zs7OwqZNm4xaX3tha/t67ty54j4NDAxU+Xr55ZeNWl97YYl9rcqGDRuU6hEdHa22LI9rw9javuZxbThL7Ovq7i8e14aztf3NY5tqOp7vbI+3t7fSeVb+ioqKsnTVSANrufYl/VT3HhBZB33a92QZvCa3Xbm5uULfvn3F40sikQg+Pj6Cg4OD+Fl6erqlq2nTGJgjq+Pk5CRERkYKP/zwg3D//n1BEAShtLRUiI2NFZo2bSoAELy9vYW0tDSjrXPGjBnCsmXLhIsXLwr5+fmCIAhCRUWFcObMGaF3797ihdnt27erzJudnS3Url1bACB07NhRSEpKEgRBEP755x/hySefFAAIUqlUuHHjhtHqay9sbV/LLygiIyONVp+awhL7urLMzEyhTp06QsuWLbVeuPO4Npyt7Wse14azxL6uzv7icV09tra/eWxTTcbznW2qXbu20KlTJ+H1118X1q9fL4SHhzMwZwOs4dqX9Fed+wJkHfRp85Hl8Jrcdg0ePFgAIPj4+AgrV64UHj58KAiCIJSUlAjnz58X3nrrLSE7O9vCtbRtDMyR1Tl06JDaaefOnRMj8/PmzTNLfR4+fCh4eXkJAIRPP/20yvSFCxeKjduUlBSlaVlZWUJAQIAAQJg0aZJZ6mtLbG1f84LCcNawrydOnCgAEP7880+tF+48rg1na/uax7XhLLGvq7O/eFxXj63tbx7bVJPxfGebiouLlf4fGRnJwJwNsIZrXzIubfcFyDro0+Yjy+E1uW3atWuX2NPx5MmTlq6O3eIYc2R1unfvrnZau3bt0LhxYwDA6dOnzVIfLy8vNG3aFIBsnIbKNm3aBAB45pln0KBBA6VpPj4+GDNmDABg69atKC8vN3FtbYut7WsynKX39cGDB7F27VoMHz4c/fr101qex7XhbG1fk+Esva/1xeO6emxtfxPVZDzf2SYXFxdLV4EMwL+P9of3Bawf23xEprVy5UoAwKRJk9CpUycL18Z+MTBHNsfHxwcAIJFIzLK++/fvIzExEQAQHBysNC07OxsXLlwAAPTq1Uvl/H369AEAZGZm4uLFi6arqB2ypn1NpmXKfV1SUoIpU6ZAKpViyZIlWsvzuDYta9rXZFrmPodrwuPa9KxpfxPVZDzfEVkX/n20PbwvYN3Y5iMyrZKSEsTGxgIARo8ebeHa2DcG5sim5Ofn4++//wYAREREmGw9giDg3r172LFjB/r27YuCggJIpdIqJyT5xRoANG/eXOWyFD+/cuWKaSpsh6xtXyu6dOkS2rRpAzc3N3h5eaF9+/aYM2cO7t27Z7J62jNT7+tFixbhypUrmD17dpWnxlXhcW061ravFfG4Ni5T72t99xePa9Oytv1trHmJbBHPd0TWw1xtWqo+Q+4LkGVUp81HlsNrcttx+fJllJSUwMHBAR07dsT27dvRrVs3eHl5wcvLC507d8bnn3+O4uJiS1fV5jEwRzbliy++QEFBAVxdXTFu3DijL//48eOQSCRwcHBA3bp1MWzYMFy8eBF16tTBrl270KhRI6Xyd+/eFd/XrVsXADB58mR4eXlh6tSpAICgoCCxDP/g6M7a9rWijIwMJCYmws3NDfn5+Th//jwWLVqENm3a4MiRI0avq70z5b5OTEzEokWL0LhxY8yaNUuneXhcm4617WtFPK6Ny9TncH33F49r07K2/W2seYlsEc93RNbD1H8fqfqqc1+AzK+6bT6yHF6T245bt24BAHx9fbFy5UoMHz4cR48ehZOTE4qLi3Hq1Cm89dZb6NWrF/Lz8y1cW9vGwBzZjLNnz2LhwoUAgNmzZyM0NNTo63BxcUFgYCBq164tpppo0aIFfv/9dzz55JNVyiuegNzc3PDgwQN8++23yMvLwzfffIPMzEy4ubmJZfLy8oxeZ3tkjfsakD1d/OWXXyIlJQVFRUXIzMxEZmYmli9fDi8vL2RkZODZZ59VuiFCmpl6X0+ZMgXFxcVYunQppFKpTvPwuDYNa9zXAI9rUzDlvjZ0f/G4Nh1r3N/VnZfIlvF8R2QdzNGmpeoz5L4AWY6hbT6yHF6T257c3FwAQGFhIWbPno3+/fvjxo0byMrKQl5eHr777ju4uLjg+PHjmD17toVra+MEIhuQnp4uNG7cWAAg9O3bVygrKzP5OgsLC4W4uDghIiJCACDMmjVLKC8vVyqzYcMGAYAAQLh27ZogCIIwZswYwd3dXZg8ebIgCIJQWloqlvnoo49MXm9bZ637Wpv4+HhBIpEIAIS33nrLRDW1L6be12vWrBEACAMHDqwyTX5MRkdHV5nG49r4rHVfa8PjWn+WOIfLadpfPK5Nw1r3tynnJbJ2PN/Zj8jISAGAEBUVZemqkJ4s+feRDGeM+wJkOqZq85Hl8JrcOq1fv148purUqSPk5eVVKTN9+nQBgODm5ibk5+dboJb2gT3myOrl5uZi4MCBuHHjBtq1a4ctW7bA0dHR5OuVSqXo06cPDh8+jA4dOuDTTz/F119/rVTGw8NDfF9YWAgAiImJQX5+PlatWqX0OQB4enqavN62zJr3tTY9e/ZEnz59AAB79uwxRTXtiqn3dXp6OmbNmgUXFxd8+eWXes3L49q4rHlfa8PjWj+WOofLadpfPK6Nz5r3tynnJbJ2PN8RWZal/z6S4YxxX4BMw5RtPrIcXpNbJ8VryQkTJij9X06enrmwsBCnT582V9XsDgNzZNWKiorw7LPP4tSpU2jatCn27t0LHx8fs9ZBKpXijTfeAAB88sknStPk4zYAUNvtOi0tTXwfGBhoghraB2vf17oIDw8HAKSkpBizWnbHHPt6zpw5yMzMxMyZM9GsWTO95uVxbTzWvq91weNaN9ZwDgfU7y8e18Zl7fvb1PMSWTOe74gsx1r+PlL1VPe+ABmfqdt8ZDm8Jrc+AQEB4vvmzZurLNOwYUPx/Z07d0xdJbvFwBxZrbKyMrz44ovYv38/QkJCEBsbq9TQNKf69esDkJ1ssrOzxc/DwsLE90lJSSrnVfy8RYsWpqmgjbOFfa0LeU56Us9c+/rq1asAgMWLF0MikVR5yY0fPx4SiUTpooLHtXHYwr7WBY9r7azpHK5uf/G4Nh5b2N+mnpfImvF8R2QZ1vT3kaqvOvcFyPhM3eYjy+E1ufVRDH5z/5gWA3NklSoqKjBmzBj88ssvCAwMRGxsLBo0aGCx+qSmporvBUEQ3/v4+KBt27YAgPj4eJXz7t+/HwDg5+eHNm3amLCWtslW9rUuzp49CwBo1KiRMatkN6xtX6vD47r6bGVf64LHtWbWtq/V7S8e18ZhK/vb1PMSWTOe74jMz9r+PlL1Vee+ABHpjtfk1icwMFAMbqt7yEuxh2NwcLAZamWfGJgjqzRlyhRs3LgR/v7+iI2NVdt1VhPFp2c0dYnOy8vTuJzS0lJxPIYmTZrA19dXafpLL70EANi1axdu3bqlNC0nJwfr168HAAwfPpy55VWwlX1dXl6ucd6TJ08iNjYWAPDMM8/oWPOaxZz7+sCBAxAEQe1LLjo6GoIgVFkWj+vqsZV9zeO6+sy5r6u7v3hcV5+t7G8e21TT8XxHZF7G+PtI5lPde0BkftVt35Nl8Jrcdg0dOhSA7JgqKCioMn3dunUAZOPRRUREmLFmdkYgsjLTp08XAAje3t7C6dOnDV4OAPGVnJystlx0dLTQvn174csvvxQSExOFiooKQRAEoaCgQNi/f7/QtWtXcTnffPNNlfmzs7OF2rVrCwCEiIgI4erVq4IgCMLt27eF/v37CwAEqVQq3Lhxw+BtsVe2tK8PHDggREZGCjExMcLt27fFz3Nzc4V169YJ/v7+AgAhMDBQSE9PN3hb7JW597Wuy4mOjlY5nce14WxpX/O4rh5z7+vq7i8e19VjS/ubxzbVdDzf2abc3FwhPT1dfMnbJiNGjFD6vKioyNJVJQXG+vtI5lPde0BkfbS178kyeE1uu27duiW4ubkJAIRBgwaJ7bbi4mLhu+++E1xcXAQAwqxZsyxbURvHwBxZlZs3b4p/UN3c3ITAwECNL030CdYolnVxcRH8/PyUPpNIJBpPNvHx8YKHh4dY3tvbW5BIJAIAwdnZWdi4caOhX4ndsrV9vX//fqVyHh4egr+/v+Dg4CB+FhISwsaYCpbY19rocuHO41p/traveVwbzhL72hj7i8e1YWxtf/PYJuL5zhZFRUUpnbvUvXjj2XoY8+8jmY8x7gGRdeH50Trxmty2bd26VQzAARB8fX2V/t+nTx+hsLDQ0tW0aU4gsiIVFRXi+8LCQhQWFpp8nU8//TS+++47HDx4EGfPnsX9+/fx4MEDuLu7o379+ujevTsmT56Mxx9/XO0yevbsiXPnzuGjjz7Cn3/+ifv37yMwMBA9e/bEO++8g/DwcJNvh62xtX3dpk0bfPzxx9i/fz+uXbuGrKwsZGdnw9vbGy1btsSzzz6LKVOmwNvb2+TbYWsssa+Ngce1/mxtX/O4Npwl9rUx9hePa8PY2v7msU3E8x2ROdjatS/JGOMeEBFpx2ty2zZ8+HAkJCTgs88+Q1xcHO7duwepVIpOnTph9OjRmDRpEpydnS1dTZsmEQSOYkpERERERERERERERERkag6WrgARERERERERERERERFRTcDAHBEREREREREREREREZEZMDBHREREREREREREREREZAYMzBERERERERERERERERGZAQNzRERERERERERERERERGbAwBwRERERERERERERERGRGTAwR0RERERERERERERERGQGDMwRERERERERERERERERmQEDc0RERERERERERERERERmwMAcERHZrYYNG0IikWDcuHFmWV+vXr0gkUiqvNRJSUlRWV4ikWDdunVmqXNNkZmZiYCAAEgkEhw7dszS1TGr1157DRKJBGPHjjVofnW/U3MdV0REREQ1geI1V01rC5i73VbTWeK3pqo90atXL7Os29TWrVsnblNKSoracuPGjVP5PWiah4jsFwNzREREZBQlJSU4duwYPv30UwwdOhR16tQRGxvvvfeezsspLS3Fl19+icceeww+Pj7w8vJChw4d8NFHHyE/P9+gus2bNw8PHjxAv3790KVLF53n27FjB0aMGIHGjRvD3d0dXl5eaN++PWbOnInLly8bVBdNNm7cKH5nCxcu1Fr+zz//FMvPmjVLZZl33nkHzs7OWL9+PU6cOGHsKhMRERERERERkR4YmCMiIjKyTp064cKFC+JLneDgYKVye/fuNWMtjW/EiBHo2rUr3n77bezcuRPp6el6LyM7Oxvdu3fH9OnTcfLkSeTk5CAvLw/nzp3De++9h4iICNy6dUuvZd68eROrVq0CAHzwwQc6zXP37l307t0bw4YNw6ZNm5CcnIzCwkLk5eXh/PnzWLp0Kdq0aYPVq1frvY2aPPXUU3BwkF2e7du3T2v5uLg48f2AAQNUlgkNDUVUVBQEQcC7776rd50q/07r1aun9zKIiIiIyP7NmzdPa9YQqtleffVVsV0RHR1t6eqY1UcffSRuuy4PYRKRfXOydAWIiIjsjYeHB9q0aaO1nLOzs1I5T09PU1bL5CoqKsT3ISEhaNu2Lfbs2aPXMsaMGSP26nrxxRcxZcoUuLi44Mcff8Q333yDxMREDB8+HMePH4ejo6NOy/zf//6HkpISdO7cGT169NBaPiMjA3369BF7xPXt2xfjxo1D8+bNUVJSgvPnz2P9+vU4duwYkpKS9No+bfz8/NC5c2f89ddfOHbsGIqKiiCVStWWlwfvPDw8NG7bm2++ie+++w6xsbE4duyYXr0GK/9OnZ2ddZ6XiIiIiHTTsGFDCIJg6WoQmVSdOnV0aivbo+DgYAQHBwMATp06ZeHaEJGlscccERERGcXQoUOxYcMGpKamIjU1FcuXL9dr/n379uHXX38FAIwePRqbNm1Cnz590L17d6xYsQJvv/02AFkjZsOGDTotMzs7G99//724TF28/vrrYlDuww8/RGxsLF5++WU89thj6N69O6ZOnYqjR4/ixx9/hJeXl17bqAt5z7eioiKN4+Hl5OQgISEBANC7d2+4uLioLduiRQt07NgRAPDll18asbZERERERERERKQPBuaIiIjIKMaNG4dRo0YhJCTEoPlXrFgBAHBwcMDixYurTP/ggw/EQJiuQb+NGzciPz8fjo6OeOmll7SWP378ODZt2gQAGDhwoMax8UaOHKnX2Hm6UkxJqSmdZXx8PMrLy6vMo86oUaMAANu3b0dWVlY1a0lERERERERERIZgYI6IdLJv3z6MGjUKDRo0gFQqha+vL7p164avvvoKJSUlaucbN24cJBIJGjZsCAC4cOECRo8ejeDgYLi6uqJJkyZ49913UVBQoLUOOTk5WLhwIR577DH4+flBKpWiYcOGGDduHM6fP6/TdjRs2BASiQTjxo0DACQnJ+P1119Hs2bN4ObmhsDAQPTo0UPtTf9bt25h8uTJCAkJgVQqRYMGDfD6668jIyMD69atE/Ppp6SkKM338ssvQyKRwMvLS+u2Ll26VFzO2bNnddouXaWkpIjLXrduHTIyMvB///d/4n4NDQ3FpEmTqtRfl2UBwJEjR/Dcc8+J309ISAiGDBmCP/74Q+UyysvLER0djf79+6Nu3bpwcXFBYGAgBg8ejF27dmmtgyAIWLduHbp16wZvb2/UqlUL3bp1w88//6zP12I3Ll++jMmTJ6NJkyZwc3ODt7c3OnTogPfffx+ZmZla5y8sLMT8+fPRsmVL8Xh47rnncO7cOZX725jKysrw559/AgC6dOmC+vXrVynj4eGBp59+GgBw8uRJ3L9/X+tyN2/eDADo2rUr6tatq7X8d999J76fPXu21vLa0mkacu587LHH4O/vL86vadlyAwcO1FrX5557DgBQUlKC7du3ay1PREREZK9u3LiBzz77DIMHD0ZoaCikUik8PT3RtGlTTJw4EX/99ZfG+RWvjbW95G3hyrKzs9XOo+16+8CBA2LZ69evo0+fPnB3d0fz5s2xdetWAMC3336LRo0awc3NDT179sSVK1eqLEdTG1bVug4cOKA0TXFMOYlEgvnz54vTVG1Xr169NG6X3C+//IJ+/fohICAA7u7uCA8Px5o1a3Sa11CVv4tz587h+eefR506deDu7o7WrVtj7ty5yM/P13tZgiBgw4YNiIyMRO3ateHh4YFmzZphwoQJalPjV/f+R35+PubNm4fWrVvD3d0dtWvXxrBhw3D69Gm9vxtLq3xfKTc3F4sXL0b79u3h5eUFX19ftG/fHm+//XaV/ZOVlYW1a9di1KhRaNGiBTw8PCCVSlG/fn0MHTpUbC9qc/PmTUyePFk8X4SGhmLq1Km4d++esTeXiGoKgYhIg+LiYuHll18WAKh9dejQQUhLS1M5f1RUlABAaNCggbB7927Bzc1N5TL69esnVFRUqK1HfHy8EBAQoLYODg4OwvLly7VuT4MGDQQAQlRUlHDo0CHBx8dH5fIaNGhQZd4TJ04I3t7eKss3atRI+Pzzz8X/JycnK837xx9/iNM2bNigsY4RERECAKFdu3Zat0dfycnJYj0WL14shIaGqtweT09P4eDBgzovKzo6Wvjqq68EiUSicnlRUVFV5v/nn3+Ejh07avxtjRkzRigtLVW5/rKyMuG5555TO++CBQuU9rc5REZGCgCEyMhIg+av/J3qY82aNYKTk5Pa76N27drC6dOn1c7/4MEDoW3btirndXd3F9avX6933RS3591339VY9sKFC2LZmTNnqi33xRdfiOV2796tcZlFRUWCq6urAECYNWuWTnWuU6eOAEDw9/cXysvLdZpHleqeO0eMGCEAEJydnYXc3FyVZdq0aSMAEJo1a6ZzvQIDA8Vjy1DmPq6IiIiIjOnGjRsar9EACBKJRJg9e7baZShe52p7qWpbCoIgZGVlqZ1H2/X2/v37xbLNmjVTmtfR0VH4+OOPqyyzRYsWVdrc0dHRatuwqta1f/9+pWlz587V+XvQ1E5SvL7UtMwPP/xQ4/dSHYrfxZo1awSpVKqyDs2bNxfu3r2r87KuXr0qXtvruq+re//j7t27QlhYmMp5XV1dhdWrVxvc7jSUfH1z587Ve17F+0p37txR225V9TuW/7Y0vZ588kkhPz9f7foPHTokeHp6qpw3ODhY6XhTdxxVpsuxR0T2jT3miEijqKgorF+/HgDwzDPPYOvWrTh9+jR+/fVXzJw5E87Ozjh79ixefPFFVFRUqF1Obm4uoqKi0K5dO/z88884ceIEYmJi0KhRIwBAbGwstmzZonLes2fPon///sjIyECdOnXw8ccf49ChQzh27Biio6PRrl07VFRU4PXXX1fbM6uyvLw8vPjiiygtLcU777yD2NhYJCQkYPfu3ZgyZQpcXV2Vyufk5GDIkCHIycmBk5MT3nrrLRw+fBhHjhzBW2+9hdTUVCxcuFDt+vr27Sv2AJJ/n6okJiaKT7CNHTtWp20x1Icffoh//vkHb7zxBuLj43Hs2DHMmzcPUqkUeXl5GDp0KB48eKDTsk6dOoVp06YhNDQUS5YsweHDh3Hq1Cls3LgRgwYNgkQiUSqfm5uL3r1748yZM3B2dsYbb7yBvXv34uTJk9i8eTOGDh0KAPjhhx8wd+5cletcsGCB+DRoly5dsG3bNpw6dQo//PADmjdvjvnz59eYp9cOHTqEV155BWVlZfD398fSpUvx119/IT4+HjNmzICjoyPS09MxaNAgtT3nXn75ZVy4cAEAMGzYMPz+++84efIkli1bBqlUijfeeMOk23D16lXxfZMmTdSWU5ymOI8qJ0+eRHFxMQBZLzRtbt26JfbC69ChAxwcDL9Mqu65U56asrS0FIcPH64y/f79+7h06ZJSWV3Iv4dDhw7pvU1ERERE9kCeCrx9+/b44IMPsGvXLpw8eRInT57Ejz/+iN69e0MQBCxatAgrV65UuYzg4GBcuHBB7euPP/6Au7s7AKjMBAEAtWrVUppn7969Bm2Pl5cX4uLisG7dOri5uaG8vBxz5szBU089hfj4eHz88ccAgCtXruDEiRMGrUOdqVOnKm3Dq6++Kk5T9b1ER0drXN6RI0ewYMECjB49Gn/88QeOHDmCzz77TPwuP/zwQ9y+fduo26DK//3f/8HV1RWff/45/vrrL8TFxYnt86SkJIwYMULnZX311VfYuHEjunXrhu+//x4nTpzAsWPHsGLFCrRp06ZKeWPc/3jppZeQmJgIABgzZgzi4uLw119/4dNPP4WLiwtmzJhhwLdiHaZMmYKLFy9i9OjR2LFjB06fPo0DBw5g3rx5qF27dpXyZWVlCA4OxhtvvIGffvoJx44dE+/9TJw4EQ4ODvjzzz8xYcIElevLyMjAs88+i7y8PLi6umLu3Lk4duwY4uPj8dprr+HOnTv46KOPTL3ZRGSPLB0ZJCLrtWXLFvEJng8++EBlmT179ohltm7dWmW6/MkmAELnzp2FoqIipel37twR3N3dBQDC8OHDq8xfUVEhPg1Vt25d4fbt21XKlJaWCt26dRMA7b3M5E9LOTk5CQEBAcKlS5dUlqv8xNJ7770nbsfatWurlFfsxQM1TzzNnj1bXPe9e/dUrveDDz4Qn3JU15OmOio/2fnpp59WKbN161Zx+ttvv63TspycnITHH39cePjwodqyil5//XVxO//44w+V87zzzjsCAMHFxaXKd5Geni72hOrUqZNQXFxcZXpwcLBYP3vvMdepUycBkPVsU/Wb/vbbb8Xlquo5FhsbK04fO3ZslemnTp0SHB0d9a6bPj3mvv76a7Hstm3bBEEQhMuXLwthYWFCaGiocPz4cbEuuvw+BUEQPvnkE7Hs9evXtdY3Li5OLD958mSdtlEVY5w709LSxB6oqvbZxo0bxfm19RxUNG/ePHG+O3fu6L5RCthjjoiIiGxZZmamcOTIEbXTy8rKhCeeeEIAZJlR9FVaWir07NlTACB4e3sLV69e1Wk+fdoCir3YYmNjxc/Hjh0rfn7t2jXxc3mvuhUrVigtp7o95ipT7O2mD8VeTW+88UaV6Tt37hSnf/XVV3otW1eK34Wjo6Nw7NixKmXeeOMNscyePXt0WpaTk5Pw2muvqSxXWloq/PPPP+L/jXH/Y9euXRq/y8OHDwsODg422WPOyclJkEgkwqZNm1SWS09Pr5JtZM+ePUJZWZnaZc+aNUusW0pKSpXpM2fO1NhuW7RokdZ7QaqwxxwRscccEan16aefApD1HFHXa2ngwIHo2bMnAODHH3/UuLx58+ZV6YkWFBSEJ598EgBw5syZKvPs3btX7MWzfPly1KtXr0oZJycnfPjhhwCA8+fP4+LFixrrAciemvr000/RqlUrldMrjwPw/fffAwDatm2L8ePHVyn/2muvqayboqioKHHdGzduVFlG/h0+9dRTOo2HVR1BQUGYNm1alc+HDx+OiIgIALIea7oQ/s2Z7+XlpXK64veZlZUljg8wdepUcf9XNnfuXEilUpSUlFTpTbl582axJ9T8+fPh4uKiND0gIABvv/22TnW3dZcvX8apU6cAAK+88orK3/TEiRPRunVrAEBMTAwEQVCaLh/DwsnJCf/73/+qzB8RESGOT2YqimMByJ+IXbBgARITE5Gamoo333xTaVrleVT5559/xPeBgYFa65CdnS2+9/b21qneqhjj3Fm3bl20b98egOpx5uSfubq66jxWBwDUqVNHfK/4/RARERHVFL6+vujatava6Y6OjmLvmeTkZNy5c0ev5c+ZMwcHDx4EAERHR6Np06aGV1YHLVu2FN+HhYUBAFxcXNC4cWPxc3nWCWu//nNxccGCBQuqfD548GD4+voCUH3fwNiGDRuGJ554osrn8+bNE9ueMTExOi2rUaNGWLp0qcppTk5OCA4OFv9vjPsf8ja8i4uL0ph/ct26dcOzzz6rU92tTVlZGcaOHYsXX3xR5fSAgAB4enoqfTZw4ECN44JPmjRJfH/kyBGlaYIgiFlQOnfujOHDh1eZf+bMmTq1NYmIKmNgjohUysjIENNcPPvssxpTurVr1w6ALG2cOo6OjujTp4/Kac2bNwcAlWkHd+/eDQCQSqUYOHCg1jpoq4ecl5cXRo4cqbUcIGuM3bp1CwAwZMgQlWWcnJzQv39/jcsJCwsTL+5VpbM8ceIErl27BuBREM+UBgwYAGdnZ5XTBg0aBABIS0tTOwi4oj59+mhMP6ho3759KCwsBACVF7Zybm5uYiO28j6VXzC7uLigb9++KudXt6/sjWLj4ZlnnlFZRiKRiI2ve/fu4caNG0rT5TcOHn/8cbWNiqefftoY1VVLHmgFIDZ25WmGFN8rBvflvyN10tPTxeV5eHhorUNBQYH4XiqVVpm+ZcsWlYPYHzhwQCxjzHOn/Jx35swZpaAh8CgwFxkZqRSs1MbPz098L/9+iIiIiGqy4uJipKam4u+//8bFixerBDrS0tJ0XtaOHTvEh7RmzpyJYcOGGbWuqihe38mDV76+vkrDCcgfOsvKyjJ5faqjU6dO8PHxqfK5g4OD2DY0x3AF6tpVfn5+ePzxxwEAx44d02lZ48aNU9vurswY9z/k7cMnnnhC/D1UZstt5cmTJxs8b0VFBe7cuYMrV66Ix7riw56Vj/Vr166JQx2o2x8uLi56DS1ARCTHwBwRqXTu3DmxV838+fNV3oyWv77++msAEC9YVAkICFB5oxt41ANG8aa43NmzZwEARUVFcHd3V1uHgIAAcR5N9ZDr2LFjld576ly5ckV8r66HHQC0aNFC67LkAbeTJ08iKSlJadqGDRsAyBpN5niCTVN9FafJc9Nr0qVLF53XK9+nANC7d2+Nvy15o7jyPpWPLdawYUO1+7FBgwZwc3PTuV62SvF3pOn3qThNcZ7CwkKkpqZqnV+X33d1KJ4fSkpKAACzZ89G48aNERISIt7gUAzgadu/8vH0VDXuVVEMcBUVFek0T2XGPHfKG3gVFRWIj48XP79165YYxNe3Eah440bXMSSJiIiI7E1JSQm+/PJLREREwNPTEw0aNEDr1q3Rtm1btG3bVunmv6p2qirXr1/HuHHjAMh6JX3yySemqHoVitlD5O8rZxSRB4bk19nWKiQkRO00TfcNjE2XtvLNmzd1ajMY0lY29P5HQUGB2MNT0zYo9rK0Jc7OzujUqZPe8+3YsQNPPfUUvLy8EBwcjJYtW4rHeseOHcVylX9bimOa2+P3SUSWxcAcEamUkZGh9zyaLkrVBeVMUQ9tvWgAWRpHXSn2VFH3xJm2aXIjRowQA0mKaSLLy8uxadMmAMCLL75o8PelD031VQxkVO6po4o+36cx9mlOTg4AzQEXiUSic0DGlsm/C0D336fiPMb8fVeHYo82eYOoQ4cOuH79OlJTU9G9e3cAyr8Fbb3g5MeRrkE2xfSVubm5VaY/9dRT4sD1qtLCAMY9d3bt2hW1atUCoJzOMi4uTnyvb2BO8furCYFrIiIiosoyMzPRpUsXTJ8+HQkJCSgrK9NYvqKiQusyCwsL8dxzzyEnJwe1a9fGpk2b4OTkZKwqa6SYoUGesq9y1gb559q21dJ0aQdXTstvCrq2lRXbVeqYs62sWB9NbWFTt+1Mxc/Pr0rQWRNBEDBhwgQMGzYMf/75p9agbuVj3d6/TyKyLPNcJRCRTfvmm2/Em+KW0rZtW61j2MkpjqGkjikCX7o0EHx8fPDss89i8+bN2LBhg5gbPi4uTkzJYY40lvrQpSFq6Pd56tQpnXou6pKGkEzL1A1gxQbr3bt31ZZTTC+ibVzH2rVrA5AF2crLyzWOLQAAzZo1E98nJydXmV6rVi20adMGAHD8+HGNywKqf+50cnJC3759sX37dqXAnPx9gwYN9H46U96LEHj0/RARERHVJNOmTUNCQgIAYOjQoXjjjTfQoUMH+Pj4iAGt/fv3i0Mx6HId/Nprr+HcuXNwcHDATz/9pDRuGNkvU7WVjX3/w17o+12uXbsW0dHRAGTpP9999110794dderUEQPngiCIx705gr5ERHIMzBGRSv7+/uJ7T09P8Wa0pepRUFBgsTooPhmleFO7Ml3z9UdFRWHz5s1ITk7GkSNH0K1bNzGNZZMmTdCtW7dq1VdXmuqr2ItKsReRMSj+tgIDA1G/fn29lyHfJ5p68wmCoFNvP1unuH+ysrLU9oJS/O0qzmPs37eh5GNNArI0QOooTlOcRxV54EkQBGRmZmoNRIWGhsLf3x8PHjzA2bNnIQiC0tgcujD2uXPAgAHYvn07Ll26hPv376NOnTrYv38/AGgd11IVBuaIiIioJsvNzRUzlbzwwgvYvHmzynL6tCPWrFkj3vyfP3++2jGwrZEu17q6ZKSxN5ZuKxt6/0PXzDfWPtagsXz33XcAZENgHD16VOUDv5q+J36fRGRKTGVJRCopDib8119/Wawe7du3BwDcuHHDoLQOxqCYS/zSpUtqy12+fFmn5fXv3x9169YFAKxfvx6FhYXYvn07AGDs2LHVqKl+NNVXcVw9bcEPfcn3KWD4b0tep5SUFKUxxxSlpKTYXCNSsUdXaWmpTvMo9vLS9PtUnKY4j5ubG0JDQ7XOr+vv21BhYWFiw1bT70LeU83BwUHr+AKK5zHF8QE0efrppwHIBpWXP0mtD2OfO+WDjAuCgAMHDiApKQn//POP0jR9yMeMlEqlaNq0abXrR0RERGRLkpKSxOvsl19+WW258+fP67S8s2fP4vXXXwcguzZ79913q19JM1LsgaQuzZ98PGpd6PtQm7XSpa0cHBysNEa1MVT3/oebm5v44Ktim76yv//+27AK2hj5mPXDhg1Tm4VH07GueC+E3ycRGRsDc0SkUp06dRAREQEA+Omnn/Dw4UOL1EPxpvSqVassUodGjRqJF7e7du1Smd6gtLQUe/fu1Wl5jo6OYiPw559/xrZt25CbmwuJRIIxY8YYr+Ja7N27V23wZ8+ePQBkPdqaNGli1PX26dNHTF+5cuVKg5YhTw9YUlKC2NhYlWV27dplWAUtSDE3vXzQbm26du0qvle3zYIgYOfOnQBkx3blfdqjRw8AwIkTJ5RSRSr69ddfdaqPoZycnPDkk08CAI4ePapy+wsKCrB7924AQOfOnbX2+JJvFyDbNl1MmDBBfP/pp5/qNI8iY587Q0JC0KpVKwCyFJbyNJbOzs4GPY0t/x4ef/xxvcZnICIiIrIHimOsqRvnt7y8XKc0gtnZ2XjuuedQVFSE0NBQrF+/3uYCU/IHRgH1gQdd27mAboE+W6Cu7ZOZmSk+fKfYDjMWY9z/kLeVjx8/rrYnly22lQ0hP941jTkeExOjdlrjxo3FIRfk90gqKykp0esYISKSY2COiNR66623AAAPHjzA2LFjUVJSorJcRUUFNm7caJIb94MGDRLHUFq4cCHi4+PVlk1NTcV///tfo9cBeNST7dKlS1izZk2V6cuWLdM4LlZl48aNAyD7bmfOnAkA6NatGxo1alT9yuooLS0NX375ZZXPt23bhtOnTwMARo8ebfTGpb+/v7j9sbGx+OSTT9SWzcvLw+LFi6uM9/X888+Ljb558+ZV+W1mZGQYFFSxNE9PTzFopmtjqXXr1ggPDwcgS6Ojqtfbt99+Kz71OWbMmCr7VD6uYXl5OWbNmlVl/pMnT2LHjh06b4ehXn31VQCyc4qqY3nhwoVioGvq1Klal1e/fn00bNgQgO6BucjISAwePBgAsGnTJrUNYk3jDxj73DlgwAAAyoG5rl27wsvLS/PGVFJYWCg+NaoYtCQiIiKqKZo2bSpeC8tTWlY2Z84cJCUlaVyOIAiIiorCjRs34OLigp9//hl+fn5Gr6+ptW3bVhxfKzo6uso17sGDB8UH/HQREhIivj958qRxKmkB27dvV5n9QrHtaYqHao1x/0P+EHBJSQnmzp1bZfrRo0drTGBOnilmz549yMvLqzJ99+7dWLdundr5JRIJRo8eDQA4deoUtm3bVqXMkiVLcO/ePeNUmIhqFI4xR0RqjRgxAtu2bcPPP/+MnTt3on379njttdcQEREBFxcX/PPPPzh06BA2bdqEf/75B8uWLTN6HRwcHPDDDz+gW7duKCoqQr9+/RAVFYWhQ4ciODgYeXl5OH/+PPbs2YO9e/fCx8cHixcvNno9Zs2ahTVr1uDevXv4z3/+g8uXL2PYsGFwdHTE9u3bsWTJEoSGhuqc5qN169aIiIjA6dOncf/+fQCaU6mYgoeHB9555x2kpqbihRdegIuLC/bu3YtFixYBkPXeMlWg85NPPkFsbCyuX7+O//73v4iLi0NUVBTCwsJQXl6Oa9euITY2Flu2bEFeXp4YKJHz9/fH22+/jQULFuDUqVPo1asX3n77bYSGhuLy5ctYsGAB7t69C6lUqvHpOGs0atQofPjhh0hISMDYsWPxyiuviI18Dw8PlcHbzz//HH369EFhYSEiIyPx3nvvicfMtm3bxGOzdu3amD17dpX5n3zySTz11FP4448/sGHDBuTm5uLVV19FQEAA/vrrL7z//vsIDg7W+vu+du0aDh8+LP5fMf3K+fPnlRo9devWFQNOcn369MHgwYPx66+/4ocffkBJSQmmTJkCFxcX/PTTT1i+fDkAoFOnTmIDSZunn34ay5cvx4EDB1BRUSHeeNBk5cqV6N69O1JSUvCf//wHv/32G0aPHo1GjRohKysLp0+fxueffy6WrxzoNPa5c8CAAViyZAmuXr0q9mis/N3pYv/+/eJTo/KUnUREREQ1ib+/PwYNGoTdu3dj27ZteP755zF+/HgEBQUhJSUF3333HX777Td07NgRZ86cUbuc6OhoMbgxefJkuLu7iw9AVebi4lJleIDS0lIxxbicYsaI27dvV1leo0aN1KbjM5Sfnx/69u2LP//8E7/++isGDx6MMWPGwN/fHwcPHsTSpUvRtm1bnDt3Tqfl9ezZEw4ODqioqMDkyZOxdOlSdOzYUXygzNHRUe2Y2NZEKpWif//++OCDD9CjRw/k5eVh3bp1Yu+qHj164JlnnjH6eo1x/+Ppp59GZGQk4uPjsWzZMuTk5GDcuHHw9PTEwYMHsWDBAri5uSE/P9/o9bc2Y8eOxaxZs3Dz5k307NkTs2bNQrNmzZCdnY3t27dj9erVaN++vcZj/Z133sHatWuRmZmJ0aNH47///S8GDBiAkpISbN68GcuXL4eHh0eN+D6JyMgEIiINiouLhfHjxwsAtL6+//77KvNHRUUJAIQGDRqoXcfcuXPFZahz6NAhoW7dulrr0KhRI43b06BBAwGAEBUVpetXIDp+/LhQq1Ytlett1aqVsGzZMvH/KSkpWpf31VdfieVdXFyEzMxMveukr+TkZHGdH330kVCvXj2V2+Ph4SEcOHBA52VFR0frXZfbt28Ljz32mNZ96uLiIly9erXK/GVlZcLw4cPVzvfRRx9Va38bIjIyUgAgREZGGryMvLw8oU2bNiq3SdNyV69eLTg6Oqr9Pvz9/YUTJ06onT89PV1o3bq1ynlr1aolbN++Xfz/unXrVC4jOjpap3OFpm3JysoSOnfurHa+5s2bC6mpqTp/n8eOHRPnjY2N1Xm+5ORkrb9PBwcH4c033xRKS0urzF/dc6eioqIiwd3dXWmeM2fO6LwtcqNHjxYACE2bNtV7XkXmPq6IiIiIjCk1NVUIDQ1Ve23Wp08f4ffffxf/v3///irLUGzDanupagsrtqV0fSnWY//+/eLniuTX45XXKW+Xq7p+O3v2rODh4aFynZ07dxZ++eUXjd9FZW+88YbebQBdri+N0dbSRLEts2rVKsHFxUXlNjRr1ky4c+eOzstKTk7Wuy7Vvf+RlpYmNG/eXOU8UqlUWLNmjfh/Q9ryhpCvb+7cuXrPq8t9JVVKSkqEp556SuOxefXqVa11O3jwoODp6alyGSEhIcKiRYv03t/V/Y0Qke1jKksi0sjFxQVr167F8ePH8corr6B58+bw9PSEs7Mz6tWrhyeffBIff/wxEhMTxXSPptC9e3dcu3YNS5YsQe/evVGnTh04OzvDy8sLbdu2xcSJE7F161aNgzRX1+OPP47z589j4sSJCA4OhouLCxo0aIBp06bh8OHDSvn0dXmSccSIEeL7QYMGKY0vZg716tXDqVOnMHnyZNSvXx8uLi6oX78+JkyYgAsXLiAyMtLk6z9+/Dg2bdqE5557DiEhIZBKpZBKpWjSpAmee+45rFq1Cnfu3EHTpk2rzO/o6IgtW7Zg7dq16NKlC7y8vODp6YmuXbvi559/xpw5c0xaf1Px8PDAoUOHMGPGDISGhsLR0VGn+SZNmoRz585h4sSJaNSoEVxdXeHp6Ym2bdti9uzZSExMROfOndXOHxAQgBMnTmDu3LkICwuDq6sr6tSpgxdeeAFHjx5FmzZtlOpoKj4+Pjhy5AiWLl2KTp06oVatWvDw8EDbtm3x4Ycf4vTp00opcrR54oknxFSfGzZs0Hm+hg0b4tixY/jpp58wbNgwhISEwNXVFbVq1ULbtm0xbdo0/P333/jss8/g5FQ1AYExz52urq7o3bu3+P+6deuKA8PrqrCwUExDpEsaUCIiIiJ7FRISgtOnT+PNN99E06ZN4eLiAl9fXzzxxBNYvnw5/vjjD3FM7Jqgffv2OHLkCIYMGQJfX1+4ubmhVatWWLBgAeLj4+Hp6anX8r788kt89913iIyMhJ+fn87tGWvy1FNP4fDhwxgyZAj8/f0hlUrRokULvP/++0hISBDHHTOV6t7/qFu3LhISEjB37ly0bNkSUqkU/v7+GDp0KI4ePYo+ffqYtP7WwtnZGbt378YXX3yB8PBwuLu7w8PDAy1btsTs2bORkJCg8l5DZT169MCFCxfwyiuvICQkRLx38uqrr+LUqVNKYzUSEelKIggaBkkhIiKdLV68GLNnz4azszMKCgpU3qxXdODAAfFm+9atWzF8+HCT1zElJUVMhRgdHS2O9UbG0atXL8THxyMyMhIHDhywdHWM6vjx4+jSpQsAID4+Hj179rRwjXS3adMmjBgxArVq1UJqaiq8vb0tXSWzW7duHcaPHw9fX1+kpKSgVq1aBi+rYcOGuHnzJqKiojSOyUBEREREZCvk18sAkJycLI5VTcYhT/8/d+5czJs3z7KVsQL8vRERx5gjIjKSY8eOAZANoK0tKAcAa9asASAb56DyGGpk2/Lz85XGhFDsbWar5L9viUSid28tS3vhhRfw4Ycf4tKlS1i2bBnee+89S1fJrCoqKsSxJ9566y29g3KVx0ApLS01av2IiIiIiKhmuH//vthWVjeGur26ffs2srKyxPdEVLMxMEdEpKPExEQ0a9YMDg5VswAnJCRgz549AIDnn39e67Ju3LiBTZs2AQDGjBkDFxcX41aWLOrUqVNo27at+H9b6JyempoKf39/lWkqHz58iGXLlgEAnnzySZvrcebg4IBPP/0UgwYNwhdffIHp06frnZLHlm3evBmJiYkICQnB9OnT9Z7/9u3bSr9nIiIiIiIiQ3zzzTf45ptvAMAuM81o8u677+L777+3dDWIyEowMEdEpKN3330XJ0+exPPPP4+ePXsiNDQUBQUFiI+Px6effoqysjLUq1cP//nPf1TOf/v2bRQUFODq1auYNWsWSktL4eTkhNdee83MW0JU1a5du/Duu+9i6NChePLJJxEWFgYAOH/+PD777DMkJyfD0dHRZtOODBw4EMuWLUNGRgZSUlLsohejrioqKjB37lz06dMH7u7ulq4OEREREREREVGNxsAcEZEeUlNTsWTJEixZsqTKtNq1a2PHjh3w9fVVOe/o0aMRHx+v9NnChQt1GmyYbIOtP+338OFDxMTEICYmpso0R0dHrFq1Shxnzha9/vrrlq6CRYwaNapa8zds2NAmen0SEREREZF1YntCNq4cx+gmIjkG5oiIdPTee++hdevW2L9/P5KTk3H//n24urqiadOmePrppzF9+nT4+/trXY5UKkXLli0xY8YMjBkzxgw1J9Ju+PDhKCsrQ2xsLC5fvox79+6hoqICwcHB6N27N6ZPn45WrVpZuppEREREREREREQ2TSLwkQUiIqu2cOFCLFy4sFrL+OOPP9CzZ08j1YiIiIiIiIjIsp566ikcPHiwWssoKioyUm2IiIh0x8AcEZGVy8zMRGZmZrWWERwcDDc3NyPViIiIiIiIiMiybt++jcLCwmotg0NLEBGRJTAwR0RERERERERERERERGQGDpauABEREREREREREREREVFNwMAcERERERERERERERERkRkwMEdERERERERERERERERkBgzMEREREREREREREREREZkBA3NEREREREREREREREREZsDAHBEREREREREREREREZEZMDBHREREREREREREREREZAYMzBERERERERERERERERGZAQNzRERERERERERERERERGbAwBwRERERERERERERERGRGTAwR0RERERERERERERERGQGDMwRERERERERERERERERmQEDc0RERERERERERERERERmwMAcERERERERERERERERkRkwMEdERERERERERERERERkBgzMEREREREREREREREREZkBA3NEREREREREREREREREZsDAHBEREREREREREREREZEZMDBHREREREREREREREREZAYMzBERERERERERERERERGZAQNzRERERERERERERERERGbAwBwRERERERERERERERGRGTAwR0RERERERERERERERGQGDMwRERERERERERERERERmYGTpStgLyoqKnDnzh14eXlBIpFYujpERERERGQgQRCQm5uLevXqwcGBzzKSYdhGJCIiIiKyD8ZuIzIwZyR37txBSEiIpatBRERERERGcuvWLdSvX9/S1SAbxTYiEREREZF9MVYbkYE5I/Hy8gIg2zG1atWycG2IiIiIiMhQDx8+REhIiHiNT2QIthGJiIiIiOyDsduIDMwZiTw1Sa1atdjoIiIiIiKyA0w/SNXBNiIRERERkX0xVhuRAyYQERERERERERERERERmQEDc0RERERERERERERERERmwMAcERERERERERERERERkRkwMEdERERERERERERERERkBgzMEREREREREREREdVwaWlpmDdvHtLS0ixdFSIiu+Zk6QrUdKWlpSgvL7d0NYjIAI6OjnB2drZ0NYiIiIjITrB9SGTb2EYkW5eWlob58+djyJAhCAoKMtoyV61ahSlTphhtmUREto6BOQt5+PAhMjIyUFxcbOmqEFE1uLq6IiAgALVq1bJ0VYiIiIjIRrF9SGQ/2EYkUmaKYB8Rka1jYM4CHj58iNu3b8PT0xMBAQFwdnaGRCKxdLWISA+CIKC0tBQ5OTm4ffs2ALDhRURERER6Y/uQyD6wjUhERES6slhg7uDBgwCAzp07w83NTad5KioqcPjwYQBAz549TVY3U8vIyICnpyfq16/PBheRDXNzc4OXlxf++ecfZGRksNFFRERERlOT20s1DduHRPaDbUQiIiLShcUCc7169YKDgwPOnz+PVq1a6TRPYWGhOF9ZWZmJa2gapaWlKC4uRkBAABtdRHZAIpHA29sbt2/fRmlpKccTIKIaLzU1FRkZGSqnBQQEIDQ01Mw1IrJNNbW9VNOwfUhkf9hGJFuRlpaGtLQ0FBQUiKmUz58/DwCIj49HVlYWXF1d4e7uDgAICgpiKkoiIiOxaCpLQRDMOp81kA/kzQszIvshP57Ly8t5bBNRjZaamoqwFi1RVFigcrrUzR2JVy4zOEeko5rYXqpp2D4ksk9sI5KxpKWlYdWqVZgyZYrRg2KrVq3C/PnzVU6bOXNmlc/mzp2LefPmaVwmg31ERLqxqTHmKioqLF0Fo+HTkET2g8czEZFMRkYGigoL4D/4TTj7hyhNK31wCw9+/RwZGRkMzBGZiD21l2oaXk8S2Rce06QPTcG3tLQ0zJ8/H0OGDDF6AGvKlCno0aMH9u/6EZ1D3OHpIcX5q/9g5tKNWDJjBBrXC8DJWwXoPWQUfH19dVq/KYJ9RET2yKYCc/LBc6VSqYVrQkRERETqOPuHwLVuU0tXg6jGYXuJiIjI9pgy+KZJUFAQnJ2dcf30fnTrUAcBPl7w9fIAAESGhyG0rh/uVdxH+/btERAQoNMyTRHsIyKyRzYVmFu7di0AoH79+hauCRERERERkXVhe4mIiIgsyRTBPiIie2S2wNyCBQtUfr5ixQrUqVNH47wFBQU4efIkDhw4AIlEgt69e5uiikRERET0r9TUVGRkZKicFhAQwHSUREbG9hIRERFZM20pN+XTTD2uoinG3TPlWH5ERKqYLTA3b968Kjm2BUHAN998o/MyBEGAr68v3nnnHWNXj8gshg4dikuXLuHy5ctwcrJch9VevXohPj4egiAYZXnjxo3D999/j+TkZDRs2NAoyzS2lJQUNGrUCFFRUVi3bp3StNLSUoSFhSEiIgI///yzZSpIRGRFUlNTEdaiJYoKC1ROl7q5I/HKZQbniIyI7SWimoltRMthG5GsTXp6OhISEgDIHropLi7G+fPnAQDx8fHIysoCALi6usLd3R1BQUFmDSJpSrmpOM0YbQRTjLtnqbH8iIhUcTDnygRBEF+qPlP3cnV1RdOmTTF58mScOnUKjRo1Mme1bVZaWhrmzZuHtLQ0S1dFNG7cOEgkEvHl5OSEoKAgvPDCCzh58qSlq2dS8fHx2LlzJz744AOLNrisifz3kJKSYtF6ODs7491338WWLVtw9OhRi9aFiMgaZGRkoKiwAP6D30TdqC+UXv6D30RRYQEOHTqEhIQEpdfly5ctXXUim8b2Epka24jWhW3EqthGJHuXlpYmXjsfPnwYcXFxiI+PBwAsWbIEERERiIiIQI8ePdCvXz/MnDkTADBz5kz069cP/fr1Q48ePRAREYFVq1YZvX5BAd6YO2kIggK8jb5sfcgDZcb8e2WKZRIRGcpsV34VFRVK/3dwcIBEIsGFCxfQqlUrc1WjRrHmpz3Gjx+P0NBQFBUV4dy5c9iyZQt27NiBnTt3YtCgQZaunkm8//77CA4OxqhRoyxdFcTExKCgQHUviJoqKioKc+bMwXvvvYd9+/ZZujpERGahLl2lPMDm7B8C17pNlaaV52UBEglefvlls9SRqKZge4nMgW1E68I2onVjG5FMYdWqVZg/f77KaX/88UeVz/o/0Rp7j1/Ckhkj0K5ZfeTlF+HkrQL0HjIK/v7+mDdvnlHTLwYF+GDe5KEAgIzsXCMt0zqCfURE1oSPZJFFTJgwAd27dxf/v3btWkycOBHTp0+3y0bXpUuXcOjQIbz11ltwdHS0dHWYekwFJycnjBgxAl999RUSExMRFhZm6SoREZmUtnSV6lQU5wGCAP/Bb8LZP0RpWuGNU8g5tN6Y1SQiohqCbUTLYhuxKrYRyRSmTJmCIUOGICsrC/t3/YjOIe64cScDM5duFINvt+9nYWf8aYwf3A3OLq7Ye/wSIsPDEN6iATKyc3Gv4j7at2+P1NRUq33YQpEpgn22jmPaEZFZU1kSqTN+/Hi4u7vj6tWrePDggdK0srIyfPHFF+jQoQPc3Nzg4+ODIUOG4OLFi2qXd+XKFYwbNw4hISFwdXVFaGgoRo8ejbNnz1Ypu2fPHvTs2RNeXl5wd3dH586dERMTY9Tti46OBgC88MILVaatWbMGEokEmzdv1riMV199FRKJBDdv3hQ/u3TpEkaMGIHAwEC4uroiLCwMn3zyCcrLy6vMLx+3RPGlSXJyMoYNGwYvLy/4+Pjg5ZdfRkJCAiQSCcaNG6dynuLiYsyaNQv16tWDVCpFt27dxHzoqurx/fffAwAaNWqkVC9VaUt+/fVX9OnTB97e3nB3d8cTTzyBnTt3qqzHtWvXMGzYMHh7e8Pb2xujRo1Cenq6xu0FgBdffBEAqowvQERkjzSlq/Tuob03nLw3neLLyTtQ63yXL1+ukgIzISEBqampxtgsIiKyE2wjso3INiLZIm0pg4OCghAeHo727dsjNDgI3To0Q2S4LOgbGR6Gvp1b4fE2jVHbxxNtmgSjto+XOasvSsvIxrmrt3A1+RYOHjyolHLzl19+wcqVK7F8+XKsXLkSK1euxC+//AJAlqL34MGDuJ5yC+eu3kLClZtIy8g2uB7ycfdUpf6Mj49HXFwc4uLicPjwYSQkJODs2bNaUzbrskz58hISEkyS+pJpNYmIPebIKkgkEvEpQWdnZ/Hz8vJyDB06FLt370br1q0xZcoU5OXlYcuWLejatSuOHDmCtm3bKi0rLi4OQ4YMQUlJCYYMGYKwsDBkZWVh9+7dcHZ2VrqgXr9+PcaOHQtfX1+MHTsWrq6u+PnnnxEVFYV//vkHc+bMMcr2xcXFQSqVomPHjlWmde3aFQBw4sQJ8aJflRMnTiA4OBgNGjQAAOzfvx+DBw9GWVkZhg8fjuDgYPz111/473//iytXrogNPblevXqJ79etW6fUeKssPT0dPXr0wJ07dzB8+HA0bdoUv//+O8aMGaNxO6dMmYLMzEyMGDECV69exa+//oqnn34aV69ehVQqrVKPHTt24Ny5c5g2bRp8fHzEzxXfA8Ann3yC//73v6hTpw5efPFFuLm54bfffsPQoUMRHR2t1AhMS0tD9+7dkZ6ejhdeeAENGzbEr7/+ipEjR2qsOwBERETA2dkZcXFxWssSEdkLVekqSx/cMvp6tKXAlLq5I/HKZT6xT0REANhGBNhGZBuRbJG6lMHm7iFV3fWt2nYA87/dJfvPSuUHE+bNm6d2PvmYeADwv3//nTtpiNhjTl1d5QGqgoICFBcXiwH8JUuWqEzxWXldcpMnT8bq1avRpUsXoy1z7ty5GrdZ03axVxwRqWOxwFzlMRSoehT/iMklJCQo/asoKCjIqv4o7NixA7m5uQgPD0etWrXEz7/++mvs3r0bI0eORExMjDgg9pw5c9C2bVvMmDEDsbGxYvmCggKMHj0aJSUliI+PFxs0AFBaWoojR46I/y8qKsK0adPg4uKCv/76C02bNhWX3bp1a8ybNw/jx4+v9veUl5eH8+fPo1OnTkoNSrkWLVrAz89P48DmxcXFuHDhAp599lmx7qNHj0ZFRQWOHTuG8PBwsezUqVPxzTffYOLEiUqpYHr16iU2eA4cOKCx0fXxxx/j9u3bWLRoEf773/8CAD788EM89thjGre1oqICp06dgouLCwBZTv6YmBjs27dPTD+jWI+UlBScO3cO06dPR8OGDVUu88yZM5gzZw5atGiBI0eOwM/PDwBQWFiIbt26Yfr06Xj++efh6ekp1vPevXtYunQppk+fDkB20dipUyeNdQcAqVSKNm3aICEhAYWFhXBzc9M6DxER6UZTCszSB7fw4NfPkZGRwcAc0b/YXqLqYhtRhm1EthHZRiRDGDuoYu4xPqu7vinDe6Fds/rY8NtRPN+nE+r4++D81X8wc+lGzJv0LCQS4EDCZfTr3Ap+3l64l/kQ81bvxJIZI+Dv7SGm4qxXJ0Dr2HLGHHevrKwMq1evxrZt27B69WqDltm4XoC4PF9fX43fn6bfiTWP60pElsdUlnZi1apViIiIUHpNmjQJADBp0qQq01atWmXR+q5duxbz5s3DnDlz8Nxzz+H5559H/fr1sWbNGqVyK1euhKOjI5YtWyY2uACgcePGGDZsGPbt24esrCzx8507d+LevXuIiopSanABsqcsFZ/Ei4+PR2ZmJp577jmxwQUAAQEBmDhxIkpLS8Wu+NVx584dVFRUIDBQdXoviUSCJ554AgkJCeINmG+//RadOnUSU7GcOXMGpaWl4jbt3LkTaWlpmDJlilKDC3j0dM+WLVsMrvPPP/8MNzc3TJ06VfzM2dlZ6f+qzJgxQ2xwAcDgwYMByNKWGWr16tWoqKjAokWLxAYXALF+OTk5Sg3vbdu2wd3dXfz9A7LG1Ouvv67T+gIDA1FeXo67d+8aXGciIlJPVQrMyoE6IiKqPrYRZdhGZBuRbUTjSk1NVZmW3JKpybWljzR0mdaQajAowBtzJw2Bg4MECVduKqWX1JTSUZdUrZrX64PWjYNR28cTXdo2Rt/OrcSUm8/07ICXnnoMzUPqYFT/x/Cf53rjmR4dAMjScSqm4gxv0QBBAT4a1zVlyhScPn0asbGxePf/JmDHp69jyYwRAIAlM0YgdsVb+H7eRAzv3QG/fP4aZozuL66rb+dW6NahGUKDg9C+fXvUrl0bADB8+HCDl6m4vPDwcK2BOWv4nRCR7WEqSzshHzxWUUJCAiZNmoRvv/22yoW5pZ/UqJxCo2vXrti1axf8/f3Fz3Jzc3HlyhX4+vpi2bJlVZaRkpICQRBw/fp18Um306dPA1BOhaGOvCGgKnWI/LPqNBbk5OMh+Pr6qi3TtWtX7NmzB3///TfatGmDjRs34vTp09izZw/atGkjPikpb3TJ/5+amlqlO31ZWRkAWQ59Q2RnZ+P27dto3bq10pOpAKqkhKmsefPmSv8PCAgAIHsi1FDybT148GCV8R/k2yj/NysrC/fu3UObNm3g4eGhVLZ9+/Y6rU/esMvIyECjRo0MrjcRERERkSWxjcg2ohzbiDW3jZiamoqMjAyV0wICAvTOVJCamoqwFi1RVFigcrouqclNkd7P1nsmyYNvqnqWBQX4YN7koZi3esej1JKAUnpJdSkdrZ3ibyE8PBwZGRm4fno/unWog5C6snN/ZHgYwls0QOLNNBw9l4g2TYKRmVusddm1a9c2+jINJR/TTp5SE4CYVjM+Ph5ZWVlwdXWFu7s7AOvrwU5EpsHAnJ3QdNIODw+v0uiytEOHDqF79+54+PAhoqOjMWPGDAwbNgz79+8XxxHIyckBILuQVtelHQDy8/PF99nZ2QCAunXraq2DvCGg+ISdnLzxl5ubq9sGaSBPdVFUVKS2TLdu3QDIxgho2rQpjh49isGDB+PPP//E22+/jRMnTkAqlYr7Ub6d27dvx/bt21UuU/F70Yem70XVZ4oqN3Tkg4cLgmBQXYBH27p06VK1ZeTbKv9X0z7VprCwEADECyIiIiIiIlvENqIM24iPsI2ozN7biMYIolWWkZGBosKCaqUmt6YgmqFBQvl8Q4cORUVFhU4BF01BfXnwTZMpw3thSM+OSElLF9NL3s3Mw8ylGzWmdNS23arS6ZpLdX8L6dm5SLhyE1m5+biafB8HDx4UU/LKv/+cnBxcT7mFc17FKCs3LE14dYPJmtJqGnNMOyKyLRYPzKWlpWHbtm04c+YM7t27h4KCAq0XaBKJhAPv2olatWph2rRpSE5OxpdffonvvvsOU6ZMAQB4e8ueFIqIiMCpU6d0Wp58QGhdupDL881nZmZWmSZ/gtHLy0un9Woi70YvX6Yqjz32GJycnHDy5EmEhITA09MT77//PiIjI1FYWIiTJ0+Kg04Dj7bzl19+EVOBGIum70XVZ6Ym39aHDx9q3R+67FNt5PPK9xsRERGRJbG9RDUN24gybCOqxzaibowRRFNHnprcnKobRDPmGGCK6Qv1CbgAqgNGrRrV05ruMSjAB0EBPvBwcxHTS8p7ebVqXA++XrIgeHHJQ+Tk5FQJUAEQg4Tp6enidtvy+M7b9p3G6u3xjz7Q0IvwfwAmD+tp0Hp0+Z1o6hVXr149fPrpp7jw1wG0D/aAu5ur0ph8imPalZWV4Y8//kBaWprFA9dEZFoWDcx9/PHH+PDDD1FSUiJ+pqmRKZFIIAiC+IQV2Y/3338fa9aswYIFCxAVFQWpVAovLy+EhYXhypUryM3N1akBJE9Xsn//fowZM0Zj2ZYtWwKQ5eavTJ4Oo0WLFnpuSVX16tWDv78/kpKS1JZxd3dH+/btceLECXh5eeHJJ59E586dUatWLfzyyy9ISkpSSkMj386TJ08avdHl4+OD4OBg3LhxAw8fPlRKVXLu3Dmjrkv+5Ks8tYoqnTp1wunTp3Hq1Cn07t1b4/J8fHxQr149JCcnIz8/X+npzMopTtS5cuUKAgMDUadOHZ3KExFZO3UpjIyRiouITIvtJarJ2EZkG1EdthH1Y4kgmilUN4hmaFBFVapB+fhtw4cPx4svvoj9u35E5xB3eHpIcf7qP5i5dKPa+qgKGM2dNERrjzlN9AlQAYanuVRMufkwv1DnacYmX9fQXuGYMryXxl6Et+9nYWf8aYwf3A3OLq5Yvf2g1m1TR9PvZMmSJfjjjz9Uzqeq95s8SBgZHobQun64V3Ef7du3R2pqKpYsWYLRo0czMEdk5xwsteK1a9fivffeQ3FxMQRBgI+PDzp16oTIyEi1r549e4r/kn3x9/fH5MmTcefOHaVBxydPnoz8/HxMnz4dpaWlSvOUlpZW+aP37LPPIjAwEDExMTh8+LDStLKyMqXPIiMj4efnh23btuHvv/8WP79z5w7WrFkDZ2fnKmMyGEIikaBHjx64deuWxqc0u3btigsXLmD37t0YMGAAJBIJ+vfvj0WLFkEQBKWByuXbuWTJEpUNoatXr2ps5GnzwgsvoLCwEMuXLxc/Ky0txTfffGPwMlWRP3F45coVtWVeeeUVSCQSvPnmmypvLMfHxyulZBk+fDjy8/OV6l5cXKz0f3Vu3ryJe/fu8RxDRHZDnsIoIiKiyuvll1+2dPWISANraS9dv34dr7zyCkJDQyGVSlGvXj2MHDlSZeDCGtZZnXkFQcCPP/6IQYMGISgoCK6urggODkZkZCQWLlyoFCAl02MbkW1EddhGNL60tDTMmzdPp56lliYPjiQkJODw4cOIi4tDfLwsKBUfH4+4uDjExcXh8OHDSEhIEINocqmpqeL88gfVVq1ahYiICPTo0QP9+vVDv379xIDWzJkz0a9fP/To0UO8jt62bRsA2e+1ffv2CA0OQrcOzdC3cytEhocBANZ/OBlb/zcVw3t3wI8fvoIlM0YAAJbMGIHYFW/h+3kTMbx3B/zy+WuYMrxXtb6T4X0icPqHuRrXt+PT1/Hu/01AbGwshg8fbtB65Ck3VfXu0zTNsHVpH3evQ/NQhLdogNaNg8VehPLvPzI8DH07t8LjbRqjto8n2jQJRrum9bUuU1P9t23bpvZ3oioo1/+J1gBk+0Bxf5/+YS6G9+lkyNdCRHbEYj3m5BdAHh4e+PHHHzF48GA+2WlkQUFBmDt3rs08YfHmm29i+fLlWLx4MSZPngw3NzdMmzYNsbGxWLt2LQ4fPoxevXrB398f165dQ1xcHGrXrq10we7m5oYNGzZgyJAh6N27N4YMGYIWLVogOzsbv/32G3r27Inu3bsDAKRSKb744gtERUWhW7duGDZsGFxcXLBr1y7cu3cPCxcuNNp3N2zYMOzYsQN//vknxo4dq7JM165dsWzZMly+fBlPPfUUAGDgwIH44YcfxOmK27l+/XoMGTIEnTp1wtNPP42wsDAUFBTgr7/+wsmTJ/HTTz+JA22npKRg3bp14vwpKSkAlJ/a6dWrlzgg+pw5c/Dzzz/j3XffxalTp9C8eXP8/vvvRs89PnDgQHzyySf4z3/+g8mTJ4tPII4ePVp8+rVTp05YuHAh3n33XYSFhWHQoEEICQnBvXv3cODAAdy4cQNpaWnik4/vvvsutmzZgnfeeQdHjx5FWFgYdu/eLT7NpIn8Qmro0KFG3U4iIkvRlMKo8MYp5Bxab6GaEZE21tBeOnToEAYNGiSOL1WrVi2kpaVh48aN2Lp1K9avX48XX3zRatZZnXnz8vIwdOhQMQWoRCKBt7c37t69izt37uDgwYP4z3/+g4CAAKNur7mxjcg2ItuIbCOqYqpx39LS0sRgn7yXUeWeaMCjFIuaxsaU03e8LsXeYerG3ZOPyxjs7YRF019GvcAAsedb5VSDvr6+SE9PV1sHuZYNg1SmnYwMD0N4iwZIvJmGo+cS0aZJcLWDWbV9vBDeooHG9WVk5yr1yjK3tIxspGXk6DweXKtG9arVi1AVXcby00RTD8klM0bA39tD7J1Xr04A0rNzsff4JUSGh8HDzUXc3w2D6yLhyk3jbRgR2SSLBeauXLkCiUSCBQsW4JlnnrFUNexaUFCQTQ0WWq9ePURFRWH16tVYsWIF3nzzTTg6OmLXrl1YtWoVYmJisGHDBgiCgJCQEAwbNgwjR46sspy+ffvi1KlTWLx4MeLi4vDLL78gMDAQPXr0wLRp05TKjhkzBn5+fli8eDE2b96M8vJytG7dGosWLUJUVJTRtu3FF1/E9OnTsX79erWNLvng3u3btxcHJn/qqafg4OCARo0aVUmb0a9fP5w+fRqLFi3Cvn37sGfPHvj7+yMsLAyff/45+vXrJ5ZNSUlROTh65c/kja7atWvj0KFDmDlzJv744w/ExcXh2WefxRtvvIHOnTtDKpUa/F0oioyMxMqVK/HVV1/ho48+Ep9CHjBggFJamjlz5iA8PBxffvkl9uzZg7y8PAQFBaFDhw6YO3eu0g2SunXr4tChQ3jrrbewb98+7Nu3D4MGDcKbb76Jxx57TGN9fvjhBwQEBOC5554zyvYREVkLVSmMSh/cslBtiEgXlm4v5eTk4LnnnkNeXh46duyITZs2oVmzZrh9+zbGjx+PP//8E1FRUejcuTMaNWpk8XVWt74jR45EXFwcfHx8sHjxYowaNQpeXl4oLS3FlStXEBMTY/QAhCWwjcg2ohzbiGwjmopiuvRVq1bpFUSbOXMmvLy8NI4jN3z4cEyZMgVZWVligOTGnQyl9IV5+UVKY3atXr0a6enpuHz5MooKC+D1xPNw8qqDsqw7yD21A16dhkIQylGe+AscUQFfLw+0alwPgGz8NidHB3HsNgBij9r4+Hg0aNBADCb5enkgPTu3Wt+fPnRKv5idi4QrN9UGxCrXPyjA22i93hSt2nYA87/d9egDLePBVTe9p6HSMrLxd/Id8bvy9vYWg8l///03GjRogNLSMnh6SJV+Jwy+EZG+LBaYc3d3R1FREbp06WKpKpAFrFu3TumpvMpWrVqllKYEAJycnPDaa6/htdde03k9LVu2xPfff69T2aeffhpPP/20zss2hFQqxdSpU7F48WLcuHEDjRs3rlImJCSkypgh/v7+KC8vV7vcli1bIiYmRu10uV69emkcj0SVRo0aiU+NycXGxop1VaRuv+qy3ilTpoiDuWsyYMAADBgwQGs5AGjatCl27NhR5XNNdUlMTMThw4fxwQcfwNXVVaf1EBEREZmKpdtLX3/9NdLT0yGVSrF9+3Y0aNAAABAcHIzNmzejWbNmyMjIwKJFi7T2GjDHOqsz7y+//IJff/0Vzs7O+PPPP8WxugDA2dkZbdu2xaeffmqUbaSq2EZkG7EythGtS1paGlatWqV1n5TnZQESidp06fLeaBkPizQG0QYMGIAuXbqo7Wn3999/o127dsjJyREDJIpBNF8vWU9JeSBNHoRSHAMs9/gWpbrlntoBAMgDMHq+7PiRjwGmNH7bSuVjSzGg9L9//5XPZw669ADTdfw5ef1NFRCbMrwXhvTsqPN4cBGtmhi9DrpQCiCacH8HBXhj5uinkJ6dq7EXIaBfj1Iish0WC8y1b98e+/fvV8r7TWTP3nnnHXz77bdYuHAh1q5da+nqaHXz5k3xhgYAVFRUiOMH9O/f31LVMpkFCxagbt26mDVrlqWrQkRUYyk+Ya0oICAAoaGhZq4NkWVZur20adMmAMAzzzyjdE0IAD4+PhgzZgyWLl2KrVu34ptvvoGjo6NF11mdeVeuXAkAmDRpklJQjsjU2Ea0bjW5jZiamiqO33f58mXMnz8fzZo10zhPRXEeIAgqU6gXpyXC8a+VaNOwNgQndwCaUyzqk67yf1ATRAOUAiuqxgBr2KgBUpJvok+/SLhWlCDpzDG8O+VFtG/dEunZuVi9/SCG94lA/y6txWBSHX8fjekLHRwkCArwQVCANx7mF2r8zsxheJ8ITBneS21ArHL9NfW+qw7Zd+Jj8vSeuvQi1GTK8F5o16y+zvtb/jvRv54+8HKXYsAbSx59qKEXIQDMnTvXpnq9E5FmFgvMTZs2Dfv27UNMTAz69u1rqWoQmY2Xlxd++OEHnDx5EuXl5Ua5eWFKnTp1QuPGjREREQGpVIqDBw/i9OnTGDVqlN3dsCgtLUWLFi0wYcIEcRwCIiIyH21PWEvd3JF45TKDc1SjWLK9lJ2djQsXLgB4lMausj59+mDp0qXIzMzExYsX0b59e4utszrzlpSUiD1+Ro8eXa1tINIX24jWy57biGV5mWJK8xMnTiArK0tp3LfExEREjRuP0hLlMfjUXadVpiqFekVRnl511CVdpWLvKmcXVzGINmV4L1xISsbCFRvQqBaQWyLg+O0KPBHsAFdH4J/cCnTs2gOegSEoKChESvJNhIYGQ1KUi1vOEvi5OcDfXYK0u7I6lxXlwUfqjFpSF3Rp2xgNg+uKvfJUpS8EgA7NZdesioG56gaM9CVfX7um9TUGxFTV35ZVdxy5oAAftG4cLH5X2va3pnSVivtcVZBWl16Eij1KW7VqZfB2EZH1sVhg7plnnsHcuXPx4Ycfws/PD/Pnz0etWrUsVR0is3jqqafEQbut3ZQpU7B7925s2LABRUVFaNKkCRYtWoS33nrL0lUzOmdnZ7z//vuWrgYRkcEUn2pWpK4HmrXR9IR16YNbePDr58jIyGBgjmoUS7aXEhMTxffNmzdXWUbx8ytXrlQ7MFeddVZn3suXL6OkpAQODg7o2LEjtm/fjs8++0y8Sd2iRQuMGDECr7/+eo1OZUemwzaidTJlG1HddRtgniwBeWd/Q86RnwAAr776qtI0Vb10pM26oOjqMfgPfhNlOfeQc2i9OK0sLxN5Z3+DZ4eBRq1j7dq1ER4ejoyMDFw/vR/dOtRBSF1/AKp7V8kDTbV9vBDeogGyszIgdaxA44geKHDwwPHNv6FZt/5A7j08OH0Gtf194F03EHfv3hPXKZTIAidbt27B7p0SFJQKCK/rgJ9i1qKkXEBipgQ5Ob0AA4NX1Q0YWfv6aipNwTfFfaAqMKdLL0LFHqWKY2cSke2zWGBuwoQJAIDGjRvjq6++wsqVK9GpUyeEhIRoHTRYIpFgzZo15qgmUY21cOFCLFy40NLVICIiLVJTUxHWoiWKCgssXZVqU/WENVFNZcn20t27d8X3devKbkBOnjwZP/30E8aMGYMVK1YojXFy7969Kssw5zqrM++tW7JeI76+vli5cqV4U9rHxwf5+fk4deoUTp06hS1btiA2NlZjz5ni4mIUFz/qYfLw4UP9vgQiK8c2YvVpu24zR5YAzw4D4eDuC9djKzBjVH/UDwrElZv38OG6vXh/XH94ugBLf9yL4i5T4VqvOcoLH6Lo6rEqD08BQHleJnKO/AS3po/rXY/07FwkXLmpcXytnJwcnLt0BZ4Ft1BeUQEASLubhpvuEty+k47iohIA6nujObh7w9HJCwDg6OkLoVR9emihXLYs9+Zd4RUYCm8A8r8c6XdSUXHkEPLzbf96m4xLW/CNiEgdiwXm1q1bB4lEAkA22G5xcTGOHj2qdT5BEBiYIyIiIvpXRkYGigoLVPY2K7xxSumpZiKyHZZsLymOa+fm5oYHDx7g22+/BQB88803WLhwoVLvvbw8/VKUGXud1Zk3NzcXAFBYWIjZs2ejf//++Oabb9CoUSOUlJTghx9+wNSpU3H8+HHMnj0bX331ldptWLRoEebPn2/oV0BENYCm67bqZAlQ1QtPXeYEJ08/OLh6wMVRgovH43DNSYKMAgEAcOpwLCQAKgRAKC1ERVEeyjJk474V37qIsoJssa4AUF6o/wMI8iDaH8cvYskGhXHfNIyvtQJAC3/Z38Q1a9YiwF2C7KIKsRdb+1YtjNY7zMHdG07etZU/y8oBAKSnZ+BmairS7qYBkAUJ3VydxQAh6cfc6T2JiKyJxQJzoaGhYkOTiIiIiKpHVW8z+U0TIrI91tRe8vf3x5gxY7B161a8/PLL8PPzQ1lZmdWuU595K/7tgVFQUIA6depg69atYq84FxcXTJw4ERcvXsQXX3yB7777DosXL4a7u7vKZc2ePVvpZvLDhw8RElK1hwkR2b+SkhKUlJTg0qVLSudyebDMmFkCDMmeUFEie0DBo1UvePrXRVH6A+DKb7jt0gjn/74mK3QgWmmerH3fie8f/Po5AMCzfX+96yvvYZSWkY3RA7qoHQ/Oz02C/BIB/+RWoH14R0jcfXDll/3wbPckvGv7o8QIvdg8PT3QrfsT8PT0QG6W+nKmTnNpbtrGPjNfPWwj3aa1fF+apKWlYdWqVZgyZYpSlgAisl4WC8ylpKRYatVEREREZGPUPfVtjrFYiCzBku0lxXSNhYWyG1AxMTGIiYmp8jkAeHp6WnSdxpp3woQJKlNVjhs3Dl988QUKCwtx+vRp9OjRQ+U2uLq6chw6IkJxcTGuXr2K9PR0/Oc//xHTM+pK3TVPcXGxynPM5cuXVfbC0yVzgoO7D5y8a8OxUPaQQot2bREa6IXLZ8+gdacucK9dD/fvZ2BfbDz69IuER3kuTp5MUEpzmXdur17bJycfX0vdeHCBtf1x78bfeHD6DAKD68PRpy66dS+Ed936cPL0rNKLTZFi70FNwTdPT0/06NkFAJCroa72luaS6Rf1Y87vy9BehGlpaZg/fz6GDBnCwByRjbBYYI6IiIiISJvyvCxAIsHLL7+scro5xmIhqmnk47QBsvHb2rRpU6VMWlqa+D4wMNCi66zOvAEBAeL75s2bq6xbw4YNxfd37txRtwlERACAsrIyCIIAB7daqD1sDoqzHt3I1xQs03bNA4kDIFSoXW/lXniGZE5wd3eDm48X3JwlCA4KgHf9UEilsmBgQIAfyjMLdU5z6ejpBydPP6Xl379/HzdTlR+AkAfRKo8H5+RdGw7SRw9SKAbRgKq92BRlF1WonE9T8E0XmtJcGqK4qAR37tyBpFw5Fabi+HlUs9hKL0Iiqj4G5oiIiIjIalUU5wGCYPSxWIhIvbCwMPF9UlIS+vXrV6VMUlKS+L5FixYWXWd15m3WrJn43lpShxKRfZA4OMIlIBSuruXiZ5qCZZqueeQBPf/Bb8LBrRYKko7CvXlXOLp7G2VMYV1SOiZeuYpzZy/K/qNDmkvXkDYIGPI2nDz9UJ4vC15t2LABUif1QTR9VO7Fpqjoxt9AxhmDlmsuWdk5SDiTgJW3E1R+J7aWHtPeMGhKRKbGwBwRERERWT1jjsVCRJr5+Pigbdu2uHDhAuLj4zF16tQqZfbv3w8A8PPzU9lDzZzrrM68gYGBaNiwIVJSUpSCd4oU04oGBwcbtH1ERLrSNG6wPGCXf24vvDoMhGvdpkYZU1iXXmVhLZohxNdZpzSXDq5uePDr5yjPy4STp1+VMe0UVTeIprIXm7T6KZZNraAgHxUV5XBv3qNKYNEY4+epoirYxEBTVQyaEpE5MDBHRERERERESl566SVcuHABu3btwq1btxAS8qj3Rk5ODtavl/XOGD58OBwdHdUuR7EXWnJyslJaSGOuszrzDh06FF988QWio6Px3nvvwd3dXWn6unXrAMjGo4uIiFBbfyIie6YpzWVoaDCkBfdxzlGCCr96agNj8jHtlD5TSlf5qOeevVDX80oxhacx02Oqoy7YxEBTVZYImuojLS1NTNFdUFCA4uJinD9/HgAQHx+PrCxZt1dXV1e4u7sjKCiI484RWSGLBeY0Nd60kUgkKCsrM2JtiIiIiIiIrIel20uvv/46vvzyS6Snp2PYsGHYuHEjmjZtijt37mDChAm4f/8+pFIp5syZU631GGud1Zn3zTffxKpVq3D37l288MILWL58ORo2bIiSkhL88MMPWLFiBQBg6tSpcHNzM9r2EpH1Ky4uVns+dXJygqurq5lrZH66pLk03rqUx5GzJenpGbiZmqr02ZXEZCQknFbb88qc1AWbrCHQpEhTCsnch7lmTS9prqCprtLS0rBq1Srk5uZiyZIlKsvMnDmzymdz587FvHnzTFw7ItKXxQJzgiBYatVWLzU1VXxyxtoEBARwDBciIiIiIhOzdHvJ29sbW7ZswaBBg3D69Gk0a9YM3t7eePjwIQRBgLOzM9atW4dGjRpZxTqrM2/9+vWxfv16jBw5Env27EGjRo3g6+uL/Px8lJTIbvT16dMHCxYsMNq26oPtQyLLKC4uxsVLlyBUqA6gSBwc0KZ1a5sJzpXlZSLv7G/w7DBQr/l0SXNZkwklhQCArVu3YPfOqsG3CqFCZc8rS42DVznYZMlAU2XaUkhezhCwMv2SUdNLqgoEWuvf3LS0NMyfPx+///47Ro8ejaysLOzf9SM6h7jjxp0MzFy6EUtmjEC7ZvWRl1+Ek7cK0HvIKLRq1crSVSciFSwWmJs7d67WMoWFhUhNTcW+fftw//59dOjQAc8++6wZamc5qampCGvREkWF1vGkSmVSN3ckXrnMxhcRERERkQlZQ3upZ8+eOHfuHD766CP8+eefuH//PgIDA9GzZ0+88847CA8PN9q6jLHO6sw7fPhwJCQk4LPPPkNcXBzu3bsHqVSKTp06YfTo0Zg0aRKcnZ2Nvr3asH1IZHrqesUVFRVBqKiAk3cgJE4uStOEshKU5dxDWVmZSQNzZXmZKM/LRFnOPVld7yQB/wYQim9dREVRHkoybgKQjUPn6OkHJ08/lcsqz8tEzpGf4Nb0caPX80FGJlyKHqKoTEDJveuQODgq1bH0wT8oKReQnpEFB09feHpa/xhwuhL+3R/uzbuqDb7Z6jh45qYphaT8u1T1PRva609Tek9rVrt2bYSHhyMjIwPXT+9Htw51EFLXHwAQGR6G8BYNkJGdi3sV99G+fXsEBARYuMZEpIpVB+bkysvLsXjxYnzwwQfo1q0bli1bZsKaWVZGRgaKCgvgP/hNcVBfa1H64BYe/Po5MjIyqtXwGjduHL7//nvx/46Ojqhduza6d++Ot99+G507dzZGdYmIiOyOql4Tly9ftlBtiMiUrKW91KRJE6xdu9bg+Q3p+VeddVZn3tatWyM6OtqgeU2F7UO2D8m0tPWKAwCJkwskzpbpFZd39jfkHPlJ/H/Wnysevd/3nVLZB79+Dq/OQ+Hg4qZ3rzhDeXp6ICQkGL/s+v3RhwcenUcV65gH4OddcejWPd9m01VqYi3BN21j2tkCTd+lMdNLqgsEWqo3IxHVLBYLzOnD0dER7777LpKSkrBixQp07doVI0eOtHS1TMrZPwSudZtauhomNX78eISGhqKoqAjnzp3Dli1bsGPHDuzcuRODBg2ydPWIiIisirX3miAiy6mJ7aWahu1Dtg/JNMrKytT2iqsozkd5XqaFaibj2WEg3Jo+jvzEw/C4uAWP94hEbimwLzYeffpFok6dAOSnJePkyQQUd5kKJ9+6SN/8gUl6xamsn6cnnh02CHl5+chIvozLZ8+gdacuyBNclOqYlXoV1y6dR8euPVC3SQuz1K0m0pYKklSrkt5Th4CqqjEFTTXWHRHZJ5sIzMk9//zz4uDbbGjavgkTJqB79+7i/9euXYuJEydi+vTpbHgRERFVoq7XROGNU8g5tN6CNbM8Vb0GOe4R1URsL5EtY/uQLElVrzhJmeVvsDv9m5qyOC0RLo4SBAfVRgFkAcTQ0GDUrRuI7IocnHOUoMKvnkV6aHl6esLT0xNC1j9wc5YgOCgAhU5eSnV0LUzHbWcJavv72FUaS0tR1ysuNfWm1lSQ6hgSaFJXD3sOUGkbU9DQse4qS8vIRlpGDrJy83E1+T4OHjyImzdlaWvj4+ORlZWFnJwcXE+5hXNexSgrVx94TUtLw6pVqzBlyhQEBQVVq15EZDw2FZiTSGQnvIsXL1q4JmQK48ePxxtvvIGrV6/iwYMH8PeX5UcuKyvD119/jXXr1iExMRGurq7o2bMnPv74Y7Rp00blsq5cuYLFixcjLi5OHFuiR48emDVrFjp06KBUds+ePVi8eDHOnDmD8vJytG7dGm+88QbGjh1r6k0mIiLSW+VeE6UPblmwNpZVnpcFSCR4+eWXq0zjuEdUE7G9RPaE7UMiw5UX5CiNS1dRlIfS9BTZ/29dRGnOPXHMtwK4wNPTgwEzG6FLrzh90mpqDTQ9ABITW1YJvl1JTEZCwmm19dAUoLLldJuaxhSUj3WXkpIKH093pWn6BitXbTuA+d/uevTByhjx7cyZM5XK/g/AzNFPYe6kIQgK8K6yrLS0NMyfPx9DhgxhYI7IithUYC42NhYAVA7KS7ZPIpHA0VE2QLB8YPXy8nIMHToUu3fvRuvWrTFlyhTk5eVhy5Yt6Nq1K44cOYK2bdsqLScuLg5DhgxBSUkJhgwZgrCwMGRlZWH37t1wdnbGunXrxLLr16/H2LFj4evri7Fjx8LV1RU///wzoqKi8M8//2DOnDlm234iIiLST0VxHiAIVXoRGmvcIyJbw/YS2RO2D8mYiouLVZ4bi4qKTLresoIcZB/eCc8OA+Hk6WfSdSkqSDqK/HN7ASiPSwc8GvdNPuYbAHTr/oRdjvtmj9SNiwYYNjaapkBTccpVVGScwIYNG1QG3yqECpX1kAeo8vOrpuA3ZbpNdb3+ch/mGj0QqCr4Kbl3F4BxetNNGd4LQ3p2REpaOjb8dhTP9+mEu5l5mLl0I5bMGIF2zerj9v0s7Iw/jfGDuyGiVRMEBfgYvD1EZH42EZjLzs7GmjVrsGzZMkgkErRr187SVSIT2LFjB3JzcxEeHo5atWoBAL7++mvs3r0bI0eORExMDJycZD/ZOXPmoG3btpgxY4Z4AwIACgoKMHr0aJSUlCA+Ph5du3YVp5WWluLIkSPi/4uKijBt2jS4uLjgr7/+QtOmTcVlt27dGvPmzcP48eP5NAkREZGVqwljLxFpwvYS2SO2D8lYiouLcfHSJQgV5h9jq6IgBzlHfoJb08eNHpgrKCjE3bv3kJv5EEVlAkruXYfEQRbMdvL0h1vLHnBPOYQ2HcPhWssHBfkFOHzoOPr0i4RzUZY45ptnYAg8PT2MWjcyPX16xRm6PImLLMilKmgnDwKqrEdWjtr1GDuwCGjv9Xc5Q8DK9EsmH3dPl950qoKVqgQF+CAowAcebi6o7eOJLm0bIzO3GAAQGR6G8BYNkHgzDUfPJaJNk2CDg3JMc0lkORYLzDVu3FincgUFBUhPTwcACIIAiUSCt956y5RVIzNZu3YtYmNjUVJSgsTEROzcuRP169fHmjVrxDIrV66Eo6Mjli1bJja6ANnvZ9iwYfjxxx+RlZUFX19fAMDOnTtx7949TJw4UanRBciesuzVq5f4//j4eGRmZmLUqFFiowuQjUkzceJELFq0CL/88gsmT55som+AiIiIiEg1tpeopmH7kEylrKwMQkUFnLwDIXFyUZpWUZyP8rxMC9XMMJ6eHujW/Qkk37iJkycSHk04EC2+zTnyIwCgEED8UVmZ9h1kvUlDQ4MhZAnimG/edQNNVkcG/OyDsYOAxl6mpoCYPNinaZqx6RustCSmuSSyHIsF5lJSUvSex8fHB59++imGDRtm/AqR2UVHRyv9v2vXrti1a5c4dkBubi6uXLkCX19fLFu2rMr8KSkpEAQB169fR6dOnQAAp0+fBgClBpY6ly9fBgB07NixyjT5Z/IyRERERETmxPYS1TRsH5KpSZxcIHF2Vf6sTPcxn4ytLC8TeWd/0zvNpaenJ3r07IK8vDy0btMCGcmXcfnsGbTu1AV5ggv2xcar7BVXUFCIc2cvmHCLqtaRqkdVakZbGIdNztz11xTsM0Vw0RqlZWQjLSMHWbn5uJp8HwcPHsTNmzcByB5AycrKAgC4urrC3d1dfLiLiMzPYoG5qKgorWUkEgmkUinq1q2LDh064Mknn4Sbm5sZakfmcOjQIXTv3h0PHz5EdHQ0ZsyYgWHDhmH//v1wdHRETo7saZKsrCzMnz9f7XLy8/PF99nZ2QCAunW152vOy8sDAPj5Vb0AVmz8ERERERGZG9tLVNOwfUg1TXleZrXSXHp6esLT0xNC1j9wc5YgOCgAhU5eAFT3irt7956xN4FMRFtqRmtn6/W3Zau2HcD8b3c9+mBljPh25syZVcqzFziR5VgsMFf5aTiquWrVqoVp06YhOTkZX375Jb777jtMmTIF3t7eAICIiAicOnVKp2X5+PgAkHXF1sbTU/ZkTGZm1bQVDx48AAB4eXnptF4iIiIiImNie4lqKrYPyZYUFRWJ78vKylBWVobiYtk4UEJ5GUrSrgIAim9dREVRHkoyZD1XSh/cgoO7t/krTDZBl9SM1szW62+tggK8MXfSEAQFqD93TBneC0N6dkRKWjo2/HYUz/fphLuZeZi5dCOWzBiBds3qIy+/CCdvFaD3kFEoKyvD6tWrzbgVRCRnscAcUWXvv/8+1qxZgwULFiAqKgpeXl4ICwvDlStXkJubq1MjSJ6yZP/+/RgzZozGsi1btgQAnDlT9YLg7NmzAIAWLVrouRVERERERERUXWwfkr6Ki4tRVlZW5XPF4JmxCBXlAIDk5GS1ZSqKcpFz/GcAQNa+75SmPfj1c3i272/0emmiOO5bbpZZV00GsvX0i7Zef2sTFOCDeZOHai0TFOADDzcX1PbxRJe2jZGZK3tYoFXjevD1ko37WFzyEDk5ORrTXAYFBXHcOSITcrB0BYjk/P39MXnyZNy5cwerVq0CIOtSnZ+fj+nTp6O0tFSpfGlpKf744w+lz5599lkEBgYiJiYGhw8fVppWVlam9FlkZCT8/Pywbds2/P333+Lnd+7cwZo1a+Ds7IwhQ4YYezOJiIiIiIhIC7YPSR/FxcW4eOkSLl++XOWlKXhmsH8Dc07egXD2D4GzfwicfOvByTsQDm5ecJIAbm6ueKLrYwCAPv0iMWLUc3imdzjqegK+T06FW1g349dLA/m4b/LeoURUs2zbdxoRY+aj39TP8NnKGDz33HNiesuZM2eiX79+6NevH3r06IGIiAh89tlnmDdvnk69zolIf+wxZ6VKH9yydBWqMEed3nzzTSxfvhyLFy/G5MmTMW3aNMTGxmLt2rU4fPgwevXqBX9/f1y7dg1xcXGoXbs2rly5Is7v5uaGDRs2YMiQIejduzeGDBmCFi1aIDs7G7/99ht69uyJ7t27AwCkUim++OILREVFoVu3bhg2bBhcXFywa9cu3Lt3DwsXLuSTIUREREREZHFsH7J9SJqVlZVBqKiAk3cgJE4uStMqivNRnlc1RakxSJxcIHF2lb3/9zNBqICkOBdOjo4ICqoDAAgI8INU6opSZydUCIBQWoiyjFQAqtNcOnr6GTjuHHvFEZFqw/tEYMrwXnqluRwwYACGDBnCv39EJmAVgbns7Gxs2rQJR48eRVJSkjios7e3N5o1a4auXbvipZdegq+vr4VranoBAQGQurnjwa+fW7oqKknd3BEQEGCy5derVw9RUVFYvXo1VqxYgTfffBO7du3CqlWrEBMTgw0bNkAQBISEhGDYsGEYOXJklWX07dsXp06dwuLFixEXF4dffvkFgYGB6NGjB6ZNm6ZUdsyYMfDz88PixYuxefNmlJeXo3Xr1li0aBGioqJMtp1ERERERLpie6nmYvuQ7UPSj2KgTPysrMRCtXkk8cpVnDt78dEHBx6NI6oqzaV3t5Hw6f7/7N17fFP1/T/w12mbpk1PSS8pTagtiNwZFCoOCpQiOhEvFdGpE5y676D7OfedwDa/un1H2Xd+3eZA991UqE6Qr3gFRNQhiEBB/CpIuVPubVNoaJM2DU1zaXP5/RETGpre05y0fT0fjz5MzjnJeQek7ee8z/v9nt/p83ir4gCgvmuhElEflZIQj6xRgwO2uczNGomsUYNhqKtHlasamZmZ0Gq1EkdM1LdJnph7/vnn8cc//tGv57fb7QYACIKA/fv3Y/369ViyZAl++9vf4re//a1UoYZERkYGTp8qgcFgkDqUgFQqFTIyMto/sA1r167F2rVrW92/evVqX6sSAIiKisLPf/5z/PznP+/wOUaPHo0333yzQ8feeeeduPPOOzv83kREREREocL1Uv/G9SHXh9Q3jBw1HBOzxsNQWoKSw4cwdlI2zO5o7NxRhFm35mLgQBUadKU4cKAY9uwnoBgxReqQiagH6PUGlF+T8LpUqYfd1nM3EGhUSixbmAeNStlj5yCizpM0Mfezn/0Mr732mm9hGRUVhSFDhvju9KytrUVZWRmcTidsNht+//vfo6ysDK+99pqUYfe4jIyMbi9uiIiIiIiod+N6iQCuD4n6AoUiFmp1KtzGi4iVCUjTqGCNigcAZGSkQa1ORZ3LhCORAlxJg7rUxpKIwpe70QoA2LhxAz79SPDbV2dz4XStAJNpJpCmDvq5NaoEFCyaG/T3JaLukSwxt23bNhQWFgIARo0ahT/84Q+48847ERsb63ecxWLBxx9/jIKCApw+fRpvvPEG7rvvPtx+++1ShE1ERERERNTjuF4iIur94hQK38y3znCYa2E+vBXihDlM0hH1AW6npyJOMWIq4lP9b7ZprNTCtW8vGhosUoQGANDX1aP4VDmM9Q04W1qNPXv2oLzcM/eyqKgIRqMRcrkcCoUCAKDRaDh3jqibJEvMeReZ48aNw759+yCKYsDjFAoFHnzwQdxxxx2YOnUqTp48icLCQi40iYiIqE/SarUBW5aVlJRIEA0RSYXrJSLqz+x2OxwOR8B9UVFRkMvlAfeFG4VC4Zv51hlOcy1M+95B7LDJTMwR9SERCiWilCn+24wmiaK52uZy+9fHsXL99qs7Vq3zPVyyZEmL1y1btgwFBQUhiJCo75IsMff1119DEAT8x3/8R6uLzObi4+Px7LPPYv78+fjmm29CECERERFRaGm1WowcNRo2q3R3SxJReOB6iYj6K7vdjuMnTsDtcgXcL0RE4Htjx/aa5BwRUUd0Zf6c3daIyspKCE7/Yzo6t87b5lJnqMP827NRptNj/davcP+sSbhca8aSF9/FysUPYeggFQ5UWHBz3sNITExktRxREEiWmKupqQHgacvSUd5jva8lIiIi6ksMBgNsVguS71oKWXK63z7rhW9h2vuWRJERUahxvURE/ZXD4YDb5UKUMhVCVLTfPrejEQ5TFRwOR69PzIliXJfaXBJR39LV+XPGOhOKDxVj1aVixER1b26dRpUAjSoBcbHRSEkQkT1uKGrr7QCA3KyRyFAnocpVjczMTKhUqq5+VCJqRrLEXHx8PGpra1FVVdXh13iPjY+P76mwiIiIiCQnS06HXD3Mb1tTTYVE0RCRFLheIqL+ToiKhiAL/+Sb2+WEy2JChEIJISKyw68TRbFLbS6JqG/p6vw5i6UBLpcTihE5YTm3jojaFiHVib/3ve8BuDo7oSNWrVoFABg7dmyPxERERERERBQOuF4iIuolnA44zbWAM/BMvPaYzWZcvlwFfe0V2BxuNFadh73iOADAXnEc1rLDaKq5iEanG3qDEWazOZjRE1GY8M6fa/4VEavssdcRkbQkq5h78MEHUVRUhI8++gj/9m//hj//+c+tlsLq9Xr85je/wZYtWyAIAh566KEQR0tEREREvU1JSUnA7SqVChkZGQH3EYULrpeIiFpns9nafN6bHCo+hn1ffn11w+41vofGna/7HpsBfLDlC0yb3sBKOyIiol5OssTcwoUL8c9//hMHDx7E2rVr8dZbb2Hy5MkYM2YMEhMTAQBGoxEnTpzA/v374XB47jzKysrCwoULpQqbiIiIiMKc02wEBAELFiwIuD8mVoHTp0qYnKOwxvUSEVFLbpcTAFBaWipxJMEzMWscho8YCkNpCUoOH8LYSdkwu6Oxc0cRZt2ai4EDVTBqz+LciaOYODUH6hs6PnuUiKirNColli3Mg0bF6juiniBZYi4yMhLbt2/HAw88gC+++AJNTU3Yt28f9u3b1+JYt9sNALj55pvx/vvvIzKy4z27iYiIiKh/cdnNgNuN5LuWQpac7revqaYCNZ+sgMFgYGKOwhrXS0REAXyXmItSpkKIir662d7gaSfZC4miCFEU4TZeRKxMQJpGBWuUZ1ZoRkYa1OpUyK16XJIJSElOgCiKEkdMRKGm1xtQrtX6bTMYDD16To0qAQWL5nrOVVffo+ci6o8kS8wBQGJiIj7//HP861//wptvvomvvvoKly5d8jtm0KBBmDZtGh555BHcddddEkVKRERERL2NLDkdcvUwqcMg6jKul4iIAhOioiHI5FefOxqD8r5ulxMuiwkRisAVIm6XE3A64HY2AQBcTTbgu5sjXI1WCC4X3I5GuN2A0+mCxWIJSlxE1D+5G60AgI0bN+DTjwS/fXU2lxQhEVGQSJqY87rjjjtwxx13AACsVitMJhMAQKlUIjY2VsrQiIiIiIiIJMX1EhFRiDgdcJprESGPa7HL7XLCUXfZd6EcAJxX9Fcf11+tXnEBsFhtOHnyDEaOGtqjIRNR3+V2em46UIyYivhU/24ftgsnAcMhKcIioiAIi8Rcc7Gxsf1+cWk2m8N2cHFMTEyfaZtw+PBhTJw40W/bmjVr8Nhjj/XoecvKynD99dfj0Ucfxdq1a3v0XERERETUt3C91P9wfRg6XCNSm5wOuButiFKmwuVoRKTViLj4eDjdQP2VesQPiIcsKgqORhtsFisUsXKMGTMCTpdD6siJqJeLUCgRpUzx3xbTd37+EvVHYZeY6+/MZjPef7MQjobw7I0eFZeEBx5d1OXF12OPPYY333zT9zwyMhIpKSmYPn06fvOb3+Cmm24KVqjtUqvVWLZsGQDPAuyjjz4K2bmDyftnWlpaiiFDhkgdDhERERERBUlfXx8CXCP2BK4Re5YQFQ3B7YIgADJZFCLhaS8XHS2DTCaD4GqCXQAiIiKgUChQb77S6XOIYhymTZ8CUWxZuUdERES9HxNzYcZms8HRUItZw0UkxCukDsdPXb0FO8/WwmazdfuuyMcffxwZGRmw2Ww4cuQINmzYgM2bN+Ojjz7ytenpaWq1GgUFBQCAtWvX9tpFFxER9T5arTbgsO6SkhIJoiEionDVX9aHANeIRM2JooicGdlSh0FEREQ9RLLEnMvlwi9/+Us0NDRg1qxZWLBgQZvHv//++/jss88giiL+9re/QRCENo/v7RLiFVAlxEsdRgDmoLzLT37yE0yfPt33/I033sC//du/4amnngrZoouIiEgKWq0WI0eNhs1qkToUIgpjXC9Rc319fQhwjdhX2e12OByBWzm63e6A36tC1brV7XLC7WwCALiabBBcLrgdds/zRivcLqfnOEej73giIgJ0Oh1Wr16N/Px8aDQaqcMh6pUipDrxxo0b8fLLL2Pz5s2YM2dOu8fffvvt+PTTT/Hyyy/j/fffD0GEFEqPP/44FAoFzp49i5qaGr99DocDL730EiZMmIDY2FgkJCQgLy8Px48fb/E+Z86cwa9//WtMnDgRiYmJiI2NxZgxY/CHP/wBVqu1xfE97dy5c7j33nuhVCqhVCrx8MMPQ6/XBzy2M7EXFBRAEAQIguBr+3L99df7tgmCgLKyMr/XvPHGG8jLy8PgwYMhl8uhUqmQl5eHb775pkc+OxERBWYwGGCzWpB811KoH33J70uZ0/aFdyLqP7heov6Oa8Tev0a02+04fuIESkpKAn6dOnUq4PbS0tKgnL89LosJTrOnTazzih4O4yU46z0dDZz1BrgajAAAh6kKTTUVcDbUeV7XaIXb0Qi32/P/YmuJRyKivkqn02H58uXQ6XRSh0LUa0lWMff2229DEAQsWrQIycnJ7R4/YMAALFq0CM899xzeeecdPPjgg10+9+XLl/Hee+9h+/btOHLkCPR6PWQyGYYOHYo77rgDTz31FNRqdZffnzpPEARERkYCAGQymW+70+nE3Llz8emnn2Ls2LHIz8+H2WzGhg0bMHXqVOzbtw/jxo3zHb9p0yb8z//8D26++WZMmzYNsbGxOHDgAJYtW4Z9+/bhs88+C9ndwzqdDtOnT4der8cPf/hDDBkyBJ988gl+9KMfBTy+M7HPnDnT97rNmzfjyJEj+OUvf4mEhATf9uaPAeCJJ55ARkYGpk+fjvT0dNTU1GDTpk2YMWMGPvvsM9x8883B/iMgIqI2yJLTIVcP89vWVFMhUTREFG6kXC8RhQOuEXv/GtHhcMDtciFKmQohKtpvn8veAKe5ts19PS1CoYTb7Uak1Yi4+HhEREahyeFA/ZV6RMuj0Whv9Dve3ejpduBN3rkAGOvqAXjmy0VGSHbvOxEREfUykiXm9u/fDwC45ZZbOvya3NxcPPfcc77XdtWQIUNgt9t9zwcMGACr1Ypjx47h2LFjeO2117Bp0ybk5uZ26zzUcZs3b0Z9fT2ysrIwYMAA3/Z//OMf+PTTT/GjH/0I69atQ1SU53/ZZ599FuPGjcPixYuxY8cO3/H33HMPfvrTn0KlUvm9/xNPPIFXX30Vu3btwqxZs0Lymf7rv/4LVVVVePHFF/HUU08B8NzFOGnSpIDHdyb2mTNn+hZeZWVlOHLkCJ566qk2B3t//vnnyMnJ8dv2u9/9DqNHj8ayZcuYmCMiIiIKI1Kul4jCAdeIvWeN2Fq7Sm9LSiEqGoJM7rdP+K49ZFv7epoQEQkhMgqCAMhkUYiURUOI8CQ64+IUiI2Ogs1iQWxcHCKion1Ju/gB8RBcDtitVihEERGyaERGRCDiu0QyERERUXsku53H26ph4MCBHX6N95fRa9tYdJbT6URubi7+93//F9XV1TCZTLBYLNixYweGDRuG2tpa3HPPPbh8+XK3zkOte+ONN1BQUIBnn30W9913H+6//35cd911+Oc//+l33KpVqxAZGYm///3vvgUXAAwdOhT33nsvdu7cCaPR6Ns+evToFosWALjzzjsBAMeOHeuhT9TSpk2boFAosHDhQt+2mJgYPPnkkwGP7+nYr11wAcDgwYMxduzYkP65EBEREVH7pFwvEUmBa8SWesMasa12laFqSdkTIiIiEBUZgYjvknbR8mhER3sqN6OjZZBFRSJCAKKiIiGTyZiUIyIiok6RrGJuwIABMBqNfr8wt6eurg4AEB/fvaHXu3bt8hsqDQBRUVG45ZZbsHHjRkycOBEmkwmrV6/GsmXLunUuCmzNmjV+z6dOnYotW7b4tempr6/HqVOnkJiYiL///e8t3qOsrAxutxvnz5/33WHocrnw+uuv480338Tx48dRX18Pt9vt956hYDQaUVVVhe9973uIi4vz25eZmRnwNT0d+7lz5/Dcc89h165dqKysRFNTk29fJBcRRERERGFFyvUSkRS4RmypN6wRO9KuMty4XU64LCZEKJRSh0JE1KP0egPKtVq/bZcq9bDbOl6ZrDPU4WRpJc6WVmPPnj1QKpU4evQoAKCoqAhGoxFyuRwKhQIAoNFooNFogvchiPooyRJz119/PYxGI4qKivx6obdl165dvtd2x7VJuebGjx+PoUOH4ty5czh48GC3zkOt27t3L6ZPn44rV65gzZo1WLx4Me69917s2rXLtwAwmUwAPAuY5cuXt/peDQ0Nvsf//u//jpdffhmpqam4//77odFoEBUVhbKyMrz55pshG8rsjSkpKanFvtZmhPRk7GfPnsX3v/99mEwmzJo1C/PmzfO1g1m7di3Ky8u7/N5ERES9UUlJScDtKpUKGRkZIY6GqCUp10tEUuAasaXetEaUsiVlpzkdcJprESGPa/9YIqJeyN1oBQBs3LgBn37kP0e1zubC6VoBJtNMIE3d7nut3rQby1/b4nmyap3fviVLlrQ4ftmyZSgoKOhK2ET9imSJuR/84Ac4ePAg/v73v2PhwoUYNGhQm8dXVFTg73//OwRBwA9+8IMejc07EDlUA6D7swEDBuCXv/wlSktL8be//Q2vv/468vPzAQBKpefutRtvvBHffvttu+9VXV2NV155BWPGjME333wDURR9+z744AO8+eabPfMhAvCeu7a25d2BgVoL9XTsL730Eurq6vDGG2/g8ccf99v3wQcfdOu9iYiIehOn2QgIAhYsWBBwf0ysAqdPlTA5R5IL5/USUU/iGtGDa0RpREZEQBTjEBkRAafUwRARdZHb6bkxQjFiKuJT/dc1jZVauPbtRUODpUPvlT9vJsYPvw7rt36F+2dNwsDkBBw9exFLXnwXKxc/hKGDVDhQYcHNeQ8jMTGR1XJEHSTZjLknnngCcrkcRqMRM2bMwO7du1s99osvvkBubi7q6uogl8vx85//vMfiamhowMmTJwF4ftlvjd1ux5UrV/y+qOv+8z//E6Io4g9/+INvQHR8fDxGjhyJU6dOdahFx4ULF+B2uzFnzhy/RQsA7N+/v83Xeo+3WDr2Q6k9CQkJGDRoEEpLS/3u1gSAw4cPtzi+O7F77x5t627J8+fPAwB++MMf+m2vra317SMiIuoPXHYz4HYj+a6lUD/6kt9X8l1LYbNaYDAYpA6TKGzXS0ShwjUi14hSiIiMhBgvBpwZ1zxpR0TUG0QolIhSpvh9RcR2ro2vRpWAsUPTkJIgInvcUNxy0xjkZo0EAORmjcS0CcORkaZBZmYmsrKymJgj6iDJfpu47rrr8Ne//hVutxulpaW45ZZbMHLkSDz66KN4+umn8fTTT+PRRx/FyJEjcdttt6GsrAyCIGDFihVIS0vrsbheeuklWCwWyOVyPPbYY60e9/zzz0OpVPq+0tPTeyym/iA5ORmLFi1CZWUlVq9e7du+aNEiNDQ04KmnnvLrdw8ATU1N2L59u++59872/fv3+/XdP3r0KF599dU2zz9s2DAAwNdff93tz+I1b948NDQ04OWXX/Zts9vtfs+9uhN7SkoKAODUqVOtHuN9/2+++ca3zel0YunSpbDb7R34NERERH2LLDkdcvUwvy9ZMn+fo/ARruslolDhGpFrxHDTVtKOiIiIqDMka2UJwHcn569+9SvY7XacPXsW586d8zvG+wuoXC7HihUr8P/+3//rsXgOHz6MP/7xjwCAZ555ps0WRs8884xfH90rV64ENTlXVx+cu/KCqadjWrp0KV5++WX86U9/wqJFixAbG4tf/vKX2LFjB9544w18+eWXmDlzJpKTk3Hu3Dl88cUXSElJ8S02Bg0ahHvvvRcffvghpk6dipycHFRUVGDz5s2YNWsW/vWvf7V67gkTJmDKlCn43//9XzgcDowYMQIA8NRTT/lam3bWb3/7W2zYsAFPP/00vvrqK4wcORKffvppwEVOd2KfM2cO/vznP+NnP/sZFi1ahIEDBwIA5s+fj/j4eABAfn4+1qxZg7lz5+Khhx5CXFwcdu/ejdraWowbNw7Hjh3r0mckIiIiop4Tbuslkk5/XB8CXCNyjdh9bpcTbqcngetqskFwueB2eP68XY1WuJ1NcLs91YUuCIiMiGDijYiIiHqcpIk5wLPYvPvuu/H3v/8dW7duRUlJiW9xKQgCxowZgzlz5uAXv/hFj876MBgMuO+++2Cz2XDLLbfgd7/7XZvHy+VyyOXyNo/pipiYGETFJWHn2VoA5qC/f3dFxSUhJiamR9570KBBePTRR1FYWIhXXnkFS5cuRWRkJLZs2YLVq1dj3bp1WL9+PdxuN9LT03HvvffiRz/6kd97vPnmmxg8eDA+/PBD/M///A9uuOEGvPTSSxg5cmSbCxcA+PDDD/Hkk09i27ZteOeddwAAjz32WJcXXWq1Gnv37sWvfvUr7Ny5Ezt37sQdd9yBpUuX4vvf/36L47sae25uLlatWoX/+Z//wXPPPYfGRk8f6dtvv9236Lrxxhuxbds2/Od//ifee+89yGQy3HLLLfjrX/+KH//4x136fERERETU88JlvUTS6M/rQ4BrRK4Ru89lMcFp9sz1c17R++1z1ntaV7sAGOs8rVFFMQ5ivH/rUCKivkivN6Bcq/XbdqlSD7utsVvvq9PpsHr1auTn57OtJVEbJE/MAZ4WCi+88AJeeOEFNDU1wWg0AgASExMhk8l6/Pz19fWYM2cOLly4gPHjx2PDhg2+nuyhJooiHnh0ka+HfriJiYlp0d++M9auXYu1a9e2un/16tV+bUoAICoqCj//+c87NCsjPj4eL774Il588cUW+5q3/whErVZjw4YN7Z6jM4YNG4bNmzd3KJbuxJ6fn+8biN6aWbNmYdasWS22tzWvhIiIiIikJ/V6iaTT19eHANeIbcXCNWL3RSiUcLvdiLQaERcfj4jIKDQ5HKi/Uo/4AfEQXA7YrVYoRBERsmjOjyOiPs/daAUAbNy4AZ9+JPjtq7O5cLpWgMk0E0hTt/oeGpUSyxbmQaNqOa9Op9Nh+fLlyMvLY2KOqA1hkZhrTiaT+doshILNZsM999yDb7/9FsOGDcO2bdu6fPdbsIii2O3FDRERERER9T2hXi+R9Lg+JOo6ISISQmQUBAGQyaIQKYuGEOG5EB0dLQMcbjQJQFRUJCJ5owMR9QNup6ciTjFiKuJT/bstNFZq4dq3Fw0Nbber1qgSULBoLgDA8F3FMRF1Ttgl5kLJ4XDggQcewK5du5Ceno4dO3ZArW79bgAiIiIiIiIiIiIiot4sQqFElDLFf5vRJFE0RP1Pv03MuVwuPPLII/j444+RmpqKHTt2YPDgwVKHRUREREREREQUVux2OxwOR4vt4dpmlYiIiCic9dvEXH5+Pt59910kJydjx44dGDFihNQhERERERERERFJorXkW1NTE86fvwC32yVBVEREFK50hjqcLK3E2dJq7NmzB0qlEkePHgUAFBUVwWg0Qi6XQ6FQAAA0Gg3nzhF9p18m5hYvXozXX38dSqUS27dvx/e+9z2pQyIiIiIiIiIikoTdbsfxEyfgdrWefItSpkKIivbb5rI3wGmu7enwgioyIgKiGIfIiAg4pQ6GiCgM6fUGlGu1vueXKvWw2xpbHLd6024sf22L58mqdX77lixZ0uL4ZcuWoaCgIKixEvVW/S4xp9Vq8dJLLwEAGhsbcccdd7R5/OXLl0MQFRERERERERGRNBwOB9wuV5vJNyEqGoJM7rdPcLS8UBvuIiIjIcaLAMDEHBFRM+5GKwBg48YN+PQjwbe9zubC6VoBJtNMIE3t254/bybGD78O67d+hftnTcLA5AQcPXsRS158FysXP4Shg1Q4UGHBzXkPIzExkdVyRM30u8Scq9ndX1arFVarVZI43G63JOclouDjv2ciIiIi6g7+Pknhoq8k39wuJ1wWEyIUSmnjAP9tE1Hv4XZ6vt8rRkxFfGqGb3tjpRaufXvR0GDxO16jSsDYoWlISRCRPW4ohqSpkRgfBwDIzRqJDHUSqlzVyMzMhEqlCt0HIeoF+l1ibsiQIZIueiIjIwF4erTHxsZKFgcRBU9TUxOAq/++iYiIiIg6gutDoh7idMBprkWEPE6S07sBuJxONDX1vqQmEVGEQokoZcrV50aThNEQ9U39LjEnNZlMBrlcDpPJhPj4eAiC0P6LiChsud1umEwmyOVyyGQyqcMhojCi1WphMBhabC8pKZEgGiIiCkdcHxL1PW63G06XG4ZqHex2u9ThEBERURhiYk4CKpUKly5dwsWLF6FUKiGTybgAI+pl3G43mpqaYDKZYDabkZaWJnVIRBRGtFotRo4aDZvV0v7BRETUr3F9SOHAm0ByO5uAa/7/czsdYb/v2u1uZ5PvudvpgNsNOJxOuAWH3/s5nS64vPsc3d/ndLpgtTWiukqHk0cPAIgAERER0bWYmJPAgAEDAAAGgwGXLl2SOBoi6g65XI60tDTfv2siIsDzM95mtSD5rqWQJaf77bNe+BamvW9JFBkREYUbrg8pHDQ2NsJgMCDS6gQi/TuBuJtscFmvhPW+FtudTXA2GBFpdcLtbIJgN8NssUC4ZvyAs6kRjTY75OYGRERFdW+fG3C5XKjUnsemdauQlDoQyuuGBfrjJiLqszQqJZYtzINGJe2MT6Jwx8ScRAYMGIABAwagqakJTqdT6nCIqAsiIyPZvpKI2iRLTodc7X9BpqmmQqJoiIgoXHF9SFI7ceIEfvaznyHl3mcRrcrw22c59w2Mu9ZIsi9CoYSlZC8Uo3MQpVAGfJ3DYoLl9D7Uf7sFymkPI0o5EI7aSzB9/QGUU34IR70BirJduHFyNmITkxGnUEChUAAA9BdO4ETxt7gxZybiUwf7xdHZfW640dTUiLLDX+HEof3Iuf2uzvwVEBH1CRpVAgoWzQUAGOrqpQ2GKIwxMScxmUzGC/tERERERETE9SFJRhAElJeXw260Qi73Tw6bDfWokWgfjFZc/vBlqAcMh1wtBnxd3ZcfwbTvHc+Ly5/3/2Dlf/U9/PZkOQBg2vQpyJmRDQAw1lRDd7EcJmMNEJfo99Ku7iMiosB0Oh1Wr16N/Px8aDQaqcMhkhQTc0RERERERERE1Ks4zLUwH96K2OHZcDmbEHd8Aybn5CI2UYXqagN27ijCrFtzIbMZce7EUUycmgMxNR2iGCd16ERE/ZJOp8Py5cuRl5fHxBz1e0zMERERERERERFRr+I018K07x3EDpuMqAEpiI4UkKZJwQB1OmJi5ACAjIw0uI1uXJIJSElOgFKdKnHURERERECE1AEQERERERERERERERER9QesmCMiIiIiIiIi6ge0Wi0MBkOL7SUlJRJE489hroXTXAuHqQoAYK88AzgbPY8rjsNlM6PR4JkT11RTgQiFUrJYiYgouDh/jvobJuaIiIiIiIiIiPo4rVaLkaNGw2a1SB1KQObDW2Ha947vufHzV64+3vm637E1n6yAmDk7ZLERERGg1xtQrtX6bbtUqYfd1tjiWJ2hDidLK3G2tBp79uyBUqnE0aNHAQBFRUUwGo2Qy+VQKBTfvbee8+eoX2FijoiIiIiIiIiojzMYDLBZLUi+aylkyel++6wXvoVp71sSReYhTpiD2GGT0XD6S8Qd34DJObmobwJ27ijCtJwpiItTwGqoxPHjp9A09m5ExsQD8FTTNZmq0Oh0Q28wwoJoCIKAadOnQBTjUG+U9GMREfV67kYrAGDjxg349CPBb1+dzYXTtQJMpplAmtq3ffWm3Vj+2hbPk1Xr/F6zZMmSFudYtGhRUGMmCndMzBERERF1UTi3gyIiIiIKRJacDrl6mN+2ppoKiaK5KkpMQpSYBLvuNKIjBaRpUmBBNADAXG/Gvr1fXz344Me+h95qOjOAD7Z8AQCYNn0KcmZkAwDqQxM+EVGf5f6urbBixFTEp2b47Wus1MK1by8aGvyrsfPnzcT44ddh/davcP+sSRiYnICjZy9iyYvvYuXihzB0kAoHKiy4Oe9hJCYmQq/Xo7CwMGSfiUhqTMwRERERdUG4t4MiIiIiChcOcy3Mh7dCnDAHUWJSp18/ctRwTMwaD0NpCUoOH8LYSdkwu6Oxc0cRZt2aC5nNiHMnjmLi1ByIqekQxbge+BRERP1bhEKJKGWK/zajKeCxGlUCxg5NQ0qCiOxxQzEkTY3EeM/35tyskchQJ6HKVY3MzEyoVCoUFxf3ePxE4aTHE3NDhw4N+nsKgoDz588H/X2JiIiIOirc20ERUe8Q7uul8+fP4/nnn8f27dtRXV2NpKQk5Obm4je/+Q0mTpwYlHME85zBjPf222/Htm3bAABr1qzBY4891tWPRNTvOc21MO17B7HDJncpMadQxEKtToXbeBGxMgFpGhWsUZ5WlhkZaXAb3bgkE5CSnAClOjXY4RMRURDp6+phrG/o8Pw5jUbDuXPU5/R4Yq6srKxDxwmCALfb3aF9giAEPI6IiIgo1MK1HRR1XWutSFUqFTIyMgLuI+qqcF4v7d27F3fccQfMZjMAYMCAAdDpdHj33XexceNGvPXWW3jggQeCcq5gnDOY8b799tu+pBxRb9PbWm13t5qOiIh6l007D6LwwyLPkw7Mn1u2bBkKCgpCEBlR6PR4Yu7RRx9tdZ/L5cKmTZvQ0NAAt9uNwYMHY/To0UhMTAQAGI1GnDx5ElqtFgAgiiLuvfdeRERE9HTYRERERNTPOM1GQBCwYMGCgPtjYhU4faqEyTkKqnBdL5lMJtx3330wm82YOHEi3nvvPQwfPhyXLl3C448/js8//xyPPvoobrrpJlx//fXdPl93zxnMeI1GIxYvXozRo0eHbSKDqDW9sdV2W9V0ohiHadOnsDUlEVGY0+sNKP/ud1KvS5V62G2NLY6dN+tGzM4e2+H5c6yWo76oxxNza9asCbjd4XDgzjvvRENDA26//Xb8+c9/xrhx4wIee+TIEfzHf/wHtm3bBoPBgI8//jjgcUREREREXeWymwG3O2B70qaaCtR8sgIGg4GJOQqqcF0v/eMf/4Ber0dMTAw+/PBDDB48GACQlpaG999/H8OHD4fBYMDzzz+PwsLCbp+vu+cMZry//vWvUV1djfXr1+MHP/hBUD4bUaj0tVbboigiZ0a21GEQEVEr3I1WAMDGjRvw6Uf+XRvqbC6crhVgMs0E0tTQqJRYtjAP44ddhysN1g7PnyPqiyQrPVuxYgU+//xzzJ49G//6179aXWQCQGZmJrZu3YrbbrsNn332GVasWBHCSImIiIioP/G2J23+de3FTaKeJvV66b333gMA3H333b4kl1dCQgIeeeQRAMDGjRvhdDq7fb7unjNY8e7ZswdvvPEG5s2bh1tvvbV7H4hIQoF+lkUpQzN7zWGuhf3yOThMVQAAe+UZ2CuOex5XHIe17DAaDeUAPDe+OK1XunQeVtMREUnP7fRUxClGTIUy+0G/L8XIaXC5nGho8FRxa1QJKFg0FxpVgoQRE4UHyRJz69atgyAI+Pd///cOv+aXv/wl3G433nzzzR6MjIiIiIiISFpSrpfq6upw7NgxAMDMmTMDHjNr1iwAQG1tLY4fP96t83X3nMGKt7GxEfn5+YiJicHKlSu78jGICID58FZcfvMpX3We8fNXYNz5uufxztdR/d7vUP/1BgBAzScrYD29r0vn8VbTiaIYnMCJiKjLIhRKRClT/L4iYpVSh0UUtiRLzJWWlgIAUlM7fseW91jva4mIiIiIiPoiKddLp0+f9j0eMWJEwGOabz916lS3ztfdcwYr3ueffx6nTp3CM88806LqriPsdjuuXLni90XUH4kT5kD96EuIn3I/1CJwz5xczLo1FwAwLWcKbrt9FnImjUJiDCDeeDcixWQAV6vpmmouotHpht5ghNlslvKjEBEREfUIyRJz8fHxADzzEDrq8OHDAMC7oYiIiIhIEiUlJSguLm7xpb1m0DlRd0m5Xrp8+bLvsVqtBgAsWrQI8fHxeOKJJwAAGo3Gd0xVVVW3ztfdcwYj3tOnT+P555/H0KFD8etf/7pLn+H555+HUqn0faWnswUu9U9RYpKndeaAFERHCkjTpCAjIw0AYK43Y/tnO7H321Mw2gDzwY9h2vc2gKvVdOaDH+OyGfhgyxc4VHxMyo9CREQh4p0/p1Gxyo76B8kSc9nZ2XC73Vi2bFmHLmRotVosW7YMgiAgO5uDf4mIiIgodJxmIyAIWLBgAW688cYWXyNHjWZyjoJKyvVSQ0OD73FsbCxqamrw2muvwWw249VXX0VtbS1iY2N9xwSjoqU75wxGvPn5+bDb7XjxxRcRExPTpc/wzDPPwGQy+b4qKiq69D5EfdnIUcPx2E8exl03T8QNiUDeD7J91XSzbs3FQw/fh9nTx+OGROD+O3MwMav1+ZpERNR3cP4c9TeSJeaWLl0KQRBw6dIlZGZm4plnnkFRURGqqqpgt9tht9tRVVWFoqIiPP3008jMzMSlS5cgCAJ+9atfSRU2EREREfVDLrsZcLuRfNdSqB99ye8r+a6lsFktMBgMUodJfUg4rZeSk5PxyCOPQKFQYNGiRUhKSgrq+wf7nJ197RtvvIGioiLMmTMHeXl5XY5ZLpdjwIABfl9E5E+hiIVanYrkhHjEygSkaVS+arqMjDQMGZIBdUoCYmUCUpIT2DGJiKif0+l0KCgogE6nkzoUoqCKkurEOTk5+Otf/4qlS5fCZDLhL3/5C/7yl7+0erzb7QYAvPDCC5g+fXqowiQiIiIi8pElp0OuHiZ1GNQPSLleiouL8z22Wq0AgHXr1mHdunUttgPBGTXQnXN257V6vR6//vWvER0djb/97W/d/hxEREREFDw6nQ7Lly9HXl6eX2tyot5Osoo5AFi8eDF27NiBiRMnwu12t/k1adIkfPHFF1i8eLGUIRMREREREYWEVOsl75w2wH9+W3PN71pOTU2V9Jzdee2zzz6L2tpaLFmyBMOHD+984ETUIaIYh2nTp0AU49o/mIiIiKiPk6xizmvWrFk4ePAgSkpKsG/fPpw9exYmkwkAkJCQgBEjRmD69OkYMWKExJESERERERGFlhTrpZEjR/oenzlzBrfeemuLY86cOeN7PGrUKEnP2Z3Xnj17FgDwpz/9CX/6059aje/xxx/H448/jsGDB6OsrKydT0PU87RabcAWyiUlJRJE0z5RFJEzo3vzL4mIiIj6CskTc16jR4/G6NGjpQ6DiIiIiIgo7IRyvZSQkIBx48bh2LFjKCoqwhNPPNHimF27dgEAkpKS8L3vfU/Sc0oRL5GUtFotRo4aDZvVInUofhzmWpgPb4U4YQ6ixI7PhWQ1HREREfU3YZOYIyIiIiIiovDw4IMP4tixY9iyZQsqKiqQnp7u22cymfDWW28BAObNm4fIyMhW30cQBN/j0tJSDBkypEfO2dXX7t69u40/havxr1mzBo899libxxKFisFggM1qQfJdSyFLTvfbZ73wLUx735IkLqe5FqZ97yB22OROJuZYTUdERIDOUAedwQRjfQPOllZjz549KC8vBwAUFRXBaDQCAORyORQKBSIiIrB582bk5+dz/hz1OpLOmCMiIiIiIqLw8+STTyIlJQU2mw333nsvzp07BwCorKzEgw8+iOrqasTExODZZ58Ni3NKES+R1GTJ6ZCrh/l9RSm7P/ORiIhICqs37caNjyzHrU/8FX9dtQ733XcflixZAgBYsmQJbr31Vtx6663IycnBjTfeiFdffRXLly/3myVM1FuERcXc5s2b8fbbb+PAgQOorq6G3W7H0aNHMWbMGN8x//rXv1BWVoYBAwZgwYIFEkZLREREREQUOlKsl5RKJTZs2IA77rgDBw8exPDhw6FUKnHlyhW43W7IZDKsXbsW119/fbfPFYxzShEvEREREQVP/ryZyJsxEWU6PdZv/Qr3z5qEy7VmLHnxXaxc/BDGD78O5gYbDlRYcHPew3A4HCgsLJQ6bKIukTQxV11djQceeAB79+4FALjdbgD+7U686uvr8eSTT0IQBEyZMgXDhg0LaaxEREREREShJPV6acaMGThy5Aiee+45fP7556iurkZqaipmzJiBp59+GllZWd0+RzDPKUW8RERERBQcGlUCNKoExMVGIyVBRPa4oaittwMAcrNGImvUYBjq6lHlqkZmZia0Wq3EERN1nWSJuaamJtx+++04cuQI3G43ZsyYgfHjx+Mf//hHwOMfeOAB/OpXv0JlZSU2btyIp59+OsQRExERERERhUa4rJduuOEGvPHGG11+vTeZGKpzdjfea3UlfqL+wGGuhdNcC4epCgBgrzwDOBs9jyuOw2Uzo6nmIhqdbugNRkSIiRBFUcqQiYiIiMKGZIm5VatW4fDhw4iOjsbmzZtx++23A0CrC01BEPDQQw9hxYoV2LVrFxNzREREFBJarRYGg6HF9pKSEgmiIaL+guslIgpn5sNbYdr3ju+58fNXrj7e+frV4wB8sOULTJvegJwZ2aEMkYiI+hB9XT2KT5XDWN+As6XV2LNnD8rLywEARUVFMBqNAAC5XA6FQgGNRgONRiNlyERtkiwx995770EQBPziF7/wLTLbk5OTgxUrVuDEiRM9HB0RERGRJyk3ctRo2KwWqUMhon6G6yUiCmfihDmIHTYZDae/RNzxDZick4v6JmDnjiLMujUXAweqYNSexbkTRzFxag7UN4ySOmQiIurFNu08iMIPi65uWLXO93DJkiUtjl+2bBkKCgpCEBlR10iWmDt58iQAYNasWR1+zXXXXQcA0Ov1PRITERERUXMGgwE2qwXJdy2FLDndb5/1wrcw7X1LosiIqK/jeomIwpHDXAvz4a0QJ8yBXD0Mdt1pREcKSNOkwIJoAEBGRhrU6lTIrXpckglISU5gG0sion5Mrzeg/Jp5cJcq9bDbGtt9rUalxLKFeZg7Mwv582aiTKfH+q1f4f5Zk3C51owlL76LlYsfwvjh18HcYMOBCgtuznsYY8aM6amPQxQUkiXmrFYrAHSqpLSx0fOPVS6X90hMRERERIHIktMhVw/z29ZUUyFRNETUH3C9RERA4JbaUrbTdpprYdr3DmKHTUaUmCRZHEREFP7cjZ7fZzdu3IBPPxL89tXZXDhdK8BkmgmkqVt9D40qAQWL5vqex8VGIyVBRPa4oaittwMAcrNGImvUYBjq6lHlqkZmZiaamppQUFCA/Px8trSksCRZYi41NRUVFRUoKyvDhAkTOvSagwcPAgAGDRrUg5ERERERERFJi+slImJLbSIi6s3cTs9NY4oRUxGfmuG3r7FSC9e+vWho6JmfcTqdDsuXL0deXh4TcxSWIqQ68bRp0+B2u/Hmm2926Pimpia8/PLLEAQBM2bM6OHoiIiIiIiIpMP1EhE1b6mtfvQl35cyZ4HUoREREXVYhEKJKGWK31dErFLqsIgkJVli7qc//SkAYMuWLfjDH/7Q5rFmsxkPPvggTp065fdaIiIiIiKivojrJSLy8rbU9n5FKVOlDikgUYzDtOlTIIpxUodCREREFNYka2V58803Y/78+Vi/fj2WL1+OLVu2IC8vz7f/yy+/xOHDh/HNN9/gnXfeQU1NDQRBwOOPP46bbrpJqrCJiIiIiIh6HNdLRCQ1h7kWTnMtHKYqAIC98gzwXVsye8VxuGxmNNVcRKPTDb3BiFQxETkzsqUMmYiI+hGNSollC/OgUbH6jnofyRJzAPDGG2/A4XDgvffeQ3FxMQ4dOgRB8AyC/H//7//5jnO73QCAH/7wh1i1apUksRIREREREYUS10tEJCXz4a0w7XvH99z4+StXH+98/epxAD7Y8gWmTW9gYo6IiEJGo0pAwaK50BnqUHyqHMb6BpwtrcaePXtQXl4OACgqKoLRaAQAyOVyKBQKREREYPPmzcjPz+f8OZKMpIk5mUyGd955B/fffz/++te/Yv/+/b5FZXM33ngjfvWrX+HBBx+UIEoiIiIiIqLQ43qJiKTiMNfC1WhFygN/gE17FHHHN2ByTi7qm4CdO4ow69ZcDByoglF7FudOHMXEqTlQ3zBK6rCJiKgfWr1pN5a/tuXqhlXrfA+XLFnS4vhFixahsLAQeXl5TMyRZCRNzHndd999uO+++1BTU4MjR47AYDAAAJKTkzF+/HikpKRIHCEREREREZE0uF4iolBzmmtRf2Az4sbMRNSAFERHCkjTpMCCaABARkYa1OpUyK16XJIJSElOgCiKEkdNRET9Uf68mcibMRFlOj3Wb/0K98+ahMu1Zix58V2sXPwQxg+/DuYGGw5UWHBz3sNwOBwoLCyUOmzq58IiMeeVnJyMWbNmSR0GERERERFR2OF6iahv0mq1voR7cyUlJRJEQ0RE1LtoVAnQqBIQFxuNlAQR2eOGorbeDgDIzRqJrFGDYairR5WrGpmZmdBqtRJHTBRmiTkiIiIiIiIiov5Cq9Vi5KjRsFktUodCRERERCHCxBwRERERERERkQQMBgNsVguS71oKWXK63z7rhW9h2vuWRJERERH1fvq6ehSfKoexvgFnS6uxZ88elJeXAwCKiopgNBoBAHK5HAqFAhqNhnPnKCQkS8ytW+cZwnjdddd1uB2LyWTCRx99BAD48Y9/3GOxERERERF1Vmstx1QqFTIyMkIcDfV2XC8R9S+y5HTI1cP8tjXVVITk3A5zLRymKgCAvfIMXDYzmvRlnucVx9FkqkKj0w29wQhBMQA3fT8LohgXktiIiIi6Y9POgyj8sOjqhlXrfA+XLFnS4vglS5YgPj4e+fn5TNBRj5IsMffYY49BEAQAwM9//nOsXLkSUVFth3Px4kU89thjiIiI4EKTiIiIiMKC02wEBAELFiwIuD8mVoHTp0qYnKNO4XqJiELFfHgrTPveAQAYP3/Fb59x5+ueYwB8sOULAMC06VMgimJIYyQior5Jrzeg/JqZb5cq9bDbGrv1vhqVEssW5mHuzCzkz5uJMp0e67d+hftnTcLlWjOWvPguVi5+COOHXwdzgw0HKiy4Oe9hOBwO3H777cjLy2NijnqU5K0s3W43Xn75ZRw4cAAffPABrrvuug69hoiIiIgoHLjsZsDtDtiGrKmmAjWfrIDBYGBijrqE6yUi6mnihDlwOZsQd3wDJufkIjZRhepqA3buKMKsW3Mhsxlx7sRRTJyaAzE1ndVyRETUbe5GKwBg48YN+PQjwW9fnc2F07UCTKaZQJq6S++vUSWgYNFc3/O42GikJIjIHjcUtfV2AEBu1khkjRoMQ109qlzVyMzMhPaaJCFRT4mQOoD58+dDEATs378fEydOxLZt26QOiYiIiIio07xtyJp/XZuoI+osrpeIqKdFiUmIGpCC6EgBaZoUDBmSgYyMNABARkYa1CkJiJUJSElOgFqdymo5IiLqNrfTUxGnGDEVyuwH/b4UI6fB5XKiocEicZREPUfyxNwzzzyDTz/9FElJSaipqcGdd96J3//+97zLk4iIiEJGq9WiuLi4xVdrM8OIiEKF6yUi6ikOcy3qvlwPh7lW6lCIiKifilAoEaVM8fuKiFW2+Rq7rRGVlZUo12r9vi5VVna7BSZRqEjeyhIAZs+ejYMHD+KBBx7A/v378dxzz+Hrr7/G22+/DZVKJXV4RERE1IdptVqMHDUaNivvxiOi8MT1EhH1BKe5FqZ97yB22GSpQyEiIuoQY50JxYeKsepSMWKiutcCU19Xj+JT5TDWN+BsaTX27NmD8vJyAEBRURGMRiMAQC6XQ6FQQKPRcO4cBU1YJOYAICMjA3v37sXixYvxyiuv4IsvvkBWVhbee+89ZGdnSx0eERER9VEGgwE2qyXgfDDrhW9h2vuWRJEREV3F9RIRERER9Sd6vQHl18x802rL4XI5oRiRg/hU/xnejZVauPbtbbcFpkalxLKFedj+9XGsXL/96o5V63wPlyxZ0uJ1y5YtQ0FBQec/CFEAYZOYAwCZTIZ//OMfmDZtGhYtWoSLFy9i5syZ+NOf/oTFixdLHR4RERH1Yd75YM011VRIFA0RUUtcLxFRqIhiHKZNnwJRjEO9UepoiIioP3E3WgEAGzduwKcftayKA662wGwuwmjq0PtrVAkoWDQXOkMd5t+ejTKdHuu3foX7Z03C5Vozlrz4LlYufgjjh18Hc4MNByosuDnvYYwZMyYIn47II6wSc14/+tGPkJmZifvvvx+nTp3Cr371K+zbtw9Lly6VOjQiIiKisOYw18J8eCvECXOkDoWIegjXS0TU00RRRM4MTzVuvcSxEBFR/+J2eubEKUZMbVEVZ7twEjAcCsp5NKoEaFQJiIuNRkqCiOxxQ1FbbwcA5GaNRNaowTDU1aPKVY3MzEy2kKegipA6gNaMGTMGBw4cwAMPPAC3240PP/wQd999t9RhERERUT/lMNei7sv1cJhrpQ6lTd55Mc4wj5OIuofrJSLqDIe5Fg5TFQDAXnkG1rLDsFcc9zyvOI6mmotodLqhNxhx+XIVzGazlOESERH5quKaf0XEiFKHRRQUYZuYA4C4uDi8++67+Nvf/oaoqCjfwEUiIiKiUOuJhFdvSfYRUXjieomIOsp8eKtvbq7x81dQ/d7vYNz5uuf5ztdhPvgxLpuBD7Z8gbVvvI1DxcekDJeIiCjs6HQ6FBQUQKfTSR0K9QGStbL88Y9/DEEQkJiY2O6xv/jFL3DTTTfhgQcewMWLF0MQHREREVHHNW8fGSUmdfh13mRf7LDJnXodEfV9XC8RUTB4f0eJHZ4Nl7MJccc3YHJOLmITVaiuNmDnjiLMujUXMpsR504cxcSpORBT0yGKcVKHTkREFFZ0Oh2WL1+OvLw8aDQaqcOhXk6yxNzatWs7dfyUKVOg1Wp7JhgiIiKibmgrwdbVpB0R9W9cLxH1LVqtFgaDocX2kpKSHj2v3+8oA1IQHSkgTZOCAep0xMTIAQAZGWlwG924JBOQkpwApTq1R2MiIiIKVxqVEssW5kGjUkodCvVxkiXmiIiIiPqDnqyKu3ZejMtmRpO+zPO84jgcljoAQFNNBQAgUkxqNYbmCcTO7CMiIqK2abVajBw1GjarRepQiIiIqA0aVQIKFs2VOgzqB5iYIyIiIrqGw1wL5zVJLzgbPY8rjsNlM6PRUA7Ak/SKUIT2bjpvoszVaEX9gc0APPNimvPOjQGAmk9WAACU036EhOnzA75n8wRiZ/YRERFR2wwGA2xWC5LvWgpZcrrfPuuFb32z34iIiKh30ul0WL16NfLz89nmkjqEiTkiIiKiZhzmWhi2/AX2iuO+bc2TXs0TXoAn6SVmzm73fZ0WE+yXz3U42QchAtaz/xewBaY3UZbyw+VAZFSr82LinPU4cKAY9uwnIB80ApE9ULHHNp1EREQdI0tOh1w9zG+bt6qdiIiIwofOUAedwQRjfQPOllZjz549KC/3rNeLiopgNBohl8uhUCgAAHq9nvPnqFN6VWLOYrHg22+/BQDMmDFD4miIiIioL3Kaa2GvOI7ku5ai0VDuS3rVNwE7dxRhWs4UxMUpYDVU4vjxU2gaezciY+IBtF1NZznzFRqObPOdpyPJPvORbW22wIxUKNucFxNjqcaRSAGupEGQq4fBYa5F3Zfrg9aSsifbdPY1rc0QUqlUyMjICHE01FdxvUTUv7XX4rrJVIVGpxt6gxEWREMQBEybPgWiGId6o4SBExERhZnVm3Zj+Wtbrm5Ytc73cMmSJS2OX7RoUSjCoj6kVyXmSktLMXPmTERERMDhcEgdDhEREfVhsuR0uBotvqSXBdEAAHO9Gfv2fn31wIMf+x4GSrDJh0wEAESJyUj8wROwXTwGRdlefG9iFpyR0fhy79eYdWsuBg5UoUFX6qtwi0pUw9wskRcMbEkZek6zERAELFiwIOD+mFgFTp8qYXKOgoLrJaL+qTMtrs0APtjyBQBg2vQpyJmRDQCoD1m0RERE4S9/3kzkzZiIMp0e67d+hftnTcLlWjOWvPguVi5+CEMHqXCgwoKb8x5GYmIi9Ho9CgsLpQ6bepFelZjzcrvdUodARERE/dTIUcMxMWs8DKUlKDl8CGMnZcPsjsbOHUUYcv1glJWW+x1vLzsEADDte9u3zQqg6KtiZE4YB8BT3aZWp6LOZfJVuEXEiD32GZwWU6t31FvP7UfTFc++hlP7PPstdZ5jK47D8d1jtt7qGJfdDLjdAecKNdVUoOaTFTAYDEzMUVBxvUTUv3S0xbXMZsS5E0cxcWoOxNR0iGKc1KETERGFJY0qARpVAuJio5GSICJ73FDU1tsBALlZI5GhTkKVqxqZmZlQqVQoLi6WOGLqbXplYo6IiIhIKgpFLNTqVLiNFxErE5CmUcEa5Wll+f3JWZh587SASTtvVZxRe9Z3USwiXoUjh4+1eb72ZtNd25bKYrG2+xmat9W89o765gnE+m8+8NvXvCKw5pMV7Z6Hrgo0V4iIiCiY2mtx7Ta6cUkmICU5AUp1qsTREhER9U76unq/2XNKpRJHjx4FEHj+XEREBDZv3oz8/HzOnyMfJuaIiIioX9BqtTAYDH7b9Ho9Dhw4AKD9WSw2yNo9R1tJO29VnNyq910Us0bFAgAsFisuX65Cfe0V2BxuNFadhxARCQCoP7AZtu+q7oDAs+mat6W66ftZvnkxDksrcY6YiojY+IB31E/LmQJXvQEV589h6JhxiElMgaXBgi/3fo2bvp+FGJfFN1tPECJR/+3mgLP1IsUkzp0jIiIiIiKiPmXTzoMo/LDI86TZ7Dmg9flzhYWFyMvLY2KOfHo8Mbdu3dX/OX/84x8H3N5Rly5dCkpMRERE1PfpdDqsXr0a+fn5aGpqwshRo2GztpKpQsdmsaSnp/VI26fTp87iyOHjVzfsXuN72Dwp5+VtmdlaWypRFGE2m6FvlugD4Es6Omoq4G7ytOGIlkUhJkYOlcqTRBs+fCjcxmjUV57H2JFDoLxuGC5frsKXe7/Ggf3N2nO0M1sv/qa5iIiOhThhDhN0RG3geomIiIiIKHj0egPKtVq/bZcq9bDbGoPy/vNm3YjZ2WN9s+cGJifg6NmLnD9HndLjibnHHnsMgiBAEAS/haZ3OxEREVFP0Ol0WL58OfLy8gAANqulxZwvp8WEhlN7MKD0iw7PYhHF4M1+E8U4TJs+BSNG3tDq3LrWWmCWlZa32ZbqUPEx7Ptyv+dJs0QfEDjp6J1315a7826Hu76q1RgbdKU4cKAY9uwnEJWohv793yN22GQm5ojawPUSEXWGw1zb6pzYrra4JiIi6gvcjZ6feRs3bsCnH/n/Hl1nc+F0DXD69GgITv8EXUeTdhqVEssW5mH8sOtwpcHqmz03JE2NxHjPDbycP0cdFZJWlm0NH+dgciIiIgqVQHO+HKbLiNbu7NYsFm+CrbPVdKIoImdGtu95Z1tgtmVi1jgkyuy+JJoiZVCbSUeLxdruvLtkVRLckZZWY6xzmXAkUoAraRAiYoKXwCTq67heIqKOMh/eCtO+dwB0rNq/eYvremNIQyUiIgop93cJN8WIqYhPzfDbZy87C5dhP9avX4+YqABJu1oBJtNMIE3d6vtrVAkoWDQXAHClgTe+UPf0eGKutLS0zf3bt2/H8OHDO/Rep0+fxu233x6MsIiIiIiC5toEm/++riXtghFTckK8L4mmvC6jzaTj5ctVIY2vNQ5zLcyHt7IFJvUbXC8RUWeIE+bA5WwKOCe2vWr/eoljJyIiCoUIhRJRyhS/bUK0p7VloKRdY6UWrn170dDQ+uiLjtLX1cNY34CzpdXYs2cPlEoljh49CgAoKiqC0WiEXC6HQqEAAGg0Gs6d66d6PDE3ePDgNvcPGjSo3WO8zGZzMEIi6peaz1riN3wiotBpK2kXTponEK+9o76tfV3RVvLNaa6Fad87bIFJ/QbXS0R9h1arhcFgaLG9pKQkaOeIEpMQNSAF0ZFCt6r9iYiI+qNASbsIoylo779p50EUfljkebLKf2b0kiVLWhy/bNkyFBQUBO381HuEpJUlEUmv+aylaxNzTNoRUW+n0+mg0+lgsVhgt9sBwO+utNhYT+vHppoKzwuECFjP/h/ECXMkibe7gp0o87zn1QTitXfUt7UPACwWKy5frkJ97RXYHG40Vp2HEBEJwDPvxmUzo9FQDsDzd+C0XmHyjYiI+hStVouRo0bDZu3+3faBNL+phYiIiMKLd/7c3JlZmJ09Fuu3foX7Z03CwOQEHD17EUtefBcrFz+EoYNUOFBhwc15DyMxMZHXYfsxJuaIwlQok2U9kbRjso+IgqUj309Wr16N5cuXB9zX/K60mk9WAADEzNkwH9mG2GGTWxzfE0mvrmirBWZ7ibJQ8cZYeqEcB/Y3G2i9e43voXfejVfNJysgZs4OVYhEREQhYTAYYLNakHzXUsiS0/32WS98C9Pet7r1/s0ryomIiCi8NJ8/FyuXISVBRPa4oRiSpkZivGdNn5s1EhnqJFS5qpGZmQmVSiVhxCS1CKlObDQaUVtbi9GjR0sVAlFY8ybLdDpdwH0FBQUB94VLHOESPxH1fm19P/HKz8/Hjh078Nt//wk2v/AkdrzyK6xc/BAAYOXih1D49INQi0DiD56A+tGXEDtyWqvv5U16eeexSKUn4gj2vDtvjJOn3IjHfvIw7rp5Im5IBPJ+kI1Zt+YCAGbdmouHHr4Pd9+c5fs7aOvPn4g8uF4i6p1kyemQq4f5fUUp2VKSiIiIiK6SLDGnVCqhVCohCEKHXzNy5EiUlpbiwoULPRgZUfhr7SJ1qBNeHblY3tnXMWlHRF2h0WiQmZmJjDQNpk0YjltuGoPcrJEAPHelTRqVgehIAbKkQZCrhyEydoDEEUujp5KOoihCrU5FckI8YmUC0jQqZGSkAfDMuxkyJANpqUm+vwPvn7/TYoL98jk4TFUAAHvlGdgrjnseVxyHteywXwtMh7k2qHEThTOul4ioo4J94w0REVF/pNcbUK7V+n1dqqyE3dYodWjUB/WqVpZRUVEdHnxOFC7aasEW7HaP3oRXdna2L7HlnbfUfNaS0ejpzSaXy6FQKKDX67t97mBpq60mEdG1mn8flclkUodDAbQ1f67+wGbYyg75jjV+/srVxwFaYCqn/QgJ0+eHJvAQKikpCbhdpVIhIyMjxNFQb8b1ElHP02q1MBgMLba39r08FMKlxTUREVFv5G60AgA2btyATz/yvymuzubC6VoBJtNMIE0d+uCoz+pViTmi3qi9+W09kYTatGkTCgsLA+5rPmvJa/Zsz6yfcE/aERFdq/n30dYSGPq6etQYDL6kEAA06csAeKqymkxVaHS6oTcYYUE0RDFO8jaWfcnpU2dx5PDxqxuazZ9rnpTzGnL9YJSVlmPWrbkYOFCFBl0pDhwohj37CShGTAlFyCHjNBsBQcCCBQsC7o+JVeD0qRIm54iIwoRWq8XIUaNhs1p69DwOcy2c5lq/inI4PXfr83cXIiKi4HJ/9zNWMWIq4lP9116NlVq49u1FQ0PXf/ZrVEosW5gHjUrZYl+wizao9+i3ibni4mJ8/fXX+Oabb/DNN9/gzJkzcLvdePTRR7F27Vqpw6N+Rq/Xo7i42FfdBqBFhZs3UeY9vi3z5s1Dfn4+jEYjdm15GzelK3Ch0oAlL76L26aMxfavT/gdv23bNgBdT9oFO/6u4A8yot7N+2947ty5cLlcAFqv+O3s95NNOw+i8MMiz5NmSSHgalWWGcAHW74AAEybPsV31zl138hRwzExazwMpSUoOXwIYydlw+yOxs4dRb7km1F7FudOHMXEqTmIiFehrLQcGRlpUKtTUecy4UikAFfSIESJSVJ/nKBy2c2A243ku5ZClpzut6+ppgI1n6yAwWBgYo6IKEwYDAbYrJaA37etF76Fae9bQTmP+fBWmPa943seqKKcv7sQEREFV4RCiShliv82o6nb76tRJaBg0VwAgKHOv7adncP6r36bmJs1axZMpu7/wyICup8U6m6Fm/citbd9SkpKCrKysmAwGHD+4C5MmzAQ6epkz/vNn43nf34/ynR6rN/6Fe6fNQmXa83dStqtXLkS27dv73b8QNsX2dtrC8ofZES9V/PZk535frho0aJW39N7V9rcmVmYOCwVf339fYydlA1FyiBUVxt8iSGZzehLComp6ZzPEiTeeTcDB6ogiiLcxou++XPWqHgA8CXf5FY9LskEpCQnwBoVK3HkoSdLTodcPUzqMIiIqIMCfd9uqqkI2vuLE+YgdthkNJz+EnHHN2ByTi7qm8DfXYiIiCTinT/ndalSz9lz1C29KjFXVlaGn/zkJxAEAV988UW33is6OhqTJk3ClClTMGXKFKxcuRLFxcVBipT6m+4mhebNm4cHHnjAV90mxsXg6NmLXUqWAVcTXiaTCefLKnAk3g6H01OBkpIQj6xRgxEXG42UBBHZ44aitt5T5dbVpF2gpNzsKWOx7esT3a7QuzZp19k/Z1bSEfUubVX8rlz8EIYOUuFAhQU35z2MxMRE6PX6VhN5ze9Kq63R+5JCyusyEBMjB+BJDLmNbl9SSKlODdVH7fOaz7shotAI5nqJiKQTJSYhSkyCXXca0ZEC0jQpsCAaAH93ISIiCqXW5s9x9hx1V69KzDU0NGD37t0QBKH9g9tx8eJFREdH+56/9tpr3X5PorZaOn788cfYv38/nE4nIiMjAQBVVZ6ZASdPnsTgwYPR1OSAGBeDxPg4jBk6CIAnWZY/L9eXKBuYnOBL2rXm2oTXXwAsundGu/F3NWm3cvFDSFbG4aOig3j8rmkYNFAFfV09tn19os34O5u0a6sypjXtzfhj0o4ovLRV8Ttm6CBERUbA3njFV/V+8uRJAJ5k/uDBg303IyTGx0GjUkKjSpDqo1APcJhrYT68FeKEOX2urSVRMARzvURERERE1N+1Nn8uGLPnqH/rVYm5YGqelKP+pSeTMW21pCwoKGj1dc2TUH/57r/eRFpKQjyGaJJ9ibIhaWokxntalbz1X4sQK48KmCgbP/w6XKo2+pJlsmg5Cj/c0+XP1lbSLjdrJOJio/HVkdP43g1pGJKmRvGp8nbjbytp19nKmK5g+0ui3sVvVtyqdX77An0fXbYwz1cxR72HtwVmoLZcTnMtTPveQeywyUzMERERERERUUhcO3+uK7PndIY6nCytxNnSauzZswdKpdJX0BGoc5hGo+H1yj6sVyXmamtrAcBXbUTUFT2ZjGmrJWXBwnsgCMDu4hLcetMYJCnjUVV7BQWFH7VacdZeIm30EE2ribKsUYNxulznS5bJ5TFYtjAPGpUyqJ+5O9pK2uVmjUSGOglVrmpkZmZCpVL52s22VZnY2tw9IgofOp0OOp0OAHz/jq/9NxyoFe+8WTdidvbYVpP5yco4bNj+Ne6dMRYDkxMwMDHe1wPeYDBI82EpoLaSb2yBSdR1XC8REREREYWn1Zt2Y/lrWzxP2rjZ2GvZsmVtFnpQ79arEnOvv/46ACAtLU3iSKg/815QDpQUaqsl5d0zJiAuNhqV+ho8PPv7vqqygsKP2qw4C5bms5Za7lOGXdJOX1cPY31DwLtIVq5cGXCuHdD63D0iCo2OVCWvXr0ay5cvD7ivrVa87SXzG+1WlF84jV3m04iJ8m/jVmdz+T1vnhiqN3blk1J3MPlG1DO4XiLqu/i7CxERUe+WP28mxg+/rsOdw1gt17f1eGJu3bp17R/UhqamJlRWVmLLli0oLi6GIAi47777ghRd19ntdl9SBgCuXLkiYTQUCt6LzfX19Vi5cmXAY9pqSdlZzZNlVxqsXXqPjp8r+Em77sbfVsu6QEm52VPGembaPXwb0lIScPhiA8ZPmQmdToeVK1f6qnAA+Krp9Hp9p+MiorZ1ZK7j3LlzkZeXB6PR6KswvlBpaLUV73XqFGhUCe1+P7FYGuByOaYBhWMAANFKSURBVKEYkePX+x0AbBdOAoZDvufNE0P1Qfz8RESd1VfXS0QUXPzdhYiIqHfTqBIwdmhahzuHUd/W44m5xx57LGjDx91uN8aNG4ff//73QXm/7nj++edbvduf+ibvxebPPvsMd9xxR8B2lV1tSRlI82TZtReiwzFp1zLG7sXfkZZ11/45b/v6BFa+3Sxpt/FT38NAlXSzZ88GgIBJO/ZxJgq+5km7rKwsGAwGnD+4C9MmDES6OhlA4Fa8Q9LUmDDCk2jryPe8a3u/A0BEjBj8D0Q9ymw2w2xuQH3tFdgcbjRWnYcQ4WnPZ684DpfNjEaDp7q8qaYCECJgPft/ECfMkTJsok7rq+slIuo8h7kW5sNbIU6Yw1mqRERERH1YyFpZut3ubr3+hhtuwMMPP4ynn37aNwBRSs8884zfhf4rV64gPT1dwoioueZVGS6Xp31Za3OMgKvJmIiICGzevLnNFmwpKSnIyMjwXUxWJcT73d3Q0y0pgdaTXqFuSdlW8q2rr/N+hvHDrsOVBmurd5G09uf81n8tQqw8ypfQu1xrxpIX38VtU8Zi+9cn/M61bds2AOzjTEQUjg4VH8O+L7++umH3Gt9D487X/Y6t+WQFxMzZMB/Zhthhk0MVIlFQ9bX1EhF1ntNcC9O+dxA7bDITc0RERL2AXm/wzbb3ulSph93WKFFE1FuELDG3fft2DB8+vNOvi4yMRGJiIuLi4nogqq6Ty+WQy+VSh0Gt8FZl6HQ6FBYWBjwmUDJm0aJFKCwsDNiCravarioLbuVbW9VtvUVXk31eo4doEBcb7Uvo1dZ7Ws4umT8bz//8fpTp9C2Sdt7WeeYGm6+X85gxY4L5sYiohzT/PlpnNEgdDgXRxKxxGD5iKAylJSg5fAhjJ2XD7I7Gzh1FmHVrLgYOVKFBV4oDB4phz34CUYlqmI9skzpsoi7ra+slIiIiIqK+yt3ouWa5ceMGfPpRyxn3p2sFmEwzgTR1l8/hLTxpq4CEeq+QJeYGDRqEwYMHh+p0RACAefPmIT8/v805Rs2TMQ6Ho9VEXle1XR3WvSQUdVxKQjyyRg0OmLTzts4z1NX7ejk3NTWhoKAg4A8//mAk8tDpdNDpdAA6VpXcE3Mdm38fLTkb9LcnCYmiCFEU4TZeRKxMQJpGBWtUPAAgIyMNanUq6lwmHIkU4EoaxHal1OtxvUQUPrRaLQyGljf8lJSUSBANERERhRu301MRpxgxtcWM+8ZKLVz79qKhwdLu+7TV/az5OBBef+x7QpaYI5JCSkpKu3OMmidjtN+VHuv1ehQXFwMIfLF58ODBOF9WgSPxdiTGx0Ffx/HbUgt29WFbP/z4g5HIY/Xq1a3OW+3IXEeTyeT7XpqsFEPaipf6l+Yze4iIiNqi1WoxctRo2KztX0wjIiKi/i3gjHujqcOvb36zsYHXl/sVJuaIAti0aVOHWmD+xbtt/m1BTQpRYG23BWX1IVGoNJ/jmZeXF7AquTNzHf8CYNnCvF7fipdCx2Kx4vLlKtTXXoHN4UZj1XkIEZEAAHvFcTgsdQCAppoKAIDTesU3s4eIiKgtBoMBNqsFyXcthSzZf4689cK3MO19KyjncZhr4TTXwmGqAgDYK88A3919b684DpfNjKaai2h0uqE3GBEhJkIUWR1ORERE1Bf0eGKutLQUAJCWltbTp6J+qiOt1JpXZTicLgCAvq4exafKYaxvwNnSauzZswfl5eUAPK2EXn31VZjNZhz7Zjcy0+JQb7WjoPAjrFz8EJKVcfio6CAev2saBg1UQaNSQqNKAMCkUE/qSvKtrZJwIuqa5lWjrVUld2Su46Vqo+976Y1jbpD4U1FvcvrUWRw5fPzqht1rfA+NO1/3Pa75ZAUAQMycHbLYiDqL6yWi8CRLTodcPcxvm/eGj2AwH94K0753fM+Nn79y9XGzn2VmAB9s+QLTpjcgZ0Z20M5PREREvRNH7PQNPZ6YC9c5CWazGTabzfe8qakJAGC32/16ycfHx0Mul4c8Pmqf95tQfX09Vq5cGfCYQFUZi+6dAQDYtPMgCj8surpz1Trfw4KCghbv5X1dbtZIxMVG46sjp/G9G9IwpBtDPKnnNU/mtdzHpB1RT+nIXMfT5Trf91LvzQ0dYbc1orKyEsJ3d5V7BZoFQ32LKMZh2vQpGDHyBkzMGg9DaQlKDh/C2EnZMLujsXNHEWbdmos4Zz0OHCiGPfsJyAeNgNN6BeYj26QOnyigcF0vEVHPEifMQeywyWg4/SXijm/A5Jxc1DfB97Ns4EAVjNqzOHfiKCZOzYH6hlFSh0xERESdoNcbUP7d2CSvS5V62G2NLY7VGepwsrTSVzyiVCpbFJ7I5XIoFAqUlJRwxE4f0G9bWT755JN48803W2x/99138e677/qer1mzBo899lgII6OO8lZsfPbZZ5g/f37AVmqBqjKuU6dAo0rA3JlZyJ83s8PVHLJoOQo/3CP1x6Yg8ibtdIa6VqsnP/74Y+zfvx8A4HQ6ERkZiaoqT7sZ7w9GAL4fjhEREdi8eTPvWiHqIcY6E4oPFWPVpWLERAl+++psLomiolARRdGvWsBtvIhYmYA0jQrWqHgAQEZGGmIs1TgSKcCVNAhy9TDYL59r9T05f46obefPn8fzzz+P7du3o7q6GklJScjNzcVvfvMbTJw4MezO2ZXXXr58Ge+99x62b9+OI0eOQK/XQyaTYejQobjjjjvw1FNPQa3mzXgUXFFiEqLEJNh1pxEdKSBNkwILogF4fpap1amQW/W4JBOQkpzANpZERES9hLvR0+Vr48YN+PSjltctTtcKMJlmAs2KPVZv2o3lr23xPGlWPAK0LDyhvqHfJuao70hJSWm1lVqgqowhaWpMGJHhe31Hqzm8+6jv8fvhB7RbPekV6AfjokWLUFhYyLtWqNcL19YIFksDXC4nFCNyEJ+a4bfPduEkYDgkUWQULiwWq9/sOQBo0pcB4Pw5os7au3cv7rjjDpjNZgDAgAEDoNPp8O6772Ljxo1466238MADD4TNObv62iFDhsBuv/q7/oABA2C1WnHs2DEcO3YMr732GjZt2oTc3NygflYiIiIi6nvc33X3UYyY2uK6RWOlFq59e9HQYPHbnj9vJsYPv85XPDIwOQFHz170FZAMHaTCgQoLbs57GJcvX8aCBQtC9nmoZ4RNYu7y5cvQ6XSwWCxwuVxwu91tHj9jxoxunW/t2rVYu3Ztt96DiPqG/HkzkTdjYsDqyYKF9yA1eQCqa69gd3EJbr1pDJqcbt+8wfHDr4O5web74ehwOFBYWBjwPOGa6CAKxFuVnJ2d3ak5nslKMSQtYiMUSkQpU/y3xfBOcrpm/lyz2XMA589R7xbq9ZLJZMJ9990Hs9mMiRMn4r333sPw4cNx6dIlPP744/j888/x6KOP4qabbsL111/frXMF45zdea3T6URubi5++tOfYvbs2UhJSYHD4UBRURF+9rOf4dy5c7jnnntw6tQpVs4RERERUYcEvG5hNAU8VqNKwNihab7ikSFpaiTGxwHwFJBkqJNQ5apGZmYmEhMTezx26nmSJ+YKCwvxl7/8xTf0vCMEQYDD4ejBqIhaaj6P7EqDVepwKIg0qgRoVAkBqyfvnjHBVz1Zqa/Bw7O/j9p6OwoKP/JVVhrq6n0/HLXX9I5uzpvoYDUd9SabNm1qNdkcaI7nsoV5nOtIkho5ajjSE2W+2XOKlEGorjb02vlzJSUlAberVCpkZGQE3Ed9i1TrpX/84x/Q6/WIiYnBhx9+6JuFl5aWhvfffx/Dhw+HwWDA888/3+rPiVCeszuv3bVrF6ZPn+63LSoqCrfccgs2btyIiRMnwmQyYfXq1Vi2bFlQPisRERERUUeUlOkCjt8JNGJHo9HwmmMvIWli7re//S3+9Kc/tXu3J5FOp+tUxYbDGfw5Q955ZACYmCOiXqU71Zrz5s1Dfn5+h+d43jjmhlbfq/n3UaJgE8U4TJs+BQMHqlBvr/HNnlNel4GYGDmAzs+fk5LTbAQEodUWJTGxCpw+VcLkXB8n5XrpvffeAwDcfffdviSXV0JCAh555BG8+OKL2LhxI1599VVERkZKes7uvPbapFxz48ePx9ChQ3Hu3DkcPHiw25+RqC3en2WiGCd1KERERBQmFvxns5vKmo3fCTRiZ9myZW2O5aHwIVlibv/+/b5F5pQpU/CTn/wEgGc+kyAI+OKLL1BXV4ejR4/i7bffxpkzZ5CVlYXnn38e0dHRUoVNElm9ejWWL18ecF+gio0l82/rUlUGqzmoM/R19Sg+Vd7mXSveO1YAQK/XSxku9WNtVWu2l7Tr7BxPjSohFB+JqAVRFJEzIxsAUN/KMZ2dPxcpJiFKTOrJsFvlspsBtxvJdy2FLDndb19TTQVqPlkBg8HAxFwfJuV6qa6uDseOHQMAzJw5M+Axs2bNwosvvoja2locP34cmZmZkp2zp+NNSEgA4KlEJOoIh7kW5sNbIU6Y06mfI81/lhEREREBwFv/tQix8qgW43cCjdgZM2aM1OFSB0mWmCssLITb7casWbOwfft2RERE4MSJE7793gXV3Llz8bvf/Q7PPPMMXnjhBbzwwgvYti182w1Rz8jPz0deXl6nKja6cnGY1RzUGZt2HkThh0VXN7Rz18qiRYtCERZRp3iTdsOHD8fo0aMlq0omCoXOzp+Lv2kuIqJjIU6YE7IYryVLTodcPUyy85N0pFwvnT592vd4xIgRAY9pvv3UqVPdTsx155w9GW9DQwNOnjwJALjxxhs79Boip7kWpn3vIHbYZMlu8CAiIqLezVtAMmvSKFxpsLYYvxNoxI5KpZI4auooyRJzRUVFEAQBCxcuRERERJvHRkRE4M9//jOOHTuGbdu2obCwEPn5+SGKlMKBtz8uKzYoVNqqnvTumzszC/nzZqJMp29x10rBwnsQr5Dj8MUGjJ8yE6IooqqqCkDgajr2gCaptdYuL1BV8qJ7Z4QgIqLg68r8Of37v0fssMlSh079kJTrpcuXL/seq9VqAJ4bjN555x088sgjeOWVV/x+b/H+jtMd3TlnT8b70ksvwWKxQC6X47HHHmvzWLvdDrvd7nt+5cqVDp+H+o+uVtMRERFR36HXG1Cu1fptu1Sph93W6HvOsUp9m2SJOe/iafjw4b5t7S04Fy5ciM8++wzr1q1jYo6IelRb1ZPX7ouLjW5x10qloe5qNd3GT/1eH6iabsmSJYiPj+/SDDCiYHjrrbegVqs7VJUsi5aj8MM9UodM1GF9bf4c9Q9SrpcaGhp8j2NjY1FTU4PXXnsNAPDqq6/ij3/8IwYMGOA7xmw2d/lcwThnT8V7+PBh/PGPfwQAPPPMM+22jn3++edbbb9P5MVqOiIiov7L3ehJsG3cuAGffuTfJr3O5sLpWgEm00wgTR364CikJEvMORyOFttEUfQ9rqur8/Xy9xoyZAgA/1Yl1Pc1n38kk8mkDoeoQ+bNuhGzs8f6KukGJifg6NmLvkTH0EEqX//nxMRE6PV63H777QFngBF1hk6ng06n87WkBNCiLWWg2YejR49GRkZGh6qS5fIYzuOkXqUj8+eIwk04rZeSk5PxyCOPYOPGjViwYAGSkpICxhcu5wxGvAaDAffddx9sNhtuueUW/O53v2v3Nc8884zfDVhXrlxBenp6G6+g3oyVb0RERNRZbqenIk4xYiriU/1v+mqs1MK1by8aGixShEYhJllibuDAgbh48SJ0Op1vW2pqKqKiouB0OnH48OEWg7u9xza/I5L6Pu/8o7y8vHbvUiUKFykJ8RiiSfZV0g1JUyMxPg6AJ9GRoU7y6/9cXFzc6ns1T04zaUet8f5/Ul9fj5UrVwY8JlC15uzZswF4knaDBw/2zZG7XNN6+y3O4yQi6nlSrpfi4uJ8j61Wz12969atw7p161psB/wThlKcM9jx1tfXY86cObhw4QLGjx+PDRs2IDIyst3PIJfLIZfL2z2OwoNWq4XBYGixvaSkpEOv91a+RQ8aBae5Fg6Tp0WqvfIM8N1FN3vFcbhsZjQaygEATTUViFDwxiYiIqL+LkKhRJQyxX+b0dSh17Y1fofXEHsPyRJz48ePx8WLF/Htt9/izjvvBABER0dj/PjxOHToEP7xj3+0WGiuWbMGAJicIQBtfxMKBbutEZWVlRCcjX7br+0HTNRdzZPT/KHav7X1C5b3/5PPPvsMd9xxh68lpRgX46vWvG3KWGz/+oTf67Zt2wbAP2n3l57/KERhx2Kxor72CmwONxqrzgMAmvRlADwXVh2WOs+2mgoAQKSYxAoJ6lFSrpe8c9oAT0vN733vey2OuTZh2F3dOWcw47XZbLjnnnvw7bffYtiwYdi2bVuLykTq/bRaLUaOGg2btft3pFvOfIWGI9t8z42fv3L18c7X/Y6t+WQFxMzZ3T4nERER9V9t3SzNa4i9h2SJuZkzZ+LTTz/Fli1bsGzZMt/2Rx55BMXFxfjwww/xox/9CPPnz4fNZsN7772HjRs3QhAE3HPPPVKFTWFEyooNY50JxYeKsepSMWKiQtMPmInA3qF5wpiDWSnYOvILVkpKil9LSlVCvK9ac8n82cifl9tqi9VkZZxvjpzJ0oQF/1kYyo9HJAnv/LnSC+U4sP+76uXda/yOaX5hteaTFQAA5bQfIWH6/JDFSf2PlOulkSNH+h6fOXMGt956a4tjzpw543s8atSobp2vu+cMVrwOhwMPPPAAdu3ahfT0dOzYscMv6Ud9h8FggM1qQfJdSyFL9m83ar3wLUx73+rweylGTEX8hDloOP0l4o5vwOScXNQ3ATt3FGFazhTExSlgNVTi+PFTaBp7NyJj4gFcraZrqrmIRqcbeoMREWJiUCpQiYiIiCi8SZaYmzdvHn7961/j8OHD+PrrrzFlyhQAwBNPPIF169bh0KFDeP/99/H+++/7vS4jIwP/8R//IUXI1MsFM7FlsTTA5XJCMSInJP2ApUgEUtc0Txi3lpjT19XDWN+As6XV2LNnD5RKZYdmgHUWy9fpWu21WI2LjeYcOep3vPPnzGYzUuPcKDl8CGMnZUORMgjV1Qbs3FGEWbfmIs5ZjwMHimHPfgLyQSMAIQJ1X66HOGGO1B+B+igp10sJCQkYN24cjh07hqKiIjzxxBMtjtm1axcAICkpKWCFWijPGYx4XS4XHnnkEXz88cdITU3Fjh07MHjw4G5/LgpvsuR0yNXD/LZ5K6M7KlKhhFw9DHbdaURHCkjTpMCCaACAud6MfXu/vnrwwY99D5vf9GEG8MGWLzBteoNvJioRERER9V2SJeauv/56XLhwAU6nE8nJyb7tMpkMO3bswL//+7/j/fffR1NTEwBAEATceeedePXVV5GUxLZBfZVOp4NOp4PFYoHdbgcAv4RF8/lHifFx0KiU0KgS2n3f7iS2AiX0vLMI2uoHrNcbUK7V+u1rLwnYWvJQqy0PaSKQeoa3mm7718excv12z8ZV6/yOCTQDbNGiRV06H8vXqTs4R476G1EUkZwQj1iZgDSNCsrrMhAT45kVlZGRhhhLNY5ECnAlDfJcgL18DqZ97yB22GSJI6e+Sur10oMPPohjx45hy5YtqKioQHr61aoik8mEt97yVBTNmzevzflrgnD1d+/S0lIMGTKkR87Z3Xjz8/Px7rvvIjk5GTt27MCIESNajZP6H4e5tt05cs0r3wTFAADAyFHDMTFrPAylJb4bP8zuaN9NHwMHqmDUnsW5E0cxcWoO1Dd0v/qUiIiIiMKfZIk5AK0uyhITE/G///u/ePXVV3HmzBk4HA4MGzaMCbl+YPXq1Vi+fHnAfYHmHy1bmNehC8cdqXArK9MiQVT47Tt1uhTFxQdbJPTqbK5Wz+Vu9FRJbdy4AZ9+FCAJWAOcPj26RfKttXM1P1+wE4EUWt5Eh85Qh2mZwwK2EyxYeA/iFXIcvtiA8VNmQhRFVFV5LgAEqqaLiIjA5s2bWRXXh3Sk0lGv16O4uLjDNzHo6+pDFj8REQWPlOulJ598En/729+g1+tx77334t1338WwYcNQWVmJn/zkJ6iurkZMTAyeffbZsDhnd167ePFivP7661Aqldi+fXtQKgCpbzEf3grTvnd8z1ubI+etfMucMA4AoFDEQq1Ohdt40XfjhzXK08oyIyMNanUq5FY9LskEpCQnsI0lERERdfgar85QB53B5NeVq7y8HMDVa4gAfNcRNRoNrx2GEUkTc+0RRRFZWVlSh0EhlJ+fj5ycHOza8jZuSldAjItpdf7RoIGqTrdYC5TYEqouA2g9keZyu1ok9GwXTgKGQwHP4f4u4aYYMbVFEtBedhYuw36sX78+YPIt0LnaPV97iUC2uQw7GlUCxg5NC9hOsNJQh8IPizwHbvzU73WtVdMVFhayKq4P8VY6Zmdnt1pBvHLlSmzfvj3g6wPdxLBk/m29cvZhWxXLRETUs+slpVKJDRs24I477sDBgwcxfPhwKJVKXLlyBW63GzKZDGvXrsX1118fFufs6mu1Wi1eeuklAEBjYyPuuOOONmO8fPly0D4v9R7ihDmIHTY54By5QJVvEfEqHDl8TOqwiYiIqBfp7DXe1Zt2Y/lrW64e1KwrV6BriMuWLUNBQUGww6YuCuvEHPU/Go0GMpkM5w/uwrQJA6FKiG91/tGQDradBNq+kNtWIs2bELs2oRcR0/6djAGTgNHaTp+rvfO1FT/bXPY+82bdiNnZYwNW061c/BCGDlLhQIUFN+c9jMTEROj1ehQWFkodNvWATZs2tfp3GygpN3vKWGz7+kSrNzF42/5em5jztlgNt6Rday2I26pYJiKi4JoxYwaOHDmC5557Dp9//jmqq6uRmpqKGTNm4Omnn+6RpGB3ztmV17pcV3+uWK1WWK3h87OQwkeUmIQoMSngHLlAlW+RCSpMmz4FohgnceRERETUW3T2Gm/+vJnImzERZTq97zri5Vqz7xri+OHXwdxg811HHDNmTEg/D7VN8sTcgQMHUFxcjIsXL8JoNKKxsREOh6PN1wiCgH/+858hipDCTWvJt460gmxLZxNi3dET52qrzSX1HikJ8RiiSQ5YTZebNRIZ6iRUuaqRmZkJlUqF4uJiAO23Nry2BSbL16XVkXaV8+bNwwMPPNDhCmJ9XT22fX2iQzcxNNd8llw4JeZaa0HcVgUxUbCJYhymTZ8CQRCgr70Cm8ONxqrzAIAmfRkAz2whh6XOs62mAgAQ+d0F3J5WUlIScLtKpUJGRkbAfdT7SL1euuGGG/DGG290+fVutzuk5+zsa4cMGdKlGKl30Gq1AW/SbO37Z7CIooicGdk9eg4iIiLqmzozyihZIaAuRsCAmGhkjxuK2nrPNcHcrJHIGjUYhrp633XEpqYmFBQUcBxOmJAsMXf69GnMmzcPp06darGvtYWRIAhwu91MzPVBzS9Sy2SyVo9rrYIC6HoryP6A8+f6vraqq1i+3nM6kmBr7XXLly9vswVpSkoKMjIyOlxBXHyqPCifKdx0pWKZKFi8F1b37vk/7Ptyv2fj7jV+xzSfLVTzyQoAgHLaj5AwfX6PxeU0GwFBwIIFCwLuj4lV4PSpEibnejmul4i6R6vVYuSo0bBZw6t7iPemD1bTERERUUd1uM1lRGyr79GRa1EUOpIl5hYtWuS7S2348OG44YYboFQqIZPJEBkZKVVYJJHm3xjauojUWgUF0PVWkH0Z58/1Hh1pJ6ivq/cb6KpUKn1VcYMGDcILL7yAY9/sRmZaHBSxclTVXkFB4UctWmA6HA5s374dOp2OP4i7qbu/1HgrHQH4qh2bVzoOHjwY58sqcCTejsT4OOjr6oMaPxF1zMSscUiU2VFy+BDGTsqGImUQqqsNvtlCcc56HDhQDHv2E5APGoHIHq6Wc9nNgNuN5LuWQpac7revqaYCNZ+sgMFgYGKul+N6iah7DAYDbFZLwO+V1gvfwrT3LUniYjUdERERdVZH21zGxLeemKPwIlli7sCBAxAEAf/93/+Np59+WqowqBdonrCoM3rakDD51jGcP9d7dKSd4KadB1H4YZHnSbOBrgACVr8tuncGgJYtMLVaLVauXIn58+czMSexjlY6/uW7/3r/TokotERRRHJCPGJlAtI0Kiivy0BMjByAZ7ZQjKUaRyIFuJIGIVJMgvnwVogT5vR4O0tZcjrk6mE9eg6SDtdLRMER6Hult/Vwd7DyjYiIiEKNo4z6DskSc6mpqdBqtZg2bZpUIVAv0TxhUXJW2lh6q870JgbY5jLceJPTc2dmYXb2WN9A14HJCe3OHCv8cI/U4fdbHZ0jl5+fD6PR6Jsld6HS0KW/045UXRJRz3Oaa2Ha9w5ih00OyZw56ru4XiIKb6x8IyIionDT/NoQhTfJEnPPPvss8vPz8d///d94+eWXcf3110sVClG/1G6byxrg9OnREJz+CTom7UKveXI6Vi5DSoKI7HFDMSRN3S9njvUW3jaX2dnZ0Ol0AFq2qzx58iTGjx8Pk8mEpiYHxLgYjBk6CEDgv1Odoa7V5FtHqi6JiKj34HqJiIiIiIg6w3ttSGeoQ/Gpcr+ROOXlnuuERUVFMBqNAAC5XA6FQgGNRsOuWiEmWWJu4cKFqKmpwbPPPothw4YhOjoaiYmJiI6ORkRERJuvFQQB58+fD1GkFGw6nQ46nc53gRpAmzOVNColNKoECSPum9pqc2kvOwuXYT/Wr1+PmCjOputPOlLl1V95v3cBgefBXftLjV6vB9DxdpWAp2VlW+0qmXwjIuo/uF4iIiIiIqKuWL1pN5a/tuXqhmYjca69FgUAy5YtCzgmh3qOZIm5TZs24fe//z0EQYDb7Ybdbsfly5c79FpBENo/iMLW6tWrsXz58oD7As1U+uUDuVj84M0APAO8KbgCtbkUoj2tLTmbrnfTqJRYMv826OvqO3yHjF6vx/Lly5GXl9ciMddfk3bez11fX4+VK1cGPCbQLzWLFi0C0H67yvHDr8OlaqOvZaUsWs4WpES9QPPZQg7+SKQewPUSERERERF1Rf68mcibMRFlOr1vJM7lWrPftShzgw0HKiy4Oe9hjBkzRuqQ+x3JEnPPPPMMHA4HYmNj8cMf/hAjR4703QEaGRkpVVgUAvn5+cjJyfFdoBbjYvzmZMkjgRfXfIARiYA8SoChZB+ee+4rAJ5qLQodDhTt3TSqBMQrYnD7L5olk9q5Q8abTArE25oxUNKuL/N+7s8++wzz589vM8HW/Jcah8OBwsJCpKSkICsrCwaDAecP7sK0CQORrk4G4GlXmTVqME6X63wtK2vr7RJ/YiLqCFEUMTFrHMzmBtTXXoHN4UZj1XkIEZ7fY+0Vx+GymdFo8NwM0VRTgUgxiXPnqMO4XiLqGK1WG/AGzpKSEgmiISIiIpKeRpUAjSoBcbHRvpE43utN3mtRhrp6VLmqkZmZCZVKJXHE/Y9kibmLFy9CEASsWrUKjzzyiFRhkAQ0Gg1kMpnvArUqId5vTlad0YCYSBfSJ+S0qNayXTgJGA5JETZRWGo+1DVQa8PO3iHjTSZ1Vn+opmsrwTZm6CDf9zF74xWYTKYWlYkmk8nXptfhbP0mg/b+TokofBwqPoZ9X359dcPuNb6Hxp2v+x1b88kKKKf9CAnT54cqPOrluF4iap9Wq8XIUaNhs/ZM6bLDXAvz4a0QJ8zhjRVEREREFDSSJeYmT56MoqIipKenSxUChbmA1VoxokTREIWn9maOdfYOGa1W26U4eks1XWsJxO4mFjftPIjCD4uubmijMpFz5Ij6jolZ4zB8xFAYSktQcvgQxk7KhtkdjZ07ijDr1lwMHKhCg64UBw4Uw579BBQjpkgdMvUiXC8Rtc9gMMBmtSD5rqWQJfv/W7Fe+BamvW916/2d5lqY9r2D2GGTmZgjIiKiPqs/3HAfbiRLzL3++uuYM2cOfv3rX+OFF17AqFGjkJSUhOjoaKlCIiLqV/R19Sg+Vd6p+XO9XWsJxO4mFufNuhH582a2WZnIOXKB2W2NqKyshOBs9NvOmaLUG4iiCFEU4TZeRKxMQJpGBWtUPAAgIyMNanUq6lwmHIkU4EoaBACo+3I9Ky+oQ7heIuo4WXI65OphftuaaiokioaIiIiod+ktN9z3JZIl5oYPH+57fMstt3TqtYIgwOFwBDskIuoEvd6A8mbVVZcq9bDbGtt4BYWbzlR5AcDs2bMBdD5p19W7bqS4W0ev16O4uBgAYLFYYLfbcfToUQBtt6RMSYhH1qjBbVYmNp8jJ5fH+NpV9mfGOhOKDxVj1aVixEQJfvs4U5T6IlZeUGdwvURERERERB117bVawP96bfPRKSQ9yRJzbrdbqlNTGGr+jaHOyCqJcOZu9LTW27hxAz796OqF9DqbC6drBZhMM4E0tTTBUae0VeV125Sx2P71Cb/jt23bBiBw0m7RokWtnqerd91IcbfOpk2bWp2xF6gl5ZL5t3Xpl5rm7Sr7M4ulAS6XE4oRnClKFGwlJSUttqlUKmRkZAQ4msIR10tERERERNSe1q7VAv7XazPHjOK1qDAiWWJu165dUp2awlDzi9QlZ6WNhdrm/q7dnGLEVL8L6Y2VWrj27UVDQ88MXqfg8SbCxw+7rtX5c0vmz8bzP78/YNKuYOE9SE0eAIvVjsMXGzB+ykw0NDQACF0LzJ6qpps3bx7y8/NhNBqxa8vbuCldgQuVhlZbUt445gZoVAlBO39/xZmiRMHjNBsBQcCCBQta7IuJVeD0qRIm53oJrpeIQsthroXTXAuHqQoAYK88A3y39rFXHIfLZkZTzUU0Ot3QG4yIEBMhivx9hYiIiKTV2rVagNdrw5lkibnc3FypTk1EQXDthfQIo0nCaKgzOlKt1VZrxkpDHQpe++jqwRs/9T3sSjVdV9tctlZN533PuXPnwuVy+VpSAvC1pVy/fj32798Pp9OJyMhInD3ruSPg5MmTGD9+PEwmE5qaHBDjYjBmqGcuVKCWlEzKEdG1RDEO06ZPgSjGSXJ+l90MuN1IvmspZMnpvu1NNRWo+WQFDAYDE3O9BNdLRKFlPrwVpn3v+J4bP3/l6uOdr189DsAHW77AtOkNyJmRHcoQiYiIiFoV8KbnANdrdYY66AwmGOsbcLa0Gnv27EF5eTmAwDfcazQazp3rAZIl5qxWq6+KQqVSQaFQSBUKEQVRe/2MqfdrqwWmt6rM3GDDgQoLbs57GA6Ho9X2kD3RrtL7njqdrtXzrly5MuD2QO0qF907o0txsHc3Uf8kiiJyZmTDbDbj8uUq1Ndegc3hRmPVeQgRkQCuVl40GjyLn6aaCkCIgPXs/0GcMCco8+dkyemQq4d1+31IOlwvEYWWOGEOYodNRsPpLxF3fAMm5+SivgnYuaMIs27NxcCBKhi1Z3HuxFFMnJoD9Q2jpA6ZiIiIqNNWb9qN5a9tubph1Trfw0A33C9btgwFBQUhiKx/kSwxV1BQgL/+9a9ISUnByZMnudAk6uU62s+Y8+d6v7aq6cYMHYTEeE+ViL3xCkwmU4u7brx33ADwXXDU6/UoLi4OWN3W1uvaMm/ePDzwwAO+lpRiXAyOnr2IJS++iyUP3walGIvdxSW49aYxqLliwcr12wO2q5RFy1H44Z5O/zlxjtxVdlsjKisrITj9E/QGA2eKUt91qPgY9n359dUNu9f4HjavvACAmk9WQMycDfORbYgdNjkoiTnq/bheIgqtKDEJUWIS7LrTiI4UkKZJgQXRAICMjDSo1amQW/W4JBOQkpzANpZERETUK+XPm4m8GRM7fMP9mDFjpA65T5IsMbdt2zYAwM9//nMkJfHiA1Fvx37GfUN3q7w27TyIwg+Lrm5o564bb5vLTZs2tVrd1tn2mF4pKSnIyMjA+YO7MG3CQKgS4n1Jw/lzshEXG41KfQ0env191NbbsXL99oDtKr1JR+oaY50JxYeKsepSMWKiWibtifqqiVnjMHzEUBhKS1By+BDGTsqG2R3tV3nRoCvFgQPFsGc/gahENcxHtkkdNoURrpeIQsdhroX58FaIE+ZIHQoRERFR0F3b4SxZIaAuRsCAmGi/G+6918UMdfWoclUjMzMTKpVKqrD7NMkSc9rv/keYOXOmVCFQiDWfJSWTyaQOh3pIR/sZU3hqq8qrI0m79tpcDh2k8t1xk5iYCL1ej8LCwjar2woW3oN4hRyHLzZg/JSZEEURVVVVALpeTde5PxO2pOwOi6UBLpcTihE5LZL2tgsnAcMhiSIj6lmiKEIURbiNFxErE5CmUcEaFQ/gauVFncuEI5ECXEmDEBHDygvyx/USUeg4zbUw7XsHscMmSx0KERERUdB0uMNZRGzog+vnJEvMORwOAEB8fLxUIVCINZ8llZGR0f4LiCisdKQ1Y3ttLqMiI3wtLgHg5MmTvv8OHjwYTU0OiHExSIyPw5ihgwAAlYa6q1V4Gz/1O1+garrZs2cD8CTtBg8ejPNlFTgSb0difBz0dfU98rmpfQGT9kxEEBG1iuslIiIiIiLqjo52OIuJZ2Iu1CRLzA0dOhTHjh1DRUUFJkyYIFUYJCHTlSuouNiIhitxfts5c4io9+lIVZlfm8tmLS4B/wTbX77776J7ZwDwVOHNzh7rq8AbmJzgq6a7bcpYbP/6hN97eVt/tfWeRERSslisuHy5CvW1V2BzuNFYdR5CRCQAwF5xHC6bGY0Gz3zOppoKQIiA9ez/QZwwh/Pn+hGul4ikJ4pxmDZ9CkQxrv2DiYiIiMIUO5yFH8kScw899BCOHj2KDRs24O6775YqDJLIxYsXsWrVahxLc3HmUD9ybT9jALhUqYfd1ihRRBQsHakqayvBtnLxQ0hWxuGjooN4/K5pGDRQBX1dPQo/3IOUhHgM0ST7KvCGpKl9s+KWzJ+N/Hm5HX7PiAgBGlUCNColrjRYm8XPdpVEFDqnT53FkcPHr27Yvcb30Ljzdb9jaz5ZATFzNsxHtiF22GQm5voRrpeIrtJqtQFv4CwpKenR84qiiJwZ2T16DiIiIiKptXVdrPl4Ko1GI0F0fZNkibknn3wSb7/9NtavX4+8vDzcd999UoVCEqipqYHD0YS4MbdATFb77ePMob6nw/2M09QtX0x9RlsJttyskYiLjcZXR07jezekYUiaGsWnyoP+ngAwYYSndN8/Mcd2lUTU87yVFyNG3oCJWeNhKC1ByeFDGDspG2Z3NHbuKMKsW3MxcKAKDbpSHDhQDHv2E4hKVMN8ZJvU4VOIcb1E5KHVajFy1GjYrJZuvY/DXAvz4a2IHZ4Nh8kzr9heeQYumxlN+jLP84rjaDJVodHpht5ghAXREMU4iCLbbxMREVHf1dZ1sebjqZiYCx7JEnOiKGL79u3Iz8/Hgw8+iEcffRQLFy7EpEmTEBUlWVgUJDqdDjqdDhaLBXa7Z77U0aNHAXjmPjmdTjQ63aixuGFTuPwWO5w51Pd0pJ9xWZkWCaLCbx+r6fqG5nfdNE+G9dTrSBp2WyMqKyshOP3/zbI9MdFV11ZeuI0XESsTkKZRwRrlmSOWkZEGtToVdS4TjkQKcCUN4u9G/RTXS0QeBoMBNqsFyXcthSw53W+f9cK3MO19q0Pv4zTXwrTvHTjMtWj47mYH4+ev+B3jrVo2A/hgyxcAgGnTp7BqjoiIiIiCStIZc14RERFYu3Yt1q5dC5lMhqSkJMTExLT6WkEQcP78+VCESV20evVqLF++POC+5nOfuNjpXwL1MxaqLgNgNV1f1vyum84l5rr2Ogo9Y50JxYeKsepSMdsTExEFCddLRP5kyemQq4f5bWuqqej0+yhGTEVEbDzijm/A5JxcxCaqUF1t8FUty2xGnDtxFBOn5kBMTed8OSIiIiIKOskSc2VlZQG3NzY24vLly22+VhCENveT9PLz85GTk4NdW97GTekKiHExfnOf3A4bXnlrMxc71KFquoaG7rWtob6H1XThxWJpgMvlhGJETot/x2xPTNQ5FosVly9Xob72CmwONxqrzkOIiATgabHmspnRaPC0+m2qqUCkmMS5c30U10tEPSNSoUTUgBRERwpI06RggDodMTFyAJ6qZbfRjUsyASnJCVCqUyWOloiIiIj6IskSc48++qhUp6Ye1HwYZGZmJs4f3IVpEwZClRDvN/epzmhALBc71EygaroIo0miaChUut7msvVqOibtpBPw3zFb8BF1yulTZ3Hk8PGrG3av8T30tljzqvlkBZTTfoSE6fNDFR6FENdLREREREQUSjpDHXQGE4z1DThbWo09e/agvNxzY2hRURGMRiMAQC6XQ6FQQKPRcO5cF0mWmFuzZk37B1Gv03wYZEZGRvsvIOoAvd6Acq3Wbxvnz/UNPdGuki0wiag3EsU4TJs+BSNG3oCJWeNhKC1ByeFDGDspG2Z3tK/F2sCBKjToSnHgQDHs2U9AMWKK1KFTD+F6iajrHOZaOExVAAB75Rm4bGY06cs8zyuOo8lUhUanG3qDERZEw2Lh74xEREREqzftxvLXtlzdsGqd72Hz8VRey5YtQ0FBQQgi63s4NZx6lOnKFVRcbETDlTjoLusAALrLOjTUsxKK2udu9CyQOX+OiIj6OlEU/ebtuo0XESsTkKZRwRoVD8DTYk2tTkWdy4QjkQJcSYMAAHVfroc4YQ5bWhIRfcd8eCtM+94BABg/f8Vvn7f62IyrM88zJ4wLaXxERERE4Sh/3kzkzZiIMp0e67d+hftnTcLlWrNvPNX44dfB3GDDgQoLbs57GGPGjJE65F6LiTnqMRcvXsSqVatxLM2FmCgBBosbAPDPf76BqAi3xNFRb9CR+XNlZVokiAq/faymIyKi/sJproVp3zuIHTa5Q4m5kpKSgNtVKhW7HRBRnyFOmAOXswlxxzdgck4uYhNVqK42+KqPZTYjzp046pt5LggCRDEOohiHeqPU0RMRERGFzrWdypIVAupiBAyIiUb2uKGorbcD8Iynyho1GIa6elS5qpGZmYmmpiYUFBQgPz+fLS07iYk56jE1NTVwOJoQN+YWiMlqRDZYkB1/Fqljh6OhqgwwHJI6ROolAs2tEqouA2A1HRERUUc4zUZAELBgwYKA+2NiFTh9qoTJOSLq1RzmWpgPb/VUEQ9IQXSkgDRNCgao0xETIwfgqT52G924dM3M89TUgQCAesmiJyIiIgqdDncqi4ht9T2aj7ViYq5zmJijLtPpdNDpdLBYLLDbPZnzo0ePAvAMg3Q6nWh0ulFjccOmcEEckIzcHwwGAFhNBsnipr6hI9V0DQ0WKUIjIiIKOy67GXC7kXzXUsiS0/32NdVUoOaTFTAYDEzMEZGktFotDAb/tWJrlb6BNK8iJiIiIqLWdfTaakx864k56jom5qjLVq9ejeXLlwfc13wYpLdv/7TpU/xmpxAFQ6BqugijZ4bhtaXYANtcEhFR7yOKcZg2fQpEMa5Tr2teOeIlS06HXD0s2CESEXWbVqvFyFGjYbPy5joiIiKiUGnr2ir1nLBJzJ0+fRpfffUVzpw5A5PJ8xevVCoxfPhwTJ06FaNGjZI4QrpWfn4+cnJysGvL27gpXQExLgZHz170DYN0O2x45a3Nvr79nb2YRNRVHS7FZptLok6x2xpRWVkJwemf3L72znYiCi5RFJEzIxtmsxmXL1ehvvYKbA43GqvOQ4iIBADYK47DZTOj0VAOwFMF57ReYeVIH8L1EvV1BoMBNqulRWWv9cK3MO19S8LIiIiIiPovjUqJZQvzoFEppQ6lT5E8MffVV19hyZIlOHDgQJvHTZo0CStWrMD06dNDFBm1R6PRQCaT4fzBXZg2YSBUCfFIjPck33KzRqLOaEDsNX37iUKBbS6Jgs9YZ0LxoWKsulSMmKiWCW8i6nmHio9h35dfX92we43voXHn637H1nyyAmLm7FCFRj2I6yXqb66t7G2qqfDbH6gauCOaVx/XG4MSKhEREVGfp1EloGDRXOgMdSg+VQ5jfQPOllZjz549KC/33BhaVFQEo9EIuVwOhULheZ1Gw7lzbZA0Mbd27Vr89Kc/hdvthtvtbvPYAwcOYObMmSgsLMRPfvKTEEVIRL0ZS7GJgsdiaYDL5YRiRE6LhLftwknAcEiiyIj6j4lZ4zB8xFAYSktQcvgQxk7KhtkdjZ07ijDr1lwMHKhCg64UBw4Uw579BKIS1TAf2SZ12NQNXC8RteSdIxc9aBQcpioAgL3yDFw2M5r0ZZ7nFcfRZKpCo9MNvcEIC6IhinG+0Qr1UgVPRERE1Eut3rQby1/bcnXDqnW+h83HWnktW7YMBQUFIYisd5IsMXfq1CksWrQILpcLMTEx+MlPfoK5c+dizJgxSExMBADU1tbixIkT+PDDD7F27VrY7Xb87Gc/Q3Z2NkaPHi1V6HQN05UrqLjYiIYrcdBd1gEAdJd1aKhnAoTCF+fPEXVNwIR3jChRNET9iyiKEEURbuNFxMoEpGlUsEbFAwAyMtKgVqeizmXCkUgBrqRB/LfZy3G9RNQ2y5mv0PDdzQfGz1/x2+etIjaDM8+JiIiIgiF/3kzkzZiIMp0e67d+hftnTcLlWrNvrNXQQSocqLDg5ryHkZiYyGq5dkiWmHvxxRfhcDiQnJyM3bt3Y+zYsS2OSUtLQ1paGm677TY88cQTuPnmm2E0GvHSSy9h9erVEkRNAKDT6bB69Wrk5+ejqqoKq1atxrE0F2KiBBgsnjt5//nPNxAV0fZdvURS4Pw5IiLqiywWa5vz5xyWOgBXW8JFikmIEpOkCpc6gOslorYpRkxFRGw84o5vwOScXMQmqlBdbfBVEctsRpw7cZQzz4mIiIi66NrChmSFgLoYAQNiopE9bihq6+0APGOtMtRJqHJVIzMzEyqVSqqQew3JEnNffPEFBEHA7373u4CLzGuNGzcOv/3tb7F06VJ88cUXIYiQWqPT6bB8+XLk5eXBaDTC4WhC3JhbICarEdlgQXb8WaSOHY6GqjK2NqOww/lzRETUF50+dRZHDh+/uqGV+XM1n6wAAMTfNBcR0bGdntFEocP1EtH/Z+/Ow6Mq8v2Pfzp7QkISCPuqrCKiAu4sCnijjLiPiMoFN1yuzvx01CuODi7M4HLF64wjLowwiCJcGRUdFY2DuA2CIAoqhFUQQQLZyE6S+v3RdJOlu9Nb+vTyfj1PPzR96pxT3adSXdXfU1WexadlKqFtByXF29StSwe17dxDKSnJkuyjiE2R0R7WPAcAAPCZ1wMb4lJDn7koYVlg7ueff5YknXXWWV7vM3LkyEb7InzEpWUpIbODsjKl0V17SZIqSw5YnCvAPdafA1yrrqrRzz//LFtd42ldDxygTgfC2YCB/XTy0CFu159rU3fIufZcctf+qqssVcGSPyi172lWZx1u0F8CpNqyQp/WkauoqLQwtwAAANHB24ENKRnuA3MNZ91jWsvmLAvMJSYmqrq6WlVVVV7v40ibmJjYWtkCACBmFRWXaN3X6/TcnnVKSWh+RxSA8JOe3kZnjThdHTvmeFx/LqViv3PtueTOfVW9b6vFOUdL6C8BUtn691Ty+SJJ3q0jd+JJJ4Q0fwAAANEskIENDWfdIzDXnGWBuWOPPVbffvut3nrrLY0YMcKrfd544w1J0jHHHNOaWQMQ45rOnyxJe34uUHVVjZs9gOhQUVGu+vo6pfUf2eyOqKrt3zM9MRCG0tPTNXLUGUE51g8//ODy9ZycHPXs2dPlNrQe+kuIVrt27XI5Et9VHZR+0vmqrzvs9TpyFRWV+mb9hlC8DQAAgJjXJSdTM268UF1yMq3OSsSxLDB3wQUX6JtvvtGf//xnDRkyRJMnT/aYfv78+frLX/4im82mCRMmhCiX2Lt3r/bu3asdO3aooKBAkrRlyxZJ0iuvvKK6urpGU4ekp7dRenq6lVkG/Ob1/MndOoc+c0AIubwjKoW6HYhWdWVFks2ma665xuX2lNQ0bd70A8G5EKO/hGi0a9cuDRh4nKoqvVvTOSG9nU/ryJWVlemsEacrPb2NDhW15jsBAABAl5wsPTjtYknSgeJD1mYmwlgWmLvzzjv1/PPP6+DBg5o6dapmz56tCRMmaNCgQcrOzpYkFRUV6bvvvtOyZcu0ceNGGWOUk5OjO++806psx5znn39eDz30kMtts2fPdj53TB1y1ojTg3bXNhBq3s6fDABAJKmoqNShwlJV1RrV/LJNkhqt0VRbUSwZo8yR1yghs5PqqspUnPe82l/wO0nSwXee1IEDBwjMhRj9JUSjAwcOqKqyQu0v+J0S2/dotK1y+1cq+XShJPvacmXr31P6Sef7dPyGo4j5aQgAAADhyrLAXHZ2tt5//32df/75Kigo0Lfffqtvv/3WbXpjjDp06KB//vOfzo4oWt9NN92kzp0766G7b9EppwxVSka2Cg4W6+PP1+rss4Yp8XCptm/Z4pw6JD29jdVZBgLmaf5kprlENKiuqtHPP/8sW13jcutqWikAkcux/tyO7T9qzep19hc/ntcojWONJknOH8TTT8yVpGY/miO06C8hmiW276Hkzn0bvXb44G7n87qyQpV8vkipfU8LddYAAADgo70HivX9jp+1Zcd+ffLJJ8rMzHT2XVauXKmioiIlJycrLS1NkhQXF6c333xTN910U8yuP2dZYE6Shg4dqk2bNulPf/qTFi5cqF9++cVluo4dO+qaa67R9OnT1b59+xDnMrZ16dJF/fr1U1K8TT2OOVZtO/dQm32/SJ+vVe8BA2SKftLenVudU4cA0arFaS4PSps3H9co0EHADuGoqLhE675ep+f2rFNKQvOyDCB6OEaOlJWVqVMbox/Wf63jh5+htA5dG63R1KbukNasWafqM25Vctf+qqssVdk3y63OPkR/CQAAAED4e/4fH+uhF5fZ//PcgkbbXM3mMW3aNL3wwgu68MILCcxZJTs7W0888YSeeOIJbdu2Tfn5+SopsY9MyczMVL9+/dS3b98WjgIArcvTNJfVO7eo/sBqvfLKK40CHaxLh3BUUVGu+vo6pfUf2awsV23/XjrwtUU5A9Ba0tPT1T4rQ6mJNnXrkqPM7j0brdGUUrFf38TbVN+uq5I791X1vq1uj7V37149//zzMX1nY6jRXwIac4wGZh05AACA8HDTpWdrSL/ueuW9L3T5mOHq2D5L3275SXc+9Zpm33Glju2aozW7K3TOhVcpOztbBQUFeuGFF6zOtqUsD8w11KdPH/Xp08fqbACAW66mubQl2ae2bBq0Y106hDOXU7ampFuUGwBWaWn9OcUnSZJ++OEHSVJBQYEeeuihmL6z0Ur0lwDWkQMAAAgHTZf7yUqxqW1Kks444Vj17tZZ2Rn2Ja9GDx2gnp3b6Zf6/TrxxBOVk5OjdevWWZXtsBFWgTlYb9euXTpw4IAKCgr0j3/8Q5deeql27NhhdbaAiNA00OFYlw6wAuvIAfDG5k1b9M36jfb/eFh/7pprrpFkn3IEAIKhtqxQZevfU2q/MyRTr9oS+1St1T/nS0faL9W7N+pwyS+qqTMqOFCkCiUpPb2N0tO5mQgAAMAK7pb7CdbMYbEySwuBOTjt2rVLAwYep6rKo6N7HENKe2Ye/SNj6hAACG+sIwfAWwMG9lOP7ES3689lJEpffrpS194+Xccff7yKiuyNP8cIupycHPXs2dPTKQDApbqyQpV8vki1ZYUqb7CuZdGHzx59fuQGgTJJ/7fsI0nSWSNOd46YAwAAQGi5W+7H3cxhBcWHVHSoXFt27Ncnn3yizMxMffvtt5KklStXqqioSMnJyUpLS7Onj5FZWkISmBs1alRQj2ez2bRy5cqgHhP2URRVlRVqf8HvJEkH33lS7S/4nWoO/Cj9sNSZjqlDACC8sY4cgJY4brTq2DFHh6oPul1/LrWmWEnxNs2aNavR/o4RdCmpadq86QeCcwGiv4RYltb/TGWcdL7KN3+mNhtf12kjR+vQYTlvEEisKtLW777VyWeOVHqnHkpPb2N1lgEAAGKetzOH/eNfa/XCG0f6Js8taLTtzjvvbJY+VmZpCUlg7rPPPpPNZms5oQvGGEly7m+M8ftY8E5i+x6NntfXsD4W0BrcTTW45+cCVVfVuNkL8B7ryAFwx5sbrezrzx1QVa1R+rAJSmzXQ7VFP+vQV28qY/jFUkKCDq16XZ9++qmOO+44denSJarvaGxN9JcQbVwtkdChQwfnaNuG4tMyldy5r6r3blZSvE3dunRQhezrW/bs2U2myGhPok0d2mcps3OnUL8VAAAA+KFLTqZm3HihLj57qHLPOF6vvPeFLh8zXB3bZ+nbLT/pzqde0+w7rtSxXXO0ZneFzrnwKmVnZ6ugoMA5i180C0lgrmfPngF3Dvfs2aO6urog5QgAQqfpYqiStGnzDq1bt9btVIPBmJMZ0Y915AC0pkbrz619u9G2Q1+96XzuGD135513KiMjI+rXAmgN9JcQTTwtkQAAAIDY0CUnSw9Ou1iSlJqcqA5Z6TrjhGPVu1tnZWfYZ0AYPXSAenZup1/q9+vEE09UTk6O1q1bZ2GuQyckgbmdO3f6tV9JSYkWLlyouXPnateuXc67Qbt37x7E3GHv3r3au3ev8+5FFtsGgsPdYqiSPfhWb+pdTjXobk5moCHWkQPQ2rxdf27GE3N06qmnqqCgQOedd17UrwXQGugvIZq4WiIhe9xNiktJV/We71X29XvN+pz1VWU6fPAnZ7/TltbWyrcAAAAAP7kaoOBudjBf15+LpllaQhKY89Wnn36quXPn6vXXX1dVVZWMMUpISNAFF1ygG264Qeedd57VWYwqzz//vB566CHn/1lsGwgOd4uhSkfX+XI51aCbOZkRm9yNitu160fWkQPQKrxdfy5NNUqKP3pjgGO0ruNmr5ycHPXs2VN79+7V888/z0i6IKK/hHDgmK6yKUcd0HCJhJqCnSr/Zrnz/676nNLRfueJJ53QCjkGAABAa2lpgIKr2cF8XX9uxowZevDBB4OZbcuETWCuoKBAf//73zV37lxt2bLFebdn3759df3112vq1Knq1In55IPJ8SPJxRdfrAsvvFCrV6/WQ3ffwmLbQJCxzhf85c2oOMoXgGDzZv05STJH1iG+5ZZbGr3umNoyJTVNmzf9oAMHDuihhx5iJF2A6C8hnLiartKTtP5nKuOk81W++TO12fh6sz5nx445Ktq1xdnvzOjc88hMLW10qKiV3wwAAAAC5mmAgrvZwS4dM8yn9eeiqT9peWBu+fLlmjt3rt5++20dPnxYxhglJyfr0ksv1Y033qizzz7b6ixGrb179zp/JBk6dKiKiopYbBsII+6Gfh8qPeRyBJW7YeGIXBUV5YyKAxC2TK39Oyf7P25RcpcBOnxwtw6+82Sj6etY8zJw9JcQjhpOV+kYGVdXUaL6ylKX01XWHtwtW1y8zOFqSVJSYoJyMu3TVfbs2U2dO3dScmXB0X5np47q1KmjJM83CAAAACC8eDM7WJecTM248UIN6dtdpeWVXq8/F00sCcz99NNPeumllzRv3rxGayEMHjxYN9xwgyZPnqzs7GwrsgYAlmtp6PcPB4yeK/jO5QgqV8PCEfkYFQcg3FRUVOpQYamqao1MTZXqq8pUX2HvbNVXlEjx9pu8HFPawTf0lxApEtv3UHx6O5Wtf0/1NZU6tOZN5zamqwQAAEBDDQchXHveUNVUlMbsQIOQBebq6ur09ttv68UXX9QHH3yg+vp6GWOUnp6uiRMn6oYbbtBpp50WquzENMdaAI4fShz/btmyxcpsATjCm7XpPA0L37lzl7LS0xpti9UvOQBAcDnWn9ux/UetWb3O/uLH8xqlafgDvGNaS6lxkI7155qjv4Rw5ulvta6sUCWfL1KHXz+kNoPO9nq6yriMHH2zfoNF7wgAAACh4s/6c9EuJIG5e++9VwsWLNAvv/wiSTLG6NRTT9WNN96oK6+8Um3asGZZqLhaC6DhDyY9M22udgNgAU+jpFxts/2yTxJfcpGquqqm2RSlTAEHINw41p8rKytTpzZGP6z/WscPP0NpHbpq//4D+lfeSp1y6lClqEYbv92ooqqj+zZscyYmJeuNfyxVQkIC68+J/hLCX8NlENz9rcanZSq5c19V793scomEptNVViakhvItAAAAwCL+rD8X7UISmHv88cdls9lkjFFCQoLGjx+vIUOG6Mcff9Rjjz3m1zEffvjhIOcyuu3du1d79+7VDz/8oKrKCmWcfrlUW6tDX72pjOEXKyG7qyp/2qCa3Z+q4ECR0jt01lkjTmexbSCC8CUX/lwF3yRp0+YdWrdurZ7bs67RFKXFVfWhziIAeCU9PV3tszKUmmhTty45yuzeUykpyZJ0dCSdB4drqnXBBRdo2rRprZ3ViEB/CeHK3WwrwZim1jECNz2dwDMAAEAs8GX9uS45maHMWsiFdI05m83mnKLl7bffDuhYdDS945hy5NChQ5o9e7bz9UOrXj/6/Ks3nc/3yT7f/1kjTtfIUWfYt4cqswCCwtOXXMO5nB1amubSXTCJ6TFd8zX4JtkDcPWmXmn9RzYKqjqmLgWASDLhwvNkDv3iHE1XZpIaTWVXWXRAX366UjOemKNjjjlGL7zwgtVZDhv0lxAK7qalbPp6S7OtBMoxAhcAAABw6JKTpQenXSxJOlAcvZGJkAXmHAuWB4PNxnSL3nJMOfL+++/r6quv1urVq/XQ3be0ON9/5z4Drc46gCBqcS7ng9Lmzcf5HExieszGiopLtO7rdT4F36SjAbimQVXH1KUAEEna57STia9wjqarTMiQdHQqu9IUm5Li7XWkY8peV+vPxRr6SwgVd9NSNn39wIEDqqqsUPsLfidJOvjOk8oed5PiUtJVved7lX39nqp/zpeOtB+rd29UfVWZDh/8STV1RgUHimRLa2vJewQAAEBkcTWYoLC0XCWlVW72iGwhCczt2LEjFKfx2bZt2zRr1ix98MEH2r9/v9q1a6fRo0frnnvu0cknn2x19oKqQ4cOGjp0qIqKirya7z89nR+DgWjiaZrL6p1bVH9gtV555RWfgkmxPD2mu1Fxu3b9qPr6Op+CbxIBOACxoaKiUvv2/aKyvXtVVWt0yy23OLe5Wn9u6NChMbPuXLj2lyRr+kyBnNOqfaNJQUGB1q1b5wyY11dXOoNvlVtXq2rn0dH8RR8+e/T5v+Y6n5fJPhPLKacOZbpKAAAAuOVpMEFVrdHne+J07uXXKScnx4rstZqQBOZ69eoVitP45NNPP9X48eNVVlYmSWrbtq327t2r1157TUuXLtXChQt1xRVXWJxLAAguV0EhW5L9bhRXQTuPwaQApscMF56m6TxUesivKSklN9OJEnwDEOUarhflao3izZu26Jv1G1s8jmP9uRkzZujBBx8MfkbDUDj2lyRr+kyBnNOqfSNd03Xknn/+eb3xxhvO7Q2Dbw2Dcg69j+mlnTt+dDsTCzd9AgAAwB1PgwniD+5T7Y8f6eDBg1ZkrVWFdI25cFFSUqLLLrtMZWVlOvnkk7V48WL169dPe/bs0bXXXqsPP/xQU6ZM0SmnnKJjjjnG6uz6xd0i3Vu2bLEyWwDCmK/BJH+mx2yt9exaI8D2wwGj5wq+82tKSgCIRQ3Xi3K1EsCAgf108tAhOrDjB6/Wn7voootC+wbQiBV9pkDOadW+kc7VOnINg3Kd09XiMghxGTnaueNHZmIBAACA31z+LlkZndNYSjEamHvmmWdUUFCglJQUvfHGG847VLt166YlS5aoX79+OnDggGbNmhVRi9Hv3bvX+bjk0st0uKbaua3h9ECd08V8/wAC5s/0mAGtZ+fnfoEE2HweRcioOABoxjGSrmPHHKWnp8sU/dTi+nP9+vWLmWksw5UVfaZAzmnVvuHO0T+sqKhQdbW9f/jtt99Kkl555RUlJyerqrJCaSeMlWrrVPHDx8oYfrESsruq8qcN0u5PlZSYoJxMe9/RVfCtMiHVsvcHAAAARKKYDMwtXrxYkjRhwoRm08ZkZWVp8uTJeuqpp7R06VLNmTNH8fHxVmTTZ88//7weeuihFtPtK2O+fwDB48v0mP6uZ+fvfoEG2Ai+AUDgGo6kQ+Swos8UyDmt2jfceeojzp492/m8YsNHzueHvnrT+Xyf7H3HE086obWyCAAAAMScOKszEGrFxcXasGGDJOnss892mWbMmDGSpMLCQm3c2PI6GOHipptu0tq1azVnzhx1TpcuOn+0xowbLUkaM260rrzqMuWOGKI+2dLlvxqp004fppGjzmB6EQCtxhHYcjxsScmS7AG7zDMmNnqk9DrR5T6B7Nc0wOZqGwAAaMyKPlMg57Rq30hw00036dVXX1W3zASde0y8xveN1+nd7D8DnNDBpqGdbeqeIY067QSdcupQSa77jgMG9rXybQAAAABRJeZGzG3evNn5vH///i7TNHx906ZNOvHEE5ulqa6udk4FItnXJZCk0tLSYGXVZ23atFHfvn31008/KSFOSk+ole3IJW6bKKXH1ao6oV5J8VKSqVZV4X5VFe537l9aVKi6eqOSA7/ocH1ci6/H8rZwyUc4bQuXfITTtnDJRzhtc7x+qKJKdSWNVyAqq6xp8Xj+7hep28IlH+G0LVzyEU7bwiUf4bQtXPIRTtvCJR9Nt1UYe9u5eO8eJdSUq7LkgOqNUXl5uaXtase5jTGW5cFKweozheqcVu3bVLj2Edu0aSObqVX7PicoNT1L8cVl0p6v1fv4kxRfVaLKrdvVvX2qKkyq1sh137GipFDS0b/Vhn/HJrVaJ5/QX9UlB3SgybZorr+o08NrW7jkI5y2hUs+wmlbuOQjnLaFSz7CaVu45COctoVLPsJpW7jkI5y2tca5wqV/KLVCH9HEmDfffNNIMpLMhg0bjDHG3HjjjSY9Pd3ccsstxhhjSktLnWmefvppl8eZMWOGMw0PHjx48ODBgwcPHjyi77F79+6Q9VPCSbD6TKE6p1X7NkUfkQcPHjx48ODBgweP6H4Eq48YcyPmysvLnc9TU1N18OBBvfjii5KkOXPmaObMmWrbtq0zTVlZmcvjTJ8+XXfeeafz//X19SosLFT79u1lszVe/6i0tFQ9evTQ7t27Gx0b4Y9rF5m4bpGJ6xa5uHaRiesWubh2rc8Yo0OHDqlr165WZ8USweozheqcVu3blC99xFCizoCvKDPwFWUGvqLMwBeUF/iqNcpMsPuIMReYa6p9+/aaPHmyli5dqmuuuUbt2rVTbW1ti/slJycrOTm50WtZWVke92nbti2VR4Ti2kUmrltk4rpFLq5dZOK6RS6uXevKzMy0Ogthw98+k1XntGpff/qIoUSdAV9RZuArygx8RZmBLygv8FWwy0ww+4gxF5hr06aN83llZaUkacGCBVqwYEGz1yUpPT09dJkDAAAAAItZ0WcK5JxW7QsAAAAA/ohrOUl06dy5s/P5vn37XKbZu3ev83mnTp1aPU8AAAAAEC6s6DMFck6r9gUAAAAAf8RcYG7AgAHO5/n5+S7TNHx94MCBAZ8zOTlZM2bMaDatCcIf1y4ycd0iE9ctcnHtIhPXLXJx7dDarOgzBXJOq/aNFNQZ8BVlBr6izMBXlBn4gvICX0VCmbEZY4zVmQi1IUOGaMOGDbriiiu0ePHiZtt/97vfafbs2WrXrp3279+v+Ph4C3IJAAAAANawos8UyDmt2hcAAAAAfBVzI+YkaeLEiZKkZcuWaffu3Y22lZSUaOHChZKkSy+9lE4XAAAAgJgTrD6TzWZzPnbu3Nlq57RqXwAAAADwVUwG5m677TZ16NBBVVVVuuSSS7R161ZJ0s8//6yJEydq//79SklJ0X333WdxTgEAAAAg9KzoMwVyTqv2BQAAAABfxeRUlpL0ySefaPz48SovL5ckZWZmqrS0VMYYJSYm6uWXX3beOQkAAAAAsSYYfSabzeZ8vmPHDvXu3bvVzmnVvgAAAADgi5gcMSdJo0aN0jfffKNrr71W3bt3V2VlpTp16qQrrrhCq1atotMFAAAAIKZZ0WcK5JxW7QsAAAAAvojZEXMAAAAAAAAAAABAKMXsiDlvbdu2TTfccIN69uyplJQUde3aVZMmTdLXX38dVeeMRqH8HPft26enn35av/rVr9S9e3clJycrPT1dQ4YM0b333qt9+/YF/ZzRKhzK/3nnnSebzSabzab58+eH7LyRzoprZ4zRq6++qvHjx6tLly5KTk5Wt27dNHr0aM2cOVM1NTWtdu5oYcV1e+2115Sbm6sOHTooMTFR2dnZOuuss/TnP/+Za+aFdevW6dlnn9WUKVM0cOBAxcXFyWazaerUqa163nConyNZqK8bbRMgtvjSfg2kPue7IPK89dZbuv322zVq1Ch16dJFiYmJSk9P1+DBg/W73/1Ou3btcrvvgw8+6CxX7h4XXHCBx/NTZiJPIGXGgXomtgTS7qSeiT3B6KdQx8Qef/vTYV3HGLj1ySefmPT0dCPJSDJt27Z1Pk9MTDSLFy+OinNGo1B/jsnJyc7jO86XmJjo/H+7du3Mxx9/HNRzRqNwKP+vvPJKo2s5b968Vj9nNLDi2h06dMiMHTvWeR6bzWaysrJMXFyc87WCgoKgnzeahPq61dbWmiuuuKLR31hmZqax2WzO/w8bNswUFRUF9bzRJjMzs9Fn6HhMmTKl1c4ZDvVzpAv1daNtAsQOX9qvgdTnfBdEpuOPP77Z90FSUpLz/+np6eaf//yny31nzJjhvL6dOnVy+bjmmmvcnpsyE5kCKTPGUM/EokDandQzsSfQfgp1TGzytz8dznUMgTk3iouLTYcOHYwkc/LJJ5v8/HxjjDE//fSTOffcc40kk5KSYrZv3x7R54xGVnyOCQkJZvTo0ebll182+/fvN8YYc/jwYZOXl2f69u3r/PF57969QTtntAmH8l9YWGg6duxojjvuOAJzPrDq2l1wwQVGksnKyjLPPfecKS0tNcYYU1NTY7799ltz1113meLi4qCeM5pYcd3mzJnj/NuaMWOGKSkpMcYYU1lZaebMmWPi4+ONJHPLLbcE7ZzRqEOHDmb48OHmtttuMwsXLjRDhw5t1QBPONTP0SDU1422CRAbfGm/BlKf810Que644w7zl7/8xWzcuNGUl5cbY4ypr683X3/9tTnnnHOcgZY9e/Y029fxY9bo0aN9Pi9lJnIFUmaoZ2JTIO1O6pnYE0h5oY6JXf72p8O5jiEw58bMmTOdH+7OnTsbbSsqKjI5OTlGkrnxxhsj+pzRyIrP8dNPP3W77ZtvvnGO4HnwwQeDds5oEw7l//rrrzeSzIcffkhgzgdWXLtly5Y5705Zs2ZN0I4bS6y4bqNGjTKSTG5ursvt06ZNM5JMp06dgnbOaFRdXd3o/6NHj27VAE841M/RINTXjbYJEBt8ab8GUp/zXRCdSktLTUZGhpFknnjiiWbbA/kxizITnVoqM9QzsSmQdif1TOwJpLxQx8Quf/vT4VzHsMacG4sXL5YkTZgwQb169Wq0LSsrS5MnT5YkLV26VHV1dRF7zmhkxec4YsQIt9uGDBmiY489VpK0du3aoJwvGlld/j/55BO99NJLuvTSSzVu3LigHz+aWXHtnnvuOUnSjTfeqOHDhwflmLHGiuv2yy+/SJJOOOEEl9uHDBkiSSovLw/K+aJVUlJSSM9ndf0cLUJ93WibANHP1/ZrIPU53wXRKSMjQ3379pVkXz8lmCgz0amlMkM9E5usandSZiJTIOWFOiZ2hbo/LbV+mSEw50JxcbE2bNggSTr77LNdphkzZowkqbCwUBs3bozIc0ajcP0cs7KyJEk2my0k54s0Vl+3mpoa3XTTTUpJSdHs2bODeuxoZ8W1q6mpUV5eniTp6quvDvh4sciqvzlHA/v77793uf27776TJA0bNiwo50PgrK6f0XpomwCRzdf2ayD1Od8F0Wv//v3avHmzJKlbt25BOy5lJnp5KjPUM3CnNdqdlJno5a68UMcglEJRZgjMueBoZEhS//79XaZp+PqmTZsi8pzRKBw/x/LycueP0PzY7JrV123WrFnatGmTpk+f3uwOCHhmxbX74YcfVFNTo7i4OJ188sl64403dNZZZykjI0MZGRk65ZRT9OSTT6q6ujrgc0Urq/7mbrnlFknSu+++q5kzZ+rQoUOSpKqqKr344ot68cUXlZKSolmzZgXlfAic1fUzWgdtEyDy+dp+DaQ+57sguhhj9Msvv+jNN9/U2LFjVVFRoZSUFI83vH333XcaPHiwUlNTlZGRoRNPPFH33XefczaEpigz0cXbMkM9A1e8bXdSz0DyXF6oYxCIcKxjCMy5sG/fPufzzp07S5KmTZumjIwM3XrrrZKkLl26ONO4u4Dhfs5oFI6f4//+7/+qoqJCycnJmjp1aqufLxJZed02b96sWbNm6dhjj9Xdd98dtOPGCiuu3e7duyVJ2dnZeu6553TppZfqiy++UEJCgqqrq/XVV1/prrvu0tlnn82UiG5Y9Tc3YcIEzZ49WwkJCXrggQfUtm1bZWdnKy0tTbfccovGjRunzz77TGeccUZQzofAheP3KgJH2wSIbP60XwOpz/kuiA6rVq2SzWZTXFycOnfurEsuuUQbN25Ux44dtWzZMh1zzDFu9z1w4IA2b96s1NRUlZeX69tvv9WsWbM0ePBgff75583SU2aig69lhnoGrnjb7qSegeS5vFDHIBDhWMcQmHOh4Q+5qampOnjwoF588UWVlZVpzpw5KiwsVGpqqjNNWVlZRJ4zGoXb57h+/XrNnDlTkjR9+nT17NmzVc8Xqay8bjfddJOqq6v11FNPKSUlJWjHjRVWXDvHKKvKykpNnz5dubm52r59u4qKilRWVqa5c+cqKSlJq1at0vTp0wM+XzSy8m/ujjvu0D/+8Q/l5ORIsk8PYIyRJMXFxfH9FmbC7XsVgaNtAkQ+f9qvgdTnfBdEh6SkJHXq1EkdOnRwTg82cOBAvf/++zr33HNd7tO/f389/fTT2rlzp6qqqlRYWKjCwkL99a9/VUZGhg4cOKCLLrqo0Y9XEmUmWvhaZqhn0JQ37U7qGTi0VF6oY+CPcK5jCMx5oX379po8ebLS0tI0bdo0tWvXLirPGY2s/BwPHDigyy67TFVVVRo7dqzuv//+kJ070oXqur300ktauXKlzj//fF144YWtco5YE4prV19fL0mqqKhQZmamli5d6rxbMykpSddff73z7pW5c+eqoqIi6HmINqH6mystLdVFF12kCy+8UBdddJE2btyo8vJybdq0Sb/97W/1/vvva9y4cXrllVda5fwIHO2TyEbbBAgPnTt3ls1m8+nhEKz2ayD1Od8FoRdImXEYOnSo9u3bp/3796uiokIfffSR2rRpo6FDh+qee+5xtrEbuuqqq/Sb3/xGvXr1Unx8vCT72j+33nqr3nnnHdlsNh08eFBPPvmkx/xTZkLPqjLTEPVMZAlGmWnI23Yn9Uxksqq8NEQdE1mCXWa8Fc51DIE5F9q0aeN8XllZKUlasGCBysvL9fzzzzd6XZLS09Mj8pzRKFw+x0OHDun888/X9u3bNWTIEL3++uvOP340Z8V1Kygo0N13362kpCQ9/fTTAR8vVlldX1533XWN/u/gmPKgsrJSa9euDfic0caqunLatGlatmyZLr/8cs2dO1fHH3+80tLSNGDAAD355JO6/fbbVVtbq9/85jcqLS0NyjkRmHD5XkXgaJsAkS+Q9msg9TnfBdEnJSVFY8aM0WeffaaTTjpJTzzxhJ555hmfjjFq1CiNGTNGkn394IYoM9HHmzJDPQOHYLU7qWdig7flhToGwWZ1HUNgzgXHvKGSmg1jdNi7d6/zeadOnSLynNEoHD7HqqoqXXTRRfrqq6/Ut29fLV++XFlZWUE/TzSx4rrdd999Kiws1J133ql+/foFfLxYZcW1c0yBKLlfgLV3797O5z///HPA54w2Vly3HTt2aPHixZKkG264wWWam2++WZJUWFiovLy8gM+JwIXD9yoCR9sECC/ff/+9CgoKfHpIgbVfA6nP+S6wnr9lpiUpKSm6/fbbJUmPPfaYz/kaOnSoJGnnzp2NXqfMWM+KMkM9E9mCVWaC3e6knglPVpQX6pjI1lrfS4Gyso4hMOfCgAEDnM/z8/Ndpmn4+sCBAyPynNHI6s+xtrZWV1xxhVasWKEePXooLy+v0R8yXLPium3ZskWS9Oijj3ocLn3ttdfKZrM1CvTgKCuuXcMfooI1tD3WWHHdNm7c6Hzubk2rXr16OZ9v37494HMicFZ/ryJwtE2A8NOuXTvl5OT49JACa78GUp/zXWA9f8uMN7p37y7JfjNbcXGxT/ly1xanzFjPijJDPRPZglFmWqPdST0TnqwoL9Qxka01v5cCYWUdQ2DOhaysLJ1wwgmSpJUrV7pMs2LFCkn2QjV48OCIPGc0svJzrK+v1+TJk/X222+rU6dOysvLa/QjM9yj/EcuK65dp06dnD80uftybHinS7du3QI+Z7Sx4rpVVVU5n+/Zs8dlmp9++sn5PDExMeBzInDUz5GNtgkAh0Dqc74LotuuXbucz40xPu27fv16SXKu9+xAmYlu7soM9Uxsa612J/VMdPKnvFDHoDVYWccQmHNj4sSJkqRly5Zp9+7djbaVlJRo4cKFkqRLL73U4zzJDe9gbDoksrXOGeusuHaSdNNNN+m1115T+/btlZeX53aKPbgW6uv28ccfyxjj9uEwb948GWO8KgOxyoq/uYsvvliS/fpUVFQ02z5//nxJ9jmhhw0b5uU7iS2hvm7HH3+887nj2E299tprzudct9ZF+yQy0TYBYlug7ddA6nO+CyJTWVmZx+2HDx92rpPSp08fZWdnO7fV1dV53HfNmjXOqccnTJjQbDtlJjIFUmYk6plY5k+7k3omdvnbT6GOgS/Cvo4xcKm4uNh06NDBSDLDhg0zW7ZsMcYYs2fPHpObm2skmZSUFLN9+3aPx5HkfOzYsSMk54x1Vly7//f//p+RZDIzM83atWuD9VZiihXXzZvjzJs3z+9jxAorrt3u3btNamqqkWTGjx/vTF9dXW3mzp1rkpKSjCRz9913B+MtRiUrrtuoUaOMJGOz2cy9995rCgoKjDHGlJaWmqeeesqkpKQ481NfXx+U9xmNDh06ZAoKCpyPM88800gyV155ZaPXq6qq3B6D9knohfq60TYBYk9L7ddA6nO+CyLTvHnzzIknnmiefvpps3nzZmf7qqKiwqxYscL5XSTJzJkzp9G+H3/8sRk9erRZsGCB2bNnj/P1Q4cOmfnz55v27dsbSaZTp07ONl1DlJnIFEiZMYZ6Jlb52+6knolNgfRTqGNilz/96XCvYwjMebBy5UrTpk0bZ6MjMzPT2Gw2I8kkJiaa1157rcVj+BokCMY5Edpr9+OPPzrTpaammk6dOnl8wD0r/uZaOg6BOe9Yce2WLl3qDMBJMtnZ2Y3+P2bMGFNZWRmEdxe9Qn3ddu3aZfr3799on7Zt2zb6/7HHHktDuAVTpkxp9Jm5e3iqv2ifhF4orxttEyA2eVOPBFKf810QeebNm9fouyMpKcm0a9eu0Ws2m83lzWwrVqxolK5Nmzamffv2Ji4uzvlajx49PP6oSpmJPIGUGQfqmdgSSLuTeib2BKOfQh0Tm/zpT4d7HUNgrgVbt2411157renevbtJSkoynTt3NldccYXXEX1/ggSBnhN2obp2O3bs8KpicDzgmRV/c56OQ2DOe1Zcu40bN5qpU6eaHj16mKSkJNO2bVtz5plnmr/+9a+mpqYmgHcTO0J93crLy83s2bPNiBEjTHZ2tomPjzeZmZnm9NNPN4899pg5dOhQgO8o+lkRmDOG9kmgQnndaJsAscnb9msg9TnfBZFl//79Zu7cueY///M/zZAhQ0znzp1NYmKiSUtLM/379zfXXXedWbVqlct9CwoKzJ/+9Cdz7rnnmmOOOcZkZWWZ+Ph4k52dbc4880zz2GOPmeLi4hbzQJmJLIGUmYaoZ2JHIO1O6pnYE6x+CnVM7PGnPx3udYzNGB9X9wUAAAAAAAAAAADgszirMwAAAAAAAAAAAADEAgJzAAAAAAAAAAAAQAgQmAMAAAAAAAAAAABCgMAcAAAAAAAAAAAAEAIE5gAAAAAAAAAAAIAQIDAHAAAAAAAAAAAAhACBOQAAAAAAAAAAACAECMwBAAAAAAAAAAAAIUBgDgAAAAAAAAAAAAgBAnMAAAAAAAAAAABACBCYAwAAAAAAAAAAAEKAwBwAAAAAAAAAAAAQAgTmAAAAAAAAAAAAgBAgMAcAAAAAAAAAAACEAIE5AAAAAAAAAAAAIAQIzAEAAAAAAAAAAAAhQGAOAAAAAAAAAAAACAECcwAAAAAAAAAAAEAIEJgDAAAAAAAAAAAAQoDAHAAAAAAAAAAAABACBOYAAAAAAAAAAACAECAwBwAAAAAAAAAAAIQAgTkAAAAAAAAAAAAgBAjMAQAAAAAAAAAAACFAYA4AAAAAAAAAAAAIAQJzAAAAAAAAAAAAQAgQmAMAAAAAAAAAAABCgMAcAAAAAAAAAAAAEAIE5gAAAAAAAAAAAIAQIDAHAAAAAAAAAAAAhACBOQAAAAAAAAAAACAECMwBAAAAAAAAAAAAIUBgDgAAAAAAAAAAAAgBAnMAAAAAAAAAAABACBCYAwAAAAAAAAAAAEKAwBwAAAAAAAAAAAAQAgTmAAAAAAAAAAAAgBAgMAcAAAAAAAAAAACEAIE5AAAAAAAAAAAAIAQIzAEAAAAAAAAAAAAhQGAOAAAAAAAAAAAACAECcwAAAAAAAAAAAEAIEJgDAAAAAAAAAAAAQoDAHAAAAAAAAAAAABACBOYAAAAAAAAAAACAECAwBwAAAAAAAAAAAIQAgTkAAAAAAAAAAAAgBAjMAQAAAAAAAAAAACFAYA4AAAAAAAAAAAAIAQJzAAAAAAAAAAAAQAgQmAMAAAAAAAAAAABCgMAcAAAAAAAAAAAAEAIE5gAAAAAAAAAAAIAQIDAHAAAAAAAAAAAAhACBOQAAAAAAAAAAACAECMwBAAAAAAAAAAAAIUBgDgAAAAAAAAAAAAgBAnMAAAAAAAAAAABACBCYAwAAAAAAAAAAAEKAwBwAAAAAAAAAAAAQAgTmAAAAAAAAAAAAgBAgMAcAAAAAAAAAAACEAIE5AAAAAAAAAAAAIAQIzAEAAAAAAAAAAAAhkGB1BqJFfX29fv75Z2VkZMhms1mdHQAAAAB+Msbo0KFD6tq1q+LiuJcR/qGPCAAAAESHYPcRCcwFyc8//6wePXpYnQ0AAAAAQbJ79251797d6mwgQtFHBAAAAKJLsPqIBOaCJCMjQ5L9wrRt29bi3ABAhNi6VdqxQzr2WKlPn9bfDwAAL5SWlqpHjx7ONj7gD/qIAAAAgI/C9De/YPcRCcwFiWNqkrZt29LpAoCWFBZKV10lLV9+9LXcXGnRIik7O/j7OeTnS9u2SX37Sv36+Z9/AEBMYPpBBII+IgAAAOClQH/zC5Fg9RFZMAEAEHpXXSXl5TV+LS9PmjSpdfYrLJTOO08aMEAaP17q39/+/6Ii3/MOAAAAAAAAIHj8/c0vQhGYAwCEVn6+/e6XurrGr9fV2V/fsiW4+0kx9+UOAAAAAAAARIRAfvOLUATmAAChtW2b5+1btwZ3vxj8cgcAAAAAAAAigr+/+UUwAnMAgNBqaeHWvn2Du18MfrkDAAAAAAAAEcHf3/wiGIE5AEBo9e9vX7w1Pr7x6/Hx9tf79QvufjH45Q4AAAAAAABEBH9/84tgBOYAAKG3aJE0blzj18aNs78e7P1i8MsdAAAAAAAAiBj+/lYYoRKszgAAIAZlZ0vvv29f323rVvuoNW8CZP7ut2iRNGmSfU05hyj+cgcAAAAAAAAihr+/+UUoAnMAAOv06+ffl6yv+8XYlzsAAAAAAAAQcfz9rTDCMJUlACB29OsnnX9+THzBAwAA7+3bt09PP/20fvWrX6l79+5KTk5Wenq6hgwZonvvvVf79u2zOosAAAAAogQj5gAAAAAAMa13796qrq52/r9t27aqrKzUhg0btGHDBr344ov6xz/+odGjR1uYSwAAAADRgBFzAAAAAICYVldXp9GjR+vll1/W/v37VVJSooqKCuXl5alv374qLCzURRddxMg5AAAAAAEjMAcAAAAAiGkrVqzQxx9/rGuuuUYdOnSQJCUkJGjs2LFaunSp4uLiVFJSoueff97inAIAAACIdATmAAAAAAAxbcSIEW63DRkyRMcee6wkae3ataHKEgAAAIAoRWAOAAAAAAAPsrKyJEk2m83ajAAAAACIeATmAAAAAABwo7y8XN9//70kadiwYRbnBgAAAECkS7A6AwAAAAAAhKv//d//VUVFhZKTkzV16lS36aqrq1VdXe38f2lpaQhyBwAAACDSMGIOAAAAAAAX1q9fr5kzZ0qSpk+frp49e7pNO2vWLGVmZjofPXr0CFU2AQAAAEQQmzHGBPOAxcXFWrx4sb744gvl5+erpKREkpSZmal+/frpzDPP1MSJE5WdnR3M01qutLRUmZmZKikpUdu2ba3ODgAAAAA/0bYPD1b3LQ8cOKDTTjtN27dv19ixY7V8+XLFx8e7Te9qxFyPHj0oRwAAAECEC3YfMaiBuVmzZmnmzJmqqqpyvuY4fMNFspOTk/X73/9ev//974N1asvReQcAAACiA21761ndtzx06JDGjBmjr776SkOGDNHKlSuVlZXl0zEoRwAAAEB0CHbbPmhrzN1888168cUXnZ2lhIQE9e7d23n3YmFhoXbu3Km6ujpVVVXpD3/4g3bu3KkXX3wxWFkAAEST/Hxp2zapb1+pXz+rcwMAAELE6r5lVVWVLrroIn311Vfq27evli9f7nNQDgAAAADcCcoac8uXL9cLL7wgY4wGDhyoJUuWqKSkRPn5+fryyy/15ZdfasuWLSopKdGiRYs0YMAAGWP00ksv6f333w9GFgAA0aKwUDrvPGnAAGn8eKl/f/v/i4qszhkAAGhlVvcta2trdcUVV2jFihXq0aOH8vLy1Llz5yC8MwAAAACwC0pg7oUXXpAknXDCCVq9erUuv/xypaamNkuXlpamiRMnavXq1Tr++OMb7QsAgCTpqqukvLzGr+XlSZMmebd/fr703nvSli3BzxsAAGhVVvYt6+vrNXnyZL399tvq1KmT8vLy1KtXr4COCQAAAABNBSUwt2rVKtlsNt17771KT09vMX1GRobuu+8+GWP05ZdfBiMLAIBw5UugLD9fWr5cqqtr/Hpdnf11T8dgpB0AABHPyr7lTTfdpNdee03t27dXXl6e+vfvH9DxAAAAAMCVoATmDh48KEkaOHCg1/s40jr2BQBEGX8CZdu2eT7m1q3utwU60g4AAFjOqr7lHXfcoblz5yozM1MffPCBBg8e7PexAAAAAMCThGAcJCMjQ4WFhfrll1+83seRNiMjIxhZAACEG0+BMndrwPTp4/mYffu6ft0x0q6phiPt+vVrOc8AAMBSVvQtd+3apf/93/+VJNXU1Gj8+PEe0+/bt8+v8wAAAACAFKQRc467CX2Z0/+5556TJOd6AACAKOLvlJT9+0u5uVJ8fOPX4+Ptr7sLrgUy0q4lrFkHAEDIWNG3rK+vdz6vrKzUL7/84vEBAAAAAIEISmBu4sSJMsborbfe0vXXX68DBw64TVtQUKBrr71Wy5Ytk81m05VXXhmMLAAAwkkggbJFi6Rx4xq/Nm6c/XV3/B1p5wlr1gEAEHJW9C179+4tY4zXDwAAAAAIhM0EoWdRV1en008/XWvXrpXNZlNCQoJOO+00DRo0SNnZ2ZKkoqIifffdd1q9erVqa2tljNGwYcO0atUqxTcdGRGBSktLlZmZqZKSErVt29bq7ACAtfLz7QEtT9tbmlpyyxZ7AK9vX++moTzvPPtUmQ1H6cXH24N67qbODOXxAAARg7a9daKpb0k5AgAAAKJDsNv2QQnMSfbO0RVXXKGPPvrIfmCbzWU6x+nOOeccLVmyRO3btw/G6S1HpwsAmgh1YKuoyL5+XcO15nJz7SPtjvyQ51Z+vn2UnyMIGIzAIgAgYtG2t1a09C0pRwAAAEB0CHbbPihTWUpSdna2PvzwQ73zzjv69a9/ra5duzab8qNLly769a9/rWXLlumjjz4Ku44TACCI/JmSMhDZ2faAX36+9O679n/ff99zUM7ddJXr13s+VyBr1gEAAI/oWwIAAACIZkEbMedKZWWlSkpKJEmZmZlKTU1trVNZjrshAcS0piPOGvJ1SspQcjeq74wzpM8+c78fI+YAIKrRtg8/kdi3pBwBAAAA0SFsR8y5kpqaqs6dO6tz586t0nFat26dnn32WU2ZMkUDBw5UXFycbDabpk6d2uK+27Zt0w033KCePXsqJSVFXbt21aRJk/T1118HPZ8AELXcjTgrKjqapl8/6fzzwy+QlZ9vn/ayYVBOsv//s8+kkSPtQbqG4uPt02OG23sBACDKtXbfEgAAAABCJcHqDARizJgxzrsmffHpp59q/PjxKisrkyS1bdtWe/fu1WuvvaalS5dq4cKFuuKKK4KdXQCIPlddZR9x1lBenn2tt9ZYRy6Ytm3zvP2226S0tMZr1rXmVJwAAAAAAAAAol6rjphrbUlJSRo+fLhuu+02LVy4UEOHDm1xn5KSEl122WUqKyvTySefrPz8fJWUlOinn37Sueeeq8OHD2vKlCnasWNHCN4BAEQwTyPOli+3T2EZzvr08bz95JN9X7MOAAAAAAAAADywLDD33XffKS4uTgkJ/g/a++mnn7RmzRr95S9/0dVXX62MjIwW93nmmWdUUFCglJQUvfHGG+p3ZDqybt26acmSJcrJyVFVVZVmzZrld74AICa0NOJs69bQ5MNf/fvbp6VsabpKT1Nx5udL770X/kFIAACiWDD6lgAAAAAQKpaPmDPG+L1vUlKSz/ssXrxYkjRhwgT16tWr0basrCxNnjxZkrR06VLVNR0FAgA4qqURZ337hiYfgVi0yD49ZUPeTFfpzdp6AAAgpALpW8YUbiwCAACAlWiPWh+YC6Xi4mJt2LBBknT22We7TDNmzBhJUmFhoTZu3BiqrAFA5PF2xFk4y872b7pKT2vrAQAAhCNuLAIAAICVaI86xVRgbvPmzc7n/fv3d5mm4eubNm1q9TwBQETzd8RZuPE0XWVTkb62HgAAiE3cWAQAAIBg8jTyzdU22qNOPk3Cv2vXLufznj17unzdWz///LPP+wRq3759zuedO3eWJE2bNk2LFi3S5MmT9eyzz6pLly7ONL/88ovbY1VXV6u6utr5/9LS0lbIMQCEOceIsy1b7GvK9e0bGSPlAuHN2nrR/hkAABCgSO9bRhzHjUVNNbyxiPYLAAAAvFFYaA+yNWxf5ubab9Q3xvW2Rx6hPdqAT4G5Y445RpJks9lUW1vrfL13796y2WzBzVkrKC8vdz5PTU3VwYMH9eKLL0qS5syZo5kzZ6pt27bONGVlZW6PNWvWLD300EOtl1kAiCT9+sXOl2c0rK0HAIDFIr1vGXG4sQgAAADB0tLIN1fbCgo8HzPG2qM+TWVpjHE+PG3z9mG19u3ba/LkyUpLS9O0adPUrl07r/edPn26SkpKnI/du3e3Yk4BAGEjGtbWAwDAYtHWtwx73FgEAACAYGhpiRd329at83zcGGuP+jRibt68eW632Ww2PfLII+rWrZtXx9qzZ4/uv/9+X04fsDZt2jifV1ZWSpIWLFigBQsWNHtdktLT090eKzk5WcnJya2QSwBA2Fu0yH4XUMMh+JG4th4AABaJ9L5lxHHcWJSX1/iHkvh4exuGG4sAAADgjZZmYvBk6FDpm29oj8rHwNyUKVM8br/44os1aNAgr4713Xffhbzz5FhXTrKvNzd48OBmafbu3et83qlTp5DkCwAQYWJxbT0AAIIo0vuWEYkbiwAAABColmZi8OT556X776c9Kh8Dc5FuwIABzuf5+fkaN25cszT5+fnO5wMHDgxJvgAAESqW1tYDAACRjRuLAAAAEKiWZmKQ3G8bPpz26BE+rTEX6bKysnTCCSdIklauXOkyzYoVKyRJ7dq1czmiDgAAAACAiNWvn3T++TH7IwgAAAACtGjR0SCcg2Pkm6dtDrRHgzNi7o033pAk9erVKxiHa1UTJ07Uhg0btGzZMu3evVs9evRwbispKdHChQslSZdeeqni4+OtyiYAAAAAxJxI6lsCAAAAMamlmRgYFdeioATmLrroIp/36d69u8cFv71RVlamqqoq5/8PHz4sSaqurtaBAwecr2dkZCg5OVmSdNttt+npp59WQUGBLrnkEr322mvq27evfv75Z1133XXav3+/UlJSdN999wWUNwAAAACAb6zqWwIAAADwkaclXlj+xSObMcZYnQl/TZ06VX//+99bTDdv3jxNnTrV+f9PPvlE48ePV3l5uSQpMzNTpaWlMsYoMTFRL7/8siZOnOhTXkpLS5WZmamSkhK1bdvWp30BAAAAhA/a9ggGyhEAAAAQHYLdto+pNeYcRo0apW+++UbXXnutunfvrsrKSnXq1ElXXHGFVq1a5XNQDgAAAAAAAAAAIOLk50vvvWeffhIhEdEj5sIJd0MCiAr5+dK2bcz/DACIabTtEQyUIwAAAIS1wkLpqquk5cuPvpabKy1aZF9HDk6MmAMABF9hoXTeedKAAdL48VL//vb/FxVZnTMAAAAAAAAAwXbVVVJeXuPX8vKkSZOO/p/RdK0iKIG5hx9+WA8//LAOHDjg9T6HDx/Www8/rEceeSQYWQAABMKbL2IAAIBWRt8SAAAACIH8fPtIubq6xq/X1dlfX7OGm/hbUVCmsoyLi5PNZtOGDRs0aNAgr/YpLy9XRkaGbDab6ppe/AjENCUAIlZ+vv1L1tP2fv2Y5hIAEDNo21snmvqWlCMAAACErffeswfc3Bk6VPrmm8aBu/h4adw46f33Wz9/YYapLAEAgWk6BH3bNs/pv/6aO2T8wVB/AAAAAAAAhKM+fTxvX7fO/Wg6fusKmGWBuZqaGkmSzWazKgsAEFvcrSOXk+N5v2eeYZpLX7BeHwAAIUXfEgAAAPBR//5Sbq59FFxD8fH20XKebN3aevmKEZYF5rYeuXht2rSxKgsAEFvcrSP3wAPuv4hHjJA+/ZQ7ZHzBwrkAAIQUfUsAAADAD4sW2aembGjcOOm55zzv17dv6+UpRlgSmKusrNSMGTMkSX25iADQ+lpa0HXmTNdfxLff7vm43CHTGAvnAgAQUvQtAQAAENZCeXO2p3O52padbV8vLj9fevdd+7/vvy+dcor7m/hzc6V+/Vr3fcSABH92GjNmjMvXr7322hbvUqyoqND333+v8vJy2Ww2XXjhhf5kAQDgi5bWkSsosH/xbtliD7b17Wv/ks3P97wfP4A11tLnfPPN9oVzG3KMpnMsnJufbz+O4xoAABDF6FsCAAAg6L+FhPq3FVfnKyy0z6q0fPnRdLm59lFq2dnBzaencxnTcj769Wt+/kWL7L9XNdxv3Dj76wiYzRhjfN0pLi5ONptNfuzayLBhw/Txxx9HxZQjpaWlyszMVElJidq2bWt1dgCgsfx8+ygtT9vdNQDOO88ePGo4Ciw+3v5l7Agmwa6lz9mT1avt04p6aigBAEKCtn3oRHPfknIEAADQAm+CV6E8nq+BMk/nmzTJ/e9pr77qf9DO1euefruTAvtdr+lN/DEq2G17vwJzZ599dqOFtVeuXCmbzaZhw4Z57AjZbDalpKSoR48eOuecc3TZZZcpMTHRv5yHGTpdAMJO0y9qfwNsRUXN75AhYOSeu8/5xBOldevc7zd0qH00HQFQALAcbfvQiea+JeUIAACgBcG+Gdyb4/k7us2X851xhvTZZ+73GzlS+uIL34J2zz4r3Xpr89cfeUQ69VT35/LE0436aCQsAnNNOe5y3LBhgwYNGhRwpiIRnS4AYcNdY2LOHOmWW/wPsHGHjHfcBTJpKAFAxKBtb51o6ltSjgAAEMs1wD1vZncyxvvy09LxPM1U5Gl0m7sAYSCzJnniLmiXlSUVF/t+I7gn774rnX9+ILmNGcFu2/u1xhwAIIxddZW9MdFQXp49KOdqHTlvuZpvGs05Fs519Tnn5vo3mm7rVj57AAAAAEDrCmYQLdhTFCK0WiOg2vSY27Z5Tn/llY1/K2mp/LR0vJtvts9U1FBennThha5Ht9XV2cvvli32/Pqaf399+qnrvBw86Pp1f4Nykv29wBJxVmcAABBE+fn2RkPDwI/UvDFx/vkEelqbq8950aKj83s7jBsnPfec52PRUAIAAACA2JOfL733nr0v35oKC+1T8g0YII0fL/Xvb/9/UZH/x3R30/CkSYHlNRq4u66hut6eztcaZcHdMXNyPO/nKojmqfz06eP5eOvWuf69zNOUk5L09df+5X/kSPvN2A3Fx0sjRnjezx9Dh7o+V26u/eFuG78NWiYogblRo0Zp1KhRYbXQNgDEpJbu1tm6NTT5gGuO0XT5+fbpAvLz7f8/5RQaSgAAiL4lAACSWic44kmwg2je3DQci9xd1+3bW+96+xp886Ys+BpAdHfMBx5w/VtI3JGQRUvlp2k++vd3/9vK0KHe5dWVZ57xLf+O33Leesv1zdnLlrnfz9+g3fPPuz7XokXubxJftMi/cyEogrLGHFg/AECY8GZ+boI84cnd2nRM8wEAIUfbHsFAOQIA+O2883xf78pf3v6O4Glqw6bb3nvPHvBxx4p1rcJhrTt319Xd2mGBXG9PU4m6W0/tjDM8jx7ztEab43eLpp9zS+VrzRrp/vsbH3PoUM/TMy5eLL30kut8SK5/W3nkEenUU90f0926bi19Jq7y3/QzcbXUiaffgNxdH2/Kiafla/xd2gaSgt+2JzAXJHS6ALQaXxuPoWzAI/hoKAGA5WjbIxgoRwAAvwQjUOaLloJonoIgxrgO/rQUBGmtm4ZdfSberHUXivXUWrquno7ja2BUcv/bUEuBJk+GDrVPL+nq96ZXX3X9OV93nTRxovtjOoK0DX8LMcbzZ+UuiNZSgMrT72WOgFgw8u9LGfIlaDdnjnTLLdzQbRECc2GKTheAoPN3oWRGXgEAEBDa9ggGyhEAwCu+jjbzFCjzJ9DUUsDIUxBEch/o8LTNscSDL4EmT9v8GR3mKZjk7e8nvuSlpQCPO60RGG0N/o44cxek9Tew6Cno683vZU0DZVbOTOUu2McN3ZYgMBem6HQBCDpvRr55aqzyRQ0AgF9o2yMYKEcAEIPc9dF9CeD4O+VeIIGm1hhd5W6Kv2eflW691bdAU0vb/J2a0ZuRV660xjSR/uRRcn2uE0/0PBWkP+drjWN6+pzdBdG8HcHmia+/lzEzFRTmgbmNGzfqqaee0ueff669e/eqoqJC9fX1njNgs6m2tjZYWbAMnS4AQdXSHTnezOsNAAD8QtveeqHuW65bt06rVq3Sl19+qS+//FL5+fkyxmjKlCmaP3++X8ekHAFADHEXqPEUhPI0kktqvUCTqyChv0EQT9xN8ecpyOHufQfymfjL00gofwOZ7q6Pu7XDWuu9eSon7qZ0DGQUnjejPN0JhxFszEwFhXFg7q233tKVV16pmpoa+XJIm82muoaVQISi0wUgqFqausLTvN7crQMAQEBo21vLir5lVlaWSkpKmr1OYA4AgiwUa3lZwV2gxt+Ai7vRZoEEyry5wdfXIIgnrgIkgRwv1ByBxWCtFSe5D1C5WzsskOvt6Xcjd8E3T2VBCnx6yWDN7GTVCDZmpoppwW7bJwQhT9qzZ4+uueYaVVdXKysrS+PHj1ebNm304osvymaz6YEHHlBxcbG+/fZbffrpp6qvr9fJJ5+sCRMmBOP0ABB9+vTxvN3V9AF1dfZG1ZYtNBCiVTh0OAEAaEVW9S2TkpI0fPhwnX766Tr99NM1e/ZsrfN3uiYAQHP+rqHu4Ou6YoGOYvFljbP8/MZ5cKirkw4edP16S6OgCgrsAQZXgTJ/3XyzPVDTUF6ePUDjCGb069f4/fbvb/9M/Rnh5qrPum2b//n3l79rn+Xk2ANAroJl/jr5ZNfXVQr+9X7++ebBXUdQLjvbfT4cmpYFyXVAr2Ggr6Wy4OqY/vCUj9YUrPwDkmSC4J577jE2m83079/f7NmzxxhjzMaNG43NZjNxcXGN0u7YscOMHj3axMXFmQceeCAYpw8LJSUlRpIpKSmxOisAwtXmzca8+64x+fnepc/NNSY+3hj7TOr2R3y8MUOHNn6t6ePdd1v3fSD0Dh60l4eG1zk315jCQqtzBgBRiba9dazqW1ZXVzf6/+jRo40kM2XKFL+PSTkCEDF87av6w13/NjfXcz489YX8PaYnns7nbtvixZ776P48POXX3fseMaJ1zuf4rF19Jp62ubJ5c/A/K8mYkSPdlwVPefRUhvz9nD3lxR/+5LHhufLzg//37eqYvpaF1soH0EqC3bYPSmDupJNOMnFxcWbOnDnO19x1nowxprKy0gwaNMjExcWZ5cuXByMLlqPTBcAtf4Mq7ho1q1f736BGZPKmsQ0ACBra9tYJl74lgTkAMcGbvmowgnYtBWNWr/Y9cNJScMTTMT29t9YI1AQ7gONPoCkYN/h6CoL4EiDxN9DkaZs3QSFfgkkt/e7ibyDQH8EMjIYCwTJEqWC37YOyxlz79u1VXFysL774Qqeddpok6fvvv9fgwYPdzvP/t7/9TTfeeKMmTJigt956K9AsWI71AwC4Fejc177M680ac9HHioWNASDG0ba3Trj0Lc8++2ytXLkyataYKy8vd7stPj5eKSkpXqWNi4tTamqqX2krKirk7ucHm82mtLQ0v9JWVlaqvr7ebT7atGnjV9qqqiqPaxb6kjYtLU02m02SVF1drdra2qCkTU1NVVxcnCSppqZGhw8fDkralJQUxcfH+5z28OHDqqmpcZs2OTlZCQkJPqetra1VdXW127RJSUlKTEz0OW1dXZ2qqqrcpk1MTFRSUpLPaevr61VZWRmUtAkJCUpOTpYkGWNUUVFh7x/u2CEde6y9j+gprRvOv/sj/cryhuU3Lk465xxp3jzp2msV/9FHctYQubkqnzvX7TSRbuuIDz6QLr20cVpJzpRDh6pi/XqZhn+fcXHSaadJ//63bJLSGuxbIcndj5nOtEfW16qsq5PzqE3emz76SM6/5NxcVf7+96ofNcrNkXU0raQqSY3+6s88U1q1SjryHtpIzjXmqoqKVNf0vZ1zjjR/vjR1qtI++ki2I5uqzz1XtS+95PYzblRHfPedavPzG5eFoiJp6lTpo4+UKvvnrNxc1fzhDzp81llu31vqpk2KO9LvbPU6okEencaOVfKiRfa/+0mTdHj5ctU02CbHd/GR/ZJ1ZH2m3FzVvvyyqh3fC1u3Stu3N/pMvKojjuyXNGCAEgcNkt57T3Xjx8vtX/3f/67EhQuV9OGHkuxlocqRT8e1a5CXxOOOC7yOcPHenH/3W7bIbNmiim7dGtULDflVRxxBO8L3tLQjgteOaPhZWSnobftgRPcSExNNXFycWb9+vfO17du3O+9qLC8vb7bPmjVrjM1mM126dAlGFizH3ZAAXGrpzkDHHUS+3oUYjndFoXW8+653dzaGYvoZAIgRtO2tEy59S39GzFVVVZmSkhLnY/fu3WFTjmT/DdvlY/z48Y3SpqWluU07evToRmlzcnLcph0+fHijtL169XKbdtCgQY3SDho0yG3aXr16NUo7fPhwt2lzcnIapXVcV1ePtLS0RmnHjx/v8XNr6PLLL/eYtqyszJl2ypQpHtPu37/fmfbWW2/1mHbHjh3OtHfddZfHtBs3bnSmnTFjhse0q1evdqZ9/PHHPaZdsWKFM+0zzzzjMe0777zjTDtv3jyPaZcsWeJMu2TJEo9p582b50z7zjvveEz7zDPPONOuWLHCY9rHH3/cmXb16tUe086YMcOZduPGjR7T3nXXXc60O3bs8Jj21ltvdabdv3mzx7QN66uysjKPaS+//PJGfVVPacer8YigtPh4t2l9qiPUuF/Ty0MeBjVJO8hD2l5N0g73kDanyXsbnZ7uNm1ak+OOb+FzMzrSR9++3VzeqZPHtGXr1zv7ckGtI+bNc/YPI66OePRRj2mXTJ/ufG+tUkds3mxWtHCNH3/8cefosNWvv+4xbUjqiP37Pab1uY5owFNa2hH2B+2Io49g1xHhIth9RHuYM0DZR+4EONhgQdOcnBzn83wXC1UeOnRIklRYWBiMLABAeGppYeOvv7bfpThggDR+vH1h5fPOs99B5oljod78fOndd+3/vv9+4AtcI/z06eN5u2NBal/LEAAAYSiS+5azZs1SZmam89GjRw9L8wMghLZssT9a0803t5wmP1967z37yJqWtNRXdaWurvGsLS3lo6W08fH2kW3B5s8x6+qksrLg5cHRRz/mGGnkSM9p+/aVzj8/+DOhnH125M6u0qmT5+0nn9y6761/f+mUU1pO16+f/dr17Nl6eQEQlYIyleXZZ5+tTz/9VLNnz9Zvf/tb5+t9+vTRzp07dffdd+vRRx9ttM+9996rxx9/XF27dtVPP/0UaBYsF07TlAAIIy1NQzhypPTFF0xJCc88TV0qMa0pAAQZbXvrhEvf0p+pLKurqxtNj1VaWqoePXqERTliCirf0zIFFVNZtjiVZWGhczrERElJkpSbq/pXXlGl42/KxbSTfk1lmZ8vM2CA3E48t3KlEmbOVPKRafWMpIqm0+o1EB8fr5Rdu5x9Vfd/yVK8dHQqS0fav/9dWrCg2VSEcX/+s1LvvFNavvxoWhfTEEpHprLMzZUeeUQ69VT301OeeaZsq1YprcHfbkVcnEyDqSAb5sM2bpzS/vQn6dRTJUmVktz/1TeenrJSUv2JJ0obNjinpLRn1j71ZJuEBGffyzmVpWNayiZTKYd1HeFiSkTqiOZp6w4cUNWVVzYr546/q7Cd7jYIaZnK8ijaEb6nZSpLLwVj2N3vf/97Y7PZTG6TxUnvuusuY7PZTFJSkpkzZ445dOiQKSgoMM8884xJTk42cXFx5pprrglGFizHdDcA3PJ3gWimJISDvwtS+ztVKgDEONr21gmXvqU/U1k2RTkCopy7fl5urjEHD7a89IAvbfSWprcfOtR9Xjydz9++6siRrvdr377lfByZ+s+rfDg+s5Y+S1+O2dJ7W7PG/flYUiI2uSpfAGJOsNv2QRkx9+WXX+qMM85QQkKCtm7dqp5Hhu8WFBRo4MCBKi4udhUQVGpqqtasWaNBgwYFmgXLcVctALeKiqRJk5x3DUqScnOl666TJk50v9+779qnRAActmyx393Yt699yoz33rNPX+nO4sXSSy81L3uLFjHtKQB4QNveOuHSt/RnxFxTlCMgigUyM8qrr0pXXeVbG72l83myerX0wAOuzye57qsuWmR/3dXMHGecIX32me/5yM93P/Wguz5zw8+kaV+oJZ6O6e69NZx1xNP5fM0LACDiBbttH5TAnCT9/e9/V21trc4880wdd9xxztfXrl2rK664Qjt27GiUvmPHjlqwYIH+4z/+IxintxydLiCG5Ofb5+N31Qj3tK1p472lzpWnjgsgMVUqALQS2vbWCoe+JYE5IEZ56s811NINcp5400Z3lQ9309ufeKK0bp378w0dKn3zje9BKH9vMHXHmxtPWyPg5ct74wZGAIAbYRuY8+Tw4cNasWKFNm7cqNraWvXr10+5ubmN5nONdHS6gBhQWOj+zkZjfL/rUfK8dhiBE3jDXRlq6U5WAr8A4BZt+/AVqr4lgTkgxnjq6zn6cw2DZcb4P4LNE39Gtx1Zo80v3vQJfL3BNJBzhRoj3wAAXorIwJw7dXV1evnllzV16lSrshA0dLqAGOApiCb5F2DjTj0EiqlSASDoaNtHnmD3LQnMAVHMl9FonqaePHxYWrkyeFM9Sv6PbvN3NJ2/fQJ358vKkoqLufEUABB1gt22jwtCnnxWU1OjZ599Vn379tUNN9xgRRYAwLP8fPv0JFu2HP3/8uWNOxiS/f/Ll3ve5jiGK9nZ9g5Kfr69U5Sfb/8/QTl4y10ZOukkz/v17Wv/t2lZBwAggtC3BCJEa7Q5fT1mYaE9oDRggH0ayv797f9fs8Zzf+7ii+1BqIYc/3fcpOkwbpy0bJk9cBcf33hbfLw0YoTnPK5b13K/sl8/ezCt4QivRYtc5+W55zyfz9En8JW7861Z4/p1x4g/AAAgSUoI9ABff/21du7cqdraWvXp00dDhw51m7a8vFzPPvusnnrqKf3yyy8yxshmswWaBQDwj6s7Jd1NYXLddf6fZ+vWlqfF6NePqTMQmKZlqH9/e9l1d+dv+/b2HyIYrQkACBNW9i3LyspUVVXl/P/hw4clSdXV1Tpw4IDz9YyMDCUnJ/t9HiDm+DpFpDdrePt7zKuuch1gKyjw/B4+/bT5a3V10r/+ZT+P1HwE26JFzWe1cASoJk3yb3Sbp36l42Y9V6PpPPUJ/O2Dejqfu9cBAMBRxk8LFiww3bt3N3FxcY0eAwcONJ999lmjtOXl5WbmzJmmffv2Ji4uzthsNmOz2UxmZqa55557/M1CWCkpKTGSTElJidVZAdCSgweNyc01xr4ygP2Rm2tMYaH93/j4xtvi440ZMaLxa7488vOtfseIVY4y7UtZz82177t5szHvvkv5BRCTaNuHVjj0LadMmWIktfiYN2+e18ekHAHGc5vTU7/Mnz6bp2OuXu1/f87T4913Pb///PzmbWp3bfSW8uhvu9xTnwAAAHgl2G17v9aYe/zxxzV9+nRHYK/Z9tTUVH3xxRc68cQT9e677+rGG2/Uvn37nGm7d++u3/72t5o2bZoyMjJ8jyaGIdYPAMKUL+sHtLQWwMiR0hdfBHeNOSAUfF2wfeTIxncGM5IOQIyhbR864dK3nDp1qv7+97+3mG7evHler2NHOULM86bN6Wv/yt8+W0uj0dyt7dbS+fLz/R8R5staccHoVzKKDQAAvwW7be9zYG7Tpk0aMmSI6urqZIzRyJEjdeqppyoxMVFbtmzRP//5T1VVVen888/XHXfcofPOO0/GGBljdPzxx+uee+7RpEmTlJAQ8CyaYYVOF2CxpgE4d9ObPPKIdOqp/p1j8WLppZdcT5kiNZ+qhGAGwtV779nX1XAnLk6qrz/6f4LMAGIMbfvQiPa+JeUIUcmXaSdbanOGkzVrpPvvd92fczf1ZGu0j4uK6FcCABCGgt2297kH8/zzz6u2tlZJSUl6/fXXdcEFFzTa/uOPP2rkyJH66KOP9NNPP6m+vl6dO3fWk08+qUmTJgWcYQAxzJf1BQ4fllaubLy/N+sHeHLyyZ7ny2cufUSKPn08b28YlJMaLzjvGHHn7gcZAAC8RN8ygvDdH978vT6+7OdpXTdj3N8UGU7cjYobN04aPtx9f87TenHB5mntNgAAEDV8HjE3bNgwrV+/Xr/97W81e/Zsl2lefvllTZkyRTabTb1799a///1vdezYMSgZDlfcDQkEia+Le7u6e7HpaB9feJpOhdFCiCaupslp6W/H06hR7uAFEEVo24dGtPcto6IceWqH890fWr72kxzXJ1j7eZpiUfJ9W0tTRHrirs/W0jE9jYrzpjwTLAMAIGYFu20f5+sO27dvlyT96le/cptm9OjRzufTp0+PmI4TgBDJz7dPa7Jly9HXCgvtnb0BA+zTnfTvb/9/UZG905iX1/gYeXnShRfaO1UNO2RSy0G5oUPtHbeG4uPtnbK33jragXRorbshASstWtS8rJ95pud9nnnG9d9iw1ELrv6+AQBwgb5lBHDXDvd2xGI0tws8vbdgvm9/+kmTJgV3v5EjXfe7HLMqeNo2c6br/tWyZfb+l7t+madt7vpsLR3TMSouP1969137v++/732QuV8/6fzzCcoBAICA+TxiLv5IA+ebb77R4MGDXaYxxig+Pl42m01ffvmlhg8fHnhOw1xU3A0JBFMwRr4FeielO97cKcndkIgVTcu6u7uhW/pbXL1aeuAB7qgHEBVo24dGtPctI74c5efbgzOetrtrJ0fzSDt/pnQM5H372zbzd1SZq/0CmZHk3XftwSxX/StP66lJLa+15usxI73sAQAAywS7be9zYC4uLk42m00bNmzQoEGDAk4XLSK+0wX4I5yDb45je5qSkuAb0Jy7HzOuu06aONH9fp7W7HD8zbE+DYAIQds+NKK9bxnx5ei99+wjptxxBFxc8TTtYaRPD+/vlI7+vO+WgqORwFMA18FTv8zfPht9PQAAEETBbtsnBCFPACKdpx/LfQ2+eZp20lXwra4usKCcuztBR4+WEhM9L9Ddrx+dNKApdwvO5+d73m/duuavOaYwWrOm5dF0BO0AAAgvffp43t63r+vX8/Mbf+c7ONoFW7ZE7nd9S+/NFV/ed9P20LZtgec5mJqOnPMmIOnNtfbUL/O3z0ZfDwAAhDG/A3P333+/srKyAk5ns9n0t7/9zd9sANHLnx+pgxlg8zQNS7gE3xyBtqajexyvZ2dzpyTgr6Y/ZvTvb68DXP3ocuKJrgNzDjffbB9N15BjHZNXX215yieCdgAQ1ehbhilP3/2eAi4tBZO2bg3s+9zKdkEggTJP79tdv+yRRzwfM5jTVXqz31lnSZ9+evT/DW98dNcnAwAAQDN+T2UZTHVNFwmOQBE/TYnVQtm5ao1z+RoQ87TNm/UYmu7nb4DN3dSSnu56bK1pJ30NvrEmHBB67qa5fOQR6dRT/Tump799b4J2ANAKaNuHRrT3LSOuHLnqm/izXlcga9N5Eg7r1gUytaTjfbv6nP2dHtNTP8lTX8/f/VzNqtAQfTIAABClwmKNuWCy2Wxh1XnyV8R1ulpLKIJQVpzLn2N6Coj5Gyxz9yP14cPSypXhEWDzhOAbEB1c/S26+0GppdF0nniqM1i3DkArom0fGtHet4yYcuRNP8nXdnhrrDEX6DGDNSOJv0E0d325lm5wWrNGuv9+36+PN0FVf/cDAACIMZYH5n788ceAT9pUr169gn7MUIuYTlcwBDNA5U8Q6tlnpVtvDc25WmPEWSDBMlc/Ujed599qBN+A2NQao+k8Wb2adeuASBGBf4sx1ba3ULT3LSOmHLVGEC3YwZ1ARuEFe0YSyf1787TNXd+xpZuY3n1XOv98//tJod4PAAAgClkemINrEdPpCoSnzklrTInoLsCTlSUVF4fmXOE24ixcEHwD4I4vo+kCqUeHDrWvW+fvFJj+TkEMxDpf/j4Cna3AQjHRtkeri4hy1FrTTjp4avf78vf/3nvS+PHutzuCV654Cjz6MyOJI1jpy5SOwZgCEwAAAJYhMBemwq3TVV5ebn+yZYu0Y4d07LH2ToGk+Ph4paSkODtC5V27Orc5Hdkvrm9fpZ5wgv21885T+YcfNh6dFRcnnXaa9O9/K05SaoNDVEhyV7hsktL8TFspydP4sDZ+pq2S5GniG1/Spsmeb0mqllQbpLSpkhwT/tRIOhxo2jPPlFatUkp9veIdaePidPicc+z/WbGi2fVOGTdO8a+9Jk2apMPLl6vGsW3sWGn+/KM/tG3dquTdu5UwYIDUr58OHz6smpoauZOcnKyEhARJUm1traqrq92mTUpKUmJios9p6+rqVFVV5TZtYmKikpKSfE5bX1+vysrKoKRNSEhQcnKyJMkYo4qKiqCkdf7dH+GsIwJMGxcXp9TUVL/SVlRUyN1XkM1mU1paml9pKysrVe9hFGmbNm38SltVVeVxeixf0qalpTnX1KmurlZtrfu/fF/SpqamOqcFq6mp0eHD7msJX9KmpKQoPj7e57TOv/uiImnqVOmjj44mHDtWyYsWKWHyZCkvT4fr6o7WJw2+WxySJSUceV4re33pTtJZZylx1Sqpru5o2rg46ZxzpHnzpGuvdeYlSVLikUBBXW2tqiZNapZPR92WuGOHknbvlvr2Vd2xxzauI5p831JH2FFH+JfW8jpiyxal7tmjuP79pX797Gl/+aXR344k599HSpcu9r/7/HzVbNqkw7162duWF13UrC2REhen+HPPlV59VYevvFI1H37Y7Hhtund3+x5CJdza9ohMEVGOAgl4+cufoL23AURf9/NnRhJ/AmUtfc6ebjjyd9QiAAAAgibobXuDoCgpKTGSTElJidVZMcYYI3ucy+Vj/LnnGpOba4x9kkaT5iHtaMmedvVqYyST4yHt8CPHczx6eUg7qEnaQR7S9mqSdriHtDlN0o72kDatSdrxHtKqSdrLW0hb1iDtlBbS7m+Q9tYW0u5okPauFtJujIuzX7vcXDPDZvOYdnWD4z7ev7/HtCuWLXOWs2f+8AePad955x1n2nnz5nlMu2TJEmfaJUuWeEw7b948Z9p33nnHY9pnnnnGmXbFihUe0z7++OPOtKtXr/aYdsaMGc60Gzdu9Jj2rrvucqbdsWOHx7S33nqrM+3+/fs9pp0yZYozbVlZmce0l19+ufd1xPjxjdKmpaW5TTt69OhGaXNyctymHT58eKO0vXr1cpt20KBBjdIOGjTIbdpevXo1Sjt8+HC3aXNychqlHT16tNu0aWlpjdKOHz/e4+fW0OWXX+4xbVlZmTPtlClTPKbdv3+/M+2tt97qMe2OHTucae+66y6PaTdu3OhMO2PGDI9pV69e7Uz7+OOPe0y7YsUKZ9pnnnnGY9p33nnHmMJCY3JzzTwP6SSZJTpST8XHmyXHHOMx7TwdrdPeaeG4zxw5psnNNStOOcVj2scbHHf16ad7TDvjnnucn8PGFuqpuy67zJj8fGMMdURD1BF2rVZHXHedx7QbHeU9N9fMuOcej2lXf/ihs235uId0kswKx3FHjjTPuGmfhINwa9sjMkVEOdq8uVE/p9njyPdTUOXm2r97G57nyHexOXiwUV/VUQ852gs+77d4sef358/j3XeD/zmvWeP+fQMAAMBywW7bB3e17Qizbds23XDDDerZs6dSUlLUtWtXTZo0SV9//bXVWWtdX39tn8rDW3l50s03t05eRo603wlolfh4acSI4B937Fj7XZ++vLf4eKlHD89pRo3y/phnnGG/63TRIvsIDk9ef91+N2x+vnTDDZ7TZmQcfd6xo3d5AQB3srPtd4I/+qh36ceNk268Mbh5qKuz37W/Zo33+6xe7Xn70qX2EQHnnSddcEHLafv3t6ctKfHu/Pn5jUcuuVJa6t2xGh7zvffso/982cfDyC8VFvp2vIb58DDySx5GYHs8pq958TB6Ucb493m9955UVuZbPjzZts37fJSUHC2XL73k3fHz8o6um+TO3Xf71raUpE8/tX+Grvh6nQD4r39/1/2W+Hj7696MDPOljs3Pt3/nNv3ucHwXX3xx8/okL88+Vf6iRUeXGnBwTKV/1VWu9/vLX1rOk6+azjbjjZY+5+HD7e2h/Pyj/bL33/dvPT4AAACEvZidyvLTTz/V+PHjVXbkh5G2bduq9MgPWImJiVq4cKGuuOIKr48XVtOU5Oer3MN0HfGSUhr83/2kUmo2PaXbtGeeqbhVq5TaYMqPirg4GTdTItri4pR27rnO9cgqli+XsyA6pg2bOlVasUK2+vqjU1nGx6syM1P1xcXNp9Q8cq42H3/s7OhVSqp3bHMcs8EPmW0arJFX9eGHqnNzTK1YoTYNtlXFxanOzTE1dqzSliyxTys1aZKqly8/Oj2l471Jzv2cU1nm5qp6/nzVOgJfW7dK27c3moY0tapKcVdfLR2ZQvJww2NmZzfaJ/WEExpPV/XDD82O5xDwNHVuNJyekqksmaaOaeqOsnyaOh/TWl5HNJkat7a2VtXnnedyul2ddpqS/v1vJR55qcVpLyVn2jrZpyp2J/FIeq/THpkeq76uTs6/+ibfLaqvP3rc+HjVjx2ryro61+/tnHOU8PLLSr72WunI92aFdPR7wJhGUw0mSEo+8j1n6utVMXGi62k6jVH8ddcppcEPmuVujilJ8ePGKeX556Vbb5WWLz/aNnCxj7MdcSQf5WVlbqdDjLPZlHr99c6pzSokGTf5sElKc3yHG6OKiRNlGv4g22A/23XXKa3Btspx41Q/b57L96axY9Xm//7Pvu2qq1S5fPnRKbFd5MX5V5+bq6qnnlLd7be7/Yzb3Hij871VSarz8Bmn/cd/yPbaa5Ixqr7yStW6mO7RsV/aRx8dnRL73HNV+9JLzjZU0zKUOm6c4mw2KS9PNXV1R6e5djF9rC/TZ6dIR6fE9iHt4SPpm2rTGlPn+Sis2vaIWBFTjoqKWl4j2hVvpqRsqqUpHT1xTCHp6/pt7tbHbmmt2/j44E4t6e/nDAAAAMuxxlwQlJSUqF+/fiooKNDJJ5+sxYsXq1+/ftqzZ4+uvfZaffjhh0pJSdH333+vY445xqtjhlWnK5DOjiee5r0/Etxy2cmQWu6AuFo4213HZc4c6ZZbQnOuQI7p4O82T/zdDwCihad6e9Ik+13yvv4AFwnc/bjoGEHg6n23xrasLKm42Pp8hNO2cPlMwq2cN12ryZs8+rN+U5CFVdseESviypGvfYzzznNfR7kLXrUURPPEXdC+pf7v4sX2UcK+tBlGj5YSE1sniEZfDgAAIOIQmAuCP/7xj7r//vuVkpKiTZs2qVevXs5txcXF6tevnw4cOKAbb7xRL7zwglfHDKtOVyCdHU/WrJHuv791AlSeuNsv1AEvOlAAEH58vdnC3Q9w7gIdTYMKQKzyd8TJyJH2aSsdvPlb9Hc0ShCFVdseESuqy1FLfU5PAXZ3AT1/g/be5sXXNkN2Nn1AAAAASCIwFxRDhgzRhg0b9Otf/1pLlixptv3OO+/UU089pXbt2mn//v3OKbk8CbtOl6e7FyX/tjl+JKFzAgCIBMEaIX34sLRyZWSPWgK84WlEpqfZEVoKsvnzY7jFwq5tj4gU1eWopVFqnqak9fcGGk9Be39G7zVEHxcAAAAeEJgLUHFxsbKPdPb/+te/6tZbb22W5p133tGECRMkSevXr9eJJ57Y4nHDrtPl79SMnraFwY8kAAAEhS8jpP39TvV1dB7BPgSLv1Oeegq++TsleEvtxzD9MTzs2vaISFFdjgIZMecQzPokzIP9AAAAiGwE5gL05Zdf6vTTT5ckffjhhxrn+IGigfz8fA040sl47bXXNHHixGZpqqurVV1d7fx/aWmpevToEX6drlCvfQYAQLTy9XuzNW6SCXawL9LXUwunbeH0mbTG2r/eiKL2Y1QHVBAyUV+OAh2l5gn1EAAAAMJI0Nv2Jsa8+eabRpKRZDZs2GCMMebGG2806enp5pZbbjHGGFNaWupM8/TTT7s8zowZM5xpGj5KSkpC9l4AAEAEyM835t137f8Guq2w0JjcXGOko4/cXPvrody2fXt45COctoXTZxJo2YMpKSmhbY+ARX058qYeAgAAAKJAsNv2MTdi7tVXX9XVV18tSdq6dauysrKUk5Pj3H7w4EG1bdtWiYmJkqQ//vGPuu+++5odJ2JGzAEAgOjTGiPi/dkWLvkIp23hkg8EJOpHOiEkYqYcUQ8BAAAgyjGVZYCaBub69Omj//zP/9TSpUt1zTXX6Pnnn1dtbW2LgbmmSkpKlJWVpd27d0d3pwsAAACIco6b7oqLi5WZmWl1dhCh6CMCAAAA0SHYfcSEIOQporRp08b5vLKyUpK0YMECLViwoNnrkpSenu7VcQ8dOiRJ6tGjRzCyCQAAAMBihw4dIjAHv9FHBAAAAKJLsPqIMReY69y5s/P5vn37NHjw4GZp9u7d63zeqVMnr47btWtX7d69WxkZGbLZbI22OaKp3CkZebh2kYnrFpm4bpGLaxeZuG6Ri2vX+owxOnTokLp27Wp1VhDBPPURQ4k6A76izMBXlBn4ijIDX1Be4KvWKDPB7iPGXGBuwIABzuf5+fkaN25cszT5+fnO5wMHDvTquHFxcerevbvHNG3btqXyiFBcu8jEdYtMXLfIxbWLTFy3yMW1a12MlEOgvOkjhhJ1BnxFmYGvKDPwFWUGvqC8wFfBLjPB7CPGBe1IESIrK0snnHCCJGnlypUu06xYsUKS1K5dO5cj6gAAAAAAAAAAAABfxVxgTpImTpwoSVq2bJl2797daFtJSYkWLlwoSbr00ksVHx8f8vwBAAAAAAAAAAAg+sRkYO62225Thw4dVFVVpUsuuURbt26VJP3888+aOHGi9u/fr5SUFN13331BOV9ycrJmzJih5OTkoBwPocO1i0xct8jEdYtcXLvIxHWLXFw7AL6gzoCvKDPwFWUGvqLMwBeUF/gqEsqMzRhjrM6EFT755BONHz9e5eXlkuzzg5aWlsoYo8TERL388svOkXUAAAAAAAAAAABAoGJyxJwkjRo1St98842uvfZade/eXZWVlerUqZOuuOIKrVq1iqAcAAAAAAAAAAAAgipmR8wBAAAAAAAAAAAAoRSzI+YAAAAAAAAAAACAUCIwBwAAAAAAAAAAAIQAgbkWbNu2TTfccIN69uyplJQUde3aVZMmTdLXX38dVeeMRqH8HPft26enn35av/rVr9S9e3clJycrPT1dQ4YM0b333qt9+/YF/ZzRKhzK/3nnnSebzSabzab58+eH7LyRzoprZ4zRq6++qvHjx6tLly5KTk5Wt27dNHr0aM2cOVM1NTWtdu5oYcV1e+2115Sbm6sOHTooMTFR2dnZOuuss/TnP/+Za+aFdevW6dlnn9WUKVM0cOBAxcXFyWazaerUqa163nConyNZqK8bbRMgtvjSfg2kPue7IPK89dZbuv322zVq1Ch16dJFiYmJSk9P1+DBg/W73/1Ou3btcrvvgw8+6CxX7h4XXHCBx/NTZiJPIGXGgXomtgTS7qSeiT3B6KdQx8Qef/vTYV3HGLj1ySefmPT0dCPJSDJt27Z1Pk9MTDSLFy+OinNGo1B/jsnJyc7jO86XmJjo/H+7du3Mxx9/HNRzRqNwKP+vvPJKo2s5b968Vj9nNLDi2h06dMiMHTvWeR6bzWaysrJMXFyc87WCgoKgnzeahPq61dbWmiuuuKLR31hmZqax2WzO/w8bNswUFRUF9bzRJjMzs9Fn6HhMmTKl1c4ZDvVzpAv1daNtAsQOX9qvgdTnfBdEpuOPP77Z90FSUpLz/+np6eaf//yny31nzJjhvL6dOnVy+bjmmmvcnpsyE5kCKTPGUM/EokDandQzsSfQfgp1TGzytz8dznUMgTk3iouLTYcOHYwkc/LJJ5v8/HxjjDE//fSTOffcc40kk5KSYrZv3x7R54xGVnyOCQkJZvTo0ebll182+/fvN8YYc/jwYZOXl2f69u3r/PF57969QTtntAmH8l9YWGg6duxojjvuOAJzPrDq2l1wwQVGksnKyjLPPfecKS0tNcYYU1NTY7799ltz1113meLi4qCeM5pYcd3mzJnj/NuaMWOGKSkpMcYYU1lZaebMmWPi4+ONJHPLLbcE7ZzRqEOHDmb48OHmtttuMwsXLjRDhw5t1QBPONTP0SDU1422CRAbfGm/BlKf810Que644w7zl7/8xWzcuNGUl5cbY4ypr683X3/9tTnnnHOcgZY9e/Y029fxY9bo0aN9Pi9lJnIFUmaoZ2JTIO1O6pnYE0h5oY6JXf72p8O5jiEw58bMmTOdH+7OnTsbbSsqKjI5OTlGkrnxxhsj+pzRyIrP8dNPP3W77ZtvvnGO4HnwwQeDds5oEw7l//rrrzeSzIcffkhgzgdWXLtly5Y5705Zs2ZN0I4bS6y4bqNGjTKSTG5ursvt06ZNM5JMp06dgnbOaFRdXd3o/6NHj27VAE841M/RINTXjbYJEBt8ab8GUp/zXRCdSktLTUZGhpFknnjiiWbbA/kxizITnVoqM9QzsSmQdif1TOwJpLxQx8Quf/vT4VzHsMacG4sXL5YkTZgwQb169Wq0LSsrS5MnT5YkLV26VHV1dRF7zmhkxec4YsQIt9uGDBmiY489VpK0du3aoJwvGlld/j/55BO99NJLuvTSSzVu3LigHz+aWXHtnnvuOUnSjTfeqOHDhwflmLHGiuv2yy+/SJJOOOEEl9uHDBkiSSovLw/K+aJVUlJSSM9ndf0cLUJ93WibANHP1/ZrIPU53wXRKSMjQ3379pVkXz8lmCgz0amlMkM9E5usandSZiJTIOWFOiZ2hbo/LbV+mSEw50JxcbE2bNggSTr77LNdphkzZowkqbCwUBs3bozIc0ajcP0cs7KyJEk2my0k54s0Vl+3mpoa3XTTTUpJSdHs2bODeuxoZ8W1q6mpUV5eniTp6quvDvh4sciqvzlHA/v77793uf27776TJA0bNiwo50PgrK6f0XpomwCRzdf2ayD1Od8F0Wv//v3avHmzJKlbt25BOy5lJnp5KjPUM3CnNdqdlJno5a68UMcglEJRZgjMueBoZEhS//79XaZp+PqmTZsi8pzRKBw/x/LycueP0PzY7JrV123WrFnatGmTpk+f3uwOCHhmxbX74YcfVFNTo7i4OJ188sl64403dNZZZykjI0MZGRk65ZRT9OSTT6q6ujrgc0Urq/7mbrnlFknSu+++q5kzZ+rQoUOSpKqqKr344ot68cUXlZKSolmzZgXlfAic1fUzWgdtEyDy+dp+DaQ+57sguhhj9Msvv+jNN9/U2LFjVVFRoZSUFI83vH333XcaPHiwUlNTlZGRoRNPPFH33XefczaEpigz0cXbMkM9A1e8bXdSz0DyXF6oYxCIcKxjCMy5sG/fPufzzp07S5KmTZumjIwM3XrrrZKkLl26ONO4u4Dhfs5oFI6f4//+7/+qoqJCycnJmjp1aqufLxJZed02b96sWbNm6dhjj9Xdd98dtOPGCiuu3e7duyVJ2dnZeu6553TppZfqiy++UEJCgqqrq/XVV1/prrvu0tlnn82UiG5Y9Tc3YcIEzZ49WwkJCXrggQfUtm1bZWdnKy0tTbfccovGjRunzz77TGeccUZQzofAheP3KgJH2wSIbP60XwOpz/kuiA6rVq2SzWZTXFycOnfurEsuuUQbN25Ux44dtWzZMh1zzDFu9z1w4IA2b96s1NRUlZeX69tvv9WsWbM0ePBgff75583SU2aig69lhnoGrnjb7qSegeS5vFDHIBDhWMcQmHOh4Q+5qampOnjwoF588UWVlZVpzpw5KiwsVGpqqjNNWVlZRJ4zGoXb57h+/XrNnDlTkjR9+nT17NmzVc8Xqay8bjfddJOqq6v11FNPKSUlJWjHjRVWXDvHKKvKykpNnz5dubm52r59u4qKilRWVqa5c+cqKSlJq1at0vTp0wM+XzSy8m/ujjvu0D/+8Q/l5ORIsk8PYIyRJMXFxfH9FmbC7XsVgaNtAkQ+f9qvgdTnfBdEh6SkJHXq1EkdOnRwTg82cOBAvf/++zr33HNd7tO/f389/fTT2rlzp6qqqlRYWKjCwkL99a9/VUZGhg4cOKCLLrqo0Y9XEmUmWvhaZqhn0JQ37U7qGTi0VF6oY+CPcK5jCMx5oX379po8ebLS0tI0bdo0tWvXLirPGY2s/BwPHDigyy67TFVVVRo7dqzuv//+kJ070oXqur300ktauXKlzj//fF144YWtco5YE4prV19fL0mqqKhQZmamli5d6rxbMykpSddff73z7pW5c+eqoqIi6HmINqH6mystLdVFF12kCy+8UBdddJE2btyo8vJybdq0Sb/97W/1/vvva9y4cXrllVda5fwIHO2TyEbbBAgPnTt3ls1m8+nhEKz2ayD1Od8FoRdImXEYOnSo9u3bp/3796uiokIfffSR2rRpo6FDh+qee+5xtrEbuuqqq/Sb3/xGvXr1Unx8vCT72j+33nqr3nnnHdlsNh08eFBPPvmkx/xTZkLPqjLTEPVMZAlGmWnI23Yn9Uxksqq8NEQdE1mCXWa8Fc51DIE5F9q0aeN8XllZKUlasGCBysvL9fzzzzd6XZLS09Mj8pzRKFw+x0OHDun888/X9u3bNWTIEL3++uvOP340Z8V1Kygo0N13362kpCQ9/fTTAR8vVlldX1533XWN/u/gmPKgsrJSa9euDfic0caqunLatGlatmyZLr/8cs2dO1fHH3+80tLSNGDAAD355JO6/fbbVVtbq9/85jcqLS0NyjkRmHD5XkXgaJsAkS+Q9msg9TnfBdEnJSVFY8aM0WeffaaTTjpJTzzxhJ555hmfjjFq1CiNGTNGkn394IYoM9HHmzJDPQOHYLU7qWdig7flhToGwWZ1HUNgzgXHvKGSmg1jdNi7d6/zeadOnSLynNEoHD7HqqoqXXTRRfrqq6/Ut29fLV++XFlZWUE/TzSx4rrdd999Kiws1J133ql+/foFfLxYZcW1c0yBKLlfgLV3797O5z///HPA54w2Vly3HTt2aPHixZKkG264wWWam2++WZJUWFiovLy8gM+JwIXD9yoCR9sECC/ff/+9CgoKfHpIgbVfA6nP+S6wnr9lpiUpKSm6/fbbJUmPPfaYz/kaOnSoJGnnzp2NXqfMWM+KMkM9E9mCVWaC3e6knglPVpQX6pjI1lrfS4Gyso4hMOfCgAEDnM/z8/Ndpmn4+sCBAyPynNHI6s+xtrZWV1xxhVasWKEePXooLy+v0R8yXLPium3ZskWS9Oijj3ocLn3ttdfKZrM1CvTgKCuuXcMfooI1tD3WWHHdNm7c6Hzubk2rXr16OZ9v37494HMicFZ/ryJwtE2A8NOuXTvl5OT49JACa78GUp/zXWA9f8uMN7p37y7JfjNbcXGxT/ly1xanzFjPijJDPRPZglFmWqPdST0TnqwoL9Qxka01v5cCYWUdQ2DOhaysLJ1wwgmSpJUrV7pMs2LFCkn2QjV48OCIPGc0svJzrK+v1+TJk/X222+rU6dOysvLa/QjM9yj/EcuK65dp06dnD80uftybHinS7du3QI+Z7Sx4rpVVVU5n+/Zs8dlmp9++sn5PDExMeBzInDUz5GNtgkAh0Dqc74LotuuXbucz40xPu27fv16SXKu9+xAmYlu7soM9Uxsa612J/VMdPKnvFDHoDVYWccQmHNj4sSJkqRly5Zp9+7djbaVlJRo4cKFkqRLL73U4zzJDe9gbDoksrXOGeusuHaSdNNNN+m1115T+/btlZeX53aKPbgW6uv28ccfyxjj9uEwb948GWO8KgOxyoq/uYsvvliS/fpUVFQ02z5//nxJ9jmhhw0b5uU7iS2hvm7HH3+887nj2E299tprzudct9ZF+yQy0TYBYlug7ddA6nO+CyJTWVmZx+2HDx92rpPSp08fZWdnO7fV1dV53HfNmjXOqccnTJjQbDtlJjIFUmYk6plY5k+7k3omdvnbT6GOgS/Cvo4xcKm4uNh06NDBSDLDhg0zW7ZsMcYYs2fPHpObm2skmZSUFLN9+3aPx5HkfOzYsSMk54x1Vly7//f//p+RZDIzM83atWuD9VZiihXXzZvjzJs3z+9jxAorrt3u3btNamqqkWTGjx/vTF9dXW3mzp1rkpKSjCRz9913B+MtRiUrrtuoUaOMJGOz2cy9995rCgoKjDHGlJaWmqeeesqkpKQ481NfXx+U9xmNDh06ZAoKCpyPM88800gyV155ZaPXq6qq3B6D9knohfq60TYBYk9L7ddA6nO+CyLTvHnzzIknnmiefvpps3nzZmf7qqKiwqxYscL5XSTJzJkzp9G+H3/8sRk9erRZsGCB2bNnj/P1Q4cOmfnz55v27dsbSaZTp07ONl1DlJnIFEiZMYZ6Jlb52+6knolNgfRTqGNilz/96XCvYwjMebBy5UrTpk0bZ6MjMzPT2Gw2I8kkJiaa1157rcVj+BokCMY5Edpr9+OPPzrTpaammk6dOnl8wD0r/uZaOg6BOe9Yce2WLl3qDMBJMtnZ2Y3+P2bMGFNZWRmEdxe9Qn3ddu3aZfr3799on7Zt2zb6/7HHHktDuAVTpkxp9Jm5e3iqv2ifhF4orxttEyA2eVOPBFKf810QeebNm9fouyMpKcm0a9eu0Ws2m83lzWwrVqxolK5Nmzamffv2Ji4uzvlajx49PP6oSpmJPIGUGQfqmdgSSLuTeib2BKOfQh0Tm/zpT4d7HUNgrgVbt2411157renevbtJSkoynTt3NldccYXXEX1/ggSBnhN2obp2O3bs8KpicDzgmRV/c56OQ2DOe1Zcu40bN5qpU6eaHj16mKSkJNO2bVtz5plnmr/+9a+mpqYmgHcTO0J93crLy83s2bPNiBEjTHZ2tomPjzeZmZnm9NNPN4899pg5dOhQgO8o+lkRmDOG9kmgQnndaJsAscnb9msg9TnfBZFl//79Zu7cueY///M/zZAhQ0znzp1NYmKiSUtLM/379zfXXXedWbVqlct9CwoKzJ/+9Cdz7rnnmmOOOcZkZWWZ+Ph4k52dbc4880zz2GOPmeLi4hbzQJmJLIGUmYaoZ2JHIO1O6pnYE6x+CnVM7PGnPx3udYzNGB9X9wUAAAAAAAAAAADgszirMwAAAAAAAAAAAADEAgJzAAAAAAAAAAAAQAgQmAMAAAAAAAAAAABCgMAcAAAAAAAAAAAAEAIE5gAAAAAAAAAAAIAQIDAHAAAAAAAAAAAAhACBOQAAAAAAAAAAACAECMwBAAAAAAAAAAAAIUBgDgAAAAAAAAAAAAgBAnMAAAAAAAAAAABACBCYA4AoNn/+fNlsNtlsNu3cuTMk55w6dapsNpt69+4dkvNB6t27t2w2m6ZOnRqS85199tnOctXwEQ127tzpfD/z5893m67h31bDh6d9AAAAgEBY0b9zJdT9D8SuWOvrOt5vwwe/rQDRicAcAAAAAAAAAAAAEAIE5gAALn388cfOO7Q+/vhjq7ODMDR8+HBt2LDB+YglF198sfN9L1++3OrsAAAAAB7RvwO8Z1Vf94MPPnCe86KLLgrZeQGEXoLVGQAAtJ6pU6cyvQhaTZs2bTR48GCrs2GJrKwsZWVlSZLS09OtzQwAAABiQrj076ycRhMIBav6uv3793c+d/Q3AUQnRswBAAAAAAAAAAAAIUBgDgAAAAAAAAAAAAgBAnMAIKl3797O+fZbeniatqOurk7z5s1Tbm6uOnfurKSkJHXq1EkXXHCBli1b5lUeHFOTvP322xo3bpxycnKUlpamoUOH6m9/+5vHY7z55pt+5VtqvOaAzWbTOeec49x2zjnnuDymNzZs2KCrr75a3bp1U3Jysvr06aPf//73qqio8Gp/f+zcudOZx/nz5+vAgQP6zW9+o169eiklJUU9e/bUjTfe6NUULE2PJUmff/65LrvsMvXo0UMpKSnq0aOHLrzwQn3wwQcujxFIuZAkY4zmz5+vs846S5mZmWrbtq3OOuss/d///Z8vH0tYmD9/fqMyaYzRK6+8otGjR6tDhw5q06aN+vXrp+uuu075+fmN9q2pqdGyZct06623atiwYcrKylJiYqI6deqkUaNGafbs2aqsrGwxD+Xl5XrwwQd1/PHHKy0tTR06dNAll1yitWvXttbbBgAAQIg0bW9+8803uvzyy9WxY0elpaXp+OOP14wZM1ReXt7isQoLC/XAAw/opJNOUtu2bZWamqo+ffpo2rRp+uGHH7zKz/fff6+bb75ZAwcOVJs2bZSYmKjOnTtr3Lhxmj17tnbs2OF233Dp35100kku0/s6reYPP/ygadOmqU+fPkpNTVVmZqZOOukkPfDAAyosLHS7X9M+WW1trZ5++mkNHTpUGRkZyszM1LnnnqvPPvvMp/z4qmE+Wnr07t271fNAX9d6Z599tmw2mx588EH9z//8j7p27aq2bdtq4sSJKikp0d69e3XBBRcoPT1dXbp00cyZM63OMoBwYQAAplevXkaSV48dO3a4PMZPP/1kTj75ZI/7Tp482Rw+fNhjHqZMmWJmzJjh9hiPPPKI2/fxxhtv+JxvhxUrVnj9GTgerkyZMsVIMr169TL//Oc/TWpqqst9x40bZ+rr6z3myV87duxwnufRRx81PXv2dJmH9PR088knn3h9rHnz5pk///nPxmazuTzelClTmu0faLmora01l112mdt9H3744UZlJxRGjx5tJJnRo0f7vO+8efOced+yZYu58sor3b63efPmNdrXUbY8PXr37m3y8/Pdnn/fvn1mwIABLvdNTk42L7zwgtvzu9O0jAAAAMA6Ddubf/vb30xKSorLtl///v3Nvn373B5n7dq1pkOHDm7bnQkJCeall17ymJdFixaZxMREj+3XsWPHut0/HPp3xhhz4oknet3/cedvf/ubSUhIcHvuDh06mLVr17rct2F7+4UXXjDjxo1zeYzExETzr3/9y+s8+aphPlp69OrVq9XzQF83+Hzt6zrS9+vXr1n+L7vsMnPKKac0e/3VV1/16tgNf1sBEH0SBADQBx98oJqaGpfb6urqNGnSJP3www/Ou/GaOnTokM455xxt2bJFiYmJuvnmm3XBBReoXbt22rFjh1599VW9+eabevnll9WjRw/98Y9/dJuXzz//XAsWLNDVV1+tKVOmqE2bNvr3v/+tP/zhD6qoqNAjjzyia6+9Vt26dWu279ixY7Vhwwbn/9966y3df//9Xn0Gp5xySqN916xZo+uuu06S9NJLL+mUU07x6jgOhw4d0pQpUzRkyBDddddd6tWrlzZt2qQZM2Zox44dysvL0+uvv65f//rXPh3XV4888ogqKyt1++236/LLL1dSUpKWL1+uRx99VGVlZbr44ouVn5+v9u3bt3isr776Ss8++6x69uyp3/72tzr11FOVkpKirVu3asGCBc3uMg1GuXj44Ye1dOlSSdIZZ5yhu+++Wz179tQPP/ygRx55RA899JASExOD82GF2J///Ge99tprOuusszRt2jQdd9xxqqur09dff61nn322Wfra2lplZGRowoQJOvvsszVw4EBlZGSoqKhIn3zyiWbPnq2dO3cqNzdX3333nVJTU5sdY+LEidq8ebMkafLkyZo6darS09P1ySef6OGHH9Ydd9zR6u8bAAAAofGb3/xGycnJ+uMf/6gRI0aorKxMf//737VgwQLl5+fryiuv1IoVK5rtV1hYqPPPP18FBQVKSEjQ7bffrosvvlgpKSn6/PPPNXPmTBUWFur6669Xv379NGLEiGbH2L9/v2644QYdPnxYHTt21F133aXhw4crKytLBQUFWr16tZYsWeIx/+HSv1u6dGmjmSlyc3P1888/e73/p59+qhtuuEHGGLVv317333+/zjzzTFVVVenNN9/Un//8ZxUUFGj8+PH6/vvv1a5dO7fH+p//+R/9+OOPuv/++3X++eersrJSb7zxhv7617/q8OHDuu222/Tdd995nTdfdOvWrdFn2tTevXt18cUXq6KiQt27d2+VPDREXzd8bN26VY8++qjOOussPfbYY3rnnXe0dOlSJSUl6YUXXlC/fv30m9/8Rhs2bNCCBQs0adIkq7MMwGpWRwYBINxNnz7deWfTkiVLXKa57bbbjCQTHx9vPvjgA5dp/vu//9tIMklJSWbv3r3NtjcctXf77bc32/7WW285t//5z3/2Ku8N7xZt6Y7KphreYblixQqv92s4qumUU04xVVVVjbb//PPPJi0tzUgyl156qU958lbTOxmfeOKJZmmWLl3q3H7PPfd4dayEhARz2mmnmdLSUrdpGwq0XBQUFJjk5GQjyQwfPtxUV1c3296tWze/7lgNRLBGzCUkJJj/+q//cpnu8OHD5qeffmr02sqVK01JSYnbY7/zzjvOY8+fP7/Z9mXLlnn8G/vss89MXFxco7tGvcGIOQAAgPDRsL0ZHx9v/v3vfzdLc/vttzvTvPvuu82233XXXR7bdxs2bHCOxDvllFNazMfKlSvd5ve7777z672Fqn/niq+jmIYPH24kmbS0NJfv98UXX3Tm7e677262vWn/bunSpc3S3HHHHc7t3377rc/vKVCHDx82o0aNMpJMZmam2bJlS6uch75u6/J3xNyIESOcr23fvt2Z72uuucb5+iuvvGIkmY4dO3p1bEbMAdGNNeYAwIN//vOfevTRRyXZ77Z0NbqrqKjIufbbrbfeqnPPPdflsWbMmKGUlBTV1NTo9ddfd3vOpKQkPfzww81ev+CCC5SdnS1J+vrrr31+L1Z48MEHlZyc3Oi1Ll26OD+jULyPLl266Le//W2z1y+99FINGzZMkvTyyy97dSxzZD20jIwMl9sbriMQjHKxZMkSVVdXS5IeeughJSUlNdqek5Oje+65x6u8h6NjjjlGTz31lMttCQkJzUaFjho1Sm3btnV7vF/96lfq2rWrJPvI06Yc1zkpKUkPPfRQs+1nnXWWLrroIq/zDwAAgPB2ySWX6PTTT2/2+oMPPuhsWy9YsKDRNmOMs904ZMgQl+uoDR482Dn6bM2aNS7Xm9u3b5/z+dChQ93mcdCgQS2/kQj2ww8/6KuvvpIk3XDDDS7f7/XXX6/jjz9ekv16GGPcHu+UU07RpZde2uz1//zP/3Q+t6K/fN999+mTTz6RJM2bN099+/Zt9XPS1w0fxx13nPN57969nb+DNHy9T58+kuyjad3N2AQgdhCYAwA3du7cqcmTJ8sYo9NPP13/8z//4zLdv/71L+e0Hq46CA6pqanOxvmaNWvcpnNMb9JUXFycc/9ffvnF27dhmfj4eI0ZM8bltv79+0sKzfs477zz3E5/MX78eEn2KUe8WRx7zJgxzsZ0S4JRLhzBpaSkJI0dO9bl/hdeeKFX+QlHU6dODWhqkoKCAm3ZskUbN250Pjp27CjJfk2bcnyep59+ujPI3VQkf54AAABobMKECS5fb9eunU477TRJ0r///e9G27Zt2+bsp7jbX5Iuvvhi5/Mvvvii2fZevXo5n7/99tte5znaNLxhzt3nabPZnDfI/fLLL9q+fbvb47kLAjn6mI5jhNKbb76pJ554QpJ055136pJLLgnJeenrho+G06/abDbnEigNX2+4LEpxcXHI8gYgPLHGHAC4UF1drcsvv1xFRUXKycnRkiVL3DZ4169f73x+zjnneHX8/fv3u93Wo0cPt9vS0tIkSRUVFV6dx0o5OTlKSUlxuS2U72PgwIFebdu8eXOjuwBdOeOMM7w+bzDKxZYtWyQ1vuOuqV69eik1NbXRmg+RwpfP02H9+vV68skn9f777+vAgQNu0zUtWxUVFc51MDyViYZ3NAIAACCytdQX+PTTT/Xjjz+qqqrK2XfJz893pvE0mq3htob7OPzHf/yH2rdvr4MHD2ry5MlasmSJfvWrX+n000/Xcccdp/j4eH/eUsTx9/N0FyRy11929DGl0PaXt23b5hxV6VhfLFTo64aPpiP+HP9v+HrD35QYMQeAEXMA4MJvfvMbrV27VnFxcVq4cKHHYJmn4IA7nhqW7oJZDXma2iNcePM+QsHdyChJjUYmenPHWpcuXbw+bzDKRUlJiSS5HEHpYLPZPG4PZ758npI0d+5cDR8+XAsXLmzx862vr2/0f8dnKXn+PD2VFwAAAEQWb/sCDduKDZ972r/htob7OLRv316vvvqqcnJyVFdXpzfffFM33nijTjjhBGVkZOiSSy7RBx984O1biVjB+jwdwqm/XFlZqcsuu0wlJSXq0KGDFi9erISE0I2BoK8bPuLiGv/E7gi8N3y9YTC+trY2NBkDELYYMQcATSxYsEAvvPCCJOmBBx5Qbm6u1/t+9dVXbu/2aqhNmzZ+5w+to2kgxxV/g42UC9d8+Tw3bdqkW265RXV1dcrJydH999+v8ePHq2fPno0+29GjR+uTTz6JiOA1AAAAwoM3fQF//Md//Ie2b9+upUuX6qOPPtIXX3yh7du3q7KyUm+++abefPNN/elPf9L06dNb5fxoXf/1X/+lb775RnFxcVq0aFGzNbLDBX1dAAg/BOYAoIENGzbolltukWTvRP3hD39ocZ/27ds7n3fq1Endu3dvtfzBd0VFRW63NbxzsOF878EQjHLhuDvQ0x2OxpiYmJ/+73//u2praxUXF6d//etfOuGEE1ymc/dZeHvHqKfyAgAAgMjiT1+g4XNP+xcWFrrcp6mMjAxNnTrVOd3hzp07tXDhQj3++OM6dOiQ/vCHP+jyyy9Xv379PL2ViNX080xNTXWZztvPM1z87W9/07x58yRJDz30kNt10loTfV0AiFxMZQkAR5SWluqyyy5TRUWFunfvrldeeaXZdASunHjiic7nX375ZWtmMaRsNpvVWQiKH374we22TZs2OZ83XCw8GIJRLhx52rlzp6qrq12m2blzZ0TMuR+ojRs3SrJ/ru6CctXV1dq8ebPLbampqc4OY8Pr3tT3338fYE4BAAAQLrzpC3Tr1q3R+mQNA2Tfffed2/0bbvMlqNa7d2/df//9Wrx4sST7lHaffPKJ1/v7y6r+XWt/nlZYv369brvtNknS+eefr9///veW5IO+LgBELgJzAHDEddddpy1btigxMVFLlixRTk6OV/uNGTPGOXXDc88915pZDKmGU1mEcvHsYFu+fLkOHz7sctu7774ryX6Xn7vFxf0VjHIxYsQISfaFofPy8lymWbZsmX8ZjDCOOfirqqrcplmyZInbTp109PNctWqV27tLY+XzBAAAiAXvvPOOy9cLCwudAYUzzzyz0ba+ffuqY8eOkjy3Dd98803n86bH8MYZZ5zhfO7Pml2+sqp/1/Czcfd5GmP01ltvSZI6duwY9L5ZMBUXF+uyyy5TVVWVevbsqYULF1oW9KSvCwCRi8AcAEiaPXu2li5dKkl6/PHHG3WSWtK+fXvntCR5eXl67LHH3KYtKyvTo48+qh07dgSU31Do0aOH8/maNWsszElg9u7dq6effrrZ6//4xz+0du1aSdLVV18d9M5UMMrF5Zdf7uxAP/jgg6qpqWm0/cCBA3riiSeCmu9w5bhrNj8/X+vXr2+2fceOHbrnnns8HuOaa66RZO/8zZgxo9n2L774gs4fAABAFHnjjTdcjuhp2LaePHlyo202m83Zbty4caNeeumlZvtv2LDBOY3hsGHDNGjQoGZp/vWvf2nXrl0e8+YQ7BFNrljVvzv++OM1dOhQSfbpH12NmnvxxRedo78mT54ctrO3GGM0ZcoUbd++XUlJSfq///s/tWvXzrL80NcFgMjFGnMAYt7mzZv13//935Kk0047TePGjXNOm+fKgAEDlJiY2Oi1xx57THl5edq2bZvuvfdeffTRR5oyZYoGDBiguro6bd26VXl5eXr99ddVVlamCy64IOjvo7i4WD/99FOj1/bs2eN8np+fr7KyskbbBw8e7PZ4Xbt2Vf/+/ZWfn68nn3xSXbp00bnnnqsOHTo406Snpwcp962nTZs2+u///m/t2rVLv/71r5WUlKTly5dr1qxZkqTs7Gzde++9rXLuQMtF+/btdc899+jhhx/WV199pbPPPlv33HOPevbsqR9++EEPP/yw9u3bp5SUFI8jyaLB5MmT9Ze//EV1dXU677zzdN999+mUU05RfX29Vq5cqdmzZ+vw4cPq06ePtm3b5vIYv/rVrzR69GitXLlSf/nLX1RSUqKpU6cqPT1dn3zyiR5++GGlpqaqvLw8xO8OAAAArSElJUW5ubn6wx/+oJEjR6qsrEzz58/XggULJEkjR47UhAkTmu03ffp0vfzyyyooKNBNN92kjRs36pJLLlFKSoo+++wzzZw5U9XV1bLZbHryySddnnvZsmV65plnNHbsWI0fP15DhgxRVlaW9u/fr/fff19z5syRJPXs2VPnnXdes/3DpX+Xn5/fLGjiGKVVXFzcrO/csWNH54hDhyeffFJjxoxRZWWlRo8erfvvv19nnXWWqqqq9I9//EN/+ctfJEkdOnTQ9OnT3b4Hq82bN895I9+0adOUlpbm9reDpKSkVg+40tcFgAhmACDGrVixwkj6/+3dz0tUbRQA4CPGOJJRMAtrNCbpB7WYTWFRCyeCXEplezWxbeuEmAr9IxTK2gRhi6KdizCICBNBWoQUaItsJ23aBfdbROFXTo7NOKP1PDAL0XPuueMr3uPrvafs1+Li4pp5Pn78mJw8eXLd+FQqlbx79+6X+Fwul0RE0tfXV7LWQqGQRERSKBR++dzExMSGzqOcXwGTk5NJQ0PDhuL7+vqSiEhyuVzJvMVisewa/sTi4uKP/KOjo0k2m12z/p07dybT09Nl55qYmNhwLZWui69fvyaXLl0qGTc6OlrW2qmm363D9axep6V+lkq5efNmyfehubk5efLkybq1ffr0KTly5MiaOdLpdHLnzp0Nf78rXSMAAFTP6uvNsbGxJJVKrXntd/jw4WR5eblknpmZmSSTyZS8/mxsbEzGx8dLxl+7dm3dHqC1tTWZnZ1d9zzq2d997zXKfRWLxTXzjI+PJ42NjSXjMplMMjMzs2Zsudfb69VQqdV97Hqv3/XDldDrbq6N9rrfv/7nNfe97tXv6+r3u5xeuJy/rQDbl0dZAlRJNpuNV69excOHD6O3tzf2798f6XQ60ul0HDx4MHp7e2NsbCyWl5fj0KFD9S63LJcvX45nz57FxYsXI5vN/nKn4HaQzWZjdnY2rl69Gu3t7ZFKpaK9vT2uXLkSb968iUKhsOnHr2RdNDY2xqNHj+Lu3btx+vTp2LVrV7S0tMSZM2dicnIyhoeHN7X+raRYLMbTp0/j/PnzsWfPnkilUpHL5WJgYCBev34dPT096+bYu3dvzM3NRbFYjGPHjkU6nY5MJhMXLlyIly9fxrlz52pwJgAA1EJ3d3e8ePEienp6IpPJRDqdjqNHj8aNGzdibm4u9u3bVzK2s7MzFhYWYnh4OPL5fLS0tERTU1N0dHTE4OBgzM/Px9DQUMn4W7duxYMHD2JgYCCOHz8era2tsWPHjti9e3ecOnUqbt++HW/fvo0TJ05sxqmvqZ793dDQUMzPz8fg4GB0dHREU1NTtLS0RD6fj+vXr8fCwkJ0dnbWrJ6/gV4XYPtqSJIkqXcRAFBNS0tL0dHRERHfHjfy/fn3VMfZs2fj+fPnUSgUYnp6ut7l1J31BgCwddy7dy8GBgYi4tsc4gMHDtS3IKgivcfm2kq9bn9/f9y/fz9yuVwsLS3VtRag+syYAwD+yJcvX/43U+F3My3+NqtnfiwvL9e5GgAAAKqlXr3u6pmOnz9/rskxgfqwMQcA/JHZ2dnI5/M/Pv6XbsJ//Pjxj//EBgAA4O9Rr163u7s7Pnz4UJNjAfVlxhwAAAAAAADUgDvmAIANqfez9reC/v5+8xwAAAD+IvXudc2Sg3+HO+YAAAAAAACgBhqSf2kgDABb1sjISIyMjFSUY2pqKrq6uqpUEQAAANtZOp2uKL6rqyumpqYqyqHXBeBnNuYA2BJWVlZiZWWlohxtbW3R3NxcpYoAAADYzt6/f19RfHNzc7S1tVWUQ68LwM9szAEAAAAAAEANmDEHAAAAAAAANWBjDgAAAAAAAGrAxhwAAAAAAADUgI05AAAAAAAAqAEbcwAAAAAAAFADNuYAAAAAAACgBmzMAQAAAAAAQA38B5P2zj4FcayCAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(nrows=4, ncols=2, sharex=False, figsize=(18,12), gridspec_kw={'height_ratios': [10,4,10,4]})\n", + "# k=0 is energy, k=1 is azimuth, ...\n", + "make_and_plot(k=0, hist_ax=ax[0,0], residual_ax=ax[1,0], ranges = ranges, normalize_weights=0) # use gridspec\n", + "make_and_plot(k=1, hist_ax=ax[0,1], residual_ax=ax[1,1], ranges = ranges, normalize_weights=0)\n", + "make_and_plot(k=2, hist_ax=ax[2,0], residual_ax=ax[3,0], ranges = ranges, normalize_weights=0)\n", + "make_and_plot(k=3, hist_ax=ax[2,1], residual_ax=ax[3,1], ranges = ranges, normalize_weights=0)\n", + "plt.savefig(savepath + 'simple_weights_lvl3.png', format='png')\n", + "plt.savefig(savepath + 'simple_weights_lvl3.pdf', format='pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now we multiply the four sets of weights to obtain one global set of weights, that work for all four variables." + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "Weights = make_weights(RD_df[keys], MC_df[keys], keys, ranges, normalize=False)\n", + "W = [np.product(Weights[:,k]) for k in range(Weights.shape[1])]" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(nrows=4, ncols=2, sharex=False,figsize=(18,12), gridspec_kw={'height_ratios': [10,4,10,4]})\n", + "make_and_plot(k=0, hist_ax=ax[0,0], residual_ax=ax[1,0], ranges=ranges, weights=W)\n", + "make_and_plot(k=1, hist_ax=ax[0,1], residual_ax=ax[1,1], ranges=ranges, weights=W)\n", + "make_and_plot(k=2, hist_ax=ax[2,0], residual_ax=ax[3,0], ranges=ranges, weights=W)\n", + "make_and_plot(k=3, hist_ax=ax[2,1], residual_ax=ax[3,1], ranges=ranges, weights=W)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Zenith prediction has a large residual around 0.6, which dominates all other weights. Not a good result" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# A more robust method of producing multidimensional weights is to use hep_ml's reweighting algorithms." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "from hep_ml.reweight import BinsReweighter, GBReweighter" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also use BinsReweighter, but in this case it was much worse." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "from hep_ml.metrics_utils import ks_2samp_weighted\n", + "hist_settings = {'bins': n_bins, 'histtype':'step', 'density': True, 'alpha': 0.9}\n", + "\n", + "def draw_distributions(MC_data, real_data, new_original_weights, save, savename):\n", + " units = ['[log10(GeV)]', '[rad]', '[rad]', '[m]']\n", + " plt.figure(figsize=[15, 7])\n", + " for id, column in enumerate(keys, 1):\n", + " xlim = np.percentile(np.hstack([RD_df[column]]), [0.01, 99.99])\n", + " plt.subplot(2, 2, id)\n", + " plt.hist(real_data[column],range=xlim, **hist_settings, color='C01', label='RD')\n", + " plt.hist(MC_data[column], range=xlim, **hist_settings, color='C00', label='MC')\n", + " plt.hist(MC_data[column], range=xlim, **hist_settings, color='k', weights=new_original_weights, label='MC weighted')#, linestyle='--')\n", + "\n", + " plt.legend(fontsize=12, loc='upper left')\n", + " \n", + " unit = units[id-1]\n", + " plt.xlabel(column + f' {unit}')\n", + " if column=='position_z_pred' and hist_settings['density'] == True:\n", + " plt.ylim(0,0.009) # No idea why, but ylim is way to low on position_z_pred by default\n", + " print('Kolmogorov-Smirnov over {:<15} = {:<5}'.format(column, np.round(ks_2samp_weighted(MC_df[column], RD_df[column], weights1=new_original_weights, weights2=np.ones(len(RD_df), dtype=float)),4)))\n", + " plt.ylabel('Normalized count')\n", + " plt.tight_layout()\n", + " \n", + " \n", + " if save == True:\n", + " plt.savefig(savename+'.png', format='png')\n", + " plt.savefig(savename+'.pdf', format='pdf')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kolmogorov-Smirnov over energy_pred = 0.0114\n", + "Kolmogorov-Smirnov over azimuth_pred = 0.0096\n", + "Kolmogorov-Smirnov over zenith_pred = 0.011\n", + "Kolmogorov-Smirnov over position_z_pred = 0.0104\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "reweighter = GBReweighter(n_estimators=50, learning_rate=0.1, max_depth=3, min_samples_leaf=1000, \n", + " gb_args={'subsample': 0.4})\n", + "reweighter.fit(MC_df[keys], RD_df[keys])\n", + "\n", + "gb_weights = reweighter.predict_weights(MC_df[keys])\n", + "# validate reweighting rule on the test part comparing 1d projections\n", + "draw_distributions(MC_df[keys], RD_df[keys], gb_weights, save=True, savename=savepath+'GBReweighter_lvl3')" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [], + "source": [ + "def make_and_plot2(k,hist_ax, residual_ax, weights):\n", + "\n", + " MC_count, MC_bin_edges = np.histogram(MC_df[keys[k]], bins=n_bins, density=1, weights=weights)\n", + " MC_xax = (MC_bin_edges[1:] + MC_bin_edges[:-1])/2\n", + " RD_count, RD_bin_edges = np.histogram(RD_df[keys[k]], bins=n_bins, density=1)\n", + " ratio = MC_count/RD_count\n", + "# hist_ax.plot(MC_xax, MC_count, linestyle='', marker='+', label='MC_counts')\n", + "# hist_ax.plot(MC_xax, RD_count, label='RD counts')\n", + " \n", + " if k == 3:\n", + " hist_ax.set_ylim(0,0.01)\n", + " hist_ax.hist(MC_df[keys[k]], weights=weights, **hist_settings, label = 'MC')\n", + " hist_ax.hist(RD_df[keys[k]], **hist_settings, edgecolor='k', label = 'Real data')\n", + " hist_ax.legend()\n", + "\n", + " residual_ax.sharex(hist_ax)\n", + " residual_ax.set_xlabel(keys[k]), residual_ax.set_ylabel('Ratio')\n", + " residual_ax.hlines(1, min(ranges[k]), max(ranges[k]), 'k','--')\n", + " residual_ax.scatter(MC_xax, ratio, c='r', s=20)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Residuals after weighting" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(nrows=4, ncols=2, sharex=False, figsize=(18,12), gridspec_kw={'height_ratios': [10,4,10,4]})\n", + "make_and_plot2(0, ax[0,0], ax[1,0], weights = gb_weights)\n", + "make_and_plot2(1, ax[0,1], ax[1,1], weights = gb_weights)\n", + "make_and_plot2(2, ax[2,0], ax[3,0], weights = gb_weights)\n", + "make_and_plot2(3, ax[2,1], ax[3,1], weights = gb_weights)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# For saving results" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [], + "source": [ + "saved_MC_df = MC_df.copy()\n", + "saved_MC_df['weights'] = gb_weights\n", + "#saved_MC_df['index'] = saved_MC_df.index" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [], + "source": [ + "saved_MC_df['event_no'] = [int(x) for x in saved_MC_df['event_no']]" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
noise_prednoiseevent_noneutrino_predneutrinostopped_muon_predstopped_muonpidL3_oscNext_boolDeepCoreFilter_13...position_z_predposition_xposition_yposition_zzenith_predzenith_kappazenithenergy_predenergyweights
69423412.478739e-280.0837370142.997264e-060.00.9956331.013.00.01.0...-270.361816-91.304764-52.503185-285.3142400.29324199.3307190.2575382.482489274.8555911.205973
41857601.006250e-210.0508782142.160454e-030.00.9999981.013.00.01.0...-191.864853-75.437294-31.545706-209.1654211.06152599.4861601.1131802.396375285.9691160.437382
68994293.240566e-280.0834795431.203268e-030.00.9999961.013.01.01.0...-333.106750-20.526276-108.013016-335.2111211.11336899.9947431.1443322.308959207.3684540.230854
78745866.143626e-100.0949917308.101420e-050.00.9916811.013.00.01.0...-361.262848-134.8795629.768695-362.2414251.02139998.9126511.0123822.310028220.8444060.216345
4196621.556118e-330.058018136.092834e-080.00.9999821.013.00.01.0...-290.955261-93.036583-46.730343-303.9335020.22347599.6390300.2217132.473863312.3898931.036581
..................................................................
24841069.928054e-110.0291017514.353368e-050.00.9989011.013.00.01.0...-277.454041-55.605572-113.112762-361.7135310.97874699.0795290.8306552.367697245.1036990.333346
65683362.816595e-040.0786601781.496580e-020.00.9995311.013.00.01.0...-297.815033-107.530426-9.924493-296.9322201.07349899.6558301.1192162.359897220.3309780.293179
16806590.000000e+000.0200174422.619590e-030.00.9999491.013.00.01.0...-357.46826290.608025-81.541855-348.2812500.78395199.4512860.7891142.414517248.7290191.634273
51246494.799421e-040.0613771868.292994e-030.00.9999981.013.00.01.0...-254.802673-116.055222-116.044563-273.5978390.97741699.3648830.9998052.290537184.1393740.315938
64233225.640023e-240.0778681393.218264e-080.00.9995591.013.00.01.0...-276.818024206.766556-32.221523-265.8847350.20313799.6783680.2576272.496662325.7116091.278586
\n", + "

132851 rows × 41 columns

\n", + "
" + ], + "text/plain": [ + " noise_pred noise event_no neutrino_pred neutrino \\\n", + "6942341 2.478739e-28 0.0 83737014 2.997264e-06 0.0 \n", + "4185760 1.006250e-21 0.0 50878214 2.160454e-03 0.0 \n", + "6899429 3.240566e-28 0.0 83479543 1.203268e-03 0.0 \n", + "7874586 6.143626e-10 0.0 94991730 8.101420e-05 0.0 \n", + "419662 1.556118e-33 0.0 5801813 6.092834e-08 0.0 \n", + "... ... ... ... ... ... \n", + "2484106 9.928054e-11 0.0 29101751 4.353368e-05 0.0 \n", + "6568336 2.816595e-04 0.0 78660178 1.496580e-02 0.0 \n", + "1680659 0.000000e+00 0.0 20017442 2.619590e-03 0.0 \n", + "5124649 4.799421e-04 0.0 61377186 8.292994e-03 0.0 \n", + "6423322 5.640023e-24 0.0 77868139 3.218264e-08 0.0 \n", + "\n", + " stopped_muon_pred stopped_muon pid L3_oscNext_bool \\\n", + "6942341 0.995633 1.0 13.0 0.0 \n", + "4185760 0.999998 1.0 13.0 0.0 \n", + "6899429 0.999996 1.0 13.0 1.0 \n", + "7874586 0.991681 1.0 13.0 0.0 \n", + "419662 0.999982 1.0 13.0 0.0 \n", + "... ... ... ... ... \n", + "2484106 0.998901 1.0 13.0 0.0 \n", + "6568336 0.999531 1.0 13.0 0.0 \n", + "1680659 0.999949 1.0 13.0 0.0 \n", + "5124649 0.999998 1.0 13.0 0.0 \n", + "6423322 0.999559 1.0 13.0 0.0 \n", + "\n", + " DeepCoreFilter_13 ... position_z_pred position_x position_y \\\n", + "6942341 1.0 ... -270.361816 -91.304764 -52.503185 \n", + "4185760 1.0 ... -191.864853 -75.437294 -31.545706 \n", + "6899429 1.0 ... -333.106750 -20.526276 -108.013016 \n", + "7874586 1.0 ... -361.262848 -134.879562 9.768695 \n", + "419662 1.0 ... -290.955261 -93.036583 -46.730343 \n", + "... ... ... ... ... ... \n", + "2484106 1.0 ... -277.454041 -55.605572 -113.112762 \n", + "6568336 1.0 ... -297.815033 -107.530426 -9.924493 \n", + "1680659 1.0 ... -357.468262 90.608025 -81.541855 \n", + "5124649 1.0 ... -254.802673 -116.055222 -116.044563 \n", + "6423322 1.0 ... -276.818024 206.766556 -32.221523 \n", + "\n", + " position_z zenith_pred zenith_kappa zenith energy_pred \\\n", + "6942341 -285.314240 0.293241 99.330719 0.257538 2.482489 \n", + "4185760 -209.165421 1.061525 99.486160 1.113180 2.396375 \n", + "6899429 -335.211121 1.113368 99.994743 1.144332 2.308959 \n", + "7874586 -362.241425 1.021399 98.912651 1.012382 2.310028 \n", + "419662 -303.933502 0.223475 99.639030 0.221713 2.473863 \n", + "... ... ... ... ... ... \n", + "2484106 -361.713531 0.978746 99.079529 0.830655 2.367697 \n", + "6568336 -296.932220 1.073498 99.655830 1.119216 2.359897 \n", + "1680659 -348.281250 0.783951 99.451286 0.789114 2.414517 \n", + "5124649 -273.597839 0.977416 99.364883 0.999805 2.290537 \n", + "6423322 -265.884735 0.203137 99.678368 0.257627 2.496662 \n", + "\n", + " energy weights \n", + "6942341 274.855591 1.205973 \n", + "4185760 285.969116 0.437382 \n", + "6899429 207.368454 0.230854 \n", + "7874586 220.844406 0.216345 \n", + "419662 312.389893 1.036581 \n", + "... ... ... \n", + "2484106 245.103699 0.333346 \n", + "6568336 220.330978 0.293179 \n", + "1680659 248.729019 1.634273 \n", + "5124649 184.139374 0.315938 \n", + "6423322 325.711609 1.278586 \n", + "\n", + "[132851 rows x 41 columns]" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "saved_MC_df" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [], + "source": [ + "saved_MC_df.to_csv('/groups/icecube/debes/work/graphnetgit/graphnet/studies/stmuon/data/stopped_muons_final_reco_MC_weighted.csv',\n", + " index = False)" + ] + }, + { + "cell_type": "code", + "execution_count": 221, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 221, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "saved_MC_df['azimuth'].plot(kind='hist', bins=100)\n", + "saved_MC_df['azimuth'].plot(kind='hist', weights=saved_MC_df['weights'], bins=100)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "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" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "3109d55312c187a5125a75c66f4a9a4d68f1d20cdd5f63e0656670a777e3f6ff" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/cm.ipynb b/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/cm.ipynb new file mode 100644 index 0000000..69288f9 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/cm.ipynb @@ -0,0 +1,123 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "there are 10999 noise, 11090 muons, and 10911 neutrinos\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import sqlite3 as sql\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "from pandas import cut, read_sql\n", + "import pickle as pkl\n", + "from random import choices\n", + "from sklearn import metrics\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors as colors\n", + "\n", + "indir = \"/groups/icecube/petersen/GraphNetDatabaseRepository/example_results/train_classification_model/last_one_lvl3MC/dynedge_pid_example/results.csv\"\n", + "outdir = \"/groups/icecube/qgf305/workspace/analyses/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/test\"\n", + "\n", + "results = pd.read_csv(indir).sort_values('event_no').reset_index(drop = True)\n", + "\n", + "#print(results.head(10))\n", + "#Noise = 0, muon =1, Neutrino=2\n", + "pid_transform = {1:0,12:2,13:1,14:2,16:2}\n", + "\n", + "predictions = []\n", + "truth = []\n", + "\n", + "noise = 0\n", + "muons = 0\n", + "neutrinos = 0 \n", + "\n", + "number = len(results)\n", + "\n", + "for i in range(number):# range(len(results)):\n", + " noise_pred = results['pid_noise_pred'].values[i]\n", + " muon_pred = results['pid_muon_pred'].values[i]\n", + " neutrino_pred = results['pid_neutrino_pred'].values[i]\n", + " predictions.append(np.argmax([noise_pred,muon_pred,neutrino_pred]))\n", + "\n", + " truth.append(pid_transform[abs(results['pid'].values[i])])\n", + " if pid_transform[abs(results['pid'].values[i])] == 0:\n", + " noise+=1\n", + " if pid_transform[abs(results['pid'].values[i])] == 1:\n", + " muons+=1\n", + " if pid_transform[abs(results['pid'].values[i])] == 2:\n", + " neutrinos+=1\n", + "\n", + "print(f'there are {noise} noise, {muons} muons, and {neutrinos} neutrinos')\n", + "\n", + "confusion_matrix = metrics.confusion_matrix(truth, predictions)\n", + "cm_display = metrics.ConfusionMatrixDisplay(confusion_matrix = confusion_matrix, display_labels = ['Noise','Muons','Neutrinos'])\n", + "cm_display.plot()\n", + "plt.show()\n", + "plt.savefig(outdir + 'Confusion_matrix.png')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('graphnet')", + "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.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e54c104f54ca5f79eede1c2e02355cc39841da57601eff628eedcebaaa867660" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/logit.ipynb b/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/logit.ipynb new file mode 100644 index 0000000..65ed320 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/logit.ipynb @@ -0,0 +1,678 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from pandas import cut, read_sql\n", + "import pickle as pkl\n", + "from random import choices\n", + "from sklearn import metrics\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors as colors\n", + "import scipy.optimize as optimize" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "class display(object):\n", + " \"\"\"Display HTML representation of multiple objects\"\"\"\n", + " template = \"\"\"
\n", + "

{0}

{1}\n", + "
\"\"\"\n", + "\n", + " def __init__(self, *args):\n", + " self.args = args\n", + "\n", + " def _repr_html_(self):\n", + " return '\\n'.join(self.template.format(a, eval(a)._repr_html_())\n", + " for a in self.args)\n", + "\n", + " def __repr__(self):\n", + " return '\\n\\n'.join(a + '\\n' + repr(eval(a))\n", + " for a in self.args)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "indir_RD = \"/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/Inference/pid_Leon_RD_results_new_model.csv\"\n", + "indir_MC = \"/groups/icecube/peter/storage/Multiclassification/Real/last_one_lvl3MC/dynedge_pid_Real_run_21.5_mill_equal_frac_second_/results.csv\"\n", + "outdir = \"/groups/icecube/qgf305/workspace/analyses/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/test\"\n", + "\n", + "results_RD = pd.read_csv(indir_RD, index_col=[0])\n", + "results_MC = pd.read_csv(indir_MC, index_col=[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-16. -14. -12. -1. 12. 13. 14. 16.]\n" + ] + } + ], + "source": [ + "print(np.unique(results_MC.pid))\n", + "pid_transform = {1:0,12:2,13:1,14:2,16:2}" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "

results_RD

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pid_noise_predpid_muon_predpid_neutrino_predpidevent_no
09.100197e-040.9952203.870316e-03-1.00.0
11.982298e-170.9999973.332041e-06-1.01.0
22.132605e-120.9999178.263976e-05-1.02.0
32.653166e-140.9997952.045055e-04-1.03.0
49.950417e-010.0003084.650586e-03-1.04.0
..................
14207049.957962e-010.0006213.582841e-03-1.096917756.0
14207052.507694e-171.0000004.941842e-07-1.096917757.0
14207061.000000e+000.0000000.000000e+00-1.096917758.0
14207079.853759e-010.0011281.349629e-02-1.096917759.0
14207089.903507e-010.0004779.172585e-03-1.096917760.0
\n", + "

1420709 rows × 5 columns

\n", + "
\n", + "
\n", + "
\n", + "

results_MC

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pid_noise_predpid_muon_predpid_neutrino_predpidevent_no
01.000000e+000.0000000.000000-1.023434375.0
11.857092e-180.9996210.00037913.070953235.0
22.644923e-140.9959310.00406913.097961265.0
38.509830e-020.0127910.90211012.033636682.0
44.873881e-040.0020450.99746812.053035643.0
..................
74249951.000000e+000.0000000.000000-1.066993636.0
74249962.241822e-120.9989570.00104313.058567439.0
74249973.683385e-020.0001570.96300916.081515634.0
74249987.042371e-040.0655150.93378016.0221130.0
74249993.246351e-070.2523720.74762713.092196571.0
\n", + "

7425000 rows × 5 columns

\n", + "
\n", + "
" + ], + "text/plain": [ + "results_RD\n", + " pid_noise_pred pid_muon_pred pid_neutrino_pred pid event_no\n", + "0 9.100197e-04 0.995220 3.870316e-03 -1.0 0.0\n", + "1 1.982298e-17 0.999997 3.332041e-06 -1.0 1.0\n", + "2 2.132605e-12 0.999917 8.263976e-05 -1.0 2.0\n", + "3 2.653166e-14 0.999795 2.045055e-04 -1.0 3.0\n", + "4 9.950417e-01 0.000308 4.650586e-03 -1.0 4.0\n", + "... ... ... ... ... ...\n", + "1420704 9.957962e-01 0.000621 3.582841e-03 -1.0 96917756.0\n", + "1420705 2.507694e-17 1.000000 4.941842e-07 -1.0 96917757.0\n", + "1420706 1.000000e+00 0.000000 0.000000e+00 -1.0 96917758.0\n", + "1420707 9.853759e-01 0.001128 1.349629e-02 -1.0 96917759.0\n", + "1420708 9.903507e-01 0.000477 9.172585e-03 -1.0 96917760.0\n", + "\n", + "[1420709 rows x 5 columns]\n", + "\n", + "results_MC\n", + " pid_noise_pred pid_muon_pred pid_neutrino_pred pid event_no\n", + "0 1.000000e+00 0.000000 0.000000 -1.0 23434375.0\n", + "1 1.857092e-18 0.999621 0.000379 13.0 70953235.0\n", + "2 2.644923e-14 0.995931 0.004069 13.0 97961265.0\n", + "3 8.509830e-02 0.012791 0.902110 12.0 33636682.0\n", + "4 4.873881e-04 0.002045 0.997468 12.0 53035643.0\n", + "... ... ... ... ... ...\n", + "7424995 1.000000e+00 0.000000 0.000000 -1.0 66993636.0\n", + "7424996 2.241822e-12 0.998957 0.001043 13.0 58567439.0\n", + "7424997 3.683385e-02 0.000157 0.963009 16.0 81515634.0\n", + "7424998 7.042371e-04 0.065515 0.933780 16.0 221130.0\n", + "7424999 3.246351e-07 0.252372 0.747627 13.0 92196571.0\n", + "\n", + "[7425000 rows x 5 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "display(\"results_RD\", \"results_MC\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "truth_MC = []\n", + "\n", + "for i in range(len(results_MC)):# range(len(results)):\n", + " truth_MC.append(pid_transform[abs(results_MC['pid'].values[i])])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def to_logit(p):\n", + " try:\n", + " logit = np.log(p/(1-p))\n", + " except ZeroDivisionError:\n", + " logit = 0\n", + " if np.isinf(logit):\n", + " logit = 0\n", + " return logit" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "logits = dict()\n", + "for item in [\"noise\", \"muon\", \"neutrino\"]:\n", + " logits[item] = results_MC[f\"pid_{item}_pred\"].apply(to_logit)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "logits = pd.DataFrame.from_dict(logits)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fix, ax = plt.subplots(figsize=[10, 5])\n", + "for item in [\"noise\", \"muon\", \"neutrino\"]:\n", + " ax.hist(logits[item], bins=50, alpha=0.33, label=item);\n", + "ax.set(yscale=\"log\")\n", + "ax.legend();" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fix, ax = plt.subplots(figsize=[10, 5])\n", + "for item in [\"noise\", \"muon\", \"neutrino\"]:\n", + " ax.hist(logits[item], bins=50, alpha=0.33, label=item, cumulative=True, histtype='step', density=True);\n", + "ax.set(yscale=\"log\")\n", + "ax.legend(loc=\"upper left\");" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "

metrics

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
stdmean
noise16.360558-16.625953
muon8.815463-2.003995
neutrino7.530003-1.146454
\n", + "
\n", + "
" + ], + "text/plain": [ + "metrics\n", + " std mean\n", + "noise 16.360558 -16.625953\n", + "muon 8.815463 -2.003995\n", + "neutrino 7.530003 -1.146454" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "stds = dict()\n", + "means = dict()\n", + "for item in [\"noise\", \"muon\", \"neutrino\"]:\n", + " stds[item] = logits[item].std()\n", + " means[item] = logits[item].mean()\n", + "\n", + "stds = pd.DataFrame.from_dict(stds, orient='index', columns=['std'])\n", + "means = pd.DataFrame.from_dict(means, 'index', columns=['mean'])\n", + "\n", + "metrics = pd.concat([stds,means],axis=1)\n", + "display(\"metrics\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fix, ax = plt.subplots(figsize=[10, 5])\n", + "for i, item in enumerate([\"noise\", \"muon\", \"neutrino\"]):\n", + " ax.hist(logits[item]-metrics[\"mean\"][i], bins=50, alpha=0.33, label=item);\n", + "ax.set(yscale=\"log\")\n", + "ax.legend();" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "def inverse_logit(p):\n", + " try:\n", + " logit = np.log(1/(1+np.exp(-p)))\n", + " except ZeroDivisionError:\n", + " logit = 0\n", + " if np.isinf(logit):\n", + " logit = 0\n", + " return logit" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [], + "source": [ + "logits2 = dict()\n", + "for item in [\"noise\", \"muon\", \"neutrino\"]:\n", + " logits2[item] = results_MC[f\"pid_{item}_pred\"].apply(inverse_logit)" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fix, ax = plt.subplots(figsize=[10, 5])\n", + "for i, item in enumerate([\"noise\", \"muon\", \"neutrino\"]):\n", + " ax.hist(logits2[item], bins=50, alpha=0.33, label=item);\n", + "ax.set(yscale=\"log\")\n", + "ax.legend();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def to_multivariate_logit(p1,p2):\n", + " \"\"\"bivariate logit with common metrics\"\"\"\n", + " try:\n", + " sigma =\n", + " rho =\n", + " mu = \n", + " p1_logit = to_logit(p1)\n", + " p2_logit = to_logit(p2)\n", + " Q = (sigma**2 * (1-rho**2))**(-1) * ( (p1_logit-mu)**2 + (p2_logit-mu)**2 - 2*rho * (p1_logit-mu)*(p2_logit-mu))\n", + " sub = (sigma**2 * np.sqrt(1-rho) * p1 * p2 * (1-p1)*(1-p2))\n", + " upper = np.exp(-Q*0.5)\n", + " logit = upper/sub\n", + " except ZeroDivisionError:\n", + " logit = 0\n", + " if np.isinf(logit):\n", + " logit = 0\n", + " return logit" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('graphnet')", + "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.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e54c104f54ca5f79eede1c2e02355cc39841da57601eff628eedcebaaa867660" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/logit_individual.ipynb b/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/logit_individual.ipynb new file mode 100644 index 0000000..696abd0 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/logit_individual.ipynb @@ -0,0 +1,904 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/groups/icecube/qgf305/anaconda3/envs/graphnet/lib/python3.8/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from sklearn import metrics\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "from sympy import Symbol, exp, log" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "class display(object):\n", + " \"\"\"Display HTML representation of multiple objects\"\"\"\n", + " template = \"\"\"
\n", + "

{0}

{1}\n", + "
\"\"\"\n", + "\n", + " def __init__(self, *args):\n", + " self.args = args\n", + "\n", + " def _repr_html_(self):\n", + " return '\\n'.join(self.template.format(a, eval(a)._repr_html_())\n", + " for a in self.args)\n", + "\n", + " def __repr__(self):\n", + " return '\\n\\n'.join(a + '\\n' + repr(eval(a))\n", + " for a in self.args)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "indir_RD = \"/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/Inference/pid_Leon_RD_results_new_model.csv\"\n", + "indir_MC = \"/groups/icecube/peter/storage/Multiclassification/Real/last_one_lvl3MC/dynedge_pid_Real_run_21.5_mill_equal_frac_second_/results.csv\"\n", + "outdir = \"/groups/icecube/qgf305/workspace/analyses/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/test\"\n", + "\n", + "results_RD = pd.read_csv(indir_RD, index_col=[0])\n", + "results_MC = pd.read_csv(indir_MC, index_col=[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "

results_RD

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pid_noise_predpid_muon_predpid_neutrino_predpidevent_no
09.100197e-040.9952203.870316e-03-1.00.0
11.982298e-170.9999973.332041e-06-1.01.0
22.132605e-120.9999178.263976e-05-1.02.0
32.653166e-140.9997952.045055e-04-1.03.0
49.950417e-010.0003084.650586e-03-1.04.0
..................
14207049.957962e-010.0006213.582841e-03-1.096917756.0
14207052.507694e-171.0000004.941842e-07-1.096917757.0
14207061.000000e+000.0000000.000000e+00-1.096917758.0
14207079.853759e-010.0011281.349629e-02-1.096917759.0
14207089.903507e-010.0004779.172585e-03-1.096917760.0
\n", + "

1420709 rows × 5 columns

\n", + "
\n", + "
\n", + "
\n", + "

results_MC

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pid_noise_predpid_muon_predpid_neutrino_predpidevent_no
01.000000e+000.0000000.000000-1.023434375.0
11.857092e-180.9996210.00037913.070953235.0
22.644923e-140.9959310.00406913.097961265.0
38.509830e-020.0127910.90211012.033636682.0
44.873881e-040.0020450.99746812.053035643.0
..................
74249951.000000e+000.0000000.000000-1.066993636.0
74249962.241822e-120.9989570.00104313.058567439.0
74249973.683385e-020.0001570.96300916.081515634.0
74249987.042371e-040.0655150.93378016.0221130.0
74249993.246351e-070.2523720.74762713.092196571.0
\n", + "

7425000 rows × 5 columns

\n", + "
\n", + "
" + ], + "text/plain": [ + "results_RD\n", + " pid_noise_pred pid_muon_pred pid_neutrino_pred pid event_no\n", + "0 9.100197e-04 0.995220 3.870316e-03 -1.0 0.0\n", + "1 1.982298e-17 0.999997 3.332041e-06 -1.0 1.0\n", + "2 2.132605e-12 0.999917 8.263976e-05 -1.0 2.0\n", + "3 2.653166e-14 0.999795 2.045055e-04 -1.0 3.0\n", + "4 9.950417e-01 0.000308 4.650586e-03 -1.0 4.0\n", + "... ... ... ... ... ...\n", + "1420704 9.957962e-01 0.000621 3.582841e-03 -1.0 96917756.0\n", + "1420705 2.507694e-17 1.000000 4.941842e-07 -1.0 96917757.0\n", + "1420706 1.000000e+00 0.000000 0.000000e+00 -1.0 96917758.0\n", + "1420707 9.853759e-01 0.001128 1.349629e-02 -1.0 96917759.0\n", + "1420708 9.903507e-01 0.000477 9.172585e-03 -1.0 96917760.0\n", + "\n", + "[1420709 rows x 5 columns]\n", + "\n", + "results_MC\n", + " pid_noise_pred pid_muon_pred pid_neutrino_pred pid event_no\n", + "0 1.000000e+00 0.000000 0.000000 -1.0 23434375.0\n", + "1 1.857092e-18 0.999621 0.000379 13.0 70953235.0\n", + "2 2.644923e-14 0.995931 0.004069 13.0 97961265.0\n", + "3 8.509830e-02 0.012791 0.902110 12.0 33636682.0\n", + "4 4.873881e-04 0.002045 0.997468 12.0 53035643.0\n", + "... ... ... ... ... ...\n", + "7424995 1.000000e+00 0.000000 0.000000 -1.0 66993636.0\n", + "7424996 2.241822e-12 0.998957 0.001043 13.0 58567439.0\n", + "7424997 3.683385e-02 0.000157 0.963009 16.0 81515634.0\n", + "7424998 7.042371e-04 0.065515 0.933780 16.0 221130.0\n", + "7424999 3.246351e-07 0.252372 0.747627 13.0 92196571.0\n", + "\n", + "[7425000 rows x 5 columns]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "display(\"results_RD\", \"results_MC\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "unique pids before transform: [-16. -14. -12. -1. 12. 13. 14. 16.]\n", + "length: 7425000\n" + ] + }, + { + "data": { + "text/plain": [ + "tensor([0, 1, 1, ..., 2, 2, 1])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(\"unique pids before transform: \", np.unique(results_MC.pid))\n", + "class_options = {1: 0, -1: 0, 13: 1, -13: 1, 12: 2, -12: 2, 14: 2, -14: 2, 16: 2, -16: 2}\n", + "pid_transform = torch.tensor([class_options[int(value)] for value in results_MC[\"pid\"]])\n", + "print(\"length: \", len(pid_transform))\n", + "pid_transform" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def logit_transform(p, eps=1e-6, inverse=False):\n", + " if np.isnan(p):\n", + " return\n", + " p = p*(1-2*eps)+eps\n", + " try:\n", + " if inverse:\n", + " transform = np.exp(p) / (1 + np.exp(p))\n", + " else:\n", + " transform = np.log(p)- np.log(1 -p)\n", + " except ZeroDivisionError as e:\n", + " print(e)\n", + "\n", + " return transform" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "keys = [\"noise\", \"muon\", \"neutrino\"]\n", + "noise_logits, muon_logits, neutrino_logits = dict(), dict(), dict()\n", + "mask = dict()\n", + "# loop over dataset\n", + "for key in keys:\n", + " # loop over noise/particle type\n", + " for class_type, item in enumerate(keys):\n", + " mask[item] = results_MC[f'pid_{key}_pred'].where(pid_transform == class_type)\n", + " # applies function elementwise and writes to item in loop e.g. \"noise_logits\"\n", + " locals()[f\"{key}_logits\"][item] = pd.Series(mask[item]).apply(logit_transform)\n", + " locals()[f\"{key}_logits\"][\"RD\"] = pd.Series(results_RD[f'pid_{key}_pred']).apply(logit_transform)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "noise prediction for noise logit: 13.81550955804604 -11.841907165403866\n", + "noise prediction for muon logit: 7.218115617865962 -13.815509557963773\n", + "noise prediction for neutrino logit: 7.9910569495195425 -13.815509557963773\n", + "muon prediction for noise logit: 5.42103538966023 -13.815509557963773\n", + "muon prediction for muon logit: 13.81550955804604 -13.384398334470275\n", + "muon prediction for neutrino logit: 13.81550955804604 -13.815509557963773\n", + "neutrino prediction for noise logit: 10.411387004006823 -13.815509557963773\n", + "neutrino prediction for muon logit: 13.34798010763727 -13.81550947680503\n", + "neutrino prediction for neutrino logit: 13.81550955804604 -13.8032699023568\n" + ] + } + ], + "source": [ + "for key in keys:\n", + " # loop over noise/particle type\n", + " for class_type, item in enumerate(keys):\n", + " print(f\"{key} prediction for {item} logit: \",eval(f\"{key}_logits\")[item].max(), eval(f\"{key}_logits\")[item].min())" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "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": [ + "\n", + "# loop over dataset\n", + "bin_value, bins = dict(), dict() \n", + "for key in keys:\n", + " fig, ax = plt.subplots(figsize=[10, 5])\n", + " # loop over noise/particle type\n", + " for class_type, item in enumerate(keys):\n", + " bin_value[item], bins[item], _ = ax.hist(eval(f\"{key}_logits\")[item], bins=100, alpha=0.33, label=item);\n", + " ax.set_title(f\"{key} predictions\")\n", + " ax.set_xlabel(\"logits\")\n", + " ax.set_ylabel(\"counts\")\n", + " ax.hist(eval(f\"{key}_logits\")[\"RD\"], bins=100, alpha=0.33, label=\"RD\")\n", + " ax.set(yscale=\"log\")\n", + " ax.legend();" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "

metrics_noise

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
stdmeandiff_realdata_mean
noise4.7000889.25610315.525815
muon0.960504-13.686823-7.417112
neutrino3.409984-12.222320-5.952608
RD9.098534-6.2697110.000000
\n", + "
\n", + "
\n", + "
\n", + "

metrics_muon

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
stdmeandiff_realdata_mean
noise3.319189-10.619669-11.644853
muon3.1339498.0895047.064320
neutrino3.883315-9.229240-10.254424
RD7.6514401.0251840.000000
\n", + "
\n", + "
\n", + "
\n", + "

metrics_neutrino

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
stdmeandiff_realdata_mean
noise4.639304-9.323438-3.362916
muon3.104028-8.100537-2.140015
neutrino4.2749578.73041514.690937
RD3.417944-5.9605220.000000
\n", + "
\n", + "
" + ], + "text/plain": [ + "metrics_noise\n", + " std mean diff_realdata_mean\n", + "noise 4.700088 9.256103 15.525815\n", + "muon 0.960504 -13.686823 -7.417112\n", + "neutrino 3.409984 -12.222320 -5.952608\n", + "RD 9.098534 -6.269711 0.000000\n", + "\n", + "metrics_muon\n", + " std mean diff_realdata_mean\n", + "noise 3.319189 -10.619669 -11.644853\n", + "muon 3.133949 8.089504 7.064320\n", + "neutrino 3.883315 -9.229240 -10.254424\n", + "RD 7.651440 1.025184 0.000000\n", + "\n", + "metrics_neutrino\n", + " std mean diff_realdata_mean\n", + "noise 4.639304 -9.323438 -3.362916\n", + "muon 3.104028 -8.100537 -2.140015\n", + "neutrino 4.274957 8.730415 14.690937\n", + "RD 3.417944 -5.960522 0.000000" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "for key in keys:\n", + " # preallocations of temporary variables\n", + " stds, means, means_realdata_diff = dict(), dict(), dict()\n", + "\n", + " # loop over noise/particle type and real data\n", + " for class_type, item in enumerate(keys + [\"RD\"]):\n", + " # take pandas standard deviation and mean and write into preallocated variable\n", + " stds[item] = eval(key+\"_logits\")[item].std()\n", + " means[item] = eval(key+\"_logits\")[item].mean()\n", + " means_realdata_diff[item] = eval(key+\"_logits\")[item].mean() - eval(key+\"_logits\")[\"RD\"].mean()\n", + "\n", + " # convert back into dataframe\n", + " stds = pd.DataFrame.from_dict(stds, orient='index', columns=['std'])\n", + " means = pd.DataFrame.from_dict(means, orient='index', columns=['mean'])\n", + " means_realdata_diff = pd.DataFrame.from_dict(means_realdata_diff, orient='index', columns=['diff_realdata_mean'])\n", + "\n", + " # concatenate into metrics variable\n", + " locals()[\"metrics_\"+key] = pd.concat([stds,means, means_realdata_diff],axis=1)\n", + "\n", + " # delete temporary variables\n", + " del stds, means, means_realdata_diff\n", + "\n", + "display(\"metrics_noise\", \"metrics_muon\", \"metrics_neutrino\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "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": [ + "# loop over dataset\n", + "bin_value, bins = dict(), dict() \n", + "for key in keys:\n", + " fig, ax = plt.subplots(figsize=[10, 5])\n", + " # loop over noise/particle type\n", + " for class_type, item in enumerate(keys):\n", + " bin_value[item], bins[item], _ = ax.hist(eval(f\"{key}_logits\")[item]-eval(f\"metrics_{key}\")[\"diff_realdata_mean\"][item], bins=100, alpha=0.33, label=item);\n", + " ax.set_title(f\"{key} predictions\")\n", + " ax.set_xlabel(\"logits\")\n", + " ax.set_ylabel(\"counts\")\n", + " ax.hist(eval(f\"{key}_logits\")[\"RD\"], bins=100, alpha=0.33, label=\"RD\")\n", + " ax.set(yscale=\"log\")\n", + " ax.legend();" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "keys = [\"noise\", \"muon\", \"neutrino\"]\n", + "noise_probability, muon_probability, neutrino_probability = dict(), dict(), dict()\n", + "mask = dict()\n", + "# loop over dataset\n", + "for key in keys:\n", + " # loop over noise/particle type\n", + " for class_type, item in enumerate(keys):\n", + " mask[item] = eval(f\"{key}_logits\")[item]-eval(f\"metrics_{key}\")[\"diff_realdata_mean\"][item]\n", + " # applies function elementwise and writes to item in loop e.g. \"noise_logits\"\n", + " locals()[f\"{key}_probability\"][item] = pd.Series(mask[item]).apply(lambda x: logit_transform(x,inverse=True))\n", + " locals()[f\"{key}_probability\"][\"RD\"] = pd.Series(results_RD[f'pid_{key}_pred']).apply(lambda x: logit_transform(x,inverse=True))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "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": [ + "# loop over dataset\n", + "for key in keys:\n", + " fig, ax = plt.subplots(figsize=[10, 5])\n", + " # loop over noise/particle type\n", + " for class_type, item in enumerate(keys):\n", + " ax.hist(eval(f\"{key}_probability\")[item], bins=100, alpha=0.33, label=item);\n", + " ax.set_title(f\"{key} predictions\")\n", + " ax.set_xlabel(\"probability\")\n", + " ax.set_ylabel(\"counts\")\n", + " ax.hist(results_RD[f'pid_{key}_pred'], bins=100, alpha=0.33, label=\"RD\")\n", + " ax.set(yscale=\"log\")\n", + " ax.legend();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "def to_multivariate_logit(p1,p2):\n", + " \"\"\"bivariate logit with common metrics\"\"\"\n", + " try:\n", + " sigma =\n", + " rho =\n", + " mu = \n", + " p1_logit = to_logit(p1)\n", + " p2_logit = to_logit(p2)\n", + " Q = (sigma**2 * (1-rho**2))**(-1) * ( (p1_logit-mu)**2 + (p2_logit-mu)**2 - 2*rho * (p1_logit-mu)*(p2_logit-mu))\n", + " sub = (sigma**2 * np.sqrt(1-rho) * p1 * p2 * (1-p1)*(1-p2))\n", + " upper = np.exp(-Q*0.5)\n", + " logit = upper/sub\n", + " except ZeroDivisionError:\n", + " logit = 0\n", + " if np.isinf(logit):\n", + " logit = 0\n", + " return logit" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('graphnet')", + "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.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e54c104f54ca5f79eede1c2e02355cc39841da57601eff628eedcebaaa867660" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/plot_roc.ipynb b/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/plot_roc.ipynb new file mode 100644 index 0000000..8965fd9 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/plot_roc.ipynb @@ -0,0 +1,521 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/groups/icecube/qgf305/anaconda3/envs/graphnet/lib/python3.8/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors as colors\n", + "from numpy import interp\n", + "import torch\n", + "\n", + "from sklearn.metrics import roc_curve, auc, roc_auc_score" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "class display(object):\n", + " \"\"\"Display HTML representation of multiple objects\"\"\"\n", + " template = \"\"\"
\n", + "

{0}

{1}\n", + "
\"\"\"\n", + "\n", + " def __init__(self, *args):\n", + " self.args = args\n", + "\n", + " def _repr_html_(self):\n", + " return '\\n'.join(self.template.format(a, eval(a)._repr_html_())\n", + " for a in self.args)\n", + "\n", + " def __repr__(self):\n", + " return '\\n\\n'.join(a + '\\n' + repr(eval(a))\n", + " for a in self.args)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "indir = \"/groups/icecube/peter/storage/Multiclassification/Real/last_one_lvl3MC/dynedge_pid_Real_run_21.5_mill_equal_frac_second_/results.csv\"\n", + "indir = \"/groups/icecube/petersen/GraphNetDatabaseRepository/example_results/train_classification_model/last_one_lvl3MC/dynedge_pid_example/results.csv\"\n", + "results = pd.read_csv(indir, index_col=[0]).sort_values('event_no').reset_index()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Examine raw data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-16. -14. -12. -1. 12. 13. 14. 16.]\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "

results

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
indexpid_noise_predpid_muon_predpid_neutrino_predpidevent_no
0189919.876266e-010.0009430.011431-1.03623.0
1116459.642183e-010.0058380.029943-1.04338.0
2100519.860364e-010.0001260.013838-1.04804.0
357351.000000e+000.0000000.000000-1.010614.0
4107459.867063e-010.0004530.012840-1.010686.0
.....................
3299549339.818321e-220.9999980.00000213.098594389.0
32996223922.866203e-070.9918530.00814713.098596055.0
32997134331.000000e+000.0000000.000000-1.098602635.0
3299861351.000000e+000.0000000.000000-1.098608605.0
32999259311.000000e+000.0000000.000000-1.098609577.0
\n", + "

33000 rows × 6 columns

\n", + "
\n", + "
" + ], + "text/plain": [ + "results\n", + " index pid_noise_pred pid_muon_pred pid_neutrino_pred pid \\\n", + "0 18991 9.876266e-01 0.000943 0.011431 -1.0 \n", + "1 11645 9.642183e-01 0.005838 0.029943 -1.0 \n", + "2 10051 9.860364e-01 0.000126 0.013838 -1.0 \n", + "3 5735 1.000000e+00 0.000000 0.000000 -1.0 \n", + "4 10745 9.867063e-01 0.000453 0.012840 -1.0 \n", + "... ... ... ... ... ... \n", + "32995 4933 9.818321e-22 0.999998 0.000002 13.0 \n", + "32996 22392 2.866203e-07 0.991853 0.008147 13.0 \n", + "32997 13433 1.000000e+00 0.000000 0.000000 -1.0 \n", + "32998 6135 1.000000e+00 0.000000 0.000000 -1.0 \n", + "32999 25931 1.000000e+00 0.000000 0.000000 -1.0 \n", + "\n", + " event_no \n", + "0 3623.0 \n", + "1 4338.0 \n", + "2 4804.0 \n", + "3 10614.0 \n", + "4 10686.0 \n", + "... ... \n", + "32995 98594389.0 \n", + "32996 98596055.0 \n", + "32997 98602635.0 \n", + "32998 98608605.0 \n", + "32999 98609577.0 \n", + "\n", + "[33000 rows x 6 columns]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(np.unique(results[\"pid\"]))\n", + "display(\"results\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "class_options = {1: 0, -1: 0, 13: 1, -13: 1, 12: 2, -12: 2, 14: 2, -14: 2, 16: 2, -16: 2,}\n", + "pid_transform = torch.tensor([class_options[int(value)] for value in results[\"pid\"]])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "same shape: True torch.Size([33000, 3])\n" + ] + } + ], + "source": [ + "y_test = torch.nn.functional.one_hot(pid_transform)\n", + "y_prob = results[[\"pid_noise_pred\",\"pid_muon_pred\",\"pid_neutrino_pred\"]]\n", + "print(\"same shape: \", y_test.shape == y_prob.shape, y_test.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "examine data post transformation" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "nb_classes = y_test.shape[1]\n", + "fpr = dict()\n", + "tpr = dict()\n", + "roc_auc = dict()\n", + "for i in range(nb_classes):\n", + " fpr[i], tpr[i], _ = roc_curve(y_test[:, i], y_prob.iloc[:, i], pos_label=1)\n", + " roc_auc[i] = auc(fpr[i], tpr[i])\n", + "\n", + "# Compute micro-average ROC curve and ROC area\n", + "fpr[\"micro\"], tpr[\"micro\"], _ = roc_curve(y_test.ravel(), y_prob.values.ravel())\n", + "roc_auc[\"micro\"] = auc(fpr[\"micro\"], tpr[\"micro\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot of a ROC curve for a specific class\n", + "test = 2\n", + "plt.figure()\n", + "plt.plot(fpr[test], tpr[test], label='ROC curve (area = %0.2f)' % roc_auc[test])\n", + "plt.plot([0, 1], [0, 1], 'k--')\n", + "plt.xlim([0.0, 1.0])\n", + "plt.ylim([0.0, 1.05])\n", + "plt.xlabel('False Positive Rate')\n", + "plt.ylabel('True Positive Rate')\n", + "plt.title('Receiver operating characteristic example')\n", + "plt.legend(loc=\"lower right\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# First aggregate all false positive rates\n", + "all_fpr = np.unique(np.concatenate([fpr[i] for i in range(nb_classes)]))\n", + "\n", + "# Then interpolate all ROC curves at this points\n", + "mean_tpr = np.zeros_like(all_fpr)\n", + "for i in range(nb_classes):\n", + " mean_tpr += interp(all_fpr, fpr[i], tpr[i])\n", + "\n", + "# Finally average it and compute AUC\n", + "mean_tpr /= nb_classes\n", + "\n", + "fpr[\"macro\"] = all_fpr\n", + "tpr[\"macro\"] = mean_tpr\n", + "roc_auc[\"macro\"] = auc(fpr[\"macro\"], tpr[\"macro\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "macro_roc_auc_ovo = roc_auc_score(y_test, y_prob, multi_class=\"ovo\", average=\"macro\")\n", + "weighted_roc_auc_ovo = roc_auc_score(\n", + " y_test, y_prob, multi_class=\"ovo\", average=\"weighted\"\n", + ")\n", + "macro_roc_auc_ovr = roc_auc_score(y_test, y_prob, multi_class=\"ovr\", average=\"macro\")\n", + "weighted_roc_auc_ovr = roc_auc_score(\n", + " y_test, y_prob, multi_class=\"ovr\", average=\"weighted\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "np.intersect1d()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot all ROC curves\n", + "fig, ax = plt.subplots(figsize=[20, 10])\n", + "# inset axes\n", + "axins = ax.inset_axes([0.56, 0.03, 0.42, 0.42])\n", + "\n", + "ax.plot(\n", + " fpr[\"micro\"], tpr[\"micro\"],\n", + " color=\"tab:olive\", linestyle='dashdot',\n", + " label='micro-average ROC curve (area = {0:0.4f})'\n", + " ''.format(roc_auc[\"micro\"]),\n", + " linewidth=2)\n", + "\n", + "axins.plot(\n", + " fpr[\"micro\"], tpr[\"micro\"],\n", + " color=\"tab:olive\", linestyle='dashdot',\n", + " label='micro-average ROC curve (area = {0:0.4f})'\n", + " ''.format(roc_auc[\"micro\"]),\n", + " linewidth=2)\n", + "\n", + "ax.plot(\n", + " fpr[\"macro\"], tpr[\"macro\"],\n", + " color=\"tab:purple\", linestyle='dashdot',\n", + " label='macro-average ROC curve (area = {0:0.4f})'\n", + " ''.format(roc_auc[\"macro\"]),\n", + " linewidth=2)\n", + "\n", + "axins.plot(\n", + " fpr[\"macro\"], tpr[\"macro\"],\n", + " color=\"tab:purple\", linestyle='dashdot',\n", + " label='macro-average ROC curve (area = {0:0.4f})'\n", + " ''.format(roc_auc[\"macro\"]),\n", + " linewidth=2)\n", + "\n", + "\n", + "colors=[\"tab:blue\",\"tab:green\",\"tab:orange\"]\n", + "\n", + "\n", + "for i, item in enumerate([\"noise\", \"muon\", \"neutrino\"]):\n", + " ax.plot(\n", + " fpr[i], tpr[i], \n", + " color=colors[i], label='ROC of {0} class (area = {1:0.4f})'\n", + " ''.format(item, roc_auc[i]))\n", + " axins.plot(\n", + " fpr[i], tpr[i], \n", + " color=colors[i], label='ROC of {0} class (area = {1:0.4f})'\n", + " ''.format(item, roc_auc[i]))\n", + "\n", + "\n", + "ax.plot([0, 1], [0, 1], 'k--', label=\"random\")\n", + "ax.set_xlim([0.0, 1.0])\n", + "ax.set_ylim([0.0, 1.05])\n", + "ax.set_xlabel('False Positive Rate')\n", + "ax.set_ylabel('True Positive Rate')\n", + "ax.set_title('Receiver operating characteristic to multi-class')\n", + "ax.legend(loc=\"upper right\", framealpha=0.99)\n", + "\n", + "# sub region of the original image\n", + "x1, x2, y1, y2 = 0, .02, 0.92, 1\n", + "axins.set_xlim(x1, x2)\n", + "axins.set_ylim(y1, y2)\n", + "\n", + "ax.indicate_inset_zoom(axins, edgecolor=\"black\")\n", + "\n", + "ax.text(\n", + " .775, .6, \n", + " f\"\"\"One-vs-One ROC AUC scores:\n", + " \\n{macro_roc_auc_ovo:.4f} (macro), \n", + " \\n{weighted_roc_auc_ovo:.4f} (weighted by prevalence)\n", + " \\nOne-vs-Rest ROC AUC scores:\n", + " \\n{macro_roc_auc_ovr:.4f} (macro), \n", + " \\n{weighted_roc_auc_ovr:.4f} (weighted by prevalence)\"\"\" ,\n", + " fontsize = 10, \n", + " bbox = dict(facecolor = 'white', alpha = 0.99))\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('graphnet')", + "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.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e54c104f54ca5f79eede1c2e02355cc39841da57601eff628eedcebaaa867660" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPrediction.ipynb b/multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPrediction.ipynb index 4c4f61b..645428c 100644 --- a/multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPrediction.ipynb +++ b/multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPrediction.ipynb @@ -9,9 +9,18 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/groups/icecube/qgf305/anaconda3/envs/graphnet/lib/python3.8/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], "source": [ "import pandas as pd\n", "import matplotlib.pyplot as plt\n", @@ -20,13 +29,14 @@ "from torchmetrics import ConfusionMatrix\n", "import torch\n", "#path_to_db = \"/groups/icecube/peter/storage/Multiclassification/Test/last_one_lvl3MC/dynedge_pid_test_run/results.csv\"\n", - "path_to_db = \"/groups/icecube/peter/storage/Multiclassification/Real/last_one_lvl3MC/dynedge_pid_Real_run_21.5_mill_equal_frac_/results.csv\"\n", + "path_to_db = \"/groups/icecube/peter/storage/Multiclassification/Real/last_one_lvl3MC/dynedge_pid_Real_run_21.5_mill_equal_frac_second_/results.csv\"\n", + "path_to_db = \"/groups/icecube/petersen/GraphNetDatabaseRepository/example_results/train_classification_model/last_one_lvl3MC/dynedge_pid_example/results.csv\"\n", "feature_data = pd.read_csv(path_to_db, index_col=[0])" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -36,7 +46,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -46,14 +56,14 @@ "unique particle ID's and their count: \n", " pid_noise_pred\n", "pid \n", - "-16.0 226198\n", - "-14.0 256710\n", - "-12.0 253786\n", - "-1.0 2474861\n", - " 12.0 572457\n", - " 13.0 2474809\n", - " 14.0 567616\n", - " 16.0 598563\n", + "-16.0 1000\n", + "-14.0 1132\n", + "-12.0 1064\n", + "-1.0 10999\n", + " 12.0 2520\n", + " 13.0 11090\n", + " 14.0 2535\n", + " 16.0 2660\n", "\n", "data:\n" ] @@ -89,43 +99,43 @@ " \n", " \n", " 0\n", - " 1.000000e+00\n", - " 0.000000\n", - " 0.000000e+00\n", - " -1.0\n", - " 23434375.0\n", + " 1.158475e-08\n", + " 0.998674\n", + " 0.001326\n", + " 13.0\n", + " 70303953.0\n", " \n", " \n", " 1\n", - " 3.946079e-22\n", - " 1.000000\n", - " 3.906106e-07\n", + " 6.296498e-07\n", + " 0.962749\n", + " 0.037251\n", " 13.0\n", - " 70953235.0\n", + " 70834217.0\n", " \n", " \n", " 2\n", - " 1.827151e-20\n", - " 1.000000\n", - " 1.306228e-07\n", - " 13.0\n", - " 97961265.0\n", + " 8.062494e-01\n", + " 0.014907\n", + " 0.178844\n", + " -1.0\n", + " 47840380.0\n", " \n", " \n", " 3\n", - " 3.665486e-01\n", - " 0.022993\n", - " 6.104581e-01\n", - " 12.0\n", - " 33636682.0\n", + " 4.564216e-12\n", + " 0.987746\n", + " 0.012254\n", + " 13.0\n", + " 89703021.0\n", " \n", " \n", " 4\n", - " 2.773106e-01\n", - " 0.017270\n", - " 7.054196e-01\n", - " 12.0\n", - " 53035643.0\n", + " 9.455863e-06\n", + " 0.987323\n", + " 0.012667\n", + " 13.0\n", + " 81500837.0\n", " \n", " \n", " ...\n", @@ -136,68 +146,68 @@ " ...\n", " \n", " \n", - " 7424995\n", - " 1.000000e+00\n", - " 0.000000\n", - " 0.000000e+00\n", - " -1.0\n", - " 66993636.0\n", + " 32995\n", + " 6.928816e-03\n", + " 0.001326\n", + " 0.991746\n", + " 16.0\n", + " 72783503.0\n", " \n", " \n", - " 7424996\n", - " 9.246089e-11\n", - " 0.916026\n", - " 8.397368e-02\n", - " 13.0\n", - " 58567439.0\n", + " 32996\n", + " 2.568107e-05\n", + " 0.185457\n", + " 0.814518\n", + " 14.0\n", + " 28491557.0\n", " \n", " \n", - " 7424997\n", - " 6.353963e-01\n", - " 0.008736\n", - " 3.558680e-01\n", + " 32997\n", + " 9.150535e-01\n", + " 0.001142\n", + " 0.083805\n", " 16.0\n", - " 81515634.0\n", + " 51018639.0\n", " \n", " \n", - " 7424998\n", - " 8.316677e-03\n", - " 0.650760\n", - " 3.409231e-01\n", - " 16.0\n", - " 221130.0\n", + " 32998\n", + " 2.543411e-02\n", + " 0.001790\n", + " 0.972775\n", + " 12.0\n", + " 61500370.0\n", " \n", " \n", - " 7424999\n", - " 1.459401e-09\n", - " 0.707856\n", - " 2.921439e-01\n", - " 13.0\n", - " 92196571.0\n", + " 32999\n", + " 9.974310e-01\n", + " 0.000018\n", + " 0.002551\n", + " -1.0\n", + " 73342438.0\n", " \n", " \n", "\n", - "

7425000 rows × 5 columns

\n", + "

33000 rows × 5 columns

\n", "" ], "text/plain": [ - " pid_noise_pred pid_muon_pred pid_neutrino_pred pid event_no\n", - "0 1.000000e+00 0.000000 0.000000e+00 -1.0 23434375.0\n", - "1 3.946079e-22 1.000000 3.906106e-07 13.0 70953235.0\n", - "2 1.827151e-20 1.000000 1.306228e-07 13.0 97961265.0\n", - "3 3.665486e-01 0.022993 6.104581e-01 12.0 33636682.0\n", - "4 2.773106e-01 0.017270 7.054196e-01 12.0 53035643.0\n", - "... ... ... ... ... ...\n", - "7424995 1.000000e+00 0.000000 0.000000e+00 -1.0 66993636.0\n", - "7424996 9.246089e-11 0.916026 8.397368e-02 13.0 58567439.0\n", - "7424997 6.353963e-01 0.008736 3.558680e-01 16.0 81515634.0\n", - "7424998 8.316677e-03 0.650760 3.409231e-01 16.0 221130.0\n", - "7424999 1.459401e-09 0.707856 2.921439e-01 13.0 92196571.0\n", + " pid_noise_pred pid_muon_pred pid_neutrino_pred pid event_no\n", + "0 1.158475e-08 0.998674 0.001326 13.0 70303953.0\n", + "1 6.296498e-07 0.962749 0.037251 13.0 70834217.0\n", + "2 8.062494e-01 0.014907 0.178844 -1.0 47840380.0\n", + "3 4.564216e-12 0.987746 0.012254 13.0 89703021.0\n", + "4 9.455863e-06 0.987323 0.012667 13.0 81500837.0\n", + "... ... ... ... ... ...\n", + "32995 6.928816e-03 0.001326 0.991746 16.0 72783503.0\n", + "32996 2.568107e-05 0.185457 0.814518 14.0 28491557.0\n", + "32997 9.150535e-01 0.001142 0.083805 16.0 51018639.0\n", + "32998 2.543411e-02 0.001790 0.972775 12.0 61500370.0\n", + "32999 9.974310e-01 0.000018 0.002551 -1.0 73342438.0\n", "\n", - "[7425000 rows x 5 columns]" + "[33000 rows x 5 columns]" ] }, - "execution_count": 6, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -211,7 +221,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -225,7 +235,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -235,9 +245,9 @@ "unique particle ID's and their count: \n", " pid_noise_pred\n", "pid \n", - "1.0 2474861\n", - "12.0 2475330\n", - "13.0 2474809\n", + "1.0 10999\n", + "12.0 10911\n", + "13.0 11090\n", "\n", "data:\n" ] @@ -273,43 +283,43 @@ " \n", " \n", " 0\n", - " 1.000000e+00\n", - " 0.000000\n", - " 0.000000e+00\n", - " 1.0\n", - " 23434375.0\n", + " 1.158475e-08\n", + " 0.998674\n", + " 0.001326\n", + " 13.0\n", + " 70303953.0\n", " \n", " \n", " 1\n", - " 3.946079e-22\n", - " 1.000000\n", - " 3.906106e-07\n", + " 6.296498e-07\n", + " 0.962749\n", + " 0.037251\n", " 13.0\n", - " 70953235.0\n", + " 70834217.0\n", " \n", " \n", " 2\n", - " 1.827151e-20\n", - " 1.000000\n", - " 1.306228e-07\n", - " 13.0\n", - " 97961265.0\n", + " 8.062494e-01\n", + " 0.014907\n", + " 0.178844\n", + " 1.0\n", + " 47840380.0\n", " \n", " \n", " 3\n", - " 3.665486e-01\n", - " 0.022993\n", - " 6.104581e-01\n", - " 12.0\n", - " 33636682.0\n", + " 4.564216e-12\n", + " 0.987746\n", + " 0.012254\n", + " 13.0\n", + " 89703021.0\n", " \n", " \n", " 4\n", - " 2.773106e-01\n", - " 0.017270\n", - " 7.054196e-01\n", - " 12.0\n", - " 53035643.0\n", + " 9.455863e-06\n", + " 0.987323\n", + " 0.012667\n", + " 13.0\n", + " 81500837.0\n", " \n", " \n", " ...\n", @@ -320,68 +330,68 @@ " ...\n", " \n", " \n", - " 7424995\n", - " 1.000000e+00\n", - " 0.000000\n", - " 0.000000e+00\n", - " 1.0\n", - " 66993636.0\n", + " 32995\n", + " 6.928816e-03\n", + " 0.001326\n", + " 0.991746\n", + " 12.0\n", + " 72783503.0\n", " \n", " \n", - " 7424996\n", - " 9.246089e-11\n", - " 0.916026\n", - " 8.397368e-02\n", - " 13.0\n", - " 58567439.0\n", + " 32996\n", + " 2.568107e-05\n", + " 0.185457\n", + " 0.814518\n", + " 12.0\n", + " 28491557.0\n", " \n", " \n", - " 7424997\n", - " 6.353963e-01\n", - " 0.008736\n", - " 3.558680e-01\n", + " 32997\n", + " 9.150535e-01\n", + " 0.001142\n", + " 0.083805\n", " 12.0\n", - " 81515634.0\n", + " 51018639.0\n", " \n", " \n", - " 7424998\n", - " 8.316677e-03\n", - " 0.650760\n", - " 3.409231e-01\n", + " 32998\n", + " 2.543411e-02\n", + " 0.001790\n", + " 0.972775\n", " 12.0\n", - " 221130.0\n", + " 61500370.0\n", " \n", " \n", - " 7424999\n", - " 1.459401e-09\n", - " 0.707856\n", - " 2.921439e-01\n", - " 13.0\n", - " 92196571.0\n", + " 32999\n", + " 9.974310e-01\n", + " 0.000018\n", + " 0.002551\n", + " 1.0\n", + " 73342438.0\n", " \n", " \n", "\n", - "

7425000 rows × 5 columns

\n", + "

33000 rows × 5 columns

\n", "" ], "text/plain": [ - " pid_noise_pred pid_muon_pred pid_neutrino_pred pid event_no\n", - "0 1.000000e+00 0.000000 0.000000e+00 1.0 23434375.0\n", - "1 3.946079e-22 1.000000 3.906106e-07 13.0 70953235.0\n", - "2 1.827151e-20 1.000000 1.306228e-07 13.0 97961265.0\n", - "3 3.665486e-01 0.022993 6.104581e-01 12.0 33636682.0\n", - "4 2.773106e-01 0.017270 7.054196e-01 12.0 53035643.0\n", - "... ... ... ... ... ...\n", - "7424995 1.000000e+00 0.000000 0.000000e+00 1.0 66993636.0\n", - "7424996 9.246089e-11 0.916026 8.397368e-02 13.0 58567439.0\n", - "7424997 6.353963e-01 0.008736 3.558680e-01 12.0 81515634.0\n", - "7424998 8.316677e-03 0.650760 3.409231e-01 12.0 221130.0\n", - "7424999 1.459401e-09 0.707856 2.921439e-01 13.0 92196571.0\n", + " pid_noise_pred pid_muon_pred pid_neutrino_pred pid event_no\n", + "0 1.158475e-08 0.998674 0.001326 13.0 70303953.0\n", + "1 6.296498e-07 0.962749 0.037251 13.0 70834217.0\n", + "2 8.062494e-01 0.014907 0.178844 1.0 47840380.0\n", + "3 4.564216e-12 0.987746 0.012254 13.0 89703021.0\n", + "4 9.455863e-06 0.987323 0.012667 13.0 81500837.0\n", + "... ... ... ... ... ...\n", + "32995 6.928816e-03 0.001326 0.991746 12.0 72783503.0\n", + "32996 2.568107e-05 0.185457 0.814518 12.0 28491557.0\n", + "32997 9.150535e-01 0.001142 0.083805 12.0 51018639.0\n", + "32998 2.543411e-02 0.001790 0.972775 12.0 61500370.0\n", + "32999 9.974310e-01 0.000018 0.002551 1.0 73342438.0\n", "\n", - "[7425000 rows x 5 columns]" + "[33000 rows x 5 columns]" ] }, - "execution_count": 8, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -395,12 +405,12 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -410,7 +420,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABncAAANECAYAAABiinpXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABZuUlEQVR4nOzdeZjVdd0//teBEQbFGcSFxaBBxWUSBXXCLcXCyNwwMxUX3CuP5pK55Ibmreat39Q83mqLYHek1Ve5yy3NjSyiIcXGBk1tCEuWyhtGMFyG8/ujr/NrAnQ4nJnPvGcej+ua6/J81ucZ8oTznNf7kysWi8UAAAAAAAAgCb2yDgAAAAAAAED7KXcAAAAAAAASotwBAAAAAABIiHIHAAAAAAAgIcodAAAAAACAhCh3AAAAAAAAEqLcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIQodwAAAGi3E044IWpqarKOAQAAPZpyBwAAAAAAICHKHQAAAAAAgIQodwAAAHqAFStWZB0BAAAoE+UOAADQLU2ZMiVyuVz84Q9/iGOPPTaqq6tj8803j0svvTSKxWK8+uqrceihh0ZVVVUMHjw4brjhhjbnT506NXK5XMyfP7/N9ieffDJyuVw8+eSTbbb/6Ec/il133TX69esXm222WRx77LHxl7/8pc0xJ5xwQvTv3z/+8pe/xMSJE6N///6x+eabx3nnnRctLS0f+J5qamrioIMOikceeSRGjx4dlZWVUVtbG/fee+8asz/11FNx+umnxxZbbBEf+tCHWvc/9NBD8bGPfSw22mij2HjjjePAAw+M3//+96vdb8aMGbHjjjtGZWVl7LjjjnHfffd9YEYAAKDjKXcAAIBu7cgjj4xVq1bFtddeG2PHjo2rrroqbrzxxth///1jyy23jK9//euxzTbbxHnnnRczZ84s6R5Tp06Nz33uc9G7d++45ppr4tRTT41777039t5771i6dGmbY1taWmLChAmx6aabxvXXXx/77rtv3HDDDXHHHXe0614vvfRSHHnkkXHAAQfENddcExUVFXHEEUfEo48+utqxp59+ejQ2NsZll10WF154YUREfO9734sDDzww+vfvH1//+tfj0ksvjcbGxth7773bFFmPPPJIHH744ZHL5eKaa66JiRMnxoknnhhz5swp6XsEAACUT0XWAQAAADrSRz/60bj99tsjIuK0006Lmpqa+PKXvxzXXHNNXHDBBRERcfTRR8fQoUPju9/9buyzzz7rdP133nknLrjggthxxx1j5syZUVlZGRERe++9dxx00EHxjW98I6644orW41euXBlHHnlkXHrppRER8YUvfCF22WWX+M53vhNf/OIXP/B+f/jDH+L//t//G5/5zGciIuLkk0+O7bffPi644ILYf//92xw7cODAeOyxx6J3794REbF8+fL40pe+FKecckqbMmny5Mmx3XbbxdVXX926/YILLohBgwbF008/HdXV1RERse+++8YnP/nJ+PCHP7xO3yMAAKC8TO4AAADd2imnnNL6z717947ddtstisVinHzyya3bBwwYENttt1388Y9/XOfrz5kzJ5YsWRKnn356a7ETEXHggQfG9ttvHw888MBq53zhC19o8/pjH/tYu+89dOjQOOyww1pfV1VVxfHHHx/PPvtsLFq0qM2xp556amuxExHx6KOPxtKlS+Poo4+Ov/3tb61fvXv3jrFjx8YTTzwRERELFy6MuXPnxuTJk1uLnYiI/fffP2pra9uVEwAA6DgmdwAAgG5t+PDhbV5XV1dHZWVlbLbZZqtt//vf/77O1//Tn/4UERHbbbfdavu23377ePrpp9tsq6ysjM0337zNtk022ST+93//t13322abbSKXy7XZtu2220ZExPz582Pw4MGt20eMGNHmuJdeeikiIj7+8Y+v8dpVVVUR8f+/p5EjR652zHbbbRfPPPNMu7ICAAAdQ7kDAAB0a/86ufJ+2yIiisVi6z//e4HynpaWlrLn6Sj9+vVr83rVqlUR8c/n7vxrCfSeigr/iQgAACnwN3cAAIA12GSTTSIiYunSpW22vzfV8p73nj/z4osvrjYR8+KLL5b9+TQvv/xyFIvFNuXTH/7wh4iIqKmped9zt95664iI2GKLLWL8+PFrPe69zO9N+vyrF198cV0jAwAAZeaZOwAAAGvwXhEyc+bM1m0tLS1xxx13tDlut912iy222CJuu+22eOutt1q3P/TQQzFv3rw48MADy5rrtddei/vuu6/1dXNzc9x1110xevToNU7j/KsJEyZEVVVVXH311fHOO++stv+vf/1rREQMGTIkRo8eHdOmTYtly5a17n/00UejsbGxTO8EAAAolckdAACANfjIRz4Su+++e1x00UXx+uuvx8CBA+Puu++Od999t81xG2ywQXz961+PE088Mfbdd984+uijY/HixXHTTTdFTU1NnHPOOWXNte2228bJJ58c9fX1MWjQoPjud78bixcvjjvvvPMDz62qqor/+q//iuOOOy522WWXOOqoo2LzzTePBQsWxAMPPBB77bVX3HLLLRERcc0118SBBx4Ye++9d5x00knx+uuvxze/+c34yEc+EsuXLy/rewIAANaNyR0AAIC1+P73vx977rlnXHvttXH11VfHfvvtF9dee+1qx51wwglxzz33xNtvvx0XXHBB3H777XHYYYfF008/HQMGDChrppEjR8Y999wTDz74YFx44YXxzjvvxD333BMTJkxo1/mTJk2Kxx57LLbccsv4z//8zzjrrLPi7rvvjtGjR8eJJ57YetynPvWp+NGPfhQtLS1x0UUXxb333ht33nln7LbbbmV9PwAAwLrLFf/1iaEAAAB0WTU1NbHjjjvG/fffn3UUAAAgQyZ3AAAAAAAAEqLcAQAAAAAASIhyBwAAAAAAICGeuQMAAAAAAJAQkzsAAAAAAAAJUe4AAAAAAAAkpCLrAD3ZqlWr4rXXXouNN944crlc1nEAAAAAAIAMFYvFeOONN2Lo0KHRq9fa53OUOxl67bXXYtiwYVnHAAAAAAAAupBXX301PvShD611v3InQxtvvHFE/PMPqaqqKuM0AAAAAABAlpqbm2PYsGGt/cHaKHcy9N5SbFVVVcodAAAAAAAgIuIDH+Wy9gXbAAAAAAAA6HKUOwAAAAAAAAlR7gAAAAAAACTEM3cyUCgUolAoREtLS9ZRAAAAAADoJlatWhVvv/121jF4HxtssEH07t17va+TKxaLxTLkoQTNzc1RXV0dy5Yti6qqqqzjAAAAAACQqLfffjuamppi1apVWUfhAwwYMCAGDx4cuVxutX3t7Q1M7gAAAAAAQMKKxWIsXLgwevfuHcOGDYtevTyRpSsqFovx5ptvxpIlSyIiYsiQISVfS7kDAAAAAAAJe/fdd+PNN9+MoUOHxoYbbph1HN5Hv379IiJiyZIlscUWW5S8RJv6DgAAAAAAEvbe89379OmTcRLa470C7p133in5GsodAAAAAADoBtb0DBe6nnL8OSl3AAAAAAAAEqLcAQAAAAAAkjNlypQYPXp01jEyUZF1AAAAAAAAoPxqLnygU+83/9oDO/V+5513Xpx55pmdes+uQrkDAAAAAAAkp3///tG/f/+sY2TCsmwAAAAAAECnGzduXHzpS1+K888/PwYOHBiDBw+OKVOmtO5fsGBBHHroodG/f/+oqqqKz33uc7F48eLW/f++LNuTTz4ZH/3oR2OjjTaKAQMGxF577RV/+tOfWvf/z//8T+yyyy5RWVkZW221VVxxxRXx7rvvdsZbLTvlDgAAAAAAkIlp06bFRhttFLNnz47rrrsurrzyynj00Udj1apVceihh8brr78eTz31VDz66KPxxz/+MY488sg1Xufdd9+NiRMnxr777hu/+93vYtasWXHaaadFLpeLiIhf/OIXcfzxx8dZZ50VjY2Ncfvtt8fUqVPjP/7jPzrz7ZaNZdkAAAAAAIBM7LTTTnH55ZdHRMTIkSPjlltuicceeywiIhoaGqKpqSmGDRsWERF33XVXfOQjH4n6+vqoq6trc53m5uZYtmxZHHTQQbH11ltHRMQOO+zQuv+KK66ICy+8MCZPnhwREVtttVV87Wtfi/PPP7/1/ikxuQMAAAAAAGRip512avN6yJAhsWTJkpg3b14MGzastdiJiKitrY0BAwbEvHnzVrvOwIED44QTTogJEybEwQcfHDfddFMsXLiwdf9zzz0XV155Zetzevr37x+nnnpqLFy4MN58882Oe4MdRLmTgUKhELW1tas1iwAAAAAA0JNssMEGbV7ncrlYtWpVSde68847Y9asWbHnnnvGPffcE9tuu238+te/joiI5cuXxxVXXBFz585t/WpoaIiXXnopKisr1/t9dDbLsmUgn89HPp+P5ubmqK6uzjoOAAAAAAB0KTvssEO8+uqr8eqrr7ZO7zQ2NsbSpUujtrZ2reeNGTMmxowZExdddFHsscceMX369Nh9991jl112iRdffDG22WabznoLHUq5AwAAAAAAdCnjx4+PUaNGxTHHHBM33nhjvPvuu3H66afHvvvuG7vttttqxzc1NcUdd9wRhxxySAwdOjRefPHFeOmll+L444+PiIjLLrssDjrooBg+fHh89rOfjV69esVzzz0Xzz//fFx11VWd/fbWm2XZAAAAAACALiWXy8X//M//xCabbBL77LNPjB8/Prbaaqu455571nj8hhtuGC+88EIcfvjhse2228Zpp50W+Xw+Pv/5z0dExIQJE+L++++PRx55JOrq6mL33XePb3zjG/HhD3+4M99W2eSKxWIx6xA91XvLsi1btiyqqqqyjgMAAAAAQIJWrlwZTU1NMWLEiCSfH9PTvN+fV3t7A5M7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAA93pQpU2L06NFZx2iXiqwDwBpNqS7xvGXlzQEAAAAAkKpSf85a8v263s9nx40bF6NHj44bb7zxA48977zz4swzz+z4UGWg3AEAAAAAAHqsYrEYLS0t0b9//+jfv3/WcdrFsmwAAAAAAECnGzduXHzpS1+K888/PwYOHBiDBw+OKVOmtO5funRpnHLKKbH55ptHVVVVfPzjH4/nnnuudf8JJ5wQEydObHPNs88+O8aNG9e6/6mnnoqbbropcrlc5HK5mD9/fjz55JORy+XioYceil133TX69u0bTz/99GrLsr13/euvvz6GDBkSm266aeTz+XjnnXdaj/nf//3fOP7442OTTTaJDTfcMA444IB46aWXOuLb1YZyJwOFQiFqa2ujrq4u6ygAAAAAAJCZadOmxUYbbRSzZ8+O6667Lq688sp49NFHIyLiiCOOiCVLlsRDDz0Uv/3tb2OXXXaJT3ziE/H666+369o33XRT7LHHHnHqqafGwoULY+HChTFs2LDW/RdeeGFce+21MW/evNhpp53WeI0nnngiXnnllXjiiSdi2rRpMXXq1Jg6dWrr/hNOOCHmzJkTP/nJT2LWrFlRLBbj05/+dJsCqCNYli0D+Xw+8vl8NDc3R3V1J695CAAAAAAAXcROO+0Ul19+eUREjBw5Mm655ZZ47LHHol+/fvGb3/wmlixZEn379o2IiOuvvz5mzJgRP/7xj+O00077wGtXV1dHnz59YsMNN4zBgwevtv/KK6+M/fff/32vsckmm8Qtt9wSvXv3ju233z4OPPDAeOyxx+LUU0+Nl156KX7yk5/EL3/5y9hzzz0jIuL73/9+DBs2LGbMmBFHHHHEun472k25AwAAAAAAZOLfJ2aGDBkSS5Ysieeeey6WL18em266aZv9//jHP+KVV14py7132223DzzmIx/5SPTu3btNvoaGhoiImDdvXlRUVMTYsWNb92+66aax3Xbbxbx588qScW2UOwAAAAAAQCY22GCDNq9zuVysWrUqli9fHkOGDIknn3xytXMGDBgQERG9evWKYrHYZt+6LIe20UYblZwva8odAAAAAACgS9lll11i0aJFUVFRETU1NWs8ZvPNN4/nn3++zba5c+e2KWT69OkTLS0tHZJxhx12iHfffTdmz57duizb3//+93jxxRejtra2Q+75nl4denUAAAAAAIB1NH78+Nhjjz1i4sSJ8cgjj8T8+fPjV7/6VVx88cUxZ86ciIj4+Mc/HnPmzIm77rorXnrppbj88stXK3tqampi9uzZMX/+/Pjb3/5W1qmbkSNHxqGHHhqnnnpqPP300/Hcc8/FscceG1tuuWUceuihZbvPmih3AAAAAACALiWXy8WDDz4Y++yzT5x44omx7bbbxlFHHRV/+tOfYtCgQRERMWHChLj00kvj/PPPj7q6unjjjTfi+OOPb3Od8847L3r37h21tbWx+eabx4IFC8qa884774xdd901DjrooNhjjz2iWCzGgw8+uNpybuWWK/77gnR0mubm5qiuro5ly5ZFVVVV1nG6linVJZ63rLw5AAAAAAC6uJUrV0ZTU1OMGDEiKisrs47DB3i/P6/29gYmdwAAAAAAABKi3AEAAAAAAEiIcgcAAAAAACAhyh0AAAAAAICEKHcAAAAAAAASotwBAAAAAABIiHIHAAAAAAAgIcodAAAAAACAhCh3AAAAAAAAElKRdQBYk5qV00s6b355YwAAAAAAQJej3AEAAAAAgG5o1LRRnXq/hskNnXq/nsyybAAAAAAAAAlR7gAAAAAAAJ1u3LhxceaZZ8bZZ58dm2yySQwaNCi+9a1vxYoVK+LEE0+MjTfeOLbZZpt46KGHIiJi6tSpMWDAgDbXmDFjRuRyuTbb/uu//iu23nrr6NOnT2y33Xbxve99r83+XC4X3/72t+Owww6LDTfcMEaOHBk/+clPOvS9lptyBwAAAAAAyMS0adNis802i9/85jdx5plnxhe/+MU44ogjYs8994xnnnkmPvnJT8Zxxx0Xb775Zruud99998VZZ50VX/7yl+P555+Pz3/+83HiiSfGE0880ea4K664Ij73uc/F7373u/j0pz8dxxxzTLz++usd8RY7hHIHAAAAAADIxM477xyXXHJJjBw5Mi666KKorKyMzTbbLE499dQYOXJkXHbZZfH3v/89fve737Xretdff32ccMIJcfrpp8e2224b5557bnzmM5+J66+/vs1xJ5xwQhx99NGxzTbbxNVXXx3Lly+P3/zmNx3xFjuEcgcAAAAAAMjETjvt1PrPvXv3jk033TRGjRrVum3QoEEREbFkyZJ2XW/evHmx1157tdm21157xbx589Z634022iiqqqrafY+uQLkDAAAAAABkYoMNNmjzOpfLtdn23vN0Vq1aFb169Ypisdjm+Hfeeads9121alVJ18qCcicDhUIhamtro66uLusoAAAAAACQhM033zzeeOONWLFiReu2uXPntjlmhx12iF/+8pdttv3yl7+M2trazojYaSqyDtAT5fP5yOfz0dzcHNXV1VnHAQAAAACALm/s2LGx4YYbxle/+tX40pe+FLNnz46pU6e2OeYrX/lKfO5zn4sxY8bE+PHj46c//Wnce++98fOf/zyb0B3E5A4AAAAAANDlDRw4MP77v/87HnzwwRg1alT84Ac/iClTprQ5ZuLEiXHTTTfF9ddfHx/5yEfi9ttvjzvvvDPGjRuXSeaOkiv++wJ1dJr3JneWLVsWVVVVWcfpUmoufKCk8+Zfe2CZkwAAAAAAdG0rV66MpqamGDFiRFRWVmYdhw/wfn9e7e0NTO4AAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQpQ7AAAAAAAACVHuAAAAAABAN1AsFrOOQDuU489JuQMAAAAAAAnr3bt3RES8/fbbGSehPd58882IiNhggw1KvkZFucIAAAAAAACdr6KiIjbccMP461//GhtssEH06mWuoysqFovx5ptvxpIlS2LAgAGtpVwplDsAAAAAAJCwXC4XQ4YMiaampvjTn/6UdRw+wIABA2Lw4MHrdQ3lDgAAAAAAJK5Pnz4xcuRIS7N1cRtssMF6Tey8R7kDAAAAAADdQK9evaKysjLrGHQCC+8BAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQjxzBwAAAAAAKMmoaaNKOq9hckOZk/QsJncAAAAAAAASotwBAAAAAABIiHIHAAAAAAAgIcodAAAAAACAhCh3AAAAAAAAEqLcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIQodwAAAAAAABKi3AEAAAAAAEiIcgcAAAAAACAhyh0AAAAAAICEKHcAAAAAAAASotwBAAAAAABIiHIHAAAAAAAgIcodAAAAAACAhCh3AAAAAAAAEqLcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIQodwAAAAAAABKSXLkzc+bMOPjgg2Po0KGRy+VixowZH3jO1KlTI5fLxQ477LDavh/96EeRy+WipqamzfEDBgxY47Xae08AAAAAAICOkFy5s2LFith5552jUCis03kbbbRRLFmyJGbNmtVm+3e+850YPnx4OSMCAAAAAAB0mOTKnQMOOCCuuuqqOOyww9bpvIqKipg0aVJ897vfbd325z//OZ588smYNGlSSVmmTJkSuVxuta+pU6eWdD0AAAAAAIAPkly5sz5OOumk+OEPfxhvvvlmRPxz+bVPfepTMWjQoJKud95558XChQtbv66//vrYcMMNY7fdditnbAAAAAAAgFY9qtwZM2ZMbLXVVvHjH/84isViTJ06NU466aQ1Hrts2bLo37//al//qn///jF48OAYPHhwzJ8/Py655JK48847Y8cdd1zjNd96661obm5u8wUAAAAAALAuKrIO0NlOOumkuPPOO2P48OGxYsWK+PSnPx233HLLasdtvPHG8cwzz6y2feTIkattW7BgQUycODHOO++8+NznPrfWe19zzTVxxRVXrN8bAAAAAAAAerQeNbkTEXHMMcfEr3/965gyZUocd9xxUVGx5n6rV69esc0226z29e9WrFgRhxxySOyxxx5x5ZVXvu+9L7rooli2bFnr16uvvlqW9wQAAAAAAPQcPW5yZ+DAgXHIIYfED3/4w7jtttvW61rFYjGOPfbYWLVqVXzve9+LXC73vsf37ds3+vbtu173BAAAAAAAerbkyp3ly5fHyy+/3Pq6qakp5s6dGwMHDozhw4e36xpTp06NW2+9NTbddNP1yjJlypT4+c9/Ho888kgsX748li9fHhER1dXV0a9fv/W6NgAAAAAAwJoktyzbnDlzYsyYMTFmzJiIiDj33HNjzJgxcdlll7X7Gv369VvvYici4qmnnorly5fHnnvuGUOGDGn9uueee9b72gAAAAAAAGuSKxaLxaxD9FTNzc1RXV0dy5Yti6qqqqzjdCk1Fz5Q0nnzrz2wzEkAAAAAAFibUdNGlXRew+SGMifpHtrbGyQ3udMdFAqFqK2tjbq6uqyjAAAAAAAAiVHuZCCfz0djY2PU19dnHQUAAAAAAEiMcgcAAAAAACAhyh0AAAAAAICEKHcAAAAAAAASotwBAAAAAABIiHIHAAAAAAAgIcodAAAAAACAhCh3MlAoFKK2tjbq6uqyjgIAAAAAACRGuZOBfD4fjY2NUV9fn3UUAAAAAAAgMcodAAAAAACAhCh3AAAAAAAAEqLcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIQodwAAAAAAABKi3MlAoVCI2traqKuryzoKAAAAAACQGOVOBvL5fDQ2NkZ9fX3WUQAAAAAAgMQodwAAAAAAABKi3AEAAAAAAEiIcgcAAAAAACAhyh0AAAAAAICEKHcAAAAAAAASotwBAAAAAABIiHIHAAAAAAAgIcodAAAAAACAhCh3MlAoFKK2tjbq6uqyjgIAAAAAACRGuZOBfD4fjY2NUV9fn3UUAAAAAAAgMcodAAAAAACAhCh3AAAAAAAAEqLcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIQodwAAAAAAABJSkXUAKKdR00aVfG7D5IYyJgEAAAAAgI6h3KFbaWhakHUEAAAAAADoUJZlAwAAAAAASIhyJwOFQiFqa2ujrq4u6ygAAAAAAEBilDsZyOfz0djYGPX19VlHAQAAAAAAEqPcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIQodwAAAAAAABKi3AEAAAAAAEiIcgcAAAAAACAhyh0AAAAAAICEKHcAAAAAAAASotwBAAAAAABIiHIHAAAAAAAgIcodAAAAAACAhCh3AAAAAAAAEqLcyUChUIja2tqoq6vLOgoAAAAAAJAY5U4G8vl8NDY2Rn19fdZRAAAAAACAxCh3AAAAAAAAEqLcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIQodwAAAAAAABKi3AEAAAAAAEiIcgcAAAAAACAhyh0AAAAAAICEKHcAAAAAAAASotwBAAAAAABIiHIHAAAAAAAgIcodAAAAAACAhCh3AAAAAAAAEqLcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIQodzJQKBSitrY26urqso4CAAAAAAAkRrmTgXw+H42NjVFfX591FAAAAAAAIDHKHQAAAAAAgIQodwAAAAAAABJSkXUA6CpGTRtV0nkNkxvKnAQAAAAAANZOuQP/T0PTgqwjAAAAAADAB7IsGwAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQpQ7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAAkRLmTgUKhELW1tVFXV5d1FAAAAAAAIDHKnQzk8/lobGyM+vr6rKMAAAAAAACJUe4AAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQpQ7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEIqsg4AqRs1bVRJ5zVMbihzEgAAAAAAegKTOwAAAAAAAAkxuQPrqaFpQdYRAAAAAADoQUzuAAAAAAAAJES5AwAAAAAAkBDLsgEAAAAAQA83atqorCOwDkzuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQpQ7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJCQiqwDQE81atqoks5rmNxQ5iQAAAAAAKTE5A4AAAAAAEBClDsAAAAAAAAJsSwbZKShaUHWEQAAAAAASJDJHQAAAAAAgIT02HInl8vFjBkzso4BAAAAAACwTjItd2bOnBkHH3xwDB06dK1lS7FYjMsuuyyGDBkS/fr1i/Hjx8dLL73U5pjXX389jjnmmKiqqooBAwbEySefHMuXL1+vbOPGjYuzzz57te1Tp06NAQMGrNe1AQAAAAAASpVpubNixYrYeeedo1AorPWY6667Lm6++ea47bbbYvbs2bHRRhvFhAkTYuXKla3HHHPMMfH73/8+Hn300bj//vtj5syZcdppp3XGWwAAAAAAAOhUmZY7BxxwQFx11VVx2GGHrXF/sViMG2+8MS655JI49NBDY6eddoq77rorXnvttdYpn3nz5sXDDz8c3/72t2Ps2LGx9957xze/+c24++6747XXXmt3lssvvzyGDBkSv/vd79bpPdTU1EQul1vtCwAAAAAAoCN06WfuNDU1xaJFi2L8+PGt26qrq2Ps2LExa9asiIiYNWtWDBgwIHbbbbfWY8aPHx+9evWK2bNnf+A9isVinHnmmXHXXXfFL37xi9hpp53WKWN9fX0sXLgwFi5cGH/+859j9913j4997GPrdA0AAAAAAID2qsg6wPtZtGhRREQMGjSozfZBgwa17lu0aFFsscUWbfZXVFTEwIEDW49Zm3fffTeOPfbYePbZZ+Ppp5+OLbfcss3+W2+9Nb797W+vdk5lZWXr680337z1n88666xYuHBh1NfXr/F+b731Vrz11lutr5ubm983HwAAAAAAwL/r0uVORzvnnHOib9++8etf/zo222yz1fYfc8wxcfHFF7fZdu+998bVV1+92rF33HFHfOc734lf/epXbQqff3XNNdfEFVdcUZ7wAAAAAABAj9Sll2UbPHhwREQsXry4zfbFixe37hs8eHAsWbKkzf533303Xn/99dZj1mb//fePv/zlL/Gzn/1sjfurq6tjm222afP171NCERFPPPFE69Ju77es20UXXRTLli1r/Xr11VffNx8AAAAAAMC/69LlzogRI2Lw4MHx2GOPtW5rbm6O2bNnxx577BEREXvssUcsXbo0fvvb37Ye8/jjj8eqVati7Nix73v9Qw45JKZPnx6nnHJK3H333SVlfPnll+Ozn/1sfPWrX43PfOYz73ts3759o6qqqs0XAAAAAADAush0Wbbly5fHyy+/3Pq6qakp5s6dGwMHDozhw4dHLpeLs88+O6666qoYOXJkjBgxIi699NIYOnRoTJw4MSIidthhh/jUpz4Vp556atx2223xzjvvxBlnnBFHHXVUDB069AMzHHbYYfG9730vjjvuuKioqIjPfvaz7c7/j3/8Iw4++OAYM2ZMnHbaaW2e8fNBU0MAAAAAAAClyLTcmTNnTuy3336tr88999yIiJg8eXJMnTo1IiLOP//8WLFiRZx22mmxdOnS2HvvvePhhx+OysrK1vO+//3vxxlnnBGf+MQnolevXnH44YfHzTff3O4cn/3sZ2PVqlVx3HHHRa9evT5wAuc9ixcvjhdeeCFeeOGF1YqkYrHY7vsDAAAAAAC0V66ohchMc3NzVFdXx7JlyyzR9m9qLnygpPPmV04qc5IuaMqyrBMAAAAAAF3UqGmjso7QLg2TG7KO0CW1tzfo0s/c6a4KhULU1tZGXV1d1lEAAAAAAIDEKHcykM/no7GxMerr67OOAgAAAAAAJCbTZ+4A667UsUpjjgAAAAAA3YPJHQAAAAAAgIQodwAAAAAAABJiWTZITEPTgqwjAAAAAACQIZM7AAAAAAAACVHuAAAAAAAAJES5k4FCoRC1tbVRV1eXdRQAAAAAACAxyp0M5PP5aGxsjPr6+qyjAAAAAAAAiVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEIqsg4A5VSzcnrJ586vnFTGJAAAAAAA0DFM7gAAAAAAACREuQMAAAAAAJAQ5U4GCoVC1NbWRl1dXdZRAAAAAACAxCh3MpDP56OxsTHq6+uzjgIAAAAAACSmIusAQOcYNW1USec1TG4ocxIAAAAAANaHyR0AAAAAAICEKHcAAAAAAAASotwBAAAAAABIiGfuQA/R0LQg6wgAAAAAQDuV+gxtegaTOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5U4GCoVC1NbWRl1dXdZRAAAAAACAxCh3MpDP56OxsTHq6+uzjgIAAAAAACRGuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJqcg6ANC1jZo2qqTzGiY3lDkJAAAAAAARJncAAAAAAACSotwBAAAAAABIiHIHAAAAAAAgIcodAAAAAACAhFRkHQDo2hqaFmQdAQAAAACAf2FyJwOFQiFqa2ujrq4u6ygAAAAAAEBilDsZyOfz0djYGPX19VlHAQAAAAAAEqPcAQAAAAAASIhn7gAAAAAAQAcZNW1U1hHohkzuAAAAAAAAJES5AwAAAAAAkBDLsgEdotRx04bJDWVOAgAAAADQvZjcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIQodwAAAAAAABKi3AEAAAAAAEhIRdYBgO6poWlB1hEAAAAAALolkzsAAAAAAAAJUe5koFAoRG1tbdTV1WUdBQAAAAAASIxyJwP5fD4aGxujvr4+6ygAAAAAAEBiPHMH6FJGTRtV0nkNkxvKnAQAAAAA/n+l/twKOoLJHQAAAAAAgIQodwAAAAAAABKi3AEAAAAAAEiIcgcAAAAAACAhyh0AAAAAAICEKHcAAAAAAAASUpF1AIB/1dC0IOsIAAAAAABdmskdAAAAAACAhJjcAbqFUdNGlXRew+SGMicBAAAAAOhYJncAAAAAAAASotwBAAAAAABIiGXZAAAAAADoMUpd3h+6EpM7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDP3MlAoVCIQqEQLS0tWUfhX9SsnF7SefMrJ5U5CQAAAAAArJ1yJwP5fD7y+Xw0NzdHdXV11nGgW2hoWpB1BAAAAACATqHcAXq0UdNGlXRew+SGMicBAAAAAGgfz9wBAAAAAABIiHIHAAAAAAAgIZZlAwAAAAAgOaUutw/dgckdAAAAAACAhCh3AAAAAAAAEqLcAQAAAAAASIhn7gCUYH3WdG2Y3FDGJAAAAABAT2NyBwAAAAAAICEmd4AeraFpQUnnjRoxvMxJAAAAAADax+QOAAAAAABAQpQ7AAAAAAAACbEsGwAAAAAAmRk1bVTWESA5yh2ATlbqX1gaJjeUOQkAAAAAkCLLsgEAAAAAACREuQMAAAAAAJAQy7IBlKChaUHJ544aMbyMSQAAAACAnsbkDgAAAAAAQEKUOwAAAAAAAAmxLBtAIkZNG1XSeQ2TG8qcBAAAAGB1pf7sAlh3JncAAAAAAAASotwBAAAAAABIiHIHAAAAAAAgIZ65k4FCoRCFQiFaWlqyjgJkoKFpQUnnjRoxvMxJAAAAAIAUmdzJQD6fj8bGxqivr886CgAAAAAAkBiTOwAAAAAARETEqGmjso4AtINyB6CbK/UvZQ2TG8qcBAAAAAAoB8uyAQAAAAAAJES5AwAAAAAAkBDLsgGwRpZzAwAAAICuyeQOAAAAAABAQkzuACSioWlBSeeNGjG8zEkAAACArq7UFTmANJjcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIR45g4AZVXqmr4NkxvKnAQAAAAAuiflDgAAAABAF1XqL1EC3Ztl2QAAAAAAABJicgegm2toWlDSeaNGDC9zEgAAAACgHJQ7sJ5qVk4v6bz5lZPKnATS5lk9AAAAANA+lmUDAAAAAABIiMkdAAAAAIAOVuqKFQBrYnIHAAAAAAAgISZ3AFijhqYFJZ03asTwMif5gPt5Vg8AAAAAPcx6lTsvv/xyvPLKK7HPPvtEv379olgsRi6XK1c2AAAAAIAuxfJqQFdQUrnz97//PY488sh4/PHHI5fLxUsvvRRbbbVVnHzyybHJJpvEDTfcUO6cAFBWJn4AAAAASFVJz9w555xzoqKiIhYsWBAbbrhh6/YjjzwyHn744bKFAwAAAAAAoK2SJnceeeSR+NnPfhYf+tCH2mwfOXJk/OlPfypLMAAAAAAAAFZX0uTOihUr2kzsvOf111+Pvn37rncoAAAAAAAA1qykyZ2Pfexjcdddd8XXvva1iIjI5XKxatWquO6662K//fYra0AAAAAAgHIr9VmsAF1BSeXOddddF5/4xCdizpw58fbbb8f5558fv//97+P111+PX/7yl+XOCEBCGpoWlHTeqBHDy5ykY5T6l/+GyQ1lTgIAAABAT1XSsmw77rhj/OEPf4i99947Dj300FixYkV85jOfiWeffTa23nrrcmcEAAAAAADg/ylpcmfBggUxbNiwuPjii9e4b/jwNH77GgAAAABIm+XVgJ6opMmdESNGxF//+tfVtv/973+PESNGrHcoAAAAAAAA1qykcqdYLEYul1tt+/Lly6OysnK9QwEAAAAAALBm67Qs27nnnhsREblcLi699NLYcMMNW/e1tLTE7NmzY/To0WUNCEDP0NC0oKTzRo1IYynQUpcJaJjcUOYkAAAAAKRuncqdZ599NiL+ObnT0NAQffr0ad3Xp0+f2HnnneO8884rb0IAAAAAoNvz7ByA9luncueJJ56IiIgTTzwxbrrppqiqquqQUADAP63Pf9yY+gEAAADontap3HnPnXfeWe4cAAAAAAAAtENJ5U5ExJw5c+KHP/xhLFiwIN5+++02++699971DgYA7dHdn9WzPjznBwAAyILl1QA6Xq9STrr77rtjzz33jHnz5sV9990X77zzTvz+97+Pxx9/PKqrq8udEQAAAAAAgP+npMmdq6++Or7xjW9EPp+PjTfeOG666aYYMWJEfP7zn48hQ4aUO2PZjRs3LkaPHh033nhj1lEAAAAAoEsygQPQdZU0ufPKK6/EgQceGBERffr0iRUrVkQul4tzzjkn7rjjjrKFmzlzZhx88MExdOjQyOVyMWPGjNWOKRaLcdlll8WQIUOiX79+MX78+HjppZfW675TpkyJ0aNHr7Z9/vz5kcvlYu7cuet1fQAAAAAAgFKVNLmzySabxBtvvBEREVtuuWU8//zzMWrUqFi6dGm8+eabZQu3YsWK2HnnneOkk06Kz3zmM2s85rrrroubb745pk2bFiNGjIhLL700JkyYEI2NjVFZWVm2LADQU3hWDwAAAEDXVlK5s88++8Sjjz4ao0aNiiOOOCLOOuusePzxx+PRRx+Nj3/842ULd8ABB8QBBxyw1v3FYjFuvPHGuOSSS+LQQw+NiIi77rorBg0aFDNmzIijjjqqXfd54IEHYtKkSXHrrbfGMccc0+58J5xwQkybNm217U888USMGzeu3dcBoPM1NC0o6bxRI4aXOUn3oRQCAICuyfJqAN1PScuy3XLLLa3FycUXXxznnntuLF68OA4//PC49dZbyxrw/TQ1NcWiRYti/Pjxrduqq6tj7NixMWvWrHZdY/r06XH00UfH97///XUqdiIibrrppli4cGHr11lnnRVbbLFFbL/99ut0HQAAAAAAgPYqaXJn4MCBrf/cq1evuPDCC2PlypVRKBRizJgxsWjRorIFfD/v3WfQoEFttg8aNKhdGQqFQlx88cXx05/+NPbdd982+xoaGqJ///5tthWLxTavq6uro7q6OiIi7r333rj99tvj5z//eQwePHiN93vrrbfirbfean3d3Nz8gRkBoLsz8QMAAACwbtap3HnrrbdiypQp8eijj0afPn3i/PPPj4kTJ8add94Zl1xySfTu3TvOOeecjspaVj/+8Y9jyZIl8ctf/jLq6upW27/ddtvFT37ykzbb/vKXv6xxubVnn302jjvuuLjllltir732Wus9r7nmmrjiiivWOzsAAAAAANBzrVO5c9lll8Xtt98e48ePj1/96ldxxBFHxIknnhi//vWv44Ybbogjjjgievfu3VFZV/PehMzixYtjyJAhrdsXL14co0ePft9zx4wZE88880x897vfjd122y1yuVyb/X369IltttmmzbaKitW/XYsWLYpDDjkkTjnllDj55JPf954XXXRRnHvuua2vm5ubY9iwYe97DgAAAAB4bg4A/2qdyp0f/ehHcdddd8UhhxwSzz//fOy0007x7rvvxnPPPbdaOdIZRowYEYMHD47HHnustcxpbm6O2bNnxxe/+MX3PXfrrbeOG264IcaNGxe9e/eOW265ZZ3vv3Llyjj00ENj++23j//zf/7PBx7ft2/f6Nu37zrfB4Cuo6FpQUnnjRoxvMxJAAAAAOip1qnc+fOf/xy77rprRETsuOOO0bdv3zjnnHM6rNhZvnx5vPzyy62vm5qaYu7cuTFw4MAYPnx45HK5OPvss+Oqq66KkSNHxogRI+LSSy+NoUOHxsSJEz/w+ttuu2088cQTMW7cuKioqIgbb7xxnfJ9/vOfj1dffTUee+yx+Otf/9q6feDAgdGnT591uhY9T83K6SWdN79yUpmTAKTJs3oAAEiRCRwAymGdyp2WlpY2pUVFRUX079+/7KHeM2fOnNhvv/1aX7+3pNnkyZNj6tSpERFx/vnnx4oVK+K0006LpUuXxt577x0PP/xwVFZWtuse2223XTz++OOtEzw33HBDu/M99dRTsXDhwqitrW2z/b3CCADoepRCAACUg5IGgCzlisVisb0H9+rVKw444IDWpcV++tOfxsc//vHYaKON2hx37733ljdlN9Xc3BzV1dWxbNmyqKqqyjpOl1Jz4QNZR+iyTO5AmizLlj7lDgAA/0q5A7B+/Hf2mrW3N1inyZ3Jkye3eX3ssceWlq6HKxQKUSgUoqWlJesoAEA7mfgBAOielDQApGidyp0777yzo3L0KPl8PvL5fGsDBwAAAAAA0F7rVO4AAKVpaFpQ0nmWc0ufiR8AAACg3JQ7AABdkFIIAGDdWF4NgJ5EuQMAXVipEz8Rpn4AAAAAuivlDgAAAABlZ5IGADqOcgcAoBuxnBsAAAB0f8odAAAAAACgJOuzpDylU+5koFAoRKFQiJaWlqyjANCNlfqXK8/q6ZmyWDbFtBAApMHyagDQ9Sh3MpDP5yOfz0dzc3NUV1dnHQcAAABIiLIFAOiVdQAAAAAAAADaz+QOAACZKPW3ji3nBgAAQE+n3AEAIClKIQC6kvVZIs3/NwEApVLuAABtNDQtKOm8USOGlzkJlFdnP5/AD+wA+CCenQMAlEq5AwAAHcCEEUA2FCYAQE+g3AEAysLEDwBQTkoaAIC1U+5koFAoRKFQiJaWlqyjAADQxaTyw0wTRgAAANlR7mQgn89HPp+P5ubmqK6uzjoOAAB0Gg8eh9V19jKOqZTIAACsnXIHAMiU5dwgTVn8cNhzjFgXikQAALoz5Q4AANCtKYXKqyd8P1N5jyZwAAB6LuUOAADAGnT3H5wrIsqvJ7xHAAC6BuUOAABAD6SIAACAdPXKOgAAAAAAAADtZ3IHElOzcnpJ582vnFTmJADZamhaUNJ5o0YML3MSAAAAgM5lcgcAAAAAACAhJncAgB7FxA8AAACQOpM7GSgUClFbWxt1dXVZRwEAAAAAABKj3MlAPp+PxsbGqK+vzzoKAAAAAACQGMuyAQC0g+XcAAAAgK7C5A4AAAAAAEBCTO4AAHQgEz8AAABAuZncAQAAAAAASIhyBwAAAAAAICGWZQMA6IIs5wYAAACsjckdAAAAAACAhCh3AAAAAAAAEqLcAQAAAAAASIhyJwOFQiFqa2ujrq4u6ygAAAAAAEBiKrIO0BPl8/nI5/PR3Nwc1dXVWccBALqRhqYFJZ03asTwMicBAAAAOorJHQAAAAAAgISY3AEAoOSJnwhTPwAAANDZTO4AAAAAAAAkxOQO9BA1K6eXdN78ykllTgIAAAAAwPpQ7gAAsF5KXdLNcm4AAABQGsuyAQAAAAAAJES5AwAAAAAAkBDLsgEAkAnLuQEAAEBplDsAACRFKQQAAEBPZ1k2AAAAAACAhCh3AAAAAAAAEmJZNgAAeoRSl3MrlWXgAAAA6CgmdzJQKBSitrY26urqso4CAAAAAAAkRrmTgXw+H42NjVFfX591FAAAAAAAIDHKHQAAAAAAgIQodwAAAAAAABJSkXUAAADojhqaFpR03qgRw8ucBAAAgO5GuQMAAAAAAD1cqb+gRjaUOwAA0IWY+AEAAOCDKHcAAKAbUAoBAAD0HMod4H3VrJxe0nnzKyeVOQkA0BGUQgAAAOnplXUAAAAAAAAA2s/kDgAA0GnW5yGtpoUAAAD+yeQOAAAAAABAQkzuAAAA62x9JnAAAABYPyZ3AAAAAAAAEqLcAQAAAAAASIhl2QAAgCSUuhTcqBHDy5wEAAAgW8odAACgW1MKAQAA3Y1yBwAAYA2UQgAApKjUv8eSFs/cyUChUIja2tqoq6vLOgoAAAAAAJAYkzsZyOfzkc/no7m5Oaqrq7OOAwAAlJGJHwAAoKOZ3AEAAAAAAEiIyR0AAIAuwMQPAADQXsodAACAhCmFAACg57EsGwAAAAAAQEKUOwAAAAAAAAmxLBsAAEAPZDk3AICurdS/r9EzKHeADlGzcnpJ582vnFTmJAAAlJNSCAAAsqfcAQAAoMN19m+eKpMAAOjOlDsAAAB0O+tTJimGAADo6pQ7AAAA8C8sPQcAQFen3AEAAIAMKZMAAFhXvbIOAAAAAAAAQPuZ3AEAAAAAgA+wPs/0g3JT7gAAAEAZ+IEPAACdRbkDAAAACersMskzfgAAug7P3AEAAAAAAEiIyR0AAADgA5U6KWTiBwCg/JQ7QJdSs3J6SefNr5xU5iQAAEA5KIUA6Go8J4/uwLJsAAAAAAAACTG5AwAAAHQ5nf1b1aVOCq1PTtNJAOvHBA49mXIHAAAA6PH8gBAgOz6DYd0pdwAAAAB6gM5+/pHnLQFAx1HuAAAAAGRA+QEAlEq5k4FCoRCFQiFaWlqyjgIAAAAkprOXL7JcEtBePi+g8yh3MpDP5yOfz0dzc3NUV1dnHQcAAACgx+rsH0abvOo6TM8BKVPuAAAAANBl+M1/urpU/jfa2c/LAjqXcgcAAAAAurHuPqGijFgz3xfo3pQ7AAAAANDFpfSD+pSyAqRKuQMAAAAArEZJA9B1KXcAAAAAoJMoTAAoB+UO0C3UrJxe0nnzKyeVOQkAAAAAQMfqlXUAAAAAAAAA2k+5AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQpQ7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAmpyDoAQJZqVk4v6bz5lZPKnAQAAAAAoH1M7gAAAAAAACREuQMAAAAAAJAQy7IBlKDU5dwiLOkGAAAAAKwfkzsAAAAAAAAJUe4AAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQpQ7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEIqsg4A0NPUrJxe0nnzKyeVOQkAAAAAkCKTOwAAAAAAAAnpkeXOlClTYvTo0VnHAAAAAAAAWGfJlzszZ86Mgw8+OIYOHRq5XC5mzJix3td88sknI5fLxdKlS1fbV1NTEzfeeON63wMAAAAAAKAUyZc7K1asiJ133jkKhULWUQAAAAAAADpc8uXOAQccEFdddVUcdthhJV/jlVdeia222irOOOOMKBaL7T5v6tSpkcvlVvuaMmVKyVkAAAAAAADeT/Llzvr63e9+F3vvvXdMmjQpbrnllsjlcu0+98gjj4yFCxe2fv3gBz+IioqK2GuvvTowMQAAAAAA0JNVZB0gS7/61a/ioIMOiosvvji+/OUvr7b/Qx/60Grb3nzzzdZ/7tevX/Tr1y8i/jn9k8/n4+qrr479999/jfd766234q233mp93dzcvL5vAehBalZOL+m8+ZWTypwEAAAAAMhSjy13FixYEPvvv3/8x3/8R5x99tlrPOYXv/hFbLzxxm22jRs3brXjli1bFgcddFAceOCB8ZWvfGWt97zmmmviiiuuWJ/YAAAAAABAD9djl2XbfPPN46Mf/Wj84Ac/WOsEzYgRI2KbbbZp81VR0bYPa2lpiSOPPDKqqqrijjvueN97XnTRRbFs2bLWr1dffbVs7wcAAAAAAOgZemy5069fv7j//vujsrIyJkyYEG+88UZJ1znnnHOioaEhZsyYEZWVle97bN++faOqqqrNFwAAAAAAwLpIvtxZvnx5zJ07N+bOnRsREU1NTTF37txYsGDBB5670UYbxQMPPBAVFRVxwAEHxPLly9fp3nfeeWfceuutcdttt0Uul4tFixbFokWL1vk6AAAAAAAA7ZV8uTNnzpwYM2ZMjBkzJiIizj333BgzZkxcdtll7Tq/f//+8dBDD0WxWIwDDzwwVqxY0e57P/XUU9HS0hKHHHJIDBkypPXr+uuvL+m9AAAAAAAAfJBcsVgsZh2ip2pubo7q6upYtmyZJdr+Tc2FD2QdAbqN+ZWTso4AAAAAAG1NWZZ1gi6pvb1B8pM7KSoUClFbWxt1dXVZRwEAAAAAABKj3MlAPp+PxsbGqK+vzzoKAAAAAACQGOUOAAAAAABAQiqyDgBAx6pZOb2k8zyrBwAAAAC6JpM7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEKUOxkoFApRW1sbdXV1WUcBAAAAAAASkysWi8WsQ/RUzc3NUV1dHcuWLYuqqqqs43QpNRc+kHUEoETzKydlHQEAAACArm7KsqwTdEnt7Q1M7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAAkRLkDAAAAAACQEOVOBgqFQtTW1kZdXV3WUQAAAAAAgMQodzKQz+ejsbEx6uvrs44CAAAAAAAkpiLrAAB0LzUrp5d03vzKSWVOAgAAAADdk8kdAAAAAACAhCh3AAAAAAAAEqLcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIRUZB0AACIialZOL+m8+ZWTypwEAAAAALo2kzsAAAAAAAAJUe5koFAoRG1tbdTV1WUdBQAAAAAASIxyJwP5fD4aGxujvr4+6ygAAAAAAEBilDsAAAAAAAAJUe4AAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQiqyDgAA66Nm5fSSzptfOanMSQAAAACgc5jcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIR45g4APZJn9QAAAACQKpM7GSgUClFbWxt1dXVZRwEAAAAAABKTKxaLxaxD9FTNzc1RXV0dy5Yti6qqqqzjdCk1Fz6QdQSAsjLxAwAAAPAvpizLOkGX1N7ewOQOAAAAAABAQpQ7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBCKrIOAAA9Qc3K6SWdN79yUpmTAAAAAJA6kzsAAAAAAAAJUe4AAAAAAAAkRLmTgUKhELW1tVFXV5d1FAAAAAAAIDHKnQzk8/lobGyM+vr6rKMAAAAAAACJUe4AAAAAAAAkpCLrAADA2tWsnF7yufMrJ5UxCQAAAABdhckdAAAAAACAhCh3AAAAAAAAEqLcAQAAAAAASIhn7gBAN1Xq83o8qwcAAACgazO5AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJqcg6AADQPdSsnF7SefMrJ5U5CQAAAED3ZnIHAAAAAAAgISZ3AIBMmfgBAAAAWDfKnQwUCoUoFArR0tKSdRQAWE2pZQsAAAAAncOybBnI5/PR2NgY9fX1WUcBAAAAAAASY3IHAEiS5dwAAACAnsrkDgAAAAAAQEKUOwAAAAAAAAmxLBsA0KN09nJulo8DAAAAys3kDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQpQ7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEIqsg4AAJCCmpXTu/X95ldO6tT7AQAAAKUzuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAAkRLkDAAAAAACQEOVOBgqFQtTW1kZdXV3WUQAAAAAAgMRUZB2gJ8rn85HP56O5uTmqq6uzjgMAsF5qVk4v6bz5lZPKnAQAAAB6BuUOAAAlFzQAAABA57MsGwAAAAAAQEKUOwAAAAAAAAmxLBsAAD2CZwMBAADQXZjcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIQodwAAAAAAABJSkXUAAABYFzUrp2cdAQAAADJlcgcAAAAAACAhyh0AAAAAAICEKHcAAAAAAAASotwBAAAAAABISEXWAQAA6JlqVk7POgIZWJ8/9/mVk8qYBAAAIF3KHQAAeB+dXUKVWmCUmlNhAgAAkB7LsgEAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAAkpCLrAAAAAAAAQJpqVk4v6bz55Y3R45jcAQAAAAAASIjJHQAA6EJK/a03AAAAeg7lDgAA9GAlL6FQOanMSQAAAGgvy7IBAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQjxzBwAASILnAwEAAPyTyR0AAAAAAICEmNwBAADWWalTNCnp7PdowggAAGgvkzsAAAAAAAAJMbkDAAB0az1hyggAAOhZTO4AAAAAAAAkRLkDAAAAAACQEMuyAQAAdAGlLh83v3JSmZMAAABdnckdAAAAAACAhJjcAQAASJiJnzUr9fsS0f2/NwAApK9LT+7MnDkzDj744Bg6dGjkcrmYMWPGascUi8W47LLLYsiQIdGvX78YP358vPTSS22Oef311+OYY46JqqqqGDBgQJx88smxfPny9713TU1N3HjjjattnzJlSowePXo93hUAAAAAAEDpunS5s2LFith5552jUCis9Zjrrrsubr755rjtttti9uzZsdFGG8WECRNi5cqVrcccc8wx8fvf/z4effTRuP/++2PmzJlx2mmndcZbAAAAAAAAKKsuvSzbAQccEAcccMBa9xeLxbjxxhvjkksuiUMPPTQiIu66664YNGhQzJgxI4466qiYN29ePPzww1FfXx+77bZbRER885vfjE9/+tNx/fXXx9ChQ9crYy6XW23bhz/84Zg/f/56XRcAAAAAAGBNuvTkzgdpamqKRYsWxfjx41u3VVdXx9ixY2PWrFkRETFr1qwYMGBAa7ETETF+/Pjo1atXzJ49e70zLFy4sPXr5Zdfjm222Sb22Wef9b4uAAAAAADAmnTpyZ0PsmjRooiIGDRoUJvtgwYNat23aNGi2GKLLdrsr6ioiIEDB7YeszYXXHBBXHLJJW22vf3221FbW9v6evDgwRHxzymiww8/PKqrq+P2229f4/XeeuuteOutt1pfNzc3v+/9AQAAerqaldOzjgAAAF1O0uVOR/vKV74SJ5xwQpttN998c8ycOXO1Y7/61a/GrFmzYs6cOdGvX781Xu+aa66JK664oiOiAgAAkKhSC6z5lZPKnAQAgFQkvSzbe1MzixcvbrN98eLFrfsGDx4cS5YsabP/3Xffjddff731mLXZbLPNYptttmnzNXDgwNWO++///u/4xje+Effdd19sueWWa73eRRddFMuWLWv9evXVV9v1PgEAAAAAAN6T9OTOiBEjYvDgwfHYY4/F6NGjI+KfS53Nnj07vvjFL0ZExB577BFLly6N3/72t7HrrrtGRMTjjz8eq1atirFjx653hlmzZsUpp5wSt99+e+y+++7ve2zfvn2jb9++631PAACArJgyAQCA7HXpcmf58uXx8ssvt75uamqKuXPnxsCBA2P48OGRy+Xi7LPPjquuuipGjhwZI0aMiEsvvTSGDh0aEydOjIiIHXbYIT71qU/FqaeeGrfddlu88847ccYZZ8RRRx0VQ4cOXa98ixYtisMOOyyOOuqomDBhQuszfHr37h2bb775el0bAACgI3X2s2w8O6f8Ovt7qqADAOg6unS5M2fOnNhvv/1aX5977rkRETF58uSYOnVqREScf/75sWLFijjttNNi6dKlsffee8fDDz8clZWVred9//vfjzPOOCM+8YlPRK9eveLwww+Pm2++eb3zvfDCC7F48eKYNm1aTJs2rXX7hz/84Zg/f/56Xx8AAIDOZzoJAICuLlcsFotZh+ipmpubo7q6OpYtWxZVVVVZx+lSai58IOsIAAAA66TUcieVqSblFQCwJiX/Ysy1B5Y5SffQ3t6gVydm4v8pFApRW1sbdXV1WUcBAAAAAAASo9zJQD6fj8bGxqivr886CgAAAAAAkBjlDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBCKrIO0BMVCoUoFArR0tKSdRQAAABol5qV00s6b37lpDInAQBAuZOBfD4f+Xw+mpubo7q6Ous4AAAAQIlKLb0iFF8AQOmUOwAAAAAA0E2Ytu0ZlDsAAABAl+MHUwAAa6fcAQAAAACALmZ9lv6k+1PuAAAAQBn4AQy0ZfoKADqOcgcAAAAAoIMpPIFyUu4AAAAAHcZEEwBA+fXKOgAAAAAAAADtZ3InA4VCIQqFQrS0tGQdBQAAAEiMpZ0A6AimbdOi3MlAPp+PfD4fzc3NUV1dnXUcAAAAoAdQCgFA96HcAQAAALoNBQYA0BModwAAAACAHkcZDKRMuQMAAAD0eJ4zAACkRLkDAAAAAEBErF/ZXepUkykqWHfKHQAAAADWylTTmvlhNF2df3ehe1PuAAAAAADJUmIAPZFyBwAAACADfiBdXiZpAOhJlDsZKBQKUSgUoqWlJesoAAAAAHRzii+A7qdX1gF6onw+H42NjVFfX591FAAAAAAAIDEmdwAAAACgi7OMHwD/yuQOAAAAAABAQkzuAAAAANBjmYgB2svzq+hKTO4AAAAAAAAkxOQOAAAAAF2GSRq6us7+36h/J8rP95TuwOQOAAAAAABAQkzuAAAAAEAnMTEAPY9/7+kIyh0AAAAAYDUeHg/QdVmWDQAAAAAAICEmdwAAAACAzFm6CqD9lDsZKBQKUSgUoqWlJesoAAAAAABloaCDzqPcyUA+n498Ph/Nzc1RXV2ddRwAAAAAKBs/4AfoeJ65AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJqcg6AAAAAAAArKualdOzjgCZMbkDAAAAAACQEOUOAAAAAABAQpQ7AAAAAAAACVHuAAAAAAAAJES5k4FCoRC1tbVRV1eXdRQAAAAAACAxyp0M5PP5aGxsjPr6+qyjAAAAAAAAiVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQpQ7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAlR7mSgUChEbW1t1NXVZR0FAAAAAABIjHInA/l8PhobG6O+vj7rKAAAAAAAQGKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQpQ7AAAAAAAACanIOkBPViwWIyKiubk54yRdz6q33sw6AgAAAAAAHcTPxdfsve/Le/3B2ih3MvTGG29ERMSwYcMyTgIAAAAAAJ2n+sasE3Rtb7zxRlRXV691f674QfUPHWbVqlXx2muvxcYbbxy5XC7rOF1Gc3NzDBs2LF599dWoqqrKOg7QDfmcATqazxmgo/mcATqazxmgI/mMWbtisRhvvPFGDB06NHr1WvuTdUzuZKhXr17xoQ99KOsYXVZVVZV/sYEO5XMG6Gg+Z4CO5nMG6Gg+Z4CO5DNmzd5vYuc9a699AAAAAAAA6HKUOwAAAAAAAAlR7tDl9O3bNy6//PLo27dv1lGAbsrnDNDRfM4AHc3nDNDRfM4AHclnzPrLFYvFYtYhAAAAAAAAaB+TOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDtkolAoRE1NTVRWVsbYsWPjN7/5zfse/6Mf/Si23377qKysjFGjRsWDDz7YSUmBVK3L58y3vvWt+NjHPhabbLJJbLLJJjF+/PgP/FwCWNe/z7zn7rvvjlwuFxMnTuzYgEDy1vVzZunSpZHP52PIkCHRt2/f2Hbbbf23E/C+1vVz5sYbb4ztttsu+vXrF8OGDYtzzjknVq5c2UlpgZTMnDkzDj744Bg6dGjkcrmYMWPGB57z5JNPxi677BJ9+/aNbbbZJqZOndrhOVOm3KHT3XPPPXHuuefG5ZdfHs8880zsvPPOMWHChFiyZMkaj//Vr34VRx99dJx88snx7LPPxsSJE2PixInx/PPPd3JyIBXr+jnz5JNPxtFHHx1PPPFEzJo1K4YNGxaf/OQn4y9/+UsnJwdSsa6fM++ZP39+nHfeefGxj32sk5ICqVrXz5m333479t9//5g/f378+Mc/jhdffDG+9a1vxZZbbtnJyYFUrOvnzPTp0+PCCy+Myy+/PObNmxff+c534p577omvfvWrnZwcSMGKFSti5513jkKh0K7jm5qa4sADD4z99tsv5s6dG2effXaccsop8bOf/ayDk6YrVywWi1mHoGcZO3Zs1NXVxS233BIREatWrYphw4bFmWeeGRdeeOFqxx955JGxYsWKuP/++1u37b777jF69Oi47bbbOi03kI51/Zz5dy0tLbHJJpvELbfcEscff3xHxwUSVMrnTEtLS+yzzz5x0kknxS9+8YtYunRpu357DeiZ1vVz5rbbbov//M//jBdeeCE22GCDzo4LJGhdP2fOOOOMmDdvXjz22GOt27785S/H7Nmz4+mnn+603EB6crlc3Hfffe+7esEFF1wQDzzwQJtf6D/qqKNi6dKl8fDDD3dCyvSY3KFTvf322/Hb3/42xo8f37qtV69eMX78+Jg1a9Yaz5k1a1ab4yMiJkyYsNbjgZ6tlM+Zf/fmm2/GO++8EwMHDuyomEDCSv2cufLKK2OLLbaIk08+uTNiAgkr5XPmJz/5Seyxxx6Rz+dj0KBBseOOO8bVV18dLS0tnRUbSEgpnzN77rln/Pa3v21duu2Pf/xjPPjgg/HpT3+6UzID3ZufAa+7iqwD0LP87W9/i5aWlhg0aFCb7YMGDYoXXnhhjecsWrRojccvWrSow3IC6Srlc+bfXXDBBTF06NDV/lIBEFHa58zTTz8d3/nOd2Lu3LmdkBBIXSmfM3/84x/j8ccfj2OOOSYefPDBePnll+P000+Pd955Jy6//PLOiA0kpJTPmUmTJsXf/va32HvvvaNYLMa7774bX/jCFyzLBpTF2n4G3NzcHP/4xz+iX79+GSXrukzuAMC/uPbaa+Puu++O++67LyorK7OOA3QDb7zxRhx33HHxrW99KzbbbLOs4wDd1KpVq2KLLbaIO+64I3bdddc48sgj4+KLL7aUNVA2Tz75ZFx99dVx6623xjPPPBP33ntvPPDAA/G1r30t62gAPZLJHTrVZpttFr17947Fixe32b548eIYPHjwGs8ZPHjwOh0P9GylfM685/rrr49rr702fv7zn8dOO+3UkTGBhK3r58wrr7wS8+fPj4MPPrh126pVqyIioqKiIl588cXYeuutOzY0kJRS/j4zZMiQ2GCDDaJ3796t23bYYYdYtGhRvP3229GnT58OzQykpZTPmUsvvTSOO+64OOWUUyIiYtSoUbFixYo47bTT4uKLL45evfwOOVC6tf0MuKqqytTOWvjUpVP16dMndt111zYP31u1alU89thjsccee6zxnD322KPN8RERjz766FqP5/9r7/5dqvrjMIA/bg0OEjSIP8ghaJBIEAUbwskhbpPQltRUg150SIyrBVFiYBQIgjiIg0RTi2BLf4HDBTe9IAii0KoOLjZ1QeI7XOGrHnq94A7nXO7l814eDuc5Hw782y6SM0ny8ePHvHv3LhsbG+nt7b2MpQIF1WjO3L17N1tbW6lWq/XP48ePMzg4mGq1mo6OjstcPlAAF7meefDgQWq1Wr08TpLt7e20trYqdoC/XCRnTk5O/ipw/hTKZ2dn/99igX+Ce8CNs3OHSzcxMZGRkZH09vamr68vnz9/zvHxcZ49e5Ykefr0adra2jI7O5skKZfLefjwYebn5/Po0aN8/fo1m5ubWVpausoxgGus0ZyZm5vLzMxM1tbWcvv27fo7vZqbm9Pc3HxlcwDXVyM5c+PGjXR3d5/7fUtLS5L8dR7gj0avZ16+fJmFhYWUy+WMjo5mZ2cnHz58yNjY2FWOAVxjjeZMqVTKp0+f0tPTk/7+/tRqtUxPT6dUKp3bNQiQJEdHR6nVavXj3d3dVKvV3Lx5M52dnZmamsr+/n5WV1eTJC9evMjCwkJevXqV58+f5+fPn/n27VvW19evaoRrT7nDpXvy5El+/fqVmZmZHB4e5v79+9nY2Ki/MGtvb+/ckyADAwNZW1tLpVLJ69evc+fOnXz//t3NEOA/NZozi4uLOT09zfDw8Ln/efPmTd6+fXuZSwcKotGcAWhUoznT0dGRHz9+ZHx8PPfu3UtbW1vK5XImJyevagTgmms0ZyqVSpqamlKpVLK/v59bt26lVCrl/fv3VzUCcI1tbm5mcHCwfjwxMZEkGRkZycrKSg4ODrK3t1f/vqurK+vr6xkfH8+XL1/S3t6e5eXlDA0NXfrai6LpzL5JAAAAAACAwvA4IQAAAAAAQIEodwAAAAAAAApEuQMAAAAAAFAgyh0AAAAAAIACUe4AAAAAAAAUiHIHAAAAAACgQJQ7AAAAAAAABaLcAQAAAAAAKBDlDgAAAAAAQIEodwAAAAAAAApEuQMAAAAAAFAgyh0AAAAAAIAC+Q1Id72CuMmywAAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -420,7 +430,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -448,8 +458,10 @@ " pid_bin_centers.append(0.5*(bin_edges[1:] + bin_edges[:-1]))\n", " \n", " ax.hist(pid_list, bins=100, log=True, stacked=True, label=(\"noise\", \"neutrino\", \"muon\"))\n", - " ax.set(ylabel='Rate',yscale='log')\n", - " ax.yaxis.set_major_formatter(ticker.EngFormatter(unit='Hz'))\n", + " ax.set(yscale='log')\n", + " ax.set_xlim(-0.001,1.001)\n", + " #ax.set(ylabel='Rate',yscale='log')\n", + " #ax.yaxis.set_major_formatter(ticker.EngFormatter(unit='Hz'))\n", " #for i, _ in enumerate(pids):\n", " # plt.errorbar(pid_bin_centers[i], pid_histlist[i], yerr = stds[i], fmt=f\".{color[i]}\")\n", " plt.title(pred.replace(\"_\",\" \")[4:])\n", diff --git a/multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPrediction2D.ipynb b/multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPrediction2D.ipynb index 303d358..4be3d19 100644 --- a/multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPrediction2D.ipynb +++ b/multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPrediction2D.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -44,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -58,7 +58,7 @@ }, { "cell_type": "code", - "execution_count": 168, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -79,7 +79,7 @@ "Length: 29349, dtype: int64" ] }, - "execution_count": 168, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -93,7 +93,7 @@ }, { "cell_type": "code", - "execution_count": 122, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -219,7 +219,7 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -239,7 +239,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/groups/icecube/qgf305/workspace/analyses/multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPrediction2D.ipynb Cell 5\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m sns\u001b[39m.\u001b[39;49mhistplot(\n\u001b[1;32m 2\u001b[0m feature_data, x\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mpid_noise_pred\u001b[39;49m\u001b[39m\"\u001b[39;49m, y\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mpid_muon_pred\u001b[39;49m\u001b[39m\"\u001b[39;49m, hue\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mpid\u001b[39;49m\u001b[39m\"\u001b[39;49m,\n\u001b[1;32m 3\u001b[0m bins\u001b[39m=\u001b[39;49m\u001b[39m50\u001b[39;49m, cbar\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m, log_scale\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m\n\u001b[1;32m 4\u001b[0m )\n", + "\u001b[1;32m/groups/icecube/qgf305/workspace/analyses/multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPrediction2D.ipynb Cell 8\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m sns\u001b[39m.\u001b[39;49mhistplot(\n\u001b[1;32m 2\u001b[0m feature_data, x\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mpid_noise_pred\u001b[39;49m\u001b[39m\"\u001b[39;49m, y\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mpid_muon_pred\u001b[39;49m\u001b[39m\"\u001b[39;49m, hue\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mpid\u001b[39;49m\u001b[39m\"\u001b[39;49m,\n\u001b[1;32m 3\u001b[0m bins\u001b[39m=\u001b[39;49m\u001b[39m50\u001b[39;49m, cbar\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m, log_scale\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m\n\u001b[1;32m 4\u001b[0m )\n", "File \u001b[0;32m~/anaconda3/envs/graphnet/lib/python3.8/site-packages/seaborn/distributions.py:1450\u001b[0m, in \u001b[0;36mhistplot\u001b[0;34m(data, x, y, hue, weights, stat, bins, binwidth, binrange, discrete, cumulative, common_bins, common_norm, multiple, element, fill, shrink, kde, kde_kws, line_kws, thresh, pthresh, pmax, cbar, cbar_ax, cbar_kws, palette, hue_order, hue_norm, color, log_scale, legend, ax, **kwargs)\u001b[0m\n\u001b[1;32m 1432\u001b[0m p\u001b[39m.\u001b[39mplot_univariate_histogram(\n\u001b[1;32m 1433\u001b[0m multiple\u001b[39m=\u001b[39mmultiple,\n\u001b[1;32m 1434\u001b[0m element\u001b[39m=\u001b[39melement,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1445\u001b[0m \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs,\n\u001b[1;32m 1446\u001b[0m )\n\u001b[1;32m 1448\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m-> 1450\u001b[0m p\u001b[39m.\u001b[39;49mplot_bivariate_histogram(\n\u001b[1;32m 1451\u001b[0m common_bins\u001b[39m=\u001b[39;49mcommon_bins,\n\u001b[1;32m 1452\u001b[0m common_norm\u001b[39m=\u001b[39;49mcommon_norm,\n\u001b[1;32m 1453\u001b[0m thresh\u001b[39m=\u001b[39;49mthresh,\n\u001b[1;32m 1454\u001b[0m pthresh\u001b[39m=\u001b[39;49mpthresh,\n\u001b[1;32m 1455\u001b[0m pmax\u001b[39m=\u001b[39;49mpmax,\n\u001b[1;32m 1456\u001b[0m color\u001b[39m=\u001b[39;49mcolor,\n\u001b[1;32m 1457\u001b[0m legend\u001b[39m=\u001b[39;49mlegend,\n\u001b[1;32m 1458\u001b[0m cbar\u001b[39m=\u001b[39;49mcbar,\n\u001b[1;32m 1459\u001b[0m cbar_ax\u001b[39m=\u001b[39;49mcbar_ax,\n\u001b[1;32m 1460\u001b[0m cbar_kws\u001b[39m=\u001b[39;49mcbar_kws,\n\u001b[1;32m 1461\u001b[0m estimate_kws\u001b[39m=\u001b[39;49mestimate_kws,\n\u001b[1;32m 1462\u001b[0m \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs,\n\u001b[1;32m 1463\u001b[0m )\n\u001b[1;32m 1465\u001b[0m \u001b[39mreturn\u001b[39;00m ax\n", "File \u001b[0;32m~/anaconda3/envs/graphnet/lib/python3.8/site-packages/seaborn/distributions.py:764\u001b[0m, in \u001b[0;36m_DistributionPlotter.plot_bivariate_histogram\u001b[0;34m(self, common_bins, common_norm, thresh, pthresh, pmax, color, legend, cbar, cbar_ax, cbar_kws, estimate_kws, **plot_kws)\u001b[0m\n\u001b[1;32m 762\u001b[0m all_data \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mcomp_data\u001b[39m.\u001b[39mdropna()\n\u001b[1;32m 763\u001b[0m \u001b[39mif\u001b[39;00m common_bins:\n\u001b[0;32m--> 764\u001b[0m estimator\u001b[39m.\u001b[39;49mdefine_bin_params(\n\u001b[1;32m 765\u001b[0m all_data[\u001b[39m\"\u001b[39;49m\u001b[39mx\u001b[39;49m\u001b[39m\"\u001b[39;49m],\n\u001b[1;32m 766\u001b[0m all_data[\u001b[39m\"\u001b[39;49m\u001b[39my\u001b[39;49m\u001b[39m\"\u001b[39;49m],\n\u001b[1;32m 767\u001b[0m all_data\u001b[39m.\u001b[39;49mget(\u001b[39m\"\u001b[39;49m\u001b[39mweights\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39mNone\u001b[39;49;00m),\n\u001b[1;32m 768\u001b[0m )\n\u001b[1;32m 769\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 770\u001b[0m common_norm \u001b[39m=\u001b[39m \u001b[39mFalse\u001b[39;00m\n", "File \u001b[0;32m~/anaconda3/envs/graphnet/lib/python3.8/site-packages/seaborn/_statistics.py:324\u001b[0m, in \u001b[0;36mHistogram.define_bin_params\u001b[0;34m(self, x1, x2, weights, cache)\u001b[0m\n\u001b[1;32m 320\u001b[0m discrete \u001b[39m=\u001b[39m discrete[i]\n\u001b[1;32m 322\u001b[0m \u001b[39m# Define the bins for this variable\u001b[39;00m\n\u001b[0;32m--> 324\u001b[0m bin_edges\u001b[39m.\u001b[39mappend(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_define_bin_edges(\n\u001b[1;32m 325\u001b[0m x, weights, bins, binwidth, binrange, discrete,\n\u001b[1;32m 326\u001b[0m ))\n\u001b[1;32m 328\u001b[0m bin_kws \u001b[39m=\u001b[39m \u001b[39mdict\u001b[39m(bins\u001b[39m=\u001b[39m\u001b[39mtuple\u001b[39m(bin_edges))\n\u001b[1;32m 330\u001b[0m \u001b[39mif\u001b[39;00m cache:\n", @@ -253,7 +253,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPredictionMCRD.ipynb b/multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPredictionMCRD.ipynb new file mode 100644 index 0000000..a022fe1 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPredictionMCRD.ipynb @@ -0,0 +1,702 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "plotting pid as a function of prediction" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/groups/icecube/qgf305/anaconda3/envs/graphnet/lib/python3.8/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.ticker as ticker\n", + "import numpy as np\n", + "from torchmetrics import ConfusionMatrix\n", + "import torch\n", + "from sklearn.preprocessing import (QuantileTransformer, quantile_transform)\n", + "import itertools" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "path_to_mc = \"/groups/icecube/peter/storage/Multiclassification/Real/last_one_lvl3MC/dynedge_pid_Real_run_21.5_mill_equal_frac_/results_first.csv\"\n", + "mc_data = pd.read_csv(path_to_mc, index_col=[0])\n", + "path_to_rd = \"/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/Inference/pid_Leon_RD_results_first.csv\"\n", + "rd_data = pd.read_csv(path_to_rd, index_col=[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "preds = [\"pid_noise_pred\",\"pid_muon_pred\",\"pid_neutrino_pred\"]\n", + "pids = [1,12,13]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "unique particle ID's and their count: \n", + " pid_noise_pred\n", + "pid \n", + "1.0 2474861\n", + "12.0 2475330\n", + "13.0 2474809\n", + "\n", + "data:\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pid_noise_predpid_muon_predpid_neutrino_predpidevent_no
01.000000e+000.0000000.000000e+001.023434375.0
13.946079e-221.0000003.906106e-0713.070953235.0
21.827151e-201.0000001.306228e-0713.097961265.0
33.665486e-010.0229936.104581e-0112.033636682.0
42.773106e-010.0172707.054196e-0112.053035643.0
..................
74249951.000000e+000.0000000.000000e+001.066993636.0
74249969.246089e-110.9160268.397368e-0213.058567439.0
74249976.353963e-010.0087363.558680e-0112.081515634.0
74249988.316677e-030.6507603.409231e-0112.0221130.0
74249991.459401e-090.7078562.921439e-0113.092196571.0
\n", + "

7425000 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " pid_noise_pred pid_muon_pred pid_neutrino_pred pid event_no\n", + "0 1.000000e+00 0.000000 0.000000e+00 1.0 23434375.0\n", + "1 3.946079e-22 1.000000 3.906106e-07 13.0 70953235.0\n", + "2 1.827151e-20 1.000000 1.306228e-07 13.0 97961265.0\n", + "3 3.665486e-01 0.022993 6.104581e-01 12.0 33636682.0\n", + "4 2.773106e-01 0.017270 7.054196e-01 12.0 53035643.0\n", + "... ... ... ... ... ...\n", + "7424995 1.000000e+00 0.000000 0.000000e+00 1.0 66993636.0\n", + "7424996 9.246089e-11 0.916026 8.397368e-02 13.0 58567439.0\n", + "7424997 6.353963e-01 0.008736 3.558680e-01 12.0 81515634.0\n", + "7424998 8.316677e-03 0.650760 3.409231e-01 12.0 221130.0\n", + "7424999 1.459401e-09 0.707856 2.921439e-01 13.0 92196571.0\n", + "\n", + "[7425000 rows x 5 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## transform monte carlo data\n", + "# remove anti\n", + "mc_data['pid'] = mc_data['pid'].apply(abs)\n", + "# make all neutrinos the same class; to match training classes\n", + "mc_data.loc[mc_data['pid']==14, \"pid\"]=12\n", + "mc_data.loc[mc_data['pid']==16, \"pid\"]=12\n", + "\n", + "print(\"unique particle ID's and their count: \\n\", mc_data[[\"pid_noise_pred\",\"pid\"]].groupby(\"pid\").count())\n", + "print()\n", + "print(\"data:\")\n", + "mc_data" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "data = pd.DataFrame()\n", + "for pred in preds:\n", + " data[\"mc_\"+pred.split(\"_\")[1]] = mc_data[pred]\n", + " data[\"rd_\"+pred.split(\"_\")[1]] = rd_data[pred]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "num_bin = 50\n", + "bin_lims = np.linspace(0,1,num_bin+1)\n", + "bin_centers = 0.5*(bin_lims[:-1]+bin_lims[1:])\n", + "bin_widths = bin_lims[1:]-bin_lims[:-1]\n", + "\n", + "##computing the histograms\n", + "hist1, _ = np.histogram(data[\"mc_noise\"], bins=bin_lims)\n", + "hist2, _ = np.histogram(data[\"rd_noise\"], bins=bin_lims)\n", + "\n", + "##normalizing\n", + "hist1b = hist1/np.max(hist1)\n", + "hist2b = hist2/np.max(hist2)\n", + "\n", + "fig, (ax1,ax2) = plt.subplots(nrows = 1, ncols = 2, figsize=(25,7.5))\n", + "\n", + "ax1.bar(bin_centers, hist1, width = bin_widths, align = 'center')\n", + "ax1.bar(bin_centers, hist2, width = bin_widths, align = 'center', alpha = 0.5)\n", + "ax1.set_title('original')\n", + "ax1.set(ylabel='Rate',yscale='log')\n", + "ax1.yaxis.set_major_formatter(ticker.EngFormatter(unit='Hz'))\n", + "\n", + "ax2.bar(bin_centers, hist1b, width = bin_widths, align = 'center')\n", + "ax2.bar(bin_centers, hist2b, width = bin_widths, align = 'center', alpha = 0.5)\n", + "ax2.set_title('ampllitude-normalized')\n", + "ax2.set(ylabel='Rate',yscale='log')\n", + "ax2.yaxis.set_major_formatter(ticker.EngFormatter(unit='Hz'))\n", + "\n", + "plt.show()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist([data[\"rd_noise\"], data[\"mc_noise\"]], density=True, log=True, stacked=True, bins=50);" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "fig, axes = plt.subplots(3,1, figsize=(20,10))\n", + "for i, pred in enumerate(preds):\n", + " feature = pred.split(\"_\")[1]\n", + " prefix_list=[]\n", + " for prefix in itertools.product([\"rd_\", \"mc_\"], [feature]):\n", + " prefix_list.append(\"\".join(prefix))\n", + " axes[i].set_title(pred)\n", + " axes[i].hist(data[prefix_list], bins=50, stacked=True, log=True, label=prefix_list);\n", + " axes[i].legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "quantile = QuantileTransformer(output_distribution='normal')\n", + "data_trans = quantile.fit_transform(mc_data[[\"pid_noise_pred\"]])\n", + "plt.hist(data_trans,bins=50);" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "quantile = QuantileTransformer()\n", + "data_trans = quantile.fit_transform(rd_data[[\"pid_noise_pred\"]])\n", + "plt.hist(data_trans,bins=50);" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABncAAANECAYAAABiinpXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABZuUlEQVR4nOzdeZjVdd0//teBEQbFGcSFxaBBxWUSBXXCLcXCyNwwMxUX3CuP5pK55Ibmreat39Q83mqLYHek1Ve5yy3NjSyiIcXGBk1tCEuWyhtGMFyG8/ujr/NrAnQ4nJnPvGcej+ua6/J81ucZ8oTznNf7kysWi8UAAAAAAAAgCb2yDgAAAAAAAED7KXcAAAAAAAASotwBAAAAAABIiHIHAAAAAAAgIcodAAAAAACAhCh3AAAAAAAAEqLcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIQodwAAAGi3E044IWpqarKOAQAAPZpyBwAAAAAAICHKHQAAAAAAgIQodwAAAHqAFStWZB0BAAAoE+UOAADQLU2ZMiVyuVz84Q9/iGOPPTaqq6tj8803j0svvTSKxWK8+uqrceihh0ZVVVUMHjw4brjhhjbnT506NXK5XMyfP7/N9ieffDJyuVw8+eSTbbb/6Ec/il133TX69esXm222WRx77LHxl7/8pc0xJ5xwQvTv3z/+8pe/xMSJE6N///6x+eabx3nnnRctLS0f+J5qamrioIMOikceeSRGjx4dlZWVUVtbG/fee+8asz/11FNx+umnxxZbbBEf+tCHWvc/9NBD8bGPfSw22mij2HjjjePAAw+M3//+96vdb8aMGbHjjjtGZWVl7LjjjnHfffd9YEYAAKDjKXcAAIBu7cgjj4xVq1bFtddeG2PHjo2rrroqbrzxxth///1jyy23jK9//euxzTbbxHnnnRczZ84s6R5Tp06Nz33uc9G7d++45ppr4tRTT41777039t5771i6dGmbY1taWmLChAmx6aabxvXXXx/77rtv3HDDDXHHHXe0614vvfRSHHnkkXHAAQfENddcExUVFXHEEUfEo48+utqxp59+ejQ2NsZll10WF154YUREfO9734sDDzww+vfvH1//+tfj0ksvjcbGxth7773bFFmPPPJIHH744ZHL5eKaa66JiRMnxoknnhhz5swp6XsEAACUT0XWAQAAADrSRz/60bj99tsjIuK0006Lmpqa+PKXvxzXXHNNXHDBBRERcfTRR8fQoUPju9/9buyzzz7rdP133nknLrjggthxxx1j5syZUVlZGRERe++9dxx00EHxjW98I6644orW41euXBlHHnlkXHrppRER8YUvfCF22WWX+M53vhNf/OIXP/B+f/jDH+L//t//G5/5zGciIuLkk0+O7bffPi644ILYf//92xw7cODAeOyxx6J3794REbF8+fL40pe+FKecckqbMmny5Mmx3XbbxdVXX926/YILLohBgwbF008/HdXV1RERse+++8YnP/nJ+PCHP7xO3yMAAKC8TO4AAADd2imnnNL6z717947ddtstisVinHzyya3bBwwYENttt1388Y9/XOfrz5kzJ5YsWRKnn356a7ETEXHggQfG9ttvHw888MBq53zhC19o8/pjH/tYu+89dOjQOOyww1pfV1VVxfHHHx/PPvtsLFq0qM2xp556amuxExHx6KOPxtKlS+Poo4+Ov/3tb61fvXv3jrFjx8YTTzwRERELFy6MuXPnxuTJk1uLnYiI/fffP2pra9uVEwAA6DgmdwAAgG5t+PDhbV5XV1dHZWVlbLbZZqtt//vf/77O1//Tn/4UERHbbbfdavu23377ePrpp9tsq6ysjM0337zNtk022ST+93//t13322abbSKXy7XZtu2220ZExPz582Pw4MGt20eMGNHmuJdeeikiIj7+8Y+v8dpVVVUR8f+/p5EjR652zHbbbRfPPPNMu7ICAAAdQ7kDAAB0a/86ufJ+2yIiisVi6z//e4HynpaWlrLn6Sj9+vVr83rVqlUR8c/n7vxrCfSeigr/iQgAACnwN3cAAIA12GSTTSIiYunSpW22vzfV8p73nj/z4osvrjYR8+KLL5b9+TQvv/xyFIvFNuXTH/7wh4iIqKmped9zt95664iI2GKLLWL8+PFrPe69zO9N+vyrF198cV0jAwAAZeaZOwAAAGvwXhEyc+bM1m0tLS1xxx13tDlut912iy222CJuu+22eOutt1q3P/TQQzFv3rw48MADy5rrtddei/vuu6/1dXNzc9x1110xevToNU7j/KsJEyZEVVVVXH311fHOO++stv+vf/1rREQMGTIkRo8eHdOmTYtly5a17n/00UejsbGxTO8EAAAolckdAACANfjIRz4Su+++e1x00UXx+uuvx8CBA+Puu++Od999t81xG2ywQXz961+PE088Mfbdd984+uijY/HixXHTTTdFTU1NnHPOOWXNte2228bJJ58c9fX1MWjQoPjud78bixcvjjvvvPMDz62qqor/+q//iuOOOy522WWXOOqoo2LzzTePBQsWxAMPPBB77bVX3HLLLRERcc0118SBBx4Ye++9d5x00knx+uuvxze/+c34yEc+EsuXLy/rewIAANaNyR0AAIC1+P73vx977rlnXHvttXH11VfHfvvtF9dee+1qx51wwglxzz33xNtvvx0XXHBB3H777XHYYYfF008/HQMGDChrppEjR8Y999wTDz74YFx44YXxzjvvxD333BMTJkxo1/mTJk2Kxx57LLbccsv4z//8zzjrrLPi7rvvjtGjR8eJJ57YetynPvWp+NGPfhQtLS1x0UUXxb333ht33nln7LbbbmV9PwAAwLrLFf/1iaEAAAB0WTU1NbHjjjvG/fffn3UUAAAgQyZ3AAAAAAAAEqLcAQAAAAAASIhyBwAAAAAAICGeuQMAAAAAAJAQkzsAAAAAAAAJUe4AAAAAAAAkpCLrAD3ZqlWr4rXXXouNN944crlc1nEAAAAAAIAMFYvFeOONN2Lo0KHRq9fa53OUOxl67bXXYtiwYVnHAAAAAAAAupBXX301PvShD611v3InQxtvvHFE/PMPqaqqKuM0AAAAAABAlpqbm2PYsGGt/cHaKHcy9N5SbFVVVcodAAAAAAAgIuIDH+Wy9gXbAAAAAAAA6HKUOwAAAAAAAAlR7gAAAAAAACTEM3cyUCgUolAoREtLS9ZRAAAAAADoJlatWhVvv/121jF4HxtssEH07t17va+TKxaLxTLkoQTNzc1RXV0dy5Yti6qqqqzjAAAAAACQqLfffjuamppi1apVWUfhAwwYMCAGDx4cuVxutX3t7Q1M7gAAAAAAQMKKxWIsXLgwevfuHcOGDYtevTyRpSsqFovx5ptvxpIlSyIiYsiQISVfS7kDAAAAAAAJe/fdd+PNN9+MoUOHxoYbbph1HN5Hv379IiJiyZIlscUWW5S8RJv6DgAAAAAAEvbe89379OmTcRLa470C7p133in5GsodAAAAAADoBtb0DBe6nnL8OSl3AAAAAAAAEqLcAQAAAAAAkjNlypQYPXp01jEyUZF1AAAAAAAAoPxqLnygU+83/9oDO/V+5513Xpx55pmdes+uQrkDAAAAAAAkp3///tG/f/+sY2TCsmwAAAAAAECnGzduXHzpS1+K888/PwYOHBiDBw+OKVOmtO5fsGBBHHroodG/f/+oqqqKz33uc7F48eLW/f++LNuTTz4ZH/3oR2OjjTaKAQMGxF577RV/+tOfWvf/z//8T+yyyy5RWVkZW221VVxxxRXx7rvvdsZbLTvlDgAAAAAAkIlp06bFRhttFLNnz47rrrsurrzyynj00Udj1apVceihh8brr78eTz31VDz66KPxxz/+MY488sg1Xufdd9+NiRMnxr777hu/+93vYtasWXHaaadFLpeLiIhf/OIXcfzxx8dZZ50VjY2Ncfvtt8fUqVPjP/7jPzrz7ZaNZdkAAAAAAIBM7LTTTnH55ZdHRMTIkSPjlltuicceeywiIhoaGqKpqSmGDRsWERF33XVXfOQjH4n6+vqoq6trc53m5uZYtmxZHHTQQbH11ltHRMQOO+zQuv+KK66ICy+8MCZPnhwREVtttVV87Wtfi/PPP7/1/ikxuQMAAAAAAGRip512avN6yJAhsWTJkpg3b14MGzastdiJiKitrY0BAwbEvHnzVrvOwIED44QTTogJEybEwQcfHDfddFMsXLiwdf9zzz0XV155Zetzevr37x+nnnpqLFy4MN58882Oe4MdRLmTgUKhELW1tas1iwAAAAAA0JNssMEGbV7ncrlYtWpVSde68847Y9asWbHnnnvGPffcE9tuu238+te/joiI5cuXxxVXXBFz585t/WpoaIiXXnopKisr1/t9dDbLsmUgn89HPp+P5ubmqK6uzjoOAAAAAAB0KTvssEO8+uqr8eqrr7ZO7zQ2NsbSpUujtrZ2reeNGTMmxowZExdddFHsscceMX369Nh9991jl112iRdffDG22WabznoLHUq5AwAAAAAAdCnjx4+PUaNGxTHHHBM33nhjvPvuu3H66afHvvvuG7vttttqxzc1NcUdd9wRhxxySAwdOjRefPHFeOmll+L444+PiIjLLrssDjrooBg+fHh89rOfjV69esVzzz0Xzz//fFx11VWd/fbWm2XZAAAAAACALiWXy8X//M//xCabbBL77LNPjB8/Prbaaqu455571nj8hhtuGC+88EIcfvjhse2228Zpp50W+Xw+Pv/5z0dExIQJE+L++++PRx55JOrq6mL33XePb3zjG/HhD3+4M99W2eSKxWIx6xA91XvLsi1btiyqqqqyjgMAAAAAQIJWrlwZTU1NMWLEiCSfH9PTvN+fV3t7A5M7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAA93pQpU2L06NFZx2iXiqwDwBpNqS7xvGXlzQEAAAAAkKpSf85a8v263s9nx40bF6NHj44bb7zxA48977zz4swzz+z4UGWg3AEAAAAAAHqsYrEYLS0t0b9//+jfv3/WcdrFsmwAAAAAAECnGzduXHzpS1+K888/PwYOHBiDBw+OKVOmtO5funRpnHLKKbH55ptHVVVVfPzjH4/nnnuudf8JJ5wQEydObHPNs88+O8aNG9e6/6mnnoqbbropcrlc5HK5mD9/fjz55JORy+XioYceil133TX69u0bTz/99GrLsr13/euvvz6GDBkSm266aeTz+XjnnXdaj/nf//3fOP7442OTTTaJDTfcMA444IB46aWXOuLb1YZyJwOFQiFqa2ujrq4u6ygAAAAAAJCZadOmxUYbbRSzZ8+O6667Lq688sp49NFHIyLiiCOOiCVLlsRDDz0Uv/3tb2OXXXaJT3ziE/H666+369o33XRT7LHHHnHqqafGwoULY+HChTFs2LDW/RdeeGFce+21MW/evNhpp53WeI0nnngiXnnllXjiiSdi2rRpMXXq1Jg6dWrr/hNOOCHmzJkTP/nJT2LWrFlRLBbj05/+dJsCqCNYli0D+Xw+8vl8NDc3R3V1J695CAAAAAAAXcROO+0Ul19+eUREjBw5Mm655ZZ47LHHol+/fvGb3/wmlixZEn379o2IiOuvvz5mzJgRP/7xj+O00077wGtXV1dHnz59YsMNN4zBgwevtv/KK6+M/fff/32vsckmm8Qtt9wSvXv3ju233z4OPPDAeOyxx+LUU0+Nl156KX7yk5/EL3/5y9hzzz0jIuL73/9+DBs2LGbMmBFHHHHEun472k25AwAAAAAAZOLfJ2aGDBkSS5Ysieeeey6WL18em266aZv9//jHP+KVV14py7132223DzzmIx/5SPTu3btNvoaGhoiImDdvXlRUVMTYsWNb92+66aax3Xbbxbx588qScW2UOwAAAAAAQCY22GCDNq9zuVysWrUqli9fHkOGDIknn3xytXMGDBgQERG9evWKYrHYZt+6LIe20UYblZwva8odAAAAAACgS9lll11i0aJFUVFRETU1NWs8ZvPNN4/nn3++zba5c+e2KWT69OkTLS0tHZJxhx12iHfffTdmz57duizb3//+93jxxRejtra2Q+75nl4denUAAAAAAIB1NH78+Nhjjz1i4sSJ8cgjj8T8+fPjV7/6VVx88cUxZ86ciIj4+Mc/HnPmzIm77rorXnrppbj88stXK3tqampi9uzZMX/+/Pjb3/5W1qmbkSNHxqGHHhqnnnpqPP300/Hcc8/FscceG1tuuWUceuihZbvPmih3AAAAAACALiWXy8WDDz4Y++yzT5x44omx7bbbxlFHHRV/+tOfYtCgQRERMWHChLj00kvj/PPPj7q6unjjjTfi+OOPb3Od8847L3r37h21tbWx+eabx4IFC8qa884774xdd901DjrooNhjjz2iWCzGgw8+uNpybuWWK/77gnR0mubm5qiuro5ly5ZFVVVV1nG6linVJZ63rLw5AAAAAAC6uJUrV0ZTU1OMGDEiKisrs47DB3i/P6/29gYmdwAAAAAAABKi3AEAAAAAAEiIcgcAAAAAACAhyh0AAAAAAICEKHcAAAAAAAASotwBAAAAAABIiHIHAAAAAAAgIcodAAAAAACAhCh3AAAAAAAAElKRdQBYk5qV00s6b355YwAAAAAAQJej3AEAAAAAgG5o1LRRnXq/hskNnXq/nsyybAAAAAAAAAlR7gAAAAAAAJ1u3LhxceaZZ8bZZ58dm2yySQwaNCi+9a1vxYoVK+LEE0+MjTfeOLbZZpt46KGHIiJi6tSpMWDAgDbXmDFjRuRyuTbb/uu//iu23nrr6NOnT2y33Xbxve99r83+XC4X3/72t+Owww6LDTfcMEaOHBk/+clPOvS9lptyBwAAAAAAyMS0adNis802i9/85jdx5plnxhe/+MU44ogjYs8994xnnnkmPvnJT8Zxxx0Xb775Zruud99998VZZ50VX/7yl+P555+Pz3/+83HiiSfGE0880ea4K664Ij73uc/F7373u/j0pz8dxxxzTLz++usd8RY7hHIHAAAAAADIxM477xyXXHJJjBw5Mi666KKorKyMzTbbLE499dQYOXJkXHbZZfH3v/89fve737Xretdff32ccMIJcfrpp8e2224b5557bnzmM5+J66+/vs1xJ5xwQhx99NGxzTbbxNVXXx3Lly+P3/zmNx3xFjuEcgcAAAAAAMjETjvt1PrPvXv3jk033TRGjRrVum3QoEEREbFkyZJ2XW/evHmx1157tdm21157xbx589Z634022iiqqqrafY+uQLkDAAAAAABkYoMNNmjzOpfLtdn23vN0Vq1aFb169Ypisdjm+Hfeeads9121alVJ18qCcicDhUIhamtro66uLusoAAAAAACQhM033zzeeOONWLFiReu2uXPntjlmhx12iF/+8pdttv3yl7+M2trazojYaSqyDtAT5fP5yOfz0dzcHNXV1VnHAQAAAACALm/s2LGx4YYbxle/+tX40pe+FLNnz46pU6e2OeYrX/lKfO5zn4sxY8bE+PHj46c//Wnce++98fOf/zyb0B3E5A4AAAAAANDlDRw4MP77v/87HnzwwRg1alT84Ac/iClTprQ5ZuLEiXHTTTfF9ddfHx/5yEfi9ttvjzvvvDPGjRuXSeaOkiv++wJ1dJr3JneWLVsWVVVVWcfpUmoufKCk8+Zfe2CZkwAAAAAAdG0rV66MpqamGDFiRFRWVmYdhw/wfn9e7e0NTO4AAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQpQ7AAAAAAAACVHuAAAAAABAN1AsFrOOQDuU489JuQMAAAAAAAnr3bt3RES8/fbbGSehPd58882IiNhggw1KvkZFucIAAAAAAACdr6KiIjbccMP461//GhtssEH06mWuoysqFovx5ptvxpIlS2LAgAGtpVwplDsAAAAAAJCwXC4XQ4YMiaampvjTn/6UdRw+wIABA2Lw4MHrdQ3lDgAAAAAAJK5Pnz4xcuRIS7N1cRtssMF6Tey8R7kDAAAAAADdQK9evaKysjLrGHQCC+8BAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQjxzBwAAAAAAKMmoaaNKOq9hckOZk/QsJncAAAAAAAASotwBAAAAAABIiHIHAAAAAAAgIcodAAAAAACAhCh3AAAAAAAAEqLcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIQodwAAAAAAABKi3AEAAAAAAEiIcgcAAAAAACAhyh0AAAAAAICEKHcAAAAAAAASotwBAAAAAABIiHIHAAAAAAAgIcodAAAAAACAhCh3AAAAAAAAEqLcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIQodwAAAAAAABKSXLkzc+bMOPjgg2Po0KGRy+VixowZH3jO1KlTI5fLxQ477LDavh/96EeRy+WipqamzfEDBgxY47Xae08AAAAAAICOkFy5s2LFith5552jUCis03kbbbRRLFmyJGbNmtVm+3e+850YPnx4OSMCAAAAAAB0mOTKnQMOOCCuuuqqOOyww9bpvIqKipg0aVJ897vfbd325z//OZ588smYNGlSSVmmTJkSuVxuta+pU6eWdD0AAAAAAIAPkly5sz5OOumk+OEPfxhvvvlmRPxz+bVPfepTMWjQoJKud95558XChQtbv66//vrYcMMNY7fdditnbAAAAAAAgFY9qtwZM2ZMbLXVVvHjH/84isViTJ06NU466aQ1Hrts2bLo37//al//qn///jF48OAYPHhwzJ8/Py655JK48847Y8cdd1zjNd96661obm5u8wUAAAAAALAuKrIO0NlOOumkuPPOO2P48OGxYsWK+PSnPx233HLLasdtvPHG8cwzz6y2feTIkattW7BgQUycODHOO++8+NznPrfWe19zzTVxxRVXrN8bAAAAAAAAerQeNbkTEXHMMcfEr3/965gyZUocd9xxUVGx5n6rV69esc0226z29e9WrFgRhxxySOyxxx5x5ZVXvu+9L7rooli2bFnr16uvvlqW9wQAAAAAAPQcPW5yZ+DAgXHIIYfED3/4w7jtttvW61rFYjGOPfbYWLVqVXzve9+LXC73vsf37ds3+vbtu173BAAAAAAAerbkyp3ly5fHyy+/3Pq6qakp5s6dGwMHDozhw4e36xpTp06NW2+9NTbddNP1yjJlypT4+c9/Ho888kgsX748li9fHhER1dXV0a9fv/W6NgAAAAAAwJoktyzbnDlzYsyYMTFmzJiIiDj33HNjzJgxcdlll7X7Gv369VvvYici4qmnnorly5fHnnvuGUOGDGn9uueee9b72gAAAAAAAGuSKxaLxaxD9FTNzc1RXV0dy5Yti6qqqqzjdCk1Fz5Q0nnzrz2wzEkAAAAAAFibUdNGlXRew+SGMifpHtrbGyQ3udMdFAqFqK2tjbq6uqyjAAAAAAAAiVHuZCCfz0djY2PU19dnHQUAAAAAAEiMcgcAAAAAACAhyh0AAAAAAICEKHcAAAAAAAASotwBAAAAAABIiHIHAAAAAAAgIcodAAAAAACAhCh3MlAoFKK2tjbq6uqyjgIAAAAAACRGuZOBfD4fjY2NUV9fn3UUAAAAAAAgMcodAAAAAACAhCh3AAAAAAAAEqLcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIQodwAAAAAAABKi3MlAoVCI2traqKuryzoKAAAAAACQGOVOBvL5fDQ2NkZ9fX3WUQAAAAAAgMQodwAAAAAAABKi3AEAAAAAAEiIcgcAAAAAACAhyh0AAAAAAICEKHcAAAAAAAASotwBAAAAAABIiHIHAAAAAAAgIcodAAAAAACAhCh3MlAoFKK2tjbq6uqyjgIAAAAAACRGuZOBfD4fjY2NUV9fn3UUAAAAAAAgMcodAAAAAACAhCh3AAAAAAAAEqLcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIQodwAAAAAAABJSkXUAKKdR00aVfG7D5IYyJgEAAAAAgI6h3KFbaWhakHUEAAAAAADoUJZlAwAAAAAASIhyJwOFQiFqa2ujrq4u6ygAAAAAAEBilDsZyOfz0djYGPX19VlHAQAAAAAAEqPcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIQodwAAAAAAABKi3AEAAAAAAEiIcgcAAAAAACAhyh0AAAAAAICEKHcAAAAAAAASotwBAAAAAABIiHIHAAAAAAAgIcodAAAAAACAhCh3AAAAAAAAEqLcyUChUIja2tqoq6vLOgoAAAAAAJAY5U4G8vl8NDY2Rn19fdZRAAAAAACAxCh3AAAAAAAAEqLcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIQodwAAAAAAABKi3AEAAAAAAEiIcgcAAAAAACAhyh0AAAAAAICEKHcAAAAAAAASotwBAAAAAABIiHIHAAAAAAAgIcodAAAAAACAhCh3AAAAAAAAEqLcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIQodzJQKBSitrY26urqso4CAAAAAAAkRrmTgXw+H42NjVFfX591FAAAAAAAIDHKHQAAAAAAgIQodwAAAAAAABJSkXUA6CpGTRtV0nkNkxvKnAQAAAAAANZOuQP/T0PTgqwjAAAAAADAB7IsGwAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQpQ7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAAkRLmTgUKhELW1tVFXV5d1FAAAAAAAIDHKnQzk8/lobGyM+vr6rKMAAAAAAACJUe4AAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQpQ7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEIqsg4AqRs1bVRJ5zVMbihzEgAAAAAAegKTOwAAAAAAAAkxuQPrqaFpQdYRAAAAAADoQUzuAAAAAAAAJES5AwAAAAAAkBDLsgEAAAAAQA83atqorCOwDkzuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQpQ7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJCQiqwDQE81atqoks5rmNxQ5iQAAAAAAKTE5A4AAAAAAEBClDsAAAAAAAAJsSwbZKShaUHWEQAAAAAASJDJHQAAAAAAgIT02HInl8vFjBkzso4BAAAAAACwTjItd2bOnBkHH3xwDB06dK1lS7FYjMsuuyyGDBkS/fr1i/Hjx8dLL73U5pjXX389jjnmmKiqqooBAwbEySefHMuXL1+vbOPGjYuzzz57te1Tp06NAQMGrNe1AQAAAAAASpVpubNixYrYeeedo1AorPWY6667Lm6++ea47bbbYvbs2bHRRhvFhAkTYuXKla3HHHPMMfH73/8+Hn300bj//vtj5syZcdppp3XGWwAAAAAAAOhUmZY7BxxwQFx11VVx2GGHrXF/sViMG2+8MS655JI49NBDY6eddoq77rorXnvttdYpn3nz5sXDDz8c3/72t2Ps2LGx9957xze/+c24++6747XXXmt3lssvvzyGDBkSv/vd79bpPdTU1EQul1vtCwAAAAAAoCN06WfuNDU1xaJFi2L8+PGt26qrq2Ps2LExa9asiIiYNWtWDBgwIHbbbbfWY8aPHx+9evWK2bNnf+A9isVinHnmmXHXXXfFL37xi9hpp53WKWN9fX0sXLgwFi5cGH/+859j9913j4997GPrdA0AAAAAAID2qsg6wPtZtGhRREQMGjSozfZBgwa17lu0aFFsscUWbfZXVFTEwIEDW49Zm3fffTeOPfbYePbZZ+Ppp5+OLbfcss3+W2+9Nb797W+vdk5lZWXr680337z1n88666xYuHBh1NfXr/F+b731Vrz11lutr5ubm983HwAAAAAAwL/r0uVORzvnnHOib9++8etf/zo222yz1fYfc8wxcfHFF7fZdu+998bVV1+92rF33HFHfOc734lf/epXbQqff3XNNdfEFVdcUZ7wAAAAAABAj9Sll2UbPHhwREQsXry4zfbFixe37hs8eHAsWbKkzf533303Xn/99dZj1mb//fePv/zlL/Gzn/1sjfurq6tjm222afP171NCERFPPPFE69Ju77es20UXXRTLli1r/Xr11VffNx8AAAAAAMC/69LlzogRI2Lw4MHx2GOPtW5rbm6O2bNnxx577BEREXvssUcsXbo0fvvb37Ye8/jjj8eqVati7Nix73v9Qw45JKZPnx6nnHJK3H333SVlfPnll+Ozn/1sfPWrX43PfOYz73ts3759o6qqqs0XAAAAAADAush0Wbbly5fHyy+/3Pq6qakp5s6dGwMHDozhw4dHLpeLs88+O6666qoYOXJkjBgxIi699NIYOnRoTJw4MSIidthhh/jUpz4Vp556atx2223xzjvvxBlnnBFHHXVUDB069AMzHHbYYfG9730vjjvuuKioqIjPfvaz7c7/j3/8Iw4++OAYM2ZMnHbaaW2e8fNBU0MAAAAAAAClyLTcmTNnTuy3336tr88999yIiJg8eXJMnTo1IiLOP//8WLFiRZx22mmxdOnS2HvvvePhhx+OysrK1vO+//3vxxlnnBGf+MQnolevXnH44YfHzTff3O4cn/3sZ2PVqlVx3HHHRa9evT5wAuc9ixcvjhdeeCFeeOGF1YqkYrHY7vsDAAAAAAC0V66ohchMc3NzVFdXx7JlyyzR9m9qLnygpPPmV04qc5IuaMqyrBMAAAAAAF3UqGmjso7QLg2TG7KO0CW1tzfo0s/c6a4KhULU1tZGXV1d1lEAAAAAAIDEKHcykM/no7GxMerr67OOAgAAAAAAJCbTZ+4A667UsUpjjgAAAAAA3YPJHQAAAAAAgIQodwAAAAAAABJiWTZITEPTgqwjAAAAAACQIZM7AAAAAAAACVHuAAAAAAAAJES5k4FCoRC1tbVRV1eXdRQAAAAAACAxyp0M5PP5aGxsjPr6+qyjAAAAAAAAiVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEIqsg4A5VSzcnrJ586vnFTGJAAAAAAA0DFM7gAAAAAAACREuQMAAAAAAJAQ5U4GCoVC1NbWRl1dXdZRAAAAAACAxCh3MpDP56OxsTHq6+uzjgIAAAAAACSmIusAQOcYNW1USec1TG4ocxIAAAAAANaHyR0AAAAAAICEKHcAAAAAAAASotwBAAAAAABIiGfuQA/R0LQg6wgAAAAAQDuV+gxtegaTOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5U4GCoVC1NbWRl1dXdZRAAAAAACAxCh3MpDP56OxsTHq6+uzjgIAAAAAACRGuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJqcg6ANC1jZo2qqTzGiY3lDkJAAAAAAARJncAAAAAAACSotwBAAAAAABIiHIHAAAAAAAgIcodAAAAAACAhFRkHQDo2hqaFmQdAQAAAACAf2FyJwOFQiFqa2ujrq4u6ygAAAAAAEBilDsZyOfz0djYGPX19VlHAQAAAAAAEqPcAQAAAAAASIhn7gAAAAAAQAcZNW1U1hHohkzuAAAAAAAAJES5AwAAAAAAkBDLsgEdotRx04bJDWVOAgAAAADQvZjcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIQodwAAAAAAABKi3AEAAAAAAEhIRdYBgO6poWlB1hEAAAAAALolkzsAAAAAAAAJUe5koFAoRG1tbdTV1WUdBQAAAAAASIxyJwP5fD4aGxujvr4+6ygAAAAAAEBiPHMH6FJGTRtV0nkNkxvKnAQAAAAA/n+l/twKOoLJHQAAAAAAgIQodwAAAAAAABKi3AEAAAAAAEiIcgcAAAAAACAhyh0AAAAAAICEKHcAAAAAAAASUpF1AIB/1dC0IOsIAAAAAABdmskdAAAAAACAhJjcAbqFUdNGlXRew+SGMicBAAAAAOhYJncAAAAAAAASotwBAAAAAABIiGXZAAAAAADoMUpd3h+6EpM7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDP3MlAoVCIQqEQLS0tWUfhX9SsnF7SefMrJ5U5CQAAAAAArJ1yJwP5fD7y+Xw0NzdHdXV11nGgW2hoWpB1BAAAAACATqHcAXq0UdNGlXRew+SGMicBAAAAAGgfz9wBAAAAAABIiHIHAAAAAAAgIZZlAwAAAAAgOaUutw/dgckdAAAAAACAhCh3AAAAAAAAEqLcAQAAAAAASIhn7gCUYH3WdG2Y3FDGJAAAAABAT2NyBwAAAAAAICEmd4AeraFpQUnnjRoxvMxJAAAAAADax+QOAAAAAABAQpQ7AAAAAAAACbEsGwAAAAAAmRk1bVTWESA5yh2ATlbqX1gaJjeUOQkAAAAAkCLLsgEAAAAAACREuQMAAAAAAJAQy7IBlKChaUHJ544aMbyMSQAAAACAnsbkDgAAAAAAQEKUOwAAAAAAAAmxLBtAIkZNG1XSeQ2TG8qcBAAAAGB1pf7sAlh3JncAAAAAAAASotwBAAAAAABIiHIHAAAAAAAgIZ65k4FCoRCFQiFaWlqyjgJkoKFpQUnnjRoxvMxJAAAAAIAUmdzJQD6fj8bGxqivr886CgAAAAAAkBiTOwAAAAAARETEqGmjso4AtINyB6CbK/UvZQ2TG8qcBAAAAAAoB8uyAQAAAAAAJES5AwAAAAAAkBDLsgGwRpZzAwAAAICuyeQOAAAAAABAQkzuACSioWlBSeeNGjG8zEkAAACArq7UFTmANJjcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIR45g4AZVXqmr4NkxvKnAQAAAAAuiflDgAAAABAF1XqL1EC3Ztl2QAAAAAAABJicgegm2toWlDSeaNGDC9zEgAAAACgHJQ7sJ5qVk4v6bz5lZPKnATS5lk9AAAAANA+lmUDAAAAAABIiMkdAAAAAIAOVuqKFQBrYnIHAAAAAAAgISZ3AFijhqYFJZ03asTwMif5gPt5Vg8AAAAAPcx6lTsvv/xyvPLKK7HPPvtEv379olgsRi6XK1c2AAAAAIAuxfJqQFdQUrnz97//PY488sh4/PHHI5fLxUsvvRRbbbVVnHzyybHJJpvEDTfcUO6cAFBWJn4AAAAASFVJz9w555xzoqKiIhYsWBAbbrhh6/YjjzwyHn744bKFAwAAAAAAoK2SJnceeeSR+NnPfhYf+tCH2mwfOXJk/OlPfypLMAAAAAAAAFZX0uTOihUr2kzsvOf111+Pvn37rncoAAAAAAAA1qykyZ2Pfexjcdddd8XXvva1iIjI5XKxatWquO6662K//fYra0AAAAAAgHIr9VmsAF1BSeXOddddF5/4xCdizpw58fbbb8f5558fv//97+P111+PX/7yl+XOCEBCGpoWlHTeqBHDy5ykY5T6l/+GyQ1lTgIAAABAT1XSsmw77rhj/OEPf4i99947Dj300FixYkV85jOfiWeffTa23nrrcmcEAAAAAADg/ylpcmfBggUxbNiwuPjii9e4b/jwNH77GgAAAABIm+XVgJ6opMmdESNGxF//+tfVtv/973+PESNGrHcoAAAAAAAA1qykcqdYLEYul1tt+/Lly6OysnK9QwEAAAAAALBm67Qs27nnnhsREblcLi699NLYcMMNW/e1tLTE7NmzY/To0WUNCEDP0NC0oKTzRo1IYynQUpcJaJjcUOYkAAAAAKRuncqdZ599NiL+ObnT0NAQffr0ad3Xp0+f2HnnneO8884rb0IAAAAAoNvz7ByA9luncueJJ56IiIgTTzwxbrrppqiqquqQUADAP63Pf9yY+gEAAADontap3HnPnXfeWe4cAAAAAAAAtENJ5U5ExJw5c+KHP/xhLFiwIN5+++02++699971DgYA7dHdn9WzPjznBwAAyILl1QA6Xq9STrr77rtjzz33jHnz5sV9990X77zzTvz+97+Pxx9/PKqrq8udEQAAAAAAgP+npMmdq6++Or7xjW9EPp+PjTfeOG666aYYMWJEfP7zn48hQ4aUO2PZjRs3LkaPHh033nhj1lEAAAAAoEsygQPQdZU0ufPKK6/EgQceGBERffr0iRUrVkQul4tzzjkn7rjjjrKFmzlzZhx88MExdOjQyOVyMWPGjNWOKRaLcdlll8WQIUOiX79+MX78+HjppZfW675TpkyJ0aNHr7Z9/vz5kcvlYu7cuet1fQAAAAAAgFKVNLmzySabxBtvvBEREVtuuWU8//zzMWrUqFi6dGm8+eabZQu3YsWK2HnnneOkk06Kz3zmM2s85rrrroubb745pk2bFiNGjIhLL700JkyYEI2NjVFZWVm2LADQU3hWDwAAAEDXVlK5s88++8Sjjz4ao0aNiiOOOCLOOuusePzxx+PRRx+Nj3/842ULd8ABB8QBBxyw1v3FYjFuvPHGuOSSS+LQQw+NiIi77rorBg0aFDNmzIijjjqqXfd54IEHYtKkSXHrrbfGMccc0+58J5xwQkybNm217U888USMGzeu3dcBoPM1NC0o6bxRI4aXOUn3oRQCAICuyfJqAN1PScuy3XLLLa3FycUXXxznnntuLF68OA4//PC49dZbyxrw/TQ1NcWiRYti/Pjxrduqq6tj7NixMWvWrHZdY/r06XH00UfH97///XUqdiIibrrppli4cGHr11lnnRVbbLFFbL/99ut0HQAAAAAAgPYqaXJn4MCBrf/cq1evuPDCC2PlypVRKBRizJgxsWjRorIFfD/v3WfQoEFttg8aNKhdGQqFQlx88cXx05/+NPbdd982+xoaGqJ///5tthWLxTavq6uro7q6OiIi7r333rj99tvj5z//eQwePHiN93vrrbfirbfean3d3Nz8gRkBoLsz8QMAAACwbtap3HnrrbdiypQp8eijj0afPn3i/PPPj4kTJ8add94Zl1xySfTu3TvOOeecjspaVj/+8Y9jyZIl8ctf/jLq6upW27/ddtvFT37ykzbb/vKXv6xxubVnn302jjvuuLjllltir732Wus9r7nmmrjiiivWOzsAAAAAANBzrVO5c9lll8Xtt98e48ePj1/96ldxxBFHxIknnhi//vWv44Ybbogjjjgievfu3VFZV/PehMzixYtjyJAhrdsXL14co0ePft9zx4wZE88880x897vfjd122y1yuVyb/X369IltttmmzbaKitW/XYsWLYpDDjkkTjnllDj55JPf954XXXRRnHvuua2vm5ubY9iwYe97DgAAAAB4bg4A/2qdyp0f/ehHcdddd8UhhxwSzz//fOy0007x7rvvxnPPPbdaOdIZRowYEYMHD47HHnustcxpbm6O2bNnxxe/+MX3PXfrrbeOG264IcaNGxe9e/eOW265ZZ3vv3Llyjj00ENj++23j//zf/7PBx7ft2/f6Nu37zrfB4Cuo6FpQUnnjRoxvMxJAAAAAOip1qnc+fOf/xy77rprRETsuOOO0bdv3zjnnHM6rNhZvnx5vPzyy62vm5qaYu7cuTFw4MAYPnx45HK5OPvss+Oqq66KkSNHxogRI+LSSy+NoUOHxsSJEz/w+ttuu2088cQTMW7cuKioqIgbb7xxnfJ9/vOfj1dffTUee+yx+Otf/9q6feDAgdGnT591uhY9T83K6SWdN79yUpmTAKTJs3oAAEiRCRwAymGdyp2WlpY2pUVFRUX079+/7KHeM2fOnNhvv/1aX7+3pNnkyZNj6tSpERFx/vnnx4oVK+K0006LpUuXxt577x0PP/xwVFZWtuse2223XTz++OOtEzw33HBDu/M99dRTsXDhwqitrW2z/b3CCADoepRCAACUg5IGgCzlisVisb0H9+rVKw444IDWpcV++tOfxsc//vHYaKON2hx37733ljdlN9Xc3BzV1dWxbNmyqKqqyjpOl1Jz4QNZR+iyTO5AmizLlj7lDgAA/0q5A7B+/Hf2mrW3N1inyZ3Jkye3eX3ssceWlq6HKxQKUSgUoqWlJesoAEA7mfgBAOielDQApGidyp0777yzo3L0KPl8PvL5fGsDBwAAAAAA0F7rVO4AAKVpaFpQ0nmWc0ufiR8AAACg3JQ7AABdkFIIAGDdWF4NgJ5EuQMAXVipEz8Rpn4AAAAAuivlDgAAAABlZ5IGADqOcgcAoBuxnBsAAAB0f8odAAAAAACgJOuzpDylU+5koFAoRKFQiJaWlqyjANCNlfqXK8/q6ZmyWDbFtBAApMHyagDQ9Sh3MpDP5yOfz0dzc3NUV1dnHQcAAABIiLIFAOiVdQAAAAAAAADaz+QOAACZKPW3ji3nBgAAQE+n3AEAIClKIQC6kvVZIs3/NwEApVLuAABtNDQtKOm8USOGlzkJlFdnP5/AD+wA+CCenQMAlEq5AwAAHcCEEUA2FCYAQE+g3AEAysLEDwBQTkoaAIC1U+5koFAoRKFQiJaWlqyjAADQxaTyw0wTRgAAANlR7mQgn89HPp+P5ubmqK6uzjoOAAB0Gg8eh9V19jKOqZTIAACsnXIHAMiU5dwgTVn8cNhzjFgXikQAALoz5Q4AANCtKYXKqyd8P1N5jyZwAAB6LuUOAADAGnT3H5wrIsqvJ7xHAAC6BuUOAABAD6SIAACAdPXKOgAAAAAAAADtZ3IHElOzcnpJ582vnFTmJADZamhaUNJ5o0YML3MSAAAAgM5lcgcAAAAAACAhJncAgB7FxA8AAACQOpM7GSgUClFbWxt1dXVZRwEAAAAAABKj3MlAPp+PxsbGqK+vzzoKAAAAAACQGMuyAQC0g+XcAAAAgK7C5A4AAAAAAEBCTO4AAHQgEz8AAABAuZncAQAAAAAASIhyBwAAAAAAICGWZQMA6IIs5wYAAACsjckdAAAAAACAhCh3AAAAAAAAEqLcAQAAAAAASIhyJwOFQiFqa2ujrq4u6ygAAAAAAEBiKrIO0BPl8/nI5/PR3Nwc1dXVWccBALqRhqYFJZ03asTwMicBAAAAOorJHQAAAAAAgISY3AEAoOSJnwhTPwAAANDZTO4AAAAAAAAkxOQO9BA1K6eXdN78ykllTgIAAAAAwPpQ7gAAsF5KXdLNcm4AAABQGsuyAQAAAAAAJES5AwAAAAAAkBDLsgEAkAnLuQEAAEBplDsAACRFKQQAAEBPZ1k2AAAAAACAhCh3AAAAAAAAEmJZNgAAeoRSl3MrlWXgAAAA6CgmdzJQKBSitrY26urqso4CAAAAAAAkRrmTgXw+H42NjVFfX591FAAAAAAAIDHKHQAAAAAAgIQodwAAAAAAABJSkXUAAADojhqaFpR03qgRw8ucBAAAgO5GuQMAAAAAAD1cqb+gRjaUOwAA0IWY+AEAAOCDKHcAAKAbUAoBAAD0HMod4H3VrJxe0nnzKyeVOQkA0BGUQgAAAOnplXUAAAAAAAAA2s/kDgAA0GnW5yGtpoUAAAD+yeQOAAAAAABAQkzuAAAA62x9JnAAAABYPyZ3AAAAAAAAEqLcAQAAAAAASIhl2QAAgCSUuhTcqBHDy5wEAAAgW8odAACgW1MKAQAA3Y1yBwAAYA2UQgAApKjUv8eSFs/cyUChUIja2tqoq6vLOgoAAAAAAJAYkzsZyOfzkc/no7m5Oaqrq7OOAwAAlJGJHwAAoKOZ3AEAAAAAAEiIyR0AAIAuwMQPAADQXsodAACAhCmFAACg57EsGwAAAAAAQEKUOwAAAAAAAAmxLBsAAEAPZDk3AICurdS/r9EzKHeADlGzcnpJ582vnFTmJAAAlJNSCAAAsqfcAQAAoMN19m+eKpMAAOjOlDsAAAB0O+tTJimGAADo6pQ7AAAA8C8sPQcAQFen3AEAAIAMKZMAAFhXvbIOAAAAAAAAQPuZ3AEAAAAAgA+wPs/0g3JT7gAAAEAZ+IEPAACdRbkDAAAACersMskzfgAAug7P3AEAAAAAAEiIyR0AAADgA5U6KWTiBwCg/JQ7QJdSs3J6SefNr5xU5iQAAEA5KIUA6Go8J4/uwLJsAAAAAAAACTG5AwAAAHQ5nf1b1aVOCq1PTtNJAOvHBA49mXIHAAAA6PH8gBAgOz6DYd0pdwAAAAB6gM5+/pHnLQFAx1HuAAAAAGRA+QEAlEq5k4FCoRCFQiFaWlqyjgIAAAAkprOXL7JcEtBePi+g8yh3MpDP5yOfz0dzc3NUV1dnHQcAAACgx+rsH0abvOo6TM8BKVPuAAAAANBl+M1/urpU/jfa2c/LAjqXcgcAAAAAurHuPqGijFgz3xfo3pQ7AAAAANDFpfSD+pSyAqRKuQMAAAAArEZJA9B1KXcAAAAAoJMoTAAoB+UO0C3UrJxe0nnzKyeVOQkAAAAAQMfqlXUAAAAAAAAA2k+5AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQpQ7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAmpyDoAQJZqVk4v6bz5lZPKnAQAAAAAoH1M7gAAAAAAACREuQMAAAAAAJAQy7IBlKDU5dwiLOkGAAAAAKwfkzsAAAAAAAAJUe4AAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQpQ7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEIqsg4A0NPUrJxe0nnzKyeVOQkAAAAAkCKTOwAAAAAAAAnpkeXOlClTYvTo0VnHAAAAAAAAWGfJlzszZ86Mgw8+OIYOHRq5XC5mzJix3td88sknI5fLxdKlS1fbV1NTEzfeeON63wMAAAAAAKAUyZc7K1asiJ133jkKhULWUQAAAAAAADpc8uXOAQccEFdddVUcdthhJV/jlVdeia222irOOOOMKBaL7T5v6tSpkcvlVvuaMmVKyVkAAAAAAADeT/Llzvr63e9+F3vvvXdMmjQpbrnllsjlcu0+98gjj4yFCxe2fv3gBz+IioqK2GuvvTowMQAAAAAA0JNVZB0gS7/61a/ioIMOiosvvji+/OUvr7b/Qx/60Grb3nzzzdZ/7tevX/Tr1y8i/jn9k8/n4+qrr479999/jfd766234q233mp93dzcvL5vAehBalZOL+m8+ZWTypwEAAAAAMhSjy13FixYEPvvv3/8x3/8R5x99tlrPOYXv/hFbLzxxm22jRs3brXjli1bFgcddFAceOCB8ZWvfGWt97zmmmviiiuuWJ/YAAAAAABAD9djl2XbfPPN46Mf/Wj84Ac/WOsEzYgRI2KbbbZp81VR0bYPa2lpiSOPPDKqqqrijjvueN97XnTRRbFs2bLWr1dffbVs7wcAAAAAAOgZemy5069fv7j//vujsrIyJkyYEG+88UZJ1znnnHOioaEhZsyYEZWVle97bN++faOqqqrNFwAAAAAAwLpIvtxZvnx5zJ07N+bOnRsREU1NTTF37txYsGDBB5670UYbxQMPPBAVFRVxwAEHxPLly9fp3nfeeWfceuutcdttt0Uul4tFixbFokWL1vk6AAAAAAAA7ZV8uTNnzpwYM2ZMjBkzJiIizj333BgzZkxcdtll7Tq/f//+8dBDD0WxWIwDDzwwVqxY0e57P/XUU9HS0hKHHHJIDBkypPXr+uuvL+m9AAAAAAAAfJBcsVgsZh2ip2pubo7q6upYtmyZJdr+Tc2FD2QdAbqN+ZWTso4AAAAAAG1NWZZ1gi6pvb1B8pM7KSoUClFbWxt1dXVZRwEAAAAAABKj3MlAPp+PxsbGqK+vzzoKAAAAAACQGOUOAAAAAABAQiqyDgBAx6pZOb2k8zyrBwAAAAC6JpM7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEKUOxkoFApRW1sbdXV1WUcBAAAAAAASkysWi8WsQ/RUzc3NUV1dHcuWLYuqqqqs43QpNRc+kHUEoETzKydlHQEAAACArm7KsqwTdEnt7Q1M7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAAkRLkDAAAAAACQEOVOBgqFQtTW1kZdXV3WUQAAAAAAgMQodzKQz+ejsbEx6uvrs44CAAAAAAAkpiLrAAB0LzUrp5d03vzKSWVOAgAAAADdk8kdAAAAAACAhCh3AAAAAAAAEqLcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIRUZB0AACIialZOL+m8+ZWTypwEAAAAALo2kzsAAAAAAAAJUe5koFAoRG1tbdTV1WUdBQAAAAAASIxyJwP5fD4aGxujvr4+6ygAAAAAAEBilDsAAAAAAAAJUe4AAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQiqyDgAA66Nm5fSSzptfOanMSQAAAACgc5jcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIR45g4APZJn9QAAAACQKpM7GSgUClFbWxt1dXVZRwEAAAAAABKTKxaLxaxD9FTNzc1RXV0dy5Yti6qqqqzjdCk1Fz6QdQSAsjLxAwAAAPAvpizLOkGX1N7ewOQOAAAAAABAQpQ7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBCKrIOAAA9Qc3K6SWdN79yUpmTAAAAAJA6kzsAAAAAAAAJUe4AAAAAAAAkRLmTgUKhELW1tVFXV5d1FAAAAAAAIDHKnQzk8/lobGyM+vr6rKMAAAAAAACJUe4AAAAAAAAkpCLrAADA2tWsnF7yufMrJ5UxCQAAAABdhckdAAAAAACAhCh3AAAAAAAAEqLcAQAAAAAASIhn7gBAN1Xq83o8qwcAAACgazO5AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJqcg6AADQPdSsnF7SefMrJ5U5CQAAAED3ZnIHAAAAAAAgISZ3AIBMmfgBAAAAWDfKnQwUCoUoFArR0tKSdRQAWE2pZQsAAAAAncOybBnI5/PR2NgY9fX1WUcBAAAAAAASY3IHAEiS5dwAAACAnsrkDgAAAAAAQEKUOwAAAAAAAAmxLBsA0KN09nJulo8DAAAAys3kDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQpQ7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEIqsg4AAJCCmpXTu/X95ldO6tT7AQAAAKUzuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAAkRLkDAAAAAACQEOVOBgqFQtTW1kZdXV3WUQAAAAAAgMRUZB2gJ8rn85HP56O5uTmqq6uzjgMAsF5qVk4v6bz5lZPKnAQAAAB6BuUOAAAlFzQAAABA57MsGwAAAAAAQEKUOwAAAAAAAAmxLBsAAD2CZwMBAADQXZjcAQAAAAAASIhyBwAAAAAAICHKHQAAAAAAgIQodwAAAAAAABJSkXUAAABYFzUrp2cdAQAAADJlcgcAAAAAACAhyh0AAAAAAICEKHcAAAAAAAASotwBAAAAAABISEXWAQAA6JlqVk7POgIZWJ8/9/mVk8qYBAAAIF3KHQAAeB+dXUKVWmCUmlNhAgAAkB7LsgEAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAAkpCLrAAAAAAAAQJpqVk4v6bz55Y3R45jcAQAAAAAASIjJHQAA6EJK/a03AAAAeg7lDgAA9GAlL6FQOanMSQAAAGgvy7IBAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQjxzBwAASILnAwEAAPyTyR0AAAAAAICEmNwBAADWWalTNCnp7PdowggAAGgvkzsAAAAAAAAJMbkDAAB0az1hyggAAOhZTO4AAAAAAAAkRLkDAAAAAACQEMuyAQAAdAGlLh83v3JSmZMAAABdnckdAAAAAACAhJjcAQAASJiJnzUr9fsS0f2/NwAApK9LT+7MnDkzDj744Bg6dGjkcrmYMWPGascUi8W47LLLYsiQIdGvX78YP358vPTSS22Oef311+OYY46JqqqqGDBgQJx88smxfPny9713TU1N3HjjjattnzJlSowePXo93hUAAAAAAEDpunS5s2LFith5552jUCis9Zjrrrsubr755rjtttti9uzZsdFGG8WECRNi5cqVrcccc8wx8fvf/z4effTRuP/++2PmzJlx2mmndcZbAAAAAAAAKKsuvSzbAQccEAcccMBa9xeLxbjxxhvjkksuiUMPPTQiIu66664YNGhQzJgxI4466qiYN29ePPzww1FfXx+77bZbRER885vfjE9/+tNx/fXXx9ChQ9crYy6XW23bhz/84Zg/f/56XRcAAAAAAGBNuvTkzgdpamqKRYsWxfjx41u3VVdXx9ixY2PWrFkRETFr1qwYMGBAa7ETETF+/Pjo1atXzJ49e70zLFy4sPXr5Zdfjm222Sb22Wef9b4uAAAAAADAmnTpyZ0PsmjRooiIGDRoUJvtgwYNat23aNGi2GKLLdrsr6ioiIEDB7YeszYXXHBBXHLJJW22vf3221FbW9v6evDgwRHxzymiww8/PKqrq+P2229f4/XeeuuteOutt1pfNzc3v+/9AQAAerqaldOzjgAAAF1O0uVOR/vKV74SJ5xwQpttN998c8ycOXO1Y7/61a/GrFmzYs6cOdGvX781Xu+aa66JK664oiOiAgAAkKhSC6z5lZPKnAQAgFQkvSzbe1MzixcvbrN98eLFrfsGDx4cS5YsabP/3Xffjddff731mLXZbLPNYptttmnzNXDgwNWO++///u/4xje+Effdd19sueWWa73eRRddFMuWLWv9evXVV9v1PgEAAAAAAN6T9OTOiBEjYvDgwfHYY4/F6NGjI+KfS53Nnj07vvjFL0ZExB577BFLly6N3/72t7HrrrtGRMTjjz8eq1atirFjx653hlmzZsUpp5wSt99+e+y+++7ve2zfvn2jb9++631PAACArJgyAQCA7HXpcmf58uXx8ssvt75uamqKuXPnxsCBA2P48OGRy+Xi7LPPjquuuipGjhwZI0aMiEsvvTSGDh0aEydOjIiIHXbYIT71qU/FqaeeGrfddlu88847ccYZZ8RRRx0VQ4cOXa98ixYtisMOOyyOOuqomDBhQuszfHr37h2bb775el0bAACgI3X2s2w8O6f8Ovt7qqADAOg6unS5M2fOnNhvv/1aX5977rkRETF58uSYOnVqREScf/75sWLFijjttNNi6dKlsffee8fDDz8clZWVred9//vfjzPOOCM+8YlPRK9eveLwww+Pm2++eb3zvfDCC7F48eKYNm1aTJs2rXX7hz/84Zg/f/56Xx8AAIDOZzoJAICuLlcsFotZh+ipmpubo7q6OpYtWxZVVVVZx+lSai58IOsIAAAA66TUcieVqSblFQCwJiX/Ysy1B5Y5SffQ3t6gVydm4v8pFApRW1sbdXV1WUcBAAAAAAASo9zJQD6fj8bGxqivr886CgAAAAAAkBjlDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBCKrIO0BMVCoUoFArR0tKSdRQAAABol5qV00s6b37lpDInAQBAuZOBfD4f+Xw+mpubo7q6Ous4AAAAQIlKLb0iFF8AQOmUOwAAAAAA0E2Ytu0ZlDsAAABAl+MHUwAAa6fcAQAAAACALmZ9lv6k+1PuAAAAQBn4AQy0ZfoKADqOcgcAAAAAoIMpPIFyUu4AAAAAHcZEEwBA+fXKOgAAAAAAAADtZ3InA4VCIQqFQrS0tGQdBQAAAEiMpZ0A6AimbdOi3MlAPp+PfD4fzc3NUV1dnXUcAAAAoAdQCgFA96HcAQAAALoNBQYA0BModwAAAACAHkcZDKRMuQMAAAD0eJ4zAACkRLkDAAAAAEBErF/ZXepUkykqWHfKHQAAAADWylTTmvlhNF2df3ehe1PuAAAAAADJUmIAPZFyBwAAACADfiBdXiZpAOhJlDsZKBQKUSgUoqWlJesoAAAAAHRzii+A7qdX1gF6onw+H42NjVFfX591FAAAAAAAIDEmdwAAAACgi7OMHwD/yuQOAAAAAABAQkzuAAAAANBjmYgB2svzq+hKTO4AAAAAAAAkxOQOAAAAAF2GSRq6us7+36h/J8rP95TuwOQOAAAAAABAQkzuAAAAAEAnMTEAPY9/7+kIyh0AAAAAYDUeHg/QdVmWDQAAAAAAICEmdwAAAACAzFm6CqD9lDsZKBQKUSgUoqWlJesoAAAAAABloaCDzqPcyUA+n498Ph/Nzc1RXV2ddRwAAAAAKBs/4AfoeJ65AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJqcg6AAAAAAAArKualdOzjgCZMbkDAAAAAACQEOUOAAAAAABAQpQ7AAAAAAAACVHuAAAAAAAAJES5k4FCoRC1tbVRV1eXdRQAAAAAACAxyp0M5PP5aGxsjPr6+qyjAAAAAAAAiVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQpQ7AAAAAAAACVHuAAAAAAAAJES5AwAAAAAAkBDlDgAAAAAAQEKUOwAAAAAAAAlR7mSgUChEbW1t1NXVZR0FAAAAAABIjHInA/l8PhobG6O+vj7rKAAAAAAAQGKUOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDsAAAAAAAAJUe4AAAAAAAAkRLkDAAAAAACQEOUOAAAAAABAQpQ7AAAAAAAACanIOkBPViwWIyKiubk54yRdz6q33sw6AgAAAAAAHcTPxdfsve/Le/3B2ih3MvTGG29ERMSwYcMyTgIAAAAAAJ2n+sasE3Rtb7zxRlRXV691f674QfUPHWbVqlXx2muvxcYbbxy5XC7rOF1Gc3NzDBs2LF599dWoqqrKOg7QDfmcATqazxmgo/mcATqazxmgI/mMWbtisRhvvPFGDB06NHr1WvuTdUzuZKhXr17xoQ99KOsYXVZVVZV/sYEO5XMG6Gg+Z4CO5nMG6Gg+Z4CO5DNmzd5vYuc9a699AAAAAAAA6HKUOwAAAAAAAAlR7tDl9O3bNy6//PLo27dv1lGAbsrnDNDRfM4AHc3nDNDRfM4AHclnzPrLFYvFYtYhAAAAAAAAaB+TOwAAAAAAAAlR7gAAAAAAACREuQMAAAAAAJAQ5Q4AAAAAAEBClDtkolAoRE1NTVRWVsbYsWPjN7/5zfse/6Mf/Si23377qKysjFGjRsWDDz7YSUmBVK3L58y3vvWt+NjHPhabbLJJbLLJJjF+/PgP/FwCWNe/z7zn7rvvjlwuFxMnTuzYgEDy1vVzZunSpZHP52PIkCHRt2/f2Hbbbf23E/C+1vVz5sYbb4ztttsu+vXrF8OGDYtzzjknVq5c2UlpgZTMnDkzDj744Bg6dGjkcrmYMWPGB57z5JNPxi677BJ9+/aNbbbZJqZOndrhOVOm3KHT3XPPPXHuuefG5ZdfHs8880zsvPPOMWHChFiyZMkaj//Vr34VRx99dJx88snx7LPPxsSJE2PixInx/PPPd3JyIBXr+jnz5JNPxtFHHx1PPPFEzJo1K4YNGxaf/OQn4y9/+UsnJwdSsa6fM++ZP39+nHfeefGxj32sk5ICqVrXz5m333479t9//5g/f378+Mc/jhdffDG+9a1vxZZbbtnJyYFUrOvnzPTp0+PCCy+Myy+/PObNmxff+c534p577omvfvWrnZwcSMGKFSti5513jkKh0K7jm5qa4sADD4z99tsv5s6dG2effXaccsop8bOf/ayDk6YrVywWi1mHoGcZO3Zs1NXVxS233BIREatWrYphw4bFmWeeGRdeeOFqxx955JGxYsWKuP/++1u37b777jF69Oi47bbbOi03kI51/Zz5dy0tLbHJJpvELbfcEscff3xHxwUSVMrnTEtLS+yzzz5x0kknxS9+8YtYunRpu357DeiZ1vVz5rbbbov//M//jBdeeCE22GCDzo4LJGhdP2fOOOOMmDdvXjz22GOt27785S/H7Nmz4+mnn+603EB6crlc3Hfffe+7esEFF1wQDzzwQJtf6D/qqKNi6dKl8fDDD3dCyvSY3KFTvf322/Hb3/42xo8f37qtV69eMX78+Jg1a9Yaz5k1a1ab4yMiJkyYsNbjgZ6tlM+Zf/fmm2/GO++8EwMHDuyomEDCSv2cufLKK2OLLbaIk08+uTNiAgkr5XPmJz/5Seyxxx6Rz+dj0KBBseOOO8bVV18dLS0tnRUbSEgpnzN77rln/Pa3v21duu2Pf/xjPPjgg/HpT3+6UzID3ZufAa+7iqwD0LP87W9/i5aWlhg0aFCb7YMGDYoXXnhhjecsWrRojccvWrSow3IC6Srlc+bfXXDBBTF06NDV/lIBEFHa58zTTz8d3/nOd2Lu3LmdkBBIXSmfM3/84x/j8ccfj2OOOSYefPDBePnll+P000+Pd955Jy6//PLOiA0kpJTPmUmTJsXf/va32HvvvaNYLMa7774bX/jCFyzLBpTF2n4G3NzcHP/4xz+iX79+GSXrukzuAMC/uPbaa+Puu++O++67LyorK7OOA3QDb7zxRhx33HHxrW99KzbbbLOs4wDd1KpVq2KLLbaIO+64I3bdddc48sgj4+KLL7aUNVA2Tz75ZFx99dVx6623xjPPPBP33ntvPPDAA/G1r30t62gAPZLJHTrVZpttFr17947Fixe32b548eIYPHjwGs8ZPHjwOh0P9GylfM685/rrr49rr702fv7zn8dOO+3UkTGBhK3r58wrr7wS8+fPj4MPPrh126pVqyIioqKiIl588cXYeuutOzY0kJRS/j4zZMiQ2GCDDaJ3796t23bYYYdYtGhRvP3229GnT58OzQykpZTPmUsvvTSOO+64OOWUUyIiYtSoUbFixYo47bTT4uKLL45evfwOOVC6tf0MuKqqytTOWvjUpVP16dMndt111zYP31u1alU89thjsccee6zxnD322KPN8RERjz766FqP5/9r7/5dqvrjMIA/bg0OEjSIP8ghaJBIEAUbwskhbpPQltRUg150SIyrBVFiYBQIgjiIg0RTi2BLf4HDBTe9IAii0KoOLjZ1QeI7XOGrHnq94A7nXO7l814eDuc5Hw782y6SM0ny8ePHvHv3LhsbG+nt7b2MpQIF1WjO3L17N1tbW6lWq/XP48ePMzg4mGq1mo6OjstcPlAAF7meefDgQWq1Wr08TpLt7e20trYqdoC/XCRnTk5O/ipw/hTKZ2dn/99igX+Ce8CNs3OHSzcxMZGRkZH09vamr68vnz9/zvHxcZ49e5Ykefr0adra2jI7O5skKZfLefjwYebn5/Po0aN8/fo1m5ubWVpausoxgGus0ZyZm5vLzMxM1tbWcvv27fo7vZqbm9Pc3HxlcwDXVyM5c+PGjXR3d5/7fUtLS5L8dR7gj0avZ16+fJmFhYWUy+WMjo5mZ2cnHz58yNjY2FWOAVxjjeZMqVTKp0+f0tPTk/7+/tRqtUxPT6dUKp3bNQiQJEdHR6nVavXj3d3dVKvV3Lx5M52dnZmamsr+/n5WV1eTJC9evMjCwkJevXqV58+f5+fPn/n27VvW19evaoRrT7nDpXvy5El+/fqVmZmZHB4e5v79+9nY2Ki/MGtvb+/ckyADAwNZW1tLpVLJ69evc+fOnXz//t3NEOA/NZozi4uLOT09zfDw8Ln/efPmTd6+fXuZSwcKotGcAWhUoznT0dGRHz9+ZHx8PPfu3UtbW1vK5XImJyevagTgmms0ZyqVSpqamlKpVLK/v59bt26lVCrl/fv3VzUCcI1tbm5mcHCwfjwxMZEkGRkZycrKSg4ODrK3t1f/vqurK+vr6xkfH8+XL1/S3t6e5eXlDA0NXfrai6LpzL5JAAAAAACAwvA4IQAAAAAAQIEodwAAAAAAAApEuQMAAAAAAFAgyh0AAAAAAIACUe4AAAAAAAAUiHIHAAAAAACgQJQ7AAAAAAAABaLcAQAAAAAAKBDlDgAAAAAAQIEodwAAAAAAAApEuQMAAAAAAFAgyh0AAAAAAIAC+Q1Id72CuMmywAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "preds = [\"pid_noise_pred\",\"pid_muon_pred\",\"pid_neutrino_pred\"]\n", + "pids = [1,12,13]\n", + "color=[\"b\",\"y\",\"g\"]\n", + "for i, pred in enumerate(preds):\n", + " pid_list=[]\n", + " pid_bin_centers=[]\n", + " \n", + " fig,ax = plt.subplots(figsize=(20,10))\n", + "\n", + " temp = 0\n", + " for i, pid in enumerate(pids):\n", + " y, bin_edges = np.histogram(feature_data[pred].loc[feature_data[\"pid\"]==pid], bins=50)\n", + " \n", + " pid_list.append(feature_data[pred].loc[feature_data[\"pid\"]==pid])\n", + " pid_bin_centers.append(0.5*(bin_edges[1:] + bin_edges[:-1]))\n", + " \n", + " ax.hist(pid_list, bins=100, log=True, stacked=True, label=(\"noise\", \"neutrino\", \"muon\"))\n", + " ax.set(ylabel='Rate',yscale='log')\n", + " ax.yaxis.set_major_formatter(ticker.EngFormatter(unit='Hz'))\n", + " #for i, _ in enumerate(pids):\n", + " # plt.errorbar(pid_bin_centers[i], pid_histlist[i], yerr = stds[i], fmt=f\".{color[i]}\")\n", + " plt.title(pred.replace(\"_\",\" \")[4:])\n", + " plt.legend()\n", + " plt.savefig(\"/groups/icecube/qgf305/workspace/analyses/multi_classification_on_stop_and_track_muons/plotting/distributions/test_plot/\"+pred.replace(\"_\",\"\")[3:-4]+\".png\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "feature_data[\"pid\"].loc[feature_data[[\"pid_noise_pred\",\"pid_muon_pred\",\"pid_neutrino_pred\"]].max(axis=1)]" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_14541/1288578722.py:3: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " preds[\"pid_noise_pred\"] = preds[\"pid_noise_pred\"].loc[feature_data[\"pid_noise_pred\"] > feature_data[\"pid_muon_pred\"]] = 1\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pid_noise_predpid_muon_predpid_neutrino_pred
010.0000000.000000e+00
111.0000003.906106e-07
211.0000001.306228e-07
310.0229936.104581e-01
410.0172707.054196e-01
............
742499510.0000000.000000e+00
742499610.9160268.397368e-02
742499710.0087363.558680e-01
742499810.6507603.409231e-01
742499910.7078562.921439e-01
\n", + "

7425000 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " pid_noise_pred pid_muon_pred pid_neutrino_pred\n", + "0 1 0.000000 0.000000e+00\n", + "1 1 1.000000 3.906106e-07\n", + "2 1 1.000000 1.306228e-07\n", + "3 1 0.022993 6.104581e-01\n", + "4 1 0.017270 7.054196e-01\n", + "... ... ... ...\n", + "7424995 1 0.000000 0.000000e+00\n", + "7424996 1 0.916026 8.397368e-02\n", + "7424997 1 0.008736 3.558680e-01\n", + "7424998 1 0.650760 3.409231e-01\n", + "7424999 1 0.707856 2.921439e-01\n", + "\n", + "[7425000 rows x 3 columns]" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "\n", + "preds = feature_data[[\"pid_noise_pred\",\"pid_muon_pred\",\"pid_neutrino_pred\"]].copy(deep=True)\n", + "\n", + "preds[\"pid_noise_pred\"] = preds[\"pid_noise_pred\"].loc[feature_data[\"pid_noise_pred\"] > feature_data[\"pid_muon_pred\"]] = 1\n", + "preds" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([7425000])" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "preds = torch.tensor(feature_data[[\"pid_noise_pred\",\"pid_muon_pred\",\"pid_neutrino_pred\"]].values)\n", + "target = torch.tensor(feature_data[\"pid\"].astype(int).values)\n", + "target.size()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "The highest label in `target` should be smaller than the size of the `C` dimension of `preds`.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/groups/icecube/qgf305/workspace/analyses/multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPrediction.ipynb Cell 9\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m confmat \u001b[39m=\u001b[39m ConfusionMatrix(num_classes\u001b[39m=\u001b[39m\u001b[39m3\u001b[39m)\n\u001b[0;32m----> 2\u001b[0m confmat(preds, target)\n", + "File \u001b[0;32m~/anaconda3/envs/graphnet/lib/python3.8/site-packages/torch/nn/modules/module.py:1110\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1106\u001b[0m \u001b[39m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1107\u001b[0m \u001b[39m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1108\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m (\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_backward_hooks \u001b[39mor\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_forward_hooks \u001b[39mor\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_forward_pre_hooks \u001b[39mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1109\u001b[0m \u001b[39mor\u001b[39;00m _global_forward_hooks \u001b[39mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1110\u001b[0m \u001b[39mreturn\u001b[39;00m forward_call(\u001b[39m*\u001b[39;49m\u001b[39minput\u001b[39;49m, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 1111\u001b[0m \u001b[39m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1112\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[39m=\u001b[39m [], []\n", + "File \u001b[0;32m~/anaconda3/envs/graphnet/lib/python3.8/site-packages/torchmetrics/metric.py:245\u001b[0m, in \u001b[0;36mMetric.forward\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 243\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_forward_cache \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_forward_full_state_update(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[1;32m 244\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m--> 245\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_forward_cache \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_forward_reduce_state_update(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 247\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_forward_cache\n", + "File \u001b[0;32m~/anaconda3/envs/graphnet/lib/python3.8/site-packages/torchmetrics/metric.py:309\u001b[0m, in \u001b[0;36mMetric._forward_reduce_state_update\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 306\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_enable_grad \u001b[39m=\u001b[39m \u001b[39mTrue\u001b[39;00m \u001b[39m# allow grads for batch computation\u001b[39;00m\n\u001b[1;32m 308\u001b[0m \u001b[39m# calculate batch state and compute batch value\u001b[39;00m\n\u001b[0;32m--> 309\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mupdate(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 310\u001b[0m batch_val \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mcompute()\n\u001b[1;32m 312\u001b[0m \u001b[39m# reduce batch and global state\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/envs/graphnet/lib/python3.8/site-packages/torchmetrics/metric.py:395\u001b[0m, in \u001b[0;36mMetric._wrap_update..wrapped_func\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 393\u001b[0m \u001b[39mwith\u001b[39;00m torch\u001b[39m.\u001b[39mset_grad_enabled(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_enable_grad):\n\u001b[1;32m 394\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 395\u001b[0m update(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 396\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m \u001b[39mas\u001b[39;00m err:\n\u001b[1;32m 397\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39mExpected all tensors to be on\u001b[39m\u001b[39m\"\u001b[39m \u001b[39min\u001b[39;00m \u001b[39mstr\u001b[39m(err):\n", + "File \u001b[0;32m~/anaconda3/envs/graphnet/lib/python3.8/site-packages/torchmetrics/classification/confusion_matrix.py:463\u001b[0m, in \u001b[0;36mConfusionMatrix.update\u001b[0;34m(self, preds, target)\u001b[0m\n\u001b[1;32m 456\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mupdate\u001b[39m(\u001b[39mself\u001b[39m, preds: Tensor, target: Tensor) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m \u001b[39mNone\u001b[39;00m: \u001b[39m# type: ignore\u001b[39;00m\n\u001b[1;32m 457\u001b[0m \u001b[39m\"\"\"Update state with predictions and targets.\u001b[39;00m\n\u001b[1;32m 458\u001b[0m \n\u001b[1;32m 459\u001b[0m \u001b[39m Args:\u001b[39;00m\n\u001b[1;32m 460\u001b[0m \u001b[39m preds: Predictions from model\u001b[39;00m\n\u001b[1;32m 461\u001b[0m \u001b[39m target: Ground truth values\u001b[39;00m\n\u001b[1;32m 462\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 463\u001b[0m confmat \u001b[39m=\u001b[39m _confusion_matrix_update(preds, target, \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mnum_classes, \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mthreshold, \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mmultilabel)\n\u001b[1;32m 464\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mconfmat \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m confmat\n", + "File \u001b[0;32m~/anaconda3/envs/graphnet/lib/python3.8/site-packages/torchmetrics/functional/classification/confusion_matrix.py:608\u001b[0m, in \u001b[0;36m_confusion_matrix_update\u001b[0;34m(preds, target, num_classes, threshold, multilabel)\u001b[0m\n\u001b[1;32m 595\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_confusion_matrix_update\u001b[39m(\n\u001b[1;32m 596\u001b[0m preds: Tensor, target: Tensor, num_classes: \u001b[39mint\u001b[39m, threshold: \u001b[39mfloat\u001b[39m \u001b[39m=\u001b[39m \u001b[39m0.5\u001b[39m, multilabel: \u001b[39mbool\u001b[39m \u001b[39m=\u001b[39m \u001b[39mFalse\u001b[39;00m\n\u001b[1;32m 597\u001b[0m ) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m Tensor:\n\u001b[1;32m 598\u001b[0m \u001b[39m\"\"\"Updates and returns confusion matrix (without any normalization) based on the mode of the input.\u001b[39;00m\n\u001b[1;32m 599\u001b[0m \n\u001b[1;32m 600\u001b[0m \u001b[39m Args:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 605\u001b[0m \u001b[39m multilabel: determines if data is multilabel or not.\u001b[39;00m\n\u001b[1;32m 606\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 608\u001b[0m preds, target, mode \u001b[39m=\u001b[39m _input_format_classification(preds, target, threshold)\n\u001b[1;32m 609\u001b[0m \u001b[39mif\u001b[39;00m mode \u001b[39mnot\u001b[39;00m \u001b[39min\u001b[39;00m (DataType\u001b[39m.\u001b[39mBINARY, DataType\u001b[39m.\u001b[39mMULTILABEL):\n\u001b[1;32m 610\u001b[0m preds \u001b[39m=\u001b[39m preds\u001b[39m.\u001b[39margmax(dim\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m)\n", + "File \u001b[0;32m~/anaconda3/envs/graphnet/lib/python3.8/site-packages/torchmetrics/utilities/checks.py:412\u001b[0m, in \u001b[0;36m_input_format_classification\u001b[0;34m(preds, target, threshold, top_k, num_classes, multiclass, ignore_index)\u001b[0m\n\u001b[1;32m 409\u001b[0m \u001b[39mif\u001b[39;00m preds\u001b[39m.\u001b[39mdtype \u001b[39m==\u001b[39m torch\u001b[39m.\u001b[39mfloat16:\n\u001b[1;32m 410\u001b[0m preds \u001b[39m=\u001b[39m preds\u001b[39m.\u001b[39mfloat()\n\u001b[0;32m--> 412\u001b[0m case \u001b[39m=\u001b[39m _check_classification_inputs(\n\u001b[1;32m 413\u001b[0m preds,\n\u001b[1;32m 414\u001b[0m target,\n\u001b[1;32m 415\u001b[0m threshold\u001b[39m=\u001b[39;49mthreshold,\n\u001b[1;32m 416\u001b[0m num_classes\u001b[39m=\u001b[39;49mnum_classes,\n\u001b[1;32m 417\u001b[0m multiclass\u001b[39m=\u001b[39;49mmulticlass,\n\u001b[1;32m 418\u001b[0m top_k\u001b[39m=\u001b[39;49mtop_k,\n\u001b[1;32m 419\u001b[0m ignore_index\u001b[39m=\u001b[39;49mignore_index,\n\u001b[1;32m 420\u001b[0m )\n\u001b[1;32m 422\u001b[0m \u001b[39mif\u001b[39;00m case \u001b[39min\u001b[39;00m (DataType\u001b[39m.\u001b[39mBINARY, DataType\u001b[39m.\u001b[39mMULTILABEL) \u001b[39mand\u001b[39;00m \u001b[39mnot\u001b[39;00m top_k:\n\u001b[1;32m 423\u001b[0m preds \u001b[39m=\u001b[39m (preds \u001b[39m>\u001b[39m\u001b[39m=\u001b[39m threshold)\u001b[39m.\u001b[39mint()\n", + "File \u001b[0;32m~/anaconda3/envs/graphnet/lib/python3.8/site-packages/torchmetrics/utilities/checks.py:283\u001b[0m, in \u001b[0;36m_check_classification_inputs\u001b[0;34m(preds, target, threshold, num_classes, multiclass, top_k, ignore_index)\u001b[0m\n\u001b[1;32m 278\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[1;32m 279\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mYou have set `multiclass=False`, but have more than 2 classes in your data,\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 280\u001b[0m \u001b[39m\"\u001b[39m\u001b[39m based on the C dimension of `preds`.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 281\u001b[0m )\n\u001b[1;32m 282\u001b[0m \u001b[39mif\u001b[39;00m target\u001b[39m.\u001b[39mmax() \u001b[39m>\u001b[39m\u001b[39m=\u001b[39m implied_classes:\n\u001b[0;32m--> 283\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[1;32m 284\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mThe highest label in `target` should be smaller than the size of the `C` dimension of `preds`.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 285\u001b[0m )\n\u001b[1;32m 287\u001b[0m \u001b[39m# Check that num_classes is consistent\u001b[39;00m\n\u001b[1;32m 288\u001b[0m \u001b[39mif\u001b[39;00m num_classes:\n", + "\u001b[0;31mValueError\u001b[0m: The highest label in `target` should be smaller than the size of the `C` dimension of `preds`." + ] + } + ], + "source": [ + "confmat = ConfusionMatrix(num_classes=3)\n", + "confmat(preds, target)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('graphnet')", + "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.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e54c104f54ca5f79eede1c2e02355cc39841da57601eff628eedcebaaa867660" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPrediction_RD.ipynb b/multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPrediction_RD.ipynb new file mode 100644 index 0000000..797ab13 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPrediction_RD.ipynb @@ -0,0 +1,336 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "plotting pid as a function of prediction" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/groups/icecube/qgf305/anaconda3/envs/graphnet/lib/python3.8/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.ticker as ticker\n", + "import numpy as np\n", + "from torchmetrics import ConfusionMatrix\n", + "import torch\n", + "#path_to_db = \"/groups/icecube/peter/storage/Multiclassification/Test/last_one_lvl3MC/dynedge_pid_test_run/results.csv\"\n", + "#path_to_db = \"/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/Inference/pid_Leon_RD_results_first.csv\"\n", + "path_to_db = \"/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/Inference/pid_40_days_sample_first.csv\"\n", + "feature_data = pd.read_csv(path_to_db, index_col=[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "preds = [\"pid_noise_pred\",\"pid_muon_pred\",\"pid_neutrino_pred\"]\n", + "pids = [1,12,13]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "unique particle ID's and their count: \n", + " pid_noise_pred\n", + "pid \n", + "-16.0 2356342\n", + "-14.0 6140114\n", + "-12.0 2508616\n", + "-1.0 61739862\n", + " 12.0 5655260\n", + " 14.0 13555279\n", + " 16.0 6257494\n", + "\n", + "data:\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pid_noise_predpid_muon_predpid_neutrino_predpidevent_no
07.730823e-018.663693e-040.226051-1.00.0
16.010027e-119.091591e-010.090841-1.01.0
24.313713e-129.999559e-010.000044-1.02.0
39.879802e-012.394820e-040.011780-1.03.0
49.335863e-011.142411e-020.054990-1.04.0
..................
982129621.668801e-181.039869e-040.99989614.099917709.0
982129631.050503e-321.098522e-111.000000-14.099917710.0
982129641.331304e-136.673888e-081.00000014.099917711.0
982129659.600319e-354.217029e-111.00000014.099917712.0
982129663.380749e-136.783007e-040.999322-14.099917713.0
\n", + "

98212967 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " pid_noise_pred pid_muon_pred pid_neutrino_pred pid event_no\n", + "0 7.730823e-01 8.663693e-04 0.226051 -1.0 0.0\n", + "1 6.010027e-11 9.091591e-01 0.090841 -1.0 1.0\n", + "2 4.313713e-12 9.999559e-01 0.000044 -1.0 2.0\n", + "3 9.879802e-01 2.394820e-04 0.011780 -1.0 3.0\n", + "4 9.335863e-01 1.142411e-02 0.054990 -1.0 4.0\n", + "... ... ... ... ... ...\n", + "98212962 1.668801e-18 1.039869e-04 0.999896 14.0 99917709.0\n", + "98212963 1.050503e-32 1.098522e-11 1.000000 -14.0 99917710.0\n", + "98212964 1.331304e-13 6.673888e-08 1.000000 14.0 99917711.0\n", + "98212965 9.600319e-35 4.217029e-11 1.000000 14.0 99917712.0\n", + "98212966 3.380749e-13 6.783007e-04 0.999322 -14.0 99917713.0\n", + "\n", + "[98212967 rows x 5 columns]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(\"unique particle ID's and their count: \\n\", feature_data[[\"pid_noise_pred\",\"pid\"]].groupby(\"pid\").count())\n", + "print()\n", + "print(\"data:\")\n", + "feature_data" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig,ax = plt.subplots(figsize=(20,10))\n", + "ax.hist(feature_data[[\"pid_noise_pred\",\"pid_muon_pred\",\"pid_neutrino_pred\"]],bins=100, log=True, stacked=True, label=(\"noise\", \"neutrino\", \"muon\"))\n", + "ax.set(yscale=\"log\")\n", + "#ax.set(ylabel='Rate',yscale='log')\n", + "#ax.yaxis.set_major_formatter(ticker.EngFormatter(unit='Hz'))\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "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": [ + "for i, pred in enumerate(preds):\n", + " fig,ax = plt.subplots(figsize=(20,10))\n", + " ax.hist(feature_data[pred], bins=100, log=True, label=(pred.replace(\"_\",\" \")[4:]))\n", + " plt.title(pred.replace(\"_\",\" \")[4:])\n", + " plt.legend()\n", + " plt.savefig(\"/groups/icecube/qgf305/workspace/analyses/multi_classification_on_stop_and_track_muons/plotting/distributions/test_plot/\"+pred.replace(\"_\",\"\")[3:-4]+\"_inference.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('graphnet')", + "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.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e54c104f54ca5f79eede1c2e02355cc39841da57601eff628eedcebaaa867660" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/multi_classification_on_stop_and_track_muons/plotting/distributions/generic_1Dhistogram.py b/multi_classification_on_stop_and_track_muons/plotting/distributions/generic_1Dhistogram.py deleted file mode 100644 index 3c6c368..0000000 --- a/multi_classification_on_stop_and_track_muons/plotting/distributions/generic_1Dhistogram.py +++ /dev/null @@ -1,238 +0,0 @@ -""" Will plot all tables and their features in a .db, as well as all features in a .csv. - This script is meant purely as an investigation tool of features in a dataset. """ - -import os, sys -sys.path.append(os.path.abspath(os.path.join(os.path.dirname( __file__ ), '..'))) -import argparse -import numpy as np -import sqlite3 as sql -import pandas as pd -import io -from pandas import read_sql -from helper_functions.plot_params import * - -def create_save_directory(args, table=None): - folder_name=args.path_to_db[:-3].split('/')[-1] - if table == None: - save_dir = args.output + folder_name + "/" - else: - save_dir = args.output + folder_name + "/" + table + "/" - os.makedirs(save_dir, exist_ok=True) - return save_dir - -def tune_bins(data,counts,bins,args): - """attempt to tune bins to find a bin with an acceptable range of zeros""" - # track previous bins - list_bin_attempt = [len(counts)] - list_counts = [counts] - list_bins = [bins] - - # too many zeros bins; auto was not able to find anything meaningful. - if zero_ratio(list_counts[-1]) < args.cutoff: - # try to find a bin that is acceptable. - while zero_ratio(list_counts[-1]) < 0.8 or list_counts[-1].size > 30: - list_bin_attempt.append(int(len(bins)/2)) - counts, bins = np.histogram(data, bins=list_bin_attempt[-1]) - list_counts.append(counts) - list_bins.append(bins) - return list_counts[-2], list_bins[-2], list_bin_attempt[-2] - else: - return list_counts[-1], list_bins[-1], list_bin_attempt[-1] - -def outlier(df, feature, sigma): - # calculate summary statistics - data_mean, data_std = df[feature].mean(), df[feature].std() - # identify outliers - cut_off = data_std * sigma - lower, upper = data_mean - cut_off, data_mean + cut_off - - # identify outliers - temp1 = pd.DataFrame({feature+"_no_outliers" : []}) - temp1 = df[feature][df[feature] < lower] - temp2 = pd.DataFrame({feature+"_no_outliers" : []}) - temp2 = df[feature][df[feature] > upper] - df_outliers = pd.concat([temp1, temp2]) - print('Identified outliers: %d' % len(df_outliers)) - - # remove outliers - temp1 = pd.DataFrame({feature+"_no_outliers" : []}) - temp1 = df[feature][df[feature] >= lower] - temp2 = pd.DataFrame({feature+"_no_outliers" : []}) - temp2 = df[feature][df[feature] <= upper] - df_no_outliers = pd.concat([temp1, temp2]) - print('Non-outlier observations: %d' % len(df_no_outliers)) - - return df_outliers, df_no_outliers - -def custom_bin_range(df): - try: - bin_range = int(df.max() - df.min())+1 - if bin_range > 100: - bin_range = 50 - except: - bin_range = 50 - return bin_range - -def zero_ratio(counts): - try: - x = counts[counts != 0].size / counts[counts == 0].size - except ZeroDivisionError: # no zeros - x = 1 - return x - -parser = argparse.ArgumentParser( - description="plotting all the features as 1-d histograms in a given dataset" -) -parser.add_argument( - "-db", - "--database", - dest="path_to_db", - type=str, - help="path to database [str]", - default="/groups/icecube/petersen/GraphNetDatabaseRepository/moon_pointing_analysis/monte_carlo/11069/Level2_nugen_numu_IC86.2012.011069_InIcePulses_InIceDSTPulses_SplitInIcePulses_SplitInIceDSTPulses_SRTInIcePulses.db", -) -parser.add_argument( - "-o", - "--output", - dest="output", - type=str, - help="the output path [str]", - default="/groups/icecube/petersen/GraphNetDatabaseRepository/moon_pointing_analysis/plots/distributions/", -) -parser.add_argument( - "-s", - "--sigma", - dest="sigma", - type=int, - help="the sigma outlier for cutting data; happen if too many bins in dataset. [int]", - default=2, -) -parser.add_argument( - "-c", - "--cutoff", - dest="cutoff", - type=float, - help="the zero ratio cutoff used in bin tuning; how many zeros instances compared to non zero instances. [int]", - default=0.8, -) -parser.add_argument( - "-l", - "--log", - dest="log", - type=int, - help="if a number exceeds the specified, will scale the graph as log. [int]", - default=5000, -) -args = parser.parse_args() - -ext = (args.path_to_db.split('.')[-1]) -if ext == "db": - # find the name of all tables - with sql.connect(args.path_to_db) as con: - table_query = """SELECT name FROM sqlite_master WHERE type='table';""" - tables = read_sql(table_query, con) - - for table in tables.name: - with sql.connect(args.path_to_db) as con: - feature_query = """SELECT * FROM %s; """ % (table) - feature_data = read_sql(feature_query, con) - - # create a folder to save results into - save_dir = create_save_directory(args, table) - - for feature in feature_data: - print(f"plotting {feature} in {table}.") - try: - # preliminary histogram counts and binning - counts, bins = np.histogram(feature_data[feature], bins='auto') - # tuning attempt to reduce excess zeros - counts, bins, _ = tune_bins(data=feature_data[feature], counts=counts, bins=bins, args=args) - - df_outliers, df_no_outliers = outlier(feature_data, feature, sigma=args.sigma) - - fig, ax = plt.subplots(3,1,figsize=(25, 15)) - - ax[0].set_title(f"full data") - ax[0].hist(feature_data[feature], bins=bins) - ax[0].set_xlabel(feature) - ax[0].set_ylabel("count") - if counts.max() > args.log: - ax[0].set_yscale("log") - - bin_range = custom_bin_range(df_no_outliers) - counts1, bins1 = np.histogram(df_no_outliers, bins=bin_range) - ax[1].set_title(f"outliers under {args.sigma} sigmas") - ax[1].hist(df_no_outliers, bins=bins1) - ax[1].set_xlabel(feature) - ax[1].set_ylabel("count") - if counts.max() > args.log: - ax[1].set_yscale("log") - - bin_range = custom_bin_range(df_outliers) - counts2, bins2 = np.histogram(df_outliers, bins=bin_range) - ax[2].set_title(f"outliers over {args.sigma} sigmas") - ax[2].hist(df_outliers, bins=bins2) - ax[2].set_xlabel(feature) - ax[2].set_ylabel("count") - if counts.max() > args.log: - ax[2].set_yscale("log") - - plt.savefig(save_dir+ feature + ".png") - - except Exception as e: - print(f"plotting {feature} in {table} failed") - print(e) - - -elif ext == "csv": - feature_data = pd.read_csv(args.path_to_db) - extra_index = "Unnamed: 0" - # if an extra index is imported, drop it. - if extra_index in feature_data.keys(): - feature_data = feature_data.drop(extra_index, axis=1) - - # create a folder to save results into - save_dir = create_save_directory(args) - - for feature in feature_data: - print(f"plotting {feature}.") - try: - # preliminary histogram counts and binning - counts, bins = np.histogram(feature_data[feature], bins='auto') - # tuning attempt to reduce excess zeros - counts, bins, _ = tune_bins(data=feature_data[feature], counts=counts, bins=bins, args=args) - - df_outliers, df_no_outliers = outlier(feature_data, feature, sigma=args.sigma) - - fig, ax = plt.subplots(3,1,figsize=(25, 15)) - - ax[0].set_title(f"full data") - ax[0].hist(feature_data[feature], bins=bins) - ax[0].set_xlabel(feature) - ax[0].set_ylabel("count") - if counts.max() > args.log: - ax[0].set_yscale("log") - - bin_range = custom_bin_range(df_no_outliers) - counts1, bins1 = np.histogram(df_no_outliers, bins=bin_range) - ax[1].set_title(f"outliers under {args.sigma} sigmas") - ax[1].hist(df_no_outliers, bins=bins1) - ax[1].set_xlabel(feature) - ax[1].set_ylabel("count") - if counts.max() > args.log: - ax[1].set_yscale("log") - - bin_range = custom_bin_range(df_outliers) - counts2, bins2 = np.histogram(df_outliers, bins=bin_range) - ax[2].set_title(f"outliers over {args.sigma} sigmas") - ax[2].hist(df_outliers, bins=bins2) - ax[2].set_xlabel(feature) - ax[2].set_ylabel("count") - if counts.max() > args.log: - ax[2].set_yscale("log") - - plt.savefig(save_dir+ feature + ".png") - except: - print(f"plotting {feature} failed, data type was of type: {type(feature_data[feature][0])}") - -print("Done plotting.") \ No newline at end of file diff --git a/multi_classification_on_stop_and_track_muons/plotting/distributions/generic_1Dhistograms_.sh b/multi_classification_on_stop_and_track_muons/plotting/distributions/generic_1Dhistograms_.sh deleted file mode 100644 index 5230b4a..0000000 --- a/multi_classification_on_stop_and_track_muons/plotting/distributions/generic_1Dhistograms_.sh +++ /dev/null @@ -1,40 +0,0 @@ -#!/bin/bash -bash_directory=$(dirname -- "$(readlink -f "${BASH_SOURCE}")") # !do not alter! - -## Description: This bash script is meant to plot everything in the folder - -# to recreate the results, follow the steps below. -# (1) designate directory containing database; data described in folder. -database_directory=/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_on_stop_and_track_muons/ -# (2) to run this shell script; copy file path and execute "bash " - -sigma=2 -cutoff=0.7 -log=5000 - - - - - -## do not alter beyond this point ## -#output directory for created plots. -output_directory=${bash_directory}/test_plot/ -# save the report file to -report_name=plot # overwrites old, thus only keeps the one with error -report_directory=/groups/icecube/${USER}/storage/nohup_reports/ -# if directories does not exist for reporting, create them. -mkdir -p ${output_directory}; -mkdir -p ${report_directory}; - -# save the report file to -report_location=${report_directory}${report_name}.out - -echo "plotting histogram of all features" -nohup python ${bash_directory}/generic_1Dhistogram.py \ --db ${database_directory} \ --o ${output_directory} \ --s ${sigma} \ --c ${cutoff} \ --l ${log} \ -> ${report_location} \ -2> ${report_directory}${report_name}.err & \ No newline at end of file diff --git a/multi_classification_on_stop_and_track_muons/plotting/distributions/generic_1Dhistograms_Multiclass_Leon_data.sh b/multi_classification_on_stop_and_track_muons/plotting/distributions/generic_1Dhistograms_Multiclass_Leon_data.sh deleted file mode 100644 index 80cd84f..0000000 --- a/multi_classification_on_stop_and_track_muons/plotting/distributions/generic_1Dhistograms_Multiclass_Leon_data.sh +++ /dev/null @@ -1,40 +0,0 @@ -#!/bin/bash -bash_directory=$(dirname -- "$(readlink -f "${BASH_SOURCE}")") # !do not alter! - -## Description: This bash script is meant to plot everything in the folder - -# to recreate the results, follow the steps below. -# (1) designate directory containing database; data described in folder. -database_directory=/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/trained_models/last_one_lvl3MC/dynedge_pid_LeonMC_data/results.csv -# (2) to run this shell script; copy file path and execute "bash " - -sigma=2 -cutoff=0.7 -log=5000 - - - - - -## do not alter beyond this point ## -#output directory for created plots. -output_directory=${bash_directory}/test_plot/ -# save the report file to -report_name=plot # overwrites old, thus only keeps the one with error -report_directory=/groups/icecube/${USER}/storage/nohup_reports/ -# if directories does not exist for reporting, create them. -mkdir -p ${output_directory}; -mkdir -p ${report_directory}; - -# save the report file to -report_location=${report_directory}${report_name}.out - -echo "plotting histogram of all features" -nohup python ${bash_directory}/generic_1Dhistogram.py \ --db ${database_directory} \ --o ${output_directory} \ --s ${sigma} \ --c ${cutoff} \ --l ${log} \ -> ${report_location} \ -2> ${report_directory}${report_name}.err & \ No newline at end of file diff --git a/multi_classification_on_stop_and_track_muons/plotting/distributions/predictionOfPID.ipynb b/multi_classification_on_stop_and_track_muons/plotting/distributions/predictionOfPID.ipynb new file mode 100644 index 0000000..a3515be --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/plotting/distributions/predictionOfPID.ipynb @@ -0,0 +1,125 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "plotting prediction as a function of pid" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "#path_to_db = \"/groups/icecube/peter/storage/Multiclassification/Test/last_one_lvl3MC/dynedge_pid_test_run/results.csv\"\n", + "path_to_db = \"/groups/icecube/peter/storage/Multiclassification/Real/last_one_lvl3MC/dynedge_pid_Real_run_21.5_mill_equal_frac_/results.csv\"\n", + "feature_data = pd.read_csv(path_to_db, index_col=[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "## transform data\n", + "# remove anti\n", + "feature_data['pid'] = feature_data['pid'].apply(abs)\n", + "# make all neutrinos the same class; to match prediction\n", + "feature_data.loc[feature_data['pid']==14, \"pid\"]=12\n", + "feature_data.loc[feature_data['pid']==16, \"pid\"]=12" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "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": [ + "preds = [\"pid_noise_pred\",\"pid_muon_pred\",\"pid_neutrino_pred\"]\n", + "pids = [1,12,13]\n", + "\n", + "for pid in pids:\n", + " feature_data[preds].loc[feature_data[\"pid\"]==pid].plot.hist(bins=50, log=True, subplots=False, figsize=(20, 10), stacked=True, title=f\"pid: {pid}\")\n", + " plt.savefig(f'/groups/icecube/qgf305/workspace/analyses/multi_classification_on_stop_and_track_muons/plotting/distributions/test_plot/pid{pid}.png')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('graphnet')", + "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.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e54c104f54ca5f79eede1c2e02355cc39841da57601eff628eedcebaaa867660" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/multi_classification_on_stop_and_track_muons/plotting/event_location/moon_position_true.py b/multi_classification_on_stop_and_track_muons/plotting/event_location/moon_position_true.py deleted file mode 100644 index dd90b65..0000000 --- a/multi_classification_on_stop_and_track_muons/plotting/event_location/moon_position_true.py +++ /dev/null @@ -1,74 +0,0 @@ -import os, sys -sys.path.append(os.path.abspath(os.path.join(os.path.dirname( __file__ ), '..'))) -import sqlite3 as sql -import numpy as np -import pandas as pd -import argparse -from pandas import read_sql -from helper_functions.plot_params import * - - -parser = argparse.ArgumentParser( - description="processing i3 files to sqlite3 databases" -) -parser.add_argument( - "-db", - "--database", - dest="path_to_db", - type=str, - help="path to database [str]", - required=True, -) -parser.add_argument( - "-o", - "--output", - dest="output", - type=str, - help="the output path [str]", - required=True, -) -parser.add_argument( - "-p", - "--pulsemap", - dest="pulsemap", - type=str, - help="the pulsemap used [str]", - required=True, -) -args = parser.parse_args() - - -with sql.connect(args.path_to_db) as con: - query = """ - SELECT - azimuth, zenith - FROM - MoonDirection; - """ - sql_data = read_sql(query, con) - - query_time = """ - SELECT - event_time - FROM - InIceDSTPulses; - """ - sql_data["time"] = read_sql(query_time, con) - -# define binning -rbins = np.linspace(0, sql_data.zenith.max(), 30) -abins = np.linspace(0, 2 * np.pi, 60) - -# calculate histogram -hist, _, _ = np.histogram2d( - sql_data.azimuth, sql_data.zenith, density=True, bins=(abins, rbins) -) -A, R = np.meshgrid(abins, rbins) - -# plot -fig, ax = plt.subplots(subplot_kw=dict(projection="polar"), figsize=(7, 7)) - -pc = ax.pcolormesh(A, R, hist.T, cmap="magma_r") -fig.colorbar(pc) -plt.grid() -plt.savefig(args.output + "moon_direction.png") diff --git a/multi_classification_on_stop_and_track_muons/plotting/helper_functions/external_functions.py b/multi_classification_on_stop_and_track_muons/plotting/helper_functions/external_functions.py index 7446947..fc69250 100755 --- a/multi_classification_on_stop_and_track_muons/plotting/helper_functions/external_functions.py +++ b/multi_classification_on_stop_and_track_muons/plotting/helper_functions/external_functions.py @@ -1,3 +1,21 @@ +def get_roc_and_auc(data, target): + fpr, tpr, _ = roc_curve(data[target], data[target+'_pred']) + auc_score = auc(fpr,tpr) + return fpr,tpr,auc_score + +def plot_roc(data, target):#, save_dir, save_as_csv = False): + fpr, tpr, auc = get_roc_and_auc(data, target) + + width = 3.176*2 + height = 2.388*2 + fig = plt.figure(figsize = (width,height)) + plt.plot(fpr,tpr, label ='%s'%(round(auc,3))) + plt.legend() + plt.title('feature selection: 10^6') + plt.ylabel('True Positive Rate', fontsize = 12) + plt.xlabel('False Positive Rate', fontsize = 12) + return + """script credit: Troels Christian Petersen""" import numpy as np diff --git a/multi_classification_on_stop_and_track_muons/plotting/reconstruction/script_archive/reconstruction.py b/multi_classification_on_stop_and_track_muons/plotting/reconstruction/script_archive/reconstruction.py deleted file mode 100755 index 24e1696..0000000 --- a/multi_classification_on_stop_and_track_muons/plotting/reconstruction/script_archive/reconstruction.py +++ /dev/null @@ -1,62 +0,0 @@ -import os, sys -sys.path.append(os.path.abspath(os.path.join(os.path.dirname( __file__ ), '..'))) -import sqlite3 as sql -import pandas as pd -import argparse -from pandas import read_sql -from helper_functions.plot_params import * - -parser = argparse.ArgumentParser( - description="plotting the predicted zenith and azimuth vs truth." -) -parser.add_argument( - "-db", - "--database", - dest="path_to_csv", - type=str, - help="path to database [str]", - default="/groups/icecube/peter/storage/MoonPointing/Models/Leon_Muon_data_MC/last_one_lvl3MC/dynedge_zenith_Leon_muon_data_MC/results.csv", -) -parser.add_argument( - "-o", - "--output", - dest="output", - type=str, - help="the output path [str]", - default="/groups/icecube/qgf305/workspace/analyses/moon_pointing_analysis/plotting/reconstruction/test_plot", -) -parser.add_argument( - "-b", - "--bins", - dest="bins", - type=int, - help="the number of bins [str]", - default=25, -) -args = parser.parse_args() - -# dataloading -azimuth = pd.read_csv(indir + "azimuth_results.csv") -zenith = pd.read_csv(indir + "zenith_results.csv") - -# assign empty containers and plotting parameters -grid = plt.GridSpec(1, 2, wspace=0.3, hspace=0.3) -fig, ax = plt.subplots(1, 2, figsize=double) - -## plot into containers -plt.subplot(grid[0, 0]) -plt.title("azimuth prediction") -mappable = plt.hist2d( - azimuth.azimuth_pred, azimuth.azimuth, bins=bin_number, cmap="viridis" -) -colorbar(mappable[3]) - -plt.subplot(grid[0, 1]) -plt.title("zenith prediction") -mappable = plt.hist2d( - zenith.zenith_pred, zenith.zenith, bins=bin_number, cmap="viridis" -) -colorbar(mappable[3]) - -# save the plot -plt.savefig(outdir + "AngleResults.png") diff --git a/multi_classification_on_stop_and_track_muons/plotting/reconstruction/script_archive/reconstruction_Leon_MC.py b/multi_classification_on_stop_and_track_muons/plotting/reconstruction/script_archive/reconstruction_Leon_MC.py deleted file mode 100644 index 2e35d48..0000000 --- a/multi_classification_on_stop_and_track_muons/plotting/reconstruction/script_archive/reconstruction_Leon_MC.py +++ /dev/null @@ -1,57 +0,0 @@ -import os, sys -sys.path.append(os.path.abspath(os.path.join(os.path.dirname( __file__ ), '..'))) -import pandas as pd -import argparse -from helper_functions.plot_params import * - -parser = argparse.ArgumentParser( - description="plotting the predicted zenith and azimuth vs truth." -) -parser.add_argument( - "-db", - "--database", - dest="path_to_csv", - type=str, - help="path to database [str]", - default="/groups/icecube/peter/storage/MoonPointing/Models/Leon_Muon_data_MC/last_one_lvl3MC/dynedge_zenith_Leon_muon_data_MC/results.csv", -) -parser.add_argument( - "-o", - "--output", - dest="output", - type=str, - help="the output path [str]", - default="/groups/icecube/qgf305/workspace/analyses/moon_pointing_analysis/plotting/reconstruction/test_plot", -) -parser.add_argument( - "-b", - "--bins", - dest="bins", - type=int, - help="the number of bins [str]", - default=25, -) -args = parser.parse_args() - -# azimuth = "" -# azimuth = pd.read_csv(azimuth) -# print(len(azimuth.azimuth_pred)) -# plt.figure() -# plt.hist2d(azimuth.azimuth_pred, azimuth.azimuth, bins = bin_number,cmap='viridis') -# plt.title("results: zenith prediction") -# plt.colorbar() -# plt.legend() -# plt.savefig("/groups/icecube/peter/workspace/graphnetmoon/graphnet/studies/Moon_Pointing_Analysis/plotting/Test_Plots/Leon_MC_Muon_data/azimuth_true_vs_pred.png") -# -zenith = "/groups/icecube/peter/storage/MoonPointing/Models/Leon_Muon_data_MC/last_one_lvl3MC/dynedge_zenith_Leon_muon_data_MC/results.csv" -zenith = pd.read_csv(zenith) - -plt.figure() -plt.hist2d(zenith.zenith_pred, zenith.zenith, bins=args.bins, cmap="viridis") -plt.title("results: zenith prediction") -plt.xlabel("zenith prediction") -plt.xlim((0, 1.5)) -plt.ylabel("true zenith") -plt.colorbar() -plt.legend() -plt.savefig(args.output + "zenith_true_vs_pred.png") diff --git a/multi_classification_on_stop_and_track_muons/plotting/uncertainty/plot_all_in_folder.sh b/multi_classification_on_stop_and_track_muons/plotting/uncertainty/plot_all_in_folder.sh index 5ea4052..0f19072 100644 --- a/multi_classification_on_stop_and_track_muons/plotting/uncertainty/plot_all_in_folder.sh +++ b/multi_classification_on_stop_and_track_muons/plotting/uncertainty/plot_all_in_folder.sh @@ -7,11 +7,10 @@ bash_directory=$(dirname -- "$(readlink -f "${BASH_SOURCE}")") # to recreate the results, follow the steps below. # (1) designate directory containing database; data described in folder. database_directory=(\ -/groups/icecube/petersen/GraphNetDatabaseRepository/moon_pointing_analysis/trained_models/dynedge_azimuth_example/results.csv \ -/groups/icecube/petersen/GraphNetDatabaseRepository/moon_pointing_analysis/trained_models/dynedge_zenith_example/results.csv \ +/groups/icecube/petersen/GraphNetDatabaseRepository/example_results/train_classification_model/last_one_lvl3MC/dynedge_pid_example/results.csv ) # (2) designate the pulsemap used. -pulsemap=TWSRTHVInIcePulses +pulsemap=SplitInIcePulses # (3) specifically for the heatmap, define the number of bins. bins=500 # (4) to run this shell script; copy file path and execute "bash " diff --git a/multi_classification_on_stop_and_track_muons/plotting/uncertainty/script_archive/Uncertainty_test_azimuth.py b/multi_classification_on_stop_and_track_muons/plotting/uncertainty/script_archive/Uncertainty_test_azimuth.py deleted file mode 100644 index 138c093..0000000 --- a/multi_classification_on_stop_and_track_muons/plotting/uncertainty/script_archive/Uncertainty_test_azimuth.py +++ /dev/null @@ -1,266 +0,0 @@ -import pandas as pd -import numpy as np -from scipy import stats -from scipy.stats import binom, poisson, norm -from helper_functions.plot_params import * -from iminuit import Minuit - -from helper_functions.external_functions import Chi2Regression -from helper_functions.external_functions import ( - nice_string_output, - add_text_to_ax, -) # Useful functions to print fit results on figure - -bin_number = 500 - -azimuth_db = "/groups/icecube/peter/storage/MoonPointing/data/Sschindler_data_L4/Trained_Models/dynedge_azimuth_all_example/results.csv" -azimuth_db = pd.read_csv(azimuth_db) -# print(azimuth_db.head(10)) -zenith_db = "/groups/icecube/peter/storage/MoonPointing/data/Sschindler_data_L4/Trained_Models/dynedge_zenith_all_example/results.csv" -zenith_db = pd.read_csv(zenith_db) -zenith = zenith_db.zenith - -azimuth, azimuth_pred, = ( - azimuth_db.azimuth, - azimuth_db.azimuth_pred, -) -azimuth_std = 1 / np.sqrt(azimuth_db.azimuth_kappa_pred) -azimuth_diff = azimuth_pred - azimuth - -print(azimuth_diff[azimuth_diff > np.pi]) -azimuth_diff[azimuth_diff > np.pi] = (azimuth_diff[azimuth_diff > np.pi] - 2 * np.pi) -azimuth_diff[azimuth_diff < -np.pi] = (azimuth_diff[azimuth_diff < -np.pi] + 2 * np.pi) -print(azimuth_diff[:10]) -azimuth_z = azimuth_diff / azimuth_std - - -def set_var_if_None(var, x): - if var is not None: - return np.array(var) - else: - return np.ones_like(x) - - -def double_gaussian(x, N1, N2, mu1, mu2, sigma1, sigma2): - return N1 * 1.0 / (sigma1 * np.sqrt(2 * np.pi)) * np.exp( - -0.5 * (x - mu1) ** 2 / sigma1**2 - ) + N2 * 1.0 / (sigma2 * np.sqrt(2 * np.pi)) * np.exp( - -0.5 * (x - mu2) ** 2 / sigma2**2 - ) - - -def gaussian(x, N, mu, sigma): - return ( - N - * 1.0 - / (sigma * np.sqrt(2 * np.pi)) - * np.exp(-0.5 * (x - mu) ** 2 / sigma**2) - ) - - -### - -# std_pred10 = np.std(azimuth_z[np.abs(azimuth_z) < 10]) -# print(std_pred10) -# def Gauss(x, mu, sig): -# return 1/(sig*np.sqrt(2*np.pi))*np.exp(-np.power(x - mu, 2.) / (2 * np.power(sig, 2.))) - -# x = np.linspace(-10,10,1000) -# y = Gauss(x,0,1.0) -# -# plt.figure() -# plt.hist(azimuth_z, bins = bin_number,density=True) -# plt.plot(x,y) -# plt.xlim([-10,10]) -# plt.title("results: Azimuth Z-score") -# plt.legend() -target = "azimuth" -xmin, xmax = -10, 10 - -counts, bin_edges = np.histogram(azimuth_z, bins=bin_number) -x = (bin_edges[1:][counts > 0] + bin_edges[:-1][counts > 0]) / 2 -y = counts[counts > 0] -sy = np.sqrt( - counts[counts > 0] -) # NOTE: We (naturally) assume that the bin count is Poisson distributed. - -chi2fit = Chi2Regression(double_gaussian, x, y, sy) -chi2fit_single = Chi2Regression(gaussian, x, y, sy) - -minuit_chi2 = Minuit( - chi2fit, N1=1000000, N2=1000000, mu1=0.0, mu2=0.0, sigma1=1, sigma2=5 -) -minuit_chi2_single = Minuit(chi2fit_single, N=1000000, mu=0.0, sigma=1) - -minuit_chi2.migrad() -minuit_chi2_single.migrad() - -fit_N1, fit_N2, fit_mu1, fit_mu2, fit_sigma1, fit_sigma2 = minuit_chi2.values[ - : -] # The fitted values of the parameters -fit_N_single, fit_mu_single, fit_sigma_single = minuit_chi2_single.values[:] - -# Loop to get both parameter values and uncertainties: -print("for double gaussian fit") -for name in minuit_chi2.parameters: - value, error = minuit_chi2.values[name], minuit_chi2.errors[name] - print(f"Fit value: {name} = {value:.5f} +/- {error:.5f}") - -print("for single gaussian fit") -for name in minuit_chi2_single.parameters: - value, error = ( - minuit_chi2_single.values[name], - minuit_chi2_single.errors[name], - ) - print(f"Fit value: {name} = {value:.5f} +/- {error:.5f}") - -# Get Chi2 value: -chi2_value = ( - minuit_chi2.fval -) # The value minimised, i.e. Chi2 or -2*LogLikeliHood (LLH) value -chi2_value_single = minuit_chi2_single.fval - -# Get number of degrees-of-freedom (Ndof): -N_NotEmptyBin = np.sum(y > 0) - -Ndof_value = N_NotEmptyBin - len( - minuit_chi2.values -) # ERDA version (older version of Minuit!) -Ndof_value_single = N_NotEmptyBin - len(minuit_chi2_single.values) - -Prob_value = stats.chi2.sf( - chi2_value, Ndof_value -) # The chi2 probability given N_DOF degrees of freedom -print( - f"for double gaussian: Chi2 value: {chi2_value:.1f} Ndof = {Ndof_value:.0f} Prob(Chi2,Ndof) = {Prob_value:5.3e}" -) - -Prob_value_single = stats.chi2.sf( - chi2_value_single, Ndof_value_single -) # The chi2 probability given N_DOF degrees of freedom -print( - f"for single gaussian: Chi2 value: {chi2_value_single:.1f} Ndof = {Ndof_value_single:.0f} Prob(Chi2,Ndof) = {Prob_value_single:5.3e}" -) - -# Adding fit results to plot: -d = { - "N1": [minuit_chi2.values["N1"], minuit_chi2.errors["N1"]], - "mu1": [minuit_chi2.values["mu1"], minuit_chi2.errors["mu1"]], - "sigma1": [minuit_chi2.values["sigma1"], minuit_chi2.errors["sigma1"]], - "N2": [minuit_chi2.values["N2"], minuit_chi2.errors["N2"]], - "mu2": [minuit_chi2.values["mu2"], minuit_chi2.errors["mu2"]], - "sigma2": [minuit_chi2.values["sigma2"], minuit_chi2.errors["sigma2"]], - "Chi2": chi2_value, - "ndf": Ndof_value, - "Prob": Prob_value, -} - -d_single = { - "N": [minuit_chi2_single.values["N"], minuit_chi2_single.errors["N"]], - "mu": [minuit_chi2_single.values["mu"], minuit_chi2_single.errors["mu"]], - "sigma": [ - minuit_chi2_single.values["sigma"], - minuit_chi2_single.errors["sigma"], - ], - "Chi2": chi2_value_single, - "ndf": Ndof_value_single, - "Prob": Prob_value_single, -} - - -fig, ax = plt.subplots(figsize=(16, 8)) # figsize is in inches -ax.errorbar( - x, - y, - yerr=sy, - xerr=0.0, - label="Data, with Poisson errors", - fmt=".k", - ecolor="k", - elinewidth=1, - capsize=1, - capthick=1, -) -ax.set_xlim(xmin, xmax) -x_axis = np.linspace(xmin - 0.001, xmax + 0.001, 1000) -ax.plot( - x_axis, - double_gaussian(x_axis, *minuit_chi2.values), - "-r", - label="Chi2 fit double gaussian distribution", -) -ax.plot( - x_axis, - gaussian(x_axis, fit_N1, fit_mu1, fit_sigma1), - "-b", - label="Chi2 fit gaussian 1 distribution", -) -ax.plot( - x_axis, - gaussian(x_axis, fit_N2, fit_mu2, fit_sigma2), - "-g", - label="Chi2 fit gaussian 2 distribution", -) - -text = nice_string_output(d, extra_spacing=2, decimals=3) -add_text_to_ax(0.62, 0.90, text, ax, fontsize=16) - -ax.set( - xlabel="Z-score", # the label of the y axis - ylabel="Frequency", # the label of the y axis - title=f"Distribution of z-scores for {target}", -) # the title of the plot -ax.legend(loc="upper left") -# could also be # loc = 'upper right' e.g. -plt.savefig( - "/groups/icecube/peter/workspace/graphnetmoon/graphnet/studies/Moon_Pointing_Analysis/plotting/Test_Plots/Model_trained_on_neutrinos/Uncertainty_test/Azimuth_Z_score_double_gaussian.png" -) - - -fig, ax = plt.subplots(figsize=(16, 8)) # figsize is in inches -ax.errorbar( - x, - y, - yerr=sy, - xerr=0.0, - label="Data, with Poisson errors", - fmt=".k", - ecolor="k", - elinewidth=1, - capsize=1, - capthick=1, -) -ax.set_xlim(xmin, xmax) -x_axis = np.linspace(xmin - 0.001, xmax + 0.001, 1000) -ax.plot( - x_axis, - gaussian(x_axis, *minuit_chi2_single.values), - "-r", - label="Chi2 fit single gaussian distribution", -) - - -text_single = nice_string_output(d_single, extra_spacing=2, decimals=3) -add_text_to_ax(0.62, 0.90, text_single, ax, fontsize=16) - -ax.set( - xlabel="Z-score", # the label of the y axis - ylabel="Frequency", # the label of the y axis - title=f"Distribution of z-scores for {target}", -) # the title of the plot -ax.legend(loc="upper left") -# could also be # loc = 'upper right' e.g. -plt.savefig( - "/groups/icecube/peter/workspace/graphnetmoon/graphnet/studies/Moon_Pointing_Analysis/plotting/Test_Plots/Model_trained_on_neutrinos/Uncertainty_test/Azimuth_Z_score_single_gaussian.png" -) - - -bin_number_2 = 50 -plt.figure() -plt.hist2d(zenith, azimuth_diff, bins=bin_number_2, cmap="viridis") -plt.title("Azimuthal error as function of true zenith") -plt.colorbar() -plt.legend() -plt.savefig( - "/groups/icecube/peter/workspace/graphnetmoon/graphnet/studies/Moon_Pointing_Analysis/plotting/Test_Plots/Model_trained_on_neutrinos/Uncertainty_test/Azimuth_Z_score_per_zenith.png" -) diff --git a/multi_classification_on_stop_and_track_muons/plotting/uncertainty/script_archive/Uncertainty_test_zenith.py b/multi_classification_on_stop_and_track_muons/plotting/uncertainty/script_archive/Uncertainty_test_zenith.py deleted file mode 100644 index 07101f7..0000000 --- a/multi_classification_on_stop_and_track_muons/plotting/uncertainty/script_archive/Uncertainty_test_zenith.py +++ /dev/null @@ -1,154 +0,0 @@ -import pandas as pd -import numpy as np -from scipy import stats -from scipy.stats import binom, poisson, norm -from helper_functions.plot_params import * -from iminuit import Minuit - -from helper_functions.external_functions import Chi2Regression -from helper_functions.external_functions import ( - nice_string_output, - add_text_to_ax, - set_var_if_None, - double_gaussian, - gaussian, -) # Useful functions to print fit results on figure - - -bin_number = 500 - -zenith_db = "/groups/icecube/peter/storage/MoonPointing/data/Sschindler_data_L4/Trained_Models/dynedge_zenith_all_example/results.csv" -zenith_db = pd.read_csv(zenith_db) -print(zenith_db.head(10)) - -zenith, zenith_pred, = ( - zenith_db.zenith, - zenith_db.zenith_pred, -) -zenith_std = 1 / np.sqrt(zenith_db.zenith_kappa_pred) -zenith_diff = zenith_pred - zenith -zenith_z = zenith_diff / zenith_std - -### - -# std_pred10 = np.std(zenith_z[np.abs(zenith_z) < 10]) -# print(std_pred10) -# def Gauss(x, mu, sig): -# return 1/(sig*np.sqrt(2*np.pi))*np.exp(-np.power(x - mu, 2.) / (2 * np.power(sig, 2.))) - -# x = np.linspace(-10,10,1000) -# y = Gauss(x,0,1.0) -# -# plt.figure() -# plt.hist(zenith_z, bins = bin_number,density=True) -# plt.plot(x,y) -# plt.xlim([-10,10]) -# plt.title("results: zenith Z-score") -# plt.legend() -target = "zenith" -xmin, xmax = -10, 10 - -counts, bin_edges = np.histogram(zenith_z, bins=bin_number) -x = (bin_edges[1:][counts > 0] + bin_edges[:-1][counts > 0]) / 2 -y = counts[counts > 0] -sy = np.sqrt( - counts[counts > 0] -) # NOTE: We (naturally) assume that the bin count is Poisson distributed. - -chi2fit = Chi2Regression(double_gaussian, x, y, sy) - -minuit_chi2 = Minuit( - chi2fit, N1=1000000, N2=1000000, mu1=0.0, mu2=0.0, sigma1=1, sigma2=5 -) - -minuit_chi2.migrad() - -fit_N1, fit_N2, fit_mu1, fit_mu2, fit_sigma1, fit_sigma2 = minuit_chi2.values[ - : -] # The fitted values of the parameters - -# Loop to get both parameter values and uncertainties: -for name in minuit_chi2.parameters: - value, error = minuit_chi2.values[name], minuit_chi2.errors[name] - print(f"Fit value: {name} = {value:.5f} +/- {error:.5f}") - -# Get Chi2 value: -chi2_value = ( - minuit_chi2.fval -) # The value minimised, i.e. Chi2 or -2*LogLikeliHood (LLH) value - -# Get number of degrees-of-freedom (Ndof): -N_NotEmptyBin = np.sum(y > 0) - -Ndof_value = N_NotEmptyBin - len( - minuit_chi2.values -) # ERDA version (older version of Minuit!) - -Prob_value = stats.chi2.sf( - chi2_value, Ndof_value -) # The chi2 probability given N_DOF degrees of freedom -print( - f"Chi2 value: {chi2_value:.1f} Ndof = {Ndof_value:.0f} Prob(Chi2,Ndof) = {Prob_value:5.3e}" -) - -# Adding fit results to plot: -d = { - "N1": [minuit_chi2.values["N1"], minuit_chi2.errors["N1"]], - "mu1": [minuit_chi2.values["mu1"], minuit_chi2.errors["mu1"]], - "sigma1": [minuit_chi2.values["sigma1"], minuit_chi2.errors["sigma1"]], - "N2": [minuit_chi2.values["N2"], minuit_chi2.errors["N2"]], - "mu2": [minuit_chi2.values["mu2"], minuit_chi2.errors["mu2"]], - "sigma2": [minuit_chi2.values["sigma2"], minuit_chi2.errors["sigma2"]], - "Chi2": chi2_value, - "ndf": Ndof_value, - "Prob": Prob_value, -} - - -fig, ax = plt.subplots(figsize=(16, 8)) # figsize is in inches -ax.errorbar( - x, - y, - yerr=sy, - xerr=0.0, - label="Data, with Poisson errors", - fmt=".k", - ecolor="k", - elinewidth=1, - capsize=1, - capthick=1, -) -ax.set_xlim(xmin, xmax) -x_axis = np.linspace(xmin - 0.001, xmax + 0.001, 1000) -ax.plot( - x_axis, - double_gaussian(x_axis, *minuit_chi2.values), - "-r", - label="Chi2 fit double gaussian distribution", -) -ax.plot( - x_axis, - gaussian(x_axis, fit_N1, fit_mu1, fit_sigma1), - "-b", - label="Chi2 fit gaussian 1 distribution", -) -ax.plot( - x_axis, - gaussian(x_axis, fit_N2, fit_mu2, fit_sigma2), - "-g", - label="Chi2 fit gaussian 2 distribution", -) - -text = nice_string_output(d, extra_spacing=2, decimals=3) -add_text_to_ax(0.62, 0.90, text, ax, fontsize=16) - -ax.set( - xlabel="Z-score", # the label of the y axis - ylabel="Frequency", # the label of the y axis - title=f"Distribution of z-scores for {target}", -) # the title of the plot -ax.legend(loc="upper left") -# could also be # loc = 'upper right' e.g. -plt.savefig( - "/groups/icecube/peter/workspace/graphnetmoon/graphnet/studies/Moon_Pointing_Analysis/plotting/Test_Plots/Model_trained_on_neutrinos/Uncertainty_test/zenith_Z_score.png" -) From 0b4606f187c6a0dfbd379708d415b1146e9ee5cb Mon Sep 17 00:00:00 2001 From: Morten Holm Date: Tue, 6 Dec 2022 09:23:37 +0100 Subject: [PATCH 2/2] all things classification --- .../README.md | 0 .../data/convert_i3_files.py | 0 ...p_MC_Level2_nugen_numu_IC86.2012.011069.sh | 0 .../data/pipeline_template.sh | 0 .../development_do_not_commit/test.py | 0 .../train_classification_model.py | 0 .../development_do_not_commit/unit_test.py | 0 .../modelling/train_classification_model.py | 0 ...n_classification_stopped_through_LeonMC.sh | 4 +- .../Classification_performance/plot_cm.py | 112 --- .../plot_confusion_matrix.py | 43 ++ .../plot_probability_heatmaps.py | 77 ++ .../Classification_performance/plot_roc.ipynb | 663 ------------------ .../Classification_performance/plot_roc.py | 148 ++++ .../script_archive}/cm.ipynb | 0 .../script_archive}/plot_roc.ipynb | 0 .../Comparison_RD_MC/Comparison_RD_to_MC.py | 0 .../plotting/Comparison_RD_MC/RD_to_MC.ipynb | 0 .../Comparison_RD_MC/Reweight MC data.ipynb | 0 .../plotting/Comparison_RD_MC/logit.ipynb | 0 .../Comparison_RD_MC/logit_individual.ipynb | 0 .../plotting/__init__.py | 0 .../plotting/distributions/PID_predictions.py | 59 ++ .../distributions/PID_predictions_fit.py | 112 +++ .../distributions/PID_predictions_logit.py | 41 ++ .../PID_predictions_logit_fit.py | 149 ++++ .../distributions/plot_all_in_folder.sh | 4 - .../PIDofPrediction.ipynb | 0 .../PIDofPrediction2D.ipynb | 0 .../PIDofPredictionMCRD.ipynb | 0 .../PIDofPrediction_RD.ipynb | 0 .../distributions/script_archive/fit.ipynb | 382 ++++++++++ .../{ => script_archive}/noise_cut.ipynb | 0 .../predictionOfPID.ipynb | 0 ...t_and_duration_distribution_from_sqlite.py | 0 .../plotting/event_location/event_heatmap.py | 0 .../event_location/plot_all_in_folder.sh | 0 .../event_location/single_event_position.py | 0 .../plotting/helper_functions/bash_test.sh | 0 .../helper_functions/external_functions.py | 14 + .../plotting/helper_functions/parsing.py | 47 ++ .../plotting/helper_functions/plot_params.py | 22 +- .../plotting/plot_all.sh | 88 +++ .../individual_zenith_kappa_reconstruction.py | 0 .../reconstruction/plot_all_in_folder.sh | 0 .../plotting/test.ipynb | 0 .../uncertainty/plot_all_in_folder.sh | 0 .../plotting/uncertainty/uncertainty_test.py | 0 .../preprocessing/calibration_test.ipynb | 153 ++++ .../classification_calibration.py | 239 +++++++ .../preprocessing/get_indices_from_cut.py | 0 .../preprocessing/test.ipynb | 514 ++++++++++++++ 52 files changed, 2089 insertions(+), 782 deletions(-) mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/README.md mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/data/convert_i3_files.py mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/data/pipeline_hep_MC_Level2_nugen_numu_IC86.2012.011069.sh mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/data/pipeline_template.sh mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/development_do_not_commit/test.py mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/development_do_not_commit/train_classification_model.py mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/development_do_not_commit/unit_test.py mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/modelling/train_classification_model.py delete mode 100644 multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_cm.py create mode 100755 multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_confusion_matrix.py create mode 100755 multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_probability_heatmaps.py delete mode 100644 multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_roc.ipynb create mode 100755 multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_roc.py rename multi_classification_on_stop_and_track_muons/plotting/{Comparison_RD_MC => Classification_performance/script_archive}/cm.ipynb (100%) mode change 100644 => 100755 rename multi_classification_on_stop_and_track_muons/plotting/{Comparison_RD_MC => Classification_performance/script_archive}/plot_roc.ipynb (100%) mode change 100644 => 100755 mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/Comparison_RD_to_MC.py mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/RD_to_MC.ipynb mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/Reweight MC data.ipynb mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/logit.ipynb mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/logit_individual.ipynb mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/plotting/__init__.py create mode 100755 multi_classification_on_stop_and_track_muons/plotting/distributions/PID_predictions.py create mode 100755 multi_classification_on_stop_and_track_muons/plotting/distributions/PID_predictions_fit.py create mode 100755 multi_classification_on_stop_and_track_muons/plotting/distributions/PID_predictions_logit.py create mode 100755 multi_classification_on_stop_and_track_muons/plotting/distributions/PID_predictions_logit_fit.py mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/plotting/distributions/plot_all_in_folder.sh rename multi_classification_on_stop_and_track_muons/plotting/distributions/{ => script_archive}/PIDofPrediction.ipynb (100%) mode change 100644 => 100755 rename multi_classification_on_stop_and_track_muons/plotting/distributions/{ => script_archive}/PIDofPrediction2D.ipynb (100%) mode change 100644 => 100755 rename multi_classification_on_stop_and_track_muons/plotting/distributions/{ => script_archive}/PIDofPredictionMCRD.ipynb (100%) mode change 100644 => 100755 rename multi_classification_on_stop_and_track_muons/plotting/distributions/{ => script_archive}/PIDofPrediction_RD.ipynb (100%) mode change 100644 => 100755 create mode 100755 multi_classification_on_stop_and_track_muons/plotting/distributions/script_archive/fit.ipynb rename multi_classification_on_stop_and_track_muons/plotting/distributions/{ => script_archive}/noise_cut.ipynb (100%) mode change 100644 => 100755 rename multi_classification_on_stop_and_track_muons/plotting/distributions/{ => script_archive}/predictionOfPID.ipynb (100%) mode change 100644 => 100755 rename multi_classification_on_stop_and_track_muons/plotting/distributions/{ => script_archive}/pulse_count_and_duration_distribution_from_sqlite.py (100%) mode change 100644 => 100755 mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/plotting/event_location/event_heatmap.py mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/plotting/event_location/plot_all_in_folder.sh mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/plotting/event_location/single_event_position.py mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/plotting/helper_functions/bash_test.sh mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/plotting/helper_functions/parsing.py create mode 100755 multi_classification_on_stop_and_track_muons/plotting/plot_all.sh mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/plotting/reconstruction/individual_zenith_kappa_reconstruction.py mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/plotting/reconstruction/plot_all_in_folder.sh create mode 100755 multi_classification_on_stop_and_track_muons/plotting/test.ipynb mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/plotting/uncertainty/plot_all_in_folder.sh mode change 100644 => 100755 multi_classification_on_stop_and_track_muons/plotting/uncertainty/uncertainty_test.py create mode 100755 multi_classification_on_stop_and_track_muons/preprocessing/calibration_test.ipynb create mode 100755 multi_classification_on_stop_and_track_muons/preprocessing/classification_calibration.py create mode 100755 multi_classification_on_stop_and_track_muons/preprocessing/get_indices_from_cut.py create mode 100755 multi_classification_on_stop_and_track_muons/preprocessing/test.ipynb diff --git a/multi_classification_on_stop_and_track_muons/README.md b/multi_classification_on_stop_and_track_muons/README.md old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/data/convert_i3_files.py b/multi_classification_on_stop_and_track_muons/data/convert_i3_files.py old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/data/pipeline_hep_MC_Level2_nugen_numu_IC86.2012.011069.sh b/multi_classification_on_stop_and_track_muons/data/pipeline_hep_MC_Level2_nugen_numu_IC86.2012.011069.sh old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/data/pipeline_template.sh b/multi_classification_on_stop_and_track_muons/data/pipeline_template.sh old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/development_do_not_commit/test.py b/multi_classification_on_stop_and_track_muons/development_do_not_commit/test.py old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/development_do_not_commit/train_classification_model.py b/multi_classification_on_stop_and_track_muons/development_do_not_commit/train_classification_model.py old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/development_do_not_commit/unit_test.py b/multi_classification_on_stop_and_track_muons/development_do_not_commit/unit_test.py old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/modelling/train_classification_model.py b/multi_classification_on_stop_and_track_muons/modelling/train_classification_model.py old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/modelling/train_classification_stopped_through_LeonMC.sh b/multi_classification_on_stop_and_track_muons/modelling/train_classification_stopped_through_LeonMC.sh index d0515e1..f6c298a 100755 --- a/multi_classification_on_stop_and_track_muons/modelling/train_classification_stopped_through_LeonMC.sh +++ b/multi_classification_on_stop_and_track_muons/modelling/train_classification_stopped_through_LeonMC.sh @@ -18,9 +18,9 @@ epochs=100 patience=10 workers=10 event_numbers=5000 #22000000 # if number goes over available events; use all events -run_name=LeonMC_data_5k #22m +run_name=LeonMC_90percentile_neutrino_data_stop_through #22m -class_options="{0:0,1:1}" +class_options="{0:-1,1:1}" target='stopped_muon' # save the report file to diff --git a/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_cm.py b/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_cm.py deleted file mode 100644 index bae4c13..0000000 --- a/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_cm.py +++ /dev/null @@ -1,112 +0,0 @@ -import sqlite3 as sql - -import numpy as np -import pandas as pd -from pandas import cut, read_sql -import pickle as pkl -from random import choices -from sklearn import metrics -import matplotlib.pyplot as plt -import matplotlib.colors as colors - -indir = "/groups/icecube/peter/storage/Multiclassification/Real/last_one_lvl3MC/dynedge_pid_Real_run_21.5_mill_equal_frac_second_/results.csv" -outdir = "/groups/icecube/qgf305/workspace/analyses/multi_classification_on_stop_and_track_muons/plotting/distributions/test_plot" - -results = pd.read_csv(indir).sort_values('event_no').reset_index(drop = True) - -#print(results.head(10)) -#Noise = 0, muon =1, Neutrino=2 -pid_transform = {1:0,12:2,13:1,14:2,16:2} - -predictions = [] -truth = [] - -noise = 0 -muons = 0 -neutrinos = 0 - -number = len(results) - -for i in range(number):# range(len(results)): - noise_pred = results['pid_noise_pred'].values[i] - muon_pred = results['pid_muon_pred'].values[i] - neutrino_pred = results['pid_neutrino_pred'].values[i] - predictions.append(np.argmax([noise_pred,muon_pred,neutrino_pred])) - - truth.append(pid_transform[abs(results['pid'].values[i])]) - if pid_transform[abs(results['pid'].values[i])] == 0: - noise+=1 - if pid_transform[abs(results['pid'].values[i])] == 1: - muons+=1 - if pid_transform[abs(results['pid'].values[i])] == 2: - neutrinos+=1 - -print(f'there are {noise} noise, {muons} muons, and {neutrinos} neutrinos') - -confusion_matrix = metrics.confusion_matrix(truth, predictions) -cm_display = metrics.ConfusionMatrixDisplay(confusion_matrix = confusion_matrix, display_labels = ['Noise','Muons','Neutrinos']) -cm_display.plot() -plt.show() -plt.savefig(outdir + 'Confusion_matrix.png') - -bins = 50 - -fig, axs = plt.subplots(3,1,sharex=False,figsize=(8, 16)) - -mask_noise = [True if truth[i] ==0 else False for i in range(len(truth))] -mask_muon = [True if truth[i] ==1 else False for i in range(len(truth))] -mask_neutrino = [True if truth[i] ==2 else False for i in range(len(truth))] - -cd1 = axs[0].hist2d(results['pid_noise_pred'].values[:number][mask_noise],results['pid_neutrino_pred'].values[:number][mask_noise],bins,norm=colors.LogNorm()) -cd2 = axs[1].hist2d(results['pid_noise_pred'].values[:number][mask_muon],results['pid_neutrino_pred'].values[:number][mask_muon],bins,norm=colors.LogNorm()) -cd3 = axs[2].hist2d(results['pid_noise_pred'].values[:number][mask_neutrino],results['pid_neutrino_pred'].values[:number][mask_neutrino],bins,norm=colors.LogNorm()) - - -axs[0].set_ylabel('Noise probability') -axs[1].set_ylabel('Muon probability') -axs[2].set_ylabel('Neutrino probability') - -axs[0].set_xlabel('Noise probability') -axs[1].set_xlabel('Muon probability') -axs[2].set_xlabel('Neutrino probability') - -axs[0].set_title('Noise') -axs[1].set_title('Muons') -axs[2].set_title('Neutrinos') - -fig.colorbar(cd1[3], ax=axs[0]) -fig.colorbar(cd2[3], ax=axs[1]) -fig.colorbar(cd3[3], ax=axs[2]) - - - -fig.tight_layout() - -fig.savefig(outdir + 'prob_heatmaps.png') - - -fpr_neutrino, tpr_neutrino , _ = metrics.roc_curve(truth,results['pid_neutrino_pred'].values,pos_label=2) -fpr_muon, tpr_muon , _ = metrics.roc_curve(truth,results['pid_muon_pred'].values,pos_label=1) -fpr_noise, tpr_noise , _ = metrics.roc_curve(truth,results['pid_noise_pred'].values,pos_label=0) - -auc_neutrino = metrics.auc(fpr_neutrino, tpr_neutrino) -auc_muon = metrics.auc(fpr_muon, tpr_muon) -auc_noise = metrics.auc(fpr_noise, tpr_noise) - - -fig, axs = plt.subplots(figsize=(16, 8)) - -axs.plot(fpr_neutrino, tpr_neutrino, label=f'Neutrino Auc={auc_neutrino}') -axs.plot(fpr_muon, tpr_muon, label=f'Muon Auc={auc_muon}') -axs.plot(fpr_noise, tpr_noise, label=f'Noise Auc={auc_noise}') - -axs.set_xlabel('FPR') -axs.set_ylabel('TPR') -axs.set_title('ROC curves') - - -fig.tight_layout() - -fig.savefig(outdir + 'Roc_curves.png') - - diff --git a/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_confusion_matrix.py b/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_confusion_matrix.py new file mode 100755 index 0000000..ecff0c8 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_confusion_matrix.py @@ -0,0 +1,43 @@ +import os, sys +# ability to fetch scripts +sys.path.append(os.path.abspath(os.path.join(os.path.dirname( __file__ ), '..'))) +from helper_functions.parsing import * +from helper_functions.plot_params import * + +import numpy as np +import pandas as pd +from sklearn import metrics +import torch + +def plot_cm(args): + results = pd.read_csv(args.MC_csv_path).sort_values('event_no').reset_index(drop = True) + + class_options = {1: 0, -1: 0, 13: 1, -13: 1, 12: 2, -12: 2, 14: 2, -14: 2, 16: 2, -16: 2,} + pid_transform = torch.tensor([class_options[int(value)] for value in results["pid"]]) + truth = pid_transform + + # return series of row wise max + predictions = results[['pid_noise_pred','pid_muon_pred','pid_neutrino_pred']].idxmax(axis="columns") + predictions[predictions == "pid_noise_pred"] = 0 + predictions[predictions == "pid_muon_pred"] = 1 + predictions[predictions == "pid_neutrino_pred"] = 2 + + noise_number = len(truth[truth == 0] == True) + muon_number = len(truth[truth == 1] == True) + neutrino_number = len(truth[truth == 2] == True) + + print(f'there are {noise_number} noise, {muon_number} muons, and {neutrino_number} neutrinos') + + confusion_matrix = metrics.confusion_matrix(truth.tolist(), predictions.values.tolist()) + cm_display = metrics.ConfusionMatrixDisplay(confusion_matrix = confusion_matrix, display_labels = ['Noise','Muons','Neutrinos']) + cm_display.plot() + + plt.savefig(args.output + 'Confusion_matrix.png') + + +def main(args): + plot_cm(args) + + +if __name__ == "__main__": + main(get_plotArgs()) \ No newline at end of file diff --git a/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_probability_heatmaps.py b/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_probability_heatmaps.py new file mode 100755 index 0000000..2a6b9a9 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_probability_heatmaps.py @@ -0,0 +1,77 @@ +import os, sys +# ability to fetch scripts +sys.path.append(os.path.abspath(os.path.join(os.path.dirname( __file__ ), '..'))) +from helper_functions.parsing import * +from helper_functions.plot_params import * + +import numpy as np +import pandas as pd +import torch + +def plot_probability_heatmaps(datapath, args): + results = pd.read_csv(datapath).sort_values('event_no').reset_index(drop = True) + + class_options = {1: 0, -1: 0, 13: 1, -13: 1, 12: 2, -12: 2, 14: 2, -14: 2, 16: 2, -16: 2,} + pid_transform = torch.tensor([class_options[int(value)] for value in results["pid"]]) + truth = pid_transform + + number = len(results) + + mask_noise = truth == 0 + mask_muon = truth == 1 + mask_neutrino = truth == 2 + + bins = 50 + + fig, axs = plt.subplots(3,1,sharex=False,figsize=(8, 16)) + + cd1 = axs[0].hist2d( + results['pid_noise_pred'].values[:number][mask_noise], + results['pid_neutrino_pred'].values[:number][mask_noise], + bins,norm=colors.LogNorm() + ) + cd2 = axs[1].hist2d( + results['pid_noise_pred'].values[:number][mask_muon], + results['pid_neutrino_pred'].values[:number][mask_muon], + bins,norm=colors.LogNorm() + ) + cd3 = axs[2].hist2d( + results['pid_noise_pred'].values[:number][mask_neutrino], + results['pid_neutrino_pred'].values[:number][mask_neutrino], + bins,norm=colors.LogNorm() + ) + + axs[0].set_ylabel('Noise probability') + axs[1].set_ylabel('Muon probability') + axs[2].set_ylabel('Neutrino probability') + + axs[0].set_xlabel('Noise probability') + axs[1].set_xlabel('Muon probability') + axs[2].set_xlabel('Neutrino probability') + + axs[0].set_title('Noise') + axs[1].set_title('Muons') + axs[2].set_title('Neutrinos') + + fig.colorbar(cd1[3], ax=axs[0]) + fig.colorbar(cd2[3], ax=axs[1]) + fig.colorbar(cd3[3], ax=axs[2]) + + fig.tight_layout() + # ensure output exists + os.makedirs(args.output, exist_ok=True) + if "MC" in datapath.split("/")[-1][:-4]: + fig.savefig(args.output + 'MC_probability_heatmaps.png') + elif "RD" in datapath.split("/")[-1][:-4]: + fig.savefig(args.output + 'RD_probability_heatmaps.png') + else: + fig.savefig(args.output + 'probability_heatmaps.png') + +def main(args): + if args.MC_csv_path is not None: + plot_probability_heatmaps(datapath=args.MC_csv_path, args=args) + # if args.RD_csv_path is not None: + # plot_probability_heatmaps(datapath=args.RD_csv_path, args=args) + +if __name__ == "__main__": + main(get_plotArgs()) \ No newline at end of file diff --git a/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_roc.ipynb b/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_roc.ipynb deleted file mode 100644 index 697c6ea..0000000 --- a/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_roc.ipynb +++ /dev/null @@ -1,663 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/groups/icecube/qgf305/anaconda3/envs/graphnet/lib/python3.8/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" - ] - } - ], - "source": [ - "import sqlite3 as sql\n", - "\n", - "import numpy as np\n", - "import pandas as pd\n", - "from pandas import cut, read_sql\n", - "import pickle as pkl\n", - "from random import choices\n", - "from sklearn import metrics\n", - "import matplotlib.pyplot as plt\n", - "import matplotlib.colors as colors\n", - "from numpy import interp\n", - "\n", - "from torch.nn.functional import one_hot\n", - "import torch\n", - "from sklearn.metrics import auc\n", - "from sklearn.metrics import roc_curve, auc\n", - "from sklearn.multiclass import OneVsRestClassifier\n", - "from sklearn.metrics import roc_auc_score\n", - "from sklearn.preprocessing import label_binarize" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "def get_roc_and_auc(pred, target, labels=None):\n", - " if labels==None:\n", - " fpr, tpr, _ = roc_curve(pred, target)\n", - " else: \n", - " fpr, tpr, _ = roc_curve(pred, target, pos_label=labels)\n", - " auc_score = auc(fpr,tpr)\n", - " return fpr,tpr,auc_score \n", - "\n", - "def plot_roc(data, target):#, save_dir, save_as_csv = False):\n", - " fpr, tpr, auc = get_roc_and_auc(data, target)\n", - " \n", - " width = 3.176*2\n", - " height = 2.388*2\n", - " fig = plt.figure(figsize = (width,height))\n", - " plt.plot(fpr,tpr, label ='%s'%(round(auc,3)))\n", - " plt.legend()\n", - " plt.title('feature selection: 10^6')\n", - " plt.ylabel('True Positive Rate', fontsize = 12)\n", - " plt.xlabel('False Positive Rate', fontsize = 12)\n", - " return" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "pids = [1,12,13]" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "indir = \"/groups/icecube/peter/storage/Multiclassification/Real/last_one_lvl3MC/dynedge_pid_Real_run_21.5_mill_equal_frac_/results_first.csv\"\n", - "results = pd.read_csv(indir, index_col=[0]).sort_values('event_no').reset_index()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[-16. -14. -12. -1. 12. 13. 14. 16.]\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
indexpid_noise_predpid_muon_predpid_neutrino_predpidevent_no
051206860.9985000.0000700.001430-1.00.0
142425880.9901030.0012910.008606-1.04.0
217719110.9541510.0022270.043622-1.09.0
355210110.9800690.0004060.019525-1.027.0
428402541.0000000.0000000.000000-1.043.0
.....................
742499558502061.0000000.0000000.000000-1.098614183.0
742499617028961.0000000.0000000.000000-1.098614190.0
742499724388541.0000000.0000000.000000-1.098614194.0
742499822838180.9996850.0000120.000303-1.098614197.0
742499935828761.0000000.0000000.000000-1.098614207.0
\n", - "

7425000 rows × 6 columns

\n", - "
" - ], - "text/plain": [ - " index pid_noise_pred pid_muon_pred pid_neutrino_pred pid \\\n", - "0 5120686 0.998500 0.000070 0.001430 -1.0 \n", - "1 4242588 0.990103 0.001291 0.008606 -1.0 \n", - "2 1771911 0.954151 0.002227 0.043622 -1.0 \n", - "3 5521011 0.980069 0.000406 0.019525 -1.0 \n", - "4 2840254 1.000000 0.000000 0.000000 -1.0 \n", - "... ... ... ... ... ... \n", - "7424995 5850206 1.000000 0.000000 0.000000 -1.0 \n", - "7424996 1702896 1.000000 0.000000 0.000000 -1.0 \n", - "7424997 2438854 1.000000 0.000000 0.000000 -1.0 \n", - "7424998 2283818 0.999685 0.000012 0.000303 -1.0 \n", - "7424999 3582876 1.000000 0.000000 0.000000 -1.0 \n", - "\n", - " event_no \n", - "0 0.0 \n", - "1 4.0 \n", - "2 9.0 \n", - "3 27.0 \n", - "4 43.0 \n", - "... ... \n", - "7424995 98614183.0 \n", - "7424996 98614190.0 \n", - "7424997 98614194.0 \n", - "7424998 98614197.0 \n", - "7424999 98614207.0 \n", - "\n", - "[7425000 rows x 6 columns]" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "print(np.unique(results[\"pid\"]))\n", - "results" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 1, 12, 13])" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "## transform data\n", - "# remove anti\n", - "results['pid'] = results['pid'].apply(abs)\n", - "# make all neutrinos the same class; to match prediction\n", - "results.loc[results['pid']==14, \"pid\"]=12\n", - "results.loc[results['pid']==16, \"pid\"]=12\n", - "results[\"pid\"] = results[\"pid\"].astype(\"int\")\n", - "np.unique(results[\"pid\"])" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "# Binarize the output\n", - "pid_true = label_binarize(results[\"pid\"], classes=[1, 12, 13])\n", - "nb_classes = pid_true.shape[1]" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0, 1])" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "y_test = pid_true \n", - "y_prob = results[[\"pid_noise_pred\",\"pid_muon_pred\",\"pid_neutrino_pred\"]]\n", - "y_test\n", - "np.unique(y_test[2])" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
pid_noise_predpid_muon_predpid_neutrino_pred
00.9985000.0000700.001430
10.9901030.0012910.008606
20.9541510.0022270.043622
30.9800690.0004060.019525
41.0000000.0000000.000000
............
74249951.0000000.0000000.000000
74249961.0000000.0000000.000000
74249971.0000000.0000000.000000
74249980.9996850.0000120.000303
74249991.0000000.0000000.000000
\n", - "

7425000 rows × 3 columns

\n", - "
" - ], - "text/plain": [ - " pid_noise_pred pid_muon_pred pid_neutrino_pred\n", - "0 0.998500 0.000070 0.001430\n", - "1 0.990103 0.001291 0.008606\n", - "2 0.954151 0.002227 0.043622\n", - "3 0.980069 0.000406 0.019525\n", - "4 1.000000 0.000000 0.000000\n", - "... ... ... ...\n", - "7424995 1.000000 0.000000 0.000000\n", - "7424996 1.000000 0.000000 0.000000\n", - "7424997 1.000000 0.000000 0.000000\n", - "7424998 0.999685 0.000012 0.000303\n", - "7424999 1.000000 0.000000 0.000000\n", - "\n", - "[7425000 rows x 3 columns]" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "y_prob" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "metadata": {}, - "outputs": [], - "source": [ - "fpr = dict()\n", - "tpr = dict()\n", - "roc_auc = dict()\n", - "for i in range(nb_classes):\n", - " fpr[i], tpr[i], _ = roc_curve(y_test[:, i], y_prob.iloc[:, i])\n", - " roc_auc[i] = auc(fpr[i], tpr[i])\n", - "\n", - "# Compute micro-average ROC curve and ROC area\n", - "fpr[\"micro\"], tpr[\"micro\"], _ = roc_curve(y_test.ravel(), y_prob.values.ravel())\n", - "roc_auc[\"micro\"] = auc(fpr[\"micro\"], tpr[\"micro\"])" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Plot of a ROC curve for a specific class\n", - "test = 1\n", - "plt.figure()\n", - "plt.plot(fpr[test], tpr[test], label='ROC curve (area = %0.2f)' % roc_auc[test])\n", - "plt.plot([0, 1], [0, 1], 'k--')\n", - "plt.xlim([0.0, 1.0])\n", - "plt.ylim([0.0, 1.05])\n", - "plt.xlabel('False Positive Rate')\n", - "plt.ylabel('True Positive Rate')\n", - "plt.title('Receiver operating characteristic example')\n", - "plt.legend(loc=\"lower right\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_36023/2474506920.py:7: DeprecationWarning: scipy.interp is deprecated and will be removed in SciPy 2.0.0, use numpy.interp instead\n", - " mean_tpr += interp(all_fpr, fpr[i], tpr[i])\n" - ] - } - ], - "source": [ - "# First aggregate all false positive rates\n", - "all_fpr = np.unique(np.concatenate([fpr[i] for i in range(nb_classes)]))\n", - "\n", - "# Then interpolate all ROC curves at this points\n", - "mean_tpr = np.zeros_like(all_fpr)\n", - "for i in range(nb_classes):\n", - " mean_tpr += interp(all_fpr, fpr[i], tpr[i])\n", - "\n", - "# Finally average it and compute AUC\n", - "mean_tpr /= nb_classes\n", - "\n", - "fpr[\"macro\"] = all_fpr\n", - "tpr[\"macro\"] = mean_tpr\n", - "roc_auc[\"macro\"] = auc(fpr[\"macro\"], tpr[\"macro\"])" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Plot all ROC curves\n", - "plt.figure(figsize=(20,10))\n", - "plt.plot(\n", - " fpr[\"micro\"], tpr[\"micro\"],\n", - " color=\"tab:olive\", linestyle='dashdot',\n", - " label='micro-average ROC curve (area = {0:0.2f})'\n", - " ''.format(roc_auc[\"micro\"]),\n", - " linewidth=2)\n", - "\n", - "plt.plot(\n", - " fpr[\"macro\"], tpr[\"macro\"],\n", - " color=\"tab:purple\", linestyle='dashdot',\n", - " label='macro-average ROC curve (area = {0:0.2f})'\n", - " ''.format(roc_auc[\"macro\"]),\n", - " linewidth=2)\n", - "\n", - "colors=[\"tab:blue\",\"tab:green\",\"tab:orange\"]\n", - "\n", - "for i, item in enumerate([\"noise\", \"muon\", \"neutrino\"]):\n", - " plt.plot(fpr[i], tpr[i], color=colors[i], label='ROC of {0} class (area = {1:0.2f})'\n", - " ''.format(item, roc_auc[i]))\n", - "\n", - "plt.plot([0, 1], [0, 1], 'k--')\n", - "plt.xlim([0.0, 1.0])\n", - "plt.ylim([0.0, 1.05])\n", - "plt.xlabel('False Positive Rate')\n", - "plt.ylabel('True Positive Rate')\n", - "plt.title('Receiver operating characteristic to multi-class')\n", - "plt.legend(loc=\"lower right\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 65, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "One-vs-One ROC AUC scores:\n", - "0.605663 (macro),\n", - "0.605656 (weighted by prevalence)\n", - "One-vs-Rest ROC AUC scores:\n", - "0.605663 (macro),\n", - "0.605656 (weighted by prevalence)\n" - ] - } - ], - "source": [ - "macro_roc_auc_ovo = roc_auc_score(y_test, y_prob, multi_class=\"ovo\", average=\"macro\")\n", - "weighted_roc_auc_ovo = roc_auc_score(\n", - " y_test, y_prob, multi_class=\"ovo\", average=\"weighted\"\n", - ")\n", - "macro_roc_auc_ovr = roc_auc_score(y_test, y_prob, multi_class=\"ovr\", average=\"macro\")\n", - "weighted_roc_auc_ovr = roc_auc_score(\n", - " y_test, y_prob, multi_class=\"ovr\", average=\"weighted\"\n", - ")\n", - "print(\n", - " \"One-vs-One ROC AUC scores:\\n{:.6f} (macro),\\n{:.6f} \"\n", - " \"(weighted by prevalence)\".format(macro_roc_auc_ovo, weighted_roc_auc_ovo)\n", - ")\n", - "print(\n", - " \"One-vs-Rest ROC AUC scores:\\n{:.6f} (macro),\\n{:.6f} \"\n", - " \"(weighted by prevalence)\".format(macro_roc_auc_ovr, weighted_roc_auc_ovr)\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.8.13 ('graphnet')", - "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.13" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "e54c104f54ca5f79eede1c2e02355cc39841da57601eff628eedcebaaa867660" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_roc.py b/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_roc.py new file mode 100755 index 0000000..0ea470a --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/plot_roc.py @@ -0,0 +1,148 @@ +import os, sys +# ability to fetch scripts +sys.path.append(os.path.abspath(os.path.join(os.path.dirname( __file__ ), '..'))) +from helper_functions.parsing import * + +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt +import matplotlib.colors as colors +from numpy import interp +import torch +from torch.nn.functional import one_hot + +from sklearn.metrics import roc_curve, auc, roc_auc_score + +def plot_roc(args): + results = pd.read_csv(args.MC_csv_path, index_col=[0]).sort_values('event_no').reset_index() + + class_options = {1: 0, -1: 0, 13: 1, -13: 1, 12: 2, -12: 2, 14: 2, -14: 2, 16: 2, -16: 2,} + pid_transform = torch.tensor([class_options[int(value)] for value in results["pid"]]) + + y_test = one_hot(pid_transform) + y_prob = results[["pid_noise_pred","pid_muon_pred","pid_neutrino_pred"]] + print("same shape: ", y_test.shape == y_prob.shape, y_test.shape) + + nb_classes = y_test.shape[1] + fpr = dict() + tpr = dict() + roc_auc = dict() + for i in range(nb_classes): + fpr[i], tpr[i], _ = roc_curve(y_test[:, i], y_prob.iloc[:, i], pos_label=1) + roc_auc[i] = auc(fpr[i], tpr[i]) + + # Compute micro-average ROC curve and ROC area + fpr["micro"], tpr["micro"], _ = roc_curve(y_test.ravel(), y_prob.values.ravel()) + roc_auc["micro"] = auc(fpr["micro"], tpr["micro"]) + + # First aggregate all false positive rates + all_fpr = np.unique(np.concatenate([fpr[i] for i in range(nb_classes)])) + + # Then interpolate all ROC curves at this points + mean_tpr = np.zeros_like(all_fpr) + for i in range(nb_classes): + mean_tpr += interp(all_fpr, fpr[i], tpr[i]) + + # Finally average it and compute AUC + mean_tpr /= nb_classes + + fpr["macro"] = all_fpr + tpr["macro"] = mean_tpr + roc_auc["macro"] = auc(fpr["macro"], tpr["macro"]) + + + + macro_roc_auc_ovo = roc_auc_score(y_test, y_prob, multi_class="ovo", average="macro") + weighted_roc_auc_ovo = roc_auc_score( + y_test, y_prob, multi_class="ovo", average="weighted" + ) + macro_roc_auc_ovr = roc_auc_score(y_test, y_prob, multi_class="ovr", average="macro") + weighted_roc_auc_ovr = roc_auc_score( + y_test, y_prob, multi_class="ovr", average="weighted" + ) + + # Plot all ROC curves + fig, ax = plt.subplots(figsize=[20, 10]) + # inset axes + axins = ax.inset_axes([0.56, 0.03, 0.42, 0.42]) + + ax.plot( + fpr["micro"], tpr["micro"], + color="tab:olive", linestyle='dashdot', + label='micro-average ROC curve (area = {0:0.4f})' + ''.format(roc_auc["micro"]), + linewidth=2) + + axins.plot( + fpr["micro"], tpr["micro"], + color="tab:olive", linestyle='dashdot', + label='micro-average ROC curve (area = {0:0.4f})' + ''.format(roc_auc["micro"]), + linewidth=2) + + ax.plot( + fpr["macro"], tpr["macro"], + color="tab:purple", linestyle='dashdot', + label='macro-average ROC curve (area = {0:0.4f})' + ''.format(roc_auc["macro"]), + linewidth=2) + + axins.plot( + fpr["macro"], tpr["macro"], + color="tab:purple", linestyle='dashdot', + label='macro-average ROC curve (area = {0:0.4f})' + ''.format(roc_auc["macro"]), + linewidth=2) + + + colors=["tab:blue","tab:green","tab:orange"] + + + for i, item in enumerate(["noise", "muon", "neutrino"]): + ax.plot( + fpr[i], tpr[i], + color=colors[i], label='ROC of {0} class (area = {1:0.4f})' + ''.format(item, roc_auc[i])) + axins.plot( + fpr[i], tpr[i], + color=colors[i], label='ROC of {0} class (area = {1:0.4f})' + ''.format(item, roc_auc[i])) + + + ax.plot([0, 1], [0, 1], 'k--', label="random") + ax.set_xlim([0.0, 1.0]) + ax.set_ylim([0.0, 1.05]) + ax.set_xlabel('False Positive Rate') + ax.set_ylabel('True Positive Rate') + ax.set_title('Receiver operating characteristic to multi-class') + ax.legend(loc="upper right", framealpha=0.99) + + # sub region of the original image + x1, x2, y1, y2 = 0, .02, 0.92, 1 + axins.set_xlim(x1, x2) + axins.set_ylim(y1, y2) + + ax.indicate_inset_zoom(axins, edgecolor="black") + + ax.text( + .775, .6, + f"""One-vs-One ROC AUC scores: + \n{macro_roc_auc_ovo:.4f} (macro), + \n{weighted_roc_auc_ovo:.4f} (weighted by prevalence) + \nOne-vs-Rest ROC AUC scores: + \n{macro_roc_auc_ovr:.4f} (macro), + \n{weighted_roc_auc_ovr:.4f} (weighted by prevalence)""" , + fontsize = 10, + bbox = dict(facecolor = 'white', alpha = 0.99)) + + # ensure output exists + os.makedirs(args.output, exist_ok=True) + fig.savefig(args.output + 'Roc_curves.png') + + +def main(args): + plot_roc(args) + + +if __name__ == "__main__": + main(get_plotArgs()) \ No newline at end of file diff --git a/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/cm.ipynb b/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/script_archive/cm.ipynb old mode 100644 new mode 100755 similarity index 100% rename from multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/cm.ipynb rename to multi_classification_on_stop_and_track_muons/plotting/Classification_performance/script_archive/cm.ipynb diff --git a/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/plot_roc.ipynb b/multi_classification_on_stop_and_track_muons/plotting/Classification_performance/script_archive/plot_roc.ipynb old mode 100644 new mode 100755 similarity index 100% rename from multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/plot_roc.ipynb rename to multi_classification_on_stop_and_track_muons/plotting/Classification_performance/script_archive/plot_roc.ipynb diff --git a/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/Comparison_RD_to_MC.py b/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/Comparison_RD_to_MC.py old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/RD_to_MC.ipynb b/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/RD_to_MC.ipynb old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/Reweight MC data.ipynb b/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/Reweight MC data.ipynb old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/logit.ipynb b/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/logit.ipynb old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/logit_individual.ipynb b/multi_classification_on_stop_and_track_muons/plotting/Comparison_RD_MC/logit_individual.ipynb old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/plotting/__init__.py b/multi_classification_on_stop_and_track_muons/plotting/__init__.py old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/plotting/distributions/PID_predictions.py b/multi_classification_on_stop_and_track_muons/plotting/distributions/PID_predictions.py new file mode 100755 index 0000000..544bbe0 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/plotting/distributions/PID_predictions.py @@ -0,0 +1,59 @@ +import os, sys +# ability to fetch scripts +sys.path.append(os.path.abspath(os.path.join(os.path.dirname( __file__ ), '..'))) +from helper_functions.parsing import * +from helper_functions.plot_params import * + +import pandas as pd +import numpy as np + + +def plot_PID_predictions(args) -> None: + feature_data = pd.read_csv(args.MC_csv_path, index_col=[0]) + + preds = ["pid_noise_pred","pid_muon_pred","pid_neutrino_pred"] + pids = [1,12,13] + + ## transform data + # remove anti + feature_data['pid'] = feature_data['pid'].apply(abs) + # make all neutrinos the same class; to match training classes + feature_data.loc[feature_data['pid']==14, "pid"]=12 + feature_data.loc[feature_data['pid']==16, "pid"]=12 + + preds = ["pid_noise_pred","pid_muon_pred","pid_neutrino_pred"] + pids = [1,12,13] + color=["b","y","g"] + for i, pred in enumerate(preds): + pid_list=[] + pid_bin_centers=[] + + fig,ax = plt.subplots(figsize=(20,10)) + + temp = 0 + for i, pid in enumerate(pids): + y, bin_edges = np.histogram(feature_data[pred].loc[feature_data["pid"]==pid], bins=50) + + pid_list.append(feature_data[pred].loc[feature_data["pid"]==pid]) + pid_bin_centers.append(0.5*(bin_edges[1:] + bin_edges[:-1])) + + ax.hist(pid_list, bins=100, log=True, stacked=True, label=("noise", "neutrino", "muon")) + ax.set(yscale='log') + ax.set_xlim(-0.001,1.001) + #ax.set(ylabel='Rate',yscale='log') + #ax.yaxis.set_major_formatter(ticker.EngFormatter(unit='Hz')) + #for i, _ in enumerate(pids): + # plt.errorbar(pid_bin_centers[i], pid_histlist[i], yerr = stds[i], fmt=f".{color[i]}") + plt.title(pred.replace("_"," ")[4:]) + plt.legend() + # ensure output exists + os.makedirs(args.output, exist_ok=True) + plt.savefig(args.output + pred.replace("_","")[3:-4]+".png") + + +def main(args): + plot_PID_predictions(args) + +if __name__ == "__main__": + main(get_plotArgs()) + diff --git a/multi_classification_on_stop_and_track_muons/plotting/distributions/PID_predictions_fit.py b/multi_classification_on_stop_and_track_muons/plotting/distributions/PID_predictions_fit.py new file mode 100755 index 0000000..6f1d056 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/plotting/distributions/PID_predictions_fit.py @@ -0,0 +1,112 @@ +import os, sys +# ability to fetch scripts +sys.path.append(os.path.abspath(os.path.join(os.path.dirname( __file__ ), '..'))) +from helper_functions.parsing import * +from helper_functions.plot_params import * + +import numpy as np +import pandas as pd +import scipy.optimize as optimize +import torch + +def plot_pid_predictions_fit(args) -> None: + results_rd = pd.read_csv(args.RD_csv_path).sort_values('event_no').reset_index(drop = True) + results_mc = pd.read_csv(args.MC_csv_path).sort_values('event_no').reset_index(drop = True) + + bins_to_use = np.linspace(-17,17,100) + bins_to_fit = np.linspace(-12,17,100) #bins_to_use + bins_to_use = np.linspace(0,1,101) + bins_middle = (bins_to_use[1:]+bins_to_use[:-1])/2 + + class_options = {1: 0, -1: 0, 13: 1, -13: 1, 12: 2, -12: 2, 14: 2, -14: 2, 16: 2, -16: 2,} + pid_transform = torch.tensor([class_options[int(value)] for value in results_mc["pid"]]) + truth_mc = pid_transform + + mask_noise = truth_mc == 0 + mask_muon = truth_mc == 1 + mask_neutrino = truth_mc == 2 + + fig, axs = plt.subplots(4,1,sharex=False,figsize=(8, 32)) + + counts_noise, _, _, _ = axs[0].hist2d(results_mc['pid_noise_pred'].values[mask_noise],results_mc['pid_neutrino_pred'].values[mask_noise],bins_to_use,norm=colors.LogNorm()) + counts_muon, _, _, _ = axs[1].hist2d(results_mc['pid_noise_pred'].values[mask_muon],results_mc['pid_neutrino_pred'].values[mask_muon],bins_to_use,norm=colors.LogNorm()) + counts_neutrino, _, _, _ = axs[2].hist2d(results_mc['pid_noise_pred'].values[mask_neutrino],results_mc['pid_neutrino_pred'].values[mask_neutrino],bins_to_use,norm=colors.LogNorm()) + counts_rd, _, _, _ = axs[2].hist2d(results_rd['pid_noise_pred'].values,results_rd['pid_neutrino_pred'].values,bins_to_use,norm=colors.LogNorm()) + + + def chi_square(n_scalers): + sum_ = 0 + for i in range(len(bins_to_use)-1): + for j in range(len(bins_to_use)-1): + if counts_rd[i,j] > 0: + sum_+= (counts_rd[i,j] - n_scalers[0]*counts_noise[i,j] - n_scalers[1]*counts_muon[i,j] - n_scalers[2]*counts_neutrino[i,j])**2/counts_rd[i,j] + elif np.max([counts_noise[i,j],counts_muon[i,j],counts_neutrino[i,j]]) >0: + sum_+= (counts_rd[i,j] - n_scalers[0]*counts_noise[i,j] - n_scalers[1]*counts_muon[i,j] - n_scalers[2]*counts_neutrino[i,j])**2/np.max([counts_noise[i,j],counts_muon[i,j],counts_neutrino[i,j]]) + else: + sum_+=0 + return sum_ + + N_0 = [50000,50000,50000] + res = optimize.minimize(chi_square, N_0, bounds = ((0, None),(0, None), (0, None))) + print(res.x) + print(res.success) + + counts_noise_fit = counts_noise*res.x[0]#*N_test[0] + counts_muon_fit = counts_muon*res.x[1]#*N_test[1]# + counts_neutrino_fit = counts_neutrino*res.x[2]#*N_test[2]# + + counts_residual = counts_noise_fit + counts_muon_fit + counts_neutrino_fit - counts_rd + + fig, axs = plt.subplots(figsize=(8, 8)) + im = axs.imshow(counts_residual,norm=colors.LogNorm()) + fig.colorbar(im, ax=axs) + fig.tight_layout() + + fig.savefig(args.output + 'residual_heatmap') + + fig, axs = plt.subplots(figsize=(8, 8)) + + sum_axis=0 + bin_width = bins_to_use[1]-bins_to_use[0] + + axs.bar(bins_middle,np.sum(counts_noise_fit,axis=sum_axis),width=bin_width,label='Scaled Noise') + axs.bar(bins_middle,np.sum(counts_muon_fit,axis=sum_axis),width=bin_width,bottom=np.sum(counts_noise_fit,axis=sum_axis),label='Scaled Muons') + axs.bar(bins_middle,np.sum(counts_neutrino_fit,axis=sum_axis),width=bin_width,bottom=np.sum(counts_noise_fit+counts_muon_fit,axis=sum_axis),label='Scaled Neutrinos') + + axs.plot(bins_middle,np.sum(counts_rd,axis=sum_axis),'o',label='Real data') + + axs.set_xlabel('Neutrino probability') + axs.set_ylabel('Count') + axs.set_yscale('log') + axs.legend(loc='upper right') + fig.tight_layout() + fig.savefig(args.output + 'Scaled_neutrino_prob_histograms.png') + + + + fig, axs = plt.subplots(figsize=(8, 8)) + + sum_axis=1 + bin_width = bins_to_use[1]-bins_to_use[0] + + axs.bar(bins_middle,np.sum(counts_noise_fit,axis=sum_axis),width=bin_width,label='Scaled Noise') + axs.bar(bins_middle,np.sum(counts_muon_fit,axis=sum_axis),width=bin_width,bottom=np.sum(counts_noise_fit,axis=sum_axis),label='Scaled Muons') + axs.bar(bins_middle,np.sum(counts_neutrino_fit,axis=sum_axis),width=bin_width,bottom=np.sum(counts_noise_fit+counts_muon_fit,axis=sum_axis),label='Scaled Neutrinos') + + axs.plot(bins_middle,np.sum(counts_rd,axis=sum_axis),'o',label='Real data') + + axs.set_xlabel('Noise probability') + axs.set_ylabel('Count') + axs.set_yscale('log') + axs.legend(loc='upper right') + fig.tight_layout() + + fig.savefig(args.output + 'Scaled_noise_prob_histograms.png') + + print(f'there are predicted noise {np.sum(counts_noise_fit)}' +f' and predicted muons {np.sum(counts_muon_fit)}' +f' and predicted neutrinos {np.sum(counts_neutrino_fit)}' ) + +def main(args): + plot_pid_predictions_fit(args) + +if __name__ == "__main__": + main(get_plotArgs()) \ No newline at end of file diff --git a/multi_classification_on_stop_and_track_muons/plotting/distributions/PID_predictions_logit.py b/multi_classification_on_stop_and_track_muons/plotting/distributions/PID_predictions_logit.py new file mode 100755 index 0000000..b9811d4 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/plotting/distributions/PID_predictions_logit.py @@ -0,0 +1,41 @@ +import os, sys +# ability to fetch scripts +sys.path.append(os.path.abspath(os.path.join(os.path.dirname( __file__ ), '..'))) +from helper_functions.parsing import * +from helper_functions.plot_params import * +from helper_functions.external_functions import logit_transform + +import pandas as pd +import scipy.optimize as optimize +import swifter + +def plot_PID_predictions_logit(args): + results_RD = pd.read_csv(args.RD_csv_path, index_col=[0]) + results_MC = pd.read_csv(args.MC_csv_path, index_col=[0]) + + pid_transform = {1:0,12:2,13:1,14:2,16:2} + + truth_MC = [] + + for i in range(len(results_MC)): + truth_MC.append(pid_transform[abs(results_MC['pid'].values[i])]) + + logits = dict() + for item in ["noise", "muon", "neutrino"]: + logits[item] = results_MC[f"pid_{item}_pred"].swifter.apply( lambda x: logit_transform(x,inverse=False) ) + logits = pd.DataFrame.from_dict(logits) + + fix, ax = plt.subplots(figsize=[10, 5]) + for item in ["noise", "muon", "neutrino"]: + ax.hist(logits[item], bins=50, alpha=0.33, label=item); + ax.set(yscale="log") + ax.legend(); + # ensure output exists + os.makedirs(args.output, exist_ok=True) + plt.savefig(args.output + "logits_unstacked.png") + +def main(args): + plot_PID_predictions_logit(args) + +if __name__ == "__main__": + main(get_plotArgs()) \ No newline at end of file diff --git a/multi_classification_on_stop_and_track_muons/plotting/distributions/PID_predictions_logit_fit.py b/multi_classification_on_stop_and_track_muons/plotting/distributions/PID_predictions_logit_fit.py new file mode 100755 index 0000000..8db2269 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/plotting/distributions/PID_predictions_logit_fit.py @@ -0,0 +1,149 @@ +import os, sys +# ability to fetch scripts +sys.path.append(os.path.abspath(os.path.join(os.path.dirname( __file__ ), '..'))) +from helper_functions.parsing import * +from helper_functions.plot_params import * +from helper_functions.external_functions import logit_transform + +import numpy as np +import pandas as pd +import scipy.optimize as optimize +import torch +import swifter + +def plot_pid_predictions_logit_fit(args): + results_rd = pd.read_csv(args.RD_csv_path).sort_values('event_no').reset_index(drop = True) + results_mc = pd.read_csv(args.MC_csv_path).sort_values('event_no').reset_index(drop = True) + + bins_to_use = np.linspace(-17,17,100) + bins_to_fit = np.linspace(-12,17,100) #bins_to_use + bins_middle = (bins_to_use[1:]+bins_to_use[:-1])/2 + + class_options = {1: 0, -1: 0, 13: 1, -13: 1, 12: 2, -12: 2, 14: 2, -14: 2, 16: 2, -16: 2} + pid_transform = torch.tensor([class_options[int(value)] for value in results_mc["pid"]]) + + keys = ["noise", "muon", "neutrino"] + noise_logits, muon_logits, neutrino_logits = dict(), dict(), dict() + mask = dict() + # loop over dataset + for key in keys: + # loop over noise/particle type + for class_type, item in enumerate(keys): + mask[item] = results_mc[f'pid_{key}_pred'].where(pid_transform == class_type) + print(f"{key}_logits", item) + locals()[f"{key}_logits"][item] = pd.Series(mask[item]).swifter.apply(logit_transform) + locals()[f"{key}_logits"]["RD"] = pd.Series(results_rd[f'pid_{key}_pred']).swifter.apply(logit_transform) + + fig, axs = plt.subplots(4,1,sharex=False,figsize=(8, 32)) + counts_noise_to_fit,_,_,_ = axs[0].hist2d(noise_logits['noise'],neutrino_logits['noise'],bins_to_fit,norm=colors.LogNorm()) + counts_muon_to_fit,_,_,_ = axs[1].hist2d(noise_logits['muon'],neutrino_logits['muon'],bins_to_fit,norm=colors.LogNorm()) + counts_neutrino_to_fit,_,_,_ = axs[2].hist2d(noise_logits['neutrino'],neutrino_logits['neutrino'],bins_to_fit,norm=colors.LogNorm()) + counts_rd_to_fit,_,_,_ = axs[3].hist2d(noise_logits['RD'],neutrino_logits['RD'],bins_to_fit,norm=colors.LogNorm()) + + + fig, axs = plt.subplots(4,1,sharex=False,figsize=(8, 32)) + + counts_noise,_,_,_ = axs[0].hist2d(noise_logits['noise'],neutrino_logits['noise'],bins_to_use,norm=colors.LogNorm()) + counts_muon,_,_,_ = axs[1].hist2d(noise_logits['muon'],neutrino_logits['muon'],bins_to_use,norm=colors.LogNorm()) + counts_neutrino,_,_,_ = axs[2].hist2d(noise_logits['neutrino'],neutrino_logits['neutrino'],bins_to_use,norm=colors.LogNorm()) + counts_rd,_,_,_ = axs[3].hist2d(noise_logits['RD'],neutrino_logits['RD'],bins_to_use,norm=colors.LogNorm()) + + xlabel = 'Noise probability' + axs[0].set_xlabel(xlabel) + axs[1].set_xlabel(xlabel) + axs[2].set_xlabel(xlabel) + axs[3].set_xlabel(xlabel) + + ylabel = 'Neutrino probability' + axs[0].set_ylabel(ylabel) + axs[1].set_ylabel(ylabel) + axs[2].set_ylabel(ylabel) + axs[3].set_ylabel(ylabel) + + axs[0].set_title('MC Noise') + axs[1].set_title('MC Muons') + axs[2].set_title('MC Neutrino') + axs[3].set_title('RD') + + fig.tight_layout() + fig.savefig(args.output + '2D_logit_prob_histograms.png') + + def chi_square(n_scalers): + sum_ = 0 + for i in range(len(bins_to_fit)-1): + for j in range(len(bins_to_fit)-1): + if counts_rd_to_fit[i,j] > 0: + sum_+= (counts_rd_to_fit[i,j] - n_scalers[0]*counts_noise_to_fit[i,j] - n_scalers[1]*counts_muon_to_fit[i,j] - n_scalers[2]*counts_neutrino_to_fit[i,j])**2/counts_rd_to_fit[i,j] + elif np.max([counts_noise_to_fit[i,j],counts_muon_to_fit[i,j],counts_neutrino_to_fit[i,j]]) >0: + sum_+= (counts_rd_to_fit[i,j] - n_scalers[0]*counts_noise_to_fit[i,j] - n_scalers[1]*counts_muon_to_fit[i,j] - n_scalers[2]*counts_neutrino_to_fit[i,j])**2/np.max([counts_noise_to_fit[i,j],counts_muon_to_fit[i,j],counts_neutrino_to_fit[i,j]]) + else: + sum_+=0 + return sum_ + + N_0 = [1,1,1] + res = optimize.minimize(chi_square,N_0,bounds = ((0, None),(0, None), (0, None))) + print(res.x) + print(res.success) + + counts_noise_fit = counts_noise*res.x[0]#*N_test[0] + counts_muon_fit = counts_muon*res.x[1]#*N_test[1]# + counts_neutrino_fit = counts_neutrino*res.x[2]#*N_test[2]# + + counts_residual = counts_noise_fit + counts_muon_fit + counts_neutrino_fit - counts_rd + + fig, axs = plt.subplots(figsize=(8, 8)) + im = axs.imshow(counts_residual,norm=colors.LogNorm()) + fig.colorbar(im, ax=axs) + fig.tight_layout() + + fig.savefig(args.output + 'logit_residual_heatmap') + + fig, axs = plt.subplots(figsize=(8, 8)) + + sum_axis=0 + bin_width = bins_to_use[1]-bins_to_use[0] + + axs.bar(bins_middle,np.sum(counts_noise_fit,axis=sum_axis),width=bin_width,label='Scaled Noise') + axs.bar(bins_middle,np.sum(counts_muon_fit,axis=sum_axis),width=bin_width,bottom=np.sum(counts_noise_fit,axis=sum_axis),label='Scaled Muons') + axs.bar(bins_middle,np.sum(counts_neutrino_fit,axis=sum_axis),width=bin_width,bottom=np.sum(counts_noise_fit+counts_muon_fit,axis=sum_axis),label='Scaled Neutrinos') + + axs.plot(bins_middle,np.sum(counts_rd,axis=sum_axis),'o',label='Real data',color='red') + axs.set_xlabel('Neutrino probability') + + axs.set_ylabel('Count') + axs.set_yscale('log') + axs.legend(loc='upper right') + fig.tight_layout() + + fig.savefig(args.output + 'Scaled_neutrino_logit_prob_histograms.png') + + + + + fig, axs = plt.subplots(figsize=(8, 8)) + + sum_axis=1 + bin_width = bins_to_use[1]-bins_to_use[0] + + axs.bar(bins_middle,np.sum(counts_noise_fit,axis=sum_axis),width=bin_width,label='Scaled Noise') + axs.bar(bins_middle,np.sum(counts_muon_fit,axis=sum_axis),width=bin_width,bottom=np.sum(counts_noise_fit,axis=sum_axis),label='Scaled Muons') + axs.bar(bins_middle,np.sum(counts_neutrino_fit,axis=sum_axis),width=bin_width,bottom=np.sum(counts_noise_fit+counts_muon_fit,axis=sum_axis),label='Scaled Neutrinos') + + + axs.plot(bins_middle,np.sum(counts_rd,axis=sum_axis),'o',label='Real data',color='red') + axs.set_xlabel('Noise probability') + + axs.set_ylabel('Count') + axs.set_yscale('log') + axs.legend(loc='upper right') + fig.tight_layout() + + fig.savefig(args.output + 'Scaled_noise_logit_prob_histograms.png') + + print(f'there are predicted noise {np.sum(counts_noise_fit)}' +f' and predicted muons {np.sum(counts_muon_fit)}' +f' and predicted neutrinos {np.sum(counts_neutrino_fit)}' ) + +def main(args): + plot_pid_predictions_logit_fit(args) + +if __name__ == "__main__": + main(get_plotArgs()) \ No newline at end of file diff --git a/multi_classification_on_stop_and_track_muons/plotting/distributions/plot_all_in_folder.sh b/multi_classification_on_stop_and_track_muons/plotting/distributions/plot_all_in_folder.sh old mode 100644 new mode 100755 index 7152167..d36a334 --- a/multi_classification_on_stop_and_track_muons/plotting/distributions/plot_all_in_folder.sh +++ b/multi_classification_on_stop_and_track_muons/plotting/distributions/plot_all_in_folder.sh @@ -11,10 +11,6 @@ database_directory=/groups/icecube/petersen/GraphNetDatabaseRepository/moon_poin pulsemap=TWSRTHVInIcePulses # (3) to run this shell script; copy file path and execute "bash " -sigma=2 -cutoff=0.7 -log=5000 - diff --git a/multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPrediction.ipynb b/multi_classification_on_stop_and_track_muons/plotting/distributions/script_archive/PIDofPrediction.ipynb old mode 100644 new mode 100755 similarity index 100% rename from multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPrediction.ipynb rename to multi_classification_on_stop_and_track_muons/plotting/distributions/script_archive/PIDofPrediction.ipynb diff --git a/multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPrediction2D.ipynb b/multi_classification_on_stop_and_track_muons/plotting/distributions/script_archive/PIDofPrediction2D.ipynb old mode 100644 new mode 100755 similarity index 100% rename from multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPrediction2D.ipynb rename to multi_classification_on_stop_and_track_muons/plotting/distributions/script_archive/PIDofPrediction2D.ipynb diff --git a/multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPredictionMCRD.ipynb b/multi_classification_on_stop_and_track_muons/plotting/distributions/script_archive/PIDofPredictionMCRD.ipynb old mode 100644 new mode 100755 similarity index 100% rename from multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPredictionMCRD.ipynb rename to multi_classification_on_stop_and_track_muons/plotting/distributions/script_archive/PIDofPredictionMCRD.ipynb diff --git a/multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPrediction_RD.ipynb b/multi_classification_on_stop_and_track_muons/plotting/distributions/script_archive/PIDofPrediction_RD.ipynb old mode 100644 new mode 100755 similarity index 100% rename from multi_classification_on_stop_and_track_muons/plotting/distributions/PIDofPrediction_RD.ipynb rename to multi_classification_on_stop_and_track_muons/plotting/distributions/script_archive/PIDofPrediction_RD.ipynb diff --git a/multi_classification_on_stop_and_track_muons/plotting/distributions/script_archive/fit.ipynb b/multi_classification_on_stop_and_track_muons/plotting/distributions/script_archive/fit.ipynb new file mode 100755 index 0000000..f165dee --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/plotting/distributions/script_archive/fit.ipynb @@ -0,0 +1,382 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os, sys\n", + "# ability to fetch scripts\n", + "sys.path.append(os.path.abspath(os.path.join(os.path.abspath(''), '../..')))\n", + "from helper_functions.parsing import *\n", + "from helper_functions.plot_params import *\n", + "from helper_functions.external_functions import logit_transform\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import scipy.optimize as optimize\n", + "import torch\n", + "import swifter" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def chi_square(n_scalers):\n", + " sum_ = 0\n", + " for i in range(len(bins_to_fit)-1):\n", + " for j in range(len(bins_to_fit)-1):\n", + " if counts_rd_to_fit[i,j] > 0:\n", + " sum_+= (counts_rd_to_fit[i,j] - n_scalers[0]*counts_noise_to_fit[i,j] - n_scalers[1]*counts_muon_to_fit[i,j] - n_scalers[2]*counts_neutrino_to_fit[i,j])**2/counts_rd_to_fit[i,j]\n", + " elif np.max([counts_noise_to_fit[i,j],counts_muon_to_fit[i,j],counts_neutrino_to_fit[i,j]]) >0:\n", + " sum_+= (counts_rd_to_fit[i,j] - n_scalers[0]*counts_noise_to_fit[i,j] - n_scalers[1]*counts_muon_to_fit[i,j] - n_scalers[2]*counts_neutrino_to_fit[i,j])**2/np.max([counts_noise_to_fit[i,j],counts_muon_to_fit[i,j],counts_neutrino_to_fit[i,j]])\n", + " else:\n", + " sum_+=0\n", + " return sum_" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "results_rd = pd.read_csv(\"/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/Inference/pid_Leon_MC_Full_db.csv\").sort_values('event_no').reset_index(drop = True)\n", + "results_mc = pd.read_csv(\"/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/Inference/pid_Leon_RD_results_new_model.csv\").sort_values('event_no').reset_index(drop = True)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "bins_to_use = np.linspace(-17,17,100)\n", + "bins_to_fit = np.linspace(-12,17,100) #bins_to_use\n", + "bins_middle = (bins_to_use[1:]+bins_to_use[:-1])/2" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "class_options = {1: 0, -1: 0, 13: 1, -13: 1, 12: 2, -12: 2, 14: 2, -14: 2, 16: 2, -16: 2}\n", + "pid_transform = torch.tensor([class_options[int(value)] for value in results_mc[\"pid\"]])" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "keys = [\"noise\", \"muon\", \"neutrino\"]\n", + "noise_logits, muon_logits, neutrino_logits = dict(), dict(), dict()\n", + "mask = dict()\n", + "# loop over dataset\n", + "for key in keys:\n", + " # loop over noise/particle type\n", + " for class_type, item in enumerate(keys):\n", + " mask[item] = results_mc[f'pid_{key}_pred'] == class_type\n", + " locals()[f\"{key}_logits\"][item] = pd.Series(mask[item]).swifter.apply(logit_transform);\n", + " locals()[f\"{key}_logits\"][\"RD\"] = pd.Series(results_rd[f'pid_{key}_pred']).swifter.apply(logit_transform);" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'noise': 0 -13.81551\n", + " 1 -13.81551\n", + " 2 -13.81551\n", + " 3 -13.81551\n", + " 4 -13.81551\n", + " ... \n", + " 1420704 -13.81551\n", + " 1420705 -13.81551\n", + " 1420706 -13.81551\n", + " 1420707 -13.81551\n", + " 1420708 -13.81551\n", + " Name: pid_noise_pred, Length: 1420709, dtype: float64,\n", + " 'muon': 0 -13.81551\n", + " 1 -13.81551\n", + " 2 -13.81551\n", + " 3 -13.81551\n", + " 4 -13.81551\n", + " ... \n", + " 1420704 -13.81551\n", + " 1420705 -13.81551\n", + " 1420706 13.81551\n", + " 1420707 -13.81551\n", + " 1420708 -13.81551\n", + " Name: pid_noise_pred, Length: 1420709, dtype: float64,\n", + " 'neutrino': 0 -13.81551\n", + " 1 -13.81551\n", + " 2 -13.81551\n", + " 3 -13.81551\n", + " 4 -13.81551\n", + " ... \n", + " 1420704 -13.81551\n", + " 1420705 -13.81551\n", + " 1420706 -13.81551\n", + " 1420707 -13.81551\n", + " 1420708 -13.81551\n", + " Name: pid_noise_pred, Length: 1420709, dtype: float64,\n", + " 'RD': 0 5.230409\n", + " 1 7.414763\n", + " 2 13.815510\n", + " 3 6.725921\n", + " 4 6.471729\n", + " ... \n", + " 48264014 4.280315\n", + " 48264015 13.815510\n", + " 48264016 5.469883\n", + " 48264017 -1.036372\n", + " 48264018 3.257304\n", + " Name: pid_noise_pred, Length: 48264019, dtype: float64}" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "noise_logits" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(4,1,sharex=False,figsize=(8, 32))\n", + "counts_noise_to_fit,_,_,_ = axs[0].hist2d(noise_logits['noise'],neutrino_logits['noise'],bins_to_fit,norm=colors.LogNorm())\n", + "counts_muon_to_fit,_,_,_ = axs[1].hist2d(noise_logits['muon'],neutrino_logits['muon'],bins_to_fit,norm=colors.LogNorm())\n", + "counts_neutrino_to_fit,_,_,_ = axs[2].hist2d(noise_logits['neutrino'],neutrino_logits['neutrino'],bins_to_fit,norm=colors.LogNorm())\n", + "counts_rd_to_fit,_,_,_ = axs[3].hist2d(noise_logits['RD'],neutrino_logits['RD'],bins_to_fit,norm=colors.LogNorm())" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(4,1,sharex=False,figsize=(8, 32))\n", + "\n", + "counts_noise,_,_,_ = axs[0].hist2d(noise_logits['noise'],neutrino_logits['noise'],bins_to_use,norm=colors.LogNorm())\n", + "counts_muon,_,_,_ = axs[1].hist2d(noise_logits['muon'],neutrino_logits['muon'],bins_to_use,norm=colors.LogNorm())\n", + "counts_neutrino,_,_,_ = axs[2].hist2d(noise_logits['neutrino'],neutrino_logits['neutrino'],bins_to_use,norm=colors.LogNorm())\n", + "counts_rd,_,_,_ = axs[3].hist2d(noise_logits['RD'],neutrino_logits['RD'],bins_to_use,norm=colors.LogNorm())\n", + "\n", + "xlabel = 'Noise probability'\n", + "axs[0].set_xlabel(xlabel)\n", + "axs[1].set_xlabel(xlabel)\n", + "axs[2].set_xlabel(xlabel)\n", + "axs[3].set_xlabel(xlabel)\n", + "\n", + "ylabel = 'Neutrino probability'\n", + "axs[0].set_ylabel(ylabel)\n", + "axs[1].set_ylabel(ylabel)\n", + "axs[2].set_ylabel(ylabel)\n", + "axs[3].set_ylabel(ylabel)\n", + "\n", + "axs[0].set_title('MC Noise')\n", + "axs[1].set_title('MC Muons')\n", + "axs[2].set_title('MC Neutrino')\n", + "axs[3].set_title('RD')\n", + "\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1. 1. 1.]\n", + "True\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "N_0 = [1,1,1]\n", + "res = optimize.minimize(chi_square,N_0,bounds = ((0, None),(0, None), (0, None)))\n", + "print(res.x)\n", + "print(res.success)\n", + "\n", + "counts_noise_fit = counts_noise*res.x[0]#*N_test[0]\n", + "counts_muon_fit = counts_muon*res.x[1]#*N_test[1]#\n", + "counts_neutrino_fit = counts_neutrino*res.x[2]#*N_test[2]#\n", + "\n", + "counts_residual = counts_noise_fit + counts_muon_fit + counts_neutrino_fit - counts_rd\n", + "\n", + "fig, axs = plt.subplots(figsize=(8, 8))\n", + "im = axs.imshow(counts_residual,norm=colors.LogNorm())\n", + "fig.colorbar(im, ax=axs)\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(figsize=(8, 8))\n", + "\n", + "sum_axis=0\n", + "bin_width = bins_to_use[1]-bins_to_use[0]\n", + "\n", + "axs.bar(bins_middle,np.sum(counts_noise_fit,axis=sum_axis),width=bin_width,label='Scaled Noise')\n", + "axs.bar(bins_middle,np.sum(counts_muon_fit,axis=sum_axis),width=bin_width,bottom=np.sum(counts_noise_fit,axis=sum_axis),label='Scaled Muons')\n", + "axs.bar(bins_middle,np.sum(counts_neutrino_fit,axis=sum_axis),width=bin_width,bottom=np.sum(counts_noise_fit+counts_muon_fit,axis=sum_axis),label='Scaled Neutrinos')\n", + "\n", + "axs.plot(bins_middle,np.sum(counts_rd,axis=sum_axis),'o',label='Real data',color='red')\n", + "axs.set_xlabel('Neutrino probability')\n", + "\n", + "axs.set_ylabel('Count')\n", + "axs.set_yscale('log')\n", + "axs.legend(loc='upper right')\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "there are predicted noise 1420709.0 and predicted muons 1420709.0 and predicted neutrinos 1420709.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(figsize=(8, 8))\n", + "\n", + "sum_axis=1\n", + "bin_width = bins_to_use[1]-bins_to_use[0]\n", + "\n", + "axs.bar(bins_middle,np.sum(counts_noise_fit,axis=sum_axis),width=bin_width,label='Scaled Noise')\n", + "axs.bar(bins_middle,np.sum(counts_muon_fit,axis=sum_axis),width=bin_width,bottom=np.sum(counts_noise_fit,axis=sum_axis),label='Scaled Muons')\n", + "axs.bar(bins_middle,np.sum(counts_neutrino_fit,axis=sum_axis),width=bin_width,bottom=np.sum(counts_noise_fit+counts_muon_fit,axis=sum_axis),label='Scaled Neutrinos')\n", + "\n", + "axs.plot(bins_middle,np.sum(counts_rd,axis=sum_axis),'o',label='Real data',color='red')\n", + "axs.set_xlabel('Noise probability')\n", + "\n", + "axs.set_ylabel('Count')\n", + "axs.set_yscale('log')\n", + "axs.legend(loc='upper right')\n", + "fig.tight_layout()\n", + "\n", + "print(f'there are predicted noise {np.sum(counts_noise_fit)}' +f' and predicted muons {np.sum(counts_muon_fit)}' +f' and predicted neutrinos {np.sum(counts_neutrino_fit)}' )\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('graphnet')", + "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.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e54c104f54ca5f79eede1c2e02355cc39841da57601eff628eedcebaaa867660" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/multi_classification_on_stop_and_track_muons/plotting/distributions/noise_cut.ipynb b/multi_classification_on_stop_and_track_muons/plotting/distributions/script_archive/noise_cut.ipynb old mode 100644 new mode 100755 similarity index 100% rename from multi_classification_on_stop_and_track_muons/plotting/distributions/noise_cut.ipynb rename to multi_classification_on_stop_and_track_muons/plotting/distributions/script_archive/noise_cut.ipynb diff --git a/multi_classification_on_stop_and_track_muons/plotting/distributions/predictionOfPID.ipynb b/multi_classification_on_stop_and_track_muons/plotting/distributions/script_archive/predictionOfPID.ipynb old mode 100644 new mode 100755 similarity index 100% rename from multi_classification_on_stop_and_track_muons/plotting/distributions/predictionOfPID.ipynb rename to multi_classification_on_stop_and_track_muons/plotting/distributions/script_archive/predictionOfPID.ipynb diff --git a/multi_classification_on_stop_and_track_muons/plotting/distributions/pulse_count_and_duration_distribution_from_sqlite.py b/multi_classification_on_stop_and_track_muons/plotting/distributions/script_archive/pulse_count_and_duration_distribution_from_sqlite.py old mode 100644 new mode 100755 similarity index 100% rename from multi_classification_on_stop_and_track_muons/plotting/distributions/pulse_count_and_duration_distribution_from_sqlite.py rename to multi_classification_on_stop_and_track_muons/plotting/distributions/script_archive/pulse_count_and_duration_distribution_from_sqlite.py diff --git a/multi_classification_on_stop_and_track_muons/plotting/event_location/event_heatmap.py b/multi_classification_on_stop_and_track_muons/plotting/event_location/event_heatmap.py old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/plotting/event_location/plot_all_in_folder.sh b/multi_classification_on_stop_and_track_muons/plotting/event_location/plot_all_in_folder.sh old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/plotting/event_location/single_event_position.py b/multi_classification_on_stop_and_track_muons/plotting/event_location/single_event_position.py old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/plotting/helper_functions/bash_test.sh b/multi_classification_on_stop_and_track_muons/plotting/helper_functions/bash_test.sh old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/plotting/helper_functions/external_functions.py b/multi_classification_on_stop_and_track_muons/plotting/helper_functions/external_functions.py index fc69250..c49b22d 100755 --- a/multi_classification_on_stop_and_track_muons/plotting/helper_functions/external_functions.py +++ b/multi_classification_on_stop_and_track_muons/plotting/helper_functions/external_functions.py @@ -1,3 +1,17 @@ +def logit_transform(p, eps=1e-6, inverse=False): + if np.isnan(p): + return + p = p*(1-2*eps)+eps + try: + if inverse: + transform = np.exp(p) / (1 + np.exp(p)) + else: + transform = np.log(p)- np.log(1 -p) + except ZeroDivisionError as e: + print(e) + + return transform + def get_roc_and_auc(data, target): fpr, tpr, _ = roc_curve(data[target], data[target+'_pred']) auc_score = auc(fpr,tpr) diff --git a/multi_classification_on_stop_and_track_muons/plotting/helper_functions/parsing.py b/multi_classification_on_stop_and_track_muons/plotting/helper_functions/parsing.py old mode 100644 new mode 100755 index e69de29..d055c33 --- a/multi_classification_on_stop_and_track_muons/plotting/helper_functions/parsing.py +++ b/multi_classification_on_stop_and_track_muons/plotting/helper_functions/parsing.py @@ -0,0 +1,47 @@ +import argparse + +def get_plotArgs(): + parser = argparse.ArgumentParser( + description="plotting the predicted zenith and azimuth vs truth." + ) + parser.add_argument( + "-mc_r", + "--mc_results", + dest="MC_csv_path", + type=str, + help=" path to monte carlo results", + default="/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/Inference/pid_Leon_MC_Full_db.csv", + ) + parser.add_argument( + "-rd_r", + "--rd_results", + dest="RD_csv_path", + type=str, + help=" path to inference results", + default="/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/Inference/pid_Leon_RD_results_new_model.csv", + ) + parser.add_argument( + "-mc_db", + "--mc_database", + dest="MC_db_path", + type=str, + help=" path to monte carlo raw database", + default="/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/Datasets/last_one_lvl3MC.db", + ) + parser.add_argument( + "-rd_db", + "--rd_database", + dest="RD_db_path", + type=str, + help=" path to real data raw database", + default="/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/Datasets/last_one_lvl3.db", + ) + parser.add_argument( + "-o", + "--output", + dest="output", + type=str, + help=" the output path [str]", + default="/groups/icecube/petersen/GraphNetDatabaseRepository/example_results/debug/", + ) + return parser.parse_args() \ No newline at end of file diff --git a/multi_classification_on_stop_and_track_muons/plotting/helper_functions/plot_params.py b/multi_classification_on_stop_and_track_muons/plotting/helper_functions/plot_params.py index 6532bd9..0aa6951 100755 --- a/multi_classification_on_stop_and_track_muons/plotting/helper_functions/plot_params.py +++ b/multi_classification_on_stop_and_track_muons/plotting/helper_functions/plot_params.py @@ -19,6 +19,8 @@ buffer = 0.02 import matplotlib.pyplot as plt +import matplotlib.ticker as ticker +import matplotlib.colors as colors from mpl_toolkits.axes_grid1 import make_axes_locatable plt.style.use("seaborn-white") @@ -41,4 +43,22 @@ def colorbar(mappable): cax = divider.append_axes("right", size="5%", pad=0.05) cbar = fig.colorbar(mappable, cax=cax) plt.sca(last_axes) - return cbar \ No newline at end of file + return cbar + +class display(object): + """Display HTML representation of multiple objects in jupyter + Use as display('object1', 'object2', ...) """ + template = """
+

{0}

{1} +
""" + + def __init__(self, *args): + self.args = args + + def _repr_html_(self): + return '\n'.join(self.template.format(a, eval(a)._repr_html_()) + for a in self.args) + + def __repr__(self): + return '\n\n'.join(a + '\n' + repr(eval(a)) + for a in self.args) \ No newline at end of file diff --git a/multi_classification_on_stop_and_track_muons/plotting/plot_all.sh b/multi_classification_on_stop_and_track_muons/plotting/plot_all.sh new file mode 100755 index 0000000..3773206 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/plotting/plot_all.sh @@ -0,0 +1,88 @@ +#!/usr/bin/env python3 +# !do not alter! +bash_directory=$(dirname -- "$(readlink -f "${BASH_SOURCE}")") + +## Description: This bash script is meant to plot everything in article + +# to recreate the results, follow the steps below. +# (1) designate directory containing databases and csv for real data (rd) and monte carlo (mc). +MC_csv_path=/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/Inference/pid_Leon_MC_Full_db.csv +RD_csv_path=/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/Inference/pid_Leon_RD_results_new_model.csv +MC_database_path=/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/Datasets/last_one_lvl3MC.db +RD_database_path=/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/Datasets/last_one_lvl3.db +# (2) designate directory for output; preferably use a folder with model name and end with "/". +output_directory=/groups/icecube/petersen/GraphNetDatabaseRepository/multi_classification_stop_track_muon/plotting/pid_Leon_MC_Full_db/ +# (3) to run this shell script; copy file path and execute "bash " + + +### do not alter beyond this point ### +# save the report file to +report_name=plot # overwrites old, thus only keeps the one with error +report_directory=/groups/icecube/${USER}/storage/nohup_reports/ +# if directories does not exist for reporting, create them. +mkdir -p ${output_directory}; +mkdir -p ${report_directory}; + +# save the report file to +report_location=${report_directory}${report_name}.out + +## Classification Performance +echo "plotting confusion matrix for MC results" +nohup python ${bash_directory}/Classification_performance/plot_confusion_matrix.py \ +-mc_r ${MC_csv_path} \ +-o ${output_directory} \ +> ${report_location} \ +2> ${report_directory}${report_name}.err & + + +echo "plotting probability heat maps for RD and MC results" +nohup python ${bash_directory}/Classification_performance/plot_probability_heatmaps.py \ +-mc_r ${MC_csv_path} \ +-rd_r ${RD_csv_path} \ +-o ${output_directory} \ +> ${report_location} \ +2> ${report_directory}${report_name}.err & + + +echo "plotting receiver operating curve for MC results" +nohup python ${bash_directory}/Classification_performance/plot_roc.py \ +-mc_r ${MC_csv_path} \ +-o ${output_directory} \ +> ${report_location} \ +2> ${report_directory}${report_name}.err & + + +## distributions +echo "plotting prediction for MC results" +nohup python ${bash_directory}/distributions/PID_predictions.py \ +-mc_r ${MC_csv_path} \ +-o ${output_directory} \ +> ${report_location} \ +2> ${report_directory}${report_name}.err & + + +echo "plotting prediction fit for RD and MC results" +nohup python ${bash_directory}/distributions/PID_predictions_fit.py \ +-mc_r ${MC_csv_path} \ +-rd_r ${RD_csv_path} \ +-o ${output_directory} \ +> ${report_location} \ +2> ${report_directory}${report_name}.err & + + +echo "plotting logits predictions for RD and MC results" +nohup python ${bash_directory}/distributions/PID_predictions_logit.py \ +-mc_r ${MC_csv_path} \ +-rd_r ${RD_csv_path} \ +-o ${output_directory} \ +> ${report_location} \ +2> ${report_directory}${report_name}.err & + + +echo "plotting logit prediction fit for RD and MC results" +nohup python ${bash_directory}/distributions/PID_predictions_logit_fit.py \ +-mc_r ${MC_csv_path} \ +-rd_r ${RD_csv_path} \ +-o ${output_directory} \ +> ${report_location} \ +2> ${report_directory}${report_name}.err & diff --git a/multi_classification_on_stop_and_track_muons/plotting/reconstruction/individual_zenith_kappa_reconstruction.py b/multi_classification_on_stop_and_track_muons/plotting/reconstruction/individual_zenith_kappa_reconstruction.py old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/plotting/reconstruction/plot_all_in_folder.sh b/multi_classification_on_stop_and_track_muons/plotting/reconstruction/plot_all_in_folder.sh old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/plotting/test.ipynb b/multi_classification_on_stop_and_track_muons/plotting/test.ipynb new file mode 100755 index 0000000..e69de29 diff --git a/multi_classification_on_stop_and_track_muons/plotting/uncertainty/plot_all_in_folder.sh b/multi_classification_on_stop_and_track_muons/plotting/uncertainty/plot_all_in_folder.sh old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/plotting/uncertainty/uncertainty_test.py b/multi_classification_on_stop_and_track_muons/plotting/uncertainty/uncertainty_test.py old mode 100644 new mode 100755 diff --git a/multi_classification_on_stop_and_track_muons/preprocessing/calibration_test.ipynb b/multi_classification_on_stop_and_track_muons/preprocessing/calibration_test.ipynb new file mode 100755 index 0000000..633c122 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/preprocessing/calibration_test.ipynb @@ -0,0 +1,153 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/groups/icecube/qgf305/anaconda3/envs/graphnet/lib/python3.8/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import sqlite3 as sql\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "from pandas import cut, read_sql\n", + "import pickle as pkl\n", + "from random import choices\n", + "from sklearn import metrics\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors as colors\n", + "from numpy import interp\n", + "\n", + "from torch.nn.functional import one_hot\n", + "import torch\n", + "from sklearn.metrics import auc\n", + "from sklearn.metrics import roc_curve, auc\n", + "from sklearn.multiclass import OneVsRestClassifier\n", + "from sklearn.metrics import roc_auc_score\n", + "from sklearn.preprocessing import label_binarize" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "indir = \"/groups/icecube/peter/storage/Multiclassification/Real/last_one_lvl3MC/dynedge_pid_Real_run_21.5_mill_equal_frac_/results_first.csv\"\n", + "results = pd.read_csv(indir, index_col=[0]).sort_values('event_no').reset_index()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "## transform data\n", + "# remove anti\n", + "results['pid'] = results['pid'].apply(abs)\n", + "# make all neutrinos the same class; to match prediction\n", + "results.loc[results['pid']==14, \"pid\"]=12\n", + "results.loc[results['pid']==16, \"pid\"]=12\n", + "results[\"pid\"] = results[\"pid\"].astype(\"int\")\n", + "np.unique(results[\"pid\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Binarize the output\n", + "pid_true = label_binarize(results[\"pid\"], classes=[1, 12, 13])\n", + "nb_classes = pid_true.shape[1]\n", + "y_test = pid_true \n", + "y_prob = results[[\"pid_noise_pred\",\"pid_muon_pred\",\"pid_neutrino_pred\"]]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig = plt.figure(figsize=(10, 10))\n", + "gs = GridSpec(4, 2)\n", + "colors = plt.cm.get_cmap(\"Dark2\")\n", + "\n", + "ax_calibration_curve = fig.add_subplot(gs[:2, :2])\n", + "calibration_displays = {}\n", + "for i, (clf, name) in enumerate(clf_list):\n", + " clf.fit(X_train, y_train)\n", + " display = CalibrationDisplay.from_estimator(\n", + " clf,\n", + " X_test,\n", + " y_test,\n", + " n_bins=10,\n", + " name=name,\n", + " ax=ax_calibration_curve,\n", + " color=colors(i),\n", + " )\n", + " calibration_displays[name] = display\n", + "\n", + "ax_calibration_curve.grid()\n", + "ax_calibration_curve.set_title(\"Calibration plots (Naive Bayes)\")\n", + "\n", + "# Add histogram\n", + "grid_positions = [(2, 0), (2, 1), (3, 0), (3, 1)]\n", + "for i, (_, name) in enumerate(clf_list):\n", + " row, col = grid_positions[i]\n", + " ax = fig.add_subplot(gs[row, col])\n", + "\n", + " ax.hist(\n", + " calibration_displays[name].y_prob,\n", + " range=(0, 1),\n", + " bins=10,\n", + " label=name,\n", + " color=colors(i),\n", + " )\n", + " ax.set(title=name, xlabel=\"Mean predicted probability\", ylabel=\"Count\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('graphnet')", + "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.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e54c104f54ca5f79eede1c2e02355cc39841da57601eff628eedcebaaa867660" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/multi_classification_on_stop_and_track_muons/preprocessing/classification_calibration.py b/multi_classification_on_stop_and_track_muons/preprocessing/classification_calibration.py new file mode 100755 index 0000000..7b7ec32 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/preprocessing/classification_calibration.py @@ -0,0 +1,239 @@ +"""Example of non-parametric isotonic calibration of a classification Model.""" + +import os +from typing import cast +import numpy as np + +from pytorch_lightning import Trainer +from pytorch_lightning.callbacks import EarlyStopping + +# from pytorch_lightning.loggers import WandbLogger +import torch +from torch.optim.adam import Adam + +from graphnet.training.loss_functions import NLLLoss +from graphnet.data.constants import FEATURES, TRUTH +from graphnet.data.sqlite.sqlite_selection import ( + get_desired_event_numbers, +) +from graphnet.models import StandardModel +from graphnet.models.detector.icecube import IceCubeDeepCore +from graphnet.models.gnn import DynEdge +from graphnet.models.graph_builders import KNNGraphBuilder +from graphnet.models.task.classification import ClassificationTask +from graphnet.training.callbacks import ProgressBar, PiecewiseLinearLR +from graphnet.training.utils import ( + get_predictions, + make_train_validation_dataloader, + make_dataloaders, + save_results, +) +from sklearn.calibration import CalibratedClassifierCV, CalibrationDisplay + +# from graphnet.utilities.logging import get_logger + +# logger = get_logger() + +# Configurations +torch.multiprocessing.set_sharing_strategy("file_system") + +# Constants +features = FEATURES.DEEPCORE +truth = TRUTH.DEEPCORE[:-1] + +# Make sure W&B output directory exists +WANDB_DIR = "./wandb/" +os.makedirs(WANDB_DIR, exist_ok=True) + +# Initialise Weights & Biases (W&B) run +# wandb_logger = WandbLogger( +# project="example-script", +# entity="graphnet-team", +# save_dir=WANDB_DIR, +# log_model=True, +# ) + + +def main() -> None: + """Run example.""" + # logger.info(f"features: {features}") + # logger.info(f"truth: {truth}") + + # single integer definition of class + # class_options = 3 + # list of classes + # class_options = [0,1,2] + # transformation of target to a given class integer + class_options = { + 1: 0, + -1: 0, + 13: 1, + -13: 1, + 12: 2, + -12: 2, + 14: 2, + -14: 2, + 16: 2, + -16: 2, + } + + # Configuration + config = { + "db": "/groups/icecube/petersen/GraphNetDatabaseRepository/Leon_MC_data/last_one_lvl3MC.db", + "pulsemap": "SplitInIcePulses", + "batch_size": 512, + "num_workers": 10, + "accelerator": "cpu", # gpu + "devices": 1, # [0], + "target": "pid", + "classification": class_options, + "n_epochs": 10, + "patience": 5, + } + archive = "/groups/icecube/petersen/GraphNetDatabaseRepository/example_results/train_classification_model" + run_name = "dynedge_{}_example".format(config["target"]) + + # Log configuration to W&B + # wandb_logger.experiment.config.update(config) + + # Common variables + train_selection = get_desired_event_numbers( + database=cast(str, config["db"]), + desired_size=1000, + fraction_noise=float(1 / 3), + fraction_muon=float(1 / 3), + fraction_nu_e=float(1 / 9), + fraction_nu_mu=float(1 / 9), + fraction_nu_tau=float(1 / 9), + ) + + ( + training_dataloader, + validation_dataloader, + test_dataloader + ) = make_dataloaders( + data_path=cast(str, config["db"]), + selection=train_selection, + pulsemaps=cast(str, config["pulsemap"]), + features=features, + truth=truth, + batch_size=cast(int, config["batch_size"]), + num_workers=cast(int, config["num_workers"]), + ) + + # Building model + detector = IceCubeDeepCore( + graph_builder=KNNGraphBuilder(nb_nearest_neighbours=8), + ) + gnn = DynEdge( + nb_inputs=detector.nb_outputs, + global_pooling_schemes=["min", "max", "mean", "sum"], + ) + task = ClassificationTask( + nb_classes=len(np.unique(list(class_options.values()))), + hidden_size=gnn.nb_outputs, + target_labels=config["target"], + loss_function=NLLLoss(options=config["classification"]), + ) + model = StandardModel( + detector=detector, + gnn=gnn, + tasks=[task], + optimizer_class=Adam, + optimizer_kwargs={"lr": 1e-03, "eps": 1e-03}, + scheduler_class=PiecewiseLinearLR, + scheduler_kwargs={ + "milestones": [ + 0, + len(training_dataloader) / 2, + len(training_dataloader) * cast(int, config["n_epochs"]), + ], + "factors": [1e-2, 1, 1e-02], + }, + scheduler_config={ + "interval": "step", + }, + ) + + # Training model + callbacks = [ + EarlyStopping( + monitor="val_loss", + patience=config["patience"], + ), + ProgressBar(), + ] + + trainer = Trainer( + accelerator=config["accelerator"], + devices=config["devices"], + max_epochs=config["n_epochs"], + callbacks=callbacks, + log_every_n_steps=1, + # logger=wandb_logger, + ) + + try: + trainer.fit(model, training_dataloader, validation_dataloader) + except KeyboardInterrupt: + # logger.warning("[ctrl+c] Exiting gracefully.") + pass + + # Saving predictions to file + results = get_predictions( + trainer, + model, + validation_dataloader, + [ + cast(str, config["target"]) + "_noise_pred", + cast(str, config["target"]) + "_muon_pred", + cast(str, config["target"]) + "_neutrino_pred", + ], + additional_attributes=[cast(str, config["target"]), "event_no"], + ) + + #save_results(cast(str, config["db"]), run_name, results, archive, model) + + fig = plt.figure(figsize=(10, 10)) + gs = GridSpec(4, 2) + colors = plt.cm.get_cmap("Dark2") + + ax_calibration_curve = fig.add_subplot(gs[:2, :2]) + calibration_displays = {} + for i, (clf, name) in enumerate(clf_list): + clf.fit(X_train, y_train) + display = CalibrationDisplay.from_estimator( + clf, + X_test, + y_test, + n_bins=10, + name=name, + ax=ax_calibration_curve, + color=colors(i), + ) + calibration_displays[name] = display + + ax_calibration_curve.grid() + ax_calibration_curve.set_title("Calibration plots (Naive Bayes)") + + # Add histogram + grid_positions = [(2, 0), (2, 1), (3, 0), (3, 1)] + for i, (_, name) in enumerate(clf_list): + row, col = grid_positions[i] + ax = fig.add_subplot(gs[row, col]) + + ax.hist( + calibration_displays[name].y_prob, + range=(0, 1), + bins=10, + label=name, + color=colors(i), + ) + ax.set(title=name, xlabel="Mean predicted probability", ylabel="Count") + + plt.tight_layout() + plt.show() + + +if __name__ == "__main__": + main() diff --git a/multi_classification_on_stop_and_track_muons/preprocessing/get_indices_from_cut.py b/multi_classification_on_stop_and_track_muons/preprocessing/get_indices_from_cut.py new file mode 100755 index 0000000..e69de29 diff --git a/multi_classification_on_stop_and_track_muons/preprocessing/test.ipynb b/multi_classification_on_stop_and_track_muons/preprocessing/test.ipynb new file mode 100755 index 0000000..cf89052 --- /dev/null +++ b/multi_classification_on_stop_and_track_muons/preprocessing/test.ipynb @@ -0,0 +1,514 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.datasets import make_classification\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "X, y = make_classification(\n", + " n_samples=100_000, n_features=20, n_informative=2, n_redundant=10, random_state=42\n", + ")\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " X, y, test_size=0.99, random_state=42\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from matplotlib.gridspec import GridSpec\n", + "\n", + "from sklearn.calibration import CalibratedClassifierCV, CalibrationDisplay\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.naive_bayes import GaussianNB\n", + "\n", + "lr = LogisticRegression(C=1.0)\n", + "gnb = GaussianNB()\n", + "gnb_isotonic = CalibratedClassifierCV(gnb, cv=2, method=\"isotonic\")\n", + "gnb_sigmoid = CalibratedClassifierCV(gnb, cv=2, method=\"sigmoid\")\n", + "\n", + "clf_list = [\n", + " (lr, \"Logistic\"),\n", + " (gnb, \"Naive Bayes\"),\n", + " (gnb_isotonic, \"Naive Bayes + Isotonic\"),\n", + " (gnb_sigmoid, \"Naive Bayes + Sigmoid\"),\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(10, 10))\n", + "gs = GridSpec(4, 2)\n", + "colors = plt.cm.get_cmap(\"Dark2\")\n", + "\n", + "ax_calibration_curve = fig.add_subplot(gs[:2, :2])\n", + "calibration_displays = {}\n", + "for i, (clf, name) in enumerate(clf_list):\n", + " clf.fit(X_train, y_train)\n", + " display = CalibrationDisplay.from_estimator(\n", + " clf,\n", + " X_test,\n", + " y_test,\n", + " n_bins=10,\n", + " name=name,\n", + " ax=ax_calibration_curve,\n", + " color=colors(i),\n", + " )\n", + " calibration_displays[name] = display\n", + "\n", + "ax_calibration_curve.grid()\n", + "ax_calibration_curve.set_title(\"Calibration plots (Naive Bayes)\")\n", + "\n", + "# Add histogram\n", + "grid_positions = [(2, 0), (2, 1), (3, 0), (3, 1)]\n", + "for i, (_, name) in enumerate(clf_list):\n", + " row, col = grid_positions[i]\n", + " ax = fig.add_subplot(gs[row, col])\n", + "\n", + " ax.hist(\n", + " calibration_displays[name].y_prob,\n", + " range=(0, 1),\n", + " bins=10,\n", + " label=name,\n", + " color=colors(i),\n", + " )\n", + " ax.set(title=name, xlabel=\"Mean predicted probability\", ylabel=\"Count\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Brier lossLog lossPrecisionRecallF1Roc auc
Classifier
Logistic0.0989210.3231780.8720090.8514080.8615860.863157
Naive Bayes0.1176080.7822460.8574000.8759410.8665710.865055
Naive Bayes + Isotonic0.0983320.3684120.8830650.8362240.8590070.862690
Naive Bayes + Sigmoid0.1088800.3688960.8611060.8712770.8661610.865300
\n", + "
" + ], + "text/plain": [ + " Brier loss Log loss Precision Recall F1 \\\n", + "Classifier \n", + "Logistic 0.098921 0.323178 0.872009 0.851408 0.861586 \n", + "Naive Bayes 0.117608 0.782246 0.857400 0.875941 0.866571 \n", + "Naive Bayes + Isotonic 0.098332 0.368412 0.883065 0.836224 0.859007 \n", + "Naive Bayes + Sigmoid 0.108880 0.368896 0.861106 0.871277 0.866161 \n", + "\n", + " Roc auc \n", + "Classifier \n", + "Logistic 0.863157 \n", + "Naive Bayes 0.865055 \n", + "Naive Bayes + Isotonic 0.862690 \n", + "Naive Bayes + Sigmoid 0.865300 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from collections import defaultdict\n", + "\n", + "import pandas as pd\n", + "\n", + "from sklearn.metrics import (\n", + " precision_score,\n", + " recall_score,\n", + " f1_score,\n", + " brier_score_loss,\n", + " log_loss,\n", + " roc_auc_score,\n", + ")\n", + "\n", + "scores = defaultdict(list)\n", + "for i, (clf, name) in enumerate(clf_list):\n", + " clf.fit(X_train, y_train)\n", + " y_prob = clf.predict_proba(X_test)\n", + " y_pred = clf.predict(X_test)\n", + " scores[\"Classifier\"].append(name)\n", + "\n", + " for metric in [brier_score_loss, log_loss]:\n", + " score_name = metric.__name__.replace(\"_\", \" \").replace(\"score\", \"\").capitalize()\n", + " scores[score_name].append(metric(y_test, y_prob[:, 1]))\n", + "\n", + " for metric in [precision_score, recall_score, f1_score, roc_auc_score]:\n", + " score_name = metric.__name__.replace(\"_\", \" \").replace(\"score\", \"\").capitalize()\n", + " scores[score_name].append(metric(y_test, y_pred))\n", + "\n", + " score_df = pd.DataFrame(scores).set_index(\"Classifier\")\n", + " score_df.round(decimals=3)\n", + "\n", + "score_df" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "from sklearn.svm import LinearSVC\n", + "\n", + "\n", + "class NaivelyCalibratedLinearSVC(LinearSVC):\n", + " \"\"\"LinearSVC with `predict_proba` method that naively scales\n", + " `decision_function` output for binary classification.\"\"\"\n", + "\n", + " def fit(self, X, y):\n", + " super().fit(X, y)\n", + " df = self.decision_function(X)\n", + " self.df_min_ = df.min()\n", + " self.df_max_ = df.max()\n", + "\n", + " def predict_proba(self, X):\n", + " \"\"\"Min-max scale output of `decision_function` to [0, 1].\"\"\"\n", + " df = self.decision_function(X)\n", + " calibrated_df = (df - self.df_min_) / (self.df_max_ - self.df_min_)\n", + " proba_pos_class = np.clip(calibrated_df, 0, 1)\n", + " proba_neg_class = 1 - proba_pos_class\n", + " proba = np.c_[proba_neg_class, proba_pos_class]\n", + " return proba" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "lr = LogisticRegression(C=1.0)\n", + "svc = NaivelyCalibratedLinearSVC(max_iter=10_000)\n", + "svc_isotonic = CalibratedClassifierCV(svc, cv=2, method=\"isotonic\")\n", + "svc_sigmoid = CalibratedClassifierCV(svc, cv=2, method=\"sigmoid\")\n", + "\n", + "clf_list = [\n", + " (lr, \"Logistic\"),\n", + " (svc, \"SVC\"),\n", + " (svc_isotonic, \"SVC + Isotonic\"),\n", + " (svc_sigmoid, \"SVC + Sigmoid\"),\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(10, 10))\n", + "gs = GridSpec(4, 2)\n", + "\n", + "ax_calibration_curve = fig.add_subplot(gs[:2, :2])\n", + "calibration_displays = {}\n", + "for i, (clf, name) in enumerate(clf_list):\n", + " clf.fit(X_train, y_train)\n", + " display = CalibrationDisplay.from_estimator(\n", + " clf,\n", + " X_test,\n", + " y_test,\n", + " n_bins=10,\n", + " name=name,\n", + " ax=ax_calibration_curve,\n", + " color=colors(i),\n", + " )\n", + " calibration_displays[name] = display\n", + "\n", + "ax_calibration_curve.grid()\n", + "ax_calibration_curve.set_title(\"Calibration plots (SVC)\")\n", + "\n", + "# Add histogram\n", + "grid_positions = [(2, 0), (2, 1), (3, 0), (3, 1)]\n", + "for i, (_, name) in enumerate(clf_list):\n", + " row, col = grid_positions[i]\n", + " ax = fig.add_subplot(gs[row, col])\n", + "\n", + " ax.hist(\n", + " calibration_displays[name].y_prob,\n", + " range=(0, 1),\n", + " bins=10,\n", + " label=name,\n", + " color=colors(i),\n", + " )\n", + " ax.set(title=name, xlabel=\"Mean predicted probability\", ylabel=\"Count\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Brier lossLog lossPrecisionRecallF1Roc auc
Classifier
Logistic0.0989210.3231780.8720090.8514080.8615860.863157
SVC0.1449440.4656470.8722010.8517720.8618650.863420
SVC + Isotonic0.0998270.3745350.8530320.8780410.8653560.863306
SVC + Sigmoid0.0987600.3213060.8737030.8487230.8610320.862957
\n", + "
" + ], + "text/plain": [ + " Brier loss Log loss Precision Recall F1 \\\n", + "Classifier \n", + "Logistic 0.098921 0.323178 0.872009 0.851408 0.861586 \n", + "SVC 0.144944 0.465647 0.872201 0.851772 0.861865 \n", + "SVC + Isotonic 0.099827 0.374535 0.853032 0.878041 0.865356 \n", + "SVC + Sigmoid 0.098760 0.321306 0.873703 0.848723 0.861032 \n", + "\n", + " Roc auc \n", + "Classifier \n", + "Logistic 0.863157 \n", + "SVC 0.863420 \n", + "SVC + Isotonic 0.863306 \n", + "SVC + Sigmoid 0.862957 " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scores = defaultdict(list)\n", + "for i, (clf, name) in enumerate(clf_list):\n", + " clf.fit(X_train, y_train)\n", + " y_prob = clf.predict_proba(X_test)\n", + " y_pred = clf.predict(X_test)\n", + " scores[\"Classifier\"].append(name)\n", + "\n", + " for metric in [brier_score_loss, log_loss]:\n", + " score_name = metric.__name__.replace(\"_\", \" \").replace(\"score\", \"\").capitalize()\n", + " scores[score_name].append(metric(y_test, y_prob[:, 1]))\n", + "\n", + " for metric in [precision_score, recall_score, f1_score, roc_auc_score]:\n", + " score_name = metric.__name__.replace(\"_\", \" \").replace(\"score\", \"\").capitalize()\n", + " scores[score_name].append(metric(y_test, y_pred))\n", + "\n", + " score_df = pd.DataFrame(scores).set_index(\"Classifier\")\n", + " score_df.round(decimals=3)\n", + "\n", + "score_df" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('graphnet')", + "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.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e54c104f54ca5f79eede1c2e02355cc39841da57601eff628eedcebaaa867660" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}