diff --git a/Bench Mark Scripts/script_EVNT.sh b/Bench Mark Scripts/script_EVNT.sh deleted file mode 100755 index 0b288df..0000000 --- a/Bench Mark Scripts/script_EVNT.sh +++ /dev/null @@ -1,3 +0,0 @@ -#!/bin/bash - -condor_submit benchmark_EVNT.sub diff --git a/Bench Mark Scripts/script_TRUTH.sh b/Bench Mark Scripts/script_TRUTH.sh deleted file mode 100755 index 663e52f..0000000 --- a/Bench Mark Scripts/script_TRUTH.sh +++ /dev/null @@ -1,3 +0,0 @@ -#!/bin/bash - -condor_submit benchmark_TRUTH.sub diff --git a/Bench Mark Scripts/script_rucio.sh b/Bench Mark Scripts/script_rucio.sh deleted file mode 100755 index f7af047..0000000 --- a/Bench Mark Scripts/script_rucio.sh +++ /dev/null @@ -1,16 +0,0 @@ -#! /bin/bash - - -export ATLAS_LOCAL_ROOT_BASE=/cvmfs/atlas.cern.ch/repo/ATLASLocalRootBase -export ALRB_localConfigDir=$HOME/localConfig -source ${ATLAS_LOCAL_ROOT_BASE}/user/atlasLocalSetup.sh -lsetup emi -echo "Wookiee13" | voms-proxy-init -voms atlas - -lsetup "rucio -w" - -rm -r mc23_13p6TeV:mc23_13p6TeV.700866.Sh_2214_WWW_3l3v_EW6.deriv.DAOD_PHYSLITE.e8532_e8528_s4162_s4114_r14622_r14663_p6026_tid37222410_00 - -curr_time=$(date +"%Y.%m.%dT%H.%M.%S") - -rucio download --rses AGLT2_LOCALGROUPDISK mc23_13p6TeV:mc23_13p6TeV.700866.Sh_2214_WWW_3l3v_EW6.deriv.DAOD_PHYSLITE.e8532_e8528_s4162_s4114_r14622_r14663_p6026_tid37222410_00 2>&1 | tee /data/selbor/LogFiles/Rucio/$curr_time.log diff --git a/Benchmark Scripts/EVNT/EVNT.root b/Benchmark Scripts/EVNT/EVNT.root new file mode 100644 index 0000000..3cda6b3 Binary files /dev/null and b/Benchmark Scripts/EVNT/EVNT.root differ diff --git a/Benchmark Scripts/EVNT/SUSY_Radiative_Decays_JO.py b/Benchmark Scripts/EVNT/SUSY_Radiative_Decays_JO.py new file mode 100644 index 0000000..99760ec --- /dev/null +++ b/Benchmark Scripts/EVNT/SUSY_Radiative_Decays_JO.py @@ -0,0 +1,218 @@ +include ( 'MadGraphControl/SUSY_SimplifiedModel_PreInclude.py' ) +from GeneratorFilters.GeneratorFiltersConf import xAODMETFilter +#from GeneratorFilters.GeneratorFiltersConf import xAODPhotonFilter +#from GeneratorFilters.GeneratorFiltersConf import xAODMultiElecMuTauFilter +from MadGraphControl.MadGraphUtilsHelpers import * + + + +include("GeneratorFilters//xAODPhotonFilter_Common.py") +include("GeneratorFilters//xAODMultiElecMuTauFilter_Common.py") +include("GeneratorFilters//xAODMETFilter_Common.py") + +JOName = get_physics_short() + +#get the file name and split it on _ to extract relavent information +jobConfigParts = JOName.split("_") +print("jobConfigParts: ", jobConfigParts) + +METCut = jobConfigParts[3] + +mN2 = float(jobConfigParts[5]) +mN1 = float(jobConfigParts[7]) + + +jobOptProcess = jobConfigParts[8] + + +print("mN2: ",mN2, "\nmN1: ", mN1, "\nProcess: ", jobOptProcess, "\nMETCut: ", METCut) + + + +higgsino = False +winobino = False +if(jobOptProcess == "HH"): + higgsino = True + jobOptProcess_evt_desc = "Higgsino" + + process = ''' + generate p p > n2 n1 @1 + add process p p > n2 n1 j @2 + add process p p > n2 n1 j j @3 + add process p p > n2 x1+ @4 + add process p p > n2 x1+ j @5 + add process p p > n2 x1+ j j @6 + add process p p > n2 x1- @7 + add process p p > n2 x1- j @8 + add process p p > n2 x1- j j @9 + ''' + +elif(jobOptProcess == "WB"): + winobino = True + jobOptProcess_evt_desc = "Wino-Bino" + process = ''' + generate p p > n2 x1+ @1 + ''' + +else: + raise RuntimeError("Only Higgsino or WinoBino supported.") + + +decays['1000023'] = """DECAY 1000023 9.37327589E-04 # neutralino2 decays + 1.00000000E+00 2 1000022 22 # BR(~chi_20 -> ~chi_10 gamma )""" + +decays['1000024'] = """DECAY 1000024 7.00367294E-03 # chargino1+ decays + +# BR NDA ID1 ID2 ID3 + 0.33333333E+00 3 1000022 -1 2 # BR(chi^+_1 -> chi^0_1 d_bar u) + 0.33333333E+00 3 1000022 -3 4 # BR(chi^+_1 -> chi^0_1 s_bar c) + 0.11111111E+00 3 1000022 -11 12 # BR(chi^+_1 -> chi^0_1 e^+ nu_e) + 0.11111111E+00 3 1000022 -13 14 # BR(chi^+_1 -> chi^0_1 mu^+ nu_mu) + 0.11111111E+00 3 1000022 -15 16 # BR(chi^+_1 -> chi^0_1 tau^+ nu_tau)""" + + + +#Photon Filter +#filtSeq += xAODPhotonFilter("PhotonFilter") +filtSeq.xAODPhotonFilter.PtMin = 5000. +filtSeq.xAODPhotonFilter.NPhotons = 1 + +#MET Filter +#filtSeq += xAODMETFilter("METFilter") +filtSeq.xAODMissingEtFilter.METCut = float(METCut)*GeV +evt_multiplier = 10 + + +#Lepton Filter +#filtSeq += xAODMultiElecMuTauFilter("MultiElecMuTauFilter") +#ElecMuTauFilter = filtSeq.xAODMultiElecMuTauFilter +filtSeq.xAODMultiElecMuTauFilter.MinPt = 20.0 * GeV +#ElecMuTauFilter.MaxEta = 2.8 +filtSeq.xAODMultiElecMuTauFilter.NLeptons = 1 +filtSeq.xAODMultiElecMuTauFilter.IncludeHadTaus = 0 # don't include hadronic taus + + + + +filtSeq.Expression = "xAODPhotonFilter and (xAODMissingEtFilter or xAODMultiElecMuTauFilter)" + + + +evgenLog.info("evt_multiplier == " + str(evt_multiplier)) + + +# exact mass spectrum and mixing matrices depend on scenario +if higgsino: + print("Choosing Higgsino...") + # see also: https://twiki.cern.ch/twiki/bin/view/LHCPhysics/SUSYCrossSections13TeVhinosplit + #masses['1000023'] = -1.0 * MassToFloat(splitConfig[3]) # N2, make LSP higgsino like (positive for wino) + #masses['1000024'] = 0.5 * (MassToFloat(splitConfig[3])+MassToFloat(splitConfig[4])) # Chargino is between N1 and N2 + masses['1000022'] = mN1 + masses['1000023'] = -1.0 * mN2 + masses['1000024'] = str((float(mN2) + float(mN1))/2.) + + # Off-diagonal chargino mixing matrix V + param_blocks['VMIX']={} + param_blocks['VMIX']['1 1']='0.00E+00' + param_blocks['VMIX']['1 2']='1.00E+00' + param_blocks['VMIX']['2 1']='1.00E+00' + param_blocks['VMIX']['2 2']='0.00E+00' + # Off-diagonal chargino mixing matrix U + param_blocks['UMIX']={} + param_blocks['UMIX']['1 1']='0.00E+00' + param_blocks['UMIX']['1 2']='1.00E+00' + param_blocks['UMIX']['2 1']='1.00E+00' + param_blocks['UMIX']['2 2']='0.00E+00' + # Neutralino mixing matrix chi_i0 = N_ij (B,W,H_d,H_u)_j + param_blocks['NMIX']={} + param_blocks['NMIX']['1 1']=' 0.00E+00' # N_11 bino + param_blocks['NMIX']['1 2']=' 0.00E+00' # N_12 + param_blocks['NMIX']['1 3']=' 7.07E-01' # N_13 + param_blocks['NMIX']['1 4']='-7.07E-01' # N_14 + param_blocks['NMIX']['2 1']=' 0.00E+00' # N_21 + param_blocks['NMIX']['2 2']=' 0.00E+00' # N_22 + param_blocks['NMIX']['2 3']='-7.07E-01' # N_23 higgsino + param_blocks['NMIX']['2 4']='-7.07E-01' # N_24 higgsino + param_blocks['NMIX']['3 1']=' 1.00E+00' # N_31 + param_blocks['NMIX']['3 2']=' 0.00E+00' # N_32 + param_blocks['NMIX']['3 3']=' 0.00E+00' # N_33 higgsino + param_blocks['NMIX']['3 4']=' 0.00E+00' # N_34 higgsino + param_blocks['NMIX']['4 1']=' 0.00E+00' # N_41 + param_blocks['NMIX']['4 2']='-1.00E+00' # N_42 wino + param_blocks['NMIX']['4 3']=' 0.00E+00' # N_43 + param_blocks['NMIX']['4 4']=' 0.00E+00' # N_44 +elif winobino: + print("Choosing Wino-Bino...") + #masses['1000023'] = 1.0 * MassToFloat(splitConfig[3]) # N2, make LSP wino like (negative for higgsino) + masses['1000022'] = mN1 + masses['1000023'] = mN2 + masses['1000024'] = masses['1000023'] # C1 = N2 + + # mixing used in R19 samples: https://gitlab.cern.ch/atlas-physics/pmg/infrastructure/mc15joboptions/-/blob/master/common/MadGraph/param_card.SM.C1N2.WZ.dat + # the off-diagonal entries lead to small but non-zero cross sections for e.g. N2N1 and N1C1 (these vanish for pure Winos/Binos) + # Chargino mixing matrix V + param_blocks['VMIX']={} + param_blocks['VMIX']['1 1']='9.72557835E-01' # V_11 + param_blocks['VMIX']['1 2']='-2.32661249E-01' # V_12 + param_blocks['VMIX']['2 1']='2.32661249E-01' # V_21 + param_blocks['VMIX']['2 2']='9.72557835E-01' # V_22 + # Chargino mixing matrix U + param_blocks['UMIX']={} + param_blocks['UMIX']['1 1']='9.16834859E-01' # U_11 + param_blocks['UMIX']['1 2']='-3.99266629E-01' # U_12 + param_blocks['UMIX']['2 1']='3.99266629E-01' # U_21 + param_blocks['UMIX']['2 2']='9.16834859E-01' # U_22 + # Neutralino mixing matrix + param_blocks['NMIX']={} + param_blocks['NMIX']['1 1']='9.86364430E-01' # N_11 + param_blocks['NMIX']['1 2']='-5.31103553E-02' # N_12 + param_blocks['NMIX']['1 3']='1.46433995E-01' # N_13 + param_blocks['NMIX']['1 4']='-5.31186117E-02' # N_14 + param_blocks['NMIX']['2 1']='9.93505358E-02' # N_21 + param_blocks['NMIX']['2 2']='9.44949299E-01' # N_22 + param_blocks['NMIX']['2 3']='-2.69846720E-01' # N_23 + param_blocks['NMIX']['2 4']='1.56150698E-01' # N_24 + param_blocks['NMIX']['3 1']='-6.03388002E-02' # N_31 + param_blocks['NMIX']['3 2']='8.77004854E-02' # N_32 + param_blocks['NMIX']['3 3']='6.95877493E-01' # N_33 + param_blocks['NMIX']['3 4']='7.10226984E-01' # N_34 + param_blocks['NMIX']['4 1']='-1.16507132E-01' # N_41 + param_blocks['NMIX']['4 2']='3.10739017E-01' # N_42 + param_blocks['NMIX']['4 3']='6.49225960E-01' # N_43 + param_blocks['NMIX']['4 4']='-6.84377823E-01' # N_44 + + + + + + + + +njets = 2 + +#if 'MET' in JOName.split('_')[-1]: +# include ( 'GeneratorFilters/MissingEtFilter.py' ) +# +# metFilter = JOName.split('_')[-1] +# metFilter = int(metFilter.split("MET")[1].split(".")[0]) + +# print "Using MET Filter: " + str(metFilter) +# filtSeq.MissingEtFilter.METCut = metFilter*GeV +# evt_multiplier = metFilter / 10 + +#else: +# print "No MET Filter applied" + + +#evgenLog.info('Registered generation of stop pair production, stop to c+LSP and t+LSP; grid point '+str(runArgs.jobConfig[0])+' decoded into mass point mstop=' + str(masses['1000006']) + ', mlsp='+str(masses['1000022'])) + +#evgenConfig.contact = [ "alvaro.lopez.solis@cern.ch","armin.fehr@lhep.unibe.ch","john.kenneth.anders@cern.ch" ] +#evgenConfig.keywords += ['simplifiedModel','charm'] +evgenConfig.description = jobOptProcess_evt_desc + ' N2->N1 + gam' + +if njets>0: + #genSeq.Pythia8.Commands += ["Merging:Process = pp>{t1,1000006}{t1~,-1000006}"] + genSeq.Pythia8.Commands += ["Merging:Process = guess"] + genSeq.Pythia8.UserHooks += ["JetMergingaMCatNLO"] + +include ( 'MadGraphControl/SUSY_SimplifiedModel_PostInclude.py' ) diff --git a/Benchmark Scripts/EVNT/benchmark_EVNT.sub b/Benchmark Scripts/EVNT/benchmark_EVNT.sub new file mode 100755 index 0000000..27ed8ec --- /dev/null +++ b/Benchmark Scripts/EVNT/benchmark_EVNT.sub @@ -0,0 +1,13 @@ +Universe = vanilla + +Output = /data/selbor/Out_Files/EVNT/$(Cluster).$(Process).out +Error = /data/selbor/Err_Files/EVNT/$(Cluster).$(Process).err +Log = /data/selbor/LogFiles/EVNT/$(Cluster).$(Process).log + +Executable = /home/selbor/benchmarks/EVNT/run_EVNT.sh + + +request_memory = 3GB +request_cpus = 1 + +Queue 1 diff --git a/Benchmark Scripts/EVNT/mc.MGPy8EG_A14N23LO_MET_25_N2_100_N1_97_WB.py b/Benchmark Scripts/EVNT/mc.MGPy8EG_A14N23LO_MET_25_N2_100_N1_97_WB.py new file mode 100644 index 0000000..93ef720 --- /dev/null +++ b/Benchmark Scripts/EVNT/mc.MGPy8EG_A14N23LO_MET_25_N2_100_N1_97_WB.py @@ -0,0 +1 @@ +include("SUSY_Radiative_Decays_JO.py") diff --git a/Benchmark Scripts/EVNT/run_EVNT.sh b/Benchmark Scripts/EVNT/run_EVNT.sh new file mode 100755 index 0000000..efd760c --- /dev/null +++ b/Benchmark Scripts/EVNT/run_EVNT.sh @@ -0,0 +1,34 @@ +#/bin/bash + + +# Copies the necessary files into the directory: +# /data/selbor/ReqFiles/ +cp ~data/selbor/ReqFiles/mc* . +cp ~data/selbor/ReqFiles/SUSY_*.py . + +# Since we aren't working in lxplus we need the following two lines: +export ATLAS_LOCAL_ROOT_BASE=/cvmfs/atlas.cern.ch/repo/ATLASLocalRootBase +source ${ATLAS_LOCAL_ROOT_BASE}/user/atlasLocalSetup.sh + +# Sets up our ATLAS Release and version +asetup AthGeneration,23.6.34,here + +# Defining out output directory +outputdir="/home/selbor/benchmarks/benchmark_EVNT/100xxx/100001/" +# Defining our seed +seed=1001 + +# Removes the output directory in case it's still there +rm -rf ${outputdir} + +# Makes the directory to store files +mkdir -p ${outputdir} + +# Copies the necessary script to the output directory +cp mc* SUSY_*.py ${outputdir} + +# Changes directory into the output directory +cd ${outputdir} + +# Runs the job using all the necessary parameters we defined above +Gen_tf.py --ecmEnergy=13000.0 --jobConfig=${outputdir} --outputEVNTFile=EVNT.root --maxEvents=10000 --randomSeed=${seed} diff --git a/Benchmark Scripts/EVNT/script_EVNT.sh b/Benchmark Scripts/EVNT/script_EVNT.sh new file mode 100755 index 0000000..8674f4b --- /dev/null +++ b/Benchmark Scripts/EVNT/script_EVNT.sh @@ -0,0 +1,4 @@ +#!/bin/bash + +# Condor command, ran in the console, needed to submit our job into the queue +condor_submit benchmark_EVNT.sub diff --git a/Benchmark Scripts/README.md b/Benchmark Scripts/README.md new file mode 100644 index 0000000..7d0f189 --- /dev/null +++ b/Benchmark Scripts/README.md @@ -0,0 +1,72 @@ +# Benchmark Scripts: +Contains information about four example jobs that are being run at the UChicago AF. The jobs run periodically, every six hours, with the aid of crontab. +## Workflow +When a crontab file access one of the scripts in this directory is works in the following way: +1. Reads the script the user specifies in their script: + - Suppose the crontab is set to run a batch job, then it will read /home/selbor/benchmarks/TRUTH3/script_TRUTH.sh + ```bash + #!/bin/bash + + condor_submit /home/selbor/benchmarks/TRUTH3/benchmark_TRUTH.sub + ``` +2. The contents of /home/selbor/benchmarks/TRUTH3/script_TRUTH.sh file will submit the submission file; /home/selbor/benchmarks/TRUTH3/benchmark_TRUTH.sub +3. The contents of the submission file will be read and the executable file will be used for the job; /home/selbor/LogFiles/benchmarks/TRUTH/run_truth3.sh + +If the user wants to run this job interactively then, within the directory the executable file is located, the user should run: +```console +./run_truth3.sh +``` +For interactive jobs, like for the Rucio Downloads, the script that the crontab reads just contains all of the commands one would enter in the console. + +## Type of Jobs +Each of the jobs listed below have their respective directories with everything needed to run them, either interactively or in the batch: +- EVNT: + - Batch +- TRUTH3: + - Batch +- Rucio: + - Interactive +- TRUTH3_centos7: + - Batch + - Interactive + +## Interactive Jobs +The following scripts are used to run interactive jobs: +- script_rucio.sh +- to_run_centos_interactive.sh + +## Batch Jobs +As outlined in the documentation, to run batch jobs we need an executable file and a submission file. For benchmarking purposes a third script was written. Information about these can be found in the following subsections. +### Executable Files +The following scripts are used as the executable files for batch job submissions: +- run_EVNT.sh +- run_truth3.sh +- to_run_centos.sh + +### Submission Files +The submission files all follow the format that was outlined in the documentation. The following is a list of the submission files used: +- benchmark_EVNT.sub +- benchmark_TRUTH.sub +- benchmark_TRUTH_centos7.sub + +### Crontab Scripts: +To run the batch jobs periodically the following scripts are accessed by a crontab file: +- script_TRUTH.sh +- script_EVNT.sh +- script_TRUTH3_centos.sh +- to_run_centos_interactive.sh + +## Cron-Jobs +The scripts are ran every six hours, this is done using a crontab. Below you'll find the crontab file used: + +```bash +0 */6 * * * /home/selbor/benchmarks/Rucio/script_rucio.sh + +0 */6 * * * /home/selbor/benchmarks/TRUTH3/script_TRUTH.sh + +0 */6 * * * /home/selbor/benchmarks/EVNT/script_EVNT.sh + +0 */6 * * * /home/selbor/benchmarks/TRUTH3_centos7/script_TRUTH3_centos.sh + +0 */6 * * * /home/selbor/benchmarks/TRUTH3_centos7/to_run_centos_interactive.sh +``` diff --git a/Benchmark Scripts/Rucio/script_rucio.sh b/Benchmark Scripts/Rucio/script_rucio.sh new file mode 100755 index 0000000..e509855 --- /dev/null +++ b/Benchmark Scripts/Rucio/script_rucio.sh @@ -0,0 +1,24 @@ +#! /bin/bash + +# Removes the existing directory in preparation for another download +rm -r mc23_13p6TeV.700866.Sh_2214_WWW_3l3v_EW6.deriv.DAOD_PHYSLITE.e8532_e8528_s4162_s4114_r14622_r14663_p6026_tid37222410_00/ + +# The following lines are needed since we aren't in xlplus +export ATLAS_LOCAL_ROOT_BASE=/cvmfs/atlas.cern.ch/repo/ATLASLocalRootBase +export ALRB_localConfigDir=$HOME/localConfig + +# Section makes use of our certificate +source ${ATLAS_LOCAL_ROOT_BASE}/user/atlasLocalSetup.sh +lsetup emi +echo "Wookiee13" | voms-proxy-init -voms atlas + +# Sets up our data management system client +lsetup "rucio -w" + +# Makes note of the current date and time; to be used in naming log files +curr_time=$(date +"%Y.%m.%dT%H.%M.%S") + +# Begins the rucio download process +# Its outputs are saved in the /data/selbor/LogFiles/Rucio/ directory. +# The file's name is the date and time the process began +rucio download --rses AGLT2_LOCALGROUPDISK mc23_13p6TeV:mc23_13p6TeV.700866.Sh_2214_WWW_3l3v_EW6.deriv.DAOD_PHYSLITE.e8532_e8528_s4162_s4114_r14622_r14663_p6026_tid37222410_00 2>&1 | tee /data/selbor/LogFiles/Rucio/$curr_time.log diff --git a/Benchmark Scripts/TRUTH3/EVNT.root b/Benchmark Scripts/TRUTH3/EVNT.root new file mode 100644 index 0000000..3cda6b3 Binary files /dev/null and b/Benchmark Scripts/TRUTH3/EVNT.root differ diff --git a/Benchmark Scripts/TRUTH3/benchmark_TRUTH.sub b/Benchmark Scripts/TRUTH3/benchmark_TRUTH.sub new file mode 100755 index 0000000..9d7cb98 --- /dev/null +++ b/Benchmark Scripts/TRUTH3/benchmark_TRUTH.sub @@ -0,0 +1,13 @@ +Universe = vanilla + + +Output = /data/selbor/Out_Files/TRUTH3/$(Cluster).$(Process).out +Error = /data/selbor/Err_Files/TRUTH3/$(Cluster).$(Process).err +Log = /data/selbor/LogFiles/TRUTH3/$(Cluster).$(Process).log + +Executable = /home/selbor/benchmarks/TRUTH3/run_truth3.sh + +request_memory = 3GB +request_cpus = 1 + +Queue 1 diff --git a/Benchmark Scripts/TRUTH3/run_truth3.sh b/Benchmark Scripts/TRUTH3/run_truth3.sh new file mode 100755 index 0000000..01dfcad --- /dev/null +++ b/Benchmark Scripts/TRUTH3/run_truth3.sh @@ -0,0 +1,26 @@ +#!/bin/bash + +# Sets up our environment +export ATLAS_LOCAL_ROOT_BASE=/cvmfs/atlas.cern.ch/repo/ATLASLocalRootBase +source ${ATLAS_LOCAL_ROOT_BASE}/user/atlasLocalSetup.sh + +# Sets up the ATLAS release and version +asetup Athena,24.0.53,here + +# Input files are found in the input directory +inputdir="/data/selbor/EVNT_StaticDir/" + +# Output files will be stored in the output directory +outputdir="/home/selbor/benchmarks/benchmark_TRUTH/100xxx/100001/" +# Defining our seed parameter +seed=1001 + + +# Runs our process with all of the previously defined parameters +Derivation_tf.py --CA True --inputEVNTFile ${inputdir}EVNT.root --outputDAODFile=TRUTH3.root --formats TRUTH3 + + +# Creates a new, clean, output directory +mkdir -p ${outputdir} + + diff --git a/Benchmark Scripts/TRUTH3/script_TRUTH.sh b/Benchmark Scripts/TRUTH3/script_TRUTH.sh new file mode 100755 index 0000000..9115b56 --- /dev/null +++ b/Benchmark Scripts/TRUTH3/script_TRUTH.sh @@ -0,0 +1,4 @@ +#!/bin/bash + +# Condor command used to submit the TRUTH3 batch job +condor_submit /home/selbor/benchmarks/TRUTH3/benchmark_TRUTH.sub diff --git a/Benchmark Scripts/TRUTH3_centos7/EVNT_centos.root b/Benchmark Scripts/TRUTH3_centos7/EVNT_centos.root new file mode 100644 index 0000000..93eff9d Binary files /dev/null and b/Benchmark Scripts/TRUTH3_centos7/EVNT_centos.root differ diff --git a/Benchmark Scripts/TRUTH3_centos7/benchmarks_TRUTH_centos7.sub b/Benchmark Scripts/TRUTH3_centos7/benchmarks_TRUTH_centos7.sub new file mode 100755 index 0000000..6547d48 --- /dev/null +++ b/Benchmark Scripts/TRUTH3_centos7/benchmarks_TRUTH_centos7.sub @@ -0,0 +1,12 @@ +Universe = vanilla + +Output = /data/selbor/Out_Files/TRUTH3_Centos/$(Cluster).$(Process).out +Error = /data/selbor/Err_Files/TRUTH3_Centos/$(Cluster).$(Process).err +Log = /data/selbor/LogFiles/TRUTH3_centos7/$(Cluster).$(Process).log + +Executable = /home/selbor/benchmarks/TRUTH3_centos7/to_run_centos.sh + +request_memory = 3GB +request_cpus = 1 + +Queue 1 diff --git a/Benchmark Scripts/TRUTH3_centos7/script_TRUTH3_centos.sh b/Benchmark Scripts/TRUTH3_centos7/script_TRUTH3_centos.sh new file mode 100755 index 0000000..f617f29 --- /dev/null +++ b/Benchmark Scripts/TRUTH3_centos7/script_TRUTH3_centos.sh @@ -0,0 +1,4 @@ +#!/bin/bash + +# Condor command used to submit the centos7 batch job into the queue +condor_submit /home/selbor/benchmarks/TRUTH3_centos7/benchmarks_TRUTH_centos7.sub diff --git a/Benchmark Scripts/TRUTH3_centos7/to_run_centos.sh b/Benchmark Scripts/TRUTH3_centos7/to_run_centos.sh new file mode 100755 index 0000000..bfe94c2 --- /dev/null +++ b/Benchmark Scripts/TRUTH3_centos7/to_run_centos.sh @@ -0,0 +1,22 @@ +#!/bin/bash + +# Sets up the environment +export ATLAS_LOCAL_ROOT_BASE=/cvmfs/atlas.cern.ch/repo/ATLASLocalRootBase + +# Defines where the input files are located +inputdir=/data/selbor/EVNT_StaticDir/ + +# Defines where the output files will be going +outputdir=/home/selbor/benchmarks/benchmark_TRUTH_centos7/100xxx/100001/ + +# Defines our seed parameter +seed=1001 + +# Creates the using centos7 +source ${ATLAS_LOCAL_ROOT_BASE}/user/atlasLocalSetup.sh -b -c centos7 -m /data:/data -r "asetup AthDerivation,21.2.178.0,here && \ +Reco_tf.py --inputEVNTFile ${inputdir}EVNT_centos.root --outputDAODFile TRUTH3.root --reductionConf TRUTH3" + +# Creates a new, clean, output directory +mkdir -p ${outputdir} + + diff --git a/Benchmark Scripts/TRUTH3_centos7/to_run_centos_interactive.sh b/Benchmark Scripts/TRUTH3_centos7/to_run_centos_interactive.sh new file mode 100755 index 0000000..1353edb --- /dev/null +++ b/Benchmark Scripts/TRUTH3_centos7/to_run_centos_interactive.sh @@ -0,0 +1,26 @@ +#!/bin/bash + +# Needed lines since we aren't in lsplus +export ATLAS_LOCAL_ROOT_BASE=/cvmfs/atlas.cern.ch/repo/ATLASLocalRootBase + +# Defines the input directory +inputdir=/data/selbor/EVNT_StaticDir/ + +# Defining the output directory +outputdir=/home/selbor/benchmarks/benchmark_TRUTH_centos7/100xxx/100001/ + +# Defining the seed +seed=1001 + + +# Defining the current time; used when naming files +curr_time=$(date +"%Y.%m.%dT%H.%M.%S") + +# Creates the container using centos7 +# Output is saved in the log file with the name set up curr_time +source ${ATLAS_LOCAL_ROOT_BASE}/user/atlasLocalSetup.sh -b -c centos7 -m /data:/data -r "asetup AthDerivation,21.2.178.0,here && \ +Reco_tf.py --inputEVNTFile ${inputdir}EVNT_centos.root --outputDAODFile TRUTH3.root --reductionConf TRUTH3" 2>&1 | tee /data/selbor/LogFiles/TRUTH3_centos7_interactive/$curr_time.log + +# Creates a new, clean, output directory +mkdir -p ${outputdir} + diff --git a/Benchmark Scripts/parse_script.py b/Benchmark Scripts/parse_script.py new file mode 100755 index 0000000..f41f3b2 --- /dev/null +++ b/Benchmark Scripts/parse_script.py @@ -0,0 +1,92 @@ +import time +import pandas as pd +import numpy as np +import matplotlib.pyplot as plt +import matplotlib.dates as mdates +import datetime +import os + +class Parsing: + def __init__(self, directory_name): + initial_directory = "/data/selbor/LogFiles/" + self.directory_name = directory_name + self.full_directory_name = initial_directory + directory_name + def cycle_through_files(self): + sorted_dir = sorted(os.listdir(self.full_directory_name)) + n_files = len(sorted_dir) + count = 0 + my_list = [] + while count < len(sorted_dir): + file = sorted_dir[count] + with open(os.path.join(self.full_directory_name, file), 'r') as f: + contents = f.readlines() + first_line = contents[0] + if self.directory_name == "Rucio": + try: + last_line = contents[len(contents)-1] + Start_Time = first_line[7:26] + End_Time = last_line[7:26] + start_time_dt = datetime.datetime(int(Start_Time[0:4]), int(Start_Time[5:7]), int(Start_Time[8:10]), int(Start_Time[11:13]), int(Start_Time[14:16]), int(Start_Time[17:19])) + end_time_dt = datetime.datetime(int(End_Time[0:4]), int(End_Time[5:7]), int(End_Time[8:10]), int(End_Time[11:13]), int(End_Time[14:16]), int(End_Time[17:19])) + my_list.append((end_time_dt - start_time_dt).total_seconds()) + except ValueError: + last_line = contents[len(contents)-10] + Start_Time = first_line[7:26] + End_Time = last_line[7:26] + start_time_dt = datetime.datetime(int(Start_Time[0:4]), int(Start_Time[5:7]), int(Start_Time[8:10]), int(Start_Time[11:13]), int(Start_Time[14:16]), int(Start_Time[17:19])) + end_time_dt = datetime.datetime(int(End_Time[0:4]), int(End_Time[5:7]), int(End_Time[8:10]), int(End_Time[11:13]), int(End_Time[14:16]), int(End_Time[17:19])) + my_list.append((end_time_dt - start_time_dt).total_seconds()) + except: + print("File {} is giving an error.".format(file)) + elif self.directory_name == "EVNT" or self.directory_name == "TRUTH3" or self.directory_name == "TRUTH3_centos7": + last_line = contents[len(contents)-2] + Start_Time = first_line[22:41] + End_Time = last_line[37:56] + start_time_dt = datetime.datetime(int(Start_Time[0:4]), int(Start_Time[5:7]), int(Start_Time[8:10]), int(Start_Time[11:13]), int(Start_Time[14:16]), int(Start_Time[17:19])) + end_time_dt = datetime.datetime(int(End_Time[0:4]), int(End_Time[5:7]), int(End_Time[8:10]), int(End_Time[11:13]), int(End_Time[14:16]), int(End_Time[17:19])) + new_name = "{}.{}.{}.T{}.{}.{}.log".format(Start_Time[0:4], Start_Time[5:7], Start_Time[8:10], Start_Time[11:13], Start_Time[14:16], Start_Time[17:19]) + os.rename(os.path.join(self.full_directory_name, file), os.path.join(self.full_directory_name, new_name)) + my_list.append((end_time_dt - start_time_dt).total_seconds()) + elif self.directory_name == "TRUTH3_centos7_interactive": + last_line = contents[len(contents)-1] + Start_Time = file + End_Time = last_line[21:40] + start_time_dt = datetime.datetime(int(Start_Time[0:4]), int(Start_Time[5:7]), int(Start_Time[8:10]), int(Start_Time[11:13]), int(Start_Time[14:16]), int(Start_Time[17:19])) + end_time_dt = datetime.datetime(int(End_Time[0:4]), int(End_Time[5:7]), int(End_Time[8:10]), int(End_Time[11:13]), int(End_Time[14:16]), int(End_Time[17:19])) + my_list.append((end_time_dt - start_time_dt).total_seconds()) + count += 1 + file_1 = sorted(os.listdir(self.full_directory_name))[0] + file_n = sorted(os.listdir(self.full_directory_name))[n_files-1] + first_measurement = datetime.datetime(int(file_1[0:4]), int(file_1[5:7]), int(file_1[8:10]), int(file_1[12:13]), int(file_1[15:16]), int(file_1[18:19])) + final_measurement = datetime.datetime(int(file_n[0:4]), int(file_n[5:7]), int(file_n[8:10]), int(file_n[12:13]), int(file_n[15:16]), int(file_n[18:19])) + return my_list, first_measurement, final_measurement +class plotting(Parsing): + def __init__(self, directory_name, my_list, first_measurement, final_measurement): + super().__init__(directory_name) + self.my_list = my_list + self.first_measurement = first_measurement + self.final_measurement = final_measurement + def make_the_plot(self): + horizontal_axis = pd.date_range(start = self.first_measurement, end = self.final_measurement, periods = len(self.my_list)) + fig, ax = plt.subplots() + date_fomatting = mdates.DateFormatter(fmt='%Y-%m-%d %H:%M') + ax.plot(horizontal_axis, self.my_list) + ax.scatter(horizontal_axis, self.my_list) + ax.grid() + fig.set_size_inches(20,9) + ax.xaxis.set_major_formatter(date_fomatting) + fig.autofmt_xdate() + if self.directory_name == "TRUTH3_centos7_interactive": + name_on_plot = "Interactive TRUTH3 using CentOS 7" + elif self.directory_name == "TRUTH3_centos7": + name_on_plot = "TRUTH3 Using CentOS7 in Batch" + elif self.directory_name == "Rucio": + name_on_plot = "Rucio Downloads" + elif self.directory_name == "EVNT": + name_on_plot = "EVNT Production" + elif self.directory_name == "TRUTH3": + name_on_plot = "TRUTH3" + plt.title("{}".format(name_on_plot), size = 15) + plt.xlabel("Start Time", size = 15) + plt.ylabel("Time Taken \n Measured in Seconds", size = 15) + plt.show() \ No newline at end of file diff --git a/Benchmark Scripts/parsing_plotting_jobs.ipynb b/Benchmark Scripts/parsing_plotting_jobs.ipynb new file mode 100644 index 0000000..a283381 --- /dev/null +++ b/Benchmark Scripts/parsing_plotting_jobs.ipynb @@ -0,0 +1,101 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "49ee2328-3a06-4251-b89c-18d9155fd518", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABogAAAL9CAYAAAAYf+RKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeZxT9dn//3eSmUxmkplBRAFldRcXUBSlKuLC4r5vrYpg7Vd/0Bbp3VZapWKtWu663dVqrQt6o9a93hZUEBxEpaIgblRvRRDvstZlZjJMlkny+2Pmc2ZGZkkySc5J8no+Hn2USc7kfM6ciTmZd67rciUSiYQAAAAAAAAAAABQNNx2LwAAAAAAAAAAAAC5RUAEAAAAAAAAAABQZAiIAAAAAAAAAAAAigwBEQAAAAAAAAAAQJEhIAIAAAAAAAAAACgyBEQAAAAAAAAAAABFhoAIAAAAAAAAAACgyBAQAQAAAAAAAAAAFBkCIgAAAAAAAAAAgCJDQAQAAAAAXXC5XCn9b8iQIZKk9evX73Cfx+NR7969deyxx2ru3LlKJBId7nPIkCFyuVyqqanpdF1z586Vy+XS2LFj232dyv+uv/56SdL111/f7uvOmHWtX79+h7VceOGF2n///dW7d295vV7ttttuOvfcc/XGG28k8VMGAAAAkGsldi8AAAAAAJxs0qRJO9z2+uuva+3atRo+fLhGjBjR7r4+ffq0+9rv9+vcc8+VJEWjUX366ad67bXX9Nprr6mmpkZz587NyDr32muvDtf68MMPS5LOOeccBQKBdvd9d+3puuuuu/Tee+/poIMO0tFHHy2fz6dPPvlEzzzzjJ599ln96U9/0pVXXpmRfQEAAADIDAIiAAAAAOhCRwHOZZddprVr1+rMM8/stuqmT58+OzzG3/72N5111ll6+OGH9cMf/lBHH310j9d59NFHd/g4JiD6wx/+YFU3Zdrdd9+tYcOGqbKyst3t//M//6Ozzz5bV199tc4999wdwjMAAAAA9qHFHAAAAADk2JlnnqmJEydKkl5++WWbV9NzRxxxxA7hkCSdfvrpGjt2rEKhkN58800bVgYAAACgMwREAAAAAGCDAw44QJK0detWm1eSXaWlpZIkr9dr80oAAAAAtEVABAAAAAA2qK+vlyTtuuuuNq8kexYvXqwlS5Zop5120pFHHmn3cgAAAAC0wQwiAAAAAMixaDSqxYsXS5LVaq4QPPTQQ1q6dKlCoZDWrl2rd955R9XV1Xr88cfVq1cvu5cHAAAAoA0CIgAAAADIkWg0qk8//VTXXXed1q5dq6lTp+qoo46ye1mW2bNna/bs2Wl//xtvvKGHH37Y+rp37976y1/+ogkTJmRieQAAAAAyiIAIAAAAALLoiy++kMvl2uH2G2+8Ub/+9a9tWFHnhg8frhEjRnR6/9NPP62GhoZO77///vt1//33KxgM6pNPPtGcOXN0zjnn6IorrtB9992XhRUDAAAASBcBEQAAAABkkd/v17nnnitJamho0Ntvv60vvvhCs2fP1qhRozRu3LgdvqejQOm7EolE0tsm68wzz9T111/f6f01NTVdBkRGIBDQyJEj9cQTTygUCllVROecc07G1goAAACgZ9x2LwAAAAAAClmfPn00d+5czZ07V0899ZTWrl2rH//4x4pGo7r00ktVX1+/w/dUVFRIkrZv397p45r7/H5/dhaeIRdffLEk6fnnn7d5JQAAAADaIiACAAAAgBzyeDy67bbbdMABB2jz5s26/fbbd9hmwIABkqTPP/+808cx95ltnapPnz6SpG3bttm8EgAAAABtERABAAAAQI6VlJToxhtvlCTdeeedCgaD7e4fM2aMJGn+/Pkdfn88HrfuO+aYY7K40p5bunSpJGnPPfe0eSUAAAAA2iIgAgAAAAAbnHHGGTrkkEP09ddf65577ml335QpUxQIBPTSSy/pz3/+c7v7YrGYfv3rX+uTTz7RgAEDbJ/r889//lNPPvmkIpFIu9sTiYT++te/as6cOXK5XJo0aZJNKwQAAADQkRK7FwAAAAAAxcjlcun666/XGWecodtuu00//vGP5fP5JEn9+/fXI488oosuukhXXnmlbr/9do0YMUKxWEwrVqzQhg0b1KtXLz355JPW99hly5YtuuCCC1RdXa2RI0eqX79++vbbb7VmzRqtX79ebrdbt912mw4//HBb1wkAAACgPSqIAAAAAMAmp59+ukaOHKnNmzfrwQcfbHffWWedpVWrVunyyy9XNBrV3/72N82fP18VFRX66U9/qvfff1+jR4+2aeWtDjjgAN1www0aOXKk/vd//1fPPPOMXn31VZWWlmrKlCl6++23NX36dLuXCQAAAOA7XIlEImH3IgAAAAAAAAAAAJA7VBABAAAAAAAAAAAUGQIiAAAAAAAAAACAIkNABAAAAAAAAAAAUGQIiAAAAAAAAAAAAIoMAREAAAAAAAAAAECRISACAAAAAAAAAAAoMiV2LwDpi8fj2rhxoyorK+VyuexeDgAAAAAAAAAAsFEikVB9fb122203ud1d1wgREOWxjRs3auDAgXYvAwAAAAAAAAAAOMiXX36pAQMGdLkNAVEeq6yslNR8oquqqmxeDXIpGo1q4cKFGj9+vEpLS+1eDoBO8FwF8gPPVcD5eJ4C+YHnKvIZv79AfuC52r26ujoNHDjQyg+6QkCUx0xbuaqqKgKiIhONRlVRUaGqqir+Qwg4GM9VID/wXAWcj+cpkB94riKf8fsL5Aeeq8lLZixN1w3oAAAAAAAAAAAAUHAIiAAAAAAAAAAAAIoMAREAAAAAAAAAAECRISACAAAAAAAAAAAoMgREAAAAAAAAAAAARYaACAAAAAAAAAAAoMgQEAEAAAAAAAAAABQZAiIAAAAAAAAAAIAiQ0AEAAAAAAAAAABQZAiIAAAAAAAAAAAAigwBEQAAAAAAAAAAQJEp6oDolltukcvl0vTp063bQqGQpk6dqp133lmBQEDnnHOOtmzZ0u77NmzYoFNOOUUVFRXadddd9fOf/1xNTU3ttqmpqdGhhx6qsrIy7bXXXpo7d+4O+7/77rs1ZMgQ+Xw+HXHEEVqxYkU2DhMAAAAAAAAAAKCdog2I3n77bf35z3/WwQcf3O72q6++Wi+88IKeeuopLV26VBs3btTZZ59t3R+LxXTKKacoEonozTff1MMPP6y5c+dq1qxZ1jbr1q3TKaecouOOO06rV6/W9OnT9cMf/lAvv/yytc0TTzyhGTNm6De/+Y1WrVql4cOHa8KECdq6dWv2Dx4AAAAAAAAAABS1ogyIgsGgfvCDH+gvf/mLdtppJ+v22tpaPfDAA7rtttt0/PHHa+TIkXrooYf05ptv6h//+IckaeHChVqzZo3mzZunESNG6KSTTtJvf/tb3X333YpEIpKke++9V0OHDtWtt96q/fffX9OmTdO5556r22+/3drXbbfdpiuuuEKTJ0/WsGHDdO+996qiokIPPvhgbn8YAAAAAAAAAACg6JTYvQA7TJ06VaeccopOPPFE3XjjjdbtK1euVDQa1Yknnmjdtt9++2nQoEFavny5jjzySC1fvlwHHXSQ+vbta20zYcIEXXXVVfroo490yCGHaPny5e0ew2xjWtlFIhGtXLlSM2fOtO53u9068cQTtXz58k7XHQ6HFQ6Hra/r6uokSdFoVNFoNL0fBvKSOd+cd8DZeK4C+YHnKuB8PE+B/MBzFfmM318gP/Bc7V4qP5uiC4j++te/atWqVXr77bd3uG/z5s3yer3q1atXu9v79u2rzZs3W9u0DYfM/ea+rrapq6tTY2OjvvnmG8VisQ63+fjjjztd+80336zZs2fvcPvChQtVUVHR6fehcC1atMjuJQBIAs9VID/wXAWcj+cpkB94riKf8fsL5Aeeq53bvn170tsWVUD05Zdf6qc//akWLVokn89n93JSNnPmTM2YMcP6uq6uTgMHDtT48eNVVVVl48qQa9FoVIsWLdK4ceNUWlpq93IAdILnKpAfeK4CzsfzFMgPPFeRz/j9BfIDz9Xumc5jySiqgGjlypXaunWrDj30UOu2WCym1157TXfddZdefvllRSIRffvtt+2qiLZs2aJ+/fpJkvr166cVK1a0e9wtW7ZY95n/N7e13aaqqkrl5eXyeDzyeDwdbmMeoyNlZWUqKyvb4fbS0lKeDEWKcw/kB56rQH7guQo4H89TID/wXEU+4/cXyA88VzuXys/FncV1OM4JJ5ygDz74QKtXr7b+d9hhh+kHP/iB9e/S0lItXrzY+p5PPvlEGzZs0OjRoyVJo0eP1gcffKCtW7da2yxatEhVVVUaNmyYtU3bxzDbmMfwer0aOXJku23i8bgWL15sbQMAAAAAAAAAAJAtRVVBVFlZqQMPPLDdbX6/XzvvvLN1++WXX64ZM2aod+/eqqqq0o9//GONHj1aRx55pCRp/PjxGjZsmC655BLNmTNHmzdv1rXXXqupU6da1T1XXnml7rrrLv3iF7/QlClTtGTJEj355JOaP3++td8ZM2Zo0qRJOuywwzRq1Cjdcccdamho0OTJk3P00wAAAAAAAJkQiye0Yt3X2lof0q6VPo0a2lset4v95YlCPz4AADpTVAFRMm6//Xa53W6dc845CofDmjBhgv70pz9Z93s8Hv3973/XVVddpdGjR8vv92vSpEm64YYbrG2GDh2q+fPn6+qrr9add96pAQMG6P7779eECROsbS644AJt27ZNs2bN0ubNmzVixAi99NJL6tu3b06PFwAAAAAApO+lDzdp9gtrtKk2ZN3Wv9qn35w2TBMP7M/+HK7Qjw8AgK4UfUBUU1PT7mufz6e7775bd999d6ffM3jwYC1YsKDLxx07dqzefffdLreZNm2apk2blvRaAQAAAACAc7z04SZdNW+VEt+5fXNtSFfNW6V7Lj40oyFDoe8v1wr9+AAA6E5RzSACAAAAAADIhFg8odkvrNkhXJBk3Tb7hTWKxTvagv3ZrdCPDwCAZBR9BREAAAAAAECqVqz7ul1bsu9KSNpUG9KUuW9rl8qydvd9d7qNq4NxN67vbLW1PpTU/q545B31rSrrdLtkbakLJ7W/Feu+1ug9d+7x/nIt2fOXr8cHAEAyCIgAAAAAAABStLW+83ChraX/uy3LK2lvycdbc7q/ZH8OTpPsuvP1+AAASAYBEQAAAAAAQIp2rfQltd1FowZp8M4VkqTEd7qVJb7T4Oy797f1xVfb9eQ7X3a7v/NGDtCg3hVJra0rG77erqdW/l+32yX7c3CaZNedr8cHAEAyCIgAAAAAAABSNGpob/Wv9mlzbajDOTYuSf2qfbrxzAPlcXfQQy5FsXhCyz7d1u3+bjnn4Izt7/XP/t3t/kYN7d3jfdkh2fOXr8cHAEAy3HYvAAAAAAAAIN943C795rRhHd5n4pnfnDYsI2HNd/e3wwyjAthfrhX68QEAkAwCIgAAAAAAgDRMPLC/7rn4UFV4Pe1u71ft0z0XH6qJB/bPyv76Vbdve1Yo+8u1Qj8+AAC6Q4s5AAAAAACANE08sL8WrtmiZ1f9S6cN76/vjxqsUUN7Z63yZOKB/TVuWD+tWPe1ttaHtGulLyf7O+Ou1/XhxjpNO24vXT1un4KprDHHN/LGRfp2e1TDB1Tr2f/vqII5PgAAukJABAAAAAAA0APbwzFJ0qghvTV6z52zvj+P25WT/bTd3269yvXhxjr17+UruPDE43Yp2hSXJJV63AV3fAAAdIYWcwAAAAAAAD3QEGmSJPnLCvdzuIGWYwuGmmxeSebF4wk1RJpDvmC48I4PAIDOEBABAAAAAAD0gAkVCjog8jUfW0MBBigm4JMIiAAAxYWACAAAAAAAoAdMaBIo4IDIhF/BlnZ6haShzTEVYgAGAEBnCIgAAAAAAAB6wAQMBV1BZAVEUZtXknltj6mhAAMwAAA6Q0AEAAAAAADQA0Grgshj80qyxwREhRigtK2KisTiCjcV3jECANARAiIAAAAAAIA0JRIJqy1ZIVcQtbaYK7wWbN9tK1eIIRgAAB0hIAIAAAAAAEhTuCmupnhCUmEHRKY6qhADovrQdwOiwjtGAAA6QkAEAAAAAACQprZhgt9byAFRqaTCDE++e0zfDYwAAChUBEQAAAAAAABpMu3Iyks98rhdNq8me/wFXEHUEGnq8msAAAoVAREAAAAAAECagkUwf0iSAgU8g+i7FUOFeIwAAHSEgAgAAAAAACBNptrEzOgpVAFfc0BUDC3mgrSYAwAUCQIiAAAAAACANBVLBZE5vmgsoXBTzObVZNZ3A6JCDMEAAOgIAREAAAAAAECaGoolIPK2Hl+hVdjUf7eCiIAIAFAkCIgAAAAAAADSZAKiQIEHRB63SxXe5jZ6DeHCrCByu8zXhXV8AAB0hoAIAAAAAAAgTcGWMKHQK4ik1mMstAobEwjtUlkmSQqGo3YuBwCAnCEgAgAAAAAASFNrBZHH5pVkX6BAAyLTYq5flU9Sa+gHAEChIyACAAAAAABIkzWDyFv4FUQmIGoosIDIHM+uLQFRoR0fAACdISACAAAAAABIk6mmKY4Wc81VUoVWQWQCob5VpsVcYR0fAACdISACAAAAAABIU2uLucIPiAq1xVww9N0Wc4V1fAAAdIaACAAAAAAAIE1mXk0xVBAVYou5RCKhhoipIKLFHACguBAQAQAAAAAApMmaQdTSfq2Q+QuwgqgxGlM80fzvvlQQAQCKDAERAAAAAABAmkz1SVG1mAsVToBijsXtknapbJ5BRAURAKBYEBABAAAAAACkKWhVEBVPQGRCsUJgnT9vScHOWAIAoDMERAAAAAAAAGky1SbFUEHU2mIuZvNKMqeh5VgCvtaAKBSNqykWt3NZAADkBAERAAAAAABAmkzAUEwVRMFQ1OaVZE59uPlY/GUl7c5hQwGFYAAAdIaACAAAAAAAIA2JRMJqt+Yv89i8muwL+FpazBVQeNI24POWuOUtaf5TWbCA2ugBANAZAiIAAAAAAIA0bI/ElEg0/7u4WswVTnhiWgRWthybNWepgI4RAIDOEBABAAAAAACkwYQIbpdUXloEFUQtVVKFFBDVh9tXgJn/rw8VzjECANAZAiIAAAAAAIA0mKDE7y2Ry+WyeTXZFygrlVRY1TUNVkBkKogK7xgBAOgMAREAAAAAAEAa2s6vKQb+Aqwg2rHFnKfd7QAAFDICIgAAAAAAgDQEv9OerNCZ+TzhpriisbjNq8kM00rOhHzm/+sJiAAARYCACAAAAAAAIA2myiRQNBVErcdZKBU2O7aYK2l3OwAAhYyACAAAAAAAIA0NkfbhQqEr9bhVVtL8p6RCaTNnzmGlj4AIAFB8CIgAAAAAAADSEAwXV0AktQYohRIQWS3mvLSYAwAUHwIiAAAAAACANBRbizlJCvgKq8KGFnMAgGJGQAQAAAAAAJCGYDgmSfKXeWxeSe6YShtz7PmuoeU4dmwxVxjHBwBAVwiIAAAAAAAA0vDd6pNiYLWYCxVGhc132wT6C6yFHgAAXSEgAgAAAAAASIPVYs5bRAFRgbWYC1ptApurwMzxFUoABgBAVwiIAAAAAAAA0vDd6pNiUEgVNolEos0cqdKW/28Oihoi+X98AAB0h4AIAAAAAAAgDa3hQvEERCZAKYSAKNwUV1M8Ial1jlTrjKX8Pz4AALpDQAQAAAAAAJCGhnBMUnFVEJkwrBBazLUNgUww5C+wGUsAAHSFgAgAAAAAACANrS3mPDavJHcKqcWcCbn8Xo/cbpckqbLAZiwBANAVAiIAAAAAAIA0mDk1xdVirnACovrQjjOkzL8bIjHFW9rPAQBQqAiIAAAAAAAA0mBVoBRhQFQIFTYdzZBq+28TAAIAUKgIiAAAAAAAANIQ7CBgKHQF1WLOVID5Ws9fWYlbJS3t5syMKQAAChUBEQAAAAAAQIqaYnGFonFJxVlBVAgBkdViztt6/lwuV0GFYAAAdIWACAAAAAAAIEUNkdbqEn+Zx8aV5JaptimE6hpzDN8N+AqpjR4AAF0hIAIAAAAAAEiRCQ9KPS6VlRRPQGSqbQqhusacw0pfxwFRIRwjAABdISACAAAAAABIkQkXiqm9nNQmPAnlf3hSb53D9gGf+ZqACABQ6AiIAAAAAAAAUmTCg7bza4qBaTHXGI0pFk/YvJqe6Szk89NiDgBQJAiIAAAAAAAAUmTm1wSKrIKobbVNQyS/AxSrxVwnM4ioIAIAFDoCIgAAAAAAgBQFO2lPVujKSjwq9bgk5X+bufpOKogIiAAAxYKACAAAAAAAIEXFOoNIag1Q8r0FGy3mAADFjoAIAAAAAAAgRaa9WrG1mJNaA5R8r7DptsVcnldIAQDQHQIiAAAAAACAFAWpIMr7gKg+1EmLOZ85vljO1wQAQC4REAEAAAAAAKTIVJ8UYwVRwbSYi9BiDgBQ3AiIAAAAAAAAUtTQUl3iL/PYvJLca20xl98VNuYcVvq+22Ku+Zzme4UUAADdISACAAAAAABIES3mpGAoavNKeibYWYu5stLm+wmIAAAFjoAIAAAAAAAgRbSYkxoi+VtBFGmKKxKLS5IC3u+2mGuuIKLFHACg0BEQAQAAAAAApMiqIPIWX0DU2mIufwOUtuHPd9sEFsqMJQAAukNABAAAAAAAkKKGom4x1zKjJ5S/AYoJt3ylbpV42v95zJzTegIiAECBIyACAAAAAABIUUO4ub1aUbaY8+V/hU2wixaBlW0qiBKJRE7XBQBALhEQAQAAAAAApMhqMfed9mTFoJBazHUUEJnjiyekUDSe03UBAJBLBEQAAAAAAAApaoh0HjAUukABBET1XbQIrPB65HKZ7aK5XBYAADlFQAQAAAAAAJCi4p5BlP8t5ro6fy6XSwGvOcZYTtcFAEAuERABAAAAAACkINwUUzTWPJumGAOiQmoxV9nJ+fMXQAgGAEB3CIgAAAAAAABS0LaqxO8tvhlEBdFiLtR1BZiZLWW2AwCgEBEQAQAAAAAApMBUlfhK3SrxFN+fVlpbzOVv+zWz9s4CooCvtGU7AiIAQOEqvqsYAAAAAACAHjCVM4EibC8ntWm/FmlSPJ6weTXpaYi0tJjzdRIQtVQQme0AAChEBEQAAAAAAAApMFUlxTh/SGoNxhIJaXs0P6uIrBZz3k5azHnzv40eAADdISACAAAAAABIgQkNOgsXCp2v1C2P2yUpf1uwtYZ8Hc+QsuYsMYMIAFDACIgAAAAAAABSYObXFGuLOZfLJb+3OVjJ1wobExB12mLOV9JuOwAAChEBEQAAAAAAQAq6qz4pBvleYVPfTZtAc3swnJ8t9AAASAYBEQAAAAAAQAqCRT6DSMr/Cpvu5khZAVg4mrM1AQCQawREAAAAAAAAKTDhQrG2mJPaVtjkd0BU2U1A1EAFEQCggBEQAQAAAAAApCAYoYIokOcBUXdVYPkegAEAkAwCIgAAAAAAgBR0156sGLRW2ORngBLspgos0DJfioAIAFDICIgAAAAAAABSYNqOmRChGLVW2ORfC7amWFyhaFxSVwFRqaT8DcAAAEgGAREAAAAAAEAKumtPVgxaW8xFbV5J6trOFeq8xRwVRACAwkdABAAAAAAAkIKGbtqTFYPWFnP5V0FkZkh5PW55Szr+01i+z1gCACAZBEQAAAAAAAApsGYQeYs3IPLncYBiBXy+zs+fP89nLAEAkAwCIgAAAAAAgBTQYq51/lIwlH8BSn3InL/OZ0iZ8CgaSyjclH9VUgAAJIOACAAAAAAAIAWmrVpRt5hrCVAaIvkXECVTAdb2vnxsowcAQDIIiAAAAAAAAFJgBQxdVKAUOhOg5HOLucouWsx53C6Vl+ZvlRQAAMkgIAIAAAAAAEhSIpGwqmaKuoLIzCDKw/CkPskWgaZKKh9DMAAAkkFABAAAAAAAkKTGaEzxRPO/i3oGkWkxl4fhSUOyAVFZ/rbRAwAgGQREAAAAAAAASTLVJC6XVOEt4hZzZflbXWO1mOsmIDItBPOxSgoAgGQQEAEAAAAAACSpIRyT1DyDx+Vy2bwa+wTaBESJRMLm1aQm6RZzeRyCAQCQDAIiAAAAAACAJLW2Jyve6iGpNTyJJ6RQNG7zalKTcos5AiIAQIEiIAIAAAAAAEhSMMlwodBVeD0yBVT5VmFjqsC6bzFHBREAoLAREAEAAAAAACTJVJMEijwgcrlc8nvzM0CpD9FiDgAAiYAIAAAAAAAgaVYFkbe4AyIpf1uwJdsmMF+PDwCAZBEQAQAAAAAAJMm0Jyv2FnNSa8CSbxU2DZHm9Vb6km0xF8v6mgAAsAMBEQAAAAAAQJJaW8x1XX1SDKwWbKH8CojMerurAmMGEQCg0BEQAQAAAAAAJMlqMUcFkQItFTimIidfJHsOK2kxBwAocAREAAAAAAAASWqtICIgMhU4+VZhY85h8i3m8uv4AABIFgERAAAAAABAkky1DBVErSFZPlXYxOMJNUSSmyNlzVjKsxZ6AAAki4AIAAAAAAAgScFwcuFCMTAt5vIpQGnbDq+7KrDKPG2hBwBAsgiIgDwTiye0Yt3XkqQV675WLJ6weUUAAAAAUDxaW8x5bF6J/VpbsMVsXknyGlrWWuJ2qayk6z+L+fOwQgoAgFQQEAF55KUPN+no3y/RlIffliRNefhtHf37JXrpw002rwwAAAAAioOZR0MFUX62mAuGo5Kaz5/L5epyWzNjqT6PKqQAAEgFARGQJ176cJOumrdKm2pD7W7fXBvSVfNWERIBAAAAQA40EBBZAlYFUf4EKKbaqbv2clJri7lwU1xNsXhW1wUAgB0IiIA8EIsnNPuFNeqomZy5bfYLa2g3BwAAAABZ1tpijoDIn4cBUSrnr20I2JBHbfQAAEgWARGQB1as+7pd5VAsLi3f0loKn5C0qTZkzSYCAAAAAGSHqUAx7ceKmZnDlE8t5ky7OH8SM6RKPW55W+YU1be0pgMAoJAQEAF5YGt9+7ZyTQnpic/dSiS63g4AAAAAkFlUELXK5wqiZFsEts5ZooIIAFB4CIiAPLBrpe87t7iUkGuHlnM7bgcAAAAAyJRYPKHGaEsFURIVKIUuH2cQNURSC/jy8RgBAEgWARGQB0YN7a3+1T65OrnfJal/tU+jhvbO5bIAAAAAoKiYcEFKvgKlkLVW1+RPeGJazCUbEPnz8BgBAEgWARGQBzxul35z2rAO7zOh0W9OGyaPu7MICQAAAADQUyYkKHG7VFbCn1SKo8Vcc6VYPh0jAADJ4moGyBMTD+yvey4+VL39pdZtiYTUr9qney4+VBMP7G/j6gAAAACg8LUNF1wuPqAX8DWHLNFYQuGm/JjRk+oMKVrMAQAKGfXQQB6ZeGB/xePS//fYKknSJUcO1rWnHUjlEAAAAADkQDDcHIIkGy4UOr+39efQEI6p0uv896b1JiDy0WIOAICiqyC65557dPDBB6uqqkpVVVUaPXq0XnzxRev+sWPHyuVytfvflVde2e4xNmzYoFNOOUUVFRXadddd9fOf/1xNTe0vFGpqanTooYeqrKxMe+21l+bOnbvDWu6++24NGTJEPp9PRxxxhFasWJGVY0Zhafuppd5+L+EQAAAAAORIawWRx+aVOIPH7VJ5aUsLtlB+BCipt5hrqSDKk+MDACAVRRcQDRgwQLfccotWrlypd955R8cff7zOOOMMffTRR9Y2V1xxhTZt2mT9b86cOdZ9sVhMp5xyiiKRiN588009/PDDmjt3rmbNmmVts27dOp1yyik67rjjtHr1ak2fPl0//OEP9fLLL1vbPPHEE5oxY4Z+85vfaNWqVRo+fLgmTJigrVu35uYHgbxVF4q2+TcXqAAAAACQK8EUw4ViYCpx8qUFW4NVBZZcyGcFRJH8OD4AAFJRdFc0p512Wruvf/e73+mee+7RP/7xDx1wwAGSpIqKCvXr16/D71+4cKHWrFmjV155RX379tWIESP029/+Vr/85S91/fXXy+v16t5779XQoUN16623SpL2339/vf7667r99ts1YcIESdJtt92mK664QpMnT5Yk3XvvvZo/f74efPBBXXPNNR3uOxwOKxwOW1/X1dVJkqLRqKLRaIffg8LzTUPr78C32yOce8DBzPOT5yngbDxXAefjeQqnqNve/H6sotTD72MLv9ejbZJqt4cUjbbMJHLwz6YuFJEklXtcSa2zvLS5a0d9I++/Cx2vNUB+4LnavVR+NkUXELUVi8X01FNPqaGhQaNHj7Zuf/TRRzVv3jz169dPp512mq677jpVVFRIkpYvX66DDjpIffv2tbafMGGCrrrqKn300Uc65JBDtHz5cp144ont9jVhwgRNnz5dkhSJRLRy5UrNnDnTut/tduvEE0/U8uXLO13vzTffrNmzZ+9w+8KFC631ofB9sM4tU/z32Rf/pwULNti7IADdWrRokd1LAJAEnquA8/E8hd3e2uyS5FH9N9u0YMECu5fjCE0hjySXXn39H9q6U0KSs5+rW75qXu+Hq1cqvC7R7fYbNjaf808+36AFC9Zne3lwACf//gJoxXO1c9u3b09626IMiD744AONHj1aoVBIgUBAzz33nIYNGyZJ+v73v6/Bgwdrt9120/vvv69f/vKX+uSTT/Tss89KkjZv3twuHJJkfb158+Yut6mrq1NjY6O++eYbxWKxDrf5+OOPO133zJkzNWPGDOvruro6DRw4UOPHj1dVVVWaPw3kmyVPfyBt3iRJKq/eWSeffLjNKwLQmWg0qkWLFmncuHEqLS21ezkAOsFzFXA+nqdwii9fWyet+1R7Dh6gk08+0O7lOMJjm9/W/637RsMOPkTj9tvZ8c/Vmz9aKjWGdfyY7+mg3au73b7u7f/T81+sUa8+fXXyyYfkYIWwC681QH7gudo903ksGUUZEO27775avXq1amtr9fTTT2vSpElaunSphg0bph/96EfWdgcddJD69++vE044QWvXrtWee+5p46qlsrIylZWV7XB7aWkpT4YiEmzpl2z+zbkHnI//TgP5gecq4Hw8T2G3UFNzxUmVj99Fo9LX/HMINSWsn4mTn6tmBlEvvy+pNVb7m/8Osz0Sd+wxIbOc/PsLoBXP1c6l8nNxZ3EdjuX1erXXXntp5MiRuvnmmzV8+HDdeeedHW57xBFHSJI+++wzSVK/fv20ZcuWdtuYr83cos62qaqqUnl5ufr06SOPx9PhNp3NPgKMulC0zb8ZkgkAAAAAuRIMN78H85cV5edtO2R+FuZn42SJREINkeZ1BpI8h4EyjyRZ3wcAQCEpyoDou+LxuMLhcIf3rV69WpLUv39/SdLo0aP1wQcfaOvWrdY2ixYtUlVVldWmbvTo0Vq8eHG7x1m0aJE158jr9WrkyJHttonH41q8eHG7WUhAR+oaWy9K24ZFAAAAAIDsaiAg2kEgjwKixmhM8ZaxQ8meQ7+35fj4gCYAoAAV3RXNzJkzddJJJ2nQoEGqr6/XY489ppqaGr388stau3atHnvsMZ188snaeeed9f777+vqq6/WmDFjdPDBB0uSxo8fr2HDhumSSy7RnDlztHnzZl177bWaOnWq1f7tyiuv1F133aVf/OIXmjJlipYsWaInn3xS8+fPt9YxY8YMTZo0SYcddphGjRqlO+64Qw0NDZo8ebItPxfkj7ahUH2oSYlEQi6Xy8YVAQAAAEBxSLX6pBiYn0VDHgREJuRxuaQKryep7wn48icAAwAgVUV3RbN161Zdeuml2rRpk6qrq3XwwQfr5Zdf1rhx4/Tll1/qlVdescKagQMH6pxzztG1115rfb/H49Hf//53XXXVVRo9erT8fr8mTZqkG264wdpm6NChmj9/vq6++mrdeeedGjBggO6//35NmDDB2uaCCy7Qtm3bNGvWLG3evFkjRozQSy+9pL59++b054H8U9fYGhBFYwmFonGVJ3lhCwAAAABIn5kJSwVRq3xqMWfWGPCWJP1By3wKwAAASFXRXdE88MADnd43cOBALV26tNvHGDx4sBYsWNDlNmPHjtW7777b5TbTpk3TtGnTut0fYERjcTVEYu1uq22MEhABAAAAQA6YkMDMpUHbFnOxbra0X0MaAZ/ZtiESUzyekNtNBw8AQOFgBhGQR+rb9Dwu9zQ3TmYOEQAAAADkBjOIdpRPFTb14eb3z6ZtXDLathM0LQYBACgUBERAHjHt5fxlHvlL2t8GAAAAAMiuIAHRDqwWcyHnhyfpVBCVlbhV0lI11JAHVVIAAKSCgAjII6ZaqMpXqvKS9rcBAAAAALKrtcUcAZFhqnHyYQZROi0CXS5XmzlLvP8GABQWAiIgj9Q1Nl/MVvlKVF6SaHcbAAAAACC70qlAKXQmbMmH9mv1aQZ8+TRnCQCAVHBFA+SR2pZ2cpW+EjW1fHCJCiIAAAAAyL5IU1yRWFySFPDy5xQjv1rMpdciMJ/mLAEAkAoqiIA80lGLudrtBEQAAAAAkG1twwF/Ci3KCl1rdY3zw5N0WwSa812fByEYAACp4CMvQB6pazQBUYnU8n6ECiIAAAAAyD4TgJSVuFXi4fO2hglbwk1xRVsqrJzKBDypB0RUEAEAChMBEZBHrAqi8lJFmUEEAAAAADljZuykGi4Uurbt2hocPqMn3RZzlb6WgCgP5iwBAJAKPvIC5BETBlX5SqwWc1QQAQAAAED2pRsuFLpSj1tlJc1/XnJ6gJJuyOf35k8bPQAAUkFABOSRthVE5bSYAwAAAICcCbZUxxAQ7SiQJy3YetpiLsgMIgBAgSEgAvJIbcsMosq2FUS0mAMAAACArDPhR6DMY/NKnMcKUAq9xZzDAzAAAFJFQATkkbqWgKjKV6KKlhlEJjQCAAAAAGRPkBZzncqXCiIzIyntCiKHB2AAAKSKgAjII3UhM4OIFnMAAAAAkEvMIOpcoCw/ZvSY9QV86QZEvP8GABQWAiIgj1gVROVtW8xFlUgkbFwVAAAAABQ+q8Wcl4Dou/wtbfecXmETTLNNoNm+weHHBwBAqgiIgDxiqoXaVhDFE1JDhItUAAAAAMgmE35QQbSjgK9UktQQcW4FUSKRSLsKLFDWfHxOr5ACACBVBERAngg3xRSKxiU1zyAqdUulHpek1soiAAAAAEB2NKRZfVIM8qHCJtwUV1O8uftG6jOITIUUAREAoLAQEAF5oq6x+ULU5Wq+mHW5miuJJKmWgAgAAAAAsooZRJ3ze50/g6jt2vwptgk0gVKDg48PAIB0EBABecK0lwuUlcjtbq4cqmoZrEkFEQAAAABkV5CAqFMBn/MDFLO2Cq/Hek+dLBMQOTkAAwAgHQREQJ4wIVB1eal1W2V5S0AU4iIVAAAAALLJzNdJtT1ZMWitsHFui7n6UPrnr20FUSKRyOi6AACwEwERkCdMCGTayklSdcu/qSACAAAAgOwKtoQfVBDtyJ8HFTatM6RSP3/m+OIJqTHq3BAMAIBUERABecKEQFXlrRezJiwy7ecAAAAAANnROoPIY/NKnMeqsIk4OCCKpN8isMLrkaulK52TQzAAAFJFQATkiVoTEPk6aDHXyAUqAAAAAGRTTypQCl2ht5hzuVwKeJ1/jAAApIqACMgTpkqoqs0MoqqWQaC1tJgDAAAAgKwKhtOvQCl0+dFirmctAq1jZAYwAKCAEBABecJUCbWtIKLFHAAAAABkXyKRoIKoC60VRM4NT1rPX3otAgM+54dgAACkioAIyBMmBKpuW0FktZgjIAIAAACAbAlF44onmv9NBdGOWmcQObf9Wr0JiHw9qyBycggGAECqCIiAPGFCIBMKSVQQAQAAAEAutK0aqShNrwKlkPlbqnK2R2JWkOY0DT1sEWgqj6ggAgAUEgIiIE/UhTpqMWcqiLhABQAAAIBsscIFr0dut8vm1ThP26qcsEOLiKwWc940K4i8tJgDABQeAiIgT9RaFUStAVGlCYioIAIAAACArAn2sPqk0JWVeFTqaQ7OnBoQ9bTFnPk+WswBAAoJARGQJ+pNQOTbscVcLTOIAAAAACBrrOoTAqJOmfAs5NCAqOct5giIAACFh4AIyBOmSqi6ok2LufLWEve4Uxs9AwAAAECea4hQQdSdQJ4EROmGfObc1xMQAQAKCAERkAcSiYQ1Z6jtDKLKln8nElykAgAAAEC2BFv6pvnLPDavxLlM8BKOOXNGU32oZwERFUQAgEJEQATkgXBTXJFYXFL7GURlJW75SpufxnW0mQMAAACArKDFXPcc32Kuh1VgrQGRQw8QAIA0EBABecDMGHK7JL+3/SfWTEWRaUEHAAAAAMisns6vKQatFUQ2L6QTJtihxRwAAK0IiIA8YKqDqspL5XK1L9c3FUW1VBABAAAAQFYECYi65fQZREHTYs5HizkAAAwCIiAPmOqgtvOHjKqWi1szowgAAAAAkFm0mOuemc/kxIAo0qZte8BLQAQAgEFABOQBE/5Ul3cQEJXTYg4AAAAAsinY0p7Mn2a4UAwCZc3vTcMxVzdb5l7bUMcEWaky31cfIiACABQOAiIgD1gVROU7vhkxoVEdLeYAAAAAICtaZxClFy4Ug0DLz8aJM4hMi0BfqVslnvT+FGZVEEUIiAAAhYOACMgD1gyiDlvMmQoiLlIBAAAAIBtoMdc9v4NnEAUzcP7M7KKGcJMSiURG1gUAgN0IiIA8UNtVQFRuZhBRQQQAAAAA2RC0KogIiDpjAhQnBkQNGTh/5nujsYTCTfGMrAsAALvlVUBUW1urd955R5s3b7Z7KUBOmeqgjlrMWRVEBEQAAAAAkBWmrRgVRJ0zP5uwA7OT+gxUELWdP9V2phEAAPnMcQHRwoULNWXKFL377rvtbv/jH/+ofv366YgjjtCAAQN09dVX27RCIPdM+GPmDbVVZWYQhQiIAAAAACAbGloG61BB1DkToISaXDavZEeZqCDyuF2q8HpaHs+BZVIAAKTBcQHR/fffr6eeekp77723ddsHH3yg6dOnKxaL6cgjj1RVVZX+67/+S88//7yNKwVyx4Q/VR0ERCY0qmvkE0wAAAAAkA2tLeY8Nq/EuUyLOSdWEGVqhpQJmIJUEAEACoTjAqJVq1ZpxIgRCgQC1m1z5861/v+NN97QypUr5fV69ac//cmmVQK5ZcKfDmcQ+aggAgAAAIBsylTAUMjMz8aJM4jqQ5k5fwECIgBAgXFcQLRlyxYNGDCg3W2LFy9Wr169dOGFF0qShg4dqmOPPVb//Oc/7VgikHO1jaaCqIMZRC23MYMIAAAAADIvHk9oe4QWc93xOzggylSLQBMQMYMIAFAoHBcQeTwehUIh6+uvv/5aH374oY455hi53a3L3WWXXbRt2zY7lgjknNVirssKIi5QAQAAACDTGiKt77WoIOqc+dlEYlIikbB5Ne2ZcxjoYYtA02KQCiIAQKFwXEA0ZMgQvfnmm4pGm/8g/uyzzyqRSGjcuHHttvvqq6+0884727FEIOfqGjufQWRuC4ab1BRzYLNnAAAAAMhjpvrE43aprMRxf0ZxDBMQJeSyKq6corXF3I7vqVNBizkAQKFx3JXNBRdcoG3btmnMmDH62c9+pl/84hcqLS3VmWeeaW2TSCS0cuVK7bHHHvYtFMiRRCJhVQdVdxAQVfpaP8FWTxURAAAAAGSUCQP8Xo9cLpfNq3EuX6lb7pYfj9MCFNMSzt/jCiJazAEACovjAqKf/OQnGjVqlN566y3dfvvtqqur080336zdd9/d2mbJkiXatm2bjjvuOBtXCuTG9khMsXhzeX5HLeZKPW75vc0XuaYVHQAAAAAgM0wYQHu5rrlcrjYzepxVQZSpc0gFEQCg0Dju6sbv9+vNN9/Ua6+9pm3btmnEiBHae++9223j8Xh0++2367TTTrNplUDumNCn1OOSr7TjTLeqvFQNkZjqGrlIBQAAAIBMaq0+cdyfUBzHX1aiulBTu7lNTlBvAiJfhgIiuncAAAqEI69u3G63xo4d2+n9Y8eO7fJ+oJDUmvlDvtJO2xlU+Uq1qTZEBREAAAAAZFiQgChppruF0ypsMhXyWS3mHBaAAQCQLse1mAPQnqkKqupg/pBRVd58kWrCJAAAAABAZpgwgBZz3TMVOoXfYs5ZxwcAQLpsv7q54YYb0v5el8ul6667LoOrAZynzqog6vzpamYT1REQAQAAAEBGmTDAX+axeSXO5/eagMhZFTbBDAdETjs+AADSZXtAdP3118vlcimRSLS7vW0rLXPfd28jIEIxMG3juq4gKm23LQAAAAAgM5hBlDwTojmtxVymAiI/M4gAAAXG9qubhx56aIfbli9frvvuu08DBgzQueeeqyFDhkiSvvjiCz3zzDPasGGDfvSjH2n06NE5Xi2Qe1YFURcBUbUJiBq5SAUAAACATMpUe7Ji4MQWbE2xuELRuKSeh3ymhZ7TAjAAANJl+9XNpEmT2n29YsUKXXnllbrmmmt0ww03qKSk/RLnzJmjWbNm6dZbb9XkyZNzuVTAFrVmBpGviwqilotUKogAAAAAILOCVBAlzfyMzNwmJ2g7D6mnbQIDLd/vpOMDAKAn3HYv4LtmzZqlPffcUzfddNMO4ZAkeTwe/e53v9Nee+2lWbNm2bBCILdaW8x1MYOonBlEAAAAAJANVBAlL+A1LeacU0EUbAlzvB63ykp6FhDRYg4AUGgcFxC99dZbGj58eLfbDR8+XCtWrMjBigB7WS3muqwgar6vloAIAAAAADLKVKD4vT0LF4qBVUHkoBZsrTOken7+/F5azAEACovjAqJYLKbPP/+82+0+//xzxWLO+UQKkC2mgqi6ixlEprqojk8xAQAAAEBG0WIueVYLNgcFKPUt75PN/KCeqGx5jHBTXNFYvMePBwCA3RwXEI0aNUorVqzQI4880uk2jzzyiN566y2NGjUqhysD7FFnZhB1GRDRYg4AAAAAsoEWc8mzWrA5qMWcVUHk7fn5axsSOikEAwAgXY67upk9e7Zee+01TZ48WXPnztUFF1ygwYMHS5K++OILPfnkk6qpqVFJSYlmz55t82qB7LNmEHXxaSfTYs5sCwAAAADIDCqIkmdCtIaIc8KTTAZ8pR63vCVuRZriCoab1KvC2+PHBADATo67ujnqqKP07LPPasqUKaqpqdHSpUvb3Z9IJLTzzjvrgQce0FFHHWXTKoHcMXOFuqogqrYqiJxzEQ4AAAAAhcCEHQRE3fM7scVcOHMt5iSpsqxEXzVFrNlUAADkM0de3Zx66qn6/PPP9fTTT2vZsmXauHGjJKl///465phjdN555ykQCNi8SiA3TNs4UyXUEXNfYzSmSFNc3hLHdY8EAAAAgLxkggBazHXPtHFzZIu5DJ0/f1mJvmqIKBimgwcAIP859uomEAjosssu02WXXWb3UgDbxOMJ69NOVeWdP13bfhKqLhRVn0BZ1tcGAAAAAMWgtcWcx+aVOJ/VYs5BFURWi7kMzCCSnDlnCQCAdFFmADhYMNKkRKL5311VEHncLlW2XKSaiiMAAAAAQM9EY3FFmuKSqCBKhtViLhJTwryZtVk2WsxJzgrBAABIl2OvbrZv36533nlHmzZtUjgc7nS7Sy+9NIerAnLLhD1lJW75Srv+tFpVeanqw02qC3GRCgAAAACZ0DYEYAZR98zPKBZPKBSNq9xrf9VV5lvMNR9TkIAIAFAAHHl1M2vWLN1+++3avn17p9skEgm5XC4CIhS0WjN/qLzz6iGjqrxU//q2kQoiAAAAAMgQEwJ4S9wq9dCEpTsVpR65lFBCLgXDTQ4JiMwMqcysxWoxx4czAQAFwHEB0Zw5c3TjjTfK4/HolFNO0T777KPKykq7lwXYoq6xZf5QEqXwZpu6EAERAAAAAGRCa7jguD+fOJLb7ZLXI4VjzZU7u1TaPx+3viXICZR1/8HLZDhxzhIAAOly3BXOX/7yF5WXl2vZsmU69NBD7V4OYCsT9iRbQSS1Vh0BAAAAAHomaLUns78SJl/43M0BkVNasDVk+ByagCgYccbxAQDQE46rj/7yyy917LHHEg4Bap1BVJ1MQOQrbfkeLlIBAAAAIBOscMHruM/XOpZpgOGYgChiKogyNYOIFnMAgMLhuICoX79+8vv9di8DcIS6kGkxl0wFES3mAAAAACCTTEBEi7nklbX8pckpLdiCocyeQ1rMAQAKieMCogsvvFA1NTVqaGiweymA7UwFkQl/umKqjOpoMQcAAAAAGdHaYo6AKFllnoQk51QQZfocBlpKpIIt86kAAMhnjguIrr/+eu2///46/fTT9dlnn9m9HMBWZp5QUhVEpsUcZe4AAAAAkBFUEKXO1zLqxykBUabPodViLsyHMwEA+c9xVzgnn3yy4vG4ampqtP/++2vw4MEaMGCA3O4dsyyXy6XFixfbsEogN0y7uKpkZhBRQQQAAAAAGdUQaa4S8Zd5bF5J/jABkRNasMXjCescmsqfngq0/C40UEEEACgAjguIampqrH/HYjF9/vnn+vzzzzvc1uVy5WhVgD3qGlOYQdRysVtLQAQAAAAAGUGLudSZLC3ogO4WDZHWNWRuBlHz+3MnBGAAAPSU465w1q1bZ/cSAMcwFUTVqVQQhQiIAAAAACATaDGXutYWc/ZX2JgqH4/bpbKSzExZMNVkTmmhBwBATzjuCmfw4MF2LwFwDNMurqq8+6eqNYOokYtUAAAAAMgEKohSV+ZJSHJGhY2ZExQoK8lYF5qANYPI/uMDAKCnMvPxCQBZUR9KvsVcdQUVRAAAAACQSQ0ERClrrSCyP0AxVUyZrAAzj7U9ElM8nsjY4wIAYAfHXuFs2bJFDz74oJYtW6Z//etfkqTdd99dY8aM0eTJk9W3b1+bVwhkX61VQZT8DKJIU1yhaEy+UoaoAgAAAEBPNFgBA++vkuWkgKg14Mvc+WsbFjZEmlSZxAc6AQBwKkcGRM8884ymTJmiYDCoRKL10xgffPCBXn75Zd1yyy164IEHdM4559i4SiC7mmJx64LahD9d8XtL5HZJ8URzFREBEQAAAAD0jNVizuvIP584kslinNBiznTlyGQFUVmJWyVul5riCQXDBEQAgPzmuBZz77zzji666CI1NDTorLPO0nPPPad3331Xq1ev1t/+9jedffbZCgaD+v73v6933nnH7uUCWdP201bJVBC53S7rwtTMLgIAAAAApM+EHJkMGApdmSMriDJ3/lwul/V4TgjBAADoCcdd4dx8882KxWJ6+umnddZZZ7W77+CDD9bpp5+u5557Tuecc45uueUWPf300zatFMiuusbmC80Kr0elnuSy3KryEtU2RlXbyEUqAAAAAPQUM4hS5/M0d4JxREAUyU7AFyhrfu9tZhwBAJCvHFdB9Prrr+t73/veDuFQW2eddZaOOuooLVu2LIcrA3KrLtQyfyiFcvXqlkoj870AAAAAgPQFCYhS5ivwFnNtHy8Ysv8YAQDoCccFRLW1tRo0aFC32w0aNEi1tbU5WBFgj9qWNnFV5clfyFbRYg4AAAAAMiKRSKgh0lwhQou55BV6i7nmx2s+SCccIwAAPeG4gKhfv3569913u91u9erV6tevXw5WBNjDhDypVBBZARGfYgIAAACAHgk3xRWLN7dLM4EAumcqiKKxhMJN9rZgy9YMqUDLe28nVEkBANATjguIJkyYoE8++US/+tWvFIvteCGRSCR07bXX6uOPP9bEiRNtWCGQG1aLufIUAqKWaiMqiAAAAACgZ9pWh/i9VBAlq22W1mDzjJ56ExD5Mt1ijgoiAEBhcNwVznXXXadnn31Wv//97/X444/r/PPP15AhQyRJX3zxhZ566imtX79eO++8s6699lp7FwtkUV1j84VmdSoBES3mAAAAACAjTHVIhdcjt9tl82ryh9sllZe61RiNKxhqUm+/17a1ZK3FXEtgSEAEAMh3jguIBgwYoCVLlugHP/iBPvzwQ/3nf/6nXK7mC7FEorm0+6CDDtKjjz6qAQMG2LlUIKusCqIUPulkqo3M9wIAAAAA0hPMUrhQDAJlJWqMRmwPUEwFUyDDLQJNRRIt5gAA+c6RVzkHHXSQ3n//fdXU1GjZsmXauHGjJGm33XbTMccco7Fjx9q7QCAHrBlEKVQQmWojU30EAAAAAEhPa7jgyD+dOJq/rETbghE1ROx9b2q1mCtL/n11MszvBAERACDfOfoqZ+zYsYRBKFq1JiDypTGDiAoiAAAAAOiR1vZkma0+KQbmZxYM2V1BlJ1zaKrK6gmIAAB5zm33AgB0rK7lQtqEPslgBhEAAAAAZIbVYs7r6M/WOpKpsLG/xZypIMrwDCIqiAAABcJxAdH999+v3r1766WXXup0mxdffFG9e/fW3Llzc7cwIMdMyFOdQos5046uloAIAAAAAHokW+FCMTChmt0BiqlgyvQ5rLQColhGHxcAgFxzXED017/+VWVlZRo/fnyn24wfP15er1ePPfZYDlcG5JZpE5dSizlTQWRzGT8AAAAA5DurgoiAKGVWizkbA6JEImHNQMpWBREt5gAA+c5xAdGaNWt08MEHy+3ufGkej0fDhw/XmjVrcrgyILfqGk2LuTRmEDVGlUgksrIuAAAAACgGpjqEgCh1Tmgx1xiNKd7ytjjT59AEYHZXSAEA0FOOC4i+/vpr9enTp9vt+vTpo3//+985WBFgD9MmLpUKItOOrimeUGOUUncAAAAASFdr9YnH5pXkHyfM6DHt5VwuqcKb2XNYWdb83puACACQ7xwXEPXp00effvppt9t9+umn2mmnnXKwIiD3Ik1xK+AxVUHJKC/1qMTtktRagQQAAAAASB0t5tLn99rfYs7sO+AtkcvlyuhjWy30aO8OAMhzjguIjj76aK1cuVI1NTWdblNTU6N33nlHRx11VO4WBuRQfcv8IUmqTKGCyOVyWS3p6to8BgAAAAAgNaY6JNPza4pBwGdazNnX2SKbLQLN70RDpIn27gCAvOa4gGjGjBlyuVw688wz9Yc//EG1tbXWfXV1dfrDH/6gs846S263W1dffbWNKwWyp67lU0iVZSXyuFP7pFNVy4W4aVEHAAAAAEhdAxVEafN77W8xVx9ufk9swqpMMo8ZT4j27gCAvOa4gGjUqFG69dZbVV9fr1/+8pfq3bu3dtllF+2yyy7aaaed9Mtf/lJ1dXWaM2cOFUQoWHVm/lB58tVDhlVBREAEAAAAAGmjxVz6Ag5owZbNCqLyUo/MZzntbKMHAEBPOS4gkqSf/vSnevXVVzVhwgT5fD599dVX+uqrr+Tz+TRx4kS9+uqrmjFjht3LBLLGtIerTOOTTtW0mAMAAACAHjMBgwk7kDzTgs3O8KS1RWDmz5/L5bKqpJhDBADIZz36GMW6deu0bNkybdq0SeFwuMNtXC6XrrvuupQfe8yYMRozZoxisZi++uorSVKfPn3kdjsy0wIyqrYnFUQ+U0HERSoAAAAApMtqMeelgihV/jYzeuxSn+UZUv6yEtWHm6wgEQCAfJTWq2QkEtEPf/hDPfroo5LU5UC+dAMiw+PxaNddd037+4F8ZMIdE/akoqq8pOUxqCACAAAAgHTRYi59fq8TWsxl9/wFfCVSHS3mAAD5La1XyVmzZmnevHnq1auXLr74Yu2zzz6qrKzM6MKampo0f/58rVixQv/+9791xBFHaMqUKZKkjRs36t///reGDRumkhIu1FB4THs4E/akwoRKtQREAAAAAJC2hixXoBSygM9JLeayV0EkERABAPJbWq+Sjz32mHr16qV3331XgwcPzvSa9Prrr+viiy/Wl19+qUQiIZfLpWg0agVEy5cv1/nnn6+nnnpKZ599dsb3D9jNVP9Up9NijhlEAAAAANAj8XhCDZHm1mFUEKXOtOULN8UVjcVV6sn9uID6UHYDIjPbqIGACACQx9J6hd66dauOOeaYrIRDa9as0cSJE7Vp0yb9+Mc/1pNPPrlDC7vTTjtNFRUVeuaZZzK+f8AJrAqidFrM+UyLOS5SAQAAACAd26Otc2WoIEqdvyU8kewLULLeYo4KIgBAAUjrVTIbwZDx29/+VqFQSAsWLND48eM73Mbr9erQQw/Vu+++m7V1AHaqNTOIqCACAAAAgJwz4YLbJflKc1/9ku9KPW6VlbgVboorGG5SrwpvztfQEKHFHAAA3UnrKmfKlCmqqanRtm3bMr0evfrqqxo1alSn4ZCx++67a+PGjRnfP+AEpsWcqQZKBQERAAAAAPRMsE31icvlsnk1+ckEMw3hWDdbZkf2W8yZ4yMgAgDkr7QCop///Oc66aSTdNxxx+nVV1/doQVcT3z77bcaOHBgt9s1NDQoGuUP4ChMVou5dCqIWtrS0WIOAAAAANJj/uhPe7n0tVbY2PO3G1rMAQDQvbReJffaay9J0hdffKETTzxRpaWl6tevn9zuHfMml8ultWvXJv3Yu+66qz777LNut/vnP/+ZVJAE5CNTQVSdRkBUXd78tK5tJEAFAAAAgHQEsxwuFIPWAMWeCiJTuZT1FnMhAiIAQP5K61Vy/fr17b6ORCLasGFDJtaj448/Xv/93/+tV199Vccdd1yH2zz33HP67LPPNHXq1IzsE3CaupYLTFMNlArzPfWhqOLxhNxu2iEAAAAAQCpMuEBAlD67W7CZkC+QRuv2ZFjHFyEgAgDkr7RazMXj8ZT+l4prrrlGXq9XZ555pu655x5t3rzZuu+bb77Rgw8+qMsvv1x+v18zZsxIZ/mA41kziMrTn0EUT3ChCgAAAADpaG0x57F5JfnL3/Kzs6vCJpjlc+i3uUIKAIBMSCsgyqb99ttPjz/+uOLxuKZNm6bdd99dLpdLDz/8sPr06aMrrrhC4XBYjz76qIYOHWr3coGMC0VjCjc1B6vpzCDylXrkLWl+atdR6g4AAAAAKbNazHmpIEpXoKW7hR0zehKJRM5mENlVIQUAQCY4LiCSpDPPPFMffvihfvzjH2u//faTz+eT1+vVHnvsof/3//6f3n//fZ1++ul2LxPIirpQc/WQyyUF0nwzYtrM1TGHCAAAAABS1lpBRECULlO5Y0eAEm6KqymeaFlHdgMiZhABAPJZjwKihQsX6qyzztLuu++usrIyXX755dZ9L7/8smbMmKGNGzem9diDBw/WHXfcoY8++kgNDQ1qbGzUp59+qj/96U/ac889e7JswNHqGpsvLivLStKeH2Ra0xEQAQAAAEDqsl19UgxM9ZUdFURt95mtKjCrhR4VRACAPJZ2QPTTn/5UJ510kp5//nnV19crGo0qkUhY9/fv31933HGHnnjiiYwsFCgWpoKouiL19nKGqSCqJSACAAAAgJSZuTIEROkL+OwLiEzAV+H1pP3By+5Uthwfs38BAPksrYDokUce0R//+EeNHDlSq1atUl1d3Q7bHHzwwRo4cKBeeOGFHi/y8ccf18UXX6yJEyfq8ssv14svvtjjxwScylT9mJAnHWZ2ETOIAAAAACB1rS3mPDavJH/ZOaOnPpT9FoH+Ni3m2n5gGgCAfJJWQHTPPfeoV69emj9/vkaMGNHpdgcffLA+//zzLh9rwYIFGjZsmG688cYd7kskEjrnnHN08cUX6/HHH9fChQv10EMP6dRTT9W0adPSWTrgeLUZCIiqy5lBBAAAAADpCkZoMddTVoBiYwVRLgKipnhC4aZ41vYDAEA2pRUQffjhh/re976nXXbZpcvtqqurtWXLli63eemll/TJJ59o4sSJO9x333336bnnnlMikdCZZ56pP/7xj/rJT34ir9ere+65RwsXLkxn+YCjmaofM0coHVUtpe6mXR0AAAAAIHnMIOq5gJ0BUQ4CvrazjeyokgIAIBPSnkHkcnXfw3Xjxo0qLy/vcpvly5erf//+Ouyww3a476677pLL5dLll1+uZ555RlOnTtUdd9yhp556SolEQg8++GDK677nnnt08MEHq6qqSlVVVRo9enS7lnWhUEhTp07VzjvvrEAgoHPOOWeHkGvDhg065ZRTVFFRoV133VU///nP1dTU/mKgpqZGhx56qMrKyrTXXntp7ty5O6zl7rvv1pAhQ+Tz+XTEEUdoxYoVKR8PCk9GW8w1cpEKAAAAAKnKRQVKoWttMRfL+b5z0WLO43apwtvcgtCOEAwAgExIKyDae++9tWrVKkWjnVcn1NfXa/Xq1TrggAO6fKx//etfGjlyZIe3f/TRR5Kk//iP/2h336mnnqr99ttPb731VsprHzBggG655RatXLlS77zzjo4//nidccYZ1r6uvvpqvfDCC3rqqae0dOlSbdy4UWeffbb1/bFYTKeccooikYjefPNNPfzww5o7d65mzZplbbNu3TqdcsopOu6447R69WpNnz5dP/zhD/Xyyy9b2zzxxBOaMWOGfvOb32jVqlUaPny4JkyYoK1bt6Z8TCgspurHtIlLhwmXamkxBwAAAAApC7aEGlQQpc/eFnO5OX92HiMAAJmQVkB03nnnadOmTbrmmms63WbmzJmqra3VhRde2OVjffXVVwoEAjvc/s4770iSBg0apH333XeH+/fdd99u29d15LTTTtPJJ5+svffeW/vss49+97vfKRAI6B//+Idqa2v1wAMP6LbbbtPxxx+vkSNH6qGHHtKbb76pf/zjH5KkhQsXas2aNZo3b55GjBihk046Sb/97W919913KxKJSJLuvfdeDR06VLfeeqv2339/TZs2Teeee65uv/12ax233XabrrjiCk2ePFnDhg3Tvffeq4qKirSqolBYTNVPVU8ConJazAEAAABAuloriDw2ryR/2dpiLkfnr9LGKikAADIhrY9STJ8+XX/96191xx136M0339QZZ5whSVq7dq1uv/12Pffcc3r99dd16KGH6oorrujyscrLy7Vx48YdbjfVQYcffnin3+fx9OyFPhaL6amnnlJDQ4NGjx6tlStXKhqN6sQTT7S22W+//TRo0CAtX75cRx55pJYvX66DDjpIffv2tbaZMGGCrrrqKn300Uc65JBDtHz58naPYbaZPn26JCkSiWjlypWaOXOmdb/b7daJJ56o5cuXd7recDiscDhsfV1XVydJikajXVZzIb/Ubm8+x36vu9Pzam7v7H5/qbvlsSL8bgA26u65CsAZeK4CzsfzFLkWDDf/rpW5+b1LRdvnapknIak5rMn1z9C8r67o4n11JpgWc7XbQ/yeFABea4D8wHO1e6n8bNIKiMrLy/XKK6/osssu04svvmjNzlm2bJmWLVsmSRo3bpzmzZsnr9fb5WMNGzZMy5cv1+bNm9WvXz/r9r/97W9yuVwaM2ZMh9+3YcMG9e/fP53l64MPPtDo0aMVCoUUCAT03HPPadiwYVq9erW8Xq969erVbvu+fftq8+bNkqTNmze3C4fM/ea+rrapq6tTY2OjvvnmG8VisQ63+fjjjztd980336zZs2fvcPvChQtVUVGR3MHD8dZ+6Zbk1rpPPtKCrz/scttFixZ1ePsn37okefSvrV9rwYIFmV8kgJR09lwF4Cw8VwHn43mKXKnf7pHk0oo3l2mtz+7V5J9FixYpGJWkEm2PxPT3+Qvk7n6UdcZ8uL75ffWW/9ugBQvWZ20/oWDzfl7/xzva/lkia/tBbvFaA+QHnqud2759e9Lbpt2MdZdddtH8+fP13nvvaeHChVq/fr3i8bgGDBigcePGadSoUUk9znnnnad//OMfOvXUU/Wf//mf6tOnj+699159/PHH8nq9Ovfcc3f4nu3bt2vVqlU69thj01r7vvvuq9WrV6u2tlZPP/20Jk2apKVLl6b1WLk0c+ZMzZgxw/q6rq5OAwcO1Pjx41VVVWXjypBJD2z4h1Rbp6OPGKkT9tu1w22i0agWLVqkcePGqbR0x1Z0u/9fre7551uSt1wnn9xxyAog+7p7rgJwBp6rgPPxPEUuNcXiii5/RZJ06sQTtVNF1x98Rau2z9W4y6Nfv9P8czz2hHGq9OXuufvG3z6SNv1LB+2/j04eu0fW9vP81+/qs7pt2nvYQTr5sAFZ2w9yg9caID/wXO2e6TyWjLQCopqaGo0dO1aSNHz4cA0fPrzTbWfPnq3f/OY3nd4/depUzZs3T6tWrdqhLdvVV1/drqrIePLJJxUOh3XCCSeks3x5vV7ttddekqSRI0fq7bff1p133qkLLrhAkUhE3377bbsqoi1btljr6Nevn1Ux1fZ+c5/5/+/OR9qyZYuqqqqs1ngej6fDbTo6XqOsrExlZWU73F5aWsqToYDUt/Qu7h0o7/a8dnbueweaP+JWF2ridwNwAP47DeQHnquA8/E8RS5sb9OWpZe/XKUlaY1vLmrmuVrqcSkaSygcd6l3Dp+7DdG4JKm6wpvV/2aY2cGhpgT/bSogvNYA+YHnaudS+bmkdZVzxhlnaNWqVd1ud9111+mGG27ochuv16slS5Zo2rRp6t+/v0pKSjR06FDdfPPNuummmzr8nvvuu09VVVWaOHFiOsvfQTweVzgc1siRI1VaWqrFixdb933yySfasGGDRo8eLUkaPXq0PvjgA23dutXaZtGiRaqqqtKwYcOsbdo+htnGPIbX69XIkSPbbROPx7V48WJrGxSvusbmNyPV5en/B85cpNaHmhSLU+YOAAAAAMkKRpokSV6PW17CoR7xlzV/LjkYasrpfhvCTe32ny3m8etzfHwAAGRK2q+UJ598spYtW6a99967w/t//etf6+abb9a+++7b7WNVV1frv/7rv/Rf//VfSe37zTffTGmtbc2cOVMnnXSSBg0apPr6ej322GOqqanRyy+/rOrqal1++eWaMWOGevfuraqqKv34xz/W6NGjdeSRR0qSxo8fr2HDhumSSy7RnDlztHnzZl177bWaOnWqVd1z5ZVX6q677tIvfvELTZkyRUuWLNGTTz6p+fPnW+uYMWOGJk2apMMOO0yjRo3SHXfcoYaGBk2ePDntY0P+SyQSqgs1B0RV5elfyFb6Wr83GGpSdQVpOgAAAAAkozVc8Ni8kvwXKCvRt9ujCobtCYgCWQ6IzOM35Pj4AADIlLReKZ9//nmdfPLJGj9+vF5//XXtvvvu7e6/5pprNGfOHO23335asmRJRhaaKVu3btWll16qTZs2qbq6WgcffLBefvlljRs3TpJ0++23y+1265xzzlE4HNaECRP0pz/9yfp+j8ejv//977rqqqs0evRo+f1+TZo0qV2l1NChQzV//nxdffXVuvPOOzVgwADdf//9mjBhgrXNBRdcoG3btmnWrFnavHmzRowYoZdeekl9+/bN3Q8DjhOKxhWNNVf8VPWgP3NZiUe+UrdC0bjqQlECIgAAAABIUjBH1SfFoDVAieV0v6aiJ2cBUYSACACQn9J6pRw7dqwef/xxnXvuuRo/frxee+017bzzzpKkn//857r11ls1bNgwLV682HGBxwMPPNDl/T6fT3fffbfuvvvuTrcZPHiwFixY0OXjjB07Vu+++26X20ybNk3Tpk3rchsUl9qW9nIet0sV3p59Wq26vFShaFi1jVENzMTiAAAAAKAI5Kr6pBhYLebC0W62zCwT2NBiDgCArqXdTPeMM87QX/7yF3388cc66aSTFAwGNWPGDN1666068MADtWTJEseFQ4DTWe3lfCVyuVw9eixTgWQeEwAAAADQvVzNrykGASsgym0FkalYosUcAABd69Er5WWXXaavv/5a//Ef/6F9991XmzZt0oEHHqjFixdrl112ydQagaJR11JBVF3e85ZwVS2PUdfIhSoAAAAAJMuEGQREPWdXgBI0LeZ8WQ6IfPa00AMAIFN6/Eo5Y8YMff3117rppps0fPhwvfLKK1a7OQCpsSqIMhEQtVyomtAJAAAAANC91hZzPWv7Dcnf8jMM5jAgijTFFYnFJUkBb45azFFBBADIU0m9Uh5//PHdblNa2vwH7fPOO6/d7S6XS4sXL05jaUDxMdU+pj1cT1gVRLSYAwAAAICkmTDDn+VwoRgEyprfl+YyIGpbreTPcshnQkRazAEA8lVSVzs1NTVJPdh77723w209naMCFJPaRlNB1PM3ItVWizkCIgAAAABIFjOIMseOAMWEUb5St0o8aY/eToqfGUQAgDyX1NXOunXrsr0OAGoNczJSQeQzFURcqAIAAABAslpbzBEQ9ZQJUII5fF8azOH5M/vIZYUUAACZlNSr5eDBg7O9jg5t2LBBmzZtUjgc7nSbMWPG5HBFQHZldAZROTOIAAAAACBVwXBMEhVEmRDw5T5AyWUFmAmIwk1xRWNxlWa5YgkAgExz5NXOgw8+qN/+9rfasGFDt9vGYrEcrAjIDTODqDoTAVFLBVEtAREAAAAAJK21gii782uKgQlQGiK5C4jqc1hB1DaEagg3qVeFN+v7BAAgkzLyavntt9+qvr5eiUSiw/sHDRqU9GM99NBD+uEPfyhJOvDAA7XPPvuosrIyE8sEHM+qIPL1/KlpqpDMYwIAAAAAumfCDCqIes7vzX2LuVxWEJV63CorcSvcFFeQgAgAkIfSfrXcvHmzrr32Wv3P//yPvvrqq063c7lcampK/kLgtttuU0lJiZ5++mmdfvrp6S4PyEsZbTFnZhA10gsZAAAAAJIVzGHAUOjsbDGXqxlSgbIShZsizCECAOSltF4tN23apMMPP1wbN27U7rvvrl122UVbt27V6NGj9fnnn2vLli1yuVwaPXq0SktT+0P3p59+qjFjxhAOoSiZdnAm3OmJaiqIAAAAACBluQ4YCpnVYi6cu/EA9aHcnj9/WYm+aohYvzcAAOSTtKbn3Xjjjdq4caNuuOEGffnllzrppJPkcrn0xhtvaNOmTaqpqdF+++0nl8ulF198MaXH7t27t/r06ZPOsoC8Z6p9qsoz0WKupOUxCYgAAAAAIFkmzKCCqOfMzzC3FUS5PX8B6xiZkQ0AyD9pBUQvvfSShg4dqmuvvbbD+8eMGaOFCxfq3Xff1W9/+9uUHvuMM87QG2+8oWiUP2qj+Jhqn+oMtphriMTUFIv3+PEAAAAAoBgErQoij80ryX9WBVGkqdO51ZlmZkjl6vxZAVEO5ywBAJApaQVE//rXvzRixAjra4+n+UU3HA5bt+2+++467rjj9OSTT6b02DfddJP8fr8mT56sb775Jp3lAXkpkUhY1T6ZaDFX6Wv9tFQdF6oAAAAA0K1EImG1CqOCqOdMeJJISNsjuamwaW0x1/P31cnwtwRRtJgDAOSjtK52qqqq2n3dq1cvSc3B0R577GHd7vP59K9//Sulx/7Zz36mYcOG6fHHH9f8+fM1cuRIDRgwQG73jlmWy+XSAw88kPoBAA7UEIkp3vKBqqoMVBCVeNzyez1qiMRU1xhVb7+3x48JAAAAAIUs3BRXU8sbMwKinvOVuuV2SfFEc2VWLn6mrQFfbiqI7GijBwBApqT1yjxo0CBt2LDB+vrAAw+UJC1YsEDTpk2TJG3fvl1vvPGG+vfvn9Jjz5071/p3bW2tlixZ0um2BEQoJLUt1UNej1tlJWkV9+2gqry0OSAK0bIRAAAAALrTtgrE7yUg6imXy6VAWYnqQk0KhpvUNwf7bLBaBObm/JnuHVQQAQDyUVKvlscff7wmTpyoX/ziF9bXd955p7Zt26ZddtlFp59+uvx+v37+85/r//7v/7T77rtr3rx52rJli6666qqUFvTqq6+mfhRAAbDay5WXyOVyZeQxq8tLtak2pLpGLlQBAAAAoDsN4eY2aOWlHnncmXlfVuxMQJSrAKXeBES+3AREJkikgggAkI+SerWsqanRkCFDrK9/8IMf6Msvv9SaNWt07LHHqnfv3vrzn/+syZMna86cOXK5XEokEjrggAP0u9/9LqUFHXvssSltDxSKTM4fMsxjUUEEAAAAAN0LMn8o46wWbDmajZvrGVK0mAMA5LO0Xi2HDx+uxx9/vN1tF110kY466igtWLBA33zzjfbZZx+dfvrpKi3NzVBAIN/VtVwsZ2L+kFFV3vwUN+ETAAAAAKBzDRHTniw382uKgankyVWAQos5AACSl9FXy0GDBunKK6/M5EMCRaO1xVzmK4hqCYgAAAAAoFtUEGWeCWpM+JZtwRwHRFQQAQDyme1XPHvssYdcLpdeeeUVDR06VHvssUfS3+tyubR27dosrg7IHdMGriqDfZJN2ESLOQAAAADoXq7bkxUDa0ZPjlrMERABAJC8pF8tP/vsMz3yyCNp7eTSSy/t9L7169dLkqLRaLuvgWJTm5UKItNijgtVAAAAAOhOrtuTFYPWFnOxrO+rKRZXKBqXlLuQr9JUSOXg+AAAyLSkXy3feOMNvfHGG2ntpKuAKB6Pd/k1UCxMiGPawmUCFUQAAAAAkDwTYlBBlDlWi7kcVNi0DWn8OZojRQURACCfJX3F07dvX+27777ZXAtQ1KwWc+VZaDHHDCIAAAAA6FZrBVFuwoViYIKaXAQowZY5R16PW2UluQqIcnd8AABkWtJ/iZ44caIefPDBbK4FKGomxKnOaIu55seqJSACAAAAgG5ZM4i8VBBlSqCs+X1pLgKU1hlSuQv4clkhBQBAprntXgCAZlYFUUZbzLXMIMrRMFAAAAAAyGdBK2AgIMoUU42ViwClvuW9r5l7lAsmINoeiSkWT+RsvwAAZAIBEeAQtWYGURYqiGgxBwAAAADda20xR0CUKbmc0WNHBVjbMLEhwoczAQD5hYAIcAgT4lRl8JNOpl2dqU4CAAAAAHQuGI5JooIokwI2BES5DPjKStwqcbva7R8AgHxBQAQ4hNViLpMVRC2PFYrGFW6KZexxAQAAAKAQ2THDptDlckZPfTj3LeZcLpe1PwIiAEC+SeoVc926dQoEAtleC1C04vGE9Wmq6gwGRJVlJXK5pESiuRdzWYA3OQAAAADQGdMijBZzmWO1mMvBbNwGm2ZI+b0l+nZ71JqBBABAvkiqgmjw4MHaeeeds70WoGjVh5uUaJllWZnBTzq53S7rjU0tc4gAAAAAoEtBmwKGQmbHDKJADmcQSW2rpOjcAQDIL7SYAxzAzB/ylbpVVpLZKp8qX2m7fQAAAAAAOmbHDJtCZz4E2RCJKWE+GZkldrSYa7u/XIRgAABkku1XPDfccEPa3+tyuXTddddlcDWAPUx1jwlzMqmqvFT/+rZRdZS6AwAAAECXTAUIFUSZY36WsXhCoWhc5d7stT63rcVcDqukAADIJNuveK6//nq5XK4dPkXicrmsf5v7vnsbAREKRV2oJSDK4Pwho7q8+WlOBREAAAAAdC6RSFgziPxlzG/NlIrS1p9lMNyU5YCoOeAL5Pj8mf01EBABAPKM7QHRQw89tMNty5cv13333acBAwbo3HPP1ZAhQyRJX3zxhZ555hlt2LBBP/rRjzR69OgcrxbIjrrG5ovIqiyUwVst5kIERAAAAADQme2RmDUblhZzmWNm4wbDTWoIN2mXyrKs7as+ZFoEZv7Dl13xe6kgAgDkJ9uveCZNmtTu6xUrVujKK6/UNddcoxtuuEElJe2XOGfOHM2aNUu33nqrJk+enMulAlljwpvqLFQQmaokE0IBAAAAAHZkqj/cLqm8lAqiTPKXeRQMN2U9QGltMZfjCiJmEAEA8pQ7Ew8SDoe1adMmff311z1+rFmzZmnPPffUTTfdtEM4JEkej0e/+93vtNdee2nWrFk93h/gBKb9WzZazJkKolpazAEAAABAp8wf9/3eknYt7tFzuZrRY1oE5roCzOyPFnMAgHzTo4Dovvvu0yGHHCK/368BAwboP/7jP6z7nn32WZ199tn67LPPUnrMt956S8OHD+92u+HDh2vFihUprxlwIisg8mWjgqhlBhEt5gAAAACgU2Z+jZ/2chlXmaMAJRiyJyDKVQAGAECmpRUQxWIxnXXWWbrqqqv0z3/+U/vvv78SplFvi+HDh+tvf/ubnnjiiZQf+/PPP+92u88//1yxWCylxwacqq7lItaEOZlkzSCigggAAAAAOhW0qT1ZMchVgNJ6DqkgAgAgGWkFRHfddZeef/55nXTSSfriiy/0wQcf7LDNnnvuqb322ksvvvhiSo89atQorVixQo888kin2zzyyCN66623NGrUqJTXDjhRNiuIzFwjE0IBAAAAAHZk/rif6+qTYpCzFnM2ncMAFUQAgDyV1ivm3Llz1bdvXz3xxBPy+/2dbjds2DCtXLkypceePXu2XnvtNU2ePFlz587VBRdcoMGDB0uSvvjiCz355JOqqalRSUmJZs+enc7yAccx7d+qszGDqJwKIgAAAADojplfQ4u5zMtFi7l4PKGGSHOnmYDPrhZzdLoBAOSXtF4xP/nkE40fP77LcEiS/H6/tm3bltJjH3XUUXr22Wc1ZcoU1dTUaOnSpe3uTyQS2nnnnfXAAw/oqKOOSnntgBPVNZoWc1kIiFoujAmIAAAAAKBzdrUnKwa5CFBMwCfZV0FEizkAQL5J6xWztLRUoVCo2+02bNigysrKlB//1FNP1eeff66nn35ay5Yt08aNGyVJ/fv31zHHHKPzzjtPgUAg5ccFnMpUEGWjxZxVQRQiIAIAAACAztBiLnusgCiLrc8bWsInj9ulspK0JiqkLZCD4wMAIBvSuuo54IADtHLlStXX13caAG3dulWrV6/WkUcemdbCAoGALrvsMl122WVpfT+QT2rNDKLyzL8RaW0x16REIiGXy5XxfQAAAABAvjPVLf4yj80rKTyVvuxX2ATDze+rA2UlOX/fa35nqCACAOSbtD5Scckll+irr77SlVdeqUgkssP9sVhMU6dO1fbt2zVp0qQeLxIodKb9WzYqiMxco0gsrnBTPOOPDwAAAACFoIEWc1nj9zYHKMFINgOilvlDNpw/M/MoGGn+YCYAAPkirYDoRz/6kcaOHavHH39c++67r6688kpJ0nvvvaef/vSn2mefffTMM89o3Lhx+sEPfpDWwhYuXKizzjpLu+++u8rKyjRlyhTrvpdfflkzZsywWs8B+awpFrcGaWZjBpHf65G75cNTzCECAAAAgI5ZLea8BESZlpsWcybgy30FmAmlEglpeyR7c5YAAMi0tAIij8ejBQsW6KqrrtLGjRt13333SZLeffdd/fGPf9SGDRt0xRVX6G9/+1taZb0//elPddJJJ+n5559XfX29otH2f9Tu37+/7rjjDj3xxBPpLB9wlPo2F8hVvsy/EXG5XMwhAgAAAIBuBKkgyppctJgz763tqCAqL239YCZt5gAA+STtV02fz6e7775b119/vWpqarR+/XrF43ENGDBAxx13nHbbbbe0HveRRx7RH//4Rx122GG67777NGLECLnd7XOsgw8+WAMHDtQLL7ygq6++Ot1DABzBhDZ+r0clnuwM0qzylerb7VFr1hEAAAAAoD2rgoiAKOOsCqIshid2tgh0uVzye0tUH25SMNykXXO+AgAA0tPjV81ddtlF5513XibWIkm655571KtXL82fP1+77LJLp9sdfPDB+uCDDzK2X8AudY3NF7HZaC9nVJWXtNsXAAAAAKC9hpYZNlQQZV5OAqKIvQFfwNcaEAEAkC+yU67QAx9++KG+973vdRkOSVJ1dbW2bNmSo1UB2WOqeqp8WQyIfLSYAwAAAICuBG2cYVPoKssKu8WclJsQDACATOvRq+bSpUu1dOlSbdq0SeFwuMNtXC6XHnjggZQeN5m5RRs3blR5eXlKjws4kQltTJVPNlSbGUS0mAMAAACADtldgVLI/FZAFMvaPuxsMdd2v9k8RgAAMi2tV82vv/5aZ511ll5//XUlEokut001INp77721atUqRaNRlZZ2XFFRX1+v1atX64ADDkhp3YATmdCmOpst5qwKIj7JBAAAAAAdsTtgKGTmZxqJxRVuiqmsJPNVWnbPkMpFlRQAAJmW1qvm1VdfrWXLlumAAw7Qj370I+2xxx4KBAIZWdB5552nX//617rmmmt06623drjNzJkzVVtbqwsvvDAj+wTsZFUQZbPFnDWDiAoiAAAAAOhI0OaAoZC1/Zk2hLMTENWb8+ezq4LI024dAADkg7ReNV944QUNGDBAy5cvz1gwZEyfPl1//etfdccdd+jNN9/UGWecIUlau3atbr/9dj333HN6/fXXdeihh+qKK67I6L4BO9Q1Nl88VuWggqiWgAgAAAAAdtAUiysUjUuigigbPG6Xyks9aozG1BBuUm+/N+P7sLsCzE8FEQAgD6X1qhmLxTR69OiMh0OSVF5erldeeUWXXXaZXnzxRa1YsUKStGzZMi1btkySNG7cOM2bN09eb+YvKIBcM6FNVRY/5WTCJ1OtBAAAAABo1RBpnRtjKkGQWf6yEjVGY6rPUutzM/snYNP5o8UcACAfpfUX6ZEjR2rz5s2ZXotll1120fz58/Xee+9p4cKFWr9+veLxuAYMGKBx48Zp1KhRWds3kGtWi7lsVhBZLea4UAUAAACA7zJ/1C/1uLLS/gxSpa9E/w6G1RDJzvtSq8VcWfbeW3fFVBBlKwADACAb0gqIrr32Wk2cOFEvvfSSJk6cmNEFnX322erfv7/uvvtuDR8+XMOHD8/o4wNOU9eY/RlE1VQQAQAAAECn7G5PVgxMZVYwSxU2refQnoCPFnMAgHyU1pXP8ccfr8cee0yXXnqpTj75ZI0bN06777673G53h9uPGTMm6cdesGCBzjzzzHSWBeSlulDuZhDVMYMIAAAAAHZgQgu/l4AoW8zPNpi1FnOmgsiec2j2m60KKQAAsiHtV81gMKjS0lL993//t/77v/+7y21jsViX97c1dOhQNTQ0pLssIO9YFUTl2Z9BVEtABAAAAAA7aJ1fQ0CULZW+7FbYmODJ7oCIFnMAgHyS1qvm3LlzdfnllyuRSOiQQw7RHnvsoUAgkJEFXXTRRfrDH/6gzZs3q1+/fhl5TMDJrBlEWWwxZ1UQhZqUSCTkcrmyti8AAAAAyDdBm9uTFQPTgi0bLeYSiYRVuWNXQESLOQBAPkrrVXPOnDkqKyvTggULNHbs2IwuaObMmXrrrbd07LHH6pZbbtGpp56q0lJ7BgwCuWCqeqqz2WKupTopFk9oeyRGX20AAAAAaIMZRNmXzYCoMRpTPNF+P7lmtZgLJ99FBwAAu6X1qrl+/Xode+yxGQ+HJGnfffdVPB7Xl19+qXPPPVcul0u77rqrfD7fDtu6XC6tXbs242sAciXcFFMoGpeU3Qqi8lKPSj0uRWMJ1YWivOkBAAAAgDbsrj4pBpVZrLAx7eVcLqnCa08VWMCXvQAMAIBsSevKZ/fdd1dFRUWm1yKpOXxqK5FIaPPmzVnZF2C3tr2JzcVkNrhcLlX5SvVVQ0R1jU3qX521XQEAAABA3glSQZR1rRVEma+wMecv4C2xraV6oKU9IQERACCfuNP5pksvvVSvvvqqvv7660yvR/F4PKX/AfmsrqW9XKWvRB53di9iq8rNHKJoVvcDAAAAAPnGVLVQQZQ92WwxZ9q62RnwtZ1BlEgkbFsHAACpSCsg+tWvfqXjjjtOxx13nGpqanjhA9JU11JBlM32ckZVS4VS7XYCIgAAAABoqzVgsKc9WTHIZou5+nDz+9xsdubojgkXm+IJhZv4QDMAID+k9cq59957S5K++OILnXDCCSotLVW/fv3kdu+YNzEnCOhcbUsFkanuySYqiAAAAACgY7SYy76CryDytu47GG6Sr5SwEQDgfGm9cn53TlAkEtGGDRsysR699tprKW0/ZsyYjOwXsINpMVeVg085mSols08AAAAAQDNazGWfqc4KhrIREJnzZ18o43a7VOH1aHskpoZwk/oEymxbCwAAyUrryiebs3/Gjh2b0kDBWCzzww2BXDHVPLmtIGJgJgAAAAC0ZVUQeQmIsqWy5YORDZFstJhzRsDnLyvR9kgsK1VSAABkg+OufC699NIOA6J4PK4vv/xSq1atUl1dnc444wz16tUr9wsEMqiusfmisTonAVFJyz6pIAIAAACAthpoMZd1/izOIHLK+assK9G2+nBWqqQAAMgGx135zJ07t8v7v/nmG11xxRX68MMPtXz58twsCsgSq4LIl4OAyMcMIgAAAADoiJlhY3cFSiEz1Vn1WW0xZ38FkZSdKikAALIhqVdOM19o9913l8fjSXne0KBBg1JfWSd22mknPfLII9pzzz01c+ZM3XvvvRl7bCDXrBlE5TmYQdRSpVRLBREAAAAAtGO1mLNxhk2hMy3mwk1xNcXiKvG4M/bYJnSyPyBqmbMUZhwCACA/JPXKOWTIELndbq1Zs0b77LOPhgwZkvScIJfLpaamzH5yoqKiQqNGjdL//M//EBAhr5mwJjcVRKbFHJ9kAgAAAIC2TMWH3QFDIWvb/q0hHFN1ReYCIqe0mAuUNb+3p8UcACBfJPXKOWbMGLlcLlVUVLT72k7BYFDffPONrWsAeqqu5aKxKicziGgxBwAAAAAdcUrAUMhKPW55S9yKNMVVH46quiJz74OdEvAFWiqIsjFnCQCAbEjqlbOmpqbLr3PthRde0GuvvaZhw4bZug6gp6wWc77sX8RWExABAAAAwA7CTTFFYwlJBETZVllWoq+aItbMp0xxTou55v0HCYgAAHkiqVfOPfbYQ+edd55+//vfZ3s9mjJlSqf3BYNB/e///q8++OADJRIJ/exnP8v6eoBsMmFNdS4qiFra2NFiDgAAAABatQ0r/F5mEGWTv6xEXzVEMh6gOKUCLNDy4U8qiAAA+SKpV87169dr27Zt2V6LJGnu3LndbjNo0CD95je/0aWXXpr9BQFZZMKa3LSYa5lBFIoqHk/I7ba3TSQAAAAAOIH5Y76v1K0ST+bm4mBH2aqwMSGf3RVEAS8VRACA/OK42ulXX3210/u8Xq/69++vIUOG5G5BQJYkEonWFnM5rCBKJKRgpMn6GgAAAACKmfljvt3hQjGoLMtOhY11DnPQvr0rtJgDAOQbx139HHvssXYvAciJcFNckVhcUm5mEPlKPdZA0LrGKAERAAAAAMg57cmKgb+suYVfpgOU1pDP3haBgSwFYAAAZAu104BNTPWQ2yX5vbl5I2JmHTGHCAAAAACamXAhV+/LiplVYRPK3HvSRCLhmJDPVDBRQQQAyBdJv3KuXr1aN9xwQ1o7mTVrVtLbfvrpp1q+fLmOOeYYDR061Lr9H//4h6ZPn64PP/xQgwYN0o033qizzz47rfUATlAXam0vl6t5QFW+Em2rD1v7BgAAAIBi55T5NcWg0pf5CptwU1xN8YQk+89ha4u5mK3rAAAgWUm/cr733nt67733UnrwRCIhl8uVUkB066236v7779f69eut27Zs2aIJEyaovr5eLpdLH3/8sS644AK99dZbOvTQQ1NaE+AUtS1VPLls9VZlVRAREAEAAACA1LbFnL3tyYqBqdIKRjIXELWt1rG7Csy0uKPFHAAgXyT9yrnnnnvqqKOOyuZaJEmvv/66RowYoQEDBli3Pfjgg6qvr9eMGTN00003acGCBTrnnHN02223ad68eVlfE5ANrRVEubuANWFULQERAAAAAEhq02KOCqKsy0aLORPGVHg9OevO0ZlAWfN7blrMAQDyRdJXP0cffbQefPDBbK5FkrRp0yaNHTu23W0vvfSSysrKdP3118vr9erMM8/UEUccobfeeivr6wGyxVTx2FJBlMGLcQAAAADIZyZgsLs9WTHIRou5+pBzzp+pQiMgAgDkC7fdC/iuUCgkj6e1rDscDuvtt9/WEUccoUAgYN0+dOhQbdy40Y4lAhlhS0DUcjFOizkAAAAAaGbanVFBlH3ZmNHjpIDPrCHSFFc0Frd5NQAAdM9xAdGAAQP0/vvvW1+/8sorCoVCOv7449tt19jYKL/fn+vlARljqnhy2WKu2qogIiACAAAAAKntDCL7A4ZC1xoQZe49aYODAr62a2AOEQAgHzguIDr++OP16aefavr06XrhhRf0y1/+Ui6XS2eccUa77T744AMNHDjQplUCPWeqeExokwtWi7lGLlQBAAAAQJIaWqpZAmWebrZET1WWmRZzmasgclKLuVKPW2UlzX9qq6e1OwAgDzguIJo5c6Z69eqlP/7xjzrzzDO1Zs0anX/++Ro+fLi1zUcffaS1a9fqqKOOsnGlQM+YKp7ctpijgggAAAAA2gpSQZQz/rLMzyAyYZNTzp8JqkxlEwAATpbUq2c8nru+qYMGDdJ7772n+++/X9u2bdPIkSN12WWXtdvm3Xff1RlnnKHzzz8/Z+sCMq3WzCDKaQVRSbt9AwAAAECxc9IMm0Lnb6nSqs9oQGTOnzMqwPxlJfqqIUKLOQBAXnDk1c+AAQN0/fXXd3r/xRdfrIsvvjh3CwKywLR5y+UMIquCiIAIAAAAACQREOVSZVnze9JMhicmbAr4nHH+zO8RLeYAAPnAcS3mgGJhS4u5lmolLlQBAAAAoBkt5nLHVBBtj8QUiycy8pgNDjt/gSzMWQIAIFuc8erZifr6eq1du1b19fVKJDq+cBgzZkyOVwVkhqniqc5hizmzLyqIAAAAAKCZ+UM+FUTZ1zbEaYg0ZeQDk1YFmNcZ58+EYLSYAwDkA2e8en7Hhx9+qOnTp6umpqbTYMiIxfhEBvJTXci0mMthBVFLyX19uEmxeEIetytn+wYAAAAAJ3JaBUohKytxq9TjUjSWUEM4MwGR41rMtRxTJucsAQCQLc549Wzj008/1dFHH626ujodddRR2rRpk9atW6cLL7xQn3/+uVatWqWmpiadfvrp6tWrl93LBdKSSCSsKp5ctpirbLOv+lBUvSq8Ods3AAAAADhNIpFQQ8QERB6bV1P4XC6X/GUl+nZ7NGMVNk4L+AJUEAEA8ojjZhDdeOONqq+v10MPPaRly5bpmGOOkSQ9+uijWr58uT766CMdffTRWrNmjW677TabVwukZ3skpqaWfstV5bm7iPWWuFVe2nyxWtfIxSoAAACA4tYYjcmMwqHFXG74W1rBZWo2rtViziHnzxwfAREAIB84LiBasmSJ9t9/f02aNKnD+/faay89//zz2rZtm6677rocrw7IjLpQc/VQidtlBTa5YgIpswYAAAAAKFbBlj/iu13K+XuzYlXpMwFKZkYGmKDJKQFRoE1rdwAAnM5xAdHWrVs1bNgw6+vS0uaWWKFQyLqtV69eGjt2rP7+97/nfH1AJpjqnaryUrlcuZ0DZFramRZ3AAAAAFCsTEjh95bk/L1ZsTKt4IKZajEXcVqLOSqIAAD5w3EBUe/evRUOh9t9LUlffPHFDttu3bo1Z+sCMslU71SX527+kGH2SQURAAAAgGLntPk1xSDjAVFLyOeUCiI/AREAII84LiAaOnRouzBoxIgRSiQSeuKJJ6zb/v3vf6umpkaDBg2yY4lAj5nqnSpf7i9gq0xAxAwiAAAAAEUuaAVEtJfLlcoMByhB02LOhvfXHQlkOAADACCbHBcQjR8/Xh9++KEVEp122mnq06ePbrjhBl144YX62c9+psMPP1y1tbU6//zzbV4tkB5TvVNlQwWRCaVqaTEHAAAAoMiZkMIp1SfFwIRxmQhQIk1xRWJxSVLA64xzSEAEAMgnznj1bOOSSy5ROBzWli1bNHjwYPn9fv31r3/V+eefryeffNLabty4cfr1r39t40qB9NVuNxVENgREtJgDAAAAAEltK4gc9+eRgpXJFnNtq5CcUgXW2mIuZvNKAADonuOugPbcc0/dfPPN7W47/vjj9cUXX2jZsmX65ptvtM8++2jkyJE2rRDoubqWEviqchtazPlMizkCIgAAAADFzfwRn4AodzLZYs6ETL5St0o8zmiSk8kKKQAAsi1vroD8fr8mTpxo9zKAjLBmENnQYq7aqiDiYhUAAABAcaPFXO5lsoIo6MDzV1nW/J47yHtuAEAecM4raCc+/fRT/fvf/9bOO++sffbZx+7lABlhzSCypcVc89OeCiIAAAAAxa61xZwz2pMVAysgykCA0uDAFoHmd6kxGlMsnpDH7bJ5RQAAdM4Z9bffEQ6H9atf/Up9+vTRfvvtp6OPPlq33HKLdf+8efN06KGHavXq1fYtEuiBukbTYs6GgMjHDCIAAAAAkJwZMBS6Sl9Li7lIzwOiegdWELX9XcrEMQIAkE2OC4gaGxs1duxY/f73v5fX69XJJ5+sRCLRbpvjjz9e7733np588kmbVgn0TK1pMeezYQZRSyhVSwURAAAAgCJn/oAf8DonYCh0fq9pMRfr8WM5MeArK3Gr1NNcNUSbOQCA0zkuIJozZ47eeustTZkyRZ9//rleeOGFHbbZbbfdNGzYML3yyis2rBDoOavFnJ0VRI1cqAIAAAAobiakcFLAUOhaW8z1/EOLTpwh5XK5rGNsyMCcJQAAsslxAdETTzyhQYMG6Z577pHP5+t0u3333VdffvllDlcGZI4jZhDRYg4AAABAkXNiwFDorBZzGaggqg858/y1VkkREAEAnM1xAdG6det02GGHqaSk6xd3r9erb775JkerAjLLVO9U21BBZPa5PRJTNBbP+f4BAAAAwCmCDmxRVugyWV3T4NAKsEyGYAAAZJPjAqLy8vKkgp9169Zpp512ysGKgMyKxxOqt1rM5f4itu0nq+rphwwAAACgiLXOsPHYvJLiYX7WwUjTDjOnU2XNkHLY+bPa6IXp3AEAcDbHBUQjRozQO++8o23btnW6zbp16/Tuu+/q8MMPz+HKgMxoiDQp3nINbEeLuRKP2wqJahu5WAUAAABQvGgxl3uVZc3vgxOJ5s4WPdHaYi7376270hoQUUEEAHA2xwVEV1xxherr63XRRRfp3//+9w73f/vtt5oyZYqi0ah+9KMf2bBCoGdMKOMtcctXas+nnKpayt3rCIgAAAAAFLGgQ1uUFTJfqVtuV/O/e9pmzqkVYKaiKRNt9AAAyCbHBUQXXXSRLrzwQi1ZskR77LGHJk6cKEl64403dMYZZ2jIkCFaunSpLrnkEp166qk2rxZInZk/ZEf1kFHVMoeoLkRABAAAAKB4UUGUey6Xywrk6jMUEDnt/AWsCiICIgCAszkuIJKkRx99VL///e/l8/m0cOFCSdKnn36qF154QS6XS7/73e/00EMP2bxKID11Ns4fMkw4ZcIqAAAAACg2sXhCjVEqiOxQ2fLz7mmFjQmYAj5nnT8/AREAIE846xW0hcvl0s9//nPNmDFDq1at0vr16xWPxzVgwAAdfvjh8nq9di8RSJtp61ZdTgURAAAAANilIdL6x3untSgrdJkKUFpbzDnrz1uBDAVgAABkm7NeQb/D4/Ho8MMP1+GHH273UoCMqQs5ocUcM4gAAAAAFDfzx/tSj0tlJQREuWQFRKECbzHXw+MDACDbHNliDihktY2mxZyNAVFLOFVLQAQAAACgSDm1+qQYVLa0hGtbxZWOoEMDIlrMAQDyhe2voDfccEPa3+tyuXTddddlcDVA9pmqnSobeyTTYg4AAABAsQuGW+YPeW3/00jRMT9zcw7S5dSAyGox18MADACAbLP9FfT666+Xy+WSJCUSiaS+x+VyKZFIEBAhL5lQxt4KItNijotVAAAAAMXJqe3JikEmWsw1xeIKRePtHs8prBZzPQzAAADINse8gh566KE67bTTVFZWltX93HzzzXr22Wf18ccfq7y8XN/73vf0+9//Xvvuu6+1zdixY7V06dJ23/f//t//07333mt9vWHDBl111VV69dVXFQgENGnSJN18880qKWn9kdbU1GjGjBn66KOPNHDgQF177bW67LLL2j3u3Xffrf/8z//U5s2bNXz4cP3xj3/UqFGjsnPwcAQTylTbGBBVU0EEAAAAoMgFrRZzzB/KNavFXA9asDW0CV+cdg5bAzDecwMAnM32gGjixIl65ZVXtHLlSq1du1bnnHOOfvCDH2js2LFZ2d/SpUs1depUHX744WpqatKvfvUrjR8/XmvWrJHf77e2u+KKK9q1v6uoqLD+HYvFdMopp6hfv3568803tWnTJl166aUqLS3VTTfdJElat26dTjnlFF155ZV69NFHtXjxYv3whz9U//79NWHCBEnSE088oRkzZujee+/VEUccoTvuuEMTJkzQJ598ol133TUrxw/7WRVEPhsriExAxAwiAAAAAEWKGUT2MYFOT2b0BFvat3k9bpWVOCsgslrMUUEEAHA4t90LWLBggf71r3/pjjvu0N57760HHnhAJ5xwggYPHqyZM2fqo48+yuj+XnrpJV122WU64IADNHz4cM2dO1cbNmzQypUr221XUVGhfv36Wf+rqqqy7lu4cKHWrFmjefPmacSIETrppJP029/+VnfffbcikYgk6d5779XQoUN16623av/999e0adN07rnn6vbbb7ce57bbbtMVV1yhyZMna9iwYbr33ntVUVGhBx98MKPHDGexZhCV2ziDyGcqiGgxBwAAAKA40WLOPlaFTY8qiJxbAWbW1JMKKQAAcsERV0G77LKLfvKTn+gnP/mJPv30U82bN0+PPfaYfv/732vOnDk66KCDdMkll+iiiy7SbrvtltF919bWSpJ69+7d7vZHH31U8+bNU79+/XTaaafpuuuus6qIli9froMOOkh9+/a1tp8wYYKuuuoqffTRRzrkkEO0fPlynXjiie0ec8KECZo+fbokKRKJaOXKlZo5c6Z1v9vt1oknnqjly5d3uNZwOKxwOGx9XVdXJ0mKRqOKRqkEyRe125tDxIpSV9rnzXxfut9fUdq6Fn53gOzp6XMVQG7wXAWcj+cpssG8NysvdfO7lSHJPlcrSppnUdc3pv+e9NtgSFJz2OS08+dryayCkSZFIhFr9jacjdcaID/wXO1eKj8bRwREbe29996aPXu2Zs+ereXLl2vevHl66qmn9Itf/ELXXHONTj31VD333HMZ2Vc8Htf06dN11FFH6cADD7Ru//73v6/Bgwdrt9120/vvv69f/vKX+uSTT/Tss89KkjZv3twuHJJkfb158+Yut6mrq1NjY6O++eYbxWKxDrf5+OOPO1zvzTffrNmzZ+9w+8KFC9u1wIOzbfnGI8mlD1euUP3/9uyxFi1alNb3fRWSpBJ92xDWggULerYIAN1K97kKILd4rgLOx/MUmfT+Brckt/696f+0YMEGu5dTULp7rn62zSXJoy/+tTnt96Qff9v8GPHwdse9r23uLFeiREL6299flAOLnNAFXmuA/MBztXPbt29PelvHBURtjR49WqNHj9a1116ryy+/XC+99JLeeOONjD3+1KlT9eGHH+r1119vd/uPfvQj698HHXSQ+vfvrxNOOEFr167VnnvumbH9p2rmzJmaMWOG9XVdXZ0GDhyo8ePHt2uBB2f79aolkpo08YRjNbSPv9vtOxKNRrVo0SKNGzdOpaWpzzKqa4zqhndfVTTh0gnjJqislKtVIBt6+lwFkBs8VwHn43mKbFg5/2PpXxt0wD576uRxe9u9nIKQ7HO1dM1WzftstXxVO+nkk49Ia1/uj7ZI/3xP/fvspJNPHpXukrMikUjomrcXKZ6Qjhp7gnatLLN7SUgCrzVAfuC52j3TeSwZjg2IQqGQnn/+ec2bN08LFy5UNBpVVVWVzj///Iw8/rRp0/T3v/9dr732mgYMGNDltkcc0Xyx8tlnn2nPPfdUv379tGLFinbbbNmyRZLUr18/6//NbW23qaqqUnl5uTwejzweT4fbmMf4rrKyMpWV7XhRUVpaypMhT8TiCavH8s6V5T0+b+me+508JXK5pERCaoy5FKjg9wfIJv47DeQHnquA8/E8RSY1RuOSpMoKL79XGdbdc7WXv/lvG9sjsbR/9o1NCUlSZbkz/7vgLytRfahJoZgcuT50jtcaID/wXO1cKj8XdxbXkbJEIqFFixbpsssuU9++ffX9739fCxcu1EknnaQnnnhCW7Zs0V133dXjfUybNk3PPfeclixZoqFDh3b7PatXr5Yk9e/fX1JzZdMHH3ygrVu3WtssWrRIVVVVGjZsmLXN4sWL2z3OokWLNHr0aEmS1+vVyJEj220Tj8e1ePFiaxsUnmCodUBlpc++/4C53S5VtgwFrQvRrxMAAABA8WmINL8/C5Q59rOzBcvf8jNvaO7FlpaGlg9f+h16/gLWMTZ1syUAAPZxxKvoqlWrNG/ePP31r3+1Kmq+973v6Qc/+IHOP/989e7dO2P7mjp1qh577DE9//zzqqystGYGVVdXq7y8XGvXrtVjjz2mk08+WTvvvLPef/99XX311RozZowOPvhgSdL48eM1bNgwXXLJJZozZ442b96sa6+9VlOnTrUqfK688krddddd+sUvfqEpU6ZoyZIlevLJJzV//nxrLTNmzNCkSZN02GGHadSoUbrjjjvU0NCgyZMnZ+x44Sy1jc1hTHmpR94Se/PZqvJS1YWarDUBAAAAQDEJtoQTfq8j/jRSVEyoU9+DDyya4CXg0PNnjjFIQAQAcDDbX0X3339//e///q8kab/99tO0adP0/e9/X0OGDMnK/u655x5J0tixY9vd/tBDD+myyy6T1+vVK6+8YoU1AwcO1DnnnKNrr73W2tbj8ejvf/+7rrrqKo0ePVp+v1+TJk3SDTfcYG0zdOhQzZ8/X1dffbXuvPNODRgwQPfff78mTJhgbXPBBRdo27ZtmjVrljZv3qwRI0bopZdeUt++fbNy7LCfqdapKrf9qacqX6mkRtUREAEAAAAoQk6vQClklb6W6ppITIlEQi6XK+XHqDcBkc+Z589UELXtJAIAgNPY/ir6ySefyOVy6ZBDDtGhhx6q9evX66abbkrqe10ul/785z+ntL9EItHl/QMHDtTSpUu7fZzBgwdrwYIFXW4zduxYvfvuu11uM23aNE2bNq3b/aEwmDCmysb2coYJqeq4WAUAAABQhKwKFAKinDOhXCyeULgpLl+pJ+XHcHrAZ7WYi/CeGwDgXI54FU0kElq1apVWrVqV0velExABdjIVRNXlDgiIWkIqKogAAAAAFKOgFTCkHk6gZyraBEL1oaY0A6LmFoEBh54/83sV7MGcJQAAss32gOihhx6yewlAztQ1Nr8BqXJAQGRCqroe9HwGAAAAgHxFBZF93G6XAmUlCoab1BBu0i6VZSk/Rn3InD/73193xFQ2NTCDCADgYLZfBU2aNMnuJQA5Y80gckCPZBNSmdAKAAAAAIqJqUBxaouyQucv8ygYbrIquVLV4PAKsEpmEAEA8oDb7gUAxaTWzCByQAWRaTFXS4s5AAAAAEUm0hRXJBaXREBkF/NzTzsgiji7AqynxwcAQC4QEAE5ZOb9mHDGTlXlzRertJgDAAAAUGzatv3ye51ZgVLoKnvYgi0Yyo+AiBZzAAAnIyACcqguZGYQ2X8Ba0KqOiqIAAAAABQZU9XhK3WrxMOfRuzQ0wqboNVizv731x2p9FFBBABwPq6CgBwyYUy1A1rMmTXU0Q8ZAAAAQJFxenuyYtDjFnNhZ59Dv5eACADgfAREQA6Zdm7OaDHXvIZ6KogAAAAAFJkGh1efFIOetJiLxxNqiMQkSQGfM88hLeYAAPmAgAjIoVozg8gBFUTMIAIAAABQrILh5nDBVHkg91oriGIpf6+pAJOcW0FEizkAQD4gIAJyqK6xZQaREyqIWtZQ2/j/t3ffYU6Uax/Hf0m2V3rvoAIi0gQUC4gIVuxdQWwgqKAH61HQo8euoCKe46tiASyoIM0jRUAURIoKgvRehYXtLcm8f+zO7C4s7IK7SWby/VwXF7vJJM8zm3ky5Z77fvJlGEaQewMAAAAAgRPq5cnCgRUgOoGy55mFQSWP26XoiNC8tFWUQXT8ATAAAAIlNPeigENZJeZig38SYmYx5fsM5eT7g9wbAAAAAAicDKvEnCfIPQlfZobNiZRgy8gtOLdOiI6Qy+Wq0H5VlITCbYsMIgBAKCNABARIvs+vrMIayckhUGIuPsojj7vgQJoycwAAAADCCXMQBV98VGEAJe9EAkSF8w+F8OdXfA4iqnYAAEIVASIgQNJzQqtGssvlUlLhHVtp2QSIAAAAAIQPSswF398rMRf6GWDmtuX1G8r1UrUDABCaCBABAWIGYRKiIxThCY2hZ5aZI4MIAAAAQDgxM1DIIAqev1NizrwBM5QDfPFRRX2jzBwAIFSFxlVqIAykFgaIzKydUJAUUxAgSiWDCAAAAEAYocRc8FkZRCcQPLHD5+d2uxRXWEbvRIJgAAAEAgEiIEDMLJ2kEJh/yJQUa5aY42AVAAAAQPgoKjEXuiXKnO5vBYjyQj+DSCrqX/oJlNEDACAQCBABAWIGYcysnVBg9oUScwAAAADCSYYNMlCcLjHa2SXmpKL+kUEEAAhVBIiAAAnJDCIzQESJOQAAAABhxC4ZKE4WbwVPfMf9WjuUmJOKrWMeASIAQGgiQAQEiBmEMcu6hYLkODODiINVAAAAAOEjozAoER8VOudn4cYMnuT5/Mr1Hl+QqKhEYGh/fpSYAwCEOgJEQIBYGUQhVWLOnIOIDCIAAAAA4cMuGShOVjy4c7xZROlmgCgmtD+/v5MlBQBAIBAgAgIkNTsES8wV9iWVABEAAACAMGKXDBQn87hdio30SDr+OXrsEuBLiD6x9QMAIFAIEAEBkpZdcECYFEJ3OFlzEOUQIAIAAAAQPjKsAIMnyD0Jb/EnWILNzMhJCPHPz8xwSidABAAIUQSIgAAxgzDJIZVBZJaY42AVAAAAQHgwDIMMohCRWBhAycw7vnNSM+AS6nNIFZWY45wbABCaCBABAZIWiiXmyCACAAAAEGZy8v3yGwU/h3qJMqczM7gyTrDEXKjPQZQQRYAIABDaCBABAZKWY5aYC50AkZnNlMYcRAAAAADChBmMcLmkuKjQLlHmdGYGUMZxl5izRwaYGYA83gAYAACBQoAICJBUK4ModA5gzWymtByvDMMIcm8AAAAAoPJlFitP5nK5gtyb8GaVmDvOAIoZUAr1DDAzw4kAEQAgVBEgAgLEKjEXQhlEZl98fkOZeb4g9wYAAAAAKp95sd4sb4bgOZEMG8MwrDmLEkM9QMQcRACAEEeACAiAnHyfcr1+SaE1B1FMpFuRnoI75igzBwAAACAcWBlEIR5cCAcnEiDKzvfZZg6povXjhkwAQGgiQAQEQHpOUY3rULrDyeVyWVlEaTkEiAAAAAA4n5l9Eurz14SDxBPIsMnIsc8cUglWgIjzbQBAaCJABASAGXxJjI6Q2x1aNa6TzXmIskl5BwAAAOB8ZjZHfBQBomA7kQwbM9sowQZzSBWVmCODCAAQmggQAQFgzT8UQuXlTIlWgIg7mgAAAAA4HyXmQseJlJgzgy12+PzMea6OZ/0AAAgkAkRAAKSaAaKY0AsQJcUUHFSnEiACAAAAEAbMAFFCdGiXJwsHJ1JiLr2wXFu8DT6/xOiCawB5Xr/yCuclBgAglBAgAgIgrbBGclJs6N3hZGY1MQcRAAAAgHCQQQZRyPg7GUQJIXgD5uGKB7GOJwgGAECgECACAiAtpDOImIMIAAAAQPgoyiAiQBRsVgm2nOMJENknAyzC41Z0RMGlN8rMAQBCEQEiIADM7JzkEJyDyMxqIoMIAAAAQDjIsNEcNk6XWFjyPDPveErMFWaARdnj8zMDkcezjgAABAoBIiAAzOycpBAMEJlBqzTmIAIAAAAQBjIpMRcy4k9gDiIrgyjGHp+f2c/jyZICACBQCBABAZBqhxJzZBABAAAACAN2KlHmdGYWUPoJlZizR4DIXEdKzAEAQhEBIiAAzOCLWc4tlJhZTalkEAEAAAAIAxlkEIUMs8Rcrtcvr89frteYwSS7fH5WibnC0oYAAIQSAkRAAKSFdAZR4RxE2dzNBAAAAMD5zLlg7BJgcLLin0F5Ayh2yyCySszlclMmACD0ECACAiCt8A6n5BCcg8jMIKLEHAAAAIBwYAYi7BJgcLJIj1tREQWXptLLGUAxA3x2+fzMIFgGGUQAgBBEgAgIgHQzgygUA0TmHESUmAMAAAAQBqwSc1H2CDA4XeJxlmCzX4m5grmuMpmDCAAQgggQAQEQynMQmVlN6ble+f1GkHsDAAAAAJXLbiXKnK4ow6Z8ARS7fX4Jx7l+AAAEEgEioJIZhqHUEJ6DyJwU1DCkjDwOWAEAAAA4l99vKCuvIFMlvjCzA8F1/AEie5UIPN71AwAgkAgQAZUsJ9+vfF9BZk4olpiLifQourDmc2oWZeYAAAAAOFdmsZvi7FKizOmKSsyVL4BilQi0SYAv4TjXDwCAQCJABFQys7ycx+1SfFRoHsCagSuzrwAAAADgRGb2SYTbZd0oh+AyAz3lzbAxlzOrYYQ6K4MohwARACD0cDQEVLI0q7xchFwuV5B7U7qkwgPrtGwOWAEAAAA4V1H2Seien4Wb4wmgGIZhZeLYJQOMOYgAAKGMABFQycysnFAsL2dKJoMIAAAAQBgwgwt2mb8mHJiZQOUpwZbr9cvrLyjhbrcAUSZz/gIAQhABIqCSpVoZRKEbILJKzGUTIAIAAADgXJk2m78mHMRHFWbYlCOAUjwLx3xdqIu35iDyBbknAAAciQARUMnMsm1JsaF78GoGr1IJEAEAAABwsAyblScLB8dTYs4M8MVFeeRx26NEoJlBlM4cRACAEESACKhkVom5kM4gKpyDiANWAAAAAA5mlvmixFzoOJ4Sc2aQxU4BPqvEHHMQAQBCEAEioJKZZduSQ3gOIjN4RYk5AAAAAE6WUVjmyy7lycKBlUFUjhJsZpAl0UYBIrOcYXa+T77C+ZMAAAgVBIiASmZm5SSFcoDInIMohwARAAAAAOfKpMRcyCkKEJV9PmpmgNnp80uIKeprBllEAIAQQ4AIqGRmVk5STOgewJrZTeZ8SQAAAADgRGaAKKEwqwPBl2iVYCs7g6ioxJx9Pr/oCI8iPQXzJVFmDgAQaggQAZUs1QwQhXIGUQwZRAAAAACcL4MMopATfxxz9JhBpITo0D2/Ls3xrCMAAIFEgAioZGbQxQzChKKk2IKDVeYgAgAAAOBklJgLPWY2UHq5AkT2zAAz57wqzzoCABBIBIiASmaWbTODMKHIyiAiQAQAAADAwYoyUEL3/CzcJBZmA5UnuybdpgG+xBgyiAAAoYkAEVDJzAyi5FAuMWfOQZTDwSoAAAAA56LEXOgxM4iy8nzy+Y1jLmtlEIXwHL+locQcACBUESACKpmZlRPSJeYKD64zcr3y+vxB7g0AAAAAVA67lihzsuLBusy8YwdQrM8vyp4BoozCDDYAAEIFASKgEhmGYWXlJNkgg0gquqMOAAAAAJyGDKLQEx3hVqTHJansDBvblpgzA0Q5lHUHAIQWAkRAJcosliIfyhlEkR634qIK7qAz50wCAAAAAKcxM1TsFmBwMpfLVe4SbPYtMVdwvp2ZRwYRACC0ECACKpFZXi7S41JMZGgPNzOAlZrNHU0AAAAAnCmzsMRXAgGikBJfWDIuvYx5cYtKBNrr8ysqMccNmQCA0BLaV6wBm0srTB9Pjo2Uy+UKcm+OLSm24IA1jZR3AAAAAA5FibnQlBhjZhAdO8PGDCDZ7fMrKjFHgAgAEFoIEAGVyCzXFsrl5UxmH9PIIAIAAADgQPk+v/K8fklSQpS9AgxOV94MG7NEoF0ziMoqoQcAQKARIAIqkRlsSYwN/QBRcmEfySACAAAA4ETFL86bc8IgNJQ7QGTTEoGUmAMAhCoCREAlMufzSbLBBJpJZoAomwNWAAAAAM5jXpyPjnArwsPlkFCSWM4MmwyrxJy9AnxmCT0CRACAUMMREVCJzGycJBtkEJlBrFRKzAEAAABwILtmn4QDM+BzrABKntevPF9BicDE6NA/xy4uPooScwCA0ESACKhEtpqDiBJzAAAAABzMDD7EEyAKOeUpwWbnEoGUmAMAhCoCREAlMoMtybbIIDJLzBEgAgAAAOA8mQSIQlZ5SszZuURgAgEiAECIstceFbAZM9iSFBv6JyBmH9NyOGAFAAAA4Dxm8CHBZtkn4aA8GTbmc4k2mOP3cAkxZgDMF+SeAABQEgEioBJZcxDZoMScmeVEBhEAAAAAJ6LEXOiyAkTHuGHRzhlgZkm8zDyvDMMIcm8AAChCgAioRKlWBlHoB4isEnPMQQQAAADAgewcYHA6MysoM+/oAaJ08/OLst/nZ5aYMwwpK48sIgBA6CBABFSitOyCA9gkG6TAm0GsVDKIAAAAADhQZuGF+QQbBhiczgz6ZByjBJtVItAG59eHi430yO0q+Jl5iAAAoYQAEVCJrBJzdsogyuZgFQAAAIDzUGIudBWVmDv6DYtFc0jZ7/NzuVzlmmcJAIBAI0AEVCJzPp9kOwSIYgsOVrPzfcrz+oPcGwAAAACoWEUBBk+Qe4LDWSXmjpFBlJ5j7wCfGdjKJEAEAAghBIiASuL3G1aNZDM7J5QlFutjOvMQAQAAAHAYMohCV3w5gidm8MiOGURSUb8zcggQAQBCBwEioJKk53plGAU/J9qgRrLH7VJi4QFrGgesAAAAABwmkwBRyIovzOrKyPPKME+kD5OZZ+8MMErMAQBCEQEioJKY5eWiI9yKibTHAaw5V5LZdwAAAABwCrtnoDiZ+ZkYhpSVV3qZOceUmMsjQAQACB0EiIBKklZYpi3JBvMPmcxMp1QCRAAAAAAchhJzoSs20iO3q+Dno5WZK5pDyp6fn5UlRcUOAEAIIUAEVJK07IKDvmQbBYisDCLmIAIAAADgMEUl5uxR4SGcuFwuK3CX7tAAUUJ0wfl2Rm7pGVIAAAQDASKgklgZRDaYf8iUFGOWmOOOJgAAAADOYvcAg9NZJdiOEiBKt3kGmDl30tHWDwCAYCBABFQScx4fO5WYSyaDCAAAAIBDUWIutJkBooyyMohsdBNmcfFlrB8AAMFAgAioJOY8PmZWjh0kxRYcsKYxBxEAAAAABzEMQ5l5BaW9yCAKTVYA5Shz9Ng9A8wMbBEgAgCEEgJEQCVJKzyoNYMudmAGs1IJEAEAAABwkFyvXz6/IYkMolBllZjLKz2AYmWARdnz8yurhB4AAMFAgAioJGm2zCAyS8xxwAoAAADAOYpnbcRFeoLYExxNUYk5X6nPm59hol1LzEWRQQQACD0EiIBKYs7jk2yjOYiSYigxBwAAAMB5Mq3sE4/cbleQe4PSHKvEnNfnV06+v8RydkOJOQBAKCJABFSStGyzxJyNAkRWBhEBIgAAAADOYZUns2lwIRwkRBdkdpVWgi2zWFZRfLQ9M8AoMQcACEUEiIBKYscSc2a2ExlEAAAAAJzEDDAkECAKWcfKsMkonJcoyuNWdIQ9A0TxVoCo9BJ6AAAEAwEioJKYWThJsfY5ATGDWcxBBAAAAMBJMskgCnlWiblSM4jMz8+ewSGpKEMqnYodAIAQQoAIqCR2zCAyg1mpZBABAAAAcJAMBwQYnO5YJdjSc+wf4EuILrg2kJnnk2EYQe4NAAAFCBABlcTMwkm24RxEeV6/cvJJewcAAADgDGbQgRJzoSuhHBlEdv78zOCkz28o1+sPcm8AAChAgAioBF6f3zqoTbJRgCghKkIuV8HPaaS9AwAAAHCIDErMhbzylJizdYAoqqjv6ZR1BwCECAJEQCUofkCbGGOfA1i326XEwgPutGwOWAEAAAA4Q2ZuQYUEAkSh65gl5hwQ4HO7XYqPKsgiKm0dAQAIBgJEQCUw5/CJi/Io0mOvYZYcV5DxRAYRAAAAAKfIzLN/BorTFQWIjix3bmUQ2egGzNIcK0sKAIBgsNeVa8AmzOybpBj7lJczmX1OyyZABAAAAMAZrBJzUfYOMDiZGTxJL+VmRStAZPPP71hZUgAABAMBIqASmNk3SbH2O3g1A0SpBIgAAAAAOESmVaLME+Se4Gis4EmeT4ZhlHjOCSXmpKIMKDKIAAChggARUAnM7JvkWBtmEBUGtdKYNBMAAACAQ1gZKDYPMDiZGTzx+Q3lev0lnnNMibkoAkQAgNBCgAioBFYGESXmAAAAACDoMhySgeJkcZFF2V3ph92waM5LlGDzDLD4Y8yzBABAMBAgAiqBWZ4tyZYZRIUBolLqPgMAAACAHRUFGAgQhSq326X4qIIA0OFz9JgBI7sH+MwAV0Yu59sAgNBAgAioBGnZBQevSTZMfzfL4pnrAAAAAAB2l0kGkS0cbY4ep5QILFo/MogAAKGBABFQCawSc3bMICo8YKXEHAAAAACnKCoxZ+8SZU5nBvCOCBDlOSNAVFRijhsyAQChgQARUAnM4EqyHQNElJgDAAAA4DBOyUBxuoSjBFAynFJiLqowAJZDgAgAEBoIEAGVIC3HLDFnwwBRjFlijgARAAAAAPvz+w1l5hWU9LJ7gMHpEo6SQZThkACfVWIujwARACA0ECACKoEZXEmKtd/Ba1EGEQesAAAAAOwvK79ovhe7BxicrqgEW8k5epySAUaJOQBAqCFABFSCVDNAZMMMIrMsHhlEAAAAAJzAvBjvcbsUHcFlkFBWlEFUdD7qpAywo5XQAwAgWDgyAiqBOX9Pki3nICo4YE3LyZdhGEHuDQAAAAD8PWZ5svgoj1wuV5B7g2MpChAVZRBlFivHlhjjjABROhU7AAAhggARUAnSsu0/B1G+z1B2vq+MpQEAAAAgtDmlPFk4KK0Em1luzgkZYNb6MQcRACBE2HvPCoSgPK/fCqwk2zCDKC7KI4+74K46M9AFAAAAAHZlZRARIAp5CdEeSVJGsQwbs9ycEzLAEo4yxxIAAMFCgAioYOk5RbWSE2yY/u5yuZQUU1RmDgAAAADszLwYT4Ao9Fkl5vKKB4gKPr9EG1boOFx8KQEwAACCiQARUMFSswuCKonREVYmjt2YcyelZRMgAgAAAGBvlJizj9JLzJkZYJ6g9KkiJUYXnGvn+fzK8/qD3BsAAAgQARUurfBOoCQblpczmaXxyCACAAAAYHcZDgowOJ2VQVQswyY9xzklAotvg8WDYAAABAsBIqCCmVk3iTYsL2dKijEziDhgBQAAAGBvmcxBZBtmmfaMUjKInJABFuFxKzqi4FJcBgEiAEAIIEAEVDAz6ybZxhlESbEFB96plJgDAAAAYHNOCjA4nVVirtgcRObPTvn8EksJggEAECwEiIAKZmbd2LnEXFEGEQEiAAAAAPaWkeuTRAaRHTi9xJxU+jxLAAAECwEioIKZGURmkMWOkpiDCAAAAIBDkEFkHwlW8MRnPea0zy8+qmA90gkQAQBCAAEioIKZZdnMMm12lFSY8s4cRAAAAADsLqOwRFl8lCfIPUFZzOyaPJ9fud6CIJHTAkTmPEtkEAEAQgEBIqCCmWXZ7JxBlEwGEQAAAACHMC/EO6VEmZMVD+KZWUTpDvv8EigxBwAIIQSIgAqWluOAOYgK+57KHEQAAAAAbM5pGShOFuFxKzayIEhkfm7W5xfjjM/PDHRlFCujBwBAsBAgAiqYmUGUbOcAUQwZRAAAAACcwbwQ75QMFKcrCqCYAaKCzy8h2hklAs1AZUYOGUQAgOALuwDR888/rzPOOEOJiYmqVauWrrjiCq1du7bEMjk5ORo8eLCqV6+uhIQEXX311dq7d2+JZbZt26ZLLrlEcXFxqlWrloYPHy6vt+TOfd68eerQoYOio6PVokULjRs37oj+jBkzRk2aNFFMTIy6dOmiJUuWVPg6I7DMoEqSje9uMudPYg4iAAAAAHZHiTl7MQNBZoDIKjEX5YzPz1y/zDzOtwEAwRd2AaL58+dr8ODBWrx4sWbNmqX8/HxdeOGFyszMtJYZNmyYpk6dqi+++ELz58/Xrl27dNVVV1nP+3w+XXLJJcrLy9NPP/2kDz/8UOPGjdNTTz1lLbN582Zdcskl6tGjh3799VcNHTpUd955p/73v/9Zy3z22Wd68MEHNWLECC1fvlynn366evfurX379gXmj4FKYc1BRAYRAAAAAAQdJebsxSwll+H4EnMEiAAAweeMvetx+Pbbb0v8Pm7cONWqVUvLli3Tueeeq9TUVL333nuaMGGCzj//fEnSBx98oFatWmnx4sXq2rWrvvvuO61evVqzZ89W7dq11a5dO/3rX//SI488opEjRyoqKkrvvPOOmjZtqldffVWS1KpVKy1cuFCvv/66evfuLUl67bXXdNddd+n222+XJL3zzjuaPn263n//fT366KMB/KugIqUWZt2YQRY7MsvjpWXnyzAMuVyuIPcIAAAAAE5MhpVB5IwSZU5nZgodMQeRQwJ8lJgDAIQSZ+xd/4bU1FRJUrVq1SRJy5YtU35+vi644AJrmZYtW6pRo0ZatGiRunbtqkWLFum0005T7dq1rWV69+6tQYMG6Y8//lD79u21aNGiEu9hLjN06FBJUl5enpYtW6bHHnvMet7tduuCCy7QokWLSu1rbm6ucnNzrd/T0tIkSfn5+crPJ9MjVJhZN3GRqrTPxXzfynr/wgpz8hvSocwcxxyIA4FW2WMVQMVgrAKhj3GKE+X1+ZXr9UuSot1sQ5WtIsZqXFRBsZvUzFzl5+crvTCQ4pTPLzai4AbM9Jw8R6yPk7CvAeyBsVq24/nbhPVVX7/fr6FDh6pbt25q06aNJGnPnj2KiopSlSpVSixbu3Zt7dmzx1qmeHDIfN587ljLpKWlKTs7WwcPHpTP5yt1mT///LPU/j7//PN6+umnj3j8u+++U1xcXDnXGpUp3y/leQuG1eIF31uBlsoya9asSnlfw5A8Lo98hkuTZ3ynatGV0gwQNiprrAKoWIxVIPQxTnG8srySeenjh7mz5Am7QvvB8XfGatoBtyS3fvl1peL3/q7MXI8kl37+cb7+jKqwLgbNuv0uSR5t3/2XZsyYEezuoBTsawB7YKweXVZWVrmXDesA0eDBg7Vq1SotXLgw2F0pl8cee0wPPvig9XtaWpoaNmyoCy+8UElJSUHsGUx/pedKP8+X2yVdeelFcrsrpzRbfn6+Zs2apV69eikysnJK2f1r5TwdyMxTpzPPUcs6iZXSBuB0gRirAP4+xioQ+hinOFG7DmVLv/ygqAi3Lrv04mB3x/EqYqwu+ma1lu3foUbNT1aPbo1lLJ4rSbr8ogut+XvsLG7dX/pw/QpFxSfp4ovPDHZ3UAz7GsAeGKtlMyuPlYf996wnaMiQIZo2bZoWLFigBg0aWI/XqVNHeXl5OnToUIksor1796pOnTrWMkuWLCnxfnv37rWeM/83Hyu+TFJSkmJjY+XxeOTxeEpdxnyPw0VHRys6+shUjsjISAZDiMjyFpQATIyJVHR05d/aVJmffXJspA5k5ikr32D7Av4mvqcBe2CsAqGPcYrjlevPkVQw7wvbTuD8nbGaFFtwLp2d71eur+CmS5dLSo6PccT8uFXiYyRJWXk+tskQxb4GsAfG6tEdz98l7JKrDcPQkCFD9PXXX2vu3Llq2rRpiec7duyoyMhIzZkzx3ps7dq12rZtm848s+DOjjPPPFMrV67Uvn37rGVmzZqlpKQktW7d2lqm+HuYy5jvERUVpY4dO5ZYxu/3a86cOdYysJ/U7IL6jkmVXVsuABJjC75I0pg4EwAAAIBNZeQWnM/ER3uC3BOUlzkHbkauz/r8EqIiHBEckqT4qKL1AwAg2Ox/Ffs4DR48WBMmTNCUKVOUmJhozRmUnJys2NhYJScn64477tCDDz6oatWqKSkpSffdd5/OPPNMde3aVZJ04YUXqnXr1rr11lv10ksvac+ePfrnP/+pwYMHWxk+AwcO1FtvvaWHH35YAwYM0Ny5c/X5559r+vTpVl8efPBB9evXT506dVLnzp01atQoZWZm6vbbbw/8HwYVIi2nMEAUY//odbIZIMpmwjcAAAAA9pRpBoiiwu7yh22ZZeQyc73KLAyiOKG0nCmh2PoBABBsztnDltPYsWMlSd27dy/x+AcffKD+/ftLkl5//XW53W5dffXVys3NVe/evfX2229by3o8Hk2bNk2DBg3SmWeeqfj4ePXr10/PPPOMtUzTpk01ffp0DRs2TKNHj1aDBg30f//3f+rdu7e1zPXXX6+//vpLTz31lPbs2aN27drp22+/Ve3atSvvD4BKZQZTnBAgSoop+Howg14AAAAAYDfmRfgEBwUYnC6hMNsrI9er9NyC81EnZYAlFJ5rZ+f75PX5FeEJu+I+AIAQEnZHSIZhlLlMTEyMxowZozFjxhx1mcaNG2vGjBnHfJ/u3btrxYoVx1xmyJAhGjJkSJl9Qvn5/IaWbE7RvvQc1UqMUeem1eRxByYV3SzHZmbf2FlS4TqkkkEEAAAAwKYyHJiB4nQJ0QXnohnFMogSHHATpql4sCszz6fkWAJEAIDg4QgJjvLtqt16eupq7U7NsR6rmxyjEZe1Vp82dSu9/TQHzUFkZkGlZZP2DgAAAMCeyCCyHzOAUlBizvz8nJNBFB3hUaTHpXyfocxcryNuMAUA2Be3KcAxvl21W4M+WV4iOCRJe1JzNOiT5fp21e5K74OT5iAyg1yUmAMAAABgVxnmHEQOCjA4nRnMKygx58w5pOKLrSMAAMFEgAiO4PMbenrqapVWQNB87Ompq+Xzl11i8O8oyiByQIDIyiAiQAQAAADAnjKtAJGzAgxOZs7RUyKDKMZZn18CASIAQIggQARHWLI55YjMoeIMSbtTc7Rkc0ql9sMsx5bkgINXM82dDCIAAAAAdkWJOfsxs4UySpSYc9bnZ65PJgEiAECQESCCI+xLP3pw6ESWO1FWiTknZBAVrkMqcxABAAAAsKmMXJ8kMojsxAye5OT7dSir4BzbaZ+fVWIuh/NtAEBwESCCI9RKjKnQ5U6UWY7NCZNMmllQlJgDAAAAYFeUmLOf4p+VeZOnUzOIKDEHAAg2AkRwhM5Nq6lucoxcx1imbnKMOjetVqn9SCu8+8dJGUSUmAMAAABgV5l5ZokyT5B7gvKKinArKqLgctWetFxJzg0QUWIOABBsBIjgCB63SyMuay1JRw0SjbistTzuY4WQ/r7UwmybpBgHBIgK1yEj1yu/3whybwAAAADg+JkZGua8NrAHM4Cyt3CuYadlgMUXBizJIAIABBsBIjhGnzZ1NfaWDqqTfGQZOZdLqpkYXantG4ZhlWNLirX/wau5DoYhpXPQCgAAAMCGzAwNp2WgOJ35ef2V4dQMIvOGTF+QewIACHfO2sMi7PVpU1e9WtfRks0p2peeo1qJMfrsl22a/OsuPfDpr5rxwDmVlt2Tne+TtzDTxgkZRNERHsVEupWT71dadr4j5lUCAAAAEF4yCy/AOy0DxenMz8tXeI7tvABRQQYRJeYAAMHmrD0soIJyc2c2r2793qZ+kpZtO6jtKdl6avIqjbqhfaW0m5ZdcGAX4XYpLsoZ9a2TYiKVk5+r1Ox8NQx2ZwAAAADgOFkl5hwWYHC6w+eMinfYHFLxzEEEAAgRlJiD4yXGRGrU9e3lcbs0+dddmrxiZ6W0k5ZjlpeLlMtVuXMdBUpSYdaQuW4AAAAAYBeGYVBizqYO/7wSY5z1+ZkBIsq5AwCCjQARwkLHxlV1//knSZL+OXmVtqdkVXgb1vxDDjpwNdfFzI4CAAAAALvI9fqtMuBOy0BxusMzvpyWAWYGvMggAgAEGwEihI3BPZqrU+Oqysj16oFPV8jr81fo+6dmF2UQOQUZRAAAAADsqvjF9/goZwUYnO7wDCKnBYjM7ZEAEQAg2AgQIWxEeNx6/fp2SoyO0PJth/Tm3A0V+v5WibkY5wSIks0AUTYBIgAAAAD2kpnrkyTFRXnkdjujDHi4OCJA5LAAHyXmAAChggARwkrDanF69so2kqQ3567X0i0pFfbeZhm2pFjnHLiawa60HA5aAQAAANhLRuHFd6dln4SD4p9ZXJRHHocF+CgxBwAIFQSIEHb6tquvq9rXl9+QHvj01worn2Zm2SQ7qsScOQcRGUQAAAAA7CUzr+Di++HZKAh9xT8zJwb4zHUys9wAAAgWAkQIS0/3PVWNqsVp56FsPTl5VYW8pxNLzFkZRASIAAAAANhMUQaRJ8g9wfFKiCkKCiU6MkBUsE1m5Hrl9xtB7g0AIJwRIEJYSoyJ1Kgb2snjdmnKr7v09Yodf/s9UwuDKEmOyiAyS8wRIAIAAABgL2b5LqfNXxMO4h2eQZQYXXTdICufLCIAQPAQIELY6tCoqh7oeZIk6cnJf2jbgay/9X7WHEQxzjl4Lcogoi4yAAAAAHsxA0SUmLOfhGJZX07MAIuJdMucVol5iAAAwUSACGFtcI8WOqNJVWXkejX0sxXy+vwn/F5WiTkHZRAlk0EEAAAAwKYyCud3cWIGitMlFMuwKf6zU7hcLmu7zCBABAAIIgJECGset0uvX99OiTERWr7tkN6Yu+GE38uJAaKk2IID1lTmIAIAAABgM1aJOQJEtlM8ayjBgRlEUlFmW0YOASIAQPAQIELYa1A1Tv++8jRJ0ltz1+uXLSkn9D5FJeYcFCCySswRIAIAAABgL0Ul5pwZYHCyBIfPQSQVrSMl5gAAwUSACJB02en1dHWHBvIb0tBPfz2hjBkzgyg51jkHr2Y2VGae72+V3wMAAACAQMsgg8i2igeIEhw0z29xlJgDAIQCAkRAoaf7nqrG1eO081C2/jl5lQzDKPdr/X7DyrJxUgZRYrED8XTS3gEAAADYSFEGkTMDDE4WG1mU9ZWSkSefv/zn53aRQIAIABACCBABhRKiIzTq+nbyuF2a+tsufbV8Z7lfm5nnlXm86qQ5iCI9bsVHFRyYmxlSAAAAAGAHGbk+SWQQ2c23q3br/FfnWb9/sWyHzn5xrr5dtTt4naoE5jxLP208oEUbDzgyCAYACH0EiIBi2jeqqmEXnCRJemrKKm09kFmu16UVZtdEedyKjnDWsDIDXuYcSwAAAABgB5mUmLOdb1ft1qBPlmtPWm6Jx/ek5mjQJ8sdEyT6dtVuLVj3lyRp0rIduvHdxY4MggEAQp+zrmQDFWBQ9xbq3LSaMvN8euDTX5Vfjrl3rPJysZFyuVyV3cWAMkvmnci8TAAAAAAQLJl5Zok5TxlLIhT4/IaenrpapeXRmI89PXW17TNtzCBYdn7Jaw1OC4IBAOyBABFwGI/bpdevb6ekmAj9uv2Q3pizvszXFAWInHdnmrlOlJgDAAAAYCfm3C7xUc47T3OiJZtTtDs156jPG5J2p+ZoyeaUwHWqgoVLEAwAYB8EiIBS1K8Sq39fdZokacz3G8o8ADWza8xsGycx1ymNDCIAAAAANkKJOXvZl3704NCJLBeKwiEIBgCwFwJEwFFc2raerunYQH5DGvbZr8cssWbOQWTO1+Mk1hxEZBABAAAAsJHMXJ8kKYEAkS3USoyp0OVCUTgEwQAA9kKACDiGkZefqsbV47TzULae+HqlDKP0NG+rxFyM8048ks0AUbY3yD0BAAAAgPIxDMOag4gMInvo3LSa6ibH6Giz+rok1U2OUeem1QLZrQpV3uDWnDX7dCAjt5J7AwAAASLgmBKiIzT6hvaKcLs07ffd+nL5zlKXM7Nrkp2YQRTDHEQAAAAA7CUrzyfz/j4yiOzB43ZpxGWtJemIIJH5+4jLWsvjPloIKfSVFQQzffPbLnV7ca7+NW219qaRTQQAqDwEiIAytGtYRcN6nSxJGjFllbbszzxiGTO7xskl5o5VYg8AAAAAQok5/5DbJcVEcunDLvq0qauxt3RQneSSmTZ1kmM09pYO6tOmbpB6VjHKEwQbdF4ztW2QrJx8v95buFnnvPS9npy8SjsOZgW0rwCA8MBtNEA5DDyvuRas+0s/b07RA5/9qkkDz1Skp+gkw8yuSYpxYIAoxiwxR4AIAAAAgD1k5BaVl3O57JtxEo76tKmrXq3raMnmFO1Lz1GtxIKycnbOHCrODII9PXW1dqcWZQfVSY7RiMtaq0+bujIMQwvW79ebc9Zr6daD+njxVk1csk1Xdaive7u3UJMa8UFcAwCAkxAgAsrB43bp9evbqc+oBfpt+yGNnr1e/+h9ivW8mV2TFOu8IWWuU1oOcxABAAAAsIfMXJ8kysvZlcft0pnNqwe7G5WmrCCYy+XSeSfX1Lkn1dDPm1P05tz1+nHDAX2+dIcmLduhy0+vp8E9Wuik2olBXhMACB6f39DSjQcceTNBIHGkBJRTvSqxev6qtho8YbnGzNugc06qoS7NCg5YzewaMogAAAAAIPiKZxABoag8QTCXy6Wuzaqra7PqWrb1oMZ8v0Fz/9ynyb/u0pTfdqnPqXU0uEcLtamfHKBeA0Do6D1qgbYezLV+r1ssExPlx5EScBwuaVtX89Y20BfLdmjYZ79q5gPnKjku0squcfIcRGYZvcrm8xsBLyUQ6DZpz97tBaNN2qO9UG+T9uzdXjDapD3aO5E2JWnGyt2qlRzvuHWkvYqXXnj+ku/1a9HGA9xVDNvr2Liq3u9/hlbtTNVbczfo2z/2aOaqgn89W9bSkPNbqH2jqsHuJgBUutlr9kqS9qTlqPiMbntSczTok+WOmLMukAgQAcdp5OWn6pctKdpyIEuPT16p0de301/pBXWDtx3Iks9vOOrEwyzJkJKZV+knVt+u2n1EHebKjv4Huk3as3d7wWiT9mgv1NukPXu3F4w2aY/2TqTN56f/oQdbSg9/+btyfS5HrSPtVbxvV+3Wo1+ulCRtTcnSje8u5q5iOEab+sl659aOWrc3XWO+36Cpv+3SnD/3ac6f+3R2ixq67/wWVrWT4oIRqEXF4jNEqAvENurzG3ph5p96sKVkGCWfM1QQLnp66mr1al2H8VFOLsM4/E8Ju0hLS1NycrJSU1OVlJQU7O6Eld+2H9LVY3+S128oOTZCqdlF8/ME4sQjPz9fM2bM0MUXX6zIyMrLWvp21W6N+OYP7U2r/HTNb1ft1qBPluvwLyTzq7wyov+BbpP27N3eibT5d8eq0/+mtBf8bZT2ChxtrDpl/UKpTdqjvRNtM8pj6KXOPj28xKNcn8sx60h79v9eQ0mBOldFkU1/ZWjsvI36esVOeQuzLTs3qaYh57fQOSfVkMvlCkqg1o6Zisez/QZ6/fgMaS/U26uMbdTvN/RXRq62p2Rp+8EsbU/J1vKtBzV/3T5VjZZScqXiGUTFTbyrq6PnsivL8cQNCBDZGAGi4Br66QpN/nXXEY8H4sQjEAfdgTyx8vkNnf3i3BI7kcPbrJMco4WPnF9hO7NAt1lR7RmGIb8hef1++fyGvH5DPl/h/37DejzP69eN7y7W/oy8o75XzYQoTRp0lqIi3IpwuxXhdinC41KE2y2P26VIj0suV/nW3a5/z8pu8++MVaf/TWkvNLZR2itQ2lh10vqFSpu0R3t/p83owwJEldGm0/+mTm8vWG2iJAJEwbM9JUv/WbBRn/+yQ3k+vyTp9IZV1K15Nb09b9MRy1d2oNaOmYrl3X6DsX7BCLbb8TOkveC1dyLbqGEYOpiVXyIAtONglrYfzNaOlCztOJStPK//hPo0+oZ26tuu/gm91gkIEIUJAkTB4/Mb6vbCHO0plllTXGWfeFT2QfeJnlj5/Iay833Kziv8l+9TVp636LF8n7LyfMop/N98bPP+TM1avbfMfp1UK0GJMRElghbmT+ZD1v2krtKfN5dJzc7X6t1pZbbZum6SkmILyuyZ35bWl6b1u1Hi+eLLmF+x6Tlerd+XUWZ7NROiFeFxFQV8fMUCQYX/B5LbJUV4CoNHbleJnz0elyILg0l5Xr+2pmSV+X6n1ktScuG8VkemApd8oLRUYVNadr7+3JNeZnut6iYqKSbyiO3D+v0oj5vMbc0l6VBWnn7bkVpmm+0bVlHV+ChJkt/v1759+1SrVi253e4yX1vcwcw8rdh+qMzl2tZPVnJc0d/UkFG0rRolt09DKrHdFt+m07Lzy7WNNq0Rr7goT8n3VNG2bhzl/Q3DKDF2svJ8hfWCj61afJQi3K6i9yhs02/+XNpjKgikqtjP5nNliSwMkrpdktvlktvtKv1nl0tud7GfSzzuUnaeV1sOlD0mWtYp2EYrQlpO+cZFRbUZqu2dUjtRiTFFVZRL+9gPP/z1G4YOHTykKlWrWOM+PcerDeUYE4fvm4623yn+ZGn7rvLulyrqe1Qq/3fpSbUSrEnejWJvbOgoY76U7wZJysz1avvB7DLba1gtTvGF3zMul6vE36v438zlKna/4OHLqfz73rK2mdJOl0rbrsq7zZxcO8EaEwV9dZXYNo5Yx8N+N6Vm5+v3cuyXTm+QrOS4qFLXpfjnV+L3Uh5Py8nXmt3lHPPF5uU8/Ej4iH3tYUscvo5/7EorXM7QScmG1qe6ZBz2mjb1k1WlAuYCPZSdr1U7y/6bmuMwUGOwov6mxf+exxLo47Vg7AvD/a7iykSAKPj2pObovws2acKSrcrJP/aF1cq4dmHnTMXybL+BXr9gBL7t/BnSXuhto5JUIyFK/7qijXYezNaOg4VBoMJgUGae75jv73EXlBZuWDVODarGSpK+Xr5dg1v7NHaNR3n+0rf7cN/XH0/cgDmIgBOwZHPKUYNDUsGJ0e7UHC3ZnGLLL6Mlm1OO+cVurt85L86VIVmBnxON6pdXeS7yVLTyXKyrSH9lHH27KkukxyWPu+Ditt8wlFXGTlaSojxuGTKU7yv9yrnfkPK8fh09D+n4lOeiREUqz4WsinZkUMet1Yf2V1p7v5fjQlZF2rw/M6DtpWRW1NZXPvk+Q/m+ssdORSnPRSy7txno9tbuPdH2XFLG8Y+nQO+bAv09KgV+HbeX44aDinTi28yJWbc3sH/P8tzcUJEqa8wbcmldaukXAMoT1KlIgR6Hgf4edfr6SdK+9LJvUgHsqk5yjJ66rLXu7dFcz0xdrW9+O7Lyick8t79/4go1qBp75A1R5o1Q7qKfPe6CShNH/FwYjX5+5prSb9Ap/P/RL1cq32fI7XIVuwmi8P+iOz+s1x25TNFNOX7D0GNfrTxme499tVKewv5bz5XyAkOSz+vVyhSXotfsk9vjOWIZn2Ho8TLae+TLlUrP8Vo3uPn8Ba8r+Lnw5jW/IZ9hyG8Y8hc+5vMXLlP4GnP5nYeyy3V9ZuinK9SwWpz1mXhcLnncBZ+dp9iNbJ7Cz838TD3m44U3v0nSiG/++Nt/0/LcpFXev+ljX60s3M5cR2wrR9wsXPBL8f+O2GbKau/xr1YqNtIjd2HArax1O+IGnGI/+/3l20YjPG5rDP0dvnKMiUe/Wqk8r2Hd4OUv3Nasnwsr1xTfZo3C7dXnN2++LPp5e0rWMbdRSdqfkadBnyw/6vO1k6LVoGqcGlaNVcNqcVYwqGG1ONVJjlGkp+iGW5/f0JJNf6lZUuYRN8lIRUHTzk2rlf0HgyQCRMAJKe8JhV1PPMrb713H2AHERnoUF+VRTOH/sVEe67GCnyMUG+VWXFSE9mfk6qvlO8ts76FeJ+vkOonW70X74MMzF3TY78YRr1m3N11vzt1QZpv3n99CJ9VOPHoGSuFyZR3Irt2TrldnrSuzvX/1baP2jaoUBnqKAj4eT/Hfiz1e+Lv7sDuFFm08oBvfXVxmex8O6GwFMc0Sdd7iJet8fnn9RuFjRT/7/IbyC8vZ5fv8WrkjVc/P/LPM9u4r/HsWV9ohUFl3wq7bm67Rc9aX2d7955+kk2onSCp5kHa8d1BLBRdI35m/scw27zm3mZrXKmjT5/Pp999/V9u2beUp5QTjWDbuy9B/FhxZCuJw93ZvrpNqJ5SSHVV0EFza3edFjxc8sG5vul4rxzb6SJ9T1Kpu0jHfv/hwKN6v4gfof+xK1dNTV5fZ3r+vPE2nN0y2TiBdKjgBNfte8HPh/8XutjezDszXLd96UIPGH/2A1PTmje3VrmGVgpO1wgNk86SttANns+xjwYFzwXM+v6E/dqXpxW/LHhNDe55U4nvt71i3J12jyjEuKqrNUG1v2AUn65Q6CcUeOXp2gvmsz+fTsmXL1LFjR0VEFBwe/7knTa9+V/aYKL5vOny/VPyxo+2bjne/NKRHiyP+nuX5Hi1YruSD6/eW72/6YK+T1bJO4jGzeUpmwByezVPw25rdaXpuxpoy23v84lZqVbfob2peYJGOkQlZynJrd6frtdllf4Ylt5myt5eSzxc9Ut5t5sELzG2mKAOyaB2MYj+X3F8dnq21fm+GxpZjvzTovOZqUSvhiAspBevjOuKx4utV/HNctydDb8wte3t5oOdJOrnYvv7wjJPi61LisSOWMbR+b4be+r5gXES4DN3Y3K+JG93yGiU7PKRHC2t//3cUb+9YynM8U54xWN7jmRP5m5Z2YWjdnvQKWz+p4o7XgrEvrJUYUyHtAaGsRkK0eraqdcwAkWn6yt0B6FGBQ9n5um/iioC1dzArX3d9tOw4XuHR/6399YTbS83O1/BJv5/w60/U1N8D9xke/9/077d3z8eBay8lK1/9PvglYO0dzMrXnR8uDVh7h7Lydf+ngRuDpobVYtW2fhU1qBZbIgBUv0qsYiLLf73E43bp0YtaKm/zsiOPvwr/H3FZa0rJHgcCRMAJKO8JhV1PPMrb7ycvba0zmlRVbGRB0CcuKkKxkR7FRLrLPXeNVHAxddHGA9qTmlPqyawZ/b+3R4sKrU8+admOMtt84IKTK6TNnq1qa8KSbWW2d1OXRhXSXuem1VQ3OabM9orfUeFxu+RxexR9AnuGLk2ra9xPW8psb2gF/T37+Ovo86Xby/H5nVSh28yUX3eW2ebDfVqWmIMobs9vurhD/ROag+ib33aV2d5DF55SIevYq3VtTSzHNnr3uc0rpL2Ojavqvws2ldne9Wc0rJD2Ljy1TrnGxMWn1a2Q9rq1qKGPFpU9Ju7rWXHbaO9T6+izcoyLimozVNsbcv7x7yvy8/OVt9nQBa1qWWP1/Ja1NOHnssdERe2byrtfGtarYr5HC9os3990cAWt45nNq+v9HzeX2d4dZzetkPYuaFVbE38p+zM8kW2mNOXdZgZXUHs+v6HJ5dgv/aN3xewnfG0MfbGs7O3l/gr8XvP5DX25vGBceNxSp5qGPt8seX0l26yocVG8vVA6nqmov6nvtNBcv2DsC7mrGOGivOf2l7atq7rJMSUyWfxGUeaLvzALpvgNUebP5k1UfkPanZpdrizE5jXjVT0huuCXo92sV7hsiZtEDnv+UGZeuUqdN6oWp6pxxc7HDrteYf5mGIYOHTqkqsXKDhd/PiUzr9xlpOsmx5TI5ilenrrgcRVm+RQu4y6ZuWX+vjs1p1xBvovb1FGtpJgSWUiHZyr5zOylws/P/OzMx/2GoX1pOdrwV9lVI0r8TY/y97R+P8YNN+X9mzapHqcqZslc88HDto1iDx315s/U7DztPFT2TdH1q8QoKTbqqP22HjviJpuSvx/KyteO8pRYrhprrd/fcSgrr1wlnVvUjFetpBjrhkozI+yYJdWPkkm4Ly1X35Vj2oiXrj69wqosXdCqtmZslmonxWjrwaJKPHUqcZ4lJyNABJyAE7n4biflXb/+ZzWpkJM5j9ulEZe11qBPlsulkjv3yor+B7pN2rN3e8Fok/ZoL9TbpD17txeMNmmP9v5um8U5YR1pz/7fa0CoK++5/egb2lfIuChvJYtnrzitQi4Ul7e9F69uW672iuYg6lLqDX7lbW/EZadW2IVwn9/QL1tSyvwM37ypQ0A/w/L+TSuqveevCmx7r1zbLqDtvXRNxQRPytvevypoDEpFcxAF4xrp/4aeqxU70rUvPUe1EgvaYB9//I5vxmwAkopOPKRS7owo/N/OJx7BWL8+bepq7C0dVCe55B1OdZJjKnwCvWC1SXv2bi8YbdIe7YV6m7Rn7/aC0Sbt0d6Jtlk7yZnrSHv2/14DQlmgz+3NgNTR3s0lqW4FXih2ensSnyHthXZ7UnCvkXrcLp3ZvLr6tquvM5tXt+112GBzGaXNEAZbSEtLU3JyslJTU5WUlBTs7oSlb1ft1tNTV5eYjK1uANIZi+5qufi4y1Ydj2Csn89vaMnmlIBG/wPdJu3Zu73jabOixqrT/6a0Z/827d5eWWPV7usXim3SHu0dr5zcPP3v25lSw/aqlRzvuHWkPWe0icCdq+L4BPLc/ttVu63J6EvL4qvoQG1Ftlee7TfQ61e8XT5D2gvF9oq3G6htlH1N2Y4nbkCAyMYIEIWGYJx4BPKLkBMr4MRx0ALYA2MVCH2MU8AeGKuhK5Dn9oG+2bSi2ivv9husm4X5DGkvVNszBWobZV9TtuOJGzAHEfA3memMTuX09QMAAAAAwOkCeW7fp01d9WpdJ2DBDKe3Z+IzpL1Qbc/ENUR7IkAEAAAAAAAAoMIE+kKx09sLBqf/TWkPKOAOdgcAAAAAAAAAAAAQWASIAAAAAAAAAAAAwgwBIgAAAAAAAAAAgDBDgAgAAAAAAAAAACDMECACAAAAAAAAAAAIMwSIAAAAAAAAAAAAwgwBIgAAAAAAAAAAgDBDgAgAAAAAAAAAACDMECACAAAAAAAAAAAIMwSIAAAAAAAAAAAAwgwBIgAAAAAAAAAAgDBDgAgAAAAAAAAAACDMECACAAAAAAAAAAAIMwSIAAAAAAAAAAAAwgwBIgAAAAAAAAAAgDBDgAgAAAAAAAAAACDMECACAAAAAAAAAAAIMwSIAAAAAAAAAAAAwgwBIgAAAAAAAAAAgDBDgAgAAAAAAAAAACDMRAS7AzhxhmFIktLS0oLcEwRafn6+srKylJaWpsjIyGB3B8BRMFYBe2CsAqGPcQrYA2MVdsb2C9gDY7VsZrzAjB8cCwEiG0tPT5ckNWzYMMg9AQAAAAAAAAAAoSI9PV3JycnHXMZllCeMhJDk9/u1a9cuJSYmyuVyBbs7CKC0tDQ1bNhQ27dvV1JSUrC7A+AoGKuAPTBWgdDHOAXsgbEKO2P7BeyBsVo2wzCUnp6uevXqye0+9ixDZBDZmNvtVoMGDYLdDQRRUlISX4SADTBWAXtgrAKhj3EK2ANjFXbG9gvYA2P12MrKHDIdO3wEAAAAAAAAAAAAxyFABAAAAAAAAAAAEGYIEAE2FB0drREjRig6OjrYXQFwDIxVwB4Yq0DoY5wC9sBYhZ2x/QL2wFitWC7DMIxgdwIAAAAAAAAAAACBQwYRAAAAAAAAAABAmCFABAAAAAAAAAAAEGYIEAEAAAAAAAAAAIQZAkQAAAAAAAAAAABhhgARAAAAACCoDMMIdhcAAACAsBMR7A4AKCk/P1+RkZHB7gaAMjBWAXtgrAKhLT09XY8//rgMw1CTJk30wAMPMGaBEMZ+FXaWnZ2t2NjYYHcDQBnY1wSWy+BWLSAkZGRk6KGHHlJGRobq1aunYcOGqV69esHuFoDDMFYBe2CsAqFv6dKl6tu3r04++WSdcsop+uijj9SzZ08NHz5c5557brC7B6AY9quws4yMDN13333at2+fatWqpcGDB6tTp07B7haAw7CvCQ5KzAEhYM2aNTrttNO0fv16NW/eXB999JFuvPFGffHFF8HuGoBiGKuAPTBWAXv48ssv1b59e33//fd655139MsvvygrK0vPP/+8Dh06FOzuASjEfhV2tnXrVnXu3Flbt27VxRdfrCVLluiuu+7S22+/LUny+/1B7iEAiX1NMBEgAkLA9OnT1bBhQ82YMUPPPPOMlixZosaNG+upp57S/v37g909AIUYq4A9MFaB0Ob3++X1erVp0yYlJSVZj5966qkaOHCg/vrrL7366qtB7CGA4tivws7mzZun6Ohoff755xo8eLDmz5+v3r17a/jw4dq2bZvcbjfz4AEhgH1N8BAgAoLIvFNl+/btkqSYmBhJUuPGjXXvvfcqNjZWw4cPD1r/ABRgrAL2wFgFQpPX69WUKVP0yy+/KD8/X263WxEREcrOzpbL5VJGRoa17EUXXaTu3btr1qxZ2rhxYxB7DYD9KuzMDPrs2rVLGRkZqlGjhiSpRo0aGjx4sNq2bauBAwcGs4sAxL4mFBAgAgLI6/Xqk08+0axZs5SSkiK3u2gIxsfHa8uWLdbvHTp00O23365Zs2Zp5cqVQegtEL4Yq4A9MFaB0Pfxxx+rRo0aeuqpp9S9e3fddtttmjNnjiTp+uuv11dffaVNmzZZyyckJKhHjx7KycnRsmXLgtVtICyxX4Wdeb1evfPOO/r888+1ceNGuVwuSVJcXJyqVq2qpUuXWss2bNhQjz/+uGbNmqXFixfL5XKRRQQECPua0EOACAiQzz77TDVq1NCoUaN0/fXX68orr9SkSZMkSX369NHixYv1+++/W8tHRUXprLPOUqNGjTRz5sxgdRsIO4xVwB4Yq0Do27t3r9566y3985//1OLFizVx4kRlZ2fr7rvvVnZ2tm6++WY1a9ZML7zwgrKzs63XXXLJJdq5c6eysrKC2HsgvLBfhZ1NnjxZNWvW1HvvvaeHHnpIF198sf7zn/9Ikrp27aq0tDT9+OOP8vl81ms6dOigHj166KOPPpIkK6AEoPKwrwlNBIiAAMjKytLbb7+toUOHaunSpZo6dapatWql22+/XVu3btVFF12kNm3aaNSoUSUi5R07dlR6ejqTJgIBwlgF7IGxCtjDkiVL9Ntvv6l///6KjY3V5ZdfrpEjRyoyMlJ33323JOm1117Tp59+qvHjx8vr9UqS9uzZo6pVqyo2NjaY3QfCBvtV2N1///tfDRgwQL/88ou+++473XLLLRoyZIjmzp2rLl26qHPnzpo0aZJ+/vln6zX169eX2+2Wx+MJYs+B8MG+JnQRIAICYMWKFVq8eLFuu+02SVK3bt307LPP6tRTT9Udd9whSXrnnXe0fPlyvf/++8rMzJRU8OUZGRmphISEoPUdCCeMVcAeGKuAPSQmJqpevXrauXOn9Vjbtm315JNPavz48Vq5cqV69+6tQYMGafTo0brxxhs1a9Ys3X///YqKitLZZ58dxN4D4YP9Kuzsjz/+0MKFC3XNNddIklq1aqUnn3xSffr00UMPPaSMjAw988wzSk1N1X//+1+lpKRYr83JyVH16tWD1XUgrLCvCV0EiIAAqFWrlhISErR161ZJBROw1ahRQ6+++qq+//57zZw5U6eeeqqGDx+u6dOn68ILL9Snn36q22+/XampqbrwwguDvAZAeGCsAvbAWAVCk2EYJeZwiI6OVpUqVbRgwQLrMbfbrQsuuEDnnXeennnmGUnSqFGj9Pjjj2vfvn167LHHlJqaqpkzZ6p+/foBXwcgHLFfhZ01aNBAbrdbO3bskCTl5eVJKrjQvGrVKn300Udq0qSJHnroIa1du1Zdu3bV6NGjdf3112vDhg267LLLgtl9IGywrwldLoNZ2IAKZw4rs4bt2rVrNWTIEJ122ml67bXXSix39dVXa9++fVq4cKG8Xq+WLFmiF154Qenp6YqLi9PYsWPVqFGjoKwH4HSMVcAeGKtA6DMMwxqju3fvVt26dSVJffv2VV5enl5++WW1adPGWv7JJ5/U0qVLNWHCBFWtWlVSwUW9Q4cOqVatWoFfASCMsF+F3fn9fmti+7/++kv333+/srOzNXnyZElSfn6+IiMjNXjwYH3//fdavXq1/H6/tm3bpmeeeUb79++X2+3W6NGj1bhx4yCuCeBc7GvsgwwioAIUj7OaJ8cul8uKip9yyilq1aqVli1bptmzZ0sqOKBxuVy67LLLlJqaqu3btysiIkJnnXWWJk+erMmTJ2v69Ol8AQIViLEK2ANjFQhtKSkpGjZsmEaOHKlPPvlEUtHJ/7hx49SnTx9NmzZNkvTEE0/ozz//1KRJk5SVlWW9x8GDB7V3714lJSVZj0VFRREcAioB+1XYWX5+/hGPud1urV+/XpJUs2ZNnXHGGdqxY4fGjx8vqWifdN111+nAgQNas2aN3G63mjRpovfff1+fffaZJk+eTHAIqEDsa+yLABHwN6SkpGjgwIEaOnSoXn/9deuLTZKmTp2q7t276/3335ck3XPPPfL5fPrkk0906NAh626XnTt3Kj8/37pzUio42ElOTg78CgEOxVgF7IGxCoS+mTNnqnnz5lq5cqVWrFih2267Tffee691oe6kk05SgwYNFB8fL8Mw1LlzZ/Xr10/ffPONRo4cqZSUFO3YsUPr1q3TlVdeyeTgQCVivwo7S0lJ0YABA3THHXfoscce0969e63nFi1apK5du+r555+XJF111VVq3ry5/vvf/2rfvn2KiIiQJG3YsEFxcXGqUqVKifeOjY0N2HoATse+xv4IEAEn6IcfflDLli21adMmZWVl6ZFHHtH111+vRYsWSZKaNGmi7t27q3r16jIMQ6eeeqr69++v33//XYMHD9bmzZu1Y8cO/fLLL7rggguYbA2oJIxVwB4Yq4A9fPzxx7ruuus0e/ZsTZkyRTNmzND8+fP15ptvKjc3V926ddOECRPUo0cP6+LA8OHDNWjQIP3nP//RBRdcoNNOO025ubm68847g7w2gHOxX4WdrVixQqeddpp27dqlRo0a6b///a9uuukmTZ06VZJUr1493XnnnWrQoIEMw1CTJk10++23Kzs7WzfeeKMWL16sbdu26X//+5+6dOmimjVrBnmNAGdiX+MMzEEEnKD77rtP+/bt02effSZJWrJkiR555BElJibqs88+U2xsrDIyMkp8ueXl5Wnu3LkaMGCAqlatqj179qh169aaOHGiGjRoEKxVARyNsQrYA2MVCG1+v18pKSm66KKLdMUVV+iJJ56wnnvuuef0zTff6N5771W/fv1KvM7r9Vp3cm/cuFHbtm2T2+3WeeedF9D+A+GG/SrsbOTIkVq0aJFmzJghj8ejtWvXasSIEfrjjz+0ePFixcfHKysrS3FxcdZrDMPQqlWrdPPNNysvL08pKSlq0aKFJk6cSCk5oJKwr3EGMoiA4+T3+5Wbm6tNmzaVSHXs3LmzBgwYoO3bt2vUqFGSpPj4eOv5/Px8RUVFqU+fPlqxYoU++eQTTZ06VT/88ANfgEAlYKwC9sBYBUJTdna25s6dqw0bNkgqKPNRo0YNpaamWvNBeL1eSdKAAQNUp04dffvttzpw4IAkWeVDzJIiktS8eXP16NGD4BBQidivws78fr8kaevWrfJ4PFYZ0lNOOUX33nuvDMPQY489Jqlkmbj8/Hy5XC6ddtppWrhwoaZPn64ZM2bop59+IjgEVAL2Nc5CgAgoQ3Z2tiZPnqylS5fK6/XK7XYrOjpaeXl5MgyjxGS7l156qc4++2xNnz5dO3fulMvlks/n08SJE/Wvf/3LWq527dpq3769zjrrrGCsEuBIjFXAHhirQOh76623VLduXT3wwANq27atHn/8ca1atUqSdP311+vdd99VTk6OIiIi5Pf7VbduXfXs2VMrV67Ujh07JBVMEP7ee+9p3Lhx1mMAKh77VdhZVlaWPvroI82ZM0cHDx605iOJjIxUVFSUdu7caS3buXNn3XbbbZo8ebI2btxobb9ffPGF7rnnHmu5xMRENW/eXJ06dQr4+gBOxb7G2QgQAcfwn//8R7Vq1dIzzzyjc845R3feead+/PFHSdIVV1yhzz//XNu3b7eWr1q1qs477zylp6dr+fLlkgrutpw7d64mTpyodevWBWU9AKdjrAL2wFgFQt9vv/2m//znP3rjjTc0e/Zsvfrqq5o9e7YeeeQRSdKgQYOUk5OjF198UVJBSR9Juuuuu7R69WqlpaVJKhirL730kj766CPuCAUqCftV2NkHH3yg2rVra8yYMbrqqqt0zTXXaMaMGZKknj17auHChfrjjz+s5WNiYnT22WdbGauS5PF4tGnTJn355Zf69ddfJcma/w5AxWBfEwYMAKXatm2b0b59e+Ptt982srKyjM8//9y4+OKLjZYtW1rLNGnSxLj77ruNnJycEq9NTEw0vvzyS+v3P//809i8eXOgug6EFcYqYA+MVcAeXn/9daN27dpGXl6e9djnn39uNG/e3HjuuecMwzCMl19+2YiOjjZ+/PFHa5lffvnFaNSokfHjjz8afr8/4P0Gwg37VdjZoUOHjC5duhgvv/yyYRiG8f333xv9+vUzqlWrZuzbt88wDMNo166dcemllxrbt28v8drmzZsbY8aMsX7fuXOnsW3btsB1Hggj7GvCAxlEwFH88MMPWr9+vW699VbFxsbq2muv1YgRI5SVlaUhQ4ZIkl566SW9++67mjRpknX35JYtW1SjRg1FRUVZ73XKKaeoSZMmwVgNwPEYq4A9MFYBe4iKilLz5s2tuYQkqXfv3rrxxhv15ptvat++ffrHP/6h888/X/fcc4+GDx+uJUuWaMSIEWratKnatm3L3dtAALBfhZ0tXrxYv/32m26++WZJUvfu3fXCCy+ofv36uvvuuyVJY8eO1Q8//KAPP/zQmvvu0KFDio6OVlxcnPVe9erVU8OGDQO/EkAYYF8THggQAUdRpUoV1apVS7t377Ye69ixox5//HGNHTtWmzdv1rXXXqvbbrtNL730km666SbNmjVL9913n6pVq6YuXboEsfdA+GCsAvbAWAVCm3lCX6NGDe3evVsrV660nktKStKll16qRo0a6e2335YkffbZZ7r66qs1Z84c3XrrrXK5XPriiy+UkJAQlP4D4Yb9KuysTp06io2NteYY8vv9qlOnjl555RVNmTJFCxcuVNeuXTVkyBB9+eWX6tWrlz799FP169dPfr9fPXr0CPIaAOGBfU14IEAEHEVsbKySkpI0b9486zGPx6NLLrlEnTp1siZWGzNmjB566CHt2LFDjzzyiFwul2bMmKGaNWsGqedAeGGsAvbAWAVCw88//2zNE1ScmfVz3XXXKTIyUp988olSUlKs5zt06KB69erpwIEDys/PV2JiokaOHKkFCxZo7ty5mjZtGuMUCCD2q7Azt9ut008/XV999ZX1uySdf/75uuCCC/Tcc89Jkv75z3/q9ddfV0JCgt5++215PB7NmzdPjRs3DlrfAScybxQ6HPua8OAyjrYFAA6XnZ2t2NjYYy7Tu3dvxcXF6YUXXtApp5wiqeBLc/jw4dq4caM++ugjJSYmSpJyc3OVlpbGlx9QwZYsWaK3337bKl1TGsYqYA+MVSB4du3apQEDBmju3LmaOXOmevbsecQyXq9XERERmjJlim644Qa99957uuGGG6wLd3369FFMTIwmT54c4N4D4c0wjFJLN7JfhZ0NHDhQ69ev19NPP62zzz5bfr9fbrdbY8aM0XvvvaeZM2eqdu3akgoyjNLT05WcnBzkXgPOMn/+fLVt21ZVq1Y96jLsa5yPDCKEnd27d6t///7q37+/7r33Xv3xxx9HLOPz+SRJjz76qH799Vd9+eWXVs1bl8ulvXv36sCBA9YXoCRFR0fzBQhUoF27dqlXr17q2rWrPv74Y2VlZR2xDGMVCL69e/dq/Pjx+uuvv466DGMVCK6HH35YTZo0UWxsrLZs2VJqcEiSIiIiJEl9+/ZV3759NXr0aL377rvKy8vT+vXrdejQIV1zzTWB7DoQdnbv3q0BAwZo+PDheuWVV5Sfn39EcIj9KkLV3r179dZbb+nPP/+UVHpWgt/vlyTdeeedysrK0kcffaScnBzrZoStW7dKKihtZXK73QSHgAq0a9cuXXLJJerRo4cWLFhQ6jLsa8IHASKEleeee04tW7ZURkaGOnfurGnTpunpp5+26t6aPB6PJKlHjx669tprNWnSJD3zzDM6ePCgNm/erO3bt6tv377BWAUgLDzwwANq1KiRatSooRUrVighIcGqeWueUEiMVSDYxo4dq6ZNm+rWW2/Vzz//fNTlGKtAcPh8Pr344ot65ZVX9O677+rrr79WvXr1jjj2Pfw1kjRq1Ch1795d9913n3r27KmOHTuqZs2auvTSSwPVfSDsTJw4UW3btlVKSoqio6P1wgsv6JZbbtHixYslFY1P9qsIRe+++65atmyp+++/X7Nnzy41uCkVlZPr1KmTbr75Zi1evFhDhgzRli1btHXrVv3++++64IILFB0dHehVAMKCeeNQVFSUduzYcdT9Bfua8EGJOYQFwzA0bdo0vfXWWxo4cKCuvPJKSdIXX3yhQYMGafXq1apVq1aJ15jpzYcOHdL48eM1fPhwtW7dWuvXr9eZZ56p8ePHq3r16sFYHcCxsrOzdfnll+vAgQN688031a1bN+3du1e9e/fWVVddpaeeeuqI1zBWgeBYvHixRowYoauuukqfffaZvF6vPv30U9WrV6/U5RmrQHAsWLBAzz77rNq2bat77rlHDz74oPbt2yefz6ebbrpJd9xxh5KTk0uUsCr+89KlS7Vx40bVqVNH5513XjBXBXA0r9eryy67TN27d9cjjzwiqWD83XLLLWrWrJmmT58ul8tljU/2qwglf/75px588EH16tVLS5cu1datW/Xaa6+pc+fOpS5vbr/Z2dmaNWuW7rjjDtWpU0c7duxQp06dNH78+COu0QD4ewzD0IQJE3TrrbfqnXfe0d133y1J2rx5s+rXr6+oqKgjXsO+JjwQIELYWL9+vfbv36+OHTtaX3rvv/++fv75Zz3xxBNq1KiRpKPXd163bp22bdum2NhYdevWLaB9B8KBeeCxbt06nXzyySWeO+2003TppZfq+eeft5Y7GsYqEBgbN27UkiVLdPXVV2vv3r1q3Lix3n77bd15551WmapjYawCFS89PV2//fab6tatq+bNm0sq2L+OGjVKzz33nAzD0O23365WrVppzZo1eu+993T//ffr4YcfVkJCQpB7D4S3n3/+WVdffbXef/99XXjhhfL5fPJ4PGrXrp1+//13vfTSS/rHP/5x1GNh9qsIpv3792vhwoW64IILlJmZqS5duuiWW27R8OHDj7gJoTS7d+/Wzp075ff7jxpUAvD3rV+/XsOGDVNUVJReffVVDRo0SHv27FFWVpauvvpq3XXXXWrWrBnXRsMMASI4UlZWlg4dOqR69epZB9bFZWRk6MYbb9T06dPVqVMnbdq0SbfddpseffRR1apVq8wL0AAqRllj1Xxs4MCBWrFixTFLWAGoPKVddD7cfffdp2nTpmnmzJlq2bJlgHsI4LnnntPo0aPVuHFjrVq1Sv/85z/Vr18/NWjQQKtXr9b777+vTp066YYbbrBe8+STT2rq1Kl6++23ddZZZwWx90B4KW2/mpGRoZo1a2rMmDG69dZbFRkZqbVr12rw4MGqXbu2NmzYoBkzZnCnNoLu0KFDmjJliho1aqR27dqVOrn9s88+q/Hjx+v1119Xnz59gtBLAKWNVcMwNHnyZN1yyy2KiorSXXfdpc6dO2vt2rV6//33ddZZZ2n06NGqVq1amYFdOAdXwOE4r7/+upo2bapXXnlFfr//iAvOkrR9+3b5/X4tWrRIM2fO1CuvvKKFCxfqjTfekCSCQ0AAlGesmo+ZJauONWcCgMrx3HPPqXnz5ho2bJjatGmj5557zpoTzDAMeb1eSdLo0aN18OBBvffee8rKygpml4Gwsn//fvXv31+ff/65PvzwQ3311Vd6+umn9fHHH1uTDrdu3VoDBw7UFVdcIaloPr+HHnpIq1atUl5eXrC6D4Sd0var27dvV0JCgh5++GENHTpUAwYM0ODBg9WmTRt17txZPXv2VGpqqjZt2hTs7iPMjRkzRvXq1dM777yjyy+/XDfccIO1r/H7/dY8WU888YRiYmL0+eefW+dw3J8OBE5pY3XevHlyuVzq3LmznnzySb366qt64YUXdPXVV+uJJ57Qww8/rFWrVmn27NmSRHAojHAVHI6Rk5OjRx55RB9//LGaNGmi33//XXPmzJFU8kDEMAy1atVK06dPV5cuXVS9enX1799fcXFxOnjwoHWhC0DlKO9YLf57ixYttHbtWiUnJwe8v0C4OtZF53nz5kkqOGmIiIiQ1+uV2+3WCy+8oLffflu//vqrJCkzM1MHDx6UxEUBoLJs2LBBmZmZev3113XRRRepYcOGevjhhxUREaGtW7day7Vo0UIxMTGSim6GWrhwoapXr674+Pig9B0IJ8far/7www+SpKefflr/+te/ZBiGNm7cqBkzZujf//63brjhBm3dupWxiqD666+/9P777+uVV17RokWL9NVXX6lq1aq68cYblZqaKrfbLY/HI6/XK5fLpUcffVSzZ8/W999/L6nguHDfvn2Sim5UAFDxjjZWb7rpJqWlpal+/fq67bbbdOONN8rtdlvnaf3799fmzZutQC/CBwEiOEZUVJTq16+vwYMH6//+7/+UlZWlr7/+WocOHbIm85RU4mfT7t27lZaWpjZt2pRr3gQAJ668Y1UqumOlffv28ng81skzF5qBynesi85btmyRVDQWzX3nwIED1axZM73++usaO3aszj33XH344YeSuAMNqCxt2rTRoEGDdP7550uSdVLfoEGDUsedOW7XrVunt956S71791aHDh0C12EgTJU3mPvAAw/ogw8+0LfffqtevXpJkiZMmKC6desqISGBC+sImgULFmjdunW6+eabJUm9evXSyy+/rLi4OA0bNsxazjwuvP7669W2bVt9+umneuGFF3TGGWfolVdekUTVFqAyHW2sxsfH64EHHpBUUKUlNjZWUtF4XL58uWJjY1WzZs3gdBxBwzcyHMPtdmvAgAG64447dNppp+mqq67S0qVLNW3aNEklL0yZF6H9fr/Wrl2re+65R4mJibrkkkuC1X0gbBzPWDW5XC5Vq1bNykTgQjNQ+cpz0bn4WDSfHzx4sL788ksNHTpUF110kYYOHRrYjgNhJiEhwRqnZsnWjIwMLV++XKeffnqJZfPy8vTMM8+oX79+6tChg6pXr64xY8aUWuYVQMU6nmBuZGSkDMNQdna21q1bp08++URXXHGFGjVqxIV1BE29evUUERGhXbt2SSrY5zRs2FAvvfSSPvroI61cudJ63Ny+r7nmGs2YMUMjR47Utddeq5deeilo/QfCxbHG6scff2yNVangxiHDMLRu3To9++yz6tq1K/NShiGOLOAoCQkJ1s8DBw5U1apVNW3aNKtWs3nHZH5+vt58803dfffdOuOMMxQXF2dN3Aag8pV3rJpOOeUUpaWlkTkEBNDxXHSWJK/Xq/vuu0/33nuvbr/9du3du1fPPvtsoLsNONLChQu1aNEiSUeWTi4t83bFihWKjY094gQ/KipKzZo1k9vt1vz58zV+/HglJiYGYA0AHM9+1e/3a/78+Ro6dKhOP/101a1bV88880wwug1YIiMj1aZNG02aNElSUdbBxRdfrM6dO+uFF16QVLQveuCBBzRgwAD169dPe/bsYRsGAqS8YzUnJ0evvfaa+vfvrw4dOig5OVkffvih4uLigtZ3BAcBIthKeU+OfT6fEhISdMcdd2jdunWaPHmypIIDFa/Xq8jISJ100kmqVauW5s+fr08//VRVqlQJ5KoAjlYRY9Usn2HWsF69erWVIg2gYlTURWep4ASjSZMmWrBggd577z32q0AF2LRpky666CKde+65euONN0o8Z+4fXS6XcnJyJBWN499++01t2rSx5u5bunSpxo8fL0m69dZb9cEHH6hjx44BXBMgPFTUftXtdqtevXo69dRTtXDhQk2cOLHEDVZAZTha+UIzG6hTp05q1qyZfvjhB/3yyy/Wa6Kjo3XFFVdo06ZNSk1NlcvlksfjUYcOHTR//nx98MEHHBcCFagixurBgwcVExOjli1bqlq1apo/f74mTJigpKSkgK0HQgcBItjC8Z4cm6677jqdeuqpmjVrlhYtWqSZM2fqkUcekSRddNFF+ve//6327dsHbD0Ap6vIsfrwww9LKqphXb169cCsBBAGKvKi88SJEyVJycnJeuihh3T22WcHcE0AZzIMQ/fee69atGih5ORk3XLLLUpNTVV6erp1YTkiIkKGYeihhx7S0KFDlZOTY90hOmPGDHXv3l379+/Xtddeq86dO1tlWsnGBSpeRe5XJ0yYIEk6+eSTdf/99xPMRaXbsmWL7rrrLg0bNkyjRo0q8ZzX6y1RhnTYsGFKSUnRuHHjZBiGtd/ZvHmzPB6PEhISrO27X79+OueccwK2HoDTVfRYlaRLLrlEr7/+OvuaMEeACCHtRE+OPR6PFVG/7777tGXLFvXt21eXXXaZ9aXIyTFQcSpjrDLPEFDxKuOi84EDB4K5SoDjrFq1SpGRkVq6dKkWL16sTz/9VE2bNtXWrVuVmJho7Tc/+eQTJScn68cff9SAAQMUExMjSdq5c6dWrFih2bNnq3Hjxjp06JC2bt2qIUOGSGIeP6AiVcZ+NSUlJZirhDDz8ssv6/TTT1dqaqoyMzP14IMP6tVXX5VUsH2b2+/QoUPVp08ftWvXTjfffLO+//57PfDAA9q6das2btyoNWvWqFevXvJ4POxngEpQ0WM1MjIyyGuEkGIAIWrlypWGx+MxzjjjDOPnn382DMMwnnrqKaN169aGYRiGz+czDMMwPv74YyMxMdHo0qWLtZxp586dxrBhwwyXy2Vcf/31xs6dOwO7EkAYYKwC9vB3x+qOHTuMOnXqGBdeeKERFxdnXHDBBca2bdsCvyKAw+3YscOYM2dOicf+97//GXFxcca6deusx7788kvjrbfeMrxeb4llf/zxR8PlchkdO3Y0Zs+eHZA+A+GI/SrsbvPmzUaHDh2MCRMmWI898MADRqdOnazfv/76a6NGjRpG165djfnz5xuGYRhpaWnGZ599ZlSpUsU47bTTjKSkJOOSSy4xUlJSAr4OQDhgrKKyRQQ7QAUcTdWqVfXdd99ZE3lKUrdu3fTKK69o/fr1OumkkyRJcXFxev755zVw4MAS6ZSS9M033+jdd9/V3Llz1b1790B2HwgbjFXAHv7uWN26dav27t2rAwcO6JtvvlHPnj0Dvg6AEx08eFD79+9X3bp1lZCQoHr16ql+/fqSCu4Idblccrvdql+/vjZu3GiN1auuuqrU92vfvr2mTZumiy++OGDrAIQj9quwuzlz5mjbtm3q1q2b9Zjf79fdd9+trKwsxcXFKT4+Xi+++KL69etnbb+JiYm67rrr1K1bN+3YsUNRUVGU7gcqEWMVlc1lGNTZQmg4/OTYPCGWik6OZ8+erXvvvVdvvPGG+vTpc9T3Kv5aABWLsQrYQ0WOVUnKzs7W999/z0VnoAI98cQTGjt2rOrVq6f8/Hy99dZbOvfccxUdHS2/32/NW5KWlqa6detq3Lhxuvbaa+X3+60SVcWxXwUqD/tV2Jm5/darV0/x8fGSCubOOumkk/TAAw/o4osv1ttvv63JkyfrjDPO0P79+/Xaa6/p4osvVmRkJPsXIEAYqwgG5iBCSHjiiSfUvHlzXXnllerYsaNmzZqlvLw8SbLqrEtS586dtXPnTqWnpx/xXHHFD9QBVBzGKmAPFT1WDcNQbGwsF7GACjRmzBhNnjxZn332mcaMGaPOnTvr7rvv1scffyxJcrvdcrlc1vjr1KmT5syZYz1XGi4IAJWD/SrsrPj226FDB82aNUvZ2dlq1qyZ3nzzTeXn5+vOO+9Uamqqli5dqnHjxum8887TM888o0WLFkli/wIEAmMVwUKACEFXGSfHJr4YgYrDWAXsgYvOQGgzb4qYPXu2TjvtNPXq1UvnnXeePv74Y3Xr1k3jx4/XggULJEk+n08ul0sej0cxMTHy+Xzy+XzB7D4Qdtivws7K2n7vvfdeDR8+XDVr1tQLL7yg9u3bq1WrVho1apQ2bdqklJSUIK8BEB4YqwgmAkQIGk6OAXtgrAL2wFgF7MHlcikzM1N//fWXTj31VEmyxt/9998vSRo/frz8fr88Ho+8Xq/cbrc6duyohQsXHjGPH4DKwX4VdlbW9jtx4kTNnz9fkrRy5Urt2LFDZ5xxhhW83LZtm5KSkhQVFRW0dQDCAWMVoYAAEYKGk2PAHhirgD0wVgF78Pv9io+P1ymnnKJvvvlGUlGWQefOnXX22WdrzZo1WrZsmSQpIiJCklStWjXl5ORo+/btwek4EGbYr8LOytp+XS6XJkyYIL/fr5NPPlmZmZl69NFHtWbNGq1Zs0ZDhw7VKaecoi5dugRzNQDHY6wiFBAgQtBwcgzYA2MVsAfGKmAP5pwkQ4YM0a+//qopU6bI5XLJ6/VKkvr166dff/1VqampkoouEvTs2VNz585Vw4YNg9NxIMywX4WdlbX9duvWTatXr9bvv/+uk046SaNGjdIbb7yha6+9Vj169FD9+vU1efJkVa9ePZirATgeYxWhgAARgoaTY8AeGKuAPTBWgdCwZcsWXXnllZo6daoklSgz5fV6rYvIrVq1Ur9+/TRs2DClpqZajzdv3lwxMTHauHGjJFlZCO3bt1fTpk0DuSpAWGO/Cjsrz/b722+/af/+/ZKkAQMGaOXKlRo7dqx++uknffjhh4qLiwta/4FwwVhFKCBAhErDyTFgD4xVwB4Yq4A9vP3225oyZYpee+01+Xw+eTwe6+Q/IiJCubm5evTRR/X777/rySefVG5uroYNG6ZVq1ZJkv73v/+pVq1a6tmzZzBXA3A89quws4rafjds2GC9rnnz5jrnnHPUrFmzAK4J4GyMVdgBASJUGk6OAXtgrAL2wFgF7OHnn3/Wrbfeqry8PL366qslnhszZozq1q2rWbNmqXr16mrcuLEmTJigZcuW6fzzz9eVV16pK664Queff76aNGkSnBUAwgT7VdhZRW2/F1xwQTBXA3A8xirsgAARKg0nx4A9MFYBe2CsAqHFMIwSv3u9Xvl8PjVu3FjXXXedOnfurE8++URbt26V2+3Wpk2btGbNGr322mtaunSpmjdvLsMwdN555+nrr7/W6NGjdfrpp2v+/Pl64403rDtHAVQO9quwM7ZfwB4Yq7ADl3H4mQ1wnAzDkMvlsn73er1yuVy6/fbbdf3112v27NmaM2eOpk6dqsaNG2vTpk167bXX1KlTJ/Xr108ul8t6j02bNunnn3/W2rVrddFFF6lLly5BXDPAWRirgD0wVoHQl52drZiYGGusmmMuPz9fp59+umbOnKnt27frscce0znnnKMRI0Zo06ZNOumkkwj8AAHGfhV2xvYL2ANjFXZGgAh/CyfHgD0wVgF7YKwCoe/hhx/W8uXLFRcXp759++qWW25RdHS0/H6/tm7dqptuukk//fSTXC6X/v3vf+u1115TSkqK/u///k+33nqrIiMjS33fwy8sAPj72K/Czth+AXtgrMLuKDGHE/bwww/rsssuU9++ffXee+8pNzdXLpdLfr9fO3bsUHJysho1aqSzzz5bF110kf773/8qNjZWixYtOqIkR3HELIGKxVgF7IGxCoS277//Xq1atdKCBQt02223yTAMjRkzxioX4na7FRcXp9jYWHm9Xo0fP14vvviifD6fzjjjDA0YMECRkZFHHZMEh4CKxX4Vdsb2C9gDYxVOQIAIx42TY8AeGKuAPTBWgdCXkpKiiRMnqmfPnpo/f75uu+02TZo0SWeddZbWrFmj7OxsSdKiRYu0bt06tW3bVkOHDtVzzz2nZ599VtnZ2froo48kccIPVDb2q7Aztl/AHhircBICRDgunBwD9sBYBeyBsQrYQ25urtq0aaM777xT0dHR8vl8io6OVkREhLZu3arY2FhJUs+ePRUXF6cLL7xQK1as0JAhQ3TZZZepadOmmjBhgnw+n9xuTsGAysJ+FXbG9gvYA2MVTkOhQxwX8+T43HPPLffJ8fDhw9WgQQNt27ZN3333nSZMmKCbb75ZHo8nyGsDOBdjFbAHxioQml5//XWlpqbq9NNP15VXXqm6devq/vvvt5437+pMS0tT+/btJRVMRpyYmKjFixerWrVq1rKNGjXSv//9b7Vs2ZJxClQy9quwM7ZfwB4Yq3Aal0GoEsdw+Mnx4fx+v9xutwYMGKDExESNHj1aXq9XERERSklJKXFyLEl//PEHJ8dAJWCsAvbAWAVC28qVK3XNNdcoKipKdevW1dKlS3XuuefqzTffVMOGDa0xak4+3KVLFw0ZMkS33nqr9VhxpT0GoOKwX4Wdsf0C9sBYhdNR3wClWrlypU455RS9//77+umnn3THHXfoiiuu0Pbt2yUVfPlJRXdP/vHHH+rUqZMkWV9wxb8AzTjkqaeeyhcgUIEYq4A9MFYBe5g8ebLq1aunlStXaurUqVqwYIF++uknvfzyy9q9e7fcbrf8fr9cLpc2bdqk9evX64wzzpBUMH7NMe3z+azHAFQ89quwM7ZfwB4YqwgXBIhQKk6OAXtgrAL2wFgFQpthGMrOztZPP/2kli1bSpIiIyPVpk0bPfvss5o3b56mTJkiSdYcQjNmzFCLFi3UsmVL/fnnn+rdu7d69uyp7OxsTvqBSsZ+FXbG9gvYA2MV4YIAEUrg5BiwB8YqYA+MVSB0rVq1SmlpaZIKTthjY2Pl9/t14MABSQVzCknS3XffrSZNmuh///ufNm/ebL1+3bp1Ov300/X444/rtNNOU5UqVfTLL79YdecBVDz2q7Aztl/AHhirCDcEiMDJMWATjFXAHhirQGibPn26Tj/9dN1www3q0KGDnnjiCeXk5EiS+vXrpylTpmj37t2KiopSbm6uJGnQoEH64YcftG/fPklSTk6OJk+erPfee0+zZs3STz/9pM8++0zJyclBWy/Aqdivws7YfgF7YKwirBkIW9OmTTPatm1rnHrqqUbz5s2Nxx9/3MjOzjYMwzDGjx9vREVFGbt27TIMwzBycnIMwzCMGTNmGNWrVzcWL15sGIZhZGdnGw0bNjRcLpfRqVMnY8mSJcFZGcDBGKuAPTBWgdCWnZ1tPPXUU0aDBg2Ml19+2Vi8eLExatQow+VyGdOmTTMMwzDWr19vtG/f3rjmmmsMwzAMr9drvb5evXrGG2+8YRiGYezdu9d46KGHjClTpgR+RYAwwX4Vdsb2C9gDYxUwDAJEYYiTY8AeGKuAPTBWAXvYuHGj0bVrV+Orr74yDMMw/H6/YRiG0adPH+OWW24xDMMw8vLyjE8++cSIiIgoMQ63bNliNG/e3JgwYULgOw6EGfarsDO2X8AeGKtAEQJEYYiTY8AeGKuAPTBWAfsYN26ckZWVZRhG0Vi96qqrjGHDhlnLpKenG/fff79RpUoVY+TIkcby5cuNhx56yGjZsqWxefPmYHQbCCvsV2FnbL+APTBWgSIRwS5xh8Br1qyZBg4cqD59+pR4PC4uTjVr1pRUMPla3759de+996pfv34aOnSoLr/8co0fP16RkZE688wzg9F1IKwwVgF7YKwC9tGvXz/rZ6/Xq8jISK1fv149evSwHk9ISNDo0aMVHR2tadOmWeN03LhxatKkSRB6DYQX9quwM7ZfwB4Yq0ARl2EYRrA7geDKz89XZGSk2rZtq7vvvltDhgwp8fzDDz+s77//XqmpqYqMjNT777+vLl26BKm3QPhirAL2wFgF7GPz5s3q1q2blixZogYNGkiSDMOQy+WSz+eT1+vVxo0b1bp16yD3FAhf7FdhZ2y/gD0wVhHOCBBBEifHgF0wVgF7YKwC9jB+/Hi99tprWrZsmSRp//79Wrt2rbp27SqPxxPk3gEwsV+FnbH9AvbAWEW4cge7AwgNP/30k+rWrWt9Ae7fv18//fSTfD6fPB6PoqOj+QIEQgBjFbAHxioQ2nw+nyRpzpw5OuOMMyRJzz//vGrVqqVvvvlGfr8/mN0DcBj2q7Aztl/AHhirCFcEiMIcJ8eAPTBWAXtgrAL24PF4lJ+fr1WrViklJUUtW7bUf/7zH02dOlUvvviiIiMjg91FAGK/Cntj+wXsgbGKcBcR7A4guIqfHDdp0kQtW7ZUTk6Opk6dqksuuSTY3QNQiLEK2ANjFbCPjRs3aunSpdq8ebMefvhhDR8+PNhdAnAY9quwM7ZfwB4Yqwh3zEEE/fnnn2rdurWqV6/OyTEQwhirgD0wVgH7GDNmjO644w7FxMQEuysAjoL9KuyM7RewB8YqwhkBIkji5BiwC8YqYA+MVQAAKg77VdgZ2y9gD4xVhCsCRAAAAAAAAAAAAGHGHewOAAAAAAAAAAAAILAIEAEAAAAAAAAAAIQZAkQAAAAAAAAAAABhhgARAAAAAAAAAABAmCFABAAAAAAAAAAAEGYIEAEAAAAAAAAAAIQZAkQAAAAAAAAAAABhhgARAAAAgLD1/fff6+qrr1b9+vUVFRWlqlWr6pRTTtG1116rt956S6mpqcHu4gkZOXKkXC7Xcf0bN26c5s2bJ5fLpf79+wd7FQAAAABUsohgdwAAAAAAguGZZ57RiBEjJEmtWrVSly5dFBkZqbVr1+qrr77SpEmT1KlTJ3Xt2tV6TZMmTbR161YZhhGwfo4bN0633367RowYoZEjR5brNe3atVO/fv1KPJaRkaEvv/xSko54TpJatGghr9f7t/sLAAAAwB4IEAEAAAAIO8uWLdPIkSMVGRmpzz//XFdccUWJ5/fs2aNPPvlEVapUCUr//q4rrrjiiHXasmWLFSAaN25cqa/LysrSmjVrlJycXMk9BAAAABBsBIgAAAAAhJ2vvvpKhmHouuuuOyKQIkl16tTRP/7xj8B3LMji4uLUsmXLYHcDAAAAQAAwBxEAAACAsPPXX39JkmrWrFmu5c25ebZu3SpJJebuadKkibXchg0bNHLkSJ155pmqU6eOoqKi1KBBA912221at25dqe9tvkdeXp6eeeYZtWzZUtHR0briiivUvXt33X777ZKkp59++og5gyra0eYgMuc0GjdunJYtW6aLLrpIVapUUbVq1XTddddpx44dkqTMzEw9/PDDatKkiWJiYtSmTRtNmjTpqO2tWbNG/fv3V8OGDRUdHa3atWvrhhtu0B9//FHh6wYAAACgJDKIAAAAAISdhg0bSpK+/PJLPfbYY6pVq9Yxl69Tp4769eunSZMmKTMzs8QcPjVq1LB+/r//+z+99NJLatOmjc444wxFR0dr9erV+vjjjzVlyhT98MMPatu27RHv7/f7dcUVV2jBggU677zz1LZtW1WvXl1du3aV1+vVjz/+qNNPP13t2rWzXtOiRYu/+Vc4fj///LMGDhyoNm3aqHfv3lq+fLm++OIL/fbbb1qyZIl69eqlrVu36txzz9X+/fs1f/58XXfddZo5c6Z69+5d4r0mT56sG264Qbm5uWrXrp26du2q7du36/PPP9fUqVM1c+ZMnXvuuQFfRwAAACBcuIxAzq4KAAAAACFg06ZNatOmjbKzs5WYmKirrrpKZ599tjp27Ki2bdvK4/GU+romTZpo69atOtpp1OLFi1W7dm01bdq0xOMffPCBBgwYoB49emju3LklnnO5XJIKAj7z5s1T/fr1Szw/btw43X777RoxYoRGjhx5gmtcMAeR2a+j9X/evHnq0aOH+vXrVyJDaeTIkXr66aclSWPHjtXAgQMlSfn5+br44os1e/ZstW7dWnXq1NE333yj+Ph4SdJ7772nO++8U+eee67mz59foi9t2rSRy+XS119/rQsuuMB67ttvv9Xll1+uOnXqaMOGDYqKijrhdQYAAABwdJSYAwAAABB2mjVrpqlTp6phw4ZKT0/Xhx9+qLvuuksdOnRQjRo1dO+992r37t3H/b5du3Y9IjgkSbfffru6deumefPmKTU1tdTXPv/880cEh0LN2WefbQWHJCkyMlL33XefJOnPP//U2LFjreCQJPXv3181atTQokWLlJ+fbz0+atQoZWZm6vnnny8RHJKkPn36aNCgQdq+fbumT59eyWsEAAAAhC8CRAAAAADCUs+ePbVhwwZ99dVXmzutoQAABKtJREFUGjhwoDp06KCIiAgdOnRIY8eOVbt27bR27drjft+MjAxNnDhRjzzyiO666y71799f/fv31+7du2UYhjZu3HjEa1wuly677LKKWK1KdeGFFx7xWLNmzSQVZFedfPLJJZ7zeDxq3Lix8vPztX//fuvx7777TpJ01VVXldrOOeecI0lasmRJhfQbAAAAwJGYgwgAAABA2IqKitKVV16pK6+8UpJ06NAhffrpp3r88ce1b98+DRkyRLNmzSr3+82dO1c33HCD/vrrr6Muk56efsRjtWrVUnR09PGvQICVluGUkJBw1OeKP5+bm2s9tmXLlmO+xlQ8qAQAAACgYhEgAgAAAIBCVapU0cCBA1WvXj317dtX33//vbKyshQXF1fmazMyMnTdddcpJSVFTz31lG644QY1btxYsbGxcrlcuummmzRx4sRS5/+JiYmpjNWpcG730YtQHOu5w/n9fklSv379jrlcly5dyv2eAAAAAI4PASIAAAAAOMz5558vSfL5fDp06FC5AkQ//PCDDhw4oGuuuUZPP/30Ec9v2rSpwvtpVw0aNNDGjRv16quvqnr16sHuDgAAABCWmIMIAAAAQNgpLYunuA0bNkgqKEFXo0YN6/GoqChJktfrPeI1Bw8elFQQ/Cjt/ZYvX35CfT1Wm3bVq1cvSdLXX38d5J4AAAAA4YsAEQAAAICw8+STT2r48OHauHHjEc/t3LlT99xzjyTp8ssvtwI0klSvXj1J0tq1a4943cknnyxJ+uqrr0rMQXTo0CHdcccdys/PP6G+HqtNu3rooYcUGxurf/zjH/rqq6+OeD43N1eTJk3Sjh07gtA7AAAAIDxQYg4AAABA2MnIyNDo0aP1yiuv6OSTT1br1q0VExOjHTt26Oeff1Z+fr5atGihUaNGlXjd5Zdfrvnz56tnz57q0aOH4uPjVaNGDb3wwgvq1KmTevXqpVmzZunkk09W9+7dJUnz5s1TjRo11LdvX02ZMuW4+9q1a1fVqlVLkyZNUvfu3dWsWTO53W4NGDBAZ511VgX8NQKvRYsWmjhxom666SZdffXVatGihVq1aqX4+Hjt3LlTy5cvV2ZmplasWFFqRhYAAACAv48MIgAAAABh55///Kc+/vhj3XLLLYqOjtYPP/ygSZMmafXq1ercubNeeukl/frrr6pfv36J191///365z//qYSEBH355Zd677339Omnn1rPT5kyRU888YRq1qypmTNnatmyZbrhhhu0ePFiValS5YT6GhMTo+nTp6tXr1769ddfNW7cOL333ntat27d3/kTBF3fvn31+++/695775XL5dKsWbM0ffp07du3T5dddpk+//xztW7dOtjdBAAAABzLZZRVfBsAAAAAAAAAAACOQgYRAAAAAAAAAABAmCFABAAAAAAAAAAAEGYIEAEAAAAAAAAAAIQZAkQAAAAAAAAAAABhhgARAAAAAAAAAABAmCFABAAAAAAAAAAAEGYIEAEAAAAAAAAAAIQZAkQAAAAAAAAAAABhhgARAAAAAAAAAABAmCFABAAAAAAAAAAAEGYIEAEAAAAAAAAAAIQZAkQAAAAAAAAAAABh5v8BA0uJvdZgu6AAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import parse_script as ps\n", + "\n", + "names_of_jobs = [\"Rucio\", \"EVNT\", \"TRUTH3\", \"TRUTH3_centos7\", \"TRUTH3_centos7_interactive\"]\n", + "for jobs in names_of_jobs:\n", + " parsing_object = ps.Parsing(jobs)\n", + " list_of_files, first_measurement, final_measurement = parsing_object.cycle_through_files()\n", + " plotting_object = ps.plotting(jobs, list_of_files, first_measurement, final_measurement)\n", + " plotting_object.make_the_plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c6c69f93-74a5-4f50-b991-69a59aca6b20", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tier3docs/README.md b/tier3docs/README.md index 2267fb8..35c53c9 100644 --- a/tier3docs/README.md +++ b/tier3docs/README.md @@ -10,7 +10,8 @@ US ATLAS hosts three shared Tier 3 computing spaces at BNL, SLAC, and UChicago, also known as Analysis Facilities (AF). These three facilities are available to all US ATLAS physicists and computer scientists. They are organized and managed to support US ATLAS users' need for computing resources including login, -run interactive and batch jobs, access ATLAS data, store private data, etc. +run interactive and batch jobs, access ATLAS data, store private data, etc. Visualization for said support can be viewed [here](https://atlas-kibana.mwt2.org:5601/s/analysis-facility/app/dashboards#/view/8bb58440-6145-11ed-afcf-d91dad577662?_g=(filters:!())). +

