From 7e33f3a5019380acde412275d3b3bbcd2c33593a Mon Sep 17 00:00:00 2001 From: "@darshanmandge" Date: Fri, 13 Feb 2026 19:12:46 +0100 Subject: [PATCH 1/8] intial implementation --- bluecellulab/circuit/config/definition.py | 14 +- bluecellulab/circuit/config/sections.py | 105 ++- .../config/sonata_simulation_config.py | 59 +- bluecellulab/circuit_simulation.py | 409 ++++++---- bluecellulab/simulation/modifications.py | 476 +++++++++++ bluecellulab/simulation/neuron_globals.py | 47 +- .../simulation_config_modifications.json | 45 ++ .../sonata-modifications.ipynb | 334 ++++++++ pyproject.toml | 1 + .../simulation_config_modifications.json | 38 + tests/test_circuit/test_simulation_config.py | 200 +++-- tests/test_simulation/test_modifications.py | 736 ++++++++++++++++++ tests/test_simulation/test_neuron_globals.py | 32 +- 13 files changed, 2253 insertions(+), 243 deletions(-) create mode 100644 bluecellulab/simulation/modifications.py create mode 100644 examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json create mode 100644 examples/2-sonata-network/sonata-modifications.ipynb create mode 100644 tests/examples/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json create mode 100644 tests/test_simulation/test_modifications.py diff --git a/bluecellulab/circuit/config/definition.py b/bluecellulab/circuit/config/definition.py index a096cfb4..014b0184 100644 --- a/bluecellulab/circuit/config/definition.py +++ b/bluecellulab/circuit/config/definition.py @@ -17,7 +17,11 @@ from typing import Optional, Protocol -from bluecellulab.circuit.config.sections import Conditions, ConnectionOverrides +from bluecellulab.circuit.config.sections import ( + Conditions, + ConnectionOverrides, + ModificationBase, +) from bluecellulab.stimulus.circuit_stimulus_definitions import Stimulus @@ -36,6 +40,9 @@ def condition_parameters(self) -> Conditions: def connection_entries(self) -> list[ConnectionOverrides]: raise NotImplementedError + def get_modifications(self) -> list[ModificationBase]: + raise NotImplementedError + def get_compartment_sets(self) -> dict[str, dict]: """Return SONATA-style compartment_sets mapping.""" raise NotImplementedError @@ -108,8 +115,5 @@ def output_root_path(self) -> str: def extracellular_calcium(self) -> Optional[float]: raise NotImplementedError - def add_connection_override( - self, - connection_override: ConnectionOverrides - ) -> None: + def add_connection_override(self, connection_override: ConnectionOverrides) -> None: raise NotImplementedError diff --git a/bluecellulab/circuit/config/sections.py b/bluecellulab/circuit/config/sections.py index 15bfad4e..c5afa4d6 100644 --- a/bluecellulab/circuit/config/sections.py +++ b/bluecellulab/circuit/config/sections.py @@ -14,7 +14,7 @@ """Classes to represent config sections.""" from __future__ import annotations -from typing import Literal, Optional +from typing import Any, Literal, Optional from pydantic import field_validator, Field from pydantic.dataclasses import dataclass @@ -29,6 +29,7 @@ from libsonata._libsonata import Conditions as LibSonataConditions except ImportError: from libsonata._libsonata import SimulationConfig + LibSonataConditions = SimulationConfig.Conditions @@ -44,6 +45,7 @@ def string_to_bool(value: str) -> bool: @dataclass(frozen=True, config=dict(extra="forbid")) class ConditionEntry: """For mechanism specific conditions.""" + minis_single_vesicle: Optional[int] = Field(None, ge=0, le=1) init_depleted: Optional[int] = Field(None, ge=0, le=1) @@ -51,6 +53,7 @@ class ConditionEntry: @dataclass(frozen=True, config=dict(extra="forbid")) class MechanismConditions: """For mechanism specific conditions.""" + ampanmda: Optional[ConditionEntry] = None gabaab: Optional[ConditionEntry] = None glusynapse: Optional[ConditionEntry] = None @@ -59,6 +62,7 @@ class MechanismConditions: @dataclass(frozen=True, config=dict(extra="forbid")) class Conditions: mech_conditions: Optional[MechanismConditions] = None + mechanisms: Optional[dict[str, dict[str, Any]]] = None celsius: Optional[float] = None v_init: Optional[float] = None extracellular_calcium: Optional[float] = None @@ -80,6 +84,7 @@ def from_blueconfig(cls, condition_entries: dict) -> Conditions: ) return cls( mech_conditions=mech_conditions, + mechanisms=None, extracellular_calcium=condition_entries.get("cao_CR_GluSynapse", None), randomize_gaba_rise_time=randomize_gaba_risetime, ) @@ -111,8 +116,14 @@ def from_sonata(cls, condition_entries: LibSonataConditions) -> Conditions: glusynapse=ConditionEntry(msv_glusynapse, init_dep_glusynapse), ) + # Store the full generic mechanisms dict from libsonata + generic_mechanisms = None + if mech_dict is not None: + generic_mechanisms = dict(mech_dict) + return cls( mech_conditions=mech_conditions, + mechanisms=generic_mechanisms, celsius=condition_entries.celsius, v_init=condition_entries.v_init, extracellular_calcium=condition_entries.extracellular_calcium, @@ -125,6 +136,7 @@ def init_empty(cls) -> Conditions: specified.""" return cls( mech_conditions=None, + mechanisms=None, celsius=None, v_init=None, extracellular_calcium=None, @@ -132,6 +144,94 @@ def init_empty(cls) -> Conditions: ) +@dataclass(frozen=True, config=dict(extra="forbid")) +class ModificationBase: + """Base class for all modification types.""" + + name: str + type: str + + +@dataclass(frozen=True, config=dict(extra="forbid")) +class ModificationNodeSet(ModificationBase): + """Modification that targets a node_set.""" + + node_set: str + + +@dataclass(frozen=True, config=dict(extra="forbid")) +class ModificationTTX(ModificationNodeSet): + """TTX modification — blocks Na channels on all sections of target cells.""" + + pass + + +@dataclass(frozen=True, config=dict(extra="forbid")) +class ModificationConfigureAllSections(ModificationNodeSet): + """Applies section_configure to all sections of target cells.""" + + section_configure: str + + +@dataclass(frozen=True, config=dict(extra="forbid")) +class ModificationSectionList(ModificationNodeSet): + """Applies section_configure to a named section list of target cells.""" + + section_configure: str + + +@dataclass(frozen=True, config=dict(extra="forbid")) +class ModificationSection(ModificationNodeSet): + """Applies section_configure to specific named sections of target cells.""" + + section_configure: str + + +@dataclass(frozen=True, config=dict(extra="forbid")) +class ModificationCompartmentSet(ModificationBase): + """Applies section_configure to segments in a compartment set.""" + + compartment_set: str + section_configure: str + + +def modification_from_libsonata(mod) -> ModificationBase: + """Convert a libsonata modification object to a BlueCelluLab dataclass.""" + type_name = mod.type.name # e.g. "ttx", "configure_all_sections", etc. + if type_name == "ttx": + return ModificationTTX(name=mod.name, type=type_name, node_set=mod.node_set) + elif type_name == "configure_all_sections": + return ModificationConfigureAllSections( + name=mod.name, + type=type_name, + node_set=mod.node_set, + section_configure=mod.section_configure, + ) + elif type_name == "section_list": + return ModificationSectionList( + name=mod.name, + type=type_name, + node_set=mod.node_set, + section_configure=mod.section_configure, + ) + elif type_name == "section": + return ModificationSection( + name=mod.name, + type=type_name, + node_set=mod.node_set, + section_configure=mod.section_configure, + ) + elif type_name == "compartment_set": + return ModificationCompartmentSet( + name=mod.name, + type=type_name, + compartment_set=mod.compartment_set, + section_configure=mod.section_configure, + ) + else: + raise ValueError(f"Unknown modification type: {type_name}") + + @dataclass(frozen=True, config=dict(extra="forbid")) class ConnectionOverrides: source: str @@ -148,8 +248,7 @@ class ConnectionOverrides: def validate_mod_override(cls, value): """Make sure the mod file to override is present.""" if isinstance(value, str) and not hasattr(neuron.h, value): - raise bluecellulab.ConfigError( - f"Mod file for {value} is not found.") + raise bluecellulab.ConfigError(f"Mod file for {value} is not found.") return value @classmethod diff --git a/bluecellulab/circuit/config/sonata_simulation_config.py b/bluecellulab/circuit/config/sonata_simulation_config.py index 797aec45..2141b136 100644 --- a/bluecellulab/circuit/config/sonata_simulation_config.py +++ b/bluecellulab/circuit/config/sonata_simulation_config.py @@ -19,7 +19,12 @@ from typing import Optional import warnings -from bluecellulab.circuit.config.sections import Conditions, ConnectionOverrides +from bluecellulab.circuit.config.sections import ( + Conditions, + ConnectionOverrides, + ModificationBase, + modification_from_libsonata, +) from bluecellulab.stimulus.circuit_stimulus_definitions import Stimulus from bluepysnap import Simulation as SnapSimulation @@ -66,33 +71,49 @@ def get_all_stimuli_entries(self) -> list[Stimulus]: for value in inputs.values(): # Validate mutual exclusivity and existence of compartment_set if "compartment_set" in value and "node_set" in value: - raise ValueError("Stimulus entry must not include both 'node_set' and 'compartment_set'.") + raise ValueError( + "Stimulus entry must not include both 'node_set' and 'compartment_set'." + ) if "compartment_set" in value: if compartment_sets is None: - raise ValueError("SONATA simulation config references 'compartment_set' in inputs but no 'compartment_sets_file' is configured.") + raise ValueError( + "SONATA simulation config references 'compartment_set' in inputs but no 'compartment_sets_file' is configured." + ) comp_name = value["compartment_set"] if comp_name not in compartment_sets: - raise ValueError(f"Compartment set '{comp_name}' not found in compartment_sets file.") + raise ValueError( + f"Compartment set '{comp_name}' not found in compartment_sets file." + ) # Validate the list: must be list of triples, sorted and unique by (node_id, sec_ref, seg) comp_entry = compartment_sets[comp_name] comp_nodes = comp_entry.get("compartment_set") if comp_nodes is None: - raise ValueError(f"Compartment set '{comp_name}' does not contain 'compartment_set' key.") + raise ValueError( + f"Compartment set '{comp_name}' does not contain 'compartment_set' key." + ) # Validate duplicates and sorted order try: last = None for trip in comp_nodes: if not (isinstance(trip, list) and len(trip) >= 3): - raise ValueError(f"Invalid compartment_set entry '{trip}' in '{comp_name}'; expected [node_id, section, seg].") + raise ValueError( + f"Invalid compartment_set entry '{trip}' in '{comp_name}'; expected [node_id, section, seg]." + ) key = (trip[0], trip[1], trip[2]) if last is not None and key < last: - raise ValueError(f"Compartment list for '{comp_name}' must be sorted ascending.") + raise ValueError( + f"Compartment list for '{comp_name}' must be sorted ascending." + ) if last == key: - raise ValueError(f"Compartment list for '{comp_name}' contains duplicate entry {key}.") + raise ValueError( + f"Compartment list for '{comp_name}' contains duplicate entry {key}." + ) last = key except TypeError: - raise ValueError(f"Compartment list for '{comp_name}' contains non-comparable entries.") + raise ValueError( + f"Compartment list for '{comp_name}' contains non-comparable entries." + ) stimulus = Stimulus.from_sonata(value, config_dir=config_dir) if stimulus: @@ -105,6 +126,12 @@ def condition_parameters(self) -> Conditions: condition_object = self.impl.conditions return Conditions.from_sonata(condition_object) + @lru_cache(maxsize=1) + def get_modifications(self) -> list[ModificationBase]: + """Returns the list of modifications from the conditions block.""" + mods = self.impl.conditions.modifications() + return [modification_from_libsonata(m) for m in mods] + @lru_cache(maxsize=1) def _connection_entries(self) -> list[ConnectionOverrides]: result: list[ConnectionOverrides] = [] @@ -126,7 +153,7 @@ def get_compartment_sets(self) -> dict[str, dict]: full_path = Path(filepath) if config_dir is not None and not full_path.is_absolute(): full_path = Path(config_dir) / filepath - with open(full_path, 'r') as f: + with open(full_path, "r") as f: return json.load(f) @lru_cache(maxsize=1) @@ -145,7 +172,9 @@ def get_node_sets(self) -> dict[str, dict]: base_node_sets.update(sim_node_sets) if not base_node_sets: - raise ValueError("No 'node_sets_file' found in simulation or circuit config.") + raise ValueError( + "No 'node_sets_file' found in simulation or circuit config." + ) return base_node_sets @@ -215,8 +244,7 @@ def tstop(self) -> float: @property def duration(self) -> Optional[float]: warnings.warn( - "`duration` is deprecated. Use `tstop` instead.", - DeprecationWarning + "`duration` is deprecated. Use `tstop` instead.", DeprecationWarning ) return self.tstop @@ -253,10 +281,7 @@ def spikes_file_path(self) -> Path: def extracellular_calcium(self) -> Optional[float]: return self.condition_parameters().extracellular_calcium - def add_connection_override( - self, - connection_override: ConnectionOverrides - ) -> None: + def add_connection_override(self, connection_override: ConnectionOverrides) -> None: self._connection_overrides.append(connection_override) def _get_config_dir(self): diff --git a/bluecellulab/circuit_simulation.py b/bluecellulab/circuit_simulation.py index 15bc4924..24127d72 100644 --- a/bluecellulab/circuit_simulation.py +++ b/bluecellulab/circuit_simulation.py @@ -14,7 +14,6 @@ """Ssim class of bluecellulab that loads a circuit simulation to do cell simulations.""" - from __future__ import annotations from collections.abc import Iterable from pathlib import Path @@ -28,7 +27,6 @@ import pandas as pd from pydantic.types import NonNegativeInt from typing_extensions import deprecated -from typing import Optional import bluecellulab from bluecellulab.cell import CellDict @@ -38,21 +36,33 @@ CircuitAccess, BluepyCircuitAccess, SonataCircuitAccess, - get_synapse_connection_parameters + get_synapse_connection_parameters, ) from bluecellulab.circuit.config import SimulationConfig from bluecellulab.circuit.format import determine_circuit_format, CircuitFormat from bluecellulab.circuit.node_id import create_cell_id, create_cell_ids -from bluecellulab.circuit.simulation_access import BluepySimulationAccess, SimulationAccess, SonataSimulationAccess, _sample_array +from bluecellulab.circuit.simulation_access import ( + BluepySimulationAccess, + SimulationAccess, + SonataSimulationAccess, + _sample_array, +) from bluecellulab.importer import load_mod_files from bluecellulab.rngsettings import RNGSettings from bluecellulab.simulation.neuron_globals import NeuronGlobals -from bluecellulab.stimulus.circuit_stimulus_definitions import Noise, OrnsteinUhlenbeck, RelativeOrnsteinUhlenbeck, RelativeShotNoise, ShotNoise +from bluecellulab.stimulus.circuit_stimulus_definitions import ( + Noise, + OrnsteinUhlenbeck, + RelativeOrnsteinUhlenbeck, + RelativeShotNoise, + ShotNoise, +) import bluecellulab.stimulus.circuit_stimulus_definitions as circuit_stimulus_definitions from bluecellulab.exceptions import BluecellulabError from bluecellulab.simulation import ( set_global_condition_parameters, ) +from bluecellulab.simulation.modifications import apply_modifications from bluecellulab.synapse.synapse_types import SynapseID logger = logging.getLogger(__name__) @@ -108,23 +118,27 @@ def __init__( self.circuit_format = determine_circuit_format(simulation_config) if self.circuit_format == CircuitFormat.SONATA: self.circuit_access: CircuitAccess = SonataCircuitAccess(simulation_config) - self.simulation_access: SimulationAccess = SonataSimulationAccess(simulation_config) + self.simulation_access: SimulationAccess = SonataSimulationAccess( + simulation_config + ) else: self.circuit_access = BluepyCircuitAccess(simulation_config) self.simulation_access = BluepySimulationAccess(simulation_config) SimulationValidator(self.circuit_access).validate() self.dt = dt if dt is not None else (self.circuit_access.config.dt or 0.025) - pc = parallel_context if parallel_context is not None else neuron.h.ParallelContext() + pc = ( + parallel_context + if parallel_context is not None + else neuron.h.ParallelContext() + ) self.pc = pc if int(pc.nhost()) > 1 or print_cellstate else None self.print_cellstate = print_cellstate self.save_time = save_time self.rng_settings = RNGSettings.get_instance() self.rng_settings.set_seeds( - rng_mode, - self.circuit_access.config, - base_seed=base_seed + rng_mode, self.circuit_access.config, base_seed=base_seed ) self.cells: CellDict = CellDict() @@ -156,7 +170,9 @@ def instantiate_gids( add_projections: bool | list[str] | str = False, intersect_pre_gids: Optional[list] = None, interconnect_cells: bool = True, - pre_spike_trains: None | dict[tuple[str, int], Iterable] | dict[int, Iterable] = None, + pre_spike_trains: None + | dict[tuple[str, int], Iterable] + | dict[int, Iterable] = None, add_shotnoise_stimuli: bool = False, add_ornstein_uhlenbeck_stimuli: bool = False, add_sinusoidal_stimuli: bool = False, @@ -266,15 +282,18 @@ def instantiate_gids( if self.gids_instantiated: raise BluecellulabError( "instantiate_gids() is called twice on the " - "same CircuitSimumation, this is not supported") + "same CircuitSimumation, this is not supported" + ) else: self.gids_instantiated = True if pre_spike_trains or add_replay: if add_synapses is False: - raise BluecellulabError("You need to set add_synapses to True " - "if you want to specify use add_replay or " - "pre_spike_trains") + raise BluecellulabError( + "You need to set add_synapses to True " + "if you want to specify use add_replay or " + "pre_spike_trains" + ) # legacy for backward compatibility if add_projections is None: @@ -288,23 +307,25 @@ def instantiate_gids( self.projections = add_projections self._add_cells(cell_ids) + self._apply_modifications() if add_synapses: - self._add_synapses( - pre_gids=pre_gids, - add_minis=add_minis) + self._add_synapses(pre_gids=pre_gids, add_minis=add_minis) if add_replay or interconnect_cells or pre_spike_trains: if add_replay and not add_synapses: - raise BluecellulabError("add_replay option can not be used if " - "add_synapses is False") + raise BluecellulabError( + "add_replay option can not be used if add_synapses is False" + ) if self.pc is not None: self._init_pop_index_mpi() self._register_gids_for_mpi() self.pc.barrier() self.pc.setup_transfer() self.pc.set_maxstep(1.0) - self._add_connections(add_replay=add_replay, - interconnect_cells=interconnect_cells, - user_pre_spike_trains=pre_spike_trains) # type: ignore + self._add_connections( + add_replay=add_replay, + interconnect_cells=interconnect_cells, + user_pre_spike_trains=pre_spike_trains, + ) # type: ignore if add_stimuli: add_noise_stimuli = True add_hyperpolarizing_stimuli = True @@ -315,14 +336,16 @@ def instantiate_gids( add_ornstein_uhlenbeck_stimuli = True add_linear_stimuli = True - if add_noise_stimuli or \ - add_hyperpolarizing_stimuli or \ - add_pulse_stimuli or \ - add_relativelinear_stimuli or \ - add_shotnoise_stimuli or \ - add_ornstein_uhlenbeck_stimuli or \ - add_sinusoidal_stimuli or \ - add_linear_stimuli: + if ( + add_noise_stimuli + or add_hyperpolarizing_stimuli + or add_pulse_stimuli + or add_relativelinear_stimuli + or add_shotnoise_stimuli + or add_ornstein_uhlenbeck_stimuli + or add_sinusoidal_stimuli + or add_linear_stimuli + ): self._add_stimuli( add_noise_stimuli=add_noise_stimuli, add_hyperpolarizing_stimuli=add_hyperpolarizing_stimuli, @@ -331,28 +354,33 @@ def instantiate_gids( add_shotnoise_stimuli=add_shotnoise_stimuli, add_ornstein_uhlenbeck_stimuli=add_ornstein_uhlenbeck_stimuli, add_sinusoidal_stimuli=add_sinusoidal_stimuli, - add_linear_stimuli=add_linear_stimuli + add_linear_stimuli=add_linear_stimuli, ) configure_all_reports( - cells=self.cells, - simulation_config=self.circuit_access.config + cells=self.cells, simulation_config=self.circuit_access.config ) # add spike recordings for cell in self.cells.values(): - if not cell.is_recording_spikes(self.spike_location, threshold=self.spike_threshold): - cell.start_recording_spikes(None, location=self.spike_location, threshold=self.spike_threshold) - - def _add_stimuli(self, add_noise_stimuli=False, - add_hyperpolarizing_stimuli=False, - add_relativelinear_stimuli=False, - add_pulse_stimuli=False, - add_shotnoise_stimuli=False, - add_ornstein_uhlenbeck_stimuli=False, - add_sinusoidal_stimuli=False, - add_linear_stimuli=False - ) -> None: + if not cell.is_recording_spikes( + self.spike_location, threshold=self.spike_threshold + ): + cell.start_recording_spikes( + None, location=self.spike_location, threshold=self.spike_threshold + ) + + def _add_stimuli( + self, + add_noise_stimuli=False, + add_hyperpolarizing_stimuli=False, + add_relativelinear_stimuli=False, + add_pulse_stimuli=False, + add_shotnoise_stimuli=False, + add_ornstein_uhlenbeck_stimuli=False, + add_sinusoidal_stimuli=False, + add_linear_stimuli=False, + ) -> None: """Instantiate all the stimuli.""" stimuli_entries = self.circuit_access.config.get_all_stimuli_entries() # Also add the injections / stimulations as in the cortical model @@ -377,7 +405,9 @@ def _add_stimuli(self, add_noise_stimuli=False, if stimulus.compartment_set is not None: targets = self._targets_from_compartment_set(stimulus, compartment_sets) elif stimulus.node_set is not None: - gids_of_target = self.circuit_access.get_target_cell_ids(stimulus.node_set) + gids_of_target = self.circuit_access.get_target_cell_ids( + stimulus.node_set + ) for cell_id in self.cells: if cell_id not in gids_of_target: continue @@ -393,35 +423,75 @@ def _add_stimuli(self, add_noise_stimuli=False, for cell_id, sec, segx, sec_name in targets: if isinstance(stimulus, circuit_stimulus_definitions.Noise): if add_noise_stimuli: - self.cells[cell_id].add_replay_noise(stimulus, noise_seed=None, noisestim_count=noisestim_count, section=sec, segx=segx) + self.cells[cell_id].add_replay_noise( + stimulus, + noise_seed=None, + noisestim_count=noisestim_count, + section=sec, + segx=segx, + ) elif isinstance(stimulus, circuit_stimulus_definitions.Hyperpolarizing): if add_hyperpolarizing_stimuli: - self.cells[cell_id].add_replay_hypamp(stimulus, section=sec, segx=segx) + self.cells[cell_id].add_replay_hypamp( + stimulus, section=sec, segx=segx + ) elif isinstance(stimulus, circuit_stimulus_definitions.Pulse): if add_pulse_stimuli: self.cells[cell_id].add_pulse(stimulus, section=sec, segx=segx) elif isinstance(stimulus, circuit_stimulus_definitions.Linear): if add_linear_stimuli: - self.cells[cell_id].add_replay_linear(stimulus, section=sec, segx=segx) + self.cells[cell_id].add_replay_linear( + stimulus, section=sec, segx=segx + ) elif isinstance(stimulus, circuit_stimulus_definitions.RelativeLinear): if add_relativelinear_stimuli: - self.cells[cell_id].add_replay_relativelinear(stimulus, section=sec, segx=segx) + self.cells[cell_id].add_replay_relativelinear( + stimulus, section=sec, segx=segx + ) elif isinstance(stimulus, circuit_stimulus_definitions.ShotNoise): if add_shotnoise_stimuli: - self.cells[cell_id].add_replay_shotnoise(sec, segx, stimulus, shotnoise_stim_count=shotnoise_stim_count) - elif isinstance(stimulus, circuit_stimulus_definitions.RelativeShotNoise): + self.cells[cell_id].add_replay_shotnoise( + sec, + segx, + stimulus, + shotnoise_stim_count=shotnoise_stim_count, + ) + elif isinstance( + stimulus, circuit_stimulus_definitions.RelativeShotNoise + ): if add_shotnoise_stimuli: - self.cells[cell_id].add_replay_relative_shotnoise(sec, segx, stimulus, shotnoise_stim_count=shotnoise_stim_count) - elif isinstance(stimulus, circuit_stimulus_definitions.OrnsteinUhlenbeck): + self.cells[cell_id].add_replay_relative_shotnoise( + sec, + segx, + stimulus, + shotnoise_stim_count=shotnoise_stim_count, + ) + elif isinstance( + stimulus, circuit_stimulus_definitions.OrnsteinUhlenbeck + ): if add_ornstein_uhlenbeck_stimuli: - self.cells[cell_id].add_ornstein_uhlenbeck(sec, segx, stimulus, stim_count=ornstein_uhlenbeck_stim_count) - elif isinstance(stimulus, circuit_stimulus_definitions.RelativeOrnsteinUhlenbeck): + self.cells[cell_id].add_ornstein_uhlenbeck( + sec, + segx, + stimulus, + stim_count=ornstein_uhlenbeck_stim_count, + ) + elif isinstance( + stimulus, circuit_stimulus_definitions.RelativeOrnsteinUhlenbeck + ): if add_ornstein_uhlenbeck_stimuli: - self.cells[cell_id].add_relative_ornstein_uhlenbeck(sec, segx, stimulus, stim_count=ornstein_uhlenbeck_stim_count) + self.cells[cell_id].add_relative_ornstein_uhlenbeck( + sec, + segx, + stimulus, + stim_count=ornstein_uhlenbeck_stim_count, + ) elif isinstance(stimulus, circuit_stimulus_definitions.Sinusoidal): if add_sinusoidal_stimuli: self.cells[cell_id].add_sinusoidal(stimulus) - elif isinstance(stimulus, circuit_stimulus_definitions.SynapseReplay): # sonata only + elif isinstance( + stimulus, circuit_stimulus_definitions.SynapseReplay + ): # sonata only if self.circuit_access.target_contains_cell( stimulus.target, cell_id ): @@ -429,8 +499,12 @@ def _add_stimuli(self, add_noise_stimuli=False, stimulus, self.spike_threshold, self.spike_location ) else: - raise ValueError("Found stimulus with pattern %s, not supported" % stimulus) - logger.debug(f"Added {stimulus} to cell_id {cell_id} at {sec_name}({segx})") + raise ValueError( + "Found stimulus with pattern %s, not supported" % stimulus + ) + logger.debug( + f"Added {stimulus} to cell_id {cell_id} at {sec_name}({segx})" + ) if isinstance(stimulus, Noise): noisestim_count += 1 @@ -439,13 +513,10 @@ def _add_stimuli(self, add_noise_stimuli=False, elif isinstance(stimulus, (OrnsteinUhlenbeck, RelativeOrnsteinUhlenbeck)): ornstein_uhlenbeck_stim_count += 1 - def _add_synapses( - self, pre_gids=None, add_minis=False): + def _add_synapses(self, pre_gids=None, add_minis=False): """Instantiate all the synapses.""" for cell_id in self.cells: - self._add_cell_synapses( - cell_id, pre_gids=pre_gids, - add_minis=add_minis) + self._add_cell_synapses(cell_id, pre_gids=pre_gids, add_minis=add_minis) def _add_cell_synapses( self, cell_id: CellId, pre_gids=None, add_minis=False @@ -478,7 +549,7 @@ def _add_cell_synapses( syn_id=idx, # type: ignore syn_description=syn_description, add_minis=add_minis, - popids=popids + popids=popids, ) logger.info(f"Added {syn_descriptions} synapses for gid {cell_id}") if add_minis: @@ -499,7 +570,9 @@ def _targets_from_compartment_set( comp_name = stimulus.compartment_set if comp_name not in compartment_sets: - raise ValueError(f"Compartment set '{comp_name}' not found in compartment_sets file.") + raise ValueError( + f"Compartment set '{comp_name}' not found in compartment_sets file." + ) comp_entry = compartment_sets[comp_name] comp_nodes = comp_entry.get("compartment_set", []) @@ -508,7 +581,10 @@ def _targets_from_compartment_set( targets: list[tuple] = [] for cell_id in self.cells: - if population_name is not None and getattr(cell_id, "population_name", None) != population_name: + if ( + population_name is not None + and getattr(cell_id, "population_name", None) != population_name + ): continue try: resolved = self.cells[cell_id].resolve_segments_from_compartment_set( @@ -516,7 +592,9 @@ def _targets_from_compartment_set( comp_nodes, ) except (ValueError, TypeError) as e: - logger.debug(f"Failed to resolve compartment_set for cell {cell_id}: {e}") + logger.debug( + f"Failed to resolve compartment_set for cell {cell_id}: {e}" + ) continue for sec, sec_name, segx in resolved: @@ -528,17 +606,22 @@ def _targets_from_compartment_set( def _intersect_pre_gids(syn_descriptions, pre_gids: list[CellId]) -> pd.DataFrame: """Return the synapse descriptions with pre_gids intersected.""" _pre_gids = {x.id for x in pre_gids} - return syn_descriptions[syn_descriptions[SynapseProperty.PRE_GID].isin(_pre_gids)] + return syn_descriptions[ + syn_descriptions[SynapseProperty.PRE_GID].isin(_pre_gids) + ] @staticmethod - def _intersect_pre_gids_cell_ids_multipopulation(syn_descriptions, pre_cell_ids: list[CellId]) -> pd.DataFrame: + def _intersect_pre_gids_cell_ids_multipopulation( + syn_descriptions, pre_cell_ids: list[CellId] + ) -> pd.DataFrame: """Return the synapse descriptions with pre_cell_ids intersected. Supports multipopulations. """ filtered_rows = syn_descriptions.apply( lambda row: any( - cell.population_name == row["source_population_name"] and row[SynapseProperty.PRE_GID] == cell.id + cell.population_name == row["source_population_name"] + and row[SynapseProperty.PRE_GID] == cell.id for cell in pre_cell_ids ), axis=1, @@ -548,7 +631,9 @@ def _intersect_pre_gids_cell_ids_multipopulation(syn_descriptions, pre_cell_ids: def get_syn_descriptions(self, cell_id: int | tuple[str, int]) -> pd.DataFrame: """Get synapse descriptions dataframe.""" cell_id = create_cell_id(cell_id) - return self.circuit_access.extract_synapses(cell_id, projections=self.projections) + return self.circuit_access.extract_synapses( + cell_id, projections=self.projections + ) @staticmethod def merge_pre_spike_trains(*train_dicts) -> dict[CellId, np.ndarray]: @@ -577,23 +662,23 @@ def _find_matching_override(self, overrides, pre: CellId, post: CellId): matched = None for ov in overrides: # ov.source and ov.target are nodeset names - if ( - self.circuit_access.target_contains_cell(ov.source, pre) - and self.circuit_access.target_contains_cell(ov.target, post) - ): - matched = ov # "last match wins" like Neurodamus ordering + if self.circuit_access.target_contains_cell( + ov.source, pre + ) and self.circuit_access.target_contains_cell(ov.target, post): + matched = ov # "last match wins" like Neurodamus ordering return matched def _add_connections( - self, - add_replay=None, - interconnect_cells=None, - user_pre_spike_trains: None | dict[CellId, Iterable] = None) -> None: + self, + add_replay=None, + interconnect_cells=None, + user_pre_spike_trains: None | dict[CellId, Iterable] = None, + ) -> None: """Instantiate the (replay and real) connections in the network.""" pre_spike_trains = self.simulation_access.get_spikes() if add_replay else {} pre_spike_trains = self.merge_pre_spike_trains( - pre_spike_trains, - user_pre_spike_trains) + pre_spike_trains, user_pre_spike_trains + ) connections_overrides = ( self.circuit_access.config.connection_entries() @@ -607,26 +692,34 @@ def _add_connections( syn_description: pd.Series = synapse.syn_description delay_weights = synapse.delay_weights source_population = syn_description["source_population_name"] - pre_gid = CellId(source_population, int(syn_description[SynapseProperty.PRE_GID])) + pre_gid = CellId( + source_population, int(syn_description[SynapseProperty.PRE_GID]) + ) - ov = self._find_matching_override(connections_overrides, pre_gid, post_gid) + ov = self._find_matching_override( + connections_overrides, pre_gid, post_gid + ) if ov is not None and ov.weight == 0.0: logger.debug( "Skipping connection due to zero weight override: %s -> %s | syn_id=%s", - pre_gid, post_gid, syn_id + pre_gid, + post_gid, + syn_id, ) continue if self.pc is None: - real_synapse_connection = bool(interconnect_cells) and (pre_gid in self.cells) + real_synapse_connection = bool(interconnect_cells) and ( + pre_gid in self.cells + ) else: real_synapse_connection = bool(interconnect_cells) if real_synapse_connection: if ( - user_pre_spike_trains is not None - and pre_gid in user_pre_spike_trains + user_pre_spike_trains is not None + and pre_gid in user_pre_spike_trains ): raise BluecellulabError( """Specifying prespike trains of real connections""" @@ -655,7 +748,9 @@ def _add_connections( spike_location=self.spike_location, ) - logger.debug(f"Added real connection between {pre_gid} and {post_gid}, {syn_id}") + logger.debug( + f"Added real connection between {pre_gid} and {post_gid}, {syn_id}" + ) else: # replay connection pre_spiketrain = pre_spike_trains.get(pre_gid, None) connection = bluecellulab.Connection( @@ -665,15 +760,21 @@ def _add_connections( stim_dt=self.dt, parallel_context=None, spike_threshold=self.spike_threshold, - spike_location=self.spike_location + spike_location=self.spike_location, ) - logger.debug(f"Added replay connection from {pre_gid} to {post_gid}, {syn_id}") + logger.debug( + f"Added replay connection from {pre_gid} to {post_gid}, {syn_id}" + ) if ov is not None: logger.debug( "Override matched: %s -> %s | syn_id=%s | weight=%s delay=%s", - pre_gid, post_gid, syn_id, ov.weight, ov.delay + pre_gid, + post_gid, + syn_id, + ov.weight, + ov.delay, ) syn_delay = getattr(ov, "synapse_delay_override", None) @@ -681,28 +782,38 @@ def _add_connections( connection.set_netcon_delay(float(syn_delay)) logger.debug( "Applied synapse_delay_override %.4g ms to %s -> %s | syn_id=%s", - syn_delay, pre_gid, post_gid, syn_id + syn_delay, + pre_gid, + post_gid, + syn_id, ) if ov.delay is not None: logger.warning( "SONATA override 'delay' (delayed weight activation) is not supported yet; " "applying weight immediately. %s -> %s | syn_id=%s | delay=%s", - pre_gid, post_gid, syn_id, ov.delay + pre_gid, + post_gid, + syn_id, + ov.delay, ) if ov.weight is not None: connection.set_weight_scalar(float(ov.weight)) logger.debug( "Applied weight override factor %.4g to %s -> %s | syn_id=%s | final_weight=%.4g", - ov.weight, pre_gid, post_gid, syn_id, connection.post_netcon_weight + ov.weight, + pre_gid, + post_gid, + syn_id, + connection.post_netcon_weight, ) self.cells[post_gid].connections[syn_id] = connection for delay, weight_scale in delay_weights: self.cells[post_gid].add_replay_delayed_weight( - syn_id, delay, - weight_scale * connection.weight) + syn_id, delay, weight_scale * connection.weight + ) if len(self.cells[post_gid].connections) > 0: logger.debug(f"Added synaptic connections for target {post_gid}") @@ -716,24 +827,48 @@ def _add_cells(self, cell_ids: list[CellId]) -> None: if self.circuit_access.node_properties_available: cell.connect_to_circuit(SonataProxy(cell_id, self.circuit_access)) - def _instantiate_synapse(self, cell_id: CellId, syn_id: SynapseID, syn_description, - add_minis=False, popids=(0, 0)) -> None: + def _apply_modifications(self) -> None: + """Apply condition modifications from the simulation config to cells.""" + try: + modifications = self.circuit_access.config.get_modifications() + except (NotImplementedError, AttributeError): + return + if modifications: + apply_modifications(self.cells, modifications, self.circuit_access) + + def _instantiate_synapse( + self, + cell_id: CellId, + syn_id: SynapseID, + syn_description, + add_minis=False, + popids=(0, 0), + ) -> None: """Instantiate one synapse for a given gid, syn_id and syn_description.""" - pre_cell_id = CellId(syn_description["source_population_name"], int(syn_description[SynapseProperty.PRE_GID])) + pre_cell_id = CellId( + syn_description["source_population_name"], + int(syn_description[SynapseProperty.PRE_GID]), + ) syn_connection_parameters = get_synapse_connection_parameters( - circuit_access=self.circuit_access, - pre_cell=pre_cell_id, - post_cell=cell_id) + circuit_access=self.circuit_access, pre_cell=pre_cell_id, post_cell=cell_id + ) if syn_connection_parameters["add_synapse"]: condition_parameters = self.circuit_access.config.condition_parameters() self.cells[cell_id].add_replay_synapse( - syn_id, syn_description, syn_connection_parameters, condition_parameters, - popids=popids, extracellular_calcium=self.circuit_access.config.extracellular_calcium) + syn_id, + syn_description, + syn_connection_parameters, + condition_parameters, + popids=popids, + extracellular_calcium=self.circuit_access.config.extracellular_calcium, + ) if add_minis: mini_frequencies = self.circuit_access.fetch_mini_frequencies(cell_id) - logger.debug(f"Adding minis for synapse {syn_id}: syn_description={syn_description}, connection={syn_connection_parameters}, frequency={mini_frequencies}") + logger.debug( + f"Adding minis for synapse {syn_id}: syn_description={syn_description}, connection={syn_connection_parameters}, frequency={mini_frequencies}" + ) self.cells[cell_id].add_replay_minis( syn_id, @@ -806,7 +941,7 @@ def run( dt = self.dt config_forward_skip_value = self.circuit_access.config.forward_skip # legacy - config_tstart = self.circuit_access.config.tstart or 0.0 # SONATA + config_tstart = self.circuit_access.config.tstart or 0.0 # SONATA # Determine effective skip value and flag if forward_skip_value is not None: # User explicitly provided value → use it @@ -838,6 +973,7 @@ def run( self.fih_prcellstate = None if self.pc is not None and self.print_cellstate: + def dump(): for cell in self.cells: pop = cell.population_name @@ -846,15 +982,21 @@ def dump(): self.pc.prcellstate(g, f"bluecellulab_t={neuron.h.t}") def schedule_dump(): - t_dump = self.save_time if self.save_time is not None else self.circuit_access.config.tstop + t_dump = ( + self.save_time + if self.save_time is not None + else self.circuit_access.config.tstop + ) neuron.h.cvode.event(t_dump, dump) self.fih_prcellstate = neuron.h.FInitializeHandler(1, schedule_dump) if show_progress: - logger.warning("show_progress enabled, this will very likely" - "break the exact reproducibility of large network" - "simulations") + logger.warning( + "show_progress enabled, this will very likely" + "break the exact reproducibility of large network" + "simulations" + ) sim.run( tstop=t_stop, @@ -862,10 +1004,11 @@ def schedule_dump(): dt=dt, forward_skip=effective_skip, forward_skip_value=effective_skip_value, - show_progress=show_progress) + show_progress=show_progress, + ) def get_mainsim_voltage_trace( - self, cell_id: int | tuple[str, int], t_start=None, t_stop=None, t_step=None + self, cell_id: int | tuple[str, int], t_start=None, t_stop=None, t_step=None ) -> np.ndarray: """Get the voltage trace from a cell from the main simulation. @@ -932,7 +1075,7 @@ def get_time_trace(self, t_start=None, t_stop=None, t_step=None) -> np.ndarray: return time def get_voltage_trace( - self, cell_id: int | tuple[str, int], t_start=None, t_stop=None, t_step=None + self, cell_id: int | tuple[str, int], t_start=None, t_stop=None, t_step=None ) -> np.ndarray: """Get the voltage vector for the cell_id, negative times removed. @@ -968,7 +1111,7 @@ def delete(self): NEURON objects are explicitly needed to be deleted. """ - if hasattr(self, 'cells'): + if hasattr(self, "cells"): for _, cell in self.cells.items(): cell.delete() cell_ids = list(self.cells.keys()) @@ -986,12 +1129,12 @@ def fetch_cell_kwargs(self, cell_id: CellId) -> dict: """Get the kwargs to instantiate a Cell object.""" emodel_properties = self.circuit_access.get_emodel_properties(cell_id) cell_kwargs = { - 'template_path': self.circuit_access.emodel_path(cell_id), - 'morphology_path': self.circuit_access.morph_filepath(cell_id), - 'cell_id': cell_id, - 'record_dt': self.record_dt, - 'template_format': self.circuit_access.get_template_format(), - 'emodel_properties': emodel_properties, + "template_path": self.circuit_access.emodel_path(cell_id), + "morphology_path": self.circuit_access.morph_filepath(cell_id), + "cell_id": cell_id, + "record_dt": self.record_dt, + "template_format": self.circuit_access.get_template_format(), + "emodel_properties": emodel_properties, } return cell_kwargs @@ -999,12 +1142,14 @@ def fetch_cell_kwargs(self, cell_id: CellId) -> dict: def create_cell_from_circuit(self, cell_id: CellId) -> bluecellulab.Cell: """Create a Cell object from the circuit.""" cell_kwargs = self.fetch_cell_kwargs(cell_id) - return bluecellulab.Cell(template_path=cell_kwargs['template_path'], - morphology_path=cell_kwargs['morphology_path'], - cell_id=cell_kwargs['cell_id'], - record_dt=cell_kwargs['record_dt'], - template_format=cell_kwargs['template_format'], - emodel_properties=cell_kwargs['emodel_properties']) + return bluecellulab.Cell( + template_path=cell_kwargs["template_path"], + morphology_path=cell_kwargs["morphology_path"], + cell_id=cell_kwargs["cell_id"], + record_dt=cell_kwargs["record_dt"], + template_format=cell_kwargs["template_format"], + emodel_properties=cell_kwargs["emodel_properties"], + ) def global_gid(self, pop: str, gid: int) -> int: """Return a globally unique NEURON GID for a (population, node_id) @@ -1076,8 +1221,6 @@ def _register_gids_for_mpi(self) -> None: self.pc.set_gid2node(g, int(self.pc.id())) nc = cell.create_netcon_spikedetector( - None, - location=self.spike_location, - threshold=self.spike_threshold + None, location=self.spike_location, threshold=self.spike_threshold ) self.pc.cell(g, nc) diff --git a/bluecellulab/simulation/modifications.py b/bluecellulab/simulation/modifications.py new file mode 100644 index 00000000..9d03eb8a --- /dev/null +++ b/bluecellulab/simulation/modifications.py @@ -0,0 +1,476 @@ +# Copyright 2023-2024 Blue Brain Project / EPFL + +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at + +# http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Module for applying SONATA condition modifications to cells. + +Implements all five SONATA modification types: +- ttx: Block Na channels via TTXDynamicsSwitch +- configure_all_sections: Apply section_configure to all sections +- section_list: Apply section_configure to a named section list +- section: Apply section_configure to specific named sections +- compartment_set: Apply section_configure to segments in a compartment set + +The section_configure parser follows neurodamus's ast.parse() + restricted exec() +pattern (neurodamus/modification_manager.py). +""" + +from __future__ import annotations + +import ast +import logging +import re + +from bluecellulab.circuit.config.sections import ( + ModificationBase, + ModificationCompartmentSet, + ModificationConfigureAllSections, + ModificationSection, + ModificationSectionList, + ModificationTTX, +) + +logger = logging.getLogger(__name__) + +# Mapping from SONATA section list names to Cell property names +SECTION_LIST_MAP: dict[str, str] = { + "somatic": "somatic", + "soma": "somatic", + "basal": "basal", + "dend": "basal", + "apical": "apical", + "apic": "apical", + "axonal": "axonal", + "axon": "axonal", +} + + +class _AttributeCollector(ast.NodeVisitor): + """AST visitor that collects all attribute names referenced in an expression.""" + + def __init__(self): + self.attrs: set[str] = set() + + def visit_Attribute(self, node): + self.attrs.add(node.attr) + self.generic_visit(node) + + +def _validate_assignment(node) -> list: + """Return assignment targets from an AST node, raising on non-assignments.""" + if isinstance(node, ast.Assign): + return node.targets + if isinstance(node, ast.AugAssign): + return [node.target] + raise ValueError( + "section_configure must consist of one or more semicolon-separated assignments" + ) + + +def parse_section_configure( + config_str: str, placeholder: str = "%s" +) -> tuple[str, set[str]]: + """Parse a section_configure string, returning sanitized code and referenced attrs. + + Follows neurodamus's ConfigureAllSections.parse_section_config() pattern. + + Args: + config_str: The raw section_configure string (e.g. "%s.gbar = 0"). + placeholder: The placeholder to replace with 'sec' (default: "%s"). + + Returns: + Tuple of (sanitized_config_str, set_of_referenced_attribute_names). + + Raises: + ValueError: If the config string contains non-assignment statements + or references attributes not on the placeholder. + """ + # Replace placeholder with internal variable name + internal = config_str.replace(f"{placeholder}.", "__sec_wildcard__.") + collector = _AttributeCollector() + tree = ast.parse(internal) + for elem in tree.body: + targets = _validate_assignment(elem) + for tgt in targets: + if not isinstance(tgt, ast.Attribute) or tgt.value.id != "__sec_wildcard__": + raise ValueError( + "section_configure only supports single assignments " + f"of attributes of the section wildcard {placeholder}" + ) + collector.visit(elem) + sanitized = internal.replace("__sec_wildcard__.", "sec.") + return sanitized, collector.attrs + + +def _exec_on_section(config: str, section, attrs: set[str]) -> bool: + """Apply a sanitized config string to a NEURON section if it has all attrs. + + Returns True if applied, False if skipped due to missing attributes. + """ + if all(hasattr(section, attr) for attr in attrs): + exec(config, {"__builtins__": None}, {"sec": section}) # noqa: S102 + return True + return False + + +def apply_modifications( + cells: dict, modifications: list[ModificationBase], circuit_access +) -> None: + """Apply a list of modifications to instantiated cells. + + Args: + cells: Dict mapping CellId to Cell objects. + modifications: List of Modification dataclass instances. + circuit_access: CircuitAccess instance for resolving node_sets. + """ + for mod in modifications: + if isinstance(mod, ModificationTTX): + _apply_ttx(cells, mod, circuit_access) + elif isinstance(mod, ModificationConfigureAllSections): + _apply_configure_all_sections(cells, mod, circuit_access) + elif isinstance(mod, ModificationSectionList): + _apply_section_list(cells, mod, circuit_access) + elif isinstance(mod, ModificationSection): + _apply_section(cells, mod, circuit_access) + elif isinstance(mod, ModificationCompartmentSet): + _apply_compartment_set(cells, mod, circuit_access) + else: + raise ValueError(f"Unknown modification type: {mod.type}") + + +def _resolve_target_cells(cells: dict, mod, circuit_access) -> list: + """Resolve node_set to the subset of instantiated cells that match.""" + target_ids = circuit_access.get_target_cell_ids(mod.node_set) + return [cell_id for cell_id in cells if cell_id in target_ids] + + +def _apply_ttx(cells: dict, mod: ModificationTTX, circuit_access) -> None: + """Apply TTX modification — enable TTX on all target cells.""" + logger.info( + "Applying modification '%s' (type=ttx) to node_set '%s'", mod.name, mod.node_set + ) + target_cell_ids = _resolve_target_cells(cells, mod, circuit_access) + count = 0 + for cell_id in target_cell_ids: + cells[cell_id].enable_ttx() + count += 1 + logger.debug(" TTX enabled on cell %s", cell_id) + logger.info("Modification '%s' (ttx): enabled on %d cells", mod.name, count) + if count == 0: + logger.warning( + "TTX modification '%s' matched zero cells in node_set '%s'", + mod.name, + mod.node_set, + ) + + +def _apply_configure_all_sections( + cells: dict, mod: ModificationConfigureAllSections, circuit_access +) -> None: + """Apply configure_all_sections — exec section_configure on all sections.""" + logger.info( + "Applying modification '%s' (type=configure_all_sections) to node_set '%s'", + mod.name, + mod.node_set, + ) + config, attrs = parse_section_configure(mod.section_configure, placeholder="%s") + target_cell_ids = _resolve_target_cells(cells, mod, circuit_access) + + n_cells = 0 + n_sections = 0 + for cell_id in target_cell_ids: + cell = cells[cell_id] + cell_applied = 0 + for sec_name, section in cell.sections.items(): + if _exec_on_section(config, section, attrs): + cell_applied += 1 + logger.debug(" Applied to section '%s' of cell %s", sec_name, cell_id) + if cell_applied > 0: + n_cells += 1 + n_sections += cell_applied + + logger.info( + "Modification '%s' applied to %d sections across %d cells", + mod.name, + n_sections, + n_cells, + ) + if n_sections == 0: + logger.warning( + "configure_all_sections '%s' applied to zero sections, " + "please check its section_configure for possible mistakes", + mod.name, + ) + + +def _apply_section_list( + cells: dict, mod: ModificationSectionList, circuit_access +) -> None: + """Apply section_list — exec section_configure on a named section list.""" + logger.info( + "Applying modification '%s' (type=section_list) to node_set '%s'", + mod.name, + mod.node_set, + ) + + # Extract list name from section_configure: e.g. "apical.gbar = 0" -> "apical" + # The format is ".attr = value [; .attr = value ...]" + match = re.match(r"^(\w+)\.", mod.section_configure) + if not match: + raise ValueError( + f"section_list modification '{mod.name}': cannot extract section list name " + f"from section_configure '{mod.section_configure}'" + ) + list_name = match.group(1) + + prop_name = SECTION_LIST_MAP.get(list_name) + if prop_name is None: + raise ValueError( + f"section_list modification '{mod.name}': unknown section list name '{list_name}'. " + f"Supported: {list(SECTION_LIST_MAP.keys())}" + ) + + # Replace list_name. with sec. for exec + config_str = mod.section_configure.replace(f"{list_name}.", "sec.") + # Parse and validate the sanitized string + collector = _AttributeCollector() + tree = ast.parse(config_str) + for elem in tree.body: + _validate_assignment(elem) + collector.visit(elem) + attrs = collector.attrs + + target_cell_ids = _resolve_target_cells(cells, mod, circuit_access) + n_cells = 0 + n_sections = 0 + for cell_id in target_cell_ids: + cell = cells[cell_id] + try: + section_list = getattr(cell, prop_name) + except AttributeError: + logger.warning( + "section_list '%s': cell %s has no '%s' property, skipping", + mod.name, + cell_id, + prop_name, + ) + continue + + if not section_list: + logger.warning( + "section_list '%s': cell %s has no '%s' sections, skipping", + mod.name, + cell_id, + list_name, + ) + continue + + cell_applied = 0 + for section in section_list: + sec_name = section.name().split(".")[-1] + if _exec_on_section(config_str, section, attrs): + cell_applied += 1 + logger.debug(" Applied to section '%s' of cell %s", sec_name, cell_id) + if cell_applied > 0: + n_cells += 1 + n_sections += cell_applied + + logger.info( + "Modification '%s' applied to %d sections across %d cells", + mod.name, + n_sections, + n_cells, + ) + if n_sections == 0: + logger.warning( + "section_list '%s' applied to zero sections, " + "please check its section_configure for possible mistakes", + mod.name, + ) + + +def _apply_section(cells: dict, mod: ModificationSection, circuit_access) -> None: + """Apply section — exec section_configure on specific named sections.""" + logger.info( + "Applying modification '%s' (type=section) to node_set '%s'", + mod.name, + mod.node_set, + ) + + # Extract section names from section_configure + # Format: "apic[10].gbar = 0; apic[10].gbar2 = 1" or "dend[3].x = 5" + # Find all unique "[]." patterns + section_names = list( + dict.fromkeys(re.findall(r"(\w+\[\d+\])\.", mod.section_configure)) + ) + if not section_names: + raise ValueError( + f"section modification '{mod.name}': cannot extract section name(s) " + f"from section_configure '{mod.section_configure}'" + ) + + # Build per-section config strings + # For each unique section name, replace "[idx]." with "sec." + # and parse to get attrs + section_configs: dict[str, tuple[str, set[str]]] = {} + for sec_name in section_names: + escaped = re.escape(sec_name) + config_str = re.sub(escaped + r"\.", "sec.", mod.section_configure) + # Filter to only statements that reference this section + # (handle multi-section configs like "apic[10].x = 0; dend[3].y = 1") + collector = _AttributeCollector() + tree = ast.parse(config_str) + for elem in tree.body: + _validate_assignment(elem) + collector.visit(elem) + section_configs[sec_name] = (config_str, collector.attrs) + + target_cell_ids = _resolve_target_cells(cells, mod, circuit_access) + n_cells = 0 + n_sections = 0 + for cell_id in target_cell_ids: + cell = cells[cell_id] + cell_applied = 0 + for sec_name, (config_str, attrs) in section_configs.items(): + try: + section = cell.get_section(sec_name) + except (ValueError, TypeError): + logger.warning( + "section '%s': cell %s does not have section '%s', skipping", + mod.name, + cell_id, + sec_name, + ) + continue + if _exec_on_section(config_str, section, attrs): + cell_applied += 1 + logger.debug(" Applied to section '%s' of cell %s", sec_name, cell_id) + if cell_applied > 0: + n_cells += 1 + n_sections += cell_applied + + logger.info( + "Modification '%s' applied to %d sections across %d cells", + mod.name, + n_sections, + n_cells, + ) + if n_sections == 0: + logger.warning( + "section '%s' applied to zero sections, " + "please check its section_configure for possible mistakes", + mod.name, + ) + + +def _apply_compartment_set( + cells: dict, mod: ModificationCompartmentSet, circuit_access +) -> None: + """Apply compartment_set — exec section_configure on resolved segments.""" + logger.info( + "Applying modification '%s' (type=compartment_set) to compartment_set '%s'", + mod.name, + mod.compartment_set, + ) + + # Load compartment sets + try: + compartment_sets = circuit_access.config.get_compartment_sets() + except ValueError as e: + logger.warning( + "compartment_set '%s': cannot load compartment_sets_file: %s", + mod.name, + e, + ) + return + + comp_name = mod.compartment_set + if comp_name not in compartment_sets: + raise ValueError( + f"compartment_set modification '{mod.name}': compartment set " + f"'{comp_name}' not found in compartment_sets file." + ) + comp_entry = compartment_sets[comp_name] + comp_nodes = comp_entry.get("compartment_set", []) + population_name = comp_entry.get("population") + + # Parse section_configure — bare format: "attr = value" + # Prefix with "seg." to make it executable + config_str = re.sub(r"(\b\w+)\s*=", r"seg.\1 =", mod.section_configure) + # But we need to be careful: only LHS identifiers should be prefixed. + # Better approach: use ast to parse and validate + # For compartment_set, the format is "attr = value [; attr = value ...]" + # We prefix each bare assignment target with "seg." + statements = [s.strip() for s in mod.section_configure.split(";") if s.strip()] + prefixed_parts = [] + all_attrs: set[str] = set() + for stmt in statements: + prefixed = "seg." + stmt.strip() + prefixed_parts.append(prefixed) + config_str = "; ".join(prefixed_parts) + + # Parse to collect attrs + collector = _AttributeCollector() + tree = ast.parse(config_str) + for elem in tree.body: + _validate_assignment(elem) + collector.visit(elem) + all_attrs = collector.attrs + + n_cells = 0 + n_segments = 0 + for cell_id in cells: + cell = cells[cell_id] + node_id = cell_id.id if hasattr(cell_id, "id") else cell_id + + if ( + population_name is not None + and getattr(cell_id, "population_name", None) != population_name + ): + continue + + try: + resolved = cell.resolve_segments_from_compartment_set(node_id, comp_nodes) + except (ValueError, TypeError) as e: + logger.warning( + "compartment_set '%s': failed to resolve segments for cell %s, skipping: %s", + mod.name, + cell_id, + e, + ) + continue + + cell_applied = 0 + for section, sec_name, seg_x in resolved: + segment = section(seg_x) + if all(hasattr(segment, attr) for attr in all_attrs): + exec(config_str, {"__builtins__": None}, {"seg": segment}) # noqa: S102 + cell_applied += 1 + logger.debug( + " Applied to segment '%s(%s)' of cell %s", sec_name, seg_x, cell_id + ) + if cell_applied > 0: + n_cells += 1 + n_segments += cell_applied + + logger.info( + "Modification '%s' applied to %d segments across %d cells", + mod.name, + n_segments, + n_cells, + ) + if n_segments == 0: + logger.warning( + "compartment_set '%s' applied to zero segments, " + "please check its section_configure for possible mistakes", + mod.name, + ) diff --git a/bluecellulab/simulation/neuron_globals.py b/bluecellulab/simulation/neuron_globals.py index 2305790b..20236797 100644 --- a/bluecellulab/simulation/neuron_globals.py +++ b/bluecellulab/simulation/neuron_globals.py @@ -13,12 +13,15 @@ # limitations under the License. """Module that handles the global NEURON parameters.""" +import logging from typing import Optional from typing import NamedTuple import neuron from bluecellulab.circuit.config.sections import Conditions, MechanismConditions from bluecellulab.exceptions import error_context +logger = logging.getLogger(__name__) + def set_global_condition_parameters(condition_parameters: Conditions) -> None: """Sets the global condition parameters in NEURON objects if GluSynapse is @@ -35,14 +38,31 @@ def set_global_condition_parameters(condition_parameters: Conditions) -> None: set_minis_single_vesicle_values(mechanism_conditions) set_init_depleted_values(mechanism_conditions) + # Apply all mechanism variables generically (matching neurodamus behavior) + if condition_parameters.mechanisms: + for suffix, variables in condition_parameters.mechanisms.items(): + for var_name, value in variables.items(): + global_name = f"{var_name}_{suffix}" + if hasattr(neuron.h, global_name): + setattr(neuron.h, global_name, value) + logger.debug("Set NEURON global %s = %s", global_name, value) + def set_init_depleted_values(mech_conditions: MechanismConditions) -> None: """Set the init_depleted values in NEURON.""" with error_context("mechanism/s for init_depleted need to be compiled"): - if mech_conditions.glusynapse and mech_conditions.glusynapse.init_depleted is not None: + if ( + mech_conditions.glusynapse + and mech_conditions.glusynapse.init_depleted is not None + ): neuron.h.init_depleted_GluSynapse = mech_conditions.glusynapse.init_depleted - if mech_conditions.ampanmda and mech_conditions.ampanmda.init_depleted is not None: - neuron.h.init_depleted_ProbAMPANMDA_EMS = mech_conditions.ampanmda.init_depleted + if ( + mech_conditions.ampanmda + and mech_conditions.ampanmda.init_depleted is not None + ): + neuron.h.init_depleted_ProbAMPANMDA_EMS = ( + mech_conditions.ampanmda.init_depleted + ) if mech_conditions.gabaab and mech_conditions.gabaab.init_depleted is not None: neuron.h.init_depleted_ProbGABAAB_EMS = mech_conditions.gabaab.init_depleted @@ -50,15 +70,24 @@ def set_init_depleted_values(mech_conditions: MechanismConditions) -> None: def set_minis_single_vesicle_values(mech_conditions: MechanismConditions) -> None: """Set the minis_single_vesicle values in NEURON.""" with error_context("mechanism/s for minis_single_vesicle need to be compiled"): - if mech_conditions.ampanmda and mech_conditions.ampanmda.minis_single_vesicle is not None: + if ( + mech_conditions.ampanmda + and mech_conditions.ampanmda.minis_single_vesicle is not None + ): neuron.h.minis_single_vesicle_ProbAMPANMDA_EMS = ( mech_conditions.ampanmda.minis_single_vesicle ) - if mech_conditions.gabaab and mech_conditions.gabaab.minis_single_vesicle is not None: + if ( + mech_conditions.gabaab + and mech_conditions.gabaab.minis_single_vesicle is not None + ): neuron.h.minis_single_vesicle_ProbGABAAB_EMS = ( mech_conditions.gabaab.minis_single_vesicle ) - if mech_conditions.glusynapse and mech_conditions.glusynapse.minis_single_vesicle is not None: + if ( + mech_conditions.glusynapse + and mech_conditions.glusynapse.minis_single_vesicle is not None + ): neuron.h.minis_single_vesicle_GluSynapse = ( mech_conditions.glusynapse.minis_single_vesicle ) @@ -73,7 +102,7 @@ class NeuronGlobals: _instance = None def __init__(self): - raise RuntimeError('Call get_instance() instead') + raise RuntimeError("Call get_instance() instead") @classmethod def get_instance(cls): @@ -112,7 +141,9 @@ def load_params(self, params: NeuronGlobalParams) -> None: self.v_init = params.v_init -def set_neuron_globals(temperature: Optional[float] = 34.0, v_init: Optional[float] = -80.0) -> None: +def set_neuron_globals( + temperature: Optional[float] = 34.0, v_init: Optional[float] = -80.0 +) -> None: """Set the global NEURON parameters.""" if temperature is None and v_init is None: return diff --git a/examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json b/examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json new file mode 100644 index 00000000..e5a1a295 --- /dev/null +++ b/examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json @@ -0,0 +1,45 @@ +{ + "manifest": { + "$OUTPUT_DIR": "./output_sonata_modifications", + "$INPUT_DIR": "./input/" + }, + "run": { + "tstart": 0.0, + "tstop": 100.0, + "dt": 0.025, + "random_seed": 1, + "spike_threshold": -30 + }, + "conditions": { + "v_init": -65, + "modifications": [ + { + "name": "TTX_block_NodeB", + "type": "ttx", + "node_set": "Mosaic_B" + }, + { + "name": "double_cm_all", + "type": "configure_all_sections", + "node_set": "Mosaic_A", + "section_configure": "%s.cm = 2.0" + }, + { + "name": "scale_soma_cm", + "type": "section_list", + "node_set": "Mosaic_A", + "section_configure": "somatic.cm *= 1.5" + } + ] + }, + "target_simulator": "NEURON", + "network": "circuit_sonata.json", + "node_set": "Mosaic_A", + "output": { + "output_dir": "$OUTPUT_DIR", + "spikes_file": "out.h5", + "spikes_sort_order": "by_time" + }, + "inputs": {}, + "reports": {} + } diff --git a/examples/2-sonata-network/sonata-modifications.ipynb b/examples/2-sonata-network/sonata-modifications.ipynb new file mode 100644 index 00000000..bf960420 --- /dev/null +++ b/examples/2-sonata-network/sonata-modifications.ipynb @@ -0,0 +1,334 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# SONATA Condition Modifications\n", + "\n", + "This notebook demonstrates how to use SONATA **condition modifications** in BlueCelluLab.\n", + "\n", + "Modifications are defined in the `conditions` block of a SONATA simulation config and allow you to\n", + "alter cell properties before the simulation runs. BlueCelluLab supports all five SONATA modification types:\n", + "\n", + "| Type | Description |\n", + "|------|-------------|\n", + "| `ttx` | Block Na channels (insert TTXDynamicsSwitch) |\n", + "| `configure_all_sections` | Apply a statement to all sections of target cells |\n", + "| `section_list` | Apply a statement to a named section list (somatic, basal, apical, axonal) |\n", + "| `section` | Apply a statement to specific named sections (e.g. apic[10]) |\n", + "| `compartment_set` | Apply a statement to segments defined by a compartment set |\n", + "\n", + "See the [SONATA-extension documentation](https://sonata-extension.readthedocs.io/en/latest/sonata_simulation.html#parameters-required-for-modifications) for the full specification." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Compile mechanisms\n", + "\n", + "As in the previous tutorial, we first compile the NEURON mechanisms." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!nrnivmodl ../mechanisms" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import logging\n", + "from pathlib import Path\n", + "\n", + "from matplotlib import pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "sns.set_style(\"white\")\n", + "\n", + "from bluecellulab import CircuitSimulation\n", + "from bluecellulab.circuit.config import SonataSimulationConfig" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Enable INFO logging for the modifications module to see what happens\n", + "logging.basicConfig(level=logging.WARNING)\n", + "logging.getLogger(\"bluecellulab.simulation.modifications\").setLevel(logging.INFO)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Examine the simulation config with modifications\n", + "\n", + "We have prepared a simulation config that includes three modifications in its `conditions` block." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sim_config_path = Path(\"sim_quick_scx_sonata_multicircuit\") / \"simulation_config_modifications.json\"\n", + "\n", + "with open(sim_config_path) as f:\n", + " config_dict = json.load(f)\n", + "\n", + "print(json.dumps(config_dict[\"conditions\"], indent=4))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The three modifications are:\n", + "\n", + "1. **`TTX_block_NodeB`** (`ttx`): Blocks Na channels on all cells in the `Mosaic_B` node set by inserting `TTXDynamicsSwitch`.\n", + "2. **`double_cm_all`** (`configure_all_sections`): Doubles membrane capacitance (`cm = 2.0`) on **all** sections of `Mosaic_A` cells.\n", + "3. **`scale_soma_cm`** (`section_list`): Further scales `cm` by 1.5x on only the **somatic** sections of `Mosaic_A` cells.\n", + "\n", + "After both modifications, somatic sections of Mosaic_A cells will have `cm = 2.0 * 1.5 = 3.0`, while dendritic/axonal sections will have `cm = 2.0`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Parse modifications with BlueCelluLab\n", + "\n", + "BlueCelluLab parses the modifications into typed dataclasses via `get_modifications()`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sonata_config = SonataSimulationConfig(sim_config_path)\n", + "modifications = sonata_config.get_modifications()\n", + "\n", + "for mod in modifications:\n", + " print(f\" {mod.name}: type={mod.type}, class={type(mod).__name__}\")\n", + " if hasattr(mod, 'section_configure'):\n", + " print(f\" section_configure: {mod.section_configure}\")\n", + " if hasattr(mod, 'node_set'):\n", + " print(f\" node_set: {mod.node_set}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Run simulation with modifications\n", + "\n", + "When `CircuitSimulation.instantiate_gids()` is called, modifications are automatically applied after cells are created but before synapses and stimuli are added. This matches the ordering used by [neurodamus](https://github.com/openbraininstitute/neurodamus).\n", + "\n", + "The INFO-level logs show exactly which modifications were applied and to how many sections/cells." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sim = CircuitSimulation(sim_config_path)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from bluepysnap import Simulation as snap_sim\n", + "import pandas as pd\n", + "\n", + "snap_access = snap_sim(sim_config_path)\n", + "all_nodes = pd.concat([x[1] for x in snap_access.circuit.nodes.get()])\n", + "all_cell_ids = all_nodes.index.to_list()\n", + "print(f\"All cells in circuit: {all_cell_ids}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Instantiate all cells — modifications are applied automatically\n", + "sim.instantiate_gids(all_cell_ids, add_stimuli=False, add_synapses=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Verify modifications were applied\n", + "\n", + "Let's inspect the cells to confirm the modifications took effect." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(\"=\" * 70)\n", + "print(\"Checking membrane capacitance (cm) on Mosaic_A cells\")\n", + "print(\"Expected: somatic cm=3.0 (2.0 * 1.5), dendritic cm=2.0\")\n", + "print(\"=\" * 70)\n", + "\n", + "for cell_id in sim.cells:\n", + " cell = sim.cells[cell_id]\n", + " print(f\"\\nCell {cell_id}:\")\n", + "\n", + " # Check soma cm\n", + " if cell.somatic:\n", + " soma_sec = cell.somatic[0]\n", + " print(f\" soma cm = {soma_sec.cm}\")\n", + "\n", + " # Check a dendritic section cm (if available)\n", + " for sec_name, sec in list(cell.sections.items())[:5]:\n", + " if 'dend' in sec_name or 'apic' in sec_name:\n", + " print(f\" {sec_name} cm = {sec.cm}\")\n", + " break" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Compare: with vs without modifications\n", + "\n", + "To see the effect of modifications on simulation output, let's run two simulations\n", + "side by side — one with and one without modifications — and compare the voltage traces." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Simulation WITH modifications (already instantiated above)\n", + "sim.run(t_stop=100.0)\n", + "traces_with_mods = {}\n", + "for cell_id in sim.cells:\n", + " traces_with_mods[cell_id] = {\n", + " \"time\": sim.get_time_trace(),\n", + " \"voltage\": sim.get_voltage_trace(cell_id),\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Simulation WITHOUT modifications (baseline)\n", + "baseline_config = Path(\"sim_quick_scx_sonata_multicircuit\") / \"simulation_config_noinput.json\"\n", + "sim_baseline = CircuitSimulation(baseline_config)\n", + "sim_baseline.instantiate_gids(all_cell_ids, add_stimuli=False, add_synapses=False)\n", + "sim_baseline.run(t_stop=100.0)\n", + "traces_baseline = {}\n", + "for cell_id in sim_baseline.cells:\n", + " traces_baseline[cell_id] = {\n", + " \"time\": sim_baseline.get_time_trace(),\n", + " \"voltage\": sim_baseline.get_voltage_trace(cell_id),\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Plot comparison\n", + "fig, axes = plt.subplots(len(sim.cells), 1, figsize=(12, 3 * len(sim.cells)), sharex=True)\n", + "if len(sim.cells) == 1:\n", + " axes = [axes]\n", + "\n", + "for ax, cell_id in zip(axes, sim.cells):\n", + " if cell_id in traces_baseline:\n", + " ax.plot(traces_baseline[cell_id][\"time\"], traces_baseline[cell_id][\"voltage\"],\n", + " label=\"baseline\", alpha=0.8)\n", + " if cell_id in traces_with_mods:\n", + " ax.plot(traces_with_mods[cell_id][\"time\"], traces_with_mods[cell_id][\"voltage\"],\n", + " label=\"with modifications\", alpha=0.8, linestyle=\"--\")\n", + " ax.set_ylabel(\"Voltage (mV)\")\n", + " ax.set_title(str(cell_id))\n", + " ax.legend(loc=\"upper right\")\n", + "\n", + "axes[-1].set_xlabel(\"Time (ms)\")\n", + "plt.tight_layout()\n", + "plt.savefig(\"ex2_modifications_comparison.pdf\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7. Graceful skipping behavior\n", + "\n", + "An important design decision: modifications **skip** sections or cells that don't match,\n", + "rather than failing. This is essential because `node_set` targets can contain heterogeneous\n", + "cells (e.g., some with apical dendrites, some without).\n", + "\n", + "- Sections missing a referenced attribute are silently skipped\n", + "- If zero sections matched, a warning is logged\n", + "- Invalid `section_configure` syntax still raises an error\n", + "\n", + "This matches [neurodamus's behavior](https://github.com/openbraininstitute/neurodamus) for `configure_all_sections`\n", + "and extends it consistently to the new types (`section_list`, `section`, `compartment_set`)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "- Modifications are defined in `conditions.modifications` of the SONATA simulation config\n", + "- BlueCelluLab parses them via `SonataSimulationConfig.get_modifications()`\n", + "- They are automatically applied during `CircuitSimulation.instantiate_gids()`, after cell creation\n", + "- All five types are supported: `ttx`, `configure_all_sections`, `section_list`, `section`, `compartment_set`\n", + "- Logging at INFO level shows what was applied; WARNING level flags zero-match cases" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/pyproject.toml b/pyproject.toml index 75a4c699..3b439f08 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -33,6 +33,7 @@ dependencies = [ "matplotlib>=3.0.0,<4.0.0", "pandas>=1.0.0,<3.0.0", "bluepysnap>=3.0.0,<4.0.0", + "libsonata>=0.1.34", "pydantic>=2.5.2,<3.0.0", "typing-extensions>=4.8.0", "networkx>=3.1", diff --git a/tests/examples/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json b/tests/examples/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json new file mode 100644 index 00000000..08196b71 --- /dev/null +++ b/tests/examples/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json @@ -0,0 +1,38 @@ +{ + "manifest": { + "$CIRCUIT_DIR": "usecase3", + "$OUTPUT_DIR": "." + }, + "run": { + "tstop": 50.0, + "dt": 0.025, + "random_seed": 1 + }, + "conditions": { + "v_init": -65, + "modifications": [ + { + "name": "TTX_block", + "type": "ttx", + "node_set": "Mosaic_A" + }, + { + "name": "configure_all", + "type": "configure_all_sections", + "node_set": "Mosaic_A", + "section_configure": "%s.cm = 2.0" + } + ] + }, + "target_simulator": "NEURON", + "network": "circuit_sonata.json", + "node_set": "Mosaic_A", + "compartment_sets_file": "compartment_sets.json", + "output": { + "output_dir": "$OUTPUT_DIR/output_sonata_modifications", + "spikes_file": "out.h5", + "spikes_sort_order": "by_time" + }, + "inputs": {}, + "reports": {} + } diff --git a/tests/test_circuit/test_simulation_config.py b/tests/test_circuit/test_simulation_config.py index 4b38a867..d5816e05 100644 --- a/tests/test_circuit/test_simulation_config.py +++ b/tests/test_circuit/test_simulation_config.py @@ -26,7 +26,17 @@ ConnectionOverrides, MechanismConditions, ) -from bluecellulab.stimulus.circuit_stimulus_definitions import Noise, Hyperpolarizing, Linear, Pulse, RelativeLinear, ShotNoise, RelativeShotNoise, OrnsteinUhlenbeck, RelativeOrnsteinUhlenbeck +from bluecellulab.stimulus.circuit_stimulus_definitions import ( + Noise, + Hyperpolarizing, + Linear, + Pulse, + RelativeLinear, + ShotNoise, + RelativeShotNoise, + OrnsteinUhlenbeck, + RelativeOrnsteinUhlenbeck, +) from tests.helpers.os_utils import cwd @@ -73,15 +83,32 @@ def test_init_with_invalid_type(): def test_get_all_stimuli_entries(): sim = SonataSimulationConfig(multi_input_conf_path) - noise_stim = Noise(target="Mosaic_A", delay=10.0, duration=20.0, mean_percent=200.0, variance=0.001, node_set="Mosaic_A",) + noise_stim = Noise( + target="Mosaic_A", + delay=10.0, + duration=20.0, + mean_percent=200.0, + variance=0.001, + node_set="Mosaic_A", + ) hyper_stim = Hyperpolarizing("Mosaic_A", 0.0, 50.0, node_set="Mosaic_A") pulse_stim = Pulse("Mosaic_A", 10.0, 20.0, 0.1, 25, 10, node_set="Mosaic_A") linear_stim = Linear("Mosaic_A", 10.0, 20.0, 0.1, 0.4, node_set="Mosaic_A") - relative_linear_stim = RelativeLinear("Mosaic_A", 10.0, 20.0, 50, 100, node_set="Mosaic_A") - shot_noise_stim = ShotNoise("Mosaic_A", 10.0, 20, 2, 5, 10, 0.1, 0.02, 0.25, 42, node_set="Mosaic_A") - relative_shot_noise_stim = RelativeShotNoise("Mosaic_A", 10.0, 20, 2, 5, 50, 10, 0.5, 0.25, 42, node_set="Mosaic_A") - ornstein_uhlenbeck_stim = OrnsteinUhlenbeck("Mosaic_A", 10.0, 20.0, 5, 0.1, 0, 0.25, 42, node_set="Mosaic_A") - relative_ornstein_uhlenbeck_stim = RelativeOrnsteinUhlenbeck("Mosaic_A", 10.0, 20.0, 5, 50, 10, 0.25, 42, node_set="Mosaic_A") + relative_linear_stim = RelativeLinear( + "Mosaic_A", 10.0, 20.0, 50, 100, node_set="Mosaic_A" + ) + shot_noise_stim = ShotNoise( + "Mosaic_A", 10.0, 20, 2, 5, 10, 0.1, 0.02, 0.25, 42, node_set="Mosaic_A" + ) + relative_shot_noise_stim = RelativeShotNoise( + "Mosaic_A", 10.0, 20, 2, 5, 50, 10, 0.5, 0.25, 42, node_set="Mosaic_A" + ) + ornstein_uhlenbeck_stim = OrnsteinUhlenbeck( + "Mosaic_A", 10.0, 20.0, 5, 0.1, 0, 0.25, 42, node_set="Mosaic_A" + ) + relative_ornstein_uhlenbeck_stim = RelativeOrnsteinUhlenbeck( + "Mosaic_A", 10.0, 20.0, 5, 50, 10, 0.25, 42, node_set="Mosaic_A" + ) entries = sim.get_all_stimuli_entries() assert len(entries) == 9 assert entries[0] == linear_stim @@ -104,6 +131,11 @@ def test_condition_parameters(): gabaab=ConditionEntry(minis_single_vesicle=None, init_depleted=None), glusynapse=ConditionEntry(minis_single_vesicle=None, init_depleted=None), ), + mechanisms={ + "ProbAMPANMDA_EMS": {"init_depleted": True, "minis_single_vesicle": False}, + "ProbGABAAB_EMS": {"property_x": 1, "property_y": 0.25}, + "GluSynapse": {"property_z": "string"}, + }, celsius=34.0, v_init=-80.0, extracellular_calcium=None, @@ -124,7 +156,10 @@ def test_connection_entries(): synapse_configure=None, mod_override=None, ) - assert entries[2].synapse_configure == "%s.NMDA_ratio = 1.22 %s.tau_r_NMDA = 3.9 %s.tau_d_NMDA = 148.5" + assert ( + entries[2].synapse_configure + == "%s.NMDA_ratio = 1.22 %s.tau_r_NMDA = 3.9 %s.tau_d_NMDA = 148.5" + ) assert entries[-1] == ConnectionOverrides( source="Excitatory", target="Mosaic", @@ -132,7 +167,7 @@ def test_connection_entries(): weight=None, spont_minis=None, synapse_configure="%s.mg = 1.0", - mod_override=None + mod_override=None, ) @@ -149,7 +184,7 @@ def test_connection_override(): weight=2.0, spont_minis=0.1, synapse_configure="%s.mg = 1.4", - mod_override=None + mod_override=None, ) sim.add_connection_override(connection_override) @@ -252,12 +287,16 @@ def test_extracellular_calcium(): def test_get_compartment_sets(tmp_path): file = tmp_path / "compartment_sets.json" - file.write_text(json.dumps({ - "soma_set": { - "population": "Mosaic", - "compartment_set": [[0, "soma", 0.5]] - } - })) + file.write_text( + json.dumps( + { + "soma_set": { + "population": "Mosaic", + "compartment_set": [[0, "soma", 0.5]], + } + } + ) + ) sim = SonataSimulationConfig.__new__(SonataSimulationConfig) sim.impl = type("impl", (), {"config": {"compartment_sets_file": str(file)}}) result = sim.get_compartment_sets() @@ -268,36 +307,38 @@ def test_get_compartment_sets(tmp_path): def test_get_node_sets(tmp_path): # Circuit file content circuit_file = tmp_path / "circuit_node_sets.json" - circuit_file.write_text(json.dumps({ - "set_from_circuit": { - "population": "PopA", - "node_id": [1, 2] - }, - "overwritten_set": { - "population": "PopB", - "node_id": [3] - } - })) + circuit_file.write_text( + json.dumps( + { + "set_from_circuit": {"population": "PopA", "node_id": [1, 2]}, + "overwritten_set": {"population": "PopB", "node_id": [3]}, + } + ) + ) # Simulation file content sim_file = tmp_path / "sim_node_sets.json" - sim_file.write_text(json.dumps({ - "overwritten_set": { - "population": "PopB", - "node_id": [99] - }, - "set_from_sim": { - "population": "PopC", - "node_id": [4] - } - })) + sim_file.write_text( + json.dumps( + { + "overwritten_set": {"population": "PopB", "node_id": [99]}, + "set_from_sim": {"population": "PopC", "node_id": [4]}, + } + ) + ) # Simulates the SonataSimulationConfig instance sim = SonataSimulationConfig.__new__(SonataSimulationConfig) - sim.impl = type("impl", (), { - "circuit": type("circuit", (), {"config": {"node_sets_file": str(circuit_file)}})(), - "config": {"node_sets_file": str(sim_file)} - }) + sim.impl = type( + "impl", + (), + { + "circuit": type( + "circuit", (), {"config": {"node_sets_file": str(circuit_file)}} + )(), + "config": {"node_sets_file": str(sim_file)}, + }, + ) # Call method result = sim.get_node_sets() @@ -305,68 +346,77 @@ def test_get_node_sets(tmp_path): # Validate merged result assert set(result) == {"set_from_circuit", "overwritten_set", "set_from_sim"} assert result["set_from_circuit"]["node_id"] == [1, 2] - assert result["overwritten_set"]["node_id"] == [99] # Overwritten by simulation file + assert result["overwritten_set"]["node_id"] == [ + 99 + ] # Overwritten by simulation file assert result["set_from_sim"]["node_id"] == [4] def test_get_node_sets_only_circuit(tmp_path): circuit_file = tmp_path / "node_sets.json" - circuit_file.write_text(json.dumps({ - "only_circuit": { - "population": "PopX", - "node_id": [5] - } - })) + circuit_file.write_text( + json.dumps({"only_circuit": {"population": "PopX", "node_id": [5]}}) + ) sim = SonataSimulationConfig.__new__(SonataSimulationConfig) - sim.impl = type("impl", (), { - "circuit": type("circuit", (), {"config": {"node_sets_file": str(circuit_file)}})(), - "config": {} - }) + sim.impl = type( + "impl", + (), + { + "circuit": type( + "circuit", (), {"config": {"node_sets_file": str(circuit_file)}} + )(), + "config": {}, + }, + ) result = sim.get_node_sets() assert "only_circuit" in result def test_get_node_sets_only_sim(tmp_path): sim_file = tmp_path / "node_sets.json" - sim_file.write_text(json.dumps({ - "only_sim": { - "population": "PopY", - "node_id": [6] - } - })) + sim_file.write_text( + json.dumps({"only_sim": {"population": "PopY", "node_id": [6]}}) + ) sim = SonataSimulationConfig.__new__(SonataSimulationConfig) - sim.impl = type("impl", (), { - "circuit": type("circuit", (), {"config": {}})(), - "config": {"node_sets_file": str(sim_file)} - }) + sim.impl = type( + "impl", + (), + { + "circuit": type("circuit", (), {"config": {}})(), + "config": {"node_sets_file": str(sim_file)}, + }, + ) result = sim.get_node_sets() assert "only_sim" in result def test_get_node_sets_no_files(): sim = SonataSimulationConfig.__new__(SonataSimulationConfig) - sim.impl = type("impl", (), { - "circuit": type("circuit", (), {"config": {}})(), - "config": {} - }) + sim.impl = type( + "impl", (), {"circuit": type("circuit", (), {"config": {}})(), "config": {}} + ) with pytest.raises(ValueError, match="No 'node_sets_file' found"): sim.get_node_sets() def test_get_report_entries(): sim = SonataSimulationConfig.__new__(SonataSimulationConfig) - sim.impl = type("impl", (), { - "config": { - "reports": { - "soma_v": { - "cells": "target_cells", - "section": "soma", - "variable_name": "v", - "compartments": "center" + sim.impl = type( + "impl", + (), + { + "config": { + "reports": { + "soma_v": { + "cells": "target_cells", + "section": "soma", + "variable_name": "v", + "compartments": "center", + } } } - } - }) + }, + ) result = sim.get_report_entries() assert "soma_v" in result assert result["soma_v"]["variable_name"] == "v" diff --git a/tests/test_simulation/test_modifications.py b/tests/test_simulation/test_modifications.py new file mode 100644 index 00000000..287ad47b --- /dev/null +++ b/tests/test_simulation/test_modifications.py @@ -0,0 +1,736 @@ +# Copyright 2023-2024 Blue Brain Project / EPFL + +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at + +# http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Unit tests for bluecellulab/simulation/modifications.py.""" + +from pathlib import Path +from unittest import mock + +import pytest + +from bluecellulab.circuit.config.sections import ( + ModificationBase, + ModificationCompartmentSet, + ModificationConfigureAllSections, + ModificationSection, + ModificationSectionList, + ModificationTTX, + modification_from_libsonata, +) +from bluecellulab.simulation.modifications import ( + _apply_configure_all_sections, + _apply_section, + _apply_section_list, + _apply_ttx, + _exec_on_section, + apply_modifications, + parse_section_configure, +) + + +# ---- parse_section_configure tests ---- + + +class TestParseSectionConfigure: + def test_simple_assignment(self): + config, attrs = parse_section_configure("%s.cm = 2.0") + assert config == "sec.cm = 2.0" + assert attrs == {"cm"} + + def test_multiple_assignments(self): + config, attrs = parse_section_configure("%s.gbar = 0; %s.cm = 1.5") + assert "sec.gbar = 0" in config + assert "sec.cm = 1.5" in config + assert attrs == {"gbar", "cm"} + + def test_augmented_assignment(self): + config, attrs = parse_section_configure("%s.gbar *= 0.5") + assert config == "sec.gbar *= 0.5" + assert "gbar" in attrs + + def test_invalid_non_assignment(self): + with pytest.raises(ValueError, match="assignments"): + parse_section_configure("%s.gbar") + + def test_invalid_no_placeholder(self): + with pytest.raises(Exception): + parse_section_configure("gbar = 0") + + +# ---- _exec_on_section tests ---- + + +class TestExecOnSection: + def test_applies_when_attr_exists(self): + section = mock.MagicMock() + section.cm = 1.0 + result = _exec_on_section("sec.cm = 2.0", section, {"cm"}) + assert result is True + assert section.cm == 2.0 + + def test_skips_when_attr_missing(self): + section = mock.MagicMock(spec=[]) # no attributes + result = _exec_on_section("sec.cm = 2.0", section, {"cm"}) + assert result is False + + +# ---- modification_from_libsonata tests ---- + + +class TestModificationFromLibsonata: + def _make_mock(self, type_name, **kwargs): + m = mock.MagicMock() + m.type.name = type_name + m.name = kwargs.get("name", "test_mod") + if "node_set" in kwargs: + m.node_set = kwargs["node_set"] + if "section_configure" in kwargs: + m.section_configure = kwargs["section_configure"] + if "compartment_set" in kwargs: + m.compartment_set = kwargs["compartment_set"] + return m + + def test_ttx(self): + mod = self._make_mock("ttx", node_set="target") + result = modification_from_libsonata(mod) + assert isinstance(result, ModificationTTX) + assert result.name == "test_mod" + assert result.node_set == "target" + + def test_configure_all_sections(self): + mod = self._make_mock( + "configure_all_sections", node_set="target", section_configure="%s.cm = 2" + ) + result = modification_from_libsonata(mod) + assert isinstance(result, ModificationConfigureAllSections) + assert result.section_configure == "%s.cm = 2" + + def test_section_list(self): + mod = self._make_mock( + "section_list", node_set="target", section_configure="apical.gbar = 0" + ) + result = modification_from_libsonata(mod) + assert isinstance(result, ModificationSectionList) + + def test_section(self): + mod = self._make_mock( + "section", node_set="target", section_configure="apic[10].gbar = 0" + ) + result = modification_from_libsonata(mod) + assert isinstance(result, ModificationSection) + + def test_compartment_set(self): + mod = self._make_mock( + "compartment_set", compartment_set="my_set", section_configure="gbar = 1.5" + ) + result = modification_from_libsonata(mod) + assert isinstance(result, ModificationCompartmentSet) + assert result.compartment_set == "my_set" + + def test_unknown_type(self): + mod = self._make_mock("unknown_type") + with pytest.raises(ValueError, match="Unknown modification type"): + modification_from_libsonata(mod) + + +# ---- Handler tests with mocked cells ---- + + +def _make_mock_cell(sections=None, section_lists=None, enable_ttx=True): + """Create a mock cell with sections and optional section lists.""" + cell = mock.MagicMock() + if sections is None: + sections = {} + cell.sections = sections + + # Section list properties + for list_name in ["somatic", "basal", "apical", "axonal"]: + if section_lists and list_name in section_lists: + setattr( + type(cell), + list_name, + mock.PropertyMock(return_value=section_lists[list_name]), + ) + else: + setattr(type(cell), list_name, mock.PropertyMock(return_value=[])) + + if enable_ttx: + cell.enable_ttx = mock.MagicMock() + return cell + + +def _make_mock_section(name="soma[0]", attrs=None): + """Create a mock NEURON section with given attributes.""" + section = mock.MagicMock() + section.name.return_value = f"Cell.{name}" + if attrs: + for k, v in attrs.items(): + setattr(section, k, v) + return section + + +def _make_circuit_access(target_cell_ids=None): + """Create a mock circuit access.""" + ca = mock.MagicMock() + if target_cell_ids is not None: + ca.get_target_cell_ids.return_value = set(target_cell_ids) + return ca + + +class TestApplyTTX: + def test_enables_ttx_on_target_cells(self): + cell_id = mock.MagicMock() + cell = _make_mock_cell() + cells = {cell_id: cell} + mod = ModificationTTX(name="block", type="ttx", node_set="target") + ca = _make_circuit_access(target_cell_ids=[cell_id]) + + _apply_ttx(cells, mod, ca) + cell.enable_ttx.assert_called_once() + + def test_zero_match_warning(self, caplog): + import logging + + cell_id = mock.MagicMock() + cell = _make_mock_cell() + cells = {cell_id: cell} + mod = ModificationTTX(name="block", type="ttx", node_set="empty") + ca = _make_circuit_access(target_cell_ids=[]) + + with caplog.at_level(logging.WARNING): + _apply_ttx(cells, mod, ca) + assert "matched zero cells" in caplog.text + + +class TestApplyConfigureAllSections: + def test_applies_to_matching_sections(self): + sec1 = _make_mock_section("soma[0]", {"cm": 1.0}) + sec2 = _make_mock_section("dend[0]", {"cm": 1.0}) + cell_id = mock.MagicMock() + cell = _make_mock_cell(sections={"soma[0]": sec1, "dend[0]": sec2}) + cells = {cell_id: cell} + mod = ModificationConfigureAllSections( + name="set_cm", + type="configure_all_sections", + node_set="target", + section_configure="%s.cm = 2.0", + ) + ca = _make_circuit_access(target_cell_ids=[cell_id]) + + _apply_configure_all_sections(cells, mod, ca) + assert sec1.cm == 2.0 + assert sec2.cm == 2.0 + + def test_skips_sections_missing_attr(self): + sec1 = _make_mock_section("soma[0]", {"cm": 1.0}) + # Create a section that explicitly lacks the 'cm' attribute + sec2 = _make_mock_section("dend[0]") + del sec2.cm # remove the auto-created attribute + cell_id = mock.MagicMock() + cell = _make_mock_cell(sections={"soma[0]": sec1, "dend[0]": sec2}) + cells = {cell_id: cell} + mod = ModificationConfigureAllSections( + name="set_cm", + type="configure_all_sections", + node_set="target", + section_configure="%s.cm = 2.0", + ) + ca = _make_circuit_access(target_cell_ids=[cell_id]) + + _apply_configure_all_sections(cells, mod, ca) + assert sec1.cm == 2.0 + # sec2 should not have cm set since it was missing + assert not hasattr(sec2, "cm") + + +class TestApplySectionList: + def test_applies_to_section_list(self): + sec = _make_mock_section("apic[0]", {"gbar": 1.0}) + cell_id = mock.MagicMock() + cell = _make_mock_cell( + sections={"apic[0]": sec}, + section_lists={"apical": [sec]}, + ) + cells = {cell_id: cell} + mod = ModificationSectionList( + name="no_gbar", + type="section_list", + node_set="target", + section_configure="apical.gbar = 0", + ) + ca = _make_circuit_access(target_cell_ids=[cell_id]) + + _apply_section_list(cells, mod, ca) + assert sec.gbar == 0 + + def test_warns_empty_section_list(self, caplog): + import logging + + cell_id = mock.MagicMock() + cell = _make_mock_cell(section_lists={"apical": []}) + cells = {cell_id: cell} + mod = ModificationSectionList( + name="no_gbar", + type="section_list", + node_set="target", + section_configure="apical.gbar = 0", + ) + ca = _make_circuit_access(target_cell_ids=[cell_id]) + + with caplog.at_level(logging.WARNING): + _apply_section_list(cells, mod, ca) + assert "no 'apical' sections" in caplog.text + + def test_unknown_list_name_raises(self): + mod = ModificationSectionList( + name="bad", + type="section_list", + node_set="target", + section_configure="unknown_list.gbar = 0", + ) + with pytest.raises(ValueError, match="unknown section list name"): + _apply_section_list({}, mod, _make_circuit_access([])) + + +class TestApplySection: + def test_applies_to_named_section(self): + sec = _make_mock_section("apic[10]", {"gbar": 1.0}) + cell_id = mock.MagicMock() + cell = _make_mock_cell(sections={"apic[10]": sec}) + cell.get_section.return_value = sec + cells = {cell_id: cell} + mod = ModificationSection( + name="set_gbar", + type="section", + node_set="target", + section_configure="apic[10].gbar = 0", + ) + ca = _make_circuit_access(target_cell_ids=[cell_id]) + + _apply_section(cells, mod, ca) + assert sec.gbar == 0 + + def test_warns_missing_section(self, caplog): + import logging + + cell_id = mock.MagicMock() + cell = _make_mock_cell() + cell.get_section.side_effect = ValueError("not found") + cells = {cell_id: cell} + mod = ModificationSection( + name="set_gbar", + type="section", + node_set="target", + section_configure="apic[10].gbar = 0", + ) + ca = _make_circuit_access(target_cell_ids=[cell_id]) + + with caplog.at_level(logging.WARNING): + _apply_section(cells, mod, ca) + assert "does not have section" in caplog.text + + +class TestApplyConfigureAllSectionsZeroMatch: + def test_warns_zero_sections(self, caplog): + import logging + + cell_id = mock.MagicMock() + # Cell with sections that all lack the referenced attribute + sec = _make_mock_section("soma[0]") + del sec.nonexistent_attr + cell = _make_mock_cell(sections={"soma[0]": sec}) + cells = {cell_id: cell} + mod = ModificationConfigureAllSections( + name="zero_match", + type="configure_all_sections", + node_set="target", + section_configure="%s.nonexistent_attr = 1", + ) + ca = _make_circuit_access(target_cell_ids=[cell_id]) + + with caplog.at_level(logging.WARNING): + _apply_configure_all_sections(cells, mod, ca) + assert "applied to zero sections" in caplog.text + + +class _CellWithoutApical: + """Helper cell-like object that raises AttributeError for 'apical'.""" + + sections = {} + + @property + def apical(self): + raise AttributeError("no apical property") + + +class TestApplySectionListAttributeError: + def test_warns_missing_property(self, caplog): + """Test the AttributeError branch when cell lacks the section list property.""" + import logging + + cell_id = mock.MagicMock() + cell = _CellWithoutApical() + cells = {cell_id: cell} + mod = ModificationSectionList( + name="no_prop", + type="section_list", + node_set="target", + section_configure="apical.gbar = 0", + ) + ca = _make_circuit_access(target_cell_ids=[cell_id]) + + with caplog.at_level(logging.WARNING): + _apply_section_list(cells, mod, ca) + assert "has no 'apical' property" in caplog.text + + def test_invalid_section_configure_raises(self): + mod = ModificationSectionList( + name="bad", + type="section_list", + node_set="target", + section_configure="= 0", + ) + with pytest.raises(ValueError): + _apply_section_list({}, mod, _make_circuit_access([])) + + +class TestApplySectionEdgeCases: + def test_invalid_section_configure_raises(self): + mod = ModificationSection( + name="bad", + type="section", + node_set="target", + section_configure="gbar = 0", # no section[idx]. prefix + ) + with pytest.raises(ValueError, match="cannot extract section name"): + _apply_section({}, mod, _make_circuit_access([])) + + def test_zero_match_warning(self, caplog): + import logging + + cell_id = mock.MagicMock() + cell = _make_mock_cell() + cell.get_section.side_effect = ValueError("not found") + cells = {cell_id: cell} + mod = ModificationSection( + name="zero", + type="section", + node_set="target", + section_configure="apic[10].gbar = 0", + ) + ca = _make_circuit_access(target_cell_ids=[cell_id]) + + with caplog.at_level(logging.WARNING): + _apply_section(cells, mod, ca) + assert "applied to zero sections" in caplog.text + + +class TestApplyCompartmentSet: + def _make_segment(self, attrs=None): + seg = mock.MagicMock() + if attrs: + for k, v in attrs.items(): + setattr(seg, k, v) + return seg + + def test_applies_to_resolved_segments(self): + from bluecellulab.simulation.modifications import _apply_compartment_set + + cell_id = mock.MagicMock() + cell_id.id = 0 + cell_id.population_name = "NodeA" + + seg = self._make_segment({"gbar": 1.0}) + section = mock.MagicMock() + section.return_value = seg # section(seg_x) returns the segment + section.name.return_value = "Cell.soma[0]" + + cell = mock.MagicMock() + cell.resolve_segments_from_compartment_set.return_value = [ + (section, "soma[0]", 0.5) + ] + cells = {cell_id: cell} + + ca = mock.MagicMock() + ca.config.get_compartment_sets.return_value = { + "my_set": { + "population": "NodeA", + "compartment_set": [[0, "soma[0]", 0.5]], + } + } + + mod = ModificationCompartmentSet( + name="set_gbar", + type="compartment_set", + compartment_set="my_set", + section_configure="gbar = 0.5", + ) + _apply_compartment_set(cells, mod, ca) + assert seg.gbar == 0.5 + + def test_warns_missing_compartment_sets_file(self, caplog): + import logging + from bluecellulab.simulation.modifications import _apply_compartment_set + + ca = mock.MagicMock() + ca.config.get_compartment_sets.side_effect = ValueError("no file") + + mod = ModificationCompartmentSet( + name="no_file", + type="compartment_set", + compartment_set="my_set", + section_configure="gbar = 0", + ) + with caplog.at_level(logging.WARNING): + _apply_compartment_set({}, mod, ca) + assert "cannot load compartment_sets_file" in caplog.text + + def test_raises_missing_compartment_set_name(self): + from bluecellulab.simulation.modifications import _apply_compartment_set + + ca = mock.MagicMock() + ca.config.get_compartment_sets.return_value = {} + + mod = ModificationCompartmentSet( + name="missing", + type="compartment_set", + compartment_set="nonexistent", + section_configure="gbar = 0", + ) + with pytest.raises(ValueError, match="not found in compartment_sets file"): + _apply_compartment_set({}, mod, ca) + + def test_warns_failed_segment_resolution(self, caplog): + import logging + from bluecellulab.simulation.modifications import _apply_compartment_set + + cell_id = mock.MagicMock() + cell_id.id = 0 + cell_id.population_name = "NodeA" + cell = mock.MagicMock() + cell.resolve_segments_from_compartment_set.side_effect = ValueError("bad") + cells = {cell_id: cell} + + ca = mock.MagicMock() + ca.config.get_compartment_sets.return_value = { + "my_set": { + "population": "NodeA", + "compartment_set": [[0, "soma[0]", 0.5]], + } + } + + mod = ModificationCompartmentSet( + name="fail_resolve", + type="compartment_set", + compartment_set="my_set", + section_configure="gbar = 0", + ) + with caplog.at_level(logging.WARNING): + _apply_compartment_set(cells, mod, ca) + assert "failed to resolve segments" in caplog.text + + def test_zero_match_warning(self, caplog): + import logging + from bluecellulab.simulation.modifications import _apply_compartment_set + + cell_id = mock.MagicMock() + cell_id.id = 0 + cell_id.population_name = "NodeA" + + # Segment missing the referenced attribute + seg = mock.MagicMock(spec=[]) + section = mock.MagicMock() + section.return_value = seg + + cell = mock.MagicMock() + cell.resolve_segments_from_compartment_set.return_value = [ + (section, "soma[0]", 0.5) + ] + cells = {cell_id: cell} + + ca = mock.MagicMock() + ca.config.get_compartment_sets.return_value = { + "my_set": { + "population": "NodeA", + "compartment_set": [[0, "soma[0]", 0.5]], + } + } + + mod = ModificationCompartmentSet( + name="zero_seg", + type="compartment_set", + compartment_set="my_set", + section_configure="gbar = 0", + ) + with caplog.at_level(logging.WARNING): + _apply_compartment_set(cells, mod, ca) + assert "applied to zero segments" in caplog.text + + def test_skips_wrong_population(self): + from bluecellulab.simulation.modifications import _apply_compartment_set + + cell_id = mock.MagicMock() + cell_id.id = 0 + cell_id.population_name = "NodeB" # wrong population + cell = mock.MagicMock() + cells = {cell_id: cell} + + ca = mock.MagicMock() + ca.config.get_compartment_sets.return_value = { + "my_set": { + "population": "NodeA", + "compartment_set": [[0, "soma[0]", 0.5]], + } + } + + mod = ModificationCompartmentSet( + name="wrong_pop", + type="compartment_set", + compartment_set="my_set", + section_configure="gbar = 0", + ) + _apply_compartment_set(cells, mod, ca) + # Cell should not have been touched + cell.resolve_segments_from_compartment_set.assert_not_called() + + +class TestApplyModifications: + def test_dispatches_ttx(self): + cell_id = mock.MagicMock() + cell = _make_mock_cell() + cells = {cell_id: cell} + ca = _make_circuit_access(target_cell_ids=[cell_id]) + + mod_ttx = ModificationTTX(name="ttx", type="ttx", node_set="target") + apply_modifications(cells, [mod_ttx], ca) + cell.enable_ttx.assert_called_once() + + def test_dispatches_configure_all_sections(self): + sec = _make_mock_section("soma[0]", {"cm": 1.0}) + cell_id = mock.MagicMock() + cell = _make_mock_cell(sections={"soma[0]": sec}) + cells = {cell_id: cell} + ca = _make_circuit_access(target_cell_ids=[cell_id]) + + mod = ModificationConfigureAllSections( + name="cas", + type="configure_all_sections", + node_set="target", + section_configure="%s.cm = 5.0", + ) + apply_modifications(cells, [mod], ca) + assert sec.cm == 5.0 + + def test_dispatches_section_list(self): + sec = _make_mock_section("apic[0]", {"gbar": 1.0}) + cell_id = mock.MagicMock() + cell = _make_mock_cell( + sections={"apic[0]": sec}, + section_lists={"apical": [sec]}, + ) + cells = {cell_id: cell} + ca = _make_circuit_access(target_cell_ids=[cell_id]) + + mod = ModificationSectionList( + name="sl", + type="section_list", + node_set="target", + section_configure="apical.gbar = 0", + ) + apply_modifications(cells, [mod], ca) + assert sec.gbar == 0 + + def test_dispatches_section(self): + sec = _make_mock_section("apic[10]", {"gbar": 1.0}) + cell_id = mock.MagicMock() + cell = _make_mock_cell(sections={"apic[10]": sec}) + cell.get_section.return_value = sec + cells = {cell_id: cell} + ca = _make_circuit_access(target_cell_ids=[cell_id]) + + mod = ModificationSection( + name="sec", + type="section", + node_set="target", + section_configure="apic[10].gbar = 0", + ) + apply_modifications(cells, [mod], ca) + assert sec.gbar == 0 + + def test_dispatches_compartment_set(self): + seg = mock.MagicMock() + seg.gbar = 1.0 + section = mock.MagicMock() + section.return_value = seg + + cell_id = mock.MagicMock() + cell_id.id = 0 + cell_id.population_name = "NodeA" + cell = mock.MagicMock() + cell.resolve_segments_from_compartment_set.return_value = [ + (section, "soma[0]", 0.5) + ] + cells = {cell_id: cell} + + ca = mock.MagicMock() + ca.get_target_cell_ids.return_value = set() + ca.config.get_compartment_sets.return_value = { + "my_set": { + "population": "NodeA", + "compartment_set": [[0, "soma[0]", 0.5]], + } + } + + mod = ModificationCompartmentSet( + name="cs", + type="compartment_set", + compartment_set="my_set", + section_configure="gbar = 0.5", + ) + apply_modifications(cells, [mod], ca) + assert seg.gbar == 0.5 + + def test_unknown_type_raises(self): + mod = ModificationBase(name="bad", type="unknown") + with pytest.raises(ValueError, match="Unknown modification type"): + apply_modifications({}, [mod], mock.MagicMock()) + + +# ---- Integration test: parse modifications from simulation config ---- + +parent_dir = Path(__file__).resolve().parent.parent + +modifications_conf_path = ( + parent_dir + / "examples" + / "sim_quick_scx_sonata_multicircuit" + / "simulation_config_modifications.json" +) + + +def test_get_modifications_from_config(): + """Test that SonataSimulationConfig.get_modifications() parses correctly.""" + from bluecellulab.circuit.config import SonataSimulationConfig + + sim = SonataSimulationConfig(modifications_conf_path) + mods = sim.get_modifications() + assert len(mods) == 2 + + assert isinstance(mods[0], ModificationTTX) + assert mods[0].name == "TTX_block" + assert mods[0].node_set == "Mosaic_A" + assert mods[0].type == "ttx" + + assert isinstance(mods[1], ModificationConfigureAllSections) + assert mods[1].name == "configure_all" + assert mods[1].section_configure == "%s.cm = 2.0" diff --git a/tests/test_simulation/test_neuron_globals.py b/tests/test_simulation/test_neuron_globals.py index 80f6a902..7a7b5352 100644 --- a/tests/test_simulation/test_neuron_globals.py +++ b/tests/test_simulation/test_neuron_globals.py @@ -16,8 +16,18 @@ import pytest import neuron -from bluecellulab.circuit.config.sections import ConditionEntry, Conditions, MechanismConditions -from bluecellulab.simulation.neuron_globals import NeuronGlobalParams, NeuronGlobals, set_global_condition_parameters, set_init_depleted_values, set_minis_single_vesicle_values +from bluecellulab.circuit.config.sections import ( + ConditionEntry, + Conditions, + MechanismConditions, +) +from bluecellulab.simulation.neuron_globals import ( + NeuronGlobalParams, + NeuronGlobals, + set_global_condition_parameters, + set_init_depleted_values, + set_minis_single_vesicle_values, +) @mock.patch("neuron.h") @@ -64,6 +74,24 @@ def test_set_minis_single_vesicle_values(): assert neuron.h.minis_single_vesicle_GluSynapse == 0.0 +@mock.patch("neuron.h") +def test_set_global_condition_parameters_generic_mechanisms(mocked_h): + """Test that generic mechanisms dict applies all variables as NEURON globals.""" + # Make hasattr return True for the globals we expect + mocked_h.cao_CR_GluSynapse = 1.0 # so the extracellular_calcium path works + conditions = Conditions( + mechanisms={ + "ProbGABAAB_EMS": {"property_x": 1, "property_y": 0.25}, + "CustomMech": {"custom_var": 42.0}, + }, + ) + set_global_condition_parameters(conditions) + # Verify generic setattr calls were made for existing attributes + assert mocked_h.property_x_ProbGABAAB_EMS == 1 + assert mocked_h.property_y_ProbGABAAB_EMS == 0.25 + assert mocked_h.custom_var_CustomMech == 42.0 + + def test_neuron_globals(): """Unit test for NeuronGlobals.""" # setting temperature From fb1b8ad5839a4ea998bf91f8400b60851ecc2ef5 Mon Sep 17 00:00:00 2001 From: "@darshanmandge" Date: Sat, 14 Feb 2026 15:07:18 +0100 Subject: [PATCH 2/8] Implement SONATA condition modifications and generic mechanism handling - Add support for all 5 SONATA modification types: ttx, configure_all_sections, section_list, section, and compartment_set - Replace hardcoded MechanismConditions with generic mechanisms dict in Conditions - Parse modifications from libsonata via SonataSimulationConfig.get_modifications() - Apply modifications automatically during CircuitSimulation.instantiate_gids() - Handle empty reports dict gracefully (libsonata returns None for reports: {}) - Add 40 unit tests for modifications with 100% coverage on modifications.py - Require libsonata>=0.1.34 for snake_case modification type enums - Add example notebook demonstrating all 5 modification types --- bluecellulab/circuit/config/definition.py | 1 + bluecellulab/circuit/config/sections.py | 2 + .../config/sonata_simulation_config.py | 2 + bluecellulab/circuit_simulation.py | 29 ++++-- bluecellulab/simulation/modifications.py | 4 +- bluecellulab/simulation/neuron_globals.py | 1 + .../simulation_config_modifications.json | 13 +++ .../sonata-modifications.ipynb | 96 ++++++++++++++----- .../simulation_config_modifications.json | 18 ++++ tests/test_simulation/test_modifications.py | 17 +++- 10 files changed, 150 insertions(+), 33 deletions(-) diff --git a/bluecellulab/circuit/config/definition.py b/bluecellulab/circuit/config/definition.py index 014b0184..c5421122 100644 --- a/bluecellulab/circuit/config/definition.py +++ b/bluecellulab/circuit/config/definition.py @@ -11,6 +11,7 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. + """Module that interacts with the simulation config.""" from __future__ import annotations diff --git a/bluecellulab/circuit/config/sections.py b/bluecellulab/circuit/config/sections.py index c5afa4d6..f1489716 100644 --- a/bluecellulab/circuit/config/sections.py +++ b/bluecellulab/circuit/config/sections.py @@ -1,4 +1,5 @@ # Copyright 2023-2024 Blue Brain Project / EPFL +# Copyright 2025-2026 Open Brain Institute # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -11,6 +12,7 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. + """Classes to represent config sections.""" from __future__ import annotations diff --git a/bluecellulab/circuit/config/sonata_simulation_config.py b/bluecellulab/circuit/config/sonata_simulation_config.py index 2141b136..3a959c03 100644 --- a/bluecellulab/circuit/config/sonata_simulation_config.py +++ b/bluecellulab/circuit/config/sonata_simulation_config.py @@ -185,6 +185,8 @@ def get_report_entries(self) -> dict[str, dict]: Each key is a report name, and the value is its configuration. """ reports = self.impl.config.get("reports", {}) + if reports is None: + return {} if not isinstance(reports, dict): raise ValueError("Invalid format for 'reports' in SONATA config.") return reports diff --git a/bluecellulab/circuit_simulation.py b/bluecellulab/circuit_simulation.py index 24127d72..33196796 100644 --- a/bluecellulab/circuit_simulation.py +++ b/bluecellulab/circuit_simulation.py @@ -138,7 +138,9 @@ def __init__( self.rng_settings = RNGSettings.get_instance() self.rng_settings.set_seeds( - rng_mode, self.circuit_access.config, base_seed=base_seed + rng_mode, + self.circuit_access.config, + base_seed=base_seed, ) self.cells: CellDict = CellDict() @@ -309,7 +311,10 @@ def instantiate_gids( self._add_cells(cell_ids) self._apply_modifications() if add_synapses: - self._add_synapses(pre_gids=pre_gids, add_minis=add_minis) + self._add_synapses( + pre_gids=pre_gids, + add_minis=add_minis, + ) if add_replay or interconnect_cells or pre_spike_trains: if add_replay and not add_synapses: raise BluecellulabError( @@ -358,7 +363,8 @@ def instantiate_gids( ) configure_all_reports( - cells=self.cells, simulation_config=self.circuit_access.config + cells=self.cells, + simulation_config=self.circuit_access.config, ) # add spike recordings @@ -516,7 +522,11 @@ def _add_stimuli( def _add_synapses(self, pre_gids=None, add_minis=False): """Instantiate all the synapses.""" for cell_id in self.cells: - self._add_cell_synapses(cell_id, pre_gids=pre_gids, add_minis=add_minis) + self._add_cell_synapses( + cell_id, + pre_gids=pre_gids, + add_minis=add_minis, + ) def _add_cell_synapses( self, cell_id: CellId, pre_gids=None, add_minis=False @@ -677,7 +687,8 @@ def _add_connections( """Instantiate the (replay and real) connections in the network.""" pre_spike_trains = self.simulation_access.get_spikes() if add_replay else {} pre_spike_trains = self.merge_pre_spike_trains( - pre_spike_trains, user_pre_spike_trains + pre_spike_trains, + user_pre_spike_trains, ) connections_overrides = ( @@ -851,7 +862,9 @@ def _instantiate_synapse( int(syn_description[SynapseProperty.PRE_GID]), ) syn_connection_parameters = get_synapse_connection_parameters( - circuit_access=self.circuit_access, pre_cell=pre_cell_id, post_cell=cell_id + circuit_access=self.circuit_access, + pre_cell=pre_cell_id, + post_cell=cell_id, ) if syn_connection_parameters["add_synapse"]: condition_parameters = self.circuit_access.config.condition_parameters() @@ -1221,6 +1234,8 @@ def _register_gids_for_mpi(self) -> None: self.pc.set_gid2node(g, int(self.pc.id())) nc = cell.create_netcon_spikedetector( - None, location=self.spike_location, threshold=self.spike_threshold + None, + location=self.spike_location, + threshold=self.spike_threshold, ) self.pc.cell(g, nc) diff --git a/bluecellulab/simulation/modifications.py b/bluecellulab/simulation/modifications.py index 9d03eb8a..bfa2418c 100644 --- a/bluecellulab/simulation/modifications.py +++ b/bluecellulab/simulation/modifications.py @@ -1,4 +1,5 @@ # Copyright 2023-2024 Blue Brain Project / EPFL +# Copyright 2025-2026 Open Brain Institute # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -11,6 +12,7 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. + """Module for applying SONATA condition modifications to cells. Implements all five SONATA modification types: @@ -81,8 +83,6 @@ def parse_section_configure( ) -> tuple[str, set[str]]: """Parse a section_configure string, returning sanitized code and referenced attrs. - Follows neurodamus's ConfigureAllSections.parse_section_config() pattern. - Args: config_str: The raw section_configure string (e.g. "%s.gbar = 0"). placeholder: The placeholder to replace with 'sec' (default: "%s"). diff --git a/bluecellulab/simulation/neuron_globals.py b/bluecellulab/simulation/neuron_globals.py index 20236797..819cdb74 100644 --- a/bluecellulab/simulation/neuron_globals.py +++ b/bluecellulab/simulation/neuron_globals.py @@ -11,6 +11,7 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. + """Module that handles the global NEURON parameters.""" import logging diff --git a/examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json b/examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json index e5a1a295..781fca8a 100644 --- a/examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json +++ b/examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json @@ -29,12 +29,25 @@ "type": "section_list", "node_set": "Mosaic_A", "section_configure": "somatic.cm *= 1.5" + }, + { + "name": "set_apic0_cm", + "type": "section", + "node_set": "Mosaic_A", + "section_configure": "apic[0].cm = 5.0" + }, + { + "name": "set_compartment_cm", + "type": "compartment_set", + "compartment_set": "Mosaic_A", + "section_configure": "cm = 10.0" } ] }, "target_simulator": "NEURON", "network": "circuit_sonata.json", "node_set": "Mosaic_A", + "compartment_sets_file": "compartment_sets.json", "output": { "output_dir": "$OUTPUT_DIR", "spikes_file": "out.h5", diff --git a/examples/2-sonata-network/sonata-modifications.ipynb b/examples/2-sonata-network/sonata-modifications.ipynb index bf960420..3098ad86 100644 --- a/examples/2-sonata-network/sonata-modifications.ipynb +++ b/examples/2-sonata-network/sonata-modifications.ipynb @@ -76,7 +76,7 @@ "source": [ "## 2. Examine the simulation config with modifications\n", "\n", - "We have prepared a simulation config that includes three modifications in its `conditions` block." + "In this example, we will use a simulation config that includes five modifications (one of each type) in its `conditions` block." ] }, { @@ -97,13 +97,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The three modifications are:\n", + "The five modifications are:\n", "\n", "1. **`TTX_block_NodeB`** (`ttx`): Blocks Na channels on all cells in the `Mosaic_B` node set by inserting `TTXDynamicsSwitch`.\n", - "2. **`double_cm_all`** (`configure_all_sections`): Doubles membrane capacitance (`cm = 2.0`) on **all** sections of `Mosaic_A` cells.\n", + "2. **`double_cm_all`** (`configure_all_sections`): Sets membrane capacitance (`cm = 2.0`) on **all** sections of `Mosaic_A` cells.\n", "3. **`scale_soma_cm`** (`section_list`): Further scales `cm` by 1.5x on only the **somatic** sections of `Mosaic_A` cells.\n", + "4. **`set_apic0_cm`** (`section`): Sets `cm = 5.0` on the specific section `apic[0]` of `Mosaic_A` cells. Cells without `apic[0]` are gracefully skipped.\n", + "5. **`set_compartment_cm`** (`compartment_set`): Sets `cm = 10.0` on specific segments defined in `compartment_sets.json` (soma[0] of node 0 at x=0.5, section 2 of node 1 at x=0.3).\n", "\n", - "After both modifications, somatic sections of Mosaic_A cells will have `cm = 2.0 * 1.5 = 3.0`, while dendritic/axonal sections will have `cm = 2.0`." + "Modifications are applied in order. After all five, the expected `cm` values for NodeA cells are:\n", + "- **soma[0]** of node 0: 10.0 (set to 2.0, then ×1.5=3.0, then overwritten to 10.0 by compartment_set)\n", + "- **soma[0]** of nodes 1,2: 3.0 (set to 2.0, then ×1.5)\n", + "- **apic[0]**: 5.0 (set to 2.0, then overwritten to 5.0 by section modification)\n", + "- **other dendrites**: 2.0" ] }, { @@ -129,7 +135,9 @@ " if hasattr(mod, 'section_configure'):\n", " print(f\" section_configure: {mod.section_configure}\")\n", " if hasattr(mod, 'node_set'):\n", - " print(f\" node_set: {mod.node_set}\")" + " print(f\" node_set: {mod.node_set}\")\n", + " if hasattr(mod, 'compartment_set'):\n", + " print(f\" compartment_set: {mod.compartment_set}\")" ] }, { @@ -193,24 +201,31 @@ "outputs": [], "source": [ "print(\"=\" * 70)\n", - "print(\"Checking membrane capacitance (cm) on Mosaic_A cells\")\n", - "print(\"Expected: somatic cm=3.0 (2.0 * 1.5), dendritic cm=2.0\")\n", + "print(\"Verifying all 5 modification types on Mosaic_A cells\")\n", "print(\"=\" * 70)\n", "\n", "for cell_id in sim.cells:\n", " cell = sim.cells[cell_id]\n", + " pop = cell_id.population_name\n", + " nid = cell_id.id\n", " print(f\"\\nCell {cell_id}:\")\n", "\n", " # Check soma cm\n", - " if cell.somatic:\n", - " soma_sec = cell.somatic[0]\n", - " print(f\" soma cm = {soma_sec.cm}\")\n", - "\n", - " # Check a dendritic section cm (if available)\n", - " for sec_name, sec in list(cell.sections.items())[:5]:\n", - " if 'dend' in sec_name or 'apic' in sec_name:\n", - " print(f\" {sec_name} cm = {sec.cm}\")\n", - " break" + " soma = cell.sections.get(\"soma[0]\")\n", + " if soma:\n", + " print(f\" soma[0] cm = {soma.cm}\")\n", + "\n", + " # Check apic[0] cm (section modification)\n", + " apic0 = cell.sections.get(\"apic[0]\")\n", + " if apic0:\n", + " print(f\" apic[0] cm = {apic0.cm}\")\n", + " elif pop == \"NodeA\":\n", + " print(f\" apic[0]: not present (section mod was skipped)\")\n", + "\n", + " # Check a dendritic section cm\n", + " dend0 = cell.sections.get(\"dend[0]\")\n", + " if dend0:\n", + " print(f\" dend[0] cm = {dend0.cm}\")" ] }, { @@ -264,8 +279,32 @@ "metadata": {}, "outputs": [], "source": [ - "# Plot comparison\n", - "fig, axes = plt.subplots(len(sim.cells), 1, figsize=(12, 3 * len(sim.cells)), sharex=True)\n", + "# Build a per-cell summary of which modifications were applied\n", + "# (based on the config's node_set / compartment_set targeting)\n", + "mod_descriptions = {\n", + " \"TTX_block_NodeB\": (\"ttx\", \"Mosaic_B\", \"block Na channels\"),\n", + " \"double_cm_all\": (\"configure_all_sections\", \"Mosaic_A\", \"cm=2.0 on all sections\"),\n", + " \"scale_soma_cm\": (\"section_list\", \"Mosaic_A\", \"somatic cm *= 1.5\"),\n", + " \"set_apic0_cm\": (\"section\", \"Mosaic_A\", \"apic[0].cm = 5.0\"),\n", + " \"set_compartment_cm\": (\"compartment_set\", \"Mosaic_A\", \"cm=10.0 on compartment set segments\"),\n", + "}\n", + "\n", + "# Map population names to the node_set they belong to\n", + "pop_to_nodeset = {\"NodeA\": \"Mosaic_A\", \"NodeB\": \"Mosaic_B\"}\n", + "\n", + "def get_mods_for_cell(cell_id):\n", + " \"\"\"Return a list of short modification descriptions for a given cell.\"\"\"\n", + " nodeset = pop_to_nodeset.get(cell_id.population_name, \"\")\n", + " labels = []\n", + " for mod_name, (mod_type, target, desc) in mod_descriptions.items():\n", + " if target == nodeset:\n", + " labels.append(f\"{mod_name} ({mod_type}): {desc}\")\n", + " if not labels:\n", + " labels.append(\"none\")\n", + " return labels\n", + "\n", + "# Plot comparison with per-cell modification labels\n", + "fig, axes = plt.subplots(len(sim.cells), 1, figsize=(12, 4 * len(sim.cells)), sharex=True)\n", "if len(sim.cells) == 1:\n", " axes = [axes]\n", "\n", @@ -277,12 +316,17 @@ " ax.plot(traces_with_mods[cell_id][\"time\"], traces_with_mods[cell_id][\"voltage\"],\n", " label=\"with modifications\", alpha=0.8, linestyle=\"--\")\n", " ax.set_ylabel(\"Voltage (mV)\")\n", - " ax.set_title(str(cell_id))\n", + "\n", + " # Build a descriptive title showing which modifications apply\n", + " mods_list = get_mods_for_cell(cell_id)\n", + " mods_text = \"\\n\".join(f\" • {m}\" for m in mods_list)\n", + " ax.set_title(f\"{cell_id}\\nApplied modifications:\\n{mods_text}\",\n", + " fontsize=10, loc=\"left\", pad=10)\n", " ax.legend(loc=\"upper right\")\n", "\n", "axes[-1].set_xlabel(\"Time (ms)\")\n", "plt.tight_layout()\n", - "plt.savefig(\"ex2_modifications_comparison.pdf\")\n", + "# plt.savefig(\"ex2_modifications_comparison.pdf\")\n", "plt.show()" ] }, @@ -320,13 +364,21 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": ".venv", "language": "python", "name": "python3" }, "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", "name": "python", - "version": "3.12.0" + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.12" } }, "nbformat": 4, diff --git a/tests/examples/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json b/tests/examples/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json index 08196b71..77e7257b 100644 --- a/tests/examples/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json +++ b/tests/examples/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json @@ -21,6 +21,24 @@ "type": "configure_all_sections", "node_set": "Mosaic_A", "section_configure": "%s.cm = 2.0" + }, + { + "name": "scale_soma", + "type": "section_list", + "node_set": "Mosaic_A", + "section_configure": "somatic.cm *= 1.5" + }, + { + "name": "set_dend0", + "type": "section", + "node_set": "Mosaic_A", + "section_configure": "dend[0].cm = 5.0" + }, + { + "name": "set_compartment", + "type": "compartment_set", + "compartment_set": "Mosaic_A", + "section_configure": "cm = 10.0" } ] }, diff --git a/tests/test_simulation/test_modifications.py b/tests/test_simulation/test_modifications.py index 287ad47b..4d0620f3 100644 --- a/tests/test_simulation/test_modifications.py +++ b/tests/test_simulation/test_modifications.py @@ -719,12 +719,12 @@ def test_unknown_type_raises(self): def test_get_modifications_from_config(): - """Test that SonataSimulationConfig.get_modifications() parses correctly.""" + """Test that SonataSimulationConfig.get_modifications() parses all 5 types.""" from bluecellulab.circuit.config import SonataSimulationConfig sim = SonataSimulationConfig(modifications_conf_path) mods = sim.get_modifications() - assert len(mods) == 2 + assert len(mods) == 5 assert isinstance(mods[0], ModificationTTX) assert mods[0].name == "TTX_block" @@ -734,3 +734,16 @@ def test_get_modifications_from_config(): assert isinstance(mods[1], ModificationConfigureAllSections) assert mods[1].name == "configure_all" assert mods[1].section_configure == "%s.cm = 2.0" + + assert isinstance(mods[2], ModificationSectionList) + assert mods[2].name == "scale_soma" + assert mods[2].section_configure == "somatic.cm *= 1.5" + + assert isinstance(mods[3], ModificationSection) + assert mods[3].name == "set_dend0" + assert mods[3].section_configure == "dend[0].cm = 5.0" + + assert isinstance(mods[4], ModificationCompartmentSet) + assert mods[4].name == "set_compartment" + assert mods[4].compartment_set == "Mosaic_A" + assert mods[4].section_configure == "cm = 10.0" From 75772be0e3084677d98c75394ecb4e6075b4f0d4 Mon Sep 17 00:00:00 2001 From: "@darshanmandge" Date: Tue, 17 Feb 2026 17:59:41 +0100 Subject: [PATCH 3/8] fix typos, lint and type-checking issues --- .gitignore | 3 +- .../config/bluepy_simulation_config.py | 4 + bluecellulab/circuit/config/definition.py | 1 - bluecellulab/circuit/config/sections.py | 4 +- bluecellulab/circuit_simulation.py | 24 +-- bluecellulab/simulation/modifications.py | 15 +- bluecellulab/simulation/neuron_globals.py | 1 - .../sonata-modifications.ipynb | 200 +++++++++++++++--- tests/test_simulation/test_modifications.py | 2 +- 9 files changed, 203 insertions(+), 51 deletions(-) diff --git a/.gitignore b/.gitignore index aabbe01f..4a608a3d 100644 --- a/.gitignore +++ b/.gitignore @@ -30,4 +30,5 @@ nrnivmodl.log cADpyr_L2TPC_dendrogram.png ex2_sonatagraph.pdf .venv -bad_dendritic_fit.png \ No newline at end of file +bad_dendritic_fit.png +/build \ No newline at end of file diff --git a/bluecellulab/circuit/config/bluepy_simulation_config.py b/bluecellulab/circuit/config/bluepy_simulation_config.py index ae05058c..81a74414 100644 --- a/bluecellulab/circuit/config/bluepy_simulation_config.py +++ b/bluecellulab/circuit/config/bluepy_simulation_config.py @@ -204,6 +204,10 @@ def add_connection_override( ) -> None: self._connection_overrides.append(connection_override) + def get_modifications(self) -> list: + """Bluepy configs do not support modifications.""" + return [] + def get_compartment_sets(self) -> dict[str, dict[str, Any]]: """Bluepy configs do not support compartment_sets.""" raise NotImplementedError("Compartment sets are only supported for SonataSimulationConfig.") diff --git a/bluecellulab/circuit/config/definition.py b/bluecellulab/circuit/config/definition.py index c5421122..014b0184 100644 --- a/bluecellulab/circuit/config/definition.py +++ b/bluecellulab/circuit/config/definition.py @@ -11,7 +11,6 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. - """Module that interacts with the simulation config.""" from __future__ import annotations diff --git a/bluecellulab/circuit/config/sections.py b/bluecellulab/circuit/config/sections.py index f1489716..6e99b3a7 100644 --- a/bluecellulab/circuit/config/sections.py +++ b/bluecellulab/circuit/config/sections.py @@ -12,7 +12,6 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. - """Classes to represent config sections.""" from __future__ import annotations @@ -163,7 +162,8 @@ class ModificationNodeSet(ModificationBase): @dataclass(frozen=True, config=dict(extra="forbid")) class ModificationTTX(ModificationNodeSet): - """TTX modification — blocks Na channels on all sections of target cells.""" + """TTX modification — blocks Na channels on all sections of target + cells.""" pass diff --git a/bluecellulab/circuit_simulation.py b/bluecellulab/circuit_simulation.py index 33196796..284bf830 100644 --- a/bluecellulab/circuit_simulation.py +++ b/bluecellulab/circuit_simulation.py @@ -273,23 +273,22 @@ def instantiate_gids( else: pre_gids = None - # if pre_spike_trains take int as key then convert to CellId + normalized_pre_spike_trains: dict[CellId, Iterable] | None = None if pre_spike_trains is not None: - if not isinstance(next(iter(pre_spike_trains.keys())), tuple): - pre_spike_trains = { - create_cell_id(gid): pre_spike_trains[gid] # type: ignore - for gid in pre_spike_trains - } + normalized_pre_spike_trains = { + create_cell_id(gid): spikes + for gid, spikes in pre_spike_trains.items() + } if self.gids_instantiated: raise BluecellulabError( "instantiate_gids() is called twice on the " - "same CircuitSimumation, this is not supported" + "same CircuitSimulation, this is not supported" ) else: self.gids_instantiated = True - if pre_spike_trains or add_replay: + if normalized_pre_spike_trains or add_replay: if add_synapses is False: raise BluecellulabError( "You need to set add_synapses to True " @@ -315,7 +314,7 @@ def instantiate_gids( pre_gids=pre_gids, add_minis=add_minis, ) - if add_replay or interconnect_cells or pre_spike_trains: + if add_replay or interconnect_cells or normalized_pre_spike_trains: if add_replay and not add_synapses: raise BluecellulabError( "add_replay option can not be used if add_synapses is False" @@ -329,8 +328,8 @@ def instantiate_gids( self._add_connections( add_replay=add_replay, interconnect_cells=interconnect_cells, - user_pre_spike_trains=pre_spike_trains, - ) # type: ignore + user_pre_spike_trains=normalized_pre_spike_trains, + ) if add_stimuli: add_noise_stimuli = True add_hyperpolarizing_stimuli = True @@ -839,7 +838,8 @@ def _add_cells(self, cell_ids: list[CellId]) -> None: cell.connect_to_circuit(SonataProxy(cell_id, self.circuit_access)) def _apply_modifications(self) -> None: - """Apply condition modifications from the simulation config to cells.""" + """Apply condition modifications from the simulation config to + cells.""" try: modifications = self.circuit_access.config.get_modifications() except (NotImplementedError, AttributeError): diff --git a/bluecellulab/simulation/modifications.py b/bluecellulab/simulation/modifications.py index bfa2418c..3856bf16 100644 --- a/bluecellulab/simulation/modifications.py +++ b/bluecellulab/simulation/modifications.py @@ -12,7 +12,6 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. - """Module for applying SONATA condition modifications to cells. Implements all five SONATA modification types: @@ -57,7 +56,8 @@ class _AttributeCollector(ast.NodeVisitor): - """AST visitor that collects all attribute names referenced in an expression.""" + """AST visitor that collects all attribute names referenced in an + expression.""" def __init__(self): self.attrs: set[str] = set() @@ -68,7 +68,8 @@ def visit_Attribute(self, node): def _validate_assignment(node) -> list: - """Return assignment targets from an AST node, raising on non-assignments.""" + """Return assignment targets from an AST node, raising on non- + assignments.""" if isinstance(node, ast.Assign): return node.targets if isinstance(node, ast.AugAssign): @@ -81,7 +82,8 @@ def _validate_assignment(node) -> list: def parse_section_configure( config_str: str, placeholder: str = "%s" ) -> tuple[str, set[str]]: - """Parse a section_configure string, returning sanitized code and referenced attrs. + """Parse a section_configure string, returning sanitized code and + referenced attrs. Args: config_str: The raw section_configure string (e.g. "%s.gbar = 0"). @@ -101,7 +103,7 @@ def parse_section_configure( for elem in tree.body: targets = _validate_assignment(elem) for tgt in targets: - if not isinstance(tgt, ast.Attribute) or tgt.value.id != "__sec_wildcard__": + if not isinstance(tgt, ast.Attribute) or not isinstance(tgt.value, ast.Name) or tgt.value.id != "__sec_wildcard__": raise ValueError( "section_configure only supports single assignments " f"of attributes of the section wildcard {placeholder}" @@ -176,7 +178,8 @@ def _apply_ttx(cells: dict, mod: ModificationTTX, circuit_access) -> None: def _apply_configure_all_sections( cells: dict, mod: ModificationConfigureAllSections, circuit_access ) -> None: - """Apply configure_all_sections — exec section_configure on all sections.""" + """Apply configure_all_sections — exec section_configure on all + sections.""" logger.info( "Applying modification '%s' (type=configure_all_sections) to node_set '%s'", mod.name, diff --git a/bluecellulab/simulation/neuron_globals.py b/bluecellulab/simulation/neuron_globals.py index 819cdb74..20236797 100644 --- a/bluecellulab/simulation/neuron_globals.py +++ b/bluecellulab/simulation/neuron_globals.py @@ -11,7 +11,6 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. - """Module that handles the global NEURON parameters.""" import logging diff --git a/examples/2-sonata-network/sonata-modifications.ipynb b/examples/2-sonata-network/sonata-modifications.ipynb index 3098ad86..47b9e56e 100644 --- a/examples/2-sonata-network/sonata-modifications.ipynb +++ b/examples/2-sonata-network/sonata-modifications.ipynb @@ -33,16 +33,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/usr/bin/xcrun\n", + "/Users/mandge/Desktop/obi/repos/BlueCelluLab/examples/2-sonata-network\n", + "Mod files: \"../mechanisms/../mechanisms/Ca.mod\" \"../mechanisms/../mechanisms/CaDynamics_DC0.mod\" \"../mechanisms/../mechanisms/CaDynamics_E2.mod\" \"../mechanisms/../mechanisms/Ca_HVA.mod\" \"../mechanisms/../mechanisms/Ca_HVA2.mod\" \"../mechanisms/../mechanisms/Ca_LVAst.mod\" \"../mechanisms/../mechanisms/DetAMPANMDA.mod\" \"../mechanisms/../mechanisms/DetGABAAB.mod\" \"../mechanisms/../mechanisms/GluSynapse.mod\" \"../mechanisms/../mechanisms/Ih.mod\" \"../mechanisms/../mechanisms/Im.mod\" \"../mechanisms/../mechanisms/K_Pst.mod\" \"../mechanisms/../mechanisms/K_Tst.mod\" \"../mechanisms/../mechanisms/KdShu2007.mod\" \"../mechanisms/../mechanisms/NaTa_t.mod\" \"../mechanisms/../mechanisms/NaTg.mod\" \"../mechanisms/../mechanisms/NaTs2_t.mod\" \"../mechanisms/../mechanisms/Nap_Et2.mod\" \"../mechanisms/../mechanisms/ProbAMPANMDA_EMS.mod\" \"../mechanisms/../mechanisms/ProbGABAAB_EMS.mod\" \"../mechanisms/../mechanisms/SK_E2.mod\" \"../mechanisms/../mechanisms/SKv3_1.mod\" \"../mechanisms/../mechanisms/StochKv.mod\" \"../mechanisms/../mechanisms/StochKv3.mod\" \"../mechanisms/../mechanisms/TTXDynamicsSwitch.mod\" \"../mechanisms/../mechanisms/VecStim.mod\" \"../mechanisms/../mechanisms/gap.mod\" \"../mechanisms/../mechanisms/netstim_inhpoisson.mod\"\n", + "\n", + " -> \u001b[32mCompiling\u001b[0m mod_func.cpp\n", + " => \u001b[32mLINKING\u001b[0m shared library ./libnrnmech.dylib\n", + "Successfully created arm64/special\n" + ] + } + ], "source": [ "!nrnivmodl ../mechanisms" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -61,7 +75,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -81,9 +95,50 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " \"v_init\": -65,\n", + " \"modifications\": [\n", + " {\n", + " \"name\": \"TTX_block_NodeB\",\n", + " \"type\": \"ttx\",\n", + " \"node_set\": \"Mosaic_B\"\n", + " },\n", + " {\n", + " \"name\": \"double_cm_all\",\n", + " \"type\": \"configure_all_sections\",\n", + " \"node_set\": \"Mosaic_A\",\n", + " \"section_configure\": \"%s.cm = 2.0\"\n", + " },\n", + " {\n", + " \"name\": \"scale_soma_cm\",\n", + " \"type\": \"section_list\",\n", + " \"node_set\": \"Mosaic_A\",\n", + " \"section_configure\": \"somatic.cm *= 1.5\"\n", + " },\n", + " {\n", + " \"name\": \"set_apic0_cm\",\n", + " \"type\": \"section\",\n", + " \"node_set\": \"Mosaic_A\",\n", + " \"section_configure\": \"apic[0].cm = 5.0\"\n", + " },\n", + " {\n", + " \"name\": \"set_compartment_cm\",\n", + " \"type\": \"compartment_set\",\n", + " \"compartment_set\": \"Mosaic_A\",\n", + " \"section_configure\": \"cm = 10.0\"\n", + " }\n", + " ]\n", + "}\n" + ] + } + ], "source": [ "sim_config_path = Path(\"sim_quick_scx_sonata_multicircuit\") / \"simulation_config_modifications.json\"\n", "\n", @@ -123,21 +178,42 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TTX_block_NodeB: type=ttx, class=ModificationTTX\n", + "node_set: Mosaic_B\n", + "double_cm_all: type=configure_all_sections, class=ModificationConfigureAllSections\n", + "section_configure: %s.cm = 2.0\n", + "node_set: Mosaic_A\n", + "scale_soma_cm: type=section_list, class=ModificationSectionList\n", + "section_configure: somatic.cm *= 1.5\n", + "node_set: Mosaic_A\n", + "set_apic0_cm: type=section, class=ModificationSection\n", + "section_configure: apic[0].cm = 5.0\n", + "node_set: Mosaic_A\n", + "set_compartment_cm: type=compartment_set, class=ModificationCompartmentSet\n", + "section_configure: cm = 10.0\n", + "compartment_set: Mosaic_A\n" + ] + } + ], "source": [ "sonata_config = SonataSimulationConfig(sim_config_path)\n", "modifications = sonata_config.get_modifications()\n", "\n", "for mod in modifications:\n", - " print(f\" {mod.name}: type={mod.type}, class={type(mod).__name__}\")\n", + " print(f\"{mod.name}: type={mod.type}, class={type(mod).__name__}\")\n", " if hasattr(mod, 'section_configure'):\n", - " print(f\" section_configure: {mod.section_configure}\")\n", + " print(f\"section_configure: {mod.section_configure}\")\n", " if hasattr(mod, 'node_set'):\n", - " print(f\" node_set: {mod.node_set}\")\n", + " print(f\"node_set: {mod.node_set}\")\n", " if hasattr(mod, 'compartment_set'):\n", - " print(f\" compartment_set: {mod.compartment_set}\")" + " print(f\"compartment_set: {mod.compartment_set}\")" ] }, { @@ -153,7 +229,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -162,9 +238,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All cells in circuit: [('NodeA', 0), ('NodeA', 1), ('NodeA', 2), ('NodeB', 0), ('NodeB', 1)]\n" + ] + } + ], "source": [ "from bluepysnap import Simulation as snap_sim\n", "import pandas as pd\n", @@ -177,9 +261,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:bluecellulab.simulation.modifications:Applying modification 'TTX_block_NodeB' (type=ttx) to node_set 'Mosaic_B'\n", + "INFO:bluecellulab.simulation.modifications:Modification 'TTX_block_NodeB' (ttx): enabled on 2 cells\n", + "INFO:bluecellulab.simulation.modifications:Applying modification 'double_cm_all' (type=configure_all_sections) to node_set 'Mosaic_A'\n", + "INFO:bluecellulab.simulation.modifications:Modification 'double_cm_all' applied to 269 sections across 3 cells\n", + "INFO:bluecellulab.simulation.modifications:Applying modification 'scale_soma_cm' (type=section_list) to node_set 'Mosaic_A'\n", + "INFO:bluecellulab.simulation.modifications:Modification 'scale_soma_cm' applied to 3 sections across 3 cells\n", + "INFO:bluecellulab.simulation.modifications:Applying modification 'set_apic0_cm' (type=section) to node_set 'Mosaic_A'\n", + "WARNING:bluecellulab.simulation.modifications:section 'set_apic0_cm': cell CellId(population_name='NodeA', id=1) does not have section 'apic[0]', skipping\n", + "INFO:bluecellulab.simulation.modifications:Modification 'set_apic0_cm' applied to 2 sections across 2 cells\n", + "INFO:bluecellulab.simulation.modifications:Applying modification 'set_compartment_cm' (type=compartment_set) to compartment_set 'Mosaic_A'\n", + "INFO:bluecellulab.simulation.modifications:Modification 'set_compartment_cm' applied to 2 segments across 2 cells\n" + ] + } + ], "source": [ "# Instantiate all cells — modifications are applied automatically\n", "sim.instantiate_gids(all_cell_ids, add_stimuli=False, add_synapses=False)" @@ -196,9 +298,42 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "======================================================================\n", + "Verifying all 5 modification types on Mosaic_A cells\n", + "======================================================================\n", + "\n", + "Cell CellId(population_name='NodeA', id=0):\n", + "soma[0] cm = {soma.cm}\n", + "apic[0] cm = {apic0.cm}\n", + "dend[0] cm = {dend0.cm}\n", + "\n", + "Cell CellId(population_name='NodeA', id=1):\n", + "soma[0] cm = {soma.cm}\n", + "apic[0]: not present (section mod was skipped)\n", + "dend[0] cm = {dend0.cm}\n", + "\n", + "Cell CellId(population_name='NodeA', id=2):\n", + "soma[0] cm = {soma.cm}\n", + "apic[0] cm = {apic0.cm}\n", + "dend[0] cm = {dend0.cm}\n", + "\n", + "Cell CellId(population_name='NodeB', id=0):\n", + "soma[0] cm = {soma.cm}\n", + "dend[0] cm = {dend0.cm}\n", + "\n", + "Cell CellId(population_name='NodeB', id=1):\n", + "soma[0] cm = {soma.cm}\n", + "dend[0] cm = {dend0.cm}\n" + ] + } + ], "source": [ "print(\"=\" * 70)\n", "print(\"Verifying all 5 modification types on Mosaic_A cells\")\n", @@ -213,19 +348,19 @@ " # Check soma cm\n", " soma = cell.sections.get(\"soma[0]\")\n", " if soma:\n", - " print(f\" soma[0] cm = {soma.cm}\")\n", + " print(\"soma[0] cm = {soma.cm}\")\n", "\n", " # Check apic[0] cm (section modification)\n", " apic0 = cell.sections.get(\"apic[0]\")\n", " if apic0:\n", - " print(f\" apic[0] cm = {apic0.cm}\")\n", + " print(\"apic[0] cm = {apic0.cm}\")\n", " elif pop == \"NodeA\":\n", - " print(f\" apic[0]: not present (section mod was skipped)\")\n", + " print(\"apic[0]: not present (section mod was skipped)\")\n", "\n", " # Check a dendritic section cm\n", " dend0 = cell.sections.get(\"dend[0]\")\n", " if dend0:\n", - " print(f\" dend[0] cm = {dend0.cm}\")" + " print(\"dend[0] cm = {dend0.cm}\")" ] }, { @@ -240,7 +375,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -256,7 +391,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -275,9 +410,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAfFCAYAAABAoX+MAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3QWYVOXbBvB7i1q6YenuVDqkS0IQEIM/GIgKKqA0AgIWZaCiIKggKI0oIqVId3d39xILuzvfdb/znWF2mO3evX/XNddOnvOe95wZPQ/P8xwPm81mg4iIiIiIiIiISBzyjMuViYiIiIiIiIiIkIJSIiIiIiIiIiIS5xSUEhERERERERGROKeglIiIiIiIiIiIxDkFpUREREREREREJM4pKCUiIiIiIiIiInFOQSkREREREREREYlzCkqJiIiIiIiIiEicU1BKRERERERERETinIJSkXTz5k188sknqF+/PsqXL49mzZrhxx9/RHBwcIQ+v3HjRhQvXtzcP3PmjLnPv9S/f39zC42713/77TeMHz8e8cl1O8Kzfv16HD161NyfN2+emUt55KuvvnLMCe+XKVMGhw8ffmyK+B7OX1Q4H4eRweOPnzt16lSI5zmOiC7vpZdeMtsVGi6H44sofv9q166NihUrYuDAgbh37555/sGDB3jmmWdw9erVCC9LRERERERE4o6CUpFw/fp1tG/fHnv27MGoUaPwxx9/oGfPnvjuu+/M4/gYD9f9yiuvIDHp0qULrly5Yu43b94cc+bMie8hJSgeHh4hHj98+BDDhw9HfAsICMCyZcuQL18+LFiwIMwxh4UBqZdffjlGxvT3339jwoQJ+PDDD/HTTz9h586dGD16tHktRYoUePHFFx2PRUREREREJGFRUCoSxo4da050f/jhB1SvXh158+Y1QRUGpH755RccP34ccYnrrFWrFtKnT4/EKlWqVMicOXN8DyNB4Xxky5bN8ThHjhzYvn37Y4GguLZq1Sr4+Pjg+eefN2Ox2WyhjjksGTNmhK+vb4yM6eeff8b//vc/1KtXD+XKlTPBu7lz5zqypVq2bImVK1fi7NmzMbI+ERERERERiTkKSkUQS4H+/PNPvPDCC0iZMmWI13hCzBIiPz8/8/jWrVt4//33UalSJRM0GjFiBO7fvx/pnbNlyxa0adPGnGy/8847jhNtYrkgS/caNmwYopyL4+CJeIUKFdCtWzdcvnzZ8TpL5phVxXGx3IkZJlbZIbNXevXqhQEDBpiyxCZNmmDFihWhloqFVf515MgRsx6WU5UtW9YEMaxyPassrXPnzmadruV74Y2xT58+GDp0qHmdgcFJkyZFeD453oULF+Lpp582JXEc1+nTpx2vc3s53xzzE088gd69e+POnTuOdfft29fsS24Xx7xmzRpMnz4dNWrUQLVq1UyAxBLWMWCVurm7sQSyYMGCKFSokGNZ+fPnNxk/n332mVluaLhclpPyeGnbti02b97seM3f399sD8fOfbt79+4Qnz1//jy6d+9u9j23jfMeFBQU4j3MDOS88HhnkMd5+Rwzb1Ep3+O6uC+rVq2K2bNnP7bP3N34eY6P28ExWXjcM7PswIED5jGDyNw//K6IiIiIiIhIwqKgVASxh87du3dNwMIVS5cYlOAJMA0aNAi3b9/GzJkz8c0335gTZ5YXRca1a9fw+uuvmxNqZqUUKVIES5Yscbx+6NAh8x6u1xlP1l999VVzEs4gFssLreUxCJM9e3Zz4s/ADgMqzoEUlmYx+4XBjXbt2uHtt982AabIYACJwQ0G6BgA+vXXX03wwCqhskr13JVwRWSMLNdiUHD+/PkmeDVmzJhIZahxvdw/3EaWP37++eeO/cvAH9f/119/mefXrVuHWbNmOT67ePFipEuXzmwXAz/vvvuuCUxNmzbNBFo+/fRTsw3hHQPMruPn3N1y5cplAjQff/xxiHFzP3p7e5tsPXe4PQx88Zjh8cLjhkHJixcvmtc5l8eOHTPzOXjwYEydOtXxWe7zHj16IEuWLGZeue5FixZh4sSJjvcwOMdMKQakChQogMKFC5v3WljSx3mILB6n3L8fffSRCagyy8lZaPPEY4cBOpYU8nixcI6YiXXhwgXHczVr1sTq1asjPTYRERERERGJXQpKRZCVocKgRFgY3Fi+fLkJwjCjg8ELBgt4As8gRUQxMMKSKGbbMGuGQQnngNjevXuRJ08eRyDMwmBS69atzbp5os+yLwawmOWSOnVqMxYGFJhhxSDM5MmTHZ/NkCGDCZzwdQY0mFXjGiQID7OBnnvuOdMQm4GK0qVLm2bTVnDLKtXjulxLuCIyRgYc+vXrZ7KHGHzjY/b4iqiuXbuaoE+xYsXQqVMnx2cZTGOwpkOHDmZemd3EwI5zg/FMmTKZ8XC7uE3cnww+cawMkAUGBuLkyZPhHgMsWWSpm7ubl5eX23GnTZvWZLExSLZr167HXrcCY8z04vHy3nvvmW1kEIrr5PHE7eP+YAbam2++6fjshg0bcO7cOTNGfpYZS5xj52Agt4cZSAxKUaNGjUyA0Dl7Lyq4PVb5XcmSJTFy5MgQr4c2Tzx2rMwz1+8AHzOz0cL9w8wp18wvERERERERiV/e8bz+RIPBD+vqe2Fh+RkDHHXq1AnxPJ9jwCKiGMQpUaJEiAbSDEpZQQBm5DBI4orlYhb2vOK4OSbeGJBgJomFQSeW91kBN5a0OZ/g87FVdhdRadKkMcEeZusw4MPsnH379iFr1qzhfjYiY2TAyDlww+AEg0ERxWCWc6CHgRZi9g+3/dtvvzWBKN64Dxjgs3Dd1v5gYImskk3rMYMh4R0DnBNmLrnDEtHcuXO7fY2lecw0GzZs2GNlblznW2+9FeI5lrLxeWaSMSDD48niHODke27cuIHKlSuHGCuDPswm43HGcfHYsoKKjRs3NplUS5cuDTFHkeU6bmYE8hhy3v/uMCOMAURyDkBZjxnctPA7wO3hNjIbTERERERERBIGBaUiiNkxzJJihhIzX1y98cYbJlOFJ/98n7sMIzas5tXBIsq5kTSxybQVlGJwxF3mh3NAh/geT0/Px/pgkdWryVpOaJ91J7SsE5Z5PfvssyaQwd5E7N/EIMyUKVPC2VpEaIycg/DmKSzuPk/MpGEwjWNmjyJeIZBXc3PmOj/kbn7COwYYAGPvJnecS9Hc+eCDD0zPsBkzZoQ7dxyHNX+unIOPDOoxQ4plhq64HQxMsZSR7ytVqlSI1xl8jE5Qyt3+c57n0Jq7M9OODf653bySI7OhrG1h8Mm56bq1/MhcIVBERERERERin8r3IognyuwFxCveuWZm8OpevDGgwGbPLJfiCTCzcnhjxgmbVLt+LixFixY1GUbOwZ/9+/c77jPziCffrqwGz8SsHI6FJWQcFwNqVmYQsbSPmS9WFtjBgwdDBDGY6WQ1M2cwx2r6Tc4Nwp1t2rQJly5dMqVfLK9jCRxLwyISOIrIGGML+0Q9+eSTpmcT+0ox8Mj5i0zAyxLeMcAMLet515u7wJczvoellV988YVpXu68TteAJx9bTdO5/5ybm/PYcv4s9xHn2RoHG65/+eWXZhuYDcXjgsc+g0TWjX2dWPrn3L8psnicO4+L63Vu5h7aPPF4YECQGV9bt251vH/Hjh1mDp2zwhhU43PuMgtFREREREQk/igoFQns68RAAPsHMfjC3kEso2L/JF5NjqVHzNhgzx729GHvHwZZ2AuITdKZ2RFRLVq0MFlRo0aNMplG7KvkfPLN/js8gXcOFBGDQbyKHINTAwcONE2emZnD7BoGRJhpw5Ip9ghi029mB1kZJAw0sQ8S18cyNo6dWU/Ek3+WjrE/Fa+8F1rmE4MF3FYun+Pj/LgG8liexfI41x5bERljbOG4GZTjPmO52yeffGKCJZEJJFpi6hgIDYNSDCA5l5Iys4v9oxgs4vjZAJ7HAPcfg2DMZmLPKAaquP94xTsL+2exDJH9yzgHvOrjkCFDTAkcSyXZ64vbw/I+9qmyblwnA0MM6DljIJUllxGZO15VkMcs+1Px2GKPrtCy89xhAPGHH34wxwrnmqWNLOtzLt/jNvH7okwpERERERGRhEVBqUhgSRCvpsZeTQw4sDSNJV68Sh0DUxZmxLD/EE/a2VibmSjjxo2L1I5heRIDUQyMMKDA8innMilmMHE8zCRyxgbcXBcDOXx9/Pjx5nkGJrg8BtLYDJsBCjaY5lXXLCwpY68qvs7G2N9//73ZVuKV5hhQadu2rQmUseG3O+wBxB5Bw4cPR6tWrcxV4Rhkunr1quNKcCxz5Bwx4OQsImOMLRwTezBxnzHQwcwhbodzRlFkxMQxEBqW3nFOnTGLr1evXia7ifPOoCkDh1ZZG4NM3DccC49VBoMsDDwxCMlsKAZ0GHytW7euaYzOfcYglRWcdC1FbNCgQYir8NH58+dNoMv12HSHxzS/P9zXnHcGUSMbvGV/Kc4HM7eY4cbgmjMGc137e4mIiIiIiEj887BFpT5JEgQGdRg8+fjjj81j9kNiAIeBo6gsi4EMXsVNJLoYHGMgiIG++MTsNI6DGWQMEoqIiIiIiEjCoUypROyFF17A2rVr3faWEokvLHFdv379Y03R48OiRYvw1FNPKSAlIiIiIiKSAOnqe4kY+wp1797dlGn17t0byRmzw9hLKTSTJk0yV9WT2McyTPaJCu1Kh3GFPa3Yz4w9p0RERERERCThUfmeJAksY3S+ap+7/kepUqWK0zGJiIiIiIiISOgUlBIRERERERERkTinnlJRxKvK8Qp4s2fPjrGdwauiWVfxY+NxXhEuqji2jRs3Iq6dOXPGrJt/Xcdx8uRJc7W1smXL4vPPPzeN2TmP0bV//35s27bN3Oe6uE4RERERERERSdgUlIqiP//8E/ny5cPChQsRG3h5ewamErs1a9agYsWK5v706dMdc9e1a1fMmTMHzZs3j/Y63nrrLZw4ccLc57q4ThERERERERFJ2BSUioKrV6+aq4sxGLJlyxacPn06xneMr68vMmbMiMQuW7ZsSJEiheOqbCVKlDDBvAwZMphG7THd54nr4jpFREREREREJGFTUCoKlixZgnTp0qFVq1bInj17iGwplqT9+OOPaNmyJSpUqIBu3brh8uXLjtKyOnXqmCuTVa1aFTVq1MC3337rdh2u5XsMfvEKc+XKlTPL/vvvv0O8f8KECahevbpZbnglhSxv++uvv9CsWTOUL1/eXLmPgbXOnTubx88//zwuXrzoeP8///yDZ555xqybmU1Lly51vMbm4iNGjDBXtuO2rVq16rF1cbtZlshSvQULFjjK+5zL9wIDAzFu3DjUqlULlStXxttvv43r16+b1zgWPn7yySdRpkwZM5atW7ea1zhHZ8+exYABA8w6XMv3Lly4gHfeeQdVqlQxczNy5EhzVTbiuvn5L7/80rzGbfj4449hs9kczdOZscbsK84tt9Nqpm6Vb4qIiIiIiIhI1CgoFQUsP3vqqafg6elpAisMtFiBDCug9Oqrr+K3337DvXv30LNnzxBZVnz/lClT8OGHH2Ly5MmYNWtWmOtjUOv11183QalFixaZZTMAw0AVcT0MdH300UcmIDZ37txwt4GBmE8++QTfffedCTJ16tTJ3H799VezvkmTJpn3MSOM42cvKAbf2rdvj169emHPnj2ObWXQisG1L774wozDnUGDBpkgGG8sr8uVK1eI1/nZ+fPnm23g9nCehg4dal577733EBQUZMbGueOV9IYNG+ZYf86cOTFw4ECzDmcMPv3vf/8z+2DatGmmj9W///6Lzz77zPGe7du34/jx45g5cyaGDBlixr9u3TrzGoNQadKkMev8+uuvTSDQ2lcMzqlMUERERERERCTqFJSKpPPnz5um2g0bNjSPGzdubLKMrMwdateunQniMJOGQRYGPg4dOuTICOJzpUuXNstg0ITBlrD88ssvJqvqxRdfRP78+c2yO3bsiJ9++sm8zkAJl1OvXj2ULFnSZAOFp0uXLiYrqlq1auYzXD4DRrzPbWKgxlp3kyZNzPsLFixoekHxdQbVGIhjVpaVxcSMIgaH3GFmGUv1eGN5nZeXl+M1LofbwGAXs62KFCmC4cOHo2jRouY1zhMDRoULFzavvfDCCzhy5Ij5LEscuSwunzdnq1evNllWo0ePNvuC2U4ffPCBCUDduXPHvIfBLgafChUqZOaV5YW7d+82rzEDi8vMnTs3KlWqhO+//x5169Y1r1nbISIiIiIiIiJR4x3FzyXrLKmUKVOaMjNiWRj7IzHLh+VfxACGJW/evCZwcvToUdNDiZk3DHxYWI7GAE9Yjh07ZrKRrIbhxDIyBomIy2Z/KwsDN1xPWDguCwMsfn5+IR5bJW5c9nPPPRfisxwHs7FYXnft2jUTyLLwynqRxeXcuHHDBOqct8HKMGMG1+LFi00wkMEyZmkFBweHu1yOvUCBAmb/WLhvGBg8deqUeZwlSxakTZvW8Trv83ViRhqDbMuWLTPBMmZHlSpVKtLbJyIiIiIiIiKPU1AqCkGp+/fvm75HFmbbsM8Us3nMpHqHnFa+zlI/d68xuOLh4RHmOhkkYR+p7t27h9x5TstyLh90tx5XzplKZI3PFQNwrjhm56CQ87p9fHwQWWGNlethX6dbt26ZoBDLJRmQ69GjR7jLdTd27gvnv1YTdmfW9rBnGLOrli9fbsr+mBH22muvmYwuEREREREREYkele9FArN09u3bh8GDB5s+Q9Zt/Pjx5spyzKihAwcOOD5z8uRJ3L5929EUm8EVNvm2sFQsvIbZzIjicli6Z91WrFhh+ksRy9yskjPi8rmemMB179y5M8RzLEfk85kyZULWrFlDrJvzE1np06c3y3Ket/3795vspMOHD2Pz5s2mVxaDcuzldenSJbeBOHdjP3HihMnCsuzYscMEwXgFwPBwv7K3FTO12Hvr3XffDdHkXURERERERESiTkGpSGZJsRSP/ZyKFSvmuDGDh+VmDFARm2UzaMQgC8u/atasacrILMyoYo8pNs5mA272SAoLr4bHkjUGSRhkYTCKV6pjryNirymuk8vjctnwO7TMp8hiLykul/2ruG4Ghxh8Y6CGGV4cO5umszk4g1O8el1U8Cp4bHa+YcMGE4gaNWqUuXohS++4LZx79nhiRhqbm5NVYshSRZY4OgefiPPOMsW+ffvi4MGDZtnsH/X000+bQFh4uEw2o+d+5Jh4ZUGrfI/ZctZVFUVEREREREQk8hSUigQGRlhG567ki0EaBmbYWPuZZ54xQSM+x2bYDCY5YwYQA00MvPTu3dssMyzs9zRx4kTTuJsBFV5FjlffY3kZsUE3S8sYcOFyGYyJSNAlItgMnVerY3Nwrpu9pLh+lrURs5fatGljStp4hUBenS8qunXrZhqoMxuJ88Yr6nF7+JdX2uPVALl+NhtnphqznaysLL6fDdn5vGuJ4jfffGPud+jQwcx1gwYNTKApIrheZoIxYMbPZ8+e3XGFP/a4svqKiYiIiIiIiEjkedjCq4GSSGHPI/Y7atu27WOvbdy4EZ07dzZZOyIiIiIiIiIiyZkypUREREREREREJM4pKCUiIiIiIiIiInFO5XsiIiIiIiIiIhLnlCklIiIiIiIiIiJxTkEpERERERERERGJcwpKxaMzZ86gePHi5m90ffXVV3jppZdCfZ2v8T1JBa9kyLmL6DxevXrVXBHx4cOHsTquFStWoE6dOihfvjx+/fXXGNu/ca1///7mFpFjKy7s378f27Zte2zfx6bx48dj1qxZSIhu3bqFQYMGoUaNGqhWrZrZV3wuNKdPn0aXLl1QoUIFNG/eHGvWrEFCEN/HGedl1apVMf57LCIiIiIiEaOglCQLo0ePxgsvvAAfH59YXc+XX36JWrVqYfHixWjVqpU5+c+VK1esrjM5eOutt3DixAlzv2LFinESVHnllVfw3Xff4fr160hohg4digMHDuD777/HDz/8gKNHj2Lw4MFu32uz2cz8Zc2aFXPnzkXr1q3Ro0cPnDt3DsndwIEDsWvXLnOf31N9X0VERERE4paCUpLkMfOBGUwtW7aM9XXdvn0blStXhp+fH9KkSYNs2bLBy8sr1tebnKRIkcLMa2xLnz69CTDOmDEDCcndu3fx999/44MPPkCZMmVQunRpE1xZvnw5AgICHnv/hg0bTEbQhx9+iMKFC+P11183GVMMUMkj/J7q+yoiIiIiErcUlIpDLB0bMWIEnnjiCVPiZZWNWG7evIkhQ4aYkhwGNt5//33zXGglS86lL9byWdLD0rGGDRuabJ3QsLSsfv36JuuEJTMHDx6M8HacPHnSZJHws0899RR+/vlnxxi5zDlz5qBmzZp48sknMWnSJGzevBlNmzY17+/bty+Cg4MjtJ4jR4441lO2bFk8//zzJiMksn777TcTXGAww7Jw4UIzJs7Vc889h3379jlemzdvHpo1a4Zy5cqZkj+O38Lt++WXX9ChQwczJmad7Nmzx/Ha2bNnTYCA913LgZhxwwwVbk+DBg0wc+ZMxz4Nb/+ytOnNN9802V5VqlTBpk2b8ODBA4wcORJVq1Y1t/feew83btyI8LzMnj3bzAEDG/z88OHDERQUhOhg9s3LL79strF69ermeLdKJpmx8/XXX5t9we9A9+7dQ2TrsMTy3XffRaVKlczxM27cOPMZHp+c1wEDBpj5cJ2rCxcu4J133jHzwu3gnHBurH3JzzODja9xvR9//LFZbnjjJe5HHj/WMctlOX/nXP3333945plnzHHFTLn169c79h+PfS6f6+JymZUzffp0Rwme9T2yjht3N26Pp6cnJk6ciJIlS4ZYN/fdnTt3HhvTzp07UapUKRMktfD3ZceOHW63gds6efJkc4zyO+D6+8Bx8Pvz9NNPm2OH30sGvWLzOGNpYs+ePc3+4+8Kj3V/f/8I/Z4xiMcAnvU94W8sg3fcj/weTZgwwXzG9fsa3u8x18eAZe3atU2Qj69bx1144xURERERETsFpWIITwZ5YsMTGOtE1BVPTP/55x98++23+OKLLxwnoRYGLNg7hyecU6dONQGYsE6AXW3fvt385Ylrp06dzIkQA0iuVq5caU7EeMI1f/58c8LVuXNnxwlXWHgyx5N4X19f02+HJ3vsvcPtokuXLpmMjWnTppmgAwMLH330ET755BNzn4EyZi2FhyfG/DwzjngCzJNOnsiyDC+yVq9ebfaL82MG7/73v//h999/NyfLzB7hCSXnjoEDPl6wYIH5XLdu3XDx4sUQ+5HP8bPp0qUzQRBiMC5nzpwmKMX7rnr37o1r166ZYBTnjQGayOC8MRDw008/mWAB55MBMQb+eCzxpJfBmYjgyTjHzTEtWbLEBAo45ojsm7Bw7hj84Nxx+5jRY/VlYgBm0aJFGDt2rAn0ZMmSxRxLVhCIJWaXL1827/v888/NvmAAkPNtzSv3mzPuM+7He/fumWOOn/v333/x2WefhfheHD9+3Mw7j3nO1bp168IdLzFYdOXKFRw6dMg85lhcx2A5fPgw3njjDTRq1MgRtGEgkdtEPPZ5vPA17j8G4BiY4rj52/Hpp5+a48MqI3N3Yz+oVKlSmaC2c5CV28SASubMmR8bF9efPXv2EM9x7hnMc4fzMGXKFDPf/H3gd/DVV181wR2LNQ/cRwy2ct5j8zhjUJHbwX3IbWXp4jfffBOh3zOWNW7dutW8n9vF+xwvx88gFo9Bd/32wvs95m8djxcG8Pj5pUuXmuMovPGKiIiIiMgj3k73JRoYoOAJGDFIw6wLZ8zMYMZAv379zL+cE0/6GNwgnrTw8zxxK1iwoHmOARiehB47dixCY+CJ57Bhw0zfJJbp8OSc62RwyhlPohh0qVevnnnMk2NmeHAbwms0zBNjnjgz0JQ2bVoULVrUnPQxe4MYYOA2chty585tggPM7mEmATG7IyLbc//+fZPBxCwMK8ODGSgce2QEBgaarAnOh4UBEQYMGLgjZrBwzngSawUI2rRpY17j3DFTioGSPn36OMbBTDTq2rWrIxDEgABLgBh44H3nk3gGRRgIYcAub968KFGihDnpZW+giGJPIGvMDMJwTCzBsrKGONfMBOH2htcInHM6atQoNG7c2DzOkyePOfFmYMV6LiqY0cRyMu77/Pnzm55HLIMj7jtuL8dILCdj1hSDhHw/g0fW/BCPZc5hxowZHfPKmzN+lgFDBpIyZMhgnmPAj8GhXr16mccMZjL4xOO1UKFC+PHHH7F7926TjRXWeCllypRmPMyk4z7jWELDYAuzvBiIIn63OX6rAXmmTJnMseLh4WGOob/++ssERrh8ZgQykMEgMgMlkSlP5HHAZYX23eCx4hzAIj62snpcf6e4PAaRmClFnDsG2vj7wO+kddxbv3E8Jhk8jM3jjPuJgXB+PnXq1CaoH5HfM2ar8TeV62SwyjruGGziscTvPcfI/eqcyRSR32P+1vG3j7+B/L4xY4rHFbMowxqviIiIiIg8oqBULOBJpytmEzCY41xyw/IvC090eDJsnQARAyk80eZrrifj7nDZzo28ebLtrtyNz/EEi5k2zhlQViPpsDC4wjHyBN/Srl07R0kLWUEFZnQQMy0sfM7dybArnijyZJeZB8wG4hwwMMDATGQw0MSsKwYEnLfBOrm2TtAZSLPmhhk7zhhQc57HAgUKOO5zHiJyRT8Ginjia82NtdzIcJ5Hlktxvc7bQdxW7sfwglLMDuO+YCCEZZIcHwMiDBJFBzNqGGxdtmyZyebhSTxLx5hJyMwcBoqsAKYVfOR4efy5zo8V+AsL9wv3hxWQIgaGGIw8deqUIyvI+Xjlfb4e1nidcVwsLQwPjyt+55wxQGJhgML6bXD9bliP+d1gSWGLFi3croOZRgy0WBgMYiYSSxtD23cMrLmWdXI91jqdcTv5XpYfWvibwuPF+TvAAF5EvgMxdZwx84nBPgbCeGvSpImjR1xYv2dcF4OSzvuFJXW8hSWiv8eu82AdV2GNV0REREREHlFQKobwhOOPP/4wJyzOJ6KurF425BxAcs1ksPCEijd3gS6eAHl7P9qFzif7VoDC3dXmuDyeiLtmczmfuIfGeX0RfY/ruCKCQYxnn33WBJPYu4WZTZxblt9EhjVvzn2swtoGnsC7my/nz0flCn5cp/O+D22cYe1f57FZPXnY08a5V5AVhAkPM4wYfGNGGDM8eJ8Bj+hiwITHFTOemKn39ttv47XXXjOZQMSMEecTfeKJ/pYtW6K0vtD2l/Nfd98ta1+ENl4ry4q47yNyDIf33XD3urvlMuPRKgNz5bxvedU9Zscx048ljKHJkSOHCQg5Y0mia0lfaPMZne9ATB1n3EfswceyP+4nZsMxa3PMmDFh/p6xxC4qwvs9Du191nEV1nhFREREROQR9ZSKITwBYtYC+0m5nhwRgyvM8mF5h8W5uTZP1Fnm41zaxhNJlpTwNesk0LnExGrIa2FJjDNe6pzlSq64PGat8F/5rRv7poTW+NgZs1KYfcCSIAt74Vh9lWIKS2d4Qsl+LMxmYW8nZpCEFdhxxyr9YqaahdvL8hwLTzIZ+GKvGc4NG0M742PXQEpkMcuCWVvODaGtBukUkf3rjBlF3C5mtVj7kMcgm3hHJKuHZZ3McGMpU/v27c34mFkU2fl1xdJVrp9Zbt99950J0LLXDrNOGFBhnx1rvOydxAwXZhjxMbfl/PnzjmVx31ulcKHhfmFGjHMmEI9jBoDy5csX5fE647ETkQw91+OKmMn2559/IjI4dufvpvPNChyzdxIDUsyQsgJ+oWHW0969e01WmoXHunM2lIUZQNxW598CZkHx81H5DsTUccaSS46BZY8MbPI4t/ZTWL9n1vfEeb8wAMnlhCW83+PojFdERERERB5RUCqOMBOGvZVYxsLeQgxO8UTFwpM1lg+xjIzBJN6s/lPFihUzfUtYBsOTLQY22EfFOahFDNqw/wvLWdismK9bPYicsR8Mm2UzG4MniAwMsCeNc9+l0LDshiet/Jd/roeZAGxCHt2yL3fBJPbj4QkkgzM8uWXQLyKlf66ZKOwF5Hw1LvaMYr8ZntgzwGZdjY0lPl26dDE9dTg3DJYws4EntMzaig6eyHKOmNHB5a1du9YcC5aI7F9nDE7wJJ99l1g2yRNmZsxwe1gmFpH5ZQ8nzguDmWzgzIBRZOfXFU/iGYDgNnK5zBaxyuE4t2wwzcbUDCSxH8+2bdtM4JTbz6bi7LHEMXGb2N+JfZ+I2WBctmsZGl9n4IHbzs9t2LDBfAeYWefcGyoq4yUGIay+U8T137592+2y+F1jxhf7F3E/MMjFZYZXKhZZHAPHzIAHy/y436yblcXDUmHrSny8KiEDgAxgcTycV/6+hHZMcz/x2OR+4nfculodSxsjK6aOMwaduM0MNPHYYYNxaz+F9XvG7wmztNjXitvM310GInmsWccVl+cayA3v9zg64xURERERkUcUlIpDvJocT5BYGsTGvAwqOGPGEU+weVLI7AeeqFtXaOPJFU+2mXXBE26eRDPI5axu3brmhJUnqywl5FX+WLrjiieXHANPPLksZnfxvc69ksLK4uBVpJjFxPXwZI8Bgaeeegoxic2erVIflljxKl8MhPHk0flKeBHBsiEGPyw8sWTDbc4tl21dYYtBIee54WvM2GLJYEQCduFh8IsnwWyEzGBS27ZtHRlSEdm/rniCz6w8lpxxmdw3DDgwMyQ8bLLOzKWOHTuak3qWbTGowrmIDm4Xg5YM/HFMLBGzrlbHY5qBEO5Hfg8YRGUJmtUPisEENoXmmNhUnn/Z6N65mTYDWc64rdZVzbg+q0E3AwLRHS8xoMIr/xUpUsQ87tmzpznm3WFmFq/Cxubz3IcMRPC4cvcdjA4GNBmwZVCVgU7nm5Vpxnm2Sl2tOWIwiMccA7I89tnc3R1ejY6/TQxG8f0MsPACAO6u7BdXxxkbxLNXGBvYt27d2my/dSXO8H7PGAhmYJrrZ2kmG+1b5ZncTpYYMhvTVVi/x9EZr4iIiIiIPOJhi269jkgCx+wJnlzz5JNBj/jAckdmyDH7wgpEMZuDJ6rMSJGEidlFDEyEV0YoIiIiIiIikadMKUnymMHCLLJFixbF2xiYIcKMDWZasDyPGTi8z6tyScLEXlLMSnJXAisiIiIiIiLRp0wpCYGlLWH1e2F5WWhlP5HBzCX2bArNpEmTYrQXD8sNWbrD3lShXVkrtrHfEJtTs78Oy/VYHsgyopgeD/vfhHU1Nu6/yDbfJvZKcu6D5e4KlBEtm0sMxo4da+ZKQSkREREREZHYoaCUhMAsHudLv7vy8/Nze2n7yGI/IV7VKzTsw8MeTxJ5DCo6X8XOFfcf92Nk8WpkzlcxdMVAG/sHiYiIiIiIiESEglIiIiIiIiIiIhLn1FMqkdu4cSOKFy8e38NIUnjlNzYlj81MplmzZjke88pvvGpbbOMVDOvXrx/p44ZXMzt69Ki5z78cb2K8PgKv+GZdhTGhfm/YYyyyV5cMDa9UGN5x9eOPP5p5cL7xqnMiIiIiIiJxQUEpEScbNmwwQYEaNWrE2rywn9PEiRMdjxk4ePnll+N0P1SsWBFr1qyJ0Hu7dOmCK1eumPuFCxc2fZbmz5+PxOatt97CiRMnIr39ceH33383/cZ4Zcbly5dHOzDEnmzsnxaeI0eO4PnnnzdzYd04TyIiIiIiInFBQSkRJ998802sN7Z2zTLKmDEjfH1943Q/sLl6tmzZovRZBjEYVEuM2VIxsf2xoVy5cqaH2uHDh00Wl5XRFln+/v54++23TVAqV65c4b6fmW8lSpQwc2Hd2BtMREREREQkLigoFYcOHDiA5557DuXLl0ft2rUxYcIEx2t3797FBx98YK5+x9uQIUMQEBDgyGZ45ZVXTHZH2bJlTVDAKqdyxQbX3bt3N+vgiS3XERQUFOHm48zY4XqqV6+OESNGOJqRs/n55MmT0aBBA3MCzRIuXkXOwrKfv/76C82aNTPr7t27t2ma3rlzZ/OYY7bKkhjMYFCD4ytTpgxq1aoVYi7Cc/XqVbz77ruoVKkSatasiXHjxpllnjlzxozj33//NcvmdowcORKHDh0yV/urUKECXn/9dXPi7s6xY8dMeVfdunUdz/3888+oV6+emXcug1fQs3C5nAfOB8uufvnllxDLW7hwIZo2bWq2n/t93759JuAwYMAAnD171oyVY3Yt32OZHeeRy+U6N2/e7HiN28X1dOjQwYypdevW2LNnDyLLtXwttO20giPcj9YYOS4er2vXrnWMN6xSuMWLF5v54bKbN29uMoEsFy5cwDvvvIMqVaqY4577y7r6I5fLufn222/x5JNPmn29YMECLFmyxIyVV2ccPXq0Y1k8vhiQ4Xt5XD3zzDPYunWreY3L4Zxz7vv37//Y9p88edLxHXvqqafMfITmv//+M8vmfuUVFFneSJyfvn37mu8Nl8O5Y+bR9OnTTeZdtWrVQl1u/vz5zX7s2bOn+cvH1vy7ltfxxm1wh8cTfzc4d3nz5kV4eMwXKFAg3PeJiIiIiIjECpvECH9/f9uLL75oq169um3dunVu39OyZUvbsGHDbKdOnbKtWrXKVr58edu///5rXuvVq5etefPmti1bttj27Nlja9asme2TTz6xBQUF2Ro0aGAbMmSI7eTJk+a1Dh062F5//XXzuQ0bNtiKFStm7gcHB9vatm1rGzhwoO3o0aPmtcaNG9smTJgQoW3o3r277a233rKdOHHCtnXrVlvNmjVt06dPN699+eWXZtuWL19uO3LkiK1fv362WrVq2e7cuWNe5xiaNm1q27Fjh239+vW20qVLm88vXrzYtm/fPlvDhg1tI0aMMO+dN2+erVq1amaeTp8+bZsxY4b5PLctIjp27Gh7/vnnbXv37rVt2rTJrGfatGlmWVxOp06dbPv377ctWrTIPG7UqJFtzZo1Zm6rVKlimzp1qtvl/vjjj+azFi6f2/HPP/+YZY8aNcqsi/vk3r17tjp16tjGjx9vO378uG3FihW2GjVq2ObPn28++99//5nPcts4n9x2zldAQIBZDz976dIlW2BgoDluOL80d+5cW4UKFcxyuA9Hjx5tHl+4cMG8Xq9ePVvVqlVty5Ytsx07dsz2wgsvmPmICC6bn3c9bsLazqtXr5r3/f333+YYt/Tp08f20UcfmfucC26LO1euXDHL5rrPnDljmzx5sq1s2bK269evm7ng8fnaa6/ZDhw4YI4HHuvWccLP8LMDBgwwc8hx8Ttj7d/Zs2ebsXH8xHl88803zfF5+PBh8x15+umnzWtcH+ecc3/r1q0Q23///n1b/fr1bT179rQdOnTI7EvO+cqVKx/bHr5eqlQp29dff232+3fffWfey+3nPuR4eUzwu/rOO+/YKleubMbBMfF7yM9yTt3566+/zHeY67979655ju/lsl1v3IbwOB9X7ly+fNnMAb/LPC74/eX+4RhERERERETignfshLqSH/aE2bRpk7k/fvx4k2nkipkazDTy8/MzWQxTp05Fnjx5cPPmTZP9wceVK1c27/3www9NY+b79++bLBtmGqVJk8a8xiwNZi2564fEbCf2kvH09EShQoXQr18/kx0SkT4xHF/p0qVNzyBmanz//fdInz69yUJitgeznzh+YjZIo0aNzHZzfFbvIWaPUMmSJVGwYEGT8UONGzc2mWLEsqKPP/7YMUcsl/v6669N6RLXHxYuY/v27SbbxsoEGTZsmMncsbz55pumJIm3jz76CC1atDBZNsR1MjvEHWYysWeS83x4eHiY+eB+YnYWM3SYNbZo0SJkyZLFPEfMNuH7mQnTpk0b/Pbbb3j66acdpYDMoGG/IO7rdOnSwcvLy2352LRp00xWD5dB7733nsmU4vyzAbu1/xs2bGjud+3a1WQaRUdY25k5c2bzngwZMoQoMSxSpIgjU4plZ7y5w+wlZtvlzJnTHPfMxGOmT8qUKbF69WrzOpu+c/nEbME33ngDvXr1Mo957LFhN4/9jh074qeffjLZRNb+ZZYc9yePN84JM7K4LnrhhRfQrVs3R4kk55xzz5szZjNdu3bNHCssXStatKhZJ79DrubMmWMy9HiMEZfPY+/WrVvmcaZMmcz+4HxyPzF7cNCgQeZYZSbWl19+abKyrHl1xqw6ci7dc/e+mGJ9D3gcMxuNvzfMVOM88bssIiIiIiIS2xSUigU8IXWHpWM8iWbAgiVCLL1iYGLXrl2mxM45IMPSJN6IgQ2WLbGshyeSDJ5kzZr1seWzpO/GjRuOwBYxsMDA1vXr180Jc1heffVVDBw4EMuWLUOdOnVMqVWpUqVMk2su1wo4EQMsLJFyLiN0LhdikIJBCOfHVlkWy5h27tyJsWPHms/zZPjy5ctmrOE5fvy4CTA4r8sK0LB0KTLjcMXABIMbFpYVFitWDC1btjTzwIBc+/bt4e3tbfYDA2Qs07JwH/KE3hqnFayzehgxQBgezodrAJFlh87z7FxuxSCKVWIZVWFtZ2i4D1hGGR7OJ491Bs8YpLSWnTp1arNN3BYrIEUM+AQGBuLUqVOOgIkVjGUgixg4c92f/M7xe8JSQZZgcv75fYnoMcWxOfdSateuXajvdQ2cWoFJa2zW998K1FnHn/U4tOPPHQZUGWh2xX3FwHV0sGSSgWzrd4HBQn4HZs6cqaCUiIiIiIjECQWlYghPEv/44w8TrHA+SXXGrApmDjHLZ+XKlfjf//5nMo4Y3AnNnTt38Oyzz5oTR2ZQMPuG65gyZcpj7+XJPLOj2KzblWt2iDvsj8NMIo6PfZnYn+e1114zwSp3GIRxPum3AjIWd5kmxEwuZqUwOMEMKgZr2LMoIhgMC09Ex+GKwQTn/lsMnHCszID7559/TJ8enrDzL+eac8XMHnfCCuiExQq8hDXPEZmDyAhrO3PkyOH2MxxPROaVc/rdd9+ZwOuKFStMwHPGjBnmFtq2Ov91N4/ugr4cD7OwmLHEYCq/KwzW9ejRI9wxRmZfhfded69H9Phzh9mKPNZcxVQzctdANTMFrd5vIiIiIiIisU2NzmMITxLZgJpNj92V7rH5MEtjmDHDrBGWabFZ9d9//20yexhIscrbiIEhlv8wUHDp0iVTFsbgEBsmM3PC3ZXPmO3B11jyw/I73pg9xJKh0LK3nLHskNkvzDhhIIHBtaVLl5qAFjOzduzY4XgvT/j37t1r1hlZDHgwG4hZWSxT44kx1xuRq7lxm5i1xYbuFs6NVU4VHczK4bItLBPkPDCziyWQLLHkfmTzbG43s2aYGWPNNeeH+9Uap/P+ZJCFgRJ+Nqx9weUyi8wZH0dlniMqrO0MDTPv3GXruWI21Keffmqao7Mk788//zTlmyzd4zadOHEixJxzDhnYyZcvX6S2gRcDYJnjjz/+aBr9MzuL3xsK77hithZL6u7du+d4jmPm99WV634lZsRxu2IDs6ys48v5xmM1uhiIZLmj8/wwa5GBbRERERERkbigoFQcYVYIy4qYGcVMp927d5srnLFcigEtBmdGjRplMkr4GgNEDBKwTIo9axikYoCJJ5IMfrkrAWIZFk9i33//fXNlPC6fV/FjJoxr9pA7HBdLgnjSzf5Oq1atMuMj9phhcIsZXgw0WFcHZFZKZDEIxeCdVWLFYAWDXBEpa2K/H84L+/RwG3kVNWaTWD2jooPb6nxFQZZbsdcV55xzz8AD9wXLnJhVxrJIZkpxPjhX3H9WsIB9odhva/78+SbgwR5aPPln6Rf3B3tLMSDjmgXDeWb/KJZrcn7GjBlj9gez5WJLWNtJLJ/j8XD79m3HZzhP1rHBeWD5pTvsScYgJLP3eDVGZuCxhxU/y33GgCz7bXF5LCXj94PZgPxcZPD9zEji2Ll8BtasqwVaxxW3g8e4cxDM+t4wwGbtS2Z0/frrr+Z5VwzY8nvF/m/crwzmcW6sUtuEjttu7UcGuLnfGIDjtnDuJk2aFGpmpIiIiIiISExTUCoOMdDEbAwGGNj0mCeyVoYPs4bYuJlZVCyZq1q1qgnWsGcRs4qGDx9uAiEsqeLJMzOLXMtsGHhiw2KWMjELiw2h69ata5o2RwQbhvPknAEVfj579uwm+EMsjWK5HYNRbdu2xYULF0xWUFQaMXNb/f39TU8tjpHBDzZNZ5ZGRIwePdoEdtj4ms2/+ZeN4KOrdu3aJgDEkkmrHxIDTWwqz7LLiRMnmnWzxImBRJ7AM7DEgCLnmI212TeMnnzySQwdOtQEe7jfuG38PANADKox24Uln67bzCAf9zsDgPwcM+VYquncgD2mhbWdxOPhs88+cwR5GFxjdhX7jhH7OLkL4BB7pvFzzAhkfyQGPdkwn+/n8WqVmvJ4sxrpR6VXEpub8/jlPmFQi4FK7hNmXbEHmxVQYkDX9fvA93AczKxidiLngoEyZlu5YgYXt2fu3LlmPdwuzldoZY4JDb9v3D5iAJvzxH3JY4093thYPyqBZhERERERkajw4CX4ovRJkSSIARg2ubaufiePY6CMwUleWS46/ZJEREREREQkedMZpYgTZjqxdEtCx6tHssRLASkRERERERGJDl19L5lgDxyWhIUmJi4xHxNYGsheSqFheVZs9u9hWdmcOXOwZs2aUEvSEiL2IuPVHEOTO3fuGGnGzZ5LbKYfmz2uREREREREJHlQ+V4ycevWLXPFtNCwR1JMXNEruhjwYNPz0LB3D/sySUhs5u18RUJX7JvEHkIiIiIiIiIiCYWCUiIiIiIiIiIiEufUUyqR4FXatm3bFuvrOXPmjLkaHv+GJyAgwFxJj+V0LHXjVeISirVr15oricWm9evXm3I24lUR69evH2NXaZw1axbiCvf3xo0bw30ft4/vbdq0qXnMaySMGTPGXE2wSpUq5gp9vPIj8T18b0zNSWwaOXKkGavzbfr06aG+/8cffzRXauSVMXn884qaIiIiIiIiEnkKSiUSb731Fk6cOBHr68mVK5fpp8S/4WEQYs+ePfjpp58wdOhQTJgwAUuWLEFCKGVjoKFnz56xup4uXbrgypUr5n7z5s1NL6qY8Morr+C7774Ls9wyJnF/M8ASEQzCzJgxw9Gn7I8//jD7nf3KFi1aZJ4jvofvTQwYWOzTp4+ZB+vGKzC68/fff5vtZf81Hvc7d+7E6NGj43zMIiIiIiIiSYGCUhKCl5cXsmXLZv6G5e7du5g9ezYGDRqE0qVLo1GjRuaKbL/88ku8z+jixYtNY+/8+fPH2TrZ5ypz5swxsqz06dObzDMr+BPbuL9TpEgRofemS5fOsZ0///wz3n77bZMpx2wpZqZZ+5/v4XsTS1CqVKlSZh6sW+rUqd2+l9vMhvL16tVDuXLlMHz4cMydO1fZUiIiIiIiIlGgoFQcOnDgAJ577jmUL1/elP8w48I1u6dq1armxhP8GzdumNdeeuklnD17FgMGDED//v3DXQ/LqiZOnGhKp8qUKWMCHM7r4vL4uFOnTmYszz//vKMMzbV87+rVq3j33XdRqVIl1KxZE+PGjTPL57YEBgaGyLCpXLmyyRyxSrjCw6wajpHLYHbQ6dOnHeP74Ycf0LVrV3Pizyu9nTx5EkOGDDHvbdy4MTZt2hTqcmfOnImGDRtGe96J6+XYuN6nnnrKBCXIKkvr3Lkzvvrqq8fK9zif/BznzVqnNS98PzNzmF3G16tXr26uKuiMy/rtt98cn+GchLXvGSBkyRz3N7eDwZKgoCDzGj/HbezevbuZzzZt2oQoBXUu32Ow8YMPPnDMB+ecZZquLl68aBqrP/nkkyH2P4/TS5cuISIWLlxoxsz9wv2zb98+x3iZfcTjjq8xC42vsayRAbA6dergr7/+crtM7gfXUjzr5q4k1d/f32xLgQIFwh0v53P37t0hrv5YoUIF05ifx5iIiIiIiIhEjoJSMeTOnTsmcFCjRg3Ta8idvn37omTJkqbkadSoUZg8eTJWrVplXmOwh6VwDE4w8MGT5XfeeccRxMiZM6cph2JmUngWLFhgSou4DpbTsfSPy9i7d6/jPSwPa9KkiTmJ5xXtunXrZgI0rvjZy5cvmx47n3/+uXk/s2H4XKZMmUJk2GTNmtUEMJyDOqH59ddfTaCGQaD58+fD19fXsb309ddfo0OHDmZ9t2/fNoEpLp8lckWLFjVBFndu3rxpAmMMoEV33rktL7/8shkbezwxWMPAyD///OMo1eO88j3Orl27ZgJ92bNnN8EiBp84f1ZAyyoDS5kypdl2Bq/Ym+n48eOO15l5xNLAQ4cOOdYT2r5ngI7z0bt3b7O/GZDi+FasWBFivosUKWLWx0AS9zfH6Wrw4MHYunUrvvnmG9MjjPe5311x/xO30cL9QxcuXEB4Vq9ebbaHWUe///67Caa9/vrrjmOQxy/7VPG1jBkzmvcxQMpAHQN2nFN3wU8GsJzL8Jxv7kpSGTz08PAwQVwGu1q1amXmKLQrWPKYcN5mXtWQ44vINouIiIiIiEhI3i6PJYp48mxl7zBwwewXV8wiadCgAfz8/JA3b16TKZQnTx5T+sOgBcuAmNFh9WtipsrBgwfNcyynYzlUREqiePL98ccfO8bAjCgGeQ4fPmxK7Ygn4OyJRCNGjDDZPGwOzoCPhdkf27dvx/Lly814adiwYSabhmN2LfmyHrsLbrlicIHrZxCBGPBhdtT9+/fNY5ZHNWvWzNxn1hNL8lgqxgACg1UMloXWEN7Hx8fMa3TnnZk1DNx89NFHSJs2rZkbBm08PT0dJWwZMmQwQStnDH6x/IvzyqBF4cKFTRCH+8CacwYy+vXrZ/Yryx4ZFGNwrGDBguZ1Bqw4VmYIlShRwrw/NGnSpDHBNmaQEbeN28j9bT3HgJTV+J0ZdytXrjRz+uKLL4YI6DGoxc8y64nYO4lz6sraT87HQGT3/9NPP22OTStwyP3GMRCDVAzsEd/HfcC5Z5kkg7/MhmPQzjlARHydt4g6duyYOaYKFSpk5mLz5s0mO4z7myWp4W2z9Tgi2ywiIiIiIiIhKSgVC3iS6w4zQZiZwxNyloK1bt3a9K9hNgxLgFjC5IyZIGxubgVMIopZNswWGjt2rMkEYVCBQRHnzBKWjVl4As5gCN/rHJRi5g6DIVZAiqyyOJZPuZ6IW48jEhTgsq0AmZVlwyCNxTmoxOWxR5Q1r3zM+XKHQSQGihg4iu68s5yQ88L5sYTWANsZ55HbxoCUheV/3AfMtrG2z7lvFwNbLId0xrlndlB4GMDhnLDZ+JEjR0xAjWWHLNt0t785N+yhZJVsWvgZlqg57xeWqjmXq7kLQDGAZt2n0Poxue5/53nn8sLa/zw+rOPKdX2uwWFmUbnz559/muPIGUsZGQC1gn4MAHLfM+jlGpQKbb18HJFtFhERERERkZAUlIohLVu2NBkyzLxgLxx3WDLF7B9mHjFThSVJzKZhUIHY2JpZL86yZMkS6bGwZIyZJe3btzeZMjzZZ+8jZ84BE2IwwjmQQ8xcCQ1L/nh1OAZSrGUx6MLAARt1h8d1/eG97jq20DBw5VrWFdV5j+rV9KzghTNrTFafJ3dzy15drp+JyHazFI6ZYwywMOON91nCF5P7293+t/a5FUCySvoY8Iuv/c/SPvahcsc1q8o6Xlyz0Jg1tWHDhsfey/dx3zJDi9lvxOOf5aoR2WYREREREREJST2lYgizadhrif2k3JXusRcN+/4wI4QNvKdNm2bK0NhbiJlIzJrhyS2vGMcbl8cSvIhkyrhilgcDE+xBxUAFez9xOc5BD+fGzOzZdOrUqccysjgOjokNrS3si/Tmm2+aHk0MHOzYscPxGvsPlS1bNkIBBC7beQwMcDHDy10z6shgRg2zkaxtjc68s/k1s4dY5mf59NNPQ+1nZWF2Fft3OWdzsQySJX9hleG54pxYfZrCC0Iyg4uldgxEMmDC/em8v51L8BiQ4ty77m9rPpz3CwN5zzzzjNugFLOOuM8tvM/n3AV/wtv/HBMDSs7LiwruP2tfut7cBcK++OILR0mlheNiYMoVj2se385j5PHP5TLDSkRERERERCJHQak4wgwLXvGMGTrMpuJVvLZs2WLKqHgizWAC+zXxKmgswWKPHQZErCwUZvLwcxFpIs4gFINjLJFin6JevXqZAIlz2dGiRYtMQ3SWcLHhNIMJ7KXkjKV8DBTxdZaEcWzff/+9aSLOciUGvDjmXbt2meAFG2O7ZmSFhn2B2Myan+M4WXLFbXUu24oKBlqYYWSVpkVn3ln+xqAQ+11xeWwczobhVlkc9wn7NjGo55o1x7m2PsdtZKNy9k8KrbTTFRuusxeWVUrH/e66HgsDXQx6cR9xPLx6HbOWnPc3+51x/3AO2H+KgTZe+c4Z54P7lK9zn3Ku2B+Nx4A73B42aOfc8cZy0bD2P8dk9WXi/mepHZuKc74ZCGQQzbl0MC6wdI99pNjPjIE8Zs3xe2E1r+d4rQwwYp8rvpf7lHPEY4dBTpXviYiIiIiIRJ6CUnGIJ/gMBvBKcrziGnv1MOuIGEhghhWbefMkl9kXDABZfYcYAGAmFps9h4cZUgxqsHdSz549TaCG/XGcs2UYOGGApW3btubKgWy07S6TZPTo0eaEu2PHjujTp4/5azWgZsNsBhFYDsdyMa7LaqwdHo6NJ/78HMfAjCb2RIoulg6WK1cuRDZLVOed93kVukuXLplsIQZrGLRiXyorsMLG6Aw4uQZ3eIU/BjkY5GFAjHPUo0ePCG8Hg0y84iIblBPnlut3h8tluSH3DbPBGIjj8eK8v5mFxJI0jofN09nM3F2ZJY8dZv1wOa+99poJVDKo6Q7nko3quX5esZD71DXryBmDeWyuTrwCIAORbP7OK95xrLwCXmSalMcEHivMllq4cKFpqM5MOgbX2AOMOF7n3lwtWrQwPcoYcOTxy8+///77cTpmERERERGRpMLD5trIRpI8BlOqVKliAh1J0bx580y2C0sNEysG/FhOZwXPooOBN/rkk0+itRwGthiAYhAxovthwoQJpo+XiIiIiIiIiCtlSkmSw4yXc+fOmVK1xIi9pNauXWuynRIalhDyCofh4XtCKzcUERERERERIV19L5Fhg24r88WdypUrm9Kx+MTSsLBK8Vg6yKbcsYVNzYcMGWJKw1iKldiw99Mbb7xheoMlNLyqIxvpL1myJMz3scSTvcL8/PzibGwiIiIiIiKSuKh8L5Fh/ydekj407MnDK6PFJ179jtk+oWHPJfZAEhEREREREZHkS0EpERERERERERGJc+opJSIiIiIiIiIicU5BqURi//792LZtG5K6v/76C1evXo3z9fIilL/88gsSinHjxmH27NlIzLgfuT/jw+nTp7Fq1apYX4+/v7+50qPlvffeM03qE7IHDx6YiwFs3LjxsTnr0qULKlSogObNm2PNmjVhLuePP/5Aw4YNUb58ebz11lsRaoCfnHHeZ82aFS/rdj1Ok8Jvdlxav349jh49Gt/DEBEREUmSFJRKJHjSd+LECSRlZ8+exbvvvot79+7F+bo3b94cq83XI4NXDVy2bBmeeeYZJGZjxoyJk8CQOwMHDsSuXbtifT0//vgj5s6d63jcs2dPjBo1ygQgEqKAgAD07t0bhw8ffiwoy9+YrFmzmu1p3bo1evToYa5i6Q7ndtCgQeY9v/32m+kjN2DAgDjaisTpzz//xMSJE+Nl3a7HaVL4zY5LDNaG1ctRRERERKJOQSlJMHhinBzX7WrSpEkmIOXtnbgvjpmQ5jSutjF//vzInTs3Fi9ejITmyJEj6NChA06dOvXYaxs2bDCZUgzMFi5cGK+//rrJmAotkDF9+nQ0a9YMbdq0QYkSJfDZZ5+ZACSXIcnn9y05fMdFREREJHYpKBWHDhw4gOeee86Uu9SuXRsTJkxwvMbMipEjR6Jq1armxjKgGzdumNdeeukl8y/SzETo379/hNa1cOFCNG3a1KyL69y3b5/jtXnz5pkTynLlyqFt27YmS8hSv359zJkzB+3atTOvv/zyy2bdzADhsphBYWVZcDmdOnUyGTEVK1bEU089FaLkjCUjHHP16tVRpkwZM57ly5c7Xi9evDi++OILs73du3dHgwYNzPP8y2V/9dVX6Nu3L0aMGGGWz7GxpIgnxDVq1EC1atXw888/O5bHbI33338flSpVQq1atczn7t+/b15jqRI/P2PGDDP3POHmeznvZ86cQefOnR1jci1rcufu3bv44IMPHPtryJAhJgvFWgZLWjjHnDNmpvBknevg4+effx4XL150u1xuAwMa1lwQS2OYjcDtqlmzpints04GL1y4gHfeeQdVqlQx4+AxZGXpcA557Hz77bd48sknzWdZwrNkyRLUq1cPTzzxBEaPHh1i3zOjomXLlmZ+unXrhsuXLzteX7FihQlClC1b1nyW28WrQRL31ZtvvokXXnjBjIXrnT9/vrlxuVGZF2aLsYyMrz377LPYtGmT4zVru1555RVznDZp0gSrV682r/E7wvfy+8X3hefhw4cYPHiwmT8eZzwWIzIOzi/XwcfcNud5/PXXX0M85vxE9rvK7eD+4b7naxwDXxs/fryZ/zp16jjKI3nMcgzubtbxzHFyG5nZ5Grnzp0oVaoU0qRJ43iucuXK2LFjh9sx8/0cgyVXrlwmGMfn3YnIcfrll1+a17jcjz/+ONSAR2BgoPkO8DvOMb799tuOq33yO8g5q1u3rjmGuS/Pnz9vXuP3nPPx77//mn3Cfc1xHDp0yPwO8v0MxvF3y5p/vs5l8Bjjse9cQs0gH48/LoffCR6/VomX9XszdOhQM8bvv//e/Bbyt5Rj4Fi4zT/88AO6du1qls9j6+TJk+a3hMts3LhxiGOe4+RnrOPdudyYx1efPn3M+vg7wd9cBrfDOk6d8TeHy+R28Dhz/p3m/HEOeAxym7isoKAg85rrb7YrZtrxvyHcHo6Jv8n8vhH379dff232I/c51+Gcmcd9ykw8fpbLnzlzpmP81vzyv1X8XePvG7eX/y3jd4mf4X87goODI7QuLpffQ5a18r9V3JdWgNX6/eLvFOc5vN8LEREREYkkm8QIf39/24svvmirXr26bd26dW7f07JlS9uwYcNsp06dsq1atcpWvnx527///mte+/jjj20dO3a07dy503bgwAHb66+/buvcubN57fr167Y6derYfvzxR9utW7fCHct///1nK126tG3GjBm2EydO2EaMGGGrVauWLSAgwDZ37lxbhQoVbPPnz7cdPXrUNnr0aPP4woUL5rP16tWz1axZ07Z27Vrb7t27bVWrVrU9+eSTZlmHDh0yY+zevbt5L5fF9bz88su2gwcP2mbPnm0er1692rzev39/8/59+/bZjh8/bhs0aJCtSpUqZhxUrFgxW+vWrc04Dh8+bLadz/HvvXv3bF9++aVZ3vjx420nT560vfPOO7bKlSubuTly5IhtwoQJtlKlStmuXr1qltejRw/zGuePy2jfvr1twIAB5rUNGzaYZXFO+TrnqFy5crbffvvNFhgYaPv777/Nui9duuQYX1h69epla968uW3Lli22PXv22Jo1a2b75JNPHNvVtGlT244dO2zr16836+WcLl682MxFw4YNzT5xZ9myZWZfO+McPv/887a9e/faNm3aZJY1bdo0M87GjRvbXnvtNbNNPO4aNGjgWLa1fzgHPA5GjRpljrlOnTrZ9u/fb/YXx8rlWvu+UqVKtgULFpjl8Xjmuonzz2Vxvk6fPm32MY+NKVOmmNe5r7gsHifcxtu3b5v9xZu1fyIzLxxfxYoVbb///rsZ+08//WT2F+8Tx8bH3EaO7e2337bVrVvXFhQUZL4jHDf3B7874Zk6daqZR+5HHldcNpcX3jh4jHIdXBePGwtfK1GihO3mzZvmMbefvw+R/a7269fPvPbLL7+Y17jfnnjiCfM94jiHDh1qvpvcZr6fY3B3c3c8c1/wO2H58MMPbe+++26I93C9PMbd4W8Gf8OcPfvss7ZJkyY99t6IHqdcP38LePxx/tasWeN23WPGjDFzxPXzd4PfjZ49e5rXOGeNGjUyxxf33SuvvGJr06aNmSMet9xu6/hftGiRecz3c138LvP3iceDtSyOi7+RnO+RI0ea3x/uTy6P2zBkyBBz/PHY6dChg/n9Ic4tl83fQO67s2fPmt9vfre5T/ibw+OMxxaPf24H54j79/PPPzfre/PNN81/M4jHGj/L30L+lq5YscJWo0YN8ztO1m8lv+NcH/cD13/s2LFQj1PLlStXzGe5H86cOWObPHmyrWzZsua7ExwcbGvbtq1t4MCBZt9wuzhO/vaS62+2K/634q233jJj2rp1q/m+T58+3bz2888/25o0aWKWye3lOvj4wYMH5vUuXbo49hX/O8nPcl3W/HLMnG+Oi2PmMcN9vX37dtvKlSvN60uXLo3Qurhc7k8em/xvGX+nevfubV7j/ubr/G8Ev8dh/V6IiIiISOQpKBVDeFLJ/3HljcEQd3jCzxMOntDQtm3bzEnC3bt3zf9A84TNwhNa/k+29RwDBjxpiAieBPCEyvmkkCclXBf/p33s2LEh3s+TKZ7oWetxfp1BBZ70OZ+o8n/IieMpU6aMOamx9O3b13GCyNf5P/gWnjxwfs6dO2ceW0EMi3XSyL/WiRZPPnliRDwx4esM6hFPgviY88gTQ86Xc9COc2c9Z50kMrDmPE+DBw82963XI+LGjRu2kiVLhjip37x5sznxsbbr119/DXGy/v777zsef/bZZyaQ584XX3xh69q1q+MxT8ict9kKXC1cuNC2fPlyE2TieCw8UWegjidPnH/ev3PnjnmNJ1BclnPQlEFUnpxb+54ntRauk+/nPuSJ8MyZMx8LzFlBP+4rniQ74zHofBxGZl7ee+89E6h1xqCj9RxPBK3jzHmerOAqX+eYIoLBEZ78WwEsnpjzhDMi4+A6uC5n/H7ze+F8fETlu8rnraCg9d3j74R18m/tz4sXL9oiyzUoxf3I764zBi0ZKHSH3ysGfpzxd+Lrr79+7L0ROU65PAYyLfyd+vbbbx9bFn8LGDhy/i1kQIf7gcvncqygOHGfct0M/lm/L86v8/jnb7Lz7x0DTcT5Z9Dceb/Wr1/fBIT5nWLgx/puEb8fDGw4/55wH1k4Zn7HLDxurMCHdfw/9dRTIX7vuL9p1qxZtmeeeSbEXPD3xnqO28+gDYNdFs4Tg6mhHacWBqU5Vv5DhDXHnCP+d4m/FdWqVXP8N4sYEOOy3f1mu+L3ioE5K/jDdVnvZZCNy7Jw7FwXn2MwzfV3j/PrHJSygm7O/y3gMev8+zJx4sRw10X8rBUsIwafrf/OuX5fwvq9EBEREZHIS9xNaxIoDw8Pt8+zNIRlJyyfYakbS+GyZctmyjJYEsDSHWcsPWBz89BKLkJz/PjxEMtKkSIF+vXrZ+6zvIQNjZ2xbMX5ykJ58+Z13E+VKhX8/PxCPLbKL6weOlmyZHE8ZumDVbrEcheWgfCKU2zevXfvXvO8VfpBzst2J0+ePI755LqdP2M9ZhkQx8/5YkmTMz7Hkhjn8VrSpk1rSoEii8vjNpQuXdrxHEtCnMuZwpvD0Bph8wpmmTJlCrEvM2bMGGJ5vOIZsSSoQIECyJAhg+M1lu5wm6y+Qdw3VklWypQpHXMa2lj4eedt4Lo5tyy543HEkjmWb/LG8iUewxHdl5GZF66TpWnOpWY87lh+Y+G2O+9Lisr+7Nixo2lCzWWzvIzzy3KuiI7Dlaenp9knEbkiWVjfVXf7io3IrePe2p+csy1btuC1115zuw6WNTkfm+5wWVa5sIXLtdbl7v2uxzAfp06d+rH3cg4jcpxa+zCs7yZLujhO5+9ekSJFTHkxSwf5fWeZmYXHb8GCBc0Y+Dey303n7wP3K0scuSx+p1i6zHLYPXv2mN83llZy/zhz3n/uuO5flkA6/95Zv7VcPsu/WS5m4W+Ql5dXiGU5P/b19Y3Q96FkyZLmv0csI+QcsVSuffv2Zl9yWznfLEG0cI5ZFm2VTIbl1VdfNRcdYAksf5tZGsg5ZNkvSzp79epl5tXC5fK/edwHrr97/O+UK+t11/82WM9xOeGtK7T/Njj/dy6ivxciIiIiEnkKSsUQ9uHhJdJ58sAeMO6wRw9P7hmoWblyJf73v/+ZHhsM5BD7HTn3dCHngE9EhdUg2zqRdcaTG6v3Bjmf2JDz/8iHty4uy3o/e3ps377dBC54AscAHP+HPrzxhLct7sbD9aZLl85tY+YcOXI4et3wpD+6jXp9fHzCfU9k5tAZT0idg3ZhrSu0fen81938hRY0DWt/8oSY+5D9VRjg4NWofvrpp3DHE9V54XoZZGFg05lzkMTd3ERlfxYtWtR8H9lriDcGjvldZs+eiIzDHX6fIrLPw2tm7/p6aMvkbwgDJO7w+A8P38MgozNebSx79uyhvt/1amR8zO94VI5T1+9laPsysr9tsfX7xkAHe0AxgMzvBHsR8bd/ypQpERpTaMsPbSwMLrEnE/vYhSaq3wf+Hnz33XfmiorsG8cAEv9bxBvXW6hQIXzzzTePfY6/t1ZPudC0atXKjJv/zeN3i/2/+H1iLy5iT0ErWGhh8JJB1oiMPSLzZx1joa0rMr/r4f1ehPXbKiIiIiLuqdF5DOG/rPJ/StevX2/+J9wVG/CyaS5Pvvgv0tOmTTNXwvr777/Nv/byRIn/Is1/reWNy2Oz34hkW7ji5xlEcP6fcp44bd261fxPuWszYj52/Z/1yGQNOZ+YMGugWLFiplkw/0edTZl5ItKoUSPcvHnTvCe0k43o/A89x3/79m2zDGsO+S/hvCpYaFlJUV23tb+c55gnXbxiXnQxCOmcscLt4GOrWTOxuTubinOb+S/9zu9nY2qeqOXLly9K63feJu5bzqnVBJjNhMeOHWuaALPZMl8P68QxuvuTzaCtfckbs5X+++8/xDQGc/755x8TMP70008xefJk813hdy+8cbjbRgZAeKy7Zs1E9rsaGQySOY/R+RZeAI2YXcRMRuvCAMQxOGcdub7feYw8Pnlz9/6YPE7Tp09vAkHOc7Z//36ThcNMIS7TuTk7s3l4nEb1943Ldt43XC+/D2wafunSJfNdZDYQL7zAxtmx+X1gVh230dqv3E7+dyQiwlo3s6F43PM7zWwiZgGxcT0vHMD1crsyZ87sWC+/D2xKz2WGt038/ef3iAFtBr74DzZLly41+5G/dbyQgrVcrpNN6rmdvAIkv0POV3Pkf1uiIrx1xeTvhYiIiIhEnoJScYT/Ys4rNzEziv+ivnv3bvOvwSxlYACK5RLDhg0zVxVixgKzjHgyZZV3MIOKn3MtsXGHV2j6/fffzZXPuAzrSlYseWGGC69ex/+x5v+Q88p5PNHiv/pHBa9Cxys+8cSGZXq8shuDFgy+sfyDJyA8ieEJDi83T6EFiazSH44nvH+Bd8WTGF5Vj1ct5L/48wSbV7vi+HhSEh5r3Tzxsa6iFxruL2bOjBo1yqyL+5InX7waYHTxeGA5p/O/ynO5gwYNwsGDB83xwbI9XnGKNwbIeKzwtQ0bNpjji1kbEdlmd3iSzWwJ7gOW3XAdLL1iKQ3Xwe3lcfPJJ5+Y7Q4r4Mc55dXGonJlKh6nvCIYx8MSL14VkDfnkr2w8PvCQEhEThQZeOO+ZECZJ8GLFi1Czpw5TfAjvHFwGxmc4DFusUphS5Qo4SjJDO14Duu7GpdYhsQTdX5nWJrJY4z72vpd4H7mSb2VdcIgAwOVvNomjxUegywBcy63ssT0cco5Y9YLl8Oxct+xtMv6HeWy+T3huHiFTe5LjiEqGHxi9hN/e7mee/fumau78fvA3xYGo7nvOQ/8R4nwvg8MtPC4jGyZKTOOGDBkphSPr1WrVpnxRDST1t1xauE+4JXtmA3F45/ZP/ze8reIJWosieM8ct/xv1m8OiCXx8B8eL/ZnDf+7vN17iuOm8slfrc+//xzk3XEOeEV7fjfSGZmMRjGdfM3iJ9du3atCYRFVVjriujvCcfP34qwfi9EREREJPIUlIpDDFzwpIYneixfYBkUM16sy48zw4pZRcyg4r/488TQKjXhSSBPevg/0+FhRgsDRbwENk9m+K/9EydONBkT7OnBfw3n/+DzNeuki0GdqOCJLEt2uE38F2P+6zP7jzAoxfvMBGvRooUJYrzxxhvmvc7ZB874r/EcE/81nSd5kcWsKAbxeAJi9UdhaUVEMPuBJ67s78MTp/DwZIlBB66H5Si8PDjnNbq4nFu3boX4F3zOI0/+WPrIy77zLwN/PDasshoeM7179zb9YKzgX1Qw24tzZpVb8pi1AgE88efcct3MnmBvMvbRCQ3LNrkd3KeRLavjurg/WULEY5YBT2Zp8diOCAYnGAhlFkt4XnjhBRNk5Ik318VtYu8szm9442AGIDOjeIxbATBmTbD3j9Ujid8N17KuiHxX45J1LDHwxP44DJRxTOxxRCzDZZDAytjj9vE443t4rLAMigG1sJYdU8cpy6AbN25sfie4bgYEGIgi9uNi1hJ/R/ka/zGAQUR35YERwaw1Br94fPC4mDp1qgnicPt5/A8fPtzst3nz5pmAEY+B0IKwDC4zS4el3qH9BoaGxxJ7gzGgwrHwvwM8btmnMCLcHacWfs+/+uorx2819wv3Efc39x2/C/ws9x17d9WtW9fx36HwfrP5Dy3MGOTvBz/PclAG2In/DeR3g/PGbeJvyg8//OAoqePxxGAQP8fl8LiMaImdq/DWFR6On78DnKewfi9EREREJPI82O08Cp8TMSdiEyZMMP/6LDGHAUoG13r06BGn08oTcK5TTXujhyewPAF2bgIvifN7SAyoS9ziP96sW7fOlGVagShecIABev33RkRERCRpUaaUSALD7B5mqoR29SdJuFhaxWwiZlCISNQww43ZqMzEY4kcM/V4v0mTJppSERERkSRGV99LZFhiYf0LvjssnWMZnUQdy3L4r/ShsUp2Ygsvcc9yG2aiuV6tUCKHfZF4lcvQsDyNjZ1jCk+cWSIU1TIjEbFfRY/fJZbMsWSS5Yv8zY2JEmkRERERSVhUvpfIsJms66XYnbEXTUQuAS+hY0Nglo+Ehs2FrX5BkrCx8bTzlQtdsXcbGzmLiIiIiIhI3FNQSkRERERERERE4px6SomIiIiIiIiISJxTUEpEREREREREROKcglIiIiIiIiIiIhLnFJQSEREREREREZE4p6CUiIiIiIiIiIjEOQWlREREREREREQkznnH/SoTn+DgYFy6dAm+vr7w8PCI7+GIiIiIiIiIiCRYNpsNd+7cQfbs2eHpGXo+lIJSEcCAVN26dWNy/4iIiIiIiIiIJGmrVq1Czpw5Q31dQakIYIaUNZlp06aNub0jIiIiIiIiIpLE+Pv7m+QeK54SGgWlIsAq2WNASkEpEREREREREZHwhdcCSY3ORUREREREREQkzikoJSIiIiIiIiIicU5BKRERERERERERiXPqKSUiIiIiIiKSyAUFBeHhw4fxPQxJJnx8fODl5RXt5SgoJSIiIiIiIpJI2Ww2XLhwATdu3IjvoUgykzFjRuTMmTPcZubJIijFL+JXX32FX3/9FYGBgWjSpAkGDx6MlClTmtdHjhyJadOmhfjMkCFD8OKLL8bTiEVERERERESixwpIZc+eHWnSpIlWgEAkovGXu3fv4tKlS+Zxrly5ojxxSSYoNWnSJMyYMQPjx4+Hr68v+vTpgwkTJpi/dPToUXP/mWeecXwmbdq08ThiERERERERkeiV7FkBqSxZsmgqJc6kTp3a/GVgisdfVEv5PJPKF3Hq1Kno168fqlevjnLlyqFnz57Yu3ev4z0MSpUqVQrZsmVz3KxJFBEREREREUlsrB5SzJASiWvWcRedXmZJIih1+PBhXL9+HQ0bNnQ816pVK0yZMsXc9/f3x8WLF1GgQAEkZ4FBwfjv0GVcvX0vvociIiIiIiIiMUQle5JYj7skEZQ6c+YMMmTIgG3btqFNmzaoW7cuRo0ahQcPHjiypDhZEydORJ06dUzAav78+Uhutp68jsV/zMXFHzsDd6/F93BEREREREREJBlLND2l7t+/b7Kd3Ll9+7Z5fezYsRgwYACCg4MxdOhQ85fNzI8dO2aCUoUKFTKNzTdv3myeZ0+pRo0aIbnw8QxC63sL4BtwFVj4FtBgKJC9RHwPS0RERERERESSoUSTKbVz5040btzY7S1FihQmKMWr7bGnVM2aNdG/f3/Mnj3bBKaYPbV+/Xq8/PLLKFGiBF566SV07NgRM2fORHKSK1M6TPLthku2TLDdOgcseANYMx7wvxzfQxMREREREZFkgtVOxYsXN3/jEte5ceNGc79+/fqYN29enK5fEnGmVNWqVXHw4EG3r23atMn8ZSaUpWDBgggICMC1a9eQNWtWZMyYMcRn+N4NGzYgOcmWNiWuemfHWN/emJJ/A9Kc/AfYuwA48CdQogVQsTPgqys2iIiIiIiISNI2Z84cNYhPABJNplRYeFU9Hx8fHDhwwPEc+0j5+vqaYNQXX3yBLl26hPgM3+scxEoOvL08kStDatzxTIu9Jd4Gnh4P5CoHBD0E9i0EHt6J7yGKiIiIiIiIxLrMmTMjVapUmul4liSCUuwN1aFDB4wYMQI7duzA9u3bMWbMGLRv3x7e3t6oV6+e6SP1ww8/4NSpU5gxYwYWLFhgyvmSm1K505u/e87eBPwqAa2+Alp+DjzxCpAx36M3MoPq2rH4G6iIiIiIiIhEic1mw/2HQXF64zoja8mSJeZiZJUqVcIHH3zguFgZW/E0bdoUZcqUMVVTw4cPR1BQkHnt3Llz5ly+YsWKpn0P4wAPHz50bPfXX3+NWrVq4YknnkD37t3N+91xLt9ji59vv/0Wr7zyCsqVK4cmTZpg9erVjvfeunUL77//vhknl811soWQJKPyvfCwh9To0aPRrVs3cyDyCnt9+vQxr/GgYrbUl19+af76+fmZpug8iJObsnkyYNm+i9h47Bq61Chgv4Rj7or2m+XmWWDtF4AtGChQC6j0PyBbsfgctoiIiIiIiEQAz4f7ztmFAxdux+l8lcyVDp+2K2c/x4ygWbNmYfz48Sbg1LdvX3z33XcmCDVy5Ehzfs+qqD179piAEANQ7CnNgFCaNGlMosnVq1fx9ttvmyqoF154AdOnT8eiRYvM+T7b+EyZMsUEsPgcq6vCMnHiRHPBNN74eV4cbeXKlfD09MSgQYNM4It9qdkmiOP78MMP8dFHH8XAzCVvSSYoxWbnPFB4c6dhw4bmltxVLZgZKbw9cfbGPRy66I/iOdO5fyODUSdWAyfW2G9FGgBPvgakzxXXQxYREREREZFIiERcKF4NHDgQlStXNvffeecdU/HESqdRo0aZABTlyZMHU6dOxeHDh81zZ8+eRenSpZE7d27kz58f33//PdKnt1cETZ482QSVGNgiBo6Y2cSsJ2ZGhaVu3bpo27atuf/GG2+gdevWuHz5sglCLV++3PSyTpfOfv7MwBgvqDZgwADHc5LMg1ISMWlSeKNG4Sz49+Bl/LHrHIrnLP74mzL4AY1HANeOA9unAUdW2G/HVgGl2wCVuwAp9cUTERERERFJaJipxIylgMDgOF1vSm/PSGVJWVVNFmZFXblyBXnz5jW9nljpdOTIEXPBs5MnT5rgEr366qsmmLVs2TJT+te8eXPz2Tt37uDChQvo1auXyW6ysMzuxIkT4Y6lQIECIVoEUWBgoOlXHRwcbNbljM9xXCwxlKhTUCoZal0htwlK/XfoMl6omh85M4TS3C1zQaDBB0D5TsDGicCZLcChv+3lfCIiIiIiIpIgMTiUyscLCZ1z8MjqScV+0L179zaZSLVr18Zbb71lekpZ2KqHpXzMXvr3339N+d5rr71m+kERW/YULFgwxHoyZMgQ7ljclfdxTCwtZDbU3LlzH3s9R44ckdxiSZKNziVyimRPh8r5MyHYBszddib8D2QtCrQYa7/VfAdIZU+NNC7t1/SLiIiIiIhIpB06dMhxf9euXciZMyd+//13tGvXzpTe8eJlhQsXNhcss4JW7EHFXlKdOnUyPajeffddLF261JTwZcmSxZTcsayPt1y5cpneVMePH4/y3mGA6/bt2ybQZy2X2VefffaZozG7RJ2CUsnUs5XzmL/L91/EFf+AiH0ozxNA0UaPHp9cB8zvDiwZCNxyf0UDEREREREREXfYm2nnzp1Yu3atKdfr0qULMmbMiO3bt5uyPfaR4kXNGGiyAkDHjh0zAasDBw6Y11etWmXK94if//zzz02DcpbsDR48GNu2bTON0KOKQTFmbL333nsmcLZ3717TS+ru3buOXlYSdSrfS6bK+GVAqVzpse/8LSzYfhav1o7Cl/TGKcDDEzi5FjizGSjfEajwIuATSjmgiIiIiIiIyP9jthObivPKdh06dMD//vc/01eKQZ+OHTua3k5sQM737d9vr9IZNmyYKed76aWXTM+np556ynHBM5bwsbfUBx98AH9/f9Pv6YcffohQ+V5YmBXFK+4x6OXt7W2CVAx4SfR52KwcOAkVD2ZeEWDr1q2OhmdJwdaT1zHs973manxT/vckMqQJ+xKZbrEZ+rqvgLNb7Y/T5wZq97FnVYmIiIiIiEisYRkZS9NYYsbm4CIJ5fiLaBxF5XvJWKV8GVEke1o8CAzG7zvPRm0hbIbOXlONhgO+2exlfH/2ATZMjOnhioiIiIiIiEgSoqBUMsZGbe2fsPeWWrTrPPwDAqO6IKDQU0CHn4Ey7ewlfbnKx+xgRURERERERCRJUVAqmatWMAvyZU6Dew+CsHjX+egtLEUaoObbQMdpQP7qIRui3zgd7bGKiIiIiIiISNKhoFQy5+npgWf/P1tq4c6zCAgMiv5CM9iXZ9y5CqwcBczpCmybBgRFMRtLRERERERERJIUBaUEdYpmQ470KXHrXiD+PXg5ZmfEFgzkKAUEPQQ2TwYWvAFcPapZFxEREREREUnmFJQSeHl64Olyuc1M/L7jHGL0goxpswHNPgPqDQJSpgOuHALmdQO2TLUHqkREREREREQkWVJQSoxGpXIgtY8XTl27i51nbsbsrLARerHGQPufgAK1gOBAYOuP9qypwAfaAyIiIiIiIiLJkIJSYvim9EaDktnN/YU7zsbOrPhmARqPBBp8AKRKb79Cn3cK7QERERERERGRZMg7vgcgCcfT5XPjz93nseXEdZy5fhd5MqWJ+ZUwa6pIAyB3RcAn9aPnb54BAvyB7CVifp0iIiIiIiIikuAoU0oc/DKmxpMFMpv7i3aej92ZSZP5UVAqOBhY9am9nG/TJPWaEhEREREREZw5cwbFixc3f+n06dNYtWqV29fiW//+/c2NvvrqK7z00kuO1/i4cuXKeOKJJ/Dzzz+jfv360V7fgwcPMGvWLMdjro/rSWwUlJIQWpW3Nzxfsf8i7gQExs3sBAUAvtnsV+rbPh2Y/7qu0CciIiIiIpLM5cqVC2vWrDF/aeDAgdi1axcSupdfftkRILp58yYmTJiAfv36YeHChejQoQPmzJkT7XX8+eefmDhxouMx18f1JjYKSkkI5fJkQL7MaRAQGIyVBy7FzewwY4p9php9CKTKYA9I8Qp9DFAFB2kPiYiIiIiIJENeXl7Ili2b+ZuY+Pr6ImPGjOa+v7+/+Vu9enX4+fkhVapUyJzZXqEUHTabLcRjro/rTWwUlJIQPDw80KxsTnP/rz3nHzvQY1WhukD7Hx9doY+lfL/3BO5e014SERERERGJjIf3Qr+5XgU9zPcGROy9kdCqVStMnz7d8bhr16548cUXHY9/++03dOrUKUSJHkvjNm3aZLKOnEvjli9fjoYNG6J8+fLo3r27yUxyh5lEffv2xYgRI1CxYkVTQscsLI6jRo0aqFatmimts3A5Q4YMMa+x9O79998PsewtW7agTZs2KFeuHN555x3cu/doDqzyPY7bKtXjGLkN8+bNC1G+t2vXLrOtHH+TJk1MBpRl9uzZaNq0KcqUKYOqVati+PDhCAoKwsaNGzFgwACcPXvWMT+u5XtcT7Nmzcz42rZti82bNzte4/p/+eUXk7VVtmxZtG7dGnv27HG8znmoV6+eeY2f5bbGFgWl5DH1S2RHKh9PnL52D3vO3orbGWKvKV6h76kBQApf+w9gynTaSyIiIiIiIpExpWnot2VDQr735zahv3fx+yHfO6Oj+/dFQq1atUyAiR4+fIgdO3Zg9+7d5j6tXbsWtWvXDvGZQYMGmWCSc2kczZ8/H+PGjTOBlL1792LSpEmhrnfx4sVIly6dKaNjsObdd981galp06aZoM6nn36Ka9fsSRE9evTA/v37TYnc1KlTcfToUUfPKL7n9ddfNwGrBQsWoEiRIliyZMlj62PZIQNLxL/cBmdXr14121OyZEmzHVwmy/wOHDhg5mfkyJHo3bu3WTYDUiz7W7FihZkHljLmzJkzRHmjc0CKwTcuj+PjOLt164aLFy863sM55HO///67mROui/bt24fPPvsMQ4cOxV9//WX6YHGegtkLOhYoKCWPSZPCG08Vz27uL94Tyw3PQ7tCX/Gm9qyphkMBLx/780GBgP/luB+PiIiIiIiIxBgGpZi5w8ocBpLy5cuH9OnTm4AIgx/MBHINSjFw4uPjgzRp0jhK44gZTAwwMdOImUEM6IQmU6ZMJquJ63vmmWdw+/ZtEygqXLgwXnnlFQQGBuLkyZOOoNDo0aPNsnnj/ZUrV+LYsWMmWMMSPK67UKFC6Nmzp8kqcsWyQ6tUj3+5Dc7+/PNPZMiQAYMHDzbLYVZSnz59cP/+fbOdo0aNQuPGjZEnTx6TMVWqVCkcPnwYKVKkMMsKrbzRCrIxk4vLfe+991CsWLEQ2WncfmZvFSxY0GSqWZlSzL5iBVXu3LnNehmQ4rbHVlDKO1aWKoleszI5sWTPBaw7ehXX7jxAZt8UcT+ItPbAmMP2acDu2UCNnkCxpvbglYiIiIiIiDzu5cczdxw8XHo0dV4Qxntdclme/y3as83sG5a7McDC4BQfX7p0CVu3bjUBFk9PT1OyxgBJeBhgsjBQExDgUm7ohEEWBlyIvZ2IfZ6cH/OqdufPnzdBMgZsLAxcMYDEoNSRI0dQokQJx7KIQSnnEr6IOH78uAk0cXstDBBZOKYvv/zSrO/gwYMmYMaAXniY1fXWW2+FeK5ChQrmeUuBAgUc99OmTevIUuPyGcBq2bKlGVuDBg3Qvn17eHvHTvhImVLiVqFsaVEiZzoEB9uwbN+F+J8lRmXPbQce3AH+/QT4e5B6TYmIiIiIiIR1QanQbt4pIvHelBF7byQw04eBKGYjsV8Rezbxtm3bNqxfvx41a9YMEfAJi3NAJzzuAivuPs/xucN+TryRa/9lZnFFlncYgZ7Vq1ebzKkrV66YrDEGpypVqhSh5aZMmdLt2J2znUIbb+rUqU2p4U8//YQqVaqYUkCOw7n0LyYpKCWhal7OXpf6154LCAqOw4bn7vCH4unPgSrdAE9v4ORaYHYX4Niq+B2XiIiIiIiIRJrVV4r9pJyDUuyR5Fq6F9eYIXXr1i2TFWVhthKvpMfXihYtakoNrQAVsf9UZBUoUMBkQDkHuFguN3nyZBMYateuHT788EOTqcRMrVOnTjneG1bQjmPcuXNniOf42DnzKzTbt2/Hd999Zxq/s5k6+1kx+4xZbLFBQSkJVc3CWZE+tTeu+j/A5hMJ4Ap4DExVfAFo+z2QpQhw/yaw7ANg5Ujgfhw3ZBcREREREZFoBaXYo4mlYzly5DClYix/YzlfaEEp9lk6ceKEaRAemxgAqlOnjmk6zqvj8cb7Tz75pClta9GihRkrez4xcMUgUlSCNi1btsSNGzdMY3FuF7OS2MicmWLsm8UAEYNWLHNkk/XLly+b8kIro4lXA+Tn2AvLWZcuXUz/KDY5Z4ngmDFjTJ+sZ599NtwxsWTw66+/NkExXtWPfa/u3r1rrvIXGxSUklCl8PZEo5I5zP3Fu+Oh4XloshQGnpkIVHzRXt98/D97gEpEREREREQSBV6xLkuWLCZDithLileVY68mqzm4K2YMsazt1VdfjfXx8Up8efPmNQEeNkFndhSDNcTeUgxE8YqBrVu3xrp168zfyEqfPr3JSmIJ49NPP22uHDh27FhzNT5e/Y/z07FjR9NniiV5nTp1cmRkMZMpf/78JrDlmqXVvHlz9OrVy5T8tWrVymSkTZkyxQTbwsN1M9jG7WPjeF59kI3OI/LZqPCwuRZCymOYoscvCiOfjOImJxdv3cdrP28Bj5KJL1WGX8bI1QrHuot7gVvngaINHz0XHAR4ujTuExERERERSWJ4lTZmwrAsy2rULZIQjr+IxlGUKSVhypE+FSrly2Tu/5WQsqUsOUqHDEid3wXM6gxcsF/OUkREREREREQSJgWlJFzNy9obnq/YfwkBgY8auSVImycDN88Av/cENk0CguyXtRQRERERERGRhEVBKQnXE/kzIXu6lPAPCMSaw1cS9ow1GQUUbQzYgoHt04H53YGrR+N7VCIiIiIiIiLiQkEpCZenpwealMlp7i/efSFhz1jKdED9QUCjD4FUGYCrR4D5rwM7ZgLBwfE9OhERERERERFJakEp9mtnZ/kaNWqgSpUqGDJkCAICAhyvnzt3Dq+99hrKly+PRo0aYfHixfE63sSmcakc8PL0wKGLt3Hkkj8SvEJ1gfY/Avlr2kv4Nk4ETq6N71GJiIiIiIjEuGD9A7wk0uPOG0kEL504Y8YMjB8/Hr6+vujTpw8mTJhg/gYGBuL1119Hnjx5MH/+fHM5xL59+5pLUBYrViy+h54oZEyTAjWLZMF/h66Yhuc9GxRFgpcms72c7+BfwLltQIFa8T0iERERERGRGJMiRQp4enqaJIxs2bKZxx4eHpphifWkoAcPHuDy5cvm+ONxl6yDUkFBQZg6dSr69euH6tWrm+d69uyJBQsWmPurVq3C+fPnMXPmTHMpwkKFCuG///7D9u3bFZSKhGZlcpmg1KpDl9G1VkGkTZkIDh/+IJdobr9ZAm4D6yYAVV4DfLPG5+hERERERESijAGBggULmvNdBqZE4lKaNGmQL18+cxxGVSKIKoTv8OHDuH79Oho2bOh4rlWrVuZGzIxisIoBKcs333wTL2NNzErnTo98mdPg1LW7WHngElqVz41Eaf03wKEl9nK+Wr2AIg3ie0QiIiIiIiJRwiwVBgZYIcSEDZG44OXlBW9v72hn5iWJoNSZM2eQIUMGbNu2zZTvMUDVuHFjvP/+++YLevr0afj5+WHMmDFYuHAhMmXKhLfffjtEEEvCx4OtedlcmLjqKJbsOY+W5XIlztTQch2Aa0eByweBFR8CJ9YAtd61N0YXERERERFJZHhe5uPjY24iiUmiaXR+//59nDx50u3t9u3b5vWxY8eaEr6PPvoI//zzDz799FPz2bt375peUrdu3cLEiRPRpk0bE5TavXt3fG9WolOvRDak8vHE6Wv3sOfsLSRKmQsCrb8BKncBPDyBoyuB2V2BUxvje2QiIiIiIiIiyUaiyZTauXMnOnfu7Pa1cePGmaDU4MGDzZX3qH///ujduzcGDRpk0soyZsyIYcOGmVrH0qVLY8uWLZg1axbKli0bx1uSuKVJ4Y2nimfHkj0X8Ofu8yibJ5FmF3l5A090BfJVB/4ZBdw4BfzVF6jbFyjRIr5HJyIiIiIiIpLkJZqgVNWqVXHw4EG3r7FnFLGBuYXN3gICAnDt2jVkz57dpDM6N9/i66EtT8LWrExOE5Raf+wqrt15gMy+Ue+0H++ylwDaTQY2TQKO/asr9ImIiIiIiIjEkURTvheWUqVKmdrZAwcOOJ47evQofH19TYZU+fLlTTN056ZvfJ19piTyCmVLixI50yE42IZl+y4k/in0TgnU6AG0//FRXymbDTj0NxD4IL5HJyIiIiIiIpIkJYmgFK+q16FDB4wYMQI7duzA9u3bTVPz9u3bm27wTz/9NIKDgzF8+HDTg+qXX37B6tWrzWckatjwnP7acwFBwbakMY0pH12dEYeXAf98BMzvBlw5Ep+jEhEREREREUmSkkRQyuohVadOHXTr1s3cateujT59+jiCVlOnTsWxY8dMgOrnn382V+ljbymJmppFsiJ9am9c9X+AzSeuJb1pZIAqdUbg2nFg/uvAtmlAsC6vKiIiIiIiIhJTPGw21ilJWPz9/VG5cmVs3brVBLjEbura45i37Swq5cuI4a3LJL1puXsNWDMOOL7a/jhHaeCpAUDGvPE9MhEREREREZFEH0dJMplSEvealckFDw9g26kbOHfjXtLbBWkyA41GAPUGAil8gYt7gbmvAIeWxvfIRERERERERBI9BaUkynJmSIVK+TKZ+7waX5LEqFuxJsCzUwG/ykBgAJA2W3yPSkRERERERCTRU1BKoqVZmZzm77J9FxEQmIR7LqXLATQfA7T6Eshd8dHzN8/ar9QnIiIiIiIiIpGioJREy5MFMiNbupTwDwjE2iNXkvZsenoCucqHDEixnG/ZB8C96/E5MhEREREREZFER0Epid4B5OmBpqXt2VKLdyfREr7QsMdU0APg+H/A7K7AibXxPSIRERERERGRRENBKYm2xqVzwMvTAwcv3MbRy/7JZ0aLNQbaTAQyFbBnSv09EFj1GfDgTnyPTERERERERCTBU1BKoi1jmhSoUTiLuf/X7vPJa0azFQPaTgLKP2dvin7gT2DOy8C5HfE9MhEREREREZEETUEpiRHNy+Yyf/85eBm37z9MXrPqnQKo9gbw9OdAulzA7QvAmc3xPSoRERERERGRBE1BKYkRpXOnR8GsvngQGIyley8mz1nNXQF4dgrwRFegcpdHzwc+iM9RiYiIiIiIiCRICkpJjPDw8EDL8rnN/T92nUNQsC15zmyKNPaAlJeP/XFQIPB7D2DN58CDu/E9OhEREREREZEEQ0EpiTF1i2VDhtQ+uOL/ABuOXdXMEsv4Lh8E9s6395o6u1XzIiIiIiIiIqKglMSkFN6eaFImp7n/+45zmlzKXx1oMRZImwO4fR74ozewepyypkRERERERCTZU6aUxKjmZXLC09MD+87fwpFL/ppdyvME0P5HoFRr+3zsWwjM6QqcUdaUiIiIiIiIJF8KSkmMypI2JWoXyWru/75T2VIhek3V7g08Pe7RFfq2TAFsybT3loiIiIiIiCR7CkpJjGtVwd7wfPXhy7hxV1eeC8Gvsv0KfWWfBZ7qxw7x9ucVnBIREREREZFkRkEpiXHFcqRD8ZzpEBhkw+LdFzTD7rKmavQEMuZ79NyGb4F/PwUCbmu+REREREREJFlQUEpiRavy9mypv/acx4PAYM1yWFjKt3s2cHAxMLsrcHK95ktERERERESSPAWlJFbUKJwFWdKmwI27D7HmyGXNcljS5QRafg5kyAPcuQws6Q+s+BC4d13zJiIiIiIiIkmWglISK7y9PNG8TC5zf+GOc7CpZ1LYcpUH2v0AlOsIeHgCR1YAszoDh5aq35SIiIiIiIgkSQpKSaxpWjYnUnh74tjlO9h15qZmOjw+qYDqbwJtvgWyFAHu3wLWfgHcv6G5ExERERERkSRHQSmJNelT+aBRqRzm/rxtZzTTEZW9BPDMd0CVbkD1t4DUmR69Fqz+XCIiIiIiIpI0KCglsapNBT94egDbTt3A8St3NNsR5eUNVHwBKNH80XNsgL7wLeDaMc2jiIiIiIiIJHoKSkmsypkhFWoUyWruz1e2VNSxJ9em74BL+4C5rwFbpgCBD2JsP4mIiIiIiIjENQWlJNa1rehn/q46fAWXbwdoxqPCwwNoNhrIXxMIDgS2/gTMexW4sEfzKSIiIiIiIomSglIS64rmSIcyfhkQHGzDwh1nNeNRlTYb0GQU0HCYvc/U9ZPA7z2ANZ8DD+5qXkVERERERCRRUVBK4kS7SvZsqaV7L8I/IFCzHp2MqcL1gA4/A8Wb2cv69s4HLuzSnIqIiIiIiEiioqCUxInK+TMhX5Y0uPcwCEv2XNCsR1eq9MBT/YEW44Cy7YF81R69FvRQ8ysiIiIiIiIJnoJSEic8PDwcvaV+33kODwKDNfMxIU9loEaPR4/vXgNmdgJ2/gYEB2mORUREREREJMFSUEriTJ1i2ZAlbQpcv/MA/xy8pJmPDfsXAXcuAxu+AeZ1Ay7u0zyLiIiIiIhIgqSglMQZHy9PtKlgz5aas/UMgoJtmv2YVvEloG4/IGU64OoRYOGbwJrxQIC/5lpEREREREQSFAWlJE41LZMT6VJ548LN+/jv8GXNfkzz9ARKNAc6TgOKNfn/RugLgFkvAUf/0XyLiIiIiIhIgpFkglI2mw1ffvklatSogSpVqmDIkCEICAgwr/Xv3x/Fixd/7Na5c+f4Hnayk8rHy5EtNXvLaQQrWyp2pM4E1BsIPD0OyJDH3mtKV+gTERERERGRBCTJBKUmTZqEGTNmYOzYsZg8eTI2bNiACRMmmNcGDRqENWvWOG6//fYbUqRIoaBUPGlRLhfSpPDC6Wv3sOHY1fgaRvLgVxl4dipQ9XXgyVcfPc8gla7SJyIiIiIiIvHIO7ZXsG7dOqxevRp79+7FtWvXzFXYsmXLhlKlSqFOnTomqym6goKCMHXqVPTr1w/Vq1c3z/Xs2RMLFiww99OlS2duFmZONW3aFA0bNoz2uiXyfFN6o2X53Pht82n8uvk0qhfOYo4LiSXeKYAKzz96zJK+5cOAe9eBmu/ar+AnIiIiIiIiklSCUvPnz8fEiRNx584dEyiqWbMmMmbMiODgYFy/fh0HDx7Ee++9hzRp0uC1115Du3btoryuw4cPm2U6B5latWplbq7Wr1+PzZs34++//47y+iT6WlXIjYU7zuL4lTvYcvI6niyQWdMaV26fB26csgel/uwNFK4PVHsTSJtN+0BEREREREQSd1DqpZdeQp48eTB69GiUK1cuzPdu2rTJlNPNmzcPv/zyS5TWd+bMGWTIkAHbtm3D+PHjTYCqcePGeP/9902ZnrPvv/8ezzzzDHLlyhWldUnMSJ/KB83L5sK8bWfx66bTeCJ/JmVLxZX0ue2N0LdMsTdBP7oSOLUeqPQ/oOyzgJdPnA1FREREREREkq9YCUoNHz4chQoVitB7Wb7H29GjR8N83/3793Hx4kW3r92+fdu8zn5SAwYMMNlYQ4cONX/Z8Nxy+vRp02uKPaYk/rHh+aKd53Do4m3sPHMTFfJmjO8hJR8p0wE13wGKtwDWjAcu7gE2TgQO/QU0+wxIlzO+RygiIiIiIiJJXKwEpf755x/4+voiR44cEf5M4cKFw3x9586doTYmHzdunAlKDR482NGjin2jevfubQJQnp72fu4s2StZsiSKFCkSqe2R2JHJNwWalM6JP3adx2+bTykoFR+yFgFafQUc/tselPLwBNJkjZehiIiIiIiISPISK0GpWbNmmaylypUro2XLlmjSpIkpr4uOqlWrmj5UoZUAknN2VsGCBREQEGCaq2fNaj/JZsP1Bg0aRGscErPaVc6DJXsvYM/ZW9h5+gbKK1sq7jFoW7wZkL+mvc+U1///LAQ+sGdOMZvKek5EREREREQkhthTiGIYM5LmzJmDihUrYvLkyahVqxbeeOMNLF682ASKYhqv5Ofj44MDBw44nmM5ILO12FydbDYbdu/ejUqVKsX4+iXqsqZNabKlaPqGk2Y/STxJlR7IlP/R412/AavHAXNfAc5u024RERERERGRhB+UsgJFLJ9bunQpZs6cacrzWGbHK/GxAfmqVasQFBQUI+tKmzYtOnTogBEjRmDHjh3Yvn07xowZg/bt28Pb257hcfbsWXMlQJXuJTwdnsgLHy8PHLhwG9tOXY/v4YiFfaVSZwSunwD+6AUsHwbcdt/XTURERERERCSyPGxxnJrCbKXly5dj2bJluHHjBtatWxcjy33w4IG52t/ChQtNtk2rVq3Qr18/x9X32JOKgSuu3/WKfOHx9/c3pYhbt241ATCJeT+sOY4F28+iaPa0GNuhvK7El1Dcv2W/St++hYAtGPBKAVR4HijfCfBJFd+jExERERERkQQoonGUWMuUcof9nVhix9v58+eRP79TqVA0MdDEpubsL7V582Zz1T3n4FP58uVNT6rIBqQkbjxbKQ9S+Xji8CV/bDx+TdOekEr6ar0LtJ0E5CoPBD0Atv4IrP0ivkcmIiIiIiIiiVysdy++ePGiKeHjbdu2bShatCiaN2+OoUOHInfu3LG9ekkkMqTxQavyuTFryxnTW6pKgczw9PSI72GJ81X6Wn4BHPsX2DzZni1lYbKlh/aViIiIiIiIJICg1KlTpxyBqD179sDPzw8tWrQwgSj1dJLQtKnoh0W7zuPk1btYe/QKahfNpslKSBh4KlwPKFjXfsU+y+ox9r9PvAKkyRxvwxMREREREZHEJVaCUo0bN0a2bNnQtGlTDB48GOXKlYuN1UgSky6VD9pU8MPMTacwY+Mp1CycVdlSCZFzQOrWeeDAYnu/qaP/ApW7AKXbAF4+8TlCERERERERSa5BqalTp6Jq1arwdD55FYmA1hVyY9HOczhz/R5WHLiERqVyaN4SsvS57GV9674ErhwG1k8A9i8EqvcE8lWN79GJiIiIiIhIcgtKVa9e3XH/7t27mD17No4dO2aukOfq448/jo0hSCLlm9IbHZ7MgylrTuCXjSdRu2hWpPLxiu9hSVhylQOe+R44uBjYPAm4cRr4qy+QtypQ5z0gbXbNn4iIiIiIiDwm1lOZevfujW+++Qa3bt2K7VVJEtGibG5kS5cSV/0fmKwpSQSYFVnyaaDjL0C5joCnF3B5P+CTOr5HJiIiIiIiIsn16nsbN27ElClTULFixdhelSQRKbw98VK1/Bi37BDmbD2DJmVyIn0q9ShKFFKmBaq/CZRsCdw6B6RM9+gKfQf/AgrXB3xSxfcoRUREREREJDlkShUqVAj379+P7dVIElO3WDYUzOqLuw+CMGvz6fgejkRWxrwhe0od/w9Y9Snw24vAoaVAcLDmVEREREREJJmL9UypTz75BD169EDLli2RO3fux5qft2nTJraHIImQp6cH/lejAIb9vhd/7j6PluVzI0d6ZdgkWrwaX9ocgP9F4J9RwJ45QLU3gdwV4ntkIiIiIiIiklSDUrNmzcLJkycxc+ZMpEyZMsRrHh4eCkpJqCrly4jyeTNg5+mbmL7hJPo0Lq7ZSqzy1wD8KgO75wDbpwOXDwKL3gEK1AKqdrdnVomIiIiIiEiyEutBqTlz5mDcuHFo3rx5bK9KkhgGLbvUKIBev+3Evwcvo01FPxTOlja+hyVR5Z0SqPgCULwZsPVHYP8i4MQae/ZU20nc4ZpbERERERGRZCTWe0plypQJRYoUie3VSBJVJHs601+KJq8+BhsbZkviliYzULs30H6qPYOqSrdHAanAAODB3fgeoYiIiIiIiCSFoNTQoUPx4YcfYv369Th9+jTOnTsX4iYSns418psr8u05ewvrj17VhCUVmQoATT8G8lZ59BzL+359Htg7HwgKjM/RiYiIiIiISGIv33v99dfN365du5pyLAszXvh4//79sT0ESeSyp0uFtpX88Oum05iy9jieKJDZBKkkiWEWHK/Sd+86sOZzYNds4MlXgEL12Pk+vkcnIiIiIiIiiS0otWLFithehSQD7SrlwbJ9F3HxVgAWbD+LDk+qMXaSw6B166+BA4uArT8Bt84CKz4Edv5qb4aep3J8j1BERERERERiUKykH7BUz+Ln5xfmzbJu3brYGIokEal8vEzTc5q99TSu+gfE95AkNnh5A6WfAZ6bATzxMuCTBrhyCPiztz1QJSIiIiIiIkmGZ2xdce+ll17C4sWLcefOnVDfd+/ePSxcuBCdOnUynxEJCxuel8iZDvcfBuPn9Sc1WUlZijRA5f8BnWYAZZ8FvFMBhes9el0N70VERERERBI9D1ssXc5sw4YN+Pbbb7F9+3aUK1cOhQoVMlfiCw4Oxo0bN3Dw4EEcOHAAFSpUMH2natasiYTK398flStXxtatW5E2bdr4Hk6ydvjibfSetdPcH9uhPIrlSBffQ5K4cP8WkCr9o8erRtvL/Sp1BtJm1z4QERERERFJhHGUWAtKWY4dO4Y1a9Zg3759uHbtmmluniVLFpQqVQq1a9dG/vz5kdApKJWwjF92CCsPXELRHGkx5tny8PR81EBfkoFb5+1X6LMFA14+QMlWQMUXgTSZ43tkIiIiIiIigojHUWK90TkzpHgTiSn/q1EA649dxeGL/li67wKalsmlyU1O0ucCWn4BbJ4MnN8J7JkLHPgDKN0WqNAJSJUhvkcoIiIiIiIiEaDrrEuik9k3BV6sZs+w+2ndSdy4+yC+hyRxLVc5e2CqxTggR2kgMADYOROY8Rxwdpv2h4iIiIiISCKgoJQkSi3K5kKhbL7wDwjE1LUn4ns4Eh/YUypPZaD110DTT4CsRQFPLyBrMe0PERERERGRREBBKUmUvDw98OZTRUxcgv2l9py9Gd9DkvjCgyB/deCZ74E23wIp/79eme3ylgwAds2yZ1KJiIiIiIhIgqKglCRaxXOmQ5PSOc39b/89isCg4PgeksQnT08gY95Hj09vAk6uA9Z/bW+MvnuOglMiIiIiIiLJLSjFbutvv/02WrdujfPnz+P777/Hn3/+GRerliSuc/X8SJ/aG6eu3cXCHefieziSkPhVBur2BdLmAO5cAdZ9Bcx8Dtg1G3h4P75HJyIiIiIikuzFelBq6dKl6NatG/z8/HD8+HEEBgbC29sb/fv3x4wZM5L9DpDoSZfKB11rFDT3Z246hUu3FGyQ/+flDZRoAXScDtTuYw9O3b0GrJ9gD07dPKOpEhERERERScpBqQkTJmDYsGHo168fvLy8zHMvv/wyPvroI0ydOjW2Vy/JQP0S2VE6d3oEBAbjm3+PwsZeQiIW7xRAqVbAc78Add4H0uUCUmcE0uV+NEc6ZkRERERERJJeUOrkyZOoUKHCY8+XK1cOFy9ejO3VSzLg6emBHvWLwMfLA1tPXse/By/H95AkIfLyAUo+bc+cavKxvQcVsZRvdhdg+3Tgwd34HqWIiIiIiEiyEetBqSJFimD16tWPPT9//nzzmkhMyJMpDZ6rks/c//6/Y7hx94EmVkIv60uf69Hjw0uB6yeATZOAGR2AbdOAB3c0eyIiIiIiIrHMO7ZXMGDAAHTv3h0bNmzAw4cPMXHiRJM9tWfPHnz77bexvXpJRtpW9MOaw1dw/ModfPffMfRrWiK+hySJAftOeacCtv1k7zO1eTKw6zegVGug7LNA6kzxPUIREREREZEkKdYzpZ544gn89ddfKFy4MOrXr48bN26Ycr7FixejevXqsb16SUa8vTzxdoOi8PSACU6tP3o1vockiYGnF1CsMdBhGlB/CJApPxBw217ON7MTcO9GfI9QREREREQkSYr1TCnKli0b3nnnnbhYlSRzRbKnRdtKeTBn6xl8u+ooyubJgLQp4+Qwl8SOPaaKNgQK1wdOrAZ2zADSZrc3Rbfw6n1pMsfnKEVERERERJKMWD9bZ3aUh4fHY8/zOR8fHxOwatasGTp16hSt9fCKa1999RV+/fVXBAYGokmTJhg8eDBSpkxpXt+yZYu54t+xY8eQP39+czXAGjVqRGudkjA9VyUv1h29gnM37uOH1cfxTsOi8T0kSWzBqUJ1gYJ1gIf3Hj1/6zzw24tAgZpAhReBbMXic5QiIiIiIiKJXqyX77344ou4fv06WrRogUGDBmHgwIFo1aqVKeOrU6cO6tata3pLTZo0KVrr4ednzJiBsWPHYvLkyaaH1YQJE8xrV69eNX2tmjdvjkWLFpkg2JtvvokLFy7E0FZKQpLS28uU8TEWunz/RWw8pjI+iQIeQCnSPHp8ZjMQHAgcWwXMew348z3g3A5GxDW9IiIiIiIiCTFTasGCBRgxYoQJSlkaNGiA4sWLm6bnfL1kyZImq+m1116L0jqCgoIwdepUk/1k9anq2bOnWTZt27YNXl5eePXVV81jBqj4/h07dqBp06Yxsp2SsJTOnQFtKvhh/vazmPDPEZTImR4Z0vjE97AkMSvVCshZxl7Wd2SFPUjFW44yQIXngXzV7VlWIiIiIiIiEiGxfgZ16tQplCjx+FXQihYtakrpqECBAiabKaoOHz5ssrEaNmzoeI7ZWFOmTDH3M2bMaDKzli5dasr8li9fjjt37qBYMZXfJGUvVsuPfFnS4Mbdh/j63yNm34tES+ZCQP3BwHO/2INUXimAi3uAf0YBgU6lfiIiIiIiIhL/QSleaY+9nu7evet4jve//vprlCtXzjxetWqV6fMUVWfOnEGGDBlMRlSbNm1MSeCoUaPw4MEDxxUAX3jhBbz99tsoXbo03nrrLXz44YcoVKhQDGyhJFQpvD3Rp1ExeHl6mCvx/XPwUnwPSZKK9LmB2n2ATr8C5TsB5ToCKXztrzH4uW8hcP9mfI9SREREREQkeZfvsXSP5XK1a9c2GVHMVjl58iRy5cqFL7/8EmvWrDENyL/44oswl3P//n1cvHjR7Wu3b982r7Of1IABAxAcHIyhQ4eav0OGDDFZUadPn0aPHj1Qr149kzE1cuRIlC9fHoULF46lLZeEoFC2tHi+Sj5M23ASE1cdQxm/DMieLlV8D0uSCt8sQLXuIZ87tw1YPQ5Y/zVQvDlQtj2QwS++RigiIiIiIpJgedjioKaJPZ/Wr1+PQ4cOmd5OLN1j7ydege/atWvmPZkzh32Z9Y0bN6Jz585uXxs3bhx69+6NadOmoUqVKuY5lujxOfaNYvBrz549pgG6pWvXrsiXLx+GDx8e7vj9/f1RuXJlbN26FWnTpo3k1kt8Cwq2of/cXThw4TbK5smAka3LwNPz8StCisSIc9vtAakrh+2PPTyBgrWBcs8BOUppkkVEREREJMnzj2AcJdYzpYiBqFq1apmbhaV1+/fvN9lKEVG1alUcPHjQ7WubNm0yf53L8QoWLIiAgAAT9Nq7d+9jfa3YXJ29qCTpY/ler0bF8PbM7dh95qZpft6ucp74HpYkVbkrAm0n2TOmdv4GnN5ov2IfbznLAo0+BNKEHYQXERERERFJDmI9KMU+T8xGOnLkiCmncw1WMYMpukqVKgUfHx8cOHDAEfg6evQofH19TZPz7Nmzm/U7Y5P1PHkUmEgucmdMjdfqFMKElUfw84aTpoyveM508T0sSao8PAC/yvbbtWPArlnA4WXA/RtAqoyP3sffRF2xT0REREREkqlYb3TO3k1+fn6YOHEiUqdObZqeDx482ASLPvvssxhZB1PBOnToYPpXsVxv+/btGDNmDNq3bw9vb2/z97///sOPP/5oekvxL3tZPf/88zGyfkkcGpfKgVpFsyI42IbRfx/AnYDA+B6SJJcr9j3VH3j+N6DeoEdBqMAA4LcXgHUTgFvn4nuUIiIiIiIiSS9TiiVyo0ePNg3FeeU7ZjTxSnhZsmTBpEmT0Lx58xhZT//+/c16unXrZpqpt2rVCn369AlxBUD2lmJDdZb2ff/996a3lSQf7GHWo14RHL54GxdvBWDCP0fQt0lx87xIrPPNar9Zjq+2B6N2zwb2zAHy1wTKtLOX/+mYFBERERGRZCDWg1LMjmKZntXziX2h6tati3LlyuH48eMxtp4UKVJg0KBB5uZOgwYNzE2SN9+U3ni/SQn0nbsLaw5fQYW8GdGkdM74HpYkR4XrAynT2QNSpzcBJ9bYb1kK24NTRRoC3inje5QiIiIiIiKJt3yvWrVqGDt2LC5evIiKFSti8eLFuHHjBlauXIn06dPH9upFHsNeUp2r5Tf3v//vGE5dvatZkrjHMr58VYHmo4EOPwOlWgPeqYCrR4FVnwH+F7VXREREREQkSYv1oBQzl27evImlS5eiRYsWpv8TA1Uff/wx3nrrrdhevYhbz1T0Q8V8GfEgMBifLjmAew+CNFMSfzLlB2r3Bl6YDVR7Ayj5NJAx36PX98wDzu8CbDbtJRERERERSTI8bGzAFIe4Ol4Jj1lS7C+VOXPCvzS6v78/KleujK1bt5qgmiQNN+4+wNu/7sD1Ow9Qp1hWvNdY/aUkAfK/DMzoANiC7aV9zKgq0ghIkSa+RyYiIiIiIhKtOEqsZ0qVLFkS165dczxmU2k2GA8MDFSPJ4lXGdOkQL+mxeHp6YH/Dl3BH7vOa49IwsNgVPFm9v5SLO1bPQ6Y3g5Y8zlwLeb68omIiIiIiCSJRucLFizAvHnzHJlRLNNjVpSzS5cuIVu2bLGxepEIK507A16uWQCTVx/H5DXHUSR7WpTMpV5nkoCkywHU7QtU7Q4c+hvYtwC4eQbYO99+a/ABUEQXcRARERERkcQnVoJSjRo1wpkzZ8z9TZs2oUKFCvD19Q3xnjRp0pj3icS3VuVz48CF2+ZqfJ/8dQBfPFfBZFGJJCip0gPl2tuvzHduO7BvPnBmK5C3yqP3XDkMpMoIpFXAX0REREREkmlQigGoHj16mPt+fn6mwXmKFDrJl4SJJaVv1y+KE1fu4Mz1e/h0yUGMbFMGXp4e8T00EfdX7ctT2X57cAdI4RTw/28McOUQUKAWULIV4FfZ/n4REREREZHkVL7nfMK/ePHiUN/bpk2b2BiCSKSkTuGFgc1Los+sndhz9iamrDmO1+oU0ixKwuYckHpw1953ij2ojv9nv6XLBZRoDhRrpuwpERERERFJHlffq1+/fsRW7uGBFStWIKHT1feSj3VHruDjvw6Y+z3qF0GT0jnje0gikcPm5/sWAkeWAwG37c95eAJPdAUqddZsioiIiIhIgomjxEqm1MqVK2NjsSKxrkaRrHihaj78svEUvv33KPwypkYZvwyaeUk8MhcEar0LVHsDOLYKOLAIOL8LyFTg0XvuXQce3gfS54rPkYqIiIiISDIXK0EpV7zS3i+//IKjR48iKCgIhQoVQvv27VGggNNJkkgC0fHJvDh17S5WH2bW1H6M61ABOdKniu9hiUQOS/mKNbbfrp8E0vs9em3vAmDbT0CeJ4ESTwP5awJecfKfAxEREREREYdY74C7ZcsWNGnSBBs3bkSePHnMbfPmzWjdurVJ4xJJkI3PGxRFkexpceteIEb8sQ/3HgTF97BEoi5T/pBBp9sXAFZun94ELPsA+OVZYMNE4PoJzbKIiIiIiCTunlLOnn32WVSvXh19+vQJ8fyYMWNMwOrXX39FQqeeUsnTFf8A9PptB27cfYgqBTNjUPOS8NQV+SSpuHkWOLjYfrt77dHzvGJfi7GMzsbn6EREREREJBGLaBwl1jOlDh8+jHbt2rkNVu3fvz+2Vy8SZVnTpsTgFqXg4+WBTcevYfKaY4jlGK5I3MngB1R5DXh+NtB4pL2Ejw3R0+V8FJDi8X5uBxAcrD0jIiIiIiIxLtabiPj5+WHXrl2P9Y/auXMnsmbNGturF4mW4jnToVejYvhsyUEs2nke2dOlQpuKTr15RBI7lvUVrG2/MWMq6OGj1y4fBBa9A/hmA4o1sd8y5ovP0YqIiIiISBIS60GpV199FUOHDsWxY8dQrlw5R0Bq2rRp6N27d2yvXiTaahfNZkr5pqw5gR/WHEeWtCnMcyJJTprMIR/fPgekTAfcuQxsn26/5ShjD04Vrg+kDD0NV0REREREJF6CUg8fPoSPj4+537ZtW/N3+vTpmDp1KlKmTImCBQti1KhRaNasWWysXiTGtangh0u3AvDHrvMYt+wQMqVJgTJ+GTTTkrQx8JS/FnBqPXBoCXBqA3Bxj/227ivgmYlAlsLxPUoREREREUmkYqXReZUqVdC0aVM8/fTT5n5ip0bnQsHBNnyy5ADWH72KtCm98dmz5ZA3cxpNjiQfd64CR5YBB/8CHtwBnp8FeP5/a8JjqwDfrED2UmqSLiIiIiKSzPlHsNF5rASlfv/9dyxZsgRr1qxBpkyZ0Lx5c7Rq1QolS5ZEYqSglFgCAoMwaP4eHLxwG1nTpsCnz5YzfaZEkhX+Z+Pe9UflfsFBwC/P2ntSpfcDijYEijQCMuaN75GKiIiIiEhyC0o5D2L58uUmQLV27VrkzZsXLVq0QMuWLZEvX+JplquglDi7ee8h+s7ZiXM37iN3xlT4tF05ZEyTQpMkydf9W/ZyvuP/AYH3Hz2frQRQtJG9DNC1X5WIiIiIiCRZCSIo5TqgZcuWmQDV+vXrUbx4cROc6ty5MxI6BaXE1eXbAeg3d5f5WzCrLz5qW9aU9Ikkaw/vASfWAoeXAmc2A7Zg+/Nl2wM1esT36EREREREJLkGpZxt2LABn376KQ4cOID9+/cjoVNQStw5e+Me+s/dhRt3H6JkrnT4sHUZpPLx0mSJEEv5jv0DHF4O1HwHyF7i/78424B9C+zZU3mrAT4qfxURERERSWoiGkeJk9QOxr02b96MpUuXmnK+u3fvomHDhnj//ffjYvUiscIvY2oMb1UaA+btxv7zt/Hx4v0Y/HQp+Hj9f+NnkeSM5Xpl2tlvzg4vszdF580nNZC/hj1AlacK4K0yWBERERGR5CTWMqUCAwOxbt06U7K3YsUKE4iqW7euKdmrU6cOUqRIPCcfypSSsOw7dwsfLNyDgMBgVCuUGf2aloC3AlMi7l05AhxZbs+iun3h0fMpfIECtYBavezBKhERERERSbTiNVOKGVCrVq0ygajq1aujb9++aNSoEXx9fWNjdSLxqlTu9BjYoiRG/LEPG45dw2d/H0TfJsUVmBJxJ2sR+63q68Cl/cDRlcCxf4E7l4GLewFvp3K+a8eBjPkAT5XFioiIiIgkRbESlDp37hzeffddNG3aFJkz64pLkvRVypcJg1uUxMg/92P90asKTImEx8MDyFHKfqv2JnBxD/Dgjv15CnwALHwL8PIBCtQGCj0F5KoAeOmCAiIiIiIiSUW8NDpPbFS+JxG19eQ1E5gKDLKhRuEseF8ZUyJRc/Uo8Ecv4P7NR8+lTGfvQVWwLpDnCcA7pWZXRERERCQRx1HUkVkkBlXOn9lkTHl7eWDd0asY/fdBBAYFa45FIitLYeDFeUDzMUDJlkDqTEDAbeDQ38DfA4FdszSnIiIiIiKJnIJSIrEcmPrkrwN4EKjAlEiksVQv75NAnffsAaqWXwBlnwXSZrc3Rbcc/w9YMhA4uAS4f0sTLSIiIiKSSKh8LwJUvidRLeUb9ed+PAyyoXzeDBjUvBRSp1DDZpFoY9W51XuKlg8Djv5jv8+m6LkrAgXrAPlrAr5ZNeEiIiIiInFM5XsiCSBjalir0kjt44Wdp29iyMI9uH3/YXwPSyTxcw5IUaXOQOUuQOZCQHAQcGYLsHocML0dMO91IDAgvkYqIiIiIiLJoXyP/dq//PJL1KhRA1WqVMGQIUMQEPDoRGTPnj3o2LEjKlasiA4dOmDHjh3xOl5JHsrlyYiRz5RB2pTeOHjhNgbM243rdx7E97BEkhYGo57oCrSfCnScDlR9HchR5v+DV7aQDdH3zAPObAWCFCAWEREREYlvSSYoNWnSJMyYMQNjx47F5MmTsWHDBkyYMMG8dvXqVXTp0gXFihXDnDlz0Lx5c3Tt2hXnzp2L72FLMlAsRzp80q4sMqbxwcmrd9Fv7i5cvHU/voclkjRlzAtUeB5o87W9D1Wd9x+99uAOsP5r4M/ewM+tgeXDgcPL1YdKRERERCSeJImgVFBQEKZOnYp+/fqhevXqKFeuHHr27Im9e/ea1xcsWICMGTNi2LBhKFy4sAlQ8dKEM2fOjO+hSzKRP4svPnu2HHKkT4nzN+/j/Tm7cOyyf3wPSyRpS5MZyFr00eOH94FiTe1X8mOA6uhKYOUIe4Bq0bv2hukiIiIiIhJnkkRQ6vDhw7h+/ToaNmzoeK5Vq1aYMmWKuX/69GmULl0aXl6PmkwXL15cJXwSp3JlSI1P2pVDvixpTAlf/7m7sfXkde0FkbjimwWo+749g6rNt0DFF4FMBQBbMHBuO3Dn8qP33rtu700VqHJbEREREZHYkiSCUmfOnEGGDBmwbds2tGnTBnXr1sWoUaPw4IH9ZCJr1qy4ePFiiM9cuHDBBLJE4lLWtCnxWbtyKJcnA+49DMKHi/Zi2b6Qx6aIxDJPTyBHKaDKa0CHn4DnZgDVewAFaj96z4k1wJ99gJ9bAUsGAvt+B27ruyoiIiIiEpO8kUjcv3//scCS5fbt2+Z19pMaMGAAgoODMXToUPOXDc8bN26Mb775BrNmzULbtm2xfv16rFixAjly5Ijz7RDxTeltrsr31YrD+OfgZXy54jAu3w5Apyp54eF6VTERiX0Z/IBy7UM+x0boLP+7ew04udZ+o8wFgbzVgHId7K+LiIiIiEiUedh42bpEYOPGjejcubPb18aNG4fevXtj2rRp5sp7tHz5cvMcr7Ln6emJuXPnYuTIkSZ4VbJkSVStWtUsc968eeGu29/f3/Sg2rp1K9KmTRvj2ybJE7960zecxKwtZ8zjeiWyo0e9IkjhnSQSGEUSv+Bg4NpR4NQG++3SPnupn4cn0HkhkCq9/X1Xjtj7VLE8UEREREREENE4SqLJlGIQ6eDBg25f27Rpk/lbqFAhx3MFCxZEQEAArl27Zsr32rVrZ0r7eCW+7Nmz47PPPkOePHnibPwirpgV9VL1AsiWLiW+/fco/jlwCedu3MOg5iWRyTeFJkwkIZT5sVE6b5Vesl+l78xm4OaZRwEpWjMeuLgHyFwIyPMEkOdJIGc5wCdVfI5eRERERCTBSxIpGaVKlYKPjw8OHDjgeO7o0aPw9fU1V93bsGEDevXqZRqdMyDFDJXVq1ebQJdIfGtaJheGty6DtCm9cfDCbfSatQNHLunKfCIJDgNRRRoAlf/36LngIPtflt5eOwbsmgUsfh/4qSXwR29g7/x4G66IiIiISEKXJIJSTAXr0KEDRowYYcr1tm/fjjFjxqB9+/bw9vY2WVP//PMPZsyYYa7EN3z4cNy8edNkTokkBBXyZsSYDuWRJ1NqXPV/gH5zd+G/Q05XAhORhMnTC2jztb2cr+FQoEQLIG12IOgBcHYrcHbbo/eyWv7ICuDOlfgcsYiIiIhIgpFoekqFh1faGz16NBYuXGgyoVq1aoV+/fohRQp7GdS///6LTz/9FOfPn0f58uXxwQcfoHDhwhFatnpKSVy5ExCI0X8fxNaT9itDdngiD16omh+enmqALpJo8D+rN0/bS/3S5wHy/X9W7o3TwG8v2u9nKmAv8zOlfmWBFGnidcgiIiIiIjEponGUJBOUik0KSklcCg624af1JzBv21lHFtV7jYsjQxof7QiRxOziPmDtF8CVg/bAlXO2VfaSQMXOjwJYIiIiIiLJII6SJMr3RJISZkV1rVkQfRoXQ0pvT+w4fQPv/LYd+8/fiu+hiUh05CgFtP3OqdTvaSBdTntfqgt7gODAR++9fAjY9rP9+SCn50VEREREkpBEc/U9keTmqeLZUShrWny0eD/O3riH/vN24+WaBdCqfG5z5T4RSaRSZQAK17ff6NZ54Nx2IFf5R+85vgrYPh3AD4BPavvV/HJXBPwqAVmK2q8MKCIiIiKSyOn/akUSsHxZ0mB8xwqoVTSrKeubvPo4Pl1y0PSeEpEkIn0uoERzIKVTWnO24kDBOvYr/j28B5zeCGycCMzrBvzcyh7IEhERERFJ5JQpJZLApU7hhb5NiqNEznSYsvYE1h65giOXbqNP4+IomSt9fA9PRGIDA1K8BQcD147ZM6l4O78DYKZk2hyP3rtmPHD7gj3TihlVDGh5qQediIiIiCR8CkqJJAIs12tdwQ/Fc6bDmL8P4uKtAPSfuwvPVcmHDk/khZeuzieSNLFML2sR+61ce3v/KQagnMv3Tq4H/C8CpzbYH3unBLKXsgepclewl/2JiIiIiCRAKt8TSURK5EyPL56riKeKZ0OwDZix8RQGztuNS7fux/fQRCQu8Ep9GfwePeZV/BqPBKr3AArWtpf7BQbYs6q2/gismxDy8xd2AwG3ta9EREREJEFQppRIIuOb0tuU7lXKlwnf/nsU+87fQs+Z2/FmvSKoUzSrmqCLJCcs5ctWzH4zmVTBwI2TwIVdwPldQMZ8j97LYNUfvexX+ctcGMhZBsjx/zdeBVAXUBARERGROKaglEgiVa9EdtNTaszSgzh44bYp61t35AreeKowMqZJEd/DE5H4wLK+zAXtt1KtQ77mf8nei+rmGeDqEftt7wL7a2kyA+U6AuWfi5dhi4iIiEjypKCUSCKWM0MqfNK2LGZvPYNfN5/GuqNXsfvsTXSvWxi1lTUlIs4y5gWe+wW4c9WeSXVxr/125RBw9xrg4VTRf+scsHIUkKO0/ZazrD1wJSIiIiISgxSUEknkvL080alKPlQtmBmfLz+M41fuYPTfB81V+pQ1JSKP8c0CFK5nv1llfZcPAulyPXrPhT3Axf+/WdLn/v9yv9JA/ppA2myaXBERERGJFjU6F0kiCmVLi7EdypsAlaenh8maemvGNqw8cBE2NkMWEXGHV+vLVS5kkMmvElBvIFCyJZC5kL3fFLOnDi8F1owHrhx89N5rx4EjK+yv67dGRERERCJBmVIiSYiPlyeer5oP1Qplxvjlh3Hiyh2MX3YYK/ZfMo3Q/TKmju8hikhi4JsVKNbEfqMAf+DS/kfZU9lKPnrvsX/tV/qjVBmA7CWBbCWA7KWA7CXsz4mIiIiIuOFhUwpFuPz9/VG5cmVs3boVadOmDf8DIglAYFAwFuw4h5mbTuFBYDC8vTzQvnJePFs5D1J4K0lSRGLIvoXAgcX2xum8sp+rDj8DmfLb77N3VYq0gLcuxiAiIiKSlEU0jqJMKZEk3GuKASg2PP/236PYevK6CVCtOnQJbzxVBBXyZozvIYpIUsCr/PEW+AC4dtSeUWVu++xBqAx5H713w7fA0RVA5sJA1mJAtmJA1uL2EkEFqkRERESSHQWlRJK4HOlTYWjLUlh75Cq+++8ozt24jyEL9qBG4Sx4uVZB87qISLQxqMTSPd4sD+8Bni5X9QsOsl/xj7cD//+8p5c9UPXMd4/eHxwc8rMiIiIikuQoKCWSDHh4eKBW0ayomC8jpm04ib92nzeN0DefuIZnKvrh2cp5kTqFV3wPU0SSGh+XPnatJwD+F+1X+7MCU7x//yYQ/DBkEGrR28CDOyEzqrIUfnyZIiIiIpJoKSglkoz4pvRG97qF0axMTkxafQw7T9/ErC1nsHz/JXSpUQB1i2UzV+4TEYkVvIpfupz2W6G69ud4xT7/S8D9G4/eZ2VTBQYA144Bh5b8/+c9gYz5gHzVgWrdtZNERET+j737gI6iasMA/KYRIAFCCb333qUXBQRFpSkgovxWxIIF7GBFbNhFRUGxICoqVcGCIoKA9N577yWEEEKS/c97N7OZLLvJJqTnfc6Zs2VmZ+7cmV2YL9/9RiSHU1BKJA+qVDwEo3rWx3+7TmLCgl04EhGNt//YillrDuJ/bSqjkepNiUimBqpKOSfXe/5A/28Ss6msjKqoE8Cp3UCR8onLMqj1011ASDhQvLozm4qPhctr+J+IiIhINqeglEgeHtLXqmpxNK1YFDPXHMSUZfuw7WgkRk5fj6YVwzCoTWVUC9fdJkUkS36ggNBw51S5beL7504Ax7cAQQVt7x0HTuxwTnuXJL4fmN9ZQL16Z6DBTZnbfhERERHxiYJSInlcvkDnXfq61CmJ75btw6/rD2Pl3tNYuXc1OtQsgVtbVUKZIqrhIiLZQEhxIKRN0vfyF3HWqjqxPWHa4RzyFxvtvANgmYaJy0ZHANOGJGRTVXMWVy9WBShUVllVIiIiIllAQSkRMcIK5jP1pno2LotJS/bgn63HzbRw+wl0q1cKfZtVQHihYPWWiGS/u/6VbuCcLLxz35l9ziAVa1BZ+DrigHPa9Y9tHcFA0cpA/ZuAml0T18GMLU4iIiIikiEUlBKRJJgV9Xi32ujTNBJfLdptsqbmrDuM3zccwdV1S6Fv8/IoWSi/ek1Esi/exa9oJedkF14buO5t4CSH+20HTu5y1qhiQXXWrGJ2leXYZmD240CxykDRKs6hgMyq4vMCYZm+SyIiIiK5kYJSIuIR60m92LM+1u0/g8lL92L9gTNmaN8fG53BKQ75K1VYwSkRyUHyFQTKN3NOFmZEMXPq1C6gRM3E9/k6JhI4vN452RUoCrR7NPEOgjFRQPxF51BCEREREfGZglIikqwG5Yvg1fINTFDq26V7sXa/Mzj1+8Yj6Fy7JHo3KYcKxWxFh0VEclpWVVgF52RX/WpnZhWDU8yoMllVu4CIg8D5U0A+240gdi8E5o12BqWYnRVmTRWdr0NKqmaViIiIiAcKSomIT+qXK4LRvRtgw8Ez+G7pPqzed9pkTXFqUaUY+jQth7plCpu7+omI5IpaVVZBdDtmRZ3em7RWVdRx52P0GeDQWudkd+3rQMVWzucMblmfL1IeCAjK6D0RERERybYUlBKRVKlXtghG9SqCTYci8NOK/Vi6+ySW7nJOtUoXQp8m5dCqanH4+ys4JSK5dAhgydpJ32t8C1C3F3BmP3B6j7NOFQNPnPges6YsO/8GVnzhfO7nDxQu6yyyziAVp0ptgfyFM3efRERERLKIglIikiZ1yhTGyOvrYv+pKExfdQB/bT6KLYfP4tU5m1GmSH70aFwWnWqXRMF8+pkRkTwSrAqv6Zzs4mIB/4DE1yySzmGBDFhdjHIGrThZ+k9KDEptmQMcWAEULuccXliEU3kgX0gm7ZSIiIhIxvJzOByODN5GjhcZGYlmzZphxYoVCA211ZAQEZfTUTGYteYgZq87jMgLsea9AkEBuKp2SVzXoAwqFlfdKRERF/7369zxhIyqPc7pzAHgmteAgIRg/l+jgW2/X9ppLLTOIFWXF4GCxZzvRUcAgfmdww5FREREckgcRSkMIpIuwgrmw22tK+OmZhXw5+Yj+GXtIew/dR6z1x0yEwumX9+gDFpWLY4ADe0TkbyO9fdCw52T/W6AdrW7O4f2mWyqfc5HFlnnxPpV9mLrSz4Ctv4KhJZyZlNxWCAzrAqVcT4Wq6pi6yIiIpLtKCglIumqQL4AXN+wrMmOWrP/jAlI/bfzBNbtP2Om4qH50KVOKVxdtxRKFc6v3hcR8aZsE+dkdyHSGZw6dyxpVhSzrph9dfawc3IPgN35O+CfsPymWc7PM1jF4FWhss6MK92oQkRERDKZglIikiF4F77GFcLMdPRsNH5bfxi/bTiCE5Ex+H7ZPjM1LF/EBKdaVyuO4EBbzRUREfEsODSh0LpbsfXuY5wZVBEHgNP7nI9nDwERB4G4i0kDWNv+AA6tSfp5Dv0rnJBVdfWoxKwqrpMZWbpLoIiIiGSAXBGU+u+//zBo0CCP8+bNm4eyZcti3759ePbZZ7F69Wrz+plnnkG7du0yva0ieVHJQvnN0L7+V1TEkp0n8MfGI1iz/zTW7j9jppDgAHSsWRJX1y2JauGhJqAlIiKpwN9NZjtxKt0g+WWrd3HWpGLAKuIQEHkEiI0GTu5yZmJZASma+4IzgFWwBFCotHPiEEEOC+TkbeihiIiISF4JSjVp0gQLFy5M8t4jjzyCsLAwE4BiLfcHHngANWvWxE8//YS5c+fiwQcfxOzZs818Eckc+QL90aFmuJmORETjz01HMXfTERw7e8FVe6pisYLomLBM6SIa3iciku7q9kj6mplUHPLHIBWDU3ZRJxKKsh9zTofXJc4LKQHc+lPi63/fAy6cTRq0KlQKCCmpAuwiIiKSe4NS+fLlQ3h4uOv1zz//jK1bt+K3334zr5csWWIypb777jsULFgQ1apVw+LFi02AaujQoVnYcpG8i/WkbmlZETdfUQFrD5zB7xsOmyyqvSej8PWSPWaqWaoQOtYKR4caJUwhdRERyQAcmsfMKU7u+n3tHMLHbCoOBzxrPR4G8hdOuuyexc55nrK4itcAbhyf+N7uhYBfABBa0jlxiKCyZEVERPKcXBGUsrt48SLeffddDBkyBMWKOW+TvGbNGtStW9cEpCy8NSGH8olI1vL3T6w9de5CLBbvOIH5W49h7f7T2HrkrJk+W7ATDcuHoX2NEmhZpTiKFAzSYRMRyexhgSXrJL9sq/uc2VaRCcXWrYnZVwFuf1hYNDZpACuooPNOhMyqKlEDaHlv4rzIY84AWGBwOu+ciIiIZLVcF5SaM2cOzp49i4EDB7reO3bsGEqWLJlkueLFi+PwYbe704hIlgoJDkSXuqXMdOpcDBZsP475W46ZwNTqfafN9KHfdtQtWwRtqhVHq6rFEV5IFykiItlC1Y6Xvsehf9GngYvnk77PwFO+EODcUSA6ArgYBZza45z43G7mUGcAi4EpBq04PNDKsAqrBFRum7H7JSIiIhkmxwSloqOjceTIEY/zOHTPyoKaMmUKbrrpJuTPn1iL5vz582aInx1fx8TEZHCrRSStiobkQ49GZc106Mx5LNh6HIt2HMeOY+ew/sAZM336z07UKBWK1lWLo031EigXVkAdLiKS3TKtChR1TnZdRyU+vxjtrFcVedQ5TDBfwaRBrZhI53MGrzid2J44v1S9pEGpqfcCjjhnYXbWvCpYHAhhBla4s75V0coZtqsiIiKSi4NSHILn7Q57H374Ibp06YITJ05g+fLl5i57dsHBwTh9+nSS9xiQsgeuRCT7KlOkAPpdUcFMLJDO2lOLtp/ApsMR2HYk0kxfLd6DsmH50bxSMTSrXBT1yxYxhdVFRCSbC8rvvaYVg1r/m+UsoG4FrphdZQJYR4HCthvWxMc7A1bxsQC2XbquUvWBXh8mvv79WcA/IDGAZYJYtke2S0RERDJUjglKtWzZElu2bEl2mQULFqB8+fKoVatWkvdLlSqF7dttf1UDcPz48UuG9IlIziiQ3rNxOTNxiN9/u06YOlRr9p/BwdPRmHn6IGauOYjgQH80qhCGKyoXRbNKxTTMT0Qkp2JgikP3OBWvlvyyvT9xBq+ijgPnEibrebHKSQNYe/4F4uM8r8c9gMU7CwYEOzOvCjLzK6HOFh+DC6lIu4iISG4PSvli7dq1aNq06SXvN2rUCJ9++qkZAmhlR61YscIUOxeRnD3E75r6ZcwUFRNrak4t330Ky/ecMgGrpbtOmgnYgYrFC6Jx+TA0LF8EDcoXQcF8uernT0RE/P2BEtWdU4ocQKdngagTCcErt0AWs6XsAawN0wFHvOdVlW0C3PBu4usl45xF2a2glQlkJTwP1J1kRURE7HLVVdm2bdvQvn37S95v0aIFypQpg6effhr3338/5s2bZwJYr776apa0U0TSH4NMbaqVMJPD4cCu4+dMgGrZ7pOmUPreE1FmYhaVvx9Qs1QhNORd/8qHoVbpQhrqJyKSl3DYXrWrPM9jHSszBNB6HQe0GOwMYHE6fxKIOgmcP+UcVpi/SNIA1trvvQewKrQEur+R+HrZZ0Bg/oS6W2HOx/x8DAOCVCdRRERyv1wVlOKQvMKFC1/yfkBAAD766COMGDECffr0QaVKlUwdqrJlbXUIRCTX8PPzQ9XwUDOxDlVE9EWs3XcGa/afxpp9p3HoTDQ2Hz5rpinL9pmAVN0yhVG/XGHULVPEFE/PHxSQ1bshIiJZNVwwICjxNZ83HuB52dgYIDY68TWDWU0HJQSvTjmDV1YgK+5i0iLuDGCtmpRMAKsF0H1M4ut/33dmYLkCVwmBLCuIZW+ziIhIDuHnYEqBJCsyMtIM9eOQv9DQUPWWSA53NCLa1KBigIqBqtNRF5PMD/D3Q/WSoSZQVbdsYdQpUxhFCug/+yIikkb87zazqhi04lA+K6C1/HMg+rQzgHXeejwFxMU4M7m6vJAYwJrQ2fchhPNedQaprMBVcBFnRhfrcpk7EtqGJ4qIiGRhHCVXZUqJiPiiZOH8uLoup1JmqN++k+ex9sBpbDwYgQ0HI3DyXAy2HD5rpmmrDpjPlC9awASnOOyvZqlQVCoeYoJXIiIiPhdrt2N9qVZDPAewLp4H4m1/MGEw64q7kgauTDAr4TWDT65l44FtvznX40m5ZsD1bye+nvmQczijCVoVAYILJz4vVAYoXV8HWEREMoyCUiKCvD7Uj0XQOV3fsKwJUh09e8EEqDYeijCPe09GYf+p82b6Y+MR8zkO+asWHpIQpHJOpQoHm/WJiIhcxj9MSYf5WQGsJrd6Xp5BKHsAizWw2j6cGLBi8Co6ArgQAUSfcWZK2T97eK3vAayv+zjb5wpc2QJYRSsD1bskLnt6HxBU0Hl3QhV4FxERLxSUEhGxYVCpVOH8ZrqqdknzHmtSbToYYWpQbTt6FluPROJ8TBw2HTprJkuh/IEmOFU1PARVSoSYmlZlCueHvzKqREQkI+866B+c+JrD9ur19v3z177hDFqZ4NWZxOAV3wuvlbhcfJyzNhYDWLxDobvyzZMGpabf5xyySKyFxeCUNYXXAVrfn7js1t+d+5GvkDPQlS804bGQ830REcm1FJQSEUlB4fxBaFm1uJkoPt6BA6fPuwJUvLsf7/Z3NjoWK/acMpMlONAflUskBKn4GB6CysVDVEhdRESyHgM+LKjuCz9/YMD3CQErBq8SHq2AVpEKSTOwOCSQn2EdrNgLzskKZgXkS7ruRe8nBrDclWkE9Hg/8fXCd53DGRm4yhcCBPMxYWK9LnsgjQE0ZTCLiGRrCkqJiKQSM58qFCtopk61S5n3YmLjsefEOWw7GmkCVDuORWLPiShciI131aey8P/HZYrkR8ViBc1UPuGxXFgBBatERCR74j9ehUo5J1+CXYNmOINTF6OcASfXFOEc/mcPHJVrmjDE0LYcP+cpgLV9rvcAVnhtoM8nia+/G+jcnhXAMkGsQs5HBtGa3pa47P4VzkdXoIvLh+quhiIiGUxBKRGRdMAaUzVKFTKTxcqoYpBq57FI7D4RZYJVvNvfwdPRZlqy82SS/++XLOQMVlUoVsAVtCobVgAhwfq5FhGRHIbBKQZ4OKGM52X4j9/VL136flwsEMM7FrrdcbD5nc4MrZhzCVNk4iPrWtkxIGUFuTwFsOxBqX/GAGcPXbochx4WrwH0+jDxvUVjnesMKuAMXrF2FuuABYU473Zozz5jsI2BNa5HWVsiIpfQVY6ISCZkVHWoGe56/9S5GOw+cQ77Tp3HvpNRZmJWVeSFWByJiDbTst1J11WkQJDJrmKAqmxYfpQpwscCJruqQL4AHUMREcldAgKT3lXQUr+P7+vo+2VC0CohcMVAkhXMYnF2u6KVgKD8wIWEZa1MLQ475HBBu90LPQewqEh54OZvEl///ChwYrtzKKMVwDLBrFAgtCTQ5fnEZTfPdgbckgS6Cia+LlLO930XEckhFJQSEclkRUPymalJxcT/bPOuf2fOXzR3+uO07+T5hLv+RZnMKs7jxGLr7sIKJgasShfOj5KFg03GFR9LhASr0LqIiORNIcWdky+ufT3pa2ZoWcEs1sWya/Y/590NOf/ieWcAywpkFSyRdNnYaOcj1+GetXXeLci0YSpwfJvn9jFAN2h64uvZjzuXZYCLU2DCIycOj+z4eOKyuxY478RoBcQYfOPzwIRHX4ZkiohkEAWlRESyyV3/wgrmM1PD8mFJ5kXFxCYM9zuPw2eizZBA8zwi2gSsrMl+J0B7tlZ4aD6EF+IdBZ3BKj7y7oLhhYJRLCQfggJ0ZyMRERG3f0CddwDk5K7Wtb53Vv9JCYErTszSikp8ZDF4u0ptgaJVnMEtE+iyLcthgXYMijHQxMkds8DsQan1PwIHV3tuH4cW3v1H4uu/XnYu6x64MoGv/ECHxxPviLhnMRB52Pm+awpO+Ex+IKxy4rIqOi8iXigoJSKSzRXMF4jqJUPN5O7chVgcOsMgVbR5PBJxAUfPRuOoebyAuHiHeY/T+gOe189MKwanSoQ6g1QlQvOheEgwitseC+YLMIEzERERSQX+28lheJyQQtZW8zt8X2+30QkF4c87s7FMICsaiD3PjSZdtnRD53BBKzjGZS4mfMa9kHzUCeDcMc/bZBDtyicTX2/+2TmU0Zu7/gD8E9Y/7xVg57ykgSt7IKvrKOcwRdrxF3BsqzOw5Wn5cs2AwHyJwbm4mMS6XQHBiYEwEckRFJQSEcnBWAC9eslCZnLHQusno2JMgOrI2WgcM8GpaOfzs86gVWycw5VptfPYOa/bKRAUYAJWDFAxiFW0YD5T54qZXUUL8tH5nO8p80pERCSDsR4VJ19ccZfv6+34pLOulXuwi4/uwxhL1XfWymLdLS7rekx4HhCUuCzfi7vonDwVnvezZY3t/Q/Y+qv3Nt42DQgs5ny+4gtgw7Sk8/0DEwJU+YBeHwOFE4rsb5wJ7Pw7YV6QM4BlLcfHBn2BggnrPb4dOLnTNj9fwvIMjOUDQksnBsaUBSZyWRSUEhHJpTh0j9lPnOri0uEHrGMVcT4WJ85dwPHIGJxMeDxhf37uAs5diMP5i3Fm2CCnlIQGByYEqZyBqjATvApCofycAlHYeizgfAwOVKF2ERGRbKFQaefki8YDUhfsajM0MWBlgl62YJY9Y4t3Lwwu5Bbosj0yMOQehLIXo+fzGL4+55xnOb0HOLDCexs5LNMKSjGra9Uk78v2+RQIr+V8vnoysGxCYsDKP8gZzLKCYxzyWKKGc9m9S4Ctvzn31wTG8iVMgc7H6l2AwmWdy57ZDxzf6nzfrNNt3aGlEjLwuM9xzqAh31dmu+QwCkqJiORRHI5XpGCQmaom3hzwEtEX43DiXAxOJgSpWHCddxA8fd6ZYXUqKsaZbXX+osnO4l0EOe0/lXIAi/IF+qNw/kATtCpcwPlYyHqdEMTi8EFmhTHgVTA4wDzmDwxQEXcREZGcIDjUOfmiemfn5It2jzgnFqaPY+DqgjMby2RmxSS9g2PNa4DwOrblYpI+2u/IWLgcUL550vnWc04MDFm4PgaErFpg7tgey6ndzuGJ3pSslxiUYgBtwdvJD+Gs3M75fPufwLzRzoCUPXBlBb9aPwhUau1c9vA6YNU3zkAYl3Utl/CafV+yjnPZiEPOIZocusn1cH6A9ZkgoFjVxCAma5/xrpTWcmaZhHWawBqfa2ilXEpBKRERSVb+oACUCytgpuSYgFRMLE6fY4AqxhWwMncOjLqIsxdicTb6osnOiuBjdKz5TExsvMnK4pQa/n7OelshwQEJjwxaOZ8zaMXXrnn5AhAcxOcBZihigXwBZr/4PCjAT/WyREREcjIGO/wT7j7oDbOVrIyllNTu7px80WgAUPuGhIAVg1cxQPzFhNcXgbAKicuWberMGDNDGRMCXK7nF5MOySxQDCjTyJn5xYCYWaftc7zjooWvraGE1nw7++vIo8Dexd73p3j1xKDUqV3A4rHel2VAsF5v5/Njm4GfH/W+bMshidl1rBk253EPwauEgFbt6xL7n+1d8rEt2BWQEOBKmMo2dmbX0YVI59BP+3wzJXymSDlnIM30SawzE80+3748zyWrzhn7lZSFliEUlBIRkXQbLsisJk4VkZBOngwOH+SwQAapTLAqIVB1NjoWEecvmkfr/agLcTgXE4uomDjzPgu4xzvgysoCLlxWuwsmBKoYpDLBqnz+zuAVXye8z4AW5wUH+pshh+YxyPacj+a18zkzwAIYORMREZHcKyiFYJhdeE3n5Isq7Z2TL5gFVrWjh2AXpwtAWMXEZRlw6viEM9jF+fZHTsWrJS5bsLgzc8rMj0sMjJnHWGfgzML6YsxMc60v4TMWe40xtolF6r2p2CrxeXRE8tllZAWlok8Diz7wvlz9PkDbhxOWPQNMv8/7srW6Jxb2ZwbcxO5Jg1fcX+s5j5O1Xmbtcb3egl0l6yYd+rrog8S6amb5AKBQWd+DormAglIiIpJlwweZxcSpdBG3+hApBLNi4uJNoIoBKQareBdC1r6KimGQKs685jy+tt6PvhhvgloXYvk6zmRokX3IYXpjUMoZvLICV4kBK1dQK8DfFIcPCnQ+5gvwc75OeC/Ja84PtL/2Q76AAATykZ/353x/8zrQXxlgIiIieYKpSXXpTW884vBAa4hgSlg3q/Nzvi3LjKVB05O+xwCNFeyy1/cqXgPo+0VCACvGLegVA4RVSlyWdb6s7DJrXWbi8rFA6QaJy7KuV7VOSefbl2ewx65QGc/rNO211Ty1apaZ+XGX/jGUGVr2ZZk15lVC1pVl/dRLbyJQtkmeCkr5Ofi/e0lWZGQkmjVrhhUrViA01Mex0CIikq0x24r1spitdT4mzjyPsh4vxuGC63V8QlDLuSyDWRc4XeQjg1wJr2MT52WXf1kZtGLwyhmk8jeBKgbK+B4frdec73ydsAw/55+4TGCA/bN89E/2swF+iUExzgvgHxMTnid9TPo+s9YCred+zqAe3wu45LPOoKaIiIhIhrDfVZHBNWZhuQe6GEziY75Q59BAs2ycs6C9+zLWxECYPRNs2We2ZRLWX6Q80OCmPBNHUaaUiIjkSQxuOOtOpe8/hfxbz8U4R9KA1UUvz7nMxXjExscjJs6B2Lh4E9iKjefn483ri2ZyZoddjHV7bU2xztcMtNlxuYtxttT5XMQKTJmglwloJQSx7EGuhGX46HzNN2CWN7Vg+Qi3ZUwNVmfAjHOtdVjLW8t5X0/CMglDN9kWPjPLXNIeZ30Krsds1bnahEfnC2u9VgiO7eMre0zOWqez5QnbcZW+sL92LuTcp4RtOBdxtTGxHYmfg/tr2zYT25F0O/b9sJZxf53Y/sS2J33teTmkuFzCfC/rv3R9tmXcGudtHZfsg9uTlJbz1sbE5ZLuXGr2Nbn99IW35d3Xm/b1eFve85zUhp+9bleBbBFJ648J//G17syYEmZYVW7r+3auuCvPHxcFpURERNIRL3w4xI7D6HxMpE83HIp4Md4ZtLICXBfjHYjj63hnsCs2zmGCV1wuLuG1Nc++nDXPPJopPulnzbLun3W+ZmyMbeGycQ6Hec73zGvz3Dk55yddlkG9xOWS2VfOS1hWRCS9pTaoltoV+WXgdlMb4EuvQKS3xTN6u94Dkalbf3rFLVMKgKa0mcttR8rrT3kDGd3GlLaQ0vozvn0pn4cptjHFffBL9rM3Ni2Pq2rbCt/nYgpKiYiI5BLMzgn2Z/0q5AoMUJkbCSUEn6xAlilRwece3re/F5/weevRWhfX64xlcVm4XpvtJQzt5CM/xyfOdVnrSWyTtW4yyyS0y/mxhHUjYVu2dbi2lbAe6zPu+23F27iOhKaY9SSsLsn71murVIVpf8J+wG151za8rMe84/DwGVufWK8T+zLxdcIqEtfrtg2rPYmfsu970netKhPuoUdvy116DiX2YZLXbotfMt9z87wu57599/1MXF/yy0n24e2YpPpQZcnB1QklktMt33NSQSkRERGRrOQaNgfWstKxkLzDFYy7JCjmNt/12n05z59PebupXN5L8CO1AZ3Ulrj1vp7UfcBb+71uN532K7UhI+/b9TAjnYJpqdpmOgbxUgow+76enHEu+7relNrj6xrSI0Z6uW10ZHAbffl8Rrchxe2nsH4/P6BmqczOt886ueRvqSIiIiIiuYOrVpTX0R0q9C8iIrmDKecpIiIiIiIiIiKSmRSUEhERERERERGRTKeglIiIiIiIiIiIZDoFpUREREREREREJNMpKCUiIiIiIiIiIplOQSkREREREREREcl0CkqJiIiIiIiIiEimU1BKREREREREREQyXWDmbzLncTgc5jEyMjKrmyIiIiIiIiIikq1Z8RMrnuKNglI+OHfunHns2LFjehwbEREREREREZE8EU8pVKiQ1/l+jpTCVoL4+HgcPXoUISEh8PPzU4+IiIiIiIiIiHjBUBMDUiVLloS/v/fKUQpKiYiIiIiIiIhIplOhcxERERERERERyXQKSomIiIiIiIiISKZTUEpERERERERERDKdglIiIiIiIiIiIpLpFJQSEREREREREZFMp6CUiIiIiIiIiIhkOgWlREREREREREQk0ykoJSIiIiIiIiIimU5BKRERERERERERyXQKSomIiIiIiIiISKZTUEpERERERERERDKdglIiIiIiIiIiIpLpFJQSEREREREREZFMp6BUKp05cwavvfYaOnXqhEaNGuHaa6/FF198gfj4eJ8+/99//6FWrVrm+f79+81zPtJTTz1lJm88zf/+++/xzjvvICu570dKFi9ejB07dpjnU6dONX0piT744ANXn/B5/fr1sW3btku6iMuw/9LCfh6mBs8/fm7v3r1J3mc7fF3fbbfdZvbLG66H7UutkSNHJllvTEwMevfujRMnTqR6XSIiIiIiIpLxFJRKhVOnTqFv375Yv349Ro8ejZ9//hlDhw7FJ598Yl5nRXu47bvuugs5ye23347jx4+b5927d8ePP/6Y1U3KVvz8/JK8vnjxIl588UVktQsXLuCPP/5AxYoVMX369GTbnBwGju688850bdv48ePxww8/JHkvX758uPXWWzFmzJh03ZaIiIiIiIikDwWlUuGtt94yF7qfffYZWrdujQoVKpigCgNS33zzDXbt2oXMxG22a9cOhQsXRk6VP39+FCtWLKubka2wP8LDw12vS5UqhVWrVl0SCMps8+fPR1BQEG655RbTFofD4bXNyQkLC0NISEi6tCkyMhIPPfSQCUqVKVPmkvk33HAD/vrrLxw4cCBdticiIiIiIiLpR0EpH3Eo0C+//IKBAwciODg4ybyrrrrKDOErV66ceR0REYHHH38cTZs2NUGjUaNGITo6OtUHZ/ny5ejVqxcaNmyIhx9+GOfPn3fN43BBDt3r0qVLkuFcbAcvxBs3bozBgwfj2LFjrvkcMsesKrarffv2GDt2rGvYIbNXHn30UTz99NNmWGK3bt3w559/eh0qltzwr+3bt5vtNGnSBA0aNDBBDGu4njUsbdCgQWab7sP3Umrj8OHD8fzzz5v5DAwyGOErtnfGjBm4/vrrzZA4tmvfvn2u+dxf9jfb3Lx5cwwbNgznzp1zbfuJJ54wx5L7xTYvXLgQkyZNQps2bdCqVSt89dVXrnUldw5YQ908TRwCWaVKFVStWtW1rkqVKpmMnzfeeMOs1xuul8NJeb706dMHy5YtSxK84f6w7Ty269atS/LZQ4cOYciQIebYc9/Y73FxcUmWYWYg+4XnO4M89vWzzZzSMnyP2+KxbNmy5SXZTt76yfo8+4sZXNx3BondMYjM48PvioiIiIiIiGQvCkr5iDV0oqKiTMDCHYcuMSjBC2AaMWIEzp49i2+//RYfffSRCQC89NJLqTowJ0+exL333msuqJmVUr16dfz666+u+Vu3bjXLcLt2vFi/++67zUU4g1gcXmitj0GYkiVLmgt/BnYYULEHUjg0i9kvvMC/8cYbTQYKA0ypwQASgxsM0DEA9N1335nghjWEyhqq52kIly9t/O2330xQcNq0aSZ49eabb6YqQ43b5fHhPnL447vvvus6vgz8cftz5swx7y9atAhTpkxxfXb27NkoVKiQ2S8Gfh555BETmPr6669NoOX11183+5DSOcDsOn7O08RsHwZoXn311STt5nEMDAw02XqecH8Y+OI5w/OF5w2DkkeOHDHz2Zc7d+40/cnaSxMnTnR9lsf8wQcfRPHixU2/ctuzZs3CuHHjXMswOMdMKQakKleujGrVqpllLRzSx35ILZ6nPL6vvPKKCaj+9NNPSeZ76yfr3Kldu7YZwlq+fHmv22jbti0WLFiQ6raJiIiIiIhIxlJQykdWhgqDEslhcGPu3LkmCMOMDgYvGCzgBTyDFL5iYIRDophtw6wZBiXsAbENGzaYC3ErEGZhMKlnz55m27zQ57AvBrCY5VKgQAHTFgYUmGHFIMyECRNcny1SpIgJnHA+AxrMqnEPEqSE2UA333yzKYjNQEW9evVMsWkruGUN1eO23Idw+dJGDv168sknTfYQg298zRpfvrrjjjtM0KdmzZoYMGCA67MMpjFY069fP9OvzG5iYMdeYLxo0aKmPdwv7hOPJ4NPbCsDZLGxsdizZ0+K5wCHLHKom6cpICDAY7tDQ0NNFhuDZGvXrr1kvhUYY6YXz5fHHnvM7CODUNwmzyfuH48HM9Duv/9+12eXLFmCgwcPmjbys8xYYh/bg4HcH9a2YlCKrr76ahMgtGfvpQX353//+59Zb506dfDyyy8nme+tn1Iz/I/HZ/PmzZdkfomIiIiIiEjWCszi7ecYDH5Yd99LDoefMcDRoUOHJO/zPQYsfMUgDrNA7AWkGZSyggDMyGGQxB2Hi1k4nIntZps4MSDBbBsLg04c3mcF3DikzR7k4mtr2J2vChYsaII9zNZhwIfZORs3bkSJEiVS/KwvbWTAyB64YXCCwSBfMZhlD/Qw0ELM/uG+f/zxxyYQxYnHgAE+C7dtHQ8Glsgasmm95jDPlM4B9gkzlzzhENGyZct6nMehecw0e+GFFy4Z5sZtPvDAA0ne4xBOvs9MMgZkeD5Z7AFOLnP69Gk0a9YsSVsZYGQ2Gc8ztovnlhVU7Nq1q8mk+v3335P0UWq5t5sZgTyH7MffE2aEMSPPF/wOcH+4j8wGExERERERkexBQSkfMTuGWVLMUGLmi7v77rvPZKrw4p/LecowYsHqNWvW+Hxw7IWkiUWmraAUgyOeMj/sAR3iMv7+/pfUwSKrVpO1Hm+f9cRb1gmHed10000mkMHaRKzfxCDM559/nsLewqc2sg9S6qfkePo8MZOGwTS2mXWTeIfAL7/8Msky7v1DnvonpXOAATDWbvKEQxeT89xzz5maYZMnT06x79gOq//c2YOPDOoxQ4rDDN1xPxiY4lBGLle3bt0k8xl8vJyglKfjZ+9nb8XdmWmX2vWn5g6BIiIiIiIikvE0fM9HvFBmLSDe8Y7ZMHa8uxcnBhRY7JnDpXgBzKwcTsw4YZFq988lp0aNGibDyB782bRpk+s5M4+Y+eEpuGJhVg7bwiFkbBcDalZmEHFoHzNfrCywLVu2JAliMNPJKmbOYI5V9JvsBcLtli5diqNHj5qhXxxexyFwHBrmS+DIlzZmFNaJuuKKK0zNJtaVYuCR/ZeagJclpXOAGVrW++6Tp8CXHZfh0Mr33nvPFC+3b9M94MnXVtF0Hj97cXOeW/bP8hixn612sID4+++/b/aB2VA8L3juM0hkTazrxKF/hw8fRlrxPLe3i9u1F3P31k+pOR8YVGO/esosFBERERERkayjoFQqsK4TAwGsH8TgC2sHcRgV6yfxbnIcesT6NazZw5o+rP3DIAtrAbFIeuHChX3e1nXXXWeyokaPHm0yjVhXacWKFa75rL/DC3h7oIgYDOJd5BiceuaZZ0yRZ2bmMLuGARFm2nDIFGsEseg3s4OsDBIGmlgHidvjMDa2nVlP1nAvDh1jfSreec9b5hODBdxXrp/tY/+4B/I4PIvD49xrbPnSxozCdjMox2PG4W6vvfaaCZakJpBoSa9zwBsGpRhAsg8lZWYX60cxWMT2swA8zwEePwbBmM3EmlEMVPH48Y53FtbP4jBE1i9jH/Cuj88++6yp78Whkqz1xf3h8D7WqbImbpOZYgzo2TGQyiGXvvQd7yrIc5b1qXhusUaXt+y8tOI+8fuiTCkREREREZHsRUGpVGCBZd5NjbWaGHDg0DQO8eJd6hiYsjAjhvWHeNHOwtrMRHn77bdTdWA4PImBKAZGGFDg8Cn7MClmMLE9zCSyYwFubouBHM5/5513zPsMTHB9DKSxGDYDFCwwzbuuWTikjLWqOJ+FsT/99FOzr8Q7zTGg0qdPHxMoY8FvT1gDiDWCXnzxRfTo0cPcFY5BphMnTrjuBMdhjuwjBpzsfGljRmGbWIOJx4yZUswc4n7YM4pSIz3OAW849I59ascsvkcffdRkN7HfGTRl4JABMmKQiceGbeG5ymCQhYEnBiGZDcVC7wy+duzY0RRG5zFjkMoKTroPRezcuXOSu/DRoUOHTKDL/dz0hOc0vz881ux3BlHTI3Bnx2Cue30vERERERERyXp+jrSMT5JsgUEdBk9effVV85r1kBjAYeAoLetiIIN3cRO5XAyOMRDEQF9WYnYa28EMMgYJRUREREREJPtQplQONnDgQPz7778ea0uJZBUOcV28ePElRdGzwqxZs3DllVcqICUiIiIiIpIN6e57ORjrCg0ZMsQM0xo2bBjyMmaHsZaSN+PHjzd31ZOMx2GYrBPl7U6HmYU1rVjP7LPPPsvSdoiIiIiIiIhnGr4nuQKHMdrv2uep/lH+/PkztU0iIiIiIiIi4p2CUiIiIiIiIiIikulUU0pERERERERERDKdglJpNHXqVNSqVQs//PBDuh2Mp556ykzW3fBuu+22NK+Lbfvvv/+Q2fbv32+2zUf3duzZswc9e/ZEgwYN8O6775q7BbIfL9emTZuwcuVK85zb4jZFREREREREJHtTUCqNfvnlF1SsWBEzZsxARrjzzjtNYCqnW7hwIZo0aWKeT5o0ydV3d9xxB3788Ud07979srfxwAMPYPfu3eY5t8VtioiIiIiIiEj2pqBUGpw4ccLc8p7BkOXLl2Pfvn3pfmBCQkIQFhaGnC48PBz58uUzzyMjI1G7dm0TzCtSpIi5e2B6Fx/ntrhNEREREREREcneFJRKg19//RWFChVCjx49ULJkySTZUhyS9sUXX+CGG25A48aNMXjwYBw7dsw1tKxDhw746quv0LJlS7Rp0wYff/yxx224D99j8KtPnz5o2LChWfdvv/2WZPmxY8eidevWZr0pDSnk8LY5c+bg2muvRaNGjTBs2DATWBs0aJB5fcstt+DIkSOu5efNm4fevXubbTOz6ffff3fN4x3vRo0ahebNm5t9mz9//iXb4n5zWCKH6k2fPt01vM8+fC82NhZvv/022rVrh2bNmuGhhx7CqVOnzDy2ha+vuOIK1K9f37RlxYoVZh776MCBA3j66afNNtyH7x0+fBgPP/wwWrRoYfrm5ZdfRkxMjJnHbfPz77//vpnHfXj11VfhcDhcd/Rjxhqzr9i33E/rDn/W8E0RERERERERSRsFpdKAw8+uvPJK+Pv7m8AKAy1WIMMKKN199934/vvvcf78eQwdOjRJlhWX//zzz/HSSy9hwoQJmDJlSrLbY1Dr3nvvNUGpWbNmmXUzAMNAFXE7DHS98sorJiD2008/pbgPDMS89tpr+OSTT0yQacCAAWb67rvvzPbGjx9vlmNGGNvPWlAMvvXt2xePPvoo1q9f79pXBq0YXHvvvfdMOzwZMWKECYJx4vC6MmXKJJnPz06bNs3sA/eH/fT888+beY899hji4uJM29h3pUqVwgsvvODafunSpfHMM8+Ybdgx+PS///3PHIOvv/7a1LH6+++/8cYbb7iWWbVqFXbt2oVvv/0Wzz77rGn/okWLzDwGoQoWLGi2+eGHH5pAoHWsGJzTMEERERERERGRtFNQKpUOHTpkimp36dLFvO7atavJMrIyd+jGG280QRxm0jDIwsDH1q1bXRlBfK9evXpmHQyaMNiSnG+++cZkVd16662oVKmSWXf//v3x5ZdfmvkMlHA9V111FerUqWOygVJy++23m6yoVq1amc9w/QwY8Tn3iYEaa9vdunUzy1epUsXUguJ8BtUYiGNWlpXFxIwiBoc8YWYZh+px4vC6gIAA1zyuh/vAYBezrapXr44XX3wRNWrUMPPYTwwYVatWzcwbOHAgtm/fbj7LIY5cF9fPyW7BggUmy2rMmDHmWDDb6bnnnjMBqHPnzpllGOxi8Klq1aqmXzm8cN26dWYeM7C4zrJly6Jp06b49NNP0bFjRzPP2g8RERERERERSZvANH4uT2dJBQcHm2FmxGFhrI/ELB8O/yIGMCwVKlQwgZMdO3aYGkrMvGHgw8LhaAzwJGfnzp0mG8kqGE4cRsYgEXHdrG9lYeCG20kO22VhgKVcuXJJXltD3Ljum2++Ocln2Q5mY3F43cmTJ00gy8I766UW13P69GkTqLPvg5Vhxgyu2bNnm2Agg2XM0oqPj09xvWx75cqVzfGx8NgwMLh3717zunjx4ggNDXXN53POJ2akMcj2xx9/mGAZs6Pq1q2b6v0TERERERERkUspKJWGoFR0dLSpe2Rhtg3rTDGbx3RqYNJu5XwO9fM0j8EVPz+/ZLfJIAnrSA0ZMiTpwbOtyz580NN23NkzlchqnzsG4NyxzfagkH3bQUFBSK3k2srtsK5TRESECQpxuCQDcg8++GCK6/XUdh4L+6NVhN3O2h/WDGN21dy5c82wP2aE3XPPPSajS0REREREREQuj4bvpQKzdDZu3IiRI0eaOkPW9M4775g7yzGjhjZv3uz6zJ49e3D27FlXUWwGV1jk28KhYikVzGZGFNfDoXvW9Oeff5r6UsRhbtaQM+L6uZ30wG2vWbMmyXscjsj3ixYtihIlSiTZNvsntQoXLmzWZe+3TZs2meykbdu2YdmyZaZWFoNyrOV19OhRj4E4T23fvXu3ycKyrF692gTBeAfAlPC4srYVM7VYe+uRRx5JUuRdRERERERERNJOQalUZklxKB7rOdWsWdM1MYOHw80YoCIWy2bQiEEWDv9q27atGUZmYUYVa0yxcDYLcLNGUnJ4NzwOWWOQhEEWBqN4pzrWOiLWmuI2uT6ulwW/vWU+pRZrSXG9rF/FbTM4xOAbAzXM8GLbWTSdxcEZnOLd69KCd8FjsfMlS5aYQNTo0aPN3Qs59I77wr5njSdmpLG4OVlDDDlUkUMc7cEnYr9zmOITTzyBLVu2mHWzftT1119vAmEp4TpZjJ7HkW3inQWt4XvMlrPuqigiIiIiIiIiqaegVCowMMJhdJ6GfDFIw8AMC2v37t3bBI34HothM5hkxwwgBpoYeBk2bJhZZ3JY72ncuHGmcDcDKryLHO++x+FlxALdHFrGgAvXy2CML0EXX7AYOu9Wx+Lg3DZrSXH7HNZGzF7q1auXGdLGOwTy7nxpMXjwYFNAndlI7DfeUY/7w0feaY93A+T2WWycmWrMdrKysrg8C7Lzffchih999JF53q9fP9PXnTt3NoEmX3C7zARjwIyfL1mypOsOf6xxZdUVExEREREREZHU83OkNAZKUoU1j1jvqE+fPpfM+++//zBo0CCTtSMiIiIiIiIikpcpU0pERERERERERDKdglIiIiIiIiIiIpLpNHxPREREREREREQynTKlREREREREREQk0ykolYX279+PWrVqmcfL9cEHH5i7xHnDeVwmt2DRePadr/144sQJU3z+4sWLGdquP//809xdkXct/O6779Lt+GY23t2Rky/nVmbYtGkTVq5cecmxz0i8a+aUKVOQHUVERJg7QbZp0watWrUyx4rvebNv3z7cfvvtaNy4Mbp3746FCxciO8jq84z9Mn/+/HT/PRYREREREd8oKCV5wpgxYzBw4EAEBQVl6Hbef/99tGvXDrNnz0aPHj3MxX+ZMmUydJt5wQMPPIDdu3eb502aNMmUoMpdd92FTz75BKdOnUJ28/zzz2Pz5s349NNP8dlnn2HHjh0YOXKkx2V5g1X2X4kSJfDTTz+hZ8+e5g6hBw8eRF73zDPPYO3ateY5v6f6voqIiIiIZC4FpSTXY+YDM5huuOGGDN/W2bNn0axZM5QrVw4FCxZEeHg4AgICMny7eUm+fPlMv2a0woULmwDj5MmTkZ1ERUXht99+w3PPPYf69eujXr16Jrgyd+5cXLhw4ZLllyxZYjKCXnrpJVSrVg333nuvyZhigEoS8Xuq76uIiIiISOZSUCoTcejYqFGj0Lx5czPEyxo2Yjlz5gyeffZZMySHgY3HH3/cvOdtyJJ96Iu1fg7p4dCxLl26mGwdbzi0rFOnTibrhENmtmzZ4vN+7Nmzx2SR8LNXXnklvvrqK1cbuc4ff/wRbdu2xRVXXIHx48dj2bJluOaaa8zyTzzxBOLj433azvbt213badCgAW655RaTEZJa33//vQkuMJhhmTFjhmkT++rmm2/Gxo0bXfOmTp2Ka6+9Fg0bNjRD/th+C/fvm2++Qb9+/UybmHWyfv1617wDBw6YAAGfuw8HYsYNM1S4P507d8a3337rOqYpHV8Obbr//vtNtleLFi2wdOlSxMTE4OWXX0bLli3N9Nhjj+H06dM+98sPP/xg+oCBDX7+xRdfRFxcHC4Hs2/uvPNOs4+tW7c257s1ZJIZOx9++KE5FvwODBkyJEm2DodYPvLII2jatKk5f95++23zGZ6f7Nenn37a9Id7Xx0+fBgPP/yw6RfuB/uEfWMdS36eGWycx+2++uqrZr0ptZd4HHn+WOcs12X/zrn7559/0Lt3b3NeMVNu8eLFruPHc5/r57a4XmblTJo0yTUEz/oeWeeNp4n74+/vj3HjxqFOnTpJts1jd+7cuUvatGbNGtStW9cESS38fVm9erXHfeC+TpgwwZyj/A64/z6wHfz+XH/99ebc4feSQa+MPM84NHHo0KHm+PF3hed6ZGSkT79nDOIxgGd9T/gby+AdjyO/R2PHjjWfcf++pvR7zO0xYNm+fXsT5ON867xLqb0iIiIiIuKkoFQ64cUgL2x4AWNdiLrjhem8efPw8ccf47333nNdhFoYsGDtHF5wTpw40QRgkrsAdrdq1SrzyAvXAQMGmAshBpDc/fXXX+ZCjBdc06ZNMxdcgwYNcl1wJYcXc7yIDwkJMfV2eLHH2jvcLzp69KjJ2Pj6669N0IGBhVdeeQWvvfaaec5AGbOWUsILY36eGUe8AOZFJy9kOQwvtRYsWGCOi/01g3f/+9//MHPmTHOxzOwRXlCy7xg44Ovp06ebzw0ePBhHjhxJchz5Hj9bqFAhEwQhBuNKly5tglJ87m7YsGE4efKkCUax3xigSQ32GwMBX375pQkWsD8ZEGPgj+cSL3oZnPEFL8bZbrbp119/NYECttmXY5Mc9h2DH+w77h8zeqy6TAzAzJo1C2+99ZYJ9BQvXtycS1YQiEPMjh07ZpZ79913zbFgAJD9bfUrj5sdjxmP4/nz5805x8/9/fffeOONN5J8L3bt2mX6nec8+2rRokUptpcYLDp+/Di2bt1qXrMt7m2wbNu2Dffddx+uvvpqV9CGgUTuE/Hc5/nCeTx+DMAxMMV287fj9ddfN+eHNYzM08R6UPnz5zdBbXuQlfvEgEqxYsUuaRe3X7JkySTvse8ZzPOE/fD555+b/ubvA7+Dd999twnuWKx+4DFisJX9npHnGYOK3A8eQ+4rhy5+9NFHPv2ecVjjihUrzPLcLz5ne9l+BrF4Dnqqt5fS7zF/63i+MIDHz//+++/mPEqpvSIiIiIikijQ9lwuAwMUvAAjBmmYdWHHzAxmDDz55JPmL+fEiz4GN4gXLfw8L9yqVKli3mMAhhehO3fu9KkNvPB84YUXTN0kDtPhxTm3yeCUHS+iGHS56qqrzGteHDPDg/uQUqFhXhjzwpmBptDQUNSoUcNc9DF7gxhg4D5yH8qWLWuCA8zuYSYBMbvDl/2Jjo42GUzMwrAyPJiBwranRmxsrMmaYH9YGBBhwICBO2IGC/uMF7FWgKBXr15mHvuOmVIMlAwfPtzVDmai0R133OEKBDEgwCFADDzwuf0inkERBkIYsKtQoQJq165tLnpZG8hXrAlktZlBGLaJQ7CsrCH2NTNBuL8pFQJnn44ePRpdu3Y1r8uXL28uvBlYsd5LC2Y0cTgZj32lSpVMzSMOgyMeO+4v20gcTsasKQYJuTyDR1b/EM9l9mFYWJirXznZ8bMMGDKQVKRIEfMeA34MDj366KPmNYOZDD7xfK1atSq++OILrFu3zmRjJddeCg4ONu1hJh2PGdviDYMtzPJiIIr43Wb7rQLkRYsWNeeKn5+fOYfmzJljAiNcPzMCGchgEJmBktQMT+R5wHV5+27wXLEHsIivrawe998pro9BJGZKEfuOgTb+PvA7aZ331m8cz0kGDzPyPONxYiCcny9QoIAJ6vvye8ZsNf6mcpsMVlnnHYNNPJf4vWcbeVztmUy+/B7zt46/ffwN5PeNGVM8r5hFmVx7RUREREQkkYJSGYAXne6YTcBgjn3IDYd/WXihw4th6wKIGEjhhTbnuV+Me8J12wt582Lb03A3vscLLGba2DOgrELSyWFwhW3kBb7lxhtvdA1pISuowIwOYqaFhe95uhh2xwtFXuwy84DZQOwDBgYYmEkNBpqYdcWAgH0frItr6wKdgTSrb5ixY8eAmr0fK1eu7HrOfvDljn4MFPHC1+oba72pYe9HDpfidu37QdxXHseUglLMDuOxYCCEwyTZPgZEGCS6HMyoYbD1jz/+MNk8vIjn0DFmEjIzh4EiK4BpBR/ZXp5/7v1jBf6Sw+PC42EFpIiBIQYj9+7d68oKsp+vfM75ybXXju3i0MKU8Lzid86OARILAxTWb4P7d8N6ze8GhxRed911HrfBTCMGWiwMBjETiUMbvR07Btbch3VyO9Y27bifXJbDDy38TeH5Yv8OMIDny3cgvc4zZj4x2MdAGKdu3bq5asQl93vGbTEoaT8uHFLHKTm+/h6794N1XiXXXhERERERSaSgVDrhBcfPP/9sLljsF6LurFo2ZA8guWcyWHhBxclToIsXQIGBiYfQfrFvBSg83W2O6+OFuHs2l/3C3Rv79nxdxr1dvmAQ46abbjLBJNZuYWYT+5bDb1LD6jd7Havk9oEX8J76y/75tNzBj9u0H3tv7Uzu+NrbZtXkYU0be60gKwiTEmYYMfjGjDBmePA5Ax6XiwETnlfMeGKm3kMPPYR77rnHZAIRM0bsF/rEC/3ly5enaXvejpf90dN3yzoW3tprZVkRj70v53BK3w1P8z2tlxmP1jAwd/Zjy7vuMTuOmX4cwuhNqVKlTEDIjkMS3Yf0eevPy/kOpNd5xmPEGnwc9sfjxGw4Zm2++eabyf6ecYhdWqT0e+xtOeu8Sq69IiIiIiKSSDWl0gkvgJi1wHpS7hdHxOAKs3w4vMNiL67NC3UO87EPbeOFJIeUcJ51EWgfYmIV5LVwSIwdb3XO4UruuD5mrfCv/NbEuineCh/bMSuF2QccEmRhLRyrrlJ64dAZXlCyHguzWVjbiRkkyQV2PLGGfjFTzcL95fAcCy8yGfhirRn2DQtD2/G1eyAltZhlwawte0Foq0A6+XJ87ZhRxP1iVot1DHkOsoi3L1k9HNbJDDcOZerbt69pHzOLUtu/7jh0ldtnltsnn3xiArSstcOsEwZUWGfHai9rJzHDhRlGfM19OXTokGtdPPbWUDhveFyYEWPPBOJ5zABQxYoV09xeO547vmTouZ9XxEy2X375BanBttu/m/bJChyzdhIDUsyQsgJ+3jDracOGDSYrzcJz3Z4NZWEGEPfV/lvALCh+Pi3fgfQ6zzjkkm3gsEcGNnmeW8cpud8z63tiPy4MQHI9yUnp9/hy2isiIiIiIokUlMokzIRhbSUOY2FtIQaneKFi4cUahw9xGBmDSZys+lM1a9Y0dUs4DIYXWwxssI6KPahFDNqw/guHs7BYMedbNYjsWA+GxbKZjcELRAYGWJPGXnfJGw674UUr//LP7TATgEXIL3fYl6dgEuvx8AKSwRle3DLo58vQP/dMFNYCst+NizWjWG+GF/YMsFl3Y+MQn9tvv93U1GHfMFjCzAZe0DJr63LwQpZ9xIwOru/ff/8154LFl+Nrx+AEL/JZd4nDJnnBzIwZ7g+HifnSv6zhxH5hMJMFnBkwSm3/uuNFPAMQ3Eeul9ki1nA49i0LTLMwNQNJrMezcuVKEzjl/rOoOGsssU3cJ9Z3Yt0nYjYY1+0+DI3zGXjgvvNzS5YsMd8BZtbZa0Olpb3EIIRVd4q4/bNnz3pcF79rzPhi/SIeBwa5uM6UhoqlFtvANjPgwWF+PG7WZGXxcKiwdSc+3pWQAUAGsNge9it/X7yd0zxOPDd5nPgdt+5Wx6GNqZVe5xmDTtxnBpp47rDAuHWckvs94/eEWVqsa8V95u8uA5E816zziutzD+Sm9Ht8Oe0VEREREZFECkplIt5NjhdIHBrEwrwMKtgx44gX2LwoZPYDL9StO7Tx4ooX28y64AU3L6IZ5LLr2LGjuWDlxSqHEvIufxy6444Xl2wDLzy5LmZ3cVl7raTksjh4FylmMXE7vNhjQODKK69EemKxZ2uoD4dY8S5fDITx4tF+JzxfcNgQgx8WXliy4Db7luu27rDFoJC9bziPGVscMuhLwC4lDH7xIpiFkBlM6tOnjytDypfj644X+MzK45AzrpPHhgEHZoakhEXWmbnUv39/c1HPYVsMqrAvLgf3i0FLBv7YJg4Rs+5Wx3OagRAeR34PGETlEDSrHhSDCSwKzTaxqDwfWejeXkybgSw77qt1VzNuzyrQzYDA5baXGFDhnf+qV69uXg8dOtSc854wM4t3YWPxeR5DBiJ4Xnn6Dl4OBjQZsGVQlYFO+2RlmrGfraGuVh8xGMRzjgFZnvss7u4J70bH3yYGo7g8Ayy8AYCnO/tl1nnGAvGsFcYC9j179jT7b92JM6XfMwaCGZjm9jk0k4X2reGZ3E8OMWQ2prvkfo8vp70iIiIiIpLIz3G543VEsjlmT/DimhefDHpkBQ53ZIYcsy+sQBSzOXihyowUyZ6YXcTARErDCEVERERERCT1lCkluR4zWJhFNmvWrCxrAzNEmLHBTAsOz2MGDp/zrlySPbGWFLOSPA2BFRERERERkcunTClJgkNbkqv3wuFl3ob9pAYzl1izyZvx48enay0eDjfk0B3WpvJ2Z62MxnpDLE7N+jocrsfhgRxGlN7tYf2b5O7GxuOX2uLbxFpJ9jpYnu5A6euwuZzgrbfeMn2loJSIiIiIiEjGUFBKkmAWj/3W7+7KlSvn8db2qcV6Qryrlzesw8MaT5J6DCra72LnjsePxzG1eDcy+10M3THQxvpBIiIiIiIiIr5QUEpERERERERERDKdakrlcP/99x9q1aqV1c3IVXjnNxYlz8hMpilTprhe885vvGtbRuMdDDt16pTq84Z3M9uxY4d5zke2NyfeH4F3fLPuwphdvzesMZbau0t6wzsVpnReffHFF6Yf7BPvOiciIiIiIpIZFJQSsVmyZIkJCrRp0ybD+oX1nMaNG+d6zcDBnXfemanHoUmTJli4cKFPy95+++04fvy4eV6tWjVTZ2natGnIaR544AHs3r071fufGWbOnGnqjfHOjHPnzr3swBBrsrF+Wkq2b9+OW265xfSFNbGfREREREREMoOCUiI2H330UYYXtnbPMgoLC0NISEimHgcWVw8PD0/TZxnEYFAtJ2ZLpcf+Z4SGDRuaGmrbtm0zWVxWRltqRUZG4qGHHjJBqTJlyqS4PDPfateubfrCmlgbTEREREREJDMoKJWJNm/ejJtvvhmNGjVC+/btMXbsWNe8qKgoPPfcc+bud5yeffZZXLhwwZXNcNddd5nsjgYNGpiggDWcyh0LXA8ZMsRsgxe23EZcXJzPxceZscPttG7dGqNGjXIVI2fx8wkTJqBz587mAppDuHgXOQuH/cyZMwfXXnut2fawYcNM0fRBgwaZ12yzNSyJwQwGNdi++vXro127dkn6IiUnTpzAI488gqZNm6Jt27Z4++23zTr3799v2vH333+bdXM/Xn75ZWzdutXc7a9x48a49957zYW7Jzt37jTDuzp27Oh676uvvsJVV11l+p3r4B30LFwv+4H9wWFX33zzTZL1zZgxA9dcc43Zfx73jRs3moDD008/jQMHDpi2ss3uw/c4zI79yPVym8uWLXPN435xO/369TNt6tmzJ9avX4/Uch++5m0/reAIj6PVRraL5+u///7ram9yQ+Fmz55t+ofr7t69u8kEshw+fBgPP/wwWrRoYc57Hi/r7o9cL/vm448/xhVXXGGO9fTp0/Hrr7+atvLujGPGjHGti+cXAzJcludV7969sWLFCjOP62Gfs++feuqpS/Z/z549ru/YlVdeafrDm3/++cesm8eVd1Dk8EZi/zzxxBPme8P1sO+YeTRp0iSTedeqVSuv661UqZI5jkOHDjWPfG31v/vwOk7cB094PvF3g31XoUIFpITnfOXKlVNcTkREREREJEM4JF1ERkY6br31Vkfr1q0dixYt8rjMDTfc4HjhhRcce/fudcyfP9/RqFEjx99//23mPfroo47u3bs7li9f7li/fr3j2muvdbz22muOuLg4R+fOnR3PPvusY8+ePWZev379HPfee6/53JIlSxw1a9Y0z+Pj4x19+vRxPPPMM44dO3aYeV27dnWMHTvWp30YMmSI44EHHnDs3r3bsWLFCkfbtm0dkyZNMvPef/99s29z5851bN++3fHkk0862rVr5zh37pyZzzZcc801jtWrVzsWL17sqFevnvn87NmzHRs3bnR06dLFMWrUKLPs1KlTHa1atTL9tG/fPsfkyZPN57lvvujfv7/jlltucWzYsMGxdOlSs52vv/7arIvrGTBggGPTpk2OWbNmmddXX321Y+HChaZvW7Ro4Zg4caLH9X7xxRfmsxaun/sxb948s+7Ro0ebbfGYnD9/3tGhQwfHO++849i1a5fjzz//dLRp08Yxbdo089l//vnHfJb7xv7kvrO/Lly4YLbDzx49etQRGxtrzhv2L/3000+Oxo0bm/XwGI4ZM8a8Pnz4sJl/1VVXOVq2bOn4448/HDt37nQMHDjQ9IcvuG5+3v28SW4/T5w4YZb77bffzDluGT58uOOVV14xz9kX3BdPjh8/btbNbe/fv98xYcIER4MGDRynTp0yfcHz85577nFs3rzZnA88163zhJ/hZ59++mnTh2wXvzPW8f3hhx9M29h+Yj/ef//95vzctm2b+Y5cf/31Zh63xz5n30dERCTZ/+joaEenTp0cQ4cOdWzdutUcS/b5X3/9dcn+cH7dunUdH374oTnun3zyiVmW+89jyPbynOB39eGHH3Y0a9bMtINt4veQn2WfejJnzhzzHeb2o6KizHtclut2n7gPKbGfV54cO3bM9AG/yzwv+P3l8WEbREREREREMkNgxoS68h7WhFm6dKl5/s4775hMI3fM1GCmUbly5UwWw8SJE1G+fHmcOXPGZH/wdbNmzcyyL730kinMHB0dbbJsmGlUsGBBM49ZGsxa8lQPidlOrCXj7++PqlWr4sknnzTZIb7UiWH76tWrZ2oGMVPj008/ReHChU0WErM9mP3E9hOzQa6++mqz32yfVXuI2SNUp04dVKlSxWT8UNeuXU2mGHFY0auvvurqIw6X+/DDD83QJW4/OVzHqlWrTLaNlQnywgsvmMwdy/3332+GJHF65ZVXcN1115ksG+I2mR3iCTOZWDPJ3h9+fn6mP3icmJ3FDB1mjc2aNQvFixc37xGzTbg8M2F69eqF77//Htdff71rKCAzaFgviMe6UKFCCAgI8Dh87OuvvzZZPVwHPfbYYyZTiv3PAuzW8e/SpYt5fscdd5hMo8uR3H4WK1bMLFOkSJEkQwyrV6/uypTisDNOnjB7idl2pUuXNuc9M/GY6RMcHIwFCxaY+Sz6zvUTswXvu+8+PProo+Y1zz0W7Oa5379/f3z55Zcmm8g6vsyS4/Hk+cY+YUYWt0UDBw7E4MGDXUMk2efse052zGY6efKkOVc4dK1GjRpmm/wOufvxxx9Nhh7PMeL6ee5FRESY10WLFjXHg/3J48TswREjRphzlZlY77//vsnKsvrVjll1ZB+652m59GJ9D3geMxuNvzfMVGM/8bssIiIiIiKS0RSUygC8IPWEQ8d4Ec2ABYcIcegVAxNr1641Q+zsARkOTeJEDGxw2BKH9fBCksGTEiVKXLJ+Duk7ffq0K7BFDCwwsHXq1ClzwZycu+++G8888wz++OMPdOjQwQy1qlu3rilyzfVaASdigIVDpOzDCO3DhRikYBDC/toalsVhTGvWrMFbb71lPs+L4WPHjpm2pmTXrl0mwGDflhWg4dCl1LTDHQMTDG5YOKywZs2auOGGG0w/MCDXt29fBAYGmuPAABmHaVl4DHlBb7XTCtZZNYwYIEwJ+8M9gMhhh/Z+tg+3YhDFGmKZVsntpzc8BhxGmRL2J891Bs8YpLTWXaBAAbNP3BcrIEUM+MTGxmLv3r2ugIkVjGUgixg4cz+e/M7xe8KhghyCyf7n98XXc4pts9dSuvHGG70u6x44tQKTVtus778VqLPOP+u1t/PPEwZUGWh2x2PFwPXl4JBJBrKt3wUGC/kd+PbbbxWUEhERERGRTKGgVDrhReLPP/9sghX2i1Q7ZlUwc4hZPn/99Rf+97//mYwjBne8OXfuHG666SZz4cgMCmbfcBuff/75JcvyYp7ZUSzW7c49O8QT1sdhJhHbx7pMrM9zzz33mGCVJwzC2C/6rYCMxVOmCTGTi1kpDE4wg4rBGtYs8gWDYSnxtR3uGEyw199i4IRtZQbcvHnzTJ0eXrDzkX3NvmJmjyfJBXSSYwVekutnX/ogNZLbz1KlSnn8DNvjS7+yTz/55BMTeP3zzz9NwHPy5Mlm8rav9kdP/egp6Mv2MAuLGUsMpvK7wmDdgw8+mGIbU3OsUlrW03xfzz9PmK3Ic81dehUjdw9UM1PQqv0mIiIiIiKS0VToPJ3wIpEFqFn02NPQPRYf5tAYZswwa4TDtFis+rfffjOZPQykWMPbiIEhDv9hoODo0aNmWBiDQyyYzMwJT3c+Y7YH53HID4ffcWL2EIcMecvesuOwQ2a/MOOEgQQG137//XcT0GJm1urVq13L8oJ/w4YNZpupxYAHs4GYlcVharww5nZ9uZsb94lZWyzobmHfWMOpLgezcrhuC4cJsh+Y2cUhkBxiyePI4tncb2bNMDPG6mv2D4+r1U778WSQhYESfja5Y8H1MovMjq/T0s++Sm4/vWHmnadsPXfMhnr99ddNcXQOyfvll1/M8E0O3eM+7d69O0mfsw8Z2KlYsWKq9oE3A+Awxy+++MIU+md2Fr83lNJ5xWwtDqk7f/686z22md9Xd+7HlZgRx/3KCMyyss4v+8Rz9XIxEMnhjvb+YdYiA9siIiIiIiKZQUGpTMKsEA4rYmYUM53WrVtn7nDG4VIMaDE4M3r0aJNRwnkMEDFIwGFSrFnDIBUDTLyQZPDL0xAgDsPiRezjjz9u7ozH9fMufsyEcc8e8oTt4pAgXnSzvtP8+fNN+4g1ZhjcYoYXAw3W3QGZlZJaDEIxeGcNsWKwgkEuX4Y1sd4P+4V1eriPvIsas0msmlGXg/tqv6Mgh1ux1hX7nH3PwAOPBYc5MauMwyKZKcX+YF/x+FnBAtaFYr2tadOmmYAHa2jx4p9Dv3g8WFuKARn3LBj2M+tHcbgm++fNN980x4PZchkluf0kDp/j+XD27FnXZ9hP1rnBfuDwS09Yk4xBSGbv8W6MzMBjDSt+lseMAVnW2+L6OJSM3w9mA/JzqcHlmZHEtnP9DKxZdwu0zivuB89xexDM+t4wwGYdS2Z0fffdd+Z9dwzY8nvF+m88rgzmsW+sobbZHffdOo4McPO4MQDHfWHfjR8/3mtmpIiIiIiISHpTUCoTMdDEbAwGGFj0mBeyVoYPs4ZYuJlZVBwy17JlSxOsYc0iZhW9+OKLJhDCIVW8eGZmkfswGwaeWLCYQ5mYhcWC0B07djRFm33BguG8OGdAhZ8vWbKkCf4Qh0ZxuB2DUX369MHhw4dNVlBaCjFzXyMjI01NLbaRwQ8WTWeWhi/GjBljAjssfM3i33xkIfjL1b59exMA4pBJqx4SA00sKs9hl+PGjTPb5hAnBhJ5Ac/AEgOK7GMW1mbdMLriiivw/PPPm2APjxv3jZ9nAIhBNWa7cMin+z4zyMfjzgAgP8dMOQ7VtBdgT2/J7SfxfHjjjTdcQR4G15hdxbpjxDpOngI4xJpp/BwzAlkfiUFPFszn8jxfraGmPN+sQvppqZXE4uY8f3lMGNRioJLHhFlXrMFmBZQY0HX/PnAZtoOZVcxOZF8wUMZsK3fM4OL+/PTTT2Y73C/2l7dhjtkNv2/cP2IAm/3EY8lzjTXeWFg/LYFmERERERGRtPDjLfjS9EmRXIgBGBa5tu5+J5dioIzBSd5Z7nLqJYmIiIiIiEjepitKERtmOnHolnjHu0dyiJcCUiIiIiIiInI5dPe9PII1cDgkzJv0uMV8euDQQNZS8obDszKyfg+Hlf34449YuHCh1yFp2RFrkfFujt6ULVs2XYpxs+YSi+lnZI0rERERERERyRs0fC+PiIiIMHdM84Y1ktLjjl6XiwEPFj33hrV7WJdJkmIxb/sdCd2xbhJrCImIiIiIiIhkFwpKiYiIiIiIiIhIplNNKRERERERERERyXQKSuUQmzZtwsqVKzN8O/v370etWrXMY0ouXLiAZ555xtR4Yv2lzz//HNnFv//+a25vn5EWL15saizR1KlT0alTp3RZ7zvvvIMpU6Ygs/B4//fffykux/3jstdcc415zRt3vvnmm2jVqhVatGiBN954A/Hx8WYel+Gy6dUnGenll182bbVPkyZN8rr8F198gfbt26NJkybm/D9//nymtldERERERCS3UFAqh3jggQewe/fuDN9OmTJlTJFvPqaEQYj169fjyy+/xPPPP4+xY8fi119/RXaor8RAw9ChQzN0O7fffjuOHz9unnfv3t0USE8Pd911Fz755JNka4ClJx5vBlh8wSDM5MmTXcXzf/75Z3PcWUR/1qxZ5j3iMlw2J2Bgcfjw4aYfrOnGG2/0uOxvv/1m9pc3BeB5v2bNGowZMybT2ywiIiIiIpIbKCglSQQEBCA8PNw8JicqKgo//PADRowYgXr16uHqq6/G3XffjW+++SbLe3T27NnmbnOVKlXKtG2y+HqxYsXSZV2FCxc2mWdW8Cej8Xjny5fPp2ULFSrk2s+vvvoKDz30kMmUY7YUM9Os489luGxOCUrVrVvX9IM1FShQwOOy3Gfe5fCqq65Cw4YN8eKLL+Knn35StpSIiIiIiEgaKCiViTZv3oybb74ZjRo1MsN/mHHhnt3TsmVLM/EC//Tp02bebbfdhgMHDuDpp5/GU089leJ2OKxq3LhxZuhU/fr1TYDDvi2uj68HDBhg2nLLLbe4hqG5D987ceIEHnnkETRt2hRt27bF22+/bdbPfYmNjU2SYdOsWTOTOWIN4UoJs2rYRq6D2UH79u1zte+zzz7DHXfcYS78b7rpJuzZswfPPvusWbZr165YunSp1/V+++236NKly2X3O3G7bBu3e+WVV5qgBFnD0gYNGoQPPvjgkuF77E9+jv1mbdPqFy7PzBxml3F+69atMX78+CT7wHV9//33rs+wT5I79gwQcsgcjzf3g8GSuLg4M4+f4z4OGTLE9GevXr2SDAW1D99jsPG5555z9Qf7nMM03R05csTc7e+KK65Icvx5nh49ehS+mDFjhmkzjwuPz8aNG13tZfYRzzvOYxYa53FYIwNgHTp0wJw5czyuk8fBfSieNXkakhoZGWn2pXLlyim2l/25bt060wZL48aNzd0ieY6JiIiIiIhI6igolU7OnTtnAgdt2rQxtYY8eeKJJ1CnTh0z5Gn06NGYMGEC5s+fb+Yx2Iv64eoAAQAASURBVMOhcAxOMPDBi+WHH37YFcQoXbq0GQ7FzKSUTJ8+3Qwt4jY4nI5D/7iODRs2uJbh8LBu3bqZi/hSpUph8ODBJkDjjp89duyYqbHz7rvvmuWZDcP3ihYtmiTDpkSJEiaAYQ/qePPdd9+ZQA2DQNOmTUNISIhrf+nDDz9Ev379zPbOnj1rAlNcP4fI1ahRwwRZPDlz5owJjDGAdrn9zn258847TdtY44nBGgZG5s2b5xqqx37lMnYnT540gb6SJUuaYBGDT+w/K6BlDQMLDg42+87gFWsz7dq1yzWfmUccGrh161bXdrwdewbo2B/Dhg0zx5sBKbbvzz//TNLf1atXN9tjIInHm+10N3LkSKxYsQIfffSRqRHG5zzu7nj8ifto4fGhw4cPIyULFiww+8Oso5kzZ5pg2r333us6B3n+sk4V54WFhZnlGCBloI4BO/app+AnA1j2YXj2ydOQVAYP/fz8TBCXwa4ePXqYPvIkIiLCnBP2fQ4MDDTt82WfRUREREREJKlAt9eSRrx4trJ3GLhg9os7ZpF07twZ5cqVQ4UKFUymUPny5c3QHwYtOAyIGR1WvSZmqmzZssW8x+F0HA7ly5AoXny/+uqrrjYwI4pBnm3btpmhdsQLcNZEolGjRplsHhYHZ8DHwuyPVatWYe7cuaa99MILL5hsGrbZfciX9dpTcMsdgwvcPoMIxIAPs6Oio6PNaw6Puvbaa81zZj1xSB6HijGAwGAVg2XeCsIHBQWZfr3cfmdmDQM3r7zyCkJDQ03fMGjj7+/vGsJWpEgRE7SyY/CLw7/YrwxaVKtWzQRxeAysPmcg48knnzTHlcMeGRRjcKxKlSpmPgNWbCszhGrXrm2W96ZgwYIm2MYMMuK+cR95vK33GJCyCr8z4+6vv/4yfXrrrbcmCegxqMXPMuuJWDuJferOOk72cyC1x//6668356YVOORxYxuIQSoG9ojL8Riw7zlMksFfZsMxaGcPEBHnc/LVzp07zTlVtWpV0xfLli0z2WE83hySmtI+W6992WcRERERERFJSkGpDMCLXE+YCcLMHF6QcyhYz549Tf0aZsNwCBCHMNkxE4TFza2Aia+YZcNsobfeestkgjCowKCIPbOEw8YsvABnMITL2oNSzNxhMMQKSJE1LI7Dp9wvxK3XvgQFuG4rQGZl2TBIY7EHlbg+1oiy+pWv2V+eMIjEQBEDR5fb7xxOyH5h/1i8FcC2Yz9y3xiQsnD4H48Bs22s/bPX7WJgi8Mh7dj3zA5KCQM47BMWG9++fbsJqHHYIYdtejre7BvWULKGbFr4GQ5Rsx8XDlWzD1fzFIBiAM16Tt7qMbkff3u/c33JHX+eH9Z55b499+Aws6g8+eWXX8x5ZMehjAyAWkE/BgB57Bn0cg9KedsuX/uyzyIiIiIiIpKUglLp5IYbbjAZMsy8YC0cTzhkitk/zDxipgqHJDGbhkEFYmFrZr3YFS9ePNVt4ZAxZpb07dvXZMrwYp+1j+zsARNiMMIeyCFmrnjDIX+8OxwDKda6GHRh4ICFulPivv2U5ru3zRsGrtyHdaW139N6Nz0reGFntcmq8+Spb1mry/0zvuw3h8Ixc4wBFma88TmH8KXn8fZ0/K1jbgWQrCF9DPhl1fHn0D7WofLEPavKOl/cs9CYNbVkyZJLluVyPLbM0GL2G/H853BVX/ZZREREREREklJNqXTCbBrWWmI9KU9D91iLhnV/mBHCAt5ff/21GYbG2kLMRGLWDC9uecc4Tlwfh+D5kinjjlkeDEywBhUDFaz9xPXYgx72wsys2bR3795LMrLYDraJBa0trIt0//33mxpNDBysXr3aNY/1hxo0aOBTAIHrtreBAS5meHkqRp0azKhhNpK1r5fT7yx+zewhDvOzvP76617rWVmYXcX6XfZsLg6D5JC/5IbhuWOfWHWaUgpCMoOLQ+0YiGTAhMfTfrztQ/AYkGLfux9vqz/sx4WBvN69e3sMSjHriMfcwud8z1PwJ6XjzzYxoGRfX1rw+FnH0n3yFAh77733XEMqLWwXA1PueF7z/La3kec/18sMKxEREREREUkdBaUyCTMseMczZugwm4p38Vq+fLkZRsULaQYTWK+Jd0HjECzW2GFAxMpCYSYPP+dLEXEGoRgc4xAp1il69NFHTYDEPuxo1qxZpiA6h3Cx4DSDCaylZMehfAwUcT6HhLFtn376qSkizuFKDHixzWvXrjXBCxbGds/I8oZ1gVjMmp9jOznkivtqH7aVFgy0MMPIGpp2Of3O4W8MCrHeFdfHwuEsGG4Ni+MxYd0mBvXcs+bY19bnuI8sVM76Sd6GdrpjwXXWwrKG0vG4u2/HwkAXg148RmwP717HrCX78Wa9Mx4f9gHrTzHQxjvf2bE/eEw5n8eUfcX6aDwHPOH+sEA7+44Th4smd/zZJqsuE48/h9qxqDj7m4FABtHsQwczA4fusY4U65kxkMesOX4vrOL1bK+VAUasc8VleUzZRzx3GOTU8D0REREREZHUU1AqE/ECn8EA3kmOd1xjrR5mHREDCcywYjFvXuQy+4IBIKvuEAMAzMRiseeUMEOKQQ3WTho6dKgJ1LA+jj1bhoETBlj69Olj7hzIQtueMknGjBljLrj79++P4cOHm0erADULZjOIwOFwHC7GbVmFtVPCtvHCn59jG5jRxJpIl4tDBxs2bJgkmyWt/c7nvAvd0aNHTbYQgzUMWrEulRVYYWF0Bpzcgzu8wx+DHAzyMCDGPnrwwQd93g8GmXjHRRYoJ/Ytt+8J18vhhjw2zAZjII7ni/14MwuJQ9LYHhZPZzFzT8Msee4w64frueeee0ygkkFNT9iXLFTP7fOOhTym7llHdgzmsbg68Q6ADESy+DvveMe28g54qSlSnh54rjBbasaMGaagOjPpGFxjDTBie+21ua677jpTo4wBR56//Pzjjz+eqW0WERERERHJLfwc7oVsJNdjMKVFixYm0JEbTZ061WS7cKhhTsWAH4fTWcGzy8HAG7322muXtR4GthiAYhDR1+MwduxYU8dLRERERERExJ0ypSTXYcbLwYMHzVC1nIi1pP7991+T7ZTdcAgh73CYEi7jbbihiIiIiIiICOnuezkMC3RbmS+eNGvWzAwdy0ocGpbcUDwOHWRR7ozCoubPPvusGRrGoVg5DWs/3XfffaY2WHbDuzqykP6vv/6a7HIc4slaYeXKlcu0tomIiIiIiEjOouF7OQzrP/GW9N6wJg/vjJaVePc7Zvt4w5pLrIEkIiIiIiIiInmXglIiIiIiIiIiIpLpVFMqh+DdyVauXIncbs6cOThx4kSmb5f1/nl3w+zi7bffxg8//ICcjMeRxzMr7Nu3D/Pnz8/w7fAulyyqb3nsscdMPbDsLCYmxtRd+++//y7pM949sXHjxuauigsXLkx2PT///DO6dOmCRo0a4YEHHvCp1lhexn6fMmVKlmzb/TzNDb/ZmWnx4sXYsWNHVjdDREREJFdSUCqH4EXf7t27kZsdOHAAjzzyCM6fP5/p2162bFmG1rlKDRZo/+OPP9C7d2/kZG+++WamBIY8eeaZZ7B27doM384XX3yBn376yfWad7QcPXq0CUBkRxcuXMCwYcOwbdu2S4Ky/I0pUaKE2Z+ePXuaOy3yhgGesG9HjBhhlvn+++/NkF3eMVK8++WXXzBu3Lgs6SL38zQ3/GZnJgZrkxs2LyIiIiJpp6CUZBu8MM6L23Y3fvx4E5AKDMzZ9yHITn2aWftYqVIllC1bFrNnz0Z2s337dvTr1w979+69ZN6SJUtMphQDs9WqVcO9995rMqa8BTImTZqEa6+9Fr169ULt2rXxxhtvmAAk1yF55/ctL3zHRURERCRjKSiViTZv3oybb77ZDHdp3749xo4d65rHzIqXX34ZLVu2NBOHAZ0+fdrMu+2228xfpJmJkNyd9+xmzJiBa665xmyL29y4caNr3tSpU80FZcOGDdGnTx+TJWTp1KkTfvzxR9x4441m/p133mm2zQwQrosZFFaWBdczYMAAkxHTpEkTXHnllUmGnHHICNvcunVr1K9f37Rn7ty5rvm1atXCe++9Z/Z3yJAh6Ny5s3mfj1z3Bx98gCeeeAKjRo0y62fbOKSIF8Rt2rRBq1at8NVXX7nWx2yNxx9/HE2bNkW7du3M56Kjo808DlXi5ydPnmz6nhfcXJb9vn//fgwaNMjVJvdhTZ5ERUXhueeecx0v3u2PWSjWOjikhX3MPmNmCi/WuQ2+5p3pjhw54nG93AcGNKy+IA6NYTYC96tt27ZmaJ91MXj48GE8/PDDaNGihWkHzyErS4d9yHPn448/xhVXXGE+yyE8vHPeVVddhebNm2PMmDFJjj0zKnh3RPbP4MGDcezYMdf8P//80wQhGjRoYD7L/WLhfeKxuv/++zFw4EDTFm532rRpZuJ609IvzBbjMDLOu+mmm7B06VLXPGu/7rrrLnOeduvWDQsWLDDz+B3hsvx+cbmUXLx4ESNHjjT9x/OM56Iv7WD/cht8zX2z9+N3332X5DX7J7XfVe4Hjw+PPeexDZz3zjvvmP7v0KGDa3gkz1m2wdNknc9sJ/eRmU3u1qxZg7p166JgwYJJ7uS5evVqj23m8myDpUyZMiYYx/c98eU85R07OY/rffXVV70GPGJjY813gN9xtvGhhx5y3ViB30H2WceOHc05zGN56NAhM4/fc/bH33//bY4JjzXbsXXrVvM7yOUZjOPvltX/nM918BzjuW8fQs0gH88/roffCZ6/1hAv6/fm+eefN2389NNPzW8hf0vZBraF+/zZZ5/hjjvuMOvnubVnzx7zW8J1du3aNck5z3byM9b5bh9uzPNr+PDhZnv8neBvLoPbyZ2ndvzN4Tq5HzzP7L/T7D/2Ac9B7hPXFRcXZ+a5/2a7Y6Yd/w3h/rBN/E3m9414fHmHVB5HHnNuw56Zx2PKTDx+luvnXT+t9lv9y3+r+LvG3zfuL/8t43eJn+G/HfHx8T5ti+vl95DDWvlvFY+lFWC1fr/4O8V+Tun3QkRERERSySHpIjIy0nHrrbc6Wrdu7Vi0aJHHZW644QbHCy+84Ni7d69j/vz5jkaNGjn+/vtvM+/VV1919O/f37FmzRrH5s2bHffee69j0KBBZt6pU6ccHTp0cHzxxReOiIiIFNvyzz//OOrVq+eYPHmyY/fu3Y5Ro0Y52rVr57hw4YLjp59+cjRu3Ngxbdo0x44dOxxjxowxrw8fPmw+e9VVVznatm3r+Pfffx3r1q1ztGzZ0nHFFVeYdW3dutW0cciQIWZZrovbufPOOx1btmxx/PDDD+b1ggULzPynnnrKLL9x40bHrl27HCNGjHC0aNHCtINq1qzp6Nmzp2nHtm3bzL7zPT6eP3/e8f7775v1vfPOO449e/Y4Hn74YUezZs1M32zfvt0xduxYR926dR0nTpww63vwwQfNPPYf19G3b1/H008/beYtWbLErIt9yvnso4YNGzq+//57R2xsrOO3334z2z569Kirfcl59NFHHd27d3csX77csX79ese1117reO2111z7dc011zhWr17tWLx4sdku+3T27NmmL7p06WKOiSd//PGHOdZ27MNbbrnFsWHDBsfSpUvNur7++mvTzq5duzruueces0887zp37uxat3V82Ac8D0aPHm3OuQEDBjg2bdpkjhfbyvVax75p06aO6dOnm/XxfOa2if3PdbG/9u3bZ44xz43PP//czOex4rp4nnAfz549a44XJ+v4pKZf2L4mTZo4Zs6cadr+5ZdfmuPF58S28TX3kW176KGHHB07dnTExcWZ7wjbzePB705KJk6caPqRx5HnFdfN9aXUDp6j3Aa3xfPGwnm1a9d2nDlzxrzm/vP3IbXf1SeffNLM++abb8w8HrfmzZub7xHb+fzzz5vvJveZy7MNniZP5zOPBb8TlpdeesnxyCOPJFmG2+U57gl/M/gbZnfTTTc5xo8ff8myvp6n3D5/C3j+sf8WLlzocdtvvvmm6SNun78b/G4MHTrUzGOfXX311eb84rG76667HL169TJ9xPOW+22d/7NmzTKvuTy3xe8yf594PljrYrv4G8n+fvnll83vD48n18d9ePbZZ835x3OnX79+5veH2LdcN38DeewOHDhgfr/53eYx4W8OzzOeWzz/uR/sIx7fd99912zv/vvvN/9mEM81fpa/hfwt/fPPPx1t2rQxv+Nk/VbyO87t8Thw+zt37vR6nlqOHz9uPsvjsH//fseECRMcDRo0MN+d+Ph4R58+fRzPPPOMOTbcL7aTv73k/pvtjv9WPPDAA6ZNK1asMN/3SZMmmXlfffWVo1u3bmad3F9ug69jYmLM/Ntvv911rPjvJD/LbVn9yzazv9kutpnnDI/1qlWrHH/99ZeZ//vvv/u0La6Xx5PnJv8t4+/UsGHDzDweb87nvxH8Hif3eyEiIiIiqaegVDrhRSX/48qJwRBPeMHPCw5e0NDKlSvNRUJUVJT5DzQv2Cy8oOV/sq33GDDgRYMveBHACyr7RSEvSrgt/qf9rbfeSrI8L6Z4oWdtxz6fQQVe9NkvVPkfcmJ76tevby5qLE888YTrApHz+R98Cy8e2D8HDx40r60ghsW6aOSjdaHFi09eGBEvTDifQT3iRRBfsx95Ycj+sgft2HfWe9ZFIgNr9n4aOXKkeW7N98Xp06cdderUSXJRv2zZMnPhY+3Xd999l+Ri/fHHH3e9fuONN0wgz5P33nvPcccdd7he84LMvs9W4GrGjBmOuXPnmiAT22PhhToDdbx4Yv/z+blz58w8XkBxXfagKYOovDi3jj0vai3cJpfnMeSF8LfffntJYM4K+vFY8SLZjueg/TxMTb889thjJlBrx6Cj9R4vBK3zzN5PVnCV89kmXzA4wot/K4DFC3NecPrSDm6D27Lj95vfC/v5kZbvKt+3goLWd4+/E9bFv3U8jxw54kgt96AUjyO/u3YMWjJQ6Am/Vwz82PF34sMPP7xkWV/OU66PgUwLf6c+/vjjS9bF3wIGjuy/hQzo8Dhw/VyPFRQnHlNum8E/6/fFPp/nP3+T7b93DDQR+59Bc/tx7dSpkwkI8zvFwI/13SJ+PxjYsP+e8BhZ2GZ+xyw8b6zAh3X+X3nllUl+73i8acqUKY7evXsn6Qv+3ljvcf8ZtGGwy8J+YjDV23lqYVCabeUfIqw+Zh/x3yX+VrRq1cr1bxYxIMZ1e/rNdsfvFQNzVvCH27KWZZCN67Kw7dwW32Mwzf13j/1rD0pZQTf7vwU8Z+2/L+PGjUtxW8TPWsEyYvDZ+nfO/fuS3O+FiIiIiKRezi5ak035+fl5fJ9DQzjshMNnONSNQ+HCw8PNsAwOCeDQHTsOPWBxc29DLrzZtWtXknXly5cPTz75pHnO4SUsaGzHYSv2OwtVqFDB9Tx//vwoV65cktfW8Aurhk7x4sVdrzn0wRq6xOEuHAbCO06xePeGDRvM+9bQD7Kv25Py5cu7+pPbtn/Ges1hQGw/+4tDmuz4HofE2NtrCQ0NNUOBUovr4z7Uq1fP9R6HhNiHM6XUh94KYfMOZkWLFk1yLMPCwpKsj3c8Iw4Jqly5MooUKeKax6E73CerbhCPjTUkKzg42NWn3trCz9v3gdtm33LIHc8jDpnj8E1OHL7Ec9jXY5mafuE2OTTNPtSM5x2H31i47/ZjSWk5nv379zdFqLluDi9j/3I4l6/tcOfv72+OiS93JEvuu+rpWLEQuXXeW8eTfbZ8+XLcc889HrfBYU32c9MTrssaLmzheq1teVre/Rzm6wIFClyyLPvQl/PUOobJfTc5pIvttH/3qlevboYXc+ggv+8cZmbh+VulShXTBj6m9rtp/z7wuHKII9fF7xSHLnM47Pr1683vG4dW8vjY2Y+fJ+7Hl0Mg7b931m8t18/h3xwuZuFvUEBAQJJ12V+HhIT49H2oU6eO+feIwwjZRxwq17dvX3Msua/sbw5BtLCPOSzaGjKZnLvvvtvcdIBDYPnbzKGB7EMO++WQzkcffdT0q4Xr5b95PAbuv3v8d8qdNd/93wbrPa4npW15+7fB/u+cr78XIiIiIpJ6CkqlE9bh4S3SefHAGjCesEYPL+4ZqPnrr7/wv//9z9TYYCCHWO/IXtOF7AEfXyVXINu6kLXjxY1Ve4PsFzZk/498StviuqzlWdNj1apVJnDBCzgG4Pgf+pTak9K+eGoPt1uoUCGPhZlLlSrlqnXDi/7LLdQbFBSU4jKp6UM7XpDag3bJbcvbsbQ/euo/b0HT5I4nL4h5DFlfhQEO3o3qyy+/TLE9ae0XbpdBFgY27exBEk99k5bjWaNGDfN9ZK0hTgwc87vMmj2+tMMTfp98OeYpFbN3n+9tnfwNYYDEE57/KeEyDDLa8W5jJUuW9Lq8+93I+Jrf8bScp+7fS2/HMrW/bRn1+8ZAB2tAMYDM7wRrEfG3//PPP/epTd7W760tDC6xJhPr2HmT1u8Dfw8++eQTc0dF1o1jAIn/FnHidqtWrYqPPvroks/x99aqKedNjx49TLv5bx6/W6z/xe8Ta3ERawpawUILg5cMsvrSdl/6zzrHvG0rNb/rKf1eJPfbKiIiIiKeqdB5OuFfVvmf0sWLF5v/hLtjAV4WzeXFF/8i/fXXX5s7Yf3222/mr728UOJfpPnXWk5cH4v9+pJt4Y6fZxDB/p9yXjitWLHC/KfcvRgxX7v/Zz01WUP2CxNmDdSsWdMUC+Z/1FmUmRciV199Nc6cOWOW8XaxcTn/oWf7z549a9Zh9SH/Es67gnnLSkrrtq3jZe9jXnTxjnmXi0FIe8YK94OvrWLNxOLuLCrOfeZf+u3LszA1L9QqVqyYpu3b94nHln1qFQFmMeG33nrLFAFmsWXOT+7C8XKPJ4tBW8eSE7OV/vnnH6Q3BnPmzZtnAsavv/46JkyYYL4r/O6l1A5P+8gACM9196yZ1H5XU4NBMnsb7VNKATRidhEzGa0bAxDbYM86cl/e3kaen5w8LZ+e52nhwoVNIMjeZ5s2bTJZOMwU4jrtxdmZzcPzNK2/b1y3/dhwu/w+sGj40aNHzXeR2UC88QILZ2fk94FZddxH67hyP/nviC+S2zazoXje8zvNbCJmAbFwPW8cwO1yv4oVK+baLr8PLErPdaa0T/z95/eIAW0GvvgHm99//90cR/7W8UYK1nq5TRap537yDpD8Dtnv5sh/W9IipW2l5++FiIiIiKSeglKZhH8x552bmBnFv6ivW7fO/DWYQxkYgOJwiRdeeMHcVYgZC8wy4sWUNbyDGVT8nPsQG094h6aZM2eaO59xHdadrDjkhRkuvHsd/2PN/5Dzznm80OJf/dOCd6HjHZ94YcNheryzG4MWDL5x+AcvQHgRwwsc3m6evAWJrKE/bE9Kf4F3x4sY3lWPdy3kX/x5gc27XbF9vChJibVtXvhYd9HzhseLmTOjR4822+Kx5MUX7wZ4uXg+cDin/a/yXO+IESOwZcsWc35w2B7vOMWJATKeK5y3ZMkSc34xa8OXffaEF9nMluAx4LAbboNDrziUhtvg/vK8ee2118x+JxfwY5/ybmNpuTMVz1PeEYzt4RAv3hWQk33IXnL4fWEgxJcLRQbeeCwZUOZF8KxZs1C6dGkT/EipHdxHBid4jlusobC1a9d2Dcn0dj4n913NTByGxAt1fmc4NJPnGI+19bvA48yLeivrhEEGBip5t02eKzwHOQTMPtzKkt7nKfuMWS9cD9vKY8ehXdbvKNfN7wnbxTts8liyDWnB4BOzn/jby+2cP3/e3N2N3wf+tjAYzWPPfuAfJVL6PjDQwvMytcNMmXHEgCEzpXh+zZ8/37TH10xaT+ephceAd7ZjNhTPf2b/8HvL3yIOUeOQOPYjjx3/zeLdAbk+BuZT+s1mv/F3n/N5rNhurpf43Xr33XdN1hH7hHe047+RzMxiMIzb5m8QP/vvv/+aQFhaJbctX39P2H7+ViT3eyEiIiIiqaegVCZi4IIXNbzQ4/AFDoNixot1+3FmWDGriBlU/Is/LwytoSa8CORFD/8znRJmtDBQxFtg82KGf+0fN26cyZhgTQ/+NZz/wec866KLQZ204IUsh+xwn/gXY/71mfVHGJTic2aCXXfddSaIcd9995ll7dkHdvxrPNvEv6bzIi+1mBXFIB4vQKz6KBxa4QtmP/DClfV9eOGUEl4sMejA7XA4Cm8Pzn69XFxPREREkr/gsx958cehj7ztOx8Z+OO5YQ2r4TkzbNgwUw/GCv6lBbO92GfWcEues1YggBf+7Ftum9kTrE3GOjrecNgm94PHNLXD6rgtHk8OIeI5y4Ans7R4bvuCwQkGQpnFkpKBAweaICMvvLkt7hNrZ7F/U2oHMwCZGcVz3AqAMWuCtX+sGkn8brgP6/Llu5qZrHOJgSfWx2GgjG1ijSPiMFwGCayMPe4fzzMuw3OFw6AYUEtu3el1nnIYdNeuXc3vBLfNgAADUcR6XMxa4u8o5/GPAQwiehoe6AtmrTH4xfOD58XEiRNNEIf7z/P/xRdfNMdt6tSpJmDEc8BbEJbBZWbpcKi3t99Ab3gusTYYAypsC/8d4HnLOoW+8HSeWvg9/+CDD1y/1TwuPEY83jx2/C7wszx2rN3VsWNH179DKf1m8w8tzBjk7wc/z+GgDLAT/w3kd4P9xn3ib8pnn33mGlLH84nBIH6O6+F56esQO3cpbSslbD9/B9hPyf1eiIiIiEjq+bHaeRo+J2IuxMaOHWv++izphwFKBtcefPDBTO1WXoBzmyrae3l4AcsLYHsReMmZ30NiQF0yF/94s2jRIjMs0wpE8YYDDNDr3xsRERGR3EWZUiLZDLN7mKni7e5Pkn1xaBWziZhBISJpwww3ZqMyE49D5Jipx+fdunVTl4qIiIjkMrr7Xg7DIRbWX/A94dA5DqOTtOOwHP6V3htryE5G4S3uOdyGmWjudyuU1GFdJN7l0hsOT2Nh5/TCC2cOEUrrMCMRcd5Fj98lDpnjkEkOX+RvbnoMkRYRERGR7EXD93IYFpN1vxW7HWvR+HILePGOBYE5fMQbFhe26gVJ9sbC0/Y7F7pj7TYWchYREREREZHMp6CUiIiIiIiIiIhkOtWUEhERERERERGRTKeglIiIiIiIiIiIZDoFpUREREREREREJNMpKCUiIiIiIiIiIplOQSkREREREREREcl0CkqJiIiIiIiIiEimU1BKREREREREREQyXWDmbzLniY+Px9GjRxESEgI/P7+sbo6IiIiIiIiISLblcDhw7tw5lCxZEv7+3vOhFJTyAQNSHTt2TM/jIyIiIiIiIiKSq82fPx+lS5f2Ol9BKR8wQ8rqzNDQ0PQ7OiIiIiIiIiIiuUxkZKRJ7rHiKd4oKOUDa8geA1IKSomIiIiIiIiIpCylEkgqdC4iIiIiIiIiIplOQSkREREREREREcl0CkqJiIiIiIiIiEimU00pERERERERkRwuLi4OFy9ezOpmSB4RFBSEgICAy15PrglKORwOfPDBB/juu+8QGxuLbt26YeTIkQgODjbzX375ZXz99ddJPvPss8/i1ltvzaIWi4iIiIiIiFz+tfDhw4dx+vRpdaVkqrCwMJQuXTrFYuZ5Iig1fvx4TJ48Ge+884655eDw4cMxduxY80g7duwwz3v37u36jO6kJyIiIiIiIjmZFZAqWbIkChYseFkBAhFfA6FRUVE4evSoeV2mTBnk6aAU0xQnTpyIJ598Eq1btzbvDR06FNOnT3ctw6DUXXfdhfDw8CxsqYiIiIiIiEj6XQtbAanixYurWyXTFChQwDwyMMXzL61D+XJFUGrbtm04deoUunTp4nqvR48eZqLIyEgcOXIElStXRl4XExuPfIGqby8iIiIiIpLTWTWkmCElktms847nYVqDUrkiOrF//34UKVIEK1euRK9evdCxY0eMHj0aMTExriwppjCOGzcOHTp0MMGqadOmIa/ZfvQs/vfJPPwy96+sboqIiIiIiIikEw3Zk5x63uWYTKno6GiT7eTJ2bNnzfy33noLTz/9NOLj4/H888+bRxYz37lzp+msqlWrmsLmy5YtM++zptTVV1+NvCLiwGY8f+oZ+K8MATp1BPwvv1K+iIiIiIiIiEiuzpRas2YNunbt6nHKly+fCUrxbnusKdW2bVs89dRT+OGHH0xgitlTixcvxp133onatWvjtttuQ//+/fHtt98iLylevhYuIBgBMRGI3fp7VjdHRERERERE8iCOdqpVq5Z5zEzc5n///Weed+rUCVOnTs3U7UsOzpRq2bIltmzZ4nHe0qVLzSMzoSxVqlTBhQsXcPLkSZQoUcLcqtCOyy5ZsgR5SYXihfB7oc64MmImoua+jsKOOKDWtcqYEhERERERkTzlxx9/VC2ubCDHZEolp27duggKCsLmzZtd77GOVEhIiAlGvffee7j99tuTfIbL2oNYeYG/vx/yNx+IDUH1cfxMJGL/fgP4dgCwejIQHZHVzRMRERERERHJFMWKFUP+/PnV21ksVwSlWBuqX79+GDVqFFavXo1Vq1bhzTffRN++fREYGIirrrrK1JH67LPPsHfvXkyePBnTp083w/nymr4tqmBu+QcxNbgn9p4LhCPyCLD0U+D8qaxumoiIiIiIiKQDh8OB6ItxmTpxm6n166+/mpuRNW3aFM8995zrZmUsxXPNNdegfv36ZtTUiy++iLi4ODPv4MGD5lq+SZMmpnwP4wDWXQjZhg8//BDt2rVD8+bNMWTIELO8J/bheyzx8/HHH+Ouu+5Cw4YN0a1bNyxYsMC1bEREBB5//HHTTq6b22QJIclDw/dSwhpSY8aMweDBg82JyDvsDR8+3MzjScVsqffff988litXzhRF50mc1+QPCsAT19bDo1Mu4t+L7fB05YNoUTQKKFopcaG9S4DSDYF8uq2oiIiIiIhITsLr4Sd+XIvNh89m6nbrlCmE129smKo7sk2ZMgXvvPOOCTg98cQT+OSTT0wQ6uWXXzbX9xwVtX79ehMQYgCKNaUZECpYsKBJNDlx4gQeeughMwpq4MCBmDRpEmbNmmWu91nG5/PPPzcBLL7H0VXJGTdunLlhGid+njdH++uvv+Dv748RI0aYwBfrUrNMENv30ksv4ZVXXkmHnsvbck1QisXOeaJw8qRLly5mEqBi8YK4o21lfDJ/J97aXRWftG8GV8WtU7uB354BChQDWg0BqnXmfR7VbSIiIiIiIjlETrmEe+aZZ9CsWTPz/OGHHzYjnjjSafTo0SYAReXLl8fEiROxbds2896BAwdQr149lC1bFpUqVcKnn36KwoULm2UnTJhggkoMbBEDR8xsYtYTM6OS07FjR/Tp08c8v++++9CzZ08cO3bMBKHmzp1ralkXKlTIzGdgjDdUe/rpp13vSR4PSknqdK9fBnM3HsGOY+fw1eI9eKhzDeeMC2eBkJLA2UPAn6OAbXOBDo8BISXUxSIiIiIiItkcM5WYsXQhNj5Ttxsc6J+qLClrVJOFWVHHjx9HhQoVTK0njnTavn27ueHZnj17THCJ7r77bhPM+uOPP8zQv+7du5vPnjt3DocPH8ajjz5qspssHGa3e/fuFNtSuXLlJCWCKDY21tSrjo+PN9uy43tsF4cYStopKJVHsej5vR2rmbTOPzcdwY3NyqNcWAGgdAOg31fAmm+BVV8DexcDP9wOtHkIqHF1zgm5i4iIiIiI5FEMDrF0S3ZnDx5ZNalYD3rYsGEmE6l9+/Z44IEHTE0pC0v1cCgfs5f+/vtvM3zvnnvuMfWgiCV7qlSpkmQ7RYoUSbEtnob3sU0cWshsqJ9++umS+aVKlUrlHkuuLHQuaVOnTGFcUbkY4h3AN0v2JM4IzAc0+x/Q51MgvJYze2reaOCvl/mtVHeLiIiIiIjIZdu6davr+dq1a1G6dGnMnDkTN954oxl6x5uXVatWzdywzApasQYVa0kNGDDA1KB65JFH8Pvvv5shfMWLFzdD7jisj1OZMmVMbapdu3aluY0McJ09e9YE+qz1MvvqjTfecBVml7RTUCqPu7VVRfO4YNtx7Dp+LunMYlWBXh8DV9wN+AcAJWoqU0pERERERETSBWszrVmzBv/++68Zrnf77bcjLCwMq1atMsP2WEeKNzVjoMkKAO3cudMErDZv3mzmz58/3wzfI37+3XffNQXKOWRv5MiRWLlypSmEnlYMijFj67HHHjOBsw0bNphaUlFRUa5aVpJ2Gr6Xx1UND0W7GiWwcNtx/LB8H564pnbSBRiManobULkdEGa7Q9+5E0CBosy3zPQ2i4iIiIiISM7HbCcWFeed7fr164f//e9/pq4Ugz79+/c3tZ1YgJzLbdq0yXzmhRdeMMP5brvtNlPz6corr3Td8IxD+Fhb6rnnnkNkZKSp9/TZZ5/5NHwvOcyK4h33GPQKDAw0QSoGvOTy+TmsHDjxiicz7wiwYsUKV8Gz3IQZUg99uwr+fsDHtzZDWdaWSs7F88DUe4DQUkCnkc7glIiIiIiIiGQqDiPj0DQOMWNxcJHscv75GkdRmougSokQNK9c1NSWmrbqQMo9cmwLEHkU2L8cmDoYOOqMWIuIiIiIiIiI+EpBKTFualbePM7ddAQnz6VQrK1sY6D3OKBIeWdwauZQYONMFUEXEREREREREZ8pKCVGvbJFUKdMIcTGOTBjtQ/ZUiyC3vsTZ62puIvAgreA+a8DsRfUoyIiIiIiIiKSIgWlxOWmZhXM45x1hxF5ITblngkOBbq+DLS8F/DzB7bMARZ9oB4VERERERERkRQpKCUuzSsVRcXiBXH+Yhx+W3/Yt57x8wMa3wJ0fxMoXg1odod6VERERERERERSpKCUJJ4M/n7o1bicef7z2oOIY+VzX5VvBvSZAIQUT3zv4GrVmRIRERERERERjxSUkiQ61gxHWMEgHI+MwaIdx1PXO/6202n7XGDWw8C8V1RnSkREREREREQuoaCUJJEv0B/X1i9jns9YfTDtvRNzzllnatvvwMyHgMhj6mkRERERERERcVFQSi7RvUFpBAb4Ycvhs9h8OCJtPVS3J3DdW0D+wsCxzcDUe4DD69TbIiIiIiIiImIoKCWXCCuYD1fWLHn52VLlmgK9P3UWQD9/Cpj1CLDpZ/W4iIiIiIiIpGj//v2oVauWeaR9+/Zh/vz5HudltaeeespM9MEHH+C2225zzePrZs2aoXnz5vjqq6/QqVOny95eTEwMpkyZ4nrN7XE7OY2CUuJRj8ZlzeOi7cdx9Gx02nupcBmgx1igSgcgPhb4ZwxwbIt6XURERERERJJVpkwZLFy40DzSM888g7Vr12b7XrvzzjtdAaIzZ85g7NixePLJJzFjxgz069cPP/7442Vv45dffsG4ceNcr7k9bjenCczqBkj2VKVECBqWL4K1+8/g5zWHcGe7KmlfWb6CwNUvAau+dhY9D6+Vnk0VERERERGRXCggIADh4eHIaUJCQlzPIyMjzWPr1q1Rrpzzbvf58+e/7G04HI4kr8PCwpATKVNKvOrZ2PmF+W3DYZyPibu8nvLzA5oOAlrck/jeuRPAiR06AiIiIiIiIunt4nnvU2xMKpa94NuyqdCjRw9MmjTJ9fqOO+7Arbfe6nr9/fffY8CAAUmG6HFo3NKlS03WkX1o3Ny5c9GlSxc0atQIQ4YMMZlJnjCT6IknnsCoUaPQpEkTM4SOWVhsR5s2bdCqVSsztM7C9Tz77LNmHofePf7440nWvXz5cvTq1QsNGzbEww8/jPPnE/vAGr7HdltD9dhG7sPUqVOTDN9bu3at2Ve2v1u3biYDyvLDDz/gmmuuQf369dGyZUu8+OKLiIuLw3///Yenn34aBw4ccPWP+/A9bufaa6817evTpw+WLVvmmsftf/PNNyZrq0GDBujZsyfWr1/vms9+uOqqq8w8fpb7mlEUlBKvmlcqirJh+REVE4e5m46kb0/xR/D3kcCMB4CdzjHBIiIiIiIikk4+v8b79MezSZf9qpf3ZWc/nnTZyf09L5cK7dq1MwEmunjxIlavXo1169aZ5/Tvv/+iffv2ST4zYsQIE0yyD42jadOm4e233zaBlA0bNmD8+PFetzt79mwUKlTIDKNjsOaRRx4xgamvv/7aBHVef/11nDx50iz74IMPYtOmTWaI3MSJE7Fjxw5XzSguc++995qA1fTp01G9enX8+uuvl2yPww4ZWCI+ch/sTpw4YfanTp06Zj+4Tg7z27x5s+mfl19+GcOGDTPrZkCKw/7+/PNP0w8cyli6dOkkwxvtASkG37g+to/tHDx4MI4cSbyuZx/yvZkzZ5o+4bZo48aNeOONN/D8889jzpw5pg4W+yk+Ph4ZQUEp8X5y+PuhRyNnttTMNQcRH580PfCyxMU4h/Uxov7Hc8DyiUAGneQiIiIiIiKSfTAoxcwdDkFjIKlixYooXLiwCYgw+MFMIPegFAMnQUFBKFiwYJKhasxgYoCJmUbMDGJAx5uiRYuarCZur3fv3jh79qwJFFWrVg133XUXYmNjsWfPHldQaMyYMWbdnPj8r7/+ws6dO02wplixYmbbVatWxdChQ01Wkafhh1yO+Mh9sPvll19QpEgRjBw50qyHWUnDhw9HdHS02c/Ro0eja9euKF++vMmYqlu3LrZt24Z8+fKZdVnDG/loZwXZmMnF9T722GOoWbNmkuw07j+zt6pUqWIy1axMKWZf+fn5oWzZsma7DEhx3zMqKKWaUpKsznVK4uslu3H4TDSW7T6JllWLp0+PBYcC174BLPkYWPcDsOIL4ORO4MqnncEqERERERERSbs7L83ccfFLGsTAoOnJLOuWy3LL95d9VJh9w+FuDLAwOMXXR48exYoVK0yAxd/f3wxZY4AkJQwwWRiouXDBbbihDYMsDLjY6zq513niXe0OHTpkgmQM2FgYuGIAiUGp7du3o3bt2q51EYNS9iF8vti1a5cJNHF/LQwQWdim999/32xvy5YtJmDGgF5KmNX1wAMPJHmvcePG5n1L5cqVXc9DQ0NdWWpcPwNYN9xwg2lb586d0bdvXwQGZkz4SJlSkqz8QQHoVq+0eT5jzcF0PvsCgDYPAh2fBAKCgF3/ADMfBCIO6aiIiIiIiIhcjqAC3qfAfKlYNti3ZVOBmT4MRDEbifWKWLOJ08qVK7F48WK0bds2ScAnOfaATko8BVY8fZ7t84T1nDh5KjTOLK7UCkwm0LNgwQKTOXX8+HGTNcbgVNOmTX1ab3BwsMe227OdvLW3QIECZqjhl19+iRYtWpihgGyHfehfelJQSlJ0fcOy8PcD1u0/g53HnHcOSFe1uwPXvwsUKOosfP73qzoqIiIiIiIiuZhVV4r1pOxBKdZIch+6l9mYIRUREWGyoizMVuKd9DivRo0aZqihFaAi1p9KrcqVK5sMKHuAi8PlJkyYYAJDN954I1566SWTqcRMrb1797qWTS5oxzauWbMmyXt8bc/88mbVqlX45JNPTOF3FlNnPStmnzGLLSMoKCUpCi8UjLbVS7hqS2WI0vWBPp8C5Zs7M6dEREREREQkVwelWKOJQ8dKlSplhopx+BuH83kLSrHO0u7du02B8IzEAFCHDh1M0XHeHY8Tn19xxRVmaNt1111n2sqaTwxcMYiUlqDNDTfcgNOnT5vC4twvZiWxkDkzxVg3iwEiBq04zJFF1o8dO2aGF1oZTbwbID/HWlh2t99+u6kfxSLnHCL45ptvmjpZN910U4pt4pDBDz/80ATFeFc/1r2Kiooyd/nLCApKiU96NC5rHudvPYbTUW63D00voSWB694CijjH9Br7VwBxSb9gIiIiIiIikrPxjnXFixc3GVLEWlK8qxxrNVnFwd0xY4jD2u6+++4Mbx/vxFehQgUT4GERdGZHMVhDrC3FQBTvGNizZ08sWrTIPKZW4cKFTVYShzBef/315s6Bb731lrkbH+/+x/7p37+/qTPFIXkDBgxwZWQxk6lSpUomsOWepdW9e3c8+uijZshfjx49TEba559/boJtKeG2GWzj/rFwPO8+yELnvnw2Lfwc7gMh5RJM0eMXhZFPRnHzquFT1mDrkbMY0KIibmmZWEwuw+z9D/j1KaB0A+DqF53D+0RERERERMTgXdqYCcNhWVahbpHscP75GkdRppT4rGdCttSc9YcQE5sxt4NMygEE5gcOrQGmDXHWmxIRERERERGRXEFBKfFZm2rFUTw0H05HXcQ/W49lfM9VbAX0+ggoXA44exiY8QCwc37Gb1dEREREREREMpyCUuKzwAB/cyc+q+B5poz8LFYF6D0OKNcMuHge+OM5YPlEwHYrSxERERERERHJeRSUklTpVq8UggP9sev4Oaw/EJE5vZe/MNB9DNAg4U4BK74A9v2XOdsWERERERERkQyhoJSkSqH8QehUp6R5Pn31gczrPf8AoM1QoOOTQL3ezqF9IiIiIiIikjmjWEQy4LxTUEpS7YaEIXzLdp/EwdPnM7cHa3cH2j0C+Pk5X0dHAIfWZm4bREREREREsoGgoCDzGBUVldVNkTwoKuG8s87DtAhMx/ZIHlGhWEE0q1QUK/acws9rD2Jwh2pZ0xDWlfprFHBgBdDmIaBer6xph4iIiIiISBYICAhAWFgYjh49al4XLFgQftYf8EUyMEOKASmedzz/eB6mlYJSkiY9G5c1Qam5G49iYMtKCAnOglMpPhYILgTExwEL3wFO7gDaPAwE6LQWEREREZG8oXTp0ubRCkyJZBYGpKzzL60Cc1Ok7oMPPsB3332H2NhYdOvWDSNHjkRwcLCZf/DgQTz//PNYunQpSpYsiUcffRTdu3fP6mbnWI0rhKFisYLYezIKf2w8gl5NymV+IwLzAZ2eBYpVA5aNBzbOBE7tAa5+EShQNPPbIyIiIiIiksmYGVWmTBlznXvx4kX1v2QKDtm7nAypXBeUGj9+PCZPnox33nkHISEhGD58OMaOHWseGaS69957Ub58eUybNs0Epp544glUr14dNWvWzOqm59gfvhsalcWH87Zj1pqD5nmAfxakiTI1tclAoFgV4M9RwKE1wLQhQLdXgOJZNKxQREREREQkkzFAkB5BApHMlCsKncfFxWHixIl48skn0bp1azRs2BBDhw7Fhg0bzPz58+fj0KFDGDNmDKpWrYqbb74ZHTp0wKpVq7K66TnaVbXDUSh/II6evYD/dp7I2sZUagP0+ggoXA44exj48yVnzSkRERERERERyZZyRVBq27ZtOHXqFLp06eJ6r0ePHvj888/Nc2ZGMVgVGhrqmv/RRx+hf//+WdLe3CI4MADX1neOH52x+mBWN8eZLdV7HFC5nXNYn3+uOL1FREREREREcqVccdW+f/9+FClSBCtXrkSvXr3QsWNHjB49GjExMWb+vn37TPGtN998E+3btzcBq7lz52Z1s3OF7g3KwN/fDxsPRWDbkbNZ3Rwgf2Gg22igRPXE93h3vhjdIlVEREREREQkO8kxQano6Gjs2bPH43T27Fkz/6233jJD+F555RXMmzcPr7/+uvksb1XIWlIREREYN26cCVw99NBDWLduXVbvVo5XPDQYHWqUMM9ZWyrbObwemPMkMPNBIOJQVrdGRERERERERHJaofM1a9Zg0KBBHue9/fbbJijFu+21aNHCvPfUU09h2LBhGDFihCn2xlsVvvDCC/D390e9evWwfPlyTJkyBQ0aNMjkPcl9ejYui7+3HMP8bcfxvzaVTaAq22Ah9HyhwIkdwLR7gatfAso2zupWiYiIiIiIiOR5OSZTqmXLltiyZYvHKTw83CzDIuaWKlWq4MKFCzh58qS5NWblypVNQMo+n8XP5fJVL1kIdcsURny8A7PXZbM+LVUP6PMpEF4LiD4D/DIM2Dgjq1slIiIiIiIikuflmKBUcurWrYugoCBs3rzZ9d6OHTsQEhJiMqQaNWpkiqHzLn32+eXKlcuiFufObCmas/4wLsQm9nO2EFoSuOF9oFonID4OWPC2c4qLzeqWiYiIiIiIiORZuSIoxbvq9evXD6NGjcLq1auxatUqU9S8b9++CAwMxPXXX4/4+Hi8+OKLpgbVN998gwULFpjPSPpoWbU4ShYKxtnoWMzbfCz7dWtQfqDzc0CLwc4hfcyW2vZ7VrdKREREREREJM/KFUEpq4ZUhw4dMHjwYDPxLnvDhw93Ba0mTpyInTt3mgDVV199hXfeecfUlpL0EeDvhxsalXUVPHc4HNmvaxmMajIQ6DoaqHmNcxIRERERERGRLOHnyJbRg+wlMjISzZo1w4oVK0yASzw7dyEWd0xchvMX4/Biz3poWrFozuiqi+eBvUuAaldldUtERERERERE8kwcJddkSknWCwkOROc6Jc3z6asOIEdgTPafN4G5LzgfY2OyukUiIiIiIiIieYKCUpKuejYuB38/YNXe09h5LDJn9G7RSs6hfZtmAbMeBiKzYU0sERERERERkVxGQSlJV6WL5Efb6iXM859W7s/+vctgVNNBwDWvA8GFgKMbgal3AwdXZXXLRERERERERHI1BaUk3d3YrLx5XLjtOI5EROeMHq7YEujzKVC8OnD+NPDzMGDN987hfSIiIiIiIiKS7hSUknRXLTwUjSuEId6Rg2pLUeGyQM8PgRpdAUc8sGYyEH06q1slIiIiIiIikispKCUZmi31+8YjOHP+Ys7p5aD8wFXPAG0fBrq8ABTIIXcQFBEREREREclhFJSSDNGofBFUCw9BTGw8fll7KGf1MutM1e8DlG2S+N7uhc5JRERERERERNKFglKSIfz8/NCnqTNb6ue1BxF9MS7n9vSZA8Bfo4HfRgBLxwPxOXhfRERERERERLIJBaUkw/AufKUK58fZ6FjM3XQk5/Z0aCmgdnfn81WTgF+GAVEns7pVIiIiIiIiIjmaglKSYQL8/dC7STnznAXP41j5PCcKCATaDAU6PwcEFQQOrgZ+usv5KCIiIiIiIiJpoqCUZKgudUuiSIEgHIm4gIXbj+fs3q7eGeg9DihWxZkp9fOjwKpvAEcODbaJiIiIiIiIZCEFpSRDBQcG4PqGZczzn1bshyOnB3CKVgJ6jQNqXgM44oHzp5yF0UVEREREREQkVRSUkgx3XcMyyB/kj13Hz2Hl3lM5v8eD8gNXPgV0HQW0vDfx/fj4rGyViIiIiIiISI6ioJRkuEL5g3BNfWe21HdL9+X8bClidlSVDkBAkPN1XCwweziw/icN5xMRERERERHxgYJSkin6NCmHoAA/bD58Fmv3n8l9vb7jL+DASuDf94G5LwAx57K6RSIiIiIiIiLZmoJSkimKhuRD13qlzfPvl+/Lfb1e42rnHfr8A4CdfwNTBwMndmR1q0RERERERESyLQWlJNP0aVoOAf5+WLf/DDYejMhdPc/hfA1uAnp8AISWBM7sB6YNATbO1HA+EREREREREQ8UlJJMU7JQfnSuXdI8n5Ibs6WoVD3gxglAxVZAXAyw4C1g2YSsbpWIiIiIiIhItqOglGSqm5qXh78fsGLPKWw7cjZ39n7+IkC3V4FW9wPBhYCa3bK6RSIiIiIiIiLZjoJSkqnKFCmAjjXDc3e2FPn7A436AwO+A8IqJr5/eD0QH5+VLRMRERERERHJFhSUkkzXt3kFU4Jpyc6T2HU8l9+lLjg08fnB1cDMocCcJ4Cok1nZKhEREREREZEsp6CUZLoKxQqiTbUS5vkPuTlbyl3UcSAgCNi/DPjpLmD/iqxukYiIiIiIiEiWUVBKskS/5uXN48Ltx7HvZFTeOArVuwC9PwGKVnZmSs0eDiwdD8THZXXLRERERERERDKdglKSJaqGh6JV1WJwOIDJS/fmnaNQrIozMFXnBpidXzUJmPkQcPZIVrdMREREREREJFMpKCVZ5paWlczjwm3Hc39tKbug/ECHx4DOzwH5QoAj64EDGsonIiIiIiIieYuCUpJlqpQIQdvqztpS3+albClL9c7AjROAprcBta7N6taIiIiIiIiIZCoFpSRL3dKiorkT3+IdJ7D9aGTeOxqFywJX3A3TCRQd4RzOd3h9VrdMREREREREJEMpKCVZqmLxguhYM9w8/+a/PToaK74ADq0BZg4Flk9UEXQRERERERHJtRSUkix3c4uK8PcDlu8+hc2HI5CnNb8TqNEVcMTDBKgYnDpzIKtbJSIiIiIiIpLuApHBFi1ahAULFmDDhg04efIk/Pz8EB4ejrp166JDhw5o0aJFRjdBsrlyYQVwVe2S+HPTUXyzZC9G9aqPPCs4FOg0AqjYEljwDnBkA/DT3UDbh4Ca1yQO8xMRERERERHJ4TIsKDVt2jSMGzcO586dQ+vWrdG2bVuEhYUhPj4ep06dwpYtW/DYY4+hYMGCuOeee3DjjTdmVFMkBxjQoiLmbTmG1ftOY/2BM6hfrgjytOpdgFL1gXmvOIfz/f0acCESaNg3q1smIiIiIiIikn2DUrfddhvKly+PMWPGoGHDhskuu3TpUnz//feYOnUqvvnmm4xojuQApQrnR9e6pfDr+sOmttQrvRuYrLo8rVBp4Pp3gTWTgU0/AzW7ZXWLRERERERERLJ3UOrFF19E1apVfVqWw/c47dixIyOaIjlIv+YV8OemI1h/IAIr955Cs0rFsrpJWc/fH2hyK9CgHxCYz/mewwFs/hmofjUQlD+rWygiIiIiIiKSfQqdz5s3D0eOHEnVZ6pVq5YRTZEcJLxQMK5rWNY8/2LRHsTHO7K6SdmHFZCibb8D/7wJ/HSXs+aUiIiIiIiISA6UIUGpKVOm4KqrrjLD+Pj8zJkzyGgOhwPvv/8+2rRpYzKvnn32WVy4cMHMe+qpp1CrVq1LpkGDBmV4uyR1+jYvjwL5ArD7+DnM33pM3edJwRJASDhwZj8w40Fg6XggNkZ9JSIiIiIiIjlKhgSlfvvtN/z4449o0qQJJkyYgHbt2uG+++7D7NmzXYGi9DZ+/HhMnjwZb731ltnmkiVLMHbsWDNvxIgRWLhwoWtiDat8+fIpKJUNFc4fhJualTfPWVsqJjY+q5uU/ZRvBtz0OVCjK+CIB1ZNAqYPAY5vz+qWiYiIiIiIiPjMz8EUowy2fv16/Prrr2Y6efIkOnfujOuvv94EqwICAi57/XFxcWZdTzzxBHr37m3emzlzJqZPn47PP//8kuXvuusuFCtWzBRi90VkZCSaNWuGFStWIDQ09LLbK8mLvhiHwV+vwKlzMbi7fRX0bFxOXebNzvnAgreA6DOAfyDQ9mGgbg/1l4iIiIiIiGQZX+MoGZIp5a5+/fp47LHHMHfuXHz55ZcoW7YsXn/9dbRv3z5d1r9t2zacOnUKXbp0cb3Xo0cPjwGpxYsXY9myZRg2bFi6bFvSX/6gANzSoqJ5PmX5PkTFxKqbvanaEej7BVC5HRAfC4Q5+01EREREREQku8uUoJSFWVKbN28206FDh1CpUqV0We/+/ftRpEgRrFy5Er169ULHjh0xevRoxMRcWmfn008/NdlUZcqUSZdtS8a4um4plAsrgIjzsZi68oC6OTkFiwFdXwZ6fwKUbZz4PofzxWv4o4iIiIiIiGRPgRm9Ad6F7/fffzcTg0Y1atRA9+7d8fzzz5uMKV9FR0d7vaPf2bNnzXzWk3r66acRHx9v1s9HFjy37Nu3z9SaYo0pyd4C/P0wqHUlvDpnM6avOoDrGpRB0RDbHegkKT8/oGTtxNdnDgAz7gdK1AA6PgWEVVCPiYiIiIiISO4PSu3du9cViGI9qXLlyuG6664zgaLq1aunaZ1r1qzxWpj87bffNkGpkSNHmjvvWXfc4xA9BqD8/f1dBdjr1KmT5jZI5mpdrThqliqErUfOYvLSvXjgKh03n53aDfgFAIfXAz/eCTS/E2jYD/C//BpuIiIiIiIiItk2KNW1a1eEh4fjmmuuMYGihg0bXvY6W7ZsiS1btnict3TpUvNYtWpV13tVqlQxd/rjkMESJUqY9xYsWGCKrEvO4OfnhzvaVsbTU9fh9w2HcX3DMqhUPCSrm5UzVG4L9J0I/PMmsH8Z8N84YOffwJVPAcWqZHXrRERERERERDKmptTEiRMxf/58k6WUHgGplNStWxdBQUGmVpVlx44dCAkJQVhYmHnNmwyuW7cOTZs2zfD2SPqpX64I2lQrjngHMGHBLnMcxUeFSgPdxwAdnwTyhQLHNgM/3Q2snqwuFBERERERkdyZKdW6dWvX86ioKPzwww/YuXOnx8Ljr7766mVvj7cX7NevH0aNGmXu6sfAxZtvvom+ffsiMNC5iwcOHMC5c+c0dC8Hur1tZSzdfRKr953G8j2ncEXlYlndpJxVa6p2d6D8FcDCt4E9i4DY6KxulYiIiIiIiEjG332PdZ0++ugjREREZOh2WEOqQ4cOGDx4sJnat2+P4cOHu+afOHHCPPIufZKzlClSAD0aOYvif7ZgF2LjdEe5VAsNB7q9AnQdBTS5LfH9yKNA7KXBYhEREREREZGM5ufI4PFQTZo0weeff24ec6rIyEg0a9YMK1asMFlZkvnOXYjFvV+vwJnzFzG4Q1XckBCkkssQFwtMuxeIjwU6PA6Urq/uFBERERERkUyLo2R4phSLj/POeCKXIyQ4EANbVjTPJ/+3F2ejL6pDL9eZfUDUceed+mY+CCx4G7gQqX4VERERERGRnFtTyu61117Dgw8+iBtuuAFly5aFv3/SOFivXr0yugmSS3StVxo/rzuEvSei8N3SfbinQ+LdFiUNeBe+fl8BSz4GtswBNs4Adi8E2j4MVOngrEclIiIiIiIiklODUlOmTMGePXvw7bffIjg4OMk8Pz8/BaXEZwH+fri7XRU8N2ODCU5d26A0yhctqB68HPmLAFc+BdS42pkpdWY/8MdzQKW2QKcRQL4Q9a+IiIiIiIjkzKDUjz/+iLfffhvdu3fP6E1JHtCkYlFz971lu0/i03924sUe9UxwUy5TuWbATZ8DK78C1nwLXDgDBBZQt4qIiIiIiEjODUoVLVoU1atXz+jNSB5yd/sqWLXvFFbtPY3FO06gTfUSWd2k3CEwGGhxD1C9M+AfBFhDbWOigLOHgOLVsrqFIiIiIiIikotkeKHz559/Hi+99BIWL16Mffv24eDBg0kmkdQqG1YAfZqWN88nLNyF6Itx6sT0VKwqEFYh8fXyz4Gp9wD/fQpc1E0LREREREREJIdkSt17773m8Y477kgyzMrhcJjXmzZtyugmSC7Ut1l5/L35KI6evYAflu/Dba0rZ3WTcqf4eOcd+uLjgNXfADv+BNo8BFRum9UtExERERERkRwuw4NSf/75Z0ZvQvKg/EEBuLt9VbwyexN+WnkAneqUQrkw1UBKdxzC1+UFoHoX4N/3gLOHgd+eASq1cQanCpdJ/22KiIiIiIhInpAhw/c4VM9Srly5ZCfLokWLMqIpkou1qloMzSoVRVy8A5/M32Gy7ySDVG4H9PsKaDwQ8A8E9iwCpgwCdi9Ul4uIiIiIiEj2CUrxjnu33XYbZs+ejXPnznld7vz585gxYwYGDBhgPiOSGhz+ObhDVQQG+LmKnksGCioAtBwM3PQZULYJEBAEhNdRl4uIiIiIiEia+DkyKL1kyZIl+Pjjj7Fq1So0bNgQVatWNXfii4+Px+nTp7FlyxZs3rwZjRs3NnWn2rbNvjVqIiMj0axZM6xYsQKhoaFZ3Rxx8/WSPZiybB/CCwXjo4FNzdA+yWD82TizP2lB9LU/AFWvBELD1f0iIiIiIiJ5WKSPcZQMC0pZdu7ciYULF2Ljxo04efKkyW4pXrw46tati/bt26NSpUrI7hSUyt54970Hvllpip73blIOd7arktVNynv2/gfMecKZTdXsdqD+TUBAhpesExERERERkRwcR8nwq0ZmSHESySjMjLrvymp4cdZGzFh9AB1qhqN6SWW0ZaqQEkCp+sCR9cCSj4Etc4A2Q4HyzTO3HSIiIiIiIpK3a0qJZLbmlYuhfY0SiHcAY//aZoqfSyYqXg3o8QHQ8UkgfxHg1G7gl+HAbyOAiIM6FCIiIiIiInIJBaUk12DR85DgAOw4dg6z1igQkun8/YHa3YH+k4D6NwJ+/s678815EoiPz/z2iIiIiIiISLamoJTkGmEF8+HOts56UpOW7MGRiOisblLelL8w0PYh4KbPgXLNgCvudgasiMGpjC1jJyIiIiIiIjmEglKSq1xdtxTqlyuMC7Hx+PjvHcjgOv6SnGJVgOveAqp0SHxv8yxgxoPA0c3qOxERERERkTwuU4JSrLb+0EMPoWfPnjh06BA+/fRT/PLLL5mxacljeHfHBzvVQFCAH1bsOYV/th3P6iblbX5+zoni44DVk53F0KcPAf5+HYg6mdUtFBERERERkdwalPr9998xePBglCtXDrt27UJsbCwCAwPx1FNPYfLkyRm9ecmDyoUVQP8rKpjn4//ZiTNRF7O6SUL+AUCPsUCNrs4hfFtmA98NBFZNAmIvqI9ERERERETymAwPSo0dOxYvvPACnnzySQQEBJj37rzzTrzyyiuYOHFiRm9e8qg+TcujUvGCOHP+Ij6evyOrmyOW0HCg0wig54dAeG3gYhSwdDzw/W3A/hXqJxERERERkTwkw4NSe/bsQePGjS95v2HDhjhy5EhGb17yqKAAfzzSpSb8/YB/tx/Hgm3HsrpJYle6PtDrY6DTSCC0JHDuKBBcSH0kIiIiIiKSh2R4UKp69epYsGDBJe9PmzbNzBPJsHOvZCj6JQzjY9Hz01Ex6uzshHfkq3E10H8S0HU0EF4zcd6WOcDpfVnZOhEREREREclggRm9gaeffhpDhgzBkiVLcPHiRYwbN85kT61fvx4ff/xxRm9e8rh+zSvgv50nsev4OXz09w48fW1tUwxdspHAYKBy28TXZ/YD/7wJwAHU7Qk0/R9QICwrWygiIiIiIiI5MVOqefPmmDNnDqpVq4ZOnTrh9OnTZjjf7Nmz0bp164zevORxzmF8NeDv74fFO05g/lYN48v2/PyB8lc479a3fqqzGPrqb4FYZbqJiIiIiIjkJn4OB2+DJcmJjIxEs2bNsGLFCoSGhqqzcqDvlu7FN//tRWhwID4c2BTFQvJldZMkJSx8vuQj4MR25+vQUkDzO4Aa3ZxD/0RERERERCRHx1EyfPges6M8DZfie0FBQQgPD8e1116LAQMGZHRTJA+7qVl5LNl5AjuOncMHf23Dc9fX1TC+7K58M6DPeGDbb8Cyz4DII8C/7wMVWwEFimZ160REREREROQyZXi6wa233opTp07huuuuw4gRI/DMM8+gR48eZhhfhw4d0LFjR1Nbavz48RndFMnDAgP88ejVNREY4Iflu09hzvrDWd0k8QUzompdC9z8DdDqPqD5nUkDUscTsqhEREREREQkx8nwTKnp06dj1KhRJihl6dy5M2rVqmWKnnN+nTp1MHLkSNxzzz0Z3RzJwyoVD8HtbSpjwoJdmLBgJxqUK4IKxQpmdbPE12LojW6+dHjfL8OACi2BFoOBErqbp4iIiIiISE6S4ZlSe/fuRe3atS95v0aNGti5c6d5XrlyZZw4cSKjmyKCGxqWRZOKYbgY58CY37YgJjZevZJTndwB+AcA+/4DfroL+HMUEHEwq1slIiIiIiIi2SUoxTvtffDBB4iKinK9x+cffvghGjZsaF7Pnz8flSpVyuimiJi78D3SpSYK5Q/EruPnMGnJHvVKTtWwH9DvK6BaJ+fr7XOB728DFr4LnDue1a0TERERERGRrL773r59+zBkyBAcPnzYZERxc3v27EGZMmXw/vvv4+DBg7jvvvvw3nvvmaLo2ZHuvpf7sOj56F82meejetVH4wphWd0kuRzHtgLLxgP7ljpfF68O3DiBd1RQv4qIiIiIiGTTOEqGB6UoLi4OixcvxtatWxEQEGCG7rVu3drc/ezkyZNmmWLFiiG7UlAqd/pw3nb8uv4wiofmw/sDmqBw/qCsbpJcrgMrnXfqq9cbqNHF+V5sDHAxCiigwKOIiIiIiEh2iqNkeKFzYiCqXbt2ZrLExMRg06ZNaNSoUWY0QeQSd7WrgrX7T+Pg6Wi8N3cbRl5XxwRKJQcr1xQo2yTpe5t/BpaOB+r3ARr2B/IXzqrWiYiIiIiISGYGpVauXIkXX3wR27dvR3x8/CXBqvXr12d0E0Q8yh8UgMe71cbjP67B0l0nMWP1QfRqUk69ldO5Bxb3L3NmSq2aBGyYBjTo65yCvUfrRUREREREJBcUOn/55ZdRrlw5jBs3DgUKFDBFz0eOHImwsDC88cYbGb15kWRVLxmKu9tVNc8nLtqNzYcj1GO5TbdXgK4vA8WrATHngBVfAN/eDKz8GohJvAGDiIiIiIiI5LKg1LZt2zB8+HC0b98e9erVQ1BQEAYOHIjnn38en332Wbpth6WxWDi9TZs2aNGiBZ599llcuHDBNX/58uXo06ePuRtgz549sWjRonTbtuRs3RuURvsaJRAf78Abv27B2eiLWd0kSe/MqSrtgT4TgC4vAEUrAf9n7y7ApKq7MIC/28vu0t3dKUhKiCCloqJgY8enYmB3IBa22NhYICCiWCAiICAh3d2dy/bufM/7v3tn7w4zu7Nd7+957rcTd27P+N3DOecffxJYNA6Y86qOtYiIiIiISHENSjE7imV61KBBA6xfv948btOmDbZu3Zpr6/noo4/w9ddf49VXX8W4ceOwYMECjB071rx3+PBhMwLgoEGDMG3aNAwcOBC33367GRFQhH2k7jynEaqXDcfBk/F4/Y+NJsgpxUxgINCwN3DpZ8A5TwDlaltlfLbYo0DssYLcQhERERERkRIlz4NSXbp0MYGi/fv344wzzsD06dNx7Ngx/PnnnyhTpkyuje736aef4qGHHjKj+jHgNWLECKxevdrd14qBsZtuugm1a9c2AaqwsDAsW7YsV9YvRV9EaDAeHtgMIUEBWLTtCKb8t7ugN0nyMjjFkfmGfgFUaZb2+pLPga8vA+a/C8RYo4KKiIiIiIhIEQ5KPfbYYzh+/Dh+//13nHfeeWYoQAaqXnjhBdxxxx25ViJ49OhR9O2bOgQ8gMGDB+OTTz4xj9m/ioEwbgMzYGbMmIFTp06hSZMmubJ+KR4aVI7CLT2t/lKf/7MNq/ccL+hNkrwOTtk4CMOhjUBSHLDiOys4Ne9NIPqAzoGIiIiIiEhRHX2vatWq+OKLL9zPv/zySzMSH7Ok2F8qN+zatQtly5Y1GVGvv/66CVD169cPDzzwAEJDQ3HmmWeaPlZ33XUXAgMDTWYVg2IsJxRx6t+yGlbtPoHZGw7ixV/W4fXL2qFSVJgOUkkIUF04Fti5EFj6BbB/NbBqMrDmR6DpQKDdVUCZ6gW9lSIiIiIiIsVKnmdKNW/eHEeOHEnXv6dx48ZISkpCnz59/F5OXFwctm/f7nU6efKkeZ9lgizhe/755zFr1iy89NJL5rPMitq5cyfuvPNOTJw40ZTvcVTAzZs358k+S9HvL1WvUiSOxSTihenrkJCUUtCbJfnVEL1OF+DCd4DzXgOqtwVSkoC104A1U3UOREREREREikKm1A8//IDJkyebxyyXY5meZ1bUgQMHULlyZb+XuXz5cgwfPtzre6+99poJSj3++ONm5D16+OGHMXLkSFM+yMbn3A4GpYijAK5YscJkcD3zzDM52FMpjsJDgvDYoOa497tl2LD/JD78ezPuPKdxQW+W5GdwqlYHa9q7HFj+HdBmWNr7B9cDibFW0IrzioiIiIiISOEJSp177rmmpI7+/fdftGvXDpGRkenmiYiIMPP5q3Pnzu6R+zxxHeQsx6tfvz7i4+NNlhYbnjdr1uy0DC72ohLxplrZcDwwoCme+XE1flu9H42qRGFAK5VvlTgMPHFyWvgBsHsJUKUF0PZyoF6P9P2pREREREREpOCCUgxA2VlJNWvWNA3O2dspr7Ro0cJkYq1btw7du3c3r7E0j9vBJudVqlQxfayctmzZglq1auXZNknR175OeVzTtZ5pev7+7C2oWzESzavnzoiRUkSlJANlawL7VgIH1gB/PAmUrQW0vQJo3A8IzrvfORERERERkeImz8r3nD16pk+f7nPeiy66KMfr44h+w4YNw6hRo0wfKZbqvfLKKxg6dCiCg4PN3yuvvBKfffaZ6WM1c+ZMzJ07F1OmTMnxuqV4u6R9TWw8cBL/bDqM56evVePzki4wCOhxH9DhemDVJKvX1PFdwN9jgMWfAJ1vBZr0L+itFBERERERKRICXIzg5LJzzjnHv5UHBJgAUW5ISEjAmDFjMHXqVBOUGjx4sGl6bmdocT1vvfUWduzYYUr77r//fnTr1s2vZUdHR6NDhw5YsmSJCYBJyRKbkIz7v1+OHYdjUL9SJF66pA1KhQYV9GZJYZAQA6z7GVjxHXDqINDrIaDZoILeKhERERERkQLlbxwlT4JSxY2CUrL/RBzun7jcjMjXqX4F0wg9MFBNriVVciKw5S+gwdlAUOqgDqt/APYsBVoPA6q10qESEREREZESI9rPoFSelO954kh7X331lenzlJycbBqSs6SuXr16+bF6kRyrWiYcjw5qjsemrMS/W4/gs3+24Ybu9XVkxcJAVGPHwA0pKcDKiVZp35bZVlP01pdaQSuWAIqIiIiIiAjyfMioxYsXo3///li4cKFpLM5p0aJFuPDCC03ETKSoYJPzu/s2MY+n/Lcbv63eV9CbJIUVR+M791mg6SArYMWm6DOfBb65HFj2DRB/sqC3UEREREREpMDlefnepZdeiq5du+K+++5L9zobkTNg9e2336KwU/meOH29cAe++XeHKd97dnBLtK1dTgdIfIs5YjVEX/MDEHvMeq3hOUDfp3TURERERESkWPI3jpLnmVIbN27EJZdc4jVYtXbt2rxevUiuu6JTbfRsUgkpKS688Mta0wBdxKeICsCZ1wNXTrQaoVeoD7S8OO39E3uBHQutkj8REREREZESJM+DUjVr1sSKFStOe3358uWoVKlSXq9eJNdx1Mi7+zRBs2qlcSo+GU/+uAqHouN1pCVjwaHWyHyXfgpUa532+qrvgV8eBCZcA6yYqNI+EREREREpMfK80flNN92Ep556Clu2bEGbNm3cAakvv/wSI0eOzOvVi+SJ0OBAPHFBCzz0/QrsOhqLp6auxouXtEbp8NSR10R8CfAYtTEkAgiNtJqizx8LLBpnNU1nNlXFhjqOIiIiIiJSbOVJT6nExESEhKTdnE+ePBnjx483o++FhYWhfv36uO666zBw4EAUBeopJb4cOBGHB75fgSOnEtCyRhk8c2FLhAVrdDXJooQYYNMMYPVk4MjWtNfrdQf6j9bhFBERERGRIsXfOEqeBKU6deqEAQMG4PzzzzePizoFpSQj2w6dwkOTViAmIRldG1bEwwOamSboIlnGn+O9y4HVU4CtfwNtLgO63Jb2HpumR1bUgRURERERkUKtQBudP/744zh06JAp3evVqxdeeuklNTWXYqtepUg8cX4LhAQFYP7mw3hv9mbk8aCWUpxL+2q0A859BrhyAtBmWNp7u5cCX10K/PaYGqOLiIiIiEixkCc9pQYPHmwmRsZmzJiBX3/9FcOGDUPt2rVx3nnn4YILLkCdOnXyYtUiBaJVzbK4v19TvPjrOvy6ah+iwoIxvGtd0xRdJFuiKqd/vmcp4EoBts21ptLVgGbnAU0HAZEaNEJERERERIqePCnf84YBqj/++MMEqObPn4+mTZua4NTw4cNR2Kl8T/z166q9eGfWZvP46i51cFlHBV8lF7Hf1LqfgA2/pY3SFxAI1O0GnP0IEOY7LVZERERERKRElO95w424+OKL8cEHH+DDDz9EUlISXnjhhfxavUi+GNCqOm7qUd88Hr9gB6Yu260jL7mnQn2g2wjg6klA78eA6m2s7KnjO60R/GyJsTrqIiIiIiJSMsv3PDEZa9GiRfj9999NOV9MTAz69u2LBx54ID9WL5KvLmxXE3GJySYoNW7OVoQFB5pglUiuCQ4DmvSzpqPbgNhjVj8qSowDvhoKVGsDNBsE1O4CBOXLT72IiIiIiEiW5NmdCjOh/vnnH1OyN3PmTBOIYtNzNkHv2bMnQkND82rVIgVu2Jm1EZeYgu+X7MK7f21GWHAQejerUtCbJcVR+XpAeY/eUyzt2z7PmkqVBxqfCzQZAFRsWIAbKiIiIiIikg9BKWZAzZ492wSiunbtigcffBDnnnsuIiMd5SUixRgbnLPReXxSMqYt34s3ZmwAAoDeTRWYkjzG/lLDvgDW/Qxs/B2IPQqsmGBNlZsCZ90DVG2h0yAiIiIiIsUzKLVnzx7cc889GDBgACpUqJAXqxApEoGpm7o3QGKyy4zI9/ofG5CS4kKf5lULetOkuCtfF+h6O9DpFmDnQmDDL8D2f4CD64FS5dLmY8AqrCwQmG/tBUVERERERPI2KPXVV1/lxWJFipzAwAD8r5dVMsXA1JszNyLFBZzbQoEpyQfsJVXvLGtiAGr3UqBMjbT3Z48BDm0AmvS3yvvK1dZpERERERGRfKPutyL5EJi6/eyGCAoMwM8r9uKtmRuRnJKi5ueSv9hbqlGftOdJ8cCBNVaw6r/x1lSludV/qkFvIEJZriIiIiIikrdUsyGST6V8t/ZsgMFtrSyVd2Ztxk8r9ujYS8GO4HflBKDv00DtzkBAIHBgLTDvLWD8JcCC93V2REREREQkTylTSiQ/e0z1qG8ypqb8txsfzN5iRui7pH1N855IvgsOBRr2tqaYI8DmP4GNfwAH1wFRjqb8cSesflQ12wOBQTpRIiIiIiKSKxSUEslHDD5df1Y9hAQFYMLiXfj8n204EZtoXlNgSgoUy/VaX2pNx3ZY5X62LX8Bc1615mnYxyrxq9SEF3RBbrGIiIiIiBRxCkqJ5DMGn67pWg9R4cH4ZO42kzV1Mi4Jd57TyGRRiRS4cnXSP09OAMLLWNlUKydaE5uiM0DFLKvy9QpqS0VEREREpAhTTymRAnLxGbVwd5/GYBxqxtr9ePGXtUhIStH5kMKH2VNXTwb6Pw80PAcICgWO7QSWfAZMvN4q7xMREREREckiZUqJFKC+LaqajKmXf12HBVuO4Olpq/H4ec0REaqvphQyQSFAvbOsKeEUsG2e1YOKJXzMorL9PQYoXcPKoCpjNfYXERERERHxJsDlcrm8viNu0dHR6NChA5YsWYKoqCgdGcl1K3cdx6if1iA2MRl1K0bgqQtaonLpMB1pKfxSUoDA1KTb6IPAV5emvVe5mRWcatAbKF21wDZRREREREQKZxxF5XsihUDrWmXx/JDWKBcRgu2HY3DfxOXYdCC6oDdLJHN2QIpCI4Ae9wE1OwABgdYofgveA74eBvxwh5VdJSIiIiIikkpBKZFColGVKLw6rC3qVIjA0VMJeGTyCizadqSgN0vEf6GRQIvBwPmvAVdPArrfA1Rva5X47V9llf3Z2DT9yFZAyboiIiIiIiWWglIihUiV0uF4+dI2aFu7LOISU/DcT2vw04o9Bb1ZIlkXUQFoeTEw+C3gqu+Bs+4C6nRJe3/Db8DE64AJ1wD/fgQcWKcAlYiIiIhICaOglEghExkWjKcvaIlzW1RFigv4YPYWfPT3FiTziUhRFFkJaHVJ+oboccet5ukcxe+/8cCUW60yv3lvAXuWWb2qRERERESkWFNQSqQQCg4KxIhzGuGaLnXN8x+X78FTP67CibjEgt40kdzR5TZg+FSgz5NAg7OBkFJA9AFg1STgl4eA5IS0eRWgEhEREREpljTuvEghFRAQgGEda6NW+VJ4fcYGLN95HCO/W4bHz2uBepUiC3rzRHKnB1WjPtaUFA/sWgxsmwMEBAEh4WnzMYsqoiJQt5s1MfNKRERERESKPAWlRAq5bo0qoUa5Unju5zXYfyIeD3y/HPf2bWJeFyk2gsOAemdZk9OJPcChDdbjHfOBOa8ClZsCdboC9boDFRtZjdRFRERERKTIUfmeSBHAzKjXLmvnboD+wi/r8OWC7UhRnykp7kpXBy79BOh4E1ClhRWAOrgeWPIZMOkmYP7Ygt5CERERERHJJmVKiRQRZcJD8MzgVvh03lZMXbYHExbtxPp9J3B/v6YoFxFa0JsnkjcYhKrY0JraXwPEHAF2LAC2z7PK/aq3TZv34AYrWFWnM1C7M1C6ms6KiIiIiEghVmyCUi6XC2+//Ta+/fZbJCUloX///nj88ccRFhZm3l+1ahVGjRqFDRs2oHHjxnj00UfRrl27gt5skSwJCgzATT0aoGGVKLzz5ybTZ+qub5fhwf5N0apmWR1NKf4iKgDNBllTUkL60j32o2KwihOVq2MFp+p0Aaq1AYIVvBURERERKUyKTfneRx99hK+//hqvvvoqxo0bhwULFmDsWKus4/Dhw7juuuvQpEkTfP/99xg0aBCuv/567Nmzp6A3WyRbejetgteGtUOdChE4eioBj01ZiYmLd6qcT0oWBpmCQtKeNzzHKvOr1hoICASO7QBWTgR+vg/4/ALg6LaC3FoRERERESmOmVLJycn49NNP8dBDD6Fr167mtREjRuCHH34wj/m3XLlyePrppxEUFISGDRti7ty5+Oabb3DfffcV8NaLZE+dihF4dVhbvDtrE2atP4gv5m/H6j0ncO+5TVC2lONGXaSkqFDfmljmF3cC2L0E2PkvsHMhkJwAlK2dNu/SL4DYY1YmVY12VqN1ERERERHJV8UiKLVx40YcPXoUffv2db82ePBgM9HOnTvRsmVLE5CyNW3aFMuWLSuQ7RXJLeEhQSYIxdK992dvxpLtRzHim/9wb9/GOKNOeR1oKbnCywANe1uTywVEHwACU/8bwOfrfgZO7gNWTQKCQq3sqlpnAjU7ABUbA4HFJpFYRERERKTQKhb/r3vXrl0oW7Ysli5diosuugi9evXC6NGjkZCQYN6vVKkS9u/fn+4z+/btM4EskaIuICAA/VpWwytD26J2hVKmnO/Jqasxbs4WJCSlFPTmiRQ89p0qXTXtOYNSXe8Amp8PRFa2sqiYVbXwA2DyLcCPdxbk1oqIiIiIlBhFJlMqLi7utMCS7eTJk+Z99pN65JFHkJKSgqeeesr8feKJJ9CvXz+8++67mDBhAoYMGYL58+dj5syZqFrVcZMiUsQ1qBxl+kx99s82/Lxirxmhb9nOY2Z0vnqVIgt680QKD2ZB1e9pTQxQsfcUg1IczW/Pf0ClJmnzJidagaqqLa0sqprtgXANKiAiIiIikhsCXBy2rghYuHAhhg8f7vW91157DSNHjsSXX36JTp06mddmzJhhXmOJXmBgICZNmoTnnnvOBK+aN2+Ozp07m2VOnjw503VHR0ejQ4cOWLJkCaKionJ930Ry26JtR/DWzI04FpOIkKAAXNutHi5oUwOBgY6RykTkdCnJQGIMEFbaer5nGTDt7vRZVyzvswNUVVsBoRE6kiIiIiIi2YijFJnyPQaR1q9f73WqXLmymadBgwbu+evXr4/4+HgcOXLEPL/kkkuwePFizJ492wSiWPJUq1atAtsfkbzUsV4FvH3FGTizXnkkJrswbs5WPDx5BXYfi9WBF8kI+07ZASmq3BQY+BLQeqjVRJ3/jnNoA7D8G2D6A8CaqWnzJsYBCTE6viIiIiIifioyQamMtGjRAiEhIVi3bp37tc2bNyMyMtKMurdgwQLce++9ptF5lSpVwOSwOXPmmECXSHFVLiIUT57fAnf0bohSIUFYu/ckRny9FJOX7kJKSpFIkBQpeCGlgDpdgG53AkM/A66eDPR+DGgyAChd3Rq5z7ZtDvD5+cAPtwMLP7RG/lOQSkRERESk6PeUyghTwYYNG4ZRo0bhpZdeMkGnV155BUOHDkVwcLDJmpo1axa+/vpr9OjRAx9//DGOHz9umqKLFGfMCBzQqjra1ymPsbM24b8dx/DpvG2Yu+kQ7unTBHUqquxIJEsiKwJN+lkTOSvgD2+yyv/2r7amZV9ZmVeVmwHV2wGtLrE+LyIiIiIiRaunVGY40t6YMWMwdepUE5QaPHgwHnroIYSGhpr3//rrLxOw2rt3L9q2bYsnn3wSDRs29GvZ6iklxQG/FzPWHjCj8sUkJCM4KACXnVkbQ9rXQmhwsUiaFCl4J/YCe5dZvajYND3aMUAHs6zsoNTORVbvqmqtgYgKBba5IiIiIiJ5wd84SrEJSuUlBaWkODkUHY93Zm3C4m1HzfOa5Urhf2c3RNva5Qp600SKb5Dq6Hagy21pr/98P7BrkfW4bC2gWhsrQMWJz9lQXURERESkmMdRikX5noj4r1JUmOk19ffGQyZris3PH/9hFXo1qYwbu9dH+Ugru1BEckGZ6tbkqWIjIOYwcHQrcHyXNa2fnvqZGsDlX6cFpvhvRwpSiYiIiEgxpKCUSAntNcUgVIe65TF+wXZMX7kXszccxKJtR3BN17oY1Ko6AgOVqSGSZ5g1xSnuBHBgDbBvpTUdWGsFpZxBqEk3AWFRQNVWQJUWQJXmKvkTERERkWJBQSmREiwqLBi39WqIPs2q4N2/NmPTgWh8MHsLfl+9Hzf3aIDWtcoW9CaKFG/hZazR/ThRUgIQdzzt/ZgjVgN1Yp8qGwNXDFDV7QY06pPPGy0iIiIikjvU3VhE0Lhqabw6tC1u7dUAEaFB2HroFB6dshLPT1+LvcdjdYRE8ktwKBBVOe15eDlg2OdAz/uBpoOA8vWs10/sATbNsJqp25ITgfnvAJv/BE7uTz8yoIiIiIhIIaRMKRExWK53fpsa6NGoMr7+dwd+XbUX8zcfNiV9g9vWwGUdayMiVD8ZIvkqMNAKRHFqfoH1WvxJ4OB6YP9qq6TPxoyqFRPSnkdUBKqy3K8FULkZULkpEBqpEygiIiIihYZG3/ODRt+Tkmj74VMYN2crlu08Zp6XLRWCKzrVQb+WVRESpCRLkUKHI/ytnmL1qGKAKiU5/ftd/ge0vdx6zBLBo9uAio2B0IgC2VwRERERKb40+p6I5EjdipF49sKWWLz9qBmlb8+xOLw/ezOm/LcbV3WuYxqlqxm6SCFSvi7Q/R7rcWIccGiDFaBiRhUfM1PKtmsRMHOU1VC9XF3rPTubiiMDBocV2G6IiIiISMmhWhwRyXCUvo71KqBd7XL4bfU+fLdoJ/afiMNrf2zApKW7cE2XuuhUv4KZT0QKkZBwoHoba7I5e0yxoXpkZeDUQStjitOG36z3AgKBQa8AtTpYz+OjgaAQBapEREREJNcpKCUimWK5HvtN9W1eFT8u34PJS3dh++EYPPfzWjSrVhrXdK2L1jXLKjglUpg5g8fNBlnTqcPAofVWjyozrQNijwLl6qTNu3IisPQL67VKja1MKpb9VWoEhGuEThERERHJPgWlRMRv4SFBGHZmbQxsVQ2Tl+42Aap1+07isSmr0KJ6GQzrWBvt65RTcEqkqIisCER2A+p2S8umOnUIiKyUNg9H+nOlpGVUbfzD8fnKwEXvpY0YmBADhJRKHwATEREREfFBjc79oEbnIt4dOZWACYt34vfV+5CYbJUGNa4ahcvOrK2yPpHigoGqmMNW8/RDG4HDnDYDx3dZJX3X/2qNEkh/jga2z0vNprKnhtbogepTJSIiIlJiREdHo0OHDliyZAmioqJ8zqdMKRHJtgqRobitV0MM7VDLNED/ZdU+bNwfbcr66leKxGUda6Nrg4pqiC5SlDHriZlTnOp0SXs94ZSVRWUHpIiZVHx973Jrci8j0Cr/u/TTtPlZJhhWNv3nRURERKREUVBKRHKsYlQYburRAJd2qIUf/tuN6Sv3YeuhU3jxl3WoVjYcF7az+lGx/E9EionQSKvHlBNL+Y5tT59VdWQLEHeCKVfpA1C/Pgoc2WxlUVVoAJSvb/3lFFFBJYAiIiIiJYDK9/yg8j2RrDkRl4gfl+3Bzyv2Ijo+ybwWFRaMga2rmYbpzLASkRJU/sesKE4s5bNf+/Ji6zVvGOy6ZFza80ObrEytUuXyZ5tFREREJEdUviciBaZMeAiu7lLXZE7NXHsAU5ftxt7jcZi4eJdpkN6rSWWTPdWgsu/aYhEpRuV/zHzi5Hzt6snAid1WJhWno1utv8d3Ww3UbQxg/XQPEH/SGu2PmVUsBeRfe3I2ZhcRERGRIkPleyKSZ1iud16b6ma0voVbj2DKf7uwdu9J/LnugJmaVSuNQW2q46yGlRAarL4yIiUKS/nK1bamBr3SXk+Kt/pS2RJjrFJBBqXijp/er6pWR+C8V9Ker/weKF0dKF8XKF1DPatERERECjEFpUQkzwUGBqBrw4pmWr/vpMmcmrf5MNbtO2mmcaW2oF+LahjQqhqqlgnXGREpyThKn3OkPgakrvwOSIwFju20mqmzbxWno9vTSgKJgat/3k57HhSaGviqC5StBVRvB9TqkL/7IyIiIiI+KSglIvmqabXSeHBAMxw9lYDf1+wzI/Ydjk7A90t2YdLSXTizbgX0a1kVZ9Ytj+AgZU+JSKqQUkDlJtbkS2Ic0PAc4NgOa0pOAA5vtiZqeSItKJUQA/zyAFC2jhWw4sSywDI1gWD1vRMRERHJDwpKiUiBKB8Ziss61sGlHWrj361HMH3lXizbeQyLth0xU7mIENN76twWVVG3YqTOkohkLqoy0Pcp63FKCnByb2pW1Q7g+C6gRvu0efl83yprcmK/q6hqQKtLgDZDrdeSk4BTB4GoqioHFBEREclFCkqJSIEKcpT27T4Wi99W7cOs9QdwLCYRU5ftMVPjKlHo07wqejaphNLhITpjIuJfz6qyNa2pbrfT3y9dFejzJHB8pxWgYmkgH7OfFYNZrpS0eVkyOOlGIDAYKF3NyqYqUyPtb6UmVkBMRERERLJEQSkRKTRqliuFG7rXx/CudbFk+1HMWLsf/247io0Hos308dwt6FivAno2qYwz65VHWHBQQW+yiBRVHMmvUZ/0r3Gkv9ijVpCKWVG2mMNAUAiQnGi9x8mp821Auyusx3zvv/FWsIqN1k3wqoa1PmZhiYiIiIibglIiUuiwl1TnBhXNdCwmAbM3HMQfa/Zj++EY/LP5sJlKhQShS4MK6NW0MtrWKqf+UyKScwwaRVSwJqc6nYEbfrdK+E7sBk7sSZ1SH5evlzbvkS3A+l9OXzYbtjM41f5aoH4P6zVmZZmywGpAiAZ5EBERkZJHQSkRKdTKRYTiwnY1MbhtDWw9dMoEqOZsPISDJ+Mxa/1BM5UOD8ZZjSqhe6NKaFWzrCkJFBHJ9XJAlvxxqtk+gx+tOkDHm9IHrRh4YgDq0EbAlZw2757/gN8esx6XKm+VBnKKSv1bq6NVfigiIiJSTCkoJSJFQkBAABpUjjLTtV3rYf3+kyZANW/TIdN/6tdV+8wUFRaMTvUrmB5V7WqXQ3iISvxEJB8xa8qZOUVJ8WnZVVWap73OEQCZQcWAFcsGOR1Ym/Z+36fTglI7/wUWfZwauKqeGiCrbpUZcgqNyKcdFBEREck9CkqJSJETGBiA5tXLmOnmHg2wcvdx/L3hIBZuPYwTsUn4c90BM4UFB6J93fLo2qCi6UGlJukiUiCCw4AK9a3JqUk/a4o/CZzcbzVYP7kPiN5n/S1fN21ejiB4cJ01edNvFFC/p/X44AZg5wIgsorVgN38rWJth4iIiEghoqCUiBRpLNVjRhSn5JRGWLv3BOZvPowFWw7jwMl485gTK/oYxGKQ6sy65VG/UqTJvhIRKXBhpa2pUiPf8zDgxIwoZ9DKPN5vBbUiKqXNu2+FlVXlic3WGZw66x6gWivrtegDVjCMgavIykCQ/q+hiIiI5B/9Pw8RKVYBKvaU4nRTj/rYcuiUFZTachg7Dsdg9Z4TZvpy/nZUiAxF+zrlTQYVA1qRYfo5FJFCjMEkTt6wDDAoNO15ubpA00HAqQNW0Cr6IJAUB8Qdt6aAwLR5t/4N/PO29ZiB+lIVrOBUZCUgoiLQ+lKrT5ZZzykgJQkIK6ORBEVERCRX6C5MRIolZkE1rBxlpqu71MX+E3FYsv0oFm87ihW7juHIqQTMWLvfTHYWVdva5dCmVlk0qVoaIUGOmzYRkcLMs59U7Y7WZHO5rGwqZkUxUOXseRUYZI0KyGbsyYlAzGFrOpj6ftOBafOumw7MH2sFwBiwiuRU2crS4vNGfa1yQUpJsZrDi4iIiGRAQSkRKRGqlgnHoNbVzZSQlILVe467g1S7j8W6s6i+XgjTi6pljTJoU8sKUjGwxT5WIiJFEjOgwstYk2eJYMuLrYlBpLhjVuDKBKYOWYEqNlO3xZ+w/iYnpPa/2pt+WTXapQWlVk0ClnyaGrxKDVoxC4ujDPIxg2Z8LCIiIiWaglIiUuKEBgfijDrlzXRTD5gsqqXbj2LF7uMmi4rN0pfuOGYmiggNQuvUskBmVDWoHKlMKhEpXpjVFFHBmnzpeCNwxjWOoFXqZD9nzysbn7PcjxObtHu6+IO0oNTK74FlX6cFrLgN7gBWBaDWmVY/LBERESl2FJQSkRKPWVQDW1c3U0qKCzuOxGD5rmNYseu4GdkvJiEZC7ceMROFBAWgabXSaJE6AiAfa2Q/ESkRgkOBMtWtKSPtr7X6Wpng1WEg9ggQcwSIPWoFsVj2Z2NGll02eHiT9wCWHZRiAGvFhLQAVqlyQHg56znnqd3Jes0uW9SAFiIiIoWaglIiIg4s06tXKdJMF7arieQUF7YcjMbyXcexZs8JM7pfdHwSVu0+YSbiPU/tChEmSMV+VI2rRJnnbLwuIlJi+1yF1gXK18183nZXAg37pAWsGMAyj4+cHsCKtpu37/e+rCEfpQWlln8D/Dc+NWiVGrxi4IoBLD7nOtkXixLjrAbwDLqJiIhIvlFQSkQkAwwsNWagqWppoAPbrrhMD6o1e60AFQNVe4/HmdH9OP26ap/5HPtSsRdV46pRaFSFf0ujeplw9aYSEfHEQJG/5XltLwcanJ2WecU+WLHH0v4ye8rG53YJ4Yndpy+rxhlpQSn2wPr3QyAkIn0Ay/TiKgu0HJKWHcaSRS7bfj84TOdUREQkmxSUEhHJYiYVs6A49W9Zzbx2LCbBBKnW7T2JjQdOYvOBU4hNTDavcbKxNxWDVAxW1asYifqVIlGrfCkEa6Q/ERH/ZNb3yqnDdUDzC1IDVkdTg1fHrcdxHgEsvk6JMdZ0Yk/6ZTXun/Z4w6/Avx+lPWdQKqxMWpCq2wigQgPrvcObrZJE836ZtL+hpTU6oYiIiIJSIiI5Vy4iFN0aVjIT2dlUDFBt2B+NTQeiTQkge1Mt33ncTLbgoADULh9hAlT1U8sG+bdsqRCdGhGRHJcQRgConfm8Xf4HtL8mfdYVA1UccTDuhDWCoC0gyCoB5PuuFCApHkg6aPXGsv4jkDbv9n+AReNOXx/rvkOjgIEvAVVbWq/tWgxs+csKXIWVBkIjrb/meRRQtnbq/oiIiBQfxSJTauHChRg+fLjX92bNmoUaNWpg586deOKJJ7Bs2TLz/NFHH0X37t3zfVtFpGRlU53TzBqNKik5BduPxGDj/pPYeigGWw9FY9uhGJNRtfXQKTM5VYgMRe0KpUzAyizL/C1lglUBatwrIpK7+LtqAkClMw9itbvCmthInaWBduDK/utsAs8RCWt1THuPgSxmYvGz8SeBIEfp34G1wNppvtd7wRtWySGtmw4s/cIKVjG4ZW+7CWZFAY36pm0H18kpJNIKdDGzS/8dERGRQqJYBKXOOOMMzJ07N91r99xzD8qVK2cCUC6XC3fccQeaNGmCSZMmYcaMGbjzzjsxffp0876ISF5jiR7L9jjZmFF1MDoeWw5aQanth09hy6FT2Hc8DkdOJZjJmVVFUWHB6YNVFUqhZrkIVC4dpsbqIiL5HshiQCgKKOPj/0826WdNTsmJVkCKgaIyNdNer97GKjnkewnRQDynE2mPmTFlYwP4k3uBkz62rVqrtKDU5lnA3NfT3gsMsoJTdpDqrLutddOBdcC2Odbr9mTPx6l0dWVriYhIrioWQanQ0FBUrpw2MstPP/2EDRs24LfffjPPFyxYYDKlvv32W0RERKBhw4aYP3++CVCNGDGiALdcREp6RlXVMuFm6towrbdJbEIyth0+hV1HY7HzSAx2Ho0xfw+cjDcj/63de9JMnsuqViYM1cuWQvWy4ahWNhw1ylmPq5QOR2hwYAHsoYiInCYoxHtvrOptrckfzc4Dara3glUJJ61AlglipT6OsnoeGiwxZEDJztBKSU7N2krteZiSlDbvwXXWiIW+9HsOqN/DesxSw3/GpgasolL/RqQ9b9wPqNgwrTn8oY1ASKnUQFcpq6k8/waHK3NLRKQEKxZBKafExES88cYbuO2221ChgvUf++XLl6NFixYmIGXr0KGDKeUTESlsSoUGoXn1MmZyik9Kxm4GqhzBql1HYrH3eCwSk13YcyzOTJ4CA2AyqRioqlbGClLxOacqZcJQMVJZViIixbbhe6sh1sReV0mxQEKMlX1lj0xYsVHavBXqW/Pa79lTYupnTHljKmZ6nXL00vJUtVVaUGrPMuDPUd7nCwgEej8GNO5rPd+7Alj8SVrQyjOQxXJIbicxEMeMMQa27HkU5BIRKVKKXVDql19+wcmTJ3HVVVe5Xzt48CCqVKmSbr6KFSti3z5r6HYRkaIgLDgIDSpHmcmJZYCHTyWY4NTe43HYeyz1r5liEZeYgv0n4s20HOnLAe2gVaUoK0BVOSoMlU3gKsxMfL1iVCgiQovdfy5EREqWwMC0MjykVRhkO1urQW+gUlMg0SOAZU/lHL25GCyq3DR1dMPUwBgDZMzcYiYXs8dspw4Ae/7zvd6zH04LSu1fBfzy0OnzMDAVEg50vg1oOjBtJEQ2ned79vvBpdL+1mgHVGpszcvtO7IlNcgVln4+HkcREck1ReYuIy4uDvv37/f6Hkv37CyoCRMm4NJLL0V4eLj7/djYWFPi58TnCQkJebzVIiJ5j6V7duZTm1rp32NPvWMxiSZAtedYrCkBPHAyzvp7Ih6HouORnOJKfT3e5zpKhQShfGQIKkQyUBVqGrFzYpaV+RsVivIRoSoTFBEpKcLLWJM/6p1lTU4mcyvOClKZQFmqqq2BPk86AljM1IpNe85RCJ04MqIzyEVcLif7uV1CyNEQfek2Ii0odWQzMPVO7/MFhQIdbwTaXm49P7YT+HtMWpaWmcLSphrtrVJL4nbuXJj2HhvdO+c3ZZAaYVFESpYiE5RiCZ6vEfbeeecd9O3bF4cPH8bixYvNKHtOYWFhOHbsWLrXGJByBq5ERIojjtRXPjLUTC1qnH7zwCyrIzEJOJgalDpwwgpYHUydGLSKSUg2owTGHkv2Wh7oVKZUMMqVCkXZiBCUKxViRgtksKpMqRCUi0h7zr/hIYEaSVBEpERnbkWcHoQpXdWa/FGnC3D1JOsxA1B2kCsp3gpiMWBlY3ZVzwcc86QGrhL5NxYoX8+x4ACreb29LGfAKzkBCAhKX8a4d3kG+xmcFpSK3gfMeNr3vAx0dfmf9fjkfmDSjY7glWPi83rdgRaD04Jd7AXmfj80LdjFx9wXu5SSwcDjO63XzRRizRcYoiwwESkQRSYo1blzZ6xfvz7DeebMmYNatWqhadOm6V6vWrUqNm3alO61Q4cOnVbSJyJSErOsWKLHqbljFHOnuMRkUx54JDoBh0/Fu0cG5GuHo9Oes6/VidgkM+FI5utm83UTuEoNVpUOD0GZ8GCUNlOIGWmQwSz+5WtlwhXIEhGRDEZDtHtQeRNVBWh+vn+Hj6MXXvFN2nMGpBiMsoNZ7G1lK1sL6PtUWnDLBLHsKQ6o3DxtXgZ+ONJhUkJqUCweSI5Pe84gkY3LshvXe1OuTtpjZpMt+8r3/nC/GZAjlltOGO47gMYG9WenlkSyKT4DYwyCMXhlgl324zCgSjOg1SVpn2dgjMtwB7w4f+rfiIpWCaft+C4ruGeWxYCY/TdYje9FSpgiE5Tyx4oVK9C+feq/RDi0bdsWH374oSkBtLOjlixZYpqdi4hIxsJDglCzXCkz+cIywZPxSSZwdSw2EcdiEnA8NtFMLB80U2wCTsQm4mhMIhKSUsyUWdmgp6DAgNSgVTBKh4UgKjVYFRkWZPpeuf+GBiEizONvaLDKC0VEJHsBLzsLyVOpckDDc/xbDvtsDX7b9/vOcsPSNYBhX5weuOLEAFm5umnzMvDT+tL0wTDOYz6bCJRx1PbzORvW8y+X61ynGYnR8ZyfP7LV9/by83ZQisv59yPf89buDAx6Oe359zda2+kNM8vOfz3t+eRbrUb7dmaXCWClBr94HLo5Si3ZN4yZY3wvMCj9Z0qVT2uoT7uXWMfBXp75m/o5BjdLV0t/LJhBx6CZ+oqJ5KpiFZTauHEjevRIHabWoVOnTqhevToeeeQR3H777Zg1a5YJYL3wwgsFsp0iIsWxTJDBIU7+iE1ItgJWsQk4bgJWiTgZl4STcYmI5t946/GJuCTreVyiycRi/ys7yAXEZnk7g4MCEBkajIjQIESGpf/Lvlkc+TA8OAjhqc/DggPNa3zMckMG6DhZz4NMkExERCTXgl/u/2CFAuUdgaeMhJe1emL5g6M2XvdTWiCJ2VAMYJkp0QrO2BigOe81x/sJ6YNdzBKzsWE9M7KSHMtyfsaZ2WX2jwE+ZqAlWp9NfyDSPz2x23fGGLPEnNb/6ntESJZwOoNSc1+3eoJ5U7o6cOW3ac+n3gEc2pi6eYGpwSkGxoKBiErA0E/T5p31gtUo38yTmg1mz88suz6OVjOrJlnbYL/P+d3LDgXaXpY2LwcAOHX49GXan6nSMi1gFnPEOk/2++5t5uPUzzuvN5ECVKyCUizJK1Pm9J4pQUFBePfdd/HYY49hyJAhqFu3rulDVaNGjQLZThGRks4EekKDUK2sf739mIkVn5SSFrgyQau0wNWp+CTT++q0vwlJiIm3emJRUrLLncGVG0KCAtIFqczj0ECEBgWZrCxOYY7Jfs1+3/N18zgoCGEhjteDAhEcpNGeREQklzEoYTKOeEvopcE6X6/lZ2UJgx12iaA/rv0x7TH7XDFwlcJAVuLpwZJBr1hZWclJqfOkBr2Y2cWsL6fWQ4H4E9Z7zvn4N9Jj1MkKDawgkR1AswN0XIdnE3+TRZaKQTQ72Mb/O8FSRqdjO4BDG7zvt+f2bpsL7F7qfV4GkZxBqRUTge3z4NNNM/kh6/H8scAmPveBgUl7Wxic2/C7I3iVGuRi8IqPmd3HYKa9DVv+Sp0nNcDlnj8QOOseILKiNe/Wv4Fdi1LncQTEGDjj8+aD05Z7YB1wcK1jvakZafbyq7dLOyfRB4ATe6z12dtrHqcuO6paWq86Zs0xcGneD/CYl5N6qRUGxSoo9csvv/h8j4Go8ePH5+v2iIhI7mVi2UEfjjKYVWzoHpOYjJj4JJzyErTi3/jEZMQlppgAFvto2X/NawnJiEtKfT0hGSmp1Q3M3kpMtgJkeYkJWQxQBQcyQBWQGqgKQEiQFbRixlaIHcBKfRwSGGCCWZyHwbO01wMREmx91ryWOg8fczlcblCg43nqX3viNqR/nv4xz5WIiIj//5FjYIH/SOXjH6rYu8pfziBOZs591v95L/4gLcDlnLwF0c66C4hLDYyZiZ9Lth4zIOLUuD9QtWXa+/Yy+dxzuRUbWCWPzuW5tynZCrLYGNRhs3tX6nzOMk1yNuu3BwbwB7PW9q/y/b7dqJ/2rwHWOIKPnur1SAtK7VwALHZkm3m66F0gvKX1ePMsYMG7vudldp8dTN34uxV086X/82kjgzIw9/fL6YNWPAd8zNd6jLQGGDDbuwiY/7bHvKmP+ZkzrrYGYqCD64Eln3kPovFv435p23t8N7B6spWF2PJilBTFKiglIiLiq6E7G6ZzyilmbTEYZYJUCekDWXYwi/2ymNmV9jcZCcnO59Zf+zHfY1DM+ms95+s2BsG4HsCzxKHwYQDNGbxikCswIC14lf55oHt+BrOYEMb3OPE1vmeepz4OCrDmM58P4mPrfet1aznW561zztfTfT51Pc5lWQE1K/BpL4efMbcCjsf2MszLqcs1r6d+xtr3tM9zXvP/ZVPns9fLZ2ae1IXZ+2jPYz7jWJb7cx7rs+ZL/561bdZzERHJRb56inlTxdHcPjNNB/g/b8eb/J+396PW5MxGMwGqZOuvc0CAzrcCZ1yTFsDivCaQlTq/M7ur+QVAzQ5p79nBMft5eLm0eWt1BELCU9eZkj7wxvlZdmpjeWf9nmnzuZefGnALjUybl9vD+Tmve/7U/eNflr7azH9wg9Pm9eQMEtpBPl+c7yWcBI5u9z1v7NG0xyyl3P6P73krN00LSp06AKz8HqjRrkQFpQJc/H/XkqHo6GjTFJ3N0aOionS0REQkz9nBr/ikZBO8YulhYnKKmZJSXCZoxb/mNedjM7mQlMLXXUhMcb5vzZPEoBfnsZeVuoxkl9W3i68ls4eX83lKinmc9tx12j+8SuFjB7nsJ1bwK33HlrTAmRXosl5M++N83RkQ84x9OZfjWMRpr5tPp26Dcxn2Mn1vh0fwLfU157qcO5Y2t+d6Mj5emX4+w5hf5uvM6PP+bLO/QUd/9uX09fv4vOOJn7uf4ToDsrjNmc2byaZkXSYLz2zZmW9bzgLH/p7DrH7Wej9vg9r+Xv9Z/axf687D85bX/xaQ2XnJ6b7lbNlF5LvqciEAKQhIDVDxsSswBC4GrViFmRyHkKRTCEgNbgXAhUBXMgMmZt7Y0EpICrFiAaEJxxEVu8ssy8wPl/lrz3sisj5iw6uYzQuPP4SKx1a45zXz8K/ZFhcOl2uNk1H1zXJLxe5Dzf2zEF+qCur1uDzDQYaKUxxFmVIiIiKFEP9PXmgwp0B4dKAoNFIcAaokR9DKGbhK9piH/wBrz8vXuQxmgqUwAOZioIvzIjXoZb3G963XU+dNsV/3+HxqoMz5HpfFx85lWZ+xHlvLtCbOy/9jaXr/ms9Y41ClpD4wr9m9gd3vcz3WX+t1axn2NlufT33s+TmzMOdy038uN4J+9j64n3ifK+crEhERKbaYUXUkdbJl9P/OOLLkDsfzRr5n3Q2Pea1ywi6BW/HYeS1QEigoJSIiItnCErRQ9wiEjv4UkmucwSwTsEoNfjkDW+mCWKmvp33eCjnZ89ivmb/WzOlet5dvvZ9+G077rMfy7c9YD9Ped76ebvmOZTnjZRluh8fy029D+uPm9XimO7bO19M98cmfz/uK/aX/bPqZ0j3z+Xnv60i/HT4+m8H60r/l47i5sngM/f589gKimX0so23x6/M5jNNm9vHM9jvT1ed4+3J4fPxZR2HfxhxuYObnOI+vgZyuP9PP5+0/VuT5dzgb25Sf25eZgADg3OZVUVIoKCUiIiJSSNl9pgJzWO4jIiIiUhhpjGkREREREREREcl3CkqJiIiIiIiIiEi+U1BKRERERERERETynYJSIiIiIiIiIiKS7xSUEhERERERERGRfKeglIiIiIiIiIiI5DsFpUREREREREREJN8pKCUiIiIiIiIiIvlOQSkREREREREREcl3wfm/yqLH5XKZv9HR0QW9KSIiIiIiIiIihZodP7HjKb4oKOWHU6dOmb+9evXKjXMjIiIiIiIiIlIi4imlS5f2+X6AK7OwlSAlJQUHDhxAZGQkAgICdERERERERERERHxgqIkBqSpVqiAw0HfnKAWlREREREREREQk36nRuYiIiIiIiIiI5DsFpUREREREREREJN8pKCUiIiIiIiIiIvlOQSkREREREREREcl3CkqJiIiIiIiIiEi+U1BKRERERERERETynYJSIiIiIiIiIiKS7xSUEhERERERERGRfKeglIiIiIiIiIiI5DsFpUREREREREREJN8pKCUiIiIiIiIiIvlOQSkREREREREREcl3CkqJiIiIiIiIiEi+U1Aqi44fP44XX3wR55xzDtq2bYuBAwfis88+Q0pKil+fX7hwIZo2bWoe79q1yzzmX3r44YfN5Iu397/77ju8/vrrKEie+5GZ+fPnY/Pmzebx5MmTzbGUNG+//bb7mPBxq1atsHHjxtMOEefh8csO53WYFbz++LkdO3ake53b4e/yrrnmGrNfvnA53D5/JCQk4KWXXkLPnj3RsWNH3HHHHdi3b5/7vYsvvhiHDx/2a1kiIiIiIiKSvxSUyoKjR49i6NChWLVqFUaPHo2ffvoJI0aMwAcffGCeF8T2cN033ngjipLrrrsOhw4dMo8HDRqE77//vqA3qVAJCAhI9zwxMRHPPPMMClp8fDz++OMP1KlTBz/88EOG25wRBqRuuOGGXNmmt956CzNmzMArr7yCb775BklJSbjzzjvhcrkQGhqKq6++GmPGjMmVdYmIiIiIiEjuUlAqC1599VVzo/vxxx+ja9euqF27tgmqMCD11VdfYevWrchPXGf37t1RpkwZFFXh4eGoUKFCQW9GocLjUblyZffzqlWr4r///jstEJTfZs+ejZCQEFx55ZVmWxj48bXNGSlXrhwiIyNzZZumTJmCe++9F506dUKjRo0watQorFy5Etu3bzfvX3DBBfjzzz+xe/fuXFmfiIiIiIiI5B4FpfzEUqCff/4ZV111FcLCwtK917t3b1PCV7NmTfP8xIkTeOCBB9C+fXsTNOKNclxcXJZPzuLFi3HRRRehTZs2uPvuuxEbG+t+j+WCLN3r27dvunIubgdvxNu1a4dbbrkFBw8edL/PkjlmVXG7evTogbFjx7rLDpm9wpv7Rx55xJQl9u/fHzNnzvRZKpZR+demTZvMes444wy0bt3aBDHscj27LG348OFmnZ7le5lt43333YennnrKvM/A4EcffeT38eT2Tp06Feeff74pieN27dy50/0+95fHm9t85plnYuTIkTh16pR73Q8++KA5l9wvbvPcuXMxfvx4dOvWDV26dMEXX3zhXlZG14Bd6uZtYglk/fr10aBBA/ey6tatazJ+Xn75ZbNcX7hclpPyehkyZAgWLVrkfi86OtrsD7ed55aBG6e9e/fitttuM+ee+8bjnpycnG4eZgbyuPB6Z5DHuXxuM6fslO9xXTyXnTt3xsSJE087Z94mfp7XBbOgePw9nTx50vxlEJnv87siIiIiIiIihYuCUn5iD52YmBgTsPDE0iUGJXgDTI899pi5KWY50bvvvmsCAM8++2yWTsyRI0dw6623mhtqZqUwC+TXX391v79hwwYzD9frxJv1m266ydyEM4jF8kJ7eQzCVKlSxdz4M7DDgIozkMLSLGa/MLhxySWX4K677jIBpqxgoIDBDQboGAD69ttvTXDDLqGyS/W8lXD5s42//fabCQoyQ4bBK5ZtZSVDjevl+eE+svzxjTfecJ9fBv64/l9++cW8/s8//2DChAnuz06fPh2lS5c2+8XAzz333GMCU19++aUJtLC3Efchs2uA2XX8nLepevXqJkDzwgsvpNtunsfg4GCTrecN94eBL14zvF543TAouX//fvM+j+WWLVvM8Xz88cfx6aefuj/Lc86St4oVK5rjynVPmzYN77//vnseBueYKcWAVL169dCwYUMzr40lfTwOWcXrlOf3+eefNwHVSZMmpXvf13HitRMYGGj2k5lXNi6rfPny6QKmZ511FubMmZPlbRMREREREZG8paCUn+wMFQYlMsLgBnvcMAjDG2MGLxgs4A28nb3hDwZGWBLFbBtmzTAo4QyIrV69GrVq1XIHwmwMJl144YVm3bzRZ9kXA1jMcilVqpTZFgYUmGHFIMy4cePcny1btqwJnPB9BjSYVeMZJMgMs4Euv/xy0xCbgYqWLVuaZtN2cMsu1eO6PEu4/NlGBiAeeughkz3E4Bufs8eXv66//noT9GnSpAmuuOIK92cZTGOwZtiwYea4MruJAQ9ng3EGO7g93C/uE88ng0/cVgbI2M+IZWOZXQMsWWSpm7cpKCjI63ZHRUWZLDYGyVasWHHa+3ZgjJlevF7uv/9+s48MQnGdvJ64fzwfzEC7/fbb3Z9dsGAB9uzZY7aRn2XGEo+xMxjI/WFvKwal6NxzzzUBQmf2XnZwf6699lqz3ObNm+O5555L976v4+St/I/b+Mknn5hsOuf3gudn3bp1p2V+iYiIiIiISMEKLuD1Fxl2NgZH38sIy88Y4OBoYE58ze5z4w8GcZo1a5augTSDUnYQgBk5DJJ4YrmYjT2vuN3cJk4MSDDbxsagE8v77IAbS9qcN/N8bpfd+SsiIsIEe5itw4APs3PWrFmDSpUqZfpZf7aRASNn4IbBCQaD/MVgljPQw0ALMfuH+/7ee++ZQBQnngMG+Gxct30+GFgiu2TTfs4yz8yuAR4TZi55wxLRGjVqeH2PpXnMNHv66adPK3PjOjnynBNLOPk6M8kYkOH1ZHMGODnPsWPH0KFDh3TbygAjs8l4nXG7eG3ZQcV+/fqZTKrff/893THKKs/tZkYgryHn+feGGWHMyHMGpJi5xjJHDkbgxO8A94f7yGwwERERERERKRwUlPITs2OYJcUMJWa+ePrf//5nMlV488/5vGUYsWH18uXL/T45zkbSxCbTdlCKwRFvmR/OgA5xHpY5efbBIrtXk70cX5/1xlfWCcu8Lr30UhPIYG8i9m9iEIYZLJnxZxt5DDI7Thnx9nliJg2Dadxm9k3iCIGff/55unk8jw95Oz6ZXQMMgLF3kzcsXczIk08+aXqGff3115keO26Hffw8OYOPDOoxQ4plhp64HwxMsZSR87Vo0SLd+ww+5iQo5e38OY+zr+buzLSzMWDGfl/M0Hv00Ud9Lj8rIwSKiIiIiIhI3lP5np94o8xeQBzxjtkwThzdixMDCmz2zHIp3gAzK4cTM07YpNrzcxlp3LixyTByBn/Wrl3rfszMI2Z+eAuu2JiVw21hCRm3iwE1OzOIWNrHzBc7C2z9+vXpghjMdLJ78zCYYzf9JmeDcKd///0XBw4cMKVfLK9jCRxLw/wJHPmzjXmFfaI6duxoejaxrxQDjzx+WQl42TK7BpihZb/uOXkLfDlxHpZWvvnmm6Z5uXOdngFPPrebpvP8OZub89pyfpbniMfZ3g42XH/rrbfMPjAbitcFr30GieyJfZ1Y+rdv3z5kF69z53Zxvc5m7r6Ok309zJ8/3wSkOADBE0884XUdDKrxuHrLLBQREREREZGCo6BUFrCvEwMB7B/E4At7B7GMiv2TOJocS4/Yv4Y9e9jTh71/GGRhLyA2SS9Tpozf6zrvvPNMVtTo0aNNphH7Ki1ZssT9Pvvv8AbeGSgiBoM4ihyDU8waYZNnZuYwu4YBEWbasGSK5U5s+s3sIDuDhIEm9kHi+ljGxm1n1pNd7sXSMfan4sh7vjKfGCzgvnL53D4eH89AHsuzWB7n2WPLn23MK9xuBuV4zlju9uKLL5pgSVYCibbcugZ8YVCKASRnKSkzu9g/isEibj8bwPMa4PljEIzZTOwZxUAVzx9HvLOxfxbLENm/jMeAoz4ywMP+XiyVZK8v7g/L+9inyp64TmaKMaDnxEAqSy79OXYst+M1y/5UvLbYo8tXdp4nZm7xGmcw8eabbzbrtCfnurlP/L4oU0pERERERKRwUVAqC9hgmaOpsVcTAw4sTWOJF0epY2DKxowY9h/iTTsbazMT5bXXXsvSiWF5EgNRDIwwoMDyKWeZFDOYuD3MJHJiA26ui4Ecvv/666+b1xmY4PIYSGMzbAYo2GCao67ZWFLGXlV8n42xP/zwQ7OvxH49DKgMGTLEBMrY8Nsb9gBij6BnnnkGgwcPNqPCMch0+PBh90hwLHPkMWLAycmfbcwr3Cb2YOI5Y6YUM4e4H86MoqzIjWvAF5be8Zg6MYvv3nvvNdlNPO4MmjJwyAAZMcjEc8Nt4bXKYJCNgScGIZkNxUbvDL726tXLNEbnOWOQyg5OepYi9unTJ90ofLR3714T6PK8Nr3hNc3vD881jzuDqP4G7pjJx/PEbCmuzzk5181grmd/LxERERERESl4Aa7s1CdJocCgDm/KX3jhBfOc/ZAYwGHgKDvLYiCDo7iJ5BSDYwwEMdBXkJidxu1gBhmDhCIiIiIiIlJ4KFOqCGMfnXnz5nntLSVSUFjiyuwlz6boBWHatGk4++yzFZASEREREREphDT6XhHGvkK33XabKdMaOXIkSjJmh7GXki8fffSRGVVP8h7LMNknytdIh/mFfaXYz+zjjz8u0O0QERERERER71S+J8UCyxido/Z5638UHh6er9skIiIiIiIiIr4pKCUiIiIiIiIiIvlOPaWyiaPKcQS8iRMn5trJ4Kho9ih+bDzOEeGyi9u2cOFC5Lddu3aZdfOv53Zs377djLbWunVrvPHGG6YxO49jTq1duxZLly41j7kurlNERERERERECjcFpbLp559/Rp06dTB16lTkhRtuuMEEpoq6uXPn4owzzjCPx48f7z52119/Pb7//nsMGjQox+u44447sG3bNvOY6+I6RURERERERKRwU1AqGw4fPmxGF2MwZPHixdi5c2eun5jIyEiUK1cORV3lypURGhrqHpWtWbNmJphXtmxZ06g9t/s8cV1cp4iIiIiIiIgUbgpKZcOvv/6K0qVLY/DgwahSpUq6bCmWpH322We44IIL0K5dO9xyyy04ePCgu7SsZ8+eZmSyzp07o1u3bnjvvfe8rsOzfI/BL44w16ZNG7Ps3377Ld38Y8eORdeuXc1yMyspZHnbL7/8goEDB6Jt27Zm5D4G1oYPH26eX3nlldi/f797/lmzZuHiiy8262Zm0++//+5+j83FR40aZUa2477Nnj37tHVxv1mWyFK9H374wV3e5yzfS0pKwmuvvYbu3bujQ4cOuOuuu3D06FHzHreFzzt27IhWrVqZbVmyZIl5j8do9+7deOSRR8w6PMv39u3bh7vvvhudOnUyx+a5554zo7IR183Pv/XWW+Y97sMLL7wAl8vlbp7OjDVmX/HYcj/tZup2+aaIiIiIiIiIZI+CUtnA8rOzzz4bgYGBJrDCQIsdyLADSjfddBO+++47xMbGYsSIEemyrDj/J598gmeffRbjxo3DhAkTMlwfg1q33nqrCUpNmzbNLJsBGAaqiOthoOv55583AbFJkyZlug8MxLz44ov44IMPTJDpiiuuMNO3335r1vfRRx+Z+ZgRxu1nLygG34YOHYp7770Xq1atcu8rg1YMrr355ptmO7x57LHHTBCME8vrqlevnu59fnbKlClmH7g/PE5PPfWUee/+++9HcnKy2TYeO46k9/TTT7vXX61aNTz66KNmHU4MPl177bXmHHz55Zemj9Vff/2Fl19+2T3Pf//9h61bt+Kbb77BE088Ybb/n3/+Me8xCBUREWHW+c4775hAoH2uGJxTmaCIiIiIiIhI9ikolUV79+41TbX79u1rnvfr189kGdmZO3TJJZeYIA4zaRhkYeBjw4YN7owgvtayZUuzDAZNGGzJyFdffWWyqq6++mrUrVvXLPuyyy7D559/bt5noITL6d27N5o3b26ygTJz3XXXmayoLl26mM9w+QwY8TH3iYEae939+/c389evX9/0guL7DKoxEMesLDuLiRlFDA55w8wylupxYnldUFCQ+z0uh/vAYBezrRo1aoRnnnkGjRs3Nu/xODFg1LBhQ/PeVVddhU2bNpnPssSRy+LyOTnNmTPHZFmNGTPGnAtmOz355JMmAHXq1CkzD4NdDD41aNDAHFeWF65cudK8xwwsLrNGjRpo3749PvzwQ/Tq1cu8Z++HiIiIiIiIiGRPcDY/V6KzpMLCwkyZGbEsjP2RmOXD8i9iAMNWu3ZtEzjZvHmz6aHEzBsGPmwsR2OAJyNbtmwx2Uh2w3BiGRmDRMRls7+VjYEbricj3C4bAyw1a9ZM99wuceOyL7/88nSf5XYwG4vldUeOHDGBLBtH1ssqLufYsWMmUOfcBzvDjBlc06dPN8FABsuYpZWSkpLpcrnt9erVM+fHxnPDwOCOHTvM84oVKyIqKsr9Ph/zfWJGGoNsf/zxhwmWMTuqRYsWWd4/ERERERERETmdglLZCErFxcWZvkc2ZtuwzxSzecxBDU5/WPk+S/28vcfgSkBAQIbrZJCEfaRuu+229CfPsSxn+aC39XhyZiqRvX2eGIDzxG12BoWc6w4JCUFWZbStXA/7Op04ccIEhVguyYDcnXfemelyvW07z4Xzr92E3cneH/YMY3bVjBkzTNkfM8Juvvlmk9ElIiIiIiIiIjmj8r0sYJbOmjVr8Pjjj5s+Q/b0+uuvm5HlmFFD69atc39m+/btOHnypLspNoMrbPJtY6lYZg2zmRHF5bB0z55mzpxp+ksRy9zskjPi8rme3MB1L1++PN1rLEfk6+XLl0elSpXSrZvHJ6vKlCljluU8bmvXrjXZSRs3bsSiRYtMrywG5djL68CBA14Dcd62fdu2bSYLy7Zs2TITBOMIgJnheWVvK2ZqsffWPffck67Ju4iIiIiIiIhkn4JSWcySYike+zk1adLEPTGDh+VmDFARm2UzaMQgC8u/zjrrLFNGZmNGFXtMsXE2G3CzR1JGOBoeS9YYJGGQhcEojlTHXkfEXlNcJ5fH5bLht6/Mp6xiLykul/2ruG4Ghxh8Y6CGGV7cdjZNZ3NwBqc4el12cBQ8NjtfsGCBCUSNHj3ajF7I0jvuC489ezwxI43NzckuMWSpIkscncEn4nFnmeKDDz6I9evXm2Wzf9T5559vAmGZ4TLZjJ7nkdvEkQXt8j1my9mjKoqIiIiIiIhI1ikolQUMjLCMzlvJF4M0DMywsfbFF19sgkZ8jc2wGUxyYgYQA00MvIwcOdIsMyPs9/T++++bxt0MqHAUOY6+x/IyYoNulpYx4MLlMhjjT9DFH2yGztHq2Byc62YvKa6fZW3E7KWLLrrIlLRxhECOzpcdt9xyi2mgzmwkHjeOqMf94V+OtMfRALl+NhtnphqzneysLM7Phux83bNE8d133zWPhw0bZo51nz59TKDJH1wvM8EYMOPnq1Sp4h7hjz2u7L5iIiIiIiIiIpJ1Aa7MaqAkS9jziP2OhgwZctp7CxcuxPDhw03WjoiIiIiIiIhISaZMKRERERERERERyXcKSomIiIiIiIiISL5T+Z6IiIiIiIiIiOQ7ZUqJiIiIiIiIiEi+U1CqAO3atQtNmzY1f3Pq7bffNqPE+cL3OE9xwabxPHb+HsfDhw+b5vOJiYl5ul0zZ840oyty1MJvv/02185vfuPojpz8ubbyw9q1a7F06dLTzn1e4qiZEyZMQGF04sQJMxJkt27d0KVLF3Ou+JovO3fuxHXXXYd27dph0KBBmDt3LgqDgr7OeFxmz56d67/HIiIiIiLiHwWlpEQYM2YMrrrqKoSEhOTpet566y10794d06dPx+DBg83Nf/Xq1fN0nSXBHXfcgW3btpnHZ5xxRr4EVW688UZ88MEHOHr0KAqbp556CuvWrcOHH36Ijz/+GJs3b8bjjz/udV4OsMrjV6lSJUyaNAkXXnihGSF0z549KOkeffRRrFixwjzm91TfVxERERGR/KWglBR7zHxgBtMFF1yQ5+s6efIkOnTogJo1ayIiIgKVK1dGUFBQnq+3JAkNDTXHNa+VKVPGBBi//vprFCYxMTH47bff8OSTT6JVq1Zo2bKlCa7MmDED8fHxp82/YMECkxH07LPPomHDhrj11ltNxhQDVJKG31N9X0VERERE8peCUvmIpWOjRo3CmWeeaUq87LIR2/Hjx/HEE0+YkhwGNh544AHzmq+SJWfpi718lvSwdKxv374mW8cXlpadc845JuuEJTPr16/3ez+2b99uskj42bPPPhtffPGFexu5zO+//x5nnXUWOnbsiI8++giLFi3CgAEDzPwPPvggUlJS/FrPpk2b3Otp3bo1rrzySpMRklXfffedCS4wmGGbOnWq2SYeq8svvxxr1qxxvzd58mQMHDgQbdq0MSV/3H4b9++rr77CsGHDzDYx62TVqlXu93bv3m0CBHzsWQ7EjBtmqHB/+vTpg2+++cZ9TjM7vyxtuv322022V6dOnfDvv/8iISEBzz33HDp37mym+++/H8eOHfP7uEycONEcAwY2+PlnnnkGycnJyAlm39xwww1mH7t27Wqud7tkkhk777zzjjkX/A7cdttt6bJ1WGJ5zz33oH379ub6ee2118xneH3yuD7yyCPmeHgeq3379uHuu+82x4X7wWPCY2OfS36eGWx8j+t94YUXzHIz217ieeT1Y1+zXJbzO+fp77//xsUXX2yuK2bKzZ8/333+eO1z+VwXl8usnPHjx7tL8OzvkX3deJu4P4GBgXj//ffRvHnzdOvmuTt16tRp27R8+XK0aNHCBElt/H1ZtmyZ133gvo4bN85co/wOeP4+cDv4/Tn//PPNtcPvJYNeeXmdsTRxxIgR5vzxd4XXenR0tF+/ZwziMYBnf0/4G8vgHc8jv0djx441n/H8vmb2e8z1MWDZo0cPE+Tj+/Z1l9n2ioiIiIiIRUGpXMKbQd7Y8AbGvhH1xBvTWbNm4b333sObb77pvgm1MWDB3jm84fz0009NACajG2BP//33n/nLG9crrrjC3AgxgOTpzz//NDdivOGaMmWKueEaPny4+4YrI7yZ4018ZGSk6bfDmz323uF+0YEDB0zGxpdffmmCDgwsPP/883jxxRfNYwbKmLWUGd4Y8/PMOOINMG86eSPLMrysmjNnjjkvzucM3l177bX48ccfzc0ys0d4Q8ljx8ABn//www/mc7fccgv279+f7jzyNX62dOnSJghCDMZVq1bNBKX42NPIkSNx5MgRE4zicWOAJit43BgI+Pzzz02wgMeTATEG/ngt8aaXwRl/8Gac281t+vXXX02ggNvsz7nJCI8dgx88dtw/ZvTYfZkYgJk2bRpeffVVE+ipWLGiuZbsIBBLzA4ePGjme+ONN8y5YACQx9s+rjxvTjxnPI+xsbHmmuPn/vrrL7z88svpvhdbt241x53XPI/VP//8k+n2EoNFhw4dwoYNG8xzbovnNtg2btyI//3vfzj33HPdQRsGErlPxGuf1wvf4/ljAI6BKW43fzteeuklc33YZWTeJvaDCg8PN0FtZ5CV+8SASoUKFU7bLq6/SpUq6V7jsWcwzxseh08++cQcb/4+8Dt40003meCOzT4OPEcMtvK45+V1xqAi94PnkPvK0sV3333Xr98zljUuWbLEzM/94mNuL7efQSxeg9767WX2e8zfOl4vDODx87///ru5jjLbXhERERERSRPseCw5wAAFb8CIQRpmXTgxM4MZAw899JD5l3PiTR+DG8SbFn6eN27169c3rzEAw5vQLVu2+LUNvPF8+umnTd8klunw5pzrZHDKiTdRDLr07t3bPOfNMTM8uA+ZNRrmjTFvnBloioqKQuPGjc1NH7M3iAEG7iP3oUaNGiY4wOweZhIQszv82Z+4uDiTwcQsDDvDgxko3PasSEpKMlkTPB42BkQYMGDgjpjBwmPGm1g7QHDRRReZ93jsmCnFQMl9993n3g5motH111/vDgQxIMASIAYe+Nh5E8+gCAMhDNjVrl0bzZo1Mze97A3kL/YEsreZQRhuE0uw7KwhHmtmgnB/M2sEzmM6evRo9OvXzzyvVauWufFmYMV+LTuY0cRyMp77unXrmp5HLIMjnjvuL7eRWE7GrCkGCTk/g0f28SFeyzyG5cqVcx9XTk78LAOGDCSVLVvWvMaAH4ND9957r3nOYCaDT7xeGzRogM8++wwrV6402VgZbS+FhYWZ7WEmHc8Zt8UXBluY5cVAFPG7ze23G5CXL1/eXCsBAQHmGvrll19MYITLZ0YgAxkMIjNQkpXyRF4HXJav7wavFWcAi/jczurx/J3i8hhEYqYU8dgx0MbfB34n7eve/o3jNcngYV5eZzxPDITz86VKlTJBfX9+z5itxt9UrpPBKvu6Y7CJ1xK/99xGnldnJpM/v8f8reNvH38D+X1jxhSvK2ZRZrS9IiIiIiKSRkGpPMCbTk/MJmAwx1lyw/IvG290eDNs3wARAym80eZ7njfj3nDZzkbevNn2Vu7G13iDxUwbZwaU3Ug6IwyucBt5g2+75JJL3CUtZAcVmNFBzLSw8TVvN8OeeKPIm11mHjAbiMeAgQEGZrKCgSZmXTEg4NwH++bavkFnIM0+NszYcWJAzXkc69Wr537M4+DPiH4MFPHG1z429nKzwnkcWS7F9Tr3g7ivPI+ZBaWYHcZzwUAIyyS5fQyIMEiUE8yoYbD1jz/+MNk8vIln6RgzCZmZw0CRHcC0g4/cXl5/nsfHDvxlhOeF58MOSBEDQwxG7tixw50V5Lxe+ZjvZ7S9TtwulhZmhtcVv3NODJDYGKCwfxs8vxv2c343WFJ43nnneV0HM40YaLExGMRMJJY2+jp3DKx5lnVyPfY6nbifnJflhzb+pvB6cX4HGMDz5zuQW9cZM58Y7GMgjFP//v3dPeIy+j3juhiUdJ4XltRxyoi/v8eex8G+rjLaXhERERERSaOgVC7hDcdPP/1kblicN6Ke7F425AwgeWYy2HhDxclboIs3QMHBaafQebNvByi8jTbH5fFG3DOby3nj7otzff7O47ld/mAQ49JLLzXBJPZuYWYTjy3Lb7LCPm7OPlYZ7QNv4L0dL+fnszOCH9fpPPe+tjOj8+vcNrsnD3vaOHsF2UGYzDDDiME3ZoQxw4OPGfDIKQZMeF0x44mZenfddRduvvlmkwlEzBhx3ugTb/QXL16crfX5Ol/Ov96+W/a58LW9dpYV8dz7cw1n9t3w9r635TLj0S4D8+Q8txx1j9lxzPRjCaMvVatWNQEhJ5Ykepb0+TqeOfkO5NZ1xnPEHnws++N5YjYcszZfeeWVDH/PWGKXHZn9Hvuaz76uMtpeERERERFJo55SuYQ3QMxaYD8pz5sjYnCFWT4s77A5m2vzRp1lPs7SNt5IsqSE79k3gc4SE7shr40lMU4c6pzlSp64PGat8F/57Yl9U3w1PnZiVgqzD1gSZGMvHLuvUm5h6QxvKNmPhdks7O3EDJKMAjve2KVfzFSzcX9ZnmPjTSYDX+w1w2PDxtBOfO4ZSMkqZlkwa8vZENpukE7+nF8nZhRxv5jVYp9DXoNs4u1PVg/LOpnhxlKmoUOHmu1jZlFWj68nlq5y/cxy++CDD0yAlr12mHXCgAr77Njby95JzHBhhhGfc1/27t3rXhbPvV0K5wvPCzNinJlAvI4ZAKpTp062t9eJ144/GXqe1xUxk+3nn39GVnDbnd9N52QHjtk7iQEpZkjZAT9fmPW0evVqk5Vm47XuzIayMQOI++r8LWAWFD+fne9Abl1nLLnkNrDskYFNXuf2ecro98z+njjPCwOQXE5GMvs9zsn2ioiIiIhIGgWl8gkzYdhbiWUs7C3E4BRvVGy8WWP5EMvIGEziZPefatKkielbwjIY3mwxsME+Ks6gFjFow/4vLGdhs2K+b/cgcmI/GDbLZjYGbxAZGGBPGmffJV9YdsObVv7LP9fDTAA2Ic9p2Ze3YBL78fAGksEZ3twy6OdP6Z9nJgp7ATlH42LPKPab4Y09A2z2aGws8bnuuutMTx0eGwZLmNnAG1pmbeUEb2R5jJjRweXNmzfPXAs2f86vE4MTvMln3yWWTfKGmRkz3B+WiflzfNnDiceFwUw2cGbAKKvH1xNv4hmA4D5yucwWscvheGzZYJqNqRlIYj+epUuXmsAp959NxdljidvEfWJ/J/Z9ImaDcdmeZWh8n4EH7js/t2DBAvMdYGadszdUdraXGISw+04R13/y5Emvy+J3jRlf7F/E88AgF5eZWalYVnEbuM0MeLDMj+fNnuwsHpYK2yPxcVRCBgAZwOL28Ljy98XXNc3zxGuT54nfcXu0OpY2ZlVuXWcMOnGfGWjitcMG4/Z5yuj3jN8TZmmxrxX3mb+7DETyWrOvKy7PM5Cb2e9xTrZXRERERETSKCiVjziaHG+QWBrExrwMKjgx44g32LwpZPYDb9TtEdp4c8WbbWZd8IabN9EMcjn16tXL3LDyZpWlhBzlj6U7nnhzyW3gjSeXxewuzuvslZRRFgdHkWIWE9fDmz0GBM4++2zkJjZ7tkt9WGLFUb4YCOPNo3MkPH+wbIjBDxtvLNlwm8eWy7ZH2GJQyHls+B4ztlgy6E/ALjMMfvEmmI2QGUwaMmSIO0PKn/PriTf4zMpjyRmXyXPDgAMzQzLDJuvMXLrsssvMTT3LthhU4bHICe4Xg5YM/HGbWCJmj1bHa5qBEJ5Hfg8YRGUJmt0PisEENoXmNrGpPP+y0b2zmTYDWU7cV3tUM67PbtDNgEBOt5cYUOHIf40aNTLPR4wYYa55b5iZxVHY2Hye55CBCF5X3r6DOcGAJgO2DKoy0Omc7EwzHme71NU+RgwG8ZpjQJbXPpu7e8PR6PjbxGAU52eAhQMAeBvZL7+uMzaIZ68wNrC/8MILzf7bI3Fm9nvGQDAD01w/SzPZaN8uz+R+ssSQ2ZieMvo9zsn2ioiIiIhImgBXTut1RAo5Zk/w5po3nwx6FASWOzJDjtkXdiCK2Ry8UWVGihROzC5iYCKzMkIRERERERHJOmVKSbHHDBZmkU2bNq3AtoEZIszYYKYFy/OYgcPHHJVLCif2kmJWkrcSWBEREREREck5ZUpJOixtyajfC8vLfJX9ZAUzl9izyZePPvooV3vxsNyQpTvsTeVrZK28xn5DbE7N/jos12N5IMuIcnt72P8mo9HYeP6y2nyb2CvJ2QfL2wiU/pbNFQWvvvqqOVYKSomIiIiIiOQNBaUkHWbxOId+91SzZk2vQ9tnFfsJcVQvX9iHhz2eJOsYVHSOYueJ54/nMas4GplzFENPDLSxf5CIiIiIiIiIPxSUEhERERERERGRfKeeUiIiIiIiIiIiku8UlCriFi5ciKZNmxb0ZhQr9913nxkpLy/L6yZMmOB+fs011+Dtt99GXps8eTLOOeecLF838+fPx+bNm81j/uX2FsVBO9euXYulS5cW6u8NG9/v378/V5b1+OOPZ3pdffbZZ+Y4OKeXXnopV9YvIiIiIiKSGQWlRBwWLFhgggLdunXLs+PCJuPvv/+++zkDBzfccEO+noczzjgDc+fO9Wve6667DocOHTKPGzZsaJp/T5kyBUXNHXfcgW3btmV5//PDjz/+aJrgh4SEYMaMGTkODHGgADb1z8ymTZtw5ZVXmmNhTzxOIiIiIiIi+UFBKRGHd999N89HW/PMMipXrhwiIyPz9TxwxL/KlStn67MMYjCoVhSzpXJj//NCmzZtTGP/jRs3miwuO6Mtq6Kjo3HXXXeZoFT16tUznZ+Zb82aNTPHwp7YsF5ERERERCQ/KCiVj9atW4fLL78cbdu2RY8ePTB27Fj3ezExMXjyySfRuXNnMz3xxBOIj493ZzPceOONJrujdevWJihgl1N54qhrt912m1kHb2y5juTkZL9HxGPGDtfTtWtXjBo1yj1CHkfkGzduHPr06WNuoFnCtX79evdnWfbzyy+/YODAgWbdI0eONCP5DR8+3DznNttlSQxmMKjB7WvVqhW6d++e7lhk5vDhw7jnnnvQvn17nHXWWXjttdfMMnft2mW246+//jLL5n4899xz2LBhA4YMGYJ27drh1ltvNTfu3mzZssWUd/Xq1cv92hdffIHevXub485lLF682P0el8vjwOPBsquvvvoq3fKmTp2KAQMGmP3neV+zZo0JODzyyCPYvXu32VZus2f5HsvseBy5XK5z0aJF7ve4X1zPsGHDzDZdeOGFWLVqFbLKs3zN137awRGeR3sbuV28XufNm+fe3oxK4aZPn26OD5c9aNAgkwlk27dvH+6++2506tTJXPc8XyxvtJfLY/Pee++hY8eO5lz/8MMP+PXXX822nnnmmRgzZox7Wby+GJDhvLyuLr74YixZssS8x+XwmPPYP/zww6ft//bt293fsbPPPtscD1/+/vtvs2ye18GDB5vyRuLxefDBB833hsvhsWPm0fjx403mXZcuXXwut27duuY8jhgxwvzlc/v4e5bXceI+eMPrib8bPHa1a9dGZnjN16tXL9P5RERERERE8oRLckV0dLTr6quvdnXt2tX1zz//eJ3nggsucD399NOuHTt2uGbPnu1q27at66+//jLv3Xvvva5Bgwa5Fi9e7Fq1apVr4MCBrhdffNGVnJzs6tOnj+uJJ55wbd++3bw3bNgw16233mo+t2DBAleTJk3M45SUFNeQIUNcjz76qGvz5s3mvX79+rnGjh3r1z7cdtttrjvuuMO1bds215IlS1xnnXWWa/z48ea9t956y+zbjBkzXJs2bXI99NBDru7du7tOnTpl3uc2DBgwwLVs2TLX/PnzXS1btjSfnz59umvNmjWuvn37ukaNGmXmnTx5sqtLly7mOO3cudP19ddfm89z3/xx2WWXua688krX6tWrXf/++69Zz5dffmmWxeVcccUVrrVr17qmTZtmnp977rmuuXPnmmPbqVMn16effup1uZ999pn5rI3L537MmjXLLHv06NFmXTwnsbGxrp49e7pef/1119atW10zZ850devWzTVlyhTz2b///tt8lvvG48l95/GKj4836+FnDxw44EpKSjLXDY8vTZo0ydWuXTuzHJ7DMWPGmOf79u0z7/fu3dvVuXNn1x9//OHasmWL66qrrjLHwx9cNj/ved1ktJ+HDx828/3222/mGrfdd999rueff9485rHgvnhz6NAhs2yue9euXa5x48a5Wrdu7Tp69Kg5Frw+b775Zte6devM9cBr3b5O+Bl+9pFHHjHHkNvF74x9fidOnGi2jdtPPI633367uT43btxoviPnn3++eY/r4zHnsT9x4kS6/Y+Li3Odc845rhEjRrg2bNhgziWP+Z9//nna/vD9Fi1auN555x1z3j/44AMzL/ef55Dby2uC39W7777b1aFDB7Md3CZ+D/lZHlNvfvnlF/Md5vpjYmLMa5yXy/acuA+ZcV5X3hw8eNAcA36XeV3w+8vzw20QERERERHJD8F5E+oqedgT5t9//zWPX3/9dZNp5ImZGsw0qlmzpsli+PTTT1GrVi0cP37cZH/weYcOHcy8zz77rGnMHBcXZ7JsmGkUERFh3mOWBrOWvPVDYrYTe8kEBgaiQYMGeOihh0x2iD99Yrh9LVu2ND2DmKnx4YcfokyZMiYLidkezH7i9hOzQc4991yz39w+u/cQs0eoefPmqF+/vsn4oX79+plMMWJZ0QsvvOA+RiyXe+edd0zpEtefES7jv//+M9k2dibI008/bTJ3bLfffrspSeL0/PPP47zzzjNZNsR1MjvEG2YysWeS83gEBASY48HzxOwsZugwa2zatGmoWLGieY2YbcL5mQlz0UUX4bvvvsP555/vLgVkBg37BfFcly5dGkFBQV7Lx7788kuT1cNl0P33328ypXj82YDdPv99+/Y1j6+//nqTaZQTGe1nhQoVzDxly5ZNV2LYqFEjd6YUy844ecPsJWbbVatWzVz3zMRjpk9YWBjmzJlj3mfTdy6fmC34v//9D/fee695zmuPDbt57V922WX4/PPPTTaRfX6ZJcfzyeuNx4QZWVwXXXXVVbjlllvcJZI85jz2nJyYzXTkyBFzrbB0rXHjxmad/A55+v77702GHq8x4vJ57Z04ccI8L1++vDkfPJ48T8wefOyxx8y1ykyst956y2Rl2cfViVl15Czd8zZfbrG/B7yOmY3G3xtmqvE48bssIiIiIiKS1xSUygO8IfWGpWO8iWbAgiVCLL1iYGLFihWmxM4ZkGFpEidiYINlSyzr4Y0kgyeVKlU6bfks6Tt27Jg7sEUMLDCwdfToUXPDnJGbbroJjz76KP744w/07NnTlFq1aNHCNLnmcu2AEzHAwhIpZxmhs1yIQQoGIZzP7bIsljEtX74cr776qvk8b4YPHjxotjUzW7duNQEG57rsAA1Ll7KyHZ4YmGBww8aywiZNmuCCCy4wx4EBuaFDhyI4ONicBwbIWKZl4znkDb29nXawzu5hxABhZng8PAOILDt0HmdnuRWDKHaJZXZltJ++8BywjDIzPJ681hk8Y5DSXnapUqXMPnFf7IAUMeCTlJSEHTt2uAMmdjCWgSxi4MzzfPI7x+8JSwVZgsnjz++Lv9cUt83ZS+mSSy7xOa9n4NQOTNrbZn//7UCdff3Zz31df94woMpAsyeeKwauc4Ilkwxk278LDBbyO/DNN98oKCUiIiIiIvlCQalcwpvEn376yQQrnDepTsyqYOYQs3z+/PNPXHvttSbjiMEdX06dOoVLL73U3Dgyg4LZN1zHJ598ctq8vJlndhSbdXvyzA7xhv1xmEnE7WNfJvbnufnmm02wyhsGYZw3/XZAxuYt04SYycWsFAYnmEHFYA17FvmDwbDM+LsdnhhMcPbfYuCE28oMuFmzZpk+Pbxh518eax4rZvZ4k1FAJyN24CWj4+zPMciKjPazatWqXj/D7fHnuPKYfvDBBybwOnPmTBPw/Prrr83ka1+df70dR29BX24Ps7CYscRgKr8rDNbdeeedmW5jVs5VZvN6e9/f688bZivyWvOUW83IPQPVzBS0e7+JiIiIiIjkNTU6zyW8SWQDajY99la6x+bDLI1hxgyzRlimxWbVv/32m8nsYSDFLm8jBoZY/sNAwYEDB0xZGINDbJjMzAlvI58x24PvseSH5XecmD3EkiFf2VtOLDtk9gszThhIYHDt999/NwEtZmYtW7bMPS9v+FevXm3WmVUMeDAbiFlZLFPjjTHX689obtwnZm2xobuNx8Yup8oJZuVw2TaWCfI4MLOLJZAsseR5ZPNs7jezZpgZYx9rHh+eV3s7neeTQRYGSvjZjM4Fl8ssMic+z85x9ldG++kLM++8Zet5YjbUSy+9ZJqjsyTv559/NuWbLN3jPm3bti3dMecxZGCnTp06WdoHDgbAMsfPPvvMNPpndha/N5TZdcVsLZbUxcbGul/jNvP76snzvBIz4rhfeYFZVvb15Zx4reYUA5Esd3QeH2YtMrAtIiIiIiKSHxSUyifMCmFZETOjmOm0cuVKM8IZy6UY0GJwZvTo0SajhO8xQMQgAcuk2LOGQSoGmHgjyeCXtxIglmHxJvaBBx4wI+Nx+RzFj5kwntlD3nC7WBLEm272d5o9e7bZPmKPGQa3mOHFQIM9OiCzUrKKQSgG7+wSKwYrGOTyp6yJ/X54XNinh/vIUdSYTWL3jMoJ7qtzREGWW7HXFY85jz0DDzwXLHNiVhnLIpkpxePBY8XzZwcL2BeK/bamTJliAh7socWbf5Z+8XywtxQDMp5ZMDzO7B/Fck0en1deecWcD2bL5ZWM9pNYPsfr4eTJk+7P8DjZ1waPA8svvWFPMgYhmb3H0RiZgcceVvwszxkDsuy3xeWxlIzfD2YD8nNZwfmZkcRt5/IZWLNHC7SvK+4Hr3FnEMz+3jDAZp9LZnR9++235nVPDNjye8X+bzyvDObx2NiltoUd990+jwxw87wxAMd94bH76KOPfGZGioiIiIiI5DYFpfIRA03MxmCAgU2PeSNrZ/gwa4iNm5lFxZK5zp07m2ANexYxq+iZZ54xgRCWVPHmmZlFnmU2DDyxYTFLmZiFxYbQvXr1Mk2b/cGG4bw5Z0CFn69SpYoJ/hBLo1hux2DUkCFDsG/fPpMVlJ1GzNzX6Oho01OL28jgB5umM0vDH2PGjDGBHTa+ZvNv/mUj+Jzq0aOHCQCxZNLuh8RAE5vKs+zy/fffN+tmiRMDibyBZ2CJAUUeYzbWZt8w6tixI5566ikT7OF5477x8wwAMajGbBeWfHruM4N8PO8MAPJzzJRjqaazAXtuy2g/idfDyy+/7A7yMLjG7Cr2HSP2cfIWwCH2TOPnmBHI/kgMerJhPufn9WqXmvJ6sxvpZ6dXEpub8/rlOWFQi4FKnhNmXbEHmx1QYkDX8/vAebgdzKxidiKPBQNlzLbyxAwu7s+kSZPMerhfPF6+yhwLG37fuH/EADaPE88lrzX2eGNj/ewEmkVERERERLIjgEPwZeuTIsUQAzBscm2PfienY6CMwUmOLJeTfkkiIiIiIiJSsumOUsSBmU4s3RLfOHokS7wUkBIREREREZGc0Oh7JQR74LAkzJfcGGI+N7A0kL2UfGF5Vl7272FZ2ffff4+5c+f6LEkrjNiLjKM5+lKjRo1cacbNnktspp+XPa5ERERERESkZFD5Xglx4sQJM2KaL+yRlBsjeuUUAx5seu4Le/ewL5Okx2bezhEJPbFvEnsIiYiIiIiIiBQWCkqJiIiIiIiIiEi+U0+pIoKjtC1dujTP17Nr1y4zGh7/ZiY+Pt6MpMdyOpa6cZS4wmLevHlmJLG8NH/+fFPORhwV8Zxzzsm1URonTJiA/MLzvXDhwkzn4/5x3gEDBpjnHCPhlVdeMaMJdurUyYzQx5EfifNw3tw6JnnpueeeM9vqnMaPH+9z/s8++8yM1MiRMXn9c0RNERERERERyToFpYqIO+64A9u2bcvz9VSvXt30U+LfzDAIsWrVKnz++ed46qmnMHbsWPz6668oDKVsDDSMGDEiT9dz3XXX4dChQ+bxoEGDTC+q3HDjjTfigw8+yLDcMjfxfDPA4g8GYb7++mt3n7KffvrJnHf2K5s2bZp5jTgP5y0KGFi87777zHGwJ47A6M1vv/1m9pf913jdL1++HGPGjMn3bRYRERERESkOFJSSdIKCglC5cmXzNyMxMTGYOHEiHnvsMbRs2RLnnnuuGZHtq6++KvAjOn36dNPYu27duvm2Tva5qlChQq4sq0yZMibzzA7+5DWe79DQUL/mLV26tHs/v/jiC9x1110mU47ZUsxMs88/5+G8RSUo1aJFC3Mc7KlUqVJe5+U+s6F879690aZNGzzzzDOYNGmSsqVERERERESyQUGpfLRu3TpcfvnlaNu2rSn/YcaFZ3ZP586dzcQb/GPHjpn3rrnmGuzevRuPPPIIHn744UzXw7Kq999/35ROtWrVygQ4nOvi8vj8iiuuMNty5ZVXusvQPMv3Dh8+jHvuuQft27fHWWedhddee80sn/uSlJSULsOmQ4cOJnPELuHKDLNquI1cBrODdu7c6d6+jz/+GNdff7258edIb9u3b8cTTzxh5u3Xrx/+/fdfn8v95ptv0Ldv3xwfd+J6uW1c79lnn22CEmSXpQ0fPhxvv/32aeV7PJ78HI+bvU77uHB+ZuYwu4zvd+3a1Ywq6MRlfffdd+7P8JhkdO4ZIGTJHM8394PBkuTkZPMeP8d9vO2228zxvOiii9KVgjrL9xhsfPLJJ93Hg8ecZZqe9u/fbxqrd+zYMd3553V64MAB+GPq1Klmm3leeH7WrFnj3l5mH/G643vMQuN7LGtkAKxnz5745ZdfvC6T58GzFM+evJWkRkdHm32pV69eptvL47ly5cp0oz+2a9fONObnNSYiIiIiIiJZo6BULjl16pQJHHTr1s30GvLmwQcfRPPmzU3J0+jRozFu3DjMnj3bvMdgD0vhGJxg4IM3y3fffbc7iFGtWjVTDsXMpMz88MMPprSI62A5HUv/uIzVq1e752F5WP/+/c1NPEe0u+WWW0yAxhM/e/DgQdNj54033jDzMxuGr5UvXz5dhk2lSpVMAMMZ1PHl22+/NYEaBoGmTJmCyMhI9/7SO++8g2HDhpn1nTx50gSmuHyWyDVu3NgEWbw5fvy4CYwxgJbT4859ueGGG8y2sccTgzUMjMyaNctdqsfjynmcjhw5YgJ9VapUMcEiBp94/OyAll0GFhYWZvadwSv2Ztq6dav7fWYesTRww4YN7vX4OvcM0PF4jBw50pxvBqS4fTNnzkx3vBs1amTWx0ASzze309Pjjz+OJUuW4N133zU9wviY590Tzz9xH208P7Rv3z5kZs6cOWZ/mHX0448/mmDarbfe6r4Gef2yTxXfK1eunJmPAVIG6hiw4zH1FvxkAMtZhuecvJWkMngYEBBggrgMdg0ePNgcI18jWPKacO4zRzXk9vmzzyIiIiIiIpJesMdzySbePNvZOwxcMPvFE7NI+vTpg5o1a6J27domU6hWrVqm9IdBC5YBMaPD7tfETJX169eb11hOx3Iof0qiePP9wgsvuLeBGVEM8mzcuNGU2hFvwNkTiUaNGmWyedgcnAEfG7M//vvvP8yYMcNsLz399NMmm4bb7FnyZT/3FtzyxOAC188gAjHgw+youLg485zlUQMHDjSPmfXEkjyWijGAwGAVg2W+GsKHhISY45rT487MGgZunn/+eURFRZljw6BNYGCgu4StbNmyJmjlxOAXy794XBm0aNiwoQni8BzYx5yBjIceesicV5Y9MijG4Fj9+vXN+wxYcVuZIdSsWTMzvy8REREm2MYMMuK+cR95vu3XGJCyG78z4+7PP/80x/Tqq69OF9BjUIufZdYTsXcSj6kn+zw5r4Gsnv/zzz/fXJt24JDnjdtADFIxsEecj+eAx55lkgz+MhuOQTtngIj4Pid/bdmyxVxTDRo0MMdi0aJFJjuM55slqZnts/3cn30WERERERGR9BSUygO8yfWGmSDMzOENOUvBLrzwQtO/htkwLAFiCZMTM0HY3NwOmPiLWTbMFnr11VdNJgiDCgyKODNLWDZm4w04gyGc1xmUYuYOgyF2QIrssjiWT3neiNvP/QkKcNl2gMzOsmGQxuYMKnF57BFlH1c+5/HyhkEkBooYOMrpcWc5IY8Lj4/NVwNsJx5H7hsDUjaW//EcMNvG3j9n3y4GtlgO6cRjz+ygzDCAw2PCZuObNm0yATWWHbJs09v55rFhDyW7ZNPGz7BEzXleWKrmLFfzFoBiAM1+TL76MXmef+dx5/IyOv+8PuzrynN9nsFhZlF58/PPP5vryImljAyA2kE/BgB57hn08gxK+Vovn/uzzyIiIiIiIpKeglK55IILLjAZMsy8YC8cb1gyxewfZh4xU4UlScymYVCB2NiaWS9OFStWzPK2sGSMmSVDhw41mTK82WfvIydnwIQYjHAGcoiZK76w5I+jwzGQYi+LQRcGDtioOzOe68/sfc9t84WBK8+yruwe9+yOpmcHL5zsbbL7PHk7tuzV5fkZf/abpXDMHGOAhRlvfMwSvtw8397Ov33O7QCSXdLHgF9BnX+W9rEPlTeeWVX29eKZhcasqQULFpw2L+fjuWWGFrPfiNc/y1X92WcRERERERFJTz2lcgmzadhrif2kvJXusRcN+/4wI4QNvL/88ktThsbeQsxEYtYMb245YhwnLo8leP5kynhilgcDE+xBxUAFez9xOc6gh7MxM3s27dix47SMLG4Ht4kNrW3si3T77bebHk0MHCxbtsz9HvsPtW7d2q8AApft3AYGuJjh5a0ZdVYwo4bZSPa+5uS4s/k1s4dY5md76aWXfPazsjG7iv27nNlcLINkyV9GZXieeEzsPk2ZBSGZwcVSOwYiGTDh+XSeb2cJHgNSPPae59s+Hs7zwkDexRdf7DUoxawjnnMbH/M1b8GfzM4/t4kBJefysoPnzz6XnpO3QNibb77pLqm0cbsYmPLE65rXt3Mbef1zucywEhERERERkaxRUCqfMMOCI54xQ4fZVBzFa/HixaaMijfSDCawXxNHQWMJFnvsMCBiZ6Ewk4ef86eJOINQDI6xRIp9iu69914TIHGWHU2bNs00RGcJFxtOM5jAXkpOLOVjoIjvsySM2/bhhx+aJuIsV2LAi9u8YsUKE7xgY2zPjCxf2BeIzaz5OW4nS664r86yrexgoIUZRnZpWk6OO8vfGBRivysuj43D2TDcLovjOWHfJgb1PLPmeKztz3Ef2aic/ZN8lXZ6YsN19sKyS+l43j3XY2Ogi0EvniNuD0evY9aS83yz3xnPD48B+08x0MaR75x4PHhO+T7PKY8V+6PxGvCG+8MG7Tx2nFgumtH55zbZfZl4/llqx6biPN4MBDKI5iwdzA8s3WMfKfYzYyCPWXP8XtjN67m9dgYYsc8V5+U55THitcMgp8r3REREREREsk5BqXzEG3wGAziSHEdcY68eZh0RAwnMsGIzb97kMvuCASC77xADAMzEYrPnzDBDikEN9k4aMWKECdSwP44zW4aBEwZYhgwZYkYOZKNtb5kkY8aMMTfcl112Ge677z7z125AzYbZDCKwHI7lYlyX3Vg7M9w23vjzc9wGZjSxJ1JOsXSwTZs26bJZsnvc+Zij0B04cMBkCzFYw6AV+1LZgRU2RmfAyTO4wxH+GORgkIcBMR6jO++80+/9YJCJIy6yQTnx2HL93nC5LDfkuWE2GANxvF6c55tZSCxJ4/aweTqbmXsrs+S1w6wfLufmm282gUoGNb3hsWSjeq6fIxbynHpmHTkxmMfm6sQRABmIZPN3jnjHbeUIeFlpUp4beK0wW2rq1KmmoToz6RhcYw8w4vY6e3Odd955pkcZA468fvn5Bx54IF+3WUREREREpLgIcHk2spFij8GUTp06mUBHcTR58mST7cJSw6KKAT+W09nBs5xg4I1efPHFHC2HgS0GoBhE9Pc8jB071vTxEhEREREREfGkTCkpdpjxsmfPHlOqVhSxl9S8efNMtlNhwxJCjnCYGc7jq9xQREREREREhDT6XhHDBt125os3HTp0MKVjBYmlYRmV4rF0kE258wqbmj/xxBOmNIylWEUNez/973//M73BChuO6shG+r/++muG87HEk73CatasmW/bJiIiIiIiIkWLyveKGPZ/4pD0vrAnD0dGK0gc/Y7ZPr6w5xJ7IImIiIiIiIhIyaWglIiIiIiIiIiI5Dv1lCoiODrZ0qVLUdz98ssvOHz4cL6vl/3+ObphYfHaa69h4sSJKMp4Hnk+C8LOnTsxe/bsPF8PR7lkU33b/fffb/qBFWYJCQmm79rChQtPO2YcPbFdu3ZmVMW5c+dmuJyffvoJffv2Rdu2bXHHHXf41WusJONxnzBhQoGs2/M6LQ6/2flp/vz52Lx5c0FvhoiIiEixpKBUEcGbvm3btqE42717N+655x7Exsbm+7oXLVqUp32usoIN2v/44w9cfPHFKMpeeeWVfAkMefPoo49ixYoVeb6ezz77DJMmTXI/54iWo0ePNgGIwig+Ph4jR47Exo0bTwvK8jemUqVKZn8uvPBCM9IiBwzwhsf2scceM/N89913pmSXI0aKbz///DPef//9AjlEntdpcfjNzk8M1mZUNi8iIiIi2aeglBQavDEuiev29NFHH5mAVHBw0R6HoDAd0/zax7p166JGjRqYPn06CptNmzZh2LBh2LFjx2nvLViwwGRKMTDbsGFD3HrrrSZjylcgY/z48Rg4cCAuuugiNGvWDC+//LIJQHIZUnJ+30rCd1xERERE8paCUvlo3bp1uPzyy025S48ePTB27Fj3e8yseO6559C5c2czsQzo2LFj5r1rrrnG/Is0MxEyGnnPaerUqRgwYIBZF9e5Zs0a93uTJ082N5Rt2rTBkCFDTJaQ7ZxzzsH333+PSy65xLx/ww03mHUzA4TLYgaFnWXB5VxxxRUmI+aMM87A2Wefna7kjCUj3OauXbuiVatWZntmzJjhfr9p06Z48803zf7edttt6NOnj3mdf7nst99+Gw8++CBGjRplls9tY0kRb4i7deuGLl264IsvvnAvj9kaDzzwANq3b4/u3bubz8XFxZn3WKrEz3/99dfm2POGm/PyuO/atQvDhw93b5NnWZM3MTExePLJJ93ni6P9MQvFXgZLWniMecyYmcKbda6Dzzky3f79+70ul/vAgIZ9LIilMcxG4H6dddZZprTPvhnct28f7r77bnTq1MlsB68hO0uHx5DXznvvvYeOHTuaz7KEhyPn9e7dG2eeeSbGjBmT7twzo4KjI/L43HLLLTh48KD7/ZkzZ5ogROvWrc1nuV9svE88V7fffjuuuuoqsy1c75QpU8zE5WbnuDBbjGVkfO/SSy/Fv//+637P3q8bb7zRXKf9+/fHnDlzzHv8jnBefr84X2YSExPx+OOPm+PH64zXoj/bwePLdfA59815HL/99tt0z3l8svpd5X7w/PDc8z1uA997/fXXzfHv2bOnuzyS1yy3wdtkX8/cTu4jM5s8LV++HC1atEBERES6kTyXLVvmdZs5P7fBVr16dROM4+ve+HOdcsROvsflvvDCCz4DHklJSeY7wO84t/Guu+5yD6zA7yCPWa9evcw1zHO5d+9e8x6/5zwef/31lzknPNfcjg0bNpjfQc7PYBx/t+zjz/e5DF5jvPadJdQM8vH643L4neD1a5d42b83Tz31lNnGDz/80PwW8reU28Bt4T5//PHHuP76683yeW1t377d/JZwmf369Ut3zXM7+Rn7eneWG/P6uu+++8z6+DvB31wGtzO6Tp34m8Nlcj94nTl/p3n8eAx4DXKfuKzk5GTznudvtidm2vG/IdwfbhN/k/l9I55fjpDK88hzznU4M/N4TpmJx89y+Rz1095++/jyv1X8XePvG/eX/y3jd4mf4X87UlJS/FoXl8vvIcta+d8qnks7wGr/fvF3isc5s98LEREREckil+SK6Oho19VXX+3q2rWr659//vE6zwUXXOB6+umnXTt27HDNnj3b1bZtW9dff/1l3nvhhRdcl112mWv58uWudevWuW699VbX8OHDzXtHjx519ezZ0/XZZ5+5Tpw4kem2/P33366WLVu6vv76a9e2bdtco0aNcnXv3t0VHx/vmjRpkqtdu3auKVOmuDZv3uwaM2aMeb5v3z7z2d69e7vOOuss17x581wrV650de7c2dWxY0ezrA0bNphtvO2228y8XBbXc8MNN7jWr1/vmjhxonk+Z84c8/7DDz9s5l+zZo1r69atrscee8zVqVMnsx3UpEkT14UXXmi2Y+PGjWbf+Rr/xsbGut566y2zvNdff921fft219133+3q0KGDOTabNm1yjR071tWiRQvX4cOHzfLuvPNO8x6PH5cxdOhQ1yOPPGLeW7BggVkWjynf5zFq06aN67vvvnMlJSW5fvvtN7PuAwcOuLcvI/fee69r0KBBrsWLF7tWrVrlGjhwoOvFF19079eAAQNcy5Ytc82fP9+sl8d0+vTp5lj07dvXnBNv/vjjD3OunXgMr7zyStfq1atd//77r1nWl19+abazX79+rptvvtnsE6+7Pn36uJdtnx8eA14Ho0ePNtfcFVdc4Vq7dq05X9xWLtc+9+3bt3f98MMPZnm8nrlu4vHnsni8du7cac4xr41PPvnEvM9zxWXxOuE+njx50pwvTvb5ycpx4fadccYZrh9//NFs++eff27OFx8Tt43PuY/ctrvuusvVq1cvV3JysvmOcLt5Pvjdycynn35qjiPPI68rLpvLy2w7eI1yHVwXrxsb32vWrJnr+PHj5jn3n78PWf2uPvTQQ+a9r776yrzH83bmmWea7xG386mnnjLfTe4z5+c2eJu8Xc88F/xO2J599lnXPffck24erpfXuDf8zeBvmNOll17q+uijj06b19/rlOvnbwGvPx6/uXPnel33K6+8Yo4R18/fDX43RowYYd7jMTv33HPN9cVzd+ONN7ouuugic4x43XK/7et/2rRp5jnn57r4XebvE68He1ncLv5G8ng/99xz5veH55PL4z488cQT5vrjtTNs2DDz+0M8tlw2fwN57nbv3m1+v/nd5jnhbw6vM15bvP65HzxGPL9vvPGGWd/tt99u/ptBvNb4Wf4W8rd05syZrm7dupnfcbJ/K/kd5/p4Hrj+LVu2+LxObYcOHTKf5XnYtWuXa9y4ca7WrVub705KSopryJAhrkcffdScG+4Xt5O/veT5m+2J/6244447zDYtWbLEfN/Hjx9v3vviiy9c/fv3N8vk/nIdfJ6QkGDev+6669zniv+d5Ge5Lvv4cpt5vLld3GZeMzzX//33n+vPP/807//+++9+rYvL5fnktcn/lvF3auTIkeY9nm++z/9G8Huc0e+FiIiIiGSdglK5hDeV/D+unBgM8YY3/Lzh4A0NLV261NwkxMTEmP8DzRs2G29o+X+y7dcYMOBNgz94E8AbKudNIW9KuC7+n/ZXX3013fy8meKNnr0e5/sMKvCmz3mjyv9DTtyeVq1amZsa24MPPui+QeT7/D/4Nt488Pjs2bPHPLeDGDb7ppF/7Rst3nzyxoh4Y8L3GdQj3gTxOY8jbwx5vJxBOx47+zX7JpGBNedxevzxx81j+31/HDt2zNW8efN0N/WLFi0yNz72fn377bfpbtYfeOAB9/OXX37ZBPK8efPNN13XX3+9+zlvyJz7bAeupk6d6poxY4YJMnF7bLxRZ6CON088/nx86tQp8x5voLgsZ9CUQVTenNvnnje1Nq6T8/Mc8kb4m2++OS0wZwf9eK54k+zEa9B5HWbluNx///0mUOvEoKP9Gm8E7evMeZzs4Crf5zb5g8ER3vzbASzemPOG05/t4Dq4Lid+v/m9cF4f2fmu8nU7KGh/9/g7Yd/82+dz//79rqzyDErxPPK768SgJQOF3vB7xcCPE38n3nnnndPm9ec65fIYyLTxd+q99947bVn8LWDgyPlbyIAOzwOXz+XYQXHiOeW6Gfyzf1+c7/P652+y8/eOgSbi8WfQ3HlezznnHBMQ5neKgR/7u0X8fjCw4fw94TmycZv5HbPxurEDH/b1f/bZZ6f7veP5pgkTJrguvvjidMeCvzf2a9x/Bm0Y7LLxODGY6us6tTEozW3lP0TYx5jHiP9d4m9Fly5d3P/NIgbEuGxvv9me+L1iYM4O/nBd9rwMsnFZNm4718XXGEzz/N3j8XUGpeygm/O/Bbxmnb8v77//fqbrIn7WDpYRg8/2f+c8vy8Z/V6IiIiISNYV7aY1hVRAQIDX11kawrITls+w1I2lcJUrVzZlGSwJYOmOE0sP2NzcV8mFL1u3bk23rNDQUDz00EPmMctL2NDYiWUrzpGFateu7X4cHh6OmjVrpntul1/YPXQqVqzofs7SB7t0ieUuLAPhiFNs3r169Wrzul36Qc5le1OrVi338eS6nZ+xn7MMiNvP48WSJie+xpIY5/baoqKiTClQVnF53IeWLVu6X2NJiLOcKbNj6KsRNkcwK1++fLpzWa5cuXTL44hnxJKgevXqoWzZsu73WLrDfbL7BvHc2CVZYWFh7mPqa1v4eec+cN08tiy543XEkjmWb3Ji+RKvYX/PZVaOC9fJ0jRnqRmvO5bf2LjvznNJ2Tmfl112mWlCzWWzvIzHl+Vc/m6Hp8DAQHNO/BmRLKPvqrdzxUbk9nVvn08es8WLF+Pmm2/2ug6WNTmvTW+4LLtc2Mbl2uvyNr/nNcznpUqVOm1eHkN/rlP7HGb03WRJF7fT+d1r1KiRKS9m6SC/7ywzs/H6rV+/vtkG/s3qd9P5feB5ZYkjl8XvFEuXWQ67atUq8/vG0kqeHyfn+fPG8/yyBNL5e2f/1nL5LP9muZiNv0FBQUHpluV8HhkZ6df3oXnz5ua/Rywj5DFiqdzQoUPNueS+8nizBNHGY8yyaLtkMiM33XSTGXSAJbD8bWZpII8hy35Z0nnvvfea42rjcvnfPJ4Dz989/nfKk/2+538b7Ne4nMzW5eu/Dc7/zvn7eyEiIiIiWaegVC5hHx4Okc6bB/aA8YY9enhzz0DNn3/+iWuvvdb02GAgh9jvyNnThZwBH39l1CDbvpF14s2N3XuDnDc25Pw/8pmti8uy52dPj//++88ELngDxwAc/w99ZtuT2b542x6ut3Tp0l4bM1etWtXd64Y3/Tlt1BsSEpLpPFk5hk68IXUG7TJal69z6fzr7fj5CppmdD55Q8xzyP4qDHBwNKrPP/880+3J7nHhehlkYWDTyRkk8XZssnM+GzdubL6P7DXEiYFjfpfZs8ef7fCG3yd/znlmzew93/e1TP6GMEDiDa//zHAeBhmdONpYlSpVfM7vORoZn/M7np3r1PN76etcZvW3La9+3xjoYA8oBpD5nWAvIv72f/LJJ35tk6/l+9oWBpfYk4l97HzJ7veBvwcffPCBGVGRfeMYQOJ/izhxvQ0aNMC777572uf4e2v3lPNl8ODBZrv53zx+t9j/i98n9uIi9hS0g4U2Bi8ZZPVn2/05fvY15mtdWfldz+z3IqPfVhERERHxTo3Ocwn/ZZX/p3T+/Pnm/4R7YgNeNs3lzRf/RfrLL780I2H99ttv5l97eaPEf5Hmv9Zy4vLY7NefbAtP/DyDCM7/U84bpyVLlpj/U+7ZjJjPPf/Pelayhpw3JswaaNKkiWkWzP+jzqbMvBE599xzcfz4cTOPr5uNnPwfem7/yZMnzTLsY8h/CeeoYL6ykrK7bvt8OY8xb7o4Yl5OMQjpzFjhfvC53ayZ2NydTcW5z/yXfuf8bEzNG7U6depka/3OfeK55TG1mwCzmfCrr75qmgCz2TLfz+jGMafnk82g7XPJidlKf//9N3IbgzmzZs0yAeOXXnoJ48aNM98Vfvcy2w5v+8gACK91z6yZrH5Xs4JBMuc2OqfMAmjE7CJmMtoDAxC3wZl15Dm/cxt5fXLyNn9uXqdlypQxgSDnMVu7dq3JwmGmEJfpbM7ObB5ep9n9feOyneeG6+X3gU3DDxw4YL6LzAbiwAtsnJ2X3wdm1XEf7fPK/eR/R/yR0bqZDcXrnt9pZhMxC4iN6zlwANfL/apQoYJ7vfw+sCk9l5nZPvH3n98jBrQZ+OI/2Pz+++/mPPK3jgMp2MvlOtmknvvJESD5HXKO5sj/tmRHZuvKzd8LEREREck6BaXyCf/FnCM3MTOK/6K+cuVK86/BLGVgAIrlEk8//bQZVYgZC8wy4s2UXd7BDCp+zrPExhuO0PTjjz+akc+4DHskK5a8MMOFo9fx/1jz/5Bz5DzeaPFf/bODo9BxxCfe2LBMjyO7MWjB4BvLP3gDwpsY3uBwuHnyFSSyS3+4PZn9C7wn3sRwVD2OWsh/8ecNNke74vbxpiQz9rp542OPoucLzxczZ0aPHm3WxXPJmy+OBphTvB5Yzun8V3ku97HHHsP69evN9cGyPY44xYkBMl4rfG/BggXm+mLWhj/77A1vspktwXPAshuug6VXLKXhOri/vG5efPFFs98ZBfx4TDnaWHZGpuJ1yhHBuD0s8eKogJycJXsZ4feFgRB/bhQZeOO5ZECZN8HTpk1DtWrVTPAjs+3gPjI4wWvcZpfCNmvWzF2S6et6zui7mp9YhsQbdX5nWJrJa4zn2v5d4HnmTb2ddcIgAwOVHG2T1wqvQZaAOcutbLl9nfKYMeuFy+G28tyxtMv+HeWy+T3hdnGETZ5LbkN2MPjE7Cf+9nI9sbGxZnQ3fh/428JgNM89jwP/USKz7wMDLbwus1pmyowjBgyZKcXra/bs2WZ7/M2k9Xad2ngOOLIds6F4/TP7h99b/haxRI0lcTyOPHf8bxZHB+TyGJjP7Debx42/+3yf54rbzeUSv1tvvPGGyTriMeGIdvxvJDOzGAzjuvkbxM/OmzfPBMKyK6N1+ft7wu3nb0VGvxciIiIiknUKSuUjBi54U8MbPZYvsAyKGS/28OPMsGJWETOo+C/+vDG0S014E8ibHv6f6cwwo4WBIg6BzZsZ/mv/+++/bzIm2NOD/xrO/4PP9+ybLgZ1soM3sizZ4T7xX4z5r8/sP8KgFB8zE+y8884zQYz//e9/Zl5n9oET/zWe28R/TedNXlYxK4pBPN6A2P1RWFrhD2Y/8MaV/X1445QZ3iwx6MD1sByFw4PzuOYUl3PixIl0/4LP48ibP5Y+cth3/mXgj9eGXVbDa2bkyJGmH4wd/MsOZnvxmNnllrxm7UAAb/x5bLluZk+wNxn76PjCsk3uB89pVsvquC6eT5YQ8ZplwJNZWry2/cHgBAOhzGLJzFVXXWWCjLzx5rq4T+ydxeOb2XYwA5CZUbzG7QAYsybY+8fukcTvhmdZlz/f1fxkX0sMPLE/DgNl3Cb2OCKW4TJIYGfscf94nXEeXissg2JALaNl59Z1yjLofv36md8JrpsBAQaiiP24mLXE31G+x38MYBDRW3mgP5i1xuAXrw9eF59++qkJ4nD/ef0/88wz5rxNnjzZBIx4DfgKwjK4zCwdlnr7+g30hdcSe4MxoMJt4X8HeN2yT6E/vF2nNn7P3377bfdvNc8LzxHPN88dvwv8LM8de3f16tXL/d+hzH6z+Q8tzBjk7wc/z3JQBtiJ/w3kd4PHjfvE35SPP/7YXVLH64nBIH6Oy+F16W+JnafM1pUZbj9/B3icMvq9EBEREZGsC2C382x8TsTciI0dO9b867PkHgYoGVy788478/Ww8gac61TT3pzhDSxvgJ1N4KVofg+JAXXJX/zHm3/++ceUZdqBKA44wAC9/nsjIiIiUrwoU0qkkGF2DzNVfI3+JIUXS6uYTcQMChHJHma4MRuVmXgskWOmHh/3799fh1RERESkmNHoe0UMSyzsf8H3hqVzLKOT7GNZDv+V3he7ZCevcIh7ltswE81ztELJGvZF4iiXvrA8jY2dcwtvnFkilN0yIxGxRtHjd4klcyyZZPkif3Nzo0RaRERERAoXle8VMWwm6zkUuxN70fgzBLz4xobALB/xhc2F7X5BUrix8bRz5EJP7N3GRs4iIiIiIiKS/xSUEhERERERERGRfKeeUiIiIiIiIiIiku8UlBIRERERERERkXynoJSIiIiIiIiIiOQ7BaVERERERERERCTfKSglIiIiIiIiIiL5TkEpERERERERERHJdwpKiYiIiIiIiIhIvgvO/1UWPSkpKThw4AAiIyMREBBQ0JsjIiIiIiIiIlJouVwunDp1ClWqVEFgoO98KAWl/MCAVK9evXLz/IiIiIiIiIiIFGuzZ89GtWrVfL6voJQfmCFlH8yoqKjcOzsiIiIiIiIiIsVMdHS0Se6x4ym+KCjlB7tkjwEpBaVERERERERERDKXWQskNToXEREREREREZF8p6CUiIiIiIiIiIjkOwWlREREREREREQk3xWrnlL79+/H6NGjsWDBAoSFhWHQoEEYOXKkebxz50488cQTWLZsGWrUqIFHH30U3bt3L+hNFhEREREREcmx5ORkJCYm6khKvggJCUFQUFCOl1NsglIulwt33XUXypQpg6+++grHjx83gafAwEA8+OCDuOOOO9CkSRNMmjQJM2bMwJ133onp06ebAJWIiIiIiIhIUb0X3rdvH44dO1bQmyIlTLly5VCtWrVMm5mXiKDUli1bTBbUvHnzUKlSJfMag1QvvfQSevbsaTKlvv32W0RERKBhw4aYP3++CVCNGDGioDddREREREREJFvsgFSVKlXM/W5OAgQi/gZCY2JicODAAfO8evXqQEkPSlWuXBnjxo1zB6Rs0dHRWL58OVq0aGG+oLYOHTqYIJaIiIiIiIhIUS3ZswNSFStWLOjNkRKkVKlS5i8DU7z+slvKV2wanbNsr0ePHu7nKSkpGD9+PLp06YKDBw+ag+TELywjyiIiIiIiIiJFkd1DypmAIZJf7OsuJ73Mik1QytOYMWOwZs0a3HvvvYiNjUVoaGi69/k8ISGhwLavsNp26BRe+nUdDpyMK+hNERERERERET+oZE+K6nVXbMr3PANSn3/+OV5//XXT3Jyj73k2fWNAKjw8vMC2sbAa8c1/5m9MfBKeubBVQW+OiIiIiIiIiBRTxS5TatSoUfj0009NYKp///7mtapVq+LQoUPp5uNzz5I+SbPl0CkdDhERERERERHJM8UqKDV27Fgzwt5rr72G8847z/1627ZtsXr1asTFpZWkLVmyxLwu3sUnpejQiIiIiIiISK7btWsXmjZtav7mJ65z4cKF5vE555yDyZMn5+v6pRiX723evBnvvvsubrnlFjOyHpub2zp16mSGKHzkkUdw++23Y9asWVixYgVeeOGFAt3mwkyDiIqIiIiIiEhx9f3336tBfCFQbIJSM2fONMNhvvfee2ZyWr9+vQlYPfbYYxgyZAjq1q2Ld955BzVq1Ciw7S2MEhzZUa4C3RIRERERERGRvFOhQgUd3kKg2ASlmCHFyRcGosaPH5+v21TUxCYmpz1RVEpERERERKRIcrlc+d6SJSw4MMujsf3666/44osvEB0djfPPPx+PP/44QkNDMXHiRHz88cemvC8yMhKDBg0y7wUFBWHPnj3m8X///WcGL+N7Dz/8MEJCQsx+MyHlm2++Me17zjzzTDz55JNeE1JYvnfnnXeaxJVrrrkG3bp1w+LFi7Fo0SJTacV19OjRw8x74sQJ07+ayTARERGmf/UDDzygwdNyQbEJSknuZkrFJyWbL7SGFhURERERESk6eB/34PcrsG7fyXxdb/PqpfHSJW2ydA85YcIEvP7666bq6cEHH8QHH3yAzp0747nnnjODl7Vo0QKrVq0yAaCuXbuiX79+JjjEwNAPP/yAw4cP46677kKDBg1w1VVXmUSUadOm4dVXX0WlSpXwySef4IYbbjCvMWiVkffffx9PPfWUmfj5J554An/++ScCAwNN1VViYqIJdsXHx5vte/bZZ/H888/nwpEr2YpVo3PJmaSUtKBUiguIS1SzcxERERERkaImiwlLBebRRx81PaHZB/ruu+82A5cx4DR69GgTgKpVqxYGDBhgglMbN240n9m9ezdKly5tsp/at2+PDz/8EL169TLvjRs3zgS3GNhq2LChCRwdP34cc+bMyXRbuAxmTdWpUwf/+9//sHfvXtOreseOHZgxY4YJkrFReps2bUxgbMqUKTh5Mn8Df8WRMqXELSk5fc1eTEISSoUG6QiJiIiIiIgUEcxUYsZSUSjfY4DHxsDToUOHULt2bVMW99Zbb2HTpk2mR/T27dvRvXt3M99NN91kgll//PEHevbsacr3+NlTp05h3759uPfee012k41lfNu2bct0W+rVq+d+HBUVZf4mJSWZQdVSUlLMupz4GrerVatWWdpnSU9BKXFLYnqUQ0xCMirq+IiIiIiIiBQpDA6FhxT+BANn8Ihlh8SeTiNHjsRFF11kejrdcccdeOaZZ9zzDR482JTyMXvpr7/+MuV7N998M2688Ubz/ptvvon69eunW0/ZsmUz3RZv5X3cJpYWMjNr0qRJp71ftWrVLO6xeFL5nrglJaecFpQSERERERERyQsbNmxwP16xYgWqVauGH3/8EZdccokpvRs6dKgpw2MJnR20Yg8q9pK64oorTA+qe+65B7///jvKlCmDihUrmpI7DnTGiQ3LWXa3devWbG8jA1ws02Ogz14us69efvllJCQk5MpxKMkUlBKfmVLpRuMTERERERERyUXszbR8+XLMmzfPlOtdd911KFeunBlZj2V77CPFkfUYaLIDQFu2bDEBq3Xr1pn3Z8+ebcr3iJ9/4403TINyluxxBL2lS5eaRujZxaAYM7buv/9+EzhbvXo1HnnkEcTExJhAmOSMyvfEZ0+pOAal9i4H9q0EWg8DgkN1tERERERERCRXMNuJTcU5st2wYcNw7bXXmr5SDPpcdtllprcTG5BzvrVr15rPPP3006ac75prrjE9n84++2wzOh6xhI+9pZ588klER0ebfk8ff/yxX+V7GWFWFEfcY9ArODjYBKkY8JKcC3DZOXDiEy9mjgiwZMkSd8Oz4mjpjqN4aupq9/OR/Zqg99J7gBO7gfbDgY5Wja6IiIiIiIgUPJaRsTSNJWZsDi5SWK4/f+MoKt8Tn5lSibHRVkCKGvXVkRIRERERERGRXKOglPhsdJ4Sc8x6EBwOlK+rIyUiIiIiIiIiuUZBKfHZ6Dwp7oT1IKz4liyKiIiIiIiISMFQUErcklLSZ0q57KDUqUPA8m91pEREREREREQk1ygoJW6JHj2lXPGn0p4seA9IsobgFBERERERERHJKQWlxC3Zo3zPFX8y/dGJO66jJSIiIiIiIiK5QkEpcUv0aHS+IbIjMPSztBfiUhufi4iIiIiIiIjkkIJS4paUWr4XEGA9j04JASrUByo0sF5QppSIiIiIiIiI5BIFpeS08r2osGDzNzYx2XojNNL661nOJyIiIiIiIiKSTQpKiVti6uh7dlCqzrFFwOJPgWPbU2eI0dESERERERGRfLFr1y40bdrU/KWdO3di9uzZXt8raA8//LCZ6O2338Y111zjfo/PO3TogDPPPBNffPEFzjnnnByvLyEhARMmTHA/5/q4nqLGij6IOMr3osKDgeNAg+glwJI1accmwTEan4iIiIiIiEgeql69OubOnYsKFSqY548++ig6deqEXr16FerjfsMNN7iDUsePH8fYsWMxatQonHXWWahYsSLOP//8HK/j559/xvvvv49hw4aZ5wxIhYSEoKhRUEpOa3ReJjz1Qk5OsP42vwBo0BsoV0dHS0RERERERPJFUFAQKleuXOSOdmRkagsc9mqOjjZ/u3btipo1a5rH4eHhOV6Hy2UlldjKlSuHokjle+KWlNpTKjIsyPwNsINSVVsBtToAUUXvx0BERERERKRESoz1PSUlZGHeeP/mzYLBgwdj/Pjx7ufXX389rr76avfz7777DldccUW6Ej2Wxv37778m68hZGjdjxgz07dsXbdu2xW233WYyk7xhJtGDDz5oMpbOOOMMU0LHLCxuR7du3dClSxdTWmfjcp544gnzHkvvHnjggXTLXrx4MS666CK0adMGd999N2Jj046BXb7H7bZL9biN3IfJkyenK99bsWKF2Vduf//+/U0GlG3ixIkYMGAAWrVqhc6dO+OZZ55BcnIyFi5ciEceeQS7d+92Hx/P8j2uZ+DAgWb7hgwZgkWLFrnf4/q/+uork2XVunVrXHjhhVi1apX7fR6H3r17m/f4We5rXlFQSk5rdB6Z2lMqMDke5pXgUB0lERERERGRouSTAb6nP55IP+8XF/med/oD6ef9+jLv82VB9+7dTYCJEhMTsWzZMqxcudI8pnnz5qFHjx7pPvPYY4+ZYBJL45zBlylTpuC1114zgZTVq1fjo48+8rne6dOno3Tp0pg6daoJ1txzzz0mMPXll1+aoM5LL72EI0eOmHnvvPNOrF271pTIffrpp9i8ebO7ZxTnufXWW03A6ocffkCjRo3w66+/ei0/ZGCJ+Jf74HT48GGzP82bNzf7wWU+9NBDWLdunTk+zz33HEaOHGmWzYDU999/j5kzZ5rjwFLGatWqme3nepwYkGLwjcvj9nE7b7nlFuzfv989D48hX/vxxx/NMeG6aM2aNXj55Zfx1FNP4ZdffjF9sHicUlJ7UOc2BaXE5+h7wUiCyQg8dRhY8yOwdY6OloiIiIiIiOQIg1LM3GEJGgNJderUQZkyZUxAhMEPZgJ5BqUYOGHPpIiIiHSlasxgYoCJmUbMDGJAx5fy5cubrCau7+KLL8bJkydNoKhhw4a48cYbkZSUhO3bt7uDQmPGjDHL5sTHf/75J7Zs2WKCNexzxXU3aNAAI0aMMFlF3soP7X5Y/Mt9cPr5559RtmxZPP7442Y5zEq67777EBcXZ/Zz9OjR6NevH2rVqmUyplq0aIGNGzciNDTULMsub+RfJzvIxkwuLvf+++9HkyZN0mWncf+ZvVW/fn2TqWZnSjH7KiAgADVq1DDrZUCK+55XQSn1lBK3lNSa1PAQ64IOcSWa1wKPbAHWTwdqdgDqp/9hEBERERERkULohtMzd9wC0gcxMPyHDOb1yGW58rscbhhM9g3L3RhgYXCKzw8cOIAlS5aYAEtgYKApWWOAJDMMMNkYqImP9yg3dGCQhQEXZ18nzz5PHNVu7969JkjGgI2NgSsGkBiU2rRpE5o1a+ZeFjEo5Szh88fWrVtNoIn7a2OAyMZteuutt8z61q9fbwJmDOhlhlldd9xxR7rX2rVrZ1631atXz/04KirKnaXG5TOAdcEFF5ht69OnD4YOHYrg4LwJHylTStxSUjOlggMDEBYcaIJS5pVS5a0ZNPqeiIiIiIhI0RBSyvfk2aIlw3nD/Js3C5jpw0AUs5HYr4g9mzgtXboU8+fPN6PUOQM+GXEGdDLjLbDi7fPcPm/Yz4mTt0bj2Rn5LjiDQM+cOXNM5tShQ4dM1hiDU+3bt/druWFhYV633Znt5Gt7S5UqZUoNP//8czPSIUsBuR3O0r/cpKCUuKXGpBAUGIBSoUH4OPImHDjndaB6G+uNBGvUABEREREREZGcsPtKsZ+UMyjFHkmepXv5jRlSJ06cMFlRNmYrcSQ9vte4cWNTamgHqIj9p7KqXr16JgPKGeBiudy4ceNMYOiSSy7Bs88+azKVmKm1Y8cO97wZBe24jcuXL0/3Gp87M798+e+///DBBx+Yxu9sps5+Vsw+YxZbXlBQSk4r3+PFzUyp/UHVcLJsYyAyddQ9ZUqJiIiIiIhILgWl2KOJpWNVq1Y1pWIsf2M5n6+gFPssbdu2zTQIz0sMAPXs2dM0HefoeJz4uGPHjqa07bzzzjPbyp5PDFwxiJSdoM0FF1yAY8eOmcbi3C9mJbGROTPF2DeLASIGrVjmyCbrBw8eNOWFdkYTRwPk59gLy+m6664z/aPY5Jwlgq+88orpk3XppZdmuk0sGXznnXdMUIyj+rHvVUxMjBnlLy8oKCVuyalBqcCAtL5ScYkpQGikNYOCUiIiIiIiIpILOGJdxYoVTYYUsZcUR5Vjrya7ObgnZgyxrO2mm27K83PAkfhq165tAjxsgs7sKAZriL2lGIjiiIEXXngh/vnnH/M3q8qUKWOykljCeP7555uRA1999VUzGh9H/+Pxueyyy0yfKZbkXXHFFe6MLGYy1a1b1wS2PLO0Bg0ahHvvvdeU/A0ePNhkpH3yyScm2JYZrpvBNu4fG8dz9EE2Ovfns9kR4PIshJTTMEWPXxRGPhnFLa6en74W8zcfxu1nN8Sfa/ej9vZJGNiuLhp3uxgYP8Sa6aYZQFDWa2VFREREREQkd3GUNmbCsCzLbtQtUhiuP3/jKMqUErfklLTyvYjgFAyMm46qaz9NH4RSXykRERERERERyQV5M6afFOmeUmx0HhXsGFEgOBzo9xwQEgGEpJbyiYiIiIiIiIjkgIJS4mYXcrKnVESQ9cSMGMlMqfoFO/qBiIiIiIiIiBQvKt+T08r3AlPL9ygpIJj1fDpKIiIiIiIihZRaRUtRve5KVFAqPj4ejz76KM4880wz/CS7z8vp5XuBgQEolZoplQxrFD7sWgKs+RE4tlOHTEREREREpBAICbH6/8bExBT0pkgJFJN63dnXYXaUqPK9l19+GatWrcLnn3+OPXv24KGHHkKNGjUwYMCAgt60whWUCgBKBaVmStlBqRXfATsXAmc/DJSrXZCbKSIiIiIiIuy0EhSEcuXK4cCBA+Z4REREmIGrRPI6Q4oBKV53vP54HWZXiQlK8YBNnDgRH330EVq2bGmmjRs34quvvlJQKpXpH8UftoAAhAdaAapE+xIJTW1wHh9dAGdPREREREREvKlWrZr5awemRPILA1L29ZddJSYotW7dOiQlJeGMM85wv9ahQwe8//77SElJQWBgiapkzDBTipF1V5kaeCvqbrStVQ43OYNSCQpKiYiIiIiIFBa8f6tevTqqVKmCxMTEgt4cKSFCQkJylCFV4oJSBw8eRPny5REaGup+rVKlSqbP1LFjx1ChQgWUdGmNzoHQUpHYFtwAFULKWW+GRll/E04V4BaKiIiIiIiINwwQ5EaQQCQ/lZj0oNjY2HQBKbKfJyQkFNBWFc5MqaDAAIQHWz9msYnJ1pvuTCkFpUREREREREQk50pMplRYWNhpwSf7eXh4eAFtVeGSmihl0j9LJx5Er/i/EH6M9aFtgTA7U0rleyIiIiIiIiKScyUmU6pq1ao4evSo6SvlLOljQKpMmTIFum2FRbIjU6r0qR24MHYKzjj2h/WmyvdEREREREREJBeVmKBU8+bNERwcjGXLlrlfW7JkCVq3bq0m545hHe3R98ICrbK9BFfqcKLV2gDnPgN0NG3PRURERERERERypMQEpUqVKoWLLroITz/9NFasWIEZM2bgk08+wfDhwwt60wpdo/OAADiCUqmN8kpXBRqcDVRtUZCbKCIiIiIiIiLFRInpKUWPPPKICUpde+21iIqKwogRI9CvX7+C3qxC11OK5XuhAdaTuJQgk0HFPlMiIiIiIiIiIrmlRAWlmC310ksvmUl8l+8FOsr3khCMuMQUlOLzbXOAxFig+fk6fCIiIiIiIiKSIyUqKCX+le8FBgDBriRTxpccEIRTCUkoFZIIzHzWmrFxPyA4VIdTRERERERERLKtxPSUEv/L9wIDAxCQkmQyppIRhFPxSUBIhNVsihKidThFREREREREJEeUKSVuKY7yPTY1n1glAVtOhaMNg1KBgUBIpBWQ4hRRQUdORERERERERLJNmVJyWlAqiEGpMtWxv0xb7AmqiZgEq78UQiOtvwmndNREREREREREJEcUlBK3lBTrr12lFxEWZP5GM1OKFJQSERERERERkVyioJS4Jdvle+x0vm8l2p2ah1rJO62eUs6gVPxJHTURERERERERyREFpcTN5Szf2zQTPfZ+hlaJqxATn1q+F1ba+qvyPRERERERERHJITU6F7fk1OH3mCiF5ETT8DzJFYRTCamZUm2GAU36A5Wa6qiJiIiIiIiISI4oKCVuqTEpq3wvJRFBAUByQFBa+V6NM3S0RERERERERCRXqHxPTivfY4aUyZQKDEAymCmVWr4nIiIiIiIiIpJLlCkl7oCUO1OK5XspSVb5HkIQa2dKndgLHFwLlCqvrCkRERERERERyRFlSomRmiTlKN9LQmAgkBQQhGg7KLVrETDjGWDFRB01EREREREREckRBaXESHZEpazyvQQzCh/L99yj74VGWn8TonXURERERERERCRHVL4nRoojKMVgFDpcj6M1+mHz3/GAPfpeWGnrb8IpHTURERERERERyRFlSomRkpJ2IBiTQrVWCG7YC8cCK6SNvhdWxvobd1xHTURERERERERyREEpOS1TypTvAYgMsxLpEpNdiE9KBsJTg1LxJ3XURERERERERCRHVL4np5fvsdH5trmISIxDGSThBKJwMi4JYXamVFIckJQABIfq6ImIiIiIiIhItihTSk4r32NMCgvfR8Cfo1A/+JB5jUEp0+g8IPWSiT+hIyciIiIiIiIi2aZMKUmXKcXKvQD+T4o14l6psFAgiUGpROvNsx8GgsPTRuITEREREREREckGBaXESHYHpax+UnZQKiw0DDiVmilFTfrriImIiIiIiIhIjql8T9JlSgWlxqSQYgWhIsKtvlEmU0pEREREREREJJcoU0oMu8+5PfIeXFamVERYuPl7IjY1U+rQJuD4DqBCA6B8PR09EREREREREckWZUqJkZziSh+UsntKpWZKnbAzpVZOAGY8A2yfryMnIiIiIiIiItmmoJSkK98LtK+I1KDPMlUQAAEAAElEQVRUpLt8LzVTKqyM9TfuuI6ciIiIiIiIiGSbyvfESElB+kypXg8CyYkIjakEYDei41ODUuGpQan4kzpyIiIiIiIiIpJtCkpJ+kbngalBqYa9zZ+oTYfM3xOxiekzpeKVKSUiIiIiIiIi2afyPUkXlAqwM6VSlSkV4lG+V9r6G3dCR05EREREREREsk2ZUuLR6Dy1lm/bHCAwGFERrczrJ+NTM6XCy1p/4xWUEhEREREREZHsU1BKjNSYFIKYKZWcAPzxpHleetgP5m90XBJSUlwIdJfvqaeUiIiIiIiIiGSfglLiMfpeAOCyRt6j0hGlUt8HTiUkoXSZ6kDPB4BS5XXkRERERERERERBKcnN8r3U/lEAQkNCER4SiLjEFNNXqnS50kDz83W4RURERERERCRH1OhcjNREKWv0vZS0TCkEBKB0uEezcxERERERERGRHFJQSoxk5+h7dlAqMDg1KGVVeUbbzc73Lgc2zQRij+roiYiIiIiIiEjh7Cn1z//Zuw84p+qs/+NnMr0wlKH3jiAiiFIEde2KCiiWdVFWXdsuuCqWBUGxd91dFUVszyrY+ypWLCsiFqQIAtKkdxiG6ZNkntf53dzkJpOZycBkZph83v9X/mk3uTc3cR/n6znnN3eufPPNN7J06VLZvXu3CT2aNWsmvXr1kmOPPVYGDBgQ7UNAFWZKmUHndvuehlI6V8oXSuUU+B7/5lGRPb+LnPmoSJv+nF8AAAAAAFB3Qql33nlHpk2bJnl5eTJ48GAZMmSINGrUSLxer+zZs0dWrFghN954o6SlpckVV1who0aNOqD95eTkyAMPPCBffvml2ccf/vAHueWWWyQz01otTvd52223yZw5c6Rx48Zy7bXXyogRI6rp0x78SkvDzJRyxZsru30vp9BXKZXcwLouzKmNQwUAAAAAAPVAVEKpiy++WNq2bSsPPfSQ9OnTp8Jtf/jhB3nttdfk7bfflpkzZ+73PqdMmSLr16+X6dOnm2qs22+/XSZPniyPPfaYeX7ixIlSWFho9rVo0SLzXKdOnSo9vljh8VrXLq2U0pX1jrtZm/mCKqX8M6VSGlrXRYRSAAAAAACgDoVSd9xxh3Tu3DmibbV9Ty+rV6/e7/3l5+fLJ598Iq+88or07t3bPKZVUqNHj5aioiLZtm2bqaCaPXu2Ccu6d+8uCxculJdffplQKqR9z6WlUskZIoec4T+/ZQadJ1vVZ1RKAQAAAACAOjXoXAMgDYKqokuXLvu9P5fLZVoFe/bsGfS4x+Mx7YNaGdWqVSsTSNn69+8vCxYs2O991jder6N9L0Smv1KqJLhSqnBvzR0gAAAAAACoV6ISSr3++uty/PHHmzY+vb13b3TDi5SUFDM0PSkpyf/Yiy++KD169JAmTZrIjh07pHnz5kGvycrKqnJwVp/5MimJ11RKZ0Wt/15k6xLzWGboTCna9wAAAAAAQF1s39NWul9//VU+/vhjefbZZ+Wuu+6SoUOHyllnnSUnnniiJCcnV/k9dR5UeSGSruanA9NtM2bMkI8++sjsWxUUFAQFVkrvFxcXV/k46nv7ns7jkux1Ih/dLNKwrcgfZ0pmasjqeyl2+x6VUgAAAAAAoI6tvterVy9zGT9+vCxZssQEVI8++qgZMK7B1JlnnmmCqvh4a4W3ymgL3pgxY8I+N3XqVDnppJPMbR2Wfvfdd5vB5vr+SkOw0ABK72uFFSyeCFbf87fvtewjcuxNVmgFAAAAAABQl0IpJx0+rpcbb7xRfvnlF/n888/lgQceMMHR3LlzI3qPgQMHyooVKyrc5rnnnpMHH3xQbr75Zvnzn//sf7xFixayc+fOoG31vlZYwVLqC6XitVLK61uKLy4+/Op7jdpZFwAAAAAAgLo0U6o8u3fvluXLl5vLli1bpEOHDtX23u+8844JpDTo+stf/hL0XN++fWXTpk2ydetW/2Pz5883j8PisXMoE0rZlVIJQZVSRW6vFLt9GwIAAAAAANTlSimdA/Xpp5+ay88//yzdunWTYcOGyZQpU6R169bVso/s7Gy588475eyzz5YzzjjDDDa36aDzdu3amVa+m266SSZNmmSqtT744AMzewrBM6XMoPOQ9r30pHjT1qfD0HXYedO0BJHNC6yZUp2P1+UPOY0AAAAAAKD2Q6n169f7gyidJ9WmTRsTFmkQ1bVr12rf37fffiv5+fmmWkovTrNnz5a2bduaKioNpM4//3zTtnfvvfdKnz59qv1YDvb2vXAzpbR6KjM1UbLzS0wLnwmlPrzB2qbNESKpjWvtuAEAAAAAwMEpKqHUKaecYoKf0047zQw2j3b4o4GXXiqSlZUl06ZNi+px1If2PZezfc83U8qeK6WhVE5BiYgrXSQpQ6Q4V6Qwh1AKAAAAAADUjVDqhRdeMIPJXbR1HXTtey4tlWraXeToa0TSm/qfb5Csc6UKAsPOUxpaoVRRTm0dMgAAAAAAOIhFJZQaPHiw/7a21b3xxhuyZs0aKS4uLrPtfffdF41DwP6GUnHhV9cLrMBXYj2QkimSs8maKwUAAAAAAFDXBp2PHz9eFixYIEcffbSkpKREe3c40EHn2r4Xhr0Cn79SKjnTutb2PQAAAAAAgLoWSn3//ffy/PPPS79+/aK9KxwAr2+mlA41l9wdIvs2W7OiGrU3j2emWj8VXX3P376nqJQCAAAAAAD7wSVR1rlzZyksLIz2bnCAPP72vTiR3/8n8v7fRX58zv98pq9SKsc5U0oxUwoAAAAAANTFSqn7779fxo0bJ2eddZa0bt26zPDzkSNHRvsQEIFSu33P5SibciWUmSllVt9Tnf8g0rijNRQdAAAAAACgroVSr7/+uqxbt05eeeUVSU5ODnpOW8UIpeoGj7N9z+sOE0qFzJRq2du6AAAAAAAA1MVQ6s0335RHH31Uhg0bFu1doToGnbucoVR8+avvAQAAAAAA1OVQqnHjxtK1a9do7wbV1L6nmVS4UCoztFKqOF9k+6/Wtu0Hcf4BAAAAAEDdCqWmTJkid955p4wdO1batm0r8fGBoEPpnCnUPo/XMei81GM9GOcIpXyr7+UVu8XrLRVXzmaRD2+wVugb827tHDQAAAAAADhoRT2Uuuqqq8z1pZdeas0rclTm6P1ly5ZF+xAQAV8mZYVSYQedW5VSWlC1r8gtDZ2r7+mDju8WAAAAAACg1kOp2bNnR3sXqMaZUqZ9r91RIklpIs16+p/XWVNpSfGSX+wxK/A1zMz0vdAjUpIvkpTO9wAAAAAAAGo3lPruu+9k8ODB5nabNm0ies3cuXPl6KOPjsbhoKqDzlv3sy4htFpKQykzV6pJmkhCsoi7SKQwh1AKAAAAAABUiUuitOLexRdfLLNmzZK8vLxytysoKJD33ntPLrzwQvMa1H77nrPFMlRm6Ap8yb5qqcK90T9AAAAAAABQr0SlUuqRRx6RefPmyVNPPSUTJkyQPn36SOfOnc1KfF6vV7Kzs2XFihWyfPly6du3r4wbN06GDBkSjUPB/gw6z9kiUrRPJL2pSFoT/zaZqdZcqRx7BT6dK5W3g1AKAAAAAADUnZlSgwYNMpc1a9bInDlz5NdffzVDzbUSJysrS4YPHy4PPfSQdOjQIVqHgCrQwfMqXmvnfn5RZMUskQFXivQbXX6lVEpmYNg5AAAAAABAXRp0rhVSekHd5vE62ve87jKr7zlX4DMzpVTvUSJdThRp3qtmDxYAAAAAABz0oh5K4eDgsSulgkKp+KBtGoRWSnUcWsNHCQAAAAAA6ouoDDrHwdy+V1EoFTJTCgAAAAAAYD9RKYWgQedm8b1Su5evkkqp/N0iu9eIJKSItOzNmQQAAAAAABGjUgqGL5MKqZQKnSll3c8t8lgPbPxJ5MMbRH56nrMIAAAAAADqXig1f/58+fvf/y4jRoyQLVu2yPTp0+XDDz+siV2jiu17LjNTyhM2lMpItu7nFflCq5SG1jWr7wEAAAAAgLoWSn366ady5ZVXSps2bWTt2rXidrslISFBJkyYIC+//HK0d48qtu9poZR0PUmk30UiTYJXTUzzhVK5/lAq07ou3Mt5BgAAAAAAdWum1BNPPCG33367nHXWWfLqq6+axy677DJp1qyZPPbYY/KnP/0p2oeAKrTvmUqpHqeF3SY9yZoxVVjiEa+3VFzJdiiVwzkGAAAAAAB1q1Jq3bp10rdv3zKP9+nTR7Zt2xbt3SNCXmf7XjnSkqwMUzfNL/EE2vfchSLuYs41AAAAAACoO6FU165d5Ztvvinz+DvvvGOeQ90Kpcyg85zNItnrRUoKg7ZJSnCZi3+uVFK6iMu3Qh8tfAAAAAAAoC61702cOFGuvvpqmTdvnpSUlMi0adNM9dSSJUvkqaeeivbuUcVQyhRKfXqryK5VIsMeFml3VNB2aUnxUuz2WqFUZoqItvAV7LGGnWc043wDAAAAAIC6EUodeeSR8tFHH/mHmmdnZ5t2vgcffFBat24d7d0jQh6vOFbf8w0yt6ugQlbgy84vkfxi3wp9A66wrtOyONcAAAAAAKDuhFJKh5pfe+21NbEr7KdSZ/teBaFUeugKfIecwTkHAAAAAAB1L5Q64YQTJC7M8Gx9LDEx0QRWp59+ulx44YXRPhRUwONbfs98VV5fFZQrodwV+Ez7HgAAAAAAQF0NpS666CJ54oknzLW27WlFjs6Teumll2TUqFHSvHlzM1sqNzdXrrjC1wqGGufLpCQ+qH0vodxKqTy7fS9ni8jejSLpTUWadKq5AwYAAAAAAAe1qIdS7777rtx1111yxhmBNq8TTzxRevToYYae6/M9e/aUyZMnE0rVgfY9lyvCUMqulFr6jsji10QO/6PIoL/W4BEDAAAAAICDmSvaO1i/fr0ccsghZR7v1q2brFmzxtzu2LGj7Nq1K9qHggp47FDKtO+5I2/fS25gXRfmcH4BAAAAAEDdCaW0Ze/xxx+X/Px8/2N6e+rUqdKnTx9z/+uvv5YOHTpE+1AQQfueWX3v0JEih50rkpJZZrs0f6WUr33P3qaIUAoAAAAAANSh9j1t3bv66qvlmGOOMRVR2ia2bt06adWqlTz22GMyZ84cuffee+Xf//53te3zjjvukFWrVpm5VbYNGzbIrbfeKgsXLpTWrVvLLbfcIkOHDq22fR7svL5UyoRSR11e7nYZvlAqv9iulCKUAgAAAAAAdTCUateunbz//vvy3XffyW+//Sbx8fGmdW/w4MFmBb5GjRqZSqkmTZpUy/5+/vlneeWVV+Soo47yP6ZB2NixY6V79+7y1ltvyeeffy7jxo2TWbNmmYAKWillhVLxpn+vfPZMqdyikFCK9j0AAAAAAFCXQimlQZRWJTkrk4qLi2XZsmVy+OGHV9t+9D1vu+020zLoNG/ePFMp9eqrr0paWpp06dLFhGQaUF1zzTXVtv/6EErFSam1op7Ok0rL0snnQdtlJIfMlPK37+2r4SMGAAAAAAAHs6iHUlq5ZLfTeb3eMmHVkiVLqm1f06dPN6v6aZvgDz/84H980aJF0qtXLxNI2fr3729a+WDx+L6aeHGLvPJH684lH4okZwSdorQku1LKEzzoXEMpDba0/Q8AAAAAAKC2B53ffffd0qZNG5k2bZqkpqaaoeeTJ082bXsPPvhgte1n9erVpm1v4sSJZZ7bsWOHNG/ePOixrKws2bp1a7Xtv75USiWUOoLDsKvvhcyUSm0sMvBqkaHXW6EUAAAAAABAXaiUWrlypTz00EOmZe7QQw+VxMREGT16tAmFnnnmGRk2bFhE71NYWCjbtm0L+1yzZs1M25624jVt2rTM8wUFBZKUlBT0mN7Xdj9YPL5B5/Fxvgqo8kIpR/uezuqKS0gW6XshpxEAAAAAANStUEqro7RNT3Xu3FlWrFghxx13nPTp00fWrl0b8ftoC96YMWPCPnfDDTeIx+ORCy64IOzzycnJkp2dHfSYBlIpKSlV+iwxMei81BlKWd9buEHnmmEVlnglNansNgAAAAAAALUeSg0aNEgeeeQR07LXr18/+b//+z85//zz5YsvvpDMTN+Q7AgMHDjQBFrhXHzxxWY21RFHHGHul5SUmJBK9/fhhx9KixYtzEwrp507d5Zp6Ytlbo8vlBJvIJAKMx8qOcElukCfhlLawmdCqd1rRPJ2imR1FUmrnlUUAQAAAABA/Rb1mVKTJk2SvXv3yqeffipnnHGGZGRkmKDqvvvuk7Fjx1bLPh5++GETPr377rvm8sc//lF69+5tbmvwpCv8LV261LQA2ubPn1+tK//Vl0opl3jKbd1TcXFx/mHn+cW+bb95RGTWTSJbf6mhowUAAAAAAAe7qFdKaZXSiy++6L//0ksvmaolrZLS+VLVtQ+nhg0bmta8Dh06mPsDBgyQVq1amSHof/vb3+TLL7+UxYsXm2AMIYPOKwml7LlSuUXuQCiV3NC6LsrhdAIAAAAAgLpRKdWzZ0/ZvXt3UKVNt27dxO12y4knnig1QWdaPfnkk2YVvnPOOUfef/99mTp1qrRu3bpG9n8wDTqXpDSRXiNEepxe7rapvkqpPHsFvuQG1nXRvugfKAAAAAAAqBeiUimlbXNvv/22ua0rtGmbXmhV1Pbt282qedGgq/CF0qqpGTNmRGV/9SmUcqVliRwzvsJt033DzQv8lVK+UKqQSikAAAAAAFCLodTJJ58sGzduNLd/+OEH6du3r6Snpwdtk5aWZrZD7dPg0C6Uitcp5pWwZ0rlFfkqpVLs9j0qpQAAAAAAQC2GUhpAjRs3ztxu06aNGXCelJQUjV2hGvjGSRnxpW6RgjyR+CSRpOAg0ZZmV0qVhFRKFe3l+wAAAAAAALXbvuecITVr1qxytx05cmQ0DgFV4LbLpPQHsWuZyEfjRRq1F7ngpbDbpyVboVReEe17AAAAAACgDoVSjz32WETbaWBFKFV3Vt5TLm/lq++lJVqhVL496Lxpd5FBfxXJbBPlIwUAAAAAAPVFVEKpL774Ihpvi2ivvKdZVGkEoVSyPVPKt22jdiKN/sj3AwAAAAAAajeUCqUr7c2cOVNWr14tHo9HOnfuLOedd5507NixJnaPSngclVLxEkEolRRSKQUAAAAAAFBFLomyn376SU499VT5/vvvpW3btuby448/yogRI2T+/PnR3j0i4HVUSsXpoHPlsoKncNJ9q+/lF/sCLK9XZPtykQ0/iHgIqgAAAAAAQB2olLr//vvloosukhtuuCHo8YcfflgeeughefXVV6N9CIiwfc8VJxLnjbxSKs+ulIqLE3n3ryKlXpGL3hJJb8o5BwAAAAAAtVsptXLlShk1alSZx88991xZtmxZtHePKrTvxWsqFUEole6bKVVgV0ppKJWSad0u3Ms5BwAAAAAAtR9KtWnTRhYvXlzm8UWLFknTplTU1AXafecPpRq0FOl2ikib/uVun+qvlPKFUiq5gXVdtC+6BwsAAAAAAOqFqLfvXX755TJlyhRZs2aN9OnTxx9IvfTSSzJ+/Pho7x5VqJRyacVTqz7WpQLp9kypIsf8qOSGIrJBpCiHcw4AAAAAAGonlCopKZHExERz+5xzzjHXM2bMkBdeeEGSk5OlU6dOcs8998jpp58ejd2jijweR/teBNKSrUqpIrfXzKMyr6NSCgAAAAAA1HYoNWTIEDnttNPkzDPPlAEDBphgyg6nUPd4nTOlPCXWXKn4xHJX4EtLDDyeX+yWBimJjplSVEoBAAAAAIBamik1efJk2blzp2ndO+644+SBBx5gqPnB0r73yxsiz58q8r+Hyt0+Id4lSQnWTyffniuV7AulaN8DAAAAAAC1VSk1fPhwc8nNzZXPP/9cPv74Yzn//POlXbt2csYZZ8hZZ50l7du3j8ausR+8Xufqe745UeVUSdnSkuKl2O2VPHuuVIfBIulNRVocyncAAAAAAABqd9B5RkaGjBw50lw0oPrss89MQPX0009Ljx49TDg1ZsyYaB4CIuD2Oiql/KFUQqWhVHZ+SaBSSlfrq2DFPgAAAAAAgKi375UXUJ199tkmkJo+fbq43W657777amr3qIAOK1fx+mvQeVIRhFLp9gp8digFAAAAAABQVyqlbKWlpfLjjz/Kp59+atr58vPz5aSTTpKbbrqpJnaPSvhGSoW07yVEtAKfDjo33EUie34XKSkQad2Xcw4AAAAAAGonlNJKqLlz55qWvdmzZ5sgSoee6xD0Y489VpKSkqK1axzIoPOI2/dCKqWyN4i8faVIamORMe/yHQAAAAAAgJoPpbQC6uuvvzZB1ODBg+Xmm2+Wk08+WdLT06OxOxwgj9e7X4POlX/QeVoT67ow22oBrOT1AAAAAAAgtkUllNq8ebNcd911ctppp0mTJr6wAnWWx8qkJF4rpbK6iXQ6VqRRhwpfk+6rlCoo8VVKpTQSiXOJlHpFCrJF0rOifdgAAAAAAOAgFpVQaubMmdF4W0R50LlLK6V6nmldKpHqr5SyB6O7RFIbieTvFinYTSgFAAAAAADqxup7qLu8vplSplIqQum+QecF9qBzleqritNgCgAAAAAAoAKEUgiulNJ5UPZyfBVITbSK7PLsQecqzdeyp5VSAAAAAAAAFSCUgn/1vXj9Ncy6UeSZ40VWfxFRpVR+UKVUY+uaSikAAAAAAFAbM6VwcHF7rFAqQedCuYutSilXYoSr7zkqpbocL9Kks0irw6N7wAAAAAAA4KBHKAUp8S2/l5TgEikoss5IfFKFZybNt/pevrN9r/0g6wIAAAAAAFAJ2vfgD6USdKaUp9g6IwkVh1Lp/lDK0b4HAAAAAAAQIUIpSImvfS8x3te+p+KTKzwzab6ZUjrovNQejK6v3fGbyIYfOasAAAAAAKBCtO8huH3PE2n7nhVKeb2lUuzxSnJCvEj+LpG3r7Bee9knupwfZxcAAAAAAIRFagBxO9v37EqphIorpVIS4iUuzrqdbw87T28q5kFtASzM5swCAAAAAIByEUpBip3te22PFGl7lEhSeoVnxuWKk9REq1oqv8QXSsUniqQ1tW7nbuPMAgAAAACActG+B3/7XmJ8nMjJd0R8RrSFT1ffyy9yDDvPaCGSt8MKpZr35OwCAAAAAICwqJSCv33PVEpVQVpygn/YuV9Gc+t6H5VSAAAAAAAgBkIpXQHusccek6OPPloGDBggt956qxQV+YZ2i8iGDRvkkksukb59+8qwYcNkzpw5tXq8dUlhiRVKpfqGl0eqgS+U2ldY4niwpXVN+x4AAAAAAIiFUOqZZ56Rl19+WR555BF59tlnZd68efLEE0/4A6uxY8dK06ZN5a233pIRI0bIuHHjZPPmzbV92HWCtuCpTE+2yDMnivznrIhe1zA10VzvLSgpWylFKAUAAAAAAOr7TCmPxyMvvPCC/OMf/5DBgwebx6655hp59913zW0NqLRS6tVXX5W0tDTp0qWLfPfddyag0u1iXUGJNRMqI65QxOsWiYssq2yUlmSu9+Q7QqlWfUUG/U0kq2t0DhYAAAAAANQL9SKUWrlypezZs0dOOukk/2PDhw83F7Vo0SLp1auXCaRs/fv3l4ULF9bK8dbVSqn0uALrgaSMqlVK5RcHHmzSyboAAAAAAADU9/a9jRs3SsOGDeXnn3+WkSNHynHHHSf33HOPFBdbYcmOHTukeXNfW5lPVlaWbN26tZaOuG6GUqmlhVUKpRqnJZatlAIAAAAAAKhPlVKFhYWybVv4Fd327dtnntd5UhMnThSv1ytTpkwx1zrwvKCgQJKSrFYzm963Q6tYl+2rdMqUPOuB5AgrpdLCzJQyb7hBZPdqkaY9RDJbVfPRAgAAAACA+uCgCaW0BW/MmDFhn3v00UdNKDV58mSz8p6aMGGCjB8/XiZNmiTJycmSnZ0d9BoNpFJSUiTWFRR7/KvvNdBB5yo9uKqsPI19M6XsUMtv3pMi6+aKDL1O5NCzq/mIAQAAAABAfXDQhFIDBw6UFStWhH3uhx9+MNedO3f2P9apUycpKiqS3bt3S4sWLWTVqlVBr9m5c2eZlr5YtDXHatlLT46XpIId1oPpWVWaKZUd2r7XqL0VSmnFFAAAAAAAQH2dKaVDzBMTE2X58uX+x1avXi3p6enSqFEjOfzww2Xp0qWmmso2f/5883isW78731y3bZwm0rijSKvDRbK6ValSqsjtNRVXfg3bWdd7CaUAAAAAAEA9DqUyMjLk/PPPl7vuususqLdgwQJ5+OGH5bzzzpOEhATT0teqVSszb0pX6ps+fbosXrxYzj33XIl1SzbtNdc9WjQQOexckeGPiXQ+LqLXpibFmwortWNfUXCllNq9NgpHDAAAAAAA6oN6EUrZM6SOPfZYufLKK83lmGOOkRtuuME8Fx8fL08++aRZhe+cc86R999/X6ZOnSqtW7eWWOb1lsr8dXvM7T5tG+7XezRvYM3l2rYvUIUmWV2t67wdIgXW+wMAAAAAAByUM6Uqo6vp6VBzvYTToUMHmTFjRo0fV1323ZpdpsKpWWKRHLH1DZG2Y0SS0qr0Hi0yk2XtzjzZ5ptNZeh7NGwrsnejyM5VIu2Oqv6DBwAAAAAAB7V6UymFqtmdVyxP/2+NZHj3yWTX85L4yysin06u8mlskWlVSm3PcbTvqabdretdK/lqAAAAAABA/a2UQuS27C2Qu95bKL12fyUjvJ9Lx2S3SGqmyOCxVT6NzRokm+vtzplS6tCRIp3/INKiN18NAAAAAAAog1AqxmZIzf76C9nz01tyVdEv0tBVKK0bpYgrq4vIiVNEmnTa70qpoPY9pav4AQAAAAAAlINQKobMX79Hvv15sYwu/N6snNe8ZTtJ6n+RyCFniiQk7dd7tmmUaq437sk3oZfLFVfNRw0AAAAAAOojQqkYclibhrK+3yDx5pVK635/EFfrviKuAxsr1qphisS74qSwxCs7cov8lVPGjhUi6+eJtOwt0qb/gX8AAAAAAABQbxBKxZCUxHgZdcJgEdFL9UiId0mbxqmyfle+rN+dHxxKrfpcZPHrIj3PIpQCAAAAAABBWH0PB6xDkzRzrcFU2LlSmxdwlgEAAAAAQBBCKRywjlnp5nr1jtzgJ1ppe2C8yN6NItkbONMAAAAAAMCPUAoH7JBWDcz1si05wU8kZ1jBlNLZUgAAAAAAAD6EUjhg3Zo3EF10b2dusezMLQp+sr1vftW6OZxpAAAAAADgRyiFA5aaFC+dmlotfMu37At+suNQ63rLIpHc7ZxtAAAAAABgEEqhWhzSKtNcL9m8N/iJzFbWwPPkBiJ71nG2AQAAAACAQSiFatGvXSNz/dPvu6W0tDT4yRMmi1z0tki7ozjbAAAAAADAIJRCtTi8XSNJjI+TbTlFsn53fvCTGc1F4hM50wAAAAAAwI9QCtUiJTFe+rS1qqW+X7M7/EZer8imnznjAAAAAACAUArV5+guWeb6yxXby7bwedwib10m8sH1IluXcNoBAAAAAIhxVEqh2gzt1lSSElyycU+BLN8asgpffIJI817W7e+esKqmAAAAAABAzCKUQrVJS0qQIb5qqY9+2VJ2gyP/IpKYJrJ9mchvH3PmAQAAAACIYYRSqFZnHd7aXH/92w7Zurcw+Mn0LJEjxgSqpXLCBFcAAAAAACAmEEqhWnVr0UCOaN9IvKUib/y0oewGfc4XadFbpDhPZPYdIu4ivgEAAAAAAGIQoRSq3QVHtTfXny/bJqt35Ib84uJFTpgsktzAauOb+zjfAAAAAAAAMYhQCtWuV+tMOaZbU1Mt9eSXq8WjN5wyW4mceo9I0+4i/S7mGwAAAAAAIAYRSiEq/jK0k6Qmxstv2/bJy9+vK7tBq8NFzn5apEGLwGPa0gcAAAAAAGICoRSiIisjWcad0NXcfv2njTJn5c4wvz7Hz2/FxyKvXSSy/nu+EQAAAAAAYgChFKLm2O7N5Mw+rczthz9dIT/9vjv8hl6vyK/viuTvFvnoZpFPbxXZu4lvBgAAAACAeoxQClF1xTGdzXwpnSt114fL5NOlW8P8Cl0iZ/7LWpkvziWy9n9W1dSX94rsXss3BAAAAABAPUQohej+wFxxMv7k7nJs96bi9ZbK41+skn99/pvkFbmDN0xMERk8VmTUsyLtBoqUekV++0TkjUtEFszkWwIAAAAAoJ4hlELUJcS75MZTesiFA9pLXJzI7GXbZezLP8sXy7eZoCpIVheRYQ9aQ9A7HWNVTrU5IvD89uUiyz4QydvFNwcAAAAAwEEsobYPALEhLi5O/jSwvRzerqH887OVsi2n0Fy//fMmGdm3jZk/lZTgyEibHyJyyt3WnKnUxoHHl38gsuy/1u1G7URa97MuLQ8XSc+q+Q8GAAAAAAD2S1xpaWlIqQpC5ebmSv/+/WX+/PmSkZHBCTpARW6PfLBoi7z+0wbJL/aYxxqmJprZUxpOHdKygQmxwlryttXWt3OFSOhPN72ZyAUzrFZA5S4SSUjm+wIAAAAAoA7mKFRKocYlJ8TLqP5t5ZRDW8gnS7fJB4s3y67cYvlg8RZzycpIkiPaNzYXraxqkJIYeHHvc6xLYY7IlkUiWxaKbF5gDUSPTwwEUmrWTSLZ60QadxJp3FGkSWfrWi8pmXzzAAAAAADUIiqlIkClVHS5PV5ZuCFb/vfbDpm3ZrcUlFjVU8oVJ9I+K91UT3Vv0cBct2mUagaoBynOF8nfKdKofeCxF0eKFOwJv9Om3UVGPRO4v3G+SHKGSGYb6xoAAAAAAOwXKqVwUA1CP7JjE3PR1r4lm/bKgvXZ5rJ+d778vjPPXD5estVsn5oULx2z0qRj03TplJVurjtkpUmaM5BSF74ismedyJ7fRfastaqp9Dp3e9ng6ct7RPJ9w9NTG4lkthVp0EIko6VIVmeRrifV1OkAAAAAACAm1Jv2vb1798pdd90l//vf/yQ5OVlGjhwp119/vbhc1vDsDRs2yK233ioLFy6U1q1byy233CJDhw6t7cNGmNa+/h2amIvanVcsy7fkyIpt+2TF1n2ycnuuFBR7ZNmWfebi1KxBsqmiatM41Vy3bpQqbRt3lGbdegRXVhXnWReb1yOS2Vqk1GtVVhVkW5dtS6znW/cNDqVe/7OIK0Eko4UvuGohktZUJK2JSINWIpmt+F4BAAAAAIiVUOqOO+6QnTt3ysyZM2XXrl1y4403SlZWllxyySWis9zHjh0r3bt3l7feeks+//xzGTdunMyaNcsEVKi7mqQnydFdm5qL3eq3cU+B/L7Lqp76fVe+ua0zqXbsKzIXbQV0SoyPk1YNNaRKkRaZKdKyYYo0b5AiLYvypXlmsqQkxouMeCLQBpizWSRno8i+bSK5W62WPpu72Kq8UrtWlT3gNkeInPnPwP1PJlnD1k1olWWtEJjS2KrG0hDLubIgAAAAAAAxpN6EUl9//bU8/PDD0q1bN3M588wz5bvvvjOh1Lx580yl1KuvvippaWnSpUsX85wGVNdcc01tHzqq2Oqn7Xp6kR6Bx/cVlphWv83ZhbJpT75s3qvXBbJ5b4GUeErNc3oJR1f+a94gWVqYsCpZWmamS/PMPtK0bbJkZSRLelK8+OustELqvBcCgZVe6yyrvJ3WtTPA8pSI/D6n/A/T9kiRMx4JHswen2QFVim+i7nd0FpZsEknfisAAAAAgHqj3oRSjRo1kvfff18GDRokOTk58s0338jJJ59snlu0aJH06tXLBFI2XZpQW/lQP+gKfYe2bmguTl5vqezILTLVVVv2FsjWvYWyfV+RbMspNJe8Io/sLSgxF20NDCc5wWVWBGyaYYVUTTOSJCu9ozTN6C5ZzazHM1MSyw5fVyfeZs2qMqHVLiu40tbAwmyRVKtF0fC4RTb8UP4HbDdQZNiDgfszRonEuUSSG4gkZVjX9m1dZfCQYYFtt/4i4koUSUoTSbQvqSJxYY4XAAAAAIAaUm9CqSlTpsjNN98sRxxxhHi9Xjn66KNNi57asWOHNG/ePGh7be3butUanI36S4MibdnTi0jZVrncIrdszymUrTmFpvXPGVppS6A+X+T2mgosvVS0H624apymlyRzu5G5fYi5btQ4yTzXKDVJGqQkWAFWaWnwm5x8pxVW2aGVfV2YI9KwbfAMLA25zAfYXvZg2g0IDqVm3SxSElIlpoFUQqpI634ip90bePyrB0S87kCAlZBiXRJTrGqtDkcHtt212grG7Of1Oj5ZT0YF3wgAAAAAAAdZKFVYWCjbtm0L+1yzZs1k7dq10rt3bxNEaQilM6aeeeYZ+etf/yoFBQWSlJQU9Bq9X1xcXENHj7oqIzlBMpplSOdmIavx+RSWeMywdQ2oduYWmcsuc7/IeiyvWLLzi01F1p68YnMRcQxRD0PzqMzUROuSkmCqrDSoapDSQRqkdJEG+nhjvW89bj8fiHriRP44U6QoV6Ron0hRjkixfTtXpKGjhVCDr4zmVihVUmANeNeB7vq4PuYtCT64NV+VDbBsLXoHh1If/UMkb0fZ7XSGVrMeIsMfDzz2xd0ihXt9IVey1aaoF3veVp/zAtv+/q2Iu8AKuOxt7O21wsv5+bxeQjAAAAAAOEgdNKGUtuCNGTMm7HM33XSTPProo/LVV1/5K6I0iLr99tvliiuuMKvxZWcHD7/WQColRatngPLpEHRdxU8v5dHh69kFJSacys4vkT351m1tCdRAS5/bax4vln2FbvGWitlOL1WRnhxvgioN0tKS4n3XjSQ9OUvSkhLM8+mZCZKutzdmm8fMNsOfNY/F29VZ7iJfSJUvEhcfvJPBf7OCK31Oh767C63t9bphu+BttV3Qo8/5Lv4TUmS1IzptWRS+qks17hgcSv0wPTBMPpSudDj69cD99/4msmOFr0orMRBg6bUOkXfO7Pr5JWuIvW5nh1z2ba306j0qsO22pVbAF58QCMfs99dWyPSmtD8CAAAAQKyEUgMHDpQVK1aEfU5X0WvcuHFQi57OkMrLy5O9e/dKixYtZNWq4JXSdKW+0JY+YH+Hr+tcKb1URgMsDas0qMopKDEhVU6hdb3Pf+02z+X4niso9pjX6vwrveyvlESXpCcnSGpivLmkJFnXqYk5kuq7nZJ4uAm8UlJckpqZICkJLhNupSa5TECXmltktk1JiBeXDnx3ViyZgKpQpCRMm+OQ66xqLq3W0gHwup2n2LroIHen5r2slQl1pUM79NLX6G0d/B50Qousyi8TsoXsU4Mjp/XzRLYtCX9ytFXRGUr99ILIxh/Db6sti1d8Ebj/2RTrvZ2hmD/wSrZWY0zwVWoufccK0YKCMce2vYZb76F2rrJmkGkIlhASoum2upojrZIAAAAADmIHTShVEQ2X9uzZI7t27TKzotSaNWvMYPMmTZrI4YcfLtOnTzctgHZ11Pz5882wc6CmAywdlq6XSGmQpbOtcgqskCq/2CN5xW7JK3JLvgZVxW7rsSLrsbxij+QXuyW3yCP5vplYqrDEK4Ul1deyqgPgTUDlC7n0fnKiywRW1nWuec663d5cm22S4yUl3X7cd51dYD2X4JKUY26SxPgI51INfyxQqaUBl32tl8CaiZbeZ1vth+Z5Dbl8oZfe1lUVnXSGl7ZF+gMxe1u3VSHlHBJvqsl8F22hDOV8780LrRbJ8phZYL7fxpK3RFbMKn/bi94WSbf+907mPiGy7L/BYZcGWSbQShY56XarjVOtmi2y4fswoZivwqzbyVaVmcpeL7J3U0gg5thWt9P7AAAAABCroVTfvn2lS5cuZtD5hAkTTED14IMPykUXXSRxcXEyYMAAadWqlUycOFH+9re/yZdffimLFy+W++67r7YPHYgoyGqUlmQu+0NDLQ2qTIhV7JaCYq+5LnR7pUCvS/S+x8zPKtBLse+6xCOFjtsFvm20/VBp2GUFXlVrQ4yEDoI3AZVWb5mwy77W4EqDsMC1Cb5MoJUkyQkpZpukeCvsSt6YLUnmuXhJbjpEklr6grGEeEmMjzP/+xDW0OsiP9g/TLQqtTTA0iHx/mCsxJrZ5axm6naKNW/Lft68Rq99QZpWQNkatBBpdkggOLPDNt1WX+MMg5zBWDjOofo7lov89kn5n6ftUYFQatXnIvP/U/62Zz8t0vwQ6/ai10R+ei648svf/pgoMnS8SLPu1rYbf7KOwV8B5nxNokin40QyW1nb7ttqDdU3VWihFWZJVvWcXV0GAAAA4KBSL0KphIQEM9T8nnvukdGjR5sKqREjRvhX34uPj5cnn3xSJk2aJOecc4506NBBpk6dKq1bt67tQwdqJNRqmKqXA69oKS0tlWKP1xdQWeGWCa9KNKDySJF97daqrMC1/bxzOw3FivQ5e1tH4KWD40045mtdjAbNo+yAygqurIs/xHLetqu8gh63wrKkeL1OleSEdOuxpJDXekut1RZVxyHayxjZAfa/xLpEYuBVIn1HO6rAQoIsZ9ujVoulNgk859wutJ1StzPBWHH47csEYyHzxZxM9ZrP7rUiKz8t//M06RIIpbSN8n8Pl7+trlrZ+bhAFdhX95et7LLbKvtfKtJ+oLWttlH+8mb4bbXCTFexzOpibZu/W2T7spBtHbf1nOmKlQAAAABiL5RSLVu2lMcfd6z2FUKDqBkzZtToMQH1jVYWWcFMyID0alLiCYRZ5uILtAr9QZYVXlnPBYIu+zUamNnPF9vv4Q7e3g6+tHjIeq3V3hhNCfFxYQIwx20NvUy4ZVd9BcIwK/Sq4LUmAEuR5LT0iqu/bK37WZdIHDrSukTisPNEup8aXM3lbH9s1D6wbas+IoP+Gmi59FeY+bZ1zgNLzhRp3jM4FHNu66ySCmrfDKPEsTKmDr2vKBjToMkOpXauFPnklvK3PfoakcPOtW5vWSzywfVhWh4TrbBLt+txeuAY5j3lCLm0sszXdqnbtzki8F1pa6iuTGm/l3M7va0zxjKaBWa86Qw3/3bR+ecVAAAAOFD1JpQCcPDTWVJ6aRDFfWg7ox16WcGVM8Syq70cYZYjILNCrwpe6wi/SjyBljm3p1TcngMbVB8JLcgKrfQyl3jHbX3eed/ctrZP9N13Vo3p92EHYM7X2MGYWdVRaaVQpNVC2sKol0hoFZRdCVWZLsdbQY6/miukaqypr31QaeA06G/B88LMte91OlfMpqsz6gD+oGqxcoIx07bpti7hOlsLcwK3C/aIrP1f+Z9HwyQ7lNLVK7+qoOX88AtFBl3t23abyCt/DB7O7w+oEkQOOUNkwBWB4/l4YvgATe+3Olyk+ymBz/bLG8FhmHN7XR2zaddA6quraNqBm34Ws12Cta3eryxABQAAQL1HKAUg5toZ9ZIe5TFE2oJoQixfYOWv3CoJrujyB2Al5Vd6BW6HD8D8bY81WP0VNP+rTMjliiDkine8xqrACxui+V7vvK/fX1iJqdYlElq55azeqogGM2c/Fdm2LQ8TGf2GI7zyBVdaOWbCrnaBbTNaWvPLTCDmC7w0zLJf26xnYFsNvrSl0DwXZvuUzMC2oZViukKls7XS2WKpt8tblVJpbmSHUrp65vdPl79t1xNFTrzNuu31iLxRQftphyEip90buD/zfCukMqFVgiMYS7ACQa2ss2k7p76/P+iyg7EEkQatRHqcFthWWzr18zvf09xOEEnKCFTDqbydVoAXdAwJhGcAAABRRCgFAFEKa1Jc1uqEItFboU7nfLk1AAsTYoVWc2n1lv28uXgC4ZfzftnntUpM92G91lkFZuZ/ea1h+DVFi7PsEEtbFq3AKl4SXdZtu+IuMcEKzDTE0scTfAP0A89bgZj/vtkuzgzK15ZLOwSzngu8tz7mnxMWSoe32ysdVkZXTzz07Mi21cqtYQ9Ftq2GbZfPDg7DnNVjzgAruYHIKXeFD9D0kuWrfFIaAmnrYbmBm6O6TMMy3Y8GaPbzThoK2bSqSqu7ypMQEjTqAH4NyMLR1lBnKDX3casiLRytnBv1TOD+e+NE9m0pu50GU407ipz7XOCxjyaI7NvsCLnsKrAEq5Xy+ImBbX9+UWTfNuszu5yXeJHEdJHDLwhsu26udbz28/7KMl+Q1saxanDOFmuWW+h72rc1oKUaDQAA1HGEUgBwENMZUhqYJNZA9VdoFZjOAPMHWpWFXJ5AGGbP/wq6b8IuZ4WYtU2JLxQLCsJKxb8qZG2xWyWdgZYGXibM8gVhVgAWCL2SQu/bYZn/sThJcDnvW0GaudbHfM/Z+9DWSXs7PR7/PDG9NvOpIvg/8dqa2OnYyD50UrrIHyZEtq2+75//Gxw8aXWTHVCFhiWjngs8Z7c/2redw/fVUZcHVq402zjeN7NN8Lba/liUE3gve1VMvdYVLp20SkqPy7lapdLXlYb81nI2imRvCP/ZtVrLae03Ijt/C7+tLkLgDKUWvWLNJQsnIUXkL46VM+f8U2TD91KuK78K3J59lxV4OUMrZ4ilK2nqd6YWzBTZND980KUXnaFmt+pq+6kuGmAqzLQl07mtS6T7adbvRu34TWTvet82zm1993VRBbvSURcXKNzr2M5xrRetcrNnpdnfFwEcAAAHJUIpAMB+V4FFc/5XaBBW4i0bgNkhlgZaGlzZwZa59gVnJe5AiGZv5wzBtNIs8B6Bx53b6cVuk6ytVsmK6N/jGmCZqjBfiBUItFymiswKtFwhgZYzCPNt73yd43n7dc7gTbc1j/mvA/u278f77pvbCSkSF9piqQdvz6KKhD1UPhInTYl82wtfDgyK9wdeeu0uu+0Jt4qU5AdXgnl9AZnO0HLSari8Hb6wzRMI3fQSei5a9Laqp8zzJcGviQ9JnTUY0mq0oPf0hWehM7u0okqPtzwaKtl2r7FCqfI4Wyk1FFv2QfnbdjwmEErpwgI6k6w8F7wUaKld+rbIzy+Vv+05z4g0882IWzhT5IdnAgGXM7zS26fcLdKil+8YPhNZ+HIgaAvdVgPP5odY2276WWTFLOtxE7ppaOkK3NfZbHb7567VVkBnnve1gPpvu0TaHhX4bDofbvPCQAhq79sO9pp0DlRb6gIHe9b5trH3HRfYNqVRoPJRf4O6vTMg9B+DfZs5bgCAuodQCgBQ55nZVa7orfwYCY+vTdIOx3SAvR2QBQdagXDM7bVDs9KwgZc+bwdjdmCmw/gD973Wfu3H9X281rWTFotY+/BIgdReBVmk36UzzAofboV7PBB4Oe+Hvs48bt/3hWr+50IDM8frXHHWbR1Zprf1eZcrWeJdKRIfFyeu3CJrO90ms4vZ1tpOV710VKqFOmRY5Cdn4FWRb3vS7WUfMxVpvoDK6ZgbrDApXDBmAq/E4BCt3cCQbRyv0Yotm7YTanul/ZzO79JttbJMr53bNmxjLURg3suxjX3tDN30tlaRhW5rfy5niKb7VOE+t/N5VZBthW4VLRhg27vRCrHKo1V4zlBq/v+Vv+0JkwOh1I7lIl/eU/62x94o0vMs6/b25SKzbix/28HjRPqcF3hfbUEtjwZuR1wcON73xgZCLmfopbf1N3C4b7GEfVutxRDsgCvoEmctMNF7VOD8ms8WF7yNfVt/L72GW9uWFIp8+2/f845t9LV6DE17BObZaVD803Ph96/HrK3DnY4JfNZf3/PdcB6H76Jt08422HXfWb8R5zHYx6HtzXb4aa/Eage//pDPd/w698/Zwqzttfq7td/Lfn/786U1CWyrYaL5nYZsZ992Lqah58Ls3/c8ANQDhFIAAERAQ4jUpHhJldoLxkJniZmVHb2BMKvEPBYIwTwhYZfzeX2dCdZ8YZdHA7KQUMyEYL77+rjzeX2dx7yP9Vr7eHSf+t567awuC2r/DPfEQc6EVaZiTcMs6/diB13O0MvazveY77a5dvlea7az3y8QtDkfs8M03VZbN/Vx87o4KyCz92U6Of3bxYsrLsGEZ/pe5to8Hieu1bsC7+FqLXEpbcq8n/lMen93sbjiiq33bTxIXFmDrWOw38u3T/1/+qe1q8htPd5juLgOGeF/z3JDPKXhiR2ghIZuenG+9rDzRQ45M3zQpRcNw2zaqqqVSHZLZui2OjvM1uJQK/Sxt3UGbnoMzgCiUTuRXiOsbeyLf1uvSIOWgW21uqntkY5tvL7P5bud2jiwrYaF2pLqP1b7/X3HoDPs/OemkqpNZ5BnVgctZy6bKs4N3NZW2YqCPG27dG674Yfyt9WQx6bz6LQSrTzdTnGEUm6RBTPK31YDKWcoNedf5Z8PrVpzhlKz7yy/irBlb5ERUwP3P7rZai0Np2k3kVHPBu5/OF4kZ3P4bfW388eZgfvv/738c5zeTOSiNwP3NUzc/mvZ71WvtWru4ncCz318i8iWRYF/XpxBmgZdf3otsO3XD1rVgc6gzfmac18ItMx+P11k4w/B4ZkdAKozHg5UgS58RWTDvODtzPv6buviGHa136/vi6z7tpxtRWToeCtUVBoY//5N+dsOuCrQov37HN9KtyHb2tv3HR3434mN80XWfBlyHhzb9z4nEDBvXSKy5quy58zevvupIk06Wbd3rgrzvo5tdZVh/d8mpdWRpvIyzPlSuuiJHYhr+Ln2a8cPJuQ8aHiuv02Vu8M6Xifn/5Zqpa5dKaq/cz3e4I0DN3UFZf3fSHsV39Wzyz+GJl2sf5ZUcb41F7K8Y2jUwZoNqdzFIqtC/8OAY9vM1iKt+wbC2pWO9vbQ71irT+3VjO3fj7NV33kMGhg7/zdi9ZchLfxxIf977thWf2vOxWSckjNF2h0VuK8t9eX973BSukj7QRJLCKUAADhoZ4npvdoPycqjAZQVWgWCqsD9Ul+oFXjcDtmc29nhWtDrfEFc4H18oZi9jS9kC36N4739YVqpeEpLzXFaIVrgcb1trnXxQn2dFiFVEKbpc/pnsFaroXL2HDR/iGUHbL5AzdrGEYr5/86xbpvQS/9elsA2/muzoX37N3+opg+64pIkLi7JH6JZ7+nb9rdt4nJtN6+39nNY0Htaj/mObYFbXK5VvuPU9xzhDwjNYwm+8E1vr42TuLW/+17fSOKaXev/DNYBWNvp83G7tJJpoy+4aypxhzwU9PeS2cb+G8otErd4i28/zSXu6Fc0nZK4Uq/ESam4Sj3iEq/ElZZKaXySlC7bZn0WT7okDnhcXKVe3/O+i3jNY+6UJuJetdP6HJ54Se87ReLEY95Hwx6X7sNcvFKS3kqK1mlQEycuj0cye//dPKfb2cdhX5dktpeCTXutc+oukoY9Lra2s7fXbU0lUKkUN+gs+Vv3WZ/T65bGHc/0v6f1x6R92yvFaV0ld9s+/3eZ1WKQP+zTY3TeLk7tKDk7rNBN3zors6u4tL3VH/hZn03/CC1JaCrZO/P82zZNaCKuZJdjG+s49NotabJnVyDcyvImSXycVeEUOGYrPPS442TXbse2xSWS4AkfonndHtmVHfjDtXGZbQO3vXFFssPxvo1zcySpIEePtIxSV6Js25XnP6wmu7dJ8p5NUp5NO/Ok1Bc6Ndm6TlK3rih3243b9klpolW12HjTSslY/3Pwvh1HtGHLHvH4CiqbrFsmmas1lApvXceLxZ1h/enaZM0SabzyC8d7Blvf8iwpyrTOf5OVv0hWuADU96J1DY+RgibWnLzGqxZJ86Xvln8MyX0kt2mG+Q9DTdYtkFZLXgl/ADpyz9Ne9jZvYD5v440/S4dfgqspSx2vW7MvU3a3SjffR6OtC6Tb4mm+bcq+8eqef5NtrdLMM412/Sy9Fj5W7vGu7HqZbG6bZt43M/tX6bfwn2FOgfX/r+rwJ/m9ndVunbFvtQxa+HDY347Ztu3Z8ptv2/SCTXLswgfLPQ+rWp4uS9pb5ze1aJecssix8q7zJaUia5udIPM7WMeb5N4nIxbdVXY7n7WNj5bvfO8b5y2RPy4OUz3ssy7zSPmqwzX+3/uYJbdZ/1yGOY6NGb3lk/Y3WP+tQErlkhVTJNEbCJr0u7dtSe0m77af4NtW5NLVt0uqJ6fMm+rVjuT28nLbW/3ve9n6u6Whe2fw91xqXe1ObCkvtL1Tzu7XRv7QI8LFcw5yhFIAACAq9A/0JP9KhXU3PIuU/suo/gul2xFa2aGWecx33xlmWdtJBaGX77EKwzEpdzu7Ik1vm2CsVMw2pY7nSkO2M/dLwzzne8/Q9zBdgb7HvY7H7GMwt83zgWOojNlG38sEefWvcu7gpn8oWX8sWULmpAXRwMRRuSMhCwiU8YvjtqPKKpx5ixx3Ble87QLntmeUv50WLy1d6HjAsdBAKF24c80CxwOXlr+tZkEvO8OXKyp+35mBbeNKr7Su/WGf9c+DBoaSI1L8UmDGW2rp+SZsjAvZXi+lJXGy1/G+Db2nSVLpCYH3MttZr9PbW14OfLZmniGSWtov6Hk7fNTbq18NVFy19vSRTG8H37beMq9Z8vYy8WpbpYi0d3eRLG8j/1/b1rGK//6i/64Rd5zVPtzB3UZaeEcGb+cLAPT+z59slKI463fZ0d1U2nrs7zn4vOnrfvp8m+S5rECxoztDOnlO9p3rwHb2+/749S7Z61rq2zZReriP879P8HGXyvff5siueOv33sEdJ31Khji+WOcxlMq8H/NkW/xy33kokf4lA8rs277//cIi2bBkpbnd1p0vQ4r7Bm1rb69+WOqW1StWm9utPLlyQtFhUp6ffhNZsXatud3ckyM7inuXeT/bgt8TZMmmdeZ2E0+25JZY25owOmT7xRtSZMG2jeZ2Q2+2lBb3LPcYlm5Nlx93W1WD6d5cSSsp/5/75TsyZW7OVnM7ubRQmrl7hD1WtWpPI/kqf7u5HV/qli4eX0VYGL/nNJE5KwP/m3aop0vYz6U25DaVH9YGKiL7ujtKYmnICsK+120pbC6LNuz1P7bY3V7SSsNXXu4obiYrtlrhuVrqaSuZpY7VkB2yPY1kzY48cxyxEkrFlTrjPoSVm5sr/fv3l/nz50tGRgZnCQAAoAKldrhVQXAVLkjTME//q7EdmNnXpibF9z72tbLDMntbfbUdsNmv0Rv2/uzX2P+12tpfIKyz3j/4GMJta71nadC2umEg+Avsz3/Mzs/gOz5/AY3+P99/bbcftJ+3nwt9zPkf1wPHaZ//4NfZ34n/+P3b2LtzPFaVfQZ9hsBjge18x2W/vpz9lv87Crkf5ndW0fMH+n5S5fcrO++vvG3LvFcFr7WeD2ocCq6gC3omzPNhtq1sJJWzxba8/YZ/Pi6i1zi3CD6+yvZV9nWVnYugbq5KjjXoZYFiRv/2/m191Y5ltwl53PECu3oy9HgDjwcfSZn3cj4eciyh7+V8feB24AnncYRuEzj2uHKPxd5tuMed5yrsOQw5ltD3Cj3euHIqS8uek8iOpex5D9q6zPcRbh+hxxLu+w/3Wwl3HuLC/Ea0YviQlplmleZYyFGolAIAAEC1smZWWf9iDQAAUJ6DO3oDAAAAAADAQYlQCgAAAAAAADWOUAoAAAAAAAA1jlAKAAAAAAAANY5QCgAAAAAAADWOUAoAAAAAAAA1jlAKAAAAAAAANY5QCgAAAAAAADWOUAoAAAAAAAA1LqHmd3nwKS0tNde5ubm1fSgAAAAAAAB1mp2f2HlKeQilIpCXl2eujzvuuOr4bgAAAAAAAGIiT2nQoEG5z8eVVhZbQbxer2zfvl3S09MlLi6OMwIAAAAAAFAOjZo0kGrevLm4XOVPjiKUAgAAAAAAQI1j0DkAAAAAAABqHKEUAAAAAAAAahyhFAAAAAAAAGocoRQAAAAAAABqHKEUAAAAAAAAahyhFAAAAAAAAGocoRQAAAAAAABqHKEUAAAAAAAAahyhFAAAAAAAAGocoRQAAAAAAABqHKEUAAAAAAAAahyhFAAAAAAAAGocoRQAAAAAAABqHKEUAAAAAAAAahyhFAAAAAAAAGocoRQAAAAAAABqHKEUAAAAAAAAahyhFAAAAAAAAGocoRQAAAAAAABqHKEUAAAAAAAAahyhFAAAAAAAAGocoRQAAAAAAABqHKEUAAAAAAAAahyhFAAAAAAAAGocoRQAAAAAAABqHKEUAAAAAAAAahyhFAAAAAAAAGocoRQAAAAAAABqHKEUAAAAAAAAahyhFAAAAAAAAGocoRQAAAAAAABqHKEUAAAAAAAAahyhFAAAAAAAAGocoRQAAAAAAABqHKEUAAAAAAAAahyhFAAAAAAAAGocoRQAAAAAAABqHKEUAAAAAAAAahyhFAAAAAAAAGocoRQAAAAAAABqHKEUAAAAAAAAahyhFAAAAAAAAGocoRQAAAAAAABqHKEUAAAAAAAAahyhFAAAAAAAAGocoRQAAAAAAABqHKEUAAAAAAAAahyhFAAAAAAAAGocoRQAAAAAAABqHKEUAAAAAAAAahyhFAAAAAAAAGocoRQAAAAAAABqHKEUAAAAAAAAahyhFAAAAAAAAGocoRQAAAAAAABqHKEUAAAAAAAAahyhFAAAAAAAAGocoRQAAAAAAABqHKEUAAAAAAAAahyhFAAAAAAAAGocoRQAAAAAAABqHKEUAAAAAAAAahyhVBXt3btX7r//fjnhhBPk8MMPl9NPP13+7//+T7xeb0Sv//7776VHjx7m9saNG81tvVYTJkwwl/KEe/61116Tf/7zn1KbQj9HZb777jtZvXq1uf3222+bc4mAxx9/3H9O9Hbv3r1l5cqVZU6RbqPnb384f4eRbmtfevXqZfb97LPP+rfR44j0/S6++GLzucqj76P7jJT+83fMMcdIv3795JZbbpGCggLzeHFxsZx99tmya9euiN8LAAAAAFBzCKWqYM+ePXLeeefJkiVL5J577pEPPvhArrnmGnn66afN/do4Ht33X/7yFzmYXHLJJbJz505ze9iwYfLmm2/W9iHVKXFxcUH3S0pK5I477pDaNmfOHHP5/PPPTfjz5JNPyqxZs8Iec0U0kLrsssuq5Zg++eQTeeKJJ+TOO++U//znP7Jo0SJ56KGHzHNJSUly0UUX+e8DAAAAAOoWQqkqeOSRR8wfus8995wMHjxY2rVrZ0IVDaRmzpwpa9eujd43FYbuc+jQoZKZmSkHq5SUFGnSpEltH0adouejWbNm/vstWrSQBQsWyLvvvlurx6XHpJfWrVvLSSedJGeeeaY/lAo95oo0atRI0tPTq+WYXnzxRfnzn/8sxx9/vPTp08eEd2+99Za/Wuqss86SL774QjZt2lQt+wMAAAAAVB9CqQhpK9CHH34oo0ePluTk5KDn9A9ibSFq06aNuZ+TkyM33XSTHHHEESY0uuuuu6SwsLDKX85PP/0kI0eONH9sX3vttf4/tJW2C2rrnoYDNm2p0uPQP8T79u0rV155pezYscP/vLbMaVWVHpe2O2mFid12qNUr119/vUycONG0JZ566qkye/bsclvFKmr/WrVqldmPtlMddthh8qc//cnfrme3pY0ZM8bsM7R9r7JjvOGGG2TKlCnmeQ0Gn3nmmYjPpx7ve++9Z8IUbYnT49qwYYP/ef28er71mI888kgZP3685OXl+fd98803m+9SP5ces1YNzZgxQ44++mgZNGiQCUhsFf0G7Fa3cBdtgezUqZN07tzZ/14dOnQwFT8PPviged/y6PtqO6n+Xs455xz58ccf/c/l5uaaz6PHrt/tL7/8EvTaLVu2yNVXX22+e/1set49Hk+F5zMtLc1/W49ZL/vTvqf70u9y4MCB8sYbbwRtW9550tfr8enn0O/Kpr97rSxbvny5ua8hsn4/+s8KAAAAAKBuIZSK0Pr16yU/P98EFqG0dUlDCf0DWE2aNEn27dsnr7zyimlx0j+ctb2oKnbv3i1XXXWV+YNaK2S6du0qH3/8sf/53377zWyj+3XSP9Yvv/xy80e4hljaXmi/n4YwzZs3N3/4a7CjgYozSPnss8+ktLTUhBujRo2Sv//97yZgqgoNkDTc0IBOA6BXX33VhAd2C5XdqheuhSuSY9R2LQ0F33nnHRNePfzww1WqUNP96vejn1HbH//1r3/5v18N/nT/H330kXl87ty58vrrr/tfq1VBDRo0MJ9Lg5/rrrvOBFMvvfSSCVoeeOAB8xkq+w1odZ3dChd6adWqlQlo7rvvvqDj1u8xISHBVOuFo59Hgy/9zejvRX83Gkpu27bNPK/ncs2aNeZ8Tp48WV544QX/a/U7HzdunGRlZZnzqvv+73//K9OmTSv3POrvQkPa4cOHm/vt27c356Gq9Heq3++9995rAlWtcnIq7zzpb0cDuqKiIvN7sek50kqsrVu3+h8bMmSIfPPNN1U+NgAAAABAdCVE+f3rDbtCRUOJimi4oTN3fvjhB/+2GhZoBY5WIUVKgxFtidJqGw29NJT4+uuv/c8vXbpU2rZt6w/CbBomjRgxwtzWP/S1kkoDrHnz5klqaqo5Fv3DvUuXLqaKaurUqWbGk2rYsKEJTvQ99fn//e9/JiT4xz/+EfFxazXQH//4RxPu2JU0OmzaHoptt+rpvkJbuHRGV2XHqIGDHk98fLwJ37RSSmd8RVqlc+mll5rQR1144YWmBdIO0zSsOf/88819Pbca7DgHjDdu3NgEV/p96GfS70jDJ23j1IDssccek3Xr1pmqpIp+A/qYti1WRUZGhnmtVjvpd6yhmJMdjOk+1I033mgqpTSE0nBKj1XDn0MPPdQ8/7e//c0fkulvY/PmzSYIdLlcpkpLz7Hub+zYsf59aJWVcrvdpnJQ72sV2IHQ0M9uv1N33323nHHGGf7nK2oJtP+ZDP1nQO/r8dn0d6SVUxqO6u8GAAAAAFA3EEpFSMMQe/W9imj7mQYcxx57bNDj+pgGFpHSSpRDDjkkaIC0VmnZLXxakaMhSShtF7NpWKLHrcekFw0kNOyxaaigoY/9x722tDn/wNf7dttdpDSI0rBHq3U0LNLqnF9//VWaNm1a6WsjOUYNi5zBggZbGpJESlvhnEGPtnqpjh07ms/+1FNPmSBKL/od2AGfvW/7+7BDJbtl076vYUhlvwE9J1q5FI5WH+nMpnC0NU8rzW6//fYybW66T2eAZLey6eNaSaaBjP6ebM6KP90mOztb+vfvH3SsGjBqNZnNnmml76Uh1qOPPmoqs/anQqq849aKQGdboB2EhdL92gGiM4Cy72u4adN/BvTz6GfUajAAAAAAQN1AKBUhbU/SChetUAqtUlF//etfTaWK/sGu24W2IdkDq3V1sEhpW5VTYmKiP5TScCTczB9noKN0G61+CZ2DpexZTfb7lPfacMqbN6QzmM4991wTmOlsIp3fpCHM888/X8mnlYiOUc9BZeepIuFer7SSRsM0PWadUaSVWbqam1Po+VHhzk9lvwENwHR2UzjOVrRwbrvtNjMz7OWXX6703Olx2OcvlDN81FBPq6O0zTCUszLQGejp9hoIalWcVuJ1795d9lfo9+c8z+UNd9dKOx3wr59bV3LUaij7s2j45Kywst+/KisEAgAAAACij5lSEdI/lHUWkLZ7hVZm6OpeetFAQdvIdJaQ/gGsf8TrRStOdEh16Osq0q1bN1Nh5Ax/li1b5r+tlUf6x3coe8Cz0qocPRYdDK3HpYGaXRmkdEU3baezq8BWrFgRFGJopZM9zFzDHHvot3IOCHfSlrXt27ebVjFtr9MWOK2qiSQ4iuQYo0XnRB111FFmZpO2HmrwqOevKoGXrbLfgFZo2Y+HXsIFX066jbbj/fvf/zZtgs59hgaeet8emq7fn3O4uf62nK/V70jPs30cOnBd2xErCnLsc1Ne8BXp79x5XLpf5zD38s6T/h40ENSKr/nz5/u3X7hwoTmHzqowrfbSx8JVFgIAAAAAag+hVBXoXCcNAnR+kIYvOj9K26gmTJhgVpPT1iOt2NBV43Smz+LFi03IorN5dEi6VnZESufqaFXUPffcYyqNdCaT84/vnj17mj/gnUGR0jBIV5HTcOqWW24xQ561MkerazQQ0UobbZnSmUc69Furg+zgQYMmHUiu+9M2Nj12rXpS+se/to5pVYyuvFde5ZOGBfpZ9f31+PT8hAZ52p6l7XEa3DhFcozRosetoZx+Z9rudv/995uwpCpBoq26fgPl0VBKAyRnK6lWdun8KK0s0uPXAfD6G9DvT0MwbUPUuVYaVOn3pyve2XQulLYh6vwyPQe66uOtt95qWuCcrZLaRmlfNLDU34oGXqFVUhqk6jaRnDtdVVB/szrAXn9bOqOrvOq8cDRAfO6558xvRc+1tjZqW5+zfU8/k/7zQqUUAAAAANQttO9VgbYE6WpqGpRo4KCVStrWp6vUaXBi04oYHdisQYFWaGhAoUO0q0LbkzSI0j+yNVDQKh69tqtTtIJJj0criZzDpnUAt8760cqX4447Tu644w7zuAYT+n4acukwbA01dMC0zuaxaUuZzqrS5zXImj59uplLpXSlOQ1WzjnnHBNE6MDv66+/vsxx6wwgnRGk+9WV0fQ4NWTSsEFXgtP2NW1z1HOkoZ6zoiWSY4wWPSatHtLvTFvC9Hzr59AZT/ujOn4D5dHWOz2nGo7atIpP29i0ukkDIQ1hNDi029o0ZNJQSge962/LXi1QafCkIaQ+r4GOhoannXZamQH39u9Mwx0N1zTw1M8ZGiJt2bJFTjzxRBM2DRw4sMLPor9prWTSfWs1mQZuzmq/SMLbTZs2mfOhIdgpp5xiwjUnDXND53sBAAAAAGpfXOn+9CehTtBwTMOn++67z9zXeUjjxo0zwdH+vJdWfx3I0GrApuGYBkE6bL02aXWaHodWkOmgegAAAABA3UH73kFs9OjR8u2334adLQXUFm1x/e6776RXr161/iX897//lT/84Q8EUgAAAABQB9G+dxDT9rarr77atGmNHz9eYplWh+kspfI888wzZlU9RJ+2YWrrXnkrHdYUbefTeWY6cwoAAAAAUPfQvod6QdsYnav2hdJZVikpKTV6TAAAAAAAoHyEUgAAAAAAAKhxzJTaT2+//bZZWe6NN96oti9jwoQJ5mIPHtcV0vaXHtv3338vNW3jxo1m33odehzr1q0zq60ddthh8q9//csMZtfzeKCWLVsmP//8s7mt+9J9AgAAAACAuo1Qaj99+OGH0r59e3nvvfckGi677DITTB3s5syZI/369TO3Z8yY4T93l156qbz55psybNiwA97H2LFj5ffffze3dV+6TwAAAAAAULcRSu2HXbt2mdXFNAz56aefZMOGDdX+xaSnp0ujRo3kYNesWTNJSkryr8p2yCGHmDCvYcOGZlB7dc950n3pPgEAAAAAQN1GKLUfPv74Y2nQoIEMHz5cmjdvHlQtpS1p//d//ydnnXWW9O3bV6688krZsWOHv7Xs2GOPNSuTDRw4UI4++mh56qmnwu4jtH1Pwy9dYa5Pnz7mvT/55JOg7Z944gkZPHiwed/KWgq1ve2jjz6S008/XQ4//HCzcp8Ga2PGjDH3//SnP8m2bdv823/55Zdy9tlnm31rZdOnn37qf06Hi991111mZTv9bF9//XWZfenn1rZEbdV79913/e19zvY9t9stjz76qAwdOlT69+8vf//732XPnj3mOT0WvX/UUUdJ7969zbHMnz/fPKfnaNOmTTJx4kSzj9D2va1bt8q1114rAwYMMOfm7rvvNquyKd23vv6xxx4zz+lnuO+++6S0tNQ/PF0r1rT6Ss+tfk57mLrdvgkAAAAAAPYPodR+0PazP/zhD+JyuUywokGLHWTYgdLll18ur732mhQUFMg111wTVGWl2z///PNy5513yrPPPiuvv/56hfvTUOuqq64yodR///tf894awGhQpXQ/GnTde++9JhB76623Kv0MGsTcf//98vTTT5uQ6cILLzSXV1991ezvmWeeMdtpRZgev86C0vDtvPPOk+uvv16WLFni/6waWmm49u9//9scRziTJk0yIZhetL2uVatWQc/ra9955x3zGfTz6HmaMmWKee7GG28Uj8djjk3Pna6kd/vtt/v337JlS7nlllvMPpw0fPrzn/9svoOXXnrJzLH66quv5MEHH/Rvs2DBAlm7dq288sorcuutt5rjnzt3rnlOQ6i0tDSzz6lTp5og0P6uNJyjTRAAAAAAgP1HKFVFW7ZsMUO1TzrpJHP/lFNOMVVGduWOGjVqlAlxtJJGQxYNPn777Td/RZA+duihh5r30NBEw5aKzJw501RVXXTRRdKhQwfz3hdccIH85z//Mc9rUKLvc/zxx0vPnj1NNVBlLrnkElMVNWjQIPMafX8NjPS2fiYNaux9n3rqqWb7Tp06mVlQ+ryGahrEaVWWXcWkFUUaDoWjlWXaqqcXba+Lj4/3P6fvo59Bwy6tturatavccccd0q1bN/OcnicNjLp06WKeGz16tKxatcq8Vlsc9b30/fXi9M0335gqq4ceesh8F1rtdNttt5kAKi8vz2yjYZeGT507dzbnVdsLf/nlF/OcVmDpe7Zu3VqOOOIImT59uhx33HHmOftzAAAAAACA/ZOwn6+L6Sqp5ORk02amtC1M5yNplY+2fykNMGzt2rUzwcnq1avNDCWtvNHgw6btaBrwVGTNmjWmGskeGK60jUxDIqXvrfOtbBrc6H4qosdl04ClTZs2QfftFjd97z/+8Y9Br9Xj0Gosba/bvXu3CbJsurJeVen7ZGdnm6DO+RnsCjOt4Jo1a5YJAzUs0yotr9db6fvqsXfs2NF8Pzb9bjQYXL9+vbmflZUlGRkZ/uf1tj6vtCJNQ7bPPvvMhGVaHdWrV68qfz4AAAAAAFAWodR+hFKFhYVm7pFNq210zpRW85iTmhB8WvV5bfUL95yGK3FxcRXuU0MSnSN19dVXB395jvdytg+G208oZ6WSso8vlAZwofSYnaGQc9+JiYlSVRUdq+5H5zrl5OSYUEjbJTWQGzduXKXvG+7Y9btwXttD2J3sz6Mzw7S66vPPPzdtf1oRdsUVV5iKLgAAAAAAcGBo36sCrdL59ddfZfLkyWbOkH355z//aVaW04oatXz5cv9r1q1bJ/v27fMPxdZwRYd827RVrLKB2VoRpe+jrXv2Zfbs2Wa+lNI2N7vlTOn7636qg+570aJFQY9pO6I+3rhxY2natGnQvvX8VFVmZqZ5L+d5W7ZsmalOWrlypfz4449mVpaGcjrLa/v27WGDuHDH/vvvv5sqLNvChQtNCKYrAFZGv1edbaWVWjp767rrrgsa8g4AAAAAAPYfoVQVq6S0FU/nOXXv3t1/0QoebTfTgErpsGwNjTRk0favIUOGmDYym1ZU6YwpHZytA7h1RlJFdDU8bVnTkERDFg2jdKU6nXWkdNaU7lPfT99XB36XV/lUVTpLSt9X51fpvjUc0vBNgxqt8NJj16HpOhxcwyldvW5/6Cp4Oux83rx5Joi65557zOqF2nqnn0XPvc540oo0HW6u7BZDbVXUFkdn+KT0vGub4s033ywrVqww763zo84880wThFVG31OH0ev3qMekKwva7XtaLWevqggAAAAAAKqOUKoKNBjRNrpwLV8a0mgwo4O1zz77bBMa6WM6DFvDJCetANKgSYOX8ePHm/esiM57mjZtmhncrYGKriKnq+9pe5nSAd3aWqaBi76vhjGRhC6R0GHoulqdDgfXfessKd2/trUprV4aOXKkaWnTFQJ1db79ceWVV5oB6lqNpOdNV9TTz6PXutKergao+9dh41qpptVOdlWWbq8D2fXx0BbFJ5980tw+//zzzbk+8cQTTdAUCd2vVoJpYKavb968uX+FP51xZc8VAwAAAAAAVRdXWlkPFKpEZx7pvKNzzjmnzHPff/+9jBkzxlTtAAAAAAAAxDIqpQAAAAAAAFDjCKUAAAAAAABQ42jfAwAAAAAAQI2jUgoAAAAAAAA1jlAKAAAAAAAANY5QqoY8/vjj0qNHj3Ivb7/9doXP66p+27dvlyOPPFIeffTRoPfWBRR1Vb9rrrkmomPR99OVAMPRx/X56vi8F1988X69Vl930kknSVFRUdDjGzduNMem19E+ptDv67DDDpMRI0bI119/XelrX3vtNfnnP/9pbu/atUs++ugj/3MbNmyI6D2Ki4vl7LPPNq+PlH42Pe79+d4jVZXfh/2b/vbbb6t8rPurOj5jNFTXP1cAAAAAUJ8QStWQyy67TObMmWMu9h/j9n29DBs2LOh+v379gl7z5ptvSvPmzeXmm2+W5557TpYvX+5/7//85z/y22+/ye233y71hYY306ZNq9Vj0O/APv8ffvihnHnmmSb4qygU27Nnjzz99NPyl7/8xdx/+OGHg0KoW265RRYvXlzpvpOSkuSiiy6Shx56SA52d955pwnZAAAAAABwIpSqIenp6dKsWTNzadiwoXnMvq+XlJSUoPuJiYmSlpbmv9+kSRPzmvPOO0+OOOIIE254PB5ZvXq1qZy67bbbJCsrS+qLNm3ayLPPPiu///57rR2Dfgf2+W/fvr1cccUV0rp1a/niiy/Kfc3MmTNl6NChkpmZ6a9i219nnXWW2demTZvkYKW/9Z07d8r06dNr+1AAAAAAAHUModRBJi4uTu6++24TRr300ksyefJkOf74402lVVX8+OOPcsopp8jhhx8u1157rezduzfsdlu3bjXPDxgwQAYOHGj27ax6+d///mfazPR9hg8fLt99912Z99A2vAsvvNBUfkVaMaOtct27dzdVNuXR99VKouOOO0769u0rV199tWzZssX//KpVq8x+9di0vVGrmJx++uknOeecc6RPnz4mAPrkk08qPS4NCsvj9XpN6562HiqtiHvnnXfMRdsvJ0yYID/88IM88cQTpn3tjTfekN69e8u6devM9vqdapvg559/7q+WOvroo817OtsXK2pP0+9LK6z0fc4///ygirqqnDs9Jq320mqxP/zhD/Liiy+GfZ/77rvPPL958+awz2dkZJjfj4ZS69evD7uNBndaFafnSM+Hhnp6jsqTn59vQlj9Perl1ltvDWr11O9Vv089B3ounKHe7NmzZeTIkeY5bYUdP3685OXl+b+vG264QaZMmWKC38GDB8szzzzjf61+Z0899ZQ5L/qbOfXUU+Wbb77xP5+TkyM33XSTea1+hrvuuksKCwvDfgY9n/rPrR6H/gb1mAEAAAAg1hBKVRP9w1b/aNUQIVwwU506dOgg48aNM6GChgf6R3RVaUXPpEmTzPXatWtNuBBKA6Q///nPUlBQYAKwf/3rX/LVV1/Jgw8+aJ5fuXKl/PWvf5WTTz5Z3nvvPdPe9re//U127NgRFNToH/56rUGDBi2RcLlcph1Rz+WsWbPCbqOf+7PPPpMHHnhAXn31VXG73Wb/ui899iuvvFLatWtnZhtpgGCHO0qP8aqrrjKBwH//+1+5/PLLTWhUXjigwYmGRVq5pZ83HG2h3L17twwaNMjc1xDu9NNPNxdtv9TzbbdlagBy7rnnmvt67vX9NWjRoNAOtdSQIUP8wUerVq38rZ3l0QDstNNOk3fffdd8dv2daEVdVc6dBjx6jFrd9/rrr5vj0hlZX375ZdB7vPDCC+Z713ZSrSArz+jRo6VLly7lBox6rNqCes8998jHH38sY8eONedn6dKlYbfXIHb+/Pny5JNPyvPPP29u62/TpmGfbqPnXMNWbaFUGoppQPanP/3JzPnS18ydO9d8RpsGk8nJyeY8avikr9V/Pmwanp1xxhnywQcfyCGHHGICMT1nSr/fffv2ySuvvGKO7Zdffgn7mX/99Vfzz5B+B3ocGo5dd911/vcBAAAAgFiRUNsHUF+8//77pgpG6R/wWmURTVrhon8w6x/7dmtfVWhYoe+h9A/4Sy+91Fw7aRiybds280e73XKoAYUGUddff735o1+rQjTMUBoCaRWLVozYtFpEg7MZM2ZUWGUUjlaR/PGPfzShzbHHHhv0nIYNGohoJYsdAun50KodHaytQUx2drYJtnS/ep70+9HQSGkYpwGiVtLYQd+yZctMOKIhgdKAyg6ANOTS4EYrrjQcCkdDlLZt2/qDNw11tC1T2d+R3ZbZqFEjc19DC60Ku/HGG034ETr8W49bq53088THx5tWwopooGV/pjvuuEOOOeYYcz6c56+yc6efVc/TvffeayqdunXrZn4bGhTaNCjUkPH//u//zDFWRI9bvwf9LjV00tDMSc+nfsf2PzNa3TZ16lQTeh566KFB2+qx63toINa/f3//OdTvzqa/T62gUhr8aeimNPTRz6EVZEq/K/0N6H5s+r384x//MMesQaWeoyVLlkinTp3M8/rPjAaZ9n70u9OAU4M8DS31N9agQQP/b1+rsiZOnBj0GbRySyseNcjTY9BASqum9Pic5xgAAAAA6jtCqSjQPzijSQMK/eNaAyGtEnnrrbdk1KhRVQ58bL169TKBS2h7lbaTdezY0R9IKd2nva2GKKGhgf6BbVuwYIFpE9T2Oed7VIWGX59++qn8+9//NlVbNq1Y0j/i9b2dgYKGB3rceox67M4gTD+zPXR8zZo1pvLHWXVUUlLiDx+UtpLZVTb6nAYf2r6on0VDvVAa5DRu3LhKn0/3p2GehlFatRQaMOpn0s+pAVskM8O0rcymgZK+v35WZygVybnT2/p6m/37slsHtapMw7eWLVtG9Dl1XzoPTcMnDcqcNBhbtGiRPPLII2b/ep416AlXOaQBp/7+nb87DRHtIFHp/C+bBkR2a5/+HvSYtQVPgyi9aIunBks2DYk0kLJpsKjnw6bv4Ty/Sp/X49bjDQ1P9TG7PdOmrX3amqothvrP3oknnmjOTUIC/3MMAAAAILbwn+Wrif6BqX8Ya6jgDGaiQdul9I9gbT/SqhgNM5wtc5Fw/uFtD+PWKh4nbWMKZbeC6XVlf0TrH/Ta9qd//GtV1f7QgeG64qBWNjnnI4U7Nvu47DAjdMi48/NpkKDfmbaO2RddYc+54p9WOWkFlV66du1qtte2Nv1M5YWR4VrlKqOfS7+PcLOi7M8QadDp/F6VnotIvlfnuYskHNHWUQ2u9LcXKZ3XpFVYodVg2m53ySWXmPBI2xe1+qq8sCv0s4RTXrWRnmdtvdMgSv9Z1XbB0Fls4d7f+Tsq73k9dxqAOX9PetFAVX87TqmpqeYza1WezmrT9lKtvtKqRAAAAACIJYRS1USrJjQ40RlI0Wzd0z+o9Y96bTFq0aKFCcB03xUNBC9v/pFt8eLF5o9trRJx0tBBq2q0Sse2cOFCE1poNYqGNaGDtLVFS8MdpdUgRx11lGlz0ioY5/tUhVayaIig7WQ2nZekx6HHY9NB5lqVosetLWd67Drjx+Zs8dJtdFs7dNKLDsHW+VIV0QCivNk/TZs2LfMZKwuTtOVL50RpGKb7Dp1Hpp9JP2ekFVjO71XbKPUcdO7cOWibys6dVgPpbZ0lZtPwSavEbDqjS6v19LvWarhIaIWZBowa6jmr8nQGk86R0hUltd1NP+uuXbvCrlyox67Bm/N3p+dQh+1XRlsW9feov0WdK6VVZfo5D2SFRJueN/2t6fdt/550yLnOjgod7q8VhE8//bSpENPWPm1H1EBOqx4BAAAAIJYQSh1EtBpDwyhtobPn4mh7mg5M1oqMSFaPs+ncKw1ANJjQsEHDJK3gcNIh2xoCaJCwYsUKmTdvnpmTowPNtYJJZ//o3CWd76N/3Osf2loV5WylUtp2p4HEo48+ut+fXT/j9u3bg6qwtOVJj0crjDSk0JXPtMJGj1tnBemsIh0+rVVlWo3iHJiuoYTOCtLzoMGNBkJ6fM6B3dqypxVoetF964wtXTVNB5eH07NnT7NCnr2am9JzqjOE7CoY/b50fxq65ObmmuPX0E7bvrTqTT+ncyU5Pe/6vnYVlh5LRSsY6ufQGWAaXmrIo+GIPTcq0nOn7WUasOn8MD13GtbpXCZ9PLQlTwNDDUSdLW4V0fBIV/vTVQJtGkLpb1HbQfU70ZZNPffhPqcGsBpcaZWThqk6TFy/w9DPGI62KOr51Nfpvu6//37z+khXhKyIztXStkSdDabvr/PFNHDSGWv6z4qTVuDpzCytltLfiwZ7up2urAgAAAAAsYRQ6iCiQ5c1JHBWrNjDlzUo0pBBB0FHQgeba2Cj1zpXSf+YDqUVKbqKmNIQTFfR0/k3dlWWVktp1ZbOtNL9ayimFT9aweWkc3z0D3T9I1xDgP39o19b55w0oNPw6e9//7sJyLQtTVu/dH9a+aUhmZ4PDUK0GkdXgbO1adPGHKsGTXrs2gqpc5KGDx8eVNGiQYxe9Bzr+dIQJnRwtU1DBR1Erq+z6fYagOj7akWOhkG6Tx2irWGKBhT6HSidU6XhhAYWNq2esecUbdmyxRyL8/1D6QqQ2iqpn1krpXQYebhqrYrOnVZR6feuQZy+jwZAGkzqIPRwLXkaupXX0hiODj13tsFpeKYBnZ6ra665xpxHXeHQWdnmpNvrynd63q644goz1FyDrMroudFATFsFNZTcvHmzqdDS1fCqg1ZFabWhvr8em1ZPhQtiNWTUc/rss8+agFN/h9oOWdnAeAAAAACob+JKq6N3BYChIZ2GHTrQ+0BpQKWBlM4mCm2tBAAAAADgYEelFFCNtBrr22+/3e/5WaGteFqdRCAFAAAAAKiPqJSqZ3QVL20Xq6gFMHTmU03Sdqm5c+eW+/wdd9wR1EJ3MHr55ZfNzCRtd9xfOufo3HPPNSstaksgAAAAAAD1DaFUPaOtYzokujw670nnGNUWnVPkXNUtVFZWlhlmDQAAAAAA6jdCKQAAAAAAANQ4ZkoBAAAAAACgxhFKAQAAAAAAoMYRSgEAAAAAAKDGEUoBAAAAAACgxhFKAQAAAAAAoMYRSgEAAAAAAKDGJdT8Lg8+Xq9Xtm/fLunp6RIXF1fbhwMAAAAAAFBnlZaWSl5enjRv3lxcrvLroQilIqCB1HHHHVed3w8AAAAAAEC99vXXX0vLli3LfZ5QKgJaIWWfzIyMjOr7dgAAAAAAAOqZ3NxcU9xj5ynlIZSKgN2yp4EUoRQAAAAAAEDlKhuBxKBzAAAAAAAA1DhCKQAAAAAAANQ4QikAAAAAAADUOGZKAQAAAABwkPN4PFJSUlLbh4EYkZiYKPHx8Qf8PoRSAAAAAAAcpEpLS2Xr1q2SnZ1d24eCGNOoUSNp2bJlpcPMK0IoBQAAAADAQcoOpJo3by5paWkHFBAAkQah+fn5sn37dnO/VatWsr8IpQAAAAAAOEhb9uxAKisrq7YPBzEkNTXVXGswpb+//W3lY9A5AAAAAAAHIXuGlFZIATXN/t0dyCwzQikAABBVW/cWytzVO02pNwAAqH607OFg/d0RSgEAgKjxeEvl+tcWyn2zlsuijXs50wAAAPAjlAIAAFGzK69Icovc5vZvW/dxpgEAAOBHKAUAAKJm575i/+0duUWcaQAAIBs3bpQePXqY65qk+/z+++/N7RNOOEHefvttvo1axup7AAAgavYVBgZf7i3Y/yGYAAAA1enNN99kQHwdQCgFAACipsjt9d/em08oBQAA6oYmTZrU9iGA9j0AABBNhSUe/20qpQAAqBm64q3+3+CavOzPKrsff/yxHHvssXLEEUfIbbfdJsXFVtv/G2+8Iaeddpr07t1bBg4cKHfccYd4PNa/U2zevFkuu+wy6devnwwePFjuuusuKSmx/sOXHsPUqVNl6NChcuSRR8rVV19ttg/H2b538cUXy1NPPSV/+ctfpE+fPnLqqafKN9984982JydHbrrpJnOc+t66z8LCwv36bhCMSikAAFAzlVK07wEAEHUazNz85mJZXsMLjPRs1UAeGNVH4uLiIn7N66+/Lv/85z9N4HTzzTfL008/bUKou+++Wx566CHp1auXLFmyxARCGkCdcsopJhBKS0uTd999V3bt2iV///vfpXPnzjJ69GiZMWOG/Pe//5VHHnlEmjZtKs8//7wJsPSxxMTECo9l2rRpMmXKFHPR1996663yxRdfiMvlkkmTJpng65VXXpGioiJzfHfeeafce++91XDmYhuDzgEAQI2EUroKn8db9f+KCgAAqqYKuVCtuuWWW6R///4yYMAAufbaa+XVV181gdM999xjAqi2bduaiikNp1auXGles2nTJmnQoIG0bt3aVC5Nnz5djjvuOPPcs88+a8ItDba6dOligqO9e/cGVT2VR9/jnHPOkfbt28tf//pX2bJli+zYsUPWr18vn3/+uQnJdFC6VlJpMPbOO+/Ivn2sLHygqJQCAAA10r6ncgvd0jCt4v9SCQAA9p9WKmnFkvM/DNWE5ARXlaqklAY8Ng2edu7cKe3atZOUlBR57LHHZNWqVbJixQpZt26daZtTl19+uQmzPvvsM9P6N2zYMPPavLw82bp1q1x//fWmusmmbXa///57pcfSsWNH/+2MjAxz7Xa7ZfXq1eL1es2+nPQxPS5tMcT+I5QCAABRE/ovxPklbmkohFIAAESThkMpifF1/iQ7wyN7JtWPP/4o48ePl5EjR8oxxxwjY8eONTOlbMOHDzetfFq99NVXX5n2vSuuuMLMg1L//ve/pVOnTkH7adiwYaXHEq69T49JWwu1Muutt94q83yLFi2q+IkRivY9AAAQNUXu4Eqp/OLg+wAAIHb99ttv/tuLFy+Wli1byvvvvy+jRo0yrXfnnXeeacPTFjo7tNIZVDpL6sILLzQzqK677jr59NNPJTMzU7KyskzLXYcOHcylVatWpu1u7dq1+32MGnBpm54Gffb7avXVgw8+6B/Mjv1HKAUAAKKmsCSkUqqIUAoAAFh0NtOiRYvk22+/Ne16l1xyiTRq1EgWLFhg2vZ0jtSECRNM0GQHQGvWrDGB1fLly83zX3/9tWnfU/r6f/3rX2ZAubbsTZ48WX7++WczCH1/aSimFVs33nijCc6WLl0qEydOlPz8fBOE4cDQvgcAAGqwUsrN2QYAAIZWO+lQcV3Z7vzzz5c///nPZq6Uhj4XXHCBme2kA8h1u2XLlpnX3H777aad7+KLLzYzn/7whz+Y1fGUtvDpbKnbbrtNcnNzzbyn5557LqL2vYpoVZSuuKehV0JCggmpNPDCgYsrtWvg6gn9OPpDPPPMM83kfNuePXvMD3POnDnSuHFjM9l/xIgREb2n/ph1RYD58+f7B54BAIDK3f7+Upm/bo///viTu8vxhzTn1AEAUA20jUxb07TFTIeDA3Xl9xdpjlKv2vd0+r2ml1r6F0qTVu0Dfe2110wSq6mmlt4BAICaq5TKo1IKAAAA9a19b9u2babHc+PGjWX6OnUo2pdffimzZ8+Wtm3bSvfu3WXhwoXy8ssvBy1BCQAAorP6XsPURNlbUMJMKQAAANS/SikdNqaT9XWZRl2u0UkHp+lzGkjZtIxMh6cBAIDo8XitKQGZqdZ/B2OmFAAAAOpdpdQJJ5xgLuHopP7mzYPnV+hSkVpdBQAAoh9KZSRb/8qRV8zqewAAADjIQikdoFVeiNSsWTNJS0sr97UFBQWSlJQU9Jjet5eUBAAA0WEvp9IgJdH6v8mEUgAAADjYQiltwRszZkzY56ZOnSonnXRSua9NTk4uE0DpfVYnAAAgutxea6ZUgxS7UsrNKQcAAMDBFUoNHDhQVqxYsV+vbdGihezcuTPoMb2vFVYAACB6PFYmRaUUAAAA6u+g84r07dtXNm3aJFu3bvU/Nn/+fPM4AACIHq+vf68BM6UAAAAQi6FUu3btZOjQoXLTTTfJ8uXL5Y033pAPPvhARo8eXduHBgBATK2+V0D7HgAAAGIplFIPPvigpKeny/nnny/Tpk2Te++9V/r06VPbhwUAQExUSmUkW4PO84pYfQ8AAERm48aN0qNHD3OtNmzYIF9//XXY52rbhAkTzEU9/vjjcvHFF/uf0/v9+/eXI488Ul588UU54YQTDnh/xcXF8vrrr/vv6/50Pwebg2amVFV88cUXZR7LysoyYRQAAKg5bk9p0KDz/GK3lJaWSlxcHF8DAACoUKtWrWTOnDnSpEkTc/+WW26RAQMGyHHHHVenz9xll13mD6X27t0rTzzxhNx1110yZMgQk02ceeaZB7yPDz/80GQcWnijNJBKTLT+I+DBpF6GUgAAoG7wlAaHUtrNV+T2SkpifC0fGQAAqOvi4+MPygXKtEvLlpuba64HDx4sbdq0MbdTUlIOeB+lvn/HsjVq1EgORjHTvgcAAGqe1zdTKj05QVy+4qiCYlr4AACIupKC8i/u4ipsWxTZtlUwfPhwmTFjhv/+pZdeKhdddJH//muvvSYXXnhhUIuetsb98MMPpurI2Rr3+eefy0knnSSHH364XH311aYyKRytJLr55ptNxVK/fv1MC51WYelxHH300TJo0CDTWmfT97n11lvNc9p6pzOqne/9008/yciRI81YoGuvvVYKCgLnwG7f0+O2W/X0GPUzvP3220Hte4sXLzafVY//1FNPNRVQNp2Hfdppp0nv3r1l4MCBcscdd4jH45Hvv/9eJk6caBZ0s89PaPue7uf00083x3fOOefIjz/+6H9O9z9z5kxTZXXYYYfJiBEjZMmSJf7n9Twcf/zx5jl9rX7WaCGUAgAAUa+UinfFSbKvOiq/hFAKAICoe/608i+f3Rq87Ysjy9921k3B2758QfjtqkAXItOASZWUlMjChQvll19+MbfVt99+K8ccc0zQayZNmmTCJG2Nc4Yv77zzjjz66KMmSFm6dKk888wz5e531qxZ0qBBA3nvvfdMWHPdddeZYOqll14yoc4DDzwgu3fvNtuOGzdOli1bZlrkXnjhBVm9erV/ZpRuc9VVV5nA6t1335WuXbvKxx9/HLb9UIMlpdf6GZx27dplPk/Pnj3N59D3/Mc//mEWaNPzc/fdd8v48ePNe2sg9eabb8rs2bPNedBWxpYtW5rj1/04aSCl4Zu+nx6fHueVV14p27Zt82+j51Afe//998050X2pX3/91czknjJlinz00UdmDpaeJ6/XK9FAKAUAAKJeKRUfFydpSVYoxQp8AADENg2ltHJHW9A0SGrfvr1kZmaaQETDD60ECg2lNDjRmUlpaWlBrWpawaQBk1YaaWWQBjrlady4salq0v2dffbZsm/fPhMUdenSRf7yl7+I2+2WdevW+UOhhx56yLy3XvS2zq9es2aNCWt0zpXuu3PnznLNNdeYqqJw7Yf2PCy91s/g9OGHH0rDhg1l8uTJ5n20KumGG26QwsJC8znvueceOeWUU6Rt27amYqpXr16ycuVKSUpKMu9ltzfqtZMdsmkll77vjTfeKN27dw+qTtPPr9VbnTp1MpVqdqWUVl/p7M/WrVub/WogpZ89WqEUM6UAAEDUAilfJiUulxVK7TKhVHT+pQYAADhcVrZyxy8uZLbjmHcr2DakluVPrx3wadbqG21304BFwym9v337dpk/f74JWFwul2lZ04CkMhow2TSoKSoKaTd00JDFXmzFnusUOudJV7XbsmWLCck0sLFpcKUBkoZSq1atkkMOOSRo4RYNpZwtfJFYu3atCZr089o0ILLpMT322GNmfytWrDCBmQZ6ldGqrrFjxwY91rdvX/O4rWPHjv7bGRkZ/io1fX8NsM466yxzbCeeeKKcd955kpAQnfiISikAABAVXscATp0nZQ831xX4AABAlCWmln9JSKrCtsmRbVsFWumjQZRWI+m8Ip3ZpJeff/5ZvvvuO7NKXaQr9ToDncqEC1bCvV6PLxyd56SXcIPG92flu4QKgp5vvvnGVE7t3LnTVI1pOHXEEUdE9L7Jyclhj91Z7VTe8aampppWw//85z9mpUNtBdTjcLb+VSdCKQAAENV5UirB5Qq07zFTCgCAmGfPldJ5Us5QSmckhbbu1TStkMrJyTFVUTatVtKV9PS5bt26mVZDO6BSOn+qqjp27GgqoJwBl7bLPfvssyYYGjVqlNx5552mUkkrtdavX+/ftqLQTo9x0aJFQY/pfWflV3kWLFggTz/9tBn8rsPUdZ6VVp9pFVs0EEoBAICocI4e0P8ImeqrlCoklAIAIOZpKKUzmrR1rEWLFqZVTNvftJ2vvFBK5yz9/vvvZkB4NGkAdOyxx5qh47o6nl709lFHHWVa28444wxzrDrzSYMrDZH2J7Q566yzJDs72wwW18+lVUk6yFwrxXRulgZEGlppm6MOWd+xY4dpL7QrmnQ1QH2dzsJyuuSSS8z8KB1yri2CDz/8sJmTde6551Z6TNoyOHXqVBOK6ap+OvcqPz/frPIXDYRSAAAgKtyOVEoHnduhVF4Rq+8BABDrdMW6rKwsUyGldJaUriqns5rs4eChtGJI29ouv/zyqB+frsTXrl07E/DoEHStjtKwRulsKQ2idMXAESNGyNy5c811VWVmZpqqJG1hPPPMM83KgY888ohZjU9X/9Pzc8EFF5g5U9qSd+GFF/orsrSSqUOHDibYCq3SGjZsmFx//fWm5W/48OGmIu355583YVtldN8atunn08HxuvqgDjqP5LX7I640tBESZWiJnv6DosmnprgAAKByewtK5KJnvze33xs7RJ7+3xqZ9csWueCodnLRoA6cQgAADpCu0qaVMNqWZQ/qBurC7y/SHIVKKQAAELXV98y/bMQFVt9TtO8BAACAUAoAAER90LkGUspu38svpn0PAAAAVEoBAIAo8fgqpXSelEpl9T0AAAA40L4HAACiGkqFVkoVUCkFAAAAQikAAFBTlVL2TKn84uBliwEAwIHxOla8BQ6m311CtRwJAABACK9vplRCfGj7Hv/iDABAdUhKShKXyyWbN2+WZs2amftxvv8YBERLaWmpFBcXy44dO8zvT393+4tQCgAARLd9L3SmFJVSAABUCw0EOnXqJFu2bDHBFFCT0tLSpH379uZ3uL8IpQAAQHTb93wzpdISrX/tYPU9AACqj1apaDDgdrvF42GFW9SM+Ph4SUhIOODKPEIpAAAQFZ7S4EqplCTrv6IVlPAvzAAAVCcNBhITE80FOJiw+h4AAIhypZQErb7n9pRKiYe5UgAAALGOUAoAAESFvSBLgm/OQFpSoECbaikAAAAQSgEAgKi279mjBnS2VFKCr4WvmBY+AACAWEcoBQAAosLjK5WyB52rNN8KfAw7BwAAAKEUAACICntsVLxjVZYU31wpKqUAAABQb0KpnJwcmTRpkhx99NEyaNAgmTBhgnnMtmfPHrnmmmukX79+csIJJ8h7771Xq8cLAEDsDDoPhFL2sPOCEnetHRcAAADqhnoTSk2ZMkWWL18u06dPl+eee05Wr14tkydP9j8/ceJE2bdvn7z22mvy17/+1Ty3ePHiWj1mAADqM29p2VAqPdmulGL1PQAAgFgXWAbnIJafny+ffPKJvPLKK9K7d2/z2C233CKjR4+WoqIi2bZtm3z55Zcye/Zsadu2rXTv3l0WLlwoL7/8svTp06e2Dx8AgHpdKeVyhWnfK2HQOQAAQKyrF5VSLpdLpk2bJj179gx63OPxSF5enixatEhatWplAilb//79ZcGCBbVwtAAAxNbqe86ZUnb7Xn4x7XsAAACxrl5USqWkpMixxx4b9NiLL74oPXr0kCZNmsiOHTukefPmQc9nZWWZCioAABAd3jAzpezV9xh0DgAAgIMmlCosLCw3RGrWrJmkpaX578+YMUM++ugjefbZZ839goICSUpKCnqN3i8uLo7yUQMAELvCDTqnfQ8AAAAHXSilLXhjxowJ+9zUqVPlpJNOMrdnzpwpd999txlsPnToUPNYcnJymQBK72uFFQAAqLlB52lJ1r965BczUwoAACDWHTSh1MCBA2XFihUVbqOr7j344INy8803y5///Gf/4y1atJCdO3cGbav3tcIKAABEh9sedB5Xtn2vkEHnAAAAMa9eDDpX77zzjgmktELqL3/5S9Bzffv2lU2bNsnWrVv9j82fP988DgAAot2+J2Xa96iUAgAAQL0IpbKzs+XOO++Us88+W8444wwz2Ny+6Ap87dq1M618N910kyxfvlzeeOMN+eCDD2T06NG1fegAANT/9r0wlVKEUgAAADho2vcq8u2330p+fr6pltKL0+zZs6Vt27amimrSpEly/vnnm7a9e++9V/r06VNrxwwAQH3n8VrX8a7AfwNLpX0PAAAA9SmU0uoovVQkKytLpk2bVmPHBABArPOGad9L9bfvuWvrsAAAAFBH1Iv2PQAAUIcHnQetvmeFUgUlvjIqAAAAxCxCKQAAEBWeMDOl7Pa9AiqlAAAAYh6hFAAAiHL7XlyZ9r3CEq//eQAAAMQmQikAABAVHrt9L0yllCp0ezjzAAAAMYxQCgAARIW3tGylVFK8S+y7+cWEUgAAALGMUAoAANTYoPO4uDhJS7IW/y0glAIAAIhphFIAACC6lVKO9r2gYeclVEoBAADEMkIpAAAQFfYg8wRHpZRz2DntewAAALGNUAoAAESFx+v7lw1XOZVStO8BAADENEIpAAAQFR6vlUrFh/zbhl0pVUj7HgAAQEwjlAIAAFHh8c2UcoXMlErzVUrRvgcAABDbCKUAAEBU2/fiy2nfyy92c+YBAABiGKEUAACI6up75Q06p30PAAAgthFKAQCAqPD4Vt+jfQ8AAADhEEoBAICohlKh7XspvkqpAgadAwAAxDRCKQAAEN1KqXJmShUUezjzAAAAMYxQCgAARHX1vfiQ1ffSkxLMNavvAQAAxDZCKQAAEBVeb/hB57TvAQAAQBFKAQCAqKB9DwAAABUhlAIAADW6+l5KovWvH0VuZkoBAADEMkIpAAAQ3ZlSIf+2kZxgDTovcns58wAAADGMUAoAAES1Uire5QpfKVVCKAUAABDLCKUAAEBUeMtZfc+ulCp0e6TUtw0AAABij7UmcxTNnTtXvvnmG1m6dKns3r1b4uLipFmzZtKrVy859thjZcCAAdE+BAAAUKuDziVspZTmUSWeUklKCA6tAAAAEBuiFkq98847Mm3aNMnLy5PBgwfLkCFDpFGjRuL1emXPnj2yYsUKufHGGyUtLU2uuOIKGTVq1AHtb9euXXLHHXfIt99+KykpKTJy5Ei5/vrrJSHB+oi6z9tuu03mzJkjjRs3lmuvvVZGjBhRTZ8WAACE8vi68+Jd4Sul7GqppAQKtwEAAGJRVEKpiy++WNq2bSsPPfSQ9OnTp8Jtf/jhB3nttdfk7bfflpkzZ+73PjXg0iosfa/s7Gxzv0GDBnL11Veb5ydOnCiFhYXm+UWLFsnkyZOlU6dOlR4fAACo3vY9DakS4uPE7Sm15kqlcIYBAABiUVRCKa1Y6ty5c0TbavueXlavXr3f+ysuLpasrCy55pprpEOHDuaxU089VebPn29ur1+/Xr788kuZPXu2Ccu6d+8uCxculJdffplQCgCAqA86L9uel5zgErfHI4UlHs4/AABAjIpKvbwGQNu2bavSa7p06bLf+0tKSpKHH37YH0itXLlSvvjiC/+8Kq2MatWqlQmkbP3795cFCxbs9z4BAECElVJhQqmURKuFr8jNCnwAAACxKiqh1Ouvvy7HH3+8aePT23v37pWactFFF8mZZ55pWvdGjx5tHtuxY4c0b948aDutrKpqcAYAACKn7XnKFdK+Z1dKKSqlAAAAYldUQqlPPvlE3nzzTenXr588++yzMnToUPnrX/8qs2bNkqKiov16T50HtW7durCX/Px8/3Y6K+rFF1+UkpISGT9+vHmsoKDAVFM56X1t+wMAANHhqaBSyh52TqUUAABA7Ira6nu9evUyFw2GlixZIh9//LE8+uijJjQ68cQTTTWThlXx8YEVeCqiLXhjxowJ+9zUqVPlpJNOMrcPOeQQc33vvffKueeeKxs3bpTk5OQyAZTe11X6AABAdHgrmSmlipgpBQAAELOiFko59e7d21x0RbxffvlFPv/8c3nggQfMinhz586N6D0GDhwoK1asCPtcbm6uqcI67bTTxOWy/iW3a9eu5nrPnj3SokUL2blzZ9Br9H6zZs0O+LMBAICqV0oxUwoAAABRad8rz+7du2X58uXmsmXLFv9g8gOl7XnXX3+9qaayLV261FRhderUSfr27SubNm2SrVu3+p/Xlfn0cQAAEOVKqQpmShW5WX0PAAAgVkW9UkqHiX/66afm8vPPP0u3bt1k2LBhMmXKFGndunW17EMrnk455RS566675O677zYzpiZNmmSGnmdkZJiLtgredNNN5nGt1vrggw9kxowZ1bJ/AABQNpDyZVLiolIKAAAANRVKrV+/3h9E6TypNm3ayBlnnGGCKLutrrrpDCm9XHrppeb+yJEj5YYbbvA//+CDD5pA6vzzzzchlm7bp0+fqBwLAACxzutr3Su/fY/V9wAAAGJdVEIprVrS4EdnPOlg85oIfxo0aCD33Xdfuc9nZWXJtGnTon4cAAAgME+q/PY9Vt8DAACIdVEJpV544QUzmNweOg4AAGKL1xu4He5fB6iUAgAAQFRCqcGDB/tv63ynN954Q9asWSPFxcVltq2ougkAAByc3I5UqqJKqcISR3oFAACAmBL1Qefjx4+XBQsWyNFHHy0pKSnR3h0AAKhrlVLhQinfTClW3wMAAIhdUQ+lvv/+e3n++eelX79+0d4VAACoY4POdcZ5uNX3khPsQedUSgEAAMSqqA996ty5sxQWFkZ7NwAAoA4OOg8XSKnkRHvQuadGjwsAAAAxVCl1//33y7hx4+Sss86S1q1blxl+PnLkyGgfAgAAqGEeb2m586SclVJFVEoBAADErKiHUq+//rqsW7dOXnnlFUlOTg56Li4ujlAKAIB6HEqVVymV4quUKnTTvgcAABCroh5Kvfnmm/Loo4/KsGHDor0rAABwkFVKFdO+BwAAELOiPlOqcePG0rVr12jvBgAA1MFB5wnx5YVS9kwpKqUAAABiVdQrpaZMmSJ33nmnjB07Vtq2bSvx8da/hNp0zhQAAKin7XvMlAIAAEBthVJXXXWVub700kvNDClbaWmpub9s2bJoHwIAAKit9j1XJYPOad8DAACIWVEPpWbPnh3tXQAAgDrGU1pZpZRVOV3iKRWvt7TcgegAAACov6ISSn333XcyePBgc7tNmzYRvWbu3Lly9NFHR+NwAABArVVKhX8+OTHwRLHHKymu4PZ+AAAA1H+uaK24d/HFF8usWbMkLy+v3O0KCgrkvffekwsvvNC8BgAA1A9e3/zyBFf4f9VIcqRVRSUMOwcAAIhFUamUeuSRR2TevHny1FNPyYQJE6RPnz7SuXNnsxKf1+uV7OxsWbFihSxfvlz69u0r48aNkyFDhkTjUAAAQG2275XTlqePJ8bHmfY9a65UYg0fIQAAAOrtTKlBgwaZy5o1a2TOnDny66+/mqHmOtw8KytLhg8fLg899JB06NAhWocAAABqicdXKhVfwagonStV4nFLkZtKKQAAgFgU9UHnWiGlFwAAEDs8vpypvEHn9lyp3CJdgY9QCgAAIBZFZaYUAACIbYFB5xWEUgnWv4ZY7XsAAACINYRSAACg2nlLIwmlrBX3qJQCAACITYRSAAAgapVS5Q06D6qUYvU9AACAmEQoBQAAorb6XnwFM6WSaN8DAACIaTUSSs2fP1/+/ve/y4gRI2TLli0yffp0+fDDD2ti1wAAoBZ4vZG37xUz6BwAACAmRT2U+vTTT+XKK6+UNm3ayNq1a8XtdktCQoJMmDBBXn755WjvHgAA1NVB54n2oHNW3wMAAIhFUQ+lnnjiCbn99tvlH//4h8THW/9F9LLLLpN7771XXnjhhWjvHgAA1NlB54RSAAAAsSzqodS6deukb9++ZR7v06ePbNu2LSr7vOOOO+Tiiy8OemzDhg1yySWXmGMZNmyYzJkzJyr7BgAAIm570HlcJKvveThlAAAAMSjqoVTXrl3lm2++KfP4O++8Y56rbj///LO88sorQY+VlpbK2LFjpWnTpvLWW2+Z2Vbjxo2TzZs3V/v+AQCAs31PKh90zup7AAAAMSkh2juYOHGiXH311TJv3jwpKSmRadOmmeqpJUuWyFNPPVWt+youLpbbbrutTGWW7lsrpV599VVJS0uTLl26yHfffWcCqmuuuaZajwEAADja9yqslLJCqWIPM6UAAABiUdQrpY488kj56KOPTBB0wgknSHZ2tgmNZs2aJYMHD67Wfemqfj169JAhQ4YEPb5o0SLp1auXCaRs/fv3l4ULF1br/gEAgMXOmeJdrspnSlEpBQAAEJOiXimlmjVrJtdee21U97F69WrTtvfee++Vad/bsWOHNG/ePOixrKws2bp1a1SPCQCAWOWNoH0vOZGZUgAAALEs6qGUVkfFhSnd18cSExNNYHX66afLhRdeWOH7FBYWljsYXd9D2/a0FU/nRoUqKCiQpKSkoMf0vrb7AQCAKA46Z/U9AAAA1FYoddFFF8kTTzxhrrVtT4eO6zypl156SUaNGmUqmHS2VG5urlxxxRXlvo+24I0ZMybsczfccIN4PB654IILwj6fnJxs2gadNJBKSUk5wE8HAADC8VRhphSr7wEAAMSmqIdS7777rtx1111yxhln+B878cQTzewnHXquz/fs2VMmT55cYSg1cOBAWbFiRdjnLr74YhN0HXHEEea+DlTXkKpfv37y4YcfSosWLWTVqlVBr9m5c2eZlj4AAFDd7Xvlh1KsvgcAABDboh5KrV+/Xg455JAyj3fr1k3WrFljbnfs2FF27dq13/t4+OGHTXufTauwtLJKH9fg6fDDDzdD0HUbuzpq/vz5Ztg5AACofh67fa/CSil7phSr7wEAAMSiqK++py17jz/+uOTn5/sf09tTp06VPn36mPtff/21dOjQYb/3oZVQ+nr70rBhQxM+6e2EhAQZMGCAtGrVSiZOnCgrV640AdXixYvl3HPPrZbPCAAAwodSCfG07wEAAKCWKqW0de/qq6+WY445xlRE6UypdevWmZDosccekzlz5si9994r//73v6N2DPHx8fLkk0/KpEmT5JxzzjFhlYZirVu3jto+AQCIZfag8wRX+f/9KyXRnilFpRQAAEAsinoo1a5dO3n//fflu+++k99++80ERNq6N3jwYLMCX6NGjUylVJMmTaptn7oKXygNombMmFFt+wAAAOVze6ygKcEVQfteCaEUAABALIp6KKU0iBo6dKi5OFe/W7ZsmZn3BAAA6melVCSDzot9ARYAAABiS9RDqZ9//lnuuOMOs/qd1+stE1bpqnkAACB2Z0oVu71mtT5XBQEWAAAA6p+oDzq/++67pU2bNjJt2jRJTU01Q88nT55s2vYefPDBaO8eAADUghLff4iKj6B9T1EtBQAAEHuiXimlq9099NBD0qVLFzn00EMlMTFRRo8eLVlZWfLMM8/IsGHDon0IAACghnk89qDzyiul7GHnKYmBkAoAAAD1X9QrpbQ6Stv0VOfOnWXFihXmdp8+fWTt2rXR3j0AAKijq+9pu16ir72vyO2psWMDAABAjIRSgwYNkkceeUS2bdsm/fr1k1mzZkl2drZ88cUXkpmZGe3dAwCAWuC22/cqmCkVNOzczbBzAACAWBP1UGrSpEmyd+9e+fTTT+WMM86QjIwME1Tdd999Mnbs2GjvHgAA1Oag80qGl9tzpbR9DwAAALEl6jOlWrRoIS+++KL//ksvvWRW4tMqKZ0vBQAA6h+3f6ZUxf/9y54rVVRCKAUAABBrol4p1bNnT9m9e7f/flxcnHTr1k3cbreceOKJ0d49AACozUqpStr3kn3DzZkpBQAAEHuiUin17rvvyttvv21ul5aWmja90Kqo7du3S7NmzaKxewAAUEcGncdX2r7nq5SifQ8AACDmRCWUOvnkk2Xjxo3m9g8//CB9+/aV9PT0oG3S0tLMdgAAoP4OOk+spH2PQecAAACxKyqhlAZQ48aNM7fbtGljBpwnJSVFY1cAAKAOz5SiUgoAAAA13r7nnCE1a9ascrcdOXJkNA4BAAAcDDOl/KvveWrkuAAAAFDPQ6nHHnssou00sCKUAgCg/imxQ6lIZ0qx+h4AAEDMiUoo9cUXX0TjbQEAwEHC45splVDJTKnkRAadAwAAxKqohFKhdKW9mTNnyurVq8Xj8Ujnzp3lvPPOk44dO9bE7gEAQG3NlKqkfS8p3g6laN8DAACINRX/58tq8NNPP8mpp54q33//vbRt29ZcfvzxRxkxYoTMnz8/2rsHAAC1wB1p+16iPVPKqqwCAABA7Ih6pdT9998vF110kdxwww1Bjz/88MPy0EMPyauvvhrtQwAAALUUSkW8+h4zpQAAAGJO1CulVq5cKaNGjSrz+LnnnivLli2L9u4BAEANKy0tFa8vlEqsbKaUHUrRvgcAABBzoh5KtWnTRhYvXlzm8UWLFknTpk2jvXsAAFBLVVKRzJRKTqB9DwAAIFZFvX3v8ssvlylTpsiaNWukT58+/kDqpZdekvHjx0d79wAAoIZ5HKFUpTOlfJVSxcyUAgAAiDlRCaVKSkokMTHR3D7nnHPM9YwZM+SFF16Q5ORk6dSpk9xzzz1y+umnR2P3AACgFjnnQ9mr65WH9j0AAIDYFZVQasiQIXLaaafJmWeeKQMGDDDBlB1OAQCA+q3QNx8qMT5OXJWuvmfPlGL1PQAAgFgTlZlSkydPlp07d5rWveOOO04eeOABhpoDABBjlVIpida8qEhmShWWWEEWAAAAYkdUKqWGDx9uLrm5ufL555/Lxx9/LOeff760a9dOzjjjDDnrrLOkffv21brPX3/9Vc4+++ygxw499FB5++23ze0NGzbIrbfeKgsXLpTWrVvLLbfcIkOHDq3WYwAAAIGV9CIJpVKTrG0KHC1/AAAAiA1RHXSekZEhI0eONBcNqD777DMTUD399NPSo0cPE06NGTOmWva1atUq6dmzpzzzzDP+xxISEvxLU48dO1a6d+8ub731lgnKxo0bJ7NmzTIBFQAAqD6F/kqpyguy0+xQqtjNVwAAABBjotK+V15ApZVMGkhNnz5d3G633HfffdX2/qtXr5YuXbpIs2bN/JfGjRub5+bNm2cqpe68806zzVVXXSV9+/Y1ARUAAIjOTKkUX2teRVJ91VQaZHkdq/YBAACg/otqpZRNK5V+/PFH+fTTT02VUn5+vpx00kly0003VWsopdVX4SxatEh69eolaWlp/sf69+9vWvkAAED1sudD2UPMK5KWFPhXkYISj6Qn18i/mgAAAKAOiNq/+Wkl1Ny5c03L3uzZs00QpUPPdQj6scceK0lJSdW6Pw2lvF6vaQnct2+f2cfNN99sKrR27NghzZs3D9o+KytLtm7dWq3HAAAAAu179hDzitgr9GmVFKEUAABAbIlKKKUVUF9//bUJogYPHmzCoZNPPlnS09P3+z0LCwtl27ZtYZ9r0qSJac9r27at3HvvvZKTk2NaA/U4nnrqKSkoKCgTgun94uLi/T4eAABQ8aDzSCql4uLiJC0xXnKL3JJf5BHJ4KwCAADEiqiEUps3b5brrrtOTjvtNBMYVQdtwStvKPrUqVPN3Kjk5GRJTEw0j91///0yatQoE2Tp49nZ2UGv0UAqJSWlWo4NAACEGXQeQaWUPexcQymtlAIAAEDsiEooNXPmzGp/z4EDB8qKFSsi3l4HmisNpVq0aGFW53PauXNnmZY+AABQfTOlUnxDzCuTaq/ARygFAAAQU2ps9b1o0sCpX79+poXPtmzZMklISJAOHTrI4YcfLkuXLjUtgLb58+ebxwEAQLRCqcj+NcNegS+/yM1XAQAAEEPqRSjVuXNnEz7deuut8ttvv8lPP/1kbp933nnSsGFDGTBggLRq1UomTpwoK1eulOnTp8vixYvl3HPPre1DBwCg3skptMKlBilWS31l7BX3qJQCAACILfUilHK5XGagua60N3r0aBk7dqwZsH7LLbeY5+Pj4+XJJ580q/Cdc8458v7775s5VK1bt67tQwcAoN7JKSgx1w1TE6vUvpdfzEwpAACAWBKVmVK1QSuhnnjiiXKf10qqGTNm1OgxAQAQy6FUZkpCldr3CgilAAAAYkq9qJQCAAB1R06hL5SKsFJKV99T+cXMlAIAAIglhFIAAKBa5RS4qxRKBVbf8/JNAAAAxBBCKQAAUG2K3V7/wPJI2/fsSqkCKqUAAABiCqEUAACoNjtyi8x1coJLMnyr6kU6U4pB5wAAALGFUAoAAFSbrXsLzXWLzBSJi4uL6DVpSVZ4le+rsAIAAEBsIJQCAADVZntOIJSKlD1TqpDV9wAAAGIKoRQAAKg2W/2hVHLEr7Hb9/KYKQUAABBTCKUAAEC1Wbcr31y3b5IW8WsyU6xV+vYVWqv2AQAAIDYQSgEAgGqzZmeeue7YND3i12T4VunLK3KL11vKtwEAABAjCKUAAEC12JVbJHvyikXnm3fMqkIo5VulT/Mohp0DAADEDkIpAABQLRZv2muuuzTL8A8vj0RSgktSEq1/JdlXWMK3AQAAECMIpQAAQLX4ZaMVSvVp27DKr7WrpXKZKwUAABAzCKUAAMAB01lQP63bs9+hVAPfsPMcQikAAICYQSgFAAAO2C+b9pp5Ulrx1Kdtoyq/3h52TvseAABA7CCUAgAAB+yTpVvN9ZCuWZIYX/V/vWjgC6Vyi9x8GwAAADGCUAoAAByQzdkF8u2qneb2sMNa7dd7ZPra9/bRvgcAABAzCKUAAMABefWH9eItFenfobF0bpaxX+9hDzqnfQ8AACB2EEoBAIADWnHvyxU7JC5OZPTA9vv9Pg1TrUqpvQUlfBsAAAAxglAKAADsl735JfLIZyvM7VMPbSndWjTY7zPZMM0KpbLzCaUAAABiBaEUAACosiK3R+7/eLnsyi2WNo1S5bIhnQ7oLDZOSzLXhFIAAACxg1AKAABUSbHbK/fNWi5LNu2V1MR4mXD6IZKaFH9AZ7GJL5TanVfMtwEAABAjrKmiAAAAEcjOL5Z7Plwmy7fuk6QEl9x2Vi/p2DT9gM9do3SrfS+3yC0lHq8kxvPfzQAAAOo7QikAABCRRRuy5V+f/yY7c4slPTlebhnWU3q3aVgtZy8jKUFcrjjxekvNsPOmGcl8KwAAAPUcoRQAAKjQvsISmTFvvcz6ZYu537pRitx6Zi9p2zit2s6cBlKN0xLNjKo9ecWEUgAAADGg3tTGl5aWymOPPSZHH320DBgwQG699VYpKiryP79hwwa55JJLpG/fvjJs2DCZM2dOrR4vAAAHw+yodxdskite/MkfSJ1+WEv51wX9qjWQCh12vocV+AAAAGJCvamUeuaZZ+Tll1+Wf/7zn5Keni433HCDPPHEE+ZaA6uxY8dK9+7d5a233pLPP/9cxo0bJ7NmzZLWrVvX9qEDAFDnKqM++mWr/HfxZv9qeDo36vKhneTwdo2itt8m6faw88B/VAIAAED9VS9CKY/HIy+88IL84x//kMGDB5vHrrnmGnn33XfN7Xnz5plKqVdffVXS0tKkS5cu8t1335mASrcDACDW6X/AWbo5Rz77dZt8u2qnFLm95vGmGUnyp4Ed5MRDmpsWu2hq1sCaI7V9H6EUAABALKgXodTKlStlz549ctJJJ/kfGz58uLmoRYsWSa9evUwgZevfv78sXLiwVo4XAIC6EkSt3pEn89bskq9W7JBtOYX+57Qy6pwj2sgxXZtKQg2thNfcF0o5jwMAAAD1V70IpTZu3CgNGzaUn3/+2bTvaUB1yimnyE033SRJSUmyY8cOad68edBrsrKyZOvWrbV2zAAA1IbCEo+piPrp990mjNKV9GypifFyTLemcmLPFtKzVQOJi4tuZVSo5g1SzPX2HCqlAAAAYsFBE0oVFhbKtm3bwj63b98+8/wjjzwiEydOFK/XK1OmTDHXOvC8oKDAhFNOer+4OPAv4gAA1Ndh5b9t2yeLN+6VxRuzZfnWfeLxlvqfT05wSf8OjWVQlywZ3DlLUhLja+1YW2TSvgcAABBLDppQSlvwxowZE/a5Rx991IRSkydPNivvqQkTJsj48eNl0qRJkpycLNnZ2UGv0UAqJcX6L7IAANQHXm+pbN5bYEKoFVtzzfWanXnm8dDZTYe3bSSDOjeRvu0bSXJC7QVR4WZK7ckvlhKPVxJrqG0QAAAAteOgCaUGDhwoK1asCPvcDz/8YK47d+7sf6xTp05SVFQku3fvlhYtWsiqVauCXrNz584yLX0AABwsCoo98vuuPFm3K09+35VvrtfuzJO8Ik+ZbRulJcphbRpKn7YNzep5LTNTarw1LxINUxMlKcFlqrt25hZJq4aptX1IAAAAiKKDJpSqiA4xT0xMlOXLl8vQoUP/n737gI6ibL8AfpNNLyQQEnrvHQRBFMSCKKJY4fvsvfztir1jVyyfvfeGHbvYEWxIF6SD9B4SSC+b/7nv7OzObjbJBkLq/Z0zZ3dnZmdnZxd0L8/7vGbdypUrER8fj+TkZPTr1w8vvPCCqaayq6Nmz55tmp2LiIjU5kbk6dkF2JiRhw0ZudiYkWtuGUBtKaPvUqQrDJ1SE9CteSK6Nks0t2wgXhtDqEA8R57r+p255v0plBIRERGp3+pFKJWQkIDx48fj7rvvxoMPPmj+J/7hhx/GuHHjEBERYYb0tWjRwvSbuuSSS/DTTz9hwYIFuP/++2v61EVEpIFjVdC2rHxs3ZWHbbvzzcxzGzLyTAC1KTMXeYXuMp/bJD4K7VPi0C4lHh2axqNdShzaNomrttny9oVmjWJMKLU5Mxdok1zTpyMiIiIi+1C9CKXsHlKTJk3ChRdeaEKpsWPHYsKECWaby+XCM888Y/pLnXjiiWjXrh2efvpptGzZsqZPW0RE6jE2FM/IKTA9kjjL3dbd+SZ42ro7D9t25ZswKiOnsNxjhIcBaY1i0Co5Fi2TY9AyORbtmsSjXdM4NIqJRH3TunEsZq/ZaYIpEREREanf6k0oxdn0GDpxCYZB1FtvvVXt5yUiIvVPflExMnMKkZ5TYIbX7cy27u/Mth6bdTkFyMwtRIl/j/GgYiLDkZYYYxp9c7ECKCuEYuVQQ2r43aZJnLldl55T06ciIiIiIvtYvQmlRERE9gRnpssuKDIB0q5cz21eoeexZ8krMrf2tvKG1AWrdEqOi0JKfJQ3dOLCECqtkXU/MTqiTvR8qg5tGluh1FqFUiIiIiL1nkIpERGpN8FSVn4RsvN5W4ysPOfjcu7nFcEdQjVTIFd4mOnp1DguCk3iI9EkPtrcWo+j0DjeCqI4xC6cyZSEpE0Ta8Y9DnfMKShCXJT+V0VERESkvtL/6YmISI02+c4tLEZeYbEJiXg/t6AYOZ6F6637RWZ9ruexfd8Olrhub8VGuZAUG2lCJHMbG+F93Ci29Lq4KJeqm/aBxJhIJMdFml5b7CvFGQRFREREpH5SKCUiIhVWIeUXuU0fJd4yKOLwNd7aj33r/dfl+21zI8eETlaIxFCpqHgPSpQq6M0UHx1hFg6JK33fhcSYCMRHedbzfnSECZmiIhpO36bajjMIZuRk4t/t2QqlREREROoxhVIiInUwJCoodltLkWPxPGYIVOjc5rifX+xGYcA63/OKkc+wqcg/dOK2fS06ItxUKrH6iMO1YiLt+y6zPtbzODYqwtyPj3IhJoq3EUgwIZPLhEsNqSF4fdYpNQEL1mdi+dYsjOpV02cjIiIiIvuKQikRkRBCoCKzMNApQSFvi92myoe3hZ5b7mM9dm5zrC+yjmOv5/OK7Ps8vmddgSc48guXiq3HvF+8Jw2QqjA8YmDEiqToCJd5HO15zPX29sD9zPYIT8DEsCkywhtCMWRSzyVx6tIswdyu2JqlCyMiIiJSjymUEpFqUVLiCXYYxLitYIWPvbdlrGdQ47ef2wp8igIel72/b73/Os9jz3NNEOTZp4CBUhGPY4VENRkChdJsO8rFYCjcVAnxPoeheRdui/Bsc6zzbnM8j/dNkMSwyRMiOW+5j8IjqQ52H6nV27NNEKuhlSIiIiL1k0IpkWoKZJhrMNxwl5SghPfNuhJThcP15rHbWs+AxrndDlL42L41YYrjOeXtZ45j1vEcrOCFrXzMa3v2LQ54rnexz9HzfPu+9/Uc78G8nh36eIMi6/Vqca6zR0FQpCsMEeHhiDThTphnnRXcmPue0CciPAwRZr11G+EKC1hvreNz/Y9pBUcMlKKcoZJjfaTntUTqm7TEaNNUfldukQmmujVXs3MRERGR+kihVAMMR6xbgPfssILBRgmsEMGsd/uCE946gxQTsLgdz+WxPLf2Ovs59jrvdk+I4bfdE2bYoQ33LfY7ri94Mds8r23dd76GL+gx9+3jOvaxj+l8njOw8b5e4HkFvJ7z/VrnXDpwst6Hta/nsksA5ikMVUxYE24FO9atFdA4H1shjuOxHQQFPA48jvexJ/DxbvMci+vsUIiP7XDIuvVsM0GRZ9/wMFULiexjYWFh6JKWiNlrdmLJ5l0KpURERETqKYVSDci69Bw88v53OHrnm5gTORDLIrphW3gq/++/pk+tweOQKJcnoAkPs0IU7xJmhSCugPXWfv7PsW/t4MT5XIYr9nOcr+G971znfczjM8ixfiSa49jbA1/P+3zr+CYA8oZIvlu7usc+NxGRYPq0SjKhFBueH9e/lS6SiIiISD2kUKoBYc+cntl/okPRarNQVngi1rtaY3N4c2xytcA/ET2RHW4NkzB5gQkifIEEGJyEhZkci8EC13O/cM+t/2NrP3ub9di6H/hc67H/fRNa+B3XCjzMuYSXfh37mNbzPNs8+wU7V/u5pV6b790R+nhf2+917OvgO77z9fzOy34fnrCm1H3P+xMREZ9+bZLM7d8bMk0lqoaqioiIiNQ/CqUa2BTbrc67Au7lvRCx7le4ti8F3IXoh3WsozKBk/v4MQhP7WbClLDl3wL/TgcSWwKJza0lPg2ITwFiklVhJSIi+0zHpgmIj3YhO7/YzMKnvlIiIiIi9Y9CqQYmJrk5sP9p1lJUAGxfBqSvAnb+a5bwJu09JVIAtiwEVk8PfiBXFHDyy0ByW+vxhtlA+mogPtWzNAViGwOuyOp7cyIiUm+w8rRf62T8tnKHGcanUEpERESk/lEo1ZBFRAHNe1tLMN2OBhp3AHZtBHZvArK2AtnbgNydQHGBFTrZVk0D/vm09DGiE4G4FGD0Q0BiM2vd5oXWMeOaWMfgbXQSf4HsozcqIiJ10ZCOTUwo9dvK7Th1iOcfQURERESk3lAoJWVL62EtgYoLgeztQFSCb11qN6DjCCB7B5C9FcjZAbiLgfzd1hIV59t3+VTgn8/8jxkW7guojrwfSEi11m9aAGSut7bFJlvDBmOSgMhYDR8UEann9m/fxBTvrtmRg02ZuWiRFFvTpyQiIiIiVUihlFQeh+Q1auG/rvsYa7G53UDBbiAn3VqcAVZSW6DVQCDXsy0vEyhxW0EWFwZONva1Wvx5kHOIskKq454GEtKsdWv/tIYj2uGV85avr2biIiJ1SmJMJPq0TsL8dZn4bcUOnDSwdU2fkoiIiIhUIYVSsm9wKB4rmrg06eC/re84a7EVFwF5GVZAxaAqKt63rXF7oM1gIDfD2oe3HDrIhcMJIx0VWGzKHizAsiux/vuOL0xb9i2wcQ4Q3cgaYsjzNLd8nGT1yuLwRhERqVEHdWpqQqkfl27Fifu10mylIiIiIvWIQimpea4IqzE6l0B9TrYWW0kJUJhrVVcxpHIGWM37Au4i/wCL+xXmWJVYDJ1smxcAS78u+5xOmewLsOa+Daz4zgqw7NDKGWRx2KJ97IIcnqQVlqkyS0Rkrw3r0hQvTl+FtTtysHxrFro2c/xdLiIiIiJ1mkIpqVsY9LA/FZfAIYRdR1lLoKJ8IG+Xf4DV8VAgsQWQv8vaxlvnfWeAtXujNbNgWTgU0d5/zhvA/Hetyiy+Htdz4fDB6ARg6GW+4YbblwMZa4Ao7pPg2C9RsxaKiDiG8A3r3BQ/Ld2GqQs3K5QSERERqUcUSkn9FxHta5xuaz3QWkLR71Sg42FW9ZVp3O4Ir3jLiilbYbZ1y8osu8m705D/891f8YMVYJV1zsc/C6R0sh6v+hn4d4Yv3OItq7EYfPF+s17Wens4JEMxzWYoIvXEqF7NTSj187JtOPPA9kiKjazpUxIRERGRKqBQSqQiSa2sJRTDrrGqoexAqiDbc5tl3XIWQRsrvVoOKL2fXd3l7Je1dQmw/LuyX/ekl4HoztZ9Bl2zXrae7wyuzG08MOhcILmNte+OlVbFlqk+iwciPfvYz2FTew1DFJEa1qtlI3RKjcfKbdn4fP5GnH5Au5o+JRERERGpAgqlRKoSAxxWOXEJ1iPLqedx1uJkZi3MskIqe5gftTvQCrRYncVt9lLouXUONzQ9tEp8+2Rv83+N/qf67q/9HZj5YtnneMxjQKv9fNVaCz/2hFexvtCL97muw8FAYnNrXzatz97u28bbiBgFXCKyR8LCwjBuUBs88PUSfLFgI04Y0Arx0fpfGBEREZG6Tv9HJ1LrZi30NFR3atHXWkIx8Bygz7jg4ZUJu5r59k1obs1uyAbtdhhm9mfDdljVUrbMDcCm+WW/bkpnXyi1ehow43/+2zmk0IRZscAhN/uGT26cByz5wrONAVaM59azLxvY28MvC/Osc2PQ5YpSyCXSgAztmII2TWKxLj0X789ah3MOCpjZVURERETqnHoRSv35558488wzg2776aef0LJlS6xbtw633XYb5s2bZx7ffPPNGDZsWLWfq8g+FxEFRDQB4ppUvG+XkdYSiBVbDH8YCtk6DLdCJ85+aBaGV7meECsXiHf07Qr3zKjIsKso16rcYp8tO/RyYrP38oYmjrrbF0qxr9aPdzuq0hhcxfhuB18EtB1ibeewxH8+9YVb3IcVbKa6KwZI7e4L0Rh2cfikfSzOCCkitUp4eBjOPagDJn7+Dz6bvxFH9W6OFkmOv6NEREREpM6pF7+8BgwYgBkzZvitu+qqq5CcnGwCqJKSElx66aXo2rUrPvroI3z//fe47LLL8NVXX5ntIhKkYstunG5LbmstoehxrLXYAVdRnifIyrGWpNa+fdN6AQdc4tvGxYRZeVaA5Qy7ivN99xl02fvb+Bxbxlpg8edln+MhNwLdRlv3N84FvrnRt429tDjckAsDrYFnA50Pt7bt/BeYP9m3zXnLJa277zox7Nq9ybMt2rePmtCL7JGB7RpjQNtkzF2bgeenrcIdx/Y0Q/tEREREpG6qF6FUVFQUUlN9P1y/+OILLFu2DFOnTjWP//jjD1MpNXnyZMTFxaFTp074/fffTUB1+eWX1+CZizQADGBMI3U2bk8pvb1pZ2sJRfcxQNfRVvjkDbpyffft2QqpcXtg0DlWMMRqLXvoH5vI83G8o2eXu9AaXshqLioutBZ79kQ+x7Z7C7D067LP8cDLfaHU9mXAZ0H+juHQQ4ZU+50F9B1nrctYB8x4NCDAigZcnh5l7O3FxvjE0G7D7NL72resBmPFnEg9wwDqguEdceXkuZi9ZiemLtqMo3q3qOnTEhEREZGGHEo5FRYW4n//+x8uvvhiNGliDV+aP38+evbsaQIp28CBA81QPhGpyyFXORhQOUOq8rBJ+wU/WkGUN/BiFZbnvrOyizMxDr7QF3R5bz1LouMHMkOumCRPEOao4iousBaU+NblZQIb5pTzvl2+UCprM/DtrWXv2++/wAH/59l3K/Dppf4BF0MxOxhrOxTofrQv7OLsjd59oxz7xljDHe1rygo4VoHZx+ESHqkqMNnn2jSJw1kHtsdL01fj5Rmr0aNFI7RLideVFxEREamD6l0o9fXXX2P37t047bTTvOu2bduGtLQ0/9+rKSnYvHlzDZyhiNRKpkdVlKfCKKDRvBMDqgG+v1/K1bI/cNZnvuGGDKJMeOUJqaIb+Yddh9/m22Zu7SUPSO3hOFcX0Ky3LwhzPoevwYDIxnCNwVRZnI3v2ex+zhtl79vjGODg6zzHzQYmO2ZytNkhVufDgOETrHXuYuDzK4KHYlxSugDdjvIdY8mXVsDFz8LcMvCKsG55zXitbKxm47EUiDUox/Ztib/+Tcf8dZm4+4vFePQ//dAoJrKmT0tERERE6msolZeXhy1btgTdxqF7dhXU+++/j5NPPhkxMTHe7bm5uWaInxMfFxSwUkFEpLpCL08IE0xsY6BzkKbzwTRuBxz/dPBtrGCyhyESK7dOfMEa3mhXaNnhFW+bdPTty3Cn1wm+7ezhVeS4beQIg1hVxmGCDMOcr2e/RnGRbx2Pt3lh2e+n4yG+UIrnP+2hsvdtMwQ42rH9rZN9VWgMrkzgxdtooHkfYOQdvn2/9YR+7BlmlijfLd9bn5N9+y79xhfweY/r2T86EWjaxbdvTro1/NPeh1Vt6nO0z5ueX39Ud1zz3jxs2ZWHiZ/9g7uP74W4qDrzvzUiIiIiUpdCKQ7BK2uGvaeffhojR47Ejh07MGvWLDPLnlN0dDQyMjL81jGQcgZXIiL1gmmizsWDoUpqt9CeG5sMDLsqtH05u+O5X/sqoUyQZYdYDHMcf78yyDniLv9QzBt8FQCNO/j2LSkG2h3kC8VMfy876CoE4gL6kplhkB7uImsp9DzO3+W/L4dHshosGFaeOUOpv14EsrcH35dB3rhXfY9ZBcaeYDYGUnZAldQGOOFZ37Yf7raGPTLocoZorPTi9T/oSt++/3wG5Gy3tvEa2vvzljNFdjrMt+/2FdZQUr99Iz2PI6zQs55hZdTtx/TCDR8twLItu3HHp4tw59heiI+uM/9rIyIiItLg1Zn/cxsyZAiWLl1a7j7Tp09H69at0a2b/w+wZs2aYcWKFX7rtm/fXmpIn4iI7AFWBpkeX2X0+WI40nFEaMfivkfdF/prn/etI7gKCLACq9JGXGf1/+J2Nrcvsm/zgYSA/x60OQDIy/A/nn3bKGDWVlZ3OXGoph28BYZgO1ZYMzgGw5kmnaEUG+pv/Sf4vqzWcoZSfzxjNb8PhgHVBT/4V4ytmxkkvPI8ZmUdP1Oa9y6wdZFneKRnX3t/Ph50rq+pPo/JWS/5XHu7eY7ntvVg3767Nll91Jzbva8RAUQlhtSfrG1KHO4+vjdunfI3lmzejes/XIDbjumJ5kn6RycRERGRuqDOhFKhWLBgAfbbb79S6/v164cXXnjBDAG0q6Nmz55tmp2LiEgdZockZQVigcMEQ8UAK1SnvGMFU3bAxWotc2uXbDkMuxooyPYEY0VWyMX9eMsqqMDzTe1qDYW097f3dVaiESvI2O/MeTxz/ILSx/X2InM033fiUEQbQ7HV08t+7wPP9t1f8T2wzJr1NqgzPgEirAlITEP9fz4te99TJgONPJMG/Pk88PeHnuDK5QjSrDCr81H3494T+uCuz/9Bs80/4e/nH4a7TQpaNk707W8v+53pO+6m+cD6WY5jRfrv3/YAqyKQdm8Gdq7xPwfvfReQ0Nw3+YI906ffPhHWddWwThEREZH6G0otX74cw4cPL7V+8ODBaNGiBW666SZccskl+Omnn0yAdf/999fIeYqISD3Dqp7wcnqGOZvfh6rff0Lf97Bbyt4WWMl16C1WjzE7vPILsor9g5OexwOt9w/Y1w7TijyBoEdaT996HscO0cz+Rf7XhpVerAyzh1w692elGUMcm7darYw+kCVudEpNwKPj++GnN79E++1Lkb0C2BQTgaYJ0YgMd7wf9kyDJ5Ta/Hf5jf3HPuELpf6dAfz2ZNn7jn4IaDvEur/yh7L7ojGgGnmnNeOnfdwZj3lCK0/A5Q2xXFYlmn3cLf8Ac9+0wq3AcIzruhwBtOhn7Zu5AVg+1XPMgGCMt816+WbSzNtlBXTeEM2zj/1cVhHa14Gfb84O37maoC3wfDxVdiIiIiINLZTikLxGjUrPmuVyufDMM8/glltuwYknnoh27dqZPlQtWwYMwRAREalvAofBsXcVl1C0ZkVxiFXFvY63llAMvsBaygrRnMHYwHOAPuMdIZcnwLIDsHhr6GVKQjSOO/kMTP+zG35dthnhJcWIynVjYJsEDGrTCI2iw4D4pr7jNu1qhVT2Mb2BmmeJSfLty/tsbu8N0Iqt/mf2Y2fgxsdlMaGf4/MoyCm7d5k9u6SN/cXW/Fb2vuwdZ4dSuzYCs18ve9+hl/lCqYw1wLe3lr3v/udZFWbEarGPzit73wGn+z7XzPXAh+f6B1jm1vO429HAwLM87y0d+PoGR8DFsMt+TgTQZrCv5xsD1V8e9j+WNyBzAandgS4jfd+leW85zoG34b7HiS0933EPVgV6g7aA/RmkNnH0v7P7yDnPw34uqxPtyjnvdyIspCGpIiIiDU29CqW+/trTdDcIBlFvvfVWtZ6PiIiIVFLgD/foBGsJQWRqZxx2TGe025aFV2asxh/rM/HLZiB8CzC4QxMckujGwHbFiIl0WUEHl1CwColLKHqOBXoca81KWaoSrBiIcfzjGYcInviif8Dl3bfICs5sKV2AEdeX3s9+blNHP02GbyZwc762vW8xkOSYSTMi1mr07wzk7P24RDmuPd8TAzj7mIGcgZs9jLUszn5rDAS3Lyt7X2fPN1bMcahoWbqMcoRSRcBfL5e9b4fh/qHUd7f7zybqxIrBMQ/7Hn98oTVMM5jmvYHjHDOkvn2yFbyRN/DyhF1NOwNjHVV4n14KZG0L2M9zn7OpHnmvb9+fHwR2b/QFeM7nMHg+2DEMmSElh6Haw0id5xAZa4WPtmXfAln2vs5jc4m0vuPOCSRM9Vx46YWvwV5y9p9phpoMWgPP1V44MYS9Lyv4+L3guXr34X3P7KYcwmyH16yu1NBYEZE6q16FUiIiIiIcznfP8b0xZ20GPpm7HvPXZeKPVelmiXSFoW/rZPRs0Qg9WzZCh6bxVT9jn/3j2QxlK2dIJwMqZ0hVHvbCajQmpF1LGrdHyYFXwl1SAncJzC1/txeb2xKrBVp2gbU9ug3chz3i3R5URq513IjWwIlTHC/k9oRvxQgrKYY7LAJI9wQ17iYIP/o1hNlVZSVus49VZeZGSWwy3DtzEMZrVRSNqOF3m/3CzH48bhHC3NZz3I1aoWiX1QMtrKgE0f0vtI7l3bcYYSZMK0Fxk44oyrLCMK6L6XQUwvi+3EXe55jnuYtRnNQVhblW77cwlCCmaQ/reOYci3zHdxfDHZOCogIriAtDGKIi46173vdU7KnyA0oQjuIiX7gV4RlCayIUHq/YEXwV5qHEXeLNVMJYOZe1JfjnEBgEsudbWRMnBE7ewCq7bUuC78vvoDOUWvolsHFe8H1ZBeYMpRa8D6z9HWW64Cff/dmvAisdjwOd87WvwuyPZ4GlX5Xfo84eVvrr48CiT4IHY1xOesnXS27Om1Y/O7+wyxOE8c/rqHuB5DbW48WfA4u/CAjFHM856AqgcXtfld2yb0qHZ/a+/U7xVdrx2q7idQg4nr10PRJo3M7ad8dK67MLFsxxYehnny8nkNg41/P3jl2Z5wkgectqysTm1r65O61ZW4O9Lz5mAGpfX1Z0svrSfk2/8w6zKklZSUgMEnMzHMf17Gs/h98fe8IL/rngnxvv8ezjB8e/u6zbgPXObd59ndutv/98x/Gttx87j+E7pu+BvW+w/QNf0+zr2cf/Of6v53xfe3V+ge8vyOsFHrfUNazo/AJez/94nueUcX729ajw/AJez/85vnPe4/ML8hnazw92LUpftxDPr4zvn+/0Sn9vSuxjOtax88Ah3dLQvin/W1P/hZUEfhJSSlZWlmmKzuboCQmh/WutiIiI1A5rd+Tg+8Vb8NvKHdjiCTecGsdHoU3jWKQmRqNxXBSS4yLNLSuqYiLDER1h3brCw6wQxYGPGO4UFZegyO1GYXEJit0lKCh2W+t46y5BYbG1jftwvf242POcQsd+RY7HfH5BqeO4zWt4n+c5LgMoEzrp/+xqjAnVUAI3gwOP2JIchHvWu1CMMLgRzuiqxI3iMBd2hnt+/LPjWfFGRJYUIpz7hHmeU8L93SgMi8TqiE7eH+7dCxcjtiTX2tdEYdzfbY5bFB6FudFWJSB33y9vJhq5M/33gxsuz3F/jD/a2hdhOCjnR6QWb/Ye196X9/mMj5J9ExwcnvU5WhesRnhYiQn/rP2shef+QtMbrTCOrdd2vY/OeYs858DrYF0DHp/3H292P4o9EzMcs/MN9M35w+wbzBMtJyE3wgpCRqW/iwFZ0/w/B8f951vfj90RKeb+iJ0fYv9d3wbs69v79VZ3Ij3Kau8xdOdnOCDjC+82v5+NJcBbLW7C5mgraNo/cypG7PzIudnPu2nXYG2MVfk4YNfPGJUxGWV5L+USLI/pY+73zf4Nx+58s8x9P2x8Hv6JHWj+3PfMnY2TM8quDPyk0emYGzvU3O+avxCn7Xy2zH0/TxiHP2KtWXM7FCzHeZmPl97J8ya/jj8Ov8SONNenddEaXJbxiGOz/5X4NnY0vosdbX50NyvehOt2le7va33TgJ+jDsUXsVYAmuxOxw27H/R8G61gzO0JyLhuZuRgfBl7rNk3zp2Na7Ietr7pnn3s53DfhZG98VXMMWbfiJJCXJb9pFlvL9a+Vri8IqIzvo05yntu52e/4Nlm72sFmry/3tUaP8T4KmrH5bxn/rw7j10SZt1uC0/FL9G+yVeOzPsaUSWF5n27PSGp9ZxwZIQl4Y/oA737Hpj/K6Jh/XfMPq713oDssATMjhrk3bd/wVzz94/ZJ8z53sKQHxaDBZGeId8AuhUuQZxnX9+1tfYtQgSWRPb07tu2aI05rnMfHt++Jqv495RHs+LNiCnJ8+zneW+efblsDG/p/TstyZ3h2dd+X77vA/fZGdYYJZ7rE+vOQSQK/fZ1Xuu8sBjvvvycuTbYfvbj2lhteUDHJrhljO+61+ccRZVSIiIiUq+1TYnDucM64JyD2uPfHTn4e0Mm/tm4C0s278KOrALszLaWhsQqSggz/xobHhYGl1lh/etspY7j9/M/NGX9C3ngvzwH2yfwX+ODH6fsffY1/ggKfKncsDj/lKQcm1wV9Dt1/DP8P67u5e/rqNb6zTUIKK8Hfb6vF9pU18Hl75vjm1n0o/CjgIDJQP1k+f5cvRl+PBBXTt+5LJ6v9WP7pfDxQMJ4a32J/fPcCq+4FGayWsiq4Hur5Ci8F3e4Y7snTPOEZDt2RsIdlm323eE+EN/F9DHhoRW4+R973c5oFIRZQ0szintjVlSzgGP6grolmfHICbeOm1/cAesiT/Ycy7e/9TPcjUVZCcjIsc43rKg5CiJGecM4K5iDCepoWU4CtuRb1yGmKBnTXUO85+e8Bnzev3kJ2OYZJruhKBYLw/md4Dbf+7LPYVNBHDJKrM9uR5EL68JaBhyTlYFWhLOzKApZ+VZl3u6iEmQg0fd+zPfP9z5zisORW2ide0GRG0WmgtA6TiC3CdpLvPeD/bn0RUg+fK3okoB/UHA8Nxq+ocJ8P03cnuGyQax1tfXeZ2jEgKUsWWHO4csl6Fm0yHOOpUWHFeIXl2/L4KK/EMmKyyBWRXXGrKjDvTnIIbtnIK7E+i4F2hjZDkvirICQf2ePzv4BSUHeH/8u3hbRHOsSD/Ie97gtU9G0yFd56cxdMl1NkJ52gHf9+M3foFmB71o432OOKxHPtHjE+/z/bPoKbQqWBz3forAoPN36ae/zj9v0CtrnLCx9UI+nu7xs/fcIwFGb3kbH3bODHpfv/ZWuz6KIk8pwzpZNH6FLZvA+izzWu92fQH6EVYk8dOPr6LbTv0rTeSofd38YOVGp5jwGbHoPPbZ94xdUmTDNE9RN7ToRu2Namoc9tnyB7lu/8oZmdvBpV1/+2vlaZMa1M5s6bPsBXTd/6akMtM+AQaW175wOFyEzsbO532rH70jb/Q+aDLkJDYUqpUKgSikREZH6KTu/COt35mJDRo4VUOVwKURGTiHyC4uRX+RGflEx8gpZqeQOGoLwfy2jIsIRER6GCFe4GSIYEW49jnSFI8Jl3bLSKtK53az37OPd1397VODzHPva+0VGhJl9GC5ZC0fuWHGRvT7MET7ZgVRDFmwoUGDwVdZQoMB1Fe0TSqBmrwgcYlLeefnv479zefuUCvHKuB5V8r6CXK/SYWKQfcrZtkfvq4zzCv5+fD/e7T8l/n9crAel9yldRWnvZ4e3Zf2x8x2r9H5lbQs8lLW+on0824McN/D1Sr2+Y0PgdSnr/Zmhs0yoGJKZ++EIc3kSTw5lLWQVoV1rY+9nVc+VsNeZp6cdh9uGcVirfSxP2GYN33UD0UneIathxYUI27EcYZ7qPbtPnHffuBSgSXvrnHncdX9Yn5E5D+7j2ZfHT0gFmvex3ju3L/X0L7aPZc6Z90uAhGZA+4P8h7aaYcWe7d7ncHhtM6C7VZ1ozHoVKMoLsq/nuP1P9e37+9NAXqbji2ufB/dNAw74P9++M/4HZG/z7FvifxvbGDjUEXpwAonMdUGO6+ntOPpB376cYXbbUs8DxzXgfVc0cNKLvn1/fsAxHDhgXzrdV2GIn+4H1vzq2TXIOZ/1mW9iER532VTHPgHO/NQ3qQvfG4fjluXU93xDW3l9+dmVZfzrvmG77FlY3iy+JzwPpHn+8WDu28BMq9IuqGMf983QvPAja0jwsf9DQ8lRFEpV4cUUERERERERkWpkNWfyhVRmIgVPSmrPruvd7vYP36Ib+SZZyM+yZnm1j+Od/MJznyGhK9LXm4091Lz7lvjvm9zWmkiCOIGF6RcY5PVRYk1sYvdm46QUPHZaD9R1Gr4nIiIiIiIiIvVbeY3yGSLZQVJFKjHjr6k24xIKVt1xCUVic1/lVgMRMO+yiIiIiIiIiIjIvqdQSkREREREREREqp1CKRERERERERERqXYKpUREREREREREpNoplBIRERERERERkWqnUEpERERERERERKqdQikREREREREREal2CqVERERERERERKTaRVT/S9Y9JSUl5jYrK6umT0VEREREREREpFaz8xM7TymLQqkQZGdnm9sRI0ZUxWcjIiIiIiIiItIg8pTExMQyt4eVVBRbCdxuN7Zu3Yr4+HiEhYXpioiIiIiIiIiIlIFREwOptLQ0hIeX3TlKoZSIiIiIiIiIiFQ7NToXEREREREREZFqp1BKRERERERERESqnUIpERERERERERGpdgqlRERERERERESk2imUEhERERERERGRaqdQSkREREREREREqp1CKRERERERERERqXYKpUREREREREREpNoplBIRERERERERkWqnUEpERERERERERKqdQikREREREREREal2CqVERERERERERKTaKZQSEREREREREZFqp1BKRERERERERESqnUIpERERERERERGpdgqlRERERERERESk2imUEhERERERERGRaqdQSkREREREREREqp1CKRERERERERERqXYKpUREREREREREpNoplBIRERERERERkWqnUEpERERERERERKqdQikREREREREREal2CqVERERERERERKTaKZQSEREREREREZFqp1BKRERERERERESqnUIpERERERERERGpdgqlRERERERERESk2imUEhERERERERGRaqdQSkREREREREREqp1CKRERERERERERqXYKpUREREREREREpNoplBIRERERERERkWqnUEpERERERERERKqdQikREREREREREal2CqVERERERERERKTaKZQSEREREREREZFqp1BKRERERERERESqnUIpERERERERERGpdgqlRERERERERESk2imUEhERERERERGRaqdQSkREREREREREqp1CKRERERERERERqXYKpUREREREREREpNoplBIRERERERERkWqnUEpERERERERERKqdQikREREREREREal2CqVERERERERERKTaKZQSEREREREREZFqp1BKRERERERERESqnUIpERERERERERGpdgqlRERERERERESk2imUEhERERERERGRaqdQSkREREREREREqp1CKRERERERERERqXYKpUREREREREREpNoplBIRERERERERkWqnUEpERERERERERKqdQikREREREREREal2CqVERERERERERKTaKZQSEREREREREZFqp1BKRERERERERESqnUIpERERERERERGpdgqlKikzMxMPPPAADjvsMPTr1w+jR4/Ga6+9BrfbHdLz//zzT3Tr1s3cX79+vbnPW7rxxhvNUpZg29977z089thjqEmB76Miv//+O1auXGnuf/zxx+Zais+TTz7pvSa837t3byxfvrzUJeI+vH57wvk9DHVfe+nZs6d57Zdeesm7D88j1OOdccYZ5n2Vhcfha1bWrbfe6nfcgoICnHDCCdixY0eljyUiIiIiIiL7nkKpSti5cyfGjRuHhQsX4t5778UXX3yByy+/HM8//7x5XBPnw9c+77zzUJecffbZ2L59u7l/9NFH48MPP6zpU6pVwsLC/B4XFhZi4sSJqGkzZswwy/fff4+bb74ZzzzzDL766qug51weBkfnnntulZ7biy++iA8++MBvXVRUFE4//XRMmjSpSl9LREREREREqkZEFR2nQXjkkUfMD92XX34Z0dHRZl2bNm0QExODSy65xPwA7tChQ7Wdz9tvv41hw4ahUaNGqKt47biIT5MmTZCamup93KxZM8ydOxdTpkzB8ccfX2OXynlOLVu2xDHHHGNCKQaLgedcnuTk5Co7p6ysLBOQ/fHHH2jRokWp7cceeywefPBBbNiwAa1ataqy1xUREREREZG9p0qpEHEo0JdffonTTjvNG0jZDj30UDOEz/7Ru2vXLlx33XXYb7/9TGh09913Iy8vr9IfzqxZs0wI0bdvX1x55ZXIzc31buNwQQ7dGzlypHcdh1TxPPhDvH///rjwwguxbds273YOmWNVFc9r+PDheOqpp7zDDlm9cvXVV+Omm24ywxKPPPJI/PDDD2UOFStv+NeKFSvM6wwYMAB9+vTBqaee6h2uZw9LO/PMM81rBg7fq+gcJ0yYgDvuuMNsHzp0qKmQCRXP99NPPzVhCofE8bzWrVvn3c73y+vNcx40aBCuueYaZGdne1/7+uuvN58l3xfPmVVDb731Fg488EAccMABeOONN7zHKu87YA91C7ZwCCSDzY4dO3qP1a5dOxN4PvTQQ+a4ZeFxOZyU35cTTzwRf/31l194w/fDc+dn+/fff/s9d9OmTbj44ovNZ8/3xuteXFxc7vWMi4vz3uc5hxrIBg7f42vxsxwyZEipaqeyrpP9fF6v/Px8894ZEAdiiMzPh39WREREREREpHZRKBWitWvXIicnxwQWgTh0iaEEfwDTLbfcgt27d+Pdd981Q5wYANx1112V+mDS09Nx0UUXmR/UrJDp3LkzvvnmG+/2ZcuWmX34uk78sX7++eebH+EMsTi80D4eQ5i0tDTzw5/BDgMVZ5Dy3XffoaSkxPzAP+mkk3DFFVeYgKkyGCAx3GBAxwBo8uTJJtywh1DZQ/WCDeEK5RynTp1qQsFPPvnEhFcPP/wwVq9eHfL58XX5+fA9cvjj//73P+/ny+CPr//111+b9b/99hvef/9973NZFZSYmGjeF4Ofq666ygRTb775pglaWJHD91DRd4CVRfZQuMCF1T4MaO6//36/8+bnGBERYar1guH7YfDF7wy/L/zeMJTcsmWL2c5ruWrVKnM92Xvp1Vdf9T6Xn/lll12GlJQUc1352p9//jmee+65Mq8jvxcMaceOHWset23b1lyHyuL3lJ/vfffdZwLVjz76yG97WdfJ/u50797dDGFt3bp1ma9x0EEHYfr06ZU+NxEREREREdm3NHwvRHaFCkOJ8jDcYM+dmTNnevdlWMAKHFYhhYrBCIdEsdqGoRdDiWnTpnm3L1q0yPwQt4MwG8Ok4447ztznD31WUjHA4vCm2NhYcy4MNzp16mSqqJ5++mnT44mSkpJMcMJjcvsvv/xiQoIbbrgh5PNmNdB///tfE+7YlTRsNm03xeZ7sl8rPj7e77ns0VXROXLoF8/H5XKZ8I2VUuzxFWqVzjnnnGNCHzrllFPMEEg7TGNYM378ePOY15bBjrPBeOPGjU1wxc+D74mfEcMnVugwIHviiSewZs0aU5VU3neA6yo7ZDEhIcE8l9VO/IwZijnZwZg9vO/aa681lVIMoRhO8VwZ/vTq1cts53BTOyTjd2Pjxo0mCAwPDzdVWrzGfL1LL73U+xqssqKioiJTOcjHrALbGwz9zjrrLFNtSPfccw/GjBnj3R7qkMDy8Hu0ZMkSE47yeyMiIiIiIiK1g0KpENl9cDj7Xnk4/IwBx8EHH+y3nusYWISKlSisAnE2kGaVlj2EjxU5DEkCcbiYjWEJz5vnxIWBBMMeG0MFhj524MYhbc6Qi4/tYXehYhDFsIfVOgyLWJ3zzz//oGnTphU+N5RzZFjkDBYYbDEkCRWHwjmDHjYRp/bt25v3/uyzz5ogigs/Azvgs1/b/jzsUMkesmk/ZlhT0XeA14SVS8Gw+oj9moLh0DxWmt15552lhrnxNZ0BEnEIJ9ezkoyBDL9PNmfFH/fJyMjAwIED/c6VASOryWz8TInHYoj16KOPmsqsPamQKuu8WRHoHBZoB2GB+LqsyAsF/wzw/fA9shpMREREREREageFUiHi8CRWuLBCKbBKhf7v//7PVKrwBzv3CxyGZDesnj9/fsgfDodVOUVGRnpDKYYjwXr+OAMd4j6sfgnsg0V2ryb7OGU9N5iy+g2xB9PJJ59sAjP2JmL/JoYwr7zySgXvFiGdI69BRdepPMGeT6ykYZjGc2Y/KVZmvf766377BF4fCnZ9KvoOMABj76ZgOHSxPLfffrvpGfbOO+9UeO14Hvb1C+QMHxnqsTqKwwwDOSsDnYEe92cgyKo4VuJ17doVeyrw83NeZzsIC8RKu8oevzIzBIqIiIiIiMi+p55SIeIPZfYC4nAvVsM4/fjjj2ZhoMBhZOwlxB/A/BHPhRUnbFId+LzydOnSxVQYOcOfxYsXe++z8oiVH8HCFRurcngubAzN82KgZlcGEWd043A6uwps6dKlfiEGK53sZuYMc+ym3+RsEO7EIWtbt241Q8U4vI5D4FhVE0pwFMo57ivsE7X//vubnk0cesjgkdevMoGXraLvACu07PWBS7Dgy4n7cDje448/boYJOl8zMPDkY7tpOj8/Z3Nzfrecz+VnxOtsnwcbiHM4YnlBjn1tygq+Qv2eO8+Lr+ts5l7WdarM94HVXryuwSoLRUREREREpOYolKoE9nViEMD+QQxf2D+Kw6huvPFGM5schx6xfw1njWNPnwULFpiQhb152CS9UaNGIb8W++qwKuree+81lUbsyTR79mzv9h49epgf8M6giBgGcRY5hlM333yzafLMyhxW1zAQYaUNh0yx5xGbfrM6yA4eGDSxITlfj8PYeO6serKHe3HoGKtiOPNeWZVPDAv4Xnl8nh+vT2CQx+FZHB7H4MYplHPcV3jeDOX4mXG42wMPPGDCksoEibaq+g6UhaEUAyTnUFJWdrF/FCuLeP5sAM/vAD8/hmAchsi+Vgyq+Plxxjsb+0JxGCL7l/EacNbH2267zfT3cg6V5DBKe2Fgye8KA6/AKikGqdwnlGvHWQX5nWUDe3632KOrrOq8PcX3xD8vqpQSERERERGpXRRKVQKbLnM2NfZqYuDAoWkc4sVZ6hhM2VgRw/5DDArYWJuVKOy/UxkcnsQgisEIAwXOBOfsb8QKJp4PK4mc2ICbr8Ugh9sfe+wxs57BBI/HII3NsBlQsME0Z12zcUgZe1VxOxtjv/DCC+a9EmeaY6By4oknmqCMDb+DYQ8g9giaOHGimZmNs8IxZNqxY4d3JjgOc+Q1YuDkFMo57is8J/Zg4mfGSilWDvF9OCuKKqMqvgNl4dA7XlMnVvFdffXVprqJ152hKYNDBmTEkImfDc+F31WGQTYGTwwhWfHERu8MX0eMGGEavzsxvOLCwI2z3zVv3tx8RwJDpE2bNpn9Ar+bwfA7zT8//Kx53RmiVkVw58QwN7C/l4iIiIiIiNS8sJI9GZ8ktQJDHYYn999/v3nMfkgMcBgc7cmxGGTsTdNqERvDMQZBDPpqEqvTeB6sIGNIKCIiIiIiIrWHKqXqsNNOOw2//vpr0N5SIjWFQ1x///139OzZs8Y/hM8//xyHHHKIAikREREREZFaSLPv1WHsK3TxxRebYVrXXHMNGjJWh7GXUllefPFFM6ue7Hschsk+UWXNdFhd2NOK/cxefvnlGj0PERERERERCU7D96Re4DBG56x9gZo1a4aYmJhqPScRERERERERKZtCKRERERERERERqXbqKbWHOKscZ8D74IMPquzD4Kxo9ix+bDzOGeH2FM/tzz//RHVbv369eW3eBp7HmjVrzGxrffr0wf/+9z/TmJ3XcW8tXrwYc+bMMff5WnxNEREREREREandFErtoS+//BJt27bFp59+in3h3HPPNcFUXTdjxgwMGDDA3H/rrbe81+6cc87Bhx9+iKOPPnqvX+PSSy/Fv//+a+7ztfiaIiIiIiIiIlK7KZTaAzt27DCzizEMmTVrFtatW1flH0x8fDySk5NR16WmpiIqKso7K1v37t1NmJeUlGQatVd1nye+Fl9TRERERERERGo3hVJ74JtvvkFiYiLGjh2LtLQ0v2opDkl77bXXcOyxx6J///648MILsW3bNu/QsoMPPtjMTDZkyBAceOCBePbZZ4O+RuDwPYZfnGGub9++5thTp0712/+pp57C0KFDzXErGlLI4W1ff/01Ro8ejX79+pmZ+xisnXnmmebxqaeeii1btnj3/+mnn3DCCSeY12Zl07fffuvdxubid999t5nZju9t2rRppV6L75vDEjlUb8qUKd7hfc7he0VFRXj00UcxbNgwDBw4EFdccQV27txptvFc+Hj//fdH7969zbnMnj3bbOM12rBhA2666SbzGoHD9zZv3owrr7wSgwcPNtfmnnvuMbOyEV+bz3/iiSfMNr6H+++/HyUlJd7m6axYY/UVry3fp91M3R6+KSIiIiIiIiJ7RqHUHuDws0MOOQTh4eEmWGHQYgcZdqB0/vnn47333kNubi4uv/xyvyor7v/KK6/grrvuwksvvYT333+/3NdjqHXRRReZUOrzzz83x2YAw6CK+DoMuu677z4TiH300UcVvgcGMQ888ACef/55EzKdcsopZpk8ebJ5vRdffNHsx4ownj97QTF8GzduHK6++mosXLjQ+14ZWjFce/zxx815BHPLLbeYEIwLh9e1aNHCbzuf+8knn5j3wPfD63THHXeYbddeey2Ki4vNufHacSa9O++80/v6zZs3x80332xew4nh01lnnWU+gzfffNP0sfr555/x0EMPefeZO3cuVq9ejXfffRe33XabOf/ffvvNbGMIFRcXZ17z6aefNkGg/VkxnNMwQREREREREZE9p1CqkjZt2mSaao8cOdI8HjVqlKkysit36KSTTjIhDitpGLIw+Fi2bJm3IojrevXqZY7B0IRhS3nefvttU1V1+umno127dubY//nPf/D666+b7QxKeJxDDz0UPXr0MNVAFTn77LNNVdQBBxxgnsPjMzDifb4nBjX2ax955JFm/w4dOpheUNzOUI1BHKuy7ComVhQxHAqGlWUcqseFw+tcLpd3G4/D98Cwi9VWnTt3xsSJE9GlSxezjdeJgVGnTp3MttNOOw0rVqwwz+UQRx6Lx+fiNH36dFNlNWnSJPNZsNrp9ttvNwFUdna22YdhF8Onjh07muvK4YV///232cYKLB6zZcuW2G+//fDCCy9gxIgRZpv9PkRERERERERkz0Ts4fMadJVUdHS0GWZGHBbG/kis8uHwL2KAYWvTpo0JTlauXGl6KLHyhsGHjcPRGPCUZ9WqVaYayW4YThxGxpCIeGz2t7IxuOHrlIfnZWPA0qpVK7/H9hA3Hvu///2v33N5HqzG4vC69PR0E2TZOLNeZfE4GRkZJqhzvge7wowVXF999ZUJAxmWsUrL7XZXeFyee/v27c3nY+Nnw2Bw7dq15nFKSgoSEhK823mf24kVaQzZvvvuOxOWsTqqZ8+elX5/IiIiIiIiIlKaQqk9CKXy8vJM3yMbq23YZ4rVPOaiRvhfVm7nUL9g2xiuhIWFlfuaDEnYR+riiy/2//Acx3IOHwz2OoGclUpkn18gBnCBeM7OUMj52pGRkais8s6Vr8O+Trt27TKhEIdLMpC77LLLKjxusHPnZ+G8tZuwO9nvhz3DWF31/fffm2F/rAi74IILTEWXiIiIiIiIiOwdDd+rBFbp/PPPP7j11ltNnyF7eeyxx8zMcqyooSVLlnifs2bNGuzevdvbFJvhCpt82zhUrKKG2ayI4nE4dM9efvjhB9NfijjMzR5yRjw+X6cq8LXnz5/vt47DEbm+cePGaNq0qd9r8/pUVqNGjcyxnNdt8eLFpjpp+fLl+Ouvv0yvLIZy7OW1devWoEFcsHP/999/TRWWbd68eSYE4wyAFeHnyt5WrNRi762rrrrKr8m7iIiIiIiIiOw5hVKVrJLiUDz2c+ratat3YQUPh5sxoCI2y2ZoxJCFw78OOuggM4zMxooq9phi42w24GaPpPJwNjwOWWNIwpCFYRRnqmOvI2KvKb4mj8fjsuF3WZVPlcVeUjwu+1fxtRkOMXxjUMMKL547m6azOTjDKc5etyc4Cx6bnf/xxx8miLr33nvN7IUcesf3wmvPHk+sSGNzc7KHGHKoIoc4OsMn4nXnMMXrr78eS5cuNcdm/6hjjjnGBGEV4THZjJ6fI8+JMwvaw/dYLWfPqigiIiIiIiIiladQqhIYjHAYXbAhXwxpGMywsfYJJ5xgQiOuYzNshklOrABi0MTg5ZprrjHHLA/7PT333HOmcTcDFc4ix9n3OLyM2KCbQ8sYuPC4DGNCCV1CwWbonK2OzcH52uwlxdfnsDZi9dLxxx9vhrRxhkDOzrcnLrzwQtNAndVIvG6cUY/vh7ecaY+zAfL12WyclWqsdrKrsrg/G7JzfeAQxWeeecbcHz9+vLnWhx9+uAmaQsHXZSUYAzM+Py0tzTvDH3tc2X3FRERERERERKTywkoqGgMllcKeR+x3dOKJJ5ba9ueff+LMM880VTsiIiIiIiIiIg2ZKqVERERERERERKTaKZQSEREREREREZFqp+F7IiIiIiIiIiJS7VQpJSIiIiIiIiIi1U6hVDV58skn0a1btzKXjz/+uNztbKC+detWDBo0yMzs58Re9Wygfvnll4d0Ljwem64Hw/XcXhXvl7PW7Qk+b+TIkcjPz/dbv379enNuvN3X5xT4efXp08fMcjht2rQKn/vee+95Z1zcsWMHvv76a++2devWhXSMgoICM4sjnx8qvjee95587qGqzPfD/k7/+uuvlT7XPVUV73FfqKo/VyIiIiIiIvWJQqlqcu6552LGjBlmsX+M24+5HH300X6PBwwY4PecDz/8EGlpabj++uvx8ssvY8mSJd5jv/7661i2bBnuvPNO1BcMb5577rkaPQd+Bvb1//LLL3HMMceY4K+8UGznzp14/vnncd5555nHDz/8sF8IdfPNN2PBggUVvnZUVBROP/10TJo0CXXdXXfdZUI2ERERERERESeFUtUkPj4eqampZklKSjLr7MdcYmJi/B5HRkYiLi7O+7hJkybmOePGjcN+++1nwo3i4mKsXLnSVE7dfvvtSElJQX3RqlUrvPTSS/j3339r7Bz4GdjXv23btrjgggvQsmVL/Pjjj2U+5+2338awYcPQqFEjbxXbnjr22GPNa23YsAF1Fb/r27dvxwsvvFDTpyIiIiIiIiK1jEKpOiYsLAz33HOPCaPefPNN3HrrrTj00ENNpVVl/PXXXxg1ahT69euHK6+8EpmZmUH327x5s9k+ePBgDBkyxLy2s+rll19+McPMeJyxY8fi999/L3UMDsM75ZRTTOVXqBUzHCrXtWtXU2VTFh6XlUQjRoxA//79cfHFF2PTpk3e7StWrDCvy3Pj8EZWMTnNmjULJ554Ivr27WsCoKlTp1Z4XgwKy+J2u83QPQ49JFbEffLJJ2bh8Msbb7wRM2fOxFNPPWWGr33wwQfo3bs31qxZY/bnZ8phgt9//723WurAAw80x3QOXyxveBo/L1ZY8Tjjx4/3q6irzLXjObHai9VihxxyCN54442gx7n//vvN9o0bNwbdnpCQYL4/DKXWrl0bdB8Gd6yK4zXi9WCox2tUlpycHBPC8vvI5bbbbvMb6snPlZ8nrwGvhTPU++GHH3D88cebbRwKe8011yA7O9v7eU2YMAF33HGHCX6HDh2KF1980ftcfmbPPvusuS78zhx55JGYPn26d/uuXbtw3XXXmefyPdx9993Iy8sL+h54PfnnlufB7yDPWUREREREpKFRKFVF+MOWP1oZIgQLZqpSu3btcNlll5lQgeEBf0RXFit6brnlFnO7evVqEy4EYoB01llnITc31wRg//vf//Dzzz/joYceMtuXL1+O//u//8MRRxyBTz/91Axvu+SSS7Bt2za/oIY//HnLoIFBSyjCw8PNcERey6+++iroPnzf3333HR588EFMnjwZRUVF5vX5Wjz3Cy+8EG3atDG9jRgg2OEO8RwvuugiEwh8/vnnOP/8801oVFY4wOCEYRErt/h+g+EQyvT0dBxwwAHmMUO40aNHm4XDL3m97WGZDEBOPvlk85jXnsdn0MKg0A616KCDDvIGHy1atPAO7SwLA7CjjjoKU6ZMMe+d3xNW1FXm2jHg4Tmyuu/9998358UeWT/99JPfMV599VXzuXM4KSvIynLaaaehU6dOZQaMPFcOQb333nvxzTff4NJLLzXXZ9GiRUH3ZxA7e/ZsPPPMM3jllVfMfX43bQz7uA+vOcNWDqEkhmIMyE499VTT54vP+e2338x7tDGYjI6ONteR4ROfyz8fNoZnY8aMwRdffIHu3bubQIzXjPj57t69G++++645t7///jvoe/7nn3/MnyF+BjwPhmNXXXWV9zgiIiIiIiINRURNn0B98dlnn5kqGOIPeFZZ7EuscOEPZv7Yt4f2VQbDCh6D+AP+nHPOMbdODEO2bNlifrTbQw4ZUDCIuvrqq82PflaFMMwghkCsYmHFiI3VIgzO3nrrrXKrjIJhFcl///tfE9ocfPDBftsYNjAQYSWLHQLxerBqh421GcRkZGSYYIuvy+vEz4ehETGMY4DISho76Fu8eLEJRxgSEAMqOwBiyMXghhVXDIeCYYjSunVrb/DGUIfDMsn+jOxhmcnJyeYxQwtWhV177bUm/Ahs/s3zZrUT34/L5TJDCcvDQMt+TxMnTsTw4cPN9XBev4quHd8rr9N9991nKp26dOlivhsMCm0MChkyvvbaa+Ycy8Pz5ufAz5KhE0MzJ15Pfsb2nxlWtz399NMm9OzVq5ffvjx3HoOB2MCBA73XkJ+djd9PVlARgz+GbsTQh++DFWTEz4rfAb6OjZ/LDTfcYM6ZQSWv0cKFC9GhQweznX9mGGTar8PPjgEngzyGlvyOJSYmer/7rMq66aab/N4DK7dY8cggj+fAQIpVUzw/5zUWERERERGp7xRK7QP8wbkvMaDgj2sGQqwS+eijj3DSSSdVOvCx9ezZ0wQugcOrOJysffv23kCK+Jr2vgxRAkMD/sC2zZ071wwT5PA55zEqg+HXt99+i8cff9xUbdlYscQf8Ty2M1BgeMDz5jny3J1BGN+z3XR81apVpvLHWXVUWFjoDR+IQ8nsKhtuY/DB4Yt8Lwz1AjHIady4caXeH1+PYR7DKFYtBQaMfE98nwzYQukZxmFlNgZKPD7fqzOUCuXa8T6fb7O/X/bQQVaVMXxr3rx5SO+Tr8V+aAyfGJQ5MRibP38+HnnkEfP6vM4MeoJVDjHg5Pff+b1jiGgHicT+XzYGRPbQPn4feM4cgscgiguHeDJYsjEkYiBlY7DI62HjMZzXl7id583zDQxPuc4enmnj0D4OTeUQQ/7ZO/zww821iYjQX8ciIiIiItKw6J/lqwh/YPKHMUMFZzCzL3C4FH8Ec/gRq2IYZjiHzIXC+cPbbsbNKh4nDmMKZA8F421FP6L5g57D/vjjn1VVe4INwznjICubnP2Rgp2bfV52mBHYZNz5/hgk8DPj0DF74Qx7zhn/WOXECiounTt3NvtzWBvfU1lhZLChchXh++LnEaxXlP0eQg06nZ8r8VqE8rk6r10o4QiHjjK44ncvVOzXxCqswGowDrc7++yzTXjE4Yusvior7Ap8L8GUVW3E68yhdwyi+GeVwwUDe7EFO77ze1TWdl47BmDO7xMXBqr87jjFxsaa98yqPPZq4/BSVl+xKlFERERERKQhUShVRVg1weCEPZD25dA9/qDmj3oOMWrWrJkJwPja5TUEL6v/kW3BggXmxzarRJwYOrCqhlU6tnnz5pnQgtUoDGsCG2lziBbDHWI1yP7772+GObEKxnmcymAlC0MEDiezsV8Sz4PnY2Mjc1al8Lw55Iznzh4/NucQL+7Dfe3QiQubYLO/VHkYQJTV+6dp06al3mNFYRKHfLFPFMMwvnZgPzK+J77PUCuwnJ8rh1HyGnTs2NFvn4quHauBeJ+9xGwMn1glZmOPLlbr8bNmNVwoWGHGgJGhnrMqjz2Y2EeKM0pyuBvf644dO4LOXMhzZ/Dm/N7xGrLZfkU4ZJHfR34X2VeKVWV8n3szQ6KN143fNX7e9veJTc7ZOyqwuT8rCJ9//nlTIcahfRyOyECOVY8iIiIiIiINiUKpOoTVGAyjOITO7ovD4WlsmMyKjFBmj7Ox7xUDEAYTDBsYJrGCw4lNthkCMEhYunQp/vjjD9Mnhw3NWcHE3j/su8T+Pvxxzx/arIpyDqUiDrtjIPHoo4/u8Xvne9y6datfFRaHPPF8WGHEkIIzn7HChufNXkHsVcTm06wqYzWKs2E6Qwn2CuJ1YHDDQIjn52zYzSF7rEDjwtdmjy3OmsbG5cH06NHDzJBnz+ZGvKbsIWRXwfDz4usxdMnKyjLnz9COw75Y9cb36ZxJjtedx7WrsHgu5c1gyPfBHmAMLxnyMByx+0aFeu04vIwBG/uH8doxrGNfJq4PHJLHwJCBqHOIW3kYHnG2P84SaGMIxe8ih4PyM+GQTV77YO+TASyDK1Y5MUxlM3F+hoHvMRgOUeT15PP4Wg888IB5fqgzQpaHfbU4LJG9wXh89hdj4MQea/yz4sQKPPbMYrUUvy8M9rgfZ1YUERERERFpSBRK1SFsusyQwFmxYjdfZlDEkIGNoEPBxuYMbHjLvkr8MR2IFSmcRYwYgnEWPfa/sauyWC3Fqi32tOLrMxRjxQ8ruJzYx4c/0PkjnCHAnv7o59A5JwZ0DJ+uuOIKE5BxWBqHfvH1WPnFkIzXg0EIq3E4C5ytVatW5lwZNPHcORSSfZLGjh3rV9HCIIYLrzGvF0OYwMbVNoYKbETO59m4PwMQHpcVOQyD+Jpsos0whQEFPwNinyqGEwwsbKyesfsUbdq0yZyL8/iBOAMkh0ryPbNSis3Ig1VrlXftWEXFz51BHI/DAIjBJBuhBxuSx9CtrCGNwbDpuXMYHMMzBnS8Vpdffrm5jpzh0FnZ5sT9OfMdr9sFF1xgmpozyKoIrw0DMQ4VZCi5ceNGU6HF2fCqAquiWG3I4/PcWD0VLIhlyMhr+tJLL5mAk99DDoesqGG8iIiIiIhIfRNWUhVjV0TEYEjHsIMNvfcWAyoGUuxNFDi0UkRERERERKSuU6WUSBViNdavv/66x/2zAofisTpJgZSIiIiIiIjUR6qUqmc4ixeHi5U3BDCw51N14nCp3377rcztEydO9BtCVxe98847pmcShzvuKfY5Ovnkk81MixwSKCIiIiIiIlLfKJSqZzh0jE2iy8J+T+xjVFPYp8g5q1uglJQU08xaREREREREROo3hVIiIiIiIiIiIlLt1FNKRERERERERESqnUIpERERERERERGpdgqlRERERERERESk2imUEhERERERERGRaqdQSkREREREREREqp1CKRERERERERERqXYKpUREREREREREpNpFVP9L1j1utxtbt25FfHw8wsLCavp0RERERERERERqrZKSEmRnZyMtLQ3h4WXXQymUCgEDqREjRlTl5yMiIiIiIiIiUq9NmzYNzZs3L3O7QqkQsELKvpgJCQlV9+mIiIiIiIiIiNQzWVlZprjHzlPKolAqBPaQPQZSCqVERERERERERCpWUQskNToXEREREREREZFqp1BKRERERERERESqnUIpERERERERERGpduopJSIiIiIiIlLHFRcXo7CwsKZPQxqIyMhIuFyu+htKlZSU4Mknn8TkyZNRVFSEI488Erfeeiuio6PN9nvuuQdvvvmm33Nuu+02nH766UGP99prr+Hll182HeBHjx5t9o2Nja2W9yIiIiIiIiKyr347b968GRkZGbrAUq2Sk5PRvHnzCpuZ18lQ6sUXX8Q777yDxx57zEwhOGHCBDz11FPmllauXGnun3DCCd7nlDUz3tSpU81zJ02ahJSUFNx0003m/u23315t70dERERERESkqtmBVFpaGuLi4vYqIBAJNQjNycnB1q1bzeMWLVqgXoVSLDt89dVXccMNN2Do0KFm3eWXX44pU6Z492Eodd555yE1NbXC473xxhs466yzcOihh5rHEydONM+97rrrVC0lIiIiIiIidRJ/O9uBFAswRKqLPfKMwRS/f3s6lK9WNjpfvnw5du7ciZEjR3rXjR07Fq+88oq5zyF4W7ZsQfv27UP6Q/r3339j0KBB3nX9+/c3Y22XLFmChqbYXVLTpyAiIiIiIiJVwO4hxQopkepmf+/2ppdZrQyl1q9fj6SkJMyZMwfHH388RowYgXvvvRcFBQXeKimWJD733HM4+OCDTWD1ySefBD3Wrl27kJ+fb5I7W0REhBn7yDLHhmTVtiyc/txPeH/KJygqdtf06YiIiIiIiEgV0JA9qavfuxobvpeXl2eqnYLZvXu32f7II4+Y/k9utxt33HGHuWWD8lWrVpk337FjR9PY/K+//jLr2VPqiCOOKPU6FBUV5beej+2Qq6GIykvHTTvvQGR6Aa7ekYj9undC71ZJ6N48EYkxkTV9eiIiIiIiIiLSgNRYKDV//nyceeaZQbc9+uijJkzibHuDBw8262688UZcc801uOWWW0z1FPtDsdqJunfvjn///RfvvvtuqVDKnq0vMIDi44Y2+17r1m0Q2bYrstfOx6Adn+HDOePx8ZwNZluT+Ci0aRKLNo3j0KZJHFomx6JFUgyaJkTDFa5GeSIiIiIiIlJ1o6MOP/xw/PDDD2jdunW1XdZu3bqZntNDhgzBYYcdhssuuwwnnnhitb2+1KJQil+CpUuXBt02c+ZMc8tKKFuHDh3MMLz09HQ0bdrUG0jZuO8ff/xR6ljcj8HU9u3b0alTJ7OuqKjINIMLpUl6vRIWhmaHXwb351ehaf5coP1Y/J7RGBsycpGeXWCW+esy/Z7CPCo1MQbNk6LRIikWzRvxfgyaNYpBWqNoJEZHqFRURERERERE6pQPP/xQvbhqgVo5+17Pnj0RGRlpGpEPGzbM20cqPj7ehEyPP/445s6di9dee837HO7rDLFs4eHh6NOnD2bPnm2CMJo3b57pK8UKqwan5QCEdzwEjVb9jLOKPsRZpz6F7CJg3c4crEvPxbr0HKxNz8GWXXlmKSwu8d4PDKwoOiIcqYnR1pLguXUsKfHRiIqola3LREREREREpIFq0qRJTZ+C1NZQir2hxo8fj7vvvhsPPvggSkpK8PDDD2PcuHEmTOLQvRdeeAEvv/yyGa43Y8YMTJkyxZThEYf+sS+VXQl16qmn4vbbb0fXrl1Nw/M777zTHL+hDd/zGnopsH4WsHUxMPcNxA86F92bNzKLk9tdgvScAmzOzLMWTzhl38/IKUR+kRvrd+aapSzJcZGlg6uEaKSYJQqN46I0RFBERERERKSK8Dc0f6tVJxYsVLbx9TfffGN+x2dlZeGYY44xLXzY//mDDz4wv/c5zI/FKUcffbTZ5nK5sHHjRnOfhSoxMTFmG9v9sLCF7/uZZ54xrX2YCwwaNMhkAS1btiz12s7he2eccQYOPPBAzJo1y/SsbtGihXmN4cOHeydQYz7B4Yacce7II4/EddddZ15f6mEoRfxSTZo0CRdeeKH5YnGGvQkTJphtffv2NdVSTzzxhLlt1aqVaYo+YMAAs/2rr74yDdLt4YFjxozBhg0bzJeRvaRGjRplvkANVkIaMPwa4Ie7gDlvAq0GAi36ldotPDzM9JTiwobogQqK3NielY9tuz2L877nMfdheMVl+ZasoKfDIYKN46NMXyuGVbzlazZJ8D1meBUd4donl0NERERERKS+4O/n6z9cgCWbd1fr6/ZokYgHT+pbqWDq/fffx2OPPYbi4mJcf/31eP75580Ip3vuucfkARxFtXDhQvP7fejQoea3PMMhBkMsTNmxYweuuOIKM2rqtNNOw1tvvYXPP//c5ANs+/PKK6/g3HPPNesYWpXnueeeMxOsceHzOZnajz/+aEZfsbd1YWGhCbvYVojnd9ddd+G+++6rgivXsNXaUIrpKD94LsGMHDnSLMEw6QxsVsZwi4t4dD7cqpYqzAFS92wYI4flsSE6l7L+MtyVV1QqtNq6Ow87sgqwIyvf9LFyl8DzuKDM4IoSoiPQ1AwJZGjFEIuBmRVYmRArPsrso+lQRURERESkIatkwVKNufnmmzFw4EBz/8orrzQjpDgy6t577zUBFLER+quvvorly5ebdSw46dWrl6l+ateunRlF1aiRNernpZdeMqGS3bqHwRFbAk2fPt1URpVnxIgR3hzh//7v/3Dcccdh27ZtJoT6/vvvTe/rxMREs53BGCdgYzGMvU7qWSgl1WD4BCAsnCVR++TwDIeSYiPN0jktIeg+HCKYkVtoAqrtDKay872B1fZs65aPWXqalV9kln+3Z5dbMsqQygwN9FRfORf2uGocH6mqKxERERERqZf4O4wVS3Vh+B5HQdlYFcUJytq0aWOGxXFk1IoVK8wIqDVr1nj7TZ9//vkmzPruu+9w8MEHm+F7fG52djY2b96Mq6++2lQ32TiM799//63wXNq3b+/XUsieJI39rd1ut3ktJ67jefXu3btS71n8KZRqyFyOj9/tBma9DHQbDSRV35ScHCJoB0ZdmqHMiqvsgmJfcMWgyhNYWUGWdX93XpH5i3djRp5ZysOKKvt1OXTQDrBSHI+T46LUpF1EREREROochkMxkbW//YkzPOLvPmJPp2uuucZUIrGn06WXXoqJEyd692NrHw7lY/XSzz//bIbvXXDBBTjvvPPMdrb46dChg9/rJCWVbkcTKNjwPp4ThxayGuqjjz4qtb1ZszJ+xErIFEqJZd7bwNy3gKVfA6MfBJp2qVV/oTJE4tIuJb7M/fKLis1wQFZWsdcV7zuXHZ7bAkfVFWcaLE+jWIZXVtUVG7I3iY80j+0+V7xNjo1EhEszDIqIiIiIiFTGsmXLMHjwYHN/wYIFaN68OT777DOcdNJJZhieXa20du1aHHDAAeYxe1CNHj0ap5xyilk4fO+TTz4xFVIpKSlmyN0hhxxi9mVPaQZcDKzsHtSVxYCLE6nxd2nbtm3NOlZvsZLr/vvvV7PzvaRQSizdxwArfwDSVwOfXQ6MvBNoa/2hryvYCL1FUqxZymJXXaVnFZiZBXd6wyqr+orrd+ZY64qKS7Art8gs5Q0ZZIUqhyj6hgha/a4YYDHIssKraBNesTJMRERERERErN5MbBrO2fcY8jA8Wr16tZlZj8EPK6nY/JxBEwMmWrVqlekVxYnMOBvftGnTzPA9Ovvss/G///3PhFNsfs6Z+ObMmWN6VO2pTp06mYqta6+91jsDIJugs/rK7mUle06hlFjimgBjnwK+ux3YMBv45iZgyMVA3/F1p0teJauu2qbElRte7c4vMiGVXWFlB1gmtGKolZ2P9JxCqy+WZ4bBVdvKDq+YR3FIoD1EsImj+sq6tdbzvkvhlYiIiIiI1HOsdGJTcc5sN378eJx11lmmrxQbiP/nP/8xvZ3YgJz7LV682DznzjvvNMP5zjjjDFNFxaooe4I0hlrsLcXAikEX+z29/PLLIQ3fK89DDz1kwjOGXhERESakYkAley+sxB64KWXil5kzAsyePdvb8KzeKi4Cpj8CLP3KetzhYGDEDUB0PX/fe4iB1K68wlJDBAOHDWbmWLMMhsKuvPIGVXZwxSArzup1ZQVYatguIiIiItKQsYk3K4s4xIzNwUVqy/cv1BxFlVJSuvn5iOuB1K7Ab08Ba38Hdm8ComtPj6nahMPxGBJx6Zha9n72LINmmKCpsvINH0zPLjTVV1yX4Qmv7Mqr1eUMG6S4KJe3woqBlVWBFRhoRZn9KjsThoiIiIiIiMi+pFBKSmN40esEILU7kLmhVjU9r6ucswx2Tgut8soKqgqt4MobYNnrC1BYXIKcgmLkFORi/c7cCqdnTQ6ouPIPsqz7iTER6nslIiIiIiIi1UKhlJQtrYe12Lb8A/z1kjWcL1FTX+7ryqvycNQtZw/cmV0YNLDy3mYXIrewGPlFbmzZlWeW8rCXVXJcpF9Ypb5XIiIiIiIisi8olJLQsPUYe03tWAF8eC5w0BVAl1H1qgl6XcKheIkxkWYpr2E75RUWe/tbcUhgWSEWZxksdpeY4YVc9qbvlTPQiooIr+J3LyIiIiIiIvWBQikJDVOIIyYCP90HbFlk3a74Hhg+AUhsrqtYi8VEutAyOdYs5SksdpvQyldlVTV9r+KjPX2vAvpc+QKsSPM4NlJ9r0RERERERBoShVISuqTWwNgngfnvArNfB9bNBD44G9j/fKDXiRx7pqtZh0W6wpGaGG2W8lS271V2fjGy83OxLr3ivlcMqhrHWRVYvtkGrdDKnnWQFVocZigiIiIiIiJ1m0IpqZxwFzDgdKDDwcAvk4BNC4DfngQSmgEdhutqNgD7su/V5sw8s4Q6dJABlh1W2eGVM9CKiQzXrIMiIiIiIiK1lEIp2TPJbYFjHgeWfA6snwW0H+bff0q9phq8yvS9yi0oRkaur+/VzoBhg9ZSiMzAoYMVXGW/WQfLqL6ygy1VX4mIiIiIiFQvhVKy5zhcr+dx1mLL3w18eS3Q/1SrmkrhlIQgNsqF2KhYtEiKrdTQQbsKK8MTWu10rK/MrIPlVV8F9sBS9ZWIiIiIiEjVUCglVWvBe8C2JcB3twNthliz9LEXlUg1Dh0kVV+JiIiIiNRt69evx+GHH44ffvgBrVu3xrp167Bq1SqMGDGi1LaaduONN5rbBx54AE8++SRmzpyJN99806zj49dee82MJrniiivM/R9//HGvXq+goABTpkzB+PHjzeMzzjgDgwcPxuWXX466RKGUVK3+p1u38ycD6/4EPjgH6H8K0P80IKL8BtoitaX6yjlkcG+rr0zVVTnVV6zM0syDIiIiIiKltWjRAjNmzECTJk3M45tvvtkELwylarNzzz3XhESUmZmJp556CnfffTcOOuggpKSk4Jhjjtnr1/jyyy/x3HPPeUMpBl+RkZGoaxRKSdWKjLFm4+tyJPDr48D6v6yZ+pZNBYZcDHQ6VFdc6mz1VV5hsbdBe2V6X/1bwXHV+0pEREREpDSXy4XU1NQ6d2ni4+O997Oysszt0KFD0apVK3M/JiZmr1+jhL2cHZKTk1EXKZSSfSO5DXD0JGD1NOC3p4Ddm4F1MxVKSZ0WE+kylVeqvhIRERGRWq8wt+xtYS4gIirEfcP9R72UtW9k+SMUnMaOHWsqfE4/3Rppc84556CwsBBvvfWWefzee++ZoWmTJk3yDtFjtRGHxNnL/fffb/b9/vvvzfO2bdtmgp8HH3wQSUlJpV6TlUQc/peYmIiPP/4YjRs3xl133YV///0XzzzzDNxuNy655BKceeaZ3gqnhx9+2Lx2fn4+DjvsMNx6663eY8+aNQv33HOPGU546KFW8UVsrHUN7OF7PEeeP40cORInnHCCqfTie7GH7y1YsMDs988//6B58+ZmeN+YMWPMtg8++AAvv/yyGarIoOvoo48258DXvummm8w+3bp1M+fIx87he3yPL774IjZs2IDOnTub7fvvv7/Zxvdy3nnn4dNPP8XixYvRsWNH3Hvvvejdu7fZ/sYbb+DVV1/F9u3b0aVLF1OhNmjQIDS4UIrJHz/MyZMno6ioCEceeaT5AKKjrT8Q/ALYYzRtt912m/eL7cQvFD+gwCTxzz//3MfvogHj+KWOh1i9pRa8D/Q41rcta6v1F2F8Sk2eoUitqb7yGzZYhdVXHB7obNRuhg+aYYPWNg4xjHCFV9l7FxEREZFa4pWjyt7W9gBg9IO+x28cDxSV0Z6iRT9g7BO+x+/8B8jLLL3fRdNCPrVhw4aZ0Ia/3RlGzZs3z4RCvM8haL/++iuGDx/u95xbbrnFBEgDBgzARRdd5K1A+uSTT/Doo4+a/OCyyy4zQcy1114b9HW/+uornH/++SaM4XOuuuoqE7YwV/jmm29MoMWhdRwuyGPl5uaaIXJ05513mr5Rzz77LNLT0805/Oc//zHH4VA6Bk0MnfwuXYsWJlgaN26cue3QoQO+++477/YdO3aYoX4M6RgK8TrccMMN6NSpE3bt2mUyDwZzPXv2xMKFC3HdddeZ4O2QQw4xQdErr7yCDz/80Du80cZAisMF77jjDvTt29c8vvDCC817bNasmdmHWQuPz9dijsL7zF4Yjj300EPm/TDMYkDF6/TLL78gnJOdNaRQil+md955B4899phJBSdMmGAuDG9p5cqV5r7zg09ISAh6rBUrVpgQ6osvvvCu2xcXVMpIzAee5b9uxv+AjXOBAacBfcb7p/QiDUhVVV9xBkKzrZK9r6hRbIQ3wGJY5X/fnpUwCokxESZwExERERHZGwyl+FueQdKiRYvQtm1bE/QwEOnTp48pHrngggv8nsMKJwZWcXFx5re9HUoxqGHwQqNHj8aSJUvKfF1WR1155ZWm4ThzhK+//tqEXW3atDGVQ0888QTWrFmDrVu3mtCMIQ6DJGI4xEolVkb9/vvvJgjia/NYrE6aNm1a0OGHdmDEW74Hpy+//NJUXrH4hvkEK5ZYUJOXl2feJ4OqUaNGmX3ZzJ3VS8uXLzfreKyyhjcyZGNPq+OPP948Zkj3119/mYoyO0/h+2f1ll2pxutCrKzie2rZsqV5TQZSrARjaNigQqni4mJzwZkSMgkkftAs4bMxlOIXJ5Qxpvzi8MtUF8ej1jsFOUBuOlCYA8x8EVj8BXDAxUCHEVZ1lYjs0+orE2A5qq925RaZZe2O8o/LPCopSGDlDK7sSqz4KJf5j5mIiIiI1JBzvyl7G0etOJ05pZx9A4KIU9/byxODqU5iFRIDFoYlfMwgaPbs2SZoYfjBoWQMSCrCQMvGoIZD7crCkMX+f1S7r1NgnyfOardp0yY0atTIG0gRK4oYIDFbYNFL9+7d/f5/l2Ea31NlrF692lRBOcMeBkQ2nhODMr7e0qVLTWDGQK8izEouFFNaqwAAZ1tJREFUvfRSv3X9+/c3623t27f3K+5hlRrx+F27dsWxxx5rzo3DD1npFRGxb+KjWhtK8cu5c+dOb3JHLGnjQkxFt2zZ4nchy8MPMdR9ZR+LigOOewZY8T0w8wVg9ybguzuAZr2tcKp5H30EItVUfbU7r8gbXHmbt3sqr5z3GVoxwDKzEWYXAMgu99iRLjtE8802yKGC9rBBBlf2Np6viIiIiFSxSvR42mf7liEqKsoEUaxGYn+k4447zoRSvM8CFc5SF+o/cFameidYsBLs+Ty/YHhuXII1GmcVV2VDqYhygp7p06ebYInVThzKyPsTJ04M6bh2y6PAc2e1k/N8g2FfLA415Gfz008/maF/7777rrm1h/41iFCKjbyYQs6ZM8cM32NAxRI1lsfxC8KEj19Sju/k2EaW7zFRDBzDaeP+7Et18sknmzCLfwDY6CstLa3a35uYP/lA11FAh+HA/HeB+e8BWxYCn14GHHEX0LF2T/EpUl+qr5LYVyouEu3hmyEkmKJiNzJzCx2Bla/qyrvOU4mVU1CMwuISbNudb5aKxEa6TEDlrbiKt/td+XpiMeBiqBUVoWHXIiIiIvWB3VeKfZTYcJyh1AsvvIDdu3fjxBNPrNFzY4UUezqxKopD6uxCFxbHcBt7QXG4HoMeVnYRG4bbVVehat++vTkOAy47hONwOVaJsQH6SSedZPpCEfOMtWvX4oADDjCPywvteI7z58/3K/Lh41Calc+dOxd//PEH/u///s+8Fof7HXjggaaKjcMX61UoxXGSDIiC4ReR2x955BETHjHR44fBWzbh4peDHwK/IGyOxpI/rmfZ2RFHHFHqeNyfYzh5LH7gDLouvvhikwDaXyKpAUzZB50L9DgOmP0qsGE20NYarmkwyVXvL5Eax2boKQnRZqlIflGxtyG7M7jyVmNl+x4XFLlND6zczGJsyqy4/1VCdAQaxzPAikJyrC+w4n2ut4cRMsBS/ysRERGR2h1KcXY7Vt9wadq0qak04m97/l4Phn2W2OycodC+xKF6Bx98sGknxJyBWKXE2es4tI3ny0bh7PnEPIIz6TG0qWwodeyxx+Lxxx83jcXZNJ1FOZxJj03UGUAxIOKwPVZzPf/882aGQQ4vtCua2H+K14PDEp3OPvts0yuL76Nfv3746KOPTK+tBx54oMJz4pDBp59+2nwebKXEzyMnJ8fM8rcv1GgoxaTOnm4xEDvYM5Riwy971jx2ur/mmmvMxWUJG5ttsUKKOJ6THwbLyoKFUmwgxhDLHifKcZn8Q8Bz2G+//fbp+5QQcBa+g68FivJ9Tc/dxcCnl1qz9/X9jzXsT0RqvegIF5o14mL9fVsW/gNBXqEb6Z7gyjt8MNu+72ng7tlW7C5BVn6RWdall18azX84YjBlN223Qitf3yuuN7MRxkciMTpC/a9EREREqhlndktJScHAgQPNYxaLcGa9jIyMUrPJ2djbiLPOcQY9hkL7Emfi44x0DHh4buytxCIX4qiul156yczIx6GHDKt4GzikryKNGjUyYdN9991nmpOz4ToLc3r06GFm/+PrMaxi8c2IESNwyimnmIosYhVTu3btTLDFCeKcWNG0fft2k3swyOLxOFMfQ6qKcF+Gbc8884ypYGPDczZ5D+W5eyKspLJXrZqwjI/d4jkVJBM6ewgeL65zndPbb79tPgwGUKFg6nf77bebDv3lYYke/6Aw+Sxrdj/ZB1ZNA7673bof2xgYdA7QbQzgqrWjTkVkH+F/qhhG2UMEM3IdMw56mrbb1Ve7cgtN/6tQuUwT+cCm7Xag5WveznUcaqgG7iIiIlJbsJCDzbI5XMsuwBCpDd+/UHOUWvvrnl3e2XiLJWZ2d3mGUvHx8aY6iiVuLGV77bXXvM/hvvZ4z8CLwaoqJqn2+EsOG2SfqmD7Sy3R4WDgiInWDH2Z64HpjwIL3reG+3U8VMP6RBoQBkGJMZFmaZsSV2ED9115hb7AKtd/JkJ7aCG3M+hiBdaOrAKzVIQ9rXyBlS+48t73DCFkkMWKMRERERERQd0LpZikjR8/Hnfffbcpm+O/knO8qT0VIUMmNkF7+eWXzXC9GTNmYMqUKXjjjTe8iR37UqWmpppjMaG7//77zfFYesdyNHaw31fjIqUKcPxNx0OAdsOAxZ8Bc163wqkf7gLmvQMc8ygQk6RLLSJ+2EvKmvkv+KwpToV2A3dHn6tMBlZ2gJVdiAxPqMXeV+yBtWVXvlkq28CdDeWTPc3bed87lDA2CrFRCrBEREREpOGptcP3iA28OHbx008/NaHU2LFjTaMxe3rG77//3oyRZC8pNhS7+uqrzQx9xOkKOf6STcGIDcDY1ItTGvK4HA/KflUcC1oRDd+rJQpygL8/ABa8B6R0Bo593AquRESqQV5hsQmwrAosX8WV3QfLrsrids4+WBnREeHeXld2/yurJ5Yn0PKs47a4KA0hFBEREc//n2j4ntTx4Xu1OpSqLRRK1TJ5mUD+biDJM8NA3i5g2oPAgNOBtB41fXYi0sDxP6s5BcWm7xXDKlOJ5Qmx7KosuycW1+UXuSt1/EiXpxLMEVR5Ay1HiMX7nK1QPbBERETqL4VSUpPqdU8pkTJxyJ5z2N78ycC/M6yl/TBg//OAJuoVJiI1gyFQfHSEWVolx1a4f64JsHyzDzorsJwhFocVcgghq7C27c43S0UiXGFWlZVdbeWdfdBRleUZWshZCDn0UUREROoe1ZpIXf3eKZSSuq/HsUBuOrBsqhVMrfkV6HwEMPBsIKlVTZ+diEi52E8qNioWLZJiQx5C6AuvPLeedQyu7G2s1ioqDr2JOwMpU2Flgir2vbIbuHt6YTmqshrFRCrAEhERqQU4ORjl5OQgNrbi/5cQqUr83jm/h3tCoZTUfY1aAIfcCPT7LzDrFWDVNGD5t8CK74HuY4DhE9R7SkTqhZhIl1maNap4ymc2ZfdWYDmqrUxo5Rg+yIWzEHLWQtMbK7sAqys4NguqGsU6q62sEMsaUhiJJE9Dd25n0OVSBZaIiMg+wUm8ODv91q1bzeO4uDgN3ZfqaVeRk2O+d/z+8Xu4pxRKSf3RuD1wxF3AtqXAXy8D6/7kHxcFUiLSIEVFhCMtMcYsoc5CaAdVbNrO+/5VWdb93XlFcJfAu64inI8iMSbCVFv5zUboCbW81ViedZGu8Cq6AiIiIg1D8+bNza0dTIlUFwZS9vdvTymUkvontRtw9EPAlkVAfKpv/Y6VwMKPgAFnWNVVIiJiMAhqmhBtlooU2QFWQLWVtweWo6k7F7Ya2JVbZJa16RVfcDZnt6utGFbZQwqt+46eWLFRiIkM178Gi4hIg8d+li1atEBaWhoKCyv+ByORqsAhe3tTIWVTKCX1V7Ne/o9nvwas/gVY9g3QdbQ1W5/CKRGRSolwhSMlIdosFeGQwF15vsorq/+VrxorM6fA3DLI2pVbaCqwOJSQyzrkhjQToV11xWbtzmosDi/0VmTFWo81jFBEROozBgRVERKIVCeFUtJw9P0PUJgLrP8LWPIFsOxroNtooL/CKRGRfYHN003fqbgoAPEVBlgcGsjQygRWnkoshlW+x7y1trNnFmci3Lo73yyVGUZoBVieKixHBZZzpkJVYYmIiIjsewqlpOFo3hsY8zCweaFVNcVwavEXwNKvgX6nAIMvqOkzFBFpsMzsf6ZheiTapSCkmQjtyis2cLcbuduVWPZjhlms1nIOI0R6aD252O/KNHR3VGCZqixHk3fNRigiIiKy5xRKSQMOp/72hFOzgJikmj4rERGpBM5C2DyJS0zIwwjtsMpu4m5XX9nhll2VxSosLlt25ZsllCqsRjHOyitf3ytvVZajwTvPXUREREQUSklD1rwPMOYRK5xK6eJbv+pnYNU0q+dUSqeaPEMREanyYYQVT3GcV2g1c7ebtzO02uV87KjK4pBDVmHZIVcozdyjI8L9G7fHBumD5Qm3GHbx/EVERETqI1VKiTCcsvGXxZw3gR0rgJU/Au0OAvY7A0jroeskItJAZjCKjXKZJZQqrGLTC8vZ98oXZGUErGOoxT5Y+ZWowmIexbDKCqzs2QgD+2L5emKpCktERETqEoVSIoFjMA65CZj3llUxteZXa2k9CBhwBtCin7WPiIgIZzragyosu+9VqRAroCqLVVickdAOuNbuCK0Ky+57ZXp02fcd1VemAstzGx2hoYQiIiJScxRKiQRq2hkYeSewcw0w7x1g+bdW3ykuvU4Ahl2layYiIntRhRWLFkmxIVVhMaCy+2Dx1gRW2QyyivyavGc4qrBCnZGQYiNd3oDKbtoeGF45H0e6wvXJi4iISJVRKCVSlsbtgENvAgaeDcx/x5qlr80Q3/aiAiA8gs1KdA1FRGSfVGE1jo8yCxAfci8sO6yy+1yZGQi94ZY1GyFvGXrlFhabZcuuvJDOKS7KFbT6yhdsRaFRTIT3NkIhloiIiJRDoZRIRRq1AIZPAAaeA8Q29q1nULXyJ6DfKUDnwwFXpK6liIjUiV5YDLFyCoq91Vf2cELe9wZb5n6RqcLaxaGEbus5XDZlhhZiJURHoFFshLcPljPQCgy2EmMiTRAnIiIiDYdCKZFQxTXx3Xe7gWVTgV0bgZ/vB/56Cej7H6D7GCAqTtdURERqfYgVHx1hllbJFQ8lZCCVXVDkNxuhXYXlDbYcVVlc2A8rK7/ILBszKg6x2LKRIVap6qvYKF+w5eiXlRgdoZkJRURE6jiFUiJ7gkP2TnwRWPwZ8PcHQPY24PengDmvAz2PA3qf5B9iiYiI1GHh4WGmkolLa0fRcHkh1u78IjOM0B4u6BxOyEosZ7DFpu6cAJe3XNYhN/SZCWOCNHUPaOjOoCs+SiGWiIhIbaNQSmRPRScA/U8Fep8MLJ8KzJ8MZK4H5r4F5GUAB1+naysiIg02xLIDolCwv9XuPHtGQv8Ay9sTy7Ge1VfOmQmRjpBDrMAZCE2oZR5H+AVbGk4oIiLSgEMp9jp48sknMXnyZBQVFeHII4/ErbfeiujoaLN948aNuOOOOzBz5kykpaXh6quvxtFHH13m8V577TW8/PLLyMrKwujRo3HbbbchNrbicnWRCkVEAT2OBbqNAf6dDix4D+gz3rc9Yx1QmAOkdtPFFBERCYK9pNgcnUu7lIovUVGx2/S5svtd8davJ1ZAsMU+WH4hVojsnljeIMtRlcX79jY74IqOcOnzFRERqQ+h1Isvvoh33nkHjz32GOLj4zFhwgQ89dRT5pYh1UUXXYTWrVvjk08+McHU9ddfj86dO6Nr166ljjV16lTz3EmTJiElJQU33XSTuX/77bfXyHuTejykr+MIa3Ga/Rqw4nug1UCrsoq3bJwhIiIie4Sz+jWJjzJLKAqKGGKVrr4yS57VK8uesZD7sRKrpJI9sSg6ItyvEoszEAatzvLcxke5TH8vERGRhqpWhlLFxcV49dVXccMNN2Do0KFm3eWXX44pU6aY+9OmTcOmTZvw7rvvIiEhAR07dsQvv/yCuXPnBg2l3njjDZx11lk49NBDzeOJEyfivPPOw3XXXadqKdm3+H+0nJUvLBzYMNtamnYB+v0X6HAI4KqVfwRFRETqlaiIcDRNiDZLZYYT7sotChpm2eEVZye0H/M5+UVubN2db5ZQhzkyuNKQQhERaahq5S/i5cuXY+fOnRg5cqR33dixY81CrIxiWMVAyvbMM8+UGXD9/fffuOyyy7zr+vfvj8LCQixZsgQDBgzYp+9FGjj+6+chNwIDzwYWvA8s+RLYvhz44W4g4Xlg4DlA97KHnYqIiEjNDicMte0Ehwh6w6ocXwWWs6G7VZllhV25hcWmIfzeDCm0+2GVNaSQj2MiNaRQRERqr1oZSq1fvx5JSUmYM2eOGb7HgGrUqFGmsikqKgrr1q1Dq1at8PDDD+PTTz9F48aNccUVV/iFWLZdu3YhPz/f9J2yRUREIDk5GZs3b67mdyYNVmJz4KArgIFnAYumAIs+AbK2AnmZNX1mIiIispc4BC8+OsIsLREb8pBCX8VV2UMK7e37Ykhh4NBCbmPopSGFIiJS70OpvLw8bNmyJei23bt3m+2PPPKI6f/kdrtNU3PeskF5Tk6O6SXFxubPPfcc/vzzTxNKvffee+jTp0+p1yGGWU58XFBQsA/foUgQMUlWMNXvFGDFd0D74b5tq6YBK38E+o4HmvXS5RMREannQwpTE6PNsjdDCv0qsTzbM6tgSGEjR+WVdesJtEqtYzVWuIIsERGpW6HU/PnzceaZZwbd9uijj5owibPtDR482Ky78cYbcc011+CWW26By+UylU533nknwsPD0atXL8yaNQvvv/9+qVDKnq0vMIDiY82+JzU6Y1/3Mf7r5k8Gtv4DrPoZaNbbCqcYWrGBuoiIiDRoezqk0BtgeYYUOkMsX5C1d0MKI11hZYRYQUKt2EgkxkRopkIREanZUGrIkCFYunRp0G3sGUVsYG7r0KGDGYaXnp5uhuKxrJiBlHN7sOMxvGIwtX37dnTq1Mms4+x9GRkZSE1N3QfvTGQPHXwt8PeHVgXVloXAdwuBxBZAn5OBbkcDUXG6tCIiIlLpIYUtkio3pNBUZHkCLLv6yhteBTwuLC4xy46sArOEitVVzrAqsYJAi0FWpEv/UCciUt/Uyp5SPXv2RGRkpGlEPmzYMLNu5cqViI+PNyFTv3798Oyzz5om5qyasrezz1QgBlesnpo9e7YJwmjevHmmr1T37t2r+Z2JlCOlE3DIDcDgC4BFHwP/fArs3gT89iSwbiZw9EO6fCIiIlJrhhSyGiuv0O0IrJzhVVmhVpGpxuLz8gpDH1ZIsVGuMquvnOvtpu8JMRGmwkxERGqvWhlKcVa98ePH4+6778aDDz5o/oPHpubjxo0zYdIxxxyDp59+GhMnTsR5552HGTNmYPr06Wb4HnHoH/tS2ZVQp556Km6//XZ07drVVFlx2B+Pr+F7UivFNQH2Px/ofzqw/FtgwXv+Q/1yM4DMddYQP87uJyIiIlJD1VgMirg0axRT6WGFQSuwAoKs3XlFpnLLXQLkFhSbZcuuUM8PiI+KCGlIoX2f+7OvloiIVI+wEv6XoRZiz6dJkyaZ2fV4imPHjsUNN9zgbVi+YsUKEy6xN1XLli0xYcIEM0Mfffzxx6ZBunM43wsvvIDXXnvNHJf7sXG63W+qIllZWRg4cKCptmJgJlKt3G7r1h6uOudN4K+XgNRuQO+TgI6HWj2qREREROohVlZlFzCk8oRW5VZiWY85Q+GeYB6VWE41FocRJnpuFWSJiOx9jlJrQ6naRKGU1CozXwQWvA8Ue/o2xDYGehwL9DwOiG9a02cnIiIiUuMCZyssFWAFCbVYhbWnQRZ7d5mgytEDyxteedbbYZe9Xj2yRKQ+CzVHqZXD90SkHOw51WccsOQLYNEUIHsbMOcNYN7bQJcjgRHXa1ifiIiINGiVna2QCovdZrhgRQ3e7SGF3hkLS+BZV4SNyAv59WIjXZ7wyjcroQmuvBVZ1uOkWN96NojnsEkRkfpCoZRIXRSbDAw4Hej7X+Df6cDCj4DNfwMlbv9Ayl0MhFuTAYiIiIhI2Vi51CQ+yiyVDbIYUvkCLf/wyl5vHucXIovN3tkjq7DYLJVp9s6wzVeRZVdg+aqvrPDKP+RKjFafLBGpvRRKidRlrgig06HWsm0pEBnn27ZjJfDVtUCPsdbQPjZQFxEREZEaDbKcPbLs0KrsUMuuyipEYXGJGZaYkVNollDZDd9LV2T5h1rOoYVcz9kYRUT2NYVSIvUFG587Lf0ayEkHZr9mDe1jQ/ReJwBpPTS8T0RERKSGcHY/K/yJZPl7SM9hG+D8IrdfWGVXX1nr/NfbwRb7ZLGDMBu/c9mUGfrwwuiIcL8gy+6L5R1y6FetZa2Pi3JpeKGIVIpCKZH6ashFVgC18GNgy0Jg+bfW0rQr0Ot4oMsowMX/GRIRERGR2ox9pGIiXWZJSwz9eUXFbhNGleqH5eiL5Q208n3VWhxeyBAsP6sA27M8k+tUYvbCBE/jd3Pf0+ydjxOi/ftl2ffZX0u9skQaJoVSIvUVA6fOh1vL1iXAok+AlT8C25cBf71kNUUXERERkXorwhVe6YbvrMrKLij2G1ronLUw2Ho+LihymzArM7fQLJWtHmNw5RdmOWY0ZLDlXG+FXGr8LlIfKJQSaQjSugNpNwEH/J81rC8i2upHRW438PN9QIcRQLsD1RhdREREpAFjxRKDHy4tkkJ/Xn4Rg6wi08jdqs4qxG4OG/QMJeQtHzuHGvI+e2W596BXlrPxu1WF5d/wPTGgWstboRWtMEukNlEoJdLQZu3rf4r/urW/A8u/s5aENKsxevcxaowuIiIiIiGLjnAhOsGFpgnRlbpqdphlB1r28MIsR4Bl3zfrHWHWnjR+pwiXFbyZKqwg4ZVVteUbXmgNQYw0fbY0zFCkaimUEmnoUjoD/U8FlnwBZG21hvaxOXqHg63eU837qjG6iIiIiNSaMMtu/G5XZFmhVWAVFsMsx2NPsFVUXGKWvQ2zEoP2yfJVazkrtxRmiZRNoZRIQ5fYzGqKPvAcYNXPwD9TgC2LrP5TXE56CWjapabPUkRERESkVOP3PQmznAFW6Sos67EddNk9s1iVtadhVqQrDPGeMCs+2uXXM8sMlXT002LIZT/mwiGKIvWZQikR8fxtEAV0HWUt25YB/3wKZK61Kqlsy74FGrcHUrvqqomIiIhInQ2zUhMrF2blFbrNDIVWjyzfMEJnFZZ3CKI9k2FekemXVbiHYRbFRrnMcMJ4T2jlDbeiPOGW6ZPlC7asx+qbJXWHQikRKY2h04jr+F9g39C9gmxg+iNAUR6Q2g3ofgzQeSQQFacrKCIiIiL1OsxiOMQlLRGVD7MclVfZHHLoqdDKstd7GsJb66zHuQXF5hi8te7nV3pGQxNWOQIrX7hlVWxZlVvORvHW9khXeGUvkcgeUyglImWzAykqyAHaHwSs/gXYttRa/ngW6Hw40ONYK6gSEREREZHSYVYlrwmHC5qQylOFZYdZ2QHhlvXYF3rxlsMMWaGVmVtolsqKiQz3hFkBwwy9lVieW7PdqthimBUX6TJhmEhlKJQSkdAkpAKH3w7kZgDLpgKLPwMy1wOLP7eWYVcBvU7Q1RQRERER2UvsJZUUG2kWIHaPmsDb1VfO3lnlhVvZBUVmoASru/IKC7A9q6BS58w8Ki6qdOWV3zDDUj20rH3UDL7hUiglIpUTmwz0+w/QdzywaZ4VSP07A2h3kG8f9qRCiaqnRERERETqQBN4YnUVgynnMMLAYYXWY//KLN4WFLnhLoG3uquy7JkN7SXeEWBZ912mCbxpFO+5tbfHRrrM+5YGEkr99ttvmD59OhYtWoT09HTz4aempqJnz544+OCDMXjw4H1zpiJSu/Av/pYDrIVD+5y9pf56CVj3J9C0qzW0T72nRERERERqNdOHKibSLEiq3HMZSvnCK6shvG/4oS/Y8j0u9K5jmLWnMxs6K7TsaiyGWN7G8FEuzzBEly/oskMvVmpFRWjIYV0JpT755BM899xzyM7OxtChQ3HQQQchOTkZbrcbO3fuxNKlS3HttdciLi4OF1xwAU466aR9e+YiUns4Aym3G4hJAlyRwPZlVnP0P54BOh0OdD8aSOvp36tKRERERETqtKiIcDSJiEKT+KhKPY/DDXMLi70BVXZ+sQm1eGuGGHJYYb7/cEM77OJ9zmzorNDavAfnzp5fzrDKCrN4n/2yHFVbjgourmcQxvcteyeshN+CCpxxxhlo3bo1TjnlFPTt27fcfWfOnIn33nsPmzdvxttvv436ICsrCwMHDsTs2bORkJBQ06cjUjew99Tyb63eUxnrfOu7HAEcdmtNnpmIiIiIiNQD+UXF3jDLGVY579thFocm2lVbfMzeWXuLoZQvsLKGGJqhhgFhVuCQxIQG0EcrK8QcJaRKqYkTJ6Jjx44hvTCH73FZuXJl6GcrIvWz9xT7TvUZB2yaDyz5Elg9DWjR37dP3i5gyyKgzWAg3FWTZysiIiIiInVMdIQL0QkupOxB7UhRsdsKs9hHyxFWeau2HOsDw66cgmLTFJ7DFtOLCpCeXbmm8HYz+4SAMIvBVaPYSBzRsxk6pTaMgpiQQqmffvoJ8fHxaNasWcgH7tSpE/YWi7iefPJJTJ48GUVFRTjyyCNx6623Ijraati2ceNG3HHHHaY6Ky0tDVdffTWOPvrooMfKzMws1e+Kww///PPPvT5PEamo91R/a8m/Egh3/LWz4nvg18eB+KZA16OAbqOBpNa6nCIiIiIisk9FuMKRFMeFMxyi0k3hcwo9Qww9wVWOZ7ihN9DyDkl0DkPk8MQi8/xidwkycwvNAuT5HX9HVj5uGdMTDUFIodT777+PRx55xJReHXvssSYcSkqqZOezPfDiiy/inXfewWOPPWZCsQkTJuCpp54ytwypLrroIjOskP2uGExdf/316Ny5M7p27VrqWCtWrDAh1BdffOFdFx6u8Z8i1So6IO0vYf+pRkD2dmDuW9bSoh/QfQzQYQQQGaMPSEREREREal1TeHtYXrNGlS++4dDBsiqx8gqLMbRjUzQUIYVSU6dOxT///INvvvkGL730Eu6++24MGzbMBFSHH364t3KpKhUXF+PVV1/FDTfcYBqr0+WXX44pU6aY+9OmTcOmTZvw7rvvmvGJHF74yy+/YO7cuUFDqVWrVqFDhw5mpkARqSX6nAz0GAus/Q1Y8hWwfqY11I/L708Bp36gYEpEREREROoN9pFic3UuTROqPkupt7Pv9ezZ0yzXXHMNFi5caAKqRx991AynYzB1zDHHmKDK5aqavjDLly83s/qNHDnSu27s2LFmIVZGMaxyNsx65plnyjweK6Xat29fJecmIlUoIgroeIi1ZG0Fln1jBVQpnfwDqZU/Ai0HALGNdflFRERERETqgT0av9a7d29ce+21+P777/H666+jZcuWePDBBzF8+PAqO7H169ebIYJz5szB8ccfjxEjRuDee+9FQYHVQGzdunVo3rw5Hn74YfO6DKt4PmVh43XOCHjyySeb/dl/auvWrVV2viJSBRLSgP3OBP77DjDiBt/6zA3A9xOBt04CvrkZWDUNKObYaxEREREREan3lVLBpKenY8mSJWbhULru3btX6vl5eXnYsmVL0G27d+8229nL6qabboLb7TZNzXl72223IScnx/SSYmPz5557zjQsv+KKK/Dee++hT58+QYfvNWnSxByLYzjZp+riiy/GBx98UGXVXSJSRdjvjb2mbHmZQGp3YNsSYM2v1hKdCHQeaTVIT+1mNVQXERERERGROiOshAlNJTBE+vbbb83CKqYuXbqYYIjD91gxVRkMks4888yg2zg0kEMF33zzTe+seayE4rp58+bhggsuwJo1a8x52A3LL7nkEqSkpJieV4Fyc3PN2M2YGGs40I4dO8xww7fffhv77bdfueeZlZVlmrzPnj3bb7igiFSz9NXAsqnAiu+s5ui2UXcDHQ7WxyEiIiIiIlILhJqjhFQptXbtWm8QxX5SrVq1wpgxY0zlEme721NDhgzB0qVLg25jzyhiA3MbG5Xn5+ebCq20tDQTMjln0OP2so4XGxvr95jhFWfjK6tSS0RqoSYdgAMuBgZfCGyYZfWf2jAHaG0F18aqn4HiIqD9MDVJFxERERERqcVCCqVGjRplZq076qijTGPzvn377vMTY1P1yMhIMzSQFU12X6j4+HgTJvXr1w/PPvusmaXPHn7H7QzMgiV0hx56KJ588kkccMABZh3DKDZSd4ZeIlJHMIxuM9ha2FvKFWmtZ+HnrFeAnWuAyDig06FA1yOB5n01vE9ERERERKQuNjp/9dVXMW3aNNxyyy3VEkgRy7vGjx9vhuJxuN7cuXNNU/Nx48YhIiLCDBdkf6mJEyeaYXwchjd9+nTzHGI/qm3btnmPxbKx+++/HwsWLMCiRYtMo3M2PO/WrVu1vB8R2UfsQIrcRdYsfoktgMIcYMmXwGdXAJNPBWa9CuzapI9BRERERESkrvaUYoNxNgdn43B7JjwnBj9VhcefNGkSPv30U9OcnDPs3XDDDYiKijLbV6xYgTvvvBPz5883/awmTJhgqrro448/Nk3N7eF8mZmZeOCBB/DTTz+Z4x5++OGm6osz/FVEPaVE6hi3G9i8wOo/xeF8DKioyyjgsFtq+uxERERERETqtVBzlEqHUpyxjlVLBx54oLdp+L4KpWoLhVIidVhhLrB6utV/qt8pQJv9rfU7VgJ/vQx0OQJodyAQEV3TZyoiIiIiIlIvVGmj88AZ81555RUMGDBgb89RRGTfi4wFuo6yFqfl3wFrfrUW9p/qOALofATQcoDVs0pERERERET2qUqHUmwMzn5NIiJ1WrfRQLgLWPE9sHszsPRra4lvCnQ6HNjvTCC67ERfREREREREqjmUYl+myy67DMcee6zp4xQeUFFw/PHH7+UpiYhUg8btgMEXAIPOA7b8bVVOsf9U9nZrqN/gC337FuQAUXH6WERERERERGoylHr//ffNbHfvvvsuoqP9e7CEhYUplBKRuoXBeot+1nLgFcD6mUDeLsAV4Wua/uE5QHyq1Sids/vFNKrpsxYREREREWl4odSHH36IRx99FEcfffS+OSMRkZoSEQW0H+a/Ln0VkLXFGuK3+W/g18eBNkOAzocBbQ9UBZWIiIiIiEh1hVKNGzdG586d9/T1RETqlqadgVM/sHpPcdmxwtcgnTP2HXQV0F0hvYiIiIiIyD4Ppe644w7cdddduPTSS9G6dWu4XC6/7ewzJSJSrySkAv1PsRZWTq38EVj5E5C5Hkhu49svfTWQtRVoNdA3/E9ERERERESCqvSvposuusjcnnPOOaaHlK2kpMQ8Xrx4cWUPKSJSdzTpaC1skL59OZDiqBxd9Anwz6dAdKLVe6rTYUCL/lbfKhEREREREdm7UOqHH36o7FNEROofhvKpXf3XxSYDsY2B3J3A4s+tJa4J0PFQK6Bq1st6noiIiIiIiIQWSv3+++8YOnSoud+qVauQLttvv/2GAw88UJdYRBqOQecC+50FbJwHrPwBWP0LkJMOLPzI6kF1yuSaPkMREREREZG6FUpxxr1nnnkGp5xyCkaMGIH4+Pig++Xm5uLbb7/F5MmT0aJFC4VSItLwhLuA1gOtZdjVwPq/rB5USW18VVLFhcDnVwGt9rOG+XE4oCqoRERERESkgQkrYTOoEPzxxx949tlnMXfuXPTt2xcdO3Y0M/G53W5kZGRg6dKlWLJkCfr372/6Th100EGoL7KysjBw4EDMnj0bCQkJNX06IlLXrf0D+PoG3+Ok1lY4xWF+KZ0UUImIiIiISIPIUUIOpWyrVq3CjBkz8M8//yA9Pd00N09JSUHPnj0xfPhwtGvXDvWNQikRqVIFOcC/M4DV04B1M4HiAv+AihVWrQfpoouIiIiISL3OUSrd6JwVUlxERGQPRcUBXUdZS0E2sPZ3YNXPwNo/gcz1VrN0W/oqa7hf066qoBIRERERkXql0qGUiIhUoah4oPNIa2EF1cY5Vo8p29y3gRXfA4ktPEP8DgFSuymgEhERERGROk+hlIhIbaqgaj/Mf50rCoiIAXZvAua/ay0moBoBdBgBNOtZU2crIiIiIiKyV8L37ukiIrJPHXIDcOYU4IiJQKdDHQHVZGD6w/77Vq5FoIiIiIiISI1SpZSISG0XGesbuleYB6z70+pBldbDtw+H/n1wNtBmf6D9wUCr/QBXZE2etYiIiIiISNWHUuye/vrrr2PNmjV47rnn8Pnnn6NVq1YYM2YMqgonBXzyyScxefJkFBUV4cgjj8Stt96K6Oho3Hjjjfjkk09KPWfIkCF44403gh7vtddew8svv2w6wI8ePRq33XYbYmNjq+x8RUSqRWSMNXSPi9P6mUDWFmDxF9bCXlVthwIdhgOtB1tDA0VEREREROry8L1vv/0WF154oQmhVq9ebQKjiIgIExS98847VXZiL774ojneI488gpdeegl//PEHnnrqKbPtlltuwYwZM7zLe++9h6ioKJx55plBjzV16lTz3LvuusuEafPnz8ekSZOq7FxFRGpcu2HAmEeBnscBcSnWrH5skP7dHcAbxwGrp9f0GYqIiIiIiOxdKMVw584778QNN9wAl8tl1p177rm477778Oqrr6IqFBcXm2PxNYYOHYq+ffvi8ssvx6JFi8z2xMREpKamehdWVB111FEYOXJk0OOxeuqss87CoYceao41ceJEfPTRR8jNza2S8xURqXGuCKD1QGD4NcBpHwLHPQ30+y/QqBVQXACkdPbtu24msPBjIGtbTZ6xiIiIiIg0cJUevsche/379y+1nmHPli1bquSkli9fjp07d/qFTGPHjjVLoN9//x1//fWXqYYqK+D6+++/cdlll3nX8fwLCwuxZMkSDBgwoErOWUSk1ggPB5r3tpYhFwOZ64BGLXzbF30CrPkN+PVxIK2nNcSv/XAguU1NnrWIiIiIiDQwla6U6ty5M6ZPLz0MhD2euK0qrF+/HklJSZgzZw6OP/54jBgxAvfeey8KCgpK7fvCCy/ghBNOQIsWjh9cDrt27UJ+fj7S0tK86zjcMDk5GZs3b66S8xURqbXCwoDktv7rWg8CmvW27m/9B/jzeeC904H3zwL+elmz+ImIiIiISO2slLrppptw8cUXmx5PrDZio3NWTy1cuBDPPvtsyMfJy8srs7Jq9+7dZjv7SfH13G437rjjDnPLBuW2devWmfNgj6nyXofYc8qJj4OFXCIi9V7vk6wlewewZgaw+hdg41xg579ATJIVZNk2LQBSuwER0TV5xiIiIiIiUg9VOpQaNGgQvv76a29T84yMDDMc7qGHHkLLli1DPg6bjZfVmPzRRx81YRJn2xs8eLBZx0bq11xzjQmgwjk0xdPAvEePHuVWaHG2PgoMoPhYs++JSIMWn2I1RueSt8vqNeWcpS93J/D5lYArEmi9P9DuIKDtAUBck5o8axERERERaaihFLG5+JVXXrlXLzxkyBAsXbo06LaZM2ea244dO3rXdejQwQzDS09PR9OmTc06DiM8/PDDy30dDtNjMLV9+3Z06tTJrOOMgQzT+D5ERARATCOgS8BkEbs2AfFNgaytwL8zrIVVVM16WbP9dTzEv1eViIiIiIjIvgylDjvsMIQ5h3Z4cF1kZKQJekaPHo1TTjkFe6pnz57mWGxEPmzYMLNu5cqViI+PNyETlZSUmAbmHEpYHlZV9enTB7NnzzZBGM2bN8/0lerevfsen6OISL3XrCdw6vvAjpXWML9/fwW2LwM2L7QWDvWzQ6mifCA8Agi3ZmUVERERERGp8lDq9NNPx1NPPWVuOWyP4RD7Sb355ps46aSTTENx9pbKysrCBRdcgD2RkJCA8ePH4+6778aDDz5oXuPhhx/GuHHjTJhEGzZsQHZ2dtChexz6x75UdiXUqaeeittvvx1du3Y153fnnXea42v4nohIBfiPEE07W8vAs62qqTW/WrP3cSif7Z/PgLlvAG2HWsP8ONzPORRQRERERERkb0OpKVOmmLBozJgx3nUcQtetWzfT9Jzb2eeJ/aD2NJSye0hNmjQJF154oQmlxo4diwkTJni379ixw9xylr5AX331lWmQbg8P5LkyxGIwxV5So0aNwnXXXbfH5yYi0mAlpAG9TrAWJzZKZ1+qZVOthX2oWvS3gisGVUmtauqMRURERESklgorYeJTCayO+uijj7z9mWwcXnfCCSdgwYIF2LhxoxnCx2bm9QGrvgYOHGiGALKKS0REAriLgc1/W32nWEm1a6NvmysKOPsL3wx+/M9OkGHgIiIiIiKCBpWjVLpSiqHUk08+ifvuuw9xcdbQjJycHDz99NPo27eveTxt2jS0a9dub85fRETqEvaSatnfWoZeCmSsBdb+bi2R8b5AijijX2xjq4KqzWDN5iciIiIi0kBVOpTi0D02Fx8+fDjat29vhtatWbMGLVq0wBNPPIEZM2aYwOrxxx/fN2csIiK1G6ugGrezln7/Bdxu3zb2pNrkqaJd9bO1b2p3K6Di0rSLqqhERERERBqISg/fo+LiYvz+++9YtmwZXC4XunTpgqFDh5oZ+NLT080+TZo0QX2h4XsiIlWEAdW2JZ4qqj+s2fyceh0PDLtal1tEREREpA7bZ8P3iEHUsGHDzGJjA/HFixejX79+e3bGIiJS/4WHA816Wsv+5wHZ261wiiHVhtlAc2sYuLF9BfDns55hfkOApNaqohIRERERqUcqHUrNmTMHEydOxIoVK+B2DsnwhFULFy6syvMTEZH6LL4p0OMYaykq8N+29jdg/SxrwZNAo5ZWD6rWg4GWA4Aoq6+hiIiIiIjUTeGVfcI999yDVq1a4bnnnkNsbKxpen7rrbciOTkZDz300L45SxERqf8ioqzF1nmk1TS91X5AeIQ1o9+iKcDUm4E3xgLbl9fk2YqIiIiISHVXSi1fvhyTJk1Cp06d0KtXL0RGRuK0005DSkoKXnzxRRx99NF7e04iIiJWZVTf8dZSkANsnAusnwms/RPIywQat/ddpdmvA1lbrEqqVgOB6ERdQRERERGR+hZKsTqKw/SoY8eOWLp0KUaMGIG+ffti9erV++IcRUSkoeNQvfYHWQvn58jdCbgifduXfwtkrgeWfAmEsW9VL6sPFUOqlC5WLysREREREalVKv1/6QcccAAeeeQRbNmyBQMGDMBXX32FjIwM/Pjjj2jUqNG+OUsRERFbWBgQ55jhlSHVQVcCfcYByW2BEjew+W/gr5eAjy8Epvyfrp2IiIiISH2olLrllltw3XXX4dtvv8V///tffPjhhyaoYvXUnXfeuW/OUkREpLyQihVRXHAZsGsTsP4vYN2fwIY5QNMuvn3dxcBX1wFpPYDW+1sVVc6KKxERERERqTZhJSX8J+Y9x6dzJj5WSbG/VJMmjn+9rieysrIwcOBAzJ49GwkJCTV9OiIiEqriQqAwF4jxVPJuXgh8eqlve2Qs0KI/0HqQtSS3s0IuERERERHZ5zlKpYfv9ejRA+np6d7HYWFh6NKlC4qKinD44Yfv+RmLiIhUNVZB2YEUcXjfITdaM/vFNrYCq7W/A789Cbx/FjB/sj4DEREREZHaNHxvypQp+Pjjj72VUZdeeqmpinLaunUrUlNT981ZioiIVAUGVN1GW4vbDaSvsob6bZgFbFoANO/j23f1L9asfhzmxyoqbouI1ucgIiIiIlKdodQRRxyB9evXm/szZ85E//79ER8f77dPXFyc2U9ERKRO4Ix8TTtbS/9TgKICINzxn8V1M4EdK6xl/ruAKwpo0RdoxaF++wNNOmpWPxERERGRfR1KMYC67LLLzP1WrVphzJgxiIqK2pvXFRERqV0iAv67NuhcoGV/YP0sa8ne5rv/53PAKZOBRi2sfRloBT5fRERERESqZvies4fUV199Vea+xx9/fCiHFBERqd3imli9p7hwTpCMNf4BlR1I0fd3ABlrgZYDgFb7WbfsWSUiIiIiInsXSj3xxBOh7GYCK4VSIiJS73BGvsbtraXPyVZIZWNvqs1/A/m7gcz1wOLPrfUpnYCW+1lD/doOqbFTFxERERGp06HUjz/+uO/PREREpC6FVM7eVBzKt2k+sHEusGG21UB9x0rPstw/lNqyCEjprKbpIiIiItLghRRKBeJMe2+//TZWrlyJ4uJidOzYEePGjUP79u0b/AUVEZEGKDoBaH+QtVBOOrBpHrBhDtC0i2+/3AxgyiVW0/Tmva1KKg71S+sBhLtq7PRFREREROpEKDVr1ixccMEF6Natm5mFj6HUX3/9hbfeeguvvPIKBg4cWGUnV1JSgieffBKTJ09GUVERjjzySNx6662Ijo7GjTfeiE8++aTUc4YMGYI33nij1PrMzEwMHjzYb11ycjL+/PPPKjtfERERbz+qTodZi9PuTUB8UyB7uxVYcaHIOKBFP6DXCRrqJyIiIiINRqVDqQceeACnn346JkyY4Lf+4YcfxqRJk0yAVFVefPFFvPPOO3jsscfMDIB8zaeeesrc3nLLLX7nsGHDBpxxxhk488wzgx5rxYoVJoT64osvvOvCOeRCRESkurAi6rQPgcx11jA/hlIc8sd+VGt/BzqO8O3L/lRr/7AqqRp3sIYJioiIiIg05FBq+fLlJoAKdPLJJ+PNN9+sqvMyFVivvvoqbrjhBgwdOtSsu/zyy70zASYmJprFxsqpo446CiNHjgx6vFWrVqFDhw5ITU2tsnMUERHZo35UyW2thZVRbJSevtIKqdgU3bbmd+D3p6z70YlWJVWL/lZI1aSjQioRERERaXihVKtWrbBgwYJS/aPmz5+Ppk2bVtmJMfzauXOnX8g0duxYswT6/fffzRDCqVOnlnk8Vkqp55WIiNQ6rIBi3yln7ylKSAPaDPbN7PfvDGuxQ6pjH7dm+BMRERERaSih1Pnnn4877rjDVB717dvXG0ixSuqaa66pshNbv349kpKSMGfOHDN8jwHVqFGjcN111yEqKspv3xdeeAEnnHACWrRoUebx2JSdfalY0bVlyxYMGjQIN910E9LS0qrsnEVERKoMh/JxKS4Cti/1zO43zwqpivKApNa+ff962Zrpr2V/q6IqpYsqqURERESkfoRShYWFiIyMNPdPPPFEc8vG5hxex6bjHBZ37733YvTo0ZV68by8PBMQBbN7926z/ZFHHjHhkdvtNmEYb2+77TbvfuvWrcMff/xhekyVhyFakyZNzLHYQJ1B18UXX4wPPvgALpdmPBIRkVrKFQE062Ut/U8F3MVAxlogItq3z5rfgB0rgDW/Wo+jEoAWfX1D/lK7WcMGRURERERqkbASJjQV4Kx17Nd0zDHHlJrBbm9w5ruyGpM/+uijpvKKFVj2a37//fdm3bx587xNyl966SV89dVX+Pjjj8t9rdzcXISFhSEmJsY83rFjB4YNG4a3334b++23X7nPzcrKMrMKzp49GwkJCXv4bkVERPaRrUuATfM8lVQLgIJs37b4VOC0D3yh1M5/gcSWQIR/1bGIiIiISFUJNUcJqVLq1ltvxTfffGOG7jVu3BhHH3206e3Uo0ePvTrJIUOGYOnSpUG3zZw509x27NjRu44VWfn5+UhPT/f2r5o+fToOP/zwCl8rNjbW73FKSoqZja+sSi0REZE6I627tfT7r9U4fcdyK6DikL+EVF8gxW2fXgYU5VszATbvAzTvCzTvDUTF1/S7EBEREZEGJqRQym4wzqSL1UoMqMaPH482bdpgzJgxOPbYY9G2bdsqPbGePXuaIYNLliwxFU12X6j4+HgTJhGLvP7++28zDK88PO9DDz0UTz75JA444ACzjmEU+1Q5Qy8REZE6j5XEHK7Hpd9//Lfl7ADCI4Di3VZgxYXCwq2m6d2OBnpbw/RFRERERPY1awxciFhydfzxx+O5554zM95dcMEFZiY+DusbN24c3njjjSo7Mb4Wg6+7777bDNebO3cuHn74YfM6ERFWlrZhwwZkZ2ejc+fOpZ7PflTbtm3zHotlY/fff78530WLFuHqq6/G8OHD0a1btyo7ZxERkVqNVVNnfAL85y1gxPVA16OARi2BEjewfbkVWtnydgE/Pwgs+QrIXM9/CarJMxcRERGRhtpTqiJsNP7ggw+aqqbFixdXzZkBKCgowKRJk/Dpp5+aqihWa91www3e2fc46x+DK1ZLBc7Ixx5TbGpuDw/MzMzEAw88gJ9++skcl0P+OCyRM/xVRD2lRESkXsveblVNNekINOnga57+zU2+feJSrOF+bKDevJ+1r6e/o4iIiIjInuQoexRK8Sl//fUXvv32WzOcLycnByNHjjQVUwceeCDqG4VSIiLS4KSvBpZ/C2xaAGxbAriL/Lez0qr7GOt+QY7VtyrSv3+jiIiIiDRMWVXZ6JyKiorw22+/4bvvvsMPP/xggqgRI0aYaqODDz64VKWSiIiI1GGsmBpykXWfjdG3LrZm9mNItWUR0Ky3b99lXwO/PQU07WKtb9bLqqpKSKux0xcRERGR2i+kUOq6667DtGnTTBA1dOhQXH/99TjiiCNM03ERERGp5yKigZb9rYXcxVZzdNvOf62+VNuWWsvCj6z18alWODX0UiDemjVXRERERKRSodTGjRtx1VVX4aijjkKTJk1CeYqIiIjUV+Eu/8fDJwADzgA2/w1sWWhVUrFxevY2YNXP1lA/26Ip1nqGVWk9gZhG1X76IiIiIlKHQqm3335735+JiIiI1F0cqtf5cGuhwlxryN+uDf69ppZ9Y623NW7vGPLXG0hqY/WnEhEREZF6L+SeUiIiIiIhYxDVaj9rcep5nBVEsaoqc7019I/Lki+sIX6nfejbd8dKILEFEBWnCy8iIiJSDymUEhERkerTbbS1UO5OYMs/niF/C4GE5r4qKU4O/MXVQP5uTzVVT2u4H5fkdkC4o6eViIiIiNRJCqVERESkZsQ2BtofZC2B8jKAiBggLxNIX2Uti7+wtkXGAT2OsRqoi4iIiEidpVBKREREamdgddr7QPYOYOs/voWz+xXmAGGOZuv5WcAnFwGp3X0VVSmdAVdkTb4DEREREamAQikRERGpveJTgA7DrYXcxUD6aiAq3rfPtiVWfyouK7631rmigKZdgbQeQKfDrLBKRERERGoVhVIiIiJSd4S7gKad/dexMmrMI8CWRVY1FW/Zi8ruVZXc1hdKZawDVv1shVUMrWIa1cjbEBERERGFUiIiIlLXcXa+1oOsxW6SvmuD1USdIVXL/r59N84B/nrJ9zipNZDaDUjtAaR1t4KqiOjqfw8iIiIiDZAqpURERKR+4Qx+DJu4dB3lvy2xpTWcj72pGFx5h/39YG0f8yjQeqB1P3OD1b+qcQfApf9lEhEREalq+j8sERERaTja7G8tlLfLCqe2LQa2LgG2LwVSu/r2XfwZMH+ypz9VF19FFW+T2gDh4TX2NkRERETqA4VSIiIi0jCxn5QzpArEYYBRCUBBltWniouNjdb/8xYQ18R6XJhnDftjlZaIiIiIhEShlIiIiEgwQy8BhlxsDfPjDH9cTEXVMsAVCcQ29u37491WaJXa3aq2atrN6k8V31RBlYiIiEgZFEqJiIiIlIVD9JLbWEuXI6x1xUVA9lb/sGnHSiB3J7D2d2uxMbhq3gcYdbeusYiIiEgAhVIiIiIilcGm541a+q8b9xqwY4XVl2r7cqtX1c5/raAqZ4f/vp9fZVVasZLKXhKbq6JKREREGhyFUiIiIiJ7KzIGaN7bWmxF+VYFVXGBbx17T22aD5S4gXUzfeujE61wqu1QoO84fR4iIiLSINTaaWNKSkrwxBNP4MADD8TgwYNx2223IT8/37t91qxZOPHEE9G/f38cd9xx+O2338o93muvvYbhw4djwIABuPnmm5Gbm1sN70JEREQaLDY+b9YTaNnft44VUsc/Cwy/Buh+jDWrX3gEkL8b2DDbqrSyud3AV9cDfzwLrPgByFhnrRMRERGpJ2ptpdSLL76Id955B4899hji4+MxYcIEPPXUU+Z2x44duPjii81y5JFH4ssvv8Qll1yCb775Bs2bNy91rKlTp5rnTpo0CSkpKbjpppvM/dtvv71G3puIiIg0UOEuIK27tdiKCoCdq60hf41a+dZnrAHW/Wkttsg4IKUTkNIZaD8caD2wes9fREREpL5XShUXF+PVV1/FDTfcgKFDh6Jv3764/PLLsWiRNRXznDlz4HK5cP7556NNmzYmnIqOjsa8efOCHu+NN97AWWedhUMPPdQca+LEifjoo49ULSUiIiI1LyIKSO0G9BzrHzLFNQFGXA/0PA5I6wm4ooDCHGDz38CiT4DNC3z7Zm8HfroPWPABsHEukLerRt6KiIiISJ2vlFq+fDl27tyJkSNHeteNHTvWLJScnIyMjAx8++23OOKII/DDDz8gOzsbXbt2DRpw/f3337jsssu86zjkr7CwEEuWLDHD+URERERqnZgkoPsYayF3MZCx1mqkzqbqrQf59mWV1bKprA/3rUts4auq6jgCaNKx+t+DiIiISF0LpdavX4+kpCRTEcXhewyoRo0aheuuuw5RUVEYNGgQTjvtNFxxxRUIDw83wdP999+Pjh1L/8/Wrl27TC+qtLQ077qIiAgTbG3evLma35mIiIjIXgz9a9LBWjDKf1tyG2DQOZ4ZAFcAuzf5ln9nAEmtfaEUQ63l3wIpXYCmnYGkttaMgiIiIiLVrMb+DyQvLw9btmwJum337t1m+yOPPGL6P7ndbtxxxx3mlg3PWRW1bt06U/3EIXmsmLrnnnvQr18/dOrUqdTrEMMsJz4uKHDMhiMiIiJSVyW3BQae7XvM4XvpK62AasdyINXRw2rjPGDB+77HHBbIoIshFSurOhwMxDet3vMXERGRBqnGQqn58+fjzDPPDLrt0UcfNWHSrbfeambeoxtvvBHXXHMNbrnlFrz00ktmdj57SF6vXr2wYMEC0zuK/aKc2GuKAgMoPo6Njd1H705ERESkBsU0AloOsJZAnPGv94meYYArrT5VHP7HhdJ6+EKpdTOBTfOtKisGVkltrIotERERkbocSg0ZMgRLlzqmPXaYOXOmuXUOx+vQoYMZhpeenm4annfv7vgXPwA9evQwvagCcZgeg6nt27d7q6iKiopMT6rU1NQqflciIiL/3959gEdVpv0f/wVSgISW0Is0paqAgBQBAV0RXdFXgXfBFWGta3t3QQXFVVmaqIB/RV1FBcsilkVcwXWtq+AqLKBYQZoU6S0QIJQk/+t+npnMTEiERZiU+X6u6/HMnHNykkk4zsxv7uc+Aoq2Wq38MNnZfoqfVVNZSLVjlVS5fmjfNZ9K386KrKqy7RZQpTaSGvf0ARgAAMBxKJINBJo3b66EhATXiLxz585u3cqVK5WcnOxCJusPtWLFioivWbVqlerUqXPEsazn1BlnnKFFixa5IMzYVfqsr1TeYAsAACCmlColVaztR8NuR26v3cY3WLewysah/dK2H/wwjcN6Wy2dI+1aF6qqsimFpROi91gAAECxUyRDqZSUFPXr10+jRo3S+PHj3VS9hx9+WH379nVhki0HDBigadOm6bzzznNX35s3b57eeOMN9/U29c/6UgUroWzfe++9112dzwKt+++/3x2f6XsAAAA/w/pL2QivqrJeVTbtL2OLv0Jg0MqPpPX/Cd23aX6V6oWqqs7oS0N1AAAQIS7HEp8iyHo+PfTQQ3rzzTddKNW7d28NGzYst2G5BVGPPvqo1q5d66b23X777erUqZPbNnPmTNcgPXx64NNPP+1CLDuuXcnPGqcH+00dTUZGhtq0aeOqrSwwAwAAQB4r3pc2fRMIrVZJBzNC25LKS1e/JcXF+fsLpvjtlQNXE7Ql0wABACgxjjVHKbKhVFFCKAUAAPBfsJeXVknlpv2tlLIOSW0Hh7a/PEDa/VPk11hzdQunqjWV2l3LrxsAgBjIUYrk9D0AAAAUY1YRVb66H/U6Hrm9zSAfWO1cLe1YLWVslvZu8+PAnshQ6u07pVLxvsF6sKrK+lXF++p5AABQfBFKAQAAILrCG6Sbg3ulnT/6gCq+TGi9VVj9tNA3W7crAQbFWYP2OlK9TlKH34fWW98ra94OAACKBUIpAAAAFK7EZKl6Cz/CWfh08cRQRVVwadVUu9ZKVU4L7WuB1POX+Oosq6ayyqrK9fyyQm3feB0AABQphFIAAAAomixIqtXKj/B+Vfu2+8oqC7OCrEeVNU/fbmNlnuPESy0ukzrdGjqGTR+sWJdpgAAAFCJCKQAAABSvflXWFN1GOKuG6j8jUE1l/arWSLvW+OXhTCmhbGjfvVul13/nK7Eq1PLVVJXqhaqrrGdV+P4AAOCkIJQCAABA8We9pCrU9MN6TYVP67NG6qUTI0OpxBRfWZW+3g/NC21v2V/qcKO/bVMFV3/iQysLq8pUiOKDAgCgZCOUAgAAQMkPq8JZ76pBswPTAK2i6ke/tCmB1qvKKqaCtq+QPn4wdL9calhlVT2pdlupUt3oPR4AAEoQQikAAADE9jTAOm0it1l1VXg/qjrtfGBlFVb7dvjx02K/vevtoVBq2wrp61d9ryqrqrJh0wrjw6q0AABALkIpAAAAIG91VVCNM6SLH/a3D+71lVQWUAV7VlVpHNp32zLph39G/i6tb1X5mj6gav1bqcbpoeDLgjEbAADEKEIpAAAA4FjY1f6qNfMjP1WbSu2u9cGVjfR1PsiyKwPaOLNvaN/l70qfTQ6rqgos7T7VVQCAGEEoBQAAAJwIaY38CMrJ8VP90gMhVdppoW0WWFkT9S3f+ZG3uurXk6RarQL7rvf9ryywKluZ6ioAQIlBKAUAAACctL5VaX7Uah257ayBUqMeoYoqV10VWB7aJ6VUD+1rUwIXv+BvJ5WXKtaJHHU7SEkp/A0BAMUOoRQAAAAQbfFJR1ZW5VZXbZfKpobWlU6UyteQMjYHqqu+9yPoN9NDodSyf0gbvzoyuLLvBwBAEUMoBQAAABS1qwKGO+sqPw5l+t5UNp0vOOy+BVZB6xdKK94/8rgp1Xw4dd69fgqgydwtJZSVSiec5AcFAED+CKUAAACA4iChTP7VVeGa9PJN09MtvFrngyurrsrYIu3dJiWGTfOzRuvL3/OhVnhVVYU6/hgpNSKvRAgAwAlGKAUAAACUFHXa+hEuM933q7JpgeFVUTYdMCdb2r3Bj3ULIiu2fveuVCrR31/+vnQg3QdWFWr5IIsKKwDAL0QoBQAAAJRkZSpKNSoeuf7Xj/igKnw6YLC6ysKq+EAgZb6bJW36OvIKgdaM3QKqirWlzkNCVwXMzpJKlY7CAwMAFHeEUgAAAEAs96+yUavVkQ3Xw9VtL5Wt5KcFWlXV4Uxpz0Y/LMgKBlJm9h/9OgusKtQOG4EAy0IyAACKeiiVk5Ojxx57TDNmzNDhw4fVs2dP3XPPPUpK8lcPWbhwocaOHatVq1apXr16GjZsmDp16pTvsdLT03X22WdHrKtUqZLmz58flccCAAAAFBvhIZOxRuvhgdX+nYFG6xt8VVU4W7dvhx+bvoncllxV+u3rofvfz/ZVV8EAq1wafawAIIYU6VBqypQpmj59uiZNmqTk5GQNHTpUkydPdsvt27frxhtvdMPCqjlz5uimm27SO++8oxo1wq5AErBixQoXQs2ePTt3XSkaNwIAAAD/fWBVLtWPmmceub3vVB9MBUMrNwK3LXwKt/h534Q9qHRiIKCqJVVpLLUdHNp2+GDklEIAQLFXZEOprKwsTZ061VU/dezY0a279dZbNWvWLHd78eLFKl26tK699lp338Ip2//LL7/UhRdeeMTxrJqqQYMGqlq1apQfCQAAABBDkspLVZv4kZf1mwqvuKp3jp/qZ4HVnk1S1kFp549+2FUDw0OpV34rZR2Qytf0wzVcD9y2qwaWrx6dxwcAKPmh1PLly7Vz506df/75uet69+7thrGqp127dundd9/Vr371K33wwQfau3evGjdunO/xrFKqfv36Ufv5AQAAAOQR3gDdKq46/yF0P+uwlLFJ2m29qjZIiSlh2w5Je7f6qYL7d0lbvo88bo3TpUsfD93//C9SYrJUwUKrwNUCy1Y+cloiAKBQFdlQav369apYsaKriLLpexZQXXDBBbrjjjuUmJiotm3b6sorr9Rtt93mpuFZZdW4cePUsGHDfI+3cuVK15eqT58+2rx5s/v6u+66S9WqVYv6YwMAAACQR+l4X/Fk44htCdLVb/lqqt0/+aUFV8EAq1L9yHDrq1eO7HWVUNaHU6d0lNrfEFq/a53vdZVQhj8JAMRSKJWZmekCovzs2bPHbZ8wYYILj7Kzs3Xfffe55Z/+9CdXFbVu3Trdcsst6t69u6uYGj16tFq2bKlGjRrlO30vNTXVHcsaqFvQZVP+XnvtNTcNEAAAAEARlpQiJZ0qVTn15/fLPiSdNTAyuNq3TTq0X9qxWko7NXI64asDfYBllVQWWqVU91MCU6r5vlZWhQUAKHmh1JIlSzRw4MB8t02cONGFUna1veBV84YPH64hQ4ZoxIgReuaZZ1y4ZKGUadGihb766iu98MILGjly5BHHs0bocXFxKlPGfwLy6KOPqnPnzu5nOOuss07q4wQAAAAQJVYRFd6LKtgkPWOz711VpkJovV1FMKGcdDDD37YRPjXw1PNDoZQFWLNu8mFVRHhlyxo+NAMAFJ9Qqn379lq2bFm+2xYsWOCW4dPxrFH5gQMHtGPHDn377bdq2rRpxNc0a9bM9aLKT9myZSPup6Wlub5UBVVqAQAAACgh7Kp9ler6ES65ijR4jpS524dWe2w64ObQ7fAqKetptXWpH/lpcpHUbVgowPpmpm++nlIjEFqVp6cVABSXnlLNmzdXQkKCli5d6iqagn2hkpOTXZhkvaCseXneKXp16hw5Bz0jI8NN8XvsscfUoUMHt87CKOtTVVAPKgAAAAAxwqqnbFQ5reB9kipIPcf6Zux7AqGVC682SZnpUrnUyADrs8mRX28VWeUD1VUNukpNevn12dlS5i4asQOISUU2lEpJSVG/fv00atQojR8/3k3Ve/jhh9W3b1/Fx8e75YABAzRt2jSdd9557up78+bN0xtvvOG+3qb+WV+qqlWrumO1adPGNUK341kPqTFjxqhLly5q0iSfS9UCAAAAQLjEclL9c/L/nRzcJ+Vkhe7n5EiNegT6Wm300wIP7fM9rWxUbhDad+8Wafr/SqUT/dRAN6r75uu2rNZMSjuyZy4AlARxOZb2FFEHDx7UQw89pDfffNOFUr1799awYcPc1feMBVHWG2rt2rVuat/tt9+uTp06uW0zZ850Tc2D0wPT09P1wAMP6KOPPnLHtSDL+lXZFf6OxiqtLNRatGiRC7gAAAAA4JgdPhCqqrJhzdarN/fbNn8rvXmzD7Ly0/q30tnXBd6YbJHeucuHVcHwKjzIKpcmleIiTgAK37HmKEU6lCoqCKUAAAAAnDRZh/2UPwuugks3tkiNL5Qadff7bVwi/f22go8THmDt2yF9/bqUEqi4CgZYiSn0tgJQZHKUIjt9DwAAAABiQul4qUJNP36OTfvrNT4UWLkRuG3TAC10CkpfJ3351yOPYb2tbL8z/1dqepFfd3CvtGWpb/xu0wZtqiIARAGhFAAAAAAUB9aM/RR/4aYjWMP08L5WZSpKp18eGV5ZQ3brbbXzRyn7UGjf7SukOUNC962aygIqC68spDr1PKl2G78t65B0OJOKKwAnBKEUAAAAABR3pUrZf0L3K9eXzvm/yH0OZfqKKgupKp0SWp+d5fe3qYNWNXUwww8Lr0zVJqFQynpgvfV/UkLZQGVVoKdV8HbNllLletF4xABKAEIpAAAAAIgFCWV8GBUeSJnaZ0n9nve3LZSycGrvtsC0wK1StRahfffv8MtD+6Vd6/wI12VoKJTa9LX0rwdCgZVVXQWnCNqoWEdK4kJSQCwjlAIAAAAAeInJfljlVH4a9ZBO6RQIrgLhlVVfuQbtWyO/zq40mL7ej/xYgNW8t7+99QfpixdDwVU5C6/SAssq/mcCUOIQSgEAAAAA/suKq7p+/Jy67aXej4YCq/Dwypbhjdl3rZFWf1Lwsc69U2p6sb+9Y7X0wz+lcmk+uLIgy8Irux+fyF8SKEYIpQAAAAAAJ6cxu/WYOhbWt+qc2wKVV9ukfdt9cGVLm1JYNjWyMfuSlwv+np2HSI26+/u7N0jrFgSCKwuwqvhjuR5cAAoboRQAAAAAoHDl1+sq6OA+qVTYW1frRXVGX2nftsgQK+uglLlbii8T2nfTN9K8SZHHiysllUv11VXtrpXqtvPrrYJrx0ofXtkoU4nwCjjJCKUAAAAAAEVXYrnI+9Wa+REuJ0c6sNsHVOVrhNaXrSzV7xwIrmzskHKyQ2FWTlZo3w1fSB+NiQyvylbyAZVVV7X+rVTzTL/NjmNVWC7csmmDSSfloQMlHaEUAAAAAKB4i4uTylT0I5xVQQUroUx2tr+CYLC6yqYNBlk/qrRT/frMXT68svDJhjn9itC+6/8jfTQ2dD8xJRBQBUIqq+QKBmeZ6f4Ytj6pvP9ZATiEUgAAAACA2GC9pKyvlI28Gnbzw2RnSft3+QDLQiobFljlipPK1wxNGzyY4ceutX7zaT1Du675TPrXOH+7dIKvunJTBAMhVrNLpSqBY1v/LJuuaBVepXm7jpKPf+UAAAAAAIQrVTpwZb80S5iO/N00vsAPmzZoQVIwuHIh1g4ptWFo3+xDvkLqwB4p65CUsdmPoPpdQrftCoT/esDftq+x0MpCLAup7LZdgTB47AMZ0qF9vvcVVx1EMUUoBQAAAADA8bCpeEkpflSul/8+zS7x4/DByMorNzVwu1Qp7OssZLJAzCq1LMSysXNNaHvdDqFQygKsj8eHAizrfxUMsGw07x0WYO0JXcWQAAtFCKEUAAAAAAAn/d13om/CHt6IPS/rW9X8f3zT9v07fXBlSzd2SJXqhvY9vP/IAGvXutB2a/AeEWA96G8nJoeCq2AFVrPeUlojv90dK8NvSwi7kiFwEhBKAQAAAABQlPpeuaqnSlJqg58PsFpc7kMkN3VwZ+SoGB5gZfp+VjZ90PWt2iulry94CmEwwEoo50MrmyIY/JnsewYDrGBwZtutyTx9sPBfIpQCAAAAAKDYXnWwgh86hgDLmrHnVl8Flna/0imhfQ8fkEon+gbuNp0wfV9kgNWwR+j2j/OkTx4O3Q9OI3QhVmWp1ZVStaZ+W8ZWKX2dX++ulFjJB3CIaYRSAAAAAADERP+r8n4U1P/KnH651OJ/fCDlAiwbu6RMuxrhzsgAyxq9W8iUmS7lZIemESowjbD5ZaF9130eGWC5QC0QTlmQ1e46qcbpftvuDdK2H8IqtCpLieUJsUogQikAAAAAABAZGFnvKRvhfazysmbqNrItkEoPC68CAVb49MPSST4Ms/WZu32g5fbbJe2Ur8wKWr9Qmjsh8nvFlfIhlgVU59wm1Wrt1+9YLW34IhRwuWVg0NS9yCOUAgAAAAAAv7APVqBxekEaX+CHsebsVl3lAqpAMBVsym6smsuqplzIle6rr6wSK9gvywKtoE1fS5/+v/y/p/XEOu9eqV5Hf3/L99KKDyKDKzfdMHA7qSLVWFFWZEOpnJwcPfbYY5oxY4YOHz6snj176p577lFSUpLb/s0332jUqFH64YcfdNppp+nuu+9Wq1atCjze7Nmz9cgjj2jr1q3q3Lmz+9rU1NQoPiIAAAAAAOCuGmgN1G3kp1F3P4KsQXtmWCVW2qmhbSnVpAZd/fbwYSGWTUEMv4KgTQn8+rWC/wC/Gik17OZv/7RY+vr1yAArPMSyaYwWnqFkhlJTpkzR9OnTNWnSJCUnJ2vo0KGaPHmyW27fvl2DBg1Sr169NHbsWM2dO1eDBw/WnDlzVKtWrSOO9dVXX2nEiBEaOXKkmjZtqjFjxuiuu+7SU089VSiPDQAAAAAAHCO7cmByFT/yOqWDH+FsOuGhvT7ECv+a1EZSy/55AqywaiwLm4J2rZXWfFrwz/SrP0sNz/W31/xbmv/UkQGWq76qINVqJZWvEfjZsmwuIhVZRTmUysrK0tSpUzVs2DB17OjL7G699VbNmjXL3bZlpUqVdP/996t06dJq1KiR5s2bp5dfftmFVnm99NJLLsC67DLfZO3BBx9U9+7dtW7dOtWt+zPzYwEAAAAAQPGbThhs6h7OpgQGm6nnFQyLgixI6jL0yAqs4Aiv8srYLO388ecDrGAotepf0oejpMSUsD5YFXx4ZcvTekpVwirBSrgiGUotX75cO3fu1Pnnn5+7rnfv3m4YC5NatGjhAqmgJk2a6Msvv8z3eEuWLNF1112Xe79mzZquosrWE0oBAAAAABDjbEphuMr1/TgW9btKFU8JVV25yqvdgdu7pfI1Q/vaeuuJFbxSYfr6yGPVOINQqrCtX79eFStW1OLFi930PQuoLrjgAt1xxx1KTExUlSpVtHTp0oiv2bRpk9svP1u2bFG1atUi1qWlpbmvAQAAAAAAOG7JaX4ci6aXSA3OzT+8OrBbqlQvpv4QhVYplZmZqc2bN+e7bc+ePW77hAkTXO+n7Oxs3XfffW75pz/9yQVUTzzxhF599VVdfvnl+uyzz/TBBx+oevXqBX4vC7PC2f2DB8MuOQkAAAAAAHAylY7/+SbvMabQQimbOjdw4MB8t02cONEFSXa1vbPPPtutGz58uIYMGeIaljdu3NhdPW/06NEurGrWrJn69++v+fPn53s8u2Jf3gDK7pctW/YkPDIAAAAAAAAU2VCqffv2WrZsWb7bFixY4JYNGzbMXdegQQMdOHBAO3bscNP3rrjiCte43K7EZ1PzrHl5nTp18j2eVVBt27YtYp3dr1q16gl9TAAAAAAAADg2pVQENW/eXAkJCRF9o1auXKnk5GR31b3PP/9cf/zjH12jcwukcnJyNHfuXBd05adly5ZatGhR7v2NGze6YesBAAAAAAAQfUUylEpJSVG/fv3cFD27ot4XX3yhhx9+WH379lV8fLyrmvroo480ffp0dyW+kSNHKj093VVOBafmbd26VVlZdklHual9b775pl577TUXdN15553q1q0bV94DAAAAAAAoJEUylAr2kOratauuv/56N7p06aKhQ4fmTsd75JFH9OKLL+qSSy7R6tWrNXXqVFdJZSzE6ty5s6uGMq1bt9af//xnPf744y6gsiv7jRs3rlAfHwAAAAAAQCyLy7G5b/hZGRkZatOmjZsCaFVcAAAAAAAA+GU5SpGtlAIAAAAAAEDJRSgFAAAAAACAqCOUAgAAAAAAQNTFR/9bFj/Btls2JxIAAAAAAAAFC+YnR2tjTih1DPbu3euW55577rHsDgAAAAAAEPP27t2r8uXLF/h74Op7xyA7O1tbtmxRcnKy4uLiYv4fFQAAAAAAQEGsQsoCqWrVqqlUqYI7RxFKAQAAAAAAIOpodA4AAAAAAICoI5QCAAAAAABA1BFKAQAAAAAAIOoIpQAAAAAAABB1hFIAAAAAAACIOkIpAAAAAAAARB2hFAAAAAAAAKKOUCpGHDhwQHfffbfatm2rzp0767nnnivsHwkoVJs3b9Ztt92ms88+W126dNG4cePceWLWrVunQYMGqVWrVrrooos0b948/lqIaddff72GDx+ee/+7775T37591bJlS11xxRX65ptvCvXnAwrLwYMHNXLkSLVr106dOnXSxIkTlZOT47ZxngDSxo0bdcMNN+iss85Sjx49NG3atNxfC+cIYv3549e//rXmz5+fu+5o70H+/e9/u6+x118DBw50+5cEhFIx4sEHH3RvGp5//nndd999mjx5st55553C/rGAQmFvGCyQ2r9/v/76179q0qRJ+uijj/TII4+4bTfffLOqVKmiv/3tb7r00kt1yy23aMOGDfy1EJPmzJmjjz/+OPf+vn37XEhlH3LMnDlTrVu3dm84bD0Qa0aPHu3eJDz77LOaMGGCXn31Vb3yyiucJ0DAH/7wB5UrV849X9gH5PZa67333uMcQUyzD8KHDBmi5cuX56472nsQW9r2yy+/XK+//rpSU1N100035X4QUpzFF/YPgJPP3ii89tprmjJlilq0aOGGnQD2ZvzCCy/kT4CYs2rVKn355Zf69NNP3f/4jYVU48ePV9euXd2nDjNmzHAvoho1aqTPPvvMPTnceuuthf2jA1G1a9cu96HGGWeckbvu7bffVlJSku68807FxcVpxIgR+uSTT9wHHfZCCYil88OeG6ZOnaozzzzTrfvd736nJUuWKD4+nvMEMS89Pd293ho1apTq16/vhlWn2+sq28ZzCWLRihUrNHTo0CPCpM8///xn34PY+/nTTz/dPc8Ym+VxzjnnaMGCBWrfvr2KMyqlYsDSpUt1+PBh92l2UJs2bdyLpuzs7EL92YDCULVqVT3zzDO5gVRQRkaGOy+aN2/ungzCzxd7UQXEGgtq7ZO6U089NXednSN2TlggZWxp0zI4RxBrFi1apJSUFDcNPMiqCO2NAucJIJUpU0Zly5Z1VVKHDh1yHwouXrxYzZo14xxBzAqGSFZVG27JUd6D2HarUg+yc8uKTUrC6y9CqRiwdetWVa5cWYmJibnr7M24lQ3ap3xArKlQoYL7pC7IwtmXXnpJHTp0cOdLtWrVIvZPS0vTpk2bCuEnBQqPfTq3cOFCVxoejnME8OwT7dq1a2vWrFmu8vy8887T448/7p5TOE8AuUqoe++91735th44vXr1chXp1pOQcwSxasCAAW4qq4VK4bYe5T1IST5nmL4XA6xvTnggZYL3rcEaEOseeugh12zT5mdbA878zhfOFcQS+9DC+g/amwn7pPtYnlM4RxCL7RHWrFnjplpYdZS9YbBzxt5ocJ4A3sqVK9W9e3cNHjzYtQ+xqXwdO3bkHAHy2H+U11cl+XmFUCpGPqXI+481eD/vmw0gFgMpuwCANTtv3LixO1/yVhDa+cK5glhiF8OwvgXhFYVHe07hHEGssb5RNu3bGpxbxVSwEe3LL7+sevXqcZ4g5lnFrX3gZxfLsOcI609oVz9+8sknVbduXc4RIEzSUd6DFPT6y2aAFHdM34sB1atX186dO11fqSD7NM/+gZeEf8TA8bJP66xBrQVTPXv2zD1ftm3bFrGf3c9bLguU9Cvuvf/++64XoY233nrLDbvNOQKE+hPam4RgIGUaNGigjRs3cp4AkrvytwW04R9aWM8cC295LgEiVT/Ke5CCtttzUXFHKBUDrJmgfZoX3gTNmnPapxWlSvFPALFbCWJTLiZOnKiLL744d731PPj222+VmZkZcb7YeiBWvPjiiy6Esl45Nnr06OGG3bZz4Ysvvsi9aowtrXEt5whijf2bt6muq1evzl1njZwtpOI8AeTeTNsU1/DqDjtH6tSpwzkC5POc8u3PvAexpd0Psul81n6kJLz+IpGIAdbb4LLLLtP999+vr776yn36/dxzz2ngwIGF/aMBhdbf4IknntB1113nrmphlYPBYVdRqlmzpu666y7X++Dpp592502fPn34ayFm2Jtq+3Q7OJKTk92w29bQeffu3RozZoy7rLEt7YWRNbAFYknDhg3VrVs393xhVzqeO3eue87o378/5wkguQ8zEhISdM8997jw9sMPP9Rf/vIXXXXVVZwjQB5nH+U9yBVXXOE+BLT1tt32s4DXruRX3MXlBD/qRIlmbxgslHr33Xfd5YuvueYaDRo0qLB/LKBQ2P/MrQdIfpYtW+Y+1RsxYoS79Kq9CbcrZHTq1CnqPydQVAwfPtwtH3jgAbe0F0nWCN0C3iZNmmjkyJFuSgYQa/bs2eOmgr/33nvuQ0C7qtLNN9+suLg4zhNAyv3wwp43UlNTdeWVV+rqq6/mHAEk9xrqhRdeyA2WjvYexPqzjR071l1xz1oq2POP9Wcr7gilAAAAAAAAEHVM3wMAAAAAAEDUEUoBAAAAAAAg6gilAAAAAAAAEHWEUgAAAAAAAIg6QikAAAAAAABEHaEUAAAAAAAAoo5QCgAAAAAAAFFHKAUAAAAAAICoI5QCAAD4hYYPH64mTZoUOGbOnOmW69evj8rvOicnR1dddZVWrlx5Qo97++2369NPPz2hxwQAALErLsdetQAAAOC47dmzR5mZme7222+/reeee06vv/567vaKFSsqPT1dqampKl269En/TVsINn/+fI0fP/6EHnfNmjX6/e9/r1mzZikxMfGEHhsAAMQeKqUAAAB+ofLly6tq1apu2G0LnoL3bViAY8toBFL2eeOTTz6p/v37n/Bj16tXT7Vq1XLBGwAAwC9FKAUAAHCS2bS98Ol7dvsf//iHevXqpZYtW2rIkCFat26dBg4c6O4PGDBAmzdvzv369957TxdddJHb1qdPHy1YsKDA7zVv3jzt37/f7WusYqpHjx6ucuucc85Ru3btNGXKFP3nP//RhRdeqNatW+vOO+9Udna223/p0qX6zW9+476+S5cumjx5csTx7VgzZsw4Sb8pAAAQSwilAAAACsGjjz6qBx54QE899ZTeffddV9lkwwKfrVu3uuAoGBINGzbMTZv7+9//rt69e+u6665zU+nyM3fuXHXs2FFxcXG567Zs2aL3339fL774om688UZNnDhRY8eOdd/fblvl0wcffOD2tYCqWbNmmj17tsaMGaNnnnlGH3/8ce6xLNhasmSJdu/efdJ/RwAAoGQjlAIAACgEgwYNctVIHTp0cCFQp06dXOWU3b7gggu0evVqt9+zzz6rfv366ZJLLnHT56yaqmvXrnr55ZfzPe53332nRo0aRaw7dOiQC7YaNmyoK6+80lVF2bJVq1bq3r27+56rVq1y+/7000+qVKmSateu7b7P1KlT1bx589xj1a1bV/Hx8fr+++9P6u8HAACUfPGF/QMAAADEIgt3gsqUKeNCoPD7Bw8edLftCno21e+VV16JCJk6d+6c73F37NihypUrF/j97NimoO93ww03uOop+37dunXTpZde6vphBZUqVco1bt++ffsvevwAAACEUgAAAIUgb9NzC3vyk5WV5abrXXbZZRHrg+FSXjZtz74mL6tuOpbvd/3117uKLZvu9+GHH+rqq6/WqFGj1Ldv39x9rNKqoK8HAAA4VryaAAAAKMIaNGjgGqTb1L3gsCqmTz75JN/909LStGvXruP6XgcOHNDo0aPd1QIHDx7selDZ1MF//vOfEYFUenq6qlSpctyPCQAAwBBKAQAAFPHeU9aI/IUXXtDatWs1bdo0N+rXr5/v/tb/admyZcf1vZKSkrR48WJXGWU9pr7++mstXLgwoqeUTSc0TZs2Pc5HBAAA4BFKAQAAFGHWjPzBBx/U9OnTddFFF+nVV1/VhAkT1K5du3z379KliwuWcnJyjuv7TZo0Sfv371efPn10zTXXqG3btrrppptyty9atEitW7dWSkrKcT8mAAAAE5dzvK9YAAAAUORYP6mePXtq3LhxBQZXv8RVV13lAitrgA4AAPBLUCkFAABQwhqoW7PyGTNmnPBj29S9jRs3uootAACAX4pQCgAAoISxSqYNGzbk9n86UR5//HHde++9SkhIOKHHBQAAsYnpewAAAAAAAIg6KqUAAAAAAAAQdYRSAAAAAAAAiDpCKQAAAAAAAEQdoRQAAAAAAACijlAKAAAAAAAAUUcoBQAAAAAAgKgjlAIAAAAAAEDUEUoBAAAAAABA0fb/AQWAZB66Iq8SAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Build a per-cell summary of which modifications were applied\n", "# (based on the config's node_set / compartment_set targeting)\n", diff --git a/tests/test_simulation/test_modifications.py b/tests/test_simulation/test_modifications.py index 4d0620f3..85f213b0 100644 --- a/tests/test_simulation/test_modifications.py +++ b/tests/test_simulation/test_modifications.py @@ -366,7 +366,7 @@ def test_warns_zero_sections(self, caplog): class _CellWithoutApical: """Helper cell-like object that raises AttributeError for 'apical'.""" - sections = {} + sections: dict[str, object] = {} @property def apical(self): From 433ec7f88dda25dc99032ccfc7eff779be8c202f Mon Sep 17 00:00:00 2001 From: "@darshanmandge" Date: Fri, 20 Feb 2026 10:44:18 +0100 Subject: [PATCH 4/8] Fix PR comments: fixed type attribute per subclass and lowercase matching --- bluecellulab/circuit/config/sections.py | 15 +++++++-------- bluecellulab/simulation/modifications.py | 2 +- 2 files changed, 8 insertions(+), 9 deletions(-) diff --git a/bluecellulab/circuit/config/sections.py b/bluecellulab/circuit/config/sections.py index 6e99b3a7..e1027770 100644 --- a/bluecellulab/circuit/config/sections.py +++ b/bluecellulab/circuit/config/sections.py @@ -150,7 +150,6 @@ class ModificationBase: """Base class for all modification types.""" name: str - type: str @dataclass(frozen=True, config=dict(extra="forbid")) @@ -165,7 +164,7 @@ class ModificationTTX(ModificationNodeSet): """TTX modification — blocks Na channels on all sections of target cells.""" - pass + type: Literal["ttx"] = "ttx" @dataclass(frozen=True, config=dict(extra="forbid")) @@ -173,6 +172,7 @@ class ModificationConfigureAllSections(ModificationNodeSet): """Applies section_configure to all sections of target cells.""" section_configure: str + type: Literal["configure_all_sections"] = "configure_all_sections" @dataclass(frozen=True, config=dict(extra="forbid")) @@ -180,6 +180,7 @@ class ModificationSectionList(ModificationNodeSet): """Applies section_configure to a named section list of target cells.""" section_configure: str + type: Literal["section_list"] = "section_list" @dataclass(frozen=True, config=dict(extra="forbid")) @@ -187,6 +188,7 @@ class ModificationSection(ModificationNodeSet): """Applies section_configure to specific named sections of target cells.""" section_configure: str + type: Literal["section"] = "section" @dataclass(frozen=True, config=dict(extra="forbid")) @@ -195,38 +197,35 @@ class ModificationCompartmentSet(ModificationBase): compartment_set: str section_configure: str + type: Literal["compartment_set"] = "compartment_set" def modification_from_libsonata(mod) -> ModificationBase: """Convert a libsonata modification object to a BlueCelluLab dataclass.""" - type_name = mod.type.name # e.g. "ttx", "configure_all_sections", etc. + type_name = mod.type.name.lower() # e.g. "ttx", "configure_all_sections", etc. if type_name == "ttx": - return ModificationTTX(name=mod.name, type=type_name, node_set=mod.node_set) + return ModificationTTX(name=mod.name, node_set=mod.node_set) elif type_name == "configure_all_sections": return ModificationConfigureAllSections( name=mod.name, - type=type_name, node_set=mod.node_set, section_configure=mod.section_configure, ) elif type_name == "section_list": return ModificationSectionList( name=mod.name, - type=type_name, node_set=mod.node_set, section_configure=mod.section_configure, ) elif type_name == "section": return ModificationSection( name=mod.name, - type=type_name, node_set=mod.node_set, section_configure=mod.section_configure, ) elif type_name == "compartment_set": return ModificationCompartmentSet( name=mod.name, - type=type_name, compartment_set=mod.compartment_set, section_configure=mod.section_configure, ) diff --git a/bluecellulab/simulation/modifications.py b/bluecellulab/simulation/modifications.py index 3856bf16..841cc56d 100644 --- a/bluecellulab/simulation/modifications.py +++ b/bluecellulab/simulation/modifications.py @@ -146,7 +146,7 @@ def apply_modifications( elif isinstance(mod, ModificationCompartmentSet): _apply_compartment_set(cells, mod, circuit_access) else: - raise ValueError(f"Unknown modification type: {mod.type}") + raise ValueError(f"Unknown modification type: {type(mod).__name__}") def _resolve_target_cells(cells: dict, mod, circuit_access) -> list: From e9a9ada5cb3b6845435876dd7e985f3e58347c4e Mon Sep 17 00:00:00 2001 From: "@darshanmandge" Date: Fri, 20 Feb 2026 16:48:12 +0100 Subject: [PATCH 5/8] fix test --- tests/test_simulation/test_modifications.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_simulation/test_modifications.py b/tests/test_simulation/test_modifications.py index 85f213b0..6d1a6d40 100644 --- a/tests/test_simulation/test_modifications.py +++ b/tests/test_simulation/test_modifications.py @@ -701,7 +701,7 @@ def test_dispatches_compartment_set(self): assert seg.gbar == 0.5 def test_unknown_type_raises(self): - mod = ModificationBase(name="bad", type="unknown") + mod = ModificationBase(name="bad") with pytest.raises(ValueError, match="Unknown modification type"): apply_modifications({}, [mod], mock.MagicMock()) From fb23e5460d6cd934f25fcff1706cd111ed6a42e6 Mon Sep 17 00:00:00 2001 From: "@darshanmandge" Date: Fri, 27 Feb 2026 17:38:16 +0100 Subject: [PATCH 6/8] improve variable naming, validation, and code clarity --- bluecellulab/simulation/modifications.py | 49 +++++++++++++++--------- 1 file changed, 30 insertions(+), 19 deletions(-) diff --git a/bluecellulab/simulation/modifications.py b/bluecellulab/simulation/modifications.py index 841cc56d..c7fd444d 100644 --- a/bluecellulab/simulation/modifications.py +++ b/bluecellulab/simulation/modifications.py @@ -192,14 +192,14 @@ def _apply_configure_all_sections( n_sections = 0 for cell_id in target_cell_ids: cell = cells[cell_id] - cell_applied = 0 + sections_applied = 0 for sec_name, section in cell.sections.items(): if _exec_on_section(config, section, attrs): - cell_applied += 1 + sections_applied += 1 logger.debug(" Applied to section '%s' of cell %s", sec_name, cell_id) - if cell_applied > 0: + if sections_applied > 0: n_cells += 1 - n_sections += cell_applied + n_sections += sections_applied logger.info( "Modification '%s' applied to %d sections across %d cells", @@ -235,6 +235,15 @@ def _apply_section_list( ) list_name = match.group(1) + # Validate that ALL attribute references use the same section list prefix + all_prefixes = re.findall(r"(\w+)\.", mod.section_configure) + if not all(prefix == list_name for prefix in all_prefixes): + mixed_prefixes = set(all_prefixes) + raise ValueError( + f"section_list modification '{mod.name}': mixed section list prefixes detected " + f"{mixed_prefixes}. All statements must reference the same section list '{list_name}'." + ) + prop_name = SECTION_LIST_MAP.get(list_name) if prop_name is None: raise ValueError( @@ -277,15 +286,15 @@ def _apply_section_list( ) continue - cell_applied = 0 + sections_applied = 0 for section in section_list: sec_name = section.name().split(".")[-1] if _exec_on_section(config_str, section, attrs): - cell_applied += 1 + sections_applied += 1 logger.debug(" Applied to section '%s' of cell %s", sec_name, cell_id) - if cell_applied > 0: + if sections_applied > 0: n_cells += 1 - n_sections += cell_applied + n_sections += sections_applied logger.info( "Modification '%s' applied to %d sections across %d cells", @@ -323,13 +332,15 @@ def _apply_section(cells: dict, mod: ModificationSection, circuit_access) -> Non # Build per-section config strings # For each unique section name, replace "[idx]." with "sec." - # and parse to get attrs + # and parse to get attrs. This handles multi-section configs like + # "apic[10].x = 0; dend[3].y = 1" by creating separate config strings + # for each section (apic[10] gets "sec.x = 0; sec.y = 1" if dend statements + # are also present, though only the apic statement will match). The config_str + # is stored in the dict and later retrieved when applying to each cell. section_configs: dict[str, tuple[str, set[str]]] = {} for sec_name in section_names: escaped = re.escape(sec_name) config_str = re.sub(escaped + r"\.", "sec.", mod.section_configure) - # Filter to only statements that reference this section - # (handle multi-section configs like "apic[10].x = 0; dend[3].y = 1") collector = _AttributeCollector() tree = ast.parse(config_str) for elem in tree.body: @@ -342,7 +353,7 @@ def _apply_section(cells: dict, mod: ModificationSection, circuit_access) -> Non n_sections = 0 for cell_id in target_cell_ids: cell = cells[cell_id] - cell_applied = 0 + sections_applied = 0 for sec_name, (config_str, attrs) in section_configs.items(): try: section = cell.get_section(sec_name) @@ -355,11 +366,11 @@ def _apply_section(cells: dict, mod: ModificationSection, circuit_access) -> Non ) continue if _exec_on_section(config_str, section, attrs): - cell_applied += 1 + sections_applied += 1 logger.debug(" Applied to section '%s' of cell %s", sec_name, cell_id) - if cell_applied > 0: + if sections_applied > 0: n_cells += 1 - n_sections += cell_applied + n_sections += sections_applied logger.info( "Modification '%s' applied to %d sections across %d cells", @@ -452,18 +463,18 @@ def _apply_compartment_set( ) continue - cell_applied = 0 + segments_applied = 0 for section, sec_name, seg_x in resolved: segment = section(seg_x) if all(hasattr(segment, attr) for attr in all_attrs): exec(config_str, {"__builtins__": None}, {"seg": segment}) # noqa: S102 - cell_applied += 1 + segments_applied += 1 logger.debug( " Applied to segment '%s(%s)' of cell %s", sec_name, seg_x, cell_id ) - if cell_applied > 0: + if segments_applied > 0: n_cells += 1 - n_segments += cell_applied + n_segments += segments_applied logger.info( "Modification '%s' applied to %d segments across %d cells", From b5f62b060d7dabdb781f7ef1f6cba9117c04ec30 Mon Sep 17 00:00:00 2001 From: "@darshanmandge" Date: Fri, 27 Feb 2026 18:07:15 +0100 Subject: [PATCH 7/8] Fix f-string formatting in sonata-modifications notebook --- examples/2-sonata-network/sonata-modifications.ipynb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/examples/2-sonata-network/sonata-modifications.ipynb b/examples/2-sonata-network/sonata-modifications.ipynb index 47b9e56e..b8f3a34f 100644 --- a/examples/2-sonata-network/sonata-modifications.ipynb +++ b/examples/2-sonata-network/sonata-modifications.ipynb @@ -298,7 +298,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -348,19 +348,19 @@ " # Check soma cm\n", " soma = cell.sections.get(\"soma[0]\")\n", " if soma:\n", - " print(\"soma[0] cm = {soma.cm}\")\n", + " print(f\"soma[0] cm = {soma.cm}\")\n", "\n", " # Check apic[0] cm (section modification)\n", " apic0 = cell.sections.get(\"apic[0]\")\n", " if apic0:\n", - " print(\"apic[0] cm = {apic0.cm}\")\n", + " print(f\"apic[0] cm = {apic0.cm}\")\n", " elif pop == \"NodeA\":\n", " print(\"apic[0]: not present (section mod was skipped)\")\n", "\n", " # Check a dendritic section cm\n", " dend0 = cell.sections.get(\"dend[0]\")\n", " if dend0:\n", - " print(\"dend[0] cm = {dend0.cm}\")" + " print(f\"dend[0] cm = {dend0.cm}\")" ] }, { From 128f3e58e4e425a77ccdf5c6ec4efeb86975dddc Mon Sep 17 00:00:00 2001 From: "@darshanmandge" Date: Fri, 27 Feb 2026 18:28:11 +0100 Subject: [PATCH 8/8] Fix section_list prefix validation regex and add --- bluecellulab/simulation/modifications.py | 14 +++--- tests/test_simulation/test_modifications.py | 47 +++++++++++++++++++++ 2 files changed, 52 insertions(+), 9 deletions(-) diff --git a/bluecellulab/simulation/modifications.py b/bluecellulab/simulation/modifications.py index 9b5f7282..51d02b2b 100644 --- a/bluecellulab/simulation/modifications.py +++ b/bluecellulab/simulation/modifications.py @@ -236,7 +236,9 @@ def _apply_section_list( list_name = match.group(1) # Validate that ALL attribute references use the same section list prefix - all_prefixes = re.findall(r"(\w+)\.", mod.section_configure) + # Use a pattern that matches "identifier.identifier" to avoid matching + # numbers before decimal points (e.g. "1.5" should not match "1" as prefix) + all_prefixes = re.findall(r"([a-zA-Z_]\w*)\.(?=[a-zA-Z_])", mod.section_configure) if not all(prefix == list_name for prefix in all_prefixes): mixed_prefixes = set(all_prefixes) raise ValueError( @@ -413,16 +415,10 @@ def _apply_compartment_set( comp_nodes = comp_entry.get("compartment_set", []) population_name = comp_entry.get("population") - # Parse section_configure — bare format: "attr = value" - # Prefix with "seg." to make it executable - config_str = re.sub(r"(\b\w+)\s*=", r"seg.\1 =", mod.section_configure) - # But we need to be careful: only LHS identifiers should be prefixed. - # Better approach: use ast to parse and validate - # For compartment_set, the format is "attr = value [; attr = value ...]" - # We prefix each bare assignment target with "seg." + # Parse section_configure — bare format: "attr = value [; attr = value ...]" + # Prefix each bare assignment target with "seg." to make it executable statements = [s.strip() for s in mod.section_configure.split(";") if s.strip()] prefixed_parts = [] - all_attrs: set[str] = set() for stmt in statements: prefixed = "seg." + stmt.strip() prefixed_parts.append(prefixed) diff --git a/tests/test_simulation/test_modifications.py b/tests/test_simulation/test_modifications.py index 6d1a6d40..c4fe8de2 100644 --- a/tests/test_simulation/test_modifications.py +++ b/tests/test_simulation/test_modifications.py @@ -404,6 +404,53 @@ def test_invalid_section_configure_raises(self): _apply_section_list({}, mod, _make_circuit_access([])) +class TestApplySectionListMixedPrefixes: + def test_float_values_not_treated_as_prefixes(self, caplog): + """Regression: 'somatic.cm *= 1.5' should NOT raise mixed prefix error.""" + import logging + + cell_id = mock.MagicMock() + sec = mock.MagicMock() + sec.name.return_value = "Cell.soma[0]" + cell = mock.MagicMock() + cell.somatic = [sec] + cells = {cell_id: cell} + mod = ModificationSectionList( + name="scale", + type="section_list", + node_set="target", + section_configure="somatic.cm *= 1.5", + ) + ca = _make_circuit_access(target_cell_ids=[cell_id]) + with caplog.at_level(logging.INFO): + _apply_section_list(cells, mod, ca) + assert "applied to" in caplog.text + + def test_mixed_prefixes_raises(self): + """'apical.gbar = 0; basal.cm = 1' should raise mixed prefix error.""" + mod = ModificationSectionList( + name="mixed", + type="section_list", + node_set="target", + section_configure="apical.gbar = 0; basal.cm = 1", + ) + with pytest.raises(ValueError, match="mixed section list prefixes"): + _apply_section_list({}, mod, _make_circuit_access([])) + + +class TestApplySectionMixedSections: + def test_mixed_sections_raises(self): + """'apic[10].x = 0; dend[3].y = 1' should raise multiple sections error.""" + mod = ModificationSection( + name="mixed", + type="section", + node_set="target", + section_configure="apic[10].x = 0; dend[3].y = 1", + ) + with pytest.raises(ValueError, match="multiple sections detected"): + _apply_section({}, mod, _make_circuit_access([])) + + class TestApplySectionEdgeCases: def test_invalid_section_configure_raises(self): mod = ModificationSection(