From 80f24626931dfacbee240f777bdb1ce8032e25a6 Mon Sep 17 00:00:00 2001 From: schroederb Date: Wed, 23 Feb 2022 15:03:37 +0100 Subject: [PATCH 1/6] initialize Alchemical System Structure --- ...ample_setupTopologyApproaches_bries.ipynb} | 0 .../gromos_system/alchemicalFE_system.py | 5 + .../pyGromosPP/generate_FETopologyApproach.py | 102 ++++++++++++++++++ .../pyGromosPP/utils/FEtopologyMakerHelper.py | 1 + 4 files changed, 108 insertions(+) rename examples/dev/{singleTop/example_ptp.ipynb => example_setupTopologyApproaches_bries.ipynb} (100%) create mode 100644 pygromos/files/gromos_system/alchemicalFE_system.py create mode 100644 pygromos/gromos/pyGromosPP/generate_FETopologyApproach.py create mode 100644 pygromos/gromos/pyGromosPP/utils/FEtopologyMakerHelper.py diff --git a/examples/dev/singleTop/example_ptp.ipynb b/examples/dev/example_setupTopologyApproaches_bries.ipynb similarity index 100% rename from examples/dev/singleTop/example_ptp.ipynb rename to examples/dev/example_setupTopologyApproaches_bries.ipynb diff --git a/pygromos/files/gromos_system/alchemicalFE_system.py b/pygromos/files/gromos_system/alchemicalFE_system.py new file mode 100644 index 00000000..dda31d01 --- /dev/null +++ b/pygromos/files/gromos_system/alchemicalFE_system.py @@ -0,0 +1,5 @@ +from pygromos.files.gromos_system.gromos_system import Gromos_System + +class AlchemicalFE_System(Gromos_System): + + pass \ No newline at end of file diff --git a/pygromos/gromos/pyGromosPP/generate_FETopologyApproach.py b/pygromos/gromos/pyGromosPP/generate_FETopologyApproach.py new file mode 100644 index 00000000..9b47440a --- /dev/null +++ b/pygromos/gromos/pyGromosPP/generate_FETopologyApproach.py @@ -0,0 +1,102 @@ +def generate_dual_topology_approach(cnfA, cnfB, topA, topB, eds:bool=False): + ##Atom Mapping + atom_mappingAB, smart = find_atom_mapping(cnfA=cnfA, cnfB=cnfB) + + ##Coordinates + cnfA, cnfB = align_cnfs_with_MCS(cnfA=cnfA, cnfB=cnfB, atom_mappingAB=atom_mappingAB) + cnf_comb = copy.deepcopy(cnfA) + #cnf_comb += cnfB # needs to be implemented + + for pos in cnfB.POSITION: + cnf_comb.POSITION.append(pos) + + cnf_comb.supress_atomPosition_singulrarities() + + + ##Top + nAtoms_top1 = len(top1.SOLUTEATOM) + top_comb = copy.deepcopy(top1) + top_comb += top2 + + ### Pertubation + ptp_comb = ptp.Pertubation_topology() + + if(eds): + from pygromos.files.blocks.pertubation_blocks import MPERTATOM + from pygromos.files.blocks.pertubation_blocks import atom_eds_pertubation_state, pertubation_eds_state + + tops = [topA, topB] + dummyState = pertubation_eds_state(IAC=22, CHARGE=0) + + numStates=len(tops) + IND = 1 + atom_states = [] + for top_ind, top in enumerate(tops): + for atom in top.SOLUTEATOM: + states = {} + for ctop in range(ntops): + if(ctop==top_ind): + states.update({ctop+1:pertubation_eds_state(IAC=atom.IAC, CHARGE=atom.CG)}) + else: + states.update({ctop+1:dummyState}) + + atom_ptp = atom_eds_pertubation_state(NR=IND, NAME=atom.PANM, STATES=states) + atom_states.append(atom_ptp) + IND+=1 + + ptp_comb.add_block(block=MPERTATOM(NJLA=len(atom_states), NPTB=numStates, STATEATOMS=atom_states)) + + else: + from pygromos.files.blocks.pertubation_blocks import PERTATOMPARAM + from pygromos.files.blocks.pertubation_blocks import atom_lam_pertubation_state, pertubation_lam_state_nonbonded + + tops = [topA, topB] + build_dummyState = lambda m: pertubation_lam_state_nonbonded(IAC=22, CHARGE=0, MASS=m) + + numStates=len(tops) + IND = 1 + atom_states = [] + for top_ind, top in enumerate(tops): + for atom in top.SOLUTEATOM: + states = {} + for ctop in range(ntops): + if(ctop==top_ind): + states.update({ctop+1:pertubation_lam_state_nonbonded(IAC=atom.IAC, CHARGE=atom.CG, MASS=atom.MASS)}) + else: + states.update({ctop+1:build_dummyState(atom.MASS)}) + + atom_ptp = atom_lam_pertubation_state(NR=IND, RES=atom.MRES, NAME=atom.PANM, STATES=states,) + atom_states.append(atom_ptp) + IND+=1 + + ptp_comb.add_block(block=PERTATOMPARAM(NJLA=len(atom_states), STATEATOMS=atom_states)) + + return cnf_comb, top_comb, ptp_comb + +def generate_hybrid_topology_approach(cnfA, cnfB, topA, topB): + ##Atom Mapping + atom_mappingAB, smart = find_atom_mapping(cnfA=cnfA, cnfB=cnfB) + + ##Coordinates + cnfA, cnfB = align_cnfs_with_MCS(cnfA=cnfA, cnfB=cnfB, atom_mappingAB=atom_mappingAB) + cnf_comb, present_atoms = merge_states(cnfA=cmol1, cnfB=cmol2, atomMatchingAB=atom_mappingAB, dist_tresh=0.0, _doNotChangeAtomType=True, _doUpdateAtomMapping=True) #no distance collapsing + + ##Top + + + ### Pertubation + + + return cnf_comb + #return cnf_comb, top_comb, ptp_comb + +def generate_single_topology_approach(cnfA, cnfB, topA, topB): + ##Atom Mapping + atom_mappingAB, smart = find_atom_mapping(cnfA=cnfA, cnfB=cnfB) + + ##Coordinates + cnfA, cnfB = align_cnfs_with_MCS(cnfA=cnfA, cnfB=cnfB, atom_mappingAB=atom_mappingAB) + cnf_comb,present_atoms = merge_states(cnfA=cmol1, cnfB=cmol2, atomMatchingAB=atom_mappingAB, dist_tresh=0.09) #no distance collapsing + + + return cnf_comb #, top_comb, ptp_comb \ No newline at end of file diff --git a/pygromos/gromos/pyGromosPP/utils/FEtopologyMakerHelper.py b/pygromos/gromos/pyGromosPP/utils/FEtopologyMakerHelper.py new file mode 100644 index 00000000..0aba17d1 --- /dev/null +++ b/pygromos/gromos/pyGromosPP/utils/FEtopologyMakerHelper.py @@ -0,0 +1 @@ +import os \ No newline at end of file From 1bb29f10f1042ae0f6a0f53e74513daa3d6458af Mon Sep 17 00:00:00 2001 From: schroederb Date: Wed, 23 Feb 2022 15:34:40 +0100 Subject: [PATCH 2/6] more docu :) --- .../pyGromosPP/generate_FETopologyApproach.py | 162 ++++++++---------- 1 file changed, 75 insertions(+), 87 deletions(-) diff --git a/pygromos/gromos/pyGromosPP/generate_FETopologyApproach.py b/pygromos/gromos/pyGromosPP/generate_FETopologyApproach.py index 9b47440a..e4cd098c 100644 --- a/pygromos/gromos/pyGromosPP/generate_FETopologyApproach.py +++ b/pygromos/gromos/pyGromosPP/generate_FETopologyApproach.py @@ -1,102 +1,90 @@ -def generate_dual_topology_approach(cnfA, cnfB, topA, topB, eds:bool=False): - ##Atom Mapping - atom_mappingAB, smart = find_atom_mapping(cnfA=cnfA, cnfB=cnfB) - - ##Coordinates - cnfA, cnfB = align_cnfs_with_MCS(cnfA=cnfA, cnfB=cnfB, atom_mappingAB=atom_mappingAB) - cnf_comb = copy.deepcopy(cnfA) - #cnf_comb += cnfB # needs to be implemented - - for pos in cnfB.POSITION: - cnf_comb.POSITION.append(pos) +"""_summary_ + +""" - cnf_comb.supress_atomPosition_singulrarities() +from typing import List, Tuple +from pygromos.files.coord.cnf import Cnf +from pygromos.files.top.top import Top +from pygromos.files.top.ptp import Ptp +from pygromos.files.top.disres import Disres - ##Top - nAtoms_top1 = len(top1.SOLUTEATOM) - top_comb = copy.deepcopy(top1) - top_comb += top2 - - ### Pertubation - ptp_comb = ptp.Pertubation_topology() - - if(eds): - from pygromos.files.blocks.pertubation_blocks import MPERTATOM - from pygromos.files.blocks.pertubation_blocks import atom_eds_pertubation_state, pertubation_eds_state - tops = [topA, topB] - dummyState = pertubation_eds_state(IAC=22, CHARGE=0) - numStates=len(tops) - IND = 1 - atom_states = [] - for top_ind, top in enumerate(tops): - for atom in top.SOLUTEATOM: - states = {} - for ctop in range(ntops): - if(ctop==top_ind): - states.update({ctop+1:pertubation_eds_state(IAC=atom.IAC, CHARGE=atom.CG)}) - else: - states.update({ctop+1:dummyState}) +def generate_dual_topology_approach(cnfs:List[Cnf], tops:List[Top], eds:bool=False, generate_distance_restraints:bool=True)->Tuple[Cnf, Top, Ptp, Disres]: + """ + This function generates a Gromos System, according to the dual topology paradigm. + In this process a coordinate, topology and pertubation file will be generated. + Additionally a distance restraint file will be generated with RestraintMaker. + + The definition of the dual topology follows the description in: + RestraintMaker: A Graph-Based Approach to Select Distance Restraints in Free-Energy Calculations with Dual Topology + Benjamin Ries$^\text{\dag}$, Salomé Rieder$^\text{\dag}$, Clemens Rhiner, Philippe H. Hünenberger$^\text{*}$ and Sereina Riniker$^\text{*}$ (2022, JCAMD) - atom_ptp = atom_eds_pertubation_state(NR=IND, NAME=atom.PANM, STATES=states) - atom_states.append(atom_ptp) - IND+=1 + Parameters + ---------- + cnfs : List[Cnf] + The cnf files of the single end-states (for protein-ligands FE -> [ligandA.cnf, ligandB.cnf, ...]) + tops : List[Top] + The top files of the single end-states (for protein-ligands FE -> [ligandA.top, ligandB.top, ...]) + eds : bool, optional + If you want do perform a eds simulation set True, as the ptp blocks vary between eds and lambda dependent calculations, by default False + generate_distance_restraints : bool, optional + If True, the dual topology approach will additionally contain distance restrained following the linked dual topology principal. + These restraints will be automatically attempted by RestraintMaker. (But double check!) + + Returns + ------- + Tuple[Cnf, Top, Ptp, Disres] + Returns the prepared Alchemical System files. + """ + pass - ptp_comb.add_block(block=MPERTATOM(NJLA=len(atom_states), NPTB=numStates, STATEATOMS=atom_states)) +def generate_hybrid_topology_approach(cnfs:List[Cnf], tops:List[Cnf], atomMapping:List=None, eds:bool=False)->Tuple[Cnf, Top, Ptp]: + """_summary_ - else: - from pygromos.files.blocks.pertubation_blocks import PERTATOMPARAM - from pygromos.files.blocks.pertubation_blocks import atom_lam_pertubation_state, pertubation_lam_state_nonbonded + The definition of the hybrid topology follows the description in: + RestraintMaker: A Graph-Based Approach to Select Distance Restraints in Free-Energy Calculations with Dual Topology + Benjamin Ries$^\text{\dag}$, Salomé Rieder$^\text{\dag}$, Clemens Rhiner, Philippe H. Hünenberger$^\text{*}$ and Sereina Riniker$^\text{*}$ (2022, JCAMD) - tops = [topA, topB] - build_dummyState = lambda m: pertubation_lam_state_nonbonded(IAC=22, CHARGE=0, MASS=m) + Parameters + ---------- + cnfs : List[Cnf] + The cnf files of the single end-states (for protein-ligands FE -> [ligandA.cnf, ligandB.cnf, ...]) + tops : List[Top] + The top files of the single end-states (for protein-ligands FE -> [ligandA.top, ligandB.top, ...]) + atomMapping : List, optional + The mapping of the atoms for the different end-states, by default None + eds : bool, optional + If you want do perform a eds simulation set True, as the ptp blocks vary between eds and lambda dependent calculations, by default False - numStates=len(tops) - IND = 1 - atom_states = [] - for top_ind, top in enumerate(tops): - for atom in top.SOLUTEATOM: - states = {} - for ctop in range(ntops): - if(ctop==top_ind): - states.update({ctop+1:pertubation_lam_state_nonbonded(IAC=atom.IAC, CHARGE=atom.CG, MASS=atom.MASS)}) - else: - states.update({ctop+1:build_dummyState(atom.MASS)}) + Returns + ------- + Tuple[Cnf, Top, Ptp] + Returns the prepared Alchemical System files. + """ + pass - atom_ptp = atom_lam_pertubation_state(NR=IND, RES=atom.MRES, NAME=atom.PANM, STATES=states,) - atom_states.append(atom_ptp) - IND+=1 +def generate_single_topology_approach(cnfs:List[Cnf], tops:List[Top], eds:bool=False)->Tuple[Cnf, Top, Ptp]: + """_summary_ - ptp_comb.add_block(block=PERTATOMPARAM(NJLA=len(atom_states), STATEATOMS=atom_states)) - - return cnf_comb, top_comb, ptp_comb + The definition of the single topology follows the description in: + RestraintMaker: A Graph-Based Approach to Select Distance Restraints in Free-Energy Calculations with Dual Topology + Benjamin Ries$^\text{\dag}$, Salomé Rieder$^\text{\dag}$, Clemens Rhiner, Philippe H. Hünenberger$^\text{*}$ and Sereina Riniker$^\text{*}$ (2022, JCAMD) -def generate_hybrid_topology_approach(cnfA, cnfB, topA, topB): - ##Atom Mapping - atom_mappingAB, smart = find_atom_mapping(cnfA=cnfA, cnfB=cnfB) - - ##Coordinates - cnfA, cnfB = align_cnfs_with_MCS(cnfA=cnfA, cnfB=cnfB, atom_mappingAB=atom_mappingAB) - cnf_comb, present_atoms = merge_states(cnfA=cmol1, cnfB=cmol2, atomMatchingAB=atom_mappingAB, dist_tresh=0.0, _doNotChangeAtomType=True, _doUpdateAtomMapping=True) #no distance collapsing - - ##Top - - - ### Pertubation - - - return cnf_comb - #return cnf_comb, top_comb, ptp_comb + Parameters + ---------- + cnfs : List[Cnf] + The cnf files of the single end-states (for protein-ligands FE -> [ligandA.cnf, ligandB.cnf, ...]) + tops : List[Top] + The top files of the single end-states (for protein-ligands FE -> [ligandA.top, ligandB.top, ...]) + eds : bool, optional + If you want do perform a eds simulation set True, as the ptp blocks vary between eds and lambda dependent calculations, by default False -def generate_single_topology_approach(cnfA, cnfB, topA, topB): - ##Atom Mapping - atom_mappingAB, smart = find_atom_mapping(cnfA=cnfA, cnfB=cnfB) - - ##Coordinates - cnfA, cnfB = align_cnfs_with_MCS(cnfA=cnfA, cnfB=cnfB, atom_mappingAB=atom_mappingAB) - cnf_comb,present_atoms = merge_states(cnfA=cmol1, cnfB=cmol2, atomMatchingAB=atom_mappingAB, dist_tresh=0.09) #no distance collapsing - - return cnf_comb #, top_comb, ptp_comb \ No newline at end of file + Returns + ------- + Tuple[Cnf, Top, Ptp] + Returns the prepared Alchemical System files. + """ + pass \ No newline at end of file From aa9778dcf7ce73b35d3f8fd6d31a653b358d05ec Mon Sep 17 00:00:00 2001 From: schroederb Date: Wed, 23 Feb 2022 15:41:28 +0100 Subject: [PATCH 3/6] nice docs --- .../pyGromosPP/generate_FETopologyApproach.py | 22 ++++++++++++++----- 1 file changed, 16 insertions(+), 6 deletions(-) diff --git a/pygromos/gromos/pyGromosPP/generate_FETopologyApproach.py b/pygromos/gromos/pyGromosPP/generate_FETopologyApproach.py index e4cd098c..9a6d0cc9 100644 --- a/pygromos/gromos/pyGromosPP/generate_FETopologyApproach.py +++ b/pygromos/gromos/pyGromosPP/generate_FETopologyApproach.py @@ -13,8 +13,8 @@ def generate_dual_topology_approach(cnfs:List[Cnf], tops:List[Top], eds:bool=False, generate_distance_restraints:bool=True)->Tuple[Cnf, Top, Ptp, Disres]: """ - This function generates a Gromos System, according to the dual topology paradigm. - In this process a coordinate, topology and pertubation file will be generated. + This function generates a Gromos System, according to the dual topology paradigm. + In this process a coordinate, topology and pertubation file will be generated. Additionally a distance restraint file will be generated with RestraintMaker. The definition of the dual topology follows the description in: @@ -41,8 +41,12 @@ def generate_dual_topology_approach(cnfs:List[Cnf], tops:List[Top], eds:bool=Fal pass def generate_hybrid_topology_approach(cnfs:List[Cnf], tops:List[Cnf], atomMapping:List=None, eds:bool=False)->Tuple[Cnf, Top, Ptp]: - """_summary_ - + """ + This function generates a Gromos System, according to the hybrid topology paradigm. + In this process a coordinate, topology and pertubation file will be generated. + A atomMapping for the different regions (single topology region/dual topology region) can be provided. + If no mapping is provided, the function will automatically generate an MCS and estimate the single and dual topology regions. + The definition of the hybrid topology follows the description in: RestraintMaker: A Graph-Based Approach to Select Distance Restraints in Free-Energy Calculations with Dual Topology Benjamin Ries$^\text{\dag}$, Salomé Rieder$^\text{\dag}$, Clemens Rhiner, Philippe H. Hünenberger$^\text{*}$ and Sereina Riniker$^\text{*}$ (2022, JCAMD) @@ -65,8 +69,12 @@ def generate_hybrid_topology_approach(cnfs:List[Cnf], tops:List[Cnf], atomMappin """ pass -def generate_single_topology_approach(cnfs:List[Cnf], tops:List[Top], eds:bool=False)->Tuple[Cnf, Top, Ptp]: - """_summary_ +def generate_single_topology_approach(cnfs:List[Cnf], tops:List[Top], atomMapping:List=None, eds:bool=False)->Tuple[Cnf, Top, Ptp]: + """ + This function generates a Gromos System, according to the single topology paradigm. + In this process a coordinate, topology and pertubation file will be generated. + An atomMapping for the single-topology regio can be provided. + If no mapping is provided, the function will automatically generate an MCS and estimate the molecule overlaps. The definition of the single topology follows the description in: RestraintMaker: A Graph-Based Approach to Select Distance Restraints in Free-Energy Calculations with Dual Topology @@ -78,6 +86,8 @@ def generate_single_topology_approach(cnfs:List[Cnf], tops:List[Top], eds:bool=F The cnf files of the single end-states (for protein-ligands FE -> [ligandA.cnf, ligandB.cnf, ...]) tops : List[Top] The top files of the single end-states (for protein-ligands FE -> [ligandA.top, ligandB.top, ...]) + atomMapping : List, optional + The mapping of the atoms for the different end-states, by default None eds : bool, optional If you want do perform a eds simulation set True, as the ptp blocks vary between eds and lambda dependent calculations, by default False From adacdc1d7be2e6d9c1071c11067110d78817dd60 Mon Sep 17 00:00:00 2001 From: schroederb Date: Wed, 23 Feb 2022 16:24:16 +0100 Subject: [PATCH 4/6] betterVarnames, AlchemFESys - declarations and concept --- .../gromos_system/alchemicalFE_system.py | 74 ++++++++++++++++++- .../pyGromosPP/generate_FETopologyApproach.py | 28 +++---- 2 files changed, 87 insertions(+), 15 deletions(-) diff --git a/pygromos/files/gromos_system/alchemicalFE_system.py b/pygromos/files/gromos_system/alchemicalFE_system.py index dda31d01..352eeb6f 100644 --- a/pygromos/files/gromos_system/alchemicalFE_system.py +++ b/pygromos/files/gromos_system/alchemicalFE_system.py @@ -1,5 +1,77 @@ +from enum import Enum +from typing import List, Tuple + +from pygromos.gromos.pyGromosPP.generate_FETopologyApproach import generate_dual_topology_approach, generate_hybrid_topology_approach, generate_single_topology_approach + + +from pygromos.files.coord.cnf import Cnf +from pygromos.files.top.top import Top +from pygromos.files.top.ptp import Ptp from pygromos.files.gromos_system.gromos_system import Gromos_System + """ + UTILS + """ +class topology_approach(Enum): + dual = 1 + hybrid = 2 + single = 3 class AlchemicalFE_System(Gromos_System): + """ + The Alchemical Free Energy Systems, should help to quickly setup and run FE simulations. + + Todo: Consider how to insert the FF-Conversions for single topologies (e.g. amber2Gromos) + + """ + + + def __init__(work_folder: str, system_name: str, in_endstate_cnfs:List[Cnf], in_endstate_tops:List[Top], + in_imd_path: str = None, topology_approach:topology_approach=topology_approach.dual, eds_simulation:bool=False, + in_gromosXX_bin_dir:str = None, in_gromosPP_bin_dir:str=None, + readIn=True, Forcefield:forcefield_system=forcefield_system(), + auto_convert:bool=False, adapt_imd_automatically:bool=True, verbose:bool=False): + + self.single_endstate_coordinates = in_endstate_cnfs + self.single_endstate_topologies = in_endstate_tops + + super().__init__(work_folder=work_folder, system_name=system_name, in_imd_path=in_imd_path, + in_gromosXX_bin_dir=in_gromosXX_bin_dir, in_gromosPP_bin_dir=in_gromosPP_bin_dir, + readIn=readIn, Forcefield=Forcefield, auto_convert=auto_convert, adapt_imd_automatically=adapt_imd_automatically + verbose=verbose) + + self.eds_simulation = self._is_eds_simulation(eds_simulation) + + self.generate_alchemical_system(in_endstate_cnfs=in_endstate_cnfs, in_endstate_tops=in_endstate_tops, + topology_approach=topology_approach, eds_simulation=eds_simulation) + + + def _is_eds_simulation(self, eds_simulation:bool)->bool: + if(hasattr(self, "imd") and eds_simulation is None): + if(hasattr(self.imd, "EDS") and self.imd.EDS.EDS): + eds_simulation = True + elif(hasattr(self.imd, "REEDS") and self.imd.REEDS.REEDS>0): #will work in future + eds_simulation = True + else: + eds_simulation = False + return eds_simulation + + @classmethod + def generate_alchemical_system(cls, in_endstate_cnfs:List[Cnf], in_endstate_tops:List[Top], topology_approach:topology_approach, eds_simulation:bool=False): + if(topology_approach == case topology_approach.dual): + self.cnf, self.top, self.ptp, self.disres = generate_dual_topology_approach(endstate_cnfs=self.single_endstate_coordinates, + endstate_tops=self.single_endstate_topologies, + eds_simulation=self.eds_simulation, + generate_distance_restraints=True) + elif(topology_approach == case topology_approach.hybrid): + self.cnf, self.top, self.ptp = generate_hybrid_topology_approach(endstate_cnfs=self.single_endstate_coordinates, + endstate_tops=self.single_endstate_topologies, + atom_mapping=None + eds_simulation=self.eds_simulation,) - pass \ No newline at end of file + elif(topology_approach == case topology_approach.single): + self.cnf, self.top, self.ptp = generate_single_topology_approach(endstate_cnfs=self.single_endstate_coordinates, + endstate_tops=self.single_endstate_topologies, + atom_mapping=None + eds_simulation=self.eds_simulation,) + else: + raise IOError("No valid topology_approach was passed. please use:\n"+str(help(topology_approach))) diff --git a/pygromos/gromos/pyGromosPP/generate_FETopologyApproach.py b/pygromos/gromos/pyGromosPP/generate_FETopologyApproach.py index 9a6d0cc9..892e0658 100644 --- a/pygromos/gromos/pyGromosPP/generate_FETopologyApproach.py +++ b/pygromos/gromos/pyGromosPP/generate_FETopologyApproach.py @@ -11,7 +11,7 @@ -def generate_dual_topology_approach(cnfs:List[Cnf], tops:List[Top], eds:bool=False, generate_distance_restraints:bool=True)->Tuple[Cnf, Top, Ptp, Disres]: +def generate_dual_topology_approach(endstate_cnfs:List[Cnf], endstate_tops:List[Top], eds_simulation:bool=False, generate_distance_restraints:bool=True)->Tuple[Cnf, Top, Ptp, Disres]: """ This function generates a Gromos System, according to the dual topology paradigm. In this process a coordinate, topology and pertubation file will be generated. @@ -23,11 +23,11 @@ def generate_dual_topology_approach(cnfs:List[Cnf], tops:List[Top], eds:bool=Fal Parameters ---------- - cnfs : List[Cnf] + endstate_cnfs : List[Cnf] The cnf files of the single end-states (for protein-ligands FE -> [ligandA.cnf, ligandB.cnf, ...]) - tops : List[Top] + endstate_tops : List[Top] The top files of the single end-states (for protein-ligands FE -> [ligandA.top, ligandB.top, ...]) - eds : bool, optional + eds_simulation : bool, optional If you want do perform a eds simulation set True, as the ptp blocks vary between eds and lambda dependent calculations, by default False generate_distance_restraints : bool, optional If True, the dual topology approach will additionally contain distance restrained following the linked dual topology principal. @@ -40,7 +40,7 @@ def generate_dual_topology_approach(cnfs:List[Cnf], tops:List[Top], eds:bool=Fal """ pass -def generate_hybrid_topology_approach(cnfs:List[Cnf], tops:List[Cnf], atomMapping:List=None, eds:bool=False)->Tuple[Cnf, Top, Ptp]: +def generate_hybrid_topology_approach(endstate_cnfs:List[Cnf], endstate_tops:List[Cnf], atom_mapping:List=None, eds_simulation:bool=False)->Tuple[Cnf, Top, Ptp]: """ This function generates a Gromos System, according to the hybrid topology paradigm. In this process a coordinate, topology and pertubation file will be generated. @@ -53,13 +53,13 @@ def generate_hybrid_topology_approach(cnfs:List[Cnf], tops:List[Cnf], atomMappin Parameters ---------- - cnfs : List[Cnf] + endstate_cnfs : List[Cnf] The cnf files of the single end-states (for protein-ligands FE -> [ligandA.cnf, ligandB.cnf, ...]) - tops : List[Top] + endstate_tops : List[Top] The top files of the single end-states (for protein-ligands FE -> [ligandA.top, ligandB.top, ...]) - atomMapping : List, optional + atom_mapping : List, optional The mapping of the atoms for the different end-states, by default None - eds : bool, optional + eds_simulation : bool, optional If you want do perform a eds simulation set True, as the ptp blocks vary between eds and lambda dependent calculations, by default False Returns @@ -69,7 +69,7 @@ def generate_hybrid_topology_approach(cnfs:List[Cnf], tops:List[Cnf], atomMappin """ pass -def generate_single_topology_approach(cnfs:List[Cnf], tops:List[Top], atomMapping:List=None, eds:bool=False)->Tuple[Cnf, Top, Ptp]: +def generate_single_topology_approach(endstate_cnfs:List[Cnf], endstate_tops:List[Top], atom_mapping:List=None, eds_simulation:bool=False)->Tuple[Cnf, Top, Ptp]: """ This function generates a Gromos System, according to the single topology paradigm. In this process a coordinate, topology and pertubation file will be generated. @@ -82,13 +82,13 @@ def generate_single_topology_approach(cnfs:List[Cnf], tops:List[Top], atomMappin Parameters ---------- - cnfs : List[Cnf] + endstate_cnfs : List[Cnf] The cnf files of the single end-states (for protein-ligands FE -> [ligandA.cnf, ligandB.cnf, ...]) - tops : List[Top] + endstate_tops : List[Top] The top files of the single end-states (for protein-ligands FE -> [ligandA.top, ligandB.top, ...]) - atomMapping : List, optional + atom_mapping : List, optional The mapping of the atoms for the different end-states, by default None - eds : bool, optional + eds_simulation : bool, optional If you want do perform a eds simulation set True, as the ptp blocks vary between eds and lambda dependent calculations, by default False From 773c17b62b9413ed3e09f1535fad7ffe231eb6ee Mon Sep 17 00:00:00 2001 From: Benjamin Ries Date: Wed, 23 Feb 2022 16:25:47 +0100 Subject: [PATCH 5/6] Update alchemicalFE_system.py --- pygromos/files/gromos_system/alchemicalFE_system.py | 1 + 1 file changed, 1 insertion(+) diff --git a/pygromos/files/gromos_system/alchemicalFE_system.py b/pygromos/files/gromos_system/alchemicalFE_system.py index 352eeb6f..e2ef7443 100644 --- a/pygromos/files/gromos_system/alchemicalFE_system.py +++ b/pygromos/files/gromos_system/alchemicalFE_system.py @@ -20,6 +20,7 @@ class AlchemicalFE_System(Gromos_System): """ The Alchemical Free Energy Systems, should help to quickly setup and run FE simulations. + Warning: This is right now just a concept! Needs to be further developed! Todo: Consider how to insert the FF-Conversions for single topologies (e.g. amber2Gromos) """ From 173d1183935e556977efbf89e7f91adea0e14c3f Mon Sep 17 00:00:00 2001 From: Candide Champion Date: Thu, 24 Feb 2022 14:07:40 +0100 Subject: [PATCH 6/6] Add files I was currently using to develop the code to prepare hybrid topologies --- .../generate_hybrid_topologies.ipynb | 1051 +++++++++++++++++ .../hybrid_topology_maker.py | 1040 ++++++++++++++++ 2 files changed, 2091 insertions(+) create mode 100644 examples/dev/hybrid_topologies/generate_hybrid_topologies.ipynb create mode 100755 examples/dev/hybrid_topologies/hybrid_topology_maker.py diff --git a/examples/dev/hybrid_topologies/generate_hybrid_topologies.ipynb b/examples/dev/hybrid_topologies/generate_hybrid_topologies.ipynb new file mode 100644 index 00000000..fdb69c64 --- /dev/null +++ b/examples/dev/hybrid_topologies/generate_hybrid_topologies.ipynb @@ -0,0 +1,1051 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "c26a3ebe", + "metadata": {}, + "outputs": [], + "source": [ + "# Ugly import of pygromos for now\n", + "import os, copy, glob\n", + "path = '/home/cchampion/programs/pygromos3'\n", + "cwd = os.getcwd()\n", + "os.chdir(path)\n", + "import pygromos\n", + "os.chdir(cwd)\n", + "\n", + "import numpy as np\n", + "import rdkit\n", + "\n", + "from pygromos.files.topology.top import Top\n", + "from pygromos.files.coord.cnf import Cnf\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "869f7eac", + "metadata": {}, + "outputs": [], + "source": [ + "# This is the path of hybrid_topology_maker.py from which we import the code doing the work.\n", + "\n", + "cwd = os.getcwd()\n", + "os.chdir('/home/cchampion/work/REEDS/input_preparation/hybrid_topologies')\n", + "from hybrid_topology_maker import constructPerturbedTopology, constructHybridConformation, \\\n", + " constructHybridTopology, reduceConformations, PerturbedAtom\n", + "os.chdir(cwd)" + ] + }, + { + "cell_type": "markdown", + "id": "9bf78148", + "metadata": {}, + "source": [ + "# Creation of Hybrid Topologies\n", + "\n", + "In this notebook, we will write functions to create hybrid topologies from a gromos topology of multiple ligands (separate from one another) + a protein. The program will write a hybrid topology for the ligands in water as well as for the complete system. \n", + "\n", + "We will also write a function to \"reduce\" the conformations to match the hybrid topologies.\n", + "\n", + "Finally, we will also create a ptp file for this hybrid topology \n", + "\n", + "Currently, the atoms to include as core will have to be be given when producing the input. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 168, + "id": "f08fc702", + "metadata": {}, + "outputs": [], + "source": [ + "root_dir = '/home/cchampion/work/REEDS/input_preparation/hybrid_topologies/PAK_hybrid_topologies'" + ] + }, + { + "cell_type": "markdown", + "id": "5c5b840d", + "metadata": {}, + "source": [ + "## 1: Reducing conformations for single ligand simulations" + ] + }, + { + "cell_type": "code", + "execution_count": 169, + "id": "969cf05d", + "metadata": {}, + "outputs": [], + "source": [ + "reduced_cnfs_path = root_dir + '/reduced_conformations'\n", + "if not os.path.exists(reduced_cnfs_path): os.mkdir(reduced_cnfs_path)\n", + "\n", + "#reduceConformations(path_cnf = root_dir+'/PAK_openff_ligands.cnf', \n", + "# out_path = reduced_cnfs_path)\n", + "#reduceConformations(path_cnf = root_dir+'/PAK_openff_complex.cnf', \n", + "# out_path = reduced_cnfs_path, contains_protein=True)" + ] + }, + { + "cell_type": "markdown", + "id": "33147eda", + "metadata": {}, + "source": [ + "## 2: Define Atoms to use to make the new topology" + ] + }, + { + "cell_type": "code", + "execution_count": 198, + "id": "a0cb806c", + "metadata": {}, + "outputs": [], + "source": [ + "reduced_tops_path = root_dir + '/reduced_topologies'\n", + "core_top_path = reduced_tops_path+'/PAK_openff_ligand_1.top'\n", + "core_top = Top(core_top_path)\n", + "\n", + "new_ligand_tops = []\n", + "\n", + "# List of all new topologies, sorted and remove top #1 from it\n", + "\n", + "reduced_tops_path = root_dir + '/reduced_topologies'\n", + "top_paths = glob.glob(reduced_tops_path + '/*ligand_*.top')\n", + "\n", + "top_paths = sorted(top_paths, key = lambda x : int(x.split('_')[-1].replace(\".top\", \"\")))\n", + "top_paths.remove(core_top_path)\n", + "\n", + "for p in top_paths:\n", + " new_ligand_tops.append(Top(p))\n", + "\n", + "# Write the connecting points here manually.\n", + "# In the future we can easily work from the maximum common substructure to define those.\n", + "# by iterating over bonds and finding the atom in the core_mapping list (from MCS) which has bonds\n", + "# with things which are not elements of that same list.\n", + "\n", + "connecting_points = []\n", + "\n", + "connecting_points.append((10, 3)) # core (lig1)\n", + "\n", + "connecting_points.append((22, 25)) # lig2\n", + "connecting_points.append((22, 25)) # lig3\n", + "connecting_points.append((22, 25)) # lig4\n", + "connecting_points.append((10, 7)) # lig5\n", + "connecting_points.append((7, 18)) # lig6\n", + "connecting_points.append((10, 6)) # lig7\n" + ] + }, + { + "cell_type": "markdown", + "id": "ad858eb6", + "metadata": {}, + "source": [ + "### 2b: Write Manually the mapping of atoms in the core\n", + "\n", + "note: need to be included atoms that go up to two bonds away from the connecting core atom into the core." + ] + }, + { + "cell_type": "code", + "execution_count": 196, + "id": "288e205e", + "metadata": {}, + "outputs": [], + "source": [ + "atom_mappings = []\n", + "\n", + "# init_id = ID in init_ligand's ligands topology. \n", + "# new_ID == corresponding ID in ligand1's topology.\n", + "\n", + "# Atom mappings of ligand 2 to the core.\n", + "atom_mappings.append(PerturbedAtom(atom='C15', init_lig=2, init_id=22, new_id=10)) # connecting atom. \n", + "\n", + "atom_mappings.append(PerturbedAtom(atom='C13', init_lig=2, init_id=20, new_id=14))\n", + "atom_mappings.append(PerturbedAtom(atom='C14', init_lig=2, init_id=21, new_id=15))\n", + "atom_mappings.append(PerturbedAtom(atom='C16', init_lig=2, init_id=23, new_id=11))\n", + "atom_mappings.append(PerturbedAtom(atom='C17', init_lig=2, init_id=24, new_id=12))\n", + "\n", + "atom_mappings.append(PerturbedAtom(atom='H18', init_lig=2, init_id=49, new_id=41))\n", + "atom_mappings.append(PerturbedAtom(atom='H17', init_lig=2, init_id=48, new_id=43))\n", + " \n", + "# Atom mappings of ligand 3 to the core.\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=3, init_id=22, new_id=10)) # connecting atom. \n", + "\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=3, init_id=20, new_id=14))\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=3, init_id=21, new_id=15))\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=3, init_id=23, new_id=11))\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=3, init_id=24, new_id=12))\n", + "\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=3, init_id=49, new_id=41))\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=3, init_id=48, new_id=43))\n", + "\n", + "# Atom mappings of ligand 4 to the core.\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=4, init_id=22, new_id=10)) # connecting atom. \n", + "\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=4, init_id=20, new_id=14))\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=4, init_id=21, new_id=15))\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=4, init_id=23, new_id=11))\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=4, init_id=24, new_id=12))\n", + "\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=4, init_id=51, new_id=41))\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=4, init_id=50, new_id=43))\n", + "\n", + "# Atom mappings of ligand 5 to the core.\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=5, init_id=10, new_id=10)) # connecting atom. \n", + "\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=5, init_id=11, new_id=15))\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=5, init_id=12, new_id=14))\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=5, init_id=14, new_id=12))\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=5, init_id=15, new_id=11))\n", + "\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=5, init_id=40, new_id=41))\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=5, init_id=38, new_id=43))\n", + "\n", + "\n", + "# Atom mappings of ligand 6 to the core.\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=6, init_id=7, new_id=10)) # connecting atom. \n", + "\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=6, init_id=5, new_id=15))\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=6, init_id=6, new_id=14))\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=6, init_id=8, new_id=12))\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=6, init_id=9, new_id=11))\n", + "\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=6, init_id=37, new_id=41))\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=6, init_id=36, new_id=43))\n", + "\n", + "# Atom mappings of ligand 7 to the core.\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=7, init_id=10, new_id=10)) # connecting atom. \n", + "\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=7, init_id=11, new_id=15))\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=7, init_id=12, new_id=14))\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=7, init_id=14, new_id=12))\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=7, init_id=15, new_id=11))\n", + "\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=7, init_id=40, new_id=41))\n", + "atom_mappings.append(PerturbedAtom(atom='x', init_lig=7, init_id=38, new_id=43))" + ] + }, + { + "cell_type": "code", + "execution_count": 199, + "id": "9afa872b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Working on addition of ligand 2 has: 14 atoms.\n", + "Working on addition of ligand 3 has: 12 atoms.\n", + "Working on addition of ligand 4 has: 15 atoms.\n", + "Working on addition of ligand 5 has: 13 atoms.\n", + "Working on addition of ligand 6 has: 17 atoms.\n", + "Working on addition of ligand 7 has: 13 atoms.\n" + ] + } + ], + "source": [ + "# for am in atom_mappings: print (am)\n", + "\n", + "constructHybridTopology(core_top, new_ligand_tops, atom_mappings, connecting_points, \n", + " path_out_top=reduced_tops_path+'/PAK_openff_hybrid.top')" + ] + }, + { + "cell_type": "markdown", + "id": "ee69bead", + "metadata": {}, + "source": [ + "### 3: Append protein to the topology" + ] + }, + { + "cell_type": "code", + "execution_count": 176, + "id": "2804507c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "com_top @topo /home/cchampion/work/REEDS/input_preparation/hybrid_topologies/PAK_hybrid_topologies/reduced_topologies/PAK_openff_hybrid.top /home/cchampion/work/REEDS/input_preparation/hybrid_topologies/PAK_hybrid_topologies/reduced_topologies/PAK_openff_protein.top @param 1 @solv 1 > /home/cchampion/work/REEDS/input_preparation/hybrid_topologies/PAK_hybrid_topologies/reduced_topologies/PAK_openff_hybrid_complex.top\n", + "red_top @topo /home/cchampion/work/REEDS/input_preparation/hybrid_topologies/PAK_hybrid_topologies/reduced_topologies/PAK_openff_hybrid_complex.top @atoms 1:a > /home/cchampion/work/REEDS/input_preparation/hybrid_topologies/PAK_hybrid_topologies/reduced_topologies/PAK_openff_hybrid_ligands.top\n" + ] + }, + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 176, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "command = \"com_top @topo \" + reduced_tops_path+'/PAK_openff_hybrid.top ' + reduced_tops_path+'/PAK_openff_protein.top'\n", + "command += \" @param 1 @solv 1 > \" + reduced_tops_path+'/PAK_openff_hybrid_complex.top'\n", + "\n", + "print (command)\n", + "os.system(command)\n", + "\n", + "# We can then even follow this by a red_top to regain the nice formatting of the gromos topology\n", + "# since it is a hybrid topology, it will understand that 1:a means all ligands as they have bonds between one another.\n", + "# calling the same thing with 2:a would make a nicely formatted hybrid topology for the complex. \n", + "\n", + "command2 = \"red_top @topo \" + reduced_tops_path+'/PAK_openff_hybrid_complex.top @atoms 1:a' \n", + "command2 += ' > ' + reduced_tops_path+'/PAK_openff_hybrid_ligands.top'\n", + "\n", + "\n", + "\n", + "print (command2)\n", + "os.system(command2)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "40cc8322", + "metadata": {}, + "outputs": [ + { + "ename": "IndexError", + "evalue": "list index out of range", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m constructHybridConformation(new_ligand_tops, connecting_points, \n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mpaths_input_cnfs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpath_out_cnf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mreduced_cnfs_path\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'/PAK_hybrid.cnf'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m )\n", + "\u001b[0;32m/home/cchampion/work/REEDS/input_preparation/hybrid_topologies/hybrid_topology_maker.py\u001b[0m in \u001b[0;36mconstructHybridConformation\u001b[0;34m(new_ligand_tops, connecting_points, paths_input_cnfs, path_out_cnf)\u001b[0m\n\u001b[1;32m 903\u001b[0m \u001b[0mlig_cnf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mCnf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcnf_path\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 904\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 905\u001b[0;31m \u001b[0mlig_core\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlig_rgroup\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfindAtomsInCoreAndRGroup\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_ligand_tops\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconnecting_points\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 906\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 907\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mpos\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mlig_cnf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mPOSITION\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontent\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mIndexError\u001b[0m: list index out of range" + ] + } + ], + "source": [ + "hybrid_topology_path = reduced_tops_path+'/PAK_hybrid_topology.top'\n", + "\n", + "paths_input_cnfs = sorted(glob.glob(reduced_cnfs_path+'/ligand_*.cnf'))\n", + "\n", + "constructHybridConformation(new_ligand_tops, connecting_points, \n", + " paths_input_cnfs, path_out_cnf = reduced_cnfs_path + '/PAK_hybrid.cnf'\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "8dd7ebf0", + "metadata": {}, + "source": [ + "## 4 Make a manual mapping of the core atoms of molecule 1 onto molecule 2\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13617ee3", + "metadata": {}, + "outputs": [], + "source": [ + "# core_mappings = List of Tuple [(id_in_mol1, id_in_mol2)]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "c32d59e5", + "metadata": {}, + "outputs": [], + "source": [ + "core_mappings = []\n", + "\n", + "# Doing it manually between molecule 1 and molecule 2\n", + "\n", + "# first benzene\n", + "core_mappings.append((10, 22))\n", + "core_mappings.append((11, 23))\n", + "core_mappings.append((12, 24))\n", + "core_mappings.append((13, 19))\n", + "core_mappings.append((14, 20))\n", + "core_mappings.append((15, 21))\n", + "#first benzene substituents\n", + "core_mappings.append((1, 1))\n", + "core_mappings.append((41, 49))\n", + "core_mappings.append((42, 47))\n", + "core_mappings.append((43, 48))\n", + "\n", + "#second bycicle benzene substituents\n", + "\n", + "core_mappings.append((16, 9))\n", + "core_mappings.append((17, 8))\n", + "core_mappings.append((18, 7))\n", + "core_mappings.append((19, 13))\n", + "core_mappings.append((20, 12))\n", + "core_mappings.append((21, 10))\n", + "\n", + "core_mappings.append((22, 6))\n", + "core_mappings.append((23, 5))\n", + "core_mappings.append((24, 4))\n", + "core_mappings.append((25, 14))\n", + "\n", + "# NHCH3\n", + "core_mappings.append((26, 3))\n", + "core_mappings.append((27, 2))\n", + "core_mappings.append((46, 35))\n", + "core_mappings.append((47, 32))\n", + "core_mappings.append((48, 33))\n", + "core_mappings.append((49, 34))\n", + "\n", + "\n", + "# \n", + "core_mappings.append((32, 11))\n", + "core_mappings.append((44, 37))\n", + "core_mappings.append((45, 36))\n", + "\n", + "# long tail\n", + "core_mappings.append((28, 15))\n", + "core_mappings.append((29, 16))\n", + "core_mappings.append((30, 17))\n", + "core_mappings.append((31, 18))\n", + "\n", + "# long tail hydrogens\n", + "core_mappings.append((50, 38))\n", + "core_mappings.append((51, 39))\n", + "core_mappings.append((52, 40))\n", + "core_mappings.append((53, 41))\n", + "core_mappings.append((54, 42))\n", + "core_mappings.append((55, 43))\n", + "core_mappings.append((56, 44))\n", + "core_mappings.append((57, 45))\n", + "core_mappings.append((58, 46))\n", + "\n", + "\n", + "#core_mappings.append((20, 12))\n", + "#core_mappings.append((21, 10))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "72818f6c", + "metadata": {}, + "outputs": [], + "source": [ + "#sorted(core_mappings)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "855a2f63", + "metadata": {}, + "outputs": [], + "source": [ + "def reassignParamsToCore(topology1, topology2, atom_mapping):\n", + " \"\"\"\n", + " This function will re-assign parameters to molecule 2 (topology 2)\n", + " based on those from the core of molecule 1.\n", + " \n", + " Q and atom type code\n", + " \n", + " \"\"\"\n", + " \n", + " new_top2 = copy.deepcopy(topology2)\n", + " \n", + " for atom in new_top2.SOLUTEATOM.content:\n", + " #print (str(atom).replace('\\t', ' '))\n", + " \n", + " atomJ = atom.ATNM\n", + " atomI = None\n", + " # Check how to change the params\n", + " for i, j in atom_mapping:\n", + " if j == atomJ:\n", + " atomI = i\n", + " break\n", + " \n", + " if atomI is not None:\n", + " \n", + " new_q = topology1.SOLUTEATOM.content[atomI-1].CG\n", + " new_iac = topology1.SOLUTEATOM.content[atomI-1].IAC\n", + " \n", + " #print (str(atom.CG) + ' -> ' + str(new_q))\n", + " #print (str(atom.IAC) + ' -> ' + str(new_iac))\n", + " \n", + " # Reassign values:\n", + " \n", + " atom.CG = new_q\n", + " atom.IAC = new_iac\n", + " \n", + " return new_top2" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "d9409100", + "metadata": {}, + "outputs": [], + "source": [ + "top1 = Top('/home/cchampion/work/REEDS/input_preparation/hybrid_topologies/PAK_hybrid_topologies/reduced_topologies/PAK_openff_ligand_1.top')\n", + "top2 = Top('/home/cchampion/work/REEDS/input_preparation/hybrid_topologies/PAK_hybrid_topologies/reduced_topologies/PAK_openff_ligand_2.top')\n", + "\n", + "new_top2 = reassignParamsToCore(top1, top2, core_mappings)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "353f7476", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'/home/cchampion/work/REEDS/input_preparation/hybrid_topologies/PAK_hybrid_topologies/reduced_topologies/PAK_openff_ligand_2_reparamcore.top'" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "new_top2.write('/home/cchampion/work/REEDS/input_preparation/hybrid_topologies/PAK_hybrid_topologies/reduced_topologies/PAK_openff_ligand_2_reparamcore.top')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "62ee98fa", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dfa490b5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f6edc249", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "8a400119", + "metadata": {}, + "source": [ + "## Maximum common substructure with RDKit " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cf1c7877", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "334b81cf", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a6bc1bb9", + "metadata": {}, + "outputs": [], + "source": [ + "import rdkit\n", + "from rdkit import Chem\n", + "from rdkit.Chem import AllChem\n", + "from rdkit.Chem import rdFMCS\n", + "from rdkit.Chem import Draw\n", + "\n", + "from rdkit.Chem import PDBWriter\n", + "\n", + "from datetime import datetime\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4ab6e967", + "metadata": {}, + "outputs": [], + "source": [ + "# Read in all molecules:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "dc316773", + "metadata": {}, + "outputs": [], + "source": [ + "path_cnfs = sorted(glob.glob('/home/cchampion/work/REEDS/input_preparation/hybrid_topologies/PAK_hybrid_topologies/mcs/*desolv.cnf'))\n", + "cnfs = [Cnf(i) for i in path_cnfs]\n", + "\n", + "path_tops = sorted(glob.glob('/home/cchampion/work/REEDS/input_preparation/hybrid_topologies/PAK_hybrid_topologies/reduced_topologies/PAK_openff_ligand_*.top'))\n", + "tops = [Top(i) for i in path_tops]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "94e55afb", + "metadata": {}, + "outputs": [], + "source": [ + "mols = [Chem.MolFromPDBBlock(cnf.get_pdb(rdkit_ready=True), removeHs=False) for cnf in cnfs]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9b732f03", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABkAAAAMgCAIAAAD0ojkNAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdeVxN+f8H8PdtL6kksoUYWaIY2WuoEYmSRhHZTcYMss2UbWp8LYWxNGZMxaRsibLUEG1ooR3Z9yJLWUppvfee3x9HVz9DWs7t3ur1fPjjfM499/N+m8ntnPf9LDyGYQgAAAAAAAAAAEBayUg6AQAAAAAAAAAAgKqggAUAAAAAAAAAAFINBSwAAAAAAAAAAJBqKGABAAAAAAAAAIBUQwELAAAAAAAAAACkGgpYAAAAAAAAAAAg1VDAAgAAAAAAAAAAqYYCFgAAAAAAAAAASDUUsAAAAAAAAAAAQKqhgAUAAAAAAAAAAFINBSwAAAAAAAAAAJBqKGABAAAAAAAAAIBUQwELAAAAAAAAAACkGgpYAAAAAAAAAAAg1VDAAgAAAAAAAAAAqYYCFgAAAAAAAAAASDUUsAAAAAAAAAAAQKqhgAUAAAAAAAAAAFINBSwAAAAAAAAAAJBqKGABAAAAAAAAAIBUQwELAAAAAAAAAACkGgpYAAAAAAAAAAAg1VDAAgAAAAAAAAAAqYYCFgAAAAAAAAAASDUUsAAAAAAAAAAAQKqhgAUAAAAAAAAAAFINBSwAAAAAAAAAAJBqKGABAAAAAAAAAIBUQwELAAAAAAAAAACkGgpYAAAAAAAAAAAg1VDAAgAAAAAAAAAAqYYCFgAAAAAAAAAASDUUsAAAAAAAAAAAQKqhgAUAAAAAAAAAAFINBSwAAAAAAAAAAJBqKGABAAAAAAAAAIBUQwELAAAAAAAAAACkGgpYAAAAAAAAAAAg1VDAAgAAAAAAAAAAqYYCFgAAAAAAAAAASDUUsAAAAAAAAAAAQKqhgAUAAAAAAAAAAFINBSwAAAAAAAAAAJBqKGABAAAAAAAAAIBUQwELAAAAAAAAAACkGgpYAAAAAAAAAAAg1VDAAgAAAAAAAAAAqYYCFgAAAAAAAAAASDUUsAAAAAAAAAAAQKqhgAUAAAAAAAAAAFINBSwAAAAAAAAAAJBqKGABAAAAAAAAAIBUQwELAAAAAAAAAACkGgpYAAAAAAAAAAAg1VDAAgAAAAAAAAAAqYYCFgAAAAAAAAAASDUUsAAAAAAAAAAAQKqhgAUAAAAAAAAAAFINBSwAAAAAAAAAAJBqKGABAAAAAAAAAIBUQwELAAAAAAAAAACkGgpYAAAAAAAAAAAg1VDAAgAAAAAAAAAAqYYCFgAAAAAAAAAASDUUsAAAAAAAAAAAQKqhgAUAAAAAAAAAAFINBSwAAAAAAAAAAJBqKGABAAAAAAAAAIBUQwELAAAAAAAAAACkGgpYAAAAAAAAAAAg1VDAAgAAAACAxmnatGmvX79mjy9fvrxq1SrJ5gMAALWGAhYAAAAAADROcXFxpaWl7PHr16/T09Mlmw8AANQaClgAAAAAAAAAACDV5CSdAAAAAAAAgLhMnz5dUVGRiF69etWiRQtJpwMAALWEAhYAAAAAADRamzdvbt26NRHFx8f7+flJOh0AAKglFLAAAAAAAKDR0tbWbtu2LRG1bNlS0rkAAEDtYQ0sAAAAAACoV0+ePBEIBOxxSUnJixcvJJsPAABIPxSwAAAAAACgXo0YMeL58+fscWJi4owZMzgPIRAI/v33Xw8PDw0NDfZMjx49nJ2dOQ8EAAD1AwUsgAamoKDg7t27oubDhw/fvHkjwXwAAAAApNCmTZvGjRuXkJCgrKzMnmnXrt3o0aMlmxUAANQaClgADUxKSsqiRYtEzTVr1kRFRUkwHwAAAIBayMnJefbs2bNnz16/fs1559evX1+7di2Px7O0tOS8cwAAkAgs4g4AAADcy8/PV1VVlZWVJSKBQFBYWKiuri7ppABAiixfvlxRUZGIXr9+LZrlx4ny8vIZM2aUlJQsXLgQQ64AABoNjMACaHgKCwszKuTl5Uk6HQCATxg1atT169fZ4xs3bowcOVKy+QCAtAkICDh16tSpU6c8PT2JiGEYrnp2c3NLTU3t0qXLhg0buOoTAED6lZeXl5aWippFRUVCoVCC+XAOI7AAGp6HDx9u2bKFPb5586ZkkwEAAACoOw8Pj/T09F27drVs2bIu/Vy6dGnTpk0yMjJ79+5VVVXlKj0AAOm3d+/ejIwMLy8vtmlqaurj42NoaCjZrDiEAhZAw9OnTx9/f3/22NHRUbLJAAB8TnFxcWFhIXsg6VwAQKrx+fzff//91atX8fHxvr6+tV64qqiIfvzRRSAQuLq6mpiYcJskAEDtjBgx4ty5c+zx6dOnMzIyfvnlF4lm1FChgAXADQ8PDz6fv3r1arbZvXv3mJiYdu3aSTYrAIDKhEJhUVGRaEhCSUmJjIyMgoKCmML9+OOPKioqRFRUVCQjg1ULAOCDe/fuiY6HDx8+fPjwR48ezZ49OyYmZuzYsdOmTfvzzz+bN29e025dXSk3N8rGZqu7uzOn+QIA1F5iYqLoODc39/79++KLJRQKy8rK2GMOp2ZLCdxNAnBDKBRWnmDM5/PF9HmhoKBQeSHk5s2bswugAgB80c2bN4cPHy5qrly5cvfu3eIL5+fnFxsbGxsbu3fvXvFFAYDGoXPnzlFRUd7e3s2aNdu3b1+fPn1iYmJq1EN0NO3cSc+fy61e/QvujgCgaQoODv6mQuNbbQYjsAAaDD6fP2bMmHHjxgUGBopO7tq1S4IpAQAAAHCFx+M5OTmZmJjMmDEjOTl55MiRS5e6rF27QVn5y+99+5ZmzSKGIXd36t9f/LkCAFSbUCg0NTVlj1+8eCHWCc52dnaiNbAGDRokvkASgQIWAGf+/vvv48ePs8dPnjzhvP9ff/01MjLy5s2bs2bNUlNT47x/AGgKGIYRbU8jEAgkmwwAwH/17NkzISHh999///XXX1NSxvTpQ3v3krHxF97l7ExZWfT114SFZQBA2sjIyIieEwMDA9PS0iSbT8OFAhYAZ3744Ydff/2VPe7atSu3ncfExLBb6gQEBKB6BQC1dufOHdEswszMzDVr1nAeYsuWLTIyMjExMUpKSuwZfX190dqlAABfJCcn5+LiMnr0uJkze92/T6am5OpKv/5K8vKfvj40lPbuJSUlCgj47DUAABIkWgRGuTpjSmuurKysKdTFsAYWgLjw+fytW7eKltCrixcvXkyZMkUgEPz2229mZmZ17xAAmqzu3btfquDg4MB5/2fPnnV1df35559v3LghWrhdRkamWbNmnMcCgMatb1/95GSemxsxDK1bR/37U3r6Jy579YqcnIiINm4kff16zhEAoDaCgoIuXLjAVW8CgWDKlCnDhw9XV1f38PAQnY+IiOjduzdXUaQBClgA4uLh4bFs2bJhw4bVcZsJoVDo6Oj4/PnzESNGrFixgqv0AABY0dHRBQUFnHSVmZk5depUgUDg7u5uZGTESZ8A0JTJy5O7O8XFkZ4eZWTQoEHk7k4fzX5WV6fFi8nMjBYtklCWAABV8vf3Fx2bmJgYGxs7OjpaWFiEhYXVvXOGYebPnx8cHKysrKynp8duAM1SU1OTlZWtewjpgQIWADfmz5+/YMECUTM6OnrWrFldu3ZNSUnp16/foUOHat3z+vUbIyMjtbW1Dx061Mg+gABA4h4/fjxu3DgjI6MbN27Usavi4mJbW9uXL19aW1uvWrWKk/QAAIho8GBKS6MffyQ+n377jUaNojZt6K+/3r/q6UkaGhQRQa6uEs0SAOAz7O3tRce6urqOjo4//fRTcXGxjY1N3XdqdnFx8fX1VVFRCQsL69u3bx17k3Ky7u7uks4BoDFQVlauPJ9ZQ0Ojffv2M2fOfPjwYVpaWnBw8IMHD0aPHi1fw4UZLlyg9esHtWx5Y/fuDYaGhlxnDQBNS8uWLR0cHERLU5mYmHTu3Dk6OvrmzZv79u3r0aNHz549a935999/Hx4erqend+rUKTGt7wAATZaCAo0dS8OG0blzNH06RUbSzZv03XfUvDlFRJCCAl24QFFR9OwZGRhQxYccAIA04vF4FhYWysrKERERJ0+eVFdXHzx4cO26Wr9+/bp16xQUFEJCQr799ltu85RCPIZhJJ0DQCMXEBAwf/78oqKiXr16HT58uPrzkHNzqV8/ys6mNWuYtWt5Yk0SAJqs4uLiH374ISAggMfj/fLLLxs2bBCtXVV9O3cGLFw4Q01N7dKlS3WpggEAVC0/n5o3p9atafNmOnOGAgNpzRrS0iJnZ1q6lLZulXR+AADVtnPnTmdnZ6FQ6OLiUnntqmry9Q1wcpohKysbGBg4ceJEcWQobVDAAqgP6enpkydPvnPnTufOg9aujZ827cszARmGxo+n0FAyMaHoaJLDlqEAIE4+Pj4//fQTn8+3tLQ8cOCAhoZG9d8bHU22tkzPnltdXLra2NiIL0kAAJaWFuXk0LBh71fIYgtYOTnUurWkMwMAqAk/P7/vv/9eIBCsXLll3bplvGoPWggJoaVL+Tye5cqVdt9//704c5QiKGAB1JOCgoL583+6eXNbWlrLmTNp506qeksuT09ydaUWLSg9nTp1qq8sAaAJi4iIcHBwePXqVY8ePUNCUnv2rNY0wKwsMjKi3Fxas4bWrhV3jgAARERaWvTyJaWnk6MjjRtH7dqRs7OkcwIAqJWTJ0/On79GWTlpyBBFP79qDVw4fZrGj6fyctq6tXzJkpqtUdOgoYAFUK8CAujHH+ndO+renQ4fps+tapWURCYmVF5Ox47R+PH1myIANGGPHz/+7rvvmjXzTEkx9fOjL45GLymhb76h5GQaNYpOnSLsMwEA9YMtYBHRokV09Cj9/DNFRtLs2fTdd5LODACg5qKjS8ePVywspAkT6NAhUlSs6uJLl2jkSHr3jlaupPXr6ytF6YBdCAHq1fTplJJCBgZ0+zYNHkw7dnzimoICsrensjJauhTVKwCoVzo6OufOne/QYURhIdnb0+rVJBRWdf1PP1FyMunq0sGDqF4BNHV8Pj80NFTUvHfv3rVr18QddN064vEoJYVOnaKJE8nRkd68EXdMAACOmZkpxsSQlhYdO0YWFlRQ8Nkrr14lS0t6945++KHJVa8II7AAJKKkhFxcyMuLiMjWlvbsoY9WmwkIoD17KDycsJEXAEiEjw8tWEDl5WRhQQcPUosWn7jmjz9o0SJSVaWLF6nau1MAQKNVUFDQpUuX3Nxctrl9+/YXL15s3LiR2yi3blFkJBkbk2iz+MxMUlKiEydo2TIqLKQ2bcjHh6ysuA0LACB2N2/SqFH05AkZGdHp06Sl9fEF9+6RiQk9f062thQU1BS/O8QILAAJUFKiHTvo4EFq3pxCQmjyZOLxKCrq/avjxpGuLp07RytXSjRLAGjCnJwoKoq0tSk8nAYMoIyMjy8oKqJNm4jHo3/+QfUKAOoJn08zZtDChRQZ+eFkp06krU1OTpSRQcOH0/PnZG1N06dTYaHkEgUAqLmePSk2lrp1o5QU+uYbevLk4wtu3qQ3b8jCgg4daorVK0IBC0CCHBwoNZVGjKDFi6lzZ1q8mEpL37/09i1t3EjJydgNGgAkxsSEkpLIyIju36chQ+ivv+jw4Q+vHj1KcXG0bRt17y65FAFAypSVlYVVuHHjBuf9b9xISUnUuTM5OX3i1c6dKTqaNm0iJSXat48MDSk+vozzHAAAxKdzZzp/nvr0oZs36fffafVqYqfMMQw5O5OVFe3fT8uWkYKCpBOVEBSwACSpWzeKiSEdHerYkSwsyMPj/Xk1NVq5kgYMoKVLJZofADRtHTtSXBzNmUNlZfT4MTk40KlT719avpw0NMjEhE6coLw8iWYJAFKDz+cnVcjMzOS288uXad06kpGhf/4hNbVPXyMjQz//TKmpZGRE2dk0e/aUefPmFRUVcZsJADRZhYWFp0Q3Q0RXr169ffs2tyHatqVz58jXl9q0oW3b6MCB9+f37qXbt+nuXTpxgi5d4jZmg4ECFoC0WLOGAgLo7t0PZ9zdJZYMAABLUZF276bLl6lbN5owgZYtI9GT4JMnFBVF16833bsoAPiIiorK2gpjxowhojdv3nCy5G5pKc2YQWVltHAhmZp+4eJevSghgTZuTHrw4ISPj8/AgQNTU1PrngMAwIsXL37++WdRMzAw8N9//+U8iqYmzZ1LROTkRO7uH/am0Namnj1JV5d0dTmP2TCggAUgLdTUaP16WrLkwxl1dcllAwBQSa9eRERdupCNDa1b9/7kV1/RzJk0eTJZWEgwNQCQXgzDWFtbjx49+vHjx3Xsys2Nrl6l7t2pmovCy8vTkiUDU1NTDQ0Nr1+/PnjwYFdX17IyzCgEgIakbVtycqIVK943NTRo8GCysCBtbYmmJTkoYAF81r59+/z9/UXNSZMmvXr1SqwRJ0+mkhJKSqKSEpo/n3JyxBoNABqD0NDQd+/esce5ubnR0dFiDbd6NR05Qjdvvm+2akU2NmINCAANhqysrKGhoaipra0tJyd3+/btiIgIQ0PDA6JpMDV38SJt2UJycuTvX7MNmg0MDC5duuTi4sIwjKen54ABAy5fvlzrNAAAiKigoOBYhTt37og73OLFFBdHycnvm23avP9asWlCAQvgsx4/fpyVlSVqpqSklIpWWRebXbvo7Vv6+2/6+2/q149iYsQdEAAatuXLl798+ZI9vn379oYNG8Qarlkz2rSJli0TaxAAaJBUVFQiK+0O6ODgsG7dumvXrk2YMOHNmzeOjo5jx4599uxZTbstKqKZM0kgIFdXGjSoxlkpKSl5eHhER0d36dLl6tWrQ4YM8fT0XFlpp+f169fHxcXVuF8AaKpKSkoyKuSIf8SBggLt3ImVkd9DAQtAwn79lQoK6NCh981u3ej+fdq2jczN6elT+vZbcnUlgUCiKQIAVDJhAvF49OoVxcSQmRm9eCHphABAirVu3TokJCQoKEhTU/PUqVN9+/Y9duxYjXrYtCnlzh0yNKQ1a2qfxjfffJORkbFo0SJZWdm2bdtevXpV9NL169dzc3Nr3zUANDGtWrX6tYKxsbGYolSe8TxiBHXuTESUlkbbt4spYMOAAhZAVfbu3TuyQi2+M/yi/fvpf/+jMWNIVfXDyfbtqWNHOn2a3NxIRoY8Penbbyk7m/PgANBIhIeHBwcHBwcHnz9/Xkwh8vKoXTvq1u1908uLzMzol18oJoYGDqSUFDGFBYBGws7O7tq1a2PHjs3JybG1tbW3t3/9+nV13hgZGbl27UATk6kBAXXdNl5FRWXHjh23b99u3759nToCAPj/nj59ysluFSJ//klDh1KPHh+GnW7ZQj/+SGPH0pIltGIFcRqtIUEBC6AqkyZNOlxBm+u18u7do59+IiLavPkTu0HLypK7O0VGUrt2dP489e1LlTZsBQD44N69e7du3bp16xbnm9azAgJIT48UFMjJ6f2Zrl0pIoKiosjUlLKyyNiY9uwRR2QAaDzatm0bGhrq7e2tqqp65MgRfX39sLCwqt+Sn58/Z84chmEsLfsYGHCTBlu9SkpKGlPh3Llz3HQNAE2AkpKSQaXPIx0dHQUFhSFDhkybNq28vJyTEAEBtHAhpaURn0/Dh78/2aYNbdxI27aRvDx5eND8+SQUchKtgUEBC6AqysrKLSvIyMgQUUJCAic9l5aSvT29fUv29u83Sf2kESMoPZ1GjaKXL2n+/PLVq3/j8/mcJAAAjcaCBQtWrVq1atWq6dOnc955ejr98APl5tJ/i2OtWtHZs+TiQqWlNHcuzZtH2OALAKrA4/GcnJyuXr36zTffPH/+3Nraet68eYWFhZ+73tnZOSsra8iQIZU3reeEoaGhX4XBgwdz2zkANGLt27c/JFr8hWj+/PkGBgavX78+cOCAnZ1dSUlJHfs/eZLmzCGGoS1b6LvvPn518mQ6fpxUVMjbm6ZOJY4qZg0JClgANXDgwIFhw4ZNnz69qKiojl0tWULp6fTVV+Tr+4UrW7em06dpwwbS0Ji/fr37N998U3lpeQCAj4SGhm7naIGEFy/I2pqKi2nRIpo16xMXyMmRhwft30/KyuTjQ2ZmJIbJ1gDQqOjq6sbExGzfvl1BQcHHx8fAwOCT059Pnjzp7++voqKyd+9eWVlZbnNQVFRsU0FJSYnbzqEe3L1791SluQkhISGPHz+WYD7QlH3zzTcxMTFaWlonTpywsLB4+/ZtrbuKiaFJk4jPJ3f3z67abmlJ0dGkqUmBgTRmDH3+K4DGCQUsgM+ytra2qbQ//JYtW1RVVZWUlPbt2zd48OCbom3kay44mHbtIkVFOnz4E5MH/0tGhlasIF9fJ11d3YsXLxoYGBw5cqTW0QGgMfn6669FT19qampdu3adPn36kiVLHB0d61hq5/Np0iR68oSGDqXNm6u6cupUOn+edHQoPp7mzfv30qVLdYkLAI2ejIyMs7Nzampq//79Hz58aGZm5uzsXHmv55cvX86bN4+IPD099fT0JJcpSKmMjIwDBw6Imnv27Ll7964E84EmzsjI6MKFCx06dDh//ryZmVnt9oVITqbx46mkhH76idzcqrpy0CCKjKTWrSkqimxshHl5+bXMuyFiAKAmrl+/3rt3byJSVlbevn17LXrIzGQ0NRkixsurxu/Ny8uzs7Nj//E6OTmVlJTUIgEAaNxCQ0PV1dWJyNDQ8P79+7XuZ+FChohp25bJzq7W9S9eMLNm3SQiRUVFHx+fWscFgKajvLzcw8NDXl6eiHr16pWSksKeZ+92zMzMhEIh50GfPn169uxZUTMmJubRo0ecRwGxCg4OnjJliqhpaWkZFRUlwXwAGIZ59OhRt27diKhnz56PHz+u0Xtv32Zat2aIGEdHRiCo1lvu32f09JjBgzf17t07u5r3ag0fClgANVZUVPT999+zVaRp06YVFBRU/71lZcyQIQwRM24cU7tbMqFQyI66J6Kvv/767t27tekFABq127dv9+rVi4g0NTXPnDlTix7272eIGEVFJjGxBu8qLy93cXERfTwWFRXVIjQANDWJiYk9evQgIjk5ORcXFz8/PyJSV1fPzMyUdGogpYKDg42MjP6ooK+vjwIWSIPnz5/37duXiDp16nTnzp1qvisri+nYkSFirK2Z8vIahHv8+AX74amnp9dECvGYQghQY8rKyj4+Pv7+/s2aNdu3b5+RkdHly5er+d61az3fvk3s1IkCAojHq010Ho/n7OwcHx/fpUuXtLS05cuXt2rVSvTqrl27RE+PANBk6enpXbp0ydbW9vXr15aWlp6enkxN9lu+fPn9hoM7d9LAgTWIKycn5+HhcfDgQRUVlX379pmYmGDNPgD4ooEDB6alpS1evFgoFHp6erJfE27btq1jx46STg2kl6ysrHIFdqslAInT1taOiYkZNmxYZmamiYlJdR4SX7x4sWTJtqwsMjWlw4dJTq4G4Tp0aB0fHz9o0KA7d+4MGTIkIyOj9qk3EPinDlBL06dPT0lJMTAwuH379pAhQ3bs2PHFt4SFha1fv+LhQ7MjR3JbtKhTdCMjo7S0tHnz5u3YsaPyvoRCoVAgENSpawBoFJo3b3706FEPDw+GYVxdXW1sbKq5qujLly+dnW8UFdG8eVXtkVoFBweHhIQEXV3d1NRUIyOjmJiY2vQCAE2JsrLytm3bLly4oKKioqKiIisrm5OTg1saqELXrl3nVNDR0ZF0OgDvaWhonD171sLC4sWLF6ampnFxcVVcnJeXN3r06ODgpY6Ov584QbXYUkJTUzMyMnLkyJHPnj0bMWJEo1+HFAUsgNrr0aNHYmLiokWLSkpKFi9ebGtr++bNm89d/OTJk1mzZjEM4+7uPmBAq89dVn3q6up///23trZ23bsCgEaJx+O5uLiEhoZqaGicPHly0KBBt27dqvotfD5/8uTJqamDHB0jvbxqH9rQ0DApKWnkyJG5ubkTJ05csmTJ/fv32Zeys7MXL15c+64BoPHKyMgoKioqKysTCASurq7ffvvtw4cPJZ0UAEDNqKionDhxwt7enq1PnT59+pOXFRUVWVtbX7lyRU9Pb8sWx+bNaxlOVVU1LCyMHXdvbm4eGRlZ+9SlHgpYAHWipKS0Y8eO4OBgDQ2NY8eO9evX7+LFi/+9jM/nOzg4vHz5csyYMcuXL+c2h4KCgq8reHp6cts5ADR0lpaWycnJvXv3vnXr1qBBg44fP17Fxa6urlFRUc2bq3p49FRQqFNcLS2t8PDw5cuXe3t7Jycn5+XlsecLCwvPnTtXp64BoDF6+PDhL7/8QkQBAQHh4eHsfl69e/fesWNHjSZBQ1PQvn37AQMGiJpDhw5t3bq1BPMB+IiCgsLBgwednJyKiopsbGwOHz780QXl5eUTJ06MjY3V0dGJiIio46AERUXFwMBAR0fHwsLCAwcO+Pr6il6Ki4tLTEysS+fSRbJLcAE0Gg8fPhw8eDARycnJubm5Cf7/7hErV64kovbt2+fm5nIbt7i4WENDQ9TcuXPnsmXLuA0BAI1AQUHBxIkTqWJYluBTO9wcPHiQiOTl5S9cuMBt9GHDhok2F7t165ahoSG3/QOA+Dx8+HDPnj2iZlBQ0NWrVzmPIhAIhg8fTkSireXevHnjxK7GRzRq1KiabukFTcSbN2/mzJkzdOhQSScC8AlCoZBdnlhWVtbb21t0XiAQTJo0iYhatWp169YtrsIJBAJfX9/79+/r6emJTq5Zs4ZdC7VxwAgsAG507tz5woUL7GPhb7/9ZmNj8+rVK/almJgYT09PGRmZgIAALS0tyeYJAE2TqqpqUFCQh4eHjIyMp6fn+PHj8/PzK19w9epVduFkLy8vExMTzhNwdXW1t7e3t7fH/EGAhiUrKyswMFDUDAsLu3nzJudRtm7dev78+Xbt2v3xxx/sGQ0NDW9v7yNHjmhpaZ09e7Z3794+Pj6cx4WGTk1NLSwsLCEh4caNG5LOBeBjPB7Pw8Nj+/btQqHwhx9+cHd3JyKGYebPn3/48GF1dfXw8PDu3btzFXWhXkoAACAASURBVE5GRmbu3LlyNVoHvqFBAQuAM/Ly8h4eHsePH9fU1AwNDe3bt29cXNyLFy+mTp0qEAjc3d3NzMwknSMANF3s2KuwsDBNTc2wsLCBAweKbvffvHlja2v77t27adOm/fDDD+KIvmDBgg0bNmzYsGHp0qXi6B8AGq6bN2/++uuvROTr66upqVn5pYkTJ16/ft3GxiY/P3/evHl2dnYvX76UUJogjWRkZCwtLYnoxIkTks4FGp6oqKhZs2aJmrNnz46KiuI8irOzs5+fn6ys7G+//ebs7Ozq6urj46OsrBwaGvr1119zHo6I3rx5s71Co5o/iAIWAOesra0vX748bNiwJ0+emJqaDh06lN0Sgp1FyDlFRcWUlBRR09HR0dXVVRyBAKBxsLCwSE9P79+//507dwYPHhwSEiIUCqdOnXr//v1+/fp5e3uLKW6HDh2++uqrr776qmPHjmIKAQBicv/+ffcKV65c4bZzPp8/Y8aM4uJiJycnthLxkdatWx87diwoKKhFixZHjx7V19evei0/aGqsra2J6OTJk5JNo6ioKDMzU9TMzs6u5ua/IEGlpaWVB6Tn5+eXlpaKI9CMGTMOHDigoKDg5eW1adMmBQWFkJAQcQx4Z8nKympWUFZWFlMUiUABC4B7Ojo6586dY1fCevr0qYKCwvbt22VlZcURi8fjde3aVdRUV1fHLEUAqFrHjh3j4uKmT5/OLow1bNiw06dPa2trnzx5spHd5QAAJ9TU1ETbxbRs2ZLbztevX5+cnKyrq7tly5YqLrOzs7t8+bKZmVlOTs6ECRPs7e2r2PoZmpRRo0apqKgkJSU9e/ZMgmmkpKSIVm0jopUrV4aHh0swH5A27CoKMjIy8vLyhoaGI0aMEF8sNTW16RUMDAzEF6j+oYAFIBZycnJmZmY8Hq+0tLSsrGzMmDHR0dGSTgoA4D0lJaW9e/du3ryZx+OlpqbKyMj8888/HTp0EFO4xYsX6+josMfa2trsRmMA0FC0atXKugL7QZGUlMTn8+vec3p6+vr162VkZPz8/Jp/aQ/5jh07RkZGent7N2vW7MiRI3379hXHZB9ocFRUVL799luhUBgWFibpXKDhiYmJERXoxfq8FhQU9PvvvzMMIy8vn5ycbGNj8+7dO/GFa6wkWcAqKCi4du2aqHnv3r3c3FwJ5gNNQXR0dOV7HQ8PDzEN7n39+vW0adOEQqGzs7O5ufmzZ89Gjhzp7OxcXl4ujnAA0GgEBgaeOnVK1Jw3b15xcbE4AvF4vDFjxigqKvL5fKFQuGTJEvGtgDtx4kTRBucaGhpTpkwRUyAAqAfZ2dkjRowYNmzYrVu36tJPaWnpjBkzysvLFy9ezG5B+EU8Hs/Jyenq1asmJiZZWVnm5ubz5s0rLCysSxrQCEjJLMLi4uJ7FQoKCiSbDFSTqalpWgXxLVgcGRk5ffp0gUCwcePGpKSkdu3anTlzxszMTLTrF4eaNWtWeTp2nz59evbsyXkUSZFkAevatWuLFi0SNT08PM6ePSvBfKApuHTpUkJCgqjp4+MjjpsehmFmzZqVlZU1ePDgTZs2nT592s3NTUZGxsvLy9zcPDs7m/OIANBoXLly5fbt26LmsWPHxFT4LigosLOzKy4utrGxGTBgwJ07dwYNGnT06FFxxAKAhqtt27Zjx44VNU1NTVu0aNGqVaukpKT+/ft7eXkxDFO7nlevXp2RkdGjR49169bV6I1dunSJiYnx8PBQUFDw8fExNDS8cOFC7XKAxsHa2lpGRiYiIkKyZaM7d+6srJCWlibBTECqXLp0acKECaWlpc7Ozi4uLvr6+nFxcV27dk1KSho+fPjTp0+5DdeyZctt27aJmnZ2dlZWVtyGkCBMIQTg3pYtW06ePNmiRYvAwEB5eXlZWVl3d/fIyMh27dqdP3++b9++//77r6RzbNKEQmHlpkAgEFOgoqKiyMhIUfPmzZt3794VUyyAGhEKhVOmTLl582bfvn33799/4cKFWbNmFRYW2tvbu7q6iu8fBQA0ON26dXN2dhY1Z86cOXPmzIyMDCcnp6KiImdnZxMTk3v37tW024SEhG3btsnJyfn7+9di9T1ZWVkXF5fExEQDA4MHDx6YmZktXrx4/fr1ogsGDBiQlZVV026hgWrduvXAgQNLS0sr33fVP0NDw6AK1RxUCNKmvLx8xowZd+7c4arDjIyMsWPHFhYWzpgxQ1RX0tXVjY2N7dOnz/Xr142NjWvxEdpkSbiAVVBQkFIBe+JC/YiKilpTQRzLfyYnJ69evZrH4/n5+XXq1El0fsSIEZcvXx4zZszLly+trKycnZ3Lyso4jw7VMXr06Li4OPY4KyurV69eYgqUk5OzYMECUfPgwYPYOAmq49ChQzMriOnLZHd397CwME1NzZCQEBUVFSUlpX/++cfb21tOTs7T03PcuHGvX78WR1wAaBzU1NS8vb1Pnz7dvn37+Pj4/v37+/j4VH8o1rt372bOnCkQCFauXDlw4MBap2FoaJiSkuLh4WFiYtKuXbuSkhLRS4WFhR99XwWN2/jx40kKZhFywt/f//79++xxYWGhp6enZPNpxIYNG1b5P6+Hh0dCQkJAQICJiUl6enrd+79///6oUaNev349YcKEPXv28Hg80Utt27Y9f/78kCFDHj58aGJicvXq1bqHawokXMB6+vSpd4U6zqIHqCYdHZ3BFZSUlLjtPC8vb9KkSWVlZUuWLGF/j1bWqlWrf//9d/v27XJycl5eXsbGxg8ePOA2AQBoBEaMGLG0goqKCuf9nzx5cv369bKysgcPHtTV1RWdd3Jyio6ObtOmTXh4eL9+/VJTUzkPDQCNiYWFxbVr1xwdHd++fTtv3jxLS8tqrpOwfPnyu3fv9uvXb9WqVXXMQV5e3sXFJTIyUkYGM0uaNHYZrNDQ0PofRMzn8/fv3y8rK1v5yUJRUVFOTq52HR45cuTRo0fscWFh4a5du+qeJHySurp6t27dRM1u3bq5ubmNGTMmJyfH1NQ0Nja2Lp1nZ2ebm5s/f/585MiRhw4d+u+W9C1atIiIiGCvGTFixMWLF+sSromQ8Ad99+7dfSsYGxtLNhloIvT09MZWYIes5+XlcdX5nDlzHj58aGRktHHjxk9ewOPxnJ2d4+LidHV1k5OT+/XrFxQUxFV0kELv3r07XUH0ZRpA1dq2bWtQgb3d4XDA5p07d6ZPny4UCj09PUePHv3Rq8bGxikpKYMGDcrKyjI2Ng4ICOAqLgA0ShoaGvv27QsKCmrZsmV4eHjv3r337dtX9VvYnQQVFRX9/f0VFBQ4SYP9qNy9e7doNzHR8z80Eb169dLT03v16lU9VwEYhpkzZ860adPCwsJOnDghOu/j42Nra1ufmQAnVFRUTp48OWPGjPz8fHNz81pPnnj16tWoUaMePnw4aNCgY8eOKSoqfvKyZs2ahYaGfvfdd2/evDE3N8ea4F+EbyqgqUtMTNTR0dmxY0fdu/rjjz9CQkLU1dUPHz5c9Q3ZwIED09PTJ06c+Pbt20mTJk2fPl1Mu4zB58yZM4e9wa28MK04FBcXx1V4/PixWGNBY5WYmNi1a9dz587VvauCgoIJEybk5+fb2touXbr0k9e0b9/+/Pnzc+fOLSkpmTFjxrx587B9KgBUzc7O7vr169bW1nl5edOnT7e3t//c1lr5+fmzZ89mGOZ///tfnz59uE1j7ty5ot3EOnfuzG3nIP3YlarreRbh8uXLAwICmjVrxu062QEBAe7u7u7u7lu2bOGwW6gOOTk5Pz8/Z2fn0tJSOzs7f3//mvZQVFRkbW1948aNPn36nDp1SlVVtYqLFRUVDx8+PHv27Hfv3llZWWE7napJsoCloKCgpaUlampoaKioqGCyOohV//79jYyMRE1HR8eYmJjCwsLFixdPnz69LjsSXr161cXFhYh27drVpUuXL16vrq4eFBS0fft2BQWFffv2GRsbY3nv+rRnzx72BlfcC+praWmtrzBixAixxoLGwcLCovKQ5NWrV+/Zs+fJkyejR4/29vauS88Mw8yePfvGjRsGBgYBAQGVF2L4iKKioq+vr7e3N7vD18iRI3NycuoSGgAaPW1t7RMnTvj7+zdv3vzIkSP6+vqVR6OILFiw4PHjx0OHDv1cDR2g1thZhMeOHau3iO7u7lu3blVQUAgJCRk6dCiHPXfr1o39qtXAwIDDbqGaeDze9u3bPTw8+Hz+rFmztm/fXv33lpWV2draJiQkdO3a9cyZM5qaml98i6ys7O7du5ctW1ZWVjZ58uQ9e/bUIffGjpEmMTExffr0efLkiaQTgabF39+frYvr6emlp6fXooeCgoLu3bsT0Y8//ljT96akpHz11VdE1Lx58wMHDtQiOtTUyJEjY2Nj2ePMzEw9PT0xBXr48GH37t1FzdWrV2/atElMsaAR4/P5bH2ciKZNm1ZUVFS7ftauXUtELVq0uHfvXjXfEhcX17ZtWyLS0dFJSkqqXVwAaFIePXpkamrKfmTZ2dm9fv1a9BI7GUdFReXOnTucx928efPq1atFzR49ejx8+JDzKCDN+Hw+Ozzi5s2b9RBu586dRCQrK3vkyBFuex47dmxkZCR7/OzZs06dOnHbP1Tfjh072C/8XFxcqnM9n8+fOHEiEbVr1+7Bgwc1Defh4UFEPB5vy5YtNU+2SZCuApaFhQURGRsbl5eX1723ly9f2tnZiZp79+719/eve7fQKN26dcvQ0JCIlJSUtm/fXtO3Ozo6ElGfPn1q92CZn5/v4OAgejotLCysRSdQff8tYKWlpW3evJnDEC9evLCwsIiPj7exsRGd/PPPP/fu3cthFGhSDh061KxZMyJi13ap6dvPnDkjKysrIyNz6tSpGr0xOzt7yJAh7MfjP//8U9O4ANAECYVCb29v9iOrU6dO0dHRDMPk5uZqa2sT0V9//SWOoDk5Oc+ePRM1b926VVZWJo5AIM1mzJhBRB4eHuIOtG/fPhkZGR6Pt3v3bs47RwFLqvj7+7Pr8S9cuFAoFFZxpVAonDNnDhG1bNny+vXrtQv3559/sltSVLNk1tRIVwHr1atXnTp1IqLly5fXvbenT5/q6uqKmv/73//WrVtX926hsSouLl60aBFbRZowYULlLwyr5uvrS0TNmjWr47c9f/31F7t3yfjx48eMGSM6Hxwc/Oeff9alZ/hITk5OaWkpe8zn8+/evcveUru5uXHS/4sXL/T19Ylo7NixnHQIwLpy5Qo7Q1lLSysqKqr6b3zw4EHLli2JaOPGjbWIW1paKvp4dHJywjNhg5afn3/69GlRMy0tTRxjYQAYhrl37x47IZrH4zk5OdnY2BDRyJEjq34CBKiL4OBgIho6dKhYo5w4cYKtaPz+++/i6H/nzp2ix4r8/PwVK1aIIwpU3/Hjx9nHtGnTplUx1GbZsmXsINP4+Pi6hDtw4IC8vDw7uUcgENSlq8ZHugpYDMNcunRJQUGBx+MdPXq0jl2hgAW1EBwcrKGhQUQdO3ZMSEj44vXXrl1jN7nnZHzf9evX+/fvf/HiRQ0NDdHJP/74Y9myZXXvHKpw+PBh9kbkl19+qWNXr1+//vrrr4moR48ez58/5yS9GsjKYg4fZg4eZO7ff3/m1CmmoOD98cuXTE2qHiCF2E1tiEhOTq6a3zAXFBT07t2biGxsbOry3BgQEMDu3GpiYlJ5mAM0LDdu3Ojbt6+ouWzZsj/++EOC+UDjVl5evnbtWvZJjF0tISsrS9JJQWNWWFiopKQkIyMjvt9T0dHRbC2Dqy8+qxAaGtq3b996CARfFB0d3bx5c3aoQXFx8X8vcHd3JyIFBYXw8PC6hztx4gT7Y7ZmzRrR9+4Mw5SWlvL5/Lr333BJXQGLYZitW7eyv+Fu3bpVl36ePn2qpKRkVqFLly4oYEF1PHr0aPDgwezzoZubWxVl7+LiYnZhxVmzZnEVXSgUFhcXo4BV/44cOcLeYddlBOibN2/69+9PRN27d5fAE/6xY0znzsyGDYynJ/PVVww720tfnxEteHTxIjN8eH1nBVzj8/lubm7sigxTp0599+5dFRcLhUJ7e3u2opqfn1/H0BcvXmzfvr2CgoKzs/OqVatE5/X19Wux0ANIBApYUP8iIiJkZWWVlJRkZWVdXFwqP4wBcM7S0pKI9uzZI47Ok5KS2CrGTz/9JI7+P3Lq1Cki6tevXz3Egi9KSkpix7Obmpq+ffu28kt//vkn5wuinTt3rl+/focOHbKyshKdtLe3P378OFchGiJpLGAxDMOufGZgYFD1fXnVnj592qlTp9cVVq1ahQIWVFNZWZmLiwv7fGhlZfXy5ctPXjZ79mx26fePPsLqqLi4WE5ObmSF7t27o4BVP0JDQxUVFYloyZIltRiokpeXN2DAAPZHIjs7WxwZVqW8nOnUiRHNt8/KYtq0Yd6+RQGrsTpx4oSamhoR9e3bt4ri0caNG9nvhG7cuMFJ3GfPnh0/fvz3339fuXKl6GSvXr3uiwb9Qa2cPn1atLg+n8/ftWuXmALduHFDV1c3uIK1tTUKWCBWQqFwzJgxRNStWzdZWVn2afzq1auSzgsaLXbDuPbt23t6esbFxX1ysEzt3L59u3Xr1kTk6OhYPxO7SkpK2HoZdiSQEtevX2/fvj0RDRgwIDc3lz25f/9+MS2IJhQKz5w5gwJWZTJf3KZQIvz8/Hr06HH16lVnZ+davL2kpGTNmjW5ubkyMjItKrBj8ACqQ15e3sPD4/jx45qamuzY3djY2I+uOXz48D///KOkpBQUFMT+auFQs2bNAiuwZTKoB+PGjQsJCVFSUtq2bRu7oWT135ufnz9q1Kjk5ORu3brFxMS0a9dOfHl+WmYmKSpSr17vmzo61Lkz3bhBRBQRQceO0bFjdP58fWcFYmNtbZ2UlNSzZ8/Lly8PGDAgMjLyv9dERUWtXr1aRkbm4MGDPXv25CRumzZtxo8fz0lXUFlAQMCVK1fY47KyshUrVogvVklJyY0Kr169El8gACLatWvX6dOntbS0YmNj4+Li2B2f+/fv7+7uLhAIJJ0dNDZFRUWHDh1SUlLKzs52cXExNjZu3ry5kZGRs7PzkSNHcnJyat3z48ePzc3Nc3JyrKys/Pz82GW2xU1RUXH06NFEFBYWVg/hqnDr1q3c3Fz2mGGY/z4ZSYOkpKRz586Jmj4+Pnl5edyG6NWrV2xs7FdffZWcnDx8+PDs7OzQ0NCZM2cKhcLNmzezK7hziB1OQUTCCtz23xBJaQFLVVU1KChIRUVl9+7dfn5+NXpvWlqakZHRunXrXF1dxZQeNBHW1taXL18eNmzYkydPzMzM3N3dRZ8a9+7dc3JyIiIvLy92+0Ju8Xi8lhXYNbagflhaWh47dkxJSenvv//+4Ycfqvl74t27d1ZWVklJSZ06dYqIiJBA9YqICgvpox8VVVUqLCQiunOHrl2ja9fowQMJJAZi071790uXLtnY2Lx69crCwsLT07Pyq5mZmZMnTxYIBG5ubuPGjeM8+j///PN1hQf40WpQtLW1V1dgp8xDE3Ts2LHdu3eLmk5OTtnZ2ZxHefjwoYuLCxHt2rVLW1t78ODBly9fdnFxEQgEv/32m7Gx8e3btzkPCk1WeXm5vb19YmKipqbm9u3bf/zxRwMDA4ZhUlNTvby87O3ttbW1u3fvPmvWrN27d7MDk6vZc25urrm5eVZWlqmpaVBQELtwav2wtrYmopMnT9ZbxE/auHFjdHQ0eywQCNhhldImPj7+7NmzoqaXl5c4vqTR1dWNjY01MDC4ceOGkZGRnZ0dn8//9ddf2RXcxeHChQsDK0RERIgpSoMh0fFfX7B//34iUlJSSktLq8715eXlHh4eCgoKRNS1a9fo6OjK4+syMjIyMjLEliw0WuXl5W5ubuzXLGZmZk+fPi0pKenXrx8R2dvbiyMi1sCSuPDwcHax6rlz535xiPi7d++GDx9ORB07dpTkAO+3b5kWLZiiovdNPp/p0IHJzMQUwkZPKBR6eHiwn1GTJ08uLCxkGKaoqIhdjs3a2loc0xwwhZBzDg4O8+bN27Vr165du7y8vCr/FuCWZNbA4vOZx48Z0f6VpaVM5an3b98y2Nqy3m3fvr3yviV9+vThfD9KgUDwzTffENG0adM+eikiIkJHR4eIlJWVPTw8sM0W1J1AIJg8eTIRtWrVqvLO4AUFBbGxsR4eHuPGjWvRokXlB+HmzZuPHDnSzc0tIiKiSHQH9R95eXnsnX/fvn3fvHlTL3+bD169eiUnJycvL1//oSubPn16YGAge1xeXt6sWTMJJvM5W7durbxjo76+vmhuPudevXrVu3dvduagg4ODmKIwDIMphB+R0hFYrKlTp86ZM6ekpMTe3j4/P7/qix88eGBqaurq6lpeXu7k5HTlyhVTU9PK0xx69+7NbsMEUCNycnLu7u5nz55t06ZNdHR03759J06cmJ6e3rVrV19fX3FEVFBQ+Pvvv0VNc3NzBwcHcQSCzxk9evTp06dVVVV37979/fffVzEOq6ioaNy4cefPn9fR0YmJiencuXM9pvn/NW9Otrb0889UUkJlZeTmRgMHUseOXHUvFAo7deokagYEBKxcuZKrzqEueDyei4vLiRMn1NXVAwMDhw0b9uDBg/nz56empurp6QUEBNTPNAeoOx6PJ1NBTCFu3LihrKzMbj/C6tSpU5s2bcQU7r3//Y969qSffiJDQ/rxRxIK6fRpmjv3wwVTp1JMjHhzAEnYsmXLhQsX2rVrt2PHjo9eGjly5LVr15ycnIqLi11dXUePHp2VlSWRJKHRWLp0aWBgoJqaWnh4eI8ePUTnVVVVjY2NXVxcQkNDc3Nzr1275u3tPW3atF69ehUUFERGRv7222/m5uZqamr6+vrz5s0LCAjIzMwUvb24uNjKyio9Pb1bt27h4eHsZuX1SVNTc9iwYeXl5WfOnKnn0B+5d+/epUuXLl26lJiYKNlMqpCYmLilgljnyOfk5Dx//pxdM/fMmTPS/N+kkam/0Y+1s3PnzvT09LS0tBkzZhw7dkw0C7QyhmF8fX2XLl367t27jh07+vn5mZmZ1X+q0Lh9++23qampU6dOPXfu3OnTp+Xk5A4dOsSuoMw5GRmZSZMmiZrdu3cXRxSo2vDhw0+dOmVpafnPP/8UFxcHBAT8d7g4e08TExPToUOHmJiYLl26SCTVD7y8yN2dRowghiETE9q3j4jI0JBEKwA2b/5hkawaYhjm5cuXomZJSUkhOz8RpMO4ceMuXrw4YcKEK1eusFugqKqqhoSEqKurSzo1qC5zc3NbW1siKi4uXr16Nef9h4SE2NnZrVmzxt/fX3Ry4cKFnAf6f86do5AQSksjVVUqKyMrKwoIoP8/CAIkJTg4+Pr16+zxo0ePuO38xo0b7H6pu3fvbvGp/+Nqamre3t7jx4///vvvIyMj+/Tps3nzZnZ9BoCaWrFixY4dO5SVlUNDQ7/++uvPXSYrK6uvr6+vr8/+pD1+/Dg+Pj4hISE+Pv7q1avsyoA+Pj5E1LVr16FDhw4ePPjIkSOxsbE6OjoRERHa2tr191eqxNra+vz58ydPnqz8gFD/zp8/z040ZmqySmw9a968uWgpD/HN9Hzy5ImFhcXLly8tLS2VlJRCQkK+/fbbkJCQUaNGiSkifCDZAWDVcffuXfb+e9u2bf99NTMzU1SusrOze/36dY06z87OvnXrlqiZnJzM7XZy0MjcvXtXSUmJ/TQcPnz4kydPJJ0RiFdsbCy7Qv+kSZPKy8srv1RSUsLu06ytrV15pLrExMYy9vaM2CZK8/l8FRUVUdPb23vhwoViigW19vbtWxMTEzk5OVlZWTs7u1pspllNeXl5lX/hPn78+KN/IFBTDg4OwcHB7HFRUZGGhkZ2dvbWrVu5+p+YmprarFkzItq0aRMnHVbXggXMzp0fmqGhzLhxzPHjjK0tU1Dw/o+lJXPmTL1mBQzDrhD0pELPnj05nEJYXl5uZGRERPPnz//ixTk5Od999x17Mz9mzBgJbOMLDRw7xE9eXj4sLKzWnRQWFopmGmpqaooellu0aNGyZUvOJ9jWyL1794hIXV29tLRUUjlgCqFITk4OO8Rv6NChhYWFfD5/7ty5RKSgoBAUFMR5uNLS0ry8PFEzLy+vpKSE8ygNSAMoYDEMc/LkSR6PJy8vHxsbW/l8UFAQ+5VO69atjx07VouefX19f/rpJ1Fz8ODB1VxvC6THrVu3KpcPwsPDOdwut7KysrIhQ4YQ0ZAhQ9jSvpaWVl1+U0KDEB8fzw61s7OzK6tYpaW0tHTs2LHsh8/169clm+F7I0cyRIybm5i65/P5MjIy/Sp07NgRBaxqSk1NNTc3FzUXLVp04MABMcXKzMxs1aoVVWxbY2dnV1BQIKZYwK3ff//94sWL7HFpaamDg8PAgQOJyNHRse63qtnZ2R06dCCiWbNm1TnTGrK1ZY4e/dBMSWH692eOH2e0tBhj4/d/NDVrXcC6du3agAEDRM0lS5b8/fffdUy5ifjvGli3bt3y8vLi5CZqzZo1RKSrq1v9L4aDgoJatmzJ1gv27dtX9xygidi7dy87//rQoUNc9cnn869cufLnn3+yddixY8dy1XOt6evrE1FkZKSkEuCygJWfz+zYwTg5MatWMampDMMwz54xmzd/uCAkhImLq0XHnyxgiX63ciI/P58d4mdoaChalUwoFC5fvpyIZGVlfX19OQwH/9Uw1sWwsrJaunRpeXm5g4MDu39nTk6Ora2tvb39mzdvLC0tL1++bGNjI+k06yQ+Pr7yBlJr1qwRbacNVTt69OiRI0dEzfnz579+/VocgVasWHHx4kUdHZ3Q0NDLly+PGTPm5cuXVlZWzs7OZWVl4ogI0mDo0KHR0dGamppHjhyZMmVKeXl5WVnZxIkT//3339atW0dHJVfb7AAAIABJREFUR/eq7aQ8LiUkUGQkqauTs7P4grBbarBWrVolvkCNjEAgKC4uFjVLS0vLy8vFEaikpGTixIm5ubmjRo06efJkixYtjhw5YmRkdPPmTXGEA24tXbpUtCGggoLCwYMH165dq6amtn//flNT07ps/V5YWDh27NgnT5588803lRdYrCcdOtDTpx+a2dnUoQMRkZkZxca+/zNsWK27Z29nP9eEGvHz81u0aNHXX3+dnJxcl37S0tLYnSX8/PzYUczVYWdnd+3aNSsrqzdv3kybNs3e3l6s69dA43D8+PG5c+cyDLN161Z2BXdOyMrKGhgY/Pjjj4GBgUQUHx8vpl/c1SfBvQgTExOjoqK0tLTYYbxExOPxOtZ6lVWBgL79ll68oLlzydCQvvuO4uPp1SsKDPxwzYULdPVqLfru2bNn3759Rc1x48YFBgYOGTLE1dW1ltn+f+ziIWlpad26dTtz5oxoQTQej7d582Z2PwonJ6fNmzdzEg4+TWKlsxoqLy83MTEhIjMzs9DQ0LZt2xKRurq6t7d3Xbr19fW1tbWNraCvry+pEVhHjx6dMmWKqDlmzJioqCiJZNLgrFu3bu3ataKmrq6uOAafnzp1isfjycnJxVV8ISAUCrdv3y4vL09ERkZG2IGrcUtNTWW/Gba0tLSysiKiVq1aSdHGpmIefsVgCmEdJCUlGRsbi5rz5s3bu3evOALNnj2biDp37vzy5UuGYe7evctuXaKmpla7QcogcVevXmU3T+jSpUvtBnsKBAJ2Q5vu3bvXdJkFbly4wPTp837PwdJSZuRI5sAB5vhxpvI2vlZWtR6BlZGRYWRkJGouXrx4165ddUq4ycjIyEhMTBQ1jx49mpCQwD77ycnJubi41G6yUklJCTtU5Oeff65dYv7+/mzZq02bNidPnnz27JloJKlQKBTfnmLQ4ERGRioqKhLRhg0bxBeF/Z5S4s9lly5dIqJOnTqJb3GAT7p27VrLli0VFRWTkpK46fHoUcbS8kMzOJgZNYq5do3p3//DycWLmb/+4iTavn372LVfFixYUMfdTsvKytjpFx06dHj06NEnr/nrr7/YbVhcXFzqEguq0GAKWAzDPHnypHXr1qLSm7m5+ePHj+vYp6+vb58+fRZUaNOmDQpYDc66deumTZv2b4U2bdpwXsB6/PixlpYWEXl6en70UmJioq6uLvuIKBpYC41SSkqKaE0ETU3NK1euSDqjCgkJDBGjrs6I8+kUBaxaS0pKatasmWj2pZaWljgKWF5eXkSkqqpaua5aUFAwceJEqtipEBvVN0RPnz4dMGAAETVv3vzff/+t6dsXL17MfmRJcgGX7dsZPT1m/HimVy9m4UJGIOC2gKWioiL699W6dWspKWAlJyeLjl+9etVQvuUqLi52cXGRlZUloj59+qSnp9e0hyVLlhBRz5496zIV8f79+8bGxkSkrKxsa2srWh6uuLhYQ0Oj1t1C/fD3909JSWGPBQLB4sWLxRHl0qVLqqqqRLRo0SJx9C+yYsUKInJ2dhZrlC8SCATsAI7Lly/XW9DMzEwdHR0isra25myly19/Zf73vw/N58+ZNm2Ya9cYbW3m55/f/zEy4qqAxTDMiRMnlJSUiMjR0bHWfwuBQMAO8WvVqlXVS98ePHiQHd/www8/4L5LHBpSAUsoFI4aNUpOTk5eXn7dunWc/EBIzxpYR48e7dChg3WF1q1bo4BVTevWrRs+fPiqCuzCtxz2z+fz2Y0CLCwsPvlTl5eXZ2dnx9Y1pk2bVlRUxGF0kB7l5eUjR47k8Xg8Hm/YsGFiWmqtNszNxT38ipXKrlPAMAzDREdHHz9+XNwRv+jp06eV15MKDw+XomFxFephBFZ8fLyCggKPxzt8+PBHLwmFQg8PD/ZxdNy4caL1GqABKS4udnBwYMfF7Ky8IPqX7N69m4jk5eWjo6PFl94X3L7NBAczJSVMVhZTsYwgU17OVP5dWVTE8Pm1615qR2CpqKiI7hkOHTo0c+ZMyeZTIwkJCd26dSMiJSUlDw8PfrX/78TFxcnKysrJydV9sIZAINi8efPOnTunTJmCAlbD8tFiSaqqqpyHyMjIYL9TnD59urhHJF28eJEd+iTWKNXx/fffE1HleSdi9eLFC3YndDMzMy5vet3cmN9++9B89oxp1465do3R02MiIt7/sbXlsIDFMExMTAw7rtPKyqp2fxdnZ2d2vELlm+HPCQsLU1ZWJiIHBwfR+rnAlVoWsAoLC0WVdYZh7t27Vw87hrBf6bCj8k6dOsVJn1JVwLKxscmsYGpqigJWNYl7CiG71o+2tvazZ8+quMzb25sdxtyvXz/J7lQC4sDn86dOncoOgmDnEo4aNUoqipX1MvzqI8HBwURUuSgjKYmJiSYmJqKmk5OTmGbn1cUnC1hpaWlcfZn59OlTdlsJV1fXz10THh7O3uvr6elJy7YDUBNCodDNzY39pmTRokXVKSjExMQoKCgQkY+PTz1k+Fnz5zNEjNgmUzS2AlZmJlNpd2wmIYEpLGQYhnn+nDl9momIqLeP+qKiokWLFrHbQQwZMuT27dtffEthYeFXX31FRL9VfjqtsylTpnh7e7O3x3fu3EEBS/qJu4B17949diySjY1NPWyAKxAI2rRpQ0QSH3ofGhrKrltSD7Hy8vL69etH9H/snXlczPkfx99z1XToFJJrc5QokruEimXFjyUsprXYEMaxaB0ry+7KseRYtM7YHFlXUcixhEjkyLEIlVIppVPN8f798ckYndPM9/ud2O/z4Y+mZj7vz6T5fj+f9+f9fr2ga9euqlsxqMSRIzhgwIeHpKOQthZCBTdu3CD9NH369Hn79m2tXkuq8PT09C5evKjiSy5evGhsbAwAgwYNqhP7hc8INUXcnz9/PnnyZMXDTZs2HT9+XL2hVGT58uXr1q3T0dEZN24cABw7doySYY2MjMifMsHKyorkILSCvr5+s/eQQkcW9UhLS+vRo8ft27c1H+rChQtEiDQkJITcvarCx8fn6tWrrVq1io+Pd3JyCgkJ0Tw6Sx1BJpONHz8+JCTEyMgoKirq8uXLlpaWZ86cGTBgQEFBgZYnR/a0s2aBqSljMb/88ksjI6PLly8/ePCAsaCfE2lpaX369HF3d8/IyNBwKIlE4uXllZaW5u7u/ssvv1T1tC+//JJcmh4/fty9e/cjR45oGJeFYTgcztKlS/fv3y8UCjds2ODp6ZmXl1fN8x89ejRs2LDS0tJFixaRQ3vtUFAA5G44bpzW5qA97t69e+fOnTt37iQnJ6v6mvBw+PPPDw+nTYOkJNi3D3r2hEuX4PRpcHCACxfomG059PT01q9ff/r06SZNmsTExHTs2HHlypVyubyal8yePfvp06edOnUimz0K2bFjh1gsFovFP/zwA7Ujs9DEnj17Zs+ePXv2bGLNVlhY+PbtW0pGTktL69ev36tXr9zd3Q8cOEDkjWiFy+V6enqClgTUlenXr1+9evVu3rz58uVLWgMVFRV5enrGx8e3a9cuIiJCdSsGlfjf/yA3FxYvhvh4OHIE5s+Hn36icvwq6Ny586VLl5o0afLPP/+4u7tnZWWp+MINGzasWLFCIBAcOnTI1dVVxVe5urqeP3++QYMGJ0+e/PLLL6n6+2cBUFfE/d69e05KWdJZs2ZtpjpLqgwxzeHxeKGhocSbr2HDhqrXM6vCpk2bhg4dqsVz6bqpgRURETF27FjFw1GjRp05c0aL86mU7du3Kx8ve3p6khZloVCo4Z9lRkYGOeFR/SwxLy+PNHoAgEgkKiAHpyyfMnK5nGz/DAwMFAcvjx49IjUvvXr1ovhgqlaQ8isjIybLrwg+Pj4A8MMPPzActxzXr19v2bJl4Ht69uxZByuwioqKlOVvUlNTo6KiyLWlefPmqtSiVwP542zevPnr169rfHJxcfG3334LrCTWp8zly5ctLCwAwMHBISkpqdLnZGVlkUKY4cOHa/l/efNmBMDevemLUFJS8vLlS8XD6OjoDRs20BdOdfT19b99j6urq6oVWJs24Zw5Hx46OmJsLDZujIr/66tX0cYGGVRxzs3NJRd8AOjXr19ycnKlTztz5gyHw9HV1aW8j5ttIfzk8Pb29vf3/+eff/75559z584ZGhru3bsXAKytrUUiUVBQUEJCgnp9fzk5OR06dACAbt26KaT9GYDJ0qfqGTZsGADQuu8uKSkZOHAgADRt2rSqu4ymFBdjYCCOH48//ohkFfTqFa5d++EJx47hlSt0RH7+/Dnpj27btq0qatq7d+/mcDhcLnf//v1qhHv06BGxa+zUqVNGRoYaI7BURP0Elq2tbcx7Ro8eTd8H6ejRozwej8PhKJIU5M9OYQZHCSNHjgQALe58EhMTz549q3gYEhKihnAm5YSHh48YMULxcOjQoZGRkVqcj4oUFxeLxWKy2Bo6dKh6vksymaxfv34A0Lt379pmS4ODg/X19cnF8e7du2pEZ6kjyOVyUm2qr69/4cIF5R/9+++/VlZWAODs7FzbUmSqmO3tfbxrV/mSJcyHJibr5ubm7969Yz66guvXr7dp02bXe/r06aPqZXzSJFSoQd25g6QNOTYWJ03Cfv3QxwdpvgJnZmb26dOHpNp37Nih3iBbtmwBAD09PeWm/hoJCgoi8qIDBw7Uji0di2Y8ffrU1tYWACwtLZWVwgklJSW9e/cGACcnp8LCQq3M8AOOjgiATDmcpKenCwQCgUBQlT8Uk6jZQrhpE44ciRculP1r3RpDQlCpURoRsUkTVMrZMcOJEyeqcQDPyclp0qQJAPz++++Uh2YTWJ8cFVsIV69eXa65xNLScsSIEevWrbt+/bqKIkGFhYXOzs4A0L59++zsbDrfQXmKiooMDAw4HI7mBmIasmvXLgAYoNyCRylSqZRsihs0aPBIuZ2ZJn79FW1t8ckT2gMp8erVK5IGbdGiRfWqL0ePHiUlfoGBgWqHS01NJZbQ1tbWn4qbRx1H/QSWhYXF1Pc4ODjQlMA6d+4c6elbsWKF4pukflhtd95K+fXXXwFg9uzZGo7z7Nkz5WNwZX9i1dm9e7dQKJw+fbqGk9Ec9RNYxcUfjgdlMlTe4mZmUjjDajh8+LCJiQkANGvW7OrVq7V9+bJly8jlWz1Frfv375OrlZ6eniZXPRYtIpfLfX19SfaqUgnk58+ft2jRAgB69uzJfA7r6tWrZC+Ro6UcBBFHqKgaziTqa2A1b44KVbuzZ3HQIHz8GJs1w8hIzMzE48fRygppOnh8j0Qi8fPzI0t5Hx+f2sp8xsTEkPujGkcvFy9ebNiwIQC0atWqDsres9TImzdv+vbtSxKgysfCcrmcKC1YWVm9ZDzHUZ7LlxEALSyQwTQ3EStUljfVFuonsJyccPbssn8NGuCWLR9ZziNiu3aojY9tRkYGqf4AgK+++iotLU3xI1J77uzsTG17BMHb2/vo0aPk63fv3llYWFAegoVaKtXAkkgkcXFxgYGBXl5eyrbyACAQCJycnMRicWhoaFXVxCUlJV9++SXJAij/7THG8OGjHB1/CA5+ynxoZbKysng8nq6uLh3l/4qeA2NjY4ZUoceORQBcs4aJWErk5OT07NmTNHVV5ep49uxZssr67bffNAyXnZ3drVs3krdlF12aQ2UL4fPnz6m1gYiNjSX2qOVSOZcuXSLLbgpjnThxAgDc3Nw0HKecvZSurq4agyQkJHA4HENDw9zcXA3noyHh4eEmJiYKd2pjY2NVE1itW3/Y+126hB4eiIhLlmCbNti/P7Zpgz/9RNeklXjx4kX37t0BgM/n+/v7q95JcenSJT6fz+VyT6tr7I2I+fn5IpGI3JunTJnir2QSd+XKlRMnTqg9MgsDyOXyadOmkRSkcnVkORITE0ltcO/eXzH8eSUruZ8Y+ShVyqZNm0hHibYmgNQmsHx9PypfX7YM586lcKpVsXfvXmJV4+LiUr1ThDKvXr0iBYBzlLuNakNKSkqXLl0AwNDQMDQ0VL1BWLSIRCKZOnUqaQhV3F+WLl0KAPXq1WPSZ71KyM5k4UImYz548IDL5QqFQgbMhaqnefPmilXx0aNHxWKxSi+r2EJ44gS2bv3hULCoCI2NUXsCBaGhocQRwsLCghRGHT16lHTZP2G2jIKlznLw4EGF3rlMJqt0oZKamhoaGioWi52cnIhDl4KKnYZSqZT4fTdu3FhbNSy7dskBcOBArQT/iPbt2xM77N9///3q1aslJSVUjTxv3jxyahsdHU3VmDVw8CACoKsrQ+GUKCgoIAtpExOTin1d165dI1kIVS/dNZGbm+vq6qqvr79+/fpDhw4pvv/zzz+np6dTEuK/A2UJrLVr11pZWbm4uDx8+JCSmT1+/Jik58eOHVsu76Awg6AwhUnE8MzNzTUch5IEFiK6ubkBwFrl3ZQ2UL8Cq2IC6+RJ7NoVSb96fj527YphYZRPuCKlpaV+fn7ERmfw4MFZWVk1viQ7O5ukJBZSsewODg42NDTcvXu3ctH7xo0btS4exFI95C6uo6NTY6oxKSnJzs6pY8c3nTqhCn9f1EBMnY2MjBiuolcmNzdXX1+fw+E8faqdA8mUlJQnT54sUeqgDAoK+ueff1R6cfPmOHgwenmhlxf27o2DBqGbGyorD4aHo6cn1VOunJs3bzZv3pxUzcTExNT4/NLS0l69egFA3759NTFgKioqIkl2kgFR/tU9evSILXT/JAgMDCR7vwkTJuzbt4/D4fB4vOPHj2t7XoivX6NQiFwuPn/OcOSvv/6a8jr9WhETE+Pi4qKKbV8lVExg3b+Pffrg+vWIiDIZzpmD331HzUTVJS0tbdCgQSTXMGTIEOKGVLGvkIVFRbKzs8PDwxcsWODq6kpOdBQ0bNhw6NChPXr0AAAzMzMtVq9kZSGPh7q6qEXhU0SMjIwUCASkxaRi/VqmBm0upBtJIBBERERQOOEayM9HXV3k8VAFHU/KKSkpIYlRfX195R3uvXv3SJre29ubwuqcoqKimJiYDRs2KN+eOnTowESr5ueFmgmsf//911NpZb9s2bKlS5eSfgShUPjrr7/WthWiHC9fviSreU9Pz0pX55MmTQKA5cuXaxKlHOQGrGFv8+TJk5ctWxb/HrUTWMTVsUWLFnQUY6uORgmsFy9QJkOZDC9eRA8P/PZbDA7+8IQ9e3DcOKrnWyXHjx8nV6ImTZpcunSpmmfK5fIhQ4YAQLdu3TT8M1aQnp5eVFTEJrA+IUhjl46OTnh4uCrPT0qStmyJANipEzKTUNJ6+RXB29sbABYtWsR86JiYGKFQuHTpUjVf37w5Xr2Kjx/j48cYHIyDBuGgQXjy5IcnhIbiqFGUTFUVXr9+Tc4tdHV1t23bVv2TSd1Ns2bNNFmqKggKCtLV1d2xY4etra3im4sWLVq9erXmg7MwwOHDh4nqIslkrSeZDq2zciUCMJYFViY+Pp7D4RgYGKjibEA5hYWFbdq0AYDFixer8/qQEAwI+PBw2DB8+hTT0nDMGHR0REdHnD0btS5thiiXyzdt2mRgYEAy4F26dKG2CYPlP4tEIklISAgKChKJRGQzSFbvurq61Mofq4GLCwKgUvUM08TExJAP3dSpU/fs2TN58uT27dsr169xOJy2bdtOmDBh586dtUqLEElNHo93gCnJwg/0748AH20SGUQqlZKuSR0dHaKJ8fTpU6L3N3ToUE3OCKuCTWBpjpoJrErJycnx8fEhpS729vbXrl1Tb5zXr1+3bdsWALp3716ViRvp+FOuAtMcsnnQpLFLKpVOnjy5V69e371HIBCoN5RMJmvZsiUAHDt2TO35aI5GCSx7e3RyQicntLFBDw/s1w+joj484fx51Lhhs1YkJycT6cfq2wlXrVoFAKamptRKwBYVFQmFwp/eM2DAADaBVWdZuHAhuZPVqorh1Su0s0MA7NCBdp23ulB+RSAN3Y0aNaLjHl8N6enppIFOfeHCii2EP//8UeHD5MlIgxpxNZSTxKqqKWDPnj3krCg2Npaq0CkpKc+fP2cTWJ8uERERPB6vXr16RkZGdWEpLJPJpK1bIwBqqVl+wIABALBEGwYX06dPBwA7O7vi4mJaAty/jyIR1gGVekRcuXIl2TNzOBxfX1/WeZmFcp4+fbpp0yYul6ujo6NN02dERFy1CgFQJNJO9Lt375qamgLA+PHjlfPFeXl5UVFR/v7+np6exsbGyvVrRkZGHh4e/v7+UVFRRUVFVY18+PDhcoZpjLJpEwLg8OFaCI2IiHK5nHRd8Hi8VatWffHFFwDg7u5Ok0nRhg0bHB0dp72nfv36deGu/WlBZQKLcPHiRRsbG3IS6OPjU9trTWFhIdFUs7e3r8Yd6d27d/Xq1QOA59SVps+ePRsAfv31VzVeGx0d7eXl9d1331HVQoiI69atAypkudRmyZIlN2/eVC5JS05OVtWztmILobc37t374Ql//cX8HUAikfj7+5OTCjc3t4oakLGxsTo6OhwOh/K8IbEvCX/PlClT2ARW3WTx4sWkglohGas66enYrh0CYNu2SKvAKNmbqXm8TzV2dnYAEMZIRzChtLTU1dUVAFxcXNQvk6yYwMrNxfbtcdEiDAvDefOwXTutlDmEhISQapqePXtWFPG5desWaa9Q27iwKp4/f96sWbOo94wdO5ZNYH0q5ObmtmvXDgDIusjc3PzixYvanVJkZGSzxo2Dhg1DlaUnqUXhccGwlui5c+c4HI5AIKiVMWjtIMpidUClPiUlhWynRSIRkTr+4osvVG3iZmGpDeQE+u+//9buNJ48QQA0M0Nmz+xI6CdEP2fYsGHVdOdIpVJF/RpJxCjg8/mKTsOMjAzFS86cOUM+vytXrmTkrVTg5UvkcNDQEGlK+qsG6aAkVFNDozkbNmwYM2bM5fe0atWKTWDVFuoTWIhYVFTk7++vo6MDAFZWVqrvA2tlMEF6Vjds2KDxfMvYvXs3AIwcOVL1lxQUFGzZsoXUiwGAiYnJxIkTqUpg5eXlGRkZAYBCB5FJduzYQTrPq0nYV0fFBNbRo9irF5KagpISdHXF2icIKOHs2bPkHtCgQYNTp04pvp+Tk0Ou9ZqbUVaEbSH8JFiyZAk5gVF29aoVGRlob48AaGuLNCkIx8XFEZMHrXTHVGTNmjUAMHjwYMYiEmvIpk2bKq/Aas2OHR/yU8nJSKrtCgtx927098c9ezAri0nrNGXi4+PJtcjCwuLChQuK72dkZBCj+hkzZlAe9Pnz52ZmZvPe06NHDzaB9UkglUo9PT0BoG3btqmpqf/73/9IAemuXbu0OKvBgwcDQIByKxzjkDQ3k3N4+/Yt6XjS3LKqOh48QC4XhUK67jGqIZfLyYp96NChiJiQkODk5ESqscRiMU2VCyz/WUitn7e3t7Yngra2CIBKd2YmePnyJfG89vDwqNWH68WLF3/99de0adM6dOjA4/GU81lt2rT59ttvFyxYQM7MFixYQN/8a6ZTJwT4SMaBcfLz81u0aEHSF7NmzaIvENtCqDm0JLAId+7c6dq1K/mQeHl51bjTkMlkI0eOJEt2VZQvQ0JCqC1Qio+PBwAbGxtVnpyamurv729ubk7eoKWlpb+//+vXr+fNm6dsKt+sWTNNpjRjxgwAmDRpkiaDqEFCQgK5nAWr3ZBcqQvhzJloa4tjxmDbtqgN0RwFGRkZ/fv3V6y0SBEHkX3t3LkzhXYeCtgEVt2HdI/yeLyQkBBNxsnMRAcHBMA2bZByF/uMjAyyK9OK7FSlZGVl6erq8ni85ORkBsLR0UBXCVu3Yv36WJMWFX1kZWV5eHiQI1OyA5dIJH369CGVWXRco9gWwk8UYpZav3594qUgl8v9/f3JykQsFqvuvUshycnJPB5PR0dHoxSzxpw+fZqcVBUyVUo5fvx4cnRPu3rp118jAGpPpR4RN2zYQFbsiv9liUQSEBAgEAhIByWNNWgs/z0ePnwIAGZmZgzrFVRk/nwEQBpOuqvk9evXpNS9e/fuqvbBVEZ+fn50dHRAQICnpyepnST7IIFAMGnSJC1r2C1digA4ebK24itqaBo2bEguYlOmTKHpBsomsDSHxgQWIkokksDAQGJCaWpqGhQUVM3HQywWk2bdW7duqTJ4bm6ujo4Oj8ejqgyhpKRER0eHy+VWf3WIi4sTiUR8Pp988p2cnIKDg6lS+y7HkydPuFyurq4uk6vA4uLiDh06AMD48ePVHyUr60PjQGkp5uQoRseHD7GoCK9dw6tXNZ2rBshksoCAAHIc4erqunz5ctJ/oaZtUE2UlpYqZ6z++ecfYj7NUkcgZUQ8Hm+vcqOrurx+jR07IgC2bo2aeOO+efMmOjo6KChILBZ7eHgQUcmGDRsaGBhQot5NFeTsgVpXjUqhr4GuPHv2IAB260ZvlGqRSqUKB9Vx48aRujNLS8uKfYWUwCawPkUCAwNJPvfqx/fTbdu2kSX48OHDGUvfKFi0aBEAjBkzhuG4FSHOZcyo2oeFhQGAvr4+E1uR+HjkcNDAQCu+XYj49OlTsrav2NIVGxtra2tLku9+fn50ZNtZ/psQgRqt90dfvowAaG3NULi8vLzOnTsDgL29PYWyp1Kp9NatWxs3bmzQoAEAnNRq6RMi4q1bCFDSooVW8mhSqZT0dTVu3PjZs2cnT54kZRyjR4+mY4N/9epVZUXpjRs31pGOik8IehNYhGfPnpFqFwDo3bt3pQkCojujp6dXqwsTGVb9KqEKODg4AECl8vMlJSWhoaHdu3cnb0RHR8fLy+vKlStUha4KYlRMbzn6x0ycOBEAWrduTaNW4sGDCIA9e9I1vsqcP3+eJAXILjE0NFTbM2Jhgrt378bExCgehoaGrl+/ns/nU3gxycnBrl1x4ECcMwfXri375o0buGxZlS/JzMTz53HLlhJfX98+ffoQX9RymJiYkNuqFmxiqubMmTOspmVyAAAgAElEQVQA8MUXX9Ba7pGVlUVK6KdPn05flDKKitDUFAEwPp72WNWyb98+8j9O7jtqu6PUSGpqqnIf6IYNG7Tbg8ZSI5GRkXw+n8Ph/PXXXxV/GhUVRXzWO3bsqKG9cq0oLS1t3LgxAERHRzMWtCqOHTsGAE2aNKE7jfL69WsiTUChrkUNDBiAAKgNlXqZTObi4lLNMWdxcbGfnx/RG3VwcNCKDgbL5weR2dZ6+4JMho0aIQAmJNAeq6SkhGx1W7Zs+Uqh2kkppGJ3ypQpdAxeC+TymZ6eRvXq0VtcX3lkOdn5mpiYxL9f8l27do2Y17u7u2tS9cZCE0wksAihoaEWFhYkSxUQEKBcAvrHH3+Q2ofa1qRs3rwZAIYNG0bVJEUiEQAEBQUpfzM9PT0gIIA4XpFydD8/P8aWg2Rn2LhxY5qKvMpx8OBBcpwbT+u2rbAQzcwQAK9fpzGKajx79szAwIBsEcViMXta+F9g/fr18+fPVzx0cHD4999/Hz9+TG2U3FwsKUF3d7SwwPv3ERFPnUIvr7KfvnmD0dEYFIRiMXp4oKUlAiAAcjhoZNSUXG2MjY2dnJxEIlFAQEBYWFhiYqJcLv/zzz8BoE2bNlovpFcgl8uJa+qZM2doCkF3A10lTJ+OAEiD2lRtOXDgAJfL1dPTMzQ0PHfunLanw1InuH//PnGb+vnnn6t6zoMHD6ytrQGgb995jOUQyCrCzs5Oyw0piIgol8vt7e0BYBvN7cCkCtXNzY25d331KgKgsTEyq1KPiL/99hsAWFlZVWO1hIhXrlxp1aoVWVIGBATQ3lbJ8rkTHR1NUjnanghOm4aDB9N+vCWVSocPH04+a8+ePaMpyq1bt8g2U+tXbOLfyrw90dy5c0nx7OXLl5W/f+/ePXIY061bN61bfrOUg7kEFiJmZ2f7+PiQjVmHDh1u3LiBiCEhIVwul8PhqNESkpqayuFw9PX1qXIKIG1Eijz0zZs3fXx8hEIhmbOjo2NQUJCaouYaQJZfDBRcPHnyhMjGb926le5YOHcuAuC4cbQHqolx48aRtizSFtq9e3cKrS1Z6iaVJrBoiuXujitXYu/eKJeXJbC++w7r1y9LVyn/MzbG7t1x0iTcvPnwmTNnXlYhoCWVSkkhfZ0qkPnll18AwEuRn6OamTNn0tpAVwl37yIAmphoxYtQQXZ2NhF0b9q0KQAIBALmSjxY6iqvXr1q1qwZAIwcObL6XUdmZubgwVMbNJDVq4cnTjAxN5Jo/uOPP5gIpgL79u0DAGtra/oy/kSS1cjI6MWLFzSFqJzevREAmVXKT0hI0dXV5XA4UVFRNT65sLBQLBaTCveePXtSfkrE8p9CJpM1bNgQAO6TI0HtMWECKk7rjh1DOhRB5HL5hAkTAMDc3Jzu90tq25kvfSoHqdiwt7dnMuiyZctIebtyT5+CxMREcgjUvn175hafLCrAaAKLEBERQVxa+Hz+sGHDiNq/2lob3bp1AwA1DO8rJSoqihQ8h4WFEQFdAOByuZ6enqrcqmliy5YtANCjRw9ao7x7965Tp060bkE/4sUL5PNRIKBe5ro2bNu2DQAMDAwePHgQGxtLNopGRkZ1qj+LhXLWr18/cODAne9p2rQprQms+HgcOhR37SpLYHl5IQAaGaGTE4pEGBCAYWGYmIiqn36R/VLz5s3rjtPTq1evBAIBTbLNf/31F8ndMN2U1KULAmBl/VnMIJVKiapo9+7di4uLAwICSFfOmDFjmBc2YqkjFBUVETUDZ2dnVa4A796htzcCII9He67j4cOHxCP17du39EZSGalU2qZNGwDQ0J2jKlJTU0mnyc6dO+kYvzrOnEEAbNCAsSR7SQl27Ijdu6fMnfur6q86deoUaWLQ19cPDAzUeqEHy6fLd999x7CsSqWYm2O7dkhqJwIC8JdfqA8xZ84csj1hQKyGOIEwX/pUjtLSUtL2npiYyExERQdYNQIyaWlp7du3J6cgxCmFpS6ghQQWIhYWFvr5+fF4PCKhXb9+fR8fn+Dg4ITa9xOvWLGimj58VdiyZYtCDSczM1MhhwQApqam8+bNY/pIrQKFhYXE7vA6nQ13pHSzZcuWuYyVoxMbHW0oOBAqmi3m5uYSGT8AEIlEzFfbsTDD+vXrPTw8NryncePGdCewXrzAFi3w4EH08sLERNTQr08mkxGnhU2bNlE0TQoYMmSIJqcRVXH79m3yOf3zzz+pHblm/vwTAbB3b6bjvueHH34AgEaNGinK8cLCwkjjWMeOHenrKWCps8jl8m+++QYAWrRooXqyWC7HgADkchEAv/8eaRIkUJQMTNaek1Sl7NixAwDatm1Lh0jfV199BQCenp6Uj6wSXbue6dTpCFPXxoULy+Sra6sJk5OTo+jA6N+/P5OibCyfE0ePHiUnOtqdhrk5Ll+Oc+ci0pPAIrpUOjo6p0+fpnjoyiCGrQ4ODgzEqp5Ro0YBwLp16xiIFRKC3bun6emZ1thgnp2dTcplLC0t7969y8DcWGpEOwksQt++fZWzRQQrK6vhw4f//vvvV65cUeVo8fHjx6TAUvXi8Ly8PGW1/wULFihLSPTp04fL5VpaWgYGBlLVmag5RLlw7NixNI0fHh5OjFSVla1p5+JFBEALCywuZi7oe4qLi4lm/3fffVfuR0FBQbq6uqRplK14/yxhuIWQCCX89ht27IhUFTiSZZylpWXdqcT5+++/iW7XwIEDZ82atXnz5rNnzyYnJ2ty3p6dnU3qt7WzJc7Px3r1EAAfPmQ+OGl9EggEly5dUv7+o0eP2rZtS258WiwNZtEKCxYsIGXC9+7dq+1rQ0NRTw8BsF+/D87AGiKTyRISEoKCgkQiUZMmTXR1dfX19c+ePUvN6BRRWlpKCv+PHDlC7chBQUHkk0iTvnKNnA0PB0ZU6hExLg4FAuRy8eMLUi0IDQ0l5iTGxsZBQUEnTpxQLLNfv37NCvyx1EhhYaG+vj6Xy9XWJ45gbo5FRdimDd65U5bASkhAqqpON23aRMqCDh06RM2INaEofdL6qRhZ9vTt25fuQOHhKBAgAG7ZkqXK8/Pz80ljlpmZGaM7ZZYq0FoC68qVK0S+6uHDh9HR0YGBgV5eXuVct/h8vp2dHSnOqqaekPj1nj9/XsXQK1eunD17tuLh33//PWTIEMXDhQsXkkLButObg4hJSUl8Pl8gEFQli6MJycnJpAA+MDCQ8sFroHNnBEDqrN9UhxwUt2nTplKzxZs3bxLx0Xr16lVq8MTySaOVBFZJCbZtS1kCC983UK9atYqyETXju+++K3cgQdDR0bG2tvb09PTz8wsKCoqKilJx6SmVSgcMGECOW7V2QZ44EQFQ6a+FGe7cuWNgYAAAW7ZsqfjTt2/fDh06lKxxAwIC2Jac/wi7d+8mSyO13RJiYrBhQwTAdu1Q7a2KRCKJiYlZtWqVp6cn2fYoIMWS33zzjZpD08bGjRvJoRSFH5bnz5/Xq1cPAA4ePEjVmLWFMZX64mK0s0MA/PFHjcZ59eqVp6cnAHTr1q1t27aKDfPVq1cZ2LWyfAaQvx+6/+Crx9wcEfHECXRxKUtgtWqFPB7a2aFIhEFB6hsU7t27lwhDb9++ncIJ1wgpfdLCNvBjcnNzdXR0eDxeVpZKeSX1uHIFDQwQAGvVNPnu3buvv/4aAAwNDdmzQ62jnQSWTCbr3LkzACyrYCmfmJgYHBwsFoudnJyI2IcCS0tLT0/PgICA6OjoYqWaHXIgOXPmzKrC3bhxY63Cxx7x3Llzrq6uiocvXrywsrJSPCwuLtbT0wOANWvWUPBWqYNYUSyhuuFOIpH07NkTAAYNGqSFXdCuXQiAjo4Mhz1w4AAACIXC27dvV/WcvLw80qlB2gnrTjkei+YcO3ZM2TVi6tSpdKSGCSdOYFpa2dd37yKFdz1S9W1ubl4X5GaIlICent7hw4ePHj26atWqSZMmubq6EsnVilhYWLi4uEyYMCEgIODIkSMJCQkVU1TEGqZhw4b0/e/UzLVryY0b/zpoEJP+pG/evCGujt7e3lU9Ry6XKySxRo8ezV6gPnuio6NJabCG+ugpKdixIwKguXktSmnevcNLl3D5cvT2XmNoaKj8Wf7iiy++/fbbnTt3PnnyJCkpify0rq3vi4qKGjRoAAC9e/eeMmXKokWL1q5dGxwcfOLEiZiYmMePH9fWZEomkxG5eq1n6xhQqUdEsRgB0M6Omor5HTt2kEpSNoHFUluIEfPgwYO1OAeSwELEoUOxSxdcuhR79kRd3Y9seays0MsLAwMxNhZV/GgeP36c2En9/vvv9E2+UoiyqpubG8NxK+Lu7g4A9JUO3L6NJiYIgFOn1vq1UqmUqLDp6uoepkO6n0VltJPA2rlzJ6l5rn7NnZ+fHx0dHRAQ4OnpWbE4y8nJSSwWBwcHHzlyBACaN2+uyL9IJBLlMshbt24pmxrk5OR07dpVOdChQ4eUlREiIiIAwMTERLnTUOtcunSJ7PqKKW24I1vEpk2b0prtrpLiYmzQAAHyPvYupZXHj/PNzBqCapI6wcHB5EjZ1taW7XxmUQ83NzQ3RzqKjnv37t2u3YQ1a7RZS4+IV69eJXYc+/fvr/jT3Nzc2NjYkJCQn376adSoUZ06dSq3ASbweDxra+svv/xSLBb/8ccfS5YsIX3NFy9eZP4dKdOxQwcA+Pvvv5kJJ5XilClnAaBr1641Xu1PnDhBSmAcHBwY0z1lYZ5nz55ZWFgAgHL9uNq8fYtffokA6OuL1tZ440bZ9ydNwmvXPjytsBCjozEgAD08ynoPAbBPn7MkXSISiYKCgiq2nAQEBABAq1atqF2raEhJSUnz5s2ryqcrEAqFlpaWTk5Onp6eIpFILBb7+/sHBgYGBweHhYXFxcWlpqaSXPbvv/9ODla1s3ZSgm6VekQ8dw65XOTzMS6OymHbtm27ZcuWw4cPHz58eMWKFWwCi0UV0tPTuVyunp6eVo5tSExFAispCQ0MyjSwiosxOhpXrsQhQ8o7TdvaPunTp8/ixYsjIiJyqujfPn/+PHG99/f3Z+StfAQpfeLz+W/evGE+ujIbNmwA2vzEHj8uq0EeMwbVU0SUy+WzZ88mS1YtGHewvEcLCaz8/PzGjRvX9l4rl8vv37+/Y8eOiRMntmvXrlxxFhGDv3nzJnny8+fPPTw8FK8tLS2t7d6D9K1Mnz69Vq+imy+++MLAwEBXV9fa2trDw0MkEilachISEtS4lEdERHA4HD6ff5nB/FE5bv7+e0cbmxEjRjATrrgYHR2xXbv8yZPLV/9Vxf3794kDhVAo1Hp5LcuniJUVAuDz59SPHBPzlsNBIyPUYrL91atXxGFqLlE0VY03b97ExcUFBwf7+fl5eXk5OTmRpZsC4tReF1Tq169fDwADBgxgJtyPPyIADhjwr4o6x48fP7azswMAMzOzU6dO0T09FubJycmxsbEhRQdSqZSSMSUS3L4dExKwUSPs2hXJqIMHY2QknjiB8+djjx5lEiHkH5eL9vY4YwYeO/YmPT292pElxGJCK9uwqiCl+k2bNt27d+/mzZuXL18+a9YskUg0aNCg7t27t27dulwvZPUYGRmRk60TJ05o+50hIm7fvh1oU6l/+xabN0cA6pWq27ZtO2fOnGXLli1btuz7779nE1gsKkJsWKkyoFedzEy0tUU/P1y//sM3T5zAq1creXJiIgYHo1iMTk7Yq9dO5QuI4gAgISGB1F7Ex8eTS5Cvry9T76Y8dJc+qcijR48AwNDQ8Ouvv167dm1MTEwpRbYjKSlll7L+/VHDknpyTsPhcJQbvFiYRAsJrMWLFwNAt27dNGlYy8vLUxRnEYc+GxsbCg/qHzx4wOfz+Xy+GsaINBEbGysQCEh7Y6VwOBxLS8uuXbsOHz581qxZ69atO3To0LVr19LS0ir9Vb98+ZLUtQXQbaxdLWlpaaThmRntwGnTEABbtqyd2mJRUZFYLCa/5xEjRjBn1Mjy6VNQgBwO6uoiRRvP8gwciAA4bx4tg9dIaWlpr169AMDNzU3DBpbS0tJ///03LCxs9erVPj4+xGvvwoULFM1UfXJycohqLAOOtEePIoeDfD7+808tXpWXl0d6zDkcjp+fHyuJ9ZkhkUh8fX3btWtHebPwgwfo4oLff1+2Hxs8GP/440PSiki6+PhgaCjWqswoOjqaw+Ho6uo+1Ib7QUXi4uIEAgGXy71UU89kUVFRampqXFxcWFhYcHBwYGCgv7+/WCwWiUQeHh52dnaWlpYCgQAAzM3NjY2N64hYqkKlno4t/YQJCIBOTtSbV7IthCzq8dtvv0FlFky0kptb1nzt5FTrRtqsrJywsDA/P79evXqVO6tr1KhR//79yYJHJBLRkYNWEXJWN3LkSG1NABFLS0uJxplynYpAICBNV6GhoWq3RpHkIwD26IGUlO6tW7eOqL6Gh4crl63VnbzB5w3TCayUlBR9fX0OhxMdHU3VmDKZrEePHgAQGRlJ1ZiIOGXKFAAYNGgQhWOqTV5eHikRF4vF2dnZd+7cCQ8P/+OPP3788cdx48a5uLg0b96cLKoqhYgou7q6ikSihQsXbtmyJTw8nEhfDRgwQIuXS8LYsWMBYD79MslhYWWphPe1erUjODiYtD61adMmnuhys7DUxK1bCIDt29M1/p07yOWiUIha0YmaPHkyADRr1iwzM5PakZcsWQJ0Wq/WCnKNolyCsBwPH6KREQLghg21fq2yJNaQIUPYJPsnzeDBgxU+R8nJyZ06dUJEOqTuSAIrMxNbtMDUVBw8GKOi0M0NFyzAiAiszOBEVSZOnAgAvXv31no6tbCwkNSvLViwgKox37x5Q1yMg4KCqBpTQ+hQqSds3YoWFrQYsbIJLBb1uH//PkkiU1WRWiNFRejqigDYujVWW4FaMxKJJC4uLjAwUCQSNWvWjGzTrKysunXrRquMXY28ePGClD5pKy8vl8vHjx8PAPXr14+MjNy9e/f333/frl07ZXcgDodjZ2cnFvvt2oW18l5asgQBsFMnpHBxtGvXriVLlvj6+ior7uvq6lIWgKVqmE5gjRkzBgBGjx5N7bDEiJDarGdmZibJiJ8+fZrCYdWD/N4cHByqF5UgXTlhYWFBQUGkMcfZ2dna2rpcxyWhfv365ubmGRkZjL2LqoiLiwMAU1NTWhvak5PRzEzNzaGChw8fEscfoVC4efPm8PBwxY8SExPV8DVn+ezZvx8B8OuvaQwxfDgC4LRpNIaolODgYPJZuKEQ0aGO5ORkHo8nFAprK65MB//88w8ANGnShL7lcl4etm2LAKhJyi4iIsLU1BQAbGxsHjx4QN3sWBjF3d1dccj34sULGxsbmgKRBBYibtmCY8fi4MFIVcljdnY2Ee2iT5hJRWbMmAEAdnZ21GpyESsYuqXTVae4uNjS0hIATp48qeFQc+fi6tVlX9+4gcuWYWGhptOrlNGjR6e9tzi5d+/eNObvYSyfLK1btwYACoshqqG0FAcNQgBs0gQpr8N+8uQJOSFjTEqlGkheXlvb3lmzZgGAkZFR3Mdie3l5eVFRUf7+/h4eHqR3u3v34aRM2NgYPTzQ3x+joj4qi3vzBq2tUXEt9PPDkydx2TKkY8vLJrC0AqMJrGvXrnE4HKFQ+JxqMRhSF0P5+eTKlSsBwNl5MFMp/srZvHkzSYo/evRIvRGKi4sfP358/vz54ODgn3/++fvvv+/WrRsANG3aVOvlVwRSQ7d161aaxpdIsGdPBEBPT9TweLK4uJi0Ey5evNjU1FTx/Y0bN9ZKA4jlP8LPPyMAUnf2XwmPHiGfjwIBMqnife3aNeKJRp+MJdEiXK+sNqE92rZtC7RJ3shk6OmJANixo6Z7xcePH7dr1w4ALC0t/f39X70qE/hPTk5euXIlBXNloR/mE1gyGXbtis2bU5bAQsRdu3YBQKNGljk5RZQNWkvOnTtHvCDiqJUfR5RKpaSwa+/evdSOrDYLFiwggrD16tVr0aJF586dBwwYMHbs2BkzZixdunTjxo379u07e/bqrVuYlFRdE42bGzZogOQ87tQppEdMmYVFI+bMmQMA8+hXT5DJcPRoBKCrDhHflz4ZGRkxaXZcKT/99BMAaCWVTPSF9PT0/qlWQKG0tPT69evbtt0cMQItLT9SyhcK0dkZ58/H48fxyROsXx/t7MoWVBMm4KFDdM3c19f3t99+e/weHR0duiKxKMFcAksulzs7OwPAokWLqB05KysLAExMTKgdFhGLi4uHDj1iaipXwa2OLu7du0d0r6jV1ZPJZMSm/fjx4xQOqzbkMNPOzo6mdoO5cxEAmzatnZBHNURFRRUUFLAJLJYaGTsWAZBurxJvbwRAxhQh0tPTmzRpAgAzZ86kL8rff/8NAMoeslqEnGf873//o2Pwn35CADQzQ0qUAPPz80eMGLF3715HR0dFHdbNmzd79OhBwegs9OPu7t6mTRtHR0dHR8d27doxkMBCxLg45PGoTGDJ5XIvr4UdO+ao4VZOCW/fviXKUL9QLj+OiO8zdDRJp9cWuVzep08fAODz+VWpSQCAg0Mv5f2elRU6OGDfvujlhVOn4uLFePQournh2rXo7IxyOZvAYqmjkLLoVq1a0R1o5kwEQCMjNbVHVES7pU8Kbty4QfoZGW79Jh3QPB7v8OHDtXphaiqGhpYp5XO5H5JZGzeijQ0uWYJ+foj0J7C6dOky8j1cLpeuSCxKMJfA2rdvHwA0bNiQ8jqp+Ph4+jY5Bw8iADZoUDvNb6ooKCggx/4+Pj6UD75u3ToAcHNzo3xkNZBIJE2bNgWAM2fOUD54RESZLjK1XotFRUWGhoYR75k6dSqbwGKpSJcuCIBXrtAb5flz1NFBHg8Z6BsrLS3t3bs3ADg7O9N6YCiRSEhTzLVr1+iLoiKvX7/W1dXl8/mpqanUjnz8OHK5yOMh5RaCbALrE4WxCqyCArxxA1NSMDMTZTK8dg2ptVB/9Ah1dZHLrdyli24mTJgAAE5OTlSZWJWjtLS0RYsWAFBbn2s6IN7zFhYWGRkZeXl5z549i42NjYyM/Ouvv9avX79kyZJp06aNHj36u++WdOyITZuivv5HxQuKfyIRurlhfDyOGIHbtrEJLJY6ilQqJT5UavemqMKCBQiAenpInUlY5ZD6I6130crlcnI2eZPWdN3H7Nmzh8vlcjgcDcv5c3MxMhJ/+gnd3PD6dbSxwcJCbN0a792jPYHFthAyD0MJrOLiYnIOtmPHDsoHP378ONCptt6rF+0dQFXh7e0NAO3atSukQYEgLy/PyMgIAO7cuUP54GpAXEUo/3989w6trBAAKe+eKSoqEgqFC9/z5ZdfsgksloqYmCAAqmucUgumTEEAZMBAZvr06aRDTSFfQh/z588HgIkTJ9IdSBUGDx5M9sO//vrroUOHbt++XVREQW/Uxo3I5+OaNZqPVB5HR0eRSCQWi8Vi8TfffMMmsD4VGEtgEeztEQDv3qVlcLIDdHBAhqWiwsPDiUIfrZ5Qf/zxBwB07NhRu1r1iYmJREmjVqm0oiJMScHbt/HcOTx4EP/4A5ctw+PHyxJYKSnYogXu388msFjqKGSLRF9r/Lp1Qba2RQIB0qMc8BGxsbFaKX2qCHEw8/f3ZybcsWPHSNHo2rVrKRz29Wskt83jx7FvX/zuOzaB9bnBUALrl19+AYAOHTrQoYC7adMmAJgyZQrlIxNu3iwz+aJauasGSHW6gYHB/fv3aQpBxE0nTZpE0/i1Ijs7mzhUbtmyJT4+Xm2rVKn0ozPk/HyMjcWpUzWVvqpIUVER20LIUj3p6QiASn8mNJKainp6OGgQ9WbnyuzduxcAdHV1r1+/TmOY9zx9+pTD4RgYGNBhwVYrJBKJk5MTkUhXwOFwmjdv7uHh4evru379+sjIyGfPUqu/y+XkoI8PJiWVPdyxA2/fRpoOERwdHffs2XPx4sWLFy9u376dTWB9KjCcwCJKIlRXFpZRVITW1giA69bRMn6lZGVlNWrUCAACAwNpDfTu3bvGjRsDQEREBK2BqkEmk/Xq1QsAxo8fT8mAJIGFiKtXo709m8BiqaMQkYFOnTpRcpJUju3bt3M4HFPTFocOaeDGqjKK0qdbt24xEK4aIiMjSVKegVjnzp0TCoUAsGzZMmpHViSwEHHwYGzalMYE1uzZs4ODgxUPzc3N6YrEogRDCawbN264uLicP3+ejsH9/PwA4Ndff6VjcAJRsaHaO7E6Hj9+XK9ePVoFkhHxyZMnXC5XT09P7WwRtdjZ2ZFKPYKenp6trW2/fv0mTJiwdOnSnTt3njlz5t9/X1d/q7p3DwFQcQz51VdIk0sJm8D6/EhJSVEcfxUVFWn+uYiOvuXsPNbbe5emM1ONCxdw8WJUdPWtW0dxQ1B8fDyxgNm2bRuV41YLaVf8U4tKhIj43h/HwsJi9erV8+bNGzp0qK2trY6OTjmJmd695wkEaG2NHh4oFmNQEEZFYWLihwR6aioKhThkSNnDcePw2DG65sy2EH6iPHv2TFF2XVpa+m+t3MJrj64uAiClHn0fERmJAFivHqak0BWiHCNHjgQAFxcXBtSpVq9eDQDdu3enO1BVkOp1KyurNxRd7hUJLIkEHRzYBBZLHeX69esGBgb16tXj8/lOTk5isTg4OPgFFTaBR48eJWVBdGfAlWG49Kkq3r17R7aflPutleP69esk0PTp0ykfXDmBlZSEBgY0JrBYtAJdCSypVNqwYUPFwx07dsyfP5+mWN988w3QbASTkoL6+sjh0JUKKUdxcXHHjh0BYNSoUXTHGjRoEAD89ttvdAeqkS1btpCklYeHh729fblKBwUuLg9JSYudHXp4oI8P+vt/2CVKJHjvHtraoo0N5uUh0pnAevfunaurq+LhgQMH1jF5xMxCA6ampop945EjR0ZrnLTetm0bAHz77beazkw1IiJQRwo+HZwAACAASURBVAcVyXx7eyrrRrOysr744gsA8PX1pWxQFfjrr78AoEuXLkwGLUdISAgACASCcqbdEonk6dOnERER69atmzp1qru7u6fnwUqVZUxMsGtXHDcOIyLQ3h6/+gqPHkVkE1gs2iY/HwHQwIDeKMOHIwAyYxO/f/9+ADA0NHz69CkD4QoKCiwsLACgevMsmrh//75QKORwOJGRkVSNGR7+we4mIQE3bsQ6IFLPwvIRiYmJpPixQYMGxHxTQcuWLb29vbdu3Xrv3j01Uthnz54lDsu0FkZUJCIiAgAcHR2ZDFopI0aMAICNGzfSFyIhIcHc3BwARCIRHccMEgkqescLCnDbNopPc1m0Dl0JLIlEYmhoqHi4detW+syqXFxcGFg6LF6MANitG/WdaBXx8fEBgFatWjHQNXP69GkAaNy4MU0qpypSqdlifn7+/fv3IyMj//zzzyVLlnh7e/ft2/err9KFwsrFRwGQx8Pdu7F3b1y+HMlfHH0JLJbPD8oTWPPmzQPaPLAqEhGBX3+NbdpgYiIipQksqVTav39/AOjRowfDTs/FxcVmZmZaLK2/ffs2qTsLCgpS5fklJZiYiGFhGBCAPj7o4YGNGn24Rh04gPb2+OgRtmqF+fn0JrDWr1+fmZlJvk5NTd28eTNdkVg+WV68QABs3pzeKGlpaGyMABgeTnegNLIvUhYloZtly5YBQL9+/RiLSCgtLXVycqKphIEwbtxHJe0sLHWBjIyMNm3aAICbm1txcXFBQUF0dHRAQICnpydZLSioV6+eh4eHv79/WFhYbm5ujSNfu3aNyMnNmDGDgTeiDGOlTzWyZ88eWi9oSUlJzZo1A4AhQ4ZIaBZHlMvLdJDp1Ppn0QKfQwKLfAyeUWI/XjX5+WU6Efv20RoHQ0NDicQMY7s1e3t7ADhw4AAz4SqiMFv8/vvvVXzJmzeYkIBRURgUhH5+KBKhhwdaWyOfjydOYO/eWFyMtrZ46xabwGKpBaamps+fP09PT09PT9+1a5fmCaz//e9/AHCIqdrliAgcNw7378eBAxER7e3x7l0MCcEbN1CFlVt1zJ49GwAaNWr08uVLSqZaK8RiMa2btGrIzs62trbWvIwuMxOjo3HHDkxIQGKZu3Ahzp9PbwKLhaVG4uIQADt1oj3Q2rVlmbKCAhqjkKLy/v37M6mFnJuba2JiAgBX6Lab/ZiFCxcCgLW1dX5+Pk0hNm1CAOzYkYmzWxYWVcjNzSVNKl27dq34ly+VShMSEoKDg318fOzs7JSTWTwez87OzsfHJzg4uNIk0b1790j+y9vbWyti6sOHDweATZs2MR9amezsbD6fLxAIshSlmNSRkZFhY2MDAH379i2mr3FdCW9vWoy8WLQLjQksLpfr+J6mTZvSlMCSSqUCgYDL5TJQFLBjBwJg//40hnj69KmxsTEAMHlUTnr3tNhdQqHZYmkp3rmDvXsjIp46hb164cCBbAKLRVVMTU379+8/YMCAAQMGODo6jh49+u+//96+fbva+XFbW1tg0OiTJLAQ0c0NDx9Ge3s8ePBD7Y+pKTo5oUiEAQEYGopxcaii8um+fftIA92lS5donX9V3L17FwCMjY3p8GOtBplMNmDAACJw8+7dO0rGTE0tS2AVFmKbNtizJ5vAYtEmp08jADJQPCSRoKMjGhrSeEcmLdsmJiYpjKltvefHH38kBQWMRYyLiyOrX1ovy8XF2LgxAiB1HYosLOpTWFhI2m7at2+vSnolLS0tLCzMz8/P2dmZNAYqsLS09PLyCgwMjI6OLi0tffr0qaWlJQAMHTqU7rKgqggODib5d61EVyCVSps0aWJhYaGvr+/s7Ozn5xcWFpaTk6P5yLm5uY6OjkQUIi+PCXV8RPz7bwRAZ2dmorEwxCdfgZWSkkIuQ3QMXg6ZDDdvxtOnP5xExcZSeZZYWlrarVs3ABjBjFDEewoLC0nJPTO2YuWg3Gzx3r2yBBYijhiBRkZsAotFVSq2EJKlkmKtExQUlJycrOJoUqlUR0eHw+EwlnZRJLAePkRbW2zTBsPC0MsLO3ZEff1KWm75fBwy5PjAgQNnz569ZcuWc+fOVXx3d+7cMTAwAICtW7cy8y4qhVwb9+zZw2RQ0gHasGFDCvfDigQWIh47hgBsAotFm+zbx5xHzf37eOpUmfobIsrluGsXZYM/f/7cyMhIW+Xkr1+/NjAw4HA4zBxXFBcXt2vXDgB+/PFHumOtXo0AyArosWidkpIScqRkbW2dWnvb1IKCggsXLixfvnzgwIGkZFKBkZERqb3y8PCg6rBKDRSlT5Rki9RDLpd///33REZQ+VfE5/M7deo0Y8aM/fv3q74MVkaRfGzTpk1GRgblM6+K/HwUCpHLxfR0xmKy0M4nn8C6cuUKAHTr1o2OwSty6RICoMIus0ePDypxmkPaZJo1a5adnU3ZoKpB9mljx45lOC4dZovKCayUFHrPe1k+MyomsIKCgr7++utyqgp2dnbTp08/cuRI9R/VJ0+ekE80I3PH7OwPCSxE/PFHBPhIA+vNG4yOLuu69fJCOzvk87FPn0XwMQYGBo6OjiNHjly8ePHWrVuJMai3tzcz76IqSG2Fsm0C3Rw5coTD4QgEAmoFFt++RWWzh1Wr8OZNCodnYakdGzciADLWnrtiBfL5ePUqIqJMhiYm1Awrk8n69OkDAMOGDaNmxNpDlnCaN56rHsvOzo6BHpyCAqxfHwFQGyL1LCxlSKVSLy8vAGjQoAElxqyJiYmKTkMOh9OsWbNGjRrR142rIsR2WYuiLvPnzwcAPT29S5cupaenV1O/5unpGRAQEB0drUoLVGlp6cCBAwGgadOmSUlJDLwRZQYORACkbqPJon0++QTWgQMHmCxZunQJnZ2xdWsk+1YKE1jh4eFks3SVrOyYJSkpiWT9mRS4YcBssbAQt26lXTWW5bOhGhH3xMTEoKAgLy8v5YM7LpdLJBVCQ0Mr6oOePHkSmFL23bkTTU0xJAR37Cj7TkEB+vpi9SX2JSX48GHy0aNHV65cOXHixF69ejVo0KBcPsvU1LR9+/ZaPJMk5Ofnk/IKha0erTx48ICEo1WNIiQEGzfGNWvoi8DCUgP+/giAjFm3r1iBY8agoyNKJFQmsNatW0d2tkwe7JcjJSVFV1eXx+NRsruuhujoaC6Xy+fzb9y4QWsgBT//zFCfKQtL5cjlub6+XezszMzM7t69S/nwDx8+1HrpE+H3338HgDFjxmgl+ooVKwBAIBCcPHmy3I9KS0vj4uICAwO9vLzq169f7tRT0WlY6bGuVCodNWoUuUQ/0oaa+tatCID/+x/zkVnogq4EFiIqbzPevHnz6tUrOqKsWrUKAObMmUPH4BW5dAmHDsW1a5GojffogTdv4oUL+PQparK/S05OJk18a9eupWqqtYVoB/7000+MRWTAbHHXLgRAJyeahmf53Cgn21mpiqdUKo2LiwsICPDw8BAKhYpbOI/Hc3Jy8vPzi4qKIqfia9euBYBp06bRPe3du5HLRQCkxPU4Jyfn+vXre/fuXbx4MUkxf/XVVxSMqzGkrH3u3Ll0B3rz5k2rVq0AQCQS0RooLAwB0MaGFUhm0RpLlmxxdh63Y8cFZsKtWIGrVuH33+OaNWUJrOvXcfFiXLcO9+zBkyfx2jV88qR2phMPHz4kLsYnTpygbeIqQa5REyZMoC9Efn5+y5YtgUFzW0TMzS0zkdTGASsLC+IPPyBAXsOGt2mTOnF1dQWAgwcP0jS+ijx9+hQAjI2NmbeG37VrF4fD4XK5qtR/latfU14J29nZiUSioKCghIQEVOpJNDY21paXdGoqcjiop4fMyqiy0AiNCSxmmDFjBgCsU27JoBOSwCotRQcHvHoVe/TAw4c/CMo0aoRduuDXX+PMmbh2LYaGYkwMpqZKZDJZNWNKJBJnZ2eyS9SK7QXh0qVLAGBhYcGMKwQzZovv3mHDhgiAly/TF4Tlv0tRUVFUVNSCBQu6devG4/EUt3B9ff1+/fp1794dANavX0/rHA4eRD4fAfC336gfPD09XSAQ8Pn8tLQ06kevJbGxsQBQv359WsvBZDLZV199BQCOjo5FKqrcq4tEUmbwrCVxfBYW/OabbwAgJCSEmXAkgZWVhc2bY1ISmphgYGAl8nxEoa9hQ7SzwwkT9gwdOnTixIl+fn6rV6/euXPn8ePHL1++/PDhw8zMzJKSEiKQN3HiRGbeQjUkJiaSOo5KPc4oYcKECQDQqVMnhve3fn5sCQOLlli+HAFQR4dWK4E1a9aANqRUKkLME8+dO8dk0CNHjvB4PA6HExQUVNvXZmRkHDt2bO7cuT179izXadi4cWOi1qevr8+wSWs5unRBAAwL0+IUWKjkk09gDR06FAAOHz7MTDiSwCJfdO2K3brh4cPYqxe2aIECQeWLsG7dUgUCgaWlpZOTk5eXl1gsDggICA0NjYuLS01Nlcvlfn5+ANCkSZPXr18z8y6qonPnzgCwe/duugMxaba4eDECoJcX3XFY/usUFBRERUX5+fk5OTlxuVxFZXX79u3pW4gcOlSWvaLvMH7YsGEAEBAQQFeA2kAqwkJDQ+kLQZzpzc3N1baerBWLFiEAalthjOW/S//+/QHg1KlTzIQjCSxE3LYNx4wpq8BatgxnzsRx43DgQOzaFa2t0cjowyKqd+9ZUC18Pr9Jkyb0lXLXirFjx9JXeHv69GkOhyMUChMolF9VjYwM1NdHDgfv3WPijJOFpYzNmxEAeTykuTaKlD6ZmJgwX/pUjgULFgAATcI7lRIVFUUST5qv9CQSiaLT0MLCgqSuDA0Nj2nbrYZkQSdN0u4sWChDmwms1NRUZQ/Ue/fuqVF/1KlTJwCIjY2ldGpVokhgIaK3NwoEHzSwZDJMTcWYGAwNxbVrceZM/Ppr7NIFPT1vVrPwMjAw4PP5fD4/ug4oje/evZvUHdAahWGzxbQ01NFBHg9pOxD9hElKSgoMDFQ8PHDgwLVr17Q4n8+GzMzMTZs2cTgcRWW1h4cH5Z/xw4fLslfLllE78EcQJa+WLVtqsT5UwcaNG4FOk+ljx45xOBw+n3/+/HmaQpTj2TPkclFPD9+8YSYgC8tHkEVUXFwcM+EUCSyZDHv2rE4Dq7QUX73ChAS8cuXBkSNHtm3btmLFih9++GH8+PFDhgxxdna2tbW1sLAgCR03Nzdm5l8jDx484HK5QqFQDZe06snKyrK0tAQA5bs2kyxd+tLefgozKvUsLIiIISHI5SKHg3/+yUA0rZQ+VSQmJgYAmjdvzlg44jRNh6Xpo0ePbGxsACBM27VPd++imZl84MAH1TdFsXwqaDOBNXv2bOUCHCMjI1WMDMpB8rvp9Htj5uXhkiV45QpOnlz2nYwMtLPDx49rfm1JSUlqampcXFxoaGhAQIBYLPby8nJycjI1NQUAMzOz9u3b0zp5FXn37l2jRo0A4BKdDS3Mmy2OGYMA6OfHTLRPidjYWBcXF8XDyZMn76LQ1fy/zbJlywDAy8srICCAfNIBwNnZmaq10ZEjZVWfdKsvy2QyYkR44cIFeiOpQG5urr6+PofDefr0KeWDP3r0iFSGMtaTTujXDwGQTrF4FpYqIZ9u+lreFOTk4MWLuH8/Kgoob936cCKoNq9evRIKhVwul/mipKogVavz5s2jdliiguzi4qKtDVhKSoqOjg4DKvUsLIiIZ86gjg4ClOW86efHH39kuPSpUmQyGdmL3blzh+5Yd+/eJQvUb7/9lqZDyuXLlwPApDpQ+9SqlQ0AaMUqjYVyPu0EVnFxMYfD0dXVpbs04N07dHdHAPTxoXjkFy9ekP3Yw4cPKR5aLZYsWQIAw4cPp2l8rZgtxsUhAJqaYkEBYzE/DdgEFn2QQ6fTp08jYl5eHrVprIgI1NVFAKRf0BwR0d/fH7Rni1MOkUgEAIsXL6Z22Ly8PHL6yvzbPHgQAdDBgeGwLCyIiIaGhgCQl5dHa5TSUvTwQIEADx2ifvDJkyeTDRj1Q6vFrVu3OByOvr7+gwcPqGpH2r9/P6nZpyN3rzqTJk0CmlXqWVgQEa9eRQMDBMBFixiLyXDpUzWQD9ry5ctpjfLkyROSKRs2bJhUKqUpyp07dwCgQYMGWi99mjlzJk2FZizMw0HE6sUF6GPOnDlGRkZEQBQAOnfunJCQkJGRYWVl1aBBA4FAUOMIjx8/trGxadmyJWldpgm5HEaPhkOHoEEDuHwZWremeHwfH59t27ZNnz6ddMdol8zMzGbNmkml0idPnnzxxRfUDp6SkuLo6Jidnb127drZs2dTO3j19OgB165BUBD4+DAZtq5z48aNYcOGKT6DUVFRs2bNGj9+vFYn9TkQHR3t6upqZWWVlJSkEHfPz8/fvHnzypUrc3JyAMDZ2fnnn392d3ev7eCnT59evvxWXNwCX19Yu5bimVfKy5cvW7RowefzX758Wc4+mXnI79bAwKBPnz4GBgYmJiaGhoYGBgbka/JFvXr1jI2NyddGRkZGRkbKEvsVQcQRI0YcOXKkQ4cOV69e1dfXZ+ztAEBpKTRtCpmZcOMGdO7MZOS6zs6dO62trfv06UMeikSivXv3anVGnxslJSVCoVBHR6ekpITWQL6+sGULNGoE169Ds2YUD56cnExsQ//991/K1y3q0bFjx6SkpNzcXAAQCoWmSjRu3NjS0tL0Yxo3bqw44ajIq1ev7O3ts7Ozt2/fPnHiRAbfR3mePXtmY2PD4XCePHlCavdYWGhh1ixYvx6mToXNmxmLKZfLrays0tPT79y54+DgwFjcioSHhw8ZMqRLly7Eu4YOUlNTXVxcXrx44eHhceLEiXLi69RibW39/PnzmJgYYm2kLc6fP+/u7m5nZ3f//n0tToOFGrSYPJs9e7aTk9Oo9wgEglWrVikmJhQKra2tnZ2dFcLnwcHBUVFRCQkJue8Nls+ePQsAffv2pW+Scjn6+CAAGhtjfDwtIRISEjgcjqGhYW6tjKNpY9y4cUBD9bt2zRb370cAtLNj7eo/IjY21t7e/ux7PD092QosSiB7jAULFlT8UcVqrLNnz6o+8qlTp4RCIQAsX36EuvnWzIABA4B+R0VV2L17N5fLVcjkq4hQKDQzM7O2tnZwcOjRo4eHh4eXl9f48eOnTZsWEhJCSszMzMwSExO18qZ++IGWCt9PHV9f3x07digeCoVCLU7msyQ1NRUALC0taY2yZg0CoFCIMTF0hfD29gaAqVOn0hWgNjx58kRfX5/L5Zqbm/P5fBWvUfr6+k2bNu3YsaO7u/uoUaN8fX1/+umnwMDAvXv3krVT//7964IQ4ZgxYwBg+vTp2p4Iy+fFzZu4eTNu24akQVUux7/+QsZrdkjp0y80lz7VSFFRkYGBAYfDSUlJoWP8169fk5Lz7t275+fn0xFCGVL6VOmSmEkkEglZe7NN0J8BdauFcOvWrZ06dbK0tKz+tBwAjIyM2rZtS5p03Nzc6LupL1yIAKinR6/NOanCWLt2LY0xVObmzZsAYGJiUkBpx938+fNBe2aLpaVoZYV8vuTCBdrl0jTn0aNHt27dUjw8efIkTf0dbAshHRQVFREppWr6gtVLY0VFRenp6QGAWCxmeCdz+PBhANC6Wl98fDwpj5o4ceLEiRNbtmxZmyxW5XA4HJIRi6TTort6Hj5EAwP08LjPwFLyE4JNYNHN3bt3AcDe3p6+ECdPIo+HHA7u20dfEHz48CGXy9XV1X358iWNYVRAJpP16tULALzfe4sWFRWlpqYmJCRER0eHhoYGBgb6+/uLxWKRSOTp6ens7GxnZ2diYlLNNcrS0lJfX59yVXj1UKjUp6WlaXsuLJ8Lq1ejoyP++Sdu3IjW1vj339qaSHxkZHiXLkXOztqagIKhQ4cCwA8//FBcTLHvZ15eHjGdJ3Wd1A5eKefOnQMAOzs7BmJVD3GJXbNmjbYnwqIpdSuBpayB9ebNm4SEhKioqODgYCJ8LhKJPDw87Ozs6tWrp7ivk69btWoVGBhYVFRE7Qw3bSozbz1Cc61DWFgYALRo0YK+JuRaYWNjY2hoqKOjoyiC8/PzCwoKCgsLi4uLU8OsOjIyksvlatdscePGK5aWTTw9PbU1AdVZv369cgWcg4PDo0eP6AjEJrDogHQ59ejRo8Zn5ufnBwQEmJmZqZLGio6OJmo1kyZNYv4cXiKREAOsGPqKKGoiKyuL9Af5+voqvpmUlLR79+5vv/1Ww36WVUzJxP6fvTOPqzn//vi5W91WLUQSWqRCInvGmqWRrNmzy2DE2JqxZRlk/FCDIWPLYJI9a2XP/i1rodWSihba13vv+f3xznVHSXU/y6XP8+GP7nU7532pz31/Xu9zXudLODm5AsCuXbvYXYZKMXPmzC5duoz/iEAgYHtF3xuXL18GgO7du9MU/8ED1NZGAFyzhqYMnxg+fDgAzJs3j/ZMlbJu3ToAMDExeV/NwaL5+fmvX79+8OBBaGjov//+u3Xr1pUrV3p6eg4fPlwkEvH5fJq2ATWAuNQvWrSI7YVwfBekp2ODBp8G8UZFYePGzNdelVFQgFpayOMhPaVPVWfAgAFk0yUUCh0cHDw9PYOCgt69e6dk2OLi4r59+wKAhYVFamoqJUv9KvLSp9iqDD6jk8OHDwNAt27d2F0Gh/KwKWD99ttvipt1ExOTqrtdZmZmPn782NDQEACIBR05pPLx8fnw4QMlyztwoGx46549lMSrDJlMZmVlBQAnT56kPdnXiIyMVFNTq7wd2tDQ0N7efuDAgT///PP69esPHjwYHh7+6tWr0tLS8gHfvn1L/o/Wrl3L/NuRk56erqGhwePxVGcX+CWYEbCePn2amJi4ZcsW+TNHjhy5d+8e5YlqG05OTgCwY8eOKr6+vIwVFhb22Wtu3LhB1KvJkyezZYTp5eUFAFOmTGElu0QiIbuuzp07f2ncR3JyclBQkIeHR3XFrIEDB7LemxMQEAAAnTp1YncZVWHSpEnyr2/durWTtgHnM2fOXLVq1eOPqKur05SodpKamtqvXz8jIyMNDQ0vLy/KBxGmpKCpKQIgM+7qDx8+5PF4WlpaaWlpTOSriOjoaLFYzOPxqC3nJC71EydOpDCmMhCXei0tLeUL6lNTUb5nLyjA1FTMyEDF/8D4eKTIB59DVbl0CZ2c/vOMqSm+fs3SahAHD0YA3L6dtQUgrlixAgDU1NSaN2/+WU9Ss2bNJkyYsHPnzujo6OruWyQSybBhw4jCnpiYSNPiK4S0Hm/cuJHJpOXJzc1VV1cXCASsNANxUAibApaSXLlyBQDMzc0lEklwcHCHDh3I77a2tranp+erV6+UCR4S8paMqGesq8/X1xdo9vOqCrm5uaQxc+bMmbm5udHR0efPn//777+XL18+YcKEXr16NWvWjFjwVIhAIDAxMenSpcvIkSMXLFjg5+d34sSJLl26kLfGen0ZcSby9PRkdxlfxc/Pb9CgQUc/0qRJE8oFrJSUFCMjo86dOzNTP1x7SEpKEggEYrG4ukp6eRkrODiY/NWtW7dIqenEiRNZHOMSHx9PblpqUIOpPGTsQ4MGDarYIpSQkBAQEODh4WFqavpVAevff/+le/1fpaCggBxRPnz4kO21fAWxWCzfNx88eFBRz6IWroWQJiQSyZYtW0ins3xkgUAgcHV1PX/+PCUXmYIC7NABAbBrVywqUj5elfjxxx+BhhGlVaS0tJQ05iiWiFJCYmKiUCgUiUQM33NWQr9+/QCgX79+AQEBZ86cuX37dmxsbHWLzhCxf3+0s0Ny9Hn5Mg4ahBs2/GfunLU1Uq2scqgYZ8/ijz/+5xkrK2TRpWj3bgT4fEkMsm3bNnJBPnLkCCLm5uaGh4f7+Pi4uLh8NupBR0fHycnJ29s7LCwsPz+/8rAymWzy5MkAYGhoGB0dzchb+URgYCDQWe1bdchRaEBAANsL4VCKb1jAmjlzJvzXEy48PNzFxYXH4wEAn893cXGpWTnJ7du3tbW1u3ffuHgxdcv9Gjk5OWQ3ye7dC3Fwb9WqVeX9mPIGT39/fy8vL9LdaW5uXqFfab169QwMDN6+Zd986smTJzweT0dHR0X88r+En5/fDz/88PtHGjRoQK2AJZVKSZVQjx49WFcVvzNWr14NAKNGjarZt5eXsTZs2KCrqwsAEyZMYH0IMZkH5+/vz3DeQ4cOAYBIJLpeIzPCp0+fbtu2zc3NrV69ehUKWCrSWTxr1qxvQmHnBKxvmgcPHnTs2FH+k//ixYuIiAgPDw/irwcAJiYm3t7eytQxSaXSceM87eyyLS0xI4PCtX+F27dvA0CdOnWoqsSvFkuXLgUAc3NzOpzs3N3dQWVc6hFx3bp1Ffp2CQQCIyMjGxubrl27TprkOXkyLlyI69fj7t148iSGh2N0NL59i/Ji/f790dERN29G5ASsWktcHDZtivK96IcPqKeHX6izZoJ371AgQHV1pMd8tnL++ecfPp/P4/Eq9BOQSCRRUVH+/v7u7u7EhV2OUCi0tbX18PAICAh4+fJl+e+dN28eAGhpad28eZP+9/E52dnZampqqlD6tHXrVgBwdnZmfUfNoQzfqoAllUpJb7Ci1zXh4cOH7u7uIpFIfgcYHBxc9TLLx48fE4V72rRpDPeUeHp6AnsdOoi4c+dOcnWrxHy6ckpKSl69ehUeHn7w4EEfH59Zs2Z17doVABo0aFBhdyHz9OzZEwB8fX3ZXkhlVNhCSGGLEylONjIy4kxYKYcUMCrZP5Kdnb169WoiYxFReMSIEaogNR48eBAA2rdvz2TSR48eaWlpQXW6Mr+ETCZ78uSJn5/fkCFD5CqhQCAQCARKFu1SwqNHjwBAT0+Pcj9HahGLxVM+0qNHDzoErPfv39+9ezckJOTRo0fyJzds2EB5olpFXl6el5cXaUhp2LDhZ0fQHz588PX1NTc3J78Xampqbm5uYWFh7URWpQAAIABJREFUNfjoITNbGjRoEhNDsf3wVyEf8cz7FURGRhKnqmvXrtERX+5SrwpW7u/evSOHAb169XJ3d//xxx87duxoaWlJTmHltG7dHQC/9EdPD6dNw/798cIFNDPDpKRPAtasWZiQUPbHwoITsGoBQ4bgokWYlYVpaThqFHp5sbweR0cEYN5LPjg4mGz5qugynpKSEhwc7OXl5ejoqKampvjbZ2xs7Obm5uvrGxERIZVKyahlNTW1kJAQut/Fl1CR0qfz589ramqKxWJtbW1HR0cvL6/g4GBWzjw4lOFbFbDIRAMLC4svvSAlJcXb21t+QNS6deuAgICvemwlJiYSXWzQoEHMCy5xcXFkg6K8S18NiIqKIq0E+/fvpzZyq1atAODw4cPUhq0ZJ0+eBAAzMzNVkAO+RHkB6+rVq61bt6ZkZ3zt2jWBQMDn80NDQ5WPxqHIjRs3yJ0hJT9d2dnZ5ubmpKTU2tq6xrIyhRQVFdWtW7fCkwOayMzMJKMG5SO9qEIqlT548ODChQsjR44EgFWrVlEbv2aQFqSDBw+yvZDKEIvFER/5/fffKRewpFJp//791dXVj9M9P6U2ERwcTNpphUKhp6fnlybbSqXSsLAwNzc3eT21tbW1j49P1bvD9uzZAwAikagqk1Up5+LFiwBgaGjI5EDPwsLCFi1aAIAXnTfexLxm/vz59KWo1kqcnJzKi5ulpaVv376Njo6+fv362bN3d+3C9etx4UKcPBkHDcKuXdHGBo2MUCAoM0fr3x/v3sW//8Zhwz4JWNbWOHRo2R8dHRYErFu3bim6TbN+y/39U1iIy5djt27o5ITr1yPrB97r1yMAUr3rqJwrV64QhxZvb+8afHtubu6lS5dWrlzZv39/UrYvhxwBCoVCdn2WSenTsGHDWFxDTEyMkZERKdT9rH6NOOUHBgYmse3fz1EVvlUB66effgKAJYp1xhWRnZ3t6+vbqFEj8gPapEkTHx+fL7WPpaWlkeqJnj17Uj61tIq4uLgAwBoGBvb8l4KCAjs7OwCYPHky5cG3b98OAF26dKE8cg2QSqXkflhuMKSCBAUFbdu2Tf5w/PjxkyZNIlfY1atXK1P1mpaWZmJiAuy5hHzfTJs2DQB+/fVXSqKR+0B9fX17e3sA0NHROcrebGk5pFB01qxZDOSSSqXOzs4A0LFjxyLafHTCwsIAoHHjxqogavv7+wNAjx492F5IZZRvIaz6AJaq8NtvvxENgnJb8dpJQkIC+T0CAAcHh//9739V+a7k5GQfHx/59klHR8fDw+PBgweVf9e1a9dIIcB29iyQie3mZtKWxghz584FAFtbW1q3jg8ePGDdpR4R9+3bR27/lKxaff8e09PLBCypFDt3xqVLVaWFcMaMGXsU5jdx4yOY48YNnDoVKZ2BUBOePUMANDBgTEp7+PAhKbmgykFPbgNqa2vL4/H09fU9PDwoiVxj3rx5w+PxtLW12brFTkpKatq0KQD06dOnqKjozZs3hw8f9vT0bNeu3WcGOD17Dh0zBrduxQcPsMKNYWEhRkR8GpUZH485ORgd/enFOTmoMo6F3yffpIAlkUiIgFpFu6ji4uKAgAB5t7Curq6np+dnTsDZ2dlt27YltVosVhKGhoaSCg5q7we+CtFHrKysvnQqqwz5+flkXuTdu3cpD14DNm3aBAC9e/dmeyHVoLS01Nvbm8/nE4G1Zk0EMpls4MCBAPDDDz+oSEfn90RBQQHZfzx9+lT5aOnp6aTW6cCBA4WFhRMnTgQAHo/n5eXFbt/+kydPyN3LVx1DlYfMPaxfvz6tB2IymczS0hIAWCytl5Obm6ujo8Pj8WJYtLD9GuUFrEmTJo0ZM4aSH4mTJ0/yeDyhUHjlyhXlo9VySkpKfH19yfG7np6er69vdVXa4uLioKAgJycnUgpKJDB/f/8K/6/j4+PJVWvRokUUvYOaEBwcTDpomLlNCg8P5/P5QqGwisqgMhCX+mXLltGd6Eu8efOGmGz8888/lAQkAhYi3r+POjqcgFXrYaP0qWKaN0cApKcj+DNiY2Pr168PAGPHjqVjg/f7778DwPDhwymPXF3atGkDAOfOnWM+dXp6uo2NDQB07tw5Ly/vs7/Nz88PDw/39fV1c3MzNDTs3t1L3uysrY2OjujlhcHBKC9EJgqnfAKzqytevowmJp88Hy9cwEGDmHlntZRvUsAiB+ZWVlbV+i6ZTBYWFkZKnABATU3N3d2dDGIoKCjo1q0bAFhaWrLuNU4a7picikVmQ4jFYvr84xcuXAgA48aNoyl+tcjJySHltZs2bbp7925KSkrN7KVKSjAhAeXf+vYtFhRgSsonSb6oCKk1K7x06RJpca1Xr14NXJZ8fHxIRU+F/o4cSnLgwAFSK0RJNNLX1r9/f/kz/v7+xNrP2dm5BsOeKKRTp05Av5HB8ePHeTyeSCS6evUqrYkQcc2aNSqyvUNEMifohx9+CAwMvH//fvmdFusoGgw9efJkx44d2traRNpQsijj+fPn5OKs4jaF3wTXr18nfW0A4ObmpqQ1QUxMjJeXl9w5Tk9Pz8PDQ3GUVWZmppWVFQAMGDCA3WJGmUxGziMZGDeRl5dHarqZ6UFm16VeJpP1798fAAZRd2cmF7AQcfZsHDQIN2/GFSs+vaB1a2R+wzJjxozp06cf/IhIJGJ6BbUWxkufvsiCBQiA9A/zev36dZMmTQBg4MCBNB0tv3r1it3SJznEiuunn35iOG92draDgwMA2NnZfXX/LJVKo6Ly/P1x/Hi0tPyPc59AgPb2+PPPePo0tmiBzZoh+VzlBCzm+SYFLA8PD2V6oG7fvj1s2DBSzMLn8wcOHEhGa5mYmKhCw8KOHTsAoFOnTsyki4uLIzcMO+VKMg28evWKDIH+rPCNLVq2bEncQAjq6urm5ubdu3d3d3dfsmTJ9u3bz5w5Ex2dUvmswpgYBMADB8oeDh6MFy+iqSnKq/tDQ3HgQIpX/u7dOzK+msfjeXp6Vr1S7+7du2pqajwej90e+O+YPn36AMBff/2lfKhz584BgKamZkJCguLz165dI8d0lpaWT548UT5Rzdi1axdRWOhL8ezZM3Jd2rJlC31Z5KSmpopEIjU1NVb8Bz9j8uTJcpmAoK+v7+Dg4O7u7uPjExQUFBERUZVt6N9/4+vXZV/fu4dPnuDp0yi/AOfnI0UlFIiIz58/J2ebhoaGYWFhNQuSk5NDgowdO5ayldVKMjMzPTw8SM2UpaUlhaWFhYWFQUFBpEeP7KCcnJyCgoIKCgp69eoFAG3atFEFyZUcy5mbm9NdazxlyhQAaNu2LWNV82S/yrxLPX60sKlbty5NB71RUThhAqrCaJkZM2aMGDHij49wAhajMFj6VBnx8XjzJiYm4osXn06qk5I+NYkVFqLSvwhpaWnW1tYA0KNHD1rVJeJEoeR8IeW5f/8+aTOicCzVVykoKOjevTv5NExNTa3ut799i8HB6O2NTk4oFpcpWQcOoKMjbtuG7u6ICgLW7dv47Bk+e4a7dnECFr18ewJWaWkp6R9UHE5UAxISEjw9PYltuZ6enp6enuJZIovIG+7u3LlDd66ioiJSzzlixAi6cxHXz+XLl9Od6KuQYYtisbhPnz4ODg7kx6k83bptBUCxGM3N0ckJ3d3Rywv9/TEsDKOiMDcXY2LQygqtrMpqSpkRsBBRJpP5+vqSYpyOHTsmVqHN+sOHD6TxWxX8X79L3rx5IxAI1NTUMpQeGp+Xl2dmZkYqBMv/bVJSUocOHQBAW1s7KChIyVw1Iy8vj6hLNF0z379/T3r6mKzZdHV1BQDW59yRujOBQDB69OihQ4e2bNlSXV29/NWpc+ch1tY4aBAuXIh//41Xr1awkVZXR2fnsq+XLkU/P+zfHy9fLnsmORnNzalceXZ29uDBgwFAIBD4+PhU99tlMtnQoUMBoHXr1gx0p36vyGSygIAA0scnFou9vb1pMo+7e/fuxIkTNTQ0yA+kjo4OOQVUhRl5iCiRSIilKVWdbhUSEhLC4/HU1dWjoqLoy/IZpAWBYZd6RExISCCFlkeOHKEpxbBhCIALFtAUvhpwLYRssnAhAiDrm9WICLS0xEGDcPBgtLAoKxQ0N/90CnTlCvbrp0wGJr1r2Cp9Kg+5Gbl37x4z6SQSCdlaUFKkUlCA16/junX44AE6OqJEgm3b4pUrnwSsYcNw9GgcPRp79uQELHr59gSskJAQAGjevDkl0dLS0pycnJhRcKoOGUE9ZswYuhPNnDkTACwsLLKzs+nOdf36dQCoV68euyWsFQ5bLCwsjImJuXTp0r59+1auXDl16tT+/fsPHnxZW/uLE6ABcO9e7NwZN25EYowoF7CePcO0NExLwyNHaBGwCFevXiV27IaGhqdPn678xUOGDAGA9u3bFxcX07Wg2g3pQRs5cqTyoYhLert27b7UhlNUVES6zEgVHit2ZqQMlg49VCqVDhgwAADs7e2ZFDJOnz4NAFZWVkweDH7G8+fPyWQcRf9pqVSamJh44cKFP//8c9asWX369GnSpEmPHl7lr0i6utiuHY4ZgytXYmQkGhjgkCFIRE4GBCxElMlkPj4+pLp51KhR1arEIdtrAwODz6oOOb7EmTNnFG0lvb29Hz58KK+N6tmzJwNzS7Oysvz9/Vu2bKmjo1OnTp3bt2/TnbHqkCEYNjY2NJkGfvjwgTjcV3jSQCvkf5nJNlupVEp8NiifBqvIgwfI46GWFrJqUo/ICVjsEh6OAPjlKfNMIJViq1YoryYOC0NbW5RIKBSw5N41zZo1Y8C7JjIykvnSpwqZNWsWMDVISiaTEYvnunXrUuJOK+fZM3R0RES8cwdbt8YBA7gWQqb59gSsqVOnUlvIc/nyZQDo0KEDVQGV582bNyKRSCQS0WpdfPToUQBQV1ePjIykL4siZEL8vn37mElXnry8POLlX/VhiwUFmJCAYWHo74/e3ujhgU5OaGuLmpp45gx27owlJdiqFd669UnA6tkT+/bFvn3RwYFGAQsR09PTiaUrETK+JE75+fmRMsOq1Gpx1AxiC3X27Fkl49y7d08gEAiFwq/+Vvr7+5NpXz169GC+8e3evXtEPKW8vmPp0qUkMsM/rhKJhLQVX2OpcyEnJ4dcnapydFFcjAkJGByMPj5lFyVj4/+IWX/9hQYGmJCA5uaYnf1JwFq4EHftwl27cONG6gUswunTp8k0Azs7uyqqUcHBwXw+XyAQsN7g8A0xd+5cxUl/2traRNc2NjYODAxkciUymYyYbV2W66MqQElJCTnqp2l4K7EpdHR0ZN7wi2GXevxooGliYkK3/aKzMwIgeyb1iIgFBQWbN29WvBb16dOHxfXUOiQSrFcPAZDFtpj4eLS0/M8z1tb4/Dmam+ODB5iaiqmpeOxYjQWskpISsntv1KgRY6a05HrIwKyJyiHDylq1asVArl9++QUAdHV1KX/XcgELEadNQw0NTsBimm9MwCotLa1Xrx4AUOj/kp2dzefz1dXVVao4Zfjw4bRK1K9evSI2K3/++SdNKcqzd+9eAGjTpg1jGT+DKPG2trbKV3ZIpfjsGXbujIh49Sq2b4+urgy1ECpC2gmJkNGuXbv4+PjPXvDo0SOxWAwAhw4doncptY+0tDT5/XlRUdGmTZuyKndN+xqlpaWkpffXX3+tyuvDw8MbNGgAAKampsxvSohdUdeuXZcsWbJ///67d+8qf29DJtAJBAJWBgIS7cydWBowi0wmI03WyjTQZWTgrVu4Zw/+9hs+fowGBoiIK1bgnDmfBKw5c3DrVty6FdesoUvAQsSYmBgixhkYGHz1vzImJobUnbHev/ltUV7ASk1NXbhwoZJXoZoxZ84cAFihaL6tAmzbto3UclJedHD8+HEA0NLSiouLozZyVWDSpR4Ro6OjxWIxj8djYHbY7dsIgHXqIFvDwInfwrJly7hJzWwycSIC4Lp1rC3gxg3s0uU/z3Trhteuobk59uqFzs7o7IwdO9ZMwJJKpaNGjSItKQzUycohpU8szjAllJSUkCMuug8pyY5OQ0ODjonGsbEon7GUkYFNm2J4ONrYfBpTeOkS0t9GVav5xgSs8+fPA4C1tTW1YYlXAmOFSFUhPDycvoa7kpKSzp07A4CLiwuT1aRFRUXEgvr69euMJZVD+bDFmJgyAQsR3d1RR4cFAYtw7949c3Nzcs6gOL8yNzeX/GzPmjWLiXXUMvbs2aNoKODo6KikikRGHZuZmVW99+rNmzek+EssFjNZ2/ju3TsjIyNitaMIsRt3c3Pz9vYmduNVl2PkDXTMt+QQXr16JRAINDQ0mB/ySEcDHRGwCgvRxgaHDWOihVCRnJwcIskJBAJvb+8vfdDk5uaS4p2hQ4ey3trwbTF37lwXF5cVH1FTU2PMR7w8x44dA4BevXqxtYAKKSoqatiwIVA9tZ1c/YDm0TeVw5hLfWlpKamdnzlzJq2J5PTowaZ2MW7cOADo3Lkzu5M0azvHjyPApx0287x6haam/3mmaVNMTKSkhXDlypUAUKdOnfv37yu90GpAHHjs7OyYTFohpHyV1iboLVu2kO3HsWPH6MuCiKWleOQI/vILrUk4KuAbE7BIhby3tze1YceOHcvuXqRC2rdvDwB79+6lPPK8efNI1YbyhtPVZdmyZQAwbNgwhvPKhy3+/fffVMVUFLDevkU9PdYELETMysoaMWIEERHc3d2JakB+sFu1alVQUMDQOmoT1ApYsbGx5JS7ukPcioqKSGM1AHh4eDBwE1taWkomYbVt2zYgIGDZsmUjR45s27Ytsfj9DIFAYG5u3q9fP09Pz23btoWGhr58+bK8VCFvoBs9ejTd66+Evn37AlOjD+WQBjo+n09tAx0RsBDx/Hnk8ZgWsPC/lliurq7lK4NkMpmbmxu5RqnC6Lpvi7lz586YMePkR8RiMYsCVnp6Oo/H09DQUKlKdkTcsGEDKcJ6+vTp27dvKZF7iKdknz59WJRcmXGpx49VDGZmZox5xoeFIQDWrYvMmtQjIp48eRIANDU1Y2Njmc7NoUh+PmpqIp+P1Z8ZV55Tp04p9pp4eHhU6aCoa9dPk3oPHixrGKu+gPXixQtFP7UjR46Eh4f36NGDebMCxkqfvsrBgwdpPfDYv38/n8/n8XiK//I0IZVi/foIgAxO8uBA/LYErJKSEtL1Rvnoq02bNgHA9OnTqQ2rJAEBAXT0CZ89e5bH4wmFwps3b1IbuSqkpKSoqakJBAImL6AMDFvMy8Pt2/HoUVQ8tJPJkB732C/i7+9PZpa1aNGC1HRoa2szWaJcq9izZ8/w4cMjP2Jvb19jAUsmk/Xu3RsAJk2aVLMIckusbt260W0ISmzmjY2Ny08ce/PmzeXLl3fs2DFv3rwBAwY0a9ZMKBSWV7U0NDTs7OyGDx++ePHiffv23bp1iwwBtLOzY1fICAoKouOqWwkxMTFkT/nHH39QG3nIkE9fz5uHJ07gsmUoH96bmYlVdgJUinPnzunr6wNA8+bNP3NRXb16NanaY6UP61unfAshiwIWIpJKOlb2FZWQlZWlqampOGtYLBYbGxvb2to6Ojq6ubl5enp6e3v7+voGBAQEBweHh4dHRUVVMhFs165dAKCnp0erRWlVoNulHhEjIyNFIhGfz2f4ZrtLFwRABk3qERHT09NJi8Bff/3FaGKOing0c+b8Nm0Cdu9WPtSOHTvmzJkjf9i+ffvHjx9//dtevsRevbBzZ+zcGbt0QaJpVl/AunbtWt++feUPx48ff/jw4eq9AeqYFzyvRUQLv3d+bC2AkJWVRe4EL1y4QPmZx6lTp8i2k7Fa/kmTEADXrmUmG0cZ35KAdfbsWQBo2bIl5ZHJgDwHBwfKIytDUVERMfwaMGCAt7f3rl27QkJCnj59qox/U1JSEun6ofxmqeqQsqCFCxcylnHGjBkAYGlpSd+wxcBABEBbW2S9CSYiIsLS0hIASOHDgQMHWF7Q98uePXtsbGymfKR+/fo1FrD+/vtvAKhbt256enqN13Pz5k1jY2MA+OWXX2bPni1/fvz48RTeVR44cAAARCJReHh4VV5fWlqakJAQFhbm7+/v6enp5ORkbm7O4/E+k7S0tbXr1KnD+sFgcXExuddlZsazvIFuyJAh9FVz/O9/OGAAUl24XA3i4uJatmwJALq6uidOnCBPhoaGCgQCPp+v/OiD2omqCVjkc3atiu3i169fT/QmGxsbIyMjgUBQXk+vEC0trcaNG9vb2/fp02fUqFGzZs1avnz5ypUrdXR0AECxVZ8t6HapLyoqIlenRYsW0RG/Ek6dQgBs1AipnhFSGcR5tnfv3lwvsyqwc+dOABhIRRdDDQUsQkEBKtfBoFIC1sHMgxAJvWJZ7vV+/fq1np4eGZsjFAodHBw8PT2DgoLSlJ4/eunSJWL7u2rVKkqWWhVOnEAA7NSJsYQciN+WgDVx4kQAWLlyJeWRc3NzBQKBmpoa5RO1lCErK8vIyIiYNH+GWCw2Nzd3cnLy8PDw9vb29/cPCwtLSEiofP8qkUh69eoFAP3796fvyO6rREREkA0lM6UWR44cAfqHLZaWYqNGCIChofQlqSqpqam6uroaGhoA4O7uzvXm0ARVLYSpqamkREX5m6Lk5OQ//vjj6NGjipPsnJ2dL126pGRkwsOHDzU1NUHphuucnJyIiIhDhw55e3uPHj3a0tKSz+eryBHCggULAGDatGl0J5I30NnY2NCnrSPi1asIgCYmyKKpS25uLnmzPB7Py8srISHB0NBQBfWOb4jDhw8r1sXMnj2bXdeef//9FwCcnZ1ZXMNnyN3HFZtzCwoKkpOTo6KiwsPDg4KCfH19vb29PT093d3dXVxcHB0dbW1tiRlfhTRs2LBjx44svilF6HOpR8S5c+eSqxNjsw7lyGRoZ4dWVo/277/ITEbS8VCnTp1Xr14xk5Gjct6+fcvn8zU0NJTcwZaUlOzYsaNx48ZOH9HV1a2GgKU0165ds7CwkJsVtm7dmkUBK0uSJbovEt4XvpcwbfQpJzU1lZyym5mZtWrVipy1y7G2tp40adLu3bufPXtW3cva3bt3yQHDzz//TNPiK0Te8JqSwmTaz4mJiVGUSlesWEGHB5Hq8C0JWHZ2dgBAUz8UsV9h5tS9iowePRoAbG1td+zY4e3tPXHixN69e1tZWRF1uUIEAoGJiUmXLl1Gjhy5YMECPz+/kydPRkREvHv3DhGXLFkCAPXr10+loqtcGYiFvOLpMU3Ihy0yYGqzZg0C4IABdOf5OkTqNTEx0dLSIp8Hj+SNQxzUQZWARW7sKbzxo0nAyszMJLMCFN81JWRlZWlpafF4PFVoJYuJieHxeNra2jk5ObQmIp79zDTQ2dggAJ45Q3eeypDJZOvWrSMlMMSRcNCgQVyxw3dDSkoKAOjo6KjI+DYl3cfz8vJevXp1//79kJCQQ4cObdmyZcWKFWTyfZMmTdgtdpNDk0s9IoaHh/P5fKFQyNau+PjxqzwejwGXekRMSsIffkhr2LBTQEAA3bk4qk7Hjh0B4OTJkzX43hcvXvj7+7u4uFhbW+/YsWP69OkZH2nTpg3DAlabNm3kZoU9e/ZkUcBCxF6xvSASDmYeZCV7VlYWcXRp37492WLl5uaGh4f7+Pi4uLgQOwU5urq6Tk5O3t7eYWFhX3XyjYqKIqdi48aNY75EY+BABEB2nbSjo6Pbtm0rfzhv3rxt27axuB66UXUB6+3btzdu3CBfy2SyPXv2lHddoYTx48fzeLx/qHP4VhJysKatrR0TE1P+b9+9excZGXny5Ek/P78FCxaMHDmyS5cuJiYmlZTHq6uri0QigUBw9epV5t/OZ5ABOlZWVrTevTA8bDEzEzU1kcfD58/pTlUZ5BicDFt8+vRpq1atyENa533UTgIDA728vOQPBw0aVAOhkHRGa2lpUdg9d/ToUX19/TYf0dXVVV7Akkgk/fr1A4BOnTrRUalKVNfffvuN8sg1oFu3bkDpwIfyMNxA98cfCICDBjGQ6itcvnxZLBbXqVNHTU3tzp07bC+Hg0rIubqSw1ipgriPm5ubU+g+LpVKSVcdkyNfK4e41HeitH0lLy/PwsICmG3D+QzGXOplMuzbFwFw1CiVEF455KxZswYAJlfZrFEmk927d2/JkiVk30sQiURr166teQuh0qhUCyEi+r7zhUgYmTiS+dT5+fk//PADufsjdRWfIZFIoqKi/P393d3dzczMFO9h5Z2GAQEB5cskX79+3bhxYwBwdXVl5QTl778RAF1cmM/8CU7AUi1CQkJcXV3lD93c3E6dOkVHouSdO7N1dHDKFDqCV5fHjx+T/q+DB6utkb9//z4iIoIUxnt5ebm5uTk4OBgbG/N4PAMDg+bNm9Ox4OpSWlpKmp9DQkLoy8L8sMUpUxAAFdyHmCYuLo4U0O7atYs8U1BQQCy3AWDYsGGVeNNysAKZHUmtvEhHBRZprKtfv/4buYMppdy8eRMAGjRooAqlDfv37wcA+hqFXrx4QY4Kf//9d5pSfEZ6Oqqro1CI9BwAVYM//viDFAuT89Wana5zqCZkTvTGjRvZXgiN7uOk18zS0pLdhk05eXl5xCzV3d198+bN+/fvP3v27J07d+Li4srP/awiZKxt27Zt2b0aM+BSj4jbtpUNPaR59glHtYmKigIAIyOjyn/XCgsLw8LCPD09TUxM5HqHlpaWi4tLQEDAhw8flPLAUhpVE7BeFr+ESNB9qFssY3RibElJibOzM7kpq2KjbnJyclBQkKenp6Ojo0gkUtSzjI2N3dzcfH19IyIiUlNTidjds2dP5vudCe/eIZ+PGhrIomVLdHS0hoaG/OjayMiIE7DYhDEBC2/eRAC0t6cleHXIy8uztramvE/n3bt3pGvj4cOHFIatMWvXrgWAAbR13LEybPHJE+TxUEcHa7pvVIp6gyXeAAAgAElEQVRKhi3u379fW1sbAJo2bcpVPbDLgwcP4uPj5Q+PHTt26NAhau+FKBewjh07xuPxRCIRrbOoSGmD3OSbRQoKCogr2YMHD+gI3rZtW+Yb6IYPRwBcs4axhBVw8eJFgUDA4/ECAwMnTJgAHy2xWPRk5KCQffv2kR9sdpdRWFhILiaKFbJUIZFISKFZUFAQ5cFrhr29veKt+2cQy1RHR0cXFxd3d3fFqYthYWFRUVHJycmKQlVISAiPx1NXV3/y5AmLbwoVXOqPHTtGU4rERNTWRgA8coSmDBxK0axZMwCQN+IokpmZGRQU5O7uTm5tCI0bN/bw8AgODlacbRcTE6PYCXv27Fkmj3JjY2MVTyj37t0bERHBWPYKafW0FURCaDZzlr1SqXTkyJEAUK9evec16lLJyckJDQ319vbu06cPOaeXQwo+OnToQLftQ+V06oQAyOIGlqvAUi1CQkI6dOhw6iOOjo50CVj5+SgUolCo5LwJ5Rk/fjwAtGzZ8qsdv9WFVOJMUY0qs8zMTE1NTR6PV7NrWeWwOGyxZ08Wxj8TKh+2GBMTY29vDwDq6uq+vr6c9QxbzJ07V3FKt46ODuWn3NQKWI8ePSJmanQPF9+0aROtona1+PnnnwHA09OT2rAymYxs45o3b17j+oiaceECAqCZGbIlFr18+ZJcllesWEGe8ff3J8eqzs7O79+z5inLQRWJiYkAYGBgwK4iSdzHbW1taTqN37FjBwC0bt1aFT5GSUWYtrb2/Pnz58yZM27cOGdn5w4dOlhYWCje2H8VfX39Zs2adezYkRjYq0IZHSJu3boVaHOpl0qxWzcEQHd3ymNzUANppFCcg5mYmOjr6+vk5KRYkmNra+vl5RUeHq4Kv5Kqz9LkpRAJP79myOlcJpN5eHgAQJ06de7fv698QMVOQxsbG+JIkJSUpHxkZVi7FgFw0iTWFsAJWKpFSEhI8+bNvT9ia2tLl4CFiK1aIQDevk1X/CpASqa1tLSePn1KefC4uDg+n6+url5h7zHzkDL12VR33JWWlnbt2pXcFDH/YXbyZNldIsPtBVUZtlhYWChvJxw0aFBmZiaTK+QgMCBgpaenK+rCT548qbFW8v79e2KG4k7/Hj8jI0MsFvP5fFWYA/Xo0SMA0NTU3LBhw4ULFxISEiipklu/fj0A6OjoREdHKx+tWkil2LQpAuBFhuZ6/YeCggIHBwcAGDhwoKK6ce3atfr16xPlnfWKDw7lIUYkTHbofIbcfZw+K66ioiJS8XT69GmaUlSRN2/ekFrR/fv3f+k1BQUFCQkJ4eHhwcHBAQEBilMXnZycbG1tjY2NFbUAExOTOnXqqMhI7sLCQuJSrzhHkirWr0cAbNgQua2QynL16lUAaNasWUREhLe3N/kQIQgEAkdHR19f39evX7O9zG+Me/n3IBIaP2ksQyZukRYtWkTqpK5fv05H/Pbt20NNzf4pJDpa2rXr3t693VnpLn/58iUnYKkWzLUQIuKkSQiAW7fSFf9rxMTEkMJI+iahuLi4AMAadttIPhIVFcXj8XR0dKit5l28eDHZhKWnp1MYtopIJGhujiJRyfnzzJnNJCYWNWhgDlUbtnj8+HGy5W3cuHGFhdkctDJ37tyffvpJXlWqoaGhCq5PFSKVSsnUrTZt2lBeEFoho0aNAoCVK1cykKtynj17JhaLibkMQSQSmZubOzk5eXp6+vv7h4WFJSQkVEsiv3jxolAo5PF49HXEVM6qVQiAI1kwby0z6beysiqvpSYlJXXo0IFUkahOWxZHzRg3bhwAbGVpH8WY+zgpF6XPJq8qyGQy4imjuEmuMRkZGTExMTdu3CANkqozj4+45nXu3JnyyIMHI4+HFy5QHpiDGgoKCk6cOKGurv5ZqeDYsWMPHz5cYasBR1WQoazR40YQCffzKaiHqpx169aR7RN982qI2f8kFmufPkI6XsPDwxnOe+LECTU1ta1btyoeHb18+fLtd23sxwlYCmzdymL9X2FhYevWrQFg1KhR9GUJDQ0FgIYNG6rIPXPLli21tbVFIpGxsbGDg4Obm5uXl5evr29QUFBEREQNJk5evnyZzPZS3rW6xuzcebdBA5PevXszk664GDt0QAuLomnTfKr4La9evSLzGYVCobe3N2dAwyRz584dMGCAvKpUTU1NRX4Zy/Pbb78BgJGREWMnnBcvXgQAU1NTdg2Sc3JybGxsyA3qTz/91Lt3bzJ0osK+mw4dOri7u//++++HDx9+8OBBfn5+hTFfvnxJ5DBvb29m380nkpJQIEBb2yfp6Yz265G7fW1t7aioqApfUFhYSPy/iSWWithjc9QAf39/qMiHkRkYcx/Pz88nv84s7jTIrOq6detSe5dCjMysra1VZGOQl5dHWo+Vn6C9bRvKK9Xi49HPD+mpCOFQioyMjICAADc3N7nVkbq6ur6+fnlzK44aE/g+MCwnrEhWVCIru1TuztidVppGbZa9e/fyeDw+nx8YGEhtZEWI2X+9evVY3zmQjteFCxcymfTixYtE5FWR2hTGUHUB686dO/Pnz5c//O2332gqQSTJEABbtaIrfqVMmzaNFMrS7UJH5sv++++/tGapCg8fPlRXV1dTU6vwzpCgo6PTokULZ2dnDw+P1atXBwQEXLlyJS4ursL69rdv3xobGzNw+lo5OTk5xHvi0aNHDKSbNw8B0NS0emXwpaWl3t7efD4fAJycnFJTU2lbIMd/YKCFkBJOnDhBxiBcuXKFsaQymaxd33bdd3cPTWfOXvQzpFIpqVS1t7dXVKOKi4sTEhKCg4N9fHw8PDycnJwaNGjwJVXL0dHRw8PDx8cnKCgoKioqNze3wgY65pk8eQEwa3ATHv6oinVnckusHj16qEifO0d1ef78OQA0aNCA+f59ufv4l3RSalmzZg1fyJ+8YzIDucqTmJhIbu+PUG0/XlpaSgbYq0455JIlSwBAV1e3Q4cOzs7O48aNmzNnzqpVq7Zt2xYYGHjx4sWHDx8mJSV/4ezgE66uqK+PZIbKjRvo7MzA2jmqyvPnz9evX+/o6Ehm1JLzjPbt248ePRoAunbtyvYCvysySjPcEt1so23tn9r3j+v/rvRd15iuUYVUXjmPHz9OZrb4+/tTGLZCKjH7ZxLS8WppaclYxjt37pAJXZS78ag+qi5gMUphIYpEKBAwPwbz8OHDACAWi+kYevUZxH+0U6dOdCeqHPmwxRkzZhQWFsbGxl6+fDkgIGDVqlXTpk3r37+/ra0t+bX8Eg0aNGjfvv3QoUPnzJmzadOmw4cPd+nSBQC6d+/OugxPHKCnTZtGd6KzZ5HHQ6EQazZrMTg42NDQEADq168fGsqaZFCr+CYErOfPnxMR1s/Pj+HUa1PXQiQMSxjGcF45y5YtAwADA4PExMSvvjgtLS08PHzXrl1eXl5DhgyxtbX9rN+BIBQKyfkEw8bt5Tl58iQpr2BGX3j9Go2MZN26rVmyZGlVXh8eHk5kQVNTU/o8jDhohRwj0TGepRI+fPjQqFEjANi0aRNDGbM+tH7YGiLhVt4tZjLKkUql3bp1A9qsCbdv3w4q41KPiFOmTCGHbZXQvLkbAGpoYKNG2Lo19u6NI0fizJm4bBn6+uI//+CdO+jqiosWYb9+iJyApRpIpVJibmVrayv/rxSLxU5OTr6+vsSWOzc3l5hjft/9UAwz5sWYBW8WEA+s0OzQXGkutQJWWFgY2Qv5+FS1NUQZypv9s4JEIiHlosx8/D158sTAwAAAxo8fryLXaibhBKz/Ym+PADUUA2pKfHw8uVfcsWMHA+ny8/OJZnHnzh0G0n0Jd3d3qMKwReI/GhYW5u/v7+3tTQofbG1tNTU1y+9gjIyM9PT0UlJSGHsXXyI2NpbP52toaGRkZNCXJSkJ69ZFANywoeZBXr9+7ejoCAACgYC0Qcn/KjExUXH2MAclbNq06ejRo/KHPXr0YF1vLc+jR4/MzMzGjRvHfOrUklTRfZHwvjClhIVf5FOnTvH5fIFAcEEJZ5Tk5GRyyfLy8nJxcTE3N+fxeCKRaO3atRQutWaUlpYSU2QGzioLC7F9ewTAPn2qMdTizZs3nTp1Ircx+/bto3OBHLTg5uYGADt37mQyKbHPc3R0ZPJyuiR5CUSCS7wLYxkJZBZEw4YNaZrEInepP3PmDB3xq0VYWBgprDt79uydO3fOnj27f//+zZs3L1u2bObMmSNGjOjVq1fr1q179/bW0ECAL/5xdUVXVwwPx/79MTCQE7DYpKCgIDg42MPDg4jdBAMDAzc3t4CAgPLmVsTrbc+ePays9vtDIpOo31fPlvzn35lCAev27duk/mDOnDmUBPwqcrN/ZtJVwvjx4wFg/fr1dCeKj48nvz6DBw8uLS2lO50KwglY/2XqVARABosOioqKSGuJm5sbY0kXLVpkP8V+3r15jGX8jN27d4NywxalUmlycvLt27eDgoI2bdo0Z86cXr16AUDdunVVZHoOcb9et24dTfElEuzZEwHQ2RmVVN7l7YRLly4Vi8Xy5/ft2zd9+nRlF8rxLTBp0iS5tcS9e/f8/PwyMjKYMW4vz+CEwRAJ69/SvgP4jJiYGJpGyP/1118A8MMPP1AbtmaQMRcTJ06kO9GUKQiATZtidWX8oqIiYmYEAB4eHipYoshRCVu2bAEAJuXv48ePkx1FXFwcY0kRMaM0Q/uBNkRCZP4Xh/9SztOnT8ViMY/HO3fuHH1ZNm7cCGy71CNiVlYWmWtZxRvC/Hx8/RofPMCwMPz3X9y6FVeuRE9PHDsWN20qE7Di4tDMDC9c4AQsuli4cKHiGAcDA4PCwkJETE9PJ+ZWit0VZmZmnp6eYWFhlVznSUng4MGDmVh9LSC1JFX/of5nT1IlYD1+/JjMiZowYQJjZUEMlz5VwtGjR8lRCq1ZkpNxyJBgAOjTp4+K3PMyDydg/ZeICDx3DhWHuMtkqGhZQvXhnqenJwBYWFgw2VryqvCV8L5Q7b5acglzk/Lk0DdssV27dgCgIof2ISEhAGBiYkLT3deSJQiAJiZI1azFmzdvlpaWcgJW7URfX1/u93T8+HFaR0l8lTNZZyASLKIsmJnxTMjJySFdDKNHj6Y8eF5eHimzjY6Opjx4dUlMTCT1odSOf/2MLVsQALW0UGEqTvXw9/cnDondunXjmke+IaKiopycnBQbpWnl3bt3RkZGzNd8EX5J+gUiYUQiQ6b1paWlZGb8jBkzaE2Ul5dHXOovX75Ma6LKIaX6nTt3pqSwjghYiLh8OfbsyQlYdDF//nzFidh6enpHjhzp1KmTvA+Uz+d36tRp3bp1VfxATE5O5vF4mpqaX5qRwlEtSmQlavfVimT/ET4oEbCKi4uJg56bmxvDvQXkWvHHH38wmbQ88o5X+pyFMzOxZUsEwAkTruXm5tKURfXhBCwFpFJcsABtbPCHH9DaGskBwv/9Hy5Z8uk1NjZYBWOUKnL69GnSWnL79m2qYlaR4QnDIRKWpSxjOK982CId5/9kek6bNm0oj1wziF++YlMeVVy+jAIB8vlI+QQkdXX1Yx+ZPXs2J2DVElRKwJKitPGTxhAJV3OVHTtVRWQy2fDhwwHAzs4ujx4PRA8PDwBQnEnCIr179wYA+iSGmzdRTQ15PFRy9NDNmzdJkXyTJk3Onz9PLFEIYWFhtdD04ZtgzJgxcm00MjJy6dIq2Z/VGOLx7OzszMrPQ2pJqviBmB/Jp9b/+EssX76cFK3QPe0HEVevXg0AjM1TLg8x7NPU1IyNjaUkoFzAKipCKytOwKKL8gJWQECAorlVDSaMk/Pp06dPU7rS2kv/uP5/pv1JviYnhTUTsPbu3St3q5RKpT///PO1a9fc3NyYHxZ55MgRUA2zf9J/s3v3bjqC5+ejoyMCYMuW1Zvc9f3BCVgK/PMP9u6NhYWIiGlp2KwZ3rtHn4AlP+DavHkzJQGrRXhuOERCvUf1CqWFTOalddhiUVERMQCmcVRldSBlz126dKE2rESClpYIgKtXUxsYEVFNTW31R4YNG8YJWLUEfX39MWPGuLu7u7u79+jRg10BCxGXpyyHSBj7Yiwz6VauXAkA+vr68WRCFQ3cu3cPAAwNDVWh3jswMJCodXQET0nBhg0RAL28KIiWlpbWo0cPOzu7mTNnKtpEamtr107fB9XH1NRUPkQyNDTUxYViiyiJRKKoVSUmJg4fPrwGt8RUMf3VdIiECS8n0J0oMjJSJBLx+fyrV5lQ9rOzs/X09JjxyytPenp6/fr1AWDbtm1Uxdy3D1+8KPv6xg3081PWfoGjQubPn9+oUaM2HxEIBG/fvj1x4oQy9VOrVq0CRiYj1RLii+LJ/MGJLye2fto6szSzZgLWhAkTAj+eU5WWlmppaVG90qqiOmb/ZFSavb39nTt3qG3BKS7Gfv0QAM3NUQXcnlmGE7AU+PFHVHSs/OMPnD+fQgGrpKREsdgvJyfnypUrP/30E1vHyO2ftYdI2Juxl7GMDAxbJOeTw4axNsJMEblf/urVq2/cuPH69eua3XGVlmJCwqdO1nfv8NEj9PT8T28rVXAthLUTfX39e/fuPX78+PHjx76+vqwLWK+LXwvuC8QPxJmltJ8xhYSECAQCPp9Pq6cMIrZp0wZUYzh9cXExOT6JiIigNnJJCXbtigDYuzdlDffFxcUpKSlz5szhBKxvAroFrL59+8oVnKSkJCZnlldIYnGi8L5QdF+UWExZeX55ioqKWrZsCQALFiygL8tnEL88yv8HqwIpie3duzdNO+RVq1BDA1XApP47pHwFlvJ+mo8ePQKA+vXrS+nY+NZKZChLLE58XPA4X5qPiG9K3hTLql02pToCFqqM2b+Xl5e2tjaPxwMAkUjk4ODg6ekZFBSUrpzhi0SCbm4IgEZGGBND1WK/Yb4ymLZ2kZwMjRp9eti4Mbx5AwCweze0bVv258WLGoe/cOHC5MmT5Q/d3d2Li4u3b99OfsqZ52ejnwFgU9omZtIlJCSQ8is/Pz97e3uasvz0009qamonT558ocT/FFVoamqampo2atRo2bJlXbt2bdy4sVgsNjU17dq16+jRoxctWrRly5bg4OBHj5LS0yuLk5wMFhawe3fZQ09PSE4GPz/42lxpDo5q0KJFi1atWrVq1YqY5rKLqZqpk45Tkazo4IeDtCaKi4sbOXKkVCpds2YN2f3Qx5QpUwDg77//pjVLVVBTUxs3bhwALFmyJDIyMjc3l6rIx47BjRvQtCkcPgwCATUx1dTUSCNhbGzs1Y9IpVJqonPQwLhx41xcXFxcXJYtW8b2WmjHTM1stP7oUizd8G4DfVkWL14cFRVlY2NDSlGYYd68edra2mfOnLl//z5jSQHg33+PHj16tE6dOnv37qVph6ylBYWF8PvvdMTmoB47OzszM7N3796RWmYO5eEBz0zNrJVGK02+JgCYiEzUeGo1iLN3797Zs2fPnj177ty5VK+xeri6ugJAcHAwi2vYvn37+vXrCwsLnZycbG1tJRJJZGTkn3/+OWLECCMjoxYtWkybNi0gICA+/mW1wiLCtGlw5AgYGMClS2BlRc/qvym4O2AFjI3h7dtPD1NToWFDAIApU+D+/bI/ZmZsrY5yRumPaiBq8KTwyfW863TnKi4uHjFiRE5OjpubG/GCoQljY2M3NzepVEra99hl7969Dx8+zMjI+PHHHzt37tywYUNEfPPmzc2bNwMDAzds2ODp6Tlo0CBPz6NGRiAWg4UFdO0KI0bAr7/Czp1w+jRERkJODgCAhQVs2ABpabSvuWPHjvKvjYyMzM3NaU/JwVER0+pOA4C/M2iUe/Ly8oYOHZqVlTV48GAvLy/6EhHGjRunqal58eLFhIQEunN9lRYtWtSpUyc0NLRdu3a6uroGBgbt2rUbP378+vXrjxw5EhkZWVhYWJU4t259+thMTgYHB9i3D06cAEND6tf86NGjUx+RSCTUJ+CgiI0bN+7cuXPnzp2//PIL22thgt8a/MYH/t7MvRmSDDri37x508/PTygUBgQEaGho0JGiQgwNDck80PXr1zOWNDkZ5s//sVu32X5+f5qamtKUZfp0qFcP7tyBK1doysBBMaogT3CUx9HRcdSoUaNGjRoxYgS7K3F1deXxeKGhoQUFBaws4Pjx47Nnz+bxeNu3bw8NDY2Ojs7Ozg4LC/P29nZyctLQ0Hj69OmuXbsmTpw4adLlOnWgTx9YsQIuXoTyu603b2DDBiguLnt48CA0agRaWhAcDC1bMvy2VBW2S8BUib/+wmHDyvqyCgqwdWu8do3CFsLg4OChQ4fmfcTFxeXChQtUrLvmeKd4QyQMTRhKd6LZs2cDU8MWIyIiAEBPT48mM+YqIh+2qDgVsaSk5OXLl+Hh4QcOHFi3bt3MmTNdXFyGDw81MECAL/7ZvRvbtsVt29DdHRFx5EikudWJo9bh6+srb8iKjY09deoUu+tBxBJZycI3Cx8X/GeIXdD7oLcl1BgcyGQyst+ytrbOzs6mJOZXGT9+PADQbWv9VRISEgwMDADAzs7Ozs5OLBaX3xsIhcLu3acOGIDz5uGOHXj5Mr55U0GoZs2we/cyK5mdO5E+k3quhfBbgYEWwmbNmhF7nZYtW7LeQkhYl7ouPDccEeVtOLnS3O3p25WPnJeXZ2lpCQArVqxQPlp1SUlJIc4yzExQlcnQ2RkB0NWV9lyrV5c1O3NQS0ZGhuJWPzExkZI+0EuXLgGAra2t8qE4qEKlWggRkQxpDQ4OZj51aGiouro6fHkSYklJyZ07dzZt2jRs2LAff4xRvMtTV8cuXXDBAjx5EsmHZ3g4CoUov+Q7OuLjx8ie06MqwglYCpSU4NSp6OCAEyagtXWZbkWpgFW3bl3HjxgYGLAuYL0rfSd+IBbcF9Dq3cD8sMXOnTsDwPbtFOwda4Z82GLVvYQKCzEhAcPCMCAAfXzQwwNdXNDBAXV08OxZbNsWJRJ0cMDLlzkBi6O2kCPJ8XjlYR1tbffUbmD8wHel7/rG9f1f/v8oCb527VoA0NHRefr0KSUBq8L169cBwNjYmEXxpaCgoG3btgAwaNAg+X3F+/fvw8PD/f39vby83NzcbG1tBQJBx44+n4np2trYti2OGoXLl+PBgxgTg82aYf/+eOAAIidgcSBi7fPAknMz76bDMwf7p/a20bbLU5YnlyS3fNpS+bDBwcFCodDBwYFaP+CqM336dKBncnR5/voLAbBuXaRtBv0nsrJQTw8B8OZNymLGx8ePHftp9siGDRuOHDlCWfTaTWlpqb6+PgBQNZWSQ3lUTcAis1OnTp3KcN5bt25paWkBwOLFi6v4LfHxuH8/Tp+OLVsin/+fjZaVFe7ahX37orU1kh92ImBxKMIJWOX48AEfP0Z58U5ODioezqem1tiZNjg42M3NTf5w0KBBrAtYiOj+wh0iYVnKMpriv379mhiZ+/r60pSiPGTGlpWVFVsG+aTqnqphiy9eYNu2iIh37mDr1jh8OCdgcdQKZr6eOeXlFIlMgoins05nlGZQJWCFhYUR43bmx3Lb2tqydUJIGDVqFAA0b9688nrYoqKip08zjh9HHx+cPBkdHbFevc+LQ3/5BZs1w4cP0cwM37+nV8Bas2aNfKOMiG3atJFQ5RLPQSmHDh0qLCybbvzmzZuQkBBq46umgPVB8qHB4wY3824iYpGs6HTW6RoLWPHx8ZGRkfKHISEhly9fZlJn/4zExEShUCgSiRIpmsH95USoo4MAyNigi8WLEQAHDqQs4JMnT9q1ayd/OGfOHBZPUr8/xowZAwAbN25keyEcZRw9evTxR2VFKpWyUiWqCDH7NzIyYtLs/9GjR0Ra/emnn2oWIScHw8PRxwddXMpU9ZMn0dUVjx9HJydETsCqCM4Dqxx6etCqFWhplT3U0QFd3U9/26ABZc60qsGi+osONj24rMGyHGlOniyPPLkydWWRrEj54BKJZNSoUZmZmQMGDPD09FQ+YBUZNmyYqalpbGxsWFgYY0nlBAUF7dq1SywWBwUFkS5CJZF7mHbsCB07woULyofk4PgGOPj+4OqGqwU8AQC41HExFFLmq0RcwFesWOHi4kJVzCoyadIkANi1axfDeQkbNmwIDAzU0dE5fvx4nTp1Knmlurq6jY3hkCHg5QW7d8ONG5CWBu/fw507EBAAS5aAmxt06QIAYGoK06bB4sX0rnzx4sUjR46UP7x//77g+/os/m4YPXq0vCnVxMSkb9++7K6HGS7mXmyr2baLVhcAUOepu9Sp+YXl0qVLAQEB8odLly41NDS0sbGhYJU1wszMbPTo0aWlpRs20OhSL5PBpEmQmwvjxoGbG315/sO8eaCtDWfOALMm9Rw1hLPBUjWGDRvWqlUr8jWfz/f29mZ3PcTsPy0tjTGz//j4+H79+n348GHo0KFbt26tWRAdHejaFby84PRpSE+Hhw/LXESHDAGRCAIDqVzwdwMnYNV2Wmq0bKfVrltstz7xfXrH9e4T1ydbmr0vc18xFn/9m7/GkiVLbt26ZWpqGhAQwOSwRaFQOGPGDADw8/NjLCkhPj6eDFv09fWlY9jiunXAoIUrBwdr5Epzi2RFxiJj5UMlJycfOnRI/vDcuXNjxowJCwtbunSp8sGry8SJE9XV1c+dO5ecnMxw6kuXLi1evJjH4+3du5cUglUXfX3o2BHGj4fff4egIBg+vOz5+fMhPBweP6ZytRwcFXLw4EHiEgAAxsbGN27cYHc9hOSS5CZqTdheBV0sXryYz+fv2bMnJSWFphQbN8K1a9CwITC5azM0hKlTAREoNKl/9uxZ548cPnyYsrgcAM7Ozmpqajdu3MjIoGVaAsd3AJMqZ1ISzJ//v/T09B9//DEwMJCSQzWhEFq3/vTwzz/B27sCl3cOTsBiDmdnZ8VTtUOHDvXu3ZvF9RAQ0P2lu0ddj7vN795tfv54AFIAACAASURBVNfb2FtHQEHREAAUFxdfunRJKBQGBgYa0jGSqlKmT5+uqal5/vz5mJgYxpIWFxePHDkyJydn+PDhxDaCEpo0gcjIsq/z8sDdHRi/8+XgYBptgTafx8+V5iof6tWrV4oVT8eOHXv48KGTkxOTqrqcunXrurq6SiSSffv2MZn31atXo0ePlkgky5cvHzZsGLXB1dTgzz9h505qo3JwVEDdunXV1MrGvQsEgvr167O7HoKRyCitlLI5wQkJCSc+8uHDB6rC1hhra+shQ4YUFxdv2rSJjvjPnoG3N/B4sGsXGBjQkeGLLFoEYjEcPQpKbhVLS0tPnz4NANbW1lc/Mlyu8XNQga6ubo8ePaRS6blz59heC4eKQgSsU6dO0Z0oPR369oXg4NFjx144cuSISCSiI4ulJYwezZWIVgAnYDGHUChUnH+sqakpFApZXA8hpTQlsThxouFE8rCrdld+TX8qkpKSFDXvq1ev/vPPP+fPn+9C+kyYxcDAYMyYMYi4bds2xpIuWqSurb27efOW9PUHPXgAmzbB2rUgldKUgYNDJeABr7dO7z2Ze9heCPWQIs3du3fLZDJmMhYWwtix49PT011cXJYvX05hZFNT4PMBAHr1gokTmb755OBQEbprd7+Wd+1VyStKomVmZkZ9pFA1Dt+XLl3K4/F27NiRnp5ObWSJBCZMgMJCmD4dnJ2pjf11jI1h1qyUrl1n/t///VSzCCUlJfv377e1tXV1dY2MjOTxeOof4dqcKYfrIuSonG7duunr6z99+jQ2Npa+LDk54OwMz5+DnR34+jppampSG79uXXB0LPv6119h/Hio1PKhNsIJWLWd1NJUY5ExDyioRIiNjd2pcAQfEBDw/PlzJycn5SPXjLlz5/J4vH379mVnZzOQ7sQJ2LIF7tyxP3gwsnJzGWUYOBAsLODFC+DOnzi+e3wb+e7O3D0kcYhnkmeH5x1SS1NrHCopKWnTR6KioihcZA1wcnKysLB48eIFmQvOAB4ekJq6o2dPlwMHDvD5VH7uX7oEenoAALGxUFQEjFxrOThUjoaihn6N/HrE9hj3cpxbotvEVxOVidahQ4dlH2nYsCFFa1QKe3t7Z2fn/Pz8LVu2UBu5qAisrMDcHOi02KqMmTOLbt36OyBgz8uXL6v1jXl5eRs3bmzatOmECRPi4+NtbW0lEgk9a+QoY/DgwTweLyQkpKiIAqNeju8PoVD4448/AgCpiKSDwkJwdYXISLC0hJAQ0NenPoW1NSxaBACQlQXTpkF0NDRuTH2WbxpOwKrtGIuM35a+RUC2F0I9LVq06NmzZ25u7t69e+nOlZQE06aVOSk4OKjRl4jPh1mzAIBRnwgODlawULe4b31/TcM1I/VHhjQLMRYZ72i8o4W4RQ1Cqamp1fuIBts2cjweb+LEicCUlbuvLxw4AGlpNlu2nKZPWy8qgv37YedOKCigKQMHh0ozxmDMM9tni+ov+r3h73ua7KkvrH/G4gzbi6KSZcuWAcCff/6ZlZWlZKiRI+HmzbKvg4PB3R1GjoSkpLJnMjNh9mwlM1QDc3Pz6rrU5+bm+vn5NWvWbMGCBampqXZ2dgEBAY8fP3Zzc/vjjz/kL5s8eXK/fv3oWXUtxcTExN7evri4mMyb4+AoD61lelIpjBsH166BiQmEhUGDBnQk+YSuLly8CJGR8OQJvYm+OdhvYeNgl4aihk3Vmv7z/p/xBuMBoBRLRbya9/G+fv3a39+ffB0fH0/NEpVgzpw5ly9f9vPzmz17Nn213BIJjBoFmZkwYADMmUNTkk9MnQorVsClS/D4MdjZ0Z6Og4NFhDyhrfiT3biZmlnN4tSvX9/d3Z18ffXqVeUXpiRTpkxZuXLlyZMn09LSjIyM6Et08yZ4eQGPB3v2QIuaSH9Vxc4O2reH//0PTpyAsWNpTMTBobKI+WI7jY+fyjyoma17/fr18/Pz5Q9btWqlJZ+LzSqdOnVycHB4/PixqampsbGxgYGBYTnq1atXt66Vvr6JoWFlA2eCgyE2Fu7eBTU1ePIEGjWCiIhP/YMFBRASwsx7KmPx4sUHDx7cvXv3kiVLKi95y8jI2Lp1q5+fH1HxHB0dvby8XFxciKOirq5uz5495S+247ZoVFNcXDxz5szhw4fr6ekBQFxcHCJaWVmxvS4OFaJ///4ikejGjRu//vqrk5NTx44dKZkIDwCIMG0aHD8OdetCWBg0bUpJ1Mrg88HFBXbtglOn4OO8Rw4ATsDi4AFvd5Pdo16M2pOxR0eg87b07e3mt5UJiKhCxVwuLi4WFhYJCQlnz54lkjwdLF4Mt25Bo0YQEAAMuELr6IC7O2zbBlu3cq7JHBzfJMbGxs7OzqdPn/7nn3/mz59PU5akJBg6FEpKYPFiJibTT50K//sf7NrFCVgcHDVn0KBBig93797N1ko+Izs7OyUlhc/n5+XlxcXFfellPXpcvHrVBAA0NcHQEAwNoW5dqFu37GtDQ+jdG7S0oHdv2LABlixh8A18GeJSf+zYsc2bN3+pDuvdu3ebN2/esmVLQUEBfJSuBg4cyOxKaztZWVmrV6+eOnUqeXjkyBEymYTdVXGoFCdPnpRIJPr6+uvXr1+/fr1AIGjevHnXrl0dHR0dHBxaKHGUN38+7N0Lurpw/jzY2FC45MpwdYVduyA4GNiYm6268FRKbuBgkQxJRgmWED+sLGlWHUGd6hpjXbp0afPmzWfOlNXMjxkzxs3NbciQITQsthr4+vr+8ssvvXr1oslu5vx5GDAABAK4evWT5R7dxMWB9f+zd59hUV1rG8cfEKQoIkjTiIUoYO8x9hK7gDGxxthiFCO2V2OJib1ENHqiHhtWMFZOEkGwa1REbGBHKaICgqJgRxSYeT+MmRijxjLMbPT/u/yw18yetZ7xutzO3LP2Wu5iZiZJSaL3DR6BfCY2NnbTpk0//Pmf/9KlSytXrtxAb/9cXyA4OLhDhw5ubm7nz5/Pi/0Qs7KkSRM5elRatpRt20QPqwnfvy8lSsi9e3L+vLi75/lwAPSpd+/eAQEB9erVCwoKun37dvo/3Lx5Mz093dFxTlhYjfR0edEiRcuXy5gxcvGi1Kghu3bJ8uVSsqRoNg2ztxcRycyUc+ckL5dgfo6TJ0/WrFnT0tLy0qVL9po6/nT58uX//Oc/fn5+mnWXWrRoMXXq1I8//liv9UFERK5fv/7RRx9dufJkt4QZM2YQYOFpwcHBn3/+eU5OTt++fW1sbA4dOhQZGZmdna09oWTJkg0bNqxfv37Dhj5Vqhi/+m5qv/wiPXuKubls2yZNm+ZF7c/38KHY20tmpiQmSsmS+htX4ZiBhSfsTOy0x0ULFDVgJbrVr1+/iRMn7t279/Tp0zqfzn31qvTqJWq1TJ2qv/RKRMqXl9at5cgR1caN0YMGVdbfwEA+5Orq+sNTP115e3sbsBitdu3affDBBzExMeHh4Q0bNtR5/4MHy9GjUqaMrFunj/RKRAoXli5dZMUKWbVKfH31MSIA/QgODg4ICLC0tFy9erVmMcHy5cu//CUPHkh6uqSny40bTw40f2rUEBGxtpapU2X4cKn850eYXr2kVi0RkWvXRP8X6erVq7dp02bbtm0LFiyYMmWK5sFz5875+vquX78+JyfH2NjYw8Nj0qRJtTRVwkCysrJ27typOY6Pjy+jh/u4kE/88ccfXbt2zcnJmTRp0sSJEzUPZmdnnz59+uDBg+Hh4X/88UdycvKGDRsOHLickjKkUCGpXl0aNpQGDaRBg2e3Ue7XTzp3ljZtRESCgsTMTHr1ks8/12t6JSIWFtKypWzeLCEhMvAN90p9B7GIO3TG3t6+bt262mbNmjWLFy9uwHo0rKysevfuLSI63zpHpZJeveTmTWne/MluEfr07bexmZnFZs5sx643QH5kYmKiWcp92bJlOu980SJZsUIsLOTXX8XO7t/P1xXNjR3+/vLU750A8rebN29qcn9fX99XX2+oUCEpVUpq1JBWraR7dxk8WCZOlPnzpWbNJyd88YU8eCC7dz9pli4tFSpIhQpSrpzu38Kr0Ezk0axSf+rUqV69elWrVm3NmjVGRkY9e/Y8d+7cli1bSK8MLisra++fLl68aOhyoBTHjh3r0KFDVlaWj4+PNr0SEVNT01q1ag0bNmzTpk1paWnR0dHLly//8stRbm7y4IGEh4uvr3h5iYODVKsmPj7yyy+i2Y80KEhGjpR790RELlyQmBjx95c8W43mZTSD5s2q9PkVtxDi3RcfH+/m5mZmZpaQkOCkux0j1GqZP1/mzJGjR/N8H4rnja6uVKnS+fPnN23a1FkPy9sA0LVLly6VK1fO1NQ0ICCgZs2aZcqUMXn16ewvlpUl7u5y5YqsXy/dur19f6+nalVJTVWtWpXo4VFG32MDyANdunQJDAxs3rz57t27dXK/s52d3LwpIhIbK1Wrypw5EhQk48dLo0YiIklJ8skn+r6FUKNp06b79+93c3OLiYkREXNz8379+o0aNap06TdZjx86xy2EeK7Y2NhGjRqlpaV9+eWX/v7+xsavNEHnxg05dEjCw+XQITl+XB49+uupUaNk5UoZOVJu3JC5c8XXV7KzDbYK1Y0bUry4mJjIjRuio/Xo8z1uIcS7r1y5ctWrV4+NjS1evLiNjY2Li4uLi0vx4sVLlCihPShTpsy/Xu+Sk+XTT2X5cqleXURkzBj57DOpXl0KFnxywvHjsm6dzJ2bx+9HRESMjIyGDBkyaNCgefPmEWAB+ZG9vb2tra2lpWXXrl1FxNTU1NnZWXOBqlixYqVKlVxcXMqWLfuv3xgTE+XaNfnooyfNw4dl927x8/srvTp//slsCD0YOvQPHx+vhQsbenhs08d4APLSL7/8EhgYaG1tvWrVKl2t1qcNHFxdZe1aKVtWHB3FxeXJg0WLytixOhnn9Rw8ePDRo0cmJiaxsbGFCxf+6quvRo8e/cEHHxigFACvLCkpqWXLlmlpaV5eXqtWrXrF9EpE7O2lQwfRbJuRkyOnTsnBgxIeLvv3P/miN2KEVK8uvXrlWemvxt5ePv5YwsNl5075/HMDF6MQzMDCu+/MmTMfffRRbm5ubm6uSqV67jnm5uaenj9nZHg7O0vp0uLsLCVLiuZYu4H1xYtSt664usrBg2JsLJ06yYAB4u0tERFPZmDt3Stz5khoqJ7eV2ZmprOzc0ZGxtGjR+vUqaOnUQHoglqt7tq1a2BgoJOTU6VKleLj45OSkv55gbK2tm7RIs7MzN7NTVxdn/wpXPhv5/z8s4waJUeP/rW4THi49O0rx449OWH4cHF319PqCbdv3/7ggw+ysrISEhKYtgDkaykpKVWqVMnIyFi9erVmNYZ3j1qtDg4Onj59+rFjx0TExMQkJydn+vTp48aNM3RpeFZGRkb37t137NihaS5fvjw3N1ch61rCIG7cuNGoUaOYmJhmzZpt3brV3NxcJ93m5IiTk9y8Kdu3y9Sp4uVlyBlYIjJ7toweLb17q1av1sHqT5999tnSpUs1u1VERUX5+/vPmzfv7bvVJ2Zg4R334MGDrl27ZmVlff3118uWLbt161ZCQkJCQkJKSkpqaqr2+Nq1aykpRcLDn9ODra04O0upUtK/v3z4obi6ip+fIhbSs7S0/Oqrr3766acFCxYEBAQYuhwAr8HX1zcwMNDKymrv3r0VKlQQkcePHycnJ587dy46OlpzaTp37lxqaurBg8WuX//baz/44EmSVb68uLmJSiVt2sg338ihQ/LKPz3mlaJFi3bs2HHt2rUrV66cPHmygasB8KbUavXXX3+dkZHh6en5TqZXKpUqNDR08uTJkZGRImJvbz9o0CA3N7cvvvhi8eLFI0eONDMzM3SN+BtbW1tteiUiX2uWXcT76s6dO61bt46JialTp05QUJCu0isR0S7n0KaNLF8ugYHy6ae66vtNdOiQ+euvX+7dG5mTc/Ht15o4derU48ePNcd3797V3DGdvzADC++4Pn36+Pv7V6pU6ejRo5aWli86LTMzMzFREhMtk5IkKUmuXJHkZElKksREefjwyTmBgTJ7tgQFyccfy5Ej4uPzZAaWk5OYmoqI3LkjJUvqbwaWiFy5cqVcuXLGxsZXrlzR4fJeAPLU7t2727Rpo1arg4KCPDw8XnJmenp6bGyxCxckLk5iYyU2VuLi/rY/vbm5zJgh9+9LbKzUqyeDBj2ZgdWpkyxa9OScRYukRQv9xe779u1r1qxZyZIlL1++XEA/OyAC0LUlS5Z88803dnZ2Z86cecc+YGRnZ69fv37GjBmab26Ojo7/93//N2TIEEtLS7VaXb169dOnT/v5+fXv39/QlQJ4vszMzDZt2oSFhbm6uoaFhTk4OOi2f+1SfcnJUqGCjBljyBlYIuLu7h4TE7Nv374mTZq8ZVcffvjhgQMHNPdH79u3b+bMmdu3b9dFjfrDDCy8yzZs2ODv729ubr5u3bqXpFciYmlp6e4u7u7PeerGDUlKkuRk0dwN4+Qk//d/f1ugYe1a0Vw2DxyQhQt1Wf+/Kl26tJeX12+//bZ06dKnN90AoFhXrlzp3r17bm7ulClTXp5eiUixYsXq1ZN69f56RKWSxMQnSdaFC5KdLZp1aWbNko8//mt9hNu3/wrTL13S/bt4iaZNm7q7u1+4cGH79u3t27fX69gAdOHSpUujR48WkUWLFr1L6dWjR482btw4ZcoUzQZ2ZcuWHTZsmLe3t3buhpGR0Xfffde9e/eZM2f27dtXJxtrANCt7OzsTp06hYWFOTs779q1S+fplTy1VF/JkrJxoxQtqvMRXk+HDh1mzZoVHBz8NgGWSqXSbF7/+eefFyxYUETu3LlTvHhxnVWpL4a+2QDIM3FxcQMGDBCRhQsXVq1a9Y37sbeXmjXFy+uvdWcGD5bTp+XMmSdNS0spXFgKFxbdzV19Dd9+++2MGTOGDh2qaebk5OTm5hqgDgCv4OHDh5999tnNmze9vLy+//77N+jB2FjKlJFWrcTHRxYskCVLnjxevLiMHPnXL4TOzjJnzpM/mr299Klv374isnz5cn0PDOCtqVSqvn373rt3r0ePHu/MLjH379+fN2+ei4tL7969L168WKlSJX9//9jY2GHDhj1z51Hnzp1dXV0TEhI2btxoqGoBvIhKperZs+e2bdvs7e137dpVKg92qFGpZPXqv5r378sff+h8kNfj6ekpIkFBQW/w2qysrN27dw8bNszZ2XnlypUismbNmq1bt27dunXmzJk6LlQvCLDwbsrKyurSpcu9e/e6du361Vdf6bbzAgVkyRKJj9dtr2/IzMwsJCTExsZG0xw2bJi/v79hSwLwIt98801UVJSrq2tAQMCr75Xzinx85MQJyc7Wba9vonfv3qampiEhISkpKYauBcDrmTt37v79+0uUKDF//nxD16IDd+/e9fX1LV269PDhw1NSUqpVq+bv73/q1KlevXo9d4JVgQIFxowZIyLTp09/0c4/AAxCrVZ/8803GzdutLa23rFjh5ubW96MIk8vDHX7tjyzFKn+1a9f39HR8eLFi9HR0a/4khs3bqxatapjx47FihVr2bLl/PnzU1JSIiIiRMTS0rJw4cKFCxe2sLDIy6rzCjNj8W4aPnz4yZMny5Ur5+fnp6s+HR1lxownx3XqyPbtUrWq/Pe/f00rrVzZMHs/A8gX5syZ4+/vb2Vl9dtvv1lbW+uqW2vrJwuOFiggCxZIv35iZiZlyvx1gqOj/Blx64mjo+PAgQNtbGw0c9QB5Bfnz5+fMGGCkZHRsmXLbG1tDV3OW7lx48bChQvnzZt3+/ZtEWnQoMGYMWM8PDyMNPddv1jPnj2nTp16/vz5zZs3f/bZZ3opFsC/Gzt2rJ+fn4WFxZYtW2potl5+PxgbG7dr127VqlVBQUEVK1Z8yZkJCQlbtmwJCQnZt2+f5oZBEalYsWLnzp09PT1r1qxZrlw5vZScl9TAOycwMFBEzMzMIiMjDV1LnouMjKxfv762OWjQoBUrVhiwHgDPtXfvXhMTEyMjo8DAQEPXog8DBgw4duyY5vjatWtt27Y1bD0A/lV2dnadOnVExNvb29C1vIbRo0cvWbJE27S3t4+Pjx86dKh28dMGDRrs2rXrtfr873//KyLVq1dXqVS6rhfAm/jxxx9FxNTUNDQ0NE8HyslRGxurq1d/8sfZWT1kSJ4O+Ep+//13Efn444//+VRubu7x48cnTpxYq1YtbchjYmLSoEGDn3/+OSkp6emTQ0JCMjMzNcdpaWn79+/XR/U6xQwsvGsSEhI0G+vOmTOnZs2ahi5HH06dOqX9FSI5OfnpixcAJUhMTOzatWtOTs748eM7depk6HL04fLlyw8ePNAcZ2dnx8bGGrYeAP9q2rRpx44dK1u27OzZsw1dy2t4ZvXPx48fL1iwYP78+UZGRp9++un3339fu3bt1+2zX79+M2bMOHny5I4dO9q0aaPTegG8tnv37i1ZsqRAgQK//PJLu3bt8no4c3M5ceLJsZ+fnD2b1wP+u1atWllaWh49evTatWuavTUePnwYHh6+ZcuWwMDA1NRUzWm2traffPKJh4fHp59+WqRIkX/28/TuOvb29vb29vqpX4cIsPBOyc7O7tGjx507dz7//HMfHx9Dl6Mn1apVCw8P1xy/P+8ayC+ysrI6dep048aNVq1asVsoAGU6ceLEjBkzjI2NV61aZWVlZehy3srw4cMzMjJGjx5duXLlN+vB3Nx8+PDho0ePnjJlCgEWoH+9e/ceMGBAgwYNROTmzZseHh5hYWHh4eFdunQxdGmGYWlp2bx585CQkA0bNtja2oaEhGzbtu3+/fuaZ8uUKdOqVSsPD482bdqYmpoattS8RoCFd8ro0aMPHz5cqlQpHS59BQBvw8fHRzOpYd26dQUKFDB0Ofrj7e1duHBhEclWwsLyAF7K1ta2YcOGNWrUeJtt2g1l5syZ2m1P79+/X7x48YCAgLfsc9CgQbNmzYqIiDhw4EDjxo3fukYAryE9PT0rK0tznJube+3aNWdn527duhm2KgOKjo7WrCs6YsQItVotIsbGxnXr1u3QoYOXl1elSpUMXaD+EGDh3REaGjpv3jxTU1NNMm3ocgBAFixYsHLlysKFCwcHBxcrVszQ5ejVkiVLNN/6rl692qxZM0OXA+Bvtm3bdu7cuW+//VbT9PX1/e9//5tP1/cdO3bsoEGDNMdFtXvrvJ1ChQoNGTJk4sSJ06dPJ8AC3h8FCsjvv//VbNtWGjY0TCW5ubknT57csmXLpk2bzp8/LyIFChRQqVTNmjXr0KFDp06dPvjgA8NUZlAEWHhHJCcn9+7dW61W//jjj/Xq1TN0OfpTpUqVoKAgbXPGjBls+wUoxKFDh7799lsjI6MVK1a88Z0s+ZeRkZGxsbHmwNC1AHjW9evXL168qG2eOXMmMzOTjxBPGzZs2Ny5c3fu3BkREfFefbYElGDgwIGa25m1u+npTatWfx07O+t5cLl///6OHTuCg4NDQ0PT09M1D9rb27dv3/7QoUOxsbFDhw799NNP9V2WYhgbugBAB3Jycrp165aent62bdsRI0YYuhy9MjU1tbOz0zatra0tLCwMWA8AjdTU1M6dOz9+/HjMmDHv7ZINAJB/WVtbDxw4UER8fX0NXQvw3lmyZElUVFRUVNSuXbsMXYs+3LhxIyAgoEuXLk5OTp06dQoICEhPT3dxcRk6dOiuXbuuXr26atWqPn36iEhwcLChizUkZmDhXTB+/Pjw8PCSJUsGBATwUz8AJVi5cmVKSkrLli2nTZtm6FoMYMqUKeXLl9cc29nZsS4hoEBbtmzR7hB65swZwxbzxsaOHfv0osXHjx/X4TyyESNGLFiwIDg4+MyZM1WqVNFVtwDeEzk5OSYmTyIXtVqtVqs1k9O1EhISNDsJRkREqFQqETE2Nq5Vq5aHh4enp+czm8t36NBh3LhxwcHBubm579Wyqk8jwEK+l52dfeDAARMTk3Xr1j09FwkA9CYrKyssLKxly5aaZkxMTOfOnR0cHD777LP38xNG3bp1tcfm5ubNmzc3YDEAnqtVq1Y//fST5vjpvdXzl2e2gdftMl4ODg5ff/31/Pnzf/zxx3Xr1umwZwDvPLVaXaRIkczMTE1zxYoVp06dWrBgQW5ubkREREhIyObNm2NiYjTPWlhYNGjQwMPDo0uXLsWLF39uhxUrVixfvnxcXFxERERDQy3NZWgEWMh/rl69GhER0alTJ01z7969fn5+165da9SokWELA/DeSk9PHzhwoHZBmY0bN5qYmIwbN86wVQHAS5iZmWk3vdHOEcAzRo0atWTJkk2bNk2aNMnV1dXQ5QDvhVmzZmlXKLe1tf3f//5n2Hp0Ra1W9+zZMzQ09NatW5pHHB0dPTw8vLy8WrZs+SrrwHh6es6dOzc4OPi9DbBYAwv5T0JCwtKlS7XN9evXnzlz5pNPPjFgSQAAAHj3lCxZslevXrm5uf7+/oauBXhfVKxY0draWnNsampau3Ztw9ajK0ZGRhcuXLh165Z2cavk5OTly5d7eXm94irGXl5eIvL70xslvmf4sQUAAB14+PDhtm3bNMdxcXEVKlQwbD0A8BKNGzeuWLGitjl+/HgXFxcD1qNk3333nbu7+/DhwzXNW7du3b59u2zZsoatCoDyZWVl1axZU3Ocnp7u5eU1f/58Ozs77Tqhr6thw4Z2dnbx8fExMTFubm66qzTfIMBCvpScnLxw4ULN8YULF9q0aWPYegDg4cOHBw8e1BwnJiYSYAFQMhcXl6cTq1ZP7xuPv3NxcZk8efLQoUM1axru3r17y5YtAQEBhq4LgNKZm5tHRUVpjpcvX37q1Kl69eq9TYcFChRo165dQEBAUFDQ6NGjdVFjPsMthMiXjI2Nzf/0fi6QDEBpbG1tp/+Jm5oBs2zXEQAAIABJREFUAACgc5q7CIODgw1diGEwAwv5UokSJfr166c5DgsLM2wxAAAAeLedO3dOs9R9UlKSoWsB8P5q3bq1ubl5RETE9evXHR0dDV2OvhFgAQDwtgoWLPj0ajJOTk5MDgWAd8mcOXOMjIxE5MqVK6VLlzZ0OQCUzsjIKD4+Xtv84osvOnXq9PbdFi5cuFmzZtu2bdu6dWvfvn3fvsP8hQAL+Y+dnd3T+4bWrl3b2dnZgPUAgL29/ZYtW7TNAQMGGLAYAIDOrVy50tTUVEQCAwOfvuADwIuUKFFCe2xpaWlpaamTbr28vLZt2xYcHPweBlhGarXa0DUAAAAAgEIVKVIkPT396QCLRdwBGEpKSkrJkiUtLCxu3Lihq1Asv2ARdwAAAAB4IVtbW839gyJiZmZmZWVl2HoAvM9KlChRu3btzMzMPXv2GLoWfSPAAgAAAIAXunz5smYFdxHx8vJauHChYesB8J57b/ci5BZCAAAAAACA/OHMmTNVq1Z1cHBITU01Nn6PpiW9R28VAAAAAAAgX6tSpUrZsmXT0tKOHDli6Fr0igALAAAAAAAg33g/7yIkwAIAAAAAAMg3NAHWyZMnDV2IXhFgAQAAAAAA5BvW1tahoaHbtm3TNDdv3qxSqQxbkh4QYAEAAAAAAOQb69evv3TpkrbZp0+fx48fG7Ae/SDAAgAAAAAAgKKZGLoAAAAAAAAAvIYzZ85oF3HPyckxbDH6QYAFAAAAAACQnyQmJkZGRmqOCbAAAAAAAACgOO3bt/fx8dEcz5s3z7DF6AdrYAEAAAAAAEDRCLAAAAAAAADyDWdnZwcHB22zRo0axsbvfrxjpFarDV0DAAAAAAAA8ELvfkQHAAAAAACAfI0ACwAAAAAAAIpGgAUAAAAAAABFI8ACAAAAAACAohFgAQAAAAAAQNEIsAAAAAAAAKBoBFgAAAAAAABQNAIsAAAAAAAAKBoBFgAAAAAAABSNAAsAAAAAAACKRoAFAAAAAAAARSPAAgAAAAAAgKIRYAEAAAAAAEDRCLAAAAAAAACgaARYAAAAAAAAUDQCLAAAAAAAACgaARYAAAAAAAAUjQALAAAAAAAAikaABQAAAAAAAEUjwAIAAAAAAICiEWABAAAAAABA0QiwAAAAAAAAoGgEWAAAAAAAAFA0AiwAAAAAAAAoGgEWAAAAAAAAFI0ACwAAAAAAAIpGgAUAAAAAAABFI8ACAAAAAACAohFgAQAAAAAAQNEIsAAAAAAAAKBoBFgAAAAAAABQNAIsAAAAAAAAKBoBFgAAAAAAABSNAAsAAAAAAACKRoAFAAAAAAAARSPAAgAAAAAAgKIRYAEAAAAAAEDRCLAAAAAAAACgaARYAAAAAAAAUDQCLAAAAAAAACgaARYAAAAAAAAUjQALAAAAAAAAikaABQAAAAAAAEUjwAIAAAAAAICiEWABAAAAAABA0QiwAAAAAAAAoGgEWAAAAAAAAFA0AiwAAAAAAAAoGgEWAAAAAAAAFI0ACwAAAAAAAIpGgAUAAAAAAABFI8ACAAAAAACAohFgAQAAAAAAQNEIsAAAAAAAAKBoBFgAAAAAAABQNAIsAAAAAAAAKBoBFgAAAAAAABSNAAsAAAAAAACKRoAFAAAAAAAARSPAAgAAAAAAgKIRYAEAAAAAAEDRCLAAAAAAAACgaARYAAAAAAAAUDQCLAAAAAAAACgaARYAAAAAAAAUjQALAAAAAAAAikaABQAAAAAAAEUjwAIAAAAAAICiEWABAAAAAABA0QiwAAAAAAAAoGgEWAAAAAAAAFA0AiwAAAAAAAAoGgEWAAAAAAAAFI0ACwAAAAAAAIpGgAUAAAAAAABFI8ACAAAAAACAohFgAQAAAAAAQNEIsAAAAAAAAKBoBFgAAAAAAABQNAIsAAAAAAAAKBoBFgAAAAAAABSNAAsAAAAAAACKRoAFAAAAAAAARSPAAgAAAAAAgKIRYAEAAAAAAEDRCLAAAAAAAACgaARYeOLBgwfh4eG3b9/O64EePnwYGRl569atvB4IwLsqNTU1PDxcpVLl9UBpaWmRkZE5OTl5PRCAd9X169fDw8Nzc3PzeqCbN29GRkZmZ2fn9UAA3lXnzp07d+6cHgaKi4u7cOGCHgbCu4cAC0/ExcU1bNgwIiIiPj5+0aJFd+/ezbuBateuvXfv3n8+lZmZ6e/vv3379jwaGsC7ITAwsGHDhg8fPgwLCwsICMi7gTZt2lS7du1/Bu537txZtWrVhAkTFi5cGBMTk3cFAMjvfv/994YNG967dy88PHz16tV5N9Bvv/1Wu3bttLS0Zx7PyMjw8/MbP378woULL126lHcFAMjvhg8fPmTIEBFZs2bNgQMH8m6gIUOG9O3b9yUnrFmzxs/Pb//+/XlXA/IpAiw86+TJk8OHD09PT9fnoGlpaZMmTSpdunSfPn3Gjx+vz6EB5F//+9//Jk2apOdB9+3b5+LiMnLkyL17906bNq1KlSoLFy7Ucw0A8p3Nmzfr/xPO9u3by5YtO3Xq1P3790+dOtXNzc3f31/PNQDIdyZPnhwYGGio0desWdO3b9/hw4dzvcI/EWDhWZ06dXr8+HHZsmX1Oeh3330XERExZcqU+vXr63NcAPnavHnzEhIS9DmiSqX65ptvPv7446SkpIMHDyYkJDRo0GDkyJEZGRn6LANAvjN79uykpCR9jpidnT1o0KABAwZcuXLlwIEDly9frl+/vo+PD7dFA3i5+Pj4BQsWGGTomzdvjhw5cujQofb29gYpAApnYugCoDhXr149duxYq1atLC0tRSQyMvLYsWPZ2dkuLi7Z2dm1atVydnZOSUkJCwtLS0srXrx4y5Ytra2tRWTr1q0VK1a0s7PbunXr9evXa9as2aBBA223x44dO378uLGx8XOXgVixYoXmIDQ09Pr163p5owDyvdOnT6emprZu3VpEcnJy9uzZExMTU7BgQVdX1/T0dE9PT3Nz87Nnz0ZFRd29e7d8+fKffPKJiYlJZmZmaGhou3btbt++vWPHjuzs7GbNmrm6umr6zM7O3rNnT2xsbNGiRf95e6CxsfGRI0dUKlWhQoVExMLCon///vv27Ttz5kyTJk30/PYB5CNnz55NTk5u06aNiOTm5u7du/f8+fOmpqZubm7p6ent27e3tLSMjo6OjIy8c+dOuXLlWrRoYWJikpWVtWXLljZt2ty7d2/Hjh2PHz9u0qSJu7u7ps+cnJy9e/deuHDB2tr6/Pnzz4xoamoaGRlpZWVlbGwsIubm5k2bNt2/f/+1a9dKliyp57cPIB/ZuXOno6NjtWrVRCQjI2PXrl0pKSm2trYffPCBiLRo0SInJ+fAgQNxcXGmpqY1atSoUaOGiMTHx1+8eLF169bHjx+PiIgoVqxY+/btNd8TRSQ9PX3Xrl3Xr18vUaJEenq6icnzg4ghQ4aYmJhMnDjx119/1dfbRX5CgIVnHTx4sFu3bhcvXixevHj37t2Dg4Pd3d2tra3j4+Nv3ry5YcOGIkWKeHl5lS9f3sHB4fz58yqVav/+/RUrVvTx8albt25YWJiTk1Nubu7QoUOnTJkyfvz4zMzMrl27hoaGuru7FylSJD4+3tBvEcA7YunSpUFBQcnJyQkJCZ6envHx8VWrVs3Ozr548eL9+/dTUlIWLlz4008/VapUydLSMjIy0t3dPTw8/ObNm126dBk4cOCGDRsqV66clJQ0dOjQLVu2tGrVKj4+3tPT89KlS1WqVMnOzn7u9apIkSJPNzXfDFk4GcDLrVixYt26ddevX79y5Yqnp2dMTEyVKlVyc3Pj4+Pv379/+fJlf3//6dOnV6pUqVChQlFRUR9++GFERMTdu3e7dOni7e29cePGSpUqXb16dciQIZs3b27Xrt2lS5c8PT3j4uK0171/DmpjY6M9fvToUUhISPny5UuUKKHH9w0g//n666/bt2+/ePHi3377rU+fPiYmJhUrVtRcvqpWrXr8+PHatWsnJSVVqFAhMzPzxIkTI0eO/Omnn3bs2PH999937Nhx27Ztrq6up0+ftra2PnnypI2NTWBg4FdffWVqaqrp5/Lly7Vr1/7nuFu3bt2wYcPvv/+ujb2AZ3ALIV5o3LhxISEhmzdvjo6OjoiI0K6i17Rp09jY2Ojo6H379sXFxRUoUMDX11fz1O7du3///ffIyMiTJ0/27Nlz5syZKpVqzJgx27Zt27JlS3R09OHDh5+7fDsAvDG1Wt2lS5c7d+6cOnXq2LFjJ0+enD17tuYpHx+f1NTUyMjIsLCw/fv3nzhxYt26dZqnjh8/Hh0dHRYWFhsbW7p06Z9++kmtVnfu3PnBgwenT5/W9DNz5sx/HX3Hjh2FChWqU6dOHr5DAO+Q7t2737hxIyoq6vjx4ydOnJg3b57m8QEDBqSmpkZFRYWFhR06dOjMmTPaTSqOHj169uzZgwcPxsbGli9ffvbs2Wq1umvXrrdu3Tp58qTmejVnzpwXjbhq1aqvvvrKzc3NyMgoODhYE7sDwMslJCT06NGjcePGiYmJBw8ejIuL08x5F5FNmzZdv3794MGDUVFREyZMmDt3bmpqqojcuXPHysoqKSnpwIEDYWFhiYmJv/zyS1xcXM+ePZs3b65ZfiEuLu6TTz7553D37t0bOHBgu3btPv30U72+T+Qr/AeG58vNzV21alWnTp28vLyeecrCwkKzQlZubm5ubm7lypVjY2M1T3l4eHz00Uea4/r162dmZiYnJ69evbpbt27t27fXZ/0A3h8nTpyIjIwcN26c9rYareLFi2smIDx69KhcuXKWlpbauwIHDhxYvHhxESlYsGDt2rUvXbqk+RL4ww8/aG8n/FdHjhxZu3btmDFj+KkQwKs4e/ZsRETE2LFjK1Wq9MxTTk5Otra2IvLo0aNSpUpZW1trr1cDBgzQ3Lljampap06dS5cuafL6cePGVahQ4V8HvX//fnZ2toWFRXJy8unTp3X9ngC8m9asWZOVlbVo0aLChQs/85Srq6vmHsD79+/XrFlTrVZrJ63/8MMPpqamIlKlShUrK6tLly4FBAQ8fvx40aJFmuUXXmTs2LHp6elsjIOXI8DC8928efPOnTs1a9b851OPHz+eMGFCmTJlzMzMbG1t9+zZk5WV9c/TNFeulJQUzXUtzysG8L7SZOjPvc5cvXq1X79+9vb25ubmtra2mZmZjx49+udpBQsWzMnJeUk/zxUXF/f555/Xq1dv1KhRb1E+gPfIS64zqamp/fv3d3Bw0Fyv7ty589zrlamp6eter4YMGbJmzZro6GgPD48vv/zyypUrb/cmALwX4uLi7O3tS5Uq9c+n9u/f36JFi0KFCllZWWkmTL3o+2BOTk5cXJyTk5MmhX+Rw4cPL1myZNq0aWXKlNFR+Xg3EWDh+TQBuUql+udTw4YNmzdv3rRp0y5fvpyRkdG2bduX9GNhYfGifgBAJzQ/DP7zOqNWq1u3bn348OENGzakpqZmZGQULVr0Jf285Lr3T4cOHWrSpEnJkiVDQkLMzc3ftHYA75eXXGfatm0bFha2du1azfXq5Ttwvdb1SsPIyKhbt27Z2dkRERGvWTWA91HhwoWfe5E5d+5cmzZtHBwcNOuKbt269c36edrUqVNVKtWIESOM/pSYmLhq1SrNlAhAiwALz1e4cGFHR8enP+KcOXNGcxASEtK5c+cvv/yyZMmSTy8O+lw2NjbFihV7bj8AoBNubm4icujQIe0jZ8+eFZHExMRz586NGTPmk08+cXJyKlKkyMs/P72on3/y8/Nr1qxZ48aN9+zZY2VlpZN3AeB98KLrTGpq6qlTp0aNGtWyZUsnJydra2u1Wv0G/TwjNDT0zp072ubly5dF5OVRPgBoaPZ01t7LnJOTo9ntdPfu3VlZWQsXLqxevXqxYsX+9Wc8V1fXtLQ07T2G2dnZFy5ceOac0aNHb/o7Ozu7pk2brl+/XtdvC/kbuxDihby9vadNmzZlyhRPT8/o6Ojhw4drHnd2dg4PDz9z5oxKpVq9evX27ds1e6y+pJ+ZM2dOmzatffv2Z8+eHTFixD/PSU9P12yVmpiYePfuXT8/PxH5+uuvWWcUwL8qX758s2bNpk+f7uDgULVq1a1bty5evFhENB+qtmzZ0rhx46SkpOnTp9+9e/cl/VSsWLFRo0ZTp061s7OrXLnyli1bVqxY8cw5jx8//uqrr9auXVutWrXmzZuvXbtW83iNGjVYxx3AvypTpkzr1q19fX2LFy9eo0aN7du3z58/X0SKFi1qaWkZEhLSvHnzq1evzpw58+bNmy/pp1y5cs2bN58xY4ajo2PVqlW3bdu2ZMmSZ865d+9e//79ixYtOmHChJIlS546dWrChAlubm7NmzfPw3cI4F3RrVu3yZMn9+jRY9asWZaWlrNmzbp48WKtWrWcnZ1FZO3atR4eHsePH3/ul7unffHFF9OmTfviiy98fX3Nzc1nzpyZlJSkWYdUq0mTJs+86ttvvy1btmynTp10+6aQ35EO4AlTU1MHBwczMzNzc3MHBwcTE5MJEyb88MMP/v7+H3300Y8//qhd5GXx4sXGxsZVq1atW7fuo0ePfvzxR82m8tbW1paWltoOzczMbGxsjI2NJ0+e/N13361cubJWrVrTpk1bvXp1hQoVnlnDLyUlZezYsWPHjk1OTr57967mODc3V59/AwDyC0tLSwcHByMjoyJFimjusgkMDPTw8Bg9enS9evV27do1ZMgQESlcuPDq1av37dtXtmzZDh06tGvXrnv37hYWFsbGxjY2NmZmZk93qFmF/bfffmvTps3IkSNr1aq1e/fuX375xcXFpUCBAtoz09LStm7damNjk5iYOPYpO3fu1PtfA4B8QHO9MjY2trKy0lyv1q9f36FDh++++65u3bpbt24dNmyYiFhYWAQEBBw6dMjFxcXT07N58+Y9e/a0tLR8yfVKe92rWbPm1q1b165d6+LiollWWcPKyio8PLxy5cr9+vVr1KjR6NGjW7VqtWfPnoIFC+r9rwFAPmBjY6PZSsLe3r5IkSIlSpTYtWtXoUKFvLy8PDw8bG1tNfF3x44dBw8ePGLEiLJly06aNMnf39/JycnU1NTc3Fzz7U/bYdGiRS0sLEqWLLlz504zMzNPT88WLVo4OTlNnjy5RIkSLy/mma+WgIbRy+cnAyKiVquNjIxOnTpVvXr1zZs3d+jQQUTu3r1rZmb29CeqV+wnz8oEgCfXmQULFgwdOjQ9PV3zOSwjI8Pa2vrpHOoV+8mzMgHgyXVm6dKlAwcOTE1NdXJyEpGMjIwiRYo8nUO9Yj8vP+fevXvc7wzgzWgvMq1bt75//354eLiIZGdn379//1/Xk3luP8AbYwYW/p3mQqNZW+HDDz/UPFikSJHXSq+0/QBA3tFer2xtbTXplYjY2tq+VnolXK8A5D3t9crKysrR0VHzoK2t7WulV/Jq1yvSKwBvTHORyc3NvXDhQrly5TQPmpqavlZ6JXy4gi6wBhZeaOzYsbGxsZ6enk5OTpcvX542bVqdOnUqVapk6LoA4FktWrRwc3OrX7++jY3NsWPHVq9e7ePjY+iiAOA52rZtW7p06UaNGtna2h4/fnz58uX9+vXjex0ApUlOTm7VqlX37t2rVKmiVqs3bNiQnJzcs2dPQ9eF9xq3EOKFjh07tnLlymPHjqWmpjo6OtavX3/SpEl2dnaGrgsA/kalUm3ZsmX9+vVnz569detWmTJlOnToMGLEiNedxQAAeU2tVoeEhKxbt+7s2bMZGRmlS5f28PAYNWoUW8UDUJo7d+6sWbMmKCjo0qVLKpXK1dV16NCh7dq1M3RdeK8RYAEAAAAAAEDRWAMLAAAAAAAAikaABQAAAAAAAEUjwAIAAAAAAICiEWABAAAAAABA0QiwAAAAAAAAoGgEWAAAAAAAAFA0AiwAAAAAAAAoGgEWAAAAAAAAFI0ACwAAAAAAAIpGgAUAAAAAAABFI8ACAAAAAACAohFgAQAAAAAAQNEIsAAAAAAAAKBoBFgAAAAAAABQNAIsAAAAAAAAKBoBFgAAAAAAABSNAAsAAAAAAACKRoAFAAAAAAAARSPAAgAAAAAAgKIRYAEAAAAAAEDRCLAAAAAAAACgaARYAAAAAAAAUDQCLAAAAAAAACgaARYAAAAAAAAUjQALAAAAAAAAikaABQAAAAAAAEUjwAIAAAAAAICiEWABAAAAAABA0QiwAAAAAAAAoGgEWAAAAAAAAFA0AiwAAAAAAAAoGgEWAAAAAAAAFI0ACwAAAAAAAIpGgAUAAAAAAABFI8ACAAAAAACAohFgAQAAAAAAQNEIsAAAAAAAAKBoBFgAAAAAAABQNAIsAAAAAAAAKBoBFgAAAAAAABSNAAsAAAAAAACKRoAFAAAAAAAARSPAAgAAAAAAgKIRYAEAAAAAAEDRCLAAAAAAAACgaARYAAAAAAAAUDQCLAAAAAAAACgaARYAAAAAAAAUjQALAAAAAAAAikaABQAAAAAAAEUjwAIAAAAAAICiEWABAAAAAABA0QiwAAAAAAAAoGgEWAAAAAAAAFA0AiwAAAAAAAAoGgEWAAAAAAAAFI0ACwAAAAAAAIpGgAUAAAAAAABFI8ACAAAAAACAohFgAQAAAAAAQNEIsAAAAAAAAKBoBFgAAAAAAABQNAIsAAAAAAAAKBoBFgAAAAAAABSNAAsAAAAAAACKRoAFAAAAAAAARSPAAgAAAAAAgKIRYAEAAAAAAEDRCLAAAAAAAACgaARYAAAAAAAAUDQCLAAAAAAAACgaARYAAAAAAAAUjQALAAAAAAAAikaABQAAAAAAAEUjwAIAAAAAAICiEWABAAAAeAfNmzdv0aJF2mb9+vXT09MNWA8A4G2YGLoAAAAAANC927dvFyxYUNtMTk7Ozc01YD0AgLfBDCwAAAAAAAAoGjOwAAAAALybFixYsGnTJs3xtWvXDFsMAOBtEGABAAAAeDcNGTLku+++0xyXKlXKsMUAAN4GtxACAAAAAABA0QiwAAAAAAAAoGgEWAAAAAD0JyIiYuXKldrmzJkzL168qPNRgoKC6tWr16NHD+0jGzdutLGx0flAAAD9IMACAAAAoD8JCQmHDh3SNnfs2JGWlqbbIZKSknr16uXp6ZmZmal9sF69eqamprodCACgNwRYAAAAAN4pgwcPvnv3bps2bdzd3Q1dCwBAN9iFEAAAAIBehYeHe3t7a45jY2N127m/v39wcLCtre3SpUt12zMAwICYgQXkV4MGDTp8+LDmOD09vUWLFoatBwAA4BW5ubl9/afixYvrsOdr166NGDFCRH7++WcnJycd9gwAMCxmYAH5VWJi4v379zXHOTk5cXFxhq0HAADgFdnZ2dWpU0dzbGVlJSKLFi3q2bOn5vht+Pj4ZGRktGvXrmfPnm9bJQBASZiBBehSZGTkkCFDtM3x48fv2bPHgPUAAAAo344dO3x8fNzd3YODg9+mn82bD/72229FihRZsmSJrmoDACgEM7AAXbp37158fLy2efny5Vu3buXdcN98843mh8qcnJy8GwUAAECHqlat+vRMqz59+jg7O9etW/fIkSMdOnTo3Lnz4sWLixUr9rrd3rwpAwc2bNgwvk+fI87OzjotGQBgeMzAAvKxxYsXR0VFRUVF7dq1y9C1AAAAvJIqVap4eXlpm717927evPmhQ4eWLl1aqFChwMDASpUq/frrr6/b7bBhcv26mJp++NVXX+i0XgCAIhBgATp2+PDhBn/asWOHocsBAADIB4yNjQcMGHD69OlmzZpdv369U6dOXbp0uXHjxiu+PDRU1q0TS0tZtkyMjPK0UgCAYRBgATr20Ucf7f5THu0MqFKp8qJbAAAAw3Jxcdm9e/eCBQsKFy4cGBjYo8eDDRv+/VV37sjAgSIiP/4oH36Y1zUCAAyDNbAAHTM2NrawsNAcFyhQQOf9q9XqAQMGqNXqH374oVy5cpoHbWxsVq1apfOxAAAA9MzY2Hjw4MEeHh7Tpx9evrzMrl2yYYMsXizFi7/wJSNGSHKy1KsnPj56LBQAoF/MwALyVk5OTvfu3SMjI3XV4aRJk1asWLFx40Zra2s7OzvNgwULFmzevLmuhgAAADCsMmXKLFvWbdMmsbWVoCCpUEH8/EStfs6Ze/fKqlViZibLl0se/HQIAFAKAixAlypVqvT9999rm0OHDj179uyGDRuaNm2qk/Wwli1bNmXKlAIFCvzyyy8VKlR4+w4BAAAUq3NnOXdOOnaUO3fE21vatpXExGfPMTOTDz+UKVOkYkVDlAgA0Bcj9XN/yACgIzk5OYMGDVq2bJmJicmiRYv69+//xl2FhoZ++umnubm5y5Yt69evnw6LBAAAULK1a2XYMElPFysrGTtWfv9d1q8XzVIKAwaIj49UqiSzZsm4cYYuFACQZ5iBBeQtExOTpUuXTpw4MScnx9vbe9KkSW/Wz7Fjx7p27ZqTkzNp0iTSK6VJS0vbtWuXtnnw4MHLly/n0Vhjx47VzubLzs6uXbt2Hg0EAIBy9Ogh0dHSs6fcuycikpQkgwY9eSo2VtLSxNdXQkNl/nwD1ggAyFsEWECeMzIymjRp0vLlywsUKDB58uR+/frl5OS8Vg+xsTJu3OEHDx70799/woQJeVQn3lhMTMzs2bO1zeXLlx85ciSPxkpJSbl7967mWK1Wx8bG5tFAAAAoioODBATIwYPyySdSq5ZYWsr69U+esrOT77+Xjz6SoUMNWiIAIC8RYAF60q9fv02bNllYWKxcuXL48P89fPiqL7x2Tdq0kT/+GOLjE7po0aK8rBEAAEDRGjR4cjB3rnz/vdy+/ddT33xjkIoAAHpiYugCgPdIx44dd+7cOW5c0KpV3Y4fl5AQ+XMXwRe6d0/at5dLl6ROHfH1bWfCP1mlunbt2oYNGzTHly5dytOxxowZ8+OPP4rXpKXoAAAgAElEQVQIixgCAN5bLi7Sp488vTaDq6vBigEA6AEzsAC9atiw4dKls+3t5cgRadxYrlx52cnZ2dK5s0RFyYcfSkiIFCqkryrx+rKyshL/9ODBgzwdy9fXNyoqKioqKu9uVAQAQPnGjJFdu+TyZblxQ5o2lchIQxcEAMhLTOcA9K1CBYmIkPbt5cQJqVdPQkOlRo3nnKZWy4ABsmOH2NvLtm3i4KD3QvE6ypQpM3r0aM1xdHS0YYsBAOB9YGYmP/8srVrJ0qWyf7/UqyfffSfffy8FCxq6MgBAHmAGFmAAxYvLgQPSurWkpkrjxvLnnnJ/4+srq1eLlZVs3y7ly+u9RLy1zMxM3XaYmpp65eVz9gAAMJxr167NmjVL29y8efPBgwd1PsqZM3Lrlnz33ZNmy5YSGioLF8qYMaJSyZQpUrOmHD2q82EBAIZHgAUYRuHCEhQk3brJ/fvi5SXr1j3ZFlrj9m3p1Us++kjWrpWaNQ1XJV5N0aJFq1atqm26u7uLSJUqVXS46H5aWlqLFi2aNGnSvXv3Ro0aaR40NTX99ddfdTUEAABvIyMjQ7scpIiEhYWdPn1at0Pk5Ejv3tK+vdy48deD7dqJk5PMnCkHDoi7u5w7J/Xqibe35PEN/QAAfSPAAgzGzEzWrZOJE0WtlqgocXSUhIQnT7m5iY2NbNokcXEGLRGvpkqVKj/99JO2OXbs2Nu3byckJAwePFgnGdbt27fbtm0bHR1dpEiROnXqODk5aR43MjJq2bLl2/cPAEC+MHOmnDghpUrJc//3q19foqJk9GgxNhY/P6lZUyIi7uq9RgBAXiHAAl5GpVJpj9Vqtc43fTMykkmT5PRpqVxZypWTIUP+eio6WhYtkj17ZN063Y4JffD29l68eLGIDB48+D//+c/bdHXnzp2WLVtGRUW5ubnt3LnT7l+3rgQAwECuXr066k8HDhzQbecXLsj06WJkJH5+Urjw88+xsBBfXzl+XGrWlNu3VR4etby9ve89PcsdAJBvEWABL6RSqaysrLTNZcuWDRs2LC8GcncXEWnVStRq0d4QVrGiDB4sn3wiX3yRF2Mizw0cOHDp0qVGRkYjRoyYOnXqm3Vy9+7d1q1bHz9+vHz58nv37tXOvQIAQIGKFCnS+k9lypTRYc8qlXz9tWRlibf386dfPa1aNYmIkDFjdt27d8XPz69atWq7d+/WYTEAAIMgwAIU5OefZfTovxbDKlnyb3OykO/0798/ICCgQIECEyZMGDt27Ou+/P59tZdXpyNHjri4uOzdu7dEiRJ5USQAALpiZWXV4k+lSpUSkaCgoLS0tLfvee5cCQ+XDz6QH398pfMLFpQRI1pHRUXVqVPn0qVLLVu27NKlS0ZGxttXAgAwFAIsQEFcXeWLL2T69CdNIyMxNTVoQXhrPXr0WLVqVYECBebN85s16zU+wT98KF5eRpmZa8uVq7x79+6SJUvmXZEAAOSF69evd+vWzd3d3c/P7236uXRJJk0SEVm2TIoWfY0XVq5c+dChQz///LOlpWVgYGDlypV///13+fsaESqVSudrRAAA8gIBFvAyWVlZNf80XRss5aVx4yQ4WO7dE7VarlzRw4DIcz179ly7dm21ahfGjHEYPfqVXpKVJV5e8scfkpJiv2PHibJly+ZxjQAAvK1ixYr16NFD22zSpEn16tWbNGly69Ytb2/vDh06pKSkvEG3KpX07SsPHkifPtK27Wu/3MTEZNiwYZGRkfXr109NTf3ss89GjBjR9qmO+vTp87///e8NCgMA6BkBFvAy5ubmUX/6/vvv82IIlUrOn/+raWEhc+fKw4cybpxUry66Xv8UhtG1a9cffnAwM5PZs+Wbb+TlP/Q+fiydO8vu3eLgILt2iYuLib7KBADgzTk6Oo4cOVLb9PLy6tix4/bt2zdt2lSsWLHg4OCKFSv6+fm97nSnZcse7t8vTk4yZ86b1+bu7n7w4MGlS5eWKVOmcePGb94RAMBwCLCA15Odna3bDr/9VmrXFmtr0S7z3aaN3Lghycly+7a0bv3Xsu7I1zw85PffxdxcliwRb2956t6Fv8nOli5dJCRE7O1l716pUEG/VQIAoGudO3c+e/bsZ599dufOHW9v76ZNm8bHx7/ia69cuTJhQtkmTf6zcKHa1vatyjAyMhowYEBMTIyNjc1bdQQAMBACLOA1qNXqrl27DhkyRPWi+OE1/fST/Oc/kpMjVlZiYfHX43Z2Ehgo334rWVnSubP89JNORoOBtW0rmzeLhYUsWya9eklu7rMn5ObKF19IUJAUKya7d0ulSoaoEtCpM2fODB06VNucMWPGrl27DFgPAINwcnL69ddfN23aZG9vf+DAgWrVqvn6+r7Kpylvb++0tOtOTkc++8xIJ5UULFhQRCIiIrRrRISGhuqkZwBAXiPAAl7I2Ng4JiZG2+zRo0fHjh23bdv23//+t0uXLllZWW/Z/8aNMmaMGBnJ8uXSosWzzxoZyezZ8vPPYmQko0bJsGEvnLODfKR1awkJkUKFZO1a6dv32XsJjY3F2VmsrWX7dqlaVZfjnj9/PjU1Vdvcs2ePLnsHXuzu3bvR0dHaZnx8/M2bNw1YDwAD6ty5c0xMzIABAzIzM8eOHdu4ceOnP2j904oVK3bs2FGsWLF58+bptpJ69epp14ho3769bjsHAOQRAizgZZ7e+q1QoULNmzf/448/7Ozsfv3112bNmr3N17B9+6R3b1GpZM4c6dnzhacNGyb+/mJqKvPnS+/eouv7F2EAzZvL9u1SpIg4OUmdOnL06JPHx42TQ4dk7lwZOFBq19bxoD///PPT0148PDx0PAAAAK/AxsZm6dKlISEhH3zwQXh4eI0aNXx9fXP/OSdZJDU1ddSoUSKyYMECR0dHvVcKAFAcAizg9Xz88cf79+8vVarU4cOHmzRpkpiY+AadnD0rHTvKo0fy7bfyf//3Lyd/+aWEhIiVlUREPOra9at79+69Sd1QkoYN5f/Zu/N4KLc3AODPLNaiEiKVolWR0qK0SiTa02JLG9p0uy203KvurV/atUer2666JKUIWVotLZRUpAXZ931mzu+Pk8lt0Zh53xlyvh+f+5nlnfMcczXL8z7nOQkJsHQppKXBkiWf1xK+fQufPsGWLRAVBf/7n6SnSBDUiY+PH10rKChI0tMhCELyLCwsEhMTHR0dKysr3dzchg0bVrdUE1u8eHFBQYGlpeXs2bMlMkmCIAiisSEJLIJoMB0dnQcPHujr67948cLQ0PDJkycNevjHjzB+PBQWwsyZsG2bQA8xNYXwcKSgMMPP7+SoUaM+ffokzLyJxqRTp8//NTCA/fs/3ygnB+vXw6BBsG4d9RGTk5Mja1E/OkH8WN++ff1rmXy7XpogiGapdevWXl5eQUFB+KSgvr6+m5tbdXU1vvfs2bP+/v6tWrU6fPgw5aENDQ3Pnj3Lv+rp6UkKkwmCIJoEksAiCGGoq6tHRkaamppmZmaOGDEiODhYwAcWFcH48fDhA4waBT4+wBT4n6CBAcPPb2+PHj3i4+OHDBny8uVLIadONDJ//w2envDx45dbnJxoCRQbG/tvLap2ISAIQbBYrFa1pKSkJD0dgiAaETMzM7zVA5fL3bZt28CBA2NjY3Nzc3///XcA2LNnT91mDlSRkZFRVlbmX1VSUpKru5MOQRAE0ViRBBZBCElBQeHatWuzZ88uKSmZMGHC+fPnf/qQioqK+fPn5ee/09MDf3+QkWlYxM6dO9+7d8/IyCgtLc3IyCg6OlrIqRONiYoKrF0Lq1d/uaVnT1oC2djYeNZiCp46JQiCIAg6KSoq7t279/bt21paWs+ePRs6dOiIESOys7PHjBnj4OAg6dkRBEEQjQj5DkMQwpOWlj579uyaNWuqq6ttbGy2b99ez8FcLtfGxubKlZNqarOCgqBVK2EiKikp3b59e/r06fn5+WPHjr18+bKQUycak4UL4e1biIuT9DwIggY9evTAO47hq05OTkOHDpXslAiCaIRGjx6dmJjo6urK5XJTU1NZLNayZcsYDIak50UQBEE0IiSBRRAiYTAY27Zt8/T0ZDAYrq6uy5cv/9HirN9//93Pz69Vq1YnT3q3by98RFlZ2fPnzy9cuLCystLa2jowMDAnJwffxeVyw8LChB+aEKPTp6Gs7PNlJhMOHYLUVEAI9uyBoiIqA128eHH79u3t2rVTVFTk39i1a1cqYxDEjykrK1+6dKlNmzZXr14FgMGDB2tqakp6UgRBNEZycnJr1qxp06ZNVVUVl8udNm3aqlWrKioqJD0vgiAIorFgIIQkPQeC+BVcuXLF1ta2srJy2rRpZ86ckZWVrXvv//73v/Xr18vKyoaEhAwbNoySiJs2bZKTk4uJiZkzZw5uPlpcXNytW7esrCxKxifos3MnrF4NRkbw559gavr5xtBQCAmBbdtgwAC4dQuUlCgI9O+//86cOZPD4URGRg4fPpyCEQmigRBCqqqqubm5KSkpWlpakp4OQRCNmr29/enTp4cPHz569OitW7fW1NRoaWkdPXrU2NhY0lMjCIIgJI9UYBEENaZNm3bjxo1WrVpduXJl/PjxRXWqaM6dO7dhwwYmk3nmzBmqslcA4O7uvmbNGqpGI8Rm/35YvRoYDJgz50v2CgDGjIElS6BbN4iNhTFjoLauTng3b960trbmcDirVq0i2StCUhISEnJzczt27EiyVwRB1C8oKOj06dPy8vInTpzYtGlTTExM//79U1NTTUxMnJycSkpKJD1BgiAIQsJIAosgKDN69Ojo6OgOHTqEh4cPGzbs48ePABAWFjZ37lyE0J49e6ZNm0ZH3ISEhPDw8PDw8KioKDrGJyh04gQsXw4MBhw6BAsXfn1vx44QGQm9e8OTJzByJGRkCB8oJCRkypQpVVVVK1as2LFjhyhzJghRhIeHAwCpniCIJm3jxo38y0+fPvXz86M8RHFxsZOTEwBs3rwZr3Pv27fvw4cPPTw8pKWlvb29dXV1Bd/0mSAIgvglkQQW0Yw8f/68rLbtUGVlZUJCAuUh+vTp8+DBAz09vcTERENDwwsXLkyaNKm6unrdunUuLi6Uh8MePXoUGBgYGBh48+ZNmkIQlDh16nPSav9+cHb+/jFqahAWBrq6kJQExsaQni5MoKioqClTplRWVrq4uOzevVv4GROEyHACa/To0ZKeyK8pOzt727Zt/KtXr16NjIyU4HyIX1XdP7OEhITr169THmL16tUfPnwYPHhw3c9LbDbb1dU1NjZ20KBB7969MzMzmzFjRn5+PuXRCYIgiCaBJLCIZsTR0fHly5f4clpamp2dHR1RNDQ0wsPDjYyM0tPTbWxsSktL7e3tN2/eTEcsbP78+bt27dq1a9eWLVvoi0KIyNcXFiwAHg88PGDJkvqOVFWFiAgYMACSk2HYMHj7tmGB7t69O378+LKysvnz53t6eooyZ6IpysvLq6qqwpd5PN6nT58kOBkej4fzKaNGjZLgNH5h+fn558+f51+Njo5+9uyZBOdDEMIJDw8/evSojIzM8ePHWSzWV/f26dPn7t27np6eLVq0uHTpUu/evekoASMIgiAaP5LAIgjqKSkp+fr6KigoyMvLM5nMcePGkX2gm7krV67s3r1JSgr+9z8QpHFZmzYQEgKDBkFaGoweDSkpggZ68OCBubl5aWmpg4ODt7c3+cNrhhwcHPg1OLm5uYMGDZLgZJ48eVJQUKClpUV2HiSIpu7vWv7+/tSOXF5evnDhQoTQn3/+2bt37+8ew2azly9f/vTp01GjRn369Gnq1KkzZszIEb1bJEEQBNGksCU9AYIQq1evXuEze2lpafRFqaiomD59eklJiYqKSmlpqZ2dXUFBweLFi+mIpaGh0bJlS3yZxWJ169aNjiiEKPz8/GbPnl1TU7N7t/6KFZMEfFTr1nDrFowbBw8fgoPDi1OnZLS1tet/yOPHj8ePH19SUjJjxoxjx44xmeQUBSFhZP2gGGRmZvI39IiIiLC3t5fsfIhfFT+1lJeXV1paSuHIa9euTUlJ6du37+rVq+s/UltbOyws7OjRoytXrrx06VJERMSOHTvI3zxBEETzQRJYRPNy4cKFtm3bAkDdXQKpxeVyra2t79+/36VLl3v37l28eHHFihVLlixJTk729PSkvCKm7hqxFi1aREdHUzs+IaJbt27h7NXKlSsFz15hrVtDcDDMnZsSHT1m5EhWaGhojx49fnTw06dPx44dW1BQMH369LNnz367BINoPoqLi3NzcwFA4p1iSAJLDBQUFExrNzSl9dwM0cxNnToVXygvL79z505cXFzbtm07d+4s4rAPHjw4ePAgm80+ceKElJTUT49nMBiOjo6mpqYLFy68ffv2nDlzLl26dOTIEQ0NDRFnQhAEQTR+5Py8kCIiIt6/f48vc7ncuh0oiMbszz//PHHixIkTJ+hrF+Xi4uLv76+srBwUFKSmprZ8+fJTp05JSUnt27dvzpw5NTU1NMUlGqGQkJDJkydXVVX99ttvO3fuFGIERUU4fVpdT69Penr6yJEjf7TzwMuXL83MzPLy8qZMmXLu3Dk2m5ycaNa2bt1qbW1tbW3t/KPNAsSCy+XevXsXSAMsmrVs2dKkFlmqSYgHh8OZNWtW7969t23bxuPxhB6nqqpq/vz5XC537dq1/fv3F/yBnTt3Dg4O9vHxUVJSCgwM7NOnj7e3t9DTIAiCIJoKksAS0pEjR+Lj4/HlqqqqpUuXSnY+hHCqq6szMjIoHNDd3f3QoUNycnJXr17lF8vY29vfuHFDUVHx9OnT5ubmxcXFFEYkGq3o6Gi8FeCyZcv27Nkj9Djy8vIBAQGmpqZZWVljxox5+vTpVwe8evXK2Ng4Kytr3Lhx58+fF+QMNvFr27p1a3BwcHBwsK+vrwSnERcXV1hY2L17d1IZQRBNnYODA/9y165dBw0aNGDAgPLycjc3t1GjRr1+/Vq4Yd3d3V+8eNGzZ89169Y19LEMBsPe3v7p06fjx48vLCx0cnJydnauWxF24MABd3d34SZGEARBNE4kgUU0I0pKSvzv9mw2u23btgsXLhwwYMCTJ08oGf/YsWN//fUXi8U6d+7c0KFD695lYmISFRWloaERGho6fPjw9PR0SiISjVZubq6FhUVZWZmzs/PevXtFHE1OTu7atWuTJk3KyckZNWrUo0eP+He9efNm9OjRmZmZY8eO9fPzk5GRETFWXUePHr158yb/6owZM0Q50040N2T9oBgoKSnZ2tryr44YMYIUYRF0OHz4MP+yoaHh4sWLz58/HxgY2KFDh6ioKD09vW3btnG53AaN+fjx4927dzOZzOPHj8vKygo3sQ4dOly/ft3X11dVVXXKlCnl5eX8u2pqaqqrq4UbliAIgmicSAJLeFFRUefPnz9//vylS5ckPRdCINeuXdPT08OXu3btGhAQkJaWlpmZOXr06IiICBEHv379+qJFiwBg3759kydP/vYAPT29qKioHj16PHv2bPjw4cnJySJGJBoVJyenV69e4cvv3r1btWrVoUOHFi5cePDgQUoan0lLS/v6+k6dOrWwsNDU1PTBgwcA8P79+7Fjx2ZkZIwZM+bq1atCfwH4kefPn797945/NSgoiCSw6BMeHs5/erOzs3+0XFQIERERTk5ODf1uKTqSwBIDVVXVVatW4ctVVVUnTpywtbXNy8uT7KyIZsLCwiIxMdHR0bGqqsrNzW3AgAGPHz8W8LEcDmf+/Pm4QeRX5/yEYGVllZqaKvo4BEEQRCNHEljCy83N/fDhw4cPHz5+/CjpuRDCaNGiRXBw8KxZswoLC83MzC5cuCD0UDExMTNnzuRwOJs2bapnt0Hc1t3IyOjt27dDhw7F3WGIX0NCQgJ/V6by8vKnT5/a2Nh4e3tTuBUgzmHZ2NgUFRWZmJhcvHhx1KhRaWlpRkZG/v7+cnJyVAUiJGLatGlVVVX48t27d7du3SrcOH5+fiYmJviyqqpqYmLi7Nmzvb29bWxsOBwONXMVAIfDuXfvHoPBGDlypNiCNnMyMjKVlZXFxcW7du2S9FyI5qJVq1ZeXl5BQUGdOnV68uTJ4MGD3dzcBKl72rx58+PHj7t3775p0yZKZtKiRQsAKCgo6F+L/EMgCIL49ZAElvCmTJmyZs2aNWvWrFixQpRx7ty5w7+cmZnJL+IgxEBGRubcuXOrV6+uqqqytrbesWOHEIOkpKRYWlqWlZUtWLDgzz//rP9gJSWl4OBgS0vL/Px8U1PTwMBAoSZONFMsFuvUqVPW1tZlZWXW1tY4ExoUFNSyZUuaInp7e0+vVVlZSVMUgkJsNrtu0Z+iomJAQICSktLFixenTJnCz5HR7dGjRyUlJb169VJTUxNPRAIANm/ezGAw9u3bl52dLem5EM2ImZlZUlKSq6srl8vdtm3bgAEDYmNj6zk+ISFh69atTCbz6NGj1J59adOmTXytlStXUjgyQRAE0Rg04QRWRQX89deXqxERUKdVS1Nibm7Ov3zjxo19+/ZJcDLNEIPB2L59u6enJ4PBWLNmzfLlyxu0SConJ8fc3Dw7O9vCwqJuh4h6yMvL+/v7Ozk5lZeXT5482cvLS9i5E42Ls7OzsbGxsbHx3Llz6YvCZrN37tzZunVrOTk5Fou1evVqBQUF+sJNnTp1ey1qG2wR37p7925kZGRkZOSLFy8oHHbAgAEhISFt27YNDAzEGwtQOPiPkPWDEmFgYGBubl5WVrZ7924Kh33z5k1YWBj/6rVr1zIzMykcn/gFyMvLe3h4RERE9OjRIyEhYciQIW5ubt/NmOPFg9XV1YsXLx4xYoT4p0oQBEE0XU04gVVZCXXTBTExEB0tjrhxcXGPHj3S0dFRVlbGt7BYLCMjI3HEJmizfPnyixcvysrK7tu3b+bMmQJ+wSspKRk3btzr168HDhx48eJFNpstYDgWi3XkyBEPDw8ul+vs7Ozm5ibC3InGYseOHVeuXLly5YroXdvrkZOTY2pqWlhYKCsry+VyZ8+efePGDfrCKSsra9WipJkXUY+rV6/++++///77L+5xRqH+/fvfvn1bRUUlKCho8uTJFRUV1I7/LZLAkpS//vqLwWAcOHCAwiKsuLi4f/75h391//79b968oWpw4lcybNiwx48fu7q6IoS2bdvWp0+fyMjIr47ZuXNnTEyMpqbm//73P4lMkiAIgmi6mnACSyJSU1MtLCyMjY3Hjx8/bNgwfKOMjExAQIDQY/J4vHu1UlJSKJop0WDTp0+/fv16q1atLl++bGFhUVRUVP/xNTU1VlZW8fHx2tragYGBuPlCg7i6up48eZLNZm/btm3u3LnibE9D0EFBQaFNmzZt2rRRVFSkKURhYeG4ceMSExN1dXWTkpKWL19eWVk5ZcoUPz8/agNVVVXl5ORQOybxU7ga1NPTc968eZQPrq+vHxER0b59+1u3bo0bN47fso0O1dXV9+/fJw2wJMLAwACvat+5c6ek50I0R3Jych4eHtHR0To6OnifXCcnJ/4LTnJyMs6xenl5UV4+3KJFi7r5Mnt7+99++43aEARBEIRkNe0EVmkpbNjw+UcM6wdzc3PHjx+flZU1ePBgXV1dqoblcrnnaj18+JCqYQkhGBsbR0dHd+jQISwsbNiwYfW050cIOTo63rp1C1c0qKqqChfRwcHh+vXrCgoKp06dsrCwKCkpEXbuxK+vqKjI1NQ0Pj6+e/fu+G/P09Nz3bp11dXVVlZWZ8+epSpQTU3NzJkzhw8fPmLECH6mHgB27tzJYrGoikKIX69evcLCwjQ0NCIjI83NzYuLi2kK9ODBg/Lycl1dXX6pMiFOmzZtYjAYBw8ezMrKomrM169fH6+Vnp5O1bDEr8rQ0PDJkyceHh5sNtvb27tv375hYWE8Hm/BggUVFRXz5883MzOjPCiTyezZsyf/atu2bdu1a0d5FIIgCEKCmnYCS0oKhg79/NO5M72xKioqJk6cmJycbGBgcPXqVWlpaapGlpKSOlDL2tqaqmEJ4fTp0ycqKqpnz56JiYnDhg17+fLldw9bu3btqVOnFBQUbt682a1bN1EimpqaBgcHKysrBwcHHzx48Pbt2/y7vLy8yG7oTYW7u3uXLl3wZQ0NjS1btlA7fnFxsZmZWUxMTNeuXcPDw9XV1fHtW7Zs+fPPP7lc7pw5c+qu8REah8Oxtra+evVqbm5ut27devfuzb/LycmJrCKkj7a2Nn/PypYtW9LU+7xHjx5RUVFdunSJjo4eM2ZMfn4+teMXFRX9+++/v//+OwDo6elROzghoH79+k2cOLG8vHz79u1UjcnlcitrNahTJNFsSUlJubq6xsTEGBgYpKammpiYDB8+PDo6Wl1dncK/TIIgCKJ5QU1Wfj5SU/tydccOtH49XbE4HM7kyZMBoEuXLpmZmdQOLisry7987NixJUuWUDs+IYT8/HxceNKmTZvIyMiv7sXN2qWkpG7evElVxOTk5D179uzbt2/16tX8G/X09F6+fElVCKLpKisrw0uxOnXq9Pbt228P8PDwAAAWi3XixAlRAnE4HBsbGwBo1apVTEyMKEMRDRUTE7No0aLg4GAxxEpLS9PW1gaA/v375+bmij5gYmKih4eHiYkJ/+wOXk77+PFj0QcnhPD48WMGgyErK5ueni70ICUlJZ6enqNGjTp//vycOXP4t48dO/bbd0aC+JGamhoPDw9paWmco9+wYYOkZ0QQBEE0VU27Aks8EEJOTk7+/v7KyspBQUGUnxXvXKd4TEFBgSy4aAzatGlz+/ZtKyurgoKCsWPHXrp0iX9XQEDA0qVLGQyGt7c3hQXw3bt3J50aiO+qqKiwtLSMiIjo2LHjnTt3On+v3NTV1XXbtm1cLnf+/PkHDx4ULhBCaNGiRWfPnlVUVAwODh4wYIBI8yYa6Pr164cPHzYkdooAACAASURBVL5+/boYYmlqaoaHh3ft2jU+Pt7ExES4fmd5eXkXLlxwcHBQU1Pr06ePm5vb7du3EUIjR47cvHmzgYFBQUHB6NGjydJ4idDX1588eXJlZeWOHTuEeHhpaamHh0fnzp1/++23O3fuPHv2jPIZEs0Hm81es2ZNv379cO3eli1b5s2bV1hYKOl5EQRBEE2QhBNoIigvR2vXfrl6+za6do2WQH/++ScAyMnJ3bt3j5YAtaKiohYsWPDo0SNaoxCC43A4ixYtAgAWi3Xw4EGE0P379+Xl5QHAw8ODjoj79u0bOXKkRy11dXVSgdXMVVVVjR8/HgA0NDTevHlT/8G7du1iMBgMBsPT07OhgXg8nrOzMwDIy8tHREQIO19CeLjIzt/fX2wRMzMz8RLRXr16ZWRkCPIQLpcbGxuLi62kpKT4nyXatWtnZ2fn6+tbUFCAj6yqqpo6dSoAtGrViu53T+K7EhISmEymrKzsx48fBX9UaWmpp6cn/1zd0KFDAwICIiMjd+/ezT9m/fr1iYmJNEyZ+GUdOXIEAJSVlXfu3Ik3vVFTU7ty5Yqk50UQBEE0MU04gYUQGjcO3b79+fLJk8jPj/oQ3t7eOH/hR8fo/7Vq1SoAWLFiBd2Bfg13796tuzjl6NGjVVVVdATy9PTEfX9sbW2VlJQAwNnZmY5ACKF9+/ZNmDDhfK1OnTqRBFZzVlVVZWlpCQCqqqrPnz8X5CFHjhzBazS2bNkieCAej7dkyRKcvQoLCxN2voTwKioqZGVlmUxmfn6+OONmZWXhPUl69OhRT5ojOzvb19fX0dGR33wNANhstpGRkYeHR2xsLI/H+/ZRHA7H1tYWAFq0aBEaGkrn70F837Rp0wDAxcVFkIPLyso8PT35/4uHDBkSEBBA9wyJ5iA9Pb1169YA4OvrixDCWxPiPzMrK6vs7GxJT5AgCIJoMpp2AkteHunqoooKhBDasAHt3Uvx+IGBgWw2GwBw9Q3dHjx4AAAdOnT47jcBycqpyXlW/kzSs/gPNze3uieEVVRUioqKaIp14sQJ/JcAAFOmTOFwODQFIj2wCL7q6upJkyYBgIqKSoOKHby9vXEOa9OmTQI+ZM2aNQAgIyNz48YNoSZLiCo0NBQA+vfvL/7Q+fn5eLloly5dUlNT+bdzOJzY2Fh3d3cDAwN+d3kA0NLScnR09PX1FeQll8PhzJkzB+dGQ0JC6Pw9iO9ITEzERVgfPnyo57DKykovLy9+6srQ0JCkrpqJM2fOZGVl4cu5ubk+Pj50RJk4cSIATJw4kX8Lj8fz8vJSUFAAgDZt2nh5edERlyAIgvj1NO0ElpISWr8e/fEHQjQksB49eoSLnAX/EigiHo+nqakJAPfv3xdPxHokViTOSp3VP6n/jNQZcWVx1wuv2761lfSk/kOcCazCwsLOnTuzWCwAMDMzKykpoSkQSWARGIfDmTVrFgC0bt06Li6uoQ8/e/YsTrm6urr+9OC1a9cCgLS09DWalmETAtiwYQMArFy5UiLRCwoKBg0aBACampoPHjzw8fGxsrLCFROYnJyciYmJh4eHgJWAdfF4vMWLF+MMKUmLiJ+VlRUALF269Lv3VlVVeXl5tW/fHv+PHjx4MPl/1KwYGhrGx8fjy8+fP+/Xrx/lIXx8fPB72bc1nm/fvh07diz+27OwsKg/zUoQBEEQ6BdIYJWWoq5dUVLS5wTWrVsoMRGJXh/z5s0bVVVVAFiwYAEVMxXUihUrJPgdhi+jOqPds3YBhQGVvMqIkojDOYcbZwJrxowZXrUUFBRoSmBVVVWZmJjg8gQVFRUAGDBgwKdPn+iIFRwcfOHCBf7VdevWUb7rJdH48RdeibIV4IULF3AOa82aNfUc9scffwCAlJTU1atXhQvU5CRWJPrk+QQWBpZySws5hWNejZH0jBBCyMjICAACAwMlNYGCgoLBgwfjJfP8vFXv3r1XrlwZEhJSWVkpyuA8Hm/ZsmU4TyqG9fhEXc+fP2cymTIyMl9lB75KXfXt29fX17cRFoATtKI7gZWZmYl7L/zzzz8/OsbX1xcf07p1ay8vL/JHSBAEQdSjySewEEKXL6OxY9GGDcjTE7VtiwBQy5bIyAi5uCAfH5SYiBr6Vpidnd2tWzd8OqimpoaOmf/I3bt3AaBjx46Sff/+X+b/Fr1fVPeWxpnAmj59+uFaNCWweDyenZ0dALRv3z4tLS01NbV79+44mZWcnEx5OILg8XgLFy4EAEVFxQcPHogy1KVLl3Cb7d9///27Lyl4ezIWi3X+/HlRAjUhmzI29X3Rd9unbS4fXIYlD8utye2a2FXSk0JlZWXS0tIsFovfAV0iMjMzWSxWixYtJk+e7O3t/f79ewoH5/F4eKNVaWlp+jo3p6enb9iwgX/13LlzZN0iQmjmzJkAsHjxYnwVp640NDRw6kpPT4+krpotQ0PDNWvW7N27d+/evevWraM8gYW7sJmbm9d/WEZGxpQpU/AfpJmZ2bt376idBkEQBPHL+BUSWAihceNQv35o+3Y0fTrS1EQA//lp2xaNG4f++ANdu1bz03qW4uLi/v37A8DAgQNLS0tp/x3+i8fjderUCQAkuxfhgncLDmb/p+1X40xgiWEJIa6JU1RU5DeMz83NHTp0KAC0bdv27t27lEckmjMej4c3vpSXl79z547oAwYGBsrKyuKdB7hcbt279uzZg7NXZ86cET1QXXl5eYWFhfyraWlpjeS78evK16pPVYs4n18oKnmVeTV5jSGBdevWLQAYNGiQZKdx8+ZNvIiMvhB4pSSLxTp9+jQd47948aLuN/CVK1ceOHCAjkBNy4sXL5hMprS09KtXr7y8vDp06IAzBbq6uiR11cwZGhpu2rTp5MmTJ0+e3LJlC7UJrIsXL+JPUAJmw319fZWVlfE7oIeHx1fvWQRBEASBEPrSlrVpQeg/Vw8cgKQkkJGBS5cgLQ0KCyEqCjw8wNIS2rWDvDy4eRP+/hvWratQV1dv3779hAkTNm7ceO3atdzc3Lrj1NTUWFlZxcfHa2trBwYG4h5Y4sRgMPA5qMuXL4s5dF0tmS3LeeUSnIBwuFxuQEAAhQPu3Llzz5490tLSly9f1tfXxze2bds2ODjYwsIiLy/P1NT0+vXrFEYkmptXr16VlZXhy9XV1Y8ePXrw4IG8vPz169dHjhwp+vgWFhZ+fn6ysrJHjhxxdnbm8Xj49n379q1YsYLBYBw5csTGxkb0QHXt2LHjxIkT/Kv4ZAC1IYQTUx4zUmGkIksRX5VhyEh2Pnzh4eEAwN+W6xeext9//+3u7s7lch0cHHBnHEIMevXqZWVlVV1d3b9/fycnp48fP+rr6/v7+z99+tTKygpvsysZXC68eQMPHkBR0edb3r+HwsIvBzx7JpF5NSsTJkxwcHBwcHCYPHkyAGRlZSUkJIg+bF5enouLCwDs2LGjY8eOgjzEysrq+fPndnZ25eXlbm5uI0eOfPXqlegzIQiCIH4pks6gCaO4GA0Zgi5eRKdOfbnx1i2UkPD949PS0OXLaM0atGBBvKKiYt1fn8Fg9OjRw9bWdu/evXfv3sWLxVRUVF69eiWe3+VbUVFRANClSxcJnhQ9n39+ZPLIurcIX4EVH4/MzZG+PhowALm7Iw4HpacjE5MvB+zZg7y9hRjYx8fH39+ff9XW1nbBggUA4OrqSslTd+HCBSaTyWAwvtu4gcPhODo6AgCLxSK75xBCMzY2jo6Oxpffvn3bo0eP/Pz8qKgoaqOEh4e3bNkSAKytrWtqao4dO8ZgMBgMxuHDh6kNhH1bHVlcXExHoIY6mnPU/q193VtwBdbbqrdn885KalYIIdx86ubNmxKcA0II93G/desW3YE8PDwAgMlkHj9+nMJhuVzuixcv2rZtO7+Wrq4uqcCqrq728fHp1KkTm81mMpndu3f38fFpFLUt6elITw9NmoScnVHXrp834rG3Rxcvfj6gpga1bCnBCTYH3/bAmj59upSUlKura1VVlSgjW1tbA8Do0aOF+EgWEBCAl7jKycl5eHjQt/UzQRAE0eQ0vQRWVRUaOxYBIB0dVF0tzAjp6em+vr4uLi5GRkZycnJ181lycnItW7YUYs8vCnG5XNxUNTY2VvzRCzmFRZwiLuKavzaf8GbCkZwj7hnuB7IPCJnAKilBmpooLAwhhEpLkYUF2rULpaWhHj2+HPPHH2j7dkomf/r0aWlpaQCwtbUV8YNXeHi4jIwMANT9Hv4t/DUMBNvrjSC+9W0Ci6ZAkZGReMPyQYMG4cwsfV/s3dzc3N3dP9Zq27ZtI0lghRaHGiQZ1L0lryZPK1FLK1GLEcc4lH1IIrMqLi6WkpJis9mSfZaKi4vZbLaUlJR41s5v374dn0Pat2+fiENlZWX5+vra2dkpKSnduXOnZ8+esbVsbW2bcwKrurr66NGjnTt3xu9TeFtJR0dHSc+rlr092rHj8+W8PKShgVJShEtgXbp0qe6bta2tbUpKCsWz/UWtX7/+7du3+PKHDx9WrVq1ZMkSXJSnp6cn9AfRwMBAAJCXl3/z5o1wI+Tm5uLNTADA2NjY0NAwIyMD33Xv3r3Zs2cLNyxBEATR1DWxBBaPh+bMQQBIRQW9fk3BgNXV1XFxcYcPH543b17Hjh1ZLJaFhQUF44pm6dKlAODm5ibmuFW8KpNXJn1e9PlQ/YGHeKHFoQezD/rm+xZxitKr06NLohs84pkzaNasL1cTE1H37vQlsBBCoaGhuMjO2NhY6JZYCQkJ+IO+INtBnjhxAu/1NnfuXDG3/Cd+AcbGxqdPn05ISEhISLh16xZ9CSyEUFRUlJycHG7rvnPnTvoCubm56ejoWNSSlpZuJAksDo/T50WfPVl7qnhVZdyyR2WPcAXW4ZzDjDgGI46xJ2uP+GeFlyEPHTpU/KHrwl84jYyMxBbx0KFDuBJwz54GP+1VVVVhYWFr1qzp27dv3bNQu3btIj2wUG3VVdeuXfHToqOj4+Pjk5SUhHOUqampkp4gQgghVVWUk/PlqqMj8vZG9vZozx6UlISSklBiooAJrEOHDq1YsYJ/1cDAIDExkfL5Nh/R0dE9evQAADab7eLiUlZW1qCHFxYW4j5re3FVnQhu3LjRsWPHHTt2aGtr87fRvHPnjpmZmYgjEwRBEE1UE0tgrVmDAJCCAqqtd6YSXvOvrKws8TTEnTt3AEBLS0ucQXmIZ/vWFuKg/bP2aVVp1Az699+ozoZQqLoaSUujt2+RjAzS1//8o6ZGYQILIfTs2TNcea6rq/vx48eGPvzDhw+4WcPMmTMFXGRx9epVeXl5AJg4cWJDP+cRzZyxsfG4cePs7Ozs7OymTp1KawKLvyoWACZPnixilWI96F1CyOOhAwfQhAlo1Ci0cuXnL8Dr16MnTz4fkJeH7Ox+9Oh3Ve8c0hz6J/U3fGm47dO2Ik7R9JTpCCHvHG9mHBPi4O/MvymbqmBWrVoFAOvXrxdz3K+sXLkSAOpu4ScGXl5eTCYTADZv3izI8ZmZmT4+PlZWVq1ateInreTl5U1MTDw8PF68eEGauHO5XF9fX7yTMgD06tXLx8eHvwIL90lYsGCBZCeJEEJcLmKzUd2lYWvXoi1bkL09MjJCs2ej2bPRrFm/XgLrVeWrcm65pGfxc+Xl5a6uriwWCwC0tbUbtKnI/PnzAcDQ0JCSpX9FRUUcDocksAiCIAisKSWwDh9GAEhKCtHXJ6RXr14AcPv2bboCCIbL5aqrqwMAf+c7MVjxYQXEgeITxSflT35+tIAOHUJLl365mpWF1NRorcDC3r5927NnTwDo3LlzUlKS4A8sLCzU1dUFgFGjRlVWVgr+wIcPH6qoqOD1WdnZ2Q2fMtFMiW0J4b///otrrxYvXoy3eTI3Ny8vp+V7FL0JrO3b0bhx6O1bVFiINm9GQ4ciHg+Zm39eqowQyshAXboIMfCx3GM4h+X6Uawrgg0MDBrD+w7efjc0NFTMcY8dO4ZzWBs3bvzuARUVFSEhIa6urviJ4tPS0nJxcQkJCan7Wp2Tk+Ndp6liSEhITEwM7b9D44BTV927d+c/P15eXl9lEF6/fo2LsBrFCrvOnVHdacycic6eFW4J4aFDh9q3bz+0VosWLRpPAutC/oWZqTMnp0z2zPLk8Dgmr0ziyiTZp6JB4uPj8Q42DAbD0dGxpKTkpw8JDQ1lMBgyMjLPnz+ncCba2tq9e/fW19fX19fv2rUrSWARBEE0W00mgXX1KmKxEIPxn8btlPvjjz8AwNnZmcYYglm8eLE4z8nv+LQD4kA6XjqkOITKcZ8/R1paqKLi89UDB5CNjRgSWAihvLy8YcOGAYCSkpKALbErKirwQ/r06VNQUNDQiG/evMHrNbS1tV9TssCVaAbEk8AKCgrCPd1WrVqFEHr+/LmamhpO1AryhURw8fHxx48fX7t2bd1FYaqqqlRGUVVFtefhEULIwABFR1OSwEIInc8/z45nizOHVVhYyGKxpKWlJVu8WVBQwGKxZGRkaMpp1u/cuXN4IXbdZoIpKSleXl5WVla4dxvWsmVLS0tLLy+v9+/fi3+ejRZOXeE1XwDQpUsXLy+vH9WSz5kzBwDmzZsn5kl+x8aNyN4e4XnGxqKOHVFRkdAJrGXLlpXX6t+/fyNJYHlmeRq+NIwvi0+pTFn+YfnrytcCJbBCQlDd85e7diEeD3E46OpVtHEj8vREDTkzJ6Lq6moPDw/cYLRLly71p9pLS0u1tLQAwMPDg9ppkAosgiAIAhM1gcXhcOqe36NpTUpEBJKVRQBo2zY6hv/i6dOnAKCioiLxVYRhYWEA0L17dzHEupB/gRnHZMQx/sn7znZ7otqwAenro7/+Qk5OqG9f9O6deBJYCKGKiorp06cDgKys7KVLl+o/mMvlTps2DQA6dOgg9FejzMxMXMWgpqYm2a0AiKZiypQpDx8+xJffv39vaGhIeYjg4GBZWVkAqLvEJikpCW8WMXz4cKrKo549e6asrMxgMK5fv07JgN+Rn4/atPnPLXPnouPHkbk5GjIEWVoiS0s0dqzQCSyE0MX8i1LxUhAHqz6uEnW2Arh69SoAjBgxQgyx6hEQEAQAI0eOlNQELl68iCsEraysFi1a1KVLF37SislkDhgwYMOGDdHR0WQzsq/g1BWuOMZFx/WkrrA3b96w2WwWi5WcnCy2eX5fRQVyckK6umjAADR0KMK1cs7OyM/v8wEcDtLQEGSkRruEUOOZRkL5f3bIFiiBtXw5OnLky9WWLVFNDbKxQdOmIX9/5O2NNDVReDj10/2xp0+fDhgwgF+K9aMeo0uWLAGAfv36VQu3y9KPkQQWQRAEgYmawNqyZcumTZv4V7W0tNLT00Uc8yuJic/79EkF+M9aNPrgD4Jh/JP5EsLhcFRVVQHg6dOntAYKLw6XiZeBONidVd92eyJJSUH//osiIlBKCiouRhUV6N69/9ybRlHLrW9wOBxnZ2cAYLFYhw8frudIFxcXAGjVqtWzZ89EiVhSUjJu3DhcKRAUFCTKUAQhusjIyBYtWgCAi4vLV3clJyfjPrtGRkZC73hQdzRc1TVu3LgGLb9tmMpKJC+P6m7KPnMmungRmZsjX1/04QP68AHFxYmSwEIIXSu8hl8VF71fxEMN3gC+QX777TcAcHd3pzWKANNA7du/37OH3reb+l26dInNZrdr1w7nYpSVla2srLy8vCj/UPFr4HK5AQEB/B72gqSu+ObOnQsADg4OdE+yPi4uX6omRc5LNs4EVim3VCZe5qvXECETWA8fIh0dxO/LGRyMBg+mdrY/VVNT4+HhgYt51dXV/f39vzrg3r17TCaTzWbH09CnliSwCIIgCKyxJ7BwR21VVTVn52TBGmqLat26dbhNjDiC1cvJyQkA/vjjD/pCJJQntH7SWky1BqtWISYTeXnRHugbHh4euHG1q6srj/edr6NbtmzBhVoCLjasX1VVlY2NDQC4ubnV3cfwyJEjN+nr30YQ37h7927Lli0BYP78+d/9y3/79i0udTEwMMjLyxM60KtXr3A9l6mpaQV/yTBN+vdH/HbCFRWoQweUmkrVEkK+gMIAnMP6484f333qqIITEA1qkEwHPT0EgCIiJDsLpK2tjVuMx8TECLiHxi8vOjq6bnewtWvXPnr0KCAgAHcmAgBNTU3BU1dYWlqatLQ0i8V6+fIlDVMWwIULCAC1bo1ETp1jKSkpdc/2XblyReKnIRFC1bxq6Xjpat5/apEETWBZWaHduz//yMigQ4fQokV1hq5GcnKiJ/6EkJiYOHjwYPy3Z2VllZubi2+vrKzEbWR/1MxORPHx8fxFHkVFRS9evKAjCkEQBNH4NeoEVlFREf5wP2LECNq/FNWKj48HgHbt2kl8qUJISAgA0NfU+d27dxaeFlLxUrNSZ3ER/V8VTp5EAGjsWNoDfc+pU6fw+pQ5c+Z8Vdl+9uxZBoPBZDIvX75MVTgej+fv7//48ePBdc6RLl26tG53YYKg1f3793HzIAcHh3pyAe/evcNZg379+uXU3dJeYO/evdPU1ASAMWPGiKODUlgY0tRE+/ahf/5BI0Yg3DWJ6gQWQiioKMjolJGsrOz8+fNpSqZ8+PCByWTKysqK7Q3uu3JzEZOJZGWRRGeBsrOzGQyGvLw8jRV8TZC/v//MmTP5VydMmLB27Vp+1dXRo0eFW6uF94mzt7enbqYCy8lBqqoIAB07Rsfw8fHxLVq00NLSonwVmxD6vugbXBRc9xZBE1hz56J//vn8IyuL9u37zzIEDgfJyiIJ/YJcLtfLywvX9rZr1w5/dsK7qerp6dG3vy1BEARBIEoSWOrq6v1qSUtLx8fHOzg4HDx48NGjR6K8jVVVVZmYmACAjo5Ofn6+iPNsENyKO0LSJ6P5qwjpqITPy8vT0dEBgDk751TyxPJtoaAASUsjNhtJaJO+4OBg/H1+7Nix/KY/oaGhuDXp3r17KY9IEliEpMTHx7dp0wYAZsyY8dNc/Pv377t164ZfbDMzMxsU6P3797iGy8jIiNp+8PVJTkbe3mjXLlTb/x7duIH4507KytC5c5TEiYiIwCVss2bNorAxIm5PbmlpKSMj06FDB1VVVcluXXr5MgJAY8ZIcAoIIeTr64tfnyU8j0bm2wTWjRs3Ro4c6eXlJUqCRpJFWLNmIQBkbIzoqW3kcDi4FOgYPQmyBrlZdLNzQuf92fv9CvxWfFiRW5Mr5BLCkBA0dOiXW+LikI4OLTMWWEpKirGxMc6ljhkzhsVisdns5rPpJ0EQBCEp1FdgHT16lN97lc1m6+jo2NnZeXp6xsbGCl7TxOPxbG1tAaB9+/ZptDVI+hE3NzcNDc2//vL7+aE0mz17NgD07dt379699+7do6q6oby8XJTt9oRnbo4A0NGj4ov4X48ePcI5wYEDB2ZlZcXGxuJvp+vWraMj3OPHj5WUlKbV0tbWJgksQgyePHnStm1bAJg2bZqAaZdPnz716dMHAHr27Cl4Fe3Hjx9x9daQIUOo6gT/c7m5SF4emZuLJ1pUVJSioiJOBYqSLygsLLxy5crChQs7duzIf4tksVj4/1SfPn0+ffpE4bQbZMkSBIA2b5ZU/M8WLVoEAP/73/8kPI9Gxt/fX01NbWwtFRWV4ODgnz9MAAsXLgQAW1tbSkYT1LVrCAC1aIHevKEvyLlz5/DiSglWA6VXpxdyChFCrypf7cvetylj07XCazW8mssFl7Nqsn7y4G8TWNXVyMgIbd6MPn5E8fFo4EB09iyd0xcIl8s9cOAA/hzFYDAmTpwo6RkRBEEQvz7qE1gPHz7cv3+/vb19r169mEwm1KGgoDBy5MhVq1ZdvHgxNTW1nmFxX1tFRcUnT56IOEMhxMWVMxi89u2RZFtw5OXlaWlptW7d+rsJwaioKOHWWVCy3Z6Qjh9HAEiirTdTUlJwsUmnTp1UVFQAwNramqYeN48fP9bX10+pZW9vTxJYBN2SkpJwG+wpU6Y0KOGSlZWlp6cHAN27d//48aMgx+Myh379+om1SPbKlc/lG+ISExOjpKQEAJaWlg191U1MTPTw8DAxMcGVnpiKigpuT56ZmZmVlaWrq4tXiwvytNNBRwcBoLt3JRL8C7yDyv379yU8j0bG399/8uTJ2bXMzMyoSmC9e/cOF2ElJSVRMuDPFRYiDQ0EgPbvpzUOl8vF/6wk9Z7LQ7wxr8ZoPNN4VPZImMf7+KDbt79cdXBAXC4qK0MbNyILC2Rjg27coKl+TQh4Dxxs0qRJZNcFgiAIglb09sAqKSmJiory9PS0s7PT0dHBjbT5WrVqZWRk5OLi4uvrW3fdyvbt2wFAWlo6JCRExOkJTVsbASAqOnoLiV8k1aNHj927d8+bN09XV5fFYtV9AuXl5Y2MjJYvX37mzJnk5GQBszBUbbcnjPx8JC2NpKSQCO2iRffp0yfcW43BYBgaGtLXJoMsISTELDk5WV1dHYTdCjA/P3/gwIG4t0795xiys7N79+6N60NF6f4ujKVLEQD6+29xxoyLi8OlUuPHj/9pv6rc3FxfX19HR0cNDY26xVYGBgbu7u6xsbFfvVYL/rTTISsLMRhIXh5JtnFNRkYGg8Fo2bJlY+hb1Kh8u4SQqgQWqt0rxtramqoBf2LuXASAhgwRw+nBCxcu4DNVEinC8srxgjhQfqr882Ir4Vy4gHr1Qs+f0zJ4Qzx58kRKSorJZP7111840d+qVSsvLy9a974gCIIgmjNRE1ilpaV1+55kZ2fX0+w2KysrMDDQ3d19/PjxuPilrk6dOk2bNm327NlMJpPBYJw+fVrEuYli9WoEgJYvl0z0HxVJlZaW1pMQVFBQwAlBHx+fH7XN2rx5M1C33Z4wzMwQADpxQjLREUIIlZWVDRgwAD9pLVq0CAoKoikQSWAR4vT69Wu8FeDYsWOFbgpeUFCAd5jq1KnTmx+s8Sko+4hkvwAAIABJREFUKOjfvz8A6OrqCtf3XSS9eyOAL92vxOXx48fKysoAYGZm9u1qbi6XGxsbi4ut8H4RmJqamp2dna+vb/2LtflPu6am5o+edprg7eAkviU9XvNlLq6VoU0IrQms9+/fy8jIMJnMhIQEqsb8odu3EYOBZGSQWPaP43K5uKT0SN21eGKRXp2O93e+mH+RrhiLFyMAVOcPQyJqamoMDAwA4LfffkMIZWZmTpkyBb/0mZmZib8BCEEQBNEciJrAEkV6enpAQIC7u7ulpSU+b4NXycnIyGzfvl2CE0MIPXqEAJCGhmRqtJctWyZIkVRRURE/n6WlpfVVQlBdXd3S0tLd3T0gICArKwvRs91egx09igDQ+PGSis/hcCZPnoyLHWxsbPCfHE15pZycHF9fX/7ViIgIOvrxEwRC6N27d507dwaA4cOHl5aWijJUYWHhkCFDAKBjx46vXr369l6c/+3Ro0dDO75TQKL1Qi9evMAFbiNGjMBnbrKzs3GxlZqaGv+1l81mGxkZeXh4fFtsVY/6n3b6ODkhAOThIbaA34f7MUn8rb8Rev/+/Z07d/hXQ0NDMzIyKBwftx6bNWsWhWN+q7i4OMrUFAEgMf4vxtsCdOzYUcz7Wk56MwniYMKbCTTGyMhAcnKIyURPn9IY5Wf+/vtv/Gmq7plsX19ffIpaXl7ew8ODpi1cCYIgiGZLkgmsurhc7vPnz318fHAFwbVr1yQ9I6SlhQDQvXvijit0kdTHjx/9/PzWrVtnamqKNyCrq2PHjngF4sGDB2mauUBycxGbLcFVhEuWLAEAZWXlly9f8ng8d3d3vJbQ3d1dIvMhCNGVlpbirQBFz17xB8TbS7Vr165u1rWoqAgXCnXr1k0yjU4uXkQAyNRUAqERQnVyWNra2vr6+nXLYLt27bp06dLr16+XlZUJN3hpaeno0aNx3ZbYkt3duyMA9PCheKL9EN78l2xhJn7p6elycnJMJpPWrgKLFy9mMpl77OyQwJv5iI7H4+F2AYcOHRJb0H/y/oE4aP2k9cdqmlva4cXUVlb0RvmxpKQkWVlZBoPxbUlgVlaWnZ0dfmE0MjKSwE6XBEEQxK+rsSSw+LZs2QIAc+bMkfRE0MqVCAD9/rtYg545c4aqIil+gZuJiUmLFi0AoH379qaS++LHxzU1jejb98FF2krrfwynq+Tk5O7W6Vd8/PhxNpsNAPPmzRNwyzaCkKzdu3fzExxFRUUrVqzw8vIaOnQohVsBlpWVmZiYAICqqir+ZltWVjZixAi8ulBia0OcnREA2rpVMtERQgilpqa2bdtWU1MTv5iYmJh4eHg8p6gZzbdPO03S01FREUIIffyIjh1Dkm27nJ6ejouOBd+qmKAQPq8zY8YMmsa/c+cOg8GQlpYWx0LF/7p8+TL+8EPVJs71y67JVnmqAnHgk+dDezBchMVgIElsdsTlco2MjADA2dn5R8dcu3YN9wGUk5Pz8PAg/7oJgiAISjS6BNarV68AoHXr1hLc/Bi7fx8BoI4dxbeKMDQ0FO9UtXfvXmpHrqmp2blzJwAMHTqU2pGFcMzbGwAsLS3FHPfo0aMAwGKx/Pz8vrrL399fTk4OACZNmiSej7kEIQoLCwv+HhefPn3q1KkTQojy9GtlZeWECRMAoE2bNpGRkbg4qGPHjuJvNP5Fjx4IAD14ILEJIIRqy4X2799Px9KkyspKS0tL/LTTV5E0dCgaMeLzu5ufH7K3pymOQP755x8AmDCBziVXxI9lZGTIyckxGIynNKxHKysrw/9e/vrrL8oH/yl+EdaBAwfEEG5ayjSIA/PX4mrl5uKCANC0aWIKV8eOHTsAQEND46fd/RwdHXEplqGhIVWJfoIgCKI5a3QJLIQQ/rRx48YNyU6Dx0OamuL7rhQbG9uyZUsAWL9+PR3jl5WVtWjRgsFgvHv3jo7xBZeTk8Nms6WlpfPz88UWNDAwEJdZ/ehT7IMHD3CH5sGDB0ugLzVBNMR3E1h04CdTcGPyDh06iLnF+H9kZCAApKCAJLpRXUZGBgAoKCjQV7BZVVU1adIkfC7nAT3vQEOHIkND5OODUCNIYM2dOxcAdu/eLclJNG94e+Lp06dTPvKKFSsAQE9PT1L7S/7777+4KyjdZ6eu5F2BOFB8ovi+6v3Pj6ZEZiaSlxd/EdabN5/k5eUF/6AeFBTUqVMn/D7i6uoq8fPTBEEQRJPGhMZn+vTpAIALvyWIwYCpUwEAxDCRt2/fWlpalpaWWltb46aYlJOXl8cbPPn5+dExvuCUlZVHjBhRXV0dGBgonogxMa9mzJjB4XDc3d3xWolvDR48ODIyUlNT8+HDhyNGjHj37p145kYQwtmzZ4+jo6Ojo+OqVavoiyIjI3P+/Hk1NTVpaWkmk7l9+3ZtbW36wtWPe+cOAMDw4VBnmz/xCwsLA4ARI0bgnDgdpKWlfX19p06dWlhYaGZmdv/+fTqibNkCGzdCfj4dYzdMeHg4AOASP0Ii1q5dKy8vf+XKladPn1I47MOHD/ft28dms0+cOCEloX+2kydPHjBgQGZm5rFjx+iLkpeX9/uw34d+GLq9/faO0h3pC/Qfamrg6AgIwaZNYooIwOPB/PntdHXfLF680dzcXJCHjBs3LiEhwcXFhcvlbtu2beDAgXFxcXTPkyAIgvhVNcYE1owZMwDAz8+vurpasjOZPh309IDu72u5ubnm5uafPn0yNjY+efJk3a7A1GokmUExzyQlBSZM6D5w4KUFCxZs3LixniN79ep1//79fv36JSUlDRky5PHjx2KYHkEIx8LCAiew+L1y6VBTU2NjY/Pp0ycul8vj8ZycnKKiougLV79F4eF9unYNnThRUhPAxJNtwTksW1vboqKisWPH4qCiy8mBs2fh3j0AAA0NcHKCtWspGVh479+/T0tLU1JS0tPTk/BUmjE1NTVHR0eE0CbqUiFVVVXz58/ncrmurq4GBgZUDdtQDAZjw4YNALB169aKigqaoixfvvxd0jtpT2lHZUeaQnyfqyvIy4O/P8TGiifg4cMQEQHv3qn//be74I9SVFTcu3fvnTt3unfv/uzZM0NDQzc3t6qqKvrmSRAEQfyyJF0C9n19+vQBgJs3b0p2GtevIyenL3vm0LHIory8HG+dbmBgUHcfYjrgVYRMJlMy24fV8enTJxaLJSMjU4TbCNMY6PNukpaWqKZGoL2cS0pKzMzMAKBly5YS/wskiO8SzxJCDocza9YsAGjdunVMTMycOXMAQF5enh9azHDxV2xsrESi82lpaQFAXFycGGJxOBzRn3YOB8XGIg8PZGSEmEwEgOzt0dCh6OVLVFWF+vRBf/4pySWEJ06cAIApU6ZIbAYEQgihzMxMGRkZ3MpAVlZWXV1dR0fHyMjI0tLSysrKzs7OxcXF3d3d09PTx8cnICAgJCQkKioqMTExPT39u8sD161bBwA9e/asqKgQ/6/zlYEDBwKAp6cnHYPjcnJ5efnXr1/TMX79itav/3PUKLtZs8QQKy0NKSggAHTlipAjlJaWuri4MJlMAOjdu7eTk1NYWBj/riFDhlA2V4IgCOIX1UgTWLhSZsGCBZKdhqcnUlBA+/d/vqqoSPH4HA5n8uTJANClS5fMzEyKR/+eqVOnAsB+/q8kOSNHjgSAs2fP0heiuBj1748A0MCBqLS0AQ+sqqqytrYGAGlpaVpnSBDCEUMCi8Ph2NjYAECrVq1wK3Eej7d48WIAkJGRCQgIoDxi/d6/fw+NYKM6PI3WrVuLbRpcLnfevHkAICcnd+vWLcEfmJ6Ojh9HVlaoTRsE8PlHTg6NG4dOnvycwEIIhYWhli0lmcDCJYT79u2T2AwIhBBCYWFhDAYD71ksBAUFBQ0NDR0dHUNDQ1NTUzMzMxaLxWKx7t27J+nfDCGEAgICAEBNTa2srIzakYuKijp06EBfduyncnJycNrx0aNHdMcyM0MASPRc2b1793r16jVhwgQrKyv+u0lRUZGKioqoQxMEQRC/ukaawEpKSgKAtm3b0tclVxCenui335C2NsrIQIjqBBaPx5s/fz4AKCsrv8TfJOh37tw5ABgxYoR4wtXjwIEDtJ51r67+/ElLWxtlZTX44Twez93dHQAYDIa7uzv18yMIEZw7d46/FWBpaSnlX5x4PN7ChQsBQFFR8eHDh3VvX7ZsGc7tfrubJ618fHwAYOLEieIM+q1Tp04BwKRJk8QZlMfjLV26FD/t/v7+9RxZVVUVGhq6bt0f+vpcftIKAPXogX77Dd28ifhtrPkJLISQtTWyt0dr1iBXV5p/k+/B3Z0TEhIkEJuoxd8rcMuWLQih8vLy9PT0xMTEqKiogIAAHx8fLy8vT09Pd3d3FxcXOzs7S0tLIyMjAwMDHR0ddXX17/aD69SpU79+/ST9m30xaNAgoGGvgAULFgCAoaGhBHPrq1evBvr38Tx2DAGgtm2F+Uz1rYqKiry8PJLAIgiCIBqqkSawEEI6OjoAEBwcLME5eHqijRuRlxeaMQMhhBQV0adPKDQUUbLu7c8//8Qn1cV5frKkpEROTq4xrCLMzMxksViysrJ0rCLk8ZCDAwJAKiro1Svhx9m7dy8udMfNR6mbIEE0Xjwez9nZGa+IiYiI+Pbe3377DSdTrgi9jKThHBwcAGDPnj1ii/hdeEGf+Est6n/aU1NTvby8rKysWrVqhXMHvXrFycsjExPk4YGSkn4+/uPHSEoKAaDVq2mZ/4+8fv0aAFRUVHg8nlgDE/+1fPlyAOjbt6/QewUWFha+f/8+ISHh7t27QUFBe/fuZbFYUlJSKSkp1E5VaHihn4qKCoXtGkJDQxkMhoyMzPPnz6kaUwg5OTkKCgoAUPd8A7UyMj7Xcp47R+WwVlZWWlpa/fr169evX9++fUkCiyAIgvipxpvAwvkd3FVUUnACi8tFgwej27eRoiI6ceLzCW11dWRlhTw9UVQUEmJr5qNHjwIAi8UScxUDQgjvzn7w4EExx/3W8OHDAcDNzS0vL4/akd3cEACSl0f374s61IULF2RkZABg5syZJIdF/PJ4PB7eqVNeXp7fmuRbeOtDKSmpixcviWdinTt3BoAn4t0t/luampoA8PTpU4lEX79+PX7jOH36dHl5eVBQ0PLly3v06FG37EVPT2/NmjWRkakN3ar+2jUkI4MAkLMzEls2ydvbGwCsrKzEFI/4nvv377NYLDabTW2DOZztnTdvHoVjigj3ku/Tp8+sWbMcHR1dXV23bNmyf/9+Hx8fPz+/0NDQ2NjYlJSUnJycKgH+/ZSWluLGfFu3bhXD5Ovn6uoKABYWFjSNP3ny53ai1CIVWARBEERDNd4E1rNnz/DyOgmuIsQJLIRQXBzq1w8pKKALF9DgwZ8/5fN/pKRQ//7IyQkdO4YSEvJ/OuHAwEBcby+RLNLp06cBYPTo0eIPXRePxzMyMsKdIwBAXV3d0tLS3d09ICAgPz9flJGPHPn8P4WqDuzh4eGtW7fesGGDlpYW/+x0QEDAkiVLqAlAEI0G/hYkLS1948aN+o90d3dv0UK1X7/CU6don1VqaioAKCkpSTaJnJKSgte2S3AauDE2k8mUlZXlJ63atGljZWV1/PhxEUtrb9xAsrIIAC1ciMTzK86ePRsADh06JI5gxPdUVlbigvc//viD2pHfvHnDZrNZLFZycjK1IwvNxMSkTZs2P2vn9ZmsrKyqqmrXrl0NDAzGjBkzZcqUOXPmLFu2bP369du2bfPy8rKwsAAAfX19ocvWKJSbm4uLsB48eED54GfOIADUqhX68IHikUkCiyAIgmioxpvAQgj16tULAEJDQyU1AX4CCyG0ZAmSlv58uaYGJSYiHx/k4oKMjJC09JdklqHhdikpKQMDAxcXFx8fn8TExK++6jx69Ag3Sd20aZN4f5vPiouLZWVlmUxmBu7sJSFr167FHxD79+8vLy9f91Mji8XS1dWdN2/e4cOH4+PfN+iTYU0NMjREDAai9kt1Wloaj8dTUFDgn5XFO9xTGYMgJA0nR6Slpa9duybI8Tt35gIgJhMdP07vxI4dOwYA06ZNozdME5nGpEmTVFVVAUBHR8fV1TUkJITC7883byI5OQSAbGyQGFr6tG/fHgCSBFnlKKxevXrxL1++fHnDhg30xWqKcM6apr0C586dCwAODg6UjyyEa9eu4b4N3t7eZ8+ePXz4sIeHh5ub2+LFi21tbSdOnDhq1Kh+/fppaWkpKSl9t6vXV9q0aSMjIxMfHy/p3+wz/LHK3Nyc8pGPHUMtWtDyOk8SWARBEERDNeoE1oYNGwBg0aJF4g8dGIjGjkXh4Sg6+vMtBQVox47vH1xSgiIj0a5daNYsZGg4/duPOGPHjl23bp2fn9/du3fxFw/JbrA4YcIEADh8+LCkJnDkyBEAkJKSunnzJkKIw+EkJib6+Pi4uLgYGRnhJXvY0KFvpaSQjg6ys0Oenig29uu6gDNnUL9+X7qS6emh0lLk60vLtEkCi/iF4VXbUlJS9bcJ/8qOHQgAMRiI1k3k8H6IBw4coDFG05kGrlravn07TeNHRCAFhc97jdFaAI13a1FXV6e1AZasrCz/8smTJ52cnOiL1eQ8fvxYSkqKyWTevXuXjvHT0tKkpaVZLJbYdqr5kcLCQlzxLfh+l2VlZZmZmcnJyTExMSEhIZcvXz5x4oSnp+dff/21atUqR0fHtm3bAsCJEydonbngcnNzFRUVASAqKkrEoUJC0Lp1X5YSu7igjx9pWVn85MmT7OxsfJnD4dSzbp0gCIIgsEadwHry5AkAtGvXTsx7u9y/j+TlEQASbllDUVFRVFSUp6ennZ1dly5d6iazGAwGAEyYMEGyuyvi/bzGjBkjkehXr15lsVgMBuPkyZPfPaCiouLevXt79+61s7MbObKMwfjPgk0FBTRqFFq9Gvn6ordv0aFDqEMHtGzZ58dSu1PkVxQUFPT19XG30S5dupAEFvHL2LlzJy5+PH/+fEMfe+gQYjAQg4HoaLD+6tWr/fv346Uxkuo8xaehoQEAku3WjMRStRQVhRQVEQCaMQPRtzrq0KFDADB79my6AiCESALrx6qrefr6+gCwcuVK+qLg3Zbt7e3pCyEIXAs2ZMgQCtf/njlzBgA0NTUFaZglHrhNnq6u7tGjR319fYODgx88ePDixYuPHz8WFxcLPs7u3UhODvn4fL5K6ycrgiAIgmgQBkLop2XSEtSzZ8/k5OTw8PBRo0aJJ+KbN2BkBNnZsGABHD1KwYAfP36MjY2NiYmJiYm5f/9+aWnps2fPdHV1KRhaWIWFhe3ateNyuRkZGbgiTGwePnxobGxcXl6+detWNzc3QR5SUgJP/8/emcdDtb9x/Dkz9mzRghZFpVRaKEqLSmnRnvZ90e6n7WrXnnbtabtX3Tbt2q+i0iKUFqEFIUtIZGdmnt8f35rmFrKcc0a37/vljxmN5/OdE2fO+Xyf5Rk8fvzlKzwcpL+zDAObNkFyMly/DocPg7k5aGlBRgZXi9fU1ExNTVVSUgKA06dPe3t7k4ZiFMovjbu7+5w5c4RCoaenJ0kyKiv798P06SCRwOrVsHRpRdeTm5t7//79mzdvXrp0KSwsDACEQiEiDhgw4MSJE+QPkH9ev35tYmJSo0aNpKQkshUhFyIiIpo0aaKvrx8fH8/pMh4+hF69QEfnVceOWw8c2MnuYY+Li7tx48bq1atjY2M3bNjwxx9/sBj8OxQVFaUfuGlpaT179iQpwJSVK+HMmYfVq6+/cuWUqqoqRyoxMTGNGjUSi8UvX778buAAb/j6+tra2iopKYWEhJDeFKwgFoubN28eHh5+8OBB4tPJnbCwsLZt2yoqKqanp//4rwzDaGtra2lp6eu/VVAQamoC+dLWBi0tkD7V0oKQEIiKgmvXIDAQdHS4vbKiUCgUCqVsyNtB+wmkpJ+3btnJydigAQJgnz6clE6MHTsWANatW8d+6DLSu3dvANi/fz+foi9fvtTR0QGAiuyBJyXhpUu4fDn27o3t2+OePbhkCfr6ooUFikScZ2DREkLKf4wdO3YAAMMwFTwbHDyIAgECfOsbWFZCQ0M3b95sa2srW0RcrVq1ESNGrFy5kpw6evXqxUWnntKwd+9eABg+fLhc1KXwk7VECAwUm5g0AwB7e/u8vLwKRissLPT393dxcTE3N5dab6qqqvXr14+JiWFlwUVCM7CK5PlzVFJCgQDv3OFca8qUKQAgr0/MrKwsIyMj4Kbq9vjx41CZkrDs7e0BoHHjxhMnThwyZIitrW2bNm1MTEz09fVJ91UAYBgBOVcX96WpiVu34urVuHEjTpmCSDOwKBQKhVKZqOwG1uPHjwFAT0+PhyrCz5+xdWsEwDZtMCuLEwlvb28AaN26NSfRy8Lhw4cBoEePHrwpxsfHkwn0ffv2ZfF/kxhYiDhyJO7bRw0sCqUMHDp0iGEYhmFYGQN3/DgqKCAAuriU9kfS0/HsWZwyBXv2nCw1rYRCoZWV1cqVKx89eiSt9wkJCalevToA2NnZ5eTkVHy1ZWXo0KEA4OHhwb+0LA4ODnzuPVT8sL99+3bXrl329vbS+2cA0NTUHDRo0LZt21q3bg0AdevWffv2LeuLJ1AD60cKC7FNGwTAWbP4kHv37l3z5laWlpe4LHstlhkzZgBAq1atuGjdQJKw+N8OLJIjR44AgJaW1vv374t8gUgkSktLi4yMCgnB27fR2xv//hv37EE3N3RxwenTcdQo7NsXHRy+GFgFBdisGQYEUAOLQqFQKJWIym5gIWKDBg0A4O7du5yqFBSgnR0CoLExfvjAlUpeXp6WlhYAcHexXko+ffqkpKSkoKAgbZ/JKRkZGaTXhqWlZXZ2NouRpQZWQgI2bIiqqizG/p6goCBps+GPHz/K/T+RQikTWVlZsuPqkpKSGjduzDAMi13JiYc1bBguWoShoV++eePGt2kYhNBQdHNDW9tvI1w7djxYvXp1BwcHDw+PxMTEIoOHhYWR9k+dOnUqUz+XiiORSGrWrAkAr1+/5lO3uGW8efOGN9GwsDB9fX1y2DMzM0vzIzk5OT4+PiTZSjbj28jIyMnJycfHR7oTkJ6e3q5dOwCoU6cO68f2/v37hYWF1MD6ETc3BEBDQ+Ttz2jaNATAkSN5kpNy+/ZthmGUlJSeP3/OkcTJkyeJCSvfJKzk5GTiNf/FxgxmYmAh4u3b2L49NbAoFAqFUon4BQwsMuPZycmJOwmJBMePRwCsXh25vj0hLWY2bNjArUwp6NmzJwAcPHiQa6H8/Pzu3bsDgKmp6cePH9kNLjWwENHdHSt9USyFIjd+HFiekJBQ3CyFcnPvHhYWoqoqWlt/mRm6bBm6u2NqKh4/jmPHYs2a32pVFBWxc2dcvx5DQgpKM4ouIiKCdFLv0KFDhnT4KPeEhoYCgIGBAW+KRfLixQsAqF27Ns+6pTzskZGRHh4e9vb2KioqUtNKV1eX+JJxcXFF/lRWVlbXrl0BoGbNmi9evGBrzefOnVNUVBw6dOitW7ek30xISJD7ODy58+oVqqoiw+D16/yJxsaisjIKBMiZj1QE2dnZDRs2BICVK1dypyIWi83MzABg37593Kn8lMGDBwOAra0tKzM9pQYWIo4eze3WIIVCoVAoZeIXuN0PCgoCAH19fRZnx3zHxo1PyHi7x485UvjG+fPnAaBNmzacK/2MgwcPAkDPnj05VZFIJGPGjCH3fu/evWM9flwcShOhkpJw61bWFSiU/wg/Gljcaeno4KRJuHcvIuKyZbhmDQqF33wrQ0OcOhXPncNyeFDR0dFkuquFhQXrhnhx7Ny5U45NfKSQhmVjxozhXzoqKqrIw56VleXj4+Pk5EQqxAkCgcDc3NzFxcXHx6egFFMMs7OzbW1tAaBGjRqszJq8fv066aTG6Xy9XxGxGDt2RACcNIlv6RkzEACHDeNPce7cuQBgZmbGdW6Ul5cXySKseKu48nHx4kVSmctWOzl/f5Qav0lJuGgRpqSwEphCoVAolIryCxhYiGhsbAwA976rQmGJXbt2AYCNzbEbN7gI/z25ubmampoAEBkZyYde8aSmpioqKioqKnJ6EzhnzhxyXRUSEsKdCiK+e4cKClitGifd9ymU/wAODg5nz57Nzc3Nzc0l9SbcaenoYFIS1quHSUlfMrDatEFbW3Rzw+BgrGCKwLt378iHQuvWrVNTU1lackkMGjQIAA4dOsSDVgkMHDgQAA4fPiwXddnD/vjxY3d3dzLZTepbSYtAExISyho8Ly+vb9++AFC1atXAwMCKrPOff/4hKWDOzs4VifOfhOQp6+tjWhrf0gkJqKqKAgGyYVH+nICAAKFQqKCgEBQUxLWWRCJp0aIFALDSTLCspKamkspijlLA7t1DQ0N0cOAiNoVCoVAoZaacBpabm5vsKL3GjRuX44K19CxYsIAMQmJ9VtHFixeFQiHDMKzX0ZTAiBEjAGDTpk28KRZHjx49AIC7975582YAUFJS+ueffziSkMXUFAHQx4cHKQrl18PBwaFx48bt2rVr165d27ZtuTawEHHnThwz5ouBxUZdyzdiY2NJe8SWLVty3chPIpFUq1YNAKKiojgVKhmxWEyWER0dLa81xMTEEA9LioKCQqdOndatW/fkyZMK1i7l5+cPGDAAALS1tQMCAsoXxN/fn3SLnz17dkUW858kOhrV1REAz5+XzwJmzUIAPqyQvLy8pk2bAsDixYs5F0NExDNnzpBMc/5HTIwePRoAbGxsWCke/BHiPDIMPn3KRXgKhUKhUMpGOQ2sNWvWrFq1Svq0fv368fHxLC2pCBYuXEhmqJNLW2traxcXF29v76SkpIqEDQgIUFNTA4D169eztdTScPbsWdLOnE/RItm/fz8A9OnTh4vgJ0+eFAgEDMMcOXKEi/g/snw5AiBt0UuhFAnPJYSIKBKhuTna2aE1JZp6AAAgAElEQVS7O/sSiYmJ5B61SZMmnO6gPH36lDRp5k6iNISEhFSGZVy/fp0k1U6ZMuXs2bPp6eksBs/PzyfJblpaWg8ePCjrj9+/f19dXR0AJk6cyNHN/C+Nry/WqCGHTupSeLNCFi9eDAAmJia5ubncKn1FmoTF4kyM0nDlyhUAUFNT43Swg5MTAuDgwdwpUCgUCoVSWn4BA+vMmTPEB2nVqpWuri78m3r16jk4OGzcuNHPz69Mc6levnxJTLFp06ZxtPLiyMnJUVdXZxiGi55QZSI5OVkoFAqFwvnz51+4cIHF/0Q/Pz/SgmTLli1sxfwpz58jAK0ipFCKhn8DCxEDA1Eg4MTAQsQPHz6QGfYmJibFTY6vONu2bQOA8ePHcxS/lGzduhUAJkyYIN9lbNmyhThEHMUXiUQko6RKlSqy/dd/ysOHDzU0NABg3Lhx3HXMrMycOPHNGBKLcckSjI3FhQu/jRrctw+fP0e+GscVDQ9WyNOnTxUVFQUCgb+/P4cyP3Du3DnSsJW3JKyMjIw6deoAwLZt2zgVSkxENTWahEWhUCiUSkH5DSx9ff2WX1FSUuLIwLp79y5pZuHm5ka+Ex8f7+3t7erqam9vX7Vq1e/8LCMjozFjxri7u/v7+5dwDREfH086zvbr108kEnGx8pIZNmwYAGyVd8vxEydOMAwjzW4j11729vaurq7e3t7lLsx58eKFtra2XBroNm6MAFiWux4K5XeBTwNrzpxvj93dOfyTTEtLs7CwAID69euzW+KXmZnp7e3t6OioqampqKjo4uLCYvByQFpE8ZbQWhz29vYAcPToUe4kRCLRuHHjSF6JT+lqwkNCQsgH2dChQ+XymV4ZGDsWT5368riwENXVMSAAlZVR2gqsc2c+JtWUDNdWSGFhobm5OQDMnTuXE4HikUgk5Fy0Y8cOfhQnT54MAFZWVjz8zjs7IwAOHMi1DoVCoVAoP6FSZ2D9NElKJBKFhoZ6eno6OTlZW1vLju4mvTlMTU2lfpZ0DE1GRkbLli1JEV92djbryy4Np0+fBoD27dvLRZ0gTZKaMGHCokWLunXrpqWlJXsAGYZp2LDhyJEjt23b5u/vX8pjFRcXR7YEhw0bxv82+JIlCIDTp/MsS6H8AmRlZcmOhGO3+Os7duzAli3xxAnuFL7x6dOntm3bAoChoeFb6VDSciEWi4OCglavXm1tbS0UCqUnQ4FAoKqqev36dbbWXFZEIhHZFWC9EWT5lhEXF8epkEQimTFjBgAoKytLXdfiePbsGcnOHjx4cOFvnH9bpIHVowe2aIFPniBWDgMLEZ2dsVMn5Gisy6pVq4idnZmZyYlAiVy4cIG3JKxbt24xDKOsrPzy5UuutVDGeeS+Jz6FQqFQKCXBpoHFrltRjiSp/Pz8wMDA3bt3jx8/vmnTprK3H6QeoWPHjv/73//I7pypqSlvI9h/JDs7u0qVKgzDyOtupLgkKZLg5uLiYm1tTRqESREKhbKGYJGtJdLT00lFj42NjVzmSYeEIADWrIm/6x48hVIp6NcPAdDTkye59PT0du3aAUCdOnXK0QsmJSXFy8vL0dHRwMBAdgvE2trazc0tKCho9uzZAKCkpHReTu2vg4KCAKBBgwZyUZcSGBgIAA0bNuRBSyKRlOawR0REkBFsAwYMkPVnf0PGjsVBg3DJElyyBBcv/mJg9e6Nt25h27YoFlcWA6ugAMePR+nc53PnWGsqHx4erqKiwjBMKRP3uKBNmzYA4M5R1fRXsrKyyDgFPlu4zp2LANi/P2+CFAqFQqEUAWsG1q1btxo3bhzC0p5aRkYGaYdpZWVV7iSpzMxMf39/d3f3MWPGmJqaMgxDbktq1aqlo6Mj9/5TQ4YM4eEqp0hKmSRVWFgom+BG0rWkKCoqEj/Lw8MjNDRULBbn5uZ26NABAJo1a/bp0yc+35EsJiYIgLdvy0ufQvndEYmwalUEQD7PsllZWV26dAEAPT290NDQn75eJBIFBwe7ublZW1sLBALpma1+/fqOjo5eXl6yGWoSicTZ2Zmc986cOcPl+yiajRs3AsCUKVP4l5Zlw4YNAODo6MiPnPSwKykpnT179scXvH79Wl9fHwDs7OzksmVSqRg7FhcuxCtX8MoVvHTpm4GFiMOH4759lcXAQsSqVbFpUyQ5UmvXIismjFgsbt++PQBMl2sOtre3NzkLcZrgP2vWLABo2bIln6ZtSsqXKZaBgbxpUigUCoXyPeU0sFJTU1NSUqRP3759O3ToUADQ1tb28/Or4Jry8/NtbW1ZT5JKSUm5evUq6axhbGzMVthyc/LkSQDo0KEDz7rlTpLKycm5f/++u7v7qFGjTExMpIYgQVNTs1atWgBQt25d7ropl4ZFixAAZ82S4xIolN+a4GAEQP7PstnZ2d26dQOAmjVrPn/+vMjXfPjwwcvLa8yYMbItFFVVVW1tbd3c3IKDg0uIv3TpUpKLymkHqCLp1asXABw/fpxn3e/o2bMnAJzgpzT0K8Ud9jdv3pAPne7du7M+bO7atWvSOYYJCQlPf4Xm1UWWEBIDKz4ejY2xZcvKYmDp6uLq1Th/PiJ7BhYxeWvVqiXH/TMCqWjmrsnpgwcPBAKBgoLCE1IayiMLFpBOWL+7WUyhUCgUOVJOA+tH8vPzR4wYQXZKK3KRLZFIxowZAwAGBgZcJEmJRKIaNWoAQGm26DmFVBEKBALuBjj+CItJUp8/f5ZNcCP2pbq6Ov9XVN/x+DHWqvWub9+dv+cgKgpF7mzahAA4ebIcpLOzs3v06AEA1atXl5oOJNnK1dXV3Nxc1nk3MjIiyValb5fj6upKzJS//vqLszfxPYWFhZqamgDA54dFkcvQ0NBgGCYxMZFn6R8Pe0xMTL169cgmUFZWFuuK6urq0nZap06dGjt2LOsSrFOCgYWI27YhQCUysHJysFEjfPbsi4FlYYHGxmhujl274oABOHYszpqFixejmxt6eOCJE3j16j/+/v7Pnj2Ljo5OS0v7LuCrV69UVVUB4Nq1a3J5R7JcvnyZnIK46MOVl5fXpEkTAHB1dWU9+E9JTsbu3XdXr14zkGZhUSgUCkVOsGZgIaJEIvnjjz8AgGGYDRs2lC/InDlzSDoPdxueU6ZMAYAVK1ZwFL/0DBo0CAB27tzJj5xYLB48eDDZooyNjWU3eGJiYtOmTQFAXj1iZCG9Ie7evSvvhVAovyO9eyMAHjsmH/X8/Pz+/fsDgJaWlouLS//+/dXV1aWmlbq6ev/+/ffu3RsdHV2++G5ubuRjbvfu3awuvFgePnwIAI0bN+ZHrjgePHgAAE2aNJGLOjnsAoHg0KFDcXFxRkZGANC+fXuOenX/igbWkSPf/CmxGOfOxagolA7EKyzEOXPw2TN5re5f6OoiIl6+jB06fDGwdHQQoNgvhkEFhX81MSAXirVr1zY1NbWystLT0wOA8ePHy/udfcHS0hIANm/ezHrkBQsWkD9DedXMkuv8Pn36yEWdQqFQKBQ2DSyCu7s76Sfi5ORU1hSYTZs2kRwuThtw3rhxg6QgcSdRSo4fPw4AnTp14kfOycmJ3NQ94+YalrRHGTVqFBfBywS5wHJycpL3QiiU347CQtTURACUYyVxfn5+v379FBQUpPlWRkZGTk5OPj4+rNz1kY8qhmF2SO0BLlm3bp3cO/sg4s5NmwBgxowZ8loAqRFjGIZ0bbeysvr8+TNHWurq6jdu3PDx8fHx8Vm6dOkvYWCVTFISduuGDRtiZZjTSAwsRBwwAM3Ncf16/PABX7/G4GD08cGzZ/HPP3H7dly9GhcsQEdHHDlS3LNnz/bt2zdr1qxu3brfTUwGAA0NDRUVlceVJMEM8erVqwBQrVo1dg3WR48eCYVCoVAoxwSo1NRUDQ0NAAgICJDXGigUCoXyO8O+gYWIZ86cUVFRAYDBgweXvjPFiRMnBAIBwzBHjhzhYlVSCgsLq1WrBgBhYWGcCv2UzMxMVVVVfqoI165dCwAqKir+/v4cSURFRTEMo6GhwXo7krJCJnbp6+vTKkIKhWcCAhAATUzkvAx/f38A0NXVPXToEBcn2D179jAMwzDMtm3bWA/+Hd27dwcALy8vroV+gq3tez29dxcvynEJJA9LWVm5Tp06nLY6UldXnz9//oIFCxYsWNCvX7//gIElEn2ZcMJj8WuxSA2smBisUqWcPbA+ffoUExPz4sWL+/fv9+nTp1JlYCEiadewceNGtgLm5+c3a9YMAFxcXNiKWT4WLlwIAL169ZLvMigUCoXye8KJgYWIvr6+ZIusS5cusrOcisPPz48MueOu7aUsEydOBADZQYrygpS6cF2KcuzYMYZhBAIB1/OzWrduDQDe3t6cqpQGUmBy//59eS+EQvm9WL8eAXDaNDkvg4esJQ8PD5JuvHr1au5U8vPzq1SpwjBMUlISdyqlWQdWqYIMgx8+yGsJKSkp5AaesGnTJu60fsUSwp9y5MiX6QpyTMISidDfH7dv//ady5fx4cOKhn337p2SkpJQKIyIiKhoLJYgyf4aGhodOnTo3bv38OHDHR0dXVxc1q5du3PnTk9Pz/Pnz9+6dSs4OPjt27fJyck/TQ5dtmwZADRq1CgnJ4eft1Ac0iQs7jZEKRQKhUIpDq4MLER88eJF7dq1SbFeyR2XXrx4oa2tDQDzyUwa7iHZ3WZmZvzIlcDRo0eJzcedxK1bt5SUlABgu+w1IzeQm8bKcK0/f/58AHB2dpb3QiiU34sePRDgWzNpecFP1tLBgweJh8VdU8WLFy9Wipr3u3cRAJs3l5f+p0+fzM3NAcDExGTr1q1cH/b/pIElEmHjxgiAhw/LbQ0bNyLD4NKl7EeeNGlSJbn8INy5c4dhmB+rHUtARUWlRo0aDRo0MDc379at28CBA8eNGzd79uwlS5Y4OzsrKCgIBIJK0txz8eLFAGBnZyfvhVAoFArlt4NBxNJ/uJaV+Pj43r17P3/+3MDA4Nq1a2ZmZj++5v379+3bt4+Lixs2bNjx48fJVSnXFBYW6unppaWlhYeHN27cmAfF4sjMzKxRo0ZBQcH79+/19fVZj//48WMbG5usrKzFixeTKkJOiYqKMjY21tbWTkpKIil18uLRo0dWVla1a9eOjY2VnTtGoVC4o7Cw0MJiXNWqDqdO9a9Zk4+TeZEUFBTo6Ojk5OQkJiaSfkncceLEibFjx4pEIhcXF1LgVnHEYvHTp09v3rx56dKlhw8f1q1bVyAQPHv2TLYbPd+sWgWuruDkBNu38y+ekZHRvXv3oKCgRo0a3b59W19fn4vDDgCFhYWOjo4zZsyYOXPmw4cPhUIhANy4cePu3bs8fIDywLFjMHo0GBrC69egpMS3+uvX0LIl5ObC9etgZ8dy8JiYmEaNGonF4pcvX5qYmLAcvYzk5ua2aNHizZs3M2fOHDp06OevZGRkpKenf/436enpGRkZnz9/LiwsLCGmvr6+mZnZ9evXeXsXJZCenl6/fv309PS7d+927NhR3suhUCgUyu8E1w5ZWloa+WyrWrXqjxtHHz9+JPOAbWxseJ6oMn78eABYu3Ytn6JF0rdvX+CmijAqKoqM5hk5cqREImE9fpG0bNkSAC5fvsyPXHFIJBJDQ0MAeFjx4gQKhVI67t27BwBNmzaV7zJIAyzespZOnTqlqKgIFU4ijo2N3b9//+DBg2WzNqpUqUKqdbp06ZKVlcXWmsuMjQ0CoDyGzGZlZZGriAYNGsi2M5Me9gULFrAiJBKJHBwcAMDIyKigoICVmJUNkQibNEEAPHiQb2mxGDt2RACcNIkrCTJjevTo0VwJlJp58+YBgJmZWX5+ful/KicnJykp6fXr18HBwT4+PmfPnv3zzz+3b9++evVqe3t7ADA0NCxTQE4hJY3du3eveKiRI9HP78vjkyfxyhVcvRqfP//ynU+f0NGx4iIUCoVC+Y/AuYGFiHl5eUOHDgUAZWXlUzKFJTk5OaTJZbNmzTjtxlokN69edezY8eGgQTzr/sjKlSsVFBQUFRWtra2dnJw8PT1DQ0Mr7jelpKSQTciuXbvyecWzZs0aqBy9VOfOnQsAc+fOlfdCKJTfhdWrVwPArFmz5LuMVatWAcDs2bN5U7x06RLJOZ0+fXqZzt6FhYX+/v4uLi7m5uayuaJGRkaOjo7e3t65ubkRERG1atUCAGtr64yMDO7eRbHk5qKKCgoEmJrKs3J2draNjQ0A1K1bNzo6+rt/9fb2Lt9h/xGxWDx69GgA0NLSkuOINx44fhwB0NAQeXZCtm9HANTXx7Q0riRiYmJIJ6zw8HCuNEpBQECAUChUUFAICgpiK6ZYLG7evDkA7N+/n62YFSQ9Pb1q1arkem/Lli0HDhzw8vL6559/AgICwsLC3r9/X/oJjOrq2Lw5kvE/y5ahuzv27o23bn3518RErFePm/dAoVAolF8QPgwsRBSJRDNnzgQAoVC4a9cuRBSLxYMHDwYAUuTFzzL+RUEBVq2KAPjmjRzUvxIZGVmjRo0fa9x0dHTs7OyWLl168eLFhISEsobNyclp3749AJibm7M7xfmnvHr1CgC0tbXlvk/44MEDAKhZs2ZYWBgdR0ih8EDXrl0B4OzZs/JdRpcuXQDg3LlzfIpeuXKFjN91dHT86QknMjLSw8PDwcFBU1NTNtnK1tbW3d393bt3370+Ojq6fv365JT+8eNHzt5EMfj6IgC2asWzbE5ODvmNql27dmRkZJGvKdNhLw6JROLo6Ej+CypJjyHuEIuxeXMEQD6dkOhoVFfnI4dv6tSpJOucW5niyc/Pb9q0KQAsWrSI3cgnT54kTq7cL66kmJubl9z7QiAQ9Ox5o359bNECO3bEPn1wxAicOhVdXHDdOty1C48cwVevUFcXFy/GZcsQqYFFoVAolJ/Bk4FFcHd3J06Nk5PT7NmzyVbnc2mWMP+MGYMA5RzgzAaySVLJycn+/v7u7u4ODg6k7k8WfX19e3t7V1dXb2/vlJSUksOKRKIBAwYAQP369RMTE/l5L7KQfcJr167xLy3LmzdvNDQ0qlevDgAaGhrsJrhRKJTvyMvLU1VVZRjmp+coHpYhEAj4X8a1a9dUVVUBYNKkST+aKTk5OT4+PiTZSvb0bmRk5OTk5OPjU/J9aUxMjLGxMQC0atUqledMqGXLEAD5zWbNz8/v06cP2YQoOaGm5MP+UyQSyfTp0wFATU3t9u3bFVjyL8PJk9IkLD62diSSL7MdRo3iXCs2NlZZWVkgELx48YJzsaJYunQpAJiYmOSShCL2EIvFpJPsvn372I1cPq5cuQIAKioqs2bNcnZ2njhx4pAhQ2xtbdu0aWNiYqKvr6+mpgYAnTs/AMASvvbuRV1dzMxEY2OMiPhmYHXpgsOG4bBh2L+/fAyskSNHvnr1ijx++/btsGHD5LAICoVCofwArwYWIv7111+kaQUAqKqqynkE78WLCIDm5nIRLzlJKj4+3tvb29XV1d7eXldXtzg/y8fHJzs7+7ufnTFjBgBUq1ZNXvOkSf3OJO4aXZSCpKQkIyMjsl1JpmHKUrNmTXt7+5UrV169ejUlhSZnUSgscPv2bQBo0aKFfJfh5+cHAC1btpSL+u3bt0mr9REjRpAxdiTZyt7eniQKEXR1dR0cHDw8POLi4kofPDY2tmHDhuTdJScnc/YmfqBDBwTAS5d4EywoKCDdIWvUqPHy5cufvv7Hw156yMhaVVXVW9KUj/86YjH273+nadO2/FghHh4IgNWq4YcPPKghsSOHDx/Oh9i/efr0qaKiokAg4Oji1svLCwDq1KnDc9PYH8nIyKhTpw4AbNu2rYSXFRYWfvyYGxmJT57g7dvo7Y1//41796KbGy5ciDNm4OjReOcO6uoiInp5Yffu3wwsT0+MiMCICLx3Tz4GlqWl5dOnT8nj0NBQczndLFAoFArlO/g2sBBx0aJFAoFAUVHRzMxMPu08pOTloaYmAuDbtzwrlzVJivhZLi4u1tbWZFNLilAoNDU1HTNmjLu7u7+/P9n9U1VVvX//Pg9vpEgiIiIAoGrVqvJKdM/OzraysgKANm3aEHMwISFBagjWqFFDevSqV29GunLY26OrK3p744/VOTY2uGnTl8cnTuC6dbhs2b/qIOQ+4J5CqQy4uroCgLOzs3yXsXz5cgCYM2eOvBYgNVOaNGlCRklIz9WWlpaurq4BAQEikah8wRMTE0mBUuPGjWU7mnNIbi4qK6NQiOnpfMghikSiYcOGkW2Y0ufR+Pv7k273Q4cOLX0LdhcXFwBQUlK6cuVKedf7S8KbFfL+PWppIQDKdEDllvj4eJKDyXOCf2FhIUmu5O4cKJFIWrRoAQB79uzhSKKUkH75lpaW5T6VyUIMLETs0QPNzStLCSE1sCgUCqVywreBdevWLSUlJVLSRZKPkpKSeF7Dvxg5EgFw40aeZSuSJFVYWPjkyRMPD4/Jkye3aNFCQUFB1s9SVVVVUFC4xONWeZGQW6wbN27wL11QUNCzZ08AMDY2Lu636+3btydOnJg7d+7o0XtJYw7pl0CApqY4bhzu2oWPHmFeHhobo7HxF5PTwwPnz0dHR/zrr2/RlJV5eWMUSuWmU6dOAHDx4kX5LoNMrPP29pbjGoKCgqpUqUI6r1evXp0kW5Wjm2GRfPjwgZRpm5iYvH//npWYxVJY+CULgpzMRSKUdc3S05HtXSiRSDRixAgA0NbWDg4OLtPPBgYGkq7Sffv2LY0vs2TJEuJeyfe3RS7wZoUMHDi0c+ergwbxmuk8a9YsYmXyKUpGWNSrV4/TxqNnzpwBAAMDg5ycHO5USsbX15dhGGVl5dDQUFYCSg2sN29QRaUSGVimpqbm5ubm5uZNmzalBhaFQqFUEng1sIKDg8m+9JIlS6Kiokj7p/r168ur0g0R8dw5BMC2bfnUJHkKbCVJZWdn37t3z93dfdSoUbVq1VJWVm7L79spEvIep0yZwrOuRCKZMGECuWl8/fp1aX5EJMIXL/DwYZw+HS0sUEnpX37WpElobIyHD6OdHSI1sCiUYsjNzVVRUREKhWnczRgrBdnZ2crKykKhkP/Jtt8tQ0lJSSAQ3Llzh4uOe2lpaW3atCF3y1FRUazH/4KnJxoZ4bBh2KkTtm+PyckYH49GRt9esGoVrl3LomDFRwEGBweTovvevXuX3ISIfEgJhcJTvKUGVTJ4sEKOHj0KADo6Ojy340xISCD9+J49e8aPYnh4uIqKCsMw//zzD6dCUueRDETin+zsbNKMb926dWzF3L792+Pz5/HkSTx/HqXjnbKz8eBBtqTKgKWlZUhIiFgsFovFL168oAYWhUKhVBL4M7AiIyNJb/KRI0eSC/qPHz9aW1uTi5t79+7xtpJ/kZv7pYqwmAlHrHPgwAFy0Xyeg2E8iYmJAoFARUXl8+fPrAcvE6GhoSTFrKztSCrIokWLAEBNTe3hw4fli5CXh48e4a5dOG4cNm2KHh5obIxpaWhnhydPfjOwDA2xVasvXwoK7L4JSmVHWlaAiB8/fixTG6My4evre/jwYenTpUuXRkdHc6RVETIzM0nnO7k3wPLx8QEACwsL+S7jxo0bAMDpXsKnT58sLS1Jm7+3XFTBv3+PtWqhNGts+XKcMoVTA0sikZARchUcBRgSElKtWjUA6NmzZ3HWzObNm8kH8fHjx8st9KvDtRWSnJxMhqh4enpyEb9knJycAGDIkCE8aInFYnI1O23aNB7kzp07BwD6+vpyScIiI5hatmxZ+kLd0iORYM+eyDAo8xkrN2gJIYVCoVROeDKwZMftyfZFys7Otre3J46D3Krehg9HANy8mQepy5cvk4o/7rbOOnToAAAnT57kKH7padKkCQDcvHmTN8V9+/YBgKKiIrsDEImB9eYNGhvj1q00A4uCKioq0seHDx+ePn06R0IHDx6cOXOm9KmVldWTJ0840ioHkZGR7u7utra2ysrKJBtIR0enlJmPHLF48WIAWLBggRzXgIgLFy4EABcXF05V0tPT27VrRzoZsX/Y//wTJ0789vTDB6xRA+Pj0dAQk5K+fLm4sGVgSSQSUlmvpqbm5+dXwWhhYWH6+voA0Llz5x/rubZt2wYAAoHg6NGjFRT61eHUChk8eDAA9OrVi/XIpSExMVFNTY1hmKfceyHED61VqxY/iZ8SicTCwgIAduzYwYOcLA8ePBAIBAoKCo8fP+ZIwtkZAXDgQI7ClwFqYFEoFErlhA8DKycnh1xkFzluTyQSkU1XoVAon9nAZ84gAFpZca0TGBhYpUoVAFixYgV3Ku7u7rztOpbMsmXLeNuQRERvb2+hUMgwjGzGCisQAwsRly3D+vWpgUX5rQ2stLQ0Ly+viRMnGhgYSFvvKSgotGvXjgzIMzAwCA8Pl9fyyGfN1atX5bUAAsmNun79OtdCWVlZXbp0AQA9PT22+tF8Yf16lDXgxGJUUMDYWFRVxZ49v3w1bMiWgfXnn3+SynpfX19WAkZERJAeZB06dJBNSd6xYwfDMAzDeHh4sCL0SyO1Qnbu3MluZNIkXlNTM1ZaCcY7zs7OADBo0CBOVaKiosilHZ+nnQsXLvCfhJWXl0c2Jl1dXblTSUxENTVkGAwK4k7k5/z1118+Pj7SSVOZmZkVSQulUCgUCotwbmCVctyem5sbuRHiesu6CLKzcelSDAnhVOTt27dk+N3kyZM5FXr//j3DMGpqallZWZwK/ZRnz56RXlQ8VBEGBASQ4YwsNmWQIjWwcnLQyIgaWBRUVlYO+8ratWs5NbAaN2489ivVq1eXi4ElFmNQEG7cmG1tbS0UCqW+Va1atSZNmnT69GmSd5CdnW1rawsANWrU4Hn+FyEzM1NRUVFBQUG+820/f/5MlsFPKTdXh/3vv3HUqG9PY2Oxdm22SggTEhIGDx4sfbp3794///xz/Pjx7M79eP36de3atQGgTZs2pDXboUOHiFNkahwAACAASURBVHsl9yFulQcurJDU1NSaNWsCgHxdQmkSVhBnXohYLO7cuTMAjB8/niOJ4iBd8Nzd3XlT/OOPPwCgSZMmXE+unDsXAbB/f05FSoL8UZiZmYnFvA4foFAoFEpp4NbAkkgkkyZNKuW4vT///JOU140fP57XxkkSCa5bhy1aYKtWaG6OpPhu+3Zcv/7ba8zNsQJtbpKTk0luQp8+fXh4ayQH4fTp01wL/ZTGjRsDAFs76sURFhamo6MDAFOnTuUi/r17KG31cOkS3r+PL1/+axKXjw8XspTKi4KCwsivWFlZcWpgDR8+/NlXzMzMym1g3b2L2dlfHqen48OHGBeHsp3ifizbSklBLy90dEQDgy8zDQwMrBQUFMzNzV1dXYODg39sT56Xl9e3b18AqFq1avmacFeEa9euAYAV9+m0JXPlyhUAaN++PW+KnBz2jx+xVi0kH9wSCc6ciS4ubBlY0dHRJiYm0qdLly7dyM0s4Hfv3hkZGZEE8F27dgkEAoZhWM82+tUhVkjfvn09PDxOnDhx5coVf3//Z8+eRUdHp6WllWMKwahRowDAxsaGiwkGZWLu3LkA0J8zL2TXrl0k//Hjx48cSRSHt7c3kc6Wntm55MmTJ4qKikKhkIcTe0oKkvHQvH+GICKmp6eT5E15tcmnUCgUSslwa2AtX76cFAU8ePCgNK/39vYmeTQ9evTgrw356dNobf1lFnhUFNati2FhuGEDLl/+7TUNG2JMTPnCf/78uXXr1mQTmJ+sqC1btgDAsGHDeNAqGTKkfMaMGdxJxMfHGxoakotvkUjEnRAizpuHAMhBjhflF+NXLCFs3hylXZICA7FjR9y7FwWCbx6WpiZKJCgS4b17uHQpWligQPBtHGf9+jh9Ol67FvbTCfH5+fkk61ZbWzsgIKB8qy0fJEFg0aJFfIr+yPz588mwXT5F8/Ly+vTpAwCLFy+WHYoSGBj4/v37cga9cgWbNUMbGzQzw4kTMSvrlzOwEPHdu3dkaBrDMACwZcsWjoR+XZydnUnb++LQ0NCoVatWkyZNLC0tu3fv7uDgMHny5Hnz5q1cuXLbtm2HDh06ffq0j49PYGBgRETEkSNHSC+zN2/eyPudYUpKChl+zYXt8u7dOw0NDQA4e/Ys68FLQ9u2bQFg69atXAvl5+c3b96czyKJ+fMRAPv25UftX4wfP57sQND0KwqFQqmccGhg7d+/H8o+bu/Ro0dkbE3btm2Tk5O5W943evdG2f7xq1bhokVsGVgFBQV2dnYAYGxs/OHDhwqvtVTExsZWkirCkJAQAKhZsyZH1lJGRkbLli0BwNLSkodNSG9vBMDWrbnWoVR2+DGwUlJSuDaw+vTBVq2QZIVqauLevVi16jfTijQ7cnfHV6/KppWfnz9o0CAA0NLSKuXuBSuQRBKux9j/FHNzc+B3fgUhPz//6NGjvr6+sm2zR40adebMmQrFTU9H2cRhNnJqoqOjVVVVrb9Sp04d7gwsRNy/fz/DMKqqqjVq1EiQzlWkICJiQkICSWHu06ePo6Pj0KFDe/bs2b59+2bNmtWtW1dbW7sEY6tIBAIBP65KKSGGcl8OvBBydSfHzcLLly8DQPXq1X+6r1BByG50o0aNeGu5lZKCGhoIgI8e8SP4hZs3bzIMQ7oE8CpMoVAolFLDlYElHbe3e/fusv7s27dvScGdsbExHwOtmjXDFy++PSWNPzZsQD09bNXqy5eycjkMLIlEQnZyqlevzvNkLtJCWF67grI0aNAAAG7fvs165IKCgu7duwNAkyZN+Mnez8tDLS0EQLnvK+/fvz84OJg8LiwslPU4KDygp6cnfXzs2LF58+bNmjWL3Ru2FStW1KxZ8+zZs7J2jKenZ1JSUvkCNm+Onp548ybevIm7d38xsJYsQUfHLyNYNTW/DLQwMkJHR/TyworcE4lEotGjRwNAlSpVuC4iJqSnpwuFQiUlJfka99Jl8FPX8yPsG1gcEB0d3ahRo+yvLFy4kDsD6/z584qKimQrBQBMTEziZSvAf3uI19y7d+8SXpOenh4bGxsaGvrgwYPr1697eXl5eHhs2rRp2bJl//vf/yZMmDB48GBbW1sLC4tGjRqRjKe/ZPtEypWUlBSSJ/WIVS/k4MGDAKCrq1vuczIrkIu9zVzO0X727JmSkpJAIOC5i/kffyAA9unDn2JGRkbdunUBYNOmTfypUigUCqWMcGJgScftrVy5snwREhMTySa2np6e9EadK7p2RVl7xd0d585lJQMrLS2tWbNmGhoanL+FH9i0aRMAjBgxgmfdH5kzZw4ANG3adP/+/SEhIWy1AJNIJGPGjAEAAwODd+/esRKzNIwejQDo5sabYNHI3pTm5eVpaWnJdz2/Offu3SNJB24s/WasX7+epK+y6EE3b46TJ+P8+Th/Po4e/c3ASk1FQ0OMi0NNTczKwuhotgRRJBKNGzeOFBP5cN8o7tKlSwDQoUMHroVK5uLFiwDQqVMneS3A19fXwsLi0ldsbGwqp4HFTwnh9evXlZWVAWDevHnJycktWrQgiSRxFWhq+V/ixIkTwPasQE9PTwBo0KABr81MS4QUF9vY2Lx9+zY5ObniPcgTEhKqVq0KAMePH2dlheXm6tWrAFCtWjWOkrAKCwvJnEonJycu4pcA6YTFMJLAwE/8KDo7LyP1H1z3o6BQKBRKRWDfwHrz5g0r4/YyMzN79eoFAOrq6twOJ96wASdO/PK4sBDbtEEfn/IZWOPGjZMOu0lISLC1tf306dP9+/fZX/PPiI6OZhhGXV2dzxHLP5Kfn29lZaWpqSktLlBUVDQ1NXV0dPT09AwNDS13iwHSmVVTUzOE4/GR33HhAgKghQWfmkVADazKxrFjx0jOacVbhLi7u5MynKNHj7KyNkKRJYSkTdOBAzhq1JceWOwiFosnTpwIAMrKyt7e3ixH/zfknLBs2TJOVX6Ks7MzcDxmvmR8fX0bNGiw7CvNmzf/bQ0sHx8fFRUVAHB2dibfSUtLI22DDA0NIyMjWVf8tUhJSSFXawcOHGAxrEgkMjExqVRJWB8+fFBWVv6uz5eKioq+vr6pqam1tbW9vb2Dg8OYMWOcnJxcXV3d3d09PT29vb19fHz8/f1DQ0Pj4+MLpMNcEAcOHAgA9vb2cnxTUjp06AAAHFnAa9euBYB69epxXaVYJG5uoU2amMumlHKHnx9qa0s6dz4cGhrKgxyFQqFQyg3LBlZycjIpGWNl3F5BQQHJsmnYsOHu3btzc3PJ96Oioi5cuFDhxX4lJwf79cPu3XHuXGzdGkk1VrkMLFtbW2mKdUxMTMOGDVlbZNkh7WDYPFBlRJokVbNmzWXLlo0cOZJUhsqira3drVu3RYsWnTt3rvRb4rt37yZeGP/NbvLyUFMTAVC+9z6jRo2ys7ObPn369OnTp06dSg2sysCJEyeIh/XHH3+UO8iBAwcYhmEYhvXx8yUYWGIxtm+PQiH7BhYiSiSS2bNnA4CSklKZ+iGWlVatWgH3M09/Csnx4aJoupT8EiWE2dnZ165dkz598eLFT+cUlxV/f3+SCT579mzZWXifPn2ysrICgLp161aGLuNyZPjw4QDQtWtX1mcFkj7uxsbGlSQJa8eOHQCgpaVlZGSkq6tLSkrLgaamZu3atevVq0eiVZJa1OvXr5MkLNZnH0VERKioqDAMc+PGDXYjl5LU1FRS/unv78+pUHY2NmiAALh6Nac6FAqFQmEBlg0s0pPIysqKrfYfEolkxYoV4eHhBgYG0j5HV69eHTBgACvxv/HmDd66hdJpTUlJKNvq9eVLlNl8K45KZWBt2LABAEaPHi2vBRSZJJWRkeHv7+/u7j5mzBhTU9Mf/SxbW1tXV1dvb+/iet6fPHmSjEI/cuQIX2/lX4wYgQAo3w4Jo0aNWr9+/cOHDx8+fHj37l1qYFUSvLy8yK3RvHnzyvHjhw4dIr/b5Wgd+FP690dpre2LFzhmDB47htLGKU+eoJERJwYWIkokEpKXpKSkxHpjPpFIFBAQsHDhQoZhlJSUpPsccuHjx48CgUBFRUWOy/glDCyuuX//PrnvnThx4o/uTGZmpo2NDQDo6em9fPlSLiuUO6TktkqVKm/fvmU9uEgkaty4MQAcPnyY9eBlJTo6mrTlOnfunOz3c3Jy4uPjQ0ND/f39vb29PT09PTw83N3dXV1dnZycxowZY29vb21tbW5ubmpqqq+vT/YnCLq6uh07dpTXO/qRjh07Ans17ASxWExyuxwdHVkMW1YWL14MAHZ2dpyqODsjALZoUZorfQqFQqHImQoZWCEhIQ+lM9gRjx8/HhwcbGdnl5KSUuGFfQ/nBhYb2NraNmrUqFWrVq1atWrWrJl8DayoqCiGYTQ0NORyK1XKJKmEhARvb29XV1d7e3syfVIWfX19e3t74melpaUh4u3bt0lDEzmOQj97FgHQ0lJe+oi0hLASc+nSJfIrOm3atDLlNfz111+kkRaf7WNnzcINGzAjgw+tJUuWAIBQKGSlNDI5OdnLy8vR0VFfX5+cLsg9qpOTE+vpJKXn7NmzJKVFXgtAxKCgINluNUuXLr1165Yc18M/AQEBpG593LhxxVWpZ2VldevWDQBq1qz5/Plznlcod9LT02vXrg0AO3fu5Eji77//BgBDQ8P8/HyOJEqDRCLp0aMHAIwcObLi0T59+hQTE/PPP/8oKSkJhcLw8PCKx2SFf/75h9hqLCZhbd26FQAMDAw+feKpBVWRfPr0iYzC5K6F/MOHKBSiggLy3q6WQqFQKOWhQgbWli1bFi9eLH1qamrKXVMJAwODDRs27Ny5c+fOndOnT6+0BlblycBCxNatWwMA161nfqTcSVJv3rw5fvz4nDlzOnToQKo/pAiFwsaNG6uqqoJMQxO5kJuLGhrIMMhj7/jvoQZWZebq1auk886UKVNK2eXt9OnTZHt//fr1XC9PyqdPKBSisjLy1ijP1dWV/C2XrzlOYWHhnTt3Fi1a1Lp1a4ZhpCeHBg0azJo1a8WKFWU97Kwza9YsAFhNq1DkR0hIiI6ODgA4ODiUXL+WnZ1NcsarV6/+7Nkz3lZYGZgwYQIAtGvXjru/FJFI1KRJEwA4ePAgRxKlwcPDg5TXFZfTXT4cHR0BYNSoUSzGrCDm5uYMw9SoUcPMzKxDhw59+vQZMWLE1KlTXVxc1q1bt2vXriNHjly4cMHX1zc4ODgyMjIlJaUEbzEqKopsCcixDYWUZcuWAUD37t25CJ6Xh6amCIBLl3IRnkKhUCjs8ysZWDt27Dh06NChQ4ecnZ2pgVUa1q1bBwBjx47lU5StJCmRSBQaGurp6enk5GRtbU1uTQ0NDVu0aCGvu1Mpw4eLzczuenjIodvO0aNHd+7ceebMGWnli0gkWrt2Lf8roZSAn58fufofOXLkT7vAnD17lrhXa9as4Wd5hPPnEQBtbPjURDc3NwAQCASHDh0q5Y8kJSV5eno6ODiQfXiCqqqqra2tm5ubbAnYjRs3iMc9atQouYyRatq0KQDcu3ePf2kKIj579kxXVxcABg0aVJruS3l5ef369QOAqlWrPnr0iIcVVgZu3rzJMIyysnJYWBinQsePH5dvElZ8fDw5aZw6dYrdyDExMcrKykKhkOtjWEoKCwubNGlCzn5lQkVFpUaNGg0aNDA3N+/WrdvAgQPHjRs3e/Zs0rFUjj0oZElPTyczH+/cucN68IULEQAbN0a5Vp9TKBQKpQxU1MDq3bv3ga8YGBhwamD9EiWElcrAioyMBABtbW3eLh9DQ0PJdcaMGTPYjZybm0vKEhs1asRu5HJw5sw5sn3Nsy6pXAAAuYy2pJSJO3fukC48w4cPL+Fe+urVq8Tw5X9unZMTAuDKlTzL4saNGwGAYZgSypcKCwv9/f1dXFxIWoH0dsvIyMjR0dHb27u4yuhSHnYu+PDhA8Mwampq8q2Z+m2JiIjQ09MDgAEDBhSUupNNfn4+mSinra0t2xLhv0pWVpaRkRFwNrROFrFY3Lx5cwDYv38/11pF0r9/fwDo27cvF8GnTZsGACNGjOAieFlZs2YN8QpfvHgREhJy586dS5cuHTt2bO/evW5ubgsXLpwxY8bo0aP79u3buXPnVq1aGRkZ6ejoyHb1+g59fX0NDY330raw8oZk73br1o31yG5uqKaGv8GfPoVCofx3qKiB1bNnz91f0dfX/80NrMePH0ubBeTm5lYGl6Fly5YAcOXKFR603r9/X6dOHQAYOnQoF0lSYrGY9LuRe7lHdnZ2lSpVGIaJKcVsSrZ4/vy5lpYWACxcuJA3UUpFuHfvHunF4+DgUOQd9Y0bN0hq4dy5c/lfXvPmCICc9RUpiT179pBhi9u2bZP9fmRkpIeHh4ODAzluhCpVqtja2rq7u78rXdWuv79/yYedI06dOgUAPXr04E2RIuX169fk08HOzi4vL69MP1tYWDhq1CgAUFdX9/Pz42aBlYXp06cDQNu2bflJUTx58iQA1K1bl39Xl0xC1NbW5siFiY2NVVZWFggEcu+hFh4eTmYFlmMuc3Z2dmJi4qtXr4KCgnx8fM6cOXP48OFt27bVrVsXAPbt28fFgsuBNAmr4gNe9+3DQYOQXKLm5GCPHshB214KhUKhcMgvU0I4ZcqUzMxM8vjJkycbNmzgSOg/BtmXmzBhAtdC6enpZmZmANC5c+ey3j+UHrLnuWzZMo7ilx4HBwcA+O72mzuioqJIcsGIESPk2KOaUlaCgoJIRx57e/vv/i58fHyIe/W///2P/4WlpqJAgGpqyNkf60/w8PAgTetdXV19fHxIspVsCoCpqamLi4uPj085bn1LOOzcQc5OfHYxoxDevHlTq1YtALC1tS3f0BKRSDR27Fjilt68eZP1FVYSbt++TYZ1vnjxgh9FsVhMLgx4tkKSk5PJWBhPT0/uVGbMmAEAw4YN407ip4jFYmtrawCYNm0ai2FPnz4NAHXq1OHt/PlTVq5cSczQOXPmuLq6btmy5cCBA15eXv/888+jR4/Cw8Pj4+Oltwkl4OqK1arhnj2IiFlZqKfH+copFAqFwi6/jIFFKR8REREGBgZLlizhVCU3N5dMcW7atCkZF8gRN2/eBAATExPuJEoJybawtrbmQSs1NZWMJO/SpUvluZqklJLHjx+Tvjy9evWS3l3fu3ePNMmaMmWKXBzJ06cRAG1t+Vf+xv79+wUCgZqamtS00tXVHT58+F9//ZWYmFjB4EUedk7ZvHlz69atf59WSpWEmJiYevXqAUCHDh2ysrLKHUckEpHW5mpqauXIZKn8ZGdnk8ZGq1at4lPXy8uLfytk8ODB5G+fU5WEhARVVVWBQCDHrPDNmzcDB7MCJRJJixYtAGD37t0shq0I169fV1VVJRX3xSEUCoVCSdWqWL8+tmiBHTtinz44YgROnYouLrhuHR46hK6uuHIlGhlhYiI1sCgUCuWXpEIG1vnz52V3t6ZPn17xuw4Ku9y8efPkyZPSp8uXL09ISGBXQiwWDxkyBABq1aoVGxvLbvDvEIlENWrUAIDQ0FBOhX6KtIqQ67ecnS22tu4IAK1atcrIyOBUi8IRISEhJB3AxsYmMzPzwYMHpE/TxIkT5TWRYMYMBEC5d/+3tbVVUFBo0KDBihUrAgIC2C1rkh52Ozu7HM5GLa5du1bayPnjx49OTk4cCVF+JC4ujnR0at++/efPnysYTSwWT5kyBQBUVFR8feUwo4NT5s6dCwBmZmZ81tWijBWyhyS9cA+xzDQ1NXmo8SeDRx0cHLgWKpKoqCgyr/nixYusBz979ixphsXdybP05OXlmZqaAkDfvn03b968fPlyZ2fniRMnDhkyxNbW1sLColGjRnp6evr6tQCwhK/69dHVFXfuxD17cMQIamBRKBTKL0mFDCxK5Wfnzp3z58+XPm3ZsmV4eDi7Ek5OTgCgpaXFzyYkucHgv+P1j5A93h07dnAnIRLhwIFoaZnQpElr1p1HCp+Eh4cbGBgAQOvWrclgrHHjxslxnmaTJgiADx7IS/8LJiYmABAQEMBR/LCwMHLYO3XqVHGDo0h69OghbcsSFxdnbGzMhQoFEQsKCh4/fix9+v79+7Nnz1apUsXS0pItc18ikTg5OZmYmHh4eMiOrps8eTK7GS48ExAQIBQKFRQUgoOD+Vc/c+YMyRLiwQpJTU2tWbMmb0WLJAmLYZinT5/yICeLRCLp1q0b+SjhKD5polrCtA3e+OOPPwCgSZMmP02nLSzEjx8xMhKfPMHbt9HbG//+G/fsQTc3dHHBNWu+GFhiMVpa4uXL1MCiUCiUXw9qYP3H4drAWrduHdmvvstXL+gbN26QWkV+5ErgxIkTANCxY0fuJBwdEQB1dfHVKz4a7lI4JTw8vHr16qTxk4ODAz9NlIvkwwdkGFRXR35TMb4nISEBADQ0NDhNCYmIiCANkjp06MBFDiM1sHgjKSmpbt260qdr165duXJlQEAA68VTnz59Wr169erVq6XfrFev3q+bYC6RSEgjqkWLFslrASQJa9euXVxrkX78NjY2vJVmkz28wYMH8yMnZdeuXQCgp6cnHXDEOufPn68MSVhPnjxRVFQUCASsTEYiBhYiBgZi06bUwKJQKJRfD0EJxeSU/wY+Pj7TvhIXF8di5OPHjy9ZskQgEBw9epT0wOKBrl27Vq9e/eXLl2FhYfwoFoe9vb2qqur9+/fJfTjrrFwJ+/eDqipcvAiNGgm5kKDwSUFBQWFhoUQiAYDY2NisrCx5reTevdudO68fPDhMUVFeSwAA8PPzA4COHTsqcrkOExOTe/fu1a9f/969e926dUtLS2NdYv369ePGjRs3btycOXNYD04pGUtLS5LSyBYMw7AbUC4govQxwzAHDx4cMmTI8uXL5bIYhmFcXV0BYO3atbm5udwJXb169dixY2pqagcOHGAYhjshWRYtWqSmpnbu3Llnz57xowgAsbGxixYtAoDdu3eTgRVc0L9//zZt2iQmJh44cIAjiZ8iEokmTZpUWFg4f/789u3bsxi5TRvg67qVQqFQKGxCDaz/Ps2aNZvwFdLVmBUSExMnT56MiNu3byc9sPhBQUGhX79+AECqEuSIurq6nZ2dRCLZtGkT62bE33/DypUgFMKxY2BtzW5sihx49eqVnZ1denq6jY2NkZHRo0ePunbt+vHjR7ks5saNE7dvLzY1vSwXdSnEwOrSpQvXQvXq1fPz8zM2Ng4ODu7evTvrh33YsGHz5s2bN2/e1KlT2Y1M+Y6CgoInX+Fo50DKqVOnhn4lJSWFUy3Wsba2DgkJIY/DwsKmTp16+vRpMvZULgwYMMDCwiIxMfHgwYMcSXz+/JlMAl23bl2DBg04UvkRPT09R0dH/Domjx+mTp2amZk5bNiwQYMGcafCMMzSpUsBYP369Tk5OdwJlcCaNWtCQkIaNWq0YsUKVgI6OEDPnl8er18Pa9bA27esBKZQKBQKT1AD67+Pvr6+5VdkB36VlYMHDyYmJpLHqampFy5c8PLycnV1JU1M+YT4ZXI3sABAUVGxZs2a7u7u2traTZs2HTt27Pbt2+/du5eXl1eRsFevwoQJgAju7jBwIFuLpciNN2/edO3aNSkpqUePHteuXbt9+3bDhg2fPHlia2srlxtj3pyjyrMMQ0NDPz8/jg67kZGRmZmZmZkZmRZK4Y6srKw9X3n06BGnWra2tmu/UrVqVU61/vNIrZDt27eTLFTWmTdvXlxcnJWVFf/XJC4uLmpqahcuXAgODuZB7vDhw9evX9fV1d2+fTvXWv369WvTpk1SUtL+/fu51vqR58+fr1+/XiAQHDhwQFVVlZWYTZuC1N68eROmT4d581gJTKFQKBSeoAYWpbT8+eefsgbW/v377e3t2doTKxPdunXT0dF58eJFREQE/+pSDh8+fObMmZSUFBMTE4FAEBYWdvToUWdn544dO2pra1taWs6aNcvT0zM8PKZMl+sFBTBzJohEsGwZ8H4dTmGfmJiY7t27JyQk2NraXrx4UUVFpU6dOnfv3m3atOnTp087derEdSLJdyQkJLx580ZLS6t169Z86n5HXFxcZGSklpYW6RPMA3Xq1PHz8zMxMXn69GmPHj1EIhE/uhQW0dHROfiVgRy7+7q6ug2/oqCgwKnW70C/fv2WL19++fJl0gcQAKKjo8ViMSvBfX19Dx06pKysfOjQIaGQ74p7PT29adOmIeKaNWu41kpMTJw/fz4A7Ny5k7Sr5xpSebphwwaek7BI8WBBQcHMmTM7derEhYSNDSgrg7c3BAVxEZ5CoVAonEANrP84bdu27d69u/Spo6NjtWrV5LgeVlBUVCRVhGTMs1y4evXq1KlTSQVlREREdnZ2aGiop6eno6OjqalpYWFhYGDg7t27x48fP336KS0t6NAB/vc/OHIEXr4EmeYkAAC3b0P79pCc/OXp8OHg5QVLlwKP5QgUroiLi+vSpUtMTIy1tfX58+elJTx6enq+vr7NmzePiIjo2rVrfHw8b0vy9fUFgI4dO/J/mycLSb/q3Lkzn8uoVavW3bt3W7ZsuWDBAmtra2kmyI0bN5YtW1a+mBMnTjQyMiKPtbS0FixYwM5aKZSKMXLkyNatW7du3ZrPGv8SYBiGYZgLFy5Iv9OpUye2etJpamqampquWLHC1NSUlYBlZdGiRerq6hcvXgzi2AuZOXPmp0+f+vTpM2LECE6FpNjb27dt2zYpKWnfvn38KBJ2784tKGhbr149MiyIC6pVg+nTAQBWreJIgUKhUCgcINcW8pRfifbt28+cOZPUU8yZM6dly5ZyXMzly5cBQF5rCAoKUldXBwBXV9ciX5CRkeHr67thw4bBgwfb2j4AQNmvatWwVy9cvhwvXcKkJDx/HvX0cMyYLz/bqBH+stOuKP+CzKQDgHbt2n3+/PnHF6SlpbVp0wYA6tWrFxUV+pSbswAAIABJREFUxc+qJk6cCABbtmzhR644xo8fDwDbtm3jX7qwsBARq1SpIh0EefLkSY5G0VNYJCUlxcLCQvp0+/btW7du5Ujr0aNHjx49kj49fPhwdnY2R1pc0K5duydPnpDHL1++bNWqlXzXQ3B1dV2/fr30ae3atZOTk8sX6tatW+7u7tKnCxYsePbsGfnTlhckMapv377cSRw7dgwAtLS04uLiuFP5kStXrgBAtWrVMjMz+VGMiEAVFRQI0M8vnlOhlBTU0EAAlPlzZ4G1a9e+e/eOPE5ISFixYgWb0SkUCuX3hmZgUcpA3bp1ST2FoaGhfFfSo0ePqlWrPn369NWrVzxLR0ZG2tvbZ2VljR49mkxW+hFNTc0uXbr88ccfZ86c8fFp9+EDXL4Mrq7QuzdUrw6pqXDtGqxaBX37gp4exMdDr17w9i34+fH8Vigc8uHDhx49ekRGRrZu3frKlSsaGho/vqZq1arXr1+3sLB49+7djBmr3r3jY2EkA6tr1658iBXP7du3QU59uGg52C9KtWrVZNNbnJycuBv72LZt27Zt20qfTpgwoSIdJClSMjIyYr9SkfrBhISE0NBQ6dPAwMCcnBz5/mm7uLhoaGhcunQpMDCQi/ipqankF37r1q21a9fmQqI4evfubWlpmZqayk8SlkQCkydDXh5MmgQ2NgacalWrBjNmAADLOe+XL1+WTgtJT0+/ePEim9EpFArl94Zex1PKgK2tLembExER8ddff8lxJYqKin379j1y5Mi5c+fIMGl+SElJ6dWr14cPH3r37v3nn3+WclB3jRrQpw/06fPlaUwMBAZCUBAEBcHr16CvDwIB7NgB48bBkyccLp7CGykpKd26dQsPD2/ZsqWPj08JHaB1dHR8fHymTVtx6dK6zp3h1i3gdHxWbGzsu3fvdHR0zMzMOJT5GdHR0WQZzZs3l+MyrKysyIO0tLSOdKA6hcI93t7e4eHh5HF6erp8F8Mu1apVmzdv3ufPn+vVq8dF/JkzZyYnJ3ft2nXChAlcxC+ZFStW9OrVa8OGDVOnTi1yP4ZFduyAe/fAwAA2bOBU5wsLFsCePXD1Kjx6BJaWfChSKBQKpSJQA4vyqzJkyJAjR46cOXOGNwMrJyenX79+b968sbCwOHXqVLk3ew0NwdAQHBy+PCUtQSwsoHNn2LaNpbVS5Ed6enrPnj1fvnxpZmZ28+ZNHR2dkl+vra196JB7377g5wcd/9/evcflfP9/HH9VOqdclcgxkVPYDHPMIZJDEQqb077bHPal5jDLMAz72oZt+M1h+9oM341KDjlEhXJa62TkWOQQOXVySEr1++Nj18zM0HV1XfG4//X5XNfl/X593LaPz/W83gc3iYwUV1dt1RYVFSUinTp1Uq+jrBPKAlidO3fWbRkHDx5UCggODg4PD9dhJYBmhYaGqu88Li4uyhQwfTBs2LApU6YoxzVr1ixNUxERET4+Psrxw6OxdMjf379v374ODg7K6fLlywsLC/39/Uvfck5OzpEjR6ysrFauXPmUv5xpVo8ePTp06LB///5ly5Z9+OGH2uvo3DlRFiRculTKZvNPOzsZN07mzZNPPpHt2zXW7Lx585Q1Z1+woBYAdI4phHhavXr1srOzU45tbGyUZdR1qHv37jY2NomJiWfOnCmD7goLZcKETb/88ku9evW2b9+urIGlWZ9+KitXCo865Vpubq6Hh0diYmKDBg127typ/l/mySwtZetW6dZNrlwRd3c5elQrtZWUlCgTGXQyce9hSoCl8zIMDQ2NjIyMjIx08oUQ0J6qVauamJgox8bGxo6OjrqtRxvatWu3+HcuLi66LkdE5P79++fPn1efZmdnl2aV+mXLlqk3mrh+/fr8+fN37dqlpeFdT0PZ6eKLL764deuWlrooKZFRo+T2bRk6VPr21VInjzFpklhby44dsn9/aZsqKChQtmv08vIaMWLEiBEj+pbllQDAS4AAC09r2rRp6qWvHB0dP9H1Jnmmpqbe3t5SJnsRKg9V//3vm717bwwPD69cubI2elGpZPr0P7YjRLlz8+bN7t27x8fHu7i47N69u2rVqk//Zy0sZOtW8fKSa9ekUyeJj9dYVZmZmcHBwaNHj65Vq1ZYWJhKpbp586bGWn8uOlwAC4CuKHmx+tTY2Lg02bGlpWWt35mammqiQP3y4YcfqpcJS0pKCgoKatu2rQ7r6d69u5ubW2Zm5jfffKOlLlaskIgIsbeXL7/UUg+PZ2cnyji5pUufP5srLCxcvXp148aNP/vsMxFp2rRpmzZt2rRp88orr2iqTgCAMIUQ5Zqvr+/atWtDQkK0OqBdRKZPl1WrxMJCpk/3qVtXw423aiXq9VgHDpSrV6VSJQ13gTKQl5fn7e3966+/1q5dOyIiolq1Z1561tRUNmyQgQNl82bx8JDw8Odfj6OoqCg+Pj48PDw8PDwuLk79Lcje3v7GjRszZsyoWrXqO++885ytl05KSkp6erqDg4OuNrxXrF+/Xv1d2s3NrX79+josBngZKEN41M6ePaurSrTnypUrzZs3V46vXr06evRo3dajWTNmzPDw8FiwYMHYsWM1vhLWpUuiLAixbJlo51fCJ5k4UX755b/r1783blx0u3btnunPKtHVp59+mpaWJiKRkZHaqREAIEKAhXKtR48e1tbWcXFxZ8+edXZ21lIv334r//mPGBvLhg3y+6LPmlS9ulSvLiJy65bUqiX37j3YEwflSF5enpeXV0xMTM2aNffs2fPc23SamEhQkLzxhoSGiqen7Nghz/SL+9Wrsndv7KZNX0dERKi3QDI1NXV3d/f09OzZs2fjxo0XLFgwefLkkSNH3rlzJyAg4PnqLA31Ali6nbjXW72rgki1atWeI3AEoCutW7d+eAmtiRMnau8Z4JlUrVo1KSlJOZ43b15BQUFpWvvvf/+rrNOXkJCggeJKrVu3bh07doyJiVmyZMnUqVM12/icOZKTIwMGiK+vZht+Kra20rbt+aio+7Nmzdq1a9dT/qni4uINGzZMmzYtJSVFRBo1ajRlypQhQ4Z8//336nm7lStXHjlypLbqBoCXD1MIUY6Zmpoq30JDQ0O11EVYmIwdKwYGsmKF9OihpU4eqFhRmjaVu3dl61btdgSN8/X13bNnT40aNfbu3VunTp3SNGViIuvWycCBkpsr3t5y6ZIUFj54q6BA8vIe/XxRkSQkyOefS4cOUq2a/N//qdatW5eZmens7Dxq1KigoKBr167t2rVr0qRJyoinDz74YNmyZSIyfvz4r3Sxa4CeLIAFoPxycXHp1KmT+rRPnz7qpdOhVTNnzhSR+fPnl35t8txcycj443T8eJkyRR6Oxa5fl7Kc7z5p0iSVShURERETE/OPHy4uLg4ODm7UqNHAgQNTUlKcnZ1XrFhx9OjR4cOHGxkZjRw5Uh1g2dvbv/fee1quHQBeIgRYKN98fX1FJCQkRBuNx8bK4MFy/77MnStls2+18sOjdq4GGrN58+bdu3erTwMDA0eNGlWrVq1du3ZpZBSAsbH89JOMGCHffivdu8u77z54/aefRL3l5sWL8t13MmCA2NlJy5YyZYocOCDm5lKrVs0lS5akpKScOXNmxYoVfn5+1tbWj7Q/ZsyYFStWGBgYTJw4ce7cuaUv+Jko3w0IsADgyd59993Ro0ePHj26W7duuq7lAXd3906dOuXk5Pzf//1fKZv673+lXj1JS3tw2rq1DB4sD0c9c+bI+vWl7OQZVKpUSRmVPHv27Cd8TImuGjduPHDgwNOnT9epU2fFihWnTp0aNWrUw0u8AQC0xKCkpETXNQDPLz8/397ePi8vb+LEiR4eHq1atVLvHV5KqanSrp1cvy6jRsmKFRpp8p9lZEiNGmJmJlevihb2OYRmfPTRRw4ODhMmTFBOHRwczpw5Y2Jioo2FhF1dxdhYvvpKunSRVaskMVFMTWXHDjl27E+f6dFDevQQNzd5+hK+//77kSNHFhcXBwYGKovOloETJ040btzY0dHx8uXLZdMjAJSNwsLC2NjYDh06KKfnzp0rLi5+7l81KlasmJWVZWxsLCJBQUFbt25dvXq1xmothT179ri7u1tYWJiamtrY2Fj/mUqlUg4qVRpZsaKptbVYW4tKJcrB73tjiogsXCgbNoi9vWzZIiJiYyMxMTJqlMTGPvhAQIA0bSplOf0uNze3Tp062dnZe/fufXiIn0KZMPjxxx+fOnVKRJycnD766KO33367QgXWYwGAssM9F+VbQkJCYWFhlSpVFi5cuHDhQhFxdHRs8bsOHTqoVKrnaDYjQzw85Pp18fISre238xiOjtK2rRw4INu3y8CBZdcvSk9722B98YWMGyeJiSIiBgaya5ccOyaWltK2rXh5iY+PPN+KW2+//baFhcWwYcM+//xzESmbDIv5gwBeVMbGxur0SkScnJxK01rv3r2VBbBEpHr16q+99lppWtOgkydPikhRUVF2dnZ2dvbffczUdNS9e4++aGb2IMmqUkX69ZPevSU6WjZulH79HnygoEAuXnxwfPu2Fqp/Ihsbm/Hjx8+cOXP69On79u1Tv65EVzNmzFCunegKAHSIOy/KsRMnTvTp06egoOCVV14ZPHhwXFxcUlJSRkbG1q1bt27dKiJGRkaNGzdu1apV+/YLXnlF1ayZGBs/vqmMDLGwEBsbEZG7dyU3VxwdxcFB1q2TMn4+8fWVAwckJIQAS69t3rz54u9P2be1/JT9yivSpYt88YUoaxZ//rlYWEi7dhr4L3Pw4MEGBgZDhw7dubPAwKBo3jytT38gwAKAp7Fu3Tr1cfv27du3b6/DYtQuXLgQGBgoImvXru3atWt2dvbNP8vNzc3Jybl9+05Ojklurty8KTdvSm6u5OTIzZuSny/5+XLt2h/h1OLF4uUlHh4PTs+dk3HjHhwfPfps25hoxPjx4xctWrR///69e/d27ty5uLh427ZtM2bMOHz4sIjUrl176tSpRFcAoEPcf1FeXb58uWfPnllZWd7e3hs3blSWHigqKjp58mTC7+Lj448ePZqSkrJmzfLCQjE2FhcXadFCWrSQDh2keXP5/ddNeestycyU2FgxMpIDB2TpUtm1SwoKxNKyrK/L11cmTpRt2+TOHR30jqfUpEmTPn36KMc//PCDtrubO1dee+3BQmya3Uxg0KBBFhaOw4e7ffaZwd278tVXor29AUtKSlgACwDKr9GjR9+6dWvQoEHKCqTPOsg9L+9BpFVQIDt3iog0bCgDB4p6BHD9+rJ584NjXWyTK9bW1hMmTPj444+nT58eGBg4c+ZMZVvJWrVqTZw4ccyYMdobbQ0AeBoEWCiXbt682bt37/Pnz7du3XrdunXqhTONjIxcXV1dXV2HDx8uIvn5+UlJSUePXti/3zguTk6dkuPH5fhxWbNGRKRiRWnRQlq1EuXbtKmpLFv2x09/ulqCqkYNadNGDh2S8HAZMEA3NeAf1a1bt3Pnzsqx8d+N69OcSpXkk08kIECGD9d8497eHX/6Sfr3l0WLJC9Pli//I9jVrOTk5GvXrtWsWbNu3bpa6QAAoDXff/99eHi4nZ3dokWLnq8FCwuxsJCqVUXkQYAlItOnS8uWUlysoSpLzd/f/4svvjhw4IDyM1Xt2rWnTZv21ltvlcG/9QCAf8QuhCh/CgsLfX19Dx8+3KhRo+3bt1tYWPzdJ83MzNq2bTtq1KDVq+XECcnNlX375OuvZdgwadxYbt+WvXtl/nz59lsRkZkz5csv/7Sps64oexEGB2umtblz54aFhalPW7durZl2UbaGDpXmzbXVeM+esmmTmJvLd9/JqFFa+SJx+fLlefPmiYieTIQBADy9jIyMDz74QEQWL15cpUoVDbZsYSH/+Y8UF4uBwZ+mxhsZaevXlCeIjIzs2rXrrVu3rKysTE1Nv/7665MnT44cOZL0CgD0BCOwUM6UlJS88847ERER1apV27FjxzPtOVixonToIOolVq9elbg4iY+Xxo1l5Uqxs5PAQJkwQd59VyuVP70BA2T27JIbN1Lu3q1pbm5eytYuXrxYU1k8SUREfvvtt1I2iI4dO1o9NEJv7NixJg9vraRR//uffPut9OolLVrIjh1SVKSlfsTTU8LDpXdvWblS7tyRNWs0sMZWUVHR4cOHw8LCtm7dmpiYWFJSUq1atUOHDl25cqWq8hM8AKA8GDt2bHZ2du/evd98802NNDhp0h/HPj5y546IyIEDf7z41Vca6eeplJSUhIWFzZo1S5kwWL169Zs3b967d8/V1dXMzKzs6gAA/BNGYKGc+eCDD9asWWNtbb1t27baz7f72u+qVBEvL5k164/l0keOlLQ0iYnRQJ2lUbu2NG7cKSqqQXh4uI5LweP07NnTzc1NfTpz5kztLYoRHS0zZsiSJSIipqby98MNNaBjR9mxQ6ytZd06GTJECgufs51z584tX768X79+KpWqZcuWn3zySUJCgqWlpaenp5GR0fnz57t163blyhWN1g4A0Jaff/5548aNNjY2y5cv13UtmhcZGdm6deu+ffsmJSU5ODh89tlnqampU6dOFZEZM2boujoAwJ8QYKE8Wbp06ZdffmlsbBwSEvLqq69qvH1DQ1m6VL7+WuMNP7N+/bxFJCQkpJTtFBcXi8icOXPa/K5Ie2N4oAV79oiIlNmi5x06SFSU2NpKUJD07y9/3QT979y9Kzt3ypw56Y0aNapTp8577723adOmW7duNWvWbPLkyVFRUZmZmeHh4fHx8c2aNTt27FinTp0uXbqkzUsBAGjAjRs3xo8fLyJffvlljRo1dF2OJinRlYeHR1xcnBJdnTt3LjAw0MzMzN/f38HB4dChQ7t27dJ1mQCAPxiUlJTougbgqaxfv/7NN98sKSn58ccfhw0bptnGPT3lP/+RFi1ERMaOlYwMCQ3VbA/P5ty5c87OzlZWVlevXn2OWYQ3btzYvn17cHCwra2tmZnZ66+/PnToUOUtGxub/Px8TdcLrSguFgcHycyUc+ekdMMNn01cnHh6yu3b8u230rChtGkjInL3rsTEiKfnnz559qxERkpkpISHy61bUrFiSX6+lYmJQZcuXby9vXv27Pnw9FVFdna2p6dnXFyck5PT7t2769SpU1aXBQB4ZoMHD16/fr27u3tkZKSB9vapLVuRkZHTp0+PjY0VkcqVK0+aNCkgIOCRx60vvvgiMDCwTZs2hw4d0lGZAIBHEWChfIiOjvb09Lx3797ChQsnTpyo8fb37pWWLR/sPJibK0eP/rFUlq60atUqPj5+06ZNffv2fco/cunSpdDQ0JCQkP379ytjrypXrty3b98OHTqMGDFC+YyZmRkBVnmRmCgtWoizs5w5U9ZdJyXJuXMSHS3ffy/HjknNmnLpknh4yPHjcvu27N4t4eGyc6ecPfvg84aG8tpr0qOH9OqV3KpVwwpPXEArJyenR48esbGxtWrV2r17N5sSAoB+CgsL69Onj6Wl5ZEjR5ydnXVdjgbs379/+vTp0dHRImJvb//BBx/4+/s/djugO3fuODs7X7t2bceOHT169CjzSgEAj8EUQpQDx44d69ev37179/79739rI70SkfHjJT39wXFqqgQGaqOTZ+Pr6ytPN4swPT190aJFHTp0qFWrVkBAQExMjImJiZeX148//piSkmJY9rv4QEPKeP7gw5o3l379RES6dpWAgD9enzhR7Oykb19ZtkzOnpXKlWXIEFm7Vq5ckbg4mTNH2rZt8uT0SkQqVaq0c+fOtm3bXrhwoUuXLikpKdq8FADA88jNzX3vvfdE5PPPP38B0qv9+/e7u7u7ublFR0fb29vPnDnzzJkzgYGBf7eZtaWl5eTJk0Vk+vTp/N4PAHqCXQih7y5dutSzZ8/s7OyBAwcuUdayfjkMHDhwypQpmzdvzs/Pf+wmOBcvXgwNDQ0ODj548KDyaGVmZtatWzc/Pz8fHx9ra2vlY2PGjLGzs1P/qfXr15dN/Sg9HQZYagMGyMqVsmXLgwm29vZSVCQtWki3buLlJe3aPec25zY2NhEREX369Nm9e7ebm1tUVJSrq6tmKwcAlMb7779/6dKldu3aKTFW+bV///6ZM2fu3r1bROzs7MaNGzdx4kT1Y9ITjB079quvvkpISNixY0evXr20XykA4B8whRB6LTc3t2PHjkeOHOnUqdPOnTu1t9fbq6+Kv78oi5OmpspPP/1pL2ddee2115KSksLCwry8vNQvXrhwYePGjQ/nVubm5l27dvXz8+vXr1/FihV1Vy80qahI7O0lJ0fS06V6dd3UMH68tGwpzZuLj49s3y59+8r+/WJgICqVZtrPy8vr27dvZGSkg4NDZGRk06ZNNdMuAKB0oqKiPDw8zMzMfvvtNxcXF12X81R69+49c+bM119/XUTOnz8/YMCAr7/+etasWVFRUfJ7dDVhwgQbG5unb/PLL7+cNGlSixYt4uLiXpglwACg/GIEFvRXfn6+t7f3kSNHXF1dN27cqL30SvHrr5KaKiJy5YpW+3kGvr6+SUlJISEhXl5e58+f37Rp02Nzq/79+1spy3fhBZKUlNqs2T1DwzrVqz9+dkOZcXWVfv1kwQIREVtbTbZsYWGxdetWPz+/sLAwJaRu1aqVJjsAADy7mzdvvv322yUlJXPmzCkv6ZWI3L17V73VcnFxcV5e3uzZs6Oiomxtbf39/Z81ulL8+9//XrhwYUJCwrZt2x7+NREAoBMsjgP99emnn+7bt69mzZo7d+5UaWrIx9+bMEHmzZN582TcOG139bT8/PxEJCgo6LXXXnNycho/fvyBAwesrKzefPPN0NDQzMzMsLCw4cOHk169kKKiNsTENGnQQCuLvj2rGTNESzuJm5qahoSE+Pj4ZGdnd+/eXdkTCgCgQ4GBgRcuXHj99dfHjx+v61pKZfbs2XPmzElLS5s1a9ZzpFciYmZmpqyENXPmTKatAIDOMQIL+uLSpUt79+4dMmSIcrp9+3YfH5/z588HBgZW19UEKt1JS0vbsmVLcHCwiBgaGiYlJVlYWLi7u/v5+Q0YMMDS0lLXBULr9uzZIyJddLoCVo0aoqyfZmUlX38ta9dqpRcTE5P169e/8cYboaGhnp6eO3bsaNu2rVZ6AgD8k717965YscLExGTlypVGRka6LufZvPXWW8ozUkFBgYi0adOmTZs2pWxzzJgxCxYsSExMVPZk1ECVAIDnxQgs6IsLFy6sXLlSfRoaGnry5MnVq1eXzdLO9euLep10CwupV68M+nyM48ePz549u1mzZs7Ozsp4KzMzszt37nTr1i0rK0sZb0V69TK4f//+wYMHDQwMOnXqpMMyXFykbt0Hx717S/v22urIxMQkKCho6NChubm5Hh4eSngHACh7p0+fNjEx+fjjj5s0aaLrWp7ZqlWrEhMTlbBJU22amZl9+OGHIjJr1iwGYQGAbhFgASIiQUHi5PTguFEj+fHHMu392LFjs2bNatmypaur68yZM48ePapSqYYNG7Zly5b4+HgRiY+PZ+nQl8qvv/5669atRo0aVa1aVYdlrFsnx48/OC4okDlztNiXkZHRqlWrRowYcefOHS8vr8jISC12BgD4XXR09N69e9Wnt27dOnjwYGBgoO4q0jujRo2qUaNGUlLS5s2bdV0LALzUmEIIPXLx4sWFCxcqx8nJybqdPFUGjh07FhwcHBQUdOLECeUVlUrl5eXl5+fn6elpYmKivNikSZPk5OQ9e/Z4enrqrliUKX2YP1j2jIyMvv/+e0NDwx9++KFPnz6bN2/28PDQdVEA8II7cOBAUVFR586dldNvvvnmjTfeMDY21mlR+sXMzCwwMNDf3//jjz/u06ePoSEjAABANwiwoEdMTEyqVKmiHJubm+u2mOdWXFxcUlKiXjbi/v37FSr86X80Jbdav379yZMnlVdsbW179+7t5+fXo0ePvz4y+vr6Jicnh4SEEGC9PPQnwNqyRc6eFREpLCyL7gwNDVeuXGllZbV69er09PT169cPGjRIeWvBggWDBg2qWbNmWdQBAChvvv/+e/VjZI0aNbZs2aLBxkeOHPn5558nJydv2rSpf//+GmwZAPD0CLCgR6pUqTJ06FDl+OHR7OXL8uXLz5w5ox5K1rp16zVr1jRu3FjJrdatW3fq1CnlLTs7u169ev1dbqU2aNCgWbNmbdy4cdmyZY9kYXghFRQUHDp0SOcLYClsbMTBQUSkoKCMejQwMFi0aNGECRP27NkTExOjDrBCQ0Pd3d0JsABA46Kjo9XHOTk5OqykNJzUi0GIGBsb19PogqampqYfffTR2LFjZ8yY4ePjwyAsANAJvgwDWnfw4EEvL6+0tDTl1NHRsX///r6+vm5ubk+zv0/Dhg0bN258/PjxPXv2MKPqZZCdne3t7Z2ZmWlvb6/rWqRTJ/HxERHJy5PJk8uoUwMDgzp16rCUOwCUDQcHB/WS7eoVDPCId999d/78+ceOHQsNDfX19dV1OQDwMiLAgr6wt7fv2rWr+rR169YP/5JWrtnb26elpdnb2/fs2dPPz69nz57POpDK19d39uzZISEhBFgvsBs3bnz22WcLFiyoUqXKunXrQkJCtm7d6uXlpeu6dOnAgQMTJ05Ujs+dO6fTWgDghdWoUaN+/fopx5MmTdJtMXrLxMTko48+2rZtW4MGDXRdCwC8pBj+Cn3h4uIybdo09enIkSPbt2+vw3pKY+3ata/97sSJE/Xr14+Njb169erq1au9vb2fYxqg8kNfaGjo/fv3tVAv9MKdO3ce3vb7yJEjx9VbAOpIu3ZSo8aD4woVpOwX/XBycvL+na2tbVl3DwDAQ0aNGnXr1i0XFxfldO/evVOnTtVtSQDwUmEEFqB5Q4cOVa+B1aJFCxF5/fXXS9Ng06ZNGzVqdOLEiZiYGHd3dw2UCDwFf/8/jk1ldI5bAAAUMUlEQVRM5LvvyrqA6tWrq1eyt7a2LuvuAeAl8OqrrxYXF6tPBw0aZGlpqcN69Nxvv/2m/uvKyclRLxABACgDBFhA+TBgwIC5c+eGhIQQYL3Arly58vbbbyvHSUlJb7zxhm7rAQC88Hr16vXw6bx583RVCQAAT0aABZQPvr6+c+fODQ0NXbJkydMs/Y7ySKVSBQQEKMfLli3TbTE617RpU5VKpT5988031fujAwCgK+7u7souhFlZWc2bN9d1OQDwEiHAAjRsxIgRD69UtWPHDo2s3fPKK680aNDg1KlT+/bt69y5c+kbhB4yNTV99dVXlWPCmlatWrVq1Up9Om7cOB0WAwCAYvv27ebm5iISFha2ceNGXZcDAC8RFnEHNMzS0tLGxkZ96uDg8Byrtj9W//79RSQkJEQjrQEAAOBZmZmZmZubm5ubm5iY6LoWAHi5EGAB5YayF+GGDRuKiop0XQs0T6VSTZgwQX3arVu3jh076rAeAAAAANAfBiUlJbquAcDTcnFxSU1NjYmJcXNz03UtAAAAL5ewsLBevXopq5Fevnw5PT29lDtNAwCeHiOwgPJkwIABwixCAAAAXfD29lbvpVOtWjXSKwAoS4zAAsqT+Pj4Vq1aOTo6pqenKzvgAAAAAADwwuMLMFCetGzZ0tnZOSMj49ChQ7quBQAAAACAMkKABZQz7EUIAAAAAHjZVNB1AQCezbBhwxwcHPz8/JTTkpISAwMD3ZYEAAAAAIBWMQILKGcWL15crVo1Jycn5dTc3Fyn5QAAAAAAoHUEWAAAAAAAANBrBFgAAAAAAADQawYlJSW6rgHAM3j33XejoqJUKpVyevz48fz8fN2WBAAAAACAVrGIO1D+zJ07d8iQIcqxmZmZbosBAAAAAEDbmEIIAAAAAAAAvUaABQAAAAAAAL3GGlhAOZOVlWVqamppaamcXrhwoVatWrotCQAAAAAArSLAAgAAAAAAgF5jCiEAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYAAAAAAAD0GgEWAAAAAAAA9BoBFgAAAAAAAPQaARYeyMjIOHDgQHFxsbY7unbtWkJCwv3797XdEYAX1fnz52NjY8ugo0uXLiUmJpZBRwBeVJmZmQcOHMjPz9d2Rzk5OQkJCXfv3tV2RwAA6EoFXRcAfREcHPz+++/fuXMnISEhLS1t+PDhWuooKCjI39//2rVrlStXVr947969H3/88eGPOTo6ent7a6kGAOXa0qVLV6xYkZOTEx4efufOnQEDBmipo2+++WbhwoX37t3761u3b9/eunXryZMnjY2NW7Ro0b17d0NDfhMC8Kg9e/b4+fmlpKTcvHnz119/HTNmjJY62r1794ABAw4fPvzKK68or/z666+HDx9+5GMGBgYjR47UUg0AAGgVARYeFRISEhYWpr0A67HS09NHjx7t6Ohobm6uvNKzZ08CLABPtnLlyoyMDO0FWH8nNja2f//+165da9iwoYWFxZw5c6Kiotq3b1/GZQAoR3bt2vXJJ59oL8D6q+jo6OXLlz/8yvXr1wsLCwmwAADlFAEWHrVo0aJFixaVcaeXLl0SkbCwsBYtWpRx1wDKr+Dg4LLvNDMz09vbu1q1anFxcdWqVRORW7duVaxYsewrAVCOTJkyZcqUKWXZ4+TJkydPnqw+LSoqatCgQbt27cqyBgAANIgAC486cuRIRkaGp6eniNy/fz8qKurUqVMmJib169dXvraZmZklJycnJibevHnTxcWlW7duRkZGeXl527Zt69WrV05Ozs6dOwsLC7t06VK/fn2lzcLCwqioqNOnT1eqVOnUqVN/7TQjI0NElK+CAPCUYmNj792717FjRxHJz8+PiIg4c+aMlZWVs7NzVlaWr6+viMTFxSUnJ+fn5zds2LBz584GBgaZmZm7d+/u37//uXPnIiMjK1So0L1795o1aypt3r17NyIiIi0tzd7e/ty5c3/tdOXKldevX9+wYYP6lkV6BeAfnT59+sSJE3379hWRkpKSmJiYo0ePGhgYNGzYMCsrq1u3biqVKjU1NTY2Nisry8nJqXv37qampsXFxRs2bOjSpUtJSUl4ePitW7c6dOjQrFkzpc3i4uLo6Ojk5GRLS8vH3q8eFhoaeubMGZ3k/gAAaAQBFh61YsWKzZs3p6ennz171tvbOzU1tVmzZoWFhWfOnLl9+/bly5e/+eabBQsWuLq6WlhYJCQkNGzY8MCBAzdu3Bg4cOCYMWPWrVvXpEmTixcvBgQEbN261cPDIzU11dvbOy0trVmzZgUFBampqX/t9MqVK0ZGRra2tmfPnjU1Na1evXrZXziAcmfevHkZGRmxsbFJSUk+Pj43btxo1qzZ7du3U1NTCwoKioqK/vWvfwUFBTVp0sTIyCg+Pr5z587h4eGnT58eOHDguHHj/ve//zVp0iQ1NXX8+PExMTHNmzdPSEjw8fHJyspq1qzZrVu3zpw589dOIyIiqlev7ubmVlRUlJ6e7uDgoJ77DAB/Jzg4eMaMGUVFRdeuXevbt298fLxya0pNTc3NzY2Pj//ll1/Gjx/v6upqY2Nz+PBhe3v72NhYGxubgQMHvv3225s2bWrQoEFmZmZAQMCPP/44ZMiQK1eu9OnTJykpqWnTpgYGBo99vnrYl19+2bVr1+bNm5fN9QIAoHGsOIvHKykpGThwYG5u7m+//RYXF3f48OH58+crb40dOzYjIyMhIWHfvn3R0dFJSUk//fST8lZ8fPzx48f37dt3+vTp2rVrL1iwoKSkxM/P786dO0eOHFEWE/3ss8/+2t3ly5dFxNHRsW7dujVq1GjWrFl8fHyZXSyAcu3evXs+Pj5WVlanTp06dOjQ0aNH1bNmZs2adfXq1djY2IMHDwYFBUVEROzatUt56/Tp02fPno2JiTl58qSpqenixYvz8/N9fHwqVap0+vTpQ4cOJScnT5gw4a/dpaamVq1a1d/f39ra2snJyc7O7sMPPyyDLVwBvBjeeeedEydOHDx4MCkpKT4+fvXq1crrgwcPTk9PP3z4cHR09OHDhy9evLhs2TLlrX379v36668HDx48ceJEmzZtlEept956KyUl5ZdffklMTExISPjhhx+e0On+/ft/+eWXSZMmafvqAADQHgIsPF5SUlJCQsLUqVMbNmz4yFuOjo4qlUpE7t27V69ePQsLC/WswDFjxjg6OoqIiYlJy5Yt09LSlPDr448/Vk8nfKyAgIBVq1YlJibm5ORERUXl5eX17NkzOztbOxcH4IWya9euCxcufPrppzVq1Hjkrdq1a1tZWYnI3bt3lZ251PerCRMmVKpUSUSsra1dXV3T0tJ27NiRnp4+b968Jw8CzcvLS0hIuHnz5qZNm44ePTpmzJj58+d/9dVXWrk2AC+WjIyMbdu2+fv7t2rV6pG37OzsqlSpIiIFBQWVKlWqUaOG+n41fPjwunXrioihoWGbNm3S0tIuXLiwc+fO8ePHP+XioQsXLmzQoIGyQAQAAOUUARYe7/Tp0yLy2muv/fWt9PT0d955p3LlymZmZra2tnl5eY/dY97Y2Pj+/ftPaOdh1atXHzp0qJOTk42Njbu7+6JFi27cuBEWFqaJSwHwglPuM4/9Fnfq1KlBgwapVCoLCwtnZ2cRyc/P/+vHTExM1Perf/w2aGdn5+7u/uOPP3p4eDRp0mThwoWurq5r1qzRwJUAeNGlpKSUlJQ89rkoOzvb39+/WrVqpqamtra2aWlpT3i+SklJkad4vlJ3umXLlsmTJxsa8uQPACjH+GcMj2dpaSkiJSUlj7xeUlLi6ekZGxu7bt26jIyMrKwsZQjDk9t51sk1derUEZHMzMxnKxrAS+nv7jO3b992d3dPT0/funXr1atXld1O/7Gdv973HlG9evX09HT1qYGBQc2aNbOysp6ndAAvmSc8F/n5+W3evPnbb7+9dOlSVlZWgwYNntCOMrb0KZ+vvvrqK3t7+yFDhjxXyQAA6AsCLDye8th04MAB9SvJyckicv78+ePHjwcGBnbt2rVq1arW1tZPfnhS2jl48OAj7TziyJEjeXl56tPdu3eLSNOmTUt7GQBeAn+9zxw9elREEhMTL1++PGfOnPbt2zs4OCjfG/+xnYfve0o7j2jXrt3p06d/++035TQnJyc2NlaZnwgAT1avXj0jI6NDhw6pX1Gei+7evbtnz56xY8d6eXlVq1ZNpVI9+fnKxcXF0NDw4XYee78SkaysrNWrV48bN87MzExDFwEAgG6wCyEer379+l26dPn000+rVKnStGnT7du3KyuJ2tnZmZmZbdmyxc3N7eLFi59++unNmzef0E7jxo3d3Nxmz55tb2/v6uoaFha2cuXKRz6Tn5/fu3dvKyurcePG1alT55dfflmwYEHXrl27du2qxSsE8KJwc3Nr3LjxBx98YGpqWqdOnf/973+bNm0yNDSsXr26oaFhSEhIvXr1Tp8+PW3atCe307lz5wYNGkycOLFChQq1a9des2bN9u3bK1R49B/KsWPHLl26tE+fPlOnTlWpVPPnz799+/ZHH32ktesD8OKwsbEZNGjQ0qVLnZ2d27dvv2/fvjlz5oiImZmZnZ3dzp07BwwYcOPGjUWLFqWkpDwhGbe1tfX19V2yZImTk1Pbtm2jo6Mfu0mOiHzzzTdFRUWjRo3S1iUBAFBWGIGFBywsLBwcHAwMDKytrStXriwiwcHBXl5ekydPbtu2bUREhL+/v4hUrFjxhx9+2Lt3b506dfr27du7d+/Bgwebm5sbGhqqVCpTU9OHG7SxsRGR0NBQT0/PiRMntmjRIioqau3atc7OzkZGRupPmpmZRUZGNm/efMaMGb179161atX777+/ZcsWAwODMv9rAFAOVKxY0cHBQUQqVapkZ2dXoUKF8PDw119/feTIkW5ubidOnPjXv/4lInXr1l28ePHatWtr1649bNiwgICALl26mJmZVahQQaVSGRsbqxu0srKqWLGisbHxzp07W7Ro8e6777Zu3TolJeW7775TZjQ/zMHBYe/evQ0aNAgICBg6dGiFChV27tzZrl27svwbAFBemJmZOTg4VKhQwcrKSlmj/dtvvx0xYsS8efNatWq1du1aZWdAAwODtWvXpqSkuLi4eHh4NGzY0N/fXxk3qlKpzM3N1Q2am5sre+msXLly6NChc+fOffXVV9esWbN+/XpnZ2cTE5OHey8sLPz5559HjhypdA0AQLlm8I+LfQAlJSUGBgZLliwJCAjIzMy0tbUVkaysLBsbm4dzqKds58mfKS4uZoVRAM9Nuc9MmTJl8eLFysTkkpKS7OxslUr1TJn409yvhFsWgFJQ7jMbNmzw9fU9evRokyZNRCQnJ8fS0vLhhP0p29FamQAA6AumEOKfKU9FycnJtra2SnolIuqDZ23nyfgqCKA01PerevXqqV/R0v1KuGUBKAX1/crQ0FDZJlVEnrw3zhPaAQDghUeAhb/VrVu3Bg0atGvXTqVSxcXFrVq1auzYsbouCgAeVVhY2K5du06dOrVq1crKymrPnj3bt2+fP3++rusCgMd44403TE1Nu3btam9vn5ycvHDhQj8/PwsLC13XBQCAvmMKIR6vuLg4LCzs559/Tk5Ozs7OdnJy6tu3r7K2sa5LA4A/KSwsDA4ODgoKSklJyc3NrVu37ptvvjlq1ChGJQDQQxEREWvWrDly5Mj169dr1Kjh4eExbdq0h1e5AgAAj0WABQAAAAAAAL3G4h0AAAAAAADQawRYAAAAAAAA0GsEWAAAAAAAANBrBFgAAAAAAADQawRYAAAAAAAA0Gv/DwAtIhSHTqRgAAAEvHpUWHRyZGtpdFBLTCByZGtpdCAyMDIxLjAzLjUAAHicnZdrbBRVFMfPzOyj7b46291uH7tl+6Dvx3bbbbsNbm/TD67GlviFKGAFUz6ATQMJoBCMmFikpVhiRWOxEUVomwo0KQjBtDurhPpKQIwQIymaiK9IjKnSgDW6c05rDJ82Z5K5+e/p+d1z5t7/3N3+NnNyDhKXNXFLQFdz4o4k7r2SKvv1eJUhMfrbumv1jGp9qNEHf0BJjI88VNuof8I/+oM4hqSwSd6QUMoS628jVk6KNWNZZQntIFRJsqyOGparYrzakBxaUJRQ8n9sHbJGTtl6RE0cNISomYM2IJqSFJqC2yMtb89qWuNU1tZiTnUai21C1sJiw8haGWxbbQBZG4ultbKzWDKkg8WSIdNZLDlSZbFkSSeLJU9mJMXe99rTUrlYZcmSbhZLlsxMsmWdlZct2UFb5GHVJTtnserS9mZzlpl2NyfJlnV06cBpC9JLlMtB6R3yclDyhY+D0vbkJblMBQklLZ+uHeTkFUmx95+u1LI/KVaSS//PRmml8lks1S1gsbRWhSyW7FjEYsmPK1ks7VExi6Ujo4TF0pFRymLptS9jsNGlb7FyFku+qmCx5KtKFku+qmKx5KtqFku+qmGx5KsAiyVf1bJY8lWQxZKv6jjs0sFez2LJVyEWS75qYLHkq0YWS75qYrHkqzCLJV81J8VaZAkUGQyKQTYawCiByQBmE5gNkCJBqgxpqWBJg8QvaasFbFaw28CeCg4rpDtATQenChlOcGWAywFuFTLd4MmELA9kOSHbAznZkJsB3lzweSHPBytc4FcgX4ECIxQaocgEK01QbIYSM5SmQZkNyu1QkQ6VbqjK1n861ORAIAdqcyGYC3VeqPdCyAcNPmjMg6Y8COeBy2iUZMVgVEwGsynNYrXZU03pqjPD5TC5Mz1ZTtWjPyVeze7eidjulzs1/cPd769o77XMxHS9uXtSE10fzeh6i/yxNhzrbtH1SfuCZj3uR90zsKgNfrUe87P+cMYPh7Zj/PI5OT6lKULXYxtntbVND+D87um9WtlRG+afal+nyX/dQW2fW4gpu0yYc2FXb2zVnk0YP3P1i9iqqT/1f45Bika10dlinL/dfitSeHY/5hx8s7clZasX2duVBaL/6RLUnifXicpjZzBnOBgSc2bHtK5/HJ1oqb5jwTm3PB4V8MLzmJ9yY0i0RnpR+3ZMisGnqOebnSMiMPwpzrOt6FuhdkYxvm96UTTvp/4vdvWI8Q8OY2/PfDYkPlnw4LMPdE2KaXUT6rf//lx87X4D9TcjkZap8TjmB62XtVfHzRg/vXBEu3T+Q4zHfzHG74WcWGvjW2p8zVgEa1kGvPF3+67is/xUVRJ37/wO88s71HjF4mqcJ9x5Szt0vgb1ry392o7XqWftRiR27uh1zH9ue4+2YVbCnEvx7Mhi32bMESUOsbv9BOrTzfPiYvgQxY+rrQ/urEd9IHBN/FD4IvbTPmFtPTbWhHp9bESseeIgru2Vh/PFPw4Dzn9vz1oxX/Yo6m2PXRCRA9PYwyvX+8R8/iDG9/1+TQzdrEA9uvWEuH3qLOoj/fPipbvPon7/tZ/Fl+/EUGf+C7rz5JnuzRg2AAADfHpUWHRNT0wgcmRraXQgMjAyMS4wMy41AAB4nJ2Yy6okNwyG9/0U9QJjdLMkr+eEDAyZQBZ5h0CWeX8i2XVxIAN91PSivlPlv2TdrD6vIz9/fHz/65/j/tDH63V0P5SOA/73O8Y4/iQAeMXjX7CxAOQVNzGT1IAWd+H4+vfPJPbvVNHWyWHpiSvvKsfbKr11ZMoraOyom8qP91W0UYfTgkHiNVusGUFfa5WsV1V8EK4duZLWVEZDl3Pt6DxqKt5Qx1xLDboXbQnvMlheUdiiu8rv76tIA+LTL73PmBdsiYylaUFk3aBRjFGsZe1rRwiIVRUQ8jPSQ6WqojxOb4iNYqS5IY3TAu1Y80taILMf5N50VndBJf3CvrwrIrXOEBnbo00tFcVe88uR+WJ2dinEWtaFLc54dilg2W15v0sd2XevXENWq+4IeXapiPkYVNyRRIcDXXWJyl7bUXbvGd/ZGUatjsKWgeYrRt2paIvFCpGzFla/Kqn4cLz6ixYrgOMkWVmC2YFr51HGCFfPpsYmxZrOGBEvq7qNYr5oE1jekGbOxQqAZrJONcxzf/fuJ06SsMWAll8Qxx7pb++rSHOb/SVtIeSaijde8Y0KIP9PjD6hMvIUktVfwkNeVTGXs0shUEnlC+YZ4Lb8YopStQXOaY5blEJxRxbVMztDRDoKQGsq0pjmdDg7g1BNBW4L4sS+Z7PPqmRn6NdERlbzS54ffVZA6KkMqKlExrLO3O0tyqioYk0BxvJzB8OayrgyNurIqzUdXUoHX/MLU62mD2828JzrrNoZ8lSjcWYJRSFVY9Tp6nWgXOsvOQXh6tlRjeq1CoiTxIl5VYA4FHM3qhFM15UYjZqKNsOVsTEdei/6pTeCFd/e1KxW01kBuOYNjukBit61RmPlS2/DvWRLbCXejgtk8gl9coAG6OTzju5rbL/jkx947oxtDcL2nhhvk0+g5AeOB/jiBEm+oCdv8Kjp/pglX+DJF4zkEwiSL8DkBx6BGKK3NZx8gSRf0JMf2KR1v2PJF/j+0pF8Qkw/dAvED2O+H4vfxnS7Kgvuls7e9kCfwTtBd7AtcryHMZvAbUFOPw/gFqw4I58oxICPd+hjwn58HePO46o4EZ9ti6UbLvAdxgYdNod03IE273TeQTZXReFvoOnHC2wHf+C34/j67dcJ898RmH/55cfH61+1Qv7aETlEsgAAAnV6VFh0U01JTEVTIHJka2l0IDIwMjEuMDMuNQAAeJxtU0tu3TAMvEqXL6gsiH8SXnqT1esBgtygR8jhO5SDNgG6sCGMSGo4HL69vl/0vB7Px9vr+8u1//vX3/Pii67Pm3+n+/+U6/Hra8alj0v+5n6/+I6i1O+Xzn7y17D/Ht+eP9+/sfrx8eDJ4hHjsEnl5eOUSbLUxyGzitnGqdN5OY1DJ7kkEJtGKuPgWVak44y5lqp1ErJjI75W7SRbsayRrCRk0Sz2JeOsSYtTu05SBY/Tp5fojlnCgqycUZQ8jjWDCVjzKYrcQZaMAzgrh2cjStQxPE2kqks7WYEQKqrcj6mqAFmTbJFJs3at5rhwFxK2CXg2yT6hejaDLMdxYy7FOhAflU2h+amZ+cBdqhUgiMElhSiHXni7oWBLHzwXR3SQ4iRrlzeTLfjR+narwCTJuTN9GkdtZpouvCFketxzcDx9Hi0yYyJN1tm7zSOnOJTvMKhtDbXypLRVRcefqcHLuifnMMr7AVvcDaDZqNqQxgIhnoSRyW4gQyrRtzGx39W3AkgzKZUNRSpVP9gzX02fWu0MJIaT8mZKYJqtDkS6ia4kyyGTtSI2TYJhDTHQ229Nld35Nlbt/nQKL7ntqFs+3Im3rblbpxuCPJ0dqNQGEaXlYE3iDr3OLY5Vj9QwyWpbpRBv3ZZo0b0wAW6IAfeeqDYLrMua8CSt24y80DzawkRybxSlNSD7aXAgyd0lHq5esGSR0aNezaQNwXCeTAvMtytgzTA2BXvO6s2J1g4lPc32Kulq7grl4dWuARKwl03o53tDqd0jsMzqnYmJHr0DMAOX8fLxB5CkAD2KQLMtAAAElnpUWHRyZGtpdFBLTDEgcmRraXQgMjAyMS4wMy41AAB4nJ2Wa2wUVRTHz+x7u9vu+9nSbrdP6HO3j90W6d6mqVQjbQRM5BGzjTYQVBSDUWkjlEoRgSIIRBK+QGtImqBRsCEg3VkiCYraRgHjA7VoTNRg24Q2vlLcOac1xk/rmWRu/nPn/u45997/mczk6OlvIHWZU7cEdEVT99LUvUOyqQJKf4Um1QZanggpIyqVpkppAtXqVPvAfeGI8oQvA2Fs66QGHaIaQgMthKrSQvWIqufRdkLVaUaNK6i0EBZfVGrSDKuwqgW2nVgtK24NsjoWW4usnsXWIWtgsfXIGlksjqnMSIs1ICstsB10viaONWibzayUo8hmsqxBR5SVZlwl5X8KoQFRy/9HW0LViFo5KO2xLc3FBpXzWci4nTxlTzPsY8pGLexyS4iKyME4oZYQna6TxdIJuVgsLdjNYqmIPCyWisjLKQQK6+NYg+rAz0HJy9mchGmtOZx9ClMdLEqL/e/HhvyYy1htmGooLy1UUpX+O2wbsQEWSynns1gqoSCLpRIqYLFUQoUslrxcxGLJVsUslgqhhMVSJZQy2Lb5z/piFku+WsJiyVdlLJZ8Vc5iyVcVLJZ8VcliyVdVLJZ8Vc1iyVchFku+CnPY+c9kDYslX9WyWPJVHYslX9WzWPJVhMWSr6JpsSaVBGoVaNSg1YBOC3odGPRgNECGEUxGMJvArINMM2SqIcsEliywWsBmBbtBIzns4HSAywluF3jc4LFD6k/B6wKfF/w+yPZDTjbkeGFRDuRmQ54EAQnyJQiqoEALhXooyoLiLCixQKkFFlthiRXKbFBugwqb8otV5YRqN4R8EPZBjR9q/VCXC/W5EMkFp0anzjTrtBqd3mA0mXU6h9Pl9ti1Pm9Ott+jLAyvqPfyt4me3atk5eFGaFps6NKg7l7xmSjf2YEarg+KtvubUQ9N7RL9Nf2oV02Vi9KqF1G7rxjFji8LUe9cXxY7ftKN+qGvZ5aNRZ5NKLp2sj+mvb2+SdFblkmx6Xs/iSn6wMagWFHy6QVFf/xqq3iu+wyOnxCHROyXMdTLQ4+Izg1HcPzdv/aJreMuoeh1E8MiejuOeuTyFTGnOYq66KU3E7GH70H2xLU7ic4/SpFtXbdGnv6iE/XcwVfkWPjIqKITf26Rv5v5HMd/mOGQT3XdQf1Cxnm5+6P9FxX9/dtfya73D2L/6yvVycaKKWSb9tyVj9/oxTlLQuPypudPoJ69dF4eO1mM+eyZsCaDjRrUOXFTc16lwP3ZOnhVxBtoTt9effNAsAv1sYkfxKbHD+OYaMet2OwbQ6jP7ds9Gk90otaeOiwOvLUZ97PP6RAbe3Q4f+PNdlF+7EHUnXvfEdssZzGf31fuEr+tHcD+i0+Ni97CItSrI4Ni7U9nUPtW/ypam59GbR/+UcRfu4D60f5tiXMjP+M8fX09cuFVG/YvvXVUPuuJYD69BSPypWHyz5rtM3Lsug+19J4p+eTNSVzX5gF/8tDQKO7ntUxIfnC6Dedpejc/OenbjvM/M5efnH15Ofa7/wZ1UNKH1TGxEgAAA196VFh0TU9MMSByZGtpdCAyMDIxLjAzLjUAAHicnZhLjhs5DIb3PkVdoAVS4kvrdJAAwWSAWcwdBphl7o+QRZVLARKgTcOL+tquv3/xJZUfR7z+ef/234/j+ervj8fBcvA8Dvjte855/NsB4OFff8OmZD2uRhvAGBrQ/FM4Pv3/J4n9HSqHNh46QqU3ENNd5fiwijSBsbx06mNT+f5xFW6I01IFOvSaF2poHkZX8as5rOalN4W+VjQVpealN+RuGV1WtpoKNJFJqTI8XVUV9NoJFWiTddZUsAHTykxHLnthIEs9QeRN5e9XouvBkFwRgFAt015rppAdRZnzUtWxAqWKdCp7IcUVFxQteyHgmREaBMWq47gX0hUjcU1FWlfCdCVmWIqLx3TIoMy0jmLVucrErldHAdZUfNpOWZkxK9aLz6YxYOSK+kSqelHDVbs+vIteujtQXhGCWfTCzfCcttGNMncvL2RamgkvLy5Xq903ax1U0wvJLGZa27TTS0w9LPa0r4hBIFW6YK2PIrreAtnTvtfuHfDxifk2fXrnSSF2+3T1ek9bU8yq89kJfc/R11cmgy9Ir0yT1FQsJiZnpm3+cgp6QUVjn+bsSxlWVPETmRhktnxgjpJKzAMhzehy15pKTFviVbF9jOKKYjLYqhcELHrxM+HIM6FfKUNNhX2HnasbCUSrcUHJk4LvkmTFqvOexiEZFzag6ooQgPNK+i87yUu1S6SW0VWmYnTVJ6aN9GKCtejGyVIzpujzahRV/MRNOXe9/tRqK/JO9sEQtev7mwnUppR3sm8f6wQP2mdNRZvopUIwalXnu5qOsc6YpqPoZTbhee3TszgZ3AvA6cWrDgeXVvSG/kzy7OQ5hcsqPfcP94Jaqjovfe8/TKCTF/DJC+TkBXryAjt5wTw5IXbK+QQ8eUHfYQTfcKv54RDHBrcd3/i2eyT4Ag2+wIIvmJcdfBwdTs5POgZf0IMvGMEXUPANm0AaW8D7PRJ8gQZfYMEXzOANnvcMCL4At6/Fzw7P/zP2NEZ53sBbTqMBnw5iSt1qtgXRO+wGH6x3RP2JZoO+hZfGDhSxv4B3kB10C7w/Ft+Bp7nF2jfOO24+2TboWxD93LEBRbQu4B3khr+O49PXL5m8mAwYf/n8/f3xEzDF4zokHZPBAAACcnpUWHRTTUlMRVMxIHJka2l0IDIwMjEuMDMuNQAAeJxtU0luG0EQ+0qOMjJq1L5AFwNz8Ul5gKEf5Al5fFgtB3GMHDQY1bDYLBb7/e1x8v283C/vb4+Xcz/3Y373U04+/3w5X1/fHn//7uddz8uPl/vlS+Onv6d+qYLx58vuks+w/76+378//mH+9uvCK6PIjqsvNpc4brKShPO46urk0ONmi8vxcsVLa/ZxA5g7fTAkxOiKFaTCUxETleOWi13cpiu0mKfimgoeWRQV4KmVTB2bh6R4eDQUh/NiNY+BWLIBQqvayXv0eJLJgEIM6BvawRdTMRLIwBQ4vWzO8nS83GhFtNZU1DXQBUoJS9tzuKTyoFiIrOe89qzC/GCFKOOppXqK7FqzpB1DS/Rk66xgPXiVjiqwaocAUiXbk/HU3PWQJVk0FVuqcG64pVkb82EXxZo1NYoWzSGL5RTglmD7AEEVmGD8eHnN1eUOBLEpnLv2Ip+esTvIUSnYrPBA4a4HzxgYmGAGxHdY9UdJ4DhAnKm7TShj78CiqZ9UWKWN45Xato8Lb0gd1a1UuzVWhVs8F1q1dUdzPVOQ0rKVR/LejGEW2z7BHngxK67k3kYlO8ugKqimDy4ihTooqFLfa0nDt7GenEEFO9x4BhR2fJsVO1mZwalgRkIRFgRzAg7lFMZjETKF4OU4zrFXjhybaw8TVjbC53xsCgYzIa4DMXJMiYgZlQ8J9i4OL5GVzrk5nu18TFBBOwVAiYGA3JGHSxa4MAe4rPbNch5TILJoZozhwqnQU/te4TYS1gtjRcTmnpklFgETobemIDAsgEA+kdmXX78BaOn3fk3K2MQAAARzelRYdHJka2l0UEtMMiByZGtpdCAyMDIxLjAzLjUAAHicnZZ7bFN1FMdP29vbjr7v+m7XlY29127tHjqd228pIVOXaWSoYYkaEY2JczoViSEGI04RiAmM+AANYHwEX4yAGsX2dosuWxCiRINIiDKDJEBqCImimNl7zkaMf13PTe4v33vu7/M7597f99y2kP3gFBQPe/E0AB3txbOjeK43eIxxLZ6QimM881BKm5HUhiZtiDebimPfjS3XaFd4M57Gsc3QISMqERrPEGrUhVoQNc2j/YSadGa9R0MNC2nxRlLSmVZjjQtsP7FmVt4WZGUW24qshcW2IWtlse3IlrBYnJNcpIu1ImtYYG+h/bVxrEGv2c4q+VpkHSxr0BY5debVSr7aCB2Iuv4/mkk1I+rmoPSOPToftkLbn4WK+8lTCuMlZ1LUQ6UsljbXy2Jpg3wslp7Xz2KphwIslnooqHOPtO292geUNsRKS30QZrFk5ginZHraKCdtmhqhTBf7368NOTKmM69W8kITpamJynWhBmPtv9P2EhtnsVTyYhZLTVTBYqmJKlksNdESFkturmKxZKtqFkudUMNiqRNqGWzv/He9jsWSr+pZLPmqgcWSrxpZLPkqwWLJV0kWS75qYrHkq2YWS75KsVjyVZrDzn8mW1gs+aqVxZKv2lgs+apdF2szGsBkBMkEZglkM1hksFqgxAqLSsBWAnYb2GVw2MFhAqcNXE5wu8DjBsUKpQp4S8HnBb8PAn4IKFD8yQ76IBSEcAgiYYhGIBqEsijEIlBugLgBFhugwgiVZlhigSonVDuhxgW1LqhzQ70bGjzQ6IGER/uv0+SFZj+kQpAOQ0sMWmPQFgOvJJscdtksyRZric0uy6Venz+gmEPBaCQc0J4Ij/aR907n9q5ermoXFzecEcveeRr1moPfiIqqWtR1x3eLFwpx1HfOjAql8xHUvhMJsVZ+EHX59ZIY2KCgVoxK92f9NtQ9R978YmV6eU7TX13KdO+cO9al6bunzt3QJJ3u1vThT9zi8G2vYXzi9uvE9uFRnP+hdYuYPjGGevjYMjGV+BLnlxbWiaHZlND04HOviisvr0ed2HZA9HS9izq4fzp3cbAdWdNap/rG+5XIvp5+WJWfFajjNVvVzF2Xs5q+6aOn1B8Gz+H8fZfCqmPqMuohaUJ9bDyHc/o8P6tdd0xg/OQhOb/1wgjqJwpS/vsrNlwz0fmjum32ftQuaVo9tFHBer7tDOR/TU1gfGjgL3FwbC++H+OstedW6wrUP2U+F7HKMdS9k+dFanwc159dV+h+pm4nxv84vjm7dMdK1DOOQvfz+4O4/t+uTQIupHD9jXsSwjP3AMaPlL0txl76HeO7GvJiwHszxhuzq8TXb+1APbfrqBj95Sjqs+c3C6VvEvVIx0kx3LwFdfbTfblVw7/hOjNnN6ln9sgYf3L1K+qaP5diPY8f+E6NPNqFendtJD+14hTWn3yxLj+eLsf5935syd/XX4+6Z7I6H4jmcN/9/wCgSsDbqJX6zAAAA0d6VFh0TU9MMiByZGtpdCAyMDIxLjAzLjUAAHicnZdLjhs3EIb3OkVfQES9q7j2GDFgxAG88B0CZJn7I8Ume5oDxICmBC36mxF/FeutxzFeP9++//3v8f6it8fjUDnUjwP+9917P34RADzy409s7tDHEzcGxqEBLf8Lx5d/fiexv4fK4Y2Afap077CrHC+rWFNlGSrUjJw3lR+vq2gDdZsqimI1W6QREs0buZ53K9hCzdFkqphg0S/UwAznjSg611SgqQNPFXTzksozTwTAfArS4o2guanOJ0HBqgqinmdx6MWm8tdnvEuGNM8yoFQj3dOYWVGgUIyRNIEz71MFjXrNFm4IM77YVEBrtmQlK+HKYu9FFWneXecTYBSrUbN6GOYTzer+vF/Sp+rqM3cdqRajUYNkK2ONu9RUsqsQrox1JaipSFOb+ZJ1FF5UyUij9emh4Ch2BmpCZx2lSlcs+sWy152RzhuxS60an96A5yTJmGMUIx3jRjht6RK9qsIQq3pULGo3shaKK+s6YNEWy/mBvrpe9D3Sr3fMZ2+is3qGd73YvT1vdHb+pzZm2G359rpK5M6ga8Iyfegvn1DRtOWswayobLtcU/HGPWJmHUdQTSVr0HHZEgFYUsmMJT9nY/pFUIveTVtsdlvKG2mvqUhjuSyw/mFn+ITK2KXmDMhdiqRoizbsuHaGzlLzbm6qwGbTFnQuqnDmbqzZGCZFv1h2/pD11K1YAWPz4D5VELhsS6Y9LL25Pxdyd1QP2FULITWVzDqfFtC4Ua0CUsUz2WYdgXvUVKyZx9q9uxerMfuudV9TzfnDtH9Z5Yk5hbotv+TOoDVbcjauSOdvNcOyLUK0vMHOpb6bh/I2OEFOXqAnL7CTF/jJC+LkBf3kCeNW/R3w5AW0Aw++4VbLJQh5g9uc/KmwnbHBF/jgC2LwBX0zJ32PN+DgC2jwBTz4Ahl8wyYwDVug+xkbfIEPviAGX9AHb/B+JlsJvX9Pdsr7Y0xb5HgP41jdbtAtpmxb5EZN32qxOTE72Q3ZWG+PZsffgDb3Cu8gw/cX6A62g2+Ol9gcn/Pp9nWOvNtvOZVvvykNn1zAO8gNfx7Hl29/zBCNDoTjL19/vD3+A+tByZDXk03yAAACWnpUWHRTTUlMRVMyIHJka2l0IDIwMjEuMDMuNQAAeJxtU0luGzEQ/EqOMjIiel+g41x8Gj/A8A/yBD8+1VSCOEEgaDQqFpvV1cX314+Tr/N23d5fP17O/dyP+V6nnHz+Wvnz9nxe+vX/dftn76lvv6l8/sDr28slXzj/f32/vn/8Vefb541XJR93W1VEeTxkJYfZcdcVxiTHw5awyADpGqD4Is8ARZazBSix3HUDISmg5NKuAsJLq7AbiJCmTpnO6hik3CiOuy9VCj8ehTJu+yiVCp2jyoVs9IW09KgxSuWpzIB0FDez+yDkJDUIRTCPHqlWcGh5ktqWyBkB0p2WpFNvScYObYNRdpdCA60S60IzKOyJz2DJgkYfU1kCftEKbXXdLC2CLeNoDQeGCeMNu5y7IR5tKLA8oII0nohHQjRqWyXZnBfQr9M1gW5GDCwXqWpMl841ToAWWbMVDqSPgfdaJjyd02pD69Nnr+gcV3klzuxNUyoLKHOLmoGBZS7qx5RPnlqM1cZ0ZYRtXahemCIQ2Ev65JjI2IDZSvBWVQ4FEEDcT0CK4d4eRsQ2pjl6T6wUtbcNGaI9s6DM7G3x9FLDamftbXEmVeyAEFqYwWa4+ZhsPGkCgjSwBDrBEs5FHKAMGYRIYmPoVtgfsZs1gg8PCImEfMEMfadMzfd0G5HaOxpBbBAgzvl5T5T8wDVBTGyiinZ5xt9qc5PQEsaihy3iQj5xSzBzL2xhJFimqHtZgYGwz2Acd046D1+CGzY7bG4Rfnrk7vBrCwDYj4CAgNuFfGCBheN4+fwJcXHsAJBna1QAAASmelRYdHJka2l0UEtMMyByZGtpdCAyMDIxLjAzLjUAAHicnZZrTBxVFMfP7GN2Yd/L7rJPGChLeS67y/JYJXAtErFSCsTYDzaVNqRaKJL4qFofSDSisRQbpNY2aitf+sFi1WpTmy6zGmnTpFFqS6NV/GJKNdiKJppoNe6cwzbGT+OdZG7+e/f+5px7z//M7vXUkQXIXObMLQBdyczdlLmfFRwaSZmv1mVGqXV7TFkRUYYaZZCi2szYcWeiQfmEX0pxHOuEpIiojlCplVCNKtSAqHYF7SRUqzJqr4IK2bD4RUSnMqzCarJsJ7F6rri1yIpcbAJZAxdbh6yRi61HNoeLxTWRXFWsEVkhy66n+pp4rEHHbOZKuRFZC5c1qERWlXGVlG82QhJR2/9HW2NRRO08KJ2xQ+Vmi5X6ZDPuJE85OQ65NUY9lMfFUnFdXCwVyM3F0n49XCz1UD4XSz3kVVkjpbw3+4DC+rjCUh/4uVgyc4CHjZObg1ws2TnExZIlC1Sx/31VEVuoklVKpMmi5GZJZcrKumzzxgktUoUKmrJ/Z9xOJ1XMxdJuV3GxlHMJF0vNG+ZiqXlLuVjqotVcLDVvGRdLHVjOxVIHVnCw7Su/J5VcLPmqioslX1VzseSrCBdLvqrhYslXUS6WfBXjYslXcS6WfFXLxZKvEjzsypu9joslX9VzseSrBi6WfNXIxZKvkqpYk0YArQZ0WtDrQNSDQQSjAXKMkJsDphwwm8AsgsUMFi1YTWCzgt0GDjs4jZDnBFceuF3gcUO+B/KdkPmb4XWDzwt+HwT8EAxAKAghLxSEoDAIUiEUCVAswCoBSjQQ1kOpAVZbocwK5TaosEGlHarsUO1Q/hfWOCCaBzEXxD1Q64OEH+oCUC9BgwSNErh0otZiFvU60WDMMZlFMc/l9uQ7RZ8/EAx585W94ZVcc3RxZmqwXFY+3PPJAtt4yyTq9ukv2O4jnajHrhxi91UlUS/ER9jGh4ZRt82XsMjyNtQV00amrbCiPruzquVw9/KMoh/ZNtR8h2UxpejFkwdbuvaEWxTde6mrZbhSzxQ98FM1i/jealb0C+61zHRmHNnh8xPsgbMfoz599xBr6zmGrHPTPiYNScjKjhMs9OFW1A9+9hUbe3ovzcfemOm2LZ1S9O8jF2e2nDuM7MNd7XLq8y9RX738vPzSqBX1sfFBOTzZi7GawC5f7ziAemrqA3nNrj5c897xtNz0owufPzj8s9w/UIF67HVj+uu1Z3DN6LiQLvhej3vp3nBBPh3pwb3f3jorRy/M4TM3/eBIL735GOoN3+Wmr0z78Nz65pfYL6FPUf/WI962vnQUtbxwlPV3TtH85mW2534j6vPfzrZMBvah7mh7PzV3rZnO31rOhl8JYG5bzu1nCess5lO6o589Nb8Z5+0jJ9moLYU5pxLfMHldGOfT1yZZk/VV1MEn/mAvHzyBeujtj9itseOot1+9wU5NDKB+Zmt4ZvodP+rdj/fJue+2oX7xydfkXfM3cI9a3SE5Gb0X53dO/C3f5XuO6v5XYbph3a+YQ9dFbdq541HMv3iuKK25VIfae3lR3mv5E5/j+Qf0+dl5Gclu0AAAA1R6VFh0TU9MMyByZGtpdCAyMDIxLjAzLjUAAHicnZdNbhsxDIX3PsVcwAJ/RIpaN0UDFE2BLnqHAl32/igpaTwK0AIxDS/8JdYz9SiSmtsRrx8vX3/9OR4verndDmmHwnH8+917P34SANz863cshoDxiYrWxqEBxf8Lx6ff/5PY36FyaOmKFCq1qHLdVY4nVIQwIrhzIep7LG8fV5EC0uvckXXmXCy1ADeZsfSONRcLFWmiU0VFkrFQQZ4q5L5gUgWKNm4r55aNBQoxW6hAqZKNBQuJtBVV1ZaNxVBsOgQGtql8f8bdhk3nWkbYY3ki01xQhoq7i5Q/dYrz7KK7m60ALo27TJ8rmGVjaYqyTjFoUkVKs9kPvAKgJlW0GEhdUQFZyhf3lMhwnl3EZAW4iqrBdJcx6a73AyRvxENFJemLd1sUXGtFkjnyWBpin75Ya0lfvDcJwPIZkxVwF68AXjVoPZtp9RkwVagwZX1pRXD0XVdRpaSKFZmTxDMtms20FehTxc8uQ1JFi/Lou55pgmwFaMEua5Iov+tSH++79+41OLqUx9K1JVXMp9pUIe912XnUYi2tk9PbPu1fP65ixdsuz7ok4qSK+C2o0awFhHd19ISKn93KNH1BxqSKn1hhnTtqktyR55errVi6ZXcU99NzHlV+N6efUKnF+DHt7V1neEKF45Yr85OQJWORYvKY01aTsfhstHk/9Tlt1LO+qJ0TVkmTO2rFaFay7w0guSO/M8Cp0ijrSysdHjcPg5wv93E/xXXqMHlefMKKzmnPflO1pIrX4Lp7Y/FhkKsj7yrA2GYsNeuuz8YuIvO8QM/60v3Zatx3vQJ69rz4DCDu6ynLOOfLHeNOyOspy+qYBilfqA5fIkeKqY7pG/Bfxwl18AIZvEAHL2iDF9jgBX3wBITBC3DwAtqBgy+41HxDyBtc4Xhr3tZo8Akt+AQLPqFv4RAMXoDBJ1DwCRx8Qg2+YBOYgS2QfY0Gn9CCT7DgE3rwAobgDR4CjMEn0P41Dj6hbjmNyXGB7tC2bEepP2LjPY0VNnsr7kCb15V3qJvxVXbQyMoJbQfboW8pEdhSIrhlQWhz1GvxctTHy+Wo1whfa3SHdsG34/j0+mVmMpoDxl8+v73c/gKyM/ClWMTfoQAAAnR6VFh0U01JTEVTMyByZGtpdCAyMDIxLjAzLjUAAHicbVNLblsxDLxKlzEqC/yTwlu+TVbOAQLfoEfI4TvUS9Cm6MKyTQ2H5Az1/vo8+XG+PF7eX5+3c5/76M/jlJPPz5s/v67zod//X+fbPxSnvn3d8fmrAbeH/IX5/8/3x8/nN54fHy883TVs3G2mq+Y4ZHq617jrDNz5OGySpkVH1uKO+CRfusZdZi1VHUdMF5ZsjMhSG0dONxVuDCurNGYFi3StiF0rpxEzsmLSSuNx1NTl4o0RUdOu5ZKMWj6ZtHmQzsuA4WloYxw6GT1HB1hUVg+BPkO7uAjKj4NmJKZYDapyZN1pqhWXN2rVHoOmqBahawI3Bmocg6OoOsbsArU6FlGkg6dyZW62sKDlQ6ZxJJqAFixQDKBwy9oRj1UxdFJVoS3Myc5lg2BE9BAHBg1WVCaIKxnQu/WBTQlulaiNIeU0EJlYQZQ79Gb3Lh8hmzrn6gDsW1HddE3fEsD0uPpZcHTBCZ6LaPdc7YR3P6yUW6eFsZdlz78iJS4YRvQtMCzUHRFYt/em1HUL14Jp7DUxFt89ifnlApZBr9kCXkXTC8H73DFentyw0CWXmMm9BlAlE7Js7RJu6Sa7WoXdTrTzYPvOg92M2boJDN37gzv3rS8caz1ge2GD4IvAF2plBNUyBBhlSqw6lgxfkBNLR9Xlm49RFQootSiGwRPtI6ei8BgQyWArQJyiabU339p/l0rp7S5fm7Ss9svKUhMAgpCIN4M1MWuGQsZefmzvgqshaH4jqJ8papFADDwq1JYaoCb65MQIikCKdedYDOr3hyLY6zVuH78BSkr5Lpxa5e8AAASAelRYdHJka2l0UEtMNCByZGtpdCAyMDIxLjAzLjUAAHicnZZpbFRVFMfPmzf71s50lnaW9nWj+zbdpChzTbWh2hSqaJSIogSjpHHBEEkqAhoTigqBsNhQm5AmIghNLHWpLZ03mpBQpYrLB7XxA0SxNQzYRKwmoPPOYRLCp5fzknfznzv39/53+Z95c2Xq5C+QvpzpWwK6WtN3W/reLnkMitZfY0y3SntvgzaiVmvqtEapl9NtV2dzq/YJv1Ri2DZLS82IGglV2gk16ETXpZUsZVj8olZmsY3IGnWxFmQNGbab5mxi+TYha9bpq22VnLGl5VpYts3IWnWxVmSlDLuSlmtj+bYga2exOKbWwWLvQNbJYpci62Kw7Q31yLpZLO1zFoulbGSzWCoFD4ulOHtZLGUyRxd7ewnSnH0sX8qkn+VL6w2wfCnPQZ2+CtxS+rRVuSxbKoU8XeztpU+xCun01aZszNhSFYUZaIyKKMJBqYaiOve4SFts5lXUTbnI55wPHW0BZ8a0xYouVDKU33o8K2i1hSyWfItYLFVfMYulCiphsVQGpSyWTncJi6XjLWOxVH7lLJZqqILBrrj5JqpksZSrKhZLuapmsZSrGhZLuaplsZSrOhZLuapnsZSrBhZLuYqxWMpVI4e9+ePcxGIpV80slnLVwmIpV626WIdBAtkARhlMRjCbwGIGiwGsFrCZwW4Dhx2cDnA5If3/0O0Ctw2ynJCdBZ5s8Hogxwu+HPD7IOCHgAeCAcgNQm4W5OVCKAjhEETCEI1Avg8K8kGRoFCCIgmKZSgxQakdljigzA3l2VDhhcoQVIWgOgw1Ye1dWBeB+ig0RCEWhcZ8aCqA5gJoKQCf0WywmE1G2Wx3OF1umznbEwjmZpm9OT5/wBPUVoVXa+3JTYnFG36hfRja40/O5g0mNN120JQ8kPrqtKb3R1zJsdeOxTX9eMe/6vdPR3D8hY4v1VcvWlHXtU2qU/MtOGaxelZd9fDXU5q+Vzmnxsrm8Zmn2t5Wz392frmmpcdeUecu7MB+29p8df/c+6ivpCYT1r+6kJ0o/CdxfXQQn/nDnjXq0fEvUFf9d3Xi0H0Sjm+0XF4+f+0a6sn43/HpG25V0/eM54mBso2o7/z0ZZE6vhX1pZnDYrOpBXXT52+JrvGPkH3hjWXiyOhu1PbeqFjoG8J5do5tja+8P4q+H3ab4sN9BlzvYM9acXXuY+w/dHi3eDFUjP3rdo+IPxIbUVfsmBGjsQHU62emxfTOTvQN/PyjOPfIPtRyf2nymVE/6utbypJnNj+FaxfvycntCy7s7xksST7R/w165a3+QF3cuQqfeVYZUlMHrThmuB3UgXfrUC87tkUdNt2FY0a8tkRKacf+DUdPxft/ewd10Qm/2LUmjGPe7Nsn6vtmcb1jex8SMqzH/tXPjYrEs2fQN/Lkt+LRnyqxf3hil5h64ADqP19KiedNp1H3jhwXfaXjqH99cEF8t20T6urkvOi5KKHv2Uu/i6bLCdSJT+S7Q12vox7pOCG2bThC+/M/McnRE5Y0474AAANQelRYdE1PTDQgcmRraXQgMjAyMS4wMy41AAB4nJ2XS4ocORCG93WKvEAn8ZQi1m4zhmF6YBZzB4OXvj8OKZSVMsxAdRS1yK+79PMrXlI+jvH55/3P7z+P54feH49D9VA7DvjPr7sf/xIAPOLnb3C6GMyVJwv38QRn/BeOLz/+T2L/ThWPtb2NJzwJXXeV42UVCxWndIUAWFWx5QBPJuGaSj+NEDMuImybysfrKu1kJUkVZPOaFz0tzOTajqJVL2agGV0BhZqXdgoCZaaNfI/u36+rSKiw5FoBbzUvHLXLmF4ApddUIr9dJFUYq14wVBpkdKO5qKri0jhrl0iKKhzRzfziqeTFPhoruuSTVutl5LeRr72RS00l1jK2zBZxsadHJwN6Rqip1erl4NM6tFV/jfd6eb0bDzmtOeSOTKSWo1Bhn/sY9Yfea14ooguQKohi5ejq5YDBa1MqVrjjqrWGUqyXqFiCnq6Abd/R61MqMi1qmPUn5MUOiFmnTdOLitXOxkNDRTxdtWZFLzG9lTlddet7dD+RozjVuPfsAJTf4vIpFYO5jzgNtHOpp98wak1y7sb9hX/z8u0zKtI6rOlNSBWVcfMgmvUyphR2r3qhOO6z6mJ0Fr1o3DwEsl5ITWoqEucRau4oDuyil+hBkBWXOGpLORq1Zqa85pWy1lRiMkRgUg/ESjma8wCmg4hQ74Y1lVGx1tbspF7L0TG6p69TSBhaTYVHT696UWnFuGh4md04bh4Kxbi0UJF1a27NizuKszEzHU+ttWJ0e0xM7Lk3h3pcmPMdQmPuqlW9aKeeOermxej28NJWNwJ5rY9ChbpxThr33msqMTF5vh9FHyEwlKNr8x4WXkC4VC+xlZhumCCTF+jkBW3ygj55gU2+4RbwyQnjavP8WbxfDl5Agy/gwRfI4BuO+2d68YJbre1r+uALbPAFPngBweALcPAFNPgCHnzDJiCDL9DBN9wOqA2+oO8/s8EX+OAFURr09BbvfLcdpsEX7GkcL5g36A5tyynvaYwmvbPAvmUhji18uo7T7A5iHIt33OLd5N5CDLENdNuPtB36trm4fm/gY+cL4hVsA9xhj0Gckfx0HQNwA73hr+P48u2PCbPtcPzl68f74xfFFNaG80RBAwAAAlx6VFh0U01JTEVTNCByZGtpdCAyMDIxLjAzLjUAAHicbVNJbhwxDPxKjmNELXAVSfSxLz61H2D4B3mCH5+iJpuBHNzWlIrF4qL314+L7+txP95fP16u/d2f/rsvufj6dfP39Pze+jzdfwhfgy99+83l6weOby+3/MP5//H9/v7xRefb54OnkbqPw2ZEso1TgHDpOHQuzxXj1JlBSxqppb7GaTNXEY9DZppRjnNN1VjVHLYsRAWQhStwSMqbkhRVncpD1ZoikQLEZ1UEjzOnqOhqDpMSOD41dWlzyHRZJ9dKkA945wppy6VE0ggju46TgXBHCQQNAE1bUraaUzgg10HT1Q1HmCbLzI0RBVAk6ntyMqTsVLFoY0LEDkVIWxi0camMxmyIyHinDVPUenbPTHl7I0YAIAPE3iRWE96I9XHAJdWSNuIzE3c0g825ldBiFxsdlVmbAqMoW6c4egQkJmKowIGxaJmcyWU54FG6DwejAigDQD+2bk614uzamIi6xUcBC9/dEi63Z6B2/wRz7dlvxLAf3RNhdtlaIgkD3XeO0m07k6yaZviPXWvMGEvW8pi/yu4TekIKXw5fG8h0VdRSDjN7CBgg9gae5Nk3AhItCVNYjuo5V2FzupWL7Tl5F4xUwCHtGaM53muDegjS1QtunswQNtmldY25OrdJ7JXzCM+ej+IlRCPmy7rTbmlbAw9gDwPL02kcMcjTBXlrOiKwZCCsFbX6PTiWpL2vVRDvxcZAh+E3nlkTzBXJ8DQzbL8XrMLygedCq7amImsBiPTe+4BmO1YART5ePn8Cn+Dvdyu3jusAAAS+elRYdHJka2l0UEtMNSByZGtpdCAyMDIxLjAzLjUAAHicnZd/TFtVFMdPf5f+LvQXlEKBwYDS0kLLT11fs4WBP1h0LGJM5khI/EdxxpglZktQNxyDbNlwf8xtmTrnQOcyMk1IwPWCyzYkgZFINAvZFhd1BAhGHWaLWew7B4zxr+a85L1+3+353PPuud/7brty5cvbkDpMqVMBdDSmzk2ps1uhVe5KfaoUQXXqw+/fHJFDQvKlUr74w6rU9ZmWmlr5Dr/0V+E1pqj/P4tfhJQsthpZFYuNIqtmsTFkNSy2Blkti8WYkI7F1iGrZ7H1yGYw2M2RMLIGFku+MrJY8pWJxZKvzCyWfGVJk/WnlHodJVtZOSi5ypYWqkNUtTa5rVRkOwelGmemheqxTop1T22jtFmcwdIycHBQWgVODkqLwMVAq2gNuNMscaFcJ/V6jcmLHs70kBWzWdNDU5uTFmvHtOsr4FWaWW+aTyynVa6nbaUlkJtmkWX235VXRXl9rLy0fvJYealU+SyWZtfPYml6C9JiFcrS/05vM9WqkMXSeItYLI13A4ul8RazWPJVCYslb2xksfSqKmWx9K4qY7H0sipnsM1rO3aAxZKvKlgs+SrIYslXIRZLvqpkseSrMIslX0VYLPmqisWSr6pZLPkqymHXdsEYiyVf1bBY8lUtiyVf1bFY8lU9iyVfNbBY8lVjWqxRIe+CqU0F1CrQqEGrAZ0W9DrQq8CQAUYDmIxgNoHFBFYL2JRgN4M9A+xayDRDlg0cWeB0gNsJHhdkKyFHD7keyPWCLxfyfJBng/w8SO2M/nzwe6EAoFANRRrYoIPiDCgxwEYjlFqgzALlVghYocIKwSz5R2GlA8IOiDihygnVLoi6IOaCGjfUuqHODfUeaPCDQ61N9W5TKrRqjVanV2kz7GaT0aD1+vPzfLlueYR4NE4E9yS7D2uFfPNo0JN801CSlHX//Fzyq5tT8l9aWF5sj0/X7Lkia83jB/HE3U8x5onOF6Rv3+tA3aV5XZr8IjMu61cS5dLT22ZQvzRyMr4UPol6+cCwpLnmlWR9aOSOFJuLod5qViRUwz9jzIOWVen3zouYt919Q6p4/uA3sv57hynRJqKY63GPL3H0xbuou7dvFZuynWOybvv6nHTw/tvYT7JpTFo4NYExV409IjqzH9uvvzYonu3UYN6pme+EoqMZdWXmI9E/HcA6zESWxa2LB7A9cOkHEZ/qwvbSDz9L/mFcxn5efte+qey4DWP6vO+Ljvk+jDmyb0hYx9pQr144Ldp3reAzDP+5UzxMjKL+PJwjLp32Y8z8bEQMDO1D/UvmnSer+1pQfzx6La7aW4m60HFYah5dRfbETwmp9/IWzLtQdEQamdiJuqh3Uerf3Yv6eIknMfyrCfWZ4F9S/f17yJY5fYkPzoxhbWEklNhbVo39B5pCCfXZIMbMXjclbv4WxXbfofOi0+vG+n+f0yI+Ceiwz4KlSdEnvYN16FrpETtKn8L2N54bEvuP9aAubl0SD0+pUGc3WMaHz85i/1tumMcHju3G/ucGfhR65zS2L0zqxqPB8xjvaNeNXzjRhPqty1Pitm0Q9dXue+Lo4jlkh7y3kkXbP0Lt+geMwO6CBMlbNwAAA4N6VFh0TU9MNSByZGtpdCAyMDIxLjAzLjUAAHicnZhLbiQ3DIb3fYq6gAW+RFJre5ABBpkAWeQOAbLM/RGqqOpSAxnAZqMX9dml3xRfovw45ufPjx9//3s8P/TxeBx9HErHAf/7HWMcfxEAPOL1N2hDe59P1BBIpga0+C0c78evJPbvUulDOZ9UXGsq2NTAcy0Px5JKrHCxZQsJ1nZ0YBuEnlaRV23hxsu7YZXDqKoYi+XablRUoaYKlHtTHLUYxVpC1eupmC9Hb11M0yphgZqKtjGQU8UFizHyBtotd2RDek3FmkYhrdwVKHpXG3XyzBdQLap4M0NIFQMt+mWETzN3wy+drFbT3BBlVQDA2G35+ZV8QfOVa8OhrOLOmjvqBHvu/vH5HUlD95H5AmzFXtcbKUvmLrhQTUUbs43sEcjF/vJmzfHsL3EGqBcrIFQE6azG8JC9+OXzMYodmQBn5hgj1VSwMeDqUt5x98vnIx0rUAgzRtRfcvf9ny/kC9GpEk9sYLUdRb6Msx+EX5iKHTMsGGSSHnIr1lFYIM6WKqJctCU6PwzKpw7F8yjWWnaGsCpGkGL3jkjDWdOzX8lLpL9/XiW6SiddVslL1n1BRZoIQHo3oqU1FW5Ao68ne/HL12yJIkwVcSjaYjEFQU+9MApqKmNmyeqYtKq7YouRcHrXHIp+ibMxWlyuZXUpqWCcZTjGypcxyio+sr/E7G3OtR3FzDDc0xYno5LK7FLcNW0B1loFnDVIa65DpFq+zLMRs8PhnDy8piJz3rWsAOxuZb+MPMtCD3ot0nHC8jqdY2boWsvdN48pKPtu3APYin4JFcXVd617MdJx2qvDsgWhGGmP3qTnPsLPWd01lT5gRRq4dgbMrFu3iT5n+aKKhQVn947MQS92zNnh4JwUQgUQSrZEouD5ncAXT5Ad+skL9OQFdvICP3nBOPmGp0Dc5Ob1ZQFNvoAnXyCTL+g76OQL7DR8gc9lG8AGt21xdt+vRQPC528iovRcQzT5Apl8QT/o+UfnTHCDnZtdMOabGzwdElMVPV+LZGTY4DaHafINd7CYL07YpGV/rW/BmpejZ7DmhHev2V3FYwtJJNgdEsHN8XGp2YBnVC6QHfoOurk37iQb+OZrGRtEedyO77gDbVHovIPs0GfwLtAdbAffgtXHdGrC78fx/v23E85/iOD8ybefH4//AO7mCfSG/amjAAACfnpUWHRTTUlMRVM1IHJka2l0IDIwMjEuMDMuNQAAeJxtU0tuG1EMu0qXCTp+0P+DLGeTlXOAIDfoEXL4Um9cpCm68HhMU5RESe+vHyffz6f70/vrx/O5n/sxn/spJ5+Pf77eruddv/9+sL4U/hE79e0Pi89feH17vsv/6X9H3n9+fNP58fl045WkncfNFzGxHy83WZlletx0daglIFsiwnzgRZNiWL6kw2tYKtoFKFYaSQyUyhyAcjG1bXkuJ95QsaUcyBNlNoG1qpqhxSs0iy8oWHtrebVf8lHkm8VEsutqSY2BKokVkC4rja1lIX01ZNSyMzp1TCChNXfbGJMYaISXatl9szVfNIcFAjVaYeUwCryyVB9IjCHxwqiCUTVSShX1IO5jBKw0bjteYFK49QQNg6Fjy7R7144mvIeUsJsPZE1pRRhcy9IC0kWMAQBxyzjQkiqCRwVe6zFtU8CAWI3aC4wyZmgkUhNSY4ZtjTS1MMG0A6NvM2j02IJGZAlx7JCAPYq0ahQjUtgJ6l0/5k8xnBRTmfITU5GRKc7IicJgMahBzG23mI5BwRh0wqMDZ7qNNwLXeTucJbELzK6sIZVgU9CTuNS2nCJ82nT4qKgV0i40QlinwCSP2Y4OHjsJHQesIfgaMxVhRB/zjdr3yE2mLXTuPWuH4KTs6QGOZ25IcReFqHLua8Vg7Cw1ysEsaXZ+dpGxxZOfND2vE1GP3RrBkh4j93KJzASZUfhFw5kBoDK5Fl0hmqNEnXXdH0fOlFFJ8sXBpeQgiuV+HCTznjM5LmcuTcf/Ufaw6xyNRRUczr1yuDOrQMOIFpO8EPwDXdJ9UDGrGzEMOB3H8+dviN4EcFaYW1sAAAR4elRYdHJka2l0UEtMNiByZGtpdCAyMDIxLjAzLjUAAHicnZZtbFNlFMdPb9/W9/W929qudOx97dZ1W62T9VnGkgm0SyQ6EWIwMwGjgcWFRONL0MRkUsmIRI04NJsguukXNRIkrLdK/CCJ2QhKBEEzwxBI3BRkkSjYe86WED815yb3yb+nz6/nPM/zP/d2YfqTi1C4zIVbBXQlCve9hXu3yi6FlHhEUxhDPU/FlBlRZWhWhlCLujBuuD+RUD7hl6FWHNtVSR2iGkJDPYRKRaJbC0qtWmHxi6iaxcaR1RTFliCrWmH7qWZtUawel6teRjOE6lgltyGrZ7HtyJYUWbLCSitshrbZwMrbgayRxeKcqInF3oOsmcUmkbUw2J5YC7JWFkvesLFYOqNSFkutYGex5EkHiyVPOlmepJpdrLzkSTcrL63Xw8pLfvYWmTcEdz02aKt8rLTUCmVFsf9/0pGtyovMq5SsWUlLXVTBQFupifwclHooUOQeh5XFrryKMuSLIOd86GgrORXTFoeKQlVS3d3H00erXcViKW+YxVL3VbFY6qDVLJbaoJrF0unWsFg63loWS+1Xx2Kph+oZbN/ym6iBxZKvGlks+aqJxZKvIiyWfBVlseSrZhZLvmphseSrGIslX7WyWPJVnMMuP5zbWCz5qp3Fkq86WCz5KlEUa5JUoJZAowatGnRa0OugRA8lEhi0YDSAyQhmE1jMUPh/aLWA1QA2M5TawF4KDjs4HeBygtsFHjd47OD1gM8LPhuU+aDcCxXl4K+AgB+CLqgMQkgFq1QQVkGVDlbrodoINSaotUJdKdQ7oKEcGsuhqQIiFcq7sNkPLQGIBaA1APEgtFVCeyV0VIJLo5NK9DqtWmc0mS1Wg67U7vH6bDqH0+X22L3KqvBKHBqezI2fmE8pHxb9lvxvY1ah6F/6pfzwq4MYH/3sjByZTqN+4bEv5d6japwzVJaT7zQacop++ckf5eHqS6jPTWnyM6lzqK88Y8vPNxyfVnQqMir3LgUx3lUzLB9bvIX6fNopR69JsqJ3bDyRm927DuM3LxjkzVvMmHfTF0/I47Vh1GcffOs+76atOGcyG0vNzliQTXeaxUSPE/VrOxMicns76qX3s+LO0A7UxpuHRW99EPXVzfvErgv78Hee/lmI00uvoI5PuYXjrze6sOb1A6l3s3nUjiv1XbfPnscaBvrXiaPmb1A/d/1F4c7EcU9mTr0tLn/7Euq5wOfi5O8foe6c+154x6ow7yPPXxMTDz2LGq5688MDj+Ocd7YsyLWzSdT7s+H8A7P0+4OzX8tr0304/9cz9vz4tjWoY5f2yx45jToZn8kdO/ww6g279siXR/5B9qBTM73H9yjGt5+SxPWJMdSdthup3ZNezDWyfq+4OJLE+V9NRUXyz20YP3DwiJjb+C/GP17Ii6k/Mhif7x8Uf/vHUN/Y+Z0Yd5xGrb2VFT+Ik6hz3T+JT8dGUafbFsXxDz/AvV2The43R45gDTNNpu7BcAa1+z1ZDPW+jtrzH0HPz31j5fgoAAADVHpUWHRNT0w2IHJka2l0IDIwMjEuMDMuNQAAeJydl02O2zAMhfc5hS8QgRR/JK47RQcoOgW66B0KdNn7o6QlxwrQAjGDLPzNWC8kH0XLty0+P96+/vqzPT717XbbRDbp2wb//JrZ9rMCwM1vv2MhwhYrsXSo+xUU/y9sn37/T2L97iq9dDTdf7/U2mlV2S6oILOMtd0/ORUtympTBajlVKT0yjwyAum4qHy/omINI5Y7FCFZM/q4klGzPRZ3qxnUbHWrVZgqIJhVMW0wMiIVzWXEhRvTUNGKkIuFvBpWR0amIDmVWghQxxXwU0YXVNAzMhwZ+UXSo1pQeK4Vzu4jKio4e02JOKUSK7DLyKg3TauokYzcKorlVLwuhvhwK9cvrtJV66wQJ/tlY+976rP/anIHbFKwK42MuGHOaY9FEOcOQMLcfNnInSYdKsCa2wFeXaI+1/qksVws3mt8+EutJ52Ggjp6zWcdttXp16e31wV17zpXEW5Jj6hYp/ls7GPSpJzuoDiuQDRZF/FpOzySQgjrnr7gkT9hO9noXRFNqrTiD0Qb+6hbcjLcrbCxjjqLtnUHvL+u0gq7NcMjg6eJ+bLKHb3rxI5+EaJcLFoQjUZdsFrLqZir8Jy7XlzJqXA8nduIpSInq4uusk8VV6H+dPK4FAtV7aO61p7mywUViJrCiIXb01nqdZU4E/J+svSounEulsgDtM3ZqZarrs8DRpn+tsq5fvEIvKR17COtnKyLlEpjZodHlnPa5wvM05x3HVGud2MezFOQe9R6UkULyzjNqc+X5A6IM8M477oKUrJ3fW3vBNPz3pIqrQjofJsg2N8IEiq9+JiMtffwXFITM1S87XnOlwrJ6nq/oPHYjdKeTocvq7g57jIO4J0nyM4TdIW284S+8wTb+YSHWgT3WONni+AJNfgACj6Ag0/Yztvk4Amnmq5rWvABPfgAC57grRDvqhMw+IAafAAFn7AIcPABEnzCGUHV4APaelsPPsCCJ3jb10dshEs4VIMPWG2Mx/gJsoIuZsUcP3+nLy74Ged0wZsdH1EzLkX0YXnWzXf5mYK/tC8gSz5+ZFmgLcn5iFnAIvMJAivgCmsNhKImB/AKcsK3bfv0/mWHfaRg/OXzx9vtLxSb1qXwQEmBAAACY3pUWHRTTUlMRVM2IHJka2l0IDIwMjEuMDMuNQAAeJxtU0uOWzEMu0qXGdTP0N8S3vJtZpU5QJAb9Ahz+FJOi06LBojjyDQlUfTj/Xnx/brdb4/359u11730937Jxdevkz+713rXr/9B8c/lSz9+Y/n6ge3H212+YP6/fdy/P//i+fZ5k0mmEeOwmWVZ45SZEZzj0BlGzuO0qaFrdWSJh4/TJ2cIMDJtsaxxxozUXB1xDxvnmk6hgPBUEpKOqGdp02R5gTgnqVaNw6eom3QkKs0aI0LpTUxcOEKBvqiyy3FmkWZm5RXjVGAUSREhi9BuggugLkcJmQi86rrrE3YUeh40WbKSO5ktEm8YcdpSHzjNFeoQBKy2wNYx/Iog44sXmY4W0GOjQgI7sGmiQoSgV5Vw11VB1kkNKF5bBGHrBhGyZdAQ9CFU0Td91oLEHXOoBqnPI8Bm3QJjQ8I7xFy6O2CpBQGPnFJcsVHk1DkLKLPdO3Q336gKtNz8GhjY6yZQPtA4Phw7klxoCZpJqm4qK0PbOj1WYszHmpZEDkz1MFsICNvjZThBt1gwh0VJU5PCJ7vBFMwZ6nlSbK3CeXX6UDV+aYXrKSBCa6VbdfY+gyoGUWzLrsrwJINbYGTMMI1qZ9OVmGeHgCiICE2QY/tDMaQmEsR7DFAwmKqrttVVIyvFYpSoUWv7zpC97yzBxPadSo2GIE+bXnBU0vKEWEvYxoYHdguwTpOgXdZhaDz6VcDf0a8MflDdnL51AHClW1PgpaFBn8pkfcHgrjUCIzC8yn6e2z8wg0o/q8AElTqHgSPH2+dPRtvwyU9kgDMAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# draw molecules\n", + "for mol in mols: AllChem.Compute2DCoords(mol)\n", + "Draw.MolsToGridImage(mols,molsPerRow=4,subImgSize=(400,400),legends=['ligand ' + str(i) for i in range(1, len(mols)+1)]) " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b13c741f", + "metadata": {}, + "outputs": [], + "source": [ + "# Do a maximum common substructure search \n", + "\n", + "mcs = rdFMCS.FindMCS(mols, \n", + " atomCompare=rdFMCS.AtomCompare.CompareAny, \n", + " bondCompare=rdFMCS.BondCompare.CompareAny, \n", + " threshold=0.5) #completeRingsOnly=True, ringMatchesRingOnly=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a7f96d69", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[#6,#7](-[#6](-[#1,#6])(-[#1])-[#1])(-[#6](-[#7,#1,#6])-[#1])-[#6](-[#7](-[#6]-[#1,#8])-[#6]1-[#6](-[#6](-[#6](-[#6](-[#6]-1-[#1])-[#17,#1])-[#6]1-[#6](-[#6]2-[#6](-[#7]-[#6](-[#7]-[#6]-2-[#7](-[#6]-1-[#8])-[#6](-[#6](-[#6](-[#7](-[#1])(-[#1])-[#1])(-[#1])-[#1])(-[#1])-[#1])(-[#1])-[#1])-[#7](-[#6](-[#1])(-[#1])-[#1])-[#1])-[#1])-[#1])-[#1,#17])-[#1])-[#8,#1]\n" + ] + } + ], + "source": [ + "smarts = mcs.smartsString\n", + "print (smarts)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "af5ece83", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcIAAACWCAIAAADCEh9HAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nO3deVyN2f8A8M/tdtv3IrdFZUtFUhqyNBM1UiFLSXYZ+5QxjOQ3box1xtI0GCGm0G5LqZBmJBQhWkSb9n3TcpfuPb8/HtP0TVL3eVJx3q/547r3OZ/7Mfj0LOd8Dg0hBBiGYZiwRHo7AQzDsP4Nl1EMwzBScBnFMAwjBZdRDMMwUnAZxTAMIwWXUQz7fFRXVzc2NgJAbW3t27dvezudLwUuoxj2+bh06VJycjIAREZGJiQk9HY6XwpcRjGsT7h9+3a7F8LJzs5OSUnJz8+nIimsS3AZxbA+wc/Pr90L4eTl5aWnpxcVFVGRFNYlor2dAIZhAAC1tbXHjh0DAJIVcNq0aebm5gKBgKK8sI/DZ6MY1ifIyMjY29vb29urqKgIMby+vt7W1lZWVlZLSwsARo8ePXToUKpzxDqGz0YxrE8QFRXV0NAAAHFx8V27dikrK2/cuLGLY1taWhwdHWNiYqqrq52cnADA0NCwB3PF/hcuoxjWJ/z000/EC3t7ewcHB4RQdnb2oUOH6HT6R8e6ubnFxMSoqKicP3++h9PEOkDDHZ4wrK8JDQ1dunQpm822trYOCQmRlZXt5ODff/9z06b1kpKScXFx48eP/2RJYq1wGcWwvuju3btz586tqqqaNm3G+fM3mMyOD7t0CdasqVRXn+Puvn7hwoWfNkfsHVxGMayPys7Onjt3HkInqqomRkTA2LHtD0hMBAsLaG6G334TbNmCHxf3GlxGMazvqqwU2NuLJCSAnByEhMD06f99lJcHEyZAWRm4uMCZM72XIoYnPGFYX6aiIhIbC4sXQ3092NrC8eP/fbR5M5SVwbffwsmTvZcfBgAAdE9Pz97OAcOwDxIVhTlzgM+Hf/6BpiYoLYXJkyEvD9TVQU4OTp8GScneTvGLhyc8YVhfR6PBL7/AmDGgowPLloGxMSgoQH4+Pg/tK/BFPYZ9CiwWi8PhAMCBAwfq6uqEiDB/PsjIwOLFcO4csNlU54eRgMsohn0KJSUlxDr30tLSlpYWoeOIiMDmzXD0KAAAiTAYlfBFPYZ9Ijt37hQVFRW6DeibN0BMqzE1hUGDoKoKRo4Eb2+wsaEySUwIuIxi2Ceye/duSUnJ5uZmgUBQVlamqqra9bHZ2WBmBt9+CydOAAB4e4O7O2Rng709/PknuLj0VM5YV+CLegz7FAYOHCgiIgIAAwYMYLFYY8eOJdrUd0V1NdjaQkUFVFeDlBQAAIMBhw4BiwU8HqxaBW5ugBvj9SI8/R7DPikOh2Ntbf3333/LyMgEBgba2dl1fjyPBzNmQGwsjBoF9+6BvPz/fOrrC+vWAY8HmzeH7d1rJyEh0YOpYx+Az0Yx7JMSFxePiYlZunRpQ0ODvb29t7d3JwcjBKtWQWwsqKnBjRvtaygAuLjAjRtgaXnh6FHHqVOnVlRU9GDq2IcgDMN6g5eXF3GZv3r1ah6P1+Exhw5VAiAZGfT0aWehUlNTtbW1AUBHRyc9Pb1H0sU+DJdRDOs1ISEhkpKSAGBtbV1XV9fu0wsXLoiLy06Z8joi4uOhSkpKTE1NAUBJSemff/7pkXSxD8AX9RjWaxwcHGJjYwcMGBAdHT1lypSCgoLWj+7du+fi4sLhvHVwiLK1/XioQYMG3b1718nJqampyd/fHyEEAAcPHmxubu65/DECLqMY1pvMzMwePHigq6v7/PnzCRMmPHnyBN61yJvL4XA2bdr0/fffdzGUhITExYsX79+/T9wiAIC8vDw+n9+D2WMAgJ/UY1hfUF1dPXfu3H/++UdGRubUqVOenp6vXr2ysbEJDw/vyiYi7SxbtozJZALAzZs37969KyMj0wMpY//B0+8xjAJFRUWysrJycnIlJSUSEhKKiordGq6kpBQTE7Ny5cqAgIBFixYhhExMTEJCQoSooYR9+/aJiIgIt3gf6y58UY9hFLh27VpaWhoAxMTEEBfm3SUuLn7+/HlDQ0MGgwEARkZGksK2wJOXl6fRaAAgJydHTAbAehQ+G8Uwajx+/LipqSkjI0NTU1O4CCwW6/nz5xISEgwGw9fXt6am5vz581LEuqXuaJ2LevDgQeEywboF/6TCMGoghAQCgUDYVZl//fXXnj176HR6aGhoXFyciorK5cuXLSwsSktLqc0ToxwuoxhGDVNTUysrKwMDg6ampv3793frEfndu3fXrl0LAN7e3nZ2dpMmTXrw4MGIESOSkpLGjRv37NmzHssao0KvzlrF+pP09PQjR45UV1dzOByEEJvNZrPZxEeVlZXE7PGgoKDr16/3Zpa9JCUlpaSkBCGUlpY2ffp0ALCxsamvr+/K2IyMDOKR1NatW9u+X1lZOWXKFACQlZW9ceNGj+SNUQFPeMK6KjIycsCAAcXFxbKystOmTYuJieHxeHZ2drt27VJWVq6vr1dVVXVxcWGxWLt27ertZHvTw4cPZ8+eXV5ePnr06IiIiMGDB3dycGVlpZmZWVZW1ty5c0NDQ9s9EeJwOMTje1FRUW9v73Xr1vVw7pgw8EU91m01NTUlJSU1NTUAkJeXR6fTN27c6OHhkZiYiH8qA8CECRMePnyop6f34sWLCRMmdNIQj81mz5o1Kysra9y4cf7+/u8/VRcXF79w4QKLxWppaVm/fr2bm5vQ916xnoPLKNYlbR90JCcnR0dHE9N66uvrlZWVifelpKS4XC7xurm5OT8/HwA4HE5eXt6nTre36ejoJCQkWFhYlJSUfP311+Hh4e8fgxBycXF58OCBtrZ2RESEtLR0h6FoNJqnp+fZs2cZDIa3t7ejoyNe39nX4DKKfVxSUtLEiRNba4GlpeWKFSumTZvG5/MHDx789OlTHo9XU1PDZrPFxcWJY/Lz8/39/QGgvLz81KlTvZZ671FUVIyOjl66dGljY+PcuXPfb4i3ffv2gIAAOTm58PDwj3bCX7FiRWRkpLy8/KVLl7Zs2dLU1AQAFRUVDQ0NPfUbwLoMl1HsI968ebNq1So2m00sidHR0dHQ0ACAwYMHS0pKxsTEbNq06ddffz116lS7W6K5ubl///33w4cPeyfvPkBMTMzPz8/Lywsh5ObmtmbNmtbN7M6ePXvw4EEGgxEWFjZ69OiuRLOyskpISLC1tdXQ0Hj58iUAXL58GT/E7wvw9Pt+o7KyUkRERElJ6UMHlJaWSklJycnJUfiltbW1ixcvrqysnDp16vLly8PDwz08PIgJ4Xp6enp6eqWlpYMGDdLX1yeODwoKap0u3tLSwmaziV2Fv2Rubm5qamrLli07depUfn5+cHDwkydPiIdF3t7eVlZWXQ9lYGAQERFx9OjRtLS0lpaWvLw8AwODHksc6ypcRvuNvXv3LliwIC0tzcXFBQB8fX1dXFx4PN7Jkydra2tHjBghJiaWlZW1detWqr6Rx+OtXr06Ozt71KhRPj4+0tLSlpaW7Y4ZNGhQ2186OTm1vh4+fLi1tXVBQUF6ejpVKfVTDg4OGhoas2fPjo6ONjU1LS0t5XK5Hh4exFxRIZSXl8vIyNTW1lKbJyYcXEb7DXl5+QkTJly8eJH4JXE1d/78+SFDhtja2hYVFSkoKGRlZVH1dQihH3/88d69e6qqqn/99deHHoB8yMCBA4nzLA6H067U9kcvX77Mz8//9ttvc3NzU1NTZ86c2d0IZmZmCQkJ1tbWr169AoDp06fv2bNH6HwsLCyMjY3Ly8uFjoBRCN8b7Wfq6+v37du3b9++3NxcAHjx4sU333wDAOrq6tR+0dGjR+Pi4mRkZC5evKimptbd4YqKiuPHj8/Ozh45cuSePXt4PB616RHy8/NjYmI6OYDD4Tx9+jQ6OprkF1VVVeXk5ABAbW3t69evhQuirq4u/+9uSvfv3+88805MnDiR+BMxNTXV0tISLghGIVxG+xk5OTkPDw8PDw8dHR0AUFFRKSoqovxbzp8/TzwOPnnyZOt9TyEMHTp05MiRFRUVt27dojC9VrGxsRISEoGBgcQp3uXLl58/fw4Av//+O4vFcnd3f/nyZVxcXExMDPnpllevXnV3d//jjz+EGy4QCBYvXvz06VNtbe358+e/ffvWzs7u+PHjQoQaP348cYJvbGwsdBsUjEK4jPZjZ86cWb58+ZEjRw4dOnTixAmqwsbHx3/33XcIoc2bN0+dOpVkNOJuaWBgIBWpdUBLS6u+vp6Yr9rQ0MDhcDIyMhobG3ft2rVnzx5ZWVkhun92yN7e/sCBA0Qv+tbpsV23devWK1euKCkpRUdHh4SEsFgsgUCwceNGPKP+M4DLaL/B4XAePnyopaVFzIT38vIyNDRUV1c/efLk+vXr169fn52dTf5bsrOz582bx+FwNm/evGHDBvIBnZ2daTTalStXGhsbyUdrq2318fX13bt3L3HxXlBQMGLECAAQFe3o1j/pTTWqq6tHjBgRHBzc9SFnzpw5cuQIg8EICQnR1dUlZtQHBgZKSEh4e3vPnz+fmAeK9Ve9uaAf647Hjx87ODgwmcw///yzwwP++eefrKwsMl9RWVk5fPhwALC1tW1paSETqq3x48cDQFBQEFUBEUKvXr0yNzf/5ZdfcnNzT548+eLFC4SQn59fUlLS69evWSwWcVh2dvbx48d37drF5/NRfT1auRJ5eKClS1H3/0cJBALiBYvFAgAREZHDhw93ZWBUVJSoqCiNRvPz82v30b1791RUVADAyMiooKCguylhfQQuo/1JREQEk8mcPn16TwRns9mTJk0CgHHjxjU2NlIY2cvLCwBmz55NVcDy8vKvvvqKyWTa2trm5uaGhoa+fv0aIRQeHh4cHBwXF3f69GkWi7Vt27bMzMygoKB3ZfT33xGx83BZGVqzhkwCrVvMr1q1isvldnJkamoq8ViptbK38/r1a+LcWV1d/Wnnu9FjfRUuo/0Jm83W1dVlMpkkzzo7VF9fb29vr6CgQPlpUVlZmaioqJiYWFVVFflozc3NdnZ2TCbT2trax8fn+PHjbT/lcrk5OTlt38nKynJ2dubz+WjbNpSb++7dBQtIphEWFkZs8mFlZVVbW9vhMcXFxUR7pwULFrSezL6vbUO8yMhIkolhnx4uo/3Mpk2bmEzmoUOHKI9MPONWVFQk2olSi5i3f/r0aZJxBALB2rVrmUzm+PHjy8vLm5qaSktLOx/y3zGhoeivvxBCKDEReXqSzAQh9PDhQ2It/KhRo968edPu08bGxq+++goAJk+e3NqY9UPYbLazszMAiIqKnjhxgnxu2KeEy2g/8/fffzOZTDMzs26NOnDgQLsXHRo1ahQA9ETfZV9fXwCYOnUqyTi7d+9mMpkjRozIyMjo9mA+Hx0+jLZtQzt3IirOixFCOTk5enp6AMBkMh8/ftzmq/izZ88GgCFDhpSXl3cllEAgIO66Ojo63r17FyGUlZV1+/ZtSvLEehQuo/0Mj8czNDScMmXKs2fPuj5q8eLF7V50aO/evQDg7OxMKsWO1NXVSUpKioiIFBYWCh0kMDBQTU1t8ODB9+7dEz6Vly+RmRkyNxc+wv+qrq62sLAAAGlp6WvXrhFvurq6AoCysnJmZma3okVFRd26devs2bMIoQcPHhw7doyqPLGeg8to/+Pu7g4AP/74Y1cOfv78eVRUlL29/bZt27Zt22ZiYtLJwXl5eTQaTVpa+u3btxQl+585c+YAwJEjR4QbHh0dLSoqamlpGRwcTCqPhgYkLY1otP/uk5LG4/HWrFkDAHQ6/cCBAz4+PgAgJiZ2584dIaLFxsba2Nhs27ZtyZIluIz2C7iM9j/3798HADU1tU7mJOXn53t5eZmYmACApqbmokWLiPc7PxtFCJmZmQFAQEAAlRkjhBAKCQkBgDFjxnz0RuH70tLSFBQUAODnn3+mIBVHRwSADh6kINS/BALB7t27id3haTQajUa7ePGicKFiY2Px2Wj/gqff9z9mZmbDhg0rLi6Oj49v91FZWdmxY8cmTpyopaW1adOm5ORkZWVlGxub1t0pxMTEOg++cOFCALh5k/omoRMnTpSUlCwoKJCRkTEwMHB0dPT09Lx+/fpH+2uUlJTMmDGjtrbW0dGRml2eFi4EAKB0YRWNRvv5558PHDggIiIiISExdOhQOzs7CuNjfVpv13FMGB4eHgCwevVq4peNjY0hISF2dnYMBoP4Y5WUlLSzswsJCenuY/fS0uoRI9LExKh6BvMOm802NzcHAEVFRTqd3u4voZaW1uzZs1ks1pUrV3L/91q7qamJmL0/efLk5uZmarLhcJCSEgJAqanUBEQIIVRQUEB0DCG2ADA2Ni4qKhIiDo/HI/7UiIatFGaI9RBcRvslooOnoqLipUuXlixZ0trFjk6nW1pa+vn5dXFr3w59+y0CQD4+lGUrEAiWLFkCAGpqavn5+Y2NjQ8fPjx58uSaNWvGjx/f2ua5lYKCgoWFxQ8//HDu3Dmi296QIUPKysooSwgh5OKCABAltwgQQgjV19cbGRkBgLm5eUZGxsiRI4nfb3JyMlVfgfVZuIz2Py0tLTdv3lRUVCTuxAGAiIjIN9984+PjQ8n89nPnEAD65hvykd7ZuXMnAMjKyn5olU5RUVF4eDiLxbKzs2vXnFRZWVlOTq67z7s/ih8bW2Zq6jNrViez4ruupaWF6EA6cuTI6upqhFBVVdXXX38NADIyMj0xgQzrU3AZ7U9SU1O3bdvGZDKJEiMmJiYvL89isdqt2yGprg5JSiIREUTJaqbAwEAajUan08PDw7s4pKioKDIycu/evRMnTgQAIyMjCvL4X3w+n+jQSmwKTdL3328CgAEDBmRnZ7e+yeFwiHNwOp3+xx9/kP8WrM/CZbQfSE1N3bFjx5AhQ1rP0UaMGLFp0yYajSYlJdUTk5PmzUMAiPxSqbt37xI3CoV74tzQ0CAjI0Oj0XKpm5zU6ocffgCATZs2kYxz6BAaMeKZtvawhISEdh8RM+qJiwZXV1c+n0/yu7C+CZfRvqugoMDLy4toF0JQU1NzdXWNj48nLkWJjy5cuED5V4eFIQDU6RzTj8vKyiLaF3VximuHiHal+/fvJ5VKR5KSkgBg0KBBZHpZXbmCREQQjYZCQz/YoCQoKEhCQgIA7O3tqe35gvURuIz2CWw2u3WZ/M6dO48fPz558uTWW5+KiorffffdnTt32p3OHDt2DABsbW0pz6e5Gdnbo4sXkUCAGhqEiUBVz71r164BgKGhodAROkG0Vrp165Zww5OTkbQ0AkAfLfK4Id7nDZfRPqGxsbF19pKjoyMxu1NCQqLzSUvl5eUMBoPBYFRUVFCekq0tOnsWIYSWL+/22ObmZuK2pomJSYNwZfhfXC5XWVkZAIiOotQinn2tXLlSiLGFhUhDAwGgFSu6dHxGRgZxW2bYsGF1dXXEm3g+0+cBT7/vK5KSktzd3d3d3cXExHbs2HH+/PmKiorr1687ODh8aM78gAEDpk2bxuPxwsLCKM+HyYT796GyEgAgMxMKCro6ECG0atWq+/fvq6urX7t2rbtbirbDYDDmzp0LAEFBQWTidIhYnxoSEjJu3LilS5f+/vvv9+7da25u/ujA5mawtobCQrC0BB+fLn3XyJEjk5KSpkyZsmbNmp9//hkA2Gz2xo0byf0OsL6ht+s4htD/no1+dL1mW35+fgAwc+ZMylNatQrl5qLvv0fLl6Pp0xEAUlBAkyYhV1fk54ceP0YfOpHavn07AMjJyaWkpFCSyZ07dwBAS0uLkslJrfh8PlGgW2+eEBgMhqGh4ebNz48cQXfuoOrq/4YUFKD8fIQQys1Fv/6KDAz+59OuaGlpqaqqWrt2bV1dXXl5+apVqyj8HWG9Be9T3yfQaDSiBzAAvD8dvRNz5szx9/d/+vRpcXGxENsgd05bG5hMSEkBdXVQUoLqakhIgISEd59+882G8vK/Tf5lZGQkIyNz7ty5/fv3MxiMsLAwQ0NDStL4+uuvNTQ03rx5k5iYOGHCBEpiAsBPP/10+fJleXn5qKgoPp+f/K/MzMznz5+XlAysqHh3pJYWGBmBkRGIikJsLNy6BUFBYG8Pbm7wsbW17REruJ4/f37s2LGWlhaqfi9YL+vtOo6RtXr1aiaT2a4JPBn376NffkHEvkFsNtq37937b96ga9fQrl1ozhyko4MMDL5q+xdJRERER0eHKBPk2zO3s3nzZgBwdXWlKuDp06cBgMFgvN/Qs7GxMTHx0cmTaM0aNH48kpJCAO/+27YN/fYbOnoU7d+PhOh3SqiqqiJ+I83Nzfhs9POAy2i/d+PGDSaTaWVlRUm07Gw0YAACQO9tv9ZeXV1dfHy8j4+Pq6vrpEmTiDk96urqFhYWlGTS1qNHjwBg4MCBPB6PfDSi5x6NRvuLaIbfqZYWlJ6OAgPRTz+h339Hjx6hNWuQq6vwZbShocHf3x8hxOVyz5w5I2QUrC/BZbTf43K5enp6TCaT/IrJ2lo0ahQCQNbWqLv1isPhEFvX6evrk0yjQ7q6ugBw8+ZNknFa95jbuXNnd8eeOIEePULFxWjQIOHLKPb5wU/q+z0Gg2FtbQ0A4eHhZOLweDBvHqSmgoEBBAVBh3u8d0JMTGz9+vXKysrp6ekvXrwgk0mHiHn4geS625WUlNjY2NTV1RFt+ro7/OuvQUsLBg2C//s/qK4mkwj2eentOo5R4O7du8QGTUI/yxYI0LJlCAAxmei9zdm6gWgCv337duFDfMDr168BQE5OrqmpSbgI3dpjrhOHDyMA1J35FNhnDp+N9ksvXrzw8PCoqqp68+ZNSEiIgoKCqqpqYWHhlStXAKC4uPjy5ctbt27tesCDB/949qxWRgYiImDwYOETI7o+E43fhY/SkWHDhpmYmNTX10dFRQkxXCAQODs7JyUlDRky5PLly8RKf+HY2wONBleuQGOj0DGwzwouo/1SY2Ojubn527dv9+/fb2homJaWdurUKT8/v99++620tDQjI4PBYHR93ntAQICHh9urVzphYVXGxqQSMzc319LSys/Pf/DgAalAHSFq9P79++Pj4+vr67s19ocffrh27ZqysnJUVNSAAQPIpDFkCHz1FTQ2QkQEmTDY5wOX0X7s9u3bK1asGDlypJOTk6mpqYyMzOLFiw8dOtR6QEVFBYfD6TzIvXv3iNWQBw/unj5dmWRKNBrNwcEBSN/E7JCEhISMjExycrK5ubm8vLyamtrMmTM9PT1DQ0PT0tI6Of89deqUt7e3mJhYaGgosY6epB7YhQTrx2iUX3xhn8DDhw9ra2uLi4v19PSITegA4NGjR9nZ2c3NzXl5eePGjUtOTi4rK4uMjBw6dKiBgYGBgcHo0aP19PSIJeqEnJycCRMmVFRUuLm5Ec/ZyXvy5ImJicmAAQOKi4tFu/ug6sPi4uKsra25XK65uXljY2Nqamq7nxAqKipGRkZjx441MjIyMjLS1dUlJrFGRUXNmjWLz+f7+fkRDUDJKy8HdXUQEYHiYlAm+6MH6/fwKqZ+zMrKateuXdLS0oWFhSNHjnz79i0ALF261N7efty4cQDQ1NQEAJmZmZmZmZcvX9bU1ExKStLU1DQyMhozZsywYcN++eWXiooKGxubw4cPU5WVsbGxvr5+enr67du3iSkE5L18+XLevHlcLnfr1q2//vorALS0tGRkZDxro7Ky8vbt27dv3yaGSEpKjh49WlNTMyoqqqWlZffu3VTVUAAYOBAsLODWLbhyBa1aRfv4AOyzhs9G+yXibNTa2jo/P3/btm3Ozs4DBgyg0WhMJnPw4MF5eXni4uI+Pj6enp5sNvvly5dpaWlpaWlVVVUBAQENDQ2tcaSkpIYMGfLgwQMZGRkK09u9ezeLxVq6dCmx5J+kyspKMzOzrKwsOzu7q1evvr8jHqG4uDg5OTk9PT0tLS05OTkjI4P4u62qqmpgYHD79u12a+dJCgws8fI6q6DwMCbmOoVhsX6pN6cJYMLKyck5cOBAVVUVsaeIhYUFm81u29bz3r17hw8ffn8gn8/PzMwMDg52d3fX0dEBgA0bNlCeXlZWFo1Gk5WVFXpyUiuhe+7V1NTExcXZ2toCgJOTE8k03ldXVycpKSkiIlJYWEh5cKx/wWW0Hztx4gSTydTW1n78+LEQw4lt7jU1NXticwtTU1MACAkJIROEmKUEANra2qWlpUJEyMvL67mtVogGUR3+uMK+KLiM9lc3b97U0NBQU1O7fPmycBEEAoG2tjYAxMfHU5sbQujIkSMAMGfOHDJB3N3dAUBOTu758+dCByFOZgMCAshk0qHQ0FAAGDduHOWRsf4Fl1HK3Llzp+3GkB919+7dV69eCfddT548GTJkCJPJFG6ruFbbtm0DgPXr15MJ0qHi4mI6nS4uLl5TUyNcBF9fXwBgMBgk19H/8ccf0DMtWZubm4nl+ZTv/4z1L7iMUmbTpk2VlZUzZsyorKzkcrnELmyenp7Ep8SL+vp6d3d3T0/PI0eOZGRk7NmzR4gvys3N1dXVnTJlyg8//EAy52fPngGAiooKl/vBHdmENnXqVADw9fUVYmxcXBzR8//PP/8kmUZ5ebmoqCiDwaisrCQZ6n3Lli0DgHXr1vXE/0Csv8DT7ykjJyenrKysoqJCXM9WV1cDQCWxC8e/L/z8/Ozt7Vks1saNG4mdeQICAu7fv9/1NTl1dXV2dnaZmZlycnIHDx4kmfOYMWP09fUrKyvj4uJIhnqfpaUljUbbsGHD5MmT3dzc/P3909LS+Hz+RwdmZGTMmTOHy+Vu37597dq1JNPo0a1Whg0bJi8v/+eff0pJSRkYGCxduvTgwYPXr19v/XPHvgR43ijFBg4cqKGh0boUsqGhYd++fQCQlZUFAG/evCFmLzIYDC6Xy+Fwtm7dihACgMGDBxu0oaGh8X5wHo/n4OCQlpamr69/4cIFBoNBPmFXV9dz585FRER8++235KO1qq6uPnfuHACw2eyEhISEf5vmi4mJEZUuFqgAABKrSURBVKvjCcbGxu26/VdWVs6cObO2tnb+/Pl79uyhJJmFCxfGxMQEBgYSnVOokpKS8uuvv759+1ZVVbW8vDw9PT09PZ34iMFgDB3aMGqUGNE238gI1NUBAMLCwMAA9PQgNBQcHCjMBetVvX06/Pkg+lf++OOPXC53zZo1RH3cuHEj8Snx4sSJE63PczgcjoeHx9atW21sbHR0dJht2NraysvLT5o0ydXV1cfHJz4+nuhIRJyaDRo0KC8vj6q0c3Nz1dTUhg4dSuEW6lwud9q0aQAwatSoly9fhoeHs1gsBwcHfX39dpM36XT6kCFD7OzsWCxWeHh4Xl4esU2IqakphfnU19cTk5Mo3Ny4uLhYU1MTABYsWCAQCOrr6+Pj4//44w8XFxcTExMDg3GtPfOJ/wYMQFZWaOlStHQp4vOF2W8V67Pw2SjFNDQ0GAzG8uXLExMTjx8/zmQyifeZTKaPj8/ChQsPHz58584dJSWl1atXS0lJ7dixAwD4fH52djYxST41NZXL5dbV1bU9iRMXF2cymXl5eVJSUuHh4VpaWlQlrK2tPXbs2CdPnty+fXvWrFnkAyKEVq1aFRsbq6amduPGDU1NTV1d3ZkzZxKfVlVVPX36tHXpUWZmZk5OTk5OTkSbPh86OjqRkZHd2pOqc7Kysra2tmFhYUFBQVu2bCEfsKmpyd7evqCgYMqUKX5+fsQk2cmTJ0+ePJk4oKUFMjMhPR3S0iA5GZKSoLwcHj2C+fNh5kzw9SWfAtaX9HYd/3wsW7YsPT297TsvX75s+8uM/22Yfu3atU4eMRUVFd26dcvLy2vJkiX6+voiIiIAoKioKNxTqc6dPn2ayWSu6OKG6x9DtEOWkpJKSkr66MFcLjc1NdXPz4/YiURMTIxOpx88eJCSTNq6dOkSABgbG5MPxefzZ8+eDQBDhw4tLy/v4qi8PBQfj4i9l5YvR7Nnk08E6ytwGaVMaWlpfX19t46vq6vr4sF1dXWLFy8GgLVr1wqVXWfKyso0NDQGDx4s9OSkVkFBQTQajU6nX716VYjhx44dAwBbW1uSabyPzWYrKCgAANELiozvv/8eAJSVlYWY50SU0ZwcxGSSzALrQ3AZ7TdSUlIAQElJicPhUB7c0dGRyWSSnKMeHx9PtEP29vYWLkJFRQWDwRAVFS0rKyOTSYdWrFgBACwWi0yQo0ePAoCYmNidO3eEGE6cvCYloZUrEel6jvUVuIz2J6NGjQKAiIgIyiOHh4fv2LEjKSmp89012Gz2h85Ys7OziXbImzZtIpPJjBkzgIrpou+7efMmcSUu9FYrkZGRdDqdRqOdP3+eTCarVyMA5OFBJkbHmpubExISEEI8Hu+ff/6h/guwjuAy2p/s3bsXABYtWtRD8RcsWJCRkZGSkvLLL7/s2bMnPz8fIZSZmfnw4UOEUG5u7sWLFxcuXPj+wMrKSqIdso2NTdsOKULw9/cHAHNzczJBOsTn89XU1ADg0aNHQgxPTk4m+mCRvz0dF4cAkJYWEraef1BFRQXxY6yxsXH16tUUR8c+AE+/708WLVpEo9GuXr3attkdhXR1dTU1NU+cOOHu7u7q6rpr1y4AKC8vz8vLA4Cqqioulzt8+PB2o7hcroODw6tXr4yNjYODgz/UyK6L7O3tpaSk4uPjiS+lkIiICNHwiZgkHxMTU1ZW1sWxxcXFs2fPbmhoWL58OTG5ggxzc9DQgDdv4OFDkpE68OLFi5MnT/ri2QCfEC6j/YmWltaECRMaGxuvX++pHpc5OTmGhoaioqKysrKysrLNzc0AEBERsXfv3g81D33x4sXjx481NTWvX79Ovm+prKzsunXrbGxsiGtwCjU3NyclJcnKymZkZLi7u1tbWw8aNEhJSantIiuBQPD+wLdv39rY2BQWFpqbm588eZJ8JiIisGABQM9sQ6KlpWVtbW1lZUV9aOwDcBntZ4ht3XpipyOCsrJy6zlaY2OjhIQEANjZ2e3YsYNYP96KOFcFgIiIiLt370ZERBCXzORZWlo+efKE2rWbCKFVq1alpKQoKCh4eXm5uroSGzrV1NQkJCR4e3svW7Zs1KhRxKqHDRs2nD59+vHjx2w2m8/nL1q0KCUlZeTIkVevXiWzpWhbxG5OwcHQ0kJJPAAA4meenJyctrb2YDL7u2LdhKff9zNOTk6bN2+Ojo6uqqpS7oFtgNTU1KSlpQ8fPtzQ0DBlypTY2FjiH+f7iOWtxAsjIyMKc5g2bZqCgkJqampmZqauri4lMbdv3x4QECAnJxcZGTl69GjiTYRQbm5u2+UAhYWF9+/fv3//PnGAqKioiopKaWnpwIEDb9y4oaioSEkyAGBiAiNGQHk5io8vt7BQJR+Qx+PNnj2byWQS6wskJCSIiVnYp9DbN2exbiMWv/v4+FAe+YcffiCmstbV1RGN69PS0kpKSoj2RS0tLZWVla1tpaysrNzd3d3d3adMmUJ5Jps3b2Yymb/++isl0c6cOQNd67lXU1MTHx9PrHowMTERFxen0+kyMjIXLlygJJO2Dh++Li4ut5yiZaEuLi4AwGQycTf+Tw+X0f6HaPnxzTffUB45PDw8JyenkwOysrJap1stXry43QsKxcfHM5lMMzMzoScntSLTc6+pqYnYL3r79u0k03jf69evAUBOTo78VivEFA5JSUliTgX2ieEy2v+07gJEYaMNIbQ2e+6Jrs98Pn/s2LFMJvPJkydk4qSlpRGLlzyEnaX5999/A8DgwYPJF/T3mZiYAEBYWBiZIFevvqTT6SIiIleuXKEqMaxbcBntl+bPnw8AXl5evZ1ID2KxWLNmzUpMTBQ6QklJCdHDxcHBQej9pgQCARGEmNZOrUOHDgHAvHnzhI5w/z6SkEBmZsFeXkKuHMPIw2W0X7p58+aZM2d4PF51dXW7jiefDT6fX1dXt3bt2tevX5eUlPj7+8fGxpaWlhJ7T7X2G4yLi/P09Hz/pmdTUxNVPfe2bt0KAK09DylUVFREp9MlJCRqa2uFGJ6TgwYORADou+8oTw3rBjzhqV+SlpbmcrmioqJv3ryJjIzs7XR6hIiISEtLy8iRI1VVVbdt22ZmZsbhcMrKygoLCwEgODiYOOzSpUv29vbt1iMIBIJFixY9fPhQR0cnIiKCZM89YpJZcHBwC4WzkwAAQE1NbdKkSWw229XV9cGDB42NjV0fW1cHs2ZBeTlYW8OJE9TmhXUPnvDUXz169EhOTi4/P594fvIZe/Lkybfffjts2LBhw4a1Lm0qLy8nlgPU1dW9P+TKlStXrlxRUlKKiooaOHAgyQTGjh2rr6+fnp5++/Zta2trktHa4vP5zc3Nampq/v7+/v7+IiIiw4cPNzIyGjt2rLGxmaGhueqHp0LFxcHLlzBmDISEgCj+d9yr8Nlof6Wurm5oaPj+0szPD51O53K57d5UUFCwtLS0tLRse6YZEBBAvOBwOEeOHLl8+TJV004XLFgAPbDqwc3N7dGjR01NTfPmzTMyMqLT6ZmZmcHBwe7u7lu3Xh40CJSUYPJkcHMDf39ISwOBABYsAGLC7rNnEBEBEREgK0ttUli34Z9i/ZWamtro0aP5fP6bN296O5eeZWpqevr06WHDhlVUVOjp6fF4vMePH4uJiamrqwNA2w2pbty44ezsTLy4cOEChTksWrTI09PzypUrJ0+elJSUpCTm0aNHjx8/LiEhERkZOXHiRADgcrlpaWnEQoCGBpvcXKipgYQE+HcPBBg9GvT1Yc8e+OsvePMGPD0pSQQjC5fRfklXV5e4VtXW1razs+vtdHqWuLj48ePHExMTid7Ss2bNevr06bp164hP161bx+PxiNdZWVnu7u4AUFNTQ20OQ4cOHTdu3KNHjyIiIhyo2IsuMjJy69atNBrtzJkzRA0FADExsbFjx44dO5b4pa8vFBdDcjIkJ7/bj0RXF2RkwMICgoLIp4BRp7efcWHYBzU2Nu7bt+/Vq1ft3ufxeK2vORzOoUOHUlJSEEKtLQR7opcgsW/2nDlzyIdKTk6TlpYGgL1793ZrIIeDXFyQQICWLEFOTuQTwaiB741ifZeUlNT27dvfv/8r2uaRipiY2I8//mhoaNjTyTg5OdHp9MjIyOrqajJxiopg7lxdE5PlK1as8PDw6NZYMTFQUQEaDbZvB4p6pGAUoCGEejsHDKNGWVmZqqpq2xfUsrS0jI2N9fX1XblypXAR6uth8mR48QKmTYOoKD6DIUxvVoRgyxYIDYWnT6EHutNg3YbPRrHPR2vp7IkaCqS7FPL5sGgRvHgBenoQGgrC1VAAoNEgLQ0KCoDSVoKY8HAZxbCumjdvnri4+J07d4qKioQY7uoKERGgogLh4UCy5R7RrrTHus5i3YMv6jGsG0xNTdPS0iQlJY2NjfX19U1MTExMTPT09EREPnJGcuwYfP89SEpCXByMH082jbdvQVUV2GzIzQUtLbLRMJJwGcWwroqJibGzsxMVFWWz2W3fl5eXt7PzVFHZZGQERkagrw+tK8tiYmD6dEAIoqPh//4Ptmx5dyJJnqMjhIbCb7/Bli3UBMSEhi/qMaxL0tPTnZycWlpatmzZUlRUFB4ezmKx7OzsmExmXV1dUdGI33+HFStg7FiQlYWxY2HFCrhwAdasgevXQSCAS5cgMZGyGgrCXtef+Hf5/Qm8Dp86+GwUwz6upKRkwoQJ+fn5jo6OQUFBNBqt3afp6YxHj1SePoVnzyArC4id8RYsABkZaG6GP/+EzZvhzBkqU+JwYPjwWi2ty2fOfKOrO6SLo5YsWXL+/Pm2LzDy8ComDPuI5ubmOXPm5OfnT5482c/Pr10NBQAmk8lkwrRp737Z0ADPn0NKCujowKVL8NNPcPAg9VmJi4OV1ZazZ30DAna2bi/Yifz8/MLCwrq6OmKhV2ZmJvU5fanwRT2GdUYgEDg7OycmJg4ZMuTSpUvEVqmdk5GBiRNh3TogukGNGQN8fo/ktnChEwBcvHixk2vKmpoaf39/KysrbW1tFxcXeXn5AwcOHDhwgKqmLRjgs1EM69yPP/549epVJSWlGzduCNFzb8kSAAAPD3j6lPrcpk6dqqamlp2d/fjxY1NT07YfNTQ0XL16NTAw8NatW0TPAUlJyTFjxlDeMhUDwGvqMezDTp06BQAMBiM2Nra3c+mYm5sbALRu19rS0nLr1q0lS5bIyMgQ/8DpdPqkSZN8fHzq6+sRQhwOhziy9QVGHn7EhGEdi4qKmjVrFp/P9/PzW0KcVfY9iYmJEyZMYDKZQUFBly5dCgwMrKioID4yMTFZsmSJk5NTD63pwlrhi3oM60BqaurChQtbWlo8PT37bA0FABEREQUFhZKSkq+//pp4Z8yYMc7Ozk5OToMHD+7d3L4cuIxiWAdu375dX1+/ZMmSnTt39nYuHcjLywsODj537hzxwF1SUpJOp69cuXLZsmXGxsa9nd0XB1/UY9g7JSUlly5d2rhxY01Nja+vr76+vqWlZZ/a6qqwsDA4ODggIODJkyfEO4MGDbKysjp//ryiomJJSYk4bp/XG/DZKIa9w+VyS0tLAaClpaW4uHhLn1llWVNTc/369dDQ0OjoaOJRu7y8/KxZsxwcHKytrRkMxvPnz1NSUqKjo2fPnt3byX6JcBnFsP/ExcW5u7s3NzfT6UJ2sSOpqanp4sWL3333HZ/P9/b2VlVVDQwMvHnzJrGpn4SEhL29vbOz84wZM9rOYF24cGFKSkpgYCAuo70Cl1EM+4+FhcWePXsqKir279/fKwnweLyUlBQAEAgEiYmJYWFhfD6fmLS0dOlSJycnOTm590c5Oztv3779+vXrDQ0NrVOdsE8Gl1EMe0dUVFRBQQEA6HS6kpJSb6Xx4MEDd3d3gUAgJSW1YcOG4cOHOzo6dj7zX1NTc9KkSffu3bt69erixYs/WaoYAT9iwrA+pK6ubseOHceOHePxeGvWrDl79mwXB544cWLDhg02NjaRkZE9miH2PrymHsM+B46OjgwG4+bNm+Xl5b2dyxcHn41iWN+CECKaSLW+6CIbG5uoqKgTJ06sW7eux7LDOoDPRjGsb2ktnd2qoUB6xz1MaPhsFMM+E42Njaqqqk1NTTk5Odra2r2dzhcEn41i2GdCWlra1tYWIRQSEtLbuXxZcBnFsM8HcV0fHx/f24l8WXAZxbDPx4wZM/bs2RMeHg4AYWFhvZ3OlwKXUQz7fIiLi798+ZJ4NnXt2rXeTudLgVcxYdhn5fXr1zt27ACA2tra3s7lS4HLKIZ9VoYPH757924AWL58eW/n8qXAZRTDPje91Z7qi4XnjWLYZ6WgoEBTU7PtC6yn4TKKYRhGCn5Sj2EYRgouoxiGYaTgMophGEYKLqMYhmGk4DKKYRhGyv8DZH5tPie62ZIAAAPjelRYdHJka2l0UEtMIHJka2l0IDIwMjEuMDMuNQAAeJztlXtI01EUx7fpHpo/t+k293Rqapazlall1HZLTCvKEkKiJEsjK9JaBZqRgpCBLVdoVDYjiPqjrOxBWel+oyCrpT0gkLQwe0AlBr0bRttxlpWcLZgV0Q/u+P7u53vPuefe+7vrba5/wHA8AY7GZPQ/Ex0t2dHKmAxBjLPDR8Zx/E7bULgmw6BWsijXi7OtzJ27cU24nOMaqmQMAblfYSynP6CvDI0R68rLdJuXieUdFJA5EBCN4amNI8iHZRnS57YMdzV9W67hL9jTSrgDB8Hd9kI4Fuu37C/v1+v4V3webq/H6yz07Mz99evCdR3AIX0/H9Q/EO9XviO34Xj9PuaQvu8+D4+uXe/auIhtUK3evZr/236weXziPNrTv7lS79q88xclHL68PCzvoIAjmCyBzM+hpxcW5GUY8pYbvl8OH5T6YpTBxCibg1IuGpmNUh5G/Udg1M8fpQEYDaAwKgzCqECI0mCM8gUoFWFUJMaoJASjUhlG5QqMKpQYVYViVKlCqRqjESNRGonSKIyGR6A0GqWjMBoWjtIYlI7GqDoMpWNQGotRmRylGozGjUWpFqXjMKqJQ+l4jIZIURqPUbEEpRMwGshHaQJGqUCUJmKU54fSJPSuQ+9JFXojKdC1EvlwAoQCfiDFEUsUSpWIEyKVyRWSkAELYyK7nm3NObSn2fnCNVPWbl6V3qn9jWJrgSqCOLWpp4d+v60V+tNSIq37hWrQhkyxNYU+Z3Hqrmca6/qoatCFyyirujiJdupYbQfdVhEM/ZmPL9FbD/NhbNYVG61j94HeUlxPJ8xNg1wbGo10a5dJ59SJnYvpuraz4HkV2GdpS9gF+v6OJsuJN5Uw57BsFZ1VfQbid54qoSs+mkCnR5rphelCmINmst0S050AunZp98X3Wgo8NwyfdO+u2UFr0u363FN88ITlqUjO7FWgOxtLSIt0M+iWUWYSP2cC6MtpRrIqvwHGXkueQmpvGkFbipWkdKcZ5s81FemXfBbDnJvUr3U1UgbUuI6/iFTaz0P/rjvbyaKZUdC/WnWMvBIVgE7Nv0FS1taCDj39nFD3LKA3sY4Q5cULoPmtveTurCLQSeW3yNRSLeiD5yrI/AW7QVe1zyPUw1zQ2ZMayLwVNyFvR0oQKQpWQH95z05SQ3phzoczbWSfPBVqPBrfQWztVaAbgl6SWdFNoGssvtOMr0tBxz09Tm43HgBdZn5B/Os+wDp07G/Sl1Tuhf7rkz81m07OAC2+WmrpeyKEvHrzZtpWlgg6OsNGP3r7GcZKvgB82Gx6B58FLQAAA5F6VFh0TU9MIHJka2l0IDIwMjEuMDMuNQAAeJydV0uu5DYM3PcpdIE2xJ9ELYP3Mhggk3lAAuQOAWaZ+yOkpZbkQQI8s9ELF2SVSyySph/Jf3+8//b3P2n+8P3xSCJJakr5P/+ttfQX5pwfdvtTDxKufpUPbArOkQ9bzelb+j+K/T9YVLL6XjgAqmwsb59naQdxaecpDiHKMS31YBLsWgpQ2Vi+fpblCRaNUrjvLQgcYTlPROgKnuCqSiQurkVzGSwglcMeUXFnnmhuAcROVA7V02nLF6mFYk7L0TK2vlfKRcv3O1qotdydbrXUqBbGroAsdzlYAWwsOk6EesndG1roYIFxIsbMMRaPRh0swIhRFtbcRmeoFNSCdiLVwQe9R0Ti0ggHC/SKCrDw0SDXrgpr3j26UQEW3YKDRbEEq9F3lBFdEYh1TNvB2vClqkKMxfcSjLiwxGo6udNdCx2l5BZjcacJX5633aPPd4bkTsM4kWaI5YuxMEju0SUtQS14NIbBYukXqwCPLvOIKV1ZbmjJ1hlezohK0CPLusrjPZ3zJXc/7jhtrWnMDMwS61LuUT5r2mcGDXaGJAdVLV1VxUtnuMFi7yM537CmSuUyBd3wqNrMwNxVtca7R5/vUrYXoUG/UrrU9A0Wm6WsCHtctLbQLOVxEejVg0e1l22Mha03Afar0mowLmRzHVG/kpIlxiI2n/ZZ2WbMzDXGYt1WhUd1I4XjYucY1cOlBp223LWhMJ19N9e2n+hG7vp0eHrk81CLvkmsAup5Dp8TIQedVvueKdpPZN88GGOx6bCcc7tPDy34HeAnKudM6O9pszrG4hMZUNdSm8ZYnj4zaO1xgcyxCjAWiymMLL7my40pyJzhOljs6yTHtHju9m9YcI9aRIulh8UTJuAdyARw4gEsLeoOdL+t7KC9gA0lMAlsKvAhZYGpwK5gKgBNsAiq4wUwT1AcL4CT2q5wPtSSDyc1SsIp1IZanNR2hfOhlrq02JrjDUxqkkRlB3UHk9o+JUh20DbAk9q6NPEGGHawHoqOF+ALWCctfr4FeCpgA3UHuoOpzTZw2YCsGLDHcQFZoUIP9wKyrBe3aAFZ1rPjBWRlYvMkWUDWbbrljpmzWa9Lwe8p/fLtzzSS+MvZkb23vxa8n5jAL2fpvW0LXlrkC373z4ueznPXx7bgmXkuvP3ou14Lftb1nB/bgoyFj7R2/Pr9/fEvoSjx0LmQzLUAAAJSelRYdFNNSUxFUyByZGtpdCAyMDIxLjAzLjUAAHicbVNLbtxQDLtKl07gPOj/wSy96Wp6gKI3yeFLPU8CFOgsPLbMJ5EU/X49j+t4f3vf198//7zN/zE3+4Gv46t4HZe8nvT+f17H8/V6rt+nnpdO1+/a/2+f/x665Nc9hvH04/P48GXCVKcuZmM/Hx+xtKvz5NUZKaj4apLKk5YHs96gKso4P1DLkOb7YFmghpPNVSjVUre0gUkXS6PWS1VCB2bqPt2YVtF9kj2198nScKBklYPaXXIqAzHmtLhbWbSeslyVplNOT3FgAkRfvSXCQD6ENUaPQXNVoyQlnYqSrlbJ3gzAjjeqmaKGgSTRMJBlXsWbOlOOQmgNSd48oSp2yYpatuhU9WlGiwhMm3Vb5uy4exCQDcXbssgbaFWgBEZMBgMe80phwPAwF0wYGi02mAgqH4zVLAaks0tAbASpyLmVNaH16MFvMyV2mDwLc+rBUHaiTy441LX5mKgMBoK5p7O1q21MJkZMLHh0PgrLjcw9q4fYA6kKjzmEJJjOcISLtnNaW0LDwR2CMdK2KDPskpZS5pimWBMWhF2aOddApBzpAFSUYrp6kMxuDUntPYYoJw81RilWrzLhBs56eLnCqIkH2WTbIabgha4UAh/odUZPtEh8GDYtxZC301Z0Ts7hmocVCuVpt2lq2Dz8aJvY+xJuxNGR4ZdlUDZDKhvbxt47Cdj5ojD9FYW08hlMtL/D+f6SRj7DB9vZgL2sfE4iO2LnFtaMQ7IDigVYznsM7j7fPv8CXuDrO8cJsvgAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "substruct = Chem.MolFromSmarts(smarts)\n", + "substruct" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "id": "137ae95f", + "metadata": {}, + "outputs": [], + "source": [ + "# Important: this is the manually curated smarts string because MCS took too long to run" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b3126cbf", + "metadata": {}, + "outputs": [], + "source": [ + "smarts_manual = '[#1,#6,#7]-[#6]1-[#6](-[#6](-[#6]' \n", + "smarts_manual+= '(-[#6](-[#6]-1-[#1])-[#1])'\n", + "smarts_manual+= '-[#6]1-[#6](-[#6]2-[#6]'\n", + "smarts_manual+= '(-[#7]-[#6](-[#7]-[#6]-2-[#7](-[#6]-1-[#8])-[#6](-[#6](-[#6](-[#7](-[#1])(-[#1])-[#1])(-[#1])-[#1])(-[#1])-[#1])(-[#1])-[#1])-[#7](-[#6](-[#1])(-[#1])-[#1])-[#1])-[#1])-[#1])-[#17])-[#1]'" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "025fadd4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# draw the new substrure for clarity\n", + "substruct = Chem.MolFromSmarts(smarts_manual)\n", + "\n", + "substruct\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "2711f2a7", + "metadata": {}, + "outputs": [], + "source": [ + "# determine the mapping of the core atoms based on the substructure match\n", + "\n", + "substruct = Chem.MolFromSmarts(smarts_manual)\n", + "\n", + "core_mappings = [] # list of mappings to substructures\n", + "\n", + "for mol in mols:\n", + " core_mapping = [i+1 for i in mol.GetSubstructMatch(substruct)]\n", + " core_mappings.append(core_mapping)\n", + " \n", + " #print (core_mapping)\n", + " #print ('\\n') " + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "22be5e93", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[3,\n", + " 10,\n", + " 11,\n", + " 12,\n", + " 13,\n", + " 14,\n", + " 15,\n", + " 43,\n", + " 42,\n", + " 16,\n", + " 17,\n", + " 18,\n", + " 22,\n", + " 23,\n", + " 24,\n", + " 25,\n", + " 19,\n", + " 20,\n", + " 21,\n", + " 32,\n", + " 28,\n", + " 29,\n", + " 30,\n", + " 31,\n", + " 56,\n", + " 57,\n", + " 58,\n", + " 54,\n", + " 55,\n", + " 52,\n", + " 53,\n", + " 50,\n", + " 51,\n", + " 26,\n", + " 27,\n", + " 47,\n", + " 48,\n", + " 49,\n", + " 46,\n", + " 45,\n", + " 44,\n", + " 1,\n", + " 41]" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "core_mappings[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "238dbdb3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "25" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "core_mappings[2][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 246, + "id": "5916c9d4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "working on this\n" + ] + } + ], + "source": [ + "# Now that the mapping has been established, write the perturbed topology\n", + "\n", + "# ligand 1 core region is \n", + "# [1:] is because i couldn't remove that one extra atom in the smarts string, but it shouldn't be there \n", + "\n", + "lig1_core = core_mappings[0][1:]\n", + "hybrid_top = Top(reduced_tops_path+'/PAK_openff_hybrid.top')\n", + "out_path = reduced_tops_path+'/PAK_openff_hybrid_v2.ptp'\n", + "\n", + "constructPerturbedTopology_v2(hybrid_top, tops, lig1_core, core_mappings, out_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 242, + "id": "439098d8", + "metadata": {}, + "outputs": [], + "source": [ + "def findIndexInSingleTop(hybrid_id, core_mappings, initial_lig_num):\n", + " \"\"\"\n", + " This function will find the index that a hybrid atom had in its initial topology \n", + " \n", + " \"\"\"\n", + " #print ('looking for hybrid atom ' + str(hybrid_id)+ '\\'s original id in ligand ' + str(initial_lig_num)+' topology')\n", + " \n", + " # 1: Find index in core of ligand 1\n", + " idx = core_mappings[0].index(hybrid_id)\n", + " \n", + " # 2: return the ID of the other ligand\n", + " return core_mappings[initial_lig_num-1][idx]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 247, + "id": "eb931d36", + "metadata": {}, + "outputs": [], + "source": [ + "def constructPerturbedTopology_v2(hybrid_topology, single_topologies, lig1_core, core_mappings, out_path, alphalj = 1.0, alphacrf = 1.0):\n", + " \"\"\"\n", + " This function will create the perturbed topology for our hybrid topology. \n", + " All ligands atoms will be written down (so energies in the EDS blocks of the output match what we want).\n", + " \n", + " Shared core atoms will have the same atom type code in all states. \n", + " -R groups will be dummy in all other states. \n", + " \n", + " note: The core isn't sorted so there are ligand 1 -R group atoms in the middle of the ptp.\n", + " \n", + " v2: now also changes the parameters of the core region \n", + " \n", + " Parameters\n", + " ----------\n", + " hybrid_topology: pyGromos Top \n", + " regular topology from which we will create the hybrid topology\n", + " lig1_core: List [int]\n", + " list of atoms which make up the core (present for all perturbed states)\n", + " core_mappings: List [List[int]]\n", + " list of atoms in the substructured. The inner lists follow the same order\n", + " so the second element in each sublist corresponds to the same hybrid atom\n", + " \n", + " \n", + " out_path: str\n", + " path to save the output ptp in\n", + " \n", + " alphalj: float\n", + " alpha parameter for the LJ interaction\n", + " alphacrf: float\n", + " alpha parameter for the CRF interaction\n", + " \n", + " \"\"\" \n", + " # count number of residues\n", + " num_atoms = hybrid_topology.SOLUTEATOM.content[-1].ATNM\n", + " num_states = hybrid_topology.SOLUTEATOM.content[-1].MRES\n", + "\n", + " dummy_iac = hybrid_topology.ATOMTYPENAME.content[0][0] # assumes dummy iac is always last\n", + "\n", + " # open the output file.\n", + " f = open(out_path, 'w')\n", + "\n", + " # Write title block.\n", + "\n", + " date_time = datetime.now().strftime(\"%d/%m/%Y %H:%M\")\n", + " f.write('TITLE\\n\\tFile created automatically from ' + hybrid_topology.path +'\\n')\n", + " f.write('\\tby ' + os.environ['USER'] + ' on ' + date_time + '\\nEND\\n')\n", + "\n", + " # Write the MPERTATOM block\n", + "\n", + " f.write('MPERTATOM\\n# NJLA: number of perturbed atoms\\n')\n", + " f.write('# NPTB: number of listed perturbation (i.e. number of perturbation states)\\n')\n", + " f.write('# NJLA NPTB\\n')\n", + "\n", + " # Write the values to NJLA and NPTB:\n", + " f.write('\\t' + str(num_atoms) + '\\t\\t' + str(num_states) + '\\n')\n", + "\n", + " # Write state identifiers\n", + " identifiers = \"\"\n", + " for i in range(num_states) : identifiers += \"ligand\"+str(i+1) + \"\\t\"\n", + "\n", + " f.write('# identifiers of the states\\n\\t' + identifiers +'\\n')\n", + "\n", + " # comment to understand the content\n", + " f.write('# NR NAME IAC(1) CHARGE(1) ... IAC(n) CHARGE(n) ALPHLJ ALPHCRF\\n')\n", + "\n", + " # Loop over topology atoms to include in the ptp\n", + "\n", + " for atom in hybrid_topology.SOLUTEATOM.content:\n", + "\n", + " ptp_str = '\\t' + str(atom.ATNM) + '\\t' + str(atom.PANM) +'\\t'\n", + "\n", + " # charge offset to make formating look good\n", + " q_offset = ' ' if atom.CG > 0 else ''\n", + "\n", + " if atom.MRES == 1 and atom.ATNM in lig1_core:\n", + " for i in range(num_states): \n", + " if i == 0:\n", + " ptp_str += str(atom.IAC) + '\\t' + q_offset + \"{:.5f}\".format(atom.CG) + '\\t'\n", + " else: # write parameters of the core from other topologies\n", + " \n", + " # Find the mapping for that atom:\n", + " idx_singletop = findIndexInSingleTop(atom.ATNM, core_mappings, i+1)\n", + " tmp_iac = single_topologies[i].SOLUTEATOM.content[idx_singletop-1].IAC\n", + " tmp_q = single_topologies[i].SOLUTEATOM.content[idx_singletop-1].CG\n", + " \n", + " q_offset = ' ' if tmp_q > 0 else ''\n", + " \n", + " ptp_str += str(tmp_iac) + '\\t' + q_offset + \"{:.5f}\".format(tmp_q) + '\\t'\n", + " \n", + " \n", + " \n", + " \n", + " else: # Dealing with -R groups (params already good in the perturbed top)\n", + " for i in range(num_states):\n", + " if i == atom.MRES-1:\n", + " ptp_str += str(atom.IAC) + '\\t' + q_offset + \"{:.5f}\".format(atom.CG) + '\\t'\n", + " else:\n", + " ptp_str += str(dummy_iac) + '\\t ' + \"{:.5f}\".format(0) + '\\t'\n", + "\n", + " # Always prepend alpha LJ and alpha CRF values\n", + "\n", + " ptp_str += \"{:.5f}\".format(alphalj) + '\\t' + \"{:.5f}\".format(alphacrf) + '\\n'\n", + " f.write(ptp_str)\n", + "\n", + " # close the block\n", + " f.write('END\\n')\n", + " f.close()\n", + "\n", + " return None\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7c82f525", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/dev/hybrid_topologies/hybrid_topology_maker.py b/examples/dev/hybrid_topologies/hybrid_topology_maker.py new file mode 100755 index 00000000..7229a89e --- /dev/null +++ b/examples/dev/hybrid_topologies/hybrid_topology_maker.py @@ -0,0 +1,1040 @@ +import os, copy, glob + +from datetime import datetime + +import numpy as np +import rdkit + +import pygromos +from pygromos.files.blocks import topology_blocks as blocks +from pygromos.files.topology.top import Top +from pygromos.files.coord.cnf import Cnf +from pygromos.files.blocks.coord_blocks import atomP + + +def reduceConformations(path_cnf, out_path, contains_protein=False): + """ + This function will make a cnf for each possible ligand (alone in water or in complex) + based on the given re-eds dual topology type cnf. + + These reduced conformations can be used for single ligand simulations, as well as + to reconstruct the Hybrid conformation. + + Parameters + ---------- + path_cnf: str + path to input cnf + out_path: str + path to output file + contains_protein: bool + + Returns + -------- + None + + """ + + # Open the cnf containing everything. + cnf = Cnf(path_cnf) + + # Count number of ligands + residues = cnf.get_residues() + if 'WAT' in residues: del residues['WAT'] + if 'SOLV' in residues: del residues['SOLV'] + num_ligs = 0 + for key, value in residues.items(): + if 'LI' in key: num_ligs += 1 + + # Make a cnf for each single ligand solvated + + for i in range(num_ligs): + # 1: Make a copy + tmp_cnf = copy.deepcopy(cnf) + + keep_res_at_id1 = False + + # 2: Remove all other ligands + for j in range(num_ligs): + if i == j: + keep_res_at_id1 = True + continue + + # delete_residue renumbers residues so we need to keep track of which one to remove + if (keep_res_at_id1): + tmp_cnf.delete_residue(resID=(2)) + else: + tmp_cnf.delete_residue(resID=(1)) + + # 3: Print results to a file + if contains_protein: + tmp_cnf.write(out_path = out_path +'/complex_' + str(i+1) + '.cnf') + tmp_cnf.write_pdb(out_path = out_path +'/complex_' + str(i+1) + '.pdb') + else: + tmp_cnf.write(out_path = out_path +'/ligand_' + str(i+1) + '.cnf') + tmp_cnf.write_pdb(out_path = out_path +'/ligand_' + str(i+1) + '.pdb') + + return None + + +# We will keep track of all of the data of PerturbedAtoms +# in this class, by making a list of PerturbedAtoms (called atom_mappings) +# which will then allow us to construct the cnf and ptp files +class PerturbedAtom: + + def __init__(self, atom:str , init_lig:int, init_id:int, new_id:int): + """ + Create object with data given as input + """ + self.atom = atom + self.init_lig = init_lig + self.init_id = init_id + self.new_id = new_id + + def __str__(self): + return ('atom: ' + self.atom + ' ' + 'initial ligand: ' + str(self.init_lig) + + ' initial id: ' + str(self.init_id) + ' new_id: ' + str(self.new_id)) + +def find_new_id(atom_mapping, init_lig, init_id): + """ + This function will return the new ID of the atom which belong + to the initial ligand init_lig and and an initial id init_id, + from the list of atom mappings + + Parameters + ---------- + mappings: List [PerturbedAtom] + + """ + + for am in atom_mapping: + if am.init_lig == init_lig and am.init_id == init_id: return am.new_id + + # if we reach this we have a problem + raise Exception("We did not find the atom you were looking for in the list\n" + + 'init_lig: ' + str(init_lig) + ' and init_id: ' + str(init_id)) + +# +# +# +def findAtomsInCoreAndRGroup(topo, connection_point): + """ + This function will find the list of atoms in a molecule + which belong to the "core" region, and those which belong + to the "-R group" + + This function even works when there are multiple connecting points, + (i.e. if multiple -R groups exist) + + Parameters + ---------- + topo: pygromos topology + + connection_point: (int, int) or (List[int], List[int]) + first element is the atom (or list of atoms) in the core region + second element is the atom (or list of atoms) in the rgroup + Returns + --------- + (core_atoms, rgroup_atoms): (List[int], List[int]) + atom ids of the core region and rgroup in the topology + """ + + # 1: Make the list of all bonds in the molecule + + bonds = [] # will be a list of tuples + + for bond in topo.BOND.content: + bonds.append( (bond.IB, bond.JB) ) + for bond in topo.BONDH.content: + bonds.append( (bond.IB, bond.JB) ) + + num_atoms = topo.SOLUTEATOM.content[-1].ATNM + + # 2: Initialize results data structure + + if isinstance(connection_point[0], int): + core_atoms = [connection_point[0]] + else: + core_atoms = connection_point[0] + + if isinstance(connection_point[1], int): + rgroup_atoms = [connection_point[1]] + else: + rgroup_atoms = connection_point[1] + + # 3: Iterate over the list until all atoms have been categorized + + niter = 0 + + while len(core_atoms) + len(rgroup_atoms) != num_atoms: + for bond in bonds: + # If its the connecting bond, this needs to be skipped + if bond[0] in core_atoms and bond[1] in rgroup_atoms or \ + bond[1] in core_atoms and bond[0] in rgroup_atoms: continue + + if bond[0] in core_atoms and bond[1] not in core_atoms: core_atoms.append(bond[1]) + elif bond[1] in core_atoms and bond[0] not in core_atoms: core_atoms.append(bond[0]) + + if bond[0] in rgroup_atoms and bond[1] not in rgroup_atoms: rgroup_atoms.append(bond[1]) + elif bond[1] in rgroup_atoms and bond[0] not in rgroup_atoms: rgroup_atoms.append(bond[0]) + + niter += 1 + if niter > 500: break # This is just to kill the unfinite loop + + return (sorted(core_atoms), sorted(rgroup_atoms)) + + +# This file contains all of the functions used to build hybrid topologies +# the functions were moved here to mke the jupyter notebook lighter. + +def addHybridAtoms(core_top, new_lig_top, new_lig_rgroup, atom_mappings): + """ + This function will add all of the atoms from a new + ligand into the topology with the core. + + Parameters + ---------- + core_top: topology + Core gromos topology object which will be updated (atoms added to this object) + new_lig_top: topology + Gromos topology object of the other ligand for which we will add atoms to core_top + new_lig_rgroup: List [int] + List of atomIDs in new_lig_top to add to core_top + atom_mappings: List [HybridAtoms] + List of HybridAtoms object keeping track of the atom renumbering + + Returns + -------- + core_top, atom_mappings: Topology, List[HybridAtoms] + core_top is the updated topology object + atom_mappings is the list keeping track of the atom renumbering + """ + atnmShift = core_top.SOLUTEATOM.content[-1].ATNM #Number of atoms found in main top. Shift secondary top atoms accordingly + mresShift = core_top.SOLUTEATOM.content[-1].MRES #Number of molecules found in main top. + + # Loop over all atoms in the new topology and add if it is in new_lig_rgroup + atom_counter = 0 + + for atom in new_lig_top.SOLUTEATOM.content: + if atom.ATNM not in new_lig_rgroup: continue + atom_counter += 1 + core_top.add_new_soluteatom(ATNM = atnmShift + atom_counter, + MRES = mresShift + atom.MRES, + PANM = atom.PANM, + IAC = atom.IAC, + MASS = atom.MASS, + CG = atom.CG, + CGC = 0, # we will make the entire perturbed region one charge group. + INE = [], # these will be filled in after all ligands have been added! + INE14 = []) + + # Keep track of the atoms that were added in the mapping list. + atom_mappings.append(PerturbedAtom(atom = atom.PANM, + init_lig = mresShift + atom.MRES, + init_id = atom.ATNM, + new_id = atnmShift + atom_counter)) + return core_top, atom_mappings + + +def addHybridBonds(core_top, new_lig_top, new_lig_rgroup, atom_mappings): + """ + This function will add all of the bonds from a new + ligand into the topology with the core. + + This includes the bonds that the -R group forms with itself + + the one connecting bond between the core region and the R group. + + Parameters + ---------- + core_top: topology + Core gromos topology object which will be updated (atoms added to this object) + new_lig_top: topology + Gromos topology object of the other ligand for which we will add atoms to core_top + new_lig_rgroup: List [int] + List of atomIDs in new_lig_top to add to core_top + atom_mappings: List [HybridAtoms] + List of HybridAtoms object keeping track of the atom renumbering + + Returns + -------- + core_top, atom_mapping: Topology, List[HybridAtoms] + core_top is the updated topology object + atom_mappings is the list keeping track of the atom renumbering + """ + + # Since this will be called just after adding the bonds, + # we assume that the number of residues in the topology equals the residue we are currently working for. + # NOTE: might have to change this if I make the core different than the -R groups? + mres = core_top.SOLUTEATOM.content[-1].MRES + # Debugging statement to see things more clearly in the file. + + debugging_mode = False + + if debugging_mode: + newBond = blocks.top_bond_type(IB=99999, JB=99999, ICB=99999) + core_top.BOND.content.append(newBond) + core_top.BOND.NBON += 1 + + for bond in new_lig_top.BOND.content: + if (bond.IB not in new_lig_rgroup) and (bond.JB not in new_lig_rgroup): continue + + # note: we need to atom_mappings to be properly set here. + newBond = blocks.top_bond_type(IB=find_new_id(atom_mappings, mres, bond.IB), + JB=find_new_id(atom_mappings, mres, bond.JB), + ICB=bond.ICB) + # Append this new bond to the topology + core_top.BOND.content.append(newBond) + core_top.BOND.NBON += 1 + + # Do exactly the same thing for bonds containing Hydrogens + + if debugging_mode: + newBond = blocks.top_bond_type(IB=99999, JB=99999, ICB=99999) + core_top.BONDH.content.append(newBond) + core_top.BONDH.NBONH += 1 + + for bondh in new_lig_top.BONDH.content: + if (bondh.IB not in new_lig_rgroup) and (bondh.JB not in new_lig_rgroup): continue + + newBond = blocks.top_bond_type(IB=find_new_id(atom_mappings, mres, bondh.IB), + JB=find_new_id(atom_mappings, mres, bondh.JB), + ICB=bond.ICB) + # Append this new bond to the topology + core_top.BONDH.content.append(newBond) + core_top.BONDH.NBONH += 1 + + return core_top, atom_mappings + +def addHybridAngles(core_top, new_lig_top, new_lig_rgroup, atom_mappings): + """ + This function will add all of the angles from a new + ligand into the topology with the core. + + This includes the bonds that the -R group forms with itself + + the one connecting bond between the core region and the R group. + + Parameters + ---------- + core_top: topology + Core gromos topology object which will be updated (atoms added to this object) + new_lig_top: topology + Gromos topology object of the other ligand for which we will add atoms to core_top + new_lig_rgroup: List [int] + List of atomIDs in new_lig_top to add to core_top + atom_mappings: List [HybridAtoms] + List of HybridAtoms object keeping track of the atom renumbering + + Returns + -------- + core_top, atom_mappings: Topology, List[HybridAtoms] + core_top is the updated topology object + atom_mappings is the list keeping track of the atom renumbering + """ + + # Since this will be called just after adding the bonds, + # we assume that the number of residues in the topology equals the residue we are currently working for. + # NOTE: might have to change this if I make the core different than the -R groups? + mres = core_top.SOLUTEATOM.content[-1].MRES + # Debugging statement to see things more clearly in the file. + + debugging_mode = False + + if debugging_mode: + newAngle = blocks.bondangle_type(IT=999999, JT=999999, KT=999999, ICT=99999) + core_top.BONDANGLE.content.append(newAngle) + core_top.BONDANGLE.NTHE += 1 + + # Here we want to include all bonds that have at least one atom + # that is part of the -R group. + for angle in new_lig_top.BONDANGLE.content: + if angle.IT not in new_lig_rgroup and angle.JT not in new_lig_rgroup and \ + angle.KT not in new_lig_rgroup: continue + + # note: we need to atom_mappings to be properly set here. + newAngle = blocks.bondangle_type(IT=find_new_id(atom_mappings, mres, angle.IT), + JT=find_new_id(atom_mappings, mres, angle.JT), + KT=find_new_id(atom_mappings, mres, angle.KT), + ICT=angle.ICT) + # Append this new bond to the topology + core_top.BONDANGLE.append(newAngle) + core_top.BONDANGLE.NTHE += 1 + + # Do the same thing for bonds with hydrogen: + + if debugging_mode: + newAngle = blocks.bondangle_type(IT=999999, JT=999999, KT=999999, ICT=99999) + core_top.BONDANGLEH.content.append(newAngle) + core_top.BONDANGLEH.NTHEH += 1 + + for angle in new_lig_top.BONDANGLEH.content: + if angle.IT not in new_lig_rgroup and angle.JT not in new_lig_rgroup and \ + angle.KT not in new_lig_rgroup: continue + + # note: we need to atom_mappings to be properly set here. + newAngle = blocks.bondangle_type(IT=find_new_id(atom_mappings, mres, angle.IT), + JT=find_new_id(atom_mappings, mres, angle.JT), + KT=find_new_id(atom_mappings, mres, angle.KT), + ICT=angle.ICT) + + # Append this new bond to the topology + core_top.BONDANGLEH.append(newAngle) + core_top.BONDANGLEH.NTHEH += 1 + + return core_top, atom_mappings + +def addHybridTorsions(core_top, new_lig_top, new_lig_rgroup, atom_mappings): + """ + This function will add all of the angles from a new + ligand into the topology with the core. + + This includes the bonds that the -R group forms with itself + + the one connecting bond between the core region and the R group. + + Parameters + ---------- + core_top: topology + Core gromos topology object which will be updated (atoms added to this object) + new_lig_top: topology + Gromos topology object of the other ligand for which we will add atoms to core_top + new_lig_rgroup: List [int] + List of atomIDs in new_lig_top to add to core_top + atom_mappings: List [HybridAtoms] + List of HybridAtoms object keeping track of the atom renumbering + + Returns + -------- + core_top, atom_mappings: Topology, List[HybridAtoms] + core_top is the updated topology object + atom_mappings is the list keeping track of the atom renumbering + """ + + # Since this will be called just after adding the bonds, + # we assume that the number of residues in the topology equals the residue we are currently working for. + # NOTE: might have to change this if I make the core different than the -R groups? + mres = core_top.SOLUTEATOM.content[-1].MRES + # Debugging statement to see things more clearly in the file. + + debugging_mode = False + + if debugging_mode: + newTorsion = blocks.top_dihedral_type(IP=99999, JP=99999, KP=99999, LP=99999, ICP=99999) + core_top.DIHEDRAL.content.append(newTorsion) + core_top.DIHEDRAL.NPHI += 1 + + # Here we want to include all torsions that have at least one atom + # that is part of the -R group. + for torsion in new_lig_top.DIHEDRAL.content: + if torsion.IP not in new_lig_rgroup and torsion.JP not in new_lig_rgroup and \ + torsion.KP not in new_lig_rgroup and torsion.LP not in new_lig_rgroup: continue + + # note: we need to atom_mappings to be properly set here. + newTorsion = blocks.top_dihedral_type(IP=find_new_id(atom_mappings, mres, torsion.IP), + JP=find_new_id(atom_mappings, mres, torsion.JP), + KP=find_new_id(atom_mappings, mres, torsion.KP), + LP=find_new_id(atom_mappings, mres, torsion.LP), + ICP=torsion.ICP) + # Append this new bond to the topology + core_top.DIHEDRAL.append(newTorsion) + core_top.DIHEDRAL.NPHI += 1 + + # Do the same thing for torsions with hydrogen: + + if debugging_mode: + newTorsion = blocks.dihedralh_type(IPH=99999, JPH=99999, KPH=99999, LPH=99999, ICPH=99999) + core_top.DIHEDRALH.content.append(newTorsion) + core_top.DIHEDRALH.NPHIH += 1 + + for torsion in new_lig_top.DIHEDRALH.content: + if torsion.IPH not in new_lig_rgroup and torsion.JPH not in new_lig_rgroup and \ + torsion.KPH not in new_lig_rgroup and torsion.LPH not in new_lig_rgroup: continue + + # note: we need to atom_mappings to be properly set here. + newTorsion = blocks.dihedralh_type(IPH=find_new_id(atom_mappings, mres, torsion.IPH), + JPH=find_new_id(atom_mappings, mres, torsion.JPH), + KPH=find_new_id(atom_mappings, mres, torsion.KPH), + LPH=find_new_id(atom_mappings, mres, torsion.LPH), + ICPH=torsion.ICPH) + # Append this new bond to the topology + core_top.DIHEDRALH.append(newTorsion) + core_top.DIHEDRALH.NPHIH += 1 + + return core_top, atom_mappings + + +def addHybridImproperTorsions(core_top, new_lig_top, new_lig_rgroup, atom_mappings): + """ + This function will add all of the angles from a new + ligand into the topology with the core. + + This includes the bonds that the -R group forms with itself + + the one connecting bond between the core region and the R group. + + Parameters + ---------- + core_top: topology + Core gromos topology object which will be updated (atoms added to this object) + new_lig_top: topology + Gromos topology object of the other ligand for which we will add atoms to core_top + new_lig_rgroup: List [int] + List of atomIDs in new_lig_top to add to core_top + atom_mappings: List [HybridAtoms] + List of HybridAtoms object keeping track of the atom renumbering + + Returns + -------- + core_top, atom_mappings: Topology, List[HybridAtoms] + core_top is the updated topology object + atom_mappings is the list keeping track of the atom renumbering + """ + + # Since this will be called just after adding the bonds, + # we assume that the number of residues in the topology equals the residue we are currently working for. + # NOTE: might have to change this if I make the core different than the -R groups? + mres = core_top.SOLUTEATOM.content[-1].MRES + # Debugging statement to see things more clearly in the file. + + debugging_mode = False + + if debugging_mode: + newTorsion = blocks.impdihedral_type(IQ=99999, JQ=99999, KQ=99999, LQ=99999, ICQ=99999) + core_top.IMPDIHEDRAL.content.append(newTorsion) + core_top.IMPDIHEDRAL.NQHI += 1 + + # Here we want to include all improper torsions that have at least one atom + # that is part of the -R group. + for torsion in new_lig_top.IMPDIHEDRAL.content: + if torsion.IQ not in new_lig_rgroup and torsion.JQ not in new_lig_rgroup and \ + torsion.KQ not in new_lig_rgroup and torsion.LQ not in new_lig_rgroup: continue + + # note: we need to atom_mappings to be properly set here. + newTorsion = blocks.impdihedral_type(IQ=find_new_id(atom_mappings, mres, torsion.IQ), + JQ=find_new_id(atom_mappings, mres, torsion.JQ), + KQ=find_new_id(atom_mappings, mres, torsion.KQ), + LQ=find_new_id(atom_mappings, mres, torsion.LQ), + ICQ=torsion.ICQ) + # Append this new bond to the topology + core_top.IMPDIHEDRAL.append(newTorsion) + core_top.IMPDIHEDRAL.NQHI += 1 + + # Do the same thing for torsions with hydrogen: + + if debugging_mode: + newTorsion = blocks.impdihedralh_type(IQH=99999, JQH=99999, KQH=99999, LQH=99999, ICQH=99999) + core_top.IMPDIHEDRALH.content.append(newTorsion) + core_top.IMPDIHEDRALH.NQHIH += 1 + + for torsion in new_lig_top.IMPDIHEDRALH.content: + if torsion.IQH not in new_lig_rgroup and torsion.JQH not in new_lig_rgroup and \ + torsion.KQH not in new_lig_rgroup and torsion.LQH not in new_lig_rgroup: continue + + # note: we need to atom_mappings to be properly set here. + newTorsion = blocks.impdihedralh_type(IQH=find_new_id(atom_mappings, mres, torsion.IQH), + JQH=find_new_id(atom_mappings, mres, torsion.JQH), + KQH=find_new_id(atom_mappings, mres, torsion.KQH), + LQH=find_new_id(atom_mappings, mres, torsion.LQH), + ICQH=torsion.ICPH) + # Append this new bond to the topology + core_top.IMPDIHEDRALH.append(newTorsion) + core_top.IMPDIHEDRALH.NQHIH += 1 + + return core_top, atom_mappings + +def addLigandToTopology(core_top, new_lig_top, new_lig_rgroup, atom_mappings): + """ + This function will add all of the atoms from a new + ligand into the topology with the core. + + Returns a new topology object which contains the hybrid topology + + Parameters + ---------- + core_top: topology contains the first few ligands + + new_lig_top: topology of the new ligand for which we will + add some parameters + + new_lig_rgroup: List [int] + indices of -R group atoms of core molecule + """ + + # Add Bonds, Angles, etc. + + (core_top, atom_mappings) = addHybridAtoms(core_top, new_lig_top, new_lig_rgroup, atom_mappings) + (core_top, atom_mappings) = addHybridBonds(core_top, new_lig_top, new_lig_rgroup, atom_mappings) + (core_top, atom_mappings) = addHybridAngles(core_top, new_lig_top, new_lig_rgroup, atom_mappings) + (core_top, atom_mappings) = addHybridTorsions(core_top, new_lig_top, new_lig_rgroup, atom_mappings) + (core_top, atom_mappings) = addHybridImproperTorsions(core_top, new_lig_top, new_lig_rgroup, atom_mappings) + + return core_top, atom_mappings + +# +# Helper functions +# + +def get_bond_list(topology): + """ + returns a list of tuples + corresoponding to all bonds + in the topology. + """ + bonds = [] # will be a list of tuples + + for bond in topology.BOND.content: + bonds.append( (bond.IB, bond.JB) ) + for bond in topology.BONDH.content: + bonds.append( (bond.IB, bond.JB) ) + + return bonds + +def find_12_neighbours(atomID, bonds): + """ + This will find all of the directly bonded atoms to atomID + + Returns + ------- + neigh12: List [int] + list of neighbours + """ + neigh12 = [] + for a, b in bonds: + if a == atomID: neigh12.append(b) + elif b == atomID: neigh12.append(a) + + return sorted(list(set(neigh12))) + + +def find_13_neighbours(atomID, bonds, neigh12): + """ + This will find all of 1,3 neighbours of atomID + + Returns + ------- + neigh13: List [int] + list of 1,3 neighbours + """ + + neigh13 = [] + for a, b in bonds: + # skip all bonds which don't include a member of neigh12 + if a not in neigh12 and b not in neigh12: continue + if a == atomID or b == atomID: continue # don't add the atom itself + + # If we reach here, figure out which one is not the second neighbour + if a in neigh12: neigh13.append(b) + else: neigh13.append(a) + + # Remove potential duplicates, and sort + return sorted(list(set(neigh13))) + +def find_14_neighbours(atomID, bonds, neigh12, neigh13): + """ + This will find all of 1,4 neighbours of atomID + + Returns + ------- + neigh14: List [int] + list of 1,4 neighbours + """ + neigh14 = [] + for a, b in bonds: + # skip all bonds which don't include a member of neigh13 + if a not in neigh13 and b not in neigh13: continue + if a in neigh12 or b in neigh12: continue + + # If we reach here, figure out which one is a third neighbour + if a in neigh13: neigh14.append(b) + else: neigh14.append(a) + + # Now we need to remove any potential "false" 3rd neighbour + # which occur for cyclic systems. + + for neigh in neigh14: + if neigh in neigh13 or neigh in neigh12: neigh14.remove(neigh) + + return sorted(list(set(neigh14))) + + +def findLastAtomsOfResidues(top): + """ + This function finds the last atom of every residue from the topology, + and returns this as a list of ints (atom IDs). + """ + last_atoms = [] # list to append results to + prev_res = 1 + for atom in top.SOLUTEATOM.content: + if atom.MRES != prev_res: + last_atoms.append(atom.ATNM-1) + prev_res = atom.MRES + + # Always need to append the last one manually + last_atoms.append(top.SOLUTEATOM.content[-1].ATNM) + return last_atoms + +def addExclusions(core_top, lig1_atoms): + """ + This function will add back the exclusions (1,2/1,3 intra/inter ligand) + as well as the 1,4 between the core of molecule 1 and the new side chains that + were added to the molecule. + + Before we start writing this function we have: + + Ligand1 core with all its exclusions with itself ok. + --> Add the 1,2/1,3 and 1,4 with all additional ligand rgroups + + Ligand1 rgroup with all its exclusions with itself ok. + --> Add the exclusions with all atoms of the new R groups that were added (INE) + --> all of its INE14 are already properly setup because they are with itself and with its own core. + + Ligands 2 ... N: + --> Add the full exclusions with other ligands (with larger atomID) + --> Add the INE14s with itself (not with the core, with itself) + (be careful to exclude fake 1,4 of other hybrid parts) + + """ + + core_atoms, lig_r1_atoms = lig1_atoms + bonds = get_bond_list(core_top) + + last_atoms = findLastAtomsOfResidues(core_top) + + for atom in core_top.SOLUTEATOM.content: + # find neighbours: + neigh12 = find_12_neighbours(atom.ATNM, bonds) + neigh13 = find_13_neighbours(atom.ATNM, bonds, neigh12) + neigh14 = find_14_neighbours(atom.ATNM, bonds, neigh12, neigh13) + + # case 1 - ligand 1 core + if atom.MRES == 1 and atom.ATNM in core_atoms: + + # Here we will just recalculate everything + atom.INEvalues = sorted([x for x in neigh12+neigh13 if x > atom.ATNM]) + atom.INE = len(atom.INEvalues) + + atom.INE14values = sorted([x for x in neigh14 if x > atom.ATNM]) + atom.INE14 = len(atom.INE14values) + + else: # -R groups + + # We need to add to the 1,2/1,3 exclusions all atoms belonging to residues N and above + full_excl = sorted(neigh12+neigh13) + + # Do not add the exclusions with other ligands to test (see if ptp does that automatically) + # to do so, uncomment next line + #full_excl.extend(range(last_atoms[atom.MRES-1]+1, last_atoms[-1]+1)) + + atom.INEvalues = [x for x in full_excl if x > atom.ATNM] + atom.INE = len(atom.INEvalues) + + # For the 1,4 exclusions, include only what is part of the same ligand. + # 1,4 exclusions with the core for -R of lig1 == same residue + # 1,4 exclusions with the core for -R of lig2...N == included + # in the INE14 for the core which are present first in the topology. + + bounds = (atom.ATNM+1, last_atoms[atom.MRES-1]) + + neigh14_updated = [x for x in neigh14 if x >= bounds[0] and x <= bounds[1]] + + atom.INE14values = sorted(neigh14_updated) + atom.INE14 = len(atom.INE14values) + + + return core_top + +# +# Smaller functions +# + +def adjustMasses(topology): + """ + This function will adjust the masses of ligands, + to ensure they match gromos convention. + + This was a problem with openFF ligands, which had slightly different + masses, which protein part and ligand part did not have the same + masses. + + """ + + for atom in topology.SOLUTEATOM.content: + if atom.MASS == 1.00795 : atom.MASS = 1.008 + elif atom.MASS == 12.01078: atom.MASS = 12.01 + elif atom.MASS == 14.00672: atom.MASS = 14.01 + elif atom.MASS == 15.99943: atom.MASS = 16.0 + + # Maybe add chlorines, fluorines, etc. later + + return topology + +# +# Main functions coordinating everything +# + +def constructPerturbedTopology(hybrid_topology, lig1_core, out_path, alphalj = 1.0, alphacrf = 1.0): + """ + This function will create the perturbed topology for our hybrid topology. + All ligands atoms will be written down (so energies in the EDS blocks of the output match what we want). + + Shared core atoms will have the same atom type code in all states. + -R groups will be dummy in all other states. + + note: The core isn't sorted so there are ligand 1 -R group atoms in the middle of the ptp. + + Parameters + ---------- + hybrid_topology: pyGromos Top + regular topology from which we will create the hybrid topology + lig1_core: List [int] + list of atoms which make up the core (present for all perturbed states) + out_path: str + path to save the output ptp in + + alphalj: float + alpha parameter for the LJ interaction + alphacrf: float + alpha parameter for the CRF interaction + + """ + # count number of residues + num_atoms = hybrid_topology.SOLUTEATOM.content[-1].ATNM + num_states = hybrid_topology.SOLUTEATOM.content[-1].MRES + + dummy_iac = hybrid_topology.ATOMTYPENAME.content[0][0] # assumes dummy iac is always last + + # open the output file. + f = open(out_path, 'w') + + # Write title block. + + date_time = datetime.now().strftime("%d/%m/%Y %H:%M") + f.write('TITLE\n\tFile created automatically from ' + hybrid_topology.path +'\n') + f.write('\tby ' + os.environ['USER'] + ' on ' + date_time + '\nEND\n') + + # Write the MPERTATOM block + + f.write('MPERTATOM\n# NJLA: number of perturbed atoms\n') + f.write('# NPTB: number of listed perturbation (i.e. number of perturbation states)\n') + f.write('# NJLA NPTB\n') + + # Write the values to NJLA and NPTB: + f.write('\t' + str(num_atoms) + '\t\t' + str(num_states) + '\n') + + # Write state identifiers + identifiers = "" + for i in range(num_states) : identifiers += "ligand"+str(i+1) + "\t" + + f.write('# identifiers of the states\n\t' + identifiers +'\n') + + # comment to understand the content + f.write('# NR NAME IAC(1) CHARGE(1) ... IAC(n) CHARGE(n) ALPHLJ ALPHCRF\n') + + # Loop over topology atoms to include in the ptp + + for atom in hybrid_topology.SOLUTEATOM.content: + + ptp_str = '\t' + str(atom.ATNM) + '\t' + str(atom.PANM) +'\t' + + # charge offset to make formating look good + q_offset = ' ' if atom.CG > 0 else '' + + if atom.MRES == 1 and atom.ATNM in lig1_core: + for i in range(num_states): ptp_str += str(atom.IAC) + '\t' + q_offset + "{:.5f}".format(atom.CG) + '\t' + + else: # Dealing with -R groups + for i in range(num_states): + if i == atom.MRES-1: + ptp_str += str(atom.IAC) + '\t' + q_offset + "{:.5f}".format(atom.CG) + '\t' + else: + ptp_str += str(dummy_iac) + '\t ' + "{:.5f}".format(0) + '\t' + + # Always prepend alpha LJ and alpha CRF values + + ptp_str += "{:.5f}".format(alphalj) + '\t' + "{:.5f}".format(alphacrf) + '\n' + f.write(ptp_str) + + # close the block + f.write('END\n') + f.close() + + return None + +def constructHybridConformation(new_ligand_tops, connecting_points, paths_input_cnfs, path_out_cnf): + """ + This function will create a Hybrid Conformation, based on the hybrid topology, + and single ligand conformations given. + + Note: This functions needs to be adapted so we can make a hybrid conformation for the + complex! + + Parameters + ---------- + new_ligand_tops: List [str] + path to the individual topologies (of the R groups) + connecting_points: List [ Tuple(List[int],List[int])] + List of the "connecting point" between core and -R group + The first inner lists correspond to the atom IDs of the atoms belonging + to the core directly bound to a -R group atom. + The second inner list corresponds to the atom IDs of the atoms belonging + to the -R group directly bound to the core. + paths_input_cnfs: List [str] + list of paths of the input conformations to combine (pre-aligned ideally) + path_out_cnf: str + path of the output cnf + Returns + -------- + None + + """ + + core_cnf = Cnf(paths_input_cnfs[0]) + + new_hybrid_cnf = copy.deepcopy(core_cnf) + + # Remove all waters (We will add them back at the end) + new_hybrid_cnf.delete_residue(resName="WAT") + new_hybrid_cnf.delete_residue(resName="SOLV") + + new_hybrid_pos = new_hybrid_cnf.POSITION.content + + curAtomID = new_hybrid_cnf.POSITION.content[-1].atomID +1 + curResID = new_hybrid_cnf.POSITION.content[-1].resID +1 + + # Add all additional -R groups + for i, cnf_path in enumerate(paths_input_cnfs[1:]): + newResId = i+2 + lig_cnf = Cnf(cnf_path) + + lig_core, lig_rgroup = findAtomsInCoreAndRGroup(new_ligand_tops[i], connecting_points[i+1]) + + for pos in lig_cnf.POSITION.content: + if pos.resID == 2: break + + # Otherwise check if atomID matches the -R groups + if pos.atomID in lig_rgroup: + # Append a new atom position + tmp = atomP(resID = curResID, resName = pos.resName, atomType=pos.atomType, + atomID = curAtomID, xp = pos.xp, yp = pos.yp, zp= pos.zp) + + new_hybrid_pos.append(tmp) + curAtomID += 1 + # end of the addition of the ligand + curResID += 1 + + # Now that all ligands have been added, add all the water molecules back. + # They will be renamed SOLV to match gromos conventions. + + for pos in core_cnf.POSITION.content: + if pos.resID == 1: continue + + tmp = atomP(resID = curResID, resName = "SOLV", atomType=pos.atomType, + atomID = curAtomID, xp = pos.xp, yp = pos.yp, zp= pos.zp) + + new_hybrid_pos.append(tmp) + curAtomID += 1 + if pos.atomType == "H2": curResID += 1 # Each time we have a new water + + new_hybrid_cnf.write(path_out_cnf) + new_hybrid_cnf.write_pdb(path_out_cnf.replace('.cnf', '.pdb')) + return None + + +def constructHybridTopology(core_top, new_ligand_tops, atom_mappings, connecting_points, path_out_top): + """ + This is the main function called to construct Hybrid topologies, + which will call all subfunctions doing the job. + + The user needs to provide the topologies, as well as a manually curated + list of atom mappings (so the program will figure out how to add the torsions) + between core and new -R groups. + + This mapping procedure may be automated in the future. + + Parameters + ---------- + core_top: pygromos Top + Topology of the core + new_ligand_tops: List [Top] + Topologies of the new ligands which will have the added -R groups + atom_mappings: List [PerturbedAtoms] + List keeping track of the mapping of perturbed atoms between their original topology + and the new hybrid one. + + connecting_points: List [ Tuple(List[int],List[int])] + List of the "connecting point" between core and -R group + The first inner lists correspond to the atom IDs of the atoms belonging + to the core directly bound to a -R group atom. + The second inner list corresponds to the atom IDs of the atoms belonging + to the -R group directly bound to the core. + + path_out_top: str + path to save the final topology to. + + Returns + ------- + None + + """ + + new_core = copy.deepcopy(core_top) + lig1_atoms = findAtomsInCoreAndRGroup(core_top, connecting_points[0]) + + # 1: Add all of the topologies together + + for i, lig_top in enumerate(new_ligand_tops): + lig_core, lig_rgroup = findAtomsInCoreAndRGroup(lig_top, connecting_points[i+1]) + print ('Working on addition of ligand ' + str(i+2) + ' has: ' + str(len(lig_rgroup)) + ' atoms.') + (new_core, atom_mappings) = addLigandToTopology(new_core, lig_top, lig_rgroup, atom_mappings) + + # 2: Reset the proper exclusions given new bonds added. + new_core = addExclusions(new_core, lig1_atoms) + + # 3: Adjust small things in some blocks + + # Change masses (openFF assigns very slightly different masses) + new_core = adjustMasses(new_core) + + # Last atom needs to be the end of a charge group. + new_core.SOLUTEATOM.content[-1].CGC = 1 + + num_atoms = new_core.SOLUTEATOM.content[-1].ATNM + + # solute-molecules, pressure and temperature groups + # need to be readjusted. + new_core.SOLUTEMOLECULES.content = [['1'], [str(num_atoms)]] + + new_core.PRESSUREGROUPS.content = [['1'], [str(num_atoms)]] + new_core.TEMPERATUREGROUPS.content = [['1'], [str(num_atoms)]] + + # Adjust residue names: + + new_core.RESNAME.content = [] + new_core.RESNAME.content.append([str(new_core.SOLUTEATOM.content[-1].MRES)]) + for i in range(1, new_core.SOLUTEATOM.content[-1].MRES+1): + new_core.RESNAME.content.append(['LI'+str(i)]) + + # Adjust TITLE block + + date_time = datetime.now().strftime("%d/%m/%Y %H:%M") + new_core.TITLE.content = ['\tFile created automatically by ' + os.environ['USER'] + ' on ' + date_time] + + # Save results + + new_core.write(path_out_top) + + # 4: Make a Perturbed topology which matches this. + + perturbed_top_path = new_core.path.replace(".top", ".ptp") + constructPerturbedTopology(new_core, lig1_atoms[0], perturbed_top_path) + + return None + + + + + + + + + + + + +