From e81ad5f33732701a2f8c222457c85986f973a99b Mon Sep 17 00:00:00 2001 From: Monkin Date: Fri, 23 Aug 2024 13:19:27 +0100 Subject: [PATCH 1/4] Add: Process and ProcessModel implementation of E/I LIF neuron model --- src/lava/proc/io/utils.py | 25 ++++ src/lava/proc/lif/models.py | 170 +++++++++++++++++++++++- src/lava/proc/lif/process.py | 246 +++++++++++++++++++++++++++++++++++ 3 files changed, 440 insertions(+), 1 deletion(-) diff --git a/src/lava/proc/io/utils.py b/src/lava/proc/io/utils.py index 7f8bc0ec7..10547db5a 100644 --- a/src/lava/proc/io/utils.py +++ b/src/lava/proc/io/utils.py @@ -280,3 +280,28 @@ def validate_channel_config(channel_config: ChannelConfig) -> None: "to be of type ReceiveNotEmpty. Got " ".receive_not_empty = " f"{channel_config.receive_not_empty}.") + +def convert_to_numpy_array(val, shape, name = "value", verbose=False): + """ + Converts a given value to a numpy array if it is not already + @param val: The value to convert. Can be a scalar, list, or numpy array + @param shape: The shape of the array to convert to + @param verbose: Whether to print debug messages + + @return: The value as a numpy array + @raises ValueError: If the value cannot be converted to a numpy array + """ + if np.isscalar(val): + if verbose: + print(f"{name} is scalar, converting to numpy array") + # If val is a scalar, create an array filled with that value with shape (n_neurons) + val = np.full(shape, val) + elif not isinstance(val, np.ndarray): + # If val is not a scalar and not a numpy array, try to convert it to a numpy array + try: + val = np.array(val) + except Exception as e: + raise ValueError(f"Failed to convert {name} to a numpy array. Please ensure it is either a scalar, list, or numpy array.") from e + + return val + diff --git a/src/lava/proc/lif/models.py b/src/lava/proc/lif/models.py index 72f02be9b..f5aa66590 100644 --- a/src/lava/proc/lif/models.py +++ b/src/lava/proc/lif/models.py @@ -14,7 +14,7 @@ from lava.magma.core.decorator import implements, requires, tag from lava.magma.core.model.py.model import PyLoihiProcessModel from lava.proc.lif.process import (LIF, LIFReset, TernaryLIF, LearningLIF, - LIFRefractory) + LIFRefractory, EILIFRefractory, EILIF) class AbstractPyLifModelFloat(PyLoihiProcessModel): @@ -559,3 +559,171 @@ def run_spk(self) -> None: Dense process for learning. """ super().run_spk() + + +class AbstractPyEILifModelFloat(PyLoihiProcessModel): + """Abstract implementation of floating point precision + excitatory/inhibitory leaky-integrate-and-fire neuron model. + + Specific implementations inherit from here. + """ + + # a_in is the input port that receives the synaptic input. + # The positive values of a_in will increase the u_exc and negative values + # will increase the u_inh. + a_in: PyInPort = LavaPyType(PyInPort.VEC_DENSE, float) + s_out = None # This will be an OutPort of different LavaPyTypes + u_exc: np.ndarray = LavaPyType(np.ndarray, float) + u_inh: np.ndarray = LavaPyType(np.ndarray, float) + u: np.ndarray = LavaPyType(np.ndarray, float) # Net current (u_exc + u_inh) + v: np.ndarray = LavaPyType(np.ndarray, float) + bias_mant: np.ndarray = LavaPyType(np.ndarray, float) + bias_exp: np.ndarray = LavaPyType(np.ndarray, float) + du_exc: np.ndarray = LavaPyType(np.ndarray, float) + du_inh: np.ndarray = LavaPyType(np.ndarray, float) + dv: np.ndarray = LavaPyType(np.ndarray, float) + + def spiking_activation(self): + """Abstract method to define the activation function that determines + how spikes are generated. + """ + raise NotImplementedError( + "spiking activation() cannot be called from " + "an abstract ProcessModel" + ) + + def subthr_dynamics(self, activation_in: np.ndarray): + """Common sub-threshold dynamics of current and voltage variables for + all Configurable Time Constants LIF models. + This is where the 'leaky integration' happens. + """ + # Get the excitatory input from a_in -- Positive values increase u_exc + exc_a_in = np.clip(activation_in, a_min=0, a_max=None) + # Get the inhibitory input from a_in -- Negative values increase u_inh + inh_a_in = np.clip(activation_in, a_min=None, a_max=0) + + # Update the excitatory and inhibitory currents + self.u_exc[:] = self.u_exc * (1 - self.du_exc) + self.u_exc[:] += exc_a_in + + self.u_inh[:] = self.u_inh * (1 - self.du_inh) + self.u_inh[:] += inh_a_in + + # Update the voltage + # Calculate the net current by adding the excitatory and inhibitory currents + self.u = self.u_exc + self.u_inh # u_inh is negative + self.v[:] = self.v * (1 - self.dv) + self.u + self.bias_mant + + def reset_voltage(self, spike_vector: np.ndarray): + """Voltage reset behaviour. This can differ for different neuron + models.""" + self.v[spike_vector] = 0 + + def run_spk(self): + """The run function that performs the actual computation during + execution orchestrated by a PyLoihiProcessModel using the + LoihiProtocol. + """ + super().run_spk() + a_in_data = self.a_in.recv() + + self.subthr_dynamics(activation_in=a_in_data) + self.s_out_buff = self.spiking_activation() + self.reset_voltage(spike_vector=self.s_out_buff) + self.s_out.send(self.s_out_buff) + +@implements(proc=EILIF, protocol=LoihiProtocol) +@requires(CPU) +@tag("floating_pt") +class PyEILifFloat(AbstractPyEILifModelFloat): + """Implementation of Excitatory/Inhibitory Leaky-Integrate-and-Fire + neural process in floating point precision. This short and simple + ProcessModel can be used for quick algorithmic prototyping, without + engaging with the nuances of a fixed point implementation. + """ + s_out: PyOutPort = LavaPyType(PyOutPort.VEC_DENSE, float) + vth: float = LavaPyType(float, float) + + def spiking_activation(self): + """Spiking activation function for LIF.""" + return self.v > self.vth + +@implements(proc=EILIFRefractory, protocol=LoihiProtocol) +@requires(CPU) +@tag("floating_pt") +class PyEILifRefractoryFloat(AbstractPyEILifModelFloat): + """Implementation of Excitatory/Inhibitory Refractory + Leaky-Integrate-and-Fire neural process in floating point precision. + This short and simple ProcessModel can be used for quick algorithmic + prototyping, without engaging with the nuances of a fixed + point implementation. + """ + s_out: PyOutPort = LavaPyType(PyOutPort.VEC_DENSE, float) + vth: float = LavaPyType(float, float) + refractory_period_end: np.ndarray = LavaPyType(np.ndarray, int) + + def __init__(self, proc_params): + super(PyEILifRefractoryFloat, self).__init__(proc_params) + self.refractory_period = proc_params["refractory_period"] + + def spiking_activation(self): + """Spiking activation function for LIF.""" + return self.v > self.vth + + def subthr_dynamics(self, activation_in: np.ndarray): + """Sub-threshold dynamics of current and voltage variables for + ConfigTimeConstantsLIF + This is where the 'leaky integration' happens. + """ + # if np.max(activation_in) > 0: + # print(f"Time step: {self.time_step} has activation.") + + # Get the excitatory input from a_in -- Positive values increase u_exc + exc_a_in = np.clip(activation_in, a_min=0, a_max=None) + # Get the inhibitory input from a_in -- Negative values increase u_inh + inh_a_in = np.clip(activation_in, a_min=None, a_max=0) + + # Update the excitatory and inhibitory currents + self.u_exc[:] = self.u_exc * (1 - self.du_exc) + self.u_exc[:] += exc_a_in + + self.u_inh[:] = self.u_inh * (1 - self.du_inh) + self.u_inh[:] += inh_a_in + + # Check which neurons are not in refractory period + non_refractory = self.refractory_period_end < self.time_step + """ non_refrac_idx = np.where(non_refractory == False)[0] + if len(non_refrac_idx) > 0: + print(f"Time step: {self.time_step} has neurons in refractory period -> {non_refrac_idx}") + print(f"{self.u[non_refrac_idx[0]]} {self.v[non_refrac_idx[0]]}") """ + + # Update the voltage of the non-refractory neurons + # Calculate the net current by adding the excitatory and inhibitory currents + self.u = self.u_exc + self.u_inh # u_inh is negative + + self.v[non_refractory] = self.v[non_refractory] * (1 - self.dv[non_refractory]) + ( + self.u[non_refractory] + self.bias_mant[non_refractory]) + + def process_spikes(self, spike_vector: np.ndarray): + """ + Set the refractory_period_end for the neurons that spiked and + Reset the voltage of the neurons that spiked to 0 + """ + self.refractory_period_end[spike_vector] = (self.time_step + + self.refractory_period) + super().reset_voltage(spike_vector) + + def run_spk(self): + """The run function that performs the actual computation during + execution orchestrated by a PyLoihiProcessModel using the + LoihiProtocol. + """ + a_in_data = self.a_in.recv() + + self.subthr_dynamics(activation_in=a_in_data) + spike_vector = self.spiking_activation() + """ if np.max(spike_vector) > 0: + print(f"Time step: {self.time_step} has a neuron spike.") """ + + self.process_spikes(spike_vector=spike_vector) # Reset voltage of spiked neurons to 0 and update refractory period + self.s_out.send(spike_vector) diff --git a/src/lava/proc/lif/process.py b/src/lava/proc/lif/process.py index d658755b8..9a776f7cf 100644 --- a/src/lava/proc/lif/process.py +++ b/src/lava/proc/lif/process.py @@ -10,6 +10,7 @@ from lava.magma.core.process.variable import Var from lava.magma.core.process.ports.ports import InPort, OutPort from lava.magma.core.process.neuron import LearningNeuronProcess +from lava.proc.io.utils import convert_to_numpy_array class AbstractLIF(AbstractProcess): @@ -416,3 +417,248 @@ def __init__( self.proc_params["refractory_period"] = refractory_period self.refractory_period_end = Var(shape=shape, init=0) + + +class AbstractEILIF(AbstractProcess): + """Abstract class for variables common to all neurons with Excitatory/Inhibitory + leaky integrator dynamics and configurable time constants""" + + def __init__( + self, + *, + shape: ty.Tuple[int, ...], + u_exc: ty.Union[float, list, np.ndarray], + u_inh: ty.Union[float, list, np.ndarray], + v: ty.Union[float, list, np.ndarray], + du_exc: ty.Optional[ty.Union[float, list, np.ndarray]] = 0, + du_inh: ty.Optional[ty.Union[float, list, np.ndarray]] = 0, + dv: ty.Optional[ty.Union[float, list, np.ndarray]] = 0, + bias_mant: ty.Union[float, list, np.ndarray], + bias_exp: ty.Union[float, list, np.ndarray], + name: str, + log_config: LogConfig, + **kwargs, + ) -> None: + super().__init__( + shape=shape, + u_exc=u_exc, + u_inh=u_inh, + v=v, + du_exc=du_exc, + du_inh=du_inh, + dv=dv, + bias_mant=bias_mant, + bias_exp=bias_exp, + name=name, + log_config=log_config, + **kwargs, + ) + + self.a_in = InPort(shape=shape) + self.s_out = OutPort(shape=shape) + self.u_exc = Var(shape=shape, init=u_exc) + self.u_inh = Var(shape=shape, init=u_inh) + self.u = Var(shape=shape, init=u_exc + u_inh) # neuron total current (u_inh is negative) + self.v = Var(shape=shape, init=v) + self.du_exc = Var(shape=shape, init=du_exc) # Shape of du_exc must match the shape of the neurons + self.du_inh = Var(shape=shape, init=du_inh) # Shape of du_inh must match the shape of the neurons + self.dv = Var(shape=shape, init=dv) # Shape of dv must match the shape of the neurons + self.bias_exp = Var(shape=shape, init=bias_exp) + self.bias_mant = Var(shape=shape, init=bias_mant) + + +class EILIF(AbstractEILIF): + """Exctitatory/Inhibitory Leaky-Integrate-and-Fire (LIF) neural Process. + This neuron model receives 2 input currents, one excitatory and one inhibitory. + The neuron's total current is the sum of the excitatory and inhibitory currents. + Each current has its own decay time-constant and it is independent on a neuron-to-neuron basis. + + LIF dynamics abstracts to: + u_exc[t] = u_exc[t-1] * (1-du_exc) + a_in (excitatory spike) # neuron excitatory current + u_inh[t] = u_inh[t-1] * (1-du_inh) + a_in (inhibitory spike) # neuron inhibitory current + + u[t] = u_exc[t] + u_inh[t] # neuron total current (u_inh[t] is negative) + v[t] = v[t-1] * (1-dv) + u[t] + bias # neuron voltage + s_out = v[t] > vth # spike if threshold is exceeded + v[t] = 0 # reset at spike + + Parameters + ---------- + shape : tuple(int) + Number and topology of LIF neurons. + u_exc : float, list, numpy.ndarray, optional + Initial value of the neurons' excitatory current. + u_inh : float, list, numpy.ndarray, optional + Initial value of the neurons' inhibitory current. + v : float, list, numpy.ndarray, optional + Initial value of the neurons' voltage (membrane potential). + du_exc : float, list, numpy.ndarray, optional + Inverse of decay time-constant for excitatory current decay. This can be a scalar, list, + or numpy array. Anyhow, it will be converted to a np array representing the + time-constants of each neuron. + du_inh : float, list, numpy.ndarray, optional + Inverse of decay time-constant for inhibitory current decay. This can be a scalar, list, + or numpy array. Anyhow, it will be converted to a np array representing the + time-constants of each neuron. + dv : float, list, numpy.ndarray, optional + Inverse of decay time-constant for voltage decay. This can be a scalar, list, + or numpy array. Anyhow, it will be converted to a np array representing the + time-constants of each neuron. + bias_mant : float, list, numpy.ndarray, optional + Mantissa part of neuron bias. + bias_exp : float, list, numpy.ndarray, optional + Exponent part of neuron bias, if needed. Mostly for fixed point + implementations. Ignored for floating point implementations. + vth : float, optional + Neuron threshold voltage, exceeding which, the neuron will spike. + Currently, only a single threshold can be set for the entire + population of neurons. + + Example + ------- + >>> ei_lif = EILIF(shape=(200, 15), du_exc=0.1, du_inh=0.2, dv=5) + This will create 200x15 EILIF neurons that all have the same excitatory and + inhibitory current decays (0.1 and 0.2, respectively) and voltage decay of 5. + """ + def __init__( + self, + *, + shape: ty.Tuple[int, ...], + v: ty.Union[float, list, np.ndarray], + u_exc: ty.Union[float, list, np.ndarray] = 0, + u_inh: ty.Union[float, list, np.ndarray] = 0, + du_exc: ty.Optional[ty.Union[float, list, np.ndarray]] = 0, + du_inh: ty.Optional[ty.Union[float, list, np.ndarray]] = 0, + dv: ty.Optional[ty.Union[float, list, np.ndarray]] = 0, + bias_mant: ty.Optional[ty.Union[float, list, np.ndarray]] = 0, + bias_exp: ty.Optional[ty.Union[float, list, np.ndarray]] = 0, + vth: ty.Optional[float] = 10, + name: ty.Optional[str] = None, + log_config: ty.Optional[LogConfig] = None, + **kwargs, + ) -> None: + # Try to convert du_exc, du_inh and dv to numpy arrays if they are not already + # If unsuccessful, it will raise a ValueError + du_exc = convert_to_numpy_array(du_exc, shape, "du_exc", verbose=True) + du_inh = convert_to_numpy_array(du_inh, shape, "du_inh", verbose=True) + dv = convert_to_numpy_array(dv, shape, "dv", verbose=True) + + super().__init__( + shape=shape, + u_exc=u_exc, + u_inh=u_inh, + v=v, + du_exc=du_exc, + du_inh=du_inh, + dv=dv, + bias_mant=bias_mant, + bias_exp=bias_exp, + vth=vth, + name=name, + log_config=log_config, + **kwargs, + ) + + # Add the vth variable to the process + self.vth = Var(shape=(1,), init=vth) + +class EILIFRefractory(EILIF): + """Exctitatory/Inhibitory Leaky-Integrate-and-Fire (LIF) neural Process with refractory period. + This neuron model receives 2 input currents, one excitatory and one inhibitory. + The neuron's total current is the sum of the excitatory and inhibitory currents. + Each current has its own decay time-constant and it is independent on a neuron-to-neuron basis. + + LIF dynamics abstracts to: + u_exc[t] = u_exc[t-1] * (1-du_exc) + a_in (excitatory spike) # neuron excitatory current + u_inh[t] = u_inh[t-1] * (1-du_inh) + a_in (inhibitory spike) # neuron inhibitory current + + u[t] = u_exc[t] + u_inh[t] # neuron total current (u_inh[t] is negative) + v[t] = v[t-1] * (1-dv) + u[t] + bias # neuron voltage + s_out = v[t] > vth # spike if threshold is exceeded + v[t] = 0 # reset at spike + + Parameters + ---------- + shape : tuple(int) + Number and topology of LIF neurons. + u_exc : float, list, numpy.ndarray, optional + Initial value of the neurons' excitatory current. + u_inh : float, list, numpy.ndarray, optional + Initial value of the neurons' inhibitory current. + v : float, list, numpy.ndarray, optional + Initial value of the neurons' voltage (membrane potential). + du_exc : float, list, numpy.ndarray, optional + Inverse of decay time-constant for excitatory current decay. This can be a scalar, list, + or numpy array. Anyhow, it will be converted to a np array representing the + time-constants of each neuron. + du_inh : float, list, numpy.ndarray, optional + Inverse of decay time-constant for inhibitory current decay. This can be a scalar, list, + or numpy array. Anyhow, it will be converted to a np array representing the + time-constants of each neuron. + dv : float, list, numpy.ndarray, optional + Inverse of decay time-constant for voltage decay. This can be a scalar, list, + or numpy array. Anyhow, it will be converted to a np array representing the + time-constants of each neuron. + bias_mant : float, list, numpy.ndarray, optional + Mantissa part of neuron bias. + bias_exp : float, list, numpy.ndarray, optional + Exponent part of neuron bias, if needed. Mostly for fixed point + implementations. Ignored for floating point implementations. + vth : float, optional + Neuron threshold voltage, exceeding which, the neuron will spike. + Currently, only a single threshold can be set for the entire + population of neurons. + refractory_period : int, optional + The interval of the refractory period. 1 timestep by default. + + Example + ------- + >>> refrac_ei_lif = EILIFRefractory(shape=(200, 15), du_exc=0.1, du_inh=0.2, dv=5) + This will create 200x15 EILIF neurons that all have the same excitatory and + inhibitory current decays (0.1 and 0.2, respectively), voltage decay of 5. + and refractory period of 1 timestep. + """ + def __init__( + self, + *, + shape: ty.Tuple[int, ...], + v: ty.Union[float, list, np.ndarray], + u_exc: ty.Union[float, list, np.ndarray] = 0, + u_inh: ty.Union[float, list, np.ndarray] = 0, + du_exc: ty.Optional[ty.Union[float, list, np.ndarray]] = 0, + du_inh: ty.Optional[ty.Union[float, list, np.ndarray]] = 0, + dv: ty.Optional[ty.Union[float, list, np.ndarray]] = 0, + bias_mant: ty.Optional[ty.Union[float, list, np.ndarray]] = 0, + bias_exp: ty.Optional[ty.Union[float, list, np.ndarray]] = 0, + vth: ty.Optional[float] = 10, + refractory_period: ty.Optional[int] = 1, + name: ty.Optional[str] = None, + log_config: ty.Optional[LogConfig] = None, + **kwargs, + ) -> None: + super().__init__( + shape=shape, + u_exc=u_exc, + u_inh=u_inh, + v=v, + du_exc=du_exc, + du_inh=du_inh, + dv=dv, + bias_mant=bias_mant, + bias_exp=bias_exp, + vth=vth, + name=name, + log_config=log_config, + **kwargs, + ) + + # Validate the refractory period + if refractory_period < 1: # TODO: Change to 0 + raise ValueError("Refractory period must be > 0.") + # Check if the refractory period is a float + if isinstance(refractory_period, float): + print("Refractory period must be an integer. Converting to integer...") + refractory_period = int(refractory_period) + + self.proc_params["refractory_period"] = refractory_period + self.refractory_period_end = Var(shape=shape, init=0) From 72d6aace45cf7a2df1a0612095e6dcf8d53f0db3 Mon Sep 17 00:00:00 2001 From: Monkin Date: Fri, 23 Aug 2024 17:39:08 +0100 Subject: [PATCH 2/4] Add: EILIF unit tests w/ different current decays --- src/lava/proc/lif/process.py | 4 +- tests/lava/proc/lif/test_models.py | 81 +++++++++++++++++++++++++++++- 2 files changed, 82 insertions(+), 3 deletions(-) diff --git a/src/lava/proc/lif/process.py b/src/lava/proc/lif/process.py index 9a776f7cf..4ae37cfaf 100644 --- a/src/lava/proc/lif/process.py +++ b/src/lava/proc/lif/process.py @@ -429,7 +429,7 @@ def __init__( shape: ty.Tuple[int, ...], u_exc: ty.Union[float, list, np.ndarray], u_inh: ty.Union[float, list, np.ndarray], - v: ty.Union[float, list, np.ndarray], + v: ty.Optional[ty.Union[float, list, np.ndarray]] = 0, du_exc: ty.Optional[ty.Union[float, list, np.ndarray]] = 0, du_inh: ty.Optional[ty.Union[float, list, np.ndarray]] = 0, dv: ty.Optional[ty.Union[float, list, np.ndarray]] = 0, @@ -524,7 +524,7 @@ def __init__( self, *, shape: ty.Tuple[int, ...], - v: ty.Union[float, list, np.ndarray], + v: ty.Optional[ty.Union[float, list, np.ndarray]] = 0, u_exc: ty.Union[float, list, np.ndarray] = 0, u_inh: ty.Union[float, list, np.ndarray] = 0, du_exc: ty.Optional[ty.Union[float, list, np.ndarray]] = 0, diff --git a/tests/lava/proc/lif/test_models.py b/tests/lava/proc/lif/test_models.py index 1d9f29943..376447004 100644 --- a/tests/lava/proc/lif/test_models.py +++ b/tests/lava/proc/lif/test_models.py @@ -17,7 +17,7 @@ from lava.magma.core.run_configs import Loihi2SimCfg, RunConfig from lava.magma.core.run_conditions import RunSteps from lava.magma.core.sync.protocols.loihi_protocol import LoihiProtocol -from lava.proc.lif.process import LIF, LIFReset, TernaryLIF, LIFRefractory +from lava.proc.lif.process import LIF, LIFReset, TernaryLIF, LIFRefractory, EILIF from lava.proc import io @@ -860,3 +860,82 @@ def test_float_model(self): [2, 4, 0, 0, 2, 4, 0, 0]], dtype=float) assert_almost_equal(v, v_expected) + +class TestEILIFFloat(unittest.TestCase): + """Test EILIF process model""" + + def test_no_decays(self): + """Test float model""" + num_neurons = 2 + num_steps = 8 + + # Two neurons with different biases + # No Input current provided to make the voltage dependent on the bias + ei_lif = EILIF(shape=(num_neurons,), + u_exc=np.zeros(num_neurons), + u_inh=np.zeros(num_neurons), + bias_mant=np.arange(num_neurons) + 1, + bias_exp=np.ones( + (num_neurons,), dtype=float), + vth=4,) + + v_logger = io.sink.Read(buffer=num_steps) + v_logger.connect_var(ei_lif.v) + + ei_lif.run(condition=RunSteps(num_steps), + run_cfg=Loihi2SimCfg(select_tag="floating_pt")) + + v = v_logger.data.get() + ei_lif.stop() + + # Voltage is expected to remain at reset level for two time steps + v_expected = np.array([[1, 2, 3, 4, 0, 1, 2, 3], + [2, 4, 0, 2, 4, 0, 2, 4]], dtype=float) + + assert_almost_equal(v, v_expected) + + def test_different_decays(self): + """Test float model""" + num_neurons = 2 + num_steps = 8 + + du_exc_arr = np.array([0.1, 0.2]) + du_inh_arr = np.array([0.2, 0.3]) + + # Two neurons with different biases + # No Input current provided to make the voltage dependent on the bias + ei_lif = EILIF(shape=(num_neurons,), + du_exc=du_exc_arr, + du_inh=du_inh_arr, + vth=6,) + + # Setup external input + positive_sps = VecSendProcess(shape=(num_neurons,), num_steps=num_steps, + vec_to_send=np.full(shape=(num_neurons), fill_value=1), + send_at_times=[1, 1, 0, 0, 0, 0, 0 , 0], dtype=bool) + + negative_sps = VecSendProcess(shape=(num_neurons,), num_steps=num_steps, + vec_to_send=np.full(shape=(num_neurons), fill_value=-1), + send_at_times=[0, 0, 0, 1, 1, 1, 0 , 0], dtype=bool) + + + # Connect external input to the EILIF model + positive_sps.s_out.connect(ei_lif.a_in) + negative_sps.s_out.connect(ei_lif.a_in) + + v_logger = io.sink.Read(buffer=num_steps) + v_logger.connect_var(ei_lif.v) + + ei_lif.run(condition=RunSteps(num_steps), + run_cfg=Loihi2SimCfg(select_tag="floating_pt")) + + v = v_logger.data.get() + ei_lif.stop() + + print("V: ", v) + + # Voltage is expected to remain at reset level for two time steps + v_expected = np.array([[1, 2.9, 4.61, 5.149, 4.73, 3.54, 2.71, 2.16], + [1, 2.8, 4.24, 4.39, 3.61, 2.16, 1.22, 0.62]], dtype=float) + + assert_almost_equal(v, v_expected, decimal=2) \ No newline at end of file From 2729caec0f637433558e49c136c88419b372a9e6 Mon Sep 17 00:00:00 2001 From: Monkin Date: Sat, 24 Aug 2024 12:30:08 +0100 Subject: [PATCH 3/4] Add: Tests for EILifRefractory --- src/lava/proc/io/utils.py | 22 +- src/lava/proc/lif/process.py | 16 +- tests/lava/proc/lif/test_models.py | 84 ++- .../custom/tutorial00_tour_through_lava.ipynb | 567 ++++++++++++++++++ 4 files changed, 675 insertions(+), 14 deletions(-) create mode 100644 tutorials/custom/tutorial00_tour_through_lava.ipynb diff --git a/src/lava/proc/io/utils.py b/src/lava/proc/io/utils.py index 10547db5a..23fc00cab 100644 --- a/src/lava/proc/io/utils.py +++ b/src/lava/proc/io/utils.py @@ -284,12 +284,24 @@ def validate_channel_config(channel_config: ChannelConfig) -> None: def convert_to_numpy_array(val, shape, name = "value", verbose=False): """ Converts a given value to a numpy array if it is not already - @param val: The value to convert. Can be a scalar, list, or numpy array - @param shape: The shape of the array to convert to - @param verbose: Whether to print debug messages - @return: The value as a numpy array - @raises ValueError: If the value cannot be converted to a numpy array + Parameters + ---------- + val : scalar | list | np.ndarray + The value to convert. Can be a scalar, list, or numpy array + shape : tuple + The shape of the array to convert to + verbose : bool + Whether to print debug messages + + Returns + ---------- + value: np.ndarray + The value as a numpy array + + Raises + ---------- + ValueError: If the value cannot be converted to a numpy array """ if np.isscalar(val): if verbose: diff --git a/src/lava/proc/lif/process.py b/src/lava/proc/lif/process.py index 4ae37cfaf..24507851d 100644 --- a/src/lava/proc/lif/process.py +++ b/src/lava/proc/lif/process.py @@ -535,13 +535,14 @@ def __init__( vth: ty.Optional[float] = 10, name: ty.Optional[str] = None, log_config: ty.Optional[LogConfig] = None, + verbose: ty.Optional[bool] = False, **kwargs, ) -> None: # Try to convert du_exc, du_inh and dv to numpy arrays if they are not already # If unsuccessful, it will raise a ValueError - du_exc = convert_to_numpy_array(du_exc, shape, "du_exc", verbose=True) - du_inh = convert_to_numpy_array(du_inh, shape, "du_inh", verbose=True) - dv = convert_to_numpy_array(dv, shape, "dv", verbose=True) + du_exc = convert_to_numpy_array(du_exc, shape, "du_exc", verbose=verbose) + du_inh = convert_to_numpy_array(du_inh, shape, "du_inh", verbose=verbose) + dv = convert_to_numpy_array(dv, shape, "dv", verbose=verbose) super().__init__( shape=shape, @@ -563,7 +564,7 @@ def __init__( self.vth = Var(shape=(1,), init=vth) class EILIFRefractory(EILIF): - """Exctitatory/Inhibitory Leaky-Integrate-and-Fire (LIF) neural Process with refractory period. + """Excitatory/Inhibitory Leaky-Integrate-and-Fire (LIF) neural Process with refractory period. This neuron model receives 2 input currents, one excitatory and one inhibitory. The neuron's total current is the sum of the excitatory and inhibitory currents. Each current has its own decay time-constant and it is independent on a neuron-to-neuron basis. @@ -622,7 +623,7 @@ def __init__( self, *, shape: ty.Tuple[int, ...], - v: ty.Union[float, list, np.ndarray], + v: ty.Optional[ty.Union[float, list, np.ndarray]] = 0, u_exc: ty.Union[float, list, np.ndarray] = 0, u_inh: ty.Union[float, list, np.ndarray] = 0, du_exc: ty.Optional[ty.Union[float, list, np.ndarray]] = 0, @@ -634,6 +635,7 @@ def __init__( refractory_period: ty.Optional[int] = 1, name: ty.Optional[str] = None, log_config: ty.Optional[LogConfig] = None, + verbose: ty.Optional[bool] = False, **kwargs, ) -> None: super().__init__( @@ -649,6 +651,7 @@ def __init__( vth=vth, name=name, log_config=log_config, + verbose=verbose, **kwargs, ) @@ -657,7 +660,8 @@ def __init__( raise ValueError("Refractory period must be > 0.") # Check if the refractory period is a float if isinstance(refractory_period, float): - print("Refractory period must be an integer. Converting to integer...") + if verbose: + print("Refractory period must be an integer. Converting to integer...") refractory_period = int(refractory_period) self.proc_params["refractory_period"] = refractory_period diff --git a/tests/lava/proc/lif/test_models.py b/tests/lava/proc/lif/test_models.py index 376447004..c83000db8 100644 --- a/tests/lava/proc/lif/test_models.py +++ b/tests/lava/proc/lif/test_models.py @@ -17,7 +17,7 @@ from lava.magma.core.run_configs import Loihi2SimCfg, RunConfig from lava.magma.core.run_conditions import RunSteps from lava.magma.core.sync.protocols.loihi_protocol import LoihiProtocol -from lava.proc.lif.process import LIF, LIFReset, TernaryLIF, LIFRefractory, EILIF +from lava.proc.lif.process import LIF, LIFReset, TernaryLIF, LIFRefractory, EILIF, EILIFRefractory from lava.proc import io @@ -932,10 +932,88 @@ def test_different_decays(self): v = v_logger.data.get() ei_lif.stop() - print("V: ", v) - # Voltage is expected to remain at reset level for two time steps v_expected = np.array([[1, 2.9, 4.61, 5.149, 4.73, 3.54, 2.71, 2.16], [1, 2.8, 4.24, 4.39, 3.61, 2.16, 1.22, 0.62]], dtype=float) + assert_almost_equal(v, v_expected, decimal=2) + +class TestEILIFRefractoryFloat(unittest.TestCase): + """Test EILIFRefractory process model""" + + def test_no_decays(self): + """Test float model""" + num_neurons = 2 + num_steps = 8 + refractory_period = 1 + + # Two neurons with different biases + # No Input current provided to make the voltage dependent on the bias + ei_lif = EILIFRefractory(shape=(num_neurons,), + u_exc=np.zeros(num_neurons), + u_inh=np.zeros(num_neurons), + bias_mant=np.arange(num_neurons) + 1, + bias_exp=np.ones( + (num_neurons,), dtype=float), + vth=4, + refractory_period=refractory_period) + + v_logger = io.sink.Read(buffer=num_steps) + v_logger.connect_var(ei_lif.v) + + ei_lif.run(condition=RunSteps(num_steps), + run_cfg=Loihi2SimCfg(select_tag="floating_pt")) + + v = v_logger.data.get() + ei_lif.stop() + + # Voltage is expected to remain at reset level for two time steps + v_expected = np.array([[1, 2, 3, 4, 0, 0, 1, 2], + [2, 4, 0, 0, 2, 4, 0, 0]], dtype=float) + + assert_almost_equal(v, v_expected) + + def test_different_decays(self): + """Test float model with different decays per neuron""" + num_neurons = 2 + num_steps = 8 + refractory_period = 1 + + du_exc_arr = np.array([0.1, 0.2]) + du_inh_arr = np.array([0.2, 0.3]) + + # Neuron 1 will spike, while neuron 2 will not due to different decay rates. + ei_lif = EILIFRefractory(shape=(num_neurons,), + du_exc=du_exc_arr, + du_inh=du_inh_arr, + vth=5, + refractory_period=refractory_period) + + # Setup external input + positive_sps = VecSendProcess(shape=(num_neurons,), num_steps=num_steps, + vec_to_send=np.full(shape=(num_neurons), fill_value=1), + send_at_times=[1, 1, 0, 0, 0, 0, 0 , 0], dtype=bool) + + negative_sps = VecSendProcess(shape=(num_neurons,), num_steps=num_steps, + vec_to_send=np.full(shape=(num_neurons), fill_value=-1), + send_at_times=[0, 0, 0, 1, 1, 1, 0 , 0], dtype=bool) + + + # Connect external input to the EILIF model + positive_sps.s_out.connect(ei_lif.a_in) + negative_sps.s_out.connect(ei_lif.a_in) + + v_logger = io.sink.Read(buffer=num_steps) + v_logger.connect_var(ei_lif.v) + + ei_lif.run(condition=RunSteps(num_steps), + run_cfg=Loihi2SimCfg(select_tag="floating_pt")) + + v = v_logger.data.get() + ei_lif.stop() + + # Voltage is expected to remain at reset level for two time steps + v_expected = np.array([[1, 2.9, 4.61, 0, 0, -1.19341, -2.02, -2.57], + [1, 2.8, 4.24, 4.39, 3.61, 2.16, 1.22, 0.62]], dtype=float) + assert_almost_equal(v, v_expected, decimal=2) \ No newline at end of file diff --git a/tutorials/custom/tutorial00_tour_through_lava.ipynb b/tutorials/custom/tutorial00_tour_through_lava.ipynb new file mode 100644 index 000000000..b0ffddff9 --- /dev/null +++ b/tutorials/custom/tutorial00_tour_through_lava.ipynb @@ -0,0 +1,567 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "3ebce42a", + "metadata": {}, + "source": [ + "*Copyright (C) 2022 Intel Corporation*
\n", + "*SPDX-License-Identifier: BSD-3-Clause*
\n", + "*See: https://spdx.org/licenses/*\n", + "\n", + "---\n", + "\n", + "# Walk through Lava\n", + "\n", + "Lava is an open-source software library dedicated to the development of algorithms for neuromorphic computation. To that end, Lava provides an easy-to-use Python interface for creating the bits and pieces required for such a neuromorphic algorithm. For easy development, Lava allows to run and test all neuromorphic algorithms on standard von-Neumann hardware like CPU, before they can be deployed on neuromorphic processors such as the Intel Loihi 1/2 processor to leverage their speed and power advantages. Furthermore, Lava is designed to be extensible to custom implementations of neuromorphic behavior and to support new hardware backends.\n", + "\n", + "Lava can fundamentally be used at two different levels: Either by using existing resources which can be used to create complex algorithms while requiring almost no deep neuromorphic knowledge. Or, for custom behavior, Lava can be easily extended with new behavior defined in Python and C.\n", + "\n", + "![lava_overview.png](https://raw.githubusercontent.com/lava-nc/lava-docs/dev/walk-through-tutorial/_static/images/tutorial00/lava_overview.png)\n", + "\n", + "This tutorial gives an high-level overview over the key components of Lava. For illustration, we will use a simple working example: a feed-forward multi-layer LIF network executed locally on CPU.\n", + "In the first section of the tutorial, we use the internal resources of Lava to construct such a network and in the second section, we demonstrate how to extend Lava with a custom process using the example of an input generator.\n", + "\n", + "In addition to the core Lava library described in the present tutorial, the following tutorials guide you to use high level functionalities:\n", + "- [lava-dl](https://github.com/lava-nc/lava-dl) for deep learning applications\n", + "- [lava-optimization](https://github.com/lava-nc/lava-optimization) for constraint optimization\n", + "- [lava-dnf](https://github.com/lava-nc/lava-dnf) for Dynamic Neural Fields\n", + "\n", + "## 1. Usage of the Process Library\n", + "\n", + "In this section, we will use a simple 2-layered feed-forward network of LIF neurons executed on CPU as canonical example. \n", + "\n", + "The fundamental building block in the Lava architecture is the `Process`. A `Process` describes a functional group, such as a population of `LIF` neurons, which runs asynchronously and parallel and communicates via `Channels`. A `Process` can take different forms and does not necessarily be a population of neurons, for example it could be a complete network, program code or the interface to a sensor (see figure below).\n", + "\n", + "![process_overview.png](https://raw.githubusercontent.com/lava-nc/lava-docs/dev/walk-through-tutorial/_static/images/tutorial00/proc_overview.png)\n", + "\n", + "For convenience, Lava provides a growing Process Library in which many commonly used `Processes` are publicly available.\n", + "In the first section of this tutorial, we will use the `Processes` of the Process Library to create and execute a multi-layer LIF network. Take a look at the [documentation](https://lava-nc.org) to find out what other `Processes` are implemented in the Process Library.\n", + "\n", + "Let's start by importing the classes `LIF` and `Dense` and take a brief look at the docstring." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "f5f304d1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;31mInit signature:\u001b[0m \u001b[0mLIF\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m \n", + "Leaky-Integrate-and-Fire (LIF) neural Process.\n", + "\n", + "LIF dynamics abstracts to:\n", + "u[t] = u[t-1] * (1-du) + a_in # neuron current\n", + "v[t] = v[t-1] * (1-dv) + u[t] + bias # neuron voltage\n", + "s_out = v[t] > vth # spike if threshold is exceeded\n", + "v[t] = 0 # reset at spike\n", + "\n", + "Parameters\n", + "----------\n", + "shape : tuple(int)\n", + " Number and topology of LIF neurons.\n", + "u : float, list, numpy.ndarray, optional\n", + " Initial value of the neurons' current.\n", + "v : float, list, numpy.ndarray, optional\n", + " Initial value of the neurons' voltage (membrane potential).\n", + "du : float, optional\n", + " Inverse of decay time-constant for current decay. Currently, only a\n", + " single decay can be set for the entire population of neurons.\n", + "dv : float, optional\n", + " Inverse of decay time-constant for voltage decay. Currently, only a\n", + " single decay can be set for the entire population of neurons.\n", + "bias_mant : float, list, numpy.ndarray, optional\n", + " Mantissa part of neuron bias.\n", + "bias_exp : float, list, numpy.ndarray, optional\n", + " Exponent part of neuron bias, if needed. Mostly for fixed point\n", + " implementations. Ignored for floating point implementations.\n", + "vth : float, optional\n", + " Neuron threshold voltage, exceeding which, the neuron will spike.\n", + " Currently, only a single threshold can be set for the entire\n", + " population of neurons.\n", + "\n", + "Example\n", + "-------\n", + ">>> lif = LIF(shape=(200, 15), du=10, dv=5)\n", + "This will create 200x15 LIF neurons that all have the same current decay\n", + "of 10 and voltage decay of 5.\n", + "\u001b[0;31mInit docstring:\u001b[0m Initializes a new Process.\n", + "\u001b[0;31mFile:\u001b[0m ~/Desktop/feup/thesis/thesis-lava/src/lava/proc/lif/process.py\n", + "\u001b[0;31mType:\u001b[0m ProcessPostInitCaller\n", + "\u001b[0;31mSubclasses:\u001b[0m LIFReset, LIFRefractory" + ] + } + ], + "source": [ + "from lava.proc.lif.process import LIF, EILIF, EILIFRefractory\n", + "from lava.proc.dense.process import Dense\n", + "\n", + "LIF?" + ] + }, + { + "cell_type": "markdown", + "id": "b4dce60e", + "metadata": {}, + "source": [ + "The docstring gives insights about the parameters and internal dynamics of the `LIF` neuron. `Dense` is used to connect to a neuron population in an all-to-all fashion, often implemented as a matrix-vector product.\n", + "\n", + "In the next box, we will create the `Processes` we need to implement a multi-layer LIF (LIF-Dense-LIF) network." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "dbd808cb", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "# Create processes\n", + "lif1 = EILIFRefractory(shape=(3, ), # Number and topological layout of units in the process\n", + " vth=10., # Membrane threshold\n", + " dv=0.1, # Inverse membrane time-constant\n", + " du_exc=[0.1, 0.2, 0.3], # Inverse synaptic time-constant\n", + " du_inh=[0.2, 0.4, 0.6],\n", + " bias_mant=(1.1, 1.2, 1.3), # Bias added to the membrane voltage in every timestep\n", + " name=\"lif1\",\n", + " refractory_period=4)\n", + "\n", + "dense = Dense(weights=np.random.rand(2, 3), # Initial value of the weights, chosen randomly\n", + " name='dense')\n", + "\n", + "lif2 = EILIF(shape=(2, ), # Number and topological layout of units in the process\n", + " vth=10., # Membrane threshold\n", + " dv=0.1, # Inverse membrane time-constant\n", + " du_exc=[0.2, 0.4], # Inverse synaptic time-constant\n", + " du_inh=[0.4, 0.8],\n", + " bias_mant=0., # Bias added to the membrane voltage in every timestep\n", + " name='lif2')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "1fbfed43", + "metadata": {}, + "source": [ + "As you can see, we can either specify parameters with scalars, then all units share the same initial value for this parameter, or with a tuple (or list, or numpy array) to set the parameter individually per unit.\n", + "\n", + "\n", + "### Processes\n", + "\n", + "Let's investigate the objects we just created. As mentioned before, both, `LIF` and `Dense` are examples of `Processes`, the main building block in Lava.\n", + "\n", + "A `Process` holds three key components (see figure below):\n", + "\n", + "- Input ports\n", + "- Variables\n", + "- Output ports\n", + "\n", + "![process.png](https://raw.githubusercontent.com/lava-nc/lava-docs/dev/walk-through-tutorial/_static/images/tutorial00/proc.png)\n", + "\n", + "The `Vars` are used to store internal states of the `Process` while the `Ports` are used to define the connectivity between the `Processes`. Note that a `Process` only defines the `Vars` and `Ports` but not the behavior. This is done separately in a `ProcessModel`. To separate the interface from the behavioral implementation has the advantage that we can define the behavior of a `Process` for multiple hardware backends using multiple `ProcessModels` without changing the interface. We will get into more detail about `ProcessModels` in the second part of this tutorial.\n", + "\n", + "### Ports and connections\n", + "\n", + "Let's take a look at the `Ports` of the `LIF` and `Dense` processes we just created. The output `Port` of the `LIF` neuron is called `s_out`, which stands for 'spiking' output. The input `Port` is called `a_in` which stands for 'activation' input.\n", + "\n", + "For example, we can see the size of the `Port` which is in particular important because `Ports` can only connect if their shape matches." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "3f8f656a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Proc: lif1 Name: a_in Size: 3\n", + "Proc: lif1 Name: s_out Size: 3\n", + "Proc: lif2 Name: a_in Size: 2\n", + "Proc: lif2 Name: s_out Size: 2\n", + "Proc: dense Name: s_in Size: 3\n", + "Proc: dense Name: a_out Size: 2\n" + ] + } + ], + "source": [ + "for proc in [lif1, lif2, dense]:\n", + " for port in proc.in_ports:\n", + " print(f'Proc: {proc.name:<5} Name: {port.name:<5} Size: {port.size}')\n", + " for port in proc.out_ports:\n", + " print(f'Proc: {proc.name:<5} Name: {port.name:<5} Size: {port.size}')" + ] + }, + { + "cell_type": "markdown", + "id": "1c5da64b", + "metadata": {}, + "source": [ + "Now that we know about the input and output `Ports` of the `LIF` and `Dense` `Processes`, we can `connect` the network to complete the LIF-Dense-LIF structure.\n", + "\n", + "![process_comm.png](https://raw.githubusercontent.com/lava-nc/lava-docs/dev/walk-through-tutorial/_static/images/tutorial00/procs.png)\n", + "\n", + "As can be seen in the figure above, by `connecting` two processes, a `Channel` between them is created which means that messages between those two `Processes` can be exchanged." + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "657063e9", + "metadata": {}, + "outputs": [], + "source": [ + "lif1.s_out.connect(dense.s_in)\n", + "dense.a_out.connect(lif2.a_in)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "7f0add01", + "metadata": {}, + "source": [ + "### Variables\n", + "\n", + "Similar to the `Ports`, we can investigate the `Vars` of a `Process`.\n", + "\n", + "`Vars` are also accessible as member variables. We can print details of a specific `Var` to see the shape, initial value and current value. The `shareable` attribute controls whether a `Var` can be manipulated via remote memory access. Learn more about about this topic in the [remote memory access tutorial](https://github.com/lava-nc/lava/blob/main/tutorials/in_depth/tutorial07_remote_memory_access.ipynb)." + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "d6be4fa0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Var: bias_exp Shape: (3,) Init: 0\n", + "Var: bias_mant Shape: (3,) Init: (1.1, 1.2, 1.3)\n", + "Var: du_exc Shape: (3,) Init: [0.1 0.2 0.3]\n", + "Var: du_inh Shape: (3,) Init: [0.2 0.4 0.6]\n", + "Var: dv Shape: (3,) Init: [0.1 0.1 0.1]\n", + "Var: refractory_period_end Shape: (3,) Init: 0\n", + "Var: u Shape: (3,) Init: 0\n", + "Var: u_exc Shape: (3,) Init: 0\n", + "Var: u_inh Shape: (3,) Init: 0\n", + "Var: v Shape: (3,) Init: 0\n", + "Var: vth Shape: (1,) Init: 10.0\n" + ] + } + ], + "source": [ + "for var in lif1.vars:\n", + " print(f'Var: {var.name:<9} Shape: {var.shape} Init: {var.init}')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "971d5ed7", + "metadata": {}, + "source": [] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "7574279a", + "metadata": {}, + "source": [ + "We can take a look at the random weights of `Dense` by calling the `get` function.\n", + "\n", + "
\n", + "Note: There is also a `set` function available to change the value of a `Var` after the network was executed.\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "e60c16db", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.01388928, 0.92301965, 0.48130938],\n", + " [0.461973 , 0.03409599, 0.1083507 ]])" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dense.weights.get()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "49a7f22e", + "metadata": {}, + "source": [ + "### Record internal Vars over time\n", + "\n", + "In order to record the evolution of the internal `Vars` over time, we need a `Monitor`.\n", + "For this example, we want to record the membrane potential of both `LIF` Processes, hence we need two `Monitors`.\n", + "\n", + "We can define the `Var` that a `Monitor` should record, as well as the recording duration, using the `probe` function." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "635bf66b", + "metadata": {}, + "outputs": [], + "source": [ + "from lava.proc.monitor.process import Monitor\n", + "\n", + "monitor_lif1 = Monitor()\n", + "monitor_lif2 = Monitor()\n", + "\n", + "num_steps = 100\n", + "\n", + "monitor_lif1.probe(lif1.v, num_steps)\n", + "monitor_lif2.probe(lif2.v, num_steps)" + ] + }, + { + "cell_type": "markdown", + "id": "ce0c6495", + "metadata": {}, + "source": [ + "### Execution\n", + "\n", + "Now, that we finished to set up the network and recording `Processes`, we can execute the network by simply calling the `run` function of one of the `Processes`.\n", + "\n", + "The `run` function requires two parameters, a `RunCondition` and a `RunConfig`. The `RunCondition` defines *how* the network runs (i.e. for how long) while the `RunConfig` defines on which hardware backend the `Processes` should be mapped and executed." + ] + }, + { + "cell_type": "markdown", + "id": "9a43d818", + "metadata": {}, + "source": [ + "#### Run Conditions\n", + "\n", + "Let's investigate the different possibilities for `RunConditions`. One option is `RunContinuous` which executes the network continuously and non-blocking until `pause` or `stop` is called." + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "0cf86c34", + "metadata": {}, + "outputs": [], + "source": [ + "from lava.magma.core.run_conditions import RunContinuous\n", + "\n", + "run_condition = RunContinuous()" + ] + }, + { + "cell_type": "markdown", + "id": "865e2ca9", + "metadata": {}, + "source": [ + "The second option is `RunSteps`, which allows you to define an exact amount of time steps the network should run." + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "91fbce5e", + "metadata": {}, + "outputs": [], + "source": [ + "from lava.magma.core.run_conditions import RunSteps\n", + "\n", + "run_condition = RunSteps(num_steps=num_steps)" + ] + }, + { + "cell_type": "markdown", + "id": "2366d304", + "metadata": {}, + "source": [ + "For this example. we will use `RunSteps` and let the network run exactly `num_steps` time steps.\n", + "\n", + "#### RunConfigs\n", + "\n", + "Next, we need to provide a `RunConfig`. As mentioned above, The `RunConfig` defines on which hardware backend the network is executed.\n", + "\n", + "For example, we could run the network on the Loihi1 processor using the `Loihi1HwCfg`, on Loihi2 using the `Loihi2HwCfg`, or on CPU using the `Loihi1SimCfg`. The compiler and runtime then automatically select the correct `ProcessModels` such that the `RunConfig` can be fulfilled.\n", + "\n", + "For this section of the tutorial, we will run our network on CPU, later we will show how to run the same network on the Loihi2 processor." + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "14c301f7", + "metadata": {}, + "outputs": [], + "source": [ + "from lava.magma.core.run_configs import Loihi1SimCfg\n", + "\n", + "run_cfg = Loihi1SimCfg(select_tag=\"floating_pt\")" + ] + }, + { + "cell_type": "markdown", + "id": "baf95f1f", + "metadata": {}, + "source": [ + "#### Execute\n", + "\n", + "Finally, we can simply call the `run` function of the second `LIF` process and provide the `RunConfig` and `RunCondition`." + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "331f71b7", + "metadata": {}, + "outputs": [], + "source": [ + "lif2.run(condition=run_condition, run_cfg=run_cfg)" + ] + }, + { + "cell_type": "markdown", + "id": "1d8ea488", + "metadata": {}, + "source": [ + "### Retrieve recorded data\n", + "\n", + "After the simulation has stopped, we can call `get_data` on the two monitors to retrieve the recorded membrane potentials." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "582215cd", + "metadata": {}, + "outputs": [], + "source": [ + "data_lif1 = monitor_lif1.get_data()\n", + "data_lif2 = monitor_lif2.get_data()" + ] + }, + { + "cell_type": "markdown", + "id": "22f44fba", + "metadata": {}, + "source": [ + "Alternatively, we can also use the provided `plot` functionality of the `Monitor`, to plot the recorded data. As we can see, the bias of the first `LIF` population drives the membrane potential to the threshold which generates output spikes. Those output spikes are passed through the `Dense` layer as input to the second `LIF` population." + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "32f48b10", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABRoAAAHWCAYAAAAYQDX3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8WgzjOAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydZZgc55W274ZhZo1GMGJmliVZtmWQMXbsxI7jOHE2sMlmAxvcL8k6tA5t1oENO2DHjmOImWTLFllkMUsjaUjDzNNY34/q6unRUENVw8y5r0vXlLqrq96pt7um66nnnMekKIqCIAiCIAiCIAiCIAiCIAhCCJgjPQBBEARBEARBEARBEARBEGIfERoFQRAEQRAEQRAEQRAEQQgZERoFQRAEQRAEQRAEQRAEQQgZERoFQRAEQRAEQRAEQRAEQQgZERoFQRAEQRAEQRAEQRAEQQgZERoFQRAEQRAEQRAEQRAEQQgZERoFQRAEQRAEQRAEQRAEQQgZERoFQRAEQRAEQRAEQRAEQQgZERoFQRAEQRAEQRAEQRAEQQgZERoFQRAG4S9/+Qsmk4mysjIANm7cyMaNG/utU1dXx5133klOTg4mk4mHH3447OMUBEEQBEEQRi/ynVQQhFhDhEZBEIQg+eIXv8gbb7zBN77xDR577DFuuOEGAH7wgx9w6623UlBQgMlk4sEHH4zsQAVBEARBEIRRy2DfSc+cOcNXv/pVFi9eTFpaGoWFhdx0000cOHAg0sMVBGGUY430AARBEGKBLVu2DHjs7bff5rbbbuPLX/5yv8e/+c1vMm7cOJYsWcIbb7wRriEKgiAIgiAIoxx/v5N++ctf5pFHHuH9738/n/nMZ2hra+N3v/sdq1ev5vXXX2fTpk3hHLYgCGMIERoFQRD8ID4+fsBj9fX1ZGZmDni8tLSU4uJiGhsbycvLC8PoBEEQBEEQhLGAv99J77nnHh588EFSU1O9jz3wwAPMmTOHBx98UIRGQRAMQ0qnBUEQ/MC3H47WK0dRFP7v//4Pk8mEyWTyrltcXByZQQqCIAiCIAijGn+/ky5btqyfyAiQk5PD+vXrOX36dLiHLQjCGEKERkEQhADZsGEDjz32GADXXnstjz32mPf/giAIgiAIghAOgvlOWltbS25ubjiGJwjCGEVKpwVBEAJk6tSpTJ06lfvuu4+ZM2fy4Q9/ONJDEgRBEARBEMYYgX4n3blzJ3v27OGb3/xmmEYoCMJYRByNgiAIgiAIgiAIgjCKqa+v50Mf+hBTpkzhq1/9aqSHIwjCKEYcjYIgCIIgCIIgCIIwSunq6uLmm2+mo6ODXbt2DejdKAiCoCciNAqCIAiCIAiCIAjCKMRut3PHHXdw7Ngx3njjDebPnx/pIQmCMMoRoVEQBEEQBEEQBEEQRhlut5uPfOQjbN26laeeeoorr7wy0kMSBGEMIEKjIAiCIAiCIAiCIIwyPve5z/GPf/yD3/3ud9xxxx2RHo4gCGMEERoFQRB05rHHHqO8vJzu7m4AduzYwfe//30A7rvvPiZPnhzJ4QmCIAiCIAijnIcffphf//rXrFmzhuTkZP72t7/1e/72228nJSUlQqMTBGE0I0KjIAiCzjzyyCNs377d+/933nmHd955B4B169aJ0CgIgiAIgiAYypEjRwDYs2cPe/bsGfB8aWmpCI2CIBiCSVEUJdKDEARBEARBEARBEARBEAQhtjFHegCCIAiCIAiCIAiCIAiCIMQ+IjQKgiAIgiAIgiAIgiAIghAyIjQKgiAIgiAIgiAIgiAIghAyIjQKgiAIgiAIgiAIgiAIghAyIjQKgiAIgiAIgiAIgiAIghAyIjQKgiAIgiAIgiAIgiAIghAy1kgPwGjcbjfV1dWkpaVhMpkiPRxBEARBEISAURSFjo4Oxo8fj9ks94ljDfk+KgiCIAhCrOPv99FRLzRWV1czceLESA9DEARBEAQhZCorK5kwYUKkhyEEiHwfFQRBEARhtDDS99FRLzSmpaUB6oFIT0+P8GgEQRAEQRACp729nYkTJ3q/1wixhXwfFQRBEAQh1vH3++ioFxq18pT09HT5YicIgiAIQkwjZbexiXwfFQRBEARhtDDS91Fp8iMIgiAIgiAIgiAIgiAIQsiI0CgIgiAIgiAIgiAIgiAIQsiI0CgIgiAIgiAIgiAIgiAIQsiI0CgIgiAIgiAIgiAIgiAIQsiI0CgIgiAIgiAIgiAIgiAIQsiI0CgIgiAIgiAIgiAIgiAIQsiI0CgIgiAIgiAIgiAIgiAIQsiI0CgIgiAIgiAIgiAIgiAIQsiI0CgIgiAIgiAIgiAIgiAIQsiI0CgIgiAIgiAIgiAIgiAIQshEVGjcsWMHt9xyC+PHj8dkMvH888/3e15RFL797W9TWFhIUlISmzZtoqSkJDKDFQRBEARBEARBEARBEARhSCIqNHZ1dbFo0SL+7//+b9Dnf/zjH/OLX/yC3/72t+zbt4+UlBSuv/56ent7wzxSQRAEQRAEQRAEQRAEQRCGwxrJnW/evJnNmzcP+pyiKDz88MN885vf5LbbbgPg0UcfpaCggOeff5677747nEMVBEEQBEEQBEEQBEEQBGEYorZHY2lpKbW1tWzatMn7WEZGBqtWrWLPnj1Dvs5ms9He3t7vnxBDnHoBHv8AdDVGeiRCKOz7PTx1PzjtkR6JECyKAm89CK/8h7osxCZOO7z4Odjx00iPRBAEQRAEQRCigoPlLdz9+z38bMtZatp6Ij2cUUfUCo21tbUAFBQU9Hu8oKDA+9xgPPTQQ2RkZHj/TZw40dBxCjrSdAH++UkoeQNKtkR6NEKwlO2C174Cp56HqgORHo0QLEf/Drv+F977I3TURHo0QrDs/CkcehS2/zjSIxEEQRAEQRCEiFPf3sunHjvI3ovN/OLt81zxw7f5xKMH2H6uAbdbDBZ6ELVCY7B84xvfoK2tzfuvsrIy0kMS/MHtguc/A05P/02XOOFiEnsXvPDZvv/LPMYm7dXw2tf7/i/zGJvUHIWd/6MuyxwKgiAIgiAIYxyny83n/n6Yxk4b0/NTWT01G7cCb56q4/4/7eeq/9nG9nMNkR5mzBO1QuO4ceMAqKur6/d4XV2d97nBSEhIID09vd8/IQbY/3uo3Nv3f7fLsF112Zz8x1NHueHhHbT1OAzbz5hk63ehpazv/wbOY7gob+rirt/u5vNPHo70UMKDosBLXwBbW99jo2Aew8U7Z+q5+n+28diessgOxGlXb964nZ4HFHC7IzokQRAEQRAEQYgk//PmOfaVNpOaYOX39y3jyU+u4c0vbuCja4tJS7BS3tTNv3uESCF4olZonDJlCuPGjWPr1q3ex9rb29m3bx9r1qyJ4MgE3Wm6AG99R12OT1N/GiRsVDZ38/7f7ObZQ5c4U9vBiaq2kV8k+EfZu7Dvt+pyfKr6M8YFqp0lDdz6q3d5r6yFF45Ujw0r/dEn1fYFlngwx6mPxfg8hgNFUfjt9gs88Nf3uNjQxcvHIlxuvvN/oO5E3zkVQJF5FARBEARBEMYmW0/X8ZttFwD40fsXMjVPvWadUZDGg7fOY9//u4Z549Np63Hww9fORHKoMU9EhcbOzk6OHDnCkSNHADUA5siRI1RUVGAymfjCF77A97//fV588UWOHz/ORz7yEcaPH8/73ve+SA5b0BO3Wy21dfbAlA0w83rP487hXxcEuy80cuuvdnGmtsP7mGssCEfhwLdkeun9kDdbXTZgHsOBoij8cedF7v/T/n6uV9doD0Vpr4HXv6Yub/wGJGaoyzE6j+Gix+7i808e4YevnfHm5rgj+V6pOab2ZgS44aG+x2UeBUEQBEEQhDFIZXM3X/zHEQA+uraYmxYWDlgnOd7K9983H5MJnjl4if2lzWEe5eghokLjgQMHWLJkCUuWLAHgS1/6EkuWLOHb3/42AF/96lf53Oc+xyc/+UlWrFhBZ2cnr7/+OomJiZEctqAn+38PFXsgLgVu/RVYNAeVfhfEiqLw6J4y7ntkPy3dDhYUZTApOxkQoVE3tn4PWkohfQJc930wW9XHY1DY6HW4+PLTx/j+K6dxK/T7IzSq3y+KAi9/AXrbYPwSWPvvMT2P4aK6tYe7frebF49WYzWbuH6eGmDmjNR7xbdkes6tsODOvudkHgVBEARBEIQxhs3p4rNPHKK918niiZn8541zhlx3yaQs7l4xCYBvPn8ch0taDwVDRIXGjRs3oijKgH9/+ctfADCZTHz3u9+ltraW3t5e3nrrLWbOnBnJIQt60nQB3npQXb7uu5A1GUwW9f86lfg5XW7+87kTfPuFk7jcCrctHs/Tn15Ddkq8+vxoFo7CRfnuvpLpW38Oielg1ncew0VDh427f7+XZw9dwmyCb908l5/eucj7/Kh+vxz7B5x7XS2Zvu3XYLHG7DyGi8MVLdz6q3c5UdVOdko8f/uXVXxwxUQggqL0rp9B3XFIyoab/qdPLAYpgRcEQRAEQRDGHL/YWsKxS21kJcfxf/cuJd46vAz21etnkZ0Sz7m6Tv78bmmYRjm6iNoejcIoR1Hgpc+rJdPF62HZA+rjmrChg/Omx+7iU48d5O/7KzCZ4BubZ/PwBxeTGGfBajYBo9yhFg4cvfDCvwEKLLkPpm9SH/fOY+wIG+VNXdz5290cqWwlIymORx9YxcfXTcFqMXnXGbXvl856eO2r6vKVX4OCuepyDM5juHjnTD33/GEvjZ025hSm88Jnr2D11BwsZvXPakTeK3UnYcdP1OUbfwKp+X03b0DmURAEQRAEQRhTKIrC84erAfjObfMpykwa8TVZKfF8fbPaCuzht0qobu0xdIyjEREahchw/Gko2wnWJLjtV+C5OO8r1Qztgri12869f9zL1jP1JFjN/O7Dy/jUldMwmVTRyCJCoz7s/gU0X4C0Qrj+B32Px1jJ7YmqNt7/m92UN3UzISuJ5z6zlnUzcgGwmMaA0Pjmf6kl04WL4Iov9D0eY/MYLp45eIl/efQAvQ43V87M45lPr2Gipx1DxG5iKAq88mV1rmbfDPPfrz5uNoPJc36VeRQEQRAEQRDGEGVN3VS19hBnMbFpTr7fr7tz6QSWT86i2+7iey+fMnCEoxMRGoWQaOxpxK0E2Legtx22fFNd3vBlyCrue04HYaO6tYc7f7uHQxWtpCdaefxfVnHdvHH91tFcak537PVcaOltweF2jLyi4QMpV5NtQe3LqAWHQEwJVLvPN3L37/fS2GlnTmE6//zXtd4EMgCz2YTZ0gMmR0y+X0akYh8cfUJdvulnasm0RgTnsdvRTae9M+z7HQ4tWfrLTx/F5Va4Y0kRf7x/OSkJfcdMu4kR9jL7409DxW6IS4Ybfgg+Arm/8+hwO2jpbTFwkIIgCIIgCIIQPnaWNACwfHI2yfHWEdbuw2w28b33zcdiNvHaiVreOVtv1BBHJSI0CkGzrXIbVz91Nb85+pvAXrj9R9BZB9nTYO3n+j8XorBxrq6DO369m/P1nYxLT+SZf13L8uLsAeuZTbHpaCxpKeH6Z6/nazu+FumhwBv/Cc5etfRdc09pxIjQ+PKxau7/8346bU5WT83mH59aTX56/7CpNlsbyVP/l+Qpv4y598uIuF3w6n+oy0vugwnL+z8foXl0K24+9sbHuO6Z66JGbHS7Fb738ml++NoZAD61YSo/vWsRcZb+f0Yj4pb2vXmz/j8gc2L/5/2cx2+/+22u/MeVXGi9YMAgBUEQBEEQBCG87DjXCMD6mbkBv3ZOYTofW1sMwPdeOoV7tF0LGogIjULQ/OnEn1BQKGkp8f9F9adhr0eY3PxjsCb0f14roQ6idPr4pTbu+u0eatt7mZ6fyrOfWcvMgrRB17VGynUUIo+ffpweZ09gx9wISt6EMy+rAsaNP+nvngKfUs3o7Qn35P4KPvf3wzhcCjcuGMdfPraS9MS4Aeu9eOFFTNZ2LAn12J3R+/sExYE/Qe1x1Y266cGBz5si06NxT/UeTjWdosPRQW1XbVj3PRgut8JXnjnGnzzNoL950xy+ceMczGbTgHX7HI1hdL8Od/MG/ArZquqs4pWLr6CgcL71vEEDFQRBEARBEITw4HC52XNBFRo3zMgLahtfuHYmaQlWLjZ2sftCk57DG9WI0CgExfmW8xyuPwyAy18RQlHg1a+oF7uzb4YZmwauE2SPxhNVbXz4kX209ThYPDGTpz+1ZthGrxENbAiSTnsnr5a+CoArkinATltfcMiqT0P+nIHr6NRr0yj+8V4FX//ncRQFPrx6Er+8ZymJcZYB6ymKwtPnnvb+3+6KbodmQHQ2wNvfU5ev/hakDHKXL0JhML7HPKLvddRzxFefOcazhy5hMZv43w8u4l/WTx1yfW+PRleYzi11p4a/eQN+zeOz555FQR2z3+d0QRAEQRAEQYhSDle00mV3kZ0Sz9zC9KC2kZpg5X1LigB4Yn+5nsMb1YjQKASFrxDgVPwUX0486wmASYTr/3vwdYIo1TxR1ca9f1RFxqWTMnns4yvJSokf9jWxmDr9aumr9DjVxKuICgG7fwHNFyF1HGz8+uDrRHHp9FPvVfL1fx4H4KNri/nebfO9LrTLOVh3kNK2Uu//HVH4+wTNWw+qATDjFsLyBwZfJwLzWN9dz7bKbd7/+31+MQCXW+Frz/aJjL+4ewm3L5kw7Gu8pdNKGM4t/ty8gRHn0eF28Nz557z/j7S4KwiCIAiCIAihovVnXDc9d9BKJH/50KpJAGw5WUd9R68uYxvtiNAoBEyPs4eXLrzk/b9fopeto38PsazJg68XoLBxsrrPybhkUiZ/fWAlaYOUv16OxRJbQuPlzrqIiS+tFbDDJwAmYfDS9GgVGp86UMnX/nkMRVFFxv+6Za43iXwwfI85jCJHY+V+OPI3dfmm/+lzvF1OBObxuZLn+gldkRLV3W6Frz97jGcOqiLjz+9ezE0LC0d8nTWcbukTz0L5ruFv3sCI87i9cjuNPY3e/zuj7HMrCIIgCIIgCIGyo8TTn3FG4P0ZfZlTmM6SSZk43QrPHLykx9BGPSI0CgHzRtkbdDg6vP/3y/2y/UfQUQNZU2Dtvw+9nh+9xDROVbdz7x/30dqtlkv7KzJC7PVoPNF4gjPNZ7z/j5ij8fVvgLMHJq+DBXcOvZ7Z/3kMF88cvMTXnlVFxvvXTB5RZGzpbeHN8jf7PWZ3jgIBxu2CV7+sLi/+MExcOfS6YZ5Hl9vFsyXP9n8sAu8ht1vh6/88xtMekfHhDy7m5oXj/Xpt2FKn+928+fLQN29gxNLpywV1cTQGRmu3PWZuWgmCIAiCIIwFWrvtHLvUCsD6IPsz+vKhlaqr8cn9lRIK4wciNAoBo12UzslWe/ON6H5putC/h1hc4tDrei+Ih9/muboO7v3jXq/I+OjHBw/yGAqLN3U6jIENIXD5MY+IEFC6Qw2AMVkGD4Dxxc95DBfPH67iK88cRVHgI2sm8+Ct84YVGUENgXG4Hd5jDqPE0Xjkcag5OnQAjC9h7tH4bvW71HTVkB6fTlGq2gsl3O46RVH4f8+f4KkDlzCb4OEPLuaWRf6JjOBTOm10j8Zd/+tz82aQABhfhpnHyo5KdlfvBnzOL9Kj0W86eh3c84d9fObxg/Q65LgJgiAIgiBEA++eb0JRYGZBKuMyhtEf/OTmheNJS7RS0dzNrvONI79gjCNCoxAQZ5vPcqzhGFaTlTtnqo62EUWvt7+vCk7TN8HM64Zf148QkZq2Hu7/035auh0sCkJkhDC6jnSg3d7O62WvA3DP7HuACAgBigJvfltdXv4AFMwdfv0oCoPZca6BLz991Bv88h0/REbfUvUPzPoAKOqp0u5yGD5eQ7F3wzsPqcsbvgqpI9zdC3PptHbMb512K0lWNcwp3KL6/75Vwt/3V2A2wf8GKDJCmNzS7TWw59fq8nXfH/7mDQw7j8+eUx2ka8evZVK6eqc2kn0xYwmb08Wn/3aQ0zXtHCxvpbHTFukhCYIgCIIgCPj2ZwzdzQiQFG/hDk8ozN/3V+iyzdGMCI1CQGhCwFWTrqIguQAYQfSqOgQn/wmYRnZPwYjCRlu3g/v/tJ+atl6m56fy14+tCFhkBLB6ejTGgu355Qsv0+PsYXrmdJYXLAciIASceh6qD0N8Klz5tZHXj5IejccvtfHpvx3E6Va4bfF4vnvr/BFFRoD9tfspby8nJS6FG6fciHaqjPnedft/Bx3VkDEJVn5i5PXDOI+1XbXsuLQDgLtm3oXVs+9wiuqP7yvnF1tLAPj++xZw2+KigLcRljCY7T9UWxhMXAWzbxp5/SHm0eHqC4G5a+ZdWDytK8TRODJut8KXnz7Gu+ebSIm38JePrWBCVnKkhyUIgiAIgjDmURSFnVp/xpmh9Wf05UOr1FZFb56SUJiREKFR8JtuRzevXHwF8FyUesrxhnQcKQq89V/q8sIPwrgFI+9kGGGj1+HiE48e4FxdJwXpCfz1gZVkJg+fLj0UseJo9HXW3TnzTq/44lbCWPLtcsDW76rLaz83sgsOokJoLG/q4mN/2U+33cW66bn85M5FfqeNacf8pik3kRyXjAnN0RjDAkx3M+z8X3X56v8H1oSRXxPGeXyu5DnciptlBcuYmjm1T/QKk6PxjZO1fOv5EwB8/poZ3nS5QDE80b7hHBx6TF3e9J3hWxhoDDGPWyu30tzbTG5SLldOvDIy55cY5b9fPc1LR6uxmk389r5lzC/KiPSQBEEQBEEQBOBiYxdVrT3EW8ysmpKt23ZnjUtj2eQsnG6Fpw9IKMxwiNAo+M3rZa/T6ehkYtpEVhWuGlkIuPC22tfPEg9X/ad/O/Ektl5ecutyK3zhySPsL2smLcHKXx9YSVFmUrC/SniTYUPgaMNRzreeJ9GSyC3TbukTd8PpODr0KDRfhJQ8WPNZ/15jGnwew0Vjp437/7Sfxk47cwvT+c2HlxJv9e9019TTxNaKrQDcNesu9UFFPe6OWO7RuOtnYGuDgvmw4C7/XhOmeXS6nd4QmLtmqmML53v9QFkz//73w7gVuGflRL6waUbQ27L4CI2KEa7Gt7+rhvPMuhEmr/HvNUOEbD1z9hkAbp9+O3HmOO85XUqnh+cPOy7yx12lAPz0rkW6NBgXBEEQBEEQ9GGXx824vDiL5HirrtvWQmH+vr8iJqojI4UIjYLfPH22z1lnNpmHL210u/vcjCs+MXwiqi+D9PZTFIXvvHSS10/WEm8x8/uPLGf2uPSgfw8Asyk2HI2as+764utJj0/vJwQYImJcjq0Ttv1QXd7wVUhI8+91EezR2GVz8vG/vEdZUzcTspL4ywMr/E4jB3j+/PM43U4W5C5gdvZsAK+jMWaFxtZK2Pd7dXnTg33hICMRpnncVbWLuu46MhMyuXbytQBYTZ7zi8GOxpK6Dj7+1wPYnG42zcnne7f5V14/FBYf16zuNzIq34PTL6kC8DXf9v91g4TBlLeXs692HyZM3n67EbmREWO8cKSKH7x6GoBvbJ7N+5YEXl4vCIIgCIIgGIfWn9GIm8E3LSwkPdHKpZYedkoozJCI0Cj4xemm05xoOoHVbOW2abcBDO9oPPEs1B6HhHRY/x/+72iQEr8/7izl0T3lmDzhDGum5QT9e2hoPRqj2dHYZmvjjbI3gD5nnSbuQpjKG/f+BrrqIasYln3U/9dFqHTa7Vb4/JOHOXqpjeyUeB59YCX5af6njLkVN8+cU11emrNOxeNojNUejdseApcNiteroUz+EqZ51AT126bdRrxFbYegiV5GuusaO2189M/v0dbjYMmkTH55z1KsltD+LPoKjbreyPANZFr8IcifM/z6vgwyj9r7/IqiKxifqgbehLtcPdbYd7GJLz99FIAHrpjCJzdMjfCIBEEQBEEQBF/sTjd7LjQBsH6Gfv0ZNRLjLNyxdAIAT+wr1337owURGgW/0MoaN03aRE6SKvR5hYDLRQinTS3vA7ji85ASgDB42QXx9nMNPPSa6h755k1zuWlhYZC/QX+8PRpd0Ss0vnLxFWwuGzOzZrIwdyHQJwRAGMSArkZ49+fq8tXfAmsA/TAjJDT+7M1zvHW6ngSrmUfuX87UvNSAXv9e7Xtc6rxEalwq1xdf7328r0djDAqNdSfhyBPqsr89/TTCMI+1XbXsqtoF4HXWAYYHkzhcbj7z+CGqWnuYkpvCn+5fQVK8n07PYdDaMoDONzJKtkDFbrAmwsZvBPbay+bR4XbwwvkXgP6CunYjI+ZDjwygqrWHzzx+CIdL4aYFhXzzpjkhOV8FQRAEQRAE/Tlc0UKX3UVOSjxzC0OrghyKez293N86XU9jp82QfcQ6IjQKI+JwOXi97HUAbp9xu/fxIUsbD/wZWisgdRys/tfAduZzQVzW2MXnnjiEW4EPLp/IA1cUB/srDEALbHCHo/w4SF668BIAd8y4w3tBa/EpeTVcDNjxU7B3QOEimHdHYK+NgND46vEafvXOeQB+9P6FLJmUFfA2XrzwIgCbp2wmOa4vQdaEJqrHoNNr63cBBebeBhOWBfbaMMzjq6Wv4lbcLM1fSnFGsffxEcOmQuR7L59if2kzqQlW/vCR5WSlBBcsdTn9Sqf1Or+4XfDWg+ryqk9BxoTAXn/ZPL5b9S4tthZyEnPYMGGDdzVxNA5Or8PFpx47QFOX2vP1p3f5HywlCIIgCIIghA8tbXrdjFzDvq/NKEhj4YQMXG6FLSfrDNlHrCNCozAiO6p20GZrIz8pn1XjVnkfN5u0QBWfi1JbB+z4sbq88esQnxLYzrRtulx88rEDtPc6WTIpk+++b56u7pG+1OnoTFctbSvlRNMJLCYLNxTf4H08bI7GljJ474/q8qbv9IX0+Iu2fpgEizO17d6Sxk+snxJU37QeZw9vlb8FwC3Tbun3nAn1/RJzpdPlu+Hc62oYyNUB9PTTMHgeFUXxCuqXH3MjHY3/eK+CR/eopQ4Pf3Ax0/MDc74Oh9VXaNTLMX3sH1B/ChIzYN0XA3/9ZSFb2jHfPGVzv3YMRrtIYxFFUfj6s8c4UdVOdko8v//IMl2cr4IgCIIgCIL+aH0TjQ7r2zxfrbR87USNofuJVURoFEbk5QsvA3Dj1Bv7OeoG7aG2/w/Q3QQ502HJfYHvzHPRe7G+jXN1neSnJfDbDy8jwarvhZ3VHN09GjUh4IqiK7yl6nCZ0GikGLDzZ+B2wNSNMO2qwF8fxjCY1m47n3j0AN12F+um5/K1G2YHtZ23K96m29lNUWoRi/MW93vOZIrR1OltD6k/l34EcqcH/nqD5/Fsy1nOt54nzhzHdcXX9XvOqATkQxUtfOv5kwB86dqZbJpboOv2zWaTtzpdlx6NLids99y8WfclSArcqes7j+32drZVbgMGEXcNdpHGIo/sKuX5I9VYzCb+70NLmZCVPPKLBEEQBEEQhLDjdiucrW0HYOmkTEP3tXn+OAB2X2iipctu6L5iEREahWFps7Wx/dJ2AG6eenO/5waUTtu7YM+v1OUNXwFLEFHyngviju4e4i1mfnvfMgrS/Q/z8Hs3Udyj0a24ebX0VWDgMddcpGBgSEbbpb6efoH2gtMIU+m00+Xm3544TGVzDxOzk/jlPUuCDvN4+aIqqN889eYB7lkzQ/QjjWYq9kHpDnUuAglk8sXgedRuYmycuJH0+P49VIZNtQ+SuvZePv3YQewuN9fPK+DfrgpCfPUDi0nHGxkn/wktpZCUDSs/Edw2fObxrfK3sLvtTM2Yypzs/oEyXnE3lt7nBrKzpIH/9iRMf+umOboEkQmCIAiCIAjGUNfRS6/DjdVsYmK2sTeHi3NTmFOYjsut8OZpKZ++HBEahWHZUr4Fh9vBjKwZzMqe1e85r/tFEwIO/lV1M2ZOhvl3Xr4pvzhS1aFuGzffvW0eS4Pos+cP0exoPFx/mKrOKlLiUrhqYn83oclk6hN4jXILvvsL1c1YvB4mrQ5uG2ESGn/0+hl2nW8kKc7C7+8Lvs9eY08je6r3AANdXtAXBhNTpdM7f6r+XHQPZE4MbhsGzqPL7RpSUAf9+wXanW4+/beD1HfYmJGfyv98YLFhfVt0a83gdqu9UgHWfDbwVhQaPvPoW6p+uaAujsY+Kpq6+bcnDuNW4M5lE7h/bXGkhyQIgiAIQozTY3fx623n+c/njosLzgBKG7oAmJidTFyQ5pNAuNHjanztuJRPX44IjcKwaI6jW6YOFF/6CQGOXtj9C/WJ9V8Kys1Y3drD73aqfdPyUqzcvXJSkKMeGYunZ5luYQ06ogkB106+lkTrQDenJga4FQP6S3bUwaG/qssbvhz8drQSewNLp986VccfdpYC8NO7FjEnhFSx10pfw6W4WJi7kMnpkwc8b4q13nXVR9SUYpM5uJ5+Gqb+vf30ZF/NPhp6GshMyGR90foBzw+4kREiP3njDIcrWklPVMNfUhOCcFz7iTdsKtSP6JmXoPEsJGQE72YE7zxW21o4UHcAgJum3DRgNe0mhiHnlhjC7nTzub8foq3HwaKJmXz/ffMlYVoQBEEQhKBxuxWeOXiJjT99hx+/fpYn9lXwvl+/y/n6jkgPbVRR2qQKjVNyg7w5HyCbF6h9Gnedb6StxxGWfcYKIjQKQ3Kp4xKH6g9hwsSNU24c8Hy/0sYjj0NHDaQXqQ6qAHG5Fb7wjyO02VXhb1yacSIA9AkBuvRQ0xGby8aWsi3A4C4vMK53HaCWvjt7YcIKmHJl8NsxGSs01rX38pVn1PCXj11RzE0LC0Panibu3jxt8GOulU47YkVo1NyM8++EnGnBb8fAHo0vXVSP+fXF1xNniRvwvJ6Oxm1n6/uJ0sUGf/nQxdGoKLDjJ+ryqk+pQTDB4pnHV1pPAbBi3AoKUwd+Zrx9d2PJuWsAP3vzHEcvtZGeaOXX9y4lMU7CXwRBEARBCI7d5xu5+Ze7+PLTR6lrtzEhK4kJWUmUN3Vz+693s+NcQ6SHOGrQHI3FOeERGqfnpzKzIBWHS2GrlE/3Q4RGYUi0nnWrCldRkDIwMKGfELDrYfXBKz4P1oSA9/V/75xnf2kzcVZVcDAbLOhoQoBuqbA6sePSDjocHRQkF7Bi3IpB19Hb6eWluxnee0Rd3vAVCMXBY2jJrcIX/3GElm4HcwvT+frm4MJfNC60XuB082msJmu/hG9ftN6YMSHA1J+G06qIF3RvRg2D5rHb0c3Wiq3A4KXq4HMjI0ShsaHD5k0k/8iayVw3b1xI2/MHrU9oSK0ZSrZA7XGIS4HV/xragMxWFOClNrXf4GAOddC/XD0W2VXSyO92XADgR+9fSFFmUoRHJAiCIAhCLKIoCl9++igf+uM+TtW0k5Zo5RubZ/PWl67khc9ewYriLDp6nXzsL+/x191lkR7uqKBMczTmhUdoBLjBmz5dG7Z9xgIiNAqDoihKv3CMwfDt56W0VUBKvppuGyAHypr5+dYSAD623hPOYLCgY4lSR6PmrLtp6k39gl98GRDCoxd7fw2OLhi3EGZcN/L6w2Gg0Pi7HRfYfaGJpDgLv/zQkpATybX3+bqidWQlDt4T1OQNg4kBAWbn/6g/59wK+aGJsEbN49aKrfQ4e5iUNomFuQsHXUePYBK3W+E/nj5KY6ed2ePS+M8b54z8Ih0wm0I8vyhKX9L0io9DcnaIA7JyKj6OUnsrCZYENk3eNOhqRgTwxBJNnTa++NQRFAXuWTnJWw4jCIIgCIIQKAfLW3jm4CUsZhP3r5nM9q9cxaeunEZinIWc1AT+9i+reP/SCbjcCv/14km+9fwJnK6x3b4mVC42eoTGMDkaAW5coJoYtp9roNMWA6aUMCFCozAoxxuPU95eTqIlcciLUk0IAHABrP0cxAXm/mjrcfD5J4/gcivcvqSIjXPGq0+ESWh0hdxETT9ae1vZWbUTGNpxBAaVN/a0wr7fqcuhuhnBMIHqUEUL/7PlHADfuXUe0/JSQ9qeW3HzysVXgKHLpiGG0nibLsCJZ9XlDV8JfXsGzeNwCd8aerjrHtlVyo5zDSTGmfnlPUvCVgIbctjUxW1QdQCsiep5NVTMVl5OVb9wbZy4kbT4tEFXM7QtQ5SjKApfeeYYDR02puen8u2b50Z6SIIgCIIgxDBP7KsA4I4lRXzntvlkXxZamWC18NO7FvL1zbMxmeCxveX8cVdpJIY6KnC63FQ2dwPhdTTOKkhjam4Kdqebt8/Uh22/0Y4IjcKgaELA1ZOuJiVu8A+q5n4BcCVlwfIHAtqHoij85z+PU9Xaw+ScZL5727y+8AmDwwiisUfj62Wv43Q7mZ09m+lZ04dcz5Dyxvf+ALZ2yJsNs4cW3PzGrP88tvc6+PyTh3G5FW5eWMhdyyeEvM2DdQep6aohLS6NjRM3Drlen6MxygWYXT9Tj/nMG6BwcKdgQHjnUb/3WkN3A3tr9gJDu6UhdHfd8Utt/PiNMwB8++Z5zCgYXFwzgpAd01rS9LKPQmp+yONxmuBVj9Doz02Mseho/MvuMt4+U0+8VRWlk+KlL6MgCIIgCMHR2m3nZU8S8YdWDR1wajKZ+PSV0/j+++YDajsxSaMOjqrWHhwuhQSrmcL0gYGqRmEymdi8QNKnL0eERmEADreD10tfB4bunwZgUfqcSK6Vn4SEwNxlTx2o5JXjNVjNJn5x9xLSEuMMLbn1RRMC3FGUOj1SqbqG7uWNtk7Y82t1ef2X+8SlUNB5HhVF4VvPn6CyuYcJWUn84PYFuqTAasf8uuLrSLAM3VtUK2OP6t51rRVw9El1eX0IieG+GBAG82rpq7gVN4vzFjMxfeKQ64XiruuyOfn3Jw/jcClsnj+Oe1YOvR8jsFpCcDSW74byXWCOg7X/rst49rjaabZYyDYnsLZo7ZDrGdaWIco5Vd3OQ6+qovQ3b5oTUoK9IAiCIAjCs4eqsDvdzClMZ/HEzBHXv3vFJOYUptPR6+SXb583foCjkNLGviAYszn068RA2Ozp07jtbAPd9ig3poQJERqFAbxb9S4tthZyEnNYXbh6yPUsJVu8y86l9wW0j8rmbr7zkpqA+uXrZ7FIOwGHSWi0esQ0Z5SEwVS0V3C04Shmk3nQhG9fdBe9Dv4FepoheyrMu12fbeo8j68er+WFI9VYzCZ+fvcSMpIGphQHSq+zd8SEb42+0ukoFmDe/YV6vKduhImDBwkFjAGfR03cHe4mBoDZrAWqBH7MH3rtNKWNXYzPSOSHdyzURZQOBEsopdNaj80l90JGkS7jecmupuDdkDyJOPPQnx1v6NEYKp22O9186akj2F1uNs0p4L7VkyM9JEEQBEEQYhhFUXhiXzkA966a5Nf3UIvZxDc8AZeP7S2joqnb0DGORrxCY25y2Pc9b3w6E7OT6HG42H5WUsRBhEZhEDQhYPOUzf3Koy/Hsv933mVXAG5GRVH4z+eO0213sbI4m0+un9r3ZNgcjerPkFJhdUTrE7imcA15yXnDrqtrv0CXs6834xWfB8vQ8x0QOs5jS5ed/3rxBACf2TiNZZMHD2wJlO2XttPp6KQwpZClBUuHXdcc7T0ae1rgyOPq8rov6bddnT+P51vOc6b5DFazlesmDx84FKy7bu/FJv62V+2J89O7FpGRHLooHSgWbxhMgK0D6s/A+bcAk/p51IEuRxfv2FSh8eak4Z2dY7F0+jfbLnCmtoPslHh+9H59nNKCIAiCIIxd9pc2c6Ghi+R4C7ctHu/36zbMzGP9jFwcLoWfbDlr4AhHJ2VaEExuaD38g8FkMnGjx9X4qqRPAyI0CpfR4+xhx6UdwAgur5qjmMt3Y/KUHgciBjx98BI7SxpJsJr50Z0L+1ubPRe6epZqDoZFczRGidC4pVx11t04dXg3I/iUTuvhaDz7CrRVQFI2LPxg6NvT8M5j6ALVd18+RWOnnRn5qfzb1UP3rgyUN8reAODGKTcOmfCtYTaiL6aeHHoUHN1QMB+mbNBvuzrOI8Ab5eoxX1e0jszEzGHXDSb0qMfu4uvPHgPU1OC103ODG2iIBO1o3Pdb9efsm1SHsQ7svLSTXtxMcjiYbxm+T+VYK50+W9vBr94pAeDBW+eRkzp0+wRBEARBEAR/eGK/esP7tsXj1dZgAaAFw7x0tJqjla0GjG704k2cjoCjEWDzAlVofPt0Hb2OsfFdejhEaBT68W7Vu/Q4eyhKLWJuzjCpm3vVC2KLVmrnpxhQ397L919WS6a/dO1MpuReFjQTJqEx5FRYHbnYdpHzreexmq3DBpJoeMNg9DhGnnlk+QMBJ4YPi5ZIHmKq9ztn6nnucBVmE/z4zoUkWPUJaOhx9rCrahcA1xZfO+L6UV067XLC/j+oy6v/NfTEcF90mkeNt8rfAhjRzQjBhR7971vnKGvqZlx6It+4cXZwg9QBrUdjQDcyupv7emyu/lfdxqLdxLi2qxsTw49nLDkaXW6Frz57DIdLYdOcAm5ZWBjpIQmCIAiCEOM0d9l57bjqaPvQysDbscwbn8HtS9TWOf/96mmUKMoTiHbKmiLnaARYNCGD8RmJdNld7CppjMgYogkRGoV+vFn+JgCbJm0auoSsow5OPAOA1dPvy+1HurCiKHzz+RO09zpZOCGDj6+bMnClMIfBRIPQqIkvqwtXkx4/cgiBVwwI1XVUfRgqdqvHfMW/hLaty9FhHjt6Hfznc8cBeOCKKSyZpE/JNFwmqGcPI6h70ByN7mh0ep15GdoqITkX5t+p77Z1/Dz6CupXTrxyxPU1564/5xaAo5Wt/HHnRQD++475pAd4B1lPNMe0O5Dzy6G/grMHChbA5Ct0GUc/Qb2re8R5NCTRPkr5065Sjla2kpZo5Qe3z5eSaUEQBEEQQuaZg5XYXW4WFGWwYEJGUNv4j+tmEW81s6+0mXfO1us8wtGJzemiqqUHiEyPRlDLpzfNLQDgbZk3ERqFPuwuO9svbQdg0+RNQ6944E/gssOEFVgs6sW8Pw6YV47XsOVUHXEWEz++cyFWyyBvv7CFwUSP0KiJu9dOHtlZBzqWN2puxnm3Q7rObh4d5vGh185Q09bL5Jxk/uO6WToNTMUvQd2HqBZg9v5G/bn8AYhL1HfbOn4eAxbUA+iLaXO6+MozR3Er8L7F47l6dkFogw0R7fzit6PR5TDEleoV1C0pzLU7RpxH3RPto5TSxi5+6ul99M2b5lCQrvPnRhAEQRCEMYeiKPx9fyUAH1o1KejtFGUm8bErigF46NUzOF36VBaNZiqbu3ErkJpgJS+CrXCump0PqFV5Y92NKkKj4GVP9R66HF3kJ+ezMG/h4Cs5bXDgEXV59b/2iQEjpJQ2d9n5rxdOAvCZjdOZPW4IoUETNhQXGPjhtJiDDGvQmcr2Ss40n8FisnDVxKv8eo0u5Y0ddXDiWXV5lX5lml5CFKh2X2jkiX1qf5Mf3rGQpHh9SqYhAEHdB3O0lk5XHYLKvWCOgxUf13/7OgqNgQrqgYi7//fOBc7VdZKTEs+3b5kX/CB1ImDH9OmXoL0KUvJg/vt1G4dXUE+ZjAnE0YjqMv3as8ewOd2sm57LB5YPH5AjCIIgCILgD3suNFHa2EVqgpVbF/kfAjMYn9k4nczkOErqO/nnoSqdRjh6udjQlzgdySqVNVNzSIwzU9PWy5najoiNIxoQoVHwovXy2jRp09DhGCeeha4GSBsPc2712wHznZdO0tRlZ1ZBGp+9aphAD9/9+lkyGQzRUjr9ZoUqBCwft5ysRP9Kg/0Vd4flwCPgdsCElTBhWfDbGQqt12YQc6gGeqgl0x9aNYk103L0HJl/gvplWL2l01GWOq2Fh8y/A9LG6b99TwlwqJ9FIwX10zXt/Pqd8wB857Z5ZKfEhzRWPehLnfbz/GKAK7WfoJ5arD44wrH0BvBE2/tcRx7fX8H+0maS4iw8dIekTAuCIAiCoA+P+4TApCRYQ9pWRlIc/3rlNAD+vLtszLvjRiLS/Rk1EuMsXDFNDaN8+8zYLp8WoVEAwOFy8E7lO8AwjiNFgb2/VpdXfgIscX45YN4938gLR6q9gR7x1mHedmafk7KB5dOWQEsbDSKQcAyNkB2Njl54r8+VagghpBX/3zvnqWjupjAjkW9s1j/Qwy9B/TIs0VhS2lELJ/6pLhs2j/o4GoMR1P1pEaAoCt96/gROt8J1cwu4aUF0BHpoYTAufxzTlw7Cpf2qK3W5fq7UfoJ6kue4jCQ06hk0FYU0dtr48etnAPjqDbOYmB2ZHj6CIAiCIIwumjptbDnpCYEJoWzalw+umEiC1czpmnaOXmrTZZujlVItcTon8t/trp6jlk+L0CgIwP7a/XTYO8hOzGZJ/pLBVyrfDbXHwZoEyz4KjOyAcbjcfOcltWT6vtWTWTQxc/iBhElotHqcWpF0NNZ01nC88TgmTFw96Wq/Xxdyj8YTz0J3I6RPgDm3BreNkQhSoCpv6uL3O9RAj/+6ZS5pOgd6+CWoD0JUlpS+53GlTloD44f4zIaKTkJjKIL6cD0aXzhSzYHyFpLiLHzntnlR407z3shw+XF+2edxMy64E9L06y3ZT1D39NL1u0djNL3PdeQnr5+lo9fJ/KJ0PrKmONLDEQRBEARhlPBeWQsOl8LMglTmjQ8uBOZyMpPjvTfR/+5pKSUMjldozEuJ8Ejgqlmq0Hi4ooXmLnuERxM5RGgUgP7hGNoF/gA0N+OiD0JyNjCyA+Zve8s5V9dJVnIcX7rWj0CPMDsaIyk0vlWhii9LC5aSm5Tr9+s0F54/IRkDUJS+Ms2V/wKW0Gz9QxKkQPX9V05jd6m9066fp38psF+C+iBo73M3USLAOHrVUCaAVZ82bj86CI3BCuojibudNif//eppAP7t6ukUZiQFPUa90cJg3COVubRXw8nn1GUd53GAoO7nPIZ0bolyjla28tRBtUH7d26d5/0bIAiCIAiCEConq1XH4eKRTDUBco/HHfni0Wraex26bns0oQmNxTmRFxrHZyYxe1wabgW2nxu7rkaDVAYhlnC6nbxd8TYwTDhGSxmcfVVd9gkPGU4MaOy08bM3zwHwletnk5Hshzutn9BonKjTV9oYOaEx0HAMDW/pdDCuo/J3oc7jSl16f+Cv9xevsOH/GLefa+DNU3VYzSb+65a5hrjT/BLUByGkY24EJ55RXakZE2H2zcbtJ4QSeI1gBfWRWgT86u3z1HfYmJSdzMfXTQl6fEbgd2uG9x5Rj+2ktTB+sW77HyCoVx5RnxjJ0ahXon2U4XYr/NeLJ1EUuGNJEcsmZ+u7gxPPqs7i9NAavwuCIAixSafNyesnaqlr76Wx00Zjp53GDhs2p4uPr5vKTQujo7WLYBzHq1ShcX6RPm5GjeWTs5iRn0pJfScvHKnmvtWTdd3+aKDL5qSu3QbAlNzIC40AV8/O50xtB2+faeD2JRMiPZyIIEKjwKG6Q7TYWshMyGT5uOWDr/TeH9VAiGlXQ35f37zhyht/+kZfmdoHV/iZ7Gn2MdkaKDSaAw1r0Jn67nqO1B8B4JpJ1wT0Wq8YEMzx0cJDFt/jdaUagtb70M8x2p19Jfb3ry1mRkGa7kPyS1AfAu197o6G3nWK0jePKz9pnCsVwKQJjcGHwQQtqA8TelTa2MUju9QS+2/fPJfEOP1SyfXAL8e00wYH/6wu69xjc4Cgrs3jCKE+uiTaRyHPHrrEkcpWUuItfF3vvq/tNfDsJ9TlLxyHjCJ9ty8IgiBEPV979hivHKsZ9Lkjfz9EvHU5187Vrz2KEF0oisIJj9CoV9m0hslk4p6Vk/juy6d4Yl8FH141KWpaBUULWhBMVnIcmcmRD4UEuGZOPr/edoHtZ+txutxYLWOvkHjs/cbCALReXldPupo48yCuQ6cNjjyhLq/8ZL+nhnI0HrvUyj8OqGVqD94SYJmaTn3hhsMa4dLprRVbUVBYlLeIcSmBlQgHnQzbUQdnX1OXV3wisNcGSoBz+NfdZVxs6CI3NZ7Pb5phyJAO1h0cWVAfAq+4i3FJ6H5TfcjTKzURlnzY2H2F+Fms767ncP1hIHBBfTjR63svn8LhUrhyZh7XeBouRxMWzw2TYXs0nn4JupsgvQhm3ajbvn0F9WuLPeKun/MYlb1IQ6S918GPXj8LwL9fM4P8dH1Svb0ceRwUF0xYISKjIAjCGGTvxSZeOVaD2QTvXzqBT185jW/eNIef372Y9y0ej1uBf3viEO+VNUd6qIJB1HeoLlazCeYWpuu+/TuWFhEvoTBDUtbYDUSPmxFg8cQsspLjaO91crC8JdLDiQgiNI5x3IqbrRVbAdX9MihnX1UviNMKYXp/V5IWHuD2cTz5lqndvqSI5cUBOufCIDT2lTZGRjjSwjECdXmBT7/AEdxJAzj6hHpMJ6yEgrkB7zcgApjD+vZefr61BICv3jCbdJ0DYDQ0l9dVE68aXFAfBq+jMRoEmEOPqj/n3masKxVC/ixq55aFeQsDFtQ1cffy9/nbZ+p4+0w9cRYT3zaoxD5U/LqRoc3jkg/r6krt51Av8Ajq/gqN0dYiQAd+8VYJjZ02puam8LErdC6xd7vh8GPq8jIDW1EIgiAIUYnLrfDdl04BcM/KSfzPBxbx9c2z+Zf1U7ltcRE/vWsR18zOx+Z08/G/vMfZ2o4Ij1gwguMe8W96fipJ8fpX2WQmx3OzhMIMSWljJwDFUSQ0WswmrpyZB8DbZ8dmn0YRGsc4R+qP0NjTSFpcGqsLVw++0sG/qj8X3zvggniw8sbnDldxuCKEMrVwOBo9PRojoTM29zZzoO4AEHgJL/gkwwZS3qgofcLG0o8EvM+A0eZQcan7HoYfvX6WTpuTRRMyuHOpMT0sfAX1YMRda7QIjbZOOP6MuhzOeQzys6iJu4GkTWsMdm6xOV3eL/QPXDGFaXmpQY3LaLyl00O995svQul2wKSeV3XE16GunSv8nceQ2jJEIefrO/jL7jIAvn3LXOKtOn/lKduh9i9OSFeFf2HM8MMf/hCTycQXvvCFSA9FEIQI8vSBSk7VtJOWaOVL184c8LzVYuZXH1rKsslZtPc6+cif9nGppTsCIxWM5IQnCGa+zmXTvviGwnRIKEw/Sj2OxqlRJDQCXD1HbZfwzhkRGoUxiCYEbJy4kTjLIC6vljK4qKaXDlameXl5Y6fNyQ9fPwPA566ZQUEwZWrevnDGXexG0tH4dsXbuBU3c3PmUpQaeKndcL3rhqRslypuxKfBvNsD3mfA+AatDDOPhypaePbQJQAevHUeZoOSYP0S1IfB666LdOr0yefA3gnZ02DyFcbvzxxYr01fmnqaOFh3EAi8bBoGL53+064yypq6yUtL4N+unh7wNsPFiI7Gw39Tf067CrL0a+o9pEPdz3kcTY5GRVH4zkuncLoVNs3JZ+MsA0rsPTdv3pl1JY2uHv23L0Ql7733Hr/73e9YuHBhpIciCEIE6eh18NMtamuOz18zg5zUhEHXS4q38Mj9y5mRn0pdu42P/Gk/zV32cA5VMJgTVe2A/kEwvmihMD0OF88fqTZsP7FINDoaAa6ckYfFbOJcXSeVzWPvBoMIjWMYRVFGdnlpF8RTN0L2wLKzy1NK/7DjIg0dNopzkvnYFcXBDUwTqQy82LV6LrzdilrqHU5CKZuGIAMbDnlcqQveDwlhcIH5Co1DzKOiKPzwVVWUvnPZBJZMyjJsOCMK6iPQ52iMcI9GbR6XfgTCUTLs60wNkHcq3/EK6hPSAneqXn5uaemy8+t3zgPw9Rtmk2ZQib0eeG9kDNaj0eWEw4+ryzonvx9tODq4oO5nCrz3JoaBbvJwset8IztLGom3mPnWzQa0iuhqgtMv0Ww28/mOY1z91NU090r/rdFOZ2cn9957L3/4wx/IyjLub5YgCNHPr945T2Onnam5KXxkTfGw62Ymx/Pox1cyPiORiw1dfP7JwygjVPwIscMJgxKnfdFCYQCe2Fch7x8fShvVMJho6tEIkJEcxzLP9e07Y7B8WoTGMcy5lnPUdNWQaElkzfg1A1fod0E8eJmmbzBJU6eNP+5Uk2C/cv1sEqxB9qgIR49GH5FmyPJGA+h2dLO/dj+gljYGQ8CBDd3NcOpFdVlnYWNIzD4l9kPM47ZzDewvaybeauY/rhtYbqInOy7tAII/5loJqhJJp1fdKbj0nnpsF38oPPsM4bO4/dJ2AK6eGOT7/LJE+99uv0CHzcmcwnRuXxLdoRt9qdODCNMlW6CzFpJzdQ2BAdheqR7z9RPW9xfU/S2dNvcXd2MVRVH4yRuqy+Te1ZOYnGPAF89jT4LLzruFM1FQmJU9i+xEg3umChHns5/9LDfddBObNo3c9sRms9He3t7vnyAIo4Pypi7+vKsMgG/ePMev1hyFGUn89YGVxFvM7CxpZPeFJoNHKYSDhg4bte29mEwwd7z+QTC+SCjMQFq77bR0q6XkxUZ83wuRq2arFTVvj8HyaREaxzA7q3YCsKpwFYnWQUqcz78FHdWQlA2zbx50G17Ry+3i/965QJfdxYKiDDbPDyz4oR/hEBotPkJjGB2Ne2v24nA7mJA6gSnpwQUTaGKA366jY0+BywYFC2D8kqD2GTAjCI1ut8JPPEmw96+ZTGFGkmFDKWsro6KjAqvZOrig7gfe0KNIlk5rPTZnbYbUMCUtB/lZtLls7KvZB8CGCRuC2rWvoF7b1uvttffV62cZVmKvF32tGQY5t2iu1MX3gDVe1/3uqFIF9QHHPMDUabfijrx7NwReP1HLsUttJMdb+OxVBpTY+/S83Z6rit7ri9brvx8hqnjyySc5dOgQDz30kF/rP/TQQ2RkZHj/TZw40eARCoIQLn7wymnsLjfrZ+RyVQCtOWYUpPEhT6+9n245K660UcBJT3/GKbkppCboF+43GBIKMxDNzViQnkCKwcc/GK6Zo54fdl9ootse+xVDgSBC4xhGc78MKQRowsaie8A6eN8RzXXU2NnD3/aWA/CVUIWAcITBmCMjNGrOug0TNgSdlhuQo1FR+oSNZfeHp9wWLhMaB47z5eM1avPsBCuf2Whsrz3NWbesYBkpccHd6dJK7ZVICY2OXtVBBeFzpYLfJbeX817te/Q4e8hPymd2dhCBUPQPPfr51hJsTjcrirPYOCsvqO2FE+tQYTDt1aqjEWCJvmE+NZ01lLSUYDaZWVe0rv+TWisDP1OnIXZdjU6Xm594emb9y/qp5A7RMyskKvdDwxkcccns7qkBghfUhdigsrKSz3/+8zz++OMkJvrXe/ob3/gGbW1t3n+VlZUGj1IQhHCw+3wjW07VYTGb+PbNcwP+Pv+Zq6aRGGfmcEXrmCynHG14y6YNDILx5QMr1JtWr56oweaMze9qelLWpAqN0ehmBJiRn0pRZhJ2p5vd58eWi1mExjFKa28rxxqPAUM4MTpq4dzr6vIw6baa6PX6yWrsLjerp2azfkZuaIPzBhcY56ix+AiNg7qODEBRFHZeUl2kV064Mujt+LpIR6TqINSfAmsiLLgz6H0GjMnn1HLZOB0uNz/zCAGf2DCVrBR9XV2Xo8cx9zoaI+XyOvMy9LRA+gSYFlwpclCYgguD0QT19RPWBy2omz377nU6eOqAeoH+1RtmB729cGLxnMNcl/doPPw4KG6YtBby9G0XoB3zRXmLyEi47MuuFrA1wvtXO7dA7CZP//NQFRcbushKjuMT64NzjY+I5ybckVlX0eHoJCshiwW5C4zZlxAVHDx4kPr6epYuXYrVasVqtbJ9+3Z+8YtfYLVacbkGfl4SEhJIT0/v908QhNjnF2+XAPDhVZOYUZAW8Ovz0xK5f20xAP+z5VzYe8UL+tIXBBOec/zK4mzGpSfS0etk57nGsOwzmiltUIXGqXnRKTSaTCau9pRPbzs3tm4siNA4RtlVvQu34mZG1gwKUwsHrnDkcTUAYuIqyB/akaRdmB4sV090uggB4e7RGKY/8Geaz1DfU0+SNYnl45YHvZ2AkmEP/kX9Ofd9kBTGxvUmk096eP95fPrAJcqauslJieeBdQYJAR467Z3e5ONQHEdxWo/GSDkatXlc8uH+QTtGE8RnUVGUfs7dYNHe5209Nlxuhatn57OiODZ64FkHK512u+GwxyU+zM2bYBmybBoCLp2G2HQ09jpcPPzWOQA+s3G6MYFBve1w8p8A7MweD8C6onX93KDC6OOaa67h+PHjHDlyxPtv+fLl3HvvvRw5cgSLReZfEMYCPXYXB8tbAEL6DvvpDdNITbBysrqdN07W6jU8IQKcqDY+CMYXs9nEjZ7y6ZeOSfp0aZOa5hytjkaAK2eq1Vg7xpgwLELjGEUTAgZ1ebndfWXTI5RpekMyTG6unVvAUj2Sg8MgNJrNJm8VsdNA56Qv2jFfXbiaeEvwLj6/k2FtHXBCvSBmWRjLbTUGmcdeh4ufb1WFgH+7errhvUz21OzBqTiZnD6ZyemTg95OX+p0BMSXpgtQthMwqUJjOAnis1jaVkpVZxVx5rj+yccBoqVO9zjVBs9fvm5W0NsKN2ZvGIyP0Fi6DVorICED5t6m6/56nb3sr1FDpkISGn3EslhMnv7b3nKq23opzEjkvjXBf96H5cQz4OiG3FnsaFdT0KVsevSTlpbG/Pnz+/1LSUkhJyeH+fPnR3p4giCEiUMVLThcCuMzEpmUnRz0drJ8brb/7M1zYW3jJOhHS5edSy09AMwLU+k0wM2LVKHxrVN19Dpi78awnpQ2dgLRlzjty5ppOcRZTFQ0d1Pm6Sk5FhChcQzidDt5t+pdYIgLpLKd0FIGCekw733DbqujRz25mUxuvnK9TkJAGIRG8OmjFqY/7sM6jgLAb0fjiWfB0QU5M2BScCEoITHIPP51dxl17TaKMpO8zbCNxFvCG2JQQ5xFczRGoHT68GPqz+nXQGaYwwS0OVRcar9PP9CO+YpxK0iOC/5LeJ+7zs1ti8cbnuSnJ4M6GrWbNwvvgvjgj8tg7K/dT6+rl3Ep45iROWPgCmPA0dhpc/LrbRcA+Pw1M0iMM8hhdlDteXtpwfu40HYBi8nC2qK1xuxLEARBiCr2eJKiV0/NCbmC6+PrppCRFEdJfScvHq3SY3hCmDlZrZZNT8pOJiPJgCqKIVgyMZOizCS67C7eGYNpxhqKolDWqDoao1loTEmwsnyyWpW1/VxDhEcTPkRoHIMcazhGu72djIQMFuYuHLiCdkG84E6IH/5De6ZWVeUXTEhjZhB9SgbFG1xg7IWuNxn28j5qBtDc28zxhuNA6KKX5vQasV/gIZ8yzUj0tbssSKStx+EVAr6waQYJVmNLzdyK29ufMVRxt690OsxCo8sJR55Ql8MZAqPhWw7q5+dRL0H9RFUHoN7E+NK1+vYzNBqL9yaG5/3S1QSnX1aXDZhHb6l60RAhU36eU80ms7c3ZqylTv9x50Wau+xMzU3hzmUTjNlJzTGoOQLmOHZkqmUwi/MXkx4fOyK4oB/btm3j4YcfjvQwBEEII3sv9gmNoZKRFMcnN0wF4OG3SnC4YuvvrgDHPUEwC8JUNq1hMpm4eaHqanz5WE1Y9x1NtPU46LSpN9EnhuAwDgcbvOXTIjQKoxjtovSK8VcM7Ctl64Azr6jLi4cv09x9vpGGdrWscd10HXuneYMLjBUatSRht59OrVB4t+pdFBRmZ8+mIKUgpG1pczZsaWPjeTUIxmSBRXeHtL+gMfefx0d2XqStx8GM/FTuWGqQEODD6abTNPU2kWxNZnlB8D0xwdfRGGaXV+k26KyD5ByYeUN49w39hUY/Po/t9nYO1x0GVNErWBRF4U+7KgCIs8DkKO67Mhh9bmnPA6eeA7cDxi2AwkFu7oSAb8jUkOJuADdv/G7NEEW0dNn5w46LAPzHdbOwWgz6anPsH+rPWZvZ0RB671dBEAQhdui2Ozl6qRXQR2gE+OjaYnJS4ilv6ubZg5d02aYQPrT+jPPCFATjy80L1T7RW8/U0WWLne9setLQYQMgPdFqXCWLTmh9GndfaBozaeEiNI5Btl/aDgxxgXTmFXD2QPY0KFo67HZ+9c55FM9bKC1Jxw93mEqnLYOVNxrEsMc8QLyp08MJP8efVn9OuwpS80PeZ1B4xQ0n7b0O/ry7DIAvXTuzX+q3UWjHfO34tcRZQitniJij8ZhnHufdDlZj07kHxezTQ9OPz+Pu6t04FSdTMqYwMT34Mu+9F5s5fkl1NFossXeHf4CjUZvHhR/UfV/nW89T3VVNgiWBlYUrB18pgHOq1nc3lkqn/7y7jC67i7mF6WyeP86YnbhdajsKoHve7bxX8x4QWpq9IAiCEDscKm/19mecmJ2kyzZTEqz868ZpAPzy7fM4xdUYU5z0OBrnh7E/o8b8onQm5yTT63CzdYyWTzd0qkJjblpChEcyMnMK08hLS6DH4eJgWUukhxMWRGgcY9R01nC+9Txmk5l1ResGrqAJVAs/MGy57aGKFnZfaMKMAe6XUdaj0eF2sLtqN6CP0OgVAoZyJylK3zwu+EDI+wsan3n8295yOnqdzMhP5fp5BgkBl6FH8rGG5mgknI5Gezec8ZTbRmoeAxQavc66ENyMAL/edh7tz1MsCV4a/Xo0tpRD5V7ABPPfr/u+fHtiJlmHuPAJ4JzqvZFhcOsKvei0OfnLu6WAGjBlNuomRvm70FEDiRnsT03D7rZTlFrE1IypxuxPEARBiCq8ZdPTQu/P6MuHV08mJyWeqtYe3h6jglEs0t7roMyTeByuxGlf+pVPHx2b6dONnXYA8lKjX2g0mUxsmKG6GsdKn0YRGscY2kXporxFZCRcdlLsbIAL76jLC+4adju/fkfttTc1V7WK6yoG+DjhjMQcph6NR+qP0OHoICshi/k5oadTeksblSGOT/UhaL4A1iSYfWPI+wsaj7jRa7PzyE5VCPjXjdOMEwJ8aOxp5GTTSQDWTwitJyZEyNF47jWwd0LmJJg4hFPNaPoJjcN/xt2Km11Vu4DQxN2jla3sLGnEHGOCly8W35sYJ55RHyxeB+njdd+XX4L6Zf1Sh8PbmmGo80uU8fjectp7nUzNSzH2JoZ282bubWyvUW8crS9ar+vFpiAIghC96Nmf0ZfEOIu3t/Df91foum0hOFq77bxX1szj+8p58MWTfObxg5zwuBc1TlapQTBFmUlkp0Sg6oi+8ult5xro6HVEZAyRpLEjdhyNABtm5gIiNEYFLpeLb33rW0yZMoWkpCSmTZvG9773PZQw9NQbrQwb1HDyObUP2/ilkDNtyG2cqW3nrdN1mEywcEIWoLMYEKYwmHA5GjWX17qidQN7YgaBN3V6qONz3CNszL4REnQK6AkGzzjfPlVNU5edCVlJ3LJIf6FlMLRjPjdnLrlJuSFvL86i/i5hFRq1eVxwV2TCfABMPn8iRhD+TzSeoLm3mdS4VJYULAl6l6qbETbPV98rCkrMBZNYPP1fnW6lbx4X6u9KbbO1cbThKDCC0KjN4yhzNPY6XPxBu4lx5TTjWjI4bXDqBQCU+XfpFjIlCIIgxAa+/RnX6Cw0Aty9chKgCkaXWrp1377gHy8cqWLVf7/F4u++yV2/3cP/e+4Ef9ldxqvHa7nnD3s5XNFX8nrS059xfgT6M2rMHpfGtLwU7E43b56qi9g4IoVWOh0LjkaA9TPyMJngTG0Hde29kR6O4US10PijH/2I3/zmN/zqV7/i9OnT/OhHP+LHP/4xv/zlLyM9tJik19nL/pr9wBDJx8efUn+O4Gb8jSc5+Mb5hWQnJwI6u18CcN+Egtd1ZLBwrWcJL4zQo9Gnj9hI82g4nnG+eLgSgE9dOY04o0IaLmNnlb5CgOZoxBQm8aW7GUreVJcjOY8mU1840wifR+19vmb8GuLMwfXELKnr4I2T6k2MT6zru9kRC6KXL9pNjPG9F6D+FFjiYc4tuu9nd/VuXIqLaRnTKEotGnpF7f3rh/Pcrx6wUcLTBy/R2GmjKDOJ9y0Z5vcPlZI3obcN0sZzLj2Xuu46Ei2JrBi3wrh9CoIgCFHDwfIWHC6FoswkJmTp05/Rlym5KaydloOiwFPvVeq+fWFkqlt7+Nqzx6hrV8WroswkrpyZxyfWT2HZ5Cw6ep3c98h+3itrBvoSpyPRn1HDZDJ5TRwvjcHyaa+jMTUyjtJAyU6JZ6GnzH4spE9HtdC4e/dubrvtNm666SaKi4u58847ue6669i/f3+khxaT7K/dT6+rl3Ep45iZNbP/k82lcOk91fky/44ht1HR1O09kf3rxmkju+uCIew9Go1zS1V1VnGh7QIWk4W1RWt12eawpdOlO9SU4qQsmHaNLvsLGs88tnb1kJuawF3LjE+aBnC4HOyu9vTEDLFXoEa8VSshDpOz7tQLakpxwXzInxOefQ6Fn59HPQT132xXb2JcP3ccM/IzvY/HShmvhnYTY0XnVvWBGdepn0md8R7ziSMc80B6NBpxTjcAh8vN7zzvl09umGrsTQztJtz8O9hR/S4AqwpXkWhNNG6fgiAIQtSglU2vmpptWMuMezyuxn8cqJRQmAjw49fP0Otws6I4ixPfuZ53v341f31gJf/vprk89vGVrJmaQ6fNyf1/2s+eC03eUupI9Gf0RSuf3lnSSGu3PaJjCTeNmqMxRkqnoS99eiyUT0e10Lh27Vq2bt3KuXPnADh69Ci7du1i8+bNQ77GZrPR3t7e75+g4r0oLdow8I+k1kdsygZIG7rP1W93XMCtqB+S+UUZWE0GJJSGO3XawB6N2jFfkr+E9Hh9rPXDCgFamebc90UmpdgHxTNOCy4+sX4KiXE6JpMPw6H6Q3Q5ushOzGZe7jxdthn2Ho2+ZdORxo/PY313PaebT2PCNHjIlB9UNnfzwhH1JsZnrprWr81AtItel2O1mDDhZnWXfz1vg8HldvX1xBxJUPedwxEc3CP2gI0SXjpazaWWHnJT4/ngiuATzkektx3Ovq4uL/yA7g51QRAEIfrZe1F1sRlRNq1x3bwCslPiqWu38c7Z0S9CRBOHKlp4/kg1JhN8++Z5pCZY+z2fHG/lTx9dwfoZuXTbXXzsL/u52NgFRF5onJ6fyuxxaTjdCm+crI3oWMKNFgaTGyOl0wAbPELjrvONhrdvizRRLTR+/etf5+6772b27NnExcWxZMkSvvCFL3DvvfcO+ZqHHnqIjIwM77+JEw28AIkhFEUZ+gJJUeDYyCnFde29PHPgEgCfvWo64BMcoGvqdHjCYCxh6NG4/dJ2QN+L0iHFXUcvnH5RXY4Cgardc1MtPd7Evasnh22/2jFfX7Qes0mfU1y8ljptcuM2+o9C2yUoVwUkI1KKA8aPVgZaz7r5ufOD7on5+x0XcbkV1s/IZeGETK/gBbFRxuuL2WRiuekcua56iE+Dmdfrvo/jjcdptbWSFp/G4vzFIwzIR+Qfod/liKn2UYDbrfBrTwuPB9YZfBPjzMvgskHuTFoyJ3Ks8RggQqMgCMJYodvu5GhlK6B/EIwvCVaLt/rniX3lhu1H6I/brfDdl04BcOfSCSyYMLhwmBRv4Q8fWc5Vs/LodbhRFChIT4gKN51WPv3ysZoIjyS8aI7GWBIaF0/MJC3RSmu3w1t+P1qJaqHxqaee4vHHH+eJJ57g0KFD/PWvf+WnP/0pf/3rX4d8zTe+8Q3a2tq8/yorpc8FQGlbKTVdNcSb41lZeFmCbe1xaDwLlgSYc/OQ2/jjzovYXaqlfOWUbKDP/aJrWIMmMBgcANEvsMEAbC4bB2oPAEP0xAySIR2NJW+ArR3SJ8CkNbrtLxgURaG2Q00/u25O3oA7g0bybpVa2qhH2rSGV2jEbXhPT2+PzclXQGYU3CjxfE6G6+/3rqecNNj3eX1HL/84oJ6rP7PRcxMjhoVGq9nEbRb1mDD3VojTv5+T5mZcO36tVxwcEl+hcQQBMRZ6NG45Vcf5+k7SEq182OibGMe03sUfYE/NXtyKmxlZMxiXYmDCtSAIghA1HCxvwelW+zNOzE42dF+aQ3/buQaqWnsM3Zeg8uLRao5UtpIcb+Er188adt3EOAu/vW8Z184tAGD55OxwDHFEblpQCMDuC01jpnxaUZQ+oTEKxF5/sVrMrJvuSZ8e5c7lqBYav/KVr3hdjQsWLOC+++7ji1/8Ig899NCQr0lISCA9Pb3fPwH21OwBYGnBUpKsl130av2nZt0AiYPfxWnpsvP4vgoAPuNxM4KP+yUGS6eNTp0+XH8Ym8tGfnI+0zKHTvEOlCGFAO8F8fv7xKEIsf1cA10O9bheO8u4u7+XU9dVx8W2i5gwsbpwtW7b1Xo0mkxu423uXnfxncbux19G+Dy63C721ewDCLoP6SO7SrE73SydlMnqqeqXNpPJFFMJyL5YcXCTRT0mRs3j3pq9AFwx/oqRV/YVIkc4r3pvZESp0KgoijeZ/P41xaQnBhc85BcddVCqOqRZ8P7AjrkgCIIwKthzQe3PaKSbUWNqXiprpqqhMP+QUBjD6bY7+eFrZwC1Wi8/feTeywlWC7++dym//fAyHrxVnxZNoVKcm8LscWm43Apvn6mP9HDCQluPA4en/VlOSmyEwWhofRp3lIjQGDG6u7sxXyaYWCwW3AaGd4xWNCFgVeGq/k+43XBcSykeumz60T3ldNtdzC1MZ6PnwwE+/bx0LZ0Ob49Go4Qj7ZivLlyta+PoQUsbe1qhZIu6PMw8hovfbLuAE/W9Ec4gsP21alDU3Jy5ZCTo1zMl3uIRM4wWGutPQ91xMMepfTajgRE+j2daztBubyc1LpV5OYF/4WrvdfC3PWqJ0Gevmt7vsxIL7rrByK/fTZapkxZTJky5Uvftd9o7OdF4AhjknD4YAQiN3tYMUSru7r7QxLFLbSTGmfnYFcXG7uzkP1Vn/YQVKFlTvEKjX8dcEARBGBVoQTDajVCjuWeVGgrz1HsSCmM0v99xkdr2Xooyk/j4uil+vy7OYuaG+eOiomxa4zqPy3LLyboIjyQ8aG7G9ERr2HIA9ELr03i4ooW2bkeER2McUS003nLLLfzgBz/glVdeoaysjOeee46f/exn3H777ZEeWkzhdDt5r/Y9ANYUXlZSW/4udFSrTsYZ1w76ervTzWN7VSHgU1dONV4ICFOPRs3RaFTp9N5q9aJUT2cdDHHMT78ILjvkzYGCyN5dO1ndxr7SZtyEZx590YQAvY+5b+m0Ue8XAI573IzTN0FydJRjjCQ0au/z5eOWj1zCOwhPH7hEl93FjPxUrp6d3+85Q3rAhoHCipcA2B6/oX/Zsk4cqDuAS3ExKW0S41PHj/yCQByNUS7u/vndUgA+sHwiOUb35NE+jwvuorKjkpquGqxmK0vzlxq7X0EQBCEq6LI5OXZJ7aMWDkcjwPWeUJja9l4JhTGQ6tYefrtd7ff8nzfOiTmx6nKum6e2dNl+roFeR3R+h9OThg5PEEwUib3+Mj4ziRn5qbgVePdCY6SHYxhRLTT+8pe/5M477+Qzn/kMc+bM4ctf/jKf+tSn+N73vhfpocUUJ5tO0unoJD0+ndnZs/s/qV1Izb0NrIN/UF89XkNjp42C9ARu9PSA0Bg2ATlY/Aif0AMjHY1ttjZONp0E9He/eMUX31RYbR4X3gU6uieD4a+7ywDITPWU6IfJGaUoilf00vuYx2vvSSMdjYrSfx6jBa/wP/g8hiLuut0Kj+4pA+CjVxQPcP4akmpvNLZOci69BcDbcfq7GSGIY+4bijRSj8YoFncrmrrZ6ikJ+ujaYmN31nQBqg6qPYPn3e495ovyFpEcZ2yPLkEQBCE60PozTsgyvj+jRoLVwp2eUJi/768wbD+KonC+vpPH95Xz2vGxFSIC8NM3ztLrULMHblwQ+32X541PpygziR6Hi50lo1e80miIwSAYXzRX42ju0xi+hIYgSEtL4+GHH+bhhx+O9FBiGq2Ed+W4ld6LSABcDjj1gro8TErxXzzC0YdXTSbO0l+bNkQIGEHY0AuL19Gof1nCgdoDKChMzZhKfnL+yC8IgAF96zrqoFRN/WV+ZPv6NXfZeeFINQCFWanQTdiExtL2Uup76ok3x7Mkf4mu27Za1GNuMrlxuAz6faoOQmsFxKXAzM3G7CMYTEN/Hm0uG4frDwPBCY3bztVT3tRNeqKV25cUDXjekBsZRnPudSyuXkrdBZwyTR95/SAYshXGUJhM6jwqrmFDfSC6HY2P7ilDUdTeNlPzUo3d2cl/qj+nboTUfMPc0oIgCEL00lc2Hb5+4wB3r5jI73dcZNvZemraeijM0CdUrrq1h7fP1LP3YhN7LzZ7y08BPr5uCv/vxjmYzZE1LISDXofLm9D8/26aq2uLq0hhMpm4dm4Bf9ldxpaTtd7AmtFKY4f63s2LYaHxkV2l7CxpQFGUUfEevJyodjQK+jDkBVLZLuhthZQ8NeF2EA5XtHCkspV4i9nbM8QXQ9wvo6BHoxa+Y8RF6YAAnrOvAAoULYMsgxNYR+DJ9yqwOd0sKMogPdnTUDlMzijNzbikYAmJ1pGbOQeCb0mww2XQ73P6RfXnrBsgPoocU8N8Ho/UH8HmspGXlMfUjKkBb/rP75YBcPfKSSTHD7zv5e0Bq0Sfu25IPPP4ins1LgPMrw3dDZxvPY8JEyvHrfT/hX6eVwftARsFdNmc3mRyw92MAKfV8nfm3Y5bcXv7v4rQKAiCMHaIlNA4NS+VlcXZuBV46Wi1Lts8V9fBtT/bzjefP8HLx9RqtQSrmSWTMgE1mO+zTxwaE2W3B8tbsLvcFGYksmiCfj3dI81181Rx8a3TdaO+v6c3cTqcYQA6smpKNvFWM9VtvVxo6Ir0cAxBhMZRTo+zhyP1RwBYPf6yCyTtQmrWjUP2EdPKYG9eVDioNdmYHo2xnzodsOMoAMyeMkivuKvN4+ybdd9XIDhdbm+ox/1rizGFaR41jHQcae9zALsRQqOiRM08DmCYefQNxwj0Ttz5+k52ljRiMsF9qwcXyGMuddrRAyVvAvCGa4Uh5xbtmM/JmUNmYqb/L/Tz8+g9v0SZuPvPw1V09Dopzkn2pvUZRks51BxVS85nbeZM8xnabG2kxKUwP3e+sfsWBEEYgi6bE7tzdIsH0YTT5eZ4ldqfcWVx+Ptm37pY7cGsVQqFyn+/etrbE/uLm2byj0+u5tiD1/HcZ67g53cvJt5i5rUTtdz7x300d9l12We0stvTF2/N1JxR5SRbWZxNRlIcLd0ODpa3RHo4hqIJjdEUyBMIiXEWVk1Rzys7zo3O8mkRGkc5h+sO43A7GJcyjklpPo5EtxvOvKIuz7l10NfWd/Tyiqdnx8fWDp7EZUyPxvCEiFg8ieZ6iwG1XbWUtZdhNplZMW6FrtuGy8rVe1qhdIf6xBDzGC7ePFVHdVsvOSnx3LywMGzzCKroeqD2AGCQ0Gg2WGisPw3NF8GSMGQoU8QYppWBb7J6oGi9GTfNKRiy75H3/BKFZbyDcuEdcHRjTxnPcWVKdN3E8LP3bTSWqyuK4r3p9ZE1xcaXdWl/GydfASm5XnF3RcGKoAKPBEEQgqG2rZcXj1bz7RdOsPnnO5n/4Bts+tl2ztd3RnpoY4Lq1l4cLoV4q5kJWfqULgfCjQsKsZpNnKxuD3nOd5U0su1sA3EWE3/4yHI+v2kGq6bmkGBV/+bftriIRz++kvREKwfLW3j/b3ZT3jQ6XVYAuy+oTtU108LrVDUaq8XMNXPUll1vjPL06cZOTxhMjJZOA6yfkQvAzhIRGoUYxNfl1e+OTdUB6KyFhHSYsmHQ1z6xrwKHS2HZ5CwWDGErN6S0cZiecHpiVOq0dszn584nLT5N123DZULAuTdUIS9vNuQa0w/OX/7sEQI+tGqSmtwWplAfgFNNp+hwdJAWn8ac7Dm6b18TdwFsRgiNmptx2lWQoP97JiSGEIxDCTxq73XwzMFLAHxsmDJY7/klCoNJBsUzjx1TrgdMuvd/VRQleOeu58bKiKXTURjA8+75Js7Xd5ISb+HO5ROM3+Fl7mKtLcOAqgBBEAQDuNTSzeaf72T1Q1v5978f5tE95ZyuaUdRoKK5m/f/Zjf7PCW9gnGUeoS2ydnJEelbmJ0S7w2MeDGE8mm3W+G/Xz0NwIdXT6Y4N2XQ9VZPzeHZf11LUWYSpY1dvP83u6lu7Ql6v9FKp0+S+GgTGgGu96RPbzlVi6IYFGAZBTR0xHYYDMD6Gerne+/FZmzO6PnerRciNI5yhrwo1S6kZlwH1oG9DexON4/vU5PO7h9OCPCIEG5FxwtqTaAy+ELXqB6N3nLScfqXTcNl5epnoqPc9lR1O/tLm7GaTdy7ylMGqwlUYRAstGM+IPBIJ3y36TQiDEabxzm36L/tUBni83ig9gBuxU1xejHjUgJL63v6wCW67S5mFqQO+yVPc4/pen4xCpcDzr0GQOdUNcxH73NLWXsZdd11xJvjWZq/NLAX++tojMIwmL/sLgXgzmUTSE+MM3ZnnfVQofbYZfZN/QKPjDqnC4IgaLjdCl995hina9oxm2B+UTofXVvMr+9dypYvbmDJpEzaehzc98j+kMQnYWQ0R99Qwlw4uHWRWj794pGqoEWj5w5XcaqmnbREK/9+9Yxh151RkMZzn1nL7HFpNHba+cErp4PaZzTzXmkzLrfCpOxkJmRFUU90ndgwI4/EODOXWno4XdMR6eEYhrdHY4yWTgPMHpdGXloCPQ4XB8tGX6m7CI2jmJbeFs40nwEucxz59oMbQth47UQNDR02CtIT2Dx/aBHB637RtXQ6vGEwejoaFUXxljauGb9Gt+360udodML5reqDERaotLLGG+aPY1yGJ4gljD0aQynh9QezyQyK+n6xOXX+fVrKoPa42g8umtKmNYaYx2CddW634i2bvn9t8bC9caJR9BqS8nehpwWSc3CMV8+3erultff54vzFgQce+fl5jLbS6YqmbraeqQfgI+EIgTn7KqDA+CWQOZGj9UfpdfWSm5TLtMxpxu9fEIQxzeP7ytl9oYnEODNvfelKXv7ceh68dR43LihkZkEaf//Eaq6fV4Dd5ebf/36Y326/MKpdS5GktNEjNOZEToy6dm4BiXFmypq6vf0iA6HX4eKnW84C8G9XTScrZeTgjPz0RH72gcWYTfDK8Rp2lTQGvN9oZo/HDbx2FLoZAZLiLV6n3JZTtREejTEoikKTp3Q6Vns0gpoUrpVP7xhlnzMQoXFUs792PwoK0zOnk5uU2/dE/SloKVX7wU3fNOhrtTTYe1dNJs4y9NvEkNLpMPX26wuD0c8tdaH1Ao09jSRaElmUt0i37friFXddNnB0Q8YkKDRmX/7Q3GXn+SNVwGVpsGGaxx5nT5/jyIDwnT7Uz4HuqdOnX1Z/Tr4CUqLwS4/OQuO2c/WUN3WTnmjl9iVFw65rSKq9UWjzOOtGLFbVdefSOXY6pMAjf1Ono6x0+tE9ZSgKbJiZx7S8VON3qM2jVjYdQuCRIAhCIFQ2d/PQa6pB4Gs3zGbqIOe8xDgLv753GQ9cofZO/+FrZ/ivF0+K2GgA5U3dQGQdjSkJVq6dqxo+ggmFeWRXKTVtvRRlJg1boXY5c8en85E16vrffvHEqAoh8gbBjFKhEeC6uWr69JZR2qexvceJ3ZOqneOHeB7NbPCIwqMxEEaExlHMiGXT06+BhIFfYo5UtnKkspV4i5l7Vk4a8LwvxoTBhKe3X1/ptH7b1I750oKlxFuMOfF5j7nLoT4w52aI4AXwk+9VYHO6mV+UzrLJWX1PhGketcCjguQCitOLDdyTR2jUW/Q64xE2orFsGgYNg/ENPFo+bnlAm9NuYnxwxUSS44cP1ogZR6Pb3W8evTcxdLzwc7ld7K/dDwQrNPrX+zaaxN0um5N/HKgE4KNrB08m15XeNri4TV32hGsZ7ZYWBEEA1e3/lWeO0m13sXJKNvd7RJ7BsJhNfPuWuXz75rmYTPDonnIpozaAMq+jMXJCI/SVT790tDqgliyNnTZ+s+0CAF+5fpbaPz0AvnjtTHJT47nY0MWf3i0N6LXRSmu3nZPV7YCaOD1auWZOAWYTnKppp7K5O9LD0Z0GT9l0WqI14Pd1tLHO42g8VdPu7Ts5WhChcRQz5AXSZY6Ny3nUUwZ786LCEe3Ihrhf/LwgDhWrRX9HYzguSvtcpJ7jE8H+jC63wt/2lAPw0bVT+jt+wiQ07q0dIvBIZ0yKJjQ69NtoZz1UqONn9k36bVdPBgln0t7n83LmkZEweFDUYFxo6GRnSSMmE9475cOh9WiMljLeIak+BB01EJ8KU640pC3D6ebTdNg7SItLY27O3MA3oM3jCOfqaBJ3nz9SRUevk8k5yWycmW/8DkveBLcDcmdC3kza7e2caDoBiNAoCIKx/G1fOXsvNpMUZ+Endy70K3zkgXVT+OKmmQD84JXTdPTq+P1kjON0ualsibyjEeDKmXlkJMVR32FjX6n/IUC/2FpCp83JgqIMr1gZCBlJcXx98xzvtmraYj8YZl9pM4oC0/JSyE8PsAVNDJGdEs+K4mwAtpwafa5GTZDLi+EgGI3c1ATmjU8H4N3zo6t8WoTGUcqljktUdlRiMVn6O46aS6HuuHrROWtgP7i2bgcvH68B/BMCDHG/xGiPRofbwXt17wHGlvB6xReA5FyYFLkL4B0lDVS39ZKZHMfNCwv7P2kKT+m0lghrbNk0aKdLu549Gs+8gtoPbilkhCFNNxgG+Tz6lpMGwlPvqe60q2flMzF75J5HhrRmMALfcK24RJ+2DPoJjdoxXzFuRXCBR/6WTkeRuPvkfvX9ct/qyeFJ/LwsbTqUwCNBEAR/qWjq5qFX1ZLpr2+ezeQAHHSfunIqxTnJ1HfYePitEqOGOOaobu3F4VKIt5opjLAgFW81e/vlv+hn+XRpY5c31PM/b5wT9N/QO5YUsWxyFt1216gIhtlzQevPmDvCmrGPN3365Ojr0+gNghkFQiP0pU+PtvJpERpHKZrjaGHeQlLifL6waOV9xVdAcvaA1714tAq7083scWksmjCyU8kQ90u4hEaTvmLAycaTdDm6yEjIYHb2bF22ORjaMXebTLhnbe5zgEYATTi6fUnRQOt6GOaxtbfVG3hktOPIhPr76Vo67S23jWxq+LBcNo+KogTVK9DhcvPsoUuAWjbtD9EWTDIo/cK11Hk0+wiNevXN0gT11eODfJ/7GwYTJeLuqep2jle1EWcxccfSMIjwjh7V0QjeNgbBCuqCIAj+opVM9zhcrJ6azX2rA2sTkWC18J3b5gPwl91lnKltN2KYY45ST+L05Ozk8NzoGoFbF6uOxFeP12Bzjvyd6JVjapn1+hm5IfUiNJtNfPe2eZhN8PKxGm9/w1ilT2gcvWXTGtd6+jS+V9ZMc5c9wqPRF01ojOUgGF82zOwLhBlN/XZFaByljFw2PXg/OK0f1geWT/SrDNWYHo3hccJZzOrbXy9Ho/eidNwqNaXYIMxK37y4ZkWu3Lap08Zbp1U7/geWDyIchWEefQOP8pLzDNuPisfR6NLpvd7bBhe3q8uefnBRyWXzeLHtIo09jSRYElicv9jvzbx9pp7GTju5qQlcNdu/MthoKuMdkoYz0HwBLPGqo5G+oCnQ50ZGr7PXG3gUtKDu5+dRO3dFWtx9yvO36Nq5BWSHo9H3xW3g6IL0CWriNH1/R9cUrjF+/4IgjEleOFrFvtJmkuMt/Pj9i4ISta6cmcfm+eNwuRW+9fyJUXWhGinKPUJjpMumNVZNyaEgPYH2Xic7zo0s9mnJyprYFArzxmfwYY8A/u0XTuLQs7l9GGnosHG2rgOAVaO4P6PGxOxk5hSm41bgnTP1kR6OrvQ5GmM7CEZj2eQskuIsNHbaOF3TEenh6IYIjaMQt+JmX616gdTPidFRB5Xq44P1gztZ3caJqnbiLCbeN0IarIaxjsbw9Gh06y00Gux+sdYe8y67itcauq/heO5wFQ6XwsIJGcwpTB+4QhjmMZyOI90djee2ePrBzYLcGfps0wgum0ftmC/JX0KCxf87iZr79f1Li4ZNsvfF666LgmCSIdHcjFOvgoQ0oK8tA+gTCHO4/jB2t5385PzgA4/8/Dx6S6cjKO72Olw8d1hNsr9rsJsYRuAtm74JTCbquuq42HYxqMAjQRAEf3n1uFrW+C/rpzIpZ+SWIkPxrZvnkhRn4b2yFv55qEqv4Y1ZSr1BMMHPiZ5YzCZuXqi6Gl84Mvz82pwuDpS1APo59/7j2lnkpMRzvr6TJz3f52KNvR7xdU5henhuYEYBm+aoN/a3nhldfRobO1SH5mgpnU6wWlg9Va003VkyesqnRWgchZS0lNDc20ySNYmFuQv7njjr6QdXtAwyBgqJTx9QyxqvmzvO7xOwIT0a/QwtCBU9ezR2O7o52nAUMN79Yil5w7vssgyf2msUiqJ4HUeDuhmhT9gwcB6DKeENFpPndOl06fReP6OV20Zp2rSGuf/n0VvCG8Axr2vv5Z2z6t3UQIQjr2M6mh2NpwfOo9Xc96dVD0ej7/s86MAjf1OnTQa41APkzVN1tPU4KMxIZMMMo53KgMsJZ19Vlz3zqN2sm5s9N6DAI0EQBH+xOV3e5v/Xheg8G5+ZxL9fo960fOi107T1SDBMKJQ3RUcQjC+3ecqn3zpdR5dt6O+ihytasTnd5KUlMC0vVZd9ZyTH8bmrpwPwx50Xde1BHS40l+doTpu+nGvmqOeVHecasTtj04k6GFrqdO4oKZ0G2DBT/b67syS22xP4IkLjKORA3QEAluYvJc4S1/fEZY3uffF1kHzAz/5pYFTqdHh6NOoZ2HC04ShOt5NxKeOYkGZgPzFFwXLmFe9/I+X0OlLZyrm6ThKsZm4ZKsnO4NLpuq46KjsqMZvMLCtYZsg+fNEcjXY9fp9+/eCiuD8j9Ps8uhU3B+sPArBy3Eq/N/HsoUu4FVg+OYvp+f5/6fWeX6K1R2NLGdQeA5O5X7iWr6NRjxsZ2jk9kGM+AH97NGo3jyLYo1G7iXHnsgn9jqVhlL8LPS2QlA2T1BtFB2rVY76icIXx+xcEYUxyoKyFbruLvLQE5g5WGRIgH183hal5KTR22vnfN8/pMMKxS5nX0Rg9QuOCogym5KbQ63B7WxcNhtaHcPXUnOBvTg7CB1ZMJCMpjvKmbt6MwSTjsdSfUWNhUQZ5aQl02pwBJZZHO6MtDAb6AmH2lzXTY4/S654AEaFxFHKwThUC+okvvW1QukNdHqQf3BaPg2R8RiLrpvufxOUNJlF0vEsSph6NZpPmaAx97IfqDwHqMdfzj/oAGs5gaS71/lfX4x4AT3ncrzcuKCQjKW7wlQyeR+2Yz8qaRVp8miH78MXraNRD9Lq4DRzdkDERCheHvj0j8ZnHkpYSOuwdJFmTmJMzx6+XK4ridUsHchMDYsDReMbjgpt8BaT0nTf7lU67QhMae5w9nGo8BRCaoB5gGEykzi2XWrrZ5XH43LUsTGXT2s2b2TeCxyWunV+WF0jZtCAIxqD1Tds4M0+XwJF4q5nveYJhHt0jwTDB4nS5qWyJPkejyWTi5oWFgBoKMxRGOfeS463esKI/7Lyo67aNpqath9LGLswmWDl1YBjqaMVsNnGNpy/6WzEoDg9FY8foCoMBmJaXwviMROxO96gRhUVoHGUoiuINDVhasLTviQvvqBeYOTMgd/qA12n90wJ1kBhSOh2uHo06OhoP1akXpUvzl46wZoicewMzfR/cSAgw3XYnLx2tBoYpmwbD59F7zAsMPuYevD0a9SidPucpf5+1GYwUpvXAZx61c8uivEXeXn4jsb+0mdLGLlLiLdy0oDCgXUd9GEyJzzz64HsKDdXReKLxBE7FSX5yPkWp/vXOHRQ/S6e1eY2UW/qZg5dQFPUCKZR+ZX6jKD7zeCMAjT2NlLeXY8IUUOCRIAhCIGw7p/bi2jjLv4A0f7hiei43zBuHW4Hfbrug23bHEtWtvThcCvFWM4XpiZEeTj9umD8OgG1nGwYtn+6xuzhcofZnDCVteig+snYy8RYzB8tbOFjerPv2jUJzMy4oyiA9cQiDxChFK59+63T9qAiKUhSFxk6tR+Po6bVpMpm8rsbRUj4tQuMoo7KjksaeRuLMcczPnd/3hFam6UlF7fea5m7eveBxkATYeN+Y0ukwpU57wmCcITqOHG4HxxrUgBbDS3g982gxae668IsBrx6vpdPmZFJ2MqumDHNX0OASeM1xZLi468Gs1zFXlGE/j1GHqe/zGIy4q7lfb144npSEwHqKGpJqrxe2TijfrS5fNo8mk0m3Gxleh3p+iG5pk3/n1UiKu253n/v1gwG6X4Om6bxaAm+JhylXAngF9RlZM0iPD72cURAE4XIqm7s5X9+JxWxi3Qz/K4n84bNXqYaCl47VUNXao+u2xwKlnsTpydnJujhN9WRuYTqTc5KxOd1sOzswNOJgeQsOl0JhRqIhQTb5aYm8b4naMukPO0pHWDt60ITGNdP0/azFAuum55JgNVPV2uNN3Y5l2nuc2D3J56OpdBr6+jTuODc6AmFEaBxlaBel83Pn9yXCKgqcf0tdnrFpwGs0B8kV03OYmB3YHyVDhIBwOxpDvLtzuuk0va5eMhIymJIxRY+hDU5vO1SqoRBWs3o3LhJiQF8IzIThv4AZOI/t9nZKWkqA8DsaQy6dbjgD7ZfAmgjF63QYmcF45lFxOb39GZfl+yeod/Q6vOU9gZZNg0E3MvSidAe47JA5GXIGusQtOp1fNHF3ScGSkLbjbzhTJMXd3ReaqGrtIS3R6nVtGI4m+k9aAwlq/1DvMc8P8ZgLgiAMgeZmXDYpa+gWNEGyYEIGa6bm4HIr/GlX7IhB0UK5R2iMprJpDZPJxOb5nvLpEwPLp/dcVI0ja3Tuz+jLv6yfCsAbp2q9vSyjGUVR2O0VGsdOf0aNpHgLV3jaom09XR/h0YSOFgSTlmAlMc4S4dHoyxXTczCboKS+k+pRcJNIhMZRxqAur9rj0FkLcclqLzEfXG6FZw56+qcF6GaEPveLrsEBYQqDsXiSYUN1HPlelGquN0O4uE09JtnTsGhCY5jFgNLGLvaXNmM2wfuXjRB646eDKhiO1B9BQWFS2iRyk8Jzd9Kkl6NREzaK10FcUoijCgOez2OVo5367nqsJisL8hb49dKXjtbQ43AxLS+FpZMyA961Ia0Z9OK85kq9dtDyd++NjBAc006305tmH7Jz18/zaiTF3X94bmLctnh8+L48+s6jh0H7HAuCIOjINq0/4+w8Q7b/yStVMejJ/RWSQB0gpd4gmDC07wiCGxeoN+LeOVNPr6P/32pvEIyBgtrMgjSumpWHosAjMSBk13fYqGrtwWI2sXxyVqSHExE2ecqnYzHE53K0IJjR1J9RIzM5noUTMgHYWRL7rkYRGkcZg5Y2lmxRf065Eqz9P5S7LzRS1dpDeqKV6+cF7iAxxtHoXy+xUNGEgFB7qAXq8goabR5nXBexZFjNzbhhZh6FGSOIZAaWwGtCQLjcjABmrUdjqO9Ln3mMCTzzeMimXhTNzZlLktU/gVR7v3xwxcSg7qxHbY9GP8rfLebQw6bONp+l29lNWnwaM7JmBL0dwO/PY6TE3dZuO2+crAXgg8snhWen9i4o26Uue+ax097J2ZazQPjaMgiCMLbodbi8LYs2ztSvP6MvG2fmMasgjS67i8f3lRuyj9FKeVP0BcH4sqAog6LMJLrtLrb7lFh22pwcvdQG6B8Eczmf2KAK2U8frKSly27ovkLlQkMnABOzkgJu4TNauGaOep45eqmVBk+QSqwyGhOnfekrn479Po0iNI4iGnsaqeioGNjAfpiy6X94QmDet6QoKAeJ5n5RUPRLKQ2To9Gsg+PIrbgHD9/RG0WB81vV5Rmb+gSYMDoanS43z3rcrx/0x/1qYOl02MJ3fDCjgwBj64AKtfyd6QM/j1GJZx4P2dQ/eP6+z8/VdXCkshWr2cQdS0dwvw6BFkwSdT0aG85CWyVYEqB4/aCrWHTo0agJ6rq4pf38PEZK3H3hSDV2p5s5henMLwpTX8TSnWr5e8YkyJ0JwNGGo7gVN0WpRRSkFIRnHIIgjCn2lzbT63BTkJ7AnMI0Q/ZhMpm8YtCf3y3D5oyyv6NRTJnX0RidQqNaPq2aQ17zSZ9+r6wZl1thQlZSwK2wAmXN1BzmjU+n1+Hmb3ujW8gua1SF4ylRKhyHg4L0RBYUZaAofWn3sYqWOJ2bNnqCYHy5cqZaqbfrfKMugbWRRITGUYR2UToza2ZfA/ueVqjcry5Pv7bf+u29DrZ4LNTBlE0DmM19byHdxACt5NbgC109HI0XWy/SZmsjyZrEnJw5eg1tIHUnoaMarEkweV1ExIBd5xup77CRnRLvTTAbFj97wgVKr7OXE00ngPCWNvaFwYTw+1zcDm4HZE+FnGk6jcxgPA63gw41XdBfcVcTpa+enR/0XUfvMQ+zc3dEtHLb4isgfvAv81prhlDOL7oGHvnpFI/ETQyAZw9pLTwmGNZXagDesulN3vJ3KZsWBMFo3jnrKZuemW/o+e7WReMZl55IQ4eNFw5XG7af0YTT5aayJbodjQCbF6h9GreerveKyHs9ZdNrw9CH0GQy8UmPkP3XPWUDSrijidJG1dE4JTc1wiOJLJqr8a3TsV0+3TDKHY2LJmSSlmilrcfB0UutkR5OSIjQOIoY1Fl38R1V6MmdBVmT+63/xola7E430/NTmTc+OAeJ5mgEHcWAsPVoVL/cuUMIa9CEgIW5C4kz69vMux/aBfGUDRCXGJHAhhePql9Sb1pQSLzVj1OHQaXTJxpP4HQ7yU3KZWJamJJpAbNXgAnh9zkfQ2nTGmYrzWYzZS71Dr8/ARlut8LLx9S77LcvKQp615ESvUbEj9TwUFOnFUXxntN1Eb38PK9Goi1DaWMXxy61YTGbuGXR+PDsVFEGbWMQ7jR7QRDGHts9acFXGdSfUSPeauaBdcUA/H7nRdwx7o4JB9WtvThcCvFWM4XpiZEezpAsmZhJQXoCHTYn755XK072XAxv4MmNCwoZn5FIY6ed5w9XhWWfwaD13JySG509N8OF1qdxZ0ljVAvDI9HYoZbqj1ah0Woxs84T3hPr6dMiNI4iBi0nLRnY6F7jJY8QcOui8UHfUdUuSkFHMSBMQqMejkZvaWOoibAjcdk8GhLCMwy9DhdbTqp3wG5d7KcQYNA8+goBYXM+4VM6HaxD07ev3/SBn8eoxWzhcKL6x3x65nQyEzNHfMmhihaqWntITbBy1ezg+095S6ejqUejrQPKd6vLw8xjqKXTZe1lNPc2E2+OZ27O3KC20Q9/ezRGQNx92XMTY+20nPB9cWwsgdYKsMSrN3AAu8vO8YbjQBjO6YIgjEnKm7q42NiF1WzyJsEayT0rJ5GWYOV8fafXSSkMTakncXpydrK3xVI0Yjb7pE8fr6Wtx8GJKq0/Y3hCEuMsZj56RTEAf4viPqAXvULj2HY0zhufTmFGIj0Olzc0KBYZzWEwGn19GkVoFKKAfg3sNUej293Xn/GyfnBNnTbvHbBbQ3CQaBeloKMYEKYwmD4hIPjekmFxv/S2DejrpwkwuvXFHIFtZ+vptDkZn5HIskl+JrYZNI+DBh6FAXOoAkz9aWivAmuiWnIbK5itHPQIjf6+zzX363XzCkJKD47KMJjSHWr5e1bxsOXvVktoNzK09/mCvAXEW3ToQ+Nnj8Zwn1sURfG+X0L5WxQwmrt48lqIV8vjTjadxO62k52YzZT0KeEbiyAIY4ZtHjfj8uIs0hINrITxkJYYx4dWqQFbv9tx0fD9xTrlHqExmsumNbQ+jW+eqmP3+UbcitqHcFxG+JyYdy6bSLzFzImqdq/QGU04XW4qmz09GvOif06NxGQycfXs2C+fHu1hMNAnNB6pbKWt2xHh0QSPCI2jhCMNR3ArbiakTiA/2eMgqjsOnXUQl6JeTPnw6vEaXG6FhRMyQvpjaozQGN7SaWeQYTDVndXUdtViMVlYlLdIz6H15+I2tfw9Zzpkqxe/XkdjmJJhNSHglkXj/b/Da8A8utwujjQcAcLfQ80c6jH39vVbD3H+pTZHBWYrhzSh0Q9x1+ly8+rxPrd0KESiRcCI+LpSh3HUWkyhORp1v4nhb+l0mN3SZ2o7KKnvJN5i5nrPRVNYGMRd7Bu+E063tCAIYwfNVXjVLGPSpgfjY1dMIc5iYn9pM4crWsK231ik1BsEE/1ltsuLs8lNTaCtx8HPt5YAsNrgtOnLyU6J57p5akmuFjAaTVS19uBwKSREeSl8uNDKp98+U48SQuuwSNLYqZVOj84wGICizCSm5aXgVuDdC7GbPi1C4yhhUJeXdiE19Uqw9lf9vcLRwtCEAJPJpH+pXZgcjaH2UNMuSudkzyE5zsAvJIP0g/MKMGFwenX0Oth6Wv1iHFD/NANSp8+2nKXL0UVqXCozMmfotl1/CNld50dfv2ikW3FzJl79Y+6PuLv7QhONnXaykuNCLgvTesBGjaNRUfpc4iPMo/dGRpCOad1DSfwM2Qq3uKv9Ldo4K4/0MLh7ALB3Qfm76rJvf8YIpNkLgjB26PUpWdwYRqFxXEYity5S+yU/tid6S1yjgfKm6A+C0bCYTVzvEfnO1HYA4evP6MvdK1TH7PNHquixR8n3NQ8XfRLEo7kUPlysmZZDUpyFmrZeTla3R3o4AaMoCg0do9/RCH2uxp0lsVs+LULjKGHQi1KvY6N/2XRVaw/vlbVgMsHNiwpD3rfu5Y1hczSGlgo7aPiO3vgKGz7z6BVgwiAGvHmqDpvTzdTclMBCg0z+9YQLBE0IWJS/qF9/0HDQ52gM4pj3tkPFHnV5xqbh140yjtgacJlMFJriGZcysuPsJY9wdOOCQuIsof2J8QaThMm5OyINZ6CtEiwJULxu2FVD6dFY11VHVWcVZpNZP7e0n+fVcIq7iqJ43y9+937Vg9Id4LJD5iTIVW9YuBU3R+qPAJI4LQiCMey52ITN6WZ8RiIzC8LbL+7Dq1Ux6JXjNTFdimc0ZT7CVCxw44L+13FrwuxoBLW/8oSsJDp6nd6KlmihtEHrzxgb82k0iXEWNsxUTQBbTtZGeDSB097rxO5Sb+CP5h6N4NunsTFm3aciNI4C7C47JxpPAD5OjJ4WuLRfXb4sCEZrvL+iOJvCjNBLOHUXA8LsaAw2dTosvQLrTkBHDcQlw+S+vn7h7F3nWzYdUDmhAfOolZMuyw+/EGA2qafLoI556XZV4MmeBtlTdR6ZsRzqUb+ILDWN7Nq1OV287vnioke/vajr0ajdvCleB/HDHw+tR2MwQqP2Pp+VNYvUeJ0uRv0Ngwmjo/FQRSuXWnpIibdwzewCw/fnZZDy95KWEjocHSRbk5mVPSt8YxEEYcygpU1fOSs/7O0ZFk/MZPa4NGxON88dvhTWfccKTpebypbYcTQCrJqSTVayWg0wIz81IuKL2Wzig8snAtFXPl3m6bk51vsz+nKDp03N6zEoNGr9GdMSrCH1gI8FVk/JId5qpqq1hwsewTzWEKFxFODbwH5y+mT1wQvvgOKG3Fmqa8OHl47p23hfdwdMDPRobO1t5ULbBUDt52UYJb59/fp6i4TL6dXcZWdXiSc0KFDHkc7zqChKxIJgwFf0CuL3GSb9Pdo53KOeL5Yy8k2JbWcb6Oh1UpiRyIri7JD37U2djpYejef9n0fNMR2U0Oh5n+vqrPOzlUE4ezRqbsZr5xaQFB+mL4yKMug8auLuorxF3vedIAiCnpzylCqunOJnqJ6OmEwm7lmpXg/8fX9lzDpkjKS6tReHSyE+hvr5WS1mr3AUjhTzobhr+UTMJthf1syFhs6IjeNyShvF0Xg5V88uwGo2ca6uk4tRNFf+0KiVTY9yNyNAUryFlZ5rqVhNnxahcRSglU0vzV/ad4d0CGHjYkMnJ6rasZhNA+z2waK7A8aAktvBCKVHo3ZROiVjCtmJoQsqQzLEPIbL6fXaiRqcboV549OZlhegs0pnobGio4Km3ibizHHMz52vyzYDwRJsubqixKzQ6HA5ONatlsEsY+Q/6pr79eaFhbr0wgl3MMmw2DqgXCt/H7nPptUcfOq0dn7R9SZGlDkaXW6FV7TQoHCWTTeeg9YKsMTDlA3ehzVxd0mBgTeOBEEY05z3XNTPyE+LyP7ft6SIBKuZs3UdHK5sjcgYoplSj/ttcnZyTPXz+9oNs/n65tl8cdPMiI1hXEaiN+AomlyNF6V0egAZSXHeXp5vnIyt9OkGb+L06A2C8UUrc98Ro30aRWgcBQxwebndPoEF/YUNTQhYNz2X7BR9PqRaSaluYoAmUBksoplDCGsIS2hATytU7lOXLxcawyQGvHikr2w6YHSeR+2YL8hdQIIlAqUhwYq79aegoxqsSTB5+L5+0cap5lP0Kk4yXS6mKsM7zrpsTraeVr+wBPV+GQRvuXo0OBovbge3A7KmQM60EVcPNnW63d5OSYuaHqmrczdAR6PRNzH2XmyiocNGRlIc66bnGbqvfmii/+QrIF698PB1S0eiLYMgCKOfpk4bzV12TCYCv3GrExlJcdy0UDUZ/H1fRUTGEM2Ue4TGWCmb1shMjufTV04jIzlMgWpD8MEVavn0swcvYXcGF4SnJ70OF9VtPYAIjZcTq+XTjWMkCEZD69O492ITvY4ouBYKEBEaYxyX2+VtYO+9KK09Bl31EJcCk9Z411UUxSs06lU2DQYEk3gFKrcqmhqEHo5GQ0MDLm5TRbqcGZBV3O+pcDi9att62V/WDAQrNOrrTPU6dyNQNg1gDTbpWxM2pvQvf48FvC6vXhumEX7vt07X0etwU5yTzIKiDF327y2djoYejQGUTYNv6nRg55cj9UdQUJicPpncJB3LoPx1NJrC05ZBu4lx44JxxFvD+FVkkHm81HmJ+p56rGYrC/IWhG8sgiCMGUrqVTfjhKyk8LWKGAStfPrlYzW090oojC+l3iCYkXtSCwO5enY++WkJNHXZvTeeI0lFczeKAmmJVnJ0MteMFq6dW4DJBEcrW6nxiLGxQGOnHRj9QTAaswrSKEhPoNfh5kBZS6SHEzAiNMY451vP9zWwz/I0sC/drv6csh6sfR/Ek9XtXGzoIsFq5rp5+jXetwQrwAyFb5qwgQKDNxU2wD413Y5uTjedBgwWvbR5nH7NgKfC4Wh8+Vg1igLLJ2dRlBlEaJDOYTCauGuoi3QYgnZ6afM4beA8Rjtel1evbcR51ISjWwMNDRoG7zGPFkcj+D2PWhiMO0Ch0bcVhq746WgMh7hrc7p47YRaNq2X+9UvHL1QsVdd9plH7X0+N2cuSdbQA9IEQRAuRxMaI1U2rbF8chbT81Ppcbh4wfN3W1Apb4qtIJhow2oxc+eyCQA8GQXl01rZ9NTclLCHL0U7+WmJLJuk9ordEkPl042dY8vRaDKZWD/Dkz4dg+XTIjTGOJr4sjh/cV8D+9Id6s8pV/ZbV2u8f/XsfNIS9bPX6+6A8W3Eb6CrxqqFNQQYBnO88ThOxUlBcgHjUwy8SB5iHsGAAJ5B8Lpfg+2fpmOPxsaeRio7KjFhYnH+4pC3FwxBCepOe19fv6kD5zGaURSFww2HAVjaaxt2Hlu77d4/gHr22/OGHkW6R2NrBbSUqv1jJ6/16yXBOhoP13uOud43Mfz8PIZD3N1xrpH2Xif5aQmsmpJj2H4GcOk9cPZCagHk9SVLa8dcyqYFQTCKCx6hcXp+ZMqmNUwmE3d7Slyf3C/l076UeR2NIjQGi1Y+vaOkgUueBO9I4XWoinA8KN7y6ROxUz491oRG6CufjsVAGBEaY5xjDccAWJy3WH3AV9jwaXTvdiu8fMzTeF9nB4kmcLoVncqcfR2NBl7sBisEeI95/mLj7pC1VUHTeTCZBxU2jO6jVtbYxbFLbZhNBB8a5KeDyh+ONhwFYHrWdNLiI+MG0I65O5BjXnUAnD2Qkgd5sw0amTGUt5fTZmsjwWRltt0+7Dy+fqIWh0thTmE603V0a/Qd8wj3+indqf4sWgqJ6X69pK81g/9jd7gdnGo6Bfic0/VCC9ka4f2ru0N9EF7yhgaN956Hw4L35s0G8Dl3a+eXRfmLwjcWQRDGFCX1HUDkhUaAO5ZOIN5i5mR1O8cvtUV6OFGB0+WmskUcjaEyOSeFtdNyUBR4+sCliI6ltFEV96U/4+BcP08VGveVNtHcZY/waPyjoWNshcEArJ+ei8kEZ2o7qG3rjfRwAkKExhjneONxgL6+UtWHwNEFyTmQP9e73tFLrVS19pASb+Gq2fm6jkF30StMjkZLkD0ajzWqQuOCXAN7eZV5hI3CxZCUOeBpo0unX/WUNa6dlhv8XSMd08OPN6jv84W5C0PeVrBoqdMBCY1DCBuxgHZumZM6gTgYdh619OCbF+qTZK/hLeONdOm07zz6idkU+I2Mcy3nsLlspMenMzl9ckBDHHlAAToaDRIaex0ub++mmxfp+34ZkUHmscvRxYXWC0Bkzy+CIIxuSuq00unIC43ZKfFeN9MT4moEoKatF4dLId5ipjA9tvppRxuaq/GZg5cCbh+jJ2WNqnAsQuPgTMxOZm5hOm5F7bMeC2g9GnPHSI9GgKyUeBZNyARg+7n6yA4mQERojGHabG2Ut5cDPqKXdiFVvB7MfdO75ZR6Atk4O5/EOH2bUHvLG/USBU3R62hUFKVP9Moz8KJ0BGHD6NJprV+H9kU0KHTs0aiJXvNz54e8rWCxBiPuBiFQRQuac3dBmkfwGuL3butxsOdCEwCbQ3m/DEI4Qo9GRFGCmketR2MgNzK0c8uC3AX6u6X9DIMxWtzdfaGRLruLcemJLPZ8cQoLtk7VYQz95vFk40kUFMaljCMvOYzp14IgjBnaehzUe5w40eBoBLh7pSoGvXikii5bhNuTRAHa/OSlJWAOp9N+FHL9vHGkJlipau3hPU+oZCS42Kj1aIyOz1w0ol3nvRED5dOKotDgKZ3OG0Ol0wBXesqnt52NrfJpERpjmBONJwCYlDaJjARPyusQF8RveoTG6+bqFwKjob+j0ayWDIPBPRoDFwJqu2pp6m3CYrIwO9ugUlg/hA3dxV0f6tt7OVLZCqipZEGjU49Gl9vFyaaTgMEu0hHwtgjAz/e5vRsq96vLMSg0aueXBWlT1AeGmMdtZ+txuhWm56cyNU/fL3PhCD0akaYL0FENlniYuMrvl1k8N3qcAfSANVRQ97OVgdHirva36Nq5BeG9mKvYq76HMydBVrH3YW9VQATPLYIgjG7Oe/ozjktP1LVHeiismZpDcU4yXXaXt53FWEbr/TZW0myNJDHOwo0LVAHrucNVERlDe6/DO6fFuZIiPhSa0LizpJHOKL/h0GFzYneq7YjG2ud04yxVaNxV0ojDFeF2UgEgQmMM4y3h1cqmHT1QuU9d9gkQudDQyfn6TuIsJt3LpsEgB4yOQSJDEUzptHbMZ2bNNC6dtKUU2irBHAeTVg+6ipHljW967POLJ2ZSEEr5iE5zWNpWSpejiyRrEtMzp4e0rVDQhCO/+wVW7gW3AzImQtYUA0emPzaXjTMtZwBYkOE55kPM4xYDb2KEI/RoRLTU8ImrIM7/z7x2I8MdQKq9JnoZ4pb2t3TaQHHX5Vb6bnrN0//9MizaPF4m+ovQKAiC0Zz39GecURA9ziqTycTdKycB8NSByCcER5qxGDJhJLcvUdOnXzleQ68j/N/htGCf3NSEqBH3o5EZ+alMzU3B7nKz7Wx0l+U2elzHqQlW3aszo52FEzLJSo6jw+bkcEVrpIfjNyI0xjC+ZXaAKjK67JA2HnKmedfTLuxWT80h3YCTrSEOGD+DC0Ih1NJGw9DcjBNWQPzgfUWMLG/UyqZDFgI0YSPEOdSEgHk587wiSCQIuEdjDPdnPNN8BqfbSXZiNkXJnpsTg/zeNqeLbWfULybXzdO3bBqMde76TZDl74G2Zmi3t1PaVgoY5Wj0r5WBkeLukcoWGjvtpCVaw5s2DT7z2D/9PSzndEEQxjTnoyRx+nLuWFKE2QSHKlq9Cb1jlcYOtfdbXtrYCZkwklVTsinKTKKj18nW0+EXsEq9ZdPSn3E4TCaT9/t7tKdPa0Eo+WPMzQjqNcUGb/l0dAvCvojQGKMoitLnftEa2A8hbGw5qZ44jBACwCAHTBgdjc4AUmEHhO8YgR/ChlHljR29DnZfaATgurkhvl80YUNxQwDH+HLCEr7jB3Ge38fv0ukY7s/Yr1egxXNzYpDP4p4LTXTZXRSkJ7CwKEP3cRgdTDIibndfMFOA8xhoawatVH1C6gSyE7MD2pdfRIGjUbuJcfXsfOKtYfz60dMCNWqyNMXrvQ/XdtVS31OPxWRhbs7cIV4sCIIQGiVRKjTmpyeyfoZ68frcocgmBEeahk5VxBBHoz6YzSZuWzwegOcOh/+9pQmNUjY9Mlr59Dtn6iPiPvWXsiY13GdyzticU618Opb6NIrQGKNc6rhEq62VOHMcs7JnqQ8OImzUt/dyWOu3N8eYUjVDxAAdg0SGwmLSShvxKxXN6XZyqukUYGA6qZ/BE2ZPD0u9xYBtZxtwuBSm5qWE/oXY130YwnvD2yvQSHHXDyzmAByNvW1QfVhd9hE2YoV+5aTDfBa3GNxvz3tuiVSPxvpT0N0EcSkwfmlAL9WOh789Gr3irlHvcz/Pqdq5xak4UQIo+x4JRVF4Q7vpFepNjEApexdQIHcmpPclXWvnlumZ00mOG5tfXAVBMJ6+xOm0CI9kIHcsLQLgn4erIpoQHGn6HI0iNOqF9t7adraBJk9perjQhMYpEgQzIguLMijMSKTL7uLd842RHs6QlDepczo5Z2y6VDfMyMNkglM17dS390Z6OH4hQmOMorm8ZmfPJt4SD7YOqDqkPjmlT9h463Q9igKLJmYyLiOEfnvD4HXX6ek+DIOj0eqTyu3y44L6fOt5el29pMalUpxRbMygGs5AVwNYk2DC8iFX85ZO6+z06uu3p4MQoM0hBD2PPc4eSlpKgOhxNCr+HPPy3aqTM3saZBQZPDL96S80Dv5ZdPv22zNIOPK66yLlaNTcjJNWgzWwcqo+R6N/bl7DewX6eU7VSqchgH6kfnC+vpOypm7iLWaunBXmdOchbt5of0cjmWYvCMLoptvupKq1B1D7oUUb181VE4IvtUQ2ITjSSI9G/Zmen8aCogycboWXj9WEdd99QuPYFKUCwWw2efusazeEoxGvS3WMOhpzUhNY4Kke23YuNlyNIjTGKF6Xl3ZRWr5HdY1lFaupmh62nNIcJMY13jdEDPC6bwwsnbb0ObD8KW881qBelM7Lned1/eiOdkE8aTVYh/6yY4TTy+Z08Y63354O7xcdhMZTTadwKS7yk/IZlxJmF9Rl9KVO+yG+xHDZdEtvC5UdamP4+Xnz+/qlXjaHRy610tBhIy3ByuqpxvTbM+QmRiCEMI/esCk/bmL4tsIwTGgcYh4vx7cPqp7ndO0mxhXTc0hNsI6wts4MMY+ai9SQ8B1BEATgQr16cZyTEk9WSvT1/0uK70sI/uehyCQERwMNIjQawu1L+hyz4UJRlL4ejXkiNPrD9Z7y6bdO1+OM0lTjck/pdPEYFo83evo0bo+R8mkRGmOUAYnTgyRqdvQ62H2+CYDrDUz4tHpDMnQ8MXndNwaGwZgDExoH9MQ0Aj+FDSPE3b0Xm+m0OclLS2DxhMzQN9hPaAxunIaXkwaAVXM0+tOjMYaFRu19XpxeTHp8+pCfRa3f3lUG9tvzirt6nlv8xeWEsl3qchDzaA0gDKa6q5rm3masZitzcuYEvC+/8DOcSRN3QWeh0eBewUPSWQ8Np9VlnzYGLreLk00ngci7pQVBGL2UeBKno60/oy/vX9qXENxjj94ebUaiJdpK6bS+3Lp4PBaziaOVrVxo6AzLPpu67HT0OjGZYFL22HS/BcrK4myykuNo7rLzXllLpIczALdboaxJczSOXaHxyllqQOfOkoaoFYR9EaExBnG4HJxpOgMMFgTTl6i5/VwDdpebqbkpTMsz7guOIcmw4ejR6CM0+iMGGJ5O6nb5BE9cOeyqRvTF1IQA3frt+QgWwc5jNJU2Ws1qKMqIoldXI9SpjuNY7s/odXkN8Vn0uqUNvIlhVOiRX9QeBVs7JGRA4aKAX27xtGZw+dGjUTu3zMqaRYLFoIscP13iVp8bBHo5pmvaejh6qQ2TCa6Zk6/LNv1G+9s4bgEk94XsnG89T4+zh2RrMlMzpoZ3TIIgjBm0IJgZBdErNK4ozmZCVhKdNqf3b/tYotvupMsjsOamRp/rNJbJTU1gw4xcAJ4Lk2NWczOOz0giMc4ywtoCgNVi5po50Vs+XdfRi83pxmo2MSErKdLDiRiLJ2aSmRxHe6/Tm8ERzYjQGIOcbTmL3W0nIyGDiWkTobsZatULVV9hQ3McXTuvAJNJ/6AGDWPCYMKQOm3y39HYae/kYttFwEB3Xe0xNUQkIX1EYUMTA/QSd/v329NJODKbAc8xDnKcWosAQ12kfhJn8dPRqInF+fMgNcy96HRgQAnvIJ/F8/WdXGzoIs5i4sqZxv2ORiYgj4gmUBWv6x9s5CcWz19Xf25ihCVZ3U+XuBGOxrc855alk7LITzOmV/CQDHITDvrOLfNz5/crFxeEofjNb37DwoULSU9PJz09nTVr1vDaa69FelhClHNeS5w28IZ/qJjNJu7QSlzHYPm0FgSTYDWHv7XHGOB2j2P2uTAFDpU2SNl0MNzgqTjZcrJW1zBAPdDE4wlZSVgtY1e+sphNrJ+hpU/XR3g0IzN2ZyqG0XoFzs+drwqIZbsABfJmQ5oqEtmd7r5+ewYnfBoiBoRBaDSbTWhao3OEwIaTTSdRUChMKSQ3KdeYAWkXxJOvAMvwX3T0FnePXmqlvsNGaoKVNdN07LcXwjw29jRS01WDCRPzcufpN6YgifP8LiMKjTFcNq0oysD+r4PMoeZ4WDstl7TEOMPGo7VliEgYTIjz6HU0BuKWNrJFgJ+fRd/+s3rdyNii902MQBiqP6NHUI8Gt7QQG0yYMIEf/vCHHDx4kAMHDnD11Vdz2223cfLkyUgPTYhiznsdjdGXOO2LJgbtLGmImURTvdD6M+alJRhqzBirXDe3gNQEK1Wt4QkcKm2SIJhgWDcjl+R4C9VtvRyvaov0cPoh/Rn70Awe22MgEEaExhhkgMtrkAupvReb6LA5yU1NYMnETEPHY4gYoLlqDBYYtD5qIwXDGh7UAAEJG3qLu5oQsHFWHglWHd09fvaFGwxNUJ+WOY2UuMj/Yenr0TjCmyWGhcaKjgrabG3Em+OZmTVTfdA88LOouaWNLJuGCDoanXY1YAuCnkern2EwDreD081qD0FjHY3+taMwmUy6ntPbehzsuaD2Cg57f8bWCmgpVf+eTFrT7ynNRRoNbmkhNrjlllu48cYbmTFjBjNnzuQHP/gBqamp7N27N9JDE6KUXoeLco/oEY2J075MyU1h2eQs3Aq8cKQ60sMJK5I4bSyJcRY2e8JGngtDKIzmaBzLvfyCITHOwlWeHoCvn4iu8mnpz9iHJjSeqGqnviO6bwqJ0BiDDBC9BhE2tDJY3frtDYMxPRqNdzRCX5/GkRyNmuhlWDppgMKG3uKut2xabyEghHkMi7gbAH45GtuqoOk8mMwweW2YRqYf2vt8Ts4c4iwep6JXLHaD201dey9HPH1Brp1jsNAYqR6NVQfA2QPJuZAfXDiLN3V6hB6NJS0l2Fw20uLTmJw+Oah9+UUAn0U9Bd5tZ+txuhVm5KeG311Q6mljULQUEtO9D3c7urnQegGIjqApIfZwuVw8+eSTdHV1sWbNmkHXsdlstLe39/snjC3KmrpwK5CeaI2JkJE7lqrl088euhThkYQXERqN53bPe+uV4zX0Ooy9eayV2U6R0umA0QwE0dansaxRExol3CcvLYH5Rep32h3nGiM8muERoTHGaLO1UdZeBngEmI5aaDwLmNSSWy7rt2ew4wiM6tFofBgMgNWP8kZFUYwXvaoPgaMLknMgf+6Iq+sp7l5o6OR8fSdxFhMbZ+ncb89zfIOZR+8xjxIhoK9H4zCitNafsXAxJGUaPia9GVA2Df37Eyou77llyaRM8tON7ben9SINu6PR9+ZNkGVU/qZO+4ZM+ZYt604A51Q9Bd4tYfxbNIAh3MUnm07iVtwUJBeQnxzmcBohpjl+/DipqakkJCTw6U9/mueee+7/s/fecZLc9Zn/uzpNzjlsjtpd5YCQQIgkgkAIOIINmIyNJdvYZ59Pd/bZd7bR2T7/HDHJ2GCyySIKZJAEAgmlVVrtrjbvzu7knDrW749vV3XPTIfq7ko983m/Xvua3p2e7tr+Vtd0PfV8nod9+3L/zr7zzjtpaWkx/2zatMnlrRW85rmRdD5jd2NVjOS+5uJ+IsEAh4fneOa8v0YnnWTMbJyWIhinuHZbB30ttcwtJ7j3iHMjn9ntxNtlzLZkXrK3m0gwwPGxBY6Nznm9OSbG6PQWWVMAbtytPrv6PadRhMYqwxACNjdtprW2NePY6LvEbNR8amiG4dllGiJBrrMzby8PptBYZRmNkO1ozC8GjCyOML40TlALclFHee6mopjFEy/MiHMFMAQJO8RdQzh6/o5Omu3O2ytzHVN6imfGVe6VX0YbQ6ajsYDQWMVj05CjcRoyawiQSmTl7Tk/Bmvnfl4SNqyj6Wgs5pZ2owgGSnM02nRMjyaS3OtSVvAadL1oPqNjDnVh3bJnzx4OHjzIQw89xAc/+EHe+c53cujQoZz3veOOO5iZmTH/nD171uWtFbzGbJzu9nc+o0FLfZiX7VMnsBupFMZwNHaJo9ExAgGNWy7tB+CuJ5zbty7MqnbicFBjoHXjthOXS1NtmOt2Ku3g7nRMktdki8cyOq0wjEE/fW6cRLJIpJeHiNBYZRgnpWaA/Zmfq69bXmDex7hSdMNum/P28mC66+wcbzTdN+4IjYUcjcY46a62XdSFHPqldTq9jltfUPh+aczRaZtGGwFedpEDzp4yhcaTMyeZj89TF6pjR+sO+7erDCLpUeKCo9MlrqOfiCVjHJ48DKwqyMhqIV5ajvLgCZW358j+sopst7RrDXiJKJx7RN2uYB2tXMQAFyMCNOvHVHN0ukKB99FTUyzEknQ11XDxQEtFj1Uy06dh7jwEwjB4zYpvGS5SKYIRSiUSibBz506uvPJK7rzzTi699FL+/u//Pud9a2pqzIZq44+wsThuFsH4O58xmzemS2G+dfC8r09g7cRone6sgvH2auaWy5TQeM+zo8wuxx15jtPpEdtNbfUbup24Eoz2ab/kNI7ORVmOpwgGNAbbRDwGuGxTK821IWaW4jyejrPyI/IOrDKMEyTTiXEmHUK+JZMRdN9RJRzZPgabB2cdjc46mUwxoECOmuNCQDIB5x5WtzfnznpajV3i7nw0wSOnpoCMDdtWylxHMyuw/SLTSeg1xug0+RyNcyOqeAINNl2T+z4+5vDkYeKpOG01bQw2Dma+kfX6P3JqnFgixUBrHTtdCLbPXnvXXI3nD0IyqvIZO3aW/TAhCxcxZmOznJw5CbgQEVBCMZM5Ol3hhR6jEe9Fu7sczwpeg/G7sf8yiKzM9HHNRSqse1KpFNFo1OvNEHzKc+nRwx0+L4LJ5obdXbTVhxmfj/LzdJHXemdMMhpdYV9fMzu7G4klUtztkIg1mh6D721xNtpnPfOyfT0ENDUhOTS95PXmmJmbg211hEU8BiAUDPCidHHPjw/7d3xaVquK0HV9ZYba0hSMqrZSNj0PgOnFmFnUcMNud4RGM0fNkYxGZx2NZut0AbeUIXo5dlI6+gzE5qGm2XLxhF3i7s+PjZNI6WzrbGCzEwG7mvVcuGz8ONoYMUWvPP+Xs2lho2c/1Lrs3rKB7EzMFVlSWWLfL55TYxQ37O5yJW8qmOWmdE1oNNZx87Vl5zMCBC3kvxrxAAONA7TXtpf9XJYoJaPRJkdjttDoOobQmP7daDCyMMLo4igBLcD+jv3ub5dQtdxxxx3cf//9nDp1iqeeeoo77riDe++9l7e97W1eb5rgQxLJlHmC7PfG6WzCwQCvuUQ5z77pQkOwHzBHp8XR6CiapvE6c3zamWZzo4VX1rJ8OhtruGqL+kzqlCBcCqdlbDonL92rhMafiNAo2MG5+XNMRacIB8Lsbd8LZx8GdGjfAY1qZ/vZsXFSOuzpaaKvxR17sTNlMC47GvOIAYlUgmcnlZjrmOh15iH1dfDqlcUbBTDE3ZRe2ViL40JAmYJxzlISjwkHjYzGPMKRsY6rhI1qIa9zNxAA1PvkoWPql5lbwlEw6/3gWiHMmSyhsQKsOBpNQd2NHNISYgyMaIZKji/DM8scHp4joMELdnaW/Thlczb9fly1jsaxZWfrTurD0l4oWGd0dJRf+7VfY8+ePbz0pS/l4Ycf5u677+blL3+515sm+JDTk4vEkzr1kSD9Ln0et4tbL1di0N3PDLMYc/aCvx8YnxNHo1u87jLVPv3AsXFTFLQTo9inW4TGinjFATU+7Yf26ZMT0jidixft7iKgweHhOc5NLXq9OTkRobGKMMam97bvJRKMrHTepLnPzGd078TOdL9UYRlMqEhhw/Hp4ywllmgIN7CtZZszG3HmF+qrxbFpsKcVVtd1U2h0bH8pYx2XEkscnToK+MvRaAiNaHn28zLW0U+YsQy5RK/0Og5NzhEMaGZQtNMYghe45GjU9YxAtakyodFKRqPZOO1Gs3opZTA2tNrfnz62XDLYSluDy02eS1Mwmi7oWLWOMjYtlMunPvUpTp06RTQaZXR0lHvuuUdERiEvRuP0jq5G96MjKuSKzW1saq9jIZY0CwPdxLVMZmAxlmAhpj5fdDZK67TTbO6o5/LNraR0+M4TF2x//EyDuAiNlXDTvh4AHj41ycS8t/Egp8eViLZVGqdX0NYQ4cotbYB/XY2+FxqHhoZ4+9vfTkdHB3V1dVx88cU88sgjXm+WJxjul0wRzEoHVbZw9CIn8vbyYBaT2CkElFBcUAmBIhmNZvlOxwGzAdd2TOeNdSecHeLuifEFzk0tEQkGuHa7Q8JRGULjsxPPktSTdNZ10lPf48x2lUGNITTmymiMLcKw2ldKWUe/ML08zZm5MwDs78wxTpre30Jaiis3t9nfTp4H1x2NE8dgcQJCtdB3aUUPVaxoStd1d0WvEtzFdrjUPR2bPpvOvG3fAY0rn9+18h1BEDY0x9L5jNU0Nm2gaRq3pp1n3zrozIhrLn5xfIIb/uonXPnn9/C+zzzCx+47zqOnJ4kmnPv9bxTB1IQCNNb4IxN8vWOMT3/LgfHpMRmDt4VN7fUcGGgmpcM9z3rbPi2N0/l5yV51nvyfIjSWztTUFNdffz3hcJjvf//7HDp0iL/5m7+hra3N603zhEMTyqFxoPMAJGIwlBZc0w6qw8NzjM5FqQsHuWqre6+RHe6XNRgnxQ67mIqNNxqveU7xxQ6mz8LskBJWB660/GN2iLuG+/Wabe3URxz6cFVCAYWBuZ93HHAlB9AqZjGJllp7tX3oUSXgNPVDyyb3N65CDk2q13xz02ZaanLkS6b/7wFSvMilkimAgBZAS49t29pqnw/DlTpwJYQqczZkHI253dIjiyNMLk8S1IIqCsNpzPdiSjk3C2Dm7pYp7iaSKX76XFpodHF/Mcnh9gc1Cv7shIrCkMZpQRCc5Fi6cXpnFTVOZ2OMuN5/dMwVR9PnHjzNOz71EGcmF5lciHHPsyP83+8f5o0f/QUX/+kP+c3PP8p81P7PAdnClJ8+c65nbr6kn2BA44mz05xK55jahelobJQymEp5xT41Pv19D3MadV3n9IQ4GvPxknRO48+PT/gy5sLXQuNf/uVfsmnTJv7t3/6Na665hm3btnHTTTexY8cOrzfNdVJ6isOThwHVxMvwk5BYhrp26NwFZBwkz9/RQW3YWtafHVR3RmO6sCHPiffhifRr3mGtpKVkjDy4vkshYv0Aaoej0RXHUfr1LWUdjUxMx17zMqkJZRyNa4TpM/YUiHiFeWzJ85rrhqORpOsONUeiGfJhY86mWTSVJ+bQeM23tWyjNuTCB+Ls/Ncir2Wl0QxPnJtmdjlBS12YSwdby3qMisiTszk0N8R8fJ5IIML21u3ub5cgCBuGY2NpobGrOoXGnd2NXDzQQiKl892n7B9xNYgnU/zxN5/mj775NImUzi2X9vPV33g+/+PVe7lpXw8dDRFiiRTfe2qYX/vUQ8wux219/nFpnHadrqYark9nN9vtmJXRaft41cVKaHzg2Ljt7zurjM5FWYonCQY0BlqrK+vWDXb3NDLQWkcskeLnxya83pw1+FpovOuuu7jqqqt405veRHd3N5dffjmf/OQnC/5MNBpldnZ2xZ/1wNm5sywmFqkJ1qisQMN5s+l5prBhONTcFgIqdb/kxOWMxlw5avFU3MwKvKjdIdErj/OmGJUKAcvxJA+eUAckRx1HZayjIcC44vIqgUgwPS6spdbuL2Wuo18wBPV8r3lCV/tbZ32QfX3Nrm0XOBTNkA8zZ7PydSzmaDQFdaeOLavJag8v9n6sVNw1fhe9cFen+Tq4RiKmHMawJp/ReM13tu0kHHBn/F8QhI3J8Iwquhhsq94Cg9dd5mz79NRCjHf+6y/57IOn0TT4g1fs4e/fehlXbW3nAzfs4BO/dhWP/NHL+MpvPJ+WujCPnZnm1z71S2aW7BM9xqQIxhMy49NDtmVyxhIpphbVviFCY+Xs7G5iZ3cj8aTOj5/1ZjT3ZNrxOtBaRyTka9nKEzRN46UXKVejH8enfb1iJ06c4KMf/Si7du3i7rvv5oMf/CC//du/zWc+85m8P3PnnXfS0tJi/tm0qfrGGHNhjHvtbtuthL1Vjo35aIJHTk8C7guNdhSTrMElodHMUcuR0Xhy5iSxVIyGcAObmhzaj8p0UFUqBDx0cpJoIkVfS62z+UElrmM0GeX49HEA9nXsc2qryiJTBrPK0ZhKZjLhqrRx2hBg9rXnfs2jKfU+uWZzs+uh9q45GufHYFLte2y6puKHCwULxzIYx3TXnLslCI2Virue5jPmcPsbuC7uCoKwIYklUozPq+y/nubqFTxuubSfgAaPnZnm9IS9I66js8vc+s8P8PPjEzREgnziHVdx24t3rhlf1jSNq7e28/n3PY/W+jAHz07zjk89xMyiPWLjuGT6ecJN+3uoCQU4MbbAM+ftMQUZaxkOarTWycVEO3jlfmN82jlXcyGM446MTefHGJ/+8eERV4u0rOBroTGVSnHFFVfw4Q9/mMsvv5wPfOADvP/97+djH/tY3p+54447mJmZMf+cPXvWxS12DuMEaW/73pXNqGmh8RfHJ4gndbZ01Lv+ZjRKUux1NBrFBe5kNOZyNBrOuj1te5wpglmegZGn1e0yHY1lCwFZ7ldHM2lKHIE/NnWMpJ6ktabVV0UwAJGsMpgV+8vosxCdgUgj9FRf7ttifJHTs6cB2NuR29G4lNalrtqSI7/RYYz3nuMZjcYxtesiqKs849aIZcjXOu26c1fLGp0uctyo5Jg+MR/lyaEZwCOhMduVuurYJkKjIAhuMJYleLQ3VG+TcXdzrWMjrh+97zinJxYZbKvja795HS/fV/gz34GBFr7wvmtpqw/z5LkZ3vapB5lejFW8HabQKI3TrtJUG+Zl6TX/1kF7HLPZ7tRqa3r3K688oITG+46OeZIBeNJonO6oXme401y7vYO6cJCR2ahtor1d+Fpo7OvrY9++lQ6biy66iDNnzuT9mZqaGpqbm1f8WQ+sOCmdPAELYxCsgf7LAbjvqLLLenFiZ45O25rR6G7rdC7XkeOOo3MPAzq0bYWm3pJ+1HSRlvn6uLa/lLiO2YK630K5jdZpTdOJJ7P2dWNsevAqCFZfY+GRqSPo6HTXd9Ne277m+yOzy6aj8fIB97OmTHed045GG8emAYJa/mPL9PI0FxbU1WHXhMYVjsYiGY2B8l3qPzs2jq7DRX3NdDd7EMZuuP1XuYt1XTeP6fkEdUEQBDswxqa7m2p991mmVIxSmG8etG/EdXY5zn88rIwgf37rAfb2WjtX29ffzBc/cC0dDRGeHprlVz/5EHMVZseZ4pQ4Gl3HGJ++64nzeac/SkHyGe1nf38zm9rrWI6nuDdtUnGT09I4XZTacNC8IPRjn41P+1povP766zly5MiKfzt69ChbtmzxaIu8IfsE6aL2izInUv2XQ6gGXdc9HVUz3XWOZDS65Whcm6O2wkXqBObYdOnCRiXi7rmpRY6PLRAMaFyXPjA5hlaaM3XFfu4zwqGMUBNNZn2wrWAd/YDR8p3vNb/v6JiZ0dhS4/6vDHN02umMxlUu8UoJFnBLG8eWwcZBmiJNtjxfUQIBSDd4Wx6dLuP461VWMJDT7W8wtjTG5PIkAS3A7rbd7m+bIAgbhtFZJTT2tlR/8+0r9vdQG1Yjrk+l3eqV8h8Pn2UhlmRnd2PJvyv29jbzpQ9cS2djDYcuzPLh7x2uaFuMEfcuyWh0nRft6aK5NsTIbJSHTlZeZGE2iMta2oamabzqQB/gTfu0kdG4tVMcjYXwa06jr4XG3/3d3+XBBx/kwx/+MMeOHeMLX/gCn/jEJ7jtttu83jRXGVkcYSo6RVALsqttV1bxhHJsnJpY5OzkEpFggGu3d7i+fY4IAS5nNKZWXaVN6SmOTCqR2zHRqwIHlSHupvQ8lbYFuP/oOABXbG6lxekMkxLXsVj7sZcY4gtAItvRmKfhtloo9prff3SMpPGrwuH3Yy4cabVfTXwJzh9Ut23K2TQyGlMFYhlc388tvh/LPaanUjr3P6eOL54IjTnc/gZmy3fzNupC0lwoCIJzDKeFxmrOZzRoqg3zsovUiOs3H698fDqRTPFvD5wC4D3XbyvL8bmrp4l/+JXLAPjiL8/ws/TvnXIwW6fFBec6NaEgN1+iRKy7bBjNF0ejMxjj0z9+doTluAvFjGl0Xef0hDE6LY7GQrx4jxIanzw3bb4P/ICvhcarr76ab3zjG3zxi1/kwIED/Nmf/Rl/93d/x9ve9javN81VzBOklm3UhmqzhI3nA3DfEaVeX72tjYYa90c3HRECNHdGp01H46oymKG5Iebj80QCEba3brf/iZPxTDNqOUJjoPzRaVfH7EsQGhOphNny7bfGaci85pDlaJw9DzNnQAuo0ekqpFBWYDKl89Pnxj0VGh1ptV/N0GOQikNjr4oysAErjkbXnbsWowzKPaYfujDL+HyUhkiQK7dUnnNZMqvc/tnI2LQgCG4xMqtO9Hq8iI9wgFvT49N3PXGeRLL0C9zZ/PDQCEPTS7TVh3nDFQNlP851Ozp5x7Vqwu0Pv/Yk89HyPp+MS+u0p9xyqdoHvvfUBaKJyj7nidDoDJcNttLbXMtCLFmRqF8qY3NRluJJAhoMtomjsRC9LbUcGGhG1+HeI/5xNfpaaAR4zWtew1NPPcXy8jLPPvss73//+73eJNdZMU66MAHjSowxnDeeNnzikBBgnBA7PC5pFDaszgY5NKnGSXe27SQccMD1N/wUxBehtgU695T84+UKAfFkigeOqfGEF+3uLvl5S6aEdTw1c4rl5DJ1oTq2NPsvHiGYVaYRT6Q/0BrCRs8BqHFpBNZGYskYx6aOAblFryfOTTOzFEc3BGOnx5dz4IqjMdslblOeVshC/qvrgrrFSIpym76N30XX7ewkEvLg48Uqt382UgQjCIJbjJiOxvUhNN6wu4u2+jDj81F+fryyEddP/ewkAG973hZqw8Ei9y7Mf3/VXgZa6xiaXuIvv1/6CPViLMFCTP2e65QyGE+4Zls7vc21zC4nzOiVchmdM7JRRWi0k0BAM12Nbo5PG2PTA2113nymrDJeslc5z/2U0yirVgWYJ0gdF2Xypzp3Q307y/EkvzjhonCUA7OYxM5WWJcyGoPpd8Bq15E52ujY2LRRWHBtOjutNMoVdx87PcV8NEFHQ4T9/S4UJZXQHp6dielIy3eFZAuN0eQqoTHtLq42jk0fI6EnaKlpoa+hb833jQ99dTXpD+BOF7LkoBL3rmWy3482EdBy579mt3y7Pzpt7f1oZjSWKO56fdGr0PvR8WO6IAhCGkNo7F0nQmMkFDBHXL9ZQUPwwbPTPHp6inBQ49eeX/kF5YaaEH/1Xy4B4LMPnubnx0tzW43PqXzG2nCARg8mwgQ1/fHaS9W+9a0nKhufFkejcxhC4z3PjhCv0NVsFRmbLo2X7lU60P1Hx4gl3FmjYvjvbF5Yw4rRRtOxoU6IHz41yXI8RW9zLbt73G+EhfLdLwVxKaMxlMfR6Lj7pYDzxgrliruGEHDD7i6zcdtRSljHQiO8fkDTNNDVaxY3hMYK19Frsl/zXDlJxv7SUJc+WVqPGY2plO1FMJDJaFx9bDk6dRQdna66LjrrHC5jWk2JGY2liLuzy3EeOz0FeCQ0Lk6ucfsbzERnGJpXJ8d72kt3kAuCIJSCkdHYvQ4yGg2M8em7nx5mKVbe72PDzfjaS/rptkmEvX5nJ7/6vM2AGqFeKGGE2igP6Wysqfp28GrGaDa/59BI2SPwkFUGI0Kj7Vy9tZ3OxggzS3F+UaGr2SonpXG6JC4eaKGzsYaFWJJfnpz0enMAERp9z/TyNBcWLgBpAWZVw62RlfDCXZ2e/ZIs1/1SEJfLYLLFgOyWb0fyvHS94qbicsXdnx3L7C+uUIbQ6G/HkTpkxlIJiM6pEXio2sbpQi3fM0txnjw3DUCTh0Kj4xmN40dgeQbC9dB7sW0Pm2902vE2+0JYFRrLEHcfOjFJIqWzrbOBTe0eZOmscvtnYxR7DTQO0FLT4vaWCYKwwRhNZzSuF0cjwJVb2hhsq2MhluRHz46U/PPnp5f43lPqfOY9L9hm67bd8aq99LfUcnZyib+++4jlnxuTfEZfsL+/me1dDUQTKX74THmjubquZxyNjevnfecXggGNl+9zd3z6tCE0dorQaIVAQOPFe7oYaK1jbjnu9eYAIjT6HuOkdFPTJpq0MJx/TH0j7bwxxqav3+myMyYLR0YbLZYWVEouMWBsaYzJ5UkCWoDdbbvtf9KpUzA/DIEwDFxR1kOUI+7OLsd5emgGcHF/sShs6Lq+MiLAr+hqv4wnE3DuEdBT0LIZWsoPNPeSQs7dX56cJKXD9s4GIuF0TqmHjkZboxmyMdrfB6+CoH15rEb+6+pYBlPc9WI/t1iyVY64a1zhvm5HR3nbVinGOuZwpUo+oyAIbjEfTZiurPWS0QhqqsNwNX7r8dLHpz/zi1MkUzrP29bOgQF7L/g01Yb5v29UI9Sf/vkpHjllzc0zLg44X6BpGq9Ll8J8q8z26floguW4GheV9XSGV6XHp390aDhn/rjdnBw3RqelCMYq/+d1B/jZH76YV128Ng7LC0Ro9DkrxkkvHIRkDBq6oH37CuHo2u0endyBmadnr6PRerZfJeRqhjVbvpu3UReqs/9JDedN/2UQLu/xzde8hNfnlycywpFrH34truPQ/BBzsTlCgRA7Wna4sGHlknY0JhNZ47bVOTadTCUzLd85nLuGcHTtjg7X3o+5MN11Tj13he7ifORzNHrq3LVY6mMcX0oRd42LXs/3TGjMv46eukgFQdhQGPmMTTUhGtZZ7t+tl/cDKlZlciFm+ecWogm++NAZAN5rs5vR4IbdXbz5qkEA/uJ7z6LrxYWQ8XlxNPqFWy5T+9bPjo2b61IKhpuxqSZEXaSykiEhN8/f0UFLXZjx+RgPWxTzy0XXdXE0lkFdJOirGAgRGn3OCieGWVigmlEN4WhbZwO9Ld5dNTXddY5kNDorbGRy1DKhqY6OTUPGebOpfIHKdJHqCUsfpiAjBDzPTVFasyZQGeLLrtZdhG10ldmNlj5kxpNxW9bRS07PnWYpsaRavpvWhrIb+8u12ztcez/mwowJcCqj0aGczVwXMeLJOM9NPwd4NTpt7f1Yqrg7tRDj2QuzADxvmwdCY3x5jds/m8MTaXHXz25pQRDWBSMz6y+f0WBndxP7+5tJpHS+mx6DtsI3Dw4xu5xgS0c9L72ox7Ht+/1X7KEuHOTxM9Pc/Uzx8W7T0SiN056zrbOBSwdbSKZ0c8S+FEalCMZxwsEAL0u/f3/g8Pj02FyUxViSgAab2sTRWK2I0OhzVozZnf2l+sdVY9NeuhnBISHApYzGTDNsRgxwvgjmYfW1guIJQ9wFSOnWmqUMh5qrjiOL63ho4hBQDUKA2tdjiTice1T9k40FIm5iHFv2tO0x38MG04sxDg8r4eja7e2uvR9z4ejo9PyoijJAg8GrbX3oXPmvx6aPkUglaIo0MdDowbi9xXU0R6ctHtMfOqmOLbu6G735kD/8pHL713dC+/YV31pKLHFyVhUQyOi0IAhOMzKXbpz20ADgJOWMT993RBXLvfmqTebvRifobqrlfS9Ujsm/uvswiSLtuGZGo4hTvuCWy8ofn5a1dAdjfPr7T18g5eD49Kl04/RAWx2RkMhV1YqsnI9ZjC9yevY0kHa/GI6NgasAeNDrUbU0jrTCutY6vVYMcHS0MbYAY0rgMdaxHLKFIStC4/RijGezhSO3sLiOfm+cNjAcjcHZ0xCbUwUiXdUpXhR6zR88MYmuw87uRrqbar0VGtP7eiplTVAviaH0MbVrD9TamxmVLTQaruPsY4snow0OlcE8eEKN0Hj2u8hYx8GrYNXrenTqKCk9RUdtB131HrRhC4KwoRieUYJHT9P6FBpvuawfTYNHTk9xdnKx6P11XeeR01OAO8aID9ywnbb6MCfGFvjKo+cK3nd8Xo1/d8notC947SV9aBo8anHfymZMHI2u8MLdnTTVhBiZjfLomSnHnscYm97SLmPT1YwIjT7m6NRRdHS66rrojMdg7gJoAei7hOnFGIfSo2rXbnNROMqBI62w6YywYllilWIUNhhC40x0hqF5dZV2T/se+5/wwhOqQKSpD5rLD2o1hACw5vR66KQSjnZ0NSjhyC0MQbTIOlZH4zRoaUdjeFptL32XQrA6M5gKle+YFzGMkwKL6+gEjrTaGwylXan95ZUyFSKU5dowrmN4nhVodXS6xFZ7M8/TK3d9gXU0xqYdi8IQBEHIwsho7Fmnjsae5lqz9OtbB4u7Go+PzTO5EKM2HOBim0tgctFUG+a3XrILgL/90VGWYvl/j5kZjSJO+YLurH3rridKczWOmWPwspZOUhMK8vJ9anz6u0+WPuJuFWMUvm+dHkc3CiI0+hhjnHRv+96MY6N7H0QaVgpHHrfaOTLa6HpG40rH0UDjAC01DnwgMtZx4MqKHsYQd8GaGODJ2DRYWsfxpXHGlsbQ0Jxp+bYRw9EYSefsVbqOXqHreiaLNKejcdX+4mUZjBOt9gamS9x+oTF7PCyRdmMWes1dweI6liLuTsxHOTIyB3goNJ7Pf1yVxmlBENzEFBrXsXj1uvSI6zcPni+aE/7Lk8r1dNmmVtdGIN927WYG2+oYnYvyrw+czHs/c9xWxCnfYLRP31Xi+LQ4Gt3j5kuUUeZ7Tzk3Pi2j8OsDERp9jOny6rgoy7FxOeChcJSDUt0vlnBpVHN1YYPjzrpV61gu2Y5GK2JAxqHWWdHzlowpbORfR0N82dqylfqwvwN/DaGxZiYtNFa4jl5xYeECs7FZQoEQO1t3rvjexHyUw8NKOHqe4Zb2QUaj7Y5GXc+8Hx0QGkOBzK/XZEonmUpyZOoIAPs69tn+fJawOjpdgrhrjE3v7W2ivcGDQP2laZg4pm7neD+K0CgIgpsYQuN6zWgEeOWBXmpCAY6NzvPM+dmC9zXaaa/Z6t70VU0oyO/fpKaSPnbvcaZyNGQvxhIspt2OIk75h1cc6CUSDHBkZM4smbOCIUx1y1o6zgt2ddJUG2J0LmrGItiNOFTXByI0+pgVotcqx4ZnwlEOHBltdEto1FY6Gh0fbSzgvCmFgJZ56xYTAyYXYhnhyM18RrC0jtWSzwiZ0ema+TPqH6rU0Wjs5ztbdxIJrhSHHjqpTgr29DTRYfyC91BodCSaAVQJzNIUBCPQc8DexwaydEYSKZ0zc2dYSixRG6xla/NW25/P2kbZn9H4oNelZOcfV1/btkLDym2Ip+I8N6UuCojQKAiCG4zMpgUPj6eNnKS5Nmy2zxYbn/5l+jPF1S7HPN1yaT8X9TUzF03wkZ8cW/P98TklPtaGAzREgmu+L3hDS12Yl+ztBlRbuVWkddo9akJBbtqnSmG++2TpxT1WEIfq+kCERp8ST8Z5Lj2eubd1d+ZkauAKb4WjHDjjaCzuhLODjKNx5WijI+3Hi5PphlsqdsJpmmZZ4H0oLQTs7ml0fzzEgrBRTY4jw9GY0hNQ167EjSqk0AhvTre05s77MReOtU4bon/PAQjZ/75Y4WhMZkbVd7ftXtPy7RoW17GUY/ovPBca0+uYI5/xxPQJ4qk4jeFGBpo8aPkWBGFDkUrpjBqt0+tYaAR43WX9gMrSS+YZnzw/vcTQ9BLBgMYVm9vc3DwCAY3//ir1Gefff3Gac1Mry0XG5tU6dTbWeFPOJuTl1svVvvWtx89bHs0VYcpdXmOMTz89nPf9Xwnjsp7rAhEafcqx6WMkUgmaIk0MxKKwPAOhWuje561wlANnMhrdyYTLtE7DUmKJU7OnAIdELyOfsX0H1LVW/HBWxYBfrC72cBML6+iouGszhqMxqWlKLK7SD6eFIgJyOtR8kNFou6NxyLl8RoCsiEaSur4yCsMrLJb6WL2IMTq3zLHReTTN5Tb7bAqsY7ZDPdsFLgiC4ASTizHiSR1NW/8nyDfu6aalLszIbNT83LAaY2x6f38zDTXuF+fdsKuT63Z0EEum+Pt7nlvxvbG0o3G9r1M1cuOebpprQwzPLvPgydz7VjbJlM7kgghTbnL9zk6aa0OMzUXN97mdGKPTftA5hPKRT94+JVsI0C6k3Yy9l0Aw7K1wlANHRhtdKoMJmmUwKY5OHSWlp+io7aCrvsv+J7NpbNrAqsDraZ5nkXWci81xbv4cUB2ORkOsSELVjk1D/sbpsbkoz6WFo+dljzm59H7MhWMZjTYVM+VD07SsCxm6943TYHkdrWY0GvmMF/U201rvQT4jFFzHaoplEASh+jHyGTsaaggH1/cpViQUMF1NX38s94irIUBctcWbC1GapvH7r1BZjd94fGiFq3FchAzfUhsOmoUj33y8+Pj0xEKUlK4u8HY0yHq6QSQU4Kb9xvi0ve3Ty/Ekc8vq86cIx9XN+v4tWMWsOCldVViwphHWY0zxpQozGkNZZTCHJ9InpR0OnZTaXDxhCjCFGp3nlXAE8LxtHuwvRUY1DSGgr6HPmZZvmzEcjQlNc8wJ5zQTSxOMLo6iobGnbc+K7xnHlr29zbRlF3ustzKYZAIuHFS3c4zc2oURzRBPppwvmrKCzRmNnv8umr0Ac+dBC0DfpWu+XU1uaUEQqh+zcbp5Y5wcv+EKFUnxg6cvsBRb+/vi4XTj9DXb3B2bzuaKzW1cv7ODRErn4/edMP9dhEZ/c2u62fz7Tw2zHC/8WcQYm+5orDE/dwnOY4jB33/6gq3j08Z6RkIBmmvdd0IL9iFCo09ZcYKU5dgYn49ydEQJR9d4IRzlIPukVNdtOtC41jqdFkmzHEf72h1ohNV12x1U5khpATEgIxw1rRSO3KLIOpr7eRW4GQGMZL0kOCpQOYkheG1p3rKm5fvBfG5pL4XGEhqQLTN+BOKLEGmCzl32Pe4qjAsZwwvDTEenCWkhdrbtLPJTDlKq0FjE+fjgcZ/kM3ZdBJGGFd9K6Smz5btaji+CIFQ3RhHMes9nNLhicxub2+tZiCX54aHhFd+bXoxxZETlyV/lYuN0Lm5/sfo9/+VHzppisJnp1+iRG18oyNVb2+lvqWUumuDHh0cL3jezliIau8n1OzppqQszPh/jIQsj7lYZz2qclvzU6kaERh+i67pZBLO7eTsMP6m+0X/FCuGo3QvhKAfG6DTY6DpyqXwiPTlNIqWb7aS723bb/0SzQ7Awqk70ey+25SHN0ekCr5GnY9NQtNTH3M/bHXjNHaBeV7/8FiNt0NTj8daUR6H9/Bf5HGoulTPlwhFHoyH691+W+b85QCAtNJ6YUa/51pat1AQ9/CBscR1NcbdALMPI7DInxhcIaHCNy22iJubFm7XlWufnz7MQXyAcCLO1Zau72yUIwoZkeEaJWOu5cTobTdO49XLlPFs9Pv3IKeVm3N7V4Llr8Nrt7Vy1pY1YIsUn71euRlPMkNFMXxIIaLwuvW99o8j4tDROe0MkFOAV+9W50Peesm982hCOO2U9qx4RGn3I8MIwC/EFQlqIbdElSCxDbQu0b/deOMqBIQSAcpHYgllaYNPj5SGYztBJJJIcmz4GwK42BxxOxth09z4I19nykIYYUOg19zzP0xCh82zjsan0a97qnKvMThpSSwBM1w16vCXlY4i7q/fzkdllTowtoOUSjlx6P+bCkQxYm2MM8mE4Gk/OHgd8sJ9bLPUxjukFjy3p30X7+1toqQvbs32lYq7jWpe4cTzf1rKNcMCj7RMEYUOxURqns3l9Wgz66XNj5v8fMvmM13jsZgQliN7+EjVN8PmHzjC5EGN8XpXBeC2CCvkx9q17j4wytRDLez9pnPaOmy9RDeE/eHqYRNKec4SxeXGorhdEaPQhhhCwtWUr4QuGm/FyCAS8F45yEMxyBNk23uhyRuOiPs5iYpFwIMzm5s32P5EDDbfFmmGzhSNP8hmhoIMqpac4PpMWYJwQdx2gIamCxKfr+j3ekvIxHI2rX3PDLb2/v3mtcLTeMhqNkVuHx9+NaIbTcz7Zzy2WwVgRdz2/6KXrBdcx334uCILgFIajcaNkNAJs62zg8s2tpHS46+B5899/mRYar/aB0Ajwot1dXDzQwlI8yb/+7KS4pqqA3T1N7OtrJp7U+W4Bx5wIjd5x3Y4OWuvV+PQvT9rTPp1ZT39MbgrlI0KjDzFPkFp3ZRwb/Vcw6gfhKAeG4AU2igGuZTQqoXFBV83HjrlfstbRLopl1xnC0b6+ZlrqPXL0FFjHobkhlhJLRAIRNjVtcnnDyqMhtQDAdG2fx1tSHslUkhMzamxotbsubz4j+CKj0TZHY3wZRp5Rt11yNJ6ZU6/5zlYP8xmh5IzGQqPTD5408hk9OomcPAHLMxCsgZ79a75tXLDz/DUXBGHDYGQ09rRsHEcjwBtWjbguxZI8dW4G8DBaYxWapnHbi9Xvg8/8/JSZ1SiuKX9z6+Xqwn6h9mlxwHlHOBjglen26e/YND49Luu5bhCh0YcYI18723bC+cfVPw5caboZPRWOcpDtaLRNDHDZ0TifFhodOSlNpeD8QXXbpiIYKO70KigcuUWBdTSEgB2tO1bkfPqW+THqUuqD6VRNt8cbUx7n5s8RTUapDdYy0Diw4nsFHWoeCo3FnLslM/yU+n80dEGLswK3upCRZGjhNIC3RTBgXWgsIu6en17i9MQiwYDmnVvFcIn3XQLBtb8PzSgMr8fVBUHYMJit000bS2h8zSX9hIMaz5yf5ejIHI+fnSKR0ulprmGwzZ64IDu4aV8Pu3samYsmiCbUmKc4Gv3NLZcOoGnwyOkpzk4u5ryP4YDr3kBOYj/x6ouV+eIHTw8Tt2F8Whyq6wcRGn2I6Whs3ASjh9Q/DlzBgyeUJdlPY9MAAS2AhhLsCjlgSnvQ9K6ZcjijMS00LqGERkfG7Caeg9gchOqga69tD1tsvNHcX7zM8yyQCWfs51XjODr/mNk6HaUKhNEcGK/5jtYdKy4QDM8sc2pikYCWZ8xJM96PNo4vW8T21ulsd7HDbXbBgEYgMkFCj1MXqlsj7rqOsY5FRNti4q5xEePAQAtNtR7nM+ZwicdTcU7OnARkdFoQBHeIJVJMpHPkejeYo7GtIcKNe9QF2K8/NsTDJ1URzNVb233VGhsIZFyNALXhAA0R5wrhhMrpbanluvR5zLcO5nY1jkvrtKc8f0cHHQ0RJhdiPHBsvOLHE6Fx/SBCo89IpBLmaOPOWFyVLzT1QXM/j55O5534ZAwhG9vHG10enV5C/fJyxP2S3XAbtE+gKjTeOD4f5eS4GvO9aouH+0uBTLgVzt1qYOhRQroO2Ciou0y+cdJH0seWff3NuYUji9l+TmB7RqOR62ejuzgfoYBGoGYYUK95QPP4V67FdSwm7j5yWp1EXrO1zb5tK5UC63h65jSJVIL6UD19DdUZcyAIQnVhFKFEggHafDR15BbG+PS3Dg7xy1PqYpRfxqazufniPrZ21AOqCMZPQqiQm1svy4zm6+nP4dlI67S3hIMBbr5EfdbKzmktFylqWj+I0OgzzsydIZ5Ku18mz6h/7L+CmcU4R0fmAbhyi4cnd3mwfbzR1dHpJFEtLQY4IXo5VDxRSNx9NC0E7O5p9HbMXstfBrMii7QaGMo4GlMeCG52kK8g45FTan/JK0p7OTodsPnY4kAxUz6CAY1AzQjgE+duiRmN+V7zR9P7y5VeXcRIxsEoSsuxjqag3rZTTiIFQXAFI5+xu3ljilcvuaib5toQF2aWeeCYEhr9UgSTTSgY4DfTrsZtnQ0eb41ghVce6KUmFOD42AJPD82u+N5iLMF8VH2mEaHRO153mcrSvPuZYZZi5X9e13VdHI3rCBEafUb2OGnAdGxczmNn1Ynd1o56Xyr8hlOn+hyNAQKRcdCS1Ifq6W9woE3YGPGzWdgoJAY8dtoQAjwWpfOsYywZ4/Ssyq2ritFGXYehRwmajsbqFBrz5dY9dkbtL1fk2188FBqNY4sto9NL0yrKABxvnAZDaFQXMXyxn5cqNOY4ns8sxTk6Ogd4eHwZfRYSS1DTDO071ny76i5iCIJQ9Zj5jM0ba2zaoCYU5OZLMp+hm2tD7Olp8nCL8vOmKwf5+Duu5MOvv9jrTREs0FQb5mX7egD42mPnVnxvfE6532rDARprqjPWaD1wxeY2BlrrWIgl+c/DI2U/zkIsyVJcffb0o94hlEbJQuP73vc+7r33Xgc2RYCscdLWnVnOmyuzhCP/XR2ErFE7u0ZKtfzZfnayYrTRCfdLIqbKJ8A5obGAo9Hz/SWPsHFq9hQJPUFTuIme+h4PNqxEpk/D0iSBdBapbYK6i0STUc7MKpd0tnN3MZbgmfPqCvFVeYXG/M5Up7F1dPrCQfW1dQs0OJ9dGgpqBH3laLS2jqZbOsdrfvDsNLoOWzrqvbvabLrEL8/k+WZhCup+EHcFz5HPrYIbGEJj7wYVGgHecEUmh/iqre0EAv50dmqaxiv297Kpvd7rTREs8sb0vnXXE+eJJTL5/WPz6fbwpo3pJPYLmqZxS9rVWMn4tJG3WR8J0iDCcdVTstA4NjbGK1/5SjZt2sQf/MEf8MQTTzixXRuWY1PpE6SGAZhSYfb0X54lHPlvbBqyRqdtczSmT4gddo4FAxqB2rTjyAn3y8jTkIxBXRu0bbP1ofOJu9FEkieHZgAf7C/mOq4s9TGdu9Uy2pgW/ePBFgCSVZjReHLmJEk9SUtNC111Xea/P3F2hmRKp6+llv7WPO2QedbRDYqVHpWEQ+7ifGiBBFpEjZD5QvQqUM6UTaH8V/N30WYPjy1F1lEcjUI28rlVcIPs0emNylVb2tjUrj5H+HFsWqhebtjVRWdjDZMLMe47Omb+u9k4vcGa3v2IMT5975ExZhbjZT3G2LyMTa8nShYav/Wtb3HhwgX++I//mIcffpgrrriC/fv38+EPf5hTp045sIkbCzNbKpE+wWvfQSLSwsGz04APhKM8FHLAlIWLZTBGhpojQkB2PqPNgpoh7qZWiT9PD80SS6Rob4iYgdeekWcdVzh3q4G0sBENqw/OSQ8Et0rJjmXIFneLjk2Dp6PTtjoah9wrggFIBi+gaToNoRY6aj1sfzewWAZjiLup1Nr93CglK7i/OM3Q4+prjnVcjC9ybl6NVlVN0ZTgKPK5VXADcTQqV9P/ueUAr9jfw1uu3uT15gjriFAwwK1pIetrj2bGp8ekcdo37O1tZk9PE7Fkih88c6Gsx5D1XF+UldHY1tbGBz7wAe69915Onz7Nu971Lj772c+yc6d8qK+E5cSyOdq4a0a5YBi4gsPDcyzGkjTVhtjV3ejhFubH9mZYF4XGYFYrrO2YJ8T2O6jyNcMaY/ZXbG7z3i2YZ1QzXymJbzmv1nE5osSianQ05muctuRQ81JotLPRPr2ObuQzAiSC6oNWT+1W79+LUHEZTCKZ4uCZacDDi16xRRg9pG7nWMfj08cBaK9tp71WHDWCQj63Ck6z0TMaDV68t5uPv+Mq2hsiXm+KsM5445WDAPzn4RGmFlQ2ozRO+wtjfPpbZY5PG0Kj5DOuDyoqg4nH4zzyyCM89NBDnDp1ip6eKsha8zEnZk6go9NW00bH8DPqHweuNIWAKza3+TbvxNbxRlh5Qpwu4HCCpL5MIKIcOo6IXuaIn/0OqnxigLG/XLXVB+7X9eBoTCXh/EEAopFuAJI5nF5+x4hl2N222/y3VEo3HY0FhSMvW6ftarSfG4bZIdAC0HepDVtWnHhAfdDqqd3qyvMVxarQmOcixpGRORZiSZpqQuz2KuR/+EkVqdHYC81ry7skn1EohHxuFZxiWIRGQXCUi/qa2dfXTDyp8+0n1ecraSj2F7dcqj6X/eLEhHnxpRTGZXR6XVGW0PiTn/yE97///fT09PCud72L5uZmvvOd73Du3LniPyzkZUVu3fCT6h+rIJ8RnHA0BjO3HRxTHV5SzcdastF+90tsEcaPqNv9l9v72OR2eum6zqNWhCO3yJEJtxBfYGh+CKiSDLWJYxBfgHA98Yh6TVNV6GjMJe6eGJ9nejFObTjAvv7m/D+cbn52upwpF7YVTV1I57J17oEad5zh0YDaz7tqtrjyfEUx17Hwa5lP3DXc0pdtbiXo1UUvYx37L88ZR2E4d6vi2CK4hnxuFZxmNJ3R2LOBMxoFwWkMV6MxPi1Co7/Y1F7PlVva0HX49hOluxplPdcXJdf5DAwMMDk5yStf+Uo+8YlP8NrXvpaaGtkZ7MAUAhoGYe48oEHPfh49/TDgE+EoD/kcMGWTLTSmkiv/biPnF1XhTiDRZ/+Djz6rRNKGbmjqtf3hc4kBZyeXGJuLEg5qXDzQYvtzlkyOTDhjP++q66K1ttWDjSoRozW85wDBQBiwUVB3ibnYHBcW1BjvjtYd5r8bFzEuHWwlHCxw3clitp8TFGpXLwnj4k3fJRVukXWWNfUhq9MvQqOxjkUu3uQbV3/EDxe9iqxjdhapIIB8bhWcZz6aYD6qPv+Ko1EQnON1l/Vz5/ee5YlzMxwbnTPLQ7pFmPINr7usn0dPT3HXE+d53wu3l/SzIjSuL0oWGv/0T/+UN73pTbS2tjqwORsbM7dOS+eatG/nwnKIoeklAhpctqnVu40rgmMZjZB23ziT9XJuId3sHXNAaBxOO296L7b/sckt7j56Ro2BHxhooTbsjDhbEtrajEZjhLdqhABD2Oi9mGBS/X9SVSY0Grl1PfU9tNRkBGjLbmk/ZDRW+ppfyKyjG8xEZ4hr6vXtCG925TmLUmJG42oXqRnLsMXD7MMi6yij08Jq5HOr4DTGiGBTTYiGmpJPrQRBsEhnYw037uninmdH+eqjQyJM+ZBXX9zH//72IZ48N8OJsXm2d1mfIjJGpyWjcX1Q8uj0+9//fvmw5hDmyNfSovqH3ot57PQ0oHIp/PzhxbGMRnBU3Di3cELdiNnvODSdcE4JjTnEXUvFHm6SQ9ioOiEgax1Ddreru4RZBLOqhdeyQ80PGY0VOxqdfT+uxtjPU/FWglqdK89ZlBIzGrP385HZZc5NqYtel27yyC2diMHYYXU7xzpOLU8xvjQOrHTuChsb+dwqOM3ITDqfsUXcjILgNG+8Qo1Pf+Pxc5Lp50M6G2t4wc5OAO4qcXxahOP1RUVlMIJ9zERnGF0cBWDndPpN2XtxVeQzQn4HTNm4JDSenVdCo16FQmMucffRtDDtm/0lx8htVY026nqWg+oSgun/T4rqKoMxXvPdrZkimMmFGCfGFgBVNFUQLx2NdhxblmdhKu1e7nFJaEw7d1PLvaRSzhValUSeFvjV5BJ3jXzGPb3NNNWGndm+YowfhWQMapqhde04uiHuDjQO0BBucHvrBEHYoIzMGUUwcnIsCE7zkou6aakLMzIbJZ5Un686GuS95ydel26fvuvgeXSLpa66rjM+r9rERWhcH4jQ6BOME6S+hj4aR55V/9h7CY+eVqOwvhGO8mBbjpqBlrVrOlQGM7U8xVR0AoDUcre9D55Kwki6ObzXmUy4QPo1MgSYueU4R4ZnAR/tL4awkeWMMtx12e3HvmVuGBbH1f7YfREhrTpHp8381yxH4+Pp0qAdXQ20NRSJJgik348OFjPlI19eYEkY78XmAWjosGGrimPs58loDwnfCY2FX0vj2JLtaHzEHJv2Mp8x6+JNriKYKSmCEQTBfYZnjCIYcTQKgtPUhIJmuzFAW32YSEgkDT9x0/5eakIBTowv8OS5GUs/M7uUIJZU5xkdxc5LhKpA3pU+wcyta9muXBvAUsc+njnvM+EoD7blqBloWs58PzsxRxtjbSSSNl85mTwB8UUI1UGHMyN8q8Xdg2enSemwqb2Obr982F3lhJtYmmByeRINjW0t2zzcMIsYwkbHLojUmy7SahIadV3P6SItqdjDB47Gio4tLo9NQ0b0SkV7SfpGaLRW6mPs5yvyX/3gri+yjvkiAgRBEJzEyGgUoVEQ3MFonwZxv/mRxpoQN+1X04Jff+ycpZ8Zm1fH0ebakD96BoSKEaHRJ5j5jOEW5Rqq7+TJ6VoSKZ2e5hoGWn2S8ZUH20enwXFxw1EhwCgQ6dnvWGO2OTqdFmB8l88Ia0Y1DXF3sGmQ+nC9V1tlneGVxROGoF5NQuPE8gTT0WkCWoDtLZn2t5KEIx+UwVTUaD/sbhGMruuZCxm+cjSWVgZjHFuW40meOa+uSPuicTpfEUz6gp04GgVBcBNDaOwVoVEQXOHSwRZ2dKmIlO4med/5kTdeMQConMZYovhE1KjkM647RGj0CabjKJ01Qe/FPHJmGlAndlqOMTE/YQowKRtHKx0WNwwhQI022jwS6oKDarUY4AvH0Wqy1zBLfKkaIWDVOoarMKPROLZsbtpMbUh9GIsnUzxxdhqAK600CPvA0ZiqZGzbZUfj6OIos7FZNAKkYl0+dDRaK4NJ6Sl0XefJczPEkzpdTTUMtnl00UvXC65jtrgrjkZBENwk42iUE2RBcANN0/iVazYDmIKj4C9euKuL7qYaphbj/PjwaNH7Sz7j+kOERh+QfYK0a16JRapx2hCOLAgBHmOWB9jp9LKYJ1Yu2Y7GlI7lsFpLuCE0ZmXXJVM6j5vCtI/2l+xSHz2VEdSrRQhYtY5G67ReRY7GXGPTz5yfJZpI0VofZnunhQ9omrPvxUKsdu6WTDIOo0burbuN0w2BXtDD/hEajexbi45GUK/7o1n5jJ5d9Jo5B8vT6pjStXfNt4cXhpmPzxPSQmxrroJYBkEQ1g0js5LRKAhu857rt/GJd1zJ7768CjLfNyDBgMbrL1euxq9ZGJ82Gqc7G0VoXC+I0OgDxpbGmI3NEtSCbBs/BYDeewmPnvGhQy0Ptow3rsZBoXHlaKPKkLBVDDAEqr5L7XvMVWSLu0dH5piPJmiIBNnT2+TYc5ZM9th4KpmJCGirAkdjdE5lbYJZ6GM6vageodG8iJH1mhvC0RWb2wgELAhHDov+hTBjGco9tow/B8louql4q30bVgDjNW8JbgLw3+h0EXdoKOsCQbbQ6It8xq6LILT2Q6hxbNnaspVw0KNWbEEQNhy6rjOabp32TT62IGwAAgGNm/b30lovxSF+xcjS/MnhUSbmowXvOyaj0+sOERp9QPZoY82wakc9W7OT6cU4NaEA+/qavdw8S9hS2LAaB8c1DfdLUAuRinYCNooBcyMwP5JuKt5nz2PmIFvcNYSAyze3EbQiHLlFlmCRSsaqK0Nt5BCgQ1MfNHYBGUdjRWO8LpPL0fhYqcKRDzIayz62GAJVz4FMe7bDHJ1ShV4tITXWk7Q7mqFcSsxoBEgkEzyWvuh1hR+ExnxFMDn2c0EQBKeZjyaIp2OPpClVEAQhw+6eJi4eaCGR0rnrifMF7ytC4/pDhEYfYDqOGvogvgChOh6aUSd0l25qJRLy/zKZ4412Op4cFDcM98uW5i2Ase02CY0jRlPxTog4V3iSLe76wnGUiyzB4sL8EIuJRUKBEJubN3u4URbJUTxhZDTqVeJoTOkpjs8cBzKORl3XeeT0JFAdQqPp3C332OJyEQxkjuntaaHRd45GixmNAMfHZ5lciBEJBTjQ3+Lk1hWmWBFMDueuIAiC00wvxgGoCQWkKVUQBGEV/yXtaiw2Pj0+L6PT6w3/K1gbANOJoaXfWD37eOTMLOBD4SgP1dY6bZYGZLlfbBMDXCqeyM5o9K3QmOVoPJbez7e3bCccqILRxhzrGApWl9A4ND/EUmKJSCDCpiY1xjs0vcTIbJRgQOPSwVZrD2S+F70bna7Y0eiS0JhMJTkxrUbuW8NpR2OyyoTGrAsEj5+ZAFTDo6cXvYqsY65juiAIgtPMLCmhsbW+Cj7XCIIguMwtl/YTDmo8PTTLkeG5vPcTR+P6Q4RGH2Dm1i2rjBd6L86Mqm32mXCUh2zRyzbM4gL7xQ1D3M0e4bXN0XjBHQeV4fRaiMU4M7mIpsFlm1sdfc6SyXJGPTetnHVVIwTkEDbM1ukqGZ029vPtrdtN1/Fj6dKgfX3N1EUsui8C1kpEnKCi/Fddd93ReG7+HMvJZWqDtbSGewA/ORqtHVMDWoBA+vh78JwPfhctTcP0aXW798CabydSCVPcrYpYBkEQ1g2Go7G1TsamBUEQVtPWEOEle7uBwq7GsbSjsUscjesGERo9JqWnzBOkndPDACx37ufY2DwAl27ycFStBBzNaHSg4dccs2vfiVGiapvQ6JKDyhACxuaXANjR1Uhzrc+uqGuaOT793GxaCKiG0cZkAkYPqdvpIhjIiLvV4mjM5fJ68uw0AJdtarX+QA6+F4tR0bFldgiWpvI2FTuBkUO6rWWbWUqSsrPRvhJKcKYax5dDF5TQWNL+YjcjT6uvLZuhbq3geWbuDLFUjLpQHQNNAy5vnCAIG5nppRgALeJoFARByMkbr1Dj0994fIhEcq1ZI5nSmVxQx1JxNK4fRGj0mAsLF1hOLhMOhNk0cgSA44Ft6Dr0tdTS3VQdDXbVVAaT0lOcmjkFKAEmlC5PsUVojC3AhBIasgUqJzAcahMLSmi8ZMCnonTakXZy9gygRqd9z8QxSCxDuAHatpn/HA6q/4tOdTgaT86cBGBH6w7z354cmgHg4sES9hc/lMGU42w2RP/OPRB251h6cjbzmhvHFv84Gq2voyGqnxhTMR4l7S92U+TijbGfb2vZZgqkgiAIbmCOTteJ0CgIgpCLG/d0094QYWwuyk+Pja/5/tRijGRKR9OgXUq11g3yidxjjBOkLY0DBOeHAY2HF/sAuMTLE7sSqWi8MR8OiRvDC8MsJ5cJBUIMNA6YLc0JO5phjabixh5o7K788QpgiLtTi2rk3rf7SyBECjg1fxZQYoDvMYWNlU3F4SrLaDQFmGb1midTOs+khUbL+Yyw8r3osjuvovxXl/MZYaXoZRxbqi2jEbKO6XqSjoYIA611Tm5ZYSwKjVubt7q0QYIgCApzdFocjYIgCDmJhALccmk/AF97dO34tJHP2F4fIRwUeWq9ICvpMeZJaTgtEnXs4NFh9aHlklKEAI8xxABbs+uMfD+bhUbjNd/ctJlQIERQs9HR6GIenCEETC+pg/PFft1fAiFGg0GWklFCWojBpkGvt6g4edYxbJbb+N/RqOv6CtEL4MTYPAuxJHXhIDu6Gqw/WFapDy7nU4YqycX0oHE6l9DoH0ejcUwtLpSbhTCazsWDLWhGxoQXFFnH1fu5IAiCW2TKYMSFIwiCkA+jffqHh0bM46aB0TgtY9PrCxEaPcZ0Yhjnfb0X89S5acDHDrUcGGKAvY5G46TYXmFj9UmprWKAiw4qQwiIJhIEAxr7+5sdf86yCAQ5EVZX+jc1b6raxmnIdjT6X2gcXRxlMbFIUAuajdNPnlNuxgMDzYRKuWKYPY7qcvN09kWMksVGlx2NK8Td5m1ZsQw+2V8M8dBCxIVxTNdIeXvRKxGD0cPqdp51NKIwRGgUBMFtphfTGY0yOi0IgpCX/f3N7OlpIpZIcdcT51d8z3A0dkoRzLpChEaPMU9Kl1Td+3LHfk5NLAJwsV8z93JQTRmNq4VGQ3BJVZnQaAoBWordPU3Uhi02CLtNIMTJiNpWY4TX1+h6fqExUD2j00ZW4KamTWYpyZPpixgXD7SW9mDZjkaXcxqDWc3lJR1flmdg6pS67ZLQOL40znx8noAWYHPz5szotE8MjSWNTpuOxqS3+a/jRyAVh5oWaN285tu5nLuCIAhuIaPTgiAIxdE0jTdfrYwPX/rlmRXfM4RGcTSuL0Ro9BjjBGn75BCgimAANrfXV9UYRkWFDflwSmicdcjRmErCyDPqtsNFMJAtBKS41M/uVy3IybSjsSqEgLlhWBxXLr7ufSu+ZZTBoPnEoVYA0y3dstX8N6MIpuQ2ew+FRqOUBEo8vhjvxeZBqG+3eatyY7zmg42DRIIR/zkaSzimBrKOL56667NF/xzj2xPLE8zF59DQ2NK8xeWNEzYSd955J1dffTVNTU10d3dz6623cuTIEa83S/CYabMMpno+swuCIHjBGy4fIBIM8Mz5WZ5KT1mBCI3rFREaPWQmOsPE8gQAW8dPAPDL5QGgusamISMGVJWjMe2us611euI4JJYgXA/tzjcrZ5xeKW8bYYsRCHGqmoRGs6l4N4RXFmBEgtWT0bja5RVPpjh0Pt0gXKpDrRodjR4XwQAE00VCCb9YGks4piZT6rjY0RCiu9mdxu6cWCyCGWgcoCYoH1AF57jvvvu47bbbePDBB/nRj35EPB7npptuYmFhwetNEzxkRhyNgiAIlmhriPDKA70AfPHhjKvRyGjsbJQLNusJERo95NTsKQC6a9poSCWhoZuHxtQbrNqERkdap41cOBtdknOxOcaXxoGM08s2R6NRWNBzIJMv6SBBMqONJTUIu00gyMlwenS6KoRGo3hirSs1UkWt06sF9aMjc0QTKZpqQ2ztKKEIBlbuzx5lNEKJxxdjHfucdxcbrHZL23YRwy4C1o+piaTa9h3d9U5uUXEMoTHPOsrYtOAWP/jBD3jXu97F/v37ufTSS/n0pz/NmTNnePTRR73eNMFDppcko1EQBMEqb71GjU/fdfA8C1H1uX5MymDWJSI0eoh5ghRqUv/Qe7GZoVZNjdPgcEajjY9plAZ01XXRFFGve9Cu8UaXHVRTi+rgHNB0dvc0ufKc5TAfCDIaUmuZPcbrWwqso9k6XUWj04YAYxTBXDzQQiBQYoOwpmWEfzvf4xbIFhqrzdEY8F3rtOFoLP46xtKFgNu76grf0Ul0XRqnBd8yM6OOqe3tuaMZotEos7OzK/4I6w8jo1GERkEQhOI8f3sHWzvqmY8m+O6TF4Cs0elGDydoBNsRodFDzBOkhDoJXWzfx/mZZTQNDlRREQxkikn8Pjq92nEEWY7GSscbXRY2zk6qg3JdjUYk5N+38qmQEoo6I800R3zajJ1NgXWsltHphfgCI4sjwFqhseyLGA5FGRRD07TMhQyrbspkHEafVbc9FBr952i0vobpi8xs9VJonDmrSn0CYejck/MuuY7pguA0qVSKD33oQ1x//fUcOHAg533uvPNOWlpazD+bNm1yeSsFp1mOJ4km1OcBGZ0WBEEojqZpvPUaVe73hXQpzPi8coZ3Nsno9HrCv+rEBsA8KV2cVn8PqVy/HV2NNNaE8v2YLwmk3U62jk47ITTmcL+YYoBegRiwwnnjzqjmmYllAOoiJbrTXOZkehm31fV4uyFWiM7B5HF1O5ejMZhxNOqV7C8OY8QytNe201KjLlo8NTQNVBDL4JHQCJnji+ULGWNHIBmDmmZodacgZDG+yIUFdWXWGFcPVqnQOLMUJ5a+ALal3cMxlgvpY2r3Xgjl/vBpuNRFaBTc5LbbbuPpp5/mS1/6Ut773HHHHczMzJh/zp496+IWCm5guBmDAa3qPrcLgiB4xRuvGCQU0Dh4dpqnh2aYXFBCY1ejjE6vJ0Ro9BBT9Jo8B8Aj0XQRTJW5GcGp0en0yKTDQqNR2FCRGDA/Agtj6abiiyraRqucGl8CoNbnF9FPpo8y2+q6vN0QKxhNxU190NC55ts1oYyj0TfiUQ5W7+fL8SSHL8wBZRTBGJQwdms3hmPa8oUMw5XacyBnU7ETnJ49DUBbTRutta2Ajx2N6FAgKuLpoRnQ1fG3rsbDjwnmOuZ2pS4lljg/fx4QoVFwj9tvv53vfOc7/OQnP2FwcDDv/Wpqamhubl7xR1hfGPmMrXVhNJd+1wiCIFQ7XU01vHyfMqB85CfHAHXBpq1eHI3riaoSGv/v//2/aJrGhz70Ia83pWLiqTjn5pTAuG1pHoI1/HRCCQC+bhDOgzk6bacIYQqN9j3m6oIMyIgBFeWojR5SX9u3Q8T58oRUSjeFxojPL6KfDKjXdVttFQiNxjr27M/57XAwrepqKf/k7uVgtdB4eHiOREqnvSHCYFuZo7BmOZP7jsaSL2QUWUcnyH0Rwzi2+GTUXsv6lV9gHZ88NwO6Ay71Uimyjmdmz6Cj01LTQltNm4sbJmxEdF3n9ttv5xvf+AY//vGP2bZNxO2NjpnPKGPTgiAIJWGMT3//6WFANU6XnCEv+JqqERoffvhhPv7xj3PJJe41iDrJublzJPQEdYEIPckkeucuDg7NA9VXBAMOl8HYJDTGU3HOzKksiGwxwDioJSvJaBw9rL527S3/MUrgxPg8y+myhlDQv4IXwKmAWr9tNR0eb4kFiqxjTVpo1LQUiaRPxKMcmOOkzUY+4zSg3Ixluy48dDQarfbWR6fT69jtzvsRMuPquYRG/zkaKVjq8+S5afT0x4OU7uF+XmQdsy8ciZtIcJrbbruNz33uc3zhC1+gqamJ4eFhhoeHWVpa8nrTBI+YWVIfxFqlCEYQBKEkXrizk4HWjPmhU8am1x1VITTOz8/ztre9jU9+8pO0ta0P10J247QGLLftZnw+SjCgsa+v+sZrTCHAVkejvZlwQ3NDJFIJ6kJ19DRk8gJtcTSOpYsnXBqbVo4j9Zp7KgQUIZFKcBpDaMzdzOkrzHXcl/Pb4WCmATmWdF9ws8rqggyjCObSStzSHmY0llwGYwrG7rwfoZij0YdCo1VHo+6RozERhYl0XmqedZTGacFNPvrRjzIzM8ONN95IX1+f+efLX/6y15smeMRM2tHYKuN+giAIJREIaLz16kxJWleTCI3rjaoQGm+77TZuvvlmXvaylxW9bzQaZXZ2dsUfP2KcIG1Na0RnQ1sB2N3TRF0kmOen/EtIc6J12t6MRvM1b95qlktARgxIVVLuYQgbLgqNuh9GG4twfv48cQ1qUyl6Qw1eb05xRgs7qGqCGaEmnvTn655MJTk9o/ICt7ZsBbIcjZW4pT0UGks6vkTnYEY5l916P8LK44tByI78VzuxIDROzEcZml7C+Hhg68WjUpg4plyXNS3Q3J/zLiI0Cm6i63rOP+9617u83jTBI7IzGgVBEITSeNNVmzCmpaUIZv3he6HxS1/6Eo899hh33nmnpfvfeeedtLS0mH82bdpU/Ic8INM4rcaln473AdVZBAMZR6Ot7hebRzUNl5chvhhU7GjU9cyIn0sOKiUcldjE6wHGfr4lniDg45ZmABYmYGFU3e7ck/Mu4SyhMepTofH8wnliqRiRQIT+hn4WogmOjRqxDJU4Gu3PTLVKSY7psSPqa2MP1Lvjok3pqSoZnc66iJXntXxySLlf68PqxNmz48uo4S7em7fQZ7VzVxAEwU0ko1EQBKF8eltqecnebgD6Wmo93hrBbnwtNJ49e5bf+Z3f4fOf/zy1tdZ2vjvuuIOZmRnzz9mzZx3eyvIwT5BmRgB4YFYVZVRjEQyUMdpohfRjFsoSK4V87peMGFDmCPLsEERnlTDasbOibbRCPJnimfOz5mijZ44jC5iveTxu2zo6hjE23boZahpz3iUU8L+j0RR3W7YQDAR55vwsKR16mmvoaa7gl3jA3vdjKRjHF0sXMgyByqW8VIALCxeIJqOEA2H6GzPuu1DQZ0KjpmWV+uQRGs8qobG5Vl1Z9uz4UmQdU3oqk0UqQqMgCB4wbWY0yui0IAhCOfyf1x3g/S/cxtufv8XrTRFsxtd9tY8++iijo6NcccUV5r8lk0nuv/9+/umf/oloNEowuHLMuKamhpoaf1tvdV3PCDDRJfRQHf95oQ5IcmkVFsFAGWUNVrB5VDOf0Gg6GsstgzHGbTt2Qsj5D5vPjcwTTaRoSo/qeJahZgFTUI8nPBm5LYnRwvmMkBG8AKLJuNNbVBarm9WNsemKS6a8HJ0updXeLBDJv452Y4q7zVtWiNG+y2gEtY7JWN51fGpoGoCWulrGFzw8vhRZx+GFYZaTy4QCIQYaB1zcMEEQBIWR0dhS5+vTKUEQBN/S31rH/7zZvc/sgnv4+jfjS1/6Up566qkV//bud7+bvXv38od/+IdrRMZqYWJ5grnYHBoaWxJxYl0XMX0mSSQYYE9vk9ebVxZmhppPy2BWiLvN+RyN5QqNh9RXlxxUhhCwq7uF56iO0elt8Xj1CI0F1jE72zPmd6ExLag/lR6FrTiWwQ9lMFb2deP96GLjdF63tOYzRyMUFRqN4qC2+hpY8NLRWHgdTXG3aaW4KwiC4BZmRqOUwQiCIAjCCnz96bypqYkDBw6s+LeGhgY6OjrW/Hs1YZwgDYQaqNHhbI06Ob2or4lIyNfT7HkxBBh7MxrtK4OZXJ5kNjarxN3mldbsil1HY+4WwTyRFgL29Lbw3GQVjU77XWi0sI6apqmRdS1FzOej06sbpyuOZbC5nKmkpw6UUHzkYeN0dhEMZB9bfNQMX0AwHp5ZZnQuSjCg0Vanxuw9uZARX4JJ9ZpK47QgCH5FMhoFQRAEITfVqWpVOeYJUkqduD/HIFC9+YxQ4mijVWwsnzCKGvob+6kNrcypM5phy26ddjkT7qm0cLS/rxXwr6NxanmK6eg0oMpgvCgRsYyuZ41OFxGo0tmYfs1ozC4lmVmKc3J8AbBhdFrzrgzGcuv00jTMnVe3u3IX+jhB3lgGM6PRtU0pToGMRmPMfld3I5GQes09abUfPwroUNcGjd0575KrfEcQBMFNDKFRWqcFQRAEYSW+djTm4t577/V6Eyomk8+4CMBD8z0AXDLQ6tUmVUxJo41WsbF1upD7JVhJRmMqlWm5dSETLppIcnh4FoB9fW3wjEdCgAWM17xfi1Cn6/4WGhfGYGlSiTCdu4vcOQgkfOlonF6eZnJ5ElDuusdPK1F6sK2O9oYKR7tsboEvBctlU8Z7sXkA6lqd3agsjH19e8v2Ff8eqrRoygmMdcxxrDbcr5cMtjhzTLfKaFY+Y77GaXE0CoLgMTNGGYyMTguCIAjCCsTR6AFmQcbsGAA/nuwA4JJN1eto9HsZTKGT0lAlGY0zZyC+AMEItG8vfv8KOXxhjnhSp70hwmBrA6DaV/2I+ZoH6tU/+FQQBTJ5cG1bIVxX5M7pMd6k/4RTw+XV29BLfbjeFI5sKZnyMqPR6vHF5bxUgJnoDBPLEwBsbdm64ntBc+TbZxmNkHMdnzTyPAdbTZe6J8cXC+soQqMgCF4ST6aYj6rjqDgaBUEQBGElIjR6wKmZUwBsi0ZJhRt4LtpKJBRgZ1ejtxtWAZYdR6VgYyZcoZPSQCUZjWbj9C4IOm8QPnRBuRn39zcTCmbGSfVyx74dxHzNg0oQ9bfQaL2pWEsfNmM+/P+sLjwy9pd9/c2VP3g1lMG4nJcKGXG3u76bhnDDiu/5tgwGcq7jofOZ44vxmnvimC6yjnOxOcaW1IW61bmYgiAIbmC4GQGaRWgUBEEQhBWI0OgyS4klzs+rDLFt8TizjTsAjT09TYSC1bscZkaj30enmws5Gstw7owZuX7uOKieNYSjvowQAP7MaTSduyFDaPTfNpqMlZCz6eOMxtWC+rO2Co0eZjRazYB1OS8VisQyBCssmnKCPOs4OrfM+HyUgAZ7e5s9Hp0uvI7Gxbruum4aI9V7gU4QhOrFyGdsrg2ZETyCIAiCICiqV9mqUs7MnkFHpyUQoS2V4mxYNSBf1Nfk8ZZVhiPuF80eR2M0GWVofggonNFYVmHDqLsOKsNxdFFfsym+gE+FRkOACaX3bR86AE1KWEcNtV/GfTg6nS16LceTnBibB5QwXTEetk6bx5dirfZj1p2pdmHlIkbKl0Ljytfy2QtzAGztbKAuEnSm4MsKsQWYPq1u53k/mhcxZGxaEASPkHxGQRAEQciPCI0uY56U6mE04FBiAFDCUTXjaEZjhY95evY0OjrNkWbaa9vXfL8iR6OZJea80JhK6RweVmLARasdjT5zC64Qd8Pp7FEfiqHAysZpS044Y3Q6XuR+7pMtwBwZniOlQ3tDhO6mmsof3Kb3YzmYx5dC+/niJMyPqNs+aJyGrKKplO6feIM8TnHD/Wr8LrIs7tqNIRY3dEFDZ867GK/56kxMQRAEt5hZigHQWi9j04IgCIKwGhEaXSbTOL0MwINz3UD1C40hzQH3i02ZcNknpVqOBtOyCxtSSRg/qm674Gg8N7XEfDRBJBhge1eDKb6AB2JAEc7MniGlp2gKN9ER9HkZzNwFiM4oB23nrqJ3NzIa/TY6HUvGODd3DlCiV0Y4asq535eMhxmN5vGlkMhpiMUtm6HGvXFaK0VTAL4xNeZZx+xYBrAo7jqB4S6WIhhBEHyMMTrdIvmMgiAIgrAGERpdxjxBmp8E4BdzXUD1C42O5HnZNKpZaLQRIBQss7Bh6hQkliFUq9qKHcYo9tjd20g4GPC1ozFbCNCC3o3cWsIQqDp2QKi4888cnfbZa3527ixJPUlDuIGuuq41wlHFeDk6HbAQzeByXipAPBVfIe6uJju3K1GOY9oJ8o5OrxIavcpoNNcx/8WbYsd0QRAEpxGhURAEQRDyI0KjyxijjVvjMRLhJoZpZ6C1ruo/qFgSAkrFpvKJYu6XgFZmYYMhUHXuzmyrg5gOtV4lBAS0AAFNvYX9ltG4YrTRxlIfRyixQMQQGhM+czSar3mzcu4amXu2XcTQ7Hk/loMl0Wu0uEBlN2fnzpLQE9SF6uip71nz/Wyh0TfN0znWcTme5PjYApDZX4yMRtdbp4usYzwV58zcGUAcjYIgeMe0mdFY3Z/fBUEQBMEJRGh0kZSeMtsyt8XiTNRvB7SqdzOCU45GewSqYkJjJqOxRCHAgvPGTg6tylADTKHRdTGgCCvKGvwuNJrraK1AxHjNY357zbP2c13X12TuVYyH62geXwo9tzly657QuFrcXc1KR6NPhMYcWZvPjcyTTOm01YfpaVauXs8uYhRZx6G5IRKptLjbsFbcFQRBcIOZxXRGY52UwQiCIAjCakRodJHhhWGWk8uECDCQSHAysBmAfVXeOA0O5XnZkAmn6zqnZk8B+YXGYLlCo4UsMTvJJRxZyq7zgBWjjR5m+1nCbJwuzdHo53H1c1NLzEUThIMaO7psyiv0cB0tlU15MDpd/CJG5lesb5qnc6xj9rHFEEw9aZ1enoVZNYqebx2zxV1DDBUEQXAbcTQKgiAIQn7kU7qLGONeg1qYMPBktBeAff3iaMyJDcLG+NI4S4klglqQwcbBnPcJBcocnTbaUV1wNM4uxzk3tQSszNwzBJiUX/LfUOLu2dmzAGxp3pI1qulDoVHXM+to0QlnlsH4TGg0ji9bmreY7ted3U1EQjYd5r0UGosdX+bHYHEC0KDTvcbps3NqP9/avDXn97MMjf5zNGatYy63tCcZjWNH1NfGXqhry3mX7P1cEATBKySjURAEQRDyI0Kji5yZVSdIm2Nq3OKBddI4DVnuF0fKYMp/TOOktK+hj3Aw94fBoFkGU4JYl0y42jh9OJ23N9BaR0vW1XNDDPBT6/R0dJq5uNrewaZB27I2HWHmLMTmIRBWZTAWyIyrx53cspIxRK/NTZvtL4IBT9exqLtu9JD62rYVIvXubBSZY/qm5k05v69pWvnRDE6RYx1z7S+eCI3GOhY4phr7+aam3K+5IAiCG2QcjTI6LQiCIAirEaHRRUwhYFGd1B2KD9AQCbKpzb0TY6cwTkpTeoqUbpO7zgYnnCnuNm/Oe59gOWUwkycgGYNwPbTkf2y7yIw2rhyz92S8sQiGuNtT30NtqNbfo9PG2HTnLsgjRK8mUwbjn9d8LjbH5LJqst/UtCnv/lIRXrZOFxPUXXQXZ2Ps65ub8h8DAuU6pp1i1Trmy/N0JA6jGBbW0coxXRAEwWnMjEYZnRYEQRCENYjQ6CKm+yUeJxZuYYwW9vY1myei1Uwwq3XZNgdMjtKCUrHifikro9HIg+vaAwHn30aHzucu9vDEdVSENUKADevoGGOlNU4DBAzRy0fCqbGft9e20xhpNEdh7XU0ereORUWvEpvD7WApscTo4ihQWGg0HY1JvwiNK0t9hqaXmF1WeZ47uzN5np7kv1pYRyviriAIgtOYjkYZnRYEQRCENYjQ6CLmCVIiwXDtNkCzVwjwEOOkFGx0wNjghLNyUlrWaKPLDbfPDucRGgP+G53OHuEFqsPRWIITzshoTPhIOM3ez+eW45ydVHmetsYy+Dmj0QNH47k5VVrSFGmipaYl7/3MCxm634RGtY7PpmMZdnQ1rsjzNI8tbq53kXWMJ+NcWLgAiKNREATvSKV0ZtJCY4s4GgVBEARhDSI0ukRKT5knppvjCY6mVDHJeshnBKccjS6NTgfV26A0obF4lphdJJIpjgwrMSCvo9GHo9Omi9RwfPpSaCx9HTOORv+85kb5zubmzRxO7yu9zbW0NdiYHeXh6HTBiABdd/X9aJAt7hpNzbnIXMjwSWHTqnXMl+fpult6aQrmlIiYz9E4ND9ESk9RF6qjo7bDne0SBEFYxdxyAuPakZTBCIIgCMJaRGh0ibHFMZaTywSBvkSCR5dU47StGWoeYpyUgo0OmFUjfqWi6/pad10OymqddtFBdWpigWgiRX0kyJb2lXmejpTwVEi26AVUvI6OkUplCn1KcKYG8N/odLa4awpHdrfZe7iOBTMa54ZheQa0AHTscm2bzP28yAhvMGCUB/nN0ajWMd/+4nr+q+Eubh6E2tz7rlVxVxAEwUkMN2N9JEhNKFjk3oIgCIKw8RCh0SWME6T+JISBx5d70TTY07v+hEb7HY3lPd5UdIr5+DwaGgNNA3nvV3JGYyIGE8fUbRcy4Q6lRxv39jatyfMM+jAvcM24ul+FxunTEF+EYA20b7P8Y350NJrO3azGadsvYmiVvR8roWBGo5Gz2b4dwrWubZMp7uZpnDYwL2T4JaPRWEd9pdCYzy3tWiyDsY7d+Y+p5oUjGZsWBMFDppdUEYy4GQVBEAQhNyI0uoR5ghRV2WlHU4Ns62ygPhIq9GNVg6ZpBDRjBNkfGY2G+NLb0EtNsCbv/UpunZ44prYp0gQtg2VtWynkK4IBMq+5TxyNM9EZpqPTQPbotE8zGo3iic7dGVHbAn4Ud7MF776QwwAAd8xJREFUmEL7S0X4NaPRWEcfNk5DmWVTTpK1jvPRBKcmFoG1+0sgYPPxvBgW1tEsVCtQ7iUIguA004vpfEYRGgVBEAQhJyI0uoR5gpRIsBRuY5LmdZPPaGB7pleFwoaVsWmAULDEDDVjbLprD7gwvpfPcQQejDcWwcgh7azrpD6cHvP2q9Bojr+X5koN+KzpezG+yNjSGAADDZs4MpI7z7NifCA05hR3zfeje43TkCMiIA/BcqIZnCRrHY+kS6Z6mmtoX5Xn6XrrtIV1lMZpQRD8gNk4LUUwgiAIgpATERpdwjxBiicYCik3xnppnDYwRC/7MhorG9W0OtpYsuPIGJvu3F3WdpVKIaHR9cKGIuQUAjSjDMYf22hS5joGfFbAYwjqLTUtTMwFWY6nqA0H2NrRYO8TVfh+rARzdDrXfj7u7vsRIJaMme3Hxdx1xuh0yjet05kyGCOWoeCxxa31trCOMjotCIIfmFlUo9OtdTYWrgmCIAjCOkKERpcwT5DicY4m1lcRjIFxYprSbWpX1TInxOWQnVtXiFCpQuP4c+pr586ytqsUJuajjM5F0TSV0biagtl1HpBztNGvjkZjHTtKW0e/jatnO3cNUXpvb7MpoNuGl63TaXddzmPLRHnrWAnn5s+ho1Mfqi/afhz0W0ZjlmCcr3Eaioi7dhOdh7nz6naedUykEgzNDQEyOi0IgrcYo9PiaBQEQRCE3IjQ6AK6rq8YnX5iqQuAfX0tXm6W7RgnpraVBxgCVZknulZHp0tuhTWFDecbbp9NO462djTQULM2z9P18cYimI7GbMdRhevoGMY6dpa2jkGflcHkapx2JJbBw3U0jy2rRc6laVhQY+NuCo3ZY9PF2o/9m9GYLBzL4OaxxXAX13dAfXvOu1xYuEBCT1ATrKG7vtv5bRIEQciDMTrdIkKjIAiCIOREhEYXmFieYDGxiKbDYDzBsVQvbfVheprzF5RUI7aP2lVaBmN5dFp9tSQE6DpMHFe3SxSoyuHQhRkgv/vVdnG3QnKKu350NC5MwNKUut2+o6QfzYyr++P/Yzp3mzdzyHSoOeCW9kFG4xrRy3gvNvZCrXtRFNnibjEyGY02Ob0rJb2OqWSCw4VGp/OJu05gCI0FLt4Y4u6mpk2mq1gQBMELTEejjE4LgiAIQk7k07oLGOJLXzJJBDih93NRX3NRJ0y1YbsDpoJMuJnoDDNRJdINNhZuhjYdjVZGG+dHITqrcgfbt5e8XaViOBov6s0torieo1YE07mbLe56OHKbF8PN2LIJIvUl/WjQZy7SXKPTzjgaPRydzld6VKYrtVKsxjJAGdEMTpNex9nFJZbiSWrDAbZ1rs3zdDX/1cxLze9KLUXcFQRBcJKZpXRGozgaBUEQBCEnIjS6gCm+xOMkCXJW71p3jdPgQF5gBQ4qQ3zpruvOtB/noaSyBkPYaN0MIecdqcWEI1dz1IqwGF9kYnkCWJ3R6F2JSF7MfMbS3IyQldHok/+PWQYT7mNkNgrAXidHp70og9HyOHcrWMdKKKWUxK+j05NziwDs6WnKmefpaqP9ePE4CmmcFgTBL2QcjSI0CoIgCEIuRGh0gUzjdJyRYC8JQutTaMwnBpRLBQ4qQ9wdbCrsZoTs0UYLQoCFE2K7iCaSHBudB2Bff+79xXSR+kD0MsSX1ppWmiNZ2+vH0WkLo5r5CJrFJN6/5tFklOGFYQAWF1oB2NJRT2OOPM+KqbCcqRLyXsRwMS81m1LcdaGAIUz7RGhMr+P0/BKQ/9jirqOxuDM1e3RaEATBSySjURAEQRAKI0KjC5jFAfEER5OqcTpXy2e1Y7sDpgIHVc5SkjyUNNpojvg5L2wcG50nkdJpqQvT11Kb8z62i7sVkNdx5KETLi8VrGPIRy7SobkhdHQaw42cHVP7cb4x+4rxgaNxzWs+7t770SCeinN+XjUkW3HXlXQhww3S6zi9sAwUd0s7ntGYnXtrwdFYLHNXEATBaSSjURAEQRAKI0KjC5gnSIkERxK9hIMaO7sbPd4q+zFHSm3LaMxqubUy1pyF1cZpKLGswXQ0Ot9wa+Yz9jXlzfO0fVy9AnLmM4I/HY0VrKOrTq8irGicHs5f7GELfiiDyd7PUymYNAQq9xqnL8xfIKknqQ3W0lXfVfT+oaA/R6dnF5SjMa/Q6NZ+PncBYvPKadm2NeddkqlkScd0QRAEp9B13cxoFEejIAiCIORGhEaH0XU9UxwQT3BC72d7ZyOR0Pp76W13wBij01Cyiyqv6JUDM0PNShmMi+UTR0eUcLS3gEPNT6JXXiHAaIj1gRgKQDIBkyfU7TLWMRjwTxlMduO0sb/s6XWgcRo8zdrM2a4+cxYSyxAIQ+sW17bFEHcHmwYttR8HNL85GtVrGY0pR87unjyN9m4VTRmif9tWCOV2B40ujhJPxQkFQvQ29Dq7PYIgCAVYiieJpz8vSkajIAiCIORm/aldPmMmOsNcXAkAg4kEJ1J97OpZf25GcKJ1OitnrkTxspTiAMujjYkYTJ1Wt11wUD2XFo4K7S+ujTdaIG9und8cjdOnIRWHUB00F8/wXI0hwPgho9F8zRs3mXmeu506vni4jjmzSA3Rv307BB3IpMxDKY3TkB3NYMEx7QbpdQxpSXqba2nJc6KcU9x1goni7mJT3G0cNCM6BEEQvMAYmw4HNeojwSL3FgRBEISNiQiNDmOcIHUnEtTpOif0PnZ1O+Q48piMAGPTCbWW9QGuBFFnPjbP5PIkUFpZQ9HW6amTajsijdDUZ3l7yuXoiBKOCu0vtr/mFZDtrltB9gi8HzCLYHZAoPRDoJHR6Aeh0XCRNgZ7WY6niAQDbG4v3LJeNoaj0YP/dzCQYz/3IJ8RSmuchuzWacc2qTTSr2WAVMGLGCGz9MjhDbewjqWU7wiCIDiJITS21EXyxtoIgiAIwkZHhEaHyTROJ5jXGpmg2TnHkcfYPzpdnqPREALaa9tpihQXdS07Gs1cvx3g8IfLhWiCoWmVobarQJ5nyCdjvMuJZUYWR4BCZTA+cTRWmLNpirt4LzQa4m4y1gHA9q4GQkGHDus+yGhc4a6z4IRzglJFr0xGo0+URsPRSLLwRQy38l8trKNZqGZR3BUEQXCK6XQ+Y6vkMwqCIAhCXkRodBjzBCmR4HiqF9DW7ei07XmBK4RG649ZshBgNaPRPCF2p3EaoLOxhraG/K2GpgDjsYh3bu4cAE3hJlprWld+08Nsv5xUmLNpiLteu0jjyTjnF1T78exsCwC78uTt2YK5jh4IjblEr3H38lKzyevczUMw7Zr1W0ZjsIij0bVGewvrKI5GQRD8wozZOC1CoyAIgiDkQ4RGhzFPkOIJjqX6CAc1tnQ0eLxVzmC66+wSlAIBIO0cLMPRaDVDzbqj0b1Rzecs5u35pQzG3M+bN60dJfJQoMqJsY5lCsZ+GZ0+v3CelJ6iLlTH0IR67+12ss3edDS6///Omf86Udk6lkMyleTcvBLVLR9fNONn/SI0ZhyNhY4vrjga48swrY4dhdaxlMxdQRAEJ5leSguN4mgUBEEQhLyI0OgwpugVj3M81ce2zgbCTo02eowjDpgyRCrjNbfSOA3ZGWpWHY0uFsEUEY5sF3fLpKC467fRadPRWN46mo5Gj0enzWb1pk0cG10AChcHVYzmvaPRdO7GFmB2SN120dE4sjhCIpUgHAjTU99j6Wf85mhcSr+EQVLs7MrvgDXEXR3dOffu5AlAh5pmaOzOeRdd103HtIxOC4LgNdkZjYIgCIIg5GZ9Kl4+whRgEglO6P3rtggGHHLAlOGiKrsVtlgZzIT7jsadRUZhXRtvLEK26LUGD51wa1iehXmVJVmpo1H3i4u0KdM47ezotHfruMa5O3Fcfa1rh/p217bDbD9uGjSPd8UIWb2Q4RKj8+pYUReClgKOnOz/n2MXMkxX6s68ubfjS+MsJZYIakH6G/qd2Q5BEASLSEajIAiCIBRHhEYHmYvNZdqP4wnVOL1O8xkhz3hjpZThhit1zC7b0ajnExsXJ2FxQt12wdF4NO1oLDYK61phQxHM1zyX4yi7dbqYmOs0hpuxsQdqm8t6CL84Go2LGK3hPpbiSSLBAFucapwGT52pa5y7FeZslktBQT0PwaC/hMYLc2r9moqYcQxxFxy8kGFhHY1jS19DH+GgnNgLguAtktEoCIIgCMURodFBzPbjZJI6HU7rPRvC0WhrMUmJRSJLiSVGF0cB62N2oUDmbZBXDDCcN80DEHE2Y3MxluDcVLpx2qKj0euMxsKj01nOL69djRXmM0J2RqO3ZTCG6BVKdQION06Dp6U+a5y7NqxjOZSa/woZR6NfRqfPzyk3TmM4t4PQIJRVxuXYhQwL61hq+Y4gCIKTGKPT4mgUBEEQhPyI0OggpssrnmBI7yJKpGi5RzUT0NTu5KWj0cjyao4001LTYulnDMcRFBADxt3LZ8w0TkdoL9A4DQ6JuyUST8a5sHAByCMGaNlCo8c5jRXmM0JGgNF94miMLqrR4Z1OFsGAp45G89iyxtHo/Psxm7IcjaZj2lth2uDcjDpJbihyjmy85uDghQwL62hm7krjtCAIPsAYnW4WR6MgCIIg5EWERgc5O5spgjmR6iUUWL+N05A1Om2n+6XEAopy2kmDWdlg+R2N7o1qPjeSzme0IBz5wdE4ND9kth931HasvUOWM8pzodEGwTgc9L51Orv9eGJajYDvdjKfETxtDzdHp43X3EXhP5uCEQF5MI4vfnE0Ds2ok+T6UOHtWTE67cSa63rWOkrjtCAI1UHG0ShlMIIgCIKQDxEaHcQsa0iofMZtnQ1EQuv3JTfzAp1wNFp8TEPcLcdxBAUKYSycENvF0dF0PqMF4cgPrdPZpSRarkKHbKHR4xHvTPlEBaPTZhuvdw614cVhEqkEkUCEc+PKVVGsobxiSnwv2okpqKfSOZ82rGOppPRUpv24lAsZacd0ygdC43w0weiCWr/aIl02mqY5eyFjcQKWpwENOnbkvVs5LlJBEASnmFmSjEZBEARBKMb6Vb18gJktFU9wXO9f10Uw4JC7rsRxTVP0arZ+UhrKFhqTRTIaXRjVPJZ2NFoRjvzgaCyaW7fC0eih0JhKZdqKK3CmhgPeC43GsWWwaZBjo4uAw43T4G3rdPZFjLlhiM2DFoD2ba5tw9jiGMvJZYJakL7GPss/56eMxmOj8yTTv/ZDFkb/jeOLI3mkxsWblk0Qrst5F13XM8cXyWgUBMEHmEKjZDQKgiAIQl5EaHQQ8wTJaJxex0Uw4JC7rsQCinLG7AIBDcOIl1MMSCVh8oS67aKj0Ypw5Aeh0XQc5RN3s8p2PB2dnj0HiSUIhKF1S9kPE0qPTnuZ0WgcW7pqB1iMJQkHNbZ0ONg4Dd6OTmc32hsxBq1bIFTj2jYYx5b+xn7CAesnmMGAkS/pvdB4dGSOBNaPqY5mwFrIZ5yKTjEfn0dDY7Bp0P5tEARBKIFoIsliTB07W+tkdFoQBEEQ8iFCo0MsxhcZWxoDYFMizolU34ZxNJrNsHZQoqPRzMUs0f0SMgsbcogB06chGYNQrXLfOMiKxmkrjsZA1kipR1gSdz0sEjExHFTt2yAYKnzfAoSD/nE01mndAGzvbCTsZOM0eLqGK/bzcffyUrMpp3EafOho1K0LxisEXruxks+Y3s97GnqoCbonKguCIOTCcDNqGjTVlv85QhAEQRDWOyI0OoRxUtqSTBJORhim3fmyBo9xRPQqwdEYS8bM9uNS87wCZmFDDvFoPD023b5jpTvPAY6PLqDr0NEQoaOx+Im1o0KARSwJMB6O3ZrYlOsX9kHrtCHu6nFVvrPTjYsYWmnuYjvJvoihu5iXmk25WYFm63S+WAYXOToyR5K0fdvCMcPRCxlmHEX+dSxX3BUEQXACI9qmtS5MIJAjk1oQBEEQBECERscwTpCMIphQIMDWddw4Dd5nNJ6bP4eOTn2oPnf7cQEKOhotjPjZxXPpsWkrjdPg8GijBRKpBENzQ0ARAcZPjsYK1zHiA0ejcXyZn28FYLcbsQzZZTD5SpMcIpSV85myaR1LJbv0qBSCPnI0PjcyTxLrjkZHXOoGFprDy33NBUEQnOCj96mc51fs7/V4SwRBEATB34jQ6BBD82nxJZ3PuHWdN06D9xmNhuA12DSYu/24AMFCQqObjdPpq+VW3a9eZzSOLo6S0BOEAiF6Gnry37HErE1HmLBnHUPG/8UjR6Ou6+bxZXRSCdKuxDKY/29cX0djPwdITnrjaDSP6SWKXsZFjJTL4uxqFqIJhqaXyspotN3RmIzD1El1u4CjMfuYLgiC4CWPnZnip8+NEwxo3PZidy90CYIgCEK1sb6VLw8xTkr7E0YRzPrOZwTvMxrPz58HVFlDqYSCBQobLIz42cUxswjG2v7iiLhbAuZ+3tBPQCtwONGsu6gcw4bGafDe0TgVnWIpsYSGxulhVUqy2xWhMbs93N11DGaJnImZc+qGyxmN5R5f/OJoPDaqLmI01deqf/Ayo3HqtHr+cD005X89jePLQOOAvc8vCIJQIv/wn+oi1xsuH2BTu8Pla4LgNQsTsDDu9VYIglDFSJKxQ2SExiQ/S/VbahCudgyhyVbRqwSBynjNBxtLd78UFAM8cDRabSg3XnNHRhstYFkI8Hp0OrYIM2rcuNJ1jJhFMt4IjYbLq6O2i5MxLd047UIswwpHo8tCY7ajUU9BpAkaCzhobWYhvsB0dBooXfTKxDJ4N2oPKp8RYFNHI4xiaQ3N44vd6226iwvn3orQKAiCH3ji7DT3HhkjGNC4/SXiZhTWGVOn4OjdMHYYxo6qr4vjoAXgsrfBS/4ImiQuQBCE0hCh0SEM98tgIsFxvY+XbwBHo+mucyKj0cJjmuJuOY7GfKPT0TmYH1a3Hc6EW4olOTu1CFh3NHrdOm3Z5VXCOjrCZNrNWNcGDaXld64mHFQuQjSPXKQLaj9vDqvG6W2dDc43TsNKR6PL67hCaNQ09V4sMR6hEoxjS0tNC42R0o7lwbSQlvC4DMZwNA52NKWFxuJr6MgxHSwVM8WTcUYXR4HyjumCIAh28Y8/VhdHXndZvzsX9gTBLSaOw8dvgNj82u/pKXj8s/D01+D634Hrfgsisv8LgmANERodIDtDrT+e4KTet+4bpyFrdNpO90vAuqOxktHpTOv0KjHAOCFu6IbalpIftxSOj82j69DeEKHTQuM0eN86XTWORhtdqZGAt6PTxn4eTnUC1t2vFbNidNrd/S17LD8BruczmseWhtKPLYYGnDOWwUUMR+Pmzmb1D1YyGjWHLmSYhT7513F4YRgdndpgbcnlXoIgCHbx9NAM9zw7SkCD2yWbUVhPpFLwrduUyNi1F/beDJ17oGuP+v08/DT88H/CuYfh3jvhkX+Dl/xPuOztBacRBEEQQIRGRzAy1AC0eDPRQB1bO9d/novhrkvpNgowpkBl3dFYzuh0KJjH0TjuXj5jqY3T4H0ZjHWh0eMyGBtzNkNBw13njXBkjE4nYkr4dqUIBtQIjYHLgrGmaYS0EAk9QUrTXM9nrGSE13A0Jj0ug3ku7WjcYgqNFlqnAw4dXyw4Gs/NqyzO/sb+ksu9BEEQ7MLIZrzl0n62d63/6SRhA/HQR+HMLyDSCL/6H9C2ZeX3Nz8P3vsjOPRN+NGfwPRpuOu34NTP4HUfAWPCRxAEIQdyOcIBDPdLdyLBUKqXrR311ISCRX6q+nHEXWfRCbcYX2QqOgVAX2NfyU+Tt3XaPCHeUfJjlkqmcboEobFqRqc9LoOxcR3NjEaPR6dn55Rg5JqjUdM8daaa+zq48n7MphKhMW8sg4ssRBOcm1IXv7Z2p53ZVoRGpy5kWHg/VuJQFwRBsIND52f54aERNA1uf4m7F7gEwVHGn4P//D/q9k1/vlZkNNA02P96uP1hePn/Udn5T34ZvvQ2lX8uCIKQBxEaHSC7COaU3uOeEOAxhhDgxei0cVLaFGmiOdJc8tOEzDKYVW7MqZPqa/v2kh+zVJ4rsQgGvB2djqfijCyOAFUwOj1p3zpml8HoHrjUDEfj6KRySbvSOG3gYXu4Gc2g4cr7MZtKRC+zaMrDjMbjY+rY0tkYobWhhNZpJ1rtYwswr44bhdZRimAEQfAaI5vxNZf0lzRtIgi+JpWEb34QEsuw4yVw5buK/0yoRuU0/soXIVQLz90Nn3sDLE07vbWCIFQpIjQ6gHmClEhwRu9xVwjwEEfcLxZHpysZm4as8cbVriNDoGrbVtbjloIxOl3KKKwj4q5FhheGSekpaoI1dNZ1Fr5zCSPwjjBl3zpmHI0p111quq5zYeECAAuLzYQCLjVOG3i4jubxBc2V92M21e5oXNFmn13MVEQoN8VdO1vtp06pr3VtUNea924iNAqC4CXPjczx/aeH0TT4LWmaFtYTP/9HlbtY0wy3/GNp5Xq7XwHv+CbUtKix60/fDHMjjm2qIAjViwiNDmC6XxIJTus97NwARTDgkPvFoqOxksZpyBQ2rCmDmTyhvrY7K2wsx5OcmUw3TpfgaPQyo9HYz/sa+opnqHmZ0Ridg4UxdduGdYykM2k0TSeWdPf/M7E8QTQZRSOAHm9lW2cDkZCLh3EPhUbDR5qsbSkoUDlBJaJXIJ9b2kVWXMQIZMV4FMnTdSSawTimFhGLZXRa8Bv3338/r33ta+nvV7mh3/zmN73eJMFBvnVQHYNeurdnQxQ6ChuE0WfhJ3+hbr/yTmgpw6Cx5fnw7u+qosyRp+Ffb8pcRBQEQUgjQqMDmCelceVo3LVBxi0ccb9YFDYqPSk1HY3Z443ROVgcV7cddlAdG1WN0631YTobI5Z/zhFx1yIliS9ejk6bDqp2W5rDI6FMh1Y86e7/59ycKshoDHUAQfeKYAw8zNoMpst3Ei3uOtxmY7PMxZRQV87xxQ+OxkwsQ+Oq9vDC6+hINIMZY2BNaBRHo+AXFhYWuPTSS/nIRz7i9aYILvDDQ8MAvOaS0nO/BcGXJBPwjd+AZAx23QSXva38x+q9GN57N7RuUZ+z//11MDds26YKglD9SOu0AwzNngXU6PRZutne5eJoo4c44n6xKFBVOmZnigHZo4TGCXF9B9SWnvtYCsfSjbC7u5tKalj10tFY0mvuYbaf3a7UTEYjxFwWGg3xJZxSo+qu5796WQaTfm8mm911uBmveXttO/Xh+pJ/Ppjr2OIyGUdjUw6hsSbvzzkSzWAhxiCajDK6NAqI0Cj4h1e96lW86lWvsnz/aDRKNBo1/z47O+vEZgkOcHpigaMj8wQDGi/e0+315giCPZx+AC4cVGPPr/2H0kamc9G+Hd5zN/zbK5XY+Nk3KKdjXZsdWyv4kVQKjnwvbeLQ0xE86a+9F6vMz0r3K2Hd4Guh8c477+TrX/86hw8fpq6ujuuuu46//Mu/ZM+ePV5vWl50Xef8gjoxrY/X0tnRtSEap8Eh0csQqIo8ZqVCY87WaRtz/YpxdEQJATtLdKh5mdFYkos0OxfObWzO2axJj04DxBIuC43pY0s8qpyZnjkaPVjHUPoCRrLZXXeJGcvQUJ7AGUq7pb0qg1mMZRqnlaMx65tFLgo5cky34Gi8MK9ySOtCdbTWtNr33ILgInfeeSf/+3//b683QyiDHx1SmXPXbm+npT5c5N6CUCWcuFd93fNKsOuzVHOfymz811fA6DPwhbeov0dKvzAr+Bxdh7vvgIc+lv8+226AV3xYiY7ChsfXo9P33Xcft912Gw8++CA/+tGPiMfj3HTTTSwsLHi9aXmZWJ4gmoqj6TrReCc7NsjYNGSdlHqQ0WgIMJU6GldkNFoc8bODE2Nqn97ZVaLQ6AdHY5OV0WkPHY1T9q5jOJi5cBD1aHR6bl45GV1vwfTQ0RhIP2eyqdfV5608lsHb0emT4wvoOrTVh+lorClpdNqRY7qFCzjZY9OlOLwFwU/ccccdzMzMmH/Onj3r9SYJFvnhM0pofPlFPR5viSDYyMn71NdtL7L3cdu3wdu/ruKJzj4E//FrkIzb+xyC9/zkwxmRcd/r4JK3wCVvhUt/FQ68EYI1cPJ++NgL4a7fkpIgwd+Oxh/84Acr/v7pT3+a7u5uHn30UW644QaPtqowhvjSk0wypPdsmLFpyHLXuZzROB+bZyY6A9ghBmSVI7joaDwxrkanS91fHBECLGIKjQ2lZDRWv6MxFPB+dHppqRVNg61uNk6Dp6U+wWQCgpBodFdoLElQz0Eo6K3QaFzE2G5cxNCyri8WczQGbL6QkYzDdFpsKSD8n5tXgrqMTQvVTE1NDTU1+aMJBH8yuRDjkdOTALxsnwiNwjphaRrOP65ub7dZaAToPQC/+h/w77fCsR/BNz8Ir/8EBHztaRKs8vN/hPv/St1+9f+Da96/9j5Tp+GeP4FnvgGP/Ts8/XW44Q/gut+W/WCD4muhcTUzM0pMam9vz3sfrzNxVjdOb+/cOEKjWRzgckajIQS01rTSEC7v9TaExhXjjS45GpMpnVMTqnF6e2eZo9N2irsWiCVjjC2qJmdro9Prx9EY0ALoupZunXb3iq3h3NXjbfS31FEbdjmWwStHYzJOKBmHYJhkk7t5WSUJ6jkIaDnc0i5yclwJjduM30WaptYxlbDsaLQtmmHmrBq7D9VCAcFYGqcFQfCK/3x2hJQO+/ubGWyr4vHPmXMwewHmR2B+WLmLEkvKedR/uddbJ7jN6QdAT0H7jvKapq2w+Vp487/Dl34FnvqKKmF81V9KZl+18+in4Yd/pG6/9H/lFhkB2rbAmz4Nz/sN+MEdcP4xJTwOPaJEZxmn33BUjdCYSqX40Ic+xPXXX8+BAwfy3s/rTJxM43SSM6keritxFLaaMUSvlJ4qcs8SsCBQ2dFOaoxOp3T3MxrPTy8RS6SIBAMMtNWV9LOGuGvra26BCwsX0NGpC9XRXptf+DfxSqBKxNSHbbB5HQNAkkTSPWdfSk+Z+3oq1sb2AQ8uYnhV6jN9JlMGU1N5c3gpVCp6ed06bQiNK9zSWhCwIDTafUw33cVbC17dlsZpQRC84ofpfMaXV6ubMZWEr70Pnvl67u///B9h58uV02jz89zdNsE7TqTHpp1wM2az+ya49WPw9ffBLz8Ozf3wgg85+5yCczz1Vfj2h9Tt6z8EL/yvxX9m87Xwvv+Ex/8dvvcH8Oy3YebV8CtfApfjjwRvqRof62233cbTTz/Nl770pYL38zoTxxQaEwlO690ZF8kGwHS/uDw6bZY1VOB+Ca7OaMwWqBx2NBpCwJaOenM7rOJI07cFsgsyLGWoeTU6PXNWXcEN1dn6y03T1aHTzYzGscUx4qk4GkH0RLM3bmmv1nHqJEHSQiPuieq6rlc8Ou11RuMJQ2jM3l8sljOZLnW7RqctXryptNxLEJxgfn6egwcPcvDgQQBOnjzJwYMHOXPmjLcbJtjGUizJT59T0xpVKzT+8I+UyKgFoGUTDFwJe26Gq96j3IxaUI22/utN8JnXqkw13ZvfT4KLOJXPmItL3gQ3/YW6fc+fwJNfcf45Bfs5+0v4xq8DOlz1XnjZn1r/2UAArnwX/Nq3lLP1/OPwyZfCyDMObazgR6rC0Xj77bfzne98h/vvv5/BwcJ2b68zcc6nyxr6EwkmagboaIh4ti1u44joZcHRaMdJqdEMa4oBhkAVrodGZz9snhhT+YzliNKOiLsWKFnc9Wp0OttBZevohtpf4i4KjcZrHqEdCHpzEcOrjMbJk4TSb003i49mY7MsxJVQV3brdNC70Wld17OOL1nueouCse2t9hbjKOy4eCQIdvPII4/w4he/2Pz77/3e7wHwzne+k09/+tMebZVgJz87Ns5yPMVAax37+pq93pzS+eUn4cF/Vrf/y7/C/tevvc9L/gh+9rdw8ItKZDx5vyp2eN1HoKbJ3e0V3GFuGMYOA5pqBXaD626H2fPw4EdUXmNjF2y/0Z3nFuzhoY+r87a9r1G5jOWcR225Dt53D3zhzTBxDD71CnjTv8Gul9u/vYLv8LWjUdd1br/9dr7xjW/w4x//mG3bnC/lqJTzs+rKdkdco7ljYzVm2u5+AUsnxHaM2a3JaHRMoFqLmaFWRnGQV47Gkl9zD51wgP2uVF297jEXhVNDfNHjbQBs8yKWwasR+KlTGUeji/uQ8Zp31HZQG6ot6zFCuYqmXGJiIcbccgJNU45pE4vCv+2t9lOn1NcCjsblxDITyxOAOBoFf3HjjTei6/qaPyIyrh9++MwwoNyMVff5/bkfwff/m7r90v+VW2QEaN8Ot/wj/PbjcPX7IRCGQ9+CT74Exo64t72Ce5y8X33tvRjqLcQd2cVNf672w1QcvvwOGH7KvecWKiO2CEe+r25f/6HKylw6dsB7fwRbXwixOSU6HvyiLZsp+BtfC4233XYbn/vc5/jCF75AU1MTw8PDDA8Ps7S05PWm5SSlpxhaVNkuerzNGyHAQ2x3v0BJZTB2jE6bjkZXG6eV0LijxCIYyIi7OrqrOY0lu0i9yvazuXE6g/uORrNxelFlFHo7Ou3+OgaNVAMX3buVjk2Dt2UwxkWMNcVBFtfRaFi3Tdy14Gg09vPGcCPNkSp0FAmCUJUkUzo/PjwKwE3VNjY9/DR85V1qEufyt8MLfq/4z7Rugpv/H7z7e9DUB+NHldj4zDed3lrBbdzKZ1xNIKDyGrdcD9FZ+PybYNrdSDOhTJ77IcQXoGUzDF5V+ePVt8Pbvw6XvU0dp775QdVMLaxrfC00fvSjH2VmZoYbb7yRvr4+88+Xv/xlrzctJ+NL48T1JEFdZyHezfaNJjTa7X4BSwKVrY7G1CpHo8P5jGCPoxG8cXpZH532ygnnzDpq6UNnzIPR6USslUgoQH9racVBtuDVCPzUSYw93c393Dy2lNk4DTliGVzk5FiOIhgo2dFoi7ir65YcjdnHlqpzFAmCULU8dmaKiYUYLXVhrt7mouurUuaG4Qtvgdi8cgzd/LelTeJsugZ+/f6022gevvJO+OEfg4ufbwQH0fWsfMYb3X/+cC289fPQdRHMXYDPvREWJ93fDqE0jDKp/bfaN9kXisAt/6Sc1Ohw12+puAdh3eJroTHXiIqu67zrXe/yetNyYpyU9iSSnNN7N1QRDDjgfoHMCXEe8XI2NstcfA6ozNG4pnV6Kmt02kGW40mGppVDt5KMRnDX6WUKMFadXkXW0TEcczSq/48XjsZUrI2tZRQH2YLFEhFbSQtUIaN12sXntsUtHfSuDCZnEQyUnNFoyzF9flRdHdcC0Lo5792kcVoQBC8wxqZfsrebcNDXp0cr+cq7YfYcdOyCt3xWncyXSmM3vOObcN1vqb///B/g8/8FonO2bqrgAZMnVO58IAxbnu/NNtS1wdu/Ck39MH4EvvhWNZor+JPoPBz9obp94I32PnYgAK/+a3j+7erv3/t9+MU/2/scgm+oot+k/ufcvCqCGUgkOLPBGqcBAprandxsnR6aU0JAe207daHyHV55MxoddjSenlhE16GpNlRWcZAXjsblxDLjS+NACU4vLzIasx1UDjka455kNLZ7d2zxogxmfgTii+YvK1ujGYpgx+h0yMPW6bxFUxbX0VaXunHxpnmw4ImwNE4LguA2uq7zo0Mq+qiq2qbHjsKZnysR6W3/oQSdcgmGVKbemz4D4QY48RP49Gtgfsy+7RXcx3AzDl4NEQ/PS1sG4e1fg9oWOPsQfPXd4pr1K0d/AIkllefad6n9j69p6lhjRDzcfYcqqBLWHSI02ojhxOhPJDit92w4odE8KbXV0Vh45NZ4zQcbC7eRF2NFYYPFET87ODmuhIDtXY1ljQlmOxrdcnqdX1CveUO4gZaaFms/5MXo9Nyw+kWpBaBlk60Prbmc0ZhMJRleUG6LVLxtZYOwm3ixjmnRP5i+kOCmo9GO0ensWAZdd1dszMQyrNpfLK6jOTptx3qbF2+2FrybCI2CILjNsdF5Tk0sEgkFuGF3l9ebY51nv6W+bn+REgXsYP+t8K5vQ30HXDgI//oKmDptz2ML7uNVPmMuevbBr3wZQrVKzPrO76hzLsFfPG2MTb/BuUJUTVOlVTfeof5+z5/CF39V5c0K6wYRGm3kfNpdN5BIsNiwmYaakMdb5C7m6LQjrdO5T3QNF2klo40AwXSOWiKlZwlUwYIjfnaQd7TRIitGp10Sf0xBvZQMNS+y/QwHVcum8kaJCuC2o3F0cZSEnkDTg+iJprWZe27hhdCYXsdQRLUmu+Xc1XXdltHpUNaIu5umxmRK5/SEGk3KPzpdRGgMOOBoLHIybMdrLgiCUAr3PKtKYK7f0UFjNX12P3SX+rrvdfY+7sCV8J67VRHE5HH41E0w8oy9zyE4TyqVaZze5gOhEdT49n/5V2UCePxz8OM/83qLhGyWZ+DYj9TtA29w9rk0DW787/Cy/632hyPfhY9dr4qtxo44+9yCK4jQaCPnZk4A0BtPUde5xeOtcR9HymCKjPhli16VYMTxJFO6yjMB1cgXDFf0uMU4kS5rKNf9qmma+bq71TptjKuX5PLyYnTawfF3zchodOn/YwjqWrINCHjTOA1Z5UxurqN6PwYjypXnlqNxKjrFUkLlp1ZyfAlkCY2JlHvN8Oenl4glU7mLgzRrmalGq70txxbjuFrEJS4ZjYIguM1jZ6YAuH5np8dbUgKTJ2H4SXU833Oz/Y/fuQveezd074P5Yfi3V8HpX9j/PIJzjDwNS5NqFH7gSq+3JsPem+E1f6du//Rv4KGPe7o5QhaHvwfJGHTuUe99N3jBh+A3H1QOSoBnvgH/fC18/QPWWsrPPASPflo5MY/dA+ceUbESy7NObrVggSq6bOd/DEdjJN7A5m6LI6XrCFuLAwyKOOHsOikNZjfDmkUwLjZOVyAcBbUgST3pmgAztFBGbp2XjkYH1tFwNCZcGp029vNYtBWobH+pCC/W0RidjjRBbNS9iID0a95d100kWL4jdoWj0T2dkePpfMacxUFWW6cDToxO538/LsYXmYqqE35xNAqC4BZPnpsG4NJNrZ5uR0k8m3Yzbr0eGjqceY7mfnj39+ALb4WzD8Jnb4W3fA52vdyZ5xPsxchn3HKd7ZM9FXPlO2FhFH785/D9P1TZjZe+1eutEoy26QMOjk3nomsPvOnf4IX/Fe69Ew5/B578Mhz5AdzyDyrSYTXxJfjhH8HD/5L7MYMRuPztcP2HoG3jGcD8gDgabSKZSnIhOgFAIt7pnePIQwz3izOj07kf0yzgqVBoDGXlqLlVBAMZobGSUVhbxQALmC7ShhKEAHE0VkR243RzbYj2MoqDbMGLdTRGp2uaAPdGp+2LZfDG0VjwIobV1mknymAKCP/G2HRzpJmmSFPlzykIglCE4ZllRmajBAMa+/ubvd4c6zg1Nr2aujZ4xzdg1ysgsQxf/BXlOBL8j5/yGXPxwt+H5/0GoMM3PwiHvuX1Fm1sFifh+I/V7f0Oj03no/cAvPXz8IF7YeAqiM7AV94J3/6dlU3lo4fhky/NiIzbXgRbroeei1XsWU2LcmY+8q/wD5fDNz4I48958l/ayIij0SbGlsZI6ClCus5MvMe7DDUPccbRmD9LTNd1G0ens5phXXI0Ti/GmFyIAbC1o/z9xRGBtwDm6HQp4q62vhyNATtLMixgiF56vJ1tZRYH2YKXZTC1yiVua6t9AUy3dAWN0wChQOZ6npvN0xmhMUdxkMV1NHN3Kz2mL8/CoroQV0j4l7FpQRDc5om0m3FXdyP1kSo5LZo5B0OPABrsfa3zzxepVyf/X/+Acjx99T0QW1BuIcGfJGJw+ufqtl/yGVejafCKOyE2r/Iav/peeGsd7L7J6y3bmBz+jvpc2HMAunZ7uy39l8N7fgA/+bBqpH7003DmQZXvefaX8IM7VJ9CQxe8/mOw82VrH+PUA3D/X8OJn8ATX4Anvgj7X68ar1vkc6YbiKPRJgwnRm8iwVm917tWWA8xG0r1hH3tqgUEqpnoDIsJdXWjUqHRC0ejUQTT21xbUXGQIwJvAYzW6dJGp70TqJxxNLpbBmM6GuNt7PDSLe326PTyjMoXAoK1rYCL+3k5zt0cZE8tJzwQGnNe9LI6Op11TK8IQ/Sv74Sa/E5FaZwWBMFtzLHpwVZPt6Mknv22+rr5Wmjqcec5g2F447/AFb8Gegq+dRs8+DF3nlsonaFHIb6g2sN7Dni9NfkJBOC1/6AcdKk4/Mc7MgU2gruYbdOv93Y7DIJheNmfKEd1Yw+MHYaPvQC+8yElMu54CfzGA7lFRlCxEr/2TXjfj2HPqwFdXSj56PPhqa+6+B/ZuIjQaBOmEyOR5By9DLbVFfmJ9YfhfgEbi0kC+UsLjJPSrrouaoI1lT2N6WhMueZoPFlhEYyBbWKABRbji0wuK+GnJHG3wDo6QpZARdtW2x8+gDfj6ql4m3f5jOD+Ok5mBKpgqBZwz7lrVyyDpmkrHdMuYRRN5YzxsDo6bddFDIuivzROC4LgNk+emwHgkk1VlK3u1tj0agJBJQpde5v6+w/+EO77a7DLXCDYx/BT6uum5ykxz88EgvCGT8DuV6nx/C+8VbnWBPdYGM8IvE63TZfKjhenBcWXq4scgRC8/P/A275m7ULL4JXwK1+EX/+pKkVanoGvvRe+8m41Li44hs+PPNWDeVKaSBBv3kI4uPFeWkPwAhvFgAInxHaelBqOxlB8FpZUGYETAlU2duQzgruORkPwago30RwpIcvI7Ww/Q9ho6CrooCoXzRB3k87/f+KpOMOLwwDo8Ta2eRnL4PY6TmUEKuNChtvibqWj05CJZnDL0bgcT3J+RjVm585otNYebltGo8WLN3ZFYQiCIFhB13WeODsNVJGjcW4EzqTbny9yYWx6NZoGr/gLuPEO9fef/LkqZCiWQbw8A0vTkIw7vokCMH1afXWh2NIWgmF406dh+43Kifm5/wJDj3m9VRuHQ99SJoK+y6B9u9dbs5bGLvjV/4C3fkEJhtf/TukCet8l8J4fwo3/Q01MPvN1+Oh1qqlacIQqCSPxP+enTwHQn0gw3u3DN6gLGIIXKDGgkqZWkwIjt3bmeRlCQHtUiZc0dEONs+PvdjROg7sZjWWNTYP7o9MOu1IDRuu0Cy7SkYUR5RDWQ+iJRo8djS6vo+mE225vMUkRsvNfBxoqP76EAhoxIOWS0HhqYgFdJ39xkNsZjSU6GgcbByt7PkEQBAucmlhkdjlBTSjAnt4qKaA6/G1AV86cFo+OlZoGN/53qGmGu++AX/yTcgbd8o8QXHVquTgJP/jvqkHWIBBWuY+RJth2A1zzfhi4wt3/w3rHFBqrqG03XKuEpM+9UYnp//46ePvXYdPVXm/Z+sdoKN93i7fbUYhAAPbeXNljBENw4x/CrperzNmJ59T+9vzb4WV/qgRvwTY2nu3OIc7PqBOp5niE/u5Oj7fGG5x1NK49IbZrtBEyjsY2Q2h0oXH6+Ng8ULmjMaClRS8XxB/TRVpqbp3b2X4O52xmymDcc5GmYq1AYGMJjVmCsSk0uvCaTyxPEE1G0dDobeit+PHcdjQasQzb8xUHWVxH89hiV0ZjEeFfRqcFQXATI59xX39z9UwiGWPTF/lAEHj+b8KtH1PuoCe+oPL14kuZ7x/5PvzztStFRlBZfMszMHtO/dwnXwz/8jJ48iuqxESonKm00NhaRUIjQKQB3vYV2HwdRGfhs6+H07/weqvWP2NH1NfeS73dDrcYuAJ+/X645tfV33/xT/CZW2Bu2NvtWmdUyW9V/zO0cEHdiLduyCIYWCU02iUGFBCobHU0pj9gdkTVYzo9apBK6ZyaKNAKWwKm68gFp5fZOL3RHY0eiLupeDt9LbXetmK63R6eJRibEQFu7Ofp17ynoYewDVc3Q9kZsC5gFE3lzGcEy+tom7g7eUp9LSD8z8XmmI3NAlIGIwiCOzxxVuUzVs3Y9MIEnPqZuu0X59FlvwJv+RwEa+DI99TI6/QZ+MZvwBffCvMj0Lkb3vef8Eej8N9Owu8+A7c9DO/8Nlz8ZuVwPPcwfP198HcH4IG/F8GxUgxHY+tmb7ejHGqa4O1fha0vhNiccpwZ+71gP8k4TBxTt7v2eLstbhKph1f/lTp+RZrgzM/h4zdk2tqFihGh0QYSqQTDMfVhZTnW6a3jyEMM8QXsdDQaJ8RrT9DtzPMyhICOuDuOxuHZZZbjKUIBjU0VFgcZYoBtBTwFMEenSxUCLGbC2YbDjkYNY6TU+dc8IzR6XAQD7q/j1Cn1NdvR6EZEgE2N0wbBgCFMu+NoPFGsaMpiqY9xEaOiY0siplwrUFD4N17ztpo26sP15T+fIAiCRZ4wGqerpQjmyHfVcbv3Yn/lqO19Nbzj62qU+vTP4O8ugSe+CFoArvttlak2eBWEaqC+XY18d+1WY9Nv/KQSHm/8H9DYq4TJH/0v+PgL4dQDXv/PqpOlaeUYheoUGkE5G3/1P1SzsJHZeOJer7dqfTJ5Ul14Djd4F8fgJRe9Fj5wL3TvU8efT78GfvERKbmyAREabWB0cZQkOmFdZyreX/EobLWiaZr9eYF5nHC6rpcveuUgmB4v7Iy742g08hk3d9QTqnBcx3B6ueGuOzenBIPSR6fdLhE5pb6uI0ej7guh0cV1TERhJi1QZTsaXXhu4zW3y1lnvMUTSZdGp8dVLEPe4iCrrdN2NNpPn1EtgeEGaOzOezcZmxYEwU0SyRTPnE83TleLo9Ecm3a5bdoKW18A7/oO1HcCOnTshPfcDTf9mcreK0RTj8pN+9BT8LqPqMcYOwyffjV88zdVI65gnekz6mt9h+N5844SqYe3fhF23QSJJfjCW+DID7zeqvXHeHpsunOXyl/diHTuhPfdAxe/SV3Muft/wFffDdF5r7esqhGh0QbME6REgpFgP91NNR5vkXfYLgbkERonlydZSiyhodHX0Ffx0xgZat2G0Oiwo/GEkc9og3DkqtOrGspgVglUTuCFuy4V85PQ6MI6Tp8BdCVQNXS5WnpkCo02NE4DhNKOxpRLV0eLFk1ZXEdbjudmjMHWgh9g7YzCEARBKMbRkXmW4ymaakJs66gCg0B0LuPo2udDoRGg71L49fvg9Z+A3/gZbLqmtJ8PReDyt8PtD8OV71b/dvDz8E9XwWP/Lg4jqxhCY7XlM+YiXKtGW/fcDIll+NKvwmOf9Xqr1hdGPuNGGpvORaQB3vBJePX/U3EOz3wDPvVymDju9ZZVLSI02kC20Jho3Zo7fH+DYIsDJps8WWLGSWl3fbc9GWpBjQhx2pLpq6YOOxpP2NQ4DTY2wxZhPjbPTFRd/S/Z0ehmtt8qgcoJzDIYF0WvVLyNHV0eX5l2s9Qne/xd01x17to/Ou1eGczUQoypxThgYXS6WOu0HeJuiY3TIjQKguAGxtj0JZtaCASq4HP76LOqRKWpT40d+5WWQbj0LRCuIBaovh1e+3fw3nug52JYmoK7fks52uZGbNvUdUs15zPmIlQDb/4MXPY25Ta763a4769FeLYLERozaBpc835413dVlMPoIfjEi8VJWyYiNNrA+Rl15WggniDStdPjrfEWxxyNq050hxbsHm3U2KSNEkCHSCM0ONscbjiOttsgHNku7ubBcDO21LTQGClxuy1mwtnCKoHKCTIlGc6+5vFknNHFUcAvo9MurmO2Ew5vXKR2HV8yZTDOfyg+mS6ZKlgcZDFr0xZxd9U65sPOzF1BEIRiGI3TVTM2PX5Ufd1IYsCmq1V22sv/TJXNPHe3arE2RsiF3BiOxrZ14Gg0CIbVWP0L/6v6+0/+HL77X92LZFrPmKPTG+jYUozNz1Pu7E3XQnQGvvgWuPf/5uyMEPIjQqMNdKJxxfIyW2LQ1bOxT5Lsz2jMfUI8PK/q53sbem15mlBAY7OmBB3anBOoDIqONpaAW9l1wwvqNS9rVN3NbL/JE+prEWGjEgJ2tfEWYWRxBB0dPRUiqDcxWGFxUMW4uo4rnXBuOXd1XefCwgWgzH09B6aj0YWMxqJFMFByRqMbjka7X3NBEIRCZBqnq6QIxhAaO33sZnSCYAiu/20lOPZeDEuT8B/vUK3WRuGJsJKpdeZoNNA0eOn/glf9NaDBI5+Cr7wTYgteb1n1kkrB+HPq9ka6iGGFpl5457fh6verv997J3zxrcphLVhChEYbeHPjLj5zYZSrZ5rZ0V3Fobs2YPt4Y54sseFFe4XGgKaxVVOPSftWWx4zH9FEkrOTi4A9GY1uZdcZQmNvfRmvuZvZflPWhI1KcMtFarzmeqKFzR0NFRcHVYyb62gKxmod3XrNp6PTRJNRAHoaemx5zKCbjkajCMaS0FhkdNoOcXfVOuZjZFGNw9l1TBcEQcjHcjzJkZE5oJocjWkxYKMJjQY9++B9P4YX/J5qs37ii/DR66WZOhfm6PRWTzfDMZ73AXjTpyEYgWe/DX+9C77ybuV0jS95vXXVxew5iC+qTEKHY8OqklAEbv5/cOtHIVSrXNUfvwHOP+71llUFIjTaQfpE6rTe4/1oo8fYPt6Y54T4wry97pdQcJWj0UHOTi6S0qEhEqTLhuIgt7LrDMdRWUKAqwKVMarp3Dq65Wg0XvNUvIXtnT64iOGhYOyWc9d4zTtqO4gEI7Y8Ziaj0fmRC0uxDFbLYCo9nqdSmQb4AsL/cmKZyeVJQIRGQRCc55nzMyRTOl1NNfS1FGlE9gtjWc2wG5VQBF72J/Du76uplZmz8Omb4Z4/hUTM663zB7q+PkenV7P/VnjHN9R+EF+AZ76unK5/tQO++h5VnCQZjsUxjisdO5V7WMjNZb8K7/2h2t+mz8CnboJH/k32sSKI0GgDsTHVRnRG72GrCI2AnRmNuUsL7HY0BgMBNplC41ZbHjMfxmjj9q5GW4qDApp6G7vmaCxLaHSzDCZ9JdfBdTT285TDr7nh8tLjrWzv8sGxxa1SnxUflLcC7mU0VrSf58HIaHSjddo8vhT6XWRxHY1jS9kXMeZHIBlV7pOWTXnvZuzndaE6miPN5T2XIAiCRbLHpquiwDERzVy02aiOxmw2X6tarS97O6DDz/5WtcOOHfV6y7xncRJiarKh0O/ddcHWF8BvH4T3/xiu+y1o2axEx6e/Bv/+Ovi3V8OJ+0QMKoRZBCPHlaL0XQofuA/2vBqSMfjOh1SEQ2zR6y3zLSI02sDxPR/gbbE7uKfmZTTXVt6AXM2YriPbMxpXOoHsFgNCAY0BzWicdvYKoJ35jJA1Ou1SRmNlQqPDji5dh+mz6raTQqPhInVJ9EolWvzhlrZYIlIxC2OQWAY0aB4E3B9Xt1NodCujMZXSOTVhJaPRWqmPOTpd7n4+k34vNg+qIPc8ZL/mVXHSLwhCVVN1RTCTJ9XxOtKkWqcFqGmCWz8Cb/53qG2FCwfVSOPDn9rYwpJxsb2xF8JV4tatBE2DgSvhpj+HDz2pxuuvfp8qDzrzc/j3W5Tr9eT9Xm+pP5EimNKoa4W3fgFe9r/VRfQnvwT/8lIYfdbrLfMlIjTawNGlRh5IXUygW96kphjgYEZjLBnLjNmVkxeYg6AGg4bQ2OJseLKlsoYSsF3czUNlQqNLI7eLk+pqJkCzPY3BuXDL0WhmNMZbfSI0ulQGY7gZm/vVqBQulh7Z7JYGCAXSrmOHMxovzC6zHE8RDmqFi4NKLYMp9zU31rG1sKuiovxXQRCEEnninHI0XlJ1RTC7HC8rrDr2vQ5+8xew/UZILMF3fw++8GaYG/Z6y7xhep0WwVhB02DwSrj5b+B3DsI1H1A5jqcfgM+8Vv258KTXW+kvxjZgm32laBq84EOqKKahG0YPwSdulIscORCh0QYsjaptEAwHTEq3ybmWQ6AaWVBjdrXBWlpq7PmQWJOYpUlLBwgXOSmulEyGmk1CowsjpSk9VVlZg1tCo0tXcjMFPM46NC8YjsZ4iz+OL26vY9YHZeM1t+3YkgcnRK9MRqOzH0BOpn8XbWqvL1wcZDWjsdKLGBZPeJxwkQqCIORiZilufg67tFocjRu1cdoqzf3w9m/AKz6snGzP/RD++Vp4+uteb5n7GI3T6zmf0QrN/fDqv1aj1Ve/XwmOJ+9Xrte7fhvmx7zeQu/RdRg7rG6L0Fg6W18AH3wAdrxUTWF99/fgy29XphcBEKHRFrqba7hqSxv7B6rkyqiD2D7emOOEONtxZNeYXe3iEACTtEC4gBPIBk5Pqg+4WzpsdjQ66PSaXJ4knoqjodFd3136A7iV7WeMajosFhuvecrhMV6j9KhGa7elOKhiXBMa0+uYlS/kVumRcSHDidFppx2NxrFla7Fji9XW6Uob7XOsYy6ccJEKgiDk4qm0m3Fzez1tDfYUfjlOtqNRyE0gAM+/DX79Pui9BJam4Kvvhq++d2Od+JuTBBvQ0ZiLlgHVGvxbj8L+NwA6PPYZ+Mcr4IF/2NglQgtjsDwNaKoMRiidxm5421fhpr9Qzd2HvwMfewGcesDrLfMFIjTawNuet4WvfvA63nHtBr96hAOilyFQoZv5fob7paehx57nAOoWlNB4QStDRCuB5XiSkdkoAFva6215zIrFAAsY4ktnXSfhQBk5pG6P3Dr8ASszOu2cu24pscRcfBaAwaY+f2TXuVXqk2Mdq7kMxi2h8cykCqTeXOzYkh7ltuxorHh0WhyNgiD4gyfMfMYqMgeMy3ijZbovgvf9J9zw39Q5xNNfhY9eB0d/6PWWuYM5SSDnpCto3Qxv+jd49w+g7zKIzsKP/hj++Xlw9G6vt84bjCKYti2Om2zWNYEAXHc7vO8eaN8Bs0PwmdfAD/8Y4steb52niNAo2IrtopchbIBZXHBhQbm87BxtrDGFxk7bHjMXZ9NCQFNNiNZ6e4qD3HB6VSwEWCyfqBiLDqpKCZkjpc6/5noywubWDseepyTMdXS41CeHM9UsJnFQrE6mkowuqvZ5J1qnHRcaJ6wKjYbwX3gdK3aoW3QYS0ajIAhuYTgaq2ZsWtdh/Dl1W0anrRGKwEv+J7z3h8qpNXcBvvAm+Nr7YWHC661zFuMC30Yfnc7HlufD+38Cr/sINPbA5AmV6fn5N8PEcWeeM74MS9P+y++TIhh76b8Mfv1+uOzt6jzp5/+gRvXPPer1lnlGyOsNENYXtjsaA1m7aCoBwbAj7peaeSU0nteddTQajqNN7fW2OdTccHpVPNro2sitS45Gu7NIc5BpnG5lS7cP8hnB03V0Yz+fWJ4goScIaAE66+y76OBWRqN1R6PF0elKxN3sBnhxNAqC4BNOjM8DsLu3yeMtscjcBYjNK3de2zavt6a6GLwKfv2n8JO/gAf/GZ76Dzj+n/Cqv4IDb1x/xTq6LqPTVggE4PK3qyKh+/4KHvwoPHc3nPgJPP92eOF/hZrGyp5jYRyO/gAOfw+O/1gVFYVqlbjZ2ANNPdC+HXa/EjY9b6Wxxi0MR2OXXMCwjZpGuPUjsPdm+M6HlJj7qZfBC34XXvSHEPJBDJaLiNAo2IpjGY1gnhQbJ6V9DX32PAcQSQuNQzjraDSEgC0d9oxNgztOLyMr0PdC44w1YaNSQsboNA6Ku1mN03buLxXhxjpmC1RZDfCmc9dBF6nhlu6u7zbfV3YQChqORueEaV3XTUdj0f3FahlMJeLuwrj6YI0GzYN57zYfm2c+rk78RWgUBMFJUimdU+nj5DabcrIdxxibbt+mnHpCaUTq4RV/ofL57rpdNcR+7b3w1Ffheb+uJmBaBtbH6Oj8iCql0AIFf+8KaWqa4KY/gyt+Db7/h0qE/tn/B098CV72p3DxmzJRM1ZIpeCxT8OTX4GzD66d/kksq9F2Y7wd4IG/h/oO2PMq2Psa1Z7u1r5oCo173Xm+jcTeV8Pma+H7/w2e+gr89G/gyPfhln9UF0A2CCI0CrZiv6Mx6wqPITQ6UBwQnlPCxtlUl22PmYvTVkcbS8B2cTcH5mte7mijG9l+Ll7JzbSrOy80puItbLJxf6kIN0p9FichrkpNaMl8UDZFLwcFdadGeAOa847G6cU4c1G1LkX3F4vrmN06ret6aS5s473Y1Ffw5Nh4zZsjzdSHfbKfC4KwLjk/s0QskSIc1OhvrfV6c6wxJo3TtjB4JXzgPvjZ38L9fw1Hv6/+GNR3QPMA9F0Ce14N21+sRMpqwvy92y+idCl07oK3fw2OfA9+cIcSAr/xAfjlJ+BVf2lNGNJ1+MEfqp8x6L1EOdv2vFo9x/wIzI3A/LD6OvSocj0uTsDjn1N/Io1wyZtVU3bPPuf+z5BVMiWj045Q3w5v/Be46Bb4zu+qixz/8jK46j3w0v8Fda1eb6HjiNAo2IrtGY1attC4sgzG1gy1OeVoPKc7m4VnZDRuttGh5kbrtG0ZjQ46ulieVuHOsEKgcoJM67SDLtK0u05PtNhWHFQxbqzjTPqDcmMPhDMngqZz1wVx125nnRsZjYZbuqe5htpwkREci5mpwazjb1JPmsd3SxjrWCyfURqnBUFwiVPjmYu9oWCVxNSPi9BoG6EI3PiHsO8W+MmHlaNr5py6uLk4of4MP6kEn1Ad7HixEon2vAoanJ14soWptFNO8hlLR9OUKLjjpfDgR+D+v4GhR+BfXgqXvAVe+ifK+ZoLXYd7/iQjMr74j+DSt6w1PbRtVX+yScbh9ANw+Lvqz+wQPPKv6s+W6+Hq9yqhKmhPrr/J8oyKZQAZnXaafbfAlutUOcwTX4BHPgXP3gWv+LByza63CIcsRGgUbCWgqQ9uthWTBAJqBEBPQSrBYnyRudgcYOOJ6fIsweg0AGdTzn6QOG01Q60EXMlorFhodGHk1hi3re+EiLMjUaaj0cHR6bOzhtDYykCbT0Z6XFnH3K5U248tOXBKaAymR2+cFBpLOrZYbIFfIzSW8pFBGqcFQfAZJyeUW35bZ5WMTYMIjU7QfRG85bPqtq6rC9UzQ8rJdvJ+las3c0Y53I58T/3O3HszXPlu2Pai0sZp3cRsnJZ8xrIJ16qMxsveBv/5Z3Dw8/Dkl+HZb6v8xut/W41cZ3PfX6kRaIDX/K1yrFklGFbj0ttvVNmhp34Kv/ykEh1PP6D+NPbCNe+Dq96rXHJ2YDilG3uhtsWexxTy09AJr/8oXPar8N3fU8f1r78fHv8svPr/Qdf6dJX69EgpVCvZo3a2kSVuGCelTeEmGsI2fVBM5/pN6o3MppwbpUml9Iyj0YnRaYcEmEQqwdjSGOB3odG9AOyQ6Wh0ztl3Pp2L2R7ppibkQUh0LtwUjFc1h9vuls7ByOII4Jyj0cnR6cyxxcJx0WpGY1Z0RcmO6VKLYKRxWhAEhzk1roTGrdWSzwjSOO00mgZ1bdB7QImJr/pL+NCT8Bs/gxv/hxp/TSXg0Lfgs7fCP16hxq/nx7ze8rWYQqM4GiumqVeVenzgJ7DpWogvwv1/BX9/GTz0CUjE1P0e+Ae498Pq9ivuLE1kXI2mwbYblAj+oafghv8GDd1q1PrHfw5/e0BlSU6dLv5YxTAap9epwOVbtr0QfuMBeMkfq3Kgk/fDPz8fvvv7sDDh9dbZjgiNgq0YYoCtAkwOobGnoce+x08LVEN6J8mUjq47IwaMzUeJJlIEAxr9rfY51IIOi17jS+Ok9BQhLURHbZmj5W4IVGYRTOFRTTswhEbdIUejruuML48C0N/kIwHGQ8HY3M8dHNt2SvQKBp0fnT6dduqU5mgs0jqdNSpdssBrrGNLkdFpcTQKguASJw2hsVocjdE5mDuvbnfu8nZbNhKaBr0XqzHr3/ipEh2vfh/UNMPUSbjnT+H/uwi+/utw/nGvtzaD8XtXRqfto/9yeM8P4M3/Du07YHEcvv8H8JFr4Ht/AD/6Y3W/l/wRPP837XvelgF4yf+E330GXv8J6LlYjfg/9DH4h8vhq++BC0+U//hjIjR6RigCN/w+/OaDsOdmFWP08CfVuj7wD5CIer2FtiFCo2ArZjOsnUJEVnGBkVtn60lp2nlzTldFME6JAUYRTH9rLWEbs4GcdnoZQkB3ffcKh1NJmCOYunP5fi46GsMBBwT1LObic8RSSwD/f3t3HuZkdfcN/HsnmWT2HTIzMMBYQUQBERQRW0qloPWluNS2XMiL1NYHOiJLq9X2UWu97Ih9tHWhpbVPra22UkutAnXhZbNWZBtcEBgR2ZmFZfZ9kvP+cZJ7MjBLMjknuTPz/VxXLiAT7hw4IZz55bfggvQuesJEg9mjUV9WYVcB44gMPdLco1FnRuNRs/9rEB9iBDmcKayMxiAnwDPQSESR4s9ovCBWAo3+sulkd78YHGBZOaOBG54AfrAf+PqzwKDxgLcV+Ohl4HdfBv5wHfDJPwGPxg9hg1HJ0mktDAMYNQso3CZfB0kDZcDZ35Pxiz8AvnSPnud2OGW/xwX/Bua+KkushQfYsxr47ZeAP80CDm6ULQBCwZYM0ZdZAMz+CzBvjXyPaa6WgetnrwA+/rvefvgRwkAjKaWlX6A5uMCrZ3CAr9TghJD9GXUFA/yBgKHBlDaGQEtwN4CSQEBggFJX6auZQRW50mldGY3+v3PRlogLshX1Y1EhyCEiYTEDxh0/kdfSliFAq6cVpxtPA1CcMY32qdMejYeGY2dlYDq40unghvrYDBsM+IKkoQR4Q5gAz2EwRBQJbR6veQ6LmYxGlk1bizMJuHwu8L2N8jb6m7JC4OhW4JV5wNOXyV59jZWRX5vXIwfbACyd1sUeJzNb794ty+pTcmWQ8SsP6H9uwwC+8BXg/74G/Nc7viEiduDzzcCfbwJ++0UZnAo22H1qv/yRGY3RV/Al4M4twKxfy56ZVUeA1XcAKycDe18PPYhsIQw0klLmZFiVGU+dlE7nJuWqu351x4xGr6Z/0Ed9pY35iicI6x4GoybQGDBEQlfZbRQyGnUHGr1tacpfL2GxQo9GTdmUFY0VEBBw2pzIjFcb3G2fOq30sqbmNg9OVvsDjepKp4FeTrVvrARa6uTPu5kAL4RgRiMRRcTxyka0eQVcDhtyUvX141bKzDpi2bTlDBoP3PIcsGSPzGZLzJLfT6x/EHhyFLB2WfvAjUioLZVZljYHkJoXueftj1zJsqz+B/uBax+M/NTg3LHALb+XAc+JC4C4RKDsYxmcevoy4L1n5VTprrQ2tme/DhgZkSVTD2x2YNwc4O5iYOpPAFcaULEX+Ntcmbla8kZMBhwZaCSltJQ3dhJoVJvR2N6jEdCf0ahyEAygKbgbQEm5eiQCjRHt0egLNGoqnTYzGlvTMbQ/BRobq2TpAHB+6bTmjMZS3/Add5LbnHCtSnuPRj2vlxOVjRACSHTakZ3s7Pk3hLCPvWrN4A/6Jw0E4rou5a5qrkKzR/aicSeqzSIlIgrknzg9LCsJNluEAwO9xfJG60vNlf35lu6VZdXuS+XgkJ3/C6y4AnjxFuDAev1lkP7AUdrgjlVE1HdlDJXDi5Z+Akz9byAxW34v9PZPgCcvAd68H6g8fP7vO/MZAAHEpwNJAyK8aOqWMwmYci+w5EP5AYYzGSj7CPjrt2Wbhk9e1du+SjEGGkmpXmW/9KSzQKPKYQ2+b4rNHo0ezaXTWXoyGnX1rlNeOq0jSNVU016q0sPwCRXi7HozGo/7mr97W9OUB6bDojvQ6A9QJWbJ/2wD6J6urrOEV3ePxiMBH2IYwXyyrjujMdiyad97S1Z8Fpz2IAKkRES95O/PWBArZdNAQOk0MxotLy5ellUveFf2XLvoBgAG8Nn/A176hpxW/d4zQMNZPc8fwaoespjETGDKPcDSPcDMp2WWYkst8P6v5YCRVbcBn29pz4gLHAQT6WxMCk5ChvwAY/FHwOQlMmu19APglduBZ8YDO/5XZqZaHAONpJSeHo3yZSo8bShvKAegMBjQUg80yHHyJxCbGY1agrsBzABMOMFdIzDQqGGd/mzG+HQgPlX99c9hDoOBnk+oP688AQBwikykJ8ZpeY5e8Wf66fo0rZsBImbmru4WAYonTgOA3fcepmvQ1DHfe0vQZfYh7GOvPsgIMruYZdNEFCmHY23itKcNOHNQ/jybfdRihmHInmuz/yLLIK/6viyDrDwEvP3fsqz6tUL106qr/INg2J+x34pLAMbPk9OMb1stezoKL7BvDfCnrwMrJgLbfgec2CUfz0xp60vKAr76MLDkY2DKj2QAsvIQsG4Z8MtLgS2PA3UV0V5llxhoJKX8wQClWUe+a9a01KCxTUbvlQ1r8PeDc6WhwUgGoCcYUN/chtN1LQD6a49Gm94gVVXXASodHGYpuJ6/8xO1sow3K2FgcBlqkWJmwuke6HN+gMr/OvcKr5Zp3zqDXnZDc0bjGf+gqSDfW/z7GMR7Rq9aM3AQDBFZzOdmRqOFqgS6U3lY9tyLSwRSB0V7NdQbmRcA1xUBP9gHzHwKcI8G2hqB3S/KMsiVXwS2PyfbxoTLXzqdwUBjv2cYwIXT5JTqhVuBCd8B4pKA0yXAG/fITEeA/RljSVI2MPXHskz+uuXy+6SG08CmR+WHF6u/CxzdZrk+jgw0klL+3mZqMxrlN7qljacAAJnxmXDZXWquHZBBZfcPbNDwj9SfzZieGIe0BLUZamagUUPwp8XTgrNNsswj7GCAzrLbCJeMxNn9U6f1ZDSeapSZu3nJCoceqaC9dLrrgHFg30QdQfXyesXZ0gEcvh6NXt3Z0sG2ZQhhH3v1nh5k4F9J/1cioiAcDujRGBP8/RmzLjQreyhGOZOA8bcDC/4NfOct4NJvAHan7L32rx8CT4wEXl0AHP5P73s5mudgBhopgHsU8H9+KYPd1/+iYxZj3rjorYt6x5kEXLVADgK6+ffAoAnyA6mPXwH+MF1OH9/1AtDSEO2VAgAcPT+EKHhaJsP6vikuazwNQPHQALPUIB+OUgPN0NOjUVfZNNBeOq2jR6M/+OKyu5DuSg/vYjYH4GnRE6SqjnCg0aYv0CiEQG2bLOcvyLBYFoP2QGPXpT+OgIFCHq8HcTa1AXud2XV2zT0aj54J8f0llB6NvSmdNjNTg+vRqKNcnYjIr7nNgxOVsiKmYECMBRpZ3th3GAYw5Cp5azgLfLRKBgVO7QM+/Ku8pQ0BxnwTGPvt0HpzsnSauhOfBky8E7jye8Dhd4GmKmDY5GivinrLHgeMuVXeTu4Gtv8e2PN3OX18zd1ybsE1S6K9SgYaSS0tk2F93+iWNcngi9qJ0+dnNLZpmAx3TGegUWNGY2DwJewSXn+fxj6R0eh76zTU/52fbToLL1ohhIGLsq0WaPT32hTyU3fVWRbd9PazB/T51JHR6A966Zh+7B8Go6MtgxAi9A8ybMH/W+xV6XSQgX+dWaRERH7HzjbAK4Akpx0DkhVVxOjmHwQzgP0Z+6TETOCqhcDEBcDxnUDxH4FPXpP/f/77f+Qt73JgzLeAUbPkdOuueFqBGtnbm8NgqFuGARR8MdqrIJXyxgE3rgCmPyLbMux+EbhsTrRXBYCBRlJMzzAYX6CxWZbw5iYpLCcN6AnnsOsb2HAk1IyjEPgDAZbvW+cPbmhYpxkwjsDEaQBwmlOnNfyd+4K7oi0ZF2SlK79+WAKnhwsPlHff6CZgbLfpCzQ2tjWiqrkKAJCroVxdZ0bj6boWNLZ6YBjA4IxQA409v34De2MGpala3gAOgyEiSzh0Wp7BhmUn6el7LIR836srB2pLgVrfj60Nsnl/YhaQkAkkZgBJA4DUwT1/UHfaNxmWE6f7NsMA8q+Qt+t/AZT8S2Y6frYBOFksb2/eJ7MgR90IjPo6kJrX8RrVx+XZ2u4CktV/WEpEMSAxE5h8N3D1IstME2egkZTSMgHZXzrdXAlA8TelnfRo1BEM0Fo63ZvSxiApLW3sQz0a/YFGaAg0ltb6A43pWl4vYQkoX4a3Tabuq9JcK1P9gW6HwQDqs3f9mXWJjkSkxKUovTYQmNGo/vVy9KzsO5aXlgCnI8jAbyil0/7WDMH+u/UH/ROzZC+ZLni8HlQ0yEl5DDQSkU7aJk43nAV2/xnY+bycBBqsuERZEj1gJDBwJDDgYiDvMiDF914oBEun+yNnIjD6G/JWVwHsWQ3s+QdwfDtwdKu8vXkfkD8RGPk14KKvyUC0eQbOZz9Pov7OIkFGgIFGUszs0ahhGIyWQGPAf852Q2ZM6shoDHlYQwi0BHd9lA5r0BVobGmQk7eAHjOoVGnvF6g+cHTgrAzUiLY05KbHK79+WM4NNKrkD1DFpwPxqec/tWGDzbDBK7zKMxoDX+c6sl1s/g8xNPZ/zc9MCGFBofdoDPrvvJvJ4YHONJ1Bm2iD3bBjQMKA4K5NRNQLh3yDYC5QFWg8scvXE2s14Gluv9+VJoOFKW4gOUd+2NJUJQOSDWeBxrMygNTaAJR+IG+BUvKAQZcDA0f5MsMNIPMLatZMsSV5oCytvmqhzFjc+xrwyT9l0PHY+/K2/kE5LCjFV4nB/oxEZCEMNJJSIWe/BMMMNMpyPGWBxtYmWeYCAOlDYbfJQKbqQKPHK3C8UmPptI7gro/a0mlNgUZ/VqorVQapIsDly+QThvpA48FK2WcnyZaNOLvFPpnWGWjspj+jn92wwyu8at9foL+E15/R6NUw0d7flmFoZgjfQIfwbzHkHo0BWeLd8f+dD0gc0KEsnohItUOnQpw4LQRwaj9w4G2gtkxm2zdWAo1V8twYmL2YM0YOWLjkJsAVREa8pw2oPCwHgFTsl89TsVf+WHsS2H8S2L9WPjZjKBBnsQ8cKfLSBgOTCuWt+jiwfx1Q8oYc6nHmM3kD2J+RiCyFgUZSSk+PRhu8AMpbfYFGVRNKq4/LH+OSgIQMOOx6SqfLaprQ6hGIsxvITQsh6yhIWoK7Pkon8frLOVRnXgZmUEUoXTzO4X/rVB/cPV57EgCQFT9Q+bXDFlC+rG0fu/lE3mFzoNXbqjyornPiNADYfa99rW0ZQsmWNoL/txhya4Yg2xiYWaScOE1Emh0+E0TptBBA6YfAvteBva8DZw50/Vi7E7jkZuCK7wKDJ4R29rA7gOwL5e3ime33N9fJ5z9ZLDMmK/YDV9wR/HWpf0gbDEz8L3lrqgEObgBK3pQ9PcfNjfbqiIhMDDSSUr2aUNoTmwNn7Da0CS9shg0DEhWV2QVORjUMs0ej6ozGI74D7uCMRPM5VNIS3PXR06NRV4Aqcp/kusyp0+ozGk81yCzb3GQLBmBsNgAG5NRpjQHjLuiasG5OP9YU9NI5dfpobwZN+f8tBvGeEXJrhiD/PXIQDBFFQmOLB6XVTQC6KZ3evw5468cy09DP7gQu+LIsY07ICLilA+5LZeN9lVzJwLDJ8kYUjPhUmUl7yU3RXgkR0XkYaCSltAwmsTlQ5gvsZCdkB/THC1Ng82S0BwPaFA9sOGb2UNMz2ENLcBdAQ2sDaltqAVi8dPqcfYyEON/r0TC88Hq9sClsvl3degoAMCxtkLJrKmVzAN5WjfvYdYDKzN5VPPhId9DLHoEejb0KNAZTOh1qa4YgezQy0EhEkeDPZkxLiENGkrPjFz1twMafAf95Sv7akQAMnwZcPAsYMaPTfsFERETUMwYaSSldU6fLHPK6agfBdOwlZjN0ZTT6e6jpCTTqymj0BwKS45KR7EwO/4K6ezRGMKPRGRDsbvV44FIUaPR4PWgWVYABjMyOXOA0JLoCjUH2aATUB9X9r3V3klvpdf10ZUs3tnhQUSsHEQwNpXS6N1Ongw3uBvnvsdyXuctAIxHp1OXE6dpyYPUdwOF/y19fVQh85SdygAsRERGFhYFGUkpPj0Y7ynw98XKTctVd95wMKn+PRtXBgF5lHIXAZvj7v1k8y8s/8CEKmXCqtfdoBFq8bXAhTsl1TzWeAgwvhLBhlNvCGY1AdDIadQXVfT0alb6/BDADjYqHwRzzDZlKiXcgLSGE16BZOu0FvN72/qmdPdT3/hJUcLe5Dmg4I3/eQ4YxMxqJKBL8E6cLAj+MObIVeOV2oK4McCYDs1YAl9wYlfURERH1RQw0klJaSqcNe3tGo8oeaueU+PkHNqgONB7rzbCGEJil01YfkOEfJKK8t58vg6qHUk2VzB6NAFo86l7rh6vkxGnRmoph2UFMr4wGHUN9WhqAelky3m2PRg0Z07Uttahvld+I6p46rXoYTGB/RiOUYQSBgUXhAdB1oDGk0ml/NmN8mrx1g4FGIooEf0ZjQbavMuPDVcA/F8r3vgEjgW+9CGQPj+IKiYiI+h4GGkkpfyDAq7LPoc2BMruG0mmzxE9OudUVDDiiOaNRd+m0uozG4AdQBK21SWYkAN1OK1bN6dATaPykQga/bd4MpMaryZJUTsc++ifAO1Nks/0u6Hit+1/naa40JDjUT4UHAkun1fZ/9b+3hFQ2DbTvISADxvauX2shBXergiubbvW04nTjaQCcOk1Eeh0yS6cTgcojwNql8v+vS78BzHxKDmEhIiIipRhoJKVCHhwQDJvDLJ1WFvRqawFqTsqfp/szGtWXTlc3tqKqoRWAvmEwWvpiAiitLwWgMBCgo+S2RmYAIi5R/QTIbrgCAjMtber+PJ+dlQG3JHuWsmsqp2MfAwf6dJOZpyN7V/nrvBMOXwah6mEwvR401SHQ2P0+hhTcrToif0zrPtBY0VgBAQGnzYnM+Mj9uyWi/ufQafk+WZCVCKz9DtBaDwydDNz8XLdtI4iIiKj3+D8sKWUODlAZhNAxDKbmBAABOOKBpAEA9GQ0+gMB2clOJLv0xPW1BHehMaNRaYDKF9hIH9JtgEq1OH+/SQDNCgONx3zB70yXnqEkSujYx+rg+myarRkUPnckSnh1DYM54us9NjQzxOEFIQQaQ5pqH+QgmNI6Gdx1J7lDK/kmIgpBbVMrTtfJgVnDy9YCBzcCdhcw82kGGYmIiDTi/7KklI7SxlYDOKW6dDqwP6PvG10d5Y1He5txFAJdGY3qA40aevud02czUmw2G4SQfx6VpdMVvkm8uZqmHyuho9dmkPtovtY1lE7HYqCx14OmjPZAeU/7GFLf3cDM1G4o7/9KRNSJw75sxhFJDUjY8N/yzqn3A9kXRnFVREREfV9MBBpXrFiBYcOGIT4+HhMnTsT27dujvSTqQkjZL0E6BQ+EYcABm7oyu04yb9qDAWqeAgCO+IY1DNUZaNQwgEcIgXJf0Et9RqPKAFVwGVRa+AKNrQqz66pb5UCUoel5yq6pnE1HoDG4fTSzdxU+t/LXeSd0TJ32egWOVTYC6EWg0WYD4Msk7CFoq6NHoxncZX9GikE8k8YO/8TpnzpeAJqqgJwxwKRF0V0UERFRP2D5QOOqVauwbNkyPPTQQyguLsbYsWMxY8YMVFRURHtp1AktwxogAzluewJshqKXbCeZNw6NGY26BsEAeoK7NS01aGyTQQx3oqLsOt29/SLOl9GosHS6UZwBAIzIikLgNFhR3Eedw2CUvc47YbZlUNijsby2CS1tXthtBvLS40O/QJD7GFqPxuAyUzlxmmIVz6Sx5fDpeky37cDVzf+WmdyzngXsbE9PRESkm+UDjU8++SS+973vYf78+Rg1ahRWrlyJxMRE/OEPf4j20qgTZo9Ghdl1Zd4WAECOXeFE2E4yb+waezRqLZ3WGHzJcGUg3tGLIEZntPT2i15Go2GWTrcquV5jazOErRYAMDonchO0QxbFfdTRAzZWS6eP+rKlB6UnwGHvxX/lQe5j0AN4WhuBel+wpYd9LK/Xn0VKpAPPpLGltLwMj8Q9L38x+W4gd2x0F0RERNRPWPpjvZaWFuzatQv333+/eZ/NZsO0adOwdevWTn9Pc3MzmpubzV/X1NRoXye18we9Dlcfxs2v36zkmtV1MgiRW10G/PpqJddsHyLSHtDxT4Z9esMB/HnrESVP8/lp37CGrBCHNYQgsG+dqr/zhlYZxFAaCPCX3G4uArb9Vs01zxyQP6ZHIzAnXy93bbwLNsT18NieCXgBByC8DlyUbeEAjD9A9fpdgDNFzTVr5XCQnvbR//7y2PbH8OwHzyp56uN1ctJ3blKukut1xmGXgcZTdc247lfvKLlmbZMMEA7N6uWHGP59/PNNcjhCF+zOJiAO+POup/Gvnc90fT0hgEE5gGED1n/XrMzuzPFa+XfOQCPFklDPpNE4j548tB/Nf/6W9ueJFXd7auE2qlCXPAzJU34U7eUQERH1G5YONJ4+fRoejwdud8eSNrfbjf3793f6e4qKivDwww9HYnnUiUHJg2DAQKu3FQcqDyi99qiGWsA3lVcNo8On2/6sw/KaZpTXNHf1m0KWEGfHCHeysuudKyUuBWmuNFQ3V6v/O88ape5iGcPkj7Wl7YElFeKSgOzh6q4XJBcGohmH4XWcgsK2nkgQQ3uXoRYpmcOA8o/by2RVSRsCJGZ1+5D8lHwUVxSjtL4UqFf31JnxmXBrHMDjTomH02FDS5sX+8tqlV77svz03v3GjGFyH8981u3DBqelAJkZOGsInDV6yMi0O+WPVT2/DzkMB0ZkjAhysUTRF+qZNBrn0daWJhR4D0f0OS3NANqEDfUzfonkOIVVMURERNQtQwiF3ekVO3nyJAYNGoT33nsPkyZNMu+/9957sWXLFmzbtu2839PZJ8j5+fmorq5GampqRNbd3x2tOYoTdSfUXVAACVVHMMY1QF2PRgBIG9whQNXm8aL4aBVa2lSGjYBh2YkYnKGvdBoATjWcwmdV3QcMQuWwOTB2wFg4/cGDcHnagOPbgTZ1QVwAQNaFUenRWFZbiTX71Q4BsBnA1y66ErkpGUqvq1RrI3B8h9phMIBs0p/UfaCxxdOCD099qLR0GgCGZwxHdkK20mue63hlgzkBVRVXnA3j8tN7F5hurAJO7u7xYV7hxUe1R9Doa2HRo+wRQBDf0A9OHoz81Gj0Vo1dNTU1SEtL43kmSkI9k0bjPNpQV42DxZu1XDtWZeYOxaDhl0V7GURERH1CsOdRS2c0Zmdnw263o7y8vMP95eXlyMnpvOTK5XLB5eq6DIz0G5I6BENSFffMGzSp58eEyWG34coCRVOtI2xA4gAMSBwQ7WV0z+4AhioqfbeAnJQMfO+KGdFeRuTFJQAFX4rKUzvtTlyRc0VUnjtcgzP0f+AQkoR04AtTe3yYDcBlutdCFANCPZNG4zyamJyG0V+aFdHnJCIiIjqXhevzAKfTifHjx2PDhg3mfV6vFxs2bOjwaTIRERERkS48kxIREREFx9IZjQCwbNkyzJs3DxMmTMCVV16JX/3qV6ivr8f8+fOjvTQiIiIi6id4JiUiIiLqmeUDjd/61rdw6tQpPPjggygrK8Nll12GN99887xm3EREREREuvBMSkRERNQzSw+DUYHN04mIiCjW8TwT27h/REREFOuCPc9YukcjERERERERERERxQYGGomIiIiIiIiIiChsDDQSERERERERERFR2BhoJCIiIiIiIiIiorAx0EhERERERERERERhY6CRiIiIiIiIiIiIwsZAIxEREREREREREYWNgUYiIiIiIiIiIiIKGwONREREREREREREFDYGGomIiIiIiIiIiChsjmgvQDchBACgpqYmyishIiIi6h3/OcZ/rqHYwvMoERERxbpgz6N9PtBYW1sLAMjPz4/ySoiIiIjCU1tbi7S0tGgvg0LE8ygRERH1FT2dRw3Rxz8a93q9OHnyJFJSUmAYhrbnqampQX5+Po4dO4bU1FRtz0Oh495YG/fHurg31sb9sS4deyOEQG1tLfLy8mCzsfNNrOF5lLg31sb9sS7ujbVxf6wrmufRPp/RaLPZMHjw4Ig9X2pqKv+BWRT3xtq4P9bFvbE27o91qd4bZjLGLp5HyY97Y23cH+vi3lgb98e6onEe5UfiREREREREREREFDYGGomIiIiIiIiIiChsDDQq4nK58NBDD8HlckV7KXQO7o21cX+si3tjbdwf6+LeULTwtWdd3Btr4/5YF/fG2rg/1hXNvenzw2CIiIiIiIiIiIhIP2Y0EhERERERERERUdgYaCQiIiIiIiIiIqKwMdBIREREREREREREYWOgkYiIiIiIiIiIiMLGQKMCK1aswLBhwxAfH4+JEydi+/bt0V5Sv1NUVIQrrrgCKSkpGDhwIG688UaUlJR0eExTUxMKCwuRlZWF5ORk3HLLLSgvL4/Sivuvxx57DIZhYMmSJeZ93JvoOnHiBG677TZkZWUhISEBo0ePxs6dO82vCyHw4IMPIjc3FwkJCZg2bRoOHDgQxRX3Hx6PBw888AAKCgqQkJCAL3zhC3jkkUcQOMeN+xMZ77zzDmbOnIm8vDwYhoF//vOfHb4ezD6cPXsWc+bMQWpqKtLT03HHHXegrq4ugn8K6st4HrUGnkljB8+k1sMzqTXxPGotsXAmZaAxTKtWrcKyZcvw0EMPobi4GGPHjsWMGTNQUVER7aX1K1u2bEFhYSHef/99rF+/Hq2trZg+fTrq6+vNxyxduhRr1qzBK6+8gi1btuDkyZO4+eabo7jq/mfHjh347W9/izFjxnS4n3sTPZWVlZg8eTLi4uLwxhtvYO/evXjiiSeQkZFhPubxxx/H008/jZUrV2Lbtm1ISkrCjBkz0NTUFMWV9w/Lly/Hb37zGzz77LPYt28fli9fjscffxzPPPOM+RjuT2TU19dj7NixWLFiRadfD2Yf5syZg08++QTr16/H2rVr8c477+DOO++M1B+B+jCeR62DZ9LYwDOp9fBMal08j1pLTJxJBYXlyiuvFIWFheavPR6PyMvLE0VFRVFcFVVUVAgAYsuWLUIIIaqqqkRcXJx45ZVXzMfs27dPABBbt26N1jL7ldraWjF8+HCxfv16MWXKFLF48WIhBPcm2n70ox+Ja665psuve71ekZOTI37xi1+Y91VVVQmXyyX++te/RmKJ/doNN9wgvvOd73S47+abbxZz5swRQnB/ogWAePXVV81fB7MPe/fuFQDEjh07zMe88cYbwjAMceLEiYitnfomnketi2dS6+GZ1Jp4JrUunkety6pnUmY0hqGlpQW7du3CtGnTzPtsNhumTZuGrVu3RnFlVF1dDQDIzMwEAOzatQutra0d9mrkyJEYMmQI9ypCCgsLccMNN3TYA4B7E22vv/46JkyYgFtvvRUDBw7EuHHj8Nxzz5lfP3ToEMrKyjrsT1paGiZOnMj9iYCrr74aGzZswKeffgoA+PDDD/Huu+/i+uuvB8D9sYpg9mHr1q1IT0/HhAkTzMdMmzYNNpsN27Zti/iaqe/gedTaeCa1Hp5JrYlnUuvieTR2WOVM6lBylX7q9OnT8Hg8cLvdHe53u93Yv39/lFZFXq8XS5YsweTJk3HppZcCAMrKyuB0OpGent7hsW63G2VlZVFYZf/y8ssvo7i4GDt27Djva9yb6Pr888/xm9/8BsuWLcOPf/xj7NixA3fffTecTifmzZtn7kFn73PcH/3uu+8+1NTUYOTIkbDb7fB4PHj00UcxZ84cAOD+WEQw+1BWVoaBAwd2+LrD4UBmZib3isLC86h18UxqPTyTWhfPpNbF82jssMqZlIFG6nMKCwuxZ88evPvuu9FeCgE4duwYFi9ejPXr1yM+Pj7ay6FzeL1eTJgwAT//+c8BAOPGjcOePXuwcuVKzJs3L8qro7/97W946aWX8Je//AWXXHIJPvjgAyxZsgR5eXncHyIii+OZ1Fp4JrU2nkmti+dRChVLp8OQnZ0Nu91+3iSy8vJy5OTkRGlV/dtdd92FtWvXYtOmTRg8eLB5f05ODlpaWlBVVdXh8dwr/Xbt2oWKigpcfvnlcDgccDgc2LJlC55++mk4HA643W7uTRTl5uZi1KhRHe67+OKLcfToUQAw94Dvc9Fxzz334L777sO3v/1tjB49GnPnzsXSpUtRVFQEgPtjFcHsQ05OznmDOdra2nD27FnuFYWF51Fr4pnUengmtTaeSa2L59HYYZUzKQONYXA6nRg/fjw2bNhg3uf1erFhwwZMmjQpiivrf4QQuOuuu/Dqq69i48aNKCgo6PD18ePHIy4ursNelZSU4OjRo9wrza699lp8/PHH+OCDD8zbhAkTMGfOHPPn3JvomTx5MkpKSjrc9+mnn2Lo0KEAgIKCAuTk5HTYn5qaGmzbto37EwENDQ2w2Tr+V2232+H1egFwf6wimH2YNGkSqqqqsGvXLvMxGzduhNfrxcSJEyO+Zuo7eB61Fp5JrYtnUmvjmdS6eB6NHZY5kyoZKdOPvfzyy8Llcok//vGPYu/eveLOO+8U6enpoqysLNpL61cWLlwo0tLSxObNm0Vpaal5a2hoMB+zYMECMWTIELFx40axc+dOMWnSJDFp0qQorrr/CpzwJwT3Jpq2b98uHA6HePTRR8WBAwfESy+9JBITE8WLL75oPuaxxx4T6enp4rXXXhMfffSRmDVrligoKBCNjY1RXHn/MG/ePDFo0CCxdu1acejQIfGPf/xDZGdni3vvvdd8DPcnMmpra8Xu3bvF7t27BQDx5JNPit27d4sjR44IIYLbh+uuu06MGzdObNu2Tbz77rti+PDhYvbs2dH6I1EfwvOodfBMGlt4JrUOnkmti+dRa4mFMykDjQo888wzYsiQIcLpdIorr7xSvP/++9FeUr8DoNPb888/bz6msbFRfP/73xcZGRkiMTFR3HTTTaK0tDR6i+7Hzj3UcW+ia82aNeLSSy8VLpdLjBw5Uvzud7/r8HWv1yseeOAB4Xa7hcvlEtdee60oKSmJ0mr7l5qaGrF48WIxZMgQER8fLy644ALxk5/8RDQ3N5uP4f5ExqZNmzr9f2bevHlCiOD24cyZM2L27NkiOTlZpKamivnz54va2too/GmoL+J51Bp4Jo0tPJNaC8+k1sTzqLXEwpnUEEIINbmRRERERERERERE1F+xRyMRERERERERERGFjYFGIiIiIiIiIiIiChsDjURERERERERERBQ2BhqJiIiIiIiIiIgobAw0EhERERERERERUdgYaCQiIiIiIiIiIqKwMdBIREREREREREREYWOgkYiIiIiIiIiIiMLGQCMR9Xm33347brzxxmgvg4iIiIj6KZ5Hiai/cER7AURE4TAMo9uvP/TQQ3jqqacghIjQioKzefNmTJ06FZWVlUhPT4/2coiIiIiol3geJSJqx0AjEcW00tJS8+erVq3Cgw8+iJKSEvO+5ORkJCcnR2NpRERERNQP8DxKRNSOpdNEFNNycnLMW1paGgzD6HBfcnLyeaUqX/7yl7Fo0SIsWbIEGRkZcLvdeO6551BfX4/58+cjJSUFF154Id54440Oz7Vnzx5cf/31SE5Ohtvtxty5c3H69Oku13bkyBHMnDkTGRkZSEpKwiWXXIJ//etfOHz4MKZOnQoAyMjIgGEYuP322wEAXq8XRUVFKCgoQEJCAsaOHYu///3v5jU3b94MwzCwbt06jBkzBvHx8bjqqquwZ88edX+pRERERBQ0nkd5HiWidgw0ElG/9MILLyA7Oxvbt2/HokWLsHDhQtx66624+uqrUVxcjOnTp2Pu3LloaGgAAFRVVeErX/kKxo0bh507d+LNN99EeXk5vvnNb3b5HIWFhWhubsY777yDjz/+GMuXL0dycjLy8/OxevVqAEBJSQlKS0vx1FNPAQCKiorwpz/9CStXrsQnn3yCpUuX4rbbbsOWLVs6XPuee+7BE088gR07dmDAgAGYOXMmWltbNf1tEREREZFqPI8SUZ8kiIj6iOeff16kpaWdd/+8efPErFmzzF9PmTJFXHPNNeav29raRFJSkpg7d655X2lpqQAgtm7dKoQQ4pFHHhHTp0/vcN1jx44JAKKkpKTT9YwePVr89Kc/7fRrmzZtEgBEZWWleV9TU5NITEwU7733XofH3nHHHWL27Nkdft/LL79sfv3MmTMiISFBrFq1qtPnIiIiIqLI4HmU51Gi/o49GomoXxozZoz5c7vdjqysLIwePdq8z+12AwAqKioAAB9++CE2bdrUaX+dgwcPYsSIEefdf/fdd2PhwoV4++23MW3aNNxyyy0dnvdcn332GRoaGvDVr361w/0tLS0YN25ch/smTZpk/jwzMxMXXXQR9u3b190fmYiIiIgshOdRIuqLGGgkon4pLi6uw68Nw+hwn396oNfrBQDU1dVh5syZWL58+XnXys3N7fQ5vvvd72LGjBlYt24d3n77bRQVFeGJJ57AokWLOn18XV0dAGDdunUYNGhQh6+5XK4g/2REREREFAt4HiWivoiBRiKiIFx++eVYvXo1hg0bBocj+LfO/Px8LFiwAAsWLMD999+P5557DosWLYLT6QQAeDwe87GjRo2Cy+XC0aNHMWXKlG6v+/7772PIkCEAgMrKSnz66ae4+OKLe/EnIyIiIqJYwPMoEcUCDoMhIgpCYWEhzp49i9mzZ2PHjh04ePAg3nrrLcyfP7/D4SzQkiVL8NZbb+HQoUMoLi7Gpk2bzMPX0KFDYRgG1q5di1OnTqGurg4pKSn44Q9/iKVLl+KFF17AwYMHUVxcjGeeeQYvvPBCh2v/7Gc/w4YNG7Bnzx7cfvvtyM7O7jDJkIiIiIj6Fp5HiSgWMNBIRBSEvLw8/Oc//4HH48H06dMxevRoLFmyBOnp6bDZOn8r9Xg8KCwsxMUXX4zrrrsOI0aMwK9//WsAwKBBg/Dwww/jvvvug9vtxl133QUAeOSRR/DAAw+gqKjI/H3r1q1DQUFBh2s/9thjWLx4McaPH4+ysjKsWbPG/FSaiIiIiPoenkeJKBYYQggR7UUQEVFwNm/ejKlTp6KyshLp6enRXg4RERER9TM8jxJRd5jRSERERERERERERGFjoJGIiIiIiIiIiIjCxtJpIiIiIiIiIiIiChszGomIiIiIiIiIiChsDDQSERERERERERFR2BhoJCIiIiIiIiIiorAx0EhERERERERERERhY6CRiIiIiIiIiIiIwsZAIxEREREREREREYWNgUYiIiIiIiIiIiIKGwONREREREREREREFLb/DygUWNbzCLOLAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib\n", + "%matplotlib inline\n", + "from matplotlib import pyplot as plt\n", + "\n", + "# Create a subplot for each monitor\n", + "fig = plt.figure(figsize=(16, 5))\n", + "ax0 = fig.add_subplot(121)\n", + "ax1 = fig.add_subplot(122)\n", + "\n", + "# Plot the recorded data\n", + "monitor_lif1.plot(ax0, lif1.v)\n", + "monitor_lif2.plot(ax1, lif2.v)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "cf5fcea8", + "metadata": {}, + "source": [ + "As a last step we must stop the runtime by calling the `stop` function. `Stop` will terminate the `Runtime` and all states will be lost." + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "0ddcd735", + "metadata": {}, + "outputs": [], + "source": [ + "lif2.stop()" + ] + }, + { + "cell_type": "markdown", + "id": "26af5f1d", + "metadata": {}, + "source": [ + "### Summary\n", + "\n", + "- There are many tools available in the Process Library to construct basic networks\n", + "- The fundamental building block in Lava is the `Process`\n", + "- Each `Process` consists of `Vars` and `Ports`\n", + "- A `Process` defines a common interface across hardware backends, but not the behavior\n", + "- The `ProcessModel` defines the behavior of a `Process` for a specific hardware backend\n", + "- `Vars` store internal states, `Ports` are used to implement communication channels between processes\n", + "- The `RunConfig` defines on which hardware backend the network runs " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 6a757baca98b70697488b51a8341275d993954d6 Mon Sep 17 00:00:00 2001 From: Monkin Date: Sat, 24 Aug 2024 13:46:37 +0100 Subject: [PATCH 4/4] Linting code --- src/lava/proc/io/utils.py | 18 +- src/lava/proc/lif/models.py | 45 +- src/lava/proc/lif/process.py | 120 ++-- tests/lava/proc/lif/test_models.py | 113 ++-- .../custom/tutorial00_tour_through_lava.ipynb | 567 ------------------ 5 files changed, 175 insertions(+), 688 deletions(-) delete mode 100644 tutorials/custom/tutorial00_tour_through_lava.ipynb diff --git a/src/lava/proc/io/utils.py b/src/lava/proc/io/utils.py index 23fc00cab..c2d55ad02 100644 --- a/src/lava/proc/io/utils.py +++ b/src/lava/proc/io/utils.py @@ -280,8 +280,9 @@ def validate_channel_config(channel_config: ChannelConfig) -> None: "to be of type ReceiveNotEmpty. Got " ".receive_not_empty = " f"{channel_config.receive_not_empty}.") - -def convert_to_numpy_array(val, shape, name = "value", verbose=False): + + +def convert_to_numpy_array(val, shape, name="value", verbose=False): """ Converts a given value to a numpy array if it is not already @@ -306,14 +307,17 @@ def convert_to_numpy_array(val, shape, name = "value", verbose=False): if np.isscalar(val): if verbose: print(f"{name} is scalar, converting to numpy array") - # If val is a scalar, create an array filled with that value with shape (n_neurons) + # If val is a scalar, create an array filled with that value + # with shape (n_neurons) val = np.full(shape, val) elif not isinstance(val, np.ndarray): - # If val is not a scalar and not a numpy array, try to convert it to a numpy array + # If val is not a scalar and not a numpy array, try to convert + # it to a numpy array try: val = np.array(val) except Exception as e: - raise ValueError(f"Failed to convert {name} to a numpy array. Please ensure it is either a scalar, list, or numpy array.") from e - - return val + raise ValueError( + f"""Failed to convert {name} to a numpy array. Please ensure it + is either a scalar, list, or numpy array.""") from e + return val diff --git a/src/lava/proc/lif/models.py b/src/lava/proc/lif/models.py index f5aa66590..446654aa2 100644 --- a/src/lava/proc/lif/models.py +++ b/src/lava/proc/lif/models.py @@ -575,7 +575,8 @@ class AbstractPyEILifModelFloat(PyLoihiProcessModel): s_out = None # This will be an OutPort of different LavaPyTypes u_exc: np.ndarray = LavaPyType(np.ndarray, float) u_inh: np.ndarray = LavaPyType(np.ndarray, float) - u: np.ndarray = LavaPyType(np.ndarray, float) # Net current (u_exc + u_inh) + # Net current (u_exc + u_inh) + u: np.ndarray = LavaPyType(np.ndarray, float) v: np.ndarray = LavaPyType(np.ndarray, float) bias_mant: np.ndarray = LavaPyType(np.ndarray, float) bias_exp: np.ndarray = LavaPyType(np.ndarray, float) @@ -594,7 +595,7 @@ def spiking_activation(self): def subthr_dynamics(self, activation_in: np.ndarray): """Common sub-threshold dynamics of current and voltage variables for - all Configurable Time Constants LIF models. + all Configurable Time Constants LIF models. This is where the 'leaky integration' happens. """ # Get the excitatory input from a_in -- Positive values increase u_exc @@ -610,7 +611,8 @@ def subthr_dynamics(self, activation_in: np.ndarray): self.u_inh[:] += inh_a_in # Update the voltage - # Calculate the net current by adding the excitatory and inhibitory currents + # Calculate the net current by adding the + # excitatory and inhibitory currents self.u = self.u_exc + self.u_inh # u_inh is negative self.v[:] = self.v * (1 - self.dv) + self.u + self.bias_mant @@ -632,27 +634,29 @@ def run_spk(self): self.reset_voltage(spike_vector=self.s_out_buff) self.s_out.send(self.s_out_buff) + @implements(proc=EILIF, protocol=LoihiProtocol) @requires(CPU) @tag("floating_pt") class PyEILifFloat(AbstractPyEILifModelFloat): """Implementation of Excitatory/Inhibitory Leaky-Integrate-and-Fire - neural process in floating point precision. This short and simple + neural process in floating point precision. This short and simple ProcessModel can be used for quick algorithmic prototyping, without engaging with the nuances of a fixed point implementation. """ s_out: PyOutPort = LavaPyType(PyOutPort.VEC_DENSE, float) vth: float = LavaPyType(float, float) - + def spiking_activation(self): """Spiking activation function for LIF.""" return self.v > self.vth - + + @implements(proc=EILIFRefractory, protocol=LoihiProtocol) @requires(CPU) @tag("floating_pt") class PyEILifRefractoryFloat(AbstractPyEILifModelFloat): - """Implementation of Excitatory/Inhibitory Refractory + """Implementation of Excitatory/Inhibitory Refractory Leaky-Integrate-and-Fire neural process in floating point precision. This short and simple ProcessModel can be used for quick algorithmic prototyping, without engaging with the nuances of a fixed @@ -661,7 +665,7 @@ class PyEILifRefractoryFloat(AbstractPyEILifModelFloat): s_out: PyOutPort = LavaPyType(PyOutPort.VEC_DENSE, float) vth: float = LavaPyType(float, float) refractory_period_end: np.ndarray = LavaPyType(np.ndarray, int) - + def __init__(self, proc_params): super(PyEILifRefractoryFloat, self).__init__(proc_params) self.refractory_period = proc_params["refractory_period"] @@ -669,7 +673,7 @@ def __init__(self, proc_params): def spiking_activation(self): """Spiking activation function for LIF.""" return self.v > self.vth - + def subthr_dynamics(self, activation_in: np.ndarray): """Sub-threshold dynamics of current and voltage variables for ConfigTimeConstantsLIF @@ -692,18 +696,18 @@ def subthr_dynamics(self, activation_in: np.ndarray): # Check which neurons are not in refractory period non_refractory = self.refractory_period_end < self.time_step - """ non_refrac_idx = np.where(non_refractory == False)[0] - if len(non_refrac_idx) > 0: - print(f"Time step: {self.time_step} has neurons in refractory period -> {non_refrac_idx}") - print(f"{self.u[non_refrac_idx[0]]} {self.v[non_refrac_idx[0]]}") """ # Update the voltage of the non-refractory neurons - # Calculate the net current by adding the excitatory and inhibitory currents + # Calculate the net current by adding the excitatory + # and inhibitory currents self.u = self.u_exc + self.u_inh # u_inh is negative - self.v[non_refractory] = self.v[non_refractory] * (1 - self.dv[non_refractory]) + ( - self.u[non_refractory] + self.bias_mant[non_refractory]) - + self.v[non_refractory] = ( + self.v[non_refractory] * (1 - self.dv[non_refractory]) + ( + self.u[non_refractory] + self.bias_mant[non_refractory] + ) + ) + def process_spikes(self, spike_vector: np.ndarray): """ Set the refractory_period_end for the neurons that spiked and @@ -712,7 +716,7 @@ def process_spikes(self, spike_vector: np.ndarray): self.refractory_period_end[spike_vector] = (self.time_step + self.refractory_period) super().reset_voltage(spike_vector) - + def run_spk(self): """The run function that performs the actual computation during execution orchestrated by a PyLoihiProcessModel using the @@ -722,8 +726,7 @@ def run_spk(self): self.subthr_dynamics(activation_in=a_in_data) spike_vector = self.spiking_activation() - """ if np.max(spike_vector) > 0: - print(f"Time step: {self.time_step} has a neuron spike.") """ - self.process_spikes(spike_vector=spike_vector) # Reset voltage of spiked neurons to 0 and update refractory period + # Reset voltage of spiked neurons to 0 and update refractory period + self.process_spikes(spike_vector=spike_vector) self.s_out.send(spike_vector) diff --git a/src/lava/proc/lif/process.py b/src/lava/proc/lif/process.py index 24507851d..43a40e084 100644 --- a/src/lava/proc/lif/process.py +++ b/src/lava/proc/lif/process.py @@ -420,7 +420,7 @@ def __init__( class AbstractEILIF(AbstractProcess): - """Abstract class for variables common to all neurons with Excitatory/Inhibitory + """Abstract class for variables common to all neurons with Excitatory/Inhibitory leaky integrator dynamics and configurable time constants""" def __init__( @@ -458,26 +458,37 @@ def __init__( self.s_out = OutPort(shape=shape) self.u_exc = Var(shape=shape, init=u_exc) self.u_inh = Var(shape=shape, init=u_inh) - self.u = Var(shape=shape, init=u_exc + u_inh) # neuron total current (u_inh is negative) + # neuron total current (u_inh is negative) + self.u = Var(shape=shape, init=u_exc + u_inh) self.v = Var(shape=shape, init=v) - self.du_exc = Var(shape=shape, init=du_exc) # Shape of du_exc must match the shape of the neurons - self.du_inh = Var(shape=shape, init=du_inh) # Shape of du_inh must match the shape of the neurons - self.dv = Var(shape=shape, init=dv) # Shape of dv must match the shape of the neurons + # Shape of du_exc must match the shape of the neurons + self.du_exc = Var(shape=shape, init=du_exc) + # Shape of du_inh must match the shape of the neurons + self.du_inh = Var(shape=shape, init=du_inh) + # Shape of dv must match the shape of the neurons + self.dv = Var(shape=shape, init=dv) self.bias_exp = Var(shape=shape, init=bias_exp) self.bias_mant = Var(shape=shape, init=bias_mant) class EILIF(AbstractEILIF): - """Exctitatory/Inhibitory Leaky-Integrate-and-Fire (LIF) neural Process. - This neuron model receives 2 input currents, one excitatory and one inhibitory. - The neuron's total current is the sum of the excitatory and inhibitory currents. - Each current has its own decay time-constant and it is independent on a neuron-to-neuron basis. + """Excitatory/Inhibitory Leaky-Integrate-and-Fire (LIF) neural Process. + This neuron model receives 2 input currents, + one excitatory and one inhibitory. + The neuron's total current is the sum of the excitatory + and inhibitory currents. + Each current has its own decay time-constant and it is independent + on a neuron-to-neuron basis. LIF dynamics abstracts to: - u_exc[t] = u_exc[t-1] * (1-du_exc) + a_in (excitatory spike) # neuron excitatory current - u_inh[t] = u_inh[t-1] * (1-du_inh) + a_in (inhibitory spike) # neuron inhibitory current + # neuron excitatory current + u_exc[t] = u_exc[t-1] * (1-du_exc) + a_in (excitatory spike) + # neuron inhibitory current + u_inh[t] = u_inh[t-1] * (1-du_inh) + a_in (inhibitory spike) + + # neuron total current (u_inh[t] is negative) + u[t] = u_exc[t] + u_inh[t] - u[t] = u_exc[t] + u_inh[t] # neuron total current (u_inh[t] is negative) v[t] = v[t-1] * (1-dv) + u[t] + bias # neuron voltage s_out = v[t] > vth # spike if threshold is exceeded v[t] = 0 # reset at spike @@ -493,17 +504,17 @@ class EILIF(AbstractEILIF): v : float, list, numpy.ndarray, optional Initial value of the neurons' voltage (membrane potential). du_exc : float, list, numpy.ndarray, optional - Inverse of decay time-constant for excitatory current decay. This can be a scalar, list, - or numpy array. Anyhow, it will be converted to a np array representing the - time-constants of each neuron. + Inverse of decay time-constant for excitatory current decay. + This can be a scalar, list, or numpy array. Anyhow, it will be converted + to a np array representing the time-constants of each neuron. du_inh : float, list, numpy.ndarray, optional - Inverse of decay time-constant for inhibitory current decay. This can be a scalar, list, - or numpy array. Anyhow, it will be converted to a np array representing the - time-constants of each neuron. + Inverse of decay time-constant for inhibitory current decay. + This can be a scalar, list, or numpy array. Anyhow, it will be converted + to a np array representing the time-constants of each neuron. dv : float, list, numpy.ndarray, optional - Inverse of decay time-constant for voltage decay. This can be a scalar, list, - or numpy array. Anyhow, it will be converted to a np array representing the - time-constants of each neuron. + Inverse of decay time-constant for voltage decay. This can be a scalar, + list, or numpy array. Anyhow, it will be converted to a np array + representing the time-constants of each neuron. bias_mant : float, list, numpy.ndarray, optional Mantissa part of neuron bias. bias_exp : float, list, numpy.ndarray, optional @@ -517,9 +528,11 @@ class EILIF(AbstractEILIF): Example ------- >>> ei_lif = EILIF(shape=(200, 15), du_exc=0.1, du_inh=0.2, dv=5) - This will create 200x15 EILIF neurons that all have the same excitatory and - inhibitory current decays (0.1 and 0.2, respectively) and voltage decay of 5. + This will create 200x15 EILIF neurons that all have the same excitatory + and inhibitory current decays (0.1 and 0.2, respectively) + and voltage decay of 5. """ + def __init__( self, *, @@ -538,12 +551,14 @@ def __init__( verbose: ty.Optional[bool] = False, **kwargs, ) -> None: - # Try to convert du_exc, du_inh and dv to numpy arrays if they are not already - # If unsuccessful, it will raise a ValueError - du_exc = convert_to_numpy_array(du_exc, shape, "du_exc", verbose=verbose) - du_inh = convert_to_numpy_array(du_inh, shape, "du_inh", verbose=verbose) + # Try to convert du_exc, du_inh and dv to numpy arrays, if they are not + # already. If unsuccessful, it will raise a ValueError + du_exc = convert_to_numpy_array( + du_exc, shape, "du_exc", verbose=verbose) + du_inh = convert_to_numpy_array( + du_inh, shape, "du_inh", verbose=verbose) dv = convert_to_numpy_array(dv, shape, "dv", verbose=verbose) - + super().__init__( shape=shape, u_exc=u_exc, @@ -563,17 +578,26 @@ def __init__( # Add the vth variable to the process self.vth = Var(shape=(1,), init=vth) + class EILIFRefractory(EILIF): - """Excitatory/Inhibitory Leaky-Integrate-and-Fire (LIF) neural Process with refractory period. - This neuron model receives 2 input currents, one excitatory and one inhibitory. - The neuron's total current is the sum of the excitatory and inhibitory currents. - Each current has its own decay time-constant and it is independent on a neuron-to-neuron basis. + """Excitatory/Inhibitory Leaky-Integrate-and-Fire (LIF) neural Process + with refractory period. + This neuron model receives 2 input currents, + one excitatory and one inhibitory. + The neuron's total current is the sum of the excitatory + and inhibitory currents. + Each current has its own decay time-constant and it is independent + on a neuron-to-neuron basis. LIF dynamics abstracts to: - u_exc[t] = u_exc[t-1] * (1-du_exc) + a_in (excitatory spike) # neuron excitatory current - u_inh[t] = u_inh[t-1] * (1-du_inh) + a_in (inhibitory spike) # neuron inhibitory current + # neuron excitatory current + u_exc[t] = u_exc[t-1] * (1-du_exc) + a_in (excitatory spike) + # neuron inhibitory current + u_inh[t] = u_inh[t-1] * (1-du_inh) + a_in (inhibitory spike) + + # neuron total current (u_inh[t] is negative) + u[t] = u_exc[t] + u_inh[t] - u[t] = u_exc[t] + u_inh[t] # neuron total current (u_inh[t] is negative) v[t] = v[t-1] * (1-dv) + u[t] + bias # neuron voltage s_out = v[t] > vth # spike if threshold is exceeded v[t] = 0 # reset at spike @@ -589,17 +613,17 @@ class EILIFRefractory(EILIF): v : float, list, numpy.ndarray, optional Initial value of the neurons' voltage (membrane potential). du_exc : float, list, numpy.ndarray, optional - Inverse of decay time-constant for excitatory current decay. This can be a scalar, list, - or numpy array. Anyhow, it will be converted to a np array representing the - time-constants of each neuron. + Inverse of decay time-constant for excitatory current decay. + This can be a scalar, list, or numpy array. Anyhow, it will be converted + to a np array representing the time-constants of each neuron. du_inh : float, list, numpy.ndarray, optional - Inverse of decay time-constant for inhibitory current decay. This can be a scalar, list, - or numpy array. Anyhow, it will be converted to a np array representing the - time-constants of each neuron. + Inverse of decay time-constant for inhibitory current decay. + This can be a scalar, list, or numpy array. Anyhow, it will be converted + to a np array representing the time-constants of each neuron. dv : float, list, numpy.ndarray, optional - Inverse of decay time-constant for voltage decay. This can be a scalar, list, - or numpy array. Anyhow, it will be converted to a np array representing the - time-constants of each neuron. + Inverse of decay time-constant for voltage decay. This can be a scalar, + list, or numpy array. Anyhow, it will be converted to a np array + representing the time-constants of each neuron. bias_mant : float, list, numpy.ndarray, optional Mantissa part of neuron bias. bias_exp : float, list, numpy.ndarray, optional @@ -614,11 +638,13 @@ class EILIFRefractory(EILIF): Example ------- - >>> refrac_ei_lif = EILIFRefractory(shape=(200, 15), du_exc=0.1, du_inh=0.2, dv=5) - This will create 200x15 EILIF neurons that all have the same excitatory and + >>> refrac_ei_lif = EILIFRefractory(shape=(200, 15), du_exc=0.1, + du_inh=0.2, dv=5) + This will create 200x15 EILIF neurons that all have the same excitatory and inhibitory current decays (0.1 and 0.2, respectively), voltage decay of 5. and refractory period of 1 timestep. """ + def __init__( self, *, @@ -661,7 +687,7 @@ def __init__( # Check if the refractory period is a float if isinstance(refractory_period, float): if verbose: - print("Refractory period must be an integer. Converting to integer...") + print("Converting the Refractory period to integer...") refractory_period = int(refractory_period) self.proc_params["refractory_period"] = refractory_period diff --git a/tests/lava/proc/lif/test_models.py b/tests/lava/proc/lif/test_models.py index c83000db8..3597f2fbb 100644 --- a/tests/lava/proc/lif/test_models.py +++ b/tests/lava/proc/lif/test_models.py @@ -17,13 +17,16 @@ from lava.magma.core.run_configs import Loihi2SimCfg, RunConfig from lava.magma.core.run_conditions import RunSteps from lava.magma.core.sync.protocols.loihi_protocol import LoihiProtocol -from lava.proc.lif.process import LIF, LIFReset, TernaryLIF, LIFRefractory, EILIF, EILIFRefractory +from lava.proc.lif.process import ( + LIF, LIFReset, TernaryLIF, LIFRefractory, EILIF, EILIFRefractory +) from lava.proc import io class LifRunConfig(RunConfig): """Run configuration selects appropriate LIF ProcessModel based on tag: floating point precision or Loihi bit-accurate fixed point precision""" + def __init__(self, custom_sync_domains=None, select_tag='fixed_pt'): super().__init__(custom_sync_domains=custom_sync_domains) self.select_tag = select_tag @@ -46,6 +49,7 @@ class VecSendProcess(AbstractProcess): send_at_times: np.ndarray, vector bools. Send the `vec_to_send` at times when there is a True """ + def __init__(self, **kwargs): super().__init__() shape = kwargs.pop("shape", (1,)) @@ -67,6 +71,7 @@ class VecRecvProcess(AbstractProcess): ---------- shape: tuple, shape of the process """ + def __init__(self, **kwargs): super().__init__() shape = kwargs.get("shape", (1,)) @@ -143,6 +148,7 @@ def run_spk(self): class TestLIFProcessModelsFloat(unittest.TestCase): """Tests for floating point ProcessModels of LIF""" + def test_float_pm_no_decay(self): """ Tests floating point LIF ProcessModel with no current or voltage @@ -251,13 +257,15 @@ def test_float_pm_impulse_dv(self): lif.stop() # Gold standard for testing: voltage decay of 0.5 should integrate # the voltage from 128. to 255., with steps of 64., 32., 16., etc. - expected_v_timeseries = [128., 192., 224., 240., 248., 252., 254., 255.] + expected_v_timeseries = [128., 192., + 224., 240., 248., 252., 254., 255.] self.assertListEqual(expected_v_timeseries, lif_v) class TestLIFProcessModelsFixed(unittest.TestCase): """Tests for fixed point, ProcessModels of LIF, which are bit-accurate with Loihi hardware""" + def test_bitacc_pm_no_decay(self): """ Tests fixed point LIF ProcessModel (bit-accurate @@ -418,6 +426,7 @@ def test_bitacc_pm_scaling_of_bias(self): class TestTLIFProcessModelsFloat(unittest.TestCase): """Tests for ternary LIF floating point neuron model""" + def test_float_pm_neg_no_decay_1(self): """Tests floating point ternary LIF model with negative bias driving a neuron without any decay of current and voltage states.""" @@ -566,6 +575,7 @@ def test_float_pm_neg_impulse_dv(self): class TestTLIFProcessModelsFixed(unittest.TestCase): """Tests for ternary LIF fixed point neuron model""" + def test_fixed_pm_neg_no_decay_1(self): """Tests fixed point ProcessModel for ternary LIF neurons without any current or voltage decay, solely driven by (negative) bias""" @@ -861,6 +871,7 @@ def test_float_model(self): assert_almost_equal(v, v_expected) + class TestEILIFFloat(unittest.TestCase): """Test EILIF process model""" @@ -872,18 +883,18 @@ def test_no_decays(self): # Two neurons with different biases # No Input current provided to make the voltage dependent on the bias ei_lif = EILIF(shape=(num_neurons,), - u_exc=np.zeros(num_neurons), - u_inh=np.zeros(num_neurons), - bias_mant=np.arange(num_neurons) + 1, - bias_exp=np.ones( - (num_neurons,), dtype=float), - vth=4,) + u_exc=np.zeros(num_neurons), + u_inh=np.zeros(num_neurons), + bias_mant=np.arange(num_neurons) + 1, + bias_exp=np.ones( + (num_neurons,), dtype=float), + vth=4,) v_logger = io.sink.Read(buffer=num_steps) v_logger.connect_var(ei_lif.v) ei_lif.run(condition=RunSteps(num_steps), - run_cfg=Loihi2SimCfg(select_tag="floating_pt")) + run_cfg=Loihi2SimCfg(select_tag="floating_pt")) v = v_logger.data.get() ei_lif.stop() @@ -905,20 +916,23 @@ def test_different_decays(self): # Two neurons with different biases # No Input current provided to make the voltage dependent on the bias ei_lif = EILIF(shape=(num_neurons,), - du_exc=du_exc_arr, - du_inh=du_inh_arr, - vth=6,) - + du_exc=du_exc_arr, + du_inh=du_inh_arr, + vth=6,) + # Setup external input positive_sps = VecSendProcess(shape=(num_neurons,), num_steps=num_steps, - vec_to_send=np.full(shape=(num_neurons), fill_value=1), - send_at_times=[1, 1, 0, 0, 0, 0, 0 , 0], dtype=bool) - + vec_to_send=np.full( + shape=(num_neurons), fill_value=1), + send_at_times=[1, 1, 0, 0, 0, 0, 0, 0], + dtype=bool) + negative_sps = VecSendProcess(shape=(num_neurons,), num_steps=num_steps, - vec_to_send=np.full(shape=(num_neurons), fill_value=-1), - send_at_times=[0, 0, 0, 1, 1, 1, 0 , 0], dtype=bool) - - + vec_to_send=np.full( + shape=(num_neurons), fill_value=-1), + send_at_times=[0, 0, 0, 1, 1, 1, 0, 0], + dtype=bool) + # Connect external input to the EILIF model positive_sps.s_out.connect(ei_lif.a_in) negative_sps.s_out.connect(ei_lif.a_in) @@ -927,17 +941,19 @@ def test_different_decays(self): v_logger.connect_var(ei_lif.v) ei_lif.run(condition=RunSteps(num_steps), - run_cfg=Loihi2SimCfg(select_tag="floating_pt")) + run_cfg=Loihi2SimCfg(select_tag="floating_pt")) v = v_logger.data.get() ei_lif.stop() # Voltage is expected to remain at reset level for two time steps v_expected = np.array([[1, 2.9, 4.61, 5.149, 4.73, 3.54, 2.71, 2.16], - [1, 2.8, 4.24, 4.39, 3.61, 2.16, 1.22, 0.62]], dtype=float) + [1, 2.8, 4.24, 4.39, 3.61, 2.16, 1.22, 0.62]], + dtype=float) assert_almost_equal(v, v_expected, decimal=2) + class TestEILIFRefractoryFloat(unittest.TestCase): """Test EILIFRefractory process model""" @@ -950,19 +966,19 @@ def test_no_decays(self): # Two neurons with different biases # No Input current provided to make the voltage dependent on the bias ei_lif = EILIFRefractory(shape=(num_neurons,), - u_exc=np.zeros(num_neurons), - u_inh=np.zeros(num_neurons), - bias_mant=np.arange(num_neurons) + 1, - bias_exp=np.ones( - (num_neurons,), dtype=float), - vth=4, - refractory_period=refractory_period) + u_exc=np.zeros(num_neurons), + u_inh=np.zeros(num_neurons), + bias_mant=np.arange(num_neurons) + 1, + bias_exp=np.ones( + (num_neurons,), dtype=float), + vth=4, + refractory_period=refractory_period) v_logger = io.sink.Read(buffer=num_steps) v_logger.connect_var(ei_lif.v) ei_lif.run(condition=RunSteps(num_steps), - run_cfg=Loihi2SimCfg(select_tag="floating_pt")) + run_cfg=Loihi2SimCfg(select_tag="floating_pt")) v = v_logger.data.get() ei_lif.stop() @@ -982,23 +998,27 @@ def test_different_decays(self): du_exc_arr = np.array([0.1, 0.2]) du_inh_arr = np.array([0.2, 0.3]) - # Neuron 1 will spike, while neuron 2 will not due to different decay rates. + # Neuron 1 will spike, while neuron 2 will not due + # to different decay rates. ei_lif = EILIFRefractory(shape=(num_neurons,), - du_exc=du_exc_arr, - du_inh=du_inh_arr, - vth=5, - refractory_period=refractory_period) - + du_exc=du_exc_arr, + du_inh=du_inh_arr, + vth=5, + refractory_period=refractory_period) + # Setup external input positive_sps = VecSendProcess(shape=(num_neurons,), num_steps=num_steps, - vec_to_send=np.full(shape=(num_neurons), fill_value=1), - send_at_times=[1, 1, 0, 0, 0, 0, 0 , 0], dtype=bool) - + vec_to_send=np.full( + shape=(num_neurons), fill_value=1), + send_at_times=[1, 1, 0, 0, 0, 0, 0, 0], + dtype=bool) + negative_sps = VecSendProcess(shape=(num_neurons,), num_steps=num_steps, - vec_to_send=np.full(shape=(num_neurons), fill_value=-1), - send_at_times=[0, 0, 0, 1, 1, 1, 0 , 0], dtype=bool) - - + vec_to_send=np.full( + shape=(num_neurons), fill_value=-1), + send_at_times=[0, 0, 0, 1, 1, 1, 0, 0], + dtype=bool) + # Connect external input to the EILIF model positive_sps.s_out.connect(ei_lif.a_in) negative_sps.s_out.connect(ei_lif.a_in) @@ -1007,13 +1027,14 @@ def test_different_decays(self): v_logger.connect_var(ei_lif.v) ei_lif.run(condition=RunSteps(num_steps), - run_cfg=Loihi2SimCfg(select_tag="floating_pt")) + run_cfg=Loihi2SimCfg(select_tag="floating_pt")) v = v_logger.data.get() ei_lif.stop() # Voltage is expected to remain at reset level for two time steps v_expected = np.array([[1, 2.9, 4.61, 0, 0, -1.19341, -2.02, -2.57], - [1, 2.8, 4.24, 4.39, 3.61, 2.16, 1.22, 0.62]], dtype=float) + [1, 2.8, 4.24, 4.39, 3.61, 2.16, 1.22, 0.62]], + dtype=float) - assert_almost_equal(v, v_expected, decimal=2) \ No newline at end of file + assert_almost_equal(v, v_expected, decimal=2) diff --git a/tutorials/custom/tutorial00_tour_through_lava.ipynb b/tutorials/custom/tutorial00_tour_through_lava.ipynb deleted file mode 100644 index b0ffddff9..000000000 --- a/tutorials/custom/tutorial00_tour_through_lava.ipynb +++ /dev/null @@ -1,567 +0,0 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "id": "3ebce42a", - "metadata": {}, - "source": [ - "*Copyright (C) 2022 Intel Corporation*
\n", - "*SPDX-License-Identifier: BSD-3-Clause*
\n", - "*See: https://spdx.org/licenses/*\n", - "\n", - "---\n", - "\n", - "# Walk through Lava\n", - "\n", - "Lava is an open-source software library dedicated to the development of algorithms for neuromorphic computation. To that end, Lava provides an easy-to-use Python interface for creating the bits and pieces required for such a neuromorphic algorithm. For easy development, Lava allows to run and test all neuromorphic algorithms on standard von-Neumann hardware like CPU, before they can be deployed on neuromorphic processors such as the Intel Loihi 1/2 processor to leverage their speed and power advantages. Furthermore, Lava is designed to be extensible to custom implementations of neuromorphic behavior and to support new hardware backends.\n", - "\n", - "Lava can fundamentally be used at two different levels: Either by using existing resources which can be used to create complex algorithms while requiring almost no deep neuromorphic knowledge. Or, for custom behavior, Lava can be easily extended with new behavior defined in Python and C.\n", - "\n", - "![lava_overview.png](https://raw.githubusercontent.com/lava-nc/lava-docs/dev/walk-through-tutorial/_static/images/tutorial00/lava_overview.png)\n", - "\n", - "This tutorial gives an high-level overview over the key components of Lava. For illustration, we will use a simple working example: a feed-forward multi-layer LIF network executed locally on CPU.\n", - "In the first section of the tutorial, we use the internal resources of Lava to construct such a network and in the second section, we demonstrate how to extend Lava with a custom process using the example of an input generator.\n", - "\n", - "In addition to the core Lava library described in the present tutorial, the following tutorials guide you to use high level functionalities:\n", - "- [lava-dl](https://github.com/lava-nc/lava-dl) for deep learning applications\n", - "- [lava-optimization](https://github.com/lava-nc/lava-optimization) for constraint optimization\n", - "- [lava-dnf](https://github.com/lava-nc/lava-dnf) for Dynamic Neural Fields\n", - "\n", - "## 1. Usage of the Process Library\n", - "\n", - "In this section, we will use a simple 2-layered feed-forward network of LIF neurons executed on CPU as canonical example. \n", - "\n", - "The fundamental building block in the Lava architecture is the `Process`. A `Process` describes a functional group, such as a population of `LIF` neurons, which runs asynchronously and parallel and communicates via `Channels`. A `Process` can take different forms and does not necessarily be a population of neurons, for example it could be a complete network, program code or the interface to a sensor (see figure below).\n", - "\n", - "![process_overview.png](https://raw.githubusercontent.com/lava-nc/lava-docs/dev/walk-through-tutorial/_static/images/tutorial00/proc_overview.png)\n", - "\n", - "For convenience, Lava provides a growing Process Library in which many commonly used `Processes` are publicly available.\n", - "In the first section of this tutorial, we will use the `Processes` of the Process Library to create and execute a multi-layer LIF network. Take a look at the [documentation](https://lava-nc.org) to find out what other `Processes` are implemented in the Process Library.\n", - "\n", - "Let's start by importing the classes `LIF` and `Dense` and take a brief look at the docstring." - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "id": "f5f304d1", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[0;31mInit signature:\u001b[0m \u001b[0mLIF\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mDocstring:\u001b[0m \n", - "Leaky-Integrate-and-Fire (LIF) neural Process.\n", - "\n", - "LIF dynamics abstracts to:\n", - "u[t] = u[t-1] * (1-du) + a_in # neuron current\n", - "v[t] = v[t-1] * (1-dv) + u[t] + bias # neuron voltage\n", - "s_out = v[t] > vth # spike if threshold is exceeded\n", - "v[t] = 0 # reset at spike\n", - "\n", - "Parameters\n", - "----------\n", - "shape : tuple(int)\n", - " Number and topology of LIF neurons.\n", - "u : float, list, numpy.ndarray, optional\n", - " Initial value of the neurons' current.\n", - "v : float, list, numpy.ndarray, optional\n", - " Initial value of the neurons' voltage (membrane potential).\n", - "du : float, optional\n", - " Inverse of decay time-constant for current decay. Currently, only a\n", - " single decay can be set for the entire population of neurons.\n", - "dv : float, optional\n", - " Inverse of decay time-constant for voltage decay. Currently, only a\n", - " single decay can be set for the entire population of neurons.\n", - "bias_mant : float, list, numpy.ndarray, optional\n", - " Mantissa part of neuron bias.\n", - "bias_exp : float, list, numpy.ndarray, optional\n", - " Exponent part of neuron bias, if needed. Mostly for fixed point\n", - " implementations. Ignored for floating point implementations.\n", - "vth : float, optional\n", - " Neuron threshold voltage, exceeding which, the neuron will spike.\n", - " Currently, only a single threshold can be set for the entire\n", - " population of neurons.\n", - "\n", - "Example\n", - "-------\n", - ">>> lif = LIF(shape=(200, 15), du=10, dv=5)\n", - "This will create 200x15 LIF neurons that all have the same current decay\n", - "of 10 and voltage decay of 5.\n", - "\u001b[0;31mInit docstring:\u001b[0m Initializes a new Process.\n", - "\u001b[0;31mFile:\u001b[0m ~/Desktop/feup/thesis/thesis-lava/src/lava/proc/lif/process.py\n", - "\u001b[0;31mType:\u001b[0m ProcessPostInitCaller\n", - "\u001b[0;31mSubclasses:\u001b[0m LIFReset, LIFRefractory" - ] - } - ], - "source": [ - "from lava.proc.lif.process import LIF, EILIF, EILIFRefractory\n", - "from lava.proc.dense.process import Dense\n", - "\n", - "LIF?" - ] - }, - { - "cell_type": "markdown", - "id": "b4dce60e", - "metadata": {}, - "source": [ - "The docstring gives insights about the parameters and internal dynamics of the `LIF` neuron. `Dense` is used to connect to a neuron population in an all-to-all fashion, often implemented as a matrix-vector product.\n", - "\n", - "In the next box, we will create the `Processes` we need to implement a multi-layer LIF (LIF-Dense-LIF) network." - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "id": "dbd808cb", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "\n", - "# Create processes\n", - "lif1 = EILIFRefractory(shape=(3, ), # Number and topological layout of units in the process\n", - " vth=10., # Membrane threshold\n", - " dv=0.1, # Inverse membrane time-constant\n", - " du_exc=[0.1, 0.2, 0.3], # Inverse synaptic time-constant\n", - " du_inh=[0.2, 0.4, 0.6],\n", - " bias_mant=(1.1, 1.2, 1.3), # Bias added to the membrane voltage in every timestep\n", - " name=\"lif1\",\n", - " refractory_period=4)\n", - "\n", - "dense = Dense(weights=np.random.rand(2, 3), # Initial value of the weights, chosen randomly\n", - " name='dense')\n", - "\n", - "lif2 = EILIF(shape=(2, ), # Number and topological layout of units in the process\n", - " vth=10., # Membrane threshold\n", - " dv=0.1, # Inverse membrane time-constant\n", - " du_exc=[0.2, 0.4], # Inverse synaptic time-constant\n", - " du_inh=[0.4, 0.8],\n", - " bias_mant=0., # Bias added to the membrane voltage in every timestep\n", - " name='lif2')" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "1fbfed43", - "metadata": {}, - "source": [ - "As you can see, we can either specify parameters with scalars, then all units share the same initial value for this parameter, or with a tuple (or list, or numpy array) to set the parameter individually per unit.\n", - "\n", - "\n", - "### Processes\n", - "\n", - "Let's investigate the objects we just created. As mentioned before, both, `LIF` and `Dense` are examples of `Processes`, the main building block in Lava.\n", - "\n", - "A `Process` holds three key components (see figure below):\n", - "\n", - "- Input ports\n", - "- Variables\n", - "- Output ports\n", - "\n", - "![process.png](https://raw.githubusercontent.com/lava-nc/lava-docs/dev/walk-through-tutorial/_static/images/tutorial00/proc.png)\n", - "\n", - "The `Vars` are used to store internal states of the `Process` while the `Ports` are used to define the connectivity between the `Processes`. Note that a `Process` only defines the `Vars` and `Ports` but not the behavior. This is done separately in a `ProcessModel`. To separate the interface from the behavioral implementation has the advantage that we can define the behavior of a `Process` for multiple hardware backends using multiple `ProcessModels` without changing the interface. We will get into more detail about `ProcessModels` in the second part of this tutorial.\n", - "\n", - "### Ports and connections\n", - "\n", - "Let's take a look at the `Ports` of the `LIF` and `Dense` processes we just created. The output `Port` of the `LIF` neuron is called `s_out`, which stands for 'spiking' output. The input `Port` is called `a_in` which stands for 'activation' input.\n", - "\n", - "For example, we can see the size of the `Port` which is in particular important because `Ports` can only connect if their shape matches." - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "id": "3f8f656a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Proc: lif1 Name: a_in Size: 3\n", - "Proc: lif1 Name: s_out Size: 3\n", - "Proc: lif2 Name: a_in Size: 2\n", - "Proc: lif2 Name: s_out Size: 2\n", - "Proc: dense Name: s_in Size: 3\n", - "Proc: dense Name: a_out Size: 2\n" - ] - } - ], - "source": [ - "for proc in [lif1, lif2, dense]:\n", - " for port in proc.in_ports:\n", - " print(f'Proc: {proc.name:<5} Name: {port.name:<5} Size: {port.size}')\n", - " for port in proc.out_ports:\n", - " print(f'Proc: {proc.name:<5} Name: {port.name:<5} Size: {port.size}')" - ] - }, - { - "cell_type": "markdown", - "id": "1c5da64b", - "metadata": {}, - "source": [ - "Now that we know about the input and output `Ports` of the `LIF` and `Dense` `Processes`, we can `connect` the network to complete the LIF-Dense-LIF structure.\n", - "\n", - "![process_comm.png](https://raw.githubusercontent.com/lava-nc/lava-docs/dev/walk-through-tutorial/_static/images/tutorial00/procs.png)\n", - "\n", - "As can be seen in the figure above, by `connecting` two processes, a `Channel` between them is created which means that messages between those two `Processes` can be exchanged." - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "id": "657063e9", - "metadata": {}, - "outputs": [], - "source": [ - "lif1.s_out.connect(dense.s_in)\n", - "dense.a_out.connect(lif2.a_in)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "7f0add01", - "metadata": {}, - "source": [ - "### Variables\n", - "\n", - "Similar to the `Ports`, we can investigate the `Vars` of a `Process`.\n", - "\n", - "`Vars` are also accessible as member variables. We can print details of a specific `Var` to see the shape, initial value and current value. The `shareable` attribute controls whether a `Var` can be manipulated via remote memory access. Learn more about about this topic in the [remote memory access tutorial](https://github.com/lava-nc/lava/blob/main/tutorials/in_depth/tutorial07_remote_memory_access.ipynb)." - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "id": "d6be4fa0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Var: bias_exp Shape: (3,) Init: 0\n", - "Var: bias_mant Shape: (3,) Init: (1.1, 1.2, 1.3)\n", - "Var: du_exc Shape: (3,) Init: [0.1 0.2 0.3]\n", - "Var: du_inh Shape: (3,) Init: [0.2 0.4 0.6]\n", - "Var: dv Shape: (3,) Init: [0.1 0.1 0.1]\n", - "Var: refractory_period_end Shape: (3,) Init: 0\n", - "Var: u Shape: (3,) Init: 0\n", - "Var: u_exc Shape: (3,) Init: 0\n", - "Var: u_inh Shape: (3,) Init: 0\n", - "Var: v Shape: (3,) Init: 0\n", - "Var: vth Shape: (1,) Init: 10.0\n" - ] - } - ], - "source": [ - "for var in lif1.vars:\n", - " print(f'Var: {var.name:<9} Shape: {var.shape} Init: {var.init}')" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "971d5ed7", - "metadata": {}, - "source": [] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "7574279a", - "metadata": {}, - "source": [ - "We can take a look at the random weights of `Dense` by calling the `get` function.\n", - "\n", - "
\n", - "Note: There is also a `set` function available to change the value of a `Var` after the network was executed.\n", - "
" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "id": "e60c16db", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.01388928, 0.92301965, 0.48130938],\n", - " [0.461973 , 0.03409599, 0.1083507 ]])" - ] - }, - "execution_count": 48, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dense.weights.get()" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "49a7f22e", - "metadata": {}, - "source": [ - "### Record internal Vars over time\n", - "\n", - "In order to record the evolution of the internal `Vars` over time, we need a `Monitor`.\n", - "For this example, we want to record the membrane potential of both `LIF` Processes, hence we need two `Monitors`.\n", - "\n", - "We can define the `Var` that a `Monitor` should record, as well as the recording duration, using the `probe` function." - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "id": "635bf66b", - "metadata": {}, - "outputs": [], - "source": [ - "from lava.proc.monitor.process import Monitor\n", - "\n", - "monitor_lif1 = Monitor()\n", - "monitor_lif2 = Monitor()\n", - "\n", - "num_steps = 100\n", - "\n", - "monitor_lif1.probe(lif1.v, num_steps)\n", - "monitor_lif2.probe(lif2.v, num_steps)" - ] - }, - { - "cell_type": "markdown", - "id": "ce0c6495", - "metadata": {}, - "source": [ - "### Execution\n", - "\n", - "Now, that we finished to set up the network and recording `Processes`, we can execute the network by simply calling the `run` function of one of the `Processes`.\n", - "\n", - "The `run` function requires two parameters, a `RunCondition` and a `RunConfig`. The `RunCondition` defines *how* the network runs (i.e. for how long) while the `RunConfig` defines on which hardware backend the `Processes` should be mapped and executed." - ] - }, - { - "cell_type": "markdown", - "id": "9a43d818", - "metadata": {}, - "source": [ - "#### Run Conditions\n", - "\n", - "Let's investigate the different possibilities for `RunConditions`. One option is `RunContinuous` which executes the network continuously and non-blocking until `pause` or `stop` is called." - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "id": "0cf86c34", - "metadata": {}, - "outputs": [], - "source": [ - "from lava.magma.core.run_conditions import RunContinuous\n", - "\n", - "run_condition = RunContinuous()" - ] - }, - { - "cell_type": "markdown", - "id": "865e2ca9", - "metadata": {}, - "source": [ - "The second option is `RunSteps`, which allows you to define an exact amount of time steps the network should run." - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "id": "91fbce5e", - "metadata": {}, - "outputs": [], - "source": [ - "from lava.magma.core.run_conditions import RunSteps\n", - "\n", - "run_condition = RunSteps(num_steps=num_steps)" - ] - }, - { - "cell_type": "markdown", - "id": "2366d304", - "metadata": {}, - "source": [ - "For this example. we will use `RunSteps` and let the network run exactly `num_steps` time steps.\n", - "\n", - "#### RunConfigs\n", - "\n", - "Next, we need to provide a `RunConfig`. As mentioned above, The `RunConfig` defines on which hardware backend the network is executed.\n", - "\n", - "For example, we could run the network on the Loihi1 processor using the `Loihi1HwCfg`, on Loihi2 using the `Loihi2HwCfg`, or on CPU using the `Loihi1SimCfg`. The compiler and runtime then automatically select the correct `ProcessModels` such that the `RunConfig` can be fulfilled.\n", - "\n", - "For this section of the tutorial, we will run our network on CPU, later we will show how to run the same network on the Loihi2 processor." - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "id": "14c301f7", - "metadata": {}, - "outputs": [], - "source": [ - "from lava.magma.core.run_configs import Loihi1SimCfg\n", - "\n", - "run_cfg = Loihi1SimCfg(select_tag=\"floating_pt\")" - ] - }, - { - "cell_type": "markdown", - "id": "baf95f1f", - "metadata": {}, - "source": [ - "#### Execute\n", - "\n", - "Finally, we can simply call the `run` function of the second `LIF` process and provide the `RunConfig` and `RunCondition`." - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "id": "331f71b7", - "metadata": {}, - "outputs": [], - "source": [ - "lif2.run(condition=run_condition, run_cfg=run_cfg)" - ] - }, - { - "cell_type": "markdown", - "id": "1d8ea488", - "metadata": {}, - "source": [ - "### Retrieve recorded data\n", - "\n", - "After the simulation has stopped, we can call `get_data` on the two monitors to retrieve the recorded membrane potentials." - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "id": "582215cd", - "metadata": {}, - "outputs": [], - "source": [ - "data_lif1 = monitor_lif1.get_data()\n", - "data_lif2 = monitor_lif2.get_data()" - ] - }, - { - "cell_type": "markdown", - "id": "22f44fba", - "metadata": {}, - "source": [ - "Alternatively, we can also use the provided `plot` functionality of the `Monitor`, to plot the recorded data. As we can see, the bias of the first `LIF` population drives the membrane potential to the threshold which generates output spikes. Those output spikes are passed through the `Dense` layer as input to the second `LIF` population." - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "id": "32f48b10", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib\n", - "%matplotlib inline\n", - "from matplotlib import pyplot as plt\n", - "\n", - "# Create a subplot for each monitor\n", - "fig = plt.figure(figsize=(16, 5))\n", - "ax0 = fig.add_subplot(121)\n", - "ax1 = fig.add_subplot(122)\n", - "\n", - "# Plot the recorded data\n", - "monitor_lif1.plot(ax0, lif1.v)\n", - "monitor_lif2.plot(ax1, lif2.v)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "cf5fcea8", - "metadata": {}, - "source": [ - "As a last step we must stop the runtime by calling the `stop` function. `Stop` will terminate the `Runtime` and all states will be lost." - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "id": "0ddcd735", - "metadata": {}, - "outputs": [], - "source": [ - "lif2.stop()" - ] - }, - { - "cell_type": "markdown", - "id": "26af5f1d", - "metadata": {}, - "source": [ - "### Summary\n", - "\n", - "- There are many tools available in the Process Library to construct basic networks\n", - "- The fundamental building block in Lava is the `Process`\n", - "- Each `Process` consists of `Vars` and `Ports`\n", - "- A `Process` defines a common interface across hardware backends, but not the behavior\n", - "- The `ProcessModel` defines the behavior of a `Process` for a specific hardware backend\n", - "- `Vars` store internal states, `Ports` are used to implement communication channels between processes\n", - "- The `RunConfig` defines on which hardware backend the network runs " - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -}