From 7b45e6adce83f1fc9542661bf96fbf75d3a90d4b Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Mon, 9 Oct 2023 17:21:33 -0400 Subject: [PATCH 01/34] script to generate the canproco subject dataset --- dataset_analysis/generate_dataset.py | 180 +++++++++++++++++++++++++++ 1 file changed, 180 insertions(+) create mode 100644 dataset_analysis/generate_dataset.py diff --git a/dataset_analysis/generate_dataset.py b/dataset_analysis/generate_dataset.py new file mode 100644 index 0000000..931c673 --- /dev/null +++ b/dataset_analysis/generate_dataset.py @@ -0,0 +1,180 @@ +""" +This file generates the dataset used for the analysis of the CanProCo dataset. +For each patients in the CanProCo dataset, it gathers information about the patient, the pathology and the lesion(s). +For now, this only focuses on the M0 timepoint. + +Args: + --data : path to the CanProCo dataset + --output : path to the output folder + +Returns: + None + +Example: + python generate_dataset.py --data /path/to/CanProCo --output /path/to/output + +Todo: + * + +Pierre-Louis Benveniste +""" + +import os +import argparse +from pathlib import Path +import pandas as pd +import json +import shutil + + +def get_parser(): + """ + This function parses the command line arguments and returns an argparse object. + + Input: + None + + Returns: + parser : argparse object + """ + parser = argparse.ArgumentParser(description='Generates the dataset used for the analysis of the CanProCo dataset.') + parser.add_argument('--data', '-d', type=str, help='path to the CanProCo dataset') + parser.add_argument('--output', '-o', type=str, help='path to the output folder') + + return parser + + +def analyze_patient(participant_id, data_path, participants_tsv, output_folder): + """ + This function analyzes a patient in the CanProCo dataset. + It gathers information on each participant, their pathology and their lesion(s). + + Input: + participant_id : id of the participant + data_path : path to the CanProCo dataset + participants_tsv : pandas dataframe containing information about the participants + + Returns: + patient_data : dictionary containing information about the patient + """ + patient_data = {} + patient_data["participant_id"] = participant_id + #sex + patient_data["sex"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["sex"].values[0] + #age at M0 + patient_data["age"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["age_M0"].values[0] + #pathology + patient_data["pathology"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["pathology_M0"].values[0] + #phenotype_M0 + patient_data["phenotype"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["phenotype_M0"].values[0] + # #date_of_scan_M0 + # patient_data["date_of_scan"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["date_of_scan_M0"].values[0] + # #institution_id_M0 + # patient_data["institution_id"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["institution_id_M0"].values[0] + # #institution_M0 + # patient_data["institution"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["institution_M0"].values[0] + # #manufacturer_M0 + # patient_data["manufacturer"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["manufacturer_M0"].values[0] + # #manufacturers_model_name_M0 + # patient_data["manufacturers_model_name"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["manufacturers_model_name_M0"].values[0] + # #receive_coil_name_M0 + # patient_data["receive_coil_name"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["receive_coil_name_M0"].values[0] + # #software_versions_M0 + # patient_data["software_versions"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["software_versions_M0"].values[0] + #edss_M0 + patient_data["edss"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["edss_M0"].values[0] + + #now we find the lesion segmentation file + lesion_file_PISR = os.path.join(data_path,"derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_lesion-manual.nii.gz") + if os.path.exists(lesion_file_PISR): + lesion_seg_file = lesion_file_PISR + else: + # If PSIR doesn't exist, use STIR + lesion_file_STIR = os.path.join(data_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_lesion-manual.nii.gz") + lesion_seg_file = lesion_file_STIR + + #we find the spinal cord segmentation file + sc_seg_file_PSIR = os.path.join(data_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_sc_seg.nii.gz") + if os.path.exists(sc_seg_file_PSIR): + sc_seg_file = sc_seg_file_PSIR + else: + # If PSIR doesn't exist, use STIR + sc_seg_file_STIR = os.path.join(data_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_sc_seg.nii.gz") + sc_seg_file = sc_seg_file_STIR + + #let's use sct to analyze the lesion + output_folder = os.path.join(output_folder, "tmp") + os.system(f'sct_analyze_lesion -m {lesion_seg_file} -s {sc_seg_file} -ofolder {output_folder} -v 0') + + #now we read the output file + output_file = str(lesion_seg_file).split('/')[-1].replace('.nii.gz', '_analysis.xls') + output_file = os.path.join(output_folder, output_file) + data = pd.read_excel(output_file) + number_of_lesions = max(data['label']) + total_lesion_volume = sum(data['volume [mm3]']) + biggest_lesion_vol = max(data['volume [mm3]']) + biggest_lesion_length = max(data['length [mm]']) + biggest_lesion_eq_diam = max(data['max_equivalent_diameter [mm]']) + + #we add this information to the patient_data dictionary + patient_data["number_of_lesions"] = number_of_lesions + patient_data["total_lesion_volume"] = total_lesion_volume + patient_data["biggest_lesion_vol"] = biggest_lesion_vol + patient_data["biggest_lesion_length"] = biggest_lesion_length + patient_data["biggest_lesion_eq_diam"] = biggest_lesion_eq_diam + + return patient_data + + +def main(): + """ + This function generates the dataset used for the analysis of the CanProCo dataset. + + Input: + None + + Returns: + None + """ + + # Parse the command line arguments + parser = get_parser() + args = parser.parse_args() + + # Get the path to the CanProCo dataset + data_path = args.data + + #build the output folder + output_folder = args.output + if not os.path.isdir(output_folder): + os.mkdir(output_folder) + + #load the participants.tsv file + participants_file = os.path.join(data_path, 'participants.tsv') + participants_tsv = pd.read_csv(participants_file, sep='\t') + + + # Create an empty DataFrame + dataset = pd.DataFrame(columns=[ + 'participant_id', 'sex', 'age', 'pathology', 'phenotype', + 'edss', 'number_of_lesions', 'total_lesion_volume', + 'biggest_lesion_vol', 'biggest_lesion_length', 'biggest_lesion_eq_diam' + ]) + + #iterate over participant_id + for participant in participants_tsv["participant_id"]: + + #analyze the patient + patient_data = analyze_patient(participant, data_path, participants_tsv, output_folder) + + #add the patient to the dataset + dataset = pd.concat([dataset, pd.DataFrame([patient_data])], ignore_index=True) + + print(dataset) + #save the dataset in the output folder + dataset.to_csv(os.path.join(output_folder, 'dataset.csv'), index=False) + + + +if __name__ == '__main__': + main() \ No newline at end of file From 2799103c6839f96649d6d4e721df89c1a921b850 Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Tue, 10 Oct 2023 10:31:36 -0400 Subject: [PATCH 02/34] renamed dataset to dataframe --- .../{generate_dataset.py => generate_dataframe.py} | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) rename dataset_analysis/{generate_dataset.py => generate_dataframe.py} (94%) diff --git a/dataset_analysis/generate_dataset.py b/dataset_analysis/generate_dataframe.py similarity index 94% rename from dataset_analysis/generate_dataset.py rename to dataset_analysis/generate_dataframe.py index 931c673..9c3cad0 100644 --- a/dataset_analysis/generate_dataset.py +++ b/dataset_analysis/generate_dataframe.py @@ -1,5 +1,5 @@ """ -This file generates the dataset used for the analysis of the CanProCo dataset. +This file generates the dataframe used for the analysis of the CanProCo dataset. For each patients in the CanProCo dataset, it gathers information about the patient, the pathology and the lesion(s). For now, this only focuses on the M0 timepoint. @@ -11,7 +11,7 @@ None Example: - python generate_dataset.py --data /path/to/CanProCo --output /path/to/output + python generate_dataframe.py --data /path/to/CanProCo --output /path/to/output Todo: * @@ -155,7 +155,7 @@ def main(): # Create an empty DataFrame - dataset = pd.DataFrame(columns=[ + dataframe = pd.DataFrame(columns=[ 'participant_id', 'sex', 'age', 'pathology', 'phenotype', 'edss', 'number_of_lesions', 'total_lesion_volume', 'biggest_lesion_vol', 'biggest_lesion_length', 'biggest_lesion_eq_diam' @@ -168,11 +168,11 @@ def main(): patient_data = analyze_patient(participant, data_path, participants_tsv, output_folder) #add the patient to the dataset - dataset = pd.concat([dataset, pd.DataFrame([patient_data])], ignore_index=True) + dataframe = pd.concat([dataframe, pd.DataFrame([patient_data])], ignore_index=True) - print(dataset) + print(dataframe) #save the dataset in the output folder - dataset.to_csv(os.path.join(output_folder, 'dataset.csv'), index=False) + dataframe.to_csv(os.path.join(output_folder, 'dataframe.csv'), index=False) From 1905c79de885b2bd183f50841500dd1746265ccb Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Tue, 10 Oct 2023 18:05:56 -0400 Subject: [PATCH 03/34] added the analysis of lesions per vert levels --- dataset_analysis/generate_dataframe.py | 214 ++++++++++++++++++------- 1 file changed, 160 insertions(+), 54 deletions(-) diff --git a/dataset_analysis/generate_dataframe.py b/dataset_analysis/generate_dataframe.py index 9c3cad0..6103ff6 100644 --- a/dataset_analysis/generate_dataframe.py +++ b/dataset_analysis/generate_dataframe.py @@ -25,6 +25,8 @@ import pandas as pd import json import shutil +import nibabel as nib +import numpy as np def get_parser(): @@ -44,66 +46,122 @@ def get_parser(): return parser -def analyze_patient(participant_id, data_path, participants_tsv, output_folder): +def analyse_lesion_per_levels(patient_data, dataset_path, output_folder): """ - This function analyzes a patient in the CanProCo dataset. - It gathers information on each participant, their pathology and their lesion(s). + This function focuses on lesions per spinal cord levels. + It computes the number, volume and average length of lesions per spinal cord level. Input: - participant_id : id of the participant - data_path : path to the CanProCo dataset - participants_tsv : pandas dataframe containing information about the participants + lesion_seg_file : path to the lesion segmentation file + labelled_sc_seg_file : path to the labelled spinal cord segmentation file + + Returns: + patient_data : dictionary containing information about the patient + """ + #get the participant_id + participant_id = patient_data["participant_id"] + + #the output folder + output_folder = os.path.join(output_folder, "tmp", participant_id) + + #now we find the labelledlesion segmentation file (it was created at the previous step with sct_analyze lesions) and the vertebral levels segmentation file + lesion_file_PSIR = os.path.join(output_folder, f"{participant_id}_ses-M0_PSIR_lesion-manual_label.nii.gz") + if os.path.exists(lesion_file_PSIR): + #if PSIR exists, use PSIR + lesion_seg_file = lesion_file_PSIR + vert_levels_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_sc_seg_labeled_discs.nii.gz") + else: + # If PSIR doesn't exist, use STIR + lesion_seg_file = os.path.join(output_folder, f"{participant_id}_ses-M0_STIR_lesion-manual_label.nii.gz") + vert_levels_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_sc_seg_labeled_discs.nii.gz") + + #now we read the lesion segmentation file and the labelled spinal cord segmentation file + lesion_labelled_seg = nib.load(lesion_seg_file) + vert_levels_seg_file = nib.load(vert_levels_seg_file) + + #we get the data from the lesion segmentation file and the labelled spinal cord segmentation file + lesion_labelled_seg_data = lesion_labelled_seg.get_fdata() + vert_levels_seg_data = vert_levels_seg_file.get_fdata() + + #get voxel size + voxel_size = lesion_labelled_seg.header.get_zooms() + + #the levels are the integer unique values without 0 + levels = np.unique(vert_levels_seg_data) + levels = levels[levels != 0] + + #we iterate over the levels + for i in range(len(levels)-1): + #get upper bound of level + upper_bound = np.where(vert_levels_seg_data == levels[i]) + upper_bound = int(upper_bound[1]) + #get lower bound of level + lower_bound = np.where(vert_levels_seg_data == levels[i+1]) + lower_bound = int(lower_bound[1]) + + #initialize the lesion_info_per_levels dictionary + nb_lesions_in_level = 0 + total_lesion_volume_in_level = 0 + avg_lesion_length_in_level = 0 + + #now we look for the lesions in this level + ## get the lesions + lesions = np.unique(lesion_labelled_seg_data) + lesions = lesions[lesions != 0] + ## iterate over the lesions + for lesion in lesions: + lesion_voxel = np.where(lesion_labelled_seg_data == lesion) + center_of_lesion = np.mean(lesion_voxel, axis=1) + volume_of_lesion = len(lesion_voxel[0])*voxel_size[0]*voxel_size[1]*voxel_size[2] + top_of_lesion = np.max(lesion_voxel[2]) + bottom_of_lesion = np.min(lesion_voxel[2]) + length_of_lesion = (top_of_lesion - bottom_of_lesion)*voxel_size[2] + #if lesion center is between upper and lower bound, then it is in the level + if center_of_lesion[1] <= upper_bound and center_of_lesion[1] >= lower_bound: + nb_lesions_in_level += 1 + total_lesion_volume_in_level += volume_of_lesion + avg_lesion_length_in_level += length_of_lesion + + #compute the average vertical length + if nb_lesions_in_level != 0: + avg_lesion_length_in_level = avg_lesion_length_in_level/nb_lesions_in_level + + #we add this information to the patient_data dictionary + patient_data[f"nb_lesions_between_{levels[i]}_and_{levels[i+1]}"] = nb_lesions_in_level + patient_data[f"total_lesion_volume_between_{levels[i]}_and_{levels[i+1]}"] = total_lesion_volume_in_level + patient_data[f"avg_lesion_length_between_{levels[i]}_and_{levels[i+1]}"] = avg_lesion_length_in_level + + return patient_data + + +def analyze_patient_lesion(patient_data, dataset_path, output_folder): + """ + This function analyzes the lesions of a patient using the sct_analyse_lesions. + It gathers information on the number of lesions, their volumes, their lengths and their equivalent diameters. + + Input: + patient_data : dictionary containing information about the patient + dataset_path : path to the CanProCo dataset + output_folder : path to the output folder where the analysis will be saved Returns: patient_data : dictionary containing information about the patient """ - patient_data = {} - patient_data["participant_id"] = participant_id - #sex - patient_data["sex"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["sex"].values[0] - #age at M0 - patient_data["age"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["age_M0"].values[0] - #pathology - patient_data["pathology"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["pathology_M0"].values[0] - #phenotype_M0 - patient_data["phenotype"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["phenotype_M0"].values[0] - # #date_of_scan_M0 - # patient_data["date_of_scan"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["date_of_scan_M0"].values[0] - # #institution_id_M0 - # patient_data["institution_id"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["institution_id_M0"].values[0] - # #institution_M0 - # patient_data["institution"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["institution_M0"].values[0] - # #manufacturer_M0 - # patient_data["manufacturer"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["manufacturer_M0"].values[0] - # #manufacturers_model_name_M0 - # patient_data["manufacturers_model_name"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["manufacturers_model_name_M0"].values[0] - # #receive_coil_name_M0 - # patient_data["receive_coil_name"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["receive_coil_name_M0"].values[0] - # #software_versions_M0 - # patient_data["software_versions"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["software_versions_M0"].values[0] - #edss_M0 - patient_data["edss"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["edss_M0"].values[0] + #get the participant_id + participant_id = patient_data["participant_id"] - #now we find the lesion segmentation file - lesion_file_PISR = os.path.join(data_path,"derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_lesion-manual.nii.gz") + #now we find the lesion segmentation file and the spinal cord segmentation file + lesion_file_PISR = os.path.join(dataset_path,"derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_lesion-manual.nii.gz") if os.path.exists(lesion_file_PISR): lesion_seg_file = lesion_file_PISR + sc_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_sc_seg.nii.gz") else: # If PSIR doesn't exist, use STIR - lesion_file_STIR = os.path.join(data_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_lesion-manual.nii.gz") - lesion_seg_file = lesion_file_STIR - - #we find the spinal cord segmentation file - sc_seg_file_PSIR = os.path.join(data_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_sc_seg.nii.gz") - if os.path.exists(sc_seg_file_PSIR): - sc_seg_file = sc_seg_file_PSIR - else: - # If PSIR doesn't exist, use STIR - sc_seg_file_STIR = os.path.join(data_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_sc_seg.nii.gz") - sc_seg_file = sc_seg_file_STIR + lesion_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_lesion-manual.nii.gz") + sc_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_sc_seg.nii.gz") #let's use sct to analyze the lesion - output_folder = os.path.join(output_folder, "tmp") + output_folder = os.path.join(output_folder, "tmp", participant_id) os.system(f'sct_analyze_lesion -m {lesion_seg_file} -s {sc_seg_file} -ofolder {output_folder} -v 0') #now we read the output file @@ -126,9 +184,55 @@ def analyze_patient(participant_id, data_path, participants_tsv, output_folder): return patient_data +def analyze_patient_tsv(participant_id, participants_tsv): + """ + This function gathers information from the participants.tsv file. + It gathers information on each participant, their pathology (and the material used for image acquisition). + + Input: + participant_id : id of the participant + participants_tsv : pandas dataframe containing information about the participants + + Returns: + patient_data : dictionary containing information about the patient + """ + patient_data = {} + patient_data["participant_id"] = participant_id + #sex + patient_data["sex"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["sex"].values[0] + #age at M0 + patient_data["age"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["age_M0"].values[0] + #pathology + patient_data["pathology"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["pathology_M0"].values[0] + #phenotype_M0 + patient_data["phenotype"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["phenotype_M0"].values[0] + #edss_M0 + patient_data["edss"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["edss_M0"].values[0] + + #### ------------- THE BELOW INFORMATION IS NOT USED FOR NOW -------------- #### + # # #date_of_scan_M0 + # patient_data["date_of_scan"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["date_of_scan_M0"].values[0] + # # #institution_id_M0 + # patient_data["institution_id"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["institution_id_M0"].values[0] + # # #institution_M0 + # patient_data["institution"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["institution_M0"].values[0] + # # #manufacturer_M0 + # patient_data["manufacturer"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["manufacturer_M0"].values[0] + # # #manufacturers_model_name_M0 + # patient_data["manufacturers_model_name"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["manufacturers_model_name_M0"].values[0] + # # #receive_coil_name_M0 + # patient_data["receive_coil_name"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["receive_coil_name_M0"].values[0] + # # #software_versions_M0 + # patient_data["software_versions"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["software_versions_M0"].values[0] + #### ------------- ------------------------------------------ -------------- #### + + + return patient_data + + def main(): """ - This function generates the dataset used for the analysis of the CanProCo dataset. + This function generates the dataframe used for the analysis of the CanProCo dataset. Input: None @@ -155,17 +259,19 @@ def main(): # Create an empty DataFrame - dataframe = pd.DataFrame(columns=[ - 'participant_id', 'sex', 'age', 'pathology', 'phenotype', - 'edss', 'number_of_lesions', 'total_lesion_volume', - 'biggest_lesion_vol', 'biggest_lesion_length', 'biggest_lesion_eq_diam' - ]) + dataframe = pd.DataFrame() #iterate over participant_id for participant in participants_tsv["participant_id"]: - #analyze the patient - patient_data = analyze_patient(participant, data_path, participants_tsv, output_folder) + #analyze the patient tsv file + patient_data = analyze_patient_tsv(participant, participants_tsv) + + #analyze the patient lesion + patient_data = analyze_patient_lesion(patient_data, data_path, output_folder) + + #analyze the patient lesion distributions per levels + patient_data = analyse_lesion_per_levels(patient_data, data_path, output_folder) #add the patient to the dataset dataframe = pd.concat([dataframe, pd.DataFrame([patient_data])], ignore_index=True) From 29e9cb7fe2080ec447b145c4520a34800cc38a55 Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Wed, 11 Oct 2023 16:30:27 -0400 Subject: [PATCH 04/34] notebook created with basic dataset statistics --- dataset_analysis/dataframe_analysis.ipynb | 248 ++++++++++++++++++++++ 1 file changed, 248 insertions(+) create mode 100644 dataset_analysis/dataframe_analysis.ipynb diff --git a/dataset_analysis/dataframe_analysis.ipynb b/dataset_analysis/dataframe_analysis.ipynb new file mode 100644 index 0000000..49e20c9 --- /dev/null +++ b/dataset_analysis/dataframe_analysis.ipynb @@ -0,0 +1,248 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Dataframe analysis\n", + "\n", + "This notebook explores the analysis of the dataframe built from canproco at time point M0. \n", + "It looks at correlation between age, phenotypes, nb of lesions and distribution of lesions. \n", + "\n", + "Author : Pierre-Louis Benveniste" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import os\n", + "import sys\n", + "import yaml" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Dataframe import\n", + "\n", + "We import the dataframe and exclude the subjects which are in the `exclude.yml` file. " + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "#load dataframe\n", + "dataframe_path = '/Users/plbenveniste/Desktop/test_generate_dataframe/dataframe.csv'\n", + "dataframe = pd.read_csv(dataframe_path)\n", + "\n", + "#load exclude.yml file\n", + "exclude_path = '/Users/plbenveniste/Documents/NeuroPoly/canproco_project/canproco/exclude.yml'\n", + "#exclude_file = pd.read_csv(exclude_path)\n", + "with open(exclude_path, 'r') as yaml_file:\n", + " exclude_file = yaml.load(yaml_file, Loader=yaml.FullLoader)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Subject exclusion\n", + "\n", + "Some subjects were excluded because of poor image quality" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "#iterate over excluded subjects\n", + "for subject in exclude_file:\n", + " #exclude subject from dataframe\n", + " dataframe = dataframe[dataframe.participant_id != subject.split('_')[0]]\n", + "\n", + "#we make sure that participants are only included once\n", + "dataframe = dataframe.drop_duplicates(subset=['participant_id'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# General statistics\n", + "\n", + "Here we compute general statistics about the dataset:\n", + "- number of participant\n", + "- number of healthy control\n", + "- age distribution\n", + "- proportion of male/female\n", + "- number and proportion per edss/phenotype" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of participants: 3\n", + "Number of females: 2 (67%)\n", + "Number of females: 1 (33%)\n", + "\n", + "Number of healthy participants: 0 (0%)\n", + "Number of MS participants: 3 (100%)\n", + "\n", + "Age distribution:\n", + "count 3.000000\n", + "mean 39.333333\n", + "std 13.796135\n", + "min 29.000000\n", + "25% 31.500000\n", + "50% 34.000000\n", + "75% 44.500000\n", + "max 55.000000\n", + "Name: age, dtype: float64\n" + ] + } + ], + "source": [ + "#number of participants\n", + "nb_participant = len(dataframe.participant_id)\n", + "#number of female participants\n", + "nb_female = len(dataframe[dataframe.sex == 'F'])\n", + "#number of male participants\n", + "nb_male = len(dataframe[dataframe.sex == 'M'])\n", + "#number of healthy patients\n", + "nb_healthy = len(dataframe[dataframe.pathology == 'HC'])\n", + "#number of MS patients\n", + "nb_MS = len(dataframe[dataframe.pathology == 'MS'])\n", + "\n", + "#now we print them all:\n", + "print('Number of participants: ', nb_participant)\n", + "print('Number of females: '+ str(nb_female) + \" (\" + str(round(nb_female/nb_participant*100)) + \"%)\")\n", + "print('Number of females: '+ str(nb_male) + \" (\" + str(round(nb_male/nb_participant*100)) + \"%)\\n\")\n", + "print('Number of healthy participants: '+ str(nb_healthy) + \" (\" + str(round(nb_healthy/nb_participant*100)) + \"%)\")\n", + "print('Number of MS participants: '+ str(nb_MS) + \" (\" + str(round(nb_MS/nb_participant*100)) + \"%)\\n\")\n", + "print('Age distribution:')\n", + "print(dataframe.age.describe())\n", + "\n", + "## Uncomment to see boxplot of age distribution\n", + "# #now we can plot the age distribution\n", + "# plt.figure(figsize=(3, 5))\n", + "# plt.boxplot(dataframe.age)\n", + "# plt.title('Age distribution')\n", + "# plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "EDSS distribution:\n", + "count 3.000000\n", + "mean 1.166667\n", + "std 1.040833\n", + "min 0.000000\n", + "25% 0.750000\n", + "50% 1.500000\n", + "75% 1.750000\n", + "max 2.000000\n", + "Name: edss, dtype: float64\n" + ] + } + ], + "source": [ + "# now we show the distribution of edss scores\n", + "print('EDSS distribution:')\n", + "print(dataframe.edss.describe())\n", + "\n", + "##Uncomment to see boxplot of edss distribution\n", + "# #now we can plot the edss distribution\n", + "# plt.figure(figsize=(3, 5))\n", + "# plt.boxplot(dataframe.edss)\n", + "# plt.title('EDSS distribution')\n", + "# plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of RIS participants: 2 (67%)\n", + "Number of RRMS participants: 1 (33%)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#now we can look at the distribution of phenotypes\n", + "phenotypes = dataframe.phenotype.unique()\n", + "for phenotype in phenotypes:\n", + " print('Number of ' + phenotype + ' participants: ' + str(len(dataframe[dataframe.phenotype == phenotype])) + \" (\" + str(round(len(dataframe[dataframe.phenotype == phenotype])/nb_participant*100)) + \"%)\")\n", + "\n", + "## uncomment to see barplot of phenotypes\n", + "#now we can plot the phenotype distribution\n", + "plt.figure(figsize=(3, 5))\n", + "sns.countplot(x='phenotype', data=dataframe)\n", + "plt.title('Phenotype distribution')\n", + "plt.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.11" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From be4eb85b194a7e437f37f4ea2c06ca82712d0edb Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Wed, 11 Oct 2023 16:44:14 -0400 Subject: [PATCH 05/34] add statistics about lesions --- dataset_analysis/dataframe_analysis.ipynb | 64 +++++++++++++++++++++++ 1 file changed, 64 insertions(+) diff --git a/dataset_analysis/dataframe_analysis.ipynb b/dataset_analysis/dataframe_analysis.ipynb index 49e20c9..93c182d 100644 --- a/dataset_analysis/dataframe_analysis.ipynb +++ b/dataset_analysis/dataframe_analysis.ipynb @@ -221,6 +221,70 @@ "plt.title('Phenotype distribution')\n", "plt.show()\n" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Statistics about lesions \n", + "\n", + "In this section we describe statistics regarding the MS lesions of the participants: \n", + "- avg number of lesion\n", + "- total volume of lesions\n", + "- biggest lesion volume\n", + "- biggest lesion length\n", + "- biggest lesion eq diameter" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index(['participant_id', 'sex', 'age', 'pathology', 'phenotype', 'edss',\n", + " 'number_of_lesions', 'total_lesion_volume', 'biggest_lesion_vol',\n", + " 'biggest_lesion_length', 'biggest_lesion_eq_diam',\n", + " 'nb_lesions_between_2.0_and_3.0',\n", + " 'total_lesion_volume_between_2.0_and_3.0',\n", + " 'avg_lesion_length_between_2.0_and_3.0',\n", + " 'nb_lesions_between_3.0_and_4.0',\n", + " 'total_lesion_volume_between_3.0_and_4.0',\n", + " 'avg_lesion_length_between_3.0_and_4.0',\n", + " 'nb_lesions_between_4.0_and_5.0',\n", + " 'total_lesion_volume_between_4.0_and_5.0',\n", + " 'avg_lesion_length_between_4.0_and_5.0',\n", + " 'nb_lesions_between_5.0_and_6.0',\n", + " 'total_lesion_volume_between_5.0_and_6.0',\n", + " 'avg_lesion_length_between_5.0_and_6.0',\n", + " 'nb_lesions_between_6.0_and_7.0',\n", + " 'total_lesion_volume_between_6.0_and_7.0',\n", + " 'avg_lesion_length_between_6.0_and_7.0',\n", + " 'nb_lesions_between_7.0_and_8.0',\n", + " 'total_lesion_volume_between_7.0_and_8.0',\n", + " 'avg_lesion_length_between_7.0_and_8.0',\n", + " 'nb_lesions_between_8.0_and_9.0',\n", + " 'total_lesion_volume_between_8.0_and_9.0',\n", + " 'avg_lesion_length_between_8.0_and_9.0',\n", + " 'nb_lesions_between_9.0_and_10.0',\n", + " 'total_lesion_volume_between_9.0_and_10.0',\n", + " 'avg_lesion_length_between_9.0_and_10.0',\n", + " 'nb_lesions_between_10.0_and_11.0',\n", + " 'total_lesion_volume_between_10.0_and_11.0',\n", + " 'avg_lesion_length_between_10.0_and_11.0',\n", + " 'nb_lesions_between_1.0_and_2.0',\n", + " 'total_lesion_volume_between_1.0_and_2.0',\n", + " 'avg_lesion_length_between_1.0_and_2.0'],\n", + " dtype='object')\n" + ] + } + ], + "source": [ + "print(dataframe.columns)" + ] } ], "metadata": { From e96eca72b08c7e7979c540269538471579c71f6c Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Thu, 12 Oct 2023 14:02:50 -0400 Subject: [PATCH 06/34] modification of column format --- dataset_analysis/generate_dataframe.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/dataset_analysis/generate_dataframe.py b/dataset_analysis/generate_dataframe.py index 6103ff6..22276ea 100644 --- a/dataset_analysis/generate_dataframe.py +++ b/dataset_analysis/generate_dataframe.py @@ -125,11 +125,13 @@ def analyse_lesion_per_levels(patient_data, dataset_path, output_folder): #compute the average vertical length if nb_lesions_in_level != 0: avg_lesion_length_in_level = avg_lesion_length_in_level/nb_lesions_in_level + avg_lesion_volume_in_level = total_lesion_volume_in_level/nb_lesions_in_level #we add this information to the patient_data dictionary - patient_data[f"nb_lesions_between_{levels[i]}_and_{levels[i+1]}"] = nb_lesions_in_level - patient_data[f"total_lesion_volume_between_{levels[i]}_and_{levels[i+1]}"] = total_lesion_volume_in_level - patient_data[f"avg_lesion_length_between_{levels[i]}_and_{levels[i+1]}"] = avg_lesion_length_in_level + patient_data[f"nb_lesions_between_{int(levels[i]):02d}_and_{int(levels[i+1]):02d}"] = nb_lesions_in_level + patient_data[f"total_lesion_volume_between_{int(levels[i]):02d}_and_{int(levels[i+1]):02d}"] = total_lesion_volume_in_level + patient_data[f"avg_lesion_volume_between_{int(levels[i]):02d}_and_{int(levels[i+1]):02d}"] = avg_lesion_volume_in_level + patient_data[f"avg_lesion_length_between_{int(levels[i]):02d}_and_{int(levels[i+1]):02d}"] = avg_lesion_length_in_level return patient_data From edb7e7ce1f4707247fd6e8731f25190e621767e1 Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Thu, 12 Oct 2023 14:03:42 -0400 Subject: [PATCH 07/34] analysis of the distribution of lesions per volum --- dataset_analysis/dataframe_analysis.ipynb | 173 ++++++++++++++++------ 1 file changed, 127 insertions(+), 46 deletions(-) diff --git a/dataset_analysis/dataframe_analysis.ipynb b/dataset_analysis/dataframe_analysis.ipynb index 93c182d..69b8348 100644 --- a/dataset_analysis/dataframe_analysis.ipynb +++ b/dataset_analysis/dataframe_analysis.ipynb @@ -14,7 +14,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 43, "metadata": {}, "outputs": [], "source": [ @@ -38,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 44, "metadata": {}, "outputs": [], "source": [ @@ -64,7 +64,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 45, "metadata": {}, "outputs": [], "source": [ @@ -93,7 +93,7 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 46, "metadata": {}, "outputs": [ { @@ -151,7 +151,7 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 47, "metadata": {}, "outputs": [ { @@ -186,7 +186,7 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 48, "metadata": {}, "outputs": [ { @@ -238,52 +238,133 @@ }, { "cell_type": "code", - "execution_count": 74, + "execution_count": 49, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Index(['participant_id', 'sex', 'age', 'pathology', 'phenotype', 'edss',\n", - " 'number_of_lesions', 'total_lesion_volume', 'biggest_lesion_vol',\n", - " 'biggest_lesion_length', 'biggest_lesion_eq_diam',\n", - " 'nb_lesions_between_2.0_and_3.0',\n", - " 'total_lesion_volume_between_2.0_and_3.0',\n", - " 'avg_lesion_length_between_2.0_and_3.0',\n", - " 'nb_lesions_between_3.0_and_4.0',\n", - " 'total_lesion_volume_between_3.0_and_4.0',\n", - " 'avg_lesion_length_between_3.0_and_4.0',\n", - " 'nb_lesions_between_4.0_and_5.0',\n", - " 'total_lesion_volume_between_4.0_and_5.0',\n", - " 'avg_lesion_length_between_4.0_and_5.0',\n", - " 'nb_lesions_between_5.0_and_6.0',\n", - " 'total_lesion_volume_between_5.0_and_6.0',\n", - " 'avg_lesion_length_between_5.0_and_6.0',\n", - " 'nb_lesions_between_6.0_and_7.0',\n", - " 'total_lesion_volume_between_6.0_and_7.0',\n", - " 'avg_lesion_length_between_6.0_and_7.0',\n", - " 'nb_lesions_between_7.0_and_8.0',\n", - " 'total_lesion_volume_between_7.0_and_8.0',\n", - " 'avg_lesion_length_between_7.0_and_8.0',\n", - " 'nb_lesions_between_8.0_and_9.0',\n", - " 'total_lesion_volume_between_8.0_and_9.0',\n", - " 'avg_lesion_length_between_8.0_and_9.0',\n", - " 'nb_lesions_between_9.0_and_10.0',\n", - " 'total_lesion_volume_between_9.0_and_10.0',\n", - " 'avg_lesion_length_between_9.0_and_10.0',\n", - " 'nb_lesions_between_10.0_and_11.0',\n", - " 'total_lesion_volume_between_10.0_and_11.0',\n", - " 'avg_lesion_length_between_10.0_and_11.0',\n", - " 'nb_lesions_between_1.0_and_2.0',\n", - " 'total_lesion_volume_between_1.0_and_2.0',\n", - " 'avg_lesion_length_between_1.0_and_2.0'],\n", - " dtype='object')\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "print(dataframe.columns)" + "# we get the column names of the dataframe corresponding to the regions\n", + "regions = dataframe.columns\n", + "regions = [str(column) for column in regions if 'lesions_between' in column]\n", + "regions = np.sort(regions)\n", + "\n", + "# we output the hist plot of the distribution of lesions per regions\n", + "plt.figure(figsize=(25, 5))\n", + "legend = [region.split('_',2)[-1] for region in regions]\n", + "plt.bar(legend, dataframe[regions].sum())\n", + "plt.title('Distribution of lesions per regions')\n", + "plt.xlabel('Regions')\n", + "plt.ylabel('Number of lesions')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Now we do the same thing but for the total volume of lesions per regions\n", + "regions = dataframe.columns\n", + "regions = [str(column) for column in regions if 'total_lesion_volume_between' in column]\n", + "regions = np.sort(regions)\n", + "# print(regions)\n", + "\n", + "# we output the hist plot of the distribution of volume of lesions per regions\n", + "plt.figure(figsize=(25, 5))\n", + "legend = [region.split('_',3)[-1] for region in regions]\n", + "plt.bar(legend, dataframe[regions].sum())\n", + "plt.title('Distribution of total volume of lesions per regions')\n", + "plt.xlabel('Regions')\n", + "plt.ylabel('Volume of lesions (mm3)')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Now we do the same thing but for the average volume of lesions per regions\n", + "regions = dataframe.columns\n", + "regions = [str(column) for column in regions if 'avg_lesion_volume_between' in column]\n", + "regions = np.sort(regions)\n", + "# print(regions)\n", + "\n", + "# we output the hist plot of the distribution of volume of lesions per regions\n", + "plt.figure(figsize=(25, 5))\n", + "legend = [region.split('_',3)[-1] for region in regions]\n", + "plt.bar(legend, dataframe[regions].sum())\n", + "plt.title('Distribution of average volume of lesions per regions')\n", + "plt.xlabel('Regions')\n", + "plt.ylabel('Volume of lesions (mm3)')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Now we do the same thing but for the average length of lesions per regions\n", + "regions = dataframe.columns\n", + "regions = [str(column) for column in regions if 'avg_lesion_length_between' in column]\n", + "regions = np.sort(regions)\n", + "# print(regions)\n", + "\n", + "# we output the hist plot of the distribution of length of lesions per regions\n", + "plt.figure(figsize=(25, 5))\n", + "legend = [region.split('_',3)[-1] for region in regions]\n", + "plt.bar(legend, dataframe[regions].sum())\n", + "plt.title('Distribution of average length of lesions per regions')\n", + "plt.xlabel('Regions')\n", + "plt.ylabel('Length of lesions (mm)')\n", + "plt.show()" ] } ], From 7e9fc0b169a7d636d167dedb2a7fa7ddde01cfd7 Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Tue, 17 Oct 2023 12:06:15 -0400 Subject: [PATCH 08/34] added sc volume in dataframe --- dataset_analysis/generate_dataframe.py | 38 ++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/dataset_analysis/generate_dataframe.py b/dataset_analysis/generate_dataframe.py index 22276ea..35d620b 100644 --- a/dataset_analysis/generate_dataframe.py +++ b/dataset_analysis/generate_dataframe.py @@ -46,6 +46,41 @@ def get_parser(): return parser +def get_spinal_cord_info(patient_data, dataset_path): + """This functions computes the volume of the spinal cord for each patient. + The volume is added to the patient_data dictionary. + + Input: + patient_data : dictionary containing information about the patient + dataset_path : path to the CanProCo dataset + + Returns: + patient_data : dictionary containing information about the patient + """ + + #get the participant_id + participant_id = patient_data["participant_id"] + + #now we find the spinal cord segmentation file + sc_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_sc_seg.nii.gz") + if not os.path.exists(sc_seg_file): + # If PSIR doesn't exist, use STIR + sc_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_sc_seg.nii.gz") + + #now we read the spinal cord segmentation file + sc_seg = nib.load(sc_seg_file) + + #now we get the total volume of the spinal cord + sc_seg_data = sc_seg.get_fdata() + voxel_size = sc_seg.header.get_zooms() + sc_volume = np.sum(sc_seg_data)*voxel_size[0]*voxel_size[1]*voxel_size[2] + + #we add this information to the patient_data dictionary + patient_data["sc_volume"] = sc_volume + + return patient_data + + def analyse_lesion_per_levels(patient_data, dataset_path, output_folder): """ This function focuses on lesions per spinal cord levels. @@ -275,6 +310,9 @@ def main(): #analyze the patient lesion distributions per levels patient_data = analyse_lesion_per_levels(patient_data, data_path, output_folder) + #analyze the patient spinal cord volume + patient_data = get_spinal_cord_info(patient_data, data_path) + #add the patient to the dataset dataframe = pd.concat([dataframe, pd.DataFrame([patient_data])], ignore_index=True) From 3b7a3d4414cf77060187e7c9c67c1c4eae631af4 Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Tue, 24 Oct 2023 10:54:35 -0400 Subject: [PATCH 09/34] changed file termination for sc_seg --- dataset_analysis/generate_dataframe.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/dataset_analysis/generate_dataframe.py b/dataset_analysis/generate_dataframe.py index 35d620b..7527260 100644 --- a/dataset_analysis/generate_dataframe.py +++ b/dataset_analysis/generate_dataframe.py @@ -62,10 +62,10 @@ def get_spinal_cord_info(patient_data, dataset_path): participant_id = patient_data["participant_id"] #now we find the spinal cord segmentation file - sc_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_sc_seg.nii.gz") + sc_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_seg-manual.nii.gz") if not os.path.exists(sc_seg_file): # If PSIR doesn't exist, use STIR - sc_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_sc_seg.nii.gz") + sc_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_seg-manual.nii.gz") #now we read the spinal cord segmentation file sc_seg = nib.load(sc_seg_file) @@ -104,11 +104,11 @@ def analyse_lesion_per_levels(patient_data, dataset_path, output_folder): if os.path.exists(lesion_file_PSIR): #if PSIR exists, use PSIR lesion_seg_file = lesion_file_PSIR - vert_levels_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_sc_seg_labeled_discs.nii.gz") + vert_levels_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_seg-manual_labeled_discs.nii.gz") else: # If PSIR doesn't exist, use STIR lesion_seg_file = os.path.join(output_folder, f"{participant_id}_ses-M0_STIR_lesion-manual_label.nii.gz") - vert_levels_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_sc_seg_labeled_discs.nii.gz") + vert_levels_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_seg-manual_labeled_discs.nii.gz") #now we read the lesion segmentation file and the labelled spinal cord segmentation file lesion_labelled_seg = nib.load(lesion_seg_file) @@ -191,11 +191,11 @@ def analyze_patient_lesion(patient_data, dataset_path, output_folder): lesion_file_PISR = os.path.join(dataset_path,"derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_lesion-manual.nii.gz") if os.path.exists(lesion_file_PISR): lesion_seg_file = lesion_file_PISR - sc_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_sc_seg.nii.gz") + sc_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_seg-manual.nii.gz") else: # If PSIR doesn't exist, use STIR lesion_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_lesion-manual.nii.gz") - sc_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_sc_seg.nii.gz") + sc_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_seg-manual.nii.gz") #let's use sct to analyze the lesion output_folder = os.path.join(output_folder, "tmp", participant_id) From 41f704b94b49c2ee24a12c2a6baa4479b66adc66 Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Wed, 25 Oct 2023 00:24:08 -0400 Subject: [PATCH 10/34] changed file with multiple path to different BIDS folder containing each mask --- dataset_analysis/generate_dataframe.py | 72 +++++++++++++++----------- 1 file changed, 42 insertions(+), 30 deletions(-) diff --git a/dataset_analysis/generate_dataframe.py b/dataset_analysis/generate_dataframe.py index 7527260..c7739e6 100644 --- a/dataset_analysis/generate_dataframe.py +++ b/dataset_analysis/generate_dataframe.py @@ -1,10 +1,14 @@ """ This file generates the dataframe used for the analysis of the CanProCo dataset. For each patients in the CanProCo dataset, it gathers information about the patient, the pathology and the lesion(s). -For now, this only focuses on the M0 timepoint. + Args: --data : path to the CanProCo dataset + --lesion : path to the lesion segmentation file + --discs : path to the vertebral levels segmentation file + --spinal-cord : path to the spinal cord segmentation file + --timepoint : timepoint of the analysis (M0, M12) --output : path to the output folder Returns: @@ -41,12 +45,16 @@ def get_parser(): """ parser = argparse.ArgumentParser(description='Generates the dataset used for the analysis of the CanProCo dataset.') parser.add_argument('--data', '-d', type=str, help='path to the CanProCo dataset') + parser.add_argument('--lesion', '-l', type=str, help='path to the lesion segmentation file') + parser.add_argument('--discs', type=str, help='path to the vertebral levels segmentation file') + parser.add_argument('--spinal-cord', type=str, help='path to the spinal cord segmentation file') + parser.add_argument('--timepoint', '-t', type=str, help='timepoint of the analysis (M0, M12)') parser.add_argument('--output', '-o', type=str, help='path to the output folder') return parser -def get_spinal_cord_info(patient_data, dataset_path): +def get_spinal_cord_info(patient_data, spinal_cord_path, dataset_path): """This functions computes the volume of the spinal cord for each patient. The volume is added to the patient_data dictionary. @@ -62,10 +70,10 @@ def get_spinal_cord_info(patient_data, dataset_path): participant_id = patient_data["participant_id"] #now we find the spinal cord segmentation file - sc_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_seg-manual.nii.gz") + sc_seg_file = os.path.join(spinal_cord_path, participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_seg-manual.nii.gz") if not os.path.exists(sc_seg_file): # If PSIR doesn't exist, use STIR - sc_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_seg-manual.nii.gz") + sc_seg_file = os.path.join(spinal_cord_path, participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_seg-manual.nii.gz") #now we read the spinal cord segmentation file sc_seg = nib.load(sc_seg_file) @@ -81,7 +89,7 @@ def get_spinal_cord_info(patient_data, dataset_path): return patient_data -def analyse_lesion_per_levels(patient_data, dataset_path, output_folder): +def analyse_lesion_per_levels(patient_data, discs_path, output_folder): """ This function focuses on lesions per spinal cord levels. It computes the number, volume and average length of lesions per spinal cord level. @@ -99,39 +107,39 @@ def analyse_lesion_per_levels(patient_data, dataset_path, output_folder): #the output folder output_folder = os.path.join(output_folder, "tmp", participant_id) - #now we find the labelledlesion segmentation file (it was created at the previous step with sct_analyze lesions) and the vertebral levels segmentation file + #now we find the labelled lesion segmentation file (it was created at the previous step with sct_analyze lesions) and the disc levels segmentation file lesion_file_PSIR = os.path.join(output_folder, f"{participant_id}_ses-M0_PSIR_lesion-manual_label.nii.gz") if os.path.exists(lesion_file_PSIR): #if PSIR exists, use PSIR lesion_seg_file = lesion_file_PSIR - vert_levels_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_seg-manual_labeled_discs.nii.gz") + disc_seg_file = os.path.join(discs_path, participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_labels-disc.nii.gz") else: # If PSIR doesn't exist, use STIR lesion_seg_file = os.path.join(output_folder, f"{participant_id}_ses-M0_STIR_lesion-manual_label.nii.gz") - vert_levels_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_seg-manual_labeled_discs.nii.gz") + disc_seg_file = os.path.join(discs_path, participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_labels-disc.nii.gz") - #now we read the lesion segmentation file and the labelled spinal cord segmentation file + #now we read the lesion segmentation file and the disc segmentation file lesion_labelled_seg = nib.load(lesion_seg_file) - vert_levels_seg_file = nib.load(vert_levels_seg_file) + disc_seg_file = nib.load(disc_seg_file) - #we get the data from the lesion segmentation file and the labelled spinal cord segmentation file + #we get the data from the lesion segmentation file and the disc segmentation file lesion_labelled_seg_data = lesion_labelled_seg.get_fdata() - vert_levels_seg_data = vert_levels_seg_file.get_fdata() + disc_seg_data = disc_seg_file.get_fdata() #get voxel size voxel_size = lesion_labelled_seg.header.get_zooms() #the levels are the integer unique values without 0 - levels = np.unique(vert_levels_seg_data) + levels = np.unique(disc_seg_data) levels = levels[levels != 0] #we iterate over the levels for i in range(len(levels)-1): #get upper bound of level - upper_bound = np.where(vert_levels_seg_data == levels[i]) + upper_bound = np.where(disc_seg_data == levels[i]) upper_bound = int(upper_bound[1]) #get lower bound of level - lower_bound = np.where(vert_levels_seg_data == levels[i+1]) + lower_bound = np.where(disc_seg_data == levels[i+1]) lower_bound = int(lower_bound[1]) #initialize the lesion_info_per_levels dictionary @@ -171,7 +179,7 @@ def analyse_lesion_per_levels(patient_data, dataset_path, output_folder): return patient_data -def analyze_patient_lesion(patient_data, dataset_path, output_folder): +def analyze_patient_lesion(patient_data, lesion_path, timepoint, output_folder): """ This function analyzes the lesions of a patient using the sct_analyse_lesions. It gathers information on the number of lesions, their volumes, their lengths and their equivalent diameters. @@ -188,14 +196,14 @@ def analyze_patient_lesion(patient_data, dataset_path, output_folder): participant_id = patient_data["participant_id"] #now we find the lesion segmentation file and the spinal cord segmentation file - lesion_file_PISR = os.path.join(dataset_path,"derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_lesion-manual.nii.gz") + lesion_file_PISR = os.path.join(lesion_path, participant_id, "ses-" + timepoint, "anat", f"{participant_id}_ses-" + timepoint+ "_PSIR_lesion-manual.nii.gz") if os.path.exists(lesion_file_PISR): lesion_seg_file = lesion_file_PISR - sc_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_seg-manual.nii.gz") + sc_seg_file = os.path.join(lesion_path, participant_id, "ses-" + timepoint, "anat", f"{participant_id}_ses-" + timepoint + "_PSIR_seg-manual.nii.gz") else: # If PSIR doesn't exist, use STIR - lesion_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_lesion-manual.nii.gz") - sc_seg_file = os.path.join(dataset_path, "derivatives", "labels", participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_seg-manual.nii.gz") + lesion_seg_file = os.path.join(lesion_path, participant_id, "ses-" + timepoint, "anat", f"{participant_id}_ses-" + timepoint + "_STIR_lesion-manual.nii.gz") + sc_seg_file = os.path.join(lesion_path, participant_id, "ses-" + timepoint, "anat", f"{participant_id}_ses-" + timepoint + "_STIR_seg-manual.nii.gz") #let's use sct to analyze the lesion output_folder = os.path.join(output_folder, "tmp", participant_id) @@ -221,7 +229,7 @@ def analyze_patient_lesion(patient_data, dataset_path, output_folder): return patient_data -def analyze_patient_tsv(participant_id, participants_tsv): +def analyze_patient_tsv(participant_id, participants_tsv, timepoint): """ This function gathers information from the participants.tsv file. It gathers information on each participant, their pathology (and the material used for image acquisition). @@ -238,13 +246,13 @@ def analyze_patient_tsv(participant_id, participants_tsv): #sex patient_data["sex"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["sex"].values[0] #age at M0 - patient_data["age"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["age_M0"].values[0] + patient_data["age"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["age_" + timepoint].values[0] #pathology - patient_data["pathology"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["pathology_M0"].values[0] + patient_data["pathology"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["pathology_" + timepoint].values[0] #phenotype_M0 - patient_data["phenotype"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["phenotype_M0"].values[0] + patient_data["phenotype"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["phenotype_" + timepoint].values[0] #edss_M0 - patient_data["edss"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["edss_M0"].values[0] + patient_data["edss"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["edss_" + timepoint].values[0] #### ------------- THE BELOW INFORMATION IS NOT USED FOR NOW -------------- #### # # #date_of_scan_M0 @@ -282,8 +290,12 @@ def main(): parser = get_parser() args = parser.parse_args() - # Get the path to the CanProCo dataset + # Get the parsed arguments data_path = args.data + lesion_path = args.lesion + discs_path = args.discs + spinal_cord_path = args.spinal_cord + timepoint = args.timepoint # supposed to be written like M0 or M12 #build the output folder output_folder = args.output @@ -302,16 +314,16 @@ def main(): for participant in participants_tsv["participant_id"]: #analyze the patient tsv file - patient_data = analyze_patient_tsv(participant, participants_tsv) + patient_data = analyze_patient_tsv(participant, participants_tsv, timepoint) #analyze the patient lesion - patient_data = analyze_patient_lesion(patient_data, data_path, output_folder) + patient_data = analyze_patient_lesion(patient_data, lesion_path, timepoint, output_folder) #analyze the patient lesion distributions per levels - patient_data = analyse_lesion_per_levels(patient_data, data_path, output_folder) + patient_data = analyse_lesion_per_levels(patient_data, discs_path, output_folder) #analyze the patient spinal cord volume - patient_data = get_spinal_cord_info(patient_data, data_path) + patient_data = get_spinal_cord_info(patient_data, spinal_cord_path, data_path) #add the patient to the dataset dataframe = pd.concat([dataframe, pd.DataFrame([patient_data])], ignore_index=True) From f1477c805337b098e7f09c34c3c2d406c6638923 Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Wed, 25 Oct 2023 01:21:56 -0400 Subject: [PATCH 11/34] fixed timepoint and include file --- dataset_analysis/generate_dataframe.py | 63 ++++++++++++++++++-------- 1 file changed, 45 insertions(+), 18 deletions(-) diff --git a/dataset_analysis/generate_dataframe.py b/dataset_analysis/generate_dataframe.py index c7739e6..6123aea 100644 --- a/dataset_analysis/generate_dataframe.py +++ b/dataset_analysis/generate_dataframe.py @@ -9,6 +9,7 @@ --discs : path to the vertebral levels segmentation file --spinal-cord : path to the spinal cord segmentation file --timepoint : timepoint of the analysis (M0, M12) + --include-file : a .yml file containing the list of participants to include --output : path to the output folder Returns: @@ -31,6 +32,7 @@ import shutil import nibabel as nib import numpy as np +import yaml def get_parser(): @@ -49,12 +51,13 @@ def get_parser(): parser.add_argument('--discs', type=str, help='path to the vertebral levels segmentation file') parser.add_argument('--spinal-cord', type=str, help='path to the spinal cord segmentation file') parser.add_argument('--timepoint', '-t', type=str, help='timepoint of the analysis (M0, M12)') + parser.add_argument('--include-file', '-e', type=str, help='a .yml file containing the list of participants to include') parser.add_argument('--output', '-o', type=str, help='path to the output folder') return parser -def get_spinal_cord_info(patient_data, spinal_cord_path, dataset_path): +def get_spinal_cord_info(patient_data, spinal_cord_path, timepoint): """This functions computes the volume of the spinal cord for each patient. The volume is added to the patient_data dictionary. @@ -70,10 +73,10 @@ def get_spinal_cord_info(patient_data, spinal_cord_path, dataset_path): participant_id = patient_data["participant_id"] #now we find the spinal cord segmentation file - sc_seg_file = os.path.join(spinal_cord_path, participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_seg-manual.nii.gz") + sc_seg_file = os.path.join(spinal_cord_path, participant_id, "ses-" + timepoint, "anat", f"{participant_id}_ses-" + timepoint+ "_PSIR_seg-manual.nii.gz") if not os.path.exists(sc_seg_file): # If PSIR doesn't exist, use STIR - sc_seg_file = os.path.join(spinal_cord_path, participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_seg-manual.nii.gz") + sc_seg_file = os.path.join(spinal_cord_path, participant_id, "ses-" + timepoint, "anat", f"{participant_id}_ses-" + timepoint+ "_STIR_seg-manual.nii.gz") #now we read the spinal cord segmentation file sc_seg = nib.load(sc_seg_file) @@ -89,7 +92,7 @@ def get_spinal_cord_info(patient_data, spinal_cord_path, dataset_path): return patient_data -def analyse_lesion_per_levels(patient_data, discs_path, output_folder): +def analyse_lesion_per_levels(patient_data, discs_path, timepoint, output_folder): """ This function focuses on lesions per spinal cord levels. It computes the number, volume and average length of lesions per spinal cord level. @@ -108,18 +111,23 @@ def analyse_lesion_per_levels(patient_data, discs_path, output_folder): output_folder = os.path.join(output_folder, "tmp", participant_id) #now we find the labelled lesion segmentation file (it was created at the previous step with sct_analyze lesions) and the disc levels segmentation file - lesion_file_PSIR = os.path.join(output_folder, f"{participant_id}_ses-M0_PSIR_lesion-manual_label.nii.gz") + lesion_file_PSIR = os.path.join(output_folder, f"{participant_id}_ses-" + timepoint+ "_PSIR_lesion-manual_label.nii.gz") if os.path.exists(lesion_file_PSIR): #if PSIR exists, use PSIR lesion_seg_file = lesion_file_PSIR - disc_seg_file = os.path.join(discs_path, participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_PSIR_labels-disc.nii.gz") + disc_seg_file = os.path.join(discs_path, participant_id, "ses-" + timepoint, "anat", f"{participant_id}_ses-" + timepoint+ "_PSIR_labels-disc.nii.gz") else: # If PSIR doesn't exist, use STIR - lesion_seg_file = os.path.join(output_folder, f"{participant_id}_ses-M0_STIR_lesion-manual_label.nii.gz") - disc_seg_file = os.path.join(discs_path, participant_id, "ses-M0", "anat", f"{participant_id}_ses-M0_STIR_labels-disc.nii.gz") + lesion_seg_file = os.path.join(output_folder, f"{participant_id}_ses-" + timepoint+ "_STIR_lesion-manual_label.nii.gz") + disc_seg_file = os.path.join(discs_path, participant_id, "ses-" + timepoint, "anat", f"{participant_id}_ses-" + timepoint+ "_STIR_labels-disc.nii.gz") #now we read the lesion segmentation file and the disc segmentation file lesion_labelled_seg = nib.load(lesion_seg_file) + + #we check if the lesion segmentation file is empty + if np.sum(lesion_labelled_seg.get_fdata()) == 0: + return patient_data + disc_seg_file = nib.load(disc_seg_file) #we get the data from the lesion segmentation file and the disc segmentation file @@ -165,7 +173,9 @@ def analyse_lesion_per_levels(patient_data, discs_path, output_folder): total_lesion_volume_in_level += volume_of_lesion avg_lesion_length_in_level += length_of_lesion - #compute the average vertical length + #compute the average vertical length and volume + avg_lesion_length_in_level = 0 + avg_lesion_volume_in_level = 0 if nb_lesions_in_level != 0: avg_lesion_length_in_level = avg_lesion_length_in_level/nb_lesions_in_level avg_lesion_volume_in_level = total_lesion_volume_in_level/nb_lesions_in_level @@ -213,6 +223,12 @@ def analyze_patient_lesion(patient_data, lesion_path, timepoint, output_folder): output_file = str(lesion_seg_file).split('/')[-1].replace('.nii.gz', '_analysis.xls') output_file = os.path.join(output_folder, output_file) data = pd.read_excel(output_file) + + #we check if the data is empty + if data.empty: + #if it is empty we return the patient_data dictionary + return patient_data + number_of_lesions = max(data['label']) total_lesion_volume = sum(data['volume [mm3]']) biggest_lesion_vol = max(data['volume [mm3]']) @@ -248,11 +264,11 @@ def analyze_patient_tsv(participant_id, participants_tsv, timepoint): #age at M0 patient_data["age"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["age_" + timepoint].values[0] #pathology - patient_data["pathology"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["pathology_" + timepoint].values[0] + patient_data["pathology"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["pathology_M0"].values[0] #phenotype_M0 - patient_data["phenotype"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["phenotype_" + timepoint].values[0] + patient_data["phenotype"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["phenotype_M0"].values[0] #edss_M0 - patient_data["edss"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["edss_" + timepoint].values[0] + patient_data["edss"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["edss_M0"].values[0] #### ------------- THE BELOW INFORMATION IS NOT USED FOR NOW -------------- #### # # #date_of_scan_M0 @@ -271,7 +287,6 @@ def analyze_patient_tsv(participant_id, participants_tsv, timepoint): # patient_data["software_versions"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["software_versions_M0"].values[0] #### ------------- ------------------------------------------ -------------- #### - return patient_data @@ -297,6 +312,13 @@ def main(): spinal_cord_path = args.spinal_cord timepoint = args.timepoint # supposed to be written like M0 or M12 + #exclude some participants (list is like this [sub-mon118, sub-mon006]) + include_list = [] + if args.include_file is not None: + with open(args.include_file, 'r') as file: + include_list = yaml.load(file, Loader=yaml.FullLoader) + + #build the output folder output_folder = args.output if not os.path.isdir(output_folder): @@ -313,6 +335,10 @@ def main(): #iterate over participant_id for participant in participants_tsv["participant_id"]: + # We skip the participant if it is in the exclude list + if participant not in include_list: + continue + #analyze the patient tsv file patient_data = analyze_patient_tsv(participant, participants_tsv, timepoint) @@ -320,19 +346,20 @@ def main(): patient_data = analyze_patient_lesion(patient_data, lesion_path, timepoint, output_folder) #analyze the patient lesion distributions per levels - patient_data = analyse_lesion_per_levels(patient_data, discs_path, output_folder) + patient_data = analyse_lesion_per_levels(patient_data, discs_path, timepoint, output_folder) #analyze the patient spinal cord volume - patient_data = get_spinal_cord_info(patient_data, spinal_cord_path, data_path) + patient_data = get_spinal_cord_info(patient_data, spinal_cord_path, timepoint) #add the patient to the dataset dataframe = pd.concat([dataframe, pd.DataFrame([patient_data])], ignore_index=True) - - print(dataframe) + + print(dataframe) + for col in dataframe.columns: + print(dataframe[col]) #save the dataset in the output folder dataframe.to_csv(os.path.join(output_folder, 'dataframe.csv'), index=False) - if __name__ == '__main__': main() \ No newline at end of file From b39d8bb9d14f61f376528fe8a2d17596bf0d708b Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Wed, 25 Oct 2023 12:21:28 -0400 Subject: [PATCH 12/34] fixed lesion analysis per level with lesions above 1 and after last level --- dataset_analysis/generate_dataframe.py | 117 +++++++++++++++++++++---- 1 file changed, 102 insertions(+), 15 deletions(-) diff --git a/dataset_analysis/generate_dataframe.py b/dataset_analysis/generate_dataframe.py index 6123aea..58fe8bc 100644 --- a/dataset_analysis/generate_dataframe.py +++ b/dataset_analysis/generate_dataframe.py @@ -9,7 +9,7 @@ --discs : path to the vertebral levels segmentation file --spinal-cord : path to the spinal cord segmentation file --timepoint : timepoint of the analysis (M0, M12) - --include-file : a .yml file containing the list of participants to include + --exclude-file : a .yml file containing the list of participants to exclude --output : path to the output folder Returns: @@ -19,7 +19,7 @@ python generate_dataframe.py --data /path/to/CanProCo --output /path/to/output Todo: - * + * UPDATE documentation of this file Pierre-Louis Benveniste """ @@ -51,7 +51,7 @@ def get_parser(): parser.add_argument('--discs', type=str, help='path to the vertebral levels segmentation file') parser.add_argument('--spinal-cord', type=str, help='path to the spinal cord segmentation file') parser.add_argument('--timepoint', '-t', type=str, help='timepoint of the analysis (M0, M12)') - parser.add_argument('--include-file', '-e', type=str, help='a .yml file containing the list of participants to include') + parser.add_argument('--exclude-file', '-e', type=str, help='a .yml file containing the list of participants to exclude') parser.add_argument('--output', '-o', type=str, help='path to the output folder') return parser @@ -153,7 +153,7 @@ def analyse_lesion_per_levels(patient_data, discs_path, timepoint, output_folder #initialize the lesion_info_per_levels dictionary nb_lesions_in_level = 0 total_lesion_volume_in_level = 0 - avg_lesion_length_in_level = 0 + lesion_length_in_level = 0 #now we look for the lesions in this level ## get the lesions @@ -171,13 +171,13 @@ def analyse_lesion_per_levels(patient_data, discs_path, timepoint, output_folder if center_of_lesion[1] <= upper_bound and center_of_lesion[1] >= lower_bound: nb_lesions_in_level += 1 total_lesion_volume_in_level += volume_of_lesion - avg_lesion_length_in_level += length_of_lesion + lesion_length_in_level += length_of_lesion #compute the average vertical length and volume avg_lesion_length_in_level = 0 avg_lesion_volume_in_level = 0 if nb_lesions_in_level != 0: - avg_lesion_length_in_level = avg_lesion_length_in_level/nb_lesions_in_level + avg_lesion_length_in_level = lesion_length_in_level/nb_lesions_in_level avg_lesion_volume_in_level = total_lesion_volume_in_level/nb_lesions_in_level #we add this information to the patient_data dictionary @@ -186,6 +186,91 @@ def analyse_lesion_per_levels(patient_data, discs_path, timepoint, output_folder patient_data[f"avg_lesion_volume_between_{int(levels[i]):02d}_and_{int(levels[i+1]):02d}"] = avg_lesion_volume_in_level patient_data[f"avg_lesion_length_between_{int(levels[i]):02d}_and_{int(levels[i+1]):02d}"] = avg_lesion_length_in_level + #we add the lesions which are above the 1st level + if int(levels[i]) == 1: + #we only have a lower bound + lower_bound = np.where(disc_seg_data == levels[i]) + lower_bound = int(lower_bound[1]) + + #initialize the lesion_info_per_levels dictionary + nb_lesions_above_1 = 0 + total_lesion_volume_above_1 = 0 + lesion_length_above_1 = 0 + + #now we look for the lesions in this level + ## get the lesions + lesions = np.unique(lesion_labelled_seg_data) + lesions = lesions[lesions != 0] + ## iterate over the lesions + for lesion in lesions: + lesion_voxel = np.where(lesion_labelled_seg_data == lesion) + center_of_lesion = np.mean(lesion_voxel, axis=1) + volume_of_lesion = len(lesion_voxel[0])*voxel_size[0]*voxel_size[1]*voxel_size[2] + top_of_lesion = np.max(lesion_voxel[2]) + bottom_of_lesion = np.min(lesion_voxel[2]) + length_of_lesion = (top_of_lesion - bottom_of_lesion)*voxel_size[2] + #if lesion center is between upper and lower bound, then it is in the level + if center_of_lesion[1] >= lower_bound: + nb_lesions_above_1 += 1 + total_lesion_volume_above_1 += volume_of_lesion + lesion_length_above_1 += length_of_lesion + + #compute the average vertical length and volume + avg_lesion_length_above_1 = 0 + avg_lesion_volume_above_1 = 0 + if nb_lesions_above_1 != 0: + avg_lesion_length_above_1 = lesion_length_above_1/nb_lesions_above_1 + avg_lesion_volume_above_1 = total_lesion_volume_above_1/nb_lesions_above_1 + + # add info to dictionary + patient_data[f"nb_lesions_above_01"] = nb_lesions_above_1 + patient_data[f"total_lesion_volume_above_01"] = total_lesion_volume_above_1 + patient_data[f"avg_lesion_volume_above_01"] = avg_lesion_volume_above_1 + patient_data[f"avg_lesion_length_above_01"] = avg_lesion_length_above_1 + + # we now add the lesions which are below the last level (we consider that their between the last level and last level + 1) + i=len(levels)-1 + level = levels[i] + # we only have an upper bound + upper_bound = np.where(disc_seg_data == level) + upper_bound = int(upper_bound[1]) + + #initialize the lesion_info_per_levels dictionary + nb_lesions_after_last = 0 + total_lesion_volume_after_last = 0 + lesion_length_after_last = 0 + + #now we look for the lesions in this level + ## get the lesions + lesions = np.unique(lesion_labelled_seg_data) + lesions = lesions[lesions != 0] + ## iterate over the lesions + for lesion in lesions: + lesion_voxel = np.where(lesion_labelled_seg_data == lesion) + center_of_lesion = np.mean(lesion_voxel, axis=1) + volume_of_lesion = len(lesion_voxel[0])*voxel_size[0]*voxel_size[1]*voxel_size[2] + top_of_lesion = np.max(lesion_voxel[2]) + bottom_of_lesion = np.min(lesion_voxel[2]) + length_of_lesion = (top_of_lesion - bottom_of_lesion)*voxel_size[2] + #if lesion center is between upper and lower bound, then it is in the level + if center_of_lesion[1] <= upper_bound: + nb_lesions_after_last += 1 + total_lesion_volume_after_last += volume_of_lesion + lesion_length_after_last += length_of_lesion + + #compute the average vertical length and volume + avg_lesion_length_after_last = 0 + avg_lesion_volume_after_last = 0 + if nb_lesions_after_last != 0: + avg_lesion_length_after_last = lesion_length_after_last/nb_lesions_after_last + avg_lesion_volume_after_last = total_lesion_volume_after_last/nb_lesions_after_last + + # add info to dictionary + patient_data[f"nb_lesions_between_{int(levels[i]):02d}_and_{int(levels[i])+1:02d}"] = nb_lesions_after_last + patient_data[f"total_lesion_between_{int(levels[i]):02d}_and_{int(levels[i])+1:02d}"] = total_lesion_volume_after_last + patient_data[f"avg_lesion_between_{int(levels[i]):02d}_and_{int(levels[i])+1:02d}"] = avg_lesion_volume_after_last + patient_data[f"avg_lesion_between_{int(levels[i]):02d}_and_{int(levels[i])+1:02d}"] = avg_lesion_length_after_last + return patient_data @@ -259,6 +344,8 @@ def analyze_patient_tsv(participant_id, participants_tsv, timepoint): """ patient_data = {} patient_data["participant_id"] = participant_id + #site + patient_data["site"] = participant_id.split('-')[1][:3] #sex patient_data["sex"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["sex"].values[0] #age at M0 @@ -313,11 +400,11 @@ def main(): timepoint = args.timepoint # supposed to be written like M0 or M12 #exclude some participants (list is like this [sub-mon118, sub-mon006]) - include_list = [] - if args.include_file is not None: - with open(args.include_file, 'r') as file: - include_list = yaml.load(file, Loader=yaml.FullLoader) - + exclude_list = [] + with open(args.exclude_file, 'r') as file: + exclude_list = yaml.load(file, Loader=yaml.FullLoader) + #only keep the participant_id + exclude_list = [participant.split('_')[0] for participant in exclude_list] #build the output folder output_folder = args.output @@ -336,7 +423,8 @@ def main(): for participant in participants_tsv["participant_id"]: # We skip the participant if it is in the exclude list - if participant not in include_list: + if participant in exclude_list: + print(f"Skipping {participant} because it is in the exclude list") continue #analyze the patient tsv file @@ -354,11 +442,10 @@ def main(): #add the patient to the dataset dataframe = pd.concat([dataframe, pd.DataFrame([patient_data])], ignore_index=True) - print(dataframe) - for col in dataframe.columns: - print(dataframe[col]) #save the dataset in the output folder dataframe.to_csv(os.path.join(output_folder, 'dataframe.csv'), index=False) + print("Dataframe saved in " + os.path.join(output_folder, 'dataframe.csv')) + return None if __name__ == '__main__': From dbfb80e29c8f4e6ad2a85b24653c3f9ad8967560 Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Wed, 25 Oct 2023 19:49:48 -0400 Subject: [PATCH 13/34] added ivadomed utilities script for image processing --- dataset_analysis/image.py | 685 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 685 insertions(+) create mode 100644 dataset_analysis/image.py diff --git a/dataset_analysis/image.py b/dataset_analysis/image.py new file mode 100644 index 0000000..03e670c --- /dev/null +++ b/dataset_analysis/image.py @@ -0,0 +1,685 @@ +import os +import numpy as np +import nibabel as nib +import logging +from copy import deepcopy + +logger = logging.getLogger(__name__) + +class Image(object): + """ + Compact version of SCT's Image Class (https://github.com/spinalcordtoolbox/spinalcordtoolbox/blob/master/spinalcordtoolbox/image.py#L245) + Create an object that behaves similarly to nibabel's image object. Useful additions include: dims, change_orientation and getNonZeroCoordinates. + """ + + def __init__(self, param=None, hdr=None, orientation=None, absolutepath=None, dim=None): + """ + :param param: string indicating a path to a image file or an `Image` object. + """ + + # initialization of all parameters + self.affine = None + self.data = None + self._path = None + self.ext = "" + + if absolutepath is not None: + self._path = os.path.abspath(absolutepath) + + # Case 1: load an image from file + if isinstance(param, str): + self.loadFromPath(param) + # Case 2: create a copy of an existing `Image` object + elif isinstance(param, type(self)): + self.copy(param) + # Case 3: create a blank image from a list of dimensions + elif isinstance(param, list): + self.data = np.zeros(param) + self.hdr = hdr.copy() if hdr is not None else nib.Nifti1Header() + self.hdr.set_data_shape(self.data.shape) + # Case 4: create an image from an existing data array + elif isinstance(param, (np.ndarray, np.generic)): + self.data = param + self.hdr = hdr.copy() if hdr is not None else nib.Nifti1Header() + self.hdr.set_data_shape(self.data.shape) + else: + raise TypeError('Image constructor takes at least one argument.') + + # Fix any mismatch between the array's datatype and the header datatype + self.fix_header_dtype() + + @property + def dim(self): + return get_dimension(self) + + @property + def orientation(self): + return get_orientation(self) + + @property + def absolutepath(self): + """ + Storage path (either actual or potential) + + Notes: + + - As several tools perform chdir() it's very important to have absolute paths + - When set, if relative: + + - If it already existed, it becomes a new basename in the old dirname + - Else, it becomes absolute (shortcut) + + Usually not directly touched (use `Image.save`), but in some cases it's + the best way to set it. + """ + return self._path + + @absolutepath.setter + def absolutepath(self, value): + if value is None: + self._path = None + return + elif not os.path.isabs(value) and self._path is not None: + value = os.path.join(os.path.dirname(self._path), value) + elif not os.path.isabs(value): + value = os.path.abspath(value) + self._path = value + + @property + def header(self): + return self.hdr + + @header.setter + def header(self, value): + self.hdr = value + + def __deepcopy__(self, memo): + return type(self)(deepcopy(self.data, memo), deepcopy(self.hdr, memo), deepcopy(self.orientation, memo), deepcopy(self.absolutepath, memo), deepcopy(self.dim, memo)) + + def copy(self, image=None): + if image is not None: + self.affine = deepcopy(image.affine) + self.data = deepcopy(image.data) + self.hdr = deepcopy(image.hdr) + self._path = deepcopy(image._path) + else: + return deepcopy(self) + + def loadFromPath(self, path): + """ + This function load an image from an absolute path using nibabel library + + :param path: path of the file from which the image will be loaded + :return: + """ + + self.absolutepath = os.path.abspath(path) + im_file = nib.load(self.absolutepath, mmap=True) + self.affine = im_file.affine.copy() + self.data = np.asanyarray(im_file.dataobj) + self.hdr = im_file.header.copy() + if path != self.absolutepath: + logger.debug("Loaded %s (%s) orientation %s shape %s", path, self.absolutepath, self.orientation, self.data.shape) + else: + logger.debug("Loaded %s orientation %s shape %s", path, self.orientation, self.data.shape) + + def change_orientation(self, orientation, inverse=False): + """ + Change orientation on image (in-place). + + :param orientation: orientation string (SCT "from" convention) + + :param inverse: if you think backwards, use this to specify that you actually\ + want to transform *from* the specified orientation, not *to*\ + it. + + """ + change_orientation(self, orientation, self, inverse=inverse) + return self + + def getNonZeroCoordinates(self, sorting=None, reverse_coord=False): + """ + This function return all the non-zero coordinates that the image contains. + Coordinate list can also be sorted by x, y, z, or the value with the parameter sorting='x', sorting='y', sorting='z' or sorting='value' + If reverse_coord is True, coordinate are sorted from larger to smaller. + + Removed Coordinate object + """ + n_dim = 1 + if self.dim[3] == 1: + n_dim = 3 + else: + n_dim = 4 + if self.dim[2] == 1: + n_dim = 2 + + if n_dim == 3: + X, Y, Z = (self.data > 0).nonzero() + list_coordinates = [[X[i], Y[i], Z[i], self.data[X[i], Y[i], Z[i]]] for i in range(0, len(X))] + elif n_dim == 2: + try: + X, Y = (self.data > 0).nonzero() + list_coordinates = [[X[i], Y[i], 0, self.data[X[i], Y[i]]] for i in range(0, len(X))] + except ValueError: + X, Y, Z = (self.data > 0).nonzero() + list_coordinates = [[X[i], Y[i], 0, self.data[X[i], Y[i], 0]] for i in range(0, len(X))] + + if sorting is not None: + if reverse_coord not in [True, False]: + raise ValueError('reverse_coord parameter must be a boolean') + + if sorting == 'x': + list_coordinates = sorted(list_coordinates, key=lambda el: el[0], reverse=reverse_coord) + elif sorting == 'y': + list_coordinates = sorted(list_coordinates, key=lambda el: el[1], reverse=reverse_coord) + elif sorting == 'z': + list_coordinates = sorted(list_coordinates, key=lambda el: el[2], reverse=reverse_coord) + elif sorting == 'value': + list_coordinates = sorted(list_coordinates, key=lambda el: el[3], reverse=reverse_coord) + else: + raise ValueError("sorting parameter must be either 'x', 'y', 'z' or 'value'") + + return list_coordinates + + def change_type(self, dtype): + """ + Change data type on image. + + Note: the image path is voided. + """ + change_type(self, dtype, self) + return self + + def fix_header_dtype(self): + """ + Change the header dtype to the match the datatype of the array. + """ + # Using bool for nibabel headers is unsupported, so use uint8 instead: + # `nibabel.spatialimages.HeaderDataError: data dtype "bool" not supported` + dtype_data = self.data.dtype + if dtype_data == bool: + dtype_data = np.uint8 + + dtype_header = self.hdr.get_data_dtype() + if dtype_header != dtype_data: + logger.warning(f"Image header specifies datatype '{dtype_header}', but array is of type " + f"'{dtype_data}'. Header metadata will be overwritten to use '{dtype_data}'.") + self.hdr.set_data_dtype(dtype_data) + + def save(self, path=None, dtype=None, verbose=1, mutable=False): + """ + Write an image in a nifti file + + :param path: Where to save the data, if None it will be taken from the\ + absolutepath member.\ + If path is a directory, will save to a file under this directory\ + with the basename from the absolutepath member. + + :param dtype: if not set, the image is saved in the same type as input data\ + if 'minimize', image storage space is minimized\ + (2, 'uint8', np.uint8, "NIFTI_TYPE_UINT8"),\ + (4, 'int16', np.int16, "NIFTI_TYPE_INT16"),\ + (8, 'int32', np.int32, "NIFTI_TYPE_INT32"),\ + (16, 'float32', np.float32, "NIFTI_TYPE_FLOAT32"),\ + (32, 'complex64', np.complex64, "NIFTI_TYPE_COMPLEX64"),\ + (64, 'float64', np.float64, "NIFTI_TYPE_FLOAT64"),\ + (256, 'int8', np.int8, "NIFTI_TYPE_INT8"),\ + (512, 'uint16', np.uint16, "NIFTI_TYPE_UINT16"),\ + (768, 'uint32', np.uint32, "NIFTI_TYPE_UINT32"),\ + (1024,'int64', np.int64, "NIFTI_TYPE_INT64"),\ + (1280, 'uint64', np.uint64, "NIFTI_TYPE_UINT64"),\ + (1536, 'float128', _float128t, "NIFTI_TYPE_FLOAT128"),\ + (1792, 'complex128', np.complex128, "NIFTI_TYPE_COMPLEX128"),\ + (2048, 'complex256', _complex256t, "NIFTI_TYPE_COMPLEX256"), + + :param mutable: whether to update members with newly created path or dtype + """ + if mutable: # do all modifications in-place + # Case 1: `path` not specified + if path is None: + if self.absolutepath: # Fallback to the original filepath + path = self.absolutepath + else: + raise ValueError("Don't know where to save the image (no absolutepath or path parameter)") + # Case 2: `path` points to an existing directory + elif os.path.isdir(path): + if self.absolutepath: # Use the original filename, but save to the directory specified by `path` + path = os.path.join(os.path.abspath(path), os.path.basename(self.absolutepath)) + else: + raise ValueError("Don't know where to save the image (path parameter is dir, but absolutepath is " + "missing)") + # Case 3: `path` points to a file (or a *nonexistent* directory) so use its value as-is + # (We're okay with letting nonexistent directories slip through, because it's difficult to distinguish + # between nonexistent directories and nonexistent files. Plus, `nibabel` will catch any further errors.) + else: + pass + + if os.path.isfile(path) and verbose: + logger.warning("File %s already exists. Will overwrite it.", path) + if os.path.isabs(path): + logger.debug("Saving image to %s orientation %s shape %s", + path, self.orientation, self.data.shape) + else: + logger.debug("Saving image to %s (%s) orientation %s shape %s", + path, os.path.abspath(path), self.orientation, self.data.shape) + + # Now that `path` has been set and log messages have been written, we can assign it to the image itself + self.absolutepath = os.path.abspath(path) + + if dtype is not None: + self.change_type(dtype) + + if self.hdr is not None: + self.hdr.set_data_shape(self.data.shape) + self.fix_header_dtype() + + # nb. that copy() is important because if it were a memory map, save() would corrupt it + dataobj = self.data.copy() + affine = None + header = self.hdr.copy() if self.hdr is not None else None + nib.save(nib.nifti1.Nifti1Image(dataobj, affine, header), self.absolutepath) + if not os.path.isfile(self.absolutepath): + raise RuntimeError(f"Couldn't save image to {self.absolutepath}") + else: + # if we're not operating in-place, then make any required modifications on a throw-away copy + self.copy().save(path, dtype, verbose, mutable=True) + return self + + +class SlicerOneAxis(object): + """ + Image slicer to use when you don't care about the 2D slice orientation, + and don't want to specify them. + The slicer will just iterate through the right axis that corresponds to + its specification. + + Can help getting ranges and slice indices. + + Copied from https://github.com/spinalcordtoolbox/spinalcordtoolbox/image.py + """ + + def __init__(self, im, axis="IS"): + opposite_character = {'L': 'R', 'R': 'L', 'A': 'P', 'P': 'A', 'I': 'S', 'S': 'I'} + axis_labels = "LRPAIS" + if len(axis) != 2: + raise ValueError() + if axis[0] not in axis_labels: + raise ValueError() + if axis[1] not in axis_labels: + raise ValueError() + if axis[0] != opposite_character[axis[1]]: + raise ValueError() + + for idx_axis in range(2): + dim_nr = im.orientation.find(axis[idx_axis]) + if dim_nr != -1: + break + if dim_nr == -1: + raise ValueError() + + # SCT convention + from_dir = im.orientation[dim_nr] + self.direction = +1 if axis[0] == from_dir else -1 + self.nb_slices = im.dim[dim_nr] + self.im = im + self.axis = axis + self._slice = lambda idx: tuple([(idx if x in axis else slice(None)) for x in im.orientation]) + + def __len__(self): + return self.nb_slices + + def __getitem__(self, idx): + """ + + :return: an image slice, at slicing index idx + :param idx: slicing index (according to the slicing direction) + """ + if isinstance(idx, slice): + raise NotImplementedError() + + if idx >= self.nb_slices: + raise IndexError("I just have {} slices!".format(self.nb_slices)) + + if self.direction == -1: + idx = self.nb_slices - 1 - idx + + return self.im.data[self._slice(idx)] + +def get_dimension(im_file, verbose=1): + """ + Copied from https://github.com/spinalcordtoolbox/spinalcordtoolbox/ + + Get dimension from Image or nibabel object. Manages 2D, 3D or 4D images. + + :param: im_file: Image or nibabel object + :return: nx, ny, nz, nt, px, py, pz, pt + """ + if not isinstance(im_file, (nib.nifti1.Nifti1Image, Image)): + raise TypeError("The provided image file is neither a nibabel.nifti1.Nifti1Image instance nor an Image instance") + # initializating ndims [nx, ny, nz, nt] and pdims [px, py, pz, pt] + ndims = [1, 1, 1, 1] + pdims = [1, 1, 1, 1] + data_shape = im_file.header.get_data_shape() + zooms = im_file.header.get_zooms() + for i in range(min(len(data_shape), 4)): + ndims[i] = data_shape[i] + pdims[i] = zooms[i] + return *ndims, *pdims + + +def change_orientation(im_src, orientation, im_dst=None, inverse=False): + """ + Copied from https://github.com/spinalcordtoolbox/spinalcordtoolbox/ + + :param im_src: source image + :param orientation: orientation string (SCT "from" convention) + :param im_dst: destination image (can be the source image for in-place + operation, can be unset to generate one) + :param inverse: if you think backwards, use this to specify that you actually + want to transform *from* the specified orientation, not *to* it. + :return: an image with changed orientation + + .. note:: + - the resulting image has no path member set + - if the source image is < 3D, it is reshaped to 3D and the destination is 3D + """ + + if len(im_src.data.shape) < 3: + pass # Will reshape to 3D + elif len(im_src.data.shape) == 3: + pass # OK, standard 3D volume + elif len(im_src.data.shape) == 4: + pass # OK, standard 4D volume + elif len(im_src.data.shape) == 5 and im_src.header.get_intent()[0] == "vector": + pass # OK, physical displacement field + else: + raise NotImplementedError("Don't know how to change orientation for this image") + + im_src_orientation = im_src.orientation + im_dst_orientation = orientation + if inverse: + im_src_orientation, im_dst_orientation = im_dst_orientation, im_src_orientation + + perm, inversion = _get_permutations(im_src_orientation, im_dst_orientation) + + if im_dst is None: + im_dst = im_src.copy() + im_dst._path = None + + im_src_data = im_src.data + if len(im_src_data.shape) < 3: + im_src_data = im_src_data.reshape(tuple(list(im_src_data.shape) + ([1] * (3 - len(im_src_data.shape))))) + + # Update data by performing inversions and swaps + + # axes inversion (flip) + data = im_src_data[::inversion[0], ::inversion[1], ::inversion[2]] + + # axes manipulations (transpose) + if perm == [1, 0, 2]: + data = np.swapaxes(data, 0, 1) + elif perm == [2, 1, 0]: + data = np.swapaxes(data, 0, 2) + elif perm == [0, 2, 1]: + data = np.swapaxes(data, 1, 2) + elif perm == [2, 0, 1]: + data = np.swapaxes(data, 0, 2) # transform [2, 0, 1] to [1, 0, 2] + data = np.swapaxes(data, 0, 1) # transform [1, 0, 2] to [0, 1, 2] + elif perm == [1, 2, 0]: + data = np.swapaxes(data, 0, 2) # transform [1, 2, 0] to [0, 2, 1] + data = np.swapaxes(data, 1, 2) # transform [0, 2, 1] to [0, 1, 2] + elif perm == [0, 1, 2]: + # do nothing + pass + else: + raise NotImplementedError() + + # Update header + + im_src_aff = im_src.hdr.get_best_affine() + aff = nib.orientations.inv_ornt_aff( + np.array((perm, inversion)).T, + im_src_data.shape) + im_dst_aff = np.matmul(im_src_aff, aff) + + im_dst.header.set_qform(im_dst_aff) + im_dst.header.set_sform(im_dst_aff) + im_dst.header.set_data_shape(data.shape) + im_dst.data = data + + return im_dst + + +def _get_permutations(im_src_orientation, im_dst_orientation): + """ + Copied from https://github.com/spinalcordtoolbox/spinalcordtoolbox/ + + :param im_src_orientation str: Orientation of source image. Example: 'RPI' + :param im_dest_orientation str: Orientation of destination image. Example: 'SAL' + :return: list of axes permutations and list of inversions to achieve an orientation change + """ + + opposite_character = {'L': 'R', 'R': 'L', 'A': 'P', 'P': 'A', 'I': 'S', 'S': 'I'} + + perm = [0, 1, 2] + inversion = [1, 1, 1] + for i, character in enumerate(im_src_orientation): + try: + perm[i] = im_dst_orientation.index(character) + except ValueError: + perm[i] = im_dst_orientation.index(opposite_character[character]) + inversion[i] = -1 + + return perm, inversion + + +def get_orientation(im): + """ + Copied from https://github.com/spinalcordtoolbox/spinalcordtoolbox/ + + :param im: an Image + :return: reference space string (ie. what's in Image.orientation) + """ + res = "".join(nib.orientations.aff2axcodes(im.hdr.get_best_affine())) + return orientation_string_nib2sct(res) + + +def orientation_string_nib2sct(s): + """ + Copied from https://github.com/spinalcordtoolbox/spinalcordtoolbox/ + + :return: SCT reference space code from nibabel one + """ + opposite_character = {'L': 'R', 'R': 'L', 'A': 'P', 'P': 'A', 'I': 'S', 'S': 'I'} + return "".join([opposite_character[x] for x in s]) + + +def change_type(im_src, dtype, im_dst=None): + """ + Change the voxel type of the image + + :param dtype: if not set, the image is saved in standard type\ + if 'minimize', image space is minimize\ + if 'minimize_int', image space is minimize and values are approximated to integers\ + (2, 'uint8', np.uint8, "NIFTI_TYPE_UINT8"),\ + (4, 'int16', np.int16, "NIFTI_TYPE_INT16"),\ + (8, 'int32', np.int32, "NIFTI_TYPE_INT32"),\ + (16, 'float32', np.float32, "NIFTI_TYPE_FLOAT32"),\ + (32, 'complex64', np.complex64, "NIFTI_TYPE_COMPLEX64"),\ + (64, 'float64', np.float64, "NIFTI_TYPE_FLOAT64"),\ + (256, 'int8', np.int8, "NIFTI_TYPE_INT8"),\ + (512, 'uint16', np.uint16, "NIFTI_TYPE_UINT16"),\ + (768, 'uint32', np.uint32, "NIFTI_TYPE_UINT32"),\ + (1024,'int64', np.int64, "NIFTI_TYPE_INT64"),\ + (1280, 'uint64', np.uint64, "NIFTI_TYPE_UINT64"),\ + (1536, 'float128', _float128t, "NIFTI_TYPE_FLOAT128"),\ + (1792, 'complex128', np.complex128, "NIFTI_TYPE_COMPLEX128"),\ + (2048, 'complex256', _complex256t, "NIFTI_TYPE_COMPLEX256"), + :return: + + Copied from https://github.com/spinalcordtoolbox/spinalcordtoolbox/ + """ + + if im_dst is None: + im_dst = im_src.copy() + im_dst._path = None + + if dtype is None: + return im_dst + + # get min/max from input image + min_in = np.nanmin(im_src.data) + max_in = np.nanmax(im_src.data) + + # find optimum type for the input image + if dtype in ('minimize', 'minimize_int'): + # warning: does not take intensity resolution into account, neither complex voxels + + # check if voxel values are real or integer + isInteger = True + if dtype == 'minimize': + for vox in im_src.data.flatten(): + if int(vox) != vox: + isInteger = False + break + + if isInteger: + if min_in >= 0: # unsigned + if max_in <= np.iinfo(np.uint8).max: + dtype = np.uint8 + elif max_in <= np.iinfo(np.uint16): + dtype = np.uint16 + elif max_in <= np.iinfo(np.uint32).max: + dtype = np.uint32 + elif max_in <= np.iinfo(np.uint64).max: + dtype = np.uint64 + else: + raise ValueError("Maximum value of the image is to big to be represented.") + else: + if max_in <= np.iinfo(np.int8).max and min_in >= np.iinfo(np.int8).min: + dtype = np.int8 + elif max_in <= np.iinfo(np.int16).max and min_in >= np.iinfo(np.int16).min: + dtype = np.int16 + elif max_in <= np.iinfo(np.int32).max and min_in >= np.iinfo(np.int32).min: + dtype = np.int32 + elif max_in <= np.iinfo(np.int64).max and min_in >= np.iinfo(np.int64).min: + dtype = np.int64 + else: + raise ValueError("Maximum value of the image is to big to be represented.") + else: + # if max_in <= np.finfo(np.float16).max and min_in >= np.finfo(np.float16).min: + # type = 'np.float16' # not supported by nibabel + if max_in <= np.finfo(np.float32).max and min_in >= np.finfo(np.float32).min: + dtype = np.float32 + elif max_in <= np.finfo(np.float64).max and min_in >= np.finfo(np.float64).min: + dtype = np.float64 + + dtype = to_dtype(dtype) + else: + dtype = to_dtype(dtype) + + # if output type is int, check if it needs intensity rescaling + if "int" in dtype.name: + # get min/max from output type + min_out = np.iinfo(dtype).min + max_out = np.iinfo(dtype).max + # before rescaling, check if there would be an intensity overflow + + if (min_in < min_out) or (max_in > max_out): + # This condition is important for binary images since we do not want to scale them + logger.warning(f"To avoid intensity overflow due to convertion to +{dtype.name}+, intensity will be rescaled to the maximum quantization scale") + # rescale intensity + data_rescaled = im_src.data * (max_out - min_out) / (max_in - min_in) + im_dst.data = data_rescaled - (data_rescaled.min() - min_out) + + # change type of data in both numpy array and nifti header + im_dst.data = getattr(np, dtype.name)(im_dst.data) + im_dst.hdr.set_data_dtype(dtype) + return im_dst + + +def to_dtype(dtype): + """ + Take a dtypeification and return an np.dtype + + :param dtype: dtypeification (string or np.dtype or None are supported for now) + :return: dtype or None + + Copied from https://github.com/spinalcordtoolbox/spinalcordtoolbox/ + """ + # TODO add more or filter on things supported by nibabel + + if dtype is None: + return None + if isinstance(dtype, type): + if isinstance(dtype(0).dtype, np.dtype): + return dtype(0).dtype + if isinstance(dtype, np.dtype): + return dtype + if isinstance(dtype, str): + return np.dtype(dtype) + + raise TypeError("data type {}: {} not understood".format(dtype.__class__, dtype)) + + +def zeros_like(img, dtype=None): + """ + + :param img: reference image + :param dtype: desired data type (optional) + :return: an Image with the same shape and header, filled with zeros + + Similar to numpy.zeros_like(), the goal of the function is to show the developer's + intent and avoid doing a copy, which is slower than initialization with a constant. + + Copied from https://github.com/spinalcordtoolbox/spinalcordtoolbox/image.py + """ + zimg = Image(np.zeros_like(img.data), hdr=img.hdr.copy()) + if dtype is not None: + zimg.change_type(dtype) + return zimg + + +def empty_like(img, dtype=None): + """ + :param img: reference image + :param dtype: desired data type (optional) + :return: an Image with the same shape and header, whose data is uninitialized + + Similar to numpy.empty_like(), the goal of the function is to show the developer's + intent and avoid touching the allocated memory, because it will be written to + afterwards. + + Copied from https://github.com/spinalcordtoolbox/spinalcordtoolbox/image.py + """ + dst = change_type(img, dtype) + return dst + + +def find_zmin_zmax(im, threshold=0.1): + """ + Find the min (and max) z-slice index below which (and above which) slices only have voxels below a given threshold. + + :param im: Image object + :param threshold: threshold to apply before looking for zmin/zmax, typically corresponding to noise level. + :return: [zmin, zmax] + + Copied from https://github.com/spinalcordtoolbox/spinalcordtoolbox/image.py + """ + slicer = SlicerOneAxis(im, axis="IS") + + # Make sure image is not empty + if not np.any(slicer): + logger.error('Input image is empty') + + # Iterate from bottom to top until we find data + for zmin in range(0, len(slicer)): + if np.any(slicer[zmin] > threshold): + break + + # Conversely from top to bottom + for zmax in range(len(slicer) - 1, zmin, -1): + if np.any(slicer[zmax] > threshold): + break + + return zmin, zmax \ No newline at end of file From e96d5c92b1b12e2f47c4a90c466f165901188c7c Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Wed, 25 Oct 2023 19:50:14 -0400 Subject: [PATCH 14/34] fixed orientation problem by using Image --- dataset_analysis/generate_dataframe.py | 56 ++++++++++++++------------ 1 file changed, 30 insertions(+), 26 deletions(-) diff --git a/dataset_analysis/generate_dataframe.py b/dataset_analysis/generate_dataframe.py index 58fe8bc..bb392a3 100644 --- a/dataset_analysis/generate_dataframe.py +++ b/dataset_analysis/generate_dataframe.py @@ -33,6 +33,7 @@ import nibabel as nib import numpy as np import yaml +from image import Image, get_dimension, change_orientation def get_parser(): @@ -122,20 +123,23 @@ def analyse_lesion_per_levels(patient_data, discs_path, timepoint, output_folder disc_seg_file = os.path.join(discs_path, participant_id, "ses-" + timepoint, "anat", f"{participant_id}_ses-" + timepoint+ "_STIR_labels-disc.nii.gz") #now we read the lesion segmentation file and the disc segmentation file - lesion_labelled_seg = nib.load(lesion_seg_file) + lesion_labelled_seg = Image(lesion_seg_file) #we check if the lesion segmentation file is empty - if np.sum(lesion_labelled_seg.get_fdata()) == 0: + if np.sum(lesion_labelled_seg.data) == 0: return patient_data - disc_seg_file = nib.load(disc_seg_file) + disc_seg_file = Image(disc_seg_file) + #we make sure that they have the same orientation + disc_seg_file = change_orientation(disc_seg_file, lesion_labelled_seg.orientation) #we get the data from the lesion segmentation file and the disc segmentation file - lesion_labelled_seg_data = lesion_labelled_seg.get_fdata() - disc_seg_data = disc_seg_file.get_fdata() + lesion_labelled_seg_data = lesion_labelled_seg.data + disc_seg_data = disc_seg_file.data #get voxel size - voxel_size = lesion_labelled_seg.header.get_zooms() + _,_,_,_,voxel_size_x,voxel_size_y,voxel_size_z,_ = get_dimension(lesion_labelled_seg) + _,_,_,_,disc_voxel_size_x,disc_voxel_size_y,disc_voxel_size_z,_ = get_dimension(disc_seg_file) #the levels are the integer unique values without 0 levels = np.unique(disc_seg_data) @@ -145,10 +149,10 @@ def analyse_lesion_per_levels(patient_data, discs_path, timepoint, output_folder for i in range(len(levels)-1): #get upper bound of level upper_bound = np.where(disc_seg_data == levels[i]) - upper_bound = int(upper_bound[1]) + upper_bound = int(upper_bound[1])*disc_voxel_size_y #get lower bound of level lower_bound = np.where(disc_seg_data == levels[i+1]) - lower_bound = int(lower_bound[1]) + lower_bound = int(lower_bound[1])*disc_voxel_size_y #initialize the lesion_info_per_levels dictionary nb_lesions_in_level = 0 @@ -163,12 +167,12 @@ def analyse_lesion_per_levels(patient_data, discs_path, timepoint, output_folder for lesion in lesions: lesion_voxel = np.where(lesion_labelled_seg_data == lesion) center_of_lesion = np.mean(lesion_voxel, axis=1) - volume_of_lesion = len(lesion_voxel[0])*voxel_size[0]*voxel_size[1]*voxel_size[2] - top_of_lesion = np.max(lesion_voxel[2]) - bottom_of_lesion = np.min(lesion_voxel[2]) - length_of_lesion = (top_of_lesion - bottom_of_lesion)*voxel_size[2] + volume_of_lesion = len(lesion_voxel[0])*voxel_size_x*voxel_size_y*voxel_size_z + top_of_lesion = np.max(lesion_voxel[1]) + bottom_of_lesion = np.min(lesion_voxel[1]) + length_of_lesion = (top_of_lesion - bottom_of_lesion)*voxel_size_y #if lesion center is between upper and lower bound, then it is in the level - if center_of_lesion[1] <= upper_bound and center_of_lesion[1] >= lower_bound: + if center_of_lesion[1]*voxel_size_y <= upper_bound and center_of_lesion[1]*voxel_size_y >= lower_bound: nb_lesions_in_level += 1 total_lesion_volume_in_level += volume_of_lesion lesion_length_in_level += length_of_lesion @@ -190,7 +194,7 @@ def analyse_lesion_per_levels(patient_data, discs_path, timepoint, output_folder if int(levels[i]) == 1: #we only have a lower bound lower_bound = np.where(disc_seg_data == levels[i]) - lower_bound = int(lower_bound[1]) + lower_bound = int(lower_bound[1])*disc_voxel_size_y #initialize the lesion_info_per_levels dictionary nb_lesions_above_1 = 0 @@ -205,12 +209,12 @@ def analyse_lesion_per_levels(patient_data, discs_path, timepoint, output_folder for lesion in lesions: lesion_voxel = np.where(lesion_labelled_seg_data == lesion) center_of_lesion = np.mean(lesion_voxel, axis=1) - volume_of_lesion = len(lesion_voxel[0])*voxel_size[0]*voxel_size[1]*voxel_size[2] - top_of_lesion = np.max(lesion_voxel[2]) - bottom_of_lesion = np.min(lesion_voxel[2]) - length_of_lesion = (top_of_lesion - bottom_of_lesion)*voxel_size[2] + volume_of_lesion = len(lesion_voxel[0])*voxel_size_x*voxel_size_y*voxel_size_z + top_of_lesion = np.max(lesion_voxel[1]) + bottom_of_lesion = np.min(lesion_voxel[1]) + length_of_lesion = (top_of_lesion - bottom_of_lesion)*voxel_size_y #if lesion center is between upper and lower bound, then it is in the level - if center_of_lesion[1] >= lower_bound: + if center_of_lesion[1]*voxel_size_y >= lower_bound: nb_lesions_above_1 += 1 total_lesion_volume_above_1 += volume_of_lesion lesion_length_above_1 += length_of_lesion @@ -233,7 +237,7 @@ def analyse_lesion_per_levels(patient_data, discs_path, timepoint, output_folder level = levels[i] # we only have an upper bound upper_bound = np.where(disc_seg_data == level) - upper_bound = int(upper_bound[1]) + upper_bound = int(upper_bound[1])*disc_voxel_size_y #initialize the lesion_info_per_levels dictionary nb_lesions_after_last = 0 @@ -248,12 +252,12 @@ def analyse_lesion_per_levels(patient_data, discs_path, timepoint, output_folder for lesion in lesions: lesion_voxel = np.where(lesion_labelled_seg_data == lesion) center_of_lesion = np.mean(lesion_voxel, axis=1) - volume_of_lesion = len(lesion_voxel[0])*voxel_size[0]*voxel_size[1]*voxel_size[2] - top_of_lesion = np.max(lesion_voxel[2]) - bottom_of_lesion = np.min(lesion_voxel[2]) - length_of_lesion = (top_of_lesion - bottom_of_lesion)*voxel_size[2] + volume_of_lesion = len(lesion_voxel[0])*voxel_size_x*voxel_size_y*voxel_size_z + top_of_lesion = np.max(lesion_voxel[1]) + bottom_of_lesion = np.min(lesion_voxel[1]) + length_of_lesion = (top_of_lesion - bottom_of_lesion)*voxel_size_y #if lesion center is between upper and lower bound, then it is in the level - if center_of_lesion[1] <= upper_bound: + if center_of_lesion[1]*voxel_size_y[1] <= upper_bound: nb_lesions_after_last += 1 total_lesion_volume_after_last += volume_of_lesion lesion_length_after_last += length_of_lesion @@ -441,7 +445,7 @@ def main(): #add the patient to the dataset dataframe = pd.concat([dataframe, pd.DataFrame([patient_data])], ignore_index=True) - + #save the dataset in the output folder dataframe.to_csv(os.path.join(output_folder, 'dataframe.csv'), index=False) print("Dataframe saved in " + os.path.join(output_folder, 'dataframe.csv')) From 757a231d073351d6676ecaf5c6291eb9cbe9c88a Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Wed, 25 Oct 2023 20:50:14 -0400 Subject: [PATCH 15/34] fixed index for voxel size --- dataset_analysis/generate_dataframe.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dataset_analysis/generate_dataframe.py b/dataset_analysis/generate_dataframe.py index bb392a3..7cdbd27 100644 --- a/dataset_analysis/generate_dataframe.py +++ b/dataset_analysis/generate_dataframe.py @@ -257,7 +257,7 @@ def analyse_lesion_per_levels(patient_data, discs_path, timepoint, output_folder bottom_of_lesion = np.min(lesion_voxel[1]) length_of_lesion = (top_of_lesion - bottom_of_lesion)*voxel_size_y #if lesion center is between upper and lower bound, then it is in the level - if center_of_lesion[1]*voxel_size_y[1] <= upper_bound: + if center_of_lesion[1]*voxel_size_y <= upper_bound: nb_lesions_after_last += 1 total_lesion_volume_after_last += volume_of_lesion lesion_length_after_last += length_of_lesion From 38f9d220fe69549394eacfed37cbab2e36dc82ca Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Wed, 25 Oct 2023 20:51:29 -0400 Subject: [PATCH 16/34] full analysis of both time point --- dataset_analysis/dataframe_analysis.ipynb | 511 ++++++++++++++++------ 1 file changed, 368 insertions(+), 143 deletions(-) diff --git a/dataset_analysis/dataframe_analysis.ipynb b/dataset_analysis/dataframe_analysis.ipynb index 69b8348..d09aece 100644 --- a/dataset_analysis/dataframe_analysis.ipynb +++ b/dataset_analysis/dataframe_analysis.ipynb @@ -6,15 +6,35 @@ "source": [ "# Dataframe analysis\n", "\n", - "This notebook explores the analysis of the dataframe built from canproco at time point M0. \n", + "This notebook explores the analysis of the dataframe describing CanProCo patients from M0 and CanProCo patients from M12 (the latter's lesion segmentation were infered using 3d nnUNet)\n", "It looks at correlation between age, phenotypes, nb of lesions and distribution of lesions. \n", "\n", + "More in details it details : \n", + "- patient\n", + "- site\n", + "- sex\n", + "- age\n", + "- phenotype\n", + "- pathology\n", + "- EDSS\n", + "- number of lesions\n", + "- volume of lesions\n", + "- lenght of lesions\n", + "- lesion per vertebral levels\n", + "\n", "Author : Pierre-Louis Benveniste" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Library import" + ] + }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 170, "metadata": {}, "outputs": [], "source": [ @@ -24,7 +44,8 @@ "import seaborn as sns\n", "import os\n", "import sys\n", - "import yaml" + "import yaml\n", + "from prettytable import PrettyTable" ] }, { @@ -38,43 +59,15 @@ }, { "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [], - "source": [ - "#load dataframe\n", - "dataframe_path = '/Users/plbenveniste/Desktop/test_generate_dataframe/dataframe.csv'\n", - "dataframe = pd.read_csv(dataframe_path)\n", - "\n", - "#load exclude.yml file\n", - "exclude_path = '/Users/plbenveniste/Documents/NeuroPoly/canproco_project/canproco/exclude.yml'\n", - "#exclude_file = pd.read_csv(exclude_path)\n", - "with open(exclude_path, 'r') as yaml_file:\n", - " exclude_file = yaml.load(yaml_file, Loader=yaml.FullLoader)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Subject exclusion\n", - "\n", - "Some subjects were excluded because of poor image quality" - ] - }, - { - "cell_type": "code", - "execution_count": 45, + "execution_count": 171, "metadata": {}, "outputs": [], "source": [ - "#iterate over excluded subjects\n", - "for subject in exclude_file:\n", - " #exclude subject from dataframe\n", - " dataframe = dataframe[dataframe.participant_id != subject.split('_')[0]]\n", - "\n", - "#we make sure that participants are only included once\n", - "dataframe = dataframe.drop_duplicates(subset=['participant_id'])" + "#load dataframes\n", + "df_M0_path = '/Users/plbenveniste/tmp_romane/canproco/project/canproco_final/dataframes/dataframe_M0/dataframe.csv'\n", + "df_M0_all = pd.read_csv(df_M0_path)\n", + "df_M12_path = '/Users/plbenveniste/tmp_romane/canproco/project/canproco_final/dataframes/dataframe_M12_3d/dataframe.csv'\n", + "df_M12_all = pd.read_csv(df_M12_path)" ] }, { @@ -93,115 +86,180 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 172, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Number of participants: 3\n", - "Number of females: 2 (67%)\n", - "Number of females: 1 (33%)\n", + "Number of participants: 289\n", + "Number of females: 202 (70%)\n", + "Number of males: 87 (30%)\n", "\n", - "Number of healthy participants: 0 (0%)\n", - "Number of MS participants: 3 (100%)\n", + "Number of healthy participants: 40 (14%)\n", + "Number of MS participants: 249 (86%)\n", "\n", - "Age distribution:\n", - "count 3.000000\n", - "mean 39.333333\n", - "std 13.796135\n", - "min 29.000000\n", - "25% 31.500000\n", - "50% 34.000000\n", - "75% 44.500000\n", - "max 55.000000\n", - "Name: age, dtype: float64\n" + "Age distribution:\n" ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ "#number of participants\n", - "nb_participant = len(dataframe.participant_id)\n", + "nb_participant = len(df_M0_all.participant_id)\n", "#number of female participants\n", - "nb_female = len(dataframe[dataframe.sex == 'F'])\n", + "nb_female = len(df_M0_all[df_M0_all.sex == 'F'])\n", "#number of male participants\n", - "nb_male = len(dataframe[dataframe.sex == 'M'])\n", + "nb_male = len(df_M0_all[df_M0_all.sex == 'M'])\n", "#number of healthy patients\n", - "nb_healthy = len(dataframe[dataframe.pathology == 'HC'])\n", + "nb_healthy = len(df_M0_all[df_M0_all.pathology == 'HC'])\n", "#number of MS patients\n", - "nb_MS = len(dataframe[dataframe.pathology == 'MS'])\n", + "nb_MS = len(df_M0_all[df_M0_all.pathology == 'MS'])\n", "\n", "#now we print them all:\n", "print('Number of participants: ', nb_participant)\n", "print('Number of females: '+ str(nb_female) + \" (\" + str(round(nb_female/nb_participant*100)) + \"%)\")\n", - "print('Number of females: '+ str(nb_male) + \" (\" + str(round(nb_male/nb_participant*100)) + \"%)\\n\")\n", + "print('Number of males: '+ str(nb_male) + \" (\" + str(round(nb_male/nb_participant*100)) + \"%)\\n\")\n", "print('Number of healthy participants: '+ str(nb_healthy) + \" (\" + str(round(nb_healthy/nb_participant*100)) + \"%)\")\n", "print('Number of MS participants: '+ str(nb_MS) + \" (\" + str(round(nb_MS/nb_participant*100)) + \"%)\\n\")\n", "print('Age distribution:')\n", - "print(dataframe.age.describe())\n", + "#print(df_M0_all.age.describe())\n", "\n", - "## Uncomment to see boxplot of age distribution\n", - "# #now we can plot the age distribution\n", - "# plt.figure(figsize=(3, 5))\n", - "# plt.boxplot(dataframe.age)\n", - "# plt.title('Age distribution')\n", - "# plt.show()" + "# Uncomment to see boxplot of age distribution\n", + "#now we can plot the age distribution\n", + "plt.figure(figsize=(3, 5))\n", + "plt.violinplot(df_M0_all.age, showmeans=True)\n", + "plt.title('Age distribution')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For the latter analysis we remove the healthy subjects from the dataframes to study MS in particular" + ] + }, + { + "cell_type": "code", + "execution_count": 173, + "metadata": {}, + "outputs": [], + "source": [ + "#removal of healthy controls\n", + "df_M0 = df_M0_all[df_M0_all.pathology != 'HC']\n", + "df_M12 = df_M12_all[df_M12_all.pathology != 'HC']" ] }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 174, "metadata": {}, "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "name": "stdout", "output_type": "stream", "text": [ - "EDSS distribution:\n", - "count 3.000000\n", - "mean 1.166667\n", - "std 1.040833\n", - "min 0.000000\n", - "25% 0.750000\n", - "50% 1.500000\n", - "75% 1.750000\n", - "max 2.000000\n", - "Name: edss, dtype: float64\n" + "+--------+--------+--------+\n", + "| EDSS | M0 | M12 |\n", + "+--------+--------+--------+\n", + "| Mean | 1.6694 | 1.6694 |\n", + "| Median | 1.5 | 1.5 |\n", + "+--------+--------+--------+\n" ] } ], "source": [ - "# now we show the distribution of edss scores\n", - "print('EDSS distribution:')\n", - "print(dataframe.edss.describe())\n", + "#now we can plot the edss distribution \n", + "plt.figure(figsize=(7, 5))\n", + "plt.violinplot(df_M0.edss.dropna(), showmeans=True, positions=[1])\n", + "plt.violinplot(df_M12.edss.dropna(), showmeans=True, positions=[2])\n", + "plt.xlabel('M0 (left) and M12 (right)')\n", + "plt.ylabel('EDSS score')\n", + "plt.title('EDSS distribution')\n", + "plt.show()\n", "\n", - "##Uncomment to see boxplot of edss distribution\n", - "# #now we can plot the edss distribution\n", - "# plt.figure(figsize=(3, 5))\n", - "# plt.boxplot(dataframe.edss)\n", - "# plt.title('EDSS distribution')\n", - "# plt.show()" + "#we print a table for comparison of the edss scores\n", + "table = PrettyTable()\n", + "table.field_names = ['EDSS', 'M0', 'M12']\n", + "table.add_row(['Mean', round(df_M0.edss.dropna().mean(),4), round(df_M12.edss.dropna().mean(),4)])\n", + "table.add_row(['Median', round(df_M0.edss.dropna().median(),4), round(df_M12.edss.dropna().median(),4)])\n", + "print(table)" + ] + }, + { + "cell_type": "code", + "execution_count": 175, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_806/3800180276.py:2: 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", + " df_M0['timepoint'] = 'M0'\n", + "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_806/3800180276.py:3: 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", + " df_M12['timepoint'] = 'M12'\n" + ] + } + ], + "source": [ + "#we add the timepoint to the dataframe \n", + "df_M0['timepoint'] = 'M0'\n", + "df_M12['timepoint'] = 'M12'" ] }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 176, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Number of RIS participants: 2 (67%)\n", - "Number of RRMS participants: 1 (33%)\n" + "+------------+-----------+-----------+\n", + "| Phenotypes | M0 | M12 |\n", + "+------------+-----------+-----------+\n", + "| PPMS | 45 (18%) | 45 (18%) |\n", + "| RIS | 46 (18%) | 46 (18%) |\n", + "| RRMS | 158 (63%) | 158 (63%) |\n", + "+------------+-----------+-----------+\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -209,17 +267,21 @@ } ], "source": [ - "#now we can look at the distribution of phenotypes\n", - "phenotypes = dataframe.phenotype.unique()\n", - "for phenotype in phenotypes:\n", - " print('Number of ' + phenotype + ' participants: ' + str(len(dataframe[dataframe.phenotype == phenotype])) + \" (\" + str(round(len(dataframe[dataframe.phenotype == phenotype])/nb_participant*100)) + \"%)\")\n", + "# now we can concatenate the two dataframes\n", + "df_concat = pd.concat([df_M0, df_M12])\n", "\n", - "## uncomment to see barplot of phenotypes\n", - "#now we can plot the phenotype distribution\n", - "plt.figure(figsize=(3, 5))\n", - "sns.countplot(x='phenotype', data=dataframe)\n", + "# now we can plot the phenotype distribution\n", + "plt.figure(figsize=(5, 3))\n", + "sns.countplot(data=df_concat, x='phenotype', hue='timepoint', palette='mako')\n", "plt.title('Phenotype distribution')\n", - "plt.show()\n" + "\n", + "#now we print a table with the results\n", + "table = PrettyTable()\n", + "table.field_names = ['Phenotypes', 'M0', 'M12']\n", + "for phenotype in np.unique(df_concat.phenotype): \n", + " table.add_row([phenotype, str(len(df_M0[(df_M0.phenotype == phenotype)])) +\" (\"+ str(round(len(df_M0[(df_M0.phenotype == phenotype)])*100/len(df_M0.participant_id))) + \"%)\",\n", + " str(len(df_M12[(df_M12.phenotype == phenotype)]))+\" (\"+ str(round(len(df_M12[(df_M12.phenotype == phenotype)])*100/len(df_M0.participant_id))) + \"%)\"])\n", + "print(table)" ] }, { @@ -238,12 +300,52 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 177, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+----------------------------------+-------+--------+\n", + "| | M0 | M12 |\n", + "+----------------------------------+-------+--------+\n", + "| Mean nb of lesions per patient | 5.3 | 3.75 |\n", + "| Mean lesion volume (mm3) | 404.3 | 190.46 |\n", + "| Mean biggest lesion volume (mm3) | 176.6 | 101.95 |\n", + "+----------------------------------+-------+--------+\n" + ] + } + ], + "source": [ + "#we print a table with the average nb of lesion per patient, average lesion volume and average lesion volume per lesion\n", + "table = PrettyTable()\n", + "table.field_names = ['', 'M0', 'M12']\n", + "table.add_row(['Mean nb of lesions per patient', round(df_M0.number_of_lesions.mean(),1), round(df_M12.number_of_lesions.mean(),2)])\n", + "table.add_row(['Mean lesion volume (mm3)', round(df_M0.total_lesion_volume.mean(),1), round(df_M12.total_lesion_volume.mean(),2)])\n", + "table.add_row(['Mean biggest lesion volume (mm3)', round(df_M0.biggest_lesion_vol.mean(),1), round(df_M12.biggest_lesion_vol.mean(),2)])\n", + "\n", + "print(table)" + ] + }, + { + "cell_type": "code", + "execution_count": 178, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -254,28 +356,51 @@ ], "source": [ "# we get the column names of the dataframe corresponding to the regions\n", - "regions = dataframe.columns\n", - "regions = [str(column) for column in regions if 'lesions_between' in column]\n", + "regions = df_M0.columns\n", + "regions = [str(column) for column in regions if 'lesions_between' in column or 'lesions_above' in column]\n", "regions = np.sort(regions)\n", "\n", "# we output the hist plot of the distribution of lesions per regions\n", "plt.figure(figsize=(25, 5))\n", - "legend = [region.split('_',2)[-1] for region in regions]\n", - "plt.bar(legend, dataframe[regions].sum())\n", - "plt.title('Distribution of lesions per regions')\n", + "legend = [region.split('_',3)[-1] for region in regions]\n", + "plt.bar(legend, df_M0[regions].sum())\n", + "plt.title('Distribution of lesions per regions in M0')\n", "plt.xlabel('Regions')\n", "plt.ylabel('Number of lesions')\n", - "plt.show()\n" + "plt.show()\n", + "\n", + "#we output the same thing for M12 \n", + "regions = df_M12.columns\n", + "regions = [str(column) for column in regions if 'lesions_between' in column or 'lesions_above' in column]\n", + "regions = np.sort(regions)\n", + "\n", + "plt.figure(figsize=(25, 5))\n", + "legend = [region.split('_',3)[-1] for region in regions]\n", + "plt.bar(legend, df_M12[regions].sum())\n", + "plt.title('Distribution of lesions per regions in M12')\n", + "plt.xlabel('Regions')\n", + "plt.ylabel('Number of lesions')\n", + "plt.show()" ] }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 179, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAB9QAAAHUCAYAAABrkhMvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABc10lEQVR4nO3deZzNhf4/8PdBxj4lMTPJUpEiWpRSN7SQSvtNO+l227ulfVfdKJVKiza0r7eSUsq9ok07t/VKN9JCuhISU/j8/uhnvoaDGWacOTyfj8d5PO58zud8zvv9eX/OcZvXfD6fVJIkSQAAAAAAAAAAxVTKdAEAAAAAAAAAUBEJ1AEAAAAAAAAgDYE6AAAAAAAAAKQhUAcAAAAAAACANATqAAAAAAAAAJCGQB0AAAAAAAAA0hCoAwAAAAAAAEAaAnUAAAAAAAAASEOgDgAAAAAAAABpCNQBAIAydf/990cqlSp6VKtWLfLy8qJTp07Rr1+/mDFjxnKv6dOnT6RSqVK9z6+//hp9+vSJMWPGlOp16d6rSZMmccABB5RqO6vy6KOPxi233JL2uVQqFX369CnT9ytr//rXv6Jt27ZRs2bNSKVSMWzYsEyXlBFjxoyJVCpV6uMs24wfPz46dOgQubm5kUqlVnjsRpTv8bu+7O9s0bNnz2jSpEmmy0irPI6Vjh07RiqVis033zySJFnu+ddee63o37b777+/aPncuXPjggsuiM6dO8cmm2yyws/IokWLYsCAAbHvvvtGw4YNo0aNGrH11lvHRRddFD///HOZ9QEAAJQtgToAAFAuhg4dGuPGjYtRo0bFHXfcEdttt11cf/31sfXWW8c///nPYuv+5S9/iXHjxpVq+7/++mtcddVVpQ5TVue9VsfKAvVx48bFX/7yl3KvYXUlSRJHHHFEbLDBBjF8+PAYN25cdOjQIdNlUY569eoV06ZNi8cffzzGjRsXRx55ZEbq2GGHHWLcuHGxww47ZOT9Ke7yyy+PZ599NtNlpFVex0rt2rVj8uTJMXr06OWeGzJkSNSpU2e55TNnzox77rknCgsL4+CDD17htufPnx99+vSJxo0bxy233BIvvvhinHTSSXHPPffEbrvtFvPnzy/LVgAAgDJSJdMFAAAA66ZWrVpF27Zti34+7LDD4pxzzondd989Dj300Jg0aVI0aNAgIiIaNmwYDRs2LNd6fv3116hRo8Zaea9V2WWXXTL6/qvy/fffx08//RSHHHJI7LXXXpkuh7Xgk08+iZNOOim6du2a0Trq1KlT4T8f5W3RokWxcOHCyMnJKdH6SZLEggULonr16mVeyxZbbFHm2ywr5XWsNGrUKGrXrh1Dhgwp9v03d+7ceOqpp+KYY46Je++9t9hrGjduHLNmzYpUKhX/+9//4r777ku77erVq8fkyZNj4403LlrWsWPHaNSoUfz5z3+Op59+Oo499tgy7wkAAFgzzlAHAADWmkaNGsVNN90Uc+fOjbvvvrtoebrLsI8ePTo6duwYG2+8cVSvXj0aNWoUhx12WPz6668xZcqU2GSTTSIi4qqrriq6BG/Pnj2Lbe/DDz+Mww8/PDbaaKOiYGhll5d/9tlno3Xr1lGtWrXYfPPNY+DAgcWeX3I5+ylTphRbvuylhzt27BgjRoyIr7/+utjl75dIdzngTz75JA466KDYaKONolq1arHddtvFAw88kPZ9Hnvssbj00kujoKAg6tSpE3vvvXdMnDhxxTt+KW+88UbstddeUbt27ahRo0a0b98+RowYUfR8nz59iv7g4MILL4xUKrXSSz4vWLAgzj333Nhuu+0iNzc36tatG7vuums899xzxdbbfvvt409/+tNyr1+0aFFsuummceihhxYt+/bbb+Pwww+P2rVrx4YbbhjHHHNMvPfee8tdZnlZ//73vyOVSsXgwYOXe+6ll16KVCoVw4cPL/G+WJGOHTtGx44dl1u+7OWxp0yZEqlUKm644Ya4/vrro0mTJlG9evXo2LFjfPHFF/H777/HRRddFAUFBZGbmxuHHHJI2lsiPPHEE7HrrrtGzZo1o1atWtGlS5cYP378KuuMWPVxteSYXrhwYQwaNGi5Y7Wkpk+fHieffHI0bNgwqlatGk2bNo2rrroqFi5cWGy9QYMGRZs2baJWrVpRu3btaNGiRVxyySVFz6/oMt7Dhw+PXXfdNWrUqBG1a9eOffbZZ7krTSz5bH/66adx1FFHRW5ubjRo0CB69eoVs2fPLrbuU089Fe3atYvc3NyoUaNGbL755tGrV69V9plKpeKMM86Iu+++O5o3bx45OTmxzTbbxOOPP75a+2TJMdK/f//4+9//Hk2bNo2cnJx49dVXV1nDXXfdFVtvvXXk5OQUzXTSpElx9NFHR/369SMnJye23nrruOOOO5bbxqeffhqdO3eOGjVqxCabbBKnn356jBgxYrl9n+6S7wsWLIiLL744mjZtGlWrVo1NN900Tj/99OUuWb7kVhojR46MHXbYIapXrx4tWrSIIUOGFFvv119/jfPOOy+aNm0a1apVi7p160bbtm3jscceW+E+iEh/rPTs2TNq1aoVX375Zey3335Rq1at2GyzzeLcc8+NwsLClW5vab169YpnnnmmWE9LZpzu6g0l/dxUrly5WJi+xM477xwREd98802JawQAANYegToAALBW7bffflG5cuV47bXXVrjOlClTYv/994+qVavGkCFDYuTIkXHddddFzZo147fffov8/PwYOXJkRESceOKJMW7cuBg3blxcfvnlxbZz6KGHxpZbbhlPPfVU3HXXXSuta8KECXH22WfHOeecE88++2y0b98+/va3v8WNN95Y6h7vvPPO2G233SIvL6+otpVdZn7ixInRvn37+PTTT2PgwIHxzDPPxDbbbBM9e/aM/v37L7f+JZdcEl9//XXcd999cc8998SkSZOiW7dusWjRopXWNXbs2Nhzzz1j9uzZMXjw4Hjssceidu3a0a1bt3jiiSci4o9L4j/zzDMREXHmmWfGuHHjVnrJ58LCwvjpp5/ivPPOi2HDhsVjjz1WdBWCBx98sGi9E044Id54442YNGlSsde/8sor8f3338cJJ5wQERHz5s2LTp06xauvvhrXX399PPnkk9GgQYPo3r37SnuLiGjTpk1sv/32MXTo0OWeu//++6N+/fqx3377lXhflJU77rgj3nzzzbjjjjvivvvui//85z/RrVu3OPHEE+PHH3+MIUOGRP/+/eOf//zncrcC6Nu3bxx11FGxzTbbxJNPPhkPPfRQzJ07N/70pz/FZ599ttL3Lclxtf/++xcdm4cffvgqj9V0pk+fHjvvvHO8/PLLccUVV8RLL70UJ554YvTr1y9OOumkovUef/zxOO2006JDhw7x7LPPxrBhw+Kcc86JefPmrXT7jz76aBx00EFRp06deOyxx2Lw4MExa9as6NixY7zxxhvLrX/YYYdF8+bN4+mnn46LLrooHn300TjnnHOKnh83blx07949Nt9883j88cdjxIgRccUVVywX/q/I8OHDY+DAgXH11VfHP/7xj2jcuHEcddRR8Y9//KPU+2SJgQMHxujRo+PGG2+Ml156KVq0aLHSGoYNGxaDBg2KK664Il5++eWi42GnnXaKTz75JG666aZ44YUXYv/994+zzjorrrrqqqLXTps2LTp06BATJ06MQYMGxYMPPhhz586NM844Y5W9J0kSBx98cNx4441x3HHHxYgRI6J3797xwAMPxJ577rlcaP3vf/87zj333DjnnHPiueeei9atW8eJJ55Y7Pu/d+/eMWjQoDjrrLNi5MiR8dBDD8Wf//znmDlz5irrSef333+PAw88MPbaa6947rnnolevXnHzzTfH9ddfX+JtHHnkkVG5cuViof7gwYPj8MMPT3vJ9zW15PLyLVu2LPNtAwAAZSABAAAoQ0OHDk0iInnvvfdWuE6DBg2SrbfeuujnK6+8Mln6P0/+8Y9/JBGRTJgwYYXb+PHHH5OISK688srlnluyvSuuuGKFzy2tcePGSSqVWu799tlnn6ROnTrJvHnzivU2efLkYuu9+uqrSUQkr776atGy/fffP2ncuHHa2pet+8gjj0xycnKSqVOnFluva9euSY0aNZKff/652Pvst99+xdZ78sknk4hIxo0bl/b9lthll12S+vXrJ3Pnzi1atnDhwqRVq1ZJw4YNk8WLFydJkiSTJ09OIiK54YYbVrq9dBYuXJj8/vvvyYknnphsv/32Rcv/97//JVWrVk0uueSSYusfccQRSYMGDZLff/89SZIkueOOO5KISF566aVi65188slJRCRDhw5d6fsPHDgwiYhk4sSJRct++umnJCcnJzn33HOLlpV0X6SbbYcOHZIOHTos9949evQoNvMl+7FNmzbJokWLipbfcsstSUQkBx54YLHXn3322UlEJLNnz06SJEmmTp2aVKlSJTnzzDOLrTd37twkLy8vOeKII1a6L0p6XCXJH8fk6aefvtLtLb3u0sfvySefnNSqVSv5+uuvi6134403JhGRfPrpp0mSJMkZZ5yRbLjhhivd9rL7e9GiRUlBQUGy7bbbFtuHc+fOTerXr5+0b9++aNmSz3b//v2LbfO0005LqlWrVjTTJXUt3X9JRURSvXr1ZPr06UXLFi5cmLRo0SLZcssti5aVdJ8sOUa22GKL5LfffitxDbm5uclPP/1UbHmXLl2Shg0bFh0/S5xxxhlJtWrVitY///zzk1QqVVTD0q9f9lhf9pgeOXJk2n38xBNPJBGR3HPPPUXLGjdunFSrVq3YPpg/f35St27d5OSTTy5a1qpVq+Tggw8uUe9LS/fZ7NGjRxIRyZNPPlls3f322y/ZaqutVrnNDh06JC1btizaVtu2bZMkSZJPP/00iYhkzJgxyXvvvbfS76KV/duUzrfffps0aNAgadu2bbFjHAAAqDicoQ4AAKx1SZKs9PntttsuqlatGn/961/jgQceiK+++mq13uewww4r8botW7aMNm3aFFt29NFHx5w5c+LDDz9crfcvqdGjR8dee+0Vm222WbHlPXv2jF9//XW5M4YPPPDAYj+3bt06IiK+/vrrFb7HvHnz4p133onDDz88atWqVbS8cuXKcdxxx8W3335b4svGL+upp56K3XbbLWrVqhVVqlSJDTbYIAYPHhyff/550Tobb7xxdOvWLR544IFYvHhxRETMmjUrnnvuuTj++OOjSpUqEfHHmeO1a9eOfffdt9h7HHXUUSWq5ZhjjomcnJxil4Z/7LHHorCwsNhZ8OW1L9LZb7/9olKl//vP76233joi/jg7fGlLlk+dOjUiIl5++eVYuHBhHH/88bFw4cKiR7Vq1aJDhw7LXRZ9WaU9rlbXCy+8EJ06dYqCgoJidS65H/vYsWMj4o/LWv/8889x1FFHxXPPPRf/+9//VrntiRMnxvfffx/HHXdcsX1Yq1atOOyww+Ltt9+OX3/9tdhr0n0+FixYUHQ5/Z122ikiIo444oh48skn47vvvitVv3vttVc0aNCg6OfKlStH9+7d48svv4xvv/22VPtk6Zo32GCDEtew5557xkYbbVT084IFC+Jf//pXHHLIIVGjRo1i77nffvvFggUL4u233y5671atWsU222xTbJsl+YwtOZN6ye01lvjzn/8cNWvWjH/961/Flm+33XbRqFGjop+rVasWzZs3L/ZdtfPOO8dLL70UF110UYwZMybmz59fsp2wAqlUKrp161ZsWevWrVf6/ZhOr1694v3334+PP/44Bg8eHFtssUXssccea1Tbsn766afYb7/9IkmSeOKJJ4od4wAAQMXh/6kDAABr1bx582LmzJlRUFCwwnW22GKL+Oc//xn169eP008/PbbYYovYYost4tZbby3Ve+Xn55d43by8vBUuW91LD5fUzJkz09a6ZB8t+/7L3oM3JycnImKlQdSsWbMiSZJSvU9JPPPMM3HEEUfEpptuGg8//HCMGzcu3nvvvejVq1csWLCg2Lq9evWK7777LkaNGhUR/xd0Lx3OzZw5s1hYuUS6ZenUrVs3DjzwwHjwwQeLLoF///33x84771x0OeXy2hcrq2lpVatWXenyJfvthx9+iIg/AuANNtig2OOJJ55YZSBd2uNqdf3www/x/PPPL1fjkv29pM7jjjsuhgwZEl9//XUcdthhUb9+/WjXrl3R8bCiHiLSf5YLCgpi8eLFMWvWrGLLV/X52GOPPWLYsGFFf6zQsGHDaNWq1Srv2b1ESb4rSrpPlijNd1W69WfOnBkLFy6M2267bbn3XHKbgyXvuSafsZkzZ0aVKlVik002KbY8lUpFXl7eKr+rIv6Yx9LfVQMHDowLL7wwhg0bFp06dYq6devGwQcfvNztIUqqRo0aUa1ateXec9nvo1XZY489olmzZnH33XfHQw89FL169SrRfdJLatasWbHPPvsUfSduvvnmZbZtAACgbFXJdAEAAMD6ZcSIEbFo0aLo2LHjStf705/+FH/6059i0aJF8f7778dtt90WZ599djRo0CCOPPLIEr1XacKP6dOnr3DZklBoSUiz7H2CS3Km7cpsvPHGMW3atOWWf//99xERUa9evTXafkTERhttFJUqVSrz93n44YejadOm8cQTTxTb38vuo4iILl26REFBQQwdOjS6dOkSQ4cOjXbt2hU7U3bjjTeOd999d7nXppvPipxwwgnx1FNPxahRo6JRo0bx3nvvxaBBg4qeX9N9Ua1atZg9e/Zyy9f0OFjWkhqW3Ke7tNbGcbVkO61bt45rr7027fNL//HMCSecECeccELMmzcvXnvttbjyyivjgAMOiC+++CJtj0s+eyvqo1KlSsXO1C6pgw46KA466KAoLCyMt99+O/r16xdHH310NGnSJHbdddeVvrYk3xWl2ScRpfuuSrf+RhttVHSFhdNPPz3ta5o2bVpU45I/1kjXw8psvPHGsXDhwvjxxx+LhepJksT06dOLzv4vjZo1a8ZVV10VV111Vfzwww9FZ6t369Yt/vOf/5R6e2XphBNOiMsuuyxSqVT06NGjzLY7a9as2HvvvWPy5Mnxr3/9q+gqIwAAQMXkDHUAAGCtmTp1apx33nmRm5sbJ598coleU7ly5WjXrl3ccccdERFFl18vyVnZpfHpp5/Gv//972LLHn300ahdu3bssMMOERHRpEmTiIj46KOPiq03fPjw5ba37FmYK7PXXnvF6NGji4LOJR588MGoUaNG7LLLLiVtY4Vq1qwZ7dq1i2eeeaZYXYsXL46HH344GjZsGM2bNy/1dlOpVFStWrVYwDd9+vR47rnnllt3SeA3bNiweP311+P999+PXr16FVunQ4cOMXfu3HjppZeKLX/88cdLXFPnzp1j0003jaFDh8bQoUOjWrVqxS5nvab7okmTJvHFF18U+6OBmTNnxltvvVXiGkuiS5cuUaVKlfjvf/8bbdu2TftYmbVxXEVEHHDAAfHJJ5/EFltskbbGdFejqFmzZnTt2jUuvfTS+O233+LTTz9Nu+2tttoqNt1003j00UeL3Spi3rx58fTTT8euu+4aNWrUWO3ac3JyokOHDnH99ddHRMT48eNX+Zp//etfxQLpRYsWxRNPPBFbbLFFNGzYMCJWb5+siRo1akSnTp1i/Pjx0bp167TvuSTs79ChQ3zyySfx2WefFdtGST5je+21V0T88Yc0S3v66adj3rx5Rc+vrgYNGkTPnj3jqKOOiokTJy53Of+1rUePHtGtW7c4//zzY9NNNy2TbS4J07/66qt45ZVXYvvtty+T7QIAAOXHGeoAAEC5+OSTT4ru4Ttjxox4/fXXY+jQoVG5cuV49tlnl7tk8NLuuuuuGD16dOy///7RqFGjWLBgQQwZMiQiIvbee++IiKhdu3Y0btw4nnvuudhrr72ibt26Ua9evaLQu7QKCgriwAMPjD59+kR+fn48/PDDMWrUqLj++uuLAruddtopttpqqzjvvPNi4cKFsdFGG8Wzzz4bb7zxxnLb23bbbeOZZ56JQYMGxY477hiVKlVaYQB65ZVXFt1z+Yorroi6devGI488EiNGjIj+/ftHbm7uavW0rH79+sU+++wTnTp1ivPOOy+qVq0ad955Z3zyySfx2GOPrdbljA844IB45pln4rTTTovDDz88vvnmm7jmmmsiPz8/7SWbe/XqFddff30cffTRUb169ejevXux53v06BE333xzHHvssfH3v/89ttxyy3jppZfi5Zdfjogo0T2GK1euHMcff3wMGDAg6tSpE4ceeuhy+3BN9sVxxx0Xd999dxx77LFx0kknxcyZM6N///5Rp06dkuyyEmvSpElcffXVcemll8ZXX30V++67b2y00Ubxww8/xLvvvlt0Zu+KrK3j6uqrr45Ro0ZF+/bt46yzzoqtttoqFixYEFOmTIkXX3wx7rrrrmjYsGGcdNJJUb169dhtt90iPz8/pk+fHv369Yvc3NwVntlcqVKl6N+/fxxzzDFxwAEHxMknnxyFhYVxww03xM8//xzXXXddqeu94oor4ttvv4299torGjZsGD///HPceuutscEGG0SHDh1W+fp69erFnnvuGZdffnnUrFkz7rzzzvjPf/5TLJAu6T4pS7feemvsvvvu8ac//SlOPfXUaNKkScydOze+/PLLeP7554vuf3722WfHkCFDomvXrnH11VdHgwYN4tFHHy06G3xln7F99tknunTpEhdeeGHMmTMndtttt/joo4/iyiuvjO233z6OO+64Utfdrl27OOCAA6J169ax0UYbxeeffx4PPfTQGv+xRFkoKCiIYcOGlWjdl156KebNmxdz586NiIjPPvss/vGPf0RExH777Rc1atSI+fPnR5cuXWL8+PFxyy23xMKFC4vubR8Rsckmm8QWW2xR5n0AAABrRqAOAACUixNOOCEi/rgv9IYbbhhbb711XHjhhfGXv/xlpWF6RMR2220Xr7zySlx55ZUxffr0qFWrVrRq1SqGDx8enTt3Llpv8ODBcf7558eBBx4YhYWF0aNHj7j//vtXq97tttsuTjjhhLjyyitj0qRJUVBQEAMGDIhzzjmnaJ3KlSvH888/H2eccUaccsopkZOTE0ceeWTcfvvtsf/++xfb3t/+9rf49NNP45JLLonZs2dHkiTFzrBd2lZbbRVvvfVWXHLJJXH66afH/PnzY+utt46hQ4cWu7/4murQoUOMHj06rrzyyujZs2csXrw42rRpE8OHD48DDjhgtbZ5wgknxIwZM+Kuu+6KIUOGxOabbx4XXXRRfPvtt2nD3ubNm0f79u3jrbfeimOOOWa5ULdmzZoxevToOPvss+OCCy6IVCoVnTt3jjvvvDP222+/2HDDDUtcV79+/eLHH38sOhbLal/stttu8cADD8R1110XBx10UGy++eZx5ZVXxosvvhhjxowpUX0ldfHFF8c222wTt956a9E95/Py8mKnnXaKU045ZaWvXVvHVX5+frz//vtxzTXXxA033BDffvtt1K5dO5o2bVr0RwARf9zG4f77748nn3wyZs2aFfXq1Yvdd989HnzwwZV+Jxx99NFRs2bN6NevX3Tv3j0qV64cu+yyS7z66qvRvn37Utfbrl27eP/99+PCCy+MH3/8MTbccMNo27ZtjB49uuge5ytz4IEHRsuWLeOyyy6LqVOnxhZbbBGPPPJIsT8OKek+KUvbbLNNfPjhh3HNNdfEZZddFjNmzIgNN9wwmjVrVnQf9Yg/QuKxY8fG2WefHaecckrUqFEjDjnkkLj66qujR48eK/2MpVKpGDZsWPTp0yeGDh0a1157bdSrVy+OO+646Nu3b9GVQ0pjzz33jOHDh8fNN98cv/76a2y66aZx/PHHx6WXXro6uyFjTj311Pj666+Lfn7qqafiqaeeioiIyZMnR5MmTeKHH36I9957LyL++DdiWWvybxgAAFB+UsmKfqMDAAAAFUTfvn2LAsyyPrMXSiqVSsXpp58et99+e6ZLKXN//etf47HHHouZM2dG1apVM10OAABAheEMdQAAACqUJWFlixYt4vfff4/Ro0fHwIED49hjjxWmQxm4+uqro6CgIDbffPP45Zdf4oUXXoj77rsvLrvsMmE6AADAMgTqAAAAVCg1atSIm2++OaZMmRKFhYXRqFGjuPDCC+Oyyy7LdGmwTthggw2KLkW/cOHCaNasWQwYMCDtZcgBAADWdy75DgAAAAAAAABpVMp0AQAAAAAAAABQEQnUAQAAAAAAACANgToAAAAAAAAApFEl0wWUt8WLF8f3338ftWvXjlQqlelyAAAAAAAAAMiwJEli7ty5UVBQEJUqrfg89HU+UP/+++9js802y3QZAAAAAAAAAFQw33zzTTRs2HCFz2c0UB80aFAMGjQopkyZEhERLVu2jCuuuCK6du0aEX/8VcBVV10V99xzT8yaNSvatWsXd9xxR7Rs2bLE71G7du2I+GNH1KlTp8x7AAAAAAAAACC7zJkzJzbbbLOiPHlFMhqoN2zYMK677rrYcsstIyLigQceiIMOOijGjx8fLVu2jP79+8eAAQPi/vvvj+bNm8ff//732GeffWLixImrbGyJJZd5r1OnjkAdAAAAAAAAgCKrum14KkmSZC3VUiJ169aNG264IXr16hUFBQVx9tlnx4UXXhgREYWFhdGgQYO4/vrr4+STT077+sLCwigsLCz6eclfFsyePVugDgAAAAAAAEDMmTMncnNzV5kjr/ju6mvZokWL4vHHH4958+bFrrvuGpMnT47p06dH586di9bJycmJDh06xFtvvbXC7fTr1y9yc3OLHu6fDgAAAAAAAMDqyHig/vHHH0etWrUiJycnTjnllHj22Wdjm222ienTp0dERIMGDYqt36BBg6Ln0rn44otj9uzZRY9vvvmmXOsHAAAAAAAAYN2U0XuoR0RstdVWMWHChPj555/j6aefjh49esTYsWOLnl/2mvVJkqz0OvY5OTmRk5NTbvUCAAAAAAAAsH7I+BnqVatWjS233DLatm0b/fr1izZt2sStt94aeXl5ERHLnY0+Y8aM5c5aBwAAAAAAAICylvFAfVlJkkRhYWE0bdo08vLyYtSoUUXP/fbbbzF27Nho3759BisEAAAAAAAAYH2Q0Uu+X3LJJdG1a9fYbLPNYu7cufH444/HmDFjYuTIkZFKpeLss8+Ovn37RrNmzaJZs2bRt2/fqFGjRhx99NGZLBsAAAAAAACA9UBGA/UffvghjjvuuJg2bVrk5uZG69atY+TIkbHPPvtERMQFF1wQ8+fPj9NOOy1mzZoV7dq1i1deeSVq166dybIBAAAAAAAAWA+kkiRJMl1EeZozZ07k5ubG7Nmzo06dOpkuBwAAAAAAAIAMK2mOXOHuoQ4AAAAAAAAAFYFAHQAAAAAAAADSEKgDAAAAAAAAQBoCdQAAAAAAAABIQ6AOAAAAAAAAAGkI1AEAAAAAAAAgjSqZLgAA1kdNLhqR6RLWeVOu2z/TJQAAAAAAkOWcoQ4AAAAAAAAAaQjUAQAAAAAAACANgToAAAAAAAAApCFQBwAAAAAAAIA0BOoAAAAAAAAAkIZAHQAAAAAAAADSEKgDAAAAAAAAQBoCdQAAAAAAAABIQ6AOAAAAAAAAAGlUyXQBAACwNjS5aESmS1gvTLlu/0yXAAAAAABlxhnqAAAAAAAAAJCGQB0AAAAAAAAA0hCoAwAAAAAAAEAaAnUAAAAAAAAASEOgDgAAAAAAAABpCNQBAAAAAAAAIA2BOgAAAAAAAACkIVAHAAAAAAAAgDQE6gAAAAAAAACQhkAdAAAAAAAAANIQqAMAAAAAAABAGgJ1AAAAAAAAAEhDoA4AAAAAAAAAaQjUAQAAAAAAACANgToAAAAAAAAApCFQBwAAAAAAAIA0BOoAAAAAAAAAkIZAHQAAAAAAAADSEKgDAAAAAAAAQBoCdQAAAAAAAABIQ6AOAAAAAAAAAGkI1AEAAAAAAAAgDYE6AAAAAAAAAKQhUAcAAAAAAACANATqAAAAAAAAAJCGQB0AAAAAAAAA0hCoAwAAAAAAAEAaAnUAAAAAAAAASEOgDgAAAAAAAABpCNQBAAAAAAAAIA2BOgAAAAAAAACkIVAHAAAAAAAAgDQE6gAAAAAAAACQhkAdAAAAAAAAANIQqAMAAAAAAABAGhkN1Pv16xc77bRT1K5dO+rXrx8HH3xwTJw4sdg6PXv2jFQqVeyxyy67ZKhiAAAAAAAAANYXGQ3Ux44dG6effnq8/fbbMWrUqFi4cGF07tw55s2bV2y9fffdN6ZNm1b0ePHFFzNUMQAAAAAAAADriyqZfPORI0cW+3no0KFRv379+OCDD2KPPfYoWp6TkxN5eXlruzwAAAAAAAAA1mMV6h7qs2fPjoiIunXrFls+ZsyYqF+/fjRv3jxOOumkmDFjxgq3UVhYGHPmzCn2AAAAAAAAAIDSqjCBepIk0bt379h9992jVatWRcu7du0ajzzySIwePTpuuummeO+992LPPfeMwsLCtNvp169f5ObmFj0222yztdUCAAAAAAAAAOuQjF7yfWlnnHFGfPTRR/HGG28UW969e/ei/92qVato27ZtNG7cOEaMGBGHHnroctu5+OKLo3fv3kU/z5kzR6gOAAAAAAAAQKlViED9zDPPjOHDh8drr70WDRs2XOm6+fn50bhx45g0aVLa53NyciInJ6c8ygQAAAAAAABgPZLRQD1JkjjzzDPj2WefjTFjxkTTpk1X+ZqZM2fGN998E/n5+WuhQgAAAAAAAADWVxm9h/rpp58eDz/8cDz66KNRu3btmD59ekyfPj3mz58fERG//PJLnHfeeTFu3LiYMmVKjBkzJrp16xb16tWLQw45JJOlAwAAAAAAALCOy+gZ6oMGDYqIiI4dOxZbPnTo0OjZs2dUrlw5Pv7443jwwQfj559/jvz8/OjUqVM88cQTUbt27QxUDAAAAAAAAMD6IuOXfF+Z6tWrx8svv7yWqgEAAAAAAACA/5PRS74DAAAAAAAAQEUlUAcAAAAAAACANATqAAAAAAAAAJCGQB0AAAAAAAAA0hCoAwAAAAAAAEAaAnUAAAAAAAAASEOgDgAAAAAAAABpCNQBAAAAAAAAIA2BOgAAAAAAAACkIVAHAAAAAAAAgDQE6gAAAAAAAACQhkAdAAAAAAAAANIQqAMAAAAAAABAGgJ1AAAAAAAAAEhDoA4AAAAAAAAAaQjUAQAAAAAAACANgToAAAAAAAAApCFQBwAAAAAAAIA0BOoAAAAAAAAAkIZAHQAAAAAAAADSEKgDAAAAAAAAQBoCdQAAAAAAAABIQ6AOAAAAAAAAAGkI1AEAAAAAAAAgDYE6AAAAAAAAAKQhUAcAAAAAAACANATqAAAAAAAAAJBGlUwXAACQTZpcNCLTJazzply3f6ZLAAAAAACICGeoAwAAAAAAAEBaAnUAAAAAAAAASMMl32E959LF5c+liwEAAAAAALKTM9QBAAAAAAAAIA2BOgAAAAAAAACkIVAHAAAAAAAAgDQE6gAAAAAAAACQhkAdAAAAAAAAANIQqAMAAAAAAABAGgJ1AAAAAAAAAEhDoA4AAAAAAAAAaQjUAQAAAAAAACANgToAAAAAAAAApCFQBwAAAAAAAIA0BOoAAAAAAAAAkIZAHQAAAAAAAADSEKgDAAAAAAAAQBoCdQAAAAAAAABIQ6AOAAAAAAAAAGkI1AEAAAAAAAAgDYE6AAAAAAAAAKQhUAcAAAAAAACANATqAAAAAAAAAJCGQB0AAAAAAAAA0shooN6vX7/Yaaedonbt2lG/fv04+OCDY+LEicXWSZIk+vTpEwUFBVG9evXo2LFjfPrppxmqGAAAAAAAAID1RUYD9bFjx8bpp58eb7/9dowaNSoWLlwYnTt3jnnz5hWt079//xgwYEDcfvvt8d5770VeXl7ss88+MXfu3AxWDgAAAAAAAMC6rkom33zkyJHFfh46dGjUr18/Pvjgg9hjjz0iSZK45ZZb4tJLL41DDz00IiIeeOCBaNCgQTz66KNx8sknZ6JsAAAAAAAAANYDFeoe6rNnz46IiLp160ZExOTJk2P69OnRuXPnonVycnKiQ4cO8dZbb6XdRmFhYcyZM6fYAwAAAAAAAABKq8IE6kmSRO/evWP33XePVq1aRUTE9OnTIyKiQYMGxdZt0KBB0XPL6tevX+Tm5hY9Nttss/ItHAAAAAAAAIB1UoUJ1M8444z46KOP4rHHHlvuuVQqVeznJEmWW7bExRdfHLNnzy56fPPNN+VSLwAAAAAAAADrtozeQ32JM888M4YPHx6vvfZaNGzYsGh5Xl5eRPxxpnp+fn7R8hkzZix31voSOTk5kZOTU74FAwAAAAAAALDOy+gZ6kmSxBlnnBHPPPNMjB49Opo2bVrs+aZNm0ZeXl6MGjWqaNlvv/0WY8eOjfbt26/tcgEAAAAAAABYj2T0DPXTTz89Hn300Xjuueeidu3aRfdFz83NjerVq0cqlYqzzz47+vbtG82aNYtmzZpF3759o0aNGnH00UdnsnQAAAAAAAAA1nEZDdQHDRoUEREdO3Ystnzo0KHRs2fPiIi44IILYv78+XHaaafFrFmzol27dvHKK69E7dq113K1AAAAAAAAAKxPMhqoJ0myynVSqVT06dMn+vTpU/4FAQAAAAAAAMD/l9FAHYDV1+SiEZkuYZ035br9M10CAAAAAACQQZUyXQAAAAAAAAAAVEQCdQAAAAAAAABIQ6AOAAAAAAAAAGkI1AEAAAAAAAAgDYE6AAAAAAAAAKQhUAcAAAAAAACANATqAAAAAAAAAJCGQB0AAAAAAAAA0hCoAwAAAAAAAEAaAnUAAAAAAAAASEOgDgAAAAAAAABpCNQBAAAAAAAAIA2BOgAAAAAAAACkIVAHAAAAAAAAgDQE6gAAAAAAAACQxmoF6q+//noce+yxseuuu8Z3330XEREPPfRQvPHGG2VaHAAAAAAAAABkSqkD9aeffjq6dOkS1atXj/Hjx0dhYWFERMydOzf69u1b5gUCAAAAAAAAQCaUOlD/+9//HnfddVfce++9scEGGxQtb9++fXz44YdlWhwAAAAAAAAAZEqpA/WJEyfGHnvssdzyOnXqxM8//1wWNQEAAAAAAABAxpU6UM/Pz48vv/xyueVvvPFGbL755mVSFAAAAAAAAABkWqkD9ZNPPjn+9re/xTvvvBOpVCq+//77eOSRR+K8886L0047rTxqBAAAAAAAAIC1rkppX3DBBRfE7Nmzo1OnTrFgwYLYY489IicnJ84777w444wzyqNGAAAAAAAAAFjrSh2oR0Rce+21cemll8Znn30Wixcvjm222SZq1apV1rUBAAAAAAAAQMasVqAeEVGjRo1o27ZtWdYCAAAAAAAAABVGqQP1BQsWxG233RavvvpqzJgxIxYvXlzs+Q8//LDMigMAAAAAAACATCl1oN6rV68YNWpUHH744bHzzjtHKpUqj7oAAAAAAAAAIKNKHaiPGDEiXnzxxdhtt93Kox4AAAAAAAAAqBAqlfYFm266adSuXbs8agEAAAAAAACACqPUgfpNN90UF154YXz99dflUQ8AAAAAAAAAVAilvuR727ZtY8GCBbH55ptHjRo1YoMNNij2/E8//VRmxQEAAAAAAABAppQ6UD/qqKPiu+++i759+0aDBg0ilUqVR10AAAAAAAAAkFGlDtTfeuutGDduXLRp06Y86gEAAAAAAACACqHU91Bv0aJFzJ8/vzxqAQAAAAAAAIAKo9SB+nXXXRfnnntujBkzJmbOnBlz5swp9gAAAAAAAACAdUGpL/m+7777RkTEXnvtVWx5kiSRSqVi0aJFZVMZAAAAAAAAAGRQqQP1V199tTzqAAAAAAAAAIAKpdSBeocOHcqjDgAAAAAAAACoUEodqL/22msrfX6PPfZY7WIAAAAAAAAAoKIodaDesWPH5ZalUqmi/+0e6gAAAAAAAACsCyqV9gWzZs0q9pgxY0aMHDkydtppp3jllVfKo0YAAAAAAAAAWOtKfYZ6bm7ucsv22WefyMnJiXPOOSc++OCDMikMAAAAAAAAADKp1Geor8gmm2wSEydOLKvNAQAAAAAAAEBGlfoM9Y8++qjYz0mSxLRp0+K6666LNm3alFlhAAAAAAAAAJBJpQ7Ut9tuu0ilUpEkSbHlu+yySwwZMqTMCgMAAAAAAACATCp1oD558uRiP1eqVCk22WSTqFatWpkVBQAAAAAAAACZVupAvXHjxuVRBwAAAAAAAABUKCUK1AcOHFjiDZ511lmrXQwAAAAAAAAAVBQlCtRvvvnmEm0slUoJ1AEAAAAAAABYJ5QoUF/2vukAAAAAAAAAsK6rtCYvTpIkkiQpq1oAAAAAAAAAoMJYrUD9wQcfjG233TaqV68e1atXj9atW8dDDz1U1rUBAAAAAAAAQMaU6JLvSxswYEBcfvnlccYZZ8Ruu+0WSZLEm2++Gaecckr873//i3POOac86gQAAAAAAACAtarUZ6jfdtttMWjQoLj++uvjwAMPjIMOOij69+8fd955ZwwcOLBU23rttdeiW7duUVBQEKlUKoYNG1bs+Z49e0YqlSr22GWXXUpbMgAAAAAAAACUWqkD9WnTpkX79u2XW96+ffuYNm1aqbY1b968aNOmTdx+++0rXGffffeNadOmFT1efPHF0pYMAAAAAAAAAKVW6ku+b7nllvHkk0/GJZdcUmz5E088Ec2aNSvVtrp27Rpdu3Zd6To5OTmRl5dX2jIBAAAAAAAAYI2UOlC/6qqronv37vHaa6/FbrvtFqlUKt54443417/+FU8++WSZFzhmzJioX79+bLjhhtGhQ4e49tpro379+itcv7CwMAoLC4t+njNnTpnXBAAAAAAAAMC6r9SXfD/ssMPinXfeiXr16sWwYcPimWeeiXr16sW7774bhxxySJkW17Vr13jkkUdi9OjRcdNNN8V7770Xe+65Z7HAfFn9+vWL3Nzcosdmm21WpjUBAAAAAAAAsH4o9RnqERE77rhjPPzww2Vdy3K6d+9e9L9btWoVbdu2jcaNG8eIESPi0EMPTfuaiy++OHr37l3085w5c4TqAAAAAAAAAJRaqc9Q79SpUwwePDhmz55dHvWsVH5+fjRu3DgmTZq0wnVycnKiTp06xR4AAAAAAAAAUFqlDtS33XbbuOyyyyIvLy8OO+ywGDZsWPz222/lUdtyZs6cGd98803k5+evlfcDAAAAAAAAYP1V6kB94MCB8d1338Vzzz0XtWvXjh49ekReXl789a9/jbFjx5ZqW7/88ktMmDAhJkyYEBERkydPjgkTJsTUqVPjl19+ifPOOy/GjRsXU6ZMiTFjxkS3bt2iXr16ZX6vdgAAAAAAAABYVqkD9YiISpUqRefOneP++++PH374Ie6+++549913Y8899yzVdt5///3YfvvtY/vtt4+IiN69e8f2228fV1xxRVSuXDk+/vjjOOigg6J58+bRo0ePaN68eYwbNy5q1669OmUDAAAAAAAAQIlVWZMXT58+PR5//PF4+OGH46OPPoqddtqpVK/v2LFjJEmywudffvnlNSkPAAAAAAAAAFZbqc9QnzNnTgwdOjT22Wef2GyzzWLQoEHRrVu3+OKLL+Kdd94pjxoBAAAAAAAAYK0r9RnqDRo0iI022iiOOOKI6Nu3b6nPSgcAAAAAAACAbFDqQP25556LvffeOypVWq3brwMAAAAAAABAVih1oN65c+fyqAMAAAAAAAAAKhSnmQMAAAAAAABAGgJ1AAAAAAAAAEhDoA4AAAAAAAAAaQjUAQAAAAAAACCNKqV9wcCBA9MuT6VSUa1atdhyyy1jjz32iMqVK69xcQAAAAAAAACQKaUO1G+++eb48ccf49dff42NNtookiSJn3/+OWrUqBG1atWKGTNmxOabbx6vvvpqbLbZZuVRMwAAAAAAAACUu1Jf8r1v376x0047xaRJk2LmzJnx008/xRdffBHt2rWLW2+9NaZOnRp5eXlxzjnnlEe9AAAAAAAAALBWlPoM9csuuyyefvrp2GKLLYqWbbnllnHjjTfGYYcdFl999VX0798/DjvssDItFAAAAAAAAADWplKfoT5t2rRYuHDhcssXLlwY06dPj4iIgoKCmDt37ppXBwAAAAAAAAAZUupAvVOnTnHyySfH+PHji5aNHz8+Tj311Nhzzz0jIuLjjz+Opk2bll2VAAAAAAAAALCWlTpQHzx4cNStWzd23HHHyMnJiZycnGjbtm3UrVs3Bg8eHBERtWrViptuuqnMiwUAAAAAAACAtaXU91DPy8uLUaNGxX/+85/44osvIkmSaNGiRWy11VZF63Tq1KlMiwQAAAAAAACAta3UgfrYsWOjQ4cO0aJFi2jRokV51AQAAFBMk4tGZLqEdd6U6/bPdAkAAAAAFU6pL/m+zz77RKNGjeKiiy6KTz75pDxqAgAAAAAAAICMK3Wg/v3338cFF1wQr7/+erRu3Tpat24d/fv3j2+//bY86gMAAAAAAACAjCh1oF6vXr0444wz4s0334z//ve/0b1793jwwQejSZMmseeee5ZHjQAAAAAAAACw1pU6UF9a06ZN46KLLorrrrsutt122xg7dmxZ1QUAAAAAAAAAGbXagfqbb74Zp512WuTn58fRRx8dLVu2jBdeeKEsawMAAAAAAACAjKlS2hdccskl8dhjj8X3338fe++9d9xyyy1x8MEHR40aNcqjPgAAAAAAAADIiFIH6mPGjInzzjsvunfvHvXq1Sv23IQJE2K77bYrq9oAAAAAAAAAIGNKHai/9dZbxX6ePXt2PPLII3HffffFv//971i0aFGZFQcAAAAAAAAAmbLa91AfPXp0HHvssZGfnx+33XZb7LfffvH++++XZW0AAAAAAAAAkDGlOkP922+/jfvvvz+GDBkS8+bNiyOOOCJ+//33ePrpp2ObbbYprxoBAAAAAAAAYK0r8Rnq++23X2yzzTbx2WefxW233Rbff/993HbbbeVZGwAAAAAAAABkTInPUH/llVfirLPOilNPPTWaNWtWnjUBAAAAAAAAQMaV+Az1119/PebOnRtt27aNdu3axe233x4//vhjedYGAAAAAAAAABlT4kB91113jXvvvTemTZsWJ598cjz++OOx6aabxuLFi2PUqFExd+7c8qwTAAAAAAAAANaqEgfqS9SoUSN69eoVb7zxRnz88cdx7rnnxnXXXRf169ePAw88sDxqBAAAAAAAAIC1rtSB+tK22mqr6N+/f3z77bfx2GOPlVVNAAAAAAAAAJBxaxSoL1G5cuU4+OCDY/jw4WWxOQAAAAAAAADIuDIJ1AEAAAAAAABgXSNQBwAAAAAAAIA0BOoAAAAAAAAAkIZAHQAAAAAAAADSEKgDAAAAAAAAQBoCdQAAAAAAAABIQ6AOAAAAAAAAAGkI1AEAAAAAAAAgDYE6AAAAAAAAAKQhUAcAAAAAAACANATqAAAAAAAAAJCGQB0AAAAAAAAA0hCoAwAAAAAAAEAaAnUAAAAAAAAASEOgDgAAAAAAAABpCNQBAAAAAAAAIA2BOgAAAAAAAACkIVAHAAAAAAAAgDQyGqi/9tpr0a1btygoKIhUKhXDhg0r9nySJNGnT58oKCiI6tWrR8eOHePTTz/NTLEAAAAAAAAArFcyGqjPmzcv2rRpE7fffnva5/v37x8DBgyI22+/Pd57773Iy8uLffbZJ+bOnbuWKwUAAAAAAABgfVMlk2/etWvX6Nq1a9rnkiSJW265JS699NI49NBDIyLigQceiAYNGsSjjz4aJ5988tosFQAAAAAAAID1TIW9h/rkyZNj+vTp0blz56JlOTk50aFDh3jrrbdW+LrCwsKYM2dOsQcAAAAAAAAAlFaFDdSnT58eERENGjQotrxBgwZFz6XTr1+/yM3NLXpsttlm5VonAAAAAAAAAOumChuoL5FKpYr9nCTJcsuWdvHFF8fs2bOLHt988015lwgAAAAAAADAOiij91Bfmby8vIj440z1/Pz8ouUzZsxY7qz1peXk5EROTk651wcAAAAAAADAuq3CBupNmzaNvLy8GDVqVGy//fYREfHbb7/F2LFj4/rrr89wdQAAALDua3LRiEyXsM6bct3+mS4BAACAlchooP7LL7/El19+WfTz5MmTY8KECVG3bt1o1KhRnH322dG3b99o1qxZNGvWLPr27Rs1atSIo48+OoNVAwAAAAAAALA+yGig/v7770enTp2Kfu7du3dERPTo0SPuv//+uOCCC2L+/Plx2mmnxaxZs6Jdu3bxyiuvRO3atTNVMgAAAAAAAADriYwG6h07dowkSVb4fCqVij59+kSfPn3WXlEAAAAAAAAAEBGVMl0AAAAAAAAAAFREAnUAAAAAAAAASEOgDgAAAAAAAABpCNQBAAAAAAAAIA2BOgAAAAAAAACkIVAHAAAAAAAAgDQE6gAAAAAAAACQhkAdAAAAAAAAANIQqAMAAAAAAABAGgJ1AAAAAAAAAEhDoA4AAAAAAAAAaQjUAQAAAAAAACANgToAAAAAAAAApCFQBwAAAAAAAIA0BOoAAAAAAAAAkIZAHQAAAAAAAADSEKgDAAAAAAAAQBoCdQAAAAAAAABIo0qmCwAAAACgbDW5aESmS1gvTLlu/0yXAAAAlDOBOgAAAAAA6z1/jFT+/CESANnIJd8BAAAAAAAAIA2BOgAAAAAAAACkIVAHAAAAAAAAgDQE6gAAAAAAAACQhkAdAAAAAAAAANIQqAMAAAAAAABAGgJ1AAAAAAAAAEhDoA4AAAAAAAAAaQjUAQAAAAAAACANgToAAAAAAAAApCFQBwAAAAAAAIA0BOoAAAAAAAAAkIZAHQAAAAAAAADSEKgDAAAAAAAAQBoCdQAAAAAAAABIQ6AOAAAAAAAAAGkI1AEAAAAAAAAgDYE6AAAAAAAAAKQhUAcAAAAAAACANATqAAAAAAAAAJCGQB0AAAAAAAAA0hCoAwAAAAAAAEAaAnUAAAAAAAAASEOgDgAAAAAAAABpCNQBAAAAAAAAIA2BOgAAAAAAAACkIVAHAAAAAAAAgDQE6gAAAAAAAACQhkAdAAAAAAAAANIQqAMAAAAAAABAGgJ1AAAAAAAAAEhDoA4AAAAAAAAAaVToQL1Pnz6RSqWKPfLy8jJdFgAAAAAAAADrgSqZLmBVWrZsGf/85z+Lfq5cuXIGqwEAAAAAAABgfVHhA/UqVao4Kx0AAAAAAACAta5CX/I9ImLSpElRUFAQTZs2jSOPPDK++uqrla5fWFgYc+bMKfYAAAAAAAAAgNKq0IF6u3bt4sEHH4yXX3457r333pg+fXq0b98+Zs6cucLX9OvXL3Jzc4sem2222VqsGAAAAAAAAIB1RYUO1Lt27RqHHXZYbLvttrH33nvHiBEjIiLigQceWOFrLr744pg9e3bR45tvvllb5QIAAAAAAACwDqnw91BfWs2aNWPbbbeNSZMmrXCdnJycyMnJWYtVAQAAAAAAALAuqtBnqC+rsLAwPv/888jPz890KQAAAAAAAACs4yp0oH7eeefF2LFjY/LkyfHOO+/E4YcfHnPmzIkePXpkujQAAAAAAAAA1nEV+pLv3377bRx11FHxv//9LzbZZJPYZZdd4u23347GjRtnujQAAAAAAAAA1nEVOlB//PHHM10CAAAAAAAAAOupCn3JdwAAAAAAAADIFIE6AAAAAAAAAKQhUAcAAAAAAACANATqAAAAAAAAAJBGlUwXAAAAAAAAsLqaXDQi0yWsF6Zct3+mSwDICGeoAwAAAAAAAEAaAnUAAAAAAAAASEOgDgAAAAAAAABpCNQBAAAAAAAAIA2BOgAAAAAAAACkIVAHAAAAAAAAgDQE6gAAAAAAAACQhkAdAAAAAAAAANIQqAMAAAAAAABAGgJ1AAAAAAAAAEhDoA4AAAAAAAAAaQjUAQAAAAAAACCNKpkuAAAAAAAAgPVTk4tGZLqEdd6U6/bPdAmQ1ZyhDgAAAAAAAABpCNQBAAAAAAAAIA2BOgAAAAAAAACkIVAHAAAAAAAAgDQE6gAAAAAAAACQhkAdAAAAAAAAANIQqAMAAAAAAABAGgJ1AAAAAAAAAEhDoA4AAAAAAAAAaQjUAQAAAAAAACANgToAAAAAAAAApCFQBwAAAAAAAIA0BOoAAAAAAAAAkIZAHQAAAAAAAADSEKgDAAAAAAAAQBoCdQAAAAAAAABIQ6AOAAAAAAAAAGkI1AEAAAAAAAAgDYE6AAAAAAAAAKQhUAcAAAAAAACANATqAAAAAAAAAJCGQB0AAAAAAAAA0hCoAwAAAAAAAEAaAnUAAAAAAAAASEOgDgAAAAAAAABpCNQBAAAAAAAAIA2BOgAAAAAAAACkIVAHAAAAAAAAgDQE6gAAAAAAAACQhkAdAAAAAAAAANIQqAMAAAAAAABAGgJ1AAAAAAAAAEhDoA4AAAAAAAAAaQjUAQAAAAAAACANgToAAAAAAAAApJEVgfqdd94ZTZs2jWrVqsWOO+4Yr7/+eqZLAgAAAAAAAGAdV+ED9SeeeCLOPvvsuPTSS2P8+PHxpz/9Kbp27RpTp07NdGkAAAAAAAAArMMqfKA+YMCAOPHEE+Mvf/lLbL311nHLLbfEZpttFoMGDcp0aQAAAAAAAACsw6pkuoCV+e233+KDDz6Iiy66qNjyzp07x1tvvZX2NYWFhVFYWFj08+zZsyMiYs6cOeVX6Hqu1ZUvZ7qEdd4nV3Upt20vLvy13LbNH8rr+8fsyl95/tthfuXPZy97mV12M7/s5b+ZSMdnr/z53sxuvjth3eK7s/z5dy+7mV/28v9ZIL0ln40kSVa6XipZ1RoZ9P3338emm24ab775ZrRv375oed++feOBBx6IiRMnLveaPn36xFVXXbU2ywQAAAAAAAAgC33zzTfRsGHDFT5foc9QXyKVShX7OUmS5ZYtcfHFF0fv3r2Lfl68eHH89NNPsfHGG6/wNaxf5syZE5tttll88803UadOnUyXQymYXXYzv+xldtnN/LKX2WU388teZpfdzC97mV32MrvsZn7Zy+yym/llL7PLbubHspIkiblz50ZBQcFK16vQgXq9evWicuXKMX369GLLZ8yYEQ0aNEj7mpycnMjJySm2bMMNNyyvEsliderU8YWZpcwuu5lf9jK77GZ+2cvsspv5ZS+zy27ml73MLnuZXXYzv+xldtnN/LKX2WU382Npubm5q1yn0lqoY7VVrVo1dtxxxxg1alSx5aNGjSp2CXgAAAAAAAAAKGsV+gz1iIjevXvHcccdF23bto1dd9017rnnnpg6dWqccsopmS4NAAAAAAAAgHVYhQ/Uu3fvHjNnzoyrr746pk2bFq1atYoXX3wxGjdunOnSyFI5OTlx5ZVXLndrACo+s8tu5pe9zC67mV/2MrvsZn7Zy+yym/llL7PLXmaX3cwve5lddjO/7GV22c38WF2pJEmSTBcBAAAAAAAAABVNhb6HOgAAAAAAAABkikAdAAAAAAAAANIQqAMAAAAAAABAGgJ1YJ3Us2fPOPjggzNdBqvJ/LKX2WU388teZpfdzC97mV12M7/sZXbZy+yym/llL7PLbuaXvcwuu5kfSxOos0678847o2nTplGtWrXYcccd4/XXXy967plnnokuXbpEvXr1IpVKxYQJEzJXaAW3PuzHlfX4+++/x4UXXhjbbrtt1KxZMwoKCuL444+P77//PoMVl9yKesv2vpa2svlFRPTp0ydatGgRNWvWjI022ij23nvveOeddzJUbcmtrK9s7WlZq5rd0k4++eRIpVJxyy23rL0C10BJe8u2vpa2qh579uwZqVSq2GOXXXbJULUlt7K+srWnZZXk+Pz888/jwAMPjNzc3Khdu3bssssuMXXq1AxUWzqr6i1b+1raqnpc9hhd8rjhhhsyVHHJmF3EL7/8EmeccUY0bNgwqlevHltvvXUMGjQoQ9WWzsp6y9Zjclnr6vxW1le29rSsVc3uhx9+iJ49e0ZBQUHUqFEj9t1335g0aVKGqi25dX12r732WnTr1i0KCgoilUrFsGHDllsnSZLo06dPFBQURPXq1aNjx47x6aefrv1iV4P5Ze/vlFY2u2z9Plna+vzZW1/ml42fvVX1lc3H5BLr6uwiVt1btva1tFX1uC79Ln59JVBnnfXEE0/E2WefHZdeemmMHz8+/vSnP0XXrl2Lfuk2b9682G233eK6667LcKUV2/qwH1fV46+//hoffvhhXH755fHhhx/GM888E1988UUceOCBGa581VbWWzb3tbRVzS8ionnz5nH77bfHxx9/HG+88UY0adIkOnfuHD/++GMGK1+5VfWVjT0tqySzW2LYsGHxzjvvREFBQQYqLb2S9pZtfS2tpD3uu+++MW3atKLHiy++mKGKS6YkfWVbT8sqSY///e9/Y/fdd48WLVrEmDFj4t///ndcfvnlUa1atQxWvmqr6i1b+1paSea39PE5bdq0GDJkSKRSqTjssMMyWPnKmd0fzjnnnBg5cmQ8/PDD8fnnn8c555wTZ555Zjz33HMZrHzVVtVbNh6Ty1pX57eqvrKxp2WtqsckSeLggw+Or776Kp577rkYP358NG7cOPbee++YN29ehqtfsfVhdvPmzYs2bdrE7bffvsJ1+vfvHwMGDIjbb7893nvvvcjLy4t99tkn5s6duxYrLT3z+791su13SiubXbZ+nyxrff3srU/zy8bP3qr6ytZjcmnr6uwiVt1btva1tFX1uK78Ln69lsA6auedd05OOeWUYstatGiRXHTRRcWWTZ48OYmIZPz48WuxuuxR3vvxpptuSlq1apXUqFEjadiwYXLqqacmc+fOLXp+6NChSW5ubjJy5MikRYsWSc2aNZMuXbok33//fdE6CxcuTM4555wkNzc3qVu3bnL++ecnxx9/fHLQQQeVaY9Le/fdd5OISL7++utS9bu2lba30vaVrfObPXt2EhHJP//5zxK9RyaUtq/S9pRNs/v222+TTTfdNPnkk0+Sxo0bJzfffHOJtp9JJeltTfrKlvn16NGjxNurKFbV15r2lC2z6969e3Lssceudp+Zsqre1rSvbJnfsg466KBkzz33LF2za5nZ/aFly5bJ1VdfXWydHXbYIbnssstWo+u1p7THZWmPSfMrP6vqa017yobZTZw4MYmI5JNPPin2nnXr1k3uvffeEr1HJqwPs1taRCTPPvtssWWLFy9O8vLykuuuu65o2YIFC5Lc3NzkrrvuKvV7rE3mV1w2/W5uZbMri++TbJjduvrZW1/mt7Rs+uwtbdm+yuKYNLu1Z2W9ZXPGUNIel5YtGQN/cIY666TffvstPvjgg+jcuXOx5Z07d4633norQ1Vln7WxHytVqhQDBw6MTz75JB544IEYPXp0XHDBBcXW+fXXX+PGG2+Mhx56KF577bWYOnVqnHfeeUXP33TTTTFkyJAYPHhwvPHGG/HTTz/Fs88+W6L3X90eZ8+eHalUKjbccMOSN7uWrU5vpe0rG+f322+/xT333BO5ubnRpk2bEr3P2lbavlanp2yZ3eLFi+O4446L888/P1q2bFmibWdaSXpb076yZX4REWPGjIn69etH8+bN46STTooZM2aUut+1paR9rUlP2TC7xYsXx4gRI6J58+bRpUuXqF+/frRr1y7t5eYqklX1VhZ9ZcP8lvXDDz/EiBEj4sQTTyxxn2ub2f3f7HbfffcYPnx4fPfdd5EkSbz66qvxxRdfRJcuXUrc69pW2uNydY5J8ysfJelrTXvKhtkVFhZGRBS74kXlypWjatWq8cYbb5Tofda29WF2JTF58uSYPn16sf2Qk5MTHTp0qNC/+zG/7LWq2ZXF90k2zG5d/eytL/NbF5XFMWl22S1b55cNGQNLyWicD+Xku+++SyIiefPNN4stv/baa5PmzZsXW5bNf81V3jKxH5988slk4403Lvp56NChSUQkX375ZdGyO+64I2nQoEHRz/n5+cX+AvH3339PGjZsWKK/HitNj0vMnz8/2XHHHZNjjjmmpG1lRGl7K4u+KvL8nn/++aRmzZpJKpVKCgoKknfffbe07a01Je2rLHuqqLPr27dvss8++ySLFy9OkiTJijPUS9JbWfdVUef3+OOPJy+88ELy8ccfJ8OHD0/atGmTtGzZMlmwYMHqtFnuStJXWfdUEWc3bdq0JCKSGjVqJAMGDEjGjx+f9OvXL0mlUsmYMWNWq8+1YVW9lUdfFXF+y7r++uuTjTbaKJk/f35J21rrzO7/ZldYWJgcf/zxSUQkVapUSapWrZo8+OCDq9PiWlPa47IsjknzKxsl6ause6qIs/vtt9+Sxo0bJ3/+85+Tn376KSksLEz69euXRETSuXPn1W21XK0Ps1tWpDnT680330wiIvnuu++KLT/ppJMq7OySxPzSyZbfza1qduXxfVIRZ7eufvbWl/ktLVs+e8tatq/yOCbNrvysrLdszRiWtar5JUn2ZAz8nyprGshDRZZKpYr9nCTJcstYtfLcj6+++mr07ds3Pvvss5gzZ04sXLgwFixYEPPmzYuaNWtGRESNGjViiy22KHpNfn5+0dmAs2fPjmnTpsWuu+5a9HyVKlWibdu2kSRJiesoaY+///57HHnkkbF48eK48847S9VrppSkt9XtK5vm16lTp5gwYUL873//i3vvvTeOOOKIeOedd6J+/folfp+1bVV9rUlP2TC7Dz74IG699db48MMPs/K7e0W9lUVf2TC/iIju3bsX/e9WrVpF27Zto3HjxjFixIg49NBDS9f0WrSyvta0p2yY3eLFiyMi4qCDDopzzjknIiK22267eOutt+Kuu+6KDh06lPh9MmFFvZVFX9kwv2UNGTIkjjnmmKy417jZRQwcODDefvvtGD58eDRu3Dhee+21OO200yI/Pz/23nvvEr9PJpT0uFydY9L8ytfK+lrTnrJhdhtssEE8/fTTceKJJ0bdunWjcuXKsffee0fXrl1LvP1MWR9mVxLZ+rsf88teK5pdWXyfZNPs1rXP3vo2v3XRmhyTZpfdsm1+2ZgxEOGS76yT6tWrF5UrV47p06cXWz5jxoxo0KBBhqrKPuW9H7/++uvYb7/9olWrVvH000/HBx98EHfccUdE/PGPyhIbbLBBsdelUqky+4esND3+/vvvccQRR8TkyZNj1KhRUadOnTKpobyUtLfV7Svb5lezZs3YcsstY5dddonBgwdHlSpVYvDgwWVSR1kraV+r21O2zO7111+PGTNmRKNGjaJKlSpRpUqV+Prrr+Pcc8+NJk2alEkd5WFVva1pX9kyv3Ty8/OjcePGMWnSpDKpo6ytTl+l6SlbZlevXr2oUqVKbLPNNsXW2XrrrWPq1KllUkd5WFVva9pXtsxvaa+//npMnDgx/vKXv5TJ+5cXs/tjdvPnz49LLrkkBgwYEN26dYvWrVvHGWecEd27d48bb7yxTOooD6U5LlfnmDS/8rOqvta0p2yZXUTEjjvuGBMmTIiff/45pk2bFiNHjoyZM2dG06ZNy6SOsrY+zK4k8vLyIiKy7nc/5pe9SvKdsibfJ9kyu3X1sxexfsxvXbSmx6TZZbdsm1+2ZQz8H4E666SqVavGjjvuGKNGjSq2fNSoUdG+ffsMVZV9yns/vv/++7Fw4cK46aabYpdddonmzZvH999/X6pt5ObmRn5+frz99ttFyxYuXBgffPBBiV5f0h6X/EM3adKk+Oc//xkbb7xxqerMhJL0tiZ9ZdP80kmSpOj+WBXN6vZV0p6yZXbHHXdcfPTRRzFhwoSiR0FBQZx//vnx8ssvl6retWlVva1pX9kyv3RmzpwZ33zzTeTn55eq3rVldfoqTU/ZMruqVavGTjvtFBMnTiy2zhdffBGNGzcuVb1r06p6W9O+smV+Sxs8eHDsuOOO0aZNm1LVubaZ3f/9/7Lff/89KlUq/p/plStXLjpLvyIqzXG5Osek+ZWfVfW1pj1ly+yWfb9NNtkkJk2aFO+//34cdNBBpap3bVkfZlcSTZs2jby8vGL74bfffouxY8dW6N/9mF/2Ks13yup8n2TL7NbVz97S1uX5rYvW9Jg0u+yWTfPLxoyB/+OS76yzevfuHccdd1y0bds2dt1117jnnnti6tSpccopp0RExE8//RRTp04t+nJd8gu6vLy8or9qo3z34xZbbBELFy6M2267Lbp16xZvvvlm3HXXXaWu8W9/+1tcd9110axZs9h6661jwIAB8fPPP5dZjwsXLozDDz88Pvzww3jhhRdi0aJFRX/xWLdu3ahatWqpa15bVtbbmvaVLfObN29eXHvttXHggQdGfn5+zJw5M+6888749ttv489//nOp611bVtbXmvaULbPbeOONl/s/lhtssEHk5eXFVlttVep616aV9bamfWXL/H755Zfo06dPHHbYYZGfnx9TpkyJSy65JOrVqxeHHHJIqetdW1bW15r2lC2zi4g4//zzo3v37rHHHntEp06dYuTIkfH888/HmDFjSl3v2rSq3takr2yaX0TEnDlz4qmnnoqbbrqp1DVmgtlF1KlTJzp06BDnn39+VK9ePRo3bhxjx46NBx98MAYMGFDqetemkhyXq3tMml/5Wllfa9pTtswuIuKpp56KTTbZJBo1ahQff/xx/O1vf4uDDz44OnfuXOp615b1YXa//PJLfPnll0U/T548OSZMmBB169aNRo0aRSqVirPPPjv69u0bzZo1i2bNmkXfvn2jRo0acfTRR5e63rXJ/BpFRHb+bm5V3ylr8n2SLbNbVz97EevH/CKy87O3qr7W5Jg0u/K3qt7WhYxhVT1mc8bA/1dWN2OHiuiOO+5IGjdunFStWjXZYYcdkrFjxxY9N3To0CQilntceeWVmSu4girP/ThgwIAkPz8/qV69etKlS5fkwQcfTCIimTVrVtH2c3Nzi73m2WefTZb++vr999+Tv/3tb0mdOnWSDTfcMOndu3dy/PHHJwcddFCZ9Dh58uS0PUZE8uqrr5b4PTJlRb2VRV/ZML/58+cnhxxySFJQUJBUrVo1yc/PTw488MDk3XffLfH2M2VFfZVFT9kwu3QaN26c3HzzzSXefiaVprfS9pUN8/v111+Tzp07J5tsskmywQYbJI0aNUp69OiRTJ06tcTbz5QV9VUWPWXD7JYYPHhwsuWWWybVqlVL2rRpkwwbNqzE28+kVfW2Jn1l0/zuvvvupHr16snPP/9c4u1mmtklybRp05KePXsmBQUFSbVq1ZKtttoquemmm5LFixeX+D0yZVW9rckxaX7la2V9rWlP2TK7W2+9NWnYsGHRv++XXXZZUlhYWOLtZ8q6PrtXX3017X+v9ujRo2idxYsXJ1deeWWSl5eX5OTkJHvssUfy8ccfl2j7mWZ+2fu7uZXNbk2/T7JlduvqZ299mV82fvZW1deaHpNmV75W1du6kDGsqsdszxhIklSSuMkDAAAAAAAAACzLPdQBAAAAAAAAIA2BOlBuHnnkkahVq1baR8uWLddKDVOnTl1hDbVq1YqpU6eulTqykfllL7PLbuaXvcwuu5lf9jK77GZ+2cvsspfZZTfzy15ml93ML3uZXXYzPyoKl3wHys3cuXPjhx9+SPvcBhtsEI0bNy73GhYuXBhTpkxZ4fNNmjSJKlWqlHsd2cj8spfZZTfzy15ml93ML3uZXXYzv+xldtnL7LKb+WUvs8tu5pe9zC67mR8VhUAdAAAAAAAAANJwyXcAAAAAAAAASEOgDgAAAAAAAABpCNQBAAAAAAAAIA2BOgAAAAAAAACkIVAHAACA9cSYMWMilUrFzz//nOlSAAAAICsI1AEAAKAC6NmzZ6RSqUilUlGlSpVo1KhRnHrqqTFr1qwye4/27dvHtGnTIjc3t8y2CQAAAOsygToAAABUEPvuu29MmzYtpkyZEvfdd188//zzcdppp5XZ9qtWrRp5eXmRSqXKbJsAAACwLhOoAwAAQAWRk5MTeXl50bBhw+jcuXN07949XnnllaLnhw4dGltvvXVUq1YtWrRoEXfeeWex17/11lux3XbbRbVq1aJt27YxbNiwSKVSMWHChIhIf8n3p59+Olq2bBk5OTnRpEmTuOmmm4pts0mTJtG3b9/o1atX1K5dOxo1ahT33HNP0fO//fZbnHHGGZGfnx/VqlWLJk2aRL9+/cp+5wAAAEAGCNQBAACgAvrqq69i5MiRscEGG0RExL333huXXnppXHvttfH5559H37594/LLL48HHnggIiLmzp0b3bp1i2233TY+/PDDuOaaa+LCCy9c6Xt88MEHccQRR8SRRx4ZH3/8cfTp0ycuv/zyuP/++4utd9NNN0Xbtm1j/Pjxcdppp8Wpp54a//nPfyIiYuDAgTF8+PB48sknY+LEifHwww9HkyZNynx/AAAAQCZUyXQBAAAAwB9eeOGFqFWrVixatCgWLFgQEREDBgyIiIhrrrkmbrrppjj00EMjIqJp06bx2Wefxd133x09evSIRx55JFKpVNx7771RrVq12GabbeK7776Lk046aYXvN2DAgNhrr73i8ssvj4iI5s2bx2effRY33HBD9OzZs2i9/fbbr+jS8xdeeGHcfPPNMWbMmGjRokVMnTo1mjVrFrvvvnukUqlo3LhxeewaAAAAyAhnqAMAAEAF0alTp5gwYUK88847ceaZZ0aXLl3izDPPjB9//DG++eabOPHEE6NWrVpFj7///e/x3//+NyIiJk6cGK1bt45q1aoVbW/nnXde6ft9/vnnsdtuuxVbtttuu8WkSZNi0aJFRctat25d9L9TqVTk5eXFjBkzIiKiZ8+eMWHChNhqq63irLPOKnaJegAAAMh2AnUAAACoIGrWrBlbbrlltG7dOgYOHBiFhYVx1VVXxeLFiyPij8u+T5gwoejxySefxNtvvx0REUmSRCqVKra9JElW+n4lfc2Sy84vkUqlimraYYcdYvLkyXHNNdfE/Pnz44gjjojDDz+8dI0DAABABSVQBwAAgArqyiuvjBtvvDEWLVoUm266aXz11Vex5ZZbFns0bdo0IiJatGgRH330URQWFha9/v3331/p9rfZZpt44403ii176623onnz5lG5cuUS11mnTp3o3r173HvvvfHEE0/E008/HT/99FMpOgUAAICKyT3UAQAAoILq2LFjtGzZMvr27Rt9+vSJs846K+rUqRNdu3aNwsLCeP/992PWrFnRu3fvOProo+PSSy+Nv/71r3HRRRfF1KlT48Ybb4yIWO4s9CXOPffc2GmnneKaa66J7t27x7hx4+L222+PO++8s8Q13nzzzZGfnx/bbbddVKpUKZ566qnIy8uLDTfcsCx2AQAAAGSUM9QBAACgAuvdu3fce++90aVLl7jvvvvi/vvvj2233TY6dOgQ999/f9EZ6nXq1Innn38+JkyYENttt11ceumlccUVV0REFLuv+tJ22GGHePLJJ+Pxxx+PVq1axRVXXBFXX3119OzZs8T11apVK66//vpo27Zt7LTTTjFlypR48cUXo1Ilv3IAAAAg+6WSVd1QDQAAAMhKjzzySJxwwgkxe/bsqF69eqbLAQAAgKzjku8AAACwjnjwwQdj8803j0033TT+/e9/x4UXXhhHHHGEMB0AAABWk0AdAAAA1hHTp0+PK664IqZPnx75+fnx5z//Oa699tpMlwUAAABZyyXfAQAAAAAAACCNSpkuAAAAAAAAAAAqIoE6AAAAAAAAAKQhUAcAAAAAAACANATqAAAAAAAAAJCGQB0AAAAAAAAA0hCoAwAAAAAAAEAaAnUAAAAAAAAASEOgDgAAAAAAAABp/D/UFziMs7qfYQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -285,30 +410,53 @@ } ], "source": [ - "# Now we do the same thing but for the total volume of lesions per regions\n", - "regions = dataframe.columns\n", - "regions = [str(column) for column in regions if 'total_lesion_volume_between' in column]\n", + "## we do the same thing for the avg volume of lesions\n", + "# we get the column names of the dataframe corresponding to the regions\n", + "regions = df_M0.columns\n", + "regions = [str(column) for column in regions if 'avg_lesion_volume_between' in column or 'avg_lesion_volume_above' in column]\n", "regions = np.sort(regions)\n", - "# print(regions)\n", "\n", - "# we output the hist plot of the distribution of volume of lesions per regions\n", + "# we output the hist plot of the distribution of lesions per regions\n", "plt.figure(figsize=(25, 5))\n", - "legend = [region.split('_',3)[-1] for region in regions]\n", - "plt.bar(legend, dataframe[regions].sum())\n", - "plt.title('Distribution of total volume of lesions per regions')\n", + "legend = [region.split('_',4)[-1] for region in regions]\n", + "plt.bar(legend, df_M0[regions].mean())\n", + "plt.title('Distribution of avg volume of lesions per regions in M0')\n", "plt.xlabel('Regions')\n", - "plt.ylabel('Volume of lesions (mm3)')\n", - "plt.show()" + "plt.ylabel('Avg volume')\n", + "plt.show()\n", + "\n", + "#we output the same thing for M12 \n", + "regions = df_M12.columns\n", + "regions = [str(column) for column in regions if 'avg_lesion_volume_between' in column or 'avg_lesion_volume_above' in column]\n", + "regions = np.sort(regions)\n", + "\n", + "plt.figure(figsize=(25, 5))\n", + "legend = [region.split('_',4)[-1] for region in regions]\n", + "plt.bar(legend, df_M12[regions].mean())\n", + "plt.title('Distribution of avg volume of lesions per regions in M12')\n", + "plt.xlabel('Regions')\n", + "plt.ylabel('Avg volume')\n", + "plt.show()\n" ] }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 180, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -318,30 +466,53 @@ } ], "source": [ - "# Now we do the same thing but for the average volume of lesions per regions\n", - "regions = dataframe.columns\n", - "regions = [str(column) for column in regions if 'avg_lesion_volume_between' in column]\n", + "## we do the same thing for the total volume of lesions\n", + "# we get the column names of the dataframe corresponding to the regions\n", + "regions = df_M0.columns\n", + "regions = [str(column) for column in regions if 'total_lesion_volume_between' in column or 'total_lesion_volume_above' in column]\n", "regions = np.sort(regions)\n", - "# print(regions)\n", "\n", - "# we output the hist plot of the distribution of volume of lesions per regions\n", + "# we output the hist plot of the distribution of lesions per regions\n", "plt.figure(figsize=(25, 5))\n", - "legend = [region.split('_',3)[-1] for region in regions]\n", - "plt.bar(legend, dataframe[regions].sum())\n", - "plt.title('Distribution of average volume of lesions per regions')\n", + "legend = [region.split('_',4)[-1] for region in regions]\n", + "plt.bar(legend, df_M0[regions].sum())\n", + "plt.title('Distribution of total volume of lesions per regions in M0')\n", + "plt.xlabel('Regions')\n", + "plt.ylabel('Total volume')\n", + "plt.show()\n", + "\n", + "#we output the same thing for M12 \n", + "regions = df_M12.columns\n", + "regions = [str(column) for column in regions if 'total_lesion_volume_between' in column or 'total_lesion_volume_above' in column]\n", + "regions = np.sort(regions)\n", + "\n", + "plt.figure(figsize=(25, 5))\n", + "legend = [region.split('_',4)[-1] for region in regions]\n", + "plt.bar(legend, df_M12[regions].sum())\n", + "plt.title('Distribution of total volume of lesions per regions in M12')\n", "plt.xlabel('Regions')\n", - "plt.ylabel('Volume of lesions (mm3)')\n", + "plt.ylabel('Total volume')\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 181, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -351,21 +522,75 @@ } ], "source": [ - "# Now we do the same thing but for the average length of lesions per regions\n", - "regions = dataframe.columns\n", - "regions = [str(column) for column in regions if 'avg_lesion_length_between' in column]\n", + "## we do the same thing for avg length of lesions\n", + "# we get the column names of the dataframe corresponding to the regions\n", + "regions = df_M0.columns\n", + "regions = [str(column) for column in regions if 'avg_lesion_length_between' in column or 'avg_lesion_length_above' in column]\n", "regions = np.sort(regions)\n", - "# print(regions)\n", "\n", - "# we output the hist plot of the distribution of length of lesions per regions\n", + "# we output the hist plot of the distribution of lesions per regions\n", "plt.figure(figsize=(25, 5))\n", - "legend = [region.split('_',3)[-1] for region in regions]\n", - "plt.bar(legend, dataframe[regions].sum())\n", - "plt.title('Distribution of average length of lesions per regions')\n", + "legend = [region.split('_',4)[-1] for region in regions]\n", + "plt.bar(legend, df_M0[regions].sum())\n", + "plt.title('Distribution of avg lesion legnth per regions in M0')\n", + "plt.xlabel('Regions')\n", + "plt.ylabel('Lesion length')\n", + "plt.show()\n", + "\n", + "#we output the same thing for M12 \n", + "regions = df_M12.columns\n", + "regions = [str(column) for column in regions if 'avg_lesion_length_between' in column or 'avg_lesion_length_above' in column]\n", + "regions = np.sort(regions)\n", + "\n", + "plt.figure(figsize=(25, 5))\n", + "legend = [region.split('_',4)[-1] for region in regions]\n", + "plt.bar(legend, df_M12[regions].sum())\n", + "plt.title('Distribution of avg lesion length per regions in M12')\n", "plt.xlabel('Regions')\n", - "plt.ylabel('Length of lesions (mm)')\n", + "plt.ylabel('Lesion length')\n", "plt.show()" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We look into the correlation between the edss score and the total lesion volume per level. " + ] + }, + { + "cell_type": "code", + "execution_count": 182, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# now we build a correlation matrix for the avg lesion volume and the edss score\n", + "# we get the column names of the dataframe corresponding to the regions\n", + "regions = df_M0.columns\n", + "regions = [str(column) for column in regions if 'total_lesion_volume_between' in column or 'total_lesion_volume_above' in column]\n", + "regions += ['edss']\n", + "#we remove the columns with no values\n", + "regions = [region for region in regions if '13' not in region]\n", + "regions = np.sort(regions)\n", + "\n", + "corr_df = df_M0[regions].corr()\n", + "\n", + "plt.figure(figsize=(10, 8)) # Adjust the figure size as needed\n", + "sns.heatmap(corr_df, annot=True, cmap='coolwarm', fmt=\".2f\", square=True, linewidths=0.5)\n", + "plt.title(\"Correlation Heatmap\")\n", + "plt.show()\n" + ] } ], "metadata": { @@ -384,7 +609,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.11" + "version": "3.11.5" }, "orig_nbformat": 4 }, From db4444574da33c3d657467445d507b770d630681 Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Sun, 29 Oct 2023 19:28:18 -0400 Subject: [PATCH 17/34] new figures created --- dataset_analysis/dataframe_analysis.ipynb | 204 ++++++++++++++++++---- 1 file changed, 173 insertions(+), 31 deletions(-) diff --git a/dataset_analysis/dataframe_analysis.ipynb b/dataset_analysis/dataframe_analysis.ipynb index d09aece..1f1f6fa 100644 --- a/dataset_analysis/dataframe_analysis.ipynb +++ b/dataset_analysis/dataframe_analysis.ipynb @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 170, + "execution_count": 177, "metadata": {}, "outputs": [], "source": [ @@ -45,7 +45,8 @@ "import os\n", "import sys\n", "import yaml\n", - "from prettytable import PrettyTable" + "from prettytable import PrettyTable\n", + "import ptitprince as pt\n" ] }, { @@ -59,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 171, + "execution_count": 178, "metadata": {}, "outputs": [], "source": [ @@ -70,6 +71,24 @@ "df_M12_all = pd.read_csv(df_M12_path)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We replace NaN values by 0 in the dataset\n" + ] + }, + { + "cell_type": "code", + "execution_count": 179, + "metadata": {}, + "outputs": [], + "source": [ + "#we replace all the NaN values by 0\n", + "df_M0_all = df_M0_all.fillna(0)\n", + "df_M12_all = df_M12_all.fillna(0)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -86,7 +105,7 @@ }, { "cell_type": "code", - "execution_count": 172, + "execution_count": 180, "metadata": {}, "outputs": [ { @@ -152,7 +171,7 @@ }, { "cell_type": "code", - "execution_count": 173, + "execution_count": 181, "metadata": {}, "outputs": [], "source": [ @@ -163,12 +182,12 @@ }, { "cell_type": "code", - "execution_count": 174, + "execution_count": 182, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -183,7 +202,7 @@ "+--------+--------+--------+\n", "| EDSS | M0 | M12 |\n", "+--------+--------+--------+\n", - "| Mean | 1.6694 | 1.6694 |\n", + "| Mean | 1.6627 | 1.6627 |\n", "| Median | 1.5 | 1.5 |\n", "+--------+--------+--------+\n" ] @@ -209,20 +228,20 @@ }, { "cell_type": "code", - "execution_count": 175, + "execution_count": 183, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_806/3800180276.py:2: SettingWithCopyWarning: \n", + "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_34092/3800180276.py:2: 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", " df_M0['timepoint'] = 'M0'\n", - "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_806/3800180276.py:3: SettingWithCopyWarning: \n", + "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_34092/3800180276.py:3: 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", @@ -239,7 +258,7 @@ }, { "cell_type": "code", - "execution_count": 176, + "execution_count": 184, "metadata": {}, "outputs": [ { @@ -300,37 +319,49 @@ }, { "cell_type": "code", - "execution_count": 177, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 185, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "+----------------------------------+-------+--------+\n", - "| | M0 | M12 |\n", - "+----------------------------------+-------+--------+\n", - "| Mean nb of lesions per patient | 5.3 | 3.75 |\n", - "| Mean lesion volume (mm3) | 404.3 | 190.46 |\n", - "| Mean biggest lesion volume (mm3) | 176.6 | 101.95 |\n", - "+----------------------------------+-------+--------+\n" + "+-------------------------------------------------+--------------------------+-------------------------+\n", + "| | M0 | M12 |\n", + "+-------------------------------------------------+--------------------------+-------------------------+\n", + "| Mean nb of lesions per patient (median | std) | 4.71 (3.0 | 4.33) | 3.49 (3.0 | 2.72) |\n", + "| Mean lesion volume (mm3) (median | std) | 360.47 (232.73 | 449.52) | 177.46 (97.84 | 238.77) |\n", + "| Mean biggest lesion volume (mm3) (median | std) | 157.41 (99.96 | 275.66) | 94.99 (52.92 | 144.37) |\n", + "+-------------------------------------------------+--------------------------+-------------------------+\n" ] } ], "source": [ + "\n", + "\n", "#we print a table with the average nb of lesion per patient, average lesion volume and average lesion volume per lesion\n", "table = PrettyTable()\n", "table.field_names = ['', 'M0', 'M12']\n", - "table.add_row(['Mean nb of lesions per patient', round(df_M0.number_of_lesions.mean(),1), round(df_M12.number_of_lesions.mean(),2)])\n", - "table.add_row(['Mean lesion volume (mm3)', round(df_M0.total_lesion_volume.mean(),1), round(df_M12.total_lesion_volume.mean(),2)])\n", - "table.add_row(['Mean biggest lesion volume (mm3)', round(df_M0.biggest_lesion_vol.mean(),1), round(df_M12.biggest_lesion_vol.mean(),2)])\n", + "table.add_row(['Mean nb of lesions per patient (median | std)', str(round(df_M0.number_of_lesions.mean(),2)) + \" (\" + str(round(df_M0.number_of_lesions.median(),2)) +\" | \"+ str(round(df_M0.number_of_lesions.std(),2)) + \")\",\n", + " str(round(df_M12.number_of_lesions.mean(),2)) + \" (\" + str(round(df_M12.number_of_lesions.median(),2)) +\" | \"+ str(round(df_M12.number_of_lesions.std(),2)) + \")\"])\n", + "table.add_row(['Mean lesion volume (mm3) (median | std)', str(round(df_M0.total_lesion_volume.mean(),2)) + \" (\" + str(round(df_M0.total_lesion_volume.median(),2)) +\" | \"+ str(round(df_M0.total_lesion_volume.std(),2)) + \")\",\n", + " str(round(df_M12.total_lesion_volume.mean(),2)) + \" (\" + str(round(df_M12.total_lesion_volume.median(),2)) +\" | \"+ str(round(df_M12.total_lesion_volume.std(),2)) + \")\"])\n", + "table.add_row(['Mean biggest lesion volume (mm3) (median | std)', str(round(df_M0.biggest_lesion_vol.mean(),2)) + \" (\" + str(round(df_M0.biggest_lesion_vol.median(),2)) +\" | \"+ str(round(df_M0.biggest_lesion_vol.std(),2)) + \")\",\n", + " str(round(df_M12.biggest_lesion_vol.mean(),2)) + \" (\" + str(round(df_M12.biggest_lesion_vol.median(),2)) +\" | \"+ str(round(df_M12.biggest_lesion_vol.std(),2)) + \")\"])\n", "\n", "print(table)" ] }, { "cell_type": "code", - "execution_count": 178, + "execution_count": 186, "metadata": {}, "outputs": [ { @@ -385,12 +416,12 @@ }, { "cell_type": "code", - "execution_count": 179, + "execution_count": 187, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -400,7 +431,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -441,7 +472,7 @@ }, { "cell_type": "code", - "execution_count": 180, + "execution_count": 188, "metadata": {}, "outputs": [ { @@ -497,7 +528,7 @@ }, { "cell_type": "code", - "execution_count": 181, + "execution_count": 189, "metadata": {}, "outputs": [ { @@ -560,12 +591,12 @@ }, { "cell_type": "code", - "execution_count": 182, + "execution_count": 190, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -591,6 +622,117 @@ "plt.title(\"Correlation Heatmap\")\n", "plt.show()\n" ] + }, + { + "cell_type": "code", + "execution_count": 191, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-------------------------------------------------+--------------------------+-------------------------+-------------------------+\n", + "| | M0 | M12 3d | M12 2d |\n", + "+-------------------------------------------------+--------------------------+-------------------------+-------------------------+\n", + "| Mean nb of lesions per patient (median | std) | 4.71 (3.0 | 4.33) | 3.49 (3.0 | 2.72) | 3.55 (3.0 | 3.16) |\n", + "| Mean lesion volume (mm3) (median | std) | 360.47 (232.73 | 449.52) | 177.46 (97.84 | 238.77) | 190.84 (88.79 | 263.25) |\n", + "| Mean biggest lesion volume (mm3) (median | std) | 157.41 (99.96 | 275.66) | 94.99 (52.92 | 144.37) | 94.58 (48.21 | 122.09) |\n", + "+-------------------------------------------------+--------------------------+-------------------------+-------------------------+\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_34092/1423961972.py:8: 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", + " df_M12_2d['timepoint'] = 'M12'\n" + ] + } + ], + "source": [ + "df_M12_path_2d = '/Users/plbenveniste/tmp_romane/canproco/project/canproco_final/dataframes/dataframe_M12_2d/dataframe.csv'\n", + "df_M12_all_2d = pd.read_csv(df_M12_path_2d)\n", + "\n", + "#removall of HC\n", + "df_M12_2d = df_M12_all_2d[df_M12_all_2d.pathology != 'HC']\n", + "\n", + "#we add the timepoint to the dataframe \n", + "df_M12_2d['timepoint'] = 'M12'\n", + "\n", + "#replace NaN values by 0\n", + "df_M12_2d = df_M12_2d.fillna(0)\n", + "\n", + "#we print a table with the average nb of lesion per patient, average lesion volume and average lesion volume per lesion\n", + "table = PrettyTable()\n", + "table.field_names = ['', 'M0', 'M12 3d', 'M12 2d' ]\n", + "table.add_row(['Mean nb of lesions per patient (median | std)', str(round(df_M0.number_of_lesions.mean(),2)) + \" (\" + str(round(df_M0.number_of_lesions.median(),2)) +\" | \"+ str(round(df_M0.number_of_lesions.std(),2)) + \")\",\n", + " str(round(df_M12.number_of_lesions.mean(),2)) + \" (\" + str(round(df_M12.number_of_lesions.median(),2)) +\" | \"+ str(round(df_M12.number_of_lesions.std(),2)) + \")\",\n", + " str(round(df_M12_2d.number_of_lesions.mean(),2)) + \" (\" + str(round(df_M12_2d.number_of_lesions.median(),2)) +\" | \"+ str(round(df_M12_2d.number_of_lesions.std(),2)) + \")\"])\n", + "table.add_row(['Mean lesion volume (mm3) (median | std)', str(round(df_M0.total_lesion_volume.mean(),2)) + \" (\" + str(round(df_M0.total_lesion_volume.median(),2)) +\" | \"+ str(round(df_M0.total_lesion_volume.std(),2)) + \")\",\n", + " str(round(df_M12.total_lesion_volume.mean(),2)) + \" (\" + str(round(df_M12.total_lesion_volume.median(),2)) +\" | \"+ str(round(df_M12.total_lesion_volume.std(),2)) + \")\",\n", + " str(round(df_M12_2d.total_lesion_volume.mean(),2)) + \" (\" + str(round(df_M12_2d.total_lesion_volume.median(),2)) +\" | \"+ str(round(df_M12_2d.total_lesion_volume.std(),2)) + \")\"])\n", + "table.add_row(['Mean biggest lesion volume (mm3) (median | std)', str(round(df_M0.biggest_lesion_vol.mean(),2)) + \" (\" + str(round(df_M0.biggest_lesion_vol.median(),2)) +\" | \"+ str(round(df_M0.biggest_lesion_vol.std(),2)) + \")\",\n", + " str(round(df_M12.biggest_lesion_vol.mean(),2)) + \" (\" + str(round(df_M12.biggest_lesion_vol.median(),2)) +\" | \"+ str(round(df_M12.biggest_lesion_vol.std(),2)) + \")\",\n", + " str(round(df_M12_2d.biggest_lesion_vol.mean(),2)) + \" (\" + str(round(df_M12_2d.biggest_lesion_vol.median(),2)) +\" | \"+ str(round(df_M12_2d.biggest_lesion_vol.std(),2)) + \")\"])\n", + "\n", + "print(table)" + ] + }, + { + "cell_type": "code", + "execution_count": 192, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot\n", + "df1 = df_M0.copy()\n", + "df1['Method']='M0 manual segmentation'\n", + "df2 = df_M12.copy()\n", + "df2['Method']='M12 3D nnUNet'\n", + "df3 = df_M12_2d.copy()\n", + "df3['Method']='M12 2D nnUNet'\n", + "\n", + "df123 = pd.concat([df1, df2, df3])\n", + "\n", + "#rename columns \n", + "df123 = df123.rename(columns={'number_of_lesions': 'Number of lesions per patient', 'phenotype': 'Phenotype', 'total_lesion_volume': 'Total lesion volume (mm3)', 'biggest_lesion_vol': 'Biggest lesion volume (mm3)', 'avg_lesion_length': 'Average lesion length (mm)'})\n", + "\n", + "f, ax = plt.subplots(figsize=(12, 11))\n", + "ax = pt.RainCloud(data=df123,\n", + " x='Method',\n", + " y='Number of lesions per patient',\n", + " hue='Phenotype',\n", + " #order=METHODS_TO_LABEL_SC.keys() if pred_type == 'sc' else METHODS_TO_LABEL_LESION.keys(),\n", + " dodge=True, # move boxplots next to each other\n", + " linewidth=0, # violionplot border line (0 - no line)\n", + " width_viol=.5, # violionplot width\n", + " width_box=.3, # boxplot width\n", + " rain_alpha=.5, # individual points transparency - https://github.com/pog87/PtitPrince/blob/23debd9b70fca94724a06e72e049721426235f50/ptitprince/PtitPrince.py#L707\n", + " rain_s=2, # individual points size\n", + " alpha=.7, # violin plot transparency\n", + " box_showmeans=True, # show mean value inside the boxplots\n", + " box_meanprops={'marker': '^', 'markerfacecolor': 'black', 'markeredgecolor': 'black',\n", + " 'markersize': '6'},\n", + " \n", + " )\n", + "plt.show()" + ] } ], "metadata": { From 0974dd6cf6ecf691a361008e9bab7110a3cdb26c Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Mon, 30 Oct 2023 14:44:27 -0400 Subject: [PATCH 18/34] formatted figure --- dataset_analysis/dataframe_analysis.ipynb | 42 +++++++++++------------ 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/dataset_analysis/dataframe_analysis.ipynb b/dataset_analysis/dataframe_analysis.ipynb index 1f1f6fa..e37ec3c 100644 --- a/dataset_analysis/dataframe_analysis.ipynb +++ b/dataset_analysis/dataframe_analysis.ipynb @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 177, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -60,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 178, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -80,7 +80,7 @@ }, { "cell_type": "code", - "execution_count": 179, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -105,7 +105,7 @@ }, { "cell_type": "code", - "execution_count": 180, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -171,7 +171,7 @@ }, { "cell_type": "code", - "execution_count": 181, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -182,7 +182,7 @@ }, { "cell_type": "code", - "execution_count": 182, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -228,20 +228,20 @@ }, { "cell_type": "code", - "execution_count": 183, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_34092/3800180276.py:2: SettingWithCopyWarning: \n", + "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_6264/3800180276.py:2: 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", " df_M0['timepoint'] = 'M0'\n", - "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_34092/3800180276.py:3: SettingWithCopyWarning: \n", + "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_6264/3800180276.py:3: 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", @@ -258,7 +258,7 @@ }, { "cell_type": "code", - "execution_count": 184, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -326,7 +326,7 @@ }, { "cell_type": "code", - "execution_count": 185, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -361,7 +361,7 @@ }, { "cell_type": "code", - "execution_count": 186, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -416,7 +416,7 @@ }, { "cell_type": "code", - "execution_count": 187, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -472,7 +472,7 @@ }, { "cell_type": "code", - "execution_count": 188, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -528,7 +528,7 @@ }, { "cell_type": "code", - "execution_count": 189, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -591,7 +591,7 @@ }, { "cell_type": "code", - "execution_count": 190, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -625,7 +625,7 @@ }, { "cell_type": "code", - "execution_count": 191, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -645,7 +645,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_34092/1423961972.py:8: SettingWithCopyWarning: \n", + "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_6264/1423961972.py:8: 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", @@ -685,12 +685,12 @@ }, { "cell_type": "code", - "execution_count": 192, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -712,7 +712,7 @@ "\n", "#rename columns \n", "df123 = df123.rename(columns={'number_of_lesions': 'Number of lesions per patient', 'phenotype': 'Phenotype', 'total_lesion_volume': 'Total lesion volume (mm3)', 'biggest_lesion_vol': 'Biggest lesion volume (mm3)', 'avg_lesion_length': 'Average lesion length (mm)'})\n", - "\n", + "plt.rcParams.update({'font.size': 12})\n", "f, ax = plt.subplots(figsize=(12, 11))\n", "ax = pt.RainCloud(data=df123,\n", " x='Method',\n", From c671c3e32eb469ef7fb2b8f97f3f70eb644f6a48 Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Mon, 30 Oct 2023 17:38:58 -0400 Subject: [PATCH 19/34] formatted legend --- dataset_analysis/dataframe_analysis.ipynb | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/dataset_analysis/dataframe_analysis.ipynb b/dataset_analysis/dataframe_analysis.ipynb index e37ec3c..3080599 100644 --- a/dataset_analysis/dataframe_analysis.ipynb +++ b/dataset_analysis/dataframe_analysis.ipynb @@ -685,12 +685,12 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -711,12 +711,12 @@ "df123 = pd.concat([df1, df2, df3])\n", "\n", "#rename columns \n", - "df123 = df123.rename(columns={'number_of_lesions': 'Number of lesions per patient', 'phenotype': 'Phenotype', 'total_lesion_volume': 'Total lesion volume (mm3)', 'biggest_lesion_vol': 'Biggest lesion volume (mm3)', 'avg_lesion_length': 'Average lesion length (mm)'})\n", - "plt.rcParams.update({'font.size': 12})\n", + "df123 = df123.rename(columns={'number_of_lesions': 'Number of lesions per participant', 'phenotype': 'Phenotype', 'total_lesion_volume': 'Total lesion volume (mm3)', 'biggest_lesion_vol': 'Biggest lesion volume (mm3)', 'avg_lesion_length': 'Average lesion length (mm)'})\n", + "plt.rcParams.update({'font.size': 14})\n", "f, ax = plt.subplots(figsize=(12, 11))\n", "ax = pt.RainCloud(data=df123,\n", " x='Method',\n", - " y='Number of lesions per patient',\n", + " y='Number of lesions per participant',\n", " hue='Phenotype',\n", " #order=METHODS_TO_LABEL_SC.keys() if pred_type == 'sc' else METHODS_TO_LABEL_LESION.keys(),\n", " dodge=True, # move boxplots next to each other\n", @@ -729,6 +729,7 @@ " box_showmeans=True, # show mean value inside the boxplots\n", " box_meanprops={'marker': '^', 'markerfacecolor': 'black', 'markeredgecolor': 'black',\n", " 'markersize': '6'},\n", + " hue_order=['RIS','RRMS','PPMS'],\n", " \n", " )\n", "plt.show()" From f36dbdaf42f17edfbc42396f60135fd78bddb152 Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Tue, 31 Oct 2023 15:59:31 -0400 Subject: [PATCH 20/34] formatted figure --- dataset_analysis/dataframe_analysis.ipynb | 91 ++++++++++++++++++----- 1 file changed, 71 insertions(+), 20 deletions(-) diff --git a/dataset_analysis/dataframe_analysis.ipynb b/dataset_analysis/dataframe_analysis.ipynb index 3080599..1a2cb57 100644 --- a/dataset_analysis/dataframe_analysis.ipynb +++ b/dataset_analysis/dataframe_analysis.ipynb @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -60,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -80,7 +80,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -105,7 +105,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -171,7 +171,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -182,7 +182,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -228,20 +228,20 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_6264/3800180276.py:2: SettingWithCopyWarning: \n", + "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_21794/3800180276.py:2: 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", " df_M0['timepoint'] = 'M0'\n", - "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_6264/3800180276.py:3: SettingWithCopyWarning: \n", + "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_21794/3800180276.py:3: 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", @@ -258,7 +258,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -326,7 +326,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -361,7 +361,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -416,7 +416,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -472,7 +472,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -528,7 +528,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -591,7 +591,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -625,7 +625,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -645,7 +645,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_6264/1423961972.py:8: SettingWithCopyWarning: \n", + "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_21794/1423961972.py:8: 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", @@ -685,12 +685,12 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABJ0AAAOYCAYAAAB/2oJ6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeXxU9dn///eZJQtLCGtCQBZZ1ApoiwvKqtXact+C1lutFmVRq37rcrsXV9C6tm61tbe/alhqa+tSBaxbVUBFXIoC7gplkxjW7MtkZs7n90dIYJLJZDI5yZlMXs/Hg9Y5c2ZyAeHknPdcn+tYxhgjAAAAAAAAwEEetwsAAAAAAABA6iF0AgAAAAAAgOMInQAAAAAAAOA4QicAAAAAAAA4jtAJAAAAAAAAjiN0AgAAAAAAgOMInQAAAAAAAOA4QicAAAAAAAA4zud2AcnGtm0VFBSoe/fusizL7XIAAAAAACnOGKOysjLl5eXJ4+m4vSHhcFjBYNDtMtCGvF6v/H5/3PsTOjVQUFCggw46yO0yAAAAAACdzLZt2zRw4EC3y2gxY4wKCwtVUlIiY4zb5aCNpaenq0+fPsrKymp2X0KnBrp37y6p9h97PH+AAAAAAAC0RmlpqQ466KD669GOpqSkRMXFxerbt6+6du3KqqEUZYxRMBhUSUmJtm/fLknN5iaETg3U/ePIysoidAIAAAAAtJuOGNYYY7Rz505lZWWpT58+bpeDNpaZmanu3bvr22+/1e7du5vNTTruYlEAAAAAAOCqcDiscDhM00YnYlmWevTooUAg0OwML0InAAAAAACQkFAoJEny+VhI1ZnUDRMPh8Mx9yN0AgAAAAAArdIRlwYicfH+fRM6AQAAAAAAwHGETgAAAAAAAHAcoRMAAAAAAEhas2bNkmVZ2rx5s9uloIUInQAAAAAAQLvavHmzLMuK+JWWlqaDDjpI5557rtavX+92iY6p+73OmjXL7VLaHePlAQAAAACAK4YNG6YZM2ZIksrLy/Xee+/pqaee0j/+8Q+9+eabOv74412uEK1B6AQAAAAAAFwxfPhwzZs3L2LbzTffrDvvvFM33XSTli9f7k5hcATL6wAAAAAAQNK4/PLLJUkffvhho+ceffRRHXbYYcrIyNDgwYM1f/582bYd9X2WLFmiH/7wh+rZs6cyMjI0atQo/fa3v1U4HI7Yb+HChbIsSwsXLtQbb7yhCRMmqGvXrurdu7dmzpypPXv2RH3/F198USeccIJ69OihzMxMHXnkkXrooYci3n/hwoUaOnSoJGnRokURywlXrFih2267TZZl6Zlnnon6NR599FFZlqUHH3ywfptlWZoyZYq2bdums88+W71791bXrl01ZcoUvfvuu1Hfp6amRg888IB+8IMfqGvXrurevbsmTpyopUuXRt3fKYROAAAAAAAgaViWFXX7ddddp9tuu03jxo3TxRdfLEmaN2+ebrnllkb73njjjTrttNP09ddf64wzztD/+3//TxkZGbruuuv0s5/9LOr7L1u2TFOnTlVubq4uvfRSDRs2TIsXL9b06dMb7fvwww/r1FNP1fr163Xuuefql7/8paqqqnTVVVfprLPOkjFGknTkkUfqyiuvlCQdccQRuu222+p/DRkyRBdeeKG8Xq/+9Kc/Ra3p8ccfV1pams4///yI7UVFRRo/frw2b96sX/ziFzrjjDO0evVqnXDCCVqxYkXEvoFAQKeccoquueYaSdIFF1ygGTNmaMuWLZo+fbp+//vfR/3ajjCIUFJSYiSZkpISt0sBAAAAAHQCHfk6tKqqynz++eemqqqqRa/btGmTkWROOeWURs/ddNNNRpKZMmWKMcaYmTNnGklm6NChpqCgoH6/Xbt2mezsbNO9e3cTCATqt7/22mtGkvnJT35iKioq6rfbtm0uueQSI8k8++yz9dsXLFhgJBmfz2feeeed+u2hUMhMmTLFSDKrV6+u375x40bj8/lMv379zNatW+u3BwIBM3nyZCPJ/PnPf270e505c2bUP4v/+q//MpZlmU2bNkVs//jjj40kc/bZZ0dsl2QkmfPOO8/Ytl2/fcWKFcayLDN8+HATDofrt994441Gkpk3b17E/qWlpeaoo44yaWlpZvv27VFra0q8f+90OgEAAAAAAFds2LBB8+bN07x583TttddqwoQJuvPOO5WRkaG77rorYt9bbrlF/fv3r3/cp08fTZ8+XWVlZfrqq6/qt9d17jz22GPq0qVL/XbLsnTPPffIsiw99dRTjWo599xzNX78+PrHXq9XM2fOlBS51O8vf/mLQqGQrrnmGh100EH129PS0nTPPfdIql1WF6+LL75Yxhjl5+dHbK/rfrrooosavcbr9erOO++M6AqbPHmypk6dqg0bNtQvs7NtW3/84x81fPhw3XrrrRH7d+/eXbfeeqtqamr0j3/8I+56W4JB4gAAAAAAwBUbN27U/PnzJUl+v185OTk699xz9atf/UqjR4+O2PcHP/hBo9cPHDhQklRcXFy/7b333lPXrl31xBNPRP2amZmZ+vLLLxttj/f9P/74Y0nSlClTGu0/btw4ZWZmau3atVG/djRTp07VwIEDtWDBAs2bN08ej0fV1dX661//qoMPPlgnnnhio9cMHjw4IvCqM3HiRP3zn//U2rVrNWHCBH311VcqKipSXl5e/Z/zgXbt2iVJUf88nEDoBAAAAAAAXHHKKafolVdeiWvfHj16NNrm89XGGgcO7967d69CoVDUkKVORUVFwu9fWloqScrJyYn63v369dP27dub/NoNeb1eXXDBBZo/f75eeeUVTZ06Vc8++6yKi4t13XXXRZ1x1a9fv6jvVVdTSUmJpNo/C0n67LPP9NlnnzVZQ7Q/DyewvA4AAAAAAKSMrKws9e7dW8aYJn9t2rSpVe8vSTt27Ij6/M6dO+v3iVfdQPHHH39cUu0AcZ/Pp1mzZjX5NaKpq6kuQKur44wzzoj557FgwYIW1RsvQicAAAAAAJAyjj32WO3Zs0fffPNNm7z/97//fUlqdJc4Sfrggw9UVVWlI488sn6b1+uVFNkt1dDAgQP1k5/8RC+++KJWrVqlt956S1OnTlVeXl7U/bds2aJt27Y12v72229LUv3XP+yww5SVlaV///vfCgaD8fz2HEXoBAAAAAAAUsYVV1whSZozZ4727NnT6PnCwkJ98cUXCb//ueeeK5/PpwceeEAFBQX124PBoH71q19JUkSHUs+ePWVZlr799tuY73vxxRcrGAzqrLPOkjEm6gDxOuFwWDfddJNqb2ZXa+XKlXrppZc0fPhwHX/88ZJqlwdeeuml2rJli6699tqowdOnn37aZOdUazHTCQAAAAAApIwf//jHuuWWW3THHXdo+PDh+vGPf6zBgwdrz5492rBhg95++239+te/1mGHHZbQ+w8bNkz33nuvrrnmGo0ZM0ZnnXWWunbtqhdffFFffvmlpk+frhkzZtTv361bNx199NF66623NHv2bI0YMUIej0fnnnuuBg0aVL/f1KlTddBBB2nbtm0aMGCAfvKTnzRZw5gxY7RixQqNGzdOJ554ogoKCvS3v/1Nfr9ff/rTn+Tx7O8xmj9/vj766CP97ne/0z//+U9NnjxZffv21fbt2/XJJ59o3bp1Wr16dZNzolqD0AkAAAAAAKSU22+/XZMmTdLvfvc7vfHGGyouLlbv3r01dOhQzZs3Tz//+c9b9f5XX321hg8frgceeEBPPvmkampqNHLkSN1///264oorGg3//vOf/6yrrrpKL7zwgkpKSmSM0bhx4yJCJ4/HoxkzZujuu+/W7Nmz65flRdOzZ08tW7ZM1157rR577DFVV1dr3LhxuuuuuzR+/PiIfdPT0/Xyyy/riSee0OLFi/Xss88qEAgoJydH3/ve93TJJZc0ulOgUyxzYC8WVFpaqh49eqikpKTFg78AAAAAAGipjnwdWl1drU2bNmno0KHKyMhwu5wOb+rUqXrllVf0n//8R0OGDIm6j2VZmjx5ctSZUu0l3r93ZjoBAAAAAAC47LPPPtMrr7yiH//4x00GTh0Ny+sAAAAAAABc8te//lVfffWVFi9eLEm65ZZbXK7IOYROAAAAAAAALvn//r//T2+//bYGDx6sJ554Qscdd5zbJTmG0AkAAAAAAMAlLZ3N1JFGczPTCQAAAAAAAI4jdAIAAAAAAIDjCJ0AAAAAAADgOEInAAAAAAAAOI7QCQAAAAAAAI4jdAIAAAAAAIDjCJ0AAAAAAADgOEInAAAAAAAAOM7ndgEA3GeMUSAQiHvfmqCtNL9HlmU1ej49PT3qdgAAAABA50LoBECBQEBz5sxx5L3y8/OVkZHhyHsBAAAAADouQie4ori0SsFgOGJberpPWd0IKwAAAAAgVVzz8mK3S2jS/T8535H32bx5s4YOHRqxzefzqV+/fho/fryuv/56HXXUURHPz5o1S4sWLdLq1as1bty4+u2hUEiPPfaYnnzySX3++eeqqqpS7969NWjQIB1//PE6//zz9f3vf9+RutsDoRNc8eXGHdpTXBGxbUBOto783gCXKurc0tPTlZ+fH3Ofa665RkVFRcrOztYV196m3j0y1b1rWtT3AgAAAIDOZtiwYZoxY4YkqaKiQmvWrNEzzzyjF154Qa+//romTZoU8/XhcFg/+clP9PrrrysvL09nnnmm+vbtq4KCAn355Zf63e9+p65duxI6Ac1h5k9ysSyr2SVxdX9nHo9Hhx6c0x5lAQAAAECHMXz4cM2bNy9i2z333KO5c+fqlltu0cqVK2O+/q9//atef/11nXLKKVq2bJn8fn/E84WFhSooKHC67DbF3evgCjInAAAAAECqu+CCCyRJa9asaXbf1atXS5IuueSSRoGTJOXm5uoHP/iBswW2MUInuMLjIXUCAAAAAHQOPl/zC8169eolSdqwYUNbl9NuCJ3gCpbXAQAAAABS3WOPPSZJmjBhQrP7nn766fJ6vbr55pt12WWX6eWXX9aOHTvausQ2xUwnuMJD6AQAAAAASCEbNmyon+lUUVGhDz/8UCtXrlS/fv30m9/8ptnXjx07VgsWLNBVV12lP/zhD/rDH/4gSRo4cKBOOukkXXbZZRo7dmxb/hYcR+gEV9DpBAAAAABIJRs3btT8+fMjtvXr109vv/22Ro4cGdd7nHfeeTrzzDP1r3/9S++8847WrFmjd999VwsXLtTixYv1hz/8QZdccklblN8mWF4HV1h85wEAAAAAUsgpp5wiY4yMMdq5c6d+85vfaPfu3TrttNNUXl4e9/tkZGTo1FNP1b333qvXX39de/fu1R133CHbtnXllVeqsLCwDX8XzuLSH67web1ulwAAAAAAQJvo27evrr32Wt1444364osvdPPNNyf8XhkZGbr55ps1adIk1dTUaNWqVQ5W2rYIneAKn5dvPQAAAABAarvxxhuVl5enRx99VJs3b27Ve3Xt2tWZotoRV/5wBaETAAAAACDVZWZm6oYbblAwGNQdd9wRc9+//e1vevPNN2WMafTcu+++qxUrVsjn82ncuHFtVa7jGCQOV/h8hE4AAAAAgNT3i1/8Qvfee68WL16sG2+8UcOGDYu633vvvaeHH35YAwYM0KRJkzRo0CDV1NTo888/17/+9S/Ztq177rlHAwYMaOffQeIIneAKOp0AAAAAIPXd/5Pz3S7BdRkZGZo7d64uv/xyzZ8/X4sXL4663zXXXKNhw4bptdde04cffqilS5cqGAwqNzdXZ5xxhi655BKdeOKJ7Vx961gmWt9WJ1ZaWqoePXqopKREWVlZbpeTsgp3lWrNp9sitg3IydaR3+s4iW1nc9lll2nv3r3q1auXfv/737tdDgAAAJAyOvJ1aHV1tTZt2qShQ4cqIyPD7XLQTuL9e6fdBK5geR0AAAAAAKmNK3+4wuf1ul0CAAAAAABoQ4ROcEVaGqETAAAAAACpjNAJrkjzEToBAAAAAJDKCJ3gCq/XI4/HcrsMAAAAAADQRgid4ArLspTm97ldBgAAAAAAaCOETnBNmp8ldgAAAAAApCpCJ7jGT+gEAAAAAEDKInSCa1heBwAAAABA6iJ0gmtYXgcAAAAAQOoidIJr0tPodAIAAAAAIFUROsE1hE4AAAAAAKQuQie4htAJAAAAAIDUxVU/XEPoBAAAAACpbecfr3e7hCb1u/Q+R95n8+bNGjp0aMQ2n8+nfv36afz48br++ut11FFHRTw/a9YsLVq0KGJbt27dNHLkSJ199tm68sorlZ6e3uTXycvL09atW+X1Np6V/Mknn2jMmDGSpEMOOURffvllxPNbt27VPffco3/961/atm1bfa2HHXaYJk2apMsuu0xdu3ZN7A+jAa764Zq0NAaJAwAAAABSw7BhwzRjxgxJUkVFhdasWaNnnnlGL7zwgl5//XVNmjSp0WsuuOACDRw4ULZtq6CgQC+88IJuuOEGvfnmm3rllVeifh2fz6eCggK9+uqrmjp1aqPnn3jiCfl8PoVCoUbPrVu3TlOmTFFxcbHGjx+vn/zkJ0pLS9OmTZv073//Wy+99JLOOOMMDR8+vJV/GvtqdeRdgASk+/n2AwAAAACkhuHDh2vevHkR2+655x7NnTtXt9xyi1auXNnoNRdeeKHGjRtX//jee+/VmDFj9Oqrr2r58uU64YQTGr3m+OOP17p165Sfn98odKqpqdFf/vIXTZ06VUuXLm302quvvlrFxcVavHixzjvvvEbPr169Wn369In3t9yspJvptH37dj300EP60Y9+pEGDBiktLU25ubk644wz9P7770d9TWlpqa6++moNHjxY6enpGjx4sK6++mqVlpa2c/VoCa/XI7+PbicAAAAAQGq64IILJElr1qyJa//evXvrtNNOi/mazMxMnX322Vq2bJl2794d8dzSpUu1e/duzZ49O+prV69erezs7KiBkyQdd9xxys7OjqvWeCRd6PTII4/oqquu0n/+8x+dfPLJuuaaazRhwgQtWbJExx9/vJ5++umI/SsqKjR58mQ9+OCDOuSQQ3TVVVfpe9/7nh588EFNnjxZFRUVLv1OEA/mOgEAAAAAUp3PF/+1rzGm2dfMmTOnvqvpQPn5+erXr5/++7//O+rrevXqpfLychUWFsZdT2skXeh0zDHH6K233tKGDRv0xBNP6O6779azzz6r5cuXy+v16tJLL1UgEKjf/7777tPatWt1/fXX67XXXtM999yjl19+WbfeeqvWrl2r++5zZjAY2gahEwAAAAAgVT322GOSpAkTJsS1/65du/TCCy9IksaPH9/kfscee6wOP/xw5efn12/bvn27XnvtNZ133nlNBlZnnnmmQqGQJkyYoAceeEAffvihqqur4/zdtFzSXfH/9Kc/jbp94sSJOuGEE/Taa6/pk08+0VFHHSVjjB5//HF169ZNt956a8T+c+fO1SOPPKInnnhC8+bNk2VZ7VE+WojQCQAAAACQCjZs2FA/06miokIffvihVq5cqX79+uk3v/lN1Nc8/vjjeuWVV2SM0fbt2/X8889r7969uuyyy3T00UfH/HqzZ8/WtddeqzVr1mjs2LFauHChwuGw5syZ0+Rr7rrrLu3du1dPPvmkrrnmGkmS1+vVEUccodNPP12XXXaZo8vrOtQVv9/vl7S/xeybb75RQUGBTjnllEa388vIyNCkSZO0ZMkSbdiwQSNGjGj3etE8QicAAAAAQCrYuHGj5s+fH7GtX79+evvttzVy5Mior3niiScabfvf//1fPfjgg81+vfPOO09z585Vfn5+feh07LHH6nvf+16Tr8nMzNSiRYt055136qWXXtIHH3ygDz74QB999JE++ugjPfbYY1q5cqUOPvjgZr9+PJJueV1Ttm7dqtdff125ubkaPXq0pNrQSVKTgVLd9rr9ogkEAiotLY34hfaTnk7oBAAAAADo+E455RQZY2SM0c6dO/Wb3/xGu3fv1mmnnaby8vKor1m9erWMMQoEAvrggw901FFH6aGHHooaRjXUr18/TZ06VU899ZReffVVbdiwockB4g0NHDhQv/jFL/T4449r/fr12rBhgyZNmqRvv/1WV111VYt+37F0iNApGAzqvPPOUyAQ0H333Sevt/aOZyUlJZKkHj16RH1dVlZWxH7R3H333erRo0f9r4MOOsjh6hFLBp1OAAAAAIAU07dvX1177bW68cYb9cUXX+jmm2+OuX9aWpqOPvpovfTSS+rZs6euuOIKbd++vdmvM2fOHBUVFemCCy5QZmamzjnnnITqHTZsmBYuXChJevPNNxN6j2iSPnSybVtz5szRW2+9pYsuuqjJ2/olau7cuSopKan/tW3bNkffH7GxvA4AAAAAkKpuvPFG5eXl6dFHH9XmzZub3b9v37667bbbVFlZ2WipXjRTp05Vbm6utm/frjPOOKO++SYRDccWOSGpQydjjC666CI9+eSTmjFjhv7v//4v4vm6DqemOpnqlso11QklSenp6crKyor4hfbD8joAAAAAQKrKzMzUDTfcoGAwqDvuuCOu11x88cXKy8vTggULtGnTppj7+nw+LV26VM8//7zuvPPOZt/79ttvj9psY4zR3XffLSn+O+3FI2lDJ9u2dcEFFyg/P1/nnHOOFi5cKI8nstzmZjY1N/MJ7kv3EzoBAAAAAFLXL37xC+Xl5Wnx4sXauHFjs/tnZGToV7/6lUKhkG6//fZm9z/66KN12mmnadCgQc3u+8ADD2jw4ME65phjdOmll+qmm27SJZdcokMOOUQPPfSQevfurfvvvz+u31c8kjJ0sm1bF154oRYsWKCzzz5bf/7zn+vnOB1oxIgRysvL06pVq1RRURHxXHV1td566y3l5eVp+PDh7VU6Wsjv98qyLLfLAAAAAACgTWRkZGju3LkKhUJxLZmTaoOqAQMG6M9//rO+/vprx2pZtmyZbrjhhvoOqd/85jf6y1/+oszMTF177bX65JNPYt79rqWSrs2krsNp4cKFOvPMM/Xkk09GDZwkybIsXXjhhbr99tt1++236957761/7u6771ZRUZEuv/xyQo0kZlmW0tN8qg4E3S4FAAAAAOCwfpfe53YJbW7IkCEyxsTc57LLLtNll11W/3jhwoX1g7ujSU9P17ffftvir3OgaPtOnDhREydOjPs9WivpQqfbb79dCxcuVLdu3TRy5Ej9+te/brTPaaedpiOPPFKSdP3112vp0qW677779PHHH2vs2LFat26dXn75ZR155JG6/vrr2/l3gJZK83sJnQAAAAAASDFJFzrVTXMvLy9vcgjWkCFD6kOnrl27asWKFZo/f76effZZrVixQrm5ubrqqqt02223tcn0dTiLO9gBAAAAAJB6ku5qv7kWs2h69OihBx54QA888EDbFIU2RegEAAAAAEDqScpB4uhc0gidAAAAAABIOYROcF26P/qgeAAAAAAA0HEROsF1dDoBAAAAAJB6CJ3gujQ6nQAAAAAASDmETnCd30foBAAAAABAqiF0guvS/CyvAwAAAAAg1RA6wXVpaXQ6AQAAAACQagid4Dqf1yOPZbldBgAAAAAAcBChE1xnWZb8DBMHAAAAACClEDohKTDXCQAAAACA1ELohKTg8/GtCAAAAABAKqG9BEnB72N5HQAAAACkmkeffMftEpr0/2ZMcOR9Nm/erKFDh0Zs8/v9ysnJ0cSJE/WrX/1KY8aMkSTNmzdP8+fPj9i3S5cuGjZsmH7605/quuuuU9euXeufGzJkiLZs2SJJ+uKLL3TooYc2+vqhUEgDBw7Ujh07JEnfffedcnNz65+vrKzUQw89pGeffVZff/21QqGQ+vTpo6FDh2rChAm68MILNWzYMEf+LBoidEJS8NPpBAAAAADowIYNG6YZM2ZIksrLy/Xee+/pqaee0j/+8Q+9+eabOv744+v3PeOMMzRq1ChJtSHR0qVLNX/+fL344ot69913lZaWVr+vx1N7vZyfn6/77ruv0dd98cUXtWPHDvl8PoVCoYjnysrKNGHCBK1fv17Dhw/XjBkzlJ2drW3btumzzz7TPffco2HDhhE6IbX5fF6FQrbbZQAAAAAAkJDhw4dr3rx5Edtuvvlm3Xnnnbrpppu0fPny+u3/8z//o5/97Gf1j3/729/qmGOO0Zo1a/TUU09p5syZ9c/5/X5NmjRJf/7zn3XXXXfJ54uMcvLz89WnTx+NGDFCq1evjnjuoYce0vr163XBBRfoT3/6k6wGd47ftGmTAoFAa3/rTaK9BEmB5XUAAAAAgFRz+eWXS5I+/PDDmPt1795ds2bNanLf2bNnq7CwUC+99FLE9sLCQr388sv6+c9/HtEdVacuhLrssssaBU6SNHTo0KhL9pxC6ISkwCBxAAAAAECqiRb0JOL0009Xz549tWDBgojtixcvVigU0pw5c6K+rlevXpKkDRs2OFJHS3Glj6RApxMAAAAAINX87ne/kyQdffTRMfcrKyvTwoULm9w3IyND55xzjv75z39q586d9dvz8/M1duzY+kHlDZ155pmSpAsuuEC/+tWv9Oabb6qoqCiR30pCmOmEpECnEwAAAACgI9uwYUP9TKe6QeKrVq1SRkaG7rrrroh9n332WX355ZeSapfILVmyRIWFhTrqqKN0zjnnRH3/OXPm6NFHH9Wf//xnXXPNNVq1apW++uor/eEPf2iypunTp+u+++7T7bffrnvvvVf33nuvpNqh5z/+8Y915ZVXasSIEQ787qMjdEJS8HoInQAAAAAAHdfGjRs1f/58SbXDv3NycnTuuefqV7/6lUaPHh2x73PPPafnnntOktSlSxcNHz5cl1xyia699tqos5kk1Xc0LViwQNdcc43y8/OVkZGhc889N2Zd1113nS655BK98sorevfdd/Xvf/9b77//vv7whz/oiSee0N///ndNmzbNgT+BxgidkBTodAIAAAAAdGSnnHKKXnnllbj2feqppyLuXhev2bNn66qrrtKbb76pp59+Wqeddpqys7ObfV337t115pln1i+3Kykp0Y033qhHH31UF1xwgbZv395k2NUaXOkjKdDpBAAAAABAbDNmzFBaWprOP/98lZeXNzlAvDk9evTQ73//ew0ePFi7d+/WJ5984nCltbjSR1LweflWBAAAAAAglj59+ujUU0/V9u3bNWjQIP3whz9M+L0sy1KXLl0crK4xrvSRFLyETgAAAAAANOs3v/mNnn/+eT3//PPyNLNq6LHHHtOHH34Y9bl//OMf+vLLL5Wdna1Ro0a1RanMdEJyYKZTbGvWrNGiRYs0c+ZMjR071u1yAAAAAAAuGTp0qIYOHRrXvi+//LIuueQSDR8+XOPHj1deXp7Ky8u1du1avf322/J4PHr00UeVnp7eJrUSOiEpMNOpaYFAQPn5+SoqKlJ+fr5GjRrVZgcEAAAAAEDquPfeezV+/Hj961//0ltvvaXvvvtOkjRgwADNnDlTl19+eZs2NljGGNNm794BlZaWqkePHiopKVFWVpbb5XQq677criMOHeB2GUnn6aef1pIlS2SMkWVZOu200+rvONCeLrvsMu3du1e9evXS73//+3b/+gAAAECq6sjXodXV1dq0aZOGDh2qjIwMt8tBO4n37532EiQNup0aKyws1LJly1SXDRtjtHTJEn33wXKRFwMAAAAAkhlX+UgaHstyu4SkYozRwoULG4VLxhgtfG6ZTGWpS5UBAAAAANA8ZjrBVeUfvqZw0U5JUih9iDQi192CkkhBQYHWr1/faLttjD7ZVqiCvaUa2LWHC5UBAAAAANA8Op3gKhOokgkFZUJBeWS7XU5SycvL05gxYxrdAtPj8WjMmDEaMHCgS5UBAAAAANA8Qie4ygRr6v/by+q6CJZladasWbIaLDu0LEuzZ89utB0AAAAAgGRC6ARXmdD+0MlDhtJIbm6uTj311PqAybIsTZs2TTk5OS5XBgAAAABAbIROcI0xJqLTidApuunTpys7O1uS1LNnT02bNs3dggAAAAAAiAOhE9wTDkU8ZLVYdOnp6ZozZ4769Omj2bNnKz093e2SAAAAACBCw7tuI7XF+/fN3evgmgO7nCQS0FjGjh2rsWPHul0GAAAAAETw+/2SpMrKSmVmZrpcDdpLRUWFLMuq//tvCqETXGPCwYjHdDoBAAAAQMfi9XqVnZ2tnTt3SpK6dOnCTY9SlDFGoVBIpaWlKi0tVXZ2trxeb8zXEDrBNY06nTguAQAAAECHk5ubK0n1wRNSm9frVf/+/dWjR49m9yV0gmtMw5lOLtUBAAAAAEicZVnq37+/+vXrp2Aw2PwL0GH5fD55vd64u9kIneAeBokDAAAAQMrwer3NLrdC58LsZrjGhCITcJbXAQAAAACQOgid4BqW1wEAAAAAkLoIneCeEHevAwAAAAAgVRE6wTV0OgEAAAAAkLoIneAaY4cjHtPpBAAAAABA6iB0gnsahE4AAAAAACB1EDrBPQ1CJ74ZAQAAAABIHVznwzUm3KDTieV1AAAAAACkDEInuMfYEQ/JnAAAAAAASB2ETnBNw04nQicAAAAAAFIHoRPc06DTidQJAAAAAIDUQegE9xgT8ZDMCQAAAACA1EHoBBeZ5ncBAAAAAAAdEqETXGPodAIAAAAAIGUROsE9NDoBAAAAAJCyCJ3gogapE61OAAAAAACkDEInuIfldQAAAAAApCxCJwAAAAAAADiO0Anusfj2AwAAAAAgVXHVD9dYnsgFdSyvAwAAAAAgdRA6wT10OsXt6aef1owZM/T000+7XQoAAAAAAHHhqh/usehtikdpaamWLFki27a1ZMkSlZaWul0SAAAAAADNInSCe+h0issDDzwgs+9Of8YYPfjggy5XBAAAAABA87jqh2ssOp0kSaa6Qsa2oz73yfr1+vrrryO2ffXVV/rkk0/aozQAAAAAABJG6AT3NOx06oQZlNn6hcxHr8t88W6j52zb1iMPRe9qeuSRR2Q3EVQBAAAAAJAMCJ3gHq/P7QpcZypKav+j7v8P8PFHH6m8OhD1deXl5Vq7dm0bVgYAAAAAQOtw1Q/XWIROsoaMkjK6Sj1zGz33/R/8QN26dlF5RWWj57p166YjjzyyHSoEAAAAACAxdDrBNZbXG7nBuFOHm6zMbrKGjpaV3bfRcx6PR5dfcWXU11155ZXyePjnCwAAAABIXly1wj10OjVr9OjRGjlyZMS2Qw45RIcffrhLFQEAAAAAEB9CJ7iG5XXxufrqq+vv9GdZlq666iqXKwIAAAAAoHmETnANoVN8srKyNH36dHk8Hk2fPl1ZWVlulwQAAAAAQLO46od7CJ3idtZZZ+mss85yuwwAAAAAAOJGpxNcY/n8bpcAAAAAAADaCKETXGP50yIed8Kb1wEAAAAAkLIIneAay5fW/E4AAAAAAKBDInSCaxqGTnQ6AQAAAACQOgid4JpGM51InQAAAAAASBmETnAPg8QBAAAAAEhZhE5wjWVZEcPEaXQCAAAAACB1EDrBVQwTBwAAAAAgNRE6wVVWWnr9f9PpBAAAAABA6iB0gqss/wGhE6kTAAAAAAApg9AJrjowdAIAAAAAAKmD0Amuiuh0crEOAAAAAADgLEInuMqTxvI6AAAAAABSEaETXEWnEwAAAAAAqYnQCa468O51AAAAAAAgdRA6wVVWWkb9f7O8DgAAAACA1EHoBFdFhE4u1gEAAAAAAJxF6ARXefz7Qyeb1AkAAAAAgJRB6ARXWdy9DgAAAACAlEToBHd5fbI8XkmS7XIpAAAAAADAOYROcJVlWfVzneh0AgAAAAAgdRA6wXV1S+wInQAAAAAASB2ETnCd5d8XOrlcBwAAAAAAcA6hE1xXt7yOu9cBAAAAAJA6CJ3gOs++5XWETgAAAAAApA5CJ7jO8id3p9OaNWt0xRVXaM2aNW6XAgAAAABAh0HoBNdZSdzpFAgElJ+fr927dys/P1+BQMDtkgAAAAAA6BAIneC6uplO4SQMnZYsWaLi4mJJUnFxsZYuXepuQQAAAAAAdBA+twsA6u5el2ydToWFhVq2bJmMqS3MGKOlS5dq4sSJys3Njdi3tKZKO6vKNbBbtjK8fjfKBQAAAJKGMabRKgHbNtpVVKU0v1c9s9Jb9H7p6emyLMvJEgG0A0InuM7yp0lKrtDJGKOFCxfWB04Nt99www0RP/Te37lZ1eGg9gYqdEy/Ie1cLQAAAJBcAoGA5syZ49j75efnKyMjw7H3A9A+CJ3Q7oqqKvTpjq31j73VlcqtLFeJVe1iVZEKCgq0fv36Rttt29b69etVUFCgAQMG1G9P9/pUHQ4q3cs/KQAAALdsLShScWlV/WOf16PvjciN8QoAQFviChntrjpUo693f1f/2BsOqWugWlVpQReripSXl6cxY8bo008/lW3b9ds9Ho9GjRqlvLy8iP2PyzlYpTXV6pnepb1LBQAAwD5FJZX6trC4/nGa30fo5JL09HTl5+c32l5RFZTf51Ga3ytJuuaaa1RUVKSePXvq/vvvj/l+ADoeQie0O0+Dtdhhj1fGsmSUPGu0LcvSrFmzdN111zXaPnv27Ebryf0er3pndG3PEgEAANBQ8pxOdnqWZUVdDtdwW915dVP7A+jYuHsd2p3HavBtZ1mq8aS5U0wMubm5OvXUUyN+EE6bNk05OTkuVwYAAIBoGn64CQBwF6ET2l20k4Fgks5Cmj59urKzsyVJPXv21LRp09wtCAAAAE3i7mYAkFwIndDurCh9zyHL70IlzUtPT9ecOXPUp08fzZ49m7XkAAAASYzQCQCSS3K2lyCleT2Ns86QlbzfimPHjtXYsWPdLgMAAADNIHICgORCpxPanS9K6BT0JG/oBAAAgI7B6+XyBgCSCUdltLu0KPObkrnTCQAAAB0DoRMAJBeOymh3Po+3Ue9zyPK6UwwAAABShs/LAjsASCaETmh3lmXJ74kMmeh0AgAAQGvR6QQAyYWjMlzRcIldmJn2AAAAaKVoN6wBALiHozJc4fc26HTiWxEAAACtRKcTACQXjspwRZrXH/HYNsx0AgAAQOv4fFzeAEAy4agMV2T6IkOnMN+KAAAAaCW/jw8yASCZcKUPV2T40yIe24ZvRQAAALQOoRMAJBeu9OGKDF/D5XV8KwIAAKB1/H5CJwBIJlzpwxUZvv2dTsYQOgEAAKD1vB5LHo/ldhkAgH240ocrImY62e7VAQAAgNRhWZZ8XrqdACBZEDrBFREzncKSEZ9IAQAAoPXSWGIHAEmD0Amu6HJA6GTCBE4AAABwBqETACQPQie4oos/ff8DWzIWwRMAAABaLy3N53YJAIB9CJ3gijSvT15P7bcfnU4AAABwCp1OAJA8CJ3gCsuylFm3xC7sbi0AAABIHX5CJwBIGoROcE3dEjsTliRLYokdAAAAWindz/I6AEgWhE5wTf0w8X3L6wyZEwAAAFqJ5XUAkDwIneCaLv50GSOZUN0WUicAAAC0jp9OJwBIGoROcE0Xf7pkS7L3hU1kTgAAAGglOp0AIHkQOsE1XdPS981zqkPqBAAAgNZJSyN0AoBkQegE13Txp0mhA4MmQicAAAC0DoPEASB5EDrBNZn+9APmOUnGvVIAAACQIrxej7xeLnMAIBlwNIZruqal19+5ThKNTgAAAHBEGt1OAJAUCJ3gGr/HK4UP/BYkdQIAAEDrMUwcAJIDoRNcY1mWvGG+BQEAAOAsQicASA5c8cM1wVBYln3gtyBTnQAAANB6fh+hEwAkA0InuKaiskZei29BAAAAOMtPpxMAJAWu+OGa8oqAvJ4D5jjR6AQAAAAHsLwOAJIDoRNcU14ZkMfaf0LAGHEAAAA4gdAJAJIDoRNcU1YRkNciagIAAICzmOkEAMmB0AmuKa8MyONhkDgAAACc5SN0AoCkQOgEV4TDtqqqgvIc2OlkCJ0AAADQel4vlzkAkAw4GsMVpeXVMjKRoROdTgAAAHCA38dlDgAkA47GcEVpebUkyWPt/xa0yJwAAADgAJ+X5XUAkAwIneCKkrK60Kmu08mwvA4AAACO8NHpBABJgaMxXLG/08mSuIEdAAAAHORjphMAJAWOxmh3tm1UVlFd/9gidQIAAICDPB7OLwEgGRA6od2VVwZk2/uX0lmcEwAAAMBBlmURPAFAEiB0QrsrLauOeGxZlizmOQEAAMBBB96wBgDgDo7EaHcl5Q1CJ1myROgEAAAA59DpBADuI3RCuysuqYx47KHTCQAAAA7zEjoBgOsIndCuwmFbpRXVjZ8gcwIAAICD6HQCAPcROqFdlZZXRwwRl/bNdCJ1AgAAgJO4Ww0AuI7QCe2quLQq6nZOCQAAAAAASC2ETmhXTYZOzHQCAAAAACClEDqhXRE6AQAAAADQORA6od0EakKqrK6J+hyhEwAAAAAAqYXQCe2mqS4nSQwSBwAAAAAgxRA6od3sLals8jk6nQAAAOAkY3N+CQBuI3RCuylqInQyxhA6AQAAwFFh23a7BADo9Aid0C7CYVslZdGX1xE6AQAAwGk2nU4A4DpCJ7SLkrLqJn/wGxlmOgEAAMBRdDoBgPsIndAumlpaJ0nGSB7DSQEAAACcYYyh0wkAkgChE9pF7NDJrk2eAAAAAAcQOAFAciB0QpszxqioNPo8p9od6HICAACAc0Jhzi8BIBkQOqHNlVfWqCYYivqcMZLFensAAAA4KBgKu10CAECETmgHsZbW2cbmznUAAABwVDBI6AQAyYDQCW0uduhkGCIOAAAARwVDnF8CQDJIytDpySef1MUXX6yjjjpK6enpsixLCxcujLrvvHnzZFlW1F8ZGRntWzii2hsjdArT6QQAAACHsbwOAJKDz+0Corn55pu1ZcsW9enTR/3799eWLVuafc3MmTM1ZMiQiG0+X1L+9jqV6kBQlVU1TT5f2+lE6AQAcMaaNWu0aNEizZw5U2PHjnW7HAAuYXkdACSHpExlHn/8cY0YMUKDBw/WPffco7lz5zb7mlmzZmnKlCltXxxaJNbSOkmybVseBokDABwQCASUn5+voqIi5efna9SoUUpPT3e7LAAuoNMJAJJDUi6vO+mkkzR48GC3y4AD9pZUxXw+bGxmOgEAHLFkyRIVFxdLkoqLi7V06VJ3CwLgmkBN9DsnAwDaV1J2OiXi7bff1gcffCCv16tDDz1UJ510Ep9uJoHmOp1Cti0/oVOHUxMMy+Ox5PMmZW4NoBMqLCzUsmXLZPYt2TbGaOnSpZo4caJyc3Nlaqolj1eWz+9ypQDaQ3Ug6HYJAAClUOh06623Rjzu37+/Fi1apJNPPjnm6wKBgAKBQP3j0tLSNqmvMwqFbZWWV8fcJ2yH5WemU4di20ZrPt8hv9ejIw7pK7/f63ZJADo5Y4wWLlxYHzg13H79JXOkL9+XvD5pzBRZ6ZkuVQqgvQQCdDoBQDLo8G0KRx55pBYtWqTNmzerqqpK33zzje644w4VFxdr2rRpWrduXczX33333erRo0f9r4MOOqidKk99JWVVjS4AGjJhTgg6GmOMjDGqCYVVw+2IgXYX2luoUNFOt8tIKgUFBVq/fr3sBjMCbdvW+vXrVbD5P5JtS8EaqSb2sm8AqaGa5XUAkBQ6fOh02mmn6fzzz9fgwYOVkZGh4cOH6+abb9bDDz+s6upq/frXv475+rlz56qkpKT+17Zt29qp8tRX1Mw8J0myCZ06HI/H0oB+3XXwwGx1zWSZCtDeKj9ZpaovPnC7jKSSl5enMWPGyOOJPK3xeDwaM2aM8kYfJWvgSFlDR8vq3sulKgG0F2MMM50AIEl0+NCpKTNnzpTP59OqVati7peenq6srKyIX3BGcXN3rjOGO9d1QJZlaXBelnL7dHW7FKBTsqyU/dGdMMuyNGvWLFmW1Wj77Nmz5fH6ZA06TFb/g12qEEB7CtSEm+22BwC0j4TOXA8++GD97ne/i7nP//3f/+ngg907uUtLS1P37t1VWRk7+EDbMMaoqDR2p1PIDhM6AUBLNQhWUCs3N1ennnpqffBkWZamTZumnJwclysD0N4YIg4AySOh0Gnz5s31tyRuSklJibZs2ZLI2zvim2++UVFRkYYMGeJaDZ1ZZVVQNcHYbc0h25aHO9cBQMvQ6dSk6dOnKzs7W5LUs2dPTZs2zd2CALiisqrG7RIAAPu02ZlrSUmJ0tPT2+rtJUllZWVav359o+1FRUW64IILJEnnnHNOm9aA6IpLm+8wq+10CrdDNQCQQjx0OjUlPT1dc+bMUZ8+fTR79uw2Pw8BkJwqqwmdACBZ+OLd8a233op4vHnz5kbbJCkcDuvbb7/Vn//8Z40cOTKhoh5//HG98847kqRPPvmkftuKFSsk1Q4PP+2007Rnzx4dccQROuqoozR69Gj169dP27dv18svv6w9e/bo5JNP1lVXXZVQDWid5pbWSVIoHJaX9fYA0CKW5WFWSQxjx47V2LFj3S4DgIsqq1heBwDJIu7QacqUKRFzEhYtWqRFixZF3dcYI8uydNdddyVU1DvvvNPovVetWlU/FHzIkCE67bTT1KtXL/3yl7/Ue++9p2XLlqm4uFhdu3bV6NGjNWPGDF144YXyer0J1YDWKSmrbnafUDgkH8vrAKBlvD4pxAUVADSFTicASB5xh0633nqrLMuSMUa33367Jk+erClTpjTaz+v1qlevXjrhhBN02GGHJVTUwoULtXDhwmb3y8rK0u9///uEvgbajm0blZU3HzrZYS6aAKClLK9PhtAJAJpEpxMAJI+4Q6d58+bV//fKlSs1e/ZsnX/++W1REzq48sqAws3clc4YSWHmOQFAi3no4AWApoRtW9XVhE4AkCziDp0OtHz5cqfrQAqJZ2ld0A7L00wwBQBozPIm9KMbADqFyqoaGTH3DgCSRavPXCsqKlRcXKxwE10rgwYNau2XQAdTUtb8EPFgOCSPodMJAFrKYlYhADSpvJJ5TgCQTBIOnZ544gndf//9+uqrr5rcx7IshUKhRL8EOqi4hojbYXnpdAKAlvP63a4AAJJWeUXA7RIAAAdIKHT64x//qF/+8pfy+XyaNGmSBg4cKJ+Pdn/EP0Q8aIflJ3QCgBazfIROANCUikpCJwBIJgklRQ899JD69Omjd955RyNHjnS6JnRglVU1zQ4Rl6RQKKQ0Q+gEAC1F6AQATWN5HQAkF08iL9qyZYvOOussAic0Uh7Hp0vGSHaYu4oAQCIInQAgOmMMnU4AkGQSCp3y8vKaHByOzi2e0Clkh+Wx+f4BgEQQOgFAdFXVQYXCdNIDQDJJKHSaPXu2Xn75ZVVUVDhdDzq4eIY3Bu2wPMxzAoDE+NLcrgAAklIZQ8QBIOkkFDrdeOONOuaYY3TyySfrrbfeUllZmdN1oYOKZx19MBziznUAkCA6nQAgurKK5m9mAwBoXwkNEk9Lq/2U1RijE044ocn9LMtSKBRKrDJ0OMaYuJbXBe2wvCyvA4CEEDoBQHRl5XQ6AUCySSh0mjhxoizLcroWdHBVgaDCcayjD4a5cx0AJMpieR0ARFVKpxMAJJ2EQqcVK1Y4XAZSQXlF80vrjJHC4VDtfwAAWoxOJwBoLGzbqohjzAMAoH0lNNMJiKaqOo55TnZYHu4qAgCJ8/roNgaABsoramT4UBMAkg6hExxTVR1sdp9gOCQvS+sAIGGWZUleup0A4EBl5SytA4BklNDyOkkKh8N6+umn9frrr6ugoECBQOPBfZZl6Y033mhVgeg4qgPxhU4ehogDQKtYvoR/fANASioldAKApJTQWWtFRYV+9KMf6b333pMxRpZlRbSz1j2m/b9zqQo0f6fCoB2Wh04nAGgVi04nAIhA6AQAySmh5XW//vWvtXr1as2fP1+7d++WMUbz5s3Td999p7///e8aOnSo/ud//idq9xNSV3Vcy+vC8tqETgDQGgwTB4D9jDGETgCQpBIKnf7xj39o3Lhxuvnmm9WrV6/67Tk5OTrzzDO1YsUKvfHGG/rNb37jWKFIbsYYVdfEDp1sYxSm0wkAWs/L8joAqFMVCCoYYnwDACSjhEKnrVu3aty4cfvfxOOJ6GoaOHCg/uu//kuLFi1qfYXoEAI1Idl27DuGBMNhWcZI3FkEAFqFTicA2K+snNUVAJCsEgqdunbtKo9n/0t79Oih7777LmKf3Nxcbd26tXXVocOojmeeUzjE0joAcIDl9bpdAgAkDZbWAUDySih0Gjx4cESgNGrUKL355pv13U7GGL3xxhvq37+/M1Ui6QWDzbc01w4Rp/UZAFrNQ+gEAHUInQAgeSUUOv3whz/U8uXLFQrVdrfMnDlTW7du1XHHHafrrrtOEyZM0Nq1a3XGGWc4WiySVygcR+gUDslDpxMAtJrFTCcAqEfoBADJK6HQ6aKLLtK1116rXbt2SZLmzJmjX/7yl1q3bp3uv/9+rV69Wj/96U81b948J2tFEguGmg+Tgh10iPiaNWt0xRVXaM2aNa7V8PDDD+vcc8/Vww8/7FoNAJIIoVNSe/rppzVjxgw9/fTTbpcCpLxgKKzKqhq3y+iQkuEcF0DqSyh0GjFihG644YaI5XOPPPKICgsLtXr1ahUUFOiZZ55Rly5dHCsUya25O4bYxsi2TYeb6RQIBJSfn6/du3crPz8/YmB+e9m9e7fef/99SdL777+v3bt3t3sNAJKLxfK6pFVaWqolS5bItm0tWbJEpaWlbpcEpLQyupwSkgznuAA6h4RCp6b07dtXxx57rHJzc518W3QAzYVONeGQJNPhOp2WLFmi4uJiSVJxcbGWLl3a7jU07BicP39+u9cAIMnQ6ZS0HnjgAZl9d2k1xujBBx90uSIgtZVy57qEJMM5LoDOodWh07vvvqtHH31Ud999tx599FG9++67TtSFDibUzPK6UDgsyxhp34l4R1DwXYGWLl0acfGwdOlSFRYWOvL+JhySKdggU1K7TNWUF8ls/0YmuP/kaeXKldq7d2/E6/bs2aOVK1fuf5+SXbXvE27+DoItrtEYFe6u0N6Sqvpttm1UsLNcoXDHChCBVGJZjn5mhBaybaPvdpWruDSyw+KTTz7R119/HbHtq6++0ieffNKe5QGdSlkFnU4tVVhYqGXLljV7jmtKd9eeY4aCbpRZr6IqqO07y1QTx42LACSfhM9a33rrLR1yyCGaOHGiLr/8ct100026/PLLNXHiRB166KF6++23nawTSa65u9d1tHlOxhj98YnHZWQabV+4cGH9D+lW+fYrmc2fyXzxnuyaapnPV8ts+VzaVHtxEg6H9fjjj0d96eOPP65wOCwTDMh88Z7M5s+kb7+Oum9r7NhTqf98W6wvN+2Vve/3HArb2lxQoq0FLBkBXOMhdHJTwc5ybdpeoi827VWgpjbwt21bjzzySNT9H3nkEdkdbHk50FHQ6dQyTZ3LNtxuQsHac9PNn0nbvnSj1HpfbNyjLQWl+s+3Ja7WASAxCfXnr169Wj/60Y8UDAY1depUTZw4UTk5OdqxY4feeustvfzyy/rRj36k5cuXa9y4cU7XjCTUXNdLR7tzXUFBgTZ+3vgHrG3bWr9+vQoKCjRgwIDWfRF/Ru3/e/2yvD4Zf7oUCkpptdvffPNNhZu4K2A4HNabb76pk06YInn9kh2Q/OmtqyeKNH/tha3XY8lqWL6fmTJAW/hm8y5VVcf+VDndVOuQnv3aqSI05D/g2Ojx1B4d165dq/Ly8qj7l5eXa+3atfrBD37QbjUCnYExRuVNdDqZYI3sqgqFfZakQ9q3sCRWUFCg9evXN9re6BzX45F8aVJNdf25qVv8fo9qQmGl+fjABeiIEgqdbrzxRlmWpRUrVmjixIkRz11//fVauXKlTjnlFN1444168803HSkUya25zp+gHZa/A3U65eXlacyYMfr0008jPp32eDwaNWqU8vLyWv01rLxhUveeUnqX2tufj5ooVZVJ3XtJkk488UQtXrw4avDk9Xp14oknyvJ6pSOmSIFKWfte56RePTJ1xCH95PVasqzaCyu/z6PRI/qqWxe/418PgLS9sFgVzdyJqUeGxSWUi3J6d1WXDL/S/F75fbUB/JFHHqlu3bpFDZ66deumI488sp2rBFJfVXWwyQ8+TSgou7pcYW/Dj806t3jPcS3PvnPM6oo2OcdsicOH91FlVVDdu6a5WgeAxCQUF3/44Yc6++yzGwVOdSZPnqyzzz5bH3zwQauKQ8cRK3Oqu3NdR1peZ1mWZs2aVR+0HLh99uzZjbYn/HW695K179Mjy58mK6t3/Xt7vV5deOGFUV938cUXy+utvdCx0jLa9GSga6ZfGWn782nLstS9a5pjfwYAIgWbmZEnSeLfn+u6d01Tetr+jk+Px6PLL7886r5XXnmlPCyJBBxXVhFraV3HmSPanlpyjmv5010PnCTJ5/Uoq1s6555AB5XQGVBGRkazS4sGDBigjAx3WzHRfhrOPjpQcF+njsfuWD/8c3Nzdeqpp9b/gLMsS9OmTVNOTk671TB58mT16hX5w753796aMGFCu9UAoP0YY5q9G2gtTryT0ejRozVy5MiIbYcccogOP/xwlyoCUlvMIeId67SzXSXDOS6AziOh0OmHP/xhs8vm3nzzTZ100kkJFYWOJ1anU8jeFzp1oE6nOtOnT1d2drYkqWfPnpo2bVq71zBv3ryIx7fddlu71wCgfYRtE9eNCvi0N3ldffXVERdyV111lcsVAamrnE6nhCXDOS6AziGh0On+++9XQUGBZs+ere3bt0c8t337ds2aNUuFhYX67W9/60iR6ABiXCQFwyFJHWt5XZ309HTNmTNHffr00ezZs5We7vyw7ub06dNHxx57rCTp2GOPVZ8+fdq9BgDtIxRXl5NEp1PyysrK0vTp0+XxeDR9+nRlZWW5XRKQssorY8y/c+JOwyksGc5xAXQOCQ0SP//889WrVy8tXrxYf/nLXzR48GD169dPO3fu1JYtWxQOhzVmzBidf/75Ea+zLEtvvPGGI4UjucTudLJlGdNhf/iPHTtWY8eOdbWGK6+80tWvD6B9dNDDJBo466yzdNZZZ7ldBpDSjDGqqIzR6cQBtVnJcI4LIPUlFDqtWLGi/r9DoZA2btyojRs3Ruyzbt26Rq9jOUDqijnTyQ7Lww9+AGiWHe/sO36eAujkAjWhJu9cBwBIHgmFTgfeXhOoFf0CyJjamU6+Dri0DgDaWzzznAAAUnmsLidJzHQCgOTA/XvhCI8neugUNmHJdMwh4gDQ3uIOneh0AtDJVcSa5ySROQFAkiB0giO8TYROwXDdnev4yQ8AAABnNBc6xRr9AABoP3Etr1u8eLEk6fTTT1f37t3rH8ej4TBxpCaPJ3p+GbJrQyeLTicAaJbVRIAPAIhUFQi6XQIAIA5xhU6zZs2SZVkaN26cunfvXv84FmOMLMsidOokmup0Cu2b/+WJdzguAHRiHpbNAUBcqqqbCZ049QSApBBX6JSfny/LstS/f39J0oIFC9q0KHQ8Tc10Ctp1y+vodAKA5sR9l1fCKQCdXLOhE6kTACSFuDudDjRz5sy2qAUdmLfZ5XX84AeA5jQV4AMA9guFbdUEQ26XAQCIA4PE4YhoF0rGSGHblmSY6QQAcfB6+bEMAM1pvssJAJAsEjq7XbVqla6++moVFhZGfb6wsFBXX3213nvvvVYVh47D52v8rRSyw5KhywkA4uX1WLJEtxMAxFIdT+jE+ScAJIWEQqcHHnhAy5YtU25ubtTnc3Nz9eKLL+rBBx9sVXHoOPw+b6NtLK0DgJaxLItuJwBoBkvrAKDjSOjM9sMPP9SECRNi7jNp0iQ6nToRX9TQad+d6widACBu0TpHAQD71QTDbpcAAIhTQme2O3fu1IABA2Luk5ubq507dyZUFDoef1PL6yTmOQFAC/ji6nRiCR6AzitApxMAdBgJhU7Z2dnaunVrzH22bNmibt26JVQUOp5Yy+vodAKA+EU7njZC5gSgEwvS6QQAHUZCodNxxx2n559/Xtu2bYv6/NatW/XCCy/o+OOPb1Vx6Dj8/qaX1zHTCQDiF+14CgDYL1ATT+jE+ScAJIOEQqerr75alZWVGj9+vBYvXqzvvvtOkvTdd99p0aJFGj9+vKqqqnTNNdc4WiySV5N3r5NkieV1ABCvNEInAIgpyPI6AOgwfIm8aOLEifrd736n//3f/9Xs2bMl1d5xx+zraPF4PHr44Yc1adIk5ypFUmu4HCRs2/UfMNHpBADxi2t5HQB0YmE7jnNLTj8BICkkFDpJ0i9/+UtNnjxZf/zjH/Xhhx+quLhY2dnZOuaYY3TJJZdo1KhRTtaJJOfzeuTxWLL3nQTULa2TmOkEAC3B8joAiC1s00UPAB1FwqGTJI0aNUp/+MMfnKoFHZhlWUrz+1QdCErav7ROotMJAFoiPa1VP5oBIOXZYc4tAaCjSGimExDNgXNIwmb/J1CETgAQPzqdACA2m3NLAOgw4vo4devWrZKkAQMGyOv11j+Ox6BBgxKrDB1Omn//t1MoXNfpZAidAKAF0gmdACCmcJjldQDQUcQVOg0ZMkSWZemLL77QyJEj6x83x7IshULcXaKzOLDTKWQOPBkgdAKAeKWxvA4AYrLjGSQOAEgKcZ3Znn/++bIsSz169Ih4DBwoInTaN9OJLicAaJk0Op0AIKb4zi45BwWAZBBX6LRw4cKYjwEp8tP5uruKEDoBQMv4fV55LIuZJQDQBI8lscAOADoGBonDMXWfzodtu/7DJYtPmQCgRSzLimOYON3GADovVlwAQMeRUOjk9Xp1xx13xNzn3nvvldfLEoHOpK7TKWRz5zoAaI105joBQJMInZyxZs0aXXHFFVqzZo3bpQBIYQmFTsYYGcIENLC/0ylcv43QCQBa7sC7gQIAIpE5tV4gEFB+fr52796t/Px8BQIBt0sCkKLabHndrl27lJmZ2VZvjyRUd5F04J3rWF4HAC3HMHEAaJqH1KnVlixZouLiYklScXGxli5d6m5BAFJW3B+lLl68OOLx2rVrG22TpHA4rG+//VYLFizQqFGjWl8hOoz0tI7X6WSMceyTHdvr0bq93yrN49ORfQbKa8WX6cZbg9n2pUzJbllDRkmZ3WQ2fCxJsoZ/X6oul9n8mTJ658gzpO3/3W39rlTFZQENHdBD3bumtfnXAzqbNJbXJa14j9lV1SH9Z3uxumb6Nbh/VpPLgdLT01kqBLSQx8O/mdYoLCzUsmXL6leuGGO0dMkSTRg/Xv3z8tq1loJd5QoGwzH3CdSEtWFrkfx+r4YflM3fP9DBxH1WO2vWrPqTIsuytGTJEi1ZsqTRfnUHr8zMTM2bN8+ZKtEh+H1eWZbVoWY6BQIBzZkzx5H3uuXh+7S7ulySNDjQS30yurV7DY9ffIYyB4yQ5U935P2iMcbo2x1lkqTvdpWre9debfa1gM6KTqfk5eQxW5Ly8/OVkZHh2PsBnYHPxzEyUcYYLVy4sNGoFGOMFj7xuH518y3tGoRv+65MdjOXC7uLK1VSXhv25/Tuoh7d2u48F4Dz4g6dFixYIKn2gDRnzhxNnz5dp512WqP9vF6vevXqpeOOO049e/Z0rFAkP8uy5Pd5a+9eV7etEy2v65fZXd/VVCjd61OPNHeWllq98yRf23YeWZalvj27qKQ8oL69urTp1wI6K0InAGiaz8cNuBNVUFCg9evXN9puG6NPvvhSBQUFGjBgQLvVk9unS7MzunplZWjnnkr5fV51zfS3T2EAHBN36DRz5sz6/165cqVOP/10TZs2rU2KQseVnuZT+MCZTkmeOaWnpys/Pz/mPtdcc42KiorUs2dP3X///THf68RuPVyvoT0+nRoxmEAZaEssr0teTh6z694PQMv4uEN2wvLy8jRmzBh9+umnsg/4oNjj8WjUqFHKa+fldYPzejT7QUtmhl/fPyynnSoC4LSEzmo3b96sf//734ROaMTn88g+oEc22ZfXWZbV7LKGA5eVtsUSiGSoAUByodMpeXHMBtznp9MpYZZladasWbruuusabZ89ezYz5gA4LqEj9gcffKBQKOR0LUgFnsiQqTMtrwMApxA6AUDT/Mx0apXc3FydeuqpEQH5tGnTlJNDNxEA5yUUOh122GHavHmzw6UgFdiWHfE42TudACAZ+X3NNSJzbAXQeTHTqfWmT5+u7OxsSVLPnj1ZwQKgzSR0xL788su1dOlSff75507Xgw7OWHQ6AUBr0ekEAE1LZ+5dq6Wnp2vOnDnq06ePZs+ezXw5AG0moSP20KFDNWXKFI0bN04XX3yxjj76aOXk5ERdAzxp0qRWF4mOI6xw5AYyJwBoMY/Hks/nVSgUbn5nAOhkuNmCM8aOHauxY8e6XQaAFJfQEXvKlCmyLEvGGN1///0xB86Fw5wwdyZhltcBgCP8hE4AEBWdTgDQcSR0xL711lu5swGiCpoDB8wb0eoEAIlJ83tVVe12FQCQfNL98VzCcK0CAMkgodBp3rx5DpeBVBEZOgEAEsXdmQAguvQ0jo8A0FFw6wc4quaA0ImldQCQOD/DxAEgKq/XI6+HyxgA6Ag4WsNRQUInAHCEn1uCA0BUlmUpI525TgDQESR8Rrtt2zZdfPHFGjZsmDIzM+X1ehv98vn4YdDZBA8YHG8xzwkAEsbyOgBoWnq63+0SAABxSCgV+s9//qNjjz1WRUVFOvzwwxUIBDR48GBlZGRo48aNCoVCOuKII5Sdne1wuUhmxhgFFZJUe6FkkTkBQMIInQCgaRncwQ4AOoSEOp3mz5+vkpISvfHGG1q3bp0kafbs2friiy+0efNmnXrqqaqoqNAzzzzjaLFIbmFjy45YUkfqBACJYqYTADSt2eV13LwOAJJCQqHT66+/rqlTp2ry5Mn128y+sCEvL09PP/20JOmmm25yoER0FDXhkCxL9T/kmekEAInzMdMJAJqUwfI6AOgQEjqj3b17tw499ND6xz6fT5WVlfWP09PTdfLJJ+vFF19sfYXoMOrnOXlqwyZmOgFA4lheBwBNa36QOK1OAJAMEgqd+vTpo4qKiojHmzdvjtjH5/OpuLi4NbWhgwnZ+0Knup/xZE4AkLCYoRPHVwCdHIPEAaBjSCh0GjFihDZu3Fj/+JhjjtGrr76q//znP5KkXbt26dlnn9WwYcOcqRIdgt1gOR2dTgCQOJbXAUDTGCQOAB1DQme0P/nJT7R8+fL6Tqb//d//VVlZmcaMGaOjjz5aI0eOVGFhoS6//HIna0WSaxQ6kTkBQMJiL6/jAAugc0sndAKADiGh0OnSSy/VihUr5PXWnhBPmTJFf/vb3zR48GB9+umnysnJ0e9+9ztddNFFjhaL5FY3TL5+kDgXRQCQMJ+XTicAaIrX62H2HQB0AAl9RJCVlaVjjz02YtuZZ56pM88805Gi0DE17HTik3gASJzX65HX41HYtt0uBQCSUnq6T8FQOPqTFoPEASAZ8DEqHGPE8joAcBJznQCgaRlpDBMHgGTXqsXQmzdv1l//+letXbtWJSUl6tGjh4488kide+65GjJkiEMloqMwdDoBgKP8fq8CNSG3ywCApJSexvI6AEh2CYdO9957r2699VaFQqGIsOHZZ5/V/Pnzdfvtt+uGG25wpEh0DD5P5A9+Op0AoHX83iYuqBqF/ADQ+aT5Y13KsLwOAJJBQn37CxYs0Ny5c9WnTx/dd999eu+997Rp0ya99957uu+++9S7d2/deOONWrhwocPlIpn5PJHfTgwSB4DWYXkdADTN74/R6UTmBABJIaFOpwcffFA5OTn6+OOP1a9fv/rtgwcP1jHHHKPzzjtPRxxxhB544AHNmjXLqVqR5Lx1nU51WROZEwC0SlqsCyoA6OQ4RgJA8kvoI9RvvvlGZ511VkTgdKCcnBydeeaZ+uabb1pVHDqW+k6nfWETnU4A0Dr+mEtHAKBzixU6WbQ6AUBSSCh06tu3r/z+2HeLSEtLU9++fRMqCh1T/Uwnww95AHCCv6nldcx0AoDYy+sAAEkhodDpZz/7mZ577jlVVlZGfb68vFzPPfeczjnnnFYVh47F5/HWXgfZtY/pdAKA1vH7uKACgKb4fTG6QS0+BAWAZJBQ6HTHHXdo9OjROvbYY/X3v/9d27dvVzAY1Pbt2/W3v/1Nxx13nI444gjdfvvtTteLJObzeOSzDviWInMCgFZpeukIB1gA8Hm52QIAJLuEhkV06dJFkmSM0bnnntvoeWOMPv/88/r96liWpVAolMiXRAdgWZYyfWmqVu3fMZ1OANA6TS4d4fAKAPJ6Y3Qz0enUrDVr1mjRokWaOXOmxo4d63Y5AFJUQqHTxIkTZXEgRxQZ3jRJIUmGmSMA0EppTQ4S5/gKAN5YnU5cq8QUCASUn5+voqIi5efna9SoUUpPT3e7LAApKKHQacWKFQ6XgVSR7ok9YB4AEL+mZjoZQn0AkNfD8rpELVmyRMXFxZKk4uJiLV26VGeeeaa7RQFISRyp4Si/Ujt0so2timBNxLaQHVZVKJjwe5pgjUww0LLXhEOyA5Uy1RUyxpYJBWVqqhKu4UCBmpDCtu3IewFonbQ0Zjp1NMYYQkGgnXg8ljxNdjTR6dSUwsJCLVu2rP5YZYzR0qVLVVhY2GhfY4dlqqPfPAoA4pFQpxPQFK+pzTGtFD3hXr1jk/YGKjSyR44Oyc5RyA5rxXffqCoU1A/6HKQBXbNb9H6mqlzmk5WSbUujJsjq1rP51wRrZNYvlyncLJPRVVbeMKmiRArWSIceI6tnboK/O2nHngpt3FaszHS/jjikrzweTtgAN/m8HnksS3bDY2qKHmNTwebtpaoJEtwD7cXr9cgOhRs/wfK6qIwxWrhwYaNwvG77DTfcEDFGxXz6jlReLA3+nqwBI9q5WgCpgE4nOMpnUvv23iU11fv+v7arKGiHVRWqkWTqt7VIdYUUCtWGTlXl8b0mFJAC1VJNtRQMSKV7pJpA7UVoRWnLazhARWVtx1Z1IKSwzUUt4DbLsqIPE+efZ9KqqEq88xVAyzU5Z5bQKaqCggKtX79edoOudtu2tX79ehUUFNRvM8aWKvedW1YUt2OVAFIJnU5wlHdf6JSqd647uu8g7agq09DufSRJmb40Hdn7IJUFqzU8q2/L3zC7n6zB36sNnXoPiOslVmZ3adiRUu/+ktcnK2dI7QlBdaXU/+CW13CAg3K7y+Ox1K1Lmvw+MmkgGaSn+RSoaXDnVzqdktbBB/WIfUctAO2Cmx5Fl5eXpzFjxujTTz+NCJ48Ho9GjRqlvLy8+m2W5ZEOOUYq3inlDXOjXAApgNAJjrLCHsmSrBRdWdA3s7v6ZnaP2HZQHEvimmJZlpRAq7KVM1hWzuD9G7r3SriGA/n9Xg0Z0MOR9wLgjKidTika7KeCLhl++WLdUQtA+yB0isqyLM2aNUvXXXddo+2zZ89uFNZZPXOknjntWSKAFMNZERwVCIbk83jEBREAOCPd3/jzIWNSNNkHAMcQOjUlNzdXp556an3AZFmWpk2bppwcwiUAzksodHrrrbe0du1ah0tBKqgOhOT3+MicAMAhaVFnOnGQBYCY6HSKafr06crOzpYk9ezZU9OmTXO3IAApK6HQ6YQTTtCf/vQnp2tBB1cTDCkUCsvn9absTCcAaG9paVFWwhM6AUBshE4xpaena86cOerTp49mz56t9PR0t0sCkKISmunUr18/paWlOV0LOrjS8oAkye/xqtrlWgAgVaRHDZ1YXgcAkmSaCOEtiykizRk7dqzGjh3rdhkAUlxCR+NTTjlFK1eubPIgj86prLw2akr3+fgUHgAcEm15HT9/AaBW2G4ihKfTCQCSQkKh01133aU9e/boF7/4hfbu3et0TeigyipqO518Hq88/JwHAEdEXV7X1EUWAHQixhjZdhMhPJ1OAJAUElpeN2PGDGVnZys/P19PPvmkhg4dqpycnMa32LQsvfHGG44UiuRX1+kkSX4r2i2+AQAtFX2QOKETAISbCpykfTev41NQAHBbQqHTihUr6v87EAjoyy+/1Jdfftlov4YhFFKXMaa+00mS/B6PuCQCgNZL9zf+UW3odAIAhcOxj4W1c504XgKAmxIKnWxOdtFARVVNxJp6n+VRjYv1AECq8Pk88liW7APnONHpBABNz3Oqw7wHAHAdi53hiLLyQMRjHz/kAcARlmXJ33CJXawlJQDQSTTX6cRcJwBwX6uPxOXl5froo4/09ttvO1EPOqii0sqIx5aRPCyvBABHpDcYJm5M2KVKACB5BEPNLa/jXBQA3JZw6LR582ZNnz5dPXv21NFHH60TTjih/rlVq1bpe9/7XsTsJ6S2PUUVkRuMLQ+fLgGAIxp3OrG8DgCCwWYCeM5FAcB1CR2Jt27dqnHjxumll17S9OnTddxxx8kcMGvi2GOP1e7du/XUU085ViiSV00w1Gh5nYyh0wkAHOL3EToBQEOhUHOhE+eiAOC2hEKn2267TUVFRVq5cqWeffZZnXzyyRHP+3w+TZw4UatWrXKkSCS3PcWVMmowX8TY8vLpEgA4IiJ0MkZqeMwFgE6oueV18nAuCgBuS+hI/Oqrr+r000/X8ccf3+Q+gwYN0vbt2xMuDB3H3oZL66TazjeLuU4A4IS0A5fXcec6AJAkBZvpdLL4ABQAXJfQkXjv3r0aMmRIs/sFAoFm90HHt7u4cehUd1HEXCcAaL0DO50Md64DAEnNh04srwMA9yWUCOTk5GjDhg0x9/n00081aNCghIpCx1EdCKm8Ikq4aNeFTvywB4DW8vkO+HFNpxMASGKQOAB0BAkdiU8++WQtW7ZMn376adTn3377bb3xxhuaOnVqq4pD8tsbrctJktl3UeRlLT0AtJrPe2DoRKcTAEhSTXOhk4cPPwHAbQklAjfffLMyMzM1YcIE3XXXXfVdTy+//LJuueUW/fjHP1afPn103XXXOVoskk/h7rLGGxvcVYkldgDQOl4vnU4A0FCzoRPnoADgOl8iLxoyZIheffVV/exnP9PNN98sy7JkjNF///d/yxijQYMG6dlnn1X//v2drhdJJBy2tXNP49DJNLgg8lqWGEECAIk7sNPJ0OkEAJKkYDAU83mLMQ8A4LqEQidJOvbYY/XNN99o2bJlev/997V3715lZWXp2GOP1fTp05WWluZknUhCO/eWKxyO8ol7w04nj0eym/kkCgDQpIhOJ5tOJwCQ6HQCgI4g4dBJknw+n04//XSdfvrpTtWDDqRwZ2n0J0zD5XWWLFky4tN5AEiEJ2IuCcdSALBtw93rAKADcCT+r6io0HfffaeKiuhDpZF6mlpaJ0kmyqfwHgY5AkDCIpaI0OkEAM0HThKhEwAkgYRDp0AgoDvvvFMjR45UVlaWBg4cqKysLI0cOVJ33XWXAoGAk3UiyezaW65QtKV1UtQLIi/tzQCQsIjrJmY6AUDzS+vETCcASAYJLa8rLi7WiSeeqHXr1snn8+mQQw5RTk6OduzYoY0bN+qWW27Rc889pzfeeEPZ2dkOl4xk8F1TS+ukqPObPPzQB4CEHXjhZIyROKQC6ORqmhkiLomZTgCQBBI6Et94441au3atZs2apc2bN+vzzz/X8uXL9fnnn2vz5s2aOXOmPv74Y910001O14skEGtpnSSZKKGTZVl82gQACYo4ehqW1wFAPJ1OJPQA4L6EQqfnn39exx9/vJ544gn1798/4rn+/fsrPz9f48aN0z/+8Q9HikRy+W5nadNL66Qm71Tn4dMmAEiIfeCKOpbXAYCC8YROZE4A4LqEUoDS0lJNnjw55j5TpkxRaWmMJVjosLZ+VxTz+WiDxCXJS6cTACTEjkydXKsDAJJFXMvrxFwnAHBbQqHT4Ycfrm3btsXcZ9u2bTr88MMTKgrJq6yiWkUllbF3otMJABxlHxjmkzkBgGpq4lleJ9HuBADuSigFmDt3rp555hmtWLEi6vNvvvmmnnnmGWY6paBtBcWxdzDRZzpJtXdf4tMmAGg5+4AldYbUKaY1a9boiiuu0Jo1a9wuBUAbim+mk5I2c+JYBaCzSOjudWVlZTrppJP0wx/+UD/60Y80YcIE9evXTzt37tTbb7+tf/3rX/qv//ovlZSUaPHixRGvPf/88x0pHO0vHLa1fUdJ7J2aCJzqeC2PQibeT6YAAJIUDh8QNDHTqUmBQED5+fkqKipSfn6+Ro0apfT0dLfLAtAGgqGO2+nEsQpAZ5JQ6DRr1ixZliVjjF599VW9+uqrjfZ58cUX9c9//rP+sTFGlmUROnVgO3aXNbt+3oRjP++h0wkAWiwU98VV57ZkyRIVFxdLkoqLi7V06VKdeeaZ7hYFoE3E3+mUfOeeHKsAdCYJhU4LFixwug50AM0NEJckYxM6tZQJh6Qdm2W6ZMmqqZKpqpDl80v9Bsvyp7la2+6iKoVtW/16dXG1DqCzi7i4otMpqsLCQi1btkxm35+PMUZLly7VxIkTlZub63J1AJwWjHOQeDIJ27Y++s9XWrp0KceqFgiFbW3YUiS/z6ODD8pmXAfQwSQUOs2cOdPpOpDkyisD2lNU0fyO4difOlmWVd8lh32+/Vpm+zcy1eUy/nSpcJNM7wHyVJZJI37gWlkl5QF9vWWvJMnrYQg84Kb4l5F0TsYYLVy4sNHPFmPbWrhwoW644QYuUoAUE3enUxItr/uqeIee+vOTjSbz1R3DOFZF982WvVr/9W5ZkjLSfRqQ093tkgC0QEKhEzqfzd/ujWs/00zoJNV2O4UJnfbz71vD78+obQH3+iWPV0rLcLUsn9cjj2XJGMnvI3QC3BSM++KqcyooKND69esbbbeN0fr161VQUKABAwa4UBmAtmCMUSi0/66e1aGgKmsCUfftGqppr7KaVbZrjwq/2dRou23bHKtiSPf75LEseSwpze91uxwALUTohGYFQ2FtLyyOb+dmltdJkkeWuHzaz8obJnXvKSu9ixQKyoSCsmSk7r1cratrpl9HHNJPxhh1yfS7WgvQ2QVqOt4ykvaUl5enMWPG6NNPP5Vt778Q9Xg8GjVqlPLy8lysDoDTgsFwxJ08w7atiiZCJ38o2F5lNeuYkYfrsFGH66vPv+BY1QIHH5StrG7p8nktZWe5+6EsgJajfQHN2lZQpFDYbn5HNT9IXJI8Ft92DVnde8lKy5DVpbs8Wb1kZfVOivbqzAwfgROQBKoCyXPRlIwsy6q/yUnD7bNnz06K4ykA5zRcWtdR/o1blqWL5lzAsSoBfXpmEjgBHRRX/4jJto02b29+gLgkycS/vA4AEL/qakKn5uTm5urUU0+tv2izLEvTpk1TTk6Oy5UBcFpNgzl3HenMkmMVgM6G0Akx7dhTpqrq+NbC13Y5xTGrySJ4AoB42bZRdeCALlKOn02aPn26srOzJUk9e/bUtGnT3C0IQJtoOOcu1nllMh4xOVYB6EwInRBTvAPEJUlxLK2rQ/swAMSnuiYYMbuE0Klp6enpmjNnjvr06aPZs2crPT3d7ZIAtIGaYOQ5p9cTa7h08t28hmMVgM6EQeJoUklZtfYWV8S9vwnHv/yDYeIAEJ/KqshuUyspP7dPHmPHjtXYsWPdLgNAG2o408nn8dS2NEXJl6zky5wkcawC0Hkk1Om0fft2vfXWW6qsrKzfZtu27r33Xo0fP14nn3yyXnnlFceKhDs2f7unRfvHM0S8DsPEASA+5RUNljjT6QSgk2sYOkmS1xPt3NIoGTudAKAzSajT6ZZbbtELL7ygHTt21G+78847ddttt9U/Xrlypd59910dddRRra8S7a46EFLBzpKWvahFy+taWBAAdFLllQ1uA87xE0AnFwg0Puf0ebwKx3m3ZQBA+0mo3WT16tU66aST5PfX3krdtm098sgjOvTQQ7V161Z98MEH6tKli3772986Wizaz9aCvbLtln0yZELMdAIApzUKnUidAHRyDWc6SVJazLlOAAC3JBQ6fffddxoyZEj9448++ki7d+/W5ZdfroEDB+qoo47Saaedpvfff9+pOtGOwmFbW7YXtexFxsjY8YdOEnewA4B4lFc07HRieTKAzi1QEyV08vkbbbMMS+sAwG0JnbmGw2HZ9v721bfffluWZenEE0+s3zZgwAAVFha2vkK0u4KdJVE/QYrFhOIfIl6HbicAiC1QE2p0ccWxE0BnFy108kfpdCJ0AgD3JRQ6DRo0SB988EH94xdeeEH9+/fXIYccUr+tsLBQ2dnZrS4Q7csYo03b9rb8dS24c10d7sAEALGVllU33kjoBKATM8aopqbxIHG/19solLcYIg4ArksodDrjjDO0atUqnXnmmTrvvPP0zjvv6Kc//WnEPp9++qkOPvhgR4pE+9lTVKGyiigXOc1pwTynOlw2AUBspeVRjsdR79AEAJ1DoCYk00SYlOaLvEeSReYEAK5L6O511157rV577TU999xzkqTRo0dr3rx59c9/8cUX+vDDDzV37lxHikT72fRty7ucJJbXAUBbKIkWOhHZA+jEKqubPudM9/oVCO5/nk4nAHBfQqFTVlaW3nvvPX366aeSpMMOO0xe7/511JmZmXr++ed11FFHOVMl2kVlVY127SlP6LUsrwMA55WWVTXe6LEk7goOoJOqqqpp8rn0Rp1OhE4A4LaEQqc6o0aNirp9yJAhEXe3Q8ewtaCoyXblmIyRCbd8eR2ZEwA0rSYYUkWUiyuLu9cB6MSa63SSJdWdzhI6AYD7OHOFJCls29r2XXFCr01kaZ1EpxMAxFISbYi4xCBxAJ1aZYxOJ8uS0rz7P1O3DG2hAOC2hEOn119/XVOnTlXfvn3l9/vl9Xob/fL5WtVIhXZUuLNUNcEEupWU2NI6iesmAIiluDTK0jpJotMJQCcWq9NJktIPDJ2Y6QQArksoFXruued09tlny7ZtDR48WIceeigBUwe3paAo8RcncOc6AEBsTYdOJPYAOq9YM50kKd3nV1mgtlOU5XUA4L6EkqLbb79dmZmZWrJkiU488USna0I7Ky2vVlFJZcKvT3R5nRSx7B4AsI8xpsnQiZlOADqrmmBIVYFmOp18++c6eQidAMB1CZ25fvXVV/rZz35G4JQitramy0mtC52YJg4AjVVVB5te8kynE4BOqrQ80Ow+HsuS31N7V206nQDAfQmFTn369FGXLl2crgUuCIVtbS8sSfwNjJGxWV4HAE4qamppnUToBKDTKi2LcWw8QLrPL0nyMEgcAFyXUOh01lln6fXXX1eIWT4d3s7dZQqFwwm/vnVdTqLRCQCiKI615NmyxMETQGdUUt7EXT0bqA2djESnEwC4LqHQ6de//rV69uyps88+W1u3bnW6JrSjgp2t6HKSA6ETAKCRJoeI1/Ew1wlA51Mab+jk9bG0DgCSREKDxEeNGqVgMKjVq1frhRdeUHZ2tnr06NFoP8uytHHjxlYXibYRDIa1a295694kTLcbADgpHLabv7BiiR2ATiYUtlVREfvOdXW8Ho98HCYBICkkFDrZti2fz6dBgwbVbzNRPk2Itg3Jo3B3qWy7dX9HdDoBgLNKyqtlN/fzkzvYAehkiksqZVpwz+M0jpMAkBQSCp02b97scBlwQ8GO0la/hwm3LnQimASASCXNLa1TbScxAHQmu4oqWrR/miwxRhwA3MdHAJ1UdSCkPS384d2IMTIsrwMARzU7z0kSg8QBdDa7WzgSguV1AJAcEup0OlAoFNLXX3+tkpISZWVl6ZBDDpHP1+q3RRsr3FXSohblaFodONHkBACNxBU6cTEFoBMJ1ITiHiJex0s3PQAkhYQ7nYqKivSLX/xC2dnZGj16tCZMmKAxY8YoOztbv/jFL7Rnz56Ei3ryySd18cUX66ijjlJ6erosy9LChQub3L+0tFRXX321Bg8erPT0dA0ePFhXX321Sktbv3wsVX23q6zV79Ha0IlTAQCIVBMMqbI6jkG5LK8D0InsTqA732OMLBJ6AHBdQi1JRUVFOu644/T111+rd+/emjhxonJzc7Vjxw79+9//1uOPP66VK1dq9erV6tWrV4vf/+abb9aWLVvUp08f9e/fX1u2bGly34qKCk2ePFlr167VySefrHPOOUfr1q3Tgw8+qOXLl+udd95R165dE/ltpqxQ2FZxSaUDb9TaIeLETgBwoJKyOD/JZ0AugE6kpUvrpNoPRz0E9ADguoTOWu+44w59/fXXmjt3rrZs2aKXX35ZCxYs0EsvvaQtW7bopptu0jfffKNf//rXCRX1+OOPa/Pmzdq1a5cuueSSmPved999Wrt2ra6//nq99tpruueee/Tyyy/r1ltv1dq1a3XfffclVEMq21tc0fydkeJgwuHWvZ7MCQAilMYbOhHaA+gkjDHalUDoJDvMTRcAIAkkFDq98MILOuGEE3TnnXeqS5cuEc9lZmbqjjvu0IknnqgXXnghoaJOOukkDR48uNn9jDF6/PHH1a1bN916660Rz82dO1c9e/bUE088wR3SGkikRTmqVi+v4+8FAA5UEu/MEg6fADqJPUUVCtS08JzTtmWMzfI6AEgCCYVOBQUFGjduXMx9jj32WBUUFCRUVLy++eYbFRQUaPz48Y2W0GVkZGjSpEnavn27NmzY0KZ1dDStvmvdPsZuZehEGAgAEUrK4rlznUTqBKCz2L6zpMWvMXZtNz6NTgDgvoRmOvXo0SPmnCVJ2rJli3r06JFQUfH65ptvJEkjRoyI+nzd9m+++abJfTqbRO7+EZVhkHhrmb2FMt9+JavvQVJ2P5mNa2VldJWGHSFVVdQ+7tpDGjp6/2vCYdnrV8jKPVhWv0H7txtbZsNamQ0f1baTH3KMPMO/f8DzRoFAoFX1BkO1J3DVgaA+/aZQBw/oIY9n/9lcTTCsjduKVRMMy2NZ6turi3L7RJ+nVneDAAD7hUJhVVbFMUQcSc+2a3/ChcK2jDHauK1Y1YGwhg3KVmY6d/gF4hUO2ypM5OY3+85RPZalcCc94Wzu3M8U75D59htZfQbKyh3S7Ptx7gYgUQmd+UyZMkXPPPOMZs2apZNOOqnR82+88YaeeeYZnXbaaa2tL6aSktpPPpoKt7KysiL2iyYQCEQckFP9jnd7ih3qcmpl4CTR6WS2fy2VF8tUV8gKVkule2RK98jqf7C0c6tUtlembG/t4zrhoFReUhtWHRA6qbJM5tuvpB2bJcsr4/tYZvDhsvxpkmq/z+fMmeNI3ZUVZbrrtqtb9R75+fnKyMhwpB4gVZRVtC4YRvKoC53CYaOS8hrt3Ft7845deys1qH+Wm6UBHcrOveUKhVo+Q7TuPLUzL69z8txP4twNQOISCp1uu+02/fOf/9Qpp5yiqVOnavLkycrJydGOHTu0YsUKvfzyy+rSpUujOUvJ6O6779b8+fPdLqPdOLW0Tq1cWidJdifvdbL6DZaprpSVM0jqlSft3i5ldJUyu0l9Bkh7v5O69pAyDpib5vVJ/nRZOUMi3yyzm6y+B8kU75RsW9aAkZLP366/HwCt06LQqZOH9smurgvU67HUvYtf2d0zVB0IqVcPLtiAlijY0fKlddIBH45anTt4AoBkkFDo9L3vfU+vvfaaZs2apX/+85/65z//Kcuy6jtXhg0bpoULF+rwww93tNiG6jqcmupkqutairXMb+7cubr66v1dG6WlpTrooIMcrDK57C2pdOR9WnvnOolOJytnsKyc/QPzrR+cvP/J7r1kjf1R49d4ffIc/ePG2z1eWaMmSKMmNPt1j5hyiTzelgdSX37wd4VqKuRL66pDjzm7xa+3w0GtW/F/LX4d0Fm0KHSy7bYrBK1WFzr5fB55vR59b1hvlysCOp5gMKydexK4a50UebObTpo5paenKz8/P+Y+11xzjYqKitSzZ0/df//9zb4fACQi4cECxx9/vL766iutWrVKH3/8sUpLS5WVlaXvf//7Gj9+fLus+T1wZlM0zc18kmoPoJ3lIBq2bVVUOjQvxG5d6NTZAyc3ebx+eRPogjr8+BltUA2AOmUV8c/b4xgKINV9W1gsO8GA/cAxEJ5OmjpZltXscri667V49gWARLVqmqVlWZowYYImTGi+u6ItjBgxQnl5eVq1apUqKioi7mBXXV2tt956S3l5eRo+fLgr9SWb8ooaxy5UTCtDJ5sLJgCI0KIPBQydTgBSlzFGW7bvTfDFznTkAwCc4XG7gNawLEsXXnihysvLdfvtt0c8d/fdd6uoqEgXXnghd1rYp7wFn6I3i9AJABwTCtuqDgTjfwHL6wCksN1FFapI8G6etV1O+88zuQ4AAHfF1el0++23y7Is/fKXv1SvXr0aBTxNsSxLt9xyS4uLevzxx/XOO+9Ikj755JP6bStWrJAknXbaafV3xrv++uu1dOlS3Xffffr44481duxYrVu3Ti+//LKOPPJIXX/99S3++qmq1ME7I5lWXvCwNAQA9quobMkQ8fr/AYCUlHCXk1R7p98DMEgcANwVV+g0b948WZals88+W7169dK8efPievNEQ6d33nlHixYtiti2atUqrVq1SpI0ZMiQ+tCpa9euWrFihebPn69nn31WK1asUG5urq666irddtttEUvuOruy8iTqdOKCCQDqtWxpHctGAKSuyuoa7dyd4ABxRc5zkiQanQDAXXGFTsuXL5ckDRo0KOJxW1m4cKEWLlwY9/49evTQAw88oAceeKDtikoBLbozUjNas1beGDqdAOBALVlG0tpOUwBIZlu3F8m04sNJE2rY6QQAcFNcodPkyZNjPkbyqwmGWjYvJBZj1JqlHTYDcAEgQmV1CzqdCJ0ApKhQ2Na274pb9R4m3PB8l9gJANzUoQeJI36VVQ4FTtK+0ClxDBEHgEhV1S04RhPcA0hR2wuLVRMMNb9jLKEGy+sInQDAVQmFTp999pkWL16s0tLS+m1VVVW69NJLNWDAAI0YMUJ/+tOfHCsSrReoaeUP8AOYVl7wEDoBQKSqFnwwwPI6AKnIGKNN2/a07k3C4cbnqWROAOCqhEKnO++8U7/61a/UvXv3+m033nijHnvsMZWVlWnr1q265JJL9MYbbzhWKFrHsaV1kgOdTlwwAUAd2zaqaskxupU3cgCAZLRjd1mL5ttFY0Ktez0AwHkJhU4ffPCBTjjhBFn7bgcRDAaVn5+vY445Rjt37tSmTZvUt29fPfjgg44Wi8RVB5zrdGrNPBHbpssJAA4UqAm16OYKhtAJQApqdZeTGt+5TqLRCQDcllDotGPHjvo72UnS+++/r7KyMl1yySXKyMhQXl6epk+frnXr1jlWKFqnuiY5Op3ocgKASC3uRG3F3UMBIBkVl1Zpb0llq9/HBOl0AoBkk1Do5PV6FQgE6h+//fbbsixLJ5xwQv223r17a/fu3a2vEI4IONjp1JJP5BtinhMARGpp6ESnE4BU40SXkxS904lWJwBwV0Kh05AhQ7R8+fL6x88++6yGDh2qwYMH12/bvn27evfu3foK4QhHl9cpweDISGE6nQAgQouPz4ROAFJIdSCowl2lze/YHCOZULQQn9QJANyUUOh03nnnad26dRo3bpwmTZqktWvX6pxzzonY56OPPtKIESMcKRKt5+Td6xJF4AQAjbWo08kYOp0ApJQt24sc6YQ34aCifTBK5AQA7koodLrssst05pln6sMPP9Q777yjU045RTfeeGP98x9++KE+++wznXjiiY4VisQZYxQMun+RwtI6AGisJZ1OhnlOAFJIOGxra0GRI+8VvcsJAOA2XyIvSk9P19///neVlpbKsix179494vmhQ4fq448/1pAhQ5yoEa0UCtsyiS6JcxCdTgDQWCDYgk5U2/2uVQBwSsHOEtW05BgYC6ETACSlhEKnOllZWVG39+nTR3369GnNW8NBoZD7YY9tTKsGkANAqmrJjR6iDskFgA7IGKPN3+517v0InQAgKbUqdPr444/11FNP6csvv1RlZaVef/11SdKWLVv0/vvv66STTlKvXr0cKRSJCyXBcgzbdj/4AoBk1KKZe0lwPAcAJ+wtqVRpebVj70foBADJKeHQ6frrr9f9999f371iWfvH9BljdO655+r+++/XlVde2foq0SrJ0OnE0joAaCwcthUMxR8k0ekEIFV8W1js3JsZI9PE8mP67AHAXQkNEl+wYIF++9vf6r//+7+1fv16zZ07N+L5IUOG6JhjjtHSpUsdKRKtE3Q4dDowYIyHMYYh4gAQRYvmOYnQCUBqCIdtFe4sdez9Ync5cQ4KAG5KqNPp0Ucf1WGHHabnnntOPp9PaWlpjfY59NBD65fbwV1hp5djWC3LKsMsrQOAqFoyz0mSROgEIAUU7i5TKOzc+WHM0InMCQBclVCn0+eff66TTz5ZPl/TmVVOTo527tyZcGFwjtOdTmphpxNL6wAguppgCz4UsMMyHE8BpIDtTi6tk7hzHQAksYRCJ5/Pp5qampj7FBQUqFu3bgkVBWc5PsS7BZ1OxoildQDQhJYMETchupwAdHzVgaB2761w9D1jLT3mLBQA3JVQ6DR69GgtX768yTCj7k52Y8eObVVxcEY47OyPW8sTf6dT2OZOSwDQlBaFTiytA5ACCnaUyDgcBXF8BIDklVDoNGfOHH311Ve69NJLG3U8lZaWatasWSosLNRFF13kSJFoHcdnKrWg04mldQDQtJaETsxzApAKdu4td/5NYx0f6bgHAFclNEh8zpw5euONN/SnP/1JTz31lLKzsyVJxxxzjL744gtVVFRo1qxZ+p//+R8na0WCwg4OapQU90wn7loHALG1rNOJmSUAOrZw2FZRSZWzb2qHY3ZOcSYKAO5KqNNJkv7yl7/oscce09ChQ7V9+3YZY/Tvf/9bgwYN0h//+Efl5+c7WSdaIWw7/+PW8njj+Lp0OQFALMx0AtCZFJVWOT5r1DR7l2ZiJwBwU0KdTnUuuugiXXTRRaqqqlJRUZGysrIYHp6EHO90kiSPV2pmXhNL6wAgtpp4QyfDzBIAHd+eImcHiEuSaeZ8lMgJANyVcKfTgTIzM5WXl0fglKTc6HSyWVoHADEZY+LudKoNnDimxuPpp5/WjBkz9PTTT7tdCoAG9hQ7Hzo19yEop6MA4C5HQicktzbpdPLGDp1YWgcAsYXCtkLxHp+Z5xSX0tJSLVmyRLZta8mSJSotLXW7JAD7hEJhlZQ6PM9Jaj50IrAHAFfFtbzu4IMPTujNLcvSxo0bE3otnNMWAVBznU4srQOA2AKBlgwRZ2ldPB544AGZfW0Nxhg9+OCDuu2221yuCoAklVUE2qQL3jRznmtodQIAV8UVOtm2LSvOO5YdiIN8cgiH2+DvIUboFLbtlPy7N8YoEA4p3duqUWhR3teWAlWSxyN5fLJ8/trt1RVSWqZk7IiLqPrXhYKSHZaVllE7zyAYkJXexdHaALSd6pYMEQ/WtGElHZcJBiRJlj9dn6xfp6+//jri+a+++kqffPKJRo8e7UZ5tXdxtY08nshzKNs2qgmFlZHm7M8TIJlVVbdRx2ZzoVPbfNUOwRgjBSql9EwpUC2lZcjyNF7oYoyRCQVl+fz7zi9DstIy43r/QCDQqhpt29QPl7dto7LyClmSwnbtDbONkfw+S8GQUZrfE/OaND09PaFrVgBtK66znc2bN7dxGWhLbbG8LlanU6p2OQXCIb2+/Usdn3OwejoY7pgvP5Ap2CirpkrqO1A64gSpcJPMtq9kumfLCodrTxgkKVR74WlqqmXWrZBCNTKHHiNt+VyqLJOGjpbVP7HORADtKxCI/wLMhFhe15CpLJX55C1JUvjQcXrkoYei7vfII4/o//7v/+SJcqHV1mqCtj75ZpfGjOwbcSH02YbdKqus0aDcLA3M7d7udQFuaLPQqZnzzlT8IDRumz+V+e4/MsaWZXmk7j1ljZ7UeL+aapmP/iXzveOkL9+XgjXSocfK6pkT8+0DgYDmzJnjWLnFxUW6+BcXJfz6/Px8ZWRkOFYPAGcw06kTaJP5SjFmOjl9K9xkYSTZxlZ5sHWf6DRSUSwFAzI1VVJNoPYHf0VJ7XPlxVJV+f4pmHX/X1MlBQO1j+v2kaS61wFIenF3OnHnuuiqyqVwWAqHtfbfH6i8Ovqxuby8XGvXrm3f2g5QVR2KGGRsjFHlvovviirCRHQeVS0I2lukmVCpE0dO+88nS3bX/n9ladMhXCgolRXVnosaI1UyEw+AM+jr7gTapNOpiSVmYdtO2R/ufo9HI3vkaEDXHo6+rzXyKCl7W+1SuR59ZHXtIQ0ZJaV3qf2EKRySfC9KqpH2Lb2zuvWUDh5TGz7lDZe6ZEmle6QBwx2tDUDbqY7zU38TDqpzXzY1oVeurEGHSZK+3/9gdXvqHyqvrGy0W7du3XTkkUe2c3G1vF5LI4f0ilheZ1m124pLA+rfr6srdQFuaKtOp1idTLVPdd7jp3XwEVLhJmnED2SVF0vZ/aIvP/P6ZA05XFb/g2UsT22Hfe7QFn2tI6ZcIo/Xn1CdX37wd4VqKuRL66pDjzm7Ra+1w0GtW/F/CX1dAO2D0KkTaJOZTpYly+OTsSM/fU/lu9b5PF4dkh27zTgRVlYfWVl9IrdldJWG7p9BYvnTav//gGWN1oEnA73zan8B6DCq4hwkztK66CzLIw0cKUnySrr8yit19913N9rvyiuvdGVpnST5vB716tF4qUfPrAz1zGIJCDqXyur2n03X2e9cZ3XpLh08RpYk9T2o6f18fll5tR9cWrlDEvpaHq9fXl9iodPhx89I6HUAOgaW16U4Y0ybdDpJkuWLzCyNSd15TgDgtOp4l5owRDwuo0eP1siRIyO2HXLIITr88MNdqgjAgWpqwm3zxjE7nTp36AQAyYDQKcXZtmm7T3kaLLEL2210MgEAKSjepSZ2iNApXldffXX90hHLsnTVVVe5XBGAOm7cVIzQCQDcR+iU4kJt1OUkNZ7rRJcTAMQnHLZVE4xjeZ2RDJ1OccvKytL06dPl8Xg0ffp0ZWVluV0SgH08LqROnJkCgPvimul0++23a8qUKZo0KcotNpHU2mppnRQZOhljZPNpEgDEJd67OJlQjTrzENxEnHXWWTrrrLPcLgNAA5anjUKnGGGWMbYrHVYAgP3i6nSaN2+eVqxYUf/Y6/XqjjvuaKua4KC27HTSAXeoCKXwAHEAcFpVVZyhE11OAFJEm3U6xQydCO0BwG1xhU5du3ZVVVVV/WNjDAfxDiIUautOp9of9CytA4D4xXsXJxMMtHElANA+PG3U6dTUuxrT2e9dBwDJIa7ldcOHD9fzzz+vn/70p8rJqb1lfHFxsbZu3drsawcNGtS6CtEqbdrpZNXeYjVcEyCEBIAWiHeIuKkhdAKQGtq704mxDwCQHOIKna655hqdf/75GjduXP22hx9+WA8//HDM11mWpVAojkGpaDPhcNveUc7y+RUOVDW/IwCgXmUcoZMJ1sgY7goKIDVkZvhVXNYG54xW9IUbhE4AkBziCp1mzJihYcOG6aWXXtL27du1cOFCjRkzRkceeWQbl4fWatNOJ0ny+lhaBwAtVFHZfAeTqaluh0oAoH106ZLWNm/siR460YUPAMkhrtBJko477jgdd9xxkqSFCxfq9NNP16233tpmhcEZbTnTSZKClsUPdQBoAWOMKuMYJE7oBCCVdM1sm9DJarLTiQ9FASAZxB06HWj58uUaMmSIw6WgLbR1p1OVbcvbpl8BAFJLTTCsUHNLn42RzZ3rAKSQtgqdos10shkiDgBJI6HQafLkyRGPKyoqVFpaqqysLHXt2tWRwuCMUKht54FUhsPqblkS3U4AEJeKqubDJLumWuKSCUAK6ZKZ3jZvHKXTybY5fgJAsojejxqHYDCou+66SyNHjlRWVpYGDhyorKwsjRgxQnfddZdqaviENhm0ZadTdSgo2xiFLXqdACBelZXN/3w01ZXtUAkAtJ/0NK983oQvPZoWZaaTLZbWAUCySKjTqaqqSieffLJWr14tr9erkSNHKjc3Vzt27NDGjRt1yy236MUXX9Qbb7yhzMxMp2tGC7TlTKeqfUs/wl6PvPxsB4C4lDc3RNwY5jkBSDmWZSmre6b2Flc4+77RQic6nQAgaST0ccN9992nd999V+ecc47+85//6IsvvtDy5cv1+eefa9OmTfr5z3+u9957T/fdd5/T9aKF2rrTSZLCHjqdACBe5c10OpmaahkG4AJIQT2z2uDD6AbL64wxYqITACSPhEKnv/3tbzrqqKP05JNPauDAgRHP5eXlafHixTrqqKP0t7/9zZEikbi2Cp1Ctl0/CJfQCQDiV1EVu9PJZmkdgBTVs0cX59+0QadT2Ca0B4BkklDotHnzZp100kkx9/nhD3+ozZs3J/L2cFBbDRKvDu3/pJ7QCQDiY9tGlbEGibO0DkAKa4tOJ6tBp5PNzW0AIKkkFDp16dJFu3btirnPrl271KVLG3yagRYJt9Ga9upg8IBHlmyCJwBoVmV1TcxZIyytA5DK0tJ86trF4bvYNQqdOIYCQDJJKHQaN26c/va3v+mzzz6L+vznn3+uv//97zruuONaVRxaz26D5XXG7J/nVP91ogxxBABEKq9gaR2Azs3xbidLsmRJqu0mpc8JAJJLQnevu+mmm/Svf/1LRx99tC644AJNnjxZOTk52rFjh1asWKEFCxYoGAxq7ty5TteLFmqLTqeacEimQety2OOVT8EmXgEAkJoZIm6MTKCq/YoBABf0yu6ibwuLnX1Tj0eywwrT5QQASSeh0On444/XU089pQsvvFB/+MMf9Oijj9Y/Z4xRjx49tGjRIo0fP96xQpGYcBt0OtWEG4dLzHUCgObF6nSyA1XccQlAyuvTs5vzb2rt63QidAKApJNQ6CRJZ5xxhk455RS98MIL+vjjj1VaWqqsrCx9//vf1/Tp09W9e3cn60QCjDFtcgePQDjUaFuY5XUA0KzyyqZDJxNgaR2A1JeZ4VfXzDRVxLqpQktZHhnDEHEASEYJh06S1K1bN82YMUMzZsxwqh44KNaw2taoCTUOnWzLU/spEz/sASAqY0zTnU7GyAS4ax2AzqFPz26qqNrr2PtZlkWXEwAkKdpTUlhbLK0L23YT3VOWwhbfTgDQlMqqYJPdpyYYYGkdgE6jd8+ujr8n85wAIDmREqSwthgiHm1pXf3X8zLXCQCaUlbRdCcTXU4AOpPePbvU33HOCUYWS+sAIEkROqFFamKFThahEwA0pSzWEPEaQicAnUea36es7hmOvZ9t7EZ3VgYAJAdCpxTWFks1QuFwk8/ZDBMHgCY1Nc/JhMMyUe4KCgCprHd2F8feK8jSOgBIWqQEqawNPvAJ2k2HTmEPnU4A0JTSJpbXmZqqdq4EANzXK9u5uU7hGB+KAgDcReiUwtqiyzgUI3QyllV7BzsAQISwbauiMvrtwU2ILicAnU+vbGfmOhkjhWOcnwIA3JVQ6OT1evXzn//c6VqQ5EK23Uz3FHewA4BoKiprmp43Emp6Vh4ApCq/z6seDsx1qgmH2uaTVgCAIxJKCLKysnTQQQc5XQsc5+wP4FhdTnVsltgBQCNl5THuXMc8JwCdVC8H5joFwkEH74MHAHBaQqHTMccco3Xr1jldCxzm9Gc+sYaI1wkzTBwAGmnyznXGlmFZCIBOyom5TjWhkCw6nQAgafkSedH8+fM1efJkLVq0SDNnznS6JjjE6U99wnHcGaSjdTqVB6tVWFmqAV2zlelLi7pP3e+74dKYoB3W1vK9yk7rot4ZiZ00mZJdUkWJTPfeskp3S30GykrPjP0a25Z2bpHSMmX1yk3o6wJoX02FToaldXEx4ZC0Y4tMZnfVZGbp/2fvvuPkKuv9gX+ec6bv7Gzf9EJIo4RQQiC0hBoEBEGQ4lUgonD5eaUpAgIJoiBesFzLVdSAXqVd2xVRmlJEUEGkQ0hC+mb7zs7s1FOe3x+b3ezszu6cmTmz0z7v14sX2TOnPJvNPnPme77f7yO7d0EaOoRpAr5aiLrmvfv2tUP2dQBeP0TrXAhVhdTiQPcuyJp6iEgQ0uOHx0hANEyBqKnLaiyhgQQGohpam3xwqOkftAy9X5jmxB+EO3ujEABaGu1bxYuonDQEJr7nsSJhaHAVYvWcPEgpkUiM87BhAnFDQ1skiCm+AGocbgCA2+2GsLFnqoyFgd52oHnG8FzFhx9EVEg5BZ2efPJJrFq1CmvWrMF3vvMdLF++HFOmTBkzIQohcMstt9gyUMqeOs7NcK5MC0+RzDJrJP6Pzm2I6Al0xQewYsq8Ma8nDR3JPRle+qig24ZgB7aEu6EIBafM3A/OLANuUktAvvs3wDQhoyHAFwD6uyD2P2riA9u3QG59azCquPQECF9tVtclosk3Xnkdb/Qt2rURcuf7iOsGLvvBL2055Y8+cw68/lqIZastH6MbJt7Z3ANTSiSSBvaZmT5gNfR+qekmwpEkamvGPtToCcawaXsfAMDpUFAfyL+3DVG5cbkc8HqciMVzKzPWTQOmaZZcT6dEIoE1a9bYcq7169fD47FvfpDv/QOIDQDBTmDoPUhLQoZ7IWobbbsOEdGQnIJO69atG/7zq6++ildffTXtfgw6FZei2BsAspTpVGaNxN2qAxE9Abea/ldBEWJ4Qb7Rf5tDx7gUFUouwTahAKoTMBOAe/Apt3BZuKlwufcMzgGMM24iKh2abiCWYN+mvDj3zHsO++Y8IQRgZc4dQRECDoeCpGbA6Rz//W7kilwOR/r9nA5lcD8x/j5E1aCu1ptz0Cmh61DMzPenNILTDcQGIJzu1FWnx8n4JyLKV053b88884zd46ACUG3ur2Ql00kKMfgGVmJPnMZzROtc9CfjaBinpM2hqHArDkT3/HmkBXWtaPLUoMbhhppDsE04nMDSVUAiCuGtBaL9gD/zEybRPBPw+AGnK2MpHhEV37j9nMgyMW0e4G+Ax+XG+vWnQMYHBhsXGjrg9kA49waPrrv2WvQFg2ioq8M93/wmgD1lyZE+SG8AIhaG9NbAYyQhauqzGoeiCCxd2IJ40kibvTRyPwBwORV43elvtQJ+N5YuboGAgNfDBwhUvepqPWjvCuV0bNLQoVh4KDrZ3G431q9fP+E+1113Hfr6+tDQ0IB77rkHAGBKE8FkHHVON9Q9951ut9vWsYn9jgQiQcDfCKHcP7jR5Ybw+m29DhHRkJzuclauXGn3OKgAFEVAQEDaVOduWnqSJGAKBYosj5IRh6Jm7Mc0UR19ozu/BpjC5dn7pD3QPPHOI4/z1+d1XSKaPBOtXEfWidoGCAAeAJig1ETseeAiVDW1JMW3p2+SP7+SZKdThdNprZw6Ux8Wn8eZ11iIKkHAn/sDtFINOgkhMpbEDc0Po/f1eQvb402ojjH3nKLMKhWIqLxwhqlgQggoqn0ldlYynYDyK7EjIiokZjoREY2vrjb3fkVJg+V1RESlLufogK7r+OY3v4nly5cjEAjAMaLPwmuvvYYrr7wS77//vi2DpNzZWWJnWsyYMm0u6yMiKmcTBZ3Ka+kFIiL7uV0OuJzZF19ohgFIQGXQiYiopOVUXheLxXDKKafgxRdfRHNzMwKBACKRyPDr++yzD+677z40NjbiK1/5im2DpeypdjYTt1ilx0wnIqJBUsqJy+uyXPWSiKgS+TxOJDU9q2OSxuD+KlcBJSIqaTlFB+644w789a9/xZ133on29nZcdtllKa/X1dVh5cqVeOKJJ2wZJOXOat8JK6z2hpK5rORGRFSBEkkdmj7+ByKhMuhEROTJob9ZwtAgpAlRgj2diIhor5yCTg8//DBWrVqF66+/HkKItI0y582bh+3bt+c9QMqP0zH5H2hMBp2IiABY6OekqGzgSkRVL5em+pphMMuJiKgM5HSnu337dhx++OET7hMIBNDf35/ToMg+LhsznaxiphMR0SBLTcTVnCrdiYgqhjfLoJOUg+V17OdERFT6cgo61dbWoqura8J9Nm/ejJaWlpwGRfbJpTHjuNjTiYgoK+HIBP2c9hAMOhFRlfN6XFntnzR0QAIOI7s+UERENPlyig4ceeSRePTRR8fNZNq5cyf+8Ic/4LjjjstrcJQ/O3s6WcVMJyKiQQMDmTOdGHQiomrncWc3DyYNDYCEw2TQiYio1OUUdPrCF76A3t5enHTSSXjxxReh64MTfjQaxZ/+9Ceccsop0DQN1157ra2DpezZWl5nOZYkAAaeiKjKSSkxELUQdHJm94SfiKjSqEp2H0kShj7Yz0laTMMnIqKiyenx6nHHHYfvfe97+NznPodjjz12eHttbS0AQFVVfP/738dhhx1mzygpZ8Xo6QQMZjsJ3ggQURWLJTToRuZ+I8LBoBMRVTdFze5hZVLXWVpHRFQmcs7pv+KKK7By5Ur84Ac/wN///nf09vYiEAjgiCOOwJVXXokDDjjAznFSjuzs6SQgIC02dpIQ1hOjiIgq0ICVJuIAoKoQigrJVZiIqEplk+mkmwYM04SXQSciorKQV0Riv/32w7e//W27xkIF4M6yRn4iQljPYmaOExFVO8tBJwyW2MlErICjISIqXapi/VFlXB/s56QaDNQTEZUDLjNW4TwuezOdrO/MPCciqm5hC/2chrDEjoiqmZJFplNC1+DcE3giIqLSl1dE4q9//St++tOf4rXXXkN/fz/q6upw8MEH45Of/CSOOeYYu8ZIeXA6VSiKgGna8MacRRyJtwFEVO0GIknL+wqnu4AjISIqbYoiLLdxiOs6vIY2CaMiIiI75BR0klLiyiuvxL333gu5p95KURSYpolXXnkFP/nJT/CZz3wG3//+9yGY8VJUQgi4XU7E4tY//Ix7rqy6NPHnTkTVS0qJSDaZTlzBjoiqmGlKSwEnzTBgmgabiBMRlZGcyuvuuece/PCHP8SBBx6I//3f/0V7ezt0XUd7ezseeeQRHHDAAbj33nvxjW98w+7xUg48NvV1yiaMJBlsJKIqlkjq0PQs+o0IAaE6CzcgIqISZpiZV/oEgJieHAw4cYVkIqKykVPQ6d5778U+++yDl156CR/96EfR2toKAGhtbcW5556LF198EXPmzMEPf/hDWwdLufG47fkgw6w1IiJrBqLZZ5eyxI6IqpWuWws6xXUNLp2ldURE5SSnoNOOHTtwzjnnwOfzpX3d7/fjnHPOwY4dO/IaHNnDrmbiDDkREVmTTWndEJbYEVG1MozMQScpJZJaEk72cyIiKis5BZ1mzpyJeDw+4T6JRAIzZ87MaVBkL7dd5XVZZTox7ZmIqldumU4MOhFRddItBJ1iugaHrrG0joiozOQUdFqzZg0eeeQRdHR0pH199+7dePjhh3HZZZflNTiyh22ZTlkEnZgVRUTVLKdMJ9UJzp5EVI2sBJ3iWpKldUREZchSNGL79u0pX19wwQV46aWXcMghh+Cqq67CMcccg9bWVnR2duIvf/kL/uu//gsrVqzAxz72sYIMmrJjV0+nrPAhFBFVsWgshxVDBSBUByRLR4ioyiS1zKvRxbUE/Fy1joio7FgKOs2dOzdtlouUEjfddFPa7Y8++igee+wx6DrfHIrNvtXr+ASeiCgT05SIxnMLHAmHk0EnIqo6sQxzZkLXoWoJ8KkmEVH5sRSN+OQnP8mVy8pYMTKdBG8KiKhKReNJyBx7jgiHE8i+Mo+IqKxlCjrF9SRcWg4ZpEREVHSWgk73339/gYdBhaSqCpwOFZpu5HUehh2JiDLLqbRuD+EoQjk0EVGRZQw6JWLwmvndxxIRUXHk1Eicys9kZzsJrixCRFUqn6ATVAadiKj6xBPjB50M04SSiE3iaIiIyE4MOlUJW/o6ZZHqxKATEVWraCz3nkxCtacHHxFROZmoD16Mq9YREZW1nINOL774Is4++2zMmzcPbrcbqqqO+c/h4M1zqXC7JvNnIRl0IqKqFY3nkekkAKGo9g2GiKjEJZM69AlaQCTjEQhpTuKIiIjITjlFIn7+85/j4osvhpQS8+bNw/LlyxlgKnF2BJ2yiyMx6ERE1SmfTCdgMNtJsncJEVWJUGT81ROkBJCITt5giIjIdjlFIm6//XY0NDTgj3/8Iw4//HC7x0QF4HLm/+RcWgwkMcuJiKqVlBKxfDKdAEB1ABqXsCOi6jAQiY/7WlJPwsHSOiKispZTed327dtxwQUXMOBURlx2lNdZjCUpDDoRUZXSDRO6kV8ZiFBZXkdE1SM0MH6QPRkdyDbVnoiISkxOQae5c+cimczzSS5NKpcz/6CTyUwnIqIJZVr22xL2dCKiKhIeGD/TSSYikzgSIiIqhJyCTldccQV+//vfo7e31+7xUIG4XTaU11kMJils9khEVcqOoBMbiRNRtZBSIhxNn+kkdR1CY2kdEVG5yyn95aqrrsKmTZtw9NFH4+abb8bSpUsRCATS7jt79uy8Bkj2sCPTyWoCU7kFnQxp4rXunUiaOg5pngWP6iz2kIaZ7/0d8oM3IPXBzEIpTZhvvQDh8QH7Hgwhcl6AkogKoJIznaSUSCQy95pqj4Wwub8bs/z1mO1vHPN1wtDxdrgDbtWJg5tnQrU4j8n+Lsht70A0ToOYuXDCcQKA1JOQpgmhKJCmAfn+K5C7NkK0zoJYfCSE053195lIGti8IwiPW0V9rQdtXQNorvfC7XJgV2cYzfVeTG2u2TsGKRGPj83i2NkeRnAggTnTAqitcU34fbvdbgghJtyHqFxFYkkY45Qka9Gw5X6ipSJp6HitZycA4JDmWXCOms/jhobXunfCoSiWH+Zmy2zbBLzzEqQvADicQH8XxL4HQ5m3NGU/aeiQ2tD9ZepYzGAX5KtPQjhcEMtWQ/jSf84jIrIi50jEwQcfjJ///Of45Cc/Oe4+Qgjoup7rJchGLhsynUyLwSTFLK+gU088grZoEADQFunHvEBzcQc0gtzwMhCPAHtuCmAYQKgHMtQDMXUfwN9Q3AESUYp4onIznRKJBNasWWPLuc677Vo4XC7Mjjeixeu3dIxs2wwMBCEjQWDGgvEDMeae+w7DAAb6gEATEO6F3LUR6N4FqWsQrXOAKXPTHm7n99nX15f3udavXw+Px2PLeIhKTbA/Nu5rRnxgEkdij45YGB2xEACgMxbGjJr6lNd3R/vRFQ8DsN62ImsfvA7Z0wZ07wIUBZASUnkTcuYiCNeIuaS/GxhaKXXUiqlyx7tA105IAaB9C8SogBURUTZyCjp95zvfwdVXXw2n04njjz8e06ZNg8NhQ6NqKhhVUaCqyrhPk6wwrAadyizTqcHtQ4O7BpqpY4q3ttjDSSFm7we59a3BJ1VIDmZAeHyApwYosbESEZBIpj5o0QwDHQP9WZ5Foi5DSUl/vivkFVmNw40atw/1bq/lY0TrbMhIcDDTaaLMn6GgnaIANXV7LlgPNM8A4hGIxqlAfWvugyci2/SFomm3y2QCpmGkfa2UtXj8CDi9EAJo8tSMeb3VE4Df2QunokBBgTIYZy4cDCh5/Xsynbohps8DRmd31jYOzpPAmAxbMW0e5I73BjOdmmcWZpxEVDVyihR985vfxIwZM/Diiy9i5kxOROVCVXIPOhnSzGL1uvIKOjkVFcdM3bfYw0hLOeRE4JATIf70WQARCEWBcujJxR4WEY0jnkgNOimKyKmEQgpMWNNcjJITt9uN9evXT7jPddddh76+PjQ0NOCee+6Z8FzZloyJpukQTdMz77enXE843RDq4G2OcDihLj0eWHp8VtdcuuoKKDmUXL/3j4ehJyNwuGqwePn5WR9vGhpef/YHWR9HVG76xsl0MuMRyDK7nwQAj8OJldMXjPt6jdOF46cPlgc/VKCyWWXuEmDukoz7CadrT5lxZMx8rDTPBE77TEHGR0TVJ6egU3t7Oy6//HIGnMqM06EgmWPlh2la/YAjISzvS0RUWUaX16lCAQQsB+2HmEKBIkvrKb8QImOZ19AHFyv7lgNFdUJ1ZB90OuCofyvAaIgqi6YbGIik6Z8mJcx4FCZXQyYiqgg5dSGeP38+gsGgzUOhQlPV3JtO66a1Dz9CSmT96YqIqELEk2P7GHqdEzeKTkcWquyCiKhE9PXH0mZtmomo5T6iRERU+nKKQlxzzTX4v//7P2zbts3u8VAB5RN0svq0SbUYnCIiqjSGYULXx86BNeOskjYRydXKiKjCBcfr5xSLFmxlNyIimnw5ldftu+++WLlyJZYtW4arrroKBx98MAKB9EtpHnfccXkNkOzjyCPopFkMJqlltnIdEZFdRjcRH+JxuOBQFehZ9NQzGXQiogrX3RcZu9EwYGpxltYREVWQnIJOq1atghCDzVFvvfXWCZuBGmW48kSlyivoZKT/MDWawkwnIqpS4wWdhADqPTXojoQtn4uZTkRUyTTdQDA0tom4GR8MRLG8joiocuQUdMoUaKLSlE95nWYxeMjyOiKqVun6OQ3xOl1wO51IaNZWc2DQiYgqWU9fJG0J3VDQieV1RESVI6eg07p162weBk0GRcntQ4wpJQxLZXMSKp9MEVGVSk4QdAKARq8f7XrQ0ocpNhInokqWrrROJhOQhg4p07UXJyKicpV76guVHZHjhxirWU5CSoBPpoioSo1XXjfEoSho8NZYOxkznYiognX3DozZtre0jveSRESVhEGnapLjZxjNtNbPiaV1RFTNksnMc2CNyw2fK/NqdiyvI6JKFYkmEYklUzdKCRkfXM2OQSciosqSU3mdoiiWejoJIaDr1gIWVHi5foRJWvwZOtg0noiqWEKzNlc2ev1IGjr0CeZMltcRUaXqGifLaaiojv2ciIgqS05Bp+OOOy5t0Km/vx8bN25EJBLB0qVLUV9fn+/4yE45PjlPGNYa3zLTiYiqWabyuiFCAM2+WnQMBMetSJaMORFRhWrvDo3ZZsb29nhiphMRUWXJKej07LPPjvtaNBrFDTfcgMcffxxPPvlkruOiAsjlM4xhmtANa03EHRbL8IiIKlGmRuIjOVUVDV4/eqNjn/gTEVWqZFJHbzCask3qGqQ+WG432EScQSciokpie08nn8+H//qv/0JdXR2uv/56u09P+cgh6pQwrH2IUqTJJuJEVNWsZjoNmbi/E1OdiKjydPQMjCmfk8xyIiKqaAVrJH7sscfiscceK9TpKQe5fIRJ6MnMOwFQ2c+JiKqYbljNCk3V6K2BQx37VsyPXURUidq7RpXWSTm8ah0AGAw6ERFVnIIFnbq6ujAwwLKBUpLL+3jcahNx9nMioiqWTWndSEIINHr9aV7Ic0BERCVG1w1096V+NjATMUi5N2BvyuyD90REVNpsDzqZpon/+Z//wcMPP4yDDz7Y7tNTHrJNWTakOeHqSiOpFsvwiIgqUTzHoBMAuB1O1LhHl9kx6kRElaWzZwCmOX5pnZRcuY6IqBLl1Eh83rx5abfruo7Ozk5omgaHw4E77rgjr8GRvUa/0WcS06yV1gGSK9cRUVXLtp/TaPWeGkS1JOTwPM0PXkRUWXa2B1O+loYOU4sPf80sJyKiypRT0Mk0TQgx9ims0+nEgQceiGXLluGzn/0sDjzwwLwHSPYpVNDJwSwnIqpyiYSW1/GKEAi4veiP7VnViTEnIqog8YSG7t5IyraRWU7AYIY9ERFVnpyCTlu3brV5GDQZsklZlhKI69Y+RDHoRETVLp7Ifx6sdXkRTsRgmhKCUSciqiBtHf2Qo+a1kQ3EgewfjhIRUXkoWCNxKj3Z9HSK6UnLT9oZdCKiamdH0EkIoMblsWE0RESlQ0qJne39qduSccgRrRlMU44JShERUWVg0KmKZPMEif2ciIisy7en05Aa52BDccHPXkRUIUIDcYQj8ZRtJkvriIiqhuXyuiuvvDLrkwsh8L3vfS/r46gwsgk6xXX2cyIisiqWZ0+nIU5VhVNVIQ17zkdEVGyjs5wgTZiJWMomNhEnIqpcloNOP/jBDyyfdGSTcQadSodpWntDj+ua5QCVk0EnIqpyUkrE4/YFidwOJ5KjPpAREZUj3TCxa9SqdYMBp733mVJm1wKCiIjKi+Wg0zPPPGNpv+3bt+PLX/4yNm/enHaFOyoew2IgKZJMWD4nM52IqNolNQOGxaC+FR6HExo/gBFRBWjr6Iemp7ZhkHFmORERVRPLQaeVK1dO+HpfXx/uuOMOfO9730M8HseKFStw11135T1Aso+VD0VSWu/nJKQJhf2ciKjKxW0qrRviVFUIfggjojInpcTWnb2pG00TZjK1vxP7ORERVTbLQafxxONxfOtb38LXv/51BINBLF68GHfccQc+8pGP2DA8spNhZH5yHtOTkBafsDvZc4SICFEbS+sAQBUqBFdxIqIy1xuMjm0gPqq0DrDe/oGIiMpTzqvXSSnx4x//GAsWLMBNN90En8+He++9F2+99RYDTiXKMDK/qUdGPX2aCPs5EREB0ZjV1T6tEQJQGXMiojK3dVfvmG1ydANxUzLETkRU4XLKdPrtb3+Lm266CRs2bEAgEMAdd9yBq6++Gh6Px+7xkY0yPUkypURct/rEXrKfExER7A86AYDKj2FEVMZicQ0dXeHUjRKQWmrfUPZzIiKqfFkFnV544QV88YtfxN/+9je4XC5cc801+NKXvoSGhoZCjY9sIqXM2Eg8mkyMzngel8MwBhtAERFVuWjM/lJjxTTBj2JEVK627uzB6BwmqSchRwWZuGodEVHlsxx0OvPMM/HYY49BURRcfPHF+PKXv4yZM2cWcmxkIymRsVfTQFaldeznREQEABG7M51Mkz2diKhsJTUd29v6xmyXae4zmelERFT5LAedfv/730MIgdmzZ6O9vR2f+cxnMh4jhMBjjz2W1wDJHplWrtMMA5phdSU6ltYREQGDc2vc5kbi0uT8SkTla9uuPuhp+oiOLa1jPyciomqQVXmdlBJbtmzBli1bLO0vhMhpUGQ/M0NpXTZZToppQjGtBqiIiCpXJJocU0KSL2n5AQARUWnRDRNbd45tIA4JyGRq0MnqaslERFTeLAedrAaaqDRNlOkkJRAZ9fRpIq4yKq2TUiKRsP69pTPUgF1KiXh8MDinmwYMKeFW9/4KSSkRM3R4VAeUEQFXKSWSySRcLte4gVipawAkhMM1+HUiCjg9EIoC0zCGP4RKKRGLRgA9CeHypp7DMABTg3CObeg/NO5SwRtNqhSRaH7zS1olnkmqmQbMUfNfoUkpgUQUcPssP9CS0oQ0TSAZAyAAlxtCUQs7UKIqt6OtD0lt7BwmDW1sj6cKvhcwpURM1+BzOCGEQFRPwq06oIrMC4fHdQ0ORYEjz/lKagmYyTiEaQIuN6AlIWrq9sylXogRY5Hm4Hwpk3HA0CB8tcOvG/3dgFCgBhrzGg8RVS/Ld4xz5swp5DiowCbKdIrpScgMmVAjOS2vcFd8iUQCa9asseVcfX19tp0rnzF86rJPF3UMdkgmk/B6vZl3JCpxAxH7V66TJTzHRvUknt+9EYY0saJ1Hho9NZNz4U3/guzaAdEyC1hwqLVjkgnIv/wvZDw62Cdrxr7AkpXMwiYqENOU2LKjJ/2LaYLpZgUX173WswO7IkHM8jci4PTg7b42BJxeHDttfsqDydF2R/vxStd2eFQHVk1fCGeOgScZ6Yf52p8G506Hc3ChILcXcuYiCCmBxqkQi4/YG/iLR2A+9zAQDQHxKLD/Coj9joSx4WXgr78GFBXmygug7HNgTuMhouqWOdxOFWGioFNWpXWSpXVEREMGCpDpJDX7A1l2ierJ4UynkDZ5GZQyEkz5v+XjQj1AMg5ocSAaBti0mKhgdnUEEUukD5qnC6ZXcqZTfzI2/P/Qnj+HtXjGxumhZByARNzQkMgn6zU2ACTigJYAtCQQjwCmCfTtHnx9aC4d+TPo6wCSCcBIAgN7GsH3tQ8GDHUN6O/IfTxEVNUmLzeeispI09ARAHTTREKz/lS9nLKcRqu5+GQIZ/ZPjKK/fREymoDwueH7yFFZHSs1A5GfPjX89XeXeuDOIdT7lfcS6Ncl6hwCNy92Z3VswgQ++3pplde5XK5iD4HIFrYHnaSELOES5maPH/s3TINumpjlb5i064r5hwCdO4DWWdYPUh0Qh58GhLoBKSFaZrG8jqhATFNi49bucV+XaQIoFRxzwsFNs7Az0ofZ/ka4FQcciopmT03Gkrl5gWYY0oTf6Ybfmd39XoqmaRALDoX01ACKOlhOp2uQCw6B6O0AmmcAAISy56bU4QCOPhuirx2IRyD2PRgAoCw9HmYiCggV2C+7e2AioiEMOlWJ8TKdIllkOQGAs4Q/DGUinCqEM/t/8jXnHWfbGNwK4FGzL+34ygFj+zRZV3p3dSxvoUpgmhIDEXuDTqVcWjdk30DLpF9T+BuALINcwuGEMnUuMHVuQcZERHvtbA8iFh8/SzNt0KkE70/s0uD2ocHtG/76wMbplo5zKir2b5iW9/WFUCBmLQZmLR77Yv2Usfu7vFCnzAGmpLZTEV4/1JXn5z0eIqpuLK+rEmaax0lSAgNJ6x+YhDShlniDWyKiyTIQTaSdW/NRDkEnIqKRTFNi07auDDuxNQMRUbVi0KlKpPtcFNeTwyuzWeHihyEiomHhAfvLVmUWK4kSEZWCHbv7EItnuEccdb9ZyaV1RESUikGnKpGuWWM2DcQBwKmXbnNbIqLJFipE0CnLeZmIqJgM08TmbeP3chpSyU3DiYhoYgw6VSnDNBHPInNJkQZUpkYTEQ0LDdjdz0mHHJpn+fmMiMrAzt3jr1g3TEpwUiMiql4MOlWJ0U+YBpLxrN7/y3nVOiIiu0kpbc90YpYTEZUTwzCxyUKWE6T1Vg5ERFR5GHSqEqOzmiNZNBAH2M+JiGikeEJHUrN3YYWRQadKXtWJiCrDjt19iGfKcgKY5EREVOUYdKoSIz/AxLQkjCwaiCumAYWldUREw/rDMXtPKGVKE3G2PyGiUmY5y4mIiKoeg05VYuQHmGwbiLvYQJyIKIXdpXVmMg45ogSFmU5EVMq2t/UhkbSY7SkKOxYiIiptDDpVCbHnDT/bBuKAZGkdEdEo/WGb+znFIsN/NpnmREQlTLchy4lxKCKi6sGgU5UQe6JOkWQiq9p6h6FDsAEkEVEKW8vrTANmcu/5uLQ4EZWybbt6s+xplybExKgTEVHVYNCpSih7gk7Zl9Yxy4mIaKR4QrNeVmKBGY+mfG0w0E9EJcowTHywvSe7gxhgIiKqagw6VQkhBOK6llUDcUDCaTDoREQ0kt2ldeaI0joAME1mOhFRadqxO5jDyp2MOhERVTMGnaqEInLMcmKZBxFRCjtL62QyATkiuG+YJpuIE1FJMk2JD3bk0MtJMOhERFTNGHSqEklDR0zLbhU6rlpHRDSWnSvXmdFwytfZZaMSEU2eto5+xOK5ZsAz8EREVK0YdKoSO0M9WTUQV6QB1bCvZwkRUaWwK+gkdS2lgbgpJfs5EVFJklJicy5ZTnsIZjsREVUtBp2qgJQSW4JdWR3jyjIrioioGiQ1PY8n/anMSCjla90wbDkvEZHdOrrDGIgkcj/B6KATq4iJiKoGg05VoDsaRjgZzbzjMMlV64iI0ggN5PGhawSp6zATe+dlwzSZ5UREJeuDHVmuWJcBY05ERNWDQacqsLF7d1al9E5Dh+CHHyKiMcI2ldaN7uWkmcxyIqLSFI7E0defzcNLKxh2IiKqFgw6VTjdNLC5ryOrnzRL64iI0gvnU16yhzR0mPHI8NeaYUBypVAiKlE72oK2n5MzHhFR9WDQqcJtD3YjqeuWM50UacJhsLSOiCidvHqa7GEO9GPoI5dhmtCZ5UREJcowTOxsD9p+XgbaiYiqB4NOFW5jz24Ae/o3Wgg8McuJiCg9KSUGovkFnaSuDfdyknIwy4mIqFS1d4Wg6fbPUww6ERFVDwadKlg0mcDOUO/eDUqmN3gJl86gExFROomknveHr8Esp0FJQ4NkkQkRlbDtu4P2nGhUkIkzHxFR9WDQqYJt6m1PfVfPkOnk1DU2ECciGsdANL+gvEwmYCZjAAYznEw+6SeiEhaJJtAbjGTe0QI56v6SmU5ERNWDQacKtqm3PeVrkeGn7WZpHRHRuGLx/OZIMzKY5cQ+TkRUDjp7Buw5UZoAE4PuRETVg0GnCtUbHUBfdNTTqQl+2qqpQzX1wg6KiKiMRWO5L7IgE3GYWgKmlNAMzrVEVPq6em0KOpmjs5zA0mIioirCoFOF2tzbMXbjBD2d2ECciGhi+WQ6GZF+QAJJQ+dHLSIqeYZhojcYteVco0vrTLZyICKqKgw6VSApJTaPKq0Dxi+vE5Bw6bk/wSciqgbReG7zpJmIQepJJE2dfUyIqCz0BqMwTJuCQ6PKiTkPEhFVFwadKlD7QBCRZJplvcf5aQ9mOfEGgIhoIolEbmVx5kA/DNO07wMcEVGB2VZaB0COKik2GHQiIqoqFRF0mjt3LoQQaf+74oorij28SZe2tA4Yp7xOwq2lCVAREVGKpJZ90MmMRyB1DZrBxuFEVD66+uwLOsEYnenEADwRUTVxFHsAdqmrq8PVV189ZvuyZcsmfzBFZJgmtvZ1pn0tXXmdU9cg+OZPRDQhwzChG9nPlWYkDM002DSXiMqGYZqIROzr9Tky08k0ORsSEVWbigk61dfXY926dcUeRtHtDvchoY/zNF4dvYFZTkREVmh69plKZiIGU09CN5nlRETlIxbXbA2UpwSd+KCTiKjqVER5He21ZZwsJwAQo8rrVMOAyg9DREQZJbUcgk6REHT2cSKiMhON2bi4jAQwYrEag0EnIqKqUzGZTolEAj/96U+xa9cuNDQ04KijjsLSpUuLPaxJZZgmtga7xt9hVKaTh1lORESWZFtaJ5NxSD1Zkc3Do3oSbZEgpvrq4He6kTB07BjoQ4vXP+4xUkrsiPRBFQpm1NRnfU0Z6Ye54eXBOvGpc6GoKtAyG0KIvfv0dwGR0PDKWDIZh/Hm8xAzF0HEwkDrHEBKoHMbTLcPYtdGoGUWlOn7jhlrKSm18VDli8VtLK3Tk8NZU1ICZpX8e+5NRNCXiGK2vxFORYUhTWwP98LvdKPFW2v5PF2xAYS1OOb4G6EqqbkCUkokEunv5c3e3cCuTcCc/Qfnxp3vAy0zgIEgIAHRMgvKzIXDWWhSSsTj8bTnkqYBdO4APD6I+taU18Y7plg4XxKVpooJOrW3t+OSSy5J2Xbqqafif/7nf9Dc3DzucYlEImXCDoVChRpiwbWF+5Acr7QOGMxrEwAkoJgGHIaNT7KIiCqYaWZ3I2tGwjBMsyJ7Of2rewd6ExHsjASxavpCvNXbhrZoEJtD499StEX78XrPTgCAR3WiyVOT1TXN1/4EvPM3QBFA/RTIaftCqE6gaTqAPUG+d14a/FQ7VMqjJYB/Pgm5+XWgdTZEIgboGmTXDmDn+4PNjDf+E/LMKyFc3uFrJZP2feC2QzKZhNfrzbwjkU2iMRuDTiMecFZLaZ1hmvhbxxYY0kRES+KgphnY1N+F9/s7ICBw4oxF8DpcGc8TNzT8vXMLJCSSpo7F9VNTXk8kElizZo0tY+7r67PtXMXE+ZKoNFVEed2aNWvw7LPPoqurC6FQCH/729/woQ99CI8//jjOPPPMCaPed955J+rq6ob/mzVr1iSO3F5bxlu1bg8hMLyCnVtnlhMRkVXZBJ2kloSpxSv2ib5bdUz4//GPEVCEgFMZ02DQwkV9gKIAQgWc7sEHKM4RH9oUFRj6EDci+wmKCrj3fABxugGXe8/5hra5AKVinr8R2SIat++hpNT2BrCqpbROCMC1Zz70DP/fCQBwKCrUdCv7pKEKZXi+nGh+JSIqdRUxg916660pXx9xxBH4/e9/j5UrV+KFF17AH/7wB5x++ulpj73xxhtx7bXXDn8dCoXKMvBkmCa29Xdn3lEBhG7CpTHLiYjIKjOLMjkzGh78f4UGnQ5pnoV9Es2o35MdtH/DNEzz1SHg8uCX4xzT7PFj5bQFUIVAjdOd9TWVg0+EOX0BIASU+lZASgjf3hIV4XACS1cCiRiE+tTgRk8NcOoaKA1TgXgEorYRUkqIhqmDr/XsAupaB48dweXKnIEwmUptPFT5culhN57hTCeZ3TxazhSh4Nip8xHRE2hw+QAAc2obEXB54FGdwwGpTJyKipXTFiBmaGhw+ybc97tLPXDnkErwlfcS6Ncl6hwCNy/Ofm4OaRLXvVU6D7I5XxKVpooIOqWjKAouvfRSvPDCC/jrX/86btDJ7XbD7c5+ki017QPBiUvr9hDqUC+nyvwwRERUCJb7RBgGzEQ0u2PKjCqUlPI4RQhL5XIBlyfnawqHE+qo3ktj9nF5gRFlckJ1QG2dM/jFnkCXEAIINEEAwLT05xvZJ6oUlNp4qPKpij3/5qSuD/YDwmCWU2XOiOm5VceY7KRMgaN0PA4nPKMC42mvpwAeNfuf21cOyH1eBoCEUVo/Vc6XRKWpIsrrxjPUyykajRZ5JIW3baIG4iOo0OHSS6tfBRFR6bN2IzuU5QSgIvs5EVHlU2z64C4Te++/K3FRBSIisqaig05///vfAQBz584t7kAKTEqJbUELpXUA6hKhwUarRERkmWLlyb+UMOORPX8u7HiIiApFUe35eGAmYgD29Pevkn5OREQ0VtkHnd555x0Eg8Ex21944QV84xvfgNvtxjnnnDP5A5tE3dEwosnM9dSqoaMx2jcJIyIiqj5mbGBwRTQw5kRE5cuOTCdp6JB7Mut1074eUUREVH7KvqfTI488gq9//es48cQTMXfuXLjdbrz11lt48sknoSgKfvCDH2D27NnFHmZBWS2ta+3vgkuytI6IKFsZM52kTCmtY9iJiMqVpczODOSeLCeApXVERNWu7INOxx9/PN599128+uqreO655xCPxzFlyhScf/75uOaaa7B8+fJiD7HgrASdFNPA1L5OJJC5GSEREaXK9OTfjEWGG+YSEZUzhw3ldWZ8sJ+Tbprsb0dEVOXKPui0cuVKrFy5stjDKJpwIoZgLHOj9CnBLjgMHabFZrhERLSXOtGHMClhRkOjNxERlaVaf34rmkktOVxaZzAYT0RU9cq+p1O129nfk3Ef1TAwta8DAOCAXughERFVHIdj/LdLMz42y4lP9omoXAX87ryOHyo1NkwTJiPwRERVj0GnMrfDQtBpSrATDmMw2KQICRWsrSciysa45SYSMCOhsZv5QYuIypTf5869mbhpDK5aJwGNWU5ERAQGncqabhpoC0+8Gp1q6Jga7EjZxmwnIqLsjBd0MmMDaXs5GQw6EVGZUlUFNb7csp3M2AAACc00GHwnIiIADDqVtd3hYMYVQab2dUI1Uj8QMehERJQdVVUgRvfEMw2Ykf6xO0vAlMwoJaLyFcilr5OUg4sqSPZyIiKivRh0KmOZ+jk50mQ5AYBDMOhERJQNIcSYvk5GOAiZJrjEkhIiKneB2uyDTkOreCYNnV3tiIhoGINOZWxXqHfC16f2tUNJkwnFTCciouw5Herwn2UyDjMxduVQPuEnokrQ0ujP7oA9q3jqhsFMTyIiSsGgU5mKJOPoj4/9wDPEpSUxNdiV9jUng05ERFkbznSSEsY4/fQ0k0/4iaj81da44a+x3tfJjA3AMHRmehIR0RgMOpWp3eHghK/P6G2DGKffEzOdiIiy53QOZjqZ0RCkMXYe1QwjY589IqJyMbU5YG1HKWFEQtDSzItEREQMOpWptglK67yJGJpD4/d7coBPoYiIsuVQFUgtCSMSHvOabpjQ+YSfiCrI1BZrQSczGkZST8LkanVERJQGg05lSEqJtnFKOwBgZvcuTFTfwUwnIqLsqZAwQj0YPcFqhgHN5LxKRJUl4HfD53FNvJNpIh7uY5YnERGNi0GnMhRKxBBJJtK+VhsNoz7dEt4jMOhERJQdKSXMzq1jyuqShs4MJyKqSEIITG2pnXCfWKgHOsvqiIhoAgw6laHd42U5SYlZ3bsyHq/AhMJWt0REliV3vA+Euoe/llIioWt8uk9EFW3G1PpxX0sm4tDTlBsTERGNxKBTGeocSJ/J1DAQRE08kvF4IQCVfZ2IiCwxwn2Iv/N3qBgMMOmGgYSusX8JEVW8gN+DxvqaMdt100Ak2AXJh5hERJQBg05lqCNN+ZwwTUtZTkPYTJyIKDOpa4j+61lI04ApB4NNmmnwYxYRVY25MxtTvjakiZ7+Xqh6skgjIiKicsKgU5mJaUmE4rEx26cEO+HW0vd5SkdlXyciooxib/8NWrgXfbEBBOMRZjcRUdWZ0lQLr9sJADClRNdACC4LmfVEREQAg05lJ11pnUPXMKO3PavzqIKZTkREE0ns2IjeLW9hdziIcCI+4aqgRESVSlEEZs9ohJRAdzQMJGNQuYACERFZxKBTmWkfCI7ZNrOnDUqWb/4sryMiGl9Xxw588Pc/oDc6MNwsXDDqRERVaua0OvTGw0hoSXjGWUGZiIgoHUexB0DZ6YqEUr72JqJoGbGiklVsJE5ENFZc1/Dq9g1w/OsZeJLsV0JEJKXEK7s3I+6IwzWgZf2gk4iIqhuDTmVESome2MDIDZjdtTOnkg9mOhER7WVKife72/DKzk2YsWsT/In4mH0kRBFGRkRUXK+2bcGGrjY4a3R4upjlRERE2WHQqYyEEjHoxt5gUX2kH4FoOKdzMdOJiGhQb2wAf9n6LrojYTSGe9EU6k27n8mKdCKqMm937MBru7cCAKYOdAIAgggUcURERFRuGHQqI90jAkzCNDG7e2fO51Jg2jEkIqKyZZgm3mjfhtfat8I0JVRDH8weHQeDTkRUTbb0deJvOzcCABTTwJRgFwwo6EeAHe6IiMgyBp3KSM+IoNPUYCfceTRyZNCJiKpZb3QAz219B73RvSXLM3va4NS1cY9h0ImIqkXnQD+e2/LOcAuHlv5uOAwdDgEEEEa/rC3uAImIqGww6FRGhoJOTj2J6b278zoXg05EVK229HXi+S3vQDf3zoM18Qha+7smPM5g0ImIqkAoEcNTm9/Yu3KnaWJaX8fw683oRj8YdCIiImsYdCoTUsrhoNOs7jYoZn5BIwadiKjaSCnxRvs2vLLrg9EvYG7H9oyLMmjSWbjBERGVgLiu4cmNryOu7c36bAr3pmSBekQSAYQRYrYTERFZwMe2ZSKua0joOmpiA2gK9eR9PgadiKja/H3nxrEBJwCt/V3wJaIZj9fAoBMRVS5TSjz7wdvoj4+YD6VMyXIa0oIerudJRESWMOhUJvrjUUBKzOnaYcv5GHQiomqyubcDb3ekaRIuJab2dWY83pQCOtQCjIyIqDT8q20Ldo1avbMmEYUnGR+zr0ckEBC5raBMRETVheV1ZSIYj6A53IuaeOan8VYISAhkrCYhIip7/fEoXtj2XtrXamMDcGuZF2WohiwnKSUSibF/FwlDxxs9u+BUVCxpnA5VUbAl3IW/tm/BNF8Ai+unYGu4Dz6HE/E9JThSSsTjez+oburvRGdsAIsbpqIrFkZPPIL9G6eh3uUdM4ZkMgmXywUh9uZRyL4OmG88ByRigDSAgSAQCQIzFkE57qOAlJCvPws50AczEQMAmJF+RF74LWAYwIZ/AEIA0+YD8w6CiPRDJmNAfxdEy2yI/VdAqIO3ROn+Dogq3bZgF17bvXXM9qZRQaiRWtCNEGqr8l5yvPkSAN4LtqMvEcUBjdNR63Dj3WA7+pNxHNg4HbVONzrjYWwMdkEzjOFzjZwvNwY78PjOdxFwenD2Pgcj4PKkvQ7nKiIqFww6lYlQJIRZ3btsO58QgJByT+iJiKhyvd2xA/qem/vRWvq7LZ0jWQVBp0QigTVr1thyrr6+PtvONbGdwC/+lPaVYMLAp7//yKit2wH8Oc3e99k9MKKy0R+PDq5UN4qQJprC4wed3CKJOoQQlIFCDq8kTdZ8+ZwtVyAiKi6W15UJZdu7cEywlDcREY0lpcSOcfrgqYaOxoGgpfPEkf5JMxFROTNME8988NZw1s1IgUgYDkOf8PhmdPPxJRERTYiZTmXAiPTD17ENE7/tExHRaDEtiYHE2H4kwOCKTEJa628XgzfzThWk5uKTIZzZ97CK/vZFyGgCwueG7yNHZXWs1AxEfvrU8NffXeqBO4dHY195L4F+XaLOIXDzYnfWx4c0ieveYtkKVYdXdm1GT3Qg7WvNE2Q5DXELDXXoR1DW2T20slEK8yURUSlj0KkMxN79B4wMT5qIiGgsl8OB8RrYNYb7LJ1DSiAmqyvTSThVCGf2twg15x1n2xjcCuBRs8+h+MoB+f2sEkY1dqiharQr1Iu3OsZZoEZKBKIhS+dpQQ/6UVeVvZ2A0pgviYhKGcvrSpzWtROJ9u2QBXgnF1V7e0BE1cKhqPCna8IqJXx7Gk5nosPBleuIqKLEdQ3Pbx3bx2mINxnPWFo3xCU01AlrASoiIqo+DDqVMGkaiL/7MgwzfQNcIiLKbKq/fsw2l56EanFujVZZaR0RVTYpJf667T1Ek8lx96mNhbM6ZzN62NuJiIjSYtCphCW3b4AxEIRusecIERGNtX/rzDHbrGY5AUAENXYOh4ioqN7v2Y2tfV0T7hOIZhd0coskAiK7Y4iIqDow6FSiTC2B+MZ/ARhcWYSIiHLTUhNAiz91SW9fImrpWCmBAcmgExFVhlA8ir/t2DjxTlKiNpa+ufhEuJIdERGlw6BTiUpsegNSG0x71gsQdJISMPnjJ6IqcfDUuSlfW810SsIFjWtuEFEFMKWJZ7e+A92YuLTYpWuW+zmN5GG2ExERpcGoQwkyo2Ektu1t7liITCcTCtuIE1HVmFXXhOaa2uGvPVrC0nEDLK0jogrxatsWdA1kbvjtTVovPx6tGT05H0tERJWJQacSFNvwT2BEoMlEYYJORETVQgiBJVNmD34hJdza+A10RxqQ/gKOiohocmwPduP13dss7ZtNz7vRPCKBGuR+PBERVR5GHkqMHuyCtntLyjbTtD8nyeDy30RUZWbXN8OhqlBNA4qFlet0qSIC3ySMjIiocMKJGJ7b+k7mHffIJ9MJAJpEb17HExFRZWHQqYRIKRF/75Ux280CrF5n8EdPRFXGoaiYW99iOcspDD/LkImorOmmgT9tfgtJ3XqPJm8intc1/RiAC1pe5yAiosrByEMJ0Tt3QO9tH7PdkPZ/7DGZ6UREVcjv8sCtW+vnFJKBzDsREZUoKSX+um0DeqJZNPeWEh4tv6CTEECj6MvrHEREVDkYdCoRUkrE33817XZZgKATM52IqBrppmEp00mXCkvriKis/bPtA2zqGfswcyJOQ4NiwwI29eiHWoCepEREVH4YeSgResc2GOGxT4WMApTWAezpRETVKa5rqIlHMu4XQoCldURUtt7t3Gm5cfhIVsuPM1GFiXrRb8u5iIiovDHoVAKklIhven1Sr5mEa1KvR0RUbMFYBJt721ETj2bct5+ldURUprYFu/DijvdzOtatWSs/tqIeDDoRERGDTiVB79wBI5R+pQ+zAKV1AJCUDDoRUXV5eddmKLqe8UNVUjoRhXeSRkVEZJ/d4T4888HbyDVV02Nj0MmNBDywJ3OKiIjKF4NORSalRHzjvyZ8vRCScBbkvEREpUZKiX/u+gDbg93wWyit6weznIio/OwO9+HJja/DyKMnk52ZTkIAdSyxIyKqegw6FdlEWU5AYYJOUgIag05EVAUM08SzW97Ba7u3AkDG0jopWVpHROWnPRzEk5vegJ5nE3C7ejoNqUMIwtYzEhFRuXEUewDVbLCX02sT71OA6ybhYoNcIqp40WQCf/7gLXQM7H3SXhcNTXhMHG4k2POOiMpIeziIJza9Dt0w8j6XnZlOAOAUOmpkFANcDZSIqGox6FRERm87jP6eCfcpRE8nltYRUSXTTQNvd+zAa+3bUj6EOfUk/LGBCY/tR12hh0dEZJuOAfsCToppwqlrNowqVZ3ox4Bk0ImIqFox6FREiW3vZdxHFiAniSvXEVElklJie383/r5jI8KJ+JjXG8PBDMcDIVlboNEREdnLzgwnAHDZnOU0xI/MvfSIiKhyMehUJGY8Aq1jW1GunYC7KNclIioEKSXaB4J4bfdWtIX6xt2vcWD81wAgAh80vi0SURnYHe4b7OFkU8AJsL+f0xCHMOCRCcR5/0lEVJV4d10kye3vDz5Wz6QA5XVRyaXAiaj8SSmxo78Hr7dvRefAxL2aXFrm0roQV60jojIwtEpdvk3DR/Pohcl0AgC/iCAuGXQiIqpGDDoVgTQNJHe8b21fm6+tS5VNcomorJnSxJa+LrzevhV9UWtlGw0ZspykBMIsrSOiEtceDhYk4ATY30R8pBpE0I3Ggp2fiIhKF4NORaB1bIeZmHjZ7kKJgVlORFSekoaO97vb8HbnTgyk6dk0keZQ74SvR+GDDiWf4RERFVR/PIqnN79RkIATULjyOgDwIQYFEiZEwa5BRESliUGnIkhaaCA+xO7quiiDTkRUZsKJGN7p3IkN3W3Qcuhf4k1E4csQ6A/Bn+vwiIgKLq4l8eSm15HQ9YJdo5CZToqQ8MoYIuAqdkRE1YZBp0lmRsPQe9uzOMLeqBP7ORFRueiOhPFG+zZsDXbmFYDPlOXE0joiKmW6aeCpzW8iFI8V7iJSFjToBAA+EUNEMuhERFRtGHSaZFp7divW2RlyMqVgeR0Rlbz2cBCvt2/Fzv6Jg0WWSImm8MTnScDNVeuIqGS9uG0DOgf6C3oN1TSgFKhsb4gbhQ1qERFRaeJd9iTTOrILOtkpBo/tjcmJiOwgpcTOUC9eb9+KjrB9H67qoiE4dW3CfVjuQUSlqisSwsaebDLkc1PIfk7D10Dhr0FERKWHQadJZMaj0Ps6i3b9CGqKdm0iovH0xQbw4vb30R4O2n7uhoHM52TQiYhKkZQSL+/aPCnXcumFDwi5kISA/SszExFRaWPQaRIVM8sJYM8SIiotmmHgX7u34K2OHZB2r5qwRyAWnvB1KYEoe4wQUQlqC/dhd6hvUq41GUEnRUg4pYYknAW/FhERlQ4GnSZRtv2c7JSQTsThKtr1iYhG2hXqxV+2votIsnA9Ppx6Eu4M54/DAwNKwcZARJSrV9s+mLRrTUZ5HQC4RQJJyaATEVE1YdBpkpjJeJar1g2x5+l/GMxyIqLSsLO/B09tfgOmWdgii0B04iwnYLDXHRFRKQrGo5N2LaehT8p1XOzrRERUdRh0miR6dxtyWfPbro9k1VpaV6iSHSLKze5wH57e/GbBA05A5tI6AEgyA3QY58uxTGPiJvSVdl0qHVJKaJMUCAIAxyT9m1NR2BXyJgvnSyIi6xh0miRGMMcG4ja8p2nSgWiVPs1PJvlEjahUSCnxp81vwSjwstxD/LFIxn0S0j0JIykPnC/Hev3ZHxR7CFSldNPM5VllziYr00mFMSnXKTTOl0RE1rGRxSTJddU6aUPUKQx/3ucgIspXQteQ0Ccvg8Np4cl9gplORFSCdHNygzOOSQo6KRWS6URERNYx02kSSF2DEeot2vWrtbQOAFwufqAkKhXhZHzyLiYl1Awf2gypQOPb4DDOl4NcIx7Hff/734fHM3GmsJQSm7YHsW13CAtm18OpKrjzq7cgMhBCIFCHm275KhJJHdNb/VDV1Gd9hmGirTMCt1tFa2P6VRTdbmbjVSOv04VpgYZJW71u8jKdKiPoxPmSiMg63m1PAqO/O6d+TkD+1XWadCCC6l0OXAhR7CEQ0R5NPj+aa2rRHcncaylfijQzTqA63wJTcL4cNPLvwePxZAw6AcCSRV4sWTRt+Gu3y4EIAIdDxewZjRMeu2Cf6n2PpoktnTpnUoJOQpoQk1T2XCmZTpwviYisY3ndJMi1tA5AzsGqIUHU2daMnIgoH4pQcNzc/aAohb9Zz5TlBAAG3wKJqIRNr21AS02g4NdRJingBABKhfR0IiIi63jHPQmMPIJO+SzwJCUQlHW5n4CIyGYNXj+Onr244IEn1cKHKBNqQcdARJQPIQQOnja34NexEqS3DzOEiIiqDYNOk0AP9eR8rMwjDTkKL5Jw5nw8EVEhLGyehjMWHYaAx1u4i1jIEmWmExGVutn1zThsxryCXsNKkN4uJuddIqKqw5m/wKSWhEzEcj4+n0ynIOpzP5iIqIBaagI4a7/DMa+xtSDn1xyZA+788ENE5eDgaXMLmvGkTGKmk8lMJyKiqsM77gIzIv15HS9z7OlkSAWhKl61johKn0t1YNU+B+Dk+QehzmNvM2VDUYEMjV4FO94RUZk4dPo+WDJ1dkHOrcrJy3SS/OhBRFR1uHRPgZnRUH7H53gjEEKAT5OIqOQJITC7vhkzAo3Y0N2GV9s+QEK3YeluIaCpDjh1bdxdKmUVJSKqfEIIHD5jX5hS4u2OHfaeO5+0+izx3pSIqPrwcUOBmZH8gk653gb0sYE4EZURVVGwf+tMnHfgCiyZOhuqkv/bk65O/FyFQSciKidCCBwxcz6OnrPIljlyiDKJmU4sayYiqj6c+Qssn6CTRG6ZTjHpQQyenK9LRFQsbocTy2fOx8cOXIH9WmZAZCiRm4iWMejE8joiKi9CCCxumYEPL7ZvMYbJDDoZXDWUiKjqMOhUYEYeQSfTNK0swDRGHxuIE1GZ87ncOGrOIpx74JGY3zQ1p1W2M2c6TeYy4URE9mny1eKs/Q7HPg35L8YwmUEnrqpMRFR9GHQqMDMazvlYI4ebAEMq6JeBnK9JRFRKAm4vVu6zP87ZfzlmBBqzOjZT0MmF8fs9ERGVOpfqwPHzDsCK2QuhKLlnhSqT2NNJkww6ERFVGwadCkgaBqSWyPl4PYclbIOoY5NGIqo4DV4/Vi9YipPnH2S5pMRQJi7jUISEEzY0LSciKhIhBPZvnYmzFh+OJp8/p3MocvKyPjVmOhERVR0GnQpIJmJ5HW+Y2WU6SQn0yYa8rklEVKqGVro7Z/8jsHzmfDjUiYNKmTKdAMCNpF3DIyIqmkafHx9evAyHTN8n6154apb3m7mSkkEnIqJqxKBTAZmJaF7HZ1teF4EPCb6ZE1GFUxUFS6bOxpmLl6HO4xt3PytBJ5dg0ImIKoOqKDh0+j44c/EyNPhqLB+nTFLQSYeDyzcQEVUhBp0KKN9MJ93ILt25F8xyIqLq0eCtwVn7LRu3ka5p4Wm/G7mXQBMRlaLmmlqctfhwLJ02B1aSntRJKq9LwjUp1yEiotLCoFMB5ZvppGXR00mTDgzI3Gr5iYjKlXNPI90lU2ePec1hZO7X5EN+8zQRUSlSFQXLZuyLD2fICAUmL9MpDvekXIeIiEoLg04FlE+mkylNaFlkOvWhninLRFSVhBA4bPq8MU10HRbmUDeScGDylgsnIppMLTUBfGS/w7F/68xx93FaCNDbIQ7PpFyHiIhKC4NOBWTmEXTKJuAkJRCUdTlfi4io3KmKguPm7p+ybLiVTCchAJ9gthMRVS6HqmLF7IVYvWApfK6x2UbqZAWdJDOdiIiqEYNOBSST8ZyPTWZxAzAAPzRkbphLRFTJGn1+1Hv2Ns+1+vSeJXZEVA1m1jXhnP2XY17jlJTtjizaOeTKlAIJltcREVUlBp0KaLKCTn2oz/k6RESVRBHZZToBgB+RQg2HiKikuB1OHD/vABw7dz+oyuDHgMkor0vAxTYQRERVikGnAsqnvM5q0Gmwgbj1ZXGJiCqVlBL6UENcKeFNWpuD3SIJN5IFHBkRUWlZ2DwNpy86FH6HA2ISGomznxMRUfVi0KmApJbbUty6aVju6cQG4kREg3b09yAYG8xaculJOHXN8rEBES7UsIiISlJLTQBn7HMgPE5nwa8Vg7fg1yAiotLEoFOBSNOA1HJ7ch63+EGJDcSJiAaZ0sTLuzYNf10bG8jq+AAYdCKi6uM2dbTUBBBwFzYoFJUMOhERVSsGnQpEJnPLcgKAmMVgVQQ1bCBORFVPSomXd25GMLa3Ibg/nl2fJjcScMF6ZhQRUSWQiRgEBOq9NWj0+QtyDV0qSMBVkHMTEVHpY9CpQHJtIi6lRMJiplM/anO6BhFRJXmjfRve6tiRss2fZaaTEEC96LdzWEREJc9MjAjWuzxo9NrfJ5SldURE1Y1BpwIZ+SaejYSuwZSZuzRJCYQlg05EVN3e6dyJV3Z9kLJNNXT4LDYRH6ke/RCZdyMiqhhy1KI3frcXDTYHnqIMOhERVTUGnQpk9Ju4VTHdemmdwR8fEVWxN9u346Xt74/ZXhsbQC4rLDiFDr/ILkOKiKicmWky82ttDjzFpM+2cxERUflh1KJAzHj2mU5SSkQt9nNiaR0RVSspJf656wP8Y+emtK8HYrk3BW9AMOdjiYjKzXgPSWvdXtS6PXmf35QCMeR/HiIiKl8MOhWIzKG0I65rMEwz87lZWkdEVezlXZvx2u6t474eiOYedPIjAif0nI8nIionE2Xm13tq4FTVvM4fgwcmC5eJiKoag04FYsazDzoNWAxUDbC0joiq1Jvt2/Fm+/ZxX3foGrw5ljcDgw3Fm0RvzscTEZWTdOV1Q4QQaPT6kU/MKAqW1hERVTtGLgpEZtlIXDcNxCyuWhdiaR0RVaGNPbvHLakbEshy1bp06tEPFZmzTomIyl2mHqRuhxMBV+6NwKPs50REVPUYdCqQbHs6RZIJS41vpQQGpD/HURERladoMoG/btuQcT9fIpL3tVRholH05X0eIqJSJk0D0shcTlzn8UFVsv/IICVXriMiIgadCkKaJsy49Q8+EkBkgvTmkTQ4oCO/+noionLzWvtWSz3vvMmELddrRB+UXJbAIyIqE9Jihr0QAj6nK+vzs58TEREBgKPYA6hEMh4dfLxjUVxLQrfwYQoAYnxiRHkyDWs3mZVyXSp/CV3Dhu42S/t6LAbwM3EIA/XoR6+st+V8VFn6QnGEBhJQhEBzgw+6YaKtKwyfx4XmBi8MY/A93TAZuKTSZTXoBAA1Lg/CiezmV/Zzqi68vySi8TDoVABmlst192dRisegE+Xr9Wd/UOwhEGXFlBKmhQ/vQprwaPZkOgFAM3oQRB2f1FOKRFLHex/0oqMnAo9bxdSmGkTiOnZ1hOHzOlFf64a2J+ik6yZ6++NorOOS8VSC9KTlXV2qA05VhWYYlo9h0Km68P6SiMbD8roCMLNYrjumJZG0UE8/JCoZdCKi6qIIa0Eft5bMKss0E6fQ0SCCtp2PKoOiCKiqgKoIqIoCp1OFy6kOblcEvG5HSpjS6eCtFpUmqWWXIeJ1WC+xk5L3rERENIiZTgVgZrF6UiiLpb1NKRAHn5ZS7v77v/8bbrc77WumKRGJafB5HFBVBbphIhbX4fc5kdRM3HjDFxAMBtHQ0ICv3nEXJACv24FoXIeqCEgJSCnh9WSeVsYbA1E6LtWB5ppadEcmDui7bernNFIzetCHemY70TCnQ8XSRa1I7DP4wKjG54RpAvvMCMDtUuH3ueB0DPZedDkV1NZk3wuHaDJI0/pDTwBQsmgmnoAbBp9tVzzXiB/xRPeYkZgGp0OByzk4N+qGgUhUhxBAjdeJ66//Avr6+tDQ0IB77rkn5dhE0oBhSvh4f0lUthh0KgCrmU4JXUMii3r6ODxsa0t5cbvd8HjGD1z6fKlPJf01g//3evfebAohUF+3dwXFCU5HZAshBI6evQj/994rE67yqUprvfGy4RAGmtCLLtlk+7mpfLldKtyuvYt6qArQ3LC3lEhRBoOUwmKWHlFRZJkZajXrFOCqddVi5Bw30T1muu1D95gjzyOEGLMv7zOJyh8fQRSA1aBTf8J6LydgcBUQIqJq1FwTwIGtsybcRxQg6AQATeiFA4U5NxFR0VhcxGZIdkEn9nMiIqJBDDrZTEoJI9Kfcb+EriGeZS29BmeuwyIiKnvLZ87H0mlzxn29UDklqjDRLLoLdHYiouKQWWY6iSxmWfZzIiKiIQw62Uwm45Ba5tVAglmsWDeEtfFEVM2EEFg2Y18cM2cx0j1wL1SmEwA0og9uWF/piYio5GU5Z1pd+EaTDmjs4EFERHswimEzcyBzllNMS2bVy2mIATXzTkREFW5Ry3ScuuAQ1LhSG4YKG1euG00IYIroLNj5iYgmXZZzZsKwdu/KRW+IiGgkBp1sZgwEJ3xdQiIYj+R2bsmgExERAEwPNOCjBxyB/VpmTNo1/YjAj+yzVImIyp0EkNStZTqxBykREY3EoJPNzAz9nCLJBDTDyOnczHQiItrLqTpw1JxFOG3RIQh4vChcV6dBQ9lOXI+MiKqNZugwLWZGxdjPiYiIRmDQyWYTZTpJKdGfQy+n4XMz6ERENMa02gacvf9yzGuaUvAl6j0igUbRV9BrEBGVmpDF+1cpmelERESpGHSy2USZTuFEDEaWy9MOkZJBJyKi8TgUFQuap2NabT28zsKu9NmCbjiQW8YqEVG5SRo6ohYWyQGAJJxc+IaIiFLwXcFGUtdgxtL3azJME6FELPdzQ6BwLXKJiCqAEHAoKlpq6tBcUwtVKcxbnCpMNhUnogpg7c7SapYTACTgzrwTERFVFQadbDRRaV0oEbVcC5+OIiRUFG45cCKi8re3tM7ndGNabT387sKUedQhBB9yf5BARFR0Fu5Lk7pmOcsJYNCJiIjGYtDJRuY4QSfNMDCQjOd9fgesrRpCRFSNpJZI+VoRChq9frT66+CwOetJCGCa6GBTcSIqWzJDywdTmuiOhrM6ZxKufIZEREQViEEnGxkD6fs5BeMRKw+TMmLQiYhofOY4JcwehxPTahvgc9r7YWiwqXivreckIpo05sS96XqjA9Cz7EWakAw6ERFRKgadbGQOjF3RKK5riGWRljwRh2DQiYhoPHKCvnlCCDTXBFDn8dl6zVZ0w8kHAkRUjiYIKIUTsazK6oDBaj2W1xER0WgMOtkoXaZTcJzG4rngBxsiovGZycw9luo8PjTX1ELYVBenCImposOekxERTSI5TqZTQtcQjGd//6rDAZNFx0RENAqDTjaRhg5zVN17VEsgadgXKGJ5HRHR+GTCWu88n9ONOneNbdetxQBqhX0PGIiIJoNMk8mUNHR0RUI5tYVIwmnDqIiIqNIw6GQTc1RGkwTQn8USs1Yw6ERElJ6UEmbMesPbgMcLj9OeD0hCAFPRDsXi8uNERKVAjsoO1QwdXZH+nFdb1uGwY1hERFRhGHSyyegPO7FkApoxcYPGbLlhT28oIqJKYw4E0z61n0ij12/b9V1CR4votu18RESFZo5YWVk3DXRGQjDM3IPnDDoREVE6DDrZZGRpnYREf8LeLCcAcCMBB+wNZBERVQK9N/u+Sg5FharY9zbYhF54kLDtfEREhST3BJ1000DnQD+MLFeqG41BJyIiSodBJ5uYsYHhP0eTSduznIDBEo4a9g0hIhrDCHbmdJxLVW0bgxDANDYVJ6IyIRPx4YCTnmfACWDQiYiI0mPQySZmdDDoJCERKkCW0xA/GHQiIhotl0wnAHmVkqTjEzE0iKCt5yQisps0dCQiIXTYFHACAF0y6ERERGMx6GSToZ5OhcpyGsKgExFRKjMeSck2tcowTVtXGB3Sii6WQhNRSevqbkNnJJh3Sd1IBuzLHCUiosrBoJNNhlavG0haW7I7Vw5hsGcIEdEIuWY5xbTCzKUOYWKK6CrIuYmI8tUeDuJv7/3T9kxPCWHr+YiIqDIwD9YuugbNMJDQtYJfyi8iiEt3wa9DRFQOcgk6mdJEfyKWeccc1aEffahDFN6CXaOQpDb5mVrFuCZRtdkd7sOTm95Aa9z+VhD2hrCIiKhSMOhkA2makKZR8CynIX4MoBuNk3ItIqJSZ/RlH3QKxqK2lpWMJgQwDR34QM4tyw9ikZ8+VewhEJHNdof78OTG16GbJrwFuGdlphMREaXD8jo7GDqklIhqkxN08iEGJ+zvQ0JEVG7MZBxGuC+rY2JaclIeEnhEAo0iu7ERERXCyIATAPgKsOgNg05ERJQOM51sIA0NMS1pe238eIQAGtGHDtkyKdcjIipVRl9nVvvrpoGePQs/TIYWdKMfAehl0GDX7XZj/fr1eZ3juuuuQ19fHxoaGnDPPfdkfXwikcC///u/5zUGIko1OuDk0DV4Jik7n4iIiEEnG0hdx8AkZTkNaUAQXWiGyadKRFTFsslyklKiOxqGOUkPCABAFSamoAu75NRJu2auhBDweDx5n8OucxFR/vpiETy16Y3hgBMA+OOFWQmZmU5ERJQOy+tsoGuJSWkgPpIqTDSI4KRek4io5EjrAaRQIoqkPvmlyXXohw/MKiCiyRXXNTy16XVoRmqT/trYQEGup6BwffKIiKh8Mehkg75IKJvPPbZpRB+fKRERWZDUtYKuVjcRIYCpIvtm50REuTJME3/e/CbCibEB70IFnVRwBUoiIhqLQScbdCUTRbmuS2ioFYW5cSAiKg/WIv69sUhR1/P2ijjqRX/xBkBEVeWlHe9jdzg4ZrtqGKgpQBNxAFCZ6URERGkw6GSDjiI9PQeARvQW7dpEREVnIZCU0DUkjeKv+NmKbijFjHwRUVXY0d+DDV1taV8LRENZlSVnQxXMdCIiorEYdMqTlBLt8chg/UQR+BCDl71CiKhaWZh6wyWySpNT6GgSfFBARIVjShP/2Llx3NfrI4XLuGR5HRERpcPV6/IUjEeRMAxoqgPOSW4mDgzGulrRhW1y1qRfu9xIbfJvhkZfM2ECk13jk8gh290wTGzaHoRhSiyYUw+nQ0157fUNnTBNoLc/hqZ6D/ab1wy3S8XWXf0IR5LYZ2Yd/D6Xjd8FUXqO5hnAxtcm3Ec3SueDUDN60Id66FAz71wiTCnxRs9ORPQkDm6ahRqnC1vDPdg+0IeFdS2od/vwr+4dcCkOyBEZFFJKvNG7C+/07YZbdSDg9GJhfStm+xuhmwb+1bMThjRxaNMsuNSxtyPFmC/3Xnd8UkokEhOX1Q/9PUgpEY3G8MHOIHTDxL6zBufTcCSJbbtDqPe7se+c5uFV/4jytaGrDcHYOOVzUjLoVADVen+597rWxZM6Nm8PwuVUse+seijK2Lmvuy+GHe0hhCNJxJMGprf4YUqJpnoPZrTW2jRyIppMDDrlKbLnCbqmOosSdAIAv4gigAGEpL8o1y8XkZ8+Vewh4LOvl0bGRSb9Awn09A+Wjfb2xzGlqWb4Nd2Q6O2PoycYg2FKaLqBlkYfWhp8aOsa7DHW0R2FfzaDTlR4joZWqPUtMIJdxR6KJYqQaEUX2uTUYg/FslAyhh2RPgDAzkgfFtVPwYZgB5Kmjo39XZhRU4/u+ODvvjniQ09ET2BDsAO7IkEkTQPTfHWQkJjtb0R3fADt0cEPv7ujIcypbRxz3VKdLxOJBNasWWNp376+Plx22acm3OdHP/4xanw+O4ZGVS6ha/hn25ZxX6+JR+AoYKmxE8UvYy4G3l9a190bQ//AYNB+anMNamvG3ivu7Aijuy+G3d0RuF0q+sMJTGupQTSmMehEVKYYdMqTuedppu5wAMXpJw4AmIJOhOFntxCyRW2NC36fC6YpUV/rTnlNVQVqvE54XCp6Qwk0BDxoDHjgdChorvciHEmiucFbpJFTNXLP3R/R154b93VFESilB/D16EdAhPM6h/TU2zMYC2pdHjR7/IjqSUz1BQAAc2ubsG2gF7P9jWj21GDbgBtOxQFlRL2jz+HCbH8DQlocLkVFvduHObVNAIBGdw3qXD6Y0kSrt7ofmKgKOx2QPT7o7UBiggegDQXMcgIAVzFvhKksNNZ50NkXhdupwudN/zG0tcmHeEIffrA5takGQgg01fPekqhcMeiUJ0MO5pUmVWdRx+ESGprQi2459mlxNXO73Vi/fn1e57juuuvQ19eHhoYG3HPPPVkfL6VEMpmEy+XKuYQi3zEMcbvdmXcC4HSoOGhhS9rXHKqC5UumpX1t4Vz++6PJ55w6B4rbB3OcFZn8Lg/iWnEyUdMRIv9VnkwxeY8YVKFgxZR5KdsW1U/Bovopw18fP30RAOChEXOcIhQcOWUejhx1LAC4VAeOmzZ/zPZSmLNHjyfdtkxjvO222xAKhRAIBLB27dqsr0GUi52hCXrGSYnGcF9Br+9GsqDnLyWlMFeV0v0lYG0u83mdOHS/KRPuM73Fj+kt1f0wgqjSMOiUp6FMpwGvH82hnqKOpRk9CKKurHqFFJoQAh6PJ+9z5Hsurze/pzN2jIGoUglFhWvOIsTf/1fa171ONxxKBLrJ5bxLXanM2ZnOn+m8d955p+3XJZqIYZpomyCo5I9H4NYKm4mkwoAKE0YVrFNUKnMV7y+JqBxU/rtCgZl7Mp1CvuLXGKvCxBTRWexhEBFNOtfsxVA8NWlfEwCafLXFWmSUiKjgOgb6J1w0oSlc+JUzhaiubCciIrKGQac8DWU6JRwuJJ3Fb5xchxC8KI9mgkREdlFcHtQcfjLEOPOw2+FEk68WYOCJiCpQT2z8PnFCmgUvrRviEuzrREREqRh0ypND2VPKJgRC3uJnOwkBTBUd/FxFRFVHrW1AzWEnQijpS4x9TjcaPTUMPBFRxdEmyHIKRMMFXbVuJA+biRMR0SgMOuWpZURZXSmU2AGAT8TRKCbniRYRUSlxNE6F7+Djxn3d7/aixReAwlo7Iqog2gRBpdb+7kkbhw+xSbsWERGVBwad8lTr9sLtGFy5LlwCmU5DWtHFunoiqkrOqXPhPeDIcV/3Ol1o9dfBwaXqiahCaGb6TCennkR9pH/SxuFBPO/VOYmIqLLwjjtPQgi01AQAAEmnC3FXaaz8oAiJ6WI3q0iIqCq55+wH974Hjfu6S3Vgir8eHqdzEkdFRFQYck+P0dFa+nuAcV4rBCEAL7OdiIhoBAadbNC6J+gEAB31LUUcSSqfiKNZ9BR7GEREReFZeCg8i5aN+7qqKGitqUO9p4Yr2xFRWRvKuk8hJVpCk1daN6RGRCf9mkREVLoYdLJBy4igU3egCYaavoltMTSjh00diagqCSHg2XfJYHNx1THufgGPF601LLcjovLlSRN0qouE4NImv9WCDww6ERHRXrzDtkFLTQCKMviY3FRUdNaVTraTIiRmsMyOiKqYc8ps+FecDsVbM+4+bocTU/318LLcjojKULpMpyn9nUUYCeBFHAomr6SPiIhKG4NONnA7nJjfOHX46476FsgSqtXwiARaxOSnVxMRlQo10Aj/UR+GY4ISaEVR0FJThzqPD4zUE1E5GZ3p5EnGURcJFWUsQgC1YqAo1yYiotLDoJNNDpwye/jPmsOFntrGIo5mrGb0wIt4sYdBRFQ0ituLmiNOhWv6vAn3q/P40FoTgFJCDw+IiCbidbhSvp4SLE6W05AAwkW9PhERlQ4GnWzS4K3BrLqm4a/bG1qLOJqxhABmijYuY0tEVU2oDniXHgfPosMm3M/jcKHVXweVfZ6IqAx4nXuDTqqhozlU3IVk/BhgiR0REQFg0MlWS6buzXaKuX3oH9FgvBS4hIZpoqPYwyAiKqrBBuMHoWbZSRBO17j7uVQHpvjZYJyISt/IoFNzqAeKWdyHjIqQ8LPEjoiIwKCTrab669FcUzv89baWWZAl9mGlToRQL/qLPQwioqJzts6C/6gzoPrrx93Hoaho9dex1I6ISppDUeFUVUBKtPaXRh/PABh0IiIiBp1sJYTAQVPnDH+dcHmws2l6EUeU3jR0wI3JX0KXiKjUqDV18B91Bpwj+vKN5lBUNPr8kzgqIqLsOVUV/vgAPMnS6OHJEjsiIgIYdLLd3PoWzKjb20S8vb4VEY+viCMaSxESM0UbF2ciIgIgHE74Dj0BngWHjLuPz+mG3+WexFEREWXHqTjQ2l/cXk4jqcLkKnZERMSgk92EEDhuzn5wORxDG7BlypzBTt4lxCMSmCKKu7IJEVGpEELAs+Bg1Bx2IsSopceH+N3eSR4VEZF1bkg0DvQVexgpGhAs9hCIiKjIGHQqAJ/LjaNnLxr+Oub2oa1hahFHlF4j+vgEiohoBOeU2fCvOB2Ke2yGqkt1DPZMISIqQQ39PRBFbiA+mg9RuKEVexhERFREDDoVyLzGKZjX2Dr8dVvjVMRdniKOaCwhgOnYDSf0Yg+FiKhkqLUNg4GnNCuQulVHEUZERJRZbYk0EB9JCKBeBIs9DCIiKiIGnQpoxexF8LkGl7CVilKSZXYOYWIG+zsREaVQfH74V5wOtb45ZTtb4hJRKZKmAW80XOxhpFWPft5nEhFVMQadCsjjcOKYOfsNfz3g9WNby8wijii9GhFDiyi9p2NERMWkuDzwLz8VjpYZw9sYdCKiUmT090CRpVVaN8QhDAREaQbEiIio8Bh0KrBZdU04eNrc4a8761vRWd9SvAGNoxk9qEG02MMgIiopwuFEzWEnwjVjXwBAUmdvEiIqPUZfJ0SJZdOP1IDSanBORESTh0GnSXDo9H2woHna8NfbW2Yi5Kst4ojGEgKYIXbDAaPYQyEiKilCUeE96FgY0+dBL7EmvUREAKD3dUAp4aCTDzF4ES/2MIiIqAgYdJoEQggcPXsRZtY1AgCkULBp2jwkXO4ijyyVU+iYIdqKPQwiopIjhMC2llnoCTQVeyhERGMYA0EoonRv64UAmkVPsYdBRERFULrvThVGVRScMG8JmmsGM5wM1YH3p8+HUWLLb/tFFM2it9jDICIqKYZp4r3uNmyZMhv9aVa1IyIqJqE6oCqlfVtfiwG4wBJlIqJqU9rvThXGqao4Zf5SBDxeAEDc5cGmqfNQakt6tKILPsSKPQwiopKxpa8TMS05nKka8dQUe0hERMOE0w21hDOdgMFspyY+2CQiqjql/e5UgbxOF1bPXwqP0wkACNUEsK1lVpFHlWqwv1MbVLB3CRERALzTtXP4z6ai4v0Z8xF3eYo4IiKivYTTDbfDgRJu6wQAqEc/+4cSEVWZigk6vfzyyzjttNPQ0NCAmpoaLF++HA888ECxh5VWwOPD6vlL4XI4AAyuaLezeUaGoyaXS+iYJjqKPQwioqLriYbRNRBK2aarDmyYMR+aw1mkURER7SWcLihCgbvE5yRFSDQKrmRHRFRNKiLo9Oyzz+KYY47BX/7yF5x77rn493//d3R3d+PjH/847rjjjmIPL63mmgBOX3govE4XAGB341Tsappe5FGlqhMh1IlQ5h2JiCrYhu70CywknW68P30+ZImXtBBR5VO8gyW/XoeryCPJrBF9zKYnIqoiZX+nrOs6LrvsMggh8Pzzz+NHP/oR7r77brz++us44IADsHbtWmzcuLHYw0yr0efH6YsORc2eVezamqahrWlakUeVaho64IJe7GEQERXN7nBw3NeiHh+2tpZWiTQRVR/XrEUQijr4MLPES+xUYbK3ExFRFSn7oNOf//xnbN68GRdddBEOOeSQ4e21tbW45ZZboOs67rvvviKOcGJ1Hh/OWHTYcHPxXY3TsLtxapFHtZcqTMwQbaV+/0JEVBAJXUMwFplwn+66ZnQHmiZpREREYyluL1xz9oNDUVFbBv3mmO1ERFQ9HMUeQL6effZZAMApp5wy5rWhbc8999xkDilrfrcHpy86FI9vfA190Qh27imzm9bbXuSRDfKJGJrRgy5ZeR+qpJRIJBIZ9xn6fzweh2YY6ElE0Oj2waXu/RXSFQFFAE7VAaeiZr62lgQgB88bjUI4HBB70uKlNIFkHMLtG/zaHLwxMw0Dka5dEL56yIFewOEEDAOQJoTqhLvGD2EaUGrqcvp7ME0JTTfhdo0d/+i/h/G43W6IUu9kSmRRVEta2m9r62z4ElH4EpW78qduGBiIR+FRnYgbOpxCQB011w3NE6ZpIhKNQkLCkBLuEXNlwtDh9XhS5k+rzGQcsWAPhNMD4fJARvoh/PUQI5aKH5ovpWkiNhCCcLggEzFIKSETMQhfDRSnh3MVVRz3vAOR3PYu6j01iGlJ6GbpBnVUYaIJveiUzcUeSkGku7/UjMEG6k5VhZQSxtBcJSWCkQGoACKGDo/qgCklvKoDSdPIeb40dA3xjp2AwwVoMcA0IALNUPasvmoO9ME0B8ckTRPxeBzSMCCj/ZCeGqB7NxAfADxewOGBp3kqFIcDwum2/HcQT+hIJBJwu9Th+dYwTJhSwulQU/YdPob3mEQVR8ih3/Iydd555+GXv/wlXnnlFRx22GFjXm9paYEQAp2dnWmPTyQSKW8KoVAIs2bNQn9/PwKBQMHGnU5c1/DkxtfRFQkBUmJW9y5M7SuNZt5SAlvkHMRQuKdn9QEHPnTmaQU7fzrxeBxr1qyx5VwfuvmzCEsNC+pasXLagglvEGRsAPLN5yDjMcTjUXz6/sdtGcOPTlkAT00txJEfhjJrkeXj7Px7WL9+PTye0n/KSmRFXNfwi9f+YmlfdzKOA3a8B9Uo/MpMZqABB59xWcGvM3w9aeLprW/j/i/dacv5LvrK9ThpzgHwqNabHstIP2LPPILLHnjGljFwrqJKFHv3ZSS2vIWYlhy8nyxhhlSwUe4Lo8CFF6oi8bGLziroNUaz877qwtsH50tvFk3ipZSIPnovPv2QfQ/ef3TyfHgXL4NYugrCl/kz0gc7g3hrQzse+smXbRtDpc/boVAIdXV1RfkcSlRIZZ/p1N/fDwCoq0uf2REIBLBz5860rwHAnXfeidtuu60gY8uWx+HEhxYejBe3v4+YloQZaESsIwBPidw0zDA17I57C3Z+f23hzj0ZEoaOuNQQ0zUkDH3ip1LxCKDrQDI++GfbBhEFvD4g2AFkEXQiovTcqgMz6hoBi49nwi436rp2FXZQAJy19QW/xki6aSKiW8v6skIzdMR1LaugE2JhyISN8yVRBXLPOxBGuA+1kAiH+hCzmK1ZDAqA1qSGkF7YIIKqlnc3Ed3UEdOTWQWdIE1goMfegSSikFoSIjYAWAg6RaIaNL3wD2GIqPSVfabTKaecgqeeegobN27E/Pnzx7y+7777YufOneOWUJVSphNNPivldbeuW4tgfz8a6uqxdu1avNmzC+8E23FAwzQc1DQDABDVNWyPBREzNMzw12O2vzHjddG2aTCNGRKJ9h1AwxSIGfMhFBUy3AP07AamzIXw+nHbl25AfzCIOo8TN595LDDvIGDr24MpaKYGaBrgr4e7th6KAMRBKy2nP4/8ewgNJNEXimNKUw087tSymdtuuw2hUAiBQABr164d91xMfSaqTLsG+tA5EMRsfxN2DPTC73RjZk1Dyj633XYb+vv74fb78LkbvgBDmhjQEpgfaIFDUWGYJjaFuhDw1WCfQHZlNVKaMDe/jvi2d4H6qYC/DqJzOzDvYCh7FuGQ8Qi+fNuX0R+JoM7vx63/8WnIhmnArvchw31AqBti6jyIBYfA4/FyriKighh9f2lKiQ/C3VAA7FPbjAE9gS/f9mXEByJoamjABVddAc0w0JkYQI3iRI3Lg1n+BnTGQvB7fJhX15L1GPRt7yLx2jOA4gDCvYOBqMVHQNl3KSQU4K2/4PaH/oD+aBx1dXW49at3Qu7eDOz+ANLhAja+CkT6Bls5+Bvgnn8I1KlzgRkLLM2dkZiG7W39iCXimDklgEDNYAuJ9u4IdN3EtNYaqHtKo3mPOYiZTlSpyj7olG953Wj8ZSciIiIiIqLJxM+hVKnKO98UwIIFCwAAGzduHPNaX18furu7h/chIiIiIiIiIqLJUfZBp5UrVwIAnnzyyTGvDW0b2oeIiIiIiIiIiCZH2QedTjzxRMybNw8PPPAAXnvtteHt4XAYt99+OxwOBy655JKijY+IiIiIiIiIqBqV/ep1DocDP/7xj7F69Woce+yxuPDCCxEIBPDrX/8aW7ZswVe+8hUsXLiw2MMkIiIiIiIiIqoqZR90AoDjjz8eL7zwAtauXYtHHnkEyWQSBxxwAG6//XZ8/OMfL/bwiIiIiIiIiIiqTtmvXmc3rhpAREREREREk4mfQ6lSlX1PJyIiIiIiIiIiKj0MOhERERERERERke0YdCIiIiIiIiIiItsx6ERERERERERERLZj0ImIiIiIiIiIiGzHoBMREREREREREdmOQSciIiIiIiIiIrIdg05ERERERERERGQ7Bp2IiIiIiIiIiMh2DDoREREREREREZHtGHQiIiIiIiIiIiLbMehERERERERERES2Y9CJiIiIiIiIiIhsx6ATERERERERERHZjkEnIiIiIiIiIiKyHYNORERERERERERkOwadiIiIiIiIiIjIdgw6ERERERERERGR7Rh0IiIiIiIiIiIi2zHoREREREREREREtmPQiYiIiIiIiIiIbMegExERERERERER2Y5BJyIiIiIiIiIish2DTkREREREREREZDsGnYiIiIiIiIiIyHYMOhERERERERERke0YdCIiIiIiIiIiItsx6ERERERERERERLZj0ImIiIiIiIiIiGznKPYASo2UEgAQCoWKPBIiIiIiIiKqBkOfP4c+jxJVCgadRgmHwwCAWbNmFXkkREREREREVE3C4TDq6uqKPQwi2wjJUGoK0zTR1taG2tpaCCGKPRwiAINPPmbNmoUdO3YgEAgUezhERCWL8yURkTWcL0uLlBLhcBjTp0+HorALDlUOZjqNoigKZs6cWexhEKUVCAR4U0BEZAHnSyIiazhflg5mOFElYgiViIiIiIiIiIhsx6ATERERERERERHZjkEnojLgdruxdu1auN3uYg+FiKikcb4kIrKG8yURTQY2EiciIiIiIiIiItsx04mIiIiIiIiIiGzHoBMREREREREREdmOQSciIiIiIiIiIrIdg05EBbJq1SoIIYo9DLLJ/fffDyEE7r///mIPhYiIiIiIqCww6FTmtm7dCiEEhBCYMWMGDMNIu9+bb745vN/ixYvT7vPAAw9g+fLlqKmpQUNDA0477TS88sorhRw+UV4uueQSCCGwdevWvM819Lt0ySWX5H0uIrvZMddHo1Hcc889uOiii7B48WIoijLh709PTw/uvfdenHnmmZg3bx7cbjeam5vxoQ99CE888URW43/22Wdx0UUXYb/99kN9fT18Ph8WLVqENWvWYMOGDRN+v0P/+Xw+TJ8+HSeeeCJuvfVWbN68OasxTIahhw0TzUnp9nn22WeHv8/PfvazaY8bCnx/7Wtfy2uMc+fOxdy5c/M6B1EpK/f58oUXXsB1112Hww47DE1NTfB4PFi8eDG++MUvIhgMTvj9cr4cxPmSqLQw6FQhHA4H2traxn1j+8lPfgKHwzHu8XfccQc+/vGPo6OjA1dccQU+9rGP4a9//SuOPvpoPPvsswUaNVH5OPvss/Huu+/i7LPPLvZQqIrlM9d3dnbi85//PB588EHE43E0NDRMeK3//d//xeWXX45XX30VxxxzDK699lp86EMfwnPPPYdTTz0Vd999t+VxP/3003jhhRdw4IEH4pJLLsFnP/tZLFy4ED/72c+wdOlSPPPMM2mP23fffbF27VqsXbsWV111FT70oQ+hs7MTt99+OxYtWoSbbroJlbYI77333luSHxCJyk25zpfnnnsuvv3tb6O2thaf/OQnceWVV8Ln8+HrX/86li1bhs7OzrTHcb4kopIlqaxt2bJFApDHHXecrKurkx/96EfH7JNIJGRzc7M888wzJQC5aNGilNfff/996XA45MKFC2UwGBze/tZbb0mfzyf33XdfqWlawb+XSrNy5UrJX7HCuvjiiyUAuWXLlrzPNfS7dPHFF+d9LiK72THXh8Nh+eSTT8qenh4ppZSrV6+e8PfnT3/6k/z9738vDcNI2f7ee+/Juro66XQ65a5duyyNPxaLpd3+9NNPSwBy2bJlab/f1atXpz3u+eefl3PnzpUA5M0332xpDJNhaN6faE5Kt88zzzwjAch9991XApDnn3/+mOPuu+8+CUDeeeedeY1xzpw5cs6cOXmdg6iUlft8+bWvfU22tbWlbDNNU/77v/+7BCCvvPLKtN8v58u9OF8SlRZmOlUIr9eL888/H48++ii6u7tTXvvd736H7u5uXHrppWmPve+++6DrOr70pS+hrq5uePsBBxyAT37yk9i8eTP+/Oc/WxqHEAKrVq3Crl27cNFFF6G5uRm1tbU4/fTT8cEHHwAANmzYgLPPPhuNjY2ora3Feeedl/apzfr163HWWWdh7ty58Hg8aGxsxOrVq9M+ER9KtV23bh1effVVrF69GrW1tairq8PZZ589JnU3UynV0Pcx0j//+U989rOfxYEHHoi6ujp4vV4sWbIEX/va16BpmqW/n4n86le/wsqVK9Ha2gqPx4NZs2bh1FNPxW9/+9sx+77xxhu44IILMG3aNLhcLsyZMwf/8R//gZ6enrTn/uEPf4gDDjhg+LzXX3894vF42u9zKJU5kUjgpptuwuzZs+H1enHYYYfh6aefBgCEw2F87nOfw4wZM+DxeLBixYpxSzE7OztxzTXXYP78+cPp5h/96Efx1ltvjdl3KI05Eong2muvxYwZM+B2u3HQQQfhl7/85Zh9f/rTnwIA9tlnn+FU65Hfz29+8xtceOGFmD9/Pnw+H+rq6nDsscfiV7/6Vcq57r//fuyzzz4AgJ/+9KcpKepDmX4T9XR68cUXcfrpp6OxsXE4DX7dunWIRqNj9h0aY1dXF9asWYPW1lZ4vV4ceeSRzCqkjPKZ6/1+P04++WQ0NjZautYJJ5yA008/HYqSequwaNEinH/++dA0DS+++KKlc3k8nrTbTzzxRDQ0NGDTpk2WzjPk2GOPxRNPPAG3242vf/3r2LFjR8Zjsn2fACb/9/Wkk07CypUr8cgjj+Cf//yn5eOszLND73vbtm3Dtm3bUua5devW2f69EBVbuc6XX/ziFzFt2rSUbUII3HLLLQCA5557ztJ5hnC+TMX5kmjyMehUQdasWYNkMolf/OIXKdvXr1+P1tZWnHHGGWmPG3ojOOWUU8a8tnr1agDZvcH19fXhmGOOwZYtW3DxxRdj1apV+MMf/oCTTz4Zb7/9NlasWIFwOIw1a9Zg2bJl+OUvf4mPf/zjY87z//7f/0NHRwdOOukkXHPNNTjjjDPw0ksv4aSTTsL//d//pb32K6+8gmOPPRYOhwOXX345li1bht/+9rc46aSTEI/HLX8P6fzoRz/Cb37zGyxZsgSXX345PvWpT0FKiRtvvBEXXHBBXuf+7//+b5x77rnYuHEjzj77bFx77bU46aSTsGPHjjFBp9/97ndYvnw5Hn30UaxatQpXX301lixZgu9+97tYsWIF+vr6Uva/9dZbccUVV6Cvrw+f+cxncN555+F///d/8bGPfWzCMZ1//vl4+OGHceaZZ+Kiiy7C22+/jTPOOAOvvvoqTjjhBDzzzDM499xzcc455+Af//gHVq9ejVAolHKOzZs347DDDsO3v/1tzJ8/H//xH/+B0047DY8//jiOPPJI/P3vfx9zXU3TcMopp+CPf/wjzjnnHPzbv/0bNm/ejI997GN48sknh/e7+uqrsXTpUgDAVVddNZxSPjKQeOONN+Ltt9/GMcccg6uuugrnnXceNmzYgHPPPRff+c53hvc7+OCDcdVVVwEAli5dOnyutWvXZqzlHwoWPvvss/jIRz6Cq6++Gn6/H7fddhtOOukkJBKJMccEg0EcffTReOONN/Dxj38c55xzDl555RWsXr06bTCOaKRc53o7OZ1OAJiwbNuKl156CX19fTjwwAOzPnbhwoU4//zzkUwm0wbnx5Pt+8Rk/77eddddkFLii1/8oqX9rc6z9fX1WLt2Lerq6lBXV5cyz41++EBUKSppvsznPJwvB3G+JCqSImdaUZ5Gp9QecMAB8qCDDhp+fefOnVJVVXnddddJKWXaFOLm5mbp9/vTnv+tt96SAOR5551naTwAJAB5zTXXpGy/4oorJABZX18vv/Wtbw1vN01TnnbaaRKAfPXVV1OO+eCDD8acv62tTU6fPl0uWLAgZftQqi0A+dBDD6W89olPfEICkA8++ODwtkylVADkypUrU7Zt3bpV6rqess00TblmzRoJQL7wwgspr2VTXnfooYdKl8slOzs7x7zW3d2d8udAICBnzpwpt23blrLfAw88IAHIz372s8PbNmzYIFVVlbNnz045TzgclgcccEDa73No3EcffbQcGBgY3v7QQw8N/wzPO++8lJLLu+66SwKQ3/jGN1LOddRRR0mHwyGffPLJlO0bNmyQtbW1csmSJSnb58yZIwHIs846SyYSieHtQyU4o1PHM5XXbd68ecy2cDgslyxZIuvq6mQkEhnenunfxFCq9n333Te8LRQKyfr6eul2u+Xrr78+vN00TXnRRRdJAPL2229POc/Qv9Mrr7wyJQ3/xz/+sQQgL7/88rTXp+pmx1w/WqZykfGEQiE5ZcoU6fF4UuYVK5555hm5du1aecMNN8iPfvSj0u12y+bmZvnyyy+n7JepXGTIT37yEwlAfuITn7B07WzeJ6TM/vc133KRofOdc845EoB84oknhvcZr1wkl3mW5SJUySplvhxt6F7rC1/4Qsp2zpecL4lKHTOdKsyll16KN954YzjN9P7774dhGFizZs24x/T396eU1Y0UCASG97HK7/fj9ttvT9l20UUXAQCamprwuc99bni7EGI4S+j1119POWao3GmkadOm4aMf/Sg2btyIbdu2jXn9uOOOw/nnn5+ybeh7f/nlly1/D+nMmTMHqqqmbBNC4P/9v/8HAMOlZ7lyOp3DT7FGampqGv7zz372M4RCIdx5552YPXt2yn4XXnghDj30UDz00EPD2x588EEYhoHrrrsu5Tx+vx8333zzhOP56le/ipqamuGvzz33XDidTgSDQdx9990pT9ouvPBCAKk/w3/961948cUXcfHFF+Pkk09OOffChQvx6U9/Gm+++WbaJ1/f/OY34XK5hr8+8cQTMWfOnKx/hvPmzRuzze/345JLLkF/f3/e/yZ++9vfIhgMYs2aNTjooIOGtw+tmOJwONKW49XU1OCuu+5KScO/+OKL4XA48h4TVYdc5nq7XHHFFejo6MBNN92UMq9Y8eyzz+K2227D1772NfzqV7/CrFmz8Pjjj2PZsmU5jWX69OkAMKZ0ZiLZvk8U4/f1jjvugMPhwA033DBh49985lmialGu8+VIr732Gm677Ta0trbi+uuvz+kcnC85XxIVS355nlRyPvGJT+DGG2/E+vXrcdhhh+H+++/HEUccgf3333/SxrBgwYKUYAWA4dr0gw46CEKItK/t2rUrZfsHH3yAO++8E3/+85+xa9euMWVKbW1tmDNnTsq2Qw89dMx4Zs6cCQBpl5nNRjKZxHe/+1089NBDeO+99zAwMJDy5tbW1pbzuT/2sY/hhhtuwIEHHogLLrgAq1atwjHHHIP6+vqU/f72t78N/z9dD5R4PI7u7m50d3ejubl5OAh01FFHjdk33baRDjnkkJSvVVVFa2srIpHImIBXup/h0Fjb29vT1r+/9957w/8fWVpTX1+fNuA4c+ZMvPTSSxOOebTOzk587Wtfwx//+Eds27YNsVgs5fV8fmbA4A0MgLSp1rNmzcK+++6LDRs2IBwOo7a2dvi1BQsWwO/3p+zvcDgwZcqUvP+dUnUo1lx/00034YEHHsCpp56Km266Kevj161bh3Xr1iESieCdd97Bl7/8ZRx99NFYv3798MOJbEz0AWM82b5PFOP3ddGiRVizZg3uvfdePPjgg+P+3eQ6zxJVk3KdL4ds2bIFZ5xxBgzDwEMPPYTm5uaczsP5kvMlUbEw6FRhWltbcdppp+HBBx/EmWeeiU2bNuHzn//8hMfU1dWNm8k01KNnvEyodIayo0YayoqZ6LWRzbg3bdqE4kNpYgAAExhJREFU5cuXIxQK4fjjj8eHP/xhBAIBKIqCZ599Fs8991zaXjnpxjl0fsMwLH8P6Zx77rl49NFHh+viW1tbhzN/vv3tb6cdj1XXX389mpqa8IMf/ADf+MY3cM8998DhcOC0007Dt771reEgTG9vLwDge9/73oTni0QiaG5uHv75tbS0jNlnypQpE55jvJ/VRH/HI3+GQ2N97LHH8Nhjj0041pHG+7fmcDhgmuaEYx6pt7cXhx9+OLZv346jjz4aJ510Eurr66GqKl577TX83//9X14/M2Dv78d4f5dTp07Fhg0bEAqFUoJOE32P+f47peqQy1yfr9tuuw133nknTjjhBPz6178ek/mZjZqaGhx++OH4zW9+g2XLluEzn/kMTj755LRz1UR2794NIP0cN55s3yey+X0dero/0Vw19NrohsOjrVu3Dj//+c9xyy234Nxzz027T67zLFE1Kef5ctu2bTj++OPR1dWFX/3qVzj++ONzHhPnS86XRMXC8roKtGbNGvT19eFTn/oUvF7vcOnTeBYsWICBgQG0t7ePeW3jxo3D+0ymb37zm+jr68NPf/pTPPXUU/jWt76FL3/5y1i3bh0WL16c9/mH3rx0XR/zWroA3Msvv4xHH30Uq1evxjvvvIMf/ehH+OpXv4p169bl3UQcGCzHuuyyy/DKK6+gq6sLv/nNb3DOOefgd7/7HU4//fThN+qhQNCbb74JKeW4/w1lgA3t39XVNeaaHR0deY97IkPX/s53vjPhWC+++OKCXP8nP/kJtm/fjq985St44YUX8J3vfAe333471q1bhyOPPNKWawx9j+P9XQ5tTxfAI8pXtnN9Pm677TasW7cOq1atwqOPPgqv12vLeR0OB44//nhEIpFxV8CcyNBCGIcffrgt48nX0Aeu8VYSBfaWtmR6mDNt2jRcffXV+OCDD/DDH/4w7T7FnmeJykU5zpdbt27FqlWr0NbWhkceeSTvpuecLzlfEhULg04V6LTTTsPUqVOxa9cufPSjH834gXflypUAkLIy2JAnnngiZZ/JsnnzZgDAmWeembLdNE389a9/zfv8Q2Vro0v6gL0lU+nGc/rpp495WvWXv/wl7/GM1NTUhI985CN4+OGHccIJJ+Ddd98dLqU74ogjAMBymdnQ6m7plum1unRvrrIday6GfhbpnraN928ISP8zm+hc4xkqQUy3FPCuXbuwefNmzJs3LyXLicgu2c71uRoqiVu5ciUee+wx+Hw+W88/VOaa7YpM77//Ph555BG43W6cffbZto4pV0uWLAEw/rzX09ODjRs3Yvbs2ZYyiL/4xS+iqakJt99+O8Lh8JjXc5lnVVVlRiVVnXKbL4cCTrt27cLDDz+Ms846K69xcb7kfElUTAw6VSCHw4Hf/e53+M1vfoOvfvWrGfe/9NJL4XA48NWvfjUly+ftt9/Gz372M+y777444YQTCjnkMYYydV544YWU7XfddZctDf4CgQAWLlyIF154IaU3Ujgcxo033mh5PG+//TbuvPPOvMfzxBNPjMm60jRtOBV46CnZpZdeitraWnzpS1/C22+/PeY80Wh0uGYdAC644AIoioJvfOMbKU+SIpGIpX8b+Vi+fDmOOOIIPPjgg3j44YfHvG6aJp577rm8rtHY2AgA2Llz55jXxvuZPfDAA/jDH/4wZv+GhgYIIdKeazxnnXUW6urqcN9996X8PKSUuPHGG6FpGi655BLL5yPKRrZzfS7Wrl2L2267Dccee2xeH6Cef/75tP1EnnzySfzmN79BXV1dxj5zI73wwgtYvXo1EokEbrzxRsyYMSOncdnt3/7t36AoCv7zP/9zzFximia+8IUvQNd1fPKTn7R0vkAggC996Uvo6urCt7/97TGv5zLPNjY2oru7O+1y50SVqpzmy5EBp4ceeijvIBHny0GcL4mKhz2dKtThhx9uOX124cKFWLduHW6++WYcdNBBOPfccxGJRPDggw9C0zT86Ec/yvoJdL6uuOIK3HfffTjnnHNw/vnno6mpCX/729/w6quv4vTTT5+wFtuqa6+9FldccQVWrFiB8847D6Zp4o9//GPaVZSWL1+O5cuX45FHHsHu3btx5JFHYvv27cPlb7/85S/zGsv5558Pn8+HY445BnPmzIGmaXjqqafwzjvv4Pzzzx9u3N3S0oIHH3wQ5513HpYuXYpTTz0VixcvRjwex7Zt2/Dcc8/hqKOOwuOPPw5gsLniDTfcgDvuuANLlizBeeedB4fDgV//+tdYsmQJ3nrrrYx18vl48MEHcfzxx+OCCy7At771LRx22GHweDzYvn07XnrpJXR1deX1Rn7CCSfg7rvvxuWXX47zzjsPNTU1mD17Ni666CJ84hOfwF133YX/+I//wDPPPIM5c+bgjTfewNNPP41zzjkHv/71r1PO5ff7cfjhh+P555/HpZdeigULFkBRFFx00UVjGqcPCQQC+NGPfoQLL7wQRxxxBM4//3y0tLTgT3/6E1555RUsX74cX/jCF3L+/ogyyWauB4DPf/7zw+UKb7755vC2ocavN9xww3AJ8/33348vf/nLcDgcWL58Of7zP/9zzPlWrVqVtpH+aGeeeSaam5tx+OGHY9asWYjFYnjjjTfw/PPPw+l04sc//vGYBSiAwf5+Qw1fk8kkOjs78fe//x1vvfUWVFXFzTffjFtvvdXy919oCxcuxN13343rrrsO+++/P8466yzMmTMHoVAITz31FN577z2sWLEiq6bCV155Jb797W8PZ2+Olu08e8IJJ+CVV17Bhz/8YRx77LFwuVw45phjcMwxx+T9/ROVsnKZL1etWoVt27bhyCOPxBtvvIE33nhjzD7pGmFzvuR8SVSyJJW1LVu2SABy9erVlvYHIBctWpT2tZ///Ody2bJl0uv1yrq6OnnqqafKf/zjH1mNB4BcuXLluOO8+OKLx7z2zDPPSABy7dq1Y7YfffTRsra2VtbX18vTTjtN/vOf/5Rr166VAOQzzzyT8RyZrv2d73xHzp8/XzqdTjl79mx56623ymQymfb76OzslGvWrJHTp0+XHo9HLlmyRH7ve9+TH3zwQdrzr1y5Ulr9Ffv+978vzzzzTDlnzhzp8XhkU1OTPOKII+QPf/hDqWnamP3fe+89+alPfUrOmTNHulwu2dDQIJcsWSI/97nPpf2Zff/735f77befdLlccubMmfLzn/+83LFjhwQgzzrrLMvjnjNnjpwzZ07a18b72ff29sqbb75ZHnjggdLr9Uq/3y8XLFggL7roIvnrX//a8vnHG9fXv/51uWDBAul0OseM4bXXXpOnnHKKbGhokLW1tXLlypXy6aeflvfdd58EIO+7776Uc23YsEGedtppsr6+XgohUv6djXeMlFI+//zz8kMf+pCsr6+XLpdLLly4UN5yyy1yYGDA8t9Tpu+fqptdc/2cOXMkgHH/GzmvDs21E/2Xbs5N51vf+pY89dRT5cyZM6Xb7ZYej0cuWLBAXnbZZfKtt94a9/sd+Z/X65XTpk2Txx9/vLzlllvkpk2bLF17SC7vE7n+vv75z3+WH/nIR+TUqVOlw+GQgUBALl++XN5zzz0yHo+PO7bLL7887fl+9rOfDf893HnnnWNez2aeDYfD8tOf/rScNm2aVBQlq58jUTko9/ky03lG3wtxvkzF+ZKo9Agpc1g/k4jK3tNPP42TTz4Z119/Pe66665iD4eIiIiIiIgqDHs6EVW4rq6uMU0Qg8HgcO+qj3zkI0UYFREREREREVU69nQiqnC/+MUvcPfdd+OEE07A9OnTsXv3bjz++OPo7OzEJZdcghUrVhR7iERERERERFSBGHQiqnBHHXUUDjvsMDz99NPo7e2FqqrYb7/9cMstt+DKK68s9vCIiIiIiIioQrGnExERERERERER2Y49nYiIiIiIiIiIyHYMOhERERERERERke0YdCIiIiIiIiIiItsx6ERERERERERERLZj0ImIiIhsNXfuXMydO7co1163bh2EEHj22WeLcn0iIiIi2otBJyIiojK3detWCCEghMCMGTNgGEba/d58883h/RYvXpzz9RjYISIiIiIrGHQiIiKqEA6HA21tbXjiiSfSvv6Tn/wEDodjkkdFRERERNWKQSciIqIKcdRRR6Gurg7r168f81oymcQvfvELnHbaaUUYGRERERFVIwadiIiIKoTX68X555+PRx99FN3d3Smv/e53v0N3dzcuvfTStMdKKbF+/XocffTRCAQC8Pl8WLZs2ZgA1qpVq3DbbbcBAI4//vjhcr10PZwikQiuvfZazJgxA263GwcddBB++ctfpr1+T08PrrnmGuyzzz5wu91obW3F+eefj3feeSft/jt27MCFF16IxsZG+P1+rFy5Es8//3ymvyIiIiIimkTMsSciIqoga9aswb333otf/OIXuOqqq4a3r1+/Hq2trTjjjDPGHCOlxL/927/hgQcewMKFC3HRRRfB5XLhqaeewqc+9Sm88847uPvuuwEAl1xyCQDgueeew8UXXzwcbKqvr085p6ZpOOWUU9Db24tzzjkH0WgUDz30ED72sY/h8ccfxymnnDK8b09PD4488khs2rQJq1atwgUXXICtW7fil7/8JR577DE89dRTWLFixfD+u3fvxooVK7Br1y6sXr0ahx56KN59912cfPLJOP744236myQiIiKifDHoREREVEGOOOIIHHDAAVi/fv1w0GnXrl148skncfXVV6ft6fTjH/8YDzzwAD71qU/hBz/4wfA+yWQS5557Lu655x5ceOGFOOyww3DJJZdg69ateO6553DJJZdg1apVacfR1taGww8/HM888wxcLhcA4KKLLsJJJ52Eb3zjGylBp+uvvx6bNm3CjTfeiDvuuGN4+yWXXIJTTz0VF198Md577z0oymCC9o033ohdu3bhK1/5Cr70pS8N73/vvffi8ssvz+8vkIiIiIhsw/I6IiKiCnPppZfijTfewD//+U8AwP333w/DMLBmzZq0+3/3u99FTU0Nvvvd76YEpVwuF7761a8CAB588MGsx/HNb35zOOAEACeeeCLmzJmDl19+eXhbMpnEgw8+iKamJtx8880px69evRqrV6/Gxo0b8eKLLw7v//DDD6O1tRXXXXddyv6XXXYZFi5cmPU4iYiIiKgwmOlERERUYT7xiU/gxhtvxPr163HYYYfh/vvvxxFHHIH9999/zL7RaBRvvvkmpk+fjq997WtjXtc0DQDw3nvvZTWG+vp67LPPPmO2z5w5Ey+99NLw1++99x5isRhWrVoFn883Zv9Vq1bhiSeewGuvvYZjjjkGGzZsQDwexwknnACPx5Oyr6IoOOqoo/D+++9nNdb/3879g6TWx3Ec/3iTsKAEIbOmhqB/SxESUUsgDQ41BIVrEdHi1BI1BiVY0R5YSxEEQURBFiGUKLXrUOSQg1JYQdKS3ikvPo89f7rn3h583i84yDm/D+d854/n/AAAAPBrUDoBAFBm7Ha73G63tre3NTQ0pOvra83MzJTMZjIZ5fN5JZPJwgbhpby8vPyrGaxWa8nrZrNZuVyucP78/CxJqq+vL5l3OBySpKenp6Jfu91eMv/RfQAAAPD78XkdAABlaHx8XJlMRhMTE6qqqpLH4ymZq62tlSR1d3crn89/eJydnf2SOd+fn0qlSq6/X3/PvZdZ6XT6L/MAAAD4epROAACUIbfbLYfDoWQyqZGRkUJp80c1NTVqa2tTLBbT4+PjP7p3RUWFJOnt7e2n52xtbZXFYtHl5aWy2eyf1kOhkCSps7NTktTS0iKLxaKrqyu9vr4WZXO5XGHvJwAAAHw9SicAAMqQ2WzW/v6+9vb2CpuBf8Tr9SqbzWpycrLkZ3S3t7dKJBKFc5vNJkm6u7v76TkrKyvl8Xh0f3+vxcXForWTkxMdHR2publZfX19hfzo6KjS6bSWl5eL8uvr6+znBAAA8B/Cnk4AAJQpp9Mpp9P5t7mpqSlFIhFtbm7q4uJCLpdLjY2NSqVSisfjikaj2traUlNTkyRpYGBAJpNJc3Nzisfjslqtslqtmp6e/tScPp9PoVBICwsLCofD6unpUSKR0O7urqqrqxUIBPTt24//yZaWlnR6eqr5+Xmdn5+rq6tLsVhMh4eHGhwc1PHx8afmAAAAgLF40wkAgP85k8mkjY0N7ezsqKOjQwcHB1pZWVEwGJTFYpHf75fL5Srk29vbFQgEZLPZtLq6qtnZWfl8vk8/v66uTtFoVF6vVzc3N/L7/QoGgxoeHlY0GlV/f39RvqGhQeFwWGNjY4pEIlpbW9PDw4OCwaB6e3s/PQcAAACMZcrn8/mvHgIAAAAAAADlhTedAAAAAAAAYDhKJwAAAAAAABiO0gkAAAAAAACGo3QCAAAAAACA4SidAAAAAAAAYDhKJwAAAAAAABiO0gkAAAAAAACGo3QCAAAAAACA4SidAAAAAAAAYDhKJwAAAAAAABiO0gkAAAAAAACGo3QCAAAAAACA4SidAAAAAAAAYLjvv2I1xcaMjG8AAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -730,10 +730,61 @@ " box_meanprops={'marker': '^', 'markerfacecolor': 'black', 'markeredgecolor': 'black',\n", " 'markersize': '6'},\n", " hue_order=['RIS','RRMS','PPMS'],\n", + " box_medianprops={\"zorder\": 11}\n", " \n", " )\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot\n", + "df1 = df_M0.copy()\n", + "df1['Method']='M0 (manual segmentation)'\n", + "df3 = df_M12_2d.copy()\n", + "df3['Method']='M12 (2D nnUNet)'\n", + "\n", + "df13 = pd.concat([df1, df3])\n", + "\n", + "#rename columns \n", + "df123 = df13.rename(columns={'number_of_lesions': 'Number of lesions per participant', 'phenotype': 'Phenotype', 'total_lesion_volume': 'Total lesion volume (mm3)', 'biggest_lesion_vol': 'Biggest lesion volume (mm3)', 'avg_lesion_length': 'Average lesion length (mm)'})\n", + "plt.rcParams.update({'font.size': 14})\n", + "f, ax = plt.subplots(figsize=(12, 11))\n", + "ax = pt.RainCloud(data=df123,\n", + " x='Method',\n", + " y='Number of lesions per participant',\n", + " hue='Phenotype',\n", + " #order=METHODS_TO_LABEL_SC.keys() if pred_type == 'sc' else METHODS_TO_LABEL_LESION.keys(),\n", + " dodge=True, # move boxplots next to each other\n", + " linewidth=0, # violionplot border line (0 - no line)\n", + " width_viol=.5, # violionplot width\n", + " width_box=.3, # boxplot width\n", + " rain_alpha=.5, # individual points transparency - https://github.com/pog87/PtitPrince/blob/23debd9b70fca94724a06e72e049721426235f50/ptitprince/PtitPrince.py#L707\n", + " rain_s=2, # individual points size\n", + " alpha=.7, # violin plot transparency\n", + " box_showmeans=True, # show mean value inside the boxplots\n", + " box_meanprops={'marker': '^', 'markerfacecolor': 'black', 'markeredgecolor': 'black',\n", + " 'markersize': '6'},\n", + " hue_order=['RIS','RRMS','PPMS'],\n", + " box_medianprops={\"zorder\": 11} \n", + " )\n", + "plt.show()" + ] } ], "metadata": { From 032e4123f3b2df95c4416b1a5a0a2c7243958984 Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Tue, 31 Oct 2023 16:32:49 -0400 Subject: [PATCH 21/34] added statistical test --- dataset_analysis/dataframe_analysis.ipynb | 84 +++++++++++++++++++++-- 1 file changed, 79 insertions(+), 5 deletions(-) diff --git a/dataset_analysis/dataframe_analysis.ipynb b/dataset_analysis/dataframe_analysis.ipynb index 1a2cb57..18b39af 100644 --- a/dataset_analysis/dataframe_analysis.ipynb +++ b/dataset_analysis/dataframe_analysis.ipynb @@ -235,13 +235,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_21794/3800180276.py:2: SettingWithCopyWarning: \n", + "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_23213/3800180276.py:2: 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", " df_M0['timepoint'] = 'M0'\n", - "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_21794/3800180276.py:3: SettingWithCopyWarning: \n", + "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_23213/3800180276.py:3: 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", @@ -645,7 +645,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_21794/1423961972.py:8: SettingWithCopyWarning: \n", + "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_23213/1423961972.py:8: 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", @@ -690,7 +690,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -743,7 +743,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -785,6 +785,80 @@ " )\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Statistics=45.913, p=0.0000\n", + "Distribution is not nornmal : we have to use the Wilcoxon signed-rank test \n", + "\n", + "Wilcoxon Statistic: 5117.0\n", + "P-value: 9.773776971792964e-08\n", + "\n", + "\n", + "Phenotype: RIS\n", + "Wilcoxon Statistic: 204.5\n", + "P-value: 0.02575209682849685\n", + "\n", + "\n", + "Phenotype: RRMS\n", + "Wilcoxon Statistic: 1777.5\n", + "P-value: 1.2024572288004824e-05\n", + "\n", + "\n", + "Phenotype: PPMS\n", + "Wilcoxon Statistic: 239.0\n", + "P-value: 0.03365938920870582\n", + "\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/anaconda3/lib/python3.11/site-packages/scipy/stats/_morestats.py:4088: UserWarning: Exact p-value calculation does not work if there are zeros. Switching to normal approximation.\n", + " warnings.warn(\"Exact p-value calculation does not work if there are \"\n" + ] + } + ], + "source": [ + "# compute wilcoxon test for the number of lesions\n", + "from scipy.stats import wilcoxon\n", + "from scipy.stats import normaltest\n", + "\n", + "method_M0 = df123[df123['Method'] == 'M0 (manual segmentation)']['Number of lesions per participant'].dropna()\n", + "method_M12 = df123[df123['Method'] == 'M12 (2D nnUNet)']['Number of lesions per participant'].dropna()\n", + "\n", + "#we check if the distribution is normal or not\n", + "stat, p = normaltest(method_M0)\n", + "print('Statistics=%.3f, p=%.4f' % (stat, p))\n", + "print('Distribution is not nornmal : we have to use the Wilcoxon signed-rank test \\n')\n", + "\n", + "# Perform the Wilcoxon signed-rank test\n", + "wilcoxon_stat, p_value = wilcoxon(method_M0, method_M12)\n", + "\n", + "print(\"Wilcoxon Statistic:\", wilcoxon_stat)\n", + "print(\"P-value:\", p_value)\n", + "print(\"\\n\")\n", + "\n", + "# iterate accross phenotypes\n", + "for phenotype in ['RIS','RRMS','PPMS']:\n", + " print('Phenotype: ', phenotype)\n", + " method_M0_phenotype = df123[(df123['Method'] == 'M0 (manual segmentation)') & (df123['Phenotype'] == phenotype)]['Number of lesions per participant'].dropna()\n", + " method_M12_phenotype = df123[(df123['Method'] == 'M12 (2D nnUNet)') & (df123['Phenotype'] == phenotype)]['Number of lesions per participant'].dropna()\n", + " # Perform the Wilcoxon signed-rank test\n", + " wilcoxon_stat, p_value = wilcoxon(method_M0_phenotype, method_M12_phenotype)\n", + " print(\"Wilcoxon Statistic:\", wilcoxon_stat)\n", + " print(\"P-value:\", p_value)\n", + " print('\\n')" + ] } ], "metadata": { From ee2500a1af188ab13808aaa5467408195706dab3 Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Thu, 2 Nov 2023 16:44:26 -0400 Subject: [PATCH 22/34] changed figure size to include brackets --- dataset_analysis/dataframe_analysis.ipynb | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/dataset_analysis/dataframe_analysis.ipynb b/dataset_analysis/dataframe_analysis.ipynb index 18b39af..a836223 100644 --- a/dataset_analysis/dataframe_analysis.ipynb +++ b/dataset_analysis/dataframe_analysis.ipynb @@ -235,13 +235,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_23213/3800180276.py:2: SettingWithCopyWarning: \n", + "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_60574/3800180276.py:2: 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", " df_M0['timepoint'] = 'M0'\n", - "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_23213/3800180276.py:3: SettingWithCopyWarning: \n", + "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_60574/3800180276.py:3: 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", @@ -645,7 +645,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_23213/1423961972.py:8: SettingWithCopyWarning: \n", + "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_60574/1423961972.py:8: 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", @@ -690,7 +690,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -730,9 +730,11 @@ " box_meanprops={'marker': '^', 'markerfacecolor': 'black', 'markeredgecolor': 'black',\n", " 'markersize': '6'},\n", " hue_order=['RIS','RRMS','PPMS'],\n", - " box_medianprops={\"zorder\": 11}\n", - " \n", + " box_medianprops={\"zorder\": 11},\n", + " \n", " )\n", + "\n", + "\n", "plt.show()" ] }, @@ -743,7 +745,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -783,6 +785,10 @@ " hue_order=['RIS','RRMS','PPMS'],\n", " box_medianprops={\"zorder\": 11} \n", " )\n", + "\n", + "#we set y_max at 25\n", + "plt.ylim(0, 25)\n", + "\n", "plt.show()" ] }, From 315094a06679c9d4bac9d02b971dfa7616fd45a6 Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Thu, 9 Nov 2023 17:03:34 -0500 Subject: [PATCH 23/34] added requirements for dataframe analysis --- dataset_analysis/requirements_dataframe.txt | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 dataset_analysis/requirements_dataframe.txt diff --git a/dataset_analysis/requirements_dataframe.txt b/dataset_analysis/requirements_dataframe.txt new file mode 100644 index 0000000..a29a770 --- /dev/null +++ b/dataset_analysis/requirements_dataframe.txt @@ -0,0 +1,8 @@ +nibabel==5.0.1 +numpy==1.24.3 +pandas==2.0.3 +matplotlib==3.7.2 +prettytable==3.9.0 +ptitprince==0.2.7 +seaborn==0.11.0 +scipy==1.11.1 \ No newline at end of file From e0f20ba942cf55263ad5107f449fc4c3c8b549a5 Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Thu, 9 Nov 2023 17:04:27 -0500 Subject: [PATCH 24/34] formatted dataframe analysis notebook --- dataset_analysis/dataframe_analysis.ipynb | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/dataset_analysis/dataframe_analysis.ipynb b/dataset_analysis/dataframe_analysis.ipynb index a836223..9993fbf 100644 --- a/dataset_analysis/dataframe_analysis.ipynb +++ b/dataset_analysis/dataframe_analysis.ipynb @@ -46,7 +46,10 @@ "import sys\n", "import yaml\n", "from prettytable import PrettyTable\n", - "import ptitprince as pt\n" + "import ptitprince as pt\n", + "\n", + "from scipy.stats import wilcoxon\n", + "from scipy.stats import normaltest" ] }, { @@ -836,8 +839,6 @@ ], "source": [ "# compute wilcoxon test for the number of lesions\n", - "from scipy.stats import wilcoxon\n", - "from scipy.stats import normaltest\n", "\n", "method_M0 = df123[df123['Method'] == 'M0 (manual segmentation)']['Number of lesions per participant'].dropna()\n", "method_M12 = df123[df123['Method'] == 'M12 (2D nnUNet)']['Number of lesions per participant'].dropna()\n", From 3a6fca6db277bec7502f63dbcad682a9d5750cd9 Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Thu, 9 Nov 2023 17:14:35 -0500 Subject: [PATCH 25/34] added readme for dataframe analysis --- dataset_analysis/README.md | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 dataset_analysis/README.md diff --git a/dataset_analysis/README.md b/dataset_analysis/README.md new file mode 100644 index 0000000..09ad9be --- /dev/null +++ b/dataset_analysis/README.md @@ -0,0 +1,23 @@ +# Installation + +To install the required libraries run : + +~~~ +pip install -r requirements_dataframe.txt +~~~ + +It is also required to install SpinalCordToolbox 6.0 : + +Installation link : https://spinalcordtoolbox.com/user_section/installation.html + +# Dataframe generation + +To generate the dataframe run : + +~~~ +python generate_dataframe.py --data /path/to/CanProCo --lesion /path/to/lesion/segmentation --discs /path/to/discs/segmentation --spinal-cord /path/to/spinal/cord/segmentation --timepoint M0 --exclude-file /path/to/exclude/file --output /path/to/output/folder +~~~ + +# Dataframe analysis + +The following Notebook `dataframe_analysis.ipynb` details the analysis of the generated dataframe. To use it, update the link to the CSV dataframes. From e02731b93714bbd1701baf5f2c342d697bedc4e1 Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Thu, 9 Nov 2023 17:32:25 -0500 Subject: [PATCH 26/34] formatted the dataframe analysis notebook --- dataset_analysis/dataframe_analysis.ipynb | 347 +++++++++++++--------- 1 file changed, 203 insertions(+), 144 deletions(-) diff --git a/dataset_analysis/dataframe_analysis.ipynb b/dataset_analysis/dataframe_analysis.ipynb index 9993fbf..c645796 100644 --- a/dataset_analysis/dataframe_analysis.ipynb +++ b/dataset_analysis/dataframe_analysis.ipynb @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -58,20 +58,22 @@ "source": [ "# Dataframe import\n", "\n", - "We import the dataframe and exclude the subjects which are in the `exclude.yml` file. " + "We import the dataframes. " ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "#load dataframes\n", "df_M0_path = '/Users/plbenveniste/tmp_romane/canproco/project/canproco_final/dataframes/dataframe_M0/dataframe.csv'\n", "df_M0_all = pd.read_csv(df_M0_path)\n", - "df_M12_path = '/Users/plbenveniste/tmp_romane/canproco/project/canproco_final/dataframes/dataframe_M12_3d/dataframe.csv'\n", - "df_M12_all = pd.read_csv(df_M12_path)" + "df_M12_3d_path = '/Users/plbenveniste/tmp_romane/canproco/project/canproco_final/dataframes/dataframe_M12_3d/dataframe.csv'\n", + "df_M12_3d_all = pd.read_csv(df_M12_3d_path)\n", + "df_M12_2d_path = '/Users/plbenveniste/tmp_romane/canproco/project/canproco_final/dataframes/dataframe_M12_2d/dataframe.csv'\n", + "df_M12_2d_all = pd.read_csv(df_M12_2d_path)" ] }, { @@ -83,13 +85,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "#we replace all the NaN values by 0\n", "df_M0_all = df_M0_all.fillna(0)\n", - "df_M12_all = df_M12_all.fillna(0)" + "df_M12_3d_all = df_M12_3d_all.fillna(0)\n", + "df_M12_2d_all = df_M12_2d_all.fillna(0)" ] }, { @@ -108,7 +111,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -127,7 +130,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAR4AAAHMCAYAAAADP8fyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA9TklEQVR4nO3de3wU1aEH8N++sptskk0gBAiEBEiMhLe8VB4RKVKLbfFitfSh1MZaq1UTvKn0QUiqRtIqWO2nfioKVmurpRa9V6n4IORC65MkivJIeAbCKyHZzYPsZnfP/SPdlZDdJJudndnd+X0/n3w+MDs7ObPZ+c2ZM+ec0QghBIiIZKRVugBEpD4MHiKSHYOHiGTH4CEi2TF4iEh2DB4ikh2Dh4hkx+AhItkxeIhIdgwe8tJoNNBoNDh69GiP5WvXroVGo8HKlSsVKZc//sq7cuVKaDQarF27VpFy9SWcyyYnBs8A/eIXv/B+0R999FGlixOxNmzYgLVr1/YKi2gQzfsmNQbPALjdbvzpT3/y/n/Tpk0KlkZ+KSkpyMnJwciRI4Pe1oYNG1BSUiLJwZmTk4OcnBwYDIagtyWFgezbyJEjkZOTg5SUFPkKFob0ShcgEmzfvh0nTpyA2WyGw+HAwYMHsXv3bsydO1fposninnvuwT333KN0MXrZv3+/0kUIWFlZGcrKypQuhuJY4xmA5557DgBw00034Wtf+1qPZUQUOAZPP86fP4/XX38dAHDrrbfitttuAwC88soraG9v7/O9p0+fxl133YX09HSYTCZkZmbi/vvvR3Nzc78Ntna7HU899RTmz5+PIUOGwGg0IjMzE/n5+airqxv0/rz66quYN28e4uPjkZSUhAULFuC1117r8z19lfXIkSP48Y9/jOzsbMTGxsJsNiMzMxNf+cpX8Mgjj3g/o82bN0Oj0eDYsWMAgIULF3rbzC7d9jXXXAONRoPNmzfjxIkTuPPOO5GZmYmYmBgsW7bMu56/xuWLNTc347777sPYsWNhNBoxatQo/OhHP0JDQ4PP9TMzM6HRaFBRUeHz9YqKCmg0GmRmZnqXBbJv/TUu79u3D7fffjsyMzNhNBqRnJyMvLw8PPvss3C5XD7fc/Hn8Nlnn+GWW27B8OHDYTQakZOTg9LSUjgcDr+fkRJ4qdWPP//5z7Db7RgzZgwWLlwIp9OJlJQUNDY24m9/+5vf4Kirq0NeXh4aGhqg0+kwceJEuN1uPPnkk3jjjTewdOlSv7/z1KlTWLp0KaqqqqDRaDBq1CiMGTMGtbW1ePbZZ/Hyyy9j69atWLRoUUD7smbNGvz6178GAKSmpmLMmDH4/PPPsWzZMmzYsCGgbQFATU0N8vLyYLVaYTKZMG7cOMTGxuLkyZPYsWMH3n33Xdx8883IysrC8OHDMXfuXHz88cew2+2YNGkSLBaLd1uXXXZZr+3X1tbigQcegNVqRW5uLiwWC/T6gX9lm5ubMWvWLBw+fBgTJkzAhAkTsHfvXjzzzDN47bXXsHPnTlx++eUB7/elBrNvvrzyyiv4/ve/D4fDAbPZjMmTJ6OpqQmVlZWorKzEli1b8I9//AMmk8nn+7dv34777rsPer0eOTk50Ov1OHjwIIqLi/Hpp59iy5YtQe+rZAT1adq0aQKA+PnPf+5d9tOf/lQAEPPnz/f7vjlz5ggAYsaMGeLo0aPe5bW1tWLSpEnCYDAIAOK2227r8T6XyyWuuuoqAUAsWrRIHDhwwPua3W4XDz74oAAghg4dKhobGwe8H2+//bYAIACI3/72t8LlcgkhhOjq6hJr1qzxlgeAOHLkSI/3FhcX+yzrsmXLBADxve99T1it1h6vnT17Vjz11FPizJkzPZZnZGQIAGLHjh1+y5qXlycACJ1OJ5YsWSJOnz7tfa2jo8P7b3/lve222wQAYTAYRFZWlti7d6/3tePHj4vZs2cLAGLq1KnC6XQGVL4dO3YIACIjI6PXawPZN0/ZiouLeyzft2+fMJlMAoDIz88XbW1t3te2b98uLBaLACDuu+++Xtv0fA4Gg0EUFRWJCxcueF/705/+JDQajQAg3nvvPb/lkhuDpw9VVVXeP+r+/fu9yz/55BPv8oMHD/Z6n+fLaTQaxbFjx3q9vn//fqHT6XwezC+//LIAILKyskRra6vPcn39618XAERZWdmA9+Xaa68VAMRNN93k8/XFixcHHDw5OTkCgKiurh5wOQIJntTUVGGz2fyu11/wABC7d+/u9b6jR48KvV4vAIitW7cGVL5QBc/tt98uAIhJkyYJt9vd630bN24UAERMTEyvMPfs66JFi3z+zqVLlwoAoqCgwG+55MY2nj54GpDnzJmDnJwc7/IrrrgCkydPBtB9fX+pbdu2AQAWL16MMWPG9Ho9JycH8+bN8/k7//a3vwEAvvvd7yI+Pt7nOsuXLwcAvPfeewPaj/b2duzcuRMAcN999/lc5/777x/Qti7m2bc///nPftsfgnHTTTchISFh0O+fNWsWrr766l7LMzIycOONNwIA3nzzzUFvX0qecqxatQoajabX67feeitSU1PhcDjwzjvv+NzG3Xff7XO55+5rMG2DUmPw+OFwOPDSSy8BgLdB+WKeZc8//3yvg+7AgQMAgKlTp/rdvr/XampqAAB//etfMW/ePJ8/v/nNbwAAJ06cGNC+1NXVecuYm5vrc52JEycOaFsXe+CBB6DRaPCb3/wGo0ePxsqVK/H000/j888/D3hbvvgr60BNmjTJ72ue/d23b19Qv0MKVqsVp0+fBgDvCe1SBoPB2x7lrxuBv7ak4cOHAwDa2tqCLapk2Ljsx9atW9HU1ISYmBjccsstvV7/7ne/iwcffBAnT57E9u3bcf3113tf8/yB+zpb+3utubkZQHd4eQLMn46Ojn73AwBaW1sBAHq9HkOGDPG5jufLGYjrrrsO7777Lh555BHs3LkTzz//PJ5//nkAwIQJE/Dwww97axaDYTabB/1eoO998rzm+WyUdHEZRowY4Xc9TwdOf2X293lptd31C7fbPdgiSo41Hj88vZMdDgeGDh3a4/aoRqPByJEj4XQ6e6zr4blE6utL7e81z3u3bt0K0d0G5/dnoL1/PSHndDpx/vx5n+ucOXNmQNu61MKFC/H222+jpaUF7777LoqLizFx4kTs27cPy5cvx1tvvTWo7Uqhr33yvHbpCcBzmSP8PHylvy4Ug3FxGTw1H19OnTrVa/1IxeDxwVOLAbqHCwwfPtznj6fb+2uvvYampibv+z3tQZ7LJl/8veapau/evVuSfQGArKws6HQ6AMAXX3zhc51gL4/i4uJw7bXXYu3atfjss8+wfPlyCCHwhz/8ocd6vtovQqWvffK8NmHChB7LPbUGf6F18OBBv9sc7L5ZLBZvTWfv3r0+13E6nd4a8KVljkQMHh82b94Mt9uN1NRUnDp1CqdPn/b5c/LkSQwdOhQOhwN//vOfve//6le/CgB4++23cfz48V7bP3jwIHbt2uXzd998880AgI0bN3rPcMEym81YsGABAODJJ5/0uc4TTzwhye8Cug9AT+P5pR314uLiAAAXLlyQ7Pf58+GHH+Lf//53r+XHjx/H1q1bAaDHJTIAZGdnA4DP9zmdTjzzzDN+f18w++bp17V+/Xqfta0XXngBZ86cgdFoDLj/Vjhi8PjguVP1ve99r88OazExMfjOd74DoOfl1jXXXIM5c+bAbrdj+fLlPcLn0KFDWL58ufe6+1IrVqzAlVdeiebmZlx77bU+A2rfvn1Ys2YN/ud//mfA+/Tggw8C6L5rtmHDBu/1vtPpRGlpKXbs2DHgbXl861vfwquvvtqrrenQoUP44x//CKD7ztLFsrKyAAz8jlwwDAYDVq5c2aMB+cSJE7jlllvQ1dWFyZMn4+tf/3qP93zjG98AADz77LM9PhObzYY77rijzztDwezbAw88AJPJhJqaGvzkJz/p8Zm+++67WLVqFQDgrrvuQmpqasDbDzsK3cYPWzt37vT2i/j000/7XX/Pnj3e9ffs2eNdXltbK0aOHOntCDd16lQxefJkodVqxfjx48W9994rAIjbb7+91zbPnDkjrr76au92hw8fLmbPni2mT58uhgwZ4l2+adOmgPZt9erV3vempqaKWbNmiaFDhwoAYsOGDQH34/F0atPr9SInJ0fMmTNHZGdnezusZWdn9+pzsmXLFu/vGTdunJg/f77Iy8vr0SfJ04+nv/3zV15PX5l7771XjB8/Xmg0GjFx4kQxbdo0b/+dlJSUHh0LPbq6urydPzUajRg7dqy44oorhMlkEklJSeKJJ57w249nIPvmrx+PEN19uGJiYgQAER8fL2bOnCnGjRvn3eaSJUt6dA7s73Pw2LRpkwAg8vLy+vo4ZcUazyU8NZcZM2b4vbV5senTp3tvjV88cDQrKwt79uzBnXfeieHDh2Pfvn2wWq34yU9+gg8//NA7lUNiYmKvbaampmLnzp144YUXcP3110MIgaqqKpw4cQJjxozB7bffjtdeew3f/va3A9q3Rx55BK+88gquvvpqtLW14cCBA8jNzcXWrVv99u/py5/+9CfcfffdmDx5Mpqbm/HJJ5/gzJkzmDlzJh5++GHs2bOn19l5+fLleO655zBnzhycO3cOu3btws6dO0My0jw5ORkfffQRfvrTn6KtrQ1ffPEFhg0bhh/+8Ieoqqry2YVAr9dj+/btKCwsxJgxY3DixAk0NDTg5ptvRlVVFaZMmeL39wW7b57fsXLlSgwZMgSffvopmpqaMH/+fDzzzDN44403/A6XiDQaIfjsdCUsXboUb775Jp544gnce++9SheHSFas8Sjg2LFj3t6nnkZfIjVh8ITIoUOH8Pjjj6OxsbHH8pqaGtxwww1wOByYN28epk2bpkwBiRTES60Qqa6uxvTp06HRaJCWloa0tDScO3fO2+kvPT0dO3bswPjx45UtKJECGDwh0tLSgscffxxvv/02jh49ivPnz8NgMCArKws33HADCgoKMHToUKWLSaQIBg8RyY5tPEQku4gane52u9HQ0ICEhARZx/wQ0cAIIdDa2oq0tDS/vfOBCAuehoYGpKenK10MIupHfX09Ro8e7ff1iAoez3QA9fX1Pnv8EpGybDYb0tPT+526I6KCx3N5lZiYyOAhCmP9NYWwcZmIZMfgISLZMXiISHYMHiKSHYOHiGTH4CEi2TF4iEh2DB4ikh2Dh4hkx+AhItkxeIhIdgweIpIdg4eIZBdRo9MJ6HA4lS4CDUBcDA+tvvDTiTC5a95Sugg0AEcfXap0EcIaL7WISHas8USYL0qXyP47Lzhc2HOsGQ6nW9Lt2p0uFP7tUwDA49+aAqNeJ+n2xw6LR2ZKnKTbJGkweCKM3G0HDqcbB860QKPRwGiQNhguZtTrJN9+Q8sFJJsNGGmJlXS7FDxeapFfLrfApyda0GF3KV2UQfuiwYamNrvSxaBLMHjIJ7dboOZEC1o6upQuSlCEAD49YUVLh0PpotBFGDzUixACnzfYcL4tOg5Wl1ugur4FrZ2RHaLRhMFDvew71Yoztk6liyEpp0ug6ngL+0GFCQYP9XDgdCsaWi4oXYyQcDjd2HOsBRcckdtmFS0YPORVe6YV9ec7lC5GSHV2ubDneDM6uxg+SmLwEACg7mwbjjVFd+h4ePolMXyUw+AhHD7XhqON7UoXQ1YdDtZ8lMTgUbnD59pw+Jy6Qsejw87wUQqDR8XUHDoeDB9lMHhUiqHzJYaP/Bg8KnSIodNLh50NznJi8KhM3dk2HGHo+NTBu12yYfCoSN3ZVtXdvQoUw0cegw6ef/zjH1i8eDGGDh2K2NhYjB07FitWrEB9fX2P9Ww2GwoLC5GRkQGj0YiMjAwUFhbCZrMFXXgauNozrTjaqI5+OsHqcLjwCcMnpAKe3EUIgR//+Mf44x//iPHjx+Pb3/42EhIS0NDQgJ07d+LYsWNIT08HALS3tyMvLw/V1dVYvHgxVqxYgZqaGqxfvx47duzArl27YDabJd8p6ungmVYcV0nnQKlc+E/4XDEmGbExoZuHSK0CDp4nn3wSf/zjH3H33XfjiSeegE7X84/idH45CK+8vBzV1dUoKirCunXrvMuLi4tRWlqK8vJylJSUBFF86g9DZ/A84TMjg+EjNY0QQgx05QsXLmD06NFISkrCgQMHoNf7zy0hBEaPHg2bzYbTp0/3qNl0dnYiLS0NcXFxqK+vh0ajGdDvt9lssFgssFqtSExMHGixVevA6fAee2XvcuHuv1QBAH6/YnpIZzgMhsmgwxUZSXxyxAAM9BgNqI3n7bffxvnz57Fs2TK4XC68+uqrePTRR/H000+jrq6ux7q1tbVoaGjA3Llze11OmUwmLFiwACdPnuz1PpJGuIdOJOnscnFUu8QCivCPP/64+016PaZOnYoDBw54X9NqtSgoKMBvf/tbAN3BAwDZ2dk+t+VZXltb63cdu90Ou/3LaSvZID0wB1UwylxunV287JJSQDWes2fPAgAee+wxJCYm4sMPP0RraysqKytx2WWX4bHHHsMf/vAHAIDVagUAWCwWn9vyVMM86/lSVlYGi8Xi/fE0WpN/bNMJHU/4sOYTvICCx+3ufrxJTEwMtm7dilmzZiE+Ph7z58/Hli1boNVq8dhjj0lWuNWrV8NqtXp/Lr1VTz3VMnRCjvP5SCOgSy1P7WXmzJlIS0vr8drEiRMxbtw41NXVoaWlxbuuvxqN57LJX40IAIxGI4xGYyBFVK1D59Qzn47SPPP5zMhMlvxZYGoRUI0nJycHAJCUlOTzdc/yCxcu9GjD8aW/NiAauKON7RwGIbPuHs4tkj/kUC0CCp6FCxcCAPbt29frta6uLtTV1cFsNmPYsGHIzs5GWloadu/ejfb2ngdFZ2cnKisrkZaWhqysrCCKT/XnO1B3tk3pYqhSu92JquPN6HIxfAIVUPCMHz8e1113Herq6rBx48Yerz366KNoaWnBjTfeCL1eD41Gg/z8fLS1taG0tLTHumVlZWhubkZ+fv6A+/BQb6esF3DgdKvSxVC11k4naupb4HIPuDscIcAOhABw6NAhXH311Th79iyWLl2Kyy+/HFVVVXjvvfeQkZGB999/HyNGjADQPWRi3rx53iETM2bMQE1NDbZt24Zp06YFPGSCHQi/1NhmR019CwL764WXSOlAOBApCUZMHW1R/Yk0JB0Ige5az8cff4yVK1fik08+we9+9zvU1tbi7rvvxocffugNHQAwm82oqKhAQUEB9u/fj8ceewx79+5FQUEBKioqOE5rkKwdXfjshDWiQyfaNLba8cUp9jMbqIBrPEpijae7XeGjo+fhdEXMn82vaKrxeGSmxCErNUHpYigmZDUeUo7d6UJ1fUtUhE60OtrYgZNR+kBEKTF4IoTbLfDpCSt7zUaA/adsaGqz97+iijF4IsQXp2ywdnQpXQwaACGAz05a0W7nc9r9YfBEgCON7Tht7VS6GBQAp0ugur6FfXz8YPCEucY2Ow6xg2BEuuBwYe9JKyLo/o1sGDxhzPPFpcjV1ObAEU6w3wuDJ0x1NybzDlY0OHyuHY1sbO6BwROm6s61obWTjZPR4vMGG+xO3pH0YPCEocY2O+fViTJdTje+aGDPZg8GT5hx8AsatZraHJyS9j8YPGFm/2kb53iJYrVnW9Hh4CU0gyeMnG3txFkbGyGjmdsN7ONgUgZPuHC63JxbRyWa27tUP56LwRMm6s61wd7FSyy1qD3Tquq7XAyeMNBmd+Jks7rPgGrjdAkcVvE82QyeMFB7ppWTeqlQQ8sFtKl0ICmDR2FNbXY0tTmULgYpQIjuk44aMXgUVssBoKrW1ObA+Xb1nXgYPAo612pHG4dFqJ4aB5EyeBSkxi8c9dbc7kBLh7pqPQwehTS12WG7wBkFqZvaTkIMHoUc55gdukhTm0NVU6UyeBTQ4XDyThb1ckJFfbkYPApQ0xeMBq7BegFOlczRzOCRmdst0KDycTrkm8slcNqmjkn9GTwya2yzczpT8kstTxNh8MjslEq+WDQ4LR1dqnhoI4NHRg6nG03tnG+H+nbKGv2X4gweGZ1rs8OtjrZDCsIZFUwGx+CR0bnW6P9CUfDa7c6onx6VwSMTp8uN87zMogGK9ilwGTwyOd/u4GUWDdi5KH8AIINHJtH+RSJp2S50oSuKOxMyeGSixjlXaPCEQFQPq2HwyKC1s4sTuVPAovl56wweGUTzmYtCJ5pryQweGZxX2SRPJA2H0x21k8EzeELM5Raqm12OpHM+SmvLDJ4Qa+ngbXQavGgdYsPgCbFm1nYoCC0dXXC7o282AwZPiJ1v57zKNHgut4CtM/q+QwyeEOpyuTmhOwUtGu9uMXhCqDkKvzAkPwYPBaQpCr8wJD/rha6om4uZwRNC0XimIvkJEX19wRg8IdLhcKpiCkuSR7SdxBg8IdLYGl1fFFJWtH2fGDwhwmkwSEqdXa6oGj7B4AkBp8sN64XoOkOR8hqjaOpcBk8INHG2QQqBaKpFM3hCINrnyyVlWDu60NkVHTcsGDwSc7lFVE/gRMqKlieVMHgk1tRmhysKB/VReDgTJc9WZ/BIjI8oplCKlkccM3gkxEcUkxyi4RHHDB4JnbF18m4WhdzpKKhVM3gk1NAS+WciCn8dDlfEz3zA4JGItaMLrZ3R07OUwtvJCD/JMXgkUt/coXQRSEXOtnbC7ozcRmYGjwQcTjfOtkb+dTdFDrcbaGiJ3O8cg0cCJ5o72KhMsqs/3xGxE8EzeILkcgvUN0f29TZFJofTjVMR2qFwUMGTmZkJjUbj8+fHP/5xr/VtNhsKCwuRkZEBo9GIjIwMFBYWwmazBb0DSjtlvYAuJ6s7pIxjTe0QIvJqPfrBvtFiseD+++/vtXzmzJk9/t/e3o68vDxUV1dj8eLFWLFiBWpqarB+/Xrs2LEDu3btgtlsHmwxFCWEwPEmNiqTcjrsLpxrsyM1waR0UQIy6OBJSkrC2rVr+12vvLwc1dXVKCoqwrp167zLi4uLUVpaivLycpSUlAy2GIo6Ze1ERxR0X6fIdvhce8QFT0jbeIQQ2LhxI+Lj47FmzZoer61evRrJycl49tlnI7KqKITA0cZ2pYtBhLZOZ8TdVR10jcdut+P555/HyZMnkZycjKuvvhpTp07tsU5tbS0aGhqwZMmSXpdTJpMJCxYswGuvvYa6ujpkZ2cPtiiKYG2Hwsnhc+0YFm+ERqNRuigDMujgOX36NFauXNlj2Ve/+lW88MILSElJAdAdPAD8hopneW1tbUQFj9stcPgcazsUPrprPXYMT4yMS65BXWrdfvvtqKiowLlz52Cz2fD+++/j+uuvxz//+U984xvf8F46Wa1WAN0N0b4kJib2WO9SdrsdNputx084ONF8IWpmgqPocehsW8T06xlU8KxZswZ5eXlISUlBQkIC5syZg//93//FvHnz8O9//xtvvvmmJIUrKyuDxWLx/qSnp0uy3WB0udw40sTaDoWfDocrYsZwSda4rNVq8YMf/AAAsHv3bgBf1nT81Wg8NRh/NaLVq1fDarV6f+rr66Uq7qAda+pgvx0KW0ca2yPicceDbuPxxdO209HR3bfl4jYcX/prAzIajTAajVIWMSidXS4cP8/aDoUvh9ONo00dyEqNV7oofZL0dvoHH3wAoLtnM9AdKGlpadi9ezfa23sesJ2dnaisrERaWhqysrKkLEbI1J1t45gsCnvHz7eHfRtkwMHzxRdfoKWlpdfyXbt24fHHH4fRaMR//dd/AQA0Gg3y8/PR1taG0tLSHuuXlZWhubkZ+fn5EXEL0HqhKypmfqPo53Z3nyTDWcCXWq+88grKy8uxaNEiZGZmwmg0Yu/evdi+fTu0Wi2efvppjBkzxrt+UVERXn/9dZSXl6OqqgozZsxATU0Ntm3bhmnTpqGoqEjSHQoFIQQOnmlVuhhEA3ba2onRybFIiotRuig+BRw8CxcuxL59+7Bnzx7s3LkTnZ2dGD58OG655RYUFBRg9uzZPdY3m82oqKhASUkJtmzZgoqKCowYMQIFBQUoLi6OiHFap22dsHZ0KV0MooAcON2K2WOHhOUVhUZE0HgFm80Gi8UCq9Xq7QMUak6XG/8+3AR7Fxt3pGbvcuHuv1QBAH6/YjqMBp3CJYo+E9ISMSopVrbfN9BjlPPx9ONoUztDhyLWobNt6ArD2+sMnj50OJw4fp7TXlDkcjjdOBKGg5kZPH2oPcPb5xT56s93oN0eXk9AYfD40dRmx7lWPhWUIp8QwIEwuyvL4PHB7RZh94ciCsb5NkdYnUgZPD6cbLmADnt49/wkClTtmdawGb3O4LmEw+nGoXPh3euTaDA6HC6cCJMnojB4LtE9ujc8zgpEUjvc2AZHGMyuwOC5SIfDiRN8FDFFMadLhMXtdQbPRerOtiFy+nETDc6J5g50OJS9vc7g+Y+WDgfO2sKn1Z8oVIRQfvQ6g+c/lP5DEMnprM0O6wXlBj4zeNDdWbCFo89JZQ4rePeWwQPgEB9VQyrU1OZAS4dDkd+t+uA512qHTcEqJ5GSlOqzpvrgOcpH1ZCKNbd3KTLJnaqD53y7gzMLkuop8Zw4VQcPaztEQGOrHW0yT5uh2uBp7ezC+TZlGtaIws0xmU/Cqg2ecBksRxQOztg6ZR3Dpcrg6XK5+Ywsoou43cApq3wnY1UGz2lrJ1xhMi8JUbg40XwBcj10RpXBc7KFl1lEl7rgcMnWg191wdPa2YW2zvCa+JooXDTIdLmluuBh2w6Rf2db7bI0Q6gveGwMHiJ/XC6BxrbQTw+jquCxXujiU0GJ+iHH0yhUFTzh9HgPonDV2GYP+dMoGDxE1IPTJdAc4ukyVBM8nV2usHuMK1G4YvBIhDMMEg1cU4jHMaomeJraeZlFNFCtnU50uUJ3I0Y1wcN5d4gCE8rLLVUEj8PpRoeDz0InCoTtQujaRFURPLZO1naIAhXK40YdwcPJ3IkCFsrjRhXBI/e0jkTRwOkS6OwKTROFOoKHo9GJBiVUJ+2oDx63W+BCiFKbKNqFqtNt1AdPu8MJmSZVI4o6rPEMEms7RIPHNp5B6nRwGgyiwQpV/7eoD56OLjYsEw2Wvcsdkikyoj54OjnxF1FQOp3S13qiPnjsbOMhCkooZu2M/uCR8emIRNEoFMdQVAePEELWx7ISRSM7L7UC4wjhfCJEahGKeXmiO3hY2yEKGi+1AtTlYpdlomCF4jiK8uBhjYcoWLzUChCDhyh4DJ4AOXmpRRS0UBxH0R08btZ4iIIViuMoyoOHNR6iYLndkHy8VnQHDy+1iCThknhSq6gOHhdrPESSkPpYiu7g4dSDRJKQutkiqoMnFPOIEKkRazwB4KUWkTTYuBwAXmoRSYONywFg7hBJw83gGTipPywi1ZL4UAo6eMrLy6HRaKDRaPD+++/7XMdms6GwsBAZGRkwGo3IyMhAYWEhbDZbsL++T8wdImlI3VwaVPDs27cPa9asgdls9rtOe3s78vLysH79euTk5KCgoAC5ublYv3498vLy0N7eHkwR+sQaD5E0wuZSy+Vy4bbbbsPUqVNx4403+l2vvLwc1dXVKCoqwvbt2/Hoo49i27ZtWLNmDaqrq1FeXj7YIvSLsUMkDamPpUEHz7p161BTU4PnnnsOOp3O5zpCCGzcuBHx8fFYs2ZNj9dWr16N5ORkPPvssxChqpkweYjC0qCCZ+/evSgpKcEvf/lLTJw40e96tbW1aGhowNy5c3tdjplMJixYsAAnT55EXV3dYIpBRDKRunIQcPA4nU6sXLkSEyZMwIMPPtjnurW1tQCA7Oxsn697lnvWI6LwpNFoJN2ePtA3PPLII6ipqcEHH3wAg8HQ57pWqxUAYLFYfL6emJjYY71L2e122O127/8Dvgsm7WcVFqLpAYUXPzYlFI9QUZLR4Lv5gboFFDw1NTV46KGH8MADD+CKK64IVZm8ysrKUFJSEvLfE0nu/kuV0kUIicK/fap0ESS18daZShchrAV0qXXbbbdh/PjxWLt27YDW99R0/NVoPDUYfzWi1atXw2q1en/q6+sDKW40VniIFCH1sRRwjQfobhj25aqrrgIA/OMf/8CyZcv6bcPprw3IaDTCaDQGUsQetBoNou3W1u9XTFe6CJKxO13ems7j35oCo56XJ+FKq2Qbzw9/+EOfyysrK1FbW4tvfOMbGDZsGDIzMwF0B0paWhp2796N9vb2Hne2Ojs7UVlZibS0NGRlZQ1+D/og9YcVDqK17cCo10XtvkUDrcSHUkDBs3HjRp/LV65cidraWqxevRpXXnmld7lGo0F+fj5KS0tRWlqKdevWeV8rKytDc3MzfvrTn0reYu4h9YdFpFaK39UKVFFREV5//XWUl5ejqqoKM2bMQE1NDbZt24Zp06ahqKgoZL9by+QhkoRe4mMp5KPTzWYzKioqUFBQgP379+Oxxx7D3r17UVBQgIqKij7HeQVL6g+LSK2kPolrRMjGK0jPZrPBYrHAarV6+wD1Zc/xZpxvc8hQMhoMe5fL2z3g9yums40njF01fijMxv4vkAZ6jEb1fDys8RBJQxdpl1pK0mujeveIZGPQSXssRfWRGaNnjYcoWFotazwBYY2HKHihOI6i+siM0Uf17hHJIhTHUVQfmQweouAxeAIkdYMYkRrFhOA4iuoj08gaD1HQQnEcRfWRadRrEYXjRIlkFYpZA6I6eDQaDadaIAqSycAaT8BC8aERqUkohrJE/VFp4vgfoqCwxjMIDB6iwdNpQ9NcEfXBExvD4CEarFCduKM/eFjjIRq0UJ24oz544ljjIRq0UB0/UR88Rr1W8pG1RGrB4BkkjUbDdh6iQYqLCc207FEfPAAvt4gGizWeIAxkrlgi6kmn0/CuVjDMIaouEkWzUB43qgieOCMvtYgCFcomClUED2s8RIELZROFKoJHp+WdLaJAmUN4paCK4AHYwEwUqHjWeIJnZo2HaMC02tAON1JP8LDGQzRgcTF6aEI4fSeDh4h6CeVlFqCm4OGlFtGAhfpErZrg0eu0nBSMaIBCeUcLUFHwAKH/MImiRaj7vqkqeEJ93UoUDbTa0A+sVlXwxDF4iPoVawjtHS1AZcETz6ETRP2S48pAVcHDwaJE/ZOjLVRVwWPQaWHkA/6I+iRHnzfVHYWhmsqRKFrIMWOn6oKHt9SJ+ibHNDLqCx7WeIj8io3RQSvDU1lUFzyc+J3IP7mOD9UFDweLEvkn1/GhuuDhA/6I/GONJ0T4gD8i/+S666u64AHYwEzkD2s8IcQezES9hfIBfpdSZfCwxkPUW5yM81WpMnjYxkPUm5x3fFUZPJwGlag3Ofu4qTJ49DotYvSq3HUiv+Qcx6jao49jtoh6kvOmi2qDh6PUiXqS86aLaoOHd7aIvmQy6GTt0a/e4OGlFpGX3H3bVBw8rPEQecj9BBbVBo/JoINOx8GiRID8J2LVBg/A52wRecj9BBZVBw8bmIm6sY1HRgkmBg9RbIwOBp28UcDgIVI5JZocVB08vLNFpMwJWNXBY9BpOfk7qV6CySD771R18ABAYqz8HzpROEmMZY1HdokKpD1RuDAZdDDq5a/1BxQ8LS0tuPfee3HVVVdhxIgRMBqNGDVqFK699lr8/e9/hxCi13tsNhsKCwuRkZEBo9GIjIwMFBYWwmazSbYTwbCwxkMqptT3P6DgaWxsxHPPPQez2Yxly5Zh1apVuP766/H555/jpptuwp133tlj/fb2duTl5WH9+vXIyclBQUEBcnNzsX79euTl5aG9vV3SnRmMBJMeWtXX+0itkuKUCZ6ALu7Gjh2LlpYW6PU939ba2oorr7wSzzzzDO677z5MnDgRAFBeXo7q6moUFRVh3bp13vWLi4tRWlqK8vJylJSUSLAbg6fVamCJNaC5vUvRchApQangCehcr9PpeoUOACQkJGDJkiUAgLq6OgCAEAIbN25EfHw81qxZ02P91atXIzk5Gc8++6zPyzO5JcXFKF0EItnpdRrFhg1JcpHR2dmJ9957DxqNBrm5uQCA2tpaNDQ0YO7cuTCbzT3WN5lMWLBgAU6ePOkNKiUlM3hIhZLiYqDRKDNQelBx19LSgg0bNsDtduPs2bN48803UV9fj+LiYmRnZwPoDh4A3v9f6uL1/K1jt9tht9u9/w9Vg3RSrAE6rQYut/K1LyK5DDUrd8IddPBc3DZjMBjwm9/8BqtWrfIus1qtAACLxeJzG4mJiT3W86WsrEyWNiCtVoNkcwwaW+39r0wUJYbGKxc8g7rUyszMhBACTqcTR44cQWlpKX7xi19g+fLlcDqdkhVu9erVsFqt3p/6+nrJtn0pJdOfSG6xMTpF5x0P6jfrdDpkZmbiwQcfhE6nQ1FREZ555hncdddd3pqOvxqN57LJX40IAIxGI4xGYzBFHLBhCUYcON0qy+8iUtqwBHmOK38k68Fy3XXXAQAqKioAoFdbz6X6awOSm8mg42h1Uo3UaAmehoYGAPDebs/OzkZaWhp2797dq6NgZ2cnKisrkZaWhqysLKmKELTURJPSRSAKuRi9VvEe+wEFT3V1tc9Lp/Pnz+PnP/85AOD6668HAGg0GuTn56OtrQ2lpaU91i8rK0NzczPy8/MVu53ni9JnASI5DEswKn7cBXRtsXnzZmzcuBELFy5ERkYGzGYzjh07hjfeeANtbW1Yvnw5vvOd73jXLyoqwuuvv47y8nJUVVVhxowZqKmpwbZt2zBt2jQUFRVJvkPBMBv1SIw1wHaBvZgpeo20KF+zDyh4brrpJlitVrz//vuorKxER0cHhgwZgnnz5uHWW2/Ft7/97R5JajabUVFRgZKSEmzZsgUVFRUYMWIECgoKUFxc3KtjYTgYaTExeChqxcbowqKnvkaEw5iFAbLZbLBYLLBard5+QFKzO13YVduIyPlUIpe9y4W7/1IFAPj9iukwGjgpW6iNHWbG+GHxIdv+QI9Rjsu+hFGvU/xWI1GopFlilS4CAAaPT6OSwuOPQySlofExiA2TqX4ZPD4MMcdwLmaKOqOT45QugheDxweNRhNWfySiYJkMOqQoODbrUgweP9KSTHy2OkWNMUPiFO+7czEGjx96nRaj2dZDUUCv0yAtSfm+Oxdj8PQhfUgcwugkQTQoo5PjoJf5EcX9Ca/ShBmTQYeRYXL7kWgwdFoN0oeE33eYwdOPsSlm1nooYo1OjlXkuVn9YfD0IzaGtR6KTDqtBmOGhufdWQbPAIwbZuaztyjipA8Jz9oOwOAZEJNBx349FFH0Og0yhobfIGwPBs8AjU0xQ89+PRQhxqXEwxBmd7IuFr4lCzMGnRZjU8L3DELkERujw+jk8G6XZPAEID05LmwG2RH5k5UaD602vGvnDJ4AaLUaXDY8QeliEPmVbI7B8AiYO5zBE6BhCUZFH4RG5I9GA+SMiIwTI4NnEHJGJPD2OoWd9CFxiDdGxiOaePgMQlyMHplhfKuS1Mdk0GFcBN38YPAMUuZQM8wRcnah6JczIiHsBoL2JXJKGma0Wg0mjIyM62mKbsMTTRE3TziDJwhJcTFIH8IezaQcvU6Dy0aE7qkRocLgCVJWajz79pBiLh+RGLbjsfrC4AmSTqvBxLTQPOOLqC+piUaMCIOngg4Gg0cCSXExYTv9AEUng14bMX12fGHwSCRrWDzvcpFsckdG5iWWB4NHIlqtBpNGJbJjIYXcqOTYiLuLdSkeJhJKMBmQNSxyq78U/uKMuqgYL8jgkVj6kFgM4VguCgGtFpg0ygJdmI88HwgGj8Q0mu67XEYDP1qSVnZqAhJNBqWLIQkeHSFg1OswMc2idDEoigxLMEZVZ1UGT4gMMcdg7LDIGbRH4ctk0CE3yvqKMXhCaFyKme09FBStFpg82hLW8ycPRnTtTZjRaDSYlGZhew8NWnZqAiyx0dGuczEeESEWo9diyqgkPo2UAjbCYoqqdp2LMXhkYIkzREXfC5JPvEmPCSOjq13nYgwemaQPicPIpMgc0Efy0us0mDI6Ovrr+MPgkdHlIxKRYOJ4LurbpFEWxMVE9/eEwSMjnVaDqelJMOj5sZNv41PjkRIf2eOwBoJHgMxMBh2mjLKwsZl6GZ5oUs3Tahk8Ckg2x0T0XCokvQSTPuo6CfaFwaOQ0clxGD0kvJ9vTfKI0WsxNT0pqhuTL8XgUdBlqQlINrNns5pptcCU0RaYDJE7qddgMHgUpNV23zaN42TxqjVhZCKS4tR38mHwKMyg02LamCTodeqpZlO3zBQzRlrUebnN4AkDcTF6TB3NYRVqkppoxHgVz17A4AkTyeaYqO4iT1+yxBkwMc0CjYrPNAyeMJKWFItMlfTjUKvYGF3UD4cYCAZPmBk/zByxD2mjvul13T3XI/mxNFJh8IQZjUaD3JGJSIqLvjlY1Kz7tnkS4vnsNQAMnrDUfZs9ibfZo8iEkYkYwj5bXgyeMBWj12L6mGQOKI0C41PjVXvb3B9+q8NYbIwO01TWlT7apCXFqmbgZyAYPGHOEmvAJI5mj0hD42NwOQcD+8TgiQDDEowczR5hEkx6TB5lgZa1VZ8YPBFidHIc+/hEiNgY3X+GwfDw8oefTATJSo3nvM1hzqDXYvoY9tXpD4MnwkwYkYihfEhgWNJpNZiWnhT18yVLgcETYTx9fBKj8CFvkUyj6X7iZzQ+fC8UGDwR6MszK6vz4WLCyERVTNIuFQZPhPJ0MIxhB0PFjU+NR1oSOwgGgt/aCOa5e6LjJGKKSR8Sxw6Cg8DgiXCJJgOmjk6Cln9J2Q1PNOGy4fFKFyMiBfR1PXnyJDZs2IDrrrsOY8aMQUxMDEaMGIHly5fjgw8+8Pkem82GwsJCZGRkwGg0IiMjA4WFhbDZbJLsAAFDzDGYmGZRuhiqkmyOwcS0RFVP5hWMgILnySefREFBAQ4fPozFixdj1apVmDdvHl577TVcffXVeOWVV3qs397ejry8PKxfvx45OTkoKChAbm4u1q9fj7y8PLS3t0u6M2o2PNHE3s0yiTfpMXU0eyUHI6AOB7Nnz0ZlZSXmz5/fY/n//d//YdGiRbjrrrvwzW9+E0Zjd+t+eXk5qqurUVRUhHXr1nnXLy4uRmlpKcrLy1FSUiLBbhDQ3d5gd7pxtJGBHiqxMTpMZ6/koGmEEEKKDS1ZsgTbt2/HRx99hJkzZ0IIgdGjR8Nms+H06dMwm79sgOvs7ERaWhri4uJQX18/4OqqzWaDxWKB1WpFYiLnJ/bniwYbGlouKF2Mftm7XLj7L1UAgN+vmA5jmD9byqDXYlZmMjsI9mGgx6hksW0wdHec0uu7/yi1tbVoaGjA3Llze4QOAJhMJixYsAAnT55EXV2dVEWg/5gwMgHDEtinREo6nQbTx7BXslQkCZ7jx4/jnXfewYgRIzB58mQA3cEDANnZ2T7f41nuWc8Xu90Om83W44f6p9FoMGmUhdOnSkSrBaaMsiDRxM9TKkEHT1dXF77//e/DbrejvLwcOl13ddlqtQIALBbfd1s81TDPer6UlZXBYrF4f9LT04MtrmrotN0Ti5s5x2/QckdaMJS9kiUVVPC43W7cfvvtqKysxB133IHvf//7UpULALB69WpYrVbvT319vaTbj3YG3X9GShvYEDpYlw1P4FM/QmDQp0MhBO644w68+OKL+N73voenn366x+uemo6/Go3nsslfjQgAjEaj9w4ZDY7JoMP0Mcn4+Oh5OF2S3EdQjYyhcRgzNE7pYkSlQZ0K3W43fvjDH+K5557DihUrsHnzZmgv6TrbXxtOf21AJJ14o569mwM0wmJCVip7JYdKwF9Ft9uN/Px8bNq0CbfccgteeOEFb7vOxbKzs5GWlobdu3f36ijY2dmJyspKpKWlISsra/ClpwFLNsdgEns3D0iyOQa5I9krOZQCCh5PTWfTpk341re+hRdffNFn6ADdd1by8/PR1taG0tLSHq+VlZWhubkZ+fn5/OPKKJW9m/vFXsnyCKiNp7S0FJs3b0Z8fDwuu+wyPPTQQ73WWbZsGaZNmwYAKCoqwuuvv47y8nJUVVVhxowZqKmpwbZt2zBt2jQUFRVJshM0cOlD4tDZ5cKxpg6lixJ2TIbuxwmxV3LoBRQ8R48eBQC0tbXh4Ycf9rlOZmamN3jMZjMqKipQUlKCLVu2oKKiAiNGjEBBQQGKi4t7dSwkeWSlxqOzy40ztk6lixI29DoNpo1JginMe09HC8mGTMiBQyak43YLVNU3o7m9S7EyhMuQCa0WmJ6ejGQ+Yjhosg+ZoMjifT67kWf43JEWho7MGDwqZtBpMT1d3c9nHzfMzA6CClDvN44A/Gf6VJX28RmZZMK4YeyrowQVft3oUpY4g+pmMEw2GzBhBNsJlcLgIQDdMxiOV0lP3bgYHaaMTmJfHQVx6HKE6XA4Q7bt4YlGNLXZccYqz212u9Pl89+hpNdpcNkIC7pcbnS53CH7PZy3p2/8dCJM7pq3lC5CSBT+7VOliyCpo48uVboIYY2XWkQkO9Z4IswXpUuULgJR0Bg8EYZtBxQNeKlFRLJj8BCR7Bg8RCQ7Bg8RyY7BQ0SyY/AQkewYPEQkOwYPEcmOwUNEsmPwEJHsGDxEJDsGDxHJjsFDRLKLqKHOnkeA2Ww2hUtCRL54js3+HtcXUcHT2toKAEhPT1e4JETUl9bWVlgs/h8gEFFPEnW73WhoaEBCQgI0Gvkn6rbZbEhPT0d9fT2fZCoRfqbSUvrzFEKgtbUVaWlp0PbxzKSIqvFotVqMHj1a6WIgMTGRB4nE+JlKS8nPs6+ajgcbl4lIdgweIpIdgycARqMRxcXFMBqNShclavAzlVakfJ4R1bhMRNGBNR4ikh2Dh4hkx+AhItkxeIhIdqoPno8++ghf+9rXkJycDLPZjNmzZ+Oll14KaBstLS1Ys2YNpkyZgoSEBKSkpGDWrFl46qmn0NnZGaKSh58XX3wRd955J2bOnAmj0QiNRoPNmzcHvB23242nnnoKU6ZMQWxsLIYNG4abb74ZtbW10hc6zEnxme7atQurVq3CjBkzMHToUJhMJlx++eX42c9+hpaWlpCUu19CxXbs2CFiYmJEfHy8yM/PF6tWrRJjx44VAMTDDz88oG00NzeLcePGCQBi3rx5YtWqVeKee+4R48ePFwDEtddeK1wuV4j3JDxkZGQIACIlJcX7702bNgW8nTvuuEMAELm5ueK///u/xa233iqMRqOwWCzi888/l77gYUyKz3T48OFCp9OJvLw8cf/994uCggIxffp0AUCMHz9enDlzJjSF74Nqg6erq0uMHz9eGI1GsWfPHu9ym80mJk6cKPR6vTh48GC/21m3bp0AIAoKCnost9vtYtasWQKA2Llzp+TlD0dvv/22OHr0qBBCiLKyskEdJO+9954AIObPny86Ozu9y9955x2h0WjEggULpCxy2JPiM3300UdFQ0NDj2Vut1vcddddAoD4yU9+IlVxB0y1l1rvvfceDh06hO985zuYPn26d3lCQgJ+9atfwel0YtOmTf1u5/DhwwCAr33taz2Wx8TEYPHixQCAs2fPSljy8PWVr3wFGRkZQW3jmWeeAQA89NBDPTrBLVq0CEuWLEFlZSUOHjwY1O+IJFJ8pj/72c8wcuTIHss0Gg1+9atfAQB27twZ1PYHQ7XBU1FRAQC47rrrer3mWTaQP8jEiRMBAP/85z97LO/q6sI777yD2NhYXHXVVUGWVj0qKipgNpsxd+7cXq8tWbIEgDIHSjQyGAwAAL1e/rHiETU6XUqehsrs7OxeryUnJyMlJWVAjZn5+fl44YUX8Nhjj+Hjjz/GrFmzYLfb8c9//hPNzc146aWXMGrUKMnLH43a29tx6tQpTJo0CTqdrtfrnr+VGhuZQ+G5554D4PvkG2qqDR6r1QrA/xD+xMREnDhxot/txMbGoqKiAnfeeSdefPFF79lYq9Xinnvuwbx586QrdJQbyN/k4vVo8Kqrq1FSUoLU1FQUFRXJ/vtVe6kllcbGRixevBjvv/8+3njjDbS0tOD06dN4+umnsWnTJsyZMwfNzc1KF5PI68iRI7jhhhvgcrnw17/+FSkpKbKXQbU1Hs9Z1d/Z02azDWhCo8LCQvzrX/9CTU0NpkyZ4t32HXfcAZfLhbvuugsbNmxASUmJdIWPUgP5m1y8HgXu2LFjWLhwIc6dO4e///3vWLhwoSLlUG2Np6/2gubmZjQ2Nvps/7nUG2+8gSFDhnhD52LXXnstAOCTTz4JsrTqYDabMXLkSBw5cgQul6vX6321y1H/jh49imuuuQYNDQ145ZVXcMMNNyhWFtUGT15eHgBg+/btvV7zLPOs0xeHwwGbzQaHw9HrtXPnzgFA2M+NEk7y8vLQ3t6O3bt393rtrbfe8q5DgfGEzsmTJ/Hyyy/jm9/8pqLlUW3wLFq0COPGjcNLL72E6upq7/LW1lb8+te/hl6vx8qVK73LGxsbsX//fjQ2NvbYzty5c+F0OvHrX/+6x3K73e5dplR1Npz5+zx/9KMfAQB++ctf9gjzd999F2+99RYWLFiAyy67TNayRgp/n+nFofPXv/4VN954o0Il/JKqJwLbsWMHlixZAqPRiBUrViAxMRGvvvoqjhw5goceegi/+MUvvOuuXbsWJSUlKC4uxtq1a73Lq6ursWDBArS2tmL27NmYO3cuOjs78dZbb+Hw4cOYMWMGdu3aBZPJpMAeymvjxo3YtWsXAOCzzz7Dnj17MHfuXGRlZQEAli1bhmXLlgHw/3kCwB133IGNGzciNzcXS5cuxZkzZ/Dyyy/DZDLhX//6F3Jzc+XcLUVJ8ZlmZmbi2LFjuPLKK719oS516d8g5GTvKx1mPvjgA/HVr35VWCwWERsbK2bOnClefPHFXusVFxcLAKK4uLjXawcPHhQ/+MEPxJgxY4TBYBCxsbFi8uTJoqSkRLS3t8uwF+HhtttuEwD8/lz82fX1ebpcLvG73/1OTJw4URiNRjF06FBx0003iQMHDsi3M2FCis+0r/d7fuSm6hoPESlDtW08RKQcBg8RyY7BQ0SyY/AQkewYPEQkOwYPEcmOwUNEsmPwEJHsGDxEJDsGDxHJjsFDRLJj8BCR7Bg8RCS7/wcqzs7vzCpFkgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -174,23 +177,24 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "#removal of healthy controls\n", "df_M0 = df_M0_all[df_M0_all.pathology != 'HC']\n", - "df_M12 = df_M12_all[df_M12_all.pathology != 'HC']" + "df_M12_3d = df_M12_3d_all[df_M12_3d_all.pathology != 'HC']\n", + "df_M12_2d = df_M12_2d_all[df_M12_2d_all.pathology != 'HC']" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 26, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -202,12 +206,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "+--------+--------+--------+\n", - "| EDSS | M0 | M12 |\n", - "+--------+--------+--------+\n", - "| Mean | 1.6627 | 1.6627 |\n", - "| Median | 1.5 | 1.5 |\n", - "+--------+--------+--------+\n" + "+--------+--------+--------+--------+\n", + "| EDSS | M0 | M12 3D | M12 2D |\n", + "+--------+--------+--------+--------+\n", + "| Mean | 1.6627 | 1.6627 | 1.6627 |\n", + "| Median | 1.5 | 1.5 | 1.5 |\n", + "+--------+--------+--------+--------+\n" ] } ], @@ -215,53 +219,61 @@ "#now we can plot the edss distribution \n", "plt.figure(figsize=(7, 5))\n", "plt.violinplot(df_M0.edss.dropna(), showmeans=True, positions=[1])\n", - "plt.violinplot(df_M12.edss.dropna(), showmeans=True, positions=[2])\n", - "plt.xlabel('M0 (left) and M12 (right)')\n", + "plt.violinplot(df_M12_3d.edss.dropna(), showmeans=True, positions=[2])\n", + "plt.violinplot(df_M12_2d.edss.dropna(), showmeans=True, positions=[3])\n", + "plt.xlabel('M0 (left), M12 3D nnUNet(middle) and M12 2D nnUnet(right)')\n", "plt.ylabel('EDSS score')\n", "plt.title('EDSS distribution')\n", "plt.show()\n", "\n", "#we print a table for comparison of the edss scores\n", "table = PrettyTable()\n", - "table.field_names = ['EDSS', 'M0', 'M12']\n", - "table.add_row(['Mean', round(df_M0.edss.dropna().mean(),4), round(df_M12.edss.dropna().mean(),4)])\n", - "table.add_row(['Median', round(df_M0.edss.dropna().median(),4), round(df_M12.edss.dropna().median(),4)])\n", + "table.field_names = ['EDSS', 'M0', 'M12 3D', 'M12 2D']\n", + "table.add_row(['Mean', round(df_M0.edss.dropna().mean(),4), round(df_M12_3d.edss.dropna().mean(),4), round(df_M12_2d.edss.dropna().mean(),4)])\n", + "table.add_row(['Median', round(df_M0.edss.dropna().median(),4), round(df_M12_3d.edss.dropna().median(),4), round(df_M12_2d.edss.dropna().median(),4)])\n", "print(table)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_60574/3800180276.py:2: SettingWithCopyWarning: \n", + "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_5585/3751552839.py:2: 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", " df_M0['timepoint'] = 'M0'\n", - "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_60574/3800180276.py:3: SettingWithCopyWarning: \n", + "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_5585/3751552839.py:3: 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", - " df_M12['timepoint'] = 'M12'\n" + " df_M12_3d['timepoint'] = 'M12'\n", + "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_5585/3751552839.py:4: 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", + " df_M12_2d['timepoint'] = 'M12'\n" ] } ], "source": [ "#we add the timepoint to the dataframe \n", "df_M0['timepoint'] = 'M0'\n", - "df_M12['timepoint'] = 'M12'" + "df_M12_3d['timepoint'] = 'M12'\n", + "df_M12_2d['timepoint'] = 'M12'" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -279,7 +291,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -290,7 +302,7 @@ ], "source": [ "# now we can concatenate the two dataframes\n", - "df_concat = pd.concat([df_M0, df_M12])\n", + "df_concat = pd.concat([df_M0, df_M12_3d])\n", "\n", "# now we can plot the phenotype distribution\n", "plt.figure(figsize=(5, 3))\n", @@ -302,7 +314,7 @@ "table.field_names = ['Phenotypes', 'M0', 'M12']\n", "for phenotype in np.unique(df_concat.phenotype): \n", " table.add_row([phenotype, str(len(df_M0[(df_M0.phenotype == phenotype)])) +\" (\"+ str(round(len(df_M0[(df_M0.phenotype == phenotype)])*100/len(df_M0.participant_id))) + \"%)\",\n", - " str(len(df_M12[(df_M12.phenotype == phenotype)]))+\" (\"+ str(round(len(df_M12[(df_M12.phenotype == phenotype)])*100/len(df_M0.participant_id))) + \"%)\"])\n", + " str(len(df_M12_3d[(df_M12_3d.phenotype == phenotype)]))+\" (\"+ str(round(len(df_M12_3d[(df_M12_3d.phenotype == phenotype)])*100/len(df_M0.participant_id))) + \"%)\"])\n", "print(table)" ] }, @@ -322,27 +334,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 9, + "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "+-------------------------------------------------+--------------------------+-------------------------+\n", - "| | M0 | M12 |\n", - "+-------------------------------------------------+--------------------------+-------------------------+\n", - "| Mean nb of lesions per patient (median | std) | 4.71 (3.0 | 4.33) | 3.49 (3.0 | 2.72) |\n", - "| Mean lesion volume (mm3) (median | std) | 360.47 (232.73 | 449.52) | 177.46 (97.84 | 238.77) |\n", - "| Mean biggest lesion volume (mm3) (median | std) | 157.41 (99.96 | 275.66) | 94.99 (52.92 | 144.37) |\n", - "+-------------------------------------------------+--------------------------+-------------------------+\n" + "+-------------------------------------------------+--------------------------+-------------------------+-------------------------+\n", + "| | M0 | M12 3D nnUNet | M12 2D nnUNet |\n", + "+-------------------------------------------------+--------------------------+-------------------------+-------------------------+\n", + "| Mean nb of lesions per patient (median | std) | 4.71 (3.0 | 4.33) | 3.49 (3.0 | 2.72) | 3.55 (3.0 | 3.16) |\n", + "| Mean lesion volume (mm3) (median | std) | 360.47 (232.73 | 449.52) | 177.46 (97.84 | 238.77) | 190.84 (88.79 | 263.25) |\n", + "| Mean biggest lesion volume (mm3) (median | std) | 157.41 (99.96 | 275.66) | 94.99 (52.92 | 144.37) | 94.58 (48.21 | 122.09) |\n", + "+-------------------------------------------------+--------------------------+-------------------------+-------------------------+\n" ] } ], @@ -351,25 +356,37 @@ "\n", "#we print a table with the average nb of lesion per patient, average lesion volume and average lesion volume per lesion\n", "table = PrettyTable()\n", - "table.field_names = ['', 'M0', 'M12']\n", + "table.field_names = ['', 'M0', 'M12 3D nnUNet', 'M12 2D nnUNet']\n", "table.add_row(['Mean nb of lesions per patient (median | std)', str(round(df_M0.number_of_lesions.mean(),2)) + \" (\" + str(round(df_M0.number_of_lesions.median(),2)) +\" | \"+ str(round(df_M0.number_of_lesions.std(),2)) + \")\",\n", - " str(round(df_M12.number_of_lesions.mean(),2)) + \" (\" + str(round(df_M12.number_of_lesions.median(),2)) +\" | \"+ str(round(df_M12.number_of_lesions.std(),2)) + \")\"])\n", + " str(round(df_M12_3d.number_of_lesions.mean(),2)) + \" (\" + str(round(df_M12_3d.number_of_lesions.median(),2)) +\" | \"+ str(round(df_M12_3d.number_of_lesions.std(),2)) + \")\",\n", + " str(round(df_M12_2d.number_of_lesions.mean(),2)) + \" (\" + str(round(df_M12_2d.number_of_lesions.median(),2)) +\" | \"+ str(round(df_M12_2d.number_of_lesions.std(),2)) + \")\"])\n", "table.add_row(['Mean lesion volume (mm3) (median | std)', str(round(df_M0.total_lesion_volume.mean(),2)) + \" (\" + str(round(df_M0.total_lesion_volume.median(),2)) +\" | \"+ str(round(df_M0.total_lesion_volume.std(),2)) + \")\",\n", - " str(round(df_M12.total_lesion_volume.mean(),2)) + \" (\" + str(round(df_M12.total_lesion_volume.median(),2)) +\" | \"+ str(round(df_M12.total_lesion_volume.std(),2)) + \")\"])\n", + " str(round(df_M12_3d.total_lesion_volume.mean(),2)) + \" (\" + str(round(df_M12_3d.total_lesion_volume.median(),2)) +\" | \"+ str(round(df_M12_3d.total_lesion_volume.std(),2)) + \")\",\n", + " str(round(df_M12_2d.total_lesion_volume.mean(),2)) + \" (\" + str(round(df_M12_2d.total_lesion_volume.median(),2)) +\" | \"+ str(round(df_M12_2d.total_lesion_volume.std(),2)) + \")\"])\n", "table.add_row(['Mean biggest lesion volume (mm3) (median | std)', str(round(df_M0.biggest_lesion_vol.mean(),2)) + \" (\" + str(round(df_M0.biggest_lesion_vol.median(),2)) +\" | \"+ str(round(df_M0.biggest_lesion_vol.std(),2)) + \")\",\n", - " str(round(df_M12.biggest_lesion_vol.mean(),2)) + \" (\" + str(round(df_M12.biggest_lesion_vol.median(),2)) +\" | \"+ str(round(df_M12.biggest_lesion_vol.std(),2)) + \")\"])\n", - "\n", + " str(round(df_M12_3d.biggest_lesion_vol.mean(),2)) + \" (\" + str(round(df_M12_3d.biggest_lesion_vol.median(),2)) +\" | \"+ str(round(df_M12_3d.biggest_lesion_vol.std(),2)) + \")\",\n", + " str(round(df_M12_2d.biggest_lesion_vol.mean(),2)) + \" (\" + str(round(df_M12_2d.biggest_lesion_vol.median(),2)) +\" | \"+ str(round(df_M12_2d.biggest_lesion_vol.std(),2)) + \")\"])\n", "print(table)" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 30, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAB90AAAHUCAYAAACXhzjlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABiiklEQVR4nO3deZhWdd0/8PfNNiwCCgjDKFuKKy65pKIGPCKEa5qpWSplZbkirmgqVoKaIrmnqbhkWo9LKr9IzC3DXUkxH7dALOGhRxEUkPX+/dHFXI5sM7eDM8O8Xtd1Xxf392yf8/kOWOc955xCsVgsBgAAAAAAAACosSZ1XQAAAAAAAAAANFRCdwAAAAAAAAAokdAdAAAAAAAAAEokdAcAAAAAAACAEgndAQAAAAAAAKBEQncAAAAAAAAAKJHQHQAAAAAAAABKJHQHAAAAAAAAgBIJ3QEAAAAAAACgREJ3AACAOjRu3LgUCoXKT8uWLVNeXp4BAwZk9OjRmTVr1grbjBw5MoVCoUbHmT9/fkaOHJnHHnusRtut7Fg9e/bMfvvtV6P9rMkdd9yRsWPHrnRZoVDIyJEja/V4te3Pf/5zdtppp7Rp0yaFQiH33XffStebNm1aCoVCxo0bt1bqWP7zNG3atLWyf2qmf//+6d+/f12XsVJr42elZ8+eKRQKqzznW2+9tfLfus/+WzRr1qwMHTo0nTp1SuvWrbPbbrvlz3/+c63VBgAAsDY1q+sCAAAASG6++eZsscUWWbx4cWbNmpUnn3wyF198cS699NLcddddGThwYOW63//+9/O1r32tRvufP39+LrjggiSpUQhYyrFKcccdd2TKlCkZNmzYCsueeuqpbLzxxmu9hlIVi8Uceuih2WyzzXL//fenTZs22Xzzzeukln333TdPPfVUunbtWifHp6prrrmmrktYpbX1s9K2bds88cQTefvtt7PJJptUWXbTTTelXbt2mTt3bpXxhQsXZq+99sqHH36YX/7yl+ncuXOuvvrqfO1rX8vDDz+cfv361WqNAAAAtU3oDgAAUA/06dMnO+20U+X3b3zjGznllFOyxx575OCDD86bb76ZLl26JEk23njjtR5Cz58/P61bt/5CjrUmu+66a50ef03ee++9fPDBBznooIOy11571WktG264YTbccMM6raGuLV68OIVCIc2aVe+Sx9KlS7NkyZKUlZXVei1bbbVVre+ztqytn5U99tgjr7zySm666aZceOGFleNvv/12nnjiiXz/+9/PDTfcUGWbG2+8MVOmTMmkSZOy2267JUkGDBiQ7bbbLmeccUaeeeaZWq8TAACgNnm8PAAAQD3VvXv3XHbZZfnoo4/yq1/9qnJ8ZY98f+SRR9K/f/907NgxrVq1Svfu3fONb3wj8+fPz7Rp0yrDtQsuuKDy8c5Dhw6tsr8XX3wxhxxySDbYYIPKO1RX9yj7e++9N9tuu21atmyZL33pS7niiiuqLF/V46sfe+yxKo+X7t+/f8aPH5933nmnyqP2l1vZ4+WnTJmSAw88MBtssEFatmyZ7bffPrfccstKj/Pb3/4255xzTioqKtKuXbsMHDgwr7/++qob/ylPPvlk9tprr7Rt2zatW7dO3759M378+MrlI0eOrPylhDPPPDOFQiE9e/as1r4/7c0338wRRxyRzp07p6ysLFtuuWWuvvrqKussW7YsP//5z7P55punVatWWX/99bPtttvml7/8ZeU6q+r5TTfdlO222y4tW7ZMhw4dctBBB+W1116rss7QoUOz3nrr5a233so+++yT9dZbL926dcupp56ahQsXVln32muvzXbbbZf11lsvbdu2zRZbbJGzzz57tee4/NH6l1xySS688MJ07949LVu2zE477bTSx4hXpyfL5/i2227Lqaeemo022ihlZWV566231ljDz3/+8/Tq1StlZWV59NFHkyTPP/98DjjggHTo0CEtW7bMl7/85fzud79bYT9PPvlkdtttt7Rs2TIbbbRRzj333Pz6179eofcre7z8Bx98kOOOOy4bbbRRWrRokS996Us555xzVuhxoVDICSeckNtuuy1bbrllWrdune222y4PPvhglfX+/e9/54c//GG6deuWsrKybLjhhtl9993z8MMPr3IukpX/rPTv3z99+vTJc889lz333DOtW7fOl770pVx00UVZtmzZave3XJMmTXLUUUfllltuqbLNTTfdlG7dulV5asdy9957bzbffPPKwD1JmjVrlu985zt59tln869//ataxwYAAKgrQncAAIB6bJ999knTpk3zxBNPrHKdadOmZd99902LFi1y0003ZcKECbnooovSpk2bLFq0KF27ds2ECROSJMccc0yeeuqpPPXUUzn33HOr7Ofggw/Opptumt///ve57rrrVlvX5MmTM2zYsJxyyim5995707dv35x88sm59NJLa3yO11xzTXbfffeUl5dX1vbUU0+tcv3XX389ffv2zauvvporrrgi99xzT7baaqsMHTo0l1xyyQrrn3322XnnnXfy61//Otdff33efPPN7L///lm6dOlq63r88cfzX//1X5kzZ05uvPHG/Pa3v03btm2z//7756677kryn8fv33PPPUmSE088MU899VTuvffeGp3/3//+9+y8886ZMmVKLrvssjz44IPZd999c9JJJ1W+EiBJLrnkkowcOTLf+ta3Mn78+Nx111055phj8uGHH652/6NHj84xxxyTrbfeOvfcc09++ctf5uWXX85uu+2WN998s8q6ixcvzgEHHJC99torf/jDH/K9730vl19+eS6++OLKde68884cd9xx6devX+69997cd999OeWUUzJv3rxqne9VV12VCRMmZOzYsbn99tvTpEmTDBkypMqcV7cny40YMSLTp0/PddddlwceeCCdO3debQ1XXHFFHnnkkVx66aX54x//mC222CKPPvpodt9993z44Ye57rrr8oc//CHbb799DjvssIwbN65y25dffjl777135s+fn1tuuSXXXXddXnzxxSp3da/KJ598kgEDBuTWW2/N8OHDM378+HznO9/JJZdckoMPPniF9cePH5+rrroqP/3pT3P33XdX/sLEP/7xj8p1jjzyyNx3330577zz8tBDD+XXv/51Bg4cmPfff3+N9azMzJkz8+1vfzvf+c53cv/992fIkCEZMWJEbr/99mrv43vf+17ee++9/OlPf0ryn6cJ3HLLLRk6dGiaNFnxUtSUKVOy7bbbrjC+fOzVV18t6VwAAAC+MEUAAADqzM0331xMUnzuuedWuU6XLl2KW265ZeX3888/v/jp/zv33//938UkxcmTJ69yH//+97+LSYrnn3/+CsuW7++8885b5bJP69GjR7FQKKxwvL333rvYrl274rx586qc29SpU6us9+ijjxaTFB999NHKsX333bfYo0ePldb+2boPP/zwYllZWXH69OlV1hsyZEixdevWxQ8//LDKcfbZZ58q6/3ud78rJik+9dRTKz3ecrvuumuxc+fOxY8++qhybMmSJcU+ffoUN9544+KyZcuKxWKxOHXq1GKS4i9+8YvV7u/T6958882VY4MHDy5uvPHGxTlz5lRZ94QTTii2bNmy+MEHHxSLxWJxv/32K26//far3f9nez579uxiq1atVujB9OnTi2VlZcUjjjiicuzoo48uJin+7ne/q7LuPvvsU9x8882r1LX++uuv8Vw/a/m5V1RUFBcsWFA5Pnfu3GKHDh2KAwcOrByrbk+Wz/FXv/rVGtWwySabFBctWlRl2RZbbFH88pe/XFy8eHGV8f3226/YtWvX4tKlS4vFYrH4zW9+s9imTZviv//978p1li5dWtxqq61W+Hnv169fsV+/fpXfr7vuupX2+OKLLy4mKT700EOVY0mKXbp0Kc6dO7dybObMmcUmTZoUR48eXTm23nrrFYcNG1at8/+0lf397NevXzFJ8Zlnnqmy7lZbbVUcPHjwGvfZo0eP4r777lu5r0MOOaRYLBaL48ePLxYKheLUqVOLv//971f4+9+8efPiscceu8L+Jk2aVExSvOOOO2p8fgAAAF8kd7oDAADUc8VicbXLt99++7Ro0SI//OEPc8stt1S5C7YmvvGNb1R73a233jrbbbddlbEjjjgic+fOzYsvvljS8avrkUceyV577ZVu3bpVGR86dGjmz5+/wl3yBxxwQJXvy++efeedd1Z5jHnz5uWZZ57JIYcckvXWW69yvGnTpjnyyCPzz3/+s9qPqF+dTz75JH/+859z0EEHpXXr1lmyZEnlZ5999sknn3ySp59+Oknyla98JX/7299y3HHH5U9/+lPmzp27xv0/9dRTWbBgQeWrBJbr1q1b/uu//muFx7oXCoXsv//+Vca23XbbKr36yle+kg8//DDf+ta38oc//CH/93//V6NzPvjgg9OyZcvK78ufHvDEE09k6dKlNerJcjX52U3+8zPRvHnzyu9vvfVW/ud//iff/va3k2SFY86YMaNyvpc/AaFTp06V2zdp0iSHHnroGo/7yCOPpE2bNjnkkEOqjC+fn8/Ox4ABA9K2bdvK7126dEnnzp1XmI9x48bl5z//eZ5++uksXry4ml1YufLy8nzlK1+pMvbZn4Hq+N73vpf7778/77//fm688cYMGDBgta9eWNVrLNa0DAAAoD4QugMAANRj8+bNy/vvv5+KiopVrrPJJpvk4YcfTufOnXP88cdnk002ySabbFLlXd/V0bVr12qvW15evsqxUh9rXV3vv//+Smtd3qPPHr9jx45VvpeVlSVJFixYsMpjzJ49O8VisUbHKcX777+fJUuW5Morr0zz5s2rfPbZZ58kqQy1R4wYkUsvvTRPP/10hgwZko4dO2avvfbK888/v9r9Jyuf24qKihXOoXXr1lUC8eQ//frkk08qvx955JG56aab8s477+Qb3/hGOnfunF122SUTJ06s1jmv6mdn0aJF+fjjj2vUk+Vq8rO7svX/93//N0ly2mmnrXDM4447rsox33///XTp0mWFfa5s7LPef//9lJeXrxAid+7cOc2aNVvjz27yn/n49M/uXXfdlaOPPjq//vWvs9tuu6VDhw456qijMnPmzDXWszLVOWZ1HHLIIWnZsmUuv/zyPPDAAznmmGNWe8yV/X364IMPkiQdOnSo0bEBAAC+aM3qugAAAABWbfz48Vm6dGn69++/2vX23HPP7Lnnnlm6dGmef/75XHnllRk2bFi6dOmSww8/vFrHqsndpCsL9JaPLQ/tloe3CxcurLJeTe+M/qyOHTtmxowZK4y/9957SVLlDuRSbbDBBmnSpMkXcpzld88ff/zxK12nV69eSZJmzZpl+PDhGT58eD788MM8/PDDOfvsszN48OC8++67ad269QrbLp+LVZ1Hqefw3e9+N9/97nczb968PPHEEzn//POz33775Y033kiPHj1Wu+2qfnZatGiR9dZbL82bN692T5ar6Z3Qn11/eR9GjBix0nerJ8nmm2+e5D89XR7Sf/Yc1qRjx4555plnUiwWq9Qwa9asLFmypKT56NSpU8aOHZuxY8dm+vTpuf/++3PWWWdl1qxZmTBhQo33V1tat26dww8/PKNHj067du1W2dck2WabbfLKK6+sML58rE+fPmutTgAAgNrgTncAAIB6avr06TnttNPSvn37HHvssdXapmnTptlll11y9dVXJ0nlo96rc3d3Tbz66qv529/+VmXsjjvuSNu2bbPDDjskSeWjpF9++eUq691///0r7K8md9LutddeeeSRRyrD7+VuvfXWtG7dOrvuumt1T2OV2rRpk1122SX33HNPlbqWLVuW22+/PRtvvHE222yzz32c1q1bZ8CAAXnppZey7bbbZqeddlrhs7I7j9dff/0ccsghOf744/PBBx9k2rRpK93/brvtllatWuX222+vMv7Pf/6z8jH9n0ebNm0yZMiQnHPOOVm0aFFeffXVNW5zzz33VLlz/qOPPsoDDzyQPffcM02bNi25J5/H5ptvnt69e+dvf/vbSo+30047VT7mvV+/fnnkkUeq/PLIsmXL8vvf/36Nx9lrr73y8ccf57777qsyfuutt1Yu/zy6d++eE044IXvvvfdaf81Ddfz4xz/O/vvvn/POO2+FJyh82kEHHZT/+Z//yTPPPFM5tmTJktx+++3ZZZddVvukDwAAgPrAne4AAAD1wJQpUyrfIT1r1qz85S9/yc0335ymTZvm3nvvzYYbbrjKba+77ro88sgj2XfffdO9e/d88sknuemmm5IkAwcOTPKf92b36NEjf/jDH7LXXnulQ4cO6dSp02rfsbw6FRUVOeCAAzJy5Mh07do1t99+eyZOnJiLL7648o7rnXfeOZtvvnlOO+20LFmyJBtssEHuvffePPnkkyvsb5tttsk999yTa6+9NjvuuGOaNGmSnXbaaaXHPv/88/Pggw9mwIABOe+889KhQ4f85je/yfjx43PJJZekffv2JZ3TZ40ePTp77713BgwYkNNOOy0tWrTINddckylTpuS3v/1trb1n+pe//GX22GOP7Lnnnvnxj3+cnj175qOPPspbb72VBx54II888kiSZP/990+fPn2y0047ZcMNN8w777yTsWPHpkePHundu/dK973++uvn3HPPzdlnn52jjjoq3/rWt/L+++/nggsuSMuWLXP++efXuN4f/OAHadWqVXbfffd07do1M2fOzOjRo9O+ffvsvPPOa9y+adOm2XvvvTN8+PAsW7YsF198cebOnZsLLrigxj2pTb/61a8yZMiQDB48OEOHDs1GG22UDz74IK+99lpefPHFylD9nHPOyQMPPJC99tor55xzTlq1apXrrrsu8+bNS/Kf97uvylFHHZWrr746Rx99dKZNm5ZtttkmTz75ZEaNGpV99tmn8u9rdc2ZMycDBgzIEUcckS222CJt27bNc889lwkTJqz2zvIvyvbbb7/CLxiszPe+971cffXV+eY3v5mLLroonTt3zjXXXJPXX389Dz/88NovFAAA4HMSugMAANQD3/3ud5MkLVq0yPrrr58tt9wyZ555Zr7//e+vNnBP/hNsPfTQQzn//PMzc+bMrLfeeunTp0/uv//+DBo0qHK9G2+8MaeffnoOOOCALFy4MEcffXTGjRtXUr3bb799vvvd7+b888/Pm2++mYqKiowZMyannHJK5TpNmzbNAw88kBNOOCE/+tGPUlZWlsMPPzxXXXVV9t133yr7O/nkk/Pqq6/m7LPPzpw5c1IsFlMsFld67M033zyTJk3K2WefneOPPz4LFizIlltumZtvvjlDhw4t6XxWZvkdzeeff36GDh2aZcuWZbvttsv999+f/fbbr9aOs9VWW+XFF1/Mz372s/zkJz/JrFmzsv7666d3796V7zBPkgEDBuTuu+/Or3/968ydOzfl5eXZe++9c+6556Z58+ar3P+IESPSuXPnXHHFFbnrrrvSqlWr9O/fP6NGjVplWL86e+65Z8aNG5ff/e53mT17djp16pQ99tgjt9566xp/VpPkhBNOyCeffJKTTjops2bNytZbb53x48dn9913r3FPatOAAQPy7LPP5sILL8ywYcMye/bsdOzYMVtttVUOPfTQyvW22267TJw4MaeddlqOOuqobLDBBjnyyCPTr1+/nHnmmav9pY+WLVvm0UcfzTnnnJNf/OIX+fe//52NNtoop512Wkm/ANGyZcvssssuue222zJt2rQsXrw43bt3z5lnnpkzzjijpD7UhbKysvz5z3/OGWeckRNPPDHz58/P9ttvnz/+8Y/p169fXZcHAACwRoXiqq5iAAAAANSSadOmpVevXvnFL36R0047ra7LqXWDBg3KtGnT8sYbb9R1KQAAAHzB3OkOAAAAUAPDhw/Pl7/85XTr1i0ffPBBfvOb32TixIm58cYb67o0AAAA6oDQHQAAAKAGli5dmvPOOy8zZ85MoVDIVlttldtuuy3f+c536ro0AAAA6oDHywMAAAAAAABAiZrUdQEAAAAAAAAA0FAJ3QEAAAAAAACgREJ3AAAAAAAAAChRs7ouoD5YtmxZ3nvvvbRt2zaFQqGuywEAAAAAAACgDhWLxXz00UepqKhIkyarv5dd6J7kvffeS7du3eq6DAAAAAAAAADqkXfffTcbb7zxatcRuidp27Ztkv80rF27dnVcDQAAAAAAAAB1ae7cuenWrVtllrw6Qvek8pHy7dq1E7oDAAAAAAAAkCTVej356h8+DwAAAAAAAACsktAdAAAAAAAAAEokdAcAAAAAAACAEgndAQAAAAAAAKBEQncAAAAAAAAAKJHQHQAAAAAAAABKJHQHAAAAAAAAgBIJ3QEAAAAAAACgREJ3AAAAAAAAACiR0B0AAAAAAAAASiR0BwAAAAAAAIASCd0BAAAAAAAAoERCdwAAAAAAAAAokdAdAAAAAAAAAEokdAcAAAAAAACAEjWr6wKAdV/Ps8bXdQmsxLSL9q3rEgAAAAAAABo8d7oDAAAAAAAAQImE7gAAAAAAAABQojoN3Z944onsv//+qaioSKFQyH333bfCOq+99loOOOCAtG/fPm3bts2uu+6a6dOnVy5fuHBhTjzxxHTq1Clt2rTJAQcckH/+859f4FkAAAAAAAAA0FjVaeg+b968bLfddrnqqqtWuvztt9/OHnvskS222CKPPfZY/va3v+Xcc89Ny5YtK9cZNmxY7r333tx555158skn8/HHH2e//fbL0qVLv6jTAAAAAAAAAKCRalaXBx8yZEiGDBmyyuXnnHNO9tlnn1xyySWVY1/60pcq/zxnzpzceOONue222zJw4MAkye23355u3brl4YcfzuDBg9de8QAAAAAAAAA0evX2ne7Lli3L+PHjs9lmm2Xw4MHp3LlzdtlllyqPoH/hhReyePHiDBo0qHKsoqIiffr0yaRJk1a574ULF2bu3LlVPgAAAAAAAABQU/U2dJ81a1Y+/vjjXHTRRfna176Whx56KAcddFAOPvjgPP7440mSmTNnpkWLFtlggw2qbNulS5fMnDlzlfsePXp02rdvX/np1q3bWj0XAAAAAAAAANZN9TZ0X7ZsWZLkwAMPzCmnnJLtt98+Z511Vvbbb79cd911q922WCymUCiscvmIESMyZ86cys+7775bq7UDAAAAAAAA0DjU29C9U6dOadasWbbaaqsq41tuuWWmT5+eJCkvL8+iRYsye/bsKuvMmjUrXbp0WeW+y8rK0q5duyofAAAAAAAAAKipehu6t2jRIjvvvHNef/31KuNvvPFGevTokSTZcccd07x580ycOLFy+YwZMzJlypT07dv3C60XAAAAAAAAgManWV0e/OOPP85bb71V+X3q1KmZPHlyOnTokO7du+f000/PYYcdlq9+9asZMGBAJkyYkAceeCCPPfZYkqR9+/Y55phjcuqpp6Zjx47p0KFDTjvttGyzzTYZOHBgHZ0VAAAAAAAAAI1FnYbuzz//fAYMGFD5ffjw4UmSo48+OuPGjctBBx2U6667LqNHj85JJ52UzTffPHfffXf22GOPym0uv/zyNGvWLIceemgWLFiQvfbaK+PGjUvTpk2/8PMBAAAAAAAAoHEpFIvFYl0XUdfmzp2b9u3bZ86cOd7vDmtBz7PG13UJrMS0i/at6xIAAAAAAADqpZpkyPX2ne4AAAAAAAAAUN8J3QEAAAAAAACgREJ3AAAAAAAAACiR0B0AAAAAAAAASiR0BwAAAAAAAIASCd0BAAAAAAAAoERCdwAAAAAAAAAokdAdAAAAAAAAAEokdAcAAAAAAACAEgndAQAAAAAAAKBEQncAAAAAAAAAKJHQHQAAAAAAAABKJHQHAAAAAAAAgBIJ3QEAAAAAAACgREJ3AAAAAAAAACiR0B0AAAAAAAAASiR0BwAAAAAAAIASCd0BAAAAAAAAoERCdwAAAAAAAAAokdAdAAAAAAAAAEokdAcAAAAAAACAEgndAQAAAAAAAKBEQncAAAAAAAAAKJHQHQAAAAAAAABKJHQHAAAAAAAAgBIJ3QEAAAAAAACgREJ3AAAAAAAAACiR0B0AAAAAAAAASiR0BwAAAAAAAIASCd0BAAAAAAAAoERCdwAAAAAAAAAokdAdAAAAAAAAAEokdAcAAAAAAACAEgndAQAAAAAAAKBEdRq6P/HEE9l///1TUVGRQqGQ++67b5XrHnvssSkUChk7dmyV8YULF+bEE09Mp06d0qZNmxxwwAH55z//uXYLBwAAAAAAAIDUceg+b968bLfddrnqqqtWu959992XZ555JhUVFSssGzZsWO69997ceeedefLJJ/Pxxx9nv/32y9KlS9dW2QAAAAAAAACQJGlWlwcfMmRIhgwZstp1/vWvf+WEE07In/70p+y7775Vls2ZMyc33nhjbrvttgwcODBJcvvtt6dbt255+OGHM3jw4LVWOwAAAAAAAADU63e6L1u2LEceeWROP/30bL311issf+GFF7J48eIMGjSocqyioiJ9+vTJpEmTVrnfhQsXZu7cuVU+AAAAAAAAAFBT9Tp0v/jii9OsWbOcdNJJK10+c+bMtGjRIhtssEGV8S5dumTmzJmr3O/o0aPTvn37yk+3bt1qtW4AAAAAAAAAGod6G7q/8MIL+eUvf5lx48alUCjUaNtisbjabUaMGJE5c+ZUft59993PWy4AAAAAAAAAjVC9Dd3/8pe/ZNasWenevXuaNWuWZs2a5Z133smpp56anj17JknKy8uzaNGizJ49u8q2s2bNSpcuXVa577KysrRr167KBwAAAAAAAABqqt6G7kceeWRefvnlTJ48ufJTUVGR008/PX/605+SJDvuuGOaN2+eiRMnVm43Y8aMTJkyJX379q2r0gEAAAAAAABoJJrV5cE//vjjvPXWW5Xfp06dmsmTJ6dDhw7p3r17OnbsWGX95s2bp7y8PJtvvnmSpH379jnmmGNy6qmnpmPHjunQoUNOO+20bLPNNhk4cOAXei4AAAAAAAAAND51Gro///zzGTBgQOX34cOHJ0mOPvrojBs3rlr7uPzyy9OsWbMceuihWbBgQfbaa6+MGzcuTZs2XRslAwAAAAAAAEClQrFYLNZ1EXVt7ty5ad++febMmeP97rAW9DxrfF2XwEpMu2jfui4BAAAAAACgXqpJhlxv3+kOAAAAAAAAAPWd0B0AAAAAAAAASiR0BwAAAAAAAIASCd0BAAAAAAAAoERCdwAAAAAAAAAokdAdAAAAAAAAAEokdAcAAAAAAACAEgndAQAAAAAAAKBEQncAAAAAAAAAKJHQHQAAAAAAAABKJHQHAAAAAAAAgBI1q+sCAIB1U8+zxtd1CazEtIv2resSAAAAAADWKe50BwAAAAAAAIASCd0BAAAAAAAAoERCdwAAAAAAAAAokdAdAAAAAAAAAEokdAcAAAAAAACAEgndAQAAAAAAAKBEQncAAAAAAAAAKJHQHQAAAAAAAABK1KyuCwAAYN3T86zxdV0CKzHton3rugQAAAAAWOe40x0AAAAAAAAASiR0BwAAAAAAAIASCd0BAAAAAAAAoERCdwAAAAAAAAAokdAdAAAAAAAAAEokdAcAAAAAAACAEgndAQAAAAAAAKBEQncAAAAAAAAAKJHQHQAAAAAAAABKJHQHAAAAAAAAgBIJ3QEAAAAAAACgREJ3AAAAAAAAACiR0B0AAAAAAAAASlSnofsTTzyR/fffPxUVFSkUCrnvvvsqly1evDhnnnlmttlmm7Rp0yYVFRU56qij8t5771XZx8KFC3PiiSemU6dOadOmTQ444ID885///ILPBAAAAAAAAIDGqE5D93nz5mW77bbLVVddtcKy+fPn58UXX8y5556bF198Mffcc0/eeOONHHDAAVXWGzZsWO69997ceeedefLJJ/Pxxx9nv/32y9KlS7+o0wAAAAAAAACgkWpWlwcfMmRIhgwZstJl7du3z8SJE6uMXXnllfnKV76S6dOnp3v37pkzZ05uvPHG3HbbbRk4cGCS5Pbbb0+3bt3y8MMPZ/DgwWv9HAAAAAAAAABovBrUO93nzJmTQqGQ9ddfP0nywgsvZPHixRk0aFDlOhUVFenTp08mTZq0yv0sXLgwc+fOrfIBAAAAAAAAgJpqMKH7J598krPOOitHHHFE2rVrlySZOXNmWrRokQ022KDKul26dMnMmTNXua/Ro0enffv2lZ9u3bqt1doBAAAAAAAAWDc1iNB98eLFOfzww7Ns2bJcc801a1y/WCymUCiscvmIESMyZ86cys+7775bm+UCAAAAAAAA0EjU6Tvdq2Px4sU59NBDM3Xq1DzyyCOVd7knSXl5eRYtWpTZs2dXudt91qxZ6du37yr3WVZWlrKysrVaNwAAQGPT86zxdV0CKzHton3rugQAAABYp9XrO92XB+5vvvlmHn744XTs2LHK8h133DHNmzfPxIkTK8dmzJiRKVOmrDZ0BwAAAAAAAIDaUKd3un/88cd56623Kr9PnTo1kydPTocOHVJRUZFDDjkkL774Yh588MEsXbq08j3tHTp0SIsWLdK+ffscc8wxOfXUU9OxY8d06NAhp512WrbZZpsMHDiwrk4LAAAaLXc610/udAYAAABYe+o0dH/++eczYMCAyu/Dhw9Pkhx99NEZOXJk7r///iTJ9ttvX2W7Rx99NP3790+SXH755WnWrFkOPfTQLFiwIHvttVfGjRuXpk2bfiHnAAAAAAAAAEDjVaehe//+/VMsFle5fHXLlmvZsmWuvPLKXHnllbVZGgAAAAAAAACsUb1+pzsAAAAAAAAA1GdCdwAAAAAAAAAokdAdAAAAAAAAAEokdAcAAAAAAACAEgndAQAAAAAAAKBEQncAAAAAAAAAKFGzui4AAAAAaNh6njW+rktgFaZdtG9dlwAAALDOc6c7AAAAAAAAAJRI6A4AAAAAAAAAJaqV0P3DDz+sjd0AAAAAAAAAQINS49D94osvzl133VX5/dBDD03Hjh2z0UYb5W9/+1utFgcAAAAAAAAA9VmNQ/df/epX6datW5Jk4sSJmThxYv74xz9myJAhOf3002u9QAAAAAAAAACor5rVdIMZM2ZUhu4PPvhgDj300AwaNCg9e/bMLrvsUusFAgAAAAAAAEB9VeM73TfYYIO8++67SZIJEyZk4MCBSZJisZilS5fWbnUAAAAAAAAAUI/V+E73gw8+OEcccUR69+6d999/P0OGDEmSTJ48OZtuummtFwgAAAAAAAAA9VWNQ/fLL788PXv2zLvvvptLLrkk6623XpL/PHb+uOOOq/UCAQAAAAAAAKC+qnHo3rx585x22mkrjA8bNqw26gEAAAAAAACABqPGoXuSvPHGG3nssccya9asLFu2rMqy8847r1YKAwAAAAAAAID6rsah+w033JAf//jH6dSpU8rLy1MoFCqXFQoFoTsAAAAAAAAAjUaNQ/ef//znufDCC3PmmWeujXoAAAAAAAAAoMFoUtMNZs+enW9+85troxYAAAAAAAAAaFBqHLp/85vfzEMPPbQ2agEAAAAAAACABqXGj5ffdNNNc+655+bpp5/ONttsk+bNm1dZftJJJ9VacQAAAAAAAABQn9U4dL/++uuz3nrr5fHHH8/jjz9eZVmhUBC6AwAAAAAAANBo1Dh0nzp16tqoAwAAAAAAAAAanBq/0/3TisViisVibdUCAAAAAAAAAA1KSaH7rbfemm222SatWrVKq1atsu222+a2226r7doAAAAAAAAAoF6r8ePlx4wZk3PPPTcnnHBCdt999xSLxfz1r3/Nj370o/zf//1fTjnllLVRJwAAAAAAAADUOzUO3a+88spce+21OeqooyrHDjzwwGy99dYZOXKk0B0AAAAAAACARqPGj5efMWNG+vbtu8J43759M2PGjFopCgAAAAAAAAAaghqH7ptuuml+97vfrTB+1113pXfv3rVSFAAAAAAAAAA0BDV+vPwFF1yQww47LE888UR23333FAqFPPnkk/nzn/+80jAeAAAAAAAAANZVNb7T/Rvf+EaeeeaZdOrUKffdd1/uueeedOrUKc8++2wOOuigtVEjAAAAAAAAANRLNb7TPUl23HHH3H777bVdCwDrmJ5nja/rEliJaRftW9clAAAAAADAOqNad7rPnTu3yp9X96mJJ554Ivvvv38qKipSKBRy3333VVleLBYzcuTIVFRUpFWrVunfv39effXVKussXLgwJ554Yjp16pQ2bdrkgAMOyD//+c8a1QEAAAAAAAAApajWne4bbLBBZsyYkc6dO2f99ddPoVBYYZ1isZhCoZClS5dW++Dz5s3Ldtttl+9+97v5xje+scLySy65JGPGjMm4ceOy2Wab5ec//3n23nvvvP7662nbtm2SZNiwYXnggQdy5513pmPHjjn11FOz33775YUXXkjTpk2rXQsAAAAANecJV/WTJ1wBAMAXp1qh+yOPPJIOHTokSR599NFaO/iQIUMyZMiQlS4rFosZO3ZszjnnnBx88MFJkltuuSVdunTJHXfckWOPPTZz5szJjTfemNtuuy0DBw5Mktx+++3p1q1bHn744QwePLjWagUAAAAAAACAz6pW6N6vX7+V/nltmjp1ambOnJlBgwZVjpWVlaVfv36ZNGlSjj322LzwwgtZvHhxlXUqKirSp0+fTJo0aZWh+8KFC7Nw4cLK7zV9LD4AAAAAAAAAJNV8p/unTZgwIU8++WTl96uvvjrbb799jjjiiMyePbvWCps5c2aSpEuXLlXGu3TpUrls5syZadGiRTbYYINVrrMyo0ePTvv27Ss/3bp1q7W6AQAAAAAAAGg8ahy6n3766ZV3hr/yyisZPnx49tlnn/zjH//I8OHDa73Az74/fvm741dnTeuMGDEic+bMqfy8++67tVIrAAAAAAAAAI1LtR4v/2lTp07NVlttlSS5++67s//++2fUqFF58cUXs88++9RaYeXl5Un+czd7165dK8dnzZpVefd7eXl5Fi1alNmzZ1e5233WrFnp27fvKvddVlaWsrKyWqsVAAAAAAAAgMapxne6t2jRIvPnz0+SPPzww5XvU+/QoUOtvhu9V69eKS8vz8SJEyvHFi1alMcff7wyUN9xxx3TvHnzKuvMmDEjU6ZMWW3oDgAAAAAAAAC1ocZ3uu+xxx4ZPnx4dt999zz77LO56667kiRvvPFGNt544xrt6+OPP85bb71V+X3q1KmZPHlyOnTokO7du2fYsGEZNWpUevfund69e2fUqFFp3bp1jjjiiCRJ+/btc8wxx+TUU09Nx44d06FDh5x22mnZZpttMnDgwJqeGgAAAAAAAADUSI1D96uuuirHHXdc/vu//zvXXnttNtpooyTJH//4x3zta1+r0b6ef/75DBgwoPL78nfCH3300Rk3blzOOOOMLFiwIMcdd1xmz56dXXbZJQ899FDatm1buc3ll1+eZs2a5dBDD82CBQuy1157Zdy4cWnatGlNTw0AAAAAAAAAaqTGoXv37t3z4IMPrjB++eWX1/jg/fv3T7FYXOXyQqGQkSNHZuTIkatcp2XLlrnyyitz5ZVX1vj4AAAAAAAAAPB51Pid7kny9ttv5yc/+Um+9a1vZdasWUmSCRMm5NVXX63V4gAAAAAAAACgPqtx6P74449nm222yTPPPJN77rknH3/8cZLk5Zdfzvnnn1/rBQIAAAAAAABAfVXj0P2ss87Kz3/+80ycODEtWrSoHB8wYECeeuqpWi0OAAAAAAAAAOqzGofur7zySg466KAVxjfccMO8//77tVIUAAAAAAAAADQENQ7d119//cyYMWOF8ZdeeikbbbRRrRQFAAAAAAAAAA1BjUP3I444ImeeeWZmzpyZQqGQZcuW5a9//WtOO+20HHXUUWujRgAAAAAAAACol2ocul944YXp3r17Ntpoo3z88cfZaqut8tWvfjV9+/bNT37yk7VRIwAAAAAAAADUS81qukHz5s3zm9/8Jj/96U/z0ksvZdmyZfnyl7+c3r17r436AAAAAAAAAKDeqnHovtwmm2ySTTbZpDZrAQAAAAAAAIAGpVqh+/Dhw6u9wzFjxpRcDAAAAAAAAAA0JNUK3V966aVq7axQKHyuYgAAAAAAAACgIalW6P7oo4+u7ToAAAAAAAAAoMFpUtcFAAAAAAAAAEBDJXQHAAAAAAAAgBIJ3QEAAAAAAACgREJ3AAAAAAAAAChRtUL3HXbYIbNnz06S/PSnP838+fPXalEAAAAAAAAA0BBUK3R/7bXXMm/evCTJBRdckI8//nitFgUAAAAAAAAADUGz6qy0/fbb57vf/W722GOPFIvFXHrppVlvvfVWuu55551XqwUCAAAAAAAAQH1VrdB93LhxOf/88/Pggw+mUCjkj3/8Y5o1W3HTQqEgdAcAAAAAAACg0ahW6L755pvnzjvvTJI0adIkf/7zn9O5c+e1WhgAAAAAAAAA1HfVCt0/bdmyZWujDgAAAAAAAABocGocuifJ22+/nbFjx+a1115LoVDIlltumZNPPjmbbLJJbdcHAAAAAAAAAPVWk5pu8Kc//SlbbbVVnn322Wy77bbp06dPnnnmmWy99daZOHHi2qgRAAAAAAAAAOqlGt/pftZZZ+WUU07JRRddtML4mWeemb333rvWigMAAAAAAACA+qzGd7q/9tprOeaYY1YY/973vpe///3vtVIUAAAAAAAAADQENQ7dN9xww0yePHmF8cmTJ6dz5861URMAAAAAAAAANAg1frz8D37wg/zwhz/MP/7xj/Tt2zeFQiFPPvlkLr744px66qlro0YAAAAAAAAAqJdqHLqfe+65adu2bS677LKMGDEiSVJRUZGRI0fmpJNOqvUCAQAAAAAAAKC+qnHoXigUcsopp+SUU07JRx99lCRp27ZtrRcGAAAAAAAAAPVdjUP3TxO2AwAAAAAAANCYNanrAgAAAAAAAACgoRK6AwAAAAAAAECJPtfj5aG6ep41vq5LYCWmXbRvXZcAAAAAAAAADVqN7nRfvHhxBgwYkDfeeGNt1VPFkiVL8pOf/CS9evVKq1at8qUvfSk//elPs2zZssp1isViRo4cmYqKirRq1Sr9+/fPq6+++oXUBwAAAAAAAEDjVqPQvXnz5pkyZUoKhcLaqqeKiy++ONddd12uuuqqvPbaa7nkkkvyi1/8IldeeWXlOpdccknGjBmTq666Ks8991zKy8uz995756OPPvpCagQAAAAAAACg8arxO92POuqo3HjjjWujlhU89dRTOfDAA7PvvvumZ8+eOeSQQzJo0KA8//zzSf5zl/vYsWNzzjnn5OCDD06fPn1yyy23ZP78+bnjjju+kBoBAAAAAAAAaLxq/E73RYsW5de//nUmTpyYnXbaKW3atKmyfMyYMbVW3B577JHrrrsub7zxRjbbbLP87W9/y5NPPpmxY8cmSaZOnZqZM2dm0KBBlduUlZWlX79+mTRpUo499tiV7nfhwoVZuHBh5fe5c+fWWs0AAAAAAAAANB41Dt2nTJmSHXbYIUlWeLd7bT92/swzz8ycOXOyxRZbpGnTplm6dGkuvPDCfOtb30qSzJw5M0nSpUuXKtt16dIl77zzzir3O3r06FxwwQW1WisAAAAAAAAAjU+NQ/dHH310bdSxUnfddVduv/323HHHHdl6660zefLkDBs2LBUVFTn66KMr1/ts2F8sFlf7CwAjRozI8OHDK7/PnTs33bp1q/0TAAAAAAAAAGCdVuPQfbm33norb7/9dr761a+mVatWawy6S3H66afnrLPOyuGHH54k2WabbfLOO+9k9OjROfroo1NeXp7kP3e8d+3atXK7WbNmrXD3+6eVlZWlrKysVmsFAAAAAAAAoPFpUtMN3n///ey1117ZbLPNss8++2TGjBlJku9///s59dRTa7W4+fPnp0mTqiU2bdo0y5YtS5L06tUr5eXlmThxYuXyRYsW5fHHH0/fvn1rtRYAAAAAAAAA+Kwah+6nnHJKmjdvnunTp6d169aV44cddlgmTJhQq8Xtv//+ufDCCzN+/PhMmzYt9957b8aMGZODDjooyX8eKz9s2LCMGjUq9957b6ZMmZKhQ4emdevWOeKII2q1FgAAAAAAAAD4rBo/Xv6hhx7Kn/70p2y88cZVxnv37p133nmn1gpLkiuvvDLnnntujjvuuMyaNSsVFRU59thjc95551Wuc8YZZ2TBggU57rjjMnv27Oyyyy556KGH0rZt21qtBQAAAAAAAAA+q8ah+7x586rc4b7c//3f/9X6e9Lbtm2bsWPHZuzYsatcp1AoZOTIkRk5cmStHhsAAAAAAAAA1qTGj5f/6le/mltvvbXye6FQyLJly/KLX/wiAwYMqNXiAAAAAAAAAKA+q/Gd7r/4xS/Sv3//PP/881m0aFHOOOOMvPrqq/nggw/y17/+dW3UCAAAAAAAAAD1Uo3vdN9qq63y8ssv5ytf+Ur23nvvzJs3LwcffHBeeumlbLLJJmujRgAAAAAAAACol2p8p3uSlJeX54ILLqjtWgAAAAAAAACgQSkpdJ89e3ZuvPHGvPbaaykUCtlyyy3z3e9+Nx06dKjt+gAAAAAAAACg3qrx4+Uff/zx9OrVK1dccUVmz56dDz74IFdccUV69eqVxx9/fG3UCAAAAAAAAAD1Uo3vdD/++ONz6KGH5tprr03Tpk2TJEuXLs1xxx2X448/PlOmTKn1IgEAAAAAAACgPqrxne5vv/12Tj311MrAPUmaNm2a4cOH5+23367V4gAAAAAAAACgPqtx6L7DDjvktddeW2H8tddey/bbb18bNQEAAAAAAABAg1Ctx8u//PLLlX8+6aSTcvLJJ+ett97KrrvumiR5+umnc/XVV+eiiy5aO1UCAAAAAAAAQD1UrdB9++23T6FQSLFYrBw744wzVljviCOOyGGHHVZ71QEAAAAAAABAPVat0H3q1Klruw4AAAAAAAAAaHCqFbr36NFjbdcBAAAAAAAAAA1OtUL3z/rXv/6Vv/71r5k1a1aWLVtWZdlJJ51UK4UBAAAAAAAAQH1X49D95ptvzo9+9KO0aNEiHTt2TKFQqFxWKBSE7gAAAAAAAAA0GjUO3c8777ycd955GTFiRJo0abI2agIAAAAAAACABqHGqfn8+fNz+OGHC9wBAAAAAAAAaPRqfKf7Mccck9///vc566yz1kY9AAAAAEAD0fOs8XVdAisx7aJ967oEAIBGpcah++jRo7PffvtlwoQJ2WabbdK8efMqy8eMGVNrxQEAAAAAAABAfVbj0H3UqFH505/+lM033zxJUigUKpd9+s8AAAAAAAAAsK6rceg+ZsyY3HTTTRk6dOhaKAcAAAAAAAAAGo4mNd2grKwsu++++9qoBQAAAAAAAAAalBqH7ieffHKuvPLKtVELAAAAAAAAADQoNX68/LPPPptHHnkkDz74YLbeeus0b968yvJ77rmn1ooDAAAAAAAAgPqsxqH7+uuvn4MPPnht1AIAAAAAAAAADUqNQ/ebb755bdQBAAAAAAAAAA1Ojd/pDgAAAAAAAAD8R43vdO/Vq1cKhcIql//jH//4XAUBAAAAAAAAQENR49B92LBhVb4vXrw4L730UiZMmJDTTz+9tuoCAAAAAAAAgHqvxqH7ySefvNLxq6++Os8///znLggAAAAAAAAAGopae6f7kCFDcvfdd9fW7gAAAAAAAACg3qu10P2///u/06FDh9raHQAAAAAAAADUezV+vPyXv/zlFAqFyu/FYjEzZ87Mv//971xzzTW1WhwAAAAAAAAA1Gc1Dt2//vWvV/nepEmTbLjhhunfv3+22GKL2qoLAAAAAAAAAOq9Gofu559//tqoY5X+9a9/5cwzz8wf//jHLFiwIJtttlluvPHG7Ljjjkn+c6f9BRdckOuvvz6zZ8/OLrvskquvvjpbb731F1onAAAAAAAAAI1Prb3TfW2YPXt2dt999zRv3jx//OMf8/e//z2XXXZZ1l9//cp1LrnkkowZMyZXXXVVnnvuuZSXl2fvvffORx99VHeFAwAAAAAAANAoVPtO9yZNmlR5l/vKFAqFLFmy5HMXtdzFF1+cbt265eabb64c69mzZ+Wfi8Vixo4dm3POOScHH3xwkuSWW25Jly5dcscdd+TYY4+ttVoAAAAAAAAA4LOqHbrfe++9q1w2adKkXHnllSkWi7VS1HL3339/Bg8enG9+85t5/PHHs9FGG+W4447LD37wgyTJ1KlTM3PmzAwaNKhym7KysvTr1y+TJk1aZei+cOHCLFy4sPL73Llza7VuAAAAAAAAABqHaofuBx544Apj//M//5MRI0bkgQceyLe//e387Gc/q9Xi/vGPf+Taa6/N8OHDc/bZZ+fZZ5/NSSedlLKyshx11FGZOXNmkqRLly5VtuvSpUveeeedVe539OjRueCCC2q1VgAAAAAAAAAan5Le6f7ee+/lBz/4QbbddtssWbIkkydPzi233JLu3bvXanHLli3LDjvskFGjRuXLX/5yjj322PzgBz/ItddeW2W9zz72vlgsrvZR+CNGjMicOXMqP++++26t1g0AAAAAAABA41Cj0H3OnDk588wzs+mmm+bVV1/Nn//85zzwwAPp06fPWimua9eu2WqrraqMbbnllpk+fXqSpLy8PEkq73hfbtasWSvc/f5pZWVladeuXZUPAAAAAAAAANRUtUP3Sy65JF/60pfy4IMP5re//W0mTZqUPffcc23Wlt133z2vv/56lbE33ngjPXr0SJL06tUr5eXlmThxYuXyRYsW5fHHH0/fvn3Xam0AAAAAAAAAUO13up911llp1apVNt1009xyyy255ZZbVrrePffcU2vFnXLKKenbt29GjRqVQw89NM8++2yuv/76XH/99Un+81j5YcOGZdSoUendu3d69+6dUaNGpXXr1jniiCNqrQ4AAAAAAAAAWJlqh+5HHXXUat+TvjbsvPPOuffeezNixIj89Kc/Ta9evTJ27Nh8+9vfrlznjDPOyIIFC3Lcccdl9uzZ2WWXXfLQQw+lbdu2X2itAAAAAAAAADQ+1Q7dx40btxbLWLX99tsv++233yqXFwqFjBw5MiNHjvziigIAAAAAAACA1OCd7gAAAAAAAABAVUJ3AAAAAAAAACiR0B0AAAAAAAAASiR0BwAAAAAAAIASCd0BAAAAAAAAoERCdwAAAAAAAAAokdAdAAAAAAAAAEokdAcAAAAAAACAEgndAQAAAAAAAKBEQncAAAAAAAAAKJHQHQAAAAAAAABKJHQHAAAAAAAAgBIJ3QEAAAAAAACgREJ3AAAAAAAAACiR0B0AAAAAAAAASiR0BwAAAAAAAIASCd0BAAAAAAAAoERCdwAAAAAAAAAokdAdAAAAAAAAAEokdAcAAAAAAACAEgndAQAAAAAAAKBEQncAAAAAAAAAKJHQHQAAAAAAAABKJHQHAAAAAAAAgBIJ3QEAAAAAAACgREJ3AAAAAAAAACiR0B0AAAAAAAAASiR0BwAAAAAAAIASCd0BAAAAAAAAoERCdwAAAAAAAAAokdAdAAAAAAAAAEokdAcAAAAAAACAEgndAQAAAAAAAKBEQncAAAAAAAAAKFGDCt1Hjx6dQqGQYcOGVY4Vi8WMHDkyFRUVadWqVfr3759XX3217ooEAAAAAAAAoNFoMKH7c889l+uvvz7bbrttlfFLLrkkY8aMyVVXXZXnnnsu5eXl2XvvvfPRRx/VUaUAAAAAAAAANBYNInT/+OOP8+1vfzs33HBDNthgg8rxYrGYsWPH5pxzzsnBBx+cPn365JZbbsn8+fNzxx131GHFAAAAAAAAADQGDSJ0P/7447Pvvvtm4MCBVcanTp2amTNnZtCgQZVjZWVl6devXyZNmrTK/S1cuDBz586t8gEAAAAAAACAmmpW1wWsyZ133pkXX3wxzz333ArLZs6cmSTp0qVLlfEuXbrknXfeWeU+R48enQsuuKB2CwUAAAAAaCR6njW+rktgJaZdtG9dlwAAjVK9vtP93Xffzcknn5zbb789LVu2XOV6hUKhyvdisbjC2KeNGDEic+bMqfy8++67tVYzAAAAAAAAAI1Hvb7T/YUXXsisWbOy4447Vo4tXbo0TzzxRK666qq8/vrrSf5zx3vXrl0r15k1a9YKd79/WllZWcrKytZe4QAAAAAAAAA0CvX6Tve99torr7zySiZPnlz52WmnnfLtb387kydPzpe+9KWUl5dn4sSJldssWrQojz/+ePr27VuHlQMAAAAAAADQGNTrO93btm2bPn36VBlr06ZNOnbsWDk+bNiwjBo1Kr17907v3r0zatSotG7dOkcccURdlAwAAAAAAABAI1KvQ/fqOOOMM7JgwYIcd9xxmT17dnbZZZc89NBDadu2bV2XBgAAAAAAAMA6rsGF7o899liV74VCISNHjszIkSPrpB4AAAAAAAAAGq96/U53AAAAAAAAAKjPhO4AAAAAAAAAUCKhOwAAAAAAAACUSOgOAAAAAAAAACUSugMAAAAAAABAiYTuAAAAAAAAAFAioTsAAAAAAAAAlEjoDgAAAAAAAAAlEroDAAAAAAAAQImE7gAAAAAAAABQIqE7AAAAAAAAAJRI6A4AAAAAAAAAJRK6AwAAAAAAAECJhO4AAAAAAAAAUCKhOwAAAAAAAACUSOgOAAAAAAAAACUSugMAAAAAAABAiYTuAAAAAAAAAFAioTsAAAAAAAAAlEjoDgAAAAAAAAAlEroDAAAAAAAAQImE7gAAAAAAAABQIqE7AAAAAAAAAJRI6A4AAAAAAAAAJRK6AwAAAAAAAECJhO4AAAAAAAAAUCKhOwAAAAAAAACUSOgOAAAAAAAAACUSugMAAAAAAABAiYTuAAAAAAAAAFAioTsAAAAAAAAAlEjoDgAAAAAAAAAlEroDAAAAAAAAQImE7gAAAAAAAABQonoduo8ePTo777xz2rZtm86dO+frX/96Xn/99SrrFIvFjBw5MhUVFWnVqlX69++fV199tY4qBgAAAAAAAKAxqdeh++OPP57jjz8+Tz/9dCZOnJglS5Zk0KBBmTdvXuU6l1xyScaMGZOrrroqzz33XMrLy7P33nvno48+qsPKAQAAAAAAAGgMmtV1AaszYcKEKt9vvvnmdO7cOS+88EK++tWvplgsZuzYsTnnnHNy8MEHJ0luueWWdOnSJXfccUeOPfbYuigbAAAAAAAAgEaiXt/p/llz5sxJknTo0CFJMnXq1MycOTODBg2qXKesrCz9+vXLpEmTVrmfhQsXZu7cuVU+AAAAAAAAAFBTDSZ0LxaLGT58ePbYY4/06dMnSTJz5swkSZcuXaqs26VLl8plKzN69Oi0b9++8tOtW7e1VzgAAAAAAAAA66wGE7qfcMIJefnll/Pb3/52hWWFQqHK92KxuMLYp40YMSJz5syp/Lz77ru1Xi8AAAAAAAAA6756/U735U488cTcf//9eeKJJ7LxxhtXjpeXlyf5zx3vXbt2rRyfNWvWCne/f1pZWVnKysrWXsEAAAAAAAAANAr1+k73YrGYE044Iffcc08eeeSR9OrVq8ryXr16pby8PBMnTqwcW7RoUR5//PH07dv3iy4XAAAAAAAAgEamXt/pfvzxx+eOO+7IH/7wh7Rt27byPe3t27dPq1atUigUMmzYsIwaNSq9e/dO7969M2rUqLRu3TpHHHFEHVcPAAAAAAAAwLquXofu1157bZKkf//+VcZvvvnmDB06NElyxhlnZMGCBTnuuOMye/bs7LLLLnnooYfStm3bL7haAAAAAAAAABqbeh26F4vFNa5TKBQycuTIjBw5cu0XBAAAAAAAAACfUq/f6Q4AAAAAAAAA9ZnQHQAAAAAAAABKJHQHAAAAAAAAgBIJ3QEAAAAAAACgREJ3AAAAAAAAACiR0B0AAAAAAAAASiR0BwAAAAAAAIASCd0BAAAAAAAAoERCdwAAAAAAAAAokdAdAAAAAAAAAEokdAcAAAAAAACAEgndAQAAAAAAAKBEQncAAAAAAAAAKJHQHQAAAAAAAABKJHQHAAAAAAAAgBI1q+sCAAAAAACAhqPnWePrugRWYtpF+9Z1CQCNljvdAQAAAAAAAKBEQncAAAAAAAAAKJHQHQAAAAAAAABKJHQHAAAAAAAAgBIJ3QEAAAAAAACgREJ3AAAAAAAAACiR0B0AAAAAAAAASiR0BwAAAAAAAIASCd0BAAAAAAAAoERCdwAAAAAAAAAokdAdAAAAAAAAAEokdAcAAAAAAACAEgndAQAAAAAAAKBEQncAAAAAAAAAKJHQHQAAAAAAAABKJHQHAAAAAAAAgBIJ3QEAAAAAAACgREJ3AAAAAAAAACjROhO6X3PNNenVq1datmyZHXfcMX/5y1/quiQAAAAAAAAA1nHrROh+1113ZdiwYTnnnHPy0ksvZc8998yQIUMyffr0ui4NAAAAAAAAgHXYOhG6jxkzJsccc0y+//3vZ8stt8zYsWPTrVu3XHvttXVdGgAAAAAAAADrsGZ1XcDntWjRorzwwgs566yzqowPGjQokyZNWuk2CxcuzMKFCyu/z5kzJ0kyd+7ctVdoI7ds4fy6LoGV+KJ+5s1//fRFzL+5r5/83W/czH/j5t/+xsvf/cbN3/3Gzfw3Xv7tb9z83W+8/N1v3GQcALVr+b+rxWJxjesWitVZqx577733stFGG+Wvf/1r+vbtWzk+atSo3HLLLXn99ddX2GbkyJG54IILvsgyAQAAAAAAAGhg3n333Wy88carXafB3+m+XKFQqPK9WCyuMLbciBEjMnz48Mrvy5YtywcffJCOHTuuchtI/vMbLd26dcu7776bdu3a1XU5fMHMf+Nl7hs389+4mf/Gy9w3bua/8TL3jZv5b9zMf+Nl7hs389+4mf/Gy9xTXcViMR999FEqKirWuG6DD907deqUpk2bZubMmVXGZ82alS5duqx0m7KyspSVlVUZW3/99ddWiayD2rVr5x/iRsz8N17mvnEz/42b+W+8zH3jZv4bL3PfuJn/xs38N17mvnEz/42b+W+8zD3V0b59+2qt12Qt17HWtWjRIjvuuGMmTpxYZXzixIlVHjcPAAAAAAAAALWtwd/pniTDhw/PkUcemZ122im77bZbrr/++kyfPj0/+tGP6ro0AAAAAAAAANZh60Tofthhh+X999/PT3/608yYMSN9+vTJ//t//y89evSo69JYx5SVleX8889f4fUENA7mv/Ey942b+W/czH/jZe4bN/PfeJn7xs38N27mv/Ey942b+W/czH/jZe5ZGwrFYrFY10UAAAAAAAAAQEPU4N/pDgAAAAAAAAB1RegOAAAAAAAAACUSugMAAAAAAABAiYTuAGvB0KFD8/Wvf72uy6AOmPvGzfw3bua/8TL3jZv5b7zMfeNm/hs38994mfvGzfw3Xua+cTP/VJfQHVbhmmuuSa9evdKyZcvsuOOO+ctf/lK57J577sngwYPTqVOnFAqFTJ48ue4KbQQaw1ys7hwXL16cM888M9tss03atGmTioqKHHXUUXnvvffqsOIvxqr6si71ZHVznyQjR47MFltskTZt2mSDDTbIwIED88wzz9RRtV+s1fVmXenLmub/04499tgUCoWMHTv2iyuwDlW3Nw25L2s6x6FDh6ZQKFT57LrrrnVU7RdndX1ZV3pSnZ/v1157LQcccEDat2+ftm3bZtddd8306dProNov1pp6sy70ZU3n+Nmf8eWfX/ziF3VU8RdjdX1ZV3qyprn/+OOPc8IJJ2TjjTdOq1atsuWWW+baa6+to2q/WKvrzbrSlzXN///+7/9m6NChqaioSOvWrfO1r30tb775Zh1V+8VaXW/Whb488cQT2X///VNRUZFCoZD77rtvhXWKxWJGjhyZioqKtGrVKv3798+rr776xRf7BVpTX9aFnlRn7teV61o1taberAt9WdM5rkvXtmpidX1ZV3pSnb/768p1rZpaU2/Whb5UZ/4/rSFf12JFQndYibvuuivDhg3LOeeck5deeil77rlnhgwZUnlBb968edl9991z0UUX1XGl677GMBdrOsf58+fnxRdfzLnnnpsXX3wx99xzT954440ccMABdVz52rW6vqwrPVnT3CfJZpttlquuuiqvvPJKnnzyyfTs2TODBg3Kv//97zqsfO1bU2/Whb5UZ/6Xu++++/LMM8+koqKiDir94lW3Nw25L9U9x6997WuZMWNG5ef//b//V0cVfzGq05eG3pPqnOPbb7+dPfbYI1tssUUee+yx/O1vf8u5556bli1b1mHla9+aerMu9KU68//pn+8ZM2bkpptuSqFQyDe+8Y06rHztWlNf1oWeVGfuTznllEyYMCG33357XnvttZxyyik58cQT84c//KEOK1/71tSbdaEvazrHYrGYr3/96/nHP/6RP/zhD3nppZfSo0ePDBw4MPPmzavj6teu1fVmXenLvHnzst122+Wqq65a5TqXXHJJxowZk6uuuirPPfdcysvLs/fee+ejjz76Aiv9Yq2pL+tCT6oz9+vCda1SrKk360Jf1nSO68q1rZpaXV/WlZ5U5+/+unBdqxRr6s260JfqzP9yDfm6FqtQBFbwla98pfijH/2oytgWW2xRPOuss6qMTZ06tZik+NJLL32B1TUua3suLrvssmKfPn2KrVu3Lm688cbFH//4x8WPPvqocvnNN99cbN++fXHChAnFLbbYotimTZvi4MGDi++9917lOkuWLCmecsopxfbt2xc7dOhQPP3004tHHXVU8cADD6zVc/y0Z599tpik+M4779TofBuSmvalpj1pqHM/Z86cYpLiww8/XK1jNFQ17U1N+9KQ5v+f//xncaONNipOmTKl2KNHj+Lll19erf03ZNXpzefpS0OZ/6OPPrra+1tXrKkvn7cnDWXuDzvssOJ3vvOdks+zoVpTbz5vXxrK/H/WgQceWPyv//qvmp1sA1PTvtS0Jw1l7rfeeuviT3/60yrr7LDDDsWf/OQn1T7XhmhNvfm8fWkI8//6668XkxSnTJlS5ZgdOnQo3nDDDdU6RkO1ut7URl/qw/x/WpLivffeW2Vs2bJlxfLy8uJFF11UOfbJJ58U27dvX7zuuutqfIyG6LN9qY2eNIS5/7TGfI1xdb1pyNf7qnuOn9YYrvd9WnX60hCv99X0HIvFxnO979Oq05uGeL2vuufYGK/3NQbudIfPWLRoUV544YUMGjSoyvigQYMyadKkOqqqcfoi5qJJkya54oorMmXKlNxyyy155JFHcsYZZ1RZZ/78+bn00ktz22235Yknnsj06dNz2mmnVS6/7LLLctNNN+XGG2/Mk08+mQ8++CD33ntvtY5f6jnOmTMnhUIh66+/fvVPtgEppS817UlDnPtFixbl+uuvT/v27bPddttV6zgNUU17U0pfGsr8L1u2LEceeWROP/30bL311tXad0NXnd583r40lPlPksceeyydO3fOZpttlh/84AeZNWtWjc+3oahuXz5PTxrC3C9btizjx4/PZpttlsGDB6dz587ZZZdd1vhIuoZuTb2pjb40hPn/rP/93//N+PHjc8wxx1T7PBuamvallJ40lLnfY489cv/99+df//pXisViHn300bzxxhsZPHhwtc+1oalObz5vXxrC/C9cuDBJqjy5o2nTpmnRokWefPLJah2nIVpTb2qjL3U9/9UxderUzJw5s0ofysrK0q9fv0Z7Hao2etIQ5p61p6HO/7p+va8UDe16Xykay/W+mmqI1/uqqzFe72s06jr1h/rmX//6VzFJ8a9//WuV8QsvvLC42WabVRlrzL+F+kWoi7n43e9+V+zYsWPl95tvvrmYpPjWW29Vjl199dXFLl26VH7v2rVrld++Xrx4cXHjjTeu1m+/1eQcl1uwYEFxxx13LH7729+u7mk1ODXtS230pD7P/QMPPFBs06ZNsVAoFCsqKorPPvtsTU+vQalub2qzL/V1/keNGlXce++9i8uWLSsWi8VG8Zuv1elNbfelvs7/nXfeWXzwwQeLr7zySvH+++8vbrfddsWtt966+Mknn5RymvVedfpS2z2pj3M/Y8aMYpJi69ati2PGjCm+9NJLxdGjRxcLhULxscceK+k8G4I19WZt9KU+zv9nXXzxxcUNNtiguGDBguqeVoNT077URk/q69wvXLiweNRRRxWTFJs1a1Zs0aJF8dZbby3lFBuM6vSmtvtSH+d/0aJFxR49ehS/+c1vFj/44IPiwoULi6NHjy4mKQ4aNKjUU6331tSbtdGXL3r+PysruePtr3/9azFJ8V//+leV8R/84Afr9Px/2mf7sjZ6Uh/n/tMa8zXG1fWmoV7v+6w1zX+x2Diu933WmvrSEK/3fdbqzrGxXe/7rFX1piFf7/usVZ1jY7ze11g0q90IH9YdhUKhyvdisbjCGF+MtTkXjz76aEaNGpW///3vmTt3bpYsWZJPPvkk8+bNS5s2bZIkrVu3ziabbFK5TdeuXSvvqpszZ05mzJiR3XbbrXJ5s2bNstNOO6VYLFa7juqe4+LFi3P44Ydn2bJlueaaa2p0rg1RdfpSak8a0twPGDAgkydPzv/93//lhhtuyKGHHppnnnkmnTt3rvZxGqI19ebz9KUhzP8LL7yQX/7yl3nxxRcb5X9/VtWb2uhLQ5j/JDnssMMq/9ynT5/stNNO6dGjR8aPH5+DDz64ZifdgKyuL5+3Jw1h7pctW5YkOfDAA3PKKackSbbffvtMmjQp1113Xfr161ft4zREq+pNbfSlIcz/Z91000359re/3aDeW1+q6vallJ40lLm/4oor8vTTT+f+++9Pjx498sQTT+S4445L165dM3DgwGofpyFaXW8+b18awvw3b948d999d4455ph06NAhTZs2zcCBAzNkyJBq778hW1VvaqMv9WX+q8N1qBV9np40pLmn9jW0+W9s1/uqo6Ff76uOxnq9b03Whet9q9PYr/et6zxeHj6jU6dOadq0aWbOnFllfNasWenSpUsdVdU4re25eOedd7LPPvukT58+ufvuu/PCCy/k6quvTvKf/2G3XPPmzatsVygUau0/sjU5x8WLF+fQQw/N1KlTM3HixLRr165WaqiPqtuXUnvS0Oa+TZs22XTTTbPrrrvmxhtvTLNmzXLjjTfWSh31UXV7U2pfGsr8/+Uvf8msWbPSvXv3NGvWLM2aNcs777yTU089NT179qyVOuqjNfXm8/alocz/ynTt2jU9evTIm2++WSt11Del9KUmPWkoc9+pU6c0a9YsW221VZV1ttxyy0yfPr1W6qiP1tSbz9uXhjL/n/aXv/wlr7/+er7//e/XyvHrq5r0pZSeNJS5X7BgQc4+++yMGTMm+++/f7bddtuccMIJOeyww3LppZfWSh310Zp683n70lDmP0l23HHHTJ48OR9++GFmzJiRCRMm5P3330+vXr1qpY76qDq9+Tx9qQ/zXx3l5eVJ4jrUp3zenjSUuWftaGjz35iu91VXQ77eVxON7XpfdTXk633V0Viv9zUWQnf4jBYtWmTHHXfMxIkTq4xPnDgxffv2raOqGqe1PRfPP/98lixZkssuuyy77rprNttss7z33ns12kf79u3TtWvXPP3005VjS5YsyQsvvFCt7at7jsv/x+abb76Zhx9+OB07dqxRnQ1NdfryeXrSkOZ+ZYrFYuX7DddFpfamun1pKPN/5JFH5uWXX87kyZMrPxUVFTn99NPzpz/9qUb1NiRr6s3n7UtDmf+Vef/99/Puu++ma9euNaq3oSilLzXpSUOZ+xYtWmTnnXfO66+/XmWdN954Iz169KhRvQ3JmnrzefvSUOb/02688cbsuOOO6/x7HWvSl1J60lDmfvHixVm8eHGaNKl6maZp06aVT3pYF62pN5+3Lw1l/j97vA033DBvvvlmnn/++Rx44IE1qrchqUlvSulLfZj/6ujVq1fKy8ur9GHRokV5/PHHG+11qM/bk4Yy96wdDWn+G9v1vupo6Nf7Po91/XpfqRrS9b7qaKzX+xoLj5eHlRg+fHiOPPLI7LTTTtltt91y/fXXZ/r06fnRj36UJPnggw8yffr0yn+0l1/8Ky8vr/xtXGrH2pyLTTbZJEuWLMmVV16Z/fffP3/9619z3XXX1bjGk08+ORdddFF69+6dLbfcMmPGjMmHH35Ya+e4ZMmSHHLIIXnxxRfz4IMPZunSpZW/7d2hQ4e0aNGixjU3BKvry+ftSUOZ+3nz5uXCCy/MAQcckK5du+b999/PNddck3/+85/55je/WeN6G5LV9ebz9qWhzH/Hjh1X+D+XzZs3T3l5eTbffPMa19uQrK43n7cvDWX+P/7444wcOTLf+MY30rVr10ybNi1nn312OnXqlIMOOqjG9TYUq+vL5+1JQ5n7JDn99NNz2GGH5atf/WoGDBiQCRMm5IEHHshjjz1W43obkjX15vP0pSHNf5LMnTs3v//973PZZZfVuMaGqDp9KbUnDWXu27Vrl379+uX0009Pq1at0qNHjzz++OO59dZbM2bMmBrX25Csrjefty8NZf6T5Pe//3023HDDdO/ePa+88kpOPvnkfP3rX8+gQYNqXG9DsqbefJ6+1Jf5//jjj/PWW29Vfp86dWomT56cDh06pHv37ikUChk2bFhGjRqV3r17p3fv3hk1alRat26dI444osb1NhRr6svn6UlDmfuk8V5jXFNv1oXrfWs6x8Z6vW91famoqFgnrvetae4b8/W+1fWmY8eO68T1vjXNf2O+3tco1PZL4mFdcfXVVxd79OhRbNGiRXGHHXYoPv7445XLbr755mKSFT7nn39+3RW8DlubczFmzJhi165di61atSoOHjy4eOuttxaTFGfPnl25//bt21fZ5t577y1++p/PxYsXF08++eRiu3btiuuvv35x+PDhxaOOOqp44IEH1so5Tp06daXnmKT46KOPVvsYDdGq+lIbPWkIc79gwYLiQQcdVKyoqCi2aNGi2LVr1+IBBxxQfPbZZ6u9/4ZsVb2pjb40hPlfmR49ehQvv/zyau+/IatJb2ral4Yw//Pnzy8OGjSouOGGGxabN29e7N69e/Hoo48uTp8+vdr7b6hW1Zfa6ElDmPvlbrzxxuKmm25abNmyZXG77bYr3nfffdXef0O2pt58nr40pPn/1a9+VWzVqlXxww8/rPZ+G7o19eXz9KShzP2MGTOKQ4cOLVZUVBRbtmxZ3HzzzYuXXXZZcdmyZTU+54Zmdb35vH1pKPP/y1/+srjxxhtX/jfuJz/5SXHhwoXV3n9DtrrefN6+1If5f/TRR1f6/12PPvroynWWLVtWPP/884vl5eXFsrKy4le/+tXiK6+8Uu3zbIjW1JfP25OGMveN9RrjmnqzLlzvW9M5Ntbrfavry7pyvW9Nc9+Yr/etrjfryvW+6vzb/1mN6Xrfuq5QLHpRDQAAAAAAAACUwjvdAQAAAAAAAKBEQndgnfWb3/wm66233ko/W2+99RdSw/Tp01dZw3rrrZfp06d/IXU0Nua+cTP/jZv5b7zMfeNm/hsvc9+4mf/Gzfw3Xua+cTP/jZe5b9zMPw2Bx8sD66yPPvoo//u//7vSZc2bN0+PHj3Weg1LlizJtGnTVrm8Z8+eadas2Vqvo7Ex942b+W/czH/jZe4bN/PfeJn7xs38N27mv/Ey942b+W+8zH3jZv5pCITuAAAAAAAAAFAij5cHAAAAAAAAgBIJ3QEAAAAAAACgREJ3AAAAAAAAACiR0B0AAAAAAAAASiR0BwAAACo99thjKRQK+fDDD+u6FAAAAGgQhO4AAADQQAwdOjSFQiGFQiHNmjVL9+7d8+Mf/zizZ8+utWP07ds3M2bMSPv27WttnwAAALAuE7oDAABAA/K1r30tM2bMyLRp0/LrX/86DzzwQI477rha23+LFi1SXl6eQqFQa/sEAACAdZnQHQAAABqQsrKylJeXZ+ONN86gQYNy2GGH5aGHHqpcfvPNN2fLLbdMy5Yts8UWW+Saa66psv2kSZOy/fbbp2XLltlpp51y3333pVAoZPLkyUlW/nj5u+++O1tvvXXKysrSs2fPXHbZZVX22bNnz4waNSrf+9730rZt23Tv3j3XX3995fJFixblhBNOSNeuXdOyZcv07Nkzo0ePrv3mAAAAQB0QugMAAEAD9Y9//CMTJkxI8+bNkyQ33HBDzjnnnFx44YV57bXXMmrUqJx77rm55ZZbkiQfffRR9t9//2yzzTZ58cUX87Of/Sxnnnnmao/xwgsv5NBDD83hhx+eV155JSNHjsy5556bcePGVVnvsssuy0477ZSXXnopxx13XH784x/nf/7nf5IkV1xxRe6///787ne/y+uvv57bb789PXv2rPV+AAAAQF1oVtcFAAAAANX34IMPZr311svSpUvzySefJEnGjBmTJPnZz36Wyy67LAcffHCSpFevXvn73/+eX/3qVzn66KPzm9/8JoVCITfccENatmyZrbbaKv/617/ygx/8YJXHGzNmTPbaa6+ce+65SZLNNtssf//73/OLX/wiQ4cOrVxvn332qXzM/ZlnnpnLL788jz32WLbYYotMnz49vXv3zh577JFCoZAePXqsjdYAAABAnXCnOwAAADQgAwYMyOTJk/PMM8/kxBNPzODBg3PiiSfm3//+d959990cc8wxWW+99So/P//5z/P2228nSV5//fVsu+22admyZeX+vvKVr6z2eK+99lp23333KmO777573nzzzSxdurRybNttt638c6FQSHl5eWbNmpUkGTp0aCZPnpzNN988J510UpXH4QMAAEBDJ3QHAACABqRNmzbZdNNNs+222+aKK67IwoULc8EFF2TZsmVJ/vOI+cmTJ1d+pkyZkqeffjpJUiwWUygUquyvWCyu9njV3Wb5I+6XKxQKlTXtsMMOmTp1an72s59lwYIFOfTQQ3PIIYfU7MQBAACgnhK6AwAAQAN2/vnn59JLL83SpUuz0UYb5R//+Ec23XTTKp9evXolSbbYYou8/PLLWbhwYeX2zz///Gr3v9VWW+XJJ5+sMjZp0qRsttlmadq0abXrbNeuXQ477LDccMMNueuuu3L33Xfngw8+qMGZAgAAQP3kne4AAADQgPXv3z9bb711Ro0alZEjR+akk05Ku3btMmTIkCxcuDDPP/98Zs+eneHDh+eII47IOeeckx/+8Ic566yzMn369Fx66aVJssLd7Mudeuqp2XnnnfOzn/0shx12WJ566qlcddVVueaaa6pd4+WXX56uXbtm++23T5MmTfL73/8+5eXlWX/99WujBQAAAFCn3OkOAAAADdzw4cNzww03ZPDgwfn1r3+dcePGZZtttkm/fv0ybty4yjvd27VrlwceeCCTJ0/O9ttvn3POOSfnnXdeklR5z/un7bDDDvnd736XO++8M3369Ml5552Xn/70pxk6dGi161tvvfVy8cUXZ6eddsrOO++cadOm5f/9v/+XJk1clgAAAKDhKxTX9PI2AAAAYJ31m9/8Jt/97nczZ86ctGrVqq7LAQAAgAbH4+UBAACgEbn11lvzpS99KRtttFH+9re/5cwzz8yhhx4qcAcAAIASCd0BAACgEZk5c2bOO++8zJw5M127ds03v/nNXHjhhXVdFgAAADRYHi8PAAAAAAAAACVqUtcFAAAAAAAAAEBDJXQHAAAAAAAAgBIJ3QEAAAAAAACgREJ3AAAAAAAAACiR0B0AAAAAAAAASiR0BwAAAAAAAIASCd0BAAAAAAAAoERCdwAAAAAAAAAo0f8HXIYd0IW5pPIAAAAASUVORK5CYII=", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAB+wAAAHlCAYAAADfkAXrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAACMrElEQVR4nOzdeZyVZf0//tdhG2SZERUXBMEF3JcSSUUFyaU0Fdc0zTCxMLOCio+oCeJOuWVpJiqaue+lJqmgglsmkpoLmiC5m8gIKLKc3x/+Zr6OzMgwDBwcns/H4zwenPu+7vt+3+c695lhXue67kKxWCwGAAAAAAAAAFiumpW6AAAAAAAAAABYGQnsAQAAAAAAAKAEBPYAAAAAAAAAUAICewAAAAAAAAAoAYE9AAAAAAAAAJSAwB4AAAAAAAAASkBgDwAAAAAAAAAlILAHAAAAAAAAgBIQ2AMAAAAAAABACQjsAQBgBdGtW7cUCoWMHz++1KVUGzNmTAqFQvr27bvIukKhkEKhkKlTpy73uhZnRa6tMb3++uv53ve+l3XXXTctWrRIoVDIgAEDFrvd1KlTq1+jUlpZ+omlN378+BQKhXTr1q3UpSwTroVl59FHH803vvGNrLbaamnWrFkKhULGjBlT6rIAAACqCewBAGAp9e3btzpsqXq0bt06a621VrbeeusMGDAgV111VebMmbNc6pk6dWpGjBiRCy64YLkcb3lqyue2pD755JPsuuuuufrqqzNr1qx89atfTe/evdOjR49Slwas4Kq+AFH1+POf//yF7ceNG1ej/c0337xImyeffDIXXHBBjjjiiGyyySbV4fiIESO+cN9z5szJX/7ylwwaNChbbrll2rVrl7KysnTp0iUHH3xw7r///gaf5wsvvJB+/frl3nvvTevWrbP99tund+/eWWuttRq8z8byr3/9K8OGDcvuu++eDTbYIO3bt69x3n//+9/r3HbAgAGL/N5RVlaWjh07ZrPNNsthhx2Wiy++ODNmzFiOZ9Q4qr68uLj3zWffw5//ostnX59vfvObX7ifdu3aNfqXJUeMGJERI0bkgw8+aLR9AgDQtLUodQEAANBUdOnSJeutt16SZP78+Zk5c2Zeeuml/Otf/8pVV12Vn/zkJznnnHMyaNCgWrffcMMN07p167Rp02ap6pg6dWpOPfXUdO3aNT/72c+Wal8VFRXZeOONq8+r1Op7bhtvvHGSpGXLlsupsuVv7NixmTJlSjp16pTnnnsuq666aqlLWmIrQz/RONq0aZONN9446667bqlLWSZKfS1ceeWVOfzww79w/eIMHDgwkydPXuJj//CHP8w111yTJCkrK0v37t3TrFmzTJkyJTfffHNuvvnmHH/88fntb3+7xPsePXp0Pv744+yzzz657bbb0rx58yXex7Jy55135uyzz06hUEjHjh2z0UYb5ZNPPsnUqVOrz/u4447L7373uzr3seaaa6Z79+5JkoULF2bmzJmZPn16nn/++Vx//fX5+c9/nmHDhuXEE09MixYr558A//a3v2X8+PG1zhS0rJx66qlJPv3iwJfxZzMAAMvfyvnbOgAALAPf//73FxkRNm/evDz66KM599xzc+edd+bYY4/NCy+8UOsI8aUZRbis7L///tl///1LXcYSe+GFF0pdwjL373//O0nSu3fvL20gsDL0E42jV69eTfr9Uqpza9OmTdZYY42MGzcur732Wq1fzqqsrMwtt9ySDh06pKysLG+99Vat+1p//fWz8cYbp2fPnunZs2dOP/30PPDAA/WqY6+99sqxxx6b3XbbLa1bt06SzJ49OyeddFIuvPDCXHTRRdlyyy1zzDHHLNH5VX1OfuMb31ihwvrk08/uG264If369csaa6xRvXzOnDn5zW9+k+HDh+f3v/99+vbtm4MOOqjWfXzzm99cZHr/hQsXZtKkSbnoooty1VVXZfjw4Xn66adz8803p1mzlWuizebNm2fBggU54YQT8thjj5W6HAAAqNPK9Zs6AAAsZy1btswuu+ySO+64I2eeeWaS5MILL8ytt95a4sr4svvoo4+SZKlnZABWXoVCId/73veycOHCXHXVVbW2ueGGGzJnzpwcdthhKSsrq3Nft912W2644Yb88pe/zK677ppVVlmlXjVccMEFueuuu/Ktb32rOqxPkrZt2+aCCy7I7rvvniS55JJLluDMPrUif07uuuuuOeSQQ2qE9cmntZ5yyin5xje+kSS13n7gizRr1izbbrttxowZU32rg9tuu22lvJXMAQcckHbt2uXxxx/3excAACs0gT0AACwnw4YNy9e//vUkyciRIxdZX3Xf1truo3r77bfnm9/8ZtZcc820bNkyq6++ejbddNMcccQRuf3226vb9e3bN7vuumuSZNq0aYvc47Zq31OnTq1eliR33XVX9thjj6yxxhopFArV+xwzZkwKhcJip5KdMGFC9t5776yxxhpZZZVVss022+R3v/tdFixYsEjbqvvOduvWrc79Vd1/9rMzFtT33JLUeV/bJCkWi7nuuuuy++67Z/XVV0+rVq3SuXPnHH744Zk0aVKt9Xz+dRgzZky+9rWvpV27dikvL8+uu+76hfcbXpzp06fn+OOPT48ePbLKKqukoqIivXr1ynnnnZePP/64RtsRI0bUeG2uuuqqGq9DbefcEBMmTMihhx6azp07p6ysLKuttlp233333HLLLXVu8+CDD+bAAw/Muuuum1atWmXVVVdNjx49ctBBB9U6pfaK1k/1vc7q47PX87PPPptDDjkka6+9dlq3bp1NNtkkp5122iJ9+1kLFy7MNddckz322CMdO3ZMq1atsu666+awww6r8/w/e9188MEH+cUvfpHu3bundevW2WabbepV95LsY+rUqTn++OOz8cYbp02bNmnfvn169uyZc8899wvP7Z///Gf222+/rL766mnTpk222mqrnH/++Vm4cGH69u2bQqGwyKjhxX1uzJ49O2effXZ69uyZ8vLytGnTJptsskmGDBlS54jwz57rRx99lOHDh2fjjTdO69at07Fjx3z729/OlClTat32k08+yYUXXpgddtghq666alq1apW11147X/3qV3P88cfnqaeeqvP8a7O4e3E3pMb6qjpGXYH9FVdckSQ56qijluo4dVl99dW/cH3VPciff/75eu+z6n1U9XPhqKOOqn6NP/8eWtr3TkOvtcXZbLPNqutrqO985zv5/ve/nyQ555xzMnfu3HpvW/WzZsCAAVmwYEHOP//8bLXVVllllVXSoUOHfOtb38o///nPWrddHu/b+lhzzTUzZMiQJMlJJ51U6+8ki/POO+9k2LBh2WqrrdK+ffu0adMmW2yxRU455ZTMnDmzRtuq16zK+uuvX+Pn8+dnYQIAgCoCewAAWI5+8pOfJEkmT56cadOm1WubESNGZP/998/f/va3JMlWW22VtdZaK2+88Ub+/Oc/5ze/+U112y233DJbbLFFkk/vBdy7d+8aj4qKikX2f+655+Zb3/pWnnrqqWywwQbp0qXLEp3Tbbfdlr59++ahhx7K+uuvn44dO2by5Mk5/vjjc/DBBzfoD+S1aci5fd78+fNzyCGH5Dvf+U7uu+++tGnTJltvvXVmzZqVa6+9Ntttt10uv/zyL9zH0UcfnaOOOipvvvlmevTokYULF2b8+PH5xje+kTvuuGOJz+uhhx7Klltumd/97neZNm1aNt1006yzzjr5xz/+kZ///OfZaaed8r///a+6/XrrrZfevXtX99Oaa65Z43X47AjVhjrhhBOy884754YbbsisWbOy2WabpaysLPfdd18OOuigHHvssYtsc+WVV2bXXXfNrbfemjlz5mSzzTZL165d89577+WWW27Jr371q3ofvxT9tCTX2ZJ47LHH0qtXr9x5551Zd91106VLl7z44os55ZRT0q9fv1rDuA8//DB77rlnvvvd7+bvf/97WrRokS222CKzZs3K9ddfn169elWPnK3Ne++9l2233TbnnXdeWrVqlc0222yJ3xeL28dtt92WzTbbLL/73e/y2muvZf31189aa62VSZMm5Re/+EX69u2bysrKRfZ7xx13ZIcddsidd96ZTz75JJtvvnlmzZqVIUOG5JBDDlmiGqu88cYb6dWrV4YNG5Z//vOf6dy5czbZZJP85z//yfnnn58tt9wyTz75ZJ3bV1ZWZscdd8xpp52W5s2bZ6ONNsoHH3yQG2+8MTvssMMin9ULFizIN7/5zfzsZz/LY489lg4dOmSbbbZJ27Zt8/zzz+d3v/tdo4/mXdIal8QGG2yQXXbZJa+88koefvjhGuteeOGFPPbYY9liiy3Ss2fPpT2NBqn68seSjJLfcsst07t375SXlydJunfvXv0Zud1221W3W9r3TmNca7VZuHBhJkyYkCQ16m2In/70p0k+DZ4bMi38/Pnzs9dee2XIkCH56KOPsvHGG+ejjz7KXXfdlZ133jn/+Mc/6tx2Wb5v6+sXv/hFOnbsmBdeeGGRLwItzsSJE7PZZpvl7LPPzgsvvJBOnTqla9euefHFF3Paaadlu+22y3//+9/q9lU/n6v07Nmzxs/n2m45AQAASZIiAACwVPr06VNMUhw+fPhi277//vvFQqFQTFK8/vrra6zr2rVrMUlx3Lhx1cvefffdYosWLYotWrQo3njjjcWFCxfW2ObJJ58sjh49usaycePGFZMUu3btWmcdr776ajFJMUmxZcuWxQsuuKA4f/786vUfffRRsVgsFq+88spikmKfPn0W2cdntz/66KOLs2fPrl532223FVdZZZVikuKvf/3rJa7ve9/7Xq2vaX22/Wxtr776ao3lI0aMKCYptmnTpnjrrbdWL//444+LgwcPLiYptmjRoviPf/yjxnZVr0PLli2Lq6++enHs2LHV62bNmlXcb7/9ikmK3bp1W6SPvsi7775b7NixYzFJ8Vvf+lbxvffeq173z3/+s9ilS5dikuJ+++23yLbDhw8vJil+73vfq/fxqny2/z/v4osvLiYprrHGGsUbbrihxrqxY8cW11xzzWKS4pVXXlm9fP78+cXVV1+9mKT429/+tjhv3rwa2z3//PPFCy+8cJFjrSj91JDrbHGqrueWLVsW99577+L//ve/6nUPP/xwcY011igmKR533HGLbHvIIYcUkxS/8pWv1DjHBQsWFC+44IJis2bNimVlZcUXXnihxnZV103z5s2LX/3qV4svv/xy9bo5c+bUq+767GPSpEnFsrKyYqFQKJ5++uk19j1lypTidtttV+t788033yxWVFQUkxQHDBhQnDVrVvW6sWPHFsvLy4stW7Zc5P1VLH7xtd+3b99ikmL37t2LzzzzTI3j9evXr5ik2KVLl2JlZWWt59qyZcviV7/61eKUKVOq173yyivF7t27F5MUjzzyyBrb3X777cUkxc6dOxcnT55cY928efOKd999d/Gee+6p5dWtW13XQkNrXJyq17Nt27bFYrFYHDNmTDFJ8aijjqrRbujQocUkxXPPPbdYLP6/9/VNN9202GPsvffe9f7ZWJcFCxYUt9pqqzo/Bxen6ufz599PVZb2vbM011ptKisri0888UTxgAMOKCYpbrLJJsWZM2cu0q7q+PX5/F+4cGGxQ4cOxSTFs88+u961VP2MadmyZbFbt27FJ598snrdO++8U9x+++2LSYq77LJLnfU15H1b9R5b3Pum6j38RddN1efr+eefX33NVv1+U6Vt27aL/O5VLBaL06dPL6622mrFJMWf/OQnxRkzZlSve/PNN4vf/OY3F/v70efrAgCAugjsAQBgKS1JYF8sFqsDq88HmLUF9o8++mgxSXGbbbapdz1LGtgPGjSoznb1Cew33njj4oIFCxZZf8YZZxSTFNdcc83i3Llzl6i+ZRHYz5o1q1heXl7rlwiq7LzzzsUkxf79+9dYXvU6JCn+6U9/WmS7N954ozpo/HyA90VGjhxZTFLs2LFjjS88VLnvvvuqj/v000/XWLcsAvvZs2dXB8l/+9vfat32lltuqe73Km+++WYxSXHVVVddojpWlH5qyHW2OFXX82qrrVb88MMPF1n/5z//uZik2KpVq+Lbb79dvfzxxx+v3u7111+vdd/HH398MUnxhz/8YY3lVddNq1atitOmTWtQ3fXZR1VQdcIJJ9S6/rXXXiu2bdu22Lx58+J///vf6uVV79ktttiixheEqlx22WXV/VffwP6hhx6q3uaJJ55YZJ/vv/9+9fvpggsuqPVcy8rKagSuVW666aZikmKHDh1qLD/rrLOKSYo/+9nPaj3/hlhc8LikNS7O5wP7WbNmFdu3b19s165d9Rcp5s+fX1xnnXWKLVu2rH6PLu/A/te//nUxSbFQKBQfe+yxJd7+iwL7xnjvLM21VmXGjBnVdVQ92rVrVzzppJNqDes/e/z6fv5vvfXWxSTFwYMH17uuqus1SfGhhx5aZP0//vGP6r754IMPaq2vIe/bZRHYz507t3q/o0aNqtG2rsD+2GOPLSYpHnroobUev7KysrjuuusWkxQfffTRGusE9gAALClT4gMAwHLWrl27JJ9Oe704VdOnvvTSS3n88ceXST1V97dtqJ/85Cdp1mzR/1ocd9xxadGiRd55550673O7PD388MOprKxMmzZtap3SPfl06twkGTt2bObPn7/I+oqKihx++OGLLF9nnXWy/vrrJ0lefvnletd01113JUl+9KMf1Trd89e//vV85StfqdF2WRo3blzee++9dO3aNXvuuWetbfbZZ5+0bNkyL774Yt54440kSceOHdO6det88MEHufPOO5eqhlL007K8zo4++ujqa/6zvv3tb2edddbJJ598kvvvv796+U033ZTk09e5U6dOte7zwAMPTJI88MADta7fbbfdlnrq5br2UVlZmbFjxyZJfvjDH9a6bZcuXbLddttlwYIFefDBB6uX33PPPUk+vb918+bNF9nu8MMPX+LpxKuuiz59+tQ6dXiHDh1y9NFH12j7eXvuuWc23HDDRZZXTW09Y8aMvP/++9XLq16XsWPH1nmP88a2pDUuqbZt2+aQQw7JrFmzcvPNNyf5tL/efPPN7L333llzzTUbvO+GGjt2bE444YQkybBhw/K1r32tUfffGO+dxrjWWrRoUT1letV93qv6Ydy4cUu17ypL8nvH52211VbZeeedF1m+7bbbpqysLMViMa+88kqt2y7r9219tWrVKiNHjkySnH322Yvce742VddBXZ9z7du3z+67756k7s9iAACorxalLgAAAFY2VX8wr7q37hfp1KlTDj/88Pz5z3/O9ttvn549e6Zfv37p1atX+vbtm9VXX32p69lss82Wavuq+8p/XkVFRTp37pypU6fm+eefzw477LBUx1laL774YpJP79fctm3bWttsueWWSZI5c+bktddeywYbbFBjfffu3VMoFGrddq211spLL72UWbNmLXFNVcetq6ZJkyblhRdeqPd+G2ry5MlJkpkzZ2annXaqs13Va/Df//43nTp1SvPmzfPzn/88Z5xxRvbbb79sttlm2X333avfp3UFz7UpRT8ty+usruujefPm2XjjjfPmm2/m+eefr15e1Qfjx4+vsw+q7un92Xsnf9bSXtNftI9nn302CxYsSKFQyBFHHFHn9i+99NIiNVb17dZbb13rNqusskp69OiRf/3rX/Wus77XUJI6r6EePXrUunyttdaq/vesWbOy2mqrJUn69++f7t2759///ne6du2avn37Zuedd84OO+yQ3r17N8o9zJe2xoY46qijcvnll2fMmDH53ve+lyuuuKJ6+fL22GOP5cADD8yCBQty6KGH5rTTTmv0YzTGe6cxrrV27dpV368+ST766KNcfPHFGTZsWPbff//cfPPNOeCAA5bqGEvye8fn1fXeKxQKWXPNNTN9+vQ6f+4tj/dtfR1xxBH59a9/nWeffTbnnHNOzjzzzDrbvvHGG3n33XeTJP/3f/+Xli1b1tpu2rRpSer+LAYAgPoS2AMAwHL0/vvvp7KyMknNP1h/kSuuuCJbbbVVRo8enSeffDJPPvlkkk9H5e27774577zz0rVr1wbXVFcoWl9fdB5rrbVWpk6d2qBRfY2tqoa11167zjbrrLPOIu0/64teq6pZBhYuXLhMaloer+GMGTOSJB988EEmTpy42PZz5syp/vdpp52W9dZbL7///e/zr3/9K//+97+TfBrqfP3rX8+5556brbbaarH7LFU/LavrbHHXx+fPoaoPpk2bVh0G1eWjjz6qdfnSXtNftI+q+orF4hK/R6pCvfbt29fZ/ovW1aYxrqG6zvWzM4d89v3Spk2bPPzwwznttNNyww03ZOzYsdWzDrRv3z4/+MEPMnLkyFpnzWioJa2xIXr37p0ePXrkwQcfzBNPPJG//vWvWXPNNbPXXnst1X6X1FNPPZVvfOMbmTVrVg444ID86U9/qnUWl6W1LN87S2OVVVbJz3/+83zyySc58cQTc8IJJyxVYF8sFvPaa68lqf/vHZ+1ND/3GvK+rZp9Y8GCBV9Y12dnV2nRYvF/3mzWrFnOPPPM7Lvvvrnwwgtz/PHH1/hZ8llVn3NJ8sQTTyx235/9nAMAgIYwJT4AACxHDz/8cPW/6zvivFWrVhk6dGheeumlTJ8+Pdddd12OPvrotGnTJrfeemt23333zJ49e1mVvFhvv/32Ytd9NoSrGvlcLBbr3G5ZnE9VDV80hfWbb765SPtlaUlqWh71VE2b3L9//xSLxcU++vbtW71toVDID37wg0yePDnvvPNObr311hx//PHp2LFj7rvvvvTr1696Cv0vUqp+WlbX2ZJeH1V9cMEFF9SrD5a3qvpWXXXVetU3YsSIRbb9oi+fLOkXU0p1Da211lr53e9+l3feeSfPPvtsLrnkkuy7776ZM2dOzj333AwcOLDRjrU8DRgwIMViMd/+9rczb968fPe7361XGNpYJk+enN133z0zZ87Mfvvtl+uvv36ZHX9F+/z9vH322SdJMmXKlOov+jXEv/71r3zwwQdJ6v97RymtuuqqSWqG5rX57FT6Vdsszj777JPevXtnzpw51VPk1+aztzGZMWPGYj/nxowZU6/jAwBAXQT2AACwHP32t79NknzlK19Jly5dlnj7zp0759BDD83o0aPz3HPPpby8PFOmTMnf//736jZ1TQW+rDz33HO1Lp85c2b1NLGbbrpp9fKqEXfvvPNOnfusmk7785bm3DbZZJMkyX/+8586R8M9++yzST4dQbu09yVekpqqjvtFNX32NVxWqqZ/fuyxx5ZqtG7Hjh2z//7757e//W2mTJmSbt265X//+19uvPHGxW67IvRTfa6z+qrr+liwYEH1lNyf7duqPqjP6PVS2HzzzVMoFPLBBx9Uz6JQXxtvvHGS/zft/+d9/PHHdV77dSn1NVQoFLL55ptn0KBBueOOO3LrrbcmSa677rrqkPTL5Mgjj0zz5s0zderUJMt3Ovxnn302u+22W95///1861vfyo033ljnVOSNodTvncX57AjyxY02/yJVv3estdZa+drXvrbUdS1rVf1S1+dElar16667bo2AfXHOOeecJMno0aMzZcqUWtt07ty5+ksAjzzySL33DQAADSWwBwCA5eSss87KAw88kCT51a9+tdT769y5c9Zff/0kqTFyuWoa5rqmy25sF110Ua0jfS+++OLMnz8/HTt2zLbbblu9fKONNkqhUMjHH3+cSZMmLbLdxIkT67yH9dKc20477ZTy8vLMmTMnl156aa1tzj333CTJnnvuuVxGle69995JkksuuaTWcxo3blyeeuqpJFku01LvvvvuWXXVVfPWW2/lsssua5R9lpeXV9+zvD4j7Fe0fqrrOquv0aNH1zoy/8Ybb8ybb76ZVq1a5etf/3r18kMOOSRJcvvtt39hkFgqa6yxRvr165ckS3xf8W984xtJkjFjxtQaQP75z3/Oxx9/vET7rLqGxo8fX32tfNYHH3yQyy+/vEbbZWmXXXap/ndD3i+ltu666+b444/P17/+9Rx11FHZfPPNl8txn3/++Xz961/Pe++9l7322iu33HJLWrVqtUyPuaK9dz7v5ptvTpJ069YtHTp0aNA+rr322lxxxRVJkhNOOGGZv6aNoepn3SOPPFLnF3jmzp2ba6+9tkb7+urdu3e+9a1vZf78+Tn55JNrbdO8efMceOCBST793W1JvzCxvH8PAwDgy09gDwAAy9D8+fPz8MMPZ7/99suJJ56YJPnZz36W/fffv17b33ffffnZz36Wp556qkYoXiwW8+c//7k60OvZs2f1ug033DCFQiHvvPNOnaN7G9PLL7+cQYMG1fjD9J133pnTTz89SfKLX/yiRkiw6qqrZuedd06S/PSnP83//ve/6nWTJk3KkUceWeeoyqU5t7Zt22bIkCFJklNOOSV33nln9bq5c+dm6NChefDBB9OiRYvqvlrWBg0alI4dO+btt9/Od77znRpT/E6aNKl6dGv//v2rQ+9lqX379jnjjDOSJD/5yU9y/vnnLxI4zJgxI3/605/yy1/+snrZv//97xx99NGZMGHCIiPz//73v+f+++9Pkmy33XaLraEU/dSQ66y+Pvzww3znO9+pMb3zI488kp/97GdJkqOPPjprrrlm9bqddtopBx98cObNm5c999wzf/nLXxb5QszUqVPz61//ujpMXN5GjRqV1q1b5/rrr8/AgQMXmVL8k08+yb333puDDz64xvJBgwaloqIizz77bI455pgaX2S47777MmTIkCUeUb3TTjtV35rhO9/5To1R/2+//XYOOeSQzJw5M126dGm00eLnnXdeRo0alWnTptVYPmfOnOpbAHTo0CEbbrhhoxxveTv//PNz3333VQe9y9rLL7+c3XbbLe+8806++c1v5tZbb10uwXIp3jufdeSRR2bixImLfGZWVlbmrLPOytlnn50k1Z+H9bVw4cL885//zFFHHZXDDz88SbL//vvnJz/5SeMUvowdcsgh2XTTTbNw4cL0799/kS/2vfnmm/n2t7+dqVOnpk2bNjV+FtXXWWedlWbNmuWmm26qM1Q/5ZRTsvrqq2fChAnZf//985///KfG+gULFuThhx/O0Ucfnddff73Guo022ihJqr+kCQAAi7P8bkQGAABN3BVXXJH77rsvyad/yJ05c2amTp1a/cfgioqKnH322Rk0aFC99zlr1qxceOGFufDCC1NeXp4NNtggzZs3z2uvvZZ33303yaehd69evaq3WW211bL33nvnr3/9a7761a9miy22qL7/7gUXXJBtttmmkc74U+ecc05++ctf5rrrrssmm2ySd955pzrI2mefffLzn/98kW1+/etfp0+fPnn44YfTuXPnbLzxxpkzZ06mTJmSPfbYIzvssEP+/Oc/L7Ld0p7bSSedlGeeeSa33HJL9ttvv6y33npZa6218tJLL2XmzJlp3rx5LrnkkgYFsw2xxhpr5Kabbsq+++6b22+/Pffcc08233zzzJkzJy+88EKS5Ktf/WpGjx69XOpJkh/96Ef53//+l+HDh2fIkCE58cQTs8kmm6RVq1Z59913M3Xq1BSLxfTp06d6m08++SRXXHFFrrjiirRp0yYbbbRRysrK8vrrr1ePMu7fv38OOuigetWwvPupIddZfY0cOTIjR45Mp06dsvnmm6eysrJ6GuZevXpVT8/8WWPGjMncuXNz5513Zt99981qq62WDTfcMAsXLsx///vfvP3220mS4cOHL8VZN9xXv/rV3HLLLfnOd76Tyy+/PFdeeWV69OiRVVddNTNnzszLL7+cefPmLbLdOuusk6uuuioHHXRQrrzyytx0003ZdNNN87///S//+c9/csABB+S9997LQw89lObNm9e7nj//+c/Zfffd8+9//ztbbLFFNt1005SVleXZZ5/NvHnzsvrqq+fWW29ttPuQv/baa7nwwgvzf//3f1lnnXWy7rrr5pNPPsl//vOfzJo1Ky1atMill16asrKyRjnel8WoUaMyatSo6udV910fNWpUfve731Uvv+OOO9K7d+/q58cdd1z158S7775bY8aJz5swYUKj1ry83zuf9ac//Sl/+tOf0qZNm2y44YZp27Zt9efDvHnzUigUMmTIkPz4xz+ucx/33HNPdtpppySfBvWVlZV57bXX8uGHHyZJWrdunWHDhuXEE09Ms2ZfjjE7LVu2zB133JFvfvObef755/PVr341Xbt2zdprr53Kysq8+OKLWbhwYdq1a5drr7023bt3X+JjbLHFFjniiCNy9dVX1zpDUJKst956ufvuu7P//vvnL3/5S/7yl79kww03TMeOHTNr1qy88sor1b/ffX7WpCOPPDK/+MUv8uMf/zi///3v07FjxxQKhQwYMCADBgxY4noBAGj6BPYAANBIpk+fnunTpydJWrVqlYqKinTv3j3bbLNN+vXrl4MPPrh6mtT62nnnnfP73/8+999/f5555pnq+3p37Ngx++yzT4455pjss88+i2x39dVX55RTTsndd9+dZ599Np988kmSLJN7Ku+///7ZbrvtcuaZZ+bxxx/P7Nmzs+WWW2bgwIE57rjjag3eevXqlYcffjgjRozIxIkT8+KLL2aDDTbIqFGjMnjw4AwcOLDO4y3NubVo0SI33XRTrrvuulx++eWZNGlS3nzzzXTs2DF77bVXfvGLX+SrX/1qg1+LhujTp0+eeeaZ/PrXv84999yT5557Li1btkzPnj1z6KGH5rjjjkvr1q2Xa02/+tWvsu++++Z3v/tdxo8fnxdffDHNmjXLuuuum2984xvZa6+90r9//+r2PXr0yOWXX577778/Tz31VKZPn54PP/wwq666anbbbbcceeSROfzww1MoFOp1/OXdTw29zupj++23zxNPPJFTTz01Dz30UD744IP06NEj3/nOdzJ06NCsssoqi2zTpk2b3H777fnrX/+aK6+8Mo8//ngmT56cdu3apVOnTunXr1/23Xff5XKbhLrstddeeeGFF3LRRRflnnvuySuvvJJXX301a6+9drbffvv069evxnukyn777ZdHH300I0eOzIQJE/LMM89kww03zK9//esMHjy4+h7b5eXl9a6lU6dOeeKJJ/Lb3/42N998c1566aXMnz8/66+/fvbee+/88pe/zDrrrNNYp55jjz02HTt2zLhx4/Lyyy/nueeey8KFC9O5c+ccfPDBGTx4cLbccstGO96XxZw5c2rMmFLlo48+qjGK+fNf5pg7d271v5988sllV2Atlvd757P+9Kc/Zfz48fnHP/6RN998MzNmzEjr1q2z8cYbp3fv3hk4cOBiv5T0zjvv5J133knyadBdXl6ezp07Z+utt87OO++cww47rMHT6ZdS9+7d8/TTT+eyyy7L7bffnueeey7//Oc/06ZNm2y11VbZfffdc/zxx6dLly4NPsbIkSNzww031Hj/fV6vXr3y73//O5dccknuvPPOPP/883nttdey1lprVb/G/fv3T9euXWtsN3jw4CSf9vGUKVPy/PPPJ0n1jA4AAPB5hWJdXyUFAAAAGqRbt26ZNm1axo0bJ6SppwULFmS11VZLZWVlJk+enK222qrUJQEAAMAy9+WYDwsAAABo0m688cZUVlZm9dVXz2abbVbqcgAAAGC5ENgDAAAAy8Vdd92VG2+8scY01MViMbfddlt+9KMfJfl0yvkWLdzBDwAAgJWD/wEDAAAAy8WUKVMyePDgtGjRIt26dUuHDh3y6quv5r333kuS7Lrrrjn55JNLXCUAAAAsP0bYAwAAAMvFHnvskeOOOy6bbLJJZsyYkUmTJmXBggXZZZddcskll+Tee+9NWVlZqcsEAACA5aZQLBaLpS4CAAAAAAAAAFY2RtgDAAAAAAAAQAm4h/1SWrhwYd544420b98+hUKh1OUAAAAAAAAAUGLFYjEffvhhOnXqlGbN6h5HL7BfSm+88Ua6dOlS6jIAAAAAAAAAWMFMnz49nTt3rnO9wH4ptW/fPsmnL3R5eXmJqwEAAAAAAACg1CorK9OlS5fqPLkuAvulVDUNfnl5ucAeAAAAAAAAgGqLu6163ZPlAwAAAAAAAADLjMAeAAAAAAAAAEpAYA8AAAAAAAAAJSCwBwAAAAAAAIASENgDAAAAAAAAQAkI7AEAAAAAAACgBAT2AAAAAAAAAFACAnsAAAAAAAAAKAGBPQAAAAAAAACUgMAeAAAAAAAAAEpAYA8AAAAAAAAAJbBCBvbXXHNNfvjDH6Znz54pKytLoVDImDFjvnCbV199Ncccc0y6du2asrKyrLXWWtl1111z00031dr+2muvTa9evdK2bdt06NAhe+21V5588sllcDYAAAAAAAAAsKgWpS6gNieffHKmTZuWNdZYI+uss06mTZv2he3//ve/p3///kmSffbZJxtssEFmzJiRf/3rX7nvvvty8MEH12h/5pln5qSTTsp6662XQYMGZdasWbn++uvTu3fv3Hvvvenbt+8yOjMAAAAAAAAA+NQKGdiPHj063bt3T9euXXP22Wdn2LBhdbadPn16DjrooKy77rq57777st5669VYP3/+/BrPp0yZkuHDh6dHjx554oknUlFRkST5yU9+kl69emXgwIF54YUX0qLFCvnSAAAAAAAAANBErJBT4u+2227p2rVrvdqeeeaZqayszB/+8IdFwvokiwTvV155ZebPn5+TTjqpOqxPks033zxHHnlkXnnllTzwwANLdwIAAAAAAAAAsBhf6mHkxWIxN954Y1ZfffX069cv//znP/Pggw9m4cKF2WabbdKvX780a1bzOwnjx49Pkuyxxx6L7G/PPffMH/7whzz44IO1rgdq1+2Eu0pdQpMy9ey9S10CAAAAAAAAy8GXOrB/9dVX8/7772e77bbLsccemz/84Q811n/lK1/JnXfemc6dO1cvmzJlStq1a5e11157kf117969uk1d5s6dm7lz51Y/r6ysXNrTAAAAAAAAAGAltEJOiV9f77zzTpLkqaeeyjXXXJMrr7wy77//fl599dUcc8wxmTRpUg466KAa28ycObPGVPifVV5eXt2mLmeddVYqKiqqH126dGmkswEAAAAAAABgZfKlDuwXLlyYJFmwYEFOO+20DBgwIB06dEi3bt3yxz/+MV/72tfy+OOPZ8KECY12zGHDhmXmzJnVj+nTpzfavgEAAAAAAABYeXypA/vPjpTfd999F1m/zz77JEmefPLJGtvUNYK+anr7ukbgJ0lZWVnKy8trPAAAAAAAAABgSX2pA/uNNtoozZs3T5Ksuuqqi6yvWvbRRx9VL+vevXtmzZqVt956a5H2Vfeur7qXPQAAAAAAAAAsK1/qwL6srCw77rhjkuTf//73IuurlnXr1q16WZ8+fZIkY8eOXaT9vffeW6MNAAAAAAAAACwrX+rAPkmOPfbYJMmIESMyd+7c6uUvvPBCxowZk/bt2+cb3/hG9fKjjjoqLVq0yBlnnFFjavznnnsuV199dTbccMP069dv+Z0AAAAAAAAAACulFqUuoDajR4/OhAkTkiTPPPNM9bLx48cnSfr375/+/fsnSQ499NDceuutufnmm7P11ltnzz33zMyZM3PLLbfk448/ztVXX50OHTpU77tHjx4ZMWJETj755Gy11VY56KCDMnv27Fx33XWZN29eLrvssrRosUK+LAAAAAAAAAA0IStkMj1hwoRcddVVNZZNnDgxEydOTPLpFPdVgX2hUMh1112XHXfcMZdffnkuvfTS6qnyTzzxxFqntz/ppJPSrVu3XHDBBbnkkkvSqlWr7Ljjjhk5cmS22267ZX5+AAAAAAAAAFAoFovFUhfxZVZZWZmKiorMnDkz5eXlpS4HSqLbCXeVuoQmZerZe5e6BAAAAAAAAJZCfXPkL/097AEAAAAAAADgy0hgDwAAAAAAAAAlILAHAAAAAAAAgBIQ2AMAAAAAAABACQjsAQAAAAAAAKAEBPYAAAAAAAAAUAICewAAAAAAAAAoAYE9AAAAAAAAAJSAwB4AAAAAAAAASkBgDwAAAAAAAAAlILAHAAAAAAAAgBIQ2AMAAAAAAABACQjsAQAAAAAAAKAEBPYAAAAAAAAAUAICewAAAAAAAAAoAYE9AAAAAAAAAJSAwB4AAAAAAAAASkBgDwAAAAAAAAAlILAHAAAAAAAAgBIQ2AMAAAAAAABACQjsAQAAAAAAAKAEBPYAAAAAAAAAUAICewAAAAAAAAAoAYE9AAAAAAAAAJSAwB4AAAAAAAAASkBgDwAAAAAAAAAlILAHAAAAAAAAgBIQ2AMAAAAAAABACQjsAQAAAAAAAKAEBPYAAAAAAAAAUAICewAAAAAAAAAogRUysL/mmmvywx/+MD179kxZWVkKhULGjBlTr21fffXVtGvXLoVCIYMGDaqz3bXXXptevXqlbdu26dChQ/baa688+eSTjXQGAAAAAAAAAPDFVsjA/uSTT84f//jHTJs2Leuss069tysWiznqqKMW2+7MM8/M4YcfnrfffjuDBg3KIYcckokTJ6Z3794ZP378UlQOAAAAAAAAAPWzQgb2o0ePztSpU/Puu+9+4Sj5z7vooosyceLEnHbaaXW2mTJlSoYPH54ePXrkX//6V84999xceumleeSRR9KiRYsMHDgw8+fPb4zTAAAAAAAAAIA6rZCB/W677ZauXbsu0TYvv/xyhg0blqFDh+YrX/lKne2uvPLKzJ8/PyeddFIqKiqql2+++eY58sgj88orr+SBBx5ocO0AAAAAAAAAUB8rZGC/pBYuXJijjjoqXbt2zSmnnPKFbaumvN9jjz0WWbfnnnsmSR588MFGrxEAAAAAAAAAPqtFqQtoDBdccEEeeeSRTJgwIWVlZV/YdsqUKWnXrl3WXnvtRdZ17969uk1d5s6dm7lz51Y/r6ysbGDVAAAAAAAAAKzMvvQj7F966aWcfPLJ+elPf5oddthhse1nzpxZYyr8zyovL69uU5ezzjorFRUV1Y8uXbo0rHAAAAAAAAAAVmpf6sB+4cKFGTBgQDp16pTTTz99uRxz2LBhmTlzZvVj+vTpy+W4AAAAAAAAADQtX+op8X/729/mscceywMPPJA2bdrUa5uKioo6R9BXTW9f1wj8JCkrK1vstPsAAAAAAAAAsDhf6hH2Tz/9dIrFYnbdddcUCoXqx6677pokufTSS1MoFNK/f//qbbp3755Zs2blrbfeWmR/Vfeur7qXPQAAAAAAAAAsK1/qEfZ9+vRJixaLnsKbb76Zu+++O5tsskl69+6dr3zlKzW2efTRRzN27NgceeSRNba79957q9sAAAAAAAAAwLL0pQ7sjzrqqBx11FGLLB8/fnzuvvvu9OnTJ3/4wx8W2eY3v/lNzjjjjOy3337V098/99xzufrqq7PhhhumX79+y6V+AAAAAAAAAFZeK2RgP3r06EyYMCFJ8swzz1QvGz9+fJKkf//+Naa5XxI9evTIiBEjcvLJJ2errbbKQQcdlNmzZ+e6667LvHnzctlll9U6ah8AAAAAAAAAGtMKmUxPmDAhV111VY1lEydOzMSJE5Mk3bp1a3BgnyQnnXRSunXrlgsuuCCXXHJJWrVqlR133DEjR47MdttttzSlAwAAAAAAAEC9FIrFYrHURXyZVVZWpqKiIjNnzkx5eXmpy4GS6HbCXaUuoUmZevbepS4BAAAAAACApVDfHLnZcqwJAAAAAAAAAPj/CewBAAAAAAAAoAQE9gAAAAAAAABQAgJ7AAAAAAAAACgBgT0AAAAAAAAAlIDAHgAAAAAAAABKQGAPAAAAAAAAACUgsAcAAAAAAACAEhDYAwAAAAAAAEAJCOwBAAAAAAAAoAQE9gAAAAAAAABQAgJ7AAAAAAAAACgBgT0AAAAAAAAAlIDAHgAAAAAAAABKQGAPAAAAAAAAACUgsAcAAAAAAACAEhDYAwAAAAAAAEAJCOwBAAAAAAAAoAQE9gAAAAAAAABQAgJ7AAAAAAAAACgBgT0AAAAAAAAAlIDAHgAAAAAAAABKQGAPAAAAAAAAACUgsAcAAAAAAACAEhDYAwAAAAAAAEAJCOwBAAAAAAAAoAQE9gAAAAAAAABQAgJ7AAAAAAAAACgBgT0AAAAAAAAAlIDAHgAAAAAAAABKQGAPAAAAAAAAACXQoMD+9ddfz0MPPZQ5c+ZUL1u4cGHOOeec9O7dO7vvvnv+9re/Nbioa665Jj/84Q/Ts2fPlJWVpVAoZMyYMYu0mzdvXm655ZYMGDAgm266adq2bZv27dvna1/7Wi6++OIsWLCgzmNce+216dWrV9q2bZsOHTpkr732ypNPPtngmgEAAAAAAABgSbRoyEa/+tWvcvvtt+ftt9+uXnbGGWdk+PDh1c8ffPDBPPLII+nZs+cS7//kk0/OtGnTssYaa2SdddbJtGnTam33yiuv5KCDDkr79u3Tr1+/7Lvvvpk5c2b+8pe/5Ljjjsvf/va33HHHHSkUCjW2O/PMM3PSSSdlvfXWy6BBgzJr1qxcf/316d27d+6999707dt3iWsGgKXR7YS7Sl1CkzL17L1LXQIAAAAAACxWg0bYP/roo9ltt93SsmXLJJ+Orr/ooouyySab5LXXXssTTzyRNm3a5De/+U2Diho9enSmTp2ad999N4MGDaqzXfv27XPxxRfnrbfeyu23355zzjknf/jDH/LSSy+lZ8+e+ctf/pKbb765xjZTpkzJ8OHD06NHj/zrX//Kueeem0svvTSPPPJIWrRokYEDB2b+/PkNqhsAAAAAAAAA6qtBgf2bb76Zbt26VT9/6qmn8t577+X4449P586d07Nnz/Tv3z+PP/54g4rabbfd0rVr18W2W3fddXPsscemTZs2NZa3bds2Q4YMSfLpSP/PuvLKKzN//vycdNJJqaioqF6++eab58gjj8wrr7ySBx54oEF1AwAAAAAAAEB9NSiwX7BgQRYuXFj9/OGHH06hUEi/fv2ql6277rp56623lr7CBqoa/d+iRc1Z/8ePH58k2WOPPRbZZs8990yyaMj/WXPnzk1lZWWNBwAAAAAAAAAsqQYF9uutt16eeOKJ6ue333571llnnWy88cbVy956662suuqqS11gQ11xxRVJFg3mp0yZknbt2mXttddeZJvu3btXt6nLWWedlYqKiupHly5dGrFqAAAAAAAAAFYWDQrsDzzwwEycODEHH3xwvvvd72bChAk54IADarR59tlns8EGGzRKkUvqj3/8Y+65557069cve+21V411M2fOrDEV/meVl5dXt6nLsGHDMnPmzOrH9OnTG69wAAAAAAAAAFYaLRbfZFG/+MUvMnbs2Nxyyy1Jki233DIjRoyoXv/888/nH//4R4YNG9YoRS6Ju+66Kz/+8Y/TtWvXXHPNNY2+/7KyspSVlTX6fgEAAAAAAABYuTQosC8vL89jjz2WZ599Nkmy6aabpnnz5tXrV1llldx2223p2bNn41RZT/fee28OPPDArLXWWnnggQeyzjrrLNKmoqKizhH0Vfejr2sEPgAAAAAAAAA0lgYF9lW22GKLWpd369Yt3bp1W5pdL7G//e1v2X///bPGGmtk3LhxdU7H37179zz66KN56623FrmPfdW966vuZQ8AAAAAAAAAy0qD7mG/ovnb3/6W/v37p0OHDhk3blw22mijOtv26dMnSTJ27NhF1t1777012gAAAAAAAADAstLgwP6+++7LXnvtlY4dO6Zly5Zp3rz5Io8WLZZqAH+9fD6sX9zo+KOOOiotWrTIGWecUWNq/Oeeey5XX311Ntxww/Tr129Zlw0AAAAAAADASq5Bifott9ySb3/721m4cGG6du2aTTbZpFHD+dGjR2fChAlJkmeeeaZ62fjx45Mk/fv3T//+/fPCCy+kf//+mTt3bvr27ZvrrrtukX1169YtAwYMqH7eo0ePjBgxIieffHK22mqrHHTQQZk9e3auu+66zJs3L5dddtly+aIBAAAAAAAAACu3BiXTI0eOzCqrrJI77rhjmYxGnzBhQq666qoayyZOnJiJEycm+TSE79+/f956663MnTs3SXL99dfXuq8+ffrUCOyT5KSTTkq3bt1ywQUX5JJLLkmrVq2y4447ZuTIkdluu+0a/XwAAAAAAAAA4PMKxWKxuKQbtW7dOt/97ndz2WWXLYuavlQqKytTUVGRmTNnpry8vNTlQEl0O+GuUpfQpEw9e+9Sl0AJuI4al+sIAAAAAIBSqm+O3KB72K+xxhpp06ZNg4sDAAAAAAAAgJVdgwL7Qw45JPfdd1/mz5/f2PUAAAAAAAAAwEqhQYH96aefng4dOuTb3/52XnvttcauCQAAAAAAAACavBYN2WiLLbbIvHnz8uijj+b222/PqquumoqKikXaFQqFvPLKK0tdJAAAAAAAAAA0NQ0K7BcuXJgWLVpkvfXWq15WLBYXaVfbMgAAAAAAAACggYH91KlTG7kMAAAAAAAAAFi5NOge9gAAAAAAAADA0mnQCPvPmj9/fl566aXMnDkz5eXl2XjjjdOixVLvFgAAAAAAAACatAaPsJ8xY0Z+8IMfZNVVV82WW26ZnXbaKVtttVVWXXXV/OAHP8j//ve/xqwTAAAAAAAAAJqUBg2FnzFjRnbYYYe89NJLWX311bPzzjtn7bXXzttvv50nn3wyo0ePzoMPPphHH300q622WmPXDAAAAAAAAABfeg0aYX/aaaflpZdeyrBhwzJt2rTcc889ufLKK3P33Xdn2rRpOemkkzJlypScfvrpjV0vAAAAAAAAADQJDQrsb7/99uy6664544wz0qZNmxrrVllllZx22mnp169fbr/99saoEQAAAAAAAACanAYF9m+88Ua23377L2zzta99LW+88UaDigIAAAAAAACApq5BgX1FRUWmTZv2hW2mTZuWioqKBhUFAAAAAAAAAE1dgwL7vn375qabbsp9991X6/r7778/N910U/r27bs0tQEAAAAAAABAk9WiIRsNHz48d911V/bcc8/stdde6dOnT9Zaa628/fbbGT9+fO655560adMmp5xySmPXCwAAtep2wl2lLqFJmXr23qUuAQAAAACavAYF9ptttlnGjh2bAQMG5K677spdd92VQqGQYrGYJNlwww0zZsyYbL755o1aLAAAAAAAAAA0FQ0K7JNkxx13zIsvvpiJEydm0qRJqaysTHl5eb7yla+kd+/eKRQKjVknAAAAAAAAADQpDQ7sk6RQKGSnnXbKTjvt1Fj1AAAAAAAAAMBKoVmpCwAAAAAAAACAlVG9RtiPHDkyhUIhxx13XFZbbbWMHDmyXjsvFAr51a9+tVQFAgAAAAAAAEBTVK/AfsSIESkUCvn2t7+d1VZbLSNGjKjXzgX2AAAAAAAAAFC7egX248aNS5Kst956NZ4DAAAAAAAAAA1Tr8C+T58+X/gcAAAAAAAAAFgyzUpdAAAAAAAAAACsjBoU2D/33HO5+uqrU1lZWb3so48+yrHHHpt111033bt3z2WXXdZoRQIAAAAAAABAU9OgwP6MM87ICSeckPbt21cvO/HEE3PppZfmww8/zGuvvZZBgwbl/vvvb7RCAQAAAAAAAKApaVBg/8QTT2TXXXdNoVBIksybNy9XXHFFevXqlXfeeSevvvpqOnbsmPPPP79RiwUAAAAAAACApqJBgf3bb7+d9dZbr/r5448/ng8//DCDBg1K69at06lTp+y3336ZPHlyoxUKAAAAAAAAAE1JgwL75s2bZ+7cudXPH3744RQKhey6667Vy1ZfffW89957S18hAAAAAAAAADRBDQrsu3XrlnHjxlU/v/nmm7P++uuna9eu1ctef/31rL766g0q6pprrskPf/jD9OzZM2VlZSkUChkzZkyd7SsrKzNkyJB07do1ZWVl6dq1a4YMGZLKyso6t7n22mvTq1evtG3bNh06dMhee+2VJ598skH1AgAAAAAAAMCSalBg/93vfjeTJ0/O9ttvn1122SVPP/10DjvssBptnnrqqXTv3r1BRZ188sn54x//mGnTpmWdddb5wrazZ89Onz59cv7552fjjTfO4MGDs9lmm+X8889Pnz59Mnv27EW2OfPMM3P44Yfn7bffzqBBg3LIIYdk4sSJ6d27d8aPH9+gmgEAAAAAAABgSTQosP/xj3+cgw8+OP/4xz8yYcKE7LnnnjnxxBOr1//jH//Ic889l379+jWoqNGjR2fq1Kl59913M2jQoC9sO2rUqDz99NMZOnRoxo4dm7PPPjv33HNPTjnllDz99NMZNWpUjfZTpkzJ8OHD06NHj/zrX//Kueeem0svvTSPPPJIWrRokYEDB2b+/PkNqhsAAAAAAAAA6qtBgX1ZWVluuOGGzJgxIzNnzszdd9+dVVZZpXr9+uuvn0mTJuUnP/lJg4rabbfdakyvX5disZjRo0enXbt2OeWUU2qsGzZsWDp06JDLL788xWKxevmVV16Z+fPn56STTkpFRUX18s033zxHHnlkXnnllTzwwAMNqhsAAAAAAAAA6qtBgX2V8vLytG/ffpHla6yxRrbeeusagfiyMGXKlLzxxhvp3bt32rZtW2Nd69ats8suu+T111/Pyy+/XL28asr7PfbYY5H97bnnnkmSBx98cNkVDQAAAAAAAABJWizNxpMmTcp1112XF154IXPmzMl9992XJJk2bVoef/zx7LbbbllttdUapdDaTJkyJUnSvXv3WtdXLZ8yZUqNf7dr1y5rr732F7avy9y5czN37tzq55WVlQ0rHgAAAAAAAICVWoNH2A8dOjQ9e/bMb37zm/z1r3/NuHHjqtcVi8V85zvfyZ/+9KdGKbIuM2fOTJI6R/KXl5fXaFf17yVp/3lnnXVWKioqqh9dunRpUO0AAAAAAAAArNwaFNhfeeWV+c1vfpNvfetb+de//pVhw4bVWN+tW7f06tUrd955Z6MUuSIZNmxYZs6cWf2YPn16qUsCAAAAAAAA4EuoQVPiX3zxxdl0001zyy23pEWLFmnVqtUibTbZZJPqKfKXlaqR8nWNiK+arv6zI+orKiqWqP3nlZWVpaysrEH1AgAAAAAAAECVBo2w//e//53dd989LVrUnfevtdZaeeeddxpcWH0s7p7ztd3jvnv37pk1a1beeuuterUHAAAAAAAAgGWhQYF9ixYt8sknn3xhmzfeeCPt2rVrUFH11b1793Tq1CkTJ07M7Nmza6z7+OOP89BDD6VTp07ZaKONqpf36dMnSTJ27NhF9nfvvffWaAMAAAAAAAAAy0qDAvstt9wy48aNy8KFC2tdP2fOnNx3333Zdtttl6q4xSkUChk4cGBmzZqVkSNH1lh31llnZcaMGRk4cGAKhUL18qOOOiotWrTIGWecUWNq/Oeeey5XX311Ntxww/Tr12+Z1g0AAAAAAAAADbqH/fe///0MHDgwxx57bC666KIa6yorKzNw4MC89dZbufDCCxtU1OjRozNhwoQkyTPPPFO9bPz48UmS/v37p3///kmSoUOH5s4778yoUaMyadKkbLvttpk8eXLuueeebLPNNhk6dGiNfffo0SMjRozIySefnK222ioHHXRQZs+eneuuuy7z5s3LZZdd9oVT/QMAAAAAAABAY2hwYH///ffnsssuy3XXXZdVV101SdKrV688//zzmT17dgYMGJCDDjqoQUVNmDAhV111VY1lEydOzMSJE5Mk3bp1qw7s27Ztm/Hjx+fUU0/NzTffnPHjx2fttdfO4MGDM3z48LRt23aR/Z900knp1q1bLrjgglxyySVp1apVdtxxx4wcOTLbbbddg2oGAAAAAAAAgCVRKBaLxYZufNlll+V3v/tdnn322VTtZtNNN81PfvKT/PCHP2y0IldklZWVqaioyMyZM1NeXl7qcqAkup1wV6lLaFKmnr13qUugBFxHjct1tHJyHTUu1xEAAAAANFx9c+Slmvv9mGOOyTHHHJOPPvooM2bMSHl5edq1a7c0uwRgGRBiNS4hFgAAAAAA0Bga5Wbtq6yySlZZZZXG2BUAAAAAAAAArBSalboAAAAAAAAAAFgZ1WuE/QYbbNCgnRcKhbzyyisN2hYAAAAAAAAAmrJ6BfYLFy5MoVBY4p0Xi8Ul3gYAAAAAAAAAVgb1CuynTp26jMsAAFixdTvhrlKX0KRMPXvvUpcAAAAAAFBy7mEPAAAAAAAAACUgsAcAAAAAAACAEhDYAwAAAAAAAEAJCOwBAAAAAAAAoAQE9gAAAAAAAABQAgJ7AAAAAAAAACiBegX2I0eOzEMPPbSsawEAAAAAAACAlUa9AvsRI0Zk/Pjx1c+bN2+e0047bVnVBAAAAAAAAABNXr0C+7Zt2+ajjz6qfl4sFlMsFpdZUQAAAAAAAADQ1LWoT6ONNtoot912Ww444ICstdZaSZIPPvggr7322mK3XW+99ZauQgAAAAAAAABoguoV2P/85z/PkUceme2337562YUXXpgLL7zwC7crFAqZP3/+0lUIAAAAAAAAAE1QvQL7I444IhtuuGHuvvvuvP766xkzZky22mqrbLPNNsu4PAAAAAAAAABomuoV2CfJDjvskB122CFJMmbMmOy///455ZRTlllhAABA09LthLtKXUKTMfXsvUtdAgAAAACNoN6B/WeNGzcu3bp1a+RSAAAAAAAAAGDl0aDAvk+fPjWez549O5WVlSkvL0/btm0bpTAAAAAAAAAAaMqaNXTDefPm5cwzz0yPHj1SXl6ezp07p7y8PN27d8+ZZ56ZTz75pDHrBAAAAAAAAIAmpUEj7D/66KPsvvvuefTRR9O8efP06NEja6+9dt5+++288sor+dWvfpW//vWvuf/++7PKKqs0ds0AAAAAAAAA8KXXoBH2o0aNyiOPPJLDDjss//nPf/L8889n3Lhx+fe//51XX301hx9+eB577LGMGjWqsesFAAAAAAAAgCahQYH99ddfn549e+aaa65J586da6zr1KlTrr766vTs2TPXX399oxQJAAAAAAAAAE1NgwL7qVOnZrfddvvCNl//+tczderUhuweAAAAAAAAAJq8BgX2bdq0ybvvvvuFbd599920adOmQUUBAAAAAAAAQFPXoMB+++23z/XXX5/nnnuu1vX//ve/c8MNN2SHHXZYquIAAAAAAAAAoKlq0ZCNTjrppPz973/Pdtttl6OPPjp9+vTJWmutlbfffjvjx4/PlVdemXnz5mXYsGGNXS8AAAAAAAAANAkNCux33HHHXHfddRk4cGB+//vf5+KLL65eVywWU1FRkauuuiq9e/dutEIBAAAAAAAAoClpUGCfJAceeGD23HPP3H777Zk0aVIqKytTXl6er3zlK9lvv/3Svn37xqwTAAAAAAAAAJqUBgf2SdKuXbscccQROeKIIxqrngYpFou57bbbctFFF+WFF17IzJkz06VLl/Tt2zf/93//lw022KBG+8rKyowYMSK33HJL3nrrray99to58MADM2LEiJSXl5foLAAAAAAAAABYmTQrdQGN4Re/+EUOPPDAvPjii+nfv3+OP/74rL/++rnsssuyzTbb5Nlnn61uO3v27PTp0yfnn39+Nt544wwePDibbbZZzj///PTp0yezZ88u4ZkAAAAAAAAAsLJYqhH2K4K33norF1xwQbp165bJkyfXGCF/wQUXZPDgwTnvvPNyxRVXJElGjRqVp59+OkOHDs0555xT3Xb48OEZOXJkRo0alVNPPXW5nwcAAAAAAAAAK5cv/Qj7qVOnZuHChendu/ci09nvvffeSZJ33nknyadT548ePTrt2rXLKaecUqPtsGHD0qFDh1x++eUpFovLp3gAAAAAAAAAVlpf+sC+e/fuadWqVSZOnJgPP/ywxrq77747SdKvX78kyZQpU/LGG2+kd+/eadu2bY22rVu3zi677JLXX389L7/88vIpHgAAAAAAAICV1pd+SvzVV189Z5xxRn75y19m0003zb777pv27dvnmWeeyX333Zcf/OAHOf7445N8Gtgnn4b8talaPmXKlDrbzJ07N3Pnzq1+XllZ2ZinAwAAAAAAAMBK4ksf2CfJL37xi3Tq1Ck//OEPc8kll1Qv33HHHXPEEUekZcuWSZKZM2cmSSoqKmrdT9WU+lXtanPWWWe5xz0AAAAAAAAAS61BU+I3b948hx9+eGPX0mCnn356BgwYkGHDhmX69OmZNWtWJkyYkPnz52fXXXfNrbfe2mjHGjZsWGbOnFn9mD59eqPtGwAAAAAAAICVR4MC+/Ly8nTp0qWxa2mQBx54IL/61a/y4x//OCeeeGI6d+6ctm3bpnfv3vnrX/+aVVZZJYMHD07y/0bW1zWCvmp6+7pG4CdJWVlZysvLazwAAAAAAAAAYEk1KLDv1atXJk+e3Ni1NMhdd92VJNl1110XWdexY8dsueWWee211/Lee+/VuEd9bRZ3j3sAAAAAAAAAaCwNuof9qaeemj59+uSqq67K9773vcauaYl88sknSZJ333231vVVy8vKytK9e/d06tQpEydOzOzZs9O2bdvqdh9//HEeeuihdOrUKRtttNGyLxwAAACWQLcT7ip1CU3K1LP3LnUJAAAA0LDAfuzYsenbt2++//3v56KLLkqvXr2y1lprpVAo1GhXKBTyq1/9qlEKrUvv3r3zu9/9Luedd14OPPDAGtPZX3XVVXn55Zez7bbbpn379kmSgQMHZuTIkRk5cmTOOeec6rZnnXVWZsyYkeOPP36R8wAAAAAAAACAxtagwH7EiBHV/37qqafy1FNP1dpueQT2Bx98cC699NKMHz8+3bt3z7777psOHTpk8uTJ+fvf/56ysrJccMEF1e2HDh2aO++8M6NGjcqkSZOy7bbbZvLkybnnnnuyzTbbZOjQocu0XgAAAAAAAABIGhjYjxs3rrHraLDmzZvnb3/7Wy688MLccMMNue666/LJJ59krbXWyne+850MGzYsW2yxRXX7tm3bZvz48Tn11FNz8803Z/z48Vl77bUzePDgDB8+vMY0+QAAAAAAAACwrDQosO/Tp09j17FUysrKMnTo0HqPjq+oqMh5552X8847bxlXBgAAAAAAAAC1a1bqAgAAAAAAAABgZdTgwH7+/Pk5//zz06tXr5SXl6dFi/83WP/pp5/Oj370o7z00kuNUiQAAAAAAAAANDUNmhL/o48+yh577JFHHnkka6yxRsrLyzN79uzq9euvv36uvPLKrLbaajn99NMbrVgAAAAAAAAAaCoaNML+zDPPzMSJE3PWWWflrbfeysCBA2usr6ioSJ8+fXLvvfc2SpEAAAAAAAAA0NQ0KLC/4YYb0rdv3wwdOjSFQiGFQmGRNhtssEFee+21pS4QAAAAAAAAAJqiBgX2r732WrbbbrsvbFNeXp6ZM2c2qCgAAAAAAAAAaOoaFNi3b98+77777he2eeWVV9KxY8cGFQUAAAAAAAAATV2DAvvtt98+f/nLX+ocQf/f//43d999d3bZZZelKg4AAAAAAAAAmqoGBfa//OUv8/7772e33XbLI488kvnz5ydJ5syZk/vvvz977LFH5s2blyFDhjRqsQAAAAAAAADQVLRoyEa77LJLfv/73+cnP/lJdt555+rl7du3T5I0b948F198cbbddtvGqRIAAAAAAAAAmpgGBfZJMmjQoPTp0yd/+MMf8vjjj+f9999PeXl5vva1r+VHP/pRNt9888asEwAAAAAAAACalAYH9kmy6aab5sILL2ysWgAAAAAAAABgpdGge9gDAAAAAAAAAEtnqUbYT5w4MVdddVWefvrpzJw5MxUVFdlmm21y5JFHZqeddmqsGgEAAAAAAACgyWlQYF8sFvOjH/0of/zjH1MsFpMkzZo1y8KFC/Pkk0/m8ssvzw9+8INcfPHFKRQKjVowAAAAAAAAADQFDZoS/9xzz82ll16aLbbYIjfddFPeeuutzJ8/P2+99VZuvPHGbL755vnjH/+Y8847r7HrBQAAAAAAAIAmoUGB/R//+Mesv/76efTRR3PggQdmzTXXTJKsueaaOeigg/LII4+ka9euufTSSxu1WAAAAAAAAABoKhoU2E+fPj0HHHBA2rRpU+v6du3a5YADDsj06dOXqjgAAAAAAAAAaKoaFNh37tw5H3/88Re2mTt3bjp37tygogAAAAAAAACgqWtQYP/9738/N954Y95+++1a17/55pu54YYbMnDgwKUqDgAAAAAAAACaqhb1afTaa6/VeH7ooYfm0UcfzVe+8pX89Kc/zU477ZQ111wz77zzTh5++OH89re/zQ477JBDDjlkmRQNAAAAAAAAAF929Qrsu3XrlkKhsMjyYrGYE088sdblf/nLX3LXXXdl/vz5S18lAAAAAAAAADQx9QrsjzzyyFoDewAAAAAAAACgYeoV2I8ZM2YZlwEAAAAAAAAAK5dmpS4AAAAAAAAAAFZGAnsAAAAAAAAAKIEGB/aPPPJI9t9//2ywwQYpKytL8+bNF3m0aFGvGfcBAAAAAAAAYKXToET9mmuuyfe+970Ui8VssMEG6dWrl3AeAAAAAAAAAJZAg1L20047LR06dMg999yT7bbbrrFrAgAAAAAAAIAmr0FT4r/22ms59NBDhfUAAAAAAAAA0EANCuy7deuWTz75pLFrWWq33XZbdt9996y++upZZZVVsv766+ewww7L9OnTa7SrrKzMkCFD0rVr15SVlaVr164ZMmRIKisrS1Q5AAAAAAAAACubBk2JP2jQoJxzzjl5//33s9pqqzV2TUusWCxm0KBB+eMf/5gNN9wwhx56aNq3b5833ngjDz74YKZNm5YuXbokSWbPnp0+ffrk6aefzu67757DDjsskydPzvnnn59x48ZlwoQJadu2bYnPCAAAAAAAAICmrkGB/U9/+tO8/PLL6d27d04++eRsvfXWKS8vr7Xteuutt1QF1sdFF12UP/7xjznuuONy4YUXpnnz5jXWz58/v/rfo0aNytNPP52hQ4fmnHPOqV4+fPjwjBw5MqNGjcqpp566zGsGAAAAAAAAYOXWoCnxk2SbbbbJW2+9lSOPPDJbb7111l9//UUeG2ywQWPWWquPPvoop556ajbYYINccMEFi4T1SdKixaffSygWixk9enTatWuXU045pUabYcOGpUOHDrn88stTLBaXed0AAAAAAAAArNwaNML+oosuys9+9rO0bNkyu+66a9ZZZ53qUHx5+/vf/573338/AwYMyIIFC3LnnXfmpZdeyqqrrprddtstG220UXXbKVOm5I033siee+65yLT3rVu3zi677JI77rgjL7/8crp37768TwUAAAAAAACAlUiDUvbzzz8/6667bh555JF07ty5sWtaIk8++WSST0fRb7311nnxxRer1zVr1iyDBw/Ob37zmySfBvZJ6gzjq5ZPmTKlzjZz587N3Llzq59XVlYu/UkAAAAAAAAAsNJp0JT4b731Vg488MCSh/VJ8s477yRJzj333JSXl+eJJ57Ihx9+mIceeig9evTIueeem0suuSRJMnPmzCRJRUVFrfsqLy+v0a42Z511VioqKqofXbp0aczTAQAAAAAAAGAl0aDAfqONNsoHH3zQyKU0zMKFC5MkrVq1yu23357tttsu7dq1y84775ybb745zZo1y7nnnttoxxs2bFhmzpxZ/Zg+fXqj7RsAAAAAAACAlUeDAvvBgwfnjjvuyLRp0xq7niVWNVq+Z8+e6dSpU411m2++eTbYYIO88sor+eCDD6rb1jWCvmp6+7pG4CdJWVlZysvLazwAAAAAAAAAYEk16B72G264Yfr06ZOePXvmpz/9abbZZps6g+tddtllqQpcnI033jhJsuqqq9a6vmr5Rx99VOMe9bVZ3D3uAQAAAAAAAKCxNCiw79u3bwqFQorFYk455ZQUCoU62y5YsKDBxdXHrrvumiR5/vnnF1k3b968vPzyy2nbtm06duyYtddeO506dcrEiRMze/bstG3btrrtxx9/nIceeiidOnXKRhtttExrBgAAAAAAAIAGBfaLC+mXpw033DB77LFHxo4dm9GjR2fgwIHV684+++x88MEHOeKII9KixaenOnDgwIwcOTIjR47MOeecU932rLPOyowZM3L88cevMOcGAAAAAAAAQNPVoMB+xIgRjVzG0rn44ouz44475phjjsntt9+eTTbZJJMmTcoDDzyQrl275te//nV126FDh+bOO+/MqFGjMmnSpGy77baZPHly7rnnnmyzzTYZOnRoCc8EAAAAAAAAgJVFs1IX0Bg23HDDPPnkkxkwYED++c9/5re//W2mTJmS4447Lk888UTWXnvt6rZt27bN+PHjM3jw4Lzwwgs599xz8+yzz2bw4MEZP358jWnyAQAAAAAAAGBZadAI+xVRly5dcuWVV9arbUVFRc4777ycd955y7gqAAAAAAAAAKhdgwL7Zs2a1es+74VCIfPnz2/IIQAAAAAAAACgSWtQYL/LLrvUGtjPnDkzU6ZMyezZs7P11ltn1VVXXdr6AAAAAAAAAKBJalBgP378+DrXzZkzJyeccEL+9re/ZezYsQ2tCwAAAAAAAACatGaNvcM2bdrkt7/9bSoqKjJ06NDG3j0AAAAAAAAANAmNHthX2XnnnXPXXXctq90DAAAAAAAAwJfaMgvs33333cyaNWtZ7R4AAAAAAAAAvtQaPbBfuHBh/vSnP+WGG27INtts09i7BwAAAAAAAIAmoUVDNtpggw1qXT5//vy88847mTdvXlq0aJEzzzxzqYoDAAAAAAAAgKaqQYH9woULUygUFlnesmXLbLHFFunZs2d+/OMfZ4sttljqAgEAAAAAAACgKWpQYD916tRGLgMAAAAAAAAAVi6Nfg97AAAAAAAAAGDxBPYAAAAAAAAAUAL1nhL/Rz/60RLvvFAo5Pe///0SbwcAAAAAAAAATV29A/s//OEP9d5poVCo/rfAHgAAAAAAAAAWVe/Afty4cfVq99prr2XkyJF55ZVXagT3AAAAAAAAAMD/U+/Avk+fPl+4fsaMGTnzzDPz+9//Ph9//HF22GGHnHPOOUtdIAAAAAAAAAA0RfUO7Ovy8ccf54ILLsioUaPywQcfZJNNNsmZZ56Z/v37N0J5AAAAAF8O3U64q9QlNClTz9671CUAAAAsc80aumGxWMzo0aPTvXv3nHjiiWnTpk3++Mc/5tlnnxXWAwAAAAAAAMBiNGiE/e23354TTzwxL774YsrLy3PmmWfmZz/7WVq3bt3Y9QEAAAAAAABAk7REgf2ECRPyf//3f3nsscfSqlWrDB48OCeddFI6dOiwrOoDAAAAAAAAgCap3oH9vvvum7vuuivNmjXL9773vYwcOTKdO3delrUBAAAAAAAAQJNV78D+r3/9awqFQtZbb7289dZb+cEPfrDYbQqFQu66666lKhAAAAAAgBVDtxP8vbexTD1771KXAACsAJZoSvxisZhXX301r776ar3aFwqFBhUFAAAAAAAAAE1dvQP7+ob0AAAAAAAAAMDi1Tuw79q167KsAwAAAAAAAABWKs1KXQAAAAAAAAAArIwE9gAAAAAAAABQAgJ7AAAAAAAAACgBgT0AAAAAAAAAlIDAHgAAAAAAAABKQGAPAAAAAAAAACXQJAP7UaNGpVAopFAo5LHHHqu1TWVlZYYMGZKuXbumrKwsXbt2zZAhQ1JZWbmcqwUAAAAAAABgZdTkAvvnn38+p5xyStq2bVtnm9mzZ6dPnz45//zzs/HGG2fw4MHZbLPNcv7556dPnz6ZPXv2cqwYAAAAAAAAgJVRkwrsFyxYkO9973vZeuuts//++9fZbtSoUXn66aczdOjQjB07NmeffXbuueeenHLKKXn66aczatSo5Vg1AAAAAAAAACujJhXYn3POOZk8eXKuuOKKNG/evNY2xWIxo0ePTrt27XLKKafUWDds2LB06NAhl19+eYrF4vIoGQAAAAAAAICVVJMJ7J999tmceuqpOfnkk7P55pvX2W7KlCl544030rt370WmzW/dunV22WWXvP7663n55ZeXdckAAAAAAAAArMSaRGA/f/78DBgwIJtuumlOOOGEL2w7ZcqUJEn37t1rXV+1vKrd582dOzeVlZU1HgAAAAAAAACwpJpEYH/mmWdWT4XfsmXLL2w7c+bMJElFRUWt68vLy2u0+7yzzjorFRUV1Y8uXbosReUAAAAAAAAArKy+9IH95MmTc/rpp+cXv/hFvvrVry7z4w0bNiwzZ86sfkyfPn2ZHxMAAAAAAACApqdFqQtYWt/73vey4YYbZsSIEfVqXzWyvq4R9FVT3Nc1Ar+srCxlZWVLXigAAAAAAAAAfMaXPrCfPHlykqR169a1rt9hhx2SJLfddlv69++/2HvUL+4e9wAAAAAAAADQGL70gf3RRx9d6/KHHnooU6ZMyb777puOHTumW7duST4N4jt16pSJEydm9uzZadu2bfU2H3/8cR566KF06tQpG2200fIoHwAAAAAAAICV1Jc+sB89enStywcMGJApU6Zk2LBh2X777auXFwqFDBw4MCNHjszIkSNzzjnnVK8766yzMmPGjBx//PEpFArLvHYAAAAAAAAAVl5f+sC+IYYOHZo777wzo0aNyqRJk7Lttttm8uTJueeee7LNNttk6NChpS4RAAAAAAAAgCauWakLKIW2bdtm/PjxGTx4cF544YWce+65efbZZzN48OCMHz++xjT5AAAAAAAAALAsNNkR9mPGjMmYMWPqXF9RUZHzzjsv55133vIrCgAAAAAAAAD+fyvlCHsAAAAAAAAAKDWBPQAAAAAAAACUgMAeAAAAAAAAAEpAYA8AAAAAAAAAJSCwBwAAAAAAAIASENgDAAAAAAAAQAkI7AEAAAAAAACgBAT2AAAAAAAAAFACAnsAAAAAAAAAKAGBPQAAAAAAAACUgMAeAAAAAAAAAEpAYA8AAAAAAAAAJSCwBwAAAAAAAIASENgDAAAAAAAAQAkI7AEAAAAAAACgBAT2AAAAAAAAAFACAnsAAAAAAAAAKAGBPQAAAAAAAACUgMAeAAAAAAAAAEpAYA8AAAAAAAAAJSCwBwAAAAAAAIASENgDAAAAAAAAQAkI7AEAAAAAAACgBFqUugAAAAAAAICVQbcT7ip1CU3K1LP3LnUJAEvNCHsAAAAAAAAAKAGBPQAAAAAAAACUgMAeAAAAAAAAAEpAYA8AAAAAAAAAJSCwBwAAAAAAAIASENgDAAAAAAAAQAl86QP7119/PRdccEH22GOPrLfeemnVqlXWXnvtHHjggXn88cdr3aaysjJDhgxJ165dU1ZWlq5du2bIkCGprKxcztUDAAAAAAAAsLL60gf2F110UQYPHpz//Oc/2X333fPzn/88O+20U+64447suOOOufHGG2u0nz17dvr06ZPzzz8/G2+8cQYPHpzNNtss559/fvr06ZPZs2eX6EwAAAAAAAAAWJm0KHUBS6tXr1556KGHsvPOO9dY/vDDD+frX/96jj322Oy3334pKytLkowaNSpPP/10hg4dmnPOOae6/fDhwzNy5MiMGjUqp5566nI9BwAAAAAAAABWPl/6EfYHHHDAImF9kuy8887Zdddd8/777+eZZ55JkhSLxYwePTrt2rXLKaecUqP9sGHD0qFDh1x++eUpFovLpXYAAAAAAAAAVl5f+sD+i7Rs2TJJ0qLFpxMJTJkyJW+88UZ69+6dtm3b1mjbunXr7LLLLnn99dfz8ssvL/daAQAAAAAAAFi5NNnA/rXXXst9992XtddeO1tuuWWSTwP7JOnevXut21Qtr2pXm7lz56aysrLGAwAAAAAAAACWVJMM7OfNm5fvfve7mTt3bkaNGpXmzZsnSWbOnJkkqaioqHW78vLyGu1qc9ZZZ6WioqL60aVLl0auHgAAAAAAAICVQZML7BcuXJjvf//7eeihh3LMMcfku9/9bqPuf9iwYZk5c2b1Y/r06Y26fwAAAAAAAABWDi1KXUBjKhaLOeaYY3LNNdfkiCOOyB/+8Ica66tG1tc1gr5qevu6RuAnSVlZWcrKyhqpYgAAAAAAAABWVk1mhP3ChQtz9NFH54orrshhhx2WMWPGpFmzmqe3uHvUL+4e9wAAAAAAAADQWJpEYL9w4cIMHDgwV155Zb797W/nT3/6U/V96z+re/fu6dSpUyZOnJjZs2fXWPfxxx/noYceSqdOnbLRRhstr9IBAAAAAAAAWEl96QP7qpH1V155ZQ4++OBcc801tYb1SVIoFDJw4MDMmjUrI0eOrLHurLPOyowZMzJw4MAUCoXlUToAAAAAAAAAK7Ev/T3sR44cmTFjxqRdu3bp0aNHTj/99EXa9O/fP9tss02SZOjQobnzzjszatSoTJo0Kdtuu20mT56ce+65J9tss02GDh26nM8AAAAAAAAAgJXRlz6wnzp1apJk1qxZOeOMM2pt061bt+rAvm3bthk/fnxOPfXU3HzzzRk/fnzWXnvtDB48OMOHD0/btm2XU+UAAAAAAAAArMy+9IH9mDFjMmbMmCXapqKiIuedd17OO++8ZVMUAAAAAAAAACzGl/4e9gAAAAAAAADwZSSwBwAAAAAAAIASENgDAAAAAAAAQAkI7AEAAAAAAACgBAT2AAAAAAAAAFACAnsAAAAAAAAAKAGBPQAAAAAAAACUgMAeAAAAAAAAAEpAYA8AAAAAAAAAJSCwBwAAAAAAAIASENgDAAAAAAAAQAkI7AEAAAAAAACgBAT2AAAAAAAAAFACAnsAAAAAAAAAKAGBPQAAAAAAAACUgMAeAAAAAAAAAEpAYA8AAAAAAAAAJSCwBwAAAAAAAIASENgDAAAAAAAAQAkI7AEAAAAAAACgBAT2AAAAAAAAAFACLUpdAAAAAAAAAKwIup1wV6lLaFKmnr13qUuAFZ4R9gAAAAAAAABQAgJ7AAAAAAAAACgBgT0AAAAAAAAAlIDAHgAAAAAAAABKQGAPAAAAAAAAACUgsAcAAAAAAACAEhDYAwAAAAAAAEAJCOwBAAAAAAAAoAQE9gAAAAAAAABQAit1YP+Pf/wje+21Vzp06JC2bdumV69eufbaa0tdFgAAAAAAAAArgRalLqBUxo8fnz333DOtWrXKoYcemoqKitx66605/PDDM3Xq1Jx44omlLhEAAAAAAACAJmylHGE/f/78DBw4MIVCIQ899FAuu+yy/OY3v8nkyZOz+eabZ/jw4ZkyZUqpywQAAAAAAACgCVspR9g/8MADeeWVV3LUUUflK1/5SvXy9u3b51e/+lUOPfTQXHnllTnzzDNLWCVVup1wV6lLaFKmnr13qUsAAAAAAJYBf0ttXP6WCsDysFKOsB8/fnySZI899lhkXdWyBx98cHmWBAAAAAAAAMBKZqUcYV813X337t0XWdehQ4esscYadU6JP3fu3MydO7f6+cyZM5MklZWVy6BSkmTh3DmlLqFJWRbvVX3UuPTRik8frfj00YpPH6349NGKzf8/Vk6uocblc27F57MOVkw+6xqPn0UrPn204tNHKz6/07Eyq3r/F4vFL2xXKC6uRRO0xx575O9//3umTJmSjTbaaJH1G264Yf773//WCOarjBgxIqeeeuryKBMAAAAAAACAL7Hp06enc+fOda5fKUfYL41hw4ZlyJAh1c8XLlyY999/P6uvvnoKhUIJK6OUKisr06VLl0yfPj3l5eWlLoda6KMVnz5a8emjFZ8+WvHpoxWb/lnx6aMVnz5a8emjFZ8+WvHpoxWfPlqx6Z8Vnz5a8emjFZ8+Ivl0ZP2HH36YTp06fWG7lTKwr6ioSPL/prP/vMrKyuo2n1dWVpaysrIay1ZdddVGrY8vr/Lych+8Kzh9tOLTRys+fbTi00crPn20YtM/Kz59tOLTRys+fbTi00crPn204tNHKzb9s+LTRys+fbTi00fUlTl/VrPlUMcKp+re9bXdp37GjBl57733ar2/PQAAAAAAAAA0lpUysO/Tp0+SZOzYsYusq1pW1QYAAAAAAAAAloWVMrD/+te/ng022CDXXnttnn766erlH374YU477bS0aNEiAwYMKFl9fPmUlZVl+PDhi9wugRWHPlrx6aMVnz5a8emjFZ8+WrHpnxWfPlrx6aMVnz5a8emjFZ8+WvHpoxWb/lnx6aMVnz5a8ekjlkShWCwWS11EKYwbNy577rlnysrKcthhh6W8vDy33nprXn311Zx++uk56aSTSl0iAAAAAAAAAE3YShvYJ8kTTzyR4cOH59FHH80nn3ySzTffPD/72c9y+OGHl7o0AAAAAAAAAJq4lTqwBwAAAAAAAIBSWSnvYQ8AAAAAAAAApSawB1iMMWPGpFAoZMyYMaUuhVronxWfPlrx6aMVnz5a8emjFZ8+WvHpoxWb/lnx6aMVnz5a8emjFZ8+WrHpnxWfPlrx6aOVk8Ae6uEf//hH9tprr3To0CFt27ZNr169cu211y7S7umnn86JJ56YPffcMx07dkyhUEjfvn2Xf8HLgNdg6dT39Zs3b15uueWWDBgwIJtuumnatm2b9u3b52tf+1ouvvjiLFiwoMH7b+i+Vwb17Z8kueyyy7LPPvtk/fXXT9u2bVNRUZGtt946p5xySt5///2lPkZD99/ULUkffd6rr76adu3apVAoZNCgQY1+jPruv6lbktdvxIgRKRQKtT5at2691Mdo6P6buoa8x1999dUcc8wx6dq1a8rKyrLWWmtl1113zU033dQox1jS/Td1S/L61fUe/+xj+vTpS3WMRB993pK+flOmTMlRRx2V7t27Z5VVVsm6666b3XffPXfeeedSH6Oh74Gmbln30ZLsvyH939Qtaf88/vjj2W+//bLGGmukrKwsPXr0yCmnnJKPPvqoUY6hj2q65ppr8sMf/jA9e/ZMWVlZvf5QXFlZmSFDhlT/nOjatWuGDBmSysrKOrfRRw23pH3U0L/RLEkfNeQ6bcpWxOtIH9W0rK+jJd1/Q/q/KVsen3NLcgx/617Ukrx+Df17dH2P4e/dtVvS68jfo1cMLUpdAKzoxo8fnz333DOtWrXKoYcemoqKitx66605/PDDM3Xq1Jx44onVbW///9q7+6io6vwP4O+RJx940AQEDAWfUskUtHXth4Kkoj0Ym7aueyoxomx1HyyXsgw12uxhdcvdLNqUdLVOblE+sKKZgMoqJqUpCamIopGoIBgKInx+f3Rm1nEGuPfODIzc9+sczul8587n8+X7ngv5vcydzz/HkiVL4O7ujgEDBuD8+fNtOHP74RrYRs36HT9+HFOnToWXlxdiYmIwefJkVFVVYdOmTZg9ezYyMzOxYcMGGAwG1fW11NYDNfkAwL/+9S9UVlZi9OjRCAwMRF1dHfbu3YuUlBSsXr0aeXl5CAgI0NxDS/32Tm1G1xMRzJw502E9lNZv77Su34wZMxASEmI25upq/X9PtfRQU7+907J+X3zxBeLi4gAA999/P/r06YPKykp8++232L59Ox566CGbeqit396pXb+FCxdarXPs2DGsW7cOgwYNQnBwsE09mJE5teuXl5eHsWPHor6+HpMnT8aUKVNQXl6O9PR0PPDAA1i0aJFFjmp6aHkNtHeOzkhNfS35t3dq80lPT8e0adPg4uKCKVOmICAgALm5uUhJScGOHTvw5ZdfwsPDQ3MPZmRpwYIFOHnyJHx9fREYGIiTJ082e3xNTQ2ioqJw4MABjB8/HtOnT8fBgwfxt7/9DVlZWdi9eze6dOli9hxmZBu1GWnZo1GTkZbztL1ztvOIGVly9Hmkpr6W/Nu71vg5p6YH97otqVk/rfvRSntwv9s6tecR96OdhBBRk+rr66Vv377i4eEhX3/9tWm8urpawsLCxNXVVb7//nvT+OHDhyU/P1+uXr0qZWVlAkCioqLaYOb2wzUQSUtLEwCSlpam+rlq1+/06dOyYsUKqampMavz008/yYgRIwSArF+/XlN9tbVvFq2Zj4jIlStXrNZasGCBAJB58+bZ1ENt/ZtBa2d0vbfeektcXV1l2bJlAkCefPJJu/ZQUv9m0NoZLVy4UABIVlaWQ3qorX8zaO2MTp06Jd7e3tK/f385efKk1Zq29FBb/2bQlj/rrjdnzhwBIEuXLrWpBzMypyWjSZMmCQDZsGGD2fjJkyfF29tbOnXqJLW1tTb1sKap18DNwJkzUltfbf43g9bM5/Lly+Lr6ytubm6yf/9+03hjY6PMnj1bAMiSJUts6sGMLH3xxRdSUlIiIiJLlixpsVZycrIAkKSkJKvjycnJZuPMqPUzUrtHoyYjLefpzaA9nUfMyDpHn0dq6qvN/2bg7Pmo7cG9bktq1k/rfrTSHtzvtk7tedQe96NvRrwlPlEzduzYgePHj+O3v/0twsPDTeNeXl548cUXce3aNaSlpZnGw8LCEBERATc3t7aYrkM4yxp8//33SEpKQkREBLp3746OHTtiwIABeO655/DTTz9ZHB8dHQ2DwYBr164hJSUFoaGhptt+rVixwmqPiooKzJo1Cz169EDnzp1x55134rPPPrNp3mrXr2fPnnjqqafQuXNnszpdunTB008/DQDIycnRVF9tbTX0kg+AJm+nbXyX4bFjx2zqoba+UnrKyOjYsWOYP38+kpKSzJ5rrx5K6yulx4ycqYcSesrolVdeQXV1Nd5991306tXLouaNdypQ20NtfaX0lJE1tbW1WLduHdzd3fHII4/Y1IMZmdOSUXFxMQwGAyZOnGg23qtXL9x+++24cuUKLl26ZFOPGzX3GlCKGVnPSG19tfkrpZd8cnNzcf78ecTFxWH48OGmcYPBgJdffhkA8O6770JENPdgRpbGjRuH3r17KzpWRPD+++/D09MTycnJZo/Nnz8f3bp1w8qVK5lRG2YEqN+jUZORlvNUKb1k5OjziBlZ5+jzSGl9LfkrxXzs14N73ZbUrJ/W/WilPbjfbZ3a88hR+9Gkjj7vCUqkUHZ2NgBgwoQJFo8Zx7T+wL9ZOMsapKenY+XKlRg7diyio6PR2NiIvXv34rXXXkNOTg527txp9X+cpk+fjry8PEyaNAkuLi5Yv349Zs+eDTc3NyQmJpqOu3z5MqKjo3Ho0CGMGjUKUVFRKC0txbRp06x+70rZc/2M39/1G+T2qm+tthrMB8jIyAAA3H777Q7p0VR9pfSWUWNjI2bOnInevXsjOTkZe/bssWsPNfWV0ltGALBr1y7s27cPLi4uGDhwIMaNG2f1doxaeyitr5ReMhIRrF+/Ht27d0dMTAzy8/ORk5ODxsZGDBs2DDExMejQwfzvftX00FJfKb1k1JT09HRUVlZi6tSp8PPz09yDGVnSklFYWBiKioqwbds23Hfffabx0tJSHD58GEOGDIGvr69NPW7U3GtAKWZkPSO19dXmr5Re8jl79iwAIDQ01OL4rl27olu3bjh58iSKi4vRt29fTT2YkW2OHj2KH374AbGxsRa3a+7YsSPGjBmDDRs24NixY+jfvz8AZtTaGWmhJiMt56lSesnI0ecRM3JuWvJXivk4P2Zk+360o+szI9v3o0mltnljP9HNYerUqQLA7LZR1/P19RU/Pz+rj7WXW+Q4yxqcPn1a6urqLMYXL14sAGTt2rVm41FRUQJARo4cKVVVVabxwsJCcXV1ldtuu83seOPtkxMTE83Gt27dKgA034LGlvW7kfF2gBkZGXavb622GnrMJy0tTRYuXChPP/20REdHCwAJDw+XiooKu/RQWl8pvWW0dOlS6dChg/z3v/8VEZGsrCxBE7es19JDTX2l9JSRcS43fgUGBsq2bdts7qG2vlJ6yej48eMCQO68806ZNWuWxTqGh4dLaWmp5h5a6iull4yaEhMTIwAkMzPTph7MyJKWjAoKCsTf31/c3Nxk6tSp8txzz0lCQoJ069ZNhgwZIkeOHLG5x42aew0oxYysZ6S2vtr8ldJLPsZ+Dz30kMWxFy9eNM3lP//5j+YezKh5Ld0+dfPmzQJA5syZY/XxefPm2fzvV2bUPCW3uL2ekj0aNRlpOU+V0ktGjj6PmFHLHHEeKa2vJX+lmE+UQ3pwr9uS2oyup3Q/WmsPve5330jN+tl7P5rU4QV7omaMHz9eAMjRo0etPt6nTx9xd3e3+lh7uWDv7Gtw4cIFASDx8fFm48ZfkDt27LB4jvGx6upq01hoaKi4u7tLWVmZxfF333235l+Qtqzf9VJTUwWAxMTE2L1+U7XtoT3nY5yn8WvChAly9uxZu/VQWt9W7TGjoqIi6dSpk8ydO9c01twFdbU91Na3VXvM6LPPPpPVq1dLSUmJXLlyRY4ePSopKSnSqVMn6dixoxw4cMCmHmrr26q9ZbRnzx4BIC4uLuLp6SlpaWlSUVEhJ06ckMTERNM/QLX20FLfVu0tI2uKi4vFYDBIr169pKGhwaYezMiS1oyKi4tl+PDhZr/Tu3XrJsuWLZNr167Zpcf1vZp7DdhK7xlpqa8mf1u1t3wuXbok3t7e4ubmZvYZzSIiv//9703r+eGHH2ruIcKMmtPS5u66desEgLzwwgtWH3/ppZeYURtndCMlezRqMtJyntqqvWXk6POIGbWsLS/Ya8nfVszHth7c67ak9WK6mv1oLT30vN99IzXr11r70WQdP8OeiG4KIoJVq1ZhzJgxuOWWW+Di4gKDwYDu3bsDAH744Qerz4uIiLAYu/XWWwEAFy9eBABcunQJJ06cQL9+/RAQEGBx/OjRo+30XWiTkZGBOXPmoHfv3li7dq1T1tZjPtnZ2RARnDt3Dps3b8bp06cRERGBb7/91inr6yWjxsZGxMfHIygoyPSZfDdLfb1kBABxcXF49NFH0bt3b3Ts2BH9+vXDggUL8NZbb6G2ttbmtXVUfb1k1NjYCABoaGhASkoK4uPj0a1bN4SEhOC9997DyJEjkZeXh927dztdfb1kZM2qVasgIpg5c6bm29UbMSP72L9/PyIjI3HLLbcgPz8fNTU1KC4uRkJCAp5++mnT5wHai71eA8zIPhk5qrZe8vH09MSyZctQX1+PUaNG4eGHH8a8efNw1113ITU1FQMHDgQAuLi4aO7BjJwfM3JujjxPmZF9MCP9Yj7OT88ZOXKv25719ZiRo/e7qXn8DHuiZvj4+AAAqqqqrD5eXV1tOqa9cpY1+MMf/oB//OMfCA4OxuTJkxEYGGj6HOLFixejrq7O6vOszc34uTUNDQ0A/ve9+fv7W63Ro0cPzfO2df22bt2KKVOmoEePHtixYwcCAwPtVr+l2mroNR8A8PX1xb333os77rgD/fv3R2JiIvLy8uzWo6X6Suklo+XLl2Pv3r3YsWMHOnfubPceWuorpZeMmjNjxgz87ne/Q25urkN6NFVfKb1kdP1/T5482eL4+++/H3l5eaZNdLU9tNRXSi8Z3aixsREffPABOnTogMcee8zmHsyo6f5KM6qvr8e0adNgMBjw+eefm35nhIaG4o033kBpaSk+/vhjZGVlYezYsZp6XE/Ja0ApZmQ9IzX1teSvlF7yAYCEhAQEBQXh9ddfx4YNG9DQ0IARI0bgyy+/xGuvvYbCwkL4+flp6sGMbKdkva8/TulzmFHbUnuuqj1PldJLRo4+jwBm5My05K8U83F+es3InvvRjq6v14wA++1Hkzq8YE/UjP79+wMAjh49iuHDh5s9VllZifPnz+Ouu+5qi6m1GmdYg/Lycrz99tu44447sGfPHrOLZD/++CMWL15sU31vb29TH2vOnj2rubYt65eZmYlf/epX8PX1RVZWFvr06WO3+kpqK6XXfG4UHByMQYMG4auvvsLly5dN62CvHk3VV0JPGR04cAAi0uSmXWpqKlJTU/HAAw/g888/V91DS30l9JRRc9zd3eHl5YXLly87pEdT9ZXQU0b9+vWDi4sLGhoa0LVrV4t6xrErV65o6qGlvhJ6yuhGmZmZOH36NGJjY9GrVy+bezAjS2ozKiwsRHFxMR588EGrv7NjYmLw8ccfIz8/3/Q7xdb/b2zpNaAEM/qfGzNSU19L/kroKR+jSZMmYdKkSRbjjzzyCDp06GD2DiZmZFtGal2/3tYYx43H3fgcZuSctJyras5TJfSUkaPPIyNm5Jy05K8E83F+es3InvvRjq6v14xuZMt+NKnHW+ITNSMqKgoAsG3bNovHjGPGY9orZ1iD4uJiiAjGjRtn8Uth165dNtf39vZGaGgojh07hh9//NHicVt6aF2/zMxMxMXFoVu3bsjKykK/fv3sVl9pbaX0mE9TysrKYDAYzG4nZ88e1uoroaeMoqKikJCQYPF1zz33AAAGDhyIhIQEjB8/XlMPLfWV0FNGzTl69CgqKysREhLikB5N1VdCTxl5eHiYNvm+++47i+cYx65fRzU9tNRXQk8Z3WjlypUAgMcff9wuPZiRJbUZXb16FQBw7tw5q/WM48Z3aGjpcT0lrwElmNH/3JiRmvpa8ldCT/k0Jzc3FyUlJZg4caLZO5iYkX16KNW/f38EBQUhNzcXNTU1Zo/V1tZi586dCAoKMvv3JjNq3Yy0sNe52tR5qoSeMnL0edQcZtT2tOSvBPNxfnrMyN770Y6ur8eMmqJ1P5o00PLB90R6UV9fL3369BEPDw/55ptvTOPV1dUSFhYmrq6uUlRUZPW5ZWVlAkCioqJaZ7IO4gxr8MMPPwgA+eUvfykNDQ2m8dLSUunTp4/VHlFRUdLUj7gZM2YIADlx4oRpLDk5WQBIYmKi2bFbt24VAAJA0tLSVM9dy/pt2bJFPDw8JCAgQAoLC+1aX01tpfSUz/nz5+Xw4cMWdRobG2XhwoUCQO6++27NPbTUV0JPGTUlKytLAMiTTz7pkB7N1VdCTxlVV1fLwYMHLepUVFTI6NGjBYC8+uqrmntoqa+EnjISEfnwww9NP3Nqa2tN40eOHJHOnTuLl5eXVFRUaO6htr4SesvIqLy8XNzc3MTX11fq6urs1oMZmVO7frW1teLj4yMdOnSQrVu3mtU6c+aMBAUFCQD59ttvNfcwUvoaUIIZ/cxaRmrqa8lfCT3lIyJSVVVlUefMmTMycOBAcXV1lfz8fM09mFHLlixZ0mIt41ySkpKsjicnJ5uNM6PWz+h6SvZo1J6ras9TJfSWkSPPIxFm1BJHnEdq6qvNXwnmo24vWk0P7nVbUrJ+tu5Ht9SD+93Na2n9HLUfTerxlvhEzXB1dcX777+P2NhYjB49GtOnT4e3tzfS09Nx4sQJvPzyyxgwYIDp+MLCQrz66qsA/neL0MLCQsTHxwP4+bM//vrXv7b692ELZ1iDwMBATJkyBZ9++ilGjBiBu+++G2fPnsXmzZsRExOD4uJim7/PpKQkpKen45///CcKCgowZswYlJaWYv369bj33nuRkZGhqa6W9YuLi0NdXR2io6Px0UcfWdQMCQkxraea+mprK6WnfEpLSxEeHo5f/OIXGDx4MAICAnD+/Hns2rULRUVFCAgIwNtvv625h5b6SugpI2ft0RI9ZXThwgUMHToUI0aMwJAhQ+Dv748zZ85gy5YtuHDhAsaPH4+5c+dq7qGlvhJ6yggAfvOb3yA9PR2ffPIJhg4ditjYWFRVVeHTTz9FbW0t1qxZg27dumnuoba+EnrLyGjNmjWor6/Ho48+Cnd3d7v1YEbm1K6fh4cHli5discffxyTJk3Cvffei0GDBuHs2bP47LPPUF1djdmzZ2PIkCGaexgpfQ0owYyazkhNfS35K6GnfABg+fLlWLt2LSIjI+Hv74/S0lJs2LABly9fxsqVKy1u4cyMbMsIAN5//33s3r0bAHDo0CHTWHZ2NgAgLi4OcXFxZnPZuHEjXn/9dXzzzTcYPnw4Dh48iC1btmDYsGFISkoyq8+MWj8jtXs0as9VteepEnrLyJHnEcCMrHH0eaSmvtr8lWA+Le9Fq+nBvW5LatdPy3600h7c77ZOTUaO2o8mDdr6LwaIbgZ5eXkyceJE8fHxkU6dOsmIESNk7dq1FscZ32HZ1Ffv3r1bf/J20tZrcOnSJXnmmWckJCREPDw8pH///pKSkiJXr161y1+0iYhcuHBBnnjiCfHz85OOHTvK8OHDJT09XdLS0mz+izZ7rZ+171Vpfa21ldBLPhUVFTJ//nwZNWqU+Pv7i6urq3h6ekp4eLgsWLBAzp8/b1MPW+q3RC8ZNUXJO+Bt6WHrO+xF9JNRVVWVzJ49W4YPHy6+vr7i6uoqPj4+EhkZKe+++65cu3bNph621G+JXjIyqq+vl2XLlklYWJh4eHiIt7e3TJgwQbKzs+3SQ0v9lugtIxGRQYMGCQD57rvv7N6DGVlSm9H27dvlvvvuEz8/P3FxcRFvb28ZPXq0rF692m491L4GWsKMms9ITX0t+bdET/l8+eWXMm7cOPH39xc3NzcJCAiQadOmyddff223HszIer+mvhYuXGjxnIsXL8rcuXMlODhY3NzcJDg4WObOnSsXL15ssg8zar2MtO7RKM1I63naEj1lJOLY84gZNd3PUeeR2vpa8m8J82n+55yaHtzrbrqfPdbP2veqpgf3u61Tk5Ej96NJHYOICIiIiIiIiIiIiIiIiIiIiKhVdWjrCRAREREREREREREREREREekRL9gTERERERERERERERERERG1Ade2ngAR6dOBAwfw+eeft3hcSEgI4uPjHT4fNRYtWqTouD/96U/o2rWrQ+fiKMzH+TEj58eMnB8zcn7MyPkxI+fHjJwb83F+zMj5MSPnx4ycHzNybszH+TEj58eMyOlp+eB7IiJbpaWlCYAWv6Kiotp6qhaUzBuAnDhxoq2nqhnzcX7MyPkxI+fHjJwfM3J+zMj5MSPnxnycHzNyfszI+TEj58eMnBvzcX7MyPkxI3J2BhEREBERERERERERERERERERUaviZ9gTERERERERERERERERERG1AV6wJyIiIiIiIiIiIiIiIiIiagO8YE9ERERERERERERERERERNQGeMGeiIiIiIiIiIiIiIiIiIioDfCCPRERERERERERERERERERURvgBXsiIiIiIiIispuSkhIYDAbEx8e39VSIiIiIiIiInB4v2BMRERERERHdxIwXyK//cnNzQ8+ePfHrX/8a+/fvb+spEhEREREREVETDCIibT0JIiIiIiIiItKmpKQEoaGh6Nu3Lx5++GEAQE1NDfLz85GVlQU3Nzds374dY8aMaZX51NfX4/jx4/Dx8UFgYGCr9CQiIiIiIiK6WfGCPREREREREdFNzHjBPjY2FpmZmWaPvfrqq5g/fz7GjBmDnJycNpohERERERERETWFt8QnIiIiIiIiaqcSEhIAAPn5+WbjV69exbJlyxAREYEuXbrAy8sLo0ePxsaNG63WKSkpwbRp03DLLbfA09MTUVFR2LlzJxYtWgSDwYDs7GyzY5v6DPtTp04hISEBPXv2hLu7O2699VYkJCSgtLTU4tjo6GgYDAZcu3YNKSkpCA0NhYeHBwYMGIAVK1ZYHF9bW4ulS5di6NCh8PHxgaenJ/r27Yvp06fj0KFDKlaNiIiIiIiIqPW4tvUEiIiIiIiIiMixXF3/98//uro6TJw4EdnZ2QgPD0dCQgLq6+uRkZGBBx54AH//+98xZ84c0/FnzpzBXXfdhbKyMtxzzz0YOnQoioqKMGHCBIwdO1bxHI4ePYrIyEiUl5fj/vvvR1hYGAoKCrBq1Sps3rwZubm56Nevn8Xzpk+fjry8PEyaNAkuLi5Yv349Zs+eDTc3NyQmJpqOmzFjBtavX4877rgDM2fOhIeHB06dOoWsrCzExsZiyJAhGlePiIiIiIiIyHF4wZ6IiIiIiIionUpNTQUAREZGmsZeeuklZGdnY9GiRUhOTobBYAAAXLp0CTExMXjmmWfw4IMPIigoCADw3HPPoaysDG+88QbmzZtnqvPBBx9g5syZiucya9YslJeXIzU1FU888YRp/L333sOTTz6JWbNmYfv27RbPKy0txeHDh+Ht7Q0A+OMf/4jbb78dS5cuNV2wr6qqwr///W+MGDECe/fuhYuLi+n5DQ0NuHTpkuJ5EhEREREREbUmfoY9ERERERER0U3M+Bn2ffv2xcMPPwwAqKmpwVdffYWcnBz4+/sjOzsbgwYNQmNjI3x9fdG9e3d8//33pov1Rps2bcLkyZNN77Kvq6uDj48PunbtilOnTsHd3d10rIhg8ODBKCwsRFZWFqKjo83mM2PGDHzwwQcAfr7o3qtXLwwePBiHDx826ysiCAsLw5EjR3Dq1CkEBwcD+PmW+Dk5OdixY4fFO/mNj1VXV8PLywvV1dXw8fHB//3f/2H37t32XmIiIiIiIiIih+E77ImIiIiIiIjagePHj2Px4sVmY/7+/ti1axcGDBgAACgqKkJlZSWCgoIsjgWAc+fOAQAKCwtNx9fV1WHEiBFmF+sBwGAwYNSoUaZjm/PNN98AAKKioiz+SMBgMGDMmDE4cuQIDh48aLpgbxQREWFR79ZbbwUAXLx4EV5eXvD29sbEiRORmZmJiIgITJ06FaNHj8bIkSMt5k1ERERERETkTHjBnoiIiIiIiKgdiI2NRWZmJoCfL7yvXr0azz77LOLi4rBv3z54enqioqICAFBQUICCgoIma9XU1AAAqqurAQB+fn5Wj+vRo4eiuRnrNHV8QEAAgJ9vbX8jHx8fizFX15+3MxoaGkxjn3zyCV555RV89NFHeOGFFwAAXl5eeOyxx/DKK6+gc+fOiuZKRERERERE1Jo6tPUEiIiIiIiIiMi+/Pz8MG/ePDz//PM4cuQIFixYAACmz4GfMmUKRKTJr7S0NLPjje+8v9HZs2cVzcdYp6njjePG47To0qUL/vKXv6C4uBjFxcVYuXIlBg4ciLfeegtz587VXJeIiIiIiIjIkXjBnoiIiIiIiKidev755xEUFIQVK1agpKQEgwYNgre3N/bv34/6+voWn3/bbbfBw8MD+fn5uHr1qtljIoK9e/cqmsewYcMAADt37oSIWNTZtWuX2XG2Cg0NxWOPPYacnBx4enpi48aNdqlLREREREREZG+8YE9ERERERETUTnXq1AnPPvss6uvrkZKSAldXVzz11FM4efIk5s2bZ/Wi/eHDh1FeXg4A8PDwwNSpU/Hjjz9i+fLlZsetWbMGR44cUTSPXr16YezYsSgoKMCqVavMHlu1ahUKCgoQExNj8fn1Sp07dw779u2zGK+srERdXR06deqkqS4RERERERGRo/Ez7ImIiIiIiIjasSeeeAKvvfYa1qxZg+effx6LFy/G119/jeXLlyMjIwNRUVHw8/PDmTNncOjQIRw8eBB79uyBv78/AGDJkiXYvn07/vznPyMrKwvDhg1DUVERNm/ejIkTJyIzMxMdOrT8foB33nkHkZGRSExMxKZNmzB48GB899132LhxI/z8/PDOO+9o/h7PnDmDkSNHIiwsDBEREejZsycuXLiADRs2oL6+HklJSZprExERERERETkS32FPRERERERE1I517NgR8+fPx7Vr17B48WJ4eHhgy5YtSE1NRUBAAD755BO8+eab2LlzJwIDA/HOO+9gyJAhpucHBwdjz549eOihh5Cbm4s333wT5eXl2LZtG/r16wdA2WfP33bbbdi/fz/i4+Oxb98+vPHGG9i3bx/i4+Px1VdfYcCAAZq/x5CQECxatAjdu3fH9u3bsWzZMmRkZCAiIgJbt27FrFmzNNcmIiIiIiIiciSD3PjhcURERERERERECkRGRmLPnj2oqqqCp6dnW0+HiIiIiIiI6KbDd9gTERERERERUbPKysosxtatW4fc3FyMGzeOF+uJiIiIiIiINOI77ImIiIiIiIioWd27d0d4eDgGDx4MFxcXHDhwANnZ2fDy8kJubq7ZLfSJiIiIiIiISDlesCciIiIiIiKiZr3wwgvYtGkTTp06hZqaGvj5+WHs2LF48cUXMXDgwLaeHhEREREREdFNixfsiYiIiIiIiIiIiIiIiIiI2gA/w56IiIiIiIiIiIiIiIiIiKgN8II9ERERERERERERERERERFRG+AFeyIiIiIiIiIiIiIiIiIiojbAC/ZERERERERERERERERERERtgBfsiYiIiIiIiIiIiIiIiIiI2gAv2BMREREREREREREREREREbUBXrAnIiIiIiIiIiIiIiIiIiJqA7xgT0RERERERERERERERERE1Ab+H8jH9UbjS2TUAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -379,7 +396,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -403,28 +420,41 @@ "plt.ylabel('Number of lesions')\n", "plt.show()\n", "\n", - "#we output the same thing for M12 \n", - "regions = df_M12.columns\n", + "#we output the same thing for M12 for 3D nnUNet \n", + "regions = df_M12_3d.columns\n", "regions = [str(column) for column in regions if 'lesions_between' in column or 'lesions_above' in column]\n", "regions = np.sort(regions)\n", "\n", "plt.figure(figsize=(25, 5))\n", "legend = [region.split('_',3)[-1] for region in regions]\n", - "plt.bar(legend, df_M12[regions].sum())\n", - "plt.title('Distribution of lesions per regions in M12')\n", + "plt.bar(legend, df_M12_3d[regions].sum())\n", + "plt.title('Distribution of lesions per regions in M12 for 3D nnUNet')\n", "plt.xlabel('Regions')\n", "plt.ylabel('Number of lesions')\n", - "plt.show()" + "plt.show()\n", + "\n", + "# we output the same thing for M12 for 2D nnUNet\n", + "regions = df_M12_2d.columns\n", + "regions = [str(column) for column in regions if 'lesions_between' in column or 'lesions_above' in column]\n", + "regions = np.sort(regions)\n", + "\n", + "plt.figure(figsize=(25, 5))\n", + "legend = [region.split('_',3)[-1] for region in regions]\n", + "plt.bar(legend, df_M12_2d[regions].sum())\n", + "plt.title('Distribution of lesions per regions in M12 for 2D nnUNet')\n", + "plt.xlabel('Regions')\n", + "plt.ylabel('Number of lesions')\n", + "plt.show()\n" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 31, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAB9QAAAHUCAYAAABrkhMvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABZMUlEQVR4nO3deZQUhfU/7NuADDuCKMOALCqIiGgURdEIqIAb7hGXKIgxrom4L7igRkCiqLhrAPc1KqIokQTBBRdciKIJaoKiAuIXFRBkr/ePvMyPkYLpgYGeGZ7nnD4nXV1ddevOnSb2Z6oqkyRJEgAAAAAAAABAEZVyXQAAAAAAAAAAlEUCdQAAAAAAAABIIVAHAAAAAAAAgBQCdQAAAAAAAABIIVAHAAAAAAAAgBQCdQAAAAAAAABIIVAHAAAAAAAAgBQCdQAAAAAAAABIIVAHAAAAAAAAgBQCdQAAYIO7//77I5PJFD6qVasW+fn50aVLlxg4cGDMnj17tff0798/MplMifazcOHC6N+/f4wfP75E70vbV/PmzePQQw8t0XaK8+ijj8Ytt9yS+lomk4n+/fuX6v5K2z/+8Y9o37591KxZMzKZTIwcOTLXJeXE+PHjI5PJlHjOypsPPvggOnXqFHXr1o1MJrPG2Y3YsPO7qfS7vOjdu3c0b94812Wk2hCz0rlz58hkMrHNNttEkiSrvf7qq68W/tt2//33F3ntp59+ir59+0ZBQUFUq1Ytdtlll3j88cdLrTYAAGDjqJLrAgAAgE3HiBEjonXr1rF06dKYPXt2vP7663HDDTfEjTfeGE888UQccMABhev+7ne/iwMPPLBE21+4cGFcc801EfG/ECRb67KvdfHoo4/GlClTom/fvqu99uabb0aTJk02eA3rKkmSOPbYY6NVq1YxatSoqFmzZmy//fa5LosNqE+fPrFgwYJ4/PHHo169ejkLUXfdddd48803o02bNjnZP0VdeeWVce655+a6jFQbalZq164d06ZNi3HjxsX+++9f5LXhw4dHnTp1Yt68eau976ijjopJkybFoEGDolWrVvHoo4/G8ccfHytWrIgTTjihVGsEAAA2HIE6AACw0bRt2zbat29f+Pzoo4+O8847L/bZZ5846qij4rPPPouGDRtGRESTJk02eMC8cOHCqFGjxkbZV3H23HPPnO6/ODNmzIjvv/8+jjzyyNUCJSqmKVOmxGmnnRYHHXRQTuuoU6dOmf/92NCWL18ey5Yti7y8vKzWT5IkFi1aFNWrVy/1WrbddttS32Zp2VCz0rRp06hdu3YMHz68yOff/Pnz46mnnooTTzwx7rvvviLvefHFF2Ps2LGFIXpERJcuXeLLL7+Miy66KHr27BmVK1cu9VoBAIDS55LvAABATjVt2jRuuummmD9/ftxzzz2Fy9Muwz5u3Ljo3LlzbLHFFlG9evVo2rRpHH300bFw4cL44osvYsstt4yIiGuuuabwEry9e/cusr33338/jjnmmKhXr15hMLS2y8s/++yz0a5du6hWrVpss802MXTo0CKvr7yc/RdffFFk+S8vPdy5c+cYPXp0fPnll0Uuf79S2iWzp0yZEocffnjUq1ev8HLBDzzwQOp+HnvssejXr18UFBREnTp14oADDoipU6euufGreP3112P//feP2rVrR40aNaJjx44xevTowtf79+9f+AcHl1xySWQymbWerbxo0aK44IILYpdddom6detG/fr1Y6+99ornnnuuyHq/+tWv4te//vVq71++fHk0btw4jjrqqMJlX3/9dRxzzDFRu3bt2HzzzePEE0+MSZMmpV5meVX//Oc/I5PJxLBhw1Z77aWXXopMJhOjRo3Kuhdr0rlz59SrIvzy8thffPFFZDKZ+POf/xw33HBDNG/ePKpXrx6dO3eOTz/9NJYuXRqXXnppFBQURN26dePII49MvSXCE088EXvttVfUrFkzatWqFd27d48PPvig2Dojip+rlTO9bNmyuOuuu1ab1WzNmjUrTj/99GjSpElUrVo1WrRoEddcc00sW7asyHp33XVX7LzzzlGrVq2oXbt2tG7dOi6//PLC19d0Ge9Ro0bFXnvtFTVq1IjatWtH165d48033yyyzsrf7Y8//jiOP/74qFu3bjRs2DD69OkTc+fOLbLuU089FR06dIi6detGjRo1Yptttok+ffoUe5yZTCbOOeecuOeee6JVq1aRl5cXbdq0Sb20dzY9WTkjgwcPjj/96U/RokWLyMvLi1deeaXYGu6+++7YYYcdIi8vr/Bn+tlnn8UJJ5wQW221VeTl5cUOO+wQd9xxx2rb+Pjjj6Nbt25Ro0aN2HLLLePss8+O0aNHr9b7tEu+L1q0KC677LJo0aJFVK1aNRo3bhxnn312/Pjjj0XWW3krjTFjxsSuu+4a1atXj9atW8fw4cOLrLdw4cK48MILo0WLFlGtWrWoX79+tG/fPh577LE19iAifVZ69+4dtWrVis8//zwOPvjgqFWrVmy99dZxwQUXxOLFi9e6vVX16dMnnnnmmSLHtPJnfNxxx622/rPPPhu1atWK3/zmN0WWn3LKKTFjxox4++23s943AACQWwJ1AAAg5w4++OCoXLlyvPrqq2tc54svvohDDjkkqlatGsOHD48xY8bEoEGDombNmrFkyZJo1KhRjBkzJiIiTj311HjzzTfjzTffjCuvvLLIdo466qjYbrvt4qmnnoq77757rXVNnjw5+vbtG+edd148++yz0bFjxzj33HPjxhtvLPEx3nnnnbH33ntHfn5+YW2/DP9WNXXq1OjYsWN8/PHHMXTo0HjmmWeiTZs20bt37xg8ePBq619++eXx5Zdfxl/+8pe4995747PPPosePXrE8uXL11rXhAkTYr/99ou5c+fGsGHD4rHHHovatWtHjx494oknnoiI/10S/5lnnomIiD/84Q/x5ptvxrPPPrvGbS5evDi+//77uPDCC2PkyJHx2GOPFV6F4MEHHyxc75RTTonXX389PvvssyLvf/nll2PGjBlxyimnRETEggULokuXLvHKK6/EDTfcEE8++WQ0bNgwevbsudZji4jYeeed41e/+lWMGDFitdfuv//+2GqrreLggw/Ouhel5Y477og33ngj7rjjjvjLX/4S//73v6NHjx5x6qmnxnfffRfDhw+PwYMHx9///vf43e9+V+S9AwYMiOOPPz7atGkTTz75ZDz00EMxf/78+PWvfx2ffPLJWvebzVwdcsghhbN5zDHHFDuraWbNmhV77LFH/O1vf4urrroqXnrppTj11FNj4MCBcdpppxWu9/jjj8dZZ50VnTp1imeffTZGjhwZ5513XixYsGCt23/00Ufj8MMPjzp16sRjjz0Ww4YNix9++CE6d+4cr7/++mrrH3300dGqVat4+umn49JLL41HH300zjvvvMLX33zzzejZs2dss8028fjjj8fo0aPjqquuWi38X5NRo0bF0KFD49prr42//vWv0axZszj++OPjr3/9a4l7stLQoUNj3LhxceONN8ZLL70UrVu3XmsNI0eOjLvuuiuuuuqq+Nvf/lY4D7vvvntMmTIlbrrppnjhhRfikEMOiT/+8Y+Ft8eIiJg5c2Z06tQppk6dGnfddVc8+OCDMX/+/DjnnHOKPfYkSeKII46IG2+8MU466aQYPXp0nH/++fHAAw/Efvvtt1po/c9//jMuuOCCOO+88+K5556Ldu3axamnnlrk8//888+Pu+66K/74xz/GmDFj4qGHHorf/OY3MWfOnGLrSbN06dI47LDDYv/994/nnnsu+vTpEzfffHPccMMNWW/juOOOi8qVKxcJ9YcNGxbHHHNM1KlTZ7X1p0yZEjvssENUqVL04pDt2rUrfB0AACgnEgAAgA1sxIgRSUQkkyZNWuM6DRs2THbYYYfC51dffXWy6n+y/PWvf00iIpk8efIat/Hdd98lEZFcffXVq722cntXXXXVGl9bVbNmzZJMJrPa/rp27ZrUqVMnWbBgQZFjmzZtWpH1XnnllSQikldeeaVw2SGHHJI0a9YstfZf1n3ccccleXl5yfTp04usd9BBByU1atRIfvzxxyL7Ofjgg4us9+STTyYRkbz55pup+1tpzz33TLbaaqtk/vz5hcuWLVuWtG3bNmnSpEmyYsWKJEmSZNq0aUlEJH/+85/Xur00y5YtS5YuXZqceuqpya9+9avC5f/3f/+XVK1aNbn88suLrH/ssccmDRs2TJYuXZokSZLccccdSUQkL730UpH1Tj/99CQikhEjRqx1/0OHDk0iIpk6dWrhsu+//z7Jy8tLLrjggsJl2fYi7WfbqVOnpFOnTqvtu1evXkV+5iv7uPPOOyfLly8vXH7LLbckEZEcdthhRd7ft2/fJCKSuXPnJkmSJNOnT0+qVKmS/OEPfyiy3vz585P8/Pzk2GOPXWsvsp2rJPnfTJ599tlr3d6q6646v6effnpSq1at5Msvvyyy3o033phERPLxxx8nSZIk55xzTrL55puvddu/7Pfy5cuTgoKCZKeddirSw/nz5ydbbbVV0rFjx8JlK3+3Bw8eXGSbZ511VlKtWrXCn+nKulY9/mxFRFK9evVk1qxZhcuWLVuWtG7dOtluu+0Kl2Xbk5Uzsu222yZLlizJuoa6desm33//fZHl3bt3T5o0aVI4Pyudc845SbVq1QrXv+iii5JMJlNYw6rv/+Ws/3Kmx4wZk9rjJ554IomI5N577y1c1qxZs6RatWpFevDzzz8n9evXT04//fTCZW3btk2OOOKIrI59VWm/m7169UoiInnyySeLrHvwwQcn22+/fbHb7NSpU7LjjjsWbqt9+/ZJkiTJxx9/nEREMn78+GTSpEmrfRa1bNky6d69+2rbmzFjRhIRyYABA0p8fAAAQG44Qx0AACgTkiRZ6+u77LJLVK1aNX7/+9/HAw88EP/973/XaT9HH3101uvuuOOOsfPOOxdZdsIJJ8S8efPi/fffX6f9Z2vcuHGx//77x9Zbb11kee/evWPhwoWrnTF82GGHFXm+8izIL7/8co37WLBgQbz99ttxzDHHRK1atQqXV65cOU466aT4+uuvs75s/C899dRTsffee0etWrWiSpUqsdlmm8WwYcPiX//6V+E6W2yxRfTo0SMeeOCBWLFiRURE/PDDD/Hcc8/FySefXHhm54QJE6J27dpx4IEHFtnHyvsSF+fEE0+MvLy8IpeGf+yxx2Lx4sVFzoLfUL1Ic/DBB0elSv/vP8l32GGHiPjf2eGrWrl8+vTpERHxt7/9LZYtWxYnn3xyLFu2rPBRrVq16NSp02qXRf+lks7VunrhhReiS5cuUVBQUKTOlfdjnzBhQkRE7LHHHvHjjz/G8ccfH88991z83//9X7Hbnjp1asyYMSNOOumkIj2sVatWHH300fHWW2/FwoULi7wn7fdj0aJFhZfT33333SMi4thjj40nn3wyvvnmmxId7/777x8NGzYsfF65cuXo2bNnfP755/H111+XqCer1rzZZptlXcN+++0X9erVK3y+aNGi+Mc//hFHHnlk1KhRo8g+Dz744Fi0aFG89dZbhftu27ZttGnTpsg2s/kdGzduXERE4e01VvrNb34TNWvWjH/84x9Flu+yyy7RtGnTwufVqlWLVq1aFfms2mOPPeKll16KSy+9NMaPHx8///xzdk1Yg0wmEz169CiyrF27dmv9fEzTp0+fePfdd+Ojjz6KYcOGxbbbbhv77rvvWve7Lq8BAABli0AdAADIuQULFsScOXOioKBgjetsu+228fe//z222mqrOPvss2PbbbeNbbfdNm699dYS7atRo0ZZr5ufn7/GZet66eFszZkzJ7XWlT365f632GKLIs/z8vIiItYaRP3www+RJEmJ9pONZ555Jo499tho3LhxPPzww/Hmm2/GpEmTok+fPrFo0aIi6/bp0ye++eabGDt2bET8v6B71XBuzpw5RcLKldKWpalfv34cdthh8eCDDxZeAv/++++PPfbYI3bccceI2HC9WFtNq6patepal6/s27fffhsR/wuAN9tssyKPJ554othAuqRzta6+/fbbeP7551ercWW/V9Z50kknxfDhw+PLL7+Mo48+Orbaaqvo0KFD4Tys6Rgi0n+XCwoKYsWKFfHDDz8UWV7c78e+++4bI0eOLPxjhSZNmkTbtm2LvWf3Stl8VmTbk5VK8lmVtv6cOXNi2bJlcdttt622z5W3OVi5z/X5HZszZ05UqVIlttxyyyLLM5lM5OfnF/tZFfG/n8eqn1VDhw6NSy65JEaOHBldunSJ+vXrxxFHHLHa7SGyVaNGjahWrdpq+/zl51Fx9t1332jZsmXcc8898dBDD0WfPn3WGIxvscUWqb9P33//fUSs/rsOAACUXVWKXwUAAGDDGj16dCxfvjw6d+681vV+/etfx69//etYvnx5vPvuu3HbbbdF3759o2HDhnHcccdlta+SnBU4a9asNS5bGQqtDGl+eZ/gbM60XZstttgiZs6cudryGTNmREREgwYN1mv7ERH16tWLSpUqlfp+Hn744WjRokU88cQTRfr9yx5FRHTv3j0KCgpixIgR0b179xgxYkR06NChyJmyW2yxRbzzzjurvTft57Mmp5xySjz11FMxduzYaNq0aUyaNCnuuuuuwtfXtxfVqlWLuXPnrrZ8fefgl1bWsPI+3SW1MeZq5XbatWsX119/ferrq/7xzCmnnBKnnHJKLFiwIF599dW4+uqr49BDD41PP/009RhX/u6t6TgqVapU5EztbB1++OFx+OGHx+LFi+Ott96KgQMHxgknnBDNmzePvfbaa63vzeazoiQ9iSj5Gcy/XL9evXqFV1g4++yzU9/TokWLwhpX/rFG2jGszRZbbBHLli2L7777rkioniRJzJo1q/Ds/5KoWbNmXHPNNXHNNdfEt99+W3i2eo8ePeLf//53ibdXmk455ZS44oorIpPJRK9evda43k477RSPPfZYLFu2rMh91D/66KOIiGjbtu0GrxUAACgdzlAHAAByavr06XHhhRdG3bp14/TTT8/qPZUrV44OHTrEHXfcERFRePn1bM7KLomPP/44/vnPfxZZ9uijj0bt2rVj1113jYiI5s2bR0TEhx9+WGS9UaNGrba9X56FuTb7779/jBs3rjDoXOnBBx+MGjVqxJ577pntYaxRzZo1o0OHDvHMM88UqWvFihXx8MMPR5MmTaJVq1Yl3m4mk4mqVasWCfhmzZoVzz333Grrrgz8Ro4cGa+99lq8++670adPnyLrdOrUKebPnx8vvfRSkeWPP/541jV169YtGjduHCNGjIgRI0ZEtWrVilzOen170bx58/j000+L/NHAnDlzYuLEiVnXmI3u3btHlSpV4j//+U+0b98+9bE2G2OuIiIOPfTQmDJlSmy77bapNaZdjaJmzZpx0EEHRb9+/WLJkiXx8ccfp257++23j8aNG8ejjz5a5FYRCxYsiKeffjr22muvqFGjxjrXnpeXF506dYobbrghIiI++OCDYt/zj3/8o0ggvXz58njiiSdi2223jSZNmkTEuvVkfdSoUSO6dOkSH3zwQbRr1y51nyvD/k6dOsWUKVPik08+KbKNbH7H9t9//4j43x/SrOrpp5+OBQsWFL6+rho2bBi9e/eO448/PqZOnbra5fw3tl69ekWPHj3ioosuisaNG69xvSOPPDJ++umnePrpp4ssf+CBB6KgoCA6dOiwoUsFAABKiTPUAQCAjWbKlCmF9/CdPXt2vPbaazFixIioXLlyPPvss6tdMnhVd999d4wbNy4OOeSQaNq0aSxatCiGDx8eEREHHHBARETUrl07mjVrFs8991zsv//+Ub9+/WjQoEFh6F1SBQUFcdhhh0X//v2jUaNG8fDDD8fYsWPjhhtuKAzsdt9999h+++3jwgsvjGXLlkW9evXi2Wefjddff3217e20007xzDPPxF133RW77bZbVKpUaY0B6NVXX114z+Wrrroq6tevH4888kiMHj06Bg8eHHXr1l2nY/qlgQMHRteuXaNLly5x4YUXRtWqVePOO++MKVOmxGOPPbZO9/k99NBD45lnnomzzjorjjnmmPjqq6/iuuuui0aNGqVesrlPnz5xww03xAknnBDVq1ePnj17Fnm9V69ecfPNN8dvf/vb+NOf/hTbbbddvPTSS/G3v/0tIqLIfbTXpHLlynHyySfHkCFDok6dOnHUUUet1sP16cVJJ50U99xzT/z2t7+N0047LebMmRODBw+OOnXqZNOyrDVv3jyuvfba6NevX/z3v/+NAw88MOrVqxfffvttvPPOO4Vn9q7Jxpqra6+9NsaOHRsdO3aMP/7xj7H99tvHokWL4osvvogXX3wx7r777mjSpEmcdtppUb169dh7772jUaNGMWvWrBg4cGDUrVt3jWc2V6pUKQYPHhwnnnhiHHrooXH66afH4sWL489//nP8+OOPMWjQoBLXe9VVV8XXX38d+++/fzRp0iR+/PHHuPXWW2OzzTaLTp06Ffv+Bg0axH777RdXXnll1KxZM+68887497//XSSQzrYnpenWW2+NffbZJ37961/HmWeeGc2bN4/58+fH559/Hs8//3zh/c/79u0bw4cPj4MOOiiuvfbaaNiwYTz66KOFZ4Ov7Xesa9eu0b1797jkkkti3rx5sffee8eHH34YV199dfzqV7+Kk046qcR1d+jQIQ499NBo165d1KtXL/71r3/FQw89tN5/LFEaCgoKYuTIkcWud9BBB0XXrl3jzDPPjHnz5sV2220Xjz32WIwZMyYefvjhqFy58oYvFgAAKBUCdQAAYKM55ZRTIuJ/94XefPPNY4cddohLLrkkfve73601TI+I2GWXXeLll1+Oq6++OmbNmhW1atWKtm3bxqhRo6Jbt26F6w0bNiwuuuiiOOyww2Lx4sXRq1evuP/++9ep3l122SVOOeWUuPrqq+Ozzz6LgoKCGDJkSJx33nmF61SuXDmef/75OOecc+KMM86IvLy8OO644+L222+PQw45pMj2zj333Pj444/j8ssvj7lz50aSJEXOsF3V9ttvHxMnTozLL788zj777Pj5559jhx12iBEjRhS5v/j66tSpU4wbNy6uvvrq6N27d6xYsSJ23nnnGDVqVBx66KHrtM1TTjklZs+eHXfffXcMHz48ttlmm7j00kvj66+/Tg17W7VqFR07doyJEyfGiSeeuFqoW7NmzRg3blz07ds3Lr744shkMtGtW7e488474+CDD47NN98867oGDhwY3333XeEsllYv9t5773jggQdi0KBBcfjhh8c222wTV199dbz44osxfvz4rOrL1mWXXRZt2rSJW2+9tfCe8/n5+bH77rvHGWecsdb3bqy5atSoUbz77rtx3XXXxZ///Of4+uuvo3bt2tGiRYvCPwKI+N9tHO6///548skn44cffogGDRrEPvvsEw8++OBaPxNOOOGEqFmzZgwcODB69uwZlStXjj333DNeeeWV6NixY4nr7dChQ7z77rtxySWXxHfffRebb755tG/fPsaNG1d4j/O1Oeyww2LHHXeMK664IqZPnx7bbrttPPLII0X+OCTbnpSmNm3axPvvvx/XXXddXHHFFTF79uzYfPPNo2XLloX3UY/4X0g8YcKE6Nu3b5xxxhlRo0aNOPLII+Paa6+NXr16rfV3LJPJxMiRI6N///4xYsSIuP7666NBgwZx0kknxYABAwqvHFIS++23X4waNSpuvvnmWLhwYTRu3DhOPvnk6Nev37q0IWeeeeaZ6NevX1x11VXx/fffR+vWreOxxx7L+hYlAABA2ZBJ1vTtDQAAAJRhAwYMKAwwS/vMXshWJpOJs88+O26//fZcl1Lqfv/738djjz0Wc+bMiapVq+a6HAAAgJxwhjoAAABl3sqwsnXr1rF06dIYN25cDB06NH77298K06EUXHvttVFQUBDbbLNN/PTTT/HCCy/EX/7yl7jiiiuE6QAAwCZNoA4AAECZV6NGjbj55pvjiy++iMWLF0fTpk3jkksuiSuuuCLXpUGFsNlmmxVein7ZsmXRsmXLGDJkSJx77rm5Lg0AACCnXPIdAAAAAAAAAFJUynUBAAAAAAAAAFAWCdQBAAAAAAAAIIVAHQAAAAAAAABSVMl1ARvaihUrYsaMGVG7du3IZDK5LgcAAAAAAACAHEuSJObPnx8FBQVRqdKaz0Ov8IH6jBkzYuutt851GQAAAAAAAACUMV999VU0adJkja9X+EC9du3aEfG/RtSpUyfH1QAAAAAAAACQa/PmzYutt966ME9ekwofqK+8zHudOnUE6gAAAAAAAAAUKu624Wu+GDwAAAAAAAAAbMIE6gAAAAAAAACQQqAOAAAAAAAAACkE6gAAAAAAAACQQqAOAAAAAAAAACkE6gAAAAAAAACQQqAOAAAAAAAAACkE6gAAAAAAAACQQqAOAAAAAAAAACkE6gAAAAAAAACQQqAOAAAAAAAAACkE6gAAAAAAAACQQqAOAAAAAAAAACkE6gAAAAAAAACQQqAOAAAAAAAAACmq5LoAAACAjan5paNzXQLr4ItBh+S6BAAAAGAT5Ax1AAAAAAAAAEghUAcAAAAAAACAFAJ1AAAAAAAAAEghUAcAAAAAAACAFAJ1AAAAAAAAAEghUAcAAAAAAACAFAJ1AAAAAAAAAEghUAcAAAAAAACAFAJ1AAAAAAAAAEghUAcAAAAAAACAFAJ1AAAAAAAAAEghUAcAAAAAAACAFAJ1AAAAAAAAAEghUAcAAAAAAACAFAJ1AAAAAAAAAEghUAcAAAAAAACAFAJ1AAAAAAAAAEghUAcAAAAAAACAFAJ1AAAAAAAAAEghUAcAAAAAAACAFAJ1AAAAAAAAAEghUAcAAAAAAACAFAJ1AAAAAAAAAEghUAcAAAAAAACAFAJ1AAAAAAAAAEghUAcAAAAAAACAFAJ1AAAAAAAAAEghUAcAAAAAAACAFAJ1AAAAAAAAAEghUAcAAAAAAACAFAJ1AAAAAAAAAEghUAcAAAAAAACAFAJ1AAAAAAAAAEghUAcAAAAAAACAFAJ1AAAAAAAAAEghUAcAAAAAAACAFAJ1AAAAAAAAAEghUAcAAAAAAACAFAJ1AAAAAAAAAEghUAcAAAAAAACAFAJ1AAAAAAAAAEghUAcAAAAAAACAFAJ1AAAAAAAAAEghUAcAAAAAAACAFFVyXQAAQLaaXzo61yWwDr4YdEiuSwAAAAAAWCfOUAcAAAAAAACAFGUmUB84cGBkMpno27dv4bIkSaJ///5RUFAQ1atXj86dO8fHH3+cuyIBAAAAAAAA2GSUiUB90qRJce+990a7du2KLB88eHAMGTIkbr/99pg0aVLk5+dH165dY/78+TmqFAAAAAAAAIBNRc4D9Z9++ilOPPHEuO+++6JevXqFy5MkiVtuuSX69esXRx11VLRt2zYeeOCBWLhwYTz66KM5rBgAAAAAAACATUHOA/Wzzz47DjnkkDjggAOKLJ82bVrMmjUrunXrVrgsLy8vOnXqFBMnTlzj9hYvXhzz5s0r8gAAAAAAAACAkqqSy50//vjj8f7778ekSZNWe23WrFkREdGwYcMiyxs2bBhffvnlGrc5cODAuOaaa0q3UAAAAAAAAAA2OTk7Q/2rr76Kc889Nx5++OGoVq3aGtfLZDJFnidJstqyVV122WUxd+7cwsdXX31VajUDAAAAAAAAsOnI2Rnq7733XsyePTt22223wmXLly+PV199NW6//faYOnVqRPzvTPVGjRoVrjN79uzVzlpfVV5eXuTl5W24wgEAAAAAAADYJOTsDPX9998/Pvroo5g8eXLho3379nHiiSfG5MmTY5ttton8/PwYO3Zs4XuWLFkSEyZMiI4dO+aqbAAAAAAAAAA2ETk7Q7127drRtm3bIstq1qwZW2yxReHyvn37xoABA6Jly5bRsmXLGDBgQNSoUSNOOOGEXJQMAAAAAAAAwCYkZ4F6Ni6++OL4+eef46yzzooffvghOnToEC+//HLUrl0716UBAAAAAAAAUMGVqUB9/PjxRZ5nMpno379/9O/fPyf1AAAAAAAAALDpytk91AEAAAAAAACgLBOoAwAAAAAAAEAKgToAAAAAAAAApBCoAwAAAAAAAEAKgToAAAAAAAAApBCoAwAAAAAAAEAKgToAAAAAAAAApBCoAwAAAAAAAEAKgToAAAAAAAAApBCoAwAAAAAAAEAKgToAAAAAAAAApBCoAwAAAAAAAEAKgToAAAAAAAAApBCoAwAAAAAAAEAKgToAAAAAAAAApBCoAwAAAAAAAEAKgToAAAAAAAAApBCoAwAAAAAAAEAKgToAAAAAAAAApBCoAwAAAAAAAEAKgToAAAAAAAAApBCoAwAAAAAAAEAKgToAAAAAAAAApBCoAwAAAAAAAEAKgToAAAAAAAAApKiS6wKATUPzS0fnugTWwReDDsl1CQAAAAAAADnjDHUAAAAAAAAASCFQBwAAAAAAAIAUAnUAAAAAAAAASCFQBwAAAAAAAIAUAnUAAAAAAAAASCFQBwAAAAAAAIAUAnUAAAAAAAAASCFQBwAAAAAAAIAUAnUAAAAAAAAASCFQBwAAAAAAAIAUAnUAAAAAAAAASCFQBwAAAAAAAIAUAnUAAAAAAAAASCFQBwAAAAAAAIAUAnUAAAAAAAAASCFQBwAAAAAAAIAUAnUAAAAAAAAASCFQBwAAAAAAAIAUAnUAAAAAAAAASCFQBwAAAAAAAIAUAnUAAAAAAAAASCFQBwAAAAAAAIAUAnUAAAAAAAAASCFQBwAAAAAAAIAUAnUAAAAAAAAASFEl1wUAQERE80tH57oE1sEXgw7JdQkAAAAAALDBOEMdAAAAAAAAAFII1AEAAAAAAAAghUAdAAAAAAAAAFII1AEAAAAAAAAgRZVcFwAAAKWp+aWjc10C6+CLQYfkugQAAAAAWI0z1AEAAAAAAAAghUAdAAAAAAAAAFII1AEAAAAAAAAghUAdAAAAAAAAAFII1AEAAAAAAAAghUAdAAAAAAAAAFII1AEAAAAAAAAghUAdAAAAAAAAAFII1AEAAAAAAAAghUAdAAAAAAAAAFII1AEAAAAAAAAgRU4D9bvuuivatWsXderUiTp16sRee+0VL730UuHrSZJE//79o6CgIKpXrx6dO3eOjz/+OIcVAwAAAAAAALCpyGmg3qRJkxg0aFC8++678e6778Z+++0Xhx9+eGFoPnjw4BgyZEjcfvvtMWnSpMjPz4+uXbvG/Pnzc1k2AAAAAAAAAJuAnAbqPXr0iIMPPjhatWoVrVq1iuuvvz5q1aoVb731ViRJErfcckv069cvjjrqqGjbtm088MADsXDhwnj00UdzWTYAAAAAAAAAm4Aycw/15cuXx+OPPx4LFiyIvfbaK6ZNmxazZs2Kbt26Fa6Tl5cXnTp1iokTJ65xO4sXL4558+YVeQAAAAAAAABASeU8UP/oo4+iVq1akZeXF2eccUY8++yz0aZNm5g1a1ZERDRs2LDI+g0bNix8Lc3AgQOjbt26hY+tt956g9YPAAAAAAAAQMWU80B9++23j8mTJ8dbb70VZ555ZvTq1Ss++eSTwtczmUyR9ZMkWW3Zqi677LKYO3du4eOrr77aYLUDAAAAAAAAUHFVyXUBVatWje222y4iItq3bx+TJk2KW2+9NS655JKIiJg1a1Y0atSocP3Zs2evdtb6qvLy8iIvL2/DFg0AAAAAAABAhZfzM9R/KUmSWLx4cbRo0SLy8/Nj7Nixha8tWbIkJkyYEB07dsxhhQAAAAAAAABsCnJ6hvrll18eBx10UGy99dYxf/78ePzxx2P8+PExZsyYyGQy0bdv3xgwYEC0bNkyWrZsGQMGDIgaNWrECSeckMuyAQAAAAAAANgE5DRQ//bbb+Okk06KmTNnRt26daNdu3YxZsyY6Nq1a0REXHzxxfHzzz/HWWedFT/88EN06NAhXn755ahdu3YuywYAAAAAAABgE7BOgfprr70W99xzT/znP/+Jv/71r9G4ceN46KGHokWLFrHPPvtkvZ1hw4at9fVMJhP9+/eP/v37r0uZAAAAAAAAALDOSnwP9aeffjq6d+8e1atXjw8++CAWL14cERHz58+PAQMGlHqBAAAAAAAAAJALJQ7U//SnP8Xdd98d9913X2y22WaFyzt27Bjvv/9+qRYHAAAAAAAAALlS4kB96tSpse+++662vE6dOvHjjz+WRk0AAAAAAAAAkHMlDtQbNWoUn3/++WrLX3/99dhmm21KpSgAAAAAAAAAyLUSB+qnn356nHvuufH2229HJpOJGTNmxCOPPBIXXnhhnHXWWRuiRgAAAAAAAADY6KqU9A0XX3xxzJ07N7p06RKLFi2KfffdN/Ly8uLCCy+Mc845Z0PUCAAAAAAAAAAbXYkD9YiI66+/Pvr16xeffPJJrFixItq0aRO1atUq7doAAAAAAAAAIGfWKVCPiKhRo0a0b9++NGsBAAAAAAAAgDKjxIH6okWL4rbbbotXXnklZs+eHStWrCjy+vvvv19qxQEAAAAAAABArpQ4UO/Tp0+MHTs2jjnmmNhjjz0ik8lsiLoAAAAAAAAAIKdKHKiPHj06Xnzxxdh77703RD0AAAAAAAAAUCZUKukbGjduHLVr194QtQAAAAAAAABAmVHiQP2mm26KSy65JL788ssNUQ8AAAAAAAAAlAklvuR7+/btY9GiRbHNNttEjRo1YrPNNivy+vfff19qxQEAAAAAAABArpQ4UD/++OPjm2++iQEDBkTDhg0jk8lsiLoAAAAAAAAAIKdKHKhPnDgx3nzzzdh55503RD0AAAAAAAAAUCaU+B7qrVu3jp9//nlD1AIAAAAAAAAAZUaJA/VBgwbFBRdcEOPHj485c+bEvHnzijwAAAAAAAAAoCIo8SXfDzzwwIiI2H///YssT5IkMplMLF++vHQqAwAAAAAAAIAcKnGg/sorr2yIOgAAAAAAAACgTClxoN6pU6cNUQcAAAAAAAAAlCklDtRfffXVtb6+7777rnMxAAAAAAAAAFBWlDhQ79y582rLMplM4f92D3UAAAAAAAAAKoJKJX3DDz/8UOQxe/bsGDNmTOy+++7x8ssvb4gaAQAAAAAAAGCjK/EZ6nXr1l1tWdeuXSMvLy/OO++8eO+990qlMAAAAAAAAADIpRKfob4mW265ZUydOrW0NgcAAAAAAAAAOVXiM9Q//PDDIs+TJImZM2fGoEGDYueddy61wgAAAAAAAAAgl0ocqO+yyy6RyWQiSZIiy/fcc88YPnx4qRUGAAAAAAAAALlU4kB92rRpRZ5XqlQpttxyy6hWrVqpFQUAAAAAAAAAuVbiQL1Zs2Ybog4AAAAAAAAAKFOyCtSHDh2a9Qb/+Mc/rnMxAAAAAAAAAFBWZBWo33zzzVltLJPJCNQBAAAAAAAAqBCyCtR/ed90AAAAAAAAAKjoKq3Pm5MkiSRJSqsWAAAAAAAAACgz1ilQf/DBB2OnnXaK6tWrR/Xq1aNdu3bx0EMPlXZtAAAAAAAAAJAzWV3yfVVDhgyJK6+8Ms4555zYe++9I0mSeOONN+KMM86I//u//4vzzjtvQ9QJAAAAAAAAABtViQP12267Le666644+eSTC5cdfvjhseOOO0b//v0F6gAAAAAAAABUCCW+5PvMmTOjY8eOqy3v2LFjzJw5s1SKAgAAAAAAAIBcK3Ggvt1228WTTz652vInnngiWrZsWSpFAQAAAAAAAECulfiS79dcc0307NkzXn311dh7770jk8nE66+/Hv/4xz9Sg3YAAAAob5pfOjrXJbAOvhh0SK5LAAAAoIIp8RnqRx99dLz99tvRoEGDGDlyZDzzzDPRoEGDeOedd+LII4/cEDUCAAAAAAAAwEZX4jPUIyJ22223ePjhh0u7FgAAAAAAAAAoM0p8hnqXLl1i2LBhMXfu3A1RDwAAAAAAAACUCSUO1Hfaaae44oorIj8/P44++ugYOXJkLFmyZEPUBgAAAAAAAAA5U+JAfejQofHNN9/Ec889F7Vr145evXpFfn5+/P73v48JEyZsiBoBAAAAAAAAYKMrcaAeEVGpUqXo1q1b3H///fHtt9/GPffcE++8807st99+pV0fAAAAAAAAAORElfV586xZs+Lxxx+Phx9+OD788MPYfffdS6suAAAAAAAAAMipEp+hPm/evBgxYkR07do1tt5667jrrruiR48e8emnn8bbb7+9IWoEAAAAAAAAgI2uxGeoN2zYMOrVqxfHHntsDBgwwFnpAAAAAAAAAFRIJQ7Un3vuuTjggAOiUqV1uv06AAAAAAAAAJQLJQ7Uu3XrtiHqAAAAAAAAAIAyxWnmAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKaqU9A1Dhw5NXZ7JZKJatWqx3Xbbxb777huVK1de7+IAAAAAAAAAIFdKHKjffPPN8d1338XChQujXr16kSRJ/Pjjj1GjRo2oVatWzJ49O7bZZpt45ZVXYuutt94QNQMAAAAAAADABlfiS74PGDAgdt999/jss89izpw58f3338enn34aHTp0iFtvvTWmT58e+fn5cd55522IegEAAAAAAABgoyjxGepXXHFFPP3007HtttsWLttuu+3ixhtvjKOPPjr++9//xuDBg+Poo48u1UIBAAAAAAAAYGMq8RnqM2fOjGXLlq22fNmyZTFr1qyIiCgoKIj58+evf3UAAAAAAAAAkCMlDtS7dOkSp59+enzwwQeFyz744IM488wzY7/99ouIiI8++ihatGhRelUCAAAAAAAAwEZW4kB92LBhUb9+/dhtt90iLy8v8vLyon379lG/fv0YNmxYRETUqlUrbrrpplIvFgAAAAAAAAA2lhLfQz0/Pz/Gjh0b//73v+PTTz+NJEmidevWsf322xeu06VLl1ItEgAAAAAAAAA2thIH6hMmTIhOnTpF69ato3Xr1huiJgAAAAAAAADIuRJf8r1r167RtGnTuPTSS2PKlCkboiYAAAAAAAAAyLkSB+ozZsyIiy++OF577bVo165dtGvXLgYPHhxff/31hqgPAAAAAAAAAHKixIF6gwYN4pxzzok33ngj/vOf/0TPnj3jwQcfjObNm8d+++23IWoEAAAAAAAAgI2uxIH6qlq0aBGXXnppDBo0KHbaaaeYMGFCadUFAAAAAAAAADm1zoH6G2+8EWeddVY0atQoTjjhhNhxxx3jhRdeKNE2Bg4cGLvvvnvUrl07ttpqqzjiiCNi6tSpRdZJkiT69+8fBQUFUb169ejcuXN8/PHH61o2AAAAAAAAAGSlxIH65ZdfHi1atIj99tsvvvzyy7jlllti1qxZ8fDDD8dBBx1Uom1NmDAhzj777Hjrrbdi7NixsWzZsujWrVssWLCgcJ3BgwfHkCFD4vbbb49JkyZFfn5+dO3aNebPn1/S0gEAAAAAAAAga1VK+obx48fHhRdeGD179owGDRoUeW3y5Mmxyy67ZL2tMWPGFHk+YsSI2GqrreK9996LfffdN5IkiVtuuSX69esXRx11VEREPPDAA9GwYcN49NFH4/TTTy9p+QAAAAAAAACQlRIH6hMnTizyfO7cufHII4/EX/7yl/jnP/8Zy5cvX+di5s6dGxER9evXj4iIadOmxaxZs6Jbt26F6+Tl5UWnTp1i4sSJqYH64sWLY/HixYXP582bt871kJ3ml47OdQmsgy8GHZLrEgAAAAAAAKBMW+d7qI8bNy5++9vfRqNGjeK2226Lgw8+ON599911LiRJkjj//PNjn332ibZt20ZExKxZsyIiomHDhkXWbdiwYeFrvzRw4MCoW7du4WPrrbde55oAAAAAAAAA2HSV6Az1r7/+Ou6///4YPnx4LFiwII499thYunRpPP3009GmTZv1KuScc86JDz/8MF5//fXVXstkMkWeJ0my2rKVLrvssjj//PMLn8+bN0+oDgAAAAAAAECJZX2G+sEHHxxt2rSJTz75JG677baYMWNG3HbbbaVSxB/+8IcYNWpUvPLKK9GkSZPC5fn5+RERq52NPnv27NXOWl8pLy8v6tSpU+QBAAAAAAAAACWVdaD+8ssvx+9+97u45ppr4pBDDonKlSuv986TJIlzzjknnnnmmRg3bly0aNGiyOstWrSI/Pz8GDt2bOGyJUuWxIQJE6Jjx47rvX8AAAAAAAAAWJOsA/XXXnst5s+fH+3bt48OHTrE7bffHt9999167fzss8+Ohx9+OB599NGoXbt2zJo1K2bNmhU///xzRPzvUu99+/aNAQMGxLPPPhtTpkyJ3r17R40aNeKEE05Yr30DAAAAAAAAwNpkHajvtddecd9998XMmTPj9NNPj8cffzwaN24cK1asiLFjx8b8+fNLvPO77ror5s6dG507d45GjRoVPp544onCdS6++OLo27dvnHXWWdG+ffv45ptv4uWXX47atWuXeH8AAAAAAAAAkK0qJX1DjRo1ok+fPtGnT5+YOnVqDBs2LAYNGhSXXnppdO3aNUaNGpX1tpIkKXadTCYT/fv3j/79+5e0VAAAAIANovmlo3NdAuvgi0GH5LoEAACgnMn6DPU022+/fQwePDi+/vrreOyxx0qrJgAAAAAAAADIufUK1FeqXLlyHHHEESU6Ox0AAAAAAAAAyrJSCdQBAAAAAAAAoKIRqAMAAAAAAABACoE6AAAAAAAAAKQQqAMAAAAAAABACoE6AAAAAAAAAKQQqAMAAAAAAABACoE6AAAAAAAAAKQQqAMAAAAAAABACoE6AAAAAAAAAKQQqAMAAAAAAABACoE6AAAAAAAAAKQQqAMAAAAAAABAiiq5LgAAAAAAKqLml47OdQmsgy8GHZLrEgAAKEOcoQ4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKarkugAAAAAAgE1V80tH57oE1sEXgw7JdQkAwEbiDHUAAAAAAAAASCFQBwAAAAAAAIAUAnUAAAAAAAAASCFQBwAAAAAAAIAUAnUAAAAAAAAASCFQBwAAAAAAAIAUAnUAAAAAAAAASJHTQP3VV1+NHj16REFBQWQymRg5cmSR15Mkif79+0dBQUFUr149OnfuHB9//HFuigUAAAAAAABgk5LTQH3BggWx8847x+233576+uDBg2PIkCFx++23x6RJkyI/Pz+6du0a8+fP38iVAgAAAAAAALCpqZLLnR900EFx0EEHpb6WJEnccsst0a9fvzjqqKMiIuKBBx6Ihg0bxqOPPhqnn376xiwVAAAAAAAAgE1Mmb2H+rRp02LWrFnRrVu3wmV5eXnRqVOnmDhx4hrft3jx4pg3b16RBwAAAAAAAACUVJkN1GfNmhUREQ0bNiyyvGHDhoWvpRk4cGDUrVu38LH11ltv0DoBAAAAAAAAqJjKbKC+UiaTKfI8SZLVlq3qsssui7lz5xY+vvrqqw1dIgAAAAAAAAAVUE7vob42+fn5EfG/M9UbNWpUuHz27NmrnbW+qry8vMjLy9vg9QEAAAAAAABQsZXZM9RbtGgR+fn5MXbs2MJlS5YsiQkTJkTHjh1zWBkAAAAAAAAAm4KcnqH+008/xeeff174fNq0aTF58uSoX79+NG3aNPr27RsDBgyIli1bRsuWLWPAgAFRo0aNOOGEE3JYNQAAAAAAAACbgpwG6u+++2506dKl8Pn5558fERG9evWK+++/Py6++OL4+eef46yzzooffvghOnToEC+//HLUrl07VyUDAAAAAAAAsInIaaDeuXPnSJJkja9nMpno379/9O/ff+MVBQAAAAAAAABRhu+hDgAAAAAAAAC5JFAHAAAAAAAAgBQCdQAAAAAAAABIIVAHAAAAAAAAgBQCdQAAAAAAAABIIVAHAAAAAAAAgBQCdQAAAAAAAABIIVAHAAAAAAAAgBQCdQAAAAAAAABIIVAHAAAAAAAAgBQCdQAAAAAAAABIIVAHAAAAAAAAgBQCdQAAAAAAAABIIVAHAAAAAAAAgBQCdQAAAAAAAABIIVAHAAAAAAAAgBQCdQAAAAAAAABIIVAHAAAAAAAAgBQCdQAAAAAAAABIIVAHAAAAAAAAgBQCdQAAAAAAAABIIVAHAAAAAAAAgBQCdQAAAAAAAABIIVAHAAAAAAAAgBQCdQAAAAAAAABIIVAHAAAAAAAAgBQCdQAAAAAAAABIIVAHAAAAAAAAgBQCdQAAAAAAAABIIVAHAAAAAAAAgBQCdQAAAAAAAABIIVAHAAAAAAAAgBRVcl0AAAAAAACQrvmlo3NdAuvgi0GH5LoEAEqJM9QBAAAAAAAAIIVAHQAAAAAAAABSCNQBAAAAAAAAIIVAHQAAAAAAAABSCNQBAAAAAAAAIIVAHQAAAAAAAABSCNQBAAAAAAAAIIVAHQAAAAAAAABSCNQBAAAAAAAAIIVAHQAAAAAAAABSCNQBAAAAAAAAIIVAHQAAAAAAAABSCNQBAAAAAAAAIIVAHQAAAAAAAABSCNQBAAAAAAAAIIVAHQAAAAAAAABSCNQBAAAAAAAAIIVAHQAAAAAAAABSCNQBAAAAAAAAIIVAHQAAAAAAAABSCNQBAAAAAAAAIIVAHQAAAAAAAABSCNQBAAAAAAAAIIVAHQAAAAAAAABSCNQBAAAAAAAAIIVAHQAAAAAAAABSCNQBAAAAAAAAIIVAHQAAAAAAAABSCNQBAAAAAAAAIIVAHQAAAAAAAABSCNQBAAAAAAAAIIVAHQAAAAAAAABSCNQBAAAAAAAAIIVAHQAAAAAAAABSCNQBAAAAAAAAIEW5CNTvvPPOaNGiRVSrVi122223eO2113JdEgAAAAAAAAAVXJkP1J944ono27dv9OvXLz744IP49a9/HQcddFBMnz4916UBAAAAAAAAUIGV+UB9yJAhceqpp8bvfve72GGHHeKWW26JrbfeOu66665clwYAAAAAAABABVYl1wWszZIlS+K9996LSy+9tMjybt26xcSJE1Pfs3jx4li8eHHh87lz50ZExLx58zZcoZu4FYsX5roE1sHG/p0wJ+XTxpwTM1I++SwhG+aEbPg3h+L4LCEbPksojs8SsmFOyIZ/cyjOxv4saXv13zbq/igdU67pnusSYJO28rM6SZK1rpdJilsjh2bMmBGNGzeON954Izp27Fi4fMCAAfHAAw/E1KlTV3tP//7945prrtmYZQIAAAAAAABQDn311VfRpEmTNb5eps9QXymTyRR5niTJastWuuyyy+L8888vfL5ixYr4/vvvY4sttljjeyDNvHnzYuutt46vvvoq6tSpk+tyKKPMCcUxI2TDnJANc0JxzAjZMCcUx4yQDXNCNswJxTEjZMOcUBwzwvpIkiTmz58fBQUFa12vTAfqDRo0iMqVK8esWbOKLJ89e3Y0bNgw9T15eXmRl5dXZNnmm2++oUpkE1CnTh0fwhTLnFAcM0I2zAnZMCcUx4yQDXNCccwI2TAnZMOcUBwzQjbMCcUxI6yrunXrFrtOpY1QxzqrWrVq7LbbbjF27Ngiy8eOHVvkEvAAAAAAAAAAUNrK9BnqERHnn39+nHTSSdG+ffvYa6+94t57743p06fHGWeckevSAAAAAAAAAKjAynyg3rNnz5gzZ05ce+21MXPmzGjbtm28+OKL0axZs1yXRgWXl5cXV1999Wq3EIBVmROKY0bIhjkhG+aE4pgRsmFOKI4ZIRvmhGyYE4pjRsiGOaE4ZoSNIZMkSZLrIgAAAAAAAACgrCnT91AHAAAAAAAAgFwRqAMAAAAAAABACoE6AAAAAAAAAKQQqANsJL17944jjjgi12VQhpkRsmFOyIY5oThmhGyYE4pjRsiGOSEb5oTimBGKY0bIhjlhXQnUISLuvPPOaNGiRVSrVi122223eO211wpfe+aZZ6J79+7RoEGDyGQyMXny5NwVSqFN4We2tmNcunRpXHLJJbHTTjtFzZo1o6CgIE4++eSYMWNGDisuW9bUv4rUu7XNSERE//79o3Xr1lGzZs2oV69eHHDAAfH222/nqNqyaW09rCj9K25OVnX66adHJpOJW265ZeMVWA5k28Py3L/ijrF3796RyWSKPPbcc88cVVv2rK1/FaV32fwe/Otf/4rDDjss6tatG7Vr144999wzpk+fnoNqy6bielgR+lfcMf7yd2Hl489//nOOKi5b1ta/itK74mbkp59+inPOOSeaNGkS1atXjx122CHuuuuuHFVbNq2thxWlf8XNybfffhu9e/eOgoKCqFGjRhx44IHx2Wef5ajasmltPawI/Xv11VejR48eUVBQEJlMJkaOHLnaOkmSRP/+/aOgoCCqV68enTt3jo8//njjF1sGFde/itC7bGakonx/uCEU17+K0LvijrEifX+4oaythxWlf9l8llSU7w8pnkCdTd4TTzwRffv2jX79+sUHH3wQv/71r+Oggw4q/PJqwYIFsffee8egQYNyXCkrbQo/s+KOceHChfH+++/HlVdeGe+//34888wz8emnn8Zhhx2W48rLhrX1r6L0rrgZiYho1apV3H777fHRRx/F66+/Hs2bN49u3brFd999l8PKy47ielgR+pfNnKw0cuTIePvtt6OgoCAHlZZd2fawPPcv22M88MADY+bMmYWPF198MUcVly3Z9K+89y6bY/zPf/4T++yzT7Ru3TrGjx8f//znP+PKK6+MatWq5bDysqO4HlaE/mUzJ6v+HsycOTOGDx8emUwmjj766BxWXjYU17+K0LtsZuS8886LMWPGxMMPPxz/+te/4rzzzos//OEP8dxzz+Ww8rKjuB5WhP4Vd4xJksQRRxwR//3vf+O5556LDz74IJo1axYHHHBALFiwIMfVlw1r62FF6d+CBQti5513jttvv32N6wwePDiGDBkSt99+e0yaNCny8/Oja9euMX/+/I1YadlUXP8qQu+ymZGK8P3hhlJc/ypC74o7xory/eGGtLYeVpT+ZfNZUhG+PyRLCWzi9thjj+SMM84osqx169bJpZdeWmTZtGnTkohIPvjgg41YHWk29M/spptuStq2bZvUqFEjadKkSXLmmWcm8+fPL3x9xIgRSd26dZMxY8YkrVu3TmrWrJl07949mTFjRuE6y5YtS84777ykbt26Sf369ZOLLrooOfnkk5PDDz+8VI9xVe+8804SEcmXX35ZouOtiErav5L2rrzOyNy5c5OISP7+979ntY+KrqQ9LGn/ytOcfP3110njxo2TKVOmJM2aNUtuvvnmrLa/Kcimh+vTv/IyJ7169cp6e5ua4vq3vr0rLzPSs2fP5Le//e06H2dFV1wP17d/5WVOfunwww9P9ttvv5IdbAVV0v6VtHflZUZ23HHH5Nprry2yzq677ppcccUVWR9rRVZcD9e3f+VhTqZOnZpERDJlypQi+6xfv35y3333ZbWPim5tPSyN/pWFOVlVRCTPPvtskWUrVqxI8vPzk0GDBhUuW7RoUVK3bt3k7rvvLvE+KrJf9q80elceZmRVvvNdu7X1rzx/95rtMa7Kd69rlk0Py+P3ryU9xiTx/WtF5gx1NmlLliyJ9957L7p161Zkebdu3WLixIk5qoq12Rg/s0qVKsXQoUNjypQp8cADD8S4cePi4osvLrLOwoUL48Ybb4yHHnooXn311Zg+fXpceOGFha/fdNNNMXz48Bg2bFi8/vrr8f3338ezzz6b1f7X9Rjnzp0bmUwmNt988+wPtgJal/6VtHflcUaWLFkS9957b9StWzd23nnnrPZTkZW0h+vSv/IyJytWrIiTTjopLrroothxxx2z2vamIpserm//ysucRESMHz8+ttpqq2jVqlWcdtppMXv27BIfb0WTbf/Wp3flYUZWrFgRo0ePjlatWkX37t1jq622ig4dOqReDm9TVFwPS6N/5WFOfunbb7+N0aNHx6mnnpr1cVZUJe3fuvSuvMzIPvvsE6NGjYpvvvkmkiSJV155JT799NPo3r171sdaUWXTw/XtX3mYk8WLF0dEFLmCR+XKlaNq1arx+uuvZ7Wfiqy4HpZG/3I9J9mYNm1azJo1q0gf8vLyolOnTr7vK0Zp9K48zAi5VV5nxHev66e8ff+6Lnz/WsHlOtGHXPrmm2+SiEjeeOONIsuvv/76pFWrVkWW+WvFsiEXP7Mnn3wy2WKLLQqfjxgxIomI5PPPPy9cdscddyQNGzYsfN6oUaMif827dOnSpEmTJln99VtJjnGln3/+Odltt92SE088MdvDqrBK2r/S6F1ZnpHnn38+qVmzZpLJZJKCgoLknXfeKenhVUjZ9rA0+1dW52TAgAFJ165dkxUrViRJkjhDfRXZ9LC0+1dW5+Txxx9PXnjhheSjjz5KRo0aley8887JjjvumCxatGhdDrPCyKZ/pd27sjgjM2fOTCIiqVGjRjJkyJDkgw8+SAYOHJhkMplk/Pjx63ScFUlxPdwQ/SuLc/JLN9xwQ1KvXr3k559/zvawKqyS9q80eldWZ2Tx4sXJySefnEREUqVKlaRq1arJgw8+uC6HWOFk08PS7l9ZnJMlS5YkzZo1S37zm98k33//fbJ48eJk4MCBSUQk3bp1W9dDrTCK6+GG6N/GnpNfipQzBt94440kIpJvvvmmyPLTTjvNnPzCL/u3IXpXFmdkVb7zXbu19a+8fvf6S8XNSJL47rU4xfWwPH7/+ktrO0bfv24aqpR6Qg/lUCaTKfI8SZLVllG2bMif2SuvvBIDBgyITz75JObNmxfLli2LRYsWxYIFC6JmzZoREVGjRo3YdtttC9/TqFGjwrPN5s6dGzNnzoy99tqr8PUqVapE+/btI0mSrOvI9hiXLl0axx13XKxYsSLuvPPOEh1rRZZN/9a1d+VpRrp06RKTJ0+O//u//4v77rsvjj322Hj77bdjq622yno/FVlxPVyf/pWHOXnvvffi1ltvjffff9+/e2uxph6WRv/Kw5xERPTs2bPwf7dt2zbat28fzZo1i9GjR8dRRx1VsoOugNbWv/XtXXmYkRUrVkRExOGHHx7nnXdeRETssssuMXHixLj77rujU6dOWe+nIltTD0ujf+VhTn5p+PDhceKJJ5ar+8RvaNn2b116V15mZOjQofHWW2/FqFGjolmzZvHqq6/GWWedFY0aNYoDDjgg6/1UZGvr4fr2rzzMyWabbRZPP/10nHrqqVG/fv2oXLlyHHDAAXHQQQdlvf1NwZp6WBr9Kytzkg3f96279eldeZoRcqO8zYjvXtdPef/+NRu+f900uOQ7m7QGDRpE5cqVY9asWUWWz549Oxo2bJijqlibDf0z+/LLL+Pggw+Otm3bxtNPPx3vvfde3HHHHRHxv3/8V9pss82KvC+TyZTaP8QlOcalS5fGscceG9OmTYuxY8dGnTp1SqWG8izb/q1r78rbjNSsWTO222672HPPPWPYsGFRpUqVGDZsWKnUUZ5l28N17V95mZPXXnstZs+eHU2bNo0qVapElSpV4ssvv4wLLrggmjdvXip1lGfF9XB9+1de5iRNo0aNolmzZvHZZ5+VSh3l1br0ryS9Ky8z0qBBg6hSpUq0adOmyDo77LBDTJ8+vVTqKM+K6+H69q+8zMmqXnvttZg6dWr87ne/K5X9l3cl6d+69K68zMjPP/8cl19+eQwZMiR69OgR7dq1i3POOSd69uwZN954Y6nUUZ4V18P17V95mZOIiN122y0mT54cP/74Y8ycOTPGjBkTc+bMiRYtWpRKHeVZNj1cn/6VhTnJRn5+fkSE7/vWwfr2rrzMCLlT3mbEd6/rpzx//1oSvn/dNAjU2aRVrVo1dttttxg7dmyR5WPHjo2OHTvmqCrWZkP/zN59991YtmxZ3HTTTbHnnntGq1atYsaMGSXaRt26daNRo0bx1ltvFS5btmxZvPfee1m9P9tjXPl/SD777LP4+9//HltssUWJ6qyosunf+vSuPM1ImiRJCu+btylb1x5m27/yMicnnXRSfPjhhzF58uTCR0FBQVx00UXxt7/9rUT1VkTF9XB9+1de5iTNnDlz4quvvopGjRqVqN6KZl36V5LelZcZqVq1auy+++4xderUIut8+umn0axZsxLVWxEV18P17V95mZNVDRs2LHbbbTf3Ffz/laR/69K78jIjS5cujaVLl0alSkW/qqpcuXLhlRw2ZcX1cH37V17m5Jf723LLLeOzzz6Ld999Nw4//PAS1VsRlaSH69K/sjAn2WjRokXk5+cX6cOSJUtiwoQJvu8rxvr2rrzMCLlTnmbEd6/rp7x//7o+fP9aMbnkO5u8888/P0466aRo37597LXXXnHvvffG9OnT44wzzoiIiO+//z6mT59e+IG98ouu/Pz8wr/aZOPakD+zbbfdNpYtWxa33XZb9OjRI9544424++67S1zjueeeG4MGDYqWLVvGDjvsEEOGDIkff/yx1I5x2bJlccwxx8T7778fL7zwQixfvrzwr4fr168fVatWLXHNFcna+re+vSsvM7JgwYK4/vrr47DDDotGjRrFnDlz4s4774yvv/46fvOb35S43opobT1c3/6VlznZYostVvsPms022yzy8/Nj++23L3G9FdHaeri+/Ssvc/LTTz9F//794+ijj45GjRrFF198EZdffnk0aNAgjjzyyBLXW9GsrX/r27vyMiMRERdddFH07Nkz9t133+jSpUuMGTMmnn/++Rg/fnyJ662Iiuvh+vSvPM1JRMS8efPiqaeeiptuuqnENVZk2fRvXXtXXmakTp060alTp7jooouievXq0axZs5gwYUI8+OCDMWTIkBLXWxGtrYfr27/yMicREU899VRsueWW0bRp0/joo4/i3HPPjSOOOCK6detW4norouJ6uD79Kytz8tNPP8Xnn39e+HzatGkxefLkqF+/fjRt2jQymUz07ds3BgwYEC1btoyWLVvGgAEDokaNGnHCCSeUuN6Kprj+rU/vysuMRPjOd22K619F+O61uGP03Wvx1tbDgoKCCvH9a3Fz4vvXTcwGuC87lDt33HFH0qxZs6Rq1arJrrvumkyYMKHwtREjRiQRsdrj6quvzl3BbNCf2ZAhQ5JGjRol1atXT7p37548+OCDSUQkP/zwQ+H269atW+Q9zz77bLLqR+rSpUuTc889N6lTp06y+eabJ+eff35y8sknJ4cffnipHOO0adNSjzEikldeeSXrfVRka+pfafSuPMzIzz//nBx55JFJQUFBUrVq1aRRo0bJYYcdlrzzzjtZb39TsKYelkb/ysOcpGnWrFly8803Z739TUFJeljS/pWHOVm4cGHSrVu3ZMstt0w222yzpGnTpkmvXr2S6dOnZ739im5N/SuN3pWHGVlp2LBhyXbbbZdUq1Yt2XnnnZORI0dmvf1NQXE9XJ/+lac5ueeee5Lq1asnP/74Y9bb3VQU17/16V15mZGZM2cmvXv3TgoKCpJq1aol22+/fXLTTTclK1asKPExV1Rr6+H69q+8zMmtt96aNGnSpPDf1iuuuCJZvHhx1tvfFKyth+vbv7IwJ6+88krqf9P36tWrcJ0VK1YkV199dZKfn5/k5eUl++67b/LRRx9lfZwVWXH9W9/elZcZ8Z3vmhXXv4rw3Wtxx+i71+KtrYcV5fvX4ubE96+blkySuDkJAAAAAAAAAPySe6gDAAAAAAAAQAqBOrBJeeSRR6JWrVqpjx133HGj1DB9+vQ11lCrVq2YPn36RqmDdGaEbJgTsmFOKI4ZIRvmhOKYEbJhTsiGOaE4ZoTimBGyYU4oj1zyHdikzJ8/P7799tvU1zbbbLNo1qzZBq9h2bJl8cUXX6zx9ebNm0eVKlU2eB2kMyNkw5yQDXNCccwI2TAnFMeMkA1zQjbMCcUxIxTHjJANc0J5JFAHAAAAAAAAgBQu+Q4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAAAAAAAAKQTqAAAAAAAAAJBCoA4AAACbiPHjx0cmk4kff/wx16UAAABAuSBQBwAAgDKgd+/ekclkIpPJRJUqVaJp06Zx5plnxg8//FBq++jYsWPMnDkz6tatW2rbBAAAgIpMoA4AAABlxIEHHhgzZ86ML774Iv7yl7/E888/H2eddVapbb9q1aqRn58fmUym1LYJAAAAFZlAHQAAAMqIvLy8yM/PjyZNmkS3bt2iZ8+e8fLLLxe+PmLEiNhhhx2iWrVq0bp167jzzjuLvH/ixImxyy67RLVq1aJ9+/YxcuTIyGQyMXny5IhIv+T7008/HTvuuGPk5eVF8+bN46abbiqyzebNm8eAAQOiT58+Ubt27WjatGnce++9ha8vWbIkzjnnnGjUqFFUq1YtmjdvHgMHDiz95gAAAEAOCNQBAACgDPrvf/8bY8aMic022ywiIu67777o169fXH/99fGvf/0rBgwYEFdeeWU88MADERExf/786NGjR+y0007x/vvvx3XXXReXXHLJWvfx3nvvxbHHHhvHHXdcfPTRR9G/f/+48sor4/777y+y3k033RTt27ePDz74IM4666w488wz49///ndERAwdOjRGjRoVTz75ZEydOjUefvjhaN68ean3AwAAAHKhSq4LAAAAAP7nhRdeiFq1asXy5ctj0aJFERExZMiQiIi47rrr4qabboqjjjoqIiJatGgRn3zySdxzzz3Rq1eveOSRRyKTycR9990X1apVizZt2sQ333wTp5122hr3N2TIkNh///3jyiuvjIiIVq1axSeffBJ//vOfo3fv3oXrHXzwwYWXnr/kkkvi5ptvjvHjx0fr1q1j+vTp0bJly9hnn30ik8lEs2bNNkRrAAAAICecoQ4AAABlRJcuXWLy5Mnx9ttvxx/+8Ifo3r17/OEPf4jvvvsuvvrqqzj11FOjVq1ahY8//elP8Z///CciIqZOnRrt2rWLatWqFW5vjz32WOv+/vWvf8Xee+9dZNnee+8dn332WSxfvrxwWbt27Qr/dyaTifz8/Jg9e3ZERPTu3TsmT54c22+/ffzxj38scol6AAAAKO8E6gAAAFBG1KxZM7bbbrto165dDB06NBYvXhzXXHNNrFixIiL+d9n3yZMnFz6mTJkSb731VkREJEkSmUymyPaSJFnr/rJ9z8rLzq+UyWQKa9p1111j2rRpcd1118XPP/8cxx57bBxzzDElO3AAAAAoowTqAAAAUEZdffXVceONN8by5cujcePG8d///je22267Io8WLVpERETr1q3jww8/jMWLFxe+/913313r9tu0aROvv/56kWUTJ06MVq1aReXKlbOus06dOtGzZ8+477774oknnoinn346vv/++xIcKQAAAJRN7qEOAAAAZVTnzp1jxx13jAEDBkT//v3jj3/8Y9SpUycOOuigWLx4cbz77rvxww8/xPnnnx8nnHBC9OvXL37/+9/HpZdeGtOnT48bb7wxImK1s9BXuuCCC2L33XeP6667Lnr27Blvvvlm3H777XHnnXdmXePNN98cjRo1il122SUqVaoUTz31VOTn58fmm29eGi0AAACAnHKGOgAAAJRh559/ftx3333RvXv3+Mtf/hL3339/7LTTTtGpU6e4//77C89Qr1OnTjz//PMxefLk2GWXXaJfv35x1VVXRUQUua/6qnbdddd48skn4/HHH4+2bdvGVVddFddee2307t076/pq1aoVN9xwQ7Rv3z523333+OKLL+LFF1+MSpV85QAAAED5l0mKu6EaAAAAUC498sgjccopp8TcuXOjevXquS4HAAAAyh2XfAcAAIAK4sEHH4xtttkmGjduHP/85z/jkksuiWOPPVaYDgAAAOtIoA4AAAAVxKxZs+Kqq66KWbNmRaNGjeI3v/lNXH/99bkuCwAAAMotl3wHAAAAAAAAgBSVcl0AAAAAAAAAAJRFAnUAAAAAAAAASCFQBwAAAAAAAIAUAnUAAAAAAAAASCFQBwAAAAAAAIAUAnUAAAAAAAAASCFQBwAAAAAAAIAUAnUAAAAAAAAASPH/ASpca9YmSDYMAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -434,7 +464,17 @@ }, { "data": { - "image/png": "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", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -459,28 +499,51 @@ "plt.ylabel('Avg volume')\n", "plt.show()\n", "\n", - "#we output the same thing for M12 \n", - "regions = df_M12.columns\n", + "#we output the same thing for M12 for 3D nnUNet \n", + "regions = df_M12_3d.columns\n", "regions = [str(column) for column in regions if 'avg_lesion_volume_between' in column or 'avg_lesion_volume_above' in column]\n", "regions = np.sort(regions)\n", "\n", "plt.figure(figsize=(25, 5))\n", "legend = [region.split('_',4)[-1] for region in regions]\n", - "plt.bar(legend, df_M12[regions].mean())\n", - "plt.title('Distribution of avg volume of lesions per regions in M12')\n", + "plt.bar(legend, df_M12_3d[regions].mean())\n", + "plt.title('Distribution of avg volume of lesions per regions in M12 for 3D nnUNet')\n", "plt.xlabel('Regions')\n", "plt.ylabel('Avg volume')\n", - "plt.show()\n" + "plt.show()\n", + "\n", + "#we output the same thing for M12 for 2D nnUNet\n", + "regions = df_M12_2d.columns\n", + "regions = [str(column) for column in regions if 'avg_lesion_volume_between' in column or 'avg_lesion_volume_above' in column]\n", + "regions = np.sort(regions)\n", + "\n", + "plt.figure(figsize=(25, 5))\n", + "legend = [region.split('_',4)[-1] for region in regions]\n", + "plt.bar(legend, df_M12_2d[regions].mean())\n", + "plt.title('Distribution of avg volume of lesions per regions in M12 for 3D nnUNet')\n", + "plt.xlabel('Regions')\n", + "plt.ylabel('Avg volume')\n", + "plt.show()" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 32, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -490,7 +553,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -515,14 +578,27 @@ "plt.ylabel('Total volume')\n", "plt.show()\n", "\n", - "#we output the same thing for M12 \n", - "regions = df_M12.columns\n", + "#we output the same thing for M12 for 3D nnUNet \n", + "regions = df_M12_3d.columns\n", "regions = [str(column) for column in regions if 'total_lesion_volume_between' in column or 'total_lesion_volume_above' in column]\n", "regions = np.sort(regions)\n", "\n", "plt.figure(figsize=(25, 5))\n", "legend = [region.split('_',4)[-1] for region in regions]\n", - "plt.bar(legend, df_M12[regions].sum())\n", + "plt.bar(legend, df_M12_3d[regions].sum())\n", + "plt.title('Distribution of total volume of lesions per regions in M12')\n", + "plt.xlabel('Regions')\n", + "plt.ylabel('Total volume')\n", + "plt.show()\n", + "\n", + "#we output the same thing for M12 for 2D nnUNet\n", + "regions = df_M12_2d.columns\n", + "regions = [str(column) for column in regions if 'total_lesion_volume_between' in column or 'total_lesion_volume_above' in column]\n", + "regions = np.sort(regions)\n", + "\n", + "plt.figure(figsize=(25, 5))\n", + "legend = [region.split('_',4)[-1] for region in regions]\n", + "plt.bar(legend, df_M12_2d[regions].sum())\n", "plt.title('Distribution of total volume of lesions per regions in M12')\n", "plt.xlabel('Regions')\n", "plt.ylabel('Total volume')\n", @@ -531,12 +607,12 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 33, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -546,7 +622,17 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAB+wAAAHlCAYAAADfkAXrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAACEPklEQVR4nOzde5xVdb0//teGgQEHGcgb4gUUQZPyCmiiopSSmpfKMg95jY50Mkvr8JUwbqUmR1FPF+2IgZbaKTP1HG9YCiZ5yQuapAYmipqaqYygEJf1+8Pf7MPAgMwwsLk8n4/HPB4zn/VZ6/Ne67P2HpjXXmuViqIoAgAAAAAAAACsU60qXQAAAAAAAAAAbIoE9gAAAAAAAABQAQJ7AAAAAAAAAKgAgT0AAAAAAAAAVIDAHgAAAAAAAAAqQGAPAAAAAAAAABUgsAcAAAAAAACAChDYAwAAAAAAAEAFCOwBAAAAAAAAoAIE9gAAsAnq3r17SqVSpkyZUulSyiZNmpRSqZRDDjlkhWWlUimlUimzZ89e53V9kPW5tpb08ssv55RTTsl2222XqqqqlEqlnHrqqZUua51aH+Z6fXztrsyGVOuaWtX7F+uX0aNHb7TvX1OmTEmpVEr37t0rXQoAANAEAnsAANiAHHLIIeXQsP6rXbt22WabbbLnnnvm1FNPzTXXXJN33313ndQze/bsjB49Opdddtk6GW9d2pj3ran++c9/5tBDD821116befPmZZ999kn//v3Tq1evSpcGa92UKVMyevTo3HzzzZUuBdY79R+AKJVKad26debMmbPK/qNGjWrwb5g33nijwfKlS5fmjjvuyHe/+90ce+yx2W677cp9P+jDP6+//nomTZqUz3/+8+nRo0fatWuXzTbbLLvuumv+7d/+Lc8+++ya7i4AAKwVVZUuAAAAaLoddtghO+64Y5Jk8eLFmTt3bv7yl7/kySefzDXXXJOzzjorF110UYYOHdro+sv+IXtNzJ49O2PGjEm3bt3yjW98Y422VVtbm1133bW8X5W2uvu26667JknatGmzjipb9yZPnpyZM2ema9eumTFjRjp16lTpkjZZLfXaZfVNmTIlY8aMySmnnJLjjjuu0uWwhrbccsvsuuuu2XbbbStdSourD6e32267ioy/dOnSXHPNNTnvvPMaXV4URa655ppVbqOuri5HHnlks8bfd99989JLLyVJOnXqlN133z3z5s3Lc889l7/85S/56U9/mquvvjqDBw9u1vYBAGBtEdgDAMAG6PTTT8/o0aMbtC1atCgPPPBALrnkktx66635yle+kmeeeabRK8R/97vfrZtCm+DTn/50Pv3pT1e6jCZ75plnKl3CWvfnP/85SdK/f39hfYWtj69d2JCceeaZOfPMMytdxlrRr1+/iv1O2m233fLMM8+sMrD/3e9+lxdeeCEf/vCH8/TTTzfap1WrVtlrr72y7777pk+fPtl3331zyCGHrNadg6qrq3PGGWfk9NNPT58+fdKq1fs3Fn3xxRdz+umn53e/+11OO+207L333tl9992bv7MAANDC3BIfAAA2Em3atMnBBx+cW265JRdccEGS5PLLL89NN91U4crY0L333ntJ4qpuABrVo0ePHHTQQZk1a1Z+//vfN9pn4sSJSZLTTjttpdvp2LFjHn/88UyYMCFDhw5N3759UyqVVquGhx56KFdeeWX69etXDuuTZMcdd8yNN96YrbbaKosWLcqECROasGcAALD2CewBAGAjNHz48Hz84x9PkowdO3aF5d27d1/p82BvvvnmHHHEEdl6663Tpk2bbLHFFvnwhz+cL37xiw2e4XzIIYfk0EMPTZK88MILDZ5Ju+y2Z8+eXW5Lkttuuy2HH354ttxyy5RKpfI2J02alFKplEMOOWSV+3b//ffnqKOOypZbbpn27dtnr732yg9/+MMsWbJkhb5TpkxJqVRK9+7dV7q9U089NaVSqcEdC1Z335KU22bPnr3CtouiyA033JDDDjssW2yxRdq2bZvtt98+gwcPzuOPP95oPcsfh0mTJmW//fZLhw4d0rFjxxx66KG5++67V3mMVmXOnDn52te+ll69eqV9+/apra1Nv379Mn78+CxYsKBB3/pnE9cfm2uuuabBcWhsnxs7BnfccUfOPPPM7L333tlqq61SXV2d7bbbLp/73Ocybdq0Fdb5/e9/n1KplNra2vKHBRrzox/9KKVSKX369Flh2W9/+9scdthhqa2tzeabb5799tuvfCvmVZ3/a+JPf/pTTj/99Oy8885p165dOnXqlAMPPDATJkxo9PxMkieeeCInnXRSunfvnurq6my++ebp0aNHjjrqqIwfPz5FUTTo/0G133nnnTnmmGOyzTbbpG3btunSpUs+/elP59577220//KvkVtvvTWHHHJIOnXqlJqamuy33375xS9+0exjsiqzZ8/O1772tey6667ZbLPNsvnmm6dPnz655JJLVjgX6/sv+15S/16wxRZbpH379tljjz3ywx/+cIVjtqymnhelUiljxoxJsuL5v6oQsaVet8vvc/38dO7cOR06dMj++++f6667bpXbeOedd3LBBRekb9++qa2tTbt27dKrV6+cffbZefXVVxtdZ9lj8ec//zlf/OIXs91226Wqqmq1H3/SlG3cf//9+cIXvpDtt98+1dXV+dCHPpTDDjssv/71r1c5xn//93+nf//+6dChQzp16pRDDjkk//u//5tk5e/N9e9rp556aqPbbMp7ZGP7+uKLL+ZLX/pStttuu1RXV6d79+755je/mbq6ukbXff311/Pv//7v6d27dzbbbLO0b98+O+64Yw466KCMHDkyr7322iqPwbJW9TtvTWpcXfVB/KRJk1ZYNnfu3PzmN7/Jhz70oRxzzDFrNM7KbLHFFitd1qlTp3zsYx9LkpVe3Q8AABVTAAAAG4wBAwYUSYpRo0Z9YN9bbrmlSFIkKWbPnt1gWbdu3Yokxb333tugfdSoUeV1ttpqq2KfffYpPvzhDxcdO3YskhT9+/cv9z3zzDOLj3zkI0WSorq6uujfv3+Dr8cee6woiqJ4/vnny9u8+OKLiyTFFltsUfTt27fYYYcdit/85jdFURTFxIkTiyTFgAEDVtiX+vXHjx9ftG7duujQoUPRp0+fYocddigv+/SnP10sXry4wXr33ntvkaTo1q3bSo/TKaecssIxXd19W7a2559/vsF2Fy1aVBx//PHl5dtvv33Rp0+fora2tkhStG7dupgwYcIK9Sx7HE4//fQiSbHDDjsUe++9d1FTU1MkKVq1alXcfPPNK92nlZk6dWp5/LZt2xZ77713seuuu5Zr3HfffYs33nij3P/qq68u+vfvXz7OW2+9dYPj8Le//e0Dx3znnXeKJEWpVCq22mqrYo899ij23HPPonPnzuV9+a//+q8G6yxdurTYeeediyTFDTfcsNJt9+vXr0hSXH755Q3af/SjH5X3qXPnzkXfvn2Lrl27FkmKb37zmys9/z/Iyua6KIrihz/8YdG6desiSVFTU1PsscceDc7Po48+uli0aFGDde66666ibdu2RZKiQ4cOxUc/+tFir732Krbccsvyesuvs6rav/GNb5TX23rrrYu+ffs22FZj7xvLvkbGjBlTJCm22WabYt999y2fK0mKH/zgB006Vh9U60033VS0b9++SFK0a9eu2H333YsePXoUrVq1KpIU++23XzF37twG6yz7XjJx4sSiVatWxYc+9KGiT58+Dfbzm9/8ZqP1NOe8WNX5v+z74dp63S67z5dffnmRpLzP22yzTXnZ1772tUbXf/rpp4vu3buX33N22mmn4qMf/WhRXV1dnusnnnhihfXqj8X3vve9on379kW7du2KffbZp9h9992Lb3zjG6tV++pu4//9v/9X3o/a2tpir732Krp06VJuGzp0aKPb//d///dyn2222abB+f6f//mfK3291v+eO+WUU1bYZlPfI5ff18svv7zo1KlTUV1dXeyzzz7lY5+k2H///Vd4Pb/00kvFdtttVyQpqqqqit12263o06dPsd1225XfT+6+++7VOt5Fserfec2t8YPUH8+jjjqqeOedd4qamppi8803L+bNm9eg3xVXXFEkKc4888wG5/Xf//73Dxyj/jXU1Pfs5R1++OFFkuIzn/nMGm0HAABamsAeAAA2IE0J7N98882iVCoVSYpf/OIXDZY1Fkz9/e9/L6qqqoqqqqril7/8ZbF06dIG6zzyyCMrBMyrE4gv+4f5Nm3aFJdddlmDYP29994rimL1Avs2bdoUX/rSl4r58+eXl/3mN78pB3//8R//0eT6GgvsV3fdZWtbPhQaPXp0kaTYbLPNiptuuqncvmDBguLss88uBzR//OMfG6xXfxzatGlTbLHFFsXkyZPLy+bNm1cce+yxRZKie/fuK8zRqvz9738vttpqqyJJ8alPfapB6PToo4+WQ8ljjz12hXVXFXB9kIULFxY/+clPipdffrlB++LFi4v//u//LjbbbLOibdu2xZw5cxosHzlyZJGkOPLIIxvd7rPPPls+hq+//nq5/cknnyyqqqqKJMXw4cOLf/7zn+VlP//5z4u2bdsWbdq0adHA/rbbbitKpVLRvn374oorrmhwfj/yyCNFz549Gz3H9tprryJJMWzYsPLroN4LL7xQXHTRRcWSJUsatK8sBJ80aVI5lL3iiivK6y1evLi4+OKLy+8F9R+QqVd/nrdp06Zo3759cd1115WXLVq0qBg6dGj5AwV1dXVNOForr/Xxxx8vqquri1KpVHzve98r3n333fKymTNnFn379m30fFv2vaS6urq49NJLGxzr733ve+UPh8yaNavBumtyXqzO+b+2XrfLv39+5zvfKQeqS5cuLa644oryhxx+9atfNVj3nXfeKXr06FEkKU444YQGr8G5c+eW3/t69uzZ4HgUxf/NXevWrYuTTjqpwYcnlp2vVVmdbfz4xz8ukhRbbrll8d///d8N1p88eXKx9dZblz+gsazbb7+9/CGIH/7wh+XzfcmSJcW4cePKH4RpSmC/Ju+R9fvapk2b4qSTTirefvvtBvtR/zvqpz/9aYP16j9k8/GPf7zB+1hRvD9HEydOLJ5++ukVD+5KrE5g39QaP8iygX1RFMWpp55aJCmuueaaBv3qP2D16KOPViSwf/nll8vnxaWXXtrs7QAAwNogsAcAgA1IUwL7oijKVwoufwVyY0HaAw88UCQp9tprr9Wup6mB/cqulCyK1Qvsd9111xUCzKIoivPPP798BezChQubVN/aCOznzZtXvivB8h8iqHfQQQcVSYrjjjuuQXv9cUhS/OxnP1thvVdeeaUcLDZ2ZezKjB07tkjev3PCsh94qPfb3/62PO706dMbLFuTwP6DjBgxokhSXHTRRQ3aZ82aVQ7kX3311ZWud/TRRzdor5/PI444YpXjtVRgv3Tp0mL33XcvkhRXXnllo+s98sgjRalUKmpra4sFCxaU2+uvcl42OPsgKwvB64PZr371q42u98UvfrHR13f9eZ6k+O53v7vCeu+++245xLzllltWu85V1XrEEUcUSYpzzz230fVefPHFoqampmjdunXx0ksvlduXfS/50pe+tMJ6S5cuLd8ZY/n3vDU5L5oS2Lf063bZfT7ssMMa7fPlL3+50bm96KKLiuT9O6Msf/eRonj/wxx77713kax4J4v6uevdu3ej666OD9rG/Pnzy1fE33nnnY1u49e//nX5vX9Z9b8Lv/KVrzS63uDBg5sc2K/Je2T9vu62224rfPihKIriq1/9apG8fyeYZQ0aNKhI0qw7pjRmdQL7ptb4QZYP7KdOnVokKQ499NByn6eeeqpIUuyxxx5FURTrPLBfunRpcfTRRxfJ+3djaOqHjwAAYG3zDHsAANiIdejQIcn7zzD+IDvuuGOS5C9/+UseeuihtVLP6aefvkbrn3XWWWnVasX/xnz1q19NVVVVXn/99Tz66KNrNEZL+P3vf5+6urpsttlm+cpXvtJon29961tJksmTJ2fx4sUrLK+trc3gwYNXaN92222z0047JUlmzZq12jXddtttSZJ/+7d/y2abbbbC8o9//OPZe++9G/RtSQ8//HCGDx+e4447LoccckgOPPDAHHjggfnlL3+ZJHnsscca9O/Ro0cOOOCALF68ODfccEODZUVRlJ/bffLJJzdYdueddyZJvvSlLzVax5AhQ1pkf+r9+c9/zp///Oe0a9cup5xySqN99t1333Tr1i1z585tcH7Wv+Z+9rOfrVENzzzzTJ577rkk/3deLe/f//3fkyTTp0/PK6+80miff/u3f1uhrX379uXzoinn28rU1dVl8uTJSZIzzjij0T477LBD+vbtmyVLlmTq1KmN9vnqV7+6QlupVMoBBxzQaK3r6rxo6dftslb27Pj69unTp+dvf/tbuf1Xv/pVkvf3rXXr1ius17p16xx77LFJknvuuafRbZ9yyimNrtsUK9vGvffemzfeeCPdunXLoEGDGl336KOPTps2bfLss8+Wz9t58+bl/vvvT9Ky89kS75H/+q//mjZt2qzQ3r9//yQrzn39e8Avf/nLLFy4sMk1N0dTa2yqgw8+OLvsskumTJmS2bNnJ0kmTpyYZM3/DdBcI0eOzP/8z/+kVCrlmmuuyeabb16ROgAAYGWqKl0AAACw9tQH9R07dvzAvl27ds3gwYNz3XXXZf/990+fPn0ycODA9OvXL4cccki22GKLNa5n9913X6P1P/KRjzTaXltbm+233z6zZ8/O008/nY997GNrNM6aevbZZ5MkO++8c2pqahrt89GPfjRJ8u677+bFF1/Mzjvv3GB5z549UyqVGl13m222yV/+8pfMmzevyTXVj7uymh5//PE888wzq73dD7J48eKcfvrpHxhK/+Mf/1ih7eSTT84f/vCHXHvttQ3Cyvvuuy+zZ89O586dc/TRR5fb33777bz22mtJkj333LPRcbp3756OHTumrq6uGXuzoieeeCLJ+2HxJz7xiZX2q9+/l156qdw2bNiwfPnLX87Xvva1jB8/Pocffnj222+/DBgwYIXzYVXq57ZDhw7p3r17o3123333tG7dOkuWLMkzzzyTrl27Nli+5ZZb5kMf+lCj626zzTZJ0qTzbWWeeuqpLFmyJKVSKV/84hdX2u8vf/lLkobHa1m9evVqtL2xWtfledHSr9tlrez9b9ddd01VVVUWL16cp59+Ottuu22S/zs3L7300kyYMKHRdeuPy8qO85q+Z69qG/X1zZ07NwceeOBK168/ni+99FK6du2aWbNmlc+hPfbYo9F1VjbPq9IS75FNOS+T9z+Edu211+b666/PHXfckUGDBmX//fdP//79s++++670XFoTTa2xOU499dScd955ueaaazJixIj8/Oc/T5s2bRr9MMva9oMf/CDf+973yt+v7MMhAABQSQJ7AADYSL355pvl8Kn+D/Ef5Kc//Wn22GOPTJgwIY888kgeeeSRJElVVVWOOeaYjB8/Pt26dWt2TSsLr1fXqvZjm222yezZs1frbgJrW30NXbp0WWmf+lBt2f7LWtWxqr/LwNKlS9dKTS15DC+++OL87Gc/S/v27XPBBRdk0KBB2XHHHbPZZpulVCrlpz/9ab70pS9l0aJFK6x7wgkn5Bvf+EYef/zxzJgxI717907yf1ekn3DCCamuri73XzZoWtUVlJtvvnmLBfZvvfVWkuS9997LtGnTPrD/u+++W/5+yJAh6dSpU8aPH5+HHnooP/nJT/KTn/wkSdKvX7+MGzcuAwYM+MBtrs7cVlVVZcstt8xrr722Ts63lak/XkVRNPl4LWtl9TZW67o8L9bmcVzZ+1/r1q2zxRZbNJjb+fPnl19TTz755Aduu6nHuSlWto36c+Htt99u0rlQP5/V1dWNXimerHqeV6Yl3iObcl4m738I44EHHsjYsWNz55135he/+EV+8YtfJHn/6vsRI0bkX//1X5u2Ix+gqTU2xymnnJKRI0fmmmuuyZ577pnXXnstn/nMZ7Lllluu8babYsKECfn617+eJLnkkksavTMHAACsD9wSHwAANlK///3vy9+v7hXnbdu2zbBhw/KXv/wlc+bMyQ033JAvfelL2WyzzXLTTTflsMMOy/z589dWyR+o/mrQVS1bNqipvzqxKIqVrrc29qe+hldffXWlfZa9dfW6uD1vU2pqyXomTZqU5P3g/hvf+EY+/OEPp6ampjw3jV1ZX69Tp07lK+ivvfbaJMmCBQty4403Jlnxdvj1j4BIVv2hg5b8QEL9mHvttVeKovjAr1NPPbXB+scff3z+8Ic/5M0338ztt9+eYcOGpXv37nn44YczaNCg1Qpb6+drVa+PxYsX54033mjQvxLqj1enTp1W63iNHj26xcZM1t15sTasbH6XLFlSfh3Vz+1mm21Wvg399OnTP/A4T5kyZZ3sw7Lq5+W4445brXPhkEMOabDewoULG/2gT9K8uazUe+Tee++d3/zmN5k7d26mTZuWCy+8MPvtt19efPHFnHHGGfmv//qvFhtrXdl+++3ziU98Is8//3zOPvvsJMlpp522Tmu49tprc8YZZ6Qoilx00UU555xz1un4AADQFAJ7AADYSP3nf/5nkvfDgB122KHJ62+//fb5whe+kAkTJmTGjBnp2LFjZs6cmbvvvrvcZ23crndVZsyY0Wj73Llzy7d0/vCHP1xur7+S8PXXX1/pNutvvb28Ndm33XbbLUny17/+daVXrj711FNJ3g/W6p9jvDbV11Q/7qpqWvYYrqnnn38+SXLQQQc1uvwPf/jDKtevD+Wvu+66LF26NLfcckvmzp2bnj17rvBBlE6dOmXrrbdO8n+3217e7NmzW+zq+uT/bp89Y8aMvP32283eTm1tbY444ohcdNFF+ctf/pL99tsvCxcuzE9/+tMPXLd+bt9555288MILjfZ5+umns2TJkgb9K6F3794plUp5++238+c//3mdjLmm58W6fp9bmZW9/z377LNZvHhxkv977ZZKpfKt6Ffn6vVKqH/tPPjgg026qnuXXXZJ69atUxTFSj/QsrJ5XpVKvUfWa9u2bQ444ICce+65efDBB8tB949//OMWH2tdqA/oZ8+enS5duuSTn/zkOhv7+uuvz2mnnZalS5fm/PPPz7Bhw9bZ2AAA0BwCewAA2AhdeOGFueeee5Ik3/nOd9Z4e9tvv3122mmnJMkrr7xSbt9ss82SvH878HXhBz/4QaNXy//4xz/O4sWLs9VWW2Xfffctt++yyy4plUpZsGBBHn/88RXWmzZt2koDnzXZtwMPPDAdO3bMu+++W77F+fIuueSSJMmgQYNSVbX2n1Z21FFHJUmuuOKKRvfp3nvvzWOPPZYkOfLII1ts3PrjuOx5U+/Pf/5zbrvttlWu/8lPfjJbb711Xn755dxzzz3lK+1POumklfZPkquvvrrR5Strb6699947PXv2zKJFi3LRRRe1yDbbtGmT/fffP0njx215u+66a3bZZZckyfjx4xvtc/HFF5frXf759evSlltumYEDByZJvvvd766zcdfkvFjX73Mrc/nll6+yfc8992zwqI3Pf/7zSd5/hn0l74yyMocddlg6deqUV199NVddddVqr9ehQ4f0798/Scu+ziv1HrkyBx98cJLVew9YHx133HE54ogj8vGPfzznnnvuOvk9lyS//OUvc/LJJ2fp0qX57ne/m29/+9vrZFwAAFgTAnsAANhILF68OL///e9z7LHHlv9A/Y1vfCOf/vSnV2v93/72t/nGN76Rxx57rEEoXhRFrrvuuvKVhX369Ckv69GjR0qlUl5//fWVXv3ZkmbNmpWhQ4c2CFNuvfXWfO9730uSfOtb30rbtm3Lyzp16lS+svvrX/96g9uvP/744zn55JNX+gzkNdm3mpqa8u13R44cmVtvvbW8bOHChRk2bFimTp2aqqqqdRYmDB06NFtttVVee+21/Mu//EvefPPN8rLHH3+8fDXkcccdlz333LPFxq1/Bvvw4cPz8ssvl9unT5+eo48+unzb7pWpqqrKiSeemOT9DzlMnjw5pVJppYH9N7/5zVRVVeWOO+7IiBEjGtwy+7rrrsu4ceNWOufNUSqVMn78+JRKpVx00UX59re/nblz5zboM3/+/Nx0000ZMmRIua2uri6f+9znctddd+Wf//xng/6PPvpo/vu//ztJ0rdv39Wq47zzzkvy/odXJkyYUH4NL126NJdddll+9rOfJXn/fKy0cePGpV27dvnFL36RIUOGrHAL8n/+85+566678rnPfa7FxlyT86L+wxAPP/xwRYPve+65J2PGjClfTV8URa666qpyOL38e8lZZ52VHj16ZNasWTnssMNW+HBSURR59NFHc/bZZ+ePf/zjutmJZWy++eY5//zzy7VeeumlKwTlb731Vn72s5/l3//93xu0n3vuuUmSn/zkJ/nxj3/c4Hy/+OKL88tf/rLJ9VTiPfJf//Vf87Of/WyFu3O8+uqrufTSS5Os/nvA+qZdu3a5/fbb89vf/rb8HPm17ZZbbsngwYOzZMmSjBkzpvy+CAAA670CAADYYAwYMKBIUuywww5F//79i/79+xf7779/8eEPf7ho3759kaRIUtTW1hZXXHHFSrfTrVu3Iklx7733ltt+85vflNfv2LFjsddeexX77rtvsdVWW5Xbv/71r6+wrU996lNFkqJt27bFPvvsUwwYMKAYMGBA8fjjjxdFURTPP/98ef1VmThxYpGkGDBgwArL6tcfP3580bp162LzzTcv+vbtW96PJMXRRx9dLF68eIV1H3rooaJdu3ZFkqJdu3bFnnvuWfTs2bNIUhx++OHF4MGDiyTFqFGjmrxvy9b2/PPPN1h30aJFxWc/+9ny8h133LHo27dvUVtbWyQpWrduXVx11VVNOg716s+DiRMnrrRPY6ZMmVJ07NixSFJUV1cX++yzT7HbbruVa9xnn32KN954Y4X1Ro0aVSQpTjnllCaNVxRF8eSTTxY1NTXlMffYY49i1113LZ/HF1xwwQfu76OPPlquMUlx8MEHr3LMH/7wh+W+H/rQh4p+/foV2223XZGkOOecc8rnzX333dekfVnZXBdFUVx99dVFdXV1kaRo06ZN8ZGPfKTYb7/9ip49exatW7cukhTdunUr93/rrbfK22vbtm2x++67F/369Su6d+9ebt9///2Ld999t8E4jb126339618vr7vNNtsUffv2bfD6HTly5Arr3HvvvSvUtrxTTjllpa+RVVlVrbfddlv5tdCqVatit912K7+XtWnTptH3jNV5L1nVudrc82LevHnFNttsUyQpOnXqVOy3337l94J6a+t1u+w+X3755eXa+/btW3Tp0qW87N/+7d8aXX/mzJkNXuM77LBDsd9++xV77rlnsfnmm5fbl5+jVc3d6lrdbYwdO7YolUrl9+i99tqr6NevX7HTTjuV2xs7rv/+7//e4Hzv169f+XyvP1ZJihdffLHBeqs6R5r7HvlB+7qy19mee+5ZJClKpVLRo0ePYr/99it22223oqqqqrxfTz/99CqP3+qMsyY1fpD643nUUUet9jrLntd///vfV1h+zDHHFFtssUX5a9l/myzbvry2bduW567+30iNfZ155plN2kcAAFjbXGEPAAAboDlz5mTatGmZNm1aHnvssbzxxhvp2bNnTj755EyaNCmvvPJKhg4d2qRtHnTQQfnRj36Uz3zmM9lmm23y17/+NU888USqqqpy9NFH59Zbb81ll122wnrXXnttzjzzzGy//fZ56qmnMnXq1EydOnWNnue9Mp/+9KczZcqUHHjggXnuuefy6quv5qMf/Wguv/zy/OY3v2n0au1+/frl97//fY466qi0a9cuzz77bNq0aZNx48bltttuW+Vtetdk36qqqvKrX/0q1113XQYOHJh33nkn06dPT01NTU488cQ8/PDDDa64XhcGDBiQP/3pT+V9mjFjRl566aX06dMnF198caZNm5YtttiiRcf86Ec/mgceeCDHHnts2rdvn2effTaLFi3KWWedlccff7zBLbxXZp999slHPvKR8s/1z7Vfma9+9auZPHlyPv7xj2fRokWZMWNGtt1221x99dW55JJLMm/evCRJx44d12znlnH66adnxowZ+frXv56ePXvm+eefz5NPPpklS5ZkwIABueiii3L33XeX+2+++ea57rrr8qUvfSm9evXKa6+9lkcffTRz587NQQcdlB/84AeZOnVq2rdvv9o1XHbZZbn99tvzqU99KkuXLs3jjz+eUqmUY489Nr/73e8yZsyYFtvfNXXkkUfmmWeeybe//e3sueeeeeWVV/L444/n3Xffzf77759Ro0Y1+hiLNdHc86Kmpia/+93v8tnPfjbt2rXLo48+Wn4vWJfOOuus3HLLLfnoRz+av/zlL6mrq0u/fv1y7bXX5kc/+lGj6+yyyy55/PHH86Mf/SiHHnpo3n333Tz22GN57bXX0qtXr3z1q1/N3XffnQMPPHCd7suyvvOd7+Txxx/PkCFDsv322+fZZ5/NjBkz0qZNm3zyk5/MD37wg/z85z9fYb1x48blF7/4Rfbff/+88847eeaZZ7Lbbrvl5ptvzumnn17u15TX+bp+j7zsssvyzW9+M3379i3PzZw5c7L77rvn3HPPzZ/+9KfstttuLTbehmLu3Ln5xz/+Uf6qV1dX12h7vfq7lSxcuLD8b6TGvv70pz+ts30BAIDVUSqKRh4ACQAAABuhv//979l6661TKpXy1ltvpba2ttIlsR5YX8+L2bNnZ6eddkqS+PPN6vvjH/+Yfv36pXPnzg1ubQ8AALA+coU9AAAAm4wJEyYkSfbYY4/1JpSl8pwXG5f6+Tz44IMrXAkAAMAHE9gDAACwUfn5z3+eO+64I0uWLCm3LV68OP/1X/9Vvi381772tUqVR4U4LzYuP/rRj/L73/++wZ0HFixYkPPPPz9XXXVVkuTMM8+sVHkAAACrbeUPawQAAIAN0COPPJLLL7881dXV2WmnndKhQ4fyM7+T5F/+5V8aPOOaTYPzYuNy991358wzz8xmm22WnXfeOW3atMkzzzyT9957L0kyfPjwfOITn6hwlQAAAB9MYA8AAMBG5Qtf+ELeeeedTJs2La+++mrmzZuXTp065fDDD89pp52WE044IaVSqdJlso45LzYuQ4cOzWabbZaHH344L774Yt57771sscUWOfzww/OVr3wlgwYNqnSJAAAAq6VULHvvMAAAAAAAAABgnfAMewAAAAAAAACoALfEX0NLly7NK6+8ks0339yt8wAAAAAAAABIURR555130rVr17RqtfLr6AX2a+iVV17JDjvsUOkyAAAAAAAAAFjPzJkzJ9tvv/1Klwvs19Dmm2+e5P0D3bFjxwpXAwAAAAAAAECl1dXVZYcddijnySsjsF9D9bfB79ixo8AeAAAAAAAAgLIPeqz6ym+WDwAAAAAAAACsNQJ7AAAAAAAAAKgAgT0AAAAAAAAAVIDAHgAAAAAAAAAqQGAPAAAAAAAAABUgsAcAAAAAAACAChDYAwAAAAAAAEAFCOwBAAAAAAAAoALW68D+N7/5TQ477LBsscUWad++fXbaaaeceOKJmTNnToN+dXV1Oeecc9KtW7dUV1enW7duOeecc1JXV7fSbV9//fXp169fampq0rlz5xx55JF55JFH1vYuAQAAAAAAAECSpKrSBTSmKIoMHTo0//Vf/5UePXrkC1/4QjbffPO88sormTp1al544YXssMMOSZL58+dnwIABmT59eg477LCceOKJeeKJJ3LppZfm3nvvzf3335+ampoG27/gggsyYsSI7Ljjjhk6dGjmzZuXX/ziF+nfv3/uuuuuHHLIIRXYawAAAAAAAAA2JaWiKIpKF7G8//zP/8zXv/71fPWrX83ll1+e1q1bN1i+ePHiVFW9/1mDUaNGZezYsRk2bFguuuiicp/69pEjR2bMmDHl9pkzZ2b33XfPzjvvnIcffji1tbVJkhkzZqRfv37Zdttt88wzz5S3/0Hq6upSW1ubuXPnpmPHjmu66wAAAAAAAABs4FY3R17vAvv33nsv22+/fTp16pRnn312lcF5URTZfvvtU1dXl1dffbXBlfQLFixI165ds9lmm2XOnDkplUpJkm9/+9u58MILc8011+Tkk09usL2vfOUrufLKK3PXXXfl8MMPX616BfYAAAAAAAAALGt1c+T17hn2d999d958880cd9xxWbJkSW666aZ8//vfz5VXXplZs2Y16Dtz5sy88sor6d+//wq3vW/Xrl0OPvjgvPzyyw3WmzJlSpI0GsgPGjQoSTJ16tQW3isAAAAAAAAAaGi9e4b9I488kiSpqqrKnnvumWeffba8rFWrVjn77LNz8cUXJ3k/sE+Snj17Nrqt+vaZM2c2+L5Dhw7p0qXLKvuvzMKFC7Nw4cLyz3V1dau9bwAAAAAAAABQb727wv71119PklxyySXp2LFjHn744bzzzju577770qtXr1xyySW54oorkiRz585NkvJz6JdXf2uB+n713zel//IuvPDC1NbWlr922GGHJu4hAAAAAAAAAKyHV9gvXbo0SdK2bdvcfPPN6dq1a5LkoIMOyo033pg99tgjl1xySb7yla9UpL7hw4fnnHPOKf9cV1cntAcAIEnS/dzbKl3CRm/294+qdAkAAAAA0GLWu8C+/ur3Pn36lMP6er17987OO++cWbNm5e233y73XdkV8fW3q1/2ivra2tom9V9edXV1qqurV3NvAAAAAAAAAKBx690t8XfdddckSadOnRpdXt/+3nvvfeAz5xt7xn3Pnj0zb968vPrqq6vVHwAAAAAAAADWhvUusD/00EOTJE8//fQKyxYtWpRZs2alpqYmW221VXr27JmuXbtm2rRpmT9/foO+CxYsyH333ZeuXbtml112KbcPGDAgSTJ58uQVtn/XXXc16AMAAAAAAAAAa8t6F9j36NEjhx9+eGbNmpUJEyY0WPb9738/b7/9dj796U+nqqoqpVIpQ4YMybx58zJ27NgGfS+88MK89dZbGTJkSEqlUrn9tNNOS1VVVc4///wGt8afMWNGrr322vTo0SMDBw5cuzsJAAAAAAAAwCavVBRFUekilvfcc8/lgAMOyOuvv56jjjoqu+22Wx5//PHcc8896datWx588MF06dIlSTJ//vwceOCBmT59eg477LDsu+++eeKJJ3LHHXdkr732yv3335+ampoG2z///PNz3nnnZccdd8zxxx+f+fPn54Ybbsh7772Xu+66q3yV/+qoq6tLbW1t5s6dm44dO7bocQAAYMPS/dzbKl3CRm/294+qdAkAAAAA8IFWN0deLwP7JJkzZ05GjhyZO++8M//4xz/SpUuXHHPMMRk5cmS23nrrBn3nzp2bMWPG5MYbb8yrr76aLl265Pjjj8+oUaNSW1vb6Pavu+66XHbZZZkxY0batm2bj33sYxk7dmz69u3bpDoF9gAA1BPYr30CewAAAAA2BBt8YL+hENgDAFBPYL/2CewBAAAA2BCsbo683j3DHgAAAAAAAAA2BQJ7AAAAAAAAAKgAgT0AAAAAAAAAVIDAHgAAAAAAAAAqQGAPAAAAAAAAABUgsAcAAAAAAACAChDYAwAAAAAAAEAFCOwBAAAAAAAAoAIE9gAAAAAAAABQAQJ7AAAAAAAAAKgAgT0AAAAAAAAAVIDAHgAAAAAAAAAqQGAPAAAAAAAAABUgsAcAAAAAAACAChDYAwAAAAAAAEAFCOwBAAAAAAAAoAIE9gAAAAAAAABQAVWVLgAAaHndz72t0iVs9GZ//6hKlwAAAAAAwAbOFfYAAAAAAAAAUAECewAAAAAAAACoAIE9AAAAAAAAAFSAwB4AAAAAAAAAKkBgDwAAAAAAAAAVILAHAAAAAAAAgAoQ2AMAAAAAAABABQjsAQAAAAAAAKACBPYAAAAAAAAAUAECewAAAAAAAACoAIE9AAAAAAAAAFSAwB4AAAAAAAAAKkBgDwAAAAAAAAAVILAHAAAAAAAAgAoQ2AMAAAAAAABABQjsAQAAAAAAAKACBPYAAAAAAAAAUAECewAAAAAAAACoAIE9AAAAAAAAAFSAwB4AAAAAAAAAKkBgDwAAAAAAAAAVILAHAAAAAAAAgAoQ2AMAAAAAAABABQjsAQAAAAAAAKACBPYAAAAAAAAAUAECewAAAAAAAACoAIE9AAAAAAAAAFSAwB4AAAAAAAAAKkBgDwAAAAAAAAAVsF4G9t27d0+pVGr0a+jQoSv0r6uryznnnJNu3bqluro63bp1yznnnJO6urqVjnH99denX79+qampSefOnXPkkUfmkUceWZu7BQAAAAAAAABlVZUuYGVqa2vzjW98Y4X2Pn36NPh5/vz5GTBgQKZPn57DDjssJ554Yp544olceumluffee3P//fenpqamwToXXHBBRowYkR133DFDhw7NvHnz8otf/CL9+/fPXXfdlUMOOWQt7hlsWrqfe1ulS9jozf7+UZUuAQAAAAAAgGZYbwP7Tp06ZfTo0R/Yb9y4cZk+fXqGDRuWiy66qNw+atSojB07NuPGjcuYMWPK7TNnzsyoUaPSq1evPPzww6mtrU2SnHXWWenXr1+GDBmSZ555JlVV6+2hAQAAAAAAAGAjsF7eEn91FUWRCRMmpEOHDhk5cmSDZcOHD0/nzp1z9dVXpyiKcvvEiROzePHijBgxohzWJ0nv3r1z8skn57nnnss999yzzvYBAAAAAAAAgE3TehvYL1y4MNdcc00uuOCCXHHFFXniiSdW6DNz5sy88sor6d+//wq3vW/Xrl0OPvjgvPzyy5k1a1a5fcqUKUmSww8/fIXtDRo0KEkyderUVdZVV1fX4AsAAAAAAAAAmmq9ve/7q6++mlNPPbVB2yc/+cn87Gc/y5Zbbpnk/cA+SXr27NnoNurbZ86c2eD7Dh06pEuXLqvsvzIXXnhhg1vsAwAAAAAAAEBzrJdX2J9++umZMmVK/v73v6euri4PPvhgjjjiiNx555055phjyre4nzt3bpI0uLX9sjp27NigX/33Tem/vOHDh2fu3Lnlrzlz5jR9BwEAAAAAAADY5K2XV9gv/zz6/fbbL//7v/+bAQMG5P7778/tt9+eo446qiK1VVdXp7q6uiJjAwAAAAAAALDxWC+vsG9Mq1atctpppyVJpk2bluT/rqxf2RXx9c+XX/aK+tra2ib1BwAAAAAAAIC1YYMJ7JOUn13/7rvvJvngZ8439oz7nj17Zt68eXn11VdXqz8AAAAAAAAArA0bVGD/0EMPJUm6d++e5P1gvWvXrpk2bVrmz5/foO+CBQty3333pWvXrtlll13K7QMGDEiSTJ48eYXt33XXXQ36AAAAAAAAAMDast4F9n/+85/z9ttvr9B+//33Z/z48amurs5nPvOZJEmpVMqQIUMyb968jB07tkH/Cy+8MG+99VaGDBmSUqlUbj/ttNNSVVWV888/v8Gt8WfMmJFrr702PXr0yMCBA9fOzgEAAAAAAADA/6+q0gUs75e//GXGjRuXj3/84+nevXuqq6vz1FNPZfLkyWnVqlWuvPLK7LjjjuX+w4YNy6233ppx48bl8ccfz7777psnnngid9xxR/baa68MGzaswfZ79eqV0aNH57zzzssee+yR448/PvPnz88NN9yQRYsW5aqrrkpV1Xp3WAAAAAAAAADYyKx3yfShhx6ap59+Oo899limTp2aBQsWZJtttskJJ5yQs88+O/369WvQv6amJlOmTMmYMWNy4403ZsqUKenSpUvOPvvsjBo1KjU1NSuMMWLEiHTv3j2XXXZZrrjiirRt2zYHHHBAxo4dm759+66rXQUAAAAAAABgE7beBfYDBgxo8jPka2trM378+IwfP3611xk8eHAGDx7c1PIAAAAAAAAAoEWsd8+wBwAAAAAAAIBNgcAeAAAAAAAAACpAYA8AAAAAAAAAFSCwBwAAAAAAAIAKENgDAAAAAAAAQAUI7AEAAAAAAACgAgT2AAAAAAAAAFABAnsAAAAAAAAAqACBPQAAAAAAAABUgMAeAAAAAAAAACpAYA8AAAAAAAAAFSCwBwAAAAAAAIAKENgDAAAAAAAAQAUI7AEAAAAAAACgAgT2AAAAAAAAAFABAnsAAAAAAAAAqACBPQAAAAAAAABUgMAeAAAAAAAAACpAYA8AAAAAAAAAFSCwBwAAAAAAAIAKqKp0AQAA/J/u595W6RI2CbO/f1SlSwAAAAAAcIU9AAAAAAAAAFSCwB4AAAAAAAAAKkBgDwAAAAAAAAAVILAHAAAAAAAAgAoQ2AMAAAAAAABABQjsAQAAAAAAAKACBPYAAAAAAAAAUAECewAAAAAAAACoAIE9AAAAAAAAAFSAwB4AAAAAAAAAKkBgDwAAAAAAAAAVILAHAAAAAAAAgAoQ2AMAAAAAAABABQjsAQAAAAAAAKACqipdAADrp+7n3lbpEjYJs79/VKVLAAAAAAAAKsQV9gAAAAAAAABQAQJ7AAAAAAAAAKgAgT0AAAAAAAAAVIDAHgAAAAAAAAAqQGAPAAAAAAAAABUgsAcAAAAAAACACqhq7op///vfM3HixPzxj3/M22+/nSVLlqzQp1Qq5Xe/+90aFQgAAAAAAAAAG6NmBfZPPvlkBg4cmLfeeitFUay0X6lUanZhAAAAAAAAALAxa9Yt8b/5zW/mzTffzIgRI/L8889n0aJFWbp06QpfjV11DwAAAAAAAAA08wr7Bx54IMcdd1zGjh3b0vUAAAAAAAAAwCahWVfYt23bNj169GjpWlZq3LhxKZVKKZVKefDBBxvtU1dXl3POOSfdunVLdXV1unXrlnPOOSd1dXUr3e7111+ffv36paamJp07d86RRx6ZRx55ZG3tBgAAAAAAAACUNSuwHzhw4DoLtp9++umMHDkyNTU1K+0zf/78DBgwIJdeeml23XXXnH322dl9991z6aWXZsCAAZk/f/4K61xwwQUZPHhwXnvttQwdOjSf//znM23atPTv3z9TpkxZi3sEAAAAAAAAAM0M7P/jP/4jM2bMyMUXX9zS9TSwZMmSnHLKKdlzzz3z6U9/eqX9xo0bl+nTp2fYsGGZPHlyvv/97+eOO+7IyJEjM3369IwbN65B/5kzZ2bUqFHp1atXnnzyyVxyySX5yU9+kj/84Q+pqqrKkCFDsnjx4rW6bwAAAAAAAABs2lbrGfann376Cm29e/fO//t//y9XXnll9txzz9TW1q7Qp1Qq5eqrr252cRdddFGeeOKJPPbYY/mP//iPRvsURZEJEyakQ4cOGTlyZINlw4cPzw9+8INcffXVGT16dEqlUpJk4sSJWbx4cUaMGNGg7t69e+fkk0/OlVdemXvuuSeHH354s2sHAAAAAAAAgFVZrcB+0qRJK13217/+NX/9618bXbYmgf1TTz2VMWPG5Lzzzkvv3r1X2m/mzJl55ZVXMmjQoBVum9+uXbscfPDBueWWWzJr1qz07NkzScq3vG8skB80aFCuvPLKTJ06VWAPAAAAAAAAwFqzWoH9888/v7braGDx4sU59dRT8+EPfzjnnnvuKvvOnDkzScph/PLq22fOnNng+w4dOqRLly6r7N+YhQsXZuHCheWf6+rqPmBvAAAAAAAAAGBFqxXYd+vWbW3X0cAFF1yQJ554Ig899FDatGmzyr5z585NkkZvyZ8kHTt2bNCv/vutt956tfsv68ILL8yYMWNWvQMAAAAAAAAA8AFaNWel008/Pbfeeusq+9x+++05/fTTm7ztJ554It/73vfyrW99K/vss09zylurhg8fnrlz55a/5syZU+mSAAAAAAAAANgANSuwnzRpUqZPn77KPn/6059yzTXXNHnbp5xySnr06JHRo0evVv/6K+tXdkV8/S3rl70Cv7a2tkn9l1VdXZ2OHTs2+AIAAAAAAACApmpWYL86FixYkKqq1brjfgNPPPFEnnnmmbRr1y6lUqn8VR/+f+xjH0upVMrNN9+c5IOfOd/YM+579uyZefPm5dVXX12t/gAAAAAAAADQ0pqeqP//SqVSo+1FUeSll17K7bffnq5duzZ5u1/60pcabb/vvvsyc+bMHHPMMdlqq63SvXv3JO8H6127ds20adMyf/781NTUlNdZsGBB7rvvvnTt2jW77LJLuX3AgAF54IEHMnny5Jx88skNxrnrrrvKfQAAAAAAAABgbVntwL5Vq1YNQvrRo0ev8rb1RVHk//2//9fkgiZMmNBo+6mnnpqZM2dm+PDh2X///cvtpVIpQ4YMydixYzN27NhcdNFF5WUXXnhh3nrrrXzta19rUPtpp52Wiy++OOeff36OPfbY8u3vZ8yYkWuvvTY9evTIwIEDm1w7AAAAAAAAAKyu1Q7sDz744HLofd9992XHHXcsX+W+rNatW+dDH/pQBg4cmC9/+cstVuiqDBs2LLfeemvGjRuXxx9/PPvuu2+eeOKJ3HHHHdlrr70ybNiwBv179eqV0aNH57zzzssee+yR448/PvPnz88NN9yQRYsW5aqrrmrW7fwBAAAAAAAAYHWtdio9ZcqU8vetWrXKaaedlpEjR66NmpqspqYmU6ZMyZgxY3LjjTdmypQp6dKlS84+++yMGjWqwW3y640YMSLdu3fPZZddliuuuCJt27bNAQcckLFjx6Zv374V2AsAAAAAAAAANiXNuox86dKlLV3HB5o0aVImTZq00uW1tbUZP358xo8fv9rbHDx4cAYPHtwC1QEAAAAAAABA07SqdAEAAAAAAAAAsClq1hX2AwcO/MA+rVq1SseOHbPrrrvmuOOOy3777decoQAAAAAAAABgo9SswL7+efalUilFUaywfPn2cePG5bTTTsuECROaVyUAAAAAAAAAbGSadUv89957L0cffXR233333HDDDXnhhReyYMGCvPDCC7n++uvTu3fvHHPMMZkzZ04mT56cffbZJxMnTswVV1zR0vUDAAAAAAAAwAapWYH9qFGj8tRTT+Whhx7KCSeckB122CFt27bNDjvskC984Qt54IEH8uSTT+YHP/hBPvGJT+Tuu+/OVlttlYkTJ7Z0/QAAAAAAAACwQWpWYH/99dfn05/+dDbbbLNGl9fU1OQzn/lMbrjhhiRJp06d8slPfjJPP/108ysFAAAAAAAAgI1IswL7v//971m8ePEq+yxevDivv/56+edtt902S5Ysac5wAAAAAAAAALDRaVZg36NHj9x44415++23G13+5ptv5le/+lV69OhRbnvllVfyoQ99qFlFAgAAAAAAAMDGplmB/de+9rW88sor2WefffKjH/0ojz32WObMmZPHHnssP/zhD9OnT5+8+uqr+drXvpYkWbp0ae6555707du3RYsHAAAAAAAAgA1VVXNWOuOMM/Lyyy/nwgsvzFlnndVgWVEUadWqVYYPH54zzjgjyftX3H/rW9/KAQccsOYVAwAAAAAAAMBGoFmBfZKMHTs2J510Uq6//vo8+eSTqaurS8eOHbPnnnvmC1/4Qnr16lXuu+WWW+brX/96ixQMAAAAAAAAABuDZgf2SdKzZ8+MGjWqpWoBAAAAAAAAgE1Gs55hDwAAAAAAAACsmTW6wv7hhx/OH//4x7z99ttZsmTJCstLpVK+853vrMkQAAAAAAAAALBRalZg/+abb+a4447LtGnTUhTFSvsJ7AEAAAAAAACgcc0K7M8555zcf//9OeSQQ3LKKadk++23T1XVGl2sDwAAAAAAAACblGal7P/7v/+bfv365Xe/+11KpVJL1wQAAAAAAAAAG71WzVlpwYIFOfjgg4X1AAAAAAAAANBMzQrs995778yePbuFSwEAAAAAAACATUezAvvRo0fn1ltvzYMPPtjS9QAAAAAAAADAJqFZz7B/+eWX86lPfSoDBgzI4MGDs/fee6e2trbRvieffPIaFQgAAAAAAAAAG6NmBfannnpqSqVSiqLIpEmTMmnSpBWeZ18URUqlksAeAAAAAAAAABrRrMB+4sSJLV0HAAAAAAAAAGxSmhXYn3LKKS1dBwAAAAAAAABsUlpVugAAAAAAAAAA2BQ16wr7er/5zW9yww035Jlnnsm7776bWbNmJUmeeeaZ3HrrrRk8eHC22267FikUAABgbel+7m2VLmGTMPv7R1W6BAAAAID1SrMC+6VLl+bEE0/MjTfemCRp37593nvvvfLyzp07Z8SIEVmyZEmGDx/eMpUCAAAAAAAAwEakWbfEv/TSS/OrX/0qZ5xxRt56661861vfarB8m222yUEHHZTbbnOVCgAAAAAAAAA0plmB/aRJk9KnT5/8+Mc/TseOHVMqlVbos8suu+T5559f4wIBAAAAAAAAYGPUrMB+1qxZOfjgg1fZZ4sttsg//vGPZhUFAAAAAAAAABu7ZgX27du3T11d3Sr7vPDCC+nUqVNzNg8AAAAAAAAAG71mBfZ777137rrrrixcuLDR5W+++WbuvPPO7L///mtUHAAAAAAAAABsrJoV2J911lmZM2dOjj/++Lz88ssNlj333HP59Kc/nblz5+ass85qkSIBAAAAAAAAYGNT1ZyVjj322Jx77rn5/ve/nx133DE1NTVJkq233jr/+Mc/UhRFvvOd72TgwIEtWiwAAAAAAAAAbCyadYV9klxwwQW566678qlPfSqbbbZZWrdunaVLl+aTn/xk7rjjjowZM6Yl6wQAAAAAAACAjUqzrrCvd9hhh+Wwww5rqVoAAAAAAAAAYJPR7CvsAQAAAAAAAIDmE9gDAAAAAAAAQAWs1i3xW7VqlVKp1OSNl0qlLF68uMnrAQAAAAAAAMDGbrUC+4MPPrhZgT0AAAAAAAAA0LjVCuynTJmylssAAAAAAAAAgE2LZ9gDAAAAAAAAQAUI7AEAAAAAAACgAgT2AAAAAAAAAFABAnsAAAAAAAAAqACBPQAAAAAAAABUwHoX2L/99ts566yz8rGPfSxdunRJdXV1tttuuwwcODC//vWvUxTFCuvU1dXlnHPOSbdu3VJdXZ1u3brlnHPOSV1d3UrHuf7669OvX7/U1NSkc+fOOfLII/PII4+szV0DAAAAAAAAgLL1LrB/44038tOf/jQ1NTU57rjj8s1vfjNHHHFEZsyYkeOPPz5nnHFGg/7z58/PgAEDcumll2bXXXfN2Wefnd133z2XXnppBgwYkPnz568wxgUXXJDBgwfntddey9ChQ/P5z38+06ZNS//+/TNlypR1tKcAAAAAAAAAbMqqKl3A8nbaaae8/fbbqapqWNo777yT/fffP1dddVW+/vWvp3fv3kmScePGZfr06Rk2bFguuuiicv9Ro0Zl7NixGTduXMaMGVNunzlzZkaNGpVevXrl4YcfTm1tbZLkrLPOSr9+/TJkyJA888wzK4wPAAAAAAAAAC2p2an0P//5z9x888354x//mLfffjtLlixZoU+pVMrVV1/dpO22bt260fbNN988gwYNyp///OfMmjUrvXv3TlEUmTBhQjp06JCRI0c26D98+PD84Ac/yNVXX53Ro0enVColSSZOnJjFixdnxIgR5bA+SXr37p2TTz45V155Ze65554cfvjhTaobAAAAAAAAAJqiWYH9Cy+8kMMOOyzPPfdco8+Ur9ecwH5lFixYkHvuuSelUim77757kvevln/llVcyaNCg1NTUNOjfrl27HHzwwbnlllsya9as9OzZM0nKt7xvLJAfNGhQrrzyykydOlVgDwAAAAAAAMBa1azA/uyzz86sWbNy0kkn5fTTT8/222/f4reQf/vtt3PZZZdl6dKlef3113P77bdnzpw5GTVqVDl8nzlzZpKUf17esv2W/b5Dhw7p0qXLKvuvzMKFC7Nw4cLyz3V1dc3YOwAAAAAAAAA2dc1K2e+55558/OMfzzXXXNPS9ZS9/fbbDZ4936ZNm/zHf/xHvvnNb5bb5s6dmyQNbm2/rI4dOzboV//91ltvvdr9l3fhhRc2qAsAAAAAAAAAmqNVc1ZaunRp9t5775aupYHu3bunKIosXrw4zz//fMaOHZsRI0bks5/9bBYvXrxWx16V4cOHZ+7cueWvOXPmVKwWAAAAAAAAADZczbrC/mMf+1iefvrplq6lUa1bt0737t1z7rnnpnXr1hk2bFiuuuqqfOUrXylfWb+yK+Lrb1e/7BX4tbW1Teq/vOrq6lRXVzdrXwAAAAAAAACgXrOusP/+97+fe++9NzfeeGNL17NKhx9+eJJkypQpST74mfONPeO+Z8+emTdvXl599dXV6g8AAAAAAAAAa0OzrrD/n//5nxx66KE54YQTMmDAgOy9996NXpVeKpXyne98Z42LrPfKK68kSaqq3i+7Z8+e6dq1a6ZNm5b58+enpqam3HfBggW577770rVr1+yyyy7l9gEDBuSBBx7I5MmTc/LJJzfY/l133VXuAwAAAAAAAABrU7MC+9GjR5e/nzJlSvmK9+U1J7CfPn16dtpppxU+APDmm2/m29/+dpLkiCOOKG9/yJAhGTt2bMaOHZuLLrqo3P/CCy/MW2+9la997WsplUrl9tNOOy0XX3xxzj///Bx77LHlcWbMmJFrr702PXr0yMCBA5tUMwAAAAAAAAA0VbMC+3vvvbel6yibNGlSJkyYkEMPPTTdunVLTU1NXnjhhdx2222ZN29ePvvZz+Zf/uVfyv2HDRuWW2+9NePGjcvjjz+efffdN0888UTuuOOO7LXXXhk2bFiD7ffq1SujR4/Oeeedlz322CPHH3985s+fnxtuuCGLFi3KVVddVb6CHwAAAAAAAADWlmYl02vzlvHHH3985s6dmwcffDD33Xdf3n333XzoQx/KgQcemJNPPjlf+MIXGlwxX1NTkylTpmTMmDG58cYbM2XKlHTp0iVnn312Ro0a1eA2+fVGjBiR7t2757LLLssVV1yRtm3b5oADDsjYsWPTt2/ftbZvAAAAAAAAAFBvvbuU/MADD8yBBx7YpHVqa2szfvz4jB8/frXXGTx4cAYPHtzU8gAAAAAAAACgRaxRYP+HP/whkyZNyvTp0zN37tx07Ngxe++9d04++eQmh+4AAAAAAAAAsClpdmD/rW99K5deemmKokiStGrVKkuXLs2jjz6aq6++Ol//+tebdMU7AAAAAAAAAGxKWjVnpWuvvTbjx4/PrrvumhtuuCF/+9vfsnjx4rz66qv5xS9+kd122y2XX355rr322pauFwAAAAAAAAA2Cs0K7K+44orssMMOeeihh3LCCSdkm222SZJsvfXW+fznP58HHngg22+/fX784x+3aLEAAAAAAAAAsLFoVmD/1FNP5bOf/Ww233zzRpd37Ngxn/nMZzJjxow1Kg4AAAAAAAAANlbNCuyTlJ9dvzKlUqm5mwYAAAAAAACAjV6zAvuPfOQj+fWvf5158+Y1uvydd97Jr3/96/Tu3XuNigMAAAAAAACAjVWzAvuhQ4fmpZdeysc+9rH8+te/zhtvvJEkeeONN3LjjTfmgAMOyEsvvZSvfOUrLVosAAAAAAAAAGwsqpqz0imnnJLp06fn8ssvz+c///kkSatWrbJ06dIk798u/2tf+1pOOeWUlqsUAAAAAAAAADYizQrsk+TSSy/NZz/72UycODHTp09PXV1dOnbsmL333junnHJKDjrooJasEwAAAAAAAAA2Ks0O7JPkwAMPzIEHHthStQAAAAAAAADAJqNZz7AHAAAAAAAAANbMal1h/+KLLyZJtttuu7Ru3br88+rYcccdm1cZAAAAAAAAAGzEViuw7969e0qlUp5++un06tWr/PMHKZVKWbx48RoXCQAAAAAAAAAbm9UK7E8++eSUSqXU1tY2+BkAAAAAAAAAaJ7VCuwnTZq0yp8BAAAAAAAAgKZpVekCAAAAAAAAAGBTtFpX2K+uBx54IP/7v/+b9u3b5/TTT0/Xrl1bcvMAAAAAAAAAsNFo1hX23/rWt9KuXbu8+eab5bYbb7wxBx10UC688MKMHDky++yzT15++eUWKxQAAAAAAAAANibNCuzvvffeHHroofnQhz5UbvvOd76T2traXHvttRk3blz+8Y9/5JJLLmmxQgEAAAAAAABgY9KswP7FF19Mz549yz/PnDkzzz77bM4666x88YtfzLe+9a0ceeSRuf3221usUAAAAAAAAADYmDQrsJ83b146dOhQ/vn+++9PqVTKEUccUW7bfffd89JLL615hQAAAAAAAACwEapqzkrbbrttnn322fLPd955Zzp06JB999233FZXV5fq6uo1rxAAAADYKHU/97ZKl7DRm/39oypdAgAAAKvQrMB+wIABueGGG/KjH/0o7dq1y80335xjjjkmrVu3LveZNWtWtt9++xYrFAAAAAAAAAA2Js26Jf6IESPSvn37nHXWWfnyl7+cNm3aZNSoUeXlf//73zNlypT079+/xQoFAAAAAAAAgI1Js66w32WXXfLnP/85v/71r5Mkn/rUp9K9e/fy8hdeeCH/9m//ln/5l39pkSIBAAAAAAAAYGPTrMA+ef859meeeWajy/r06ZM+ffo0uygAAAAAAAAA2Ng1O7Cv9+c//znPPPNM5s+fn5NOOqklagIAAAAAAACAjV6znmGfJH/84x+z11575aMf/Wg+97nP5dRTTy0vu++++7LZZpvl1ltvbYkaAQAAAAAAAGCj06zAfsaMGRk4cGCef/75nH322TniiCMaLD/ooIOy5ZZb5le/+lWLFAkAAAAAAAAAG5tmBfajRo1Kkjz66KO5+OKL07dv3wbLS6VSPvaxj+WPf/zjmlcIAAAAAAAAABuhZgX2U6dOzWc/+9nssssuK+2z44475m9/+1uzCwMAAAAAAACAjVmzAvt33nknW2+99Sr7LFiwIEuWLGlWUQAAAAAAAACwsWtWYL/DDjvkqaeeWmWfRx99ND169GhWUQAAAAAAAACwsWtWYP+pT30qkydPzj333NPo8l/+8pd58MEHc9xxx61JbQAAAAAAAACw0apqzkrf/va3c+ONN+aII47IKaecUn5W/Y9//OM88MADueGGG9K9e/ecc845LVosAAAAAAAAAGwsmhXYb7XVVpk6dWpOOumkTJgwodx+5plnJkn222+/3HDDDamtrW2ZKgEAAAAAAABgI9OswD5Jdt5550ybNi3Tp0/Pgw8+mDfffDMdO3bMfvvtl759+7ZkjQAAAAAAAACw0Wl2YF9vr732yl577bVC+w9+8IPce++9uemmm9Z0CAAAAAAAAADY6LRaWxt+7LHHcsstt6ytzQMAAAAAAADABm2tBfYAAAAAAAAAwMoJ7AEAAAAAAACgAgT2AAAAAAAAAFABAnsAAAAAAAAAqACBPQAAAAAAAABUQNXqdjzyyCObtOE//elPTS4GAAAAAAAAADYVqx3Y33nnnU3eeKlUavI6L7/8cn71q1/l9ttvzzPPPJNXX301H/rQh9K/f/8MGzYs++233wrr1NXVZfTo0fn1r3+dV199NV26dMlnP/vZjB49Oh07dmx0nOuvvz6XXXZZZsyYkbZt2+ZjH/tYxo4dmz59+jS5ZgAAAAAAAABoqtUO7J9//vm1WUfZD37wg1x00UXp0aNHDjvssGy99daZOXNmbr755tx888254YYb8vnPf77cf/78+RkwYECmT5+eww47LCeeeGKeeOKJXHrppbn33ntz//33p6ampsEYF1xwQUaMGJEdd9wxQ4cOzbx58/KLX/wi/fv3z1133ZVDDjlknewrAAAAAAAAAJuu1Q7su3XrtjbrKOvXr1/uu+++HHTQQQ3af//73+fjH/94vvKVr+TYY49NdXV1kmTcuHGZPn16hg0blosuuqjcf9SoURk7dmzGjRuXMWPGlNtnzpyZUaNGpVevXnn44YdTW1ubJDnrrLPSr1+/DBkyJM8880yqqlb70AAAAABscrqfe1ulS9jozf7+UZUuAQAAWMtaVbqA5X3mM59ZIaxPkoMOOiiHHnpo3nzzzfzpT39KkhRFkQkTJqRDhw4ZOXJkg/7Dhw9P586dc/XVV6coinL7xIkTs3jx4owYMaIc1idJ7969c/LJJ+e5557LPffcs5b2DgAAAAAAAADet94F9qvSpk2bJClf/T5z5sy88sor6d+//wq3vW/Xrl0OPvjgvPzyy5k1a1a5fcqUKUmSww8/fIXtDxo0KEkyderUtVE+AAAAAAAAAJRtMIH9iy++mN/+9rfp0qVLPvrRjyZ5P7BPkp49eza6Tn17fb/67zt06JAuXbqsVv/lLVy4MHV1dQ2+AAAAAAAAAKCpNojAftGiRTnppJOycOHCjBs3Lq1bt06SzJ07N0ka3Np+WR07dmzQr/77pvRf3oUXXpja2try1w477ND0HQIAAAAAAABgk7feB/ZLly7N6aefnvvuuy9f/vKXc9JJJ1W0nuHDh2fu3Lnlrzlz5lS0HgAAAAAAAAA2TFWVLmBViqLIl7/85fz85z/PF7/4xVx55ZUNltdfKb+yK+Lrb1e/7BX1tbW1Teq/vOrq6lRXV6/+TgAAAAAAAABAI9bbK+yXLl2aL33pS/npT3+aE088MZMmTUqrVg3L/aBnzjf2jPuePXtm3rx5efXVV1erPwAAAAAAAACsDetlYL906dIMGTIkEydOzAknnJCf/exn5efWL6tnz57p2rVrpk2blvnz5zdYtmDBgtx3333p2rVrdtlll3L7gAEDkiSTJ09eYXt33XVXgz4AAAAAAAAAsLasd4F9/ZX1EydOzOc+97n8/Oc/bzSsT5JSqZQhQ4Zk3rx5GTt2bINlF154Yd56660MGTIkpVKp3H7aaaelqqoq559/foNb48+YMSPXXnttevTokYEDB66dnQMAAAAAAACA/9969wz7sWPHZtKkSenQoUN69eqV733veyv0Oe6447LXXnslSYYNG5Zbb70148aNy+OPP5599903TzzxRO64447stddeGTZsWIN1e/XqldGjR+e8887LHnvskeOPPz7z58/PDTfckEWLFuWqq65KVdV6d1gAAAAAAAAA2Misd8n07NmzkyTz5s3L+eef32if7t27lwP7mpqaTJkyJWPGjMmNN96YKVOmpEuXLjn77LMzatSo1NTUrLD+iBEj0r1791x22WW54oor0rZt2xxwwAEZO3Zs+vbtu7Z2DQAAAAAAAADK1rvAftKkSZk0aVKT1qmtrc348eMzfvz41V5n8ODBGTx4cBOrAwAAAAAAAICWsd49wx4AAAAAAAAANgUCewAAAAAAAACoAIE9AAAAAAAAAFSAwB4AAAAAAAAAKkBgDwAAAAAAAAAVILAHAAAAAAAAgAoQ2AMAAAAAAABABQjsAQAAAAAAAKACBPYAAAAAAAAAUAECewAAAAAAAACoAIE9AAAAAAAAAFRAVaULAAAAAACAjV33c2+rdAkbvdnfP6rSJQBAk7nCHgAAAAAAAAAqQGAPAAAAAAAAABUgsAcAAAAAAACAChDYAwAAAAAAAEAFCOwBAAAAAAAAoAIE9gAAAAAAAABQAQJ7AAAAAAAAAKgAgT0AAAAAAAAAVIDAHgAAAAAAAAAqQGAPAAAAAAAAABUgsAcAAAAAAACAChDYAwAAAAAAAEAFCOwBAAAAAAAAoAIE9gAAAAAAAABQAQJ7AAAAAAAAAKgAgT0AAAAAAAAAVIDAHgAAAAAAAAAqQGAPAAAAAAAAABUgsAcAAAAAAACAChDYAwAAAAAAAEAFCOwBAAAAAAAAoAIE9gAAAAAAAABQAQJ7AAAAAAAAAKgAgT0AAAAAAAAAVIDAHgAAAAAAAAAqQGAPAAAAAAAAABUgsAcAAAAAAACAChDYAwAAAAAAAEAFCOwBAAAAAAAAoAIE9gAAAAAAAABQAQJ7AAAAAAAAAKgAgT0AAAAAAAAAVIDAHgAAAAAAAAAqQGAPAAAAAAAAABUgsAcAAAAAAACAClgvA/uf//znOeOMM9KnT59UV1enVCpl0qRJK+1fV1eXc845J926dUt1dXW6deuWc845J3V1dStd5/rrr0+/fv1SU1OTzp0758gjj8wjjzyyFvYGAAAAAAAAAFa0Xgb25513Xv7rv/4rL7zwQrbddttV9p0/f34GDBiQSy+9NLvuumvOPvvs7L777rn00kszYMCAzJ8/f4V1LrjgggwePDivvfZahg4dms9//vOZNm1a+vfvnylTpqylvQIAAAAAAACA/7NeBvYTJkzI7Nmz8/e//z1Dhw5dZd9x48Zl+vTpGTZsWCZPnpzvf//7ueOOOzJy5MhMnz4948aNa9B/5syZGTVqVHr16pUnn3wyl1xySX7yk5/kD3/4Q6qqqjJkyJAsXrx4be4eAAAAAAAAAKyfgf0nPvGJdOvW7QP7FUWRCRMmpEOHDhk5cmSDZcOHD0/nzp1z9dVXpyiKcvvEiROzePHijBgxIrW1teX23r175+STT85zzz2Xe+65p+V2BgAAAAAAAAAasV4G9qtr5syZeeWVV9K/f//U1NQ0WNauXbscfPDBefnllzNr1qxye/0t7w8//PAVtjdo0KAkydSpU1c65sKFC1NXV9fgCwAAAAAAAACaaoMP7JOkZ8+ejS6vb6/vV/99hw4d0qVLl9Xqv7wLL7wwtbW15a8ddtih2fUDAAAAAAAAsOnaoAP7uXPnJkmDW9svq2PHjg361X/flP7LGz58eObOnVv+mjNnTrNqBwAAAAAAAGDTVlXpAjY01dXVqa6urnQZAAAAAAAAAGzgNugr7OuvlF/ZFfH1z5df9or62traJvUHAAAAAAAAgLVhgw7sP+iZ8409475nz56ZN29eXn311dXqDwAAAAAAAABrwwYf2Hft2jXTpk3L/PnzGyxbsGBB7rvvvnTt2jW77LJLuX3AgAFJksmTJ6+wvbvuuqtBHwAAAAAAAABYWzbowL5UKmXIkCGZN29exo4d22DZhRdemLfeeitDhgxJqVQqt5922mmpqqrK+eef3+DW+DNmzMi1116bHj16ZODAgetsHwAAAAAAAADYNFVVuoDGTJgwIffff3+S5E9/+lO5bcqUKUmS4447Lscdd1ySZNiwYbn11lszbty4PP7449l3333zxBNP5I477shee+2VYcOGNdh2r169Mnr06Jx33nnZY489cvzxx2f+/Pm54YYbsmjRolx11VWpqlovDwsAAAAAAAAAG5H1Mpm+//77c8011zRomzZtWqZNm5Yk6d69ezmwr6mpyZQpUzJmzJjceOONmTJlSrp06ZKzzz47o0aNSk1NzQrbHzFiRLp3757LLrssV1xxRdq2bZsDDjggY8eOTd++fdf6/gEAAAAAAADAehnYT5o0KZMmTVrt/rW1tRk/fnzGjx+/2usMHjw4gwcPbkZ1AAAAAAAAALDmNuhn2AMAAAAAAADAhkpgDwAAAAAAAAAVILAHAAAAAAAAgAoQ2AMAAAAAAABABQjsAQAAAAAAAKACBPYAAAAAAAAAUAECewAAAAAAAACoAIE9AAAAAAAAAFSAwB4AAAAAAAAAKkBgDwAAAAAAAAAVILAHAAAAAAAAgAoQ2AMAAAAAAABABQjsAQAAAAAAAKACBPYAAAAAAAAAUAECewAAAAAAAACoAIE9AAAAAAAAAFSAwB4AAAAAAAAAKkBgDwAAAAAAAAAVILAHAAAAAAAAgAoQ2AMAAAAAAABABQjsAQAAAAAAAKACBPYAAAAAAAAAUAECewAAAAAAAACoAIE9AAAAAAAAAFSAwB4AAAAAAAAAKkBgDwAAAAAAAAAVILAHAAAAAAAAgAoQ2AMAAAAAAABABQjsAQAAAAAAAKACqipdAAAAAAAAAKwN3c+9rdIlbPRmf/+oSpcAGzRX2AMAAAAAAABABQjsAQAAAAAAAKACBPYAAAAAAAAAUAECewAAAAAAAACoAIE9AAAAAAAAAFSAwB4AAAAAAAAAKkBgDwAAAAAAAAAVILAHAAAAAAAAgAoQ2AMAAAAAAABABQjsAQAAAAAAAKACBPYAAAAAAAAAUAECewAAAAAAAACoAIE9AAAAAAAAAFSAwB4AAAAAAAAAKkBgDwAAAAAAAAAVILAHAAAAAAAAgArYpAP7P/7xjznyyCPTuXPn1NTUpF+/frn++usrXRYAAAAAAAAAm4CqShdQKVOmTMmgQYPStm3bfOELX0htbW1uuummDB48OLNnz863v/3tSpcIAAAAAAAAwEZsk7zCfvHixRkyZEhKpVLuu+++XHXVVbn44ovzxBNPpHfv3hk1alRmzpxZ6TIBAAAAAAAA2IhtklfY33PPPXnuuedy2mmnZe+99y63b7755vnOd76TL3zhC5k4cWIuuOCCClYJAAAAAACsD7qfe1ulS9jozf7+UZUuAaAiNsnAfsqUKUmSww8/fIVl9W1Tp05dlyWxCv4htG74xxAAAAAAAACsW5tkYF9/u/uePXuusKxz587ZcsstV3pL/IULF2bhwoXln+fOnZskqaurWwuVkiRLF75b6RI2CWvrHDZ/a5+527CZvw2Xuduwmb8Nl7nbsPl/E8vz2lv71ubrzvytfd43YePifXPt83tvw+b/exsu/2aBxtW/NoqiWGW/UvFBPTZChx9+eO6+++7MnDkzu+yyywrLe/TokZdeeqlBMF9v9OjRGTNmzLooEwAAAAAAAIAN2Jw5c7L99tuvdPkmeYX9mhg+fHjOOeec8s9Lly7Nm2++mS222CKlUqmClbG+qKuryw477JA5c+akY8eOlS6HJjJ/Gy5zt+Eydxs287fhMncbNvO34TJ3Gzbzt+Eydxs287fhMncbNvO34TJ3Gzbzt+EydyyvKIq888476dq16yr7bZKBfW1tbZL/u5398urq6sp9llddXZ3q6uoGbZ06dWrR+tg4dOzY0RvyBsz8bbjM3YbL3G3YzN+Gy9xt2MzfhsvcbdjM34bL3G3YzN+Gy9xt2MzfhsvcbdjM34bL3LGslWXOy2q1DupY79Q/u76x59S/9dZbeeONNxp9vj0AAAAAAAAAtJRNMrAfMGBAkmTy5MkrLKtvq+8DAAAAAAAAAGvDJhnYf/zjH8/OO++c66+/PtOnTy+3v/POO/nud7+bqqqqnHrqqRWrjw1bdXV1Ro0atcKjE9gwmL8Nl7nbcJm7DZv523CZuw2b+dtwmbsNm/nbcJm7DZv523CZuw2b+dtwmbsNm/nbcJk7mqtUFEVR6SIq4d57782gQYNSXV2dE088MR07dsxNN92U559/Pt/73vcyYsSISpcIAAAAAAAAwEZskw3sk+Thhx/OqFGj8sADD+Sf//xnevfunW984xsZPHhwpUsDAAAAAAAAYCO3SQf2AAAAAAAAAFApm+Qz7AEAAAAAAACg0gT2AC1g0qRJKZVKmTRpUqVLoYnM3YbN/G24zN2GzfxtuMzdhs38bbjM3YbN/G24zN2GzfxtuMzdhs38bbjM3YbL3CGwhyb64x//mCOPPDKdO3dOTU1N+vXrl+uvv36FftOnT8+3v/3tDBo0KFtttVVKpVIOOeSQdV/wOuTYrJnVPX6LFi3Kr3/965x66qn58Ic/nJqammy++ebZb7/98uMf/zhLlixZK2OvjXE3Fqs7d0ly1VVX5eijj85OO+2Umpqa1NbWZs8998zIkSPz5ptvrtXx18bYG4OmzN/ynn/++XTo0CGlUilDhw5dZ2Ov6bgbi6Ycv9GjR6dUKjX61a5du7U6/toYe2PQnPP/+eefz5e//OV069Yt1dXV2WabbXLooYfmV7/61Vodu6XG3Vg05fit7Nxf9mvOnDlrbfzE/C2vqcdv5syZOe2009KzZ8+0b98+2223XQ477LDceuuta23stXHebAwqOXdNHb+lx94YNHX+HnrooRx77LHZcsstU11dnV69emXkyJF577331urY5q6hn//85znjjDPSp0+fVFdXr9Yf0uvq6nLOOeeUf+9069Yt55xzTurq6ppVg/lrvqbOX0v/vaopc9eSr/mNwYb22jN/DVXytdfUsVv6vNnQbShzJ19YUVOOn7/zr5+qKl0AbEimTJmSQYMGpW3btvnCF76Q2tra3HTTTRk8eHBmz56db3/72+W+N998cy688MK0bds2vXr1yhtvvFHBytc+x2bNNOX4Pffcczn++OOz+eabZ+DAgTnmmGMyd+7c/M///E+++tWv5s4778wtt9ySUqnUomO39Lgbi6bMXZL87Gc/y1tvvZWDDjoo2267bRYuXJgHH3ww3/3ud3PNNdfkoYceSpcuXdbK+C099sagqfO3rKIoctppp63zsdd03I1Fc4/fKaecku7duzdoq6pq+j+JmzN+S429MWjO8bv77rtz3HHHJUmOPvro7Lzzznnrrbfy5JNP5re//W0+97nPrZWxW2rcjUVTj9+oUaMa3c6sWbNy3XXX5cMf/nB22GGHtTa++WuoqcfvoYceyqGHHppFixblmGOOyWc/+9m8/vrruemmm3Lsscdm9OjRK53jNRm7pc+bjUEl566p47f02BuDps7fTTfdlBNOOCGtW7fOZz/72XTp0iXTpk3Ld7/73dxzzz353e9+l+rq6hYf29yt6LzzzssLL7yQLbfcMttuu21eeOGFVfafP39+BgwYkOnTp+ewww7LiSeemCeeeCKXXnpp7r333tx///2pqalZ7fHN35pp6vy15N+rmjJ3Lfma31hsSK8987eiSr72mjJ2S583G4MNZe7kCytqyvHzd/71VAGslkWLFhU9evQoqquri8cee6zcXldXV/Tu3buoqqoq/vKXv5Tbn3rqqeLRRx8t/vnPfxZ/+9vfiiTFgAEDKlD52ufYFMXEiROLJMXEiRObvG5Tj99LL71U/PjHPy7mz5/fYDvz5s0r+vTpUyQpfvnLX7b42C057vpkXc5dURTFe++91+i2zjvvvCJJ8a1vfWutjd+SY68v1vX8Levyyy8vqqqqivHjxxdJijPOOGOdjL0m465P1vXcjRo1qkhS3HvvvWtYedPHb8mx1xfrev5efPHFomPHjkXPnj2LF154odFtro2xW2rc9Ukl3zeXdeaZZxZJiksuuWStjW/+GmrO/B1xxBFFkuKWW25p0P7CCy8UHTt2LNq3b18sWLBgrYzdmOacN+uLDXXumjN+S469vliX8/fuu+8WW265ZdGmTZvikUceKbcvXbq0+OpXv1okKS688MK1Mra5W9Hdd99dzJ49uyiKorjwwgs/cFsjR44skhTDhg1rtH3kyJGrPbb5W/fz11J/r2rK3LXka359sqm89sxf4yr12mvq2C153qwvNpW5ky+sqCnHb2P9O/+Gzi3xYTXdc889ee655/Iv//Iv2Xvvvcvtm2++eb7zne9k8eLFmThxYrm9d+/e2WeffdKmTZtKlLtOrS/H5i9/+UuGDRuWffbZJ1tssUXatWuXXr165dxzz828efNW6H/IIYekVCpl8eLF+e53v5uddtqpfNuqH//4x42O8eabb2bo0KHZZpttstlmm6Vv3775zW9+s0Z1N/X4bbfddvnKV76SzTbbrMF2ampqcs455yRJpk6d2uJjt+S4y9tU5i7JSm9/XX+F36xZs9ba+C059rI2pfmrN2vWrAwfPjzDhg1rsO7aHntNx13epjh3LaHS49fblObvggsuSF1dXa688srsuOOOK2xzde9U0NSxW2rc5W1Kc9eYBQsW5Lrrrkvbtm1z0kknrbXxzV9DzZm/v/71rymVSvnkJz/ZoH3HHXfMRz7ykbz33nt555131srYy2vuebMsc9f0uWvO+C059rI2lfmbNm1a3njjjRx33HHZd999y+2lUinf+973kiRXXnlliqJo8bHN3Yo+8YlPpFu3bqvVtyiKTJgwIR06dMjIkSMbLBs+fHg6d+6cq6++erXmLjF/63r+kpb7e1VT5q4lX/PL21TmrpKvPfPXuEq99poydkufN8syd2t/bPnCippy/Nbm3/lpvk3zHpzQDFOmTEmSHH744Sssq2/bVN/E1pdjc9NNN+Xqq6/OoYcemkMOOSRLly7Ngw8+mIsuuihTp07Nfffd1+gv8RNPPDEPPfRQjjjiiLRu3Tq//OUv89WvfjVt2rTJl7/85XK/d999N4ccckj+9Kc/5WMf+1gGDBiQOXPm5IQTTmh031dXSx6/+v1b3T9At9TYTR13eeYuue2225IkH/nIR9b5+M0Ze1mb2vwtXbo0p512Wrp165aRI0fmgQceWCdjt8S4y9vU5i5Jfv/73+fhhx9O69ats9tuu+UTn/hEk29P2NzxW2LsZW0q81cURX75y19miy22yMCBA/Poo49m6tSpWbp0afbaa68MHDgwrVqt3ueQmzJ2S467vE1l7lbmpptuyltvvZXjjz8+W2211VoZ3/ytqDnz17t37zz77LOZPHlyPvWpT5Xb58yZk6eeeiof/ehHs+WWW66VsZfX3PNm+W2Yu6bNXXPGb8mxl7WpzN9rr72WJNlpp51W6N+pU6d07tw5L7zwQv7617+mR48eLTq2uVszM2fOzCuvvJJBgwatcAvldu3a5eCDD84tt9ySWbNmpWfPnh+4PfO3buevJTVl7lryNb+8TWXuKvnaM38brpY+b5Zl7jZc5m7N/87PGqjMhf2w4Tn++OOLJA1ub7SsLbfcsthqq60aXbax3JZlZdaXY/PSSy8VCxcuXKF9zJgxRZLi5z//eYP2AQMGFEmK/fbbr5g7d265/ZlnnimqqqqKXXfdtUH/+lsaf/nLX27QftdddxVJmn3LmjU5fsurvwXebbfdtk7Hbuq4y9sU527ixInFqFGjinPOOac45JBDiiTF3nvvXbz55ptrffyWGHtZm9r8XXLJJUWrVq2KP/zhD0VRFMW9997b5FvTN2fslhh3eZvS3NXXsvzXtttuW0yePHmtjt+SYy9rU5m/5557rkhS9O3btxg6dOgKx3Hvvfcu5syZ0+Jjt+S4y9tU5m5lBg4cWCQp7rzzzrU2vvlbUXPmb8aMGcXWW29dtGnTpjj++OOLc889t/jSl75UdO7cufjoRz9aPP3002tt7OU197xZlrlr+tw1Z/yWHHtZm8r81Y/3uc99boW+b7/9drmW22+/vcXHNner9kG3l/3f//3fIklx5plnNrr8W9/61lr9/7r5W7XVubXzstbk71VNmbuWfM0vb1OZu0q+9szfB1uXr72mjN3S582yzN2AdTq2fGFFTZ27Za3p3/lpPoE9rKbDDjusSFLMnDmz0eU777xz0bZt20aXbeyB/fp+bP7xj38USYpTTz21QXv9L9R77rlnhXXql9XV1ZXbdtppp6Jt27bF3/72txX6f/zjH2/2L8E1OX7L+slPflIkKQYOHLhOx27OuKtrY567+jrrvw4//PDitddeWyfjt8TYq2NjnL9nn322aN++fXH22WeX25oTnDd17JYad3VtjHP3m9/8prjmmmuK2bNnF++9914xc+bM4rvf/W7Rvn37ol27dsX06dPX2vgtOfbq2Njm74EHHiiSFK1bty46dOhQTJw4sXjzzTeL559/vvjyl79c/s9xS4/dkuOuro1t7hrz17/+tSiVSsWOO+5YLFmyZK2Nb/5W1Nz5++tf/1rsu+++Df7t0Llz52L8+PHF4sWL1+rYy9bQ3PNmdZi7lh+/pcZeHRvb/L3zzjtFx44dizZt2jR4dnLx/7V350FR3ocfxz8IiBoOLxDxQkXjUS9karUgakzQ2Bgak1pnbESJxtb0sLGmHj+jsU1MrE5im1jSeMQxycQa6zlixggejCdRoyjWBq2EqHiCgwURv78/MkvABV2WZ1nXfb9mmMk8++zz+e7zeR6jz5dnH2PMr3/96/L9+fHHH1uebQzd3cv9Ln5/9NFHRpKZNWtWla+/9tprDndnDP0ZU7f93a0216tq0p2V57yjHrbu3Hnu0d/9PaiTvlYfN46gO9dkM79gz9kJe1de58f98Qx7AA8NY4yWL1+ugQMHqmnTpvL19ZWPj4+aNWsmSfr222+rfF90dLTdstatW0uSrl+/Lkm6ceOGzpw5o6ioKIWHh9utHxcXZ9GncM6WLVv00ksvqV27dlq9erXH5Xpjd+np6TLG6NKlS9q8ebO++eYbRUdH66uvvvK4bG/p786dO0pKSlJERET5s+g8PddbupOkxMREPf/882rXrp0aNGigqKgozZ49W++8846Ki4td2qmrsr2lvzt37kiSysrKNH/+fCUlJalJkyaKjIzU+++/r379+mn//v3as2ePx+R6S3dVWb58uYwxGj9+vNNfSe8I+rPGoUOHFBsbq6ZNmyozM1NFRUXKyclRcnKyfv/73+u5556rk3FYddzQXd1056psb+kvMDBQixcvVmlpqfr376+xY8dq2rRpGjBggFJSUtSlSxdJkq+vr+XZdOfZ6M8zufKcpzvXoz9Uhe48lzd35675BXyPhxAADgoJCZEkFRQUVPl6YWFh+Tre5kHZN7/5zW/0t7/9TW3atNHIkSPVsmXL8mcDz5s3TyUlJVW+r6qx2Z7RUlZWJun7zxYWFlblNlq0aOH0uGu7/7Zt26ZRo0apRYsW2rFjh1q2bFkn2bXJvZu3didJzZs314gRI9SzZ0916tRJEydO1P79++skvzbZFXlLf0uWLNG+ffu0Y8cONWrUyOncmmZbmXs3b+nuXsaNG6df/epXysjIqPN8Z7Ir8pb+Kv73yJEj7dZ/6qmntH///vKL1FZlW5l7N2/p7m537tzRypUrVa9ePU2YMMGl+fRXfb6j/ZWWlmr06NHy8fHR+vXry/8f1L59ey1cuFC5ubn69NNPlZaWpsGDB1uaXVFtj5uK6K7m3dU03+rsirylP0lKTk5WRESE3nrrLW3YsEFlZWWKiYnRF198oTfffFPZ2dkKDQ21NJvuas+R/V1xPSu2R38Pppqe91ad83fzlu7cee5J9OeprD5uKqI7z+Wt3Vl5nR/OY8IecFCnTp0kSadPn1bfvn0rvXbt2jVdvnxZAwYMcMfQ3O5B2Df5+fl699131bNnT+3du7fSpNaFCxc0b968Wm0/ODi4PKcqFy9edHrbtdl/qamp+ulPf6rmzZsrLS1NHTp0qJPs2uZW5K3d3a1Nmzbq2rWrDh48qJs3bzo0MWtVvjPZNt7U35EjR2SMqfYCV0pKilJSUvT0009r/fr1lmVbmVuRN3V3L/Xr11dQUJBu3rxZ5/nOZNt4U39RUVHy9fVVWVmZGjdubLc927L//e9/lmZbmVuRN3V3t9TUVH3zzTdKSEhQ27ZtXZpPf/Zq2l92drZycnL0zDPPVPl3gyFDhujTTz9VZmbmfSd/avv33docNzZ0972adFfTfKuzbbypP5vhw4dr+PDhdst/8YtfqF69elXeyVWbbLqrvYr7uyq25bb1arI9+vMszpz3VpzzFXlTd+4892zoz/NYfdzY0J3n8tburLzOj9rhK/EBB8XHx0uSPv/8c7vXbMts63ibB2Hf5OTkyBijoUOH2v3jdPfu3bXefnBwsNq3b6///Oc/unDhgt3rtclwdv+lpqYqMTFRTZo0UVpamqKiouok24rciryxu+qcP39ePj4+Dn9VmpX5Nc228ab+4uPjlZycbPfz5JNPSpK6dOmi5ORkPf7445ZmW5lbkTd1dy+nT5/WtWvXFBkZWef5zmTbeFN/AQEB5RfETpw4Yfce2zJH9mNNsq3MrciburvbsmXLJEkvvPCCy/Ppz15N+7t165Yk6dKlS1Vuz7bcdseJldkV1fa4saG779Wku5rmW51t40393UtGRobOnj2rYcOGOXTHH91Zk+GoTp06KSIiQhkZGSoqKqr0WnFxsXbt2qWIiAiH/w1Nf3Xbn5WsOu9res5X5E3dufPcuxf6e7BZfdzY0J3n8sburL7Oj1py5sH3gDcqLS01HTp0MAEBAebw4cPlywsLC0337t2Nn5+fOXXqVJXvPX/+vJFk4uPj62awdexB2DfffvutkWR+9KMfmbKysvLlubm5pkOHDlVmxMfHm+r+GBw3bpyRZM6cOVO+bM6cOUaSmThxYqV1t23bZiQZSWbFihU1Hrsz+2/r1q0mICDAhIeHm+zs7BpnOpttVW5F3tTd5cuXzfHjx+22c+fOHfPqq68aSeaxxx5zSb7V2Tbe1F910tLSjCTz4osv1mm2M7kVeVN3hYWF5ujRo3bbuXr1qomLizOSzIIFC1ySb3W2jTf1Z4wxH3/8cfmfU8XFxeXLT548aRo1amSCgoLM1atXLc+2Krcib+vOJj8/3/j7+5vmzZubkpKSGmc7k09/ldV0/xUXF5uQkBBTr149s23btkrbysvLMxEREUaS+eqrryzPtrHiuLGhu+/UtLua5ludbeNN/RljTEFBgd128vLyTJcuXYyfn5/JzMy0PJvu7u+NN96477ZsY5k+fXqVy+fMmeNwHv3VfX8V1eZ6VU3Pe6vO+Yq8rTt3nXvG0N/91OW5V9NsK48bG7qrm+5ckett3bniOj9qh6/EBxzk5+enDz74QAkJCYqLi9OYMWMUHBysdevW6cyZM/rTn/6kzp07l6+fnZ2tBQsWSPr+qzazs7OVlJQk6btnR//lL3+p88/hCg/CvmnZsqVGjRqlzz77TDExMXrsscd08eJFbd68WUOGDFFOTk6tP+f06dO1bt06/eMf/1BWVpYGDhyo3NxcrVmzRiNGjNCWLVuc2q4z+y8xMVElJSUaNGiQPvnkE7ttRkZGlu9Pq7KtzK3Im7rLzc1Vnz599MMf/lDdunVTeHi4Ll++rN27d+vUqVMKDw/Xu+++65J8q7NtvKk/K7kz28aburty5Yp69eqlmJgY9ejRQ2FhYcrLy9PWrVt15coVPf7445o6dapL8q3OtvGm/iTp5z//udatW6e1a9eqV69eSkhIUEFBgT777DMVFxdr1apVatKkieXZVuVW5G3d2axatUqlpaV6/vnnVb9+/TrJp7/Karr/AgICtGjRIr3wwgsaPny4RowYoa5du+rixYv617/+pcLCQk2ZMkU9evSwPNvGiuPGhu6c666m+VZn23hTf5K0ZMkSrV69WrGxsQoLC1Nubq42bNigmzdvatmyZQ5/tTLd1a47Sfrggw+0Z88eSdKxY8fKl6Wnp0uSEhMTlZiYWGksGzdu1FtvvaXDhw+rb9++Onr0qLZu3arevXtr+vTpDmfTX933Z9X1qpqe91ad8xV5W3fuOvck+quKu869mmZbedzY0F3ddMf8gr2a7j9XXOdHLbn7NwYAT7N//34zbNgwExISYho2bGhiYmLM6tWr7daz3flY3U+7du3qfvAu5u59c+PGDfPyyy+byMhIExAQYDp16mTmz59vbt26ZclvwBljzJUrV8ykSZNMaGioadCggenbt69Zt26dWbFiRa1/A86q/VfVZ7Ui2xW5Nt7S3dWrV82MGTNM//79TVhYmPHz8zOBgYGmT58+Zvbs2eby5csuy3dVtjHe0191anOne22ya3uHvTHe011BQYGZMmWK6du3r2nevLnx8/MzISEhJjY21vz97383t2/fdlm+q7KN8Z7+bEpLS83ixYtN9+7dTUBAgAkODjZPPPGESU9Pd2m2lbk23tadMcZ07drVSDInTpxwOteZfPqzV9P+tm/fbn7yk5+Y0NBQ4+vra4KDg01cXJz58MMPXZ5t5XFjDN3Vprua5ludbYx39ffFF1+YoUOHmrCwMOPv72/Cw8PN6NGjzZdffunybLqrOq+6n1dffdXuPdevXzdTp041bdq0Mf7+/qZNmzZm6tSp5vr1606Ngf7qrj+rr1c52p3V57yNN3VnjPvOPfqrPs8d515Ns60+boyhu7rojvmF6vOs2H9VfVa4no8xxggAAAAAAAAAAAAAANSpeu4eAAAAAAAAAAAAAAAA3ogJewAAAAAAAAAAAAAA3MDP3QMAgOocOXJE69evv+96kZGRSkpKcvl4amLu3LkOrfe73/1OjRs3dulY3IHuPBv9eS6682z057nozrPRn+eiO89Gf56L7jwb/XkuuvNs9Oe56M5z0R08ijMPvgeAurBixQoj6b4/8fHx7h6qHUfGLcmcOXPG3UN1CbrzbPTnuejOs9Gf56I7z0Z/novuPBv9eS6682z057nozrPRn+eiO89Fd/AkPsYYIwAAAAAAAAAAAAAAUKd4hj0AAAAAAAAAAAAAAG7AhD0AAAAAAAAAAAAAAG7AhD0AAAAAAAAAAAAAAG7AhD0AAAAAAAAAAAAAAG7AhD0AAAAAAAAAAAAAAG7AhD0AAAAAALDM2bNn5ePjo6SkJHcPBQAAAACABx4T9gAAAAAAeDDbBHnFH39/f7Vq1Uo/+9nPdOjQIXcPEQAAAAAAVMPHGGPcPQgAAAAAAOCcs2fPqn379urYsaPGjh0rSSoqKlJmZqbS0tLk7++v7du3a+DAgXUyntLSUn399dcKCQlRy5Yt6yQTAAAAAABPxYQ9AAAAAAAezDZhn5CQoNTU1EqvLViwQDNmzNDAgQO1c+dON40QAAAAAABUh6/EBwAAAADgIZWcnCxJyszMrLT81q1bWrx4saKjo/XII48oKChIcXFx2rhxY5XbOXv2rEaPHq2mTZsqMDBQ8fHx2rVrl+bOnSsfHx+lp6dXWre6Z9ifO3dOycnJatWqlerXr6/WrVsrOTlZubm5dusOGjRIPj4+un37tubPn6/27dsrICBAnTt31nvvvWe3fnFxsRYtWqRevXopJCREgYGB6tixo8aMGaNjx47VYK8BAAAAAFB3/Nw9AAAAAAAA4Fp+ft//87+kpETDhg1Tenq6+vTpo+TkZJWWlmrLli16+umn9de//lUvvfRS+fp5eXkaMGCAzp8/ryeffFK9evXSqVOn9MQTT2jw4MEOj+H06dOKjY1Vfn6+nnrqKXXv3l1ZWVlavny5Nm/erIyMDEVFRdm9b8yYMdq/f7+GDx8uX19frVmzRlOmTJG/v78mTpxYvt64ceO0Zs0a9ezZU+PHj1dAQIDOnTuntLQ0JSQkqEePHk7uPQAAAAAAXIcJewAAAAAAHlIpKSmSpNjY2PJlr732mtLT0zV37lzNmTNHPj4+kqQbN25oyJAhevnll/XMM88oIiJCkvTHP/5R58+f18KFCzVt2rTy7axcuVLjx493eCyTJ09Wfn6+UlJSNGnSpPLl77//vl588UVNnjxZ27dvt3tfbm6ujh8/ruDgYEnSb3/7W/3gBz/QokWLyifsCwoK9M9//lMxMTHat2+ffH19y99fVlamGzduODxOAAAAAADqEs+wBwAAAADAg9meYd+xY0eNHTtWklRUVKSDBw9q586dCgsLU3p6urp27ao7d+6oefPmatasmf7973+XT9bbbNq0SSNHjiy/y76kpEQhISFq3Lixzp07p/r165eva4xRt27dlJ2drbS0NA0aNKjSeMaNG6eVK1dK+m7SvW3bturWrZuOHz9eKdcYo+7du+vkyZM6d+6c2rRpI+m7r8TfuXOnduzYYXcnv+21wsJCBQUFqbCwUCEhIfrxj3+sPXv2WL2LAQAAAABwGe6wBwAAAADgIfD1119r3rx5lZaFhYVp9+7d6ty5syTp1KlTunbtmiIiIuzWlaRLly5JkrKzs8vXLykpUUxMTKXJekny8fFR//79y9e9l8OHD0uS4uPj7X5JwMfHRwMHDtTJkyd19OjR8gl7m+joaLvttW7dWpJ0/fp1BQUFKTg4WMOGDVNqaqqio6P17LPPKi4uTv369bMbNwAAAAAADxIm7AEAAAAAeAgkJCQoNTVV0ncT7x9++KFeeeUVJSYm6sCBAwoMDNTVq1clSVlZWcrKyqp2W0VFRZKkwsJCSVJoaGiV67Vo0cKhsdm2U9364eHhkr77avu7hYSE2C3z8/vuckZZWVn5srVr1+r111/XJ598olmzZkmSgoKCNGHCBL3++utq1KiRQ2MFAAAAAKAu1XP3AAAAAAAAgLVCQ0M1bdo0zZw5UydPntTs2bMlqfw58KNGjZIxptqfFStWVFrfduf93S5evOjQeGzbqW5923Lbes545JFH9Oc//1k5OTnKycnRsmXL1KVLF73zzjuaOnWq09sFAAAAAMCVmLAHAAAAAOAhNXPmTEVEROi9997T2bNn1bVrVwUHB+vQoUMqLS297/sfffRRBQQEKDMzU7du3ar0mjFG+/btc2gcvXv3liTt2rVLxhi77ezevbvSerXVvn17TZgwQTt37lRgYKA2btxoyXYBAAAAALAaE/YAAAAAADykGjZsqFdeeUWlpaWaP3++/Pz89Mtf/lL//e9/NW3atCon7Y8fP678/HxJUkBAgJ599llduHBBS5YsqbTeqlWrdPLkSYfG0bZtWw0ePFhZWVlavnx5pdeWL1+urKwsDRkyxO759Y66dOmSDhw4YLf82rVrKikpUcOGDZ3aLgAAAAAArsYz7AEAAAAAeIhNmjRJb775platWqWZM2dq3rx5+vLLL7VkyRJt2bJF8fHxCg0NVV5eno4dO6ajR49q7969CgsLkyS98cYb2r59u/7whz8oLS1NvXv31qlTp7R582YNGzZMqampqlfv/vcDLF26VLGxsZo4caI2bdqkbt266cSJE9q4caNCQ0O1dOlSpz9jXl6e+vXrp+7duys6OlqtWrXSlStXtGHDBpWWlmr69OlObxsAAAAAAFfiDnsAAAAAAB5iDRo00IwZM3T79m3NmzdPAQEB2rp1q1JSUhQeHq61a9fq7bff1q5du9SyZUstXbpUPXr0KH9/mzZttHfvXj333HPKyMjQ22+/rfz8fH3++eeKioqS5Niz5x999FEdOnRISUlJOnDggBYuXKgDBw4oKSlJBw8eVOfOnZ3+jJGRkZo7d66aNWum7du3a/HixdqyZYuio6O1bds2TZ482eltAwAAAADgSj7m7ofHAQAAAAAAOCA2NlZ79+5VQUGBAgMD3T0cAAAAAAA8DnfYAwAAAACAezp//rzdso8++kgZGRkaOnQok/UAAAAAADiJO+wBAAAAAMA9NWvWTH369FG3bt3k6+urI0eOKD09XUFBQcrIyKj0FfoAAAAAAMBxTNgDAAAAAIB7mjVrljZt2qRz586pqKhIoaGhGjx4sP7v//5PXbp0cffwAAAAAADwWEzYAwAAAAAAAAAAAADgBjzDHgAAAAAAAAAAAAAAN2DCHgAAAAAAAAAAAAAAN2DCHgAAAAAAAAAAAAAAN2DCHgAAAAAAAAAAAAAAN2DCHgAAAAAAAAAAAAAAN2DCHgAAAAAAAAAAAAAAN2DCHgAAAAAAAAAAAAAAN2DCHgAAAAAAAAAAAAAAN/h/dRtj27ZqVSUAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -571,14 +657,27 @@ "plt.ylabel('Lesion length')\n", "plt.show()\n", "\n", - "#we output the same thing for M12 \n", - "regions = df_M12.columns\n", + "#we output the same thing for M12 for 3D nnUNet \n", + "regions = df_M12_3d.columns\n", "regions = [str(column) for column in regions if 'avg_lesion_length_between' in column or 'avg_lesion_length_above' in column]\n", "regions = np.sort(regions)\n", "\n", "plt.figure(figsize=(25, 5))\n", "legend = [region.split('_',4)[-1] for region in regions]\n", - "plt.bar(legend, df_M12[regions].sum())\n", + "plt.bar(legend, df_M12_3d[regions].sum())\n", + "plt.title('Distribution of avg lesion length per regions in M12')\n", + "plt.xlabel('Regions')\n", + "plt.ylabel('Lesion length')\n", + "plt.show()\n", + "\n", + "#we output the same thing for M12 for 2D nnUNet \n", + "regions = df_M12_2d.columns\n", + "regions = [str(column) for column in regions if 'avg_lesion_length_between' in column or 'avg_lesion_length_above' in column]\n", + "regions = np.sort(regions)\n", + "\n", + "plt.figure(figsize=(25, 5))\n", + "legend = [region.split('_',4)[-1] for region in regions]\n", + "plt.bar(legend, df_M12_2d[regions].sum())\n", "plt.title('Distribution of avg lesion length per regions in M12')\n", "plt.xlabel('Regions')\n", "plt.ylabel('Lesion length')\n", @@ -589,17 +688,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "# Correlation between features\n", "We look into the correlation between the edss score and the total lesion volume per level. " ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 34, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -623,77 +723,26 @@ "plt.figure(figsize=(10, 8)) # Adjust the figure size as needed\n", "sns.heatmap(corr_df, annot=True, cmap='coolwarm', fmt=\".2f\", square=True, linewidths=0.5)\n", "plt.title(\"Correlation Heatmap\")\n", - "plt.show()\n" + "plt.show()" ] }, { - "cell_type": "code", - "execution_count": 15, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "+-------------------------------------------------+--------------------------+-------------------------+-------------------------+\n", - "| | M0 | M12 3d | M12 2d |\n", - "+-------------------------------------------------+--------------------------+-------------------------+-------------------------+\n", - "| Mean nb of lesions per patient (median | std) | 4.71 (3.0 | 4.33) | 3.49 (3.0 | 2.72) | 3.55 (3.0 | 3.16) |\n", - "| Mean lesion volume (mm3) (median | std) | 360.47 (232.73 | 449.52) | 177.46 (97.84 | 238.77) | 190.84 (88.79 | 263.25) |\n", - "| Mean biggest lesion volume (mm3) (median | std) | 157.41 (99.96 | 275.66) | 94.99 (52.92 | 144.37) | 94.58 (48.21 | 122.09) |\n", - "+-------------------------------------------------+--------------------------+-------------------------+-------------------------+\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/39/xt15x04d55900qfkrrsvtymw0000gn/T/ipykernel_60574/1423961972.py:8: 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", - " df_M12_2d['timepoint'] = 'M12'\n" - ] - } - ], "source": [ - "df_M12_path_2d = '/Users/plbenveniste/tmp_romane/canproco/project/canproco_final/dataframes/dataframe_M12_2d/dataframe.csv'\n", - "df_M12_all_2d = pd.read_csv(df_M12_path_2d)\n", - "\n", - "#removall of HC\n", - "df_M12_2d = df_M12_all_2d[df_M12_all_2d.pathology != 'HC']\n", - "\n", - "#we add the timepoint to the dataframe \n", - "df_M12_2d['timepoint'] = 'M12'\n", - "\n", - "#replace NaN values by 0\n", - "df_M12_2d = df_M12_2d.fillna(0)\n", + "# Abstract plots\n", "\n", - "#we print a table with the average nb of lesion per patient, average lesion volume and average lesion volume per lesion\n", - "table = PrettyTable()\n", - "table.field_names = ['', 'M0', 'M12 3d', 'M12 2d' ]\n", - "table.add_row(['Mean nb of lesions per patient (median | std)', str(round(df_M0.number_of_lesions.mean(),2)) + \" (\" + str(round(df_M0.number_of_lesions.median(),2)) +\" | \"+ str(round(df_M0.number_of_lesions.std(),2)) + \")\",\n", - " str(round(df_M12.number_of_lesions.mean(),2)) + \" (\" + str(round(df_M12.number_of_lesions.median(),2)) +\" | \"+ str(round(df_M12.number_of_lesions.std(),2)) + \")\",\n", - " str(round(df_M12_2d.number_of_lesions.mean(),2)) + \" (\" + str(round(df_M12_2d.number_of_lesions.median(),2)) +\" | \"+ str(round(df_M12_2d.number_of_lesions.std(),2)) + \")\"])\n", - "table.add_row(['Mean lesion volume (mm3) (median | std)', str(round(df_M0.total_lesion_volume.mean(),2)) + \" (\" + str(round(df_M0.total_lesion_volume.median(),2)) +\" | \"+ str(round(df_M0.total_lesion_volume.std(),2)) + \")\",\n", - " str(round(df_M12.total_lesion_volume.mean(),2)) + \" (\" + str(round(df_M12.total_lesion_volume.median(),2)) +\" | \"+ str(round(df_M12.total_lesion_volume.std(),2)) + \")\",\n", - " str(round(df_M12_2d.total_lesion_volume.mean(),2)) + \" (\" + str(round(df_M12_2d.total_lesion_volume.median(),2)) +\" | \"+ str(round(df_M12_2d.total_lesion_volume.std(),2)) + \")\"])\n", - "table.add_row(['Mean biggest lesion volume (mm3) (median | std)', str(round(df_M0.biggest_lesion_vol.mean(),2)) + \" (\" + str(round(df_M0.biggest_lesion_vol.median(),2)) +\" | \"+ str(round(df_M0.biggest_lesion_vol.std(),2)) + \")\",\n", - " str(round(df_M12.biggest_lesion_vol.mean(),2)) + \" (\" + str(round(df_M12.biggest_lesion_vol.median(),2)) +\" | \"+ str(round(df_M12.biggest_lesion_vol.std(),2)) + \")\",\n", - " str(round(df_M12_2d.biggest_lesion_vol.mean(),2)) + \" (\" + str(round(df_M12_2d.biggest_lesion_vol.median(),2)) +\" | \"+ str(round(df_M12_2d.biggest_lesion_vol.std(),2)) + \")\"])\n", - "\n", - "print(table)" + "Here we build the plots used in the abstract" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 35, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABJ0AAAOYCAYAAAB/2oJ6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeXxU9b3/8feZJRO2ENaEgCyCuCHSgoqyarW23CtgvWq1KIta9VbrdS+uoHVt1VpbW3/VsNTW1qUKWLe64IK4FEXcFcpmYlizL5OZOd/fHyGBIZPJZHKSM5m8no8HLXPmzOQDxJNz3vP5fo5ljDECAAAAAAAAHORxuwAAAAAAAACkH0InAAAAAAAAOI7QCQAAAAAAAI4jdAIAAAAAAIDjCJ0AAAAAAADgOEInAAAAAAAAOI7QCQAAAAAAAI4jdAIAAAAAAIDjfG4XkGps21ZhYaF69Oghy7LcLgcAAAAAkOaMMSovL1deXp48no7bGxKJRBQKhdwuA23I6/XK7/cnvD+h034KCwt1wAEHuF0GAAAAAKCT2bp1qwYNGuR2GS1mjFFRUZFKS0tljHG7HLSxQCCgvn37Kisrq9l9CZ3206NHD0l1/7En8hcIAAAAAEBrlJWV6YADDmi4Hu1oSktLVVJSon79+qlbt26sGkpTxhiFQiGVlpaqoKBAkprNTQid9lP/H0dWVhahEwAAAACg3XTEsMYYo+3btysrK0t9+/Z1uxy0sS5duqhHjx765ptvtHPnzmZzk467WBQAAAAAALgqEokoEonQtNGJWJalnj17KhgMNjvDi9AJAAAAAAAkJRwOS5J8PhZSdSb1w8QjkUjc/QidAAAAAABAq3TEpYFIXqL/3oROAAAAAAAAcByhEwAAAAAAABxH6AQAAAAAAFLWnDlzZFmWNm3a5HYpaCFCJwAAAAAA0K42bdoky7KifmVkZOiAAw7Q2WefrXXr1rldomPq/6xz5sxxu5R2x3h5AAAAAADgiuHDh2vWrFmSpIqKCr3zzjt67LHH9I9//EOvvvqqjjvuOJcrRGsQOgEAAAAAAFeMGDFCCxYsiNp2ww036LbbbtP111+v1157zZ3C4AiW1wEAAAAAgJRx6aWXSpLef//9Rs89+OCDOvTQQ5WZmakhQ4Zo4cKFsm075vssW7ZM3/ve99SrVy9lZmZq1KhR+vWvf61IJBK13+LFi2VZlhYvXqxXXnlFEydOVLdu3dSnTx/Nnj1bu3btivn+zz77rI4//nj17NlTXbp00ZgxY/Sb3/wm6v0XL16sYcOGSZKWLFkStZxw5cqVuvnmm2VZlp544omYX+PBBx+UZVm67777GrZZlqWpU6dq69atOvPMM9WnTx9169ZNU6dO1dtvvx3zfWpra3Xvvffqu9/9rrp166YePXpo0qRJWr58ecz9nULoBAAAAAAAUoZlWTG3X3311br55ps1fvx4XXjhhZKkBQsW6MYbb2y073XXXaeZM2fqq6++0mmnnab//d//VWZmpq6++mr9+Mc/jvn+K1as0LRp05Sbm6uLL75Yw4cP19KlSzVjxoxG+95///065ZRTtG7dOp199tn62c9+purqal1++eU644wzZIyRJI0ZM0aXXXaZJOnII4/UzTff3PBr6NChOv/88+X1evWnP/0pZk0PP/ywMjIydO6550ZtLy4u1oQJE7Rp0yb99Kc/1WmnnabVq1fr+OOP18qVK6P2DQaDOvnkk3XllVdKks477zzNmjVLmzdv1owZM/S73/0u5td2hEGU0tJSI8mUlpa6XQoAAAAAoBPoyNeh1dXV5rPPPjPV1dUtet3GjRuNJHPyySc3eu766683kszUqVONMcbMnj3bSDLDhg0zhYWFDfvt2LHDZGdnmx49ephgMNiw/aWXXjKSzA9/+ENTWVnZsN22bXPRRRcZSebJJ59s2L5o0SIjyfh8PvPWW281bA+Hw2bq1KlGklm9enXD9g0bNhifz2f69+9vtmzZ0rA9GAyaKVOmGEnmz3/+c6M/6+zZs2P+XfzXf/2XsSzLbNy4MWr7hx9+aCSZM888M2q7JCPJnHPOOca27YbtK1euNJZlmREjRphIJNKw/brrrjOSzIIFC6L2LysrM+PGjTMZGRmmoKAgZm1NSfTfnU4nAAAAAADgivXr12vBggVasGCBrrrqKk2cOFG33XabMjMzdfvtt0fte+ONN2rAgAENj/v27asZM2aovLxcX375ZcP2+s6dhx56SF27dm3YblmW7rzzTlmWpccee6xRLWeffbYmTJjQ8Njr9Wr27NmSopf6/eUvf1E4HNaVV16pAw44oGF7RkaG7rzzTkl1y+oSdeGFF8oYo/z8/Kjt9d1PF1xwQaPXeL1e3XbbbVFdYVOmTNG0adO0fv36hmV2tm3rD3/4g0aMGKGbbropav8ePXropptuUm1trf7xj38kXG9LMEgcAAAAAAC4YsOGDVq4cKEkye/3KycnR2effbZ+8Ytf6Igjjoja97vf/W6j1w8aNEiSVFJS0rDtnXfeUbdu3fTII4/E/JpdunTRF1980Wh7ou//4YcfSpKmTp3aaP/x48erS5cuWrt2bcyvHcu0adM0aNAgLVq0SAsWLJDH41FNTY3++te/6sADD9QJJ5zQ6DVDhgyJCrzqTZo0Sf/85z+1du1aTZw4UV9++aWKi4uVl5fX8Pe8rx07dkhSzL8PJxA6AQAAAAAAV5x88sl64YUXEtq3Z8+ejbb5fHWxxr7Du3fv3q1wOBwzZKlXWVmZ9PuXlZVJknJycmK+d//+/VVQUNDk196f1+vVeeedp4ULF+qFF17QtGnT9OSTT6qkpERXX311zBlX/fv3j/le9TWVlpZKqvu7kKRPP/1Un376aZM1xPr7cALL6wAAAAAAQNrIyspSnz59ZIxp8tfGjRtb9f6StG3btpjPb9++vWGfRNUPFH/44Ycl1Q0Q9/l8mjNnTpNfI5b6muoDtPo6TjvttLh/H4sWLWpRvYkidAIAAAAAAGnjmGOO0a5du/T111+3yft/5zvfkaRGd4mTpPfee0/V1dUaM2ZMwzav1yspultqf4MGDdIPf/hDPfvss1q1apXeeOMNTZs2TXl5eTH337x5s7Zu3dpo+5tvvilJDV//0EMPVVZWlv79738rFAol8sdzFKETAAAAAABIGz//+c8lSfPmzdOuXbsaPV9UVKTPP/886fc/++yz5fP5dO+996qwsLBheygU0i9+8QtJiupQ6tWrlyzL0jfffBP3fS+88EKFQiGdccYZMsbEHCBeLxKJ6Prrr1fdzezqvP7663ruuec0YsQIHXfccZLqlgdefPHF2rx5s6666qqYwdMnn3zSZOdUazHTCQAAAAAApI0f/OAHuvHGG3XrrbdqxIgR+sEPfqAhQ4Zo165dWr9+vd5880398pe/1KGHHprU+w8fPlx33XWXrrzySo0ePVpnnHGGunXrpmeffVZffPGFZsyYoVmzZjXs3717dx111FF64403NHfuXB100EHyeDw6++yzNXjw4Ib9pk2bpgMOOEBbt27VwIED9cMf/rDJGkaPHq2VK1dq/PjxOuGEE1RYWKi//e1v8vv9+tOf/iSPZ2+P0cKFC/XBBx/ot7/9rf75z39qypQp6tevnwoKCvTxxx/ro48+0urVq5ucE9UahE4AAAAAACCt3HLLLZo8ebJ++9vf6pVXXlFJSYn69OmjYcOGacGCBfrJT37Sqve/4oorNGLECN1777169NFHVVtbq5EjR+qee+7Rz3/+80bDv//85z/r8ssv1zPPPKPS0lIZYzR+/Pio0Mnj8WjWrFm64447NHfu3IZlebH06tVLK1as0FVXXaWHHnpINTU1Gj9+vG6//XZNmDAhat9AIKDnn39ejzzyiJYuXaonn3xSwWBQOTk5Ouyww3TRRRc1ulOgUyyzby8WVFZWpp49e6q0tLTFg78AAAAAAGipjnwdWlNTo40bN2rYsGHKzMx0u5wOb9q0aXrhhRf0n//8R0OHDo25j2VZmjJlSsyZUu0l0X93ZjoBAAAAAAC47NNPP9ULL7ygH/zgB00GTh0Ny+sAAAAAAABc8te//lVffvmlli5dKkm68cYbXa7IOYROAAAAAAAALvl//+//6c0339SQIUP0yCOP6Nhjj3W7JMcQOgEAAAAAALikpbOZOtJobmY6AQAAAAAAwHGETgAAAAAAAHAcoRMAAAAAAAAcR+gEAAAAAAAAxxE6AQAAAAAAwHGETgAAAAAAAHAcoRMAAAAAAAAcR+gEAAAAAAAAx/ncLgCA+4wxCgaDSb02ErFlGyO/zytJCgQCsizLyfIAAAAAAB0QoRMABYNBzZs3z5H3ys/PV2ZmpiPvBQAAAADouAid4IqSsmqFQpGobYGAT1ndCSsAAAAAIF1c+fxSt0to0j0/PNeR99m0aZOGDRsWtc3n86l///6aMGGCrrnmGo0bNy7q+Tlz5mjJkiVavXq1xo8f37A9HA7roYce0qOPPqrPPvtM1dXV6tOnjwYPHqzjjjtO5557rr7zne84Und7IHSCK77YsE27Siqjtg3MydaYwwa6VFHnFggElJ+fH3efK6+8UsXFxerVq5fuueeehu3bd1cpGIwor383eb0eBQKBti4XAAAAAFLO8OHDNWvWLElSZWWl1qxZoyeeeELPPPOMXn75ZU2ePDnu6yORiH74wx/q5ZdfVl5enk4//XT169dPhYWF+uKLL/Tb3/5W3bp1I3QCmsPMn9RiWVazS+Lq/83233dwHt1pAAAAADBixAgtWLAgatudd96p+fPn68Ybb9Trr78e9/V//etf9fLLL+vkk0/WihUr5Pf7o54vKipSYWGh02W3Ke5eB1eQOQEAAAAA0t15550nSVqzZk2z+65evVqSdNFFFzUKnCQpNzdX3/3ud50tsI0ROsEVHg+pEwAAAACgc/D5ml9o1rt3b0nS+vXr27qcdkPoBFewvA4AAAAAkO4eeughSdLEiROb3ffUU0+V1+vVDTfcoEsuuUTPP/+8tm3b1tYltilmOsEVHkInAAAAAEAaWb9+fcNMp8rKSr3//vt6/fXX1b9/f/3qV79q9vVjx47VokWLdPnll+v3v/+9fv/730uSBg0apBNPPFGXXHKJxo4d25Z/BMcROsEVdDoBAAAAANLJhg0btHDhwqht/fv315tvvqmRI0cm9B7nnHOOTj/9dP3rX//SW2+9pTVr1ujtt9/W4sWLtXTpUv3+97/XRRdd1BbltwmW18EVFt95AAAAAIA0cvLJJ8sYI2OMtm/frl/96lfauXOnZs6cqYqKioTfJzMzU6eccoruuusuvfzyy9q9e7duvfVW2batyy67TEVFRW34p3AWl/5whc/rdbsEAAAAAADaRL9+/XTVVVfpuuuu0+eff64bbrgh6ffKzMzUDTfcoMmTJ6u2tlarVq1ysNK2RegEV/i8fOsBAAAAANLbddddp7y8PD344IPatGlTq96rW7duzhTVjrjyhysInQAAAAAA6a5Lly669tprFQqFdOutt8bd929/+5teffVVGWMaPff2229r5cqV8vl8Gj9+fFuV6zgGicMVPh+hEwAAAAAg/f30pz/VXXfdpaVLl+q6667T8OHDY+73zjvv6P7779fAgQM1efJkDR48WLW1tfrss8/0r3/9S7Zt684779TAgQPb+U+QPEInuIJOJwAAAABIf/f88Fy3S3BdZmam5s+fr0svvVQLFy7U0qVLY+535ZVXavjw4XrppZf0/vvva/ny5QqFQsrNzdVpp52miy66SCeccEI7V986lonVt9WJlZWVqWfPniotLVVWVpbb5aStoh1lWvPJ1qhtA3OyNeawjpPYdjaXXHKJdu/erd69e+t3v/ud2+UAAAAAaaMjX4fW1NRo48aNGjZsmDIzM90uB+0k0X932k3gCpbXAQAAAACQ3rjyhyt8Xq/bJQAAAAAAgDZE6ARXZGQQOgEAAAAAkM4IneCKDB+hEwAAAAAA6YzQCa7wej3yeCy3ywAAAAAAAG2E0AmusCxLGX6f22UAAAAAAIA2QugE12T4WWIHAAAAAEC6InSCa/yETgAAAAAApC1CJ7iG5XUAAAAAAKQvQie4huV1AAAAAACkL0InuCaQQacTAAAAAADpitAJriF0AgAAAAAgfRE6wTWETgAAAAAApC+u+uEaQicAAAAASG/b/3CN2yU0qf/FdzvyPps2bdKwYcOitvl8PvXv318TJkzQNddco3HjxkU9P2fOHC1ZsiRqW/fu3TVy5EideeaZuuyyyxQIBJr8Onl5edqyZYu83sazkj/++GONHj1aknTwwQfriy++iHp+y5YtuvPOO/Wvf/1LW7dubaj10EMP1eTJk3XJJZeoW7duyf1l7IerfrgmI4NB4gAAAACA9DB8+HDNmjVLklRZWak1a9boiSee0DPPPKOXX35ZkydPbvSa8847T4MGDZJt2yosLNQzzzyja6+9Vq+++qpeeOGFmF/H5/OpsLBQL774oqZNm9bo+UceeUQ+n0/hcLjRcx999JGmTp2qkpISTZgwQT/84Q+VkZGhjRs36t///reee+45nXbaaRoxYkQr/zb21OrIuwBJCPj59gMAAAAApIcRI0ZowYIFUdvuvPNOzZ8/XzfeeKNef/31Rq85//zzNX78+IbHd911l0aPHq0XX3xRr732mo4//vhGrznuuOP00UcfKT8/v1HoVFtbq7/85S+aNm2ali9f3ui1V1xxhUpKSrR06VKdc845jZ5fvXq1+vbtm+gfuVkpN9OpoKBAv/nNb/T9739fgwcPVkZGhnJzc3Xaaafp3XffjfmasrIyXXHFFRoyZIgCgYCGDBmiK664QmVlZe1cPVrC6/XI76PbCQAAAACQns477zxJ0po1axLav0+fPpo5c2bc13Tp0kVnnnmmVqxYoZ07d0Y9t3z5cu3cuVNz586N+drVq1crOzs7ZuAkSccee6yys7MTqjURKRc6PfDAA7r88sv1n//8RyeddJKuvPJKTZw4UcuWLdNxxx2nxx9/PGr/yspKTZkyRffdd58OPvhgXX755TrssMN03333acqUKaqsrHTpT4JEMNcJAAAAAJDufL7Er32NMc2+Zt68eQ1dTfvKz89X//799d///d8xX9e7d29VVFSoqKgo4XpaI+VCp6OPPlpvvPGG1q9fr0ceeUR33HGHnnzySb322mvyer26+OKLFQwGG/a/++67tXbtWl1zzTV66aWXdOedd+r555/XTTfdpLVr1+ruu50ZDIa2QegEAAAAAEhXDz30kCRp4sSJCe2/Y8cOPfPMM5KkCRMmNLnfMccco8MPP1z5+fkN2woKCvTSSy/pnHPOaTKwOv300xUOhzVx4kTde++9ev/991VTU5Pgn6blUu6K/0c/+lHM7ZMmTdLxxx+vl156SR9//LHGjRsnY4wefvhhde/eXTfddFPU/vPnz9cDDzygRx55RAsWLJBlWe1RPlqI0AkAAAAAkA7Wr1/fMNOpsrJS77//vl5//XX1799fv/rVr2K+5uGHH9YLL7wgY4wKCgr09NNPa/fu3brkkkt01FFHxf16c+fO1VVXXaU1a9Zo7NixWrx4sSKRiObNm9fka26//Xbt3r1bjz76qK688kpJktfr1ZFHHqlTTz1Vl1xyiaPL6zrUFb/f75e0t8Xs66+/VmFhoU4++eRGt/PLzMzU5MmTtWzZMq1fv14HHXRQu9eL5hE6AQAAAADSwYYNG7Rw4cKobf3799ebb76pkSNHxnzNI4880mjb//3f/+m+++5r9uudc845mj9/vvLz8xtCp2OOOUaHHXZYk6/p0qWLlixZottuu03PPfec3nvvPb333nv64IMP9MEHH+ihhx7S66+/rgMPPLDZr5+IlFte15QtW7bo5ZdfVm5uro444ghJdaGTpCYDpfrt9fvFEgwGVVZWFvUL7ScQIHQCAAAAAHR8J598sowxMsZo+/bt+tWvfqWdO3dq5syZqqioiPma1atXyxijYDCo9957T+PGjdNvfvObmGHU/vr3769p06bpscce04svvqj169c3OUB8f4MGDdJPf/pTPfzww1q3bp3Wr1+vyZMn65tvvtHll1/eoj93PB0idAqFQjrnnHMUDAZ19913y+utu+NZaWmpJKlnz54xX5eVlRW1Xyx33HGHevbs2fDrgAMOcLh6xJNJpxMAAAAAIM3069dPV111la677jp9/vnnuuGGG+Lun5GRoaOOOkrPPfecevXqpZ///OcqKCho9uvMmzdPxcXFOu+889SlSxedddZZSdU7fPhwLV68WJL06quvJvUesaR86GTbtubNm6c33nhDF1xwQZO39UvW/PnzVVpa2vBr69atjr4/4mN5HQAAAAAgXV133XXKy8vTgw8+qE2bNjW7f79+/XTzzTerqqqq0VK9WKZNm6bc3FwVFBTotNNOa2i+Scb+Y4uckNKhkzFGF1xwgR599FHNmjVLf/zjH6Oer+9waqqTqX6pXFOdUJIUCASUlZUV9Qvth+V1AAAAAIB01aVLF1177bUKhUK69dZbE3rNhRdeqLy8PC1atEgbN26Mu6/P59Py5cv19NNP67bbbmv2vW+55ZaYzTbGGN1xxx2SEr/TXiJSNnSybVvnnXee8vPzddZZZ2nx4sXyeKLLbW5mU3Mzn+C+gJ/QCQAAAACQvn76058qLy9PS5cu1YYNG5rdPzMzU7/4xS8UDod1yy23NLv/UUcdpZkzZ2rw4MHN7nvvvfdqyJAhOvroo3XxxRfr+uuv10UXXaSDDz5Yv/nNb9SnTx/dc889Cf25EpGSoZNt2zr//PO1aNEinXnmmfrzn//cMMdpXwcddJDy8vK0atUqVVZWRj1XU1OjN954Q3l5eRoxYkR7lY4W8vu9sizL7TIAAAAAAGgTmZmZmj9/vsLhcEJL5qS6oGrgwIH685//rK+++sqxWlasWKFrr722oUPqV7/6lf7yl7+oS5cuuuqqq/Txxx/HvftdS6Vcm0l9h9PixYt1+umn69FHH40ZOEmSZVk6//zzdcstt+iWW27RXXfd1fDcHXfcoeLiYl166aWEGinMsiwFMnyqCYbcLgUAAAAA4LD+F9/tdgltbujQoTLGxN3nkksu0SWXXNLwePHixQ2Du2MJBAL65ptvWvx19hVr30mTJmnSpEkJv0drpVzodMstt2jx4sXq3r27Ro4cqV/+8peN9pk5c6bGjBkjSbrmmmu0fPly3X333frwww81duxYffTRR3r++ec1ZswYXXPNNe38J0BLZfi9hE4AAAAAAKSZlAud6qe5V1RUNDkEa+jQoQ2hU7du3bRy5UotXLhQTz75pFauXKnc3Fxdfvnluvnmm9tk+jqcxR3sAAAAAABIPyl3td9ci1ksPXv21L333qt77723bYpCmyJ0AgAAAAAg/aTkIHF0LhmETgAAAAAApB1CJ7gu4I89KB4AAAAAAHRchE5wHZ1OAAAAAACkH0InuC6DTicAAAAAANIOoRNc5/cROgEAAAAAkG4IneC6DD/L6wAAAAAASDeETnBdRgadTgAAAAAApBtCJ7jO5/XIY1lulwEAAAAAABxE6ATXWZYlP8PEAQAAAABIK4ROSAnMdQIAAAAAIL0QOiEl+Hx8KwIAAAAAkE5oL0FK8PtYXgcAAAAA6ebBR99yu4Qm/e+siY68z6ZNmzRs2LCobX6/Xzk5OZo0aZJ+8YtfaPTo0ZKkBQsWaOHChVH7du3aVcOHD9ePfvQjXX311erWrVvDc0OHDtXmzZslSZ9//rkOOeSQRl8/HA5r0KBB2rZtmyTp22+/VW5ubsPzVVVV+s1vfqMnn3xSX331lcLhsPr27athw4Zp4sSJOv/88zV8+HBH/i72R+iElOCn0wkAAAAA0IENHz5cs2bNkiRVVFTonXfe0WOPPaZ//OMfevXVV3Xcccc17Hvaaadp1KhRkupCouXLl2vhwoV69tln9fbbbysjI6NhX4+n7no5Pz9fd999d6Ov++yzz2rbtm3y+XwKh8NRz5WXl2vixIlat26dRowYoVmzZik7O1tbt27Vp59+qjvvvFPDhw8ndEJ68/m8Codtt8sAAAAAACApI0aM0IIFC6K23XDDDbrtttt0/fXX67XXXmvY/j//8z/68Y9/3PD417/+tY4++mitWbNGjz32mGbPnt3wnN/v1+TJk/XnP/9Zt99+u3y+6CgnPz9fffv21UEHHaTVq1dHPfeb3/xG69at03nnnac//elPsva7c/zGjRsVDAZb+0dvEu0lSAksrwMAAAAApJtLL71UkvT+++/H3a9Hjx6aM2dOk/vOnTtXRUVFeu6556K2FxUV6fnnn9dPfvKTqO6oevUh1CWXXNIocJKkYcOGxVyy5xRCJ6QEBokDAAAAANJNrKAnGaeeeqp69eqlRYsWRW1funSpwuGw5s2bF/N1vXv3liStX7/ekTpaiit9pAQ6nQAAAAAA6ea3v/2tJOmoo46Ku195ebkWL17c5L6ZmZk666yz9M9//lPbt29v2J6fn6+xY8c2DCrf3+mnny5JOu+88/SLX/xCr776qoqLi5P5oySFmU5ICXQ6AQAAAAA6svXr1zfMdKofJL5q1SplZmbq9ttvj9r3ySef1BdffCGpboncsmXLVFRUpHHjxumss86K+f7z5s3Tgw8+qD//+c+68sortWrVKn355Zf6/e9/32RNM2bM0N13361bbrlFd911l+666y5JdUPPf/CDH+iyyy7TQQcd5MCfPjZCJ6QEr4fQCQAAAADQcW3YsEELFy6UVDf8OycnR2effbZ+8Ytf6Igjjoja96mnntJTTz0lSeratatGjBihiy66SFdddVXM2UySGjqaFi1apCuvvFL5+fnKzMzU2WefHbeuq6++WhdddJFeeOEFvf322/r3v/+td999V7///e/1yCOP6O9//7umT5/uwN9AY4ROSAl0OgEAAAAAOrKTTz5ZL7zwQkL7PvbYY1F3r0vU3Llzdfnll+vVV1/V448/rpkzZyo7O7vZ1/Xo0UOnn356w3K70tJSXXfddXrwwQd13nnnqaCgoMmwqzW40kdKoNMJAAAAAID4Zs2apYyMDJ177rmqqKhocoB4c3r27Knf/e53GjJkiHbu3KmPP/7Y4UrrcKWPlODz8q0IAAAAAEA8ffv21SmnnKKCggINHjxY3/ve95J+L8uy1LVrVwera4wrfaQEL6ETAAAAAADN+tWvfqWnn35aTz/9tDzNrBp66KGH9P7778d87h//+Ie++OILZWdna9SoUW1RKjOdkBqY6RTfmjVrtGTJEs2ePVtjx451uxwAAAAAgEuGDRumYcOGJbTv888/r4suukgjRozQhAkTlJeXp4qKCq1du1ZvvvmmPB6PHnzwQQUCgTapldAJKYGZTk0LBoPKz89XcXGx8vPzNWrUqDY7IAAAAAAA0sddd92lCRMm6F//+pfeeOMNffvtt5KkgQMHavbs2br00kvbtLHBMsaYNnv3DqisrEw9e/ZUaWmpsrKy3C6nU/noiwIdechAt8tIOY8//riWLVsmY4wsy9LMmTMb7jjQni655BLt3r1bvXv31u9+97t2//oAAABAuurI16E1NTXauHGjhg0bpszMTLfLQTtJ9N+d9hKkjM7e7WS++Ur2utdlSnc2bCsqKtKKFStUnw0bY7R8+XIVFRW5VSYAAAAAAAnp3Ff5SCkey3K7BNcYY2S2fi5VlMgUrm/YtnjxYu3fjNjUdgAAAAAAUgkzneCqivdfUqR4uyQpHBgqHZTrbkEusSxLyhkqs/tbWf0HS5IKCwu1bt26Rvvatq1169apsLBQAweyHBEAAAAAkJrodIKrTLBaJhySCYfkke12Oa6yDjxSnnE/kNUnT5KUl5en0aNHN7oFpsfj0ejRo5WXl+dGmQAAAAAAJITQCa4yodqG33s77+q6mCzL0pw5c+q6oPbbPnfu3EbbAQAAAABIJYROcJUJ7w2dPGQojeTm5uqUU05pCJgsy9L06dOVk5PjcmUAAAAAAMRH6ATXGGOiOp0InWKbMWOGsrOzJUm9evXS9OnT3S0IAAAAAIAEEDrBPZFw1ENWi8UWCAQ0b9489e3bV3PnzlUgEHC7JAAAAACIwt21O5dE/725ex1cs2+Xk0QCGs/YsWM1duxYt8sAAAAAgCh+v1+SVFVVpS5durhcDdpLZWWlLMtq+PdvCqETXGMioajHdDoBAAAAQMfi9XqVnZ2t7du3S5K6du3KTY/SlDFG4XBYZWVlKisrU3Z2trxeb9zXEDrBNY06nTguAQAAAECHk5ubK0kNwRPSm9fr1YABA9SzZ89m9yV0gmvM/jOdXKoDAAAAAJA8y7I0YMAA9e/fX6FQqPkXoMPy+Xzyer0Jd7MROsE9DBIHAAAAgLTh9XqbXW6FzoXZzXCNCUcn4CyvAwAAAAAgfRA6wTUsrwMAAAAAIH0ROsE9Ye5eBwAAAABAuiJ0gmvodAIAAAAAIH0ROsE1xo5EPabTCQAAAACA9EHoBPfsFzoBAAAAAID0QegE9+wXOvHNCAAAAABA+uA6H64xkf06nVheBwAAAABA2iB0gnuMHfWQzAkAAAAAgPRB6ATX7N/pROgEAAAAAED6IHSCe/brdCJ1AgAAAAAgfRA6wT3GRD0kcwIAAAAAIH0QOsFFpvldAAAAAABAh0ToBNcYOp0AAAAAAEhbhE5wD41OAAAAAACkLUInuGi/1IlWJwAAAAAA0gahE9zD8joAAAAAANIWoRMAAAAAAAAcR+gE91h8+wEAAAAAkK646odrLE/0gjqW1wEAAAAAkD4IneAeOp0S9vjjj2vWrFl6/PHH3S4FAAAAAICEcNUP91j0NiWirKxMy5Ytk23bWrZsmcrKytwuCQAAAACAZhE6wT10OiXk3nvvldlzpz9jjO677z6XKwIAAAAAoHlc9cM1Fp1OkiQTCsqEgjGf+/jjj/XVV19Fbfvyyy/18ccft0dpAAAAAAAkjdAJ7tm/06kTZlCmslTmg3/JfPCyTFV51HO2beuBBx6I+boHHnhAtm23R4kAAAAAACSF0Anu8frcrsB91eVSJCJFwlJNRdRTa9euVUVFRcyXVVRUaO3ate1QIAAAAAAAyeGqH66xCJ2kPnmyBldKsqReuVFPjRkzRt27d48ZPHXv3l1jxoxpnxoBAAAAAEgCnU5wjeX1Rm8w7tThJsvyyBp0sKxBIxvNuPJ4PLr00ktjvu6yyy6Tx8N/vgAAAACA1MVVK9xDp1OzjjjiCI0cOTJq28EHH6zDDz/cpYoAAAAAAEgMoRNcw/K6xFxxxRUNXVCWZenyyy93uSIAAAAAAJpH6ATXEDolJisrSzNmzJDH49GMGTOUlZXldkkAAAAAADSLq364h9ApYWeccYbOOOMMt8sAAAAAACBhdDrBNZbP73YJAAAAAACgjRA6wTWWPyPqcSe8eR0AAAAAAGmL0AmusXwZze8EAAAAAAA6JEInuGb/0IlOJwAAAAAA0gehE1zTaKYTqRMAAAAAAGmD0AnuYZA4AAAAAABpi9AJrrEsK2qYOI1OAAAAAACkD0InuIph4gAAAAAApCdCJ7jKygg0/J5OJwAAAAAA0gehE1xl+fcJnUidAAAAAABIG4ROcNW+oRMAAAAAAEgfhE5wVVSnk4t1AAAAAAAAZxE6wVWeDJbXAQAAAACQjgid4Co6nQAAAAAASE+ETnDVvnevAwAAAAAA6YPQCa6yMjIbfs/yOgAAAAAA0gehE1wVFTq5WAcAAAAAAHAWoRNc5fHvDZ1sUicAAAAAANIGoRNcZXH3OgAAAAAA0hKhE9zl9cnyeCVJtsulAAAAAAAA5xA6wVWWZTXMdaLTCQAAAACA9EHoBNfVL7EjdAIAAAAAIH0QOsF1ln9P6ORyHQAAAAAAwDmETnBd/fI67l4HAAAAAED6IHSC6zx7ltcROgEAAAAAkD4IneA6y5/anU5r1qzRz3/+c61Zs8btUgAAAAAA6DAIneA6K4U7nYLBoPLz87Vz507l5+crGAy6XRIAAAAAAB0CoRNcVz/TKZKCodOyZctUUlIiSSopKdHy5cvdLQgAAAAAgA7C53YBQP3d69qz06mgskQRY+uAbr1kWVbMfYqKirRixQoZU1eYMUbLly/XpEmTlJub237FAgAAAB2MMSapVQK2bbR9d5UyAz5l9wg0bA8EAk2etwNIXYROcJ3lz5DUfqHTrppKfbBziyTJa3k0sFt2o32MMVq8eHFD4LT/9muvvZYfegAAAEATgsGg5s2b59j75efnKzMz07H3A9A+CJ3Q7oqrK/XJti0Nj701VcqtqlCpVdMuX9/v8cpjWbKNlOGJ/Z9AYWGh1q1b12i7bdtat26dCgsLNXDgwLYuFQAAAC2wpbBYJWXVDY99Xo8OO4gOdQBwC6ET2l1NuFZf7fy24bE3Ela3YI2qM0Lt8vWzMjI1dcBIRYxRVkbsT0vy8vI0evRoffLJJ7Jtu2G7x+PRqFGjlJeX1y61AgAAIHHFpVX6pqik4XGG30fo5JJAIKD8/Pxm97vyyitVXFysXr166Z577pEkVVaH5Pd5lOH3Rr0fgI6H0AntzrPfsrSIxytjWTJqv+Vq3fzxf2hZlqU5c+bo6quvbrR97ty5LK0DAABIRZyipQzLshJaDld/Xr3v/iyjA9IHd69Du/NY+33bWZZqPRnuFBNHbm6uTjnllKgfhNOnT1dOTo7LlQEAACCW/T/cBAC4i9AJ7S7WyUDIm5pNdzNmzFB2drYkqVevXpo+fbq7BQEAAKBJdKMDQGohdEK7s2L0PYctvwuVNC8QCGjevHnq27ev5s6dy1pyAACAFEboBACpJTXbS5DWvJ7GWWfYSt1vxbFjx2rs2LFulwEAAIBmEDkBQGqh0wntzhcjdAp5Ujd0AgAAQMfg9XJ5AwCphKMy2l1GjPlNqdzpBAAAgI6B0AkAUgtHZbQ7n8fbqPc5bHndKQYAAABpw+dlgR0ApBJCJ7Q7y7Lk90SHTHQ6AQAAoLXodAKA1MJRGa7Yf4ldhJn2AAAAaKVYN6wBALiHozJc4ffu1+nEtyIAAABaiU4nAEgtHJXhigyvP+qxbZjpBAAAgNbx+bi8AYBUwlEZrujiiw6dInwrAgAAoJX8Pj7IBIBUwpU+XJHpz4h6bBu+FQEAANA6hE4AkFq40ocrMn37L6/jWxEAAACt4/cTOgFAKuFKH67I9O3tdDKG0AkAAACt5/VY8ngst8sAAOzBlT5cETXTyXavDgAAAKQPy7Lk89LtBACpgtAJroia6RSRjPhECgAAAK2XwRI7AEgZhE5wRdd9QicTIXACAACAMwidACB1EDrBFV39gb0PbMlYBE8AAABovYwMn9slAAD2IHSCKzK8Pnk9dd9+dDoBAADAKXQ6AUDqIHSCKyzLUpf6JXYRd2sBAABA+vATOgFAyiB0gmvql9iZiCRZEkvsAAAA0EoBP8vrACBVEDrBNQ3DxPcsrzNkTgAAAGglltcBQOogdIJruvoDMkYy4fotpE4AAABoHT+dTgCQMgid4Jqu/oBkS7L3hE1kTgAAAGglOp0AIHUQOsE13TICe+Y51SN1AgAAQOtkZBA6AUCqIHSCa7r6M6TwvkEToRMAAABah0HiAJA6CJ3gmi7+wD7znCTjXikAAABIE16vR14vlzkAkAo4GsM13TICDXeuk0SjEwAAAByRQbcTAKQEQie4xu/xSpF9vwVJnQAAANB6DBMHgNRA6ATXWJYlb4RvQQAAADiL0AkAUgNX/HBNKByRZe/7LchUJwAAALSe30foBACpgNAJrqmsqpXX4lsQAAAAzvLT6QQAKYErfrimojIor2efOU40OgEAAMABLK8DgNRA6ATXVFQF5bH2nhAwRhwAAABOIHQCgNRA6ATXlFcG5bWImgAAAOAsZjoBQGogdIJrKqqC8ngYJA4AAABn+QidACAlEDrBFZGIrerqkDz7djoZQicAAAC0ntfLZQ4ApAKOxnBFWUWNjEx06ESnEwAAABzg93GZAwCpgKMxXFFWUSNJ8lh7vwUtMicAAAA4wOdleR0ApAJCJ7iitLw+dKrvdDIsrwMAAIAjfHQ6AUBK4GgMV+ztdLIkbmAHAAAAB/mY6QQAKYGjMdqdbRuVV9Y0PLZInQAAAOAgj4fzSwBIBYROaHcVVUHZ9t6ldBbnBAAAAHCQZVkETwCQAgid0O7KymuiHluWJYt5TgAAAHDQvjesAQC4gyMx2l1pxX6hkyxZInQCAACAc+h0AgD3ETqh3ZWUVkU99tDpBAAAAId5CZ0AwHWETmhXkYitssqaxk+QOQEAAMBBdDoBgPsIndCuyipqooaIS3tmOpE6AQAAwEncrQYAXEfohHZVUlYdczunBAAAAAAApBdCJ7SrJkMnZjoBAAAAAJBWCJ3QrgidAAAAAADoHAid0G6CtWFV1dTGfI7QCQAAAACA9ELohHbTVJeTJAaJAwAAAACQZgid0G52l1Y1+RydTgAAAHCSsTm/BAC3ETqh3RQ3EToZYwidAAAA4KiIbbtdAgB0eoROaBeRiK3S8tjL6widAAAA4DSbTicAcB2hE9pFaXlNkz/4jQwznQAAAOAoOp0AwH2ETmgXTS2tkyRjJI/hpAAAAADOMMbQ6QQAKYDQCe0ifuhk1yVPAAAAgAMInAAgNRA6oc0ZY1RcFnueU90OdDkBAADAOeEI55cAkAoIndDmKqpqVRsKx3zOGMlivT0AAAAcFApH3C4BACBCJ7SDeEvrbGNz5zoAAAA4KhQidAKAVEDohDYXP3QyDBEHAACAo0Jhzi8BIBWkZOj06KOP6sILL9S4ceMUCARkWZYWL14cc98FCxbIsqyYvzIzM9u3cMS0O07oFKHTCQAAAA5jeR0ApAaf2wXEcsMNN2jz5s3q27evBgwYoM2bNzf7mtmzZ2vo0KFR23y+lPzjdSo1wZCqqmubfL6u04nQCQDgjDVr1mjJkiWaPXu2xo4d63Y5AFzC8joASA0pmco8/PDDOuiggzRkyBDdeeedmj9/frOvmTNnjqZOndr2xaFF4i2tkyTbtuVhkDgAwAHBYFD5+fkqLi5Wfn6+Ro0apUAg4HZZAFxApxMApIaUXF534oknasiQIW6XAQfsLq2O+3zE2Mx0AgA4YtmyZSopKZEklZSUaPny5e4WBMA1wdrYd04GALSvlOx0Ssabb76p9957T16vV4cccohOPPFEPt1MAc11OoVtW35CJ9cFayPyeS15vSmZQwNAs4qKirRixQqZPUu2jTFavny5Jh49TrmDh8iyOL4BnUlNMOR2CQAApVHodNNNN0U9HjBggJYsWaKTTjop7uuCwaCCwWDD47KysjaprzMKR2yVVdTE3SdiR+RnppOrduyu0votJQpkeHXkIf3k9XBhBqBjMcZo8eLFDYHT3u22Fj/4gK6Z+2N5DznapeoAuCEYpNMJAFJBh7+6HDNmjJYsWaJNmzapurpaX3/9tW699VaVlJRo+vTp+uijj+K+/o477lDPnj0bfh1wwAHtVHn6Ky2vbnQBsD8T4YTAbZXVIRkZBWsjCocJAIFUF95dpHDxdrfLSCmFhYVat26d7P1mBNq20cdbi1S4tfkbkgBILzUsrwOAlNDhQ6eZM2fq3HPP1ZAhQ5SZmakRI0bohhtu0P3336+amhr98pe/jPv6+fPnq7S0tOHX1q1b26ny9FfczDwnSbIJnVw3MKeH8vp114jB2QpkeN0uB0Azqj5eperP33O7jJSSl5en0aNHy7Nfp6bH49Hog4Zp4DEnuFQZADcYY5jpBAAposOHTk2ZPXu2fD6fVq1aFXe/QCCgrKysqF9wRklzd64zhjvXpQC/z6OhA3uqX++ubpcCIAHMJmrMsizNmTNHlmU12j73f38uT1YflyoD4IZgbaTZbnsAQPtI6sz1wAMP1G9/+9u4+/zxj3/UgQcemFRRTsjIyFCPHj1UVRU/+EDbMMaouCx+p1PYjhA6AUBL7ResoE5ubq5OOeWUhuDJsixNnz5dOTk5LlcGoL0xRBwAUkdSodOmTZsabknclNLSUm3e7N4Mha+//lrFxcUaOnSoazV0ZlXVIdWG4rc1h21bHu5cBwAtQ6dTk2bMmKHs7GxJUq9evTR9+nR3CwLgiqrqWrdLAADs0WZnrqWlpQoEAm319pKk8vJyrVu3rtH24uJinXfeeZKks846q01rQGwlZc13mNV1OkXaoRoASCMeOp2aEggENG/ePPXt21dz585t8/MQAKmpqobQCQBShS/RHd94442ox5s2bWq0TZIikYi++eYb/fnPf9bIkSOTKurhhx/WW2+9JUn6+OOPG7atXLlSUt3w8JkzZ2rXrl068sgjNW7cOB1xxBHq37+/CgoK9Pzzz2vXrl066aSTdPnllydVA1qnuaV1khSORORlvT0AtIhleZhVEsfYsWM1duxYt8sA4KKqapbXAUCqSDh0mjp1atSchCVLlmjJkiUx9zXGyLIs3X777UkV9dZbbzV671WrVjUMBR86dKhmzpyp3r1762c/+5neeecdrVixQiUlJerWrZuOOOIIzZo1S+eff768Xu7G5YbS8ppm9wlHwvKxvA4AWsbrk8JcUAFAU+h0AoDUkXDodNNNN8myLBljdMstt2jKlCmaOnVqo/28Xq969+6t448/XoceemhSRS1evFiLFy9udr+srCz97ne/S+proO3YtlF5RfOhkx3hogkAWsry+mQInQCgSXQ6AUDqSDh0WrBgQcPvX3/9dc2dO1fnnntuW9SEDq6iKqhIM3elM0ZShHlOANBiHjp4AaApEdtWTQ2hEwCkioRDp3299tprTteBNJLI0rqQHZGnmWAKANCY5U3qRzcAdApV1bUyYu4dAKSKVp+5VlZWqqSkRJEmulYGDx7c2i+BDqa0vPkh4qFIWB5DpxMAtJTFrEIAaFJFFfOcACCVJB06PfLII7rnnnv05ZdfNrmPZVkKh8PJfgl0UAkNEbcj8tLpBAAt5/W7XQEApKyKyqDbJQAA9pFU6PSHP/xBP/vZz+Tz+TR58mQNGjRIPh/t/kh8iHjIjshP6AQALWb5CJ0AoCmVVYROAJBKkkqKfvOb36hv37566623NHLkSKdrQgdWVV3b7BBxSQqHw8owhE4A0FKETgDQNJbXAUBq8STzos2bN+uMM84gcEIjFQl8umSMZEe4qwgAJIPQCQBiM8bQ6QQAKSap0CkvL6/JweHo3BIJncJ2RB6b7x8ASAahEwDEVl0TUjhCJz0ApJKkQqe5c+fq+eefV2VlpdP1oINLZHhjyI7IwzwnAEiOL8PtCgAgJZUzRBwAUk5SodN1112no48+WieddJLeeOMNlZeXO10XOqhE1tGHImHuXAcASaLTCQBiK69s/mY2AID2ldQg8YyMuk9ZjTE6/vjjm9zPsiyFw+HkKkOHY4xJaHldyI7Iy/I6AEgKoRMAxFZeQacTAKSapEKnSZMmybIsp2tBB1cdDCmSwDr6UIQ71wFAsiyW1wFATGV0OgFAykkqdFq5cqXDZSAdVFQ2v7TOGCkSCdf9BgDQYnQ6AUBjEdtWZQJjHgAA7SupmU5ALNU1CcxzsiPycFcRAEie10e3MQDsp6KyVoYPNQEg5RA6wTHVNaFm9wlFwvKytA4AkmZZluSl2wkA9lVewdI6AEhFSS2vk6RIJKLHH39cL7/8sgoLCxUMNh7cZ1mWXnnllVYViI6jJphY6ORhiDgAtIrlS/rHNwCkpTJCJwBISUmdtVZWVur73/++3nnnHRljZFlWVDtr/WPa/zuX6mDzdyoM2RF56HQCgFax6HQCgCiETgCQmpJaXvfLX/5Sq1ev1sKFC7Vz504ZY7RgwQJ9++23+vvf/65hw4bpf/7nf2J2PyF91SS0vC4ir03oBACtwTBxANjLGEPoBAApKqnQ6R//+IfGjx+vG264Qb17927YnpOTo9NPP10rV67UK6+8ol/96leOFYrUZoxRTW380Mk2RhE6nQCg9bwsrwOAetXBkEJhxjcAQCpKKnTasmWLxo8fv/dNPJ6orqZBgwbpv/7rv7RkyZLWV4gOIVgblm3Hv2NIKBKRZYzEnUUAoFXodAKAvcorWF0BAKkqqdCpW7du8nj2vrRnz5769ttvo/bJzc3Vli1bWlcdOoyaROY5RcIsrQMAB1her9slAEDKYGkdAKSupEKnIUOGRAVKo0aN0quvvtrQ7WSM0SuvvKIBAwY4UyVSXijUfEtz3RBxWp8BoNU8hE4AUI/QCQBSV1Kh0/e+9z299tprCofrultmz56tLVu26Nhjj9XVV1+tiRMnau3atTrttNMcLRapKxxJIHSKhOWh0wkAWs1iphMANCB0AoDUlVTodMEFF+iqq67Sjh07JEnz5s3Tz372M3300Ue65557tHr1av3oRz/SggULnKwVKSwUbj5MCnXQIeJr1qzRz3/+c61Zs8a1Gu6//36dffbZuv/++12rAUAKIXRKaY8//rhmzZqlxx9/3O1SgLQXCkdUVV3rdhkdUiqc4wJIf0mFTgcddJCuvfbaqOVzDzzwgIqKirR69WoVFhbqiSeeUNeuXR0rFKmtuTuG2MbItk2Hm+kUDAaVn5+vnTt3Kj8/P2pgfnvZuXOn3n33XUnSu+++q507d7Z7DQBSi8XyupRVVlamZcuWybZtLVu2TGVlZW6XBKS1crqckpIK57gAOoekQqem9OvXT8ccc4xyc3OdfFt0AM2FTrWRsCTT4Tqdli1bppKSEklSSUmJli9f3u417N8xuHDhwnavAUCKodMpZd17770ye+7SaozRfffd53JFQHor4851SUmFc1wAnUOrQ6e3335bDz74oO644w49+OCDevvtt52oCx1MuJnldeFIRJYx0p4T8Y6gqKhIK1asiLp4WL58uYqKitqthtdff127d++O2rZr1y69vvwJ2cFqmcINMiU72rQG2zb6dkeFbNs02lZcxqeLgBssy9HPjNBCldUhFWwvV+1+N9H4+OOP9dVXX0Vt+/LLL/Xxxx9L2nvsLOHYCTimvJL/nlqqPc5xg7URFWwrV1VNyLH3BNAxJX3W+sYbb+jggw/WpEmTdOmll+r666/XpZdeqkmTJumQQw7Rm2++6WSdSHHN3b2uo81zMsZo8eLFDT+Mm9veFiKRiB5++OGYzz38+DOK/PslmU2fyHy+Wqa2us3qKNheoY0FpVFzu77dUbfti//sVnUw3GZfG0ATPIRObvriP7u0ubBMG7aWNGyzbVsPPPBAzP0feOAB2bbdcDz9fONuBWs5dgJOoNOpZdrrHHfD1mJt/rZMX2zc3fzOANJaUv35q1ev1ve//32FQiFNmzZNkyZNUk5OjrZt26Y33nhDzz//vL7//e/rtdde0/jx452uGSkoHIkfKHW0O9cVFhZq3bp1jbbbtq1169apsLBQAwcObNMaXn31VUWauCtgxDZ69autOungAySfX/K03VKbDH/dxa1l7butbp6M12vJ67FivQxAkr7etEPVzXwyHDA1OrhX/3aqCPvz+70KhiINx0JJWrt2rSoqKmLuX1FRobVr12rgkIMlSV6PJQ/BIdBqxhhVNNHpZEK1sqsrFfFZkg5u38JSWHud4/p9dcfHDB8zCIHOLqkr1euuu06WZWnlypWaNGlS1HPXXHONXn/9dZ188sm67rrr9OqrrzpSKFJbc5+KhOyI/B2o0ykvL0+jR4/WJ598InufsMzj8WjUqFHKy8tr8xpOOOEELV26NGbw5PV49L1zLpJVXS4FMmX5/G1WR06fbuqa6Zfft/cCqV/vruqS6ZPf54266ALQegVFJaps5k5MPTMtLqFcdNjwPqqqDqlHt4yGbWPGjFH37t1jBk/du3fXmDFj5PF41DXTrwy/N+qYCiA51TWhJj/4NOGQ7JoKRbx8OLav9jrHHX5AtnL6dFW3Lm13jgqgY0jqjOf999/XmWee2ShwqjdlyhSdeeaZeu+991pVHDqOeJlT/Z3rOtLyOsuyNGfOHFmW1Wj73LlzG21vC16vV+eff37M5y686CL5fD5ZPXrJyujS5rX06JbR6M/cvWuGAhkEToDTQs3MyJMU3XqIdufzepTVPRB1XPR4PLr00ktj7n/ZZZc1dDb16MaxE3BKeWW8pXUdZ45oe2qvc1yPx1JW94C8XgJ2oLNL6iiQmZnZbNvlwIEDlZmZmVRR6HhMnB/soT2dOh67Y/3wz83N1SmnnNLww9eyLE2fPl05OTntVsOUKVPUu3fvqG19+vTRxIkT260GAO3HGNPs3UDrEDqloiOOOEIjR46M2nbwwQfr8MMPd6kiIL3FHSLesU4721UqnOMC6DySCp2+973vNbts7tVXX9WJJ56YVFHoeOJ1OoXtPaFTB+p0qjdjxgxlZ2dLknr16qXp06e3ew0LFiyIenzzzTe3ew0A2kfENgkNcW2Pbksk54orroi6kLv88stdrghIXxV0OiUtFc5xAXQOSYVO99xzjwoLCzV37lwVFBREPVdQUKA5c+aoqKhIv/71rx0pEh1AnIukUCQsqWMtr6sXCAQ0b9489e3bV3PnzlUgEGj3Gvr27atjjjlGknTMMceob9++7V4DgPYRTqjLSaLTKXVlZWVpxowZ8ng8mjFjhrKystwuCUhbFVVx5t+1w52GO7JUOMcF0DkkNUj83HPPVe/evbV06VL95S9/0ZAhQ9S/f39t375dmzdvViQS0ejRo3XuuedGvc6yLL3yyiuOFI7UEr/TyZZlTIf94T927FiNHTvW1Rouu+wyV78+gPbRQQ+T2M8ZZ5yhM844w+0ygLRmjFFlVZxOJw6ozUqFc1wA6S+p0GnlypUNvw+Hw9qwYYM2bNgQtc9HH33U6HUsB0hfcWc62RF5+MEPAM2yE519x89TAJ1csDbc5J3rAACpI6nQad/bawJ1Yl8AGVM308nXAZfWAUB7S2SeEwBAqojX5SSJmU4AkBq4hyUc4fHEDp0iJiKZjjlEHADaW8KhE51OADq5ynjznCQyJwBIEYROcIS3idApFKm/cx0/+QEAAOCM5kKneKMfAADtJ6HldUuXLpUknXrqqerRo0fD40TsP0wc6cnjiZ1fhu260Mmi0wkAmmU1EeADAKJVB0NulwAASEBCodOcOXNkWZbGjx+vHj16NDyOxxgjy7IInTqJpjqdwnvmf3kSHY4LAJ2Yh2VzAJCQ6ppmQidOPQEgJSQUOuXn58uyLA0YMECStGjRojYtCh1PUzOdQnb98jo6nQCgOQnf5ZVwCkAn12zoROoEACkh4U6nfc2ePbstakEH5m12eR0/+AGgOU0F+ACAvcIRW7WhsNtlAAASwCBxOCLWhZIxUsS2JRlmOgFAArxefiwDQHOa73ICAKSKpM5uV61apSuuuEJFRUUxny8qKtIVV1yhd955p1XFoePw+Rp/K4XtiGTocgKARHk9lizR7QQA8dQkEjpx/gkAKSGp0Onee+/VihUrlJubG/P53NxcPfvss7rvvvtaVRw6Dr/P22gbS+sAoGUsy6LbCQCawdI6AOg4kjqzff/99zVx4sS4+0yePJlOp07EFzN02nPnOkInAEhYrM5RAMBetaGI2yUAABKU1Jnt9u3bNXDgwLj75Obmavv27UkVhY7H39TyOol5TgDQAr6EOp1Yggeg8wrS6QQAHUZSoVN2dra2bNkSd5/Nmzere/fuSRWFjife8jo6nQAgcbGOp42QOQHoxEJ0OgFAh5FU6HTsscfq6aef1tatW2M+v2XLFj3zzDM67rjjWlUcOg6/v+nldcx0AoDExTqeAgD2CtYmEjpx/gkAqSCp0OmKK65QVVWVJkyYoKVLl+rbb7+VJH377bdasmSJJkyYoOrqal155ZWOFovU1eTd6yRZYnkdACQqg9AJAOIKsbwOADoMXzIvmjRpkn7729/q//7v/zR37lxJdXfcMXs6Wjwej+6//35NnjzZuUqR0vZfDhKx7YYPmOh0AoDEJbS8DgA6sYidwLklp58AkBKSCp0k6Wc/+5mmTJmiP/zhD3r//fdVUlKi7OxsHX300brooos0atQoJ+tEivN5PfJ4LNl7TgLql9ZJzHQCgJZgeR0AxBex6aIHgI4i6dBJkkaNGqXf//73TtWCDsyyLGX4faoJhiTtXVon0ekEAC0RyGjVj2YASHt2hHNLAOgokprpBMSy7xySiNn7CRShEwAkjk4nAIjP5twSADqMhD5O3bJliyRp4MCB8nq9DY8TMXjw4OQqQ4eT4d/77RSO1Hc6GUInAGiBAKETAMQVibC8DgA6ioRCp6FDh8qyLH3++ecaOXJkw+PmWJalcJi7S3QW+3Y6hc2+JwOETgCQqAyW1wFAXHYig8QBACkhoTPbc889V5ZlqWfPnlGPgX1FhU57ZjrR5QQALZNBpxMAxJXY2SXnoACQChIKnRYvXhz3MSBFfzpff1cRQicAaBm/zyuPZTGzBACa4LEkFtgBQMfAIHE4pv7T+YhtN3y4ZPEpEwC0iGVZCQwTp9sYQOfFigsA6DiSCp28Xq9uvfXWuPvcdddd8npZItCZ1Hc6hW3uXAcArRFgrhMANInQyRlr1qzRz3/+c61Zs8btUgCksaRCJ2OMDGEC9rO30ynSsI3QCQBabt+7gQIAopE5tV4wGFR+fr527typ/Px8BYNBt0sCkKbabHndjh071KVLl7Z6e6Sg+oukfe9cx/I6AGg5hokDQNM8pE6ttmzZMpWUlEiSSkpKtHz5cncLApC2Ev4odenSpVGP165d22ibJEUiEX3zzTdatGiRRo0a1foK0WEEMjpWp1N1uFYf7Nwqb0Qa3XuAPFbrMthAIJBUu7ddXaGaz9+XldlVGnaErBh1mPLdMps/k9Wrv6yBI2O+jynZpoxtG+XpP1jWgANbXEdTtnxbppLyILcnBtpRBsvrUpYxplUdAcVlNSrYXqF+vboqp0/XpH92AJ2Zx8N/M61RVFSkFStWNKxcMcZo+fLlmjRpknJzc2W2b5Yp2iQrb7isvoMc//rbdlXqy0275fN4dNjwPo6/P4DUkvBZ7Zw5cxpOiizL0rJly7Rs2bJG+9UfvLp06aIFCxY4UyU6BL/PK8uyOsxMp28qS7S9vFhP3HyvI++Xn5+vzMzMFr8uWPAfnf/rPzlSw8MXnqbMYJVjoVPEtvXNtvI9v0/df0sg3dDplLqCwaDmzZvn2Psl+7MD6Mx8Po6RyTLGaPHixY1GpdRvv/baa2W2fikFq2W++apNQqdvispVtLNSfq9HPXsEHH9/AKkl4dBp0aJFkuoOSPPmzdOMGTM0c+bMRvt5vV717t1bxx57rHr16uVYoUh9lmXJ7/PW3b2uflsKL6/L6ZKl//hS4Add71zn3isjQ1bOUMfezuvxqH/vriopD8rLp4pAuyF0AoCm+XzcgDtZhYWFWrduXaPttm1r3bp1KiwsVF7OEJmijY6eU+4rp0837Sqpkc9nqX/vrm3yNQCkjoRDp9mzZzf8/vXXX9epp56q6dOnt0lR6LgCGT5F9p3plLqZk7IyMvX9oaM0JT8/7n5XXnmliouL1atXL91zzz1N7hcIJBdgZfbqp3wHa3B6mcaIwXXh8WJCJ6DdsLwudQUCAceO2fXvB6BlfNwhO2l5eXkaPXq0PvnkE9n7fFDs8Xg0atQo5eXlybIsWYMObrMaBuX20KDcHm32/gBSS1JntZs2bdK///1vQic04vN5omb/pPLyOqmuO6u5ZQ37LittiyUQqVADgNRCp1Pq4pgNuM9Pp1PSLMvSnDlzdPXVVzfaPnfuXGbMAXBcUkfs9957T+Fw2OlakA480SFTKi+vA4BURegEAE3zM9OpVXJzc3XKKadEBeTTp09XTk6Oy5UBSEdJhU6HHnqoNm3a5HApSAe2ZUc9TvVOJwBIRX5fc43IHFsBdF7MdGq9GTNmKDs7W5LUq1cvVrAAaDNJHbEvvfRSLV++XJ999pnT9aCDMxadTgDQWnQ6AUDTAsy9a7VAIKB58+apb9++mjt3LvPlALSZpI7Yw4YN09SpUzV+/HhdeOGFOuqoo5STkxNzDfDkyZNbXSQ6jogi0RvInACgxTweSz6fV+FwpPmdAaCT4WYLzhg7dqzGjh3rdhkA0lxSR+ypU6fKsiwZY3TPPffEHTgXiXDC3JlEWF4HAI7wEzoBQEx0OgFAx5HUEfumm27izgaIKWT2HTBvRKsTACQnw+9VdY3bVQBA6gn4E7mE4VoFAFJBUqHTggULHC4D6SI6dAIAJIu7MwFAbIEMjo8A0FFw6wc4qnaf0ImldQCQPD/DxAEgJq/XI6+HyxgA6Ag4WsNRIUInAHCEn1uCA0BMlmUpM8BcJwDoCJI+o926dasuvPBCDR8+XF26dJHX6230y+fjh0FnE9pncLzFPCcASBrL6wCgaYGA3+0SAAAJSCoV+s9//qNjjjlGxcXFOvzwwxUMBjVkyBBlZmZqw4YNCofDOvLII5Wdne1wuUhlxhiFFJZUd6FkkTkBQNIInQCgaZncwQ4AOoSkOp0WLlyo0tJSvfLKK/roo48kSXPnztXnn3+uTZs26ZRTTlFlZaWeeOIJR4tFaosYW3bUkjpSJwBIFjOdAKBpzS6v4+Z1AJASkgqdXn75ZU2bNk1Tpkxp2Gb2hA15eXl6/PHHJUnXX3+9AyWio6iNhGVZavghz0wnAEiej5lOANCkTJbXAUCHkNQZ7c6dO3XIIYc0PPb5fKqqqmp4HAgEdNJJJ+nZZ59tfYXoMBrmOXnqwiZmOgFA8lheBwBNa36QOK1OAJAKkgqd+vbtq8rKyqjHmzZtitrH5/OppKSkNbWhgwnbe0Kn+p/xZE4AkLS4oRPHVwCdHIPEAaBjSCp0Ouigg7Rhw4aGx0cffbRefPFF/ec//5Ek7dixQ08++aSGDx/uTJXoEOz9ltPR6QQAyWN5HQA0jUHiANAxJHVG+8Mf/lCvvfZaQyfT//3f/6m8vFyjR4/WUUcdpZEjR6qoqEiXXnqpk7UixTUKncicACBp8ZfXcYAF0LkFCJ0AoENIKnS6+OKLtXLlSnm9dSfEU6dO1d/+9jcNGTJEn3zyiXJycvTb3/5WF1xwgaPFIrXVD5NvGCTORREAJM3npdMJAJri9XqYfQcAHUBSHxFkZWXpmGOOidp2+umn6/TTT3ekKHRM+3c68Uk8ACTP6/XI6/EoYttulwIAKSkQ8CkUjsR+0mKQOACkAj5GhWOMWF4HAE5irhMANC0zg2HiAJDqWrUYetOmTfrrX/+qtWvXqrS0VD179tSYMWN09tlna+jQoQ6ViI7C0OkEAI7y+70K1obdLgMAUlIgg+V1AJDqkg6d7rrrLt10000Kh8NRYcOTTz6phQsX6pZbbtG1117rSJHoGHye6B/8dDoBQOv4vU1cUDUK+QGg88nwx7uUYXkdAKSCpPr2Fy1apPnz56tv3766++679c4772jjxo165513dPfdd6tPnz667rrrtHjxYofLRSrzeaK/nRgkDgCtw/I6AGia3x+n04nMCQBSQlKdTvfdd59ycnL04Ycfqn///g3bhwwZoqOPPlrnnHOOjjzySN17772aM2eOU7UixXnrO53qsyYyJwBolYx4F1QA0MlxjASA1JfUR6hff/21zjjjjKjAaV85OTk6/fTT9fXXX7eqOHQsDZ1Oe8ImOp0AoHX8cZeOAEDnFi90smh1AoCUkFTo1K9fP/n98e8WkZGRoX79+iVVFDqmhplOhh/yAOAEf1PL65jpBADxl9cBAFJCUqHTj3/8Yz311FOqqqqK+XxFRYWeeuopnXXWWa0qDh2Lz+Otuw6y6x7T6QQAreP3cUEFAE3x++J0g1p8CAoAqSCp0OnWW2/VEUccoWOOOUZ///vfVVBQoFAopIKCAv3tb3/TscceqyOPPFK33HKL0/Uihfk8Hvmsfb6lyJwAoFWaXjrCARYAfF5utgAAqS6pYRFdu3aVJBljdPbZZzd63hijzz77rGG/epZlKRwOJ/Ml0QFYlqUuvgzVqO7fmE4nAGidJpeOcHgFAHm9cbqZ6HRq1po1a7RkyRLNnj1bY8eOdbscAGkqqdBp0qRJsjiQI4ZMb4aksCTDzBEAaKWMJgeJc3wFAG+8TieuVeIKBoPKz89XcXGx8vPzNWrUKAUCAbfLApCGkgqdVq5c6XAZSBcBT/wB8wCAxDU108kQ6gOAvB6W1yVr2bJlKikpkSSVlJRo+fLlOv30090tCkBa4kgNR/nVMUMn2xhVhmpb/LqqcK0ixk766xrblqmpjP1cTaWM3bL3tmsqZVeUJleLMaoJhrmYBVJIRgYzndJNOGKrNhRxuwwgLXg8ljxNdjTR6dSUoqIirVixouGczxij5cuXq6ioqGEfEwnLBKvdKhFAGiF0gqO8pu5byupgwcW/d2zWq4Vf6JPdhQm/ZkPZDr1S8IXeKtqQdFBjPl0l88HLMlu/jN6+5Yu67Z+9nfB72SU7ZF54ROb5P8ne9EmLa9n4Tak++Hybvtpc3OLXAmgbPq8n9gVVBzvGok4obGvtF9u15tNt2l3KxRzghCaX2LG8LiZjjBYvXtzo3HXf7SYckln7iswHL8nsSvzcGABiIXSCo3ymY97eu7S2Our/E3tNjSSpIlQjO4kLQGOMVFXXlWQqS6Kfq39c2YKupcoSqbZGsiNS6c4W11NRHap7m6pQi18LoG1YlhV7mDiZU4cUDkdUG4rIyKiymmMt4IQm58wSOsVUWFiodevWyd6vm962ba1bt06FhYVSKCgFa+p+1rTkXBQAYkhqphPQFO+e0Kmj3bnuu30Hq7CqREO790n4NYdm5yrD41XfzO5JzRSwLEsaeZRUsl0acGD0c8OOkDK7Sb1yEn+/AQdKh0+QaiplHXJMi+sZfkC2tu2qVL9eXZvfGUC7CWT4FKzd786vdDp1SF0y/Rp+QLZqgmEN6Nfd7XKAtMZNj2LLy8vT6NGj9cknn0QFTx6PR6NGjVJeXl7d392IMVJ1hZQ3wr1iAaQFQic4yop4JEuykh9z5Io+md3UJ7Nbi17TxefXqN55rfq6Vq+cmMGSldlNGnZEy97L45V1+ISka+nWxa8DB2Un/XoAbSNmp1MHC/axV06flv2sAZAkQqeYLMvSnDlzdPXVVzfaPnfu3Iawzuo/xI3yAKQhltfBUcFQWD6PR1wQAYAzAv7Gnw+ZVtzAAAA6B0KnpuTm5uqUU07ZGzBZlqZPn66cnMQ77AEgUUmFTm+88YbWrl3rcClIBzXBsPweH5kTADgkI+ZMJw6yABAXnU5xzZgxQ9nZ2ZKkXr16afr06e4WBCBtJRU6HX/88frTn/7kdC3o4GpDYYXDEfm83g430wkAUlVGRoyV8IROABAfoVNcgUBA8+bNU9++fTV37lwFAgG3SwKQppKa6dS/f39lZGQ4XQs6uLKKoCTJ7/GqxuVaACBdBGKGTiyvAwBpz92AY7Aspog0Z+zYsRo7dqzbZQBIc0kdjU8++WS9/vrrTR7k0TmVV9RFTQGfj0/hAcAhsZbX8fMXAOpE7CZCeDqdACAlJBU63X777dq1a5d++tOfavfu3U7XhA6qvLKu08nn8crDz3kAcETM5XVNXWQBQCdijJFtNxHC0+kEACkhqeV1s2bNUnZ2tvLz8/Xoo49q2LBhysnJabgDQj3LsvTKK684UihSX32nkyT5rVi3+AYAtFTsQeKETgAQaSpwkvbcvI5PQQHAbUmFTitXrmz4fTAY1BdffKEvvvii0X77h1BIX8aYhk4nSfJ7POKSCABaL+Bv/KPa0OkEAIpE4h8L6+Y6cbwEADclFTrZnOxiP5XVtVFr6n2WR7Uu1gMA6cLn88hjWbL3neNEpxMAND3PqR7zHgDAdSx2hiPKK4JRj338kAcAR1iWJf/+S+ziLSkBgE6iuU4n5joBgPtafSSuqKjQBx98oDfffNOJetBBFZdVRT22jORheSUAOCKw3zBxYyIuVQIAqSMUbm55HeeiAOC2pEOnTZs2acaMGerVq5eOOuooHX/88Q3PrVq1SocddljU7Cekt13FldEbjC0Pny4BgCMadzqxvA4AQqFmAnjORQHAdUkdibds2aLx48frueee04wZM3TsscfK7DNr4phjjtHOnTv12GOPOVYoUldtKNxoeZ2ModMJABzi9xE6AcD+wuHmQifORQHAbUmFTjfffLOKi4v1+uuv68knn9RJJ50U9bzP59OkSZO0atUqR4pEattVUiWj/eaLGFtePl0CAEdEhU7GSPsfcwGgE2pueZ08nIsCgNuSOhK/+OKLOvXUU3Xcccc1uc/gwYNVUFCQdGHoOHbvv7ROqut8s5jrBABOyNh3eR13rgMASVKomU4niw9AAcB1SR2Jd+/eraFDhza7XzAYbHYfdHw7SxqHTvUXRcx1AoDW27fTyXDnOgCQ1HzoxPI6AHBfUolATk6O1q9fH3efTz75RIMHD06qKHQcNcGwKipjhIt2fejED3sAaC2fb58f13Q6AYAkBokDQEeQ1JH4pJNO0ooVK/TJJ5/EfP7NN9/UK6+8omnTprWqOKS+3bG6nCSZPRdFXtbSA0Cr+bz7hk50OgGAJNU2Fzp5+PATANyWVCJwww03qEuXLpo4caJuv/32hq6n559/XjfeeKN+8IMfqG/fvrr66qsdLRapp2hneeON+91ViSV2ANA6Xi+dTgCwv2ZDJ85BAcB1vmReNHToUL344ov68Y9/rBtuuEGWZckYo//+7/+WMUaDBw/Wk08+qQEDBjhdL1JIJGJr+67GoZPZ74LIa1liBAkAJG/fTidDpxMASJJCoXDc5y3GPACA65IKnSTpmGOO0ddff60VK1bo3Xff1e7du5WVlaVjjjlGM2bMUEZGhpN1IgVt312hSCTGJ+77dzp5PJLdzCdRAIAmRXU62XQ6AYBEpxMAdARJh06S5PP5dOqpp+rUU091qh50IEXby2I/YfZfXmfJkiUjPp0HgGR4ouaScCwFANs23L0OADoAR+L/yspKffvtt6qsjD1UGumnqaV1kmRifArvYZAjACQtaokInU4A0HzgJBE6AUAKSDp0CgaDuu222zRy5EhlZWVp0KBBysrK0siRI3X77bcrGAw6WSdSzI7dFQrHWlonxbwg8tLeDABJi7puYqYTADS/tE7MdAKAVJDU8rqSkhKdcMIJ+uijj+Tz+XTwwQcrJydH27Zt04YNG3TjjTfqqaee0iuvvKLs7GyHS0Yq+LappXVSzPlNHn7oA0DS9r1wMsZIHFIBdHK1zQwRl8RMJwBIAUkdia+77jqtXbtWc+bM0aZNm/TZZ5/ptdde02effaZNmzZp9uzZ+vDDD3X99dc7XS9SQLyldZJkYoROlmXxaRMAJCnq6GlYXgcAiXQ6kdADgPuSCp2efvppHXfccXrkkUc0YMCAqOcGDBig/Px8jR8/Xv/4xz8cKRKp5dvtZU0vrZOavFOdh0+bACAp9r4r6lheBwAKJRI6kTkBgOuSSgHKyso0ZcqUuPtMnTpVZWVxlmChw9rybXHc52MNEpckL51OAJAUOzp1cq0OAEgVCS2vE3OdAMBtSYVOhx9+uLZu3Rp3n61bt+rwww9PqiikrvLKGhWXVsXfiU4nAHCUvW+YT+YEAKqtTWR5nUS7EwC4K6kUYP78+XriiSe0cuXKmM+/+uqreuKJJ5jplIa2FpbE38HEnukk1d19iU+bAKDl7H2W1BlSp7jWrFmjn//851qzZo3bpQBoQ4nNdFLKZk4cqwB0Fkndva68vFwnnniivve97+n73/++Jk6cqP79+2v79u1688039a9//Uv/9V//pdLSUi1dujTqteeee64jhaP9RSK2CraVxt+picCpntfyKGwS/WQKACBJkcg+QRMznZoUDAaVn5+v4uJi5efna9SoUQoEAm6XBaANhMIdt9OJYxWAziSp0GnOnDmyLEvGGL344ot68cUXG+3z7LPP6p///GfDY2OMLMsidOrAtu0sb3b9vInEf95DpxMAtFg44Yurzm3ZsmUqKSmRJJWUlGj58uU6/fTT3S0KQJtIvNMp9c49OVYB6EySCp0WLVrkdB3oAJobIC5JxiZ0agl7xzcy33wpZfaQZ+hhsrp0d7skRWxb23ZVqWumX9k9+NQNSAVRF1d0OjVi7IiKPv1AK5Yvl9nz92OM0fLlyzVp0iTl5ua6XCEAp4USHCSeaoqKirRixYpGx6pjJ0xQsLtfvTK6qndmN5erbDvxzjONMSrYXq5+vboqw+91qUIATksqdJo9e7bTdSDFVVQFtau4svkdI/E/dbIsq6FLrrMzlaUy/35R+naDlBGQqSqWNfZkt8tSwbYKfbOtXJZlaexhOfzQB1JA4stIOidTsF6LH32s0c8WY4wWL16sa6+9lpmCQJpJuNMphZbX1R+TYh2r/vDI/9Mx55wqr8er7w86VH5Pep5/xTvPDIVtbS4sU1lFrQ49sI+LVQJwUlKhEzqfTd/sTmg/00zoJNV1O0UInSSvX5Y/Q8bjkbw+KaOr2xVJUsMPf5/XkseTOidqQGcWSvjiqnMqLC7Tx1uLGm23bVvr1q1TYWGhBg4c6EJlANqCMUbh8N67etaEQ6qqDcbct1u4tr3KalZhYaHWrVvXaLtt29r4+Vc6dMcu5QwYkNYrA/y+uvtYxTrPrH+U4UvPwA3orAid0KxQOKKCopLEdm5meZ0keWSJyyfJyuwqTTxNpnibLH+GrF45bpckScrt203duvgVyPDK503qBpcAHBas7ZjLSNrLwCPG6YjDDtWnX3wp2957IerxeDRq1Cjl5eW5WB0Ap4VCkag7eUZsW5VNhE7+cKi9ympWXl6eRo8erU8++STmseqHRxyt7v5Mea30Pf8a0K+7unfNiHme6fN5NGpEX/XoluFSdQDaQvoe0eCYrYXFCkfs5ndU84PEJcmTxj9IW8rK7CrvgGHy9B0oy5s6GXCPbhksqwNSSHUwdS6aUpFlWZp7/gWNltBZlqW5c+eytA5IM/svreso/41bltVwQ6b9t8+dO1d9MrsrkELng22lqfNMy7KU1T3QYf49ASSGq3/EZdtGmwqaHyAuSTKJL68DACSupobQqTm5ubk65ZRTGi5WLMvS9OnTlZOTGl2kAJxTu9+cu450ZsmxCkBnQ+iEuLbtKld1TWJr4eu6nBKY1WQRPAFAomzbqCa4Txcpx88mzZgxQ9nZ2ZKkXr16afr06e4WBKBN7D/nLt55ZSoeMTlWAehMCJ0QV6IDxCVJCSytq0fbLAAkpqY2FDW7hNCpaYFAQPPmzVPfvn01d+5cBQKB5l8EoMOpDUWfc3rj3ukt9W5ew7EKQGeS/ouGkbTS8hrtLqlMeH8TSXz5B8PEASAxVdXR3aZWSn5unzrGjh2rsWPHul0GgDa0/0wnn8dT19IUI1+yUi9zksSxCkDnkVSnU0FBgd544w1VVVU1bLNtW3fddZcmTJigk046SS+88IJjRcIdm77Z1aL9ExkiXo9h4gCQmIrK/ZY40+kEoJPbP3SSJK8n1rmlUSp2OgFAZ5JUp9ONN96oZ555Rtu2bWvYdtttt+nmm29uePz666/r7bff1rhx41pfJdpdTTCswu2lLXtRi5bXtbAgAOikKqr2uw04x08AnVww2Pic0+fxKpLg3ZYBAO0nqXaT1atX68QTT5Tf75dU1+X0wAMP6JBDDtGWLVv03nvvqWvXrvr1r3/taLFoP1sKd8u2W/bJkAkz0wkAnNYodCJ1AtDJ7T/TSZIy4s51AgC4JanQ6dtvv9XQoUMbHn/wwQfauXOnLr30Ug0aNEjjxo3TzJkz9e677zpVJ9pRJGJrc0Fxy15kjIydeOgkcQc7AEhEReX+nU4sTwbQuQVrY4ROPn+jbZZhaR0AuC2pM9dIJCLb3tu++uabb8qyLJ1wwgkN2wYOHKiioqLWV4h2V7i9NOYnSPGYcOJDxOvR7QQA8QVrw40urjh2AujsYoVO/hidToROAOC+pEKnwYMH67333mt4/Mwzz2jAgAE6+OCDG7YVFRUpOzu71QWifRljtHHr7pa/rgV3rqvHHZgAIL6y8prGGwmdAHRixhjV1jYeJO73ehuF8hZDxAHAdUmFTqeddppWrVql008/Xeecc47eeust/ehHP4ra55NPPtGBBx7oSJFoP7uKK1VeGeMipzktmOdUj8smAIivrCLG8TjmHZoAoHMI1oZlmgiTMnzR90iyyJwAwHVJ3b3uqquu0ksvvaSnnnpKknTEEUdowYIFDc9//vnnev/99zV//nxHikT72fhNy7ucJJbXAUBbKI0VOhHZA+jEqmqaPucMeP0KhvY+T6cTALgvqdApKytL77zzjj755BNJ0qGHHiqvd+866i5duujpp5/WuHHjnKkS7aKqulY7dlUk9VqW1wGA88rKqxtv9FgSdwUH0ElVV9c2+VygUacToRMAuC2p0KneqFGjYm4fOnRo1N3t0DFsKSxusl05LmNkIi1fXkfmBABNqw2FVRnj4sri7nUAOrHmOp1kSfWns4ROAOA+zlwhSYrYtrZ+W5LUa5NZWifR6QQA8ZTGGiIuMUgcQKdWFafTybKkDO/ez9QtQ1soALgt6dDp5Zdf1rRp09SvXz/5/X55vd5Gv3y+VjVSoR0VbS9TbSiJbiUlt7RO4roJAOIpKYuxtE6S6HQC0InF63SSpMC+oRMznQDAdUmlQk899ZTOPPNM2batIUOG6JBDDiFg6uA2FxYn/+Ik7lwHAIiv6dCJxB5A5xVvppMkBXx+lQfrOkVZXgcA7ksqKbrlllvUpUsXLVu2TCeccILTNaGdlVXUqLi0KunXJ7u8Topadg8A2MMY02ToxEwnAJ1VbSis6mAznU6+vXOdPIROAOC6pM5cv/zyS/34xz8mcEoTW1rT5aTWhU5MEweAxqprQk0veabTCUAnVVYRbHYfj2XJ76m7qzadTgDgvqRCp759+6pr165O1wIXhCO2CopKk38DY2RsltcBgJOKm1paJxE6Aei0ysrjHBv3EfD5JUkeBokDgOuSCp3OOOMMvfzyywozy6fD276zXOFIJOnXt67LSTQ6AUAMJfGWPFuWOHgC6IxKK5q4q+d+6kInI9HpBACuSyp0+uUvf6levXrpzDPP1JYtW5yuCe2ocHsrupzkQOgEAGikySHi9TzMdQLQ+ZQlGjp5fSytA4AUkdQg8VGjRikUCmn16tV65plnlJ2drZ49ezbaz7IsbdiwodVFom2EQhHt2F3RujeJ0O0GAE6KROzmL6xYYgegkwlHbFVWxr9zXT2vxyMfh0kASAlJhU62bcvn82nw4MEN20yMTxNibUPqKNpZJttu3b8RnU4A4KzSihrZzf385A52ADqZktIqmRbc8ziD4yQApISkQqdNmzY5XAbcULitrNXvYSKtC50IJgEgWmlzS+tU10kMAJ3JjuLKFu2fIUuMEQcA9/ERQCdVEwxrVwt/eDdijAzL6wDAUc3Oc5LEIHEAnc3OFo6EYHkdAKSGpDqd9hUOh/XVV1+ptLRUWVlZOvjgg+Xztfpt0caKdpS2qEU5llYHTjQ5AUAjCYVOXEwB6ESCteGEh4jX89JNDwApIelOp+LiYv30pz9Vdna2jjjiCE2cOFGjR49Wdna2fvrTn2rXrl1JF/Xoo4/qwgsv1Lhx4xQIBGRZlhYvXtzk/mVlZbriiis0ZMgQBQIBDRkyRFdccYXKylq/fCxdfbujvNXv0drQiVMBAIhWGwqrqiaBQbksrwPQiexMojvfY4wsEnoAcF1SLUnFxcU69thj9dVXX6lPnz6aNGmScnNztW3bNv373//Www8/rNdff12rV69W7969W/z+N9xwgzZv3qy+fftqwIAB2rx5c5P7VlZWasqUKVq7dq1OOukknXXWWfroo49033336bXXXtNbb72lbt26JfPHTFvhiK2S0ioH3qi1Q8SJnQBgX6XlCX6Sz4BcAJ1IS5fWSXUfjnoI6AHAdUmdtd5666366quvNH/+fG3evFnPP/+8Fi1apOeee06bN2/W9ddfr6+//lq//OUvkyrq4Ycf1qZNm7Rjxw5ddNFFcfe9++67tXbtWl1zzTV66aWXdOedd+r555/XTTfdpLVr1+ruu+9OqoZ0truksvk7IyXARCKtez2ZEwBEKUs0dCK0B9BJGGO0I4nQSXaEmy4AQApIKnR65plndPzxx+u2225T165do57r0qWLbr31Vp1wwgl65plnkirqxBNP1JAhQ5rdzxijhx9+WN27d9dNN90U9dz8+fPVq1cvPfLII9whbT/JtCjH1Orldfy7AMC+ShOdWcLhE0Ansau4UsHaFp5z2raMsVleBwApIKnQqbCwUOPHj4+7zzHHHKPCwsKkikrU119/rcLCQk2YMKHRErrMzExNnjxZBQUFWr9+fZvW0dG0+q51exi7laETYSAARCktT+TOdRKpE4DOomB7aYtfY+y6bnwanQDAfUnNdOrZs2fcOUuStHnzZvXs2TOpohL19ddfS5IOOuigmM/Xb//666+b3KezSebuHzEZBok7yUTCMus/qOseGzBcZu0rUnWF1G+wrAEHyoSC8V+/s0B2wVeyaoNS1x6yRnxHVmBvF6IxRsFg4/cwxmhzYZmqasIaNqinZKQN3xSrrCKk7KyARhyQrZraiLZ8W6ZwONLwmpqaGm35tkzllbUaNihbXTNbdiipv0EAgL3C4YiqqhMYIo6UZoxROGI3/D6W8spabSooVVb3gIbkZbVneUCHEonYKkrm5jd7zlE9lqVIJz3hbOrcr9F+kbDMhrWSMbKGj5Hl88fcj3M3AMlKKnSaOnWqnnjiCc2ZM0cnnnhio+dfeeUVPfHEE5o5c2Zr64urtLTuk4+mwq2srKyo/WIJBoNRB+R0v+PdrhKHupxaGThJdDpFKdsp7fpWkmRKd0nbt0rlu6VIWKZsp2THv4AxBV9Ju4tkdhXKyhsh7fhGGjSy4flgMKh58+Y5UmpxcXGr3ys/P1+ZmZmO1AOki/LK5i8OkPqCtRFF9lzlRuzYx+yinZUqr6pVeVWt8vp3k9/nbc8SgQ5j++6Khg+9WqL+PLUzL69z8txP4twNQPKSCp1uvvlm/fOf/9TJJ5+sadOmacqUKcrJydG2bdu0cuVKPf/88+ratWujOUup6I477tDChQvdLqPdOLW0Tq1cWidJNr1Oe3XvLXXPluyIlHugVFIk+TKk7P6yBgyXrJVxX271HyITrK77dCqzm9R7QLuUDcA5LQqdCO1TViDDK4+n7kK3qTtn9evVRaUVQWV1D8jn5U6EQFMKt7V8aZ20z4ejVucOngAgFSQVOh122GF66aWXNGfOHP3zn//UP//5T1mW1dCFMXz4cC1evFiHH364o8Xur77DqalOpvqupXjL/ObPn68rrrgi6jUHHHCAg1Wmlt2lVY68T2vvXCfR6bQvy58ha/SUvRt+eEH08xmZkqqabGu2Bhwo74ADE/paR069SB5v7NbpeL547+8K11bKl9FNhxx9Zotfb0dC+mjlH1v8OqCzaFHotKf7EanHsiz5fXVBUn34tL/srEyNOzy3PcsCOpxQKKLtu5K4a50UfbObTpo5BQIB5efnx93nyiuvVHFxsXr16qV77rmn2fcDgGQkFTpJ0nHHHacvv/xSq1at0ocffqiysjJlZWXpO9/5jiZMmNAua373ndkUS3Mzn6S6A2hnOYhGbFuVVQ7NC7FbFzoROLnH4/XL28R6/XgOP25WG1QDoF55ZeLz9jiGAkh33xSVyE4yYN93DISnk6ZOlmU1uxyu/notkX0BIFlJh05S3QFq4sSJmjhxolP1tMhBBx2kvLw8rVq1SpWVlVF3sKupqdEbb7yhvLw8jRgxwpX6Uk1FZa1jFyqmlaGTzQUTAERp0YcChk4nAOnLGKPNBbuTfLEzHfkAAGd06EEClmXp/PPPV0VFhW655Zao5+644w4VFxfr/PPP504Le1S04FP0ZhE6AYBjwhFbNcFQ4i9geR2ANLazuFKVSd7Ns67Lae95JtcBAOCuhDqdbrnlFlmWpZ/97Gfq3bt3o4CnKZZl6cYbb2xxUQ8//LDeeustSdLHH3/csG3lypWSpJkzZzbcGe+aa67R8uXLdffdd+vDDz/U2LFj9dFHH+n555/XmDFjdM0117T466erMgfvjGRaecHD0hAA2KuyqiVDxBv+BwDSUtJdTpIUiQ7wGSQOAO5KKHRasGCBLMvSmWeeqd69e2vBggUJvXmyodNbb72lJUuWRG1btWqVVq1aJUkaOnRoQ+jUrVs3rVy5UgsXLtSTTz6plStXKjc3V5dffrluvvnmqCV3nV15RQp1OnHBBAANWra0jmUjANJXVU2ttu9McoC4ouc5SRKNTgDgroRCp9dee02SNHjw4KjHbWXx4sVavHhxwvv37NlT9957r+699962KyoNtOjOSM1ozVp5Y+h0AoB9tWQZSWs7TQEglW0pKJZpxYeTJrx/pxMAwE0JhU5TpkyJ+xiprzYUbtm8kHiMUWuWdtgMwAWAKFU1Leh0InQCkKbCEVtbvy1p1XuYyP7nu8ROAOCmDj1IHImrqnYocJL2hE7JY4g4AESrrmnBMZrgHkCaKigqUW0o3PyO8YT3W15H6AQArkoqdPr000+1dOlSlZWVNWyrrq7WxRdfrIEDB+qggw7Sn/70J8eKROsFa1v5A3wfppUXPIROABCtugUfDLC8DkA6MsZo49ZdrXuTSKTxeSqZEwC4KqnQ6bbbbtMvfvEL9ejRo2Hbddddp4ceekjl5eXasmWLLrroIr3yyiuOFYrWcWxpneRApxMXTABQz7aNqltyjG7ljRwAIBVt21neovl2sZhw614PAHBeUqHTe++9p+OPP17WnttBhEIh5efn6+ijj9b27du1ceNG9evXT/fdd5+jxSJ5NUHnOp1aM0/EtulyAoB9BWvDLbq5giF0ApCGWt3lpMZ3rpNodAIAtyUVOm3btq3hTnaS9O6776q8vFwXXXSRMjMzlZeXpxkzZuijjz5yrFC0Tk1tanQ60eUEANFa3InairuHAkAqKimr1u7Sqla/jwnR6QQAqSap0Mnr9SoYDDY8fvPNN2VZlo4//viGbX369NHOnTtbXyEcEXSw06kln8jvj3lOABCtpaETnU4A0o0TXU5S7E4nWp0AwF1JhU5Dhw7Va6+91vD4ySef1LBhwzRkyJCGbQUFBerTp0/rK4QjHF1epySDIyNF6HQCgCgtPj4TOgFIIzXBkIp2lDW/Y3OMZMKxQnxSJwBwU1Kh0znnnKOPPvpI48eP1+TJk7V27VqdddZZUft88MEHOuiggxwpEq3n5N3rkkXgBACNtajTyRg6nQCklc0FxY50wptISLE+GCVyAgB3JRU6XXLJJTr99NP1/vvv66233tLJJ5+s6667ruH5999/X59++qlOOOEExwpF8owxCoXcv0hhaR0ANNaSTifDPCcAaSQSsbWlsNiR94rd5QQAcJsvmRcFAgH9/e9/V1lZmSzLUo8ePaKeHzZsmD788EMNHTrUiRrRSuGILZPskjgH0ekEAI0FQy3oRLXd71oFAKcUbi9VbUuOgfEQOgFASkoqdKqXlZUVc3vfvn3Vt2/f1rw1HBQOux/22Ma0agA5AKSrltzoIeaQXADogIwx2vTNbufej9AJAFJSq0KnDz/8UI899pi++OILVVVV6eWXX5Ykbd68We+++65OPPFE9e7d25FCkbxwCizHsG33gy8ASEUtmrmXAsdzAHDC7tIqlVXUOPZ+hE4AkJqSDp2uueYa3XPPPQ3dK5a1d0yfMUZnn3227rnnHl122WWtrxKtkgqdTiytA4DGIhFboXDiQRKdTgDSxTdFJc69mTEyTSw/ps8eANyV1CDxRYsW6de//rX++7//W+vWrdP8+fOjnh86dKiOPvpoLV++3JEi0Tohh0OnfQPGRBhjGCIOADG0aJ6TCJ0ApIdIxFbR9jLH3i9+lxPnoADgpqQ6nR588EEdeuiheuqpp+Tz+ZSRkdFon0MOOaRhuR3cFXF6OYbVsqwywtI6AIipJfOcJEmETgDSQNHOcoUjzp0fxg2dyJwAwFVJdTp99tlnOumkk+TzNZ1Z5eTkaPv27UkXBuc43emkFnY6sbQOAGKrDbXgQwE7IsPxFEAaKHByaZ3EnesAIIUlFTr5fD7V1tbG3aewsFDdu3dPqig4y/Eh3i3odDJGLK0DgCa0ZIi4CdPlBKDjqwmGtHN3paPvGW/pMWehAOCupEKnI444Qq+99lqTYUb9nezGjh3bquLgjEjE2R+3lifxTqeIzZ2WAKApLQqdWFoHIA0UbiuVcTgK4vgIAKkrqdBp3rx5+vLLL3XxxRc36ngqKyvTnDlzVFRUpAsuuMCRItE6js9UakGnE0vrAKBpLQmdmOcEIB1s313h/JvGOz7ScQ8ArkpqkPi8efP0yiuv6E9/+pMee+wxZWdnS5KOPvpoff7556qsrNScOXP0P//zP07WiiRFHBzUKCnhmU7ctQ4A4mtZpxMzSwB0bJGIreLSamff1I7E7ZziTBQA3JVUp5Mk/eUvf9FDDz2kYcOGqaCgQMYY/fvf/9bgwYP1hz/8Qfn5+U7WiVaI2M7/uLU83gS+Ll1OABAPM50AdCbFZdWOzxo1zd6lmdgJANyUVKdTvQsuuEAXXHCBqqurVVxcrKysLIaHpyDHO50kyeOVmpnXxNI6AIivNtHQyTCzBEDHt6vY2QHikmSaOR8lcgIAdyXd6bSvLl26KC8vj8ApRbnR6WSztA4A4jLGJNzpVBc4cUxNxOOPP65Zs2bp8ccfd7sUAPvZVeJ86NTch6CcjgKAuxwJnZDa2qTTyRs/dGJpHQDEF47YCid6fGaeU0LKysq0bNky2batZcuWqayszO2SAOwRDkdUWubwPCep+dCJwB4AXJXQ8roDDzwwqTe3LEsbNmxI6rVwTlsEQM11OrG0DgDiCwZbMkScpXWJuPfee2X2tDUYY3Tffffp5ptvdrkqAJJUXhlsky5408x5rqHVCQBclVDoZNu2rATvWLYvDvKpIRJpg3+HOKFTxLY7zb99ZahWXXw+eazWNw2a2hqZUK2szK6SbUsyMjVVMv6AzJ4QzxgjEwrK8gda/fUAuKumJUPEQ7VtWEnHZ4ytTz74QF999VXU9i+//FIff/yxjjjiCMe+VrA2Ip/XktfrUThiy7aNMvzN31wD6Oyqa9qoY7O50KltvmrKMsaWgtVSoGvU9ZsxRgpWSYEusvact+4N6ZP7sNgYo2AwmNB+tSFbgQyvakMR2bbk99UdRyO23TBc3hijktIKSVJmoOWjhwOBQFLXrADaVkL/NW/atKmNy0BbaovldfE6nTpLl9PnxUVaX7ZdfTO769ic5LoB65mynTLvvyCzu0hm4EF1od6uAqlsV90wgtqauh1DQZk1L0mHT5DVo7cDfwoAbgkGE78AM2GW18Vjf/lvPfD7B2M+98ADD+iPf/yjPJ7Wfziwq6RaX20qVobfo0MO7KNP1++UbRsdOryPenbnwwAgnjYLnZo57+wsH4Q2+PoDmZ0FsnKGSMPH7N2+cZ1M0SapzwBZBx9dt62+i7amSubb/8ga0LLz2WAwqHnz5jlStiQVFxfrfy/+adKvz8/PV2ZmpmP1AHAGM506gTaZrxRnppPTt8JNVaW11Xv+v6b1b1ZVLhOsqptLUL5LCgWl6oq6OS41lXunYBpT94leFXNKgI4u4U4n7lzXrA8/+VQVNbG7wSoqKrR27VpHvk5ldUhGRsFQRFXVobpOJ2NUVU0oCDSnugVBe4s0Eyp1sshJprJ0z/+XxNyu+v+X9gZ2xnBuCaDNtLxvER1Om3Q6eWN/60Rsu9P8cB/VO0+byncpt2tW69+s/2BZh46XirfJOuBQKVQje8CB0u4iyZ8hvfd3SUHJ55c16GCp3wGt/5oAXFWT4Kf+JhJS57tsapnvnHSKuj//piqqG38I0L17d40ZM8aRr5PXv7uMMeqS6Ve/3l0VjtgKhW3l9OnmyPsD6aytOp3idTLVPdW5jp/WiO9KO7ZKOUOitw8fIxVtkvoN2rvR56/7f3+GdMAhrfq6R069SB6vP6nXfvHe3xWurZQvo5sOOfrMFr3WjoT00co/JvV1AbQPQqdOoE1mOlmWLI9Pxo7+9L0z3bWuuz+gUb3zHHkvy+OVNWy0NGzvtn17ySzf03X/7/XJGty6kwIAqaE6wUHiLK1rnrdnX136f5frjjvuaPTcZZdd5sjSOknyeT0aktez4fGAft0deV+gM6hqohuxLXXGO9dZPXpJPXo13t41SzpwdPS2PbOdLH9AVkbrlqV5vH55fcmFTocfN6tVXxtAamN5XZozxrRJp5MkWb7ozNKYzjPPCQBaqybRpSYMEU/IEUccoZEjR0ZtO/jgg3X44Ye7VBGAfdXWRtrmjeN2OnW+0AkAUg2hU5qzbdN2n/Lst8QuYrfRyQQApKFEl5rYYUKnRF1xxRUNdy6yLEuXX365yxUBqOfGTcUInQDAfYROaS7cRl1OUuO5TnQ5AUBiIhFbtaEEltcZydDplLCsrCzNmDFDHo9HM2bMUFaWAzP3ADjC40LqxJkpALgvoZlOt9xyi6ZOnarJkye3dT1wWFstrZOiQydjjGw+TQKAhCR6FycTrlVnG4LbWmeccYbOOOMMt8sAsB/L00ahU5wwyxjblQ4rAMBeCXU6LViwQCtXrmx47PV6deutt7ZVTXBQW3Y6aZ87VIQ70QBxAGit6uoEQye6nACkiTbrdIobOhHaA4DbEgqdunXrpurq6obHxhgO4h1EONzWnU51P+hZWgcAiUv0Lk4mFGzjSgCgfXjaqNOpqXc1pjPeuw4AUk9Cy+tGjBihp59+Wj/60Y+Uk5MjSSopKdGWLVuafe3gwYNbVyFapU07nSzJ8vkVqQ0SQgJACyQ6RNzUEjoBSA/t3enE2AcASA0JhU5XXnmlzj33XI0fP75h2/3336/7778/7ussy1I4nMCgVLSZSKRt7yhn+fyKBKub3xEA0KAqgdDJhGplDHcFBZAeumT6VVLeBueMVuyFG4ROAJAaEgqdZs2apeHDh+u5555TQUGBFi9erNGjR2vMmDFtXB5aq007nSTJ62NpHQC0UGVV8x1MpramHSoBgPbRtWtG27yxJ3boRBc+AKSGhEInSTr22GN17LHHSpIWL16sU089VTfddFObFQZntOVMJ0kKWRY/1AGgBYwxqkpgkDihE4B00q1L24ROVpOdTnwoCgCpIOHQaV+vvfaahg4d6nApaAtt3elUbdvytulXAID0UhuKKNzc0mdjZHPnOgBppK1Cp1gznWyGiANAykgqdJoyZUrU48rKSpWVlSkrK0vdunVzpDA4Ixxu23kgVZGIeliWRLcTACSksrr5MMmurZG4ZAKQRrp2CbTNG8fodLJtjp8AkCpi96MmIBQK6fbbb9fIkSOVlZWlQYMGKSsrSwcddJBuv/121dbyCW0qaMtOp5pwSLYxilj0OgFAoqqqmv/5aGqq2qESAGg/gQyvfN6kLz2aFmOmky2W1gFAqkiq06m6ulonnXSSVq9eLa/Xq5EjRyo3N1fbtm3Thg0bdOONN+rZZ5/VK6+8oi5dujhdM1qgLWc6Ve9Z+hHxeuTlZzsAJKSiuSHixjDPCUDasSxLWT26aHdJpbPvGyt0otMJAFJGUh833H333Xr77bd11lln6T//+Y8+//xzvfbaa/rss8+0ceNG/eQnP9E777yju+++2+l60UJt3ekkSREPnU4AkKiKZjqdTG2NDANwAaShXllt8GH0fsvrjDFiohMApI6kQqe//e1vGjdunB599FENGjQo6rm8vDwtXbpU48aN09/+9jdHikTy2ip0Ctt2wyBcQicASFxldfxOJ5uldQDSVK+eXZ1/0/06nSI2oT0ApJKkQqdNmzbpxBNPjLvP9773PW3atCmZt4eD2mqQeE147yf1hE4AkBjbNqqKN0icpXUA0lhbdDpZ+3U62dzcBgBSSlKhU9euXbVjx464++zYsUNdu7bBpxlokUgbrWmvCYX2eWTJJngCgGZV1dTGnTXC0joA6Swjw6duXR2+i12j0IljKACkkqRCp/Hjx+tvf/ubPv3005jPf/bZZ/r73/+uY489tlXFofXsNlheZ8zeeU4NXyfGEEcAQLSKSpbWAejcHO92siRLlqS6blL6nAAgtSR197rrr79e//rXv3TUUUfpvPPO05QpU5STk6Nt27Zp5cqVWrRokUKhkObPn+90vWihtuh0qo2EZfZrXY54vPIp1MQrAABSM0PEjZEJVrdfMQDggt7ZXfVNUYmzb+rxSHZEEbqcACDlJBU6HXfccXrsscd0/vnn6/e//70efPDBhueMMerZs6eWLFmiCRMmOFYokhNpg06n2kjjcIm5TgDQvHidTnawmjsuAUh7fXt1d/5NrT2dToROAJBykgqdJOm0007TySefrGeeeUYffvihysrKlJWVpe985zuaMWOGevTo4WSdSIIxpk3u4BGMhBtti7C8DgCaVVHVdOhkgiytA5D+umT61a1Lhirj3VShpSyPjGGIOACkoqRDJ0nq3r27Zs2apVmzZjlVDxwUb1hta9SGG4dOtuWp+5SJH/YAEJMxpulOJ2Nkgty1DkDn0LdXd1VW73bs/SzLossJAFIU7SlprC2W1kVsu4nuKUsRi28nAGhKVXWoye5TEwqytA5Ap9GnVzfH35N5TgCQmkgJ0lhbDBGPtbSu4et5mesEAE0pr2y6k4kuJwCdSZ9eXRvuOOcEI4uldQCQogid0CK18UIni9AJAJpSHm+IeC2hE4DOI8PvU1aPTMfezzZ2ozsrAwBSA6FTGmuLpRrhSKTJ52yGiQNAk5qa52QiEZkYdwUFgHTWJ7urY+8VYmkdAKQsUoJ01gYf+ITspkOniIdOJwBoSlkTy+tMbXU7VwIA7uud7dxcp0icD0UBAO4idEpjbdFlHI4TOhnLqruDHQAgSsS2VVkV+/bgJkyXE4DOp3e2M3OdjJEicc5PAQDuSip08nq9+slPfuJ0LUhxYdtupnuKO9gBQCyVVbVNzxsJNz0rDwDSld/nVU8H5jrVRsJt80krAMARSSUEWVlZOuCAA5yuBY5z9gdwvC6nejZL7ACgkfKKOHeuY54TgE6qtwNznYKRkIP3wQMAOC2p0Onoo4/WRx995HQtcJjTn/nEGyJeL8IwcQBopMk71xlbhmUhADopJ+Y61YbDsuh0AoCU5UvmRQsXLtSUKVO0ZMkSzZ492+ma4BCnP/WJJHBnkI7S6VRUVaaaSEjd/QGV1lZrcPfe8rew9m1VZaqK1GpI997yOLCs0JTvltn9rWR5ZPUdKNkRqXSn1H9wq98bgLuaCp0MS+sSYmoqpV2FMr1yVevxN72fbUvbt8iEa2V5fVL/IVL5TqmmWuo/WJbHI3v7Vmn7ZmX06itPZak0cpw8mS278C2tCKqyKqScPl3l9e49/lfXhLW7tDrmUspwxNb2XVXq0S1DPbpltOjrAemqV1aXVr9HMBJSRlvcPacVjDEKBpv4sKEZxcEqldRW6YBuveTzeBUIBGS18cxUY4xMwddSrxxZXbOinysvlsp2Sv2HyPJz7ALQckmFTi+99JKmTp2qefPm6YEHHtDRRx+tnJycRgdEy7J04403OlIoWm7fE2En2Al8imR3gEHi5bU1en/HZtnGVnmoRj0zuqgiFNSRfQYl/B4VoRq9t2OzJCPbGA3P6teqmowdkflstUzRRsnrkxlwoKxIWAqHZFWWtuq9/z97dx4mR1XuD/x7qnqdpWef7JmQFQghSELYSViDwAVBkMWrQFxArlc2RUEwQRTEC6jX5aeoAb3K5i6ibEpABBVECGtIQvbJ7NPTPb3Wcn5/TGYyPd0zU91dvX8/z8NDprq66sxMcrrqrfd9DxEV3njldcxyska++zIw6Ed07w58/J71thzzhydMh6ehBQj2Aceea/l9mm7i7a29MKVEXDMwZ0bdyGvvbu9DKKpBN5If0mzfM4CuvjBURcERh0yFohT/5yVRrrlcDng9TkSimZUZ66YB0zSLrqdTLBbDmjVrbDnW+vXr4fFk3/tqQnoccsdbQMc2iGWnjWyW0oR8+wVA1yHCQWDB4bkdBxGVpYyCTuvWrRv58yuvvIJXXnkl5X4MOhWW3Re0ljKdSqCRuENRoQoFUprwOoae2HjU8Z+cpzyGUOFQFOimkfZ7UxICcLoA1QGoDgiXF9DjgK4BrhxfaBBRTmm6gUiMfZuy4nQn/t8O++Z/kWaWk6IADlVBXDfgciZmyDqdKhDVkCrXeHhfp0PhQq9Eo9TVejMOOsV0HYo5+fUpTWJ4Ukq65hSAwz204IXLxvmXiCpKRkGnZ555xu5xUA6oNvdXspLpJIUY+uAqsidOo3kdTpw4fQHipgGv6sSgHkODK71Glh6HE6umDR2jzpV9argQCrDkBGDuYYAQENV1Qz/DSBCobcz6+ERUOOP2cyLLxMLlQMgPT1Ud1q8/YsJ9r7/uWvT7B9BQV4e7v/ENyHgE0OJD8yoAMxoC/F1wNbRChAcgpsxJayyqouDQRS2IxY2kMrlFBzQgFNbgUJOjSrOm1qK+1g2vx5HzUhmiUlJX60FHdyCj98YNHYqFh6L55na7sX79xFmZ119/Pfr7+9HQ0IC77757ZHvcMBAy9l+but15CPaoTohDjgWq6hI2CyGGrk95PUpEWcgo6LRy5Uq7x0E5oCgCAgLSpjp309KTJAFTKFBkcZeMeB0uDIeKGtWM/hkkHMMOwumGqB9TpudssvEMRFQIE61cR9YI1QH4miEwFPSfcN99/fmEqg6VpIwtS/F4gPp9c2tdZnOsy6kmZTkBQwEpX03q/itCCPhqmClANJavJvOrqWINOgkhJi2JG54nxu7rAeBD9g3W0yGEgPA1p37N6eL1KBFlpfhroShjQggoKZ62ZspKphNQGiV2RET5wkwnIqLx1dVm3kYgbrC8joio2GUcHdB1Hd/4xjewYsUK+Hw+OBz7s0VeffVVXHXVVXj33XdtGSRlzs4SO9NixpRpc1kfEVEpmyjoxCIrIqp0bpcDLmf6WeeaYQASUBl0IiIqahnVFUUiEZx22ml44YUX0NzcDJ/Ph1AoNPL6AQccgPvuuw+NjY34yle+YttgKX2qnc3ELVbpMdOJiGiIlHLi8joluUSLiKjSVHmciGt6Wu+JG0P7q1wFlIioqGUUHbj99tvxt7/9DXfccQc6Ojrw8Y9/POH1uro6rFy5Ek888YQtg6TMOVP0nMiU1d5Qkg1SiYgAALG4Dk0f/4ZIqAw6ERF5POmvBBwzNAhpQhRhTyciItovo6DTww8/jFWrVuGGG24YajyXIsgwd+5c7Ny5M+sBUnacjvzf0JgMOhERAbDQz0lRh1avJCKqYFUZBJ00w2CWExFRCcjoSnfnzp044oiJlyz2+XwYGBjIaFBkn1Sr6+QaM52IiIZYaiKe4QqaRETlwptm0EnKofI69nMiIip+GQWdamtr0d3dPeE+W7duRUtLy4T7UO5l0phxXOzpRESUlmBogn5O+wgGnYiownk9rrT2jxs6IAGHkV4fKCIiyr+MogNHHXUUHn300XEzmXbv3o0//vGPOOGEE7IaHGXPzp5OVjHTiYhoyODg5JlODDoRUaXzuNObB+OGBkDCYTLoRERU7DIKOn3uc59DX18fTjnlFLzwwgvQ9aEJPxwO489//jNOO+00aJqG6667ztbBUvpsLa+zHEsSAANPRFThpJQYDFsIOjnTe8JPRFRuVCW9W5KYoQ/1c5IW0/CJiKhgMnq8esIJJ+C73/0uPvOZz+D4448f2V5bWwsAUFUV3/ve97Bs2TJ7RkkZK0RPJ2Ao20nwQoCIKlgkpkE3Ju83IhwMOhFRZVPU9B5WxnWdpXVERCUi45z+K6+8EitXrsT3v/99/OMf/0BfXx98Ph+OPPJIXHXVVVi8eLGd46QM2dnTSUBAWmzsJCGsJ0YREZWhQStNxAFAVSEUFZKrMBFRhUon00k3DRimCS+DTkREJSGriMRBBx2Eb33rW3aNhXLAnWaN/ESEsJ7FzBwnIqp0loNOGCqxk7FIDkdDRFS8VMX6o8qoPtTPSTUYqCciKgVcZqzMeVz2ZjpZ35l5TkRU2YIW+jkNY4kdEVUyJY1Mp5iuwbkv8ERERMUvq4jE3/72N/zkJz/Bq6++ioGBAdTV1eGwww7DRz/6URx33HF2jZGy4HSqUBQB07ThgzmNOBIvA4io0g2G4pb3FU53DkdCRFTcFEVYbuMQ1XV4DS0PoyIiIjtkFHSSUuKqq67CvffeC7mv3kpRFJimiZdffhk//vGP8clPfhLf+973IJjxUlBCCLhdTkSi1m9+xj1WWl2a+HsnosolpUQonUwnrmBHRBXMNKWlgJNmGDBNg03EiYhKSEbldXfffTd+8IMf4JBDDsEvfvELdHR0QNd1dHR04JFHHsHixYtx77334p577rF7vJQBj019ndIJI0kGG4mogsXiOjQ9jX4jQkCoztwNiIioiBnm5Ct9AkBEjw8FnLhCMhFRycgo6HTvvffigAMOwIsvvogPfvCDaG1tBQC0trbi/PPPxwsvvIC2tjb84Ac/sHWwlBmP254bGWatERFZMxhOP7uUJXZEVKl03VrQKaprcOksrSMiKiUZBZ127dqF8847D1VVVSlfr6mpwXnnnYddu3ZlNTiyh13NxBlyIiKyJp3SumEssSOiSmUYkwedpJSIa3E42c+JiKikZBR0mjlzJqLR6IT7xGIxzJw5M6NBkb3cdpXXpZXpxLRnIqpcmWU6MehERJVJtxB0iugaHLrG0joiohKTUdBpzZo1eOSRR9DZ2Zny9b179+Lhhx/Gxz/+8awGR/awLdMpjaATs6KIqJJllOmkOsHZk4gqkZWgU1SLs7SOiKgEWYpG7Ny5M+Hriy66CC+++CLe97734eqrr8Zxxx2H1tZWdHV14a9//Sv+93//F0cffTQ+9KEP5WTQlB67ejqlhQ+hiKiChSMZrBgqAKE6IFk6QkQVJq5NvhpdVIuhhqvWERGVHEtBpzlz5qTMcpFS4qabbkq5/dFHH8Vjjz0GXeeHQ6HZt3odn8ATEU3GNCXC0cwCR8LhZNCJiCpOZJI5M6brULUY+FSTiKj0WIpGfPSjH+XKZSWsEJlOghcFRFShwtE4ZIY9R4TDCaRfmUdEVNImCzpF9ThcWgYZpEREVHCWgk73339/jodBuaSqCpwOFZpuZHUchh2JiCaXUWndPsJRgHJoIqICmzToFIvAa2Z3HUtERIWRUSNxKj35znYSXFmEiCpUNkEnqAw6EVHlicbGDzoZpgklFsnjaIiIyE4MOlUIW/o6pZHqxKATEVWqcCTznkxCtacHHxFRKZmoD16Eq9YREZW0jINOL7zwAs4991zMnTsXbrcbqqom/edw8OK5WLhd+fxdSAadiKhihaNZZDoJQCiqfYMhIipy8bgOfYIWEPFoCEKaeRwRERHZKaNIxM9+9jNceumlkFJi7ty5WLFiBQNMRc6OoFN6cSQGnYioMmWT6QQMZTtJ9i4hogoRCI2/eoKUAGLh/A2GiIhsl1Ek4rbbbkNDQwP+9Kc/4YgjjrB7TJQDLmf2T86lxUASs5yIqFJJKRHJJtMJAFQHoHEJOyKqDIOh6LivxfU4HCytIyIqaRmV1+3cuRMXXXQRA04lxGVHeZ3FWJLCoBMRVSjdMKEb2ZWBCJXldURUOQKD4wfZ4+HBdFPtiYioyGQUdJozZw7i8Syf5FJeuZzZB51MZjoREU1osmW/LWFPJyKqIMHB8TOdZCyUx5EQEVEuZBR0uvLKK/GHP/wBfX19do+HcsTtsqG8zmIwSWGzRyKqUHYEndhInIgqhZQSwXDqTCep6xAaS+uIiEpdRukvV199NbZs2YJjjz0WN998M5YuXQqfz5dy39mzZ2c1QLKHHZlOVhOYKjHotD3Yi52D/VhY14KpVXWW3ye7d0Hu3Qq4q4FYCPA1A4FeiPpWiNkH5XDERJQL5Zzp9GZfO7qCfhzcMA11Lm/S64Zp4LW+dhjSxGGNM+FUVXRGAtgy0INZNfWYXdM4sq/b7YYQIuOxmIE+yJf/BKE4IFacAVFVm3I/6e+CueXfEJFBiBnzgQMOnfS8UkrEYtn11DL2lVjquoloNHUWR0wz8NeXd2NgMIbli6egbXrqz45sf1ZExSwUiY/8exlLCwct9xMtZYY08dzeLZhRXYd5vhYAwBt97fDHw1jSOCPlfGuVlBLYthFm9+6hRSqmtAHvvQbEoxBHn5O47/Y3IIN9EAccCggB+d5GiJp6SG8t0LUDYvp8iOYZWX2vRFSZMo5EHHbYYfjZz36Gj370o+PuI4SAruuZnoJs5LIh08m0GExSzMoLOm3ydyJu6tg80J1e0Gn3u0BkEHL7GxDNs4C924DaRshBPzB9PoTDmbtBE5HtorHyzHSKGzre7W3HL9beY8vx1q9fD4/Hk/kBdr0NdO8euh3dsxliweEpd5PtW4DOHZAhP6A6IKbNA7w1Ex46FothzZo1mY9tlEDAb+lYj03wWtY/K6Ii5h+IjPuaER3M40gKRzdNDMTDGNSimOdrQUTXsC3YA2DooebSppmZHzwaguzYDnTthHS5gb69QH/n0GvvvTqym5QSsn3r0Bcd7w09/Aj2QQb7hv5sGpB73mXQiYgyklHQ6dvf/jauueYaOJ1OnHjiiZg2bRocDhsaVVPOqIoCVVXGfZpkhWE16FSBmU5zapuwY7Av4Um+FWJKG+SeLRCzFw+tVjXnECDYB1HfwoATUQmKxRMftGiGgc7BgTSPIlE3SUnJQLYr5KXJqaiYVlWf13NOaNpcYMdbEIoKMXXOuLuJltmQfR0QLjfQOBXwVOVvjEQ0qf5AOOV2GY/BNIw8j6YwHEKBW3ViZnU9AMCjOjCtqg79sTBm7NuWMXfV0NynRSEcTsjWNkCaQDwGzDowYVfRPAMy2As0zwIUZSg4VV039F/ndojWtuzGQkQVK6NI0Te+8Q3MmDEDL7zwAmbOzCL6TnmlKpkHnQxpprF6XeUFnRbVT8Gi+ilpv09Mnw8xfX4ORkREhRCNJQadFEVY7oc3mhSYsKY53yUnQggcOX0e1q9fP+F+119/Pfr7+9HQ0IC777573P3cbndW41EapwFnfGLS/UTLTKgtmV+nLF11JRQ1/QcA7/zzYejxEByuahy44sK0328aGl7b8P2030dUavrHyXQyoyHICrmeVBUFp83c31JBCIHlLfYEeISiQBx4JHDgkfs3LliWvJ8QEAuXY3Qhr1h22v4vxgSoiIjSkVHQqaOjA1dccQUDTiXG6VAQz7DywzSt3uBICMv7EhGVl7HldapQAAHLQfthplCgyOJ6yi+EmLTMa7j3kJV9S4GiOqFmkHW6+Jj/zMFoiMqLphsYDKXonyYlzGgYJldDJiIqCxmtXjd//nz4/X6bh0K5pqoZ/boBALpp7eZHSIm0766IiMpENJ7cx9DrdKV9HAk2jiai8tY/EEmZtWnGwpb7iBIRUfHLKApx7bXX4ne/+x127Nhh93goh7IJOll92qRaDE4REZUbwzCh68lzYLUz/VIyydXKiKjM+cfr5xQJZ1SWTERExSmj8rp58+Zh5cqVWL58Oa6++mocdthh8Pl8Kfc94YQTshog2ceRRdBJsxhMUitw5ToiIiC5ifgwj8MFh6pAT6OnnsmgExGVuZ7+UPJGw4CpRVlaR0RURjIKOq1atQpCDDVH/dKXvjTSwyEVo0JWnigFWQWdjNQ3U2MpzHQiogo1XtBJCKDeU42eUNDysZjpRETlTNMN+APJTcTN6FAgiuV1RETlI6Og02SBJipO2ZTXaRaDhyyvI6JKlaqf0zCv0wW304mYZm01BwadiKic9faHUpbQDQedWF5HRFQ+Mgo6rVu3zuZhUD4oSmY3MaaUMCyVzUmofDJFRBUqPkHQCQAavTXo0P2WbqbYSJyIylmq0joZj0EaOqRM1V6ciIhKVeapL1RyRIY3MVaznISUAJ9MEVGFGq+8bphDUdDgrbZ2MGY6EVEZ6+kbTNq2v7SO15JEROWEQadKkuE9jGZa6+fE0joiqmTx+ORzYLXLjSrX5KvZsbyOiMpVKBxHKBJP3CglZHRoNTsGnYiIyktG5XWKoljq6SSEgK5bC1hQ7mV6CxO3+Dt0sGk8EVWwmGZtrmz01iBu6NAnmDNZXkdE5ap7nCyn4aI69nMiIiovGQWdTjjhhJRBp4GBAWzevBmhUAhLly5FfX19tuMjO2X45DxmWGt8y0wnIqpkk5XXDRMCaK6qReegf9yKZMmYExGVqY6eQNI2M7K/xxMznYiIyktGQacNGzaM+1o4HMYXvvAFPP7443jyySczHRflQCb3MIZpQjesNRF3WCzDIyIqR5M1Eh/Nqapo8NagL5z8xJ+IqFzF4zr6/OGEbVLXIPWhcruhJuIMOhERlRPbezpVVVXhf//3f1FXV4cbbrjB7sNTNjKIOsUMazdRijTZRJyIKprVTKdhE/d3YqoTEZWfzt7BpPI5ySwnIqKylrNG4scffzwee+yxXB2eMpDJLUxMj0++EwCV/ZyIqILphtWs0ESN3mo41OSPYt52EVE56ugeU1on5ciqdQBgMOhERFR2chZ06u7uxuAgywaKSSaf41GrTcTZz4mIKlg6pXWjCSHQ6K1J8UKWAyIiKjK6bqCnP/HewIxFIOX+gL0p0w/eExFRcbM96GSaJv7v//4PDz/8MA477DC7D09ZSDdl2ZDmhKsrjaZaLMMjIipH0QyDTgDgdjhR7R5bZseoExGVl67eQZjm+KV1UnLlOiKicpRRI/G5c+em3K7rOrq6uqBpGhwOB26//fasBkf2GvtBP5mIZq20DpBcuY6IKlq6/ZzGqvdUI6zFIUfmad54EVF52d3hT/haGjpMLTryNbOciIjKU0ZBJ9M0IUTyU1in04lDDjkEy5cvx6c//WkccsghWQ+Q7JOroJODWU5EVOFiMS2r9ytCwOf2YiCyb1UnxpyIqIxEYxp6+kIJ20ZnOQFDGfZERFR+Mgo6bd++3eZhUD6kk7IsJRDVrd1EMehERJUuGst+Hqx1eRGMRWCaEoJRJyIqI+2dA5Bj5rXRDcSB9B+OEhFRachZI3EqPun0dIrocctP2hl0IqJKZ0fQSQig2uWxYTRERMVDSondHQOJ2+JRyFGtGUxTJgWliIioPDDoVEHSeYLEfk5ERNZl29NpWLVzqKG44L0XEZWJwGAUwVA0YZvJ0joioophubzuqquuSvvgQgh897vfTft9lBvpBJ2iOvs5ERFZFcmyp9Mwp6rCqaqQhj3HIyIqtLFZTpAmzFgkYRObiBMRlS/LQafvf//7lg86usk4g07FwzStfaBHdc1ygMrJoBMRVTgpJaJR+4JEbocT8TE3ZEREpUg3TOwZs2rdUMBp/3WmlOm1gCAiotJiOej0zDPPWNpv586d+PKXv4ytW7emXOGOCsewGEgKxWOWj8lMJyKqdHHNgGExqG+Fx+GExhswIioD7Z0D0PTENgwyyiwnIqJKYjnotHLlyglf7+/vx+23347vfve7iEajOProo3HnnXdmPUCyj5WbIimt93MS0oTCfk5EVOGiNpXWDXOqKgRvwoioxEkpsX13X+JG04QZT+zvxH5ORETlzXLQaTzRaBTf/OY38fWvfx1+vx8HHnggbr/9dnzgAx+wYXhkJ8OY/Ml5RI9DWnzC7mTPESIihG0srQMAVagQXMWJiEpcnz+c3EB8TGkdYL39AxERlaaMV6+TUuJHP/oRFixYgJtuuglVVVW499578cYbbzDgVKQMY/IP9dCYp08TYT8nIiIgHLG62qc1QgAqY05EVOK27+lL2ibHNhA3JUPsRERlLqNMp9/+9re46aabsGnTJvh8Ptx+++245ppr4PF47B4f2WiyJ0mmlIjqVp/YS/ZzIiKC/UEnAFB5G0ZEJSwS1dDZHUzcKAGpJfYNZT8nIqLyl1bQ6fnnn8fnP/95/P3vf4fL5cK1116LL37xi2hoaMjV+MgmUspJG4mH47GxGc/jchjGUAMoIqIKF47YX2qsmCZ4K0ZEpWr77l6MzWGSehxyTJCJq9YREZU/y0Gns88+G4899hgURcGll16KL3/5y5g5c2Yux0Y2khKT9moaTKu0jv2ciIgAIGR3ppNpsqcTEZWsuKZjZ3t/0naZ4jqTmU5EROXPctDpD3/4A4QQmD17Njo6OvDJT35y0vcIIfDYY49lNUCyx2Qr12mGAc2wuhIdS+uIiIChuTVqcyNxaXJ+JaLStWNPP/QUfUSTS+vYz4mIqBKkVV4npcS2bduwbds2S/sLITIaFNnPnKS0Lp0sJ8U0oZhWA1REROUrFI4nlZBkS1p+AEBEVFx0w8T23ckNxCEBGU8MOlldLZmIiEqb5aCT1UATFaeJMp2kBEJjnj5NxFVCpXVSSsRiE39vppSIGjq8qiNloHT4okhKiWh0/OBczNAQMXTUu7xJ74/H43C5XJYDsTIeBVQnhKrCjEch9wX5hsdgajEgFoFSUz/UHyEeBVzecY8/etxGgX5/o8/LC00qF6Gw9bnTshLIJNVNA7ppwuNwFnQcMh4BFAdEinFIacKMhiCcbgh1/+WO1DXA1CHGzNVElL1d7f2Ia8lzmDS05B5PZXgtYEqJiK6hyuFMeU0W0uLwqCqihpHz7394foRpAIq6b4A6IFSYsTDEqPNLKSFNAzIagVDE0HWnUKB4a4bGGQtDOl0QmgbhqcrpuImo/FgOOrW1teVyHJRjE2U6RfQ45CSZUKM5La9wV3ixWAxr1qyx5Vj9/f22HauQY9i44fs2jSZz8XgcXi9v+Kj0DYbsX7lOFvkcq5kGNrS/i6ihY3nLbEyrqivIOGRfB+SmfwBOD7D0RAinK3GHWBTyqZ8A0+cBS0+CcDghtTjka88AWhRYdCRE49SCjJ2oHJmmxLZdvalfTBFMN8uwuO7l7h3ojARwQG0zDmmcnvDau/5ObBroxKAWQ43TDS2HVQOyvwPynX8AhgEpxFBwXgDQYpDRELB7M6Snan/2mRaD+epfgJ3vDD3MDA8A3lqYx58PEeiF2bkdCA0A1fXAnMUQ0+fnbOxEVH6UQg+A8mOioFNapXWSpXVERMMGc5DpJDX7A1l2ihk6ooYGQCKQxueH7UIDQyuuxqNDQaQkcui1WBTQ9t9YIR4del9oII+DJSp/ezr9iMRSB81TBdPLMdNpIB5J+H+q1/pi4aHMolwG3fbNjzIcBHQNiEcgI4NDny+hAcCIA4YGyH3X9FICwb6huTQSBOIxQIsDwX7IkH/o9cF9zeEH/bkbNxGVpbR6OlHpMlI0dAQA3TQR06w/VS+lLKexqi89FcKppv2+8G9fgAzHIKrcqPrAMWm9V2oGQj95auTr7yz1wJ1BqPcr78QwoEvUOQRuPtCd1ntjJvDp1/bfkB266kqoav5LYgxDG8mycrlck+xNVBpsDzpJCVnkJcw1TjeWNs3EoBbDXF9z4QYybS6EaQCeaogqX/LrDifEwUdDNE2H8NYAAERVLTDvMCAaAqbNze94icqYaUps3t4z7usyRaZTGcacsKx5NvaE/WiraUp67eCG6fA6XDiofioihganksPbsGnzIAwDcHkgtDjgcAKqAzIShFQUYOc7gMsLvNAJIAo4nFAOXQW5+11IhwsI9kF4vBCzDwJiYYjOHZCzD4bQ4wCznIgoTQw6VYjxMp1CaT6ldhb5zdBEhFOFcKb/V776ghNsG4NbATxq+g32v7LYk8VZE3/3quqEWuA+LFxkgMqBaUoMhuwNOhV7ad2w2TWNhR7CUB+ntoMneN0F5aCjk7dPYbsAIrvt7vAjEh0/SzNl0KkMy+saPdVo9FSnfK3a6UoouVNyeC0kVAfQdjDGnmHk69lDc6f46WMj+4uGKRANU5IP5qgD5h6adCwiIqtYXlchzBSPk6QEBuPWb5iENKGWQINbIqJ8GAzHUs6t2SiVoBMR0TDTlNiyo3uSndiagYioUjHoVCFS3RdF9TjMCVa1G8vFmyEiohHBQfv7Gck0VhIlIioGu/b2IxKd5BpxzPVmOZbWERFRagw6VYhUzRrTaSAOAE69uJvbEhHlUyAXQadCNuYmIkqTYZrYumP8Xk7DyrFpOBERWcOgU4UyTBPRNDKXFGlAZWo0EdGIwKDd/Zx0yOF5lvdnRFQCdu8df8W6EVKCkxoRUeVi0KlCjH3CNDi8ZLRFpbxqHRGR3aSUtmc6McuJiEqJYZjYYiHLCdJ6KwciIio/DDpViLFZzaE0GogD7OdERDRaNKYjrtm7sMLooFM5rupEROVl195+RCfLcgKY5EREVOEYdKoQo29gIlocRhoNxBXTgMLSOiKiEQPBiL0HlDKhiTjbnxBRMbOc5URERBWPQacKMfoGJt0G4i42ECciSmB3aZ0Zj0KOKkFhphMRFbOd7f2IxS1me4rcjoWIiIobg04VQuz7wE+3gTggWVpHRDTGQNDmfk6R0MifTaY5EVER023IcmIcioiocjDoVCHEvqhTKB5Lq7beYegQbABJRJTA1vI604AZ3388Li1ORMVsx56+NHvapQgxMepERFQxGHSqEMq+oFP6pXXMciIiGi0a06yXlVhgRsMJXxsM9BNRkTIME+/t7E3vTQwwERFVNAadKoQQAlFdS6uBOCDhNBh0IiIaze7SOnNUaR0AmCYznYioOO3a689g5U5GnYiIKhmDThVCERlmObHMg4gogZ2ldTIegxwV3DdMk03EiagomabEe7sy6OUkGHQiIqpkDDpViLihI6KltwodV60jIkpm58p1ZjiY8HV62ahERPnT3jmASDTTDHgGnoiIKhWDThVid6A3rQbiijSgGvb1LCEiKhd2BZ2kriU0EDelZD8nIipKUkpszSTLaR/BbCcioorFoFMFkFJim787rfe40syKIiKqBHFNz+JJfyIzFEj4WjcMW45LRGS3zp4gBkOxzA8wNujEKmIioorBoFMF6AkHEYyHJ99xhOSqdUREKQQGs7jpGkXqOszY/nnZME1mORFR0XpvV5or1k2CMSciosrBoFMF2NyzN61SeqehQ/Dmh4goSdCm0rqxvZw0k1lORFScgqEo+gfSeXhpBcNORESVgkGnMqebBrb2d6b1m2ZpHRFRasFsykv2kYYOMxoa+VozDEiuFEpERWpXu9/2Y3LGIyKqHAw6lbmd/h7Edd1yppMiTTgMltYREaWSVU+TfczBAQzfchmmCZ1ZTkRUpAzDxO4Ov+3HZaCdiKhyMOhU5jb37gWwr3+jhcATs5yIiFKTUmIwnF3QSeraSC8nKYeynIiIilVHdwCabv88xaATEVHlYNCpjIXjMewO9O3foEz2AS/h0hl0IiJKJRbXs775GspyGhI3NEgWmRBREdu512/PgcYEmTjzERFVDgadytiWvo7ET/VJMp2cusYG4kRE4xgMZxeUl/EYzHgEwFCGk8kn/URUxELhGPr8ocl3tECOub5kphMRUeVg0KmMbenrSPhaTPLbdrO0johoXJFodnOkGRrKcmIfJyIqBV29g/YcKEWAiUF3IqLKwaBTmeoLD6I/PObp1AS/bdXUoZp6bgdFRFTCwpHMF1mQsShMLQZTSmgG51oiKn7dfTYFncyxWU5gaTERUQVh0KlMbe3rTN44QU8nNhAnIppYNplORmgAkEDc0HmrRURFzzBM9PnDthxrbGmdyVYOREQVhUGnMiSlxNYxpXXA+OV1AhIuPfMn+ERElSAczWyeNGMRSD2OuKmzjwkRlYQ+fxiGaVNwaEw5MedBIqLKwqBTGeoY9CMUT7Gs9zi/7aEsJ14AEBFNJBbLrCzOHByAYZr23cAREeWYbaV1AOSYkmKDQScioopSFkGnOXPmQAiR8r8rr7yy0MPLu5SldcA45XUSbi1FgIqIiBLEtfSDTmY0BKlr0Aw2Diei0tHdb1/QCcbYTCcG4ImIKomj0AOwS11dHa655pqk7cuXL8//YArIME1s7+9K+Vqq8jqnrkHww5+IaEKGYUI30p8rzVAQmmmwaS4RlQzDNBEK2dfrc3Smk2lyNiQiqjRlE3Sqr6/HunXrCj2Mgtsb7EdMH+dpvDp2A7OciIis0PT0M5XMWASmHoduMsuJiEpHJKrZGihPCDrxQScRUcUpi/I62m/bOFlOACDGlNephgGVN0NERJOKaxkEnUIB6OzjREQlJhyxcXEZCWDUYjUGg05ERBWnbDKdYrEYfvKTn2DPnj1oaGjAMcccg6VLlxZ6WHllmCa2+7vH32FMppOHWU5ERJakW1on41FIPV62zcP7YiH0x8KYXdMIp5KURpugOxLEoBbD7NpGqELBoBZFRziAGdX18Dpcls4ntTjQvROobQKqaiH3bgMiAaCuGYgMQgb6IKp8EHMW73+PacB4+0UgFoFYeASUqloAgLF7E7DtdWDRkVBbZyWfa1STY8MozMquo8/Llb4o3yJRG0vr9PhI1pSUgFkhf5+7I0EEtRja9s177SE/NNPE7JoGCCEA7P9ZZPpvXEqJWCz9a3mpxyG3vgapx2Huuxcwo2GEXvwDROtswOmBMDSgYQqEp2bfe7SROVjU1I8cKxqNjvyZ8yURjadsgk4dHR247LLLEradfvrp+L//+z80NzeP+75YLJYwYQcCgVwNMefag/2Ij1daBwzltQkAElBMA44CfTgQEZUa00zvQtYMBWGYZln2cjJME3/v3AZDmghpcRzaNGPcfSN6HP/o2g4JCc00sLB+Cl7q3olBLYrOSBDHTp1n7aQ73oDs2gWoDmBKG+Tb/wCCvYDLA5gm0N8JWdcE4XTuf48WB174HeDyAv4uYNVFMGNhYMNDQGQQ6NgGefZ/QbirEk4Vj++/4d644ftp/WxyIR6Pw+v1FnoYVEHCERuDTqMecFZKaV1E1xLmvRZvDf7VsxMAoAiBWTUNAIC4OXTNrmVYdRCLxbBmzRpbxuwPR/GJbz+Q1TE4XxLReMqivG7NmjXYsGEDuru7EQgE8Pe//x3vf//78fjjj+Pss8+eMOp9xx13oK6ubuS/WbOSn3qWim3jrVq3jxAYWcHOrTPLiYjIqnSCTlKLw9SiZftEXwjApQ49s3KrEz+7UoUCx75MKI9jKCDk2fcej+oc931JnJ59/3cN/Vl1AIoKOFxD/6kqoDj27zcyAAegKMBwYElRAad7/zEnydIiqkThqH0PJaW2P4BVKaV1qhD75z3VCZeiQhFDT35Hz5kCYt8fRAFGSUSUP2WR6fSlL30p4esjjzwSf/jDH7By5Uo8//zz+OMf/4gzzzwz5XtvvPFGXHfddSNfBwKBkgw8GaaJHQM9k++oAEI34dKY5UREZJWZRpmcGQ4O/b9Mg06KUHD81PkI6TE0uKom3NelOrBy2gJEDQ0N+wI/R7S0YSAeRb07jafRsw+CaJgCeGsgnG5IX+PQzWyVD4gNQsYiEE7P0D4jJ/cAZ10FEQsD0w4YGrvTDfOsT0F2bIOYsRBiOAA1esyu/SV/h666Emo6wTGbGIY2kjUwejxE+ZBJD7vxjGQ6yfTm0VLmUh1YNW0BIqPmvVXTFsCQJnyu/fOeS1ERAuBMtbx0mr6z1AN3Bof5yjsxDOgSdQ6Bmw9Mng8nMxA38dk3hwKLnC+JaDxlEXRKRVEUXH755Xj++efxt7/9bdygk9vthtud/iRbbDoG/ROX1u0j1OFeTuV5M0RElAuW+0QYxlAJVzrvKUFu1TFpltMwr8MJr2P/jYhDUdHkqU7rfEIIwNe0/+vaRozkBnhSB76EEFCbpydtV6rrgHmHTXyufVTVCdWR/5uo0QSzICjPVMWev3NS1yH3lY4Z0qyoK0+PwzmS3QkA1SkC3MP/tu34N+5WAI+a/nG+stgz+U4TiKmcL4locmVRXjee4V5O4XC4wCPJvR0TNRAfRYUOl25frT4RUWWwdiE7nOUEoCz7ORFR+VNsunGXsf3X3+W6qAIREU2urINO//jHPwAAc+bMKexAckxKiR1+C6V1AOpigaHlQ4iIyDLFypN/KWFGQ/v+nNvxEBHliqLac3tgxiIAhi47K6WfExERJSv5oNNbb70Fv9+ftP3555/HPffcA7fbjfPOOy//A8ujnnAQ4fjkjcFVQ0djuD8PIyIiqjxmZBBy340VY05EVKrsyHSShg65L7Nez3B1NiIiKg8l39PpkUcewde//nWcfPLJmDNnDtxuN9544w08+eSTUBQF3//+9zF79uxCDzOnrJbWtQ50wyVZWkdElK5JM52kTCitY9iJiEqVpczOSch9WU4AS+uIiCpdyQedTjzxRLz99tt45ZVX8OyzzyIajWLKlCm48MILce2112LFihWFHmLOWQk6KaaBqf1diKGwDf6IiErRZE/+zUhopGEuEVEpc9hQXmdGh/o56abJ/nZERBWu5INOK1euxMqVKws9jIIJxiLwRyZvlD7F3w2HocO02AyXiIj2Uye6CZMSZjgwdhMRUUmqrcluRTOpxUdK6wwG44mIKl7J93SqdLsHeifdRzUMTO3vBAA4oOd6SEREZcfhGP/j0owmZznxyT4RlSpfjTur9w+XGhumCZMReCKiisegU4nbZSHoNMXfBYcxFGxShIQK1tYTEaVj3HITCZihQPJm3mgRUYmqqXJn3kzcNIZWrZOAxiwnIiICg04lTTcNtAcnXo1ONXRM9XcmbGO2ExFResYLOpmRwZS9nAwGnYioRKmqguqqzLKdzMggAAnNNBh8JyIiAAw6lbS9Qf+kK4JM7e+CaiTeEDHoRESUHlVVIMb2xDMNmKGB5J0lYEpmlBJR6fJl0tdJyqFFFSR7ORER0X4MOpWwyfo5OVJkOQGAQzDoRESUDiFEUl8nI+iHTBFcYkkJEZU6X236QafhVTzjhs6udkRENIJBpxK2J9A34etT+zugpMiEYqYTEVH6nA515M8yHoUZS145lE/4iagctDTWpPeGfat46obBTE8iIkrAoFOJCsWjGIgm3/AMc2lxTPV3p3zNyaATEVHaRjKdpIQxTj89zeQTfiIqfbXVbtRUW+/rZEYGYRg6Mz2JiCgJg04lam/QP+HrM/raIcbp98RMJyKi9DmdQ5lOZjgAaSTPo5phTNpnj4ioVExt9lnbUUoYoQC0FPMiERERg04lqn2C0jpvLILmwPj9nhzgUygionQ5VAVSi8MIBZNe0w0TOp/wE1EZmdpiLehkhoOI63GYXK2OiIhSYNCpBEkp0T5OaQcAzOzZg4nqO5jpRESUPhUSRqAXYydYzTCgmZxXiai8+GrcqPK4Jt7JNBEN9jPLk4iIxsWgUwkKxCIIxWMpX6sNB1GfagnvURh0IiJKj5QSZtf2pLK6uKEzw4mIypIQAlNbaifcJxLohc6yOiIimgCDTiVo73hZTlJiVs+eSd+vwITCVrdERJbFd70LBHpGvpZSIqZrfLpPRGVtxtT6cV+Lx6LQU5QbExERjcagUwnqGkydydQw6Ed1NDTp+4UAVPZ1IiKyxAj2I/rWP6BiKMCkGwZiusb+JURU9nw1HjTWVydt100DIX83JB9iEhHRJBh0KkGdKcrnhGlaynIaxmbiRESTk7qG8L83QJoGTDkUbNJMg7dZRFQx5sxsTPjakCZ6B/qg6vECjYiIiEoJg04lJqLFEYhGkrZP8XfBraXu85SKyr5ORESTirz5d2jBPvRHBuGPhpjdREQVZ0pTLbxuJwDAlBLdgwG4LGTWExERAQw6lZxUpXUOXcOMvo60jqMKZjoREU0ktmsz+ra9gb1BP4Kx6ISrghIRlStFEZg9oxFSAj3hIBCPQOUCCkREZBGDTiWmY9CftG1mbzuUND/8WV5HRDS+7s5deO8ff0RfeHCkWbhg1ImIKtTMaXXoiwYR0+LwjLOCMhERUSqOQg+A0tMdCiR87Y2F0TJqRSWr2EiciChZVNfwys5NcPz7GXji7FdCRCSlxMt7tyLqiMI1qKX9oJOIiCobg04lREqJ3sjg6A2Y3b07o5IPZjoREe1nSol3e9rx8u4tmLFnC2pi0aR9JEQBRkZEVFivtG/Dpu52OKt1eLqZ5UREROlh0KmEBGIR6Mb+YFF9aAC+cDCjYzHTiYhoSF9kEH/d/jZ6QkE0BvvQFOhLuZ/JinQiqjBvdu7Cq3u3AwCmDnYBAPzwFXBERERUahh0KiE9owJMwjQxu2d3xsdSYNoxJCKikmWYJjZ27MCrHdthmhKqoQ9lj46DQSciqiTb+rvw992bAQCKaWCKvxsGFAzAxw53RERkGYNOJaR3VNBpqr8L7iwaOTLoRESVrC88iGe3v4W+8P6S5Zm97XDq2rjvYdCJiCpF1+AAnt321kgLh5aBHjgMHQ4B+BDEgKwt7ACJiKhkMOhUQoaDTk49jul9e7M6FoNORFSptvV34bltb0E398+D1dEQWge6J3yfwaATEVWAQCyCp7Zu3L9yp2liWn/nyOvN6MEAGHQiIiJrGHQqEVLKkaDTrJ52KGZ2QSMGnYio0kgpsbFjB17e897YFzCnc+ekizJo0pm7wRERFYGoruHJza8hqu3P+mwK9iVkgXpEHD4EEWC2ExERWcDHtiUiqmuI6TqqI4NoCvRmfTwGnYio0vxj9+bkgBOA1oFuVMXCk75fA4NORFS+TCmx4b03MRAdNR9KmZDlNKwFvVzPk4iILGHQqUQMRMOAlGjr3mXL8Rh0IqJKsrWvE292pmgSLiWm9ndN+n5TCuhQczAyIqLi8O/2bdgzZvXO6lgYnng0aV+PiMEnMltBmYiIKgvL60qEPxpCc7AP1dHJn8ZbISAhMGk1CRFRyRuIhvH8jndSvlYbGYRbm3xRhkrIcpJSIhaztkDFtmAP2kMDEBAI6lEYpgFTSsQNfeRY0WgUIT2Ol7q3Y28oAKeiYkFdK5Y0TociUudISCkRj8fhcrkgRu0j/Z0wX/8r0LEdcDgBaQDRKNA4FVCdgJRAQwuEuwrmvjIgMxxA6Mn/gxAC0jSAjh2AqgIHLAH6uwBvDUTrLECLQ8w9FMJTDQCWfwZE5WSHvxuv7t2etL1pTBBqtBb0IIDairyWtDpf+uMRvNW3F02eaiyqnwIAMEwDr/W1I7ZvrhqeL6WUeGrPO2gP+THFW4sZNY1YWNeK1/v2QBUKljZOh6rsf/jBuYqISgWDTiUiEApgVs8e244nBCCk3Bd6IiIqX2927oJuGClfaxnosXSMeAUEnWKxGNasWWPLsfr7+2071sS2jPuKP6rjE/f/KcUrb+ZuOEQlaCAaHlqpbgwhTTQFxw86uUUcdQjAL325HF5RKs35koioMFheVyKUHW/DMcFS3kRElExKiV3j9MFTDR2Ng35Lx4nCY+OoiIiKg2GaeOa9N6ClCMz7QkE49mUvjqcZPXx8SUREE2KmUwkwQgOo6tyBiT/2iYhorIgWx2AsuR8JMLQik5DW+ttF4LVzWEWv+tJTIZzp97AK//YFyHAMosqNqg8ck9Z7pWYg9JOnRr7+zlIP3Bk8GvvKOzEM6BJ1DoGbD3Sn/f6AJnH9Gyxbocrw8p6t6A0PpnyteYIsp2FuoaEOA/DLOruHVjKKYb4kIipmDDqVgMjb/4QxyZMmIiJK5nI4MF4Du8Zgv6VjSAlEZGVlOgmnCuFM/xKh+oITbBuDWwE8avo5FF9ZnN3vKmZUYocaqkR7An14o3OcBWqkhC8csHScFvRiAHUV2dsJKI75koiomLG8rshp3bsR69gJmYNPclGxlwdEVCkciooaV4oghJSoikUsHUOHgyvXEVFZieoantue3MdpmDcenbS0bphLaKgT1gJURERUeRh0KmLSNBB9+yUYZuoGuERENLmpNfVJ21x6HKrFuTVcYaV1RFTepJT42453EI7Hx92nNhJM65jN6GVvJyIiSolBpyIW37kJxqAfusWeI0RElOzg1plJ26xmOQFACNV2DoeIqKDe7d2L7f3dE+7jC6cXdHKLOHwivfcQEVFlYNCpSJlaDNHN/wYwtLIIERFlpqXah5aaxCW9q2JhS++VEhiUDDoRUXkIRMP4+67NE+8kJWojqZuLT4Qr2RERUSoMOhWp2JaNkNpQ2rOeg6CTlIDJXz8RVYjDps5J+NpqplMcLmhcc4OIyoApTWzY/hZ0Y+LSYpeuWe7nNJqH2U5ERJQCow5FyAwHEduxv7ljLjKdTChsI05EFWNWXROaq2tHvvZoMUvvG2RpHRGViVfat6F7cPKG39649fLjsZrRm/F7iYioPDHoVIQim/4FjAo0mchN0ImIqFIIIbBkyuyhL6SEWxu/ge5og7Imh6MiIsqPnf4evLZ3h6V90+l5N5ZHxFCNzN9PRETlh5GHIqP7u6Ht3ZawzTTtz0kyuPw3EVWY2fXNcKgqVNOAYmHlOl2qCKEqDyMjIsqdYCyCZ7e/NfmO+2ST6QQATaIvq/cTEVF5YdCpiEgpEX3n5aTtZg5WrzP4qyeiCuNQVMypb7Gc5RREDcuQiaik6aaBP299A3Hdeo8mbyya1TlrMAgXtKyOQURE5YORhyKid+2C3teRtN2Q9t/2mMx0IqIKVOPywK1b6+cUkL7JdyIiKlJSSvxtxyb0htNo7i0lPFp2QSchgEbRn9UxiIiofDDoVCSklIi++0rK7TIHQSdmOhFRJdJNw1Kmky4VltYRUUn7V/t72NKb/DBzIk5Dg2LDAjb1GICag56kRERUehh5KBJ65w4YweSnQkYOSusA9nQiosoU1TVUR0OT7heAj6V1RFSy3u7abblx+GhWy48nowoT9WLAlmMREVFpY9CpCEgpEd3yWl7PGYcrr+cjIio0fySErX0dqI6GJ913gKV1RFSidvi78cKudzN6r1uzVn5sRT0YdCIiIgadioLetQtGIPVKH2YOSusAIC4ZdCKiyvLSnq1QdH3Sm6q4dCIMb55GRURkn73Bfjzz3pvINFXTY2PQyY0YPLAnc4qIiEoXg04FJqVEdPO/J3w9F+Jw5uS4RETFRkqJf+15Dzv9PaixUFo3AGY5EVHp2Rvsx5ObX4ORRU8mOzOdhADqWGJHRFTxGHQqsImynIDcBJ2kBDQGnYioAhimiQ3b3sKre7cDwKSldVKytI6ISk9H0I8nt2yEnmUTcLt6Og2rQwDC1iMSEVGpcRR6AJVsqJfTqxPvk4PzxuFig1wiKnvheAx/ee8NdA7uf9JeFw5M+J4o3Iix5x0RlZCOoB9PbHkNumFkfSw7M50AwCl0VMswBrkaKBFRxWLQqYCMvg4YA70T7pOLnk4srSOicqabBt7s3IVXO3Yk3IQ59ThqIoMTvncAdbkeHhGRbToH7Qs4KaYJp67ZMKpEdWIAg5JBJyKiSsWgUwHFdrwz6T4yBzlJXLmOiMqRlBI7B3rwj12bEYxFk15vDPoneT8QkLU5Gh0Rkb3szHACAJfNWU7DajB5Lz0iIipfDDoViBkNQevcUZBzx+AuyHmJiHJBSomOQT9e3bsd7YH+cfdrHBz/NQAIoQoaPxaJqATsDfYP9XCyKeAE2N/PaZhDGPDIGKK8/iQiqki8ui6Q+M53hx6rTyYH5XVhyaXAiaj0SSmxa6AXr3VsR9fgxL2aXNrkpXUBrlpHRCVgeJW6bJuGj+XRc5PpBAA1IoSoZNCJiKgSMehUANI0EN/1rrV9bT63LlU2ySWikmZKE9v6u/Fax3b0h62VbTRMkuUkJRBkaR0RFbmOoD8nASfA/ibio1UjhB405uz4RERUvBh0KgCtcyfM2MTLdudKBMxyIqLSFDd0vNvTjje7dmMwRc+miTQH+iZ8PYwq6FCyGR4RUU4NRMN4euvGnAScgNyV1wFAFSJQIGFC5OwcRERUnBh0KoC4hQbiw+yurgsz6EREJSYYi+Ctrt3Y1NMOLYP+Jd5YGFWTBPoDqMl0eEREORfV4nhyy2uI6XrOzpHLTCdFSHhlBCFwFTsiokrDoFOemeEg9L6ONN5hb9SJ/ZyIqFT0hILY2LED2/1dWQXgJ8tyYmkdERUz3TTw1NbXEYhGcncSKXMadAKAKhFBSDLoRERUaRh0yjOtI70V6+wMOZlSsLyOiIpeR9CP1zq2Y/fAxMEiS6REU3Di48Tg5qp1RFS0XtixCV2DAzk9h2oaUHJUtjfMjdwGtYiIqDjxKjvPtM70gk52isBje2NyIiI7SCmxO9CH1zq2ozNo381VXTgAp65NuA/LPYioWHWHAtjcm06GfGZy2c9p5BzI/TmIiKj4MOiUR2Y0DL2/q2DnD6G6YOcmIhpPf2QQL+x8Fx1Bv+3Hbhic/JgMOhFRMZJS4qU9W/NyLpee+4CQC3EI2L8yMxERFTcGnfKokFlOAHuWEFFx0QwD/967DW907oK0e9WEfXyR4ISvSwmE2WOEiIpQe7AfewP9eTlXPoJOipBwSg1xOHN+LiIiKh4MOuVRuv2c7BSTTkThKtj5iYhG2xPow1+3v41QPHc9Ppx6HO5Jjh+FBwaUnI2BiChTr7S/l7dz5aO8DgDcIoa4ZNCJiKiSMOiUJ2Y8muaqdcPsefofBLOciKg47B7oxVNbN8I0c1tk4QtPnOUEDPW6IyIqRv5oOG/nchp6Xs7jYl8nIqKKw6BTnug97chkzW+7bskqtbRudMmO1PJzQZVw/jHnjBn572RQiHMSjWdvsB9Pb3095wEnYPLSOgCIMwN0BOfLfecd9XfTyEPJUSqmMXHzeyp/UkpoeQoEAYAjT3/nVOR2hbx84Xy577yj5stclckTUelj0ClPDH+GDcRtmL816UC4Qp/mx+P7bxhCP3m6gCMZ8umNXC6YKpeUEn/e+gaMHC/LPawmEpp0n5h052EkpYHzZbKNz/6g0EOgCqWbZibPKjOWr0wnFUZezpNrnC+TmaYO8EEOEaXARhZ5kumqddKGqFMQNVkfg4goWzFdQ0zPXwaH08KT+xgvkImoCOlmfoMzjjwFnZQyyXQiIiLrmOmUB1LXYAT6Cnb+Si2tAwCXa/8NZfWlp0A48/tXXmp6whOw7xzqhlsVeR1DzJBF8QSMKBiP5u9kUkKd5KbNkAo0fgyO4Hw5JKqb+O/Xh7IYvve978Hj2Z8pbJoS7V2DcDgUTG2uHtluGCbauwah6SZUVcG37loHv98Pn68Od99zN1RFQUdPCLpuYlprNVRl6JlfXDPw77e7ENMMHH7QFNRUJTdYdruZjVeJvE4Xpvka8rZ6Xf4yncoj6MT5ckhAM3H9G0PzpaLw85SIUuPskAfGQE9G/ZyA7KvrNOlACJW7HLgQ+z+AhdOR94uCsdyqgKcAFwVExaCpqgbN1bXoCU3eaylbijQnnUB1fgQm4Hw5bH8SuMfjSQg6AcD8Od6U71pwwP7PWmVfUMnhUFFdNbR9zszkMnePB1i54oCsR0zlaenUtrwEnYQ0IfJU9lwumU6cL4fEjFE/B8HrWyJKjeV1eZBpaR2AjINVw/yos60ZORFRNhSh4IQ5B0FRcn9hOlmWEwAY/AgkoiI2vbYBLdW+nJ9HyVPACQCUMunpRERE1vGKOw+MLIJO2SzwJCXgl3WZH4CIyGYN3hocO/vAnAeeVAs3USbUnI6BiCgbQggcNm1Ozs9jJUhvH2bDEBFVGgad8kAP9Gb8XplFGnIYXsSR3B+CiKiQFjZPw1mLlsHnSV2mZAsLWaLMdCKiYje7vhnLZszN6TmsBOntYnLeJSKqOJz5c0xqcchYJOP3Z5Pp5Ed95m8mIsqhlmofzjnoCMxtbM3J8TXH5AF33vwQUSk4bNqcnGY8KXnMdDKZ6UREVHF4xZ1jRmggq/fLDHs6GVJBoIJXrSOi4udSHVh1wGKcOv9Q1HnsXfDAUFRgkqamgh3viKhEHD79ACyZOjsnx1Zl/jKdJG89iIgqDpfuyTEzHMju/RleCATg49MkIip6QgjMrm/GDF8jNvW045X29xDTbVi6WwhoqgNOXRt3l3JZRYmIyp8QAkfMmAdTSrzZucveY2eTVp8mXpsSEVUePm7IMTOUXdAp08uAfjYQJ6ISoioKDm6diQsOORpLps6GqmT/8aSrEz9XYdCJiEqJEAJHzpyPY9sW2TJHDlPymOnEsmYiosrDmT/Hsgk6SWSW6RSRHkTgyfi8RESF4nY4sWLmfHzokKNxUMsMiElK5CaiTRp0YnkdEZUWIQQObJmB/zjQvsUY8hl0MrhqKBFRxWHQKceMLIJOpmlaWYApST8biBNRiatyuXFM2yKcf8hRmN80NaNVtifPdMrnMuFERPZpqqrFOQcdgQMasl+MIZ9BJ66qTERUeRh0yjEzHMz4vUYGFwGGVDAgfRmfk4iomPjcXqw84GCcd/AKzPA1pvXeyYJOLozf74mIqNi5VAdOnLsYR89eCEXJPCtUyWNPJ00y6EREVGkYdMohaRiQWizj9+sZLGHrRx2bNBJR2Wnw1mD1gqU4df6hlktKDGXiMg5FSDhhQ9NyIqICEULg4NaZOOfAI9BUVZPRMRSZv6xPjZlOREQVh0GnHJKxSFbvN8z0Mp2kBPplQ1bnJCIqVsMr3Z138JFYMXM+HOrEQaXJMp0AwI24XcMjIiqYxqoa/MeBy/G+6Qek3QtPTfN6M1NSMuhERFSJGHTKITMWzur96ZbXhVCFGD/MiajMqYqCJVNn4+wDl6POUzXuflaCTi7BoBMRlQdVUXD49ANw9oHL0VBVbfl9Sp6CTjocXL6BiKgCMeiUQ9lmOulGeunOfWCWExFVjgZvNc45aPm4jXRNC0/73ci8BJqIqBg1V9finAOPwNJpbbCS9KTmqbwuDldezkNERMWFQaccyjbTSUujp5MmHRiUmdXyExGVKue+RrpLps5Oes1hTN6vqQrZzdNERMVIVRQsnzEP/zFJRiiQv0ynKNx5OQ8RERUXBp1yKJtMJ1Oa0NLIdOpHPVOWiagiCSGwbPrcpCa6DgtzqBtxOJC/5cKJiPKppdqHDxx0BA5unTnuPk4LAXo7ROHJy3mIiKi4MOiUQ2YWQad0Ak5SAn5Zl/G5iIhKnaooOGHOwQnLhlvJdBICqBLMdiKi8uVQVRw9eyFWL1iKKldytpGar6CTZKYTEVElYtAph2Q8mvF742lcAAyiBhomb5hLRFTOGqtqUO/Z3zzX6tN7ltgRUSWYWdeE8w5egbmNUxK2O9Jo55ApUwrEWF5HRFSRGHTKoXwFnfpRn/F5iIjKiSLSy3QCgBqEcjUcIqKi4nY4ceLcxTh+zkFQlaHbgHyU18XgYhsIIqIKxaBTDmVTXmc16DTUQNz6srhEROVKSgl9uCGulPDGrc3BbhGHG/EcjoyIqLgsbJ6GMxcdjhqHAyIPjcTZz4mIqHIx6JRDUstsKW7dNCz3dGIDcSKiIbsGeuGPDGUtufQ4nLpm+b0+EczVsIiIilJLtQ9nHXAIPE5nzs8VgTfn5yAiouLEoFOOSNOA1DJ7ch61eKPEBuJERENMaeKlPVtGvq6NDKb1fh8YdCKiyuM2dbRU++Bz5zYoFJYMOhERVSoGnXJExjPLcgKAiMVgVQjVbCBORBVPSomXdm+FP7K/IXhNNL0+TW7E4IL1zCgionIgYxEICNR7q9FYVZOTc+hSQQyunBybiIiKH4NOOZJpE3EpJWIWM50GUJvROYiIysnGjh14o3NXwraaNDOdhADqxYCdwyIiKnpmbFSw3uVBo9f+PqEsrSMiqmwMOuXI6A/xdMR0DaacvEuTlEBQMuhERJXtra7deHnPewnbVENHlcUm4qPVYwBi8t2IiMqGHLPoTY3biwabA09hBp2IiCoag045MvZD3KqIbr20zuCvj4gq2OsdO/HizneTttdGBpHJCgtOoaNGpJchRURUyswUmfm1NgeeIrLKtmMREVHpYdQiR8xo+plOUkqELfZzYmkdEVUqKSX+tec9/HP3lpSv+yKZNwVvgD/j9xIRlZrxHpLWur2odXuyPr4pBSLI/jhERFS6GHTKEZlBaUdU12CY5uTHZmkdEVWwl/Zsxat7t4/7ui+cedCpBiE4oWf8fiKiUjJRZn69pxpOVc3q+BF4YLJwmYioojHolCNmNP2g06DFQNUgS+uIqEK93rETr3fsHPd1h67Bm2F5MzDUULxJ9GX8fiKiUpKqvG6YEAKN3hpkEzMKg6V1RESVjpGLHJFpNhLXTQMRi6vWBVhaR0QVaHPv3nFL6ob50ly1LpV6DEDF5FmnRESlbrIepG6HEz5X5o3Aw+znRERU8Rh0ypF0ezqF4jFLjW+lBAZlTYajIiIqTeF4DH/bsWnS/apioazPpQoTjaI/6+MQERUzaRqQxuTlxHWeKqhK+rcMUnLlOiIiYtApJ6Rpwoxav/GRAEITpDePpsEBHdnV1xMRlZpXO7Zb6nnnjcdsOV8j+qFksgQeEVGJkBYz7IUQqHK60j4++zkREREAOAo9gHIko+GhxzsWRbU4dAs3UwAQ4RMjypJpWLvILJfzUumL6Ro29bRb2tdjMYA/GYcwUI8B9Ml6W45H5cM0JTp7Q/C4HWjwpV6VyzSHrgGklBgIRrFtzwDaptWhoW7//u/t8iMa13HgAY1QMsgiIcqW1aATAFS7PAjG0ptf2c+psvD6kojGw6BTDphpLtc9kEYpHoNOlK3XNny/0EMgSosp5chN/ESENOHR7Ml0AoBm9MKPOj6ppwTt3YPYuTcAAYH3HdQKjzvxUso0JXRj6EGSYUi88Go7AqE49nQO4syV8wAAnb0hvPRmx9AbhMDBc5vy+j0QAQD0uOVdXaoDTlWFZhiW38OgU2Xh9SURjYeP1nLATGO57ogWR9xCPf2wsGTQiYgqiyKsBX3cWjytLNPJOIWOBuG37XhUHlyOoRJ3VRVQleS/mwl/XQXgdg0FpVyu/aXxbqcKVQgIAF4XS+apMKSWXoaI12G9xE5KXrMSEdEQZjrlgJnG6kmBNJb2NqVAFKlT+Yms+H//7//B7XYnbNN1A9G4CSEAp0OBy7n/BmhgMAZdN9FY58FnP/tZ9Pf3o6GhAXfffffIPtGYAQkJ776n/YZhIhzVUe11QklxQwYgaQxEE3GpDjRX16InNHFA321TP6fRmtGLftQz24lGtDZVocrrgNOhwulMDhgJIeB0DD3TUxWBE5bNQGdvGC2N+7M+6n0enHpMG+KambCdKJ+kaf2hJ4C0ykBjcMPgs+2y5xr1K051janpBiJRA0IAVR4HVFVJeC0WN1FT5cT111+f8hpzmGlKhCJa0jHG4vUlUXFi0CkHrGY6xXQNsTTq6aPwsK0tZcXtdsPjSQ5cjrce4uh9xb7H90KIhO0pDofq6qyGSZRACIFjZy/C7955ecJVPlVprTdeOhzCQBP60C1Z/kT71VRNnPExer50OFTMmFKbtE9dLR8iUYGlmRlqNesU4Kp1lUKM+juR6hrTA6B2nItMD4DhmXG8a8zRqqr4d4qoVPERRA5YDToNxKz3cgKGVgEhIqpEzdU+HNI6a8J9RA6CTgDQhD44kJtjExEVjMVFbIalF3RiBh8REQ1h0MlmUkoYoYFJ94vpGqJp1tJrcGY6LCKikrdi5nwsndY27uu5KoBThYlm0ZOjoxMRFYZMM9NJpDHLsp8TERENY9DJZjIehdQmXw3En8aKdcNYG09ElUwIgeUz5uG4tgOR6oF7rjKdAKAR/XDD+kpPRERFL8050+rCN5p0QGMHDyIi2odRDJuZg5NnOUW0eFq9nIYZ4Ao3RESLWqbj9AXvQ7UrsWGosHHlurGEAKaIrpwdn4go79KcM2OGtWtXLnpDRESjMehkM2PQP+HrEhL+aCizY0sGnYiIAGC6rwEfXHwkDmqZkbdz1iCEGqSfpUpEVOokgLhuLdOJPUiJiGg0Bp1sZk7SzykUj0EzjIyOzUwnIqL9nKoDx7QtwhmL3gefx4vcdXUaMpztlNuzEBEVH83QYVrMjIqwnxMREY3CoJPNJsp0klJiIINeTiPHZtCJiCjJtNoGnHvwCsxtmpKwfHMueEQMjaI/p+cgIio2AYvXr1Iy04mIiBIx6GSziTKdgrEIjDSXpx0mJYNORETjcSgqFjRPx7TaeniduV3pswU9cCCzjFUiolITN3SELSySAwBxOLnwDRERJeCngo2krsGMpO7XZJgmArFI5seGQO5a5BIRlQEh4FBUtFTXobm6FqqSm484VZhsKk5EZcDalaXVLCcAiME9+U5ERFRRGHSy0USldYFY2HItfCqKkFCRu+XAiYhK3/7SuiqnG9Nq61Hjzk2ZRx0CqELmDxKIiArOwnVpXNcsZzkBDDoREVEyBp1sZI4TdNIMA4PxaNbHd8DaqiFERJVIarGErxWhoNFbg9aaOjhsznoSApgmOtlUnIhKlpyk5YMpTfSEg2kdMw5XNkMiIqIyxKCTjYzB1P2c/NGQlYdJk2LQiYhofOY4JcwehxPTahtQ5bT3ZmioqXifrcckIsobc+LedH3hQehp9iKNSQadiIgoEYNONjIHk1c0iuoaImmkJU/EIRh0IiIaj5ygb54QAs3VPtR5qmw9Zyt64OQDASIqRRMElIKxSFpldcBQtR7L64iIaCwGnWyUKtPJP05j8UzwxoaIaHxmfPIeS3WeKjRX10LYVBenCImpotOegxER5ZEcJ9MppmvwR9O/ftXhgMmiYyIiGoNBJ5tIQ4c5pu49rMUQN+wLFLG8johofDJmrXdeldONOne1beetxSBqhX0PGIiI8kGmyGSKGzq6Q4GM2kLE4bRhVEREVG4YdLKJOSajSQIYSGOJWSsYdCIiSk1KCTNiveGtz+OFx2nPDZIQwFR0QLG4/DgRUTGQY7JDNUNHd2gg49WWdTjsGBYREZUZBp1sMvZmJxKPQTMmbtCYLjfs6Q1FRFRuzEF/yqf2E2n01th2fpfQ0SJ6bDseEVGumaNWVtZNA12hAAwz8+A5g05ERJQKg042GV1aJyExELM3ywkA3IjBAXsDWURE5UDvS7+vkkNRoSr2fQw2oQ8exGw7HhFRLsl9QSfdNNA1OAAjzZXqxmLQiYiIUmHQySZmZHDkz+F43PYsJ2CohKOafUOIiJIY/q6M3udSVdvGIAQwjU3FiahEyFh0JOCkZxlwAhh0IiKi1Bh0sokZHgo6SUgEcpDlNKwGDDoREY2VSaYTgKxKSVKpEhE0CL+txyQisps0dMRCAXTaFHACAF0y6ERERMkYdLLJcE+nXGU5DWPQiYgokRkNJWSbWmWYpq0rjA5rRTdLoYmoqHX3tKMr5M+6pG40A/ZljhIRUflg0Mkmw6vXDcatLdmdKYcw2DOEiGiUTLOcIlpu5lKHMDFFdOfk2ERE2eoI+vH3d/5le6anhLD1eEREVB6YB2sXXYNmGIjpWs5PVSNCiEp3zs9DRFQKMgk6mdLEQCwy+Y4ZqsMA+lGHMLw5O0cuSS3/mVqFOCdRpdkb7MeTWzaiNWp/Kwh7Q1hERFQuGHSygTRNSNPIeZbTsBoMogeNeTkXEVGxM/rTDzr5I2Fby0rGEgKYhk68J+eU5I1Y6CdPFXoIRGSzvcF+PLn5NeimCW8OrlmZ6URERKmwvM4Ohg4pJcJafoJOVYjACfv7kBARlRozHoUR7E/rPREtnpeHBB4RQ6NIb2xERLkwOuAEAFU5WPSGQSciIkqFmU42kIaGiBa3vTZ+PEIAjehHp2zJy/mIiIqV0d+V1v66aaB338IP+dCCHgzAB70EGuy63W6sX78+q2Ncf/316O/vR0NDA+6+++603x+LxfCpT30qqzEQUaKxASeHrsGTp+x8IiIiBp1sIHUdg3nKchrWAD+60QyTT5WIqIKlk+UkpURPOAgzTw8IAEAVJqagG3vk1LydM1NCCHg8nqyPYdexiCh7/ZEQntqycSTgBAA10dyshMxMJyIiSoXldTbQtVheGoiPpgoTDcKf13MSERUdaT2AFIiFEdfzX5pchwFUgVkFRJRfUV3DU1teg2YkNumvjQzm5HwKctcnj4iISheDTjboDwXSue+xTSP6+UyJiMiCuK7ldLW6iQgBTBXpNzsnIsqUYZr4y9bXEYwlB7xzFXRSwRUoiYgoGYNONuiOxwpyXpfQUCtyc+FARFQarEX8+yKhgq7n7RVR1IuBwg2AiCrKi7vexd6gP2m7ahiozkETcQBQmelEREQpMOhkg84CPT0HgEb0FezcREQFZyGQFNM1xI3Cr/jZih4ohYx8EVFF2DXQi03d7Slf84UDaZUlp0MVzHQiIqJkDDplSUqJjmhoqH6iAKoQgZe9QoioUlmYeoNFskqTU+hoEnxQQES5Y0oT/9y9edzX60O5y7hkeR0REaXC1euy5I+GETMMaKoDzjw3EweGYl2t6MYOOSvv5y41Usv/xdDYc8ZMIN81PjEL2e69/gj2dA1iSlMVGnwebNnph0MVmDe7Hns6B+EPxkZW/NI0Ax09IcQ1A/5gDAfMqENttSvH3wVRao7mGcDmVyfcRzeK50aoGb3oRz10qIUeSlriho7f7diIqKHhrFmHoMFTnfB6VNfw+O63ENbjKd9vShMb2t/Fy927MM/XjHMPWApFTPzcqxDz5f7zjk9KiVgsBt0wsXWXHwLAvFn1UNX934+xb6UwXTcQjU4c9HS73SOr/hFla1N3O/yRccrnpGTQKQcq9fpy/3kntrd7EN39EcyaUouGuqFVTbt6Q3hjcy88HhWHLWod2TeuGfjXmx3w1bgxb1Y9FIVzI1E5YNApS6F9T9A11VmQoBMA1IgwfBhEQNYU5PylIvSTpwo9BHz6teLIuBhrT+cgBiNxxOMGTFPCHxwaZ1O9B7s7gwAAY1/QyZTAzvbAyPLLe7sHUVvdWJiBU8VzNLRCrW+B4e8u9FAsUYREK7rRLqcWeihp2R7sxY5gLwBgY187Vk5fkPB6e3gAWwPdI8GWsfpiYbzauxv9sRDe8ms4NjIXU6vqJjxnsc6XsVgMa9assbRvIDAw6b7r16+Hx+OxY2hU4WK6hn+1bxv39epoCI4clho7Ufgy5kLg9eXEdnUEoRsm9nQNjgSdtrUH0O0Pw6kq6GgOQe4r+TRNib3dIcQ0A1OaquCrcRdy6ERkEwadsmTumyR1hwMoTD9xAMAUdCGIGnYLoYy0NlUh1mFgSnMV6n0eeHvCcKgCdbUetDZWwR+MQd33tEkIYFprNaIxAwODMbQ0VhV49FTp3HMORvjVZ8d9XVEEiukBfD0G4BPBrI4hPfX2DMaimTUNaPHWIKrrWFQ/Jen1Kd5aTPX68Po4GTv1Li/m+VowqMUxu6YRzW4+JCGy23t9nYhN8AC0IYdZTgDgKuSFMBWtKU3V6O4Lo7Vp//XizNYa9PRHUOV2oLneO7JdCIGGOg/qatyo9joLMVwiygEGnbJkyKGnunG1sBOjS2hoQh96JDNORnO73Vi/fn1Wx7j++uvR39+PhoYG3H333Wm/X0qJeDwOl8uVcQlFtmMY5nanfmI0tbkaU5v3l8u876D9qc7zZzcAAO7fF3RyOVXMmurLeAxEdnNObYPiroI5zopMNS4PolphMlFTESL7VZ5Mkd9HDFUOFy5dePS4r1c73fjwghV40flT9CGU9LpDUXHOnKU4Z87SCc9TDHP22PGk2jbZGG+99VYEAgH4fD6sXbs27XMQZWJ3YIKecVKiMdif0/O7kbq8thwVw1xVTNeXwPhzWdt0H9qmJ143zphSixlTake+Hh6/26Xi2PfNyGocRFR8GHTK0nCm06C3Bs2B3oKOpRm98KOu5HqF5JIQIuuyheEPwmyO5fV6J98px2MgKldCUeFqW4Tou/9O+brX6YZDCY2UhFLxKpY5e7LjT3bcO+64w/bzEk3EME20TxBUqomG4NZym4mkwoAKE0YFrFNULHMVry+JqBSU/6dCjpn7Mp0CVbWT7Jl7qjAxRXQVehhERHnnmn0glDHNrYcJAE1VtYVaZJSIKOc6BwcmXDShKZj7lTOFqKxsJyIisoZBpywNZzrFHC7EnYVfwasOAXhRvM0EiYhyQXF5UH3EqRDjzMNuhxNNVbVDESgiojLTGxm/T5yQZs5L64a5BPs6ERFRIgadsuRQ9pWyCYGAt/DZTkIAU0Un76uIqOKotQ2oXnYyhJK6xLjK6Uajp5qBJyIqO9oEWU6+cDCnq9aN5mEzcSIiGoNBpyy1jCqrK4YSOwCoElE0ivw80SIiKiaOxqmoOuyEcV+vcXvRUuWDwlo7Iioj2gRBpdaBnryNowqRvJ2LiIhKA4NOWap1e+F2DK1cFyyCTKdhrehmXT0RVSTn1DnwLj5q3Ne9Thdaa+rgUPgRSETlQTNTZzo59TjqQwN5G4cH0axX5yQiovLCK+4sCSHQUj20DGjc6ULUVRwrPyhCYrrYyyoSIqpI7raD4J536Livu1QHptTUw+N05nFURES5Iff1GB2rZaAXGOe1XBAC8DLbiYiIRmHQyQat+4JOANBZ31LAkSSqElE0i95CD4OIqCA8Cw+HZ9HycV9XFQWt1XWo91RzZTsiKmnDWfcJpERLIH+ldcOqRTjv5yQiouLFoJMNWkYFnXp8TTDU1E1sC6EZvWzqSEQVSQgBz7wlQ83FVce4+/k8XrRWs9yOiEqXJ0XQqS4UgEvLf6uFKjDoRERE+/EK2wYt1T4oytBjclNR0VVXPNlOipCYwTI7IqpgzimzUXP0mVC81ePu43Y4MbWmHl6W2xFRCUqV6TRloKsAIwG8iEJB/kr6iIiouDHoZAO3w4n5jVNHvu6sb4EsoloNj4ihReQ/vZqIqFiovkbUHPMfcExQAq0oClqq61DnqQIj9URUSsZmOnniUdSFAgUZixBArRgsyLmJiKj4MOhkk0OmzB75s+Zwobe2sYCjSdaMXngRLfQwiIgKRnF7UX3k6XBNnzvhfnWeKrRW+6AU0cMDIqKJeB2uhK+n+AuT5TTMh2BBz09ERMWDQSebNHirMauuaeTrjobWAo4mmRDATNHOZWyJqKIJ1QHv0hPgWbRswv08Dhdaa+qgss8TEZUAr3N/0Ek1dDQHCruQTA0GWWJHREQAGHSy1ZKp+7OdIu4qDIxqMF4MXELDNNFZ6GEQERXUUIPxQ1G9/BQIp2vc/VyqA1Nq2GCciIrf6KBTc6AXilnYh4yKkKhhiR0REYFBJ1tNralHc3XtyNc7WmZBFtnNSp0IoF4MFHoYREQF52ydhZpjzoJaUz/uPg5FRWtNHUvtiKioORQVTlUFpETrQHH08fSBQSciImLQyVZCCBw6tW3k65jLg91N0ws4otSmoRNu5H8JXSKiYqNW16HmmLPgHNWXbyyHoqKxqiaPoyIiSp9TVVETHYQnXhw9PFliR0REAINOtptT34IZdfubiHfUtyLkqSrgiJIpQmKmaOfiTEREAITDiarDT4JnwfvG3afK6UaNy53HURERpcepONA6UNheTqOpwuQqdkRExKCT3YQQOKHtILgcjuEN2DalbaiTdxHxiBimiMKubEJEVCyEEPAsOAzVy06GGLP0+LAatzfPoyIiss4NicbB/kIPI0ED/IUeAhERFRiDTjlQ5XLj2NmLRr6OuKvQ3jC1gCNKrRH9fAJFRDSKc8ps1Bx9JhR3coaqS3UM9UwhIipCDQO9EAVuID5WFcJwQyv0MIiIqIAYdMqRuY1TMLexdeTr9sapiLo8BRxRMiGA6dgLJ/RCD4WIqGiotQ1DgacUK5C6VUcBRkRENLnaImkgPpoQQL3wF3oYRERUQAw65dDRsxehyjW0hK1UlKIss3MIEzPY34mIKIFSVYOao8+EWt+csJ0tcYmoGEnTgDccLPQwUqrHAK8ziYgqGINOOeRxOHFc20EjXw96a7CjZWYBR5RatYigRRTf0zEiokJSXB7UrDgdjpYZI9sYdCKiYmQM9EKRxVVaN8whDPhEcQbEiIgo9xh0yrFZdU04bNqcka+76lvRVd9SuAGNoxm9qEa40MMgIioqwuFE9bKT4ZoxDwAQ19mbhIiKj9HfBVFk2fSjNaC4GpwTEVH+MOiUB4dPPwALmqeNfL2zZSYCVbUFHFEyIYAZYi8cMAo9FCKioiIUFd5Dj4cxfS70ImvSS0QEAHp/J5QiDjpVIQIvooUeBhERFQCDTnkghMCxsxdhZl0jAEAKBVumzUXM5S7wyBI5hY4Zor3QwyAiKjpCCOxomYVeX1Ohh0JElMQY9EMRxXtZLwTQLHoLPQwiIiqA4v10KjOqouCkuUvQXD2U4WSoDrw7fT6MIlt+u0aE0Sz6Cj0MIqKiYpgm3ulpx7YpszGQYlU7IqJCEqoDqlLcl/W1GIQLLFEmIqo0xf3pVGacqorT5i+Fz+MFAERdHmyZOhfFtqRHK7pRhUihh0FEVDS29XchosVHMlVDnupCD4mIaIRwuqEWcaYTMJTt1MQHm0REFae4P53KkNfpwur5S+FxOgEAgWofdrTMKvCoEg31d2qHCvYuISICgLe6d4/82VRUvDtjPqIuTwFHRES0n3C64XY4UMRtnQAA9Rhg/1AiogpTNkGnl156CWeccQYaGhpQXV2NFStW4IEHHij0sFLyeaqwev5SuBwOAEMr2u1unjHJu/LLJXRME52FHgYRUcH1hoPoHgwkbNNVBzbNmA/N4SzQqIiI9hNOFxShwF3kc5IiJBoFV7IjIqokZRF02rBhA4477jj89a9/xfnnn49PfepT6OnpwYc//GHcfvvthR5eSs3VPpy58HB4nS4AwN7GqdjTNL3Ao0pUJwKoE4HJdyQiKmObelIvsBB3uvHu9PmQRV7SQkTlT/EOlfx6Ha4Cj2RyjehnNj0RUQUp+StlXdfx8Y9/HEIIPPfcc/jhD3+Iu+66C6+99hoWL16MtWvXYvPmzYUeZkqNVTU4c9HhqN63il170zS0N00r8KgSTUMnXNALPQwiooLZG/SP+1rYU4XtrcVVIk1Elcc1axGEog49zCzyEjtVmOztRERUQUo+6PSXv/wFW7duxSWXXIL3ve99I9tra2txyy23QNd13HfffQUc4cTqPFU4a9GykebiexqnYW/j1AKPaj9VmJgh2ov9+oWIKCdiugZ/JDThPj11zejxNeVpREREyRS3F662g+BQVNSWQL85ZjsREVUOR6EHkK0NGzYAAE477bSk14a3Pfvss/kcUtpq3B6cuehwPL75VfSHQ9i9r8xuWl9HgUc2pEpE0IxedMvyuqkypYmwpsFhSkQMDS5FBaSEJiU86v5/GlLKkf9Ho9GR7ZphwJAmIACP6oTD5UTcNFCVRmq7jIUhVScigX4gFgUcDkBRANMEIKBU1UKojpExmKaJcOduCF8ThBAwY2HI0ADgrYXqrYFLEUA8AuGtgVCt//OWUiIWi0388zJT/xzGcrvdEMXeyZTIorAWt7Tf9tbZqIqFURUr35U/pZSIRKOIGjqqxvSN0U0DhpQwTXNkX39oEE4hoCpq0rFUpwO6lPBa7D8jTWNorvPUIDrQA6k6oTjdEPvmW2nogGlAON3752zTHJpbVReEOjQGc9APqahQnC64XS4I1QFR5D1wiKxyzz0E8R1vo95TjYgWh24Wb1BHFSaa0Icu2VzooeSEaZrwh0NwKwpippk0ZwJIuLYLhUPQpYRbdcCUJqKGgSqHE5phwOV2waGoiJuGpTlTShPmQC+kHkdMOABpQkBAeGthRgaBUACivgkw9FHzpYFQxw7AlFDqmiENDXLQDygqEBoAqmrhbmiFokWh1DZa/jkYhonBUARuV/LnQKqfxXjXmLG4AVUFnE433K6Sv30lqjhCDv8rL1EXXHABfvnLX+Lll1/GsmXLkl5vaWmBEAJdXV0p3x+LxRJutgOBAGbNmoWBgQH4fL6cjTuVqK7hyc2voTsUAKTErJ49mNpfHM28pQS2yTZEkLunZ/U+B95/9hk5O/5Yf+/chr2BXvxi7T22HG/N7V9ERBg4uGEa5vlaJt1fdu6A3PoqIpEwPvHjR20Zww8vXQ3PQCfE7IMgVpwBkeJmL5VoNIo1a9bYMob169fD4yn+p6xEVkR1DT9/9a+W9nXHo1i86x2oRu5XZjJ9DTjsrI/n/Dyj2TlPfOSrX4CuCBzePAszqusn3FdKCfn3RyF3vYOoFPjE7/5tyxh+dPkZ8NQ1QixdBeGusuWYRIUWefslxLa9gYgWH7qeLGKGVLBZzoOR48ILVZH40CXn5PQcY73U/h6+8dmbbTnWh269Hi6XGwZMHNY0C7NqGibc33jlaeDlPyEajeITf7evafsPT2qDx9cAcchxUA4+xtJ7Xn27HV+/7bO2jeFT134Vhx44HXW1btuOWUwCgQDq6uoKch9KlEslHyoeGBgAANTV1aV83efzYffu3SlfA4A77rgDt956a07Gli6Pw4n3LzwML+x8FxEtDtPXiEinD54iuWiYYWrYG/Xm7Pg1tbk7dioDcXszEkJ6FIrTiYH4+FlAiW/wD/0/0GPfIKLhoQjhoB/QNWCSJ0tENDG36sCMukbA4uOZoMuNuu49uR0UAGdtfc7PkUtRPQ6Hy4WBeGTSoBNMAwj27Zvb7Ps8lPHo0DwZCwMMOlGZcM89BEawH7WQCAb6EbGYrVkICoDWuIaAntsHVaqa/24iARuvMTXTQDgeQa3LjYF4BLMwcdAJ/k5A1wG7H4BEw0BtPWR/6gf5qYQj9v79MyUQjmplG3QiKlcln+l02mmn4amnnsLmzZsxf/78pNfnzZuH3bt3j1s6VEyZTpRfPdFBtIf8aFQ96IoE0eytgWYYCGpRzPe1wLEvS+jWW29FIBCAz+fD2rVrAQCmlHgv2IO+aAg1Tjfm+1oRgo7eWAjzfC3W0p+1GLBnMwxPDWLv/hvwdwFVtfteNAFFgZh7GJRpc3Hrl25BoL8PvioPbj7vJIj5h0PUNcN891/A9teBKbMhDjsF7u7tEN27gLbFUNJobmylvO6WW9YiGAygoaF+5OeQCsvriMqTlBLtgT50hAOYU9uIasf+i/4dwV6E9Dj+7xvfRWQwhIa6elx49RWodXpSBpW6tDAG9Rjm+1rgslAKbHbvBra9BrN+GmKdOwEJKDPmAtPmQygK5N5tgBEHps/Hl2/7ytB8We3FLZ/4MERtE0TTdJjREPD2i5DxODC1DR63G4rLCzF9np0/JiIi+GNhbO3rhEd1IGbomFPbnFRid8u6tej396PG58N/3XAdQnoc830t8Mej6IoE0FbTiI5IAA6XC9UOFwa0CBb4WiedM01/N+TLf4IMBRCrmzoUuFcVoG0JsOmfQ9eb0xdAOFXc9pvnEPD3w+d14+aTDwVMHVhwOBDXgG2vApoGhAeA+la4Z8yDYhrA4uOg1KR+2J/0cwhG0dE9gKlN1fC4xx93qmvtYZGYjs7eEExTorrKi5lTa6EqJd+WOCVmOlG5KvmgU7bldWPxHzsRERERERHlE+9DqVyVfJh4wYIFAIDNmzcnvdbf34+enp6RfYiIiIiIiIiIKD9KPui0cuVKAMCTTz6Z9NrwtuF9iIiIiIiIiIgoP0o+6HTyySdj7ty5eOCBB/Dqq6+ObA8Gg7jtttvgcDhw2WWXFWx8RERERERERESVqORXr3M4HPjRj36E1atX4/jjj8fFF18Mn8+HX//619i2bRu+8pWvYOHChYUeJhERERERERFRRSn5oBMAnHjiiXj++eexdu1aPPLII4jH41i8eDFuu+02fPjDHy708IiIiIiIiIiIKk7Jr15nN64aQERERERERPnE+1AqVyXf04mIiIiIiIiIiIoPg05ERERERERERGQ7Bp2IiIiIiIiIiMh2DDoREREREREREZHtGHQiIiIiIiIiIiLbMehERERERERERES2Y9CJiIiIiIiIiIhsx6ATERERERERERHZjkEnIiIiIiIiIiKyHYNORERERERERERkOwadiIiIiIiIiIjIdgw6ERERERERERGR7Rh0IiIiIiIiIiIi2zHoREREREREREREtmPQiYiIiIiIiIiIbMegExERERERERER2Y5BJyIiIiIiIiIish2DTkREREREREREZDsGnYiIiIiIiIiIyHYMOhERERERERERke0YdCIiIiIiIiIiItsx6ERERERERERERLZj0ImIiIiIiIiIiGzHoBMREREREREREdmOQSciIiIiIiIiIrIdg05ERERERERERGQ7Bp2IiIiIiIiIiMh2DDoREREREREREZHtGHQiIiIiIiIiIiLbOQo9gGIjpQQABAKBAo+EiIiIiIiIKsHw/efw/ShRuWDQaYxgMAgAmDVrVoFHQkRERERERJUkGAyirq6u0MMgso2QDKUmME0T7e3tqK2thRCi0MMhAjD05GPWrFnYtWsXfD5foYdDRFS0OF8SEVnD+bK4SCkRDAYxffp0KAq74FD5YKbTGIqiYObMmYUeBlFKPp+PFwVERBZwviQisobzZfFghhOVI4ZQiYiIiIiIiIjIdgw6ERERERERERGR7Rh0IioBbrcba9euhdvtLvRQiIiKGudLIiJrOF8SUT6wkTgREREREREREdmOmU5ERERERERERGQ7Bp2IiIiIiIiIiMh2DDoREREREREREZHtGHQiypFVq1ZBCFHoYZBN7r//fgghcP/99xd6KERERERERCWBQacSt337dgghIITAjBkzYBhGyv1ef/31kf0OPPDAlPs88MADWLFiBaqrq9HQ0IAzzjgDL7/8ci6HT5SVyy67DEIIbN++PetjDf9buuyyy7I+FpHd7Jjrw+Ew7r77blxyySU48MADoSjKhP9+ent7ce+99+Lss8/G3Llz4Xa70dzcjPe///144okn0hr/hg0bcMkll+Cggw5CfX09qqqqsGjRIqxZswabNm2a8Psd/q+qqgrTp0/HySefjC996UvYunVrWmPIh+GHDRPNSan22bBhw8j3+elPfzrl+4YD31/72teyGuOcOXMwZ86crI5BVMxKfb58/vnncf3112PZsmVoamqCx+PBgQceiM9//vPw+/0Tfr+cL4dwviQqLgw6lQmHw4H29vZxP9h+/OMfw+FwjPv+22+/HR/+8IfR2dmJK6+8Eh/60Ifwt7/9Dcceeyw2bNiQo1ETlY5zzz0Xb7/9Ns4999xCD4UqWDZzfVdXFz772c/iwQcfRDQaRUNDw4Tn+sUvfoErrrgCr7zyCo477jhcd911eP/7349nn30Wp59+Ou666y7L43766afx/PPP45BDDsFll12GT3/601i4cCF++tOfYunSpXjmmWdSvm/evHlYu3Yt1q5di6uvvhrvf//70dXVhdtuuw2LFi3CTTfdhHJbhPfee+8tyhtEolJTqvPl+eefj29961uora3FRz/6UVx11VWoqqrC17/+dSxfvhxdXV0p38f5koiKlqSStm3bNglAnnDCCbKurk5+8IMfTNonFovJ5uZmefbZZ0sActGiRQmvv/vuu9LhcMiFCxdKv98/sv2NN96QVVVVct68eVLTtJx/L+Vm5cqVkv/EcuvSSy+VAOS2bduyPtbwv6VLL70062MR2c2OuT4YDMonn3xS9vb2SimlXL169YT/fv785z/LP/zhD9IwjITt77zzjqyrq5NOp1Pu2bPH0vgjkUjK7U8//bQEIJcvX57y+129enXK9z333HNyzpw5EoC8+eabLY0hH4bn/YnmpFT7PPPMMxKAnDdvngQgL7zwwqT33XfffRKAvOOOO7IaY1tbm2xra8vqGETFrNTny6997Wuyvb09YZtpmvJTn/qUBCCvuuqqlN8v58v9OF8SFRdmOpUJr9eLCy+8EI8++ih6enoSXvv973+Pnp4eXH755Snfe99990HXdXzxi19EXV3dyPbFixfjox/9KLZu3Yq//OUvlsYhhMCqVauwZ88eXHLJJWhubkZtbS3OPPNMvPfeewCATZs24dxzz0VjYyNqa2txwQUXpHxqs379epxzzjmYM2cOPB4PGhsbsXr16pRPxIdTbdetW4dXXnkFq1evRm1tLerq6nDuuecmpe5OVko1/H2M9q9//Quf/vSnccghh6Curg5erxdLlizB1772NWiaZunnM5Ff/epXWLlyJVpbW+HxeDBr1iycfvrp+O1vf5u078aNG3HRRRdh2rRpcLlcaGtrw3//93+jt7c35bF/8IMfYPHixSPHveGGGxCNRlN+n8OpzLFYDDfddBNmz54Nr9eLZcuW4emnnwYABINBfOYzn8GMGTPg8Xhw9NFHj1uK2dXVhWuvvRbz588fSTf/4Ac/iDfeeCNp3+E05lAohOuuuw4zZsyA2+3GoYceil/+8pdJ+/7kJz8BABxwwAEjqdajv5/f/OY3uPjiizF//nxUVVWhrq4Oxx9/PH71q18lHOv+++/HAQccAAD4yU9+kpCiPpzpN1FPpxdeeAFnnnkmGhsbR9Lg161bh3A4nLTv8Bi7u7uxZs0atLa2wuv14qijjmJWIU0qm7m+pqYGp556KhobGy2d66STTsKZZ54JRUm8VFi0aBEuvPBCaJqGF154wdKxPB5Pyu0nn3wyGhoasGXLFkvHGXb88cfjiSeegNvtxte//nXs2rVr0vek+zkB5P/f6ymnnIKVK1fikUcewb/+9S/L77Myzw5/7u3YsQM7duxImOfWrVtn+/dCVGilOl9+/vOfx7Rp0xK2CSFwyy23AACeffZZS8cZxvkyEedLovxj0KmMrFmzBvF4HD//+c8Ttq9fvx6tra0466yzUr5v+IPgtNNOS3pt9erVANL7gOvv78dxxx2Hbdu24dJLL8WqVavwxz/+EaeeeirefPNNHH300QgGg1izZg2WL1+OX/7yl/jwhz+cdJz/+q//QmdnJ0455RRce+21OOuss/Diiy/ilFNOwe9+97uU53755Zdx/PHHw+Fw4IorrsDy5cvx29/+Fqeccgqi0ajl7yGVH/7wh/jNb36DJUuW4IorrsDHPvYxSClx44034qKLLsrq2P/v//0/nH/++di8eTPOPfdcXHfddTjllFOwa9eupKDT73//e6xYsQKPPvooVq1ahWuuuQZLlizBd77zHRx99NHo7+9P2P9LX/oSrrzySvT39+OTn/wkLrjgAvziF7/Ahz70oQnHdOGFF+Lhhx/G2WefjUsuuQRvvvkmzjrrLLzyyis46aST8Mwzz+D888/Heeedh3/+859YvXo1AoFAwjG2bt2KZcuW4Vvf+hbmz5+P//7v/8YZZ5yBxx9/HEcddRT+8Y9/JJ1X0zScdtpp+NOf/oTzzjsP//mf/4mtW7fiQx/6EJ588smR/a655hosXboUAHD11VePpJSPDiTeeOONePPNN3Hcccfh6quvxgUXXIBNmzbh/PPPx7e//e2R/Q477DBcffXVAIClS5eOHGvt2rWT1vIPBws3bNiAD3zgA7jmmmtQU1ODW2+9FaeccgpisVjSe/x+P4499lhs3LgRH/7wh3Heeefh5ZdfxurVq1MG44hGy3Sut5PT6QSACcu2rXjxxRfR39+PQw45JO33Lly4EBdeeCHi8XjK4Px40v2cyPe/1zvvvBNSSnz+85+3tL/Veba+vh5r165FXV0d6urqEua5sQ8fiMpFOc2X2RyH8+UQzpdEBVLgTCvK0tiU2sWLF8tDDz105PXdu3dLVVXl9ddfL6WUKVOIm5ubZU1NTcrjv/HGGxKAvOCCCyyNB4AEIK+99tqE7VdeeaUEIOvr6+U3v/nNke2macozzjhDApCvvPJKwnvee++9pOO3t7fL6dOnywULFiRsH061BSAfeuihhNc+8pGPSADywQcfHNk2WSkVALly5cqEbdu3b5e6ridsM01TrlmzRgKQzz//fMJr6ZTXHX744dLlcsmurq6k13p6ehL+7PP55MyZM+WOHTsS9nvggQckAPnpT396ZNumTZukqqpy9uzZCccJBoNy8eLFKb/P4XEfe+yxcnBwcGT7Qw89NPI7vOCCCxJKLu+8804JQN5zzz0JxzrmmGOkw+GQTz75ZML2TZs2ydraWrlkyZKE7W1tbRKAPOecc2QsFhvZPlyCMzZ1fLLyuq1btyZtCwaDcsmSJbKurk6GQqGR7ZP9nRhO1b7vvvtGtgUCAVlfXy/dbrd87bXXRrabpikvueQSCUDedtttCccZ/nt61VVXJaTh/+hHP5IA5BVXXJHy/FTZ7Jjrx5qsXGQ8gUBATpkyRXo8noR5xYpnnnlGrl27Vn7hC1+QH/zgB6Xb7ZbNzc3ypZdeSthvsnKRYT/+8Y8lAPmRj3zE0rnT+ZyQMv1/r9mWiwwf77zzzpMA5BNPPDGyz3jlIpnMsywXoXJWLvPlWMPXWp/73OcStnO+5HxJVOyY6VRmLr/8cmzcuHEkzfT++++HYRhYs2bNuO8ZGBhIKKsbzefzjexjVU1NDW677baEbZdccgkAoKmpCZ/5zGdGtgshRrKEXnvttYT3DJc7jTZt2jR88IMfxObNm7Fjx46k10844QRceOGFCduGv/eXXnrJ8veQSltbG1RVTdgmhMB//dd/AcBI6VmmnE7nyFOs0Zqamkb+/NOf/hSBQAB33HEHZs+enbDfxRdfjMMPPxwPPfTQyLYHH3wQhmHg+uuvTzhOTU0Nbr755gnH89WvfhXV1dUjX59//vlwOp3w+/246667Ep60XXzxxQASf4f//ve/8cILL+DSSy/FqaeemnDshQsX4hOf+ARef/31lE++vvGNb8Dlco18ffLJJ6OtrS3t3+HcuXOTttXU1OCyyy7DwMBA1n8nfvvb38Lv92PNmjU49NBDR7YPr5jicDhSluNVV1fjzjvvTEjDv/TSS+FwOLIeE1WGTOZ6u1x55ZXo7OzETTfdlDCvWLFhwwbceuut+NrXvoZf/epXmDVrFh5//HEsX748o7FMnz4dAJJKZyaS7udEIf693n777XA4HPjCF74wYePfbOZZokpRqvPlaK+++ipuvfVWtLa24oYbbsjoGJwvOV8SFUp2eZ5UdD7ykY/gxhtvxPr167Fs2TLcf//9OPLII3HwwQfnbQwLFixICFYAGKlNP/TQQyGESPnanj17Era/9957uOOOO/CXv/wFe/bsSSpTam9vR1tbW8K2ww8/PGk8M2fOBICUy8ymIx6P4zvf+Q4eeughvPPOOxgcHEz4cGtvb8/42B/60IfwhS98AYcccgguuugirFq1Cscddxzq6+sT9vv73/8+8v9UPVCi0Sh6enrQ09OD5ubmkSDQMccck7Rvqm2jve9970v4WlVVtLa2IhQKJQW8Uv0Oh8fa0dGRsv79nXfeGfn/6NKa+vr6lAHHmTNn4sUXX5xwzGN1dXXha1/7Gv70pz9hx44diEQiCa9n8zsDhi5gAKRMtZ41axbmzZuHTZs2IRgMora2duS1BQsWoKamJmF/h8OBKVOmZP33lCpDoeb6m266CQ888ABOP/103HTTTWm/f926dVi3bh1CoRDeeustfPnLX8axxx6L9evXjzycSMdENxjjSfdzohD/XhctWoQ1a9bg3nvvxYMPPjjuzybTeZaokpTqfDls27ZtOOuss2AYBh566CE0NzdndBzOl5wviQqFQacy09raijPOOAMPPvggzj77bGzZsgWf/exnJ3xPXV3duJlMwz16xsuESmU4O2q04ayYiV4b3Yx7y5YtWLFiBQKBAE488UT8x3/8B3w+HxRFwYYNG/Dss8+m7JWTapzDxzcMw/L3q9fEbAAAEuxJREFUkMr555+PRx99dKQuvrW1dSTz51vf+lbK8Vh1ww03oKmpCd///vdxzz334O6774bD4cAZZ5yBb37zmyNBmL6+PgDAd7/73QmPFwqF0NzcPPL7a2lpSdpnypQpEx5jvN/VRD/j0b/D4bE+9thjeOyxxyYc62jj/V1zOBwwTXPCMY/W19eHI444Ajt37sSxxx6LU045BfX19VBVFa+++ip+97vfZfU7A/b/+xjvZzl16lRs2rQJgUAgIeg00feY7d9TqgyZzPXZuvXWW3HHHXfgpJNOwq9//eukzM90VFdX44gjjsBvfvMbLF++HJ/85Cdx6qmnppyrJrJ3714Aqee48aT7OZHOv9fhp/sTzVXDr41tODzWunXr8LOf/Qy33HILzj///JT7ZDrPElWSUp4vd+zYgRNPPBHd3d341a9+hRNPPDHjMXG+5HxJVCgsrytDa9asQX9/Pz72sY/B6/WOlD6NZ8GCBRgcHERHR0fSa5s3bx7ZJ5++8Y1voL+/Hz/5yU/w1FNP4Zvf/Ca+/OUvY926dTjwwAOzPv7wh5eu60mvpQrAvfTSS3j00UexevVqvPXWW/jhD3+Ir371q1i3bl3WTcSBoXKsj3/843j55ZfR3d2N3/zmNzjvvPPw+9//HmeeeebIB/VwIOj111+HlHLc/4YzwIb37+7uTjpnZ2dn1uOeyPC5v/3tb0841ksvvTQn5//xj3+MnTt34itf+Qqef/55fPvb38Ztt92GdevW4aijjrLlHMPf43g/y+HtqQJ4RNlKd67Pxq233op169Zh1apVePTRR+H1em05rsPhwIknnohQKDTuCpgTGV4I44gjjrBlPNkavuEabyVRYH9py2QPc6ZNm4ZrrrkG7733Hn7wgx+k3KfQ8yxRqSjF+XL79u1YtWoV2tvb8cgjj2Td9JzzJedLokJh0KkMnXHGGZg6dSr27NmDD37wg5Pe8K5cuRIAElYGG/bEE08k7JMvW7duBQCcffbZCdtN08Tf/va3rI8/XLY2tqQP2F8ylWo8Z555ZtLTqr/+9a9Zj2e0pqYmfOADH8DDDz+Mk046CW+//fZIKd2RRx4JAJbLzIZXd0u1TK/VpXszle5YMzH8u0j1tG28v0NA6t/ZRMcaz3AJYqqlgPfs2YOtW7di7ty5CVlORHZJd67P1HBJ3MqVK/HYY4+hqqrK1uMPl7mmuyLTu+++i0ceeQRutxvnnnuurWPK1JIlSwCMP+/19vZi8+bNmD17tqUM4s9//vNoamrCbbfdhmAwmPR6JvOsqqrMqKSKU2rz5XDAac+ePXj44YdxzjnnZDUuzpecL4kKiUGnMuRwOPD73/8ev/nNb/DVr3510v0vv/xyOBwOfPWrX03I8nnzzTfx05/+FPPmzcNJJ52UyyEnGc7Uef755xO233nnnbY0+PP5fFi4cCGef/75hN5IwWAQN954o+XxvPnmm7jjjjuyHs8TTzyRlHWladpIKvDwU7LLL78ctbW1+OIXv4g333wz6TjhcHikZh0ALrroIiiKgnvuuSfhSVIoFLL0dyMbK1aswJFHHokHH3wQDz/8cNLrpmni2WefzeocjY2NAIDdu3cnvTbe7+yBBx7AH//4x6T9GxoaIIRIeazxnHPOOairq8N9992X8PuQUuLGG2+Epmm47LLLLB+PKB3pzvWZWLt2LW699VYcf/zxWd1APffccyn7iTz55JP4zW9+g7q6ukn7zI32/PPPY/Xq1YjFYrjxxhsxY8aMjMZlt//8z/+Eoij4n//5n6S5xDRNfO5zn4Ou6/joRz9q6Xg+nw9f/OIX0d3djW9961tJr2cyzzY2NqKnpyflcudE5aqU5svRAaeHHnoo6yAR58shnC+JCoc9ncrUEUccYTl9duHChVi3bh1uvvlmHHrooTj//PMRCoXw4IMPQtM0/PCHP0z7CXS2rrzyStx3330477zzcOGFF6KpqQl///vf8corr+DMM8+csBbbquuuuw5XXnkljj76aFxwwQUwTRN/+tOfUq6itGLFCqxYsQKPPPII9u7di6OOOgo7d+4cKX/75S9/mdVYLrzwQlRVVeG4445DW1sbNE3DU089hbfeegsXXnjhSOPulpYWPPjgg7jggguwdOlSnH766TjwwAMRjUaxY8cOPPvsszjmmGPw+OOPAxhqrviFL3wBt99+O5YsWYILLrgADocDv/71r7FkyRK88cYbk9bJZ+PBBx/EiSeeiIsuugjf/OY3sWzZMng8HuzcuRMvvvgiuru7s/ogP+mkk3DXXXfhiiuuwAUXXIDq6mrMnj0bl1xyCT7ykY/gzjvvxH//93/jmWeeQVtbGzZu3Iinn34a5513Hn79618nHKumpgZHHHEEnnvuOVx++eVYsGABFEXBJZdcktQ4fZjP58MPf/hDXHzxxTjyyCNx4YUXoqWlBX/+85/x8ssvY8WKFfjc5z6X8fdHNJl05noA+OxnPztSrvD666+PbBtu/PqFL3xhpIT5/vvvx5e//GU4HA6sWLEC//M//5N0vFWrVqVspD/W2WefjebmZhxxxBGYNWsWIpEINm7ciOeeew5OpxM/+tGPkhagAIb6+w03fI3H4+jq6sI//vEPvPHGG1BVFTfffDO+9KUvWf7+c23hwoW46667cP311+Pggw/GOeecg7a2NgQCATz11FN45513cPTRR6fVVPiqq67Ct771rZHszbHSnWdPOukkvPzyy/iP//gPHH/88XC5XDjuuONw3HHHZf39ExWzUpkvV61ahR07duCoo47Cxo0bsXHjxqR9UjXC5nzJ+ZKoaEkqadu2bZMA5OrVqy3tD0AuWrQo5Ws/+9nP5PLly6XX65V1dXXy9NNPl//85z/TGg8AuXLlynHHeemllya99swzz0gAcu3atUnbjz32WFlbWyvr6+vlGWecIf/1r3/JtWvXSgDymWeemfQYk53729/+tpw/f750Op1y9uzZ8ktf+pKMx+Mpv4+uri65Zs0aOX36dOnxeOSSJUvkd7/7Xfnee++lPP7KlSul1X9i3/ve9+TZZ58t29rapMfjkU1NTfLII4+UP/jBD6SmaUn7v/POO/JjH/uYbGtrky6XSzY0NMglS5bIz3zmMyl/Z9/73vfkQQcdJF0ul5w5c6b87Gc/K3ft2iUByHPOOcfyuNva2mRbW1vK18b73ff19cmbb75ZHnLIIdLr9cqamhq5YMECeckll8hf//rXlo8/3ri+/vWvywULFkin05k0hldffVWedtppsqGhQdbW1sqVK1fKp59+Wt53330SgLzvvvsSjrVp0yZ5xhlnyPr6eimESPh7Nt57pJTyueeek+9///tlfX29dLlccuHChfKWW26Rg4ODln9Ok33/VNnsmuvb2tokgHH/Gz2vDs+1E/2Xas5N5Zvf/KY8/fTT5cyZM6Xb7ZYej0cuWLBAfvzjH5dvvPHGuN/v6P+8Xq+cNm2aPPHEE+Utt9wit2zZYuncwzL5nMj03+tf/vIX+YEPfEBOnTpVOhwO6fP55IoVK+Tdd98to9HouGO74oorUh7vpz/96cjP4Y477kh6PZ15NhgMyk984hNy2rRpUlGUtH6PRKWg1OfLyY4z9lqI82UizpdExUdImcH6mURU8p5++mmceuqpuOGGG3DnnXcWejhERERERERUZtjTiajMdXd3JzVB9Pv9I72rPvCBDxRgVERERERERFTu2NOJqMz9/Oc/x1133YWTTjoJ06dPx969e/H444+jq6sLl112GY4++uhCD5GIiIiIiIjKEINORGXumGOOwbJly/D000+jr68PqqrioIMOwi233IKrrrqq0MMjIiIiIiKiMsWeTkREREREREREZDv2dCIiIiIiIiIiItsx6ERERERERERERLZj0ImIiIiIiIiIiGzHoBMREREREREREdmOQSciIiKy1Zw5czBnzpyCnHvdunUQQmDDhg0FOT8RERER7cegExERUYnbvn07hBAQQmDGjBkwDCPlfq+//vrIfgceeGDG52Ngh4iIiIisYNCJiIioTDgcDrS3t+OJJ55I+fqPf/xjOByOPI+KiIiIiCoVg05ERERl4phjjkFdXR3Wr1+f9Fo8HsfPf/5znHHGGQUYGRERERFVIgadiIiIyoTX68WFF16IRx99FD09PQmv/f73v0dPTw8uv/zylO+VUmL9+vU49thj4fP5UFVVheXLlycFsFatWoVbb70VAHDiiSeOlOul6uEUCoVw3XXXYcaMGXC73Tj00EPxy1/+MuX5e3t7ce211+KAAw6A2+1Ga2srLrzwQrz11lsp99+1axcuvvhiNDY2oqamBitXrsRzzz032Y+IiIiIiPKIOfZERERlZM2aNbj33nvx85//HFdfffXI9vXr16O1tRVnnXVW0nuklPjP//xPPPDAA1i4cCEuueQSuFwuPPXUU/jYxz6Gt956C3fddRcA4LLLLgMAPPvss7j00ktHgk319fUJx9Q0Daeddhr6+vpw3nnnIRwO46GHHsKHPvQhPP744zjttNNG9u3t7cVRRx2FLVu2YNWqVbjooouwfft2/PKXv8Rjjz2Gp556CkcfffTI/nv37sXRRx+NPXv2YPXq1Tj88MPx9ttv49RTT8WJJ55o00+SiIiIiLLFoBMREVEZOfLII7F48WKsX79+JOi0Z88ePPnkk7jmmmtS9nT60Y9+hAceeAAf+9jH8P3vf39kn3g8jvPPPx933303Lr74YixbtgyXXXYZtm/fjmeffRaXXXYZVq1alXIc7e3tOOKII/DMM8/A5XIBAC655BKccsopuOeeexKCTjfccAO2bNmCG2+8EbfffvvI9ssuuwynn346Lr30UrzzzjtQlKEE7RtvvBF79uzBV77yFXzxi18c2f/ee+/FFVdckd0PkIiIiIhsw/I6IiKiMnP55Zdj48aN+Ne//gUAuP/++2EYBtasWZNy/+985zuorq7Gd77znYSglMvlwle/+lUAwIMPPpj2OL7xjW+MBJwA4OSTT0ZbWxteeumlkW3xeBwPPvggmpqacPPNNye8f/Xq1Vi9ejU2b96MF154YWT/hx9+GK2trbj++usT9v/4xz+OhQsXpj1OIiIiIsoNZjoRERGVmY985CO48cYbsX79eixbtgz3338/jjzySBx88MFJ+4bDYbz++uuYPn06vva1ryW9rmkaAOCdd95Jawz19fU44IADkrbPnDkTL7744sjX77zzDiKRCFatWoWqqqqk/VetWoUnnngCr776Ko477jhs2rQJ0WgUJ510EjweT8K+iqLgmGOOwbvvvpvWWImIiIgoNxh0IiIiKjOtra0444wz8OCDD+Lss8/Gli1b8NnPfjblvv39/ZBSYs+ePSMNwlMJhUJpjaGuri7ldofDAdM0R74OBAIAgClTpqTcf+rUqQCAgYGBhP+3tram3H+84xARERFR/rG8joiIqAytWbMG/f39+NjHPgav14uLL7445X4+nw8AsGzZMkgpx/3v/7dz/y5Z7XEcwN9PhjwIIgiCNTkIWi05iIgtgjS4OASFf4BIi3vYKKTgD9wFbQkEIYgo8FFCKPFBd10khxqUhCZpMZv04r3dH9i5ePG+Xts53zfnfOb3+Z7vu3fv/pU5T9+/v7//0/XT+6e50zLr4ODgL/MAAFw+pRMAXEH9/f1pbm7O58+f8+DBg7PS5vfq6+tz69atbG9v5+vXr//o2TU1NUmS4+PjX56zvb095XI5m5ubOTo6+sP62tpakuTu3btJkra2tpTL5WxtbeXbt2/nst+/fz87+wkAgMundAKAK+j69et59epVXr58eXYY+J8ZGRnJ0dFRhoaGfvob3cePH7O3t3d23djYmCT59OnTL89ZW1ubwcHBfPnyJc+ePTu3trKykrdv36a1tTU9PT1n+YcPH+bg4CBTU1Pn8nNzc85zAgD4D3GmEwBcUZ2dnens7Pzb3PDwcDY2NvL8+fN8+PAhfX19uXnzZvb397Ozs5NqtZoXL16kpaUlSdLb25tSqZTR0dHs7OykoaEhDQ0Nefz48YXmnJiYyNraWsbGxrK+vp6urq7s7e1laWkpdXV1mZ+fz7Vrv30nGx8fz+rqap4+fZr379+no6Mj29vbefPmTe7fv5/l5eULzQEAQLHsdAKA/7lSqZSFhYUsLi7mzp07ef36daanp1OpVFIulzM5OZm+vr6z/O3btzM/P5/GxsbMzMzkyZMnmZiYuPD7m5qaUq1WMzIykt3d3UxOTqZSqWRgYCDVajX37t07l79x40bW19fz6NGjbGxsZHZ2NoeHh6lUKunu7r7wHAAAFKt0cnJyctlDAAAAAHC12OkEAAAAQOGUTgAAAAAUTukEAAAAQOGUTgAAAAAUTukEAAAAQOGUTgAAAAAUTukEAAAAQOGUTgAAAAAUTukEAAAAQOGUTgAAAAAUTukEAAAAQOGUTgAAAAAUTukEAAAAQOF+ALGGt3k88GVIAAAAAElFTkSuQmCC", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABJ0AAAOYCAYAAAB/2oJ6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeXxU9dn///eZJZMQCAECCQFZZHFDtMUFlU2rteW+Bay3Wi3K4v6t1tu9uILWtVVrbe3trxqW2tq6VAHrVhVcEJdSWdwF2UwMCGQh22Rmzuf3R0hgyCSZTE5yJpPX8/GgZc6cmVxAPDnnPdfnOpYxxggAAAAAAABwkMftAgAAAAAAAJB6CJ0AAAAAAADgOEInAAAAAAAAOI7QCQAAAAAAAI4jdAIAAAAAAIDjCJ0AAAAAAADgOEInAAAAAAAAOI7QCQAAAAAAAI7zuV1AsrFtW0VFRerRo4csy3K7HAAAAABAijPGaPfu3crPz5fH03l7QyKRiEKhkNtloB15vV75/f649yd02k9RUZEOOOAAt8sAAAAAAHQxW7du1cCBA90uo9WMMSouLlZZWZmMMW6Xg3YWCASUk5OjrKysFvcldNpPjx49JNX9xx7PXyAAAAAAAG1RXl6uAw44oOF6tLMpKytTaWmp+vbtq8zMTFYNpShjjEKhkMrKylRYWChJLeYmhE77qf+PIysri9AJAAAAANBhOmNYY4zR9u3blZWVpZycHLfLQTvLyMhQjx499M0332jHjh0t5iadd7EoAAAAAABwVSQSUSQSoWmjC7EsSz179lQwGGxxhhehEwAAAAAASEg4HJYk+XwspOpK6oeJRyKRZvcjdAIAAAAAAG3SGZcGInHx/nsTOgEAAAAAAMBxhE4AAAAAAABwHKETAAAAAABIWjNnzpRlWdq0aZPbpaCVCJ0AAAAAAECH2rRpkyzLivqVlpamAw44QOeee67Wrl3rdomOqf+zzpw50+1SOhzj5QEAAAAAgCuGDRum6dOnS5IqKir03nvv6cknn9Q//vEPvfHGGzr++ONdrhBtQegEAAAAAABcMXz4cM2dOzdq280336w777xTN910k5YtW+ZOYXAEy+sAAAAAAEDSuOKKKyRJH374YaPnHnnkER1yyCFKT0/X4MGDNW/ePNm2HfN9Fi9erB/84Afq1auX0tPTNWrUKP3mN79RJBKJ2m/BggWyLEsLFizQ66+/rnHjxikzM1N9+vTRjBkztHPnzpjv/8ILL+jEE09Uz549lZGRoSOPPFK//e1vo95/wYIFGjp0qCRp4cKFUcsJly9frttuu02WZenpp5+O+TUeeeQRWZalBx98sGGbZVmaNGmStm7dqrPPPlt9+vRRZmamJk2apHfffTfm+9TW1uqBBx7Q97//fWVmZqpHjx4aP368lixZEnN/pxA6AQAAAACApGFZVszt1113nW677TaNHTtWl1xyiSRp7ty5uuWWWxrte+ONN2ratGn68ssvdcYZZ+j//b//p/T0dF133XX66U9/GvP9ly5dqsmTJysvL0+XXXaZhg0bpkWLFmnq1KmN9n3ooYd02mmnae3atTr33HP185//XNXV1brqqqt01llnyRgjSTryyCN15ZVXSpKOOOII3XbbbQ2/hgwZogsvvFBer1d/+tOfYtb02GOPKS0tTeeff37U9pKSEp1wwgnatGmTLr74Yp1xxhlauXKlTjzxRC1fvjxq32AwqFNPPVXXXHONJOmCCy7Q9OnTtXnzZk2dOlW///3vY35tRxhEKSsrM5JMWVmZ26UAAAAAALqAznwdWl1dbT799FNTXV3dqtdt3LjRSDKnnnpqo+duuukmI8lMmjTJGGPMjBkzjCQzdOhQU1RU1LDfd999Z7Kzs02PHj1MMBhs2P7qq68aSebHP/6xqaysbNhu27a59NJLjSTzzDPPNGyfP3++kWR8Pp955513GraHw2EzadIkI8msXLmyYfuGDRuMz+cz/fr1M1u2bGnYHgwGzcSJE40k8+c//7nRn3XGjBkx/y7+67/+y1iWZTZu3Bi1/aOPPjKSzNlnnx21XZKRZM477zxj23bD9uXLlxvLsszw4cNNJBJp2H7jjTcaSWbu3LlR+5eXl5ujjjrKpKWlmcLCwpi1NSXef3c6nQAAAAAAgCvWr1+vuXPnau7cubr22ms1btw43XnnnUpPT9ddd90Vte8tt9yi/v37NzzOycnR1KlTtXv3bn3xxRcN2+s7dx599FF169atYbtlWbrnnntkWZaefPLJRrWce+65OuGEExoee71ezZgxQ1L0Ur+//OUvCofDuuaaa3TAAQc0bE9LS9M999wjqW5ZXbwuueQSGWNUUFAQtb2+++miiy5q9Bqv16s777wzqits4sSJmjx5stavX9+wzM62bf3xj3/U8OHDdeutt0bt36NHD916662qra3VP/7xj7jrbQ0GiQMAAAAAAFds2LBB8+bNkyT5/X7l5ubq3HPP1S9/+UsdfvjhUft+//vfb/T6gQMHSpJKS0sbtr333nvKzMzU448/HvNrZmRk6PPPP2+0Pd73/+ijjyRJkyZNarT/2LFjlZGRodWrV8f82rFMnjxZAwcO1Pz58zV37lx5PB7V1NTor3/9qw488ECddNJJjV4zePDgqMCr3vjx4/XPf/5Tq1ev1rhx4/TFF1+opKRE+fn5DX/P+/ruu+8kKebfhxMInQAAAAAAgCtOPfVUvfzyy3Ht27Nnz0bbfL66WGPf4d27du1SOByOGbLUq6ysTPj9y8vLJUm5ubkx37tfv34qLCxs8mvvz+v16oILLtC8efP08ssva/LkyXrmmWdUWlqq6667LuaMq379+sV8r/qaysrKJNX9XUjSJ598ok8++aTJGmL9fTiB5XUAAAAAACBlZGVlqU+fPjLGNPlr48aNbXp/Sdq2bVvM57dv396wT7zqB4o/9thjkuoGiPt8Ps2cObPJrxFLfU31AVp9HWeccUazfx/z589vVb3xInQCAAAAAAAp49hjj9XOnTv11Vdftcv7f+9735OkRneJk6QPPvhA1dXVOvLIIxu2eb1eSdHdUvsbOHCgfvzjH+uFF17QihUr9NZbb2ny5MnKz8+Puf/mzZu1devWRtvffvttSWr4+occcoiysrL073//W6FQKJ4/nqMInQAAAAAAQMr4xS9+IUmaPXu2du7c2ej54uJiffbZZwm//7nnniufz6cHHnhARUVFDdtDoZB++ctfSlJUh1KvXr1kWZa++eabZt/3kksuUSgU0llnnSVjTMwB4vUikYhuuukm1d3Mrs6bb76pF198UcOHD9fxxx8vqW554GWXXabNmzfr2muvjRk8ffzxx012TrUVM50AAAAAAEDK+NGPfqRbbrlFd9xxh4YPH64f/ehHGjx4sHbu3Kn169fr7bff1q9+9SsdcsghCb3/sGHDdO+99+qaa67R6NGjddZZZykzM1MvvPCCPv/8c02dOlXTp09v2L979+46+uij9dZbb2nWrFkaMWKEPB6Pzj33XA0aNKhhv8mTJ+uAAw7Q1q1bNWDAAP34xz9usobRo0dr+fLlGjt2rE466SQVFRXpb3/7m/x+v/70pz/J49nbYzRv3jz95z//0e9+9zv985//1MSJE9W3b18VFhZq3bp1WrNmjVauXNnknKi2IHQCAAAAAAAp5fbbb9eECRP0u9/9Tq+//rpKS0vVp08fDR06VHPnztXPfvazNr3/1VdfreHDh+uBBx7QE088odraWo0cOVL333+/fvGLXzQa/v3nP/9ZV111lZ5//nmVlZXJGKOxY8dGhU4ej0fTp0/X3XffrVmzZjUsy4ulV69eWrp0qa699lo9+uijqqmp0dixY3XXXXfphBNOiNo3EAjopZde0uOPP65FixbpmWeeUTAYVG5urg499FBdeumlje4U6BTL7NuLBZWXl6tnz54qKytr9eAvAAAAAABaqzNfh9bU1Gjjxo0aOnSo0tPT3S6n05s8ebJefvllff311xoyZEjMfSzL0sSJE2POlOoo8f67M9MJAAAAAADAZZ988olefvll/ehHP2oycOpsWF4HAAAAAADgkr/+9a/64osvtGjRIknSLbfc4nJFziF0AgAAAAAAcMn/9//9f3r77bc1ePBgPf744zruuOPcLskxhE4AAAAAAAAuae1sps40mpuZTgAAAAAAAHAcoRMAAAAAAAAcR+gEAAAAAAAAxxE6AQAAAAAAwHGETgAAAAAAAHAcoRMAAAAAAAAcR+gEAAAAAAAAxxE6AQAAAAAAwHE+twsA4D5jjILBYMPjUDgij2XJ6219Lh0IBGRZlpPlAQAAAAA6IUInAAoGg5o9e7Yj71VQUKD09HRH3gsAAAAA0HkROsEVpeXVCoUiUdsCAZ+yuhNWAAAAAECquOalRW6X0KT7f3y+I++zadMmDR06NGqbz+dTv379dMIJJ+j666/XUUcdFfX8zJkztXDhQq1cuVJjx45t2B4Oh/Xoo4/qiSee0Keffqrq6mr16dNHgwYN0vHHH6/zzz9f3/ve9xypuyMQOsEVn2/Ypp2llVHbBuRm68hDB7hUUdcWCARUUFAgSbJto6LtFfL5PMrLyWzY55prrlFJSYl69eql+++/v9n3AgAAAICuZtiwYZo+fbokqbKyUqtWrdLTTz+t559/Xq+99pomTJjQ7OsjkYh+/OMf67XXXlN+fr7OPPNM9e3bV0VFRfr888/1u9/9TpmZmYROQEuY+ZNcLMuKWhI3fEhGzH1i7QsAAAAAkIYPH665c+dGbbvnnns0Z84c3XLLLXrzzTebff1f//pXvfbaazr11FO1dOlS+f3+qOeLi4tVVFTkdNntirvXwRVkTgAAAACAVHfBBRdIklatWtXivitXrpQkXXrppY0CJ0nKy8vT97//fWcLbGeETnCFx0PqBAAAAADoGny+lhea9e7dW5K0fv369i6nwxA6wRUsrwMAAAAApLpHH31UkjRu3LgW9z399NPl9Xp188036/LLL9dLL72kbdu2tXeJ7YqZTnCFh9AJAAAAAJBC1q9f3zDTqbKyUh9++KHefPNN9evXT7/+9a9bfP2YMWM0f/58XXXVVfrDH/6gP/zhD5KkgQMH6uSTT9bll1+uMWPGtOcfwXGETnAFnU4AAAAAgFSyYcMGzZs3L2pbv3799Pbbb2vkyJFxvcd5552nM888U//617/0zjvvaNWqVXr33Xe1YMECLVq0SH/4wx906aWXtkf57YLldXCFxXceAAAAACCFnHrqqTLGyBij7du369e//rV27NihadOmqaKiIu73SU9P12mnnaZ7771Xr732mnbt2qU77rhDtm3ryiuvVHFxcTv+KZzFpT9c4fN63S4BAAAAAIB20bdvX1177bW68cYb9dlnn+nmm29O+L3S09N18803a8KECaqtrdWKFSscrLR9ETrBFT4v33oAAAAAgNR24403Kj8/X4888og2bdrUpvfKzMx0pqgOxJU/XEHoBAAAAABIdRkZGbrhhhsUCoV0xx13NLvv3/72N73xxhsyxjR67t1339Xy5cvl8/k0duzY9irXcQwShyt8PkInAAAAAEDqu/jii3Xvvfdq0aJFuvHGGzVs2LCY+7333nt66KGHNGDAAE2YMEGDBg1SbW2tPv30U/3rX/+Sbdu65557NGDAgA7+EySO0AmuoNMJAAAAAFLf/T8+3+0SXJeenq45c+boiiuu0Lx587Ro0aKY+11zzTUaNmyYXn31VX344YdasmSJQqGQ8vLydMYZZ+jSSy/VSSed1MHVt41lYvVtdWHl5eXq2bOnysrKlJWV5XY5Kav4u3Kt+nhr1LYBudk68tDOk9h2NZdffrl27dql3r176/e//73b5QAAAAApozNfh9bU1Gjjxo0aOnSo0tPT3S4HHSTef3faTeAKltcBAAAAAJDauPKHK3xer9slAAAAAACAdkToBFekpRE6AQAAAACQygid4Io0H6ETAAAAAACpjNAJrvB6PfJ4LLfLAAAAAAAA7YTQCa6wLEtpfp/bZQAAAAAAgHZC6ATXpPlZYgcAAAAAQKoidIJr/IROAAAAAACkLEInuIbldQAAAAAApC5CJ7iG5XUAAAAAAKQuQie4JpBGpxMAAAAAAKmK0AmuIXQCAAAAACB1ETrBNYROAAAAAACkLq764RpCJwAAAABIbdv/eL3bJTSp32X3OfI+mzZt0tChQ6O2+Xw+9evXTyeccIKuv/56HXXUUVHPz5w5UwsXLoza1r17d40cOVJnn322rrzySgUCgSa/Tn5+vrZs2SKvt/Gs5HXr1mn06NGSpIMOOkiff/551PNbtmzRPffco3/961/aunVrQ62HHHKIJkyYoMsvv1yZmZmJ/WXsh6t+uCYtjUHiAAAAAIDUMGzYME2fPl2SVFlZqVWrVunpp5/W888/r9dee00TJkxo9JoLLrhAAwcOlG3bKioq0vPPP68bbrhBb7zxhl5++eWYX8fn86moqEivvPKKJk+e3Oj5xx9/XD6fT+FwuNFza9as0aRJk1RaWqoTTjhBP/7xj5WWlqaNGzfq3//+t1588UWdccYZGj58eBv/NvbU6si7AAkI+Pn2AwAAAACkhuHDh2vu3LlR2+655x7NmTNHt9xyi958881Gr7nwwgs1duzYhsf33nuvRo8erVdeeUXLli3TiSee2Og1xx9/vNasWaOCgoJGoVNtba3+8pe/aPLkyVqyZEmj11599dUqLS3VokWLdN555zV6fuXKlcrJyYn3j9yipJvpVFhYqN/+9rf64Q9/qEGDBiktLU15eXk644wz9P7778d8TXl5ua6++moNHjxYgUBAgwcP1tVXX63y8vIOrh6t4fV65PfR7QQAAAAASE0XXHCBJGnVqlVx7d+nTx9Nmzat2ddkZGTo7LPP1tKlS7Vjx46o55YsWaIdO3Zo1qxZMV+7cuVKZWdnxwycJOm4445TdnZ2XLXGI+lCp4cfflhXXXWVvv76a51yyim65pprNG7cOC1evFjHH3+8nnrqqaj9KysrNXHiRD344IM66KCDdNVVV+nQQw/Vgw8+qIkTJ6qystKlPwniwVwnAAAAAECq8/niv/Y1xrT4mtmzZzd0Ne2roKBA/fr103//93/HfF3v3r1VUVGh4uLiuOtpi6QLnY455hi99dZbWr9+vR5//HHdfffdeuaZZ7Rs2TJ5vV5ddtllCgaDDfvfd999Wr16ta6//nq9+uqruueee/TSSy/p1ltv1erVq3Xffc4MBkP7IHQCAAAAAKSqRx99VJI0bty4uPb/7rvv9Pzzz0uSTjjhhCb3O/bYY3XYYYepoKCgYVthYaFeffVVnXfeeU0GVmeeeabC4bDGjRunBx54QB9++KFqamri/NO0XtJd8f/kJz+JuX38+PE68cQT9eqrr2rdunU66qijZIzRY489pu7du+vWW2+N2n/OnDl6+OGH9fjjj2vu3LmyLKsjykcrEToBAAAAAFLB+vXrG2Y6VVZW6sMPP9Sbb76pfv366de//nXM1zz22GN6+eWXZYxRYWGhnnvuOe3atUuXX365jj766Ga/3qxZs3Tttddq1apVGjNmjBYsWKBIJKLZs2c3+Zq77rpLu3bt0hNPPKFrrrlGkuT1enXEEUfo9NNP1+WXX+7o8rpOdcXv9/sl7W0x++qrr1RUVKRTTz210e380tPTNWHCBC1evFjr16/XiBEjOrxetIzQCQAAAACQCjZs2KB58+ZFbevXr5/efvttjRw5MuZrHn/88Ubb/vd//1cPPvhgi1/vvPPO05w5c1RQUNAQOh177LE69NBDm3xNRkaGFi5cqDvvvFMvvviiPvjgA33wwQf6z3/+o//85z969NFH9eabb+rAAw9s8evHI+mW1zVly5Yteu2115SXl6fDDz9cUl3oJKnJQKl+e/1+sQSDQZWXl0f9QscJBAidAAAAAACd36mnnipjjIwx2r59u379619rx44dmjZtmioqKmK+ZuXKlTLGKBgM6oMPPtBRRx2l3/72tzHDqP3169dPkydP1pNPPqlXXnlF69evb3KA+P4GDhyoiy++WI899pjWrl2r9evXa8KECfrmm2901VVXterP3ZxOETqFQiGdd955CgaDuu++++T11t3xrKysTJLUs2fPmK/LysqK2i+Wu+++Wz179mz4dcABBzhcPZqTTqcTAAAAACDF9O3bV9dee61uvPFGffbZZ7r55pub3T8tLU1HH320XnzxRfXq1Uu/+MUvVFhY2OLXmT17tkpKSnTBBRcoIyND55xzTkL1Dhs2TAsWLJAkvfHGGwm9RyxJHzrZtq3Zs2frrbfe0kUXXdTkbf0SNWfOHJWVlTX82rp1q6Pvj+axvA4AAAAAkKpuvPFG5efn65FHHtGmTZta3L9v37667bbbVFVV1WipXiyTJ09WXl6eCgsLdcYZZzQ03yRi/7FFTkjq0MkYo4suukhPPPGEpk+frv/7v/+Ler6+w6mpTqb6pXJNdUJJUiAQUFZWVtQvdByW1wEAAAAAUlVGRoZuuOEGhUIh3XHHHXG95pJLLlF+fr7mz5+vjRs3Nruvz+fTkiVL9Nxzz+nOO+9s8b1vv/32mM02xhjdfffdkuK/0148kjZ0sm1bF1xwgQoKCnTOOedowYIF8niiy21pZlNLM5/gvoCf0AkAAAAAkLouvvhi5efna9GiRdqwYUOL+6enp+uXv/ylwuGwbr/99hb3P/roozVt2jQNGjSoxX0feOABDR48WMccc4wuu+wy3XTTTbr00kt10EEH6be//a369Omj+++/P64/VzySMnSybVsXXnih5s+fr7PPPlt//vOfG+Y47WvEiBHKz8/XihUrVFlZGfVcTU2N3nrrLeXn52v48OEdVTpaye/3yrIst8sAAAAAAKBdpKena86cOQqHw3EtmZPqgqoBAwboz3/+s7788kvHalm6dKluuOGGhg6pX//61/rLX/6ijIwMXXvttVq3bl2zd79rraRrM6nvcFqwYIHOPPNMPfHEEzEDJ0myLEsXXnihbr/9dt1+++269957G567++67VVJSoiuuuIJQI4lZlqVAmk81wZDbpQAAAAAAHNbvsvvcLqHdDRkyRMaYZve5/PLLdfnllzc8XrBgQcPg7lgCgYC++eabVn+dfcXad/z48Ro/fnzc79FWSRc63X777VqwYIG6d++ukSNH6le/+lWjfaZNm6YjjzxSknT99ddryZIluu+++/TRRx9pzJgxWrNmjV566SUdeeSRuv766zv4T4DWSvN7CZ0AAAAAAEgxSRc61U9zr6ioaHII1pAhQxpCp8zMTC1fvlzz5s3TM888o+XLlysvL09XXXWVbrvttnaZvg5ncQc7AAAAAABST9Jd7bfUYhZLz5499cADD+iBBx5on6LQrgidAAAAAABIPUk5SBxdSxqhEwAAAAAAKYfQCa4L+GMPigcAAAAAAJ0XoRNcR6cTAAAAAACph9AJrkuj0wkAAAAAgJRD6ATX+X2ETgAAAAAApBpCJ7guzc/yOgAAAAAAUg2hE1yXlkanEwAAAAAAqYbQCa7zeT3yWJbbZQAAAAAAAAcROsF1lmXJzzBxAAAAAABSCqETkgJznQAAAAAASC2ETkgKPh/figAAAAAApBLaS5AU/D6W1wEAAABAqnnkiXfcLqFJ/2/6OEfeZ9OmTRo6dGjUNr/fr9zcXI0fP16//OUvNXr0aEnS3LlzNW/evKh9u3XrpmHDhuknP/mJrrvuOmVmZjY8N2TIEG3evFmS9Nlnn+nggw9u9PXD4bAGDhyobdu2SZK+/fZb5eXlNTxfVVWl3/72t3rmmWf05ZdfKhwOKycnR0OHDtW4ceN04YUXatiwYY78XeyP0AlJwU+nEwAAAACgExs2bJimT58uSaqoqNB7772nJ598Uv/4xz/0xhtv6Pjjj2/Y94wzztCoUaMk1YVES5Ys0bx58/TCCy/o3XffVVpaWsO+Hk/d9XJBQYHuu+++Rl/3hRde0LZt2+Tz+RQOh6Oe2717t8aNG6e1a9dq+PDhmj59urKzs7V161Z98sknuueeezRs2DBCJ6Q2n8+rcNh2uwwAAAAAABIyfPhwzZ07N2rbzTffrDvvvFM33XSTli1b1rD9f/7nf/TTn/604fFvfvMbHXPMMVq1apWefPJJzZgxo+E5v9+vCRMm6M9//rPuuusu+XzRUU5BQYFycnI0YsQIrVy5Muq53/72t1q7dq0uuOAC/elPf5K1353jN27cqGAw2NY/epNoL0FSYHkdAAAAACDVXHHFFZKkDz/8sNn9evTooZkzZza576xZs1RcXKwXX3wxantxcbFeeukl/exnP4vqjqpXH0JdfvnljQInSRo6dGjMJXtOIXRCUmCQOAAAAAAg1cQKehJx+umnq1evXpo/f37U9kWLFikcDmv27NkxX9e7d29J0vr16x2po7W40kdSoNMJAAAAAJBqfve730mSjj766Gb32717txYsWNDkvunp6TrnnHP0z3/+U9u3b2/YXlBQoDFjxjQMKt/fmWeeKUm64IIL9Mtf/lJvvPGGSkpKEvmjJISZTkgKdDoBAAAAADqz9evXN8x0qh8kvmLFCqWnp+uuu+6K2veZZ57R559/LqluidzixYtVXFyso446Suecc07M9589e7YeeeQR/fnPf9Y111yjFStW6IsvvtAf/vCHJmuaOnWq7rvvPt1+++269957de+990qqG3r+ox/9SFdeeaVGjBjhwJ8+NkInJAWvh9AJAAAAANB5bdiwQfPmzZNUN/w7NzdX5557rn75y1/q8MMPj9r32Wef1bPPPitJ6tatm4YPH65LL71U1157bczZTJIaOprmz5+va665RgUFBUpPT9e5557bbF3XXXedLr30Ur388st699139e9//1vvv/++/vCHP+jxxx/X3//+d02ZMsWBv4HGCJ2QFOh0AgAAAAB0ZqeeeqpefvnluPZ98skno+5eF69Zs2bpqquu0htvvKGnnnpK06ZNU3Z2douv69Gjh84888yG5XZlZWW68cYb9cgjj+iCCy5QYWFhk2FXW3Clj6RApxMAAAAAAM2bPn260tLSdP7556uioqLJAeIt6dmzp37/+99r8ODB2rFjh9atW+dwpXW40kdS8Hn5VgQAAAAAoDk5OTk67bTTVFhYqEGDBukHP/hBwu9lWZa6devmYHWNcaWPpOAldAIAAAAAoEW//vWv9dxzz+m5556Tp4VVQ48++qg+/PDDmM/94x//0Oeff67s7GyNGjWqPUplphOSAzOdmrdq1SotXLhQM2bM0JgxY9wuBwAAAADgkqFDh2ro0KFx7fvSSy/p0ksv1fDhw3XCCScoPz9fFRUVWr16td5++215PB498sgjCgQC7VIroROSAjOdmhYMBlVQUKCSkhIVFBRo1KhR7XZAAAAAAACkjnvvvVcnnHCC/vWvf+mtt97St99+K0kaMGCAZsyYoSuuuKJdGxssY4xpt3fvhMrLy9WzZ0+VlZUpKyvL7XK6lDWfF+qIgwe4XUbSeeqpp7R48WIZY2RZlqZNm9Zwx4GOdPnll2vXrl3q3bu3fv/733f41wcAAABSVWe+Dq2pqdHGjRs1dOhQpaenu10OOki8/+60lyBp0O3UWHFxsZYuXar6bNgYoyVLlqi4uDhqP1NdIfvjd2Q2rJYxthulAgAAAAAQhat8JA2PZbldQlIxxmjBggXavxkx5vbvtkjlO2W2bZaqdndwpQAAAAAANMZMJ7iq4sNXFSnZLkkKB4ZII/LcLSiJFBUVae3atY2227attWvXqqioSAMG7FmO2Dtf2lEopWdKGd07uFIAAAAAABqj0wmuMsFqmXBIJhySRywL21d+fr5Gjx7d6BaYHo9Ho0ePVn5+fsM2q3u2PN8/RZ5Dj5fl8XZ0qQAAAAAANELoBFeZUG3D772srotiWZZmzpwpa79lh5ZladasWY22AwAAAACQTAid4CoT3hs6echQGsnLy9Npp53WEDBZlqUpU6YoNzfX5coAAAAAAGgeoRNcY4yJ6nQidIpt6tSpys7OliT16tVLU6ZMcbcgAAAAAADiQOgE90TCUQ9ZLRZbIBDQ7NmzlZOTo1mzZikQCLhdEgAAAABE2f+u20ht8f57c/c6uGbfLieJBLQ5Y8aM0ZgxY9wuAwAAAACi+P1+SVJVVZUyMjJcrgYdpbKyUpZlNfz7N4XQCa4xkVDUYzqdAAAAAKBz8Xq9ys7O1vbt2yVJ3bp146ZHKcoYo3A4rPLycpWXlys7O1teb/N3Tyd0gmsadTpxXAIAAACATicvL0+SGoInpDav16v+/furZ8+eLe5L6ATXmP1nOrlUBwAAAAAgcZZlqX///urXr59CoVDLL0Cn5fP55PV64+5mI3SCexgkDgAAAAApw+v1trjcCl0Ls5vhGhOOTsBZXgcAAAAAQOogdIJrWF4HAAAAAEDqInSCe8LcvQ4AAAAAgFRF6ATX0OkEAAAAAEDqInSCa4wdiXpMpxMAAAAAAKmD0Anu2S90AgAAAAAAqYPQCe7ZL3TimxEAAAAAgNTBdT5cYyL7dTqxvA4AAAAAgJRB6AT3GDvqIZkTAAAAAACpg9AJrtm/04nQCQAAAACA1EHoBPfs1+lE6gQAAAAAQOogdIJ7jIl6SOYEAAAAAEDqIHSCi0zLuwAAAAAAgE6J0AmuMXQ6AQAAAACQsgid4B4anQAAAAAASFmETnDRfqkTrU4AAAAAAKQMQie4h+V1AAAAAACkLEInAAAAAAAAOI7QCe6x+PYDAAAAACBVcdUP11ie6AV1LK8DAAAAACB1EDrBPXQ6xe2pp57S9OnT9dRTT7ldCgAAAAAAceGqH+6x6G2KR3l5uRYvXizbtrV48WKVl5e7XRIAAAAAAC0idIJ76HSKywMPPCCz505/xhg9+OCDLlcEAAAAAEDLuOqHayw6nSRJxtgyNZUNwdK+1q1bpy+//DJq2xdffKF169ZFv0dNpYxtt2udAAAAAAC0BqET3LN/p1NXzaC++o/Mf16Tvl4Ttdm2bT388MMxX/Lwww/L3hMymS2fyfznNZnP3m33UgEAAAAAiBehE9zj9bldQVIwlWV7/r80avvq1atVUVER8zUVFRVavXp11OtV//8AAAAAACQBrvrhGovQSZJkDf+e9N03Uu7gqO1HHnmkunfvHjN46t69u4488si61w8ZJaVnSr3yOqJcAAAAAADiQqcTXGN5vdEbGo806hKsHr1lHThaVmbPqO0ej0dXXHFFzNdceeWV8njq/vO1MrrLGnq4rOy+7V4rAAAAAADxInSCe+h0atHhhx+ukSNHRm076KCDdNhhh7lUEQAAAAAA8SF0gmtYXhefq6++uuFOf5Zl6aqrrnK5IgAAAAAAWkboBNcQOsUnKytLU6dOlcfj0dSpU5WVleV2SQAAAAAAtIirfriH0CluZ511ls466yy3ywAAAAAAIG50OsE1ls/vdgkAAAAAAKCdEDrBNZY/LepxF715HQAAAAAAKYnQCa6xfGkt7wQAAAAAADolQie4Zv/QiU4nAAAAAABSB6ETXNNophOpEwAAAAAAKYPQCe5hkDgAAAAAACmL0AmusSwrapg4jU4AAAAAAKQOQie4imHiAAAAAACkJkInuMpKCzT8nk4nAAAAAABSB6ETXGX59wmdSJ0AAAAAAEgZhE5w1b6hEwAAAAAASB2ETnBVVKeTi3UAAAAAAABnETrBVZ40ltcBAAAAAJCKCJ3gKjqdAAAAAABITYROcNW+d68DAAAAAACpg9AJrrLS0ht+z/I6AAAAAABSB6ETXBUVOrlYBwAAAAAAcBahE1zl8e8NnWxSJwAAAAAAUgahE1xlcfc6AAAAAABSEqET3OX1yfJ4JUm2y6UAAAAAAADnEDrBVZZlNcx1otMJAAAAAIDUQegE19UvsSN0AgAAAAAgdRA6wXWWf0/o5HIdAAAAAADAOYROcF398jruXgcAAAAAQOogdILrPHuW1xE6AQAAAACQOgid4DrLn9ydTqtWrdIvfvELrVq1yu1SAAAAAADoNAid4DoriTudgsGgCgoKtGPHDhUUFCgYDLpdEgAAAAAAnQKhE1xXP9MpkoSh0+LFi1VaWipJKi0t1ZIlS9wtCAAAAACATsLndgFA/d3r3Op0iti2NlfsUg9/uvpmdG/YXlxcrKVLl8qYusKMMVqyZInGjx+vvLw8d4oFAAAAklwoHNG2nZXKSLOUmeF35D0DgYAsy3LkvQB0HEInuM7yp0lyL3T6qny7virbLkuWTh5wsNJ9fhljtGDBgobAqV799htuuIEfegAAAEAMG78p07fby/Tob29y7D0LCgqUnp7u2PsB6BiETuhwJdWV+njblobH3poq5VVVqMyqcaWedG/dpy9+j1deT92K06KiIq1du7bRvrZta+3atSoqKtKAAQM6tE4AAAA0b0tRiUrLqxse+7weHTqCDvWO5vd73S4BQJIgdEKHqwnX6ssd3zY89kbCygzWqDot5Eo9Q3r0Uc+0DGV4/fJ76n5A5ufna/To0fr4449l23bDvh6PR6NGjVJ+fr4rtQIAAKBpJWVV+qa4tOFxmt9H6OSCIflZ6p0V0P/3p8fk8zY/Rviaa65RSUmJevXqpfvvv7/J/QKBgNNlAugAhE7ocJ79lqVFPF4Zy5KRe8vVegW6RT22LEszZ87Udddd12j7rFmzWFoHAACQjDhFSwqWZalnj/iWwtWfV1uWxfI5IAVx9zp0OI+137edZanWk+ZOMc3Iy8vTaaedFvWDcMqUKcrNzXW5MgAAAMSy/4ebAAB3ETqhw8U6GQh5k7PpburUqcrOzpYk9erVS1OmTHG3IAAAADSJbnQASC6ETuhwVoy+57DlzK1UnRYIBDR79mzl5ORo1qxZrCUHAABIYoROAJBckrO9BCmt/g5x+wpbyfutOGbMGI0ZM8btMgAAANACIicASC50OqHD+WKETiFP8oZOAAAA6By8LdwpDQDQsTgqo8OlxZjflMydTgAAAOgcCJ0AILlwVEaH83m8jXqfw5bXnWIAAACQMnxeFtgBQDIhdEKHsyxLfk90yESnEwAAANqKTicASC4cleGK/ZfYRZhpDwAAgDaKdcMaAIB7OCrDFX7vfp1OfCsCAACgjeh0AoDkwlEZrkjz+qMe24aZTgAAAGgbn4/LGwBIJhyV4YoMX3ToFOFbEQAAAG3k9/FBJgAkE6704Yp0f1rUY9vwrQgAAIC2IXQCgOTClT5cke7bf3kd34oAAABoG7+f0AkAkglX+nBFum9vp5MxhE4AAABoO6/HksdjuV0GAGAPrvThiqiZTrZ7dQAAACB1WJYln5duJwBIFoROcEXUTKeIZMQnUgAAAGi7NJbYAUDSIHSCK7rtEzqZCIETAAAAnEHoBADJg9AJrujmD+x9YEvGIngCAABA26Wl+dwuAQCwB6ETXJHm9cnrqfv2o9MJAAAATqHTCQCSB6ETXGFZljLql9hF3K0FAAAAqcNP6AQASYPQCa6pX2JnIpJkSSyxAwAAQBsF/CyvA4BkQegE1zQME9+zvM6QOQEAAKCNWF4HAMmD0Amu6eYPyBjJhOu3kDoBAACgbfx0OgFA0iB0gmu6+QOSLcneEzaROQEAAKCN6HQCgORB6ATXZKYF9sxzqkfqBAAAgLZJSyN0AoBkQegE13Tzp0nhfYMmQicAAAC0DYPEASB5EDrBNRn+wD7znCTjXikAAABIEV6vR14vlzkAkAw4GsM1mWmBhjvXSaLRCQAAAI5Io9sJAJICoRNc4/d4pci+34KkTgAAAGg7hokDQHIgdIJrLMuSN8K3IAAAAJxF6AQAyYErfrgmFI7Isvf9FmSqEwAAANrO7yN0AoBkQOgE11RW1cpr8S0IAAAAZ/npdAKApMAVP1xTURmU17PPHCcanQAAAOAAltcBQHIgdIJrKqqC8lh7TwgYIw4AAAAnEDoBQHIgdIJrdlcG5bWImgAAAOAsZjoBQHIgdIJrKqqC8ngYJA4AAABn+QidACApEDrBFZGIrerqkDz7djoZQicAAAC0ndfLZQ4AJAOOxnBFeUWNjEx06ESnEwAAABzg93GZAwDJgKMxXFFeUSNJ8lh7vwUtMicAAAA4wOdleR0AJANCJ7iibHd96FTf6WRYXgcAAABH+Oh0AoCkwNEYrtjb6WRJ3MAOAAAADvIx0wkAkgJHY3Q42zbaXVnT8NgidQIAAICDPB7OLwEgGRA6ocNVVAVl23uX0lmcEwAAAMBBlmURPAFAEiB0Qocr310T9diyLFnMcwIAAICD9r1hDQDAHRyJ0eHKKvYLnWTJEqETAAAAnEOnEwC4j9AJHa60rCrqsYdOJwAAADjMS+gEAK4jdEKHikRslVfWNH6CzAkAAAAOotMJANxH6IQOVV5REzVEXNoz04nUCQAAAE7ibjUA4DpCJ3So0vLqmNs5JQAAAAAAILUQOqFDNRk6MdMJAAAAAICUQuiEDkXoBAAAAABA10DohA4TrA2rqqY25nOETgAAAAAApBZCJ3SYprqcJDFIHAAAAACAFEPohA6zq6yqyefodAIAAICTjM35JQC4jdAJHaakidDJGEPoBAAAAEdFbNvtEgCgyyN0QoeIRGyV7Y69vI7QCQAAAE6z6XQCANcROqFDlO2uafIHv5FhphMAAAAcRacTALiP0AkdoqmldZJkjOQxnBQAAADAGcYYOp0AIAkQOqFDNB862XXJEwAAAOAAAicASA6ETmh3xhiVlMee51S3A11OAAAAcE44wvklACQDQie0u4qqWtWGwjGfM0ayWG8PAAAAB4XCEbdLAACI0AkdoLmldbaxuXMdAAAAHBUKEToBQDIgdEK7az50MgwRBwAAgKNCYc4vASAZJGXo9MQTT+iSSy7RUUcdpUAgIMuytGDBgpj7zp07V5ZlxfyVnp7esYUjpl3NhE4ROp0AAADgMJbXAUBy8LldQCw333yzNm/erJycHPXv31+bN29u8TUzZszQkCFDorb5fEn5x+tSaoIhVVXXNvl8XacToRMAwBmrVq3SwoULNWPGDI0ZM8btcgC4hOV1AJAckjKVeeyxxzRixAgNHjxY99xzj+bMmdPia2bOnKlJkya1f3FoleaW1kmSbdvyMEgcAOCAYDCogoIClZSUqKCgQKNGjVIgEHC7LAAuoNMJAJJDUi6vO/nkkzV48GC3y4ADdpVVN/t8xNjMdAIAOGLx4sUqLS2VJJWWlmrJkiXuFgTANcHa2HdOBgB0rKTsdErE22+/rQ8++EBer1cHH3ywTj75ZD7dTAItdTqFbVt+QqeUUhuKyOOx5PMmZaYNIEUVFxdr6dKlMnuWbBtjtGTJEo075ijlHTBYlodjEtCV1ARDbpcAAFAKhU633npr1OP+/ftr4cKFOuWUU5p9XTAYVDAYbHhcXl7eLvV1ReGIrfKKmmb3idgR+ZnplDLKdgf16dc75fNaGj2ynwJpXrdLAtAFGGO0YMGChsApavsjD+v66dPkPXyCS9UBcEMwSKcTACSDTv+x35FHHqmFCxdq06ZNqq6u1ldffaU77rhDpaWlmjJlitasWdPs6++++2717Nmz4dcBBxzQQZWnvrLd1Y0uAPZnIpwQpJKqmpCMMQqFbdUywBNoF+FdxQqXbHe7jKRSVFSktWvXyt5vRqBt21q3tVhF33zT4s8jAKmlhuV1AJAUOn3oNG3aNJ1//vkaPHiw0tPTNXz4cN1888166KGHVFNTo1/96lfNvn7OnDkqKytr+LV169YOqjz1lbQwz0mSbEKnlJLbJ1MDc3to6ICe6pGZ5nY5QEqqWrdC1Z994HYZSSU/P1+jR4+WZ78ldB6PR6NHHKgBY38gy7Jcqg5ARzPGMNMJAJJEpw+dmjJjxgz5fD6tWLGi2f0CgYCysrKifsEZpS3duc4Y7lyXYjweS4P6Z6l/3+5ulwKkLMtK2R/dCbMsSzNnzmwULFmWpVn/7wp5euW6VBkANwRrI3Q3AkCSSOjM9cADD9Tvfve7Zvf5v//7Px144IEJFeWEtLQ09ejRQ1VVzQcfaB/GGJWUN9/pFLYjhE4A0Fp07MSUl5en0047rSF4sixLU6ZMUW4ugRPQ1TBEHACSR0Kh06ZNmxpuSdyUsrIybd68OZG3d8RXX32lkpISDRkyxLUaurKq6pBqQ823NYdtWx7uXAcArUOnU5OmTp2q7OxsSVKvXr00ZcoUdwsC4Iqq6lq3SwAA7NFuZ65lZWUKBALt9faSpN27d2vt2rWNtpeUlOiCCy6QJJ1zzjntWgNiKy1vucOsrtOJYdMA0CoeOp2aEggENHv2bOXk5GjWrFntfh4CIDlV1RA6AUCy8MW741tvvRX1eNOmTY22SVIkEtE333yjP//5zxo5cmRCRT322GN65513JEnr1q1r2LZ8+XJJdcPDp02bpp07d+qII47QUUcdpcMPP1z9+vVTYWGhXnrpJe3cuVOnnHKKrrrqqoRqQNu0tLROksKRiLystweAVrEsD7NKmjFmzBiNGTPG7TIAuKiqmuV1AJAs4g6dJk2aFDUnYeHChVq4cGHMfY0xsixLd911V0JFvfPOO43ee8WKFQ1DwYcMGaJp06apd+/e+vnPf6733ntPS5cuVWlpqTIzM3X44Ydr+vTpuvDCC+X1ehOqAW1TtrumxX3CkbB8LK8DgNbx+qQwF1QA0BQ6nQAgecQdOt16662yLEvGGN1+++2aOHGiJk2a1Gg/r9er3r1768QTT9QhhxySUFELFizQggULWtwvKytLv//97xP6Gmg/tm20u6Ll0MmOcNEEAK1leX0yhE4A0CQ6nQAgecQdOs2dO7fh92+++aZmzZql888/vz1qQidXURVUpIW70hkjKcI8JwBoNQ8dvADQlIhtq6aG0AkAkkXcodO+li1b5nQdSCHxLK0L2RF5WgimAACNWd6EfnQDQJdQVV0rI+beAUCyaPOZa2VlpUpLSxVpomtl0KBBbf0S6GTKdrc8RDwUCctj6HQCgNaymFUIAE2qqGKeEwAkk4RDp8cff1z333+/vvjiiyb3sSxL4XA40S+BTiquIeJ2RF46nQCg9bx+tysAgKRVURl0uwQAwD4SCp3++Mc/6uc//7l8Pp8mTJiggQMHyuej3R/xDxEP2RH5CZ0AoNUsH6ETADSlsorQCQCSSUJJ0W9/+1vl5OTonXfe0ciRI52uCZ1YVXVti0PEJSkcDivNEDoBQGsROgFA01heBwDJxZPIizZv3qyzzjqLwAmNVMTx6ZIxkh3hriIAkAhCJwCIzRhDpxMAJJmEQqf8/PwmB4eja4sndArbEXlsvn8AIBGETgAQW3VNSOEInfQAkEwSCp1mzZqll156SZWVlU7Xg04unuGNITsiD/OcACAxvjS3KwCApLSbIeIAkHQSCp1uvPFGHXPMMTrllFP01ltvaffu3U7XhU4qnnX0oUiYO9cBQILodAKA2HZXtnwzGwBAx0pokHhaWt2nrMYYnXjiiU3uZ1mWwuFwYpWh0zHGxLW8LmRH5GV5HQAkhNAJAGLbXUGnEwAkm4RCp/Hjx8uyLKdrQSdXHQwpEsc6+lCEO9cBQKIsltcBQEzldDoBQNJJKHRavny5w2UgFVRUtry0zhgpEgnX/QYA0Gp0OgFAYxHbVmUcYx4AAB0roZlOQCzVNXHMc7Ij8nBXEQBInNdHtzEA7KeislaGDzUBIOkQOsEx1TWhFvcJRcLysrQOABJmWZbkpdsJAPa1u4KldQCQjBJaXidJkUhETz31lF577TUVFRUpGGw8uM+yLL3++uttKhCdR00wvtDJwxBxAGgTy5fwj28ASEnlhE4AkJQSOmutrKzUD3/4Q7333nsyxsiyrKh21vrHtP93LdXBlu9UGLIj8tDpBABtYtHpBABRCJ0AIDkltLzuV7/6lVauXKl58+Zpx44dMsZo7ty5+vbbb/X3v/9dQ4cO1f/8z//E7H5C6qqJa3ldRF6b0AkA2oJh4gCwlzGG0AkAklRCodM//vEPjR07VjfffLN69+7dsD03N1dnnnmmli9frtdff12//vWvHSsUyc0Yo5ra5kMn2xhF6HQCgLbzsrwOAOpVB0MKhRnfAADJKKHQacuWLRo7duzeN/F4orqaBg4cqP/6r//SwoUL214hOoVgbVi23fwdQ0KRiCxjJO4sAgBtQqcTAOy1u4LVFQCQrBIKnTIzM+Xx7H1pz5499e2330btk5eXpy1btrStOnQaNfHMc4qEWVoHAA6wvF63SwCApMHSOgBIXgmFToMHD44KlEaNGqU33nijodvJGKPXX39d/fv3d6ZKJL1QqOWW5roh4rQ+A0CbeQidAKAeoRMAJK+EQqcf/OAHWrZsmcLhuu6WGTNmaMuWLTruuON03XXXady4cVq9erXOOOMMR4tF8gpH4gidImF56HQCgDazmOkEAA0InQAgeSUUOl100UW69tpr9d1330mSZs+erZ///Odas2aN7r//fq1cuVI/+clPNHfuXCdrRRILhVsOk0KddIj4qlWr9Itf/EKrVq1yrYaHHnpI5557rh566CHXagCQRAidktpTTz2l6dOn66mnnnK7FCDlhcIRVVXXul1Gp5QM57gAUl9CodOIESN0ww03RC2fe/jhh1VcXKyVK1eqqKhITz/9tLp16+ZYoUhuLd0xxDZGtm063UynYDCogoIC7dixQwUFBVED8zvKjh079P7770uS3n//fe3YsaPDawCQXCyW1yWt8vJyLV68WLZta/HixSovL3e7JCCl7abLKSHJcI4LoGtIKHRqSt++fXXssccqLy/PybdFJ9BS6FQbCUsyna7TafHixSotLZUklZaWasmSJR1ew/4dg/PmzevwGgAkGTqdktYDDzwgs+curcYYPfjggy5XBKS2cu5cl5BkOMcF0DW0OXR699139cgjj+juu+/WI488onfffdeJutDJhFtYXheORGQZI+05EU9Gxhht3r1LRZVlkqTi4mItXbo06uJhyZIlKi4udubrRcIyRRtkSr9rcp83l72uXbt2RW3buXOn3lz2uiM12LbRt99VqLQ8/k8JjTEqauVrADjLshz9zAhxMMaoeEeldpVVN2yz7fptdcfDdevW6csvv4x63RdffKF169Z1aK1AV7K7kvOR/ZmaKpnCr2SqK2I+397nuG2VyPkpgOSV8FnrW2+9pYMOOkjjx4/XFVdcoZtuuklXXHGFxo8fr4MPPlhvv/22k3UiybV097rOMM9pa2WJ1u76Rqt2bNaumkotWLCg4YdxPWNMzO0JKVwvs+ljmc9WytRWN3o6Eonoscfnx3zpY4/PVySO4e0tKdpeoY2FZfps4y4Fa8NxvSZiG21qeA13IwRc4SF06mjFOyr19Tel+nzjLlVWh+q27azb9sXGXaqoCurhhx+O+dqHH35YdidbXg50FnQ6NWbWr5LZ/KnMFx80fq6Jc1lHz3HbqDCB81MAySuh/vyVK1fqhz/8oUKhkCZPnqzx48crNzdX27Zt01tvvaWXXnpJP/zhD7Vs2TKNHTvW6ZqRhMKR5k+mO8Od6wJenyRLHsvSzm3btXbt2kb72LattWvXqqioSAMGDGjbF0wL1P2/zy95Gv+n+MYbbyjSxN9ZxLb1xhtv6JRTTmlTCX5/3YWr12PJ47Hiek39Xq15DYD4fbXpO1XXhJrdJ2BqdFCvfh1UESQpzV83R8vrseT11h370nx12zweS598vE4VFbG7CioqKrR69Wp9//vf75higS7CGKOKJjqdTKhWdnWlIj5L0kEdW5jb/Ol1/5+W3uipoqKi9j/HbaO0BM5PASSvhEKnG2+8UZZlafny5Ro/fnzUc9dff73efPNNnXrqqbrxxhv1xhtvOFIokltLn4qE7Ij8Sd7plJuRpYn9h8tredXN59fo0aP18ccfR3067fF4NGrUKOXn57f561l5Q6XMbCmQLsvnb/T8SSedpEWLFsXsaPJ6vTrppJPaXENun0x1S/crze+V3xffYGKv16PDR/RVIM0rv49uC8BphcWlqmzhTkw9062udgnluj7ZGTrioH7yei2lp9WdPuX0ylB6oK/8Po/8vlx17949ZvDUvXt3HXnkkR1cMZD6qmtCTX7wacIh2TUVini7Xmhhjfi+1H/PeeZ+8vPz2/0ct60SOT8FkLwSumL88MMPdfbZZzcKnOpNnDhRZ599tj74oHFLJ1JTc5lT/Z3rkn15nSRlpWUo058my7I0c+ZMWVb0iYplWZo1a1aj7YmyevSSlZYR8zmv16sLL7ww5nOXXHKJvF5nfgj3yExTIK1179UjM63hU38Azgq1MCNPkuTQMQitk5nhbwic6nXvlqZAmk8ej0dXXHFFzNddeeWV8rAkEnDc7srmlta5v0zMLZbHKysrR1aMm0501DluWyVyfgogOSV0BpSent5i2+WAAQOUnt64pROpyTTzgz20p1PHY3euH/55eXk67bTTGn74WpalKVOmKDc3t8NqmDhxonr37h21rU+fPho3blyH1QCg4xhjWrwbaJ3kuChAtMMPP1wjR46M2nbQQQfpsMMOc6kiILU1O0S8c512dqhkOMcF0HUkFDr94Ac/aHHZ3BtvvKGTTz45oaLQ+TTX6RS294ROnaDTaX9Tp05Vdna2JKlXr16aMmVKh9cwd+7cqMe33XZbh9cAoGNEbBPXENdk+SQajV199dVRF3JXXXWVyxUBqauCTqeEJcM5LoCuIaHQ6f7771dRUZFmzZqlwsLCqOcKCws1c+ZMFRcX6ze/+Y0jRaITaOYiKRQJS+ocy+v2FwgENHv2bOXk5GjWrFkKBAIdXkNOTo6OPfZYSdKxxx6rnJycDq8BQMcIx9XlJNHplLyysrI0depUeTweTZ06VVlZWW6XBKSsiqpm5t8lwV3YklkynOMC6BoSGiR+/vnnq3fv3lq0aJH+8pe/aPDgwerXr5+2b9+uzZs3KxKJaPTo0Tr//POjXmdZll5//XVHCkdyab7TyZZlTKf94T9mzBiNGTPG1RquvPJKV78+gI7RSQ+T2M9ZZ52ls846y+0ygJRmjFFlVTOdThxQW5QM57gAUl9CodPy5csbfh8Oh7VhwwZt2LAhap81a9Y0eh3LAVJXszOd7Ig8/OAHgBbZ8c6+4+cpgC4uWBtu8s51AIDkkVDotO/tNYE6sS+AjKmb6eTrhEvrAKCjxTPPCQAgVTTX5SSJmU4AkBy4fy8c4fHEDp0iJiKZzjlEHAA6WtyhE51OALq4yubmOUlkTgCQJAid4AhvE6FTKFJ/5zp+8gMAAMAZLYVOzY1+AAB0nLiW1y1atEiSdPrpp6tHjx4Nj+Ox/zBxpCaPJ3Z+GbbrQieLTicAaJHVRIAPAIhWHQy5XQIAIA5xhU4zZ86UZVkaO3asevTo0fC4OcYYWZZF6NRFNNXpFN4z/8sT73BcAOjCPCybA4C4VNe0EDpx6gkASSGu0KmgoECWZal///6SpPnz57drUeh8mprpFLLrl9fR6QQALYn7Lq+EUwC6uBZDJ1InAEgKcXc67WvGjBntUQs6MW+Ly+v4wQ8ALWkqwAcA7BWO2KoNhd0uAwAQBwaJwxGxLpSMkSK2Lckw0wkA4uD18mMZAFrScpcTACBZJHR2u2LFCl199dUqLi6O+XxxcbGuvvpqvffee20qDp2Hz9f4WylsRyRDlxMAxMvrsWSJbicAaE5NPKET558AkBQSCp0eeOABLV26VHl5eTGfz8vL0wsvvKAHH3ywTcWh8/D7vI22sbQOAFrHsiy6nQCgBSytA4DOI6Ez2w8//FDjxo1rdp8JEybQ6dSF+GKGTnvuXEfoBABxi9U5CgDYqzYUcbsEAECcEjqz3b59uwYMGNDsPnl5edq+fXtCRaHz8Te1vE5inhMAtIIvrk4nluAB6LqCdDoBQKeRUOiUnZ2tLVu2NLvP5s2b1b1794SKQufT3PI6Op0AIH6xjqeNkDkB6MJCdDoBQKeRUOh03HHH6bnnntPWrVtjPr9lyxY9//zzOv7449tUHDoPv7/p5XXMdAKA+MU6ngIA9grWxhM6cf4JAMkgodDp6quvVlVVlU444QQtWrRI3377rSTp22+/1cKFC3XCCSeourpa11xzjaPFInk1efc6SZZYXgcA8UojdAKAZoVYXgcAnYYvkReNHz9ev/vd7/S///u/mjVrlqS6O+6YPR0tHo9HDz30kCZMmOBcpUhq+y8Hidh2wwdMdDoBQPziWl4HAF1YxI7j3JLTTwBICgmFTpL085//XBMnTtQf//hHffjhhyotLVV2draOOeYYXXrppRo1apSTdSLJ+bweeTyW7D0nAfVL6yRmOgFAa7C8DgCaF7HpogeAziLh0EmSRo0apT/84Q9O1YJOzLIspfl9qgmGJO1dWifR6QQArRFIa9OPZgBIeXaEc0sA6CwSmukExLLvHJKI2fsJFKETAMSPTicAaJ7NuSUAdBpxfZy6ZcsWSdKAAQPk9XobHsdj0KBBiVWGTifNv/fbKRyp73QyhE4A0AoBQicAaFYkwvI6AOgs4gqdhgwZIsuy9Nlnn2nkyJENj1tiWZbCYe4u0VXs2+kUNvueDBA6AUC80lheBwDNsuMZJA4ASApxndmef/75sixLPXv2jHoM7CsqdNoz04kuJwBonTQ6nQCgWfGdXXIOCgDJIK7QacGCBc0+BqToT+fr7ypC6AQAreP3eeWxLGaWAEATPJbEAjsA6BwYJA7H1H86H7Hthg+XLD5lAoBWsSwrjmHidBsD6LpYcQEAnUdCoZPX69Udd9zR7D733nuvvF6WCHQl9Z1OYZs71wFAWwSY6wQATSJ0csaqVav0i1/8QqtWrXK7FAApLKHQyRgjQ5iA/eztdIo0bCN0AoDW2/duoACAaGRObRcMBlVQUKAdO3aooKBAwWDQ7ZIApKh2W1733XffKSMjo73eHkmo/iJp3zvXsbwOAFqPYeIA0DQPqVObLV68WKWlpZKk0tJSLVmyxN2CAKSsuD9KXbRoUdTj1atXN9omSZFIRN98843mz5+vUaNGtb1CdBqBtM7X6VQarNJHxZvVMy1dh/bq36b3CgQCCbV7G2MUDAZlKkpkNn0iKztH1sCD654r/EqmZJuswYfI6tEn9uu//VpmZ5GsgSOVnntAh7ach8K21m8pkSVp+OBe8nkZEwc4IY3ldUmr/pjdVrZt9PU3pZLl04jBvRt+hgJomcdD6BQPU1Mps/4jWendpGFHyrLqztOKi4u1dOnShpUrxhgtWbJE48ePV15eXsfUZow2FpZpR0m1akORll8AoNOK+6x25syZDRezlmVp8eLFWrx4caP96g9eGRkZmjt3rjNVolPw+7yyLKtTzXRav3Ob/jSn+flk8SooKFB6enqrXxcMBjV79mxXa0hUaXmNSspr9vw+qJxedDcCTqDTKXk5ecyWpEv+90717pmh/H7dHXtPINX5fBwj47J9q1S+U6Z8p6y8oVL3XjLGaMGCBY1GpdRvv+GGGzrkA8yaYETFOyq1o6Ratr03/AKQeuIOnebPny+p7mAwe/ZsTZ06VdOmTWu0n9frVe/evXXcccepV69ejhWK5GdZlvw+b93d6+q3Jfnyuv6ZWW6X0Kn17BFQZrpflmUpq3ua2+UAKYPQqetID3jVKyvgdhlAp+Lz0Vkdlz79pR1bpfRMqVvdOW9RUZHWrl3baFfbtrV27VoVFRVpwIAB7V5aesCr3lnpCoftqMYGAKkn7tBpxowZDb9/8803dfrpp2vKlCntUhQ6r0CaT5F9Zzold+ak/KzeKigoaHafa665RiUlJerVq5fuv//+JvcLBBK7aAgEAq7XkKg0v1dHHNyvQ78m0BWwvC55OXnMrn8/LrSA1vFxh+y4WJk9ZX3/lKht+fn5Gj16tD7++GPZ+3xQ7PF4NGrUKOXn53dMbZalgw/so4MP7KOnFnhV2SFfFYAbEjqr3bRpk/79738TOqERn8/T0CIrJf/yOsuyWlyOtu+nL+2xdC0ZagCQXOh0Sl4cswH3+el0SphlWZo5c6auu+66RttnzZpFCA7AcQkdsT/44AOFw2Gna0Eq8ESHTMm+vA4AkhGhEwA0zc9MpzbJy8vTaaedFhWQT5kyRbm5uS5XBiAVJRQ6HXLIIdq0aZPDpSAV2JYd9TjZO50AIBn5fS01InNsBdB1MdOp7aZOnars7GxJUq9evVjBAqDdJHTEvuKKK7RkyRJ9+umnTteDTs5YdDoBQFvR6QQATQsw967NAoGAZs+erZycHM2aNavD54IC6DoSOmIPHTpUkyZN0tixY3XJJZfo6KOPVm5ubsw1wBMmTGhzkeg8IopEbyBzAoBW83gs+XxehcORlncGgC6Gmy04Y8yYMRozZozbZQBIcQkdsSdNmiTLsmSM0f3339/swLlIhBPmriTC8joAcISf0AkAYqLTCQA6j4SO2Lfeeit3NkBMIbPvgHkjWp0AIDFpfq+qa9yuAgCST8AfzyUM1yoAkAwSCp3mzp3rcBlIFdGhEwAgUdydCQBiC6RxfASAzoJbP8BRtfuETiytA4DE+RkmDgAxeb0eeT1cxgBAZ8DRGo4KEToBgCP83BIcAGKyLEvpAeY6AUBnkPAZ7datW3XJJZdo2LBhysjIkNfrbfTL5+OHQVcT2mdwvMU8JwBIGMvrAKBpgYDf7RIAAHFIKBX6+uuvdeyxx6qkpESHHXaYgsGgBg8erPT0dG3YsEHhcFhHHHGEsrOzHS4XycwYo5DCkuoulCwyJwBIGKETADQtnTvYAUCnkFCn07x581RWVqbXX39da9askSTNmjVLn332mTZt2qTTTjtNlZWVevrppx0tFsktYmzZUUvqSJ0AIFHMdAKAprW4vI6b1wFAUkgodHrttdc0efJkTZw4sWGb2RM25Ofn66mnnpIk3XTTTQ6UiM6iNhKWZanhhzwznQAgcT5mOgFAk9JZXgcAnUJCZ7Q7duzQwQcf3PDY5/Opqqqq4XEgENApp5yiF154oe0VotNomOfkqQubmOkEAIljeR0ANK3lQeK0OgFAMkgodMrJyVFlZWXU402bNkXt4/P5VFpa2pba0MmE7T2hU/3PeDInAEhYs6ETx1cAXRyDxAGgc0godBoxYoQ2bNjQ8PiYY47RK6+8oq+//lqS9N133+mZZ57RsGHDnKkSnYK933I6Op0AIHEsrwOApjFIHAA6h4TOaH/84x9r2bJlDZ1M//u//6vdu3dr9OjROvroozVy5EgVFxfriiuucLJWJLlGoROZEwAkrPnldRxgAXRtAUInAOgUEgqdLrvsMi1fvlxeb90J8aRJk/S3v/1NgwcP1scff6zc3Fz97ne/00UXXeRosUhu9cPkGwaJc1EEAAnzeel0AoCmeL0eZt8BQCeQ0EcEWVlZOvbYY6O2nXnmmTrzzDMdKQqd0/6dTnwSDwCJ83o98no8iti226UAQFIKBHwKhSOxn7QYJA4AyYCPUeEYI5bXAYCTmOsEAE1LT2OYOAAkuzYtht60aZP++te/avXq1SorK1PPnj115JFH6txzz9WQIUMcKhGdhaHTCQAc5fd7FawNu10GACSlQBrL6wAg2SUcOt1777269dZbFQ6Ho8KGZ555RvPmzdPtt9+uG264wZEi0Tn4PNE/+Ol0AoC28XubuKBqFPIDQNeT5m/uUobldQCQDBLq258/f77mzJmjnJwc3XfffXrvvfe0ceNGvffee7rvvvvUp08f3XjjjVqwYIHD5SKZ+TzR304MEgeAtmF5HQA0ze9vptOJzAkAkkJCnU4PPvigcnNz9dFHH6lfv34N2wcPHqxjjjlG5513no444gg98MADmjlzplO1Isl56zud6rMmMicAaJO05i6oAKCL4xgJAMkvoY9Qv/rqK5111llRgdO+cnNzdeaZZ+qrr75qU3HoXBo6nfaETXQ6AUDb+JtdOgIAXVtzoZNFqxMAJIWEQqe+ffvK72/+bhFpaWnq27dvQkWhc2qY6WT4IQ8ATvA3tbyOmU4A0PzyOgBAUkgodPrpT3+qZ599VlVVVTGfr6io0LPPPqtzzjmnTcWhc/F5vHXXQXbdYzqdAKBt/D4uqACgKX5fM92gFh+CAkAySCh0uuOOO3T44Yfr2GOP1d///ncVFhYqFAqpsLBQf/vb33TcccfpiCOO0O233+50vUhiPo9HPmufbykyJwBok6aXjnCABQCfl5stAECyS2hYRLdu3SRJxhide+65jZ43xujTTz9t2K+eZVkKh8OJfEl0ApZlKcOXphrV/RvT6QQAbdPk0hEOrwAgr7eZbiY6nVq0atUqLVy4UDNmzNCYMWPcLgdAikoodBo/frwsDuSIId2bJiksyTBzBADaKK3JQeIcXwHA21ynE9cqzQoGgyooKFBJSYkKCgo0atQoBQIBt8sCkIISCp2WL1/ucBlIFQFP8wPmAQDxa2qmkyHUBwB5PSyvS9TixYtVWloqSSotLdWSJUt05plnulsUgJTEkRqO8qtzhU62sVUZqm20vTJUK9vYLlS0l6mtkQmHZIwts6cWY0caft8RakMRhSPu/j0AXVlaGjOdOjNjjCI2x1CgvXg8ljxNdjTR6dSU4uJiLV26tOEDDGOMlixZouLi4oZ9TLBKJsJYFABtR+gER3lN3beU1Uk+hX9/+ya9UfS5PivZ+0P2s5JivVH0ud7fvsm1ukzpdzKrXpX56HWZT1dKtcG6J2qqZN75R4fUULo7qFWfbtNHn21TbSjSIV8TQDSf1xP7gqqTHGO7utqQrXVf7qAzDWhHTS6xY3ldTMYYLViwoNFxad/tZvtmmVX/kln7pozNOSCAtiF0gqN8pnPd3rustrru/0PVe7ft+X39c66oKqu7qAwFpfKdUU+Z/R63Wwk1IRljFArbCtZywgG4wbKs2MPEyTA6jepgWBGbfzCgvTQ5Z5bQKaaioiKtXbtW9n5dmLZta+3atSoqKpIqyuo21lRIdDsBaKOEZjoBTfHuCZ06y53rxuQM1rbqcg3t0adh26he+dro26H+3Xq6V1juEFnhWsmfLnXPlrz/rNvu9ck6+scdU0KfbgqHbfl9HvXITOuQrwmgsUCaT8Ha/U766ZzpFLxeSyMH9+K27oALuOlRbPn5+Ro9erQ+/vjjqODJ4/Fo1KhRys/Pl8I5sjweqXu2LD/DxQG0DWdBcJQV8UiWZHWS66G+Gd01qne+Mvf5gdrdH9DhvQcoJ727a3VZXp+sQYfK6n+grB69ZfnqZmVZgQx5+g3qkBq8Ho8G9c9S/77u/T0AUOxOp04S7Hd1Pq9HfbIz3C4D6JoInWKyLEszZ85sFMpZlqVZs2bJsixZ/oCsIaNk5Qx0qUoAqYTQCY4KhsLyeTzigggAnBHwN25K7sgbCgBA50To1JS8vDyddtppDcGTZVmaMmWKcnNzXa4MQCpKKHR66623tHr1aodLQSqoCYbl9/jInADAIWkxZzpxkAWAZtHp1KypU6cqOztbktSrVy9NmTLF3YIApKyEQqcTTzxRf/rTn5yuBZ1cbSiscDgin9fbaWY6AUCyS0uLMX6R0AkAmkfo1KxAIKDZs2crJydHs2bNUiDA7CYA7SOhQeL9+vVTWhqDhRGtvCIoSfJ7vKpxuRYASBWBmKETy+sAQJJMEyG8ZTFFpCVjxozRmDFj3C4DQIpL6Gh86qmn6s0332zyII+uaXdFXdQU8Pn4FB4AHBJreR0/fwGgTsRuIoSn0wkAkkJCodNdd92lnTt36uKLL9auXbucrgmd1O7Kuk4nn8crDz/nAcARMZfXNXWRBQBdiDFGtt1ECE+nEwAkhYSW102fPl3Z2dkqKCjQE088oaFDhyo3NzfmrTdff/11RwpF8qvvdJIkvxXrFt8AgNaKPUic0AkAIk0FTtKem9fxKSgAuC2h0Gn58uUNvw8Gg/r888/1+eefN9pv/xAKqcsY09DpJEl+j0dcEgFA2wX8jX9UGzqdAECRSPPHwrq5ThwvAcBNCYVONie72E9ldW3Umnqf5VGti/UAQKrw+TzyWJbsfec40ekEAE3Pc6rHvAcAcB2LneGI3RXBqMc+fsgDgCMsy5J//yV2zS0pAYAuoqVOJ+Y6AYD72nwkrqio0H/+8x+9/fbbTtSDTqqkvCrqsWUkD8srAcARgf2GiRsTcakSAEgeoXBLy+s4FwUAtyUcOm3atElTp05Vr169dPTRR+vEE09seG7FihU69NBDo2Y/IbXtLKmM3mBsefh0CQAc0bjTieV1ABAKtRDAcy4KAK5L6Ei8ZcsWjR07Vi+++KKmTp2q4447TmafWRPHHnusduzYoSeffNKxQpG8akPhRsvrZAydTgDgEL+P0AkA9hcOtxQ6cS4KAG5LKHS67bbbVFJSojfffFPPPPOMTjnllKjnfT6fxo8frxUrVjhSJJLbztIqGe03X8TY8vLpEgA4Iip0Mkba/5gLAF1QS8vr5OFcFADcltCR+JVXXtHpp5+u448/vsl9Bg0apMLCwoQLQ+exa/+ldVJd55vFXCcAcELavsvruHMdAEiSQi10Oll8AAoArkvoSLxr1y4NGTKkxf2CwWCL+6Dz21HaOHSqvyhirhMAtN2+nU6GO9cBgKSWQyeW1wGA+xJKBHJzc7V+/fpm9/n44481aNCghIpC51ETDKuiMka4aNeHTvywB4C28vn2+XFNpxMASGKQOAB0BgkdiU855RQtXbpUH3/8cczn3377bb3++uuaPHlym4pD8tsVq8tJktlzUeRlLT0AtJnPu2/oRKcTAEhSbUuhk4cPPwHAbQklAjfffLMyMjI0btw43XXXXQ1dTy+99JJuueUW/ehHP1JOTo6uu+46R4tF8inesbvxxv3uqsQSOwBoG6+XTicA2F+LoRPnoADgOl8iLxoyZIheeeUV/fSnP9XNN98sy7JkjNF///d/yxijQYMG6ZlnnlH//v2drhdJJBKxtX1n49DJ7HdB5LUsMYIEABK3b6eTodMJACRJoVC42ectxjwAgOsSCp0k6dhjj9VXX32lpUuX6v3339euXbuUlZWlY489VlOnTlVaWpqTdSIJbd9VoUgkxifu+3c6eTyS3cInUQCAJkV1Otl0OgGARKcTAHQGCYdOkuTz+XT66afr9NNPd6oedCLF28tjP2H2X15nyZIlIz6dB4BEeKLmknAsBQDbNty9DgA6AUfi/8rKSn377beqrIw9VBqpp6mldZJkYnwK72GQIwAkLGqJCJ1OANBy4CQROgFAEkg4dAoGg7rzzjs1cuRIZWVlaeDAgcrKytLIkSN11113KRgMOlknksx3uyoUjrW0Top5QeSlvRkAEhZ13cRMJwBoeWmdmOkEAMkgoeV1paWlOumkk7RmzRr5fD4ddNBBys3N1bZt27RhwwbdcsstevbZZ/X6668rOzvb4ZKRDL5tammdFHN+k4cf+gCQsH0vnIwxEodUAF1cbQtDxCUx0wkAkkBCR+Ibb7xRq1ev1syZM7Vp0yZ9+umnWrZsmT799FNt2rRJM2bM0EcffaSbbrrJ6XqRBJpbWidJJkboZFkWnzYBQIKijp6G5XUAEE+nEwk9ALgvodDpueee0/HHH6/HH39c/fv3j3quf//+Kigo0NixY/WPf/zDkSKRXL7dXt700jqpyTvVefi0CQASYu+7oo7ldQCgUDyhE5kTALguoRSgvLxcEydObHafSZMmqby8mSVY6LS2fFvS7POxBolLkpdOJwBIiB2dOrlWBwAki7iW14m5TgDgtoRCp8MOO0xbt25tdp+tW7fqsMMOS6goJK/dlTUqKatqfic6nQDAUfa+YT6ZEwCotjae5XUS7U4A4K6EUoA5c+bo6aef1vLly2M+/8Ybb+jpp59mplMK2lpU2vwOJvZMJ6nu7kt82gQArWfvs6TOkDo1a9WqVfrFL36hVatWuV0KgHYU30wnJW3mxLEKQFeR0N3rdu/erZNPPlk/+MEP9MMf/lDjxo1Tv379tH37dr399tv617/+pf/6r/9SWVmZFi1aFPXa888/35HC0fEiEVuF28qa36mJwKme1/IobOL9ZAoAIEmRyD5BEzOdmhQMBlVQUKCSkhIVFBRo1KhRCgQCbpcFoB2Ewp2304ljFYCuJKHQaebMmbIsS8YYvfLKK3rllVca7fPCCy/on//8Z8NjY4wsyyJ06sS27djd4vp5E2n+eQ+dTgDQauG4L666tsWLF6u0tFSSVFpaqiVLlujMM890tygA7SL+TqfkO/fkWAWgK0kodJo/f77TdaATaGmAuCQZm9DJKca2pW2bpPTM6O0VJVLZDpkefWTt3in1yZe13z5O+W5XlYykfr27tcv7A4hP1MUVnU4xFRcXa+nSpTJ7/n6MMVqyZInGjx+vvLw8l6sD4LRQnIPEk01Tx6pBRx6mIw8cqYA3ocuzpFYbiui7kipl90hXZoa/0fP2Pn8XAFJPQke1GTNmOF0HklxFVVA7Sypb3jHS/KdOlmU1dMmhBd9ukNn8qWRJxtQNETbGyHy6UgqHZCrLpMye0s4iWaObv5tkIkrKa/TVlrqg0edlCDzgpviXkXRNxhgtWLCg0c+W+u033HADMwWBFBN3p1MSLa9r6lhlG1t/f+Iv8vz8Ih3db4g7xbWjr7eWald5jb71V+qowxp/CBAO153nhiNcHwCpKPWidLSLTd/sims/00LoJNV1O0UInVqWll73/16f6k+YLMuS/AEpHJICGdH7Oczn9TRcpPl9hE6Am0JxX1x1TUVFRVq7dm2j7bZta+3atSoqKtKAAQNcqAxAezDGNAQVklQTDqmqNhhz38xwbUeV1aKmjlXGNir+aqMqduySUjB08vu9kqS0Pf/fFD4bAFIToRNaFApHVFhcGt/OLSyvkySPLHH51DKr7wFSRnfJH5BlvbR3+6jxUvVuqVuWrKoyKTO7Xb5+j8w0HXlQXxlJ3dIbt0ID6DjB2s65jKSj5Ofna/To0fr4449l23svRD0ej0aNGqX8/HwXqwPgtFAoEnUnz4htq7KJ0MkfDnVUWS1q7lh10KGHaMLBR7pXXDs6cGBP9e2VoW4xltZJez/c9HpInYBURPsCWrS1qEThiN3yjmp5kLgkeSy+7eJlde8lKxA9T8nyp8nK6iOPzy8rK0dWO679z0j3EzgBSaA6mDwXTcnIsqyGm5zsv33WrFksrQNSzP5L6zrLf+PNHasuvuBCeT2peY5sWZayugeaHNdQ//fRWf4dAbROah7Z4BjbNtpU2PIAcUmSiX95HQAgfjU1hE4tycvL02mnnRZ18TJlyhTl5ua6XBkAp9XuN+euM51ZcqwC0NUQOqFZ23buVnVNfGvh67qc4pjVZBE8AUC8bNuoJrhPFynHzyZNnTpV2dnZkqRevXppypQp7hYEoF3sP+euufPKZDxicqwC0JUQOqFZ8Q4QlyTFsbSuHu2zABCfmtpQ1OwSQqemBQIBzZ49Wzk5OZo1a5YCgYDbJQFoB7Wh6HNOr6e5AdXJd/MajlUAuhIGiaNJZbtrtKu0Mu79TST+5R8MEweA+FRVR3ebWkn5uX3yGDNmjMaMGeN2GQDa0f4znXweT11LU4x8yUq+zEkSxyoAXUdCnU6FhYV66623VFVV1bDNtm3de++9OuGEE3TKKafo5ZdfdqxIuGPTNztbtX88Q8TrMUwcAOJTUbnfEmc6nQB0cfuHTpKaGMJtlIydTgDQlSTU6XTLLbfo+eef17Zt2xq23XnnnbrtttsaHr/55pt69913ddRRR7W9SnS4mmBYRdvLWveiVi2va2VBANBFVVTtdxtwjp8AurhgsPE5p8/jVSTOuy0DADpOQu0mK1eu1Mknnyy/v+5W6rZt6+GHH9bBBx+sLVu26IMPPlC3bt30m9/8xtFi0XG2FO2SbbfukyETZqYTADitUehE6gSgi9t/ppMkpTU71wkA4JaEQqdvv/1WQ4YMaXj8n//8Rzt27NAVV1yhgQMH6qijjtK0adP0/vvvO1UnOlAkYmtzYUnrXmSMjB1/6CRxBzsAiEdF5f6dTixPBtC1BWtjhE4+f6NtlmFpHQC4LaEz10gkItve27769ttvy7IsnXTSSQ3bBgwYoOLi4rZXiA5XtL0s5idIzTHh+IeI16PbCQCaF6wNN7q44tgJoKuLFTr5Y3Q6EToBgPsSCp0GDRqkDz74oOHx888/r/79++uggw5q2FZcXKzs7Ow2F4iOZYzRxq27Wv+6Vty5rh53YAKA5pXvrmm8kdAJQBdmjFFtbeNB4n6vt1EobzFEHABcl1DodMYZZ2jFihU688wzdd555+mdd97RT37yk6h9Pv74Yx144IGOFImOs7OkUrsrY1zktKQV85zqcdkEAM0rr4hxPI55hyYA6BqCtWGZJsKkNF/0PZIsMicAcF1Cd6+79tpr9eqrr+rZZ5+VJB1++OGaO3duw/OfffaZPvzwQ82ZM8eRItFxNn7T+i4nieV1ANAeymKFTkT2ALqwqpqmzzkDXr+Cob3P0+kEAO5LKHTKysrSe++9p48//liSdMghh8jr3buOOiMjQ88995yOOuooZ6pEh6iqrtV3OysSei3L6wDAeeW7qxtv9FgSdwUH0EVVV9c2+VygUacToRMAuC2h0KneqFGjYm4fMmRI1N3t0DlsKSppsl25WcbIRFq/vI7MCQCaVhsKqzLGxZXF3esAdGEtdTrJkupPZwmdAMB9nLlCkhSxbW39tjSh1yaytE6i0wkAmlMWa4i4xCBxAF1aVTOdTpYlpXn3fqZuGdpCAcBtCYdOr732miZPnqy+ffvK7/fL6/U2+uXztamRCh2oeHu5akMJdCspsaV1EtdNANCc0vIYS+skiU4nAF1Yc51OkhTYN3RiphMAuC6hVOjZZ5/V2WefLdu2NXjwYB188MEETJ3c5qKSxF+cwJ3rAADNazp0IrEH0HU1N9NJkgI+v3YH6zpFWV4HAO5LKCm6/fbblZGRocWLF+ukk05yuiZ0sPKKGpWUVSX8+kSX10lRy+4BAHsYY5oMnZjpBKCrqg2FVR1sodPJt3euk4fQCQBcl9CZ6xdffKGf/vSnBE4pYktbupzUttCJaeIA0Fh1TajpJc90OgHoosorgi3u47Es+T11d9Wm0wkA3JdQ6JSTk6Nu3bo5XQtcEI7YKiwuS/wNjJGxWV4HAE4qaWppnUToBKDLKt/dzLFxHwGfX5LkYZA4ALguodDprLPO0muvvaYws3w6ve07disciST8+rZ1OYlGJwCIobS5Jc+WJQ6eALqisoom7uq5n7rQyUh0OgGA6xIKnX71q1+pV69eOvvss7Vlyxana0IHKtrehi4nORA6AQAaaXKIeD0Pc50AdD3l8YZOXh9L6wAgSSQ0SHzUqFEKhUJauXKlnn/+eWVnZ6tnz56N9rMsSxs2bGhzkWgfoVBE3+2qaNubROh2AwAnRSJ2yxdWLLED0MWEI7YqK5u/c109r8cjH4dJAEgKCYVOtm3L5/Np0KBBDdtMjE8TYm1D8ijeUS7bbtu/EZ1OAOCssooa2S39/OQOdgC6mNKyKplW3PM4jeMkACSFhEKnTZs2OVwG3FC0rbzN72EibQudCCYBIFpZS0vrVNdJDABdyXclla3aP02WGCMOAO7jI4AuqiYY1s5W/vBuxBgZltcBgKNanOckiUHiALqaHa0cCcHyOgBIDgl1Ou0rHA7ryy+/VFlZmbKysnTQQQfJ52vz26KdFX9X1qoW5VjaHDjR5AQAjcQVOnExBaALCdaG4x4iXs9LNz0AJIWEO51KSkp08cUXKzs7W4cffrjGjRun0aNHKzs7WxdffLF27tyZcFFPPPGELrnkEh111FEKBAKyLEsLFixocv/y8nJdffXVGjx4sAKBgAYPHqyrr75a5eVtXz6Wqr79bneb36OtoROnAgAQrTYUVlVNHINyWV4HoAvZkUB3vscYWST0AOC6hFqSSkpKdNxxx+nLL79Unz59NH78eOXl5Wnbtm3697//rccee0xvvvmmVq5cqd69e7f6/W+++WZt3rxZOTk56t+/vzZv3tzkvpWVlZo4caJWr16tU045Reecc47WrFmjBx98UMuWLdM777yjzMzMRP6YKSscsVVaVuXAG7V1iDixEwDsq2x3nJ/kMyAXQBfS2qV1Ut2Hox4CegBwXUJnrXfccYe+/PJLzZkzR5s3b9ZLL72k+fPn68UXX9TmzZt100036auvvtKvfvWrhIp67LHHtGnTJn333Xe69NJLm933vvvu0+rVq3X99dfr1Vdf1T333KOXXnpJt956q1avXq377rsvoRpS2a7SypbvjBQHE4m07fVkTgAQpTze0InQHkAXYYzRdwmETrIj3HQBAJJAQqHT888/rxNPPFF33nmnunXrFvVcRkaG7rjjDp100kl6/vnnEyrq5JNP1uDBg1vczxijxx57TN27d9ett94a9dycOXPUq1cvPf7449whbT+JtCjH1Obldfy7AMC+yuKdWcLhE0AXsbOkUsHaVp5z2raMsVleBwBJIKHQqaioSGPHjm12n2OPPVZFRUUJFRWvr776SkVFRTrhhBMaLaFLT0/XhAkTVFhYqPXr17drHZ1Nm+9at4ex2xg6EQYCQJSy3fHcuU4idQLQVRRuL2v1a4xd141PoxMAuC+hmU49e/Zsds6SJG3evFk9e/ZMqKh4ffXVV5KkESNGxHy+fvtXX33V5D5dTSJ3/4jJMEi8rYxty3y6QqZwvawhh0k9+sh8+W9Z6d2kPgOk6t2yDjhYVq/cqNfY696S1aO3rCGj6raV75TZ9LGs7FxZgw6O/bWMUTAYbLGmb4p3q3B7hWzbyGNZys3ppsH5WbIsqyEkNMaopib6e+jbHZXaWVqtgf16SJb0zbbd6tMzQ/37xp6nVn+DAAB7hcMRVVXHMUQcSWNzUZnKK2o1dGBPde+WJkmybaNQ2JbEhytAW0UitooTufnNnnNUj2Up0kX/M2zq3M8UfiVTsk3W4ENk9egT9/tx7gYgUQmFTpMmTdLTTz+tmTNn6uSTT270/Ouvv66nn35a06ZNa2t9zSorq/vko6lwKysrK2q/WILBYNQBOdXveLez1KEupzYGThIn46rYJbPlc2n3LplNRurWU9q2SSaQIe0sktUrT6boq6jQSXZY2l0is7tE6j9MViBD5tuvpYpSmYpSacBwWd7G/1kHg0HNnj3bkbJLSkra/F4FBQVKT093pB4gVeyubDkYRvIIhSMq3F43Z+bb7yo1YnBd6FRRVSvbrvv5Vv//ABKzfVeFwuHWzxCtP0/tysvrnDz3kzh3A5C4hEKn2267Tf/85z916qmnavLkyZo4caJyc3O1bds2LV++XC+99JK6devWaM5SMrr77rs1b948t8voME4trVMbl9ZJkt3Ve50ys6V+g6Rwray8A6XsHJnKUlnpmXWdTsFKWf32m23m8UqBdKl7bymt7ge/1fcAmd27ZGX3ixk4AegcWhU6dfXQPgn4vB7l9Oqm8oqg+vbKaNiemeGXZ8/wAo+n617wAk4o2tb6pXXSPh+OWl07eAKAZJDQFeqhhx6qV199VTNnztQ///lP/fOf/4xafjNs2DAtWLBAhx12mKPF7q++w6mpTqb6rqXmlvnNmTNHV199ddRrDjjgAAerTC67yqoceZ+23rlOotPJ8vrkPepUSafu3Th4VPOv8XjlGXNq9LbeebJ658X9dY+YdKk8Xn9rSpUkff7B3xWurZQvLVMHH3N2q19vR0Jas/z/Wv06oKtoVehk2+1XCOJiWZZGDu7VaLvX65Hf523YB0BiQqGItu9M4K51UvTNbrrof4aBQEAFBQXN7nPNNdeopKREvXr10v3339/i+wFAIhJuizj++OP1xRdfaMWKFfroo49UXl6urKwsfe9739MJJ5zQISda+85siqWlmU9S3QG0qxxEI7atyiqH5oXYbQudunrg5CaP1y+vr/Wh02HHT2+HagDU210Z/7w9jqEAUt03xaWyEwzY9x0D4emiqZNlWS0uh6u/XotnXwBIVJvW4liWpXHjxmncuHFO1dMqI0aMUH5+vlasWKHKysqoO9jV1NTorbfeUn5+voYPH+5KfcmmorLWsQsV08bQyeaCCQCitOpDAUOnE4DUZYzR5sJdCb7YmY58AIAzPG4X0BaWZenCCy9URUWFbr/99qjn7r77bpWUlOjCCy+kvX2PilZ8it4iQicAcEw4YqsmGIr/BSyvA5DCdpRUqjLBu3nWdTntPc/kOgAA3BVXp9Ptt98uy7L085//XL17924U8DTFsizdcsstrS7qscce0zvvvCNJWrduXcO25cuXS5KmTZvWcGe866+/XkuWLNF9992njz76SGPGjNGaNWv00ksv6cgjj9T111/f6q+fqsodvDOSaeMFD0tDAGCvyqrWDBFv+B8ASEkJdzlJUiQ6wGeQOAC4K67Qae7cubIsS2effbZ69+6tuXPnxvXmiYZO77zzjhYuXBi1bcWKFVqxYoUkaciQIQ2hU2ZmppYvX6558+bpmWee0fLly5WXl6errrpKt912W9SSu65ud0USdTpxwQQADVq3tI5lIwBSV1VNrbbvSHCAuKLnOUkSjU4A4K64Qqdly5ZJkgYNGhT1uL0sWLBACxYsiHv/nj176oEHHtADDzzQfkWlgFbdGakFbVkrbwydTgCwr9YsI2lrpykAJLMthSUybfhw0oT373QCALgprtBp4sSJzT5G8qsNhVs3L6Q5xqgtSztsBuACQJSqmlZ0OhE6AUhR4Yitrd+Wtuk9TGT/811iJwBwU6ceJI74VVU7FDhJe0KnxDFEHACiVde04hhNcA8gRRUWl6o2FG55x+aE91teR+gEAK5KKHT65JNPtGjRIpWXlzdsq66u1mWXXaYBAwZoxIgR+tOf/uRYkWi7YG0bf4Dvw7TxgofQCQCiVbfigwGW1wFIRcYYbdy6s21vEok0Pk8lcwIAVyUUOt1555365S9/qR49ejRsu/HGG/Xoo49q9+7d2rJliy699FK9/vrrjhWKtnFsaZ3kQKcTF0wAUM+2japbc4xu440cACAZbduxu1Xz7WIx4ba9HgDgvIRCpw8++EAnnniirD23gwiFQiooKNAxxxyj7du3a+PGjerbt68efPBBR4tF4mqCznU6tWWeiG3T5QQA+wrWhlt1cwVD6AQgBbW5y0mN71wn0egEAG5LKHTatm1bw53sJOn999/X7t27demllyo9PV35+fmaOnWq1qxZ41ihaJua2uTodKLLCQCitboTtQ13DwWAZFRaXq1dZVVtfh8TotMJAJJNQqGT1+tVMBhsePz222/LsiydeOKJDdv69OmjHTt2tL1COCLoYKdTaz6R3x/znAAgWmtDJzqdAKQaJ7qcpNidTrQ6AYC7EgqdhgwZomXLljU8fuaZZzR06FANHjy4YVthYaH69OnT9grhCEeX1ynB4MhIETqdACBKq4/PhE4AUkhNMKTi78pb3rElRjLhWCE+qRMAuCmh0Om8887TmjVrNHbsWE2YMEGrV6/WOeecE7XPf/7zH40YMcKRItF2Tt69LlEETgDQWKs6nYyh0wlAStlcWOJIJ7yJhBTrg1EiJwBwV0Kh0+WXX64zzzxTH374od555x2deuqpuvHGGxue//DDD/XJJ5/opJNOcqxQJM4Yo1DI/YsUltYBQGOt6XQyzHMCkEIiEVtbikocea/YXU4AALf5EnlRIBDQ3//+d5WXl8uyLPXo0SPq+aFDh+qjjz7SkCFDnKgRbRSO2DKJLolzEJ1OANBYMNSKTlTb/a5VAHBK0fYy1bbmGNgcQicASEoJhU71srKyYm7PyclRTk5OW94aDgqH3Q97bGPaNIAcAFJVa270EHNILgB0QsYYbfpml3PvR+gEAEmpTaHTRx99pCeffFKff/65qqqq9Nprr0mSNm/erPfff18nn3yyevfu7UihSFw4CZZj2Lb7wRcAJKNWzdxLguM5ADhhV1mVyitqHHs/QicASE4Jh07XX3+97r///obuFcvaO6bPGKNzzz1X999/v6688sq2V4k2SYZOJ5bWAUBjkYitUDj+IIlOJwCp4pviUufezBiZJpYf02cPAO5KaJD4/Pnz9Zvf/Eb//d//rbVr12rOnDlRzw8ZMkTHHHOMlixZ4kiRaJuQw6HTvgFjPIwxDBEHgBhaNc9JhE4AUkMkYqt4e7lj79d8lxPnoADgpoQ6nR555BEdcsghevbZZ+Xz+ZSWltZon4MPPrhhuR3cFXF6OYbVuqwywtI6AIipNfOcJEmETgBSQPGO3QpHnDs/bDZ0InMCAFcl1On06aef6pRTTpHP13RmlZubq+3btydcGJzjdKeTWtnpxNI6AIitNtSKDwXsiAzHUwApoNDJpXUSd64DgCSWUOjk8/lUW1vb7D5FRUXq3r17QkXBWY4P8W5Fp5MxYmkdADShNUPETZguJwCdX00wpB27Kh19z+aWHnMWCgDuSih0Ovzww7Vs2bImw4z6O9mNGTOmTcXBGZGIsz9uLU/8nU4RmzstAUBTWhU6sbQOQAoo2lYm43AUxPERAJJXQqHT7Nmz9cUXX+iyyy5r1PFUXl6umTNnqri4WBdddJEjRaJtHJ+p1IpOJ5bWAUDTWhM6Mc8JQCrYvqvC+Tdt7vhIxz0AuCqhQeKzZ8/W66+/rj/96U968sknlZ2dLUk65phj9Nlnn6myslIzZ87U//zP/zhZKxIUcXBQo6S4Zzpx1zoAaF7rOp2YWQKgc4tEbJWUVTv7pnak2c4pzkQBwF0JdTpJ0l/+8hc9+uijGjp0qAoLC2WM0b///W8NGjRIf/zjH1VQUOBknWiDiO38j1vL443j69LlBADNYaYTgK6kpLza8VmjpsW7NBM7AYCbEup0qnfRRRfpoosuUnV1tUpKSpSVlcXw8CTkeKeTJHm8UgvzmlhaBwDNq403dDLMLAHQ+e0scXaAuCSZFs5HiZwAwF0JdzrtKyMjQ/n5+QROScqNTiebpXUA0CxjTNydTnWBE8fUeDz11FOaPn26nnrqKbdLAbCfnaXOh04tfQjK6SgAuMuR0AnJrV06nbzNh04srQOA5oUjtsLxHp+Z5xSX8vJyLV68WLZta/HixSovL3e7JAB7hMMRlZU7PM9Jajl0IrAHAFfFtbzuwAMPTOjNLcvShg0bEnotnNMeAVBLnU4srQOA5gWDrRkiztK6eDzwwAMye9oajDF68MEHddttt7lcFQBJ2l0ZbJcueNPCea6h1QkAXBVX6GTbtqw471i2Lw7yySESaYd/h2ZCp4htp+S/vTFGwUhYAW+bRqHFZFdVyERC8qSlywpk1H292hrJ45Xl8++twbZljC3L2tukaGoqpbQMWR4aF4HOpKY1Q8RDte1YSedlglWSPyDL49W6dev05ZdfRj3/xRdfaN26dRo1apQUrJIC3RI6n3FKsDYsy2PJ2EaBNOd/lgDJrLqmnTo2Wwqd2uerdgrG2DIVpbLSu8vyp7XutTVVMh6PLBlZaRlNvL9RMBhs8rnakK00v6fhuBsKR+SxLIUjRn6fRx5P3XZ7zygQ27ZVU1PTsJ/X27pz20Ag4OoxHkBscZ3xbNq0qZ3LQHtqj+V1zXU6pWqXUzAS1muFn+v43APVK9DNsfc1hV/JvP+CVL5Lpv9Qacypks8v89l7ki9NOmLS3k/xaiplf/y2vIdPrHvtls9lvvlCyuoja9Q4x2oC0P6CwfgvwEyY5XX7M99+LbNxndSth+zDJ+jhhx+Oud/DDz+sP157sawdhbL6DpRGjOngSuts31Wlrzbv0s6yGvXpmaHhg7KV2yfTlVoAN7Rb6NTCeWcqfhAaL/ujN6T1H0lZfaRJZ8tKj++YY4rWy/56jbSrWCZnoDyHjJXVK7fRfsFgULNnz3as3tLS0ja9X0FBgdLT0x2rB4AzaI3oAtplvlIzM52cvhVusjCSbGNrd6jG2fetKJFqa6RQUCZYI1WVSVXldZMvQ0Gptjp6CmbZjr2vrSyt+01lmaM1AWh/cXc6cee62OqPf9UVWv2fj1RRURFzt4qKCn207mNJknHxWFlZFZIxUk1NRLZtVFlFkIiupboVQXurtBAqdd3ISXXnjMau64qvqYr/dZVlUiQs1VTWdZJVMR8PQOLo7e4C2qXTqYklZhHbTtkf7n6PRyN75mpgZraj72sNGSXV1sjs3iWr7yApf4RkWbLCtXXL5rr3kuqXzvn8skZP2vvaoYdL6ZlSjE+fACS3mjg/9TeRkLr4ZVNsgw6R5fVLWX30vV556t69e8zgqXv37vreKVNk7fhG6nuAC4XWGZjXXZYl5fbpJp/PqwH9uOMvupb26nRqrpOp7qmue/y0vneS9MW/pb4DZWX3jf+Fgw6Vx5cm03+YrEA3KW9oiy85YtKl8nj9Le4Xy+cf/F3h2kr50jJ18DFnt+q1diSkNcv/L6GvC6BjEDp1Ae0y08myZHl8Mnb0p++pfNc6n8erg7KdD3esQDdZh09o/MSgQ/fus2d9upWWLk9Wn73b0zOloYc7XhOA9lcd5yBxltbFZqVlNBz/LElXXHGF7r777kb7XXnllfJm9ZayendwhdH8Pq+GDOjpag2Am6pqOn42XVe/c50nu5907ORWv84K1B1fWzMdyeP1y+tLLHQ67PjpCb0OQOfA8roUZ4xpl04nSbJ80ZmlMak7zwkAnFYT71IThojH5fDDD9fIkSOjth100EE67LDDXKoIwL5qayPt88bNdjp17dAJAJIBoVOKs23Tfp/y7LfELmK308kEAKSgeJea2GFCp3hdffXVeztDLUtXXXWVyxUBqOfGTcUInQDAfYROKS7cTl1OUuO5TnQ5AUB8IhFbtaE4ltcZydDpFLesrCxNnTpVHo9HU6dOVVZWltslAdjD40LqxJkpALgvrplOt99+uyZNmqQJE2LMnUFSa6+ldVJ06GSMkc2nSQAQl3jv4mTCterKQ3ATcdZZZ+mss85yuwwA+7E87RQ6NRNmGWO70mEFANgrrk6nuXPnavny5Q2PvV6v7rjjjvaqCQ5qz04n7XOHinAKDxAHAKdVV8cZOtHlBCBFtFunU7OhE6E9ALgtrtApMzNT1dXVDY+NMRzEO4lwuL07nep+0LO0DgDiF+9dnEwo2M6VAEDH8LRTp1NT72pMV793HQAkh7iW1w0fPlzPPfecfvKTnyg3t+6W8aWlpdqyZUuLrx00aFDbKkSbtGunkyVZPr8itUFCSABohXiHiJtaQicAqaGjO50Y+wAAySGu0Omaa67R+eefr7FjxzZse+ihh/TQQw81+zrLshQOxzEoFe0mEmnfO8pZPr8iweqWdwQANKiKI3QyoVoZw11BAaSGjHS/Sne3wzmjFXvhBqETACSHuEKn6dOna9iwYXrxxRdVWFioBQsWaPTo0TryyCPbuTy0Vbt2OkmS18fSOgBopcqqljuYTG1NB1QCAB2jW7e09nljT+zQiS58AEgOcYVOknTcccfpuOOOkyQtWLBAp59+um699dZ2KwzOaM+ZTpIUsix+qANAKxhjVBXHIHFCJwCpJDOjfUInq8lOJz4UBYBkEHfotK9ly5ZpyJAhDpeC9tDenU7Vti1vu34FAEgttaGIwi0tfTZGNneuA5BC2it0ijXTyWaIOAAkjYRCp4kTJ0Y9rqysVHl5ubKyspSZmelIYXBGONy+80CqIhH1sCyJbicAiEtldcthkl1bI3HJBCCFdMsItM8bx+h0sm2OnwCQLGL3o8YhFArprrvu0siRI5WVlaWBAwcqKytLI0aM0F133aXaWj6hTQbt2elUEw7JNkYRi14nAIhXVVXLPx9NTVUHVAIAHSeQ5pXPm/ClR9NizHSyxdI6AEgWCXU6VVdX65RTTtHKlSvl9Xo1cuRI5eXladu2bdqwYYNuueUWvfDCC3r99deVkZHhdM1ohfac6VS9Z+lHxOuRl5/tABCXipaGiBvDPCcAKceyLGX1yNCu0kpn3zdW6ESnEwAkjYQ+brjvvvv07rvv6pxzztHXX3+tzz77TMuWLdOnn36qjRs36mc/+5nee+893XfffU7Xi1Zq704nSYp46HQCgHhVtNDpZGprZBiACyAF9cpqhw+j91teZ4wRE50AIHkkFDr97W9/01FHHaUnnnhCAwcOjHouPz9fixYt0lFHHaW//e1vjhSJxLVX6BS27YZBuIROABC/yurmO51sltYBSFG9enZz/k3363SK2IT2AJBMEgqdNm3apJNPPrnZfX7wgx9o06ZNibw9HNReg8Rrwns/qSd0AoD42LZRVXODxFlaByCFtUenk7Vfp5PNzW0AIKkkFDp169ZN3333XbP7fPfdd+rWrR0+zUCrRNppTXtNKLTPI0s2wRMAtKiqprbZWSMsrQOQytLSfMrs5vBd7BqFThxDASCZJBQ6jR07Vn/729/0ySefxHz+008/1d///ncdd9xxbSoObWe3w/I6Y/bOc2r4OjGGOAIAolVUsrQOQNfmeLeTJVmyJNV1k9LnBADJJaG71910003617/+paOPPloXXHCBJk6cqNzcXG3btk3Lly/X/PnzFQqFNGfOHKfrRSu1R6dTbSQss1/rcsTjlU+hJl4BAJBaGCJujEywuuOKAQAX9M7upm+KS519U49HsiOK0OUEAEknodDp+OOP15NPPqkLL7xQf/jDH/TII480PGeMUc+ePbVw4UKdcMIJjhWKxETaodOpNtI4XGKuEwC0rLlOJztYzR2XAKS8nF7dnX9Ta0+nE6ETACSdhEInSTrjjDN06qmn6vnnn9dHH32k8vJyZWVl6Xvf+56mTp2qHj16OFknEmCMaZc7eAQj4UbbIiyvA4AWVVQ1HTqZIEvrAKS+jHS/MjPSVNncTRVay/LIGIaIA0AySjh0kqTu3btr+vTpmj59ulP1wEHNDatti9pw49DJtjx1nzLxwx4AYjLGNN3pZIxMkLvWAegacnp1V2X1Lsfez7IsupwAIEnRnpLC2mNpXcS2m+ieshSx+HYCgKZUVYea7D41oSBL6wB0GX16ZTr+nsxzAoDkREqQwtpjiHispXUNX8/LXCcAaMruyqY7mehyAtCV9OnVreGOc04wslhaBwBJitAJrVLbXOhkEToBQFN2NzdEvJbQCUDXkeb3KatHumPvZxu70Z2VAQDJgdAphbXHUo1wJNLkczbDxAGgSU3NczKRiEyMu4ICQCrrk93NsfcKsbQOAJIWKUEqa4cPfEJ206FTxEOnEwA0pbyJ5XWmtrqDKwEA9/XOdm6uU6SZD0UBAO4idEph7dFlHG4mdDKWVXcHOwBAlIhtq7Iq9u3BTZguJwBdT+9sZ+Y6GSNFmjk/BQC4K6HQyev16mc/+5nTtSDJhW27he4p7mAHALFUVtU2PW8k3PSsPABIVX6fVz0dmOtUGwm3zyetAABHJJQQZGVl6YADDnC6FjjO2R/AzXU51bNZYgcAjeyuaObOdcxzAtBF9XZgrlMwEnLwPngAAKclFDodc8wxWrNmjdO1wGFOf+bT3BDxehGGiQNAI03euc7YMiwLAdBFOTHXqTYclkWnEwAkLV8iL5o3b54mTpyohQsXasaMGU7XBIc4/alPJI47g3S2TqdgJKytFSXqm9FdPdMyGrbbxmhLxS4FvHv/EwnbEYXsiPzt9Gc0JcVSTZWUO0TWnvDOGFvatkUmUrf8xtjcnQXojJoKnQxL61rFGKNgMCi7pFj6dqOUO1iePvlR+9jBKunLVVLfgbJ69JYp2y7ZtpTZU1ZNtYyMLBkFBgyT5/9n777j5Crr/YF/nnOm7+7Mtmx6ISEFEooEQiehBoEL0otXgcgVLj+VpigIEgRBvIB4Ua+iBvAqzXpFlKYUEVQQIdSQ3jbby8xOPeX5/bHZzc7uzO6ZmTP98369eJE9c8qzu8kzZ77n+/0+ruxKe4IDcQxENExu8kFVM3vYYpoS7d1heNwO1Hqd6OiNIFDrRq3PldVYiMpZg9878U4TiBsaXPlYPScHQ3NVTzyC/kQEs2oaoGZ5/+h2uyFy7Jkqe9qARBSYPBtCDN1jyuH7SyKifMoq6PTss89ixYoVWLVqFe6//34sW7YMkydPHjMhCiFw88032zJQylymN8ITMS08RTLLrJH42p6daIv0Y2PIgZUz9h3eviPci3d6dgIAzN3BNs008UFvG/Zvmm77OGQkBPnh3wGJwad10+YNvtCxDXLT20Bid2mOHoc0dAg1q3+6RFQk6crrmOWUmXg8jlWrVtlyrh/f8Dn49jsi4+N0w8T7G7thSomEZmDO9EBGx+/qHMDWXUEICNTVOBEMJ+B0KDhkydSMx0JU7lwuB7weJ6Kx7MqMddOAaZol19PJzrlqzZo18Hiy730lI8HBe0zsvsecOnfwhe5WYPdCFnwvIqJ8yuqT6+rVq4f//Oabb+LNN99MuR+DTsWlKPYGgCxlOpVZI3HP7uCNR3EmbXcrg9sVoWBkzpgnX8Ee1QEoDsDQAZd7z3bn7puM4WCeAMrsZ0xU7TTdQDTOvk2lRjizyywSAnCoChK6Aacz8/nY6RzMdlBVAbdLBcKDDZWJqlWgzpt10Cmu61CYBT4+1TH4n6EDI7M7nSPuN9kVi4jyKKtP0C+88ILd46A8UG3ur2Ql00kKMXhHXmJPnNJZ3DAN03z18I8qsZjs82P51PlQhYo/7g74uFUV8wMteRmHcHuBA48FtAREbf2e7Y1TgANWAO5ngEgccLqHS++IqDyk7edEGXO73VizZg1kIgbZ3wnhbx6cP0e47rrr0Nvbi4b6AO7+r/8CIkFICAiPF4jHIFUHhJ6Au2lyVmNQFQX7L5yEeMJAXU3mgauWRh98HgecDhUup4LJTTXweZ0TH0hUoQJ1HrR1BrM6NmHoUCw8FC20obkqYRgIG3E0uMY2TB+eqxoacM8994x7rlwItw844FhAH3WPGWgefNAZjvLekojyKqug0/Lly+0eB+WBoggICEib6txNS0+SBEyhQJHlkaarCIEmT+omln6Xd9S+Ss419eMRbh/gHntTImoCw/X3+bw+EeXHeCvXUWaEEINlJh4P4K9Puw8ACEWFt6YWqKnd82KdPeNwOVW4nNlnJ43s3+Svze0DJVG589dm39epVINOQ3OVB4Afqe8zh+eqoXktn+Px+ACkuMdk9jwRFQBnmgomhICi2heksJLpBJRfiR0RUT4x04mIKL1AXfYBl4TB8joiolKXdXRA13V8+9vfxrJly+D3++Fw7Emaeuutt3DllVfio48+smWQlD07S+xMixlTJlN0iYiGjRd0Yu4iEVU7t8sBlzPz4gvNMAAJqAw6ERGVtKzK66LRKE466SS8+uqraG5uht/vRzgcHn59r732woMPPojGxkbcfvvttg2WMqfa2UzcYpUeM52IiAZJKccvr8tyCW0iokri8ziR0PSMjkkYg/urXHmNiKikZRUduOOOO/DXv/4Vd955J9ra2nDZZZclvR4IBLB8+XI888wztgySsufMoefEaFZ7Q0n2HSIiAgDEEzo0Pf0HIqEy6ERE5PFk3kw/bmgQ0oQowZ5ORES0R1ZBp8cffxwrVqzA9ddfDyFEyubGc+fOxbZt23IeIOWmGMswmww6EREBsNDPSVHZyJWIqp4vi6CTZhjMciIiKgNZ3elu27YNhxxyyLj7+P1+9Pf3ZzUosk8uq+tki5lORESDLDURV7OqdCciqhjeDINOUg6W17GfExFR6csq6FRXV4fOzs5x99m4cSMmTZqU1aDIPtk0ZkyLPZ2IiDISCo/Tz2k3waATEVU5r8eV0f4JQwck4DAy6wNFRESFl1V04LDDDsOTTz6ZNpNpx44d+MMf/oBjjjkmp8FR7uzs6WQVM52IiAYNDEyc6cSgExFVO487s3kwYWgAJBwmg05ERKUuq6DTl770JfT09OCEE07Aq6++Cl0fnPAjkQj+9Kc/4aSTToKmabj22mttHSxlztbyOsuxJAEw8EREVU5KiYGIhaCTM7Mn/ERElUZVMvtIEjf0wX5O0mIaPhERFU1Wj1ePOeYYfO9738MXvvAFHH300cPb6+rqAACqquL73/8+li5das8oKWvF6OkEDGY7Cd4IEFEVi8Y16MbE/UaEg0EnIqpuiprZw8qErrO0joioTGSd03/FFVdg+fLl+MEPfoC///3v6Onpgd/vx6GHHoorr7wSixcvtnOclCU7ezoJCEiLjZ0khPXEKCKiCjRgpYk4AKgqhKJCchUmIqpSmWQ66aYBwzThZdCJiKgs5BSR2GefffCd73zHrrFQHrgzrJEfjxDWs5iZ40RE1c5y0AmDJXYyHs3jaIiISpeqWH9UGdMH+zmpBgP1RETlgMuMVTiPy95MJ+s7M8+JiKpbyEI/pyEssSOiaqZkkOkU1zU4dweeiIio9OUUkfjrX/+Khx9+GG+99Rb6+/sRCARw4IEH4tOf/jSOOuoou8ZIOXA6VSiKgGna8MacQRyJtwFEVO0GwgnL+wqnO48jISIqbYoiLLdxiOk6vIZWgFEREZEdsgo6SSlx5ZVX4oEHHoDcXW+lKApM08Qbb7yBn/zkJ/jsZz+L73//+xDMeCkqIQTcLieiMesfftKeK6MuTfy9E1H1klIinEmmE1ewI6IqZprSUsBJMwyYpsEm4kREZSSr8rp77rkHP/zhD7FkyRL84he/QFtbG3RdR1tbG5544gksXrwYDzzwAO699167x0tZ8NjU1ymTMJJksJGIqlg8oUPTM+g3IgSE6szfgIiISphhTrzSJwBE9cRgwIkrJBMRlY2sgk4PPPAA9tprL7z22ms4++yz0dLSAgBoaWnBOeecg1dffRWzZ8/GD3/4Q1sHS9nxuO35IMOsNSIiawYimWeXssSOiKqVrlsLOsV0DS6dpXVEROUkq6DT9u3bcdZZZ8Hn86V8vba2FmeddRa2b9+e0+DIHnY1E2fIiYjImkxK64awxI6IqpVhTBx0klIioSXgZD8nIqKyklXQacaMGYjFYuPuE4/HMWPGjKwGRfZy21Vel1GmE9Oeiah6ZZfpxKATEVUn3ULQKaprcOgaS+uIiMpMVkGnVatW4YknnkB7e3vK13ft2oXHH38cl112WU6DI3vYlumUQdCJWVFEVM2yynRSneDsSUTVyErQKaYlWFpHRFSGLEUjtm3blvT1BRdcgNdeew0f+9jHcNVVV+Goo45CS0sLOjo68Je//AX//d//jcMPPxznnXdeXgZNmbGrp1NG+BCKiKpYJJrFiqECEKoDkqUjRFRlEtrEq9HFtDhquWodEVHZsRR0mjNnTsosFyklbrzxxpTbn3zySTz11FPQdb45FJt9q9fxCTwR0URMUyISyy5wJBxOBp2IqOpEJ5gz47oOVYuDTzWJiMqPpWjEpz/9aa5cVsaKkekkeFNARFUqEktAZtlzRDicQOaVeUREZW2ioFNMT8ClZZFBSkRERWcp6PTQQw/leRiUT6qqwOlQoelGTudh2JGIaGJZldbtJhxFKIcmIiqyCYNO8Si8Zm73sUREVBxZNRKn8lPobCfBlUWIqErlEnSCyqATEVWfWDx90MkwTSjxaAFHQ0REdmLQqUrY0tcpg1QnBp2IqFpFotn3ZBKqPT34iIjKyXh98KJctY6IqKxlHXR69dVXceaZZ2Lu3Llwu91QVXXMfw4Hb55LhdtVyN+FZNCJiKpWJJZDppMAhKLaNxgiohKXSOjQx2kBkYiFIaRZwBEREZGdsopE/OxnP8PFF18MKSXmzp2LZcuWMcBU4uwIOmUWR2LQiYiqUy6ZTsBgtpNk7xIiqhLBcPrVE6QEEI8UbjBERGS7rCIRt912GxoaGvDHP/4RhxxyiN1jojxwOXN/ci4tBpKY5URE1UpKiWgumU4AoDoAjUvYEVF1GAjH0r6W0BNwsLSOiKisZVVet23bNlxwwQUMOJURlx3ldRZjSQqDTkRUpXTDhG7kVgYiVJbXEVH1CA6kD7InIgOZptoTEVGJySroNGfOHCQSOT7JpYJyOXMPOpnMdCIiGtdEy35bwp5ORFRFQgPpM51kPFzAkRARUT5kFXS64oor8Pvf/x49PT12j4fyxO2yobzOYjBJYbNHIqpSdgSd2EiciKqFlBKhSOpMJ6nrEBpL64iIyl1W6S9XXXUVNmzYgCOPPBI33XQTDjjgAPj9/pT7zpo1K6cBkj3syHSymsBUqUGnhKHj1fZN+FjTDHgdLlvPLRNRyH/9CTLYA7Hf0VCm7DXxMT1tkDvWQUyaCTF1rq3jIaLsVFqmkyFNvN29A3FDxwGNM6AYJiK6hrXdO+BzurGkYSoUIbC+vwOd0QHs0zAFDW7fhOd1u90QQtgyRtm+FbJ9C8S0vSGap4953dy1EXj/NUifH6ImADjdEHsfBOFMPY9LKRGPj99TyzQlNu3sh6YZmDezfkzfRNMcfB+MxXW8s64Vc6YHsGlHPwSAeTProarWn/nZ+bMiKjXhaAJGmpJkLRKy3E+0lET0BN7q3gGf6sT+TTOgjPj3G9YSeKt7O2ocLssPc7Mhe9sgt6+DFAJ4/9XBPoGHnAJ1YerWKFKLQ/Z3QQSak7d37YBs3QgxZQ5Ey+y8jZeIKlvWkYgDDzwQP/vZz/DpT3867T5CCOi6nu0lyEYuGzKdTIvBJMWszKCTISW6YwPYEe7D/ECLvSfv2gm5cwOgxSE3/AuwEnTauR4Y6IOMhRl0IioRsXhlZTr1xiPYGe4DAGzp7cDtV19vy3nXrFkDj8djy7nkjg+BeAxy50cpg07Y9DZk105A7ISsa4IITAL62oFJM1OeLx6PY9WqVbaMLRIO4s5bv5jTOez8WRGVmr7+aNrXjNhAAUdin+0DveiODaAbwOy6pqRA/I5wL3riYfTEw3kNp8kdg/eI2PYe0NMGSBN4/6/AqKDTcODLNCFbN4wNOu34CIiEILevY9CJiLKWVdDp/vvvx9VXXw2n04ljjz0WU6dOhcNhQ6NqyhtVUaCqStqnSVYYVoNOFZrppAiBGocbU7yps/py0jAFomkqZKgHYuYiS4eIybMg42GIFmYTEpWKeCL5QYtmGGgf6M/wLBKBCUpK+nNdIc+igMuLRncN4oaOyb66glwzU2LyHMi2zek/EE1fAPR1At46iNp6wO0FRn2wIqLi6A1GUm6XiThMwyjwaOwx1efHznAfvA4n/E7PmNd2hHvhc7iQz/zFoXtEzNkfSMQHM5322n/sfkNZWEKkvJ8Uk+cMBvQnz8njaImo0mUVKfr2t7+N6dOn49VXX8WMGTPsHhPliapkH3QypJnB6nWVGXRyqw4cN31hXs4tvLUQy8/P7JiW2XzqRFRiYvHkoJOiiKxKKKTAuDXNhSo5cSoqjpwyb/CaUmLNmjXj7n/dddeht7cXDQ0NuOeee9Lu53a7bRujmLEQYkb6uVmZswSYsySrcx+w4gooqjPj4z78x+PQE2E4XDVYtCyzuR0ATEPD2y/+IOPjiMpNb5pMJzMWhizT+0m/y5v2ftHv8uL46YMPF3+ex7LZpHvEw06beH+XB6Jp2tjtU+cym56IcpZV0KmtrQ2XX345A05lxulQkMiy8sM0rX7AkRCW9yUiqiyjy+tUoQACloP2Q0yhQJGl9ZRfCDFhmdfQU3Mr+5YDRXVCdWQedFp8xL/nYTRElUXTDQyEU/RPkxJmLAKTqyETEVWErFav23vvvdHX12fzUCjfMmlcOppuWvvwI6RExp+uiIgqRCwxto+hN03D6vHIvBZeEBEVX29/NGXWphmPWO4jSkREpS+rKMQ111yD//u//8PWrVvtHg/lUS5BJ6tPm1SLwSkiokpjGCZ0fewcWOPMvJRMcrUyIqpwfen6OUUjeV3ZjYiICiur8rp58+Zh+fLlOPjgg3HVVVfhwAMPhN+furnyMccck9MAyT6OHIJOmsVgklqhK9cREU1kdBPxIR6HCw5VgZ5BTz2TQSciqnBdveGxGw0DphZjaR0RUQXJKui0YsUKCDHYHPVrX/vanpUPUjDKdOWJSpRT0MlI/WFqNIWZTkRUpdIFnYQA6j016AqHLJ+LmU5EVMk03UBfcGwTcTM2GIhieR0RUeXIKug0UaCJSlMu5XWaxeAhy+uIqFql6uc0xOt0we10Iq5ZW82BQSciqmTdveGUJXRDQSeW1xERVY6sgk6rV6+2eRhUCIqS3YcYU0oYlsrmJFQ+mSKiKpUYJ+gEAI3eWrTpfZY+TLGROBFVslSldTIRhzR0SJmqvTgREZWr7FNfqOyILD/EWM1yElICfDJFRFUqXXndEIeioMFbY+1kzHQiogrW1TMwZtue0jreSxIRVRIGnapJlp9hNNNaPyeW1hFRNUskJp4Da1xu+FwTr2bH8joiqlThSALhaCJ5o5SQscHV7Bh0IiKqLFmV1ymKYqmnkxACum4tYEH5l+1HmITF36GDTeOJqIrFNWtzZaO3FglDhz7OnMnyOiKqVJ1pspyGiurYz4mIqLJkFXQ65phjUgad+vv7sX79eoTDYRxwwAGor6/PdXxkpyyfnMcNa41vmelERNVsovK6IUIAzb46tA/0pa1Ilow5EVGFausKjtlmRvf0eGKmExFRZckq6PTiiy+mfS0SieArX/kKnn76aTz77LPZjovyIJvPMIZpQjesNRF3WCzDIyKqRBM1Eh/Jqapo8NaiJzL2iT8RUaVKJHT09EWStkldg9QHy+0Gm4gz6EREVEls7+nk8/nw3//93wgEArj++uvtPj3lIouoU9yw9iFKkSabiBNRVbOa6TRk/P5OTHUiosrT3j0wpnxOMsuJiKii5a2R+NFHH42nnnoqX6enLGTzESauJybeCYDKfk5EVMV0w2pWaLJGbw0c6ti3Yn7sIqJK1NY5qrROyuFV6wDAYNCJiKji5C3o1NnZiYEBlg2Ukmzex2NWm4iznxMRVbFMSutGEkKg0Vub4oUcB0REVGJ03UBXb/JnAzMehZR7AvamzDx4T0REpc32oJNpmvjf//1fPP744zjwwAPtPj3lINOUZUOa466uNJJqsQyPiKgSxbIMOgGA2+FEjXt0mR2jTkRUWTq6B2Ca6UvrpOTKdURElSirRuJz585NuV3XdXR0dEDTNDgcDtxxxx05DY7sNfqNfiJRzVppHSC5ch0RVbVM+zmNVu+pQURLQA7P0/zgRUSVZUdbX9LX0tBharHhr5nlRERUmbIKOpmmCSHGPoV1Op1YsmQJDj74YHzuc5/DkiVLch4g2SdfQScHs5yIqMrF41pOxytCwO/2oj+6e1UnxpyIqILE4hq6esJJ20ZmOQGDGfZERFR5sgo6bdmyxeZhUCFkkrIsJRDTrX2IYtCJiKpdLJ77PFjn8iIUj8I0JQSjTkRUQVrb+yFHzWsjG4gDmT8cJSKi8pC3RuJUejLp6RTVE5aftDPoRETVzo6gkxBAjctjw2iIiEqHlBI72vqTtyVikCNaM5imHBOUIiKiysCgUxXJ5AkS+zkREVmXa0+nITXOwYbigp+9iKhCBAdiCIVjSdtMltYREVUNy+V1V155ZcYnF0Lge9/7XsbHUX5kEnSK6eznRERkVTTHnk5DnKoKp6pCGvacj4io2EZnOUGaMOPRpE1sIk5EVLksB51+8IMfWD7pyCbjDDqVDtO09oYe0zXLASong05EVOWklIjF7AsSuR1OJEZ9ICMiKke6YWLnqFXrBgNOe+4zpcysBQQREZUXy0GnF154wdJ+27Ztw9e//nVs3Lgx5Qp3VDyGxUBSOBG3fE5mOhFRtUtoBgyLQX0rPA4nNH4AI6IK0NreD01PbsMgY8xyIiKqJpaDTsuXLx/39d7eXtxxxx343ve+h1gshsMPPxx33XVXzgMk+1j5UCSl9X5OQppQ2M+JiKpczKbSuiFOVYXghzAiKnNSSmzZ0ZO80TRhJpL7O7GfExFRZbMcdEonFovhvvvuw7e+9S309fVh0aJFuOOOO/CJT3zChuGRnQxj4ifnUT0BafEJu5M9R4iIELGxtA4AVKFCcBUnIipzPX2RsQ3ER5XWAdbbPxARUXnKevU6KSV+/OMfY/78+bjxxhvh8/nwwAMP4N1332XAqUQZxsRv6uFRT5/Gw35ORERAJGp1tU9rhABUxpyIqMxt2dkzZpsc3UDclAyxExFVuKwynX7729/ixhtvxLp16+D3+3HHHXfg6quvhsfjsXt8ZKOJniSZUiKmW31iL9nPiYgI9gedAEDlxzAiKmPRmIb2zlDyRglILblvKPs5ERFVvoyCTq+88gq+/OUv429/+xtcLheuueYafPWrX0VDQ0O+xkc2kVJO2Eg8koiPznhOy2EYgw2giIiqXCRqf6mxYprgRzEiKldbdnRjdA6T1BOQo4JMXLWOiKjyWQ46nX766XjqqaegKAouvvhifP3rX8eMGTPyOTaykZSYsFfTQEaldeznREQEAGG7M51Mkz2diKhsJTQd21p7x2yXKe4zmelERFT5LAedfv/730MIgVmzZqGtrQ2f/exnJzxGCIGnnnoqpwGSPSZauU4zDGiG1ZXoWFpHRAQMzq0xmxuJS5PzKxGVr607e6Gn6CM6trSO/ZyIiKpBRuV1Ukps3rwZmzdvtrS/ECKrQZH9zAlK6zLJclJME4ppNUBFRFS5wpHEmBKSXEnLDwCIiEqLbpjYsmNsA3FIQCaSg05WV0smIqLyZjnoZDXQRKVpvEwnKYHwqKdP43GVUWmdlBLxuPXvbbSYoQ33G5BSIhyJQJMmPGryP52EYUAAcKpqyjEkEgm4XK6kQKw0dMDUIU0T0DUoNYFxvw8AkKaJaH8P4PKOOpcBGBqEK3Uz/1hsT1DRKNLvb+R1eaNJlSIcyX5+SatCM0kThg4JwK1mvoaJlCYQj0IqDgxOfQKAhHC6U+wrk/5PRIWzvbUXCW3sHCYNbWyPpwr9NxrVE3ApDqhK6kXCNdOYsAJhtLCWgNfhgCKsLzxuRoOQ0QiE2wfhcAAOF6AlAJcbQkm+Xx3qtSXjEUjdgPD6IGMRAIDiq4NMRCGhQJg6hKcmo7ETEVm+85s9e3Y+x0F5Nl6mU1RPQE6QCTWS0/IKd8UXj8exatUqW87V29uL/7jsMlvOlfUY+vrwmf/8XE7nWPviD2waTfYSiQS8Xm+xh0GUs4Gw/SvXyTKaY60Ka3G83LYBppQ4YvJcNLh9GR0vP3oDsn0LEA5C1jZAAIDTBSw5CqJ21GImQz+/MnpAQlQJTFNi8/bu1C+mCKabFVhct22gB29370CNw43l0+ZDHRUkShg6Xtq1HjFDh2Gxn9W6vnZ81N+ORncNjpwyz9IxZsdWyD/9HOhtg6xpgJy6F+DyAk4XRG09sP9yiJFjS8RhvvUCZPvmwXm2eQbQtQ2AgLHkGIjuHZA97ZCBZigzFkDMWWLxJ0JEBFgPl1NZGy/olFFpnWRpHRHRkIE8ZDpJzf5AVrGF9QR004ApTQxkkFm75wT9g8GkeARIxCDjYcA0gejA2H2HPshVaBYFUana2d6HaDx1sDdVML0SM536E1EAQ3Pe2KBS3NARMzQA0vLKfUPn7M/gfh39XUAiBpgGkIgAsTAQ7h2cHyOhwflzFNnXASTigJ4A+joATRv8c0/r4OrW0RBg6JDhfuvjICJChj2dqHwZKRo6AoBumohr1p8Gl1OW02g1F58I4Rxb/jaRyG9fhYzEIXxu+D5xREbHSs1A+OHnhr/+7gEeuLMI9d7+YRz9ukTAIXDTorHlJOOJm8Dn3t5zo7L/iiugqs7MB5Ejw9CGs6xcLlfBr0+UD7YHnaSErMAMnUmeWuxTPxWGNDF9nFLidMT8pUDn9sFAktMDKAqElEDz9LE7O1wAIoCj8PMcUbUyTYn1W7rSvi5TZDpVYMwJCwKToQiBepcvZSlxncuDA5pmIKwl4LBYKre4YRp8Dhcme+ssj0PMPQAy1APs2gRMmgnRNA3w+SFiYSDQDDF6bKoDYumJg/tHw8DUuUDrhsFK5oXLINq3AJPnDLZ2mLqX5XEQEQEMOlWNdJlO4UyemgBwlvGHIeFUIZyZ/5WvOfcY28bgVgCPmnmD/dsXp+7VZE3y715VnVCL/GGMiwxQJTBNiYGwvUGnSiytAwb/ze8dmJT98XWNEHWN1vbd3UdFZND7hIhys6OtD9FY+izNlEGnCiyvc6sOLG6YNu4+s2oH5zKr90I1TheWNI5/ztGE6oB60InW93c4odQ1AiPn2ZaZe/48ezF450ZE2eIdWZVIlcIrJTCQsP6BSUgTaoU2uCUiytRAJG65PMKqSg06EVHlMk2JDVs7J9iJrRmIiKoVg05VItXnopiegJnB6hkufhgiIhoWGsgsU9QKmU2/IyKiItq+qxfR2AT3iKPuNyuxtI6IiFJj0KlKpGrWmEkDcQBw6pXX3JaIKFvBfASdMpyXiYiKyTBNbNyavpfTkEpsGk5ERNYw6FSlDNNELIPMJUUaUJkaTUQ0LDhgdz8nHXJonuXnMyIqAzt2pV+xbpiU4KRGRFS9GHSqEqOfMA0kYhm9/5fzqnVERHaTUtqe6cQsJyIqJ4ZhYoOFLCdI660ciIio8jDoVCVGZzWHM2ggDrCfExHRSLG4joRm78IKI4NOlbiqExFVlu27ehGbKMsJYJITEVGVY9CpSoz8ABPVEjAyaCCumAYUltYREQ3rD0XtPaGUSU3E2f6EiEqZ5SwnIiKqegw6VYmRH2AybSDuYgNxIqIkdpfWmYkY5IgSFGY6EVEp29bai3jCYranyO9YiIiotDHoVCXE7jf8TBuIA5KldUREo/SHbO7nFA0P/9lkmhMRlTDdhiwnxqGIiKoHg05VQuyOOoUT8Yxq6x2GDsEGkERESWwtrzMNmIk95+PS4kRUyrbu7Mmwp12KEBOjTkREVYNBpyqh7A46ZV5axywnIqKRYnHNelmJBWYskvS1wUA/EZUowzCxaVt3ZgcxwEREVNUYdKoSQgjEdC2jBuKAhNNg0ImIaCS7S+vMEaV1AGCazHQiotK0fVdfFit3MupERFTNGHSqEorIMsuJZR5EREnsLK2TiTjkiOC+YZpsIk5EJck0JTZtz6KXk2DQiYiomjHoVCUSho6oltkqdFy1johoLDtXrjMjoaSvM8tGJSIqnNb2fkRj2WbAM/BERFStGHSqEjuC3Rk1EFekAdWwr2cJEVGlsCvoJHUtqYG4KSX7ORFRSZJSYmM2WU67CWY7ERFVLQadqoCUEpv7OjM6xpVhVhQRUTVIaHoOT/qTmeFg0te6YdhyXiIiu7V3hTAQjmd/gtFBJ1YRExFVDQadqkBXJIRQIjLxjsMkV60jIkohOJDDh64RpK7DjO+Zlw3TZJYTEZWsTdszXLFuAow5ERFVDwadqsD6rl0ZldI7DR2CH36IiMYI2VRaN7qXk2Yyy4mISlMoHENvfyYPL61g2ImIqFow6FThdNPAxt72jH7TLK0jIkotlEt5yW7S0GHGwsNfa4YByZVCiahEbW/ts/2cnPGIiKoHg04VbltfFxK6bjnTSZEmHAZL64iIUsmpp8lu5kA/hj5yGaYJnVlORFSiDMPEjrY+28/LQDsRUfVg0KnCre/eBWB3/0YLgSdmORERpSalxEAkt6CT1LXhXk5SDmY5ERGVqrbOIDTd/nmKQSciourBoFMFiyTi2BHs2bNBmegNXsKlM+hERJRKPKHn/OFrMMtpUMLQIFlkQkQlbNuuPntONCrIxJmPiKh6MOhUwTb0tCW/q0+Q6eTUNTYQJyJKYyCSW1BeJuIwE1EAgxlOJp/0E1EJC0fi6OkLT7yjBXLU/SUznYiIqgeDThVsQ09b0tdigt+2m6V1RERpRWO5zZFmeDDLiX2ciKgcdHQP2HOiFAEmBt2JiKoHg04VqicygN7IqKdT4/y2VVOHaur5HRQRURmLRLNfZEHGYzC1OEwpoRmca4mo9HX22BR0MkdnOYGlxUREVYRBpwq1sad97MZxejqxgTgR0fhyyXQywv2ABBKGzo9aRFTyDMNET1/ElnONLq0z2cqBiKiqMOhUgaSU2DiqtA5IX14nIOHSs3+CT0RUDSKx7OZJMx6F1BNImDr7mBBRWejpi8AwbQoOjSon5jxIRFRdGHSqQG0DfQgnUizrnea3PZjlxBsAIqLxxOPZlcWZA/0wTNO+D3BERHlmW2kdADmqpNhg0ImIqKpURNBpzpw5EEKk/O+KK64o9vAKLmVpHZCmvE7CraUIUBERUZKElnnQyYyFIXUNmsHG4URUPjp77Qs6wRid6cQAPBFRNXEUewB2CQQCuPrqq8dsP/jggws/mCIyTBNbejtSvpaqvM6paxB88yciGpdhmNCNzOdKMxyCZhpsmktEZcMwTYTD9vX6HJnpZJqcDYmIqk3FBJ3q6+uxevXqYg+j6HaFehHX0zyNV0dvYJYTEZEVmp55ppIZj8LUE9BNZjkRUfmIxjRbA+VJQSc+6CQiqjoVUV5He2xOk+UEAGJUeZ1qGFD5YYiIaEIJLYugUzgInX2ciKjMRKI2Li4jAYxYrMZg0ImIqOpUTKZTPB7Hww8/jJ07d6KhoQFHHHEEDjjggGIPq6AM08SWvs70O4zKdPIwy4mIyJJMS+tkIgapJ6qieXhYS2BXpA9TfYExr20f6B0uL2x016DB7cvqGrK/C+a2DwDTgJh3IJTa+uTXdQ3o2ArUNY49NhaB+fafgWAPEGiGmD4fwlcHGQsDEBBON0Tz9D37j2hybBjFWdl15HW50hcVWjRmY2mdnhjOmpISMKvg73NUT2BnuA9TfH7UOj3D23XTwNaBHgRcXgRc3pyzYKWUiMfHv5eXwW4g3A+pOiEggUkzIYSADPcDwS7I3e9R0jAQ2fQuZE8HEA0CMxdBxEKA0w00TAXaNgFSQszeF8LhGj5/LBYb/jPnSyJKp2KCTm1tbbjkkkuStp188sn43//9XzQ3N6c9Lh6PJ03YwWAwX0PMu9ZQLxLpSuuAwbw2AUACimnAUaQ3ByKicmOamd3ImuEQDNOsil5Ob3ZtQ18igtZIf9L2tkgQb3VvR1skiFqnGwGXDyfP3AdKqgaD45BaHPKtPwGb1gKKCvS2ASsuSN5p63uQ7VsBVR3zocN852XgjWcBPQG43JCb34GcNg+IRQaXcq9rBNxeiN0Bq0RizwfutS/+IKOx5kMikYDX6y32MKiKRKI2Bp1GPOCsltK6N7u2oycexvZwH46dtmB4+0f9HdgY7IQiBKb6AtCGAj5ZBkri8ThWrVply5h7+/tx2U135HQOzpdElE5FlNetWrUKL774Ijo7OxEMBvG3v/0NH//4x/H000/j9NNPH3cyv/POOxEIBIb/mzlzZgFHbq/N6Vat200IDK9g59aZ5UREZFUmQSepJWBqsap4og8AbtWR9P8hLlWFgIBDUaEKBe7dX2dMUQGXd/D/igJ4asbuM5RNMOIJ/J4B+gaPE2LwHE7X4H6qCqiOwdcczszHRVShIjH7HkpKbU8Aq1pK6zyqc/f/k+fEoTnSqTjgVVPMVUREFaoiMp2+9rWvJX196KGH4ve//z2WL1+OV155BX/4wx9w6qmnpjz2hhtuwLXXXjv8dTAYLMvAk2Ga2NrfNfGOCiB0Ey6NWU5ERFaZGZTJmZHQ4P+rJOi0dNIs9MWjqHd58b8jtje6a7B86nwAgGYaqHW6IUTmQSehOoClJ0Hu/TEIQ4donjF2p5kLIRpaAE8NhPhd0kvKkiNhNk4BIiGgJgBRPwnC4QS0xHAgSnhrh/d3ufZ8GNx/xRVQ1cIHpAxDG84aGDkeokLIpoddOsOZTjKzebScHdg8A3PiTQi4PEnb5/knodFdA6/DCY/qhFtVEQWymhdH++4BHrizSCW4/cM4+nWJgEPgpkXujI/vT5j44nuDgUXOl0SUTkUEnVJRFAWXXnopXnnlFfz1r39NG3Ryu91wuzOfZEtN20Df+KV1uwl1qJdTdXwYIiKyg+XyB8OAGY9kdkyZU4WCplTZRwDqRn3oypZweaBOSv9ASAiRsp8TAAhFhTpjwdgX0vSXGvkBUFWdUIucBWXHB1KiTKiKPX/npK5D7u5bZEizau48x5sTR/a1y7TUeDxuBfComf/ebl+c2xwdVzlfEtHEKqK8Lp2hXk6RSKTII8m/reM1EB9BhQ6Xbl+tPhFRdbB2IzuU5QSgKvo5EVHlUWz64C7je+6/q2FRBSIiSq2ig05///vfAQBz5swp7kDyTEqJrX0WSusABOLBweVDiIjIMsXKk38pYcbCu/+c3/EQEeWLotrz8cCMRwEM3nZWSz8nIiIaq+yDTu+//z76+vrGbH/llVdw7733wu1246yzzir8wAqoKxJCJDFxY3DV0NEY6S3AiIiIqo8ZHYDc/cGKMSciKld2ZDpJQ4fcnVmvm/b1iCIiovJT9j2dnnjiCXzrW9/C8ccfjzlz5sDtduPdd9/Fs88+C0VR8IMf/ACzZs0q9jDzymppXUt/J1ySpXVERJmaMNNJyqTSOoadiKhcWcrsnIDcneUEsLSOiKjalX3Q6dhjj8UHH3yAN998Ey+99BJisRgmT56M888/H9dccw2WLVtW7CHmnZWgk2IamNLbgTi4LDQRUaYmevJvRsPDDXOJiMqZw4byOjM22M9JN032tyMiqnJlH3Ravnw5li9fXuxhFE0oHkVfdOJG6ZP7OuEwdJgWm+ESEdEe6ngfwqSEGQmO3kREVJbqanNb0UxqieHSOoPBeCKiqlf2PZ2q3Y7+7gn3UQ0DU3rbAQAO6PkeEhFRxXE40r9dmrGxWU58sk9E5cpf687p+KFSY8M0YTICT0RU9Rh0KnPbLQSdJvd1wGEMBpsUIaGCtfVERJlIW24iATMcHLuZH7SIqEzV+tzZNxM3jcFV6ySgMcuJiIjAoFNZ000DraHxV6NTDR1T+tqTtjHbiYgoM+mCTmZ0IGUvJ4NBJyIqU6qqoMaXXbaTGR0AIKGZBoPvREQEgEGnsrYr1DfhiiBTejugGskfiBh0IiLKjKoqEKN74pkGzHD/2J0lYEpmlBJR+fJn09dJysFFFSR7ORER0R4MOpWxifo5OVJkOQGAQzDoRESUCSHEmL5ORqgPMkVwiSUlRFTu/HWZB52GVvFMGDq72hER0TAGncrYzmDPuK9P6W2DkiITiplORESZczrU4T/LRAxmfOzKoXzCT0SVYFJjbWYH7F7FUzcMZnoSEVESBp3KVDgRQ39s7AeeIS4tgSl9nSlfczLoRESUseFMJylhpOmnp5l8wk9E5a+uxo3aGut9nczoAAxDZ6YnERGNwaBTmdoV6hv39ek9rRBp+j0x04mIKHNO52CmkxkJQhpj51HNMCbss0dEVC6mNPut7SgljHAQWop5kYiIiEGnMtU6TmmdNx5FczB9vycH+BSKiChTDlWB1BIwwqExr+mGCZ1P+ImogkyZZC3oZEZCSOgJmFytjoiIUmDQqQxJKdGaprQDAGZ07cR49R3MdCIiypwKCSPYjdETrGYY0EzOq0RUWfy1bvg8rvF3Mk3EQr3M8iQiorQYdCpDwXgU4UQ85Wt1kRDqUy3hPQKDTkREmZFSwuzYMqasLmHozHAioookhMCUSXXj7hMNdkNnWR0REY2DQacytCtdlpOUmNm1c8LjFZhQ2OqWiMiyxPaPgGDX8NdSSsR1jU/3iaiiTZ9Sn/a1RDwGPUW5MRER0UgMOpWhjoHUmUwNA32oiYUnPF4IQGVfJyIiS4xQL2Lv/x0qBgNMumEgrmvsX0JEFc9f60Fjfc2Y7bppINzXCcmHmERENAEGncpQe4ryOWGalrKchrCZOBHRxKSuIfKvFyFNA6YcDDZppsGPWURUNebMaEz62pAmuvt7oOqJIo2IiIjKCYNOZSaqJRCMRcdsn9zXAbeWus9TKir7OhERTSj63t+ghXrQGx1AXyzM7CYiqjqTm+rgdTsBAKaU6BwIwmUhs56IiAhg0KnspCqtc+gapve0ZXQeVTDTiYhoPPHt69Gz+V3sCvUhFI+NuyooEVGlUhSBWdMbISXQFQkBiShULqBAREQWMehUZtoG+sZsm9HdCiXDN3+W1xERpdfZvh2b/v4H9EQGhpuFC0adiKhKzZgaQE8shLiWgCfNCspERESpOIo9AMpMZziY9LU3HsGkESsqWcVG4kREY8V0DW9uWwfHv16AJ8F+JUREUkq8sWsjYo4YXANaxg86iYioujHoVEaklOiODozcgFmdO7Iq+WCmExHRHqaU+KirFW/s2IDpOzegNh4bs4+EKMLIiIiK683WzVjX2QpnjQ5PJ7OciIgoMww6lZFgPArd2BMsqg/3wx8JZXUuZjoREQ3qiQ7gL1s+QFc4hMZQD5qCPSn3M1mRTkRV5r327Xhr1xYAwJSBDgBAH/xFHBEREZUbBp3KSNeIAJMwTczq2pH1uRSYdgyJiKhsGaaJtW1b8VbbFpimhGrog9mjaTDoRETVZHNvB/62Yz0AQDENTO7rhAEF/fCzwx0REVnGoFMZ6R4RdJrS1wF3Do0cGXQiomrWExnAS1veR09kT8nyjO5WOHUt7TEMOhFRtegY6MdLm98fbuEwqb8LDkOHQwB+hNAv64o7QCIiKhsMOpWRoaCTU09gWs+unM7FoBMRVavNvR14efP70M0982BNLIyW/s5xjzMYdCKiKhCMR/HcxrV7Vu40TUztbR9+vRld6AeDTkREZA2DTmVCSjkcdJrZ1QrFzC1oxKATEVUbKSXWtm3FGzs3jX4Bc9q3Tbgogyad+RscEVEJiOkanl3/NmLanqzPplBPUhaoRyTgRwhBZjsREZEFfGxbJmK6hriuoyY6gKZgd87nY9CJiKrN33esHxtwAtDS3wlfPDLh8RoYdCKiymVKiRc3vYf+2Ij5UMqkLKchk9DN9TyJiMgSBp3KRH8sAkiJ2Z3bbTkfg05EVE029rTjvfYUTcKlxJTejgmPN6WADjUPIyMiKg3/at2MnaNW76yJR+BJxMbs6xFx+EV2KygTEVF1YXldmeiLhdEc6kFNbOKn8VYISAhMWE1CRFT2+mMRvLL1w5Sv1UUH4NYmXpShGrKcpJSIx9P/LAzTwNs9rTCkiQMbZ6A3EcFzOz9AvcuLk2cuhioUSCmHz/WP1k2IaHHs0zAF6/s7ICCwqGEK3u/dBQEBBYAuTRzQNANu1TF8XCKRgMvlghBieJvc+BbkprcBLQZ07QSEABQH4KkBps4FunYAsQgw70CYuxfZMCMhhF/4BYTLBdTUQ85cBPHmc5B6AmLZaRBaDOY7f4FQVYj9l0PUNgDAuD8Dokq1ta8Tb+3aMmZ706gg1EiT0IUg6qryXjLdfNkbj+CD3jY0e2qgSROhRAxLGqfBrTiwtmcnAOCApulwKGryfLlzI8J6AoZpYGu4F/sEJuPA5plQRPp8Ms5VRFQuGHQqE8FwEDO7dtp2PiEAIeXu0BMRUeV6r307dMNI+dqk/i5L50hUQdApHo9j1apVWR37q1Ff9/b24r4v3pT7oCx5b8Sf1w3/qS+m4T9+9JvUh/zv86M2/M72URGVi/5YZHClulGENNEUSh90cosEAgiiT/rzObySlMt8OVpvby/u+9LNSdv+ZMuZiYhKA8vryoSy9QM4xlnKm4iIxpJSYnuaPniqoaNxoM/SeWLw2DgqIqLSYJgmXtj0LrQUgXl/OASHoY97fDO6+PiSiIjGxUynMmCE++Fr34rx3/aJiGi0qJbAQHxsPxJgcEUmIa31t4vCa+ewSl7NxSdCODPvYRX57auQkTiEzw3fJ47I6FipGQg//Nzw1989wAN3Fo/Gbv8wjn5dIuAQuGmRO+Pjg5rEde+ybIWqwxs7N6I7MpDyteZxspyGuIWGAPrRJwN2D61slMJ8SURUyhh0KgPRD/4BY4InTURENJbL4UC6BnaNoV5L55ASiMrqynQSThXCmfktQs25x9g2BrcCeNTMcyhuX5zb7ypuVGOHGqpGO4M9eLc9zQI1UsIfCVo6zyR0ox+BquztBJTGfElEVMpYXlfitM4diLdtg8zDO7mo2tsDIqoWDkVFrStFEEJK+OJRS+fQ4eDKdURUUWK6hpe3jO3jNMSbiE1YWjfEJTQEhLUAFRERVR8GnUqYNA3EPngdhpm6AS4REU1sSm39mG0uPQHV4twaqbLSOiKqbFJK/HXrh4gkEmn3qYuGMjpnM7rZ24mIiFJi0KmEJbatgzHQB91izxEiIhpr35YZY7ZZzXICgDBq7BwOEVFRfdS9C1t6O8fdxx/JLOjkFgn4RWbHEBFRdWDQqUSZWhyx9f8CMLiyCBERZWdSjR+TapOX9PbFI5aOlRIYkAw6EVFlCMYi+Nv29ePvJCXqoqmbi4+HK9kREVEqDDqVqPiGtZDaYNqznoegk5SAyV8/EVWJA6fMSfraaqZTAi5oXHODiCqAKU28uOV96Mb4pcUuXbPcz2kkD7OdiIgoBUYdSpAZCSG+dU9zx3xkOplQ2EaciKrGzEATmmvqhr/2aHFLxw2wtI6IKsSbrZvROTBxw29vwnr58WjN6M76WCIiqkwMOpWg6Lp/AiMCTSbyE3QiIqoWQgjsN3nW4BdSwq2lb6A70oCszeOoiIgKY1tfF97etdXSvpn0vBvNI+KoQfbHExFR5WHkocTofZ3Qdm1O2maa9uckGVz+m4iqzKz6ZjhUFappQLGwcp0uVYThK8DIiIjyJxSP4qUt70+84265ZDoBQJPoyel4IiKqLAw6lRApJWIfvjFmu5mH1esM/uqJqMo4FBVz6idZznIKoZZlyERU1nTTwJ82vouEbr1Hkzcey+matRiAC1pO5yAiosrByEMJ0Tu2Q+9pG7PdkPZ/7DGZ6UREVajW5YFbt9bPKSj9E+9ERFSipJT469Z16I5k0NxbSni03IJOQgCNojencxARUeVg0KlESCkR++jNlNtlHoJOzHQiomqkm4alTCddKiytI6Ky9s/WTdjQPfZh5nichgbFhgVs6tEPNQ89SYmIqPww8lAi9PatMEJjnwoZeSitA9jTiYiqU0zXUBMLT7hfEH6W1hFR2fqgY4flxuEjWS0/nogqTNSLflvORURE5Y1BpxIgpURsw9sFvWYCroJej4io2PqiYWzsaUNNLDLhvv0srSOiMrW1rxOvbv8oq2PdmrXyYyvqwaATEREx6FQS9I7tMIKpV/ow81BaBwAJyaATEVWX13duhKLrE36oSkgnIvAWaFRERPbZFerFC5veQ7apmh4bg05uxOGBPZlTRERUvhh0KjIpJWLr/zXu6/mQgDMv5yUiKjVSSvxz5yZs6+tCrYXSun4wy4mIys+uUC+eXf82jBx6MtmZ6SQEEGCJHRFR1WPQqcjGy3IC8hN0khLQGHQioipgmCZe3Pw+3tq1BQAmLK2TkqV1RFR+2kJ9eHbDWug5NgG3q6fTkACCELaekYiIyo2j2AOoZoO9nN4af588XDcBFxvkElHFiyTi+POmd9E+sOdJeyASHPeYGNyIs+cdEZWRtlAfntnwNnTDyPlcdmY6AYBT6KiREQxwNVAioqrFoFMRGT1tMPq7x90nHz2dWFpHRJVMNw28174db7VtTfoQ5tQTqI0OjHtsPwL5Hh4RkW3aB+wLOCmmCaeu2TCqZAHRjwHJoBMRUbVi0KmI4ls/nHAfmYecJK5cR0SVSEqJbf1d+Pv29QjFY2Nebwz1TXA8EJR1eRodEZG97MxwAgCXzVlOQ2oxcS89IiKqXAw6FYkZC0Nr31qUa8fhLsp1iYjyQUqJtoE+vLVrC1qDvWn3axxI/xoAhOGDxrdFIioDu0K9gz2cbAo4Afb3cxriEAY8Mo4Y7z+JiKoS766LJLHto8HH6hPJQ3ldRHIpcCIqf1JKbO/vxtttW9AxMH6vJpc2cWldkKvWEVEZGFqlLtem4aN59PxkOgFArQgjJhl0IiKqRgw6FYE0DSS2f2RtX5uvrUuVTXKJqKyZ0sTm3k683bYFvRFrZRsNE2Q5SQmEWFpHRCWuLdSXl4ATYH8T8ZFqEEYXGvN2fiIiKl0MOhWB1r4NZnz8ZbvzJQpmORFReUoYOj7qasV7HTswkKJn03iagz3jvh6BDzqUXIZHRJRX/bEInt+4Ni8BJyB/5XUA4EMUCiRMiLxdg4iIShODTkWQsNBAfIjd1XURBp2IqMyE4lG837ED67paoWXRv8Qbj8A3QaA/iNpsh0dElHcxLYFnN7yNuK7n7Rr5zHRShIRXRhEGV7EjIqo2DDoVmBkJQe9py+AIe6NO7OdEROWiKxzC2rat2NLXkVMAfqIsJ5bWEVEp000Dz218B8FYNH8XkTKvQScA8IkowpJBJyKiasOgU4FpbZmtWGdnyMmUguV1RFTy2kJ9eLttC3b0jx8sskRKNIXGP08cbq5aR0Ql69Wt69Ax0J/Xa6imASVPZXtD3MhvUIuIiEoT77ILTGvPLOhkpyg8tjcmJyKyg5QSO4I9eLttC9pD9n24CkSCcOrauPuw3IOISlVnOIj13ZlkyGcnn/2chq+B/F+DiIhKD4NOBWTGItB7O4p2/TBqinZtIqJ0eqMDeHXbR2gL9dl+7oaBic/JoBMRlSIpJV7fubEg13Lp+Q8IuZCAgP0rMxMRUWlj0KmAipnlBLBnCRGVFs0w8K9dm/Fu+3ZIu1dN2M0fDY37upRAhD1GiKgEtYZ6sSvYW5BrFSLopAgJp9SQgDPv1yIiotLBoFMBZdrPyU5x6UQMrqJdn4hopJ3BHvxlywcIJ/LX48OpJ+Ce4PwxeGBAydsYiIiy9WbrpoJdqxDldQDgFnEkJINORETVhEGnAjETsQxXrRtiz9P/EJjlRESlYUd/N57buBammd8iC39k/CwnYLDXHRFRKeqLRQp2LaehF+Q6LvZ1IiKqOgw6FYje1Yps1vy26yNZtZbWjSzZkVphbqiSrj/qmnGj8J0MinFNonR2hXrx/MZ38h5wAiYurQOABDNAh3G+3H3dEX83jQKUHKViGuM3v6fKJ6WEVqBAEAA4CvR3TkV+V8grFM6Xu687Yr7MV5k8EZU/Bp0KxOjLsoG4DfO3Jh2IVOnT/ERizweG8MPPF3Ekgz63lssFU/WSUuJPG9+FkedluYfURsMT7hOX7gKMpDxwvhxr7Us/LPYQqErpppnNs8qsFSrTSYVRkOvkG+fLsUxTB/ggh4hSYCOLAsl21TppQ9QphNqcz0FElKu4riGuFy6Dw2nhyX2cN8hEVIJ0s7DBGUeBgk5KhWQ6ERGRdcx0KgCpazCCPUW7frWW1gGAy7XnA2XNxSdAOAv7V15qetITsO/u74ZbFQUdQ9yQJfEEjCiUiBXuYlJCneBDmyEVaHwbHMb5clBMN/H5dwazGL7//e/D49mTKdzaMYBdnQOY0lQD3ZQI1LoRS+jY1hrEXjPrEY/paO0cwKMP/hf6+/vQ0NCAe+65Z/j4YDiBnv4opjTVwOO29vN1u5mNV428Them+hsKtnpd4TKdKiPoxPlyUFAzcd27g/OlovD9lIhS4+xQAEZ/V1b9nIDcq+s06UAY1bscuBB73oCF01Hwm4LR3KqApwg3BUSloMlXi+aaOnSFJ+61lCtFmhNOoDrfApNwvhyyJwnc4/EkBZ3mzvJg7qzmMUfMmdE0/Oe995qEJ346eA4hRNLxHo8HLU3+fAyaKtABU2YXJOgkpAlRoLLnSsl04nw5KG6M+DkI3t8SUWosryuAbEvrAGQdrBrSh4BtzciJiHKhCAXHzNkHipL/G9OJspwAwOBbIBGVsGl1DZhUk/8gpVKggBMAKBXS04mIiKzjHXcBGDkEnXJZ4ElKoE8Gsj8BEZHNGry1OHLWorwHnlQLH6JMqHkdAxFRLoQQOHDqnLxfx0qQ3j7MhiEiqjYMOhWAHuzO+liZQxpyBF4k4Mz6eCKifFjQPBWnLVwKv8ebv4tYyBJlphMRlbpZ9c1YOn1uXq9hJUhvF5PzLhFR1eHMn2dSS0DGo1kfn0umUx/qsz+YiCiPJtX4ccY+h2BuY0tezq85Jg6488MPEZWDA6fOyWvGk1LATCeTmU5ERFWHd9x5ZoT7czpeZtnTyZAKglW8ah0RlT6X6sCKvRbjxL33R8Bj74IHhqICEzQ1Fex4R0Rl4qBpe2G/KbPycm5VFi7TSfKjBxFR1eHSPXlmRoK5HZ/ljUAQfj5NIqKSJ4TArPpmTPc3Yl1XK95s3YS4bsPS3UJAUx1w6lraXSplFSUiqnxCCBwyfR5MKfFe+3Z7z51LWn2GeG9KRFR9+Lghz8xwbkGnbG8DetlAnIjKiKoo2LdlBs5dcjj2mzILqpL725Oujv9chUEnIionQggcOmNvHDl7oS1z5BClgJlOLGsmIqo+nPnzLJegk0R2mU5R6UEUnqyvS0RULG6HE8tm7I3zlhyOfSZNh5igRG482oRBJ5bXEVF5EUJg0aTp+LdF9i3GUMigk8FVQ4mIqg6DTnlm5BB0Mk3TygJMY/SygTgRlTmfy40jZi/EOUsOw95NU7JaZXviTKdCLhNORGSfJl8dztjnEOzVkPtiDIUMOnFVZSKi6sOgU56ZkVDWxxpZ3AQYUkG/9Gd9TSKiUuJ3e7F8r31x1r7LMN3fmNGxEwWdXEjf74mIqNS5VAeOnbsYh89aAEXJPitUKWBPJ00y6EREVG0YdMojaRiQWjzr4/UslrDtQ4BNGomo4jR4a7Fy/gE4ce/9LZeUGMr4ZRyKkHDChqblRERFIoTAvi0zcMaiQ9Dkq83qHIosXNanxkwnIqKqw6BTHsl4NKfjDTOzTCcpgV7ZkNM1iYhK1dBKd2fteyiWzdgbDnX8oNJEmU4A4EbCruERERVNo68W/7boYHxs2l4Z98JTM7zfzJaUDDoREVUjBp3yyIxHcjo+0/K6MHyI882ciCqcqijYb8osnL7oYAQ8vrT7WQk6uQSDTkRUGVRFwUHT9sLpiw5Gg6/G8nFKgYJOOhxcvoGIqAox6JRHuWY66UZm6c49YJYTEVWPBm8Nztjn4LSNdE0LT/vdyL4EmoioFDXX1OGMRYfggKmzYSXpSS1QeV0CroJch4iISguDTnmUa6aTlkFPJ006MCCzq+UnIipXzt2NdPebMmvMaw5j4n5NPuQ2TxMRlSJVUXDw9Hn4twkyQoHCZTrF4C7IdYiIqLQw6JRHuWQ6mdKElkGmUy/qmbJMRFVJCIGl0+aOaaLrsDCHupGAA4VbLpyIqJAm1fjxiX0Owb4tM9Lu47QQoLdDDJ6CXIeIiEoLg055ZOYQdMok4CQl0CcDWV+LiKjcqYqCY+bsm7RsuJVMJyEAn2C2ExFVLoeq4vBZC7By/gHwucZmG6mFCjpJZjoREVUjBp3ySCZiWR+byOAGYAC10DBxw1wiokrW6KtFvWdP81yrT+9ZYkdE1WBGoAln7bsMcxsnJ213ZNDOIVumFIizvI6IqCox6JRHhQo69aI+6+sQEVUSRWSW6QQAtQjnazhERCXF7XDi2LmLcfScfaAqgx8DClFeF4eLbSCIiKoUg055lEt5ndWg02ADcevL4hIRVSopJfShhrhSwpuwNge7RQJuJPI4MiKi0rKgeSpOXXgQah0OiAI0Emc/JyKi6sWgUx5JLbuluHXTsNzTiQ3EiYgGbe/vRl90MGvJpSfg1DXLx/pFKF/DIiIqSZNq/DhtryXwOJ15v1YU3rxfg4iIShODTnkiTQNSy+7JecziByU2ECciGmRKE6/v3DD8dV10IKPj/WDQiYiqj9vUManGD787v0GhiGTQiYioWjHolCcykV2WEwBELQarwqhhA3EiqnpSSry+YyP6onsagtfGMuvT5EYcLljPjCIiqgQyHoWAQL23Bo2+2rxcQ5cK4nDl5dxERFT6GHTKk2ybiEspEbeY6dSPuqyuQURUSda2bcW77duTttVmmOkkBFAv+u0cFhFRyTPjI4L1Lg8avfb3CWVpHRFRdWPQKU9GvolnIq5rMOXEXZqkBEKSQSciqm7vd+zAGzs3JW1TDR0+i03ER6pHP8TEuxERVQw5atGbWrcXDTYHniIMOhERVTUGnfJk9Ju4VVHdemmdwV8fEVWxd9q24bVtH43ZXhcdQDYrLDiFjlqRWYYUEVE5M1Nk5tfZHHiKSp9t5yIiovLDqEWemLHMM52klIhY7OfE0joiqlZSSvxz5yb8Y8eGlK/7o9k3BW9AX9bHEhGVm3QPSevcXtS5PTmf35QCUeR+HiIiKl8MOuWJzKK0I6ZrMExz4nOztI6IqtjrOzfirV1b0r7uj2QfdKpFGE7oWR9PRFROxsvMr/fUwKmqOZ0/Cg9MFi4TEVU1Bp3yxIxlHnQasBioGmBpHRFVqXfatuGdtm1pX3foGrxZljcDgw3Fm0RP1scTEZWTVOV1Q4QQaPTWIpeYUQQsrSMiqnaMXOSJzLCRuG4aiFpctS7I0joiqkLru3elLakb4s9w1bpU6tEPFRNnnRIRlbuJepC6HU74Xdk3Ao+wnxMRUdVj0ClPMu3pFE7ELTW+lRIYkLVZjoqIqDxFEnH8deu6CffzxcM5X0sVJhpFb87nISIqZdI0II2Jy4kDHh9UJfOPDFJy5ToiImLQKS+kacKMWf/gIwGEx0lvHkmDAzpyq68nIio3b7VtsdTzzpuI23K9RvRCyWYJPCKiMiEtZtgLIeBzujI+P/s5ERERADiKPYBKJGORwcc7FsW0BHQLH6YAIMonRpQj07B2k1kp16XyF9c1rOtqtbSvx2IAfyIOYaAe/eiR9bacjypXNKajpz8KCcDtVNFU74VhDL6na7qJTdv7MGd6AIqS+sP30PFNDV54XLwto8KxGnQCgBqXB6F4ZvMr+zlVF95fElE6vLvJAzPD5br7MyjFY9CJcvX2iz8o9hCIMmJKCdOcOJAvpAmPZk+mEwA0oxt9CPBJPY1r3ZYedPdHERpIoKXJh+6+KHRj8O+rphv45wftcDkVzJjiT3t8JKahNxjHkvnNhRw6VTs9YXlXl+qAU1WhGYblYxh0qi68vySidFhelwdmBst1R7UEEhbq6YdEJINORFRdFGEt6OPWEhllmU7EKXQ0iD7bzkeVyeVUoCoCDlWBEAIeT/LzPFURcI+TweRyKkn/JyoUqWWWIeJ1WC+xk5L3rERENIiZTnlgZrB6UjCDpb1NKRCDJ5shEQEA/ud//gdut3v4a8M0EYnq8HkdSU1CIzF99wclFbphYiCq4dabb0B/fx8aGhrwtVvvgGFIBOpcWTUXHTkGoom4VAeaa+rQFR4/oO+2qZ/TSM3oRi/qme1EaS2c04gZk+ugKgoUBfB6nHDuDiC5XQ4cd+gs1Nelf+9eOKcR4aiGWl/mPXOIciFN6w89AUDJ4P0+DjcMPtuueK4Rv+LR95hWSCnRP5DArV8bvMesr6/Hvffem3LfeMKAYUr4POk/vvL+kqg0MeiUB1YzneK6hngG9fQxeNjWlnLidrvh8SR/+KlJkf0+ahfU1gCqOnhnIYTA5OZAvoZINIYQAkfOWoj/+/CNcVf5VKW13niZcAgDTehBp2yy/dxUGVRVgb82+YPOUHaeqohxA07pjicqiAwzQ61mnQJcta5aiBF/J1LdY1rh9XqH7zEVRUl7jixOTUQlgo8g8sBq0Kk/br2XEzC4CggRUTVqrvFjScvMcfcReQg6AUATeuBAfs5NRFQ0FhexGZJZ0In9nIiIaBCDTjaTUsII90+4X1zXEMuwll6DM9thERGVvWUz9sYBU2enfT1fBXCqMNEsuvJ0diKi4pAZZjqJDGZZ9nMiIqIhDDrZTCZikNrEq4H0ZbBi3RDWxhNRNRNC4ODp83DU7EVI9cA9X5lOANCIXrhhfaUnIqKSl+GcaXXhG006oLGDBxER7cYohs3MgYmznKJaIqNeTkMMqNkMiYiooiycNA0nz/8YalzJfXCEjSvXjSYEMFl05O38REQFl+GcGTes3bty0RsiIhqJQSebGQN9474uIdEXC2d3bsmgExERAEzzN+DsxYdin0nTC3bNWoRRi8yzVImIyp0EkNCtZTqxBykREY3EoJPNzAn6OYUTcWiGkdW5melERLSHU3XgiNkLccrCj8Hv8SJ/XZ0GDWU75fcqRESlRzN0mBYzo6Ls50RERCMw6GSz8TKdpJToz6KX0/C5GXQiIhpjal0Dztx3GeY2TU5avjkfPCKORtGb12sQEZWaoMX7VymZ6URERMkYdLLZeJlOoXgURobL0w6RkkEnIqJ0HIqK+c3TMLWuHl5nflf6nIQuOJBdxioRUblJGDoiFhbJAYAEnFz4hoiIkvBdwUZS12BGU/drMkwTwXg0+3NDIH8tcomIKoAQcCgqJtUE0FxTB1XJz1ucKkw2FSeiCmDtztJqlhMAxOGeeCciIqoqDDrZaLzSumA8YrkWPhVFSKjI33LgRETlb09pnc/pxtS6etS681PmEUAQPmT/IIGIqOgs3JcmdM1ylhPAoBMREY3FoJONzDRBJ80wMJCI5Xx+B6ytGkJEVI2kFk/6WhEKGr21aKkNwGFz1pMQwFTRzqbiRFS25AQtH0xpoisSyuicCbhyGRIREVUgBp1sZAyk7ufUFwtbeZg0IQadiIjSM9OUMHscTkyta4DPae+HocGm4j22npOIqGDM8XvT9UQGoGfYizQuGXQiIqJkDDrZyBwYu6JRTNcQzSAteTwOwaATEVE6cpy+eUIINNf4EfD4bL1mC7rg5AMBIipH4wSUQvFoRmV1wGC1HsvriIhoNAadbJQq06kvTWPxbPCDDRFRemZi4h5LAY8PzTV1EDbVxSlCYopot+dkREQFJNNkOsV1DX2xzO9fdThgsuiYiIhGYdDJJtLQYY6qe49ocSQM+wJFLK8jIkpPxq31zvM53Qi4a2y7bh0GUCfse8BARFQIMkUmU8LQ0RkOZtUWIgGnDaMiIqJKw6CTTcxRGU0SQH8GS8xawaATEVFqUkqYUesNb/0eLzxOez4gCQFMQRsUi8uPExGVAjkqO1QzdHSG+7NebVmHw45hERFRhWHQySajP+xEE3FoxvgNGjPlhj29oYiIKo050Jfyqf14Gr21tl3fJXRMEl22nY+IKN/MESsr66aBjnAQhpl98JxBJyIiSoVBJ5uMLK2TkOiP25vlBABuxOGAvYEsIqJKoPdk3lfJoahQFfveBpvQAw/itp2PiCif5O6gk24a6Bjoh5HhSnWjMehERESpMOhkEzM6MPznSCJhe5YTMFjCUcO+IUREYxh9HVkd51JV28YgBDCVTcWJqEzIeGw44KTnGHACGHQiIqLUGHSyiRkZDDpJSATzkOU0pBYMOhERjZZNphOAnEpJUvGJKBpEn63nJCKymzR0xMNBtNsUcAIAXTLoREREYzHoZJOhnk75ynIawqATEVEyMxZOyja1yjBNW1cYHdKCTpZCE1FJ6+xqRUe4L+eSupEM2Jc5SkRElYNBJ5sMrV43kLC2ZHe2HMJgzxAiohGyzXKKavmZSx3CxGTRmZdzExHlqi3Uh799+E/bMz0lhK3nIyKiysA8WLvoGjTDQFzX8n6pWhFGTLrzfh0ionKQTdDJlCb649GJd8xSAP3oRQARePN2jXySWuEztYpxTaJqsyvUi2c3rEVLzP5WEPaGsIiIqFIw6GQDaZqQppH3LKchtRhAFxoLci0iolJn9GYedOqLRmwtKxlNCGAq2rFJzinLD2Lhh58r9hCIyGa7Qr14dv3b0E0T3jzcszLTiYiIUmF5nR0MHVJKRLTCBJ18iMIJ+/uQEBGVGzMRgxHqzeiYqJYoyEMCj4ijUWQ2NiKifBgZcAIAXx4WvWHQiYiIUmGmkw2koSGqJWyvjU9HCKARvWiXkwpyPSKiUmX0dmS0v24a6N698EMhTEIX+uGHXgYNdt1uN9asWZPTOa677jr09vaioaEB99xzT8bHx+Nx/Od//mdOYyCiZKMDTg5dg6dA2flEREQMOtlA6joGCpTlNKQBfehEM0w+VSKiKpZJlpOUEl2REMwCPSAAAFWYmIxO7JRTCnbNbAkh4PF4cj6HXeciotz1RsN4bsPa4YATANTG8rMSMjOdiIgoFZbX2UDX4gVpID6SKkw0iL6CXpOIqORI6wGkYDyChF740uQA+uEDswqIqLBiuobnNrwNzUhu0l8XHcjL9RTkr08eERGVLwadbNAbDmbyucc2jejlMyUiIgsSupbX1erGIwQwRWTe7JyIKFuGaeLPG99BKD424J2voJMKrkBJRERjMehkg85EvCjXdQkNdSI/Nw5EROXBWsS/Jxou6nreXhFDvegv3gCIqKq8tv0j7Ar1jdmuGgZq8tBEHABUZjoREVEKDDrZoL1IT88BoBE9Rbs2EVHRWQgkxXUNCaP4K362oAtKMSNfRFQVtvd3Y11na8rX/JFgRmXJmVAFM52IiGgsBp1yJKVEWyw8WD9RBD5E4WWvECKqVham3lCJrNLkFDqaBB8UEFH+mNLEP3asT/t6fTh/GZcsryMiolS4el2O+mIRxA0DmuqAs8DNxIHBWFcLOrFVziz4tcuN1Ap/MzT6mnETKHSNTzyDbPeOngh2dQzAMCVcThXzZtXD6x6cJhK7vxfdSH/Ctq4wOnoimDG5Fo0Bb07jJrLC0TwdWP/WuPvoRul8EGpGN3pRDx1qsYdiWXcsjPd7d6HFW4eF9ZOHt++K9ONv7ZsBAIdP3gtTfIExx+qmgX9170Dc0NERCSKoxTDFF0CT24ePNc+EQ0n/cyjGfLnnuulJKRGPx9HVG8X7m7rhdqhYPL8ZtT5n0j5D/4/Fxg96ut3u4VX/iHK1rrMVfdE05XNSMuiUB9V6f7nnutYNRBLYvKMf/loXan0u7GgPQdMMxBOD309cMxAKJ1BX48rDaImoWBh0ylF49xN0TXUWJegEALUiAj8GEJS1Rbl+uQg//Fyxh4DPvV0aGRfp7GgLIRiOo6cvhimTatDZE8GsqX6YpjkcbNL19HcY29uC0HQTO9oHGHSignA0tECtnwSjr7PYQ7FEERIt6ESrnFLsoVi2KdiJvkQEfYkI9g5MgioGk6TX93diS6gbQgDNntqUQaeuWBhtkX70x6PYMtADAaA3PnieztgApqY4ZkipzpfxeByrVq2ytG9vb++E+65ZswYej8eOoVGVi+sa/tm6Oe3rNbEwHHksNXai+GXMxcD7S+t2dYYRiiQQiiTgdTvQPzAYwDfMwXtL05Bo7RzAwprGIo+UiOzEoFOOzN1PM3WHAyhOP3EAwGR0IIRadguhnExu8kE3TDibVXhcDjQGBj8IKYoCVRn8oOlQ01flTm6qQUd3BJObfAUZLxEAuOfsi8hbL6V9XVEESukBfD364RehnM4hPfX2DMaCmbUN6EtE0eKtGw44AcDs2kZsGxgsF5xVm/oDQqPbh3qXD27VCQMSA1oMU7wBBFw+NLlrCjJ+omqxqacd8XEegDbkMcsJAFzFvBGmsjCpwYvgQBx1tW7U+ZzQdBOTmxQou7M9FQVoaeA9JFGlYdApR4YcjMwnVOcEe+aXS2hoQg+6JJ8MjOR2u7FmzZqcznHdddeht7cXDQ0NuOeeezI+XkqJRCIBl8uVdQlFrmMY4na7x319+uQ6TJ9cl/pYl4owAIcjfdBp1lQ/Zk31Zz0+omw4p8yG4vbBTLMiU63Lg5hWnEzUVITIfZUnUxTuEcMUXyBlFtPsukbMrls27rEu1YGjp+5t+VqlMGePHk+qbRON8dZbb0UwGITf78ctt9yS8TWIsrEjOE7POCnRGOrN6/XdSOT1/KWkFOaqUrq/BKzNZfV+D5Yu3pPpO3XSYJXG424HImHA7XKgIcDMT6JKw6BTjoYynQa8tWgOdhd1LM3oRh8CZdUrJN+EEDmXLQy9kedyLq83t1IzO8ZAVKmEosI1eyFiH/0r5etepxsOJQzd5HLepa5U5uyJzj/Ree+8807br0s0HsM00TpOUKk2FoZby28mkgoDKkwYVbBOUanMVby/JKJyUPnvCnlm7s50CvpSZ4cUkipMTBYdxR4GEVHBuWYtguJJXa4lADT56oq1yCgRUd61D/SPu2hCUyj/K2cKUV3ZTkREZA2DTjkaynSKO1xIOIu/0kIAQXhRHs0EiYjsorg8qDnkRIg087Db4USTr24wAkVEVGG6o+n7xAlp5r20bohLsK8TERElY9ApR8PLPQuBoLf42U5CAFNEOz9XEVHVUesaULP0eAgldYmxz+lGo6eGgSciqjjaOFlO/kgor6vWjeRhM3EiIhqFQaccTRpRVlcKJXYA4BMxNIrCPNEiIioljsYp8B14TNrXa91eTPL5h1fKISKqBNo4QaWW/q6CjcOHaMGuRURE5YFBpxzVub1wOwZXrguVQKbTkBZ0sq6eiKqSc8oceBcflvZ1r9OFltoAHArfAomoMmhm6kwnp55Afbi/YOPwIJbz6pxERFRZeMedIyEEJtUMLhGfcLoQc5XGyg+KkJgmdrGKhIiqknv2PnDP2z/t6y7Vgcm19fA4nQUcFRFRfsjdPUZHm9TfDaR5LR+EALzMdiIiohEYdLJBy+6gEwC0108q4kiS+UQMzaK72MMgIioKz4KD4Fl4cNrXVUVBS00A9Z4armxHRGVtKOs+iZSYFCxcad2QGhEp+DWJiKh0Mehkg0kjgk5d/iYYauomtsXQjG42dSSiqiSEgGfefoPNxVVH2v38Hi9aalhuR0Tly5Mi6BQIB+HSCt9qwQcGnYiIaA/eYdtgUo0fijL4mNxUVHQESifbSRES01lmR0RVzDl5FmoPPxWKtybtPm6HE1Nq6+FluR0RlaFUmU6T+zuKMBLAixgUFK6kj4iIShuDTjZwO5zYu3HK8Nft9ZMgS6hWwyPimCQKn15NRFQqVH8jao/4NzjGKYFWFAWTagIIeHxgpJ6IysnoTCdPIoZAOFiUsQgB1ImBolybiIhKD4NONlkyedbwnzWHC911jUUczVjN6IYXsWIPg4ioaBS3FzWHngzXtLnj7hfw+NBS44dSQg8PiIjG43W4kr6e3FecLKchfoSKen0iIiodDDrZpMFbg5mBpuGv2xpaijiasYQAZohWLmNLRFVNqA54DzgGnoVLx93P43ChpTYAlX2eiKgMeJ17gk6qoaM5WNyFZGoxwBI7IiICwKCTrfabsifbKer2oX9Eg/FS4BIapor2Yg+DiKioBhuM74+ag0+AcLrS7udSHZhcywbjRFT6RgadmoPdUMziPmRUhEQtS+yIiAgMOtlqSm09mmvqhr/eOmkmZIl9WAmIIOpFf7GHQURUdM6Wmag94jSotfVp93EoKlpqAyy1I6KS5lBUOFUVkBIt/aXRx9MPBp2IiIhBJ1sJIbD/lNnDX8ddHuxomlbEEaU2Fe1wo/BL6BIRlRq1JoDaI06Dc0RfvtEciopGX20BR0VElDmnqqI2NgBPojR6eLLEjoiIAAadbDenfhKmB/Y0EW+rb0HY4yviiMZShMQM0crFmYiIAAiHE76DjoNn/sfS7uNzulHrchdwVEREmXEqDrT0F7eX00iqMLmKHRERMehkNyEEjpm9D1wOx9AGbJ48e7CTdwnxiDgmi+KubEJEVCqEEPDMPxA1S4+HGLX0+JBat7fAoyIiss4NicaB3mIPI0kD+oo9BCIiKjIGnfLA53LjyFkLh7+Oun1obZhSxBGl1ohePoEiIhrBOXkWag8/FYp7bIaqS3UM9kwhIipBDf3dEEVuID6aDxG4oRV7GEREVEQMOuXJ3MbJmNvYMvx1a+MUxFyeIo5oLCGAadgFJ/RiD4WIqGSodQ2DgacUK5C6VUcRRkRENLG6EmkgPpIQQL3oK/YwiIioiBh0yqPDZy2EzzW4hK1UlJIss3MIE9PZ34mIKIniq0Xt4adCrW9O2s6WuERUiqRpwBsJFXsYKdWjn/eZRERVjEGnPPI4nDhq9j7DXw94a7F10owijii1GhHFJFF6T8eIiIpJcXlQu+xkOCZNH97GoBMRlSKjvxuKLK3SuiEOYcAvSjMgRkRE+cegU57NDDThwKlzhr/uqG9BR/2k4g0ojWZ0owaRYg+DiKikCIcTNUuPh2v6PABAQmdvEiIqPUZvB0SJZdOP1IDSanBORESFw6BTARw0bS/Mb546/PW2STMQ9NUVcURjCQFMF7vggFHsoRARlRShqPDufzSMaXOhl1iTXiIiANB726GUcNDJhyi8iBV7GEREVAQMOhWAEAJHzlqIGYFGAIAUCjZMnYu4y13kkSVzCh3TRWuxh0FEVHKEENg6aSa6/U3FHgoR0RjGQB8UUbq39UIAzaK72MMgIqIiKN13pwqjKgqOm7sfmmsGM5wM1YGPpu0No8SW364VETSLnmIPg4iopBimiQ+7WrF58iz0p1jVjoiomITqgKqU9m19HQbgAkuUiYiqTWm/O1UYp6ripL0PgN/jBQDEXB5smDIXpbakRws64UO02MMgIioZm3s7ENUSw5mqYU9NsYdERDRMON1QSzjTCRjMdmrig00ioqpT2u9OFcjrdGHl3gfA43QCAII1fmydNLPIo0o22N+pFSrYu4SICADe79wx/GdTUfHR9L0Rc3mKOCIioj2E0w23w4ESbusEAKhHP/uHEhFVmYoJOr3++us45ZRT0NDQgJqaGixbtgyPPPJIsYeVkt/jw8q9D4DL4QAwuKLdjubpExxVWC6hY6poL/YwiIiKrjsSQudAMGmbrjqwbvre0BzOIo2KiGgP4XRBEQrcJT4nKUKiUXAlOyKialIRQacXX3wRRx11FP7yl7/gnHPOwX/+53+iq6sLn/zkJ3HHHXcUe3gpNdf4ceqCg+B1ugAAuxqnYGfTtCKPKllABBEQwYl3JCKqYOu6Ui+wkHC68dG0vSFLvKSFiCqf4h0s+fU6XEUeycQa0ctseiKiKlL2d8q6ruOyyy6DEAIvv/wyfvSjH+Huu+/G22+/jcWLF+OWW27B+vXriz3MlBp9tTh14UGo2b2KXWvTVLQ2TS3yqJJNRTtc0Is9DCKiotkV6kv7WsTjw5aW0iqRJqLq45q5EEJRBx9mlniJnSpM9nYiIqoiZR90+vOf/4yNGzfioosuwsc+9rHh7XV1dbj55puh6zoefPDBIo5wfAGPD6ctXDrcXHxn41TsapxS5FHtoQoT00Vrqd+/EBHlRVzX0BcNj7tPV6AZXf6mAo2IiGgsxe2Fa/Y+cCgq6sqg3xyznYiIqoej2API1YsvvggAOOmkk8a8NrTtpZdeKuSQMlbr9uDUhQfh6fVvoTcSxo7dZXZTe9qKPLJBPhFFM7rRKSvvQ5WUEvF4fMJ9AMCUJvrDA3Cre/7ZxA0dCVNHwjDQUFMLCAGP6oBiodxGSgmzvxNS16F5A5AAMNAL4W+CEAJGsAtQnVBrApCmMXxMJNgLGRmAUtcAmYgBAITbCxnqg2fSFCA6AKhOKB5fXn4OUkrEYrG0+7ndbsQTBtwuFaLUO5oSTSCiJSztt6VlFnzxCHzxyl35c/Q8YZgmNGnAozqhmwYMKS3NE7ppIK5IuBQVdS5vRmMwEzHEExpgaIDLAyEUSNOEGQtB6AZEXcOYMZh6ArK/G4CE8PkBpxsCEp6aOs5RVFHcc5cgsfUD1HtqENUS0M3SDeqowkQTetAhm4s9FNuFtQQ8qgotoUEzBu/fnKo6PE+6FBVRQ4e5+/djmmbSfCmlRNTQd99PCrjd7ozmKmmaMDu3QaouxJ1eoGsHUNcAIRTAUwMZDgLSBBwOmLvHJ00T4e3rgdp6qN46yEQUppQQWhzS5YNIROD21ECoChRvrbVxSIlYXAeknnb8pimhGeaE7x26YQKQqPH5OG8TlSEhh/6Vl6lzzz0Xv/zlL/HGG29g6dKlY16fNGkShBDo6OhIeXw8Hk+6iQ4Gg5g5cyb6+/vh9/vzNu5UYrqGZ9e/jc5wEJASM7t2YkpvaTTzlhLYLGcjivw9Pav3O/Dx00/J2/lTicViWLVqlS3nOuCaT2FOYwum+QI4eureE+5vvPtX4LXfIhaP4z9e7bJlDD86/yh4EhHA5YZy7IUQfms3c3b+HFZ/4z509Wto8Huwz9zKC1RSdYnpGn7+1l8s7etOxLB4+4dQjfyvzGT6G3DgaZfl/Toj2TlP7PX5cxHw1eKM2fthYb217F4Z6kH0rZdw2f/8wpYx/OQ7d8M7qbR6KRLlKvrB64hvfhdRLTF4P1nCDKlgvZwHI8+FF6oicd5FZ+T1GkPW9bXjo/521MGJB264zZZzrlmzBh6P9ftv4+mfABv+hZhu4j/+0WfLGADgRyfMg6dxEpQjzoBomT3h/h9t6cGujn788L6v2jaG+7/3QzQ11Nl2vlITDAYRCASK8jmUKJ/KPtOpv78fABAIBFK+7vf7sWPHjpSvAcCdd96JW2+9NS9jy5TH4cTHFxyIV7d9hKiWgOlvRLTdD0+J3DRMNzXsimX2VDoTtXX5O3chhPU44oaGoBaDKSWUiZ7E9LUDugYYNj6J7OsEPB4gEYMMBy0HnewUjmqD/49oBb82kd3cqgPTA42AxcczIZcbgc6d+R0UAGddfd6vkU+6aSBh6OiKhbHQ6kHREGBn5kZkwL5zEZUI99wlMEK9qINEKNiLqMVszWJQALQkNAT1/JYDqmrhuon0JwazXYNa+ozw/A+iEzANe+dLANCigBaHHOiHaJl496H7QTtF4+wzS1SOyj7T6aSTTsJzzz2H9evXY++9x2aXzJs3Dzt27EhbOlRKmU5UeFbKym699VYEg0F4amtwybWfw1x/M1ShwDANrOvrwM5IH4JaDLPqJyHg8mCyz4/J3on/7pgD/ZB/fxIyOoD44qMH+2Zt+xCYfxBQ2wj56m8BlxviYyfgtltvRTAShb+xGTeddzLQtgnYawlEOAiYJmTDZIhdG+GauwRK2xbAVwexaBmEotr+c/D7/bjlllvS7mdIBe3dETTXe+GvdVu6PhGVvtHzxK5IP/oSEcyra0FbtB9RXcNj3/nBhPPExmAnPgh1IuDx4ujJe8NjcYl3aZqQO9YhFgkDUkI0T4Ooa4Ls64D50RuAoUMsOQq33Xt/0hiM9f8CPvo7YAKYuQAiMAnC6YZ7r32hqGX/7I2ISkhYS2BzqAstnlrUCic2hwYz2efWNWPbQA/ipo4mdy3aokE8fO/9CAVDCAQC+ObXbx8+R0iLY9tAD6b5Amhw+zIurzN2bgD+/ntIhwtx/2Rg23tArR9omgHUNgDtWwE9AbjcuP33f0N/XEPA58VNR80DpsyD2O8ooH0LZG8HhKFBujxAOAi31welpg5i4TII58T3d6FwAh09YTTUOeHzpJ5r+0Jx9IfiePCBbyMUSv3eIaVEW2cYpgT2mtkIRSn7lsRpMdOJKlXZB51yLa8bjf/YiYiIiIiIqJD4OZQqVdmHiufPnw8AWL9+/ZjXent70dXVNbwPEREREREREREVRtkHnZYvXw4AePbZZ8e8NrRtaB8iIiIiIiIiIiqMsg86HX/88Zg7dy4eeeQRvPXWW8PbQ6EQbrvtNjgcDlxyySVFGx8RERERERERUTUq+w6aDocDP/7xj7Fy5UocffTRuPDCC+H3+/HrX/8amzdvxu23344FCxYUe5hERERERERERFWl7INOAHDsscfilVdewS233IInnngCiUQCixcvxm233YZPfvKTxR4eEREREREREVHVKfvV6+zGVQOIiIiIiIiokPg5lCpV2fd0IiIiIiIiIiKi0sOgExERERERERER2Y5BJyIiIiIiIiIish2DTkREREREREREZDsGnYiIiIiIiIiIyHYMOhERERERERERke0YdCIiIiIiIiIiItsx6ERERERERERERLZj0ImIiIiIiIiIiGzHoBMREREREREREdmOQSciIiIiIiIiIrIdg05ERERERERERGQ7Bp2IiIiIiIiIiMh2DDoREREREREREZHtGHQiIiIiIiIiIiLbMehERERERERERES2Y9CJiIiIiIiIiIhsx6ATERERERERERHZjkEnIiIiIiIiIiKyHYNORERERERERERkOwadiIiIiIiIiIjIdgw6ERERERERERGR7Rh0IiIiIiIiIiIi2zHoREREREREREREtmPQiYiIiIiIiIiIbMegExERERERERER2Y5BJyIiIiIiIiIish2DTkREREREREREZDsGnYiIiIiIiIiIyHaOYg+g1EgpAQDBYLDIIyEiIiIiIqJqMPT5c+jzKFGlYNBplFAoBACYOXNmkUdCRERERERE1SQUCiEQCBR7GES2EZKh1CSmaaK1tRV1dXUQQhR7OEQABp98zJw5E9u3b4ff7y/2cIiIShbnSyIiazhflhYpJUKhEKZNmwZFYRccqhzMdBpFURTMmDGj2MMgSsnv9/OmgIjIAs6XRETWcL4sHcxwokrEECoREREREREREdmOQSciIiIiIiIiIrIdg05EZcDtduOWW26B2+0u9lCIiEoa50siIms4XxJRIbCROBERERERERER2Y6ZTkREREREREREZDsGnYiIiIiIiIiIyHYMOhERERERERERke0YdCLKkxUrVkAIUexhkE0eeughCCHw0EMPFXsoREREREREZYFBpzK3ZcsWCCEghMD06dNhGEbK/d55553h/RYtWpRyn0ceeQTLli1DTU0NGhoacMopp+CNN97I5/CJcnLJJZdACIEtW7bkfK6hf0uXXHJJzucispsdc30kEsE999yDiy66CIsWLYKiKOP+++nu7sYDDzyA008/HXPnzoXb7UZzczM+/vGP45lnnslo/C+++CIuuugi7LPPPqivr4fP58PChQuxatUqrFu3btzvd+g/n8+HadOm4fjjj8fXvvY1bNy4MaMxFMLQw4bx5qRU+7z44ovD3+fnPve5lMcNBb6/+c1v5jTGOXPmYM6cOTmdg6iUlft8+corr+C6667D0qVL0dTUBI/Hg0WLFuHLX/4y+vr6xv1+OV8O4nxJVFoYdKoQDocDra2tad/YfvKTn8DhcKQ9/o477sAnP/lJtLe344orrsB5552Hv/71rzjyyCPx4osv5mnUROXjzDPPxAcffIAzzzyz2EOhKpbLXN/R0YEvfvGLePTRRxGLxdDQ0DDutX7xi1/g8ssvx5tvvomjjjoK1157LT7+8Y/jpZdewsknn4y7777b8riff/55vPLKK1iyZAkuueQSfO5zn8OCBQvw05/+FAcccABeeOGFlMfNmzcPt9xyC2655RZcddVV+PjHP46Ojg7cdtttWLhwIW688UZU2iK8DzzwQEl+QCQqN+U6X55zzjn4zne+g7q6Onz605/GlVdeCZ/Ph29961s4+OCD0dHRkfI4zpdEVLIklbXNmzdLAPKYY46RgUBAnn322WP2icfjsrm5WZ5++ukSgFy4cGHS6x999JF0OBxywYIFsq+vb3j7u+++K30+n5w3b57UNC3v30ulWb58ueQ/sfy6+OKLJQC5efPmnM819G/p4osvzvlcRHazY64PhULy2Wefld3d3VJKKVeuXDnuv58//elP8ve//700DCNp+4cffigDgYB0Op1y586dlsYfjUZTbn/++eclAHnwwQen/H5XrlyZ8riXX35ZzpkzRwKQN910k6UxFMLQvD/enJRqnxdeeEECkPPmzZMA5Pnnnz/muAcffFACkHfeeWdOY5w9e7acPXt2TucgKmXlPl9+85vflK2trUnbTNOU//mf/ykByCuvvDLl98v5cg/Ol0SlhZlOFcLr9eL888/Hk08+ia6urqTXfve736GrqwuXXnppymMffPBB6LqOr371qwgEAsPbFy9ejE9/+tPYuHEj/vznP1sahxACK1aswM6dO3HRRRehubkZdXV1OPXUU7Fp0yYAwLp163DmmWeisbERdXV1OPfcc1M+tVmzZg3OOOMMzJkzBx6PB42NjVi5cmXKJ+JDqbarV6/Gm2++iZUrV6Kurg6BQABnnnnmmNTdiUqphr6Pkf75z3/ic5/7HJYsWYJAIACv14v99tsP3/zmN6FpmqWfz3h+9atfYfny5WhpaYHH48HMmTNx8skn47e//e2YfdeuXYsLLrgAU6dOhcvlwuzZs/H5z38e3d3dKc/9wx/+EIsXLx4+7/XXX49YLJby+xxKZY7H47jxxhsxa9YseL1eLF26FM8//zwAIBQK4Qtf+AKmT58Oj8eDww8/PG0pZkdHB6655hrsvffew+nmZ599Nt59990x+w6lMYfDYVx77bWYPn063G439t9/f/zyl78cs+/DDz8MANhrr72GU61Hfj+/+c1vcOGFF2LvvfeGz+dDIBDA0UcfjV/96ldJ53rooYew1157AQAefvjhpBT1oUy/8Xo6vfrqqzj11FPR2Ng4nAa/evVqRCKRMfsOjbGzsxOrVq1CS0sLvF4vDjvsMGYV0oRymetra2tx4oknorGx0dK1jjvuOJx66qlQlORbhYULF+L888+Hpml49dVXLZ3L4/Gk3H788cejoaEBGzZssHSeIUcffTSeeeYZuN1ufOtb38L27dsnPCbT9wmg8P9eTzjhBCxfvhxPPPEE/vnPf1o+zso8O/S+t3XrVmzdujVpnlu9erXt3wtRsZXrfPnlL38ZU6dOTdomhMDNN98MAHjppZcsnWcI58tknC+JCo9BpwqyatUqJBIJ/PznP0/avmbNGrS0tOC0005LedzQG8FJJ5005rWVK1cCyOwNrre3F0cddRQ2b96Miy++GCtWrMAf/vAHnHjiiXjvvfdw+OGHIxQKYdWqVTj44IPxy1/+Ep/85CfHnOf//b//h/b2dpxwwgm45pprcNppp+G1117DCSecgP/7v/9Lee033ngDRx99NBwOBy6//HIcfPDB+O1vf4sTTjgBsVjM8veQyo9+9CP85je/wX777YfLL78cn/nMZyClxA033IALLrggp3P/z//8D8455xysX78eZ555Jq699lqccMIJ2L59+5ig0+9+9zssW7YMTz75JFasWIGrr74a++23H7773e/i8MMPR29vb9L+X/va13DFFVegt7cXn/3sZ3HuuefiF7/4Bc4777xxx3T++efj8ccfx+mnn46LLroI7733Hk477TS8+eabOO644/DCCy/gnHPOwVlnnYV//OMfWLlyJYLBYNI5Nm7ciKVLl+I73/kO9t57b3z+85/HKaecgqeffhqHHXYY/v73v4+5rqZpOOmkk/DHP/4RZ511Fv793/8dGzduxHnnnYdnn312eL+rr74aBxxwAADgqquuGk4pHxlIvOGGG/Dee+/hqKOOwlVXXYVzzz0X69atwznnnIP7779/eL8DDzwQV111FQDggAMOGD7XLbfcMmEt/1Cw8MUXX8QnPvEJXH311aitrcWtt96KE044AfF4fMwxfX19OPLII7F27Vp88pOfxFlnnYU33ngDK1euTBmMIxop27neTk6nEwDGLdu24rXXXkNvby+WLFmS8bELFizA+eefj0QikTI4n06m7xOF/vd61113QUqJL3/5y5b2tzrP1tfX45ZbbkEgEEAgEEia50Y/fCCqFJU0X+ZyHs6XgzhfEhVJkTOtKEejU2oXL14s999//+HXd+zYIVVVldddd52UUqZMIW5ubpa1tbUpz//uu+9KAPLcc8+1NB4AEoC85pprkrZfccUVEoCsr6+X99133/B20zTlKaecIgHIN998M+mYTZs2jTl/a2urnDZtmpw/f37S9qFUWwDyscceS3rtU5/6lAQgH3300eFtE5VSAZDLly9P2rZlyxap63rSNtM05apVqyQA+corryS9lkl53UEHHSRdLpfs6OgY81pXV1fSn/1+v5wxY4bcunVr0n6PPPKIBCA/97nPDW9bt26dVFVVzpo1K+k8oVBILl68OOX3OTTuI488Ug4MDAxvf+yxx4Z/h+eee25SyeVdd90lAch777036VxHHHGEdDgc8tlnn03avm7dOllXVyf322+/pO2zZ8+WAOQZZ5wh4/H48PahEpzRqeMTlddt3LhxzLZQKCT3228/GQgEZDgcHt4+0d+JoVTtBx98cHhbMBiU9fX10u12y7fffnt4u2ma8qKLLpIA5G233ZZ0nqG/p1deeWVSGv6Pf/xjCUBefvnlKa9P1c2OuX60icpF0gkGg3Ly5MnS4/EkzStWvPDCC/KWW26RX/nKV+TZZ58t3W63bG5ulq+//nrSfhOViwz5yU9+IgHIT33qU5auncn7hJSZ/3vNtVxk6HxnnXWWBCCfeeaZ4X3SlYtkM8+yXIQqWaXMl6MN3Wt96UtfStrO+ZLzJVGpY6ZThbn00kuxdu3a4TTThx56CIZhYNWqVWmP6e/vTyqrG8nv9w/vY1VtbS1uu+22pG0XXXQRAKCpqQlf+MIXhrcLIYazhN5+++2kY4bKnUaaOnUqzj77bKxfvx5bt24d8/oxxxyD888/P2nb0Pf++uuvW/4eUpk9ezZUVU3aJoTA//t//w8AhkvPsuV0OoefYo3U1NQ0/Oef/vSnCAaDuPPOOzFr1qyk/S688EIcdNBBeOyxx4a3PfroozAMA9ddd13SeWpra3HTTTeNO55vfOMbqKmpGf76nHPOgdPpRF9fH+6+++6kJ20XXnghgOTf4b/+9S+8+uqruPjii3HiiScmnXvBggX4j//4D7zzzjspn3x9+9vfhsvlGv76+OOPx+zZszP+Hc6dO3fMttraWlxyySXo7+/P+e/Eb3/7W/T19WHVqlXYf//9h7cPrZjicDhSluPV1NTgrrvuSkrDv/jii+FwOHIeE1WHbOZ6u1xxxRVob2/HjTfemDSvWPHiiy/i1ltvxTe/+U386le/wsyZM/H000/j4IMPzmos06ZNA4AxpTPjyfR9ohj/Xu+44w44HA585StfGbfxby7zLFG1KNf5cqS33noLt956K1paWnD99ddndQ7Ol5wviYoltzxPKjmf+tSncMMNN2DNmjVYunQpHnroIRx66KHYd999CzaG+fPnJwUrAAzXpu+///4QQqR8befOnUnbN23ahDvvvBN//vOfsXPnzjFlSq2trZg9e3bStoMOOmjMeGbMmAEAKZeZzUQikcB3v/tdPPbYY/jwww8xMDCQ9ObW2tqa9bnPO+88fOUrX8GSJUtwwQUXYMWKFTjqqKNQX1+ftN/f/va34f+n6oESi8XQ1dWFrq4uNDc3DweBjjjiiDH7pto20sc+9rGkr1VVRUtLC8Lh8JiAV6rf4dBY29raUta/f/jhh8P/H1laU19fnzLgOGPGDLz22mvjjnm0jo4OfPOb38Qf//hHbN26FdFoNOn1XH5nwOANDICUqdYzZ87EvHnzsG7dOoRCIdTV1Q2/Nn/+fNTW1ibt73A4MHny5Jz/nlJ1KNZcf+ONN+KRRx7BySefjBtvvDHj41evXo3Vq1cjHA7j/fffx9e//nUceeSRWLNmzfDDiUyM9wEjnUzfJ4rx73XhwoVYtWoVHnjgATz66KNpfzbZzrNE1aRc58shmzdvxmmnnQbDMPDYY4+hubk5q/NwvuR8SVQsDDpVmJaWFpxyyil49NFHcfrpp2PDhg344he/OO4xgUAgbSbTUI+edJlQqQxlR400lBUz3msjm3Fv2LABy5YtQzAYxLHHHot/+7d/g9/vh6IoePHFF/HSSy+l7JWTapxD5zcMw/L3kMo555yDJ598crguvqWlZTjz5zvf+U7K8Vh1/fXXo6mpCT/4wQ9w77334p577oHD4cApp5yC++67bzgI09PTAwD43ve+N+75wuEwmpubh39/kyZNYw9/GAAAEo5JREFUGrPP5MmTxz1Hut/VeD/jkb/DobE+9dRTeOqpp8Yd60jp/q45HA6YpjnumEfq6enBIYccgm3btuHII4/ECSecgPr6eqiqirfeegv/93//l9PvDNjz7yPdz3LKlClYt24dgsFgUtBpvO8x17+nVB2ymetzdeutt+LOO+/Ecccdh1//+tdjMj8zUVNTg0MOOQS/+c1vcPDBB+Ozn/0sTjzxxJRz1Xh27doFIPUcl06m7xOZ/Hsdero/3lw19NrohsOjrV69Gj/72c9w880345xzzkm5T7bzLFE1Kef5cuvWrTj22GPR2dmJX/3qVzj22GOzHhPnS86XRMXC8roKtGrVKvT29uIzn/kMvF7vcOlTOvPnz8fAwADa2trGvLZ+/frhfQrp29/+Nnp7e/Hwww/jueeew3333Yevf/3rWL16NRYtWpTz+YfevHRdH/NaqgDc66+/jieffBIrV67E+++/jx/96Ef4xje+gdWrV+fcRBwYLMe67LLL8MYbb6CzsxO/+c1vcNZZZ+F3v/sdTj311OE36qFA0DvvvAMpZdr/hjLAhvbv7Owcc8329vacxz2eoWvff//944714osvzsv1f/KTn2Dbtm24/fbb8corr+D+++/HbbfdhtWrV+Owww6z5RpD32O6n+XQ9lQBPKJcZTrX5+LWW2/F6tWrsWLFCjz55JPwer22nNfhcODYY49FOBxOuwLmeIYWwjjkkENsGU+uhj5wpVtJFNhT2jLRw5ypU6fi6quvxqZNm/DDH/4w5T7FnmeJykU5zpdbtmzBihUr0NraiieeeCLnpuecLzlfEhULg04V6JRTTsGUKVOwc+dOnH322RN+4F2+fDkAJK0MNuSZZ55J2qdQNm7cCAA4/fTTk7abpom//vWvOZ9/qGxtdEkfsKdkKtV4Tj311DFPq/7yl7/kPJ6Rmpqa8IlPfAKPP/44jjvuOHzwwQfDpXSHHnooAFguMxta3S3VMr1Wl+7NVqZjzcbQ7yLV07Z0f4eA1L+z8c6VzlAJYqqlgHfu3ImNGzdi7ty5SVlORHbJdK7P1lBJ3PLly/HUU0/B5/PZev6hMtdMV2T66KOP8MQTT8DtduPMM8+0dUzZ2m+//QCkn/e6u7uxfv16zJo1y1IG8Ze//GU0NTXhtttuQygUGvN6NvOsqqrMqKSqU27z5VDAaefOnXj88cdxxhln5DQuzpecL4mKiUGnCuRwOPC73/0Ov/nNb/CNb3xjwv0vvfRSOBwOfOMb30jK8nnvvffw05/+FPPmzcNxxx2XzyGPMZSp88orryRtv+uuu2xp8Of3+7FgwQK88sorSb2RQqEQbrjhBsvjee+993DnnXfmPJ5nnnlmTNaVpmnDqcBDT8kuvfRS1NXV4atf/Sree++9MeeJRCLDNesAcMEFF0BRFNx7771JT5LC4bClvxu5WLZsGQ499FA8+uijePzxx8e8bpomXnrppZyu0djYCADYsWPHmNfS/c4eeeQR/OEPfxizf0NDA4QQKc+VzhlnnIFAIIAHH3ww6fchpcQNN9wATdNwySWXWD4fUSYyneuzccstt+DWW2/F0UcfndMHqJdffjllP5Fnn30Wv/nNbxAIBCbsMzfSK6+8gpUrVyIej+OGG27A9OnTsxqX3f793/8diqLgv/7rv8bMJaZp4ktf+hJ0XcenP/1pS+fz+/346le/is7OTnznO98Z83o282xjYyO6urpSLndOVKnKab4cGXB67LHHcg4Scb4cxPmSqHjY06lCHXLIIZbTZxcsWIDVq1fjpptuwv77749zzjkH4XAYjz76KDRNw49+9KOMn0Dn6oorrsCDDz6Is846C+effz6amprwt7/9DW+++SZOPfXUcWuxrbr22mtxxRVX4PDDD8e5554L0zTxxz/+MeUqSsuWLcOyZcvwxBNPYNeuXTjssMOwbdu24fK3X/7ylzmN5fzzz4fP58NRRx2F2bNnQ9M0PPfcc3j//fdx/vnnDzfunjRpEh599FGce+65OOCAA3DyySdj0aJFiMVi2Lp1K1566SUcccQRePrppwEMNlf8yle+gjvuuAP77bcfzj33XDgcDvz617/Gfvvth3fffXfCOvlcPProozj22GNxwQUX4L777sPSpUvh8Xiwbds2vPbaa+js7Mzpjfy4447D3XffjcsvvxznnnsuampqMGvWLFx00UX41Kc+hbvuuguf//zn8cILL2D27NlYu3Ytnn/+eZx11ln49a9/nXSu2tpaHHLIIXj55Zdx6aWXYv78+VAUBRdddNGYxulD/H4/fvSjH+HCCy/EoYceivPPPx+TJk3Cn/70J7zxxhtYtmwZvvSlL2X9/RFNJJO5HgC++MUvDpcrvPPOO8Pbhhq/fuUrXxkuYX7ooYfw9a9/HQ6HA8uWLcN//dd/jTnfihUrUjbSH+30009Hc3MzDjnkEMycORPRaBRr167Fyy+/DKfTiR//+MdjFqAABvv7DTV8TSQS6OjowN///ne8++67UFUVN910E772ta9Z/v7zbcGCBbj77rtx3XXXYd9998UZZ5yB2bNnIxgM4rnnnsOHH36Iww8/PKOmwldeeSW+853vDGdvjpbpPHvcccfhjTfewL/927/h6KOPhsvlwlFHHYWjjjoq5++fqJSVy3y5YsUKbN26FYcddhjWrl2LtWvXjtknVSNszpecL4lKlqSytnnzZglArly50tL+AOTChQtTvvazn/1MHnzwwdLr9cpAICBPPvlk+Y9//COj8QCQy5cvTzvOiy++eMxrL7zwggQgb7nlljHbjzzySFlXVyfr6+vlKaecIv/5z3/KW265RQKQL7zwwoTnmOja999/v9x7772l0+mUs2bNkl/72tdkIpFI+X10dHTIVatWyWnTpkmPxyP3228/+b3vfU9u2rQp5fmXL18urf4T+/73vy9PP/10OXv2bOnxeGRTU5M89NBD5Q9/+EOpadqY/T/88EP5mc98Rs6ePVu6XC7Z0NAg99tvP/mFL3wh5e/s+9//vtxnn32ky+WSM2bMkF/84hfl9u3bJQB5xhlnWB737Nmz5ezZs1O+lu5339PTI2+66Sa5ZMkS6fV6ZW1trZw/f7686KKL5K9//WvL5083rm9961ty/vz50ul0jhnDW2+9JU866STZ0NAg6+rq5PLly+Xzzz8vH3zwQQlAPvjgg0nnWrdunTzllFNkfX29FEIk/T1Ld4yUUr788svy4x//uKyvr5cul0suWLBA3nzzzXJgYMDyz2mi75+qm11z/ezZsyWAtP+NnFeH5trx/ks156Zy3333yZNPPlnOmDFDut1u6fF45Pz58+Vll10m33333bTf78j/vF6vnDp1qjz22GPlzTffLDds2GDp2kOyeZ/I9t/rn//8Z/mJT3xCTpkyRTocDun3++WyZcvkPffcI2OxWNqxXX755SnP99Of/nT453DnnXeOeT2TeTYUCsn/+I//kFOnTpWKomT0eyQqB+U+X050ntH3Qpwvk3G+JCo9Qsos1s8korL3/PPP48QTT8T111+Pu+66q9jDISIiIiIiogrDnk5EFa6zs3NME8S+vr7h3lWf+MQnijAqIiIiIiIiqnTs6URU4X7+85/j7rvvxnHHHYdp06Zh165dePrpp9HR0YFLLrkEhx9+eLGHSERERERERBWIQSeiCnfEEUdg6dKleP7559HT0wNVVbHPPvvg5ptvxpVXXlns4REREREREVGFYk8nIiIiIiIiIiKyHXs6ERERERERERGR7Rh0IiIiIiIiIiIi2zHoREREREREREREtmPQiYiIiIiIiIiIbMegExEREdlqzpw5mDNnTlGuvXr1aggh8OKLLxbl+kRERES0B4NOREREZW7Lli0QQkAIgenTp8MwjJT7vfPOO8P7LVq0KOvrMbBDRERERFYw6ERERFQhHA4HWltb8cwzz6R8/Sc/+QkcDkeBR0VERERE1YpBJyIiogpxxBFHIBAIYM2aNWNeSyQS+PnPf45TTjmlCCMjIiIiomrEoBMREVGF8Hq9OP/88/Hkk0+iq6sr6bXf/e536OrqwqWXXpryWCkl1qxZgyOPPBJ+vx8+nw8HH3zwmADWihUrcOuttwIAjj322OFyvVQ9nMLhMK699lpMnz4dbrcb+++/P375y1+mvH53dzeuueYa7LXXXnC73WhpacH555+P999/P+X+27dvx4UXXojGxkbU1tZi+fLlePnllyf6ERERERFRATHHnoiIqIKsWrUKDzzwAH7+85/jqquuGt6+Zs0atLS04LTTThtzjJQS//7v/45HHnkECxYswEUXXQSXy4XnnnsOn/nMZ/D+++/j7rvvBgBccsklAICXXnoJF1988XCwqb6+PumcmqbhpJNOQk9PD8466yxEIhE89thjOO+88/D000/jpJNOGt63u7sbhx12GDZs2IAVK1bgggsuwJYtW/DLX/4STz31FJ577jkcfvjhw/vv2rULhx9+OHbu3ImVK1fioIMOwgcffIATTzwRxx57rE0/SSIiIiLKFYNOREREFeTQQw/F4sWLsWbNmuGg086dO/Hss8/i6quvTtnT6cc//jEeeeQRfOYzn8EPfvCD4X0SiQTOOecc3HPPPbjwwguxdOlSXHLJJdiyZQteeuklXHLJJVixYkXKcbS2tuKQQw7BCy+8AJfLBQC46KKLcMIJJ+Dee+9NCjpdf/312LBhA2644Qbccccdw9svueQSnHzyybj44ovx4YcfQlEGE7RvuOEG7Ny5E7fffju++tWvDu//wAMP4PLLL8/tB0hEREREtmF5HRERUYW59NJLsXbtWvzzn/8EADz00EMwDAOrVq1Kuf93v/td1NTU4Lvf/W5SUMrlcuEb3/gGAODRRx/NeBzf/va3hwNOAHD88cdj9uzZeP3114e3JRIJPProo2hqasJNN92UdPzKlSuxcuVKrF+/Hq+++urw/o8//jhaWlpw3XXXJe1/2WWXYcGCBRmPk4iIiIjyg5lOREREFeZTn/oUbrjhBqxZswZLly7FQw89hEMPPRT77rvvmH0jkQjeeecdTJs2Dd/85jfHvK5pGgDgww8/zGgM9fX12GuvvcZsnzFjBl577bXhrz/88ENEo1GsWLECPp9vzP4rVqzAM888g7feegtHHXUU1q1bh1gshuOOOw4ejydpX0VRcMQRR+Cjjz7KaKxERERElB8MOhEREVWYlpYWnHLKKXj00Udx+umnY8OGDfjiF7+Yct/e3l5IKbFz587hBuGphMPhjMYQCARSbnc4HDBNc/jrYDAIAJg8eXLK/adMmQIA6O/vT/p/S0tLyv3TnYeIiIiICo/ldURERBVo1apV6O3txWc+8xl4vV5ceOGFKffz+/0AgKVLl0JKmfa/F154IS/jHLp+e3t7yteHtg/tNxTM6ujoGHd/IiIiIio+Bp2IiIgq0CmnnIIpU6Zg586dOPvss4eDNqPV1dVhn332wQcffIC+vj5L51ZVFQBgGEbO41y0aBE8Hg9ef/11RCKRMa+/9NJLAIADDzwQALBw4f9v545ZGlmjMACfLCLBJhCw0MpCWNDKIohoIwRbO8UfIGKTXrQUNBAVeyHaCIIgiCg4WggaErA3jZjCRtFWrHS7XIS7LLgDu7jP0w3zwpz6/b453yObzcb19XW8vr5+yL69vbV3PwEA8OcpnQDgC+ro6IjDw8M4ODhoLwP/mVKpFC8vLzE7O/u/v9Hd3d1Fq9VqP+fz+YiIuL+//+05Ozs7Y2ZmJp6enmJlZeXDu7Ozszg5OYn+/v4YHR1t56empuLx8THW1tY+5Le2tuxzAgD4i9jpBABfVKFQiEKh8Mvc3Nxc1Ov12NnZiaurqygWi9Hb2xsPDw/RbDaj0WjE7u5u9PX1RUTE+Ph4ZDKZWFxcjGazGblcLnK5XMzPz39qznK5HBcXF7G8vBy1Wi2Gh4ej1WrF/v5+dHV1RbVajW/f/jsnW11djfPz81haWorLy8sYGhqKm5ubOD4+jomJiTg9Pf3UHAAApMtNJwD4x2Uymdje3o69vb0YHByMo6OjWF9fjyRJIpvNRqVSiWKx2M4PDAxEtVqNfD4fGxsbsbCwEOVy+dPf7+7ujkajEaVSKW5vb6NSqUSSJDE5ORmNRiPGxsY+5Ht6eqJWq8X09HTU6/XY3NyM5+fnSJIkRkZGPj0HAADpyry/v7//6SEAAAAA+FrcdAIAAAAgdUonAAAAAFKndAIAAAAgdUonAAAAAFKndAIAAAAgdUonAAAAAFKndAIAAAAgdUonAAAAAFKndAIAAAAgdUonAAAAAFKndAIAAAAgdUonAAAAAFKndAIAAAAgdT8APMNysag85ngAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -706,7 +755,7 @@ "# plot\n", "df1 = df_M0.copy()\n", "df1['Method']='M0 manual segmentation'\n", - "df2 = df_M12.copy()\n", + "df2 = df_M12_3d.copy()\n", "df2['Method']='M12 3D nnUNet'\n", "df3 = df_M12_2d.copy()\n", "df3['Method']='M12 2D nnUNet'\n", @@ -743,12 +792,12 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 36, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -795,9 +844,19 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Statistical test\n", + "\n", + "\n", + "In this section we look into a statistical test to compare M0 and M12 for each phenotype" + ] + }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 37, "metadata": {}, "outputs": [ { From 63dbb29a475dee0ab04e87db0d17368a0166dc5b Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Thu, 9 Nov 2023 17:35:19 -0500 Subject: [PATCH 27/34] added comment about use of image.py file --- dataset_analysis/README.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/dataset_analysis/README.md b/dataset_analysis/README.md index 09ad9be..ed639e3 100644 --- a/dataset_analysis/README.md +++ b/dataset_analysis/README.md @@ -18,6 +18,9 @@ To generate the dataframe run : python generate_dataframe.py --data /path/to/CanProCo --lesion /path/to/lesion/segmentation --discs /path/to/discs/segmentation --spinal-cord /path/to/spinal/cord/segmentation --timepoint M0 --exclude-file /path/to/exclude/file --output /path/to/output/folder ~~~ +> **Note** +> It uses the file `image.py` to fix the orientation of masks if they are not the same as the image's orientation + # Dataframe analysis The following Notebook `dataframe_analysis.ipynb` details the analysis of the generated dataframe. To use it, update the link to the CSV dataframes. From b4f6ef17a7bf78b1ffa963fd6df587bad9c06e90 Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Thu, 9 Nov 2023 17:41:46 -0500 Subject: [PATCH 28/34] fixed function names --- dataset_analysis/generate_dataframe.py | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/dataset_analysis/generate_dataframe.py b/dataset_analysis/generate_dataframe.py index 7cdbd27..9407f36 100644 --- a/dataset_analysis/generate_dataframe.py +++ b/dataset_analysis/generate_dataframe.py @@ -16,10 +16,10 @@ None Example: - python generate_dataframe.py --data /path/to/CanProCo --output /path/to/output + python generate_dataframe.py --data /path/to/CanProCo --lesion /path/to/lesion/segmentation --discs /path/to/discs/segmentation --spinal-cord /path/to/spinal/cord/segmentation --timepoint M0 --exclude-file /path/to/exclude/file --output /path/to/output/folder Todo: - * UPDATE documentation of this file + * Pierre-Louis Benveniste """ @@ -59,12 +59,14 @@ def get_parser(): def get_spinal_cord_info(patient_data, spinal_cord_path, timepoint): - """This functions computes the volume of the spinal cord for each patient. + """ + This functions computes the volume of the spinal cord for each patient. The volume is added to the patient_data dictionary. Input: patient_data : dictionary containing information about the patient dataset_path : path to the CanProCo dataset + timepoint : timepoint of the analysis (M0, M12) Returns: patient_data : dictionary containing information about the patient @@ -101,6 +103,8 @@ def analyse_lesion_per_levels(patient_data, discs_path, timepoint, output_folder Input: lesion_seg_file : path to the lesion segmentation file labelled_sc_seg_file : path to the labelled spinal cord segmentation file + timepoint : timepoint of the analysis (M0, M12) + output_folder : path to the output folder where the analysis will be saved Returns: patient_data : dictionary containing information about the patient @@ -286,6 +290,7 @@ def analyze_patient_lesion(patient_data, lesion_path, timepoint, output_folder): Input: patient_data : dictionary containing information about the patient dataset_path : path to the CanProCo dataset + timepoint : timepoint of the analysis (M0, M12) output_folder : path to the output folder where the analysis will be saved Returns: @@ -342,6 +347,7 @@ def analyze_patient_tsv(participant_id, participants_tsv, timepoint): Input: participant_id : id of the participant participants_tsv : pandas dataframe containing information about the participants + timepoint : timepoint of the analysis (M0, M12) Returns: patient_data : dictionary containing information about the patient From f3189d1dd3c9f49f3a4f887d2357b3983cef709f Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste <67429280+plbenveniste@users.noreply.github.com> Date: Mon, 13 Nov 2023 16:38:28 -0500 Subject: [PATCH 29/34] change analyse lesion description Co-authored-by: Jan Valosek <39456460+valosekj@users.noreply.github.com> --- dataset_analysis/generate_dataframe.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dataset_analysis/generate_dataframe.py b/dataset_analysis/generate_dataframe.py index 9407f36..1581f3a 100644 --- a/dataset_analysis/generate_dataframe.py +++ b/dataset_analysis/generate_dataframe.py @@ -97,7 +97,7 @@ def get_spinal_cord_info(patient_data, spinal_cord_path, timepoint): def analyse_lesion_per_levels(patient_data, discs_path, timepoint, output_folder): """ - This function focuses on lesions per spinal cord levels. + This function focuses on lesions per vertebral levels. It computes the number, volume and average length of lesions per spinal cord level. Input: From 964f10e75d9b535140cb1306a586e42e319e7c19 Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste <67429280+plbenveniste@users.noreply.github.com> Date: Mon, 13 Nov 2023 16:39:27 -0500 Subject: [PATCH 30/34] change description of analyse lesion Co-authored-by: Jan Valosek <39456460+valosekj@users.noreply.github.com> --- dataset_analysis/generate_dataframe.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dataset_analysis/generate_dataframe.py b/dataset_analysis/generate_dataframe.py index 1581f3a..fa4d35d 100644 --- a/dataset_analysis/generate_dataframe.py +++ b/dataset_analysis/generate_dataframe.py @@ -98,7 +98,7 @@ def get_spinal_cord_info(patient_data, spinal_cord_path, timepoint): def analyse_lesion_per_levels(patient_data, discs_path, timepoint, output_folder): """ This function focuses on lesions per vertebral levels. - It computes the number, volume and average length of lesions per spinal cord level. + It computes the number, volume and average length of lesions per vertebral levels. Input: lesion_seg_file : path to the lesion segmentation file From 5c79d5aa8ad81d3c57490083d0d231720e8fcc7d Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste <67429280+plbenveniste@users.noreply.github.com> Date: Mon, 13 Nov 2023 16:41:57 -0500 Subject: [PATCH 31/34] update analyse patient tsv description Co-authored-by: Jan Valosek <39456460+valosekj@users.noreply.github.com> --- dataset_analysis/generate_dataframe.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dataset_analysis/generate_dataframe.py b/dataset_analysis/generate_dataframe.py index fa4d35d..c6d325c 100644 --- a/dataset_analysis/generate_dataframe.py +++ b/dataset_analysis/generate_dataframe.py @@ -342,7 +342,7 @@ def analyze_patient_lesion(patient_data, lesion_path, timepoint, output_folder): def analyze_patient_tsv(participant_id, participants_tsv, timepoint): """ This function gathers information from the participants.tsv file. - It gathers information on each participant, their pathology (and the material used for image acquisition). + It gathers information on each participant, their pathology (and the acquisition parameters used for image acquisition). Input: participant_id : id of the participant From d10610662eb2935160443ad33b8b31d4cc395da4 Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste <67429280+plbenveniste@users.noreply.github.com> Date: Mon, 13 Nov 2023 16:45:50 -0500 Subject: [PATCH 32/34] changed iteration over disc not levels --- dataset_analysis/generate_dataframe.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dataset_analysis/generate_dataframe.py b/dataset_analysis/generate_dataframe.py index c6d325c..6d66ad5 100644 --- a/dataset_analysis/generate_dataframe.py +++ b/dataset_analysis/generate_dataframe.py @@ -149,7 +149,7 @@ def analyse_lesion_per_levels(patient_data, discs_path, timepoint, output_folder levels = np.unique(disc_seg_data) levels = levels[levels != 0] - #we iterate over the levels + #we iterate over the intervetebral discs (aka levels here) for i in range(len(levels)-1): #get upper bound of level upper_bound = np.where(disc_seg_data == levels[i]) @@ -459,4 +459,4 @@ def main(): if __name__ == '__main__': - main() \ No newline at end of file + main() From 42b1e988d552fd669a14fe58f9aacb7720c293e2 Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste <67429280+plbenveniste@users.noreply.github.com> Date: Mon, 13 Nov 2023 16:50:10 -0500 Subject: [PATCH 33/34] changed age description --- dataset_analysis/generate_dataframe.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dataset_analysis/generate_dataframe.py b/dataset_analysis/generate_dataframe.py index 6d66ad5..e302fea 100644 --- a/dataset_analysis/generate_dataframe.py +++ b/dataset_analysis/generate_dataframe.py @@ -358,7 +358,7 @@ def analyze_patient_tsv(participant_id, participants_tsv, timepoint): patient_data["site"] = participant_id.split('-')[1][:3] #sex patient_data["sex"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["sex"].values[0] - #age at M0 + #age at scan patient_data["age"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["age_" + timepoint].values[0] #pathology patient_data["pathology"] = participants_tsv.loc[participants_tsv["participant_id"] == participant_id]["pathology_M0"].values[0] From 250f606b1363e1bf8645cf6be246d37df20d506e Mon Sep 17 00:00:00 2001 From: Pierre-Louis Benveniste Date: Tue, 14 Nov 2023 11:14:58 -0500 Subject: [PATCH 34/34] limit spinal cord volume to C1-C7 --- dataset_analysis/generate_dataframe.py | 48 ++++++++++++++++++++++---- 1 file changed, 41 insertions(+), 7 deletions(-) diff --git a/dataset_analysis/generate_dataframe.py b/dataset_analysis/generate_dataframe.py index 9407f36..b1037ba 100644 --- a/dataset_analysis/generate_dataframe.py +++ b/dataset_analysis/generate_dataframe.py @@ -58,7 +58,7 @@ def get_parser(): return parser -def get_spinal_cord_info(patient_data, spinal_cord_path, timepoint): +def get_spinal_cord_info(patient_data, spinal_cord_path, discs_path, timepoint): """ This functions computes the volume of the spinal cord for each patient. The volume is added to the patient_data dictionary. @@ -77,17 +77,49 @@ def get_spinal_cord_info(patient_data, spinal_cord_path, timepoint): #now we find the spinal cord segmentation file sc_seg_file = os.path.join(spinal_cord_path, participant_id, "ses-" + timepoint, "anat", f"{participant_id}_ses-" + timepoint+ "_PSIR_seg-manual.nii.gz") + disc_seg_file = os.path.join(discs_path, participant_id, "ses-" + timepoint, "anat", f"{participant_id}_ses-" + timepoint+ "_PSIR_labels-disc.nii.gz") + if not os.path.exists(sc_seg_file): # If PSIR doesn't exist, use STIR sc_seg_file = os.path.join(spinal_cord_path, participant_id, "ses-" + timepoint, "anat", f"{participant_id}_ses-" + timepoint+ "_STIR_seg-manual.nii.gz") + disc_seg_file = os.path.join(discs_path, participant_id, "ses-" + timepoint, "anat", f"{participant_id}_ses-" + timepoint+ "_STIR_labels-disc.nii.gz") + #now we read the spinal cord segmentation file - sc_seg = nib.load(sc_seg_file) + sc_seg = Image(sc_seg_file) - #now we get the total volume of the spinal cord - sc_seg_data = sc_seg.get_fdata() - voxel_size = sc_seg.header.get_zooms() - sc_volume = np.sum(sc_seg_data)*voxel_size[0]*voxel_size[1]*voxel_size[2] + # we read the disc segmentation file + disc_seg_file = Image(disc_seg_file) + disc_seg_file = change_orientation(disc_seg_file, sc_seg.orientation) + + #we get the data from the disc segmentation file + disc_seg_data = disc_seg_file.data + + #if level 0 and level 7 don't exist we move on to the next patient + if 1 not in disc_seg_data or 8 not in disc_seg_data: + patient_data["sc_volume"] = None + return patient_data + + #get voxel size + _,_,_,_,disc_voxel_size_x,disc_voxel_size_y,disc_voxel_size_z,_ = get_dimension(disc_seg_file) + + #else we get their coordinates + level_0 = np.where(disc_seg_data == 1) + level_0_bottom = int(level_0[1]) + level_7 = np.where(disc_seg_data == 8) + level_7_top = int(level_7[1]) + + #now we get the spinal cord segmentation data + sc_seg_data = sc_seg.data + + #we crop the spinal cord above disc level 0 (in the data its the bottom) and bellow disc level 7 (in the data its the top) + sc_seg_data = sc_seg_data[:, level_7_top:level_0_bottom, :] + + #we get the voxel size + _,_,_,_,voxel_size_x,voxel_size_y,voxel_size_z,_ = get_dimension(sc_seg) + + #we compute the spinal cord volume + sc_volume = np.sum(sc_seg_data)*voxel_size_x*voxel_size_y*voxel_size_z #we add this information to the patient_data dictionary patient_data["sc_volume"] = sc_volume @@ -447,11 +479,13 @@ def main(): patient_data = analyse_lesion_per_levels(patient_data, discs_path, timepoint, output_folder) #analyze the patient spinal cord volume - patient_data = get_spinal_cord_info(patient_data, spinal_cord_path, timepoint) + patient_data = get_spinal_cord_info(patient_data, spinal_cord_path, discs_path, timepoint) #add the patient to the dataset dataframe = pd.concat([dataframe, pd.DataFrame([patient_data])], ignore_index=True) + print(dataframe['sc_volume']) + #save the dataset in the output folder dataframe.to_csv(os.path.join(output_folder, 'dataframe.csv'), index=False) print("Dataframe saved in " + os.path.join(output_folder, 'dataframe.csv'))