The AFs also support a wide variety of tools specific for analysis, including ATLAS/CERN software in CVMFS, Grid middleware, Rucio clients, Machine Learning packages, MPI, Jupyter diff --git a/tier3docs/sshlogin/new/uc2_batchsys.md b/tier3docs/sshlogin/new/uc2_batchsys.md index 40dd002..1f9431e 100644 --- a/tier3docs/sshlogin/new/uc2_batchsys.md +++ b/tier3docs/sshlogin/new/uc2_batchsys.md @@ -232,9 +232,5 @@ Queue 1
to know the actual size of your current directory
- Check the table displayed at the start of your session,
which indicates the usage of your /home and /data directories. - -- -- -- diff --git a/tier3docs/sshlogin/new/uc3_htcondorg1.md b/tier3docs/sshlogin/new/uc3_htcondorg1.md index 1c38e63..68f5f37 100644 --- a/tier3docs/sshlogin/new/uc3_htcondorg1.md +++ b/tier3docs/sshlogin/new/uc3_htcondorg1.md @@ -7,23 +7,56 @@ EL::CondorDriver driver; job.options()->setString(EL::Job::optCondorConf, "getenv = true\naccounting_group = group_atlas."); driver.submitOnly( job, "yourJobName”); ``` -### Useful attributes for the jobs submission file -| Option | What is it for? | -|-------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| transfer_output_files= | When it isn't specified, it automatically transfers back all files that have been created or modified in the job’s temporary working directory. | -|-------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| transfer_input_files | HTCondor transfer input files from the machine where the job is submitter to the machine chosen to execute the job | -|-------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| when_to_transfer_output |
  • on_exit:(default) when the job ends on its own
  • on_exit_or_evict: fit the job is evicted from the machine
| -|-------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| should_transfer_files |
  • yes: always transfer files to the remote working directory
  • if_needed: (default) access the files from a shared file system if possible, otherwise it will transfer the file
  • no: disables file transfer
  • command specifies whether HTCondor should assume the existence of a file system shared by the submit machine and the execute machine.
| -|-------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| arguments | options passed to the exe from the cmd line | -|-------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| periodic_remove=time |
  • remove a job that has been in the queue for more than 100 hours e.g.(time() - QDate) > (100*3600):
    • remove jobs that have been running for more than two hours e.g. periodic_remove = (JobStatus == 2 ) && (time() - EnteredCurrentStatus) > (2*3600)
| -|-------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| queue | indicates to create a job | -### Useful commands to manage and check jobs status. +

Useful attributes for the jobs submission file

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
OptionWhat is it for?
transfer_output_files=When it isn't specified, it automatically transfers back all files that have been created or modified in the job’s temporary working directory.
transfer_input_filesHTCondor transfer input files from the machine where the job is submitter to the machine chosen to execute the job
when_to_transfer_output
  • on_exit:(default) when the job ends on its own
  • on_exit_or_evict: fit the job is evicted from the machine
should_transfer_files
  • yes: always transfer files to the remote working directory
  • if_needed: (default) access the files from a shared file system if possible, otherwise it will transfer the file
  • no: disables file transfer
  • command specifies whether HTCondor should assume the existence of a file system shared by the submit machine and the execute machine.
argumentsoptions passed to the exe from the cmd line
periodic_remove=time
  • remove a job that has been in the queue for more than 100 hours e.g.(time() - QDate) > (1003600):
    • remove jobs that have been running for more than two hours e.g. periodic_remove = (JobStatus == 2 ) && (time() - EnteredCurrentStatus) > (23600)
queueindicates to create a job
+ + +

Useful commands to manage and check the job's status.