diff --git a/.gitignore b/.gitignore index e80b094..eacdac1 100644 --- a/.gitignore +++ b/.gitignore @@ -5,6 +5,7 @@ tmp/* **/tmp/* # figures from notebooks not saved by default notebooks/img/* +notebooks/results/* # Byte-compiled / optimized / DLL files __pycache__/ diff --git a/cleo/__init__.py b/cleo/__init__.py index 25c52d2..e270701 100644 --- a/cleo/__init__.py +++ b/cleo/__init__.py @@ -1,23 +1,23 @@ """Contains core classes and functions for the Cleo package.""" from __future__ import annotations +import cleo.coords + # auto-import submodules import cleo.ephys +import cleo.imaging +import cleo.ioproc import cleo.opto -import cleo.coords -import cleo.stimulators import cleo.recorders -import cleo.ioproc +import cleo.registry +import cleo.stimulators import cleo.utilities import cleo.viz -import cleo.imaging -import cleo.registry - from cleo.base import ( CLSimulator, - Recorder, - Stimulator, InterfaceDevice, IOProcessor, + Recorder, + Stimulator, SynapseDevice, ) diff --git a/cleo/base.py b/cleo/base.py index 35880fc..4a67d64 100644 --- a/cleo/base.py +++ b/cleo/base.py @@ -1,32 +1,32 @@ """Contains definitions for essential, base classes.""" from __future__ import annotations -from abc import ABC, abstractmethod -from typing import Any, Tuple, Iterable + import datetime +from abc import ABC, abstractmethod +from typing import Any, Tuple -from attrs import define, field, asdict, fields_dict +import neo +from attrs import asdict, define, field, fields_dict from brian2 import ( - np, - NeuronGroup, + BrianObjectException, Equations, - Synapses, - Subgroup, Network, NetworkOperation, + NeuronGroup, + Quantity, + Subgroup, + Synapses, + Unit, defaultclock, ms, - Unit, - Quantity, - BrianObjectException, + np, ) -from matplotlib import pyplot as plt -from mpl_toolkits.mplot3d import Axes3D from matplotlib.artist import Artist -import neo -from cleo.registry import registry_for_sim +from mpl_toolkits.mplot3d import Axes3D -import cleo.utilities +from cleo.registry import registry_for_sim +from cleo.utilities import add_to_neo_segment, analog_signal, brian_safe_name class NeoExportable(ABC): @@ -54,7 +54,7 @@ class InterfaceDevice(ABC): other functions so that those objects can be automatically added to the network when the device is injected. """ - sim: CLSimulator = field(init=False, default=None) + sim: CLSimulator = field(init=False, default=None, repr=False) """The simulator the device is injected into """ name: str = field(kw_only=True) """Identifier for device, used in sampling, plotting, etc. @@ -149,6 +149,7 @@ def update_artists(self, artists: list[Artist], *args, **kwargs) -> list[Artist] return [] +@define class IOProcessor(ABC): """Abstract class for implementing sampling, signal processing and control @@ -157,9 +158,12 @@ class IOProcessor(ABC): class more useful, since delay handling is already defined. """ - sample_period_ms: float + sample_period_ms: float = 1 """Determines how frequently the processor takes samples""" + latest_ctrl_signal: dict = field(factory=dict, init=False, repr=False) + """The most recent control signal returned by :meth:`get_ctrl_signals`""" + @abstractmethod def is_sampling_now(self, time) -> bool: """Determines whether the processor will take a sample at this timestep. @@ -191,7 +195,7 @@ def put_state(self, state_dict: dict, sample_time_ms: float) -> None: pass @abstractmethod - def get_ctrl_signal(self, query_time_ms: float) -> dict: + def get_ctrl_signals(self, query_time_ms: float) -> dict: """Get per-stimulator control signal from the :class:`~cleo.IOProcessor`. Parameters @@ -202,10 +206,51 @@ def get_ctrl_signal(self, query_time_ms: float) -> dict: Returns ------- dict - A {'stimulator_name': value} dictionary for updating stimulators. + A {'stimulator_name': ctrl_signal} dictionary for updating stimulators. """ pass + def get_stim_values(self, query_time_ms: float) -> dict: + ctrl_signals = self.get_ctrl_signals(query_time_ms) + self.latest_ctrl_signal.update(ctrl_signals) + stim_value_conversions = self.preprocess_ctrl_signals( + self.latest_ctrl_signal, query_time_ms + ) + return ctrl_signals | stim_value_conversions + + def preprocess_ctrl_signals( + self, latest_ctrl_signals: dict, query_time_ms: float + ) -> dict: + """Preprocess control signals as needed to control stimulator waveforms between samples. + + I.e., if a control signal defines the frequency of a periodic light stimulus, this + function computes the current intensity given the latest frequency and the current + time. This is called immediately after :meth:`get_ctrl_signals` and on every timestep + to update the stimulator waveform between samples. + + This only needs to be implemented when a stimulus that varies between samples is desired. + Otherwise, the control signal returned by :meth:`get_ctrl_signals` is used directly. + If not all stimulators need this functionality, only return a dict for those that do. + The original, unprocessed control signal is used for the others. + + Parameters + ---------- + query_time_ms : float + Current simulation time. + + Returns + ------- + dict + A {'stimulator_name': value} dictionary for updating stimulators. + """ + return {} + + def get_intersample_ctrl_signal(self, query_time_ms: float) -> dict: + """Get per-stimulator control signal between samples. I.e., for implementing + a time-varying waveform based on parameters from the last sample. + Such parameters will need to be stored in the :class:`~cleo.IOProcessor`.""" + return {} + def reset(self, **kwargs) -> None: pass @@ -271,7 +316,7 @@ def reset(self, **kwargs) -> None: self._init_saved_vars() def to_neo(self): - signal = cleo.utilities.analog_signal(self.t_ms, self.values, "dimensionless") + signal = analog_signal(self.t_ms, self.values, "dimensionless") signal.name = self.name signal.description = "Exported from Cleo stimulator device" signal.annotate(export_datetime=datetime.datetime.now()) @@ -375,21 +420,21 @@ def get_state(self) -> dict: state[name] = recorder.get_state() return state - def update_stimulators(self, ctrl_signals) -> None: + def update_stimulators(self, stim_values: dict[str, Any]) -> None: """Update stimulators with output from the :class:`IOProcessor` Parameters ---------- - ctrl_signals : dict - {`stimulator_name`: `ctrl_signal`} dictionary with values + stim_values : dict + {`stimulator_name`: `stim_value`} dictionary with values to update each stimulator. """ - if ctrl_signals is None: - return - for name, signal in ctrl_signals.items(): - self.stimulators[name].update(signal) + for name, value in stim_values.items(): + self.stimulators[name].update(value) - def set_io_processor(self, io_processor, communication_period=None) -> CLSimulator: + def set_io_processor( + self, io_processor: IOProcessor, communication_period=None + ) -> CLSimulator: """Set simulator IO processor Will replace any previous IOProcessor so there is only one at a time. @@ -417,8 +462,8 @@ def set_io_processor(self, io_processor, communication_period=None) -> CLSimulat def communicate_with_io_proc(t): if io_processor.is_sampling_now(t / ms): io_processor.put_state(self.get_state(), t / ms) - ctrl_signal = io_processor.get_ctrl_signal(t / ms) - self.update_stimulators(ctrl_signal) + stim_values = io_processor.get_stim_values(t / ms) + self.update_stimulators(stim_values) # communication should be at every timestep. The IOProcessor # decides when to sample and deliver results. @@ -482,7 +527,7 @@ def to_neo(self) -> neo.core.Block: block.groups.append(dev_neo) elif isinstance(dev_neo, neo.core.dataobject.DataObject): data_objects = [dev_neo] - cleo.utilities.add_to_neo_segment(seg, *data_objects) + add_to_neo_segment(seg, *data_objects) return block @@ -611,7 +656,7 @@ def connect_to_neuron_group(self, neuron_group: NeuronGroup, **kwparams) -> None model=mod_syn_model, on_pre=self.on_pre, namespace=mod_syn_params, - name=f"syn_{self.name}_{neuron_group.name}", + name=f"syn_{brian_safe_name(self.name)}_{neuron_group.name}", ) syn.namespace.update(self.extra_namespace) syn.connect(i=i_sources, j=i_targets) diff --git a/cleo/coords.py b/cleo/coords.py index b4150cc..2940606 100644 --- a/cleo/coords.py +++ b/cleo/coords.py @@ -1,16 +1,15 @@ """Contains functions for assigning neuron coordinates and visualizing""" from __future__ import annotations + from typing import Tuple -from brian2 import Quantity, mm, meter, Unit, np +from brian2 import Quantity, Unit, meter, mm, np from brian2.groups.group import Group from brian2.groups.neurongroup import NeuronGroup from brian2.units.fundamentalunits import get_dimensions -import numpy as np from cleo.utilities import ( - get_orth_vectors_for_V, modify_model_with_eqs, uniform_cylinder_rθz, xyz_from_rθz, @@ -47,7 +46,7 @@ def assign_coords_grid_rect_prism( ValueError When the shape is incompatible with the number of neurons in the group """ - num_grid_elements = np.product(shape) + num_grid_elements = np.prod(shape) if num_grid_elements != len(neuron_group): raise ValueError( f"Number of elements specified in shape ({num_grid_elements}) " diff --git a/cleo/ephys/lfp.py b/cleo/ephys/lfp.py index 8e0eb48..cd81d0e 100644 --- a/cleo/ephys/lfp.py +++ b/cleo/ephys/lfp.py @@ -1,19 +1,20 @@ """Contains LFP signals""" from __future__ import annotations -from typing import Any + from datetime import datetime +from typing import Any +import numpy as np +import quantities as pq from attrs import define, field from brian2 import NeuronGroup, mm, ms from brian2.monitors.spikemonitor import SpikeMonitor -import numpy as np from nptyping import NDArray from tklfp import TKLFP -import quantities as pq -from cleo.base import NeoExportable -from cleo.ephys.probes import Signal, Probe import cleo.utilities +from cleo.base import NeoExportable +from cleo.ephys.probes import Signal @define(eq=False) diff --git a/cleo/ephys/probes.py b/cleo/ephys/probes.py index 3170b52..43635e6 100644 --- a/cleo/ephys/probes.py +++ b/cleo/ephys/probes.py @@ -1,17 +1,16 @@ """Contains Probe and Signal classes and electrode coordinate functions""" from __future__ import annotations + from abc import ABC, abstractmethod -from collections.abc import Iterable -from operator import concat from typing import Any, Tuple -from attrs import field, define -from mpl_toolkits.mplot3d.axes3d import Axes3D -from matplotlib.artist import Artist -from brian2 import NeuronGroup, mm, Unit, Quantity, umeter, np import neo +from attrs import define, field +from brian2 import NeuronGroup, Quantity, Unit, mm, np, umeter +from matplotlib.artist import Artist +from mpl_toolkits.mplot3d.axes3d import Axes3D -from cleo.base import Recorder, NeoExportable +from cleo.base import NeoExportable, Recorder from cleo.coords import concat_coords from cleo.utilities import get_orth_vectors_for_V diff --git a/cleo/imaging/scope.py b/cleo/imaging/scope.py index af0e27e..ca4f8ff 100644 --- a/cleo/imaging/scope.py +++ b/cleo/imaging/scope.py @@ -375,7 +375,7 @@ def add_self_to_plot( y / axis_scale_unit, z / axis_scale_unit, color=color, - alpha=0.3, + alpha=0.2, ) target_markers = ax.scatter( @@ -384,15 +384,17 @@ def add_self_to_plot( coords[:, 2] / axis_scale_unit, marker="^", c=color, - label=self.sensor.name, + label=f"{self.sensor.name} ROIs", **kwargs, ) color_rgba = target_markers.get_facecolor() color_rgba[:, :3] = 0.3 * color_rgba[:, :3] target_markers.set(color=color_rgba) - handles = ax.get_legend().legendHandles + handles = ax.get_legend().legendHandles + handles.append(target_markers) patch = mpl.patches.Patch(color=color, label=self.name) handles.append(patch) ax.legend(handles=handles) + return [scope_marker, target_markers, plane] diff --git a/cleo/ioproc/base.py b/cleo/ioproc/base.py index a66c991..55b1d0e 100644 --- a/cleo/ioproc/base.py +++ b/cleo/ioproc/base.py @@ -1,10 +1,12 @@ """Basic processor and processing block definitions""" from __future__ import annotations + from abc import ABC, abstractmethod -from typing import Tuple, Any from collections import deque +from typing import Any, Tuple import numpy as np +from attrs import define, field from cleo.base import IOProcessor from cleo.ioproc.delays import Delay @@ -44,7 +46,7 @@ def __init__(self, **kwargs): When `delay` is not a `Delay` object. """ self.delay = kwargs.get("delay", None) - if not isinstance(self.delay, Delay): + if self.delay and not isinstance(self.delay, Delay): raise TypeError("delay must be of the Delay class") self.save_history = kwargs.get("save_history", False) if self.save_history is True: @@ -109,70 +111,62 @@ def compute_output(self, input: Any, **kwargs) -> Any: pass +@define class LatencyIOProcessor(IOProcessor): - """IOProcessor capable of delivering stimulation some time after measurement.""" - - t_samp_ms: list[float] - """Record of sampling times---each time :meth:`~put_state` is called.""" + """IOProcessor capable of delivering stimulation some time after measurement. - def __init__(self, sample_period_ms: float, **kwargs): - """ - Parameters - ---------- - sample_period_ms : float - Determines how frequently samples are taken from the network. + Note + ---- + It doesn't make much sense to combine parallel computation + with "when idle" sampling, because "when idle" sampling only produces + one sample at a time to process. + """ - Keyword args - ------------ - sampling : str - "fixed" or "when idle"; "fixed" by default - - "fixed" sampling means samples are taken on a fixed schedule, - with no exceptions. - - "when idle" sampling means no samples are taken before the previous - sample's output has been delivered. A sample is taken ASAP - after an over-period computation: otherwise remains on schedule. - - processing : str - "parallel" or "serial"; "parallel" by default - - "parallel" computes the output time by adding the delay for a sample - onto the sample time, so if the delay is 2 ms, for example, while the - sample period is only 1 ms, some of the processing is happening in - parallel. Output order matches input order even if the computed - output time for a sample is sooner than that for a previous - sample. - - "serial" computes the output time by adding the delay for a sample - onto the output time of the previous sample, rather than the sampling - time. Note this may be of limited - utility because it essentially means the *entire* round trip - cannot be in parallel at all. More realistic is that simply - each block or phase of computation must be serial. If anyone - cares enough about this, it will have to be implemented in the - future. - - Note - ---- - It doesn't make much sense to combine parallel computation - with "when idle" sampling, because "when idle" sampling only produces - one sample at a time to process. + t_samp_ms: list[float] = field(factory=list, init=False, repr=False) + """Record of sampling times---each time :meth:`~put_state` is called.""" - Raises - ------ - ValueError - For invalid `sampling` or `processing` kwargs - """ - self.t_samp_ms = [] - self.out_buffer = deque([]) - self.sample_period_ms = sample_period_ms - self.sampling = kwargs.get("sampling", "fixed") - if self.sampling not in ["fixed", "when idle"]: - raise ValueError("Invalid sampling scheme:", self.sampling) - self.processing = kwargs.get("processing", "parallel") - if self.processing not in ["serial", "parallel"]: - raise ValueError("Invalid processing scheme:", self.processing) + sampling: str = field(default="fixed") + """Sampling scheme: "fixed" or "when idle". + + "fixed" sampling means samples are taken on a fixed schedule, + with no exceptions. + + "when idle" sampling means no samples are taken before the previous + sample's output has been delivered. A sample is taken ASAP + after an over-period computation: otherwise remains on schedule. + """ + + @sampling.validator + def _validate_sampling(self, attribute, value): + if value not in ["fixed", "when idle"]: + raise ValueError("Invalid sampling scheme:", value) + + processing: str = field(default="parallel") + """Processing scheme: "serial" or "parallel". + + "parallel" computes the output time by adding the delay for a sample + onto the sample time, so if the delay is 2 ms, for example, while the + sample period is only 1 ms, some of the processing is happening in + parallel. Output order matches input order even if the computed + output time for a sample is sooner than that for a previous + sample. + + "serial" computes the output time by adding the delay for a sample + onto the output time of the previous sample, rather than the sampling + time. Note this may be of limited + utility because it essentially means the *entire* round trip + cannot be in parallel at all. More realistic is that simply + each block or phase of computation must be serial. If anyone + cares enough about this, it will have to be implemented in the + future. + """ + + @processing.validator + def _validate_processing(self, attribute, value): + if value not in ["serial", "parallel"]: + raise ValueError("Invalid processing scheme:", value) + + out_buffer: deque[Tuple[dict, float]] = field(factory=deque, init=False, repr=False) def put_state(self, state_dict: dict, sample_time_ms: float): self.t_samp_ms.append(sample_time_ms) @@ -184,15 +178,15 @@ def put_state(self, state_dict: dict, sample_time_ms: float): self.out_buffer.append((out, t_out_ms)) self._needs_off_schedule_sample = False - def get_ctrl_signal(self, query_time_ms): + def get_ctrl_signals(self, query_time_ms): if len(self.out_buffer) == 0: - return None + return {} next_out_signal, next_t_out_ms = self.out_buffer[0] if query_time_ms >= next_t_out_ms: self.out_buffer.popleft() return next_out_signal else: - return None + return {} def _is_currently_idle(self, query_time_ms): return len(self.out_buffer) == 0 or self.out_buffer[0][1] <= query_time_ms diff --git a/cleo/light/__init__.py b/cleo/light/__init__.py index 0262ee2..6ede35b 100644 --- a/cleo/light/__init__.py +++ b/cleo/light/__init__.py @@ -1,14 +1,15 @@ from cleo.light.light import ( + Koehler, Light, - fiber473nm, - OpticFiber, LightModel, + OpticFiber, + fiber473nm, ) from cleo.light.light_dependence import ( LightDependent, + cubic_interpolator, equal_photon_flux_spectrum, linear_interpolator, - cubic_interpolator, plot_spectra, ) from cleo.light.two_photon import ( diff --git a/cleo/light/light.py b/cleo/light/light.py index 31921b5..0f8cad7 100644 --- a/cleo/light/light.py +++ b/cleo/light/light.py @@ -4,13 +4,11 @@ import datetime import warnings from abc import ABC, abstractmethod -from typing import Any, Tuple, Union +from typing import Any, Union import matplotlib as mpl -import matplotlib.pyplot as plt -import neo import quantities as pq -from attrs import asdict, define, field +from attrs import define, field from brian2 import ( NeuronGroup, Subgroup, @@ -30,7 +28,7 @@ from nptyping import NDArray from cleo.base import CLSimulator -from cleo.coords import coords_from_ng, coords_from_xyz +from cleo.coords import coords_from_xyz from cleo.registry import registry_for_sim from cleo.stimulators import Stimulator from cleo.utilities import ( @@ -188,7 +186,7 @@ def viz_params( density_factor = 3 cyl_vol = np.pi * r_thresh**2 * zc_thresh markersize_um = (cyl_vol / n_points_per_source * density_factor) ** (1 / 3) / um - intensity_scale = (1e3 / n_points_per_source) ** (1 / 3) + intensity_scale = 1.5 * (4e3 / n_points_per_source) ** (1 / 3) return coords_from_xyz(x, y, z), markersize_um, intensity_scale def _find_rz_thresholds(self, thresh): @@ -230,6 +228,38 @@ def fiber473nm( ) +@define +class Koehler(LightModel): + """Even illumination over a circular area, with no scattering.""" + + radius: Quantity + """The radius of the Köhler beam""" + zmax: Quantity = 500 * um + """The maximum extent of the Köhler beam, 500 μm by default + (i.e., no thicker than necessary to go through a slice or culture).""" + + def transmittance(self, source_coords, source_dir_uvec, target_coords): + r, z = self._get_rz_for_xyz(source_coords, source_dir_uvec, target_coords) + T = np.ones_like(r) + T[r > self.radius] = 0 + T[z > self.zmax] = 0 + T[z < 0] = 0 + return T + + def viz_params( + self, coords, direction, T_threshold, n_points_per_source=4000, **kwargs + ): + r, theta, zc = uniform_cylinder_rθz(n_points_per_source, self.radius, self.zmax) + + end = coords + self.zmax * direction + x, y, z = xyz_from_rθz(r, theta, zc, coords, end) + density_factor = 2 + cyl_vol = np.pi * self.radius**2 * self.zmax + markersize_um = (cyl_vol / n_points_per_source * density_factor) ** (1 / 3) / um + intensity_scale = (1 / n_points_per_source) ** (1 / 3) + return coords_from_xyz(x, y, z), markersize_um, intensity_scale + + @define(eq=False) class Light(Stimulator): """Delivers light to the network for photostimulation and (when implemented) imaging. @@ -298,6 +328,11 @@ def _check_coords(self, attribute, value): def _default_default(self): return np.zeros(self.n) + @property + def color(self): + """Color of light""" + return wavelength_to_rgb(self.wavelength / nmeter) + def transmittance(self, target_coords) -> np.ndarray: """Returns :attr:`light_model` transmittance given light's coords and direction.""" return self.light_model.transmittance( @@ -342,7 +377,10 @@ def add_self_to_plot(self, ax, axis_scale_unit, **kwargs) -> list[PathCollection T_threshold = kwargs.pop("T_threshold", 1e-3) viz_points, markersize_um, intensity_scale = self.light_model.viz_params( - self.coords, self.direction, T_threshold, **kwargs + self.coords, + self.direction, + T_threshold, + **kwargs, ) assert viz_points.shape[0] == self.n assert viz_points.shape[2] == 3 @@ -381,6 +419,8 @@ def add_self_to_plot(self, ax, axis_scale_unit, **kwargs) -> list[PathCollection viz_points[i, idx_to_plot, 2] / axis_scale_unit, c=T[i, idx_to_plot], cmap=self._alpha_cmap_for_wavelength(intensity), + vmin=0, + vmax=1, marker="o", edgecolors="none", label=self.name, diff --git a/cleo/light/light_dependence.py b/cleo/light/light_dependence.py index ca08aab..d74729d 100644 --- a/cleo/light/light_dependence.py +++ b/cleo/light/light_dependence.py @@ -1,15 +1,14 @@ from __future__ import annotations -from typing import Callable, Tuple + import warnings +from typing import Callable, Tuple from attrs import define, field -from brian2 import np, NeuronGroup, mm -from nptyping import NDArray +from brian2 import NeuronGroup, mm, np from scipy.interpolate import CubicSpline -from cleo.base import InterfaceDevice, SynapseDevice from cleo.coords import assign_xyz -from cleo.utilities import wavelength_to_rgb +from cleo.utilities import brian_safe_name, wavelength_to_rgb def linear_interpolator(lambdas_nm, epsilons, lambda_new_nm): @@ -37,10 +36,18 @@ class LightDependent: peak-non-peak wavelength relation; see ``notebooks/multi_wavelength_model.ipynb`` for details.""" - spectrum: list[tuple[float, float]] = field(factory=lambda: [(-1e10, 1), (1e10, 1)]) + spectrum: list[tuple[float, float]] = field() """List of (wavelength, epsilon) tuples representing the action (opsin) or excitation (indicator) spectrum.""" + @spectrum.default + def _default_spectrum(self): + warnings.warn( + f"No spectrum provided for light-dependent device {self.name}." + " Assuming ε = 1 for all λ." + ) + return [(-1e10, 1), (1e10, 1)] + spectrum_interpolator: Callable = field(default=cubic_interpolator, repr=False) """Function of signature (lambdas_nm, epsilons, lambda_new_nm) that interpolates the action spectrum data and returns :math:`\\varepsilon \\in [0,1]` for the new @@ -60,7 +67,7 @@ def _get_source_for_synapse( phi : 1/second/meter**2 Irr : watt/meter**2 """, - name=f"light_agg_{self.name}_{target_ng.name}", + name=f"light_agg_{brian_safe_name(self.name)}_{target_ng.name}", ) assign_xyz( light_agg_ng, @@ -91,7 +98,7 @@ def epsilon(self, lambda_new) -> float: def equal_photon_flux_spectrum( - spectrum: list[tuple[float, float]] + spectrum: list[tuple[float, float]], ) -> list[tuple[float, float]]: """Converts an equival photon flux spectrum to an equal power density spectrum.""" spectrum = np.array(spectrum) diff --git a/cleo/light/two_photon.py b/cleo/light/two_photon.py index 76c6203..b1e3ff1 100644 --- a/cleo/light/two_photon.py +++ b/cleo/light/two_photon.py @@ -1,8 +1,7 @@ from typing import Any -import numpy as np from attrs import define -from brian2 import Quantity +from brian2 import Quantity, np from brian2.units import nmeter, um from nptyping import NDArray diff --git a/cleo/opto/__init__.py b/cleo/opto/__init__.py index 4110f21..7bb169f 100644 --- a/cleo/opto/__init__.py +++ b/cleo/opto/__init__.py @@ -1,15 +1,17 @@ """Contains opsin models, light sources, and some parameters""" -from cleo.opto.opsins import ( - FourStateOpsin, - ProportionalCurrentOpsin, - Opsin, - BansalFourStateOpsin, - # BansalThreeStatePump, -) from cleo.opto.opsin_library import ( chr2_4s, chr2_b4s, - vfchrimson_4s, + chr2_h134r_4s, chrimson_4s, + enphr3_3s, gtacr2_4s, + vfchrimson_4s, +) +from cleo.opto.opsins import ( + BansalFourStateOpsin, + BansalThreeStatePump, + FourStateOpsin, + Opsin, + ProportionalCurrentOpsin, ) diff --git a/cleo/opto/opsin_library.py b/cleo/opto/opsin_library.py index 5842929..99065be 100644 --- a/cleo/opto/opsin_library.py +++ b/cleo/opto/opsin_library.py @@ -1,29 +1,21 @@ """A bunch of fitted opsin models.""" -from typing import Callable -from attrs import field, define from brian2.units import ( - nsiemens, - mm, + mM, mm2, - nmeter, - meter, - kgram, - Quantity, - second, ms, - second, - psiemens, mV, - volt, - amp, - mwatt, + nsiemens, + pcoulomb, + psiemens, + second, ) -from cleo.light.light_dependence import plot_spectra, equal_photon_flux_spectrum +from cleo.light.light_dependence import equal_photon_flux_spectrum, plot_spectra from cleo.opto.opsins import ( - FourStateOpsin, BansalFourStateOpsin, + BansalThreeStatePump, + FourStateOpsin, ) @@ -71,7 +63,7 @@ def chr2_4s() -> FourStateOpsin: def chr2_b4s() -> BansalFourStateOpsin: - """Returns a 4-state Vf-Chrimson model. + """Returns a 4-state ChR2 model. Params given in Bansal et al., 2020. Action spectrum from `Nagel et al., 2003, Fig. 4a @@ -111,8 +103,48 @@ def chr2_b4s() -> BansalFourStateOpsin: ) +def chr2_h134r_4s() -> BansalFourStateOpsin: + """Returns a 4-state ChR2(H134R) model. + + Params given in Bansal et al., 2020. + Action spectrum is same as for :func:`~chr2_4s`, but blue-shifted 20 nm + (I cannot find it directly in the literature). + + Parameters can be changed after initialization but *before injection*. + """ + + return BansalFourStateOpsin( + Gd1=0.045 / ms, + Gd2=0.01 / ms, + Gr0=1e-4 / ms, + g0=37.2 * nsiemens, + phim=1e16 / mm2 / second, # *photon, not in Brian2 + k1=0.3 / ms, + k2=0.12 / ms, + Gf0=0.014 / ms, + Gb0=0.01 / ms, + kf=0.01 / ms, + kb=0.01 / ms, + gamma=0.05, + p=1, + q=1, + E=0 * mV, + name="ChR2(H134R)", + spectrum=[ + (380, 0.34), + (402, 0.65), + (440, 0.96), + (450, 1), + (480, 0.57), + (500, 0.22), + (520, 0.06), + (540, 0.01), + ], + ) + + def vfchrimson_4s() -> BansalFourStateOpsin: - """Returns a 4-state Vf-Chrimson model. + """Returns a 4-state vf-Chrimson model. Params given in Bansal et al., 2020. Action spectrum from `Mager et al., 2018, Supp. Fig. 1a @@ -137,7 +169,7 @@ def vfchrimson_4s() -> BansalFourStateOpsin: p=1, q=1, E=0 * mV, - name="VfChrimson", + name="vf-Chrimson", spectrum=equal_photon_flux_spectrum( [ (470, 0.34), @@ -246,8 +278,51 @@ def gtacr2_4s() -> BansalFourStateOpsin: ) +def enphr3_3s(): + """Returns a 3-state model of eNpHR3, a chloride pump. + + Params given in Bansal et al., 2020. + Action spectrum from `Gradinaru et al., 2010 `_, + Figure 3F, + extracted using `Plot Digitizer `_. + """ + return BansalThreeStatePump( + Gd=0.025 / ms, + Gr=0.05 / ms, + ka=1 / ms, + p=0.7, + q=0.1, + phim=1.2e18 / mm2 / second, + E=-400 * mV, + g0=22.34 * nsiemens, + a=0.02e-2 * mM / pcoulomb, + b=12, + name="eNpHR3.0", + spectrum=[ + (390, 0.162), + (405, 0.239), + (430, 0.255), + (445, 0.255), + (470, 0.371), + (495, 0.554), + (520, 0.716), + (542.5, 0.840), + (560, 0.930), + (590, 1), + (630, 0.385), + ], + ) + + if __name__ == "__main__": import matplotlib.pyplot as plt - plot_spectra(chr2_4s(), chr2_b4s(), vfchrimson_4s(), chrimson_4s(), gtacr2_4s()) + plot_spectra( + chr2_4s(), + chr2_h134r_4s(), + vfchrimson_4s(), + chrimson_4s(), + gtacr2_4s(), + enphr3_3s(), + ) plt.show() diff --git a/cleo/opto/opsins.py b/cleo/opto/opsins.py index a7cb365..d7715c2 100644 --- a/cleo/opto/opsins.py +++ b/cleo/opto/opsins.py @@ -1,31 +1,32 @@ """Contains opsin models and default parameters""" from __future__ import annotations -from typing import Callable, Tuple -import warnings -from attrs import define, field, asdict, fields_dict +from typing import Any, Tuple + +from attrs import define, field from brian2 import ( - NeuronGroup, Synapses, Unit, + check_units, get_unit, implementation, - check_units, + np, ) -from nptyping import NDArray from brian2.units import ( - mm, - mm2, - nmeter, Quantity, - second, + amp, + cm2, + mM, + mm2, ms, - psiemens, - nsiemens, + msiemens, mV, + nsiemens, + pcoulomb, + psiemens, + second, + umeter, volt, - amp, - mM, ) from brian2.units.allunits import radian @@ -203,63 +204,69 @@ def init_syn_vars(self, opto_syn: Synapses) -> None: setattr(opto_syn, varname, value) -# TODO: not quite done -# @define(eq=False) -# class BansalThreeStatePump(MarkovOpsin): -# """3-state model from `Bansal et al. 2020 <10.1016/j.neuroscience.2020.09.022>`_. - -# rho_rel is channel density relative to standard model fit; -# modifying it post-injection allows for heterogeneous opsin expression. - -# IOPTO_VAR_NAME and V_VAR_NAME are substituted on injection. -# """ - -# Gd: Quantity = 0 -# Gr: Quantity = 0 -# ka: Quantity = 0 -# p: Quantity = 0 -# q: Quantity = 0 -# phim: Quantity = 0 -# E: Quantity = 0 -# a: Quantity = 0 -# b: Quantity = 0 -# vartheta_max = 5 * mM -# kd = 16 * mM -# model: str = field( -# init=False, -# default=""" -# dP0/dt = Gr*P6 - Ga*P0 : 1 (clock-driven) -# dP4/dt = Ga*P0 - Gd*P4 : 1 (clock-driven) -# P6 = 1 - P0 - P4 : 1 - -# Theta = int(phi_pre > 0*phi_pre) : 1 -# Hp = Theta * phi_pre**p/(phi_pre**p + phim**p) : 1 -# Ga = ka*Hp : hertz - -# fphi = P4 : 1 -# dCl_in/dt = a*(I_i + b*I_Cl_leak) : molar -# Cl_out : molar -# E_Cl = -26.67*mV * log(Cl_out/Cl_in) : volt -# I_Cl_leak = g_Cl * (E_Cl0 - E_Cl) - -# Psi = vartheta_max*Cl_out / (kd + Cl_out) / 4.43 : 1 -# I_i = fphi*(V_VAR_NAME_post-E)*Psi*rho_rel - -# IOPTO_VAR_NAME_post = -(I_i + I_Cl_leak) : ampere (summed) -# rho_rel : 1""", -# ) - -# extra_namespace: dict[str, Any] = field( -# init=False, factory=lambda: {"E_Cl0": -70 * mV, "g_Cl": 2.3 * msiemens / cm2} -# ) - -# def init_opto_syn_vars(self, opto_syn: Synapses) -> None: -# raise NotImplementedError("Still need to figure out [Cl-_out]") -# opto_syn.P0 = 1 -# opto_syn.P4 = 0 -# opto_syn.P6 = 0 -# opto_syn.Cl_out = 124 * mM -# opto_syn.Cl_in = np.exp(np.log(124) - 70 / 26.67) * mM +@define(eq=False) +class BansalThreeStatePump(MarkovOpsin): + """3-state model from `Bansal et al. 2020 `_. + Defaults are for eNpHR3.0. + + rho_rel is channel density relative to standard model fit; + modifying it post-injection allows for heterogeneous opsin expression. + + IOPTO_VAR_NAME and V_VAR_NAME are substituted on injection. + """ + + Gd: Quantity = 0.25 / ms + Gr: Quantity = 0.05 / ms + ka: Quantity = 1 / ms + p: Quantity = 0.7 + q: Quantity = 0.1 + phim: Quantity = 1.2e18 / mm2 / second # photons + E: Quantity = -400 * mV + g0: Quantity = 22.34 * nsiemens + a: Quantity = 0.02e-2 * mM / pcoulomb + b: float = 12 + vartheta_max: Quantity = 5 * mM / second + kd: Quantity = 16 * mM + # Sukhdev Roy said they used 2.3 nS for the 'photocurrent simulation' and 2.3 mS/cm² for the 'neuronal simulation', whatever that means + # g_Cl: Quantity = 2.3 * msiemens / cm2 * (30090 * umeter**2) # surface area + g_Cl: Quantity = 2.3 * nsiemens + Cl_out: Quantity = 124 * mM + Psi0: Quantity = 4.4286 * mM / second + E_Cl0: Quantity = -70 * mV + vmin: Quantity = -400 * mV + """Needed to avoid jumps in [Cl_in] for EIF neurons""" + vmax: Quantity = 50 * mV + """Needed to avoid jumps in [Cl_in] for EIF neurons""" + model: str = field( + init=False, + default=""" + dP0/dt = Gr*P6 - Ga*P0 : 1 (clock-driven) + dP4/dt = Ga*P0 - Gd*P4 : 1 (clock-driven) + P6 = 1 - P0 - P4 : 1 + + Theta = int(phi_pre > 0*phi_pre) : 1 + Hp = Theta * phi_pre**p/(phi_pre**p + phim**p) : 1 + Ga = ka*Hp : hertz + + fphi = P4 : 1 + dCl_in/dt = a*(I_i + b*I_Cl_leak) : mmolar (clock-driven) + E_Cl = -26.67*mV * log(Cl_out/Cl_in) : volt + I_Cl_leak = g_Cl * (E_Cl0 - E_Cl) : ampere + + Psi = vartheta_max*Cl_out / (kd + Cl_out) / Psi0 : 1 + I_i = g0*fphi*Psi*rho_rel * (clip(V_VAR_NAME_post, vmin, vmax)-E) : ampere + + IOPTO_VAR_NAME_post = -(I_i + I_Cl_leak) : ampere (summed) + rho_rel : 1""", + ) + + def init_syn_vars(self, opto_syn: Synapses) -> None: + opto_syn.P0 = 1 + opto_syn.P4 = 0 + # P6 automatically set since it's 1 - P0 - P4 + RToverF = 26.67 * mV + # need to remove and add back on units for log/exp to work + opto_syn.Cl_in = np.exp(self.E_Cl0 / RToverF + np.log(self.Cl_out / mM)) * mM @define(eq=False) diff --git a/cleo/registry.py b/cleo/registry.py index f198298..c275f1d 100644 --- a/cleo/registry.py +++ b/cleo/registry.py @@ -3,13 +3,15 @@ This should only be relevant for developers, not users, as this code is used under the hood when interacting devices are injected (e.g., light and opsin).""" from __future__ import annotations + from typing import Tuple from attrs import define, field -from brian2 import NeuronGroup, Synapses, Subgroup -from brian2.units.allunits import meter2, nmeter, kgram, second, meter, joule +from brian2 import NeuronGroup, Subgroup, Synapses +from brian2.units.allunits import joule, kgram, meter, meter2, nmeter, second from cleo.coords import coords_from_ng +from cleo.utilities import brian_safe_name @define(repr=False) @@ -53,6 +55,9 @@ class DeviceInteractionRegistry: """ """Model used in light propagation synapses""" + brian_objects: set = field(factory=set, init=False) + """Stores all Brian objects created (and injected into the network) by this registry""" + def register(self, device: "InterfaceDevice", ng: NeuronGroup) -> None: """Registers a device injection with the registry. @@ -109,6 +114,14 @@ def connect_light_to_ldd_for_ng( # fmt: on self.connections.add((light, ldd, ng)) + def _add_brian_object(self, obj): + self.brian_objects.add(obj) + self.sim.network.add(obj) + + def _remove_brian_object(self, obj): + self.brian_objects.remove(obj) + self.sim.network.remove(obj) + def _get_or_create_light_prop_syn( self, ldd: "LightDependent", ng: NeuronGroup ) -> Synapses: @@ -119,12 +132,12 @@ def _get_or_create_light_prop_syn( self.light_source_ng, light_agg_ng, model=self.light_prop_model, - name=f"light_prop_{ldd.name}_{ng.name}", + name=f"light_prop_{brian_safe_name(ldd.name)}_{ng.name}", ) light_prop_syn.connect() # non-zero initialization to avoid nans from /0 light_prop_syn.Ephoton = 1 * joule - self.sim.network.add(light_prop_syn) + self._add_brian_object(light_prop_syn) self.light_prop_syns[(ldd, ng)] = light_prop_syn return self.light_prop_syns[(ldd, ng)] @@ -144,7 +157,7 @@ def init_register_light(self, light: "Light") -> Subgroup: Irr0_prev = self.light_source_ng.Irr0 n_prev = self.light_source_ng.N # need to remove the old light source from the network - self.sim.network.remove(self.light_source_ng) + self._remove_brian_object(self.light_source_ng) else: Irr0_prev = [] n_prev = 0 @@ -155,12 +168,12 @@ def init_register_light(self, light: "Light") -> Subgroup: ) if n_prev > 0: self.light_source_ng[:n_prev].Irr0 = Irr0_prev - self.sim.network.add(self.light_source_ng) + self._add_brian_object(self.light_source_ng) self.subgroup_idx_for_light[light] = slice(n_prev, n_prev + light.n) # remove and replace light_prop_syns for previous connections for light_prop_syn in self.light_prop_syns.values(): - self.sim.network.remove(light_prop_syn) + self._remove_brian_object(light_prop_syn) prev_cxns = self.connections.copy() self.connections.clear() self.light_prop_syns.clear() diff --git a/cleo/utilities.py b/cleo/utilities.py index 8f1b744..5ed2566 100644 --- a/cleo/utilities.py +++ b/cleo/utilities.py @@ -89,7 +89,13 @@ def xyz_from_rθz(rs, thetas, zs, xyz_start, xyz_end): cyl_length = np.sqrt(np.sum((xyz_end - xyz_start) ** 2, axis=-1, keepdims=True)) assert cyl_length.shape in [(m, 1), (1,)] c = (xyz_end - xyz_start) / cyl_length # unit vector in direction of cylinder + # in case cyl_length is 0, producing nans assert c.shape in [(m, 3), (3,)] + if c.shape == (m, 3): + assert cyl_length.shape == (m, 1) + c[cyl_length.ravel() == 0] = [0, 0, 1] + elif c.shape == (3,): + c[:] = [0, 0, 1] r1, r2 = get_orth_vectors_for_V(c) @@ -213,7 +219,7 @@ def modify_model_with_eqs(neuron_group, eqs_to_add): ) -def wavelength_to_rgb(wavelength_nm, gamma=0.8): +def wavelength_to_rgb(wavelength_nm, gamma=0.8) -> tuple[float, float, float]: """taken from http://www.noah.org/wiki/Wavelength_to_RGB_in_Python This converts a given wavelength of light to an approximate RGB color value. The wavelength must be given @@ -261,6 +267,16 @@ def wavelength_to_rgb(wavelength_nm, gamma=0.8): return (R, G, B) +def brian_safe_name(name: str) -> str: + return ( + name.replace(" ", "_") + .replace("-", "_") + .replace(".", "_") + .replace("(", "_") + .replace(")", "_") + ) + + def style_plots_for_docs(dark=True): # some hacky workaround for params not being updated until after first plot f = plt.figure() diff --git a/cleo/viz.py b/cleo/viz.py index 05d7997..4a6bf49 100644 --- a/cleo/viz.py +++ b/cleo/viz.py @@ -1,26 +1,27 @@ """Tools for visualizing models and simulations""" from __future__ import annotations -from typing import Tuple, Any, Union + from collections.abc import Iterable +from typing import Any, Tuple, Union -from attrs import define, field -from matplotlib.artist import Artist -import numpy as np -import matplotlib.pyplot as plt import matplotlib.animation as anim -from mpl_toolkits.mplot3d import Axes3D +import matplotlib.pyplot as plt +import numpy as np +from attrs import define, field from brian2 import ( - mm, - um, - Unit, - NeuronGroup, - ms, NetworkOperation, + NeuronGroup, Quantity, SpikeMonitor, + Unit, + ms, + um, ) +from matplotlib.artist import Artist +from mpl_toolkits.mplot3d import Axes3D from cleo.base import CLSimulator, InterfaceDevice +from cleo.registry import registry_for_sim _neuron_alpha = 0.2 @@ -287,10 +288,18 @@ def plot( ax = fig.add_subplot(111, projection="3d") if sim is not None: if len(neuron_groups) == 0: + neuron_groups = set() for obj in sim.network.objects: - neuron_groups = [] if type(obj) == NeuronGroup: - neuron_groups.append(obj) + neuron_groups.add(obj) + # remove fake "neuron groups" added by devices + for dev in sim.devices: + for obj in dev.brian_objects: + neuron_groups.discard(obj) + registry = registry_for_sim(sim) + for obj in registry.brian_objects: + neuron_groups.discard(obj) + neuron_groups = list(neuron_groups) if len(devices) == 0: devices = sim.devices diff --git a/docs/_tutorials.rst b/docs/_tutorials.rst deleted file mode 100644 index 5bd60db..0000000 --- a/docs/_tutorials.rst +++ /dev/null @@ -1,14 +0,0 @@ -Tutorials -========= - -.. toctree:: - - tutorials/electrodes - tutorials/optogenetics - tutorials/multi_opto - tutorials/on_off_ctrl - tutorials/PI_ctrl - tutorials/lqr_ctrl_ldsctrlest - tutorials/all_optical - tutorials/video_visualization - tutorials/neo \ No newline at end of file diff --git a/notebooks/newman15_validation.ipynb b/notebooks/newman15_validation.ipynb new file mode 100644 index 0000000..6aa4d22 --- /dev/null +++ b/notebooks/newman15_validation.ipynb @@ -0,0 +1,1439 @@ +{ + "cells": [ + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Replication of Newman *et al.* (2015) *in-vitro* optoclamp\n", + "\n", + "![Newman et al. 2015 Fig 2A](attachment:image.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING /home/kyle/miniforge3/envs/cleo/lib/python3.12/site-packages/attr/_make.py:918: RuntimeWarning: Running interpreter doesn't sufficiently support code object introspection. Some features like bare super() or accessing __class__ will not work with slotted classes.\n", + " set_closure_cell(cell, cls)\n", + " [py.warnings]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import brian2 as b2\n", + "import cleo\n", + "\n", + "b2.prefs.codegen.target = 'cython'\n", + "rng = np.random.default_rng()\n", + "plt.rc('svg', fonttype='none')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Balanced E/I network\n", + "from [Neuronal Dynamics](https://neuronaldynamics-exercises.readthedocs.io/en/latest/_modules/neurodynex3/brunel_model/LIF_spiking_network.html#simulate_brunel_network)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from random import sample\n", + "\n", + "b2.defaultclock.dt = 0.2 * b2.ms\n", + "\n", + "N_Excit=800\n", + "N_Inhib=None # None = N_Excit / 4\n", + "N_extern=1000\n", + "connection_probability=0.1\n", + "w0=0.78 * b2.mV\n", + "g=7.5\n", + "synaptic_delay=1.5 * b2.ms\n", + "poisson_input_rate=8.2 * b2.Hz\n", + "w_external=None\n", + "w_external=0.1 * b2.mV\n", + "v_rest=-70 * b2.mV\n", + "v_reset=-60 * b2.mV\n", + "firing_threshold=-50 * b2.mV\n", + "membrane_time_scale=20 * b2.ms\n", + "Rm = 100 * b2.Mohm\n", + "abs_refractory_period=2 * b2.ms\n", + "monitored_subset_size=100\n", + "random_vm_init=True\n", + "\"\"\"\n", + "Fully parametrized implementation of a sparsely connected network of LIF neurons (Brunel 2000)\n", + "\n", + "Args:\n", + " N_Excit (int): Size of the excitatory popluation\n", + " N_Inhib (int): optional. Size of the inhibitory population.\n", + " If not set (=None), N_Inhib is set to N_excit/4.\n", + " N_extern (int): optional. Number of presynaptic excitatory poisson neurons. Note: if set to a value,\n", + " this number does NOT depend on N_Excit and NOT depend on connection_probability (this is different\n", + " from the book and paper. Only if N_extern is set to 'None', then N_extern is computed as\n", + " N_Excit*connection_probability.\n", + " connection_probability (float): probability to connect to any of the (N_Excit+N_Inhib) neurons\n", + " CE = connection_probability*N_Excit\n", + " CI = connection_probability*N_Inhib\n", + " Cexternal = N_extern\n", + " w0 (float): Synaptic strength J\n", + " g (float): relative importance of inhibition. J_exc = w0. J_inhib = -g*w0\n", + " synaptic_delay (Quantity): Delay between presynaptic spike and postsynaptic increase of v_m\n", + " poisson_input_rate (Quantity): Poisson rate of the external population\n", + " w_external (float): optional. Synaptic weight of the excitatory external poisson neurons onto all\n", + " neurons in the network. Default is None, in that case w_external is set to w0, which is the\n", + " standard value in the book and in the paper Brunel2000.\n", + " The purpose of this parameter is to see the effect of external input in the\n", + " absence of network feedback(setting w0 to 0mV and w_external>0).\n", + " v_rest (Quantity): Resting potential\n", + " v_reset (Quantity): Reset potential\n", + " firing_threshold (Quantity): Spike threshold\n", + " membrane_time_scale (Quantity): tau_m\n", + " abs_refractory_period (Quantity): absolute refractory period, tau_ref\n", + " monitored_subset_size (int): nr of neurons for which a VoltageMonitor is recording Vm\n", + " random_vm_init (bool): if true, the membrane voltage of each neuron is initialized with a\n", + " random value drawn from Uniform(v_rest, firing_threshold)\n", + " sim_time (Quantity): Simulation time\n", + "\n", + "Returns:\n", + " (rate_monitor, spike_monitor, voltage_monitor, idx_monitored_neurons)\n", + " PopulationRateMonitor: Rate Monitor\n", + " SpikeMonitor: SpikeMonitor for ALL (N_Excit+N_Inhib) neurons\n", + " StateMonitor: membrane voltage for a selected subset of neurons\n", + " list: index of monitored neurons. length = monitored_subset_size\n", + "\"\"\"\n", + "if N_Inhib is None:\n", + " N_Inhib = int(N_Excit / 4)\n", + "if N_extern is None:\n", + " N_extern = int(N_Excit * connection_probability)\n", + "if w_external is None:\n", + " w_external = w0\n", + "\n", + "J_excit = w0\n", + "J_inhib = -g * w0\n", + "\n", + "lif_dynamics = \"\"\"\n", + "dv/dt = (-(v-v_rest) + Rm*(I_ChR2R + I_eNpHR3)) / membrane_time_scale : volt (unless refractory)\n", + "I_ChR2R : amp\n", + "I_eNpHR3 : amp\n", + "\"\"\"\n", + "\n", + "neurons = b2.NeuronGroup(\n", + " N_Excit + N_Inhib,\n", + " model=lif_dynamics,\n", + " threshold=\"v>firing_threshold\",\n", + " reset=\"v=v_reset\",\n", + " refractory=abs_refractory_period,\n", + " method=\"linear\",\n", + ")\n", + "if random_vm_init:\n", + " neurons.v = (\n", + " np.random.uniform(\n", + " v_rest / b2.mV, high=firing_threshold / b2.mV, size=(N_Excit + N_Inhib)\n", + " )\n", + " * b2.mV\n", + " )\n", + "else:\n", + " neurons.v = v_rest\n", + "excitatory_population = neurons[:N_Excit]\n", + "inhibitory_population = neurons[N_Excit:]\n", + "\n", + "exc_synapses = b2.Synapses(\n", + " excitatory_population,\n", + " target=neurons,\n", + " on_pre=\"v += J_excit\",\n", + " delay=synaptic_delay,\n", + ")\n", + "exc_synapses.connect(p=connection_probability)\n", + "\n", + "inhib_synapses = b2.Synapses(\n", + " inhibitory_population,\n", + " target=neurons,\n", + " on_pre=\"v += J_inhib\",\n", + " delay=synaptic_delay,\n", + ")\n", + "inhib_synapses.connect(p=connection_probability)\n", + "\n", + "external_poisson_input = b2.PoissonInput(\n", + " target=neurons,\n", + " target_var=\"v\",\n", + " N=N_extern,\n", + " rate=poisson_input_rate,\n", + " weight=w_external,\n", + ")\n", + "\n", + "# collect data of a subset of neurons:\n", + "monitored_subset_size = min(monitored_subset_size, (N_Excit + N_Inhib))\n", + "idx_monitored_neurons = sample(range(N_Excit + N_Inhib), monitored_subset_size)\n", + "# rate_monitor = b2.PopulationRateMonitor(neurons)\n", + "# record= some_list is not supported? :-(\n", + "# spike_monitor = b2.SpikeMonitor(neurons, record=idx_monitored_neurons)\n", + "# voltage_monitor = b2.StateMonitor(neurons, \"v\", record=idx_monitored_neurons)\n", + "\n", + "net = b2.Network(\n", + " neurons,\n", + " exc_synapses,\n", + " inhib_synapses,\n", + " external_poisson_input,\n", + " # rate_monitor,\n", + " # spike_monitor,\n", + " # voltage_monitor,\n", + ")\n", + "\n", + "# net.run(3 * b2.second)\n", + "# plt.scatter(spike_monitor.t / b2.ms, spike_monitor.i, s=0.5)\n", + "# plt.xlim(0, 10000)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "sim = cleo.CLSimulator(net)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING /home/kyle/Dropbox (GaTech)/projects/cleo/cleo/utilities.py:91: RuntimeWarning: invalid value encountered in divide\n", + " c = (xyz_end - xyz_start) / cyl_length # unit vector in direction of cylinder\n", + " [py.warnings]\n" + ] + }, + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cleo.coords.assign_coords_rand_cylinder(neurons, [0, 0, 0], [0, 0, 0], 1)\n", + "cleo.viz.plot(neurons, xlim=[-1, 1], axis_scale_unit=b2.mm)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Multi-electrode array (MEA)\n", + "Spacing appears to be 200 μm." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "space = 200 * b2.um\n", + "n_side = 8\n", + "radius = space * n_side / 2\n", + "x, y = np.meshgrid(np.linspace(-radius, radius, n_side), np.linspace(-radius, radius, n_side))\n", + "y.shape\n", + "xy = np.column_stack([x.ravel(), y.ravel()]) * b2.meter\n", + "xy = np.delete(xy, [0, n_side - 1, -n_side, -1], 0) * b2.meter\n", + "plt.scatter(xy[:, 0] / b2.um, xy[:, 1] / b2.um)\n", + "# xy" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcYAAAGFCAYAAABnrlPrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdZ5hdV3X4/+/pt7e505tGvUuWZNm4AjYJMZ3QDD9aEkogoYQS4E8CSQgEiAEnAUKAhBBKiAkOGHBvYMvdsnqdIk0vt7fTz//FHQ0jXLBsC9l4f55nXswt55475a6z1157bSkIggBBEARBEACQz/QJCIIgCMLTiQiMgiAIgrCICIyCIAiCsIgIjIIgCIKwiAiMgiAIgrCICIyCIAiCsIgIjIIgCIKwiAiMgiAIgrCICIyCIAiCsIgIjIIgCIKwiAiMgiAIgrCICIyCIAiCsIgIjIIgCIKwiAiMgiAIgrCIeqZPQBCEM8fzPBzHOdOnITxNaJqGoihn+jTOOBEYBeFZKAgCpqamKBaLZ/pUhKeZVCpFR0cHkiSd6VM5Y0RgFIRnoRNBsa2tjUgk8qz+EBSagiCgXq8zMzMDQGdn5xk+ozNHBEZBeJbxPG8hKLa0tJzp0xGeRsLhMAAzMzO0tbU9a9OqovhGEJ5lTswpRiKRM3wmwtPRib+LZ/PcswiMgvAsJdKnwiMRfxciMAqCIAjCSURgFARBEIRFRGAUBEEQhEVEYBQEQRCERcRyDUEQnhTT8bA9H0OVMdRnZ3m/8LtFjBgFQXhCXM9naLbK/SN57hvJc99wnqHZKp4fnLbXXLJkCbfeeiuXXXYZsViMgYEBvvnNby7cf/vtt7N161bC4TAbNmzg2muvXbjvLW95Cx/84AdPOt4HP/hB3vKWtyx8L8syhw8f5qKLLiIUCnHnnXcCcOutt7J9+3bC4TADAwNceeWVC88ZGRmhr6+P2267ja1btxKNRtmyZQt33XXXwmNKpRKve93riMViSJK08PXOd77zSb2uJElUq9WF26rVKpIkMTIyAsAnP/lJPv7xj/OhD32ItrY2urq6+PCHP4zruk/0V/DsEAiC8KzSaDSC/fv3B41G40kdZ3CmEly3dyK488hs8MBIPrjzyGxw3d6JYHCm8hSd6cP19/cHS5cuDW699dagWq0GP/jBDwJVVYPBwcFgaGgoaG1tDa677rqgXq8H11xzTZBIJILBwcEgCILgzW9+c/CBD3zgpON94AMfCN785jcvfA8E5557bnDzzTcHjUYjcBwnOHjwYBCLxYJvf/vbQaVSCR544IFgYGAg+OpXvxoEQRAMDw8HkiQFl1xySXDo0KGgXC4H73vf+4KBgYGF477jHe8ILrzwwmB6ejrYs2dP0N7eHvzDP/xDUK1Wn9TrAkGl8qufd6VSCYBgeHg4CIIg+MQnPhEkEongyiuvDGq1WrB79+5g+fLlwcc//vFH/Rk/VX8fz2RixCgIwikzHY+JYoO4oREPaWiKTDykETc0Jkomluudttd+05vexHOf+1yi0Sivec1rGBgY4KGHHuLrX/86r3/96/n93/99wuEwL37xizn33HO5+uqrT+n4b3zjG3n+859PKBRCVVW+/vWvc9lll/HGN76RWCzGli1b+Nu//Vv+6Z/+aeE5QRDwV3/1V6xcuZJ4PM6HPvQhhoeHyefzANxwww28973vpa2tjfXr1/PqV7+aoaEhotHok3rdx6Ovr4/3vOc9RCIRNmzYwCc+8Qm+/e1vn9Ixnm1EYBQE4ZTZno/l+YS0k+cUQ5qC5XpYrn/aXnvt2rUnfZ9IJCiXy+zevZsrr7zypFTlDTfcwPT09Ckdf/v27Sd9f+DAAc4666yTbtu2bRuHDh3C8351AbD4vBKJBADlchkA3/fRdX3hfl3XkeWTP36f6Ov+JsuWLTvp+82bN3P8+HGRTn0MIjAKgnDKdEXGUGRM5+QPaNPxMFQFQz19Hy0n+nn+uiAI+NSnPkUQBCd9fe5zn3vUY9m2/bDbQqHQw4776z1DFx//N50XwKWXXso3vvENTNNkcnKSq6++mpe85CVPyev+pvfz60G00Wggy7LocPMYRFWqIAinLKQpdKXCHJmpLHxvOh4Vy2FFW/yMVKeuXbuWe+6551HvD4VCCyO4Ew4cOEB3d/djHnfTpk088MADJ912//33s27dOlT18X2Efu5zn2PTpk0sXbqUbDbLhz/8YS677LIn9bonAmm5XCYWiy28n1+3f//+k77fs2cPS5cufdY2CH88xIhREIQnpL8lyoq2OD5QaNj4wIq2OP0t0d/01NPi7W9/OzfffDNXXnklxWKRfD7Pz372M0ZHRwE466yz+MlPfsKePXtoNBr853/+J/fee+9vPO573vMerrvuOr73ve9hmiY7d+7kr//6r/noRz/6uM/tmmuuYePGjRw/fpzdu3cvVKM+mddtb2+nq6uLL3zhC9RqNYaHh/m7v/u7h40EJycn+exnP0utVmP//v38/d//PW9961sf97k/G4nAKAjCE6LIEktbY5y9JM3ZSzKcvSTN0tYYinxmUnQrVqzghhtu4KqrrqKrq4uBgQH+8R//cSHt+Ed/9Ee8+MUv5oILLqCrq4s777yTT3/607/xuJ2dnfz4xz/miiuuIJFI8LKXvYw/+7M/4/Wvf/3jPrfe3l5uuOEGNE1DkiRaWlp4xzve8Zhzhb/pdSVJ4jvf+Q7XXnstLS0tvPzlL+dDH/oQXV1dJx3nFa94BZOTk/T19XHBBRfw8pe/nA9/+MOP+9yfjaTg0ZLVgiD8TjJNk+HhYQYGBh42ryU89Q4ePMgll1zCf//3f3P++ecDMDQ0xPOe9zz+4R/+gTe84Q2n7bU/+clPsm/fPq666qrH/Rzx9yHmGAVBEE6rn/70p6xfv54LL7xw4bbly5ezevVqJiYmTvvri7HPqROpVEEQhNNozZo13Hfffdx5553Ytk0ul+MrX/kKd955528swBHODDFiFARBOI1e9KIX8bGPfYw3velNjI2Nkclk2LZtGzfeeCPr1q0706cnPAIxxygIzzJiDkl4LOLvQ6RSBUEQBOEkIjAKgiAIwiIiMAqCIAjCIiIwCoIgCMIiIjAKgiAIwiIiMAqC8Kz2lre8hQ9+8INn+jSEpxERGAVBeMZ4y1vesrDXYjgcZvPmzfznf/7nmT4t4XeMCIyCIJyyHTt2POoGwNPT0+zYseO0vfYHPvABgiBgYmKCv/zLv+RP//RPueWWW07b6wnPPiIwCoJwSnbs2MEHP/Qh/vRd73pYcJyenuZP3/UuPvihD53W4AiQTqe5/PLLefWrX83PfvYzPvnJT/LXf/3XfPazn6W9vZ0XvvCFQHPB+nve8x7a29uJxWL8wR/8AUNDQycdy7Zt3vnOd5JIJGhra+Nv//ZvT7p/dHSUF73oRcRiMXp6evj85z9/Wt+bcGaJwCgIwilZtmwZHR0djI+PnxQcTwTF8fFxOjo6WLZs2W/lfIIgWOjQ8p3vfIfBwUH27dvH1VdfDcA73/lOdu/ezV133cXExARbtmzh0ksvpdFoLBzj3//93zn//POZnp7mmmuu4Wtf+9rCjhSu63LZZZfxvOc9j8nJSW6++Wa+/OUv873vfe+38v6E3z4RGAVBOCXt7e189Stfobu7eyE47t69eyEodnd389WvfIX29vbTeh6FQoHvfve7/PjHP+aVr3wl0Bz5ffnLXyabzRIOhykWi3z3u9/lq1/9KkuXLiWRSPCpT30KRVG45pprFo61detW3vjGNxIOhznnnHN4z3vew9e//nUAbrnlFhRF4YMf/CDxeJxVq1bxjne8g+9///un9f0JZ44IjIIgnLJfD45ve/vbf2tB8YorrkCSJPr7+/n617/Oj370I7Zu3QrA5s2b0TRt4bFHjhxBURTWrFmzcJskSWzdupX9+/cv3LZq1aqTXmPdunUL6dbdu3eza9euhaIfSZL42Mc+9qhzrMIznwiMgiA8Ie3t7XzyE5846bZPfuITp32keKL4plwuc9ttt3HJJZcs3PfrTa+DIEBRlIcdIwgCfN9f+N513ZPu930fx3EWHnvppZcSBMFJX/fee+9T+baEpxERGAVBeEKmp6f55N/8zUm3ffJv/uZpNZJavXo1ruty8ODBhduCIOCBBx5g06ZNC7ctvh+ao8Tly5cDsHbtWnbt2oVpmr+dkxbOOBEYBUE4ZYsLbbq7u/n6v/3bSXOOT5fgmEgkeNe73sW73/1ujh8/TqVS4eMf/ziapvHyl7984XG7d+/mm9/8JpVKhR07dvDP//zPvPnNbwbgBS94AdlslrfPp4ur1Sr33HMPd9999xl6V8LpJgKjIAin5NeD4le/8hU2btz4sIKcp0tw/MxnPsPatWs566yzaG9v54EHHuCaa645KcV65ZVXcuutt9LZ2ckrX/lK3vve9/KmN70JAF3XufHGG2k0Gqxbt462tjbe9ra3UalUztRbEk4zsVGxIDzLPNmNaE+sY+zo6HhYoc2JoDk1NcU/fv7znHfeeU/lqQu/BWKjYhEYBeFZ56n44NuxYwfLli17xEKb6elpBgcHRVB8hhKBEdQzfQKCIDzzPFbQa29vP+2VqYJwOok5RkEQBEFYRARGQRAEQVhEBEZBEARBWEQERkEQBEFYRARGQXiWWtwSTRBOEH8XoipVEJ51dF1HlmUmJiZobW1F13UkSTrTpyWcYUEQYNs2s7OzyLKMrutn+pTOGLGOURCehWzbZnJyknq9fqZPRXiaiUQidHZ2isB4pk9CEITfviAIcF0Xz/PO9KkITxOKoqCq6rM+gyACoyAIgiAsIopvBEEQBGERERgFQRAEYRERGAVBEARhEREYBUEQBGERERgFQRAEYRERGAVBEARhEREYBUEQBGERERgFQRAEYRERGAVBEARhEREYBUEQBGERERgFQRAEYRERGAVBEARhEREYBUEQBGERERgFQRAEYRERGAVBEARhEREYBUEQBGERERgFQRAEYRERGAVBEARhEREYBUEQBGERERgFQRAEYRERGAVBEARhEREYBUEQBGERERgFQRAEYRERGAVBEARhEREYBUEQBGERERgFQRAEYRERGAVBEARhEREYBUEQBGERERgFQRAEYRERGAVBEARhEREYBUEQBGERERgFQRAEYRERGAVBEARhEREYBUEQBGERERgFQRAEYRERGAVBEARhEfVMn4AgPB5BEPDLX/6SUqlEa2srmzdvJhQKnenTEgThd5AUBEFwpk9CEB6Lbdtcf/31+L7/sPs0TWPp0qWsXLkSWRYJEEEQnjwRGIWntfHxce6//36AhZFipVJh//79lMvlhz0+EomwceNGWltbRaAUBOEJEYFReNq65557mJqaAmDDhg10dHQ87DG+7zM9Pc3Ro0cxTfOk+2RZJpPJsGXLFsLh8G/lnAVBeOYTgVF42gmCgOuuuw7btpFlmQsvvBBd1x/Xc13X5ejRo0xOTuK67kn3qapKX18f69atE6NJQRAelQiMwtNKsVjk9ttvByAWi3HuueciSdIpHSMIAoaGhjh27BhLly5lbm6OYrHIr/+ph0Ih1q1bR1dXlwiUgiAsEIFReNrYv38/R44cAWDp0qUsW7bslI/hOA579+6lVquxadMm4vH4wn2+75PL5Th06BCNRuOk50mSRCqVYvPmzSQSiSf3RgRBeEYTgVE444Ig4JZbbqFarQLNkWJHRwctLS3E4/HHPWKsVCrs2rWLaDTK+vXr0TTtMR/v+z6Dg4OMjY09LO2qKApdXV2sXbtWLAsRhGcZERiFM2rxUgxd19m2bRv5fH7hS5IkMpkMLS0ttLS0PGqQmpyc5MCBAyxZsoSBgYFTTr8CWJbF/v37yefzD1saYhgGK1euZMmSJSLtKgi/40RgFM6Y0dFRHnzwQQDa29vZuHHjSff7vk+5XCaXy5HL5SiXy0QiEVpaWshkMmQyGSRJ4vDhw0xOTrJhwway2exTcm6+71MsFjlw4AD1ev1h9ycSCc466yxSqdRT8nqCIDx9iMAonBF33XUXMzMzAGzevJnW1tbf+BzHcSgUCguB0jRNZFlGURTWrFlDa2vrExopPh6+7zM6Osrw8DCO45x0nyzLC4FdpF0F4ZlPBEbht8rzPK6//nocxznlpRiLFQoFdu3aRTgcxjAMCoXC4067PhUsy+LQoUPMzs4+LO2qaRrLly9n+fLlIu0qCM9AIjAKvzWFQoFf/OIXQDMVuX379ie0FGN0dJQjR46wcuVKenp6kCTpUdOuJwJlOp1GVU9fa+DH6sYTjUbZuHEj2WxWBEpBeAYQgVH4rdizZw9DQ0MALF++nIGBgVM+hud57N+/n0KhwMaNGx9zfu+R0q6pVGphfjKRSJzWtOvk5CSDg4NYlnXSfaIbjyA8/YnAKJxWQRBw8803U6vVADjvvPOIRqOnfJx6vc6uXbtQVZWNGzdiGMYpPz+Xy51ytetTwbIshoaGmJycxPO8k+5TVZX+/n7Wrl0rRpOC8DQhAqNw2ti2zXXXXUcQBBiGwYUXXviERmmzs7Ps3buXrq4uVqxY8aQDyJlOu9ZqNfbv30+pVHpYN55wOMy6devo7OwUgVIQzhARGIXTYmRkhF27dgHQ0dHBhg0bTvkYi1u7rV279hGbiD8VznTadXZ2lsOHDz+sCbroxiMIZ4YIjMJTbseOHczOzgJw1llnPaG1hY7jsGfPHhqNBps2bSIWiz3Vp/mo6vU6+Xx+IfX620y7PlY3HlVV6erqYs2aNWJZiCCcRiIwCk8Z27a58cYbcV0XRVG44IILntBSjBOt3WKxGOvWrfuNrd1Op8Vp13w+T6lUOu1pV8uy2LVrF0EQsHr1agYHBykUCg9bFhIKhVi1ahV9fX0i7SoITyERGIWnRC6X44477gAgmUxy9tlnP6H048TEBAcPHnxSrd1Op9Oddi2Xyzz00ENkMhnWrFmDoigL94luPILw2yECo/Ck7dq1i5GREQBWrlxJf3//KR/D930OHz7M1NQU69evf8pau51uj5V2zWQyp7QkY2pqiv3797N06VL6+/t/Y4D1fZ9jx45x7NixR+zGc2JuV6RdBeHUiMAoPGFBEHDTTTctjF6e6FIM0zTZvXs3vu+zadOmZ+z6vieadg2CgMHBQUZHR1m/fv3jao/3SCzL4uDBg8zNzT0s7arrOsuXL2fZsmUi7SoIv4EIjMITUqvVuOmmm4DmXNcFF1zwhFKIhUKB3bt3k81mWb169Umpw2e6x5N29TyPvXv3Uq1W2bx581NaZFSpVNi3bx+VSuVh90WjUTZt2kRLS4sIlILwa0RgFE7Z0NAQe/bsAaC7u5u1a9ee8jGCIOD48eMcPXr0pNZuv8t+Pe16gq7rbNiw4bQuyfhN3XhaWlrYsmWLSLsKAiIwCqfojjvuIJfLAbBt2zbS6fQpH+NUWrv9rsrn8zz00ENEo1EkSaJcLhMOhxeWhJzuJgOWZTE4OMjU1JToxiMIv0YERuFxsW2bG264Ac/zntRSjFqtxu7du9E0jQ0bNpxya7ffBWNjYxw6dIhVq1bR09MDPHLaNZlMLgTK09lkAJpp14MHDz5qN57169fT0dEhAqXwrCACo/Abzc7OsmPHDgDS6TTbtm17wsd5Klu7/Tbdc889DAwM0NbW9rD7ZmZmGB4e5pxzznnMYyyuvN24cSOZTOZRH9toNBaC5OJq1xOFPKezQMn3fWZmZjhy5MgjduNJp9Ns3ryZeDx+2s5BEM4kERiFx/TQQw9x7NgxAFavXk1vb+8pH+NE1eXx48dPa2u3J8Kf//OXJYkgCB5xVHbPPffw/33847S3tfHFL37xpOA4MzPD+9//fqZnZvj7T33qUYOj4zjs3r0b27bZvHnzKQW2E9WuJ+YnS6XSbzXt6vs+R48eZXx8/BG78fT09LBu3brTeg6C8NskAqPwiIIg4IYbblgYMVx44YVPqDDjTLZ2eyy25zNVMpksWszVbVzPJxVW6UyF6EiESIR+1W1nZmaG973/L5iYnKC7s3MhOJ4IihOTk3Qtuv3XVatVHnroIWKxGOvXr3/SAcR13YVdQnK5HI1Gg2QySSKVQYkkCEWihHWVVFhDkZ/69Ktpmuzbt49isfiI3XhOXEA9kzICgrCYCIzCwzxVSzGeTq3dAFzfR6L5Pg5NVxkvNijWHGaqNl4QEA+ptMd10hGddV1xEiGNquUyUWowNDbLV77yL+QnjtGbjvD/ffQv+cxnPvOYQdFyPYbHpzl48BDL+7tZt2rFKf0cbc8nV7WpWi66IpOOaicFbADH85nMVzgyOsPhyTzlSh1FglAsytK2JOev7iEZP/W1pY+X7/sUCgUOHjz4iN14kskkW7ZsEU3QhWcUERiFkwwODrJ3714AFEXB931SqRTZbJaWlhZisdjj+nA/0dptYGCAJUuWnJGlGLbnUzVd6rZLyXSoNHyQQFclZso2iZDK4FyNkCpjqDJzNYfedAhZkuhOhejNhNk3UaHUcIkbKrlCgS9/7RuUp4ZRqzNAQFdnJ1+aD4onAq8iS8yUTXbsHWZ4bJKe3m662lrpz4ToToUf9WfhBwHTZYvRQoNyw6ZUd1FkmUREwwt8wqrC8rYoHYnmyN1yPQ5NVZksWxzP1SlZDposI3kOZqPBXLlKu2axtStER2v2t5Z2Fd14hGc6ERgFoJk6/eUvf0mhUADg7LPPJpVKLWzwe6IIRFGUhSCZyWQeVpnq+z6HDh1ienr6Sbd2u+Ouu8l29pHNZkmEVHT1V6m5Y+NTHBkaZtvWbRiajCpL1KzmsoOooVCsOwzN1cnXbY7nG3h+wLJslERYZSRXp2Z5LG+NMpyr0xJrvoeK6RDWVLqSIbwgIGbIjBYa9Kcj+EDF9Dg8OMS/fuu7KI08kiTzF+/9czauWYnlekwULcqmgy4HjIxNItlVtq9fRSwWo2p5mK7Hxu4EmejDq3mDIOD+4wXuOJpnqmgyV3MwXY8VrVE296ZY0hKhankoMmzpS2KoCsNzNY7O1oloCkdmq7i+z8hcg4iuMJCN0LB9aqbNpnaNNrVxUtr116tdPT+gbnvIEkR05UlfyJxoXJDP50kkEo+YdtV1nRUrVrB06VKRdhWeVkRgFLBtm+uvvx7f91FVlfPPP/8Rl2KcaGKdy+WYm5ujVquRSCQWPmQNw2DPnj1PSWu3626/i7//52+SyLTyx3/8x7S1ZGhL6MR0lcPHJ/n0V/6DohXwB7/3e6xcNoAMxMIKUV1FkSVqlkvc0LBcj5F8HRmo2z6ZqI7leowWGmzuSZKrOaSjGrIkUag5ZGIaUgAl08F0PBwP0hEV14N8qczVP7mGvB9CqRfQK6OkW9p47stej2aECWkKjudy5NgkdSfg0k39rOpMYajNbj7TFZPedJgVbSfPs95zzz1omS5+frTOTMmm4XpULbf5+8Anq5r83rbV9GciTJUtNvUmaInq3H+siOsFIMH+iQoV06FqexTqLqmIiqbIaDJs6E5w/rIWYoa6UO06OTPH6EwBP4BoIglGDCUUI2TopMIaS7KRh6VtHy/btnnooYeQJIlNmzYt/C35vk+1WmXfvn1Uq9WHPS8Wiy104/ldb/YgPL2JMrJnuenpae6++24AMpkMW7dufdTHyrK8sGRgxYoVmKZJPp9nbm6OY8eO4XkeoVDoSadOy6aDG20jlU6TnzrGv3/ja7zgVW9B0sI0GjV+dv3N1CyFdEhGCsX5xZE5NEViSSbK6o4YFctlrmZz7pIMhYaNhNScKyxa+EBUVyg3XI7l6rTGDaZKJmXTJVdtpldNx2NdT4KMbjBTsdg3USFfqbHn7tsp112MVIRLLtzOQ7f+hHyhyM+vu57tF17C8rYolbkJ2uMhqnKMubpPa82mM9m8QFBlGds9edR0ouJVG9hO7wUvJx2LENJlFEmiWm+w/8gQlCfJRhSy29YxP0VKEIAfNKtpDU1CUyXmag6W69FwfDKo1CyXkApjBRPT8YgZKuFwmHC6Dc+JEg91UahUeXCySOBMk5WPo+oaDSXO/lSMC1Z305WOID/G77JmuZiuj6ZIxA2Ver3Ozp07SSQSrFu37qQWf7Isk0gkeM5zngM0A+X4+DjDw8NYlkW1WuXOO+9ceGw2m+Wss84SaVfht06MGJ/FHnjgAcbGxgBYt24dXV1dp3yME63djhw5Ql9fH4qiLCwpiMViC2nXVCrV7PBiurh+QEiViRrN6zLPD5ir2uSqNm7g07A98nWbGBaf/8KVTJkyyWSacy96PrffeReVhkU8FuUVL7yEWVNmpmzRkdAJ6QotUQNVgWrDZWNPEtv32TNWxvR8VAmysRAdSYMjM1WCICAT0XjgeInZqo0qSTQcG9eXGMhG6E6GKVsuo3NlDh04gF2aRk+2s2HDerYuyaL6Jlf9z/+Qr7to6S7OX9vHyqW96JEkeyYqJMMK2WiITT1JYiGFmYrFmo44PelfjaRPVLYephu5YwVnn3UWiqYzXa5xePAYpgtRGlxyzma6WpJ0JnW29aUJGwrjRZO5qkVXMsx02eS6/TNMly1CqoymyBiaTCaiY2gyb9jeQ3cqjO367BwtYTo+LVGNiZLJcK6OKstkwjKzxQr5UpWpYo2E6rKiNcrZy1rpbGs9qcmA6/sMz9WZKltYro8qSxiBSXn0CEv7e1i+fPkpXxxZlsXRo0eZnp5+xG48AwMDrF69WqRdhdNOBMZnoSAIuP7667EsC0mSuOiii55QFxvP8xbK9n+9tZtt2wvLCebm5mjYHlUlDqEY4WicRDRMZzJEXybESK7OaN5cWFpweLqK7QZsX5JidHqOr/7XVVRzU7jhNL5skIiGOeeCi4lGIzQcn7rtkQipRHSVzoRBxfaoWy4r22K4vs9tR3IEvk9YV1nZFiNiKCiyRESVydVt9oyXkSWJ2YpNrmZhuwEhXaY7FaLueEzOVZgcO0ZUcdl21mYS0TCZqE5XIoRn1fnmD66mQpjzNq9hycAAhZrDWKGOoSm0J0J0J0NEdIV1XXHWdyUIaSc3Sp+ZmeHNf3UlE1IbRixF75IBxkaGqLoBRFvobcuwujPJQDaC5/vEDJW+TIQAKDdcIrpCPKRy++FZDs7UCKsyHckQYVVZGM29Zms3azvjzFYsdgzlMVQZPwjI1Ww8H5CYv8Aw0BSZwbkamuRjmSbtmk2XViemsdBgoC5HOFbySIc1wrrCxPQMu4+MsGVlP8/dtOwpSYVWKhUOHDhAqVR62H2RSIT169fT3t4uAqXwlBOB8VmmWq1y8803A80Pl/POO+8JfYidSms33/e5b3Cao5M5ZLtGo1rBlTRMJUY6GSVQI/Skw8RCKhNFk2P5Okdna6xpjxMzVMYnx/m///keXjhNgMwLf//3kCNJvEAiostMFEyyMZ1YSGVJS5R8zaRmugRIRHSF0aLJdNlEVWTa4wYr2mIszUbI12wePFagYnu4fsBM2SJfd5AAVZGJzRfxuEGAb9v0ZCK0p6LN1KIEG7tiOIUp7hopUHQMlvW0EzUUjhcaIEHMUFmejRIPqUgSXLQiS286jOl4eH5ASFMWLgbuOXicD371x5SI4MsychCgGBFaO7vpTkdZ1R4jHdE4XjBxPZ+1nXFWd8TI1RzCmkxb3ODAVIXd42USYb05PynLGJrEdNlkXVeCC5dnGS/UuXOoQDKkIUkwW7WxXI+WiMZ02WJpNsJo0aRQd1nbGUORJCwvYH1njCUJCbNSZHp2jp2jZXRdpyObwnM9CsUC/QPLUEJRzupNEQ89tbM0j9WNR5ZlUqkUW7duJRKJPKWvKzw7icD4LHL48GEOHDgAwJIlS1ixYsUTOs6J1m7d3d0sX778N16xl02HB4+XSIY0dFWmYdnsG5tjaKpEqVrDcz1aU2F0I0wyHiMTi3B0tobl+Uieza233kqjMIPkNJCQCGV72HDuRcQiITwfKpaHrkgMZKNoMoyXLNIRjSAIyMZ0HC8gX3NoiWo4foBfGGegt4uyp3PnUB4/CCjWXVzPx3EdKg0bRdWJGQpzNYe4oRANqbTFQiAFeL5PSJVpC4pkojp6qo1jBQffDyg0bCwnoDNtEFYVzl6Soj0RYrZs05FspnlnKw6u5xE1VHrTEdoTBq7v8/XrHuCr19wFikagaCxfvoKu1jTLWpsj45mSiU9zmUZIVVjdEWNDZ4JAktjal+RYvs4NB2ZpjeloqkzFdDk2V8cPoCtp0NsSZqJo4Xg+bfEQIU2mZrvsnyhTtz0kSUJXFMZLDVoiGstboyTCGpoik4porG6P0d8SwXQ87hnOY9crzE6OY87v1hGNRvH0GOev6qKvPXNaC2h83+fIkSNMTEw8Yjee3t5e1q9fL0aTwimr1WoiMD4bBEHAbbfdRrlcBmD79u0kk8kndJzHau3meP7CfNPidGG+ZrNztLSw/m663JzXihlqM5XnOnhWg8NTFVo1i6ih4KjNK/+bbr6NkumSMQJe//Lf56qrfsSsCZFUC5vOvZiyKxPTFZJhDS8IsFyfvkyInmSYsaJJa8KgPx2marnMVm32HRnh9puuIxOSedEfXs5QOaBcd8jVbeqWzfTkBK7nkW7pJBIxqNse8fmRaCaqUWrY2JZDv1rholWtrFyxnMmyxUylmZYeztWoNFza4gbFhkNHwmCgJUqh7uD4Pr7fnJ+rmi6m45MIK5y/LItXL/Kuv/oc42QJANm3SYQNXvzilxCJRDmaq1Kzmt15LC8grivYns+GrgRd6RBbelO4ns8th+aw3YCG4zE5P0rOxjRaowapiMb9x4tkozoBoEgSqiwxVmwwWTLxgwBFbq7DbI0ZuF6Arkqs60oQ1hTaEwZrOuL4QcB9wzn2HTpKRPFZuXIlBAETswXyxRLtchVd+VXa9XT3doVmN569e/dSKpUesRvP2rVr6e7uFoFS+I0cxxGB8Xfdry/FuPjii5/Qh8NjtXYLgoCp+YXpDdtDVWRa4xpLMlF0VaZuezw4WkRXZKK6ysHpCg3HIwiYT9X5FGs2I7kGy9siRCWX0ckZ7rz+R1TKRWLJDK945Svxwi3YtsP11/wvhUKBdDLJG17/eiQjQqnhMpKrs7ItyjkDGYqN5jpGAmiLa7QnQ9QtjyNjM/zo+/9JvlAgle3k+S99FSVHZd9YjsGxOTxAkjwGOlqxAxlFlkmFdcLzwde3G9QqZf7o/CWct2EZnh+we7zEkZkaXckwXhCwb6JCw3aZq9q0xQ0yUR3P94iFVAgkqpZHSJcJgua8Xlqzufo/v8Z01SGe7eTC513K7bffSrlUJprMcO5zL8WRVDRZxnR89Pk5xJrp4PgBZ/WmWNURI6YrTJYtCjUbz4M7dh+mv7OFUCTOstYIQQB7J8qkIhqRwOTo6CR9/Utx/YCi6dAW1RjONyjUHNIRjartE9JknrsiQ9XyWdUepS8TodFocMOOBxiqqGTbO0lGDEKqjKxILMmE6UgYTOeLjE/nmJgrYtertCVCLOnMLlQ1L24y0HA8HM8npConrVV9onzfJ5/Pc/DgQRqNxsPuT6VSnHXWWaIbj/CoRGD8HTY1NcU999wDsFD6/kSUy2V27dpFPB5/xNZuJ5Y0aPPzcrbnU2q4dKdCrOmIYbk+B6YqjBUapMM6Y0WTXM0mHlLpTjWLbw7PVjmeq9MS1elMhgg1Zvjxf32dWLaLl7ziFaiShF2voSnQcOF/b3sAOz/Oa1/1h7T19FO3PWYrNsuyEdZ0JnB9nyMzNSZLJo7n0RYLUbVdGo5HSnX53o9+SqU4RyKZ4sILL+b6u3dTkmMooTjpVBJZVgGfbNxgQ1cSQ5MZnZqj0bA4b1Un/++CZhr68EyF/ZNVDkxWsB2fTFynYjrMVW0MVaYlYqCqEhFNJqypKLJMJqYtLIGYmM3z/R9fT33mOB1RmXf+6btw1AgTc0X+5yfXUs3PkkwmWXbOJbQno1Ss5gg2HdEZLzYvRJ6zLENPKozr+xiajK5I3L3zAN/9+a2ktIB3vfVyetuzzFWbhUamWefOn/4PxYbNS1/yUtLtPcRCCpu6kwuPqVguqbCKqsr0pyOkIzobeuK4jRr3PLCTipLEj7ZSsXzqjktIU1jRGiFqqMxWbcYKJooc0JeO4gc+Zr1GRm4gNYon9XatyVHqQTPFHVLl+YKs8GMuETlVvu8zPDzM8ePHH5Z2VRSF9vZ20Y1HOIkIjL+j7r33XiYnJwFYv349nZ2dT+g4i1u79fT24foQ0uSF+aMgCHhorEzFdGlZ1NHFcn2KDZvWmE7F8nho7360eAu+EsZyPeqOx7rOOCAxNJUjN5dDSbSiawq6LNOTCVEcP0Y624qvR9BkGVkCxbepVcr84tAUxVKJVX3tpOMxar7G8YpLS9Rge3+GdEQjX7e5ayiP5/ssb49SMX0atktfJkKhWOLqn99I1XIJABQdLRylZ8U64mEDxwuwPY+I1qx0NasFiqZHd1sLbz5vCava4xyZqXLfSJGG7TJZNpkomkyXbRzfpyNukE0YZCIauqrgBz7lhkNPOko29quf0z17DvOzO3YSCRm8/NIL6GhJkgorKIrM9FyR//3ef1AbO8z21/0FXd2dpCMaNcenWHMYL9XpTIR58YZ2NEUhCAKmKxatcR3drvIXn/4XCoUcLakkl732rajhCIcmcvzi3t3YZoOEbPMHv3cJmXgMVZZY0R4jGzOoLXo/qiSxsj1GKqrh1MqMDR0h0dZFWU6gKQrFho3rN1PYdctjTWeUquUxV222p0tFVJa1RqmYHqoisaU3iedY5HI5Hhqe4chUiagKmVQcPRpHDcXY2JumJ336imgsy+LAgQPkcrlH7MazcuVKBgYGRNr1WSoIAhEYf9cEQcB1112HbdvIssyFF174hJZiLG7ttnL1OkYbCvsnKjhBQGcixIauOEuyURzP575jRVRZIqqfXIm4b7KMqkiUJ0b4xje/TqRtgPN+/2V0t6ZQJcjXXAqVCnfeej2NYp43vfolLF++kumyRdV2Oas3ieX4PDhaIh1p7hRhuz6GKnFkpobteqxIKcwWSwzPNhivBERCCms64wSqAZJCrmoz0BqmOxWmVHeQJYl83cF0XManc9x39w4CRcOXZc7avIWVPa20xAwmSiaOF1CuWtQqRVoTGtmWVjb2pPiD9e3Yrs8dgzmGZ+t4NIt7VFkiXzXZO1mhNxNhRVuMvkwERYJj+Qa5qkUirNGXiaDKEpMlk+G5OoMTsyRjUQbaE8iA5XiEDZWQqhCTbTop0LF0DfeOFOcrZiVM16PYcDin/+Qg0nA8TMdjS1+KobFJPvi5rzMTxAlFYpy1eQMP7dxNxXYJh6Ocf/Ym1vZkWd0R5XjeRJKgNx0hpMnUbZeK5aArCqbjUcznmZudpqenlyoGjuNj+z7FerMXbcV0sL2A85alkZExNAVNkSjWHVa0xUiGVcaLDdZ0xIiHNCQpYO9ElZAq49smpVKRYqnEdLFK1DA4Z1mW1mwLkXgSX1IIac3CoKfaiS29Dhw48IjdeOLxOJs2bSKTOb3FRMLTR7PjlPA7o1wuc+uttwLN9lrnnnvuE/pnNk2T3bt34/s+Z2/fzvWHCtw9XGiW/6sK44UGQ3M1LlvfzvLWKGFNoWK6LG4B2nA8SqZDfzpCa383iZZOZqsNdlz/I172yteyblkHgxOz/Pint2PPjNIW19mwrJdMKkxUl5mu2KQjarP3pyajqzJRXSEApkomluOhaQqWbDDjxnDDBq26S8NyGJ6p4Ll5ZEWhJx0hrhgMz1SZrNjEDJXZqoXn2hzZ/SABHoEaJ1BU9h45xvL2BJJkUDVd5sp1fKtOOhFm8/IuWuIGm3uaRUteEFCzPFzfx/EDJAkihsLIaA4CDV2SqNsejfniHU2RSGsexblZCqE+CGCi2KBmOfS1Z0hFdDzfZ6pikwgpKK5HJqLRn21BV1vpawmTDGsM5mo4ro+mytRNl9bEyctkJODElW4qneEPX/M6vv1/N1IvTHDXHQU8I0HUULns4m1EwhFkCabKNi1RjaLpMl02CYCWiIqhKByarlLM53AbVTauGqC7JclP98wQ0RVCmoymSnRHQxyd9Wg4DrNlm5Cu0Ko252ehWUU7WXLYN1Fmz3iFuu2iKs0LqecszRCLxYjFYnR39zBg2czkS+QbdW6+4wCH5hwcWSObCLN9aSsXr+km/Qi9Zp+oE0s9fr0bz9DQELZtU6lUuOOOOxYeK7rxPDuIwPg74sCBAxw+fBh4cksx8vk8e/bsIZvNsnr1ag7O1NkxVCCiyaSjOmXLpVBxGS+aeIHPSzd20hrVGMnVGZqr4Xo+qiKjKRKh+TL/kBriFZe/kav+5yrKhTmu/r//I/XKF/LD736LhhejJZXmQ+/5E5LJNKOFBsO5GhLgjgWM5psFNONFk2REJxvVqFkeVcujP6ozkmswXWkQ0TUSsTDhkI4mS6xoizBTqCG7JlNTE+yZ9bFRaIuHmas5jA8fwq43iMYSrF63gf3791Ozavzs9nvYvm0LBB5WvUZHS4JQKMxk2WJ5e4zWWDMQGapMLKRQtT0s18P1YXZklB133QWpHtKhFUiKREiVadga1WqV6396NdX8DH/wstdgpNsp1l38AEKaiixByfQxHQ9dkTEU6EyG6E6FmK3YFOsOq9rjLGmJ4Hg+iiyxf7JCue7SGm+OpIIgoGQ6tMZ1FBnGihY97Rkue+45XH3V9/BkFdlpsHLTuYRCYSQJEmGNQs1hstggHtHoS0ewXY+JskmuajM1PU1KcegbWELBkjFqNooMkxUTJYCwIVNqQLHmULVcaraLF0BYc9GU5kVZ1XTZP1VmrNBAUxSiukyx4TNYr+P6Ps9f1brQT9b2JCKxBMMFhUE3oKKaOK5DbtbkyNQI9+8f4YWrUyzpaj0t1a6yLNPb27uwIbdlWezfv5+5ubmFtZTXX389AJqmsXTpUlauXCnSrr9DZFkWgfGZLggCbr31ViqVCgDnnXce0eip7b93Ipt+7NgxDhweZOXKFSzt76VmudxxZI6pskVfOsxsxaLh+uiqhO3JzFVsDkxW0BWZsXydY/kGXgCaAh1xg55MmKrpEY4rJOIJ/vDVr+ZHV/2AQqnIl//lSiTPIdOV5s1vfAOWHObAZJljhTqpsMaajjjDcw1Gcg160iFa4zqzVYtj8w3B4yGVgukxU7WQJZmooWC6zUpX1w+QJJm+thSqIjE0WyfUKBMLXIqVGsdGRvBsGy2epX/lCs5d1cX67hT/fdO91GybOx/cz7r+NrYu60PVNbKx5lKH5KKNf2VJoicZ4nYzx3ixgecFSEEILZ6hbtU5cOAAa9euQVdkqtUqN91yG41KlY54mP6udobKPumYii5L5OsupttsgycHEDMU+jJhOhKhhW2sbLf5O9JVeaFycyAb4eBUdaFJuiRBJqrTn4ngeAGW4yHbNW696XpQDEBCckwOHTxAMhphbU8adT7IaYrEWa0p0mGd6arJgckyo5NzGKpE19IeQoaO6gfMVm1sz2dyeg7NCKOqzTnPkCoTC6lUTI9KvUEtX6HU2k1MVxjJO0wULYoNj7a4ihNAKqSjEHB0pkZPKsLytii5qo3pNlvBDc3V8b2A9lSk+bt1fKoNh4YSMO2oGJOTHDx4kHA4vLAs5NerXZ8KlmVRLpfp7+9nxYoVVKtV9u/fT7lcxnEcDh06xKFDh4Bmw4wNGzbQ1tYmAuUzWBAEIjA+ky1eiqFpGhdffPEppU6LDYfJkslMucHeIyPkSjWW9vczbIYoj5WYrVqMFkwUwPECZmsWuiLTkTQoNRwiuoqhyuwcKxPVFM5ZmiYIWPhQrjRcymaV0YKC5XqUXY0LLvl9fnbVfyF7Dr4W4a2veRlnr+xm/2SZQzNVFEkiEdLwAnADn/akQcPxGWiJEjM09k2UiRoK5y/LsHOszFghwA8CKpZHV8JAVSSOztY5njc5uz9FOqpxaLoKkkJnS4ySNMtgo4geSdPdtwQ18Jg9PoSvhXjBlhXccte91GyZkGGQTcXIRDX60mGqltfcyWKe5wdUbZ8lLRFM22Uk38DzJdqXrmVy5DBOdY6hXfcwcME2rtuxi0atQa/u8qH3vRdHjZCzS4wXTYq+T67m4AcBlu1juh4xXUVpk4gazYIay/VJhn/1r+r6PoW6Q7HeHKVVGs3nZ6I6HQmDREjDdDxq1TL/+pUvUy1WSLT1sfn857Pj/t2Y9SoP3f1L+l/4fEYcH9fz2diVJBXWqNkuB8eKTE7NEjU00pk0+YaHj0l7wqBcd5mcnmHwobsJxZMs27CVrkQY0/XpShqYlskdd+7ALk7wupdfRvey5Tw0VsILApJhlWRExfF8yraDrqkkVJ+xYp2K6Sw8ZrpsUTVdfCCsNwOMoUrUZBlVlfFCSTZuWoMc/Gq3lyNHjpy0pVYmkyGRSDypAJXP59m1a9fCnqLQnHM855xzgGbadXp6mqNHj2KaJvV6faEKXJZl0uk0W7duPe1rOIWnlphjfAYbGxvjgQceAKCtrY1Nmzad0vPzNZv9UxVmCjUePDTERE0mmsygV3xcTHaOFinUXFRZwg9gsmxiyBK255Ov2rg+9Gci+IFE1WwWnjQX98voqsRE0WGuapEIq2RjBqbtMVuscO8vfwl+gGckkTybH/7nv5F+31+iGxF602E0VaHh+AzONtNs/ZkIR2ZqjBVN8nUby/HJxnVaYjrpsEpHPIRPgK5IaIpMoW5TajjoisRE2cRyPWK6Qn9LhIGWMPGeZXTFJDASHKtBS1gnmzEwa2VS9Twv2baCvXM2K9oitOsWnckomiJjOjap8K+KXCqmS75mkYlq9LdEaEuEKNRthmYl2tavZ+Sea6lODPLzHx7Gi7SSjhj82dv+jHgiRb7eTEd6vg8EGKrcTB17PhFJJmIo1G2P3PzoLB3RaY03U7i263NopsJUyeJYrtGs/I2GWJJtLnEYnqsTNVS8WpFv/NMVzNZ92pIx3vknr6foGUhaiHt/eTPW5CA3/iTP619/Of19STriYSQkRmfyHBsdoz0dQ4/EyEQM6rbLVNnCdHxMz2d9bwvjD5rMVmHfwUOsXbUKTdOo1Os8dNu1WJUK4XQHqXQLbhBQtVxc18efv67QFBnbaaaNEyGVmKHS3xKmNWYgSTBRsijPt/RbfJnn+QEBPvm6w/3HS4RVmfZEjOUrW1gtywtbauXzeY4dOwY88SYD09PT7Nu3j9WrVz9qc31Zluns7Fyo+PZ9n8OHDzM5OYnruuRyOW644Qag2Y2nr6+PdevWidHk05wYMT5D3X333UxPTwOwadMm2traTun5QRAwVmwwmytwdHiUQI2yrCdBWFcJAiiaDmOFBqqi0pkMYXkeYwWTubqN7QSUdJmlrVG6Ujq5mk3FcqnbPjXLRUKibjmMl0wsL2CgJUI6otEZ8bjx+9/DrDTojCn8+Tvfxr/9yxcZny3wT//6dT78Z28jEW52mklFVI7M1KhZHumoj6FIIAUQBPjS/G4cNRtVlhifmcGWdNoSERqqj+V5LGuNcFZPgkq1xp7D46xe2kvDDZgs2RzLmciRNlzPZ02bQVfKwG1UkawCSwZ6iCRbSB2fQ7IbDI1N88DBETzFYKAtSV8sYMTz5tfuec2lGZ5Pazy00MhAUWQ8P2DDZS/kf775ZQIkPD3BlvMuZcrUmJusoCoyFbPZxi5s6LREwQdMWycRUkkaChMli4AKazpiLGkJE57vJDRRajBVsjBUGVWRWZqNUrM9JksmK9pilEyX6ZJFZXSY0sRROrtX8NY/fTdaJE63IrP63KW8cn0L//CPX6QweYROqchAVy/DczXqlTyHBkfo7WzHUZtVvGFDQZah0HBRZNjalURTZba8+6185l/+nelqkcP79jKwciUHdu7DciTC2SVs3r4d9Ag1y6U9EaLh+owVGkgFiKjNtLciS2hRjXRUozv1q4uO1e0xRnJ1ijWLQlUmGdEomS6u52F5KgTM76/psX+ySq5ms6w1SjgUoqenh56eHoIgoFwuN/eenE+7hkKhhSD5WGnXsbExDh8+zIYNG2htbX3c/1eyLLN69WpWr14NQKPRYN++fZRKJVzXZWhoiKGhIUB043k6U1VVLNd4JgmCgGuvvRbHcZ7UUgzTcfnxjv1MTM8hJ9txVQPPC4gZKsW6gyTBVNlElWXWdMaQJZnxQp19kxXqtseSlgjruuJYTjPAzlVNQqpKSJepWh6zZQvb84kZCsmIjmmaHN63C3tulFQ8xife+Tqes7aPqakZ3vnJLzLbCGiNqLzpLW/BlELkqjbTFQvL8bA8j8CXaE/ohHWV2YrFsrYoEhJ7jx7njr2D6HqIFcuWYvrN9mfbl6RZlgj4py99kblKg1de/mZCLd3N5Rpyc42lLDXX1MWcAnuGJ+no6SOZTKArCh1Jg3LdZtd4hYbloGNj1qrkSjXCKnRkYmihGMeqzQ/DtV3zlap+wJ6JMqVSlfvv+iWN/AQAVrSDcDTGW190AalkkorlcmS6ihv4xDQVWW7OGyZCCoW602yUEFJY3hpDkiAb1VnbGUdX5YXNiR3PZ2iuTiqika9ZjBdNupJhEmGVtrjBxStauO3Oe4i3dYERR5MlOpIh2ufb8s3MzDA8PMw555xD3Xa55cFDHBmdIZbtpOyptCUMTMtjpmJTd1wst9l+blNPgkLdaXYwGp3hGz+6nkrNRKI5vxtKtLBh02bOXtZGS1Rnumzi+gGu63PfaImG3ZxDlJDoy4S4aEUL6YhOW/xXVZ6W63H3UIHhXI3ZqoXp+oRVlXREpTMV4rkrWojoGvZ8sB0tNVjaEqUzadCTDp+0nvYE13UpFArkcjlyudxC2vXEiPLEllrDw8McO3aMzZs3k06nT/l/69GIbjzPHL7vi8D4TFEoFPjFL34B/Gqe44ksxbBtm7sf3M0vRmrEWjooWQGOF4Ak0R7XqZouXtDstWm7Pktbo3QnQ0xXLB48XqI7ZdAaNyjUHAp1h5F8naiuENFkbDfgeLGB64EmQ1vCoDMV4ujoDIeHjxPF5LnnbWfbsg560waeD7uHp/n+j39Oo5TnJZf9AQNL+hnO1anbHh0Jg5myyWix2Ye0Na6hyc0Akq86zJSrHNy7F6teJhwOsXTtFsJhg60dBtd/71+ZnZujpbWdl77x7SQTCSKGQsNqtjmLGzKHB4/Rrpucc9ZGfNXA9QNkJFQFDk03K2NTEQ0JieOFOvvGSyxJqSQki2KpxO7xKscbCmvaorS1JJFUg4lcmZ/efjdWrUyLbLP1/Odx+wN7sYtTpMMKL3vZy4hGY+TrNlFNQVcVcnWb9riB4zX3OOxMhehKhFnRHkWieZFiTw9y1uqlHG/oEIBPwMHJanNbrHyJXKHEtlVLKDccUhGNVR0xJksWsiyRiWi48xc+qztjpMK/6lzk+z779+9nNpenb+V6ar7C8Fx9obE6EjiuT8xoViXbnk9nPESx4XBgqkZudoaf3XgTATK+GuL8c8/B1aL0t0Sac8WeT81xqTaaS1u602FqlociQVcqxNrOOPm6Q0citNDtxg8CRosNuhIhKqbDTMWaH5E3e8X2pCN4fsBIrs7cfOAcyEYIqwqqIrG+K0Eqoj3yP8C8xWnXfD5PEARomobjOKxfv/6URopPhO/7DA0NMTo6+ojdeDo7O1m3bp1YFnIGiAX+zxB79+5lcHAQgGXLlrF06dJTPobr+1TKFXbt2sWMF8EKt1JzfSzLZ6JiUrc9wppCV9KgYrrUHJ/+TJiIruL7zWUTputz8YosxYY9XzDi88CxEh0JHW1+8fXRuRoEYHs+rXFjoVF4Ll9koDVBSzLG9oE0w3M1UhGNpdkIDw1NMz2bo7+/n3zNwvabu0F0xA12jZco1psj5Pa4QWtcZ6LQmN/aSWJZUub//veHFGsmRksXq9dvZuiBX2CO7aUtm+WP3vVeTClEa9xYWGphWSaHDh+m7MhcevZalrUnKc33Vi02HMqmw2TRZG1HnJaYgU/A/okKNdslrCms7YyjyjJ1y+La3eOYjTp6YOLVq/zy3p2UXZWM7vKmy1+DZESZnCty/c+voTo3RTqV5I/f8iZSqST+fPXsWLFOseFSbtj4AazvSrCkJbLQMOHOB/bwnW9+hd5owJ99/DNUCdMW19k7XuaewRnuu/ceTMfh4rM30dbeSRA0q2YjRrO/a1usOZKaq9pk4xobupqjI8dx+OW9O5mrOfQvW0lLIkJbXMd2A+4dznN4tkZLVMdxfYoNh6rtUTVdVrRHWd8VZ9/INFd/778ozE3iaxGceCfRWJJVW55DPBLCD6DuuOiKgu8HtMZ1VrTHiIdUWmMGvh+gyhKaKpOvOSTnt6q6d/c+VvR1cfH6PvxAYniuRq5mMzhbJ1csE3VKbFy/miMzdRKGTNH0WN4aoSVqMF0x6UqG6M00q6iLdRddk2mN6WSj+iNeTHqex0MPPUSlUiEcDlOpVE5Ku6bT6Ye1QXyqnVgWks/nH9aNxzAMVq5cyZIlS0Ta9bdEzDE+jQVBwC233LLQkeNUlmKUTYfpssVk2aRquhQLRUozE/R0dxCPZVgeDzFWajBVMolaCqW6gzrf0NvQFRJhnaXZKKmwSqnhUnNcYrrC2PBR6kaKntY0hbqNIkvoqkrYUPDtBmGvhqfHUCSZlojGXNWm0nCJxuOEI2EarseR2RrHcjXa4wZ96Qjrl7TTkmqmGAsNl3REY3k2Rtl00FWZiK7h+0FzV3pVIWpoGKpFIqTR3Rrnja9/Ld/+/lXMVWvcs+sAiqPQ1d7LH73j7cTiSdr05pweQLlS5sjhw6QyGVrSHUTDBpbrcWi62pzTjGiossTxXIORfANdVYiGFCQJfL+ZAjxREhLSdbYsbSeqK3g+7Nm7l7ppkVZNXnrBucjVGXwnjqronPv8F3LXbTdRKBc5PDpNnxRi+0CKtrjBinqEquWSqznkqhbL2mJoiz4As21tZNNJJo4d4Mq//2v+6AOfYIYYpXKZu3fuxvJVIoaKEkqQr7u0xZrbWPWmIwQ028TFQyrJ+d9lw2lu53XzXQ8yY2v09S3HCRRG5urMVCzWdsRZ0R7DBzRF4qHRMuWGSyqi4So+w7M1xmdK3HbLjdQbDu0tWd7w+sv56o9/SdlyOPjgnWw8+wICRcXzAlw8oiGNjmSIgZYIyXBzFF6sO6iKzOr2GKOFBnNVm3t3H+B/fvi/tER1jPe8EyUcx3R9opqK5NT5yXU3U6+Vea0TkOnopWgGhDWZmNH8KAtrCtOVZvFOqeES1mScesB0yWJZa4S+zMmt5lzXZdeuXTiOw3nnnYeu6yelXRdXuy5Ouz7VAcowjIVexr7frLY9ePAgtVoNy7LYs2cPe/bsAZoZo82bN5PJZJ7ScxB+RYwYn6Zs2+baa68FmvNYJ+Y8Hs8/ZLHhsH+yQqHmMF1uFpE4Zp2Ny7pRQhFqtsfZfWkkGWqmtxBEdU1ibUecTFQDJCaKFg3HbS7YlyXu3bWP737/+0RaunnL5a/CxODAdIWEoWKaJnf+4jZqpkX32u20Z5N0pyIU6jZzVZvedBhdac6lrWyPsWe8hCLL9KRCrO6Ikwhr1C2X4VyNsKbSmw4zV7U4PNMcLcxWLAZaIrQlDOZqNglDoeb4JAwNWZbYfXSMW+7YgS+rSHaNV/z+87lgwzLWdcUJazJ7J6pMzcyQnxqnu7sbU0sQILEs2/ygnCyb9KbCzZGU73Noqsp02WJle4zedJjxYoNdY2XWdsZY0tK8OMnXbDRVZmN3HNsN8IKAn91+H4lsO0u7slTKFabn8vxyMM9UzWNJDPTApr1/GTYql6zKsqH7V9t/VS2XXWNlgiAgFdaQJIlyw6Fqu/SEHD718Q8zMTlJe1cvf/zu9/PZ//opOT9MSrZ5yYtfgqXoTJcsNFUmE9FY1RZHVSXytWbP2vZ4CNPzWJGU2btnFzk5TVd3D+mI3lx+Yrkcy9fRFEiENI7l681q4ppDNmagSBITJZNqrcH999+DmZ8mHo/xwhf+Pqu6WrhvcJrb77ybeqVAJJHmnO3nEgobhDWZTMRAlmFZNkp3KowfBEyWLFa2RxZ+ngcmK+wenuQ7//51crkZkm19PPelr2FtbyuTcwV+8L9XU2x46Kl2Nm8+i0gkRCai09sSZiATJT1/IVZ3XDRFoTNhLIwQK6aLG/hs6U0R0ZWF/7GdO3eiqiqbNm161GKcRqNBPp9fSL0GQfBb3VLL931GR0cZGRnBtu2T7pNlmdbWVjZv3izSrk8hERifho4fP87OnTsBSCaTRKPRhc4bmUyGbDZLNpvFMIxHfP7+iQqTZRPLtrnvwDBxLaC1owdF1cjOp+C29aVpWdTMeqps0psJsbItvnCb6/tYjo86vxTivkOjfPKLX2fW0UhGdF75speihyLMlSr8/MZbqVarxKJRNpx9HvFYBNdrzucFSM22cQ2X/myzF+fh6QquB6oi05cOs6w1SkiVCRsycUNlqmwzPFdl30QFRZGIaiqyLBHRZToTBheuaGWsUOeB0RIHx/M8eP8DmNU8an0OtZ4j3r6EN7/hci5c10sqrLL/0BH2Hpuhvaefum9Qc13a4wYxXWO81KBheWztT6EpzQuPu3fuoSQniMfjLM1GcNyAutNMpdarFaampzlrwxpWtEYXllIAzFYt9k6U0WWFWKjZKu/OoTyuYxOWXBr1Oq7VIKZJdGWTnL+yg4627EIR1UzFYmi2TtV2qTSanWRihkpHwkB3a/zj33yUyckJAknByizDaFvKc553KdFIjIbTrEj1aVZ2tidCpCMqhYZLJqIS1lRCfg17eoi2ngFmghjZaHNu9Xi+zlzFZrTYYK5m0RFvrh8dydUJaxIr2+M4bkDN9miUZvnlXfeQ0jze++ZXU/ab86OqDPVane/+37VUXYkXXrCV9SsG8AJIhVWG5xqkIs29LS3XoyWqs6YzTlhTqFkuD46WCKkKZq3EF664gulSHa17Leed+xzuu+MWKvlpMqkU5/3BHzJRa/bszcT05mhShmxMJ6Ip2J6HJisoioQsScQMBUNVmCybbOpO0Bo3aDQaPPjgg8Tj8VPa0PhEteuJQFksFs9I2vXw4cPMzMw8LO2qaRrLli1jxYoVIu36JIjA+DSzY8cOZmdnAdi8efNCEUAQBFQqFebm5pibm6NcLhOLxRaCZDKZRJIkLNfjjqN5iqUy9x06jiUbtGVbiGgKfgDLWqPsn6yiq81dEzIRvVl0IvEbixaCIODw8Qne//f/TK7mkI0oXP7a1/Ktq6+jYPpEozFe+sJLWdrVgu8HTJdtEmEFVZbYOVamarokDJWa7RHSZFrjBsW6S0yX0TWF5W1RLljWQiaqMV5scNdQnnzdwfchpCkEfkCx4bJtSYILlmWRJLhh5xB/9+2fUa02O+b8wfMu4Mabb6ZUrZNIpPh/r7iMWqVEi+5xyTkbcSSNvRNlsjGdsNYcIcxWLR44XmRzT5KORIi9e/fy5a9+hWjbEt7zjrewuq+DiK6SCCuMjE/zV5/8O+bmZvmbj36Ii88/92E/oxN7U9ZsF9P2mS5brOpo7l/pBQGu6zGeK5ErVlliNDC8Gqlkgmw2S0tLC0YkxljRZPdYGcf3SYSa6d0AcPPjfO6Tf4kbyWInB3jOpZfhajHS0WYbuHzdQZEkVrRGiYUU5mou5bpNdypEjDp6ZZrztqwllmppNmcPa0yWLCZLZnMj6rkaNdslpKmkIgqTxeZ7WZaNsDQbpdjwCGsyR46Ns2mglfNWd+O4ARXTpmo10+SVSo2RmQLLejvRFZnlbRGWtkQ4PFujNWaQieikIxrZmL6wofVsxeLB0RJdyWYRTr6Q53Nf/CcmgiS+FkUrHaclmeS1l7+B41WQpID+TISYoVK1mlmPhKFxwfI0u8bKTM8X7ECzLV93KoTt+ZzVmyKEzYMPPkhrayurV69+Us3BF6dd8/k89Xr9tKddf12lUlnoxvPrIpEImzZtIpvNikB5CkRgfJqwbZsbb7wR13Uf11IM27bJ5XLMzc2Ry+UASKQylKUoO4byHJ0u05Aj+LKKKoPjgSpL9KVDyJJMZzpE4AeENJnVHXFWtseIG81R2Yk1c49mdGKK9/5/f8dUqQGSDK5FsqOXN73pLazpb1+YHyvNd2RpS+jsGMwzUbJIzXc2URSJhKGBFNCdCmOozb6q5y9tQZnfeWLvRIWO+WKgE51QfD+gNaaztT/F/YdG+esvfYNpUkQiYc57zrmEQyGKlTq77rqNarlAzFDZ8pyLGOjvY2NPkqiuUjQduhK/Sn85vs9Dx0s4gc+m7iSlUpEvfflrFOZm6Iv6/NMVn6OtrY2ZmRne//73MzE5SVdnJ1/84hcfdQ2p4/nNDXhdn4PTVVRZJqIrjBVMpsoNSqaLocosa43QEVVJyyaF/K9SdcedGBOWTiYRQ1Obregkp85//9e/U8zNEKghXFlH7l7Hxg1nEYoY9CRDuEGzUYCKjON71GwPTZGwaxUkp8G2Nf0MtKfpTYeZrlhMl00e2HuYttZWyp7K0GyNsK7Qm4lgOh64Jg8Mz9GWbWF9Z4LZqkXNcklGNc4byNASbW5Tla85OJ5HzfKoWM2GAKW6Q1RX2L40ha6opCMa67vihDSFQt3meL5B1Wo2kSg1XAbnaqTCGp2JELois/PQIN/4ye14oRRq6Tj/7xUvJtbSxmi+QW8mTCKkLez3ado+btCsTr1nqECx4dAWDzX7upZMpsoW3akQqzMq+dEjrF/ed1q2lnqstGsmkyESOX3bacHDu/EsJssymUyGLVu2iG48v4EIjE8D+XyeX/7ylwAkEgm2b99+SlexQRBQKpW49/A4+47NkG+4HKmoSIpO2YGooaFrMqWGS2fCoCsZ5oIVLaQjGtNlE1WWSIZVLDdAliVaojpLWiKPGSD37t3Lu/7iL5vbOwUef/IXf8X6lcvxggDT8ZFoFkKULQdjfvF7oe4yU7bI1ayFatU1HXE29CRw3QDL89nWn8RQFabKJnvGK3QlT543KdRtIrrCQDbCD266l2/9949Q2ldwzjnb6UgnGC+bJAyV6VyBPfffTVCa5NWveAnpziV0JZsNBBRZYnlr7KTjjpca2I5POqoTBAFeo8JXPve3zIyP0NXZyUc/+lE+/ZnPMDE9Q1d7O1/64hceNSgGQUDd8fD8gLCmMF5scHS2juv5HJhsVrc6HvSkQvSmwyiyxObeJK1xgyAIGJ/N8727j1Gv19B9i1DIwPXhult/SaVUoiUW4q2veSnfuOpnzMgZ9HCUgeWrQVZIR3Q6UzoTJZuYrtCZNBgZn8bzXFb0ddGfjdOWMCCAgWyYG+7cyb/+6BZCsRhrtl1A3ZXpSBi0J0NUKjXuvvHH5F2NjWc/hxV9XZiujwycO5ChOx3C9Zr9U2UpACRa4zrFhstsxaJsOvN7UEZY3xWnJxUmaqiM5OrcMZgjX3VwfJ9c1SI5P4q05v92ytUK1994MyXTx9eawSSlelz+0ueDGkGSJPpbwvTNb7lVMV0CAkKaQq5mU7ddclWXsukwU22uiV2dUanlJkhl21na046hKkR0hfaE8agVq0/G0yHt6jgOg4ODC914FhPdeB6dCIxn2O7duxkeHgZgxYoVCz0ZT9VsoczVv9xFxNCww1luODCL7VgU6wESkAjLOCi0JyKs70kslPAfy9U5MF2lKxWiPx0hG9Wpuc3KxnVdzWUJv258cop3fewzzFSt+S2OJKJtPbz2la8gHIs310XSLMXXFRlNlYnNpyInShb7JyuocrM59lm9SbqSzaUEibDKpp4EsiRRs112jpYWeqdCc85zpmKxpiOO43nsGCpw34FhJD0Gqo7tBZTqFiHJwaw1yCRCtBs+q1cMUDI9VrRFKTUc6rZHXzpCfH55QMPxGCs26M+ESUc04iGNTERjdnaW977/A0xOTeCrEbxQkkxbF3/2rj9ldV87XanQwpzkCXXbYyRXJ1drbuAb1RW6kyHKpsO1+6bZPVEmHTboy4RpjWnYXvPntKUvyfquJEEQcGSmys/3TpMMqaTCGpPTU1z9o/+laLrosQwvumg7y3o6GCs7/OznPycXRFHjLXT3LqE1EcYPminVzd0xqOco2hIdra1oikomprO+K07FdOlviaBZRf7o09+i4KokDI1lWy9AUjQ8z+HIzvuwcsdIJhK8/jWv4uyVXcQMhXzNplj3CGim4KNGc13p8UKDiKZguT6KJCHLElXbYWtfinMHMvM/H5erH5pkrtpM706UTGYrNpoi0Z0OkQ7r3Dc0xY1378GtlYlrAReft41b7tpFzXZpC/K89BWvRjXCbOpJkAzrNByPQt1maTbazC5YLomwRqnhsH+yjOdDvVZFrc4AHm6sk3g8zrquOK4bEEgBq9rjqFZ5oenB6fBIaddEIrEQKH8baddqtcq9996L53kPuy8UCrFu3Tq6urqe9YFSBMYzJAgCbrrpJur1OvDEdsU4YWZmhnsf2kdRzdDS1s6u8TIHpiqEVIW5moMueWRDAWMFE3yPjoSOYYRIxMPUHQlFhnWdSVwvIB1V6c9EKdRtNvUkT9ptHuDwsQne9/f/zIxjkIzo/OFlL+DaH/03k24YPdPLG198Id2tGWzHY/dEBUUO6IiHqTse3akQ7fEQI3NVhvN1VFlmc0+SeEjj0KGDXLh+CWsGuhdea7zQYHCuxmy+wOz0DMtXrqQ9obOiLcaByTK3Hc4jSWA5PrGQSqFms390BjyXZCKBoRu0JXQCP6AlpnP2kjSVhoskNdcPWq6H78NM1QIgFdaoWk6zefX8nOzo6Bj//f3v4SOhuHU+8K530NO/hHzdIRFSaInohHSFTFTHUGTuGsozWmwQ1RTk+f6xXhCQCCvsnagyV7ZoS4QIAkiGmw21J4oW63tirO2I4/oB4wWLvZMlPA86Ewa1uTF++KOrMTKdvOj3LqEzrjE2V6ZcbeD6DrfsGcdUwqzo7aK9Nd1cP2ja+FaNgYxBNJltXpQUbXRVYkVbs/9rJqITMWRu2TvO9TffTq1aQk+2k+xdyfT0DH69QJoab3zFH7BpoINNPQl0tdnyrtRwsD0fy/UZLzaYLFkMz9UpNRwCAlJhlZoVMFlusDQb5UXr21neFmWsYPLT3VN0p8LISnONoiJLVE2XqK4wkIArvnMtRTlGTHK49KLttKXiSK7Jf//8dqy543SrZd79vg+hheN4foA/vyPJQDZC3fIYnKvTkTAwHZ8DUxUqpQJTMzk6Qh7f+b+fE0lm+cNXvJxtKzqbqfW6Q6Vc5D+v+ASzM1P8/ac+ddqC42KPlnY9kXp9qtOujuOcVIUrSRKzs7McPnz4YWlXSZJIpVJs3rz5WdmNRwTGM6Ber3PTTTcRBAGGYXDhhRc+oTROEAQcPXqU0dFRlq9aw6GywvBsHUmR2DteRqI5cggCn/50mOFcA0WG9nBA4FqUqjY5W6IrqXPOQAuRaIyy5bOiLYrp+qzpiNOd+lUqc2h0kvf87ReYMjXS8QiXv/ZVSFqEwKnz/f/+ATk/SlLzecVLX4wn68zVHCK6TG86jOl4lE0XxwuIGAqlWvMDtDUeguIEV33t83Slow+btzt6fIK//Ou/Yy5f4C/e9x7WrNtAoe5yZKbK0dkqXckQhbqLIgXMzUwzXvUIR+OEDY2QqpIwFNygGRi39aWpWC7ruuLEDIVSw2W6bHG8UKctZjBRNCmbDiN5k9F8jbASsP/e26naPj4SRvEYnVGJd7/n/cxYKnM1m+Vt0YU0cN12mS7bhHWF2YoNBHQkQvNzsc00Y6nhkghpOL7PVNEkrDX7hp47kCZXc/F8n5XtMUYLdQo1h1LDJRPTKUyPEU1k2LQky1zNYe9ElZppg+9ydKpMud6gI64TC2tEDI1S1cRXQ6zvbSGQZDzfY3iuQVcyxKqOGMNzNXRVoi8TpVi3sRp1rrr+TmpmA8mzQQ0RMsJccO5WlrWnOXtJiv6WCJmovrD1FsD+yQpTZZNsTOfe4SJHZ6s0HG++n6tEItK8MOnPRLhkdRZDk7nl0BydyTCaIjGSa+DNB1hZBkrT/M/NdyMlOvi9c9aTTsSwHJ+2uE6lVuPmH/8Ae+g+/v5vP8maTVsYnK1zLNfA9jxkSaYl1ixUMp0ARYYd+0eoVKpsX7OEpB7w+X/7HsViiVQqyYff8QY6W7PM5XN87p/+lerIbnpa0485d3y6nO60q203C45CoRAbN258xBGh7/sMDg4yNjb2sLRroVDgpptu4qtf/SrxePxhzz1Vs7OzrFy5kmKxCDQDcRAEyLLMRRddtLDhOsBnP/tZPvaxjy1U4K5bt47BwUFM0yQUCrF582Z27tyJZTU7ZIVCITKZDLlcDt/3Oe+880463mOZmppiZGSEZ/d4+QwYGRnhxhtvJAgCurq6uOiii04pKJYaDkdmqtwzOMvVt97L0bFptm/fTl93J7IEx4v1haKHkulQtxwKdZf9UzUcrzkHEwpHiSezdHR10NeaRJYUpmZmOHToIKNjo4yMTWKaJr8+xbjr8DD5cp1MLMRrXv2HZNPNbZ1QI7zkFa8ioQdYc6PojRwBoMpQtbz5tGIzZTldtgipMtuXZnjR+g560iEiqQzpti7GZvK8//3vZ2ZmBtf3OXxsgo99/K/IjR2lK6ETa+nkWL6BHwRoioTvw1zVxnVsDo+MU7RlUqk0nakIF69opS8TwqX52LmKNV+NqpGN6iRC2sL8XjZqUGw41ObnH8t1G9u22fPgPVRrNWKGyoXnPYdIWx/TxQqf/9dvMTxdwPV85soWxYbL7rEytxyaZXiuynihTliXSYRVTNdDVxUcz8f1ApJhjeHRMabmyszNp1s7kgbx+cpTs1Hn0KFDdCTDpCI6yYiGrkhsWLWcgY40lifRlQyTCivMVB1qrkxbNsWaJV20tLSgqwq6W0PCx7EsZnI5SuUKB6cqGGpzXs50PCyn2Qf1eK7GVNmm7mssX7MWAh+9NotaneKCbetoz8TxCMg3HHZPlBmcq+LPX0vbXrMjTkxXUSSZTFQjE2m2jZNlida4ga7INByf44UGNx2cbbab82GuYkEAqZCK6foU6jYxXaW1q5et27bRv3Q5JUdmpmxRNF2OzNRQ9BCvvfwNfPBjn2Db9u3UbJ+9ExVmKiY126fUcDg4VaXccFmSMShMj2G4VTau6GdpR4pspoWX/+EfEm1ppZyb4stXfpHBwaN84YtfopDP09nedkaCIjQDQzKZZGBggG3btvHc5z6XVatWIUkSR48e5fbbb+fee+9lcHCQYrH4sGUaj8WyLO6//34ikcijBkVoFuesWLGC5z3vebzgBS/goosuWqhm/da3vsV3v/vdhZ6yS5Ys4Yc//OETfr/r16+nUqnws5/9jHQ6TRAEtLa2csMNN3D33Xdz+eWXA81A9ZGPfISVK1cyNDTEq1/9avbt28dZZ53F7Owsz3ve87j77rt5wxvewJvf/GYymQyNRoN/+Id/4KKLLmLJkiXs2LFjoUnKbzIxMcH73/9+MWL8bbrzzjuZm5sDYMuWLbS0tJzS8/M1mwNTVfKlKuOjw+hGhCVL+lnblSAI4M7BHHsnyqiKTMP2qNoulu1jeX5zJwddIRPR6EiGMWSJkuki0Wzj1hLVietQrtSJSRYJ6qzIaLS3tZLKtCCH4uyZrLJn/2FaWrL4epjMfLPmuaqNIgUcnykRc0ukOvp48Hip2ZIsojHQEkECdk+WkQPY0JOgKxEiX3fI12wKdYeM5vG/3/kmpbHDdGRbeOVb3sV//eCH5AsFsqk4b/mTt1PHoD1ukAg1P3wPT1eYzZdwKjm6OrK0tGQZyzfoTIdY2Rrn0HSV3WMlcnWbuuOxNBvhpRs72NSdXLgYeeBYkYrpMlEyqTtec851osjw8DBurUBUU7j0onNBNZBckx03XEPONYhEY2zYdg7xSJiupMHhmSpTpWbzdD+ApdkIA9kIlhtQs5ppwmRYZ2J8lJtuuA492cqqrRewvCPFmo4YqbDKrpEZrvnx/1HNT/Oet76O7oFVjJca+H7A+q4402Wb1phBQMADx4scz9eZrFh4ro8XSCieieparOprY7zqYZo2PdGAfKXGZMWlO2HQ3RLFVULM1Jsjd9f1ydVsijWTo4cOYJsmsl1Bdm0S0RCXv/JFRKMx1nTEAYliw2FdV5xESEWRJHaOlvD8ZsCfKDV44HiJ2XKDmaoN8z2CiuUy8UiYSFinJx1uFl5VHZJhFcW3GZzI0draxrK2CBNFC8v1KTeavXgXCpm8gOXtMTZ2J+hIhGiN6UyWTQ5MVZvblSm/qoQu1m1WaAWSisPq9Rs5VnQ4lm9gez65qkOtVuG2H36LwuwkARK+kaA9rvO1z3yM9vb2p+af/SlmmuZCA/RTSbuapskDDzxAMplk7dq1T3ju0Pd9/uM//oP3vve9/HrIaGlpWfhcezxs28YwDD70oQ/x5je/mfXr1/Pnf/7n/PM//zP1ep2/+7u/44orrsCyLF784hfzs5/9bOE1X/SiF3HttdeSSqXI5/NcddVVXH755axbt45ly5bx+te/nte97nUsWbKEl7zkJXR1dfGRj3yEHTt2PK70eKPR4Kc//akYMf422LbNT3/6U+bm5lAUhYsvvviUg6IfBIwWGkzOzJIbO8rS7na2b1yFrqocna1xZLZZ6r6sNcbSbIRNPQmyUYPeTJhzlqR56cYOtvamWZqNEVIVutNhNFVmvGQR1hRkSWK06NCQQmxcvYzXvfBC1q9bi+PDjfcf5HvX7+C+vYcpEMYMFFw/IF+zqVtuc7spSSYZj+HFO5iuWNi+32x+7XjoWrMqdapoMlmyOJ5vcPdwgf0TFWKGQiqis7K3lT95+zswlmxhWG7nH7/9f8yVqrQkY1z22rdyz7jN0GydkZzJkdkqpu3g14tMzebp7uliZV83MUNjY2+SmKEyXTE5OFVB05pbM/VnIoRUhfuPFec/tJtaYhp1x8N2PWbKFkEAvm3iWiYRTWX5ui24aEyXLOZMmfNf8FJiYYNGo45v1QjrModnquQqDiFNIRvV8f2AiZLFaK5B3fZIGBq6phAxFNb1dxCPRqiaLvt2PUh7yKU3HaZerfCT//sx+UqDeDKDHM9iuz5xQ+Os3tT80gMJXZXJ1WzGiyaGqtARC5EKa6hODdO0MLUYwwUXTVVY0Zmkv7uD3zt7Na84ZyWXrGsno/sUZqap52fIz+UoVWtkdI+RA7sxbQ8jFOa88y4gEotTKc5x1VU/wjPr6KqMKkvMVkzuHszzwLEieybKyFJA1XKwXZ90RCOsysxUneZ+igHUa2VGjh5h39ER6g2LmK6xpjPBms4EZsPkumuuZvf13+esaIHfW9NGTG/uRSlLEqbrU7c9TMfH9gOiqsySTIRsTGe6YnNoqkpIVU4qgIqqEsfGJijWHbZt20YkHEKSJCSpGaZb4xq9bWle/KrL8YwEvhFHtqt8/D1/8rQNitAsjOnu7mbjxo1cfPHFbNmyhUQiwfT0NDt27OCOO+7gwIEDzMzM4DgO0PyQv//++0mn00+68vS+++7jr//6r/nsZz+L7/sEQcC//du/0dXVdcqt6f7rv/4LgI985CP85Cc/QZZlvvjFLwLw1a9+lde97nXYts3Y2BgPPfTQSbUX+/btI5FILKRgd+7cSTqdZv/+/fzHf/zHwrmNj4/zuc99DsuyCIKAjo6Ox3Vu4XCYV7/61aJX6umWy+W44447gObWMtu2bXtC84kN22Xv4SEa5SJrV60gmUwBkAipDOVqSPPtzSRJYrxoUrM86raHBKzvCtGbiaApFmNFk5rlUpo6RkVOACrdqTBRQ6GvJULCUPDNKrsfGuL855xLMQjTIWUZUFymZ/PsGi2w40CesKrQnoqghcL0ZZOs7ogxWTZRZJmh2WYfVFmGhusxnm8wU7Wo2x662lw2MldpdmgJGwqdiRAhTUY2oqx9zqXccfutKI08gR5l06UvY7IhUbddarZHNKTQsOD46Bhtus3W1X10ZuKkImqzYMYPODJT44HxIrmqTU+6ubC7LWbQkTQYnqtzPFcnojXTm4mQRkfC4OhsjZmKRTKskkmnUJcPEI1EcFCo2B7IzQ/qkqpy4XMvplys0NfTOZ8GbPb81DSJzrhB3fFxg4CJisWGuMHmvgSTJQtFloiE47zgspfysxtuplqa5Ts/+BH6K3+fH3zv25ScMOGWfi56/gWUXJ3JiTK61lzrqCrNvxnLbS5vaPaNlVAk8GslknHww624gczm3gQ96TCGqjBXsdEU6EhHCYIoS+IZnGiVarXB3rECtXKB+w/spuG4aPF2li5fhh6NsWH7eey5705KuXGu+q9v0P1n76JKiJG8yfJscylPw/aoOV5zXeJ8A/SWmEZEb86bEvjEIxHUUATLh4NHhxhoCaMSpz/q8r1r/4fGxCD9CZnzNyxH0xQCqXkRaDoe7fNLP5BcelJhYmGNYsMhFWnuW2kt2vwY5pcmDI+gKgob1q1F0zSOzFSZqdj0pSNo83tlHhqd5qc/+m/U6hSS7yG7db7w+c/y6c9+nvb2tt+4jvdMO5F2PZF6PVHtms/nOXr0KPV6nVgsRr1ep6WlZSEl+0TdeeedvOpVr+KTn/wk73vf+xaO9ba3vY23ve1tp3y8w4cPA81NpCcmJtB1HWV+E4IDBw7wzne+E4BDhw5Rq9VOWnNZrVZJJBKUSiWgmWqtVCrouk4ymeSnP/0pQRCQTCbRNI3bbruN9vZ2+vv7T+kcRWA8jXbt2sXIyAgAK1euPOVfzgmmabJz5y6shsfqNWtIxn91BeXNd62RaXZGaYk104xTJRNdBl1v9h1VJJmOZAhJCrh95zFuvuaHRDPtvP3/vYqetiSyJBMxZPL5Ap//p3+jMbqXv/vEx/GzK6g0HOY8n5wdhqhMV8ij2rBouA5UcqjMMlSPM+eF6GtN059pbqwb0WXGSw0qpkuh5hAPqWiKzHTZotSwqZouqgwbuhNYjs/IVI4H77uXAAkUlQC46b79nLV5I53pBDMVk5HZKvlCsbkrw5Iu1sQjnDOQxnJ8Ds/UaNgeqiJRtzxqjksggV2cJtrViqaECYKAg1PNfSUdP8Cslannp9jUv5JCzUGTpebODJrMbNVGwsf1fDZ3J4kYCtMlk/ZEkkh/G8cLdeaqNg3bpz2ukYxoNByfRFilYblUbA/T8dg3WaU9rtGXiTBbMVnd28rmt76UL37tP5i2Y1xx1a3IXpxkPMLvX3oBrekklueTiepkIhqFukNXsjkyPJavUTRdOhM6w3NVpqdn6UmH6OxoZ3DOYmtfglXtcY7la4wXTGq2S93xWd0RIxsxKJrNgp5IKERXa4p9dYuaGkOJJ8lkO8BxGZ2cw0VhxbqzGLtvmlylyp0Hx7BDWXwCkMJ4fnO+2g8gpMkMZCM4XsCqtiiyJLF3oszwXB3Tk+jsH2Bi9Di22eCmOx8kKa3jzmu+R7Fs0pnN8OlPfRw5kmJork42qmE6PrNVk7DaXDozUWoQ0lSSEY2K2VwfqkgSXakQsxWbuYqFKvmMHDtGoIZZu7ST7kwY2/WZrdokQyqKLDWraUsFvvONL5Mr1enLpvj4X36Qv/3clxgp2/zZ33yRd77zHSzvbqMrFcLxAoL5itfQ0zhYqqpKa2vrQpesXC7Hrl27MAxjYbu6J1rt+otf/ILXvOY1fPrTn+bd7373Ewqwn//85/nwhz/8sNslSeKSSy456TbDMBbmTx+t5eVid9xxB8lkEsuyuO222/j+979Pa2sroVCIH/zgB+zcuZPnPOc5p3zOYo7xNAiCgBtvvHFhQ9ILLrjgCXeayOfz7N69m7a2NqR0D2NFi7a4jio3r35nq81uMrbXXFifr9mMFU38oHmfIkls7kmyvDWKFwTk6jaKVeNf//FvGKspZNNJPvQX7yWTzpAv5PnHL3yJ2WKVvrDD5z73GX455lKab+U2Vmhg+wGG2hytbOxubp1kWyYjMwWGZiponomqamjhCMlYlEBpBuq9E2U0VSHwAnwJLNujbjd3bHj5pm4atTJfuepGKp6MHo6xZfVS9uzZTVmKYCiwZcNaTB/MSg1XkpCMKO3x5ga+5w6kaVgekiSRjjSbb++bLPHLI3niXoHbfnY1yUSCV73ucgaLAUtbI2zpTVOrFPn8F64kVzX58z96A5m+lcgE+EEzTbx/sorj+yxvjbKlL0mx4XJoukpEU1nZ3lwzt2eszP3HC7TGDTJRg2LdxnR8Gk4zldiVChEPafSmQ/g+uH7A1r4Uddvjzj1H+cGPfkSgRlDMEi98+R/S29mFoSuYloeiSs09GzWFbX1J5mo29w8XOTxbQcejXi7QnorR391BEMBooUF30mCsaDFabOD5oEgSTuDRnQyzoTvO+s4EI/k644XmnFvZdNkzOE7J12mJh+mIG2iyj+LZTBbrWNUygWvR3d1DPVDpSkdxAomE0QxUhqoQMxSeuzJLRFcIgoCHxkocnK6w81iJutPMEozlqhwdGsGtl1DNEmp1mkwywvve/kfEEkms+U2HLdfDD+BYvkE2quMFAYenm9XHKztiKJLE8tYoxbpLOqpRsxz2j+Y5Pj5BPJ5gaU87m3qTrG6P0XB87h0pULdcqrZHsVTm6h98l+LMOJnWdq78+HtoyWa5Y/8oX/va1yjMTNKSbeWVb3o7oUiUzHzj9LCu0J+JnFSh/XRVqVR44IEH6O3tXdierlKpLMxPnkq166233srrXvc6Pv/5z/OOd7zjKWuA8J3vfIc3vvGN5HI5vvnNb/KRj3yERqOBYRh85Stf4ZxzzmHr1q3kcjk2b95MPp9fKJ5ZunQp+XyeSqXC8PAw/f39J53Xr4czXW827IhEIuzevZu+vr7HdY5ijvEpVqvV+MlPfkKj0SAUCnHppZc+oaAYBAEjIyPs3LmT5cuXs3btWgayzWAwV7WZLJvMVC3SEY2V7XGWt0WZrVrsGMozUWwwU7EWunpMlBocK9SpWi5diRDnrunjX674HB3JMLPlBldc8QUGB49yxRVfYKZs0pYMc+UVnyWeapnfdFhGliQCJLJRnbrV3K29uUWTzFjFZ1lPB5tW9LNh9UqW9bQjBz6F2Wlmx45TmpvDdxxU38MHamZz6yPHC6jaPrcfnOArV11HOdCIaCrnbl6LFI6zdvNWFCNKQw7zwO4DVPJ5wpEQoXCU9pjGcwbShDWFQ1NV9k1VKM/vKnJoukJYV5sbL0sxwqk25mo23/7RteBZrGqLU6sU+cIVV5CfnSITj5Bq66QnZYAEqixjOgEV28VQFEBiNG8R1VSSoebC8brloSsKqzvjXLKqDYmAkVyN2Urzd9OwmnNuW3rTrGqP4fnNPqkV06XUcDg6McsNN96EatdRnAayU+OXv7iDvWM5pADak0ZzL0Q/YKzYYP9UlVzVYUNPgr64TCmfp68tzXM3LWNNRxxNlQlpCr/YM8yBiQKlhovtuWgKGIpMPKQwOJnnvod2c+5AmpCu4AXNXTRaW1sJG83OM8WGSzxisGGgk9X9nfQuGeDS7evoTyroVonjx8cYm5xmcq5I4NnkqhZTJauZOqU5CuhJh4kbWnNLrdZY829HVli5pBvVLDR7vkazXPSClxDoUXRVpiMRoiNhUDE9ovMde2q2hyxDbzpMIqxyZLrGWKHBjqECx4t1QqrMQCwgUh1nbV8r21f3saUvxYq26PyHZcBwrs49IwXmqjbTs3PkzYBI1wr+5I//hL7uDqbLFtF4gr9837tpa0lTKBYYn5pluuIQ0RTa480uQUdmquRr9mP8x555pVKJ+++/n/7+fpYtWzY/tyqRSCQeVu0qy/LDql0nJiYWdu+46aabeO1rX8uXvvSlpzQoAgsVp5/97Gd5zWteg+/7/MVf/AUAr3jFK/jBD36AoihkMhme85znUKvVFp67ZcsWyuUy0WiUrq4uvv71rwPNUfO3vvUtPvrRjxKLxTAMg2uuuYY//dM/5dJLL+Whhx6iq6vrcZ1fEAQilfpUGhwcZO/evQD09PSwZs2aJ3Qc13XZv38/pVKJbdu2kUw2tyYKaQpru+IU6y6W66Er8nw5v0zEV3A9n3RUoyNuYGgKYU2h1HBQZFjWGqM/EyaqK0iSRKStjSv//uP8+cc/w3TZ4jP/9DUA2hJhvvS3H6a9vZ3Jkkk6olK3febqzS2oCECRIaqr6IpCxTRx/WB+XZrMZMnE1yLE0zqpsMr6Vp19ozOURwocmKrh0CxCkWUFRVZIhzQmc0UalRLRVIhNZ51FezqO5XgMNWy6OjuYHBvGcy1CuoqvGti2R3equZxhrmqjyDCcq+P7AYmwxkzFoVBvriNsTcZ48Uteys//f/beO1yTurz/f02fZ55eTz/bK7sLLFWk2VARLIhdo9EES6JGNMXvV/NLotGoAfxGozGWoIIICCoKgkgXpC2wuyzby9nTn96nz/z+mMMRojG4i6nc18XFdZ3ZMzv7PDNzfz73/b5f7x/9gFb5MA//7AecWno1//Iv/0KlWqVYKPC+9/8RcizBcFojY6g8MtGk50akHFkUScdkql0HwpCMITOa1UnpEb90ddzglGVp2pbL3kqPMPRIqDKaItB3AzqWS1yTFxSrPh3bR/BMfvyD79NuNchmMpx5ziu47yfXMdes8sDDj7G2dBpxLU3fidijjZ5DpWOxcSRNZX4OtTvPCauHaboKe+a7DKS0qN/WnOGRLQ8ipQZZvmoVNgqWFDCUjtHt9rnr1p9gVQ8zFBdZMryagUSArkokdRnbDxYoRz6uH43Z+EGIKkscu2woMj6ebLB1soGBR7ffZ9/+Br4gkkvF2T8JyeVDKIpCMaGxYShJuWMTBJGFVnpA485bboMgRMBD7szwszvuYNXwaxnPRcKIYlJjKOMx17ZYmTeoapEh9kgmRkiAF4QUkiqFhEZMkdh5eI767CSDo+MYyQzAYrVkKKPz2GSL2aa5AE0wiacGePE5L8NIpSkVcqhS5NOpyxLpZI6LP/xhnjgwjZIbBSHa3QuCQEqXKXdtaj1nUYn9Xy0ajQaPPfYYK1as+I27on9ddn2q2vXSSy/l2muvZdmyZezZs4dPfvKTvPOd73zWUXmSJDE+Ps4ll1zCWWedxeDgIP/4j/9IMplk165dfPaznyWTyQBRGfaaa66hWCyyZcsWDMMgDEOWL19Os9nk9ttvJwxDXv7yl3PhhRfy9re/nW63yxVXXMF55523OKbyTIliQRAgiuJzpdRnI8Iw5J577qHRaABw0kknLX6xv230er3F/sDGjRt/I0j8qdHsu/xw6xzBwjD7k9F3fKo9m/OOGWBp4VfJOtu2b+f9H/kooShD4POFz32KYzdtBKIxjK1TLeKaRLPvsnOug+uHJDSJkYzBeDbGnnIHLww5biT695qeR9/2afRcBlIaI1mdu/fWmGr0uWVnBdfx0eUQ3wuJyTCYkvEEhbxoEsRS+Ch4IahSNE8Y2h1c20FTFdK5Ai3LQxTglKUZCkmdlumhS/DQ4RYrCnFCIXLgEIBaz2FFMc6m4RQ5yeKvPv4xpkwRAg/Bd8mXhnnzOy+i5SmossjyYhwROFDro8sSGSMSe/RsH8cLcP2Ak5dmWFaI03d8ym2LvhP1w7bOtBlYcAvp2y4hAvvKfUoplVxcxXZ9htI6E5UWWx74BWarTsaQeNWrXsNQPk1ecfj0l79NNTBIaQLPP/OFIGuIgoAb+BQTGitjfdrNBmvXrEHVDaabFgghq4rxaGFg9fjcN66l7iooqTwb168jk4iR0wJuue0uzMYcJT3gS3/5QfpygtmmxWBK52Cty43b5/ECSKgSxWRkI2V7PqsHEqwfShFXZSYbfR6bbOH4UQ9oSTaGIXrY/Q6C3WFAsUmn04vA7Mke7JjusH+uwe233ESnWSOZyfHmV76EG67+NtNBmgHV4S8++F5y2UjZaLoeT8y2KSV1EpqMpkQLk0NVk4Qe7dgB5ufn2LZvkpmOx/M3LmflyMDi/T7V7KNKIlPlBjPlCutWrqDet6n1ohGRFcU4xbjGycuyC4ACO9oZEtmvHaxGNKpiUsP1AoIwJCQawTlpafa3ep7/I+LJnuLq1asZHR094vP4vs8ll1zC3/7t37J69Wr27t3L2NgY55xzDu9+97s57rjjnrVr7na7LFu2bHHM48kB/yf/v2bNGnbt2sXMzAwjIyOLPwdYsWIFMzMzmKb5tJ//pnj729/O5Zdf/u/+Od/3kSTpuR3j0YbjOPz0pz9d/EBPP/30Z5zM/nWUy2V27NjB6OgoK1aseEbyascLCAnxg4CEJtE0XTwvRJaFheM+siBgaL/6VZfLZT7zd3+H6PYXf/bZz/zd4pBzxpDJGir1nkMpqZPWFXbOd2lbLkEQ0DAdlhejXlvP9ohrMvt37WJgaAhDixNTJfaWe0w1LGZaDroIXhhgxGLYbkAQBjgBNHomcsxnUO3hSjHSyRgdJ6DcazOSUhhaNkxMi4DnkgSEAqIUOTTkDJVG32Uko+MFIbNti7QmEwgC6ZjC0pyB5fnkSwX+8i8+zHv+/K/x4iUCI8ZxL7mQR+ZcHN9mVTHOgXKf2bZJx3LJx3UqHZvRjM5gMTJcnmxYTDdNphomtZ5Lx/LQFYmW6TBR6dNdKAMeblhYjk/H8bHrHh3bJxeTMRSJeNDHqU8Tyw6x+fmnE0gqfddHEnXOfeUF3HDjjfRabcxeh/XLM5GytGsxMT2Hkgo44/hj0DR98WWQ1CJT6TAUGMjneOMFr+Sq7/+YRq/Fjh3bOe6YtTx0zxZ6lkUuHuPP3vs2xkcGo5Ju32WubdHseSRjCvWuSyiA5UUjEoVE1MNtWR5BEJXUE7qMLAgMZ3VGMjF0WWKmlWJ5wWAkKS26vRw8NMF0D/a14acP7cQM4ySLCV52zllkSnle/paLuPr7N1ItT3DpJZdw8Yc/HCXHUGBpPsHGkSfpRBF7drppMZTSUCWB2vwcc3NzBCHcce8D7LrvZv70Qx9E0pNMNU2mGn1m6h0euec22n2TlCqwatUqhtIhbdNDQEBXomcrYyhM1vsLIPMo6bZMB0WSqHQsdFVCBGZaNgk9GiV50uj4v0JUKhW2b9/O2rVrn3Gp8N+KH/3oR3zuc5/jiiuu4PWvfz39fp+77rqLW2+99ddaWh1NJBKJRXu93xTDw8PPKPE92/HcjvEoolKpcN999wGQzWY58cQTj+g8T0W7HXPMMc9onsp0fSYbfapdlzCEuCpR7ljU+y6mExIu4L07lsf6oQQvWlMgRKBje/hBSK9Z56N/9uFFC6WPfvSjfPrTn/4VS6We7XGg1qPedfEXiDMxRSIfV8kYCumYwmTd5ECtz65du7niyivIpDNc/Ed/iBpPIyCwt9zhkUNVfvHoNkxi5AsDaFqEFotrMpIEyzIxCkZAvdWn0THpuz59XyaXirN+JMvygSQCIQdqPaYbNiMZjaF0jHxcZX+1TyYmo4gCB+t9EqqEIkel5Qg4HhIL+3zhEx9lenYOO7MUNzVCPJnm+We9kLWjeWo9h0bfIyYLbJ/toIoiyZhMQpVZUTCYapq0TA9BhMjjT2LTSApZEnjwYJ2ppkVKl5ElOFQ3MZ1IRCIviDeSmsQxw2lOXpqlfHgPdTGLI6ooooAXsoDIAzmwma02WD46Qsv2MB0Heg0UWaZYKrFuKEPP9jhc72P7Eb4vqSvMNi00RUQSBfbN1Ljp1ttphzEEQgTPIiM7/Ok7Xsvz140vem62LZepRp/7D7ZQJQFVEelYXmTtldRw3YCxfIxGz6FnRyKaRt9FV0RWliIhTMv0kCTYNJJahL0DzLdMHtg3z7bt27nhtl9AZojhFWvIJhOsLCVJxA1wLG684Xq6tVne/fa3snL1WkzXZ0k+xqpSgsP1PvsrfRzf51DNxPUD/F6duN/l2GPWsXeuxVe/ewPO5FYK+QLnvfUitFiCZrvFtTfehlWfRc8Pc/45L2T1cJ4QKLcthjI6x49msDyfStdhpmFS6zkkdYWBlMZsy2KmtZCIZSkaE1Il4prExuEUS/K/W+uoZxrlcpnt27dzzDHHPOM5vV8XYRhy3XXX8d73vpdvf/vbXHDBBc/iVf73iudKqUcZjzzyCJOTkwCsW7fuiEsYjuOwfft2bNtm06ZNJBKJf/d3XD9gx2yHSscmrUcqzI7tLgxGg+OFeEHEnywldE5amkYSRfZVejRNh3q9yTe+/nUalRmGMgaf+P8+zsrxIZq16q/1GwzDkK7tU+051Ls2pruA/EqojOdiqJJI03TZNznHp//uM1RnpxgolXjjH/05a0ZLPLp/lm9c+yNqfgwxXaJYGqCQiiEIIiKQjSvkDQXL92m0epTrHWRNQ5cEBnWP0PdAUckk4mwaLzBcSEZiloUemCQKVLo2lhtQ6zrk4gotM/I7XDOQ4MBMhSu+fAmNw7sZHB7h/Hd+iKu+8x3m+wHpTJa3v/kNzPcF9lS6KJJE1/LQFDEq51o+tudTSKgLJdSoxDjdMDl2NIVdn2XeNai50YiI4/k4QYiAgOU4xEWfZCqBKokMp2KcvaZAMaFy/8EGowuK1X3VHpbrI4oC9Y7NvkoPNwiIySJut00hrTFULNB1fFILCLVW36OY0Fg7lKCU0HhwosFs0yK90BOeL1d54Od3IrpdJLPF31x8EScdewzOAppOU8RIwYvAI4dbuH5AOhYltpCQRs9h20yH0YxOPq7Ssz0kUWQ8H8N0fJr9CLae0mWWLAzdPzWemOuwZ65L2/I4dGgCQU8w0bTpmA6DiseqLJSyCeZ7AZJnctyxm1BEkcGUylBGx/FCHplsIgsiSV3mcL3HwzsP0LMcTl2/nOFcktm2zXytwY1XfpVys0N8cDmvfvmL+P5PbqPdbpFOpXjpK84nFosT1xTalktClzhrZQ7bC5lsmthOQKPv0bRsXD9k00iakYzG1qk2sigShpAyJEqJCEqe0GSOG0sf0bP+bMbc3Bw7duxg48aNR4WwC8OQq6++mg984AN85zvf4ZWvfOWzeJX//eLJcu5zifG3jDAM+elPf7pIoz/rrLOOuHTabrfZunUrqVSKY445Bll+ZpXtSsdm23SbYkJ7GtB5pmUuONNL9F2fTCxSBmqyyPbpNo2+Sz6u8ui2x/ny1T/GyBR5+wXnMjaYJx9XWTOQoNus8aEPfYj5cplPfuITrDv2hEUXhUPVPp4fktDlBYcFj6GMyvrBFB3bi9Sy8xU+//d/R7lcJjW6hove+jq++u1rmLMktPwwQ2s3Y/kChYSKJMGqQoK25WG6HtVGK3LGSKdpWCFDaY2Tl2bIaCLNVovJaps8PZZlIsWaFM+hJ5LIskytazPTipKKLIkUExF+rN1q8sUvfYXOxOOMFjN8+rOXcNhUsHptLvnSN6gtfCYnvfQCDjZ8MnEFRRRIGwq+D7vnO1iuz/OWZxlIxZhtW9iuzxOzHQSnx4Gtv0BJFli/aRMeCm3LxwsCVAIOHJ4i7FU5bsM69ESWgaTOknzkSdgyXY4fS1Htusy2bPIJBdcP2THb5lC1jxB6pIIehWwKIZag1XcxFJkXriswUTMXHSXaZlTO7TsejhcwmNaYqzW46oaf0W9VkXsVCDwK2QznvuFd6IZBxlBI6TLFpMbqgQSVjs3u+R45Q0FXJGzP5+GJJpIgctKyDNKC+KLajQym15SixZumiMRV+Wn3IEQD+j/fV+OBQw0UUaCU0mn1Hdq2T9/2I7VqVmKu3mL/fJMMNmsGdJYOFigVC2SzWep9j63TbYZSOr7vsXP3Hio9FyUzRCCIbBhKMZiO/Cu3HpjjK1dcS90WkDwLwW5SSqi8+s3voo9KXJXIxxUUWWTDcIpMTOHRyRaOFzLdNDFUiZgqUe06BGHI0lwMP4TBlIYggBSVCah0bEpJjfXDRw/RPpqYmZlh165dbNq0iUKhcMTnCcOQK6+8kosvvphrrrmGc88991m8yv/e8VyP8beIbrfLbbfdBkTooOc///lHrNianp5m165drFix4ldmcf69MN1I/PCvX0j6wu5p7eDTH9xq16FhuhQT0YOeGV7Gea94BflcjkwmTSmhMd+10Osi6wYjkPLufQdIjq/n0ckWXhBS7li4Xsixo+lFBJcsCsw0bRShQ6UXYcEULcmb3vMRLv/6V6g26nzm818E3yMxvpGhYzbjI2OI0VpsMKmzohhn61STcrWOG8C6sRJuKOLjkIkpNPoeeSPOMctGGR5wkYSQouaxa7LM4QP7afUcAkVH0eKMFdOsHYjjeCGKFCWLqZk5OnMHGClmuOyyyygUi9Sm2nhBkve/+/e57GvfpdFpRogpIYHp+KiGQhiCT0AiJqNLApoiE4Yw17Ki0qLjo4sqekyn7Qls27GHF520geF0nHK7x9Yde/Fsm6QsUsymqNvRLq3R9zBdH88P2THdxfR80guzlz3Hw/YC4qLHXKNDfjBLLJGiY/s4boChhMy3bCodG00WSWgSjh/QsTwG0xpd26fb6XDd9T/EajbIpjO88U3v4oof38G0JXDND3/Ea195Lo6XwPECar0IHXbMcDLypKxHjNNK16bec1g/mKTRdSLnENunYTrs2jfB4eWDLBkqkI9HvpUhYKgy8+UyBw5NMLJqPVNNk5mmRSamYHkmhFGlQ1dETM/ncFdA0tLkB+LkYhK+7NHo96nt3InjOIhGmoobI0aaiUOH0FSNMzcfQ63vIQgCm5ekiasyHctlKpfh9LNfyA9vu4/QdxCBd771TYwvHWBvuUsxobGiGCefiODxlU7EtG2bHooclbohakd4frjokdkyPXILZeee4+GHUEz+56pSJycn2bt3L8cdd9xvjWJ7aoRhyDe/+U3+/M//nOuuu46XvvSlz+JV/veP53aMzzD27NnDzp07AViyZAmrV68+ovMEQcCuXbsol8ts3Ljxt2amAsy2LB6f6VA7vJeR0RFy2RxBGDLVMFlWMFg7mKRcLi+ars61oz8/lNLp2R675rvRS9ULEYToxVjtOsy3bUYyOqmYTNv06DuRGlKVRR6dbNHsO6wsJRhKa1Q6NuWOw8FajyAIGc3GWDMQwaUBHnx8D1/9539CQMCN5Tn2BefhKwZ9xyepSaR1hYyhkFRg9+FZFFUlmUqzJB/HciO3BUWKepnFZOTBuGOmvUhamWxY5AwFz3VodLr0uj1aXZNSQmL1YJoVI0Wy2SzZuMbjj21h2bJliyWnateJFLZewFy1zo7DZfR0kemWRddyURUZTZaQRbCcAMv1WDuQQFMlds/36NoeHdtDl0SSasgT27di+iKZsMfZp53MrQ9up+cGqDGDzRvWkUvFSWkSawYTHKhE86QATdPD8XzGsgarBxLMtS0Oz1To9fro6QzD2SSyJCKJcKjaxw9DjhlK0bZdyh2H4ZSG8BTiUavd4fvXX0Or3SeX0HjFBW+gmEszWW7wg1vvwakcIpXJc+JZ56BpMQoJBV2VeNn6EsNpnS2Hm0zWTRRF5HC1T9108fyQQlylYbrsOTzHrq2PMuDP8pa3v5MDLQHL83H8AMsy2f6Lu7Aa87zo3Fdy6saV7J7vRmVpWaRpeliuT0oX6TnROYfTMWRZYFUpStQxReK4sSS2aTI1V+HWHbNM13vosshwMcNoKYuoGqwbivp8QRjy+HSbvdNlvvWVf2TeDPCUJIgSeR0uesfbGBsscMxwkrj6yz1As+/y8OEGs61onMQNwkXVcSmpLVYbmqZH13YJw0isM5rRWZI3EJ/l8YVnGhMTExw4cIDjjz/+iFXvECXFr3/963zsYx/jBz/4AS984QufvYv8HxLPDfj/OxGGIXfeeediUjzppJOOOClalsVDDz1Ep9PhlFNOOaKkCNFg/fTBvXzhG9/m7y+5lH3T82w53IyIJk2bR/Yc5gMX/yn/5+N/yQMPPICuRDvJJ9mSYRjJoy3PJ65JdK3IVaLcsfCCgNmWtSjLf9KY1lAjiHStGxnSHqyaTDf6lNsOM22bg7U+26ZbzLYt6o06P7jmOwhhiGjWCSSFXdsfZWNJ5fjRFIooMtO22DrZ4ME9M6QScVaNDTKWTzCYji2wWxVM18cPo9X74brJbDsqOWqyQFyVmG1bTHc8lg0X2bRmGStXLGNsZIS+LzI7eYhdj/yCXY9vZXBwkHg8vqhuKyy42A+mdVaMlLjg+Rt42foBTlmaIRNXiSsCugySAAk9cgip9qOSpyKLaJLASFpn02iKNcM53v+as8gGbfqtMj/54TW41QlSosX6NatJx2MkNZlMXGV/pR8RgESBY4ZS0ZykJPD4bIdD1R5+u0KcPrlSkaQRYywbY1nBQEAgAPJxlXRMYTQbo5RQmaibdGwHWRKodGz8bpVOp0smleDVr3sT+UwK1w8pZdKccuqpJDJFWnZAaHaIqRIpXcFxfbZOt9hX6dOxfIpJlWYvcqN4YrbD/nKXJ+Y7TLdMFD2GkswwHyb552t+wv75JpWOTavb4/6tO2kQR82PkkqnafY9luRipGMKuiKjyAKqLFDve9R6LjMti93lDrokkNRk0jGZruPSdwLi8TimZNA1bRKpFEZugENtn7sfn+Tg7seZ2fc4Bw8eZLbS4MBMhW/98z9Sq5YZMETe85bXkDF06j2Pb3/lCxQk62lJESAVkyklVZp9hz2VHvNti2rHZr7jUO06OH7ASCbG8WMp/PIBhjSH48fSLCvEn5YUy+UyDzzwwBE9w79tHDx4kIMHD7J58+ajTor/9E//xMc//nFuuOGG3zopttttXvva1/7KXKBt27z73e+mUCiQz+f5oz/6o0WY+bNx/D86nkuMvyGedMVotVrIssxZZ511xDdlvV7n/vvvJ5lMcuKJJx4xIg6iQf/TNyylkNCZN+Gyb/2QRrPNioJBo9ngz/7fFRzwc8SXbERID6HLAoMLBJy2HRkETzUsVEmkkNCodG0afY+xnEEhoZGJqUiSQK3nMNnosWuuQ7XrUO7aTNT6VBYGt2t9l6GMxlg2hi5HUOe9MzX+/rJ/oFqvk8/n+D//52Nk4xpObYaf/uBafNcmE1fRQhfZNVk9kmfzymGGMjEMWaJjeciSEPV9lMg+y/Z9yl0LrzlDLDAJwshlQhIF3CCk0XfZM1Xj0X2T1FwJL5Zl1YbjOe200ygWi9RqNe6//37uvfdedu3aRbVaJaVJrB9Ksnk8RdpQsfwAL4j6ST0noG35uAEkdZnl+RgjaY1SIupXLSkYnLEqz3FjGUpJjeFijje//AykbhUkiVCUOO3kk1lSSqFIAklNIqnKNHo2oigiilGiG8vFOGVZjowuMj0zixS6rFyxgsG0QTGhUu057Ct36TkeywoGx4+lMF2fruURUyUysagEO5BUySUUSqPLOOuc89l09itA0RlI6SiiSChAJhHneS94Maef/nzGx8cIw5DDTRPTDdg73+O+A3V2zLTZOhX91zZdepZHpRu5hDS7DoV0nBedeixKZoRmqLFr5w4cs8vj27bhtyrEVZnVm09DiyUIwhBdkVkzkCCfUHC8EEMRGc7EyBoKcV1eRL+1TJcgiHi/oiBweK7KPVueYMOSEi8/aTUnrxrkxccu45SNqzjtxOMYGxmm1Wpx5113849f/jLVSplcLscHP/B+nrdxDX/2h29kQPdoTu7i43/xEcrl8tOeH1EQWFFIkI4puH6A5QZoisRoRo+Ur0GAoYo8tuVhPveJj/Ppj/8Z/Vb9aecol8t86EMf4v9+7GO/0+T4pGJ9YmKCE044YRH2caTn+sIXvsAnPvEJbrzxRs4+++zf6vd37NjBKaec8msRch/96EfZuXMnW7du5fHHH2f37t187GMfe9aO/0fHc6XUfyPm5uaedsMPDw8vrmaeqUgGoptxYmKC/fv3s2bNmqMawP3XMT07x7s/finVTp9SXOYtb30bX7/2Rup9h3Qiwbve/BqSyTQDKQVVlthf7lHruQtGsjCSjpHSZHbMdYirEusGUyR1GdcPeGK2zYFan7SmkEuoqBIcqJlU2g7pmIQsRolpPG9EZrJ9FyGwufOWG+nOT5AuDvGHv/dm0uk0h+ZrXH3t92l2u8Tywxx/zDH0fVgxWuLsNUO0HJeEIlPt2cw0bUwnEpSM5XSG0wbDaZUb73mUb33rGxRTcX7/vR+k6ip0LJfZloUYuNxz9130TYvzX/A8koVhjhtLcfLSLHFNRhQEfN+nXq9TrVapVqs4jkMul8NVU1Q9nWI6zkzL5MFDTUIC8obKWC6i+eyv9CgmVUYzBrbnM9uySekKshTtoJXA4vuXf5lyeR4/OYQQeuSTcV77lndwuBMZESuSyEzDouv6ZGIqhYRCxlCZrnW4f88M2ZjMGRuWsH4oRTGpLTJvdVkiFZOpdx0G0xo9J6DvROSjiZqFJMKSvMGBSo9G30WTRTqWiyZLrB1M4vkBh+p9ikmN6UaUCAUBuo5PQhFZUUpGIHoRHptsASGeH/WPKwu4N00CWRYZSunENZlys8vOPXtx+13EMKIhJXWRTSeeCqLCSCbGSDpGMiaxeiDBTMvikYkW+biCKAnYrk/T9DAUkVrPZe1gklJSZSCpUVIs7n1kB25qiI3Lnv6stEwXWRI4aUkGQRC4+75f8H8v/TqJRIILzn85kigSjycItAQpTeSKL3yKSrnM337yk7/ixdexPLYcbmK7vzTS1mSRlC6jqyInL83Sa9Z/rUr7yaT4r3/+bEcYhuzdu5fZ2VlOOOGEZ6RY/03nuuyyy7j00ku56aabOPXUU3/rc3zxi19kyZIlJJNJ3vGOdywaJARBQCaT4eabb+a0004DIgOFM844g0ajgSAIR3X8SeeN/8h4LjH+mnjooYeYmZkBYP369RiGQaVSoVqt0u/3yWazFItFCoXCbyTVe57Hjh07aLfbbNq06ahWe78ubM/nxw8f5Kv/8k3qnR6BYhCICllD4YSzXs7SwQy6LDLXdFhRirGikCAkYKZpU+3ZpGIKaV1mpmWjyAJ5QyOhyaR0mUO1Hj/bU2VJJrKsshcIIEIY9cayhhztRGKRlH9fpcfc3DwP3HcPSUPjlee+jHVjRVp9l+mWhRpYfPume+gLOsOlAfLFIsctyfCCVQU6ts9IRiMbU3livsNc00JVJIZSGmsG4mQNlbsfn+Bz//BlmvOT5AslXvuO9zJvi+yYrLP78cdw2jXSusSrzz8PSY0RAssKBkPpaBC9kFDoORHj1VBFbNNkvlzhF/vKNNod8gmdrhBnVxNG8lGyGM8ZSKJAuW0zmNLIGApxTaLRd5lv29T7LoJrcuc1X6M5tY/UkvW87c1v5KpvX06lWiU9uJSNL3kdgaSgyxJtK/q9UkolH9fwXJddh6uEisyxS4rEVJlMTGHzeJowhIe27mBwYIDBYo6W5WEoMtkFMcjD+2bYemiec09ehypFnpAs8mthX7VPy3RZN5gga6iIosBUvc+u+S6qLEIIgxmdYlzD8gKyhsy9+6ocqplkDYVCQmeyaTLT6KMpMposkotHMAHb9am2ukzt341sNwkljeedciJ6IoUsiqweSNA2XQbTOoNJHcv1qfXtBWpStFCZbdk0TAfL8ckaCicvyzIk95k8sJfh5WuZtqNE+dTSZa3nkIrJHDf6y+fox3fch2MUyWWziKFPud7E7HXJBG38fgvTsjjj9NNRE2lCUSGpyxiqTNf22DLRJKkrqLKA50eLA9eLjJFPGM9gqNKvJMF/a9732Y4wDNm9ezeVSoUTTjjht3LE+HXn+uxnP8sXvvAFbrnlFk466aSjurY777zzaYlxz549rFu3DtM0FxX6T4K7H3zwQTRNO6rjGzduPKrrPZJ4TpX6lAjDkJtvvhnHcRAEgTPPPHPxi8pms6xevZp+v0+1WqVSqbBnzx4Mw6BQKFAsFkmn04u0mqei3U455ZQjHun4TWG5Pt1Q5eQXvoKbb/geoWIQKHGWHn8CcUMnZyhYTsBsx2Qgo6ApIrMth9mWTdN0EYSo71jt2nhBSN8KkCUBXRaZ79iIIYuuB0PpGKNZHVWCnbM9JFGg6/h4aoBAVKpdUVxOISYwWMhz0pphYrJEKelj+wFbD7UZGFuK5QkMD5bQFZG+7bO/2icXV1CkaIfiegFL83FkUaBte+yc67FhWGTD8mEuuugi/vmf/5lqZY5rvvV1XvjKC9m39QEs0yQd03jVeS9D0qKkGAKiEDE/H55oLPZZQ0JSusKSnMHY+BLmwjSrhADH7HFwtobXa7G31cAVZZx+ksFcmlJKZzSnU0xozDQtFEmklFRJiQ7f+dIXaE3upTS6nAve8QesHh/g4g9/mEsvuYSZTo/bH9zK2nXrWD+cwfGiAfpq1yEX69HoWMRjKptGc6wZTKJJIrvLPW59oozQKXPd968nlUxz4etfz0A+iywGzLRMqvUGl197A1ZthhMHZJLDy1FFEVUW2FvpktAUErqM4/n4XgThLiU1CnEVywup96LS+XTDotV32TiSQpclglCM4O4dB8uLeruKJAEBkhixdw1FotyyKU8fIgxdwiAgFH0e3LGPTevXsnYoRympMZrRGUrrGKpEOiZzuG5x3/46CVVGVURG0hohIfG0TjYmk3AaTE9Ncfzxx2Mk07SnWtS6DllDQRSjGdF6zyGhScy0IrVrz/EYX30Mcy2bRt8hocmsXzbMcEonHZNpt9tMzVW4Zeske8q7sAWZVDzOpvEs52wcJWso1HouxYSKIokEYUjTdBhMacQWyDilUqTSfjI5vv8DHwD4nSfFJ554gkajcdRtlzAM+dSnPsVXvvIVbr31Vk444YRn8UqjqNVqJBKJp73jBEEgl8sxPz9PPB4/quPPJcb/xGi329xxxx0AxONxnve85/3aEQrDMBgfH2d8fBzP86jValSrVbZu3UoYhhQKBVRVZXp6mrGxsWeMdjuSqPVcbLPHvffcAWEAbp9QTbFt936WlZIYqoTthuiSSLXjsuVwk72V3sJcWshU0yerR8DxnBoljrbls32mTSmpsmogTiam0ncil4akJtN3fJYWYsRUmV1zbQ7VInf3nKEynNYoHrcGTZaIyVH5Q5Ml0vSZLDfIZbOk4wZxXY52cJbPnvkOJy/LIgki853IasjxQzq2hwg0eg4zLZOhVIylQ0Xe8c4/4Bv/8i/UK7Nc/0+fIZAUSqNrecvr3kQsnqDRc0nFJPpuSFyTSWgSu+Y7iMDx4xlkUaDZj+yjNg4nEQU43LBJaDEKg8MsDZPMNPp0TZNWu0vYrdE3VEphgWx6iOJIEmtBzr9r2yEas4fIj6/hze+7mFlLZvt0m9GMwQc/9CH+5p++S81xCSyTIMjg+DCajTHb7IDtkk3GyKcMxnNxtIXPSxZgf6PPWDJNMpOn2Wxy9XU/4OWvOI+XHjdOaHb40te+gNkXKCVkxkZHaEbTO/Qcn/mWTZCK3Oo7VkBTc9g23WHNQMBsy2Y8p7OyaLBtuk1IiCpKC/eSgyhAMaGiKhKuF0EcElrki5nQZFYUDTzL4sHbbidsVimm86x5/lk89vgO+t0m+x67jxesOJcVBYORbIxM7Je9KEOVOFDtMd20SMcUBGAkrZOMyXSqc7RaddZtPI7bt+wkkR8ELc5M06Lv+iAIBH6A5NtMT+xn9erVkYo0CMnoCik9AumHQkjOUBbJPvFkksq8S0OFeCENlkW5a/H9hyfZunuCM5ensJUk3X6cWEwnBLKxyDfzqc9+qVTiox/96GJShKgn9rtIikEQLFaZTjzxRHT9yK2ugiDgb/7mb7j88su57bbbOPbYY5/FK/1l/FujZmEYIsvyUR//z4jnEiORU/SuXbsAWLp0KatWrXpGvyfLMgMDAwwMDBCGIa1Wiz179jA3NwdAs9nk8OHDFAoF4vH4Ec88PjXcBQ89PwjZcXCOG77zDXqtHpniMCed/SJufXAXttnj9ltuYvwNF9DwIlJKuWMz07JomdHMW0wWCQKY71oszRkkNJnxrMGheo+2qSB350nHS9ieRCamRmXAjo0oCOQlE3tuhlds3MxcyyIgJKXJZAyVw/VIqWq6PooEU4cnOThdJZfLsG44Q0KTqfccGj0fy/VwAxhMRiMhQRBS6TrMtW08P9r32X7AXMtkMK3RNAMEUeflr3o1V/3TJchWEy9e5LQXvIyWr9BuR0P+ubgcWR/pMq1+hDgzNAmByFKqkFCZbVvsKXep9x2mmxaiaNOxPOY7FpIosWwgRzqm0jJt0rEA17X5+cNbiUkhpUKeQqHA5uOP56KP/CU9NY8WS5ETHCo9l37ZZ1k+zukvfjmH5ptsWD5C1/JwfB89MMmIHhuXD9FyI+Wr9xQb+pbl4fohxWyKt7/pdVx5xRXUa7P86OZbKSpn8tPLL6MxO8fAsmN513v+iFw2R9iLqgB7ZtrMd6Ih/LSuYKjRQudwo0mzH30nxaTGSFpn83iGA5U+Hdvj8ek2hAKDaY24JtEyPUJFpNHzSOgSo9moWqAFDlf/4Dv0m03GEgpf+L/vwNVS7D52kC//4z/QOHiIm/75Uc655HNkYqmn3bcJTeEFqws8fLhJ23KJKzKyCPPTk2SFPhs2b+bGXzzO1755BZlUknMu/D1sQY1AEILA3pk2D/30OvrlQ7zn3e/GTI4QhrAka6DKER2n0XeYrFsUEpFfabPvcaDaww+iF+xoMcOSAYFqx6ZnOvQlmSIdpmam6IoKsUQGKZ1iRhUopSOik+MHNOs1Pvl3n8XX0wRyDAKPv/nsZXzhc596RvjGZxpBELB9+3b6/T4nnnjiMzLq/U3n+vjHP85VV13F7bffzoYNG5616/zXUSwW6Xa7OI6zuOsLgoBGo8HAwACqqh7V8f+M+F+dGJ8cxXgSkHvqqaeSTB4Z1cJ1Xfbv34/neZx22mlIkrTYl9y/fz+api32JbPZ7L+5i3T8IPL0a0VGs0NpjeGMHj3opsu+co+W6dJstvinb11Ns+czkpT543e/hVg8SSYe5/rbfkGr4fHN717Hi152HildWgBVi2R0ia7l4qsyS3Mxppo2Xdsla0T9F12W6NbL3Pjj71E0RF73++/BdMVFLzo9sPiHy79Ks1bmoovezYo16xCAmCwRBiEdy2fnXJe4AuX5WTzPxcgO4871qXWjUliU3G16tk9MlejbHsECdq7Rd4lrEroR7WR2z7bZU+lSiGuIokCr0+fhRx7DHjgOrz2JKMr84rYf89o3vIVA0QkJ6FoemZiKKkm4voMfgCJJTwMiCMD+Sp+RjM6JSzPMNC2aC+W4pfkYoxkD14+EKr0wxE/lMDIjqKGNKFgcmJjkpw8+wb6eSizexQwEDF0noUvYjs+Beo9sKoGsRtzP+VafZr2GKvkMDhRYNphipumwr9KlkAwIgpDuwuegSNGcpyJrvOWtb+WKK66g1m7y5a9+A706y8jQEB/7+IepeTpzbQtBCKl1LQ43o3GbjuXRtVwyMQVJEiJogSSiKRKyKDDdshjN6iBEC5G26aDJEmtSCTaOpJht2jT6LoW4iyCEDKRirB1IcnDvLtqNKvlsjk999P0ksgX2lfuoRoq3/+H7ufzr/8zM3CEOHDz4a19oxaTGGSvzlDs2rb7D4QN7GVQ9zjzlZA63XNRUnkw6Rbnn8f0bf8JbX3MusqjT6XR44LYf0eo7DORLFAeGmbVEbC+k53iocvQyTSwQhSJ0m4jl+nQsDy8IiWu//P7jqozjBfh6mjWrVrBRgof3zTExX2f2wCSPPLEfT9HJp1LEVYFvfecaamGJ3OgS3vK6V3P1td9jql7jfX/2l3z5c594VnaOvu+zbds2bNvmhBNOOKrWSxAEfPSjH+X666/njjvuOGL7u2cay5cvJ5fLsWXLFp73vOcBkXgGYNmyZWiadlTH/zPif21idByHW265hSAIkGWZs88++4h3dK1Wi23btpFKpTj22GMXt/9jY2OMjY0tKiIrlQo7duzA8zzy+fxionzyIXD9gG3TLR462KS1wKI0VJFjR9OctDTL3vkeHTtiZFYPV+jVZokPLOfNbzqfoWIBy/VJJpOcdOKJPHb/PXTaNerNJiPDw1he9MLsBSGyKGIs4rwcmqbHptGo/CSLAkYiTS6hUy3P8N3Lv8rv/8G7iWsSrtXj+qsup9ZoERs5htkwxajrY6gyByo9HptsoSkiuuizff8kPVcilsqyTJJZMxCn3LW5a2+NyLUoxHQC8oLIlsk2mbiKIETKw3RMIQwC5jsOu8s9Zpo2YSgQl30efOwxbMdDz5R4yUtewM/vvY/mzC5+fMVXePcfv5+MkeZAtc+BSpdq16bedyi3bZbk9QW/wYXvzIySUDqmIAoCe3bvIiVnWF5II4sCo5kY8x2LEHAtk/mJWY7buIGZVkDDlzGyaWqdBl2zTcL36FVmaPgg6QbjhTSZdIqRnMEvDjSYqnWpzs8QhCKhkWMwFWMsZ5DRFWrdqD8WBCGqLLI0b2CoNm3TIxmT0WIJzjznFVz//e8juH0CNcGb3vsRPCVJXhPwgoCZloUmiYxkdeY69oLKVGCyZSERjba0LJeYKmE5Pl3bo9GLYODL8jF0JRGxWhHpWT7HjaWo9Vx2z3XIJ1Ty8WimdHT5an7/HW/nmOVjDJUK7C336JoemiIxUMjyrj+8iJnZOVYcc/y/+awkNBlNDKke2MFIQuTYY09ClmV2zdXp+CovvfBtXHvjbbQtm+9c92NecNaZ3HHnnXRbTVKZPO98++vI57NU5jqLoPYnw/NDJFFYFOzEFBFFErFdh6QeLbQcL/q8mqbL/Qcb2F64oMRW2bx2BZIoMFFusfVwhb1TVR76+a20ghhyaYzNp2xkcGiYP//Au/n7z3+R2XqDD1z8p/zDpZ87quTo+z6PPfYYvu9zwgkn/NpxiGcaQRDwkY98hJtuuok77rjjiGeuf5sQBIH3ve99/Pmf/zlXXXUVkiTxp3/6p7ztbW9bLAUf7fH/6PhfqUqdnp7m4YcfBqIywNH4jP22aLcwDOl0OosCnk6nQyqVIp/PU/ENfrCjRtt0ScZUDFVCCEEQBU5fmSMIoPQUpd62x7fTU3LIusFwRmeyYWK7AYNJjWqrxd7JMn0lw0hGJxNXqXZtMrpC3/Fp2z6jaY3Ztk3OUDhmOIUsifRsj7bpYPV7fPea79HsmRiZEsedeBK7fv4TuuVJUqUhXn7h20jEkwymNJbkI1ume/bVMXCZL88TaHEsIUZSk1haSFBKKmyfanPvgTqSGJW+coYcAaodn+NGM6wciPP4TAdZhGY/mqE7XO/TsnyyasiOnbtx+i3iqsyajZtZP5rDdyxuv/F6ujN7yBcHOe9N72Rb2aPneOQTGklNQkCgkFI5biiNpkZ8US8IcIOA8azBEzt28MV/+mdigyt45WsuoJBJs2Ygwe75LvP1Jjf+4DqsuX287z3vQS0t5VC9z3guxmzTotZzsN2AmCLiei6dnklg90nJPmtLMQTFYPdsM8LWxTMoksjawSQ5Q8ULQ3KGjCpLmAuA8Iyh8vhMm6mmiShAr9vj+mu/S7NZR7Z7hLJCPpPhondfRCyepJjUIuD3VBtJEpis9+k6fmSM7AUUEgrDmWjQ/sndU9ty8QMYSKqsGUiyvGgw3bCo9hxkUWAorXOo1icIYVXJQBJEZAF0TYp2WmFIz/aZa1kkYwqmExCGTyYlOGYkyfGjmV97/1uWxSOPPIJhGGzcuJGOHbC/0uPGx+ewvYBlhTj1Rpsf33oH3X4P0XMRrQaJfIlXnf9Kjls2SCGh8sRsm9mWzYlLMqRjyuLYxWguxroFJKIfhNy1t8LNO8poskRKl5msm8x3bAxVZCxrMJDSaPQjAc6xo5ESdedcBy8IeGDHAe67506MeIrjNm/GDSAhOKwZiJNUBS6/5odYM7v5u7/8i18ZB3mm4Xkejz76KIIgcNxxxx1VT833ff7kT/6E2267jdtuu40VK1Yc8bl+U/xrVSpE/44Pf/jDXHnllTiOw6tf/Wq+9KUvLY6YHO3x/+j4X5cYH3jggcUe4MaNG4/YruWpaLdNmzYdMbfQtu3IU+3QPD/Z1eJgR6CQVEkYOvmkga5JNHseK0sGw2mNJbmn3yhty8X2AobTGk/MdRlJ6xiqjBsE7C13eXiiiSZJrBmIc7AeWfekNRlZFsgbCvmFl6MfREk7HVOodG3u21en1ely849/SKNv4xlFJKdLTg055xWvJJNKkIzJCKHA+qEEcx2LHzx0CNntcfyKIVANnpjr0rM90jGZVaUE0w2ThycaFFIxVuQN4ppECByum6Q0ibecPMrBuokuR0KNnu2zp9xhqmmRCPo8tnMfmipyyvHHYoci6wZSSKJAr9fljhuvp+5KrNx8Br5iMJaNsboUB0Ega8h07YBUTGYopRNTRTRZ4kC1jwDEsfjC5y9lpuuhDa7iXReey4YlA/x89zQ//NGPMecOMJjUuOiP/4R5S8YJQgaSKtWuw+F6j8em24hEfb1m30FVRV66Oo/udZgtV0irIqmYyEA+Sz6XQ9CTiLJM3lDJJ5Sn7WQhQtbtLXc5OFvl29/6Js16hWIqzmve8BZ+cPWV1CrzFAsF/uTii7HFGDNNk44dkEso7JntcKBmEoYhpuOTNmQ2jWTwgoBm32M0q1M3XRzXp12rcPzyATavGMb0PCZrJtPtaJfp2yZxr8nJx0WKwMdn2nRtj2OGkhiqzGSrz1276+QNhVWDCWRRwPEiatKygsF5G3/1uer1ejzyyCPk83nWrl1Lx/bZMdthtmWxv9Kja3mIooguw8x8lbvvewDR7aE293Pem99LtlBi7UACURRwPB9EMJ0gWpx4AYMpjZPGM4xmY4sLVNPxuHVXmfsPtqh0LGwvQJEEluQMlhXiGKrIE7M9dEVg3WCSfFzjidkWQgj7aiZqv4Iaz6LqegR8UMEQXDJCn52H5jCsMi867UTy+Tz5fP632uG4rsujjz6KLMsce+yxRzWv5/s+73//+7nnnnv42c9+9p9WgvyfEv9rSqlhGPKTn/wE13URRZEzzjjjiOv4lmUt1sBPPfXUo9rua5rGnkNT2GqB0nCC9lyLlBLQ77bZW28SkwSqlkfgD9K349huyFA6EpYA9Gyf8bxOJqaS0GQEBOY7Ns2ew1zLYWneoNF3aVseKU3mcKOHLApsHsqwLGcwktUX7YaejHLHZnnRIDmWpii/jC9ecT2ibxMCL37xi5BUndm2hRuoeF5IGAbsOTxNuWnygvXD5HMZKgv2VLYboKci5mmt6xCGkNZlUoZMox+Z/dZ7Do4nMd2ySMdkKh2X3kK/TRAE0pqMoWVZsWIFshbDDSVEQkQxpGm6zHR8lpz6CjKdLmIsgRiG9J2A6ZbNMUMJbBdGM9HA+cpCgkP1PnMtG9cPovELWeANf/DHfPPyy6nP7+eaKy4neO1r+fENP6HbaDCc1Ln4wxcTqgl67TZZQ4lc5Wt9JhsWYQCBAC3LxfFDCqpEvdVBNuvouSFcLU48CYQmrfkpLLNPOp0mVihgCAUSicTTKg2FhEq/5XDpP3+OXqXKeCHLRz96MVVX5yMX/wmXXnIJlWqVz196Ke94zwdwfBmEkJmGDUJUOu3aPiECpaSOwC9Lx44fsGEoya49+7jpjlt5/H6F0ff9HqV8nlxcIxmTmS43uOp7V9Ls29TMgOOPWUOr71DtOxiqSFJT8IIQUQixvQDHC5BVCVUSEJ5ie/bUhF9vNHn00UcZHhllYHScluUx24p8K4sJlWY/KqHvr3TZP99jzxO7CVWDIHAJlQQ//9mNXPT7byOuSaQMhWJCxfUCHplskTNUkpqEJInsq/QRBYGRbDTiEFNlXrlpmONGM/xsV5lteyZIxtOsLCVILJh3G4qE6XhsP1TG67cQkgPUezYIcPzqFXRsn8P1HoYqk47rKKJBPl3ihePLWZ6CbqvB9PQ0TzzxBIlEYhEEkslk/m0tgePwyCOPoGkamzZtOqqk6Hke733ve3nwwQe54447GB8fP+JzPRdR/K9IjM1mk7vuuguAZDLJKaeccsT9xHq9zrZt2yiVSqxdu/aoRzEeeOAB/ubv/p7YyBpe/Oo3EdM1NF3GSKWYmG+yZe8B3FDCsUzCkTTzNYOBdIq1ozmkBTn9UCqGH4Z0bZeZpoXnB3Qsn7m2RVKXiKsStu/TtQPimkxck1iWj3ZUsvSr1993fGKKjN1rc/X3rgNAdHqEWoKf/exnvOHCCzjcc5lv2SzL6zyxb5qpdoCsGcz3ArSWTcdxcV0fQYzMev0gcmCIKTKW61Fu29S7UW9NFmAopdGzfUBAEWGi3sfxQlRJwNAkREEgm03RNiPYcyGhoisSuhIh1qYaJko8GdkUhSFxRaLSc6j2XAw1wtUNaSpzbYuO5TGQ0haG/3UOVnukDYPP/Nl7+fRf/V9mD+zh8kseI5RUBkbX8Ht/8D6UWIpK16bv+Sw3YuQTGqbrU++7JFQRVZaxPY+4phA4NnumbdYsHaSUTtJ1fGQ9hismGBkbZywlLxJ4Dh48iCzLFAoFCoUCuVwOWZaZnZqgMXOIsVKJy/7+7/C0FJWZNrlsbnFOstZoMD9fpjS2jMm6Sct0FhioMo4fkNQigEM+odAwI2HRsoJBTJEiOEUqQ63T4+//4Stc+Na3k0wmkT2Tf7nmh3QtyKXSxDN5dky32V/rE5MFqlp0j7Utj1rPoRzYeEFAcUFZnNQVUrHIlkwWo57e44dmeHDbHuL5AWrdOPv2NzBUiammSSmhkY6pqLJAt+sh+i4HHn8Urz5DOpXmlLNP57F776RZneZrX/8X/vg9f8DSwjA5Q+WxqRZpXSEXX1AyhiEdy2OyaVFMaahPubcH0zpOdZp7774TPZWl+PIXoQ/kIAzRFIGZepdf3P8QXnOGM89+McSy9JzoGcoYKqoUeYfWeg5xVWZUjJxhSkmNgUKOFStW4DgO9XqdWq3G9u3b8X2fbDa7mCifHNK3bftp5eSjeYe4rstFF13EY489xp133snIyMgRn+u5+GX8jy+l7tixg3379gGReupI6+5PRbutXbv2WbsBy+Uy7/uzjzPdF8hk8qx74QX0fYlGz2Tv/gksz8cQfS44YxO6IiO4PeYafeIKbB7PsG7JIEuGivgIfP+xWebbDkNpnb7tsa/SxXQDsobCylICzw/YO9+l50a0kU2jKU5ZGg1kPzX2lDs8fnCeb3/lH5gxIZUtcc4553DDnfdjNquk4zorT3kJCU3B6jQIJJVUOsXhpo0QRjuekBDbi0qzwymdfEIlporsne+yc2IGTY9jISECqhTRUsazMQ7O1+k0m+jZEl3HQxVFQqKyoB+ExBSZpC4hSyKj2RgpXWaqaVHuRFi6mCpBKOAFPn03oJRQGU7pDKZ11g8lmWqaJDQFTf7ly8h0fUzHY0Upwc5du/mrv/5rRM9C8Cw+9bnPEyuN88Rcl67p4QQ+miSyJB9n+1SLBw838DyIqyJ+GBLYPTwvZKCQZtNobqGH5bFmMI4iitiez/Hj6UWw9ZOy9CcTpWmaZLNZ8vk8hyYmWLd2LQMDA/Rsj0enWlHJNqZQb9SZmJxmcOkqRjIa9+6vL5Qio0VCue2QjMkokshAUkMgIBVT6Fo+0y2TMISuabN7y71Y9VnSqRQXvOIcrr/xZmq+TlqFd73+laRSKfaXezw61WQgqZFPaLh+yFQzwgMWkgrj2RhuAMMZldG0wVguxqaRiOt68yMH2LpnkrHxIXwxMiDOJzSWF+LsqXTo2j4njWeZa1vcvWuW+++9h67pkNbgda86F0/UkH2bW6/6CpVqhVxphHe/9z2ctGqE3fNdkguw+WrXoe/4yJKAJMELVxdIx1RcP6BluuytdNlxqMyV1/+YphUQS6Q46/RT0NQYjU6fBx/aglOfoqj5vP7Nb8UUNHbPR62AjcNpVhRjhKGA6fqsHUyyshgnrv3b+4owDOl2u4tzzs1mk1gsRjqdpl6vk8lk2LBhw1ElRcdxeNe73sXOnTu57bbbGBoaOuJzPRdPj/+xiTEMQ26//Xa63S4Ap512GvF4/IjO9btGu+07PMOffOL/Ua9VSAwsZeUpL+KBJw5iLYg6Xn36RjYsKdG1PXRZYiStUm20yYgWtXod17ZIZ9LMuwZGMonlR0SbSteh2XNQZZHVpSS75jtUug6FuILrQ1wTWVaI84oNA4urboD9k7P8yd9cSrXRJp0v8cJXvoF8NtpNXPvtb1BtdVEGVvL8TatIFEcYH8xjuQFPzHbo2D4DSZW8oTLRsCgmFY4bTSMJAm4QcN+2vdx2+13I2SFWH7ORsUKK4XSEbNsxWeNn99yH15jlgnNfQmZglFrPoe8GJDWZ0YzGKzYOsK/co9J1KaVUZFHgzt1VHp/pIImgKdGoQ9f2aJouSV3m5CUZTlkWLQAenWyRiSmLnpIQJcb9lR44fb51+b9Qb9YRggDRrDGYz3Leuz5C3ZXRVQldFrHdAC8ImW2ZHKr3USSJoaTKdLlKwwpRtRgrSglOGM9ieQEJTWJpPkbfCZhrW5y8NMN4LrIv6juRbZMqiRiqRL/fZ2a+wuMTZQ6X22iaxOqRPMeMD+DIcQ7Vraf4ccJIRmd5weDuvXWmmybljk3XjsqTCFDuOGRjCpokMN00mWxEuL0QkAApdNn+8H34hx5GDH2c+CBGYZgzX/ASxkppIBL0VLo2shgtRizXX6TNpAyZE8azxBeMflcU4zxveQ5NFrnp4b3ct3uW5WNDeKJM1/ZZN5ika/sMpzX8IOTe/Q0GUxEc4hePH+Cue+4hEdN4/1tehRxLMte2SGgSQ7rHFz5/GbVGgze84z287LRjmWs79B2PuXakxNUVia4d2Vu9ZF2RlK6wa67DTNNmvmuRj6s02x2u+/FPaXkSUrLAppXjHNp2P+2eRSYm8dpXvxIjnkCRRQI/jIAYokA2JjOYjrF+KMHawcQCEeiZh+d5zM3NsWfPHiBaED25ADqSOWfbtnn729/OwYMH+dnPfvafNu/3PzX+RybGp45iqKrKmWeeecSl06ei3TZu3Pg7QbuFYciWvZP8f3//JWrNNr6exjMGSCoB55zzItaPlpClyMhWCAVKKZWZhXKRhIBlW3Q6bSq1FvGwj6xpJFMZjESKR+csGn2PjCEz3TDJGBrDGY2W6TOQVGj2PU5amuHMVb90An/ggQf4i7/6W9JDy3jrRe+n5asYqsjyQpxWq8Hn/vGrtGyBl7/obFasWUdqod/WtVxMLyQMQwZTMRzPZ6phLpjoenQtn7wecO+N32VeKGDEDH7vvLMYLGZpt9p89ZqbaXsCGdnhXa8/H0k3aPRcaj2H5fk444UYpy7NMduy2FPukdQktk612T3fYaJh4gchpYSKrshoMiiyxInjac5eXSBrqAQhbJ1q0bF8ComnLAQqXQ7M1bn9mq9RXxC2vOlt7+Dyq66j1u5gFMZ4y4Xnkc9k6NoekiCgqwIT9T5zLQfLdpmtNZAlGU/SCIANQ0nyCY2BZIQne+TxPajJDIpmsGogznhWR5ZEKl2Hcq1BvVLmzJM2MpjUuXtvjb2VHmEY0DdNfMdiXDUZNzy0RAY1kSGTzVJIJ0jqMj3bZ6Le50C1S6PvEVclYqpMtWPTsT2SusS+Sp+26SAKEfNUl2UCQuZaFmavzeM3fQvJ6eLGi1zw+jeTLZQYSsdQRCGyM2uZGLKCKLHg+OGjyRKZmMzSnEEppdF3fU5ekuWYoQQ3P7STR/aXyQ4MMVbMMNvsM9mwGcpopHWFvu2jKSKHGyayKCAADdMlZtV43toxRgcK7K/0mGqaDCQ1Vg8maDYazEzPUBhfycpSHNP1uHtPA1mMBGueHyHdDEVCU0SqXQfbDem7EYZPAGKqhIbDj267l57lorYmkO0WsaFVnPOyl2GGKkvycdIxmf2VHoeqfSwvIKNLbF6SIZ/QWJY3WFVK/IpR+G+KJ4VHxWKR1atXY5omtVqNWq1GvV5HUZTFJJnL5X7jyIZlWbztbW9jenqaW2+9lWKxeARvnefiN8X/uMQ4OTnJI488AsDAwACbNm064nPNz8+zY8cOxsbGWLly5bNCrvm3IgxD7tuynT///z6BpyVxUyNccP4rUFMFRGBJLkbH9skYCi3TQZGiXaDpRiXGlunQtTxGMxqiZ9JsNGg0mhxsA2qMZCJO1RYZzsYgFOjaHuM5nbblM5DSeOHqPKIooMmRYvOBBx5g6dKlZPIFWqbHbMui3rOZnJjAbFaQtBhCcRmiIJKJKeyvRDOWQykNSRQYzug0+y57yl2SWmR8XEiq6LJEVnH58revp+FJZNSQ819yFjfffAsVV8FIpHjNS84gZiTo2F40GmB5ZAyFdYMJXr5hAMcLeWSyyZaJJrMtm6QmU+tFM4uKGDkkjGYNTl6e4bjR9NP8+Kpdh13zHSwnQJNFbD/g8HyNa666iu7MXoqFAhd/+MPksjnu3TXJd6//Ed1Wi3xc5i1vfSupVIpqx6GQUJhqWdiWycHD8wiagRZPkDEi0PfyQpx6zyWly2zZsYcf33wLyUSCd73xtawZL7FrtoMsi2Qlhy/9w2VUW13e9HvvYnzpMvZU+oxlYugLzvLVBcf5l63OINhtqtUqjUaDQNbpyyl8JYGk6TRNl+mmTc6QkSSRRt8lpkgkFkYQar1oB728EKk2fR92zdQjIdnUY8hmHV9NoA+u5AXnvJSTlw8xmNbYNdtl53yHgbSK5QRMNk16Ty4uQhjKxjhxPEXX8iOF8uQBHjhQw/ECxNQASweyNEyPiVoPXZEwVIl6u4tstRgcXcJoRieuSTw+3UGRBdYPplBlkcN1kwPVHpvHUhSTkcDN9SMV6rGjaWQJbtw+T98JFkdFMoZCPq5w554aYQgDqYhve6DSJZdQycU1xrMxnjg4xa33PIRkVpF8i7PPvYBAS1HrOhwzlKDWc9hX7WO50QIgCAJGswbjWZ1kTOF5y7OsKiWIKf/+zrHb7bJlyxaGhoZYtWrVr7xHfN+n2Wwull37/T6pVGqxN5lKpX6psjVN3vzmN1Or1bjllluO2NP1ufjN8T9KfPOLX/xi0XvtuOOOO+KVVBAE7N+/n6mpKTZs2PA7YSL+66hUKnzpss8gOV0CLYnkWdx2512c87JzaXoS1Z7DcEYnF48spNIxhb3lLpYXECGzBSzXp9JzUSSNeH4UPT/CkGvSbrfZerjORMOl21LRtBij+SQxRaLVd2n0HB6dagFRYhxOa5x40smLK+JSUiIu+Tx4cAcrUgonnf1ifEHiF/vrPDbVxvdDgiDqFaZ0GTcAWRBpmx4ri3E0RcRyQzIxhWbfRdJU3nLhq/jW939Ct1nnyutvBARSyRgvPvv5pJNxDtQscnGZ0Id0TCGhSjh+SNv0yMVVBlM6kiigSBBTRdamkmiyyFzLQpMlluRjrCzEF7iwv4xCQmWjlKTccTDdqMw5d3AP7Vad3MAYv/eHf4gSSxGGITEjyavOfwU/uuEGms0qlXKFVCqFJEUlUMXvc3hmjkI+B6qBJouRc0ZMiSDXC+MI856BkczRLR/i6n/5Eh/84Afp2QJep8t3v/NlqtUqxUKBleNDPDLXJaFKi0kRoJDU2FPu0HBFjl+yhCVLltC3HO7aMcWB6Srtbg3PC9BiBq6oEqopcimNIAwZTGrUei6FhIYkRP3H6HMTME2LR7c+jmWbjKYT/P57fp+vXPsTKoHGj+5+lI7ls3wwy6pinBP1NI9OthfL+b4ChCFBCHMtiy0TAeuGEkwf2EO314MQrvvOt4kNLOWVF1xIKZcmrsnMtWxiosNdd9yJ2apy4StfzrEjx2C5IQMplXrPjXrLvkgxqZLQRRw/pNmPfERNN2AkE+3CG/0niU2QicmokkRcl5iqmzR6DjFNjnjCno/lBtS6LoQQuib3PryNQNEQgjRyt8+2u3/C2a+4kKYAu+Y6eEBMFogpKnE1Ij+V2xZ+EJCPqzw+LeP6IWsHE79ihPzU6HQ6bNmyhbGxMZYvX/5rF9eSJC2Oe6xevRrLshaT5MTEBNu2bePOO+/kzDPP5KabbsLzPG699Vay2exRv3eei18f/yMSo+u63Hrrrc/KKIbjOGzfvh3btjn55JOPuC/528RTrW3yS9Zx7hvfwQ3XXEVl7iB3/Pg6XvXa1yOoMU5ZkmUoo7N9usVMM3KTz8cjs9pKx2ai3kOVkuhK1DdbXUrQm9rP2uXLGB0Z4YoHJqh2LBK+hdVts//gBD3b5ZjVywhyOqmYih/A3nIPEFiaj1R0jUaDhx55jHS+xJrVq1AUBVUQOG1FDlGAQ3WTwZRK03I5UDUpJlWmmiZt22NVKYHt+fTtyI1bkSKLnxXDeU48+VTuuOM2RM8GIeR5z3s+A/kUYSggitAxPWQ5otAsyRkEYUjLdMnF1SiBZ2LoSgQwf1JdKwqRLVbP9tk110GWJEpJlbFsLLKQ6kQeg14QkosrDCQ1NmzYwBmveD2DhRwNV6VT7pIzIjuikUKWt77+Ag7NVliydDlhENA2HdxeC7fbIp4rMpJPk4ur2F7IdLNPz/YXxUEJTUaWRJad+1Ju//6V1OYm+Pz/+wInvOz1/Pz2n2IuJMWLP/xhUukM7uwcQfCrRRyBqNz4ZHScgLIrk8oNMDws4bkO9Wabw9UOU50G1YqCKxl4doJ8OsHKYpzHXR/TD6i0beJKyJZtO7Bdl5QMb379O5h2FZad8lLMRx/Cqk3w0D11ci99McmxNKetzNG3fe4/VAckvCDgYM0iocukYwrVjs2ebpk1WZHTTjkRds+Szhepzx3ihuuv5fzXvA4fhYTscvctP6bbdyjpsHH5MNPNaLffsz1AQBYFlhZiDKd1PD9kvm1T6UaQ82WFiOu7c7ZDre9Q77lUew7j2RhDaZ2O6XKw2sPxAzQ/IGNETNZWwmWuY9Po9akd2o1lOSjJAivWraex/U7qrSY/u/lGXvqK89hT8zAkAU9kATvno0gioSBEsHIgG1eo9xxmmharSr9+CL3VavHII4+wdOnS32quUNd1RkZGGBkZWfQ63LdvH5/61Kfo9/ts2rSJz33uc7zsZS/jec973lGRcp6LXx//7UupjUaDu+++G4BUKsXJJ5981Gi3dDrN+vXr/0PI7v/a7+017/8reqFGv9/j+9+7llZ1hsGkxu+9+/2cumaU4bTGbbsrbJvqsLIUJW3HC9g1Fyn8Tl6WYXUxQdvyePyJnVz15c8ymEvz+x/+a8quzOFan7bpMVPvsGPXHhzXZs1IgRWlDIWMwWgxzVA+i66qbF6SZn52hp8/thujMEIik0cSBfIJJZqP7LkcqvUpdxy6tketZ+EumNwqCwDmE8YyaIrE3nIPQxXp2T6lpEq/0+aLV/2IXrseJcbAp5RQece73gVqAoFop6irInFVQpUk5toWywvRYHalY/PIZJN6z8X1QzIxGQSB/eUuDdPl+LE0S3NxKj2bw3WThBaNrbgBlBIakghd20ORRCzXo9n36Ls+shiJazqOy+axiIRSWejVtU2PcsdiplxH9G2MdA5JVhhMaSR1GVkUUWSBuZbNxuEkQ+kYPSdy8ghDsPpdbrzyK1SqVZzcckSzzYgRLJZuO5bHrrk2851IxKIuKGebPZeu6/HqTYMMZ6L5vD3zXX6yo8xIRscPIjcS1w9o9hyKCZXxeMD2ySqq30cGYkacgz2ZvU0PTZGxui12Pb6VlODyjjecz8qhArfvrpIyFOI4fP+aq2i2O7zkvAvYvH4lZ67Os+VQg18cbJLURWbbDq4blfZ1WUDvV4jrKidsWM2qgQSTdZOH981yxXeupFWZI10Y4rWvOp9bv/sV5meniS07gfNf+0YSiSS1noumCDRNl9GMzkBSJxdXOX4svfgZPBlhGEZQgLZFMR6pqR+fbrNjto0iifhA3/Zomg6aJEWoO1HAdDxqHZPazCRhY4p4Is7YMSeBJDNiiDx29010qjMUUgbLX/gmWg70nQDbi0qpghDd14W4Sj6p8sI1BRRRAgFOWpL5lX5jsxnNba5YseKo5wo7nQ4XXnghgiDwzW9+k/vvv5+bb76ZW265hQsvvJAvfvGLR3X+5+JX47/1jnH79u0cOHAAgFWrVrF06dIjPtfU1BS7d+9+xmi3ZysOHjzIfLnM8NAQH/vbz/LQXATBHsimed3rX8/V37uecn2Wudk5lPVjCILAUEpnl9yj2nXQZIFq18XyfMZzOqIgREPxMYViaYDswBjTc1N8/stf5S8+cBEr8gV+sm2SXbuewPYFFD1FLDdMYGh4+Ow4VObQxBSFtIE9J1Fr94kNLGMgn10AgIfMtRyqHQc/CEloCmtKcR6dajFVt8nGVQqZyKWhbbrsnO+wYShJJiZzuGFGisZ6k1tu+SmdvkVJF/j9N7yZq664nOr8JN/+6pd5w++/l0wmTT6uLr4Ybc9HEARSCzCCjKFQTGo0+y6u5zPT8iOcneVCt0JWjNG2NOaaNkIoMNuyonKj4FKfavG8zRtJajKPz7Txg5ANIylapkvL9ADI+yrFpMJQKkpEoihgWS6VcgV8n7XLRmlaAX3bo95zGUzpLCtEO+z5toUsRfePoUoUkxpTdRNH0HnV697KV7/+daReHYSQC9/yTuLJNC3Tpe/6nLg0w575LoeqfRQ5GgERBThhLM1Q+pcgCUGIkGd9x6fciWAFkihQ7buIksiL148QS2WYbZl0eiaTtRa751o4rk88ITGQilE8YRPrxgcx4knCEFIxmaQmo0oqF77xzbTrNbKDo3Qsj0bPwQ9hLBfjULVHx/SIKRLTTRPNaXHGsjTLli1lqmnTMCP3l1QqxfkXvIEffe+7dKd2cuWlDyKEAdklx3DBW96KJWg8NtWiYbqkNJmxfAzfh0o3cgIZyWiAQMt0UWVx0TWj1nXIG1rEQfV8FFmgmNRoWS55XSEXk6l1beZ6FrYfEJMjiH7bCrBdj3QixZlnPI+4YVDvu8iiyEVvez3f+eoXqdYrxIIenpZGknxSSLg+zLUtVEGgmFRZkouRNVTaphcJh/7Vq6Jer/PYY4+xevVqRkdHj+r90Gq1uOCCC9B1nR/96EckEgmWLVvGm970JoIgoN/vH9X5n4tfH/8tE2MYhtx22230ej3g6EYxfN9n9+7dlMtljj/++CNGux1pnHLKKfztJz/J0qVLmXN1MkafMIyAyAO5NG+88DXsnaqyYf26RX+7obTO8rxBQBjNhcVBFkFXJJJPma0q5LJ84OKP8A+XfIbZeo3LLr2U897we9x+94O47Rrx7DCrVy8hk4gx2bbx0zqFXBLHdbCdGlbPomaGeNOTyG4XP5MlmUpSiCtsOdxkOBNbtPuZqJvkFgxf44qE54cYqkwYhth+SCmpko7J7J2ucv3138OuzJMdXMY5578RPZfnQxdfzOcvvZRyrc53vvk1PvL+91LvR0nRdAIsz2c0q2Go0c86C/ZMISFOECIJAmsHkuzet5frr/sm225NcN7b3rPgOKLQrrr4js2PfvJDOu0GihiyYvVaerZH0/RYWQrIGSr5hV1IuWMz17RpmT7NvsOhSofdB6foeBKDxQKBIJLQRWRRxPIiQciKYhzXCzAUmSfrMAICIxmdIAiZnK/z/Wu/i9SvoNodAtXg6qu+wx++530MFHKsycYZzsRYVoizb77LdMtaBIsvLzxdzp+Pq+QMhb2VLqoo0qmV0RMpUrpGXJEodyx8P+BQzcQye8zWu2SyWURC5NDHdW28QGDnxDzMNBjOxmm6IlVZIa5JKKJEbmCUvu0zkI7Mgv0wssmKDJ/BdGxajTbDuRjLly/DckPm2jZL8zEkQcB0Aox4klNedC4/u2oSwazj6Rle+fq3sHnFELbnM98xQQjJxTWWZCOfz7bpMtmIdvmCIKDJ0iKlqJTU8III/ADQNj16dgR8aFsew2kdSRLYcriFH0BqgdIzltWRRYGMuoRTl2dIJZNIAthuQMNysYUk7/qjDzIxNcfA2FL2zPeY61g0ehFyUZdAV2VWFpOsH0rhByFdx2N1Kb7ILgaoVqts27aNtWvXMjw8fFTvhmazyatf/WrS6TQ/+MEPfuUdJ4rifxpL9H96/G4cdH+H4TgOP/rRj+j1emiaxotf/OIjToqmafLwww/T6XQ49dRT/8OT4pNxyimnkCsU6Tk+gymdsaxOQEi15yLrcVYsHWMsqy/unjKGwrKigS5LFBIqOUONrHbUSBEJ0eLB9gKWDhf5q4//X7K5POVqla9c/h06toeRLDK6cj2hqCzMgQWYToDnueyZqhCIKqefcTrHbDyWFUuXICBw8NBBtmzZwr79e6nUWwRe1Dds9B2CEOKqRBgS+TPqkTghpkhsHE5x4tIsg2kdu1Oj3aiSKg7yknNfgaQa1HsOSizFn1x8MZnSCO3KNFp/ng3DSUJCOnZkf9SxfLZOdThY7bFzrkvf9llVTLJpJMVIVmckq7Jx+QiZbJ5yo8nV116PZ/Xw/BDb7PPTn95Ms1FFzw7RkNLcf7DO1ukOu+Y7PHSowf5KD2tB5VvtOjRMFxGBdq/P5OEpBFUnns5QSGp07QDPDxDFMLLRMj0qHZue47NmII4fRk4hthfQMT3MXoeffvv/0T34CEsyGv/4+UsYzxq0Dz7GlZ//G0Y1h7FctOPUZYljxzKcu2GQF68tsbKYeNrLF1iANsQRgEpljtvvvou77rgNQ3ApJFQeOdxi20wHzzK57bbbefCB+ynRQldkLGRGBwooyTyWmiQUZbZPN5mYmademaPTatE3bfaUu7Rtn9UDcRKaTNfy6DsBpaSGgk+11iaZ0InHk0zWTbZNt2ibUa/wYK1PQIjomdx31104qVHcWI5ATfCDa6+i2WwgCgJJTYl6xIKA40erCRGBluVF3qEpnfyC2EoQYKIeqZ8P1Uya/WiXLYgsKFMhtgA6FwVQFp4XVRYRBZG4JqPoOoGkY7oBbSsiF4lEatehQp5XnnH8AsxdjsAQKY3RjM5xY9EYSlqPIPTVrsNQWnvaLr5cLrN161bWr19/1EmxXq9z3nnnkc/nueGGG/5DtA7PxS/jv1WP8dChQ4uM0sHBQTZu3HjE53oS2/Rsod2ONoIw5LHJFj3bXxBy+Fhe9PJ1/ZATlmRIPuk35wUIhDh+GPXYvICm6eAGIXlDQyDy2TM0ic3jaXRZ4oc/38rnv/QVvFgeO7uCTcesRtHjeH5A2/ZxXB9DFkiGFqMFg9PWLeHU5VmmWxbVjkspqUWqQNNkplzlkYkaeuCwrGDQDA2avoKDhC5JLM0b6KrEZN1kOKPx0vUDGKrEPftqHKj0OHhogoFSAVGNMd+2cPyQjcMRwFlwusjdec56/qnMt20en2mT1hViqkQYhtT7LuWOTVyVGF9IJBCVFStdm+G0zq7Jeb721a9SsULSyQQvePHLuPPWm2i2Ohj5YU488wUsLWSo9h0IQoQFs+B0TGUgqVFMKouzjoHd465tBxgqFQi1OA8ealJMapHzCQKjGZ3ZloWmSJy8JMuKYjTTV27b7Kv0aZou/W6ba7/xRRqHnmB0aJDLLruMUqn0tP7y4PAoH/rYJwm1yBmimFQZTuvov2EcoNKx+cmOMs1Wmx/ecAOdZo1cQudlr3kjgqojuBY3/uA66n0XNTfMW19xFrOmyHTDRBZF/CBkKKMzlouxv9xDk0J6pkW7a9G1XCQBThiL8YYTx8nk8tyyq8ZDh5oErkWz2SBUk7iCTBBCMaFG2DUvwPUCkrpCXvO46sorqXX6pNIZ3nHBy7nq6qupNTuU0nHe/8fvY7ovM9+xaJoe4ws7Rj+I4BQnLckwmNLpOV4kwOnY7Kv0EAHHD2nUqwzk0hhGjGIimlPNGCp+EHDtlsN4tkMum0YUIlZu2/TYOd9hTdFAkiR6rk9MEvHCgE0jad5w4giGKvHDrXPMt23GczFCoNZ1mKybiJLAhqEkK0pxhlM62fgvAfBzc3Ps2LGDjRs3HrWKvVqtcv755zM+Ps611177n2a99L85/tuUUu+9916q1SoAxx9/PIVC4d/5jV8fYRhy6NAhDhw48Kyi3Y42RCGy+3litkPH8ohr0QuxZnsMpjV0WWTXXIf5jkOwsJbJxBRWD8RJ6Qq253O4brJztsPeSg/b8ynGI3zXoGJz3Te+gOC4BPFBIGT/rl2cdvLxHO6EOI6P5bjEPB8jn2RssAALK/jhdIxGz2OqYUbef02LSlehMDCCIgT0cQm6HabmGnQciBsqnpPEFxUcHzYMJ9GVhT6hG/E1j1u/cnEHZKgSe+c7BABCyMhAgZE1YwDMdyxkUYwwb0S+bzlDYedcG02OPe3ze7K8l9QlTl41Quy97+aSr11Fw3T54TXfRrZalIqDrD/jhSiKylzHiuZD83GyhszhhhX58gUBY1mDWs+l3ahycGIaLZnHluK0ey62GzLTtMjGFNyQaFYuqXLC0iybx9KLRB1BAEEIUSSBeq1CpesyML6WSz7zl4svzlKpxGWXXcYHL/4IU32Rh3dPsnnjekJC9pX7tC2P9UPJpzE/nxq5uMqG4STzCYWPvPP1fPlLX2S23efqn97HGSdu5IH7f0HX9MnGdTaeegrdQKFnO/iBAEKIoYoMpKIxDlGAZEzFQ2RtIY0oCHR6FjHVZf/BQ9hPPEHXM6jVA0TPplTMk05E7iW75zoMpTVOXZ5j11yXyYZJpdnmpttvpN1skiwM8YdveS2iFuecC3+Pa2+6g5lmhc9+5du84fVvQBFlRtI6haRKTI7GMzRZRFcis+GD1Ujp2+i71PsOuiLRa9Z55MFfoKTynHrC8Qykirh+wNapFn2zz8FDEziBQAAMFzKRgMqJ4AeuH9KwHGKKCIJATo+A5E/MdVmajaHKAumYTNuK1M2VjkXPicaEUno0kzuaERaT4szMDLt27eLYY4894vfSk1Eulzn//PNZsWIFV199NZqm/fu/9Fw86/FfPjE6jsOtt96K53lIksTpp59+xKMYT0W7nXTSSaRSqWf5ao8uBlIarh8w1bQWEFwCw2md5cU4My2L6ZZFKRGJDoIw2iHtr/TZNBL9O3q2xxNzHaabJjFVxvNC5htt7vzJDdiVGuOFDC9+43lc9aNbafQl7n3wETJL1tK3fQghnU+Sz8Rp9B3SMQVVEsnFVXJxhXtm2mybblHrucRVieVFg36jTC6dxUgUyJUc5L5Ju2vy6MEaUmCSFh1msiG7DIF1IzlEMXKR79s+hirhByyoSoWIJiPLTDYs6n2X9YNJPD9EFoWIO2n7UdkMIATbCxY/N9uLXpozTYucobCqFGfT8iHefsFL+Yd/+S6hqOKrSS583RtwYzlapk2l6xHTBFw/JAgFUnoE2A6CaPdz4NAEuyarZAfHaPYC5tvRSIGhS2R1mbYdXYvr+Swvxtk4nFpMim3L5WDNRJdligmdZfljyagi8VwJycg87TsvlUr8n7/+FPfsmOCMEzYuLhjiqsxc2yIfVxjNRAP5YRiNDgRhVKJWpIhG5PghHUnkvLdcxDdvuJ1+r8MdN15PKGvouRHOfsHz6Qcye8s9YqpMQo/mSgMid5YwBFkS6Ts+CVWmGNfpOh5NQcJWYuSWrWB5VuHOLU+QoIGkCkhmA0ly6YTR/VFIaAtAe5WphslsrUXDCskUhnnL615NzEjw8ESLhK5z1lmnc8c9v6BqWjx2cI61y8YZSGvkDJUAKOkyMUVktm3TsyNRVVyT2F9xkESRbExFDpJklID27C62PGARV09HVHWq7R6Pbn8CJ5RRJBlBVih3HFzfx/dCYqqAJImkJRFVEhHEkJ7r0zQ9tk226NsuiiixrKBxqGYy17aQRYHBtEYpETF3Kx2HmZZJzlCYnp5mz549HHfccUfdipmbm+O8887jmGOO4corr/ydULaei2cW/6UTY61W4+c//zkA6XSak0466YjVot1ul23btqFpGqeccsp/yZtOFATGc5F5qukEyJJAXJXwgpBy2yGl/ZLxKQoCOUOlYTp07Kjn8fhMh7bpsbwQR5FFyvUOd9/+M9qWz9DYOi79xMVMWSr5bJavfu1rzNc6VASFweERhkp5VpWSCEKk4Cyl9EVz24m6SbUXedkV4gqyLLHv8Cw7HrqbtK7y4pe/guevGKDcddg738V1LO6/40GmZ3eyJHYu5dkZZgcNTCVFTokhipFFUxiCF/gUEjKlpIokRju/mYZFEEZqwtm2SaMnUu97eGHUz+tYHoYSkV1kUWB/pct82yYdU5hsmNy7v85srcV9d99NGIaIYQAE/OCqyzn3be9DlhQG0xp9J7K8sr2ApC4TBJGI6cCeXUhmh8zgGP1AZCyrsXO2g+UFhGYbSUuxaSTDcCZCpo3nYhiqRLlc5uDBg4ys3oTtBuTSv7zHNh+7kXLHptpzKP4raLuaSLN+zZrFpOgFAZWOw4FqtGtsD0bkn3rfodFz8Rf6uUsW7pVjR1McqvY5VNU5/ZTN3Pqz20EA0W7z0uefj6LFCLo2GUNhOBOBvKebFqoU9UELcZXRrM7jM10KcYGDtR62FwEZAkIePNSgNd8lsDqcunEFgaDQbHfp9vpY7QbtvkeNNvOKST6dZsNwAtsfIHfWGZy8aoihYp77DtQIgNUDcYKSgaE8n90zDdRUfsFGSmMopZOKyeTiT/bJ4ZHJJu2FRVHLcrHdgLbt0g8kNp/9crbc9RMafZM7f34fL3n+iRy4/1bCbh9jYC1Do0sYTBu4oYAqRtZbjZ5Dy3RIG9F303dCah0LXZbw/ICZZsRdTceSLMnrdG2XfFyJ+LMpDQGBuCbRsXz2H5xgcuIgmzdvJpPJHNWzPzs7y7nnnsvmzZv51re+ddSziZ/85Cf5+Mc//rSfffrTn+Yv/uIvsG2bD3zgA1x33XWEYcgb3/hGPv/5zy/+nf/e8f8N8V82MW7dunXRIXr16tUsWbLkiM/1JNptfHycFStW/IeNYhxpaLKEJv+ytxSEkWu6KomYjk/X9giAmCzi+iG261Pp2Dw5F64t9KWcXoueZZNKxHnta99APJ2l22wy3Zd44flv4IYbf0yn32IouYxSKgZE0vN0TMFQJEQBphp9Hp6oM9O0IhqMqmBoAl0tjp7MUO/0uPGnd7D0DS/HRSUl+/z0ph/Q6zkM5Iuccdop9EKVvObRbNTZd/gwMRnSqTRaPElbgExSo9n3aJkWfhhS6zo8OtVkZTFOve8yWe8zljUiBJkksLRgIEsiru+zt9Kn1fdYVoiOb5tuc+/eMgf27MS1AuIDy3nJ84/n57fdzkyryXVXX8Hr3vg2+qgEQZSYG6bDmlICy3awqxOMpRSef+qJ/Hx/i5btEYYhA2mNerXKow/dzUQ8wclvPp81pQSVjo0gCIv9wvlymQ/+n78hNrjyV75XURB+7fC+KomLCb9re0w3TTqWT0iErZtuWjw80SRrRAlMEKKd3u75DooU0YrKXZv5ZoeH77k9GuWIDyHYTe657VbOevkrWTmYYknOIBtXIIRqL0q8jZ5DTBVpWQFJTSQUIFxQEQ8kVNwwZHZmlkCxee3ZJ3G45THfsRnJFpFFgUbf5YnpJkOGT6fdZmpqCgcRyY5RyOdpeCpO3UQkMgcWBYGO5SEqBmuXxLBdn7Qu4XoBs20Lx1eZbUel6vFcDMcP2DbdwvMjBbbrB+iKSBiExHWN4894Gfc9+DD9boubrrsSEcjlSqw6bh2znahPn49ryJKILEr4YUDP9glCl3xcpWO6yLJI1/ZoWxKGJtHoe+yZ7zCQ0gmDKKGmYyqFhYTteiG1yjymOceJJ2w+alOBqakpzj33XE477TS+8Y1vPCvz07Ozs3z2s5/lT//0T3/l2Ec/+lF27tzJ1q1bEUWRt73tbXzsYx/jM5/5zDM6/r8h/sslxjAMufXWWzFNc/FnT2LeisXioqfZM4kgCNi3bx/T09P/YWi330WokkgqJrFnvoflBlhuNNNnez75uIoiCfhhiK5ECd/3QZJgbGyU0047g0wmRTqdZOdcDz+ElGQz3Wiw4dSzme96rF4yzNKCAQg4Cy/otKHQsT22TreZaznIkoTlhdR6Dn4okzR0Nhx/Glu2b6Ntu3zhe7exZv1G9jyxHduCVDrLH7z9teSyOayWyUApy4YVIwyOd9k3U6febDE1Octc28HLGlRVg4F8Gk1RmX2yTBqCKoLrhwuK0YDVA3FWFuNUupG9luOHLC9EJd8DlT47pmoc2v04br9LShPZeMLJPNGAsZPOoblzJ5X6FNd999v83tvfgaHqtE0PVfbIaCHW3D5WDGbZtHEDjh+SiasUUtrCrtBACxwmHoVmY47Lv/ZPfOCP/whBSxCabT70sT9bhDSsWb6Eg72QcsdedM2QxOizzRi/WqmI+Lcu+6s9/ACmGyaCJFCMR4a8Xhh97qosMtWwMF0fXY4ILLNtC1USmZ6vc9dPbqDTrFNIJXneC1/M7ff+gkatzD03Xcefv/fthIJAbOGlW0oIuF5Ie0HMlNQldFniQLmHIovU+i4T9R5ut8WadIAdiNSbbVYOlJBEIXI98QLSusLanMThmQqrV68hVvTYNVUnHvZJuDV6s/N0FYMuOoYcEgYLWEAJVFHEcnzimozvhzw21WJFIVLAHq73yRoq2ZiC44XMtWwMRaRjeeye6zKc0pAkAUVVWbd+PVvvvwsBCBE492XnMOcb1Kw+cTXaJQPUZZe2LZNOyIgL84dxXcK0A6pdm+GsRlyT6bsBphuQNiTydiTmGc9pxBSZvuNxcGoazazygtNPJJlMHtWzPTExwbnnnssLXvACvvrVrx6VYfFTY3Z2ljPPPPNXfh4EAV/72te4+eabF/UVl1xyCWeccQaf+tSnEAThNx5/tq7vv3r8l0qMvV6Pn/3sZ0CERTr99NOxbZtKpUKlUmHv3r0YhkGxWKRYLJJOp//N3d9/BtrtdxXCQtm01mvgeNG8neeHBKIIC2MZ6ZhMrSeRisnUe5GwoOv4aOkcyYRKNiZTbls47RpmrcyLjluGJcS4fU+Flumye76HKolRT4+QIAg5WO1heQEpXUYUWJhd82hbXtRfCyVWrVnP3t07setTPLblfgJJJZ4pctoZp1PMZSl3ItWpGwQEIaweSDKQ0unZA4TAgfkmj+wv0+112VWr0vElmr7KuuEM5Z5Nu+8zmNYhFMgYCh3bp9Z1EQUBUYjKWrokISIw2zJpd3tYlk0sFuekU06gbIHnu8STOidtWs+WxxzK7Qrt2jybN21AEuHgTA2xdoiNK8cWKwq6CLm4wlTDXHDIEBjMpznhRefx85//nJlGmU9//Xu87mUv4CtXf4XqQlK87LLL8LUUrVqNqbqJJIjEVJGsobBmIBHZQT0lwjDEC0KEBYB72/JAhLQmI4ni/8/eeYfJVdf7/3Xa9D6zs33TGwmBNIKA0n9IEhDBAgqIwAUuVVCkXBARr8CVoqDYFb161XsVSAiIgIKCQID03pPtOzM7vZ3+++NshkS6oZP38/A8PHuyZ87snDmf7/fzeRcMy0a37MbioCPqwa1I5OsGlbojlxH1Cr+798eUilWCTZ185tOfJB4JEQj4eXTRH6j0rOFHt32TM770H6RFAdOy6cnW6SvWqKoGIa+HtpCPoYJKdmQH1SRAKpMHUcAt2vzj8Yd5/P4y3/3W9ezX2kxFMzEsm3J+mO997QYGchUu/fJXSY6eRFcyyrhkB4ooUqvXGEpn+fvmDFtzWYYGZVTRg9fjJYdMc9iDX5HYVnRSNjTTojfnkG02DZXxuSTaI17qhtM1cbtE+vMqxoivr47BthX/wBYkDG8UW5C57/Fn2W/OR2CEZKSbNqIg0ORzUahqyJJIS8gNAmwaLCNJkAh66Ir68Llkwh4b07aI+dzM6IiwOV0hW9Eo12ukhwaRqsMc+xYUxe3btzNv3jw+/vGPc88997ylRSeTyXDxxRdz5plnEggEOOmkk7jttttIp9NUKhVmz57d+LfTp09H13XWrVuH2+1+zeN7owR4P+E9Uxi3bdvG6tWrAWhvb2e//fYDnALZ2dlJZ2cnhmEwPDxMOp1m+fLliKLYKJKxWKxxYxUKBVauXEkkEuGAAw54R6zd3k4sWbIEX6KdlpBDvCmrJgGP427TPTjM//51B3OmT8GybKI+hS2pMlvTKqYNMZ9CyOOjJ1tja88AGBqjOruo4sRCeWQn9FcUnN2HIgmMjvowbZul3QWCHpnmkJvBooqjqRbIVzQMyyYRdDEmHiHpmcLf/zYEho6tBBi3334gu1g/WMAwIeZ3s3mowkBeZXzST9zvIjqy8Q95ZHryBoOaTMX0k6nXMHSdrT0pqia0hd1gevF6PbhkNx5FpL9YHwnNdY3kItZRDScjUPGE6JywH0Gfh5IuYFkmtgDDVZ2WoIfJ+00nVagyJCZY3VekXCrgKqeYd9Akujr3dCnpinmpaSb9hRqDhbpTNNxeZh50CMuffYpKahu//MVPEW2Bjo6x3Hnbt/CGYqzsK9Ac9JDwK2RKGiXVdBJHwp49LM7yVZ2+fI3N6QpDRZXRMS/xgAtJFGgJuSnVDfrzNTyKxGBRJeFXiI0YEAiYrMtW2ZGtUsoN02+HaQq7OONzp2ArXnJVHbfPx1cuOJN7v/01UoM9uCtp3NEoq3qL2Ni0hdxohotYwMXmdIV83WRC0keqqFIr50n4FTTJT0pT8QWDDGSKXHz9rXzvpqvobGshlUpx1Ve+zMDIouDQ/cczbLnQTRtlhLHp9XgZ3dlORQ5Squto9SpbBgrsGMgSdlsE3QEGUzr5moSFyKbBsqN/FAWKFYPN1QrJoIuprUE2DVWI+hWmtllUVZOIrPOL++5H699CYMxBjJp6GJs2biKvGby4ahPTpkzAKwtgW4R9TmdlTMxPWXOCuj2KhGFY5KoGyYCzMx2uaJimTXvUQ6Gm41YcYlWxprNh02YsO8+hh+/9QnvLli3Mnz+fE044ge9973tvuVzs97//PYZh0NTUxObNmzn//PM588wzufbaawkEAntwLARBIBaLMTQ0hN/vf83j+wrjO4inn36a4eFhAGbPnv2qrvGyLNPc3ExzczOWZZHP50mn02zcuBFVVYnH48iyzODgIOPHj39Hrd3eLixZsoT/uO46Im1jOfXfr2RclxNIqhomq7YP8NP7HqOqGfSULDo7OpBFm6BboWOUj5jfRWfEzdZUiSXre4h5JWZOGYdpC2zNVDAMi66Yl7jfRV++Tt1t4ZEFxiT9jIr6KNTyZMs6U1qDKJLjpqKIIIsuwh6FA7tCFIslnvzzPzAVH5aoICCwbf1qRsUPQRT8TGzxkQx4sGybXFVn81AFX6fUiOsJexWSIRfFbTpBj0KXWyFf05FFEGoasYBErlhk89Aw5bAbr8+HJbrpjCYJeWTcsjgykyxg2w7Tsqs5CrZAX6GOZhhYiLRHvDQF3dR0E0W1yZQ03EaFQqHIMTPG09nxctmO3yUzrT3E6t4C2YrO5KSbVFnD0xKk1XsI9//vTqRaGcvl57RzLyQaj7O6r8TWdAW/IjmxWZYzG87XdIZKKokR4k2hprNu0Im/kgQB24aBohNn1TxidZcu64iCjUsWyNc0XJJAsWYgCrB2oESu5sgPutpbKM36KJ3JME2xCFG/QqqgMc4jcfCYGAfeeQfbt29n7ty59OVrZCoqbSEPwxWdvrzDuiyPELgmNnlIp4eRFReCN4hkWkRDfj591qn87Id3M1Cxufj6W7j+knO489u3NNrHu7SZpXQF8xXmqFGvwsSkH0mKMqYlTmrEyNxtVulO5Vg3UAFJQnJ5SIQC2IpCsa6Tq+os7y5x7BQXrWEnWsu2bWrVCgvv+y2Voe0k4wk+efJx9FQFwj4Py5c+TzXXw7YVGRYcdzTBgBtFEgh5FKI+N6ph0hx0bAu9ssATmzL0lyzyqoksCDSHHaciRRIdi0VgYOcWzEqOjx48B6/X+7L392awceNGFixYwKc+9SnuvPPOt0VD3dra2vj//fffnx//+MdMnz6dq6+++hX/vW3byLL8qs/LXcc/LHhX36mmaTz66KOYpvmmpRiiKBKLxYjFYkycOJFiscj69espl8vYtk06nQacueT7uY06ZswYmpNJegd6uPdnP+VLF59Pa1OCDT0p7v3DYsq6RFTWmT6mGVOSGS5rxAIuDhoVxe+WSWXz7NzZTTTooyXZRN0Av1vEsmzSFY32qJeumBfVdBxN6oaFMvLl6Ix6WN5dwC2LzB4VJlf1MlzWCHoUmkMulm4Z5Fd/fo6ytwNFkhjX3sTAjs3U0gM8+dQzdJ54JMmAQ2EXRzSIA0WVfFXHG3YKo25aDJU0moIePIqIgIBumGwfGMbt8eAJxBgXi9Ou6WSLJYYKFbTKEA91r6Y4YyqzxrfQGvbSl3cRD7gaJgAuWUAUbOqGzaRmLxOa/GQqGh6XTEvYg2KWCVoah86dhC64KNSNhuXe7hAFMCwn1cEGBksahlrlyT8/jC17sGUXoqHys//+HZFIhJ6axEC+TqqkUtZNYl6FmN9FXTMJe2QmJAO4ZJGBQp3aiNNRoS6SLmkI2AwVVMY0edmcqrBxhADSEnIzOemnZtgMFmtIAlQ0g6aAm4hPpiPiJejtYnu6yrKeAtPbg/g9MuMSfjTDxBWMcsDMXbl9Al5FxqPI+FwWlRFmbq6qUaiqrNySJxj0EgsHKasGfrdMU9BFJBrlxDP/nd/88UH6igUu/cZ3kOo1OncrisDIIqtGoeZkUQJkKjouRWRckxOsvH9bmExZc0hGaoBIPEmipcKzW9Jg1ukZylDRbERZxiu72D5cZlvGz/SOED6XyLZMBbOSpzqwiY6wl7Mu+RKCO4CaqxJyy4S8H+Hpv/+dsqpTLOQ4dEob4xJ+TAt8Lsck3lkgaFgINIU8eGWRlpAHn0uirDnOOpNaAmDbrBmReM2ePXuvxfbr1q1jwYIFnHHGGdx6663vmLHIhAkTnADxlhbK5TKapjWetZZlkcvlaG5uxuVyvebxDwvetcKYTqd55plnAIhGo3v0tN8s6vU6GzZsQBRFDjvsMMDpsafTabZu3YrH46GpqYlkMvmac8n3InaJwL90+eV0D2zjzu//mJNPPoXfLP4LhbpN0O/mC6fMIxION5h9gg5l1aRSzLJ+yw5i8SYCoTAxnwvNsMhWdDTTkYO0Rxx3FWnEfBxspBEfyrDXRVPITU0z0Q2b6oiERBLg2Q39/PqJldQFL7Ik0dbWiiZIJMdMJWvUqBbS/O6+xYQ/dxLRSISASybkdW633XcUFc2kbpiMjnmRJIGyapLL5Old/QxiuJXxcQ+zxjWjGo4uLeJz8+gfH2Zjuo+g30e1lMMyTPoMH26fn9awl4BXJlc16Yr5CFZ1Ah6HUJGvGpRVDY9RxeuxmTplMtGgn4FiHX03XeTusGwwbRtZGPEHrZT5/R9/Tz6fIxRv5YtnfZrf/fa3pAtlvv39n3Du2WdTqutUNZOQV0E3bTTDoqpbDI8I1JuDbop1A9+Im09NMyhrOoNFjapq0FOoka8adEa9dES8IIIuCXjdAj5FRJIEcjUDURQIuGVn5+PyYlk2mm6RqxhkKwbrB0q4FYn4iM6wLewm6FGQRCe70yULaIZJtqJj6RqyVqWIgqVL+DSTomog1k1GRb30ZmsoHj/HHfUx/u///hdL9mCGR3P6hWcST7yUexrxKYxPBtgxXGVHtsJwRcc0oTXiJl1WUSQBjzJiZehX0AzH/DyV8LEhVWW4rCAFLBKCjYKBrtbpyau8uKGCXo7Qmogwd1SEyQd38dEOhdGjR9OnuunN1chXdAzbJhkNMf/YI+lJ5wgnWkkVVA4ZE2t8703LJl/XGa445vt+l4wkQE23YMSbVZFsFFFg9erVVKtVZs+evddi+zVr1rBgwQLOPfdcvvnNb76jblvr16/H7/fT1tZGLBZj6dKlfOQjHwFouImNGTMGt9v9msc/LHhXCuOSJUsYHBwEYMqUKXvlQL/L2q25uZlJkyY1braOjg46Ojr2mEuuWLECoDGXjMfj7wuWVTKZ5Dt33smXLr+C3u51/PwHfeihFqLBCCfNP5rYiIZKFAW8ikhVNdnZ041ULzB18gR2lgSqukEy6KwAa7qJV3Haew7hRiTqc7ElXSbolgm4HfPvQlVncjJAZ8zL+sEy+ZpNsW7SnauzascwmmnhkUVa21uJ+jzotqMDnHLIYTz/9z9TsD2s3zHImDHOKjviVTBM28lqrBvE/AqKKBD2OEzFmN9F1OciLLWwzGWTy+5g1Z/WMPO8C0lXRWSzzqN//DWFwW6SiThzZ+xPMBTGjc6mlX0YxTy2PoTX46XL52dYlhnXFKY2wuTFNpHrRdqjHjo72/H73I0Hs7Lb7E8zLHTTwiU7IvCIV3GE3nqFB//4O3IVg3A0wadOOYnRo5r5wrnn8/Of/4xcJs0vfvIDRh31OSwkXKJIWXfirCJepwhUNXPEGFukUDPozddY01fCsC3iPplUahBVCxD2+5jaFsI/8lkMFuqUS2U2DecZP6aDqmbSGvLQFHA7elDDoq6a9Bbr5GoGkuB8Voos0hnx4JYktmgmk5J+2iNuurN1SnUDQRBxCxqlco6ZYxP0V512rW7ZhD0KyYDL8e2taoREjUf+8ncExYMlu7AkD7f/5iH8oQgHT+lsSIwcKzuRpTsNAm6L5qAbWZTYmq5SrhsjrXmnTbnL8q417GHOqChPbkyjyALJoBNEXVENWpIQVgx81LGHd5AtwNZinM7OTiKRCFbdZsdwtbHrlwQRS/YycVQQQTTJqzpb0hU8ikTII1NWHSenuN/lRI0JjkG6ZcPouJOhma2orF+/nohsMGvWrL3WPa9cuZITTjiBCy+8kBtvvPFtXZyXy2Vuu+02Pve5zzFq1Cg2bNjAueeey0UXXYTX6+XCCy/kqquu4re//S2SJHHllVdyxhlnNHbDr3f8w4B3vDBWKhWOOuooJk+ezOc//3mmTp2Kbdtv+kbZZe22ffv213Sy/+e5ZKFQIJ1Os2nTJlRVJRaLNQrle9l+KZlMcu01V3PJpZciaiUQbD752U/jDwSxbId1V9UMwm6J4dQQaclkztRJ1JDJVUvkazp1LY9bFjEtsAWLsFthRU8BwzYJuBU8smO/Vqw5Bs5Bj8z4ZIB8TaOqmiT8MhXNpD3iYagpTlfdZkwySF4XRoT/IrmKRtkQOfCwY6lXSwSb2qhpFqJg80KqREvIS8SvUNdfSktoC7spq+ZIBJCAKXo44vgTeXbR/1DauoLfff9Wjj71PB7+428oplMkR4J9vYEwdd3EF/DTlowjiwncEpRKZfoyBfKVOvgEWmNB3H4PnnKOesxPIBYj4lOwLYFMTaMt7B4xPbfoydUYLKrohoXXJdEe9tAWdlOo6Szf2EcpmyaU7OTI404gFAxiWhbTx7bw1Usu4La7fkAul2GsXiYajIMACI51W1vYTaakNz7PlpCHrZlh1vaXUHXHYGDDzn6WLV1KUIZDjzyaQk3H73bmPqZWY/HDf6KW7WXS6Z+mI9JKUTXoz9fJlDV2DFcYKNQQRYHOiJdC3cTvElBkhXKtDILAhISfgaLKAR0hgm6FVX0FtEqJgJrlo3MnYMoe4sM1SnWHmdoe8VBVDbZmahRKRVY+9QilqkYk4Oek449m4cOPkctl+dY9v+SK885g7uROwh7nest1A9uGcYnASDST4JgglFRawk6bVTWcxYdXkXjh+efpTLQzuslPd7aGYdkYpo1Hkejw2RSyBQ4/9EBGxXwUi0UymQw9PT2sXbuWQDCIlwCCZZMumXhcEkGPgiLZqIbAcEljw2AZjyLilkXHSccl41Ek/IrEQKFO0C1RUk0UUUAWoXvHDkaHYNasWXstbF+2bBknnngil19+Odddd93b3rFSFIWNGzdy+OGHk81m6ejo4Nxzz+WrX/0qANdffz35fJ4DDjgATdM46aSTuOOOOxq//3rHPwx4V0zE16xZw+LFi3nwwQdZsmQJM2bMYP78+SxYsOANGXrvbu12wAEH/EvWbrZtU6lUGlKQYrFIKBRqFEm/3/+earnubjgNYCp+Ql1TOeZTZyC5vIiCgKFrVHNDjI55mDppAmsHywwVNTwu0WFH1g2iPpm4301/wRGRh30KouDsNKe1BZmYDCCNyDZcksBQWWNFd558zUAWwR6RTawdKLJhsDxiY2dTUXUM06aqmwRdMi5FoCnoITSyU7ItG9WwOWhMhMnNDs1dNy0yFZXOqJdUUaO/WKeqGYiCQGfUy2ifzvVXX0nf4BBaqBMEkeaIvxHsmyqpxPwKMZ/Cqv4SogCZkspQScW0QMDGKxpIagm1XES3BSqSB0H20xQN0h7zM6HJz/ikH0USWdVbYGe2TjLgwqNI1HSTmm4ypTVI0O1YtP3jxZUkk820NzfRHHLhdysE3BJDJZWn1/VSGh7CinSMZCTayJJAV9RLoWYQcMucMrOFgNvxtv3z2hTP7ywgC+BxSZhajT89/jdKuoXf7eLIwz7CmOYohVKJ+x79O9VqnYjL5JMnzCMSDLK6v8jGVBlVd8zma4aFYAtEvBKGbeN1ySQCbryyQDLopivmpzPmYc6oCIZps3TdFpZvH+KASeMJh/z0jexea4ZFU8BFwu/G55HoHcrywEOPUBvaQaCpjc+c/EkMyc3mgRwvPL+EajlPxKNwyeknMWVUC+MSPpZsz7EtU8UlO8UoEXAT8yn0F+ooskC57jjZeBUJNbWdn93+DZqbElz8H99izbCFZtpOULVd55c//TH5QoFvXHY2Rx128B7fC03TyGQyDKbS/G1zloIKHp+PcChAwO8nUzGI+91M7wyhiCIlVWd1X5HRMR9NQTfbhius6y9T0Ryi1LiEFz03SJNP5BOHz8Lj2rui+MILL3DSSSdx1VVXcdVVV72nnin78Op4V9M1bNtmcHCQBx98kEWLFvGXv/yF9vZ25s2bx4IFCzj44INfxoQqlUqsWrUKr9fLtGnT3jJrt931ktlsFrfbTTKZbOgl3830jd2LYltrK9dccw0333wzvekc0Y5xnHLWRagmVDIDzBrfwtSJY1k/WGZpdx5RENFMk7puMbbJz3BZxbJtshUD3TCRa8OMbktiSB48ssisUREmtwTRDIun1u5k485+mtpHk68ZFGs6JdVgv7YgqYLKCztz7Lp5CjWNmurssjpiXmRBIBHw0BJ20xR00ZOrsSNd5aMT40xoeilDLl1WSQbdjI77yFUdezavIjVCitesWcMll16K6Q5h+JOcd955TBw3lppuYtmQDCgYNuwcrtIa8pCvO1l+UZ+LUt0gYJUZGBykq7MTt8fDcK6AUS0xXKwgudzs3xlnQkcT/TWR5T1FZFEkNmKdFvYqjuxBFpnZFSZb1diarjJYrGOaNnG/wvSOMDG/C8Oy2DRUYaBQpz9fZ2e2imnZBD0SAbeMJAocMjbOlNbgyN9LZ1lPnnRRI13WiPkU8nWd7UM5/vbcCtRaiZBsMXfuXP7x/HLq9RpRWWPeghMIBUJEfTL9hRrPbc9j2Q6DMl/T0XSTumHjVsAtigiSSMglMaMzgiJLtEecqKSNW3fQny1i+BKoljNjzlY0SprB+CY/+7WGEAQnWSLT381Df/g1gXgrhxx/MrLioayaaKaFYKo89+yz1Mt5Ljr5CDrGTCLkkdg0VCZbNWgJudFMC8uCrqiHHdkq6YpOwCXiVWTqukm+VOaZ+++lvH05ba2tXP61m8nbXoazOX55773kM0O0B2W+/+2bXtOkY+dwmRU7MqiVErVygW3DdWqCmwM7IoxvT+Dz+xEQWNqdR5FEwh6ZgWIdz4i94FChRr2YZVJc5vNHz8br3rui+Oyzz3LKKadw/fXXc8UVV+wriu8jvKdip8rlMn/+859ZuHAhDz/8MIIgcPzxxzN//nyOPvpofv/733Pvvffyk5/8hAkTJrxtN5ppmo255C52ayKRaMwl30na8j8Xxd0jiy674iv0FOqEEh189IgjmLH/fkwf106mpLExVaZQNUiG3PRkK/TnVcY2+TFtm+7hGl6XRGpwgGf/9hhxj8gnP3MaLo+fcUk/c8dE2bRzgK/e+n1KqR7OOOcC5FgnigQbhyq0hTwEvRI7hqsMFlV6sjVM00mlGJf0kS6pDFcMwl7ZiWaKOnFEO3M1jp+aZGzipcKYKqm0ht1Mbnm5WPqfd8mW4iPWNoaLvnQF/mCIYt1EFEESBPrz9ZFAYwNZlHArAnpxGLdWYOLESWzJmwQ9MhOTzmsbhsFQJkt3Kku1VKZmgSb56GwKg+LBJcuMT/qdwF3dZELSz+q+Ij25OoZlY9tQ1gySATfzpiWJ+V2Ylk22qpEpawwW6lQ1x5zd65IYFffQFPCA4ARKq7o1snCB7lyNSt0kU3aYqYP5EiuffYpKPoXpbwJTo1Usc/Kpn8frDzhs46LKtuEK5bqzq7VtJ6+yrhtkqzqSIKDIAjYCYbfM1LYgiiwxKuqB0hCqpkKold6CTraiIQmQLjus3daQ23H6kR1j8eaQi6baTpRIG3/e5jBuEwEF3XLSV4aGi1QqRRYcNIV0SWVTukzUq2DZNjGfi4hPcTxf6waFqobHJTEm8VLAb7qoUq6UeebX3ybV1+0Uxyuv5tY772IolaItHuGuO779us5Vlm0zkK+PyHQsujMlKtUKcbFGsVhEFEUikQhF24vi8TFU1gm4JBRZpK7p1DJ9RP0uRo0ey0FjYq8Z+fV6ePrpp/n0pz/NTTfdxCWXXLKvKL7P8J4qjLvDMAyefvppHnjgARYtWkRPTw+2bfP5z3+eb3zjGyQSiXfkZrNtuzGXTKVS1Ov1xlwykUi87QPpXTrG5hF26q6Hg2XbPLVmB9/6zg+o5NKcdeYZTJ52AIWajm7ZBN0SO7N1EgEXuarG1nSFiFfBrYj05+r43DLVWoXnH3+YUnaIUDTBgk+ewsyxrYz161xyzdfpL1u0hNxcdvkVlHFSBXoLVXTDJup3kfA7cT3Zqo4oQmfEQ0k1WdlbZNtwBSybgFumM+bDsGw03eDY/ZoZP7JjVA2TXE1neltoD2Nt3bTY3D3A9Td+k3RqiLZ4iOuu+go333zzSHZhO2decSPBUJjoiMWaYVlsHiqTKqsk/C6qwwNIZp2pUyajKC6e3pZlTNxPZ9TRoK1Zs4a29jYG6jLYNnG3xcqdw2jVEtVygeGqwSHTJ9EajxLwewh7ZZ7dmsWyBWIBp/1sWhbbM1VmdkU4fEL8ZfdjRTNG0jscS7PhioZhWXgVmfawm2xFY7iqI0sCm4YqbB+uIAkiXVEPAS3LXff8ADXYgWDq/Me5J6P7mzFMm4BHZqhYZ3umQraqg+3kExqmw3DtKVSRcObFLllkdNxHIuBGsE3CRo6OkIwr1kl/SaU3Vydb1fC6ZCqqjiIKxAMuxjcFSIY8SCNt9lmjImwcKnH/8kGGK47VXaFmEPUrjvxFFPCOJKdkKirjmwNkKxq2ZRPxurBxFhJ1w6Ij5CXke2lxaZgW3bkqH+1wc8eNVzcWQsAei8E3CsNyMkyHyyobBis0BV2IgtNtSg3n6M/k8aEypHvx+QNEgj4q2UGSIS9jxo6jUDeZ1RUh6PnXFsB///vf+cxnPsPNN9/MhRdeuK8ovg/xni2Mu5BKpTj11FMbnoLPPvssK1asYO7cuSxYsID58+e/o8bgu88lC4UCwWCwIQV5u+aSS5YsYcyYMXs8HFL5Mg88vQqrXibg8zDjwBkAbBt2XFSmtwfYnKoiCSKK5Aj6i3WDqNch0AwV6/hcMqPDAov+8HuyVYNQMMCVnz+e//7+bfRkqwQ7p3DVpecRicQcsXVNZ6hQpyvuYVTMT9ijsDldxrRsBgsa+ZpGrqqTLmtsG64Q8cgE3QoRn0Jr0EWmqjMhGSARcCEgOMU06iXmc1GsOxISjyKyuSfFHd//CZlynUCsmU9+4gQOndRGTKxx1bX/QV+2SrB9AlddfDZN8Zfy70p1g23pAtmBHpqDLiZOmIgsy5TqBpvSJVqCbtrCXtauXcv3f3APsWiU4z9/AU3xCJOSQXYMV9g6MMyD9/2BYrXOIXPn0JkIMS7uwXSH2FFT6IgF8bheemAOFurE/C4+PjVJwP3yB6ll26zpLzJUVIn5XCPORQaqYTEq5iVb1cnXdIYrKjsyNcYkvMRkne9/907SmQxaqBVbUOhQqpz2b5dQtl1EvM4OTDMMntvhzCgDbplUSaVUN6nqBl5ZJOSVaQl7GR33YVsm23v6mBj3cMiBk9kwVKEnV2NruoIsCnhdErmKTrGuE/cpzOiK8pGxMYaKKk1BBc20eGZrnnxVpVA3kEWRsmbglkSmtAYoVA0UWcQjC5TqJp0xL4okkimrdES8uBURw3RsBmVRpCn00kKoqhpkqjonH9BCtncrl1x6aePY3XfdxbRp0zAtm2Jddwg7kkjY68hOXgu6abFxqOw4IkkilmVhAZ0xD0mvwFPr+xnO5rBqRQRRdFjq3hDRcJDZY+KvmoP5WvjrX//Kaaedxh133MG55577viyKu8iQ/wop8oOC93RhzGazHHDAARxyyCH87Gc/IxAIYNs2PT09LFq0iEWLFvHkk08yfvx45s+fz/z585k1a9Y7JsHQNK1RJIeHh3G73Q3yTiQSedvmksVikb89v4KU4WPOtPFI4kvvN1tR2ZSuMCUZpG6a9OXrjdVz3TDxKBJ13aKk6ui6k16PqbP86cdQ+zbgKvUhWAbNbZ2cdcUN2C4/pbpBSXVSPRRJYM7oMAd0RHBJIusGSgwWVTTD5K/rU/QXVQzTJlvTaQ25GdfkR9WdpPiEX2F80u+kFtgQcEtUVIOt6Qq5moFh2mTKdXZ09/DkI4sIRuJ86uRPIrg8VFSL1rAb2ajxs1/+hqwmcvoJR3HEnOmNB2QqX2TNhs3Ew0GaWjvxuhymqWqY1HWTgaJKwCXjE+r86kffY6ikEUok+dyppzFjXCvZbJZvf/+nZCoa3mgrZ396Hh+b3I7HqvDC5gH+tjVPzAWRkB+vP0gwECCvmjQF3Rw1KUHI8/KZVL7qzBJ3FcVdyJQ1Ij6Zyc0B8jWDQk1nS6qMUavwix9+l3QmQ7ypmY+f/DkWPbiIfGaIeCTM/NO+SMVy0RRwEQ8qLNtZYKigggiVkc/JLQmMafIT9Sn43TJhF6R6dyK4fVi6yqyJnZRsDy/szDOQr2ECLllErdcZylfx+QOMT/g5dHyMqN9Fk9/F37cMM1io43VJZKsagi0gSVDVLHwuCZfksE6TIQ+K5Jh9hz2Oe03ziHFES8hFuW6wur9ES8gx5dZMi1RZpSvqZU6zwFe/8uWX7Rhv+fbt5PGSLmlYtmMWkfArTGgONByUYE+Zza6/tWZa7MhU2ZwqU9FNmvwuJjYHaA172DaY55HnVhMJ+mltSpDK5hjOl2hSVMa3RkkkEiQSCXw+3xsqEH/+858544wzuPvuuznrrLPet0Wlv7+ftra2RmG0LOtd5Vi8G3hPF0ZwVmBHHnnkK95ku9qcDz/8MIsWLeKRRx7B5/Nx/PHHs2DBAg4//PB3THtjmibZbLZRKC3LIpFIkEwm39K55K4IrXhbF8NC+BUfuNmqSlUzsGxnV6brFj63TFvYQ76mkQy6MSwYKqkMFVQs26KVPN/9xlcRbEfofvddd9E2ZiKPb0jTX6gT8sgE3AqJgKNFnJD0MybhZ7ii8ei6FBsGy2wYKqHpFqZlIwo2HTE/Mb+C3yUypTWMTxEZ1+T8HkBVMxsPZ9VwjJt3ZqvkKgZ2ZZjZ41uJRsKYlsXqviKCKHDomBhoZZ5e30sk2c7UliAtYQ+5fI7n125lxtgW5kwdT6qsOWQU02KoarN1GgAAYrRJREFUoCEKNprphDvnqzr5Upl//P3v1AppgqEoxxxxGM/96Q9kMylCzZ3829lf5MhpXUT9rpG/q8rClQP0pUuYpkquVKFa0wn7XRwyLsHcia2Yogvdcgp+zO/CJYmkSiqr+oq0hva8D8uqI2eYMzrSKOxrtvVxzc3fIZMvE4tFOe+cs9lvdAtGpcA1N/0XqUKFaCzOeef9G+3JOD63TMSjkKto7BiuYtoWiYCb1AgrtzPmAV1l/foNCP4otlrmJz//BeFYkn879xxWZZykChuIuWyWLV9OvaYyfr9pTOxq5ogJCeaMjvLizhzPbstRVU1CfoViVccwLWwB3KJEa8RNyCsjCDAxGcQlifTkamQrGn2FOh7ZMVFvCXsQBYGBfK0R9CwKAq1hD+1ejVtvuZVUrkAyGuGrl57P3bffSv/AANFR+/G587/E+PYmlJGIrnRFpT3sZb/W4B4yG8O08CgjMpuIh0LNCe+uaU44tj5iaN/mF0lvW4sYiOONt1E3bLyKSGvYQ0h2OAaZTIZcLofb7SaRSBCPx/fwZN4dDz/8MGeddRY/+MEPOP3009+3RTGTyXD44YczY8YMmpqauOWWW97TMra3C+/5wvhmoKoqTz75JA888ACLFy+mUChwzDHHMH/+fD7+8Y8TiUTe8blkOp2mWq3uoZf8V4q1bdts27aNnTt3Mm3aNBJNTawdKDJU0Ih4lQYFfriiIYlQ0yxKmkFVM4n5FA4aHWGwpLItVSHkdRHyyER9TvDxhp5BfvuD2xnu3tR4vbbWVr5xy23srMqOCYAk4nOJSIKzGwCYOSpMvqrzP8/3sHGoQr6mUVEtBMHGtiAecF5nVNzPtLYgblnkgM5ww3ptqKjyxKYMVc0k4pWRJIGtqQrbhx1G51GTErhkZ1e5ut8pLmMSPsbEnYK8fqBARbeIiBpDgwPMnNjFR/cf23CU6c3VeLE7z/bhGk1+F1G/gs8lsaKnwKZUhTa/wN8eXUyhXMEWXUh6laTX5iuXXsiB49qJ+BypSXeu5pBKBku80FMAG6J+GSwb0VRJKipWvYotKUTDIfzBEKObo0xpC6EaFst7CkQ8yh4G4umSSjyosH/bS1l+S5Ys4Zqv3Ui8pYPrv/Y1utqaG7rAwaEhLr3yPxjMl7n8skv5yJyZjeL7z8jXdDYOltk5lGXztm6C0SgTO9sYHdC54frr6CuoRJs7WHDaF9mcNUgVKmxavw61UiCoSBxz9BHMHJskGXQzsTnAz5/ZSbasoY/MCwMe0XGZsSzGJ4Mct18SUYDV/SU8skjQLWPZNjuzNXrzNSJema6YD79LHukKaMSDCi5JxO+WKOZy3PDtu8nkSyQiQc46999oTsRISCo3Xnc1O2sKiUiYK6+4jFg0hmZYDJVUCjWdAztD1HWLVEkj5HHu1eqIm9LklgD5qs5QUaN5t9ZtOl9i/caNHDqplf2nTMIGjBFpjfhPz4ddC95dZDxN04hGo5imic/nY+rUqSxatIhzzjmHn/70p5x66qnv26K4C5s3b+b555/nF7/4BTt27ODrX/86Rx55ZCOG6sOAD1Rh3B2WZbF06VIeeOABHnzwQdavX8+hhx7amEt2dXW9YzdwtVptkHcKhQKBQKAxlwwEAq97HaZpsmbNGorFIjNmzCAQcMgrdd1k+3CV4ZGHllcWKakGsug4hwBY2KSLKlXNJF3RKI0QJnTTJuqVCUsqt3/vJxR7N9IV9TSkIP0DAyQ7RvPZi65lYkdyj2us6c6DZ3ZXhOU9BZ7ZOoyNw2rsL9SxLdAtC0UUyOZLdMT9HDKhha64h6mtYRIjCRJrtvbyuyXbmTJuNMGRYpkqqaztLVDSLQ6fECfsVRgs1Okt1OmIeOiK+eiMeNEMi1V9edbtHELRKkwc28EBo5NMaQk2vEjXDZToy9cQAI9LplQzMC2T/nwd3bIZnwxQzQ1x729+jy2ISHqNm798LkfMme60kGyb9QMl+gp1Qm6F3nyNLekKkgBNATfNYSftZGuqTGfMQ0jUyeVyZHM5hqsWk9rCHDCmhYzhIV21CHtkZMkRmJu2zbS2kBO+vBteaZ4MziLihU29dPcPMnnSJKyRdJPJzYFXZE+u29bLQ89vxBdrJhmP4ndLNAU8xKQa11/9FfqH0jS3tnHc6Rfzi4efoZrPEA4GOP744xnfniDsdRyQSnWDv25IY1gWhgUl1SDqVZAkJ77q07PamNkZQQB6clW2ZWojbkIimmE6vqamTVEzneSWmBMoHfUpzOgMYwO//fOz3PPzX9EUcHHFFVcQj8XJlDWCHokwVS676bsUhoe4+ILzGTdxCtuHq+SrGjXDojXkIVfVGNfkp2W3XXluhBBmWTYuWcQ/MheuVCusX7ceKRjnuNmT9iB9vR5s26ZarZLJZLj33nu54447CIVCFItFrr76aq677rr37e7q1eaK1113HS+++CLTpk3j/PPPZ8KECe/iVb5z+MAWxt2xa7e1cOFCFi5cyDPPPMN+++3XiH3Zf//937Ee+i5B8q65pKIojZ1kNBp92XXUajVWrFiBoihMnz79FXWbu8TJpmWzqrdI6J92J9mKxqq+AqPiPtIljbBHQZRgS3+WRxf9H6XhFF3uOnfffktDCnL55ZfTN5QiOOZA/v2CCwiFowxXNFTDRDMsxiR8zBkd4dF1aSclQjcdP01FQsYmXdGxaiXWrVtDwCVz3iePZHRLAtOynSJiV7nsy19lu9TOx487nhn7jaeiOlKDLakyhZo+UjjcIzIIFb9L5sCOMBGfYyz9jzU7CAp1jpk9BdnlZbiiMSruYXxTgBU9BTJljaGSSqlm0Bx2Y9s2a/tLTqtXFEh6bB78w2/J5vPYLj+CXmOUUuZ7t32LZDJJrqqxvKdAzOdCFAXW9hcp1QxSFRW/IjIhGUQQYGVvgTmjo7SFHcarjU0qV6RQKNAslCiUytQkP7bH2U0mwgE6o749djGvBdUwWdZdwLQg6nMWEKZlM1isEw8oeGWZumES8TnJHMND/fxl+RYiraOY0N7UeOANlVSagi6a5TpXXHEF/QMDWJKLWmwigUQbnzjxBHwBR6JiWTTIQZtSJXJlnaphYdnOfdYccjE5GeS0g9pRJIl0SaU3XydX1TBMm0RQIV3QeHLzMG6XiEeW0A1HY9kR8bBfa4jDxseo6ybPbsuydsMmAtEEoWCIqE8h7JWpaiZTWoI8ubabTd2D7D9pHMW6w/R1ySIu2Wl9LuvO0xxwM7bJ7/j+jnjBVlTHT1YUnIi2crnMxo0baGpuwR1OMLMzQsT3r2kVbdvm3nvv5YorruDwww9n3bp15PN5jj76aM455xxOPPHEf+m87wZ2nyEahtMN2n308+tf/5rFixfj8/n4+te/TldX17tyne8kPhSFcXfYts3w8DCLFy9m0aJFPProo8Tj8YapwKGHHvqWmQa8HkzTJJfLkUqlGnPJeDzemEtWKhVWrFhBMpl8Q45AFdVgaXeegFtu+FaCs5LflKpw8Jgo6ZLKYMGZQ67d3suq5ctJCEVuvOSLzJrU2WjN7SqOvQWVeV+4DH+iA0nEmQVaJpNagszuivDXjWlW9RWxsOnL1hEEgahPoaabBCSLpc8/Qy07SItb56ovXYQ/GGbnYIbffe9bpHp3EBg7k7knnonk8lCqmyDYiEBVN4n6XI3ikS1raJZNZ8RD2CPx4oYduASbI2dOJBF0wh2rmolqmkxtC/LXDRlyVcd0YKCkEnLLdEQ9bB4qo5oWtqGx4q8LKeSyRCIRDj1mHv947CFq216kIxlrBA6v7S/RGvZgWhZPbhxmQ8qxcAPwuyUQBDTDYlZXmNFxPy0hN6Ig8MKK1TS3tHDsgaMxdZ1MJkP/UJrMcBatVkHXVA4//PBXnVntjnRZZWVvkZage4/V/JZUiYGiyvhkAI8sUdMNStkUlNJ4W8aSjIbRTduZtRoWigSKJPGRsVG2b97QYH9aio/PXnoDdXcUWRJwSyJ+j0ylbiCJAt25OqIIIlBRLYbLKq0RN/OnNdMW8TVyI12yhN8tOYkpRZXubJW+Qp24343fLSIIAsWaTqFmcOyUJo6a1ESuqrFo5SA13SLklbFtpxMS9MhEvE6B3JJ2yDPFuk6uohP1KrRHvUxs9hP1yjy3I0+uZjBqhOHcPPIZKLJAwu9ia6aK21bZvmUzre1tyIEYEa+LAzpCr8tsfSXYts1vf/tbvvSlL/G73/2OBQsWYNs2q1ev5uGHH6ajo4PTTz/9TZ/33cZdd93F008/jd/v5+KLL2bWrFmNYwsXLuTee+9l1qxZXHbZZXsd0vxex4euMP4zqtUqjz/+OIsWLWLx4sWoqspxxx3H/PnzOfbYYwkGg+/YXLJYLDbmkuVyGYDm5mYmTJjwhjLgbNtmdV+RTEUjGXA3dgrrB0sU6zpzx8SoqibPbMuyOeWcX6lnOWh8G95AkMmtAaa0vGSvl0ql2Lh5K6XwWPpHjL9NyybkkREFgeawm1LNoK+oYpoWfTmVVKmOZlq0hT2MT/owNZVHFz9AZWALzdEQX/ziF/nRf/8fxd4NdEW9/Od/3cbKDCztzhP2OnmONd3AJYvYNigiKJJIZ9SLjcBArszW7j68bhdHHziOppCvcb26aZGv6XRFPfxlUwZsJwh5qKgyVKxjCwKSCLau8Y+//plKYZhowM/HP3EKisfP9ITAD2/+j0bw7vX/+W366gpNATf5ms5fN6bpK9RxSwLYYOH40wbcElPbgrhlmdExL6mdm7n7F7+h2Qs/vPWGPdqig4ODXHb5FQwVqiz4xMl0drTT0RRlVFvyVXWx6bLK8p4CTX7XSKi0gGqYLO3OI4uOxlAUYMeOHWwbyDJr2iRMUaGu2wyV6o35WU01EQX4SLvMt66/qsH+tEWJwJgZfP6sc/AHQpQ1hxizOV2mppp0RD3UdMemDdtmoFhHBCa3hIj7FVLFOnUTRsV8hL0yIY9Crqrx100p6pqNjRP3FPK4MG1HY3j81CSHjovTl6/x53UpLBuaAo5JgmZY9OXrjIo7yS+VukO2qdRN1gwUqegGY2M+JjYHqekm2YpGRTOZ3BxEkQTqukUy6GLO6AjNIQ/LtgywZNVGkq0tNCWaiPocdvQrsYjfyHfsv//7v/nKV77C//3f/3H88ce/6XO8F3HLLbdw++23c95557Flyxb+9re/8cADD3DwwS9Z8H3ve9/jt7/9LT/+8Y+ZOnXqB5qt+qEvjLvDNE2effZZFi5cyIMPPsj27ds54ogjmD9/PvPmzaO1tfVtL5KWZbF582b6+/tpaWmhUqmQz+cbc8mmpqbXLNbFus7GwQr5mo4ogAW4JXHET9NkQ6rM2r4SFjaqbuF3S7SGPCQCHgJekeOnNv/TrEZjyfYchZpBWTNxiQ65Y7Cokq1oTG4O0Bb1kC7r5CsaA0WNumEypyvsOLSUNFq8Fr//6d1kMhnn7+wO0+6zuGfE4mtlT4ENQ2UkUXDs1iybgFtiy0iyfcAtMzruIyDZ9PX2ovj8uIMRRsf8jEr4GvOjfFVHkQVcsjP325qpUtOcBAnDsijWdA4bF6M6tIMf/OY+/JEExxx/AvFIiJmdYaZ3hMgNZ7j88ssZSqW48Rs34W2fTK6qMzzSjs5VnOgow7QJ+xS8skg84KI17Mw9PbJIWNb4zU9/SGHnWtqbEy93KyqZhJu7OPvss3G53Wi1MgGzhKSWCAQCDZelXR7A3dkaT27OoOoWMZ9rZC5m8/yOHFNbg7RHPazduIVypcroMePw+9xUdZsXt2dxuxyGbMDl7AAzxSJP//6H5Heua9gL3nTrHXTXFWKRCMd/5guEgs6ctidbZXV/iTmjIjSHHKP3oWKd/lwNzbSZ2OJH1R2TA0UWaQt5aIl4GOjtJhCOsT6jEXDLeFxOq9U0LIKKjceqcPb/m8mEZIAXd+bZlqlQqRukyyo13TFEkEWB0XEvIY+LXFUnHlAYrmis6S9RqRvEAy5Gxbz05uuIokDMJxP1u0divEzGJvwcPTlBLptl5cpVtI+ZQCTRhCyKhL3yHkzuN4pd7dOrr76a+++/n2OOOeZNn+O9gt2LmmVZXHXVVZx++ukccMABVCoVvvGNb/CTn/yERx99dI9IwBNPPJF6vc6jjz76bl36O4J9hfFVYNs2GzZsaJB3nn/+eWbMmNEg77yR1uabha7rrF69mnq9zoEHHojP52v8fNdcMpPJIMtyg7zzSnPJuu4kVWi6iVuRiPkVBgoqi1cPsnGojGqYyILYENQH3QqdUS+6ZXFgR5iPjIs1WqqFms5fNmYYLNaxRzxJh8sammFRVg2ifhf7tweZ3BLALUuN1IxEwEXQIzNc0Rgd9zHYs4P/+va3sSQ3iBLfue5SDpoxHYCNQyX68ypuWWTjUImabpGv6k7GXs0JRvZJJnK9gOYKEgsH8bskBISRBBA/sihiWjaTWgIMFutsHio7KRkjzjO2bVNSTY6e3MSh42L89eklRJNtxOIxEgF3w0EHnJ3yrsT7smqwLV3huW05luzMYVo2HkWkqhp4XTKiYNMU8DClNYgkgmnDwaNjyFqRq6/88sv8bXfm64Q7JnPlxf9GU9wJD85VdSQR9m/1U8pnG/NnURSxvBFyth9cXnI1g4pqohmmY9iumbSFXfT1DyDYFp2dHZiWgAkIts1zO/IIgo1Hloh4FRJuiycW/g/5zBCjvRrfufMOkskk23sHuPjG75CuWURCIc783GcdUkld54XtOVyyxKRmh/A1VKozXNZQJIGgR6FQ19marhJwSY6/rJ7l/of+hCvSxpyDD6ZmyQ0LvUy5Rs+OHQi57dxw6hGM229/VvUW6c/XqOlOaHJLyEPALZOrOpFofpeIIkv43BJr+0vkaxrZkoaiiHREvNQ1C49L5OAxMZqCzo5TNyxEUWCUT2f92jVMnTqVlpaWvfpu2rbNT37yE772ta+xaNEijjjiiL0637uJ3Yvi7373O3p6evj5z3/OPffcw5FHHgk4nbTrr7+eX/3qV/zlL39h+nTnu7pt2za+8IUv8N3vfpeZM2e+a+/h7ca7FlT8XocgCEyZMoUpU6Zw9dVXN8zOFy5cyC233NIwOz/hhBOYO3fuXusUd80TfT4fBx100B7nUxSF1tZWWltbsSyroZdcu3YthmE0dhiJRAJFUfAoEm3hPedWPpdE2KswOuqhrDstR78oYdsO03BzukIyoNCdrTKuyU/HiHVa0CPjVQR6sg67s1jXsWxHC+Z1i8gi9OTqBNwSB412WrV13WR8k9+JWqporNs5xI9//b+Y7hCCZSBWh7n9ju9w/Y030drcRMij0GvXqWgmVc1ymLWSCAKEvAqSqdKfrdDVHKEtHBwpCB46Il42pSoMFlUmNwdoj3hJBl0UazpDJcdgQJREClUN3bRRZLFBVPr44R951c8imUw22p8Bt8y09pCzc96ZQx4J2q2oBvmKRlkzkSWJct3AsGxGx710xbxIoq8RMN2bznHhV7+GDYTbJ/Dv/3Z2oygChNwS27JVol6ZoDeCtyVIMj4KU62yvidNsTiAZKq4fSEUxU+vLmILIi1BhaWbe6gbAmPbk8iSTKZSa0SGdUTdeGWRomoiigKFQp58oUAiFuO2b17ZeI+j21u47KLz+dbPH6A43Ec6lcbjC6AZFnPHROjNq3gUxx2nUHOCki0E/C4nALot7Gk4HjU3RQn6/WRMWP7MExzwkSMp6VCta/Tu2I5erxLyR8jKMVy5GlGvQl++Rlk18LtlZFHAI4u0hN0jxVTFa9gUazrDZdVp5fsULNspVomAgsflSEQ8I3P1YV2jVsyzbtt2pk/f/03Zyb0SbNvmnnvu4Zvf/CaLFy/mYx/72F6d792EbduNonjFFVfw05/+lMMPP5yNGzfy3HPPcdBBB+H3+/H5fNx0001YlsWBBx7Ixo0bmTBhAs3NzRiGwfr16/cVxg87BEGgtbWV8847j/POO49SqdQwOz/11FMRRXEPs/NdO703ikwmw+rVq+no6GD8+PGv2a4VRbHhyDF58mRKpRLpdJqdO3eydu1aIpFIIxVk97mkZdv4XBKxgIcotrOjNJy2U76mE/e7CHi8pEoaG4bKJINuXLIzz2oJebFsG8O0RnSKEA+4KdY06qaNUdVY3m1imWCN2JP1F+oMVzTcZoX/uftmysM52puauPySS/j2939KT0nlqlu+x+e/cBZtTXFCHomBgka26sRjhb0yEa9MvlAgXVKJRcPoKEgCDT1dPOBG2bKRQKKF/Vpb8CjO7Rzzu/AqItuHsgyk8gTjTRimjd8jMZCvM5iv43ZJmJbzN4nsZi9mWCNhwgj43RKi4LAaRVEg7HV2P84uVGC4ZuCVBZr8Lnxu2bFpM23KqkHY67CNv3Dxldx4+z1YshsLiZnHfBJV9DRo8WXVoCdbpTtfpzdbo6ybRDwy7WEvJjYVJcwB0zqRbINcPseOwSz5oTJet0KvYVFSBRSfn7X9JXpGwndDbgnVcMT+hmkzOuChWDPwh9o5/uTTOGpaJ6FoHN20UCSHFDNnQgefPfHj9KczhFs6qekmzUE3Mb+LiM9FIuAmX9UJuGWaLJtczWgwnz2KgN8lgiBQtxXmLTiR+x57mnJqiOVLnubA2QfRs/JF7FqdmFtm/rHHsLMkgEtFRKCqmWQqGnXDpqKZeF0S4xL+BuGnL19noKgiigIWEPW5CHok/C4ZUXDcbcBhy1Y0g1Qmg5Dv4/A5B5BIJNgb2LbNXXfdxX/913/xpz/9iUMOOWSvzvduY9ez5bnnnmPTpk2sX7+e9vZ2fvGLX/DVr36VpqYmTj/9dDweT6M4NjU1NXbcfr+fL37xi4wePfpdfBdvP97yVurAwACf+cxnkCSJJ598co9j2WyWCy64gD//+c/4fD4uuOACbrjhhrfs+LsBXdcbZucPPvggQ0NDHHXUUcyfP5/jjz/+Nc3Obdumu7ubLVu2sN9++9Ha2rpX11Kr1RrknVwuh9/vb8wlBZePF7vz9OZqWLajF9yaqTJcVgl6ZGZ0hGmLeCnWdaI+hbljYrSFnVljb67GolUDZCsaO4Zr+FwSNd0pIHG/C49LpKaZRH0K09vDTGz2Iwki/ekM3/n+jyn1rKMzFuDOO++kLPpZtqWfX/7kB6TLKsF4G4d//AS6khGmtAbZkiqzfqBEe9jD1p4BcjWNUCSOZYNmQXvIQ9gnM3dMlK0bN3D3j39KLBrlB9/4Cu2tzpdXNy0eWrqV7/5qISXd4sjDDmbahNGIAgwWVFrCHlpCbkBAEgVaQm4mJP3kazrd2RrpskahqmHbjpfrmCY/K7oLbEw5Upihkk66VKekmuiGxfikn0nNQZqDLjTTYlJzkK6Yl007+/nSN+9muFjBVtwgyHiizcz6yEc5YeYoYj6FzakKmbJK3bDIVZydLdiN/MLBosqU1gATkg4LcGe2yqa+LKmhQXQbekoj95IkEfa5MQUXQY9CwCsysSlApqxRNyxKdQOvLNEWcTM+6cQveV0S7REPbWEPgiCwbqDI5lSFkFfG73J2b8MVnVFxDxOaAlQ1k9V9RdYPlujO1lBkibKq05uv0xJ04qw6Ih5CXpntA8P87x8eIG8qCEYNbBt/KMqpC45B8fhZM1CgK+ZjTNxHTTfZlKqg6RZul8iRExINB59k0MVgSeWFHbkGq9UtSbRGPNR1p4iOjnlxyRKGZVEu5Kileznm4AOI77Yr/1dg2za333473/nOd/jTn/7E3Llz9+p8rwdVVbn00kv54x//iG3bnHrqqXznO9/Z66Dkf8Yf/vAHHnvsMSqVCr/+9a8brdV77rmHG264gW9/+9ucdtppL9NkGoaBLMsfCi/Vt3TH+NRTT3HmmWcyY8YMstnsy46fe+65SJLEtm3byOVynHLKKSSTSf793//9LTn+bkBRFI488kiOPPJI7rzzTlatWsXChQv56U9/ysUXX8zBBx/c8HHd3ey8VquxbNkyDMNg9uzZhMPh13ml14fX66Wrq4uuri50XWd4eJhUKsWyZcsQRRHDHUE0fFQtZydkms58Zr+WoLMDrOsjs0GFQk1vFMaAW2Z0wk/II5Mp6+RrGpIgEvfLeF0iUa+C6HehGTZ+RUISnJ1EdmiQfD5HU+to7rzlP4jEE2zbWaC9Kc6pZ1/Az//nj5TzGdxagZoeYrBQ58D2MFgWa7fsxCWKdLW1EvQqCIKNbgA2jG3y41VkmltbCcWbyfZu5qtf+XKD5JIbzvCre+6kRBMhv5vJnUkkQaCqWbhlcWQ2GsArO16qffk6ouCwPwtVg+GySs2wMG2bsmZSVA1KqoFXkXHJEvu1uOn3OdFPmmExtTU4ElEl0purUVV1+geKXH3DN8loXkKJVo7/f0fxyKN/Ybhc4ulla1AkgYPGN9OTqxH0yOiqiY1AW9RN93CV7cMV+gsSkgDLugvE/c7urVQus7VnkK7mCL2ZAoGAj5BXoVxTcZt1crUSmbxEi1/GXxli/MSJ5Ko6XlnEBHwuGQkBzbIZKqikStrI4sDD2IQTS5YpaxRHpBptYTddUS+ZssZAoT6yK7ZGCDI2HlmkK+ol7JWxcSze/G6Zjx84mqD9/7j9D3/DUgKIeoXjDp9LIh4mXdRQJBGXOOKoJAjEfS4Gi3VEG1ySSL6qIwjQPDJz1AybyIi2sao5UVuiAPu3h5jdFaaqW+zs7sEo9fHRQ2YQjUb36rtk2za33HIL99xzz8sIKG8XrrnmGtavX8/KlSsRRZEzzjiD6667jltvvXWvzvvP7FFFUeju7mbjxo0888wzjV3whRdeiGmaXHvttdTrdc4555w9ivKu8c6uZ9gHtSjCW7xjvOGGGzj++OPZsGED99577x47xlQqRWtrK93d3Q1roYULF3LNNdewbt26vT7+XsMus/OFCxeyaNEi/va3vzXMzufMmcNNN93EmDFjuPfee992P1fLssjlcgylUmzpSzNUNhA8QUzJS0Vw0RLyIo4E9CaD7hGhvI/xTY6nqWXbrB0oMpCvM1zVeX57jnRZw++WaA64ifhdRLyOS0p72NsI4wV4btlqRne2cvQBY6jrJi9257EsZ+dj1Cvkh4cZO24s2YpOa9iNVzDI922hJAaJNLVSMyzKdUfXFvXJ1PWR9p8IIgKyXuGHt36Nwf7ePUguPalhfOMO4pTPnoY/EMQtOSkj3dkahmnRmfAR9Ti2ZAOlOj05J05LAAp1k2TQRTLgomY42sl8XaemmSiSSF23KNQNhgp12qIeDh4TxSNL9OdrbB+uEZJ0fveLHzKULeBrm8BnPnkCluShO13gmX88Talu4vH5OPnoQ2iKBkkG3WxJVyjVDcqqTneujiwKRLwKAhD1K4yK+wgKGhu29aB5IuQKZZ5augqX28/U/acS9nlpi3hIl2r0pHLsXLcCo5zjwOlT6egcRTgYIOT30hL2kq858U8Aqm4yKubluKlJREHABoo1p/i5ZJGQR2awqLJxsIwoCHgUkeGyxrZMBUkUaAq68bkkKppByKMwoclPU9BNrZjlsssvZ7vqQwuPQTRUIgEPJ5x4In6/35G5uBQMwCOJ1E2DoYJjZ3hgZ5iY301XzEtb2EOxrrOyt4g0ItQHx2u2qpsc0B4i5nexfft2duzYwcyZM/d6kWlZFv/5n//JT3/6Ux577DEOPPDAvTrfG33NSCTCI4880ihUK1eu5KMf/Si5XO4tCUb49re/zZVXXgnA3/72N77zne8Qi8W48MIL99As3nTTTTz33HMsXrz4A138XgtvCyv13nvvfVlhfPTRRzn77LPp7e1t/GxwcJC2tjby+TzPPffcXh3fRW1/L2KXd+pDDz3EL3/5Sx5//HFcLhef+cxnOPnkkzn88MPfMSsp27Ypl8ukUil29qdYM1DB6/cxqjlOPBbDEOQ9Hji7UNNNtmeqDFc0NqXKrBsokfArNIc8JINuQh6Z5T1FOiMeJrUEsW2bimqwI1tjdNzLtLYQPpfEqr4i3cM10hWtYYdWUQ3HyFox2LptO0dN62T06NGUVBPLtvEqEh5FRBIdR5Zc1fHpdMsSEZ9MNpPZI9AYoLW1jXO+ehOiN0jU58wQe7I1ntiUIeiW6Iz5qKomxbqOKAj05qvII6vqgEfG75ZRRAGfS2ZC0j+S2iCgG6CaJrphU6jpeBWRjqiPVFGlO1elLeJBS+/kxz+/F1+ii9nHLKAjHmHrcAUBKFdrvLhqPXq9yiEHTmbymE46oz5SZZXBQp3NqQoATSOZj0XVYM6oKF6zipkfJNzSCW4/2wey/O/jS6haAn7Z5qiDZxINBciXKjz3xJ8pp7YTiTVx3LwTCbpFhHqRoQooXh/BoJ9kNIyiKOSrOumyyuyuCB5FIuCWaAl7iI989rrpeL3qhr2HS0y67Bh2t4Y9I3IJF/GAgiyKewRMt7S28anzruDHv1tEvlAiFvTxpQu+iKH46M3VKNUMVMMm5JVpDrpIhtxMaw83fE93ob9QZ3umSlUfCX9WRLpiXjoiHrZv305PTw+zZs3aa+G5ZVl8/etf57//+795/PHH2X///ffqfG8UmzZtYsqUKdRqtYbBiG3b+Hw+nn/++b2+jlKpxPTp04lGoyxbtgxwjM9/9rOfkUgk+Pd///c9FgAf5DbpG8E7Rr4ZHh5+Wc8/Ho9j2zapVGqvj7+XC6MgCEQiETweD88++yw33ngjc+bM4YEHHuDiiy+mWCxyzDHHsGDBAo477ri31excEASCwSDBYJBx48YxJlVg5bYBdgzlWL21h6DXzeSOOIImYfuUxnV4FYn9WoNUNIMpLQGmtATIVw0SfgWvS3basH6ZummyOVUmV9XJVTV8Lsdzc3lvgbEJh+2aLqnUcia5soYgClg2+OwKm3f2MWnsKCZNGIcoCHh3yz1UDZN81bGr2uWsk686+YEBb5ivXnU1X/rSZY1/f+01V9Myup0NQ6WGvGBbuoKATUfUR9ynUK4blOsGFjYhj4LfJZGvGVTqBs1BN4Wa3jAZsG2RiUk/LkmiWNeRRWGkxWcxVKrTZ1lMag7QGfMitU3nkn87G2+0iQ1Zi3UDJSq64zFqIDN+/EQsvUZbWwuGBVvTZWRRQNVNVMN0QoCrGoW6SdinsKknRdCqcNSM8aiis4sanfDhVgR+8/A/qFdqPPPkYxxz5OE8//gjVDMDjPIa3H3jxSSTSSqawY5MlT+t6iOVL2PqeXKpQXxeLxXBS04T6Q66mdAUIFXSGK5oTG5xdrI13aQyYkS/O8IehZKqMzruw79bDuXuRdEJGXYkITPHtXLVtdczuGMDP71zgHlnf5mK4SLqd6FIAvmqQa6mc9CYKAn/y52n2sJOWHSp7qSShDwyPpfEli1b6O/vZ/bs2Q0P4X8VlmVx7bXX8oc//IEnnniC/fbbb6/O92YwPDxMIBDYw3VLEARisRhDQ0NvujDu3j61bZtgMMgzzzzDiSeeyNy5c1myZAnz5s3DsizuvfdefvKTn3D22Wc3do4f9Bni6+FNFca//OUvnHLKKa94bPHixRx22GGv+ruvFhsFTu96b4+/17F27VrOPvtsfv3rX/OJT3wCgI9//ONYlsWLL77IwoULufPOO7ngggs49NBDmT9/PgsWLKCzs/NtvTnHJMMkI07momGY6JUC5fwwK1asQBTFBnlnl3WZ3+UQM1yyyNa0s4Pcma2h6hYmYOkWA4UKQ8U6rWEPE5OOf2WmrJGt5Dl0bIxZoyIYFmzLVAh7ZMRajlR2mK7RY5k+vvVlCQdDRZXtmSoVzSmMNd3EskCWQUKkXC7y3z/6CbYgNmKzbr75Zu688072b4uSLmukiirxoIuWsJuyajFU0shWNEd6YNjER3avLt2iWNfJlDSqhklLQMQayY6M+5224T97nIZ9CsW66bBbR+ar06ZNQzctKpQYKmkYtiNzEEVojvgJekOU62ZDi1czTAASARfZska2aiAKAka+Qp9qMHVUFEvx4cL527gliY9N6cCnfJSfPfBXisUSD/7x94h6hVa/yF23/ifNzc0U6zrrBsoUazout5uaaGAFI0S9EoViiR3pEqKpM2DniJpxopEoOu4Gw1USBWRRQDdtdrPfRbcco/B/tlTbvn07Q6nUSFG8syGVGNPRyq3fuonLv3YLvXWJtd1pJo/tQpIEFEmkI+ppCPtfDbvuPXC++xs3biSdTjN79mz8fv8bvudfCZZl8dWvfpVFixbxxBNPMGnSpL0635vFaxH0/pXn2+4zRUEQME2T1tZWHnjgAebNm8ehhx7KP/7xDxYsWIBlWdx+++0888wze7RUP6xFEd5kYTz66KPJ5/P/0gs1NTUxPDy8x892OaE0Nzfv9fH3OqZOncrmzZtfpqkSRZGDDjqIgw46iG9+85ts3bq1MZe85pprmDp1aqNIvl1m57s/cIj5obMNy7LI5/Ok02k2btyIqqrE4/FGoQx5XExtc8y6S3UBUZDozddxSQ51f2IyiCgKrOotEPA4rcxcxRGyHzouzjFTEmxPe3hhzSZK5SoHTpvMuJYozf+UdlCs66zpL1LTLYfgYZus6itT1Uxawx70epX7f/8/5Ks2HZ3j+PpXLmmkg1x++eXceeedjE8maQ660U2LoMdpFadKGrmqhldxCp9blgh7ZCwbBgs1egs1TAsnsaRusF9rEJ/r5XMeZ3Fmo0gCqmHt4aiiGRbxgIv920L0FepUVROvYpMMOhZzuYpGoaqjSBIht8z4cX5W9xcZKNRxySIeW0MzTXxBL2XNpr9Qpyn40o5CEkXmTGijduxB/M9PvoeklcCoc8P1t9Ay8p3ozdWpqAZtYY8TRmxYjZzEkFvBFwzjlkTCURnL0ti+Yzs1VUf2hQiazXS1Jon7XfTla8gBJ01EMywKNaNh2bY75s6dy39+85svSwjRTIuc5eWM8y5hZ/8A0eZRKLIz0+yMeYl4FWcxolmve7/ats369evJZrPMnj37DdklvhZM0+TLX/4yjzzyCE888cS7kiDR1NREuVxG07TGrnEXN+DNPN8WLlzYWHhff/31PP300zzxxBNIkoRpmrS3t/PAAw9w3HHHMW/ePB5++GFOPPFEEonE+16K8lbiHTO6mzVrFkNDQ/T39zd+tmTJEkaNGoXX693r4+8HvJ7QWBAExo8fz5e//GWefPJJBgYGuOyyy1i3bh3HHnss06ZN4ytf+QpPPvkkuq6/rdcqiiKxWIxJkyZx6KGHctBBBxEKhejt7eXvf/87L7zwAms2biddqDIm7nfaPn4njDZb1akbFoZlMVjWcMkC8YCLiE+mXDfZlq6gaTr57o2M9pucdvQcPjKhhdYR2cAu2LbNmr4C6wZKdGcr/GNLlkfWZFjbX2IgXyeVLXDf//0fw1UDX6KdBV/8Elqogwuu/U+aOsbSN1IcU6kUfrdEyKuQrxlEvS4mJQNMbgmgm9AadhP1KVQ1A9UwaQ55mNwSZHZXmKCWoVYpY77CJH79jj5+++izrO4rka3o7MxWKamOAUJVMynUDdojXiY0+5nWFqAt6sarSBRGimJH1MPouJ+gx7Eo87tkPLKIRxIJ2Cq2ZRIJh5jQFCDiUxgua8iiQLqsopsWmmGxpTfNn+//HXIlhSUIGP4k19/1S17c1E2+ppGr6oQ8SuPzGdfkQxLAJQq0ht2EPAqJgBvB5SHU1MaBBx7IpClTCAZ8pIYGefrpp0lvW4NRytCbztNfqJGva7SF3YyKvbJed+7cuS+71/NVnWxVZ0JHkgP3m4w9Yt5gWo54X0BAH3EVei1YlsXatWvJ5XJvWVG89NJLeeyxx3jyySfftVilsWPHEovFWLp0aeNnK1euBGDMmDFv6BzDw8N8+ctfZtWqVYDTkcrlcpx66qkAjeI4ZswYLr74Yh555BHmzJkD0CiKlvX6C5MPA96xwhiJRPjc5z7HZZddxvDwMNu2beOGG27gvPPOe0uOf9AgCAKJRIIvfvGL3H///aRSKb773e+iqmpDYHvOOedw3333USqVeBs4VHtcSzAYZOzYscydO5fDDjuM1tZW+jM5Nm7cyLo1q+gbGERT60giBNwKxbpOqWbgEkVAwDBtBMGJCRrMl/n7sy/gcrmYO2c24YD3FVMOMhWNbZkahukIv01sypozi1JNm96hHMVClmjAy7RDjmVYk6lpFqYc4FP//lUCYw+kpyLwj9VbKNYNxsR9+BSJ/kKdVEl1jNCDLjyKhM8loZoWFc1xchkb9+OtDrLo1z/m17/4Met2DGBaL/2N123v48r/vIvv/+xXbNqwgYBHQjMs+gt10mUV1TQZHfcyMemnPeLB71YY3+SnI+qmoppEvQpjE36nLWzD6IRTZPyKiKVV8cgwpq2Jic0BuuJ+REFAlgTGj8hm8jWdnqEMv/zR3eR7NhLtnMgXL72WeDxBJpvja7f/kOc39GJYjrQCQBJEYn4XsYCbuF8h4nExNuEj4lNwyyKZiuMBq9oK08Z1cdjBB/Gxj32MiWNH0+rWsTPbqPasw1cdIi7VkN9Ep003nQeuJAqEfDI+RSJXcQpiuW6SKqlOuzrw6sk2lmU1cklnz56912xuwzC46KKLeOqpp3jiiScYO3bsXp1vbyAIAhdeeCFXXXUVfX19DA4OcuWVV3LGGWe84ffp9XoZO3YsfX19gLNA+fGPf8zatWv53Oc+B9Bgt06ZMoXbb7/9ZX6vH1RT8DeLd4yVClAul7ngggt48MEHkWWZM888k9tuu63xYe3t8Q8LTNPkmWeeaZid79y5k8MPP5wFCxYwb948Wlpa3pH5wI7hChsHS3jtOht70+xIlwkpYLh8KG4fOU1EEAVGx33Iokgy6CIqG7ywdjOHTGxhzv6TX/M6l/cWeHarkwRiWDaJgIuqarBj2NH+tYQ9+OrDKP4wPRWbg0ZFmdEZoaqZrBsoMZDNEzSKTJo4EbciMjEZIOCRyI6I3n0uiYBHRtUt6rpFRdXZOFShPeq0CPO5HHfcfjupbJ5YUwv33HgFnW0tDAwOccF/3EoqX6QpGuHMc88nGApj2zYuSWRqe4igW260XndlJ24aqrAlXWZVXwlFgKaQh7awm86ol6agi97hMlu3bWH1sESyKU4y6EYSBaqqwUBJ5bCxcU44oBkBgZ19g1x77TUM9nXT1DmOz/77VUzsSFIojFxzZphwyyguPP8c3L4gzUEPkiiQKass6ynQFfUyoTmAblr0ZGv05VVEwWJic4BkyCHirFz24h4t0d3b61u2bqW3p4c5c+Y07Ahfa/eWLqus6i3SFHDeU7GuM1BQ6clVSQTcTGkNMCbu28OzdneYpsmqVatQVZWZM2fudTScYRicf/75LF26lMcff/w9kTFoGAZf/vKX+c1vfoOmaZx00kncc889b4pUdMstt/DLX/6Sv/71r7S2tmKaJs8//zznnnsus2fP5pe//CX1ep358+fzmc98hvPPPx94udbxw459JuLvc+yat+xy3nnhhReYOXNmYy45efJrF5+9Qb6ms7KngFuWkCTYkiozkC1RqVTwGBV6SiaS4mH/jgidLTEUo866Ldtpb2/nuJnjXzF5fhd00+L+FQP05mr051XKqo5LltBMJw+wKegm4JZoDXnJ1XSwbQ4bH6M94mP7sJPKIQCTWoJEvE4MkiyJzOgMUawbpMsamm4R9SkNLV5ZNVjWXcDnkvCOXFs2l+W/vvM9htNDjPZbXHvN1Xzzlm+zs6YQSTRzwqdPx+vzg+CkxSuSwLz9WxrMykJNJ1/VqagGO7M1EGyqmsXObBXLtIkFXOzfGmQgX2btpq1MaolQdsVY0VdC002HOGHbjI77OG12B50xp/gsWbKE/7juOpqTSS67/mbKvBR8nM1lneJY1rjwnDOYOnUambIGtpNzOVisMyHhFECAbEVlZV+BoFtmXFOACUk/29et4Lrrr6c5mdyDRAMvMU+HUikuu/RSWltbyefz+P3+hm9vOBze477TTYs1/SUyFZWIx4UkQqFuYBg2+7UFHNnHq9ynpmmycuVKDMNgxowZe+0Eo+s655xzDuvWrePxxx+nra1tr873XsAuBunQ0BCXX345c+bM4YILLsDr9WKaJkuWLOG0007Dtm3cbjdjxoz5wCdk7A32FcYPEGzbZmBggAcffJBFixbx17/+lY6OjkYI81thdv7Pr9ebq7FjhJVaM0zKdQOfS6I94ka2dLb2Z0hl8xi1KoYNsViMg6eMYmJ7/DULdqqk8vj6FFXNoqoZ9BdVBBuyVR3LtpjY5McaaYUOlzQCXoVZXWFkUWTdQAkbm3LdYnzSR3KE0JMqqTQFXAxXnPmsIgnUdIuIV2G/1gB+t8zynjwbBkt4ZImgR0GRBDK5HL+759tkerY471sQ8Y+bzdEnn057Iop3ZGdYUw0GinX+337NTEj6GSrW2ZapopoW6ZLKQKHOpOYgXkVkWU+R4bJKRTWwDINcoUhLxMfY9iZEAQpVnUxVx7RsIl6Fg8dEmTM6SrGmk6vpeCSJ3i1rOWDSGOpykE3pMm0hp2galkVfapj12/uZf+gBjGvyk6vq1HVrpCA5uzVJECirJlvTFTyKyMRmxyrOxiYhqdzytat2k128FJ21pxzD+fkup6VMJtMgxe3y9I3H4yiKQlUz2Zl1mMyW5RjUd8W8Dc3kK8EwDFasWIFt28yYMWOv719N0zjrrLPYsmULjz/++F6nbryb2F1OsfuO71vf+hZPPfUUV1xxBUcddVSjo1YqlfjjH/9IMBhsqAtM0/zQddzeCPYVxg8wSqUSjzzyCIsWLeLhhx9GkqSG2flRRx31ps3OX/V16gbFuiOlCHokAi6p8SUt1jSeXbmensEsna3NuKwaZiWPx+NumJ2Hw+GXtXG6szVW9xeoqCaDRY18VUUQnGDgiEdxHFBEGBP3oRk2mmkxLuFQ9pdsz7EtU8WwLMI+hahXZkJTENM2Rxx+XATcL9H+B4p1xiT8xHwKa/qL7Mw6ocy6YZEIuJg7Oko9tZ1LL3tJJ3nuf3ybQSvMqJgX1bTJVjS6cxVM02ZyS4gJzX6yZY3mkJeoT2FLujwSBWZhmhZlzaRU19k0mCdXrDOmycfHprRjYbOsu0Bz2MPHxseQRRGPLLIjW8W2wS2L6KZNrqJhA9PaQoxt8rG2v4QwUtZ683XSZQ3DttivJcS0tiCt4ZfmVNaI7dtgoc7agRKSIDAu6W+kU+SrOrIk0OFR+epXXh6d9c9F8Z+xy9BiV0xapVIhGo02CqXo8jSMG15tlwjOzm758uVIksSBBx641w9wVVU588wz6e7u5rHHHtvr1I13E6+kMdy9yJ1xxhkMDg5yzTXXcOihh76igci+ovjq2FcYPyTQdZ2nnnqKBx54gMWLF78ps/N/FYZhNOZCM2bMaJAITNNkeHi4YXgONFpw8XgcWXbSOdb2Fwl7ZTJllZ3ZOrmqgaobjEn4mdISoDXkIeRVcMkC2zNVhkoahZpjWTdYqtMe9hL0ypRqBjY2E5IBWsJuOiN7LgiKdUfIL0tO0kNTwI1qmOiW5bA67Trf/9a19KYy2KILwTaJtY3i6M9djCF5GCiqZMt1KroFNiSDbvZrC1Ks6kxtC9EV89GTrzGQr1Os62xLVQh4ZfLFCusHivh9HrriQaa1hwh5JLakqhimxRGTEo3Q6PUDJQZKdTojDutXFkVquolmWnx0fJymgIvNI45EmunMY1vDHrwj5tr7t4deNr+raAZLdxYIuGXcu4kUTctmuKoyszOCWsq9zFXotYriK6FWqzXyRLPZLF6vt/F5RyKRV5xtaZrGsmXLcLvdTJ8+fa8f4PV6ndNPP53BwUEeffTRvU7deK/g3/7t3zjwwAO56KKLgJeKnWmanHrqqZRKJT71qU/x2c9+lmAw+KEwAH8rsK8wfghhWRarVq1qzCVXrlz5qmbn/yrq9TrLly/H5XIxffr0V50L7dpdpFIp0uk09XqdWCxGMBpnQHNj2k4CvYVNtqJS1SymtQXpiHobFm7gPMwLNZ1VfQWWdxcoqjqaCTXVRDctBGwmt4XoinrpiHixbJBFAcOy2ZGpkK1pYAuMTfhJBFwNlmxfKsNd37+H3GAP0ZYujvvEp1j40KMUigX8kQSHHHUcouIiX9GRJBFBAFl0AnYDboWWsJvJzUEs22ZLusy6wTI7MxV8okG2WEUVPQiGiuz2ML0zyoSkn53DNUp1nY9OSBAU6uzs7iXnaaE84oTTHHI39JKDhTpNATcfnRCnWNdZ1p0nGXSPFDunmAwW63TFvExI7kniUA2Tpd0FZFF4Scc68vOyajKrK4zfLbNmzRouufTSxvG777qLadOm/Uv3hWEYjTzRTCaDZVkNfWw8HsflcqGqKsuWLcPn870l2t1arcZpp51GLpfjz3/+M7FYbK/O915BsVjkyiuvJBKJcOuttzbaqbuKo2EYXH311WzatIlisciPfvQjWlpa3pLAgg869hXGDzl2RV8tWrSIhQsX8ve//50JEyY05pKzZs160w+mUqnE8uXLG5mRb+b3K5VKYyfZlylQxIfsCxIORYiF/YyO+/ZoC/4znt2WZd1AiZJmkCk5hBNFFiipBlGPQmvYgzXitenkIeoUagZtEQ/ZipMa73NLBN0y5XKJ//nVLxguVIhFQpx55pnoopdMocAfH3mSkqkg+wJMHDcORVEIeRWagi78ikSpbuKWBWJ+F9Pbw0R8CpmyysNrBljfmycgGnQ0R9iRyrNhy3Zkl5ePTJ/AkVNa2TBYoVw3OKTTxU9+9EOGVIH9DltAPB7D75LpjHlpCroRgGxFJ+JTOLAjhCgKbB6qvOzvM1zRiPoU9m9/uW3iplSJncN1mgIuFEnEsCxSJUenuF9rkHQ6vdc7xleDbdsUi8XGbrJcLhMMBqnVaoRCIQ444IC93ilWKhU++9nPUqvVePjhh/c6dePdxCvt8h577DFOOukkHn/8cT7ykZfCt3ffOa5cuZK7776bF154AVEUufbaaxvaxn14Zezj575BnHvuuQiCsMd/v/vd7xrHs9ksn/nMZwiHw7S2tnLjjTfu8fuvd/zdgiAIjBo1iksuuYTHHnuMoaEhrr32Wrq7uznxxBOZNGkSl156KY8++iiqqr7u+TKZDC+88AKdnZ1MmTLlTRdVv9/P6NGjmTNnDvOO/hhHTOuiw6OjD22i3ruW4uBOstnsqwqRA27JEddXDRIBF21RD3G/m6jHTbFukK/p2NiUVJNtmQpr+8s0BVxMbgkS97vIVFTWD5QYLNbZ2jtEyvLjbergnLPPxFZ8WLaFLXuYOedgfAoYtQqWVsMli0gCxH0uBEHA75Hwu5wkjlxVI112IqqapRpe0aClKUoo4KMzEUZxedB0g2UvLmXnUA7TtggrBvf89OcMam580Ramd8WI+d2IgkC6rFGqOQXd75bwupydqleREAT20Fvato1qWIQ8r0xaGRXz0RJ2ka1qDBTrZMo6TUEXYxL+PYpiW2srd991F22trQ1XoVQq9aY+23+GIAiEw2HGjRvHwQcfzOzZs6nVakiSRC6X45lnnmHDhg1kMhlM03zT5y+Xy5xyyilomsYjjzzyvi6K8JK1267xA8Cxxx7LhRdeyD333EOxWGz8XJIkbNtGkiRmzpzJL37xC+677z6+//3v88lPfvLduPz3FfbtGN8g5s+fz1lnncWnP/3pVzx+8sknI0kSP/zhDxtZkRdccEEjK/L1jr8XUa/XefLJJxtzyWKxyLHHHsv8+fNf0ex88+bNdHd3vyWhy/8M0zQbLbh0Oo1lWQ17ul1zSYBMWePBVYOs7C3QFfciCyLFuoFl2ViCTUfEy4Gdjk/ptkyFfM2gLeRmv9YQO4arvLgzh2qYtEd8BDwSvd07kf0RJnck6MnWqRsmvYU6gm1TrNWolqtEI1Fawm4yZZ22sBOA7FFEQl6ZiSNzTcMwGejeytZUmfVqBMMGYSR7UFXrLFmxBqOSJybUOfuU/8f9v7yH/oKGr2MSF3/hVDqa42waqrB2sIRpWgQ8MuObAiQCLmRR4MCOMH63xLqBEqmSRtDtpNsX6wYhr9xIN3klWLbTht5laRfxKgxn0q/IPn01VureolqtsnTp0kaXYZcd2q6Wq67rxGKxhmby9dJoisUip5xyCrIss3jx4r1O3XgvwLZtPv3pTyNJEkcccUTj2fHkk09y88038+Mf/5hRo0a9TJP4ShrFfbrF18a+wvgGMXPmTH7wgx+8Yor3By1L8pVgWRYvvPBCw1Rg48aNHHrooSxYsICPf/zj3HbbbSxfvpyHHnrobV+Z7856TKfTVKvVxkOzqamJLVmVhSsGG5mDAbdMU9BFvqrTEfGyX1sQAYFtwxVSBRWXIjKlJUhfvk6qVKdQ02nelUbvkVnRU8CyoDdfx6OIFGoOA9ewLEzLpq5bBNwiZdXE71bwKCJNfoWZo6LM6orgEm1WrFjBcNXAjnbRnVPpK9QREKgZJgGXSNxt8eff/Ih8zwZEyzl/onM8p174VSZ3Njdeb3OqwtZ0BUGAqa0hAm6JUXEvo2I+BEGgrpv05utkShoWNjGfQkfU22DhvlHsrpN8LR3jf37zm3udbF8ul1m6dCmtra1MmDDhZe3CXVFpu1quxWKRYDDYIPAEg8E9fqdQKPDJT34Sv9/PwoUL9zp1472EwcFB7rvvPm688UaOPvpoTjzxRE499VQ+97nPoWkaf/jDH97tS/xAYF9hfIPo6upCVVVyuRzxeJzPf/7zfPOb38Tj8ex11uR7OTLrlWDbNlu3buWBBx5g4cKF/OMf/2g4EZ177rlMmzbtHV2NVioVMpkMqVSKQqGAx+dnyApSl3wkQo4XqWXbLOsuMr7Zx6ioI+vIVTVW9ZXwKRIHdoboyVbpydeJeBUmNvvxKk4x2ThUplDTWD9YIuCWKasGZdWiJeTCsJycwpBbplDX6Yz6iPsVRsf9jE340DStQUISEmMoqRY+t8jWdIV0Uce0LXTL5pCxUXzlfi7fLTrr5tu+Qz3QRtAtN8wQLNtia7pC3O9mdMJH0CMT9rw8fUY3LWzYI9PwzWLJkiUvMwPfhVQqxfbt2/e6KJZKJZYuXUpHR8cbJn1pmtbQS2YyGWRZ5qmnnmLMmDEcdthhnH766cRiMRYuXPi+8VF+sxgcHOSOO+5g/fr1FItFLrvsMm677TbuuOMODj744Hf78t73eO/nNb1H8NRTT+FyuYhEIqxYsYIvfvGLqKrK3Xff/YHOknwl7DI7P+uss7j//vuZNWsWp59+Ok888QTHHHMMiUSiQd459NBD99qp5PXg9/vx+/2MGjWq8dCkb4i1vTsYHpAIhULEoxEmJn0gCNR0E68iOQn1XgmXJJApa6iWjY0jt9hVFEt1Y2Tm5qWsOnpNURBxyTZ1wyLglvApEqPiPkbFvbRHvHhkybFyq1ZZtmwZ4XCYqVOn8uIIA9Qry0xpCdEVNTAsm1xVI2jXuOXWW/Z4X3fdfiuXXHczuaoXj2IiiY4gvzXsZWpb8DV3gcpeFMRdeK2il0wm97qFWigUWL58OaNGjXrDRtkALpeLtrY22traGi3X++67j5/97GekUikSiQRnnnkm6XT6PWH19nagpaWFb33rWxiGwVVXXcUvfvELVq1axSOPPMLBBx+8T46xl9i3YxzBm82aXLx4MZ///OcpFAr87ne/4+abb2644YOzqnW73Wzfvp3nnnvuNY+PHj36bXlPbyfq9ToHHHAA06dP51e/+lVjZV6tVnnsscdYuHAhDz30ELquc9xxxzF//nyOPfbYd3TWU1N1dg6kSWWGKeeHkbDR3GEsdxCPL4Df46Ip6KIp4KJu2Ni2Tbaik6mojMQj4lFExsS9xANulnXnqWkWougUzFJdJ1vRGdPkY3ZXlOaQuyFYL5VKLFu2jJaWFiZOnIggCGxOldkxXKNtN9aoalh0D6b57d3fItW342VC+tbWNq7+xi0YSgDdtIn5HWbtm22NvteQz+dZvnw5Y8eOZdSoUXt9vnQ6zYIFC0gkEhx33HE88sgjPP3000ydOpW77rqLww8//C246vcutmzZwkMPPcTXv/51Hn/88T1yFffhzWNfYfwXsXHjRqZMmYKmafztb3/jC1/4wh6t0v7+ftrb26lWqzzzzDOvefz92u556qmnOPTQQ1+1bbq72fmiRYvo7u7miCOOYP78+e+o2Tm8JA1Ip9N0D6Qolqs0xSJ0tjruO7s+g11ElLJqIgoQ8igERxidffk6W0YMzSVRQDctIj6Fqa1BfLvpAHO5HCtWrGD06NGMHj268R7LqsGa/hIV1cDvkjEsm8HMMP/zo++S3bmO9tcgudxxxx0kk8kPxC4gm82yYsUKJkyYQGdn516fb2hoiBNOOIFJkybx29/+tmEwvku3OHfu3De1I30/49JLL2W//fbjggsu2Ldr3AvsK4z/Ih544AG+8pWvsGXLFvL5PE1NTezcubNhSHz//fdz+eWXs2PHjtc9/mHAq5mdL1iwgPnz57+tZuevhGq12iDv5PN5AoFAg7zzz2SO3ZGragxXdDTDIuxVSASUhpAenNnbmjVrmDhxIh0dHS/7/VLdoL9QI1c1kEWBwW3rufPmr9PSlHjbSS7vBWQyGVatWsWkSZMaRLS9weDgIPPnz2f69On8+te/ftvb9u91XHnllWzdupX77rvv3b6U9zX2FcY3gG3btrFw4UJOOukk2traeOGFFzjzzDO58sorG5TpL3zhC1SrVX74wx9SKBQ46aSTOPXUU7n22mvf0PEPE3aZnS9atKhhdt7Z2cm8efM44YQTOOigg95Ss/PXg67rDcbjLjJHU1MTyWSSaDT6holEfX19bNy4kWnTpr3u/M20bAQBREF4R0gu7wWkUilWr179lsl5+vv7mTdvHnPmzOGXv/zlO3rPvFdx4403sm7dOn71q1+9rqRlH14d+wrjG0AqleKcc85hyZIlFItFxo0bx2WXXbZHSPK+LMl/HcVicQ+zc1mW3xaz8zcCy7L20EsahtGQBSQSiVfckdi2zY4dO9ixYwcHHHDAB8Zy7K3E0NAQa9asYf/9939LdI/d3d3Mnz+fww47jJ/97Gf7iiLOnHXq1Kk89NBDzJkz592+nPc19hXGfXhPYZfZ+f3338/ixYtJpVINs/N58+YRj792XNVbCdu2KZVKpNNpUqkUlUqFSCTSSAXxer3Yts2mTZsYHBxk5syZHwgh+VuN/v5+NmzYwP77709TU9Nen2/Hjh3MmzePY445hh/96Ef7Fpe7oVarvW85C+8l7CuM+/CehWVZrFy5skHeWbVqFR/5yEcaUpCxY8e+o3PJWq3W2Enmcjn8fj+2bWMYBrNmzcLv979j1/J+QW9vL5s2beKAAw54mWTpX8HWrVtZsGABxx9/PN///vf3FcV9eFuwzxNoH96zEEWRGTNm8PWvf52lS5eydetWPv3pTzfo6HPnzuXrX/86L7744qt6p76V8Hq9dHV1MWvWrIZ8R1VVDMNg6dKlrFu37l/29fwgoru7m82bNzNjxoy3pChu2rSJ448/nhNPPJF77rnnLS2KH1Qv5H3417CvMb8P7wvsMju/9NJLueSSS8jn8zz00EMsWrSIE044gUAg0NhJfuxjH3tbiQeaprFq1SoURWH27NkN0+t0Os369evRdb0RpZRIJBrygQ8TduzYwfbt25k5c+ZbEnO0YcMG5s+fz2mnncZtt932ljsrDQwM8L//+7+v6oV87rnnIkkS27Zta3gdJ5PJBvnu9Y7vw/sL+1qp+/C+R71e569//SuLFi3iwQcfpFwuc8wxx7BgwQKOO+44wuHwW9ZyrdfrLFu2DL/fz7Rp0162a9nl67krX7JcLhOJRBpSkHeSSPRuwLZttm3bRk9PDzNnznxLXJ3WrVvXMPG/+eab3xa7wQ+7F/I+7Il9hXEfPlCwLIvnn3++YXa+adMmDjvssEYIc2dn579cJMvlMsuWLSORSDBlypQ3dJ56vd6YS2azWXw+X0MKEgqFPlACbNu22bJlC/39/cyaNestMe9evXo1CxYs4Pzzz+cb3/jG2+bBu88LeR92x74Z4z40oKoq559/PolEgng8zkUXXYSu6+/2Zb0piKLIwQcfzM0338zq1atZu3Ytxx9/PAsXLmTatGkcdthhfOtb32LVqlVvai5ZKBR48cUXaWtre8NFEcDj8dDZ2cnMmTM54ogjGDduXGPX+fe//51169aRTqff93NJ27bZuHEjAwMDzJ49+y0piitWrGDevHlcdNFF3HTTTW+rMf1TTz3FihUrKBQK3HfffSxevJgrr7wSYK+9kPfh/Yd9hfE9CMMw6O/vB9jj4f12PzyvueYa1q9fz8qVK1mzZg0bN27kuuuue1tf8+2EIAhMmDCBK6+8kr/97W8MDAxwySWXsHr1ao4++mj233//xrHXWgBkMhmWLl3K2LFjGT9+/L+8y5NlmebmZvbff38OP/xw9t9/fyRJYsOGDTz55JOsWLGC/v5+NE37V9/yu4JdrkbpdJo5c+a8JezcpUuXMn/+fK644gpuuOGGvd5Z/+UvfyESibzif08//TSjRo2itbUVr9fLRz7yEW677TZ+9atfAbzia+9qtMnyy5NN/vn4Prz/sK+V+h5EpVJh+vTp3HHHHXziE594R17TsiwikQiPPPIIhxxyCAArV67kox/9KLlc7gNHi69UKjz22GMsWrSIxYsXYxgGxx13HAsWLOCYY45p6BF/+ctfEgwGOeSQQ2hpaXlbrmXXXHJXy7VUKhEOhxtzyfeyDMSyLNatW0ehUGDWrFl4PJ7X/6XXwZIlSzj55JO59tpr+cpXvvKutJv3eSF/uLFvx/gehN/v55Of/CTPPfdc42eXXnopt912G9VqdY9/u2td849//IP169f/y6+5ZcsWKpUKs2fPbvxs+vTp6Lr+gSQQ+P1+TjrpJH7+85/T39/PAw88QFtbGzfeeCOjRo3i5JNP5pRTTuGKK67A6/W+bUURnB1JMBhk7NixzJ07l8MOO4zW1lay2SzPPvsszzzzDJs3byafz/NeWsdalsWaNWsoFovMnj37LSmKzzzzDCeddBJf+9rX3rWiCLB+/XrGjh2LLMvMmjWLoaGhRhcHnOI9atQovF7v6x7fh/cf9hXG9yiOOOIIHnvsMXp7e7nooot45JFHOOigg/5/e/ceFWP+xwH83W0KlZQk12rJ/VItVpJLWHTsIbusDmKztl1h5TixltiftcuJXbcVuyxZl5zlqM2dVHJZqwuxQnIJG5mapgszNfP8/nDm2Wdo3ZrS8H6d4+w5z3eanmdqn3fP832+n4/eU4266vmHDx9GaGgo9u/fD61WC0EQXvoEKpfLYW1trbe0wMTEBPb29rh3757Bjqs2Mjc3h6+vL5YtW4bLly/j7NmzePToEY4cOQK1Wo2lS5ciMjISly5dqpFgsrKyQrNmzfTmJVUqFTIyMpCUlISLFy/i/v37r3VeUqvV4vz58ygrK8O7775rkOUxx48fR0BAAL799lt8+eWXNRaKOTk5+OGHH3D9+nWoVCqkpKQgLCwMM2fOBADY2dkhMDAQ06dPh1wuR05ODiIiIsSSkM8bJ+PDYKylvLy80KhRI4wePRoFBQU4cuQIfH199U6GJiYmuH37NsLCwhAcHIywsDCYmpqKC5Rfxn+9XhCEt2qeRKPRYMWKFbh+/TrOnz+PW7duYcKECTh16hR69eoFDw8PfPXVVzh58mSNBJNuXrJjx47w9fVFly5dYG5ujitXriAxMRHp6em4c+cOVCpVte+LjkajQUZGBlQqFby8vAyyTjMxMREffvghlixZgilTptTolaK1tTUSEhLQo0cP1K9fH5999hlmz56ttwZxzZo1sLS0hJubG7p16wY/Pz+Eh4e/8DgZF84x1jK6q8AdO3YgMDAQgwcPxpYtW8Sn3ExMTMT/FhcXY8aMGcjLy0N8fDyAx7eiDh8+jHnz5r3UU3zXrl2Du7s7Hj58KJ7otFot6tWrh7S0NLRr165ajre2SUhIwPTp07F///6n2kYplUrs378fcXFx2L9//2stdi4IAkpLS8V5SaVSCVtbW715yeoIl4qKCmRkZEAQBHh4eBjkj6ajR49izJgxWLFiBT755JM3agkLGScGYy2jUqmwdu1arFmzBuPHj0dCQgKOHTtW6Wt37NiBtWvXYtGiRejduzcAYNSoUcjLy0NycjK0Wi1MTU2Rn5//VPFm6Y9dF7aNGjVCXFwcevbsCQBIT0+Ht7c3CgsLDTJ/ZCzUavVzr4LKy8uRnJwsFjvPz89H//79xTqeNVnsHHj8eyNdL2llZSWGpJ2dnUH2pby8HOnp6TAzM0PXrl0N8kDWgQMHMH78ePH3naFItQGDsRa5d+8eJk6cCOBxw9HWrVtj5MiR2Lx5M9q2bav32rKyMoSHh+Phw4dYv369eHXo6OiIlStXYsyYMdBoNDAzM8OQIUPg7OyMjRs3oqSkBDKZTO/Er/sVWLBgAY4dO4bt27fDzMwMY8eOhZubG9avX19Dn4Bx0mq1yMjIEIsKvO5i5xqNBnK5XAxKAGLrLAcHh1e6yisvL0daWhpkMhk6d+5skFCMj4/HxIkT8fPPP2PMmDEMRao13p7JIyOg1WrRvXt3BAcHo3nz5gAezzGlpKSgbdu20Gq14vxhZmYmbt26hREjRoihmJmZCaVSiT59+gCAePK6dOkSxo4dCwBITk7Gjh07MGzYMKjVanh7e8PV1RUAMG/ePCgUCnTu3BlqtRojRozA8uXLa/pjMDqmpqbw9PSEp6cnFixYgJs3b4odQSIiIuDu7i6GpKenZ7UuVAce/9wbNWqERo0aQRAEFBUV4f79+8jOzsaFCxdgb28vXk2+yEMzarUaqampqFu3Ljp16mSQ/d+zZw8+/fRTbNy4EaNHj67y+xEZEq8Ya7nIyEikpKQgJiYGlpaW4vxiTEwMNm/ejIiICLG+48yZM/HXX3/p3UZNTk5GYGAgkpOT4erqijVr1mD27NkICgpCXl4eDh48iBkzZuB///sf7t27BycnJ/F7S9+jc+fOsLOze02fgnESBAGFhYVisfODBw/C1tYWQ4YMqZFi55WRzksWFRXBxsZG7C9Z2bykrkqPjY0NOnToUOVQFAQBu3fvRkhICKKjozFy5MgqvR9RdWAw1iK6H8WTJyddySldKAJAdHQ0NmzYgH379okLwN3d3TFt2jSEhoaioqIC5ubmmDJlCnJzc7F7924UFRVh8uTJKC0tRVxcHGQyGWJiYhASEoLw8HAcOnQImZmZCAoKwoIFC8SyXgEBAejVq5f4+Dq9Gl2x89jYWMTHx6OkpAQDBw6Ev7+/wYudvwi1Wi2GpFwuh6Wlpd68pEqlQmpqKho0aID27dtXed8EQcDOnTsxdepUbN26tcaKVxC9LC7XqEUqW2YhCIJeKOpKxCmVShQXF4uhqFQqodFoxL/odfNIsbGxGDRoEMzNzXHt2jXcvXsXU6ZMEecYNRoNBEHAnTt3EBsbi+3btyMxMRF79+4V9yE0NBS///57tR//m87KygpDhw7FunXrkJubi4MHD6J169aIjIyEi4sLhg0bhqioKOTm5tbIekmZTIamTZuia9eu6Nu3L9q0aQONRoPMzEwkJSXh5MmTqFOnDtzd3Q0Situ2bcPUqVMRExPDUKRajcFYy+lOSE+emO7evSs+kKPRaGBra4ugoCD88ssvOHv2LLKysjBu3DgUFhaib9++AICLFy9CrVajX79+4vukpqZi6NChCA8Ph42NDQYMGAALCwu9qju3b98WK+7UREPgt4G02PmFCxfEYud79uxBhw4dxGLnmZmZNfKZm5mZwdHREe3bt4eXlxdMTExgbW0NlUqFpKQkpKWlITc3F48ePXrp9xYEAdHR0QgLC8OuXbvg7+9fDUdAZDgMRiOjuyLs3r07iouLUVpaKj5kM2nSJPTq1Qv+/v749ddfkZ2djb59+8LV1RUKhUJcj6i7RapQKHD16lV06tRJb83ezZs3xSUbute1b98eeXl51f7gyNvoyWLnd+7cQWhoKDIzM9G/f/8XLnZuCMXFxUhNTUWzZs3QvXt3eHt7o2fPnrC3t0deXh5SUlJw+vRp5OTkoLi4+LlXtoIgYMOGDQgPD0dsbCzef//9at1/IkPgU6lGqkuXLjh//jyKiorE26lNmjTBqlWrsGrVKjx8+BAJCQkoKysTF+mfOHEC06dPF9/jzJkzKC8vR/v27cVt586dg0ql0quZamFhAYVCUauLWb8pTExM4OTkhODgYAQHB6O0tBSHDh1CXFwcgoKCUFFRgcGDB8Pf3x8DBw40SHsnHaVSibS0NLRo0QJubm7i9nr16qFevXpwcXGBWq3GgwcPkJ+fjxs3bsDCwkKcl2zQoIHeH06CICAqKgrffPMN4uLixDsXRLUdg9EICYIAV1dXpKam6p0YtVottFotzM3NUadOHb1bVvb29njvvfcwaNAgcVtSUhIcHR3RoUMHcdu2bdvg6ekpXkGWlZXhxo0bqFu3rthxgmqOrqD8iBEjUFFRgRMnTiA2NhYLFy7EpEmT0LdvX/j7+2Po0KFwcnJ65blAhUKB9PR0uLm5oWXLlv/5OplMhiZNmqBJkybQaDQoKChAfn4+Lly4AK1Wi7y8PJSUlGDEiBHYvn07vvvuO+zduxc+Pj6v+hEQ1TjeFzNCupNfw4YN9SrSmJqa6i3els5Nubi44KeffoKzszOAx/OSubm5aNiwod6JcN++ffjggw/Eh3MUCgXOnDmjdwVZ2yxatEh8cEn37/vvvwfw/ObLxtSc2dzcHH369MHy5cvFYuc+Pj7YsmUL3N3d4efnh2XLliErK+ulHt4pKChAWloaWrVq9cxQfJJ0XtLX1xeenp5QKBT48ccf4erqiq+//hrBwcFo0aLFqxwu0WvDYHyDSW9rPfkAh5mZGaKjozF37lxYWFgAAG7duoWLFy+KBQKAx7dbHzx4gFGjRtXMTr+Cf/75B0uXLhW7igiCgNmzZwN4fvNlY23ObGJigg4dOmDu3Lk4ffo0bt68iaCgIJw4cQLe3t7w8PDA3LlzcerUqWcWO5fL5cjIyECbNm3EohKvuj/169dHSEgIgoKCYG1tjdDQUKSnp+Odd96Bp6cnVqxY8crvT1STuI7xLSVdE6lTWFiI3bt3Y8yYMahbty5yc3OxePFiFBcX47fffntNe/p8AQEBGD169FMVVJ7XfNnExOSNa84sCAKKi4v1ip1bWFhg8ODBGDZsGPr16yf2CNy1axcAwNvbW7yTUNXvvXjxYqxbtw4HDx6El5cXgMdXpPv27UNJSQlCQkKq/H2IqhuDkZ6iq3gzf/58pKWlYdasWXpXkbWNr68vLl26BKVSCWtrawwfPhyRkZHIz89Hu3bt9DqGCIKAunXr4syZM7C0tHzmeKdOnV7nYRmEWq1GcnIy9uzZg/j4eDx48AD9+/eHnZ0ddu7ciaioKIPcDdBqtfjmm2+wadMmHD58GF26dDHA3hO9HryVSiLd7VZTU1OcPn0a69evx6RJk2p1KAJATEwM0tLSUFRUhMTERFy6dAnjx49/bvPlt6E5s0wmw4ABA7B69Wrk5OQgKSkJpqam2Lp1K8rLy7Fx40asXLkSOTk5r1xUQKvVYt68eYiOjkZCQgJDkYweg5FEujnJkydPYvTo0Zg7dy6GDx/+enfqBTg7O6N58+awsrJCp06dsH79euzdu/c/F8brmi+/bc2ZTU1NkZ6ejqNHj+LAgQPIzs5GQEAADh06BA8PD/To0QMLFy5EamrqCxcV0Gq1mDNnDnbu3Iljx46hY8eO1XwURNWPt1JJj27u8erVq2jduvXr3p1XolKpYGVlhezs7Gc2X5bJZG9Vc+Zr166hW7duiI2NFft3AvrFzmNjY3Ho0CGx2PmwYcPQu3fvSouda7VazJo1C/Hx8Th69Cjc3d1r8nCIqg2Dkd44GRkZ8PHxQX5+Plq0aPGfzZctLS3fuubMBQUFsLe3f+ZrdMUh4uLi8Mcff6C0tPSpYudarRYzZszAkSNHcOTIEbRq1aqGjoCo+jEYyaiVlJQgMjISgYGBaNmyJbKyshAcHAw/Pz8sWbIEERERz2y+/Lzxt51Go8GZM2fE/pLZ2dnw8fFBWVkZ8vLycOzYMbGfJ9EbQyAyYo8ePRI+/vhjoXHjxoJMJhPc3NyExYsXCxUVFYIgCEJ5ebkwbdo0wcHBQbCxsRHGjRsnFBcXi1//vHH6l1arFS5fvizMnz9fcHBwEC5fvmyw9757967g4+Mj9OnT56kxuVwufPTRR4Ktra3QuHFjYcGCBQYdJ3oSrxiJ6LU6fvw4xo8fDw8PDxQUFCAxMVFvPCAgAGZmZoiKikJhYSFGjhyJkJAQfP755wYZJ3oSg5GIXquIiAgMGTIEWVlZ2LRpk14w3r9/H87Ozrh16xaaNm0K4HGP0Tlz5uDvv/+u8jhRZd68Z9KJyKgsXLgQAJCVlfXUWEZGBpydncVQA4AePXogKysLSqWyyuO2trbVeGRkrLiOkYhqLblcDgcHB71tDg4OEAQB9+/fr/I4UWUYjERUrY4ePQo7O7tK/6WkpDzzaysrwqCb/fmvIg0vM05UGf5mEFG18vPzg0KheKWvdXR0hFwu19v24MEDAICTk1OVx4kqwytGIqq1vLy8cO/ePdy9e1fc9ueff6Jly5aoU6dOlceJKsNgJKpllEolRo4cCRcXF73tVW26bExNmXXs7OwQGBiI6dOnQy6XIycnBxEREZg8ebJBxokqw2AkqkUuXryIHj16iM2jparadNlYmzKvWbMGlpaWcHNzQ7du3eDn54fw8HCDjRM9iesYiWqR1atXo2XLlrCxscGECRNw48YNAFVvuvwmNmUmqi4MRqJaKDExUS8Yr1y5UqWmy29DU2YiQ+GtVCIjUNWmy29DU2YiQ2EwEhmB5zVVruo4Ef2L/0cQGQFHR0eUlJRArVbrNVUuLCyEk5MTZDJZlcaJ6F+8YiQyAm5ubrC3t0dqaqq47dy5cwAAV1fXKo8T0b8YjERGwMTEBF988QXCw8Nx584d5OXlYdasWRg3bhysrKyqPE5E/+KtVCIjMW/ePCgUCnTp0gVqtRrDhw/H8uXLDTZORI9xuQYREZEEb6USERFJMBiJiIgkGIxEREQSDEYiIiIJBiMREZEEg5GIiEiCwUhERCTBYCQiIpJgMBIREUkwGImIiCQYjERERBIMRiIiIgkGIxERkQSDkYiISILBSEREJMFgJCIikmAwEhERSTAYiYiIJBiMREREEgxGIiIiCQYjERGRBIORiIhIgsFIREQkwWAkIiKSYDASERFJMBiJiIgkGIxEREQSDEYiIiIJBiMREZEEg5GIiEiCwUhERCTBYCQiIpJgMBIREUkwGImIiCQYjERERBIMRiIiIgkGIxERkQSDkYiISILBSEREJMFgJCIikmAwEhERSTAYiYiIJBiMREREEgxGIiIiCQYjERGRBIORiIhIgsFIREQkwWAkIiKSYDASERFJMBiJiIgkGIxEREQSDEYiIiIJBiMREZEEg5GIiEiCwUhERCTBYCQiIpJgMBIREUkwGImIiCQYjERERBIMRiIiIgkGIxERkQSDkYiISILBSEREJMFgJCIikmAwEhERSTAYiYiIJBiMREREEgxGIiIiCQYjERGRBIORiIhIgsFIREQkwWAkIiKSYDASERFJMBiJiIgkGIxEREQSDEYiIiIJBiMREZEEg5GIiEiCwUhERCTBYCQiIpJgMBIREUn8H5e/1FRyRNEGAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xyz = np.column_stack([xy, np.zeros(xy.shape[0])]) * b2.meter\n", + "spikes = cleo.ephys.SortedSpiking(r_perfect_detection=40 * b2.um, r_half_detection=80 * b2.um)\n", + "probe = cleo.ephys.Probe(coords=xyz, signals=[spikes])\n", + "sim.inject(probe, neurons)\n", + "cleo.viz.plot(neurons, devices=[probe])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# sigma_ext = 0.05\n", + "# neurons.w_external_factor = rng.lognormal(0, sigma_ext, neurons.N) / np.exp(sigma_ext**2 / 2)\n", + "# plt.figure()\n", + "# plt.hist(neurons.w_external_factor)\n", + "# print(np.exp(sigma_ext**2 / 2))\n", + "# neurons.w_external_factor = 1\n", + "# w_external = 0.1 * b2.mV\n", + "# w0 = 0.78 * b2.mV\n", + "# w0 = 0 * b2.mV\n", + "# J_excit = w0\n", + "# J_inhib = -g * w0\n", + "sim.set_io_processor(cleo.ioproc.RecordOnlyProcessor(sample_period_ms=1))\n", + "sim.run(5 * b2.second)\n", + "plt.figure()\n", + "plt.scatter(spikes.t_ms, spikes.i, s=0.2)\n", + "sim.reset()\n", + "# plt.xlim(0, 10000)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Optogenetics" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING /home/kyle/Dropbox (GaTech)/projects/cleo/cleo/light/light_dependence.py:88: UserWarning: λ = 590.0 nm is outside the range of the action spectrum data for ChR2(H134R). Assuming ε = 0.\n", + " warnings.warn(\n", + " [py.warnings]\n" + ] + }, + { + "data": { + "text/plain": [ + "CLSimulator(io_processor=RecordOnlyProcessor(sample_period_ms=1, sampling='fixed', processing='parallel'), devices={BansalThreeStatePump(name='eNpHR3.0', save_history=True, on_pre='', spectrum=[(390, 0.162), (405, 0.239), (430, 0.255), (445, 0.255), (470, 0.371), (495, 0.554), (520, 0.716), (542.5, 0.84), (560, 0.93), (590, 1), (630, 0.385)], required_vars=[('Iopto', amp), ('v', volt)], Gd=25. * hertz, Gr=50. * hertz, ka=msecond ** -1, p=0.7, q=0.1, phim=1.2e+24 * (second ** -1) / (meter ** 2), E=-0.4 * volt, g0=22.34 * nsiemens, a=2.e+08 * metre ** -3 * second ** -1 * amp ** -1 * mole, b=12, vartheta_max=5. * katal / (metre ** 3), kd=16. * mmolar, g_Cl=2.3 * nsiemens, Cl_out=124. * mmolar, Psi0=4.4286 * katal / (metre ** 3), E_Cl0=-70. * mvolt, vmin=-0.4 * volt, vmax=50. * mvolt, model='\\n dP0/dt = Gr*P6 - Ga*P0 : 1 (clock-driven)\\n dP4/dt = Ga*P0 - Gd*P4 : 1 (clock-driven)\\n P6 = 1 - P0 - P4 : 1\\n\\n Theta = int(phi_pre > 0*phi_pre) : 1\\n Hp = Theta * phi_pre**p/(phi_pre**p + phim**p) : 1\\n Ga = ka*Hp : hertz\\n\\n fphi = P4 : 1\\n dCl_in/dt = a*(I_i + b*I_Cl_leak) : mmolar (clock-driven)\\n E_Cl = -26.67*mV * log(Cl_out/Cl_in) : volt\\n I_Cl_leak = g_Cl * (E_Cl0 - E_Cl) : ampere\\n\\n Psi = vartheta_max*Cl_out / (kd + Cl_out) / Psi0 : 1\\n I_i = g0*fphi*Psi*rho_rel * (clip(V_VAR_NAME_post, vmin, vmax)-E) : ampere\\n\\n IOPTO_VAR_NAME_post = -(I_i + I_Cl_leak) : ampere (summed)\\n rho_rel : 1'), Probe(name='Probe', save_history=True, signals=[SortedSpiking(name='SortedSpiking', brian_objects={}, probe=..., r_perfect_detection=40. * umetre, r_half_detection=80. * umetre, cutoff_probability=0.01)], probe=NOTHING), BansalFourStateOpsin(name='ChR2(H134R)', save_history=True, on_pre='', spectrum=[(380, 0.34), (402, 0.65), (440, 0.96), (450, 1), (480, 0.57), (500, 0.22), (520, 0.06), (540, 0.01)], required_vars=[('Iopto', amp), ('v', volt)], Gd1=45. * hertz, Gd2=10. * hertz, Gr0=100. * mhertz, g0=37.2 * nsiemens, phim=1.e+22 * (second ** -1) / (meter ** 2), k1=300. * hertz, k2=120. * hertz, Gf0=14. * hertz, Gb0=10. * hertz, kf=10. * hertz, kb=10. * hertz, gamma=0.05, p=1, q=1, E=0. * volt, model='\\n dC1/dt = Gd1*O1 + Gr0*C2 - Ga1*C1 : 1 (clock-driven)\\n dO1/dt = Ga1*C1 + Gb*O2 - (Gd1+Gf)*O1 : 1 (clock-driven)\\n dO2/dt = Ga2*C2 + Gf*O1 - (Gd2+Gb)*O2 : 1 (clock-driven)\\n C2 = 1 - C1 - O1 - O2 : 1\\n\\n Theta = int(phi_pre > 0*phi_pre) : 1\\n Hp = Theta * phi_pre**p/(phi_pre**p + phim**p) : 1\\n Ga1 = k1*Hp : hertz\\n Ga2 = k2*Hp : hertz\\n Hq = Theta * phi_pre**q/(phi_pre**q + phim**q) : 1\\n Gf = kf*Hq + Gf0 : hertz\\n Gb = kb*Hq + Gb0 : hertz\\n\\n fphi = O1 + gamma*O2 : 1\\n\\n IOPTO_VAR_NAME_post = -g0*fphi*(V_VAR_NAME_post-E)*rho_rel : ampere (summed)\\n rho_rel : 1'), Light(name='yellow light', save_history=True, value=array([0.]), light_model=Koehler(radius=1. * mmetre, zmax=0.5 * mmetre), wavelength=0.59 * umetre, direction=array([0., 0., 1.]), max_Irr0_mW_per_mm2=None, max_Irr0_mW_per_mm2_viz=None), Light(name='blue light', save_history=True, value=array([0.]), light_model=Koehler(radius=1. * mmetre, zmax=0.5 * mmetre), wavelength=0.465 * umetre, direction=array([0., 0., 1.]), max_Irr0_mW_per_mm2=None, max_Irr0_mW_per_mm2_viz=None)})" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "blue = cleo.light.Light(\n", + " name=\"blue light\",\n", + " coords=[0, 0, -100] * b2.um,\n", + " light_model=cleo.light.Koehler(radius=1 * b2.mm),\n", + " wavelength=465 * b2.nmeter,\n", + ")\n", + "chr2r = cleo.opto.chr2_h134r_4s()\n", + "sim.inject(blue, neurons)\n", + "sigma_expr = 0.2\n", + "sim.inject(\n", + " chr2r,\n", + " neurons,\n", + " Iopto_var_name=\"I_ChR2R\",\n", + " rho_rel=0.3 * rng.lognormal(0, sigma_expr, neurons.N) / np.exp(sigma_expr**2 / 2),\n", + ")\n", + "\n", + "yellow = cleo.light.Light(\n", + " name=\"yellow light\",\n", + " coords=[0, 0, -250] * b2.um,\n", + " light_model=cleo.light.Koehler(radius=1 * b2.mm),\n", + " wavelength=590 * b2.nmeter,\n", + ")\n", + "enphr3 = cleo.opto.enphr3_3s()\n", + "sim.inject(yellow, neurons)\n", + "sim.inject(\n", + " enphr3,\n", + " neurons,\n", + " Iopto_var_name=\"I_eNpHR3\",\n", + " rho_rel=0.001 * rng.lognormal(0, sigma_expr, neurons.N) / np.exp(sigma_expr**2 / 2),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = cleo.light.plot_spectra(chr2r, enphr3)\n", + "ax.axvline(465, color=blue.color)\n", + "ax.axvline(590, color=yellow.color)" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = cleo.viz.plot(sim=sim, colors=['#c500cc'], figsize=(2.2, 2.2), scatterargs=dict(s=5))\n", + "ax.set(zticks=[])\n", + "# legend above plot\n", + "# ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.1))\n", + "fig.savefig('img/fig/optoclamp-3d.svg', dpi=300, bbox_inches='tight', transparent=True)" + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Eyeball test\n", + "Trying different levels of stimulation to ensure network activity looks roughly like the following:\n", + "\n", + "![newman-1d.png](attachment:image.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO No numerical integration method specified for group 'syn_ChR2_H134R__neurongroup', using method 'euler' (took 0.03s, trying other methods took 0.09s). [brian2.stateupdaters.base.method_choice]\n", + "INFO No numerical integration method specified for group 'syn_eNpHR3_0_neurongroup', using method 'euler' (took 0.01s, trying other methods took 0.05s). [brian2.stateupdaters.base.method_choice]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting simulation at t=0. s for a duration of 9. s\n", + "0.95 s (10%) simulated in 10s, estimated 1m 25s remaining.\n", + "1.7952 s (19%) simulated in 20s, estimated 1m 20s remaining.\n", + "2.7834 s (30%) simulated in 30s, estimated 1m 7s remaining.\n", + "3.7696 s (41%) simulated in 40s, estimated 56s remaining.\n", + "4.7212 s (52%) simulated in 50s, estimated 45s remaining.\n", + "5.6852 s (63%) simulated in 1m 0s, estimated 35s remaining.\n", + "6.6412 s (73%) simulated in 1m 10s, estimated 25s remaining.\n", + "7.503 s (83%) simulated in 1m 20s, estimated 16s remaining.\n", + "8.1992 s (91%) simulated in 1m 30s, estimated 9s remaining.\n", + "8.8308 s (98%) simulated in 1m 40s, estimated 2s remaining.\n", + "9. s (100%) simulated in 1m 42s\n" + ] + } + ], + "source": [ + "test_length_s = 9\n", + "intrvl_ms = test_length_s * 1000 / 9\n", + "\n", + "\n", + "class TestIOProc(cleo.ioproc.LatencyIOProcessor):\n", + " def __init__(self):\n", + " super().__init__(sample_period_ms=1)\n", + " self.UC_hist = []\n", + " self.UH_hist = []\n", + "\n", + " def process(self, state_dict, t_sample_ms):\n", + " UC, UH = 0, 0\n", + " if 1 * intrvl_ms <= t_sample_ms < 2 * intrvl_ms:\n", + " UC = 0.5\n", + " elif 3 * intrvl_ms <= t_sample_ms < 4 * intrvl_ms:\n", + " UC = 0.25\n", + " elif 5 * intrvl_ms <= t_sample_ms < 6 * intrvl_ms:\n", + " UH = 0.25\n", + " elif 7 * intrvl_ms <= t_sample_ms < 8 * intrvl_ms:\n", + " UH = 0.5\n", + "\n", + " self.UC_hist.append(UC)\n", + " self.UH_hist.append(UH)\n", + " return {\"blue light\": UC, \"yellow light\": UH}, t_sample_ms\n", + "\n", + " def preprocess_ctrl_signals(self, latest_ctrl_signals, t_ms):\n", + " out = {}\n", + " t = t_ms * b2.ms\n", + " UC = latest_ctrl_signals.get(\"blue light\", 0)\n", + " pulse_freq_465nm = (10 * UC + 10) * b2.Hz\n", + " pulse_width_465nm = 5 * UC * b2.ms\n", + " power_465nm = 13.2 * UC\n", + " on_465nm = t % (1 / pulse_freq_465nm) < pulse_width_465nm\n", + " out[\"blue light\"] = on_465nm * power_465nm\n", + "\n", + " UH = latest_ctrl_signals.get(\"yellow light\", 0)\n", + " out[\"yellow light\"] = UH * 11.8\n", + " return out\n", + "\n", + "\n", + "sim.reset()\n", + "test_proc = TestIOProc()\n", + "sim.set_io_processor(test_proc)\n", + "sim.run(test_length_s * b2.second, report=\"text\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax2 = ax.twinx()\n", + "\n", + "ax.scatter(spikes.t_ms, spikes.i, s=0.2, color=\"k\")\n", + "ax.set(ylim=[0, max(spikes.i)], ylabel=\"neuron index\", xlabel=\"time (ms)\")\n", + "ax.spines[\"right\"].set_visible(True)\n", + "ax2.plot(test_proc.t_samp_ms, test_proc.UC_hist, color=blue.color, label=\"$U_C$\")\n", + "ax2.plot(test_proc.t_samp_ms, test_proc.UH_hist, color=yellow.color, label=\"$U_H$\")\n", + "ax2.set(ylim=[0, 1], ylabel=\"$U_C, U_H$\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## PI control" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "class Controller(cleo.ioproc.LatencyIOProcessor):\n", + " def __init__(self, sample_period_ms=4):\n", + " super().__init__(sample_period_ms=sample_period_ms)\n", + " self.fre = cleo.ioproc.FiringRateEstimator(\n", + " tau_ms=2500, sample_period_ms=sample_period_ms\n", + " )\n", + " self.Ts = 0.01 * b2.second # control period (round-trip time)\n", + " self.Ti = 1 * b2.second # integral time constant\n", + " self.K = 0.1 # proportional gain\n", + " self.u = 0\n", + " self.ef_prev = 0\n", + " self.Δ = 0.25 # overlap between ChR2 and eNpHR3\n", + " self.uu = []\n", + " self.UCs = []\n", + " self.UHs = []\n", + " self.frs = []\n", + " self.target = 1\n", + " self.timepoints = [10, 20, 80, 90] * b2.second\n", + " # self.timepoints = [1, 2, 3, 4] * b2.second * 5\n", + " # self.timepoints = [2, 7, 22, 27] * b2.second\n", + "\n", + " def process(self, state_dict, t_sample_ms):\n", + " t = t_sample_ms * b2.ms\n", + " _, _, spike_counts = state_dict[\"Probe\"][\"SortedSpiking\"]\n", + " f, _ = self.fre.process(spike_counts, t_sample_ms, sample_time_ms=t_sample_ms)\n", + " f = np.mean(f)\n", + " self.frs.append(f)\n", + " if t < self.timepoints[0]:\n", + " UC = 1\n", + " UH = 0\n", + " elif t < self.timepoints[1]:\n", + " UC = 0\n", + " UH = 0\n", + " elif t < self.timepoints[2]:\n", + " ef = self.target - f # error in firing rate\n", + " self.u = self.u + self.K * (ef - self.ef_prev + self.Ts / self.Ti * ef)\n", + " self.uu.append(self.u)\n", + " UC = self.u + self.Δ\n", + " UC = np.clip(UC, 0, 1)\n", + " UH = -self.u + self.Δ\n", + " UH = np.clip(UH, 0, 1)\n", + " self.ef_prev = ef\n", + " elif t >= self.timepoints[2]:\n", + " UC = 0\n", + " UH = 0\n", + "\n", + " self.UCs.append(UC)\n", + " self.UHs.append(UH)\n", + "\n", + " return {\"blue light\": UC, \"yellow light\": UH}, t_sample_ms + self.Ts / b2.ms\n", + "\n", + " def preprocess_ctrl_signals(self, latest_ctrl_signals, t_ms):\n", + " out = {}\n", + " t = t_ms * b2.ms\n", + " UC = latest_ctrl_signals.get(\"blue light\", 0)\n", + " pulse_freq_465nm = (10 * UC + 10) * b2.Hz\n", + " pulse_width_465nm = 5 * UC * b2.ms\n", + " power_465nm = 13.2 * UC\n", + " on_465nm = t % (1 / pulse_freq_465nm) < pulse_width_465nm\n", + " out[\"blue light\"] = on_465nm * power_465nm\n", + "\n", + " UH = latest_ctrl_signals.get(\"yellow light\", 0)\n", + " out[\"yellow light\"] = UH * 11.8\n", + " return out\n", + "\n", + "ctrlr = Controller()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_results(t_ms, frs, UCs, UHs, target):\n", + " t = np.array(t_ms) / 1000\n", + " fig, axs = plt.subplots(2, 1, sharex=True, figsize=(4, 6))\n", + " axs[0].plot(t, frs)\n", + " axs[0].set(ylabel=\"firing rate (Hz)\")\n", + " axs[0].hlines(target, ctrlr.timepoints[1], ctrlr.timepoints[2])\n", + " axs[1].plot(t, UCs, label=\"$U_C$\", color=blue.color)\n", + " axs[1].plot(t, UHs, label=\"$U_H$\", color=yellow.color)\n", + " axs[1].set(ylabel=\"$U_C,U_H$\", xlabel=\"time (s)\")\n", + " axs[1].legend()\n", + " display(fig)\n", + " plt.close(fig)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "results = {}" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "target = 0\n", + "Starting simulation at t=0. s for a duration of 90. s\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4.3248 s (4%) simulated in 1m 0s, estimated 19m 49s remaining.\n", + "9.048 s (10%) simulated in 2m 0s, estimated 17m 54s remaining.\n", + "12.8734 s (14%) simulated in 3m 0s, estimated 17m 58s remaining.\n", + "17.4852 s (19%) simulated in 4m 0s, estimated 16m 35s remaining.\n", + "21.947 s (24%) simulated in 5m 0s, estimated 15m 30s remaining.\n", + "26.695 s (29%) simulated in 6m 0s, estimated 14m 14s remaining.\n", + "31.5058 s (35%) simulated in 7m 0s, estimated 13m 0s remaining.\n", + "36.1702 s (40%) simulated in 8m 0s, estimated 11m 54s remaining.\n", + "40.8526 s (45%) simulated in 9m 0s, estimated 10m 50s remaining.\n", + "45.1696 s (50%) simulated in 10m 0s, estimated 9m 56s remaining.\n", + "49.5872 s (55%) simulated in 11m 0s, estimated 8m 58s remaining.\n", + "53.8322 s (59%) simulated in 12m 0s, estimated 8m 4s remaining.\n", + "58.6226 s (65%) simulated in 13m 0s, estimated 6m 57s remaining.\n", + "63.2598 s (70%) simulated in 14m 0s, estimated 5m 55s remaining.\n", + "67.5408 s (75%) simulated in 15m 0s, estimated 4m 59s remaining.\n", + "71.6312 s (79%) simulated in 16m 0s, estimated 4m 6s remaining.\n", + "75.9052 s (84%) simulated in 17m 0s, estimated 3m 9s remaining.\n", + "79.6462 s (88%) simulated in 18m 0s, estimated 2m 20s remaining.\n", + "80.6462 s (89%) simulated in 2h 7m 2s, estimated 14m 44s remaining.\n", + "82.757 s (91%) simulated in 2h 8m 2s, estimated 11m 12s remaining.\n", + "85.851 s (95%) simulated in 2h 9m 2s, estimated 6m 14s remaining.\n", + "90. s (100%) simulated in 2h 9m 54s\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "target = 1\n", + "Starting simulation at t=0. s for a duration of 90. s\n", + "5.198 s (5%) simulated in 1m 0s, estimated 16m 19s remaining.\n", + "10.5918 s (11%) simulated in 2m 0s, estimated 15m 0s remaining.\n", + "16.0224 s (17%) simulated in 3m 0s, estimated 13m 51s remaining.\n", + "21.1268 s (23%) simulated in 4m 0s, estimated 13m 2s remaining.\n", + "26.4166 s (29%) simulated in 5m 0s, estimated 12m 2s remaining.\n", + "32.2326 s (35%) simulated in 6m 0s, estimated 10m 45s remaining.\n", + "37.783 s (41%) simulated in 7m 0s, estimated 9m 40s remaining.\n", + "43.499 s (48%) simulated in 8m 0s, estimated 8m 33s remaining.\n", + "49.1974 s (54%) simulated in 9m 0s, estimated 7m 28s remaining.\n", + "54.176 s (60%) simulated in 10m 0s, estimated 6m 37s remaining.\n", + "59.3976 s (65%) simulated in 11m 0s, estimated 5m 40s remaining.\n", + "65.1494 s (72%) simulated in 12m 0s, estimated 4m 35s remaining.\n", + "70.8056 s (78%) simulated in 13m 0s, estimated 3m 31s remaining.\n", + "75.7364 s (84%) simulated in 14m 0s, estimated 2m 38s remaining.\n", + "80.918 s (89%) simulated in 15m 0s, estimated 1m 41s remaining.\n", + "85.6166 s (95%) simulated in 16m 0s, estimated 49s remaining.\n", + "90. s (100%) simulated in 16m 52s\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAIPCAYAAACfew4GAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABuxklEQVR4nO3dd3hUVfrA8e9MyqQnpBCSEHpvoQmIIjZWwUWwoauCDRYXsOHPEhc7K1aUtSDKim0tqLgqTVAsoIIQIBAIvUMIpE4ySSaTzP39cTONTPokM5N5P88zT2bu3Ln33Eny3nPfc+45GkVRFIQQQvgErbsLIIQQouVI0BdCCB8iQV8IIXyIBH0hhPAhEvSFEMKHSNAXQggfIkFfCCF8iAR9IYTwIT4X9BVFQa/XI/ekCSF8kc8F/aKiIiIjIykqKnJ3UYQQosX5XNAXQghfJkFfCCF8iAR9IYTwIRL0hRDCh0jQF0IIHyJBXwghfIgEfSGE8CH+7i6AqN28lZks+vUQAIfnjUOj0bi5REIIb6bxtekS9Xo9kZGRFBYWEhER4e7i1EhRFDqnrqy2/MjzV7mhNEKI1kLSOx7KWcAXQoimkqDvgVbtzHJ3EYQQrZQEfQ9zJMfAP/671WHZDUPaW5+bzT6VjRNCuJg05HqIE/klXPjCT9WWH3xuHKZKM1+knQCguLyCiKCAli6eEKKVkJq+h3AW8JfNGImfVoPOX0uAn9prp7isoqWLJoRoRaSm72adHl3hdPn00V0Y3KENABqNhvCgAPIM5RRJ0BdCNIHU9N2kzFRZY8AHSB3b2+F1mE49PxcbTc1aLiFE6yY1fTfp9fhqp8v3PHslQQF+1ZZbgr7U9IUQTSE1fQ/jLOCDLeiXlFe2ZHGEEK2M1PTd4IXVexxe/+uaftwyvGOtnwnRqSeDYqPU9IUQjSdB3w0W/nzQ+jzj6SustfjahAZW1fQl6AshmkDSOy3s3KGO6hPwAUKravoGSe8IIZpAgn4Le+KbXdbnL9+QUu/PhVTV9A1S0xdCNIEE/RakKAofbTxqfX1V/4R6f9ZyRSBBXwjRFBL0W9BrP+x3eB0c6LynjjMhkt4RQriABP0WtOBHW9Af3jm6QZ+1ddmUmr4QovEk6LeQMpNjDf2TaSMa9HlLTr/YKDV9IUTjeWTQ//LLLxk5ciRhYWHEx8fz4IMPUlGh1nDz8vKYNGkSkZGRJCQk8PTTT7u5tPUz02645GGdovHTNmzaw9CqVJB02RRCNIXHBf3CwkIWLVrEk08+SU5ODuvWrWP58uW89NJLAEydOhVFUTh06BDr169n2bJlLFy40M2lrtuPe85Yn3/294bV8gFCrWPvSNAXQjSexwX9yMhI1q5dyxVXXEFQUBB9+/bljjvu4Ndff+XMmTN88803vPbaa8TExNCtWzeeeeYZXn/9dXcXu1bGCseUjLaBtXyw9dOXYRiEEE3hFXfk5uTkkJCQwPbt20lISCApKcn63vDhw9mzZw96vd7pROdGoxGj0Wh9rdfrW6TM9kbOW9fkbYRKl00hhAt4XE3/XNnZ2Xz44YdMnz6d3NxcYmJiHN6PiYlBURTOnDnj9PPz5s0jMjLS+khOTm6JYjvINZRbn//26KWN2oZlGAaD9N4RQjSBRwf94uJiJkyYwAMPPMDw4cPRaKqnRSzDGvj7O79oSU1NpbCw0Po4fvx4s5a5LklRwY36nKWmX2YyUynz5AohGslj0zulpaVMnDiRESNGkJqaCkBcXBy5ubkO6+Xk5AAQHx/vdDs6nQ6dTte8ha2nvw6o/x245wqxu5HLIPPkCiEaySNr+qWlpUyYMIFevXrx6quvWpcPGTKE7OxsTp06ZV22adMmOnbsSHBw42rQzS3fLrWT0j6q0dvR+Wvxr2oALpG++kKIRvK4oG8J+H369OGNN95wSOlERUVx8803c99995Gbm8uhQ4d48skn+fvf/+7GEtduy9F86/Opozo3ejsajcZa25dum0KIxvK4oP/FF1+wdu1aFixYgEajcXgcOXKEN998E51OR5cuXTjvvPO47LLLeOSRR9xd7BpN+3CL9bmzNomGCJWhGIQQTeRxOf0pU6YwZcqUWtf5+OOPW6g0nkVu0BJCNJXH1fRbk3Nvymoqy1AMBsnpCyEaSYJ+M3r310PW5xtTL2vy9sKC5AYtIUTTSNBvRi+v2Wd93i4yqMnbC5P0jhCiiSToN5OswlKXb1Ny+kKIppKg30zOtxtvp7F34Z4r3BL0yyToCyEaR4J+C9jwyCUu2Y7U9IUQTSVBv5ld3rttk/vnW1gaciXoCyEaS4J+M7AfEO2Goa4b1TNchlcWQjSRBP1mkGY39EKnmFCXbVfSO0KIppKg3wzyDLZJW3q2C3fZdi1dNoukIVcI0UgS9JvB3R9vrXulRgiT9I4Qookk6HsRacgVQjSVBP1mlOCCu3DtSU5fCNFUEvRdrKLSbH3+1i2DXbrtcLugb5kmUgghGkKCvosdzSuxPm/KTFnOWNI7igIl5TLSphCi4STou9jzq/ZYn2u1rrkpyyI4wA/LJqUxVwjRGBL0Xay0GWvgGo3GmtcvkqAvhGgECfoutuFADgB+Lq7lW0i3TSFEU0jQbyb2QzG4UpiMtCmEaAIJ+i5UVGayPp93bf9m2YelMVfSO0KIxpCg70LZetvwC38b1qFZ9iHpHSFEU0jQd6E/DuU2+z5kykQhRFP4u2pDJpOJ7du3c+rUKXJycoiOjiYhIYGBAwcSFOTaO1M9ldHU/H3n5a5cIURTNDnor1mzhnfeeYc1a9agKAoJCQnExcWRl5fH6dOnMZlMXH755fz9739n3LhxriizxzpbpKZ37rygc7PtQxpyhRBN0aT0zsSJE5k1axYDBw7kl19+oaioiH379vHbb7+RmZlJfn4+Gzdu5Pzzz+fee+9l4sSJLiq2ZzpZoE6GnhjVfFc24TLomhCiCZpU07/iiitYtmwZWm3N545+/frRr18/Zs+ezZtvvtmU3Xm8NbuzAUiIdM1E6M5IekcI0RRNqun/4x//QKvVsnPnTsxms9N11qxZA0BAQAD3339/U3bn8cor1O+g2GiqY83Gk/SOEKIpXNJ7JyUlhWHDhpGRkVHtvbFjx7piFx7PvgvlRT3imm0/0ntHCNEULuuyeffdd3PppZfy7LPPUllp68XiK0MAWxpxgwK0zZreiQiWKROFEI3nkqCv0WiYOnUqW7du5Y8//mDo0KGkp6db3/MFB84UA1Bmcp7mcpWIoAAACkubL4UkhGi9XNZPH6B9+/asXLmSJUuW8Je//IXp06e7cvMebd6qzBbZT2SwGvT1ZRL0hRAN55KafpcuXRxe33HHHWzbto1t27Y1ept6vZ7rrruOTp06OSyfO3cuGo3G4fH88883ej+ucvCsoUX2E2EJ+qUmn0mdCSFcxyVBf//+/dWWJSYm8t1333HkyJEGb2/Xrl0MHz6cgICAau9lZWXx4osvoiiK9fHoo482ptguFReuAyAlOapZ92NJ75gVMMjsWUKIBmr2sXeSk5Mb/JmffvqJF198kbvvvrvae1lZWXTo0DyDmTVFl9hQAO68oFOz7icoQEugn/prk7y+EKKhmhT0tVotfn5+NT4s7zfUrFmzGD9+vNP3cnJymDVrFjqdjpiYGO666y7y8/ObchguselwHgCJUc3XcwfUhnFLDx69BH0hRAM1qSF3586d1ueKojBgwACHZc3h888/p6Kigri4OPbv38/06dOZMmUK3333ndP1jUYjRqNtyGO9Xu/yMlluygKstfDmFBEUQE5xuQR9IUSDNSno9+3b1+G1RqOptszVEhISrM/79+/PO++8w4ABA8jNzSUmJqba+vPmzePpp59u1jKdqhpzB6B3QkSz7gsg3NqDR/rqCyEaxuvH0+/evTuKolBQUOD0/dTUVAoLC62P48ePu7wMm4/kWZ8H+jf/V2rptik5fSFEQ7m0n747ZGZmEhoaSlJSktP3dTodOp2uWctgqmzZrpMRQZLTF0I0jlfV9IuLi3nqqafYt28fRqOR9PR0pk6dysyZM906UctjXzdvO8a5IuQGLSFEIzWppn/DDTc4DLOgKAqTJk2qtt7SpUubshurgIAA9u7dy+jRo8nLy6N9+/ZMnTqVhx9+2CXb9xaS3hFCNFaTgn6/fv0cXru6Effiiy92uLlLp9Px6aefunQfrhAbFkhOcTn3Xta9RfZnuUFLXyoNuUKIhmlS0H/yySddVQ6vlhAZTE5xOQOTI1tkf9Z++pLeEUI0UJNy+i+99JLDMMq1MRqNHjFGTnPIM5QD0CYksEX2F2k3/o4QQjREk4L+tm3b6NatG88++yw7duxwOnvWli1bePLJJ+nWrZt1uOXWJr9EDfrRoS0T9GV4ZSFEYzUpvfPJJ5+wfv163nnnHS655BKMRiPt2rUjIiKC3NxcsrOzCQoKYuzYsXz44Ydccsklriq3xygzVVJSNfBZm5YK+lU1fZlIRQjRUE3upz9q1ChGjRpFZWUlu3btIisri7y8PKKiokhISKBPnz4EBrZMMHSHghK1tu2v1RCua5nbHqSfvhCisVwWpfz8/BgwYAADBgxw1Sa9gjWfHxrYYrOEWXL6RcYKKs0KflrfmJ1MCNF0XnVzliey5vNbqBEXbOkdgCLpwSOEaAAJ+k1kq+lXn/CluQT4aQmrSiXll0jQF0LUnwT9JrLU9Fuqu6ZFVEiAw/6FEKI+XBb0P/vsMyZMmMD5559vXbZp0yZ+/PFHV+3CI9nn9FuS5SSTb5CgL4SoP5cE/ZdffpnHHnuM888/nz///NO6XKPR8OCDD7piFx7LEnRbMqcP9jV9Se8IIerPJUH/3//+N99//z2PPvooimIbZrhv374cOHDAFbvwWHlVQbela/qWG8EKJL0jhGgAlwT9/Px863j29t0WCwsLCQhouQZOd7DW9FuwIRfs0jsS9IUQDeCSoD969GgWLVrksKy8vJzHHnuMMWPGuGIXHqulx92xkPSOEKIxXHJz1ttvv824ceP46KOPUBSFK664gvT0dGJjY1m7dq0rduGxWnrcHQtpyBVCNIZLgn779u3Ztm0b69atY8eOHSiKwn333ceYMWNadXpHURQPqOlL0BdC1J9Lgv7SpUuZNGkSY8aMcUjnGAwGVqxYwcSJE12xG49TaqrEWKGOLNrSNX1bQ66kd4QQ9eeSnP7f/vY3p8sDAgK49dZbXbELj2Sp5Qf6awkJ9GvRfUtDrhCiMZpU09+9ezegpjkyMzMdumtWVlayfPly4uPjm1ZCD5ZvUGvZ0SEtN9iahX1DrqIoLb5/IYR3alLQnzt3LuvXr0ej0VSbH1ej0ZCcnMxrr73WlF14tLyqWrYlALckS02/vMJMSXkloS00rLMQwrs1eRKVyspKevTowcGDB11VJq9h66Pf8vMFhAT6EeivpbzCTH5JuQR9IUS9NDmn7+fnR0ZGhivK4nX2ZhcBcKbI2OL71mg0tKm6wpDGXCFEfbmkeujv789bb71FRkYGZWVl1d5/7733XLEbj7PzRCEAJ/JL3LL/NiGBZOuN0pgrhKg3l/Teueuuu3j99dcJCAjggw8+IDo6mvz8fFatWsWVV17pil14pA0HcgD4S592btm/3JUrhGgol9T0V65cybZt20hOTub111/n5ZdfBtQa/saNG5k0aZIrduOxWrq7poWlLSGvuOXTS0II7+Sy8fSjo6MBiImJIS8vD4BJkybx8ccfu2oXHqdnfDgAY/snuGX/sWE6AHKKJb0jhKgflwT9QYMGsWXLFgD69evHp59+CsCBAwcwmVpv6kFfNT9tGzd02QRb0M81SE1fCFE/LknvPPPMM7Rp0waAOXPmMGHCBN544w1OnDjB/fff74pdeKTCUjXoRwa7J+jHhKnpnbNFUtMXQtSPS4K+/RSJl112Gbt37+bPP/+kffv2jBgxwhW78DjGikpKyisBiApu+X76YJ/ekZq+EKJ+XBL0x40bx9dff41OpwahDh060KFDB1ds2mPl2Q1pHB7knhujJOgLIRrKJTn9rVu3YjAYXLEpr7Evu9j6XKt1z7g3cXZB337cIyGEqIlLgv7s2bN57LHHqKysdMXmvEKgn8s6PjWaJadfZjJbU01CCFEbl+QlDAYDa9eupXPnzgwcOJCgoCCH95cuXdrgber1eu644w7S0tI4cuSIdbnRaOTee+/lq6++QlEUbrrpJl577bUWn6zF0nNnUIeoFt2vvVCdP8EBfpSaKskpNsr4O0KIOrkkSmi1WqZMmeKKTQGwa9curr/+elJSUqq9l5qaSmZmJunp6Wi1WiZPnsycOXN44YUXXLb/+igqqwAgPMi9M4PFhgdyPK+UnGIjHWNC3VoWIYTnc0nQf/LJJ12xGauffvqJF198kfDwcDZu3GhdbjabWbx4MatXryYpKQmAV155hVGjRvHcc8/h59dyd8YWWIZVdlN3TYvYMB3H80ql26YQol48Mh8wa9YsAH7++WeH5QcOHMBgMDB06FDrsgEDBmAymdi9ezf9+/evti2j0YjRaOvdotfrXVJGd02Ifq6YUOnBI4SoP/e3RjZAbm4uYWFhBAbaAq1GoyE6Oprs7Gynn5k3bx6RkZHWR3JyskvKYhnkzB0TqNiLC1e/i1wZikEIUQ9eFfRrmhJQURT8/Z1ftKSmplJYWGh9HD9+3CVlsUygYpnByl2kr74QoiFcEvRffPFFystrrmn+8ccffPXVV+Tm5jZpP3FxcRQXFzvsy2w2k5+fX+NcvDqdjoiICIeHK+S6cdYsexL0hRAN4ZKcfmpqKh07duTIkSNotVrGjh1Lv379AHjqqad4+eWXSUxMJCcnhw0bNtCnT59G7adLly5ER0eTlpZmHfohPT0dgM6dO7viUOrN02r6Z90we5cQwvu4pKavKAp33nknv/32G5s2beKSSy7hm2++AeCdd97h999/Z9++fdx7773MnTu30fvRaDTMmDGDRx55hJMnT3L69GkeeughJk+eXO3egOZm6bLprsHWLNpFqkH/tL76jGVCCHEul/XeWbNmDRdccAEAe/fu5dZbb2XChAmcPn3a2qvm7rvvZvjw4U3az+OPP05BQQEpKSmUl5czceJE5s+f3+TyN5TBqAb9UJ17JlCxiI9QT3Zn9OpQDDW1ewghBLgo6AcFBTncSNW9e3fOnDkDqLVzSyCKi4vj7Nmz9d7uxRdf7HA3Lqjz8S5YsIAFCxY0veCNpCgKhnJL0Hdvr9e24WrQL680k2coJ6Yq3SOEEM64JL1z0UUXMW3aNLZv386uXbu45557KCwsZNasWSiKwq5duwDIzMwkNjbWFbt0K2OFGXPV+GbuDvqB/lpiq8bgkRSPEKIuLgn6//nPf8jPz2fYsGEMHDiQ/fv3s3XrVtq2bcsHH3zAhAkT+Mc//sHEiRO55ZZbXLFLt7If3Cw4wL3pHbCleLIl6Ash6uCSampSUhKrV69GURQURUGrVc8lTzzxBADt27dn2bJlzJ49m7vvvtsVu3QrSz4/KECLn5uGVbbXLiKIXaf0ZBVK0BdC1M6luQn7/L29Sy65hEsuucSVu3IrS00/NNAzRrGIj6yq6UvQF0LUwSXpnf3793P55ZcTFRWFn5+f9aHValt0ELSWYpkbN8LN3TUt2lWldySnL4Soi0uqqtOmTSM+Pp5Vq1a57I5XT+a5QV9u0BJC1M4lQT8tLY2TJ0/6RMAHW9B3941ZFpLeEULUl0vSO8nJyRQXF9e9YiuRdjQfgBP5JW4uiUrSO0KI+nJJ0H/mmWe49957OXHihCs25/FyqwY3M5rMbi6Jql1VTb+w1ESpzJUrhKiFS9I7r7/+Olu2bOHrr78mJCSE4OBgh/ctd+e2Fklt1OP7a0qCm0uiigjyJzTQD0N5JacKS+kaF+buIgkhPJRLgv4zzzzjis14jWO5alonzEO6bGo0GpLaBLMvu5iT+RL0hRA1c0nUGj16tCs24zW2HS8AoKjqJi1P0L5NCPuyizmRX+ruogghPFiTgv7//vc/Jk6cyIcffljrelOmTGnKbjxOqM6PPAO0bxNc98otxFKWkwWe0bgshPBMTQr6H374IRMnTuT111+vcR2NRtPqgr5lwhLLmDeeIK5qdM2FPx/koSt6ubk0QghP1aSgv2zZMgA2b97sksJ4i7KqXjvH8zynVn3grNpl1jL6pxBCOOOSLpvjxo3DaPS9u0GHdY52dxGs7rm0u/V5pUR+IUQNXBL0t27disFgcMWmvEKAnzqoXKwHTVjSJTaUQH/113mqQBpzhRDOuSToz549m8cee4zKytZ/Y5CxohJTpVqTdvcEKva0Wg3JVY25xzwo7SSE8CwuiVoGg4G1a9fSuXNnBg4cWG2S8qVLl7piNx6huMzWTTPMg4I+QMeYUA6eNXA0t4QLurm7NEIIT+SSqKXValtdD52aGIzq1UxwgJ9HTKBir0N0CABHc30n1SaEaBiXBP0nn3zSFZvxCsVGz5gQ3Rlb0Jf0jhDCuSZFrlOnTpGYmMixY8dqXa9Dhw5N2Y1HsQT98CDPC/odY6qCvuT0hRA1aFLkGj16NPv376dTp05oNBoUpXpXQY1G06oaeA3Wmr7nzQhmCfrHcg0oiuJ06kohhG9rdNDfs2cPO3bsAKCoqMhlBfJ0lvF2PK0RF9TxdzQaMJRXkmso96gupUIIz9DoLpujR4+mrEydtOOFF14gNDS0xkdrUmKp6XvICJv2ggL8SKgaGkIac4UQzjQ66BsMButduP/6179cViBP58kNuQBd26rDKh844zszmQkh6q/Rkevaa69l2LBhnHfeeSiKwqRJk2pctzX10y+pmpnKE3P6AF3jwli/P0eCvhDCqUYH/SVLlvDFF19w4MABVqxYQd++fV1ZLo9lKFdr+iEemN4B6B6v1vT3S9AXQjjR6Mjl5+fHTTfdBMCJEyd8pq/+JxvV7qkl5Z4zgYq97m3DAdifLUFfCFGdS8beefvtt12xGa/QJjQQsN2Z62m6VeX0TxaUeuyJSQjhPi4J+r6kU6zaG2l0jzg3l8S56NBAYqpOTAfPSA8eIYQjrw36c+fORaPRODyef/75Zt+vwcN774Cttn/grO/cPyGEqB+vDfpZWVm8+OKLKIpifTz66KPNvl9PviPXwtKYu0/y+kKIc3h10HfHmD6WLpue2nsHoGe7CAAys/RuLokQwtN4bdDPyclh1qxZ6HQ6YmJiuOuuu8jPz6+2ntFoRK/XOzyawtI46sk1/b6JatDPOClBXwjhyGuD/ueff87WrVspLCzk559/JjMz0+mY/vPmzSMyMtL6SE5ObtJ+rTX9AM+t6fduF4FWAznFRs7oy9xdHCGEB/HaoJ+QkEBycjJBQUH079+fd955hxUrVpCbm+uwXmpqKoWFhdbH8ePHG71Ps1mxBv3gQM+t6QcH+tE1Ts3rZ5wqdHNphBCexGuD/rm6d++OoigUFBQ4LNfpdERERDg8GqvUZOub74mjbNqzpHh2SYpHCGGn1QT9zMxMQkNDSUpKarZ9WIZg0GggKMCzv7p+SZEA7DolQV8IYePZkasGxcXFPPXUU+zbtw+j0Uh6ejpTp05l5syZ1SZld6WSqrtwQwP9PX6Ckj5VNf2dJyW9I4Sw8ewcRQ0CAgLYu3cvo0ePJi8vj/bt2zN16lQefvjhZt2vbbA1z83nWwxoH4VWow7HkK0vIz6i+U6GQgjv4ZVBX6fT8emnn7b4fm3DKnv+1xam86dXuwh2Z+lJO5rPuP4J7i6SEMIDeGV6x10sd+N6Q00fYEjHNgCkHa1+/4IQwjdJ0G8Aa03fg+/GtTe0kxr0t0jQF0JUkaDfAJapEkM8+G5ce4M7qEF/18lCykyeORS0EKJlSdBvgKIyNeiHBwW4uST1075NMPEROirMClulti+EQIJ+g5RW9d4J85Kavkaj4YKusQBsOJDj5tIIITyBBP0GsNyRGxTgHUEf4MLuEvSFEDYS9BugtNwMQLA3Bf1uatDfebKQfEO5m0sjhHA3CfoNYKnpe1PQbxsRRM/4cBQFfj+YW/cHhBCtmgT9BrD0gPHkETadGVWV4vlxT7abSyKEcDcJ+g1QWu59OX2AMX3iAfgx8wymSrObSyOEcCcJ+g3gjekdgKGdookJDaSw1MSfh/PcXRwhhBtJ0G+AUi+YQMUZP63GWttfnXHazaURQriTBP0G8NaaPsAV/doBsCrjtKR4hPBhEvQbwBv76Vtc2C2W2LBAcoqN/LL3rLuLI4RwEwn6DeCt6R2AAD8t1wxSZxVbuqXx8wQLIbybBP0GKLPW9L3za7thaDIA6/ac4UxRmZtLI4RwB++MXm5S5sU5fYAe8eEM7hBFhVnh4z+Ours4Qgg3kKDfAGUVagOoN+b0LaaO6gLARxuPWtNV9VFmqmTS23/wwuo9zVU0IUQLkKBfT6ZKM5VmBQCdv/d+bVf0bUdydDD5JSY+/fNYvT/3y76z/Hkkj4U/H5SZuITwYt4bvVqYscLWzdGba/p+Wg13j+4KwJs/HbBOAVmXjzfa0kH/WrEbRVGapXxCiOYlQb+e7Gee8uaaPsCkocl0igkh11DOu+sP1eszlqscgK3HClglN3kJ4ZW8O3q1IEvQD/TXotFo3Fyapgnw0/LgX3oCsPDngxzLLanzMyHnzAv8/Ko9lFfITV7exGxW5HcmJOjXlyW9E+TltXyLvw5IYGTXGIwVZh7/JqPOdI256v0nx/chLlzHsbwSPvzjSAuUVLiC2axw1esb+Murv5BbbGyx/eYZytl9St9i+xN1ax0RrAWUefHduM5oNBqendiPQD8tv+w7y1Pf7uJsUc3BoLDUBEC7iCD+7y89AHh5zV72Zxc1aL+KonDgTBFmc8u3CVQ2Yp8Lfz7I3R+loS8zNUOJWo6hvILMLD1Hckt4YGl6i7XJ3Lp4E+P+vZ6PNta/i/CuU4UcOlvskFJ1BYNR/Q72ni6ioKTcZ+9VkaBfT2Umtaav89Ibs5zpGhdG6rheAHzwx1HO+9cPHMkxOF03p6p2GBuu44YhyYzqHkuZycw9n26jpNx5Y3CxscIaXL7fdZrpH23h3z8e4PL5v3LL4k0OQfirtBNc+dqvbD2WT1GZiTfW7beeUM4UlbFyZxamSjOKorByZxaf/nmMA2eKqDQrlJkqySk2klVYyg+7sx22qygKiqLw2Nc7GTJ3LVe+9ivvbTjsUM4jOQb+9s5G3vzpQLVg+MLqPazedZoBT61hyW+On9t6LJ81u9S2jdxiIzcu+oNOj65g3qpMzGaFwlITV/17PfNWZlq3azYr/HYgh/lr9rLkt8PMX7uP51ZmUl5h5s73N3Ppyz/z19fXs+mQbcKbRb8c5J5Ptzk98WQVlvLg0nSe/CbDemK2f++1H/ZxulD9/ix+3XeWD2u5T+N4XgnlFWZe+n4P1y/8naO5Bo7kGHjp+z2c0dsC5X82HOaeT7dV26/F2SIju7PUWv7j/8twWkH442AuT327i3xDOYqicLbIyFX/3sClr/xCr8dXM29VpvV723Na71BZOJJjsJbnaK6By175mYU/H3TYvv3v8+EvdzB2wXqueO1XBj6zlmH/+pF/rdhd4/fQWmkUH+uGodfriYyMpLCwkIiIiHp/7veDOdz87ia6tw1j7ezRzVjClqUoCpP/86d1Dt0ucaEs+8dIokICHdY7b+5azhaX89U/zqd3QgRni4xc+9Zv5BpMXNKzLf/+20D8tLa2jhN5pfzltV9JaR/JjIu7Mv3jrU73f8OQ9vzfFT0Y/tw667IxfdqydvcZAHq3C8dPqyGjASmCbm1DuefS7lzSM45Jb2/keH4JhnPuSegcG0Lb8CAeH9+Hv/57g8N71w1K4vYLOxMbFsj589Y5vJc6the3DO9AVmEZY179FYAwnR/Fxuq1Un8tWFLo0y/qwn2Xd2f+2n0sXn+42rrOXNa7LSO7xvLscjUwdYwJ4esZIzmrL2dt5mm+3naSg2cdT9J3j+7C/jPFlJZX1jpTmlYDC28ZzKgecQD8tj+HF77fw4guMXy8sfauvH88eim/H8rhwaU7AEiMCuL924exbs8ZBnWI4su045wsKKu2//ZtgvnvXcOJCQukqKyCzUfyuPez7db3Y0IDMRgrrPfDWEw5vyOfbDpKhRkGd4iid0IE+YZyVlZ1Jpg7oR9zvsmwrn/DkCQyTurJPK2eZGaP6cENQ9tX+11aPH11Xy7sFstrP+xjVUYWFWb46h8jGdKxTa3fg7eSoF9PP+05wx3vb6Z/UiTf3XNhM5aw5ZWUV/B/X6Szcqf6T9Q3MYL/Th1uDfyKotA5daU7iyhEi/t02gjO7xrj7mK4XOvJVTQzS37R27trOhMS6M9btwxhzQMXERMayK5TeiYt+sPaq2eTTLwifNAd7//Jd+mn3F0Ml/OvexUBUF7Z+nL65+oRH86nfx/BrYs3sS+7mAlvbuD56waw77QtF5vx1F/Qah27rK7ZdZoHPk/H2SXjI1f2sg7d8PsjlxIe7I+p0kxQgB8b9uew93QRr6zdB8A/Lu7KlBEdefCLdA6eLeaDO4Zx6GwxS34/wtkiIy9eP4AAPy3H80q4rHdbFAWy9UZKK9QTcpfYUCrNCj/tOcO/1+3nwBk19TGqeyxtw3RcNSCBEV1jUBSF/2w4wi/7zpJVWMqpgjJGdInmvdvP41huCQfPFPPaj/vZf6YYgEt6xvHmLYMxmxXmrdrDfzfZ0h+vTBpAqdHMkTwDg9pHcUnvtoB6B/fy9CwKS03cNrIjqzJO839f7LB+buvjlzt0Cli5M4u1u7N5/Ko+RIcFklNUznOrdpN+vJCswjKu6BvPTed14I73N1s/ExHkz5CO0fRsF8a9l3WnotLMV1tP8u76Q9x0XgfW7s4msU0Qsy7pxvw1+xifksiVVfMqlJkqeeDzdH7Z5zjM9vWDk/h+12mW3DGMPonqlbDBWEF5hUJUiD+ZWUVc//Yf1vV/nD2awzkGpn64xWE78RE6esSH0zEmhMfG9QbgSE4J0z7azMl8xwbU125MoWvbMPZnF5N+vIDwoAD+cXEXNBoNiqLwytp9fPj7EW4d0ZFuceE8vyqT4vJKusaF8vINKbz50wF+yDzDfZd1Z9qozry7/jArd2ZxUY84EiODOFlQynu/HQHgib/24aZhydZ9m80Kzy7fzedbTgBw2/kdubhnWz7eeJQf95zhnk+38cehXB4d24uIoAAnf+HeR9I79fTFluM89OUOLu4Zx/t3DGvGErrf6cIy/v7RFnacKHRY3iU2lHX/d7HTz/xxMJd//DeNghK1US8iyJ9Fk4dyftcYKirNVCoKOn/nPZ8sf4L29z8oilLr6/rYl11UdYKIr3GdYmMFK3dmcXnveKJDbe0YiqLwzq+H+HjTUV64dgAju8Val3+97SSB/lrG9ktwaMeoyx8Hc3lw6XYGdWzDmzcPrvfnsgpLiQ4NROfvR1ZhKSXllXSNC2vUd2Kv0qwwb2Umi6sath//ax/uurAzZrNS7cRu71RBKWt3Z3Pt4CTCqwKh5TMGYwW7s/QM6dDG6TbOFhmZvXQ7R3NLeO/28+gaF1qvY7A/1kqz0qDvHeCnvWfYeaKQmZd0q/ZZRVFYviOLQH8tV/RtZ93Hi6v3sOhX9ebFtuE6Usf14uqUpAbv29NI0K+nT/88RuqynVzeO57Ftw1txhJ6BmNFJQt+2M/bvxzE0mHimkFJvHrjwBo/YzYrVCoKfhpNrUHDlzU1UDeH3w7kcPBsMbcO7yi/t3P8fjCHf36dweGqXm2dY0OZNqoLVw9MJEznz4EzRTz93W6GdowmMSoIs6Lwlz7taBMaWMeW3ccrg77RaOTee+/lq6++QlEUbrrpJl577TUCAuq+/Gps0P/ojyM8/s0uxvZrx8JbhzSl+F4lM0vPcysz+e1ADosmD7XOtSuErygzVfKfDYd559dD1u6pIYF+XNY7vuqegurdnEf3iOPy3m0Z1T2OxKhgbl/yJ0VlFfylTzyje8bRNzHSbVcMXhn0Z8+ezZYtW/j000/RarVMnjyZIUOG8MILL9T52cYG/fc2HOaZ5bsZn5LI638b1JTie6XyCjOBrbARW4j6KjZW8Nmfx/hk0zEO1XA/S31FBgcwoH0kfRMj6RIXSufYUJKigmkbrsPfr3n/z7wu6JvNZqKioli9ejUjR44EID09nVGjRpGfn4+fX+13zDY26C/65SDzVu3h2sFJzJ80sCmHIITwYoqisO14AWt2ZbN+/1mO5Zbw1q2D6Z0QQZjOnxP5JazZnc2v+86SdjQfU6UtxF7eO55Nh3IpqmF0Wz+thnYRQbx4/QAuqGpHcjWv671z4MABDAYDQ4fa8uoDBgzAZDKxe/du+vfv77C+0WjEaLQNL6DXN24ckHeqGnQCtFLbFcKXaTQaBndow+AObXh0bK9q73drG063tuHMuLgbZaZKdp0q5FheCSO7xhIfEURFpZndWXr1BrIsPUdyDRzJNZBVUEaFWeFkQSmhuuYLzV4X9HNzcwkLCyMw0NZQotFoiI6OJjs7u1rQnzdvHk8//XST9/uXvvF8+udxuseHNXlbQgjfEBTgx5CO0QzpGG1d5u+nZUD7KAa0j3JY12xWyCk2cjy/hJ7x4c1WJq8L+jX1fFAUBX//6oeTmprK7Nmzra/1ej3JycnV1qvLnRd05trB7RnaSm/NFkK4l1aroW1EEG0jgpp1P14X9OPi4iguLqa8vNxa2zebzeTn5xMfX71niU6nQ6fTNXm/3ZvxzCuEEC3F6xLUXbp0ITo6mrS0NOuy9PR0ADp37uyuYgkhhFfwuqCv0WiYMWMGjzzyCCdPnuT06dM89NBDTJ48maCg5r0sEkIIb+d16R2Axx9/nIKCAlJSUigvL2fixInMnz/f3cUSQgiP53X99Juqsf30hRCiNfC69I4QQojGk6AvhBA+xCtz+k1hyWY19s5cIYTwVOHh4XWO4upzQb+oSJ0QpDE3aAkhhCerT1ulzzXkms1mTp06Va8zoj3LnbzHjx/3uQZgOXbfO3ZfPW7w7mOXmr4TWq2W9u3bN/rzERERXveH4Cpy7L537L563NB6j10acoUQwodI0BdCCB8iQb+edDodTz75pEsGb/M2cuy+d+y+etzQ+o/d5xpyhRDCl0lNXwghfIgEfSGE8CES9IUQwodI0BdCCB8iQV8IIXyIBH0hhPAhEvSFEMKHSNAXQggfIkFfCCF8iAR9IYTwIRL0hRDCh0jQF0IIHyJBXwghfIgEfSGE8CES9IUQwodI0BdCCB8iQV8IIXyIBH0hhPAhEvSFEMKHSNAXQggfIkFfCCF8iAR9IYTwIRL0hRDCh0jQF0IIHyJBXwghfIgEfSGE8CES9IUQwodI0BdCCB8iQV8IIXyIBH0hhPAhEvSFEMKHSNAXQggfIkFfCCF8iAR9IYTwIT4X9BVFQa/XoyiKu4sihBAtzueCflFREZGRkRQVFbm7KEII0eJ8LugLIYQvk6AvhBA+RIK+EEL4EAn6QgjhQzwm6Ov1eq677jo6depU63rbt2/nggsuIDQ0lJ49e/L111+3TAGFEKIV8Hd3AQB27drF9ddfT0pKSq3rlZWVMW7cOB544AHWrFnD5s2bufbaa+natSsDBgxoodIKIVqKoihUVFRQWVnp7qK4XUBAAH5+fk3ejkbxgA7rb7zxBh07diQ8PJzbb7+dI0eOOF3viy++4J///Cf79u2zLnvggQcwGo289dZb9dqXXq8nMjKSwsJCIiIiXFF8IUQzKC8vJysri5KSEncXxSNoNBrat29PWFhYk7bjETX9WbNmAfDzzz/Xut62bdsYNmyYw7Lhw4fz0ksv1fgZo9GI0Wi0vtbr9Y0q45MbYe3xRn3UJfy18OgQGNfJfWUQoqWYzWYOHz6Mn58fiYmJBAYGotFo3F0st1EUhbNnz3LixAm6d+/epBq/RwT9+srNzSUmJsZhWUxMDNnZ2TV+Zt68eTz99NNN3vf+QvjjdJM30yRBfhL0hW8oLy/HbDaTnJxMSEiIu4vjEeLi4jhy5Agmk8l3gr6zM72iKPj713wYqampzJ492/par9eTnJzc4H3PHgg3dm/wx1xi/Sl4ZRtUuj0RJ0TL0mo9pq+J27nqSsergn5cXByHDx92WJaTk0N8fHyNn9HpdOh0uibve2g8DG3yVhqntMJNOxZCtDpedRodNmwYmzdvdli2adMmevfu7aYSCSGEd/H4oD9+/HiWLFkCwNixY6msrOSll16ipKSEX375hSVLljBt2jQ3l1IIIbyDxwf9o0ePkpubC4C/vz/Lly9n+fLlxMbGctttt/Haa69xwQUXuLmUQghhoygKUVFRvP7669XemzFjRrVeiC3Jo3L6F198cbU++jt27HB43atXL3755ZcWLJUQQjTMwYMHKSwsZOjQ6i2BaWlpDBkyxA2lUnl8TV/YSOcdIbxDWloa/v7+DBw40GG5yWRix44dbg36HlXTF0KImigKlLihJ1uIPzS0t2RaWhp9+vQhODjYYfmuXbsoKyuToC9q57v3IQphU1IBYW+3/H6L74bQgIZ9Ji0trcbUjk6no1+/ftZl77//Pq+//jqVlZWYzWYefPBBbrvttqYWu0aS3hFCCBfbunVrjUG/f//+BASoZ5FFixbx3nvv8f3337N9+3Z++umnZp+/W2r6QgivEOKv1rrdsd+GOH78OAUFBfTt27faez/88ANjx44FID8/nzlz5pCenk5sbCygDitz++23N7XItZKgL4TwChpNw9Ms7mAymQAoLi52WL527Vr279/P+++/D8DXX3/NJZdcQmJiYouWT4K+F3H/INhCiLp07tyZXr16kZqaik6nIzY2lk2bNvHPf/6T22+/nZEjRwKQkZFRrXdPS5CgL4QQLqTRaFixYgX/93//x4033ojJZKJbt24899xz3Hnnndb1QkNDMZvNLV4+acj1Aj48jLgQXqlLly4sW7aMnJwcCgsLSUtLY9q0aQ5DIo8dO5ZPPvnEOuKAXq/n448/bvaySdAXQgg3GDlyJLNnz+aSSy6hf//+XHjhhdb2gOYk6R0hhHCTqVOnMnXq1Bbdp9T0hRDCh0jQF0IIHyJB34tIj00hRFNJ0BdCCB8iQd8LSI9NIYSrSNAXQggfIkFfCCF8iAR9IYTwIRL0hRDCh0jQ9yIyyqYQoqkk6AshhIspikJUVBSvv/56tfdmzJjBsGHD3FAqlQR9LyCjbArhXQ4ePEhhYWGNUya6c2J0CfpCCOFiaWlp+Pv7V5skxWQysWPHDgn6QgjRmqSlpdGnTx+Cg4Mdlu/atYuysjK3Bn0ZWlkI4R0UBZSSlt+vJqTBOda0tLQaUzs6nY5+/foBMH/+fPLy8pg7dy4AFRUVxMTEkJubi79/84RnCfpCCO+glMCxsJbfb4di0IQ26CNbt27l+uuvr7Y8LS2N/v37ExCgzvCekZHBuHHjrO9nZmbSqVOnZgv44EHpHaPRyPTp04mNjSUmJoaZM2fWOIvMf/7zH3r27ElgYCBJSUk8/PDDVFRUtHCJW5702BTC8x0/fpyCggL69u1b7b0ffvjBOjE6qEE/JSXF+nr79u3079+/WcvnMTX91NRUMjMzSU9PR6vVMnnyZObMmcMLL7zgsN5vv/3GrFmz+Oqrr7j00kvZt28fEyZMIDExkfvvv989hRdCND9NiFrrdsd+G8BSWS0udizr2rVr2b9/P++//z6gduvcs2cPY8aMsa6Tn59Pampq08pbB48I+mazmcWLF7N69WqSkpIAeOWVVxg1ahTPPfecw2TCe/bsoV+/ftZLogEDBliDf2slPTaFQM2rNzDN4g6dO3emV69epKamotPpiI2NZdOmTfzzn//k9ttvt9b0Dx8+TI8ePdiyZYv1s2PHjm32mr5HpHcOHDiAwWBwaPgYMGAAJpOJ3bt3O6x75ZVXcuzYMZYuXQpAeno6a9asYfLkyU63bTQa0ev1Dg8hhGguGo2GFStW0LVrV2688UYuuugiFi1axHPPPcfixYut62VkZNC7d2+Hz+7evdvayNtcPKKmn5ubS1hYGIGBgdZlGo2G6OhosrOzHc58SUlJ/PDDD4wfP54nnniCgoICvv322xrvcJs3bx5PP/10sx+DEEJYdOnShWXLltW6TkZGBn369LG+NhgMFBYW0rFjx2Ytm0fU9DU1dIdSFKVaK7bZbGb+/Pl0796duXPnMnjwYGbNmsWZM2ecbiM1NZXCwkLr4/jx4y4vvxBCNNS5Nf09e/Y4nASai0fU9OPi4iguLqa8vNxa2zebzeTn5xMfH++w7ptvvsmOHTvYtGkT/v7+XH/99dx3333cdtttrFq1qtq2dTodOp2uRY6jucmAa0K0Hp988onD6yFDhvD77783+349oqbfpUsXoqOjSUtLsy5LT08H1EYRe7t27WLIkCEOVwCXXXYZu3btapnCCiGEF/OIoK/RaJgxYwaPPPIIJ0+e5PTp0zz00ENMnjyZoKAgxo8fz5IlSwAYOXIkX331FT///DNlZWXs3buX559/nssuu8zNR9F8pPeOEMJVPCK9A/D4449TUFBASkoK5eXlTJw4kfnz5wNw9OhRcnNzAZgyZQpnzpxh2rRpHD16lDZt2nDttdfy0ksvubP4QgjhFTSK4luZYr1eT2RkJIWFhURERLi7OPWy7ABctwouTID11e/sFqLVKSsr4/Dhw3Tu3JmgoCB3F8cjuOo78Yj0jhBCiJYhQV8I4bF8LBFRK1d9FxL0vYj8+QtfYRmFsqTEDUMpe6jy8nIAh2FpGsNjGnKFEMLCz8+PqKgo602XISEhNd7E6QvMZjNnz54lJCSkycMuS9D3Aj78ty58WLt27QBqvNve12i1Wjp06NDkk58EfSGER9JoNCQkJNC2bdsa59bwJYGBgWi1Tc/IS9AXQng0Pz+/JuexhY005AohhA+RoC+EED5Egr4XkS6bQoimkqAvhBA+RIK+F5Aem0IIV5GgL4QQPkSCvhBC+BAJ+kII4UMk6AshhA+RoO9FZJRZIURTSdAXQggfIkHfC8gom0IIV5GgL4QQPkSCvhBC+BAJ+kII4UMk6AshhA+RoO9FpMemEKKpJOgLIYQPkaDvBaTHphDCVSToCyGED/GYoG80Gpk+fTqxsbHExMQwc+ZMTCZTjeu/8847pKSkEBQURHh4ODk5OS1YWiGE8E4eE/RTU1PJzMwkPT2djIwM9u7dy5w5c5yu+/zzz/Pxxx+zaNEi8vLyyM7OJjo6uoVLLIQQ3kejKO4fxstsNhMVFcXq1asZOXIkAOnp6YwaNYr8/Hz8/Pys62ZnZ3Peeeexa9cuwsPDG7wvvV5PZGQkhYWFREREuOwYmtO3h2DCChgeDxsnubs0Qghv5hE1/QMHDmAwGBg6dKh12YABAzCZTOzevdth3TVr1nDhhRcyd+5c2rVrR5s2bbj//vtrTQUJIYRQNTrom81mlxUiNzeXsLAwAgMDrcs0Gg3R0dFkZ2c7rJuRkcH3339PfHw8Bw8e5Oeff+bbb7/l1Vdfdbpto9GIXq93eHgbGXBNCOEqjQ760dHRDBo0iClTpvDiiy+yatUqjh8/3qhtaWqIaoqi4O/v77AsPz+fiy++mNmzZxMaGkpKSgr3338/y5Ytc7qNefPmERkZaX0kJyc3qoxCCNEa+Ne9inO5ublkZmaybds27r33Xs4//3x2796NXq+nT58+bNiwod7biouLo7i4mPLycmtt32w2k5+fT3x8vMO6wcHBxMbGOixLTEwkPz/f6bZTU1OZPXu29bVer5fAL4TwWY2u6fv5+dGvXz8mT55MVFQUK1eu5MiRI5w4cYJ///vfDdpWly5diI6OJi0tzbosPT0dgM6dOzusO3jwYNavX++wbP/+/XTq1MnptnU6HREREQ4PIYTwVS5pyLVPz4SEhDB48OAGf37GjBk88sgjnDx5ktOnT/PQQw8xefJkgoKCGD9+PEuWLAHguuuuo6ioiEcffRSDwcAff/zBggULuPPOO11xKEII0ao1Or3zxBNPMHDgQFJSUlxSkMcff5yCggJSUlIoLy9n4sSJzJ8/H4CjR4+Sm5sLQFhYGGvWrGHGjBnExMQQFxfHI488wo033uiScngyt/etFUJ4vUb303/11VfJyMggIyODPXv20LNnT3r37k2fPn3o3bs3V199tavL6hLe2E//u8Nw9XIYFg+bpJ++EKIJGl3Tf+CBBxxeHz582HoSWLp0qccGfW8kPTaFEK5S76A/YsQIhgwZYn3069fP4U7Zzp0707lzZ8aPH98sBRVCCNF09Q76gwcPJi0tjSVLlmA0GtHpdPTv35+RI0dy0003MXz48OYspxBCCBeod++dt956i40bN6LX69m6dStvvPEGQ4cOZeXKlYwcOZKpU6fiAcP4CCGEqEWDc/r+/v6kpKSQkpJi7Sa5du1abrnlFkaOHCldJ4UQwoO5pJ/+mDFjmDt3LgsXLnTF5kQN5EJKCNFULhtlc8SIERw4cMBVmxNCCNEM6h3033zzTf7880+MRqPT93NycggICHBZwYSNdNkUQrhKvXP6c+bMQa/X4+/vT58+fRg6dChDhw6lb9++FBcXk5qaykUXXdScZRVCCNFE9Q76+fn5HDx4kLS0NOvjq6++oqCgAIBevXrx8ssvN1c5hRBCuECDeu907dqVrl27MmmSbSyAEydOYDKZqo2GKYQQwvM0ehgGi/bt27uiHEIIIVqAR8yRK+pHemwKIZpKgr4QQvgQCfpeQCZGF0K4ikuDvlar5dJLL3WY9lAIIYTncGnQf++997jooouYOXOmKzcrhBDCRRo9c5a38saZs1Yegau+g6FtYbOnzAppLgH9q6CYIPJB0Ia7u0RCiHpodJfNjz76CEVRmDJliivLI2rhUWfn3H+A4UP1eflmaLtcGh+E8AKNTu+88sorTmfJ+u9//8sHH3zQpEIJD2fabwv4AKUrwbjBfeUR9aeUQ9lvUJnv7pIIN2l00NdqtbRp06ba8quvvppXX321SYUSHs6wVP0Z9BcIu0t9XrTYfeUR9aMY4fRoOH0hnOoDFcfcXSLhBk0K+vn51WsL4eHhMoOWi3lc0qR0ufoz9AYIu71q2begVLitSKIeihaDcaP6vPI05D/q3vIIt2h00J81axbXXHMN2dnZDsvz8vKaXCjhwRQjGLeqz4MuBt0I0EaBuQCMm91YMFGn4v+oPy0nasMXUHnGbcUR7tHohtzbb78do9FI//79ufTSSxk4cCBms5lPPvmE2bNnu7KMwpOUpwPloI0B/65q423QGCj5AsrWQtD57i6hqImpapKjyEehfJfaAG/4EiJmuLdcokU1qZ/+9OnT2bt3L1dccQVnz56lrKyMd999V+bJbc2Mm9SfuuG23jpBVfMoWFIHwjMppepPTSiEXKM+L/3efeURblHvmv6IESMYMmSI9dGvXz/8/Pxo06YNd9xxR3OWUVTxiKYS0271Z2CKbZluuPrTuEktpHTdbLyKU2D4L4RcCwFdXbddpQKoanPRBEPwlVDwGJT9qPbo0QS6bl/eQqkA/Hzu77XeNf3BgweTlpbGrFmzGDx4MOHh4QwfPpwHHniATZs2NWcZhScx7VV/BvS0LQtMAXRgzoMKmSe5SQpfgPyH4WQ39QQAYNwOxR+pN8I1lqWWD2rQDxyopugUA5Rvr/vzpn2Qez+U72ngfisg/zE4fSWU/tywzzansg1wLAqyzoPK7DpXb03qHfTfeustNm7ciF6vZ+vWrbzxxhsMHTqUlStXMnLkSKZOnSq9dpqJR1VELEHf3y7oawJBN0h9bvy95ctkUfwJZJ2vBklnFAXyHlUDq2Ju2LaVikZ8RoHi/0LJqvqtX/Q+FP3b9vpEEhg+h7OTIGcKnLmmYfu3Zy6oeuIHmiD1j0o3Ql1krEelTb8AihbAqd5gLq7/fvWvQ+E8KPsezowD05H6fU6phOKPoayZ/p7Kfqk64aVB7qzm2YeHanBO39/fn5SUFO68807efPNN9u7dy+rVq/n2229ZsmRJowtiNBqZPn06sbGxxMTEMHPmTEym2ms2RqORIUOGMHTo0EbvVzSAuQgqq2qf9jV9gMAh6s+c29UhGlpSxWnQvwU5t6jtClmD1KBRbb19oH9B7apYONdWkwa1Jltx1Pn2zcVwIhlO9oaK4/Uvl2kH5NyqBjv9W87XUSrVR0UW5DpJk569CSr2q89LV6g11MYwV/Wq84sDTdW/vTXo19AWU/whnL4Mij+DIrvyF72p/ixZDrkzHb/Hc5X8z/ZcKVVPAPVRugJyJsPpC6Dk26pjMNTvs3WpOA5l6+zK+BWYDrtm217AJQOujRkzhrlz57Jw4cJGbyM1NZXMzEzS09PJyMhg7969zJkzp9bP3HfffSQkJDR6n6KBTFXBRxsHfufcmBfY3/a8tsbBilNwsg9kjaz+j2bW168cFaegZDWcuQFOpsCJBMg7Z5C/o/6O3RGLFsHJXrbXBU+qNemSlVCZAyf7wolOcLyTGsysZSqE3LvVfu0V+9QgVxOlArL/CicHwOlLoeQb23t5M6Hi5Dnrm+HUIDieCCVL63fs+teqLytdA2engOlQzQ0/lafVn5oQ27K6gn7hfDU45vzNcXnREnU/+Q+pJ4NTA2q+R0OpCtQR/6f+NHwO5jLn69qrOGF7nnuv+rljEVDwTM2fMZfV3fBlLoWT/RyDPorajuIjXDbK5ogRIzhwoHH5XLPZzOLFi3n++edJSkoiISGBV155hYULF1JZ6aTGhjrcw5kzZ7j99tubUGrRIBVH1J/+Xaq/F2AX9Mu31ryNsp/AlAnGP+BkF7UmqZRDwTw4FglnJ6s1seyJah77XIoCWUPhzFgo+VKtTdfkrN24UPYB2N6Zq6oCQFXQqjwKZ8bbujfmznAMCKXf2VJc5zLtVmuopp3qcRY86fh+wTmVGMWgrms+A3n313wc9kpXqoHLug0Fcu8Bw0dwsiuctQvQpkNVefhdtruo7WvLuvPUnxWHoDLXcT+VZ8GU7rwMFXvV7p6mqvy+OdexRu9wjFVXfcFXgl8SKIVg/KX2Y8z/p+NJvPKoesWDWf1OLVdkxq22NobyPXA8Bk6lqFdNNTGfBcW+clHVl8WwVE1hlf4ExjQP6TXRPOod9N98803+/PNPjEaj0/dzcnIICAhoVCEOHDiAwWBwSNMMGDAAk8nE7t27q62/e/duXnzxxXqlk4xGI3q93uEhGqmyqvbln1z9vcABtuemXTVvQzknH1y2Ts17W2qbho/h7I1Q+o2axz4SCLn3wfGOcKKbGhwra/mndtj29+qJo2gxlP5Y83pnnQxderK7GvjKt1V/z/BZ9WWVOWrAqY3hazWYKApkj1Vrrs5Evwlxn1df7tdOTZEcC4HSdVC+EwqeVq9ALEo+h7wHIOdOKHy+Kg/fD0qr2hX8YmzraiPBv5P6vPh9yBqlNraW/gTH2zovW/BV6s+s4Y7Li5xc5Stm9QQPajfR4CvV56WrnW8b1CuGulJAJzpB4Uvq1eKp3lC+G8q3qCcY007Iu1c9uVUcg/JMW1uMYoayX+02pIGYqlSVaaf6t5V9qVqpyGm9PRLr3WVzzpw56PV6/P396dOnD0OHDmXo0KH07duX4uJiUlNTueiiixpViNzcXMLCwggMtHUb02g0REdHk52dTf/+tlqkwWDg1ltvZcmSJURGRta57Xnz5vH00083qlyexu11D8slt3/76u9pwyDqX1DwTyj5Wq1dGjerDbyBKWpqqGSF81v/i993DFzGP+zeNDk2bto/P1fgYIh6Bs781bYs55xRYLVREHYn6OfXvB0Lw2fqHcgAMe+COV/tWVPyLUQ9qTZSmvZCmxfPSRc4oQlWa7mmnepJq6bAF/GwerOUokDUAfX7tAi+GorfUZ9nX1bzvpylgCwnyrDbHJcH9FWv4PKr0i/ZlzjZYABggnZ/qA31pSuqr1K2Do5GQfy3tvs2lCK7TfSA4CvUu4JrS/8pBhz+0oMnqBWAc+U/bHte8Dj42VVESr6EY1/aXofcAG2Xqn97+pdsyzsYQBusDhFuuWqxMHwAce/XXE4vVu+gn5+fz8GDB0lLS7M+vvrqKwoKCgDo1asXL7/8cqMKoamhe4qiKPj7Oxbx7rvvZtq0aQwePLhe205NTXW4Q1iv15Oc7KSmKupWWdWI6VfD9xc+zRakTvWzLU+uGuelZJnzzxl/db68IQL6Q7sN6j9xwja1MdeZdr+o6xZ/rKZV7IVNU1MHZWvU1yXf2oJ+4GD1Cif/YTV9pf+32hVRMah93f2727aju6DquH6rej0SNGHqdguervl7ANBWtZVoNBD1mJpastwbEXSRLeg7pQOcX4lbnZvGCejnPIhb+UOHfLUtQKNRe/6cSxOpntCUQnVAt05VQdvay8dPPa6gS9WXpkx1pM+gC9TvUf8WRNwLfgmO9wsk7Qe/9nAsuPZjqu37BPVucdNB2/dooa3arm5E9aDfijVoGIauXbvStWtXJk2aZF124sQJTCYTnTt3bnQh4uLiKC4upry83FrbN5vN5OfnEx8fb13v2LFjfPzxx3z33XekpqYCYDKZMBqNREVFsXz5ci688EKHbet0OnQ6XaPL5gk8psdmbTV9UHuGOFMwr3rPmNiPoWw9FC9yXK6JOCfnWovks2pf83MrDbqBEDW3eg4dbGmohD/UKxJLDRcger56xaJ/S80pGzeAUtXoqNGpxxfQV01f5d1n+5xpj2PQiP9BXT9rKJTvgLb/g6J31KDvLEC1/RbOXF31otzxvah/wdlrwL8HBI2q+buI+1pNn9QVIEMnOb4O7FvzutpYSM629fYBxwZ7gIj71asWU6Ft2RGNOi6TtTG2Uv0d+VUN3VFxUB3pM36tOv5Pxd7qDfEAAd2qfvatPWVYH4b/2n6XAFFP2Z7rRqhXm/Y0dXyPXqzJDbnt27dvUsAH6NKlC9HR0Q5z66anq41I9ttOTEzk8OHDbN++3fp4+umn6dOnD9u3b5eum82too6afk2KFqj9oe0FXwWxb9uGA7CIsUvfRD7hvNEYIPZT8Iut+SaGoNG1lymgC0Q84LjMUssM/4faQ8k+SGir8u+WWnxN/BJAW9UPvt0vkHxGPVnUFLATMyH4rxD3JQRdVj39EjpRnaCm3Vrw7wC6C51uBt1wdb9aZydeu7Y23ZBz3upHjdofdgz4ABo/x9d+7SDy8eqfLfvZ+Y16lsZjgOwxNc/DYOlZBBC3VE3JJR20XS1Y95/o+LptDfdEGD5Xr8gA4r5S03PWfdn9Ti1dj+2/s1bGpXPkNpZGo2HGjBk88sgjnDx5ktOnT/PQQw8xefJkgoKCGD9+PEuWLMHf359OnTo5PGJjYwkMDKRTp04EBTm59BSuoZihsqrLYU01fYCEtJrfs/DvDNpQ9XnozY7vBY+1PQ8aCXFf2F63+xmS86HdrxB2U+37CBxS+/vgJKBVBX2NpvpJw9J4HVRH0G/zgu25NszWtTVwGNUCSfgMCOyl7i/0Omj3A/h3rL7NkKvUgA/qsXd0lsKpOvklbILIVPUKwSLuY/VncPVJjwjoVX0ZQOhtavmdia2aQCfoCrWmH3YzBDlrC6gSZjcWV+CwmtezZx/MA/tA7H/UE3XsBxBo14h87u/Jrx3EvFd9e/apHftuq6BeSYT+Tc39x31Sv/J5MY8I+gCPP/44gwYNIiUlhR49epCYmMj8+Wpj29GjR8nNza1jC6JZmc+idmvUqrXZmujqaGuJWwqJO0FTFQBDrnOsvfq1hZDrQdsWAgepwwVYaMLAL6r2NIeFNlgNSgRA/Dp1H7FOZnSLeET9GXS54/KarhR0dYwiGtDf+XJtkGOAjXnP1nOkITQa9eTU5kU1FaYJV78jS2otoDO0eQ7CLL1PAtRg1u4XiHXS201rl8awT2n4tau5DGGT1bx9u9VqGgug3TpIqqHLts4uSNvX9GtjLnK+3L89JG5U04PB49SeTrqRVeWPUHsjhd8BHSvVhtpOitoeYy/oYsfXGo0a7NsuxRYS3d5totnIxOhe4PujcOW3MCgOttZRwW02pgNqN0ZNOHSsI+de/CnkVNXgw2fa7uAE6FhRPUWgKFC8RM0X686z9ZG2pG7KflP7kofe2rAxKcwGtcdNbVcm5hI13x52s3rCsTBugiy7FIOlcVJR1L79li6Q4bPUtIxpp5qSCB5T876yzrd1TU3YprY9NIViVq9Wahrkrny3GpTrGrhN/7baU6nt52pPnuL3IepZNX3WoPIocNRJPbJ9FvhXnUTMRc67qsYthYInbG0jidsdB/Wri7lY7e7pF1X9vbyHQG/XyaRTLSHPdFAd96g+f+deqtHj6YuW59bTs6UXi6YejeJhf4Pgy9RumgE9bEG/7arqAR/UgBV+p+Nre0EXAHWkVZzRhtrSSDWuEwKR91df7lBjtztmjQbiV4Jxm9pNMeKBqjTRxLrLEzjIFvTPHcaiMSzpqZpOhIF96rediLvVB4BfvGPNvEHl0ahTaJatUXtCFb+rLtdG2dbRhjv/bOgN6lVf4bMQ0LthAR9qTkWB2uvJPuj7OAn6on6sQb+eQ/D6tbXVnKNfV2tiIVc2T9mag9Yu7+uspqwbZBtkrr6CLrfdxKRtpb1D2i4DU4aauw+fAShqaste0iH1ZqrybeqQGuF/V5drtI4NrK6is2tHiHqunh9qvQkQCfpewCNG2WxITf9cEV46iqE2Rh1iQFv3TYD1EjIBwv5e/xq4N9KG2q4UakpfBXRWH6E3tEyZ/Gzdvq0N4jXyhH+25iVBX9SPddalVlpDdabdOsh/HKJfqnvd+tD4QeyiutcTrtf2G/VO4HqfaKSmL3ydZTx2+/xsaxc4AOJrGKhNeJeQq9VHnVp/Td9jumwKD+eLQV+IVkiCvqgfc9Vt9lrv6OYqRNO03vSOBH0v4q4/w21n4aM9llnMvHscIyFqJ+kdIRj8GezJrwr6mtY7JokQNlLTF27kCXWPcL+q2+JruwlGCOHxJOiLeokMqMrpa1zUZ10IT+QRN8U0Lwn6ol50WsvNWTKSqfAFkt4RPi5AKzl94Qukpi88iDsHXAvQqEG/XKnn2DtCCI8kQV/US6BWncavqFxq+sIHtOIR5yXoewFPuOC0BH0zUtMXrZkn/Lc1Lwn6ok5tdLb0TqUEfeETpKYvfJiCraZfoUh6R7RmUtMXArAF/UppyBXCq0nQF3VSFAjSlgFQocjYO8IXSHpHeAB3/hmG+hsAMCl1zDkrhFeT9I4Qak5fU5XTl1E2hU+Qmr5wI3cPB6Io4K+tAMBYKZOtCeHNJOiLevHXqEG/pEKCvmjNJL0jBAq2oC81feEbJL0jfJwl6JebJeiL1kxq+kKgANGB+QCUK37uLYwQLUJq+s3OaDQyffp0YmNjiYmJYebMmZhMpmrrFRcXk5qaSpcuXQgKCmLAgAEsX77cDSVuee76M+wbttP6XNI7Qng3jwn6qampZGZmkp6eTkZGBnv37mXOnDnV1lu9ejVZWVmsXbuW/Px8HnzwQa6//nqOHj3qhlL7hivjbCfVCnPrv/wVvqz1/317RNA3m80sXryY559/nqSkJBISEnjllVdYuHAhlZWVDutef/31vP/++3Tt2pXg4GBuu+02OnXqxMaNG91U+ubn7j/Doopw6/P8ykQ3lkSIliLpnWZ14MABDAYDQ4cOtS4bMGAAJpOJ3bt31/pZs9lMXl4eCQkJTt83Go3o9XqHh2gAxcz8vvcAYFY0lFXK2DtCeDOPCPq5ubmEhYURGGgLKBqNhujoaLKzs2v97HvvvUe7du244IILnL4/b948IiMjrY/k5GSXlr31s7WraDUKFWY3FkWI5ubuOyFbgEcEfU0NX7SiKPj719xwuH79ep544gk+++wz/Pyc9ypJTU2lsLDQ+jh+/LhLyuw7HH83pRVuKoYQLar1pnc8oitGXFwcxcXFlJeXW2v7ZrOZ/Px84uPjnX5my5Yt3HjjjXzxxRf06dOnxm3rdDp0OhkvxhWKKsIoLHd3KYRoTlLTbxFdunQhOjqatLQ067L09HQAOnfuXG39LVu2MHHiRD755JMa0zqtkbun7czQ96O4ei9aIYQX8Yigr9FomDFjBo888ggnT57k9OnTPPTQQ0yePJmgoCDGjx/PkiVLADXgX3PNNXz66adcfPHF7i24j5mavlhy+kJ4OY8I+gCPP/44gwYNIiUlhR49epCYmMj8+fMBOHr0KLm5uQA8/PDDnDhxgosuugiNRmN9tOYTgKe0LZ0oa09ZZd3rCeG9POSfrRl5RE4fwN/fnwULFrBgwYJq7+3YscP6fN26dS1ZLHEOveT0ha9QFM+pcbmQx9T0hXcoMLq7BEI0p9YX5M8lQV80iC8F/d9OwXmfQ9oZd5dENNWS3XDNCjA0qCNC6+y2KUFfNIgv5fQv/Aq2nIE7f3DN9oyV8NfvIPV312xP1N+dP8L/DsHn+91dEveToO9FPKHeYWxE0P/nH3DvL+7vctpYrkrrfnkAVhyB59PqXNVr5ZTC1wfBVAk/HIO1x6qvs+0sPL8Fbv4ezv8CVhxu3jKdLLY9P1BQ19qtP73jMQ25wjvUJ+grCuzJh115cH47eG6LuvzCRJjUvXnL5yr2DdbpOY7vmRVYdxxWHYV5IyGwnlMM/HzC9ryoHMJb4TBGo5fB7jwY2la9SgIw3A0hAbZ1Bn/m+Jm/LgflHvVEMfMXGBADs1JcV6ZNp23P56XBcyPr+0kvraXUQWr6XsC9dQ/HP/z6BP23M6DPf+GGVfDAetvyG1c7/7xZgbmb4fuq0bFLKyCvzPb+t4fghTR1vYbILlFrlbXJL4OHf4ODhY7L02v4nFmBoZ/DmG9g/na4biUsyoBbvocPM2vf145c2/MDhTWvVx+KoravmCprHhrj15Pw52nn79l79k/o/iEc1au/g6uXw4niuj/nrEy789TnW+zaQc6W2p7nl+HUgu0QtBDe3QX3/AobTtV/v8ZKOKKHQzV8p780YFu+QIK+qDcFDQYTlNcR+Gf8bHv+xQHH997NcLzcNisQtxge3whXfqsuG/8ddHpfDTwVZpiwAh793bHGVh/XrFBrlZ/vgy4fwKvbqq/zf7/BS1vVE5S9zTU03mbmOZ5Ilh+Bu3+CT/bBbT/A71k1l8f+bmb7Wn9j3L8e2rwDgW9Br4/V4G/vcKFa6x7+hfodf7YPjhc539YTm9STUKcP1N/Bd4fhxVpSUIrieFIGdR+/1XDsK+2mutie43yd+9c7ntQfraPdY8F2GPSp+rc04BPo/AF0/VBNL4F6JXWqGEpM8OM5w23V3u3YvoolNX0hUIBThprfX1fHeHb3/KoGYsuJ44NMxwByohh+PAFFJtiVC5vtBlnNLVOD2ef76m4fKCqHP6pOEjd9D4f1MHtD9fXeqxq5+9wrgl9OOr627O+POk48GbnOlxeXqykvi9kb1KuEhioxQW4p/DvdtuxYEeRUfYfpZ+G2tbAww/b+Wzvgb9/DxBXOy+VMbb203tgBMe+qJ+bicvW7SXwPRn3lfP01dnn9P2sfNNeqQ7jz5fvyof176kliew7M/Bn2FdjeP1EM87ZAxCJIWgKhb6tpRnvnXkVUmmH0V3Dhl+rz1k6Cvqi3kKoWoNou/S/7X93bOVNq6zr35TlXAt8esj1fegBGfml7PX45dPlQDeIvbq19H5vrEVzOHVKirCpNYlZg/TmB4UjVNAw11WYtHvvD9jy7xNZwuPF09fTUsoPqSVJR1CugPh/D3nzHdSzv7cpVn/f/BGIX17z/gZ/Bh3vUqxeLe35Vf251krLanVd9GcBHex3TMvburdre0SK1Ufqtneqx1uR/dr/T+vxewPHk8EcWjP0GdubAzWvgpF2l44dzrpj25jv+DiyGtLU9LzsnHbY9B349pf5ux69o/Q25EvS9iLt7vySFqj+PNzDf+9hQuOicCbc+3qumcewv/UFtyLN4r5b5cx79HXbkqDXNEicpp59POv+cxfazcP+vjsssJ4HHfod8I4TbNT4aqgJFXUE/t0zNW5sVtWdK94/UXPmvNeSVL/uf+l38/SfIzIeP9ji+vyRTfW/EF2q7w6Ea5gBad6LmWru9X8/5Xs6tBdtru7h62ujc16UVMP+ctFnvNjC9H4xxMnWFfdps86TqfxdxwepP+zaW61bB6mMw4NPq90yc2+/+pu+dH8uN3eHyZNv2Zv5se+8Pu9+p45Vc60zvSO8dUW/tw2Brbs01/VM1LH94sJpesXfvr87XbYiUT23P24XAvslqj5ifTsCzm51/ZnO22rNk0GfV37t2pWNgvShJ7blzolhtLDxZDPsL1Pe+GgvTflJTU3/tBN2i4LXt6nvnLYWSCsiqqpFe9Z0tmN3RWw3k9qastT2POmcU8HlVPZ+KTdWvPuzduqbm9+x9e1g9Lovagj6obQan7oSwAPW7PfdqYf522xWgxe5b1Z+nDZDwHmg1aoUlu0RNRQEcmAJdI2FaX/DTwoMD1e+orFJtiwD1BDUwzvY9NsXNPRxPeG/thDcvVp/XlbJrbSToewFPGf7DWtOvoUHQ0jUT4MhtsLdArfVF6uCVC2FiF3hqk1qjtXdFBzhdUr1rZEOcLlEDzPPn29IZzgxbCjd0c/7e2nPaIyZ0tuXhVx6xNQCOTIBru0G5We0x8vAQ+OaQLeif2xNoVx4EVF1TPzIEHhio1lqdsaR3KszqlYh9L59z2xkao22w4+ua2iDsJb6n/vzfVc7TQSVVV0H9Y+DDMbbllm6aZkVN6f1Q9f0OilMDPsCtvdSHhX0j6+hlMKoeUzJP7qlu76k/nb//yGBIClO7Dy8/oi7ToKbsOkU4Bn1F8ZB/tmYkQV/UW/sw9aezmn6hEd7cqT6/oRt0jFAfFgmhah/9AiNM/8nxs3f1gf/utQX9qzqpNzEB9I2G23qr+e+4YLggoeaeHQZT9YC/+mo1gN7zq+1q49weRTW5sQe8VtVg+sQm2/Krq6Z4uKmHbdmYDhAfUnNu22RW3+/ZRq313tlHPZGcPmf9xbvV9dqH2b5Pi6/tcuP7JkNkoNpryL5bLMC/L1KDbLHJdiIa0U5tV3h5m3qSsrDU9Bdfqp70Hh2i1ur7/lc9qdmbuAIua+/8+K7qBMvHOy6zT48dKoTvqxp0r+jgfBsAof7gp4HKqsxKTVc3H45RUzRFJnh2BGywS9Hc2QfevVT9e6hUbFdPj50H5yfApV+riZvOH8Bz51e/CrWR9I7wcUlVQd9ZTt++lt4vpuZtRJxzQ9KtPeHarpBnVHvtzOwPDw2GxzepwfXKjup6Dw1WfyqKmuu377FRk5u6wxVVn1+Y4fyfW+cHK8bD5f9zXJ47TS3rqETH2q1WA3/rQTURgfDDRLWhtSaWk4VGA/+5TM3Bhy+qvt6/tlRfBmotOCIQzk613RB2/0C1odRyFfDgILin6sam0wZICIGbe6pXWBtPqwHdeoylthP49d3grr6Ox++sbD9WNZxm3gK9/2tbPrN/9XU1GvWkvStPDc71Cfp+Wpg/Cu6r5Wot605oFwoXJ0GQv1oZUIDkMOgdrV5VajXOb37rFun42tLoOzIB7k+BtjoNtPIePBL0Ra0UxdZzuUNV0D9YWH3U2Z12aYLBcTVv7y8d1NpilA7euhjahqjLp/eDv/e1bfOti51/XqOBtBvVniPv7lJrys7GU+kWCYsutb2e0st29WARoIVfr4UebdRgaDKrgeTJYRAdpK6z4CK1Rm3pLfS3HjV3J+wTreaoz5RATDCkxDoGr5cvdFw/NEBt7MwugX+ep968VpcJnavfAfziSPVK6MHBtrYDUAOjpVY/pRf855yG8U1VPWR6VaXg7IUFqr9HZz1+BsZCr2j1ztkduernLSfXcwVVRZj/HVJ7A1mu1mpzbwoEauEfP6uve7dRTwS3roF/na8eF0Cy3e+hUwQcu6P27YL699YupPoV1jVd4IbucKQAKLAslZq+8HHdotSf+Ua1X7h9gNlhV9P/Sy01uegg+OEa5+/Vt+0iLBD6xsBrF6mv37tM7VXzl29s6+yb7Li9Sd3VbnvdPlRfL7xYTRsFV/0HHL5NPQmcG/x0fvD0cLWveaQOFoyquVxaDbxjd6LZY3eF8NkV1a9yNBpYM1F9frZU/Xxddx3PHlR92bB26qM2lhRHiV13xY1Vuezhzqeh5pnh8Nl+mNHfsevs1KorgrcuVntJzRqglt0ZS4pnYVWq6taeEFCPYSu62NXIF14Co5PUK5ymtm/p/GDvZDU19PFedZm/Fm7pqT5v/Rl9CfpexR31DgXbP0KIv1rLPVakNjjaB/20qhrh51fWfywaVwkJUHPqK8erOfEXL3AeHLpEqDX3qECY3Mtxndjg6utbBPnDtr81vFy9ouHHidAmSG28rE1csJpmumk11snnE0Lhv39RrxZ25sLUPmpvlsaIqbpyOVOinli0GlvQH1HDCeOqzuoD4L4UWFDVvmEJ+hckqo/a3NrT1n02Sqc2ZNfHmGT1u0sOh+5R6jJXdWiICFSvHixu66V+1wBaT+k10Ywk6Is6OJ5qekbZgv6FVf/wpRW2nH5NtcaWMLaT+qiJRqOmDlrSpU76qtfkyo7w937qjVUh/pBxs3pl9N1f1V48l9bQiFofkVVXGQrqzUk6P9sNUDUFfXsPDYbEUDWI6xpwUr+zj/r3sfWs2v4QH1K/z2k0DfvuGmpcJ7WC0C9GbQOw7td+JfvcZisiQd8LuPPvzv6GMA1q75O1x9XumBbbzqo9ZOJDas53i/pJHaLmzMd0sLUrnNsTqjGC7f7TSyrUXHxhuVr7rq3h3SIpzLHXT31pNK4dMdNVBsbBoduqL68pTdWaSNAX9aagsQaI7XYNfPa5YR+4Om5WbYLU3jau5qdV2yxMZrXmvbrqTugxyWpOW6g0MuCa8HX2f/YaDQyrSt9syrY1OlpytiPr6JUh3MtS2y8ywVcH1edX1tDrxlf5Qk1fgr5okP4xavDQl6t5/fJKddgDcD7WivAcfaPVn/+3Qb0TN8hPvUdC2Gh84FJVgr6o1bk5fX+trbb/43H1pqBik9r7pLE9S0TLmN5P/bmqKrUzpVf1sX58nUNyx90jHDYTCfpexFP+Bi13li49YBsJ87quvnFp7M1u7Qnjq353vdrA3PPdWx5PZF/R95B/N5eThlxRq3Nz+qCOrfPQb47jokzti/Bwflr45ip1OIqksIZ1vfQV9ukdqekLt/G0CnRyONwzwPb61p6Ok1QIz6XRqHe7SsB3zj4gNnROZm8hNX1RK4eavt3zVy5Ux5apMKvDGQjRGmjscpStNOZ7Tk3faDQyffp0YmNjiYmJYebMmZhMJqfrbt++nQsuuIDQ0FB69uzJ119/3cKlFX5auKMPTOvX8sMuCNFcHGv6rTPse0zQT01NJTMzk/T0dDIyMti7dy9z5syptl5ZWRnjxo1j4sSJnDlzhkWLFnHXXXexY8cON5S69XPoveNpeSYhXKz135rlIUHfbDazePFinn/+eZKSkkhISOCVV15h4cKFVFY6Tsr53XffERYWxkMPPURoaCgXX3wxt912G2+//babSi+EaC20dukdyek3owMHDmAwGBg6dKh12YABAzCZTOzevZv+/W0zNGzbto1hw4Y5fH748OG89NJLTrdtNBoxGo3W13p9jdPk1C73fij9rnGfbaKhFXCgasjeo5m1r+tqWswkV41AKRV90drZ/43nHepPjpvqxfqIj+mf1Dx9aj0i6Ofm5hIWFkZgoG3AcY1GQ3R0NNnZ2Q5BPzc3l5gYxxGiYmJiyM7OdrrtefPm8fTTTze9kOYzUHGo7vWaQTDQNdQtu7bKMiYSF1DL+MNCtAJB/jpOlHWgfdAxkoOPuK0c2yrLmm3bHhH0a7r1WVEU/P3961zX2XoWqampzJ492/par9eTnNyI8QKinobwexv+ORc5WwrZpW7bPcnxvfD384g/FyGajVarJaLTDjLyWviS+hxd2jRflziP+C+Oi4ujuLiY8vJya23fbDaTn59PfHx8tXUPHz7ssCwnJ6faehY6nQ6dzgX3mgd0Vx9uEhcEcW3qXk8I0TQRQZH0Sxzh7mI0G49oyO3SpQvR0dGkpaVZl6Wnq9P0dO7c2WHdYcOGsXnzZodlmzZtondv6SwuhBB18Yigr9FomDFjBo888ggnT57k9OnTPPTQQ0yePJmgoCDGjx/PkiVLABg7diyVlZW89NJLlJSU8Msvv7BkyRKmTZvm5qMQQgjP5xFBH+Dxxx9n0KBBpKSk0KNHDxITE5k/fz4AR48eJTc3FwB/f3+WL1/O8uXLiY2N5bbbbuO1117jggsucGfxhRDCK2iU1jqqUA30ej2RkZEUFhYSEdHEOeiEEMLLeExNXwghRPOToC+EED7EI7pstiRLNqvRd+YKIYSHCg8Pr3PKR58L+kVFRQCNu0FLCCE8WH3aKn2uIddsNnPq1Kl6nRHtWe7kPX78uM81AMux+96x++pxg3cfu9T0ndBqtbRv377Rn4+IiPC6PwRXkWP3vWP31eOG1nvs0pArhBA+RIK+EEL4EAn69aTT6XjyySddM3ibl5Fj971j99XjhtZ/7D7XkCuEEL5MavpCCOFDJOgLIYQPkaAvhBA+RIK+EEL4EAn69WA0Gpk+fTqxsbHExMQwc+ZMTCaTu4vVLL788ktGjhxJWFgY8fHxPPjgg1RUVACQl5fHpEmTiIyMJCEhwTUTznugl156CY1GQ0ZGBuAbx52ens7VV19NmzZtCAgI4I033gBa/7FnZmZyxRVXEBoaSlhYGGPHjmXv3r1A6/2/l6BfD6mpqWRmZpKenk5GRgZ79+5lzpw57i6WyxUWFrJo0SKefPJJcnJyWLduHcuXL+ell14CYOrUqSiKwqFDh1i/fj3Lli1j4cKFbi61a23YsIG1a9cSEhJiXdbaj/vgwYNcddVVXHvttezfv5/S0lLuuusuoPUf+4QJE+jWrRsnTpzg6NGjJCUlceONNwKt+P9eEbWqrKxUwsPDld9++826bPv27Up4eLhSUVHhxpK1jHnz5ilXXnmlkp2drWi1WuXEiRPW9/73v/8pvXv3dmPpXCs7O1vp27evcvjwYSU0NFTZuXOnTxz3xIkTlU8//bTa8tZ+7CaTSdFoNEpGRoZ12a+//qoEBwe36v97qenX4cCBAxgMBoYOHWpdNmDAAEwmE7t373ZjyVpGTk4OCQkJbN++nYSEBJKSkqzvDR8+nD179rSKYarNZjO33norzz33HJ06dbIub+3HbTQa+fHHHwkNDWXAgAGEhIQwatQo9uzZ0+qP3d/fn0mTJvHss89SWlpKSUkJr7zyCtOmTWvV//cS9OuQm5tLWFgYgYGB1mUajYbo6Giys7PdWLLml52dzYcffsj06dPJzc0lJibG4f2YmBgUReHMmTNuKqHrPP3006SkpHD11Vc7LG/tx33o0CHKyspYvHgxK1as4MSJE/To0YPrrruu1R87wHvvvUdAQAAdOnSgc+fODBo0iFdffbVV/9/73CibDVXTMKWKouDv33q/vuLiYiZMmMADDzzA8OHDOXz4cLV1lKqbub39e1i7di0//fQT69atq/aes99/azlugPz8fBRF4f3336dNmzYAzJ8/nzZt2nD06NFq67emYwdYs2YNf/75J/PmzePw4cO8++67pKSk0K5dO6frt4b/e+8ufQuIi4ujuLiY8vJy61nfbDaTn59PfHy8m0vXPEpLS5k4cSIjRowgNTUVUL+H3Nxch/VycnIAvP57mDdvHlu2bCE2Nta6zGAwMHLkSJKSkqwT71i0luMGCA4Oxs/Pj6ioKOuyyMhIQkJCqKysbLW/c4CzZ8/yt7/9jd9++43BgwcDMHHiREaPHs2qVata7f+9pHfq0KVLF6Kjo0lLS7MuS09PB6Bz587uKlazKS0tZcKECfTq1YtXX33VunzIkCFkZ2dz6tQp67JNmzbRsWNHgoOD3VFUl/nkk0/YvXs327dvtz5A7b66fv36VnvcAL169UKr1bJ582brsqysLAwGA3fccUerPvaDBw+iKAqDBg2yLjvvvPMICgqioqKi9f7fu6sF2Zs88cQTyqhRo5QTJ04oWVlZymWXXaZMmzbN3cVyuZKSEmXMmDHKfffd5/T9KVOmKNdff72Sk5OjHDx4UOnfv7/yr3/9q2UL2UIAZefOnYqitP7jvv/++5WUlBTl0KFDSnZ2tnLttdcqV155paIorfvY9Xq9EhkZqcyZM0fJy8tT8vPzlaeeekqJiopS8vPzW+3/vQT9ejCZTMq9996rxMTEKOHh4crkyZOVoqIidxfL5T744AMFcPo4fPiwUlRUpNxyyy1KRESEEh0drdx///1e332tJvZBv7Ufd3l5uXLfffcpMTExSlhYmHLdddcpZ8+eVRSl9R/7pk2blNGjRyshISFKcHCwctFFFymbN29WFKX1/t/L0MpCCOFDJKcvhBA+RIK+EEL4EAn6QgjhQyToCyGED5GgL4QQPkSCvhBC+BAJ+kII4UMk6AshhA+RoC+EED5Egr7weYsWLbLOCWtxzTXXsGzZshYrg8FgoEePHmzcuLHGdcxmM+effz5ff/11i5VLtD4S9IXP++mnn6ot+/rrr7n22mtbrAzz589nyJAhjBgxosZ1tFotL7zwAvfffz/l5eUtVjbRukjQFz7txhtv5PPPP+eee+5Bo9Fw9913AzB06FDef/99AH7++WdGjRrF+++/T4cOHQgNDeXmm28mOzubm2++mbCwMBITE3nzzTcdtv3LL78wZMgQgoOD6d+/P6tWraqxHO+884513wDPPvssycnJBAcH06dPHz766CMALrroIvz9/Vm9erWLvwnhM9w94psQ7jZ69Gjl9ddfd1g2ZMgQZcmSJYqiKMpPP/2kBAUFKVOnTlXy8/OVnTt3Ku3atVMSEhKUJUuWKEVFRcqXX36p+Pv7K8eOHVMURVEOHTqkxMXFKatXr1ZKSkqU7777TomIiFAOHjxYbf9btmxRoqKiFLPZrCiKoqxbt06Jjo5Wdu3apZSUlCh//vmnsmPHDuv699xzj3LXXXc107chWjup6QtRD2VlZcybN4+oqCj69evHuHHj6NixI7fffjthYWFcd911JCUlsWvXLgDeffddbr75Zq644gqCg4P561//yogRI5zm4zds2MB5551nnZqxpKQEs9lMZGQkwcHBnHfeefTv39+6/qhRo/jtt99a5sBFqyNBX4h6iIyMdJhOsU2bNnTt2tVhnbCwMIqLiwHYsWMHCxYsQKPRWB9r1qxxOql2VlYW7du3t76+8sormTJlCv379+e+++7jyJEjDusnJiY6zGYlRENI0BeiHpxNhl3bBNmKojB37lwUdaIi6+PFF1+stm5eXh4RERHW135+fixYsICtW7fi5+dH//79+fzzz63vx8XFodfrMZlMTTwq4Ysk6Aufp9VqqaysdOk2+/Tpw6ZNm+q1blRUVLUJyAE6derE/Pnzef7553n22Wety/Py8ggLCyMgIMBl5RW+Q4K+8Hnt27dn7dq1lJSUUFhY6JJt/v3vf+fHH39kwYIFFBQUkJeXx4oVKzh+/Hi1dRMSEsjKyrK+TktLY+3atRQUFFBQUMCWLVsc0j+nT58mISHBJeUUvkeCvvB5jz32GKdPnyYmJoZnnnnGJdvs3r07a9as4YsvviAxMZHOnTvz8ssvoziZnXTEiBFs3rzZmq4xm808/PDDJCUlkZSURFZWFm+99ZZ1/Q0bNnD++ee7pJzC98gcuUK4maIoJCUl8dFHH3HZZZfVuX6vXr147rnnWvTmMdF6SE1fCDfTaDRMnTq12s1dzvzwww8UFxczbty4FiiZaI0k6AvhAR5++GF27NjB77//XuM6ZrOZhx56iAULFhAUFNSCpROtiaR3hBDCh0hNXwghfIgEfSGE8CES9IUQwodI0BdCCB8iQV8IIXyIBH0hhPAhEvSFEMKHSNAXQggfIkFfCCF8iAR9IYTwIf8PjMj4jGjUCiIAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "target = 2\n", + "Starting simulation at t=0. s for a duration of 90. s\n", + "5.3376 s (5%) simulated in 1m 0s, estimated 15m 52s remaining.\n", + "10.7968 s (11%) simulated in 2m 0s, estimated 14m 40s remaining.\n", + "16.3904 s (18%) simulated in 3m 0s, estimated 13m 28s remaining.\n", + "22.1738 s (24%) simulated in 4m 0s, estimated 12m 14s remaining.\n", + "27.803 s (30%) simulated in 5m 0s, estimated 11m 11s remaining.\n", + "32.9368 s (36%) simulated in 6m 0s, estimated 10m 24s remaining.\n", + "37.946 s (42%) simulated in 7m 0s, estimated 9m 36s remaining.\n", + "43.1956 s (47%) simulated in 8m 0s, estimated 8m 40s remaining.\n", + "48.3988 s (53%) simulated in 9m 0s, estimated 7m 44s remaining.\n", + "53.3826 s (59%) simulated in 10m 0s, estimated 6m 52s remaining.\n", + "58.8052 s (65%) simulated in 11m 0s, estimated 5m 50s remaining.\n", + "64.4326 s (71%) simulated in 12m 0s, estimated 4m 46s remaining.\n", + "69.614 s (77%) simulated in 13m 0s, estimated 3m 48s remaining.\n", + "75.3188 s (83%) simulated in 14m 0s, estimated 2m 44s remaining.\n", + "80.6286 s (89%) simulated in 15m 0s, estimated 1m 45s remaining.\n", + "86.6446 s (96%) simulated in 16m 0s, estimated 37s remaining.\n", + "90. s (100%) simulated in 16m 39s\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAIPCAYAAACfew4GAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB1pklEQVR4nO3dd3wUZf7A8c9ueg8pQBJC7y0gSBUQFRE8hFMPPRVsoP4QG4oYBSsn2LBgOTxPENvZ8E5BEVRQLCAECAZC7y2QuqmbTXZ+f0y2b/omu5v9vl+vfWV3Znbmmc3ud575Ps88o1EURUEIIYRP0Lq7AEIIIZqPBH0hhPAhEvSFEMKHSNAXQggfIkFfCCF8iAR9IYTwIRL0hRDCh0jQF0IIH+JzQV9RFHQ6HXJNmhDCF/lc0C8sLCQqKorCwkJ3F0UIIZqdzwV9IYTwZRL0hRDCh0jQF0IIHyJBXwghfIgEfSGE8CES9IUQwodI0BdCCB8iQd8LrM04S8dH1pB+It/dRRFCeDmNr90uUafTERUVRUFBAZGRke4uTrUURaHfk+tQFIXi8krz9KOLr3RjqYQQ3s7f3QUQjhRFoVPqN+4uhhCiBZL0jgeqKeD72ImZEMLFJOh7mNqCepnB2EwlEUK0RBL0PYiiKHyw5bjNtGcm97F5XVJe0ZxFEkK0MJLT9xAdH1njMO3gPybg76dl2vCO9FzwLWUGIyXllcS6oXxCiJZBavoeoNSqd441fz/LvycsUD0+l1SzrBBC1IUEfQ+w+UiOw7TX/j7Q5nVokB8AxZLeEUI0ggR9NyssM3Dr8q020+69pCtXpSTaTAsNUGv61Z0VCCFEXUhO3836PbnO5nV1F1+Za/p6qekLIRpOavoeZJJd7d6a5PSFEK4gQd+NdGUGm9dL7fL41kIC1Zq+BH0hRGNI0Hej/lapnbnje9S4bJg56Et6RwjRcBL03cRotL3ydtbFXWpcPjRI0jtCiMaToO8m+88Vmp9ffUESGo2mxuVDA6TLphCi8STou4GiKFzxyibz6yVTB9T6HnNNXy81fSFEw0nQd4OGDJscKg25QggXkKDvZk9M6l2n5aQhVwjhChL0m5n9wGq3juxUp/eFSj99IYQLSNBvRo99+afN6/0LJ9T5vaFS0xdCuIAE/Wb0od1Y+YH+df/4TQ25xdKQK4RoBI8M+p9//jkjRowgPDycNm3a8OCDD1JRodZwc3NzmTp1KlFRUSQkJPDUU0+5ubQN8/PcsfVa3pTTLzVI0BdCNJzHBf2CggKWLVvGE088QXZ2Nj/++COrV6/mhRdeAGDGjBkoisLhw4fZtGkTq1at4q233nJzqWu3NuOs+fmHM4bSPja0Xu83DcMgA64JIRrD44J+VFQU69evZ/z48QQHB9OnTx9uvfVWfv75Z86dO8f//vc/XnnlFWJjY+natStPP/00S5cudXexa3XXB2nm54M7tqr3+2XANSGEK3hc0HcmOzubhIQEdu7cSUJCAklJSeZ5Q4cOZe/eveh0OjeWsH6C/P3q/R7T0Mol5RW13jxdCCGq4/Hj6WdlZbFy5Uq+/vprDh8+TGys7R1iY2NjURSFc+fOERkZ6fB+vV6PXq83v3bHwUFf0fjauanLplEBfYWR4ID6HziEEMKja/pFRUVMnjyZBx54gKFDhzodn8ZU6/X3d378WrRoEVFRUeZHcnJyk5bZmSe/2m1+fs0F7Rq0jhCrIC8pHiFEQ3ls0C8tLWXKlCkMGzaM1NRUAOLj48nJsb2fbHZ2NgBt2rRxup7U1FQKCgrMjxMnTjRtwZ34+A/LNv/x174NWoefVkNwgPrvksZcIURDeWR6p7S0lMmTJ9OzZ09efvll8/RBgwaRlZXF6dOnSUxU7zK1ZcsWOnToQEhIiNN1BQUFERQU1CzlrovGpGXCAv0pM5RLTV8I0WAeV9M3BfzevXvz+uuv26R0oqOjueGGG7jvvvvIycnh8OHDPPHEE9xxxx1uLHHzsW7MFUKIhvC4oP/ZZ5+xfv16Xn31VTQajc3j6NGjvPHGGwQFBdG5c2cuvPBCLr30UubNm+fuYlfrdH6p+flrNdwOsS5CA6TbphCicTwuvTN9+nSmT59e4zIffPBBM5Wm8UYs/tH8/OIe8Y1al6mmLzl9IURDeVxNvyWLDA5o1PvlAi0hRGNJ0G9C1vfBnTwgsdHrCwuSWyYKIRpHgn4TeuX7/ebn4/u0bfT6woPUM4WiMgn6QoiGkaDfhF778aD5+YS+rgj6ak2/SHL6QogGkqDfRCqNtuPjOLuauL7Cg9WcfqHU9IUQDSRBv4l8ts1yFe5HM4e6ZJ3m9I7U9IUQDSRBv4k8sspya8QRXeJcsk5TTV+6bAohGkqCvheRnL4QorEk6HsRU3pHcvpCiIaSoN/E4iNcN9hbeNXN0aWmL4RoKAn6TeBsQZn5+UOXd3fZeiMkpy+EaCQJ+k3goc/Szc/H9W58/3wTc01f0jtCiAaSoN8EhnWOMT+PCQt02XrDTEG/vMJmiAchhKgrCfpN4MV16vALpjtduYopvaMoUGKQQdeEEPUnQb8JlRmMLl1fkL8Wf616Za+keIQQDSFB38XKrGrgC6c07H641dFoNOYLtKQHjxCiISTou1jmGZ35+Y1D27t8/aYx9SXoCyEaQoK+i53Ot3TXdMUga/ZMeX1J7wghGkKCvov9vP98k67fcoGWoUm3I4RomVx2j1yDwcDOnTs5ffo02dnZxMTEkJCQwIABAwgODnbVZjzeJ1Wja7aNbJp9luGVhRCN0eigv27dOt5++23WrVuHoigkJCQQHx9Pbm4uZ8+exWAwcNlll3HHHXcwceJEV5TZK5zVldW+UAOYavpyVa4QoiEald6ZMmUKs2fPZsCAAfz0008UFhayf/9+fv31VzIzM8nLy2Pz5s0MHz6ce++9lylTprio2J5JUSwXTKUkRzfJNmT8HSFEYzSqpj9+/HhWrVqFVlv9saNv37707duXOXPm8MYbbzRmcx6v0CoQT+qf0CTbMAX9Qgn6QogGaFRN///+7//QarX8+eefGI3OL0Rat24dAAEBAdx///2N2ZzH27jP0oh7+0WdmmQb4dJ7RwjRCC7pvZOSksKQIUPIyMhwmDdhwgRXbMIrHD5fZH7eFN01QdI7QojGcVmXzbvuuotLLrmEZ555hspKy1Wp1nnulu6V7w80+TZkpE0hRGO4JOhrNBpmzJjB9u3b+f333xk8eDDp6enmecJ1IkPUu2fpyqSfvhCi/lzWTx+gXbt2fPPNNyxfvpzLL7+cO++805Wr9xq3juzYZOuOMgX9UqnpCyHqzyU1/c6dO9u8vvXWW9mxYwc7duxwxeq9zoAm6q4JEBmsBv2CUqnpCyHqzyU1/QMHHHPZiYmJfP3115w4ccIVm/B41qNrmsbHaQpRkt4RQjRCk4+9k5yc3NSb8AjHckrMz8f2aN1k24kMUQ8oJeWVGCpdO16/EKLla1TQ12q1+Pn5VfswzW8InU7HNddcQ8eOHW2mL1y4EI1GY/NYvHhxY3bDJTbuO2d+3pSN1xFV6R0AnaR4hBD11Kg8xJ9//ml+rigK/fv3t5nWULt37+baa68lJSXFYd6ZM2d4/vnnmTt3bqO340r7s4pqX8gF/LQaIoL8KdRXUFBqIDY8qFm2K4RoGRoV9Pv06WPzWqPROExriA0bNvD8888TERHB5s2bbeadOXOG0aNHN3obrhYepJ7R/KWJhl+wFhkSQKG+Ap301RdC1JNHjqc/e/ZsJk2a5HRednY2s2fPJigoiNjYWG6//Xby8vKqXZder0en09k8mkJuiZpqacqeOyamvvrSg0cIUV8eGfRr8sknn7B9+3YKCgrYuHEjmZmZTJ8+vdrlFy1aRFRUlPnRVA3L2YV6AOIjmj7dElnVO0hy+kKI+vK6oJ+QkEBycjLBwcH069ePt99+mzVr1pCTk+N0+dTUVAoKCsyPpupCml2kBv24ZsixR0lNXwjRQI3K6f/tb3+z6amiKApTp051WO7TTz9tzGZq1K1bNxRFIT8/n9jYWIf5QUFBBAU1fSBuzqAvQzEIIRqqUUG/b9++Nq9d0YhbX5mZmYSFhZGUlNTs2zYxVBrJq8rpx4UHNvn2pKYvhGioRgX9J554wlXlqJOioiJefPFFbrjhBjp06MDevXuZMWMGd999t1vvw5tbXA6o3SlbhTZ90DcNxSDj7wgh6qtROf0XXnjBZhjlmuj1+kZfRBUQEMC+ffsYM2YMkZGRXH311VxzzTU8++yzjVpvY52vasSNCQtEq236UUWjQqQhVwjRMI2q6e/YsYOuXbty2223MXnyZPr27etw68Rt27bx9ddf8+6773LRRRfVa/0XX3wxR48eNb8OCgri448/bkyRm0Rz5vNBcvpCiIZrVND/6KOP2LRpE2+//TZjx45Fr9fTtm1bIiMjycnJISsri+DgYCZMmMDKlSsZO3asq8rtUbKL1PROc+TzQXL6QoiGa/RwkKNGjWLUqFFUVlaye/duzpw5Q25uLtHR0SQkJNC7d28CA5snGLqLqaYf39w1fQn6Qoh6ctkYwH5+fvTv35/+/fu7apVew3RhVlwzXJgFUtMXQjSc112c5YlMNf3YsOY5ozH33imr8Kl7EAshGk+CvgtYcvrNW9OvNCoUl9et95QQQoAEfZcw995ppvROcICWAD+1a6jk9YUQ9eGyoP+f//yHyZMnM3z4cPO0LVu28MMPP7hqEx7L0mWzedI7Go1G8vpCiAZxSdB/8cUXefTRRxk+fDh//PGHebpGo+HBBx90xSY8VkWl0Zzeaa7eOwDRVVf+5pWUN9s2hRDezyVB/7XXXuO7777jkUcesWlY7NOnDwcPHnTFJjzWH0dyzc9jmqkhFyDGFPSLpaYvhKg7lwT9vLw884Bn1qNuFhQUEBAQUN3bWhx/v+ZrImkVpn6uuVLTF0LUg0ui1JgxY1i2bJnNtPLych599FHGjRvnik14rJyqwdaGdIpp1u2aziryiiXoCyHqziUXZ/3zn/9k4sSJvP/++yiKwvjx40lPTycuLo7169e7YhMe63R+KWBJtzQX02ieuRL0hRD14JKg365dO3bs2MGPP/7Irl27UBSF++67j3HjxrX49M7yX48CsD+rsFm3a67pS3pHCFEPLgn6n376KVOnTmXcuHE26Zzi4mLWrFnDlClTXLEZj1RZ1XA9rIvjXbuaktT0hRAN4ZKc/t///nen0wMCArjppptcsQmP1T4mFIBRXeOadbtS0xdCNESjavp79uwB1HvjZmZm2nTXrKysZPXq1bRp06ZxJfRwphuoxDfT1bgmrcKky6YQov4aFfQXLlzIpk2b0Gg0DvfH1Wg0JCcn88orrzRmEx5NURS3Bf0YSe8IIRqg0TdRqayspHv37hw6dMhVZfIa+SUGSg3qgGetI5r3Hr2mfvqlhkpKyysJCfRr1u0LIbxTo3P6fn5+ZGRkuKIsXmfrUcvVuM0ddMOD/M2DrkleXwhRVy7pvePv78+bb75JRkYGZWVlDvPfffddV2zG45S4cVhjjUZDq9BAzhXqyS0uJzE6xG1lEUJ4D5f03rn99ttZunQpAQEBvPfee8TExJCXl8e3337LFVdc4YpNeKSf95936/alB48Qor5cUtP/5ptv2LFjB8nJySxdupQXX3wRUGv4mzdvZurUqa7YjMdp10qtXY/v454eStJXXwhRXy4bISwmRh17JjY2ltxcNdc9depUPvjgA1dtwuPsOaMDICHKPakVGX9HCFFfLgn6AwcOZNu2bQD07duXjz/+GICDBw9iMLTcfuTfZ54DIONUgVu2bxlps+V+xkII13JJ0H/66afNF2HNnz+fefPm0atXL0aNGsXs2bNdsQmP1Lqqb/5VAxLdsn1LX329W7YvhPA+LsnpW98i8dJLL2XPnj388ccftGvXjmHDhrliEx4pLjyIc4V681AMzc10Va7k9IUQdeWSoD9x4kS+/PJLgoLUmm/79u1p3769K1bt0Uz3pzXdr7a5xVXdnjG7UIK+EKJuXJLe2b59O8XFxa5YlVcxBf3oZh5L38Q09IPpxuxCCFEblwT9OXPm8Oijj1JZ6b6LlZqbodJIkb4CgGg31fRNQd80/o8QQtTGJemd4uJi1q9fT6dOnRgwYADBwbbj0Hz66aeu2IxHMdXyASLdHPQL9RUy/o4Qok5cEvS1Wi3Tp093xarMdDodt956K2lpaRw9etQ8Xa/Xc++99/LFF1+gKArXX389r7zySrPfoetkXqn5uZ9WU8OSTSciyJ8gfy36CiPZRXqS3dSgLITwHi4J+k888YQrVmO2e/durr32WlJSUhzmpaamkpmZSXp6OlqtlmnTpjF//nyee+45l5ahNsVVqZ1Af5dd31ZvGo2G+IggTuaVcq5Qgr4QonYuCfqutmHDBp5//nkiIiLYvHmzebrRaOSdd95h7dq1JCUlAfDSSy8xatQonn32Wfz8mi+9UVimpnf6JUU12zadMQV9yesLIerCI4O+6YKujRs32kw/ePAgxcXFDB482Dytf//+GAwG9uzZQ79+/RzWpdfr0estAVGn07mkjLoytaYfEezejzA+XHrwCCHqzn25iQbIyckhPDycwEBLF0mNRkNMTAxZWVlO37No0SKioqLMj+TkZJeUxXRBVCs3ddc0iZMePEKIenBJ0H/++ecpL6/+AqHff/+dL774gpycnEZtR6Nx3mCqKAr+/s5r3KmpqRQUFJgfJ06caFQZTEyDnMWGuTfom2r656WmL4SoA5fkJlJTU+nQoQNHjx5Fq9UyYcIE+vbtC8CTTz7Jiy++SGJiItnZ2fzyyy/07t27QduJj4+nqKiI8vJyc23faDSSl5dX7Q3Yg4KCzFcKu5K7r8Y1kb76Qoj6cElNX1EUbrvtNn799Ve2bNnC2LFj+d///gfA22+/zW+//cb+/fu59957WbhwYYO307lzZ2JiYkhLSzNPS09PB6BTp06N24l6MgV9d/XRN5GgL4SoD5e1Qq5bt46RI0cCsG/fPm666SYmT57M2bNnzQ2sd911F0OHDm3wNjQaDbNmzWLevHl8/PHH+Pn5MXfuXKZNm+ZwQVhT87SavjTkCiHqwiVBPzg42KZPfbdu3Th3Th1rXqPRmHPx8fHxnD/fuFsMLliwgPz8fFJSUigvL2fKlCksWbKkUetsCI8J+lU5/XOFehRFqbbdQwghwEXpndGjRzNz5kx27tzJ7t27ueeeeygoKGD27NkoisLu3bsByMzMJC4urs7rvfjii22uxgX1Juyvvvoq2dnZ6HQ6Vq5cSXh4uCt2o148Jb3TOlIN+uUVRpuhIYQQwhmXBP1///vf5OXlMWTIEAYMGMCBAwfYvn07rVu35r333mPy5Mn83//9H1OmTOHGG290xSbdzlNq+kH+fuYeRKfzy9xaFiGE53NJeicpKYm1a9eiKAqKoqDVqseSxx9/HIB27dqxatUq5syZw1133eWKTbqV0aiYR9h0d9AHaBsVTE5xOWd1pfROjHR3cYQQHsyll5Na5++tjR07lrFjx7pyU25VXF6BoqjP3X1FLqg3Zt99WseZAqnpCyFq5pL0zoEDB7jsssuIjo7Gz8/P/NBqtc06Hk5zKSlX7xug1UCQGwdcM0mIUnsunZH0jhCiFi6pps6cOZM2bdrw7bffEhnZ8tMLpqAfFujvEb1l2pqCvtT0hRC1cEnQT0tL49SpUz4R8MEyrLKn3LTEVNM/qyutZUkhhK9zSW4iOTmZoqIiV6zKK+iqhlX2hHw+qDl9kPSOEKJ2Lgn6Tz/9NPfeey8nT550xeo8XqF5WGX399wBq5x+QRmKqYVZCCGccElVdenSpWzbto0vv/yS0NBQQkJCbOabrs5tKYo8ZCx9E1NOv9RQia60gqhQzzgYCSE8j0ui1tNPP+2K1XgN012zIj2kph8c4Eer0ADySgycLiiVoC+EqJZLgv6YMWNcsRqvYbowKzzIM2r6oOb180oMnCkopVeCbzSoCyHqr1FR67///S9Tpkxh5cqVNS43ffr0xmzG4xR6WHoHIDE6mD1ndJySxlwhRA0aFbVWrlzJlClTWLp0abXLaDSalhf09Z7VkAvQrlUoACdzS9xcEiGEJ2tU0F+1ahUAW7dudUlhvIWpph/uQTX95Bg16J/Ik6AvhKieS7psTpw4Eb3ed27iUeRh/fQBklupPaaOS01fCFEDlwT97du3U1xc7IpVeQVzTt+DGnJNNf2MUzrKK4xuLo0QwlO5JOjPmTOHRx99lMrKSleszuN52sVZYAn6AL8eynZjSYQQnswlVdXi4mLWr19Pp06dGDBggMP9aj/99FNXbMZjFOk9r/eOdffRsnLfOPgKIerPJVFLq9W2uB46NTGNveNJDbkAUwYk8t+dpzmS4zupNiFE/bgkaj3xxBOuWI1XUBTFI2v6AB3jwgA4mi1BXwjhXKOi1unTp0lMTOT48eM1Lte+ffvGbMajFJdXmu+a5SnDMJh0Mgd96cEjhHCuUUF/zJgxHDhwgI4dO6LRaJyO8KjRaFpUA69psDV/rcYj7pplrWNsVdCX9I4QohoNDvp79+5l165dABQWFrqsQJ6uSG/J53vCXbOsmYL+uUI9xfoKwjyoS6kQwjM0uKo6ZswYysrUcV6ee+45wsLCqn20JKZbJYYGeMZds6xFhQbQqmqETantCyGcaXDQLy4uNl+F+49//MNlBfJ0xXo16HvKrRLtdZS8vhCiBg0+/7/66qsZMmQIF154IYqiMHXq1GqXbUn99EsNak7fU1MnnWLD2HE8nyPZvnP7SiFE3TU4ci1fvpzPPvuMgwcPsmbNGvr06ePKcnksU3onxAPTOwBdWocDcPCcBH0hhKMGB30/Pz+uv/56AE6ePOkzffVLqtI7oR6a3uneJgKAfVkS9IUQjlzS5/Cf//ynK1bjFUrK1fROaKBnpnd6VAX9Q+eLqKiUgdeEELY8q6O5Fygu9+yafrtWIYQE+FFeYeSYDLMshLAjQb+eivWe3ZCr1Wro1kbN6+8/6zvXTwgh6sZrg/7ChQvRaDQ2j8WLFzf5dk0NuWFBnlnTB+jWWk3x7Je8vhDCjmdWV+vgzJkzPP/888ydO7dZt2uq6XtqTh+gR9uqmn6W1PSFELa8tqZ/5swZtwzkVlzVkBvuoekdsPTg2XtW5+aSCCE8jdcG/ezsbGbPnk1QUBCxsbHcfvvt5OXlOSyn1+vR6XQ2j8Y4la8OPeGpOX2APolRABzOLjYPAy2EEODFQf+TTz5h+/btFBQUsHHjRjIzM53eyGXRokVERUWZH8nJyY3abvqJfEAdZdNTxUcE0TYyGEWBPaelti+EsPDaoJ+QkEBycjLBwcH069ePt99+mzVr1pCTk2OzXGpqKgUFBebHiRMnGrXdpOgQwPNuoGKvXzu1tr/rZL57CyKE8CheG/TtdevWDUVRyM/Pt5keFBREZGSkzaMxygxq7512rUJrWdK9+iWpQT/jVIGbSyKE8CQtJuhnZmYSFhZGUlJSk21DURTz/XEjQ7yjpv+nBH0hhBWvDPpFRUU8+eST7N+/H71eT3p6OjNmzODuu+8mODi4ybarrzBiqFTvDubJvXfAUtM/nF1MYdWBSgghvDLoBwQEsG/fPsaMGUNkZCRXX30111xzDc8++2yTbtd0YRZ4dj99gLjwIJKiQ1AUSD8htX0hhMqzI1c1goKC+Pjjj5t9u6YLs4L8tfh5cO8dkws7tuLUzlL+OJrLRd3i3F0cIYQH8MqavrtYhmDwjmPl4I4xAGw7muvmkgghPIUE/XqwDKvsuePuWBvSSQ36O47nY5BhloUQSNCvF3NN38Pz+SZd48OJDg2g1FApXTeFEIAE/XoxD7bmwSNsWtNqNQzuoNb2Nx+WFI8QQoJ+vZR4+A1UnBlV1YC7Yd85N5dECOEJJOjXQ7GH3yrRmUt6tgYg7VgeBSXSX18IXydBvx5KzTl976npJ8eE0rV1OJVGhZ8PnHfJOisqjXL/XSG8lAT9eijWV6V3vKTLpomptr9hb+NTPEX6Cro+9i1dH/vWPCSFEMJ7SNCvB1OXTW+q6QOM7aEG/Y37z1NpVBq8HkVR6PvEd+bXH2w+1uiyCSGalwT9ejDl9EO8KKcPMLhjKyKC/cktLie9EUMt59m1Cfy83zXpIiFE85GgXw8lXpjTBwjw0zKmezwA3/55psHrOXze9kbr24/ny525hPAyEvTrocRLc/oAk1ISAfgq/XSDUzw/WrUJdIgNpbzCyA+ZWS4pn2g5zhfqG5VGFE1Lgn49FHtpTh/g4h7xRAb7k6XTs+VwTu1vcOLNjYfMz6+qOois2n7KJeXzZWWGylqHvz5fqDdfHOjJdhzP48J/fE+XR78hS1fm7uIIJyTo14Opy2ZIgPcF/SB/P67srwbqj7c27paRANcOagfAzwfOcyq/tNHr80WKovDeb0fpuWAto57fUG1vqBO5JVz4j++55KWNKErda9AFJQbe2XSYvOJyVxW5Vn998zfz86HP/uAw/787TtHxkTW8s+mwx50NlFcYmfPJTp78aneLHqtKgn49lFbdKjHEC2v6ADcObQ/A2owzZBfp6/Xe84WW5eeO70GH2DCGd45FUeDzbSdrfK/RqJhvM2lv39lCrnjlZzo+sobv99Q/VXQgq5AXv9tnU1OuLTCezi9l9PMbam2IPpBVyNqMMyiKQkGJgfQT+dz90XZO5JbUWq4yQyU7T+TXWJYf957jia92A5BfYqD/k+ucjpE0/78ZAGTp9Ex+41eHfXln02HOFNgeeAvLDKQ8vY6FazIZ/cIGhwD73Nq9rPj1CHe+v42v0k87bHP78bxq22vqc5Gf9T2ai/QV3P/JTgAWrsmky6PfUFBiwGhU6D7/Wzo+ssam3eh8oXpWar+93acLqj3rKdJX8Pe3NzPt31uq/Y6XlFfQ8ZE1XPnaJvQVlu/lJ9tOsGrHKVb8dpSlPxyo8z56G+9LTrtRqXkYBu/82PomRZGSHE36iXw+2XqCu8d2rfN7rWuh04d3AOD6Icn8fjiHT7YeZ9bYLgT4qXWI/JJy8ksMHMkp5kBWIc9+sxeAge2jeeHaFLq2DgdAX1HJ/Z/sZO/ZQgBmrNzGK9cNYFJKIvd+vIN2MSH0aBPBml1neGpyH3KKynlx3T5mXdyV3gmRVBiNjHv5ZwBe33AQrQZahQaSU1zOYxN7cWX/BL5IO8mtF3UiPMifD7cc47EvMyz78e4fDO8cy7jebbh1ZEcMlQqLvs3k87STfPF/I7i8at321mac5dCzE1EUhRfX7WPTgWw+njmMm/69hR3H8xnZNZZD54o5qyvj1pEdeWJSH0A9+Gmt7sOQftIxwP9l6S/sfeYKgq3OJn+yOjjtOlnA/qxCurUOZ+Xvx8wHjYVrMkmbfxmx4UEAPLLqT/N7CssqGLH4B3575FL8tBquW/Y7W45YxmL6bncWu08XkDqhFxWVRvo++R1lBrWm2yE2lGM5JXw/ZzSd48Lp+tg3GBWYPCCRV64bgEZj2Z9jOcUO+7Py92O8+LdowLZNyOTl7/dz7aB2lFeo27vkpZ84uvhKjuUUM+aFjeblvpo9ksjgAG769xZO5pWSGBXML/MuYX1mFsM6xRIVGsDOE/lMsTooDl74vfkz0VdUEqDVotVqePeXIwDsPq2jx/y1HHp2In5aDQv+a/luvPbjQR4Y191m/1oKjVKf88UWQKfTERUVRUFBQb1vkj580Q+cKSjj69kXme9B622+SDvJg5+lExMWyM8Pj63zbR83H87h+rc3A7Dn6fGAWpsdt+QncooNLL6mL1elJLF+Txb3/WdnjevavuAy/vXzYd766XCj9qU+FlzZi2fWZFY7/7aLOrJx33kOn3cMXI01smscvx7MBmDtfaMo0lfgp9XYpEKsPTy+B7eM7AjAu78c4cV1+x2W+euARL7c6VhD/9ugdpSWV7D6z7MO8y7r1ZolU1Po/9R6p9v9zx3DuO8/O8jSOa8hB/lr0FfYhov/3T2Srq3D0Gg0PPG/3XyWpp713XtJV1778SAA/3dxF+65pCuLv93Lyt9tr+3w10KFXSZlzb0XceVrvzhsPyrEn4JS5zX8S3u15ofMhl18uHBKX1KSo5i01PYs6qMZQxnRteXdfEiCfj0MeHod+SUGvp8zmq6tI5qohE2rolKtHR/JLubBcd2559JudXpfx0fWNHHJhPAso7rF8f7tQ91dDJeTnH49mPrpe9vFWdb8/bTcf5ka6N/edFgGYRPCCX+thk0HstncwJ5unsx7o1czqzQq5ryjN/besTapfyJvbTzE3rOFvL3pEHPH96z1PTcObc+HW44zY1Qn5ozrbjMv9Ys/+Z9dY+CQjjGM79OGIn0l6/ec5cW/pbDtWJ65UdLenqfHU2lUeOjzdL7LUBt0e7WNIPNsIfOv7MXrPx4gv7SCvklRfDhjCJ9tO8nCNZmM79OGRVf349OtJ+nWJpxebSPRaGD44h+dbmf22K60jw3hyPliZl/SleM5paz+8zRvbLB0R/1q9kiuel091f/XtEF0ig9n9+l8xvZojZ9Ww6s/HODtn4+Yl3/5uhQe+CSdAD8NWx69lOAAP07klOLvp+HhL3aRdiyvxs92+4LLzDn89347xnNr9zoss+7+0bSLCaGgxMDKzcd4q6r7bLC/lg9mDKVH2wj6PbnO5j2/P3IJUaEB1a73hzljWL8ni78NbseC/2bwTYYlJZQ2/zJ+2n+eswVljO/TlkuX/GSet/upyzlToOcyq2nWxvZozRs3DgRg5W/HWGy33WU3XcCo7vEU6yu48B9qD5+wQD/+eOxS+jxhuw8/zb2YYn0lE1/bZPNZ+Gk1PPhZOlm6MnSlBoqrKmQXd4/nzZsuAOBkbimXv+LYLjOkYwx3jenMsC6xvPL9fpv/ZUq7KD6+YxjPfpPJB5uP89zavXw8c5hNG4u3k/ROHRXrK+hTNe5M5tNXeG0PHpN1u89yx/tpBAdoWf/AGJJjQmtc/u4Pt7PmzzM8Mak3t47sZDNPV2bg8iU/c9aqX/bndw0336PXmqIoHMkuZtvRPP56QRIrfz/G8M6x9E50/r8o1lcQFuSPvqKSo9kl9Ghbt7TawXNFvLPpMA9e3oO48EDe2XSESkXhrjFdHJYtLa9k4DPrKDMYWXHrhVzcozWfbjvBsZxiHrq8R7WNeYqimOdVGhX8tM6XO3y+iFd/OMD4Pm2Z9eF2m3kzR3XisSt725W9kIc+28XOE/nmaUcXX2mzzAebj3Egq5Anr+pjLoPRqHAkp5i0o3l0jAsz3y7TJO1YLte89TsAmx4ea/M/P5pdzMUvbgTU3ln2jfyv/XCAJev38/oNA/lLVdff3OJyxrywgcIy2zz7F/83nEEdLNs2fXfMn8ezE80N2psP5/BF2kkWTOpNZHAAGacK+MtSNZ+/b+EVBPmrv7MVvx7hq/TTLJs2mPiIIOpqw75znM4v5cahHdh1Mh9DpcKgDq3M84v0FTbjST1/bX+mDk4mS1fG6Oc3oK+q6G197LJ6bdeTSdCvo/OFei78x/cAHFk00etb9RVF4e//2szmw7mM6hbHytuG1LhP1771G9uO5fHGDRdwZf8Ep8t8++cZHvtvBlcPTGL+X3o7XcZTncov5Vh2cZM33N3z8Q6+Tj/NXWO68PchyXSIDat22fv+s4P/7TzN8lsvNA+a11jF+gqCA/ycHqBWbT/JlsO5PD2ljznYmiiKQm5xubl3kL1Ko8KM97aSX2rgkzuGE+hvyRyfzCvhouc2APDq9QOYPCDJJfviKhmnCvh612nuHN2FmLBA8/SlPxzgpfVqI/qY7vG8d9sQdxXRpSTo19GJ3BJGPb+BkAA/Mp+5oglL2HyOZBcz/pWfKa8w8syUvkwb1qHaZUc/v4HjuSV8dtdwLnRSgxd1YzQqbDmSS0pylNd2/W2ItRln+HrXGZ6/pj9hXjKMiaHSyOVVnR4Alv59oHk4E28mDbl15O0XZjnTKS6Mh8f3AOCZr/fYXEhjTVEUzhWqqZvWLeQU1120Wg3Du8T6VMAHuKJvAm/ccIHXBHxQByrc8NDF3HOJmup65ItdHMgqdHOpGk+Cfh2VePEQDDW5/aJOjOvdhvJKI7e/t83p1aZZOr35Yp3WEcHNXUQh3Oq+S7sxrHMMxeWV3PbeVq8fU0iCfh2ZrsYNDmhZH5lGo+GlqSn0bBvB+UI9N7/7B2cLbL/U1pfGt6QzHSHqwt9Py+s3XED7mFBO5Jby1zd+ZfDC7+n4yBpSV/3pFQPhWWtZEawJmcboaEldt0wigwNYcesQkqJDOJxdzDVv/cae0zrz/MKqL3W3quEThPA1ceFBfDhjKG0igzhdUGYe1+fjP47T54nvuOKVn1m96zRlhkqOZBdz2oMHIZSgX0emrltB/i3zI2sbFcx/7hhG57gwTuWXcu0/f+OTrcdRFIXfqoYQiA0PrGUtQrRcyTGhfHLHcFpVXftgbe/ZQmZ/tIOeC9Yy9sWNjFj8Iyt+PYLRqGD0sNFEpfdOHX2dfpp7Pt7BsM4x/OeO4U1YQvcqKDFw90fb+aUq0I/pHm8e8KtfUhRf33ORO4snhNudL9Tz5saDDOkYQ9uoYOZ9sYv9WUU1vmf+lb24aVgHj8gUSNCvI9NAZaO7x7OyhfTXrU6lUeGdTYd5ad1+yq3GFb/30m4OV+MK4evKDJXsOJ5PqaGCV74/QH6JgSxdGQqYr+IHiI8I4pYRHfnb4HYOHSJMywU2QybBe/pPWdHr9dx777188cUXKIrC9ddfzyuvvEJAgONpl6uYgl+gX8tM71jz02q4c0wXxvVuw4vr9vFN1YiNY3vEu7lkQnie4AA/hneJBeCSnm3M04/lFPPaDwf5YvtJ2kQGkaXT88J3+1iyfj8Xd4/nkl6tGdkljvYxoUx8bROn8kq5pFdrxvdpy5hu8eYhNFzNK2v6c+bMYdu2bXz88cdotVqmTZvGoEGDeO6552p9b0Nr+it/P8rj/9vNlf0SeOPGCxpTfK+z57SOMwWlXNKztddfiSyEO5RXGPk6/TQfbDnGjuP5NvPCAv3MYweZWA934WpeF/SNRiPR0dGsXbuWESNGAJCens6oUaPIy8vDz6/mnFlDg/47mw6zcE0mUwYk8sr1Axu1D0II33Ugq5Dvdp/lp/3n2XlCHQ/I5I7Rndl0IJuPZgylVVjTdJzwuvTOwYMHKS4uZvDgweZp/fv3x2AwsGfPHvr162ezvF6vR6+33BRCp9PREC98tw9onpybEKLl6tYmgm5tIph9STdKyyv581QBe8/q6J0Q6XSQQlfzugiWk5NDeHg4gYGWo6BGoyEmJoasLMd7rC5atIioqCjzIzk5uUHbNQ0y1lX6qgshXCQk0I8hnWKYPrxjswR88MKgX9Mwt/7+jicuqampFBQUmB8nTpxo0HbvGtOF1fdcxMxRnRv0fiGE8ARel96Jj4+nqKiI8vJyc23faDSSl5dHmzZtHJYPCgoiKKjxg4R1b+Odt0cUQghrXlfT79y5MzExMaSlpZmnpaenA9CpU6fq3iaEEAIvDPoajYZZs2Yxb948Tp06xdmzZ5k7dy7Tpk0jOFhGgBRCiJp4XXoHYMGCBeTn55OSkkJ5eTlTpkxhyZIl7i6WEEJ4PK/rp99YDe2nL4QQLYHXpXeEEEI0nAR9IYTwIV6Z028MUzaroVfmCiGEp4qIiKh1fCyfC/qFheqNjRt6Za4QQniqurRV+lxDrtFo5PTp03U6IlrT6XQkJydz4sQJn2sAln33vX331f0G7953qek7odVqadeuXYPfHxkZ6XVfBFeRffe9fffV/YaWu+/SkCuEED5Egr4QQvgQCfp1FBQUxBNPPOGSwdu8jey77+27r+43tPx997mGXCGE8GVS0xdCCB8iQV8IIXyIBH0hhPAhEvSFEMKHSNAXQggfIkFfCCF8iAR9IYTwIRL0hRDCh0jQF0IIHyJBXwghfIgEfSGE8CES9IUQwodI0BdCCB8iQV8IIXyIBH0hhPAhEvSFEMKHSNAXQggfIkFfCCF8iAR9IYTwIRL0hRDCh0jQF0IIHyJBXwghfIgEfSGE8CES9IUQwodI0BdCCB8iQV8IIXyIBH0hhPAhEvSFEMKHSNAXQggfIkFfCCF8iAR9IYTwIRL0hRDCh0jQF0IIHyJBXwghfIjPBX1FUdDpdCiK4u6iCCFEs/O5oF9YWEhUVBSFhYXuLooQQjQ7nwv6QgjhyyToCyGED5GgL4QQPkSCvhBC+BCPCfo6nY5rrrmGjh071rjczp07GTlyJGFhYfTo0YMvv/yyeQoohBAtgL+7CwCwe/durr32WlJSUmpcrqysjIkTJ/LAAw+wbt06tm7dytVXX02XLl3o379/M5VWCNFcFEWhoqKCyspKdxfF7QICAvDz82v0ejSKB3RYf/311+nQoQMRERHccsstHD161Olyn332GY899hj79+83T3vggQfQ6/W8+eabddqWTqcjKiqKgoICIiMjXVF8IUQTKC8v58yZM5SUlLi7KB5Bo9HQrl07wsPDG7Uej6jpz549G4CNGzfWuNyOHTsYMmSIzbShQ4fywgsvVPsevV6PXq83v9bpdA0q4xObYf2JBr3VJfy18MggmNjRfWUQorkYjUaOHDmCn58fiYmJBAYGotFo3F0st1EUhfPnz3Py5Em6devWqBq/RwT9usrJySE2NtZmWmxsLFlZWdW+Z9GiRTz11FON3vaBAvj9bKNX0yjBfhL0hW8oLy/HaDSSnJxMaGiou4vjEeLj4zl69CgGg8F3gr6zI72iKPj7V78bqampzJkzx/xap9ORnJxc723PGQDXdav321xi02l4aQdUuj0RJ0Tz0mo9pq+J27nqTMergn58fDxHjhyxmZadnU2bNm2qfU9QUBBBQUGN3vbgNjC40WtpmNIKN21YCNHieNVhdMiQIWzdutVm2pYtW+jVq5ebSiSEEN7F44P+pEmTWL58OQATJkygsrKSF154gZKSEn766SeWL1/OzJkz3VxKIYTwDh4f9I8dO0ZOTg4A/v7+rF69mtWrVxMXF8fNN9/MK6+8wsiRI91cSiGEsFAUhejoaJYuXeowb9asWQ69EJuTR+X0L774Yoc++rt27bJ53bNnT3766admLJUQQtTPoUOHKCgoYPBgx5bAtLQ0Bg0a5IZSqTy+pi8spPOOEN4hLS0Nf39/BgwYYDPdYDCwa9cutwZ9j6rpCyFEdRQFStzQky3UH+rbWzItLY3evXsTEhJiM3337t2UlZVJ0Bc1893rEIWwKKmA8H82/3aL7oKwgPq9Jy0trdrUTlBQEH379jVPW7FiBUuXLqWyshKj0ciDDz7IzTff3NhiV0vSO0II4WLbt2+vNuj369ePgAD1KLJs2TLeffddvvvuO3bu3MmGDRua/P7dUtMXQniFUH+11u2O7dbHiRMnyM/Pp0+fPg7zvv/+eyZMmABAXl4e8+fPJz09nbi4OEAdVuaWW25pbJFrJEFfCOEVNJr6p1ncwWAwAFBUVGQzff369Rw4cIAVK1YA8OWXXzJ27FgSExObtXwS9L2I+wfBFkLUplOnTvTs2ZPU1FSCgoKIi4tjy5YtPPbYY9xyyy2MGDECgIyMDIfePc1Bgr4QQriQRqNhzZo1PPTQQ1x33XUYDAa6du3Ks88+y2233WZeLiwsDKPR2Ozlk4ZcL+DDw4gL4ZU6d+7MqlWryM7OpqCggLS0NGbOnGkzJPKECRP46KOPzCMO6HQ6PvjggyYvmwR9IYRwgxEjRjBnzhzGjh1Lv379uOiii8ztAU1J0jtCCOEmM2bMYMaMGc26TanpCyGED5GgL4QQPkSCvheRHptCiMaSoC+EED5Egr4XkB6bQghXkaAvhBA+RIK+EEL4EAn6QgjhQyToCyGED5Gg70VklE0hRGNJ0BdCCBdTFIXo6GiWLl3qMG/WrFkMGTLEDaVSSdD3AjLKphDe5dChQxQUFFR7y0R33hhdgr4QQrhYWloa/v7+DjdJMRgM7Nq1S4K+EEK0JGlpafTu3ZuQkBCb6bt376asrMytQV+GVhZCeAdFAaWk+berCa13jjUtLa3a1E5QUBB9+/YFYMmSJeTm5rJw4UIAKioqiI2NJScnB3//pgnPEvSFEN5BKYHj4c2/3fZFoAmr11u2b9/Otdde6zA9LS2Nfv36ERCg3uE9IyODiRMnmudnZmbSsWPHJgv44EHpHb1ez5133klcXByxsbHcfffd1d5F5t///jc9evQgMDCQpKQkHn74YSoqKpq5xM1PemwK4flOnDhBfn4+ffr0cZj3/fffm2+MDmrQT0lJMb/euXMn/fr1a9LyeUxNPzU1lczMTNLT09FqtUybNo358+fz3HPP2Sz366+/Mnv2bL744gsuueQS9u/fz+TJk0lMTOT+++93T+GFEE1PE6rWut2x3XowVVaLimzLun79eg4cOMCKFSsAtVvn3r17GTdunHmZvLw8UlNTG1feWnhE0DcajbzzzjusXbuWpKQkAF566SVGjRrFs88+a3Mz4b1799K3b1/zKVH//v3Nwb+lkh6bQqDm1euZZnGHTp060bNnT1JTUwkKCiIuLo4tW7bw2GOPccstt5hr+keOHKF79+5s27bN/N4JEyY0eU3fI9I7Bw8epLi42Kbho3///hgMBvbs2WOz7BVXXMHx48f59NNPAUhPT2fdunVMmzbN6br1ej06nc7mIYQQTUWj0bBmzRq6dOnCddddx+jRo1m2bBnPPvss77zzjnm5jIwMevXqZfPePXv2mBt5m4pH1PRzcnIIDw8nMDDQPE2j0RATE0NWVpbNkS8pKYnvv/+eSZMm8fjjj5Ofn89XX31V7RVuixYt4qmnnmryfRBCCJPOnTuzatWqGpfJyMigd+/e5tfFxcUUFBTQoUOHJi2bR9T0NdV0h1IUxaEV22g0smTJErp168bChQu54IILmD17NufOnXO6jtTUVAoKCsyPEydOuLz8QghRX/Y1/b1799ocBJqKR9T04+PjKSoqory83FzbNxqN5OXl0aZNG5tl33jjDXbt2sWWLVvw9/fn2muv5b777uPmm2/m22+/dVh3UFAQQUFBzbIfTU0GXBOi5fjoo49sXg8aNIjffvutybfrETX9zp07ExMTQ1pamnlaeno6oDaKWNu9ezeDBg2yOQO49NJL2b17d/MUVgghvJhHBH2NRsOsWbOYN28ep06d4uzZs8ydO5dp06YRHBzMpEmTWL58OQAjRozgiy++YOPGjZSVlbFv3z4WL17MpZde6ua9aDrSe0cI4Soekd4BWLBgAfn5+aSkpFBeXs6UKVNYsmQJAMeOHSMnJweA6dOnc+7cOWbOnMmxY8do1aoVV199NS+88II7iy+EEF5Boyi+lSnW6XRERUVRUFBAZGSku4tTJ6sOwjXfwkUJsMnxym4hWpyysjKOHDlCp06dCA4OdndxPIKrPhOPSO8IIYRoHhL0hRAey8cSETVy1WchQd+LyNdf+ArTKJQlJW4YStlDlZeXA9gMS9MQHtOQK4QQJn5+fkRHR5svugwNDa32Ik5fYDQaOX/+PKGhoY0edlmCvhfw4e+68GFt27YFqPZqe1+j1Wpp3759ow9+EvSFEB5Jo9GQkJBA69atq723hi8JDAxEq218Rl6CvhDCo/n5+TU6jy0spCFXCCF8iAR9IYTwIRL0vYh02RRCNJYEfSGE8CES9L2A9NgUQriKBH0hhPAhEvSFEMKHSNAXQggfIkFfCCF8iAR9LyKjzAohGkuCvhBC+BAJ+l5ARtkUQriKBH0hhPAhEvSFEMKHSNAXQggfIkFfCCF8iAR9LyI9NoUQjSVBXwghfIgEfS8gPTaFEK4iQV8IIXyIxwR9vV7PnXfeSVxcHLGxsdx9990YDIZql3/77bdJSUkhODiYiIgIsrOzm7G0QgjhnTwm6KemppKZmUl6ejoZGRns27eP+fPnO1128eLFfPDBByxbtozc3FyysrKIiYlp5hILIYT30SiK+4fxMhqNREdHs3btWkaMGAFAeno6o0aNIi8vDz8/P/OyWVlZXHjhhezevZuIiIh6b0un0xEVFUVBQQGRkZEu24em9NVhmLwGhraBzVPdXRohhDfziJr+wYMHKS4uZvDgweZp/fv3x2AwsGfPHptl161bx0UXXcTChQtp27YtrVq14v77768xFSSEEELV4KBvNBpdVoicnBzCw8MJDAw0T9NoNMTExJCVlWWzbEZGBt999x1t2rTh0KFDbNy4ka+++oqXX37Z6br1ej06nc7m4W1kwDUhhKs0OOjHxMQwcOBApk+fzvPPP8+3337LiRMnGrQuTTVRTVEU/P39babl5eVx8cUXM2fOHMLCwkhJSeH+++9n1apVTtexaNEioqKizI/k5OQGlVEIIVoC/9oXcS4nJ4fMzEx27NjBvffey/Dhw9mzZw86nY7evXvzyy+/1Hld8fHxFBUVUV5ebq7tG41G8vLyaNOmjc2yISEhxMXF2UxLTEwkLy/P6bpTU1OZM2eO+bVOp5PAL4TwWQ2u6fv5+dG3b1+mTZtGdHQ033zzDUePHuXkyZO89tpr9VpX586diYmJIS0tzTwtPT0dgE6dOtkse8EFF7Bp0yabaQcOHKBjx45O1x0UFERkZKTNQwghfJVLGnKt0zOhoaFccMEF9X7/rFmzmDdvHqdOneLs2bPMnTuXadOmERwczKRJk1i+fDkA11xzDYWFhTzyyCMUFxfz+++/8+qrr3Lbbbe5YleEEKJFa3B65/HHH2fAgAGkpKS4pCALFiwgPz+flJQUysvLmTJlCkuWLAHg2LFj5OTkABAeHs66deuYNWsWsbGxxMfHM2/ePK677jqXlMOTub1vrRDC6zW4n/7LL79MRkYGGRkZ7N27lx49etCrVy969+5Nr169uOqqq1xdVpfwxn76Xx+Bq1bDkDawRfrpCyEaocE1/QceeMDm9ZEjR8wHgU8//dRjg743kh6bQghXqXPQHzZsGIMGDTI/+vbta3OlbKdOnejUqROTJk1qkoIKIYRovDoH/QsuuIC0tDSWL1+OXq8nKCiIfv36MWLECK6//nqGDh3alOUUQgjhAnXuvfPmm2+yefNmdDod27dv5/XXX2fw4MF88803jBgxghkzZuABw/gIIYSoQb1z+v7+/qSkpJCSkmLuJrl+/XpuvPFGRowYIV0nhRDCg7mkn/64ceNYuHAhb731litWJ6ohJ1JCiMZy2Sibw4YN4+DBg65anRBCiCZQ56D/xhtv8Mcff6DX653Oz87OJiAgwGUFExbSZVMI4Sp1zunPnz8fnU6Hv78/vXv3ZvDgwQwePJg+ffpQVFREamoqo0ePbsqyCiGEaKQ6B/28vDwOHTpEWlqa+fHFF1+Qn58PQM+ePXnxxRebqpxCCCFcoF69d7p06UKXLl2YOtUyFsDJkycxGAwOo2EKIYTwPA0ehsGkXbt2riiHEEKIZuAR98gVdSM9NoUQjSVBXwghfIgEfS8gN0YXQriKS4O+VqvlkksusbntoRBCCM/h0qD/7rvvMnr0aO6++25XrlYIIYSLNPjOWd7KG++c9c1RuPJrGNwatrb8u0IKIZpQg2v677//PitXrnRlWUQtfOroLIRoEg3up//SSy+xYcMGh+kffvghFRUV3HzzzY0qmBBCCNdrcE1fq9XSqlUrh+lXXXUVL7/8cqMKJTxPvl6GdhaiJWhU0M/Ly3OYHhERIXfQcjF399hcfQRavQ2pv9nNMOqgdCMole4olhCiARoc9GfPns1f//pXsrKybKbn5uY2ulDCs9z7s/r3ue1WE42FcKofZI2FnFluKZcQov4anNO/5ZZb0Ov19OvXj0suuYQBAwZgNBr56KOPmDNnjivLKNystMLJxOLPofK4+rzo39DqafBr06zlEkLUX6P66d95553s27eP8ePHc/78ecrKyvjXv/4l98ltYfKd3TendI3Vi0oo+ba5iiOEaIQ61/SHDRvGoEGDzI++ffvi5+dHq1atuPXWW5uyjKKKu5pKypyl7MurrroOGgb6zaDfBBG3NGexhBANUOegf8EFF5CWlsby5cvR6/UEBQXRr18/RowYwfXXX8/QoUObspzCQxgV0BpzoOKoOiH8DjXol2+v8X1CCM9Q5/TOm2++yebNm9HpdGzfvp3XX3+dwYMH88033zBixAhmzJghvXaaiCcNuKavBAx71Rd+HSDkEvV5eQYYy9xWrmajOGvgcKLkWzjVC8p+adryCFFP9c7p+/v7k5KSwm233cYbb7zBvn37WLt2LV999RXLly9vcEH0ej133nkncXFxxMbGcvfdd2MwGGp9z6BBgxg8eHCDtyvq55MDWGr5AZ3Brz1oooAKqDjoxpI1g8J34Xg0FK+qfdm8VPXgeHZUkxerRpW5oHsDij5wPl+pAMXYvGVypvhLODMGyne7uyQtnksGXBs3bhwLFy7krbfeavA6UlNTyczMJD09nYyMDPbt28f8+fNrfM99991HQkJCg7cp6u/3M0DFEfWFf0f1NCSgq/q65Ct3FctC0UPhMqjMqn1ZAKUcKo7VbdnCf4JSDOevqX1ZQ7rlubG4busvz4DK/LotWxfFX8KJWMidDdnToOKM7fyK4+pB7JgfnLnYtY1GilLzwURRQLGq1BX8A/Q/w+m+jd+2fiucSIKsSeq1JM4UvAhHNXD+JtvrTIreh7PjW/TBx2WjbA4bNoyDBxtW0zMajbzzzjssXryYpKQkEhISeOmll3jrrbeorHR+4c+HH37IuXPnuOWWWxpRalFfF7fDUtP376j+1VYNXJf/mPsv2y16H3LughM13MbTcBBOdFB/9MeC4GRHKP2h9nX7tbVax9Gqv4fVg4xSAZV5cHacul5rxyOgMqfmdRsOwel+cLKd6z5D+3aWUrseVvpt6kEMQP8TGDJcs93KLDjZAc4MUq/ncCZrHJzspB5wFb2lYwDYHvhK18H5G6HyXN23X/ACVJ6G0tVw+gLny+TNVf8Wf6huw/zel6BsHZwZXvfteZk6B/033niDP/74A73eWf89yM7OJiAgoEGFOHjwIMXFxTZpmv79+2MwGNizZ4/D8nv27OH555+vUzpJr9ej0+lsHqJ+YoItzxUFJ0E/zrJApV1tsqlVZkPxf9VaZck3kDOzakZF9QGndL3lGgOT3Puq34bhAJy9DEq/tkw71Qny5sOpLupBJn8BnEyCsu+drECBvIdq3o9zk6oWLQb97zUvW2d2Bw/roF/wChS/bzu/7CfHVRiLoOhjMJbWfbOlP0LlCSjfCYVvOl+m7AeoPAW5c9QDpzX9r+rfyjzIGg/FH6kHU/N7fwFjgfP1Go5AyWeW1xWHHA+i9mc8Zeut3l91hqZU891pAeoc9OfPn8/w4cOJjIxk4MCBzJw5k2XLlvHLL7+wdu1aHnzwQUaPHt2gQuTk5BAeHk5gYKB5mkajISYmxuGK3+LiYm666SaWL19OVFRUretetGgRUVFR5kdycnKDyugJPKGZXF8JVJxQX/i1V/8G9LQsUHHY4T0oinrKnfsQlDsexDEchRPt1RqyripIKJVgLKm9QHlz4fxf4exFcO5K23llP6kBq/K87fTiD52UoZrTeaUC8uapQcpewT+sni8GpYbAWLQC8p92PmSFsQAMmVbldrItpQJy50LJ147z8p+B/H84Trc/eJR8rh4gK85C3gNQ8l+75TdXbasccudB2W9wsj1k3wBnx9qWt0blVtv8xkm5tlnNXw3YfSb6repf6wOxYVfVvC1qO8nJjs437ez/qP9NPRiYvk/FH9sVtyrQV5x2vs4Wps5BPy8vj/379/P+++9z+eWXc+TIEVJTUxk9ejQTJ05Er9fz4osvNqgQmmq6pyiKgr+/ba/Su+66i5kzZ3LBBdWcttlJTU2loKDA/Dhx4kSDyujLrCtK+XosKQFthPo3oLtlgYpDjm8+poUzQ0D3Epzu47iB0v+pNUOA3LvV95wZCqe6Q8UpyF8Ehv3OC1e0Qv3rrHZ8bpIasKxP8cs2WWqSznZUv1VNJ1ScAt1SOBYAJV86X76+8p8A3auO089ebPu67GfHZfS/gu5FOHeVGrTN03dC/uOQPx8K/223nh8d13P+r2CsJtVUXpXeKfkv6J6HsyPBWDW+VvkW9W/Rx2o7wNlx1df+rWvS+p/Vq7et5T5ovVFLbzDzpKqDgv2ZiLEAyquCvzEfyv9Uz7b0OyzL6F5zLM/Zi+BUZ0t7gSbIdr5p+yX/c74/LUyjb6Jy8uRJDAYDnTp1avA6Dh06RPfu3SktLTXX9o1GI2FhYWzfvp1evXoBcPz4cTp06GBTwzcYDOj1esLDw1m9ejUXXXRRjdvyxpuofHcMrvgKBsbD9uubf/sxb0NeVVavZyvIHB0PxmxI/BMC+6o1qONh6gJRj0Orp9TnRSvVIFv0ju0KOxhAY3Uwz7rKNnUScQ8ULnUsSPsiKN8BQSPVBuTKbDgRX7edaHdSrYmf6lbDMifgzAj1AOTXASrr2MBbH0GjIMEuqNu3AQB00IOm6sxXqVAPPiba1tDmWwi6AE4PswRkgHZnwL8tlP2qBjuAsOuh+D+WZSLuhUInwZFA6FAM56bYXXFtWvdxteZvEjwO2q6zXcZwVE19OeyPUf2fGYvUNo6a+HeGpP1wzO4youh/qO1GznSsCmPWn6UmHJQiu3KUqwfJgsUQPBbKqoaHTz6v9nDKe6DqvaHqZ9ECNXjsHZN27WpoMKujzp07ExMTQ1paGsOHqw0o6enqKZf1wSQxMZEjR47YvPfzzz9n5cqVfPXVV7Rt2xbRtBLDUBvewFJj0oZCq8WQ9wgUfwKaACj9DvTV9FEv36UGLKgaqdMuZeEs4INam9W9YnkdPtP5cs6cbKcGqZoUfWA542hMwG/9Nej/gIAuaiosf4Flnn6Tkzf4AxXQ6jk1lQRqLrttVUCqsGt/MJ5TG0k7KrYB37R+/7/ZpjAiH7IN+vYBXxsLSpl6Bmc46DzgA5SutX1dth6K3oNwq3tnVFRzRlZ5GvyTwFiHARkrjjgGfKg+4IP6nfLvbHntlwCR91s+T5NjlhQyZRvAv5O6PcMeuwNEo0Ojx3LpPXIbSqPRMGvWLObNm8epU6c4e/Ysc+fOZdq0aQQHBzNp0iSWL1+Ov78/HTt2tHnExcURGBhIx44dCQ4Orn1jot6sTwWdBn2w/OAq9qlBrrqAD5A1wfK8YEndC2Id8AGK/lX394Jtgx1A5MPQPh9CqhpR81NrX0fYDRBXTZ93k9C/qAPQhd8M0TV3O1a7NVZd8BVuNWZV2UarZaq56C3nfsdpefPVhmc/q67M/skQ/WT1ZQiZAP5V3W6tDw727NsAALJvsX1tLquf7f6Y8ubWB6MYJ2cbmggcWq8CB1VfJpPTKbZnIa2eh4Detb/PtN+GQ1DyhdUMT2hBaxoeEfQBFixYwMCBA0lJSaF79+4kJiayZIkaEI4dO0ZOTi1d3kSzKK8ow9xQpwm3zPDvUPeVGM9ZuuBZB5mAfo0uHzGvQsKO2pcDCEwBbZSaoqqL6Kch/kMI+zuEVXNnOOueTNWx7jtuajwFx1yz6VoDUyDVxtrOL3TSPlCxX20LKXhefR04BPxaQ/QTtgcCm/LkQkDVGXXBU9WXu9RJo6w9U4UgaKT6eZmYgr5i1fvPugOAeZqT9Fvk/bVvFyztD6B+N52t31rotZZrTCoOQnlmzcu3EB4T9P39/Xn11VfJzs5Gp9OxcuVKwsPVoLJr1y4eesh5l7dbbrmFbdu2OZ0nXC9EU9XDQRMMWqs7p/nVs1fUiTZqP23rGlXIxEaXj8h7IWhA3ZYN6KH+resBy3RQ0mghfoUa1CIfhjZWtw1NOlD7egxWjd0Gq95MmhAIu9HyOmuy+tfU7bG6BliAOLv7VStVB5byPyzT/LvYLhM+Q227iF6opjmqEzql+nlgO/xG+Z+W7fsnqW08YEn75D+h/g27EfztAnzc+46pLGflhtq/K6FXWroUVyfkMsu6DYcA6+7oUtMXHsBd1z1ZbzeIbPWJtrXtoEC1jqWvhTi7rnIVRy3BwC8JWj1Lg+8TFvc+JPxR+3LWTEG0tuCQtB/iPoLQSbbToxdAzHMQcrHayNxRAb9ox/e3/tr2rKii6sCgKJaUVUA/tXG71WLLcqZ8vfUZQJtqLiILcNIrCmyDuX0vmcjZkHwUggY6D/qaENC2gSgnufRYq55C1gcuUwrNdCYX0KtqmYO2XyS/RDXtZC3sRrWDgD1TbdwkaIz6mdZEE6B+nqFT1a7FrZ1cLR5+i1XQT3ec30JJ0Bf1YjR109OG2s7Q1PJVCpkIYX+rfn7ELHUdiU5+fP52P/q2do2hIRMg/CYIutAyLb7qAp3IeRDQ33b5oJHqWUrgkKr1d7SdH73IcfvhfweNX/Xl14ZVPy/0L9C+AMKmq68NVVeuG3ZZ+pWbLmrzb2dbHsUIVA1nEPWEOsBdzOuO2/BLdL5t64Btf7GadX97+6AfNk09kLU76pgbj1oAEbepnyOovWHM5a0K7CHj1b/W6RPTfgBEPuD4eWo0ls/IJO4Dx5RZ+A3qd6XNeoi4GwfWbQWtP4F2RyBwgN06blUPpqby2R8QWzAJ+l7Ak0bZNF+ApAlxnBdv1Z894j5I3AkRswENRM1Vf+QJW2teb2A/aHdK7VrX9icIvFCtxVsLGgltqq589WvvvGE17Fq15h2zGILshv1u+7PahdNUK/drbzs/+GLb1674B2i0lny1qaZfadWTxc+q62mM1VWshkyrhvOqjgrO8t6aIEuDtLWQyyzPw6bazrNuILUP+q0Wq2XWBjse4COr7oynVLXtlK6xXFBlutAq9Oqq9VYF1cqztoHV9P0JvU79a6q5x9i1U4TfqH7+2njH94ZcBrGvQ3u7i/jC7dpbNFrwawdBFwF+6ncr7t2q8nXGOUnvCB9m/fXXUEPQt86N+yeqDaUxr0FyNgRXXa1dXU+MiDtt36sJUN+T+AcED1NrdSETIOmwGgRCLlWDevIx8IupeQeiHrZ9rdHaBjKt1b4E9LFNJ7T5ruZ114epBl+0Qr1S1br7onVO3roBsvKkZfAvU799f6uL4UBNPfm1gtg3nGzT6n8S85LtPOuzE/tUS01MB8sAq1z7maqzJlO3R1M6yy+6qkcOtr1/TJ953Ar1eo+QKy3LRz2qnrm0tzozSUy3tKGE2V2sog2xnNmBZSwoaxqNerDvYFC/W+ZlQx2XbeEk6It60Zhr+k66x1oHGNPIkhqNbVCurtasqeXHF3IZtPnG0sukPgK6WmrBibucLxM5V62Vtv3JtpeMppYLierDL8ny/NyVlquXQyZBkNXw4Nb7WHHG0hhr2Kf+tQnQ/mrqyTQ9xmqk22S7kUatzyYi59rOsw+UWrshTky578ChjtNMlEqrnkZWB1JTeU3Dd2hbWV3jEaz2nrL+XrT6BySfAq1177AESxuKddA2CbsW2qytuSFdo6n9rE3jHRdsNoYEfVEr6/a3SL+qBjr77oNg25vHvnZtLWkvRNfQNbAptP6fWnMMrKZbaMzz0O4A+MWqgSH+U4iar94O0lX87S5k1FeNgmnfVRMsF57prQZBM50paPyg1Ytqbbqd3bAiIZdbnvu1dlxvm/UQcRdEP+44z3T21mqJYxtF3HK1ATVumWWaqZHWJHe2YyoK1NQKWMZlCqzbECr1FjLesdG33kzjALXc9E7LvexMNIlwv6q+0Na1RhONRs2vKvqaGzYDeqhBp+Qry5C6WhfWqJ3RaGx70NQm7G81Nzw3hHVNH8BQ1b3RWdA3nTWZxhYCtbHaJOpB9WEvoDMkbLM9AFsLucw2z28tYbuadw+b4jgveBQkbLSdFjYVsq3KVPhPq5nWF+6ZavpVZzamNJWnaJ+vjicElnGlWjCp6XsRT6h7BGmd1OSsaUOcd1t0JuQvlufOTtlbGvv8sXVXR3vOupHWlgIzCRqkBv/6CuzpPOBXRxNg6YfvMK+Gmn55HS+eay72qSzAM35tTUOCvqiV9dc/2K8qZ+usdlpf0Y9CVCq09fH7yDob6tnZBWN+TlJq7lbdMBPaaMtz+0biyrN4nMiqMXpquxCtBZCg7wU8pcdmeIB1Td8FQV8TqF6QFTyy8etqafzb176MJ9AEqAO62bM+27Nvy/Cze+0JWj0NbTeqg961cBL0RZ0F+kGUf9UFPfXJj4uaWV/damI/Tk5zN3zXh/VVxM7YXzhWebLpytJQmkAIHmNVmZH0jvBhpq9/oBY6hFYNOVyfAdaEReCFTiY6CTD2bRzOhkLwFBo/CJlseR083na+/QEs6tGmL1ODecp5ddORoC/qLNAPOoYcVV9I0G+Y1qtshxyGunUzrGkICE9gnY4KtBsHSGt38Zz9QGuiWUnQ9yLuHnCtb0w5SSFVo2xK0G8Y/3YQZ5fOCRzqfFn7C6g8mXVjrfUN2MFxXKbgUU1fnsZy14+tGUg/fVFnA2OthtD1gSsXm1Trb+DcRAi5Qr0q1ZnoJwGjOu67p7Ou6Vvf5N1e6DW2wzd4nJaf3pGg7wU85WsYpDVYXvhCv/qmFDrBcl/X6mhDIebF5ilPY1kPWudsmOfYt6HoXefjA3mkllvTl/SOqJXp6x/kV2E1Vb46wop1eif2n47zI2ZCwu91uO+Cu3lKFavpyC9X1Jkp6BuMAR423rNwO+seOn5t3VcOUStJ74g6C9So6Z1K/JHkjrCh8VPvjGY854JBzzxBy03vSNAXtTJ1ZAjQqjX9SkW+NsKJ8OtrX8bjtfwzWEnveBF31z2CtOqdkioUqeeLls7dv7amI0Ff1Fl84HEAsvTV3I9VCOHxJOh7AXe3mZrqPG2C1btm5ZY7G4pWiJZA0jtCmAVU9dM3SE5ftHiS3hE+zNyQqzF12ZSgLxy9uhMe+dXbRzBo+TV9+fWKOvPTVkClBH3hyFAJ929Sn9/cC3rF1Ly8cB+p6Ys686+q6ZcbA7y8Nidc7bTVrWVPFrmvHK7Tcr/gHhP09Xo9d955J3FxccTGxnL33XdjMBgclisqKiI1NZXOnTsTHBxM//79Wb16tRtK3Pzc9TU0bdcU9CsUfypb7m+i2SiKt6dCLE5YBfqbv3ecv3gbtF8Ox3TNV6aGafnpHY8J+qmpqWRmZpKenk5GRgb79u1j/nzH+2+uXbuWM2fOsH79evLy8njwwQe59tprOXbsmBtK7Vv8q67IrVD8qTC6uTBe7v29oH0denxQfeDP18ON38FaL/hqHy+0PD9T7Dg/9Xf1wHDtt47zPFMLORo74RFB32g08s4777B48WKSkpJISEjgpZde4q233qKystJm2WuvvZYVK1bQpUsXQkJCuPnmm+nYsSObN292U+mbnqfUPcKN2wDIKY8lT+/mwni56evVvwfyoazS+TKP/AYf7YcJXzVbsRrMOugPrWFMtW3nYFd205dHVM8jgv7BgwcpLi5m8ODB5mn9+/fHYDCwZ8+eGt9rNBrJzc0lISHB6Xy9Xo9Op7N5iPox1XkCjIcB+Dl3NMcKq19eVG9/Hkz4n+20DdXcMnZZRtOXx1Ws0zsj7X6KlXZnhemeHPTdfVFMM/CIoJ+Tk0N4eDiBgYHmaRqNhpiYGLKysmp877vvvkvbtm0ZOXKk0/mLFi0iKirK/EhOTna6nKidBjW9U1wRxlE5djbIxK9h7XHbabllzpe1Vl7N2YCnsK7p/3rGdl623f6lnWv68jSepHealKaao6uiKPj7V989cNOmTTz++OP85z//wc/P+T1EU1NTKSgoMD9OnDjhkjL7EkvOWR17x6AE2NTsRN0dKnCcluskVWYf5E3dIT1RaQWsPmp5vcWunnbWLsf/anqTF6kRpKbfLOLj4ykqKqK8vNw8zWg0kpeXR5s2zhOE27Zt47rrruOzzz6jd+/e1a47KCiIyMhIm4doGI1SdUWuMYBix45VooHu+9lx2im7g+pbfzZPWRpi5o81zz9tF/TbhjZdWRqqqBw+3g+F5bUv6+08Iuh37tyZmJgY0tLSzNPS09XqQKdOnRyW37ZtG1OmTOGjjz6qNq3TErm7e19A5S4AypVA9C5INxQb4Jb1sPpI49fV0hz3kjOp0gr4cJ/j9JxSy3P7s8KzJU1bpoa4bxPc8B08/Ku7S9L0PCLoazQaZs2axbx58zh16hRnz55l7ty5TJs2jeDgYCZNmsTy5csBNeD/9a9/5eOPP+biiy92b8F9hAJosUT5cqNrgv6CzfDeXpjkG5dZVGtaD8dpzvqzny91nOZuc39xPl1nVWO2v1iriweO1/duVX+Rzw9JeqfZLFiwgIEDB5KSkkL37t1JTExkyZIlABw7doycnBwAHn74YU6ePMno0aPRaDTmR0s+AHhCh4KoAEsyOi1/ULXdDM8UwxEneWtnvrdqXnHFQcTT2acO+seqf51d6HbUSe+ouqbUvj0KW2vu/+DUlrPwxq66n1GWVsAb1aSdrP+fppp+t+iqvx4W9K0boVsFWc1w96l1E/GYoO/v78+rr75KdnY2Op2OlStXEh4eDsCuXbt46KGHAPjxxx9RFMXhsXHjRjeWvuWL9FerngYlBIMSSJaTU3RFgcR3ofNK29N7e3+cheu+hT9zLNNKmriNoLySGnscKYpt4+kbu+D2H8Dowt+9fZ6+X1xV2Zxc6GbqEjtngGXaP60C7AObQLNU7QJqbXeO2kNoyKfOy/DZAZi82nmPoWGfweyfnLcxrD4C3d+HX05bpn1kl9ZZPAISwtTn1pUCU02/S1VzmrP9dacOKyzPEz2wvcHVPCboC8+lKBDmp7bGVaIeiJ1dnGWdfnh+e/XrG/oZfHrQbhuNLWQtOr8Hnd6rvk/8rd9D+D/hdJG6v7N/Uk/5N512vnxD2Kc5BrdW/9qf5SiKJd0wIN4yXV8VLCuM8MpO9XmPD2zf+5VV+4iznkJT16rL3G8X2K0rtUt3QYHd/3f6evVCsrs2WKYdyLddZt4gCK7qRGcd9E9UHcA6V9Xwf6zmf1BdeepqRWbDznCsFRo84LS6iUnQF3US6qdW7Y2oVaGyCsdlrE+Tk9RjA/pK2JNr+RFXV3Oura/65weh30fquupr+zk4VdWD5JIvnS/z3l4wGGHAf7A5i3FlLyVTGcID4I+p0DFCff31EfjBKtW1P9/yvG0oXN5efZ5c9Znan7Es2VH1vjx49HfL9K4rbZc7YfX/ed+ull5gl3oqsfv/mg7yu60+/wNODiqmoG86c1MUOFm13+0jLMuVVq0/twy+O2b7vbjte3WICuuunvvz4Pq1MG2d5b3WXtmpHrirO8MBdSRQZ++1dszmwCzpHeHDwvzVX6BRowZ9Zz8e62C1LUvNLU/6Gvp8qAY2qL6m/fZuy/Md59X89+oj0O5dWH8c/vYtZOSo66o0qgcBzVL1cbqani6mQPKaXb/wYoPt+DDWgf18KRy0CmZXfu183Q1xpCpYX98NLmwD0Vb542nrLc8P5luet4+AdlYHUHCsYT/4C2SXwg3rHLeZaRWk7/nJdl6+VW3+uF0bQk01bdMZnXW6au9N6t/wqtsnF1V9prllls93alfL8qZKw5VfwxVfWc5szhbD8kz1ecK7luV7fACfHIAP9sEHe23Lc6pITXeZOEstGhVIXgGhb6lnXKbP0r6dRVGkpi88iDtH2TTV9JUagv6NVkHn/X1qbnl9VQ327d1qzvyy/zrfRusQ9e+Ws3DBfyBymdqr51QxXP+d7bLrT6gHAZPxTsamWZYBfq+rbQe/n7Wd12GF2vZwrqpGbz+kxH/22752RV4/X285mJgaNNtY5Y8DrX6J1oOSdY+GoKrasynl4qyGbTA6v9J14ynL8//ZdY21HgPniN3Zw5Q1at/1cyXqX2sLqoa5MgX223tDj1bqc/+q/fh3VRA37XO7cNuavunMYXPV/8bU1/8Oq/QRqDdmsT8Ambbxn/1w6ZfQbrnt/Det2j4qjGpgP6aznMElL1e7Z4LzFJiF1PSFDzPl9NGoLXXFdkHffnwVe2uOwsq91c+f+6t6+j3sM8d59qkf+wHIMnLg+TTb0ShNuedPD9qegQDkVK3PNAaMfbrEvkfK9nPw0na1fM4oChwuqP4zWJEJrd629GfvWpXb7hUD46pGBTFUvXd/nm0+XKPBPKLpc9vh0wPOG1pPOOntAzDPqt+5KT1kEhloWbd90N96DiKWQZt/w067sXKWZcAzf1hSPfemWOaZ1ret6gBkCvpdo0BrVYl+LR2HkVqNiuWM0OT+TY79+h/folYg/v6d8/aBx7dYnl/4iXqA32p3QFx1SD2YmYL+BfH4DAn6XsATTjhNNX1/P7V6eq7EtgZ2pg4X3NhfuTkiAQZa/dhmbWx4+eb9Vv/RKGOD1b+1jSN04afw0K9qesHarI1qjnnVIeiyEvzfcD6s8K1248t3jbY8n9pN/Xu6WD2oWKcpJnZQ/5pSJgDXrXVexuoGMSu0Sl0lR9jOe+x39Yzql9OOQd/aAicD2FoH1p6tLM//VrU/plr971Xj8HSNsu16nF3m5GC7Czo5uWDevjZ+sgh6fuC4nLXSCvXAsDNbPSNx9rkty7AclEx3+lI84tfWtCToizoxBf0gfzXolxstNWaovqZZHd2d8Ou1tj1XvjpS/fJ1NeMHWHe89uVAbTsA533iq1teUdTgPHaVOjTCB/ts0zGJ71b/fhPri5MubG15XlYJ31idrXw0Xv07raf6N8oyHqED+7RI76ogZgrIRsWxZ8s3x9Tg+OSWmoO+dYrImUCrYa9MjdOBWvWsxXTWZEr/PDNM/fvhPse2iXt/Vs8+7B10koKpqbwA/zusnn3VZOMpywGlSySEOgzzJekd4cNM6R2tNsycY7ZuAK3PUMuDWkNE1Y/b+mrUcy644vTfe2D8/2pfDtTAcTDfkoqozZKdau+QV9NrD4Q1CbOquZv66oNj182oqoZeU48Y+x42z41wXPekTnD2driuqsa9N09t6Lz3J0sKyV77CEsQXXJR9eW+vlv180yCqwLnz6dtexKlVO2ndWDdZXWdhon9gQBs11MT08VuoB5A9+ZVvyyog8SZg36U2n7iCyToixqZUji3tq9qLas8bQ761kHK9AO7pB18OdE2z2tvxWWW5w8MrHtZ/jHM9vVD9XhvWADc0N1ufdug2/uWHkVvXVz7eradU9sfavLCdvWOVy9st+3XDo6pOq0G/KomPrPVMv3WXpbnwX449fAgx2m39VIbiK3bQU4WVX/lLKi9ZUw9hiY5DnVl9hcn876ZZPvauqxfHLI8NwX9v1v9Dx75zXF9JRVqQ611+4OzlJm947fAlqmW1/f9XLfuvaaDTJcouLGHpHeEh3HnVeGmK3KpPOUQ9HXl8NQf6vMxSTClC7w6Glb/BR6/0HFdptQDqD1TbrQbe8ZZ8I0KVIPcoemg3KM+Fgype/lP3Qov1lCLBZjS2ZJuGdS65mVr8vCv6h2vHv7V8UYoY9s5Lm8ahsHUtTRAC/++1DK/Q6TtwWJYWzgwTX0+oYPtukYnqX9vsTpoWLcTAMy7wLEMZZUQ4q/m1P/e3XE+wKXtbNMvs/vDhI62y/SNxanWVT2VnKWo7NMqnSPh2C2Oy715sfN1g9peEWy1Hl05POakLaLiblhYVXkYk2QZIqJPrKVXkIWkd4QP25pfFb0j7nYI+p9aNXBa56uv7ARPDoX4EMu08ADbXhwAw9vavr6zL1zZUe1RkX8HvHcZ7LlR/VF2tlq/s/yvMxclqKmShDDIvLH65dqEwnvj1DOI76dYcuquZH+2AWowtTYu2bbRU6uBX661vF4zydIY/PoYy/S1V0FMVeO09ZW89l1Wb6tmJPI+MeCndV5GgLZh8NHl6lnTI4Pg5VGOyySEwdtjbaf9dLXleWgA/K2r7fzPJti+7h3jfLypaT1s1314unogODjdMq26Axao3yk/rSW1+FNViq5DhHrNRKi/9NMXHsKdA66ZRti07rJp6k1iyjFbN5h1tut9odHAuRlwfoYaJHY7CbrXdFFrXQCfXKG+Z/Uk2HadGqyn94LEcMf3ATxYleKxToeY/DAFNl4N315lmdYzRv3xO6PRqL04XrhIDQJ/766eUdzdz/ny9fWvS5wH3K/tUiSm2rq1YW3VfPvvf7MEdlAPgsvGqmcG4+1q/Vd3cVzPpmugVbDjdLDU0id0gFdGqQfIEVW3Pry2KlBf2QkK74RFI5zVjFVBVimeccmO+/OE1RlaZKAadK2Zzrasxx0CCA+EoVUVhMGtoVMU/F8/24qGswPWoelqx4Gv/qK+9rP7PZmum7jW7mAkNX3hmxSFHWMGMr511ZVXmmDzj9R0Fad17tS6Jm4tLgTuH2B7gY5J2zA1OCv3WLowQt0Odk8NhS1/g3cvg81/s503PEE9mITbnRE4y1tbdx21lzoYpve0DbZgm4Z6cSQkhlW/jtn9YUYf5/sU4q+2hZiYhl2wptWo7R/D2jrOu6Ov84NJr1a2r2f0hosS1TOvj8erZ1TWTGdcflq4b4B6gNzwV/V/87HVWU9t/xfroO+sHaCPVQpoSmfHIHxh1X2TnhpqmWY6G+ofp9bsrc98rDnrb985Sq3dm84w7c8GTGMgxQTbnpW2VBL0RY0URU//SOtWQAMdq2rzpn7W1hdqtW7mH01YAAypClZD28KnV6jPO0eqwdSZv3RUa7DWZyXvXup8WVDHEXpvnG33ytO3wV391DOYr/4CcwaqjYnO8uWdImHR8Jr3Y8Vlas15QJz6cAX74HyJ1e2hr+8Ol9vdLnqMkzOMQD91enW1emfGd4ChbdQzBvsDi8mNPdT9fGGk7XULYDm7CA9UzwwXXAj/vdIyv0uU7YHFWmI43GW1zYud7FNMsO3+jLc6yJZVtvz0TvU3oBUCcKgXlP1Mxwg1iWrq355d1dXy7bHuH/v/6i5qEHb2YzdJClevEQC1cby0Qs0118Z6EDLTEMJxIZYzBz8NLB6pPjRLLcvuudG2kdGZ5Ai1sTkqyHWf4ZhEWGj12j7IX5SoXjR1sECt/bqqy2J0EGyeWvMyH1xu+3psO7UXVXyIbZfW3jHwtF2vrdrck6JerDYmSW1TcuadS+DODWoKyfpg99hg66VaZnpHgr6on5ArbWr6RsUyFsxFie4rlomftuZuh/Y0mroFfID7U9QrZ+0bKp0ZkQC/VV2NWlvANzH1cHGVy9pD5Wz48pCaO4+1OwtrHQoHpjt/b3NbcCG0CVHbChqrdwz89real7m5l/qwN74DkN/4MngyCfpexB31DodthkwwB/1DBWojbrFBPd3uWk0+v6W4uqv6qIvnR6hDFTjr4dKctBq4po5ldqex7Zx3Z21uWnefqjYDCfqifjSB5gbCU8WWIQ/6x0JANXlWXzQyEX74q7tLIerLJpmpKJ4x8JWLSUOuF3Dv986urq/REhVk6eb2z6qLj2rq/SKEt9D4QE1fgr6oUXVXAZu6uZnuc+sJp+ZCNJZtQGyZDbkS9EWDXGXVWBqodd63XAhv0/Lr+RL0RS2qq+tM6WwZ1fDBgY4XLgnhjbT2Y4S0QNKQK+qsNGIRpl5/wf6Qdr3ae6d7qxrfJoTXkPSO8CjuHGUToDx0ls1rf60EfNHCWFX03f17ayoS9EWNlBZa2xHCGet++sYWGvUl6HuBlp9lFMIzWP/WWmbIl6Av6sEX+jAL32bdkGtsoVHfY4K+Xq/nzjvvJC4ujtjYWO6++24MBoPTZXfu3MnIkSMJCwujR48efPnll81cWt/RQs9whXDKtqbfMr/8HhP0U1NTyczMJD09nYyMDPbt28f8+fMdlisrK2PixIlMmTKFc+fOsWzZMm6//XZ27drlhlILIVoS64AoNf0mZDQaeeedd1i8eDFJSUkkJCTw0ksv8dZbb1FZWWmz7Ndff014eDhz584lLCyMiy++mJtvvpl//vOfbiq975DkjmjpfCG94xH99A8ePEhxcTGDB1sGs+7fvz8Gg4E9e/bQr5/lfnU7duxgyBDbO2IPHTqUF154wem69Xo9er3e/Fqn0zWskDn3Q+nXDXtvIw2ugIOXqM+PZTbvtrUYSfaBuwkJAbYVm9zD/ch2U71YF/kB/ZJqufNOA3lE0M/JySE8PJzAQMt97TQaDTExMWRlZdkE/ZycHGJjY23eHxsbS1ZWltN1L1q0iKeeeqrxhTSeg4rDjV9PA4QAXWq4FV9zOKNPJD5Aor9o2YL9gzhZ1p52wcdJDjnqtnLsqCxrsnV7RNCvrleIoij4+/vXuqyz5UxSU1OZM2eO+bVOpyM5OdnpsjWKfgoi7q3/+1zkfClklbpt8yS36Ym/n0d8XYRoMlqtlsiOu8jIbeZTajudWzm5w4uLeMSvOD4+nqKiIsrLy821faPRSF5eHm3atHFY9siRIzbTsrOzHZYzCQoKIigoqPGFDOimPtwkPhji5epXIZpcZHAUfRPreY9GL+IRDbmdO3cmJiaGtLQ087T09HQAOnWyvffdkCFD2Lp1q820LVu20KtX0x0ZhRCipfCIoK/RaJg1axbz5s3j1KlTnD17lrlz5zJt2jSCg4OZNGkSy5cvB2DChAlUVlbywgsvUFJSwk8//cTy5cuZOXOmm/dCCCE8n0cEfYAFCxYwcOBAUlJS6N69O4mJiSxZsgSAY8eOkZOj3q3D39+f1atXs3r1auLi4rj55pt55ZVXGDlypDuLL4QQXkGjKL51zaVOpyMqKoqCggIiIyPdXRwhhGhWHlPTF0II0fQk6AshhA/xiC6bzcmUzWrwlblCCOGhIiIiah0N1+eCfmFhIUDDLtASQggPVpe2Sp9ryDUajZw+fbpOR0Rrpit5T5w44XMNwLLvvrfvvrrf4N37LjV9J7RaLe3atWvw+yMjI73ui+Aqsu++t+++ut/QcvddGnKFEMKHSNAXQggfIkG/joKCgnjiiSdcM3ibl5F9971999X9hpa/7z7XkCuEEL5MavpCCOFDJOgLIYQPkaAvhBA+RIK+EEL4EAn6daDX67nzzjuJi4sjNjaWu+++G4PB4O5iNYnPP/+cESNGEB4eTps2bXjwwQepqKgAIDc3l6lTpxIVFUVCQoJrbjjvgV544QU0Gg0ZGRmAb+x3eno6V111Fa1atSIgIIDXX38daPn7npmZyfjx4wkLCyM8PJwJEyawb98+oOX+7iXo10FqaiqZmZmkp6eTkZHBvn37mD9/vruL5XIFBQUsW7aMJ554guzsbH788UdWr17NCy+8AMCMGTNQFIXDhw+zadMmVq1axVtvveXmUrvWL7/8wvr16wkNDTVPa+n7fejQIa688kquvvpqDhw4QGlpKbfffjvQ8vd98uTJdO3alZMnT3Ls2DGSkpK47rrrgBb8u1dEjSorK5WIiAjl119/NU/buXOnEhERoVRUVLixZM1j0aJFyhVXXKFkZWUpWq1WOXnypHnef//7X6VXr15uLJ1rZWVlKX369FGOHDmihIWFKX/++adP7PeUKVOUjz/+2GF6S993g8GgaDQaJSMjwzzt559/VkJCQlr0715q+rU4ePAgxcXFDB482Dytf//+GAwG9uzZ48aSNY/s7GwSEhLYuXMnCQkJJCUlmecNHTqUvXv3tohhqo1GIzfddBPPPvssHTt2NE9v6fut1+v54YcfCAsLo3///oSGhjJq1Cj27t3b4vfd39+fqVOn8swzz1BaWkpJSQkvvfQSM2fObNG/ewn6tcjJySE8PJzAwEDzNI1GQ0xMDFlZWW4sWdPLyspi5cqV3HnnneTk5BAbG2szPzY2FkVROHfunJtK6DpPPfUUKSkpXHXVVTbTW/p+Hz58mLKyMt555x3WrFnDyZMn6d69O9dcc02L33eAd999l4CAANq3b0+nTp0YOHAgL7/8cov+3fvcKJv1Vd0wpYqi4O/fcj++oqIiJk+ezAMPPMDQoUM5cuSIwzJK1cXc3v45rF+/ng0bNvDjjz86zHP2/28p+w2Ql5eHoiisWLGCVq1aAbBkyRJatWrFsWPHHJZvSfsOsG7dOv744w8WLVrEkSNH+Ne//kVKSgpt27Z1unxL+N17d+mbQXx8PEVFRZSXl5uP+kajkby8PNq0aePm0jWN0tJSpkyZwrBhw0hNTQXUzyEnJ8dmuezsbACv/xwWLVrEtm3biIuLM08rLi5mxIgRJCUlmW+8Y9JS9hsgJCQEPz8/oqOjzdOioqIIDQ2lsrKyxf7PAc6fP8/f//53fv31Vy644AIApkyZwpgxY/j2229b7O9e0ju16Ny5MzExMaSlpZmnpaenA9CpUyd3FavJlJaWMnnyZHr27MnLL79snj5o0CCysrI4ffq0edqWLVvo0KEDISEh7iiqy3z00Ufs2bOHnTt3mh+gdl/dtGlTi91vgJ49e6LVatm6dat52pkzZyguLubWW29t0ft+6NAhFEVh4MCB5mkXXnghwcHBVFRUtNzfvbtakL3J448/rowaNUo5efKkcubMGeXSSy9VZs6c6e5iuVxJSYkybtw45b777nM6f/r06cq1116rZGdnK4cOHVL69eun/OMf/2jeQjYTQPnzzz8VRWn5+33//fcrKSkpyuHDh5WsrCzl6quvVq644gpFUVr2vut0OiUqKkqZP3++kpubq+Tl5SlPPvmkEh0dreTl5bXY370E/TowGAzKvffeq8TGxioRERHKtGnTlMLCQncXy+Xee+89BXD6OHLkiFJYWKjceOONSmRkpBITE6Pcf//9Xt99rTrWQb+l73d5ebly3333KbGxsUp4eLhyzTXXKOfPn1cUpeXv+5YtW5QxY8YooaGhSkhIiDJ69Ghl69atiqK03N+9DK0shBA+RHL6QgjhQyToCyGED5GgL4QQPkSCvhBC+BAJ+kII4UMk6AshhA+RoC+EED5Egr4QQvgQCfpCCOFDJOgLn7ds2TLzPWFN/vrXv7Jq1apmK0NxcTHdu3dn8+bN1S5jNBoZPnw4X375ZbOVS7Q8EvSFz9uwYYPDtC+//JKrr7662cqwZMkSBg0axLBhw6pdRqvV8txzz3H//fdTXl7ebGUTLYsEfeHTrrvuOj755BPuueceNBoNd911FwCDBw9mxYoVAGzcuJFRo0axYsUK2rdvT1hYGDfccANZWVnccMMNhIeHk5iYyBtvvGGz7p9++olBgwYREhJCv379+Pbbb6stx9tvv23eNsAzzzxDcnIyISEh9O7dm/fffx+A0aNH4+/vz9q1a138SQif4e4R34RwtzFjxihLly61mTZo0CBl+fLliqIoyoYNG5Tg4GBlxowZSl5envLnn38qbdu2VRISEpTly5crhYWFyueff674+/srx48fVxRFUQ4fPqzEx8cra9euVUpKSpSvv/5aiYyMVA4dOuSw/W3btinR0dGK0WhUFEVRfvzxRyUmJkbZvXu3UlJSovzxxx/Krl27zMvfc889yu23395En4Zo6aSmL0QdlJWVsWjRIqKjo+nbty8TJ06kQ4cO3HLLLYSHh3PNNdeQlJTE7t27AfjXv/7FDTfcwPjx4wkJCeEvf/kLw4YNc5qP/+WXX7jwwgvNt2YsKSnBaDQSFRVFSEgIF154If369TMvP2rUKH799dfm2XHR4kjQF6IOoqKibG6n2KpVK7p06WKzTHh4OEVFRQDs2rWLV199FY1GY36sW7fO6U21z5w5Q7t27cyvr7jiCqZPn06/fv247777OHr0qM3yiYmJNnezEqI+JOgLUQfOboZd0w2yFUVh4cKFKOqNisyP559/3mHZ3NxcIiMjza/9/Px49dVX2b59O35+fvTr149PPvnEPD8+Ph6dTofBYGjkXglfJEFf+DytVktlZaVL19m7d2+2bNlSp2Wjo6MdbkAO0LFjR5YsWcLixYt55plnzNNzc3MJDw8nICDAZeUVvkOCvvB57dq1Y/369ZSUlFBQUOCSdd5xxx388MMPvPrqq+Tn55Obm8uaNWs4ceKEw7IJCQmcOXPG/DotLY3169eTn59Pfn4+27Zts0n/nD17loSEBJeUU/geCfrC5z366KOcPXuW2NhYnn76aZess1u3bqxbt47PPvuMxMREOnXqxIsvvoji5O6kw4YNY+vWreZ0jdFo5OGHHyYpKYmkpCTOnDnDm2++aV7+l19+Yfjw4S4pp/A9co9cIdxMURSSkpJ4//33ufTSS2tdvmfPnjz77LPNevGYaDmkpi+Em2k0GmbMmOFwcZcz33//PUVFRUycOLEZSiZaIgn6QniAhx9+mF27dvHbb79Vu4zRaGTu3Lm8+uqrBAcHN2PpREsi6R0hhPAhUtMXQggfIkFfCCF8iAR9IYTwIRL0hRDCh0jQF0IIHyJBXwghfIgEfSGE8CES9IUQwodI0BdCCB8iQV8IIXzI/wNABGNwiiqyZgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "target = 3\n", + "Starting simulation at t=0. s for a duration of 90. s\n", + "5.7382 s (6%) simulated in 1m 0s, estimated 14m 41s remaining.\n", + "10.9472 s (12%) simulated in 2m 0s, estimated 14m 27s remaining.\n", + "16.5206 s (18%) simulated in 3m 0s, estimated 13m 21s remaining.\n", + "21.6028 s (24%) simulated in 4m 0s, estimated 12m 40s remaining.\n", + "26.5102 s (29%) simulated in 5m 0s, estimated 11m 59s remaining.\n", + "32.3136 s (35%) simulated in 6m 0s, estimated 10m 43s remaining.\n", + "37.4074 s (41%) simulated in 7m 0s, estimated 9m 51s remaining.\n", + "42.7774 s (47%) simulated in 8m 0s, estimated 8m 50s remaining.\n", + "47.4104 s (52%) simulated in 9m 0s, estimated 8m 5s remaining.\n", + "52.879 s (58%) simulated in 10m 0s, estimated 7m 1s remaining.\n", + "58.5566 s (65%) simulated in 11m 0s, estimated 5m 54s remaining.\n", + "63.3888 s (70%) simulated in 12m 0s, estimated 5m 2s remaining.\n", + "68.351 s (75%) simulated in 13m 0s, estimated 4m 7s remaining.\n", + "73.622 s (81%) simulated in 14m 0s, estimated 3m 7s remaining.\n", + "78.7916 s (87%) simulated in 15m 0s, estimated 2m 8s remaining.\n", + "83.499 s (92%) simulated in 16m 0s, estimated 1m 15s remaining.\n", + "89.1612 s (99%) simulated in 17m 0s, estimated 10s remaining.\n", + "90. s (100%) simulated in 17m 8s\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "target = 4\n", + "Starting simulation at t=0. s for a duration of 90. s\n", + "5.3652 s (5%) simulated in 1m 0s, estimated 15m 47s remaining.\n", + "10.5302 s (11%) simulated in 2m 0s, estimated 15m 6s remaining.\n", + "15.7146 s (17%) simulated in 3m 0s, estimated 14m 11s remaining.\n", + "21.2152 s (23%) simulated in 4m 0s, estimated 12m 58s remaining.\n", + "26.8102 s (29%) simulated in 5m 0s, estimated 11m 47s remaining.\n", + "31.5548 s (35%) simulated in 6m 0s, estimated 11m 7s remaining.\n", + "35.9668 s (39%) simulated in 7m 0s, estimated 10m 31s remaining.\n", + "41.1246 s (45%) simulated in 8m 0s, estimated 9m 30s remaining.\n", + "45.8936 s (50%) simulated in 9m 0s, estimated 8m 39s remaining.\n", + "50.3518 s (55%) simulated in 10m 0s, estimated 7m 52s remaining.\n", + "54.7624 s (60%) simulated in 11m 0s, estimated 7m 5s remaining.\n", + "59.8806 s (66%) simulated in 12m 0s, estimated 6m 2s remaining.\n", + "64.8026 s (72%) simulated in 13m 0s, estimated 5m 3s remaining.\n", + "69.893 s (77%) simulated in 14m 0s, estimated 4m 2s remaining.\n", + "74.2894 s (82%) simulated in 15m 0s, estimated 3m 10s remaining.\n", + "79.2674 s (88%) simulated in 16m 0s, estimated 2m 10s remaining.\n", + "84.3858 s (93%) simulated in 17m 0s, estimated 1m 8s remaining.\n", + "89.4886 s (99%) simulated in 18m 0s, estimated 6s remaining.\n", + "90. s (100%) simulated in 18m 6s\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAIPCAYAAACfew4GAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB9GElEQVR4nO3deXgT5doH4N8kadN9L6UblH0tZSm77CKCIiiIK4gKBz/ADQ9iFcQFBUFRDi4H9QjidlyAo4IgIKCAglCgUCj7WuhC27TpmqbNfH9MJplJJmmapM323NfVi2QymXlTmmfeed6NYVmWBSGEEJ8gc3UBCCGENB8K+oQQ4kMo6BNCiA+hoE8IIT6Egj4hhPgQCvqEEOJDKOgTQogPoaBPCCE+xOeCPsuyUKvVoDFphBBf5HNBv7y8HOHh4SgvL3d1UQghpNn5XNAnhBBfRkGfEEJ8CAV9QgjxIRT0CSHEh1DQJ4QQH0JBnxBCfAgFfUII8SEU9N1cpaYOKS9sQcoLW7D+r8uuLg4hxMNR0Hdz3Rb/anj88o8nXVgSQog3oKDvxrKulbq6CIQQL0NB341N+GC/2TadjuYMIoTYj4K+Gzp5owwpL2yRfK2itq6ZS0MI8SYU9N3QHf/aZ7bNX8H9V5XXUNAnhNiPgr6bUNdoMeerI/jPvktmr11aOg7B/nIAQDXV9AkhDlC4ugCEy9P3eGU7AGDLiTzRa5eWjgPDMAjyV0BVpUWlpt4VRSSEeAmq6btYgboGbV/8RfK1y8vuAMMwAIAgfU2/kmr6hBAHUNB3sf5v/ia5/asZ/UXPg5TcTVl1LdX0CSH2o/SOmzn00q2IDVWabQ/y42v6FPQJIfajoO9C2nqd6PnRRaMRGewvuW+wkgv6VRpK7xBC7EfpHRd6bN0hw+PfnhtmMeADQJA/d32mmj4hxBEU9F1o77kiw+N2sSFW9w2iLpuEECegoO8hqKZPCHEGCvoucuBiseHxwju6NLg/5fQJIc5AQd9F3v71jOHx4PYxDe4fqE/vVFFNnxDiAAr6LnL4isrwuEt8WIP7B+vTOxT0CSGOoKDvIWhELiHEGSjou8CIt/cYHn/xeD+b3sM35FbR3DuEEAdQ0G9mZdVaXCqqNDwf3K7hfD4ABPENuVqq6RNC7EdBv5nNXH9Y9FwmY2x6XzDV9AkhTkBBv5n9fanE8Pjte9Nsfh/l9AkhzkBB34Um90myed8g6rJJCHECtwz6P/zwAwYNGoSQkBDExcXhueeeQ10dV8MtKSnBlClTEB4ejvj4eLz66qsuLq3tiis0hsed4kIb9d5gpbHLJsvS4uiEEPu4XdAvKyvDmjVrsHjxYhQVFWHXrl3YvHkzVqxYAQCYMWMGWJbFxYsXsXfvXmzcuBEfffSRi0ttmz5Ldhoer7zP9tQOYKzp1+tYaOp0DexNCCHS3C7oh4eHY8eOHRgzZgwCAgLQrVs3PProo/jjjz9QWFiIH3/8Ee+99x6io6PRvn17vPbaa1i9erWri91o3RLCG7U/32UToBQPIcR+HjGfflFREeLj43Hs2DHEx8cjMTHR8Fr//v1x+vRpqNVqhIWZj2zVaDTQaIxpFbVa3SxltoaxrcOOiFzGQKmQQVOnQ1VtHaKsTMNMCCGWuF1N31RBQQHWr1+PWbNmobi4GNHR0aLXo6OjwbIsCgsLJd+/dOlShIeHG36Sk5Obo9hm/jh70/B4/4KRdh1DmNcnhBB7uHXQr6iowIQJE/Dss8+if//+hkXChfhGTYVC+qYlIyMDZWVlhp9r1641aZktmfbZ34bH8eEBdh0jkF8ykWbaJITYyW3TO9XV1Zg4cSIGDBiAjIwMAEBsbCyKi4tF+xUVcQuRxMXFSR5HqVRCqTRfc9aVpC5etuCnV6bF0Qkh9nLLmn51dTUmTJiAzp0749133zVs79OnDwoKCnDjxg3DtoMHD6J169YIDAx0RVFtcvFmheFxWnKE3cehhVQIIY5yu6DPB/yuXbvi/fffF9WKIyIi8OCDD+Lpp59GcXExLl68iMWLF+Mf//iHC0vcsJHv/G54vGJyD7uPYxygRekdQoh93C7of//999ixYwdWrVoFhmFEP5cvX8YHH3wApVKJtm3bom/fvhg1ahQWLFjg6mJbVFheI3resZGDsoQMNX2af4cQYie3y+lPmzYN06ZNs7rPl19+2UylcVy/N35z2rEMSyZSTZ8QYie3q+l7s/NvjHXo/SH6LpsV1HuHEGInCvpNLFQfqPumREIhd+zXbQj6NRT0CSH2oaDfxMr1tfL7+7Zy+FhU0yeEOIqCfhPS6YyzYe4+Iz1iuDFCArigX05BnxBiJwr6TWjCB/sNj58Y1s7h41F6hxDiKAr6TejE9TLD467x5pPBNVZoAN9lk4I+IcQ+FPSbiHCCNcD2tXCtCVH6AaCcPiHEfhT0m8iGI7mGx6dfv90px+T76ZdTeocQYicK+k3kRmm14XGAfnZMR/HpHarpE0LsRUG/iRy6rAIAdGgR4rRjCtM7tE4uIcQeFPSb2OO3tHHasfgum/U6FjVaWieXENJ4FPSbgLAWPrh9jNOOG+QnNyy1WK7ROu24hBDfQUG/CezMMQ7Eig113gIuMhmDEJppkxDiAAr6TeCvC8bVvZzViMvjUzw0QIsQYg8K+k3gs/2XmuzY/OLolN4hhNiDgr6HoakYCCGOoKDfhHokhTv9mNRXnxDiCKetnKXVanHs2DHcuHEDRUVFiIqKQnx8PHr27ImAgABnncbtCXvuvD6hu9OPT9MrE0Ic4XDQ3759Oz7++GNs374dLMsiPj4esbGxKCkpQX5+PrRaLW699Vb84x//wLhx45xRZrd2XTASt3O8/evhWsIHfZqKgRBiD4fSOxMnTsTcuXPRs2dP/P777ygvL8fZs2exf/9+5OTkQKVS4cCBAxg4cCCeeuopTJw40UnFdl+3vLXb8FipcG7PHcDYe4dm2iSE2MOhmv6YMWOwceNGyGSWrx3du3dH9+7dMW/ePHzwwQeOnI6A0juEEMc4VNP/v//7P8hkMpw4cQI6nfS0ANu3bwcA+Pn54ZlnnnHkdB4hTd94269NVJMcn3rvEEIc4ZTeO2lpaejXrx+ys7PNXhs7dqwzTuExLhZVAgDu7BHfJMenJRMJIY5wWpfNJ554AiNHjsTrr7+O+nrjFAG+NhtkVLA/AEDuhEVTpFBNnxDiCKcEfYZhMGPGDBw5cgR//fUX0tPTkZWVZXjNV7AsiyvFVQCAzi0dXx5RSmgAjcglhNjPaf30ASApKQm//PIL1q5di9tuuw2zZs1y5uHdnrraWPuOCPJrknOEB/qZnYsQQmzllJp+27ZtRc8fffRRHD16FEePHnXG4T1GYXmN4XG7WOctniIUFqAP+jVU0yeENJ5Tavrnzp0z25aQkICff/4Z165dc8YpPAI/MKttbHCTnSPMUNPXQqdjnbLgOiHEdzT53DvJyclNfQq38cneiwCAizcrm+wcfHpHxwKVtZTiIYQ0jkM1fZlMZrWhlmVZMAwj6s3jzfafL254JwcpFTL4y2WordehrFqL0ICmaTsghHgnh2r6J06cwPHjx3H8+HFkZWWBZVnD8+PHjxtet4darcakSZOQkpIi2r5kyRIwDCP6WbZsmSMfw+nSmmB2TR7DMIIUD9X0CSGN41BNv1u3bqLnDMOYbbPHyZMnMXnyZKSlpZm9lpeXh+XLl2P+/PkOn8eZhOMRXhjbpUnPFRaoQFGFhhpzCSGN5tQum86ye/duLF++HKGhoThw4IDotby8PAwdOtRFJbOssFxjeNw9sWn66PP4vH5ZNQV9QkjjuOUiKnPnzsX48eMlXysqKsLcuXOhVCoRHR2Nxx9/HCqVyuKxNBoN1Gq16Kcp3BQEfX7UbFMxdNukoE8IaSS3DPrWfPvttzhy5AjKysqwZ88e5OTkYNq0aRb3X7p0KcLDww0/TdWb6LN9xnVxm3oUchjV9AkhdnKoSnrvvfeKAhzLspgyZYrZft99950jpxGJjzdOZJaamoqPP/4YPXr0QHFxMaKjo832z8jIwLx58wzP1Wp1kwT+AxebvucOLzyQ+29T0/w7hJBGcijod+8uXg7QGY24jdWhQwewLIvS0lLJoK9UKqFUKpu8HLd1a4l1f17G9EEpTX4uSu8QQuzlUNBfvHixs8pht5ycHAQHByMxMdGl5eBz+q2jg5r8XOGBFPQJIfZxKKe/YsUKmwdeaTQah/vTV1RU4JVXXsHZs2eh0WiQlZWFGTNmYM6cOS5ffJ0P+jEhTX9XYeinT102CSGN5FDQP3r0KNq3b4/XX38dx48fl1w96/Dhw1i8eDHat29vmG7ZXn5+fjhz5gyGDRuGsLAw3HPPPZg0aRLefPNNh47rDPlqbrK1luFNf/GhLpuEEHs5lN75+uuvsXfvXnz88ccYMWIENBoNWrZsibCwMBQXF6OgoAABAQEYO3Ys1q9fjxEjRjTq+MOHD8fly5cNz5VKJb755htHitwkdDrWGPTDmj7oG3P61JBLCGkchzuUDxkyBEOGDEF9fT1OnjyJvLw8lJSUICIiAvHx8ejatSv8/f2dUVa3VViuQW2dDnIZg/hmqOmHGXrvUE2fENI4ThtFJJfL0aNHD/To0cNZh/QY11TcalmJEYFQyJt+6AOldwgh9vK4wVnu6Kp+icTkqMBmOR+f3qmqrYe23rwdhRBCLKGg7wRXS7ig3yqq6btrAsZ1cgHqtkkIaRwK+k7Ap3eSIpsn6CvkMoTq5/cppaBPCGkEpwX9//73v5gwYQIGDhxo2Hbw4EH89ttvzjqF28or5XruJEU2T3oHACKDucbx0qraZjsnIcTzOSXov/3223jxxRcxcOBA/P3334btDMPgueeec8Yp3Bpf244Iar5eSpFBXF5fVUk1fUKI7ZwS9P/1r3/h119/xQsvvCBaTKRbt244f/68M07h1nLyuOmaQ5TyZjsnX9MvoZo+IaQRnBL0VSqVYe4b4aybZWVl8PPz7jVc63XGi1x0cNNPwcCL1N9VqCop6BNCbOeUoD9s2DCsWbNGtK22thYvvvgiRo8e7YxTuC1h75mEiGbM6fNBv4rSO4QQ2zllcNa///1vjBs3Dl988QVYlsWYMWOQlZWFmJgY7NixwxmncFt5ZTWGx/6K5usMZczpU02fEGI7pwT9pKQkHD16FLt27cLx48fBsiyefvppjB492uvTO+/uPOuS8/I5fRXl9AkhjeCUoP/dd99hypQpGD16tCidU1lZiS1btmDixInOOI1byrpW6pLzGtM7FPQJIbZzSj7igQcekNzu5+eHhx9+2BmncFt83/xxqS2b9byRwfr0DuX0CSGN4FBN/9SpUwC4tXFzcnJE3TXr6+uxefNmxMXFOVZCN3fkaikAICq4eWcSpd47hBB7OBT0lyxZgr1794JhGLP1cRmGQXJyMt577z1HTuEx0pIimvV8UYKcvk7HQiZjGngHIYQ4YRGV+vp6dOzYERcuXHBWmTxScjNNtsaL0Pfe0bFAeU0dwoO8u8GcEOIcDuf05XI5srOznVEWj8OyLPzkXA27ORZEF1Iq5Aj250YA06hcQoitnNJ7R6FQ4MMPP0R2djZqamrMXv/ss8+ccRq3w81nz7Vj8AubNKfIYH9U1lZDVVWLNghu9vMTQjyPU3rvPP7441i9ejX8/Pzw+eefIyoqCiqVClu3bsXtt9/ujFO4JX6iNX+5DIF+zTfvDo8acwkhjeWUmv4vv/yCo0ePIjk5GatXr8bbb78NgKvhHzhwAFOmTHHGadwOP61xeJCfaM6h5mIcoEXdNgkhtnHavAFRUVEAgOjoaJSUlAAApkyZgi+//NJZp3A7ZfpgG+GC1A4AROkbb0sqNS45PyHE8zgl6Pfq1QuHDx8GAHTv3h3ffPMNAOD8+fPQar23FsovTO6KfD4ARIdws3oWVVB6hxBiG6ekd1577TVERkYCABYuXIgJEybg/fffR25uLp555hlnnMItXS+tBgCX9ZGP4YN+OdX0CSG2cUrQFy6ROGrUKJw6dQp///03kpKSMGDAAGecwi0t2ZIDAPj7UolLzh8TwuX0b1ZQ0CeE2MYp6Z1x48ZBozEGnlatWmHy5MleHfABIC0pHEDz99HnxYZSeocQ0jhOCfpHjhxBZWWlMw7lUa6WVAEAJqQluOT8hvQO1fQJITZyStCfN28eXnzxRdTX1zvjcB6D7yqZq6p2yfn5mn5JJTf/DiGENMQpOf3Kykrs2LEDbdq0Qc+ePREQECB6/bvvvnPGadxWr1YRLjkvP+lavY6FqqrW0JuHEEIscUrQl8lkmDZtmjMO5ZlcMDALAPzkMkQG+UFVpUVRBQV9QkjDnBL0Fy9e7IzDiKjVajz66KPIzMzE5cuXDds1Gg2eeuopbNiwASzL4v7778d7773n0mUZeyVHuOzcMSFKfdDXoBNCXVYOQohnaL6VvBvh5MmT6N+/v2Qgz8jIQE5ODrKyspCdnY0zZ85g4cKFzV7Gunqd4bGyGRdEN0WNuYSQxnBKTd/Zdu/ejeXLlyM0NBQHDhwwbNfpdPj000+xbds2JCYmAgDeeecdDBkyBG+++Sbk8uab9Ky8ps7wOCXGdTNc8o25N2mAFiHEBm4Z9OfOnQsA2LNnj2j7+fPnUVlZifT0dMO2Hj16QKvV4tSpU0hNTTU7lkajEY0hUKvVTimjuobruRPkL4ef3PU1fRqgRQixhVOi1fLly1Fba3mA0F9//YUNGzaguLjYofMUFxcjJCQE/v7G9WgZhkFUVBQKCgok37N06VKEh4cbfpKTkx0qA69U312zqta13VRjQrnfRVE5DdAihDTMKTX9jIwMtG7dGpcvX4ZMJsPYsWPRvXt3AMArr7yCt99+GwkJCSgqKsK+ffvQtWtXu85jafpilmWhUEh/lIyMDMybN8/wXK1WOyXwbzp63eFjOAPl9AkhjeGUmj7Lsnjsscewf/9+HDx4ECNGjMCPP/4IAPj444/x559/4uzZs3jqqaewZMkSu88TGxuLiooK0V2FTqeDSqVCXFyc5HuUSiXCwsJEP84QrGz+RVOktNDn9Aspp08IsYHTcvrbt2/H4MGDAQBnzpzBww8/jAkTJiA/P9+Qa3/iiSfQv39/u8/Rtm1bREVFITMz0zDJW1ZWFgCgTZs2Dn6Cxjl1wzltA45qGc4NhCtQmy9TSQghppxS0w8ICEBaWprheYcOHVBYWAiAS8nwaZnY2FjcvHnT7vMwDIPZs2djwYIFuH79OvLz8zF//nxMnTrVbBRwU2sdzfXYuadXYrOe11TLMO5zl1TWokbrW9NgEEIazylBf+jQoZg5cyaOHTuGkydP4sknn0RZWRnmzp0LlmVx8uRJAEBOTg5iYmIcOteiRYvQq1cvpKWloWPHjkhISMDKlSud8TEahV9ApVNL1w6ICg/0M4wTKFRTiocQYp1Tgv5//vMfqFQq9OvXDz179sS5c+dw5MgRtGjRAp9//jkmTJiA//u//8PEiRPx0EMP2Xzc4cOHi0bjAoBCocCqVatQVFQEtVqN9evXIyQkxBkfo1GK9YuR8/PfuArDMIjXp3jyKcVDCGmAU3L6iYmJ2LZtG1iWBcuykMm4a8nLL78MAEhKSsLGjRsxb948PPHEE844pcvxi6JHBrk26ANAXFgALhdXIa/MNbN9EkI8h1MHZwnz90IjRozAiBEjnHkql+PTOxFBrpvzh0eNuYQQWzklvXPu3DnceuutiIiIgFwuN/zIZLJmnRqhOaldvCi6EB/088sop08Isc4pNf2ZM2ciLi4OW7dudVo/eHfGsizU+rl3wtwh6IfxOX1K7xBCrHNK0M/MzMT169d9IuADgLqmDvX6larcIr3DB/0ySu8QQqxzSnonOTkZFRUVzjiUR1Dpe+4E+8uhVLg+fWVM71DQJ4RY55Sg/9prr+Gpp55Cbm6uMw7n9lT6njsRbtBzBzAG/cJyDa2VSwixyinpndWrV+Pw4cPYtGkTgoKCEBgYKHqdH53rLfgZNiODXZ/aAYDYECVkDFCnY3GzQoO4sOYdnUwI8RxOCfqvvfaaMw7jMSo0XCNuiNI9liNQyGWIDw/E9dJq5KqqKegTQixyStQaNmyYMw7jMSr1QT/Y3z2CPgAkRvJBvwp9Wke6ujiEEDflUNT63//+h4kTJ2L9+vVW95s2bZojp3E7lfqFU4LdpKYPAEmRgfj7EpCrom6bhBDLHIpa69evx8SJE7F69WqL+zAM431Bn6/pu8mc+gCQHBkEAMhVVbm4JIQQd+ZQ0N+4cSMA4NChQ04pjKeocMP0TlIk13hONX1CiDVO6bI5btw40eLj3q6syn2mYOAlGWr6FPQJIZY5JegfOXIElZWVzjiURyit1vfTd/G0ykLJUVxN/7qqmvrqE0IsckrQnzdvHl588UXU1/vGyk18P/0IN6rptwwLgFzGoLZeR+vlEkIsckpSurKyEjt27ECbNm3Qs2dPs6ULv/vuO2ecxm2402RrPK6vfgByVVy3TX6ULiGECDkl6MtkMq/roWNNdS0X9IP83af3DsD14OGCfjXSU1xdGkKIO3JK0F+8eLEzDuMxDDX9APep6QNcXv+vi8CVYuq2SQiR5lDQv3HjBhISEnD16lWr+7Vq1cqR07gVlmVRXsPl9EMD3KfLJgC0ieHWCr5Y5DsznhJCGsehqDVs2DCcO3cOKSkpYBgGLGvea4RhGK9q4K3R6qCt5z6nO+X0AaBtbDAA4FKR7/SkIoQ0jt1B//Tp0zh+/DgAoLy83GkFcndqfS1fxnDz6buTtjFc0L94sxIsy0quV0wI8W12d9kcNmwYamq4RTveeustBAcHW/zxJsbUjp/bBdVW0UGQMdyI4ZvUbZMQIsHuoF9ZWWkYhfvGG284rUDurqyaa8R1t3w+ACgVcsPI3IuU4iGESLA7ct1zzz3o168f+vbtC5ZlMWXKFIv7elM/fb6m7249d3htY4NxtaQKZwvKMaBttKuLQwhxM3YH/bVr1+L777/H+fPnsWXLFnTr1s2Z5XJbfHdNd6zpA4BKP1r45R9PYtrAFNcWhhDiduyOXHK5HPfffz8AIDc312f66htq+m7Wc4fXIlTp6iIQQtyYU+be+fe//+2Mw3iEcr6m70YLqAgtmdjd8Ji/QBFCCM8pQd+X8AuohLhpeicuLABxYVxt/2wBDdIihIhR0G8kwwIqblrTB4COcaEAgDP5vjN+ghBiG48N+kuWLAHDMKKfZcuWNfl5DTV9Nw76nVvyQV/t4pIQQtyNxwb9vLw8LF++HCzLGn5eeOGFJj9vpUa/KLqbjcYV4mv6n/91hRZUIYSIuG91tQF5eXkYOnRos5/XE9I7yVFBhsc5+Wp0Swh36vFZlsVt7/6Bc4UVGNu9JVpFBSFjXBennoMQ0jQ8tqZfVFSEuXPnQqlUIjo6Go8//jhUKpXZfhqNBmq1WvTjiEoPCPq9WkUYHp8tcH5ef/Wu8zhXyDUSb83Ox5o/LiJXRdM5E+IJPDbof/vttzhy5AjKysqwZ88e5OTkSC7ksnTpUoSHhxt+kpOTHTpvZa0+vePGQV+pkOO+dO5zfrTngtOPv3LHWbNt+88XOf08hBDn89igHx8fj+TkZAQEBCA1NRUff/wxtmzZguLiYtF+GRkZKCsrM/xcu3bNofMaG3LdN6cPANEh3KLtZwsqUN8Mef0FG040av/aOh06L9qKGZ8fbqISEUKkeGzQN9WhQwewLIvS0lLRdqVSibCwMNGPIzwhvQMAd/VMMDx2ZoqnQF1j8TWp9RQs6bhwK2q0OuzMKcCrP590RtFcqqzasYFwV4orG31xLq2qxZ4zhY36vRPi3pGrEXJychAcHIzExMQmPU9xZS0AINjfvX91nVuGwV8hQ22dDkevlqJLvGMXO17/N38zPJ43uiO6JYThcX1tff1fV/DIoJQGj1FaVSt6vnb/ZTw/pjMCm7FH1MWbFUiKDIK/wrzew7IsnvsuC4H+crxxd2qDx0p5YYvh8eGFtyImpHFTYby06QS+OsitPnd52R02v6/nazsAAM/f3gmzh7c3bGdZFm0yfgEAvDK+K6YPbtOo8mjrdfCTu0d9sFJTh5U7ziLrWilYAF/P7A+lQvrvZMepAsxcb7xzHN4pFt0TwjGxVwLatwg12//PC0U4eLEET43qALnMvaZJb0ru8T/bSBUVFXjllVdw9uxZaDQaZGVlYcaMGZgzZw4CAgKa7Lw1WuMKYO5e0weAfwxpCwA4etW8gdsZ5o5oj1Fd4gyLtyz+6SRulFZbfc+hyyWGYCWUfaPM5vOeyC1DygtbcOfqvaL/E4ALeNZqzNp6HVJe2IKR7/yOu97fJ7lPgVqDjUev46uDV7EhM9dqWcqqxDX89CU7UVhufjdUqK7BpI/+RF6Z+PdzJr/cEPC5c1u+k+LLP//7LFG7yvJtZ0T7nMozdlZ45edTqK41/x0dvaoSTdNx8WYFUl7YgpQXtqDDS1tFF7LMKyo8912W2e8aAA5fLsH1Bv7PrWnoLqXb4l/xn32XcPiKCplXVEh/fafkfoXqGlHAB4A9Z27i/d3ncevKPyTf8+AnB7Hqt3No9+IvuOWtXT5zx+SRQd/Pzw9nzpzBsGHDEBYWhnvuuQeTJk3Cm2++2aTnrRJ8ecLddMI1Ib4Xz7FrpU1yfJm+diScu3/Qsl1IeWELtp7Ik3zPvf/+S3L7kSvWL0x19TrD4/H6YJ19XY3Oi7YZzlVVW4c2Gb+g3Yu/YMnmUzhfyKW1SqtqcVJ/Uenw0lbDcU7nl5t90R/85AAGLDXezTz3fRaulYh7Jt394X6kvLAFlZo6DFr2G0z1e+M33P3hfvG2N39D5hUVBi7dhVU7zxm2j3lPHJDm/3Dc8LioQoN954pw8aZxOo2NR3LxfWYu/vXbOdH7hBenf6zPFL2WlVsqev7J3ou4+8M/kfrKdpRVa/HRngsY+c7vZp+jQF2D6tp6TProT2w4kovOi7aBZVlsOpqLcwXl+DnrBib/+y8MXrYLf14wNuRfKqrEqRtqw0WkpFJ8Z1ejrceOUwVIeWEL2mT8gpQXtqCqts7wObYc5/4/D1wUt88BQLk+vWqq35vm/w9CKpMymMpVVWPSR39a3cdbuH91VYJSqcQ333zT7Ofl/zD9FTKPuB3smRwBADhXWIGyaq1DF6qq2jpRgPz5ycGG38fCO7pgyZYc0f7/99URrH+sH9JTIlGvY/FT1g2k6csj9Nzojnhnx1ks3XoaS7eeBgD8/dIo0Yjnri//anj81wsjzY7xf18dQebCW9FnibEW+Om+S/h03yXRfssnm6dqzhVUICkqEACw+rdz+POCeaAZsnw3/nlbR5RWa3FrlzgcvVoKALjr/X2G3lymjl4txf0f/4U1U/uYpUre3XkWk3onoqTKPBD9cfYmKmq00LEs0gWfZ/dzwxEXrrTYYP7c91kY1aUFjlxRmdW8/zxfhB5J4ajXsRj3r724VmJ8Pe3V7ZLHA4C9527iarH4gvfYusPYfabQbN8HPzmIk6/ehvOFlZjwgfiC1/v1HWgZpsTOecNQVl2Hsav+MExRzuv68q/YNHsQnvs+i3sePxz3f3xAslyPfPY3FtzeGSkx3HiUSgsXAqE/zxdhRJcWAICSilo8v+G42T5HrpYa/qaD3Dx96wiG9ZV7Gj21Wo3w8HCUlZU1ulH3XEE5Rr/7ByKC/HDs5duaqITONWzFblwprsL6x/phaMdYu48jvN0nxNs1pm3F03hkesdV+PROkJ97d9cU6tM6EgBw8JJ5DZYQIu33szddXYQmQ0G/EfiGrAA3nnfH1KB2MQAgmbZojFOvjcEzt3YAAIQFKHDqtTEWf4RplA8f7IVOceY9J+bf1gl/vTASp14bg/v7JtlVpiOLbrXvwwBYPL6r1dffuLs7Tr02xubj8Z/l6Mu3YstTt1jcL0Tibyc+PACnXhuDQe0av7xl9iu3QSrRGOIvx4lXGnc3uujOrjj12hj8MX+Eze9JjgpEYqR05wlbxrKcfLXhMm556hazvyve4vFd8djgFMNz07/FX59ueKqWU6+NQVSQOPX5yGd/i9qRvAkF/Ubg591x1wVUpAzUB5LjuWUOLaoS5K/A+r+uAOCWjAzyV1j8mZLeyvC+2V8fxRmTcQKxoUrMGdke8RGBCPJXYNmkNHw8tQ9u7RJn8fxv3N1d9DwtOQJRwUoM7yROWV1edofo57nRHSWPN91K19KvZ/bHQ/1bI8hfgRfGdpbcx7R9gv8skUFKdEsIx+YnpQP/scW3wU8uDtObZg9GkL8Ca6b2Mdv/+ycGSh5n57xhyHntdoQESKcav5w5AKEBfphxi3R3zZ/mDsazt3aEn5zBS+O64MyS2/H4LW0Q5K9Aq+ggs/2FFySFjMHp12/H0UWj8cf8Edg8d4jZ/jEh/sh+9XZseeoWDLOQVlz9QC8EK/2w93nrF5luCeGGv6tPpqWLXnv151P4bP9lw3PTv8WOLUMsHjclOgh/vjASQf4KTOxlXvEwbQD3FhT0G8GwapabLoouJTEiECnRQajXsTh0ucShY/F3OkM6xDS4b3y45a6zvzxlHiRu69YSnz6SjjNLbsep18Zg13PDDK+tmdoHD/VvjcvL7sDTozogvXUkNv3fIADAislphv1MAwIAPDmqAy4vuwOfP9bPsO3rGf3BMAx+sBBQ+7cxBrgnhrXDPP2FI1nf4Lv16SFYN72vxc8HAN0Tw0VjIxIjArFp9iAo5DIcyBgl2rel/ncVGuCHB/oZL5hjusWhb0oUzr8x1uz47VuEGMY1hAf54e5e4vEpXeK5u6un9HdnQq/e1Q09kiLw9K0dcO6NcZg5tK1Z33fTi8VHD3MX5X8MbYvTr9+OAD85IoP9wTAMIoP9RfsyDPDtLO532y0hHJ8/1g9hgkWHXr6zKy4vuwPj07gBhMIJAgHuYsDbOHuQ6LXRXeMsXrBjJZYKZRgGv88fLrn/nvkjkBDB/Z8+d5t55eCPs945tYjnVFndAF9TdtdF0S0Z2C4Gl4uvYt+5YozsbLk23ZB2sSE4cb0M6a2jGtx32zNDzXqGhAYo8Opd3SS/nDw++LSNDcGlpePAMOJa8bOjO+JZQe09NlSJ+WM6obiiFrfqe2dIGdYxFpeX3SEaeJSeEoVbu8RhZ06BaF/TnllPjeqAWcPMA2P7FiE4X1iBtRYuAJufvAWn89Uor6nDgLbGC0m0lcFbS+9JxWsTuol6/CjkMkzomYAfj90AAMmLVa9WEdh09DoA4K+MkYayhklUUCb1aTidtvDOrrg3PRlj3vsDt3aJQ3igHz59xPyiyusSH4acPDUigvxwdNFos/+3rMW3QVvPSg6GA4C1j/bFo2sPYdPsQejVKhLpKZG4UlyF3q0izfZddGdXFFfW4uesG6Ltt3drKXns1tHBuLzsDry17bRhLqqOceI7gGClAv+bMxgTBT2P9p67Kfpb8xaeFb1cjO9m5s4LqEgZ1jEG3/x9Fb+ezMeiO7uYfSFtsXzbaZy4zvV157vKWSPVPfTootFQNGKkp63lnDOifcM76Zl2n1wysTuSIgPRqWUoNh25jhX39pB8n9Qo0J3zhknsaSSXMRantX773jT88/ss0R2IpTICwDv3pqFP60gkRwYhPcX8oju5TxLW7b+M1tFBiA8PFL12IGMUcvLV+GzfJSgVcpvXgujUMhSHXrrVpq6+/505AN9nXsOEnomS/28Mw8BfYfn/c0SnFqIeM/HhgWafgyeXMcgY29ks6I/sbPmiDwALbu9sCPoL7zBv0+mZHIFdzw2DuqYOEz/Yj2PXSlFWpUV4kOfc2dvCs6KXi/HpjSAPasgFgOGdWiDYX47rpdU4eq1UsvbUkA8Fs3XG2jjNwBt3d8dLm7INzxsT8JtLy/AAvHJXNwAQpVaa2uQ+SZhsQ42bp5DLMG1gisXXg/wV+O056YtQy/AAtAwPwIhO1oOiFGt3ZULhQX6YoR8B3hwSIgKx9J5UXC6qRHFlLUZ1boERDQR9APj1maHIulaKW9pLpyjbxnJ3APxd3N7zN3FnjwTJfT0VBf1GMPTe8aAumwBX3lu7xuHHYzew5XieXUFfyNaBaQ/2a4W40ABUaetxR2q8Q+ckDbPnDs6T2XOR7tQyFJ1amvcmMzWqcwucL6zArycLvC7ou1/Vy43VaLkuXEoPC/oADEF3y/E8h5dQTE2ybSUuhmFwa9c43JWW4BEjmAnh3d6dax/YlVMgOeeQJ6Og3wj8f77SQmOUOxvWKRahSgXy1TXIbOQEbMJZMTMX3urVQ9QJAYC0pAjEhwegsrYe+855Vy8ez4teLqSp42r6npbeAbiGyNHduJ47m00awBpSLpgnxVrPE0K8hUzGYIy+N9Dcb45AU+c9tX0K+o1gzOl75q/tzh5ciueX7PxGLdhRrf/ckV7Wi4EQa8ancd+XGq0OEz/wnhk4PTN6uQgf/AI9sKYPALe0j0V4oB9ulmvw9yXbB2oZ5hyitA7xIcIODzl5asOIfE9HQb8RjMHPM4O+v0KGMfoUz4Yj1hcHETJON+uZn5sQezAMgw8f6m14/tOxxqVF3RUF/Ubgg36gB9d47+ubDID7Ay6q0Nj0niqNZ1/sCLHXuNR4vDSuCwDgq4NXvGJ1LQr6jVDtBTXe3q0i0TM5ArX1Onx54IpN76ni01oe/LkJsdfkPklQKmQ4eUPt8Gy17oCCfiN4enoH4G5ZH9dPpvX5n5dtmnmz2gdWEyLEkshgf8NAsA92n3dxaRxHQb8Rqr2kQXNs95ZoGxsMVZUWn+273OD+xrSW517sCHHEzKFtoZAx+PNCscOz1boaBX0bsSyLSi9I7wDcPC7P3srNHvjp3osobiC3z49E9tReS4Q4KjEiEPemc+1hSzafcnhUuytR0LdRbb0O/P+zN9R470iNR7eEMJRr6rBMvyC5JXx6h4I+8WXPju6AYH85snLLDNNYeyIK+jaqqTUuneYNwU8mY/DaBG41qu8zc3HwouUGqkpK7xCCFqEBmDOSm8b79S2nUFhe4+IS2YeCvo34gVkKGSM537kn6tM6Eg/0425Z532XhbIq6UZdvp++p60jQIizzRzSFl3jw1BapcWLG094ZJrHO6JXM/D00biWvDiuC1pHB+F6aTWe+/6Y5B9xhb6ffjAFfeLj/OQyvH1vGvzlMuzMKcS/dp1zdZEajYK+jfieO544rbI1oQF+eP+B3vBXcH/ES7fmmA1AqdLwNX3v+uyE2KNrQhhem8AtvPPeznP4+uBVF5eocSjo26imjs9re9+vLDUpHG9NSgUAfLL3Et7ZflYU+Cupnz4hIvf3a4U5I9oBABb+7wR+yLR9WhNX874I1kQMM2xKrJXqDe7ulYSX7+TWDX1/93ks2HDcMJ1sNXXZJMTMP2/rhAf7t4KOBf75fRZW7TyHeh3r9lM1UNXNRhqt586lb6vHbmkDP4UMi3/MxneHc3Hyhhrv3tcTGn7xGA+dUpqQpsAwDJZM6I7QAAXW/H4R7+48i+8OX8P10mrc3q0lXp3QDXFhAa4uphn6FtvI0+fSt9XUAa3x2fS+iAzyw8kbaoxbtRen88sBcAuxEEKMZDIGGWO7YPnkHgj2l+N6aTUAYNvJfNy68nes+f2C2y3A4t0RzIn4nL431/R5wzu1wNanh2J01zjUCXrzePsFjxB7TUlPxtanh2Jw+2jDtvKaOizdehrDV+zBmt8vNDjyvaSyFucLK5o8PeSR6R2NRoOnnnoKGzZsAMuyuP/++/Hee+/Bz6/pVnbi0zv+XtJHvyEtwwPwybR07DpdgOXbzqC0Sos2McGuLhYhbqtVdBC+fLw/zhdWoHV0MH7KuoG3fz2DvLIaLN16Git+PYOhHWMxsnMLDGwXjTbRwZDJGBSoa3CpqBIvbDiOy8VVaBsbjNcndMfg9jFNUk6PDPoZGRnIyclBVlYWZDIZpk6dioULF+Ktt95qsnPW1nNB39fy2iM7x2Fk5zjodCxkMsbVxSHErTEMgw5xoQC4KZnHp8Xjx2M38MVfV3Diehl2nS7ErtOFAIDwQD/0SArHXpOF1y/erGzSgZAM6+5NzSZ0Oh0iIiKwbds2DBo0CACQlZWFIUOGQKVSQS63nn5Rq9UIDw9HWVkZwsLCbD7vp3svYsmWHEzsmYD37u/l0GcghPie84Xl2HoiH3+cu4njuWXQ1Okk93vz7lQ80C8ZDNM0lSyPq+mfP38elZWVSE9PN2zr0aMHtFotTp06hdTUVNH+Go0GGo0xl6ZWqxt9TpZlsfsMd3X2V/hWTZ8Q4hztW4TiyVGheHJUB9TW6XA6X40T18tw6oYaHeNCMapLC/jLZWjRxD1+PC7oFxcXIyQkBP7+/oZtDMMgKioKBQUFZkF/6dKlePXVVx0+b2QQd76+KVEOH4sQ4tv8FTL0SIpAj6SIZj+3x1VbLd3ysCwLhcL8GpaRkYGysjLDz7Vr1+w65xt3p+K9+3picp+kRr+fEELchcfV9GNjY1FRUYHa2lpDbV+n00GlUiEuLs5sf6VSCaVS6fB5wwP9MLFXosPHIYQQV/K4mn7btm0RFRWFzMxMw7asrCwAQJs2bVxVLEII8QgeF/QZhsHs2bOxYMECXL9+Hfn5+Zg/fz6mTp2KgAD3G/JMCCHuxOPSOwCwaNEilJaWIi0tDbW1tZg4cSJWrlzp6mIRQojb87h++o6yt58+IYR4A49L7xBCCLEfBX1CCPEhHpnTdwSfzbJnZC4hhLiz0NDQBqdv8LmgX17OzQ2fnJzs4pIQQohz2dJW6XMNuTqdDjdu3LDpiiikVquRnJyMa9eu+VwDMH123/vsvvq5Ac/+7FTTlyCTyZCUZP9UCmFhYR73h+As9Nl977P76ucGvPezU0MuIYT4EAr6hBDiQyjo20ipVGLx4sVOmbzN09Bn973P7qufG/D+z+5zDbmEEOLLqKZPCCE+hII+IYT4EAr6hBDiQyjoE0KID6GgTwghPoSCPiGE+BAK+oQQ4kMo6BNCiA+hoE8IIT6Egj4hhPgQCvqEEOJDKOgTQogPoaBPCCE+hII+IYT4EAr6hBDiQyjoE0KID6GgTwghPoSCPiGE+BAK+oQQ4kMo6BNCiA+hoE8IIT6Egj4hhPgQCvqEEOJDKOgTQogPoaBPCCE+hII+IYT4EAr6hBDiQyjoE0KID6GgTwghPoSCPiGE+BAK+oQQ4kMo6BNCiA+hoE8IIT6Egj4hhPgQnwv6LMtCrVaDZVlXF4UQQpqdzwX98vJyhIeHo7y83NVFIYSQZudzQZ8QQnwZBX1CCPEhFPQJIcSHUNAnhBAf4jZBX61WY9KkSUhJSbG637FjxzB48GAEBwejU6dO2LRpU/MUkBBCvIDC1QUAgJMnT2Ly5MlIS0uzul9NTQ3GjRuHZ599Ftu3b8ehQ4dwzz33oF27dujRo0czlZYQ0lxYlkVdXR3q6+tdXRSX8/Pzg1wud/g4DOsGHdbff/99tG7dGqGhoZg+fTouX74sud/333+Pl156CWfPnjVse/bZZ6HRaPDhhx/adC61Wo3w8HCUlZUhLCzMGcUnhDSB2tpa5OXloaqqytVFcQsMwyApKQkhISEOHcctavpz584FAOzZs8fqfkePHkW/fv1E2/r3748VK1ZYfI9Go4FGozE8V6vVdpVx8QFgxzW73uoUChnwQh9gXIrrykBIc9HpdLh06RLkcjkSEhLg7+8PhmFcXSyXYVkWN2/eRG5uLjp06OBQjd8tgr6tiouLER0dLdoWHR2NgoICi+9ZunQpXn31VYfPfa4M+Cvf4cM4JEBOQZ/4htraWuh0OiQnJyMoKMjVxXELsbGxuHz5MrRare8EfakrPcuyUCgsf4yMjAzMmzfP8FytViM5ObnR557XE7ivQ6Pf5hR7bwDvHAXqXZ6II6R5yWRu09fE5Zx1p+NRQT82NhaXLl0SbSsqKkJcXJzF9yiVSiiVSofPnR4HpDt8FPtU17noxIQQr+NRl9F+/frh0KFDom0HDx5Ely5dXFQiQgjxLG4f9MePH4+1a9cCAMaOHYv6+nqsWLECVVVV+P3337F27VrMnDnTxaUkhBDP4PZB/8qVKyguLgYAKBQKbN68GZs3b0ZMTAweeeQRvPfeexg8eLCLS0kIIUYsyyIiIgKrV682e2327NlmvRCbk1vl9IcPH27WR//48eOi5507d8bvv//ejKUihJDGuXDhAsrKypCebt4SmJmZiT59+rigVBy3r+kTI+q8Q4hnyMzMhEKhQM+ePUXbtVotjh8/7tKg71Y1fUIIsYRlgSoX9GQLUgCN7S2ZmZmJrl27IjAwULT95MmTqKmpoaBPrPPdcYiEGFXVASH/bv7zVjwBBPs17j2ZmZkWUztKpRLdu3c3bFu3bh1Wr16N+vp66HQ6PPfcc3jkkUccLbZFlN4hhBAnO3LkiMWgn5qaCj8/7iqyZs0afPbZZ/j1119x7Ngx7N69u8nX76aaPiHEIwQpuFq3K87bGNeuXUNpaSm6detm9trOnTsxduxYAIBKpcLChQuRlZWFmJgYANy0MtOnT3e0yFZR0CeEeASGaXyaxRW0Wi0AoKKiQrR9x44dOHfuHNatWwcA2LRpE0aMGIGEhIRmLR8FfQ/i+kmwCSENadOmDTp37oyMjAwolUrExMTg4MGDeOmllzB9+nQMGjQIAJCdnW3Wu6c5UNAnhBAnYhgGW7ZswT//+U/cd9990Gq1aN++Pd5880089thjhv2Cg4Oh0+mavXzUkOsBfHgacUI8Utu2bbFx40YUFRWhrKwMmZmZmDlzpmhK5LFjx+Lrr782zDigVqvx5ZdfNnnZKOgTQogLDBo0CPPmzcOIESOQmpqKW265xdAe0JQovUMIIS4yY8YMzJgxo1nPSTV9QgjxIRT0CSHEh1DQ9yDUY5MQ4igK+oQQ4kMo6HsA6rFJCHEWCvqEEOJDKOgTQogPoaBPCCE+hII+IYT4EAr6HoRm2SSEOIqCPiGEOBnLsoiIiMDq1avNXps9ezb69evnglJxKOh7AJplkxDPcuHCBZSVlVlcMtGVC6NT0CeEECfLzMyEQqEwWyRFq9Xi+PHjFPQJIcSbZGZmomvXrggMDBRtP3nyJGpqalwa9GlqZUKIZ2BZgK1q/vMyQY3OsWZmZlpM7SiVSnTv3h0AsHLlSpSUlGDJkiUAgLq6OkRHR6O4uBgKRdOEZwr6hBDPwFYBV0Oa/7ytKgAmuFFvOXLkCCZPnmy2PTMzE6mpqfDz41Z4z87Oxrhx4wyv5+TkICUlpckCPuBG6R2NRoNZs2YhJiYG0dHRmDNnjsVVZP7zn/+gU6dO8Pf3R2JiIp5//nnU1dU1c4mbH/XYJMT9Xbt2DaWlpejWrZvZazt37jQsjA5wQT8tLc3w/NixY0hNTW3S8rlNTT8jIwM5OTnIysqCTCbD1KlTsXDhQrz11lui/fbv34+5c+diw4YNGDlyJM6ePYsJEyYgISEBzzzzjGsKTwhpekwQV+t2xXkbga+sVlSIy7pjxw6cO3cO69atA8B16zx9+jRGjx5t2EelUiEjI8Ox8jbALYK+TqfDp59+im3btiExMREA8M4772DIkCF48803RYsJnz59Gt27dzfcEvXo0cMQ/L0V9dgkBFxevZFpFldo06YNOnfujIyMDCiVSsTExODgwYN46aWXMH36dENN/9KlS+jYsSMOHz5seO/YsWObvKbvFumd8+fPo7KyUtTw0aNHD2i1Wpw6dUq07+23346rV6/iu+++AwBkZWVh+/btmDp1quSxNRoN1Gq16IcQQpoKwzDYsmUL2rVrh/vuuw9Dhw7FmjVr8Oabb+LTTz817JednY0uXbqI3nvq1ClDI29TcYuafnFxMUJCQuDv72/YxjAMoqKiUFBQILryJSYmYufOnRg/fjxefvlllJaW4qeffrI4wm3p0qV49dVXm/wzEEIIr23btti4caPVfbKzs9G1a1fD88rKSpSVlaF169ZNWja3qOkzFrpDsSxr1oqt0+mwcuVKdOjQAUuWLEHv3r0xd+5cFBYWSh4jIyMDZWVlhp9r1645vfyEENJYpjX906dPiy4CTcUtavqxsbGoqKhAbW2tobav0+mgUqkQFxcn2veDDz7A8ePHcfDgQSgUCkyePBlPP/00HnnkEWzdutXs2EqlEkqlslk+R1OjCdcI8R5ff/216HmfPn3w559/Nvl53aKm37ZtW0RFRSEzM9OwLSsrCwDXKCJ08uRJ9OnTR3QHMGrUKJw8ebJ5CksIIR7MLYI+wzCYPXs2FixYgOvXryM/Px/z58/H1KlTERAQgPHjx2Pt2rUAgEGDBmHDhg3Ys2cPampqcObMGSxbtgyjRo1y8adoOtR7hxDiLG6R3gGARYsWobS0FGlpaaitrcXEiROxcuVKAMCVK1dQXFwMAJg2bRoKCwsxc+ZMXLlyBZGRkbjnnnuwYsUKVxafEEI8AsOyvpUpVqvVCA8PR1lZGcLCwlxdHJtsPA9M2grcEg/sNR/ZTYjXqampwaVLl9CmTRsEBAS4ujhuwVm/E7dI7xBCCGkeFPQJIW7LxxIRVjnrd0FB34PQnz/xFfwslFVVLphK2U3V1tYCgGhaGnu4TUMuIYTw5HI5IiIiDIMug4KCLA7i9AU6nQ43b95EUFCQw9MuU9D3AD78t058WMuWLQHA4mh7XyOTydCqVSuHL34U9AkhbolhGMTHx6NFixYW19bwJf7+/pDJHM/IU9AnhLg1uVzucB6bGFFDLiGE+BAK+oQQ4kMo6HsQ6rJJCHEUBX1CCPEhFPQ9APXYJIQ4CwV9QgjxIRT0CSHEh1DQJ4QQH0JBnxBCfAgFfQ9Cs8wSQhxFQZ8QQnwIBX0PQLNsEkKchYI+IYT4EAr6hBDiQyjoE0KID6GgTwghPoSCvgdxVY/N3bnAh8dddHJCiFPRylmkQSM3cf92iwaGJbq2LIQQx1BN3wO4S4/NK2pXl4AQ4igK+sRmfxe4ugSEEEe5TdDXaDSYNWsWYmJiEB0djTlz5kCr1Vrc/+OPP0ZaWhoCAgIQGhqKoqKiZiytb/rghKtLQAhxlNsE/YyMDOTk5CArKwvZ2dk4c+YMFi5cKLnvsmXL8OWXX2LNmjUoKSlBQUEBoqKimrnEhBDieRiWdf00XjqdDhEREdi2bRsGDRoEAMjKysKQIUOgUqkgl8sN+xYUFKBv3744efIkQkNDG30utVqN8PBwlJWVISwszGmfoSn9dBGYsAXoHwccmNL852dWGx/vuYcacwnxZG5R0z9//jwqKyuRnp5u2NajRw9otVqcOnVKtO/27dtxyy23YMmSJWjZsiUiIyPxzDPPWE0FEecZvhE4VeLqUhBC7GV30NfpdE4rRHFxMUJCQuDv72/YxjAMoqKiUFAgbj3Mzs7Gr7/+iri4OFy4cAF79uzBTz/9hHfffVfy2BqNBmq1WvTjadxtwrWTxa4uASHEXnYH/aioKPTq1QvTpk3D8uXLsXXrVly7ds2uYzEWohrLslAoxEMJVCoVhg8fjnnz5iE4OBhpaWl45plnsHHjRsljLF26FOHh4Yaf5ORku8pIjIJodAchHsvur29xcTFycnJw9OhRPPXUUxg4cCBOnToFtVqNrl27Yt++fTYfKzY2FhUVFaitrTXU9nU6HVQqFeLi4kT7BgYGIiYmRrQtISEBKpVK8tgZGRmYN2+e4blarabA76BACvqEeCy7a/pyuRzdu3fH1KlTERERgV9++QWXL19Gbm4u/vWvfzXqWG3btkVUVBQyMzMN27KysgAAbdq0Ee3bu3dv7N27V7Tt3LlzSElJkTy2UqlEWFiY6Ic4xl/e8D6EEPfklIZcYXomKCgIvXv3bvT7Z8+ejQULFuD69evIz8/H/PnzMXXqVAQEBGD8+PFYu3YtAGDSpEkoLy/HCy+8gMrKSvz1119YtWoVHnvsMWd8FGIDncv7exFC7GX3jfrLL7+Mnj17Ii0tzSkFWbRoEUpLS5GWloba2lpMnDgRK1euBABcuXIFxcVc62FISAi2b9+O2bNnIzo6GrGxsViwYAHuu+8+p5TDnblLrP3tGjCUum0S4pHs7qf/7rvvIjs7G9nZ2Th9+jQ6deqELl26oGvXrujSpQvuuusuZ5fVKTyxn/7Pl4C7NgP94oCDLu6nDwCvDwAW9m3+chBCHGd3Tf/ZZ58VPb906ZLhIvDdd9+5bdD3RG7WYxOhfq4uASHEXjYH/QEDBqBPnz6Gn+7du4tGyrZp0wZt2rTB+PHjm6SgxH08sxd4uqerS0EIsYfNQb93797IzMzE2rVrodFooFQqkZqaikGDBuH+++9H//79m7KchBBCnMDm3jsffvghDhw4ALVajSNHjuD9999Heno6fvnlFwwaNAgzZsyAG0zjQ5pAiEk6hwZnEeK5Gv31VSgUSEtLQ1pamqGb5I4dO/DQQw9h0KBB1HXSC8lNGhVGJrmmHIQQxzmln/7o0aOxZMkSfPTRR844HLHAXW6kKutcXQJCiL2cNsvmgAEDcP78eWcdjrix3bmuLgEhxF42B/0PPvgAf//9NzQajeTrRUVF8POjvnxNwd26bBJCPJfNOf2FCxdCrVZDoVCga9euSE9PR3p6Orp164aKigpkZGRg6NChTVlW4iJ8VmlaZ2D9ae5xTR0QQA26hHgcm7+2KpUKFy5cQGZmpuFnw4YNKC0tBQB07twZb7/9dlOVk7iB+zsYg341BX1CPFKjvrbt2rVDu3btMGWKcS6A3NxcaLVas9kwiffpEGF8XFPvsmIQQhzgcF0tKYn67/mSYD+gUsuldwghnsct1sgltnFVj01hV9EA/cwbVNMnxDNR0Cc2YxhApe+8RUGfEM9EQd8DuNPC6PwCKocLrO9HCHFPTg36MpkMI0eOFC17SLxTmL+rS0AIsYdTg/5nn32GoUOHYs6cOc48LHExYVvCwJbcv0paJ5cQj+TUntbTp08HALzyyivOPCxxEwwAhb6aUOcm8wARQhrH7pr+F198gfXr1zuzLKQB7hBnj93k/v30pGvLQQixj901/XfeeQe7d+822/7VV1+hrq4OjzzyiEMFI+6pXMv9++tV15aDEGIfu2v6MpkMkZGRZtvvuusuvPvuuw4VirgXd7jDIIQ4h0NBX6VSmW0PDQ2lFbSczI16bGJxP1eXgBDiCLuD/ty5c3H33XejoEDcYbukpMThQhH3xAC4Sz/FUnSAS4tCCLGT3Tn96dOnQ6PRIDU1FSNHjkTPnj2h0+nw9ddfY968ec4sI3Ej/vqumjJ3uv0ghNjMoX76s2bNwpkzZzBmzBjcvHkTNTU1+OSTT2idXC8jzNb56/9iamkaBkI8ks01/QEDBqBPnz6Gn+7du0MulyMyMhKPPvpoU5aR6LlDUwk/KKus1rXlIITYx+ag37t3b2RmZmLt2rXQaDRQKpVITU3FoEGDcP/996N///5NWU7iBhgGCBGsiHm1HGgV6rryEEIaz+b0zocffogDBw5ArVbjyJEjeP/995Geno5ffvkFgwYNwowZM6jXThNxpwnXogQNuFfUrisHIcQ+jc7pKxQKpKWl4bHHHsMHH3yAM2fOYNu2bfjpp5+wdu1auwui0Wgwa9YsxMTEIDo6GnPmzIFWq23wPX369EF6errd5yUNE17KGQZIjeYe1+pcUhxCiAOcMuHa6NGjsWTJEnz00Ud2HyMjIwM5OTnIyspCdnY2zpw5g4ULF1p9z9NPP434+Hi7z0nsE6RPClbR6lnEnekqgPzbAPVqV5fErThtls0BAwbg/Pnzdr1Xp9Ph008/xbJly5CYmIj4+Hi88847+Oijj1BfL91N5KuvvkJhYaFhkjfS9PgsUyAf9K3fiBFPxda7R68BR1X9BNTsAEqe8o7P4yQ2B/0PPvgAf//9NzQajeTrRUVF8PPzk3ytIefPn0dlZaUoTdOjRw9otVqcOnXKbP9Tp05h+fLlNqWTNBoN1Gq16Ic4hq/pV1O3Te/DaoDrnYCCMa4uieNkIcbHukLXlcPN2Nx7Z+HChVCr1VAoFOjatSvS09ORnp6Obt26oaKiAhkZGRg6dKhdhSguLkZISAj8/Y0rczAMg6ioKBQUFCA1NdWwvbKyEg8//DDWrl2L8PDwBo+9dOlSvPrqq3aVy924S12lwZq+rgpgAgCGFmbzONrTQN0F7qe+BJBHubpEHLYeqP4VUPYF5LG2vUdXbnxcexIIjGuasnkYm4O+SqXChQsXkJmZafjZsGEDSktLAQCdO3fG22+/bVchGAvdU1iWhUIhLuITTzyBmTNnonfv3jYdOyMjQzRCWK1WIzk52a5y+irTO2OrOf2qn4HCu7jHyQWAvIX1g9erANQD8hhHi0mcQf2+8bH2DCAfaH3/uqtAyTwg7Bkg4JamK1feYKD2IPc4xcbqT9HDxsd1l51eJE/VqGkY2rVrh3bt2mHKlCmGbbm5udBqtWjTpo3dhYiNjUVFRQVqa2sNtX2dTgeVSoW4OOPV+erVq/jyyy/x888/IyMjAwCg1Wqh0WgQERGBzZs345ZbxH94SqUSSqXS7rK5A3fpsclfm4P0Wbxq06DP6owBHwAKpwDxeywfkNUCN1KB+htAqwpAFuTM4noWlnV+39zqXYAsElD2sv09FeuMj+vOArAS9HUVQG5r7nHVBtuDsT34gG8rXZn4eR3NBc5zeOWspKQkhwvRtm1bREVFITMzEwMHcn9kWVlZACC6mCQkJODSpUui9/7www9Yv349fvrpJ7Rs2dLhspCGBVqq6Vd+J36u+d36gXQVQP11/b5/AYGjnFK+BrEsoNkH+PcAZA2nCJu+PDogrz/AKIGWfzgnLVZfBBTof5+tawHG1vY2wX+q9oL1Xat/FT9ndc2T0mNrAaaBRZorN4mf11PQ57lF0pVhGMyePRsLFizA9evXkZ+fj/nz52Pq1KkICAjA+PHjsXbtWigUCqSkpIh+YmJi4O/vj5SUFAQE0NSPzcFieqfogcYdSHva+Lg206EyNUrV90D+UCBvmPOPXV8KXGa4n/pi296jKwZqDwOa/UDx/zmnHDpBhwXh77kx6vP0x6oAiucCmkMm5zCZWr38Y/vO02A5TH6P+SMBzbEG3pMrfl75X8s9eMre5f6/yj+xu4iexC2CPgAsWrQIvXr1QlpaGjp27IiEhASsXLkSAHDlyhUUF9v4BSJOZ/pVMfTe4YM+y3JfmsYq/9D4uOwd7stda95by+mq/sf9q81y7nFZDXDTmPpE2Ru2vU+YUqloZOC0FMi0OcbHtSdsO5bOpGdb/Q3u36uhQPkHQJ7JYgrFM8XPKz+37TyNxZpM9KTZD+Q1kLIqXWRyjGqg8gvpfVX6Nr/if9hXPg/jNkFfoVBg1apVKCoqglqtxvr16xESwnW5On78OP75z39Kvm/69Ok4fPhwcxbVZ5n10zcEfTu7wVZ+aXysKwSuxQA3ugFVv9hbRBvP+43xMSvdBdkuN/pz/cJ56neBuisNv6/cZFCjrWVSfwRckXEX3Ort4tcK7zQ+trWmX/qm+Dlf0zdl6UKjOSp+XncVUH8A6KptO79FTuobXCSxhKv2kvk2L+c2QZ80zF3GlwSZdtms+dPyzqwdX1jVC7btx7JA3TXHfjFa+wYUmpdFK33nkJvS8HtNg2tdrvR+pkpmGx8XjLH8u66/ZtvxqjaYlOOG+T7ai0BuItdIb8bkYpXbGiiZa6xJS7Hl/870ouhM+UPEz03vKrwQBX3SaHxNX6UBUJsNFI4T7xDxKgz3BfU3pQ9i7cuutTEdoV4B5LYCytfYtr8UW2ritrAlH6wrB/IGAqUm40aYQJMy2dnoWK9fxY41GUBRsY5rZLX63hKgzuQCqCsEdJXibaoM7iJV9b35MZSCcTrCu5XyfwPXu5pflFiW+/+7zAAaK206ZW9afq0hik7WX+c7EhieF0jv50Uo6HsAV8+yaRqf2+k7vGQXgxvEYyp8ISDTD+rRWWiLqTtn/aRV26y/rqsGVAu4xyUNNH6yrDEIaS+LX6s9ara7XUwbNaWoFgGaA0DpK+LtASa9loqm2lcGPoBJpYcqv7X+3psPmmyQA2DNa/9VJj20hNga4+Oyd8WvaXOAyq9Mtp02NrjmWZg00doFUFfB/cMCecJrU/7txsem40QaCur1+dZf9wIU9InN+ItPnL47vaYe5jXl1rVctz2ZfipOXZH0wXRV1k9W9rr110uelN5eewJQfwjkjwBUL3GpkuLHgatRXFlNa6il1if1s5kw4Emp2gKUrzI+FzaamtbMhbXP2myg5oBtZajZoz9epflrDeX1a0y6X/J5dKk8uKmQGfq36ANq5SagNMN8v1qT9NeNriZllEi1VZhMtRJwq6CIXIB+8Fcg4TNgJ399EH6WiNfEF9WbgguqcMSu4ZgW2jG8CAV90mh++r8arQ7iRlHA2B+cvxhUmLxuoK+NymKAxLMSL1tpJ6hXARX/kX7tRg+gZA4XAMveBHKTucDBVgGF9wJl9o0at0pXDZQtMT73SzPfR9iwCgD5guAldbfB6oDyz7jBa/kDbUv5qJ7n/pVqY6m7aP29ygZG3loTps/Z6wqAunzg5j3S+9VmWz+OVKpNJhyprQRa7gAUKfr9ubuEb/U3jW8fhfltqV9nIHSW8bmwob3wXuNjPg1ka3uKB6OgTxqND/oMagHN39yTgDFA3E7BXvqgXmEh316tT9/oigC/DkCwaXoBXK6XlZjrQTXffBvLNtwoWHtIeuItSw2gdXncTI0NHdc0L5x4DIg/on8ikz5+7SFjDZ8fOCQTzClT+jJ3h8LTmIxItdbrRBYpUUYLbSs8v87Gx8HTrO9rSqEfoMnWcP3hLe6XYHyskehxVy/RcFzzh/Fx/D7uX35KhYLbRLsG+wGAyV2ToiWgaCtdHuEdgVz/OyuZI72vF6GgTxpkGvIU+r+aYHkZAH0DYdwvDY6oza/UtwMA5imN2K+AxDPmb+JTFkJStXxWDWj+MN9uC6lgo1MDuQlA4YSGG4rVgvw1X8v3TwXXmK2znOKq3ADUCS4Yfl2Mj037+Jd/Kn5uNV2jv1D6pQJy/XoTfu0t7157WpxGCZtr5dgmIlcATAi4NgAAqmct7yu8+OX1NX+9aBp3Z1ghuHAI2xCUpnl/8d+QuhbihueW+r8HZR/LZeLxlRcfQEHfg7i6xybfnszX9P0Y/ksnb3D4fV4lEP8ZkPo1kFMCY7pCOci4k6KD+RtrdnNB6TIDFE7Wn05iwrz6fKB4tvl2WxTNED9n64GrgukZGmooFg4yi9QHa0YBw/9Y8ZOAUmIysvprQMFY4/OIVyyfo8akH76wx0/gBONjViuYXEwLhOlTPvUmFx5dBdf9EgCKpotfU/YF4nbAqtA53HxJ4f/UN/bYsIxa5RdAzT7rF9GiB7mR3fW2TYV8ubTC8HjnNQBVPxpf9BcEe6VJ10xTwvRWQz2dPBwFfdJofE3fT6YP+lLzusSs078WgjcPAX0EnUd+uQxj90BhrpphuEAiVPYmcENfA+Z7kkj1O9eeBbSNGM0rDJSmAVVXavtxAIARXCCC7jB/vep76TaKulxx91S/BroXCnse8WkqeSsgVjDIrb7YOFJWe9rYe6XmV2O/e10FN8r2ejtuOgPhZGbh+pGs/g0sQRo2D5AFG58zFqZAScoFlAOMz/OHAMVPWD82YLwg8WTSs7X+etHkLk0muBgygokWY782PjbtRKDoyKUYDa+XNlw+D0ZB3wO4yyybvEA5V9s31vQlgr4ftwZCLRuGlw6Iu9T9cz8AhX52xpDHxO+TBcPqJxbOwyLsgy2c3dMWcmtzq0vcU1kbZMaWWX7NQF97jBL04DHrHtjAQDbhxYnvVVN/lVsshG/w1Jnk7vm553Wl3KAqgJtSgad+T7x/iP648gjxdn+TdIyfSZ6ctTDqVpEIRDeQHov9wXxb/XVxqiZaMOVzkLEB9q88k9/9zfuNjxm58bE80fi45jfuX76HWYuNQKDgYm0pHeclKOiTBpmGQD85MDge8JfpRy9K1fRlEdxLrHT/dbZW32NHFmr+YotN5tt41wS9ORqa/qHF/yy/Zi1vLdXP3ZZ0Q+DYhvfx722sFSsSxa/xQciSyo1co3Lp6+ZdRPn1CEzTOMLGYUA/w6igC6jZfDmC/21hbT9Q0Ggaa6WvvhB/1ybqgWMi8Qzg39N8e30eN8cOj68kAEDkW4aHuWpj0O9pbUkG4WAXvoLAtysx/kDQJOPrtSetHMjzUdAndokPFqZ3JKa51fcg8WOq4S8zD6KMVt+7pWaX+XsD72o4vQBwOfCQGdKvxf6XO06Q1HQBAOAnnWcHgOqt5tsK7wZUL4s2/ZUH9P9OECRDTdoUoiWW82T8gQj9GATTC4ksCAi20i++5lcuEJa+bP4aH9xNG6VNV75iy40TzkkRTkMgvBtigrlUTasyIPhe8/dJ4dM/cisXM1mE9AI6pndBwj71fsbp1sMUxgv/saJGtHqVrzFWGhh/8UXBUpdTL0FBn9hMmHTxkwFKQzCXqumHG94RoSi1fNBAibVYGUacp7ZYoEAgYLj5dv/eQPB93HFafAskS4yy9OsIhDxqePrrZQ2Y1cA/dsFwlyJSe5AbMKY5CpQuAS4z+MevJ5CnFrQvmF5Egkz65nMnNubZhSNUk/R91COXiHcPNbkjMe31xOPTOMLVogLHmnfftDb4yK+LuAeRcK0BXRl3ZyILs/x+S4S5dVNsHcBIHLP8I3E/+gCTabADud9tlH+JYdPIGEEFQurvQkjUrmDf2t6eioK+B3GXCdcAwF8GtFTqg6lUfpyRGb7Mkf7mKZ466GuBgVKBEeZpCcl9oqVTIi02i59bKl+IsVb9yHaujJ+cBFj+ayHsWcSrO2uYtvf3QcPACNMhpnlwmUktG+BSYVKNknzXSkUSELnMuD3wdvF+wimTASBIXyuV+j2EzdN3pxS43tl8P17iKXGNV9ZAA7VQpMmgN3lr8fNYibl6AO5iJTXPiK5EnL5jTNZ70v9uI/2Mf1vvdxdcIE3LY01DC7J4GQr6pEFSFxt/ORAo1zfeyULMdwAMA16EX0yeDFZSQ4B0bduUso95aqDFT4AiXqIsEquqMXJD8Gjhb0y1nCzi2yokaqiCuemj/FXGdg0pjAyG/us8tko6nSFsFwl92vg4YBQQ9Z7haXWlSS8gPtcu9fvSlTk2cZPwQhLQQJfHsHnGuxUACDcZQBc8Wfp9tqzoJdUzSH8HE+VnrOl3CRWMXfBPNX9PuMTUEIDx/yNYsAhQ5Qbpfb0ABX0P4G69dwAu6AfI9I2Jlrrr6b+YEX6lJi+wkIEPrBaCvmm//6D7zPdh681ruEHjpY8X95uFMnJB//jwNIyK4UYUt9fpg27tMfOxA2VLRU8fT7YwHQQvOR/wE8wxI0+WHjErKlMAt95sCss9DuZ6pOhYBhmZJm0dgfpGSaljNpTiEFJKrCIW9iygaAOESYyANsUwgKIVkHgBiP4MCJVYkMTfZOGToIm2lU1qXiMrFQquPBJ/V5bacHjCHko3LVykvAAFfWIzYaUxxE+Q07cY9CMAmH8xFYxwagUr+V6+UdO/F9Div0C8yVQE8pbStWYp/oLAq2hnfCyYTnjnwNGYnrwWAYy+1q9TAYmm0zyLB+680OEtWCWPAWI+E5w7vuGgb0p/YZIxLN7rbjriVf+fIlXTNzSgWvkd84LvN98mj+KCeNRyW0vKdeUMfVS6Bm8Y8KXgLmjWemk1RP87eSJlDSIFtX3r74lo4PVG/r94KAr6xC6tQ4G2QdwAGh2CJffhc+O3xYoHP8X4C7oVWsunxnwGJF4EEvQ9fUzz/IxMnLNOamCyLL5LpVQtVG9tT5NxA9YaIW2l7M/daSTqLzCNXYzdWgqEvyNiTWaMjBNMTZ2cD53/YPP3BtwKRL4DxG0HQmeavw44d15vebT+DkaiMTriNSvvSzTfJgjQ89utQEKAYDqLUAvz50gFdeGdnC0pRS9AQZ80SKr9eHJ7oF0wN5d+sU5iVkkAjH4QzPRkcV/w/pGCGru1oMrIRN3zDD1URPswXLBPPG/e791U7A9Ay9+BsOes78ez1r+8sQJHAn76OwzGJM9v2tWzMfieQKYLsQhHlcojUMyYNAgDQORyIHweEDjavEzNLWIRl0qSIpwlkycI4IOi/kSIXDCSWylxgQOkg3qQYFBf4IiGy+kFFA3vQoi5CCUQ4c815FbpJHqpWDA4ah/+1/du44bGBBtGcEfR8nfj44aCPU8WBAQMbXg/XiPSDyWBy2D7b8GEVC8hW0T/2/jYtKHaZCrmap1JLVfRHlA2sLh4c0s8beyfnyvo/WM6GhgAy4QZ2rq6hJwW3z2a9njimQb9sOe5i43h9UbegXkoqul7EFf32DS90Q9R6IN+fZBN7+/bAljda7UDBdDPzZNc1LjgbY2lLqMAEKBv+IvdAMB6tz51ncTIYluZ9kG3RcxX4hqw6QpRfFdOvSpdhOFxTkWa9BoGrsb4c43BcpPeVxJjOVS1xr79VWwspiQIRgnLLeTmZSZ3Q1Fvmfc8a7lXXxaTfb0IBX1itwgFNwS+rFY6py+U99BB7L27BCX1Vqb4tYUs2PoIz0YqCPoCW4Xz1ksJvgf1rSSmZhC4VHTc/kLw89E3Roh4/YE6v6H4rcQ4+rigRjzgSV1nDIQyBq5fg9Ma0zYMibIKL7LXa3sjPdbC3D+NZbjguDjd1YQo6HsAV38/LQ0KC9UPgS+vl05srLtmHPzUUj0AyvyukOscW3j6RgWQadusuza5e1sEnji6yGz7Y8f+Y/jc/zkJKD4Qv/5jvniCt1L/BqZftuKsDcvr/looXjDkvWPi1/dcZ3Dr/m9xX+Z/8eixz1BaJ27/UNUagySDOm6pSzclLNui069BJ/H3p643XtTq6m5icGjDC9ML/44PqvpJ7nNJzX3ZXH1X3ZQo6BO7hSq4aFVRLz0466XTJguB6AowPNzYr/1MRcdGnY9lgcS1QPq3wCaJ9djt8Vc+UFxrfuew9tpj+Fm/ONUM/ej+JWdfAgDMPbEaH18R9wC6WNG46Qn+e9047uCgDdfBNVfEjZnP7gXeOGR8Xqzvyv7djfuw7tqj2Gjy+ympNf4fzcpajYAP4XZUNcDBfOBCGfDQkS/xRe7DWH7heWyQWDq3VPB/Nixqm+i1AgvLL1fXAS/mvIHj6lSMPbgVk38Bik1uEEb9j/u3qs57wz4FfWIz0R1HfSHCFVzjWUG1dNCXCqZCLfwLUdeI9SrKBT397vnF+PhEEXBAYnods/JUA9+eBWpMVmCsrJdOT03YIn7+ytlX0G/vQXx4eTaKasU9e1Yea9xQ/kePrcW7F5/BkP1/YM/1hvcv0ZrfTS0UTJaZbxLoOkWInxcLUnAHS/sDAPbacN7mwrJA1CfAgO+Bbl8BX19/CNOOfoFandK42ppAmZbB3BPS7UM7LCwnrNIAS8+/iLTfj0OljcKGC8CLfxlfL6wCWJYxlMdbUdAn9tEPU79UlYI/CqXXIB2eZGHQll6xNtpqmqGmDth3A4YLw02JtC3LAj2+AQZ+DxxqoMZ86/+A+38FXjlo+oo4f5ZV1kPy/fWsAodK+4GFzCwI1+qsB/2vzgCH9eWr0wE1ukDMO/ku9pUMwWc2rP1ytbqV5Pb8Sr5s4u3+gpT0tXLg3ex2OFLWC/tLBqG6nmukfHovMG07sC4HLk/3PGZhwDQALD9ivk1VI92BIL8mDr9ZGK5RKtEs84tg5oh9gglKGS9O8FDQJw2S/POv575ZmwvuRFWd9J9RQ4FkSuZ3qLWyz7CNwJANgJ8+n37FZPr8Op1+XVS9fg1M835M36tvQwOpoYVnjDNdqi1MraPSinuI1LGWez//dg14eDvQV18+qeBjTW09cKlK+sLK330FmLQ7jhfMOddqHXBRLUf6H4cxZP9e8Be5ozeBL84Aj+4E3j0qfe6aOufVenMrAGY192N6zHU50u8BgBqJvxGVBmZ3WwCwIW+SxWNJ/d5zBd37S2sBVv+7YRgK+k1Oo9Fg1qxZiImJQXR0NObMmQOt1nzkXkVFBTIyMtC2bVsEBASgR48e2Lx5s8QRvY9b/RnqVzVS14VJfikB7otpyeB9+3G0rDdqraR3/hbU3Lt9Zcy38gqrgCKJaVkkjyVI/5wXLLbUViIV3yGMu6VoFQqEmyz6FKzvWFKqjRBtL9VKdxO8VMbdYfCuqK3/XqSU6D/jexefAQAM/3O34TX+LkjqmMKABnAjpFkLX/nvJPLmuRVA2BrgkQaWyxU6dhNYcojLn5saLFggS/Y+0ONr831spdIAl6rMB3O9kLNMYm/je6we08a/JU/nNkE/IyMDOTk5yMrKQnZ2Ns6cOYOFCxea7bdt2zbk5eVhx44dUKlUeO655zB58mRcuXJF4qjEmcRJEK4KrNX52RX068GlfizV9OtNLganJKZXkcvMG+I+yZY+3tCN0ttLJMo4rh238LrUBeEF/Vrb9VZq9kJt14uf36xuOLiU1xprxJVa4N1j3PZnT76Lh07X4Pfi4YZ9vz3H/StVi20o3SV09Kb5tvezAK2OuxtoqLZfp+PaVXr9F1h0wLx3EQBcNZkp4oRErt5WJTVAdrl4Js2bmhhU1HO9lKQuOlsbCBG7rwtq+u5VxXIqtwj6Op0On376KZYtW4bExETEx8fjnXfewUcffYT6enFUmDx5MtatW4d27dohMDAQjzzyCFJSUnDgwAELR/d8btmjWr/CUq3OH+UWUiDW0hj8JGyWUkBSwdjU3hvmNf1/7AbOl5rva3oelgW09dJlLJcNBABUSEwR06URc3KZXrgAQCmXbpsQNi4vEfTK2XFVnNO+tZV42orf9Y2xUhfYQAXMujv6NeIbXyb4f/3lsvV9F+zn2lV475iki4SfSUgqONtC6vPGKo2jcg9LXPA+NJ07T4/v7bPlsjHoezO3CPrnz59HZWUl0tON08b26NEDWq0Wp05Zb+XS6XQoKSlBfLzEHOrg0kZqtVr0Q5xAv4KTlvVDoUQQq9dZzocDwF8lXJWZr6maKrJhrI2ONXZVFBppMntClkQttp4F3heMp9K20M9TH/EGtPpgfVhiPEDXKODL24BuUYAO3K3AtWpucFWJSVmkyqbVATcltvMppzMqcZD/30Xxfq1MBv7+dMnyuV4/BLML8tmp5vvxTHPtwqC/z8qCWwCw8pj4uWl5Flmok6lqzC9MANA5EugQYXxu2uPK9Hdtavbv1l8XkupBRjX9JlZcXIyQkBD4+xt7QDAMg6ioKBQUWL9H/eyzz9CyZUsMHiw9ydLSpUsRHh5u+ElOTnZq2X2XsaavlfjS8DXoelb6T4zvJvm3xH+vjgW6fmW+3dSNShj60gtdq+D6sOtYoO+3QM//mu9zrhT4XpDH9gsayM0AGfGiWYABgEe7AB8OB7pEAQ91ArIfAmQJ+4GgibjjINe3c5tJ+uA/EvUVrY5riwCAqZ2M21P1+e1X/xbv//lp8fMwC52E+LuH7wTTzvyZZ14jjrHeoUqUchHeBUUouRSQaYrGFtZq83IZUCZRa7+3PbBGMP/ZH4KeNSwr7nUjRaqbp9Bmwewbwr9fvsumN3OLoM9YGHLKsiwUCsu507179+Lll1/Gf//7X8jl0sOmMzIyUFZWZvi5du2a5H6kYaL/Jv2EXpX1wdJBX19LnJP9qeSxhiRw/1+3JJi/9sVp821Slh8RB26hhQeAD49L19YBoKqOG5gl5TaJ3pFLBwH/Z7oYk393oMUmnCjnungK7xwAcR9wnlYHLNDfVMSaTO+irgW+sTIlzgMdgfQWwH9Gmb/GB/0WJr0YTWvEwX7AfYLZhFNM2i2CBF+3G5XGx0XVQO//Aq3XAR/YOOME394idRfCK7DQGB8fLE6PRQqyWqctjWD272NTuRgAd7QxXkC1OvO7Deq908RiY2NRUVGB2lrj/aROp4NKpUJcnMT6pgAOHz6M++67D99//z26du0quQ8AKJVKhIWFiX6Ig9haQMPdr/92cxS0Ul3q9F/k89XmMyQCQISS+9MrlBg9OX2n5VNrBLMQKwQXIdMACgBP/mH5OP/KsvyaQuJbIXV8U5YuIkJ/CAZEXTXpXWMtHQYAo5K4C+9jXc3TPHzQN63Jm7YfMAwwVHChHWVl2p8swcSVwhG+c21MncR8Kl0GobRvxP3jefFBwBDB5KknBQ35s4ydl1AmE0xPUZtp8TzCtNUu/SSvfPuGutbYZZRy+s2kbdu2iIqKQmam8T8tK4v7VrZpY94t6/Dhw5g4cSK+/vpri2kdb+Q2owTZGvArSOVp4iW7XfJTC+wp7M4tn+cvmOskapWhoda0pt5QzxbRoCNB0PzqNvN9rbFW+5T62susxAJhoLX0f8TXKl8S5LZbmQxkbijc3Cn4Kryvn5gzOoCrUfNpHNOLEx9wO0cC5fqZHB7vZnz9RZPVF/kGWNNeURdNmsJMe/sEWrghP1cKjP9Z+jWe1MCshGCu0Zs3Q7DPXsFFQut/q+h93wgm5BTm6i8IuukO0M9Czf8NDP4B2GMyoIty+k2MYRjMnj0bCxYswPXr15Gfn4/58+dj6tSpCAgIwPjx47F27VoAXMC/++678c0332D48OGuLbgPkAxirLFbSx2rkEzv8LXBehbc8nlxW40vBk00dIdsIQhS/FB8oaUDgWuPco8X9Ob+Na3lAlyaQiotY8mWy8bHD3USvxbVQN7blDA9IZWaerYn1/BrKiEYGC1oYjom0eAsFCdI3fAXkeIa4C7BdBFRAcbA1z0ahkb2XrFAiP49SjlQNwcomwW0DQfuSDG+/9/6Lq+7G5iiYXkmcLrEmIKRagcBgI5fANcFaaIzDwM/3mH92IC4ERcwH3HMC458RPRcuJuwx9Y4wYUnwOQCpakHzpTy76cum81m0aJF6NWrF9LS0tCxY0ckJCRg5cqVAIArV66guJhrmXn++eeRm5uLoUOHgmEYw483XwBcPcsmz1gM4ze8npVDx0p3TxSRRwGta7iFwhWtkKCfCuaQIOeeI5GrHRQPJIUA7JPAMv1NnVRjYnwQ8Gp/Gz+IiXdM1stmGKB+rvG5sHFUCn8xAoCl+ptVYcrrxXTp1E+7cOD7scbnr1no1ggA95uszy7slfOnoGeNQma882AAzN/PPY42uZDJZcYLx4fDxa/tuArcuxVW/fcc0OUr4IU/uYu1tTsh3vQuQMdI4C7pwcWIDQR2TgR+mwhE2njhDVQK1hEIvBN3phif8nPwsCx3x2GNVIcCb+U2QV+hUGDVqlUoKiqCWq3G+vXrERLC3f8eP34c//znPwEAu3btAsuyZj979uxxYel9jL6mz0IBhf7b3vUr4AcLjaoGjBKQc200pumAtK+5UbdCrUOlG3r/KbHgU4g/0F+6+adBUvl6GQNUPAEcvg+4t4P560Kzuhsfn1ZxjYJ8/3k5Y/nO4a62QLiggTJHkLf+ZKR433tNliFIN1kzRYhvkzhRbGygtNj4Ce7O6TFBs5hUryNL3j7KTYTH18Q/HWl5X+FAvAvTzF9fNRQYlQyMFNz9zBSkon4z6YNhNniOUYhSQnfrJ+UTXhQt4ds5+N47VNMnRIjlavoM44ch+i/L2VJx7TBCH8yEtWCh2/Wr4SUEAyeLgeMSXewuT5euQb5ioUbPMJZzywAwrrV0ashSLTXYD+hjJbjyEk1y8zGfAKN/5B7X62vB/ibftAc6Gs/bSz/1vXAW0ce7Aj8JuhUONrn4tbSybk2ZRINwsvREqAbCmq6lsROW8PnyYD9ggoVavGm52kqsTBgncfHtKkiL8dNZtNb/H35luqCWrtJs8NnVcvPpKHjCXkyX9G0W83pK7+tNKOgTq6TrO3x0UpjVQPkeKHyKQZgvFpLrA96NSqC7xBwsw60sexvsByyU7hSEs1O5PthTO3Fpmar/A57vDbQJAz4fDTzXBMvC+suB94YYn0uNFv11gvi5sNulaYMuwF3AxrcBbjwGnJsqzudb8rG+X/tgiXGKpl0zTTXUr92at/QprbhAICYQ2D9Zej/Tdo14kwtXO4kLgWkff8X7wBV9es/QHhT+IgA/IPIts1ToqRJgyWHj8wcESzh8Mdr4mO8U0CKIJlwjxFyd/j6bCUKiyRc3fA13G8/3jIix0NUxvIHp55c1sFa4pfx9UgjXB3v9bVxaJlABvDWYSyfEBIprd4CxF4yjGpo5c3gS8C/Bsr7COxJ/kyEmwi6V8cFA+wjbysDflZjOuAkAPc0npBSZatKYzcfODWPNdjXD3xnwF6ZB8cC6W83362eSfvt7ivh5a4kL0+MmvbGFDbqGi0bkG0DrcsNC708I0m0v/iW+oAnbL/wkfk980PdmFPQ9iKvrHoavg35gFvy7o4tEr5Rn9hpru5aCfhuJWp1Q/5bWX5cxXM1WztjWG4SvAZrWmNs3UA5bNVSTBrj89D3tzBtOTed/f32AfWXg00ymvVMA7q7BGtMyseB+x3eavG96F9vKYtoj6t723GcXSgox3tFZmh7CdLCZkCiVxxgbRz4SjOQ17WAQoYRVfIqJcvqECLH6foCycHSIAI7cL375I8HEVqa9RmzRO7bhfQBgZneusdVSbxBb2BKsbTG1c8P7BCiADePMR/aajpqVanewBZ/uMB1c9njXhnuAhfib/y7igszvQt4YwP3/LJJIrwl7KAnLsLAv8N1Y6TLsvofrmWXaRVPobQeG4ki1FQmZ3gHFBFJNn7gBV/4ZSvfT1w+jZbhqmFQulmdLVz5THwy3fV+pWm1DhFMNSE2fbA8ZA9wtcfEpeLzh95rO3GmaMrOE7+4Z4sf1MrIU2BtqxOXNNrkYJUiUIyEEyLwfeE3ibiTET/y8eCawcRzwsoX2F1vd37illBtlx0Txc74hWEY5fUIE+Jq+PuiH+duXJpkhyNemtwC0c4CSmcYRk01F2Lgslde11w/jxJ/ppXTr6QneXJPVGW0t0+T2XC25/AnzXka/TTQ+7iqRgpPypEk5+KAvFfwB855SvUzu0KICgLvbOf47lqo4yO2oTGwZb77NPP1INX1CDAw1SUNN3/iNOTdNPGzeFnMEQeaBjlxKwNZBOY7g+9U3lOduLBkDvCdorH3Btvm/RDXZV/pZ3q8xhI2iqdbXpzcwvWvig/3FR7hG6NMPi1//eIT4+RzTCemcxLRh+sGO5mUxtcIkJdQhAhiXIr3vt/rBdz9YSEF5GztujonP0+mDvkxcjf3xDuD2n2w/TGtB7rqvDf3hnWVUMnB+mu1pj8YI9uNq340RqeQuQEo58LKTgr5wPiBr+XJr+KCvlANPppm/HmrSA2tKA4PY7GVaEfh8tPSkeEKmdyfDJAb58aZ0MJa9oFwQ9VnWK68CFPQ9iCsmXJM8pUl6hzemtXg3094apsL8gU4R3NRt/Zo4pWPKWjtEc2MY8UAsZwhXAice5PLs8kbczzMw/p839DsaYzLXUXPFx4YCPgBMNGlfsbdx3BtReoc0nkR6h3dM0JNnrURfbSG5DDj5EHD8gcanhkjDukc3vneSMCXVMcL6vgEKrqH6qTQg64FGF69RHtSnwGy9awkyaVS2NeiL1/bwzsZcCvoewF3uMA3FsFDTB4C0WEA3l0txWFrlSUgus68HDmkawq6nDQV9gGuoXjUU6NHA4C9HfXkbcPR+7sdWPwgGlrWx8eLnJl+1JkVfN9J4rHROn+cuFynSeB0iuBG1HcLFk8G5GsMAPW0cv8ET9vqRmtrawpkEj72zpk9Bn1gl2Y6gs5zeIZ5NIbM8d46nES6iEm3jn6owvcOyrFdWYCjok8azkt4hxF2MbwM80tk4o6stTOv5XhjzKegT2xlqPTr9XLoU9IkbC1AA60Y3vJ+YuKbvjagh14O4xZ8gqwPqznCPGRtaagnxIN5YszdFQZ9YZXah0QlmsFK0N32VEI8myum7RzXL6SjoewC3qn3oBKtcK5p5RBUhzchLszsU9IntuIuPfmksWYTrCkJIk/H+LpsU9EnjsPxCp5TPJ95H2EXTO0M+BX3SALM/fFa/4gc/QIsQL8KAcvqEiFV+w/3LVri2HIQ0NS9N6lPQ9yCu/htkGADqla4tBCFNSNx7xztR0CeEED2GBmcRd+BWXTZl+mWYgqe6thyENDEvjfkU9Il1Zn/4Cv0ag8H3NXtZCGlqDHXZbD4ajQazZs1CTEwMoqOjMWfOHGi1Wsl9jx07hsGDByM4OBidOnXCpk2bmrm0PozvvUMzbBIvRF02m1FGRgZycnKQlZWF7OxsnDlzBgsXLjTbr6amBuPGjcPEiRNRWFiINWvW4PHHH8fx48ddUGrfwgCCGTabYQVzQpod5fSbhU6nw6effoply5YhMTER8fHxeOedd/DRRx+hvr5etO/PP/+MkJAQzJ8/H8HBwRg+fDgeeeQR/Pvf/3ZR6X2MoaZPQZ94H7dqP2sibjG18vnz51FZWYn09HTDth49ekCr1eLUqVNITU01bD969Cj69esnen///v2xYsUKyWNrNBpoNBrDc7VabV8hi58Bqn/SPzGpAYhqBKa1A8df61/P4oZ+itibZ8X7MYL9GCvHYBjb38eYvE91O/c4JA8Ay0+rTEGfeB9GsNyW6lIqil1UL1aHfYnUxIFNcmy3CPrFxcUICQmBv79xaD/DMIiKikJBQYEo6BcXFyM6Olr0/ujoaBQUFEgee+nSpXj11VcdL6SuEKi75Phx7OAPIN4dYix/LZDFAopWLi0KIU1BKVcit6YVkgKuIjnwssvKcbS+psmO7RZBn7GwJhnLslAoFA3uK7UfLyMjA/PmzTM8V6vVSE5ObnwhI14Dwp4WlsRkB8b5rwk+a2EVg3zBzAeszccUP2ftLFvbcMa40Lk8AZAFgxBvI5PJENr6OLJVOS4tR9vILk12bLcI+rGxsaioqEBtba2htq/T6aBSqRAXF2e276VL4hp3UVGR2X48pVIJpdIJKzz7tQfguvnjW/gDLSJcdnpCfEZ4YDjCAwe4uhhNxi0actu2bYuoqChkZmYatmVlZQEA2rRpI9q3X79+OHTokGjbwYMH0aVL010ZCSHEW7hF0GcYBrNnz8aCBQtw/fp15OfnY/78+Zg6dSoCAgIwfvx4rF27FgAwduxY1NfXY8WKFaiqqsLvv/+OtWvXYubMmS7+FIQQ4v7cIugDwKJFi9CrVy+kpaWhY8eOSEhIwMqV3OReV65cQXExt0yfQqHA5s2bsXnzZsTExOCRRx7Be++9h8GDB7uy+IQQ4hEY1ltHIFigVqsRHh6OsrIyhIWFubo4hBDSrNympk8IIaTpUdAnhBAf4hZdNpsTn82ye2QuIYS4qdDQUIvjnng+F/TLy8sBwL4BWoQQ4sZsaav0uYZcnU6HGzdu2HRFFOJH8l67ds3nGoDps/veZ/fVzw149menmr4EmUyGpKQku98fFhbmcX8IzkKf3fc+u69+bsB7Pzs15BJCiA+hoE8IIT6Egr6NlEolFi9e7JzJ2zwMfXbf++y++rkB7//sPteQSwghvoxq+oQQ4kMo6BNCiA+hoE8IIT6Egj4hhPgQCvo20Gg0mDVrFmJiYhAdHY05c+ZAq9W6ulhN4ocffsCgQYMQEhKCuLg4PPfcc6irqwMAlJSUYMqUKQgPD0d8fLxzFpx3QytWrADDMMjOzgbgG587KysLd911FyIjI+Hn54f3338fgPd/9pycHIwZMwbBwcEICQnB2LFjcebMGQDe+72noG+DjIwM5OTkICsrC9nZ2Thz5gwWLlzo6mI5XVlZGdasWYPFixejqKgIu3btwubNm7FixQoAwIwZM8CyLC5evIi9e/di48aN+Oijj1xcaufat28fduzYgaCgIMM2b//cFy5cwB133IF77rkH586dQ3V1NR5//HEA3v/ZJ0yYgPbt2yM3NxdXrlxBYmIi7rvvPgBe/L1niVX19fVsaGgou3//fsO2Y8eOsaGhoWxdXZ0LS9Y8li5dyt5+++1sQUEBK5PJ2NzcXMNr//vf/9guXbq4sHTOVVBQwHbr1o29dOkSGxwczJ44ccInPvfEiRPZb775xmy7t392rVbLMgzDZmdnG7b98ccfbGBgoFd/76mm34Dz58+jsrIS6enphm09evSAVqvFqVOnXFiy5lFUVIT4+HgcO3YM8fHxSExMNLzWv39/nD592iumqdbpdHj44Yfx5ptvIiUlxbDd2z+3RqPBb7/9huDgYPTo0QNBQUEYMmQITp8+7fWfXaFQYMqUKXj99ddRXV2NqqoqvPPOO5g5c6ZXf+8p6DeguLgYISEh8Pf3N2xjGAZRUVEoKChwYcmaXkFBAdavX49Zs2ahuLgY0dHRotejo6PBsiwKCwtdVELnefXVV5GWloa77rpLtN3bP/fFixdRU1ODTz/9FFu2bEFubi46duyISZMmef1nB4DPPvsMfn5+aNWqFdq0aYNevXrh3Xff9ervvc/NstlYlqYpZVkWCoX3/voqKiowYcIEPPvss+jfvz8uXbpktg+rH8zt6b+HHTt2YPfu3di1a5fZa1L//97yuQFApVKBZVmsW7cOkZGRAICVK1ciMjISV65cMdvfmz47AGzfvh1///03li5dikuXLuGTTz5BWloaWrZsKbm/N3zvPbv0zSA2NhYVFRWora01XPV1Oh1UKhXi4uJcXLqmUV1djYkTJ2LAgAHIyMgAwP0eiouLRfsVFRUBgMf/HpYuXYrDhw8jJibGsK2yshKDBg1CYmKiYeEdnrd8bgAIDAyEXC5HRESEYVt4eDiCgoJQX1/vtf/nAHDz5k088MAD2L9/P3r37g0AmDhxIoYNG4atW7d67fee0jsNaNu2LaKiopCZmWnYlpWVBQBo06aNq4rVZKqrqzFhwgR07twZ7777rmF7nz59UFBQgBs3bhi2HTx4EK1bt0ZgYKAriuo0X3/9NU6dOoVjx44ZfgCu++revXu99nMDQOfOnSGTyXDo0CHDtry8PFRWVuLRRx/16s9+4cIFsCyLXr16Gbb17dsXAQEBqKur897vvatakD3Jyy+/zA4ZMoTNzc1l8/Ly2FGjRrEzZ850dbGcrqqqih09ejT79NNPS74+bdo0dvLkyWxRURF74cIFNjU1lX3jjTeat5DNBAB74sQJlmW9/3M/88wzbFpaGnvx4kW2oKCAveeee9jbb7+dZVnv/uxqtZoNDw9nFy5cyJaUlLAqlYp95ZVX2IiICFalUnnt956Cvg20Wi371FNPsdHR0WxoaCg7depUtry83NXFcrrPP/+cBSD5c+nSJba8vJx96KGH2LCwMDYqKop95plnPL77miXCoO/tn7u2tpZ9+umn2ejoaDYkJISdNGkSe/PmTZZlvf+zHzx4kB02bBgbFBTEBgYGskOHDmUPHTrEsqz3fu9pamVCCPEhlNMnhBAfQkGfEEJ8CAV9QgjxIRT0CSHEh1DQJ4QQH0JBnxBCfAgFfUII8SEU9AkhxIdQ0CeEEB9CQZ/4vDVr1hjWhOXdfffd2LhxY7OVobKyEh07dsSBAwcs7qPT6TBw4EBs2rSp2cpFvA8FfeLzdu/ebbZt06ZNuOeee5qtDCtXrkSfPn0wYMAAi/vIZDK89dZbeOaZZ1BbW9tsZSPehYI+8Wn33Xcfvv32Wzz55JNgGAZPPPEEACA9PR3r1q0DAOzZswdDhgzBunXr0KpVKwQHB+PBBx9EQUEBHnzwQYSEhCAhIQEffPCB6Ni///47+vTpg8DAQKSmpmLr1q0Wy/Hxxx8bzg0Ar7/+OpKTkxEYGIiuXbviiy++AAAMHToUCoUC27Ztc/JvgvgMV8/4RoirDRs2jF29erVoW58+fdi1a9eyLMuyu3fvZgMCAtgZM2awKpWKPXHiBNuyZUs2Pj6eXbt2LVteXs7+8MMPrEKhYK9evcqyLMtevHiRjY2NZbdt28ZWVVWxP//8MxsWFsZeuHDB7PyHDx9mIyIiWJ1Ox7Isy+7atYuNiopiT548yVZVVbF///03e/z4ccP+Tz75JPv444830W+DeDuq6RNig5qaGixduhQRERHo3r07xo0bh9atW2P69OkICQnBpEmTkJiYiJMnTwIAPvnkEzz44IMYM2YMAgMDceedd2LAgAGS+fh9+/ahb9++hqUZq6qqoNPpEB4ejsDAQPTt2xepqamG/YcMGYL9+/c3zwcnXoeCPiE2CA8PFy2nGBkZiXbt2on2CQkJQUVFBQDg+PHjWLVqFRiGMfxs375dclHtvLw8JCUlGZ7ffvvtmDZtGlJTU/H000/j8uXLov0TEhJEq1kR0hgU9AmxgdRi2NYWyGZZFkuWLAHLLVRk+Fm+fLnZviUlJQgLCzM8l8vlWLVqFY4cOQK5XI7U1FR8++23htdjY2OhVquh1Wod/FTEF1HQJz5PJpOhvr7eqcfs2rUrDh48aNO+ERERZguQA0BKSgpWrlyJZcuW4fXXXzdsLykpQUhICPz8/JxWXuI7KOgTn5eUlIQdO3agqqoKZWVlTjnmP/7xD/z2229YtWoVSktLUVJSgi1btuDatWtm+8bHxyMvL8/wPDMzEzt27EBpaSlKS0tx+PBhUfonPz8f8fHxTikn8T0U9InPe/HFF5Gfn4/o6Gi89tprTjlmhw4dsH37dnz//fdISEhAmzZt8Pbbb4OVWJ10wIABOHTokCFdo9Pp8PzzzyMxMRGJiYnIy8vDhx9+aNh/3759GDhwoFPKSXwPrZFLiIuxLIvExER88cUXGDVqVIP7d+7cGW+++WazDh4j3oNq+oS4GMMwmDFjhtngLik7d+5ERUUFxo0b1wwlI96Igj4hbuD555/H8ePH8eeff1rcR6fTYf78+Vi1ahUCAgKasXTEm1B6hxBCfAjV9AkhxIdQ0CeEEB9CQZ8QQnwIBX1CCPEhFPQJIcSHUNAnhBAfQkGfEEJ8CAV9QgjxIRT0CSHEh1DQJ4QQH/L/Twvw17ADTY4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "target = 5\n", + "Starting simulation at t=0. s for a duration of 90. s\n", + "4.4498 s (4%) simulated in 1m 0s, estimated 19m 14s remaining.\n", + "9.773 s (10%) simulated in 2m 0s, estimated 16m 25s remaining.\n", + "15.2974 s (16%) simulated in 3m 0s, estimated 14m 39s remaining.\n", + "20.5274 s (22%) simulated in 4m 0s, estimated 13m 32s remaining.\n", + "25.406 s (28%) simulated in 5m 0s, estimated 12m 43s remaining.\n", + "31.1876 s (34%) simulated in 6m 0s, estimated 11m 19s remaining.\n", + "36.4108 s (40%) simulated in 7m 0s, estimated 10m 18s remaining.\n", + "41.3462 s (45%) simulated in 8m 0s, estimated 9m 25s remaining.\n", + "46.5506 s (51%) simulated in 9m 0s, estimated 8m 24s remaining.\n", + "52.3036 s (58%) simulated in 10m 0s, estimated 7m 12s remaining.\n", + "57.8828 s (64%) simulated in 11m 0s, estimated 6m 6s remaining.\n", + "62.94 s (69%) simulated in 12m 0s, estimated 5m 10s remaining.\n", + "68.5966 s (76%) simulated in 13m 0s, estimated 4m 3s remaining.\n", + "73.0966 s (81%) simulated in 14m 0s, estimated 3m 14s remaining.\n", + "78.0586 s (86%) simulated in 15m 0s, estimated 2m 18s remaining.\n", + "83.1278 s (92%) simulated in 16m 0s, estimated 1m 19s remaining.\n", + "88.9238 s (98%) simulated in 17m 0s, estimated 12s remaining.\n", + "90. s (100%) simulated in 17m 12s\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "target = 6\n", + "Starting simulation at t=0. s for a duration of 90. s\n", + "5.1144 s (5%) simulated in 1m 0s, estimated 16m 36s remaining.\n", + "9.712 s (10%) simulated in 2m 0s, estimated 16m 32s remaining.\n", + "14.455 s (16%) simulated in 3m 0s, estimated 15m 41s remaining.\n", + "19.9498 s (22%) simulated in 4m 0s, estimated 14m 3s remaining.\n", + "24.1998 s (26%) simulated in 16h 5m 2s, estimated 1d 19h 43m 59s remaining.\n", + "26.1162 s (29%) simulated in 16h 6m 2s, estimated 1d 15h 23m 4s remaining.\n", + "31.3214 s (34%) simulated in 16h 7m 2s, estimated 1d 6h 11m 41s remaining.\n", + "37.4836 s (41%) simulated in 16h 8m 2s, estimated 22h 36m 16s remaining.\n", + "43.9408 s (48%) simulated in 16h 9m 2s, estimated 16h 55m 45s remaining.\n", + "50.0178 s (55%) simulated in 16h 10m 2s, estimated 12h 55m 25s remaining.\n", + "55.9642 s (62%) simulated in 16h 11m 2s, estimated 9h 50m 33s remaining.\n", + "62.6164 s (69%) simulated in 16h 12m 2s, estimated 7h 5m 6s remaining.\n", + "69.0772 s (76%) simulated in 16h 13m 2s, estimated 4h 54m 43s remaining.\n", + "75.4404 s (83%) simulated in 16h 14m 2s, estimated 3h 7m 59s remaining.\n", + "81.7342 s (90%) simulated in 16h 15m 2s, estimated 1h 38m 36s remaining.\n", + "88.2048 s (98%) simulated in 16h 16m 2s, estimated 19m 52s remaining.\n", + "90. s (100%) simulated in 16h 16m 19s\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "target = 7\n", + "Starting simulation at t=0. s for a duration of 90. s\n", + "5.9782 s (6%) simulated in 1m 0s, estimated 14m 3s remaining.\n", + "11.7324 s (13%) simulated in 2m 0s, estimated 13m 21s remaining.\n", + "18.1968 s (20%) simulated in 3m 0s, estimated 11m 50s remaining.\n", + "24.542 s (27%) simulated in 4m 0s, estimated 10m 40s remaining.\n", + "30.8314 s (34%) simulated in 5m 0s, estimated 9m 36s remaining.\n", + "36.2338 s (40%) simulated in 6m 0s, estimated 8m 54s remaining.\n", + "41.5274 s (46%) simulated in 7m 0s, estimated 8m 10s remaining.\n", + "47.071 s (52%) simulated in 8m 0s, estimated 7m 18s remaining.\n", + "52.6092 s (58%) simulated in 9m 0s, estimated 6m 24s remaining.\n", + "58.5766 s (65%) simulated in 10m 0s, estimated 5m 22s remaining.\n", + "64.5588 s (71%) simulated in 11m 0s, estimated 4m 20s remaining.\n", + "70.0358 s (77%) simulated in 12m 0s, estimated 3m 25s remaining.\n", + "75.246 s (83%) simulated in 13m 0s, estimated 2m 33s remaining.\n", + "80.2564 s (89%) simulated in 14m 0s, estimated 1m 42s remaining.\n", + "85.3954 s (94%) simulated in 15m 0s, estimated 49s remaining.\n", + "90. s (100%) simulated in 15m 51s\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "target = 8\n", + "Starting simulation at t=0. s for a duration of 90. s\n", + "5.0328 s (5%) simulated in 1m 0s, estimated 16m 53s remaining.\n", + "10.5744 s (11%) simulated in 2m 0s, estimated 15m 1s remaining.\n", + "16.7554 s (18%) simulated in 3m 0s, estimated 13m 7s remaining.\n", + "22.6548 s (25%) simulated in 4m 0s, estimated 11m 53s remaining.\n", + "28.6752 s (31%) simulated in 5m 0s, estimated 10m 42s remaining.\n", + "34.5978 s (38%) simulated in 6m 0s, estimated 9m 36s remaining.\n", + "40.5144 s (45%) simulated in 7m 0s, estimated 8m 33s remaining.\n", + "46.0656 s (51%) simulated in 8m 0s, estimated 7m 38s remaining.\n", + "50.7954 s (56%) simulated in 9m 0s, estimated 6m 57s remaining.\n", + "56.2116 s (62%) simulated in 10m 0s, estimated 6m 1s remaining.\n", + "61.4026 s (68%) simulated in 11m 0s, estimated 5m 7s remaining.\n", + "66.1746 s (73%) simulated in 12m 0s, estimated 4m 19s remaining.\n", + "71.09 s (78%) simulated in 13m 0s, estimated 3m 27s remaining.\n", + "76.0992 s (84%) simulated in 14m 0s, estimated 2m 33s remaining.\n", + "80.9006 s (89%) simulated in 15m 0s, estimated 1m 41s remaining.\n", + "86.3298 s (95%) simulated in 16m 0s, estimated 41s remaining.\n", + "90. s (100%) simulated in 16m 39s\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "target = 9\n", + "Starting simulation at t=0. s for a duration of 90. s\n", + "5.8238 s (6%) simulated in 1m 0s, estimated 14m 27s remaining.\n", + "11.3472 s (12%) simulated in 2m 0s, estimated 13m 52s remaining.\n", + "16.8864 s (18%) simulated in 3m 0s, estimated 12m 59s remaining.\n", + "21.5152 s (23%) simulated in 4m 0s, estimated 12m 44s remaining.\n", + "26.759 s (29%) simulated in 5m 0s, estimated 11m 49s remaining.\n", + "32.155 s (35%) simulated in 6m 0s, estimated 10m 48s remaining.\n", + "37.6578 s (41%) simulated in 7m 0s, estimated 9m 44s remaining.\n", + "43.6072 s (48%) simulated in 8m 0s, estimated 8m 31s remaining.\n", + "49.44 s (54%) simulated in 9m 0s, estimated 7m 23s remaining.\n", + "55.1548 s (61%) simulated in 10m 0s, estimated 6m 19s remaining.\n", + "60.9512 s (67%) simulated in 11m 0s, estimated 5m 15s remaining.\n", + "64.6168 s (71%) simulated in 12m 0s, estimated 4m 43s remaining.\n", + "70.8192 s (78%) simulated in 13m 0s, estimated 3m 31s remaining.\n", + "76.9384 s (85%) simulated in 14m 0s, estimated 2m 23s remaining.\n", + "82.9704 s (92%) simulated in 15m 0s, estimated 1m 16s remaining.\n", + "88.5652 s (98%) simulated in 16m 0s, estimated 16s remaining.\n", + "90. s (100%) simulated in 16m 16s\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "target = 10\n", + "Starting simulation at t=0. s for a duration of 90. s\n", + "5.3682 s (5%) simulated in 1m 0s, estimated 15m 46s remaining.\n", + "10.7438 s (11%) simulated in 2m 0s, estimated 14m 45s remaining.\n", + "16.7818 s (18%) simulated in 3m 0s, estimated 13m 5s remaining.\n", + "22.6076 s (25%) simulated in 4m 0s, estimated 11m 55s remaining.\n", + "27.9536 s (31%) simulated in 5m 0s, estimated 11m 6s remaining.\n", + "33.5514 s (37%) simulated in 6m 0s, estimated 10m 6s remaining.\n", + "38.9606 s (43%) simulated in 7m 0s, estimated 9m 10s remaining.\n", + "44.5084 s (49%) simulated in 8m 0s, estimated 8m 11s remaining.\n", + "49.8102 s (55%) simulated in 9m 0s, estimated 7m 16s remaining.\n", + "55.095 s (61%) simulated in 10m 0s, estimated 6m 20s remaining.\n", + "60.182 s (66%) simulated in 11m 0s, estimated 5m 27s remaining.\n", + "65.2698 s (72%) simulated in 12m 0s, estimated 4m 33s remaining.\n", + "70.4748 s (78%) simulated in 13m 0s, estimated 3m 36s remaining.\n", + "75.6062 s (84%) simulated in 14m 0s, estimated 2m 40s remaining.\n", + "80.6512 s (89%) simulated in 15m 0s, estimated 1m 44s remaining.\n", + "86.0184 s (95%) simulated in 16m 0s, estimated 44s remaining.\n", + "90. s (100%) simulated in 16m 44s\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import display\n", + "import pickle\n", + "import os\n", + "\n", + "targets = range(11)\n", + "# targets = [2, 3, 4, 5]\n", + "ctrlr = Controller()\n", + "for target in targets:\n", + " filename = f\"results/results_{target}.pkl\"\n", + " if os.path.exists(filename):\n", + " print(f\"results for target {target} already saved. skipping.\")\n", + " continue\n", + "\n", + " ctrlr = Controller()\n", + " sim.reset()\n", + " sim.set_io_processor(ctrlr)\n", + " ctrlr.target = target\n", + " print(f\"target = {target}\")\n", + " sim.run(ctrlr.timepoints[-1], report_period=60 * b2.second, report=\"text\")\n", + "\n", + " results[target] = (\n", + " ctrlr.t_samp_ms,\n", + " ctrlr.frs,\n", + " ctrlr.UCs,\n", + " ctrlr.UHs,\n", + " )\n", + " with open(filename, \"wb\") as file:\n", + " pickle.dump(results[target], file)\n", + "\n", + " plot_results(*results[target], target)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(spikes.t_ms, spikes.i, marker='.', s=.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for target in targets:\n", + " with open(f\"results/results_{target}.pkl\", \"rb\") as file:\n", + " t_ms, frs, UCs, UHs = pickle.load(file)\n", + " plot_results(t_ms, frs, UCs, UHs, target)" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib import ticker\n", + "\n", + "plt.style.use(\"seaborn-v0_8-paper\")\n", + "figwidth = 3\n", + "fig, axs = plt.subplots(\n", + " 3,\n", + " 1,\n", + " sharex=True,\n", + " figsize=(figwidth, figwidth * 3.2 / 2.7),\n", + " height_ratios=[2.22, 1, 1],\n", + " # layout=\"constrained\",\n", + ")\n", + "rainbow_cycler = plt.cycler(\n", + " color=[\n", + " \"#e56f72\",\n", + " \"#cd0608\",\n", + " \"#fd6b16\",\n", + " \"#fdc803\",\n", + " \"#b8f003\",\n", + " \"#08a605\",\n", + " \"#02a9d7\",\n", + " \"#0169f1\",\n", + " \"#9900d7\",\n", + " \"#5601d5\",\n", + " \"#9b9b9b\",\n", + " ]\n", + ")\n", + "for ax in axs:\n", + " ax.set_prop_cycle(rainbow_cycler)\n", + "\n", + "offset_s = 20\n", + "t_start_s = -8\n", + "lw = 0.5\n", + "for target in targets:\n", + " with open(f\"results/results_{target}.pkl\", \"rb\") as file:\n", + " t_ms, frs, UCs, UHs = pickle.load(file)\n", + " t = np.array(t_ms) / 1000 - offset_s\n", + " axs[0].hlines(\n", + " target,\n", + " ctrlr.timepoints[1] / b2.second - offset_s,\n", + " ctrlr.timepoints[2] / b2.second - offset_s,\n", + " color=\"k\",\n", + " )\n", + " axs[0].plot(t[t >= t_start_s], np.array(frs)[t >= t_start_s], clip_on=False, lw=lw)\n", + " axs[0].set(\n", + " # ylabel=\"Firing rate (Hz/unit)\",\n", + " ylim=[-0.5, 10],\n", + " # yticks=range(0, 11, 1),\n", + " # yticklabels=range(0, 11, 5),\n", + " )\n", + " axs[0].yaxis.set_major_locator(ticker.MultipleLocator(5))\n", + " axs[0].yaxis.set_minor_locator(ticker.MultipleLocator(1))\n", + " axs[1].plot(t, UCs, lw=lw)\n", + " axs[1].set(\n", + " # ylabel=\"$U_C$\",\n", + " ylim=[-0.1, 1],\n", + " yticks=[0, 0.5, 1],\n", + " )\n", + " axs[2].plot(t, UHs, lw=lw)\n", + " axs[2].set(\n", + " # ylabel=\"$U_H$\",\n", + " xlabel=\"Time (sec)\",\n", + " ylim=[-0.1, 1],\n", + " xlim=[t_start_s, max(t)],\n", + " yticks=[0, 0.5, 1],\n", + " xticks=range(0, 70, 10),\n", + " )\n", + " fig.savefig(\"img/fig/optoclamp-frs.png\", dpi=300, bbox_inches=\"tight\", transparent=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# # Retrieve objects from the file\n", + "# with open('data.pkl', 'rb') as file:\n", + "# loaded_data = pickle.load(file)\n", + "# loaded_numbers = pickle.load(file)\n", + "\n", + "# print(loaded_data) # Output: {'name': 'John', 'age': 30}\n", + "# print(loaded_numbers) # Output: [1, 2, 3, 4, 5]" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "cleo12", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/poetry.lock b/poetry.lock index 69806cb..1306b98 100644 --- a/poetry.lock +++ b/poetry.lock @@ -3680,16 +3680,17 @@ test = ["flake8", "isort", "pytest"] [[package]] name = "tklfp" -version = "0.2.0" +version = "0.2.1" description = "A minimal package for computing the kernel LFP approximation from Telenczuk et al., 2020" optional = false -python-versions = ">=3.6" +python-versions = ">=3.9" files = [ - {file = "tklfp-0.2.0-py3-none-any.whl", hash = "sha256:6e81624225cc4fecfbf5e42cb82e8aa800b91b84365e63c66e0e974f06f9c09e"}, - {file = "tklfp-0.2.0.tar.gz", hash = "sha256:d8bbfe1b9778df67ea87d9937820f4177fa1604f12cda02ddad1e6ea5e2526fc"}, + {file = "tklfp-0.2.1-py3-none-any.whl", hash = "sha256:0238f2840b9129bbb83c7cd2e33442f5aae1bc641a68eb659ae235bf5ccf4781"}, + {file = "tklfp-0.2.1.tar.gz", hash = "sha256:2a3a8de3fb7dd9aed60c3d14accf262b9fc625114f532532f75137ea1f48d0c9"}, ] [package.dependencies] +importlib-resources = "*" numpy = "*" scipy = "*" diff --git a/pyproject.toml b/pyproject.toml index b2ee33c..924fb9a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "cleosim" -version = "0.12.4" +version = "0.13.0" description = "Cleo: the Closed-Loop, Electrophysiology, and Optogenetics experiment simulation testbed" authors = [ "Kyle Johnsen ", diff --git a/tests/ioproc/test_processing.py b/tests/ioproc/test_processing.py index ba79f3c..e1d8c94 100644 --- a/tests/ioproc/test_processing.py +++ b/tests/ioproc/test_processing.py @@ -1,10 +1,10 @@ """Tests for cleo/processing/__init__.py""" from typing import Any, Tuple -from brian2 import Network, PoissonGroup, ms, Hz +from brian2 import Hz, Network, PoissonGroup, ms, np from cleo import CLSimulator -from cleo.ioproc import LatencyIOProcessor, ProcessingBlock, ConstantDelay +from cleo.ioproc import ConstantDelay, LatencyIOProcessor, ProcessingBlock class MyProcessingBlock(ProcessingBlock): @@ -62,12 +62,12 @@ def process(self, state_dict: dict, sample_time_ms: float) -> Tuple[dict, float] def _test_LatencyIOProcessor(myLIOP, t, sampling, inputs, outputs): - expected_out = [None if out is None else {"out": out} for out in outputs] + expected_out = [{} if out is None else {"out": out} for out in outputs] for i in range(len(t)): assert myLIOP.is_sampling_now(t[i]) == sampling[i] if myLIOP.is_sampling_now(t[i]): myLIOP.put_state({"in": inputs[i]}, t[i]) - assert myLIOP.get_ctrl_signal(t[i]) == expected_out[i] + assert myLIOP.get_stim_values(t[i]) == expected_out[i] def test_LatencyIOProcessor_fixed_serial(): @@ -130,3 +130,48 @@ def test_no_skip_sampling(): sim.set_io_processor(sc) sim.run(150 * ms) assert sc.count == 150 + + +class WaveformController(LatencyIOProcessor): + def process(self, state_dict, t_ms): + return {"steady": t_ms, "time-varying": t_ms + 1}, t_ms + 3 + + def preprocess_ctrl_signals( + self, latest_ctrl_signals: dict, query_time_ms: float + ) -> dict: + out = {} + # (sample_time_ms+1) * whether query time is even + out["time-varying"] = latest_ctrl_signals.get("time-varying", 0) * int( + query_time_ms % 2 == 0 + ) + return out + + +def test_intersample_waveform(): + ctrlr = WaveformController(sample_period_ms=2) + trange = np.arange(0, 10) + exp_outs = [ + {"time-varying": 0}, # t=0 + {"time-varying": 0}, + {"time-varying": 0}, + # t_query=3, t_sample=0 + {"steady": 0, "time-varying": 0}, + # t_query=4, t_sample=0 + {"time-varying": 1}, + # t_query=5, t_sample=2 + {"steady": 2, "time-varying": 0}, + # t_query=6, t_sample=2 + {"time-varying": 3}, + # t_query=7, t_sample=4 + {"steady": 4, "time-varying": 0}, + # t_query=8, t_sample=4 + {"time-varying": 5}, + # t_query=9, t_sample=6 + {"steady": 6, "time-varying": 0}, + # t_query=10, t_sample=6 + {"time-varying": 7}, + ] + for t, exp_out in zip(trange, exp_outs): + if ctrlr.is_sampling_now(t): + ctrlr.put_state({}, t) + assert ctrlr.get_stim_values(t) == exp_out diff --git a/tests/light/test_light.py b/tests/light/test_light.py index 70424f0..c820eb5 100644 --- a/tests/light/test_light.py +++ b/tests/light/test_light.py @@ -1,9 +1,9 @@ -import pytest -from brian2 import mm, np, asarray, mwatt, mm2, nmeter, um import neo +import pytest import quantities as pq +from brian2 import asarray, mm, mm2, mwatt, nmeter, np, um -from cleo.light import Light, fiber473nm, LightModel, GaussianEllipsoid +from cleo.light import GaussianEllipsoid, Koehler, Light, LightModel, fiber473nm from cleo.utilities import normalize_coords @@ -111,7 +111,9 @@ def test_coords(): assert light.coords.shape == (2, 3) -@pytest.mark.parametrize("light_model", [fiber473nm(), GaussianEllipsoid()]) +@pytest.mark.parametrize( + "light_model", [fiber473nm(), GaussianEllipsoid(), Koehler(1 * mm)] +) @pytest.mark.parametrize( "m, squeeze_coords, squeeze_dir", [ @@ -122,7 +124,7 @@ def test_coords(): (4, False, False), ], ) -@pytest.mark.parametrize("n_points_per_source", [1, 100, 10000]) +@pytest.mark.parametrize("n_points_per_source", [None, 1, 100, 10000]) def test_viz_params( light_model: LightModel, m, @@ -135,25 +137,25 @@ def test_viz_params( light_coords = rand_coords(m, squeeze_coords) light_direction = rand_coords(m, squeeze_dir, False) + if n_points_per_source is None: + kwargs = {} + else: + kwargs = {"n_points_per_source": n_points_per_source} + def check_viz_points(coords): - assert coords.shape[0] <= m * n_points_per_source + if n_points_per_source: + assert coords.shape[0] <= m * n_points_per_source assert coords.shape[-1] == 3 viz_points, _, _ = light_model.viz_params( - light_coords, - light_direction, - 0.5, - n_points_per_source, + light_coords, light_direction, 0.5, **kwargs ) check_viz_points(viz_points) n_to_plot = len(viz_points) for T_threshold in [1e-1, 1e-3, 0]: viz_points, _, _ = light_model.viz_params( - light_coords, - light_direction, - T_threshold, - n_points_per_source, + light_coords, light_direction, T_threshold, **kwargs ) check_viz_points(viz_points) assert len(viz_points) >= n_to_plot diff --git a/tests/opto/test_opsins.py b/tests/opto/test_opsins.py index 7ca57c8..2fca309 100644 --- a/tests/opto/test_opsins.py +++ b/tests/opto/test_opsins.py @@ -1,22 +1,22 @@ import pytest from brian2 import ( - NeuronGroup, Network, + NeuronGroup, + meter, + ms, mV, + mwatt, + namp, + np, pamp, - ms, - meter, second, - np, seed, - namp, - mwatt, ) from brian2.core.base import BrianObjectException -from cleo import CLSimulator -from cleo.opto import chr2_4s, Opsin, ProportionalCurrentOpsin +from cleo import CLSimulator, opto from cleo.coords import assign_coords_grid_rect_prism +from cleo.opto import Opsin, ProportionalCurrentOpsin, chr2_4s model = """ dv/dt = (-(v - -70*mV) + 100*Mohm*Iopto) / (10*ms) : volt @@ -121,36 +121,62 @@ def test_v_and_Iopto_in_model(opsin, opsin2): @pytest.mark.slow -def test_markov_opsin_model(opsin, neurons): +@pytest.mark.parametrize( + "opsin, is_exc, stim_gain, rest_state, active_states", + [ + (chr2_4s(), True, 0.5, "C1", ("O1", "O2", "C2")), + (opto.chr2_b4s(), True, 1, "C1", ("O1", "O2", "C2")), + (opto.chrimson_4s(), True, 8, "C1", ("O1", "O2", "C2")), + (opto.vfchrimson_4s(), True, 0.7, "C1", ("O1", "O2", "C2")), + (opto.gtacr2_4s(), True, 8, "C1", ("O1", "O2", "C2")), + (opto.enphr3_3s(), False, 0.5, "P0", ("P4", "P6")), + ], +) +def test_markov_opsin_model( + opsin, neurons, is_exc, stim_gain, rest_state, active_states +): + """stim_gain is a multiplier for the stimulation strength, i.e., + to accelerate slower opsins. + + GtACR2 is listed as excitatory in this test since its reversal potential is + -69.5, slightly above the resting potential of -70 mV.""" sim = CLSimulator(Network(neurons)) sim.inject(opsin, neurons) opsyn = opsin.synapses[neurons.name] light_agg = opsin.light_agg_ngs[neurons.name] assert all(neurons.Iopto) == 0 assert all(neurons.v == -70 * mV) - assert all(opsyn.C1 == 1) - assert all(opsyn.O1 == 0) - assert all(opsyn.C2 == 0) - assert all(opsyn.O2 == 0) + assert all(getattr(opsyn, rest_state) == 1) + for active_state in active_states: + assert all(getattr(opsyn, active_state) == 0) + # light on - light_agg.phi = 1e10 / second / meter**2 + light_agg.phi = stim_gain * 1e10 / second / meter**2 + # sim.run(stim_gain * 1 * ms) sim.run(1 * ms) # current flowing, channels opened - assert all(neurons.Iopto > 0) - assert all(neurons.v > -70 * mV) # depolarized - assert all(opsyn.C1 < 1) - assert all(opsyn.O1 > 0) - assert all(opsyn.C2 > 0) - assert all(opsyn.O2 > 0) + if is_exc: + assert all(neurons.Iopto > 0) + assert all(neurons.v > -70 * mV) # depolarized + else: + assert all(neurons.Iopto < 0) + assert all(neurons.v < -70 * mV) # hyperpolarized + assert all(getattr(opsyn, rest_state) < 1) + for active_state in active_states: + assert all(getattr(opsyn, active_state) > 0) + # light off: should go back to (close to) resting state light_agg.phi = 0 + # sim.run(stim_gain * 49 * ms) sim.run(49 * ms) - assert all(neurons.Iopto > -100 * pamp) - assert np.allclose(neurons.v, -70 * mV, atol=2 * mV) # within 2 mV of -70 - assert all(opsyn.C1 > 0.99) - assert all(opsyn.O1 < 0.01) - assert all(opsyn.C2 < 0.01) - assert all(opsyn.O2 < 0.01) + if is_exc: + assert all(neurons.Iopto > -100 * pamp) + else: + assert all(neurons.Iopto < 100 * pamp) + assert np.allclose(neurons.v, -70 * mV, atol=2 * mV) + assert all(getattr(opsyn, rest_state) > 0.99) + for active_state in active_states: + assert all(getattr(opsyn, active_state) < 0.01) @pytest.mark.slow diff --git a/tests/test_base.py b/tests/test_base.py index f416823..6675f85 100644 --- a/tests/test_base.py +++ b/tests/test_base.py @@ -1,15 +1,15 @@ """Tests for base module""" +import neo import pytest from brian2 import ( - NeuronGroup, + BrianObjectException, Network, - Synapses, + NeuronGroup, PopulationRateMonitor, + Synapses, ms, - BrianObjectException, ) -import neo from cleo import CLSimulator, IOProcessor, Recorder, Stimulator @@ -103,7 +103,7 @@ def put_state(self, state_dict: dict, time): mock_processing = {-1: "expected"} self.my_stim_out = mock_processing[state_dict["my_rec"]] - def get_ctrl_signal(self, time) -> dict: + def get_ctrl_signals(self, time) -> dict: return {"my_stim": self.my_stim_out} def is_sampling_now(self, time) -> bool: diff --git a/tests/test_viz.py b/tests/test_viz.py index 3b9914b..979269d 100644 --- a/tests/test_viz.py +++ b/tests/test_viz.py @@ -1,12 +1,15 @@ -from brian2 import NeuronGroup, Network, ms, mm +import itertools + import pytest +from brian2 import Network, NeuronGroup, mm, ms +import cleo from cleo import CLSimulator -from cleo.viz import VideoVisualizer -from cleo.light import Light, fiber473nm -from cleo.opto import chr2_4s from cleo.coords import assign_xyz from cleo.ephys import Probe +from cleo.light import Light, fiber473nm +from cleo.opto import chr2_4s +from cleo.viz import VideoVisualizer @pytest.mark.slow @@ -38,3 +41,39 @@ def test_VideoVisualizer(): "scatterargs": {"s": 20}, # to adjust neuron marker size } ani = vv.generate_Animation(plotargs) + + +@pytest.mark.slow +def test_plot_sim(): + ng = NeuronGroup( + 1, + """v : volt + Iopto : amp""", + threshold="v > 1 * volt", + reset="v = 0 * volt", + ) + assign_xyz(ng, 0, 0, 0) + light = Light(light_model=fiber473nm(), max_Irr0_mW_per_mm2=20) + # opsin = chr2_4s() + probe = Probe([(0, 0, 0.1)] * mm) + + sim = CLSimulator(Network(ng)).inject(light, ng).inject(probe, ng) + + vv = VideoVisualizer() + sim.inject(vv, ng) + + ngs_sim_devs_npoints = itertools.product( + [[ng], []], + [None, sim], + [[light, probe], [light], []], + [None, 1, 100, 1000], + ) + + for ngs, sim_param, devices, n_points in ngs_sim_devs_npoints: + if n_points: + light_kwargs = {"n_points_per_source": n_points} + else: + light_kwargs = {} + cleo.viz.plot( + *ngs, sim=sim_param, devices=[(dev, light_kwargs) for dev in devices] + )