From e4ecd6f9bfd200e888af4f92c17729d99bba1d26 Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Tue, 30 Jul 2019 19:16:13 -0400 Subject: [PATCH 01/45] Commit ODE capabilities. Add unit test for pm.ode --- pymc3/ode/__init__.py | 2 + pymc3/ode/ode.py | 183 +++++++++++++++ pymc3/ode/utils.py | 81 +++++++ pymc3/tests/test_ode.py | 497 ++++++++++++++++++++++++++++++++++++++++ 4 files changed, 763 insertions(+) create mode 100644 pymc3/ode/__init__.py create mode 100644 pymc3/ode/ode.py create mode 100644 pymc3/ode/utils.py create mode 100644 pymc3/tests/test_ode.py diff --git a/pymc3/ode/__init__.py b/pymc3/ode/__init__.py new file mode 100644 index 00000000000..468c3f54aeb --- /dev/null +++ b/pymc3/ode/__init__.py @@ -0,0 +1,2 @@ +from . import utils +from .ode import DifferentialEquation \ No newline at end of file diff --git a/pymc3/ode/ode.py b/pymc3/ode/ode.py new file mode 100644 index 00000000000..c90cd11200f --- /dev/null +++ b/pymc3/ode/ode.py @@ -0,0 +1,183 @@ +import numpy as np +from pymc3.ode.utils import augment_system, ODEGradop +import scipy +import theano +import theano.tensor as tt +THEANO_FLAG = 'compute_test_value=ignore' + + +class DifferentialEquation(theano.Op): + + ''' + Specify an ordinary differential equation + + .. math:: + \dfrac{dy}{dt} = f(y,t,p) \quad y(t_0) = y_0 + + Parameters + ---------- + + func : callable + Function specifying the differential equation + t0 : float + Time corresponding to the initial condition + times : array + Array of times at which to evaluate the solution of the differential equation. + n_states : int + Dimension of the differential equation. For scalar differential equations, n_states =1. + For vector valued differential equations, n_states = number of differential equations iun the system. + n_odeparams : int + Number of parameters in the differential equation. + + .. code-block:: python + + def odefunc(y,t,p): + #Logistic differential equation + return p[0]*y[0]*(1-y[0]) + + times = np.arange(0.5, 5, 0.5) + + ode_model = DifferentialEquation(func = odefunc, t0 = 0, times = times, n_states = 1, n_odeparams = 1) + ''' + + __props__ = () + + def __init__(self, func, t0, times, n_states, n_odeparams): + + if not callable(func): + raise ValueError("Argument func must be callable.") + if np.any(np.diff(times)<0): + raise ValueError("The values in times must be monotonically increasing or monotonically decreasing; repeated values are allowed.") + if n_states<1: + raise ValueError('Argument n_states must be at least 1.') + if n_odeparams<0: + raise ValueError('Argument n_states must be non-negative.') + + #Public + self.func = func + self.t0 = t0 + self.times = times + self.n_states = n_states + self.n_odeparams = n_odeparams + + #Private + self._n = n_states + self._m = n_odeparams + n_states + + self._augmented_times = np.insert(times, t0, 0) + self._augmented_func = augment_system(func, self._n, self._m) + self._sens_ic = self._make_sens_ic() + + self._cached_y = None + self._cached_sens = None + self._cached_parameters = None + + def _make_sens_ic(self): + + # The sensitivity matrix will always have consistent form. + # If the first n_odeparams entries of the parameters vector in the simulate call + # correspond to ode paramaters, then the first n_odeparams columns in + # the sensitivity matrix will be 0 + sens_matrix = np.zeros((self._n, self._m)) + + # If the last n_states entrues of the paramters vector in the simulate call + # correspond to initial conditions of the system, + # then the last n_states columns of the sensitivity matrix should form + # an identity matrix + sens_matrix[:, -self.n_states:] = np.eye(self.n_states) + + # We need the sensitivity matrix to be a vector (see augmented_function) + # Ravel and return + dydp = sens_matrix.ravel() + + return dydp + + def _system(self, Y, t, p): + """ + This is the function that will be passed to odeint. + Solves both ODE and sensitivities + Args: + Y (vector): current state and current gradient state + t (scalar): current time + p (vector): parameters + Returns: + derivatives (vector): derivatives of state and gradient + """ + + dydt, ddt_dydp = self._augmented_func(Y[:self._n], t, p, Y[self._n:]) + derivatives = np.concatenate([dydt, ddt_dydp]) + return derivatives + + def _simulate(self, parameters): + + # Initial condition comprised of state initial conditions and raveled + # sensitivity matrix + y0 = np.concatenate([ parameters[self.n_odeparams:] , self._sens_ic]) + + # perform the integration + sol = scipy.integrate.odeint(func=self._system, + y0=y0, + t=self._augmented_times, + args=tuple([parameters])) + # The solution + y = sol[1:, :self.n_states] + + # The sensitivities, reshaped to be a sequence of matrices + sens = sol[1:, self.n_states:].reshape(len(self.times), self._n, self._m) + + return y, sens + + def _cached_simulate(self, parameters): + + if np.array_equal(np.array(parameters), self._cached_parameters): + return self._cached_y, self._cached_sens + else: + return self._simulate(np.array(parameters)) + + def state(self, x): + + y, sens = self._cached_simulate(np.array(x, dtype=np.float64)) + self._cached_y, self._cached_sens, self._cached_parameters = y, sens, x + return y.ravel() + + def numpy_vsp(self, x, g): + + numpy_sens = self._cached_simulate(np.array(x, dtype=np.float64))[1].reshape((self.n_states * len(self.times), len(x))) + return numpy_sens.T.dot(g) + + def make_node(self, odeparams, y0): + + if len(odeparams)!=self.n_odeparams: + raise ValueError('odeparams has too many or too few parameters. Expected {a} paramteres but got {b}'.format(a = self.n_odeparams, b = len(odeparams))) + if len(y0)!=self.n_states: + raise ValueError('y0 has too many or too few parameters. Expected {a} paramteres but got {b}'.format(a = self.n_states, b = len(y0))) + + if np.ndim(odeparams) > 1: + odeparams = np.ravel(odeparams) + if np.ndim(y0) > 1: + y0 = np.ravel(y0) + + odeparams = tt.as_tensor_variable(odeparams) + y0 = tt.as_tensor_variable(y0) + x = tt.concatenate([odeparams, y0]) + + return theano.Apply(self, [x], [x.type()]) + + def perform(self, node, inputs_storage, output_storage): + + x = inputs_storage[0] + out = output_storage[0] + + # get the numerical solution of ODE states + out[0] = self.state(x) + + def grad(self, inputs, output_grads): + + x = inputs[0] + g = output_grads[0] + + # pass the VSP when asked for gradient + grad_op = ODEGradop(self.numpy_vsp) + grad_op_apply = grad_op(x, g) + + return [grad_op_apply] \ No newline at end of file diff --git a/pymc3/ode/utils.py b/pymc3/ode/utils.py new file mode 100644 index 00000000000..15d3767874a --- /dev/null +++ b/pymc3/ode/utils.py @@ -0,0 +1,81 @@ +import theano +import theano.tensor as tt + + +def augment_system(ode_func, n, m): + '''Function to create augmented system. + + Take a function which specifies a set of differential equations and return + a compiled function which allows for computation of gradients of the + differential equation's solition with repsect to the parameters. + + Args: + ode_func (function): Differential equation. Returns array-like + n: Number of rows of the sensitivity matrix + m: Number of columns of the sensitivity matrix + + Returns: + system (function): Augemted system of differential equations. + + ''' + + # Present state of the system + t_y = tt.vector('y', dtype=theano.config.floatX) + + # Parameter(s). Should be vector to allow for generaliztion to multiparameter + # systems of ODEs + t_p = tt.vector('p', dtype=theano.config.floatX) + + # Time. Allow for non-automonous systems of ODEs to be analyzed + t_t = tt.scalar('t', dtype=theano.config.floatX) + + # Present state of the gradients: + # Will always be 0 unless the parameter is the inital condition + # Entry i,j is partial of y[i] wrt to p[j] + dydp_vec = tt.vector('dydp', dtype=theano.config.floatX) + + dydp = dydp_vec.reshape((n, m)) + + # Stack the results of the ode_func + # TODO: Does this behave the same of ODE is scalar? + f_tensor = tt.stack(ode_func(t_y, t_t, t_p)) + + # Now compute gradients + J = tt.jacobian(f_tensor, t_y) + + Jdfdy = tt.dot(J, dydp) + + grad_f = tt.jacobian(f_tensor, t_p) + + # This is the time derivative of dydp + ddt_dydp = (Jdfdy + grad_f).flatten() + + system = theano.function( + inputs=[t_y, t_t, t_p, dydp_vec], + outputs=[f_tensor, ddt_dydp], + on_unused_input='ignore') + + return system + + + +class ODEGradop(theano.Op): + + def __init__(self, numpy_vsp): + + self._numpy_vsp = numpy_vsp + + def make_node(self, x, g): + + x = theano.tensor.as_tensor_variable(x) + g = theano.tensor.as_tensor_variable(g) + node = theano.Apply(self, [x, g], [g.type()]) + return node + + def perform(self, node, inputs_storage, output_storage): + + x = inputs_storage[0] + + g = inputs_storage[1] + out = output_storage[0] + out[0] = self._numpy_vsp(x, g) # get the numerical VSP diff --git a/pymc3/tests/test_ode.py b/pymc3/tests/test_ode.py new file mode 100644 index 00000000000..a359f8a9ced --- /dev/null +++ b/pymc3/tests/test_ode.py @@ -0,0 +1,497 @@ +from ..ode import DifferentialEquation +from ..ode.utils import augment_system + +import numpy as np +from scipy.integrate import odeint +from scipy.stats import norm +import pymc3 as pm +import theano +import theano.tensor as tt +import pytest + + +def test_gradients(): + with theano.configparser.change_flags(compute_test_value='off'): + '''Tests the computation of the sensitivities from the theano computation graph''' + + # ODE system for which to compute gradients + def ode_func(y, t, p): + return np.exp(-t) - p[0] * y[0] + + # Computation of graidients with Theano + augmented_ode_func = augment_system(ode_func, 1, 1 + 1) + + # This is the new system, ODE + Sensitivities, which will be integrated + def augmented_system(Y, t, p): + + dydt, ddt_dydp = augmented_ode_func(Y[:1], t, p, Y[1:]) + derivatives = np.concatenate([dydt, ddt_dydp]) + return derivatives + + # Create real sensitivities + y0 = 0.0 + t = np.arange(0, 12, 0.25).reshape(-1, 1) + a = 0.472 + p = np.array([a, y0]) + + # Derivatives of the analytic solution with respect to y0 and alpha + # Treat y0 like a parameter and solve analytically. Then differentiate. + # I used CAS to get these derivatives + y0_sensitivity = np.exp(-a * t) + a_sensitivity = -(np.exp(t * (a - 1)) - 1 + (a - 1) * + (y0 * a - y0 - 1) * t) * np.exp(-a * t) / (a - 1)**2 + + sensitivity = np.c_[a_sensitivity, y0_sensitivity] + + integrated_solutions = odeint(func=augmented_system, + y0=[y0, 0, 1], + t=t.ravel(), + args=tuple([p])) + simulated_sensitivity = integrated_solutions[:, 1:] + + np.testing.assert_allclose( + sensitivity, simulated_sensitivity, rtol=1e-5) + + +def test_simulate(): + with theano.configparser.change_flags(compute_test_value='off'): + '''Tests the integration in DifferentialEquation''' + + # Create an ODe to integrate + def ode_func(y, t, p): + return np.exp(-t) - p[0] * y[0] + + # Evaluate exact solution + y0 = 0 + t = np.arange(0, 12, 0.25).reshape(-1, 1) + a = 0.472 + y = 1.0 / (a - 1) * (np.exp(-t) - np.exp(-a * t)) + + # Instantiate ODE model + ode_model = DifferentialEquation(func=ode_func, + t0=0, + times=t, + n_states=1, + n_odeparams=1) + + simulated_y, *_ = ode_model._simulate([a, y0]) + + np.testing.assert_allclose(y, simulated_y, rtol=1e-5) + + +class TestSensitivityInitialCondition(object): + + t = np.arange(0, 12, 0.25).reshape(-1, 1) + + def test_sens_ic_scalar_1_param(self): + with theano.configparser.change_flags(compute_test_value='off'): + + '''Tests the creation of the initial condition for the sensitivities''' + + # Scalar ODE 1 Param + # Create an ODe to integrate + def ode_func_1(y, t, p): + return np.exp(-t) - p[0] * y[0] + + # Instantiate ODE model + # Instantiate ODE model + model1 = DifferentialEquation(func=ode_func_1, + t0=0, + times=self.t, + n_states=1, + n_odeparams=1) + + # Sensitivity initial condition for this model should be 1 by 2 + model1_sens_ic = np.array([0, 1]) + + np.testing.assert_array_equal( + model1_sens_ic, model1._make_sens_ic()) + + def test_sens_ic_scalar_2_param(self): + with theano.configparser.change_flags(compute_test_value='off'): + + # Scalar ODE 2 Param + def ode_func_2(y, t, p): + return p[0] * np.exp(-p[0] * t) - p[1] * y[0] + + # Instantiate ODE model + model2 = DifferentialEquation(func=ode_func_2, + t0=0, + times=self.t, + n_states=1, + n_odeparams=2) + + model2_sens_ic = np.array([0, 0, 1]) + + np.testing.assert_array_equal( + model2_sens_ic, model2._make_sens_ic()) + + def test_sens_ic_vector_1_param(self): + with theano.configparser.change_flags(compute_test_value='off'): + + # Vector ODE 1 Param + def ode_func_3(y, t, p): + ds = -p[0] * y[0] * y[1] + di = p[0] * y[0] * y[1] - y[1] + + return [ds, di] + + # Instantiate ODE model + model3 = DifferentialEquation(func=ode_func_3, + t0=0, + times=self.t, + n_states=2, + n_odeparams=1) + + model3_sens_ic = np.array([0, 1, 0, 0, 0, 1]) + + np.testing.assert_array_equal( + model3_sens_ic, model3._make_sens_ic()) + + def test_sens_ic_vector_2_param(self): + with theano.configparser.change_flags(compute_test_value='off'): + + # Vector ODE 2 Param + def ode_func_4(y, t, p): + ds = -p[0] * y[0] * y[1] + di = p[0] * y[0] * y[1] - p[1] * y[1] + + return [ds, di] + + # Instantiate ODE model + model4 = DifferentialEquation(func=ode_func_4, + t0=0, + times=self.t, + n_states=2, + n_odeparams=2) + + model4_sens_ic = np.array([0, 0, 1, 0, 0, 0, 0, 1]) + + np.testing.assert_array_equal( + model4_sens_ic, model4._make_sens_ic()) + + def test_sens_ic_vector_3_params(self): + with theano.configparser.change_flags(compute_test_value='off'): + + # Big System with Many Parameters + def ode_func_5(y, t, p): + dx = p[0] * (y[1] - y[0]) + ds = y[0] * (p[1] - y[2]) - y[1] + dz = y[0] * y[1] - p[2] * y[2] + + return [dx, ds, dz] + + # Instantiate ODE model + model5 = DifferentialEquation(func=ode_func_5, + t0=0, + times=self.t, + n_states=3, + n_odeparams=3) + + # First three columns are derivatives with respect to ode parameters + # Last three coluimns are derivatives with repsect to initial condition + # So identity matrix should appear in last 3 columns + model5_sens_ic = np.array([[0, 0, 0, 1, 0, 0], + [0, 0, 0, 0, 1, 0], + [0, 0, 0, 0, 0, 1]]) + + np.testing.assert_array_equal( + np.ravel(model5_sens_ic), + model5._make_sens_ic()) + + +def test_logp_scalar_ode(): + with theano.configparser.change_flags(compute_test_value='off'): + + '''Test the computation of the log probability for these models''' + + # Differential equation + def system_1(y, t, p): + return np.exp(-t) - p[0] * y[0] + + # Parameters and inital condition + alpha = 0.4 + y0 = 0.0 + times = np.arange(0.5, 8, 0.5) + + yobs = np.array([0.30, + 0.56, + 0.51, + 0.55, + 0.47, + 0.42, + 0.38, + 0.30, + 0.26, + 0.21, + 0.22, + 0.13, + 0.13, + 0.09, + 0.09]).reshape(-1, + 1) + + ode_model = DifferentialEquation(func=system_1, + t0=0, + times=times, + n_odeparams=1, + n_states=1) + + integrated_solution, *_ = ode_model._simulate([alpha, y0]) + + manual_logp = norm.logpdf( + x=np.ravel(yobs), + loc=np.ravel(integrated_solution), + scale=1).sum() + + with pm.Model() as model_1: + + forward = ode_model(odeparams=[alpha], y0=[y0]).reshape(yobs.shape) + + y = pm.Normal('y', mu=forward, sd=1, observed=yobs) + + pymc3_logp = model_1.logp() + + np.testing.assert_allclose(manual_logp, pymc3_logp) + + +class TestErrors(object): + + '''Test running model for a scalar ODE with 1 parameter''' + def system(y, t, p): + return np.exp(-t) - p[0] * y[0] + + times = np.arange(0, 9) + + ode_model = DifferentialEquation( + func=system, + t0=0, + times=times, + n_states=1, + n_odeparams=1) + + def test_too_many_params(self): + with pytest.raises(ValueError): + self.ode_model(odeparams=[1, 1], y0=[0]) + + def test_too_many_y0(self): + with pytest.raises(ValueError): + self.ode_model(odeparams=[1], y0=[0, 0]) + + def test_too_few_params(self): + with pytest.raises(ValueError): + self.ode_model(odeparams=[], y0=[1]) + + def test_too_few_y0(self): + with pytest.raises(ValueError): + self.ode_model(odeparams=[1], y0=[]) + + +class TestDiffEqModel(object): + + def test_scalar_ode_1_param(self): + '''Test running model for a scalar ODE with 1 parameter''' + with theano.configparser.change_flags(compute_test_value='off'): + def system(y, t, p): + return np.exp(-t) - p[0] * y[0] + + times = np.array([0.5, 1., 1.5, 2., 2.5, 3., 3.5, + 4., 4.5, 5., 5.5, 6., 6.5, 7., 7.5]) + + yobs = np.array([0.31, + 0.57, + 0.51, + 0.55, + 0.47, + 0.42, + 0.38, + 0.3, + 0.26, + 0.22, + 0.22, + 0.14, + 0.14, + 0.09, + 0.1]).reshape(-1, + 1) + + ode_model = DifferentialEquation( + func=system, + t0=0, + times=times, + n_states=1, + n_odeparams=1) + + with pm.Model() as model: + + alpha = pm.HalfCauchy('alpha', 1) + y0 = pm.Lognormal('y0', 0, 1) + sigma = pm.HalfCauchy('sigma', 1) + forward = ode_model( + odeparams=[alpha], + y0=[y0]).reshape( + yobs.shape) + + y = pm.Lognormal('y', mu=pm.math.log( + forward), sd=sigma, observed=yobs) + + trace = pm.sample(100, tune=0) + + assert trace['alpha'].size > 0 + assert trace['y0'].size > 0 + assert trace['sigma'].size > 0 + + def test_scalar_ode_2_param(self): + '''Test running model for a scalar ODE with 2 parameters''' + with theano.configparser.change_flags(compute_test_value='off'): + def system(y, t, p): + return p[0] * np.exp(-p[0] * t) - p[1] * y[0] + + times = np.array([0.5, 1., 1.5, 2., 2.5, 3., 3.5, + 4., 4.5, 5., 5.5, 6., 6.5, 7., 7.5]) + + yobs = np.array([0.31, + 0.57, + 0.51, + 0.55, + 0.47, + 0.42, + 0.38, + 0.30, + 0.26, + 0.22, + 0.22, + 0.14, + 0.14, + 0.09, + 0.10]).reshape(-1, + 1) + + ode_model = DifferentialEquation( + func=system, + t0=0, + times=times, + n_states=1, + n_odeparams=2) + + with pm.Model() as model: + + alpha = pm.HalfCauchy('alpha', 1) + beta = pm.HalfCauchy('beta', 1) + y0 = pm.Lognormal('y0', 0, 1) + sigma = pm.HalfCauchy('sigma', 1) + forward = ode_model( + odeparams=[ + alpha, + beta], + y0=[y0]).reshape( + yobs.shape) + + y = pm.Lognormal('y', mu=pm.math.log( + forward), sd=sigma, observed=yobs) + + trace = pm.sample(100, tune=0) + + assert trace['alpha'].size > 0 + assert trace['beta'].size > 0 + assert trace['y0'].size > 0 + assert trace['sigma'].size > 0 + + def test_vector_ode_1_param(self): + '''Test running model for a vector ODE with 1 parameter''' + with theano.configparser.change_flags(compute_test_value='off'): + def system(y, t, p): + ds = -p[0] * y[0] * y[1] + di = p[0] * y[0] * y[1] - y[1] + + return [ds, di] + + times = np.array( + [0.0, 0.8, 1.6, 2.4, 3.2, 4.0, 4.8, 5.6, 6.4, 7.2, 8.0]) + + yobs = np.array([[1.02, 0.02], + [0.86, 0.12], + [0.43, 0.37], + [0.14, 0.42], + [0.05, 0.43], + [0.03, 0.14], + [0.02, 0.08], + [0.02, 0.04], + [0.02, 0.01], + [0.02, 0.01], + [0.02, 0.01]]) + + ode_model = DifferentialEquation( + func=system, + t0=0, + times=times, + n_states=2, + n_odeparams=1) + + with pm.Model() as model: + + R = pm.Lognormal('R', 1, 5) + sigma = pm.HalfCauchy('sigma', 1, shape=2) + forward = ode_model( + odeparams=[R], y0=[ + 0.99, 0.01]).reshape( + yobs.shape) + + y = pm.Lognormal('y', mu=pm.math.log( + forward), sd=sigma, observed=yobs) + + trace = pm.sample(100, tune=0) + + assert trace['R'].size > 0 + assert trace['sigma'].size > 0 + + def test_vector_ode_2_param(self): + '''Test running model for a vector ODE with 2 parameters''' + with theano.configparser.change_flags(compute_test_value='off'): + def system(y, t, p): + ds = -p[0] * y[0] * y[1] + di = p[0] * y[0] * y[1] - p[1] * y[1] + + return [ds, di] + + times = np.array( + [0.0, 0.8, 1.6, 2.4, 3.2, 4.0, 4.8, 5.6, 6.4, 7.2, 8.0]) + + yobs = np.array([[1.02, 0.02], + [0.86, 0.12], + [0.43, 0.37], + [0.14, 0.42], + [0.05, 0.43], + [0.03, 0.14], + [0.02, 0.08], + [0.02, 0.04], + [0.02, 0.01], + [0.02, 0.01], + [0.02, 0.01]]) + + ode_model = DifferentialEquation( + func=system, + t0=0, + times=times, + n_states=2, + n_odeparams=2) + + with pm.Model() as model: + + beta = pm.HalfCauchy('beta', 1) + gamma = pm.HalfCauchy('gamma', 1) + sigma = pm.HalfCauchy('sigma', 1, shape=2) + forward = ode_model( + odeparams=[ + beta, gamma], y0=[ + 0.99, 0.01]).reshape( + yobs.shape) + + y = pm.Lognormal('y', mu=pm.math.log( + forward), sd=sigma, observed=yobs) + + trace = pm.sample(100, tune=0) + + assert trace['beta'].size > 0 + assert trace['gamma'].size > 0 + assert trace['sigma'].size > 0 From 8d9743f9473c6d907fb8f0361c78bb2f6661a70a Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Tue, 30 Jul 2019 19:16:13 -0400 Subject: [PATCH 02/45] Commit ODE capabilities. Add unit test for pm.ode --- pymc3/ode/__init__.py | 2 + pymc3/ode/ode.py | 183 +++++++++++++++ pymc3/ode/utils.py | 81 +++++++ pymc3/tests/test_ode.py | 497 ++++++++++++++++++++++++++++++++++++++++ 4 files changed, 763 insertions(+) create mode 100644 pymc3/ode/__init__.py create mode 100644 pymc3/ode/ode.py create mode 100644 pymc3/ode/utils.py create mode 100644 pymc3/tests/test_ode.py diff --git a/pymc3/ode/__init__.py b/pymc3/ode/__init__.py new file mode 100644 index 00000000000..468c3f54aeb --- /dev/null +++ b/pymc3/ode/__init__.py @@ -0,0 +1,2 @@ +from . import utils +from .ode import DifferentialEquation \ No newline at end of file diff --git a/pymc3/ode/ode.py b/pymc3/ode/ode.py new file mode 100644 index 00000000000..c90cd11200f --- /dev/null +++ b/pymc3/ode/ode.py @@ -0,0 +1,183 @@ +import numpy as np +from pymc3.ode.utils import augment_system, ODEGradop +import scipy +import theano +import theano.tensor as tt +THEANO_FLAG = 'compute_test_value=ignore' + + +class DifferentialEquation(theano.Op): + + ''' + Specify an ordinary differential equation + + .. math:: + \dfrac{dy}{dt} = f(y,t,p) \quad y(t_0) = y_0 + + Parameters + ---------- + + func : callable + Function specifying the differential equation + t0 : float + Time corresponding to the initial condition + times : array + Array of times at which to evaluate the solution of the differential equation. + n_states : int + Dimension of the differential equation. For scalar differential equations, n_states =1. + For vector valued differential equations, n_states = number of differential equations iun the system. + n_odeparams : int + Number of parameters in the differential equation. + + .. code-block:: python + + def odefunc(y,t,p): + #Logistic differential equation + return p[0]*y[0]*(1-y[0]) + + times = np.arange(0.5, 5, 0.5) + + ode_model = DifferentialEquation(func = odefunc, t0 = 0, times = times, n_states = 1, n_odeparams = 1) + ''' + + __props__ = () + + def __init__(self, func, t0, times, n_states, n_odeparams): + + if not callable(func): + raise ValueError("Argument func must be callable.") + if np.any(np.diff(times)<0): + raise ValueError("The values in times must be monotonically increasing or monotonically decreasing; repeated values are allowed.") + if n_states<1: + raise ValueError('Argument n_states must be at least 1.') + if n_odeparams<0: + raise ValueError('Argument n_states must be non-negative.') + + #Public + self.func = func + self.t0 = t0 + self.times = times + self.n_states = n_states + self.n_odeparams = n_odeparams + + #Private + self._n = n_states + self._m = n_odeparams + n_states + + self._augmented_times = np.insert(times, t0, 0) + self._augmented_func = augment_system(func, self._n, self._m) + self._sens_ic = self._make_sens_ic() + + self._cached_y = None + self._cached_sens = None + self._cached_parameters = None + + def _make_sens_ic(self): + + # The sensitivity matrix will always have consistent form. + # If the first n_odeparams entries of the parameters vector in the simulate call + # correspond to ode paramaters, then the first n_odeparams columns in + # the sensitivity matrix will be 0 + sens_matrix = np.zeros((self._n, self._m)) + + # If the last n_states entrues of the paramters vector in the simulate call + # correspond to initial conditions of the system, + # then the last n_states columns of the sensitivity matrix should form + # an identity matrix + sens_matrix[:, -self.n_states:] = np.eye(self.n_states) + + # We need the sensitivity matrix to be a vector (see augmented_function) + # Ravel and return + dydp = sens_matrix.ravel() + + return dydp + + def _system(self, Y, t, p): + """ + This is the function that will be passed to odeint. + Solves both ODE and sensitivities + Args: + Y (vector): current state and current gradient state + t (scalar): current time + p (vector): parameters + Returns: + derivatives (vector): derivatives of state and gradient + """ + + dydt, ddt_dydp = self._augmented_func(Y[:self._n], t, p, Y[self._n:]) + derivatives = np.concatenate([dydt, ddt_dydp]) + return derivatives + + def _simulate(self, parameters): + + # Initial condition comprised of state initial conditions and raveled + # sensitivity matrix + y0 = np.concatenate([ parameters[self.n_odeparams:] , self._sens_ic]) + + # perform the integration + sol = scipy.integrate.odeint(func=self._system, + y0=y0, + t=self._augmented_times, + args=tuple([parameters])) + # The solution + y = sol[1:, :self.n_states] + + # The sensitivities, reshaped to be a sequence of matrices + sens = sol[1:, self.n_states:].reshape(len(self.times), self._n, self._m) + + return y, sens + + def _cached_simulate(self, parameters): + + if np.array_equal(np.array(parameters), self._cached_parameters): + return self._cached_y, self._cached_sens + else: + return self._simulate(np.array(parameters)) + + def state(self, x): + + y, sens = self._cached_simulate(np.array(x, dtype=np.float64)) + self._cached_y, self._cached_sens, self._cached_parameters = y, sens, x + return y.ravel() + + def numpy_vsp(self, x, g): + + numpy_sens = self._cached_simulate(np.array(x, dtype=np.float64))[1].reshape((self.n_states * len(self.times), len(x))) + return numpy_sens.T.dot(g) + + def make_node(self, odeparams, y0): + + if len(odeparams)!=self.n_odeparams: + raise ValueError('odeparams has too many or too few parameters. Expected {a} paramteres but got {b}'.format(a = self.n_odeparams, b = len(odeparams))) + if len(y0)!=self.n_states: + raise ValueError('y0 has too many or too few parameters. Expected {a} paramteres but got {b}'.format(a = self.n_states, b = len(y0))) + + if np.ndim(odeparams) > 1: + odeparams = np.ravel(odeparams) + if np.ndim(y0) > 1: + y0 = np.ravel(y0) + + odeparams = tt.as_tensor_variable(odeparams) + y0 = tt.as_tensor_variable(y0) + x = tt.concatenate([odeparams, y0]) + + return theano.Apply(self, [x], [x.type()]) + + def perform(self, node, inputs_storage, output_storage): + + x = inputs_storage[0] + out = output_storage[0] + + # get the numerical solution of ODE states + out[0] = self.state(x) + + def grad(self, inputs, output_grads): + + x = inputs[0] + g = output_grads[0] + + # pass the VSP when asked for gradient + grad_op = ODEGradop(self.numpy_vsp) + grad_op_apply = grad_op(x, g) + + return [grad_op_apply] \ No newline at end of file diff --git a/pymc3/ode/utils.py b/pymc3/ode/utils.py new file mode 100644 index 00000000000..15d3767874a --- /dev/null +++ b/pymc3/ode/utils.py @@ -0,0 +1,81 @@ +import theano +import theano.tensor as tt + + +def augment_system(ode_func, n, m): + '''Function to create augmented system. + + Take a function which specifies a set of differential equations and return + a compiled function which allows for computation of gradients of the + differential equation's solition with repsect to the parameters. + + Args: + ode_func (function): Differential equation. Returns array-like + n: Number of rows of the sensitivity matrix + m: Number of columns of the sensitivity matrix + + Returns: + system (function): Augemted system of differential equations. + + ''' + + # Present state of the system + t_y = tt.vector('y', dtype=theano.config.floatX) + + # Parameter(s). Should be vector to allow for generaliztion to multiparameter + # systems of ODEs + t_p = tt.vector('p', dtype=theano.config.floatX) + + # Time. Allow for non-automonous systems of ODEs to be analyzed + t_t = tt.scalar('t', dtype=theano.config.floatX) + + # Present state of the gradients: + # Will always be 0 unless the parameter is the inital condition + # Entry i,j is partial of y[i] wrt to p[j] + dydp_vec = tt.vector('dydp', dtype=theano.config.floatX) + + dydp = dydp_vec.reshape((n, m)) + + # Stack the results of the ode_func + # TODO: Does this behave the same of ODE is scalar? + f_tensor = tt.stack(ode_func(t_y, t_t, t_p)) + + # Now compute gradients + J = tt.jacobian(f_tensor, t_y) + + Jdfdy = tt.dot(J, dydp) + + grad_f = tt.jacobian(f_tensor, t_p) + + # This is the time derivative of dydp + ddt_dydp = (Jdfdy + grad_f).flatten() + + system = theano.function( + inputs=[t_y, t_t, t_p, dydp_vec], + outputs=[f_tensor, ddt_dydp], + on_unused_input='ignore') + + return system + + + +class ODEGradop(theano.Op): + + def __init__(self, numpy_vsp): + + self._numpy_vsp = numpy_vsp + + def make_node(self, x, g): + + x = theano.tensor.as_tensor_variable(x) + g = theano.tensor.as_tensor_variable(g) + node = theano.Apply(self, [x, g], [g.type()]) + return node + + def perform(self, node, inputs_storage, output_storage): + + x = inputs_storage[0] + + g = inputs_storage[1] + out = output_storage[0] + out[0] = self._numpy_vsp(x, g) # get the numerical VSP diff --git a/pymc3/tests/test_ode.py b/pymc3/tests/test_ode.py new file mode 100644 index 00000000000..a359f8a9ced --- /dev/null +++ b/pymc3/tests/test_ode.py @@ -0,0 +1,497 @@ +from ..ode import DifferentialEquation +from ..ode.utils import augment_system + +import numpy as np +from scipy.integrate import odeint +from scipy.stats import norm +import pymc3 as pm +import theano +import theano.tensor as tt +import pytest + + +def test_gradients(): + with theano.configparser.change_flags(compute_test_value='off'): + '''Tests the computation of the sensitivities from the theano computation graph''' + + # ODE system for which to compute gradients + def ode_func(y, t, p): + return np.exp(-t) - p[0] * y[0] + + # Computation of graidients with Theano + augmented_ode_func = augment_system(ode_func, 1, 1 + 1) + + # This is the new system, ODE + Sensitivities, which will be integrated + def augmented_system(Y, t, p): + + dydt, ddt_dydp = augmented_ode_func(Y[:1], t, p, Y[1:]) + derivatives = np.concatenate([dydt, ddt_dydp]) + return derivatives + + # Create real sensitivities + y0 = 0.0 + t = np.arange(0, 12, 0.25).reshape(-1, 1) + a = 0.472 + p = np.array([a, y0]) + + # Derivatives of the analytic solution with respect to y0 and alpha + # Treat y0 like a parameter and solve analytically. Then differentiate. + # I used CAS to get these derivatives + y0_sensitivity = np.exp(-a * t) + a_sensitivity = -(np.exp(t * (a - 1)) - 1 + (a - 1) * + (y0 * a - y0 - 1) * t) * np.exp(-a * t) / (a - 1)**2 + + sensitivity = np.c_[a_sensitivity, y0_sensitivity] + + integrated_solutions = odeint(func=augmented_system, + y0=[y0, 0, 1], + t=t.ravel(), + args=tuple([p])) + simulated_sensitivity = integrated_solutions[:, 1:] + + np.testing.assert_allclose( + sensitivity, simulated_sensitivity, rtol=1e-5) + + +def test_simulate(): + with theano.configparser.change_flags(compute_test_value='off'): + '''Tests the integration in DifferentialEquation''' + + # Create an ODe to integrate + def ode_func(y, t, p): + return np.exp(-t) - p[0] * y[0] + + # Evaluate exact solution + y0 = 0 + t = np.arange(0, 12, 0.25).reshape(-1, 1) + a = 0.472 + y = 1.0 / (a - 1) * (np.exp(-t) - np.exp(-a * t)) + + # Instantiate ODE model + ode_model = DifferentialEquation(func=ode_func, + t0=0, + times=t, + n_states=1, + n_odeparams=1) + + simulated_y, *_ = ode_model._simulate([a, y0]) + + np.testing.assert_allclose(y, simulated_y, rtol=1e-5) + + +class TestSensitivityInitialCondition(object): + + t = np.arange(0, 12, 0.25).reshape(-1, 1) + + def test_sens_ic_scalar_1_param(self): + with theano.configparser.change_flags(compute_test_value='off'): + + '''Tests the creation of the initial condition for the sensitivities''' + + # Scalar ODE 1 Param + # Create an ODe to integrate + def ode_func_1(y, t, p): + return np.exp(-t) - p[0] * y[0] + + # Instantiate ODE model + # Instantiate ODE model + model1 = DifferentialEquation(func=ode_func_1, + t0=0, + times=self.t, + n_states=1, + n_odeparams=1) + + # Sensitivity initial condition for this model should be 1 by 2 + model1_sens_ic = np.array([0, 1]) + + np.testing.assert_array_equal( + model1_sens_ic, model1._make_sens_ic()) + + def test_sens_ic_scalar_2_param(self): + with theano.configparser.change_flags(compute_test_value='off'): + + # Scalar ODE 2 Param + def ode_func_2(y, t, p): + return p[0] * np.exp(-p[0] * t) - p[1] * y[0] + + # Instantiate ODE model + model2 = DifferentialEquation(func=ode_func_2, + t0=0, + times=self.t, + n_states=1, + n_odeparams=2) + + model2_sens_ic = np.array([0, 0, 1]) + + np.testing.assert_array_equal( + model2_sens_ic, model2._make_sens_ic()) + + def test_sens_ic_vector_1_param(self): + with theano.configparser.change_flags(compute_test_value='off'): + + # Vector ODE 1 Param + def ode_func_3(y, t, p): + ds = -p[0] * y[0] * y[1] + di = p[0] * y[0] * y[1] - y[1] + + return [ds, di] + + # Instantiate ODE model + model3 = DifferentialEquation(func=ode_func_3, + t0=0, + times=self.t, + n_states=2, + n_odeparams=1) + + model3_sens_ic = np.array([0, 1, 0, 0, 0, 1]) + + np.testing.assert_array_equal( + model3_sens_ic, model3._make_sens_ic()) + + def test_sens_ic_vector_2_param(self): + with theano.configparser.change_flags(compute_test_value='off'): + + # Vector ODE 2 Param + def ode_func_4(y, t, p): + ds = -p[0] * y[0] * y[1] + di = p[0] * y[0] * y[1] - p[1] * y[1] + + return [ds, di] + + # Instantiate ODE model + model4 = DifferentialEquation(func=ode_func_4, + t0=0, + times=self.t, + n_states=2, + n_odeparams=2) + + model4_sens_ic = np.array([0, 0, 1, 0, 0, 0, 0, 1]) + + np.testing.assert_array_equal( + model4_sens_ic, model4._make_sens_ic()) + + def test_sens_ic_vector_3_params(self): + with theano.configparser.change_flags(compute_test_value='off'): + + # Big System with Many Parameters + def ode_func_5(y, t, p): + dx = p[0] * (y[1] - y[0]) + ds = y[0] * (p[1] - y[2]) - y[1] + dz = y[0] * y[1] - p[2] * y[2] + + return [dx, ds, dz] + + # Instantiate ODE model + model5 = DifferentialEquation(func=ode_func_5, + t0=0, + times=self.t, + n_states=3, + n_odeparams=3) + + # First three columns are derivatives with respect to ode parameters + # Last three coluimns are derivatives with repsect to initial condition + # So identity matrix should appear in last 3 columns + model5_sens_ic = np.array([[0, 0, 0, 1, 0, 0], + [0, 0, 0, 0, 1, 0], + [0, 0, 0, 0, 0, 1]]) + + np.testing.assert_array_equal( + np.ravel(model5_sens_ic), + model5._make_sens_ic()) + + +def test_logp_scalar_ode(): + with theano.configparser.change_flags(compute_test_value='off'): + + '''Test the computation of the log probability for these models''' + + # Differential equation + def system_1(y, t, p): + return np.exp(-t) - p[0] * y[0] + + # Parameters and inital condition + alpha = 0.4 + y0 = 0.0 + times = np.arange(0.5, 8, 0.5) + + yobs = np.array([0.30, + 0.56, + 0.51, + 0.55, + 0.47, + 0.42, + 0.38, + 0.30, + 0.26, + 0.21, + 0.22, + 0.13, + 0.13, + 0.09, + 0.09]).reshape(-1, + 1) + + ode_model = DifferentialEquation(func=system_1, + t0=0, + times=times, + n_odeparams=1, + n_states=1) + + integrated_solution, *_ = ode_model._simulate([alpha, y0]) + + manual_logp = norm.logpdf( + x=np.ravel(yobs), + loc=np.ravel(integrated_solution), + scale=1).sum() + + with pm.Model() as model_1: + + forward = ode_model(odeparams=[alpha], y0=[y0]).reshape(yobs.shape) + + y = pm.Normal('y', mu=forward, sd=1, observed=yobs) + + pymc3_logp = model_1.logp() + + np.testing.assert_allclose(manual_logp, pymc3_logp) + + +class TestErrors(object): + + '''Test running model for a scalar ODE with 1 parameter''' + def system(y, t, p): + return np.exp(-t) - p[0] * y[0] + + times = np.arange(0, 9) + + ode_model = DifferentialEquation( + func=system, + t0=0, + times=times, + n_states=1, + n_odeparams=1) + + def test_too_many_params(self): + with pytest.raises(ValueError): + self.ode_model(odeparams=[1, 1], y0=[0]) + + def test_too_many_y0(self): + with pytest.raises(ValueError): + self.ode_model(odeparams=[1], y0=[0, 0]) + + def test_too_few_params(self): + with pytest.raises(ValueError): + self.ode_model(odeparams=[], y0=[1]) + + def test_too_few_y0(self): + with pytest.raises(ValueError): + self.ode_model(odeparams=[1], y0=[]) + + +class TestDiffEqModel(object): + + def test_scalar_ode_1_param(self): + '''Test running model for a scalar ODE with 1 parameter''' + with theano.configparser.change_flags(compute_test_value='off'): + def system(y, t, p): + return np.exp(-t) - p[0] * y[0] + + times = np.array([0.5, 1., 1.5, 2., 2.5, 3., 3.5, + 4., 4.5, 5., 5.5, 6., 6.5, 7., 7.5]) + + yobs = np.array([0.31, + 0.57, + 0.51, + 0.55, + 0.47, + 0.42, + 0.38, + 0.3, + 0.26, + 0.22, + 0.22, + 0.14, + 0.14, + 0.09, + 0.1]).reshape(-1, + 1) + + ode_model = DifferentialEquation( + func=system, + t0=0, + times=times, + n_states=1, + n_odeparams=1) + + with pm.Model() as model: + + alpha = pm.HalfCauchy('alpha', 1) + y0 = pm.Lognormal('y0', 0, 1) + sigma = pm.HalfCauchy('sigma', 1) + forward = ode_model( + odeparams=[alpha], + y0=[y0]).reshape( + yobs.shape) + + y = pm.Lognormal('y', mu=pm.math.log( + forward), sd=sigma, observed=yobs) + + trace = pm.sample(100, tune=0) + + assert trace['alpha'].size > 0 + assert trace['y0'].size > 0 + assert trace['sigma'].size > 0 + + def test_scalar_ode_2_param(self): + '''Test running model for a scalar ODE with 2 parameters''' + with theano.configparser.change_flags(compute_test_value='off'): + def system(y, t, p): + return p[0] * np.exp(-p[0] * t) - p[1] * y[0] + + times = np.array([0.5, 1., 1.5, 2., 2.5, 3., 3.5, + 4., 4.5, 5., 5.5, 6., 6.5, 7., 7.5]) + + yobs = np.array([0.31, + 0.57, + 0.51, + 0.55, + 0.47, + 0.42, + 0.38, + 0.30, + 0.26, + 0.22, + 0.22, + 0.14, + 0.14, + 0.09, + 0.10]).reshape(-1, + 1) + + ode_model = DifferentialEquation( + func=system, + t0=0, + times=times, + n_states=1, + n_odeparams=2) + + with pm.Model() as model: + + alpha = pm.HalfCauchy('alpha', 1) + beta = pm.HalfCauchy('beta', 1) + y0 = pm.Lognormal('y0', 0, 1) + sigma = pm.HalfCauchy('sigma', 1) + forward = ode_model( + odeparams=[ + alpha, + beta], + y0=[y0]).reshape( + yobs.shape) + + y = pm.Lognormal('y', mu=pm.math.log( + forward), sd=sigma, observed=yobs) + + trace = pm.sample(100, tune=0) + + assert trace['alpha'].size > 0 + assert trace['beta'].size > 0 + assert trace['y0'].size > 0 + assert trace['sigma'].size > 0 + + def test_vector_ode_1_param(self): + '''Test running model for a vector ODE with 1 parameter''' + with theano.configparser.change_flags(compute_test_value='off'): + def system(y, t, p): + ds = -p[0] * y[0] * y[1] + di = p[0] * y[0] * y[1] - y[1] + + return [ds, di] + + times = np.array( + [0.0, 0.8, 1.6, 2.4, 3.2, 4.0, 4.8, 5.6, 6.4, 7.2, 8.0]) + + yobs = np.array([[1.02, 0.02], + [0.86, 0.12], + [0.43, 0.37], + [0.14, 0.42], + [0.05, 0.43], + [0.03, 0.14], + [0.02, 0.08], + [0.02, 0.04], + [0.02, 0.01], + [0.02, 0.01], + [0.02, 0.01]]) + + ode_model = DifferentialEquation( + func=system, + t0=0, + times=times, + n_states=2, + n_odeparams=1) + + with pm.Model() as model: + + R = pm.Lognormal('R', 1, 5) + sigma = pm.HalfCauchy('sigma', 1, shape=2) + forward = ode_model( + odeparams=[R], y0=[ + 0.99, 0.01]).reshape( + yobs.shape) + + y = pm.Lognormal('y', mu=pm.math.log( + forward), sd=sigma, observed=yobs) + + trace = pm.sample(100, tune=0) + + assert trace['R'].size > 0 + assert trace['sigma'].size > 0 + + def test_vector_ode_2_param(self): + '''Test running model for a vector ODE with 2 parameters''' + with theano.configparser.change_flags(compute_test_value='off'): + def system(y, t, p): + ds = -p[0] * y[0] * y[1] + di = p[0] * y[0] * y[1] - p[1] * y[1] + + return [ds, di] + + times = np.array( + [0.0, 0.8, 1.6, 2.4, 3.2, 4.0, 4.8, 5.6, 6.4, 7.2, 8.0]) + + yobs = np.array([[1.02, 0.02], + [0.86, 0.12], + [0.43, 0.37], + [0.14, 0.42], + [0.05, 0.43], + [0.03, 0.14], + [0.02, 0.08], + [0.02, 0.04], + [0.02, 0.01], + [0.02, 0.01], + [0.02, 0.01]]) + + ode_model = DifferentialEquation( + func=system, + t0=0, + times=times, + n_states=2, + n_odeparams=2) + + with pm.Model() as model: + + beta = pm.HalfCauchy('beta', 1) + gamma = pm.HalfCauchy('gamma', 1) + sigma = pm.HalfCauchy('sigma', 1, shape=2) + forward = ode_model( + odeparams=[ + beta, gamma], y0=[ + 0.99, 0.01]).reshape( + yobs.shape) + + y = pm.Lognormal('y', mu=pm.math.log( + forward), sd=sigma, observed=yobs) + + trace = pm.sample(100, tune=0) + + assert trace['beta'].size > 0 + assert trace['gamma'].size > 0 + assert trace['sigma'].size > 0 From 5b88886310be12a6d311e1d72b694aabd44ab02c Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Thu, 1 Aug 2019 16:34:24 -0400 Subject: [PATCH 03/45] re run existing ODE notebook to comare against pymc3.ode --- .../notebooks/ODE_parameter_estimation.ipynb | 321 ++++++++---------- 1 file changed, 143 insertions(+), 178 deletions(-) diff --git a/docs/source/notebooks/ODE_parameter_estimation.ipynb b/docs/source/notebooks/ODE_parameter_estimation.ipynb index 04cbb7ff77e..c4e4f9df731 100644 --- a/docs/source/notebooks/ODE_parameter_estimation.ipynb +++ b/docs/source/notebooks/ODE_parameter_estimation.ipynb @@ -4,7 +4,15 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING (theano.configdefaults): install mkl with `conda install mkl-service`: No module named 'mkl'\n" + ] + } + ], "source": [ "from scipy.integrate import odeint\n", "import numpy as np\n", @@ -332,7 +340,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4YAAAHyCAYAAAC3X9DzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdd5wURd4/8M93EyyLZFhyzlEkHCZAFIxIkCiIJ5jBu+fu56PenfEO79RTnzsxnJwKHCJRgsqBYkJQkSSSk0gOS2Zh8279/qjume5JO7s7Mz0z+3m/XvParerq7u/M9HR3dVdXiVIKREREREREVH4lOB0AEREREREROYsVQyIiIiIionKOFUMiIiIiIqJyjhVDIiIiIiKico4VQyIiIiIionKOFUMiIiIiIqJyjhVDoggQkc4iUigiG0VEnI4nXETkuIgoERnldCzhIiLPGu/xT07HQv6JyMvG9/Rbp2OJNBGZbrz3MU7HEg1E5Cbj88gJ1TQKnfJw3Ag1EVljfGZPOB0LxRdWDCmkLCfNHCDT7hXo39szioOHlpiIPGpsWx2djgXAPwCcB/C4iNRxMhARedD8vYlI3WLKVrSUjeuTCRFpDuARAEcBvO1wOE6YDKAQwPMiUtHpYMhORGoZ+7NnRaSy0/EQEZlYMSQKMxG5GcANADYopT52Op4Y9SiAZwA4XjFUSp2DrhxeBuBZZ6MhP/4GIAXA35RS5e5uj1JqL4D3ATQB8BuHw4kGFwHsMl7RoBb0/uwZAKwYUmnsh96eTzscB8UZVgyJwu9x4+9bjkZBoTQVQBGA8SJS0+lgyM24WzgcQDaAGQ6H46R/GX9/JyJJjkbiMKXUaqVUW6VUF6djIQoFpdQoY5v+t9OxUHxhxZAojESkLYA+AHIALHA4HAoRpdRRAF8BqADg185GQx7uByAAliilMp0OxilKqTUA9gKoC2CQw+EQEVEMYMWQHCUidUQk13ju6fZiyv7dKLfDkmd9bqqXiFQVkb+JyG4RyRaRUyKyRES6+VheqohsM+b9VkQS/ax3sVHmgIhUL+FbvM/4+1+l1Hk/y59jLP9fIpIgIpNEZL2IXDBe34jIiACfi+shdBGpICKPG53cnDc/F4/yFUTkERFZaXw+eSJyTEQWiUj/QG9GRCoZz8XsND7fEyLysYj0Ke6DEJEuIvJnEflKRPYZ8583Yn1ORGr4mOcF43nVdCNrtuX79tdhRKrxTOIaETknIjki8ouITAv0jKK1AwQRqSIizxvbx0U/z/B9YPy9z3NZsUhEaojI/SKyQES2ishZ47PbLyLvi0iPAPO+YHxGy430SBH5QkROikiRr2caRWSQsc0dNbbBMyLytYjcV9o7XMZ89xjJD/yU8dxnNBCRt4z3mWPE8x8Raeln/raW+euKSGsRedeYP1dEdvqYp4WITBGRHcb2lGX8/6qINPRR3tznLCzm/XawvhcfRWYbf+8PtJyyEpE2IjJVRH62/K7Xi8gfJcAzdCLSREReE5HtInLJ+PyOGPO+IiJXBJj3FhGZJyIHje/ttIj8JCL/9NxWJQydyIjeV/cXkddF5Acj7jzR+9Sv/G3HIrIGwA5L1jGPfdpyH/PUN7aVHcbndFFEtog+1tX2E1+x26mU8fhbgs+qxMcNEfkfY30nRCQ5QLkk4zdre3Za3M9f7zTSPUXkQ9H7+VwR2SsiL4lIFT/LTRGRISLyjohsMObLM+JZJiLDA8Rk295EpKuxrR4zfvvbjPeXYJmnj/GZHDe2580i4vd3K0F0PiMiHUWfV+w0tpmLxv8fGO9NPMrXEn3c2yQimcb7PW78rt4I9H1RHFFK8cVXyF7Qz1wpvWkFPc8cY55PApRJAZBhlPu9Jb+iuT7o5mO/GP9nA8iyTMsB0NfHcjsZZRWAv/iYPsmYVgDgmlJ8HtuM+f8niPf/NoBFlvWdgW6uaL6Ht/zMv8aY/mcAa43/8wGcNf7vZSnbAsBOyzKLoDtSUZbXP/yspzaALZZyeQDOGf8XAhgP4LiRHuVj/uOWebOgn42wvr8DAFp4zPMnY75Co8w5I22+9nuUbwJ90mUuM9cSo/m53u/n/Znx/RbAzz7mr+tRvqVluc0c+r09aImhbjFlrb+VJ3xMf8HjczptvH8zrxDAA36Wbc67HMAblm3rjLGsJyxl0wAs8djmzntsC98AqFKKz6OHZd3Vg/gcxsG9X7kE/SyasqT7+Zi/raXMKKOcMua9BGCnR/nxxm/FnCcb7n2Ogv6d9vWY5ya4f8d+v1foZ10VgJ/8TL8B7v1fRR/Tb7LE4fWbDfIzH+vx/s4b6zPT+wC08jFfd9j3Pfnw3uf9y8d8lQEs9rH9WJe1xs/7zAnwGZR0WluPGC7Ae1/6BYAKHvMtBXDSUiYD9n3aBz6+wwuW8uZ2ZqZPAvhVabdTlOH4G+T2UarjBoDqcB/DhwVY/mDLctMt+ea+cSd0q458uI8hhZZ4fgSQWsxvwzxOZnp8vzMBSKDtBvpuvbkfPQv79j3NKD/RiKkI9uOVAvCsn/dtHve99uXG9Kc91pUF/fuyvveKlvJNARyxTCv0UX55afYRfMXWy/EA+IqvF0pXMewD98loQz9lhlt2tDUt+daTvDMAfgLQG7opWQKAXtDNqRT0g9q+duIPW3aEfSz5neE+gXumFJ9FLcuO+aoA5cwDs3nAegxAZWNaOvTzbOZ79KrUWA4QmcYyxpo7fOiDcjXj/yqWz2IFgGsApBjTqgP4X7hPHrwqAAD+aznAjIdxwgOgGYCPje/G/Lx8VQw/AHCX9TuGboo5AMB6Y77v/HxGfiucljLJADYa5U4DGAkg2ZjWCsCnlu/Z1wm/uY5MAIcADASQZExrDI8TPCP/lDHPrx36vYWyYjgJwFMAulq2C4GuAJuVvXwAHXzMa1YMM41t/i8wfqfGehtbys43yu42vqPLjPxUAEOhO1VQAGaX4vP4f+ayg/wczkFfBLgOxr4BwFUAtlu2I88LAtYT7kwAqwB0tUxvbfn/NuPzyIXuKbQx3Pum9nBfCDoDoJ5lPoH74sQf/LyPCkZ8CsBEP2Wqwr0P6utjepkqhtD7V/OE+ysA7Y38RABD4K5MbIfHyTeA1ca0NdAVevPzTwHQGno/6HVBDe5KYYGxnTWwTKsNvY+Z4ud9hrJi2AL6GdZbYLkIAb2fnQD3/uSvPua1bkOBKv7N4K4U/gTjIp+xfVwH9/78BIA6pdlOUYbjb5DbSKmPGwCmGfmfBlj+UqPMfI98c9+YCV1pfNPcVqAvTv2PZdv9o4/lXgu93+sHYx9l5NcC8Hu4LyL5Oiab202B8f39x/xsje3jFct387hR7mUAtYwyNQHMgnuf29THOvxWDAH8zrL8BQA6W6alGfEtgOWYBt1ZlQKwB0BfAIlGfhJ0pXEigMkl3UfwFXsvxwPgK75eKEXF0JjPPBF7xs/0Fcb0WR751pO8owBq+Ji3h6VMNz/LN0/QDgGoAX2Sat7t+8bcSZbwPd1iWW9agHJzLOW8DlBGGfNk+hiMyo5l2hrL/P0DrOd5o8xnMCo8PsqMNsocAZBgye9tWcedPuZLgvtuZYlPMqFPYM2T3O4+pgdTMbwb7qu7fXxMT4G74rguwDry4KPy42ednxvzvF3W305pXrBXDD3vPPh6mWV9XmUuZl3vGPO+7mOa9W7j8wGW0d+yfdXzU6YZ9IliEYB2JYxxHnycJHqUse4zsgC09FGmPtx3f17xmGY94d4DH3cbLL+J/Ua5cX7KCPRdVgXgBY9pjxv5P8P3Ba0xxvRLAKoGeL9m5cGrgomyVwy/MubdBt93JH8F9x2HSR7vu8DI71qC9d1qifeeEswX8ophEOu8Bu6LD0ke04KtGE6z/LZr+ZjeFO4Kysul2U6NsqU6/gbxGZTpuGFsP+Y+vamP+RtZtq/+HtOs+0avO89GGfOC15ZSfL9jjXm3BthuFICP/Mz/g6XMFB/TkwEcNqY/6mO6z4oh9MUR8wLv9BK8n33GPENK+lnwFV8vPmNI0cLsQW+Ctd094Opl8HojGWhMsjeVUmc8M5VS66ArVIC+C+jLBOidcEMA7wH4J/QV/bMAxiilCoN5Ex7qG3+zlVKXgiifCd00zJc/G3/rQl/N82WDUmpFgOWPN/6+rJQq8FNmPvQV3PrQzWxN5sDDPyulvJ7dMpY3OcC6A1L6+cvVRvKaUi5mpPH3a6XUSh/ryIO+wwAA3UWklZ/lfKSU2hbkOk8Zf+sHLBUZtaHvMAd6lcVS42+g7ycf+sq3PxOMvzOUUsd8FVBK/QK9LQj03eSSML+Hk0GW/0DpoR08YzgKXREG3Nu+L/9USmX7mXYDdNPmI9BNzrwopZRl2o0ek9+DvkjR3FiWJ/PZ1rnKz/PLBr/bqFJquVJKjNecAMvwIiLpcO+LXlQ+hgVRSv0A4BMjOdqSr6DvpABAvRKs1tyHbVBKTStJvJGmlFoNfXGhKkoxzI7oZ96HGcnXlVKnPMsopfYDeNdIjvacbhFoOwVCc/z1pUzHDWP7+RF6X+DrWe4J0Hfff4a+SOfP837ylxh/2/l6HrQY5v6wgwTue+BFP/mfWf5/wXOiUiof+sIL4P+8xZdRACpBt1J4tATznTP+luT3SHGIFUOKFv+BvnrfCPpqm9UE6APDTqXUNwGW8UOAaUeNv14dnACAUaEcA331cRDcB6H7lFKHAoful9kpgFdl1Y81SqksP/FtgfsEr7uf+b/1t2ARaQFdqQSA940Hyr1e0JXjFKNcE8sizHV+GSB+8+6BX6I7HFkgujOYLGunCwDMzg+8OuMIkhljoBOELywxlvhz9MH8bn12ABFh9Swn+V4v6LvgAYlIK6OTi42iO+4ptHw/Zkcogb6fHUqpswGmX238fdjfNmhsh2bls4mf5fhT0t9coO3ZnFZfRPydLAXaVsz3Whu6gxF/73WKUc72XpVSJwF8aCRtJ8Ui0hq6CSCgm5oHEq5t1NqhV6DfnHmxqptHZxdmhXG20QnItSJS3DZ6lfE3KsaDFd2R0UQRWWF0LGJ25GL+ZqoaRUuzT2sD9xiHwXy+pd1OgdAcf30JxXHDrLTeY628GRVY80LBO8bFBl+OBjiGm+cFiXB/Vy6iO7N7QnQHcCeNzljM79a6j2kQIP51fvJPWOI7UkyZknR6Z/5Gvvd1MSEA8/f4qoi8KbpjpctKMD/FiXI9thFFD6XUORGZC92j4P3QzyV49jJY3AlQoK7pzTtkfns3U0p9IyL/gm5LD+i7Gh/6Kx+Eisbf3CDL+zs4WKfXAlDHz/SMAPNa7xYEe4JYyfK/uU6/MSqlMkXkAnwfYJOgm8zeYck2O5vIN9JVoT+ztCDjsy4/AfqzKS7GC5YYS/M5ejKvwlcMWMqDiCyF/cTatEcpdW1JlhUqIjIS+gQxxZJ9Hu6OE1KgT1ACfT9+PzujUmCeuFaFj+3Eh0rFF7EJ5W/OOq0O3K0OrIL5zaUguLu1vt7rv6DvBA0SkdpGZRFwVxQ3Kz0sRSCl2kaDYP5+iuD7szEdNv5WgH6+yry7+TvoZsPXQD/f/L8ACkTkR+iT1H9b7yob24+5zgOheANlYVTCvoRusmnKhr6AZ7YwqQ19Ab7E+zTY90+BttPDlv9Ls52G6vjrS5mOG4YPoFsh1IN+ZnexkX8zdEU2H7rJrT/BnBcAHucGItIeukJurWxfgr6zVmSkzd+1v+8312ipEmjdZTpv8cG8AFzS38jz0He2hwB4yHgVichWAMugK99erSso/vCOIUUTcwD4W0XEPKm6DXrHnIswD1YtIrWgd4qmHkFcwQ7ktPG3pENclFag5q7WoTiaBbqzVNqmZcV4CLpSWADdW1pL6GeSaiql6iql6sJ9xVL8LCNSStJs2LwDfTpgKW814buppyN3HkUPxfEudCXmU+iOF1KVUtWUUunG93OXWTzAogJ9dmKZ954gt8EHS/hWovE3tzLI9+pVcTPu0GyH/l7uAXQ3+tDP0wLBnayXdhsNK6XUaeMiSF/oE//voU+4ewB4DsAeEbnDc7aIBhnY69CVwgzo3m3TlVKVlFK1Lfs0865SLOzTHD3++qOUugh3c2vr8A3mxZElSqkTCL2Z0O99L3SnWDWUUpWVUnWM77aFpazT369VqX4jSqlcpdRQ6AuWkwF8Df1YSWfo5513iMikUAVJ0YsVQ4oaxrOAG6HvZJtXKc2d/wJfzw+G2DToq/wHoa9qtwfwf2VYnnl1v6rncxt+BGqOArjvQJTkjpbpuOX/kjbPs67Tb4xGsxOfY0LB/azJG0qpvyilflZKFXmU8RwnMGjGssxmM36bbYkes8qMsTSfoyfzpDvYZ9oAAEqpXn4qB22LnzssBkJf9T4BYLBSarWPZ8ZK/f0Aru/I/JxKsw0Gw1y+zybjPgT6zVmnleU3V9b3ajalu9f4Owj6AkIWdE+CxSnVNhoE8zNJQOBnbM3fYy7czxW6KKVWKqX+Vyl1FYBq0CfhO6C3xxlijG9qNBU01xmu7ScoIlIJ+jcD6B6cZyqlMjzKVIB+P6VlXV6gpqjWaaXep4Xp+FvW44bJ/A3cKCKNjbu1txp5JX3usVjG8+fmGJrDlVKLfDSRL9P+MIzKtN9RSm1USj2llLoOevu9EfqiTRKAf4qIU8coihBWDCnamFct7xWRJnA/71CaZixBE5FHoK+OFkI33XrAmPSAiAzxO2Ng242/CdC9xxWnl787lKIHZjfvJq0vRSy74K44DQxU0A9znX0DlOkL/1dOGxl/f/Q1UUSqwXfTSpNZiQx0ZdaM8foAZfpZluHv2Y+SaGb8LfGgz1HG/H52+OpExOCrA5SSMp91ui0Ey/LF/M01D7L8dUFMO6r8dJRTDPO9NjV+v6VlPv/VSkSuQ/CdzpjNL80TxFBvoxss/wf6zZnbzfoAz4EBAJRS2UqpRQBGGFlpAK60FPnO+FuafVgo1YW7eZ/PfRr0/tDf4zrWi2L+9mm7oHscBYL7fI+Ucju1CvXxt6zHDQCuZ+y/hT6WToCuuCZBdzrzRSljC8TcHxYB2OynTCj2h+Fg/kauNFpBlZpSKl8p9Rl0D+uF0J9/oG2R4gArhhRtZkNfVW4KfUKUgNI99B40EekM4O9G8s9Kqe+UUnOhewUEgHdEpJHvuQPaAndPXz2DKH8Z9ODqvjxp/D0B3cSjRIwTMrOXxQeLO1E1r9JbzDX+thIRr14ajWdR/hhgkeYJbBc/059D4M5RzDsNga7Am01f+4pIH8+JIpIM9+e4vqzPS4hIZQAdjKRXL6gxxvx+2hpNFW1EpCfcPSSWhXmC2V1E7glUUEQuk5L3FGjuJ64Q3atjccaI7nXRc9114e5Bda7n9CB9Ct36AAD+Udx78fGbA+DqsXe2kfwz3CekwZyst4X72a2QbqNG8z2z18THRcSrKayI9ID7IsBsS35SMa0orD1oWitRZg+c3YrbfsLMWiH32qcZv6G/eOZbWO+c+tynKd0T9nwjOdHXSb5ReTO309me00sh1Mffsh43rMy7huPhvnseqNOZsjC/3wT46FHWuJD5hzCsNxTmQF9IqoDAPUS7iBboOcZcuJsje7b0oTjDiiGFjYjUKubldUBUelgH83mC3sbfsN0tNJoEzYHeia6CvVvr30Bfta0B3ZNniX4vRtM584D6qyBmOQ9gsog8KiJpRnx1ROQtuIdieFbpbqxL4wXo95MG4BsReVAs3WyLSHURuU1EZsHjKqzSwz+Y3Wu/KyK/NisQItIUuvfErtDPJPiy3Pg7yWPe+iLyBvRnHegZqK3G3xEi4q+Tgtlwd22+UERGmCfjItISumvyboBrUOGy6g69D82FHlMqln1q/K0L3XyvHqCbw4nIndCdDwS8OxUMpdSncJ/AviO6N8qm5nTRvTxeJSKvQHeeUNKmeN9An7ikIbghAvIAfCYifS0x9ILudKIa9IWdv/ueNTCj04kHjXiuB/CViPQVe8+KLUX3arkR7h4WfTFPiq+B3r6D6XQGcO93Dio9tIGNiNwk7l40Aw3L4c8foU8Y2wP4r4i0M5abKCKDoHsPTYS+W/meZb6WAHaJyB9EpLPldyoi0hXu59kuwNKjplJqGdydj/xbRP5ieR4OIlJbRB4Q3YlY2CilTsN9N+w1Eelt3J2FiFwO/XvqAHsF1zr/cbhbcIwPcBHjL9Cdk9QB8LmIuI4jxsWvFdA9l2aglNupR1whPf6G4LhhNR/6GNEQuqVGcZ3OlMVPcDfJnGF8p+b2eS30RZbK/mZ2ktI9kZqV7btF9wLuGnpKRNJE5HYR+UR0c2dAn//sF5HJItLTkm/2gPwB9HPOBbAPs0HxSEXBYIp8xc8LlgHug3ht8rOMjpYyOfAxaL2lrHWw6l4ByvkbDHaqkX8GQCMf83WFu1fGp0rxeYwy5t0boIw5wP3bABYZ/xcYMRVZ3t9U+B7o2ud787OuRtAnNOYyi6DHarzg8d14DfgLfXKyzVIm15hXQZ8cjoefgeihO1vZa5m3wDKvgh6/0fwcvAYjhntgdAV9QnAEevDwXR7lmgDY6bH9nPVY7wN+PhufsQf4LF81ys928PdmHcTZ70DZPn4rXtuK8R1Yt4Fz0BUnBWA3dAcbCr4HAjcHuF8eRMwVoe9GWNeVaWzvhR75NUvxmZgDxvv8vXp8DuOgT6oVdLO9TMu0LHgMmm3MH9Tg5JbyI+AehFwZn+kpuPcr5uv/FbOcdZayE4P8LBYa5f/mZ3qZBrg3lnGXZTsxt5tsS3ofgFYBPkPzN33KYznZAG73sb7KAD7ysa2et6TX+HmfIRvgHrqJa5ZHvOb2k2d87373KdAdfFjnPQi9T5vhUa4/7PvnTI/t6RSAX5V1O7XMF/TxN8jllfq44WNZf7csZ34xZc19484AZfx+RtCdpVn3R5cs3/cF2I9JvTzm9bvdlDA+v/tVFHPchz4XK/KI/7THe6polLXuE83j5GnYf8eFAB4sy7bAV2y8eMeQoo5Saivcz8OErdMZ0T3emc/r3K98jHWklPoRwBNG8hkRucqzTDEWQnf60MK4ExGIgj4Y/Qb6imUy9M78WwCjlVL3K2MvXlrGe+wFfTL3CfQBOc1Y1y/Qd9UegY/nJ5TuXKEn9FXs3XCf0C0F0E8p9Z7nPJZ5T0PfvXgd+gTIPPh8DmCYUup/iol7BXSnG19CH5TrQlcCm3iUOwDdacBjANZCn4RUMtY5A0BXpVSZOysw7h6bd1hC3vmBE4zvYAL0hYNs6Gd4dkN/31cgNJ31QCmVo5QaBz0O33+gKw6J0Cf8J6C/42cBdDC2m5Iyv48xQZTdDX3x523oE6EU6N/E+wAuN7a7MlFKzYO+Q/YX6M/2EvTdyGwAm4x13w7gtWIWZTYrDKrTGaNFxi2A66JSWCilZgLoBN1U/Rfok8x86I5MngTQRSm1x2O2fQAGA/gn9PizJ6Cb0udBVyJeg/7+P/KxvotKqduN+ZdAD8+Qasy7CfoCx0TP+UJNKfU99D7tQ+htJxG6cjobuqIwr5hFPAM9APlG6H1hQ+j9mW1oE2MbbAf9vnYZ6xHo52lfBNBO6YHgQyLUx9+yHDd8mG/5P6z7XaWHquoLfaHpPPTnngG9nXeFbmEUtZRSz0Lvt9+D/r0lQB/n90DvPwbBPaxPLnRl9kUAq6EvvJpDcOyBbsLdTSkV1jvxFB2kjOeZRCEnIo2hTzASAPRRYXy+MBJE5K/QzyO8pZR62Mf0OdBNRd9WJe+enxwgIgOgm4ttV0p1KK48RY7RLHEf9N3xXyml1npMrwh3E78rVXBNMh0nIiugL9hMU0oFanZqlr8f+uR5mVLqlnDHR/Ehmo+/IvIn6DutP0PfheYJLFGI8Y4hRaOHobfNbdF0UCqDl6GbzvxaRIIZ6Jqin9nxwJ8cjYK8KKUKoO/GAO67/THNeHbP7A3wrUBljfKJ0APGK3AbpZKJyuOv0TmK2Vv426wUEoUHK4YUVUTkSuimlADwipOxhIrRFOd56OZOoej0hBxkdPrQF8A3SqnFxRQnZ8yAbo49WET89YQbE4wmoW9CNx/8Runx5oozFrr56vtGc3iiYkXr8de40PFX6FYA5wH829mIiOJXSbsCJwo5owesXdDPpph31H6Afv4oXkyBftYtt7iCFPWqQw+vMb+4guQMpVSRiNwLPVRCXehKYkwRkSnQzx7WhX72MQ/A74KdHXob5Qk0BRTNx18RGQN9UbUm3L2A/kkpdc7/XERUFqwYUjSwDsJ8DPqh9D8oPY5TXFC66/pA41pRjDDuEvJOYZRTSq2He0iBWFQbQGPoHijXAnhSKbUxmBmVUtPDGBfFl2g+/l4GHVsedGc7/1RKha0jJSJi5zNERERERETlXszeMaxVq5Zq2rSp02EQERERERE5YsOGDaeUUrVDsayYrRg2bdoU69fHcishIiIiIiKi0hORA6FaVsR7JRWR34nINhHZKiKzRaSiiDQTkR9EZK+IzBWRlEjHRUREREREVF5FtGIoIg2gu0LurpTqCCARwCgALwL4P6VUS+jx3iZEMi4iIiIiIqLyzIlxDJMApIpIEnT3/ccA9AOwwJg+A8BgB+IiIiIiIiIqlyJaMVRKHQHwMoCD0BXC8wA2ADinlCowih0G0MDX/CJyv4isF5H1J0+ejETIREREREREcS/STUmrAxgEoBmA+gDSANwU7PxKqalKqe5Kqe61a4ek8x0iIiIiIqJyL9K9kt4A4Bel1EkAEJGFAK4GUE1Ekoy7hg0BHIlwXEREREREVAIXLlxARkYG8vPznQ4l7iQnJ6NOnTqoUqVKxNYZ6YrhQQC9RKQSgGwA1wNYD+ArAMMAzAFwN4AlEY6LiIiIiIiCdOHCBZw4cQINGjRAamoqRMTpkOKGUgrZ2dk4ckTfK4tU5TDSzxj+AN3JzEYAW4z1TwXwOIDfi8heADUBvBvJuIiIiIiIKHgZGRlo0KABKlWqxEphiIkIKlWqhAYNGiAjIyNi6434APdKqWcAPOORvQ9Az0jHQkREREREJZefn4/U1FSnw4hrqampEW2m68RwFUREREREFON4pzC8Iv35smJIRERERERUzrFiSEREREREVM6xYkhEREREROXSs88+i1q1ajkdRjDbj40AACAASURBVFRgxZCIiIiIiKicY8WQYsKGoxvw9vq3cfjCYadDISIiIiKKO6wYUlRTSuG5r59D9393x4NLH0TntzrjdNZpp8MiIiIiojiWn5+P9PR0TJ482WvaNddcg+HDhwMA3nnnHYgItm3bhhtuuAFpaWlo164dlixZ4iq/d+9eVK5cGX/+859deXl5ebj88stx3XXXQSkV/jcUBFYMKWrlFebhniX34NmVz7ryzuacxfzt850LioiIiIi8iETHK1SSk5Mxbtw4zJgxw5a/Z88efPvttxg/frwtf/To0Rg8eDAWLVqEZs2aYeTIkTh27BgAoGXLlnjxxRcxefJk/PjjjwCA5557Dvv27cO0adOiZtgPVgwpKp3LOYebZ92MGT/N8Jq2/uh6ByIiIiIiovJkwoQJ2Lt3L1atWuXKmzZtGurXr48BAwbYyj766KOYNGkSBgwYgOnTpyMvLw9Lly51TX/44YfRu3dv3H333Vi9ejVefPFFvPLKK2jatGmk3k6xWDGkqHPg3AFc8941+PKXL31OZ8WQiIgiLTs/G0t2LsGqA6uiptkXEYVX27ZtcdVVV2H69OkAgKKiIsycORPjxo1DYmKiray1olinTh3UqlULhw+7+8YQEbz33ns4cOAAbrjhBvTv3x/33XdfRN5HsFgxpKiy4egG9Hq3F7ad3Oa3zNaMrcjOz45gVEREVJ4VqSLcMe8ODJ47GL2n98bfv/u70yERUYRMmDAB8+fPR1ZWFlasWIHDhw/jnnvu8SpXrVo1WzolJQU5OTm2vMaNG+Pqq69Gbm4uHn744bDGXRqsGFLU+GT3J+g9vTeOXzxuy7+y4ZVocFkDV7pQFWLzic2RDo+IiMqpz/d9jmV7l7nSz696HrkFuQ5GRBR9lIqOV6iNHDkSALBgwQJMnz4dV199NVq3bl2qZS1YsADLly9Hly5d8OijjyI7O7pudLBiSFHhzXVvYtCcQcjKz7LlD2s/DF+M+wJXNbrKls/mpEREFCmvr33dlr6QewHL9y53KBoiiqS0tDSMHDkSU6ZMweLFi33eLQxGRkYGHnroIfzmN7/Bf//7X2RkZOCPf/xjiKMtmySnA6DyrUgV4fEVj+Pl71/2mvbolY/ixf4vIkES0K1eN1tvpBuObYhkmEREVE79cvYXfLL7E6/8udvmYlDbQQ5EREShlpeXhwULFnjl9+nTB7Vr18aECRNw5ZVXIi0tDSNGjCjVOh544AHUqFEDf/vb35CamoopU6Zg3LhxGDJkCHr37l3WtxASrBiSY7Lzs3HXorvw4Y4PbfkJkoApN0/Bwz3cba+71+9uK8M7hkREFAlvrX8LCt7t0z7a9RGy8rNQKbmSA1ERUShlZma6xiW0+uqrr9C3b1/06tUL6enpuOmmm3DZZZeVePkzZ87ERx99hNWrVyM1NRUAMHbsWCxcuBD33HMPNm/ejLS0tDK/j7KSWO1Zq3v37mr9elYOYtXJSycxaM4gfH/4e1t+peRKmDtsLm5rfZst/2z2WdR4qYYrnSAJyPxDJg/IREQUNln5WWj4akOczTnrc/q8YfMwvIP3ySRRebBjxw60a9fO6TAiYvPmzejSpQu+/vpr9OnTJ6LrLu5zFpENSqnufguUAJ8xpIjbfXo3rnz3Sq9KYd3KdfHNr7/xqhQCQPXU6mhRvYUrXaSK8NPxn8IeKxERlV+zt8z2WykEdHNSIopfp06dwrfffovf/OY36NKlS8QrhZHGiiFF1OqDq3Hlu1fi57M/2/I71O6ANRPWoFv9bn7nZXNSIiKKFKUUXl9n73Smb9O+tvTSPUuRmZsZwaiIKJIWL16Ma6+9FqdOncK0adOcDifsWDGkiJm7dS6u/8/1OJN9xpbfr1k/rB6/Gk2qNQk4f7d69kojO6AhIqJw+e7Qd9h0fJMrLRC8e/u7aFLVfazKKcjBx7s/diI8IoqAe++9F0VFRdi6dSu6du3qdDhhx4ohhZ1SCi+ufhGjPhyFvMI827S7u9yNZWOWoVrFan7mduMdQyIiipQpa6fY0gPbDETz6s0xssNIW/6crXMiGRYRUdiwYkhhVVBUgIeWPoQnvnjCa9pzfZ/DtEHTkJKYEtSyrqh3hS2949QOXMq7FJI4iYiITEczj3r1mD2pxyQAwMiO9orh8r3LcS7nXMRiIyIKF1YMKWwyczMxcPZAvL3hbVt+ckIyZgyegaf7PA0RCXp5VStWRasarVzpIlVka+ZDREQUClM3TEVBUYEr3aZmG1zf/HoAQNe6XdGyRkvXtPyifCzeuTjiMRIRhRorhhQWRy4cQe/pvbF873JbftUKVbF87HKM6zKuVMtlc1IiIgqnvMI8rwuaE3tMRILoUyYRwagOo2zT2ZyUiOIBK4YUcptPbEavd3t53c1rXLUxvh3/Lfo161fqZXt2QLP+GCuGREQUOgt3LMTxi8dd6coplXH35Xfbyng2J/183+c4lXUqIvEREYULK4YUUp/9/Bmuee8aHL5w2JbfrV43/HDvD+hQp0OZlu95x3DDUfZMSkREoePZ6czdXe5GlQpVbHkd63RE+9rtXelCVYiFOxZGJD4ionBhxZBC5r0f38Mts25BZp59TKeBrQdi5a9Xom7lumVeR9d6XSFwP5e489ROjiFFREQhsfHYRnx36Dtb3sQeE32WZXNSovjw7LPPolatWj6n/frXv0b37t19TotHrBhSmSml8OSXT2LCRxNQqApt0yb2mIhFIxchLSUtJOuqUqEKWtds7V43FDugISKikHhj7Ru29PXNrke72u18lvVsTrrywEpbE1QioljDiiGVSW5BLsYuGovnVz1vyxcIXh3wKqbcPAWJCYkhXSc7oCEiolA7nXUaH2z9wJb3SM9H/JZvXbM1Lq97uStdpIqwYPuCsMVHRLEpOzvb6RCCxoohldqZ7DMY8P4AfLDFfiCtmFQR84fPx++u/F2JhqMIllfFkB3QEBFRGb3747vIKchxpRtXbYzbWt8WcB42JyUqP44dO4bx48ejefPmSE1NRevWrfHkk08iLy/PVWb//v0QEcyaNQvjxo1DtWrVMHDgQNf0d955Bx06dECFChXQpEkTvPTSS068Fb+SnA6AYtMvZ3/BLR/cgp2ndtrya1WqhY9Hf4xeDXuFbd2ePZOyAxoiIiqLwqJCvLnuTVvew90fLrbFy4gOI/DEF0+40t8e+haHzh9Co6qNwhInEYVPQUGBV55SyvX/qVOnUKNGDbz66quoXr06du/ejWeffRYnT57E22/bh7h59NFHMXToUMyfPx+JiXo/8ve//x1//OMf8dhjj6Fv377YsGEDnnrqKVSqVAmTJk0K75sLEiuGVGJrj6zFwNkDkXEpw5bfumZr/PfO/6JFjRZhXb/ZAY2C/rHuOr0LF3IvePUaR0REFIyle5biwPkDrnSFxAqYcMWEYudrVr0ZejboibVH1rry5m+fj99f+fuwxEkUzeS50LcSKw31jCq+kIfTp08jOTnZ57Ru3fQNiU6dOuHll1925V999dVIS0vD+PHjMWXKFKSkpLim9erVC2+84X5m+cKFC3juuefw5JNP4plnngEA9O/fH1lZWZg8eTIeeughVwXSSWxKSiWyeOdi9J3e16tSeE3ja/Dd+O/CXikE9JhSbWu1teVtPLYx7OslIqL49Pra123pOzvdiVqVfPdS6GlkB3snNGxOShR7qlatinXr1nm9brvN3ZxcKYV//OMfaN++PVJTU5GcnIwxY8YgNzcXBw8etC3v1ltvtaW///57XLp0CcOHD0dBQYHr1a9fP5w4cQKHD9uHeXMKK4YUtH+u+SeGzh2K7AL7Q7SjOo7CirtWoGalmhGLheMZEhFRKOw8tRMr9q2w5U3qGXyzrhEdRtjS646uw76z+0ISGxFFRlJSErp37+71qlnTfW77j3/8A48++iiGDBmCJUuWYO3ata67gjk5Obblpaen29KnTp0CAHTo0AHJycmu13XXXQcAOHToUDjfXtDYlJSKVVhUiN9/+nu8tvY1r2l/uOYPmNxvMhIkstcYutfvjpmbZ7rS7ICGiIhKw3OIiisbXokr6l0R9PwNqzTENY2vweqDq11587bNwxPXPBFgLiKKNfPnz8ewYcPw/PPunvi3b9/us6xn54s1atQAAHzyySdelUYAaNOmTQgjLT1WDCmgrPws3PnhnViya4ktP1ES8datb+G+bvc5Ehc7oCEiorK6kHsB03+abssryd1C08gOI20Vw7nb5rJiSOVOaZ7tiyXZ2dmoUKGCLW/WrFlBzXvllVciNTUVR48e9WpmGk1YMSS/Tlw8gYGzB2Ld0XW2/MoplTF/+Hzc1PImhyIDLq97ORIkAUWqCACw58wenMs5h2oVqzkWExERxZaZP83ExbyLrnR6WjqGtR9W4uUMaz8Mv13+W9cxadPxTdh1ahfa1IqOuwBEVHb9+/fHa6+9hl/96ldo0aIFZs2ahb179wY1b7Vq1fDss8/it7/9LQ4cOIDevXujqKgIu3fvxldffYVFixaFOfrg8BlD8mnHyR3o9W4vr0phg8saYPU9qx2tFAJAWkoa2tdub8tjBzRERBQspRReX2fvdOaBbg8gJTHFzxz+1a1cF32b9rXlzd02tyzhEVGUefrppzF69Gg8+eSTGD16NFJSUvDaa96PWfnz2GOPYerUqVi2bBkGDRqE0aNHY9asWbj22mvDGHXJiHV8jljSvXt3tX49nysLh5X7V2Lw3ME4l3POlt85vTOW3rkUDas0dCgyu18v/jVm/DTDlX7phpfwv1f/r4MRERFRrPh83+foP7O/K52UkIQD/3MA9S+rX6rlTd0wFQ988oAr3a5WO2x7eJvXs0ZE8WLHjh1o166d02HEveI+ZxHZoJTq7rdACfCOIdnM2jwL/Wf296oUDmgxAKvuWRU1lULAu2dSdkBDRETB8hyiYmi7oaWuFJrzJyW4n9DZcWoHtmZsLfXyiIgijRVDAqCb1Ez+ZjLGLhqL/KJ827R7u96LT0Z/EnUDyHt2QLP+KCuGRERUvP3n9uPj3R/b8h7p+UiZllmrUi3c0PwGWx6bkxJRLGHFkJBfmI97P7oXT331lNe0v/b7K6YOnIrkxGQHIgusS90uSJREV3rf2X04m33WwYiIiCgWvLXuLVdHMQDQJb0Lrm50dZmX6znY/dxtcxGrj+wQUfkT0YqhiLQRkU2W1wUR+R8RqSEiK0Rkj/G3eiTjKs/O55zHrR/civc2vWfLT0lMwayhs/CHa/8Qtc9HVEquhA51OtjyNhzjsBVERORfdn423vnxHVvepJ6TQnKsG9x2sK3zmr1n9rJjNCKKGRGtGCqldimlLldKXQ6gG4AsAIsAPAHgC6VUKwBfGGkKs+z8bPSd0Rcr9q2w5VevWB0r7lqBOzvd6VBkweN4hkREVBJzts7BmewzrnT1itVDdryrVrGaV6/dbE5KRLHCyaak1wP4WSl1AMAgAGb3kjMADHYsqnLk9bWvY9PxTba8ZtWa4fsJ36N3k94ORVUy7ICGiIiCpZTClLVTbHkTuk5ApeRKIVsHm5NSecJtO7wi/fk6WTEcBWC28X+6UuqY8f9xAOnOhFR+KKVsQz0AQM8GPbHm3jUxNSCvV8WQHdAQEZEf3x/+Hj8e/9GVFgge6vFQSNdxe5vbkZqU6kofPH8Qaw6vCek6iKJBcnIysrOznQ4jrmVnZyM5OXL9fDhSMRSRFAC3A5jvOU3pqrHP6rGI3C8i60Vk/cmTJ8McZXzbfGIztp3c5konSiI+GvUR6qTVcTCqkuuc3tnWPfj+c/txOuu0gxEREVG08hyi4tbWt6J59eYhXUfllMq4tfWttjw2J6V4VKdOHRw5cgRZWVm8cxhiSilkZWXhyJEjqFMncufmScUXCYubAWxUSp0w0idEpJ5S6piI1AOQ4WsmpdRUAFMBPcB9ZEKNT+9vft+WvrHljUivHHs3aismVUTHOh1tTWI3HNuAAS0GOBgVERFFm2OZxzB/u/169KQek8KyrpEdRmLB9gWu9Pzt8/Hqja8iQdgZPMWPKlX0MGZHjx5Ffn5+MaWppJKTk5Genu76nCPBqYrhaLibkQLARwDuBvCC8XeJE0GVF4VFhfhg6we2vLGdxjoUTdl1q9fNVjFcf3Q9K4ZERGTz743/RkFRgSvdumZr9G/RPyzruqXVLUhLTsOl/EsAgKOZR7H64OqYeX6fKFhVqlSJaMWFwivil65EJA1AfwALLdkvAOgvInsA3GCkKUy+2v8VjmYedaUrp1TGoLaDHIyobDyfM+SQFUREZJVfmI9/rf+XLW9ij4lhu4NXKbmS13F1ztY5YVkXEVGoRLxiqJS6pJSqqZQ6b8k7rZS6XinVSil1g1LqTKBlUNl4NiMd2m5oSHtkizR2QENERIEs3LEQxy4ec6XTktNwd5e7w7pOz95JF2xfYLtjSUQUbdjYvZzJys/Chzs+tOXd1fkuh6IJjU51OiE5wd1j08HzB3HyEjsnIiIi7fV19k5nxnUZh6oVq4Z1nTe2uBFVK7jXcTLrJL7e/3VY10lEVBasGJYzS3YuwcW8i650vcr1cF3T6xyMqOwqJFVAp/ROtjw2JyUiIgDYdHwTVh9cbcub1DM8nc5YVUiqgCHthtjy2JyUiKIZK4blzPtb7M1I7+x0JxITEh2KJnS612NzUiIi8vbG2jds6X7N+qF97fYRWbdnc9KFOxYirzAvIusmIiopVgzLkYxLGfh076e2vLGdY7c3Uqtu9bvZ0rxjSEREZ7LPYNaWWba8cA1R4cv1za5HzdSarvTZnLP4fN/nEVs/EVFJsGJYjszdOheFqtCV7linI7qkd3EwotBhBzREROTpvR/fQ3ZBtivdqEojDGwzMGLrT05Mxh3t7rDlsTkpEUUrVgzLkZmbZ9rSYzuNhYg4FE1odazTESmJKa704QuHceLiCQcjIiIiJxUWFeLNdW/a8h7u8TCSEiI7hPPIjvbmpIt3LkZOQU5EYyAiCgYrhuXErlO7sO7oOlvenZ3udCia0EtJTEHn9M62PDYnJSIqv5btXYZfzv3iSldIrIAJXSdEPI4+TfogPS3dlc7My8TyvcsjHgcRUXFYMSwnPJ+x6Nu0LxpVbeRQNOHBDmiIiMg0Ze0UW3pUx1GonVY74nEkJiRiePvhtjw2JyWiaMSKYTmglPIa1D7Wxy70hR3QEBERoFvJfPbzZ7a8SAxR4Y9nc9KPd3+MS3mXHIqGiMg3VgzLge8OfefVnMbzYfh4wA5oiIgIgNezhb0a9vI6RkTSVY2uQoPLGrjSWflZWLpnqWPxEBH5wophOeB5t/D2NrejasWqDkUTPh1qd0CFxAqu9NHMoziWeczBiIiIKNIyczMx/afptrxIDlHhS4IkYESHEba8udvmOhQNEZFvrBjGubzCPK+DTzw2IwV0t+Bd6tqH32BzUiKi8mXm5pm4kHvBla6TVgfD2g9zMCJtVMdRtvTS3UttcRIROY0Vwzi3bM8ynM0560rXTK2JG1ve6GBE4cUOaIiIyi+lFF5f+7ot7/4r7keFpAp+5oicHvV7oFm1Zq50bmEuPtr1kYMRERHZsWIY5zzHLhzZYaRtvL9449kBDSuGRETlx1f7v8KOUztc6URJxIPdH3QwIjcRYXNSIopqrBjGsXM55/Dx7o9teWM7j3Uomsjw7Fxgw7ENUEo5FA0REUWS593Coe2GokGVBn5KR55nc9JP936Ks9ln/ZQmIoosVgzj2ILtC5BXmOdKt6jeAr0a9nIwovBrX7s9KiZVdKWPXzyOo5lHHYyIiIgi4cC5A1iya4ktz8khKnzpkt4FrWu2dqXzi/KxaOciByMiInJjxTCOefZGOrbzWIiIQ9FERlJCEi6ve7ktjx3QEBHFv3+t/xeKVJEr3alOJ1zb+FoHI/ImIhjZwT6mIZuTElG0YMUwTh04dwArD6y05Y3pNMahaCKLHdAQEZUvOQU5+PfGf9vyHun5SFReDPVsTvrFvi9w8tJJh6IhInJjxTBOfbDlA1v6Vw1+hVY1WzkUTWRxoHsiovJl7ta5OJ192pWuVrEa7ux0p4MR+de+dnt0rNPRlS5Uhfhwx4cORkREpLFiGIeUUl69kcbr2IW+ePZMyg5oiIjil1IKU9ZOseWNv3w80lLSHIqoeGxOSkTRiBXDOLTp+CZbd91JCUleXWTHs7a12qJSciVXOuNSBg5fOOxgREREFC4/HPnB9iy5QPBwj4cdjKh4nhXDlftXsqM0InIcK4ZxyPNu4U0tb0LttNoORRN57ICGiKj88Byi4pZWt6BFjRYORROcVjVb4Yp6V7jSCgoLti9wMCIiIlYM405BUQFmb51tyxvbKb7HLvSFHdAQEcW/ExdPYN62eba8aBuiwh82JyWiaMOKYZz58pcvcfzicVf6spTLcHub2x2MyBnsgIaIKP5N3TAV+UX5rnSrGq0woMUAByMKnucjHt8d+g4Hzx90KBoiIlYM447n2IXD2g9DanKqQ9E4hx3QEBHFt/zCfPxrw79seRN7TESCxMapTdNqTdGrYS9bnufdTyKiSIqNvScF5VLeJSzcsdCWN7Zz+WtGCgBtarZBWrK7R7pTWad4JZaIKI4s3rnY1mFLWnIa7r78bgcjKjk2JyWiaMKKYRxZvHMxLuVfcqUbXNYAfZr0cTAi5yQmJNoe7AfYnJSIKJ68vs7e6cxdne9CtYrVHIqmdIa3Hw6BuNLrj67Hz2d+djAiIirPWDGMI+9vsTcjHdNpDBITEh2Kxnnd6nk3JyUioti3+cRmfHPgG1vexJ4THYqm9BpUaYBrm1xry+NdQyJyCiuGceLExRP47OfPbHnltRmpiR3QEBHFJ88hKq5reh061unoUDRlw+akRBQtWDGME7O3zkaRKnKlO6d3Rqf0Tg5G5Dx2QENEFH/OZp/16mgtVoao8OWOdnfYOszZfGIzdpzc4WBERFResWIYJzwPkuVx7EJPrWu2RuWUyq70mewz2H9uv3MBERFRmU3bNA3ZBdmudMMqDWN6WKb0yuno16yfLY93DYnICawYxoEdJ3fYnp8TCO7sdKeDEUWHBEnwes6QzUmJiGJXkSrCG+vesOU91P0hJCUkORRRaPhqTsoWLkQUaawYxoFZW2bZ0v2a9UODKg0ciia6sAMaIqL4sWzPMuw7u8+VTklMwX1X3OdgRKExtN1QW+V256md2JKxxcGIiKg8YsUwxhWpIu9mpOW80xkrdkBDRBQ/PIeoGNVxFGqn1XYomtCpkVoDA1oMsOXN2TrHoWiIqLxixTDGfXvwWxw4f8CVrphUEUPbDXUwoujiWTFkBzRERLFpz+k9WL53uS1vUo/Y7XTGE5uTEpHTWDGMcZ53Cwe3HYwqFao4FE30aVGjhe3zOJdzztYMiYiIYsOb6960pXs26IkeDXo4FE3oDWozCCmJKa70vrP7+PgDEUUUK4YxLLcgF/O2z7PlsTdSO3ZAQ0QU+y7mXcR7m96z5T3S8xGHogmPqhWr4pZWt9jy2JyUiCKJFcMYtnTPUpzLOedK16pUy+sZBWIHNEREse79ze/jQu4FV7p2pdoY3n64gxGFh2dz0nnb5tnGKCYiCidWDGOYZzPSUR1GITkx2aFoohc7oCEiil1KKby+1t7pzP3d7keFpAoORRQ+t7W+DalJqa70oQuHsObwGgcjIqLyhBXDGHUm+wyW7llqy7ury10ORRPdfHVAwyuwRESxYeWBldh2cpsrnSiJeLD7gw5GFD6VUyrjtta32fLmbuVg90QUGawYxqgF2xcgrzDPlW5VoxV61I+fh/BDqXn15qhWsZorfSH3An4+87ODERERUbCmrJ1iSw9pNwQNqzR0KJrwG9VxlC09b/s8FBYVOhQNEZUnrBjGqJmbZ9rSYzuPhYg4FE10ExF2QENEFIMOnj+IxTsX2/LiaYgKX25ueTMqp1R2pY9fPI5VB1c5GBERlRcRrxiKSDURWSAiO0Vkh4hcKSI1RGSFiOwx/laPdFyx5Jezv2D1wdW2vDGdxjgUTWzgc4ZERLHn7fVv25r+d6zTEb2b9HYwovBLTU7FoDaDbHlsTkpEkeDEHcN/AliulGoLoAuAHQCeAPCFUqoVgC+MNPnxwZYPbOmrGl2FFjVaOBRNbGDPpEREsSWnIAdTN0615U3qMalctI7xbE66YMcCFBQVOBQNEZUXEa0YikhVAL0BvAsASqk8pdQ5AIMAzDCKzQAwOJJxxRKlFN7fYu+NlGMXFs/zjuHGYxvZAQ0RURSbt20eTmWdcqWrVqiKsZ3Lx/FuQIsBtmfjT2Wdwpe/fOlgRERUHkT6jmEzACcBTBORH0XkHRFJA5CulDpmlDkOIN3XzCJyv4isF5H1J0+ejFDI0WXDsQ3YeWqnK52UkIQRHUY4GFFsaFqtKapXdLdQzszLxJ7TexyMiIiIAvEcomJ81/FIS0lzKJrISklMwZC2Q2x5bE5KROEW6YphEoArALyllOoK4BI8mo0qpRQA5WtmpdRUpVR3pVT32rVrhz3YaOQ5duEtrW5BzUo1HYomdohI2J8zLCwEZs0Cnn8e2L8/pIsmIipX1h5Zi3VH19nyHu7xsEPROMOzOenCnQttvZETEYVapCuGhwEcVkr9YKQXQFcUT4hIPQAw/mZEOK6YUFBUgNlbZ9vy7urMsQuDFe6K4SuvAGPHAk8+CVx3HXD+fEgXT0RUbnjeLby55c1oWaOlQ9E4o1+zfqhVqZYrfS7nHD77+TMHIyKieBfRiqFS6jiAQyLSxsi6HsB2AB8BuNvIuxvAkkjGFSs+3/c5Mi6568xVKlTxGgiX/AtnBzQFBbpiaNq/H3jrrZAtnoio3Mi4lIG52+zNJh/p+YhD0TgnKSEJd7S7w5bn+bkQEYWSE72SPgJglohsBnA5gL8CeAFAfxHZA+AGI00ePMcuHN5+OComVXQocfLyVwAAIABJREFUmtjjqwOaUA0avHIlkOFxn/sf/wByckKyeCKicuPfG/5tazLZonoL3NjyRgcjco5nc9LFOxcjOz/boWiIKN5FvGKolNpkPCfYWSk1WCl1Vil1Wil1vVKqlVLqBqXUmUjHFe0yczOxaMciW1556Z0tVBpXbWxrlnMp/xJ2nd4VkmXPmeOdd+IEMGOGdz4REflWUFSAt9bbm1tM7DERCeLEdWznXdv4WtStXNeVvph3Ecv2LnMwIiKKZ+VzTxuDFu9cjOwC91XCRlUaxf0gv6EmIt7NSY+WvTlpXh6wcKHvaS+9pJuZEhFR8ZbsXIIjmUdc6UrJlXBP13scjMhZiQmJGN5+uC2PzUmJKFxYMYwRnmMXjuk0ptxeQS2LcHRA8/nnwBk/97j37QM+/LDMqyAiKhemrJ1iS9/V+S7beH7lkWdz0o93fYyLeRcdioaI4hlrFjHgWOYxfL7vc1sem5GWTjg6oPFsRpqcbE+/8AKgfA7AQkREpi0ntmDlgZW2vIk9JjoUTfTo1bAXGlVp5EpnF2Tjk92fOBgREcUrVgxjwOyts1Gkilzpy+tejg51OjgYUezyvGP44/EfUVBU+raeOTnA4sX2vNdeA0Tc6U2bgM/YwzgRUUBvrHvDlu7TpA86pXdyKJrokSAJGNFhhC2PzUmJKBxYMYwBnoPac+zC0mtYpSHqpNVxpbPys7Dz1M5SL2/ZMiAz052uWxe47z5g6FB7uRfYzy4RkV/ncs559bw9qeckh6KJPiM7jLSll+1ZhvM5HCyXiEKLFcMoty1jG348/qMrnSAJXs8bUPBC3QGNZzPS4cOBxETg8cft+V9/DfzwQ6lXQ0QU16Zvmo6s/CxXumGVhhjcdrCDEUWX7vW7o3n15q50bmEuluzikM9EFFqsGEY5z7uF1ze7HvUvq+9QNPEhVB3QXLoEfOLxmMcoo87eowdw/fX2aS++WKrVEBHFtSJV5NWM9MFuDyIpIcmhiKKPiHjdNWRzUiIKNVYMo1iRKsKsLbNseex0puy8KobHSlcx/PhjIMt9gRuNGgG9ernTnncNFy0Cduwo1aqIiOLWp3s/xd4ze13plMQU3NftPgcjik6eFcPPfv4MZ7I57DMRhQ4rhlFs1YFVOHThkCtdKbkShrYbGmAOCoZnU9JNxzeVqgMaz2akI0cCCZZf1A03AFdcYS/z97+XeDVERHHNc4iKER1G2J4FJ61zeme0rdXWlS4oKsDCHX4G0SUiKgVWDKOYZzPSwW0Ho3JKZYeiiR/1L6uPupXrutI5BTnYfnJ7iZZx/rzueMZqlMejnyLAE0/Y895/Hzh0CEREBGDjsY1Ytte+M32k5yMORRPd2JyUiMKNFcMolVOQg/nb59vyxnZiM9JQCEUHNIsXA3l57nSLFt53BwHdO2nLlu50fj7wf/9XolUREcWtP6/8sy3dq2Ev9GzQ06Foop9nxfDLX75ExqUMh6IhonjDimGU+mT3Jzif6+6Kuk5aHfRv0d/BiOJLWTug8WxGOmqUfexCU2Ii8Nhj9rypU4HTp0u0OiKiuLPp+CavnjWf7v20Q9HEhna126FzemdXukgVYcH2BQ5GRETxhBXDKOXZjHR0x9HsoS2EytIBzalTwIoV9jzPZqRW48YB9eq505cuAW+84b88EVF54Hm3sEf9Hrip5U0ORRM72JyUiMKFFcModDrrNP6757+2PPZGGlqeTUl/Ov4T8gvzg5p34UKgsNCdbt8e6NjRf/kKFYDf/c6e99pruoJIRFQebT6xGYt2LrLlPdPnGYivphdk41kxXHVgFY5cOOJQNEQUT1gxjELzts1DfpG7ktKmZhuvigyVTb3L6tnGg8wtzMW2k9uCmtdXM9LiPPAAULWqO336NPDee0Gtjogo7njeLexevztuaXWLQ9HElhY1WthavSgorz4JiIhKgxXDKPT+Fnsz0rGdx/IqahiU5jnDY8eAr7+2540c6bOoTZUqwMMP2/Nefll3RkNEVJ5sObEFH+740Jb3dO+neZwrATYnJaJwYMUwyuw7uw/fHfrOljem0xiHoolvpemZdMECQCl3umtXoHXr4Nb329/qZqWmgwe97z4SEcW7v3zzF1v6inpX4LbWtzkUTWwa0WGELb3m8BocOHfAoWiIKF6wYhhlZm2eZUtf0/gaNKvezKFo4ltpOqApTTNSU3o6MH68Pe/FF4GiouCXQUQUy7ZlbPPqRZN3C0uucdXGuKrRVba8edvmORQNEcULVgyjiFIKMzfPtOVx7MLw8bxjuPnEZuQV5vkpre/wfWe/mYsRI3yX9efRR4EEy69u2zZg6dKSLYOIKFb95Zu/QMHd7OLyupfj9ja3OxhR7PJsTjpnG5ugEFHZsGIYRdYdXYc9Z/a40imJKRjeYbiDEcW39MrpaFiloSudV5iHrRlb/Zaf53ExtlcvoGnTkq2zeXPvZxJfeKFkyyAiikXbT273uqvFu4WlN6z9MAjcn93GYxux98xeByMioljHimEU8Ry78NZWt6JGag2HoikfStIBTVmakVo9/rg9/d13wOrVpVsWEVGsmPzNZNvdws7pnTGo7SAHI4pt9S+rj95Netvy5m5lJzREVHqsGEaJ/MJ8zNlqr3lw7MLwC7YDmr17gQ2WSSLA8FLezO3SBbj5Znse7xoSUTzbeWqn1zHu6d5PI0F4GlIWozrar1CyOSkRlQX3yFHis58/w8msk650tYrVOKZTBATbAc1cj4uwvXsD9ev7LBqUJ56wp5cuBTZvLv3yiIiimefdwk51OmFIuyEORhQf7mh3BxIl0ZXemrEV209udzAiIoplrBhGCc+xC4e3H46KSRUdiqb88LxjuOXEFuQW5HqVC1UzUtO11+pnFK1eeqlsyyQiika7T+/G7K2zbXlP9+HdwlConVYb/Zr1s+WxOSkRlRb3ylHgQu4FLN652JZ3V+e7HIqmfKmdVhuNqzZ2pfOL8rElY4utzLZtwFZLnzSJicAdd5RtvSLedw3nzAF++aVsyyUiijaTv5mMIuUel6djnY4Y2m6ogxHFF1/NSZV1wF0ioiCxYhgFFu1YhJyCHFe6SdUmuLrx1Q5GVL4U1wGNZzPS668Hatcu+3oHDgTatXOnCwuBV14p+3KJiKLFntN7MGuLfXzep3o/xbuFITSk7RAkJyS70rtP78ZPJ35yMCIiilXcM0cBz7ELx3Qaw4NmBAXqgEap0DcjNSUkePdQ+u67QEZGaJZPROS051c9b7tb2L52ewxrP8zBiOJP9dTqGNBigC2PzUmJqDRY+3DYkQtH8OUvX9ry2BtpZAXqgObHH4E97qElkZwMDAlhfwmjRwONGrnTOTnAa6+FbvlERE7Ze2av1zBMvFsYHmxOSkShwL2zw2ZvnW3rqa1bvW5oV7tdgDko1DzvGG7N2Opq2uvZjPSmm4Bq1UK37pQU4P/9P3veG28AmZmhWwcRkROeX/U8ClWhK922VlsMb1/KcX4ooNvb3I4KiRVc6f3n9mPd0XUORkREsYgVQ4d5Xk3l3cLIq1mpJppWa+pKFxQVYPOJzWFtRmp1771AjRru9LlzwNSpoV8PEVGk/HzmZ8z8yf6YxFO9n0JiQqKfOagsqlSo4jXEFZuTElFJsWLooC0nttgeEE+QBK/mIBQZvjqgWbMGOHjQnZeaCtx+e+jXnZYG/OY39rxXXwVyvUfNICKKCX9d9Vfb3cI2NdtgZIeRDkYU/zzPH+Ztn2d7vpOIqDisGDrI827hgBYDULdyXYeiKd+617NXDDcc3eDVjPTWW4HKlcOz/kmTgEqV3OmjR4H33/dfnogoWv1y9hf8Z/N/bHlP9n6SdwvD7NZWt6JSsvtAcvjCYXx36DsHIyKiWMOKoUOKVJFXF95jO7EZqVO61bc/Z7j+6HrMm2cvE45mpKaaNYH77rPnvfSSHsKCiCiW/HXVX1FQVOBKt6rRiq1hIiAtJQ0DWw+05bE5KRGVBCuGDlm5fyWOZB5xpdOS0zC47WAHIyrfvDug2YZjJ7Nd6cqVgVtu8ZwrtH7/eyApyZ3evRtYvDi86yQiCqX95/Zj+k/TbXlP9n4SSQlJvmegkPJsrrti3wqHIiGiWMSKoUM8xy4c0m4I0lLSHIqGqqdWR/PqzV3pIhQCdd3Pfw4apJ8xDKfGjYExY+x5L7ygx1IkIooFf1v1N9vdwpY1WuLOTnc6GFH5ckPzG5Ao7ia7u07vwtHMow5GRESxhBVDB2TnZ2PB9gW2vLs63+VQNGTy7IAG9d3jGYazGanVY4/Z0+vXA19+6bssEVE0OXj+IKZtmmbL+9O1f+Ldwgi6rMJl6NGghy3v6/1fOxMMEcUcVgwd8PHuj5GZ5x6orm7luujXrJ+DERHg3QGNWTGsVg0YMCAyMbRvr+9OWr34YmTWTURUFn9b9TfkF+W70s2rN+cQTA7o26SvLc2KIREFK+iKoYjcISITLOlmIvKdiJwTkQ9FJITDfsc3z95IR3cczSuqUcCzAxrU2wAAGDpUD0QfKU88YU+vWAFs2BC59RMRldSh84fw7o/v2vJ4t9AZ1zW7zpb+av9XDkXin1LAkiXAgw96jxdMRM4pyR3DJwFUsaSnAKgF4AUAVwD/n737jo+q2hY4/tvpIfQOUkVBqvTekSKCYMF2ETsXsVxFBQG96vWigmJXiu0CdsWn2CgiRXqRroIgIL0HCOnJfn+cTCZ7Jm2SmTkzk/X9fOYT9p4zM8v7Hkz22WuvxSQvxhWyTlw4wY+7fzTm5I5qYGhdo7U5UeU3iLzgtzRSh44doUcPc052DYUQgeyFFS8Yu4X1y9eXIxI26VK7i7Eg3316NwfPHbQxItOBAzBoEAwdCjNmwM03w5dfFvw6IYTvebIwvBjYBqCUKgf0Ax7WWr8ATAQG5/NakeXzHZ8bB/ObVGlCq+qtbIxIOJSPKU/N6EudE2GZlL9sC7165f0aXxk3zhx/+SX8+af/4xBCiIIcPHeQdze9a8xN6DaByPBImyIq2eKi4mh/UXtjLhDSSTMzrYVg06bwww/mcy++aE9MQgiTp2cMHfURewAZwE9Z44NAFW8FFco+3GamkQ5vPhyllE3RCFeRJ8x00qZ9NxgtJPxlwABo0cI51lq+OIUQgWnyismkZqRmj+uWq8uIy0fYGJHoVc8lnXSvvemku3dDnz5W6uj58+7Pr1sH27b5Py4hhMmTheEW4B9KqTjgbmCJ1jol67k6wPHCvIlSap9SaptSarNSakPWXEWl1CKl1J9ZPyt48h8RLHaf3s2ag2uMOSnjHTgSE+HIRrMATdylG/K42reUcj9rOGsWHJaq40KIAHL4/GHe+fUdY25it4lEhfvxYLZw47YwtOmcYUYGTJ1q3ehcujT/a997L//nhRC+58nCcAJwDXAOa8fw6RzPDQXWevBevbTWLbXWjt/CHwcWa60vBRZnjUOOa9GZ7nW7U7d8XZuiEa6+/x5S95s7hgcz7Kv6MmwY1K/vHKemwquv2haOEEK4mbxiMikZKdnjOuXqcFvL22yMSAB0qt2JyDBnKu/e+L3sj9/v1xi2b4fOneHRRyEpyXwuLs69DdScOZCSghDCRoVeGGqtV2DtDLYH6mqt1+V4+n2s4jRFNQSYlfXnWVgLzZCitXZbGMrB/MDy2WfAEbMAze8nfychNcGWeCIi4LHHzLnp0yE+3pZwhBDCcOT8EWb+OtOYm9B1guwWBoBSkaXoWKujMeevc4apqfDMM9C6tZUi6qpfP9ixAz74ACrkyA87fdqqVCqEsI9HZwy11ue11hu11vEu8z9orXcV9m2AhUqpjUqpkVlz1bTWR7L+fBSo5klcwWDtobXsObMnexwVHsX1Ta63MSKR07lz1o4hKWXhZKPseY1m05FNtsV1++1QtapzfP48TJtmWzhCCJFtysopJKcnZ49rl63NHa3usDEikZMd6aTr10PbtvD005CWZj5Xvry1GJw/H+rWhZgYGO5SlF3SSYWwl0cLQ6VUTaXUSKXUf5RSU1wehS2o31Vr3Rq4ErhPKdU955Naa42zyI3r549USm1QSm04ceKEJ6HbznW3cHDDwZSPkdaPgWLePEh2/H5z2Ewn3XjEvnTS2Fh46CFz7tVX3dNyhBDCn44mHGX6xunG3Piu42W3MID0rNfTGC/ZtwTrVyzvS0qCsWOtdku5FZG55hr47TfrZmfOent33WVet2gR7PdvxqsQIgdPGtxfA/wFvAXcBQzL5VEgrfWhrJ/Hgf/DSk09ppSqkfU5NcijkI3WeqbWuq3Wum2VKsFTBDU1I5VPt5sdXKV3YWAxGuweNgvQbDhsTwEah3vvhTJlnOPjx+F//7MtHCGE4MWVLxq7hbXK1uLOVnfaGJFw1al2J6LDo7PHf5/9m33x+7z+OcuXW8VlXnzRakmRU9Wq8PnnMHcu1Kjh/trLL4c2Oe7Fai3fb0LYyZMdw+eAhVhpnxdpreu7PC4u6A2UUnFKqTKOP2P1QtwOzAMcp9VvA0Iqy3zB7gWcSjqVPa4YW5GBlw60MSKR0+nTsHBhjgmXhaGdO4Zgpd+MGmXOvfgipKfnfr0QQvjSsYRjTNtg5rQ/3uVxoiOi83iFsENMRAydancy5ryZTnr+PIweDT16WO0oXN16q7VLOGyYuUvoynXX8P33rWqmQgj/82RhWBt4XWt9uhifVw1YoZTaAqwDvtdazwdeAPoqpf4ErsgahwzX3oU3NLlB0m0CyP/9n3kW4tIyrVA4v8V2ntzJuZRzNkTm9NBDEJXj/2X27oUvvrAvHiFEyfXSqpdISnfms9csU5O7Wt+VzyuEXXx1znD+fKtRfW5n3mvVss7sz54NlSoV/F4332ydN3T4+29YvNgrYQohPOTJwnAV0KjAq/Khtf5La3151qOp1npS1vwprXUfrfWlWusrirn4DChnk88yb+c8Y07SSAPLp2aWLzdfV5rLKl+WPba7AA1AzZpwm0sF+BdesNJuhBDCX45fOM7bG9425h7v8jgxETF5vELYyfWc4dJ9S4t1zvD0aeu76Mor4cAB9+fvvdeqODrQg6So8uXhepdafFKERgh7eLIwHAOMVErdllWEppTrw1dBBrO5v881zmHUL1+fzrU72xiRyOn4cfj5Z3PuxhuhTc3AKUDj8NhjZjrO1q3WXVshhPCXl1a9RGJaYva4Ruka3NPmHhsjEvnpcFEHY9F+8NxBo0K6J778Eho3tnYCXV1yidXA/u23oWxZz9/77rvN8ddfw6lTuV8rhPAdTxaGW4HmwAfAAeB8Lg/hwrUa6fAWw1H5JdsLv/ryS/OwfIsW0KQJtK0RWAVoAC691P2u6uTC1gIWQohiOnHhBG+tf8uYG9dlnOwWBrDoiGi61O5izC3Z61k66dGjcN111lnB4y6lAcPCrAb2W7ZYZw2Lqnt3a3HpkJoKH36Y9/VCCN/wZGF4J3BH1uPOPB4ihwNnD7g1lP1H83/YE4zIlWsa6Y03Wj/b1gy8hSHAuHHmeNkyWL3anliEECXL1NVTjd3C6qWrM7LNyHxeIQKBWzrp/qWFep3WMGuWdbP0q6/cn2/WDNassYqhlSpmzphScKfLb5HvvSfHJYTwt4jCXqi1/p8P4whJn2z/BJ2jJWO7mu1oVLlYxzSFFx08CCtWmHOOhWHL6i0JU2Fkams78c/Tf3I2+SzlYsr5OUpTmzbQt6/V68lh8mQr7UYIIXzlZOJJ3lz3pjE3tvNYYiNjbYpIFJZbAZq9Vj/D/LKX9u+Hf/4TFixwfy4yEiZOhPHjzaJoxXXbbfDEE84snm3bYMMGaNfOe58hhMifRw3uIbvJ/XVKqXuyftb0RWDBTmvNnK1zjDkpOhNYvvjCvBvZrh00aGD9OS4qjsaVGxvX/3rkVz9Gl7fHHzfH33xjlQQXQghfeXn1y1xIu5A9rhZXjX+2/aeNEYnCandRO0pFOrf0jiQcYdepXblem5kJb71l7Qbmtihs1w5+/RWeesq7i0Kwiqy5Fq2RIjRC+JcnDe7DlVJvA/uBL4AZWT/3K6XeUkp5vMgMZVuPbWX78e3Z43AVzk3NbrIxIuEqrzRSB9d00kAoQAPQqxe0NUNjyhR7YhFChL5Tiad4Y90bxtxjnR8zFhsicEWFR7mdM3Q95gKwa5d1TvD++yEhwXwuJsZKGV21ylo0+oprT8OPP4YLF3K/VgjhfZ4s5p7BOkc4AagHxGb9nJA1/7R3QwturkVn+l/Sn6pxVW2KRrjauxfWrTPnbrjBHLepYVYmDZRzhkq57xp+9JHV+0kIIbztlTWvkJDqXClUKVWFUW1H2RiR8FR+/QzT060jCS1auB+vAKswzNatVpGZiEIfQCqaq66CatWc4/PnrSJxQgj/8GRhOAJ4Qmv9otb6b611StbPF4Engdt9EmEQysjM4OPtHxtzw5tLGmkg+ewzc9y1K9Subc4FagEagKFDoWFD5zg9HV5+2b54hBCh6XTSaV5f+7ox91jnx4iLirMpIlEUveqbC0NHP8OtW6FjR+tmY0qK+ZoyZawG9kuWWFWx/SEy0r1nr6STCuE/niwMq2K1rMjN1qznBfDj7h85fP5w9rh0VGmGXDbExoiEq4LSSAEur345YTkypPec2cOZpDM+jqxwwsNh7Fhz7p13pO+TEMK7Xl3zKudTnd2oKpeqzOh2o22MSBRFmxptiIt0LuaPXTjG6Kf+oE0b2JjLKYkrr7Qa1Y8aZbWk8CfX6qS//GKluQohfM+Tv+67gLwOyd0E7Cx+OMFPa82kXyYZc9c1vk7OYgSQP/6wei45hIW59wcEKBVZiqZVmhpzgVKABmD4cOuwvkNiIrz5Zt7XCyGEJ84kneG1ta8Zc492elR2C4NQZHgk3ep2M+amz19Cerp5XcWKMGcOfP+9exaNvzRqZGXx5PT++/bEIkRJ48nC8L/A7Uqpn5RSo5RS1yil/qmU+gm4Lev5Em/JviWsObjGmHuo40M2RSNy45pG2qsXVK+e+7WBnE4aHQ1jxphzr78uB/WFEN7x2trXOJdyLntcKbYS97W/z8aIRHF0qWmmk1LPbHQ/bJhV4Xr4cOssu51ci9DMmoXbIlYI4X2FXhhqrT8HBgBxwGvAXOB1oBQwQGv9hU8iDDL/XW6uj6+69CpaVm9pUzTCldaFSyN1cC1AEyiVSR1GjoTy5Z3j06fh3Xfti0cIERrik+N5dc2rxtyjnR+ldFRpmyISxbFkCUwb19OcrLcUVCbVq1sN7D//3Cz8Yqdhw6wzjg5Hj8IPP9gXjxAlhUeZ41rrhVrrTlgVSasDsVrrzlrrRQW8tERYfWC1UekLYGK3iTZFI3KzbZuVSuoQEQHXXpv39YG8YwjWF+f995tzU6dCaqo98QghQsPra1/nbMrZ7HHF2Irc1052C4PN2bNWo/reveHwxtaQkmO1FXeSoff8xm+/wTXX2BdjbuLi4CaXw0ty01MI3yvSkWKtdabW+rjWOtPbAQUz17OFvev3plPtTjZFI3LjulvYrx9UqpT39S2qtSBchWeP98bv5XTSaR9FVzQPPGD1mHI4cAA++cS+eIQQwe1s8lleWfOKMfdIp0coE10mj1eIQPTdd9C0KcycmTWRGQH7uxvX9L5zCRUq+D+2wnBNJ/3hBzhyxJ5YhCgp8l0YKqWmKKVq5fhzfo/J/gk5MG06sonv//zemJPdwsDiaRopQGxkLM2qmt18Nx4OrHTSqlXdv0AnT4ZMuW0jhCiCN9a9QXxyfPa4QkwF7m9/fz6vEIHk1Cn4xz9g8GA4dMjlyb159zMMNO3bQ7McX78ZGdZZQyGE7xS0YzgMcOyn3JA1zu9RYj234jlj3KlWJ7eGssJeGzZYje0doqNhSCG6iAR6OinAI49YLSwcfv8dvv3WvniEEMHpXMo5Xl5tNkUd02kMZaPL2hSR8ERqKgwcCB9/7P5cw4bw7hM9jbll+5eRGaDJX0q53/R8/33rJq8QwjfyXRhqretrrbdk/ble1jivx8X+CTnw/H7id+b+NteYm9htIsrusl7C4LpbOHAglCtX8OsCvQANQP367ucxXnhBvkCFEJ55c92bnEl29mstH1OeB9o/YGNEwhNz58K6deZceLjVwH7zZrh9QEvKxzgrlp1OOs22Y9v8HGXhDR9uNb13+PNPq6+hEMI3Cn3GUCk1QimV62kspVRFpdQI74UVXJ5f8Twa52/gLau3ZOClA22MSLjKzHRvU+G6kMpLMOwYAowbZ47XrJEvUCFE4Z1POc/U1VONuYc7Pky5mELcQRMB4f/+zxw3awZr18Lzz0NsLISHhdO9rnnOMJDTSStXhqFDzbn33rMnFiFKAk+Kz3wANMjjufpZz5c4f535i4+3mTkbslsYeFatMs9alCoFV11VuNe2qNaCyDDnLcv9Z/dzMvGklyMsvubN3f+bXnjBnliEEMHnrfVvGcW1ykWX48EOD9oYkfBEcjL8+KM5N3MmtDGTXuhZt6cxXrpvqU/jKi7XdNIvvrCqrQohvM+ThWF+K51KwLl8ng9Zk1dMJkNnZI8vq3wZ1zbOp/+BsIVrGunVV1vlsAsjOiI64AvQODz+uDn+8UfYssWeWIQQwSMhNYGXVr1kzD3U8SEj7VAEtp9+goQE57hGDejQwf26XvXN+gfL9i8jIzPD/cIAccUVULu2c5yUJJW3hfCVgqqSDlFKva+Uej9r6knHOMfjY+A9YL3Pow0wh84d4n9b/mfMje86njBVpC4gwkfS0607jDkVNo3UIVjSSbt2hS5dzLnJJbpesBCiMN5e/zankk5lj8tGl+VfHf5lY0TCU65ppEOGQFguv460qNaCCjHOHhXxyfFsORa4dxDDw+GOO8w5SScVwjcKWsFUBZpnPcBKJW3u8qgLLAT+6aMYA9ZLq14iNcPZSbx++frc3OxmGyMSuVm2DI4fd47LloUBAzx7j2AoQOPgetbws8/gr7+JMc1wAAAgAElEQVTsiUUIEfgupF5w2y38V4d/USE2QBvcCTfp6TBvnjmXV9P6MBVGj3o9jLlATye94w6rSqnDhg2wdat98QgRqgqqSvqO1rqd1rodsAy41jHO8eiitb5La703v/cKNccvHGfGxhnG3Lgu44gMj8zjFcIurmmk11xjtarwRLDsGIJ1zrBpU+c4MxNeeinv64UQJdu0DdM4kXgie1wmqgwPdXzIxoiEp1auhJM5jr6XKwc9e+Z9vWs7rUAuQANQr56VUpqT7BoK4X2FznnUWvfSWv/hy2CCyatrXiUpPSl7XLNMTW5vebt9AYlcpaZa5btz8jSNFKBZ1WZEhUdljw+cO8DxC8fzeYV9wsLcdw0/+ACOHbMnHiFE4LqQeoEpK6cYcw92eJCKsRVtikgUhWsa6aBBEBWV+7XgvjBcvn856ZnpPojMe1yL0Hz4IaSk2BOLEKHKo8NwSqkySqnhSqn/KKWmuD58FWSgOZN0hjfXvWnMPdb5MaIjPNyGEj73009wxtmSi0qVoE8fz98nOiKa5lWbG3OBWoAGrMVvnTrOcXIyvP66ffEIIQLT9A3Tjd3C0lGlebjjwzZGJDyltfvCMK80UoemVZtSKdbZgexcyjk2H93sg+i8Z+hQqJjjfsXp0/D11/bFI0Qo8qSPYQNgN/A2MBEYATwEPArcBVzviwAD0Zvr3uR86vnsceVSlbmn9T02RiTy4ppGet11ZrNcTwRTOmlkJDz6qDn31ltwrkTWDhZC5CYxLZEpq8x7ug+0f4BKpXJtWSwC1KZN8PffznFMTMHn6MNUGD3r9TTmluwN7HTS6Gir4X1Okk4qhHd5smP4Clbl0WpYrSsGArHAcCABuNHr0QWghNQEXl37qjE3puMY4qIK2ftA+E1ysvvdxKKkkTq4LgwDuQANWGk3lSs7x2fPwowZeV8vhChZZmyYYaTEx0XGMabTGBsjEkXhulvYr1/h2jEF2zlDcE8nXbQI9u2zJRQhQpInC8P2wHTAkdEdpbXO0Fp/DEwFXvN2cIFoxoYZbg2AR7cbbWNEIi8//gjnnRu7VK8O3bsX/f1cK5MG8o4hQKlS8KBLb+qXX7YWzEKIki0pLcltt/D+9vdTuVTlPF4hApWnaaQOrjuGv/z9S8CfM2zRAtqa92j54AN7YhEiFHmyMIwBzmmtM4HTQM0cz20HLvdmYIEoOT2Zl1ab5R0faP8A5WLK2RSRyI9rGumwYVY/pKJqWrUp0eHOc6SHzh/iaMLRor+hH9x3n3nn+OhRmDPHvniEEIFh5saZxr9fpSJL8UinR2yMSBTFn3/Cjh3OcXg4DB5cuNc2qdKEqnFVs8cJqQkBfXbewXXX8IMPICPDnliECDWeLAx3YfUsBNgEjFJKxSilIrHOGB72dnCB5v1N7xtfpHGRcfyrozQADkQJCfDtt+ZccdJIAaLCo2hRrYUxF+hfohUrwsiR5tyUKfIlKkRJlpyezOSVk425+9rdR5W4KjZFJIrKdbewe3eryFphKKXczxkGQTrpzTdDbKxzfOCAVWhOCFF8niwMPwVaZv35SaADcA44D9wAPO3VyAJMWkaa2xfpqLajJO0mQH33HSQ5u4lQuzZ07Fj89w2mAjQOY8aYBXd274avvrIvHiGEvd7Z+A5HEo5kj0tFluLRzo/m8woRqIqaRuoQjOcMy5WzMoBykiI0QniHJ30MX9ZaP5L15zVAM+A+YCzQSmv9kW9CDAwfbv2Qv886y35Fh0dL2k0Ac00jvfFGq79fcbktDI8E/sKwVi33Sm6TJ1slzoUQJUtyejIvrHzBmBvddrSRUiiCw5EjsGaNOTd0qGfv4bpjuOLvFaRlpBUvMD9wTSf9+ms4edKeWIQIJYX6VTkrZfQdpVT2novW+oDW+h2t9eta6+2+C9F+GZkZPL/ieWPurlZ3UaNMDZsiEvmJj7cKz+RU3DRSB9cCNIGeSurw2GOglHO8cSMsXmxfPEIIe7z363scPu88+REbESu7hUHqm2/McZs2VnaMJxpVakT10tWzx4lpiaw/vN4L0flWt25w6aXOcVqa1fBeCFE8hVoYaq2TgZuwCtCUOF/89gV/nv4zexwRFsHYLmNtjEjk5+uvITXVOW7QAFq39s57N6nShJgI51+DIwlHjF+yAlXjxu53kl94IfdrhRChKSU9xW238N6291KtdDWbIhLFUdw0UrDOGbqlkwZ4P0OwbnTeeac59+67kgkjRHF5klz3M9CrwKtCTKbO5LlfnjPmhrcYTt3ydfN4hbDbZ5+Z45tuMnfLiiMyPJKW1Vsac8GyazhunDlevBjWB/6NYSGEl7y/6X0OnjuYPY6JiOGxLo/ZGJEoqvh4+Plnc64oC0NwTyddun9p0d7Iz267zaw0vmMHrFtnXzxChAJPFoZvAXcopV5SSvVWSjVVSjXJ+fBVkHb6btd3bDu+LXusUIzvOt7GiER+Tp60Gt7m5K00Uodg62fo0KED9HK5tTN5cu7XCiFCS0p6ituRiFFtRhlphCJ4fP89pOdoOdiwoZUZUhSuO4Yr/15JSnpKHlcHjho1YOBAc06K0AhRPJ4sDOcDtYAxwE/AVmBb1mN71s+QorXmv8v/a8zd0PQGGlZqaFNEoiBz55qtGJo0gWbNvPsZwViAxuHxx83xV1/BoUP2xCKE8J//bf4fB84dyB7HRMTIkYggllsaaVEzYy6peAkXlbkoe5yUnsS6Q8Gx9Xb33eb400/hwgV7YhEiFHiyMOyNlUrqePTO8XCMQ8pPf/3kdgh7QrcJNkUjCiO3NFJvy60AjQ6Sgw19+0KLHK0YtYaPP7YvHiGE76VmpPLcCvNIxMjWI6WAWpBKSnIvsFbUNFLIvZ/h0n1Li/6GfjRwIFTPsel9/jx88YV98QgR7DxpV7FUa70sv4cvA7XDpF8mGeOrG13t1uBcBI4jR2DpUnPuxhu9/zmNqzQmNsLZXffYhWMcOh8c225KwR13mHOzZ8uBfSFC2azNs9zaLY3rOi6fV4hAtmgRJCY6xzVrQrt2xXvPYOxnCBARYZ01zEnSSYUoukIvDJVSGUqp9nk810YplZHbc8Fqxd8rWLbfXOtO7DbRpmhEYXzxhbnAadXKOnfhbRFhEbSq0cqYC5ZzhgA332we2N++HbZssS8eIYTvpGWkue0W3tP6HmqWqWlTRKK4XNNIhw4tfp/eXvXNheGqA6tITk8u3pv6iWt10hUrYOdOe2IRIth58k9JftnrkUB6Ps8HHdfdwr4X96X9Rbmui0WA8EcaqUOw9jMEqFYN+vc35+bMsScWIYRvzd4ym33x+7LHUeFRslsYxNLT4dtvzbnipJE61C9fn9plnU0QUzJSWHtwbfHf2A8aNrT6GuYku4ZCFE2+C0OlVB2lVHelVPesqVaOcY5HP+ABYK/Po/WTjYc3Mn/3fGNOdgsD2/79sGqVOXfDDb77vGAuQAMwYoQ5/ugjs8KdECL4pWWkud3kvLvV3dQqW8umiERx/fILnDrlHFeoAD16FP99lVJuu4bBkk4KcNdd5njWLKvpvRDCMwXtGN4BLAWWABqYljXO+ZgPDAWeKeyHKqXClVKblFLfZY3rK6XWKqV2K6U+U0pFefRf4WWuX6Rdanehe93ueVwtAsHnn5vjjh2hXj3ffZ7rwjCYCtAAXH01lC3rHB87Bj/9ZF88Qgjv+3Drh+yNd96zjQyL5PGuj+fzChHoXNNIBw2CyEjvvHewnjMEuP56KFPGOT5+3GrpIYTwTEELw7eB5sDlWKmk/8ga53w0AipqrT/x4HP/BfyeYzwZeEVrfQlwBrgr11f5wY7jO/i/P8x/eZ/o/gTKWx3ShU/4M40UoFGlRsRFxmWPTySeMErBB7rYWBg2zJybPdueWIQQ3nc2+SwTfzYzXe5qdRe1y9XO4xUi0GkNX39tznkjjdTBtTLpmoNrSEpL8t4H+FBcHNxyizkn6aRCeC7fhaHW+oTWeofWejtQH5ibNc75+FNrXehOqEqpWsBVwLtZY4XV6uLLrEtmYe1A2sK1AXCbGm3o36B/HleLQPDnn7AxxxE/pdwXPd4WHhYe1AVoAG691Rx//TWcO2dPLEII7xq/eDxHEo5kjyPDIhnfbbyNEYni2rgRDuS4/xgb635evDjqla9HvfL1ssepGamsPrjaex/gY67ppD/8AIcP2xOLEMHKk3YV+7XWqUqpaKXUxUqpJq6PQr7Vq8BYIDNrXAmI11o7TjgdBC7K7YVKqZFKqQ1KqQ0nTpwobOiFtvv0bj7Zbm58Tug2QXYLA5zrbmH37lb5bl8L5gI0YB3Wr1vXOU5Kgrlz7YtHCOEdqw+sZvqG6cbc410fp065OjZFJLzBNY20f38oVcq7n+GWTro3eNJJ27aF5s2d48xM66yhEKLwPGlXUTPrTGAi8CewLcdje9bPgt5jEHBca12k36C11jO11m211m2rVKlSlLfI1+QVk8nUmdnjJlWaMPQy2zYvRSH5O43UIdgL0ISFwfDh5pxUJxUiuKVlpDHyu5FonGeeL614KRO6TbAxKuENrgtDb6aROrguDJfuX+r9D/ERpdx3Dd97z1ogCiEKx5N2Fe8CbYExwACs9E/Ho1fWz4J0Aa5WSu0DPs16zWtAeaVURNY1tQC/dws/cPYAs7aYt5YmdJ1AmCpmcyDhU9u3Ww+H8HC47jr/fLbbwvDwhqAqQAPu6aRLlsDff+d+rRAi8E1dPZXtx7cbc9MHTScmIsamiIQ37NwJv+eozBAebhWe8TbXc4ZrD64lMS3R+x/kI8OHQ1SO8oV79sDy5fbFI0Sw8WTV0wV4UGv9mtZ6kdZ6meujoDfQWo/XWtfSWtcDbgJ+1lr/A6vq6fVZl90GfOPhf0exvbjqRdIynbWNL65wMTc2u9HfYQgPue4W9ukDPthMzlXDSg0pHVU6e3w66TT7z+73z4d7SaNG0N6lPedHH9kTixCiePac3sMzy8wC4bddfhu96xfmvq0IZK67hT17QsWK3v+c2uVq06BCg+xxWmYaK/9e6f0P8pFKlWCoS6KXFKERovA8WRgeB3xVnmocMEYptRvrzKFf/xofSzjGO7++Y8yN7zqeiLCIPF4hAoHW9qWRAoSpMFrXaG3MBVsBGnDvaTh7tvW/rRAieGitGf3DaJLTk7PnKsVW4qV+L9kYlfAWf6SROgRz2wpwTyf98kuIj7cnFiGCjScLw38D45RSZQu8shC01ku11oOy/vyX1rq91voSrfUwT6qcesPLq182vkxrla3FiMtH5PMKEQg2bbIqkjpERvr2yzI3bWu49zMMNjfeCBE57oH88YdZ5VUIEfg+2f4JC/csNOam9ptK5VKVbYpIeMuhQ7BunTnnuivmTa7ppEv3LfXdh/nAFVeYhdWSk+ETTxqqCVGCebIwvBaoA+xXSi1USn3u8visoDcIRKeTTvP2hreNubGdxxIVHpXHK0Sg+PRTczxgAJQv798Y2tQ0K5MGWwEagMqV4aqrzDnpaShE8DiddJqH5j9kzPWu31tucIYI196F7dvDRbnWbveOXvXNHcP1h9eTkJrguw/0srAwuOMOc07SSYUoHE8WhpWBPcBmIBKo4vKo6vXo/OCNtW8Y/+BVjavK3a3vtjEiURh2p5E6uBag2Xh4Y9AVoAH3IjSffAJpablfK4QILGMXjeVEorOFU3R4NNOvmi6tlkKEP9NIAWqWqUnDSg2zx+mZ6az4e4VvP9TL7rjDqlLqsHEjbN5sXzxCBAtP+hj2Kujhy0B94XzKeV5b+5oxN6bjGGIjY22KSBTWmjVm9czYWLj6av/HcUnFSygTVSZ7fCb5DHvj9/o/kGIaNMjcbT15EubPty8eIUThLN+/nPc2mdshT3R/gksrXWpTRMKbTp+GpUvNOX8cmehZt6cxDrZ00jp1oG9fc052DYUoWJF6MShLzRwtJoLStA3TOJN8JntcIaYC97a718aIRGG5ppFedRWULp37tb4UpsLc00mDsABNdLR11jAn6WkoRGBLSU/hn9/905hrXLkxY7uMtSki4W3ffQcZGc5x48ZWNWlfc00nDbYCNOBehOajj6zzhkKIvHm0MFRKDVRKrQWSgQNAi6z5d5RSw/N9cYBJSkti6uqpxtyDHR6kbLRXausIH8rIgC++MOfsSCN1cC1AE4wLQ3BPJ503Tyq5CRHIJq+czB8n/zDmZg6eKWfkQ4i/00gdXAvQbDy8kXMp5/zz4V4yZIjVvsLhzBn3/z2FEKZCLwyVUiOAecAfwEgg5+GFXcBdub0uUL3767scv3A8e1w6qjQPdnjQxohEYf3yCxw54hyXLg0DB9oXj+uO4cYjwVnSs3NnuPhi5zglxX0BLoQIDLtO7WLSL5OMuXta30PXOl1tikh4W2IiLFhgzvlrYVi9dHUuq3xZ9jhDZwTdOcPoaKvhfU6STipE/jzZMZwIvKi1vg340OW5HUATr0XlY6kZqUxZNcWYG912NBVjfdAtVnidaxrpkCHWGUO7hEoBGqXcdw2lOqkQgUdrzajvRpGakZo9VzWuKpOvmGxjVMLbFiyApBzdo2vXhjZt8r7e29z6Ge4N/nTSxYthb/CVARDCbzxZGNYFFuXxXDIQNDmYc7bM4eC5g9njmIgYxnQaY2NEorDS0mDuXHPOzjRSgAYVGlAuulz2+GzKWfac2WNjREXnujBcsUK+RIUINLO2zHI78/Vq/1epEFvBpoiEL7imPQ4dalba9LVgb3QP0Ly51d4jpw8+sCcWIYKBJwvDA0CrPJ5rC+wufji+l56ZzvMrnjfm7m51N9VKV7MpIuGJn3+2KmY6lC8P/frZFw+AUiokCtAANGhgpZTm9KFrfoAQwjYnLpzgkYWPGHP9G/TnpmY23yETXpWWBt9+a875K43UoUe9HsZ409FNxCcH38Fz113DDz4wC/oIIZw8WRi+BzyVVWTGkbinlFJ9gLHAO94Ozhc+3/G5sZsTGRbJY10eszEi4QnXNNJrr4WoAKizECoFaABGuPTEnj3b6hsphLDfo4se5XTS6exxbEQs066aJj0LQ8yyZWbxr0qVoFs3/8ZQNa4qTas0zR5n6kx+2f+Lf4PwgptuglKlnOODB2HhQvviESKQebIwnAzMAWYBjm+lVcAC4DOt9etejs3rMnUmz/3ynDE34vIR1ClXx6aIhCdSUtxTa+xOI3UIlQI0ADfcYC62d++GtWvti0cIYVn812JmbzEP/j7V4ynqV6hvU0TCV1y/6wYPhggbGoSFQjpp2bIwbJg5J0VohMidJw3utdb6PqAhcD/wBPAvoEnWfMD75o9v2HFiR/Y4TIXxeNfHbYxIeGLBAjh71jmuUgV69cr7en/KrQBNps60KZriqVDB+iUkJylCI4S9ktKSGPX9KGOuRbUWcj4+BGVmwtdfm3P+TiN1cO1nGGyN7h1c00nnzYMTJ+yJRYhA5nGDe631Hq31TK31c1rr6VrrXb4IzNu01m6lvW9qdhOXVLzEpoiEp1zTSK+/3p47qLmpX74+FWKchR/Op55n/aH1NkZUPK5FaD77zNqxFULYY9Ivk9h92nmUX6GYMWgGkeGRNkYlfGH9ejh82DmOi4O+fe2JpXvd7sZ489HNRipzsOjaFRo2dI7T0mDOHPviESJQedLH8EGl1At5PPe8Uup+74XlfQv3LHRL7xvfdbxN0QhPJSZad/hyCpQ0UrAK0HSq3cmYe3rZ0/YE4wVXXmk2Bj59Gn74wb54hCjJdhzfwZSVZoule9veS8daHW2KSPiSaxrpgAH2tWSqXKoyLaq1yB5rNMv3L7cnmGJQyn3X8L335Py8EK482TEcTd6VR3dlPR+w/vvLf43xNZddQ7OqzWyKRnjq++/hwgXnuGZN6w5gIHmg/QPGeP7u+Szbt8ymaIonKsp94S13V4Xwv0ydyT+/+ydpmWnZczVK1+C5Ps/l8yoRrLR2XxjalUbq4HrOMFjTSUeMgPBw5/i33+T8vBCuPO1jmNfCcC9Qr9jR+Mjy/ctZ8fcKY25it4k2RSOKwjWN9IYbIMzjRGjf6t+gv1vazfjF44Oy2T24Vyf97js4dcqeWIQoqd799V1WHlhpzL1x5RuUiymXxytEMPv9d9iV44BORARcdZV98QD0rNfTGAdjARqA6tVh0CBzTorQCGHy5FfrM0CjPJ5rBJwrfji+8d/l5m5h/wb93apIisB17py1Y5hTIKWROiileL6P2SNz9cHVfLfrO5siKp527dzPZHz+uX3xCFHSHE04ythFY425wQ0Hc23ja22KSPia625h795Wv1479ajbA4WzHcrWY1s5mXgyn1cELtd00k8/hYQEe2IRIhB5sjD8FnhaKdU856RSqhnwFPCNNwPzlvWH1rPor0XG3BPdn7ApGlEU8+aZhU/q1YP27W0LJ1+da3dmUEPzluTEnycGZYVSpXLvaSiE8I+HFzzM2RRnKea4yDjeHPim9CwMYYGWRgpQIbYCLau3NOaC9ZjElVdCjRrOcUKC3PAUIidPFobjgZPAJqXUeqXUPKXUemAzcBwIyL4PrpVIu9ftTtc6AXY4TeTL9R/tG2+0Fi2BalLvScbd1W3Ht/HJtk9sjKjo/vEPc7xmDfz5pz2xCFGSzN89n0+3mzn0z/Z6VvruhrC//4aNOWrkKQVDhtgXT06u6aTBes4wIgJuu82ck3RSIZw86WN4GmgH3AfsAWKzft4LdNBan/FJhMWw7dg2vtlpbmTK2cLgcu4cLFxozt1wgz2xFFaLai24ufnNxty/l/6b1IxUmyIqunr1oLt5bFKK0AjhYxdSL3Dv9/cac61rtOaBDg/k8QoRClx7F3bsaO5u2SkUGt073HmnOV61yjrbKYTwsI+h1jpZaz1Da32T1rpv1s93tNYB2eHsuRVm1bZ2NdvR92KbmgGJIvn+ezONtH59aNXKvngK6z89/0NEmLPJ4l9n/uK9X4PztqRrOumcOVYDZiGEbzyz7Bn2xe/LHoepMGYOmmn8myJCTyCmkTp0q9uNMOX8lXHHiR0cv3DcxoiK7tJLoUcPc+799+2JRYhAU6S6jkqpcKVUKdeHt4Mrjl2ndvH5DjMHcWK3iXI2I8jMnWuOr78+sNNIHRpUbMA9re8x5v6z/D8kpiXaFFHRXX89xMQ4x/v2wcqVeV4uhCiGLUe38PLql425B9s/KAXTQtzJk7DcpT1gIC0My8eUp1V1865ssJ4zBPciNLNnWwXWhCjpPGlwX1Yp9aZS6jCQApzP5REwXljxglHwo1nVZgxuNNjGiISnLlxwb6p+3XX2xFIUT3Z/ktgIZ1fiowlHeX3t6zZGVDTlyrmfc5F0UiG8LyMzg5HfjSRDZ2TP1S5bm2d7P2tjVMIfvv3WzMRo1gwuucS+eHITSumk110HZcs6x8ePWy2ZhCjpPNkxnAHcBnyGda7wzlweAWF//H7mbDV/c53YbaKRBiEC3/z5kJTkHNeuHbjVSHNTo0wNHuzwoDE3eeVkziQF3HHcAt16qzn+/HNITrYnFiFC1bQN01h3aJ0x99bAtygdVdqmiIS/BHIaqUOv+qGzMCxVCm65xZx79117YhEikHiyUuoPPKy1fjjrXOEs14evgvTUi6teJD0zPXt8acVLGdZkmI0RiaL48ktzfO21wZFGmtO4LuMoF+1sRB2fHM+Lq160MaKi6dcPqlZ1js+ete5wCyG849C5Q0xYPMGYu7bxtZLpUgIkJLgXWQvEhWHXOl0JV+HZ4z9O/sHRhKM2RlQ8rumk8+fDoUP2xCJEoPBkYXgBOOirQLzlyPkjvPuredtnfNfxhIeF5/EKEYiSk93TOq6/3p5YiqNCbAXGdjEbVL+29rWg+zKNjISbzUKr0tNQCC96cP6DnE91nsgoE1WG1wcEX+q58Nz8+WaRtbp1oWXLvK+3S9nosm5nXYO1bQVAmzbQooVznJkJ//ufbeEIERA8WRhOBUYrFdj5mC+vfpmUDOe/sHXK1WF4i+E2RiSKYuFC6y6qQ40a0LmzffEUx786/ItqcdWyx4lpifx3+X9tjKhoXKuTzp8PJ07YE4sQoWTeznl89ftXxtzzfZ7norIX2RSR8Kfc0kgDNTvG7Zzh3uBNJ1XKfdfw/fel6rYo2TxZ5F0EXA7sVErNVEpNcXlM9lGMhXYq8RTTNkwz5sZ2HktkeKRNEYmick0jveYaCAvoWxJ5i4uK44nuTxhzMzfOZO+ZvTZFVDStWkGTJs5xejp8+mne1wshCnY+5Tz3/XCfMdfhog6MajvKpoiEP6WmWm2ZcgrENFIH14Xh0v1L7QnES4YPh+ho5/ivv2BZ8BZbFaLYPPlV+3ogE4gA+gLDcnnY6rW1r3Eh7UL2uHrp6tzZKmBq4ohCSk2FefPMuWBMI81pZJuR1CtfL3uclpnGU0ufsi+gIlDKfddQ0kmFKJ4nlzzJwXPOUxrhKpyZg2fK8YcSYskS68y2Q5Uq0KWLffEUpEudLkY/zV2ndnH4/GEbIyqeihXdF+LvBWfLYSG8otALQ611/QIeF/sy0IKcTT7LG+veMOYe6fQIsZGxebxCBKrFi80vysqVoVs3++LxhqjwKP7T8z/G3IdbP2TbsW02RVQ0//iHmeK0YQP8/rt98QgRzDYc3pDr91aLai3yeIUINV9/bY6vvhrCA/ieQOmo0rSr2c6YC+Z0UnBPJ507F84EX/FwIbwiSJPz3L29/m3ik+OzxxVjK0oqTpBybWp/zTUQEZH7tcHklua30LRK0+yxRvPEkifyeUXgqVULevc256SnoRCeS89MZ+S3I41+u/XK1+OpnsGVSSCKLjMTvvnGnAvkNFIHt3TSIC5AA9Z3Wr16znFyMnz8sW3hCGErjxaGSqmLlVLTlFLblFKHsn6+rZSydbcwMS2RV9a8Ysw91OEh6f0UhNLT3e+gBlNT+/yEh4UzqfckY27eznmsPrDapoiKxrWn4Ycfyv0F01UAACAASURBVGF9ITz1+trX2XR0kzE37applIosZVNEwt/WroUjR5zj0qWhTx/74imsnvV6GuNg7mcIVv2CO+4w5ySdVJRUhV4YKqXaAJuB64D1wOysn9cBm5RSrX0SYSG8s/EdTiQ6yyOWiSrD/e3vtyscUQzLlsGpU85xhQruO1TB7OpGV9OxVkdjbsLPE9Ba2xSR56691moO7HDggBzWF8IT++P38+SSJ425m5rdxIBLBtgUkbCDazXSgQMhJsaeWDzRpU4XIsOcRf32nNnDgbMHbIyo+G6/3TwmsWmT9RCipPFkx/AlYBNQT2t9p9Z6vNb6TqB+1vxLvgiwICnpKUxZNcWYu6/dfVSIrWBHOKKYXKuRXn211UMvVCileK73c8bc0n1LWfTXIpsi8lyZMu7pTpJOKkThaK2574f7SExLzJ4rH1OeV/u/amNUwt+0zr1NRTAoFVmKDrU6GHPBnk5apw7062fOya6hKIk8WRi2B6ZorRNzTmaNXwI65PoqH5u1ZZZRESs2IpaHOz1sRyiimDIy3L8og70aaW561e9F34v7GnMTFgfXrqFrOukXX0BiYu7XCiGc5v4+l+//NPsTTLliCtVKV8vjFSIU7dgBu3c7x1FR1o5hsOhZt6cxDvZ0UoC77zbHH30ESUn2xCKEXTxZGCYBlfJ4riKQXPxwPJOemc4LK14w5ka2GUnVuKr+DkV4wcqVcOyYc1ymDPTtm/f1wey5Puau4cYjG5n7+9w8rg48ffpAjRrOcUKCexEFIYTpbPJZHvzxQWOuS+0u3NX6rjxeIUKV603QPn2gbFl7YimKXvVdGt2HwMLw6qutKugO8fHu/3cSItR5sjD8HnhBKdU152TW+HngW28GVhifbPuEvfHOJuGRYZE82vlRf4chvMS1GungwWbj2VDStmZbrm9iboc+8fMTpGem2xSRZyIi4JZbzDnpaShE/sYvHs+RBGe1kciwSGYOnkmYCpkC4aKQgjWN1KFTrU5EhUdlj/fF72Nf/D77AvKCqCj3bBhJJxUljSffRmOAv4BlSqkjSqktSqkjwHJgL/CILwLMz/MrnjfGd7S8g1pla/k7DOEFmZnuC8NQqUaal2d7PWv8Qrjz1E5mbZ5lY0SecW12v3AhHD1qTyxCBLrVB1YzfcN0Y25cl3E0qdLEpoiEXfbtMwubKGXtVgWT2MhYt0JqwX7OENx7Gv78M+zZY08sQtjBkwb3p7TWXYGrgLeBlVk/B2itu2qtT+X7Bl52JvkMv590dtYOV+GM6zrOnyEIL1q3Dg4dco5LlYIBIV6g77LKl3H75bcbc08ve5rkdL9nZRdJixbWwyEzU3o/CZGbtIw0Rn43Eo3zHPElFS9hQrcJNkYl7OLakqlLF6gWhEdMXfsZhkI6adOm0MGlYsYHH9gTixB2yHdhqJSqoZSaq5Tq75jTWs/XWj+rtR6ttX7WukzNVUr59WDfkfNHjPEtzW/h4gq2tlMUxeBajfSqq8yWCKHqqZ5PGek4B88dZNr6aTZG5BnXXUOpTiqEu6mrp7L9+HZjbvpV04mNjLUpImGnYE8jdXBbGO5dElRF1PLiumv4v/9ZxfGEKAkK2jF8FLgYWJjPNQuxWlb4NZU0Kc1ZKkqhGN91vD8/XniR1iUvjdShTrk6jG472ph7bsVznE85b1NEnrnlFqs5sMPmzbBtm33xCBFo9pzewzPLnjHmRlw+gj4XB0Enc+F1J07AihXmXLAuDDvU6kBMhLPx4oFzB4y6D8HqxhvNG9OHDsGCBfbFI4Q/FbQwHARM1/ncAsp6bgYwpKAPU0rFKKXWZZ1P3KGUeiZrvr5Saq1SardS6jOlVFRB75XTtY2vpXGVxp68RASQX3+1zlw4xMQEV9nu4prQbQKlo0pnj08mnuTl1S/bGFHh1ajhXjlWdg2FsGitGf3DaCM9vFJsJab2m2pjVMJO8+ZZafcOl18O9evbF09xxETE0KlWJ2Nuyd7gTyctW9ZaHOYkRWhESVHQwrAu8Fsh3ud3oF4hrksBemutLwdaAgOUUh2BycArWutLgDOAR7W7J3ab6MnlIsC47hb272+1qigpqsRVYUzHMcbc1NVTOZl40qaIPONaxe2jjyTtRgiAT7Z/wsI9ZsLNS/1eonKpynm8QoS6UEkjdQjFc4bgnk46bx4cP25PLEL4U0ELwySgMJ11Smddmy9tScgaRmY9NNAbcJwymwUMLcRnAjDw0oG0qtGqsJeLAKO11Rw9p1Bsal+QRzo/QqVYZ5vQ86nnef6X5/N5ReAYOhRKOzc8OXzYquQmREl2Ouk0D81/yJjrVa8Xt11+m00RCbudPw+LFplzQb8wdOlnuHTf0pA4Z9i5MzRq5Bynp0s2jCgZCloY/goUpojykKxrC6SUCldKbQaOA4uAPUC81trRwO0gcFFh3gtktzDYbdsGu3c7x5GRMGiQffHYpWx0WbcKhW+tf4sDZw/YFFHhxcW5nwmVnoaipBu7aCwnEk9kj6PDo5k+aDpKKRujEnb68UdITXWOL74Ymje3Lx5vaFezHbERziJKh84fYvfp3fm8Ijgo5b5r+O671s1sIUJZQQvDt4G7lFJ53uJUSo0A7gDeLMwHaq0ztNYtgVpAe+CyQsaKUmqkUmqDUmoDWHdfO9fuXNiXiwDkmkbaty+UL29PLHYb3W600YczJSPFrWhFoHKtTvrVV5CQkPu1QoS65fuX894m81DSxG4TaVipoU0RiUCQWxppsN8niI6IpkudLsZcqKSTjhgBERHO8R9/wNKltoUjhF/kuzDUWs8FXgM+UEqtV0o9q5S6Ryl1t1LqP0qptcAHwOta6//L771yee94YAnQCSivlHL89asFHMrjNTO11m211m1BdgtDgWubipJSjTQ3MRExPNXjKWPug80fsPPkTpsiKryePaGWc01LYqL7L0FClAQp6Sn887t/GnOXVb6MsV3G2hSRCAQpKfD99+ZcsKeROrieMwyFRvdg9ZZ0zWAaM0bO0IvQVmCDe631I1ipouew2lfMAGYCjwHngSFa60cL82FKqSpKqfJZf44F+mIVrlkCOE6W3QZ8U9B71a9Qn971exfmY0WA+v13+C1HaaPwcBhSYG3b0HZ7y9uNXYVMncmTS560MaLCCQuD4cPNOUknFSXR5JWT+ePkH8bczEEziY6ItikiEQh+/tk6Y+hQrRp06pT39cGkZ72exnjJvtDoZwjWQjCnzZthxgx7YhHCHwpcGAJorb/VWvcBygA1sh5ltNZXaK2/8+DzagBLlFJbgfXAoqzXjwPGKKV2A5WAAgsDV4ytKGc1gpxrGmmvXlCpUu7XlhQRYRE82+tZY+6L377g1yOFOsJrK9fqpIsXW/2fhCgpdp3axaRfJhlzd7e6m251u9kUkQgUrhkUQ4aYPWCDWbua7YiLjMseH004ys5TgZ/pUhjdusFNN5lzEyda/SiFCEUe/bOktU7XWh/LeqQX/Aq312/VWrfSWrfQWjfTWv8na/4vrXV7rfUlWuthWusUT99bBB/XhWFJrEaam+ubXE+r6mal3QmLJ+RxdeBo0gRat3aOtbZaVwhREmitGfXdKFIznNVFqsZVZXLfyTZGJQJBRgZ845IHFSpppACR4ZF0rdPVmAuVdFKAl14yK2/Hx8P48fbFI4Qvhcj9KhFs9uyxUjIclLLaHggIU2E81+c5Y27BngUs27fMpogKz7UIzezZUsVNlAyztsxyK7rxSv9XqBhb0aaIRKBYvdrsgVe2LPQOsZMwuaWThoqLLoJ//9uce+89WLfOnniE8CVZGApbuO4Wdu9unbkQlv4N+tOjbg9jbvzi8QF/buPmm62zog47dpg3AIQIRScunOCRhY8Yc/0a9OPmZjfbFJEIJK5ppFddBVFR9sTiK7kVoAn07ytP/OtfcJlLDf377pNCNCL0yMJQ2EKqkeZPKcXzfcwG96sPrubbXd/aFFHhVK0KAwaYc9IUWIS6Rxc9yumk09njmIgYpl01Tc7BC7TOvU1FqGlTsw2lo5z5lscvHOf3k7/bGJF3RUXBG2+Ycxs2wPvv2xOPEL4iC0Phd/v3w/r15ty119oTSyDrVLsTgxsONuYm/jyRjMzAvkXpWoTm448h3eMTyUIEh8V/LWb2FrME71M9nuLiChfbFJEIJFu3wt69znF0NFx5pX3x+EpEWATd6phFlpbsDZ10UoArrnCvhTB+PJw+nfv1QgQjWRgKv/vqK3PcubOVwy/cTeo9CYVz12H78e18sv0TGyMq2NVXW2doHI4dg0WL7ItHCF9JSkti1PejjLnmVZvzSKdH8niFKGlcdwv79jULmYQS13TSUDpn6DB1KpQq5RyfOmVVKRUiVMjCUPid6/lCSSPNW/Nqzbml+S3G3L+X/NuofBhoYmNh2DBzTnoailA06ZdJ7D69O3usUMwYNIPI8EgboxKBpCSkkTr0qu9+zjBTZ9oUjW/UqeO+EJwxA34N/I5SQhSKLAyFXx0+DCtXmnOyMMzfMz2fISIsInu8N34v7/76ro0RFcy1OunXX8O5c/bEIoQv7Di+gykrpxhzo9qOolPtEOlaLortr7+sVFKHsDAYPDjv64Ndq+qtKBvtTBc5lXSKHcd32BiRbzzyCFxyiXOstVWIJjO01sCihJKFofAr17unbdtC3br2xBIsGlRswD2t7zHmnl3+LBdSL9gUUcG6djX/75qc7F5wSIhglKkz2XVqFyO/G0laZlr2fI3SNdwKRomSzfX7rls3qFLFnlj8ITwsnO51uxtzoZhOGh0Nr79uzq1ZA7Nm2ROPEN4kC0PhV66LA2lqXzhPdn+S2IjY7PHRhKO8se6NfF5hr7Aw9yI0Up1UBButNfvi9/Hlb18ybtE4+szuQ8XJFWn0ZiNWHVhlXPv6la9TLqacTZGKQFSS0kgdSsI5Q7AKCA0ZYs6NGwfx8fbEI4S3qGDtM9O2bVu9YcMGu8MQHjh+HGrUMNMt/vzTTMkQeRv/03heWPlC9rh8THn+evAvKsRWsDGqvO3aBY0amXP79skOsQhcR84fYcPhDaw/vD7758nEkwW+blDDQcy7aZ60pxDZjh2zvu9y/opVEv7923RkE61nts4eV4ipwMmxJwlTobcPsXcvNGliZcQ4PPCA+26iEL6mlNqotW7rjfcKvb+pImB9/bW5KLz8clkUemJsl7GUjymfPY5Pjnc74xRIGjaEDh3MuY8+sicWIVydSjzFgt0LmLR8EkM/HUqtl2tR8+WaXP3p1Ty7/Fl+3P1joRaFFWMr8uaVb8qiUBi++cZcFLZqFfqLQoAW1VoY31Nnks+w9djWfF4RvOrXh8cfN+feess8VypEsJGFofAbaWpfPBViKzC281hj7rW1r3Hk/BGbIiqYazrp7NnmL0tC+MO5lHMs3beUF1e+yI1f3sjFr11M5RcrM+CjATyx5Am+2fkNh84fKvT7lY8pzxUXX8GErhNYd/c66pYvAb/xC4+UxDRSsM4Z9qjbw5gLtX6GOY0day0QHTIzrUI08j0ngpWkkgq/OHUKqlWDjBy92X/7DRo3ti+mYHQh9QINXm/AsQvHsudGtx3NW1e9ZWNUeTt5EmrWhDRnjQ7WrYN27eyLSYS2xLRENh/dbKSE7jy5E03RvuviIuNoXaM17Wq2o23NtrS7qB0NKjSQHUKRp7NnrSIzOf/d27YNmjWzLyZ/em3Nazy04KHs8dWNruabm76xMSLfmjfP/bzhnDkwfLg98YiSx5uppBEFXyJE8c2bZy4KGzeWRWFRxEXF8WT3J7n/x/uz52b+OpNHOj/CxRUutjGy3FWuDAMHWmlVDnPmyMJQeEdqRirbjm0zzgTuOL6DDJ1R8ItzER0eTcvqLa0FYNZC8LLKlxEeFu7lyEUo++EHc1F4ySXQtKl98fhbz3o9jfGyfcvIyMwI2b9Hgwdb33M//OCce+wxuPpqKFs279cJEYhkYSj8wrWpvVQjLbp72tzD1NVT2Ru/F4D0zHSeWvoUc64JzLKft95qLgw/+QSmToVI6QEuPJCRmcHvJ39n/SHnInDLsS2kZqQW6f3CVTjNqzV37gTWbEfTqk2JCo/ycuSipMktjbQkbTA3r9acSrGVOJV0CoCzKWfZfHQzbWq2sTky31AKXnsNfvoJUrP+OTp6FJ55xvquEyKYSCqp8Lnc0mo2b7aKz4iimbNlDiO+dnaRVyi2jNpC82rNbYwqdykpUL26WcZ73rzQbvQsiidTZ7L79G5rAXhoPRuObODXI7+SmJZYpPdTKBpXaWzsBF5e7XJiI2MLfrEQHkhOtr7vEhKcc6tWQadO9sVkh+s+v46vfv8qe/xS35d4pPMjNkbke088AZMmOcfh4bBlS8naLRb2kFRSEVS++849raZFC/viCQW3NL+FKaumsP34dgA02iqiEYDnOKKj4cYbYcYM59zs2bIwFCatNcv2L2P6hunM3z2fsylni/xeDSo0oN1F7WhbwzoT2Kp6K8pEl/FitELk7qefzEVhjRru1ZlLgp51exoLwyX7loT8wnDCBOuoxN9/W+OMDKt9xeLFJWvHWAQ3WRgKn8utGqn8I1k84WHhTOo9iSGfOk+8z9s5j1UHVtG5dmcbI8vdiBHmwvDbb+HMGagQmC0YhR/FJ8cza/Mspm+czh8n//D49bXK1jLSQdvUbEPF2Io+iFSIgrmmkQ4ZAmElsP57r/pmo/vl+5eTnplORFjo/tpZqhS88opZcX3JEvj8c+vmqBDBQFJJhU8lJFhpNTkbwK5fD229suFdsmmt6fJ+F1YfXJ0916NuD5bctiTgKiZqDZdeCnv2OOdmzICRI+2LSdhr4+GNTNswjY+3fUxSelKhXlOlVBXaXdQueyHYtmZbqpeu7uNIhSic9HRrh/BkjvaXCxZAv372xWQXrTXVXqrGicQT2XPr7l5Hu4tCu/KY1tC/Pyxa5Jy76CL44w8oXdq+uEToSkpLolRUKUklFcHhhx/MRWHdutAmNM+f+51Siuf6PEevWc47s8v2L2PhnoX0v6S/jZG5U8oqQvP00865OXNkYVjSJKYl8tn2z5i2YRrrD6/P99ryMeWtxV9WOmjbmm2pXbZ2wN30EMJh5UpzUViuHPTsaVs4tlJK0bNeT7747YvsuSX7loT8wlApeOMNaN7ceYTm0CH473/hhRfsjU2EnlOJp+g9u7dX37MEJjgIf3KtRipppN7Vs15P+jUwb0dP+HkCmTrTpojy5trTacUK+Osve2IR/rXz5E4env8wF718EXfOuzPPRWFEWATXN7mexSMWc2rsKRbduojnr3ieaxtfS51ydWRRKAKaaxrpoEEQVYKL3Lq2rViyL3Qb3efUqBGMGWPOvfwy7NxpTzwiNMUnx9Pvw35sPbbVq+8rC0PhM0lJ8P335py0qfC+53o/Z4x/PfIrc3+bm8fV9mnQALp0Mec+/NCeWITvpWWk8eVvX9Jndh8ue+syXl37KvHJ8bleW6tsLf7T8z/8/dDffDHsC3rX702Ykq8nETy0zr1NRUnWq555znDF3ytIy0jL4+rQ8sQTVgqpQ1qaVYgmSE9viQBzLuUc/T/sz69HfvX6e8s3r/CZBQvgwgXnuGbNklmdzdfa1GzD9U3MFfeTS54kPTPdpojyduut5nj2bPmiDDUHzh7g30v+Td1X6zLsi2H8vPfnPK/t36A/X9/4NXv/tZcnezxJjTI1/BipEN6zaZOzGiVATAwMGGBfPIHgssqXUS2uWvY4ITWBjUc22hiR/5Qu7d7DcNEi95sHQngqITWBgR8NZN2hdT55f1kYCp/JrRppSazO5g/P9nrW2GHZeWonszbPsjGi3N1wg5latWcPrFljXzzCOzJ1Jgt2L2Dop0Op91o9nl3+LEcSjuR6baXYSjzW+TF2P7Cb+cPnM+SyISFdqVCUDK6/8PfrB3Fx9sQSKBznDHNasrdkpJOC9X3Xy9w05eGHIbFo7ViFIDEtkcGfDGblgZU++wz5NV34REqK1ZIgp5wlnIV3XVb5Mu5oeYcx9/Syp0lOT87jFfaoUMG9f+Hs2fbEIorvZOJJXlz5Ig3faMiAjwbwzc5v8jzf2rl2Z+ZcM4eDYw4ype8UGlRs4OdohfAdSSPNnWs6aUk5ZwjOQjQROe57/f03PP+8fTGJ4JWcnsyQT4ewdN9SY75jrY5e/RxZGAqf+OknOHfOOa5aFbp2tS+ekuCpHk8RHR6dPT547iBvr3/bxohyN2KEOf7sM+tGgggOWmtWHVjFrf93K7VersXYn8ay58yeXK8tHVWaUW1GsWXUFlbeuZLhLYYTExHj54iF8K0//4QdO5zj8HD3G2AllWs/w5UHVpKakWpTNP7XtCk8+KA5N2UK7N5tTzwiOKWkp3DtZ9fy018/GfNta7blx3/86NXPkoWh8AnXaqTXXGN9WQrfqV2uNqPbjTbmnvvlOc6lnMvjFfYYMAAqVXKOz5xxL1IkAs/5lPNM3zCdljNa0uX9Lny49UNSMnJf0Tev2py3B77N4TGHmTZoGi2qtfBztEL4j+tuYffu5r9xJdmlFS+lRmnn2eHEtETWH8q/VU2oeeopqJ6j3WpqKjz0kH3xiOCSmpHKDV/ewI+7zQVgy+otWTB8AeVjynv182RhKLwuLQ2+/tqck2qk/jG+63hKR/0/e/cdHkXVBXD4d9NIILRQBASkg9I7qDRFpAUQEBWQJqAoCvbyqdi7KGJBQKWIdJFiRSEKirSAgDRFmnSQXgJJ7vfH3ZCd3Q0ksNmZzZ73eXjC3JndnOzs7sy5NX0V3UOnDzF8yXAbI/IWFQV33GEtmzjRnljExa3dt5Z7v76XEsNLMOjrQRlOjR0VHkWP6j1Y3Hcxf9zzB4PqDyJvrrwBjlaIwJNupBlTSnm1GoZSd1KAfPngzTetZV9/7T3cRghPyanJdJ/ZnTmb5ljKqxWtxvw75xMXE+f33ymJofC7hQtNK1CauDho1sy+eEJJkTxFeLjxw5ayt5e8zYGTB2yKyDfP2Um//hoOHbInFuEtKTmJSWsmcf2n11NjVA0+WvERJ86e8Hls2QJleb3l6/z74L983vlzrit9naw3KELGnj3eE2h16mRPLE7lOc7Qc4xUKOjRw3s4zZAhZlkvIXxJSU3hzll3MnODtQtelcJV+PHOHymcu3C2/F5JDIXfeXYj7dQJIiPtiSUUPdT4IQrFpPdjOnH2BK8udtZo9/r1oVKl9O1z58xYQ2Gvfw7/w+PzH6fkOyXpOatnhjOfhakwOlTuwLc9vuXvB/7mseseo0ieIgGOVgj7zZ5t3a5XD0qVsicWp/KcmfTXnb+SlBxaA8uVgvfft87MvnWrd0uiEGBm+u43px9T1k2xlFeIq8BPvX7iitgrMnjk5ZPEUPhVSop3txqZjTSw8uXKx1NNnrKUfbj8Q3Ye3WlTRN6U8p6ERmYntUdKagpzNs2hzaQ2VHivAm/89gYHTx30eWyx2GI83eRptg7ZyuzbZ9O6QmtZiF6ENOlGenHlC5anZL6S57fPJJ9h6a6lNkZkj5o14b77rGWvvmoSRCHSpOpU7p57NxP+sN4UlS1QlgW9FlAib4ls/f1yRRd+tWgRHHDrtZg/P9x4o33xhKp7699ruRAnpSTx/M/P2xiRtx49rNtLl8LmzfbEEor2ntjLS7+8RNkRZek4pSPf/f0dGu3z2BZlWjCt6zR2DN3Bize8SOn8pQMcrRDOc+QILFhgLZPE0JtSSrqTurzwAhRx61xx5oxZ21AIMLN+D/5mMGNXjbWUl85fmgW9F1Aqf/Z3R5DEUPiV56L2HTpArly+jxXZJzoimueaPWcp+2z1Z2w8uNGegHwoU8Z77Onnn9sSSsjQWrNw60K6Te9GqXdK8czCZ9h5zHdLcv5c+RnScAgb7tvAgt4LuLXqrUSGS59wIdJ8/TUkJ6dvV64MV19tXzxO5rXQfYhNQJOmQAF4/XVr2ezZ8K1/VxwQQUhrzYPfP8hHKz6ylJfIW4IFvRZQpkCZgMQRcfFDhMic1FT48ktrmXQjtU/vWr1587c32XRoE2C6Jzyz8Bmm3zrd5sjS3Xkn/Pxz+vbEifDcc9ZxGOLiUlJTOHLmCIdOH+K/0/9x6JTrp9v2odOHWL139fn3Q0bqlajHoHqDuL3a7eSOzB2gv0CI4CPdSDPPs8Vwyc4lnEk+E5LrmvbuDaNHWycteuABWLdOKtJDldaax398nBFLR1jKi8UWY0GvBZSPKx+wWJTWvrsOOV29evX0ihUr7A5DuPn1V+usW7GxsH8/xMTYF1Oom/7ndLrN6GYpWzFgBXVL1LUpIqujR836TmfOpJf98gs0aWJfTHbSWnM06WiGyV3atmfZkTNHMuwGmhkxETHcXu12BtUbRP0r6/vxLxIiZzp9GgoXhlOn0suWLoUGDeyLyenKvFuG7Ue3n99e2HuhV0tiqEhMNBMVud+Cv/IKPPmkfTEJ+zyz4BleWvSSpaxI7iIk9EngmiLXXPTxSqmVWut6/ohFWgyF33jORtqunSSFdutyTRfqFK9D4p7E82VPLXiK73t+b2NU6fLnh44drTOSTpgQ/Imh1pqT505eMLk7n+S5lR0+fZgUnRKwOCsXqsw99e6hd83eFIwpGLDfK0Swmz/fmhReeaW50RcZa1G2BeNWjzu/vXBr6CaGderA3XfDqFHpZS+9ZMbel5Yh3CHlxZ9f9EoK42Li+LHXj5lKCv1NEkPhF1p7J4ayqL39wlQYr9zwCq0ntT5f9sOWH0jYluCYC3KvXtbEcPp0eO+94KhUSEpOYtbGWczeNJtdx3ZZkr6zKWftDs+niLAIOlXpxKB6g2hRpoWsOSjEJfDsRtqpk3SBv5jmVzW3JobbFvI8zpoULZBeftlc79LW8D11Ch5+2JSJ0PD64td5NuFZS1mB6ALMv3M+Na6oYUtM0pVU+MXy5dYuNDExZnbSPHnswSPE2wAAIABJREFUi0kYWmtajG/Bz9vTB/M1KtmI3/r95oikIDnZ1Lbv359eNnUqdOuW8WPstungJsYkjmHc6nEcOn3I7nAAs0xJoZhCFMpdiLiYOArFePzMXYhCMYWoW6IuRfMUtTtcIYJWcrLpAn/I7aP/448yA/fF7Di6g6vever8dlR4FIcfPxzSY5nHjIGBA61l8+dDy5b2xCMC550l7/DQDw9ZyvJG5eXHXj/S4Mqs9UmXrqTCcTxnI23TRpJCp1BK8eqNr3Ltp9eeL/v939+Zu3kuHSp3sDEyIyICuneHd99NL5s40XmJ4ZnkM8xcP5MxiWMsSba/5YnMY0nkPJM7X9sFowvKjKFCBMiiRdaksGBBaNrUvniCRen8pSlXsBz/HP4HgLMpZ1mycwk3lgvdjLpfPzMRjXs7x/33wx9/QFSUfXGJ7PXBsg+8ksI8kXn4rud3WU4K/U0SQ3HZfHUjldlInaVxqcZ0qNyBOZvmnC976qenaFexHeFh4TZGZtx5pzUx/PZb04JY1AENW+sPrGfMyjFMWDOB/07/l+nH5QrPZU3uchciLjrj5C5tO1eETEsnhJN5diONj4dIqZfJlOZXNT+fGILpThrKiWF4OHzwATRqlD4RzcaNMGIEPPqovbGJ7DFm5RgGfzvYUhYTEcM3Pb7h2lLXZvCowJHEUFy2P/6ALVvSt6OioH17++IRvr18w8vM3TT3/OyVfx74kzd/e5PBDQYTGxVra2y1a0PVqvDnn2Y7JQWmTDFTeNvh9LnTzFg/g9GJo1m8Y/EFjy0QXYBeNXoRXzmeIrmLnE/2YiJiHNFVVwjhP1rDV19Zy2SZisxrUbYFn67+9Px2qC50765BA7jrLhjrtqb5Cy+YnjRXXmlfXML/xq8ez93z7raURUdEM/eOuTS9yhndDmSotLhsnq2FrVpBvnz2xCIyVq1oNXrU6GEpe/KnJyn8RmHaTGrDh8s/ZOdR34udZzelTKuhuwkTAh/Huv3rGPLtEEoML0Gvr3pdMClsUroJE2+ZyO6HdjOizQhalmtJzWI1KZW/FLkjc0tSKEQOtHIl7HT7moyJMdc8kTmek54t27WMk2dP2hOMg7zyChQokL594oS0GOY0X6z9gr6z+1qWlooKj2LWbbMc1Woe0MRQKVVKKbVQKbVeKfWnUmqIqzxOKTVfKfWX66fMmx5EPMcXymykzvV88+eJCLN2FEhKSeK7v7/jvm/uo/S7pan9cW2eXfgsK3avIFWnBiy2Hj1Mgphm5UpYvz77f++pc6cYv3o81316HdU/qs57y97jyJkjPo+Ni4njwUYPsv7e9fzS9xd61uhJTGQQTJ8qhPALz26krVtD7tCdOyXLSuYrSYW4Cue3z6We49edv9oYkTMUKWJmKXU3eTIkJNgSjvCzGetn0GtWL0tSGBEWwYxbZ9C6QusLPDLwAt1imAw8rLW+BmgE3KeUugZ4AvhJa10R+Mm1LYLA+vWmP3yaiAjoYP98JiID5QqW4+kmT1/wmNV7V/PiLy9Sf0x9Sg4vycC5A5m7aS6nzp264OMuV8mScMMN1rKJE7Pv963Zt4b7v7mfEm+XoM/sPvy287cMj212VTMmdZ7Erod2Mfzm4Vxd5OrsC0wI4VieiaF0I826FmVaWLYXbl1oUyTOcvfdUKuWtez+++HcOXviEf4xe+Ns7ph5h2WN4nAVztSuU4mvHG9jZL4FNDHUWu/RWie6/n8c2ABcCXQExrsOGw90CmRc4tJ5thbeeKOZoU0417Dmw1jcdzFDGw6lXMFyFzx2z4k9jEkcQ4cpHSj8RmHiJ8czZuUY9hzfky2xeXYn/fxzSPVjo+XJsyf5dNWnNBrbiJqjavL+8vc5mnTU57GFYgrxcOOH2XjfRhL6JNC9eneiI6L9F4wQIqhs2gQbNqRvR0TIePpL4ZkYJmxPsCcQh0mbiMbdunXeZSJ4fPPXN9w6/VaSU5PPl4WpMCZ1nkTnqzvbGFnGbFvHUClVBvgFqAbs0FoXcJUr4HDatsdjBgIDAUqXLl13+/btAYtX+FazJqxZk749ejQMGGBfPCJrtNZsOLiBuZvmMmfzHJbsXGLp6nAh9UrUI75SPPGV4qlVrJZfxtQdP27WBzvl1jj500/eLYlZtXrvakavHM2ktZM4lnTsgsfeUPYGBtQZwC1VbpEZQoUQ5732Gjz5ZPp2y5ZmzTmRNXuO76HE8BLnt8NVOIcfP0zeXHltjMo5+vSB8ePTt/PlM5USxYrZFpK4BPO3zCd+cjxJKUnnyxSK8Z3Gc2fNOy/wyKzz5zqGtiSGSqlY4GfgZa31l0qpI+6JoFLqsNb6gu1OssC9/TZvhsqV07fDwmDvXtNXXgSnAycP8M1f3zB381y+3/I9J86eyNTjSuUrRftK7YmvFE+Lsi0uq2WtZ0+YNCl9u08f+OyzrD/PibMnmLJuCqNXjmb57uUXPLZI7iL0rdWX/nX6U7FQxaz/MiFEjpaSYmaPTExML/vgA7j3XvtiCmZV3q/CpkObzm9/3f1r2lZsa2NEzrFvH1SqBMfc6jB79bImi8LZFm5dSNsv2nIm+Yyl/JMOn9Cvdj+//76gTgyVUpHAPOB7rfVwV9kmoLnWeo9SqjiQoLWufKHnkcTQfq++Ck89lb59ww2mdUfkDEnJSSRsS2Du5rnM3TyXHUd3ZOpxeSLz0Kp8K+IrxdOuUjuK5snaYoQ//AA335y+HRtrLpSZneAhcU/i+dbBiyW2Lcu1ZGCdgXSs0pGocFlNWAjh7dQpMzmW5zIV//4rywlcqkHzBjFq5ajz21flv4qEPgmUKVDGvqAcZMQIGDrUWrZ4MVx3nT3xiMxbvGMxN39+s9e8DB+1+4h76t2TLb8zaBNDVzfR8cB/WuuhbuVvAoe01q8ppZ4A4rTWj13ouSQxtF+9embmyDRSe5pzaa1Zu38tczbNYe7muSzbtSxTj1MoGpZsSHyleDpU7kDVIlUv2uU0JQVKlYI9bsMYJ00yazpl5HjScSavm8zolaNZuWdlxgcCRfMUpV+tfvSv05/yceUz9XcIIULTvn1mAfvlHp0OpCL08nz393e0mdTGUibJYbrkZLO+77p16WU1a5p7rvBw++ISF/b7v7/TamIrjp89bikf0XoEDzTMvoWZgzkxvB5YBKwF0qaUeApYCkwDSgPbgW5a6/8u9FySGNpr61Yo5zZviVKwaxcUL25fTCJw9p7Yy9ebv2bu5rnM/2d+pmcsLVOgzPkkselVTTNspXv0UXjrLbfHlYFp06B+/fQyrTUr96xk9MrRfLH2C06eu/BaWK3Kt2JgnYHEV46X1kEhxEVt3Aht25rrnbsSJWDhQtPdT1warTW9v+rNxDXWqaclOUz3yy/QrJm17P334b777IlHXNiK3StoOaGl14R2b970Jo9c+0i2/u6gTQz9SRJDe739Njzi9j6//npYtMi+eIR9Tp87zYKtC853Od19fHemHpcvVz5uLn8z8ZXiaVuxLYVyFzq/b80aUzvqLiLCrPM08P5jTPnzC0avHM2qvasu+DuKxRY73zpYtmDZLP9tQojQ9PPP0KkTHPFY0rRGDfj6a7O8jrg8yanJ9P6qN1+s/cJSLslhuh494Au3l6dAATO/g8zl4Cyr967mhvE3cPjMYUv5yze8zFNNnsrgUf4jiSGSGNqtcWP4/ff07XffhSFD7ItHOIPWmsQ9ieeTxMQ9iRd/EGb65utKXWdmOa0cT+VClbn9dsW0aeefGa5cBnVHE1ZzCqnhGbdQKhStK7RmYN2BtKvYjsjwyMv/w4QQIeOLL6BvXzh71lreqhVMn25miRT+kZyaTK9ZvZi8brKlXJJDY/duM8nfCbfh8nfdBWPH2heTsFq3fx0txrfg4KmDlvJhzYbxXPPnAhKDJIZIYminf/81Y8Dc7djhXSbErmO7mLd5HnM2z+Gnf36yTNt8IRXiKtCmXDzb57djzm8boe5oKLbmgo8pkbcEd9W+i7tq38VVBa7yR/hCiBCiNbzyCjz9tPe+u+6Cjz6CSKln8jtJDi/srbfM8Ap3v/8ODRvaE49It/HgRpqNa8b+k/st5U9c9wSv3PiKX5bxygxJDJHE0E7vvWdtHWzY0Np6KIQvJ8+e5Md/fmTu5rnM2zyPfSf3XfZzKh1G6wptuKf+QNpWbEtEWIQfIhVChJpz52DQIPjkE+99L79s1i8M0D1eSMooOSxToAwLey8M6eTw3DkztGLDhvSyunVh6VKZiMZOfx36i2bjmrHnxB5L+UONHuKtVm8FLCkE/yaGYf54EhFaZs60bnfpYk8cIrjkicpDxyodGdthLLsf3s3vd/3O/5r8jxpX1Mj6kx0tCQnD0O9uZfdb86iY2kGSQiHEJTl2DNq1804Ko6LMjMhPPSVJYXaLCItgwi0TuL3a7ZbybUe20WJ8C7Yd2WZPYA4QGQkjR1rLVq70XYkhAmPr4a3cMOEGr6RwcP3BAU8K/U1aDEWW7N1rZmRzf9ts2WKdoVSIrNp+ZPv5cYkLty7kXOo5r2PCVBiVaM/myQNI3dwaUtMTwZgYs+5T//5yAyeEyLydO01SuHattbxgQbNuYdOm9sQVqpJTk7lz1p1MWTfFUl6mQBkSeieE9DCBbt3MGNc0cXFmIppChTJ+jPC/HUd30PSzpmw/ut1SPrDOQEa1H2VLUihdSZHE0C6jRpnuNmlq14bEzM0vIkSmHE86zg9bfmDO5jn8tvM38kTmocvVXehbuy8l85VkyRKzpuG2bd6P7doVRo82N3VCCHEhq1ebpHC3x0TKZcvCN99AlSr2xBXqJDn0bedO85485Tb32j33mLGvIjB2HdtFs3HN2HJ4i6W8T60+fNLhE8KUPR0xJTFEEkO7tGxpXdT35ZdNNxshAunoUXNBnDLFe1+pUmZWweuvD3xcQojg8O23pgXGfbZHgAYNYO5cKFrUnriEIcmhb6+9Zsa7plEKli83Yw5F9tp7Yi/NxjVj86HNlvIe1XswvtN4wsPsG/ApYwyFLQ4ehIQEa5mMLxR2yJ/fJH+ffQZ58lj37dxpFgV+/nlITrYnPiGEc40eDfHx3klhp05m4XpJCu0XERbBxFsmclvV2yzlaWMOtx/ZnsEjc7YHH4SKFdO3tTYL3qem2hdTKDhw8gA3TrjRKym89ZpbGddpnK1Job9JYigybfZsSElJ365WzayvI4QdlII+fUxX5jp1rPtSU+G556BFC7OUihBCpKbCE0/A3Xdbr2UAQ4fCjBmQO7c9sQlvEWERfN75c6/kcOuRrSGbHObK5T0RzdKlMH68PfGEgkOnDtFyYkvWH1hvKe9UpROTOk/KcRPfSWIoMk1mIxVOVKkS/PYbPPyw977Fi8003zNmBD4uIYRznDljxia//rq1XCkzcdU778jU/06Ulhx2q9rNUp6WHO44Gno1fzffDLfcYi17/HE4fNieeHKyI2eO0OrzVqzZZ11HuV3FdkztOpXI8Jy3sKkkhiJTjhyBH3+0lnXtak8sQnjKlcssAvzdd97dwI4cgVtvhYED4eRJe+ITQtjn0CEzPn7qVGt5TAzMmgUPPGBPXCJzIsIimNR5ks/ksPm45iGZHA4fDtHR6dsHDsCwYfbFkxMdSzrGzZ/fTOIe6wyLrcq3Yka3GUSFR9kUWfaSxFBkyty5ZpHVNJUrQ9Wq9sUjhC833wxr1kDr1t77xoyBevXgjz8CH5cQwh5btkDjxvDrr9byokXh55+hY0d74hJZI8mhVZky3hP/ffCBXN/8ISk5icQ9ibSZ1IZlu5ZZ9rUo04KvbvuK6IjoDB4d/CQxFJni2RWvSxdZL0440xVXwNdfmxrVSI9eHhs3mlkH33vPuhanECLnWbIEGjWCv/6yll99Nfz+O9Svb09c4tKkJYe3XnOrpTxUk8NHH7WuIZ2aCoMHy7UtK06cPcGvO35l5NKR9Jvdj9of1ybvq3mpO7ouv+38zXJsk9JNmHvHXGIiY2yKNjBkuQpxUcePQ5EikJSUXpaYaNYwFMLJEhPhjjvMIsCe2rUzs5oWKRL4uIQQ2WvmTOjZ04wtdNe8OXz5pax1GsySU5PpPrM709dPt5SXK1iOhb0XUjp/aZsiC7x588wMu+4mTjTvfWF16NQhVu1dxao9q0jcm8iqPavYfGgzmovnQY1LNub7nt+TN1feAESadbKOIZIYBtKUKebmOk3ZsqZ7jrQYimBw4oQZQ/TZZ977ihUzF9GWLQMflxDC/7Q2vQUefdS75aRnTxg71oxJFsFNksN08fEmQUwTFweTJ0OrVvbFZCetNbuP7yZxTyKr9q46//NSW5TrlajHj3f+SP7o/H6O1H8kMUQSw0Dq2tU6I+mjj8Ibb9gXjxCXYupUMwHNsWPWcqXMe/rFFyEqZ44lFyIkJCebZSc++MB73zPPmLVNpUIz5ziXco4eX/bwmRwm9E6gVP5SNkUWWFu2mDkf3Ht1gVma5YUXvIdU5CSpOpV/Dv9jkj+3lsADpw5c1vOWzl+a2sVqc2PZGxlQd4DjxxRKYogkhoFy8qQZpH/qVHrZ779Dw4b2xSTEpdq6FXr0MGOPPNWvb2pZy5cPfFxCiMtz4oTp2eLecgIQEWEWtO/b1564RPY6l3KO7l92Z8Z660QIoZYcvvSSqfzw1KiRua6VKRPwkPwuOTWZDQc2WFoBV+1ZxfGzxy/5ORWKSoUqUbt4bWoXq02d4nWoVawWhXMX9mPk2U8SQyQxDJSZM63LUpQqBdu3S62rCF7Jyabl4OWXvbuaxcbChx/CnXfaE5sQIuv27IH27c2YYnf58plrmHQVz9kkOTTXshdfNNe21FTrvgIF4JNPoHNne2K7FKfPnWbt/rWmFdCVBK7Zt4aklKSLPzgDEWERVC1SlTrF65xPAmsWq0lsVKwfI7eHJIZIYhgo3bub2qY0Q4bAu+/aF48Q/pKQYMYc7drlva9HD5Mg5ssX8LCEEFnw55/Qti3s8Bg+VKqUmZ24enV74hKBlVFyWL5geRb2XhgSySGYJVh69PB9Xbv3Xnj7bev6h05w9MxRVu9dbWkJ3HBgAyk65ZKfMyYihprFalKnWB1qFzdJYNUiVckVkTMHGEtiiCSGgXDmjJmx8cSJ9LJFi+D66+2LSQh/OnQI+veHr77y3leunKkUadAg8HEJIS5uwQLTCnL0qLW8dm3TpbRECXviEvY4l3KOO2bewcwNMy3loZYcHjxouk57dqsGqFHDjLevUiXwcaVZuXslP2z54XwiuOXwlst6vgLRBc63AKb9rFSoEuFh4X6K2PkkMUQSw0CYOxc6dEjfLlbM1EKFyeqXIgfRGj7+GB580Htq+4gI0z3nscfkfS+Ek4wfbyp1kpOt5W3bmhvf2ODvHSYuwYWSw4Q+CZTMV9KmyAJLaxgxwly7zp2z7sud20zQ1Lt3YIcFnU05y+BvBjMmccwlP0fx2OKmBdDVEli7WG3KFCiDCvHxTZIYIolhIPTuDRMmpG/fe6/v2d6EyAnWrTOTV6xb573vxhvNZ0FaIISwl9ZmpsXnnvPed889MHKkqdARoUuSw3QrVsDtt5uZSz316AEffQR5A7A033+n/6PrtK4s3LYw048pV7ActYulTwpTu3htisUWy8Yog5ckhkhimN3OnoUrroAjR9LLfvoJbrjBvpiEyG6nT5ulK3xVgBQubNZCbN8+8HEJIcx1aeBA01ro6Y034JFHZGI0YZxLOcftM2/nyw1fWspDMTk8dsxUmrjPF5GmQgXTwl6nTvb9/r8O/UX7ye3ZfGizz/1hKowqhatYuoLWKlaLAtEFsi+oHEYSQyQxzG7ffQdt2qRvFy5sZn6TmlgRCmbPhn794L//vPfdf7+5CXXaAH4hcrIjR6BLFzOu0F2uXKY1v1s3e+ISziXJYTqtTcXm4MGmAtRdZCS8+SY88ID/K1YStiXQeWpnDp85bCkvV7AcjzR+hDrF61D9iurkjszt318cYvyZGMqoGeHTTGsPDG65RZJCETo6doQ1a6BFC+99I0eadTzXrw98XEKEou3b4brrvJPCQoVMTxZJCoUvkeGRTOkyhc5XW9dp2HJ4Cy3Gt+DfY//aFFngKWUqO1euhGrVrPvOnYOhQ81179Ah//3OTxI/4aaJN3klhU1KN2Fp/6UMqj+IhiUbSlLoMJIYCi/JyTBrlrWsSxd7YhHCLldeCfPnm/UOwz0mN1uzBurVMwtnB2mnCyGCwsqVZpFuz4qYChVgyRKTMAqRkbTk8JYqt1jK//7v75BLDgGuvhqWLTNdSz3NnQu1apnZ5y9HSmoKj81/jP5z+5Ocap0dqnfN3sy/c37QLSAfSiQxFF5++cVaa1SwoIwtFKEpPByeegoWL4ayZa37Tp+Gu++Grl19dzkVQlyeefOgaVPYu9da3rixSQorVrQnLhFcIsMjmdp1aobJ4a5jPhb9y8FiYsykM9OmQf781n3//gvNm5vZuFMuYRnBE2dP0GVaF9787U2vfa/e+Cqfdfwsx64lmFNIYii8zLCuD0uHDqYPuhChqlEjWLXKzFrq6csv/VPLKoRI9+GHpmvbqVPW8ltvNd1HC0uDg8iCCyWHzcc3D7nkEMxnadUqMzTCXWoqPPss3HQT7N6d+ef799i/NPmsCbM3zbaUx0TEMOPWGTxx/RMhv6xEMJDEUFikpHh3I+3a1Z5YhHCS/Plh0iQYNw7y5LHu27kTmjWDAQNg3z5bwhMiR0hNNbOL3nef+b+7Rx+FKVNMi4cQWRUZHsmUrr67lYZqcli2rKnUfPxx730LF0LNmvDttxd/nhW7V9BgTANW711tKS8eW5xf+v5Cl2tkPFKwkMRQWPz2m7XbTt68ptZICGEG8PfuDYmJULeudZ/WMHas6d722mtw5ow9MQoRrE6fNhPJvP22tTwszLQgvvGG+b8QlyoqPIopXafQqUonS3modisF0yPstdfMbPRFilj3HTwIbduaypqzZ30/fub6mTT9rCl7TuyxlNcqVotlA5ZRr4RfJssUASJfscLCsxtpfLyZDlwIka5SJVOJ8sgj3vuOH4cnnzSD/KdNk8lphMiMAwfMWHbPGbHz5IE5c2DQIHviEjlPVHgUU7tO9UoO//rvr5BNDgFuvhn++MP3nBJvvw3XXw///JNeprXm1UWv0nV6V04nW9fA6FC5A4v6LgqpJUFyCkkMxXmpqWa8lDuZjVQI36KizNpP8+ebRNHTtm1w223QpAksXx7w8IQIGsuWmQllfv/dWl68uJkMrV07e+ISOZckh74VLw4//AAvveQ9G/fy5VC7tqnwTEpOou/svjy14Cmv53j02kf5stuXxEbFBihq4U+SGIrzli0zM1KlyZ0bWre2Lx4hgkHLlrBuHbz7rpnB19Ovv0KDBtCrl/XzJUSoW7PGTDDTsCFs2WLdV7WqSRTr1LEnNpHzpSWHHSt3tJSnJYe7j2dh5pUcJDwc/vc/SEiAUqWs+44dg9v6HqTMszcx/o/xln0RYRGMjR/LGze9QXiYR1YpgoYkhuI8zy48bdua5FAIcWGRkTBkCPz9NzzwAEREeB8zcaJpWXzuOTh5MuAhCuEYmzaZGX5r1TLdRD3deKOpUCldOvCxidASFR7FtFun+UwOm49rHrLJIZiuo6tXQyf3RtXCG6B/Q/bmsk7DXTC6ID/0/IG76twV2CCF30liKAAzDspzfKHMRipE1sTFwYgRpgWxfXvv/adPw/PPQ+XKJlH0nHVRiJxs+3bo1w+uucbMLupr/G2/fvDNN97rqwmRXSQ5zFhcnBliNHIkRFSaD/0bQ9w/lmOKhlfk97uW0qJsC5uiFP4kiaEAzFo227alb+fKZVoMhRBZV7kyzJ1rxmpUq+a9f9cu07W0YUNYvDjw8QkRSHv2wODBZsbezz7zXSHSsCH8+CN88okZvytEIKUlhx0qd7CUh3q3UjCzcUc0GoXu0Qaij1p3bm3B/ld+59nBFTl61PfjRXCRxFAA3q2FrVubpSqEEJfupptMpcuoUd7TgAOsWGEmp+nWDbZuDXx8QmSngwfN2oPlysEHH8C5c97H1KxpKlGWLDFdSIWwS1R4FNNvne6VHG4+tDlkk8OU1BQe/O5BBn09iBSdYt2ZeBd8/h2cjmPqVDMeWCZaC36SGAqf3UhlNlIh/CMiAu6+G/76Cx57zHdryPTpZnmLJ54wg/uFCGZHj8KwYSYhfOst32t6Vq4MU6eaNUHbtzetEkLY7ULJYd3RdXl10ascOnXIpugC63jScTpO6ci7S9+1lCsUt8e9Re6fxkBK+gXtn3/g2mvN0hYyTCJ4KR2ki2zVq1dPr1ixwu4wcoS1a6FGjfTtyEjYvx8KFLAvJiFyqn/+gccf966MSVO0qJkqvF8/7+nChXCykyfh/ffNQvT//ef7mDJlTNLYs6fvSZqEcIKzKWfpOq0rczfP9doXHRFNz+o9GdJoCNWK+hgrkANsP7Kd+MnxrN2/1lKeOzI3X3T+go5VOrJpk1mS6Y8/vB/fti2MG+e7p4zwP6XUSq11PX88l7QYCq/ZSG+6SZJCIbJLuXKmhfDnn31Pxb9/PwwcaPb99FPg4xMiq5KSzOQU5cubVm9fSWHx4vDhh2ZG0j59JCkUzhYVHsWMbjOIrxTvte9M8hnGrhpL9Y+q03JCS+ZumkuqzjlNZEv/XUrDsQ29ksIr817J4r6L6VjFTNJTubJZUmbwYO/n+OYb00184cJARCz8SRJDId1IhbBB06ZmPMa4cVCihPf+NWvMGokdOsDmzQEPT4iLOncOxo41k8o88ADs2+d9TOHCpjvpli0waJBMLCOCR1py+EjjR8gd6Xvtrp+2/kSHKR2oNLISI34fwbGk4B4LMHXdVJqNa8a+k9YPc70S9Vg2YBm1i9e2lEdHm0qhL7/0blDYs8eMGx42DJKTszty4S8B7UqqlPoUaA/s11pXc5XFAVOBMsA2oJt0kEwvAAAgAElEQVTW+vDFnku6kvrHxo1mbFOa8HBzcS9UyL6YhAg1J0+a7ndvvmmWtPAUEWFqZZ99FgoWDHx8QrhLTTXLTQwbZtbu9CVfPnjkERg6VCYyE8Hv8OnDjE0cy/vL32fH0R0ZHpc3Ki/9avfj/gb3Uz6ufAAjvDxaa1785UWGJQzz2tfl6i5MuGVChslxmu3boXt3+O03731NmsAXX0DJkv6KWLjzZ1fSQCeGTYETwAS3xPAN4D+t9WtKqSeAglrrxy/2XJIY+sfLL8PTT6dvt2wJ8+fbF48QoWznTnjySZg0yff+uDh47jm45x4zFliIQNIaZs+GZ54xa3X6kjs3DBliksK4uMDGJ0R2S05N5quNXzFi6QgW78h4rSGFon2l9gxtNJQWZVqgHDy70pnkM9w15y6+WPuF176nrn+KF294kTCVuQ6GycmmwujVV73XKY2LMz1k4r1752Y7rU2l64kTcPy4+ZmZ/8fGmiWnatY0P/PkCXzsmRG0iSGAUqoMMM8tMdwENNda71FKFQcStNaVL/Y8khj6R506Zjr9NKNGmRkUhRD2WbbMtLQsWeJ7f5Uqpnte27Yym6PIflqbNTmfftosseJLVJTpKvrkk3DFFYGNTwg7JO5JZMTSEUxZN4WzKWczPK5a0WoMaTiEHtV7EBMZE8AIL27/yf10mtKJJf9aLzaRYZGM7TCWXjV7XdLz/vijmWDKV/fyoUPhtdfMetkZSUrKfPKW2f9f7kypSkGFCmayxho1TLJYo4aZUMvu63BOSwyPaK0LuP6vgMNp2xciieHlOXkSPv3UjAtJo5TpEy4XdSHspzVMm2ZmMN2+3fcxrVqZqcGr5cyJ8YQDLFoE//uf+elLeLiZQfeZZ6BUqcDGJoQT7D2xl1ErRvHRio/Yf3J/hscViinEwLoDubf+vZTMZ3+fynX71xE/OZ5tR7ZZygvFFGLWbbNoclWTy3r+ffugVy9TqeSpalWTZLknb+5JnK81T50qb970ZDEtYaxWLbBd6HNsYujaPqy19jmKRik1EBgIULp06brbM7pbEhnas8dMJz5qlPfMcc2aQUKCLWEJITJw+jS8+y688oq5YHoKCzOzmL7wgkwNLvxn+XKT7H3/ve/9SkGPHqbbWIUKgY1NCCdKSk5i6p9TGbF0BIl7EjM8LiIsgq7XdGVIwyE0KtkogBGm+/avb7ltxm0cP3vcUl6lcBXm3THPb+MjU1PN2Pn//Q9SUvzylEGjXLn0VsW0hLFsWXPN9reclhhKV9IA+OMPeOcdM/g3o5qY0aNhwIDAxiWEyJy9e01Xvk8/9R67AWayj6efNr0ALtRFR4gLWbfOJIRffZXxMZ07m4qIqlUDF5cQwUJrza87f+Xd399l1sZZF1zKosGVDRjScAhdr+lKVHhgpuwduXQkQ78f6hVXy3ItmX7rdApE+3+9siVL4I47Mu79EgjR0WbMYGysac3z/L9nWZ48pjFlzRpzD/33376vvVmRJw9Ur25NGGvUMNfvy5HTEsM3gUNuk8/Eaa0fu9jzSGJ4campprZ3+HDT3zsjkZFmXOHw4TKhhRBOt3o1PPRQxutDlStnZjjt3Nn+cQ8Xk5RkEt69e80FOO3fsWOmFap+fXMBjY62O9Kc76+/zMRGkydnfPPTpg28+CLUrRvQ0IQIWtuPbOeD5R8wJnEMR84cyfC44rHFua/+fQysO5AiebKn60dyajJDvxvKB8s/8Np3T917eK/Ne0SGZ99N4JEj0L+/99rZvoSHm+TMVwKX2cTOM8m73PvbkydNxdmaNenJ4po1cPTo5T0vmHGK7uMWa9Qw68KGh2fu8UGbGCqlJgPNgcLAPmAY8BUwDSgNbMcsV+FjeVwrSQwzdvo0fP65aSHcsCHj4woWNLMbDh7sex01IYQzaQ1z5piZHzNaLqBpU/MdUKdO4GM7dsw72fO17WshdE8REaaGtV49kyjWq2fGb0glln/s2GFa/8aNy7irV7Nm8NJLcP31AQ1NiBzj5NmTTFwzkRFLR7Dx4MYMj8sVnose1XswpNEQalxRw2+//+iZo3Sb0Y0ftlgH/IWpMN65+R3ub3B/QGZO1drcl65caZK1jBK7XLmcX7EJ5u/ZuTM9SUxLGP/66/Inu8md21zrPBNGz/UiIYgTQ3+SxNDb/v3w4Yfm34EDGR9XoQI8+CD07u3cqXeFEBd39qwZM/zCC75rLZUyn/OXX778yp+UFPO94p7gZZT8+VqL0Z9y5YJatdITxfr1oXLlzNeuCnOuXnkFPv7YvI98adDAJIQtWwbHTZoQTpeqU5m/ZT4jlo7g27+/veCxLcq0YEjDIbSv1J7wsEv/cvvn8D/ET45n/YH1lvLYqFimdJlCu0rtLvm5hW+nTsGff3q3Lh6+6CrtF1e6tPfMqFdfLYmhJIZu1q833UA//9x0zcpI06amC1r79nIDJUROcvCg6QY4apTvVp88eeCJJ+DhhyHGY7b0M2cu3LqX9v/9+509eUBsrGkddU8Wy5WThMbTf/+ZrsYjR5qbF1+qVzcJYXy8vH5CZJdNBzcxctlIxq0ex8lzJzM8rlzBcgyuP5h+tfuRPzp/ln7Hrzt+pdPUThw8ddBSXjp/aebdMY/qV1S/pNhF1mkNu3Z5ty5u2nT5rYsgiWHIJ4Zam3GDw4fDd99lfFx4OHTrZhLCen55ywghnGr9etO99NsMKqJLlYImTayJ35GMh71ku7AwKFoUiheHYsXMz+LFzZjCNWvMzJjbtl368xcsaL733LuhliwZmsnOsWOma/Hw4eb/vlSqBM8/b64Z2TFznhDC25EzR/gk8RPeX/6+19IR7mKjYulbqy/3N7ifioUqXvR5P1/zOXfNuctrjcWGVzZk9u2zuSJW1iZzgtOnTfdaz4Tx0KGsPIskhiGbGCYlmckBhg+HtWszPi5/fjOF/f33y9pSQoSa774zrYPr11/82OwQHe2d7HluFytmksKL9V44eNAsqr5ihUkUV6yA3bsvPbYrrrAmivXrmzhyqlOn4IMP4PXXM77RKF3aLDvRq5cZ0ymECLyU1BTmbJrDiKUj+Hn7zxkep1C0rdiWIQ2H0LJcS6+xgak6lWELh/HSope8Hnt7tdv5tMOnxETGeO0TzqG1dUbUtIRxw4aMeu5IYhhyieHBg6ab2Pvvm0VDM1KmDAwdahYcDuTimkIIZ0lONkvQPPtsVmseM1awoO8EzzP5y58/e1vldu+2JorLl1/e31iqlDVRrFvX/K1OorVZx/K//8zfmtmfhw9n3AW4WDGzxEn//rLEiRBOsnrvakYsHcEXa7/wavFzV7VIVR5o+AA9a/Qkd2RuTp87TZ/ZfZj25zSvY4c1G8awZsMCMsmMyB5JSb5bFw8ckMQwZBLDTZvM4tbjx194QofGjU130U6dpMZXCJHuyBEzXuy993yvYRoeblrRLta6V6yYc5eN0Nqsj+WeKK5cmXGXycxIWy4jLVmsXduMY/SH06ezltyl/cxoDdqsioszY07vu8/MfCeEcKb9J/fz8YqP+XDFh+w9sTfD4+Ji4uhfuz8J2xNYtmuZZV+u8Fx82vFTulfvnt3hChtoDWFhkhjm6MRQa/j5Z3j7bZg3L+PjwsKgSxczw2jjxoGLTwgRfHbsgAULzPeLe8JXuHDOnIwqNdVMGe7espiYeOkzpoaFwdVXW7uhXnONWdsqK8ndoUNmwh875M1ruhg/+ODlL6gshAicsylnmf7ndN5d+i4rdmf+3rdI7iJ8dftXXFvq2myMTthNlqsgZyaGZ8/CtGlm/OCqVRkfFxtruv488ACULRu4+IQQIpglJ5txl+7J4h9/+K8lzqmKFTPjBx97DAoVsjsaIcSl0lqz5N8ljFg6gpnrZ5KiM54qumqRqszrPo8yBcoELkBhC0kMyVmJ4eHDZizQyJFmKtuMlCplksEBA8wYHiGEEJcnKclM5OXeDfXPP/0xfbj/xcSYxC4uLnM/CxUyYyWjouyOXAjhbzuP7uTD5R8yOnE0/53+z7KvdYXWTO06lXy5pGtAKJDEkJyRGG7ZYsYPfvppxutJgemy9PDDpttoZGTg4hNCiFB06pTpteHesrhpk/+ePzIyPXHLbJIXF+e9BqUQQpw6d4pJayYxJnEMO4/tpH/t/gxrPoyIMJlwIlRIYkjwJoZaw6+/mu6iX31ltn1RCjp2NBPKXH99aK67JYQQTnH0qBmj6N6yuGuX6b3h2Up3sSQvTx75ThdCCOEf/kwMpTohQJKTYeZMM6HM8uUZH5c7N/Tta5acqFAhcPEJIYTIWP780KKF+SeEEELkRJIYZrOjR2HsWDNV/I4dGR9XooRZjH7gQFOrLIQQQgghhBCBIolhNkhONuNTJk82SeHx4xkfW6uW6S56220yQYAQQgghhBDCHpIY+kFKipnyfOFC82/RoosvrNyunZlQpnlzGWsihBBCCCGEsJckhpcgNdVMb56QYBLBn3+GI0cu/rjoaOjd24wfrFIl28MUQgghhBBCiEyRxDATtDaLIqe1CP78Mxw6lPnHFy0KgwfDPfdAkSLZF6cQQgghhBBCXApJDH3QGjZvTk8EExJg//6sPUfhwqabaPv2ZvxgdHR2RCqEEEIIIYQQl08SQ0wiuGWLNRHcsydrz1GwIDRrlj6dedWqEBaWLeEKIYQQQgghhF+FbGK4dWt6ErhwIfz7b9Yenz8/NG2angjWqCGJoBBCCCGEECI4hUxiuHNneovgwoWwfXvWHh8baxLB5s1NIli7NoSHZ0uoQgghhBBCCBFQOTYx3L07vTVw4ULTVTQrcueG669PbxGsWxcicuyrJYQQQgghhAhlOSbV2bfPmghu3py1x0dHw3XXmSSweXOoX18WnBdCCCGEEEKEhqBNDJOTYebM9ERw/fqsPT4qCho3Tm8RbNgQcuXKnliFEEIIIYQQwsmU1truGC6JUvU0rMj08ZGRJvlLSwQbNYKYmGwMUAghhBBCCCGykVJqpda6nj+eK2hbDC8mPNx0B01LBK+9FvLksTsqIYQQQgghhHCeHJMYhoWZCWLSEsHrroO8ee2OSgghhBBCCCGcL6gTw9q10xPBJk3M2oJCCCGEEEIIIbImaBPDWrUgMdHuKIQQQgghhBAi+IXZHcClksXlhRBCCCGEEMI/gjYxFEIIIYQQQgjhH5IYCiGEEEIIIUSIk8RQCCGEEEIIIUKcJIZCCCGEEEIIEeIkMRRCCCGEEEKIECeJoRBCCCGEEEKEOEkMhRBCCCGEECLESWIohBBCCCGEECFOEkMhhBBCCCGECHGSGAohhBBCCCFEiJPEUAghhBBCCCFCnCSGQgghhBBCCBHiJDEUQgghhBBCiBAniaEQQgghhBBChDhJDIUQQgghhBAixCmttd0xXBKl1HFgk91xZEJh4KDdQWRCMMQZDDGCxOlvEqd/BUOcwRAjSJz+JnH6l8TpP8EQI0ic/hYscVbWWuf1xxNF+ONJbLJJa13P7iAuRim1QuL0j2CIESROf5M4/SsY4gyGGEHi9DeJ078kTv8JhhhB4vS3YIrTX88lXUmFEEIIIYQQIsRJYiiEEEIIIYQQIS6YE8PRdgeQSRKn/wRDjCBx+pvE6V/BEGcwxAgSp79JnP4lcfpPMMQIEqe/hVycQTv5jBBCCCGEEEII/wjmFkMhhBBCCCGEEH4giaEQQmQTpZSyOwYhhBBCiMyQxDBA5AZRKKXk83aZlFKxwfBZUkqVUkpFa+mrH7KC4X0q/CsYzrlSKtzuGETgBcN7E4InzmBxKa9n0N+oKqWqKKWaKKVyKaUiXGVOfGPlAcfGdp5SqqJSqqFSKo/dsVyIUqq6UupGpVRxJ7+mrvdmPwCtdaoTk0OlVLxS6jG747gYpVRH4C3gCrtjuRCl1M3ATKC0a9tx5xxAKdVYKdVPKXWdUira7ngyopSqrJRqpJSKcPJ3vFKqjlKqo1LqKqVUbq21dtq5d+LrFsyUUvWVUrcqpWo7uSJIKdVCKfU0gNY6xWnvS3fB8h5VShVWSkXaHcfFKKUqKaXyOfi92Uwp9YhS6jalVH6nxunJqe9Tf1yHHPvlkBlKqc7AHOBp4DPgAaVUnOuFcMxJU0rFA0uUUk2cFps7pVR74EvgZWC8Uqqmq9xR8Sql2gBfAPcC44GS9kbkTRm5gfeBx5RSD8D55DDC3ujSKaVaAS8Aq+yO5UKUUk2B14CZWuu9Hvsc8/50vZ6vAQWBh8Ccc1uD8kEp1QH4GLgeeAQo47bPSa9nR2AG8DDwDnBv2k2Ow+LsAEwBegDPA68rpYo7sDIoHzi3siKNUqqGUqqNUqqcUiqX3fH44roOfQq0xpzzOvZG5M11HcqF+Yw/qZR6Cc5fhxyX1LjulV500mfbF6VUJ+A9XJV/TuW6Hn0FNHFtO6q12HW+R2Aqe+OB+m77HPUeUErVcn0nlXRwxZ9frkOO+qOywnVz3QW4S2t9MzANKIq5CY9zSq2DUqoq8AbwGzBCKdXUaTc1AEqpRsCbQG+tdUtgF/AYgFNeSzC1S5gv5P5a6y7AUaCqa59j3s/aOAVMwEwjXCutVU5rnWxrcC6ucz4JuEdrPV8pVUApVVYplddJyatLTeAzV5wlXF/Q17pVBNl+7pVSNwIfAXdqrSsCZZRSN9gclhelVBwwCOipte4HHADqKKWKKaXyOOX7yRXnAOB2rfWtwHKgF/CwUqqgk76XgDbAI1rrbpjvp8PAu0qpYk6pGFBK3QL8q5Rq48CE9TxXBeUk4G7gJUzi5agbRbfrZX+t9V2Y62V5pVSMcrW+OyFe13UoCVOB+gRQTSk1wrXvnK3BeVCmp8ULQILnZ9sJr2Ua17l/HRittd7isc8xnylXUvg6sA/oCqa12Nag3LgqznsBA7TWjwLbgarK9AJ0zHUdzidcE4HOwFDgZaVUYQd+j/rlOuSkPyirFJAfqA6gtf4KmOva191BJ2sf8LLW+m5gJPC+UqqZU26+3KQCr2utE13bzwKxSqkYG2PyZRcwUGu9VClVHFMTdo9S6hOgn3JIlzi3c5sElMdcmGsopUYqpd521eTanXztA04B5ZRShYHZmBbO8UAfJ9TUu72OGkir4Z4O9MTcOH6olCrqkJtvjUm21iml8gMbgRrgrBsb4BwQg0kGCwI3AbdhWuSeUc7pznMOyIurNVNrPQH4B/O93x4cdSMWBlwN4PoOHYM5/4864TtUKVUeeBBTUfW5UqqtA29qUErVxVSk3qm17gQkYj7rjqqgBLZhKtSWKqWuwLwfb8e0fjjpM5QmCrgGc1NbUSk1XSk1WSkV5oSWQ2V6J30MPK+1/lEpVVCZ7rlXOamyyqU8MEdrnaDMWPI7lFKdL6VlJru4KiQ/BvporVtgKgR62hyWpxSgENDMdS93G9AcU4HxkVOu667v7+6YRpMBwDzgOuBtp8QI56+F4ZjP+WVdh2x/A2eVUipKmb785zAXkJuVUi1du3/DdIlrgs1/myvOGK31QWAqgNb6M2A41uSwgp034K44o7TWy4BZrrJIIBrTTSK/q6yYnYmM2+v5t9Z6oav4TmCk6wZiAXAz5ovGNm6vZ9pNwVxgn9b6Z0yLx11AXldNri0th64Yc2utt2Jes+eBdcDnWut2mPdBK0x3SNsopaJITwbnAz2UUjOBT7TWPTCVF4eAejaFCFjO+QKt9RKllNJaH8W8jk8qpeo54SbR7bvzOGas5r3A18A4rXVHTGvnFZgbH9t4xDkBuEMpdbdS6hUgGViDed86qZvuB5g4b3Vt/wt8i+nFkt+2qNIdBN7RWt8H9AemKKXaed7IOuDm+z9ghNZ6tWv7HSC/UupKG2PyorXeq7Ve7NqMB950fXdOwFRklLUrNndu53YWcERrvQ1T8dcWiNFapzqk5fAAsAUorJSqhbluPge8DfxPOWCMnNtn4ygmqQGYjElmWgOzlVKlHPKdtAe4Q2v9hyvuz4GK4IjPOACuluzHMAnhOGCq1voWzHk/DDSwLTirVMx1Ma0RKgFYDZzANErYnWtEKKVyud53o/DDdSioEkOlVBfM2LI5yvRN3oEZY9hNKXWT62Z7KiY5qOWAOGcrpdphar0B0FqPwySHbyil3nf935YaZVeck4G5Sqm2mFZYMB+EE8BhrfVepVR34EXAlgTW8/V0tXKgtX5Da/2y6/+TMK+jbTcQbnHOc8WZDzgCXKWUuhcYjBm/WUQpdb/NMX6llOqotd4I3AgM01qPAdBaT8RMlmTb2E2P17ID8Dfm9atBeo3YdkwNWTGb45xM+jk/38XRVRnwPtDGVTNv2/etx3dne0yi3QxIADYAaK1/AWKBcjaF6RnnzZjKlOmY8VtRWuvuWutPMcmCbQmXMhP33J62rbVeAwzDtLR3c12LfgcK4LqhsJOromKe6/+zMF24piil2ruSw9pKqVi7b75dlVUT4PxwkWjM9TO3q6y8sqlXiOc5T/s8a63Haq3fc/1/MaYyy7YJstzjdEv8I4ASSqn/YbprPohJwl6xK053WuvdQD/gVszEXeNdlVVp4/iusjE8wNJivRpzzzkTmKS1vltrPRBYhKvbs9201hu01r8rpcJccS8CeiulWtj5GffxvbkC05AzH9MbBFflRSRQ3I4YPbkS2Dcx3+1PKqXeAuIwlS2V7KwIcN23j8NcL290tRI+D/S9rOuQ1joo/gGVMDcwjYE7MAnhIMxNbV/gG2CI6/8bgGIOinMIUMHjuMmYWrKaDouzvNsxn2FaZVcA1R0WZ0WP47piuh0Vd1CcDwMVgCcxXY/iXcc2AUo6JMZHPD8rrtdylcM+Qw9gEsJbgL8wSeIAYKXnZ8sB7033z1AHYCkQbUeMF4jzQaCw6734GdDR9S8RKOuAOLtjujY/AJTwOK6X6zXNa1OcrYCTmElxBrqVx7rO91rMhGhDXX9PKZvibIwZn5m2Hebx8xZMS+IYTAVBEYfFGen6OQdTUdUNM7FCAZvP+QC38nCP4zq7PkOlbXotfcbp2tffdR3q5NouA1xlR5y+zrurrCSmO7572QzgJofFWQvYCUx0K3sVeNApcQLK4+f9mNbifDbF5/N707WvLiY5HIBpQbTtup7BaxkDNMW0YD/tVv61jd/vbUjvPTMQ2IvrPv1yr0N2j3HKioKYLnlLMDN8bgf6YMb1zAY2Y7pGnQK6a4+ZC22McxumJkwrpcZprY+5+n9XB27QWq91YJwTMR/gazEX5BZa678cGOdeTNey7pgkrJvWeo/D4jyOafX4QWu90nXsr9qeWqaMYuymlPoM89nphene0dVhn6G+rn3vYxLD2zC1in201n/bEuWF35vjtdZHtdZzXN06igNbHRZnd+AnzPtzKHAa83o6Kc6+QJgyY4hPAL2BxzGf9eM2xVkO0/K/GuiolBqotR6ttT6BqbndgunmXhBzc7Ez0AEqM/HELOBbpVRerfUYbVqPlOtnmNZ6lqvnzS2Ya9EBm+PM53od0+JM6+K4F9PN+Rqgr9b6SKDjxPuc43pNU1xd8yIw9yMPYb47d9gQY4ZxuvYtAtporTe4zv82m2L0+f4E0Fr/i+n2mHZcF0zX9o0Oi3O1Uuo2TE+RRzG971phvlMdEafWZlymdmUKwGLMZ70gcMyGMD3fmwPc3pvrMXNw3IfpqtvXrut6Bt9Jp4FfXP/SjrsTKIG5LgU6xlhMYvi01vp7V9mVmB5Va133HZd+HbIj072MDHkCptYwwrV9Hab/bBvXdjiu2kaHxXmtK85Wru0i2FSjmMk4017PHsA1Do7zJtd2K0yTvtPivA7Tkn2ja1vhqr1zUIye783rgcoOfC3T4mxrd2xZeT2d8u8Ccd7g2s6DTS1wWXk9MRfi8nbF54pBYWqQYzETjozCTERi+3l2i/Ee4CnMWLKPsbZypbUgNMCMy6/h0DgjXa91AqZ3jZ0tCL7O+d1u+8MwMydXtCvGC8TpqPdmJs572vuzL7AJqOqgOD1buspiWmKfwsZ7pYu8nmFu/38P+3qEXPS9iZkkKZddr+PFzrnbe7MzsMyu707X900NzPJDaT0sXgA+9Mfzp/2RjqSUaoC5OJzVWi9XZqHwmphs/let9TmlVG+gHdBD2zSIOotx3qlNn2WnxtmL9BnW0Da0bGXx9bzdjhgvIc7u2obJZoIhRonTtjj7YC5+PbXWZx0cp5O+O5O0GReTVp7PFVsz4HvMTc9xbWbJto2rFSsaU1naHjNBxiqt9cdux+THTEBiV8+AzMbZBPhPa/1ngGPLyjk/oc3YzYALtvcmZPq8VwTQ9vVWylScTnCxOJWZHC3g3/HB8hlyl8n3ZmHMd2dAe4O4Xs8ozOf4D1dZhNY62dUzqY7W+kml1B3ADq31r5fyexzblVSZSVtewfThLa2U2q+1fkgp9QTQCSiFWVdEA2cwE6YEQ5x23ShmNk4wSywobcOaN1l8PZNInzDHyXGecf10coxJdsR4CXHa8lrm0DhTXXHasrZVkH53llRKndZm+SG0GRrwNbAfM8aoMqbV3Y44PW/CTrvKv8F8TzZTZi3DWOCk1vpLTLctJ8dpy81iFs95FUzvkIALlvemK9ZLeX86PU7bEu2sxolZ6D6Q8eXU9+YprfVMG2J0fz1LuV7PgW6Vz0eBE64E8TnMNfTSZHeT56X8w8xA9i3pXfBKY6alf9e13RNzw5CAGWBZW+KUOCXO4IpR4pQ4gzTO/cCnHsc9CuzGpu5kmNr3PzA3DhOAjz3258NM1LYMcwNh12RiWYnzmB1xBtE5D4o4g+W8X0KcwfI5CnicOfi9acs5z8zriZlw5pwrzqsv6/fZdTIu8iLkAaYB1dzK3sQMQH7Rraw6UFTilDglzuCLUeKUOIM4zj+Bt93KHsJ047EjxqC4CQuiOB1/zoMszmA57xKn/2KU92aAX0/MOpULucykUGvtrHUMlVKVALTWJzF/8HdKqW5KqY8xg1bbAg9PV+kAAAX/SURBVMVV+jp2a7XW+yVOiVPiDJ4YJU6JMwfEGQ/kU0rFuY4brs0aUnZQmK5i+1yx7MBMS99QKfW223EpQHut9frAhwg4PM5gOefBEqcbR593NxLn5QYm703/Bpf51zMfZvmUrlrrDZf7ex2TGCqz6PJqpdRUAK3185iMuBJmkfAHtdb/YGb0tGWBW4lT4nRynMEQo8QpceagOIsCuWyMMyhuwoIhziA650ERJwTHeZc4/RqfvDf9G2NWXs+8WuszWutDfvnll9vk6I9/mGbS7zCLNI4DJmdwXE/MWiyFJU6JU+IMrhglTolT4vRbnO0x645OdSsbglnQ+HXSF4efDRS3I8ZgiTOIznlQxBks513ilPemE19LJ7yetpyYDP7AEpgZfwoDM4Av3PZFAK0xgyprSZwSp8QZnDFKnBKnxHnZ8QXFTViwxBkM5zyY4gyW8y5xynvTqa+l3a+nI9cxVEoVAkYDp7XWPZVS1YBywDJt45pLniRO/5I4/ScYYgSJ098kTv9yapxKqRKY2RujMQtFn9Vad3ftiwBaYhY8Hqi1Xi1xZp5Tz7knJ8cZLOdd4swe8t70r0C/no5MDOH8ApJvAtdixkI201rvtjcqbxKnf0mc/hMMMYLE6W8Sp385PU4n34S5C5Y4wfnnPE0wxBks513i9C95b/pXIF9Px0w+40lrfRBYA+QHOjvtDZVG4vQvidN/giFGkDj9TeL0L6fHqc2EA3cD55RSm4BZwAqn3dgES5zg/HOeJhjiDJbzLnH6l7w3/SuQr6djE0NlpitvC7TSWq+1O56MSJz+JXH6TzDECBKnv0mc/hUMcQbDTRgET5zBcM4heOIMlvMucfqPvDf9K5Cvp2O7kgIopaK11mfsjuNiJE7/kjj9JxhiBInT3yRO/3J6nK6bhmnAw1rrNXbHk5FgiROcf87TBEOcwXLeJU7/kvemfwXq9XR0YiiEEEKIiwuGmzAInjiFfwXLeZc4Q4+8llaSGAohhBBCCCFEiHPsGEMhhBBCCCGEEIEhiaEQQgghhBBChDhJDIUQQgghhBAixEliKIQQIuQopWYqpbYopaJ97PteKbVBKRVlR2xCCCGEHSQxFEIIEYqGAEWBJ90LlVJdgVbAIK31WTsCE0IIIewgs5IKIYQISUqph4GXgWpa67+VUnmAjcACrXXvbP7dMVrr09n5O4QQQoiskBZDIYQQoWoEsAkY6doeBuQGHkk7QClVSyn1nVLqhFLqqFJqslKqiNv+fEqpj5RSm5VSp5VS/yilRiilYt2OiVZKaaXUYKXU+0qpg8DywPyJQgghROZE2B2AEEIIYQetdbJSahCwWCn1DDAUuE9rfQBAKXU1sAj4FegO5MK0MM4Crnc9TV4gBdMl9eD/27t/0K2qOI7j70MOuuVYFLUEglMQVBC4FG21FCRKQzQ7tkhNbdLU0BBC0Bg0BNJQv8FFHISIcHByEcSGhiAkK07Dc6V6eApKn0Du6wWXA/d+Offc6fK5f86pnqzOLu2rW6c8Wx1Up/d2UQDwH/mUFIBVG2N8XL1dXapemMuNcYzxWXWsenrO+euy73j1XfXSnPNgR1+HqhPVV9Ujc85bywQ3t6vLc87n/49rAoB/y6ekAKzduaX9YP71aemL1ee1CXxL6LtW3ayeuVs0xnhrjPHtGOOn6pfq62pUT22d58Kexg8A90wwBGDt7my1jTEeqh6u3msT9v68PVo9vtSdrM5XF6vXqmerN5ZutpfCuLWf4QPAvfOPIQBsmXP+Nsb4sfqk+nRHyfdL+3p1cc555u6BMcbRv+v2vg4SAO4jwRAAdjuojs85r/xDzZHq5619p/Y3JADYD8EQAHZ7t7o8xviizZvDH6rHqperj+acl9pMMnNujPFO9U31Sn/MWAoADwzBEAB2mHNeHWM8V73f5j/Cw9WNNmHw+lL2YfVEm7UPD1dfVm+2WeYCAB4YlqsAAABYObOSAgAArJxgCAAAsHKCIQAAwMoJhgAAACsnGAIAAKycYAgAALBygiEAAMDKCYYAAAArJxgCAACs3O9oOkaVHRo44wAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -402,44 +410,13 @@ "Auto-assigning NUTS sampler...\n", "Initializing NUTS using adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", - "NUTS: [sigma, yto, xto, delta, gamma, beta, alpha]\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "51b6ca3e30814018b15692dfed658d5b", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, description='Sampling 2 chains', max=5000, style=ProgressStyle(description…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/osvaldo/anaconda3/lib/python3.7/site-packages/scipy/integrate/odepack.py:247: ODEintWarning: Repeated error test failures (internal error). Run with full_output = 1 to get quantitative information.\n", - " warnings.warn(warning_msg, ODEintWarning)\n", - "/home/osvaldo/anaconda3/lib/python3.7/site-packages/scipy/integrate/odepack.py:247: ODEintWarning: Excess work done on this call (perhaps wrong Dfun type). Run with full_output = 1 to get quantitative information.\n", - " warnings.warn(warning_msg, ODEintWarning)\n", - "/home/osvaldo/anaconda3/lib/python3.7/site-packages/scipy/integrate/odepack.py:247: ODEintWarning: Repeated error test failures (internal error). Run with full_output = 1 to get quantitative information.\n", + "NUTS: [sigma, yto, xto, delta, gamma, beta, alpha]\n", + "Sampling 2 chains, 0 divergences: 0%| | 0/5000 [00:00" ] @@ -518,6 +495,14 @@ "execution_count": 10, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/demetri/anaconda3/envs/gsoc/lib/python3.6/site-packages/pymc3/stats.py:991: FutureWarning: The join_axes-keyword is deprecated. Use .reindex or .reindex_like on the result to achieve the same functionality.\n", + " axis=1, join_axes=[dforg.index])\n" + ] + }, { "data": { "text/html": [ @@ -553,97 +538,97 @@ " \n", " \n", " alpha\n", - " 0.552456\n", - " 0.065637\n", - " 0.002289\n", - " 0.428681\n", - " 0.678782\n", - " 735.656650\n", - " 0.999878\n", + " 0.546238\n", + " 0.062607\n", + " 0.001882\n", + " 0.431009\n", + " 0.683215\n", + " 943.313994\n", + " 1.001490\n", " 0.549\n", " 0.065\n", " \n", " \n", " beta\n", - " 0.028047\n", - " 0.004369\n", - " 0.000153\n", - " 0.020097\n", - " 0.036484\n", - " 788.347157\n", - " 0.999785\n", + " 0.027682\n", + " 0.004183\n", + " 0.000121\n", + " 0.019921\n", + " 0.036197\n", + " 1038.814557\n", + " 1.000905\n", " 0.028\n", " 0.004\n", " \n", " \n", " gamma\n", - " 0.792733\n", - " 0.089938\n", - " 0.003068\n", - " 0.621923\n", - " 0.973234\n", - " 810.449110\n", - " 0.999962\n", + " 0.800985\n", + " 0.089085\n", + " 0.002686\n", + " 0.624201\n", + " 0.969263\n", + " 899.887191\n", + " 1.001295\n", " 0.797\n", " 0.091\n", " \n", " \n", " delta\n", - " 0.023821\n", - " 0.003547\n", - " 0.000112\n", - " 0.017602\n", - " 0.031104\n", - " 897.445670\n", - " 0.999911\n", + " 0.024174\n", + " 0.003591\n", + " 0.000106\n", + " 0.017432\n", + " 0.031091\n", + " 903.692124\n", + " 1.001325\n", " 0.024\n", " 0.004\n", " \n", " \n", " xto\n", - " 34.039379\n", - " 3.016263\n", - " 0.064226\n", - " 28.193732\n", - " 40.092932\n", - " 2089.061030\n", - " 0.999853\n", + " 33.958321\n", + " 2.995589\n", + " 0.065663\n", + " 28.476836\n", + " 40.251438\n", + " 2216.184676\n", + " 0.999667\n", " 33.960\n", " 2.909\n", " \n", " \n", " yto\n", - " 5.953507\n", - " 0.521353\n", - " 0.012523\n", - " 5.027723\n", - " 7.023803\n", - " 1696.227658\n", - " 1.000744\n", + " 5.954806\n", + " 0.528449\n", + " 0.011694\n", + " 4.940673\n", + " 6.990385\n", + " 1583.237072\n", + " 0.999951\n", " 5.949\n", " 0.533\n", " \n", " \n", " sigma__0\n", - " 0.249232\n", - " 0.044163\n", - " 0.000950\n", - " 0.177959\n", - " 0.340757\n", - " 2200.725278\n", - " 0.999702\n", + " 0.248752\n", + " 0.044778\n", + " 0.000940\n", + " 0.174250\n", + " 0.341214\n", + " 1984.170678\n", + " 0.999723\n", " 0.248\n", " 0.045\n", " \n", " \n", " sigma__1\n", - " 0.251609\n", - " 0.043279\n", - " 0.000791\n", - " 0.178921\n", - " 0.338763\n", - " 2199.754925\n", - " 1.000951\n", + " 0.252926\n", + " 0.044053\n", + " 0.000971\n", + " 0.175737\n", + " 0.337417\n", + " 2414.840347\n", + " 1.000093\n", " 0.252\n", " 0.044\n", " \n", @@ -653,24 +638,24 @@ ], "text/plain": [ " mean sd mc_error hpd_2.5 hpd_97.5 n_eff \\\n", - "alpha 0.552456 0.065637 0.002289 0.428681 0.678782 735.656650 \n", - "beta 0.028047 0.004369 0.000153 0.020097 0.036484 788.347157 \n", - "gamma 0.792733 0.089938 0.003068 0.621923 0.973234 810.449110 \n", - "delta 0.023821 0.003547 0.000112 0.017602 0.031104 897.445670 \n", - "xto 34.039379 3.016263 0.064226 28.193732 40.092932 2089.061030 \n", - "yto 5.953507 0.521353 0.012523 5.027723 7.023803 1696.227658 \n", - "sigma__0 0.249232 0.044163 0.000950 0.177959 0.340757 2200.725278 \n", - "sigma__1 0.251609 0.043279 0.000791 0.178921 0.338763 2199.754925 \n", + "alpha 0.546238 0.062607 0.001882 0.431009 0.683215 943.313994 \n", + "beta 0.027682 0.004183 0.000121 0.019921 0.036197 1038.814557 \n", + "gamma 0.800985 0.089085 0.002686 0.624201 0.969263 899.887191 \n", + "delta 0.024174 0.003591 0.000106 0.017432 0.031091 903.692124 \n", + "xto 33.958321 2.995589 0.065663 28.476836 40.251438 2216.184676 \n", + "yto 5.954806 0.528449 0.011694 4.940673 6.990385 1583.237072 \n", + "sigma__0 0.248752 0.044778 0.000940 0.174250 0.341214 1984.170678 \n", + "sigma__1 0.252926 0.044053 0.000971 0.175737 0.337417 2414.840347 \n", "\n", " Rhat STAN_mus STAN_sds \n", - "alpha 0.999878 0.549 0.065 \n", - "beta 0.999785 0.028 0.004 \n", - "gamma 0.999962 0.797 0.091 \n", - "delta 0.999911 0.024 0.004 \n", - "xto 0.999853 33.960 2.909 \n", - "yto 1.000744 5.949 0.533 \n", - "sigma__0 0.999702 0.248 0.045 \n", - "sigma__1 1.000951 0.252 0.044 " + "alpha 1.001490 0.549 0.065 \n", + "beta 1.000905 0.028 0.004 \n", + "gamma 1.001295 0.797 0.091 \n", + "delta 1.001325 0.024 0.004 \n", + "xto 0.999667 33.960 2.909 \n", + "yto 0.999951 5.949 0.533 \n", + "sigma__0 0.999723 0.248 0.045 \n", + "sigma__1 1.000093 0.252 0.044 " ] }, "execution_count": 10, @@ -704,29 +689,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/osvaldo/proyectos/00_PyMC3/pymc3/pymc3/sampling.py:1100: UserWarning: samples parameter is smaller than nchains times ndraws, some draws and/or chains may not be represented in the returned posterior predictive sample\n", - " warnings.warn(\"samples parameter is smaller than nchains times ndraws, some draws \"\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "4fe97ab2eb4b4fe2ab49bc1ca5cfdb7d", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, max=500), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" + "/Users/demetri/anaconda3/envs/gsoc/lib/python3.6/site-packages/pymc3/sampling.py:1109: UserWarning: samples parameter is smaller than nchains times ndraws, some draws and/or chains may not be represented in the returned posterior predictive sample\n", + " warnings.warn(\"samples parameter is smaller than nchains times ndraws, some draws \"\n", + "100%|██████████| 500/500 [00:05<00:00, 91.69it/s] \n" ] } ], @@ -744,7 +709,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -851,7 +816,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -942,23 +907,23 @@ "text": [ "Sample initial stage: ...\n", "Stage: 0 Beta: 0.009 Steps: 25\n", - "100%|██████████| 1000/1000 [00:55<00:00, 17.88it/s]\n", - "Stage: 1 Beta: 0.015 Steps: 9\n", - "100%|██████████| 1000/1000 [00:26<00:00, 37.05it/s]\n", + "100%|██████████| 1000/1000 [00:42<00:00, 23.70it/s]\n", + "Stage: 1 Beta: 0.014 Steps: 9\n", + "100%|██████████| 1000/1000 [00:19<00:00, 51.19it/s]\n", "Stage: 2 Beta: 0.019 Steps: 5\n", - "100%|██████████| 1000/1000 [00:17<00:00, 56.88it/s]\n", - "Stage: 3 Beta: 0.028 Steps: 13\n", - "100%|██████████| 1000/1000 [00:58<00:00, 17.02it/s]\n", - "Stage: 4 Beta: 0.054 Steps: 4\n", - "100%|██████████| 1000/1000 [00:18<00:00, 52.84it/s]\n", - "Stage: 5 Beta: 0.114 Steps: 10\n", - "100%|██████████| 1000/1000 [00:52<00:00, 26.37it/s]\n", - "Stage: 6 Beta: 0.239 Steps: 4\n", - "100%|██████████| 1000/1000 [00:21<00:00, 46.46it/s]\n", - "Stage: 7 Beta: 0.496 Steps: 8\n", - "100%|██████████| 1000/1000 [00:36<00:00, 27.21it/s]\n", + "100%|██████████| 1000/1000 [00:13<00:00, 75.69it/s]\n", + "Stage: 3 Beta: 0.028 Steps: 14\n", + "100%|██████████| 1000/1000 [00:46<00:00, 21.71it/s]\n", + "Stage: 4 Beta: 0.053 Steps: 4\n", + "100%|██████████| 1000/1000 [00:13<00:00, 73.70it/s]\n", + "Stage: 5 Beta: 0.111 Steps: 8\n", + "100%|██████████| 1000/1000 [00:27<00:00, 36.49it/s]\n", + "Stage: 6 Beta: 0.237 Steps: 4\n", + "100%|██████████| 1000/1000 [00:13<00:00, 73.44it/s]\n", + "Stage: 7 Beta: 0.519 Steps: 8\n", + "100%|██████████| 1000/1000 [00:27<00:00, 36.05it/s]\n", "Stage: 8 Beta: 1.000 Steps: 4\n", - "100%|██████████| 1000/1000 [00:20<00:00, 49.45it/s]\n" + "100%|██████████| 1000/1000 [00:13<00:00, 71.96it/s]\n" ] } ], @@ -991,7 +956,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1052,38 +1017,38 @@ " \n", " \n", " a\n", - " 0.230932\n", - " 0.017052\n", - " 0.000531\n", - " 0.201126\n", - " 0.266330\n", + " 0.231128\n", + " 0.016112\n", + " 0.000470\n", + " 0.199191\n", + " 0.261736\n", " 0.2\n", " \n", " \n", " b\n", - " 0.236115\n", - " 0.080920\n", - " 0.002661\n", - " 0.094373\n", - " 0.397491\n", + " 0.232353\n", + " 0.073796\n", + " 0.002175\n", + " 0.092065\n", + " 0.368774\n", " 0.2\n", " \n", " \n", " c\n", - " 2.920302\n", - " 0.035240\n", - " 0.001100\n", - " 2.853546\n", - " 2.991818\n", + " 2.923832\n", + " 0.033734\n", + " 0.001033\n", + " 2.859648\n", + " 2.989395\n", " 3.0\n", " \n", " \n", " sigma\n", - " 0.478180\n", - " 0.016855\n", - " 0.000528\n", - " 0.443860\n", - " 0.509162\n", + " 0.478079\n", + " 0.017448\n", + " 0.000581\n", + " 0.444733\n", + " 0.511978\n", " 0.5\n", " \n", " \n", @@ -1092,10 +1057,10 @@ ], "text/plain": [ " mean sd mc_error hpd_2.5 hpd_97.5 True values\n", - "a 0.230932 0.017052 0.000531 0.201126 0.266330 0.2\n", - "b 0.236115 0.080920 0.002661 0.094373 0.397491 0.2\n", - "c 2.920302 0.035240 0.001100 2.853546 2.991818 3.0\n", - "sigma 0.478180 0.016855 0.000528 0.443860 0.509162 0.5" + "a 0.231128 0.016112 0.000470 0.199191 0.261736 0.2\n", + "b 0.232353 0.073796 0.002175 0.092065 0.368774 0.2\n", + "c 2.923832 0.033734 0.001033 2.859648 2.989395 3.0\n", + "sigma 0.478079 0.017448 0.000581 0.444733 0.511978 0.5" ] }, "execution_count": 18, @@ -1129,7 +1094,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4gAAAHNCAYAAABculU4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzdd5xU9b3/8deZttO2d2Apu1QBBQEFBGwoNuwtaBKNsUfNTaLJjfozMcmN5iYxRk00es3VG1GJ0cQWTTQasYsdadI7W9hepp3z++NsG2aWsiw7u8v7+Xicx+x858zZz8AuzHu+zbAsCxERERERERFHqgsQERERERGRvkEBUURERERERAAFRBEREREREWmlgCgiIiIiIiKAAqKIiIiIiIi0UkAUERERERERAFypLqC35eXlWcOHD091GSIiIiIiIinx4YcfVlqWlZ/ssYMuIA4fPpwlS5akugwREREREZGUMAxjQ1ePaYipiIiIiIiIAAqIIiIiIiIi0koBUURERERERAAFRBEREREREWmlgCgiIiIiIiKAAqKIiIiIiIi0UkAUERERERERQAFRREREREREWikgioiIiIiICKCAKCIiIiIiIq0UEEVERERERARQQBQREREREZFWCogiIiIiIiICKCCKiIiIiIhIK1eqCxAREdmdaDSKaZqYpollWQlf73q7u8f68vMdDgcejyfuSEtLS2hLdrjdbhwOfeYrIiL7TwFRRER6RDQapbGxkcbGRhoaGtqP3d3fm3MDjjCjc5343eB3GwQ89q3HCQZgGPb3b/u69S6GAe9vMXl/SyyhVr8brprqSfr8PX29eqfJk19Ek/4ZfHeGh0yv0eU1OtfW+ev6kMVP3ggnveY3D3czscAOf6YFoRiEYxCKWvZtDMIxi6jlwDRcxHBhOd2YhotPdvqJORNDZrrXSTDNheFOw+FOw+H24vGk7VMo7W6YVZAVEenbFBBFRA4ylmXtR3CrJ9JUx876Zhoa4s9vaWnh0EIHhxUmhrlA6/08t8HQXR/LA3+xwYV/aeaDjYlh7qzxLp4419+t13r7v0NJA2K6x+BXJ3q7dc0XVkW6DIj/Md3D4Ix9D0DbG8wuA+L80S5OH+Peh6tZQBgIU/bbHaytthLOuOkoD3fOjX/94ZhFKNp6G4Zwc2IIDUXhx/8O8e8NiX+mI3McXDHF3XGNJEE2FO0IsqbDhWW4sZxuqiJp1MR8SQKlmzSPB7cnMXx6vV6CwSDBYJD09PSE213bXC695RER2Rv611JEZICIRqPs2LGDbdu2sX37drZt29Z+dL6/fft2wuEw80e7GJvnID9gEPR0hLgCt5EY8DLAn2sQ8Nj9Xnm/qKeqOTF4nD/ezc2z07pVf2aakbS9MdKty6VE4p/I3kn+yluv2d2LAqHkORaPM1mb0dq+u2rgnveTB9mybIMbZ+7r330EiPBfi6u5+V+hhEdzfAZVN6UTNe1w2jmohsMWoQoIb48PoU1Ri5oYfLgtxs/f7Ki1LVCmp6dzwTjIDKRhuvxYniBGWjoOXyZOXybuYDbuYA7+9GzSMzK6DKBerxfD2P2flYhIf6SAKCLSxzU2NnYZ+Cq3byFSvQWroRxPpIaCgEFhwKAwaFAYcOCMWNz2bEvS635nhodjhnfvvwG/G6qaE9ubIt1PM/4uOsmauwg5eyMjI50hQ/JxOBwYhoHD4cDhcJDns4DKbl0zJyeH2bNL467ZdpuW9jF2792+8Xq9LFhwOuFwOOHIzl4LNHSr1nBiRx8Aac7uB5tQV9d0df+aXddp37ocBi4PBIA9Bdg23l1+tFtaWmhpaaGyspLL5wcpze6ipzcCVEO0yqIhbA//rQ9b1IdgQ6PJGU/YP/hOpzOuB3POUAeDMj1YnkBr4MywA2egLXBmEUzSs9l2GwwGcTqTJHcRkV6mgCgikgKWZbFz586kPXy73q+vr+e7MzyMyHZQGDCY3BYACx1kDuv8ZjlxGGZFo9llDTsauh/m7J7E+OcbhkHU8HT7mj/64Y18d+QZBINBAoFA+5vmtJov4bkbwO0Ht6/11g9Od+skP6Njsl/71/b9b39lLt8ec1LiNwvVw+t3dC5+l+d3/fWM3JG8MWlB8hfxzu/sa8c9j05fd9TW+etMT4DHjrg8+TVX/h2q19vnWjGIhiAWgVgIYmGIhrFiYcxIM2YkhBVuxoyGsKIh3llyJyHLFRc4Q6EQJeseJ7ztRQwrisOM4qSLhJbE7KOPIzApMyHITsipBLbs9XU6C8WS/ywm6+nc+2t2/Vj6XvyYuhwGWV7I8nb8jm2r7/g6FotRW1tLbW0tAHcc5uOMsV18ytEAkVqL+jA0hK320LkpBPVhiyuea6Gq2cLn88UNjz2kwMOIHCdGWhDDm4HLn4nTn4UnmIs/PXOPQ2s9Ho96OUVknykgiogcIOFwmDVr1rB8+XJWrFjByhXLqdv0Bf7mbeRQQ77Pau3pMxgZMIhWmny/i96+K6e4GZW77++Wc/0GTgN2ff/t8/moN72wD8GgTczh4Yk//S9G8WHtIS4YDOLz+TDWvgafPhEf5Nq+9vgTQ57bB54AuH0c4s+17++qaCJc/q99rnO30tJh3s969poAM67p+WuOOXmPpxiAs/XorKzLZxwff9ey7LDZGjg7h0+7vTWURkP8oGgi+HMSL1mx0g6z7ddJHmStSIsdYCMtWNEQREN8+9YL+FrJiYRCobjQ6apdD5/+xx5ffzJp/nQGDcqmvr6ehoYGrE5jddO7GM68J/Xhrj9U2dM13U6DHJ89bHZXVzxn/943NzfT3NxMeXk5AOcem8YtY5MM2w1BqNGifmN8L+fW1sBZH7L49bthVux0JITIwdleRuU4cPgycHgzcQWycAeyCWRkddm72XYbCAS0yJDIQUABUURkP9XU1LBixQpWrFjB8uXL2Lb6c6LbV+Bv2cbIbBid6+D0XAcjhzrwlra9OUzswvC5uw5rOxotRuXue20Ow+D3v/oJmYNHU1RURHFxMcXFxQSDQVjxAqx/CwJ5dmBqDWod4a0t1PnA3faYD6fDyWFdfcOy4+xD+hfDAFeafXRvCinkj7GP3X2b1mPXiFHYeiR15qWtQTOcPHwmCaLEwpyaMYgtfzwCsHvsm5qaaGhooL6ujrq3/4ualjqslnoIN+CINOKMNeOKteC2QngI4zYSe99DlofcXC/19fWEw/FDidM93e+pa+gieKbv5u8izWWQ5jLI62L9pv/7LMLS8ijV1dVUV1e3t58/3sWd03d5kgUtVRb1W+1ezrbAuSMEa8KtQ2zDFn9dEePz+kzy8/PjjqL8bEbmOEnPLSarsITswiHkFxaTl5eH270vCyyJSF+ggCgishdM02TTpk3tQXDVimV8sXwlK1asYMeOHe3n+VzQdHMGTIR9faddGEj+BtPtdrf29iVOxjNxEE3LhmA+rsxiHOlFduALFECwAAL5XD5sZvKeubGn2scAFYvFCIfDRCKRpLehUIimpqb2o7m5Oe521/ZwOIxlWV0ebVs9dHV4vV68Xu9eP+5yuXA6ne1H5/tt8x4PCoYBLo99dPsSBoFAgEAgQGFhIYz6456fFA1DuME+QvbtRIeTynunAPYIgYaGhvYeyqwP76a8dj1WyA6cjmgzLrMZtxnGQxhXksAJEImB2xck1JA4z3R/QmdXvZ1dXdPrMvC6DPIDXV9zbXULr6+voqqqihUrVrS3j8tzsOzaINQCa+22pohFddiiMeKgxXIRxkPU6cV0BTC86Vi+HBzphVgF43GOOq49bKaldfcTChHpKQqIIiKdtLS08OWXX9ohcNnn1Kz7mFj5KvzNWxiWHmN0joPzcx28Vh7jd/9OXKWlOQoba02GZu77MKyCoJM777iDotZevuLiYoqKisjJycGx6u9QsxEC+e3Bj0ABDl82nj405KulpaW9x6KiooINGzawfv16tm/fTmVlJRUVFe23VVVVRKP7sQKNpITT6SQjI6P9yMzMJCMjg/T09Lj2nJyc9jf9eXl55OXlkZOTQ1paWv8Ity4PuHKSD6cFPB4POTk55OS0Pj7+D7u/XjTUGjTr2wMn4Qbc0RD1PzkV0zTbt5NpC52ZXzxKRcUHGOFGnNEmnLFmu4fTCuM0dj+HuDnmBBJDaXeH14Lds5hMMEl297sN/O627xVtPZqAnXZTyD4WvvYEFz39vY760tPJz8+noKCAu6dvB7efqCcLy5+HI6OQtOzB+POHkV5cRvaQ0fizCjrN+RWRnqCAKCIHJcuy2LhxI2+//TbLP3yL2JaPcNeuJ9eqZlSugym5Ds7ONHAON2A47DrDa3Ru12/OVlV1HRDDrgxi2SNwFYzBnTustafPDnvOYAE35ZRBssDXSz19bUPxqqqq2sNd2+26detYv34969evxzS7XvwmFdwO2rfmcLf+NdWHLKp3mdLpMMBp2Hv2OR321223oZg91G/Xt5pOh8GYXPv8SAy21Jutz7PndzparzEyx4HP1dHudEB1s8Vbm2IJ1zQMOH6Ei/Q0ewXPT7fHiJj29e1bi4hp9yoHPUZ7W9S0H68PWe1LBEVNe5sHe59Be8GXti0hDoRYLJYwbPFAcrvdCUGz8/DGtvt5eXlkZWURCATw+/19b4GWtiG8geRjxR0OR/siM8XFxXbj4Ycnv5ZlQbQlLmi2fx2yh81+/oMzCRtp7WGz7Ta45nl2bnkBR7QJV6wZl2kHTsceAifspldyP0Jn+S4LadXX11NfX8+m9Ws5Yl4GdqDcbC8OXNl6fNlxfkvUoqrFSV3MTYPlp8WZTo1nEMuzj28Pmp1/XgKBQN/6uRDpgwxrfzZY6oemTp1qLVmyJNVliEgvC4VCfPTRR7zzzju8/fbbvP3227RUb+P9y4OMzNn3Hri6kEXmHfWA/QZ21KhRjBs3jrFjx7IgbxnDzQ24i8bhLhoLuSPtI6e0y96InmRZFg0NDWzcuJHPP/+cNWvWtAe7tqO3eu4y0+wA5XV17K3oa91n8ehhLk4a6aQg4ODjbTGqmi3SPQbpaZCRZg93O7zYgcuR/M3cjgaz/VpdndMStTqFuIPvTeGKylin0AkR02LW0OSfDX+8LcbKKrMjbLZubD+hwMnxI5w0hOH5VRGWbDPbA2zbNb0ug4kFDhojdsi2D1haHmNjrRW3T6Fpgcth73sZMa32+qIp/MzB6/XGBc9dg2jb15mZmfj9/rijzwXR7rAsiDTHBUzCjQk9npHSuVRZmVRUVFBRUUF5eTkVFRUEKj7mVPMfuKwwXiOCz2myt79u//lqC3e8mbg1THHQYOt307v1cv69PsoxjzQlfWzxN4IUpruoi3lowk+LK4OYNwcC9jB9b24JgYLhZA4qI3fQCDIyM/v/369IEoZhfGhZ1tRkj6kHUUQGpK1bt/LO22/x5Xsvs+KzD3n89WUJi0oAZHRzuksgzclLTz9G6YRpjBgxAperd/45tSyLqqoqVq5cyVtvvcWbb77J4sWLqamp6ZHrZ6RBQcDRvp9ifsAg3WNw/AgXk4ocFAYN7n4vTChq9xqke2gNdQZzS7v/Z9DlnnS7URjc83O8+7E330AwNm/vV76dXOxkcnHX52f74KuHefhqlysU7Z2oaXUZ6DsHz1DMoiCQ+HfcErW4691wXG9pOGaH2vmjXdS2WKytsXh+VYTGMDRG7LDaGLbPKQra3zsUtWiM2D24LS0tbN68mc2bN+/fi9sNv9+f0OOZl5dHUVERQ4YMYfDgweTn55OVlUV2dra9KnBvBRPDsBek8vjtIexdcANFQFFR0e6vZ5oQaSLWXEtN+WZqyjdTX7GVhuodNNWUE66rxGqsxBWqJpyfxvjxLe3Dz9tGJxR0MSd7b5Q3dt35MSobCoMm0NJ67ATW2yNgq1qPVfa5LVGLTY1QHXZSHvbx3xsmJCzQk5+fT1GWj5zCIRQUDyYrK0uBUvo99SCKSL8XiUT47LPP+PjNf1C99BXSKpcyJtDAEYOdZPsM3tgQ5ej/Tf5p8rMX+pg/putV9uqdWUQzhpE2aDy+IRMwckdBbhlkDQNnz4dC0zTZvHkz77zzDm+++SZvvvkmn3zySbeu5XLYQxQHZzgYlG4wON1gULqDwekGX5/U/QU/RPqrmGl12ZO8vsakLtS2R2HHSp4nlLowLdjWYHL7v8PUhSwaI1an8GnhMOwe0MbwrruDHjgjRoygrKyM0tJSysrK2o8RI0aQkZHRL0OKaZrt85d3bttAbOP7hKu3EKvbjtFYgStUg9esJ0gzma4IeT6z0zzHDvd9EOZbLyZuGeQwIHxLerdGE6zZaTLynsSFhABeXODn5FEuqpstdjRa1ERc1JtemowAYXcmpi8XI70AT9YgfPnDCBaOIKd4OPkFBfYc8z40j1wOHupBFJEBpbKykvffep2N7z1PbOP7FEQ2MbUIvpntgMHYR6d/3qYUO5PuBej1etnhLiFm7aDWOwSr4BDShx+Op3icPSQ0ewTpni7WkO+mSCTCxx9/zOLFi9t7/6qqqvbpGukeGJHtwO+2e/kKWo/CoIMCv8EFEw7CZeUdLntbjlDdHk402O1b+Ozhnc5rY7VuVN+qaCIYDjCc4HB2fL3x7eTXzBud5JpA5cqOr0uPgVgUzIi9ZYMZse9XLE9+zcIJraVZ9rnR1i0e6rd1/dpkt8FgeNbu36QPy3Lw4kX79rbpgy0x6sNWfPAMW8we6qQo6GBbvcnCpRE219lBs3PobPu6KZL82uvWrWPdunX7VA/YPZm7hsqRI0cyYsQI8vLyyMzMTFlgcTgc5ObmkpubC2PHAvN2e75lmtRUbqN68yrqtq2luXID4eqtZMxw8+3R3vahsG2HWV/e7aHmOxq7HgNd2Norne0zyPYZ2IsDNbUeFcBq+5+d6tZjld3rXd5okfm7JnwZuXE9kgUFBYzJd1GYFSR32FhGjJ/G8LJROJ37vheuSHcoIIpIn7dhwwZefvllop88SVbtF4wNNnBioQOXx4CRkLirWryAx2B8gYOatCHMmDGDmTNnMmPGDA477DA8sSZwesjpwSBYW1vLW2+9xdNPP82zzz5LRUXFXj834Mbu5cswWnv9HPziBG+P1ZYywcJOeyy23laugobWLUJKj4Fxp7fuxxiEtKB9TqQJ1v7b3qOxba9GTxCyh0GwqH1vRpytoTgWtedMGa3BzeHcJcj1v16VfdJcY/+ZxSJgRjuFzU7367fZK+KGG+1z2+abjZwLDnfrXoOh1v0EQ/af/5pX7euXHmMH3s4h1ozApvehdlPymvx5nfYuDCU/x3CCdYBW1UmhaYN3/4a+NNvBUV3MCe3KisoYn2w3OwVPO3ROKnQwo8TFtnqTNzbGWL3TpDFstc8LbWydF9oYaWbL6qWsXLaUyD7O+ywoKIgLlm1Bs6CggOzsbLKysnptuD2A4XCQVTCYrILBwLFxj301yfmWGaN+x3pqtnxJ/Y51NFduJFK9FauhHEdzFZ5wLT6rgXRHCzmeKL5OL2V3w1a7MxzW47T3sGwImTS0BtjOHpzv5YLDPVADfGoveFUdcdPiDGL6cnFnDbJ7IoeOwZdb0rqydevhzRz4/9bJAaUhpiLS50SjUd59911eeOEFnn/+eZYuXQrAK1/1c/w+znNrtjzUBUdinHAbBZNO6tE6Lcti06ZN/OUvf+HRRx/d66GgRUGD0bkORuc6eHB+x/6EdSGLjP1YDbDHZA6191IMFthv7r2ZsOol2LnGfnziefaG6J50O7SlBe3QBnYQaHuTEixIvv+iHLwsyw6qbT2e0ZD9M+LLsuetmZ16UUN1sOxv0Fwdf2QOgewRnUJnxA6eddtg5Qsd36t4UqcQ3GgfZhfdcQe56maLP30eaR9W2xY8/W6YPdTF+lqTj7bF+KLcpKrZYmezhbmPbx/bwmTn3svi4mKys7Pbw2Wf2wMx3EhTxQZqt6ymqr6JjaGMuMV57KOchye8S15adK8X5mmzocZk+N3Jh63+7UIfp+9m+sPuvHnYryk5fC4lJSXxvcHNNR3/RitAHvR2N8RUAVFE+oSdVVW889z/suW9v/Kfi5axc+fOhHN+dlwaP5zd9RuIiGlQ5SrCGjyF3EPn4RkxA7raNmIftYXWRx99lEcffZRQqIuekFbj8hycOdbFmWPdpHvg0x0mo3MdjMpx7NeS8N1SNBHSB0F6EWS03jaU2z14OaX2m+2cEfbXeuMgA1ks0hEW23pPm6vt3uWsYR3bRYTqO1bvfO76jueXHhsfOCNNEG6yzz3IVDdbVDaZmBaMSbIY0itro/x7Q7S9h7NtiG1dyA6glU0WFY1WwtD/XQUCgbhey7KyMgYNGtQeLNuOXl3UJxkzBk07adm5ibpta2jYsY5Q1WaitdugsQJnSzVp0ToCNJHhDON3mXy0HaY8kHxY/LuXBThySPeGlObcWUd1C/h8PkaPHs3YsWMZM2YMpxWVM23HQixfDkbheCg4BArGddx6M/bnT0D6GQXEThQQRfoGy7JY8cl7rPj7A7jWv86kQCUlrXsHDvpVPdsaEv9tOn2Mi79d2DEUtCKWTmPWWNLHHUvOxBMwig4F9/4Px6ypqeGpp57i0UcfZfHixbs9tyhoMD7fwSH5TsYXOLhySi8u/pI9wh7uF8jv6PEL5Ntvgv25UDjeDoQOzVsROaDa9iVsqYPGcqjfAaFauze+0zYRhOrt4+3fQkut/dxDzrB7QncNnbUbU/uaesl9H4SparIDY1WzSVWTRVWzxbHDXWytt1i902RHo8mOBovmfdydp7CwMC5YlpSUkJ2dTV5eXvvKsR5Pihbsav37DrkzqaysTJgveXTVY+RFt+GniUxXFOdefs4ZiVmk/bQ+6Uzre0728q0jun690WAxzuKJGAWHdITGvNE98v+q9D39NiAahvEwcBpQblnWhCSPG8DdwCnYM4EvsSzro91dUwFRJHVampv48IU/svO9RRQ2LOXw/EjS5e4v/Vsz//tJx1Awp9PJzJkzOXveHM4cXEHRlNPwls7scsPpfbFp0yYeeOAB7r///i4Xi3EaMKnIwX/OSuOcQ+whP29ujDI+39m6IEEPcnrsHr62Hr/0YvuNpSsNig6F4kMhd5Q9rFNEBi7LssNiS63d499QDg3b7Q+BdtmfkFADLH+2Yx5o2XH2HN1wQ3yP5/bPUvuaesCanSbljSY7Gu0VQ8sbLXY0mAzLcrB6p8nnO0ze2xLb5yGwAB6Ph8MOO4zDDjuMSZMmMW3aNCZPnozbneKFv8wY1VvXsmH5ErZ/+Rk7N6+isXwD0dpteMI15Pms1sXKHJiWxeh7G5Ne5vWv+zl6+L5N0zBxEE4vgXP/iHfYlJ54NdJH9OeAOAdoAB7tIiCeAlyHHRCPBO62LOvI3V1TAVGkd21b/TnLn78PY82rTPDuIH8vJvMv+iLC1f/ycfLJJ3Pqqacyb948cnJ6ZoP5lStX8vOf/5xHHnmky3MGpxtMH+LkyCFOjhzsZOogZ9Kl1LvNk25vlZFbBo2V9gIuw2fZi4RkDNIQTxE5MMJN0FjR0ZvZtLN1oSjL7sVs6+HsHDqjnbaLyCmFpqqO3s8+yrQsalqgqsmeM9nWK3nWWDdRE5ZVxFheabKswuTTHTHe2BAjug8L9kybNo3Zs2cza9Yspk+fTlFRUcqGt0YiEdauXcuKFStYsWIFK1eubP+6uro67tyXL/Yze6gTXzf+Pxv06wa8ecMYM2YMY8eObR+2emh6DdktG1t7Hcfp/7B+pN8GRADDMIYDz3cREB8AXrcs6/HW+yuBYyzL6nKdbwVEkQMrFovxwQcf8OnzDzKr/jnGZbXg2Mv/LJqjBhuMEpwTz6b0nP/XI0t6b9u2jV/+8pf8+te/Tvr4iCyDb0/3cP2RB3hxhBN/CoMOt7fPCBboP1AR6b9iUWipsQNm7UbY+K69Mm71Bvu2fitMOMceBt8+r7PO/nrNv1JdfVJVTabdG9nWK9locd0RHsIxi2UVJn/8JEJlU8cQ2MomO3jWhxOvNWjQIGbPns3s2bOZOXMmZWVlZGT07vw+y7KorKxMCI6rVi7HqNnAIXkGEwocTCxwMqHAXjQt2YgegMomk/z/Tr6Yzr2neLl2Wsew1WbSaPQPxVE8gYyR03EVT7SDo79nPuSVnjOQA+LzwB2WZb3Zev9V4PuWZXWZABUQRQ6sN954g6OPPprRuQ5WfmvPwyA3NPupzj2cQbO/SsHUM/d7rkNdXR333HMPt9xyS9LHS7MNZg91MXuYk8sm98DcE3fAXtEzfywUjAVfjr2X3tAZ4NROQiIicVrqoOpLaKq2eyObd9pBs+22qQoqVnRsgdMPLa+Icc6iZnY0WlQ3W3HzAf1uCEVh5iw7QB511FGMGjWKIUOG4PP1zqrPoVCI1atXxwXHNauWQcWXDA80MaHAyYR8BxMLnQzPcvD6+ijHPtKU9Fp7O2y11vRT7xuCUTiejJHTSS87wl5AzXkQ7tvbRwzkgPgC8PNdAuJNlmV9uMt5VwBXAAwdOnTKhg0bDnTZIgetSCRCfn4+tbW1rL0+yIjs+Jn1dWFYbZbgHDOP0Sdfha9o1H59v3A4zEMPPcQtt9ySMJwm329w4QQ3pmW1h8JB6d1c0TRY2PGGZehMmHYZDJkGmSU9skqqiIgkEWmxw2NjpT1H2+G052M2VnQcm96Dta+nutKkIjGLiqa2uZIW80Z2hKmt9SafbjdZU22yemfHsa7GpGR4GbNmzWLWrFmMHTuWoUOHMmjQoAO6z6RlWWzfvj0uOG78cinlG1bx9rLNJMsMVTelk9PNufjz/z2GgtKJccNWR4wYkfo5nweJgRwQNcRUpA+64IILWLRoEb871cvVUz2sqPNSlTWZwlkXUzbnfAxX93vuLMvimWee4aabbmLNmjVxj3ldcOxwF6eNdnHNtP3sHSw50g6Ag6e0BsEhGhYqItIfdB4C29ZLWb8dXr3dbk9gQNJ1P/uG+pDFW5ti/N9nYdZVW+xoNKmLpTHpiKOYPXsOEyZMoKSkhJKSEgoKCuL3PuwhTU1NfPnll3FzHFevWsHRvlWMzo4xscDB+HznXm/jVNFoUvDLxGGrLpeLh87NZ85QqPEMwswdQ/rI6YycOR9H9jD9P/rlt1sAACAASURBVNyDBnJAPBX4Fh2L1PzWsqwjdnc9BUSRA++pp57iqaee4vx5R3H08SeQO3Tsfl0vFApxzz33cOONNyY8NiTD4NRRLk4d5eL4Utf+LSZTegzMuA5GzIH9CLEiItKPxKJ2iOzcM1m3Fd7/A9Rtsc+Z9k07bLYPh622byPJh172hqaI3TOZ7TVoCNsh8gevtLCuxn5vP378eGbNmsVhhx3WHiDbtvroqUV1LMtiy5YtdmhcvozyLz/C2r6UQONGStIamFDgYFy+A48z/vu9ti7KcY8m/7N74xI/s4cl9pS2WG5iOaPwD5/auo/jOHs7p0Bej7yWg02/DYiGYTwOHAPkATuA2wA3gGVZ97duc3EvcBL2NheX7m7+ISggivQX0WiUBx98kGuuuSauPeCGW49O4/tHdXNRGZcPSqbZw0RLpkHeGMgq6YGKRUTkoPP5U1C+DCpW2kfVl3Z7Tqk9LDZU1+slvb0pyuqdnYeuWvjdcFSJk8/LTZaWx1hXbZGZlcXs2bOZPHkyQ4cOZejQoe0hMhAI7HcdDQ0NrFq1ipXLv6By5btEt35OoGE9RY5q3t8c5meLk6zwA+y8KX3ftpAK5NthsWA8nHC7PuDdS/02IB4ICogifZdpmjz22GN87Wtfi2vPSIMfH5PGt6fvx0qjJ/wEhs209xLUfx4iItIbIs12UGwsh4bW3sn67faKrhPOIVq5mrp1n9C85Qsi5avwt2ynIC15cDoQnlwa4d0tMZaWx1habrK9IT4XHH744UybNo1hw4ZRUlLCoYceyvjx4/drlXHTNNm4cWPCthwrV66E+u1s/W569y7sz4Ob1uz5PAEUEOMoIIr0LW1zCs8555y49oKAwRljXJw9zs1xI5wJw1O6lDEERs+DUSdCMB+KJ2sRGRER6T+2fw4b3oaN72Jteg+jdZjrRu84YrXb8ETqyPXG8Lp6fj5eZZPJ0nITlwM211n8dUWE51dFaYwknjtv3jwuuugizjzzTNLTuxnqdlFbW8uazz+gYtliQps+wl29msyWLRySB1ne3b/eT2oz+HTSTznrrLN6fVuR/kgBsRMFRJG+4R//+Adnn302jY2NgL1EwCWT7DA4PMvBzBLnXu+fSMl0OxSOngcFh2gSu4iIDGyWBaF6zLpt8D8n4AjVHtBvt6wiFrfSatuxsdYi1ilKXHXVVdx4442Ulpb22PdubGzkuWef5aU//5HKZf9mXC7t23Acku9oD8q/fS/EDS+F8Hq9zJ8/nwULFnDyySeTlpYGT1wEWcPgiG/aw39FAbEzBUSR1Pnkk0845ZRT2LatY6HhYZkGd8z1cuGEbixrPfliOP42e+N5ERGRg5kZg9rNsHOtfVSvw9q5llj5l7h2rjrg335rvckzK6Lc/GoLtSG77YILLuDGG29k8uTJPbK6alVVFX/+859ZuHAhixcvxmFAWbaDiYUO1teYfLTNjDs/KyuLGy6cy48K/9HaYtgfJh9xBZQdd1B/oKyA2IkCokjvikQi3Hbbbfz85z9vb/O54JxD3Fw6yc1xI/ZyT6fckfZehGNOgSOv1Oa6IiIie8s0oWG7HRyr1sDGd6F5J9bwWYQ3f0p062ek1a7DZfXM/McPt7bOa6ww+XyHPb9xaKaDk2ZN5oQLrmTy8WfjTc/Zr++xceNGnnjiCR577DE+++yzLs974DQvV0xJsvZA7ig7KE76CqT1zBDZ/kQBsRMFRJHesX37dk466SQ+/fRTABwGnD3OxYllLi4Y7yZjb/ZKKj4Mxs2HsfMhf8xB/UmfiIjIAWWaULMeti+FRV894N9uS51JeTRAVunhFIw5kkDJRBg0GXJG7PO1li5dyuOPP87ChQtZv359e7vTgNXXBxmetZveS086TL7IDou5Zd14Jf2TAmInCogiB9Y///lPTjzxxPb7k4scvPb1AJl7mFweZ8qlMPs7kDX0AFQoIiIie625Gnauax262npbtRo2v3/AvuXOsReTfcxVGIUT9unDYcuyeOedd1i4cCFPPvkklZWVpDnhgglurj/Cw5RBe1h9deRcOPIqKDt+wC9wp4DYiQKiSM8zTZObb76ZO+64A7AXnLn92DRumbOX21IMngrjz7SHjx5En96JiIj0Wy11sGUJrPw7LH8e6rcesG+1dty1DDnqAjzFh+z1FJNIJMIrr7zCwoULeeaZZ2hsbGTGECfXHeHh3ENcuHezOnosawTO6VfavYqO7m/p0ZcpIHaigCjSc3bs2MGJJ57YPvY/z29wySQ3VxzuZlTuHv5BDRbCoRfApIugYGwvVCsiIiIHXEMFlC9rP1o2foxRsZw0I9p+Ssy0cDr2fdpIOGZRZeRi5o0he8ws/MOn2B8yB/N3+7zGxkaee+45Fi5cyN///nfyvTGumurhyiluCoPJewq/bMrgi5n3dKyEOsAoIHaigCiy/1599VXmzp3bfv/oYU6unOLh7HEu0vZmX6YFi+zhG869XKBGRERE+i/ThNpNWOXL2F5Vx8OvLGfh7+9kaDBKWbbByBwHU4qdzB7WvfcF6wOTMOb+iKGTjsHYw5DUqqoqnnrqKRYuXMi7b73BeYe4ue4ID0cOif9g++Knm3ns8wiZmZmcd9553HrrrQwdOnCmviggdqKAKNJ9jzzyCJdccgkAaU5YdJ6P08fs5Wqi2cPh4qc1hFREREQAe87g2rVree655/jdXXfwP8fVdzskfv+VFh5YEuaYk87g6KOP5qijjmLy5Mm43V2/T2lbCXXhwoWkVS7luiPcnD/eTXWzxdDfNBCOdZybl5fHv/71LyaWZMKyZ+2ttnxZ3aq1L1BA7EQBUWTf/fWvf+Wss84CwOWA/5ju4RcneHf/JKfH3rR+0gJ7DL9WIBUREZHdsCyL1atX8/o/X+TNJ+/mgiHb2dZgMTjdwcQCB4Mzdr9wTCRm8a91MZ5ZEeGvK6LsaLSYM2cOs2fP5qyzzmLKlCldPveLL75g4cKF/OPpPxFo3sK/N8QSzsnLy2PZ3eeSv2ohuP32tlvH3twvt95SQOxEAVFk773++usce+yxgL134WWHu/nujLTdLxedUwZTLrHnFgZye6dQERERGXAsy2LVqlW89tprPProo6z4+B3GFziZWODgd6f6dvtc07J4Z1OMo4a6+N4/WvjNu2HKRo3m5ZdfZvjw4bv9nu+++y6PPfZY+0qobXwu2PLdDLI7f0Y+7Ztw6q/285X2PgXEThQQRfbso48+av+ULcdncO00e3x+fmA3wXD8Wfb2FCPmqLdQREREepxlWaxYsYLXXnsN35LfMTdzAyWZe78dRSRmcfJjTbyzI42tW7eSmZm5+/MjEW688UbuvvtuAC6b7Oah05ME0wv+ZO/b3I8oIHaigCjStVWrVjFmzBgAxuU5WHZtcO+e+JUnYcxJB7AyERERkXiWabL2raepfvtRiqrfZ4i3ea+e1xSxOPH/mph2zrf49a/v2u3CNpZl8e1vf5vf/va35PsNLp/i5oYjPRR0/tDcmwlXvdmv9m9WQOxEAVEk0ebNmykpKQGgNNtgzfXpu3+CM82eWzjzOi06IyIiIn2CuWM55W88jLHieQpje96X8ZPtMe77IMxFd/yVY044pcvzLMvihhtu4J577gFg6iAHb38jEL+XYsmRcMmL/WaFdgXEThQQRTrs3LmTsWPHUlFRQZ7fYMO3g/jduxkempYB0y6DI6+G9MLeK1RERERkX9RsxHr9DoxPHtvzqS0Wjy93cMk58/ClZ9vDRcuOA3fHcFLLsrj++uu59957AfjODA+/OnGXBftmfw+Ov7VHX8aBooDYiQKiCMRiMc466yyee+45XA64dpqHHx+TRqZ3N+HwhNvtOYbejN4rVERERGR/Va2BJ78K5V/s/XPSi+Hch2HYzPYmy7K47rrruO+++zCA5xf4OGVU5xVMDfjaX6H0mB4q/MBRQOxEAVEOds888wxnn302AHNLndx9kpdD8p1dPyFjMFz+mnoMRUREpH8zTVj3Omuf/CHDWpbhdOx+UT3LmYZx7sMw7rSONsvi2muv5fe//z35foNPrgowKL3TfMRgIVz1FgTzD9Sr6BEKiJ0oIMrBqqqqiry8PABGZBn86kQvZ43bzb493iz41pI+/w+ciIiIyL5q3raSJ753IqcN2rnbVdotHBjz77K38GplmibXXnst999/P8cOd/LK1/w4Oi90M/IEWLAIHHu/wmpv211A7LtVi0iPaBsOkZeXx+B0A+u2DNbekJ48HKZlwJFXwQ2fwQ82KByKiIjIgOQrHsOlj21g03n/4KvPNLNkayzpeQYmPHcDjS/eBq0daw6Hg/vuu48rr7yS19bH+NnicPyTVv8T3r3vQL+EA0Y9iCID2LvvvsuMGTNwO+CG6R7++wRv1ydPvhiOvw2CBb1XoIiIiEiKxWIxfvazn/G3+39MYcDBoHSDB07zJgxBXeccybCSQTjOfgAyBmGaJldffTX/8+AfeP0SP7OGdqxgahlOjKsWQ+H43n45e0VDTDtRQJSDQUtLC6NGjWLz5s3MGOLkf073Mq6reYZDpsHJd8LgKb1bpIiIiEgfsmnTJo4//ni+/PJL5o928eS5PnxJVnev9Y8g87sfgNONaZpcddVVvPTkQ3xyVZAcn0HMtPjNJz6ufWItXn8gBa9kzzTEVOQgctddd+Hz+ajesZnfnJTGm9/wdx0O5/0XfOMfCociIiJy0CspKWHVqlU8/fTTPLcqygn/10R1c2JnWmbTOl6+bhzr1q3D4XBw//33M+/8y/jG35rZVGtyzCNNfO+5cv7yzF9T8Cr2nwKiyACxdetWDMPgO9/5DqeNdvH51UFuODItftJ0Z99bDTOu7dMTqEVERER621lnnUVtbS3jT76M2X9sZGu9mXDOvIIKfn3hGHbu3InD4eCBBx7Ac+hZjL63gTc32vMZ33///d4uvUfonaHIAPCLX/yCwYMHMzLHgXVbBs99xc+I7CS/3pO/agfDH9VqARoRERGRLmRkZPDAAw/w0LNvcfqzfsobE0PiPSf7+Nop0wF74ZoFCxbQEu14/MMPP+ytcnuUAqJIP9bc3IxhGHz/+9/n4dO9fHldMPmJWcPga8/CGfcqGIqIiIjspenTp/POss08kfsdombicNM7D9/KqqUfAzBlSvyUnY8//phYLPnqqH2ZAqJIP/XPf/4Tv99Paba9dcWlkz3JT5x+DVzzDpQe3bsFioiIiAwAbreb63/wYzYueDvhsfEFTpbcdhRYFkOGDCE/v+OD+KamJlasWNGbpfYIBUSRfsayLI477jhOPPFE5pU5WXp1F72GAGfeDyf9HDx9cwUtERERkf6idOwErFsqeH1D/HDTBRPd7HjhZxiGwdSp9sKgQQ8MzzJY/9ZfYEv/Gmrq2vMpItJXrF27lrKyMoIeuP80L1dO6aLXEOCHWxUMRURERHqQ4fIw7vZPWfrzQ5lQ0LFKfPZ7v4BJJzFlyhSqP/8H71zW+h5s66/ghdfgitdSVPG+Uw+iSD9x++23U1ZWxpxhTj67Kth1ODzjd/YiNAqHIiIiIj2usKSUS/7upC7UMSfR4zSILFzAjENHUdm0y1zFpqpernD/qAdRpI9rbGwkGAzidcGT5/o4f7w74RzLcGBMvQxO+LGCoYiIiMgBtujVj/nGaWN46nx/e5u7aQenfHEdX2+JD4hWUxVdbDrWJ6kHUaQPW7x4McFgkCnFDppvzkgaDskdiXHZP+HUXyocioiIiPSC0tJSnlvj4K53QwmP/fa0rLgVT41wA0RaerO8/aKAKNJH3XrrrcyZM4ejhzlZckUXC9FMvwauXAxDpvZucSIiIiIHuffee4+b/pkYEJsDQxKHmTbv7KWq9p+GmIr0MZZlMXr0aNauWc0tczz86Oi05Cd+/XkYMbt3ixMRERERACZNmkTUhHveD3PdER1rQ5R4G6hssijq/Pl+YyVkDOr9IrtBPYgifUhtbS0Oh4O6bWt4+WI/PznWi9ORZNT6Ne8qHIqIiIik2Kuvvsqfv4jEtY10V/TrhWoUEEX6iCVLlpCVlcWxw518cmWAuaXxHfwWBpQcCbdWQsG4FFUpIiIiIm2OPfZYPtgaIxzrCIQjsh24d01ZCogisi/uuusupk2bxspvBfjX1wMUp+/yq+nPw7j4L3DZP8CZZKEaEREREel1hmHwyGNP8uHWWFz7UUN3mckXTZyr2FdpDqJIis2aNYvPl7yFdVtG8hOGzYJzHoKM4t4tTERERET26Oyzz+auh77GjJLdRKvckb1X0H5SQBRJkaamJgKBAJOLHNT+oItwOOdGOPoH4NSvqoiIiEhf5HK5WBctBGq6PqkfTQ/SEFORFFi7di2BQIBzD3Hx0ZVdbGEx7+dw3C0KhyIiIiJ9XJ0ju8vHmjx54O2iM6APUkAU6WVvvvkmZWVlnDLKxZ/P8yc/6YI/wYxrercwEREREemWunCSVedbRXPH9GIl+08BUaQXLVq0iNmzZ3PlFDfPXuhLftINn8G4+b1bmIiIiIh0W0VL1wExrWRyL1ay/xQQRXrJL37xCy684ALumJvG/af5ku9vePMOyB7W+8WJiIiISLeFosnb39gEaaUze7eY/aTJTSK94Morr+SR//kDC8/xceGE+G0qLMOBcfIv4IjLU1SdiIiIiOwP0zQT2m54qYXF4fF8NPbUFFTUfQqIIgfYnDlz2LniLVpuSZycbLn9GOc+DGNOTkFlIiIiItITLMtKaIvELIYN638jwzTEVOQAsSyL7OxsHBvfZuk1iSuVWoECjEteUDgUERER6edM02TJ1lhc26oqUwFRRGyxWAyHw0Gxq44XFiRZqTR7OMY3X4HBh/d+cSIiIiLSoywzxri8+Gi1tFwBUUSApqYmXC4Xhxc7eONSPwFPksVoLn1Ji9GIiIiIDBCD/NG493xVTSY7Gi1KS0tTWFX3aA6iSA+qqakhOzubWUOdPP8VP5neJOHwh1vBE+j94kRERETkgBgRaI67X9Fkz0mcMWNGKsrZL+pBFOkhtbW1ZGdnM6/MycsXJwmHU78B/69a4VBERERkgMmJlcfdH5vn5NPr8ijIzUlRRd2nHkSRHlBXV0dWVhYPn+7l0smexBOOugHm/hiMrjdRFREREZH+aUK+M6EtkJ4Fzv4Xt/pfxSJ9TH19PZmZmfz9Ij8njUzyK3X8/4PZ3+39wkRERESkV1x0qDuhLVQyKwWV7D8FRJH90NDQQEZGBksuDzBlUOInR5zySzji8t4vTERERER6xeeffszEJO2Dj/56r9fSEzQHUaSbGhsbSU9PZ+nVXYTDsacpHIqIiIgMcE88+JuENtOCzDFzUlDN/lNAFOmGpqYmgsEgP5jlYXxBknB4yJlw4WO9X5iIiIiI9Kr3/574nu+TaCk4+mfU6p9Vi6RQU1MTgUCAG4708PPjvYknTLkUzn+k9wsTERERkV533IjEWXvGqLkpqKRnKCCK7IOWlhYCgQDfmOzmNyclCYfTr4H5icMMRERERGTgMU2Tc8clBsSyE/rvNCMtUiOylyKRCD6fj3MPcfGH0+LDoenw4PjKQhh1QoqqExEREZHe9vZrLzMrN366UVWLg9zBo1NU0f5TD6LIXrAsC4/Hw8kjXTx2tg+no2M/Q9Nw47hokcKhiIiIyEHmrYX/ndD2ufPQFFTScxQQRfZCTk4Ot8zx8OJFfjzOjnBoGQ4c5/8vlB2buuJEREREJCUObXkvoc1/6PwUVNJzFBBF9uCYY45hwahGfnJs4pxD48zfw7jTUlCViIiIiKTayaMSZ+xNPOWbKaik5yggiuzGNddcQ/2qxdx3ii/xweP/Hxx2Ye8XJSIiIiIpV7t2SULbskrwpWeloJqeo4Ao0oW77rqLlx6/nxcX+BMf9GbC7O/2flEiIiIi0iesfegbCW2Vh1zS+4X0MK1iKpLEM888w09v/i5vf8NPYXCXz1F82XDTutQUJiIiIiJ9wmTPhoS2CWf3/w4E9SCK7OL9999nwfln8+yFPsbkxS9bzMzr7XBoGMmfLCIiIiIDnmXGEtp++XaInKKhKaimZykginSybt06Zs04kqfP93PU0F062CeeB3N/rHAoIiIicpB75bG7E9qi07+Vgkp6ngKiSKv6+npKS0sJ35qRsCKVNXwWnHEfOPQrIyIiInKwe+WB/4y7/86mKAu+eX2KqulZercrAliWRUZGBhu/HUx4zMwbi3HBY+BKS0FlIiIiItLXzCuL70z4v88iDB3a/4eXggKiCABFRUX86SwfJZmJvxKOi/8Mvv69XLGIiIiI9IwNyz/muBHxAbGuYFqKqul5Cohy0Lv66qtZUFrDRYe6Ex88+yHIGhifBomIiIjI/lv8ywUJbd+/4/4UVHJgaJsLOagtWrSIFx9/gA3fTk98cOb1cOh5vV+UiIiIiPRZF5dsTWibMGFCCio5MNSDKAetlStXcvnXLuCFBf7EB4fOgBN/0vtFiYiIiEifFa5Yk9D24EdhjAG0yr0CohyUGhsbmXDIWP58np8JBbvsdZhZAt94KTWFiYiIiEifVXfvcQltE655NAWVHDgKiHLQsSyLYDDIvad4OXGXFaisQ86AGz5LUWUiIiIi0pflGTUJbdPnnZuCSg4cBUQ56IwdO5Yrpri5coonrj1WfDjGWQ9or0MRERERSWCGGhLaPt4WG1DDS0EBUQ4y3//+9zkhcx0PnOaLaw8HinFetAjcvi6eKSIiIiIHs9f+K7GnsGb+wymo5MDSKqZy0Hj11Vd56ZFf8ulVwbj2iJGG52tPQzA/RZWJiIiISF93vPFOQtsxpw68Fe/VgygHhZqaGk4+cS5vXhpIeMx9/H9C4SEpqEpERERE+oNYc11C28MfD6zVS9soIMqAZ1kW2dnZ3HOKl/S0JL/Es/6j94sSERERkX7jrZ+eltA2+rqnUlDJgaeAKAPevHnzuDLJojQA3FLe+wWJiIiISL8yx/1pQtusuaemoJIDTwFRBrQnnniCxhX/4p6TvXHt0fQhcNM6cKWlqDIRERER6Q+iVesT2u58K9T7hfQSLVIjA9bWrVv51jcW8PGVAdzOjqGlEcOD++I/gz8nhdWJiIiISH/g+O0k2GWW0nE/fjk1xfSCPt2DaBjGSYZhrDQMY7VhGD9I8vglhmFUGIbxSevxzVTUKX2PZVkMKxlM5U3plGTG/5i7z39Yi9KIiIiIyF5xGFZC27SZR6egkt7RZwOiYRhO4D7gZOAQ4CuGYSR7V/+kZVmTWo+HerVI6bPGjh1L883pCe3WzOth3PwUVCQiIiIi/U1ky2cJbfcvCaegkt7TZwMicASw2rKstZZlhYEngDNSXJP0A7/97W/5SvEGXI7EFUuN4/9fCioSERERkf5ox70nJbTNuuODFFTSe/pyQBwMbOp0f3Nr267OMQzjM8MwnjIMoyTZhQzDuMIwjCWGYSypqKg4ELVKH7Fq1Soe+Ol/8KNjkiw+c/lr4HT3flEiIiIi0i85wvVx92tbLCZMmJCianpHXw6IyXad3HUA8HPAcMuyDgVeAR5JdiHLsv5gWdZUy7Km5ufn93CZ0leYpsnYMWP44ppg4oMzr4PBh/d+USIiIiLSL9Vt+IxB6fFxaf5TZoqq6T19OSBuBjr3CA4BtnY+wbKsKsuy2taYfRCY0ku1SR80fvx4vjczyV6HACf+tHeLEREREZF+7f5r58bdX7whylNvr01RNb2nLwfED4BRhmGMMAzDA1wIPNv5BMMwijvdPR1Y3ov1SR+yaNEiMuu/5GfHJRlaevOO3i9IRERERPovy+KmqfF7HS5cGqGgoCBFBfWePrsPomVZUcMwvgW8DDiBhy3L+sIwjNuBJZZlPQtcbxjG6UAU2AlckrKCJWVqa2u54msX8PGVwfj9Dl1B3Ne+DW5vCqsTERERkf5m08v3sOviJjuL5qSklt5mWFbivh4D2dSpU60lS5akugzpQYZhsOhcH+eN32UBmq88AWNOTk1RIiIiItJ//SgzoSlycyVu98BY8NAwjA8ty5qa7LG+PMRUZI9uuukmrprqTgiH1pFXKRyKiIiIyL6LtCQ0vbo2OmDC4Z4oIEq/tXLlStY8fxe/P9UX1x7KHYdxwu0pqkpERERE+rPqXx+R0LZ09PUpqCQ1+uwcRJHdsSyLKRPH0vDDjLj2KE7SFjwGriSL1YiIiIiI7EF284aEtutv/q8UVJIa6kGUfmn69On85qTExWdc406B3LIUVCQiIiIi/Z1Vn7j6/buboxhGsi3aByYFROl3nn/+eZxbP+TSSUnGgZ//f71fkIiIiIgMCF/eeXRCW+3ZT6SgktTREFPpV1paWvjKOfP55MogTscun+Rc/zEcRJ/uiIiIiEjPGu3altA275T5KagkddSDKP1KdnY2vznJS1nOLj+6F/8FckpTU5SIiIiI9Hv1X/wzoe2cRU0pqCS1FBCl33j88cc5aXiUyyZ74tqtaZfDyLkpqkpEREREBgLnwnMT2u59dWMKKkktBUTpF5qbm/nZDRfzzAX+uPZQ+jBtaSEiIiIi+8eM4d9leYvlFTGKi4tTU08KKSBKv1BQUMDSa4JxbVHLIO0rj4LH38WzRERERET2rOreExLaHmw4PgWVpJ4CovR5ixYt4vH5sYR255GXw6BJKahIRERERAaS3J0fJrT98o/PpKCS1FNAlD6tpaWFO274CqeNTtzSwjjhJymoSEREREQGEqsuceXS1TtNHI6DMyodnK9a+o3i4iI+ujKY+MAFfwK3t/cLEhEREZEBZd0vEvc+XHHs/6Sgkr5BAVH6rL/85S+cNjRxaWErUADjDq79aERERETkwCh17UhoO+2s81NQSd+ggCh9UigU4sqvnsevT0xLeMz4jy9SUJGIiIiIDDQ1a5YktJ30p8YUVNJ3KCBKn1RSUsJd89LID+zyI/rVZ8DlSf4kEREREZF98NC1x8Td+sHHhQAAIABJREFUr2mx+N83N6emmD5CAVH6nJdeeonDM3by1cPig6B13K1QdlyKqhIRERGRASUW5aLxRlzTDS+1UFRUlKKC+gZXqgsQ6cw0Tc4742SWXh2/ME1z5kh8R92QoqpEREREZKBZ+fuLGJPe0V9WH7LImvH1FFbUNyggSp9y2mmn8e9LAgzL6vhljVngO/9BcCZudSEiIiIi0h1jKl+Ku7+i0uQ3f/hDiqrpOzTEVPqMNWvWMLnhVQ4vdsa1O2Z+CwYfnqKqRERERGSgiWxMXJzmyS8iGIaR5OyDi3oQpc84bNxIGn6YkdBuHHtzCqoRERERkYHK/fDxCW0X3ftOCirpe9SDKH3CnXfeyXdmJFmd9NhbwOPv/YJEREREZGAyzaTNkw/XiDVQQJQ+oLGxkQfv/E9+ODtxz0OOvrH3CxIRERGRAWvLI99MaPvOp6NSUEnfpIAoKTd48CDuO8WH19Ux5rsRH9y0LoVViYiIiMhANHjDXxLa/vup91JQSd+kgCgp9eqrrzJvSBPzRsZPhw2cdTf4c1JUlYiIiIgMRFbNxoS2u94N4XQ6k5x9cFJAlJSxLIuzT53Lb+Z549obC6bAoeenqCoRERERGag23zkjoW3MtU+moJK+S6uYSsqcf/75rPpWkMJgx+cUYdMgcP4DoCWGRURERKQnWRYlaQ1xTVHT4pT5Z6SooL5JPYiSEtu2bSN77d/iwiGA++jvQZ4mCYuIiIhIz9r6t9sT2s5+PpCCSvo29SBKSgwdMojIrUn2PJzz3RRUIyIiIiID3aBPfp3Q9uRba1NQSd+mHkTpdS+++CIfXpHk05ojrwa3r/cLEhEREZEBLdniNA9/HMbn03vPXSkgSq+yLIvvfX0+h/5/9u47LIqrjQL4GWDpoiACFlCwt1iwd8WOxl4idqMmYj6J3agBW2IvUdQkthhb7MZojDW2aFTU2HsXFbGh0nfv94eyOMxSVGB24fyeh0fm3dnZM7sL7svcueNqYKaoZpMzPxARERERZXl3Jysnp8ndbYkKSYwfG0TKVAMHDsR8X2vlDX12Z34YIiIiIsr6hIBFXISspBMCrdp/plIg48YGkTLNy5cvcfL3H1GvkPzUV2HnArhXVikVEREREWVlF/esRL4c8ran/Q5HldIYPzaIlGm8PAsiuHmSax6a54I06LRKiYiIiIgoq/t3Xl/Z8rYrcVh94IpKaYwfG0TKFCEhIWjp/goV88rPPbTzWw5YcnphIiIiIkp/utdP0Km0RlZbcCIOVlZWKiUyfmwQKVPUr1EJ3/nIfxBfejQEvOqqlIiIiIiIsrpFAxvARiPpl28912HArE0qJjJ+bBApw82YMQPTG1vDzT7x7RatBXK0naViKiIiIiLK0nQ61Le/Liv9GBKL5r4tVApkGtggUoaKj4/Hn8Ej0M/bUla3qD0YyOWhUioiIiIiyupuL/0cRXMnnt4UqxU4FldcxUSmwSL1VYg+XIMGDXCgu/IcQ4u6Q1RIQ0RERETZRcG7G2TLluYS/jp0UqU0poNHECnDPHr0CDah/yhv8KoPWNlnfiAiIiIiyhbibv2rqI3ZGw0LCx4fSw2fIcow7vnz4nR/W+UNXTcoa0RERERE6USzrLGi9um0A5kfxATxCCJliJMnT6JfRQuUypM47lsnBNBzO2BmnsI9iYiIiIg+QlyUonThsRZVqlZVIYzpYYNIGaJ+DW8E1pVf1iKqeDugUE2VEhERERFRdvDfbxMVtZBSY1RIYprYIFK6W7NmDUbUtEIeu8S3V2S8BLuWk1VMRURERETZwdNds2XLr2IFuvmPVCmN6eE5iJTuxn3lh1P95TOXauoOAXK4qpSITElERATCwsIQFxendhQiIvpAGo0GLi4ucHBwUDsKZTPPrx5FfU95ixNwtjQWqZTHFLFBpHQ1cuRIXPSXz1D6XGuNXHW+VikRmZKIiAg8evQI+fPnh42NDSRJUjsSERG9JyEEoqKicP/+fQBgk0iZas/kz9DOPXH5wO14TFu+Xb1AJohDTCndxMXFIeyvmYp6zsYjeVkLSpOwsDDkz58ftra2bA6JiEyUJEmwtbVF/vz5ERYWpnYcykZE1HM0cX0iq80/HgtHR0eVEpkmNoiUbho3boQlrWwUdam6vwppyBTFxcXBxkb5HiIiItNjY2PD0wUoU+2b1Rf2lol/YH7wUod+s7aqmMg0sUGkdBEeHo4WlkeVN1TpD1hYZn4gMlk8ckhElDXw9zllKm08GsTulJUWnIhFg0ZNVQpkungOIqULz0KF8HKolfKGZlMyPwwRERERZSsPf+kFtyQ1i6p9Vcli6ngEkT7a5cuX0bpwrPKGFrMB/vWQspmgoCA4Ozt/0H3Hjx+P/Pnzw8zMDD179kzfYOmkUqVKacp2//592Nvb48aNGxkfyohs2bIFJUuWhKWlJQoVKqR2nI9SqFAhDB06NF225ezsjKCgIP2yr68vJkyYkC7bBj7u5y4rWbt2LZYtW5au2/z7778hSRLOnTsHAIiNjUVQUBBOnz6dro9D9LHc7vyuqI2Z/IMKSUwfG0T6aOVKl8DE+gaOHlbqlflhiEzUiRMnEBgYiIEDB+Lw4cMYO3as2pE+ysSJE9GyZUt4eXmpHSXTaLVadO/eHeXKlcPevXuxadMmtSMZrZEjR2LmzJl4/vy52lGylIxoECtWrIgjR46gcOHCAN40iOPGjWODSEblxY2Titqk004wM2Or8yH4rNFHOXbsGPyrWKJgrsS3UqwWwP/4HwfR+7h06RIAwN/fH9WrV9d/GPsQUVFRButxcXHQarUfvN20ioiIwC+//ILevXtn+GMZkwcPHiAiIgJdunRBrVq1UKFCBbUjGa3atWsjd+7c+PXXX9WOkiUk9zOfnPf5XeDg4IBq1apxAjEyajsndZAtn3qgxec/Gpgbg9KEDSJ9lCZ1q2J0bfnRQ13FnoCTpzqBiIxMwvCsv//+Gx06dIC9vT28vLwwf/58/To9e/ZEt27dAAA5c+bUrw8AT58+Rf/+/eHq6gpra2vUqFED//77r+wxJEnCzJkzERAQgDx58qBs2bIAgHr16qF9+/b46aefULhwYVhbWyM0NBQAcO7cOfj6+iJHjhzIkSMHOnTogIcPH8q2e+7cOdSsWRPW1tYoWbIkfv9dOXzHkLVr18LGxgYNGjTQ127dugVJkrBmzRr06tULDg4OKFCgAFasWAEAmDp1KvLly4c8efJgxIgR0Ol0iiwp5X39+jUGDhyI4sWLw9bWFp6envD390dERITiuZozZw6++eYb5MmTBy4uLvD390dMTEya9qts2bKwsrKCu7s7Ro8ejfj4eADAsmXL4O7+5sJbrVq1giRJsiGV74qLi8PQoUPh4eEBKysr5MuXD23atEFs7Juh+g8ePEDv3r3h5eUFGxsbFCtWDGPGjNHf/rHPZ8JwzMOHD6NixYqwtrZG+fLlcejQoVSfg0OHDqFu3bqwtbVF7ty50bdvX7x8+VK2zoEDB1CuXDlYW1vD29sb//zzj8FttWvXDsuXL0/x8RL2c9WqVejWrRty5MgBFxcXjBs3zuD6p06dQrVq1WBra4sKFSrg4MGDstuXL1+OWrVqwcnJCY6Ojqhfvz5OnDghW+f8+fNo2rQpnJycYGdnh5IlSyI4OFi2zpYtW1CpUiVYW1vDzc0Nw4cPT3W2znd/HgsVKgQbGxv4+vrqrxWYIDw8HD169EDu3Llha2uLevXqKTIWKlQIQ4YMwYQJE1CgQAE4ODigZ8+e2LBhA/bv3w9JkmTvweR+F1y6dAmdO3eGu7s7bG1tUbp0acyePVv2fkk6xDRHjhwAgF69eukf59atWynuO1FGEtEv0MTlsaw240gsXF1dVUpk+jhJDX2wnTt3YmQtKzjZJJ5n+CpOgn1j0x4aR5QR+vbtix49eqBfv35YvXo1/P39UalSJVSpUgVjx46Fu7s7Jk6ciL1798LGxgalSpVCTEwMGjZsiOfPn2PatGlwcXHBggUL0LBhQ1y9ehVubomn40+bNg116tTBr7/+Kvtwd/jwYVy/fh1TpkyBra0tcubMiWvXrqFmzZqoVKkSfv31V2i1WowdOxYtW7bEsWPHIEkSoqKi0KRJEzg7O2PVqlWIiopCQEAAXr16hTJlyqS4r3v27EGVKlVgbm6uuG3EiBHw8/PDhg0bsGTJEvTo0QOnTp3C7du3sWTJEoSEhGDMmDGoUKECOnfuDABpyhsZGQmtVotJkyYhT548uHv3LiZNmoQOHTrgr7/+kmWYMWMGGjRogBUrVuDMmTMYNWoUChYsiOHDhye7Tzt37kSnTp3QvXt3TJs2DWfOnMHYsWPx5MkTLFy4EL6+vti4cSPatm2L6dOno2bNmihQoIDBbX3//fdYuXIlJk+eDE9PTzx8+BDbt2/XH9EJDw+Hk5MTZs6cCUdHR1y5cgVBQUF4/Pgxfvzxx49+PgEgMjISXbt2xahRo5A3b17MmDEDzZo1U7yv3nX48GH4+PigdevWWL9+PZ48eYKRI0fi2bNnWL9+PQAgNDQUzZo1Q5UqVbB+/XqEhobCz88PkZGRiu3VqFED06ZNw7Nnz1K9RtmwYcPQokULrF+/HgcOHMC4cePg7OwMf//EyyhFRkaiR48e+Prrr+Hm5oZx48ahTZs2uHPnDmxtbQG8aTi7d++OwoULIzY2FqtWrUKdOnVw7tw5/XDoTz/9FCVKlMCKFStgZWWFy5cvy/7QsHbtWnz22Wfo378/vvvuO1y/fh2jRo2CTqfD9OnTU9yPI0eO4PLly5g5cyaio6MxYsQItG7dGsePH9ev07p1a1y7dg3Tp0+Hs7Mzpk2bhvr16+PUqVMoUqSIfr1Vq1ahdOnSmD9/PuLj41GuXDncuXMHz58/1/8B6t33oKHfBVeuXEHx4sXh5+eHHDly4PTp0wgMDERUVBRGjRplcB/27t2LBg0aYMyYMfD19QUA5M2bN8X9JspIu6b2RGOrxM+iD1/p0GcmL23xUYQQ2erL29tbUPqo4GYmRKCD7Ctm93dqxyITduHCBdkyAKP4eh+BgYEid+7c+uV9+/YJAGLs2LH6WmxsrHB2dhYjRozQ15YuXSoAiJcvX+prixYtEhqNRly5ckVfi4uLE15eXmLo0KGy56l8+fKKLHXr1hXW1tbiwYMHsnrXrl1FsWLFRExMjL525coVYWZmJv744w8hhBDBwcHCwsJC3L17V7/OoUOHBADRo0ePFJ+DokWLyvIJIcTNmzcFANGzZ0997cWLF8LCwkIUKVJExMfH6+uVK1cWHTt2fK+8ScXFxenz3r59W18HIGrXri1bt1WrVqJq1aop7lPVqlVFvXr1ZLUpU6YIMzMz/XOUsI9bt25NcVu+vr5i8ODBKa6TdF9WrlwprKys9M/BxzyfgYGBAoBYuXKlvvby5Uvh6Ogoe08WLFhQDBkyRL9cq1YtxXOwZ88eAUCcPXtWCCHEsGHDhJOTk3j9+rV+nRUrVggAIjAwUHbfhH3YuXNnsvuesE6jRo1k9c8//1zky5dPaLVa2T7t2bNHv86pU6cEAPHnn38a3LZWqxVxcXGiePHiYty4cUIIIR4/fiwAiDNnzhi8j06nEx4eHrLnXQghFi9eLKytrUV4eHiy+1K3bl1hYWEhbt26pa8lvEcTMv75558CgPj777/167x69Uo4OzuLfv366WsFCxYUbm5uIioqSvYY7dq1E3Xr1jX42IZ+FyTdt7i4ODFp0iTh6empryf8Dkt4jV++fCkAiKVLlya7rXcl/b1OlK608eL6/+xln0XH1rFUO5VJAHBCJNMvvfcQU0mSykqS1EeSpNGSJE2QJOlrSZJ8JUlK+c9/lKWsWrUKJ/vby2pPYi1hWXuQSomIjFvjxo3132s0GhQtWhT37t1L8T67d++Gt7c3PD09ER8frx/OWLduXcWQs4S/5Cfl7e2tOCK0e/dutGnTBmZmZvrtenp6olChQvrtHjt2DN7e3rIjEDVr1oSLi0uq+/rw4cNkZ5T08fHRf+/g4IA8efKgbt26sqONRYoUkQ27S0teAPj1119RoUIF2NvbQ6PRoFatWgCAK1euyDK8+1oAQKlSpVJ8LbRaLU6ePIkOHeTnuHTq1Ak6nQ5HjhxJ9r6GlC9fHsuWLcPUqVNx5swZvPl/OpEQArNnz0apUqVgY2MDjUYDPz8/xMTE4M6dO7J1P+T5TNCmTRv99/b29mjUqBGOHTtmMHNkZCSOHDmCjh076l+D+Ph41KpVCxqNBiEhIQDevG8aNWqkP2IHAG3btjW4zYT3SNKhzYa8mzVhm6GhobLXTaPRoF69evrlUqVKAYBsnYsXL6JNmzZwdXWFubk5NBoNLl++rH+PODk5wd3dHV988QV+++03hIWFyR73ypUruHPnjuJ5aNCgAaKjo/XDMJNTsWJFFCxYUL+c8DOV8LwfO3ZM/xomsLOzQ4sWLRRDgH18fGBtbZ3i473L0O+C6OhoBAYGokiRIrCysoJGo8Ho0aNx8+ZN/e8bImN295e+8HJMbGei4wVs6wxUMVHWkKYGUZIkL0mSpkmSFArgNICFAAIA9AIwAcBWAI8lSdojSdJnkiTx3MYsbu6I7oqak1cFwNLWwNpElCtXLtmypaUloqOjU7xPeHg4jh49Co1GI/taunQp7t69K1s3uXMtDNXDw8MxZcoUxXZv3Lih3+7Dhw8NNoNpaRCjo6NhZWVgZmMYfh5Se27SknfTpk3o3r07qlevjnXr1uHo0aP6WUSTPs/v+1qEh4cjLi5O8VwmLD99+jTZ+xoyZswY+Pv7Y/78+ShXrhzc3d0xZ84c/e2zZ8/GkCFD0KZNG2zZsgXHjh3TnwOXln1Jy/7Z29srJh1xcXHBgwcPDGZ+9uwZtFotBgwYIHsNrKysEBcXl+L7xsbGBvb29optJrxHUvs5SMhmaPndvA4ODrIZCy0tLWXbf/nyJRo3boy7d+9i5syZOHjwII4fP45y5crp1zEzM8POnTvh5uaG3r17w83NDbVr18apU6cAvHkvAEDz5s1lz4On55vz7pP+XKa2Hwm1hP148OCBwZ9ZV1dXxfvsfc+vMrT+iBEjMH36dPTr1w/bt2/H8ePHMWbMGABpe12I1OZ+e4Nsed35OAwfN02lNFlHqucgSpK0CIAfgEMAxgP4B8B5IYT2nXWcAVQG0ATAVABBkiT1EUKkfsY7mZzZs2ejb0WNoi5126hCGqKsy8nJCZUqVcKCBQsUtyVtwKRkrjlqqO7k5IQ2bdrg888/V9yWcFTHzc1NP7Pqu5IeUUkud3peviAtedetW4eqVavKJv/Zv39/ujy+s7MzNBqNYt8fPXqkz/c+rK2tMX78eIwfPx5Xr17FwoULERAQgOLFi6Np06ZYt24dOnTogEmTJunvc+HChY/fkXe8evUKUVFRsiYxLCws2XPJcuXKpZ/0pHnz5orb8+XLB+DN+ybp8xQVFYVXr14p7pPwHknL85d0mwnL73Pu25EjR3Dv3j3s2rULJUqU0NdfvHghW69EiRLYsGED4uLicPDgQYwYMQK+vr64d++ePutPP/1kcJbahEYxrfuRUEvYj7x58xpc59GjR4rnKbmf+eQYWn/dunX46quvZOffbtu27b22S6SW53t/QK4ktZtmhXhpi3SQlklqogGUEELcTm4FIUQ4gD8B/ClJ0mAAHQDkT5+IZGwWTByCCwPsZDVR8lNIVsq/EBN9jKRD77IbHx8f7Ny5Ex4eHmk6cvc+2z137hy8vb2T/ZBZuXJlrFy5Evfu3dMPMz18+HCaGsTixYvj5s2bmZo3KipK0TSvXLkyXR7f3Nwc3t7eWLduHb788kt9fe3atTAzM0P16tU/eNtFixbF9OnTERwcjAsXLqBp06YZui/v2rRpE7p06QLgTcO4a9cu9OvXz+C6dnZ2qFatGi5fvoxvv/022W1WrlwZS5YsQWRkpH6Y6caNhv94mDDzZbFixdKU9d3nfuPGjcibN2+yEwEZknApiHef23/++Qe3bt2Ct7e3Yn2NRoMGDRpg8ODB6NKlC54/f47ixYsjf/78uHXrFvr27Zvmx05w8uRJ3LlzBx4eHgASf6aqVKkCAKhatSoCAwNx4MAB1KlTB8Cb4b3btm1TDLM1JC0jE96V9L2m1WqxZs2aVB8D4BFGUl+uA8pJEb9aZHjWZHo/qTaIQgj9QF5JkuoB+EcIEZvC+joAv6VLOjI6o0aNwvh6VjA3S/yQ9lg4Ik/7pSqmIsqaunfvjoULF6JevXoYOnQovLy88OTJExw7dgxubm74+uuvP2i7QUFBqFKlCnx9fdG7d284Ozvj/v372LVrF3r27Il69eqhV69emDhxInx9fREUFISoqCiMHTs22XML31WzZs00XxIjvfI2atQI/v7+mDRpEqpWrYrt27djz5496ZZh3LhxaNKkCXr16oXOnTvj7NmzGDt2LPr27fteTQrw5nw6b29vVKhQATY2Nli/fj3i4+P1DUGjRo3www8/oGrVqihcuDBWrlyJa9eupdu+AG+GfY4ePRqvXr1Cvnz5MH36dMTGxmLQoOTPI586dSp8fHxgZmaG9u3bI0eOHLhz5w62bduGSZMmoVixYggICEBwcDBatGiBwYMHIzQ0FN9//73Ba+idOHECOXPmROnSpVPNe/78efTv3x/t2rXDgQMHsHjxYsyZM+e9jhRUq1YN9vb26Nu3L4YPH4579+4hKCgI+fMn/j37zJkzGDp0KDp16gQvLy88e/YMU6ZMQbly5fRH8GbMmIFu3bohIiICzZo1g6WlJW7cuIHNmzdj/fr1svMvk3JxcUGLFi0QFBSkn8W0YsWKaNq0KQCgSZMmqFmzJjp16oTJkycjd+7cmD59OqKiojBs2LBU97FEiRLYsmULNm/ejAIFCiBfvnz6o7uGNGrUCMHBwShSpAicnJwQHByc6iVfLC0t4enpibVr16JMmTKwtrbGJ598om8ciTJD3O3jSDqWbeGJWHyRyozIlDbvewx2D4DyGRGEjJ8QAjuWTUWnMvIfyTwdZwHmvGIKUXqztrbGvn370KhRIwQGBqJx48YYNGgQrl69qj/i8CGKFSuGo0ePwtbWFv369UOzZs0QGBgIKysr/TT6tra2+Ouvv2BnZ4fOnTtj3LhxmDFjhmyCjeS0bdsWFy5cUEyokpF5+/fvjyFDhmDOnDlo27Ytbt++jVWrVqXL4wNvJrZZs2YNTpw4gZYtW+rPE5w3b957b6tGjRrYvHkzunTpglatWiEkJAQbNmxApUqVAADffvstPvvsM4wZMwafffYZLC0t8cMPP6TbvgBvXt/ly5dj/vz5aNeuHZ49e4bt27enOGSzVq1aOHDgAB4/foxu3bqhZcuWmDp1Ktzd3fXnt+XPnx/bt29HeHg42rVrh/nz52PFihUGm6YdO3boJx9KzdSpUxEREYF27drhxx9/xNixYzFw4PtNROHq6op169bh4cOHaNWqFWbPno2FCxfKLh3h5uYGV1dXTJo0Cc2aNcOAAQMU1wDt1KkTtmzZgtOnT6NDhw5o27Yt5s+fj4oVK6baJFWvXh0DBgxAQEAA+vTpgzJlymDz5s2ydTZt2oRGjRohICAAHTp0gBACe/fuleVMzoABA9C4cWP07t0blStXxk8//ZTi+nPnzkXt2rXh7++P3r17o0yZMsle3uJdCxcuRHh4OBo2bIjKlSvrr69KlFnuLVBOflVzEo8ephcptSFckiRZCCHi336vA1BNCKGY5kySpKoANgkhkv9TlRGoVKmSSDr7H6WNv78/mj9bCt9iiQ3iY4t8yPPNeYDjvSkdXLx4ESVLllQ7BqWD8uXLw8/PL01HPShzBQUFYd68efoJV9Tw4sULuLq6Yvfu3frZZg25desWPD09sXXrVrRo0SITE6a/evXqwdnZWX/NyOyCv9cp3cVG4skYV+S2TfzseT5Mi9Lzlec6U/IkSQoRQlQydFtaPtWPliTpoSRJu/HmmmC+kiRVkSQp6Z8DLQHk/sisZKSEEHh1+GdZcwgAeTr9wOaQiBRGjx6N4OBgTpVPBi1YsADVqlVLsTkkIjJkz6y+subwebTAldrvP5qDkpeWcYGrADwD8AkACcAwAGMB6CRJugHgPwCXANQBcCW5jZBp++qrr/BLa/k5JI+svOBapKFKiYjImLVv3x43btzA/fv30zQslbKXnDlzpvuwWSLKBnQ6FLi7BXBOvNbr/OOx+GZyT/UyZUGpDjGVrSxJYQBaAniINw1jwlcJABEARgohDmdAznTDIabvTwiBkbWtMaVhkgvyfjoPqNhNnVCUJXEoEhFR1sLf65Sezq6fhrLnJuqX47QCk2O6YuzU+SnciwxJaYjpe80sIoR4d5712wC2fkwwMg2DBv0PPyRtDgGgQtfMD0NERERE2dLTP4KAQonty5pzcRi9gcNL0xtPHqMUCSFgf8rALGj1xwDveZFeIiIiIqIPEb5jKuoWkh/b2hdd+r0ud0Npk+ozKklSN0mSzFNbL8l9ikiSVPvDY5GxCAgIwHc+Bo4e1uXMhERERESUOZyPTpItH70Xj9m/7VUpTdaWlpZ7CIDrkiRNkCSpXHIrSZKUW5IkP0mStgI4BSD5iymRSRBC4OTmYOUNPt9mfhgiIiIiypZe/ac8q+3IA3M4ODiokCbrS/UcRCFEeUmSOgH4Cm8uefEKwEUA4QBiAOQC4AnAA29mO10B4AshxP0MS02ZYsiQIRhbx0pWe23mALvaQ1RKRERERETZzY5Z/mhfSF5rM+8/VbJkB2katCuE+E0IUQtAUby5zMVpAPEA7AA8AvALgKYA8gohAtgcmj4hBP5Z+wMaF5b/DcGu+xqVEhERERFRdhP3/AF88z+X1YKPx6KQp6dKibK+953F9DqA6xmUhYzIsGHDMLaOpawWaumFfIVqqpSIiIiIiLKb38e2RLuFrcOwAAAgAElEQVTciRMj3nmhQ6XRu1RMlPVx2h9SEELg71Wz4FtMI6vn6zxbpUREpkGSpFS//v77b7Vjpig6OhqSJGHRokVqR1FVaGgogoKCcO/evXTdbrVq1dC1a+IlgrZv34558zhFOxGRISLmJerZXJbVZh+NRdUatVRKlD2kegRRkiQnAPMANAKgBfA7gBFCiGfvrFMFb4aYNhVC1MigrJRJgoKCcKKfvaz2QFMQeT3rqJSIyDQcOXJE/31UVBQaNGiAMWPGwNfXV18vVaqUGtHoPYWGhmLcuHFo2rQpChQokG7bXbx4MaytE2eG3r59O3bv3o2BAwem22MQEWUVOyd3RRPbxONZz6IEav3PwOXXKF2lZYjpLAAdAWwDEAagBoA/JElqA2AMgA4AXAAIAEczKCdlotA/vgda2shqeTvN5HUPiVJRrVo1/fevXr0CABQuXFhWT050dLSscSD1REdHv9f6UVFRsLGxSX1FAKVLl/6QSERE2U/sazQRf8tK847HYuyUHurkyUbSMsS0CYCRQohWQoi+AMoCuADgOICBeHNJix4AXN9OZEMmbOHChfi5pYEPOoV9Mj8MURa1cOFCSJKEkydPonbt2rCxscHcuXOxY8cOSJKEa9euydZPOiwRAPbt24datWrBxsYGzs7O+PLLLxEZGZni43bu3Bm1atXCunXrUKxYMVhbW6Nu3bq4cuWKYt34+HgMHz4cuXPnhqurKwYNGoS4uDj97Xfv3kWPHj3g6ekJGxsbFC9eHOPGjZOtI4TA+PHj4eXlBWtra7i5uaF58+Z48uSJfp3Hjx+jT58+cHFxgY2NDWrXro2QkJAU9yPhedq3bx+aNm0KW1tbFCpUCEuWLFGsu3LlSpQuXRpWVlbw8PBAUFAQtFqt/nZDr8W0adNQuXJlAED16tUhSZK+eU947L1796J58+aws7PD0KFDAQCTJ0+Gt7c3HBwc4ObmhtatW+PmzZuyPO++liNHjkRwcDAuX76sH4L8xRdfpLjvRETZxaNZ8pFrkXECOXyGqpQme0nLEUQXAIcSFoQQQpKkCQD6APhWCDExo8JR5vthrD++8JcPLxVV+kPi0UNSU1DOD7tf3nJA/wOGb/uxDvAglSmyg1582OOmUadOneDv74/x48fDyckJDx48SNP99u7diyZNmqBTp04YPXo0Hj16hJEjR+Lly5dYsWJFive9evUqvvnmG0yYMAEajQZjxoxB06ZNcfnyZWg0iecdf/fdd2jSpAlWr16NkJAQjB49GoULF8b//vc/AEBYWBjc3Nwwe/Zs5MqVCxcvXkRQUBCePn2KOXPmAAB+/vlnzJgxA1OnTkXJkiXx+PFj7N69G1FRUQDeHHmrX78+YmJiMHPmTOTOnRtz586Fj48Prl27Bmdn5xT3pUePHujVqxe+/vpr/Pbbb+jTpw88PDzQsGFDAMDWrVvRtWtX9OnTBzNnzkRISAgCAwPx/PlzzJ4tP6c66Wvh7u6OXr16YdGiRShdujTMzOR/T+3Zsyf69OmDoUOHwtbWFgBw//59DBo0CB4eHnjx4gWCg4NRq1YtXLlyBXZ2dor8/v7+uH79Oo4fP441a97MEO3q6priPhMRZQvaOLhGyf9YKgEY9M0EdfJkM2mdxVSbZDnhMhacQigL2bRpE0bUtFTUpWZTVEhDlPUNHToU/fv31y+ntUEcMWIEGjZsKGsGXVxc0LJlSwQGBqJo0aLJ3jcsLAzbt2+Ht7c3AOCTTz5BiRIlsHLlSvTs2VO/XokSJfDzzz8DABo3boz9+/dj48aN+gbR29tbvw0hBGrWrAlLS0sMGjQIM2fOhLm5OY4dO4YWLVrI9rFdu3b675csWYLr16/j4sWLKFSoEACgQYMGKFKkCObMmYMJE1L+INC6dWuMGzcOANCkSRNcu3YNEydO1DeIY8eORdOmTfUT7jRp0gTx8fGYMGECvvnmG7i4uOi3lfS1SDgSWrp0aYNDhP38/BAYGCirzZ07V/+9VquFj48PnJ2dsW3bNnTs2FGxDXd3d7i6usLa2jpNw5CJiLKL0PmtkC9Jbc7TuhjJAxaZIq2zmM6WJOkHSZK+lCSpHqB/zWIzJhap4ete7eD3iXzmUl2H5Tz3kCiDvDt5TVo9f/4cISEh6NixI+Lj4/VfdevWBQCcPHkyxft7eHjoGzsAKFq0KMqUKYNjx47J1mvcuLFsuVSpUrIZPXU6HaZNm4YSJUrAxsYGGo0Gffr0watXr/SNbvny5bF582aMHz8eJ06cgE6nk21z9+7dqFq1KgoUKKDfD3Nzc9SuXRsnTpxI9blo06aNYvn48eMAgJiYGJw5cwYdOnSQrdOpUyfEx8fj33//ldXf97UwtP6hQ4fQoEEDODk5wcLCAjly5EBMTIzBIbxERJQMIZDvyWFFedi8zSqEyZ7S0iDOARCJNxPVBAPYA+DW29vmSZI0TZKkLpIklZIkiZfNMFGHDh3CsJpWsDBLbAbvxdjBrGRLFVMRZW0fMpzwyZMnEEKgd+/e0Gg0+i97e3vodDrcvXs3xfu/e9Ts3VrSo5e5cuWSLVtaWsomb5kyZQq++eYbdOrUCVu3bsWxY8cwa9YsAImTvHz55ZcIDAzEypUrUblyZbi5uWHcuHH6RjE8PBz79++X7YdGo8Hq1atT3Q9D++Li4oLIyEi8ePECDx8+hBBC8RwnLD99+tRgPa2Srn/9+nU0adIEVlZWWLRoEQ4fPozjx48jZ86c7z3pDRFRdnZ71WBFbdK1EjA3N1chTfaU6hBTIcTXCd9LkpQHwCdvv8q+/RoAIGFWk0gA9km38aEkSWqKNw2qOYBFQojJSW63ArAcgDeAJwA6CSFupdfjZyftm9bBrQD5S+fWfgpgxp6fjEBGnAuY3LmJmSjpub0JE6HExsoHZ7zbzDg6OgIAvv/+e/1QyneldkmGsLAwg7WUhqUasm7dOvj5+emHeALKo5fm5uYYPnw4hg8fjtu3b2P58uUIDAxEwYIF0bNnTzg5OaFmzZqK8wEBpGlW0LCwMNmsoGFhYbC1tUXOnDlhbW0NSZIU+/vo0SMAgJOTk6z+vudZJ11/27Zt0Gq12Lx5M6ysrAC8OccyIiLivbZLRJTd3dr1EwoWkrcoQxer/392dvJen/6FEI+FEHuEELOEEL2FEJXxpiEsgTdHGKenVzBJkszx5ohlMwClAHwmSVLSC4j1AfBMCFEEby7HwZPlPsCFCxfwYwtrWFskfuB5GKWBRfnOKqYiyn4SmruLFy/qa9evX8eNGzf0y05OTqhQoQKuXr2KSpUqKb7c3NxSfIw7d+7IZgm9evUqzp07hypVqrxX1qioKH0jlGDlypXJrl+wYEGMHTsW7u7uuHDhAgDAx8cHly9fhpeXl2I/0nI5iE2bNimWE2YftbKyQrly5bBu3TrZOmvXroWFhQWqVq2a4rYtLd+cj53Wo39RUVEwNzeX/YV79erVEEKk+jg8wkhE9MaNv1eibpLmcPSpvIr/byhjpXWSmmSJN//7XXn7tf6jEyWqAuCaEOIGAEiStAZAK7y5xEaCVgCC3n6/Hm+GvEoitf+RSaZ5jTK4FZBDVnP0DQTMNcncg4gyQpEiRVC2bFmMGjUKFhYWiI2NxXfffYfcuXPL1ps2bRqaNWsGnU6Htm3bws7ODrdu3cIff/yBWbNmoWDBgsk+houLCzp37iybxdTDwwNdunR5r6yNGjXC4sWLUbFiRRQsWBC//PKL7BxFAOjVqxfy58+PKlWqwMHBATt37sTdu3dRv359AMDnn3+On3/+GfXq1cPgwYPh6emJ8PBwHDlyBJ6envD3908xw+bNm+Ho6IgaNWrgt99+w8GDB/HXX3/pbx8/fjw+/fRT9OvXD+3bt8fJkycxYcIE+Pv7Gxxq+y5PT09YWlpi6dKlsLKygpWVFSpWrJjs+j4+Phg1ahT69OmD7t2747///sMPP/wAe/uUB9WUKFECd+/excqVK1G8eHG4uLjAw8MjxfsQEWVVF3/qC69iiZ8//7oWj5ErjquYKHsy5vGD+QG8exLKvbc1g+sIIeIBvACQG5Rm9+/fx/kByg8wVtX6qJCGiH777Te4urqiS5cuCAwMxKRJk+Dp6Slbx8fHB/v27cO9e/fg5+eHTz/9FDNmzICXl5eimUyqaNGimDhxIsaMGYMuXbogT548+PPPP/VHzNJq4sSJaNu2LUaOHAk/Pz/kzJkT06fLB5HUqFEDe/bsQY8ePeDr64vt27dj2bJlaNasGQDA1tYW+/fvR+3atTF69Gg0atQIAQEBuH37tv5IYEqWLVuGf/75B61bt8bu3bvx888/yybXadmyJX799VccOnQILVq0QHBwML755hvMmDEj1W3nyJEDCxcuxOHDh1GnTh3UqFEjxfUrVaqEn3/+GQcOHECLFi2wYcMGbNy40eDlLd7l5+eHLl26ICAgAJUrV8Z3332XajYioqwoNGQHfIvJD04sveaIHDlyJHMPyiiSsR5skySpA4AmQojP3y53A1BFCPHVO+ucf7vOvbfL19+u8yTJtvoB6AcAHh4e3rdv386kvTB+xQo448rncbKaTmMHs9GhKiWi7OzixYsoWbKk2jGyrM6dO+PevXs4dOhQ6isbsR07dqBZs2a4evUqihQponYcIkoBf69TWm36zB5tiicO0z98Jx7FJt9EnlRGfNCHkSQpRAhRydBtxnwE8R4A93eWCwBI2rXo15EkyQJATgBPk6wDIcRPQohKQohKefLkyaC4piciIgK/t1ae+2Lmf1SFNERERESUHT07vEzWHALAzBMSm0OVGHODeBxAUUmSPCVJsgTQGcDvSdb5HUCPt9+3B7CX5x+mXauWvijhbGDK4Fw8/4WIiIiIMofjrkGy5ROhWszael6lNPTRk9RkFCFEvCRJAwH8hTeXuVgihDgvSdJ4ACeEEL8DWAzgV0mSruHNkUNOu5lGOp0Obk+PArCV3/CFaQ89I6LkrVmzRu0I6aJp06apzg5KRESm4dnhZXBMUttzMx4jUphwjTKW0TaIACCE2A5ge5Lat+98Hw2gQ2bnygqGDBmMkTXlUwZH5CgGB7eyKiUiIiIiouzm0IIAtExyOnn7BWfVCUMAjHuIKWWgS38Eo5xb4vBSrU7AoWfWOLpARERERMYv/PJRNPfSyWoLT8SicJGiKiUigA1itrRixQoMqS6f0v6GzSdA7sIqJSJKxKGDRERZA3+fU2p2f9sM5maSfvnsIy0azT6jYiIC2CBmS9OH9kBDL/no4qI95qqUhiiRRqNBVFSU2jGIiCgdREVFQaPRpL4iZUtPrvyLDsW1strEgzE8emgE2CBmM8ePH8fGTvKJaS5FOwP5KqiUiCiRi4sL7t+/j8jISP7lmYjIRAkhEBkZifv378OFlymgZPwd1FR29PDCYy0mbTynYiJKYNST1FD6G9C6Go73tZfVinafrVIaIjkHBwcAQGhoKOLi4lROQ0REH0qj0cDV1VX/e53oXc9ObUW7YvJzD4P+jsHa4OIqJaJ3sUHMRh4+fKhoDgHAvISvCmmIDHNwcOAHCiIioizMcUtX2fLZR1pM2sSjh8aCQ0yzkWYNailq8blLAGZ8GxARERFRxnt24CdFbenpOBQtxqOHxoKdQTYRGxuLug53FXWLPn+qkIaIiIiIsiPHvcMUtQG/cOZSY8IGMZv4vHdPfF1NfmmLhyV6ArZO6gQiIiIiomwlbMc0Re3nk7EowqOHRoUNYjYRc3odCuZKfLmj4gTcWoxRMRERERERZScuRycqas2CL6uQhFLCBjEbWLp0KQKqyo8e3s9TB7DPo1IiIiIiIspOru1bqagtOG2GAu4eKqShlLBBzAYWjPkc1d3lE9YW8ZupUhoiIiIiym5uL+2nqHX4+YoKSSg1bBCzuMuXL+NYkktbnI1yBfIUUykREREREWUn57bOh4+X/GBF191OcM7D0WzGiA1iFuffupqiVrJTUOYHISIiIqLsRwhEbJbPXLrrejzmb/9PpUCUGjaIWVhMTAx2d9Ip6hblO6uQhoiIiIiym5BVE1AjyalOa8OLwsHBQaVElBo2iFlYwBc9FbWYXEUAM77sRERERJTB4mPgfXWGrLTlUhzmbjqqUiBKC3YKWVhH3e+KmtXnf6qQhIiIiIiym4dTKitqu0QNWFtbq5CG0ooNYha19rffUMPdXHmDvUvmhyEiIiKibEXERsIt7raiPnvlDhXS0Ptgg5hFzRnmBysLSV7svkWdMERERESUrWz5trWiFhz1KSwsLAysTcaEDWIWdOvWLfyviqWsduJlHsCrnip5iIiIiCj7iH/9FLV0R2S1x691GDB5uUqJ6H2wQcyCOjSthXal5H+dKft5sEppiIiIiCg7WR9QC862iW1GRIzAX0UmQJKkFO5FxoINYhaj1Wrxab5wWJgl/gBeDBewKtFYxVRERERElB28vH8JrVzuyWrT/4lB1/4BKiWi98UGMYsZPWII+ntrZLWcjYYC/IsNEREREWWwv0bUgo0m8XNn6Esd6n2zQcVE9L7YIGYxdR/8DBe7xJf1RbRAvqaDVUxERERERNnB4z1z0b5InKz27b4YNGjSQqVE9CHYIGYhp0+dQrOi8nMPo2zcACt7lRIRERERUbYgBPIcHCMrnX2kxeDlISoFog/FBjELmdSrnqLm+tm8zA9CRERERNnKnR87KWrrLgGlypRVIQ19DDaIWYRWq0VD91hFXSrGyWmIiIiIKAPFx8Dj4V+K8qB1tzI/C300NohZxPjRQ9G1rHxymgc1J6mUhoiIiIiyiwcTlUcJZ1wvgtzOziqkoY/FBjGLeLI3GHaWiTNG3YvQIW+DL1RMRERERERZXfyrp8iLR4p6wLJjKqSh9MAGMQs4f+4cvqxkKatdy1kLMLdI5h5ERERERB9v/aDqitpyq54wNzdXIQ2lBzaIWcA3XeujtEviD2G8TqBOwCIVExERERFRVvfk+im0zvtAVpv+Twy6j5qjUiJKD2wQTZxOp8P8BtGy2o5bFjDLmV+lRERERESUHewdVRPWFomnON2P0MF76AYVE1F6YINo4uaP+x/yO8hfxrK9Z6uUhoiIiIiyg3N/LECHUvIJEsfsi0H9xr4qJaL0wgbRxHWJXq6oFazTVYUkRERERJQtxEXDdtdwWen4fS3Gbb6iUiBKT2wQTdjVyxfhZCPJahHCDjDjy0pEREREGePxpJLwcpR/3lx42xMeBQupE4jSFTsJE/b3tz6Kmp3/PhWSEBEREVF2EBN6HnnwVFY7ei8eC7edVCkRpTc2iCasb8nXipq5S3EVkhARERFRdrB/bD1F7VrxAdBoNMqVySSxQTRRO9b/Ap0QstrdIt1VSkNEREREWd21w5vhkz9GVnsaJdB12DSVElFGYINoovbN7gczKfH8w8evdXDvwmvOEBEREVEG0OnwaLEfzM3kl7W4136HiqEoI7BBNEE6rRY9y8kP468JLcDJaYiIiIgoQ+yd9TlqeljIaqOP2OKTyjVUSkQZhR2FCVo1bTBK5jHXL8dpBdoGrlExERERERFlVfEvw1H24TpZ7ffLcZi/56ZKiSgjsUE0Qa8O/SRb3nolHvmLlVMpDRERERFlZcdHlEYeu8S2ISpO4GKhnrC1tVUxFWUUi9RXIWPyKvw++nnLh5eGutRTJwwRERERZWn3No9HdZdoWW3SwRhMPDBfpUSU0XgE0cTcnNZANjlN2Gsdek1apWIiIiIiIsqStHEocHqGotxy8i4VwlBmYYNoYsraPJQtu9iZwc4hl0ppiIiIiCirejCumKL20zkrVK1RR4U0lFnYIJqQB+cOKWq/W7dTIQkRERERZWURV/9BXrOninr3FXdUSEOZiQ2iCdk1vZei1mL4IhWSEBEREVFWpl3UVFFb6/AFrK2tVUhDmYkNoqnQadHAST68tPeWKJjx2odERERElI6OrpoMRxtJVrv7QoeOg6eolIgyE7sLE3Ftz3IUcEh8uV7FCrT7doWKiYiIiIgoq9HFvEKeo5OUdf8TKqQhNbBBNBGnV4yRLW+6GAffNh1VSkNEREREWdHaL8ujsFNii6ATAsMuVUDBIsVVTEWZiQ2iKYiPRQO3l7LSlhuWKoUhIiIioqzo0p5V6FAgTFabdywWU1fvUykRqYENogl4vSMITu+MAw+P1KHL2J9UTEREREREWYmIjYS0qR/MzRI/c95+rkPZgHWQJCmFe1JWwwbRBNidCJYtn36oQ5t2HF5KREREROkjcoI7ijuby2pj/rVH/SYtVUpEamGDaOxePlSU/rgSz7/kEBEREVG6CN23BHbm8bLa1stxWLz/tkqJSE1sEI2c2DJQUTOr/qUKSYiIiIgoy9HpYLF9kKJs0fx7WFpyzovsiA2ikZOu7VLUAoPGqZCEiIiIiLKaTaOawMVO3hLsuBaPZt2UTSNlD2wQjdmrx4pS7y1RyJkzpwphiIiIiCgreXjhMJpY/CurnQjVotYC5SlOlH2wQTRm1/coSmctPlEhCBERERFlKTotrk1vDFtN4rwWz6IEzpYZDfscOVQMRmqzUDsAJe/lv8vx7o/n94diMG9ecLLrExERERGlxfphDdHeQ94KBPwVjV9Oj1IpERkLHkE0VlHPYX3vH1lpzbk4VK1aVaVARERERJQV3N+3GO1znJTV/rgSh9l7ObSU2CAar8vboTETiYvhWpx5pFMxEBERERGZOhEfg/z7B8tqz6IEwqt/C0cnJ5VSkTHhEFMjpT2zHu9eqnTthXjMnDlTtTxEREREZPpeB+WDfZIOIGh/DOYcHalOIDI6bBCNUeRT4MY+WWnt+Tic+HOASoGIiIiIyNTd3PwdPC3iFfXv9zxVIQ0ZKw4xNUZbBsIcicNJ70XocC5MBysrKxVDEREREZGp0kU+g+fpKYr6Tq9vYWtnp0IiMlZsEI3R5W2yxQIOZnB3d1cpDBERERGZujX9yypqG6+ao3H3ISqkIWPGBtHYCKEoDdsVja5du6oQhoiIiIhM3cGlQehS+KWi3nLZIxXSkLFjg2hsHl9SlOYdi0XHjh1VCENEREREpuxF6HUUOTdDVnsSqcOhKj9Bo9GolIqMGRtEY3N1p2xx25U4RMcD5cqVUykQEREREZkkIXBgSFnkzZH4kV+rE5hwrTRqNe+kYjAyZpzF1Nhc3SVb/PPam5mmJElSIw0RERERmajVQ3zwWXH5UcKJB2Mxa+8RlRKRKeARRGMS8xK4c1RW2n5VORUxEREREVFKrm+dgc8cQmS1f+7Go88vl3jggVLEBtGY3NgP6OL0i5fDtbj5XKBEiRIqhiIiIiIiUxL/8jEKh4yX1SJiBC6XHoYCHoXUCUUmgw2iMTm/SbaYMLyUE9QQERERUVrd/7aIojb9X4Feg4MyPwyZHDaIxkII4Nx6WengHS0AoH379mokIiIiIiIT88d33VAwp7I+dseTzA9DJokNorG4d1xROvngTYNYqlSpzE5DRERERCbmyj/bUO/VFkX9ZP3V0FhaqpCITBEbRGNxcIaidOu5AACYm5tndhoiIiIiMiGxr18g+tdOsLdMnIAmKk5gQnhTVKzbXMVkZGrYIBqLKzvUTkBEREREJmppZzd84io/qDBoRzTGzvtNpURkqtggGqnVZ9/MZlq0aFGVkxARERGRMTswqhr6e8uHkK4+G4cfDr1QKRGZMjaIxiDyqaL0Y0gsAMDDwyOz0xARERGRibi8bjzqWF2U1a4+0aLUiJ2wtrFRKRWZMjaIxuDRednixcda/Qym8fHxaiQiIiIiIiP36u45FD+vnMdiT+7uKFellgqJKCuwUDsAAXj1SLZ4/rEOujfz0+DkyZMqBCIiIiIio6aNg/3imorygbvAF4vnqxCIsgoeQTQGr8Jkiw9fCf33L1++zOw0RERERGTsJjgbLNf8SXnqEtH7MMoGUZIkJ0mSdkmSdPXtv47JrKeVJOn026/fMztnuklyBPHhK51KQYiIiIjI2G2Y0N1g/UanA7w8Gn00o2wQAYwEsEcIURTAnrfLhkQJIcq//fo08+KlsxSOIBIRERERJQjZvhxNozYr6js8RsCrZDkVElFWY6wNYisAv7z9/hcArVXMkvEe/CdbZINIREREREk9uXcNjn/5w85S0te0OoEFj8qjae9vVExGWYmxNoiuQogHAPD2X5dk1rOWJOmEJElHJUkyzSZSpwPC5LOYRsTIG8TIyMjMTERERERERkYXH4uQUeXg5Sj/+P7ltmh8uWC/SqkoK1JtFlNJknYDcDNw0+j32IyHECJUkiQvAHslSTorhLhu4LH6AegHGOF1BV+GKkq3nsvPQbx16xZKlSqVWYmIiIiIyJgIgaUdnNGnnPyj+8ITsVhwLEqlUJRVqdYgCiEaJnebJEmPJEnKK4R4IElSXgBhhtYTQoS+/feGJEl/A6gAQNEgCiF+AvATAFSqVMm4xm+GX1GUHr2WRzx//jwbRCIiIqJs6v7oAuhTTpLVDt2JR6uFlzgpDaU7Yx1i+juAHm+/7wFgS9IVJElylCTJ6u33zgBqAriQaQnTy5Mk/WyJFojVykshISGZl4eIiIiIjMap75siv+UrWe1+hA669suQt0BBlVJRVmasDeJkAI0kSboKoNHbZUiSVEmSpEVv1ykJ4IQkSf8B2AdgshDC9BrE+Bj5sr2rYhU2iERERETZz5EtS1Ah5oiivsOuHeo076BCIsoOVBtimhIhxBMAPgbqJwB8/vb7fwCUzeRo6c+xkHz56Q3FKidOnMicLERERERkFG6eO4a8+wYBueTHczbedUSfxcvUCUXZgrEeQcw+nLzky09vwM1NPnfP8+fPMzEQEREREakp4skjPJhVH4WSNIdbL8eh7eJb6oSibIMNotqSHkF8cRdfDfhCsdqKFSsyJw8RERERqUYbF4P9Az1Rw10+0G/+8Vj4rnipUirKTtggqs3SFttYz/cAACAASURBVHDIn7gsdBj6uXJMebdu3fDyJX8pEBEREWVZQmBbd0e0LK6RlXdej0fXFfdgxhlLKROwQVSbTgtE3JeVLJ9egY+P4hRMFCpUKJNCEREREVGmG5cLnyZpDk8/1KLIqENwcMytUijKbtggqk0y8BKc+hVbt25VlJ8+fYpVq1ZlQigiIiIiykx3Ryhnsr/5TIeIT5fCq1QFFRJRdsUGUW2SpKxd2w0bGxscO3ZMcZOfnx9ev36dCcGIiIiIKDOcGl4S7jbRivpRz0G8nAVlOjaIxuCTzgbLlStXRtu2bRV1e3v7jE5ERERERJngQGBDVLANVdQ3x9TAZwETVUhE2R0bRGPg3VNZe3oTALB+/XqDdwkODs7AQERERESU0TbOGYk60nFFfdvTQmj9/Z8qJCJig2gc8n6irF3bDQCQJAmXLl1S3Dxw4EDcv39fUSciIiIi47d75RzUD52vqB8Os4fvD/+pkIjoDTaIxsDSDvD5Vl67tkf/bfHixdGrVy/F3QoUKACtVpvR6YiIiIgoHR3atBhlTo2Bo418Loqdt8xQcz4PAJC62CAai6JN5Ms3DwDxMfrFRYsWGbzbiBEjMjIVEREREaWjg5sWo8jhALjZyz+Gf7svGo2WPlUpFVEiNojGwrU0YO+WuBz3GrhzRL9oZmaGs2fPKu42Y8YMHDx4MDMSEhEREdFHCFn9HWr/N1jRHP7wbwyC9kZCMjS7PVEmY4NoLCQJKNJQXru6S7ZYpkwZ9OnTR3HXOnXq4OlT/sWJiIiIyFidWDMZ3penKOoLTsRiwO8RMDM3VyEVkRIbRGNSNEmDeGQecPgHWWnu3LkG75o7d27odLqMSkZEREREH2jf5uWodOl7Rf3HkFh8vvE5LDSWKqQiMowNojHxqgdISV6SXWOBy4nTHNvY2GD37t0G725ubo5Dhw5lXD4iIiIiei/7Ny5Gkf3+Bm/rveE5NJZWmZyIKGVsEI2JjSNQoIqyvq4X8OiCftHHxwfdunUzuInatWvD0dERN2/ezKiURERERJQGe1fPRfF/AuCeU/mRO27UQzaHZJTYIBob7x7KWnwUsLoz8PqJvrR48WK0b9/e4CaeP38OLy8vVKlSBS9evMiopERERESUjI1zx6D86dGKCWk2XYxD3MhQaKxsVEpGlDI2iMam3GdA1S+V9ee3gXU9AG0cAECj0WDdunWYNm1asps6fvw4cuXKBT8/P8THx2dUYiIiIiJ6x69j/dAw9Ac4JbnO4aKTsWix/Ck01nYqJSNKHRtEYyNJQLPJwJdHgIpJjibeOgj8OVxWGjp0KE6fPg1HR8dkN7lq1SpoNBqMGzcuIxITERER0Vt/BZRHN/M/4GAlbw7n/BuDnhteQGNlrVIyorRhg2isXEsBzacDBWvK6yeWAPu+A6ITh46WK1cOT58+xb///pviJoOCgiBJEpYvX54RiYmIiIiytb1fuKNJLuU8EBMPxOCrP15ztlIyCWwQjZmFJdBxOZDLQ17fPwWY7AG8uC8rV6lSBUKIZGc5TdCjRw9IkoRdu3aluB4RERERpU4IgUtf5UQDtwjFbcGnNRizN5rXOSSTwQbR2Nk5A51XAxoDY9VnlQIenlWUfXx8IITAmjVrUtx048aNIUkSQkJC0istERERUbYSHxeHkP45UCK38rbrr6zhvzk880MRfQQ2iKbArQzQ9ifDty2sBVzbY/CmTp06QQiR4kQ2AFCpUiVoNBpcvHjxY5MSERERZRuPQu9iVUcHVMqnPDp4JsoVhac/UiEV0cdhg2gqSrYAag81fNvK9sCpFcnedejQodDpdPjySwOzo74VHx+PUqVKoWTJkrh69erHpiUiIiLK0kIO7sLl0SXQvZzyvMJ/UR6fTLmiQiqij8cG0ZQ0GAOUbqOsCx2wxR/Y9z0ghMG7SpKE+fPnIzo6Gg0aNEj2IS5duoRixYqhcePGuHHjRnolJyIiIsoy1s6fBIe1bVCnoIXitqOO7VA1aL8KqYjSBxtEUyJJQKv5QN7yhm/fPxnYPACIj012E1ZWVtizZw/CwsLg7u6e7Hq7du1C4cKF4efnh9u3b39sciIiIqIsYe6XPmh4ewqK5pYPK73yRIuTNReh2qAlKiUjSh9sEE2NpS3w2WrA0fPNsrmV/Pb/VgGrOgDXdgNH5gPRytm0ACBPnjy4c+cOzp8/n+LDrVq1CoUKFUK1atVw586d9NgDIiIiIpMjhMDhvjnxlesJONnIr3H496145BxyAhUbdVApHVH6+X97dx5fVX3nf/z1yU4WCBCSkAABZBcoS0CtFVAssviTuk1tbad2tNaOTmtrf7WdliK08/vVdpzOTFtbnVadVq3bFKuYVqtWBXEpO7LvW9iSQALZc+93/jg34QZuNpLcm9y8n4/HeZx77/necz8cDgnv+/2e7zHXxJDEaJWfn+9Wr14d6TLar6oMTh+FypPw+1ugsqTptpfcBdPvhP4XNdnkz3/+M/PmzWvVRy9atIhbb72VUaNGYWYtv0FERESkGztx9DB7F41meu75k9E8sb6GW58pIj4pxIzzIl2Uma1xzuWH3KaAGAWKdsFTN8LJfc00Mhh1DVz6FRg20xuueo66ujoeffRR7r777lZ/dHZ2NosWLWLhwoXk5ua2vXYRERGRLuy1P/yO5OV38Ykh519v+Lvdffn8b/eG/H+VSFemgBgkKgMiwJkTXk/i4Vb82TLHwSVfhomfhvhe520uKytj6dKlPPTQQ20uY/DgwSxevJgbbriBvn37tvn9IiIiIl3F9267hq/0W0Vu7/OvytrsH87FS9dFoCqR9lNADBK1ARGgpgJe/ipser717+k3HD77PGSMOG/T4cOHeeGFF7j33nsvuKRhw4axZMkSbrzxRpKTky94PyIiIiLhUlFRwdeuSOcX85NIiG3cO+h3jo+G3sHEL/5bhKoTaT8FxCBRHRDrFe2Ezcvg5H4YNgPefxiOrG/5fZffC7O+A/FJ522qrKzknnvu4bHH2jcz16hRoxoCY3x8fLv2JSIiItLR1q54lSlv/F3Iba/trmPSD9eQmTcmzFWJdCwFxCA9IiCeyzk4+AG8/0vY+jI4X/PtP/YZuPgGGD4L4s6/+euBAwd4/fXXefDBB9mxo303gR03bhxLly7l+uuvJyZGk+qKiIhI5Pzu/k/x+V5/Dbnt19vSuP2pfVjs+dciinQ3CohBemRADHbqICy/17sNRkuS0mHcdV5YHHoFNPED8dixYxQUFPDDH/6QPXv2tKu8SZMmsWTJEq699loFRhEREQmLkuIiDn9vKBOyzp+ltLzGsaL/Z5h73yMRqEykcyggBunxARG8HsW978DTn4a6yta/L/92GH8jDL282WYlJSUsW7aMJUuWcPDgwXaVOm3aNB544AHmzJlDXJy+sRMREZGO9eQjP+VzRx5ocvveeU8z7JIF4StIJAwUEIMoIJ7D74O3fgTv/BgSUqHmTMvv+X4JxJz/DVtTzpw5w9NPP83ixYs5evRoO4qFyy67jEWLFnHVVVeRmJjYrn2JiIhIz1VdXc2t+f34xTUxZKWGHrVUe+9W4tNzwlyZSOdTQAyigNgMvw/2rYTNf4Atf4TKk6HbpefBhJsgZ7K39M717v/jXKvuA1RZWcljjz3G4sWLKS4ublfJM2bM4P7772fmzJmkpOgGtSIiItKy1wv+yJ5f3sKdU8+fawFgrw1l2PfX6/6GErUUEIMoILaSrxb2vA0bn4VNzzXfNjkDElLg1H4YMBY+uRRGfrLVP1QrKyt55JFHWLx4MWVlZe0qe/bs2Xzta19jxowZ9OnTp137EhERkeji8/m47eqL+f74Q4zsH3o0VNH835Ax/aYwVyYSXgqIQRQQ26j0MDx/Gxz68MLe/+V3YODH2vSWM2fO8Ktf/YrFixdTUVFxYZ8bcM011/ClL32JGTNmMGDAgHbtS0RERLqv5c8+zrVbQ9/buc7veKlsHDc8tLLJSflEookCYhAFxAt0ZCN88Ahseh581W17b9Z4uPh6b+k33OtZPLbZmyW1d06LPY0lJSUNPYy1tbXt+EN4Fi5cyB133MGsWbNITU1t9/5ERESk6yopKeHB6wby4NXn3+cZYHuRj5ibfsPIWZ8Oc2UikaOAGEQBsZ3Ki2DnX6BwHRxZD0c3QW0bevkSe8OAMY17JEfOgYGTAtc0ToK0gc2GxsOHDzdcw9hR529GRgbz589n3rx5TJ48meHDhxMfH98h+xYREZHI+N437mLsvt9y68TQv9Nf2N+XGx/ZjCVoHgPpWRQQgyggdjBfHRTt8G6b8df/B9Wl7d9nSqYXFvsNh2EzAhPhDAzZ1DnHzp07efLJJ/nBD37Q/s8OYdCgQcyfP5/58+czdepUcnJydI9GERGRLmztmjX82xcv49/nJpKRHPp39qaJi5lwwzfCXJlI16CAGEQBMQzOnIAVD8Gu16FkNzh/x+175By47meQmhWyl9Hv97N+/Xqee+45HnzwwY773CZcdNFFLFiwgPnz5zNt2jT69evX6Z8pIiIioVVWVnLzFWP4xsVFXDWs6WsJ3X3bsbTsMFYm0rUoIAZRQAyzM8e9W2Zs+SMUroea0x2z36R0yBzrDVcdMAYyx0BqNgwY3Sg4OucoLCxk9erVPPHEE7z44osd8/mtMH78+Iaex+nTp9OrV6+wfbaIiEhP4pzjO3fcwI8Gv9lkm/VHfQy88zmypswPY2UiXZMCYhAFxAhyDkoPwYltcHyrN1FN7hRISPWuZyxc513TWFfV/s+a+W3vesaBk0IOT62oqGDlypUsW7aMgoICDhw40P7PbIP8/PyG8Jifn09sbOiptkVERKR5P/vXf+Ezx3/U5FDSqjrH+vR5XPr1JyFW8wuIgAJiIwqIXZyvDoq2w9s/hi0d1NuXmu2FxZzJsHU5jLoGhs/07tmY2vjWFzU1Nezfv5/169fzpz/9iYKCAo4dO9YxdbTS5Zdfzvz581mwYAETJ07EdJNeERGR8yx/+SVOPf5pPjcx9M3uAVYUxnPJA++QkDMujJWJdH0KiEEUELsRvx9KD8Kxj7whqhufhT5DoKKobTOntiQuCSZ/LjBUdawXHFP6n9esrq6O/fv3895771FQUEBBQQGlpR0wKU8bzJ49mwULFjBv3jxGjx6t8CgiIj3Opk2b+PrCyfz4k0lMGdj0CJx9+YsYuuC+Fm+nJdITKSAGUUCMAn4/lB6A49vgxFZvvfGZjv2MlAGNr2/Mzfd6IZvg8/nYt28fb731FgUFBbzyyitUV7fxfpHtYGYNQ1bnzJnD8OHDNdOqiIhElY0bN/L5OZN58Ook5o5oegKayrh0en1zEyT1DmN1It2LAmIQBcQoVlft3aOx9CAU7/ImxTm6CXwdFNQuvRv6DII+ud669yAvSFaXQa/0Jt/m9/vZvXs3r732WkPPYzj16tWrITzOmjWLvLw8XfMoIiLdxttvv81Dd17NLePjuWV8HDHN9QjeswYyRoSvOJFuSgExiAJiD+Or9SbFKVwPG56B/Ss7/zMHfgymfQnGXgu9+jbb1DnH1q1bG653fPPNpmdf6wzp6enMmTOHmTNnMmPGDMaMGUNcXNPfyoqIiITL888/z7sPfY5/n5vUbLuVp7K47Bu/I3bIJWGqTKT7U0AMooAo+Gq9WVQPr4Htf4Ipf++FyBPbvOGqRTs6rtcxNdsbolo/XLVXXzi8GrLGB3ohc70l7vwL7J1zbNiwgVdeeYWCggJWrVrVMTW1QXJyMjNnzuSKK65g2rRpjBw5kuzsbBITE8Nei4iIRD/nHD//+c957l+/zuKZiVw9vOkvLT84Fs+Eb7xI8shPhLFCkeiggBhEAVFa5KuDk/vg51PD9IEGqZmB4auDIG2gN3FOziRIHwJ9BkNyBgRdU1hXV8ff/va3hiGra9euDVOtoQ0bNoypU6c2LGPHjiUrK4v4eE0nLiIiLauuruYfv3IXx1Y+yX2XJXBlMze533Eqjqxbf0mf/Js1AY3IBVJADKKAKK3mq4Wyw969G0sPe9c2Nnp+CKrDO4spV30P0nIgLdsLkmnZkNgb6iohMQ3w7vH44YcfNkyWs2XLlvDW2Iy8vLyGEJmfn8+ECRPIzMzUNZEiIj3UBx98wM3XfJzFMxO4amgcw/o2P8FazSe+RcJV32n0pamItJ0CYhAFROlQVWVwaj/sXQG7Xofdb3iv9xkCp4+Avzb8NY2cc3b4ap/BZyfVScuhuPQ0H374YcM1j7t37w5/fa0wZMiQhhA5depUJk2aRGZmpm7rISISBWpra7nvvvsoe+dXPPGpXi22P1idRs7sLxM7+3vqMRTpIAqIQRQQJWx8tVCyx7ve8cR275Ycm5c1bpOaDWeOARH6dzhqLkz6LKQNxJ+Syd6iKlasep933nmHt99+mz179kSmrlYaPHhwQ4icOnUqU6ZMYcCAAQqSIiJd0Lp165hz5Sf46VX+Zm9uX2+HL5eRt/8XNvTyzi9OpIdRQAyigCgR56vzQmFKBsQlQl0NnC48O3T1rf8PJ/dGrr7k/t5w1ZP7vOeDL4EZ38KfNpCT/hQOHj/F+vXrWb16NWvWrGHNmjXU1kagp7QNBg8e3OgayalTp5KZmRnpskREol5RURH33HMPW/76PF/OT+BzE+Lpk9T0l3jVdY79vacz6tYfQ+6UMFYq0rMoIAZRQJRuo7YSTh/1lqIdUFUK5cfPvlZW6A1jra0Ib11Jfbx7QPYZBDtf9V5LSINB+TB4Oi5nMmfi+nGgpIbVm3ezZu3ahiBZXd1Bs8N2ktzc3POCZFZWlnokRUTaoLi4mH/6p3+i4A+/5/qx8Xx5ajyXDmr5FkoOw76+2bs0QkQ6lQJiEAVEiSrOQfVpLywe+ygwYU2V1xtZFphYp/Swd2uNSIhNPDuhTkqGN+Q2azzkfRwm3Up5dS179+5lbVCIXLNmDVVVVZGpt5VycnIahcgpU6YwcOBABUkR6bFKSkr46le/yqvLnua5m3o1OwvpudzHbsGu/Q+Ib/5+hyLScRQQgyggSo/knNfrWLgWDv0NDq32luGzvO2nj3jLmeOE9XrIxN6Q3M+7jUdyfy9Ern/K25Y1AbLHQ9Z4arImsruiN6vXb2oUJCsrK8NX6wUaMWIEEyZMYMKECYwbN47Ro0czePBg+vbtS4xm4RORbuzYsWN885vf5H+eeZJrR8Xx2QnxXDsqjriY5r8sK6o0EiZeT+/pn4WRnwxTtSISTAExiAKiSDN8dd4w1n0rYeNzXpjsm+cFufpeSV9N5Orr1Q9619/mI9Az+eGj0HcY5E7BN+QTHDpZycZdhXy4eQ8r12zmw9VrqagI8zDcdkhLS2PMmDGMHj260XrIkCGkpaWpl1JEIsbn8/Hb3/6Wb33rW8RXFfPxwbF8akwcC0fHk5bY8s+mg/EjGPSpRdjo+RDX8iQ1ItJ5FBCDKCCKtIPfD+UnoOwQHN8GO/7s9USeLmzcrv8IKDsCteWRqTNYUjpUnWr0kkvN4kz6WN5jKmu37WPV+u289cEGTp/pAvVegPT0dMaMGdMoUI4ZM4a8vDx69Wp5CnkRkVCcc7z77rvcf//9vLdqFbeMj+Mnn0wit3fbRj/4L/86MVP/HvoN76RKRaStFBCDKCCKhFFVWWBSnSOw5UVY/djZbRYDzh+52kJJ6uP1UgbNIluWN5fC0mr2HjvNlv3HWbNtPweLK6j1QeFpP4fKXKRuUtIuGRkZjcJkcKiMj4+PdHkiEiH79+9nyZIlPP7442SnGrOHxfHvcxPJSG59KDxl6aS7U3Djb2D8jbp3oUgXpIAYRAFRpIvw+72evYpiKC/y1sW7YM0ToW/z0RUDZQhbY0ZzuKSSPUdOsu3ACYorHcUVjuR4OFHh2Fbk5+iZ7vlzNysri7Fjx4Yc/hobGxvp8kSkjaqrq3nhhRd4+OGHWbVqFb0TYdbQOGYPi2X2sDguzmz9v+vTpJJ8yeeJ/dinYeAkhUKRLk4BMYgCokg35avzhreePhLolSyEox/BmsfPthlzbVDgLILKk5GrtwU1KTmUuyRKqowjZXUcKDpDTkwJg1J9bCvysa3Iz/ZiP9uK/Ow56ae4wlHti3TVbZebm9sQJkePHs2IESO46KKLyMvLIylJMxaKhIvP5+PVV1/l4Ycf5pVXXgFgYKpx07h4/nPehf9bdJfejY2e581OHaMvikS6CwXEIAqIIj1Ifahc87h3L8mind7iC9yPMXcqVJRAZYl3n8kuzh+bRFVMMmV1cRRXOIbEFZMW76fwtJ+H3qth/VEfpVWOU1WOU1VQWu2o6/qdriElJSUxdOhQ8vLyyMvLa3hcv87IyCAxMTHSZYp0SXV1dbz++us8+eSTPPWUNzN0rziYMjCWSwbFcmmutx7S5wJnUu47DBb8K4y4ugOrFpFwUkAMooAoIiH56rwhr+VFcGSDFyhrK7z7NlYEhsCWF3uPy4sid2/JDvL85lrWHPE1DIGtXwPExsCxM46TVY6abthrWS9UsKxfcnNzNYGPdGvOObZt28bLL7/M8uXLWbFiRcO25Hi4aVw8d09LYHruhffq+Z1RlzWBhNGfhOyJXiBMTO2I8kUkwhQQgyggikiHcc4bxlq0E4p3er2QqVlneyWD17vfiHS1F6TGH0NZjVFcXsfJSh+nqqBfL2v4T+f+U372l/o5UOqnYGcdHx33U1rtKK1ynK4Bfzf+FZOZmRkyZNav09LSIl2iRDnnHEePHuXVV19l+fLlLF++nOrq6kZtBiQbo/rHMHlgDPkDY5maE8v4Nlw7GNL0L8PwmZB3OfRKb9++RKRLUkAMooAoIhHl90N1aaA3MqhHsqIY3v+ldx/Kc6VkekHTXxf+etvpdLU77/5oL2ypDQyDPbtU1MInhsRyoNQ1BM79p/wUnnZUdr8/NgDx8fHk5uY2WrKzs8nMzGxYsrKySE9PJzk5WRP99DBlZWVs2LCBdevWNSwbNmwI2bZPIozJiGVMRgxPfOpsz3dZtaN3K+4/2BS/xWG5kzG/D1Iz4Yr7YNA0TTAj0gMoIAZRQBSRbsk5qC4L6pU8CSt/CvvfBRyMng/Vp71hslWlgaXM29bN1fi8Hsmyau+6yrJqh9/BVcPiAFh3xMd/fFDTKHCernGU10CfJONEuZ/S6u7dmxksLi6OrKyshoB5buAMfjxgwAASEnRD8nCorq7m6NGjHD58mJ07d7Jjxw42btzIunXrOHz4cLPvTY6H/JxYZuTFMjMvjuxUY8UBH2P6xzB2QAzZqRd4rWAoE26G3HwvCGaPhzhdyyvSEykgBlFAFJEew+/3wmTJXji5z7t9SP3jkVcHwubJxkNhi3dGuuqweO9gXaPAWT8s9p7pCZRUOnaV+HlhSx3ltY4zNVBe4zhT4yiv9QLrqSrv9e46CVBzkpOT6du3L2lpaaSkpJCcnNywBD9vbltTbRMTE4mJ6cCw0wLnHD6fj9raWmpqahrW9cvp06cpLS3l5MmTHDlyhCNHjlBYWNhoXVRUdMGfn5oAE7O8nr/j5Y6sFCMr1chMMbJSYshKMa4MfNHRaWITYfqXIP8foP9FnftZItJtKCAGUUAUEWmBc1BXDTFx3oyv9b2R9T2Te9+GTc/DmWON35eWA0m9vbbVZVBzJjL1R8iaQh8Vtd5w2YZ1neNLU7wevKo6x3ffrKa0yjUKnuW10L+XERsDx8sdJ8r9lFR6r0djAO3OslONvD4xXNTPGNkvllH9Y0iIhRUHfPRJhIFpMeSkGrm9Y8hJM3LSwhCG41Og33DIGAk5kyBnsje5Vq++GioqIk1SQAyigCgiEiZ+nzfs9fQROLEdSg9Ccn9vSFtw4KwqhQPvwfEtka64SyqtcucFz0sGnb1e8Y09dWwr9lPr82ad9RbHsPQYJmTFUlbtKK/xruWsrHX8cXsdRRXeLVDq/PVrSE8y+icbFbWOQ2WOk5WuYV/1+3WA0XUGLoeqJcYgJR5GZ8TQr5fRJ9Hok+Stz9R4vcO9A6/1TjR6J0LvROP/fvzsUMu39tWREm+kJEBqgpESDykJRlJchAJXTLzX+5cxyvvyxflh1DwYMx/S8xQERaTNFBCDKCCKiHQj9b2Z1WWBayxLvfWxj2Ddk1B6CNKHQNbFQT2dp7zey1MHIl19j3K83N8QNuvD56j+jSfe+ei4D8MLcWbeekByDH17hQ44B0r9xMUQWIz4GM6b9Ki8xjXsK8YgITZKwtKl/whDr4ABo70QGNvJQ1FFpEdRQAyigCgi0sP4fV5gPHPC6810fq8XMzhwVpdB2RH44Jdn3/exz3jvq6mAmnKoLffWJXsi92eR7qv3IBh2BaQM8JbUTG+dlA598yAlI9IVikgP0lxA1NdRIiIS3WJiIamPt2SMaL7tvB+1bp9+H9RWeJP8lBd5j+OTobYysFScXb//sNfTWVcN0+44GzSDg2fhuvb/OSVypt7mDZ9OGQBp2d71uGnZ3qJZQkWkm1FAFBERaauYWEhM85b0Ic23zf9i2/fvq4W6Km8GyuCwWf9491+haIfXAzpyjjde01cLvpqz603PeTPWnit7AiSkeffVbFh8cHxz43ap2Y3356s+f19dkgXCennozcNmQGLvs39/9cu+ld61fmlZcPH13jFKSPb2lZDireN76Xo/EYl6GmIqIiIiLXPOC5K+aq83NDi49urn9ZSdGzorT0HRdm9Yb9pA6J0DFgOYtzbz9ntkA8TGQ2xCYB3vDb1M7u/NphsT54Xy+nVNudfGYgP7CezLYrx9KMSJiDRLQ0xFRESkfcy8iVJi47weNfq17n2Dp7XcZsCottWSkNK29iIi0mrhu1utiIiIiIiIdGkKiCIiIiIiIgIoIIqIiIiIiEhAlwyIZnazmW02M7+Zhbx4MtBurpltN7NdZvbtcNYoIiIiIiISbbpkQAQ+Am4A3mmqgZnFAr8A5gHjgM+Y2bjwaogCBwAACfBJREFUlCciIiIiIhJ9uuQsps65rQDW/DTV04Fdzrk9gbbPAAuBLZ1eoIiIiIiISBTqqj2IrZELHAx6fijwmoiIiIiIiFyAiPUgmtnrQHaITd91zv2xNbsI8Zpr4rPuBO4EGDJkSKtrFBERERER6UkiFhCdc1e3cxeHgMFBzwcBhU181qPAowD5+fkhQ6SIiIiIiEhP152HmP4NGGlmw8wsAbgFeCnCNYmIiIiIiHRbXTIgmtn1ZnYIuAx4xcxeDbyeY2YFAM65OuAe4FVgK/Ccc25zpGoWERERERHp7rrqLKbLgGUhXi8E5gc9LwAKwliaiIiIiIhI1OqSPYgiIiIiIiISfgqIIiIiIiIiAiggioiIiIiISIA517Pu+mBmJ4D9EfjoDKAoAp8rOvaRpGMfOTr2kaXjHzk69pGjYx85OvaR1R2Pf55zbkCoDT0uIEaKma12zuVHuo6eSMc+cnTsI0fHPrJ0/CNHxz5ydOwjR8c+sqLt+GuIqYiIiIiIiAAKiCIiIiIiIhKggBg+j0a6gB5Mxz5ydOwjR8c+snT8I0fHPnJ07CNHxz6your46xpEERERERERAdSDKCIiIiIiIgEKiJ3EzH5iZtvMbKOZLTOz9CbazTWz7Wa2y8y+He46o5GZ3Wxmm83Mb2ZNzihlZvvMbJOZrTez1eGsMVq14djrvO9gZtbPzP5iZjsD675NtPMFzvn1ZvZSuOuMJi2dx2aWaGbPBrZ/YGZDw19l9GrF8b/NzE4Ene93RKLOaGNmj5nZcTP7qIntZmb/Gfh72WhmU8JdYzRrxfGfZWalQef998NdY7Qys8Fm9lcz2xr4v87XQrSJivNfAbHz/AUY75ybCOwAvnNuAzOLBX4BzAPGAZ8xs3FhrTI6fQTcALzTirZXOucmRdPUxBHW4rHXed9pvg284ZwbCbwReB5KZeCcn+Scuy585UWXVp7HtwMnnXMjgJ8CD4a3yujVhp8jzwad778Oa5HR6wlgbjPb5wEjA8udwC/DUFNP8gTNH3+AFUHn/dIw1NRT1AH3OefGApcCd4f4uRMV578CYidxzr3mnKsLPH0fGBSi2XRgl3Nuj3OuBngGWBiuGqOVc26rc257pOvoiVp57HXed46FwH8HHv838KkI1tITtOY8Dv47eQGYbWYWxhqjmX6ORIhz7h2gpJkmC4HfOs/7QLqZDQxPddGvFcdfOolz7ohzbm3g8WlgK5B7TrOoOP8VEMPjH4A/hXg9FzgY9PwQ559o0nkc8JqZrTGzOyNdTA+i875zZDnnjoD3SwzIbKJdkpmtNrP3zUwh8sK15jxuaBP4wrAU6B+W6qJfa3+O3BgY5vWCmQ0OT2k9nn7GR95lZrbBzP5kZhdHuphoFLhkYDLwwTmbouL8j4t0Ad2Zmb0OZIfY9F3n3B8Dbb6L1yX9VKhdhHhN08q2QmuOfStc7pwrNLNM4C9mti3wzZw0owOOvc77C9TcsW/DboYEzvvhwJtmtsk5t7tjKuxRWnMe61zvPK05ti8Dv3fOVZvZXXi9uVd1emWi8z6y1gJ5zrkzZjYfeBFvuKN0EDNLBf4HuNc5V3bu5hBv6XbnvwJiOzjnrm5uu5l9AbgWmO1C30/kEBD8jeYgoLDjKoxeLR37Vu6jMLA+bmbL8IYsKSC2oAOOvc77C9TcsTezY2Y20Dl3JDCc5XgT+6g/7/eY2Vt434AqILZda87j+jaHzCwO6IOGhnWUFo+/c6446Ol/oWtAw0U/4yMoOLA45wrM7GEzy3DOFUWyrmhhZvF44fAp59wfQjSJivNfQ0w7iZnNBe4HrnPOVTTR7G/ASDMbZmYJwC2AZhUMAzNLMbO0+sfAHLwJVqTz6bzvHC8BXwg8/gJwXm+umfU1s8TA4wzgcmBL2CqMLq05j4P/Tm4C3mziy0JpuxaP/znX/VyHd72QdL6XgL8PzOZ4KVBaP/xdOp+ZZddf62xm0/H+r1/c/LukNQLH9TfAVufcvzXRLCrOf/Ugdp6fA4l4QxcB3nfO3WVmOcCvnXPznXN1ZnYP8CoQCzzmnNscuZKjg5ldD/wMGAC8YmbrnXPXBB97IAtYFvi7iQOeds79OWJFR4nWHHud953mR8BzZnY7cAC4GcC8243c5Zy7AxgLPGJmfrz/NPzIOaeAeAGaOo/NbCmw2jn3Et5/JH5nZrvweg5viVzF0aWVx/+rZnYd3mUeJcBtESs4ipjZ74FZQIaZHQIWA/EAzrlfAQXAfGAXUAF8MTKVRqdWHP+bgK+YWR1QCdyiL6Y6zOXA54FNZrY+8No/A0Mgus5/0zkjIiIiIiIioCGmIiIiIiIiEqCAKCIiIiIiIoACooiIiIiIiAQoIIqIiIiIiAiggCgiIiIiIiIBCogiIiIiIiICKCCKiIiIiIhIgAKiiIhIO5nZW2b2cjPb3zSznWYWZ54NZvaFc9qMMrMHzCwh8PwXZvabzq5dREQkmAKiiIhI+20FxoTaYGZXAlcCi5xzdcDfAX2Bp89pOg/4R+dcTeD5T4BbzWxE55QsIiJyPgVEERGR9tsKDKvv/TvHD4ANwLOB518Ffuecqz2n3UTgo/onzrl9wErgKx1erYiISBMUEEVERNpvKxALNOrtM7O5wOXAPzvnXKA38OPAC+e0OwH8A3ClmbnAchXwP3i9iPp9LSIiYaFfOCIiIu23NbAefc7rS4F3nXMFgeezgXK8HkUAzMyA/wNUAf8CXBZYVgWWLGBCp1UuIiISJC7SBYiIiHR3zrlDZnaaoOsQzWwhMA2YEdR0KrDVOecPeq8zs6NAErDcOfd+0D42Az5gOkGhUkREpLOoB1FERKRjbCPQgxjoFVwCFDjnVgS1yQaKQrx3IuAIugYRIDCpzanA+0RERDqdehBFREQ6RvBMpjfjhb7bzmmTBFSEeO9EYI9z7kyIbdWB94mIiHQ69SCKiIh0jK3AaDOLBR4AnnXOrT+nTQmQHuK9E2l6CGl64H0iIiKdTgFRRESkY2zFC3PfAEYC3w/RZjswLMTrY/CGqDZiZgOAZGBHx5UpIiLSNAVEERGRjlE/k+lS4DHn3M4Qbd4FhgSCX7AyYIaZzTCzSwPXMALk412buKpTKhYRETmHAqKIiEjH2A3UBB4vbaLNW3jDReee8/q3gX7AG8CLzjkXeH0u8LZzrrhjSxUREQnNzv4OEhERkc5mZv8BjHDOLWihXSywH/i2c+7JsBQnIiI9nnoQRUREwusnwCwzG9VCu5uBSuCZzi9JRETEo4AoIiISRs65Q8DtwMAWmhpwe+BeiCIiImGhIaYiIiIiIiICqAdRREREREREAhQQRUREREREBFBAFBERERERkQAFRBEREREREQEUEEVERERERCRAAVFEREREREQABUQREREREREJ+F8Akyw5GiHZCAAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1207,7 +1172,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.6.9" } }, "nbformat": 4, From 58a83520717678f11f690524e68cfc949f21020e Mon Sep 17 00:00:00 2001 From: aloctavodia Date: Tue, 30 Jul 2019 19:59:43 -0300 Subject: [PATCH 04/45] use service xvfb --- .travis.yml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index f544cdd9458..806831ccf4f 100644 --- a/.travis.yml +++ b/.travis.yml @@ -12,10 +12,11 @@ addons: before_install: - . ./scripts/install_miniconda.sh - - sh -e /etc/init.d/xvfb start - - export DISPLAY=":99.0" - export MKL_THREADING_LAYER=GNU +services: + - xvfb + install: - . ./scripts/create_testenv.sh - pip install coveralls From 21cf56ca706576d98a92183a60bdc6939349454d Mon Sep 17 00:00:00 2001 From: lucianopaz Date: Wed, 31 Jul 2019 11:40:21 +0200 Subject: [PATCH 05/45] Fixed float32 precision errors --- pymc3/tests/test_distributions_timeseries.py | 4 +++- pymc3/tests/test_minibatches.py | 9 ++++++++- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/pymc3/tests/test_distributions_timeseries.py b/pymc3/tests/test_distributions_timeseries.py index d9529efd1b2..26218ff8892 100644 --- a/pymc3/tests/test_distributions_timeseries.py +++ b/pymc3/tests/test_distributions_timeseries.py @@ -6,6 +6,7 @@ import numpy as np import pytest +from .helpers import select_by_precision pytestmark = pytest.mark.usefixtures('seeded_test') @@ -92,7 +93,8 @@ def test_GARCH11(): z = Normal('z', mu=0, sigma=vol, shape=data.shape) garch_like = t['y'].logp({'z':data, 'y': data}) reg_like = t['z'].logp({'z':data, 'y': data}) - np.testing.assert_allclose(garch_like, reg_like) + decimal = select_by_precision(float64=7, float32=4) + np.testing.assert_allclose(garch_like, reg_like, 10**(-decimal)) diff --git a/pymc3/tests/test_minibatches.py b/pymc3/tests/test_minibatches.py index 7863a2c2fb9..f6c9d64c0ff 100644 --- a/pymc3/tests/test_minibatches.py +++ b/pymc3/tests/test_minibatches.py @@ -232,7 +232,14 @@ def test_multidim_scaling(self): with pm.Model() as model5: Normal('n', observed=[[1]], total_size=[2, Ellipsis, 2]) p5 = theano.function([], model5.logpt) - assert p0() == p1() == p2() == p3() == p4() == p5() + _p0 = p0() + assert ( + np.allclose(_p0, p1()) and + np.allclose(_p0, p2()) and + np.allclose(_p0, p3()) and + np.allclose(_p0, p4()) and + np.allclose(_p0, p5()) + ) def test_common_errors(self): with pm.Model(): From 463bd7a0f0412b43bbad203ae57b831fda8bc8b8 Mon Sep 17 00:00:00 2001 From: Osvaldo Martin Date: Wed, 31 Jul 2019 18:27:11 -0300 Subject: [PATCH 06/45] SMC stabilize covariance matrix (#3573) * stabilize covariance * add release note * fix test --- RELEASE-NOTES.md | 1 + pymc3/step_methods/smc_utils.py | 4 +- pymc3/tests/test_step.py | 402 ++++++++++++++++---------------- 3 files changed, 205 insertions(+), 202 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 77648092fb4..68124f88bd9 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -13,6 +13,7 @@ ### Maintenance - Moved math operations out of `Rice`, `TruncatedNormal`, `Triangular` and `ZeroInflatedNegativeBinomial` `random` methods. Math operations on values returned by `draw_values` might not broadcast well, and all the `size` aware broadcasting is left to `generate_samples`. Fixes [#3481](https://github.com/pymc-devs/pymc3/issues/3481) and [#3508](https://github.com/pymc-devs/pymc3/issues/3508) - Parallelization of population steppers (`DEMetropolis`) is now set via the `cores` argument. ([#3559](https://github.com/pymc-devs/pymc3/pull/3559)) +- SMC: stabilize covariance matrix [3573](https://github.com/pymc-devs/pymc3/pull/3573) ## PyMC3 3.7 (May 29 2019) diff --git a/pymc3/step_methods/smc_utils.py b/pymc3/step_methods/smc_utils.py index 08bad0463b9..9e5bea1c7bc 100644 --- a/pymc3/step_methods/smc_utils.py +++ b/pymc3/step_methods/smc_utils.py @@ -44,9 +44,11 @@ def _calc_covariance(posterior, weights): Calculate trace covariance matrix based on importance weights. """ cov = np.cov(posterior, aweights=weights.ravel(), bias=False, rowvar=0) + cov = np.atleast_2d(cov) + cov += 1e-6 * np.eye(cov.shape[0]) if np.isnan(cov).any() or np.isinf(cov).any(): raise ValueError('Sample covariances not valid! Likely "draws" is too small!') - return np.atleast_2d(cov) + return cov def _tune(acc_rate, proposed, step): diff --git a/pymc3/tests/test_step.py b/pymc3/tests/test_step.py index d67c0ef1d2b..e96a4c0de8d 100644 --- a/pymc3/tests/test_step.py +++ b/pymc3/tests/test_step.py @@ -247,7 +247,7 @@ class TestStepMethods: # yield test doesn't work subclassing object 0.81375848, 0.81375848, 0.81375848, - 1.91238675 + 1.91238675, ] ), Metropolis: np.array( @@ -460,206 +460,206 @@ class TestStepMethods: # yield test doesn't work subclassing object ), SMC: np.array( [ - 0.85565708, - -0.20703928, - 0.60432641, - 0.82409514, - 0.66956453, - 1.8112792, - 0.50997512, - 0.01190834, - 0.11877327, - 1.04616417, - 0.35542005, - 0.97711504, - 1.08273637, - 0.12254235, - -0.2125738, - 1.90683646, - 0.76584362, - 1.61601695, - 1.26496703, - 0.72605833, - 0.27710235, - 0.59466026, - 1.48847988, - 1.48383337, - 0.85487674, - 0.40339276, - 1.11378016, - -0.01154067, - -0.24933179, - 0.04855045, - 0.44408864, - 1.07009531, - 0.71832419, - -0.02224457, - 0.15732459, - 0.74732395, - -0.55976656, - 1.83476589, - 1.13464886, - 1.04477015, - -0.8829041, - 0.68610315, - -0.51600577, - 1.06577114, - 0.72533608, - 0.26181788, - 0.37045769, - 0.49110905, - 0.95187097, - 0.57052924, - 1.18390833, - -0.28470992, - 0.5143004, - 0.36340091, - 0.26524336, - 0.91352757, - -0.16906895, - 0.02671801, - -0.62018961, - 0.13845522, - 0.69578158, - 0.82213017, - 0.95565383, - 0.57201004, - 0.66751355, - 0.74662892, - -0.18802906, - -0.16424007, - 0.67661192, - 0.986151, - 1.11037246, - 0.53367584, - 0.81646283, - 0.69093199, - 1.30967566, - 0.58455688, - -0.10754191, - -0.66843656, - 0.61473792, - 0.11205418, - 1.50795552, - 1.61304845, - 0.97329021, - 0.80782701, - 1.83144593, - 0.34256428, - 0.49090154, - 1.85297793, - 0.44832949, - 1.35766813, - 0.48916332, - 0.410038, - -0.69870943, - 0.06616812, - -0.17685433, - -0.0487383, - 1.92862324, - 0.47539572, - 1.19401681, - 0.3670901, - 2.11504383, - 1.16863035, - 0.74908135, - 0.90147245, - 0.6291441, - 0.96889664, - 0.93871964, - 0.74575969, - 0.06810336, - 0.45469347, - 0.29787682, - 0.73557892, - -0.3388827, - -0.0991328, - 1.12325585, - 0.87397644, - -1.14737408, - -0.78658091, - 0.67716022, - 0.20961362, - 0.11759984, - 0.72748548, - -0.29959649, - -0.09436443, - 0.42100225, - 0.04656646, - 1.21211555, - 0.04060845, - 1.38031545, - 0.58429818, - 0.33843531, - 0.82207289, - 0.96509587, - 1.00370899, - 1.23734919, - -0.01960951, - 0.7721088, - 0.04627471, - -0.62058523, - 0.21093904, - -0.15935501, - 0.83237845, - 0.10157936, - -0.45885173, - 1.26206955, - 1.07601436, - 1.23736132, - 0.28618097, - -0.14328022, - -0.13158901, - 0.74308368, - 0.26291343, - 0.17504558, - 0.55601578, - 1.46900503, - 0.65131007, - 0.89596352, - 0.32536798, - -0.25504495, - 0.07563569, - 1.48775514, - 0.28519783, - 0.58513482, - -0.63672688, - 1.59324146, - 0.53826815, - 0.41792749, - 0.76583018, - 0.87290581, - 0.89110704, - 0.27282461, - -0.20300455, - 1.01058543, - 0.68072852, - -0.21073928, - 1.19114065, - 0.6372328, - 0.33444015, - 1.05599084, - 0.78372828, - 1.0127235, - -0.19460124, - 1.31807913, - 0.58658129, - -0.34218648, - 0.68725616, - 0.37484537, - 2.48875271, - -0.06424102, - 0.22162396, - -0.21623175, - 0.25998439, - 0.37801803, - -0.51312636, - -0.35024508, - 1.90460979, - 0.02214471, - -0.59132265, - 0.42870423, - 0.88951751, + 0.85565848, + -0.2070422, + 0.60432617, + 0.82409693, + 0.66956559, + 1.81128223, + 0.5099755, + 0.0119065, + 0.11877237, + 1.04616407, + 0.35541975, + 0.97711646, + 1.08273746, + 0.12254112, + -0.21257513, + 1.90683915, + 0.76584417, + 1.61601906, + 1.26496997, + 0.72605814, + 0.27710155, + 0.59465936, + 1.48848202, + 1.48383457, + 0.85487729, + 0.40339297, + 1.11378062, + -0.01154052, + -0.24933346, + 0.04855092, + 0.44408811, + 1.07009768, + 0.71832534, + -0.02224531, + 0.15732427, + 0.7473228, + -0.55976844, + 1.83476852, + 1.13464918, + 1.04477006, + -0.8829072, + 0.68610441, + -0.51600679, + 1.06577287, + 0.72533541, + 0.26181682, + 0.37045784, + 0.49110896, + 0.95187099, + 0.57052884, + 1.18390954, + -0.28471075, + 0.51430074, + 0.36340121, + 0.26524266, + 0.91352896, + -0.16906962, + 0.02671763, + -0.62019011, + 0.13845477, + 0.69578153, + 0.82213032, + 0.95565471, + 0.57200968, + 0.66751333, + 0.74663059, + -0.18802928, + -0.16424154, + 0.67661238, + 0.9861513, + 1.11037445, + 0.53367436, + 0.81646116, + 0.690932, + 1.30967756, + 0.58455721, + -0.10754287, + -0.6684397, + 0.61473599, + 0.11205459, + 1.50795626, + 1.61304945, + 0.97329075, + 0.80782601, + 1.83144756, + 0.34256431, + 0.4909023, + 1.85297991, + 0.44832968, + 1.35766865, + 0.48916414, + 0.41003811, + -0.69870992, + 0.06616797, + -0.17685457, + -0.04873934, + 1.92862499, + 0.47539711, + 1.19401841, + 0.36708951, + 2.11504567, + 1.1686311, + 0.74908099, + 0.90147251, + 0.6291452, + 0.96889866, + 0.93871978, + 0.74575847, + 0.06810142, + 0.45469276, + 0.2978768, + 0.73557954, + -0.33888277, + -0.09913398, + 1.12325616, + 0.87397745, + -1.14737571, + -0.78658184, + 0.67716005, + 0.20961373, + 0.11759896, + 0.72748602, + -0.29959812, + -0.09436507, + 0.42100139, + 0.0465658, + 1.21211627, + 0.0406079, + 1.38031654, + 0.58429982, + 0.33843332, + 0.82207419, + 0.9650973, + 1.00370894, + 1.23735049, + -0.01960991, + 0.77210838, + 0.04627416, + -0.62058637, + 0.21093913, + -0.15935478, + 0.83237714, + 0.10157911, + -0.45885337, + 1.26207038, + 1.07601429, + 1.23736173, + 0.28618205, + -0.143281, + -0.13159008, + 0.74308471, + 0.26291269, + 0.17504574, + 0.55601508, + 1.46900656, + 0.65130981, + 0.89596543, + 0.32536767, + -0.25504632, + 0.07563599, + 1.48775644, + 0.28519708, + 0.58513646, + -0.63673033, + 1.5932429, + 0.53826754, + 0.41792748, + 0.7658319, + 0.87290603, + 0.89110888, + 0.27282434, + -0.20300504, + 1.01058742, + 0.68072965, + -0.21073937, + 1.19114243, + 0.63723316, + 0.3344412, + 1.05599174, + 0.78372725, + 1.01272241, + -0.19460072, + 1.3180811, + 0.58658171, + -0.34218688, + 0.68725498, + 0.37484577, + 2.48875469, + -0.06424035, + 0.22162324, + -0.21623218, + 0.25998442, + 0.37801781, + -0.51312723, + -0.35024653, + 1.90461235, + 0.02214488, + -0.59132457, + 0.42870476, + 0.88951825, ] ), } From 76851e240ac048b82543a7f4df23d4492eaf8a44 Mon Sep 17 00:00:00 2001 From: rpgoldman Date: Thu, 1 Aug 2019 08:24:43 -0500 Subject: [PATCH 07/45] WIP: Documentation cleanup (#3575) * Fix typos in docstrings. Fix some minor wording errors, but mostly fixed formatting issues. * Update sphinx configuration. Updated to make a deprecation warning go away. This should not change the behavior at all. * Update MultiTrace docs. Minor typo fixes and added MultiTrace attributes section. * Fix RST issues in documentation. * Remove obsolete file. The `getting_started.rst` file does not yield output that is linked into the docs. Instead, the index.rst file directly links to the pages once linked from getting_started. --- docs/source/Gaussian_Processes.rst | 8 +++++--- docs/source/api.rst | 6 +++--- docs/source/api/backends.rst | 7 ------- docs/source/api/bounds.rst | 4 ++-- docs/source/api/gp.rst | 4 ++-- docs/source/api/inference.rst | 13 ++++++++---- docs/source/api/model_graph.rst | 2 +- docs/source/conf.py | 3 ++- docs/source/developer_guide.rst | 6 ++++-- docs/source/getting_started.rst | 13 ------------ pymc3/backends/base.py | 25 +++++++++++++++++----- pymc3/data.py | 4 ++-- pymc3/distributions/continuous.py | 16 +++++++-------- pymc3/distributions/discrete.py | 5 +++-- pymc3/distributions/timeseries.py | 2 +- pymc3/math.py | 8 ++++---- pymc3/sampling.py | 33 ++++++++++++++---------------- pymc3/step_methods/smc.py | 28 +++++++++++++------------ 18 files changed, 96 insertions(+), 91 deletions(-) delete mode 100644 docs/source/getting_started.rst diff --git a/docs/source/Gaussian_Processes.rst b/docs/source/Gaussian_Processes.rst index 3ff8d8c2448..aabcd1fe929 100644 --- a/docs/source/Gaussian_Processes.rst +++ b/docs/source/Gaussian_Processes.rst @@ -88,7 +88,7 @@ all columns of the matrix of inputs. Covariance functions in PyMC3 closely follow the algebraic rules for kernels, which allows users to combine covariance functions into new ones, for example: -- The sum two covariance functions is also a covariance function:: +- The sum of two covariance functions is also a covariance function:: cov_func = pm.gp.cov.ExpQuad(...) + pm.gp.cov.ExpQuad(...) @@ -98,12 +98,14 @@ which allows users to combine covariance functions into new ones, for example: cov_func = pm.gp.cov.ExpQuad(...) * pm.gp.cov.Periodic(...) -- The product (or sum) of a covariance function with a scalar is a covariance -function:: +- The product (or sum) of a covariance function with a scalar is a + covariance function:: cov_func = eta**2 * pm.gp.cov.Matern32(...) + + After the covariance function is defined, it is now a function that is evaluated by calling :code:`cov_func(x, x)` (or :code:`mean_func(x)`). Since PyMC3 is built on top of Theano, it is relatively easy to define and experiment diff --git a/docs/source/api.rst b/docs/source/api.rst index ff5d9dab12a..1166fbb839b 100644 --- a/docs/source/api.rst +++ b/docs/source/api.rst @@ -1,8 +1,8 @@ .. _api: -************* +*************** API Reference -************* +*************** .. toctree:: :maxdepth: 2 @@ -24,7 +24,7 @@ API Reference Indices and tables -=========== +=================== * :ref:`genindex` * :ref:`modindex` diff --git a/docs/source/api/backends.rst b/docs/source/api/backends.rst index 3772f2a77de..6bd876b01d5 100644 --- a/docs/source/api/backends.rst +++ b/docs/source/api/backends.rst @@ -7,13 +7,6 @@ Backends .. automodule:: pymc3.backends :members: -basic Backends (including MultiTrace) -^^^^^^^^ - -.. automodule:: pymc3.backends.base - :members: - - ndarray ^^^^^^^ diff --git a/docs/source/api/bounds.rst b/docs/source/api/bounds.rst index 0df043a0c97..ad90d33cbbd 100644 --- a/docs/source/api/bounds.rst +++ b/docs/source/api/bounds.rst @@ -72,8 +72,8 @@ Caveats an unnormalized probability distribution. This doesn't effect inference algorithms but may complicate some model comparison procedures. -API -### +Bounded Variable API +#################### .. currentmodule:: pymc3.distributions.bound diff --git a/docs/source/api/gp.rst b/docs/source/api/gp.rst index 53351ab9053..e5236d6c357 100644 --- a/docs/source/api/gp.rst +++ b/docs/source/api/gp.rst @@ -1,5 +1,5 @@ -Gaussian Processes ------------------- +Gaussian Processes API +---------------------- .. currentmodule:: pymc3.gp.gp diff --git a/docs/source/api/inference.rst b/docs/source/api/inference.rst index 18c2e086d69..3805fc57cf9 100644 --- a/docs/source/api/inference.rst +++ b/docs/source/api/inference.rst @@ -14,6 +14,11 @@ Sampling Step-methods ^^^^^^^^^^^^ +.. currentmodule:: pymc3.sampling + +.. autofunction:: pymc3.sampling.assign_step_methods + + NUTS ~~~~ @@ -56,7 +61,7 @@ Sequential Monte Carlo MultiTrace -^^^^^^^^ +^^^^^^^^^^ .. currentmodule:: pymc3.backends.base .. autoclass:: pymc3.backends.base.MultiTrace @@ -65,7 +70,7 @@ MultiTrace .. autoclass:: pymc3.backends.base.BaseTrace Variational Inference ----------------- +--------------------- OPVI ^^^^ @@ -75,8 +80,8 @@ OPVI .. automodule:: pymc3.variational.opvi :members: -Inference -^^^^^^^^^ +VI Inference API +^^^^^^^^^^^^^^^^ .. currentmodule:: pymc3.variational.inference diff --git a/docs/source/api/model_graph.rst b/docs/source/api/model_graph.rst index 34466b9d321..dae59b898b1 100644 --- a/docs/source/api/model_graph.rst +++ b/docs/source/api/model_graph.rst @@ -1,5 +1,5 @@ Graphing Models -------------- +--------------- .. currentmodule:: pymc3.model_graph .. automodule:: pymc3.model_graph diff --git a/docs/source/conf.py b/docs/source/conf.py index 80e34f39b6c..ac43d39ff11 100755 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -41,7 +41,9 @@ "numpydoc", "IPython.sphinxext.ipython_console_highlighting", "sphinx.ext.autosectionlabel", + "sphinx.ext.napoleon", "gallery_generator", + "recommonmark", ] # Don't auto-generate summary for class members. @@ -59,7 +61,6 @@ # The suffix(es) of source filenames. # You can specify multiple suffix as a list of string: # source_suffix = ['.rst', '.md'] -source_parsers = {".md": "recommonmark.parser.CommonMarkParser"} source_suffix = [".rst", ".md"] # The encoding of source files. diff --git a/docs/source/developer_guide.rst b/docs/source/developer_guide.rst index 027b3026048..ba9c406d554 100644 --- a/docs/source/developer_guide.rst +++ b/docs/source/developer_guide.rst @@ -136,6 +136,8 @@ straightforward. In a perfect world, we should have follows a Gaussian distribution, and :math:`\chi = \text{Normal}(0, 1), x \sim \chi` which define a scalar density function that takes input :math:`x` + +.. math:: (``X:=f(x) = 1/sqrt(2*pi) * exp(-.5*x**2)``) Within a model context, RVs are essentially Theano tensors (more on that @@ -827,8 +829,8 @@ the input to the Theano function being a 1d vector (instead of a list of RV that each can have very different shape), thus it is very easy to do matrix operation like rotation etc. -Reflection -~~~~~~~~~~ +Notes +~~~~~ | The current setup is quite powerful, as the Theano compiled function is fairly fast to compile and to call. Also, when we are repeatedly diff --git a/docs/source/getting_started.rst b/docs/source/getting_started.rst deleted file mode 100644 index d67a4d0343d..00000000000 --- a/docs/source/getting_started.rst +++ /dev/null @@ -1,13 +0,0 @@ -.. _getting_started: - -*************** -Getting started -*************** - -.. toctree:: - notebooks/getting_started.ipynb - notebooks/api_quickstart.ipynb - notebooks/variational_api_quickstart.ipynb - gp.rst - theano.rst - advanced_theano.rst diff --git a/pymc3/backends/base.py b/pymc3/backends/base.py index 75f7afc51ad..64cabeaecb3 100644 --- a/pymc3/backends/base.py +++ b/pymc3/backends/base.py @@ -219,7 +219,7 @@ def stat_names(self): class MultiTrace: - """Main interface for accessing values from MCMC results + """Main interface for accessing values from MCMC results. The core method to select values is `get_values`. The method to select sampler statistics is `get_sampler_stats`. Both kinds of @@ -256,6 +256,17 @@ class MultiTrace: For any methods that require a single trace (e.g., taking the length of the MultiTrace instance, which returns the number of draws), the trace with the highest chain number is always used. + + Attributes + ---------- + nchains : int + Number of chains in the `MultiTrace`. + chains : `List[int]` + List of chain indices + report : str + Report on the sampling process. + varnames : `List[str]` + List of variable names in the trace(s) """ def __init__(self, straces): @@ -363,19 +374,23 @@ def stat_names(self): names.update(vars.keys()) return names - def add_values(self, vals, overwrite=False): - """add variables to traces. + def add_values(self, vals, overwrite=False) -> None: + """Add variables to traces. Parameters ---------- vals : dict (str: array-like) The keys should be the names of the new variables. The values are expected to be - array-like object. For traces with more than one chain the length of each value - should match the number of total samples already in the trace (chains * iterations), + array-like objects. For traces with more than one chain the length of each value + should match the number of total samples already in the trace `(chains * iterations)`, otherwise a warning is raised. overwrite : bool If `False` (default) a ValueError is raised if the variable already exists. Change to `True` to overwrite the values of variables + + Returns + ------- + Nothing. """ for k, v in vals.items(): new_var = 1 diff --git a/pymc3/data.py b/pymc3/data.py index cac3b97ba3a..9f71a171653 100644 --- a/pymc3/data.py +++ b/pymc3/data.py @@ -141,8 +141,8 @@ class Minibatch(tt.TensorVariable): if we want 1d slice of size 10 we do >>> x = Minibatch(data, batch_size=10) - Note, that your data is cast to `floatX` if it is not integer type - But you still can add `dtype` kwarg for :class:`Minibatch` + Note that your data is cast to `floatX` if it is not integer type + But you still can add the `dtype` kwarg for :class:`Minibatch` in case we want 10 sampled rows and columns `[(size, seed), (size, seed)]` it is diff --git a/pymc3/distributions/continuous.py b/pymc3/distributions/continuous.py index 343598be846..f771c01145d 100644 --- a/pymc3/distributions/continuous.py +++ b/pymc3/distributions/continuous.py @@ -589,8 +589,7 @@ class TruncatedNormal(BoundedContinuous): ======== ========================================== Support :math:`x \in [a, b]` Mean :math:`\mu +{\frac {\phi (\alpha )-\phi (\beta )}{Z}}\sigma` - Variance :math:`\sigma ^{2}\left[1+{\frac {\alpha \phi (\alpha )-\beta \phi (\beta )}{Z}}- - \left({\frac {\phi (\alpha )-\phi (\beta )}{Z}}\right)^{2}\right]` + Variance :math:`\sigma ^{2}\left[1+{\frac {\alpha \phi (\alpha )-\beta \phi (\beta )}{Z}}-\left({\frac {\phi (\alpha )-\phi (\beta )}{Z}}\right)^{2}\right]` ======== ========================================== Parameters @@ -1544,14 +1543,14 @@ def _repr_latex_(self, name=None, dist=None): get_variable_name(lam)) def logcdf(self, value): - """ + r""" Compute the log of cumulative distribution function for the Exponential distribution at the specified value. References ---------- .. [Machler2012] Martin Mächler (2012). - "Accurately computing log(1-exp(-|a|)) Assessed by the Rmpfr + "Accurately computing :math: `\log(1-\exp(-\mid a \mid))` Assessed by the Rmpfr package" Parameters @@ -1758,8 +1757,9 @@ class Lognormal(PositiveContinuous): tau : float Scale parameter (tau > 0). (only required if sigma is not specified). - Example - ------- + Examples + -------- + .. code-block:: python # Example to show that we pass in only `sigma` or `tau` but not both. @@ -2931,7 +2931,7 @@ def logcdf(self, value): References ---------- .. [Machler2012] Martin Mächler (2012). - "Accurately computing log(1-exp(-|a|)) Assessed by the Rmpfr + "Accurately computing `\log(1-\exp(- \mid a \mid))` Assessed by the Rmpfr package" Parameters @@ -4060,7 +4060,7 @@ def logcdf(self, value): References ---------- .. [Machler2012] Martin Mächler (2012). - "Accurately computing log(1-exp(-|a|)) Assessed by the Rmpfr + "Accurately computing :math: `\log(1-\exp(- \mid a \mid<))` Assessed by the Rmpfr package" Parameters diff --git a/pymc3/distributions/discrete.py b/pymc3/distributions/discrete.py index 8fae8b8cceb..efd1fdda398 100644 --- a/pymc3/distributions/discrete.py +++ b/pymc3/distributions/discrete.py @@ -1535,9 +1535,10 @@ class OrderedLogistic(Categorical): ranges. Do not explicitly set the first and last elements of :math:`c` to negative and positive infinity. - Example + Examples -------- - .. code:: python + + .. code-block:: python # Generate data for a simple 1 dimensional example problem n1_c = 300; n2_c = 300; n3_c = 300 diff --git a/pymc3/distributions/timeseries.py b/pymc3/distributions/timeseries.py index 694913985eb..52ed2be5c09 100644 --- a/pymc3/distributions/timeseries.py +++ b/pymc3/distributions/timeseries.py @@ -316,7 +316,7 @@ class EulerMaruyama(distribution.Continuous): sde_fn : callable function returning the drift and diffusion coefficients of SDE sde_pars : tuple - parameters of the SDE, passed as *args to sde_fn + parameters of the SDE, passed as `*args` to `sde_fn` """ def __init__(self, dt, sde_fn, sde_pars, *args, **kwds): super().__init__(*args, **kwds) diff --git a/pymc3/math.py b/pymc3/math.py index c7405f53fab..7f3e409d367 100644 --- a/pymc3/math.py +++ b/pymc3/math.py @@ -50,10 +50,10 @@ def kron_matrix_op(krons, m, op): Parameters ----------- - krons: list of square 2D array-like objects - D square matrices [A_1, A_2, ..., A_D] to be Kronecker'ed: - A = A_1 \otimes A_2 \otimes ... \otimes A_D - Product of column dimensions must be N + krons : list of square 2D array-like objects + D square matrices :math:`[A_1, A_2, ..., A_D]` to be Kronecker'ed + :math:`A = A_1 \otimes A_2 \otimes ... \otimes A_D` + Product of column dimensions must be :math:`N` m : NxM array or 1D array (treated as Nx1) Object that krons act upon """ diff --git a/pymc3/sampling.py b/pymc3/sampling.py index 01fc923d4b9..348dfe23b6e 100644 --- a/pymc3/sampling.py +++ b/pymc3/sampling.py @@ -106,7 +106,7 @@ def assign_step_methods(model, step=None, methods=STEP_METHODS, A fully-specified model object step : step function or vector of step functions One or more step functions that have been assigned to some subset of - the model's parameters. Defaults to None (no assigned variables). + the model's parameters. Defaults to `None` (no assigned variables). methods : vector of step method classes The set of step methods from which the function may choose. Defaults to the main step methods provided by PyMC3. @@ -205,7 +205,7 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N ---------- draws : int The number of samples to draw. Defaults to 500. The number of tuned samples are discarded - by default. See discard_tuned_samples. + by default. See `discard_tuned_samples`. step : function or iterable of functions A step function or collection of functions. If there are variables without a step methods, step methods for those variables will be assigned automatically. @@ -218,7 +218,7 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N * adapt_diag : Start with a identity mass matrix and then adapt a diagonal based on the variance of the tuning samples. All chains use the test value (usually the prior mean) as starting point. - * jitter+adapt_diag : Same as `adapt_diag`, but add uniform jitter in [-1, 1] to the + * jitter+adapt_diag : Same as `adapt_diag`\, but add uniform jitter in [-1, 1] to the starting point in each chain. * advi+adapt_diag : Run ADVI and then adapt the resulting diagonal mass matrix based on the sample variance of the tuning samples. @@ -234,18 +234,19 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N If 'ADVI', number of iterations, if 'nuts', number of draws. start : dict, or array of dict Starting point in parameter space (or partial point) - Defaults to trace.point(-1)) if there is a trace provided and model.test_point if not + Defaults to `trace.point(-1))` if there is a trace provided and model.test_point if not (defaults to empty dict). Initialization methods for NUTS (see `init` keyword) can - overwrite the default. For 'SMC' it should be a list of dict with length `chains`. + overwrite the default. For 'SMC' step method, `start` should be a list of dicts + of length = `chains`. trace : backend, list, or MultiTrace This should be a backend instance, a list of variables to track, or a MultiTrace object with past values. If a MultiTrace object is given, it must contain samples for the chain number `chain`. If None or a list of variables, the NDArray backend is used. Passing either "text" or "sqlite" is taken as a shortcut to set up the corresponding - backend (with "mcmc" used as the base name). Ignored when using 'SMC'. + backend (with "mcmc" used as the base name). Ignored when using 'SMC' as step method. chain_idx : int Chain number used to store sample in backend. If `chains` is greater than one, chain - numbers will start here. Ignored when using 'SMC'. + numbers will start here. Ignored when using 'SMC' as step method. chains : int The number of chains to sample. Running independent chains is important for some convergence statistics and can also reveal multiple modes in the posterior. If `None`, @@ -253,7 +254,8 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N number of draws. cores : int The number of chains to run in parallel. If `None`, set to the number of CPUs in the - system, but at most 4 (for 'SMC' ignored if `pm.SMC(parallel=False)`. Keep in mind that + system, but at most 4. When using 'SMC', this parameter will be ignored if running with + `pm.SMC(parallel=False)`. Keep in mind that some chains might themselves be multithreaded via openmp or BLAS. In those cases it might be faster to set this to 1. tune : int @@ -271,7 +273,7 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N discard_tuned_samples : bool Whether to discard posterior samples of the tune interval. Ignored when using 'SMC' compute_convergence_checks : bool, default=True - Whether to compute sampler statistics like gelman-rubin and effective_n. + Whether to compute sampler statistics like Gelman-Rubin and `effective_n`. Ignored when using 'SMC' Returns @@ -281,7 +283,6 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N Notes ----- - Optional keyword arguments can be passed to `sample` to be delivered to the `step_method`s used during sampling. In particular, the NUTS step method accepts a number of arguments. Common options are: @@ -291,7 +292,7 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N posteriors. * max_treedepth: The maximum depth of the trajectory tree. * step_scale: float, default 0.25 - The initial guess for the step size scaled down by `1/n**(1/4)`. + The initial guess for the step size scaled down by :math:`1/n**(1/4)` You can find a full list of arguments in the docstring of the step methods. @@ -1320,14 +1321,10 @@ def sample_prior_predictive(samples=500, model : Model (optional if in `with` context) vars : Iterable[str] A list of names of variables for which to compute the posterior predictive - samples. - Defaults to `model.named_vars`. - DEPRECATED - Use `var_names` instead. + samples. *DEPRECATED* - Use `var_names` argument instead. var_names : Iterable[str] A list of names of variables for which to compute the posterior predictive - samples. - Defaults to `model.named_vars`. - + samples. Defaults to `model.named_vars`. random_seed : int Seed for the random number generator. @@ -1335,7 +1332,7 @@ def sample_prior_predictive(samples=500, ------- dict Dictionary with variable names as keys. The values are numpy arrays of prior - samples. + samples. """ model = modelcontext(model) diff --git a/pymc3/step_methods/smc.py b/pymc3/step_methods/smc.py index fcc4374b04d..056132f5a19 100644 --- a/pymc3/step_methods/smc.py +++ b/pymc3/step_methods/smc.py @@ -58,36 +58,38 @@ class SMC: It should be between 0 and 1. parallel : bool Distribute computations across cores if the number of cores is larger than 1 - (see pm.sample() for details). Defaults to True. + (see `pm.sample()` for details). Defaults to True. model : :class:`pymc3.Model` Optional model for sampling step. Defaults to None (taken from context). Notes ----- - SMC works by moving from successive stages. At each stage the inverse temperature \beta is + SMC works by moving through successive stages. At each stage the inverse temperature \beta is increased a little bit (starting from 0 up to 1). When \beta = 0 we have the prior distribution and when \beta =1 we have the posterior distribution. So in more general terms we are always computing samples from a tempered posterior that we can write as: - p(\theta \mid y)_{\beta} = p(y \mid \theta)^{\beta} p(\theta) + .. math:: + + p(\theta \mid y)_{\beta} = p(y \mid \theta)^{\beta} p(\theta) A summary of the algorithm is: - 1. Initialize \beta at zero and stage at zero. - 2. Generate N samples S_{\beta} from the prior (because when \beta = 0 the tempered posterior + 1. Initialize :math:`\beta` at zero and stage at zero. + 2. Generate N samples :math:`S_{\beta}` from the prior (because when :math `\beta = 0` the tempered posterior is the prior). - 3. Increase \beta in order to make the effective sample size equals some predefined value - (we use N*t, where t is 0.5 by default). + 3. Increase :math:`\beta` in order to make the effective sample size equals some predefined value + (we use :math:`Nt`, where :math:`t` is 0.5 by default). 4. Compute a set of N importance weights W. The weights are computed as the ratio of the likelihoods of a sample at stage i+1 and stage i. - 5. Obtain S_{w} by re-sampling according to W. + 5. Obtain :math:`S_{w}` by re-sampling according to W. 6. Use W to compute the covariance for the proposal distribution. 7. For stages other than 0 use the acceptance rate from the previous stage to estimate the - scaling of the proposal distribution and n_steps. - 8. Run N Metropolis chains (each one of length n_steps), starting each one from a different - sample in S_{w}. - 9. Repeat from step 3 until \beta \ge 1. - 10. The final result is a collection of N samples from the posterior. + scaling of the proposal distribution and `n_steps`. + 8. Run N Metropolis chains (each one of length `n_steps`), starting each one from a different + sample in :math:`S_{w}`. + 9. Repeat from step 3 until :math:`\beta \ge 1`. + 10. The final result is a collection of N samples from the posterior. References From cd140a17e56fbaf9614b081ba53fdf0cc8f7b633 Mon Sep 17 00:00:00 2001 From: "Robert P. Goldman" Date: Thu, 1 Aug 2019 11:04:09 -0400 Subject: [PATCH 08/45] Fix RST bugs Luciano Paz caught. --- pymc3/backends/base.py | 2 +- pymc3/data.py | 42 ++++++++--------- pymc3/distributions/continuous.py | 12 ++--- pymc3/distributions/timeseries.py | 2 +- pymc3/sampling.py | 76 +++++++++++++++---------------- 5 files changed, 67 insertions(+), 67 deletions(-) diff --git a/pymc3/backends/base.py b/pymc3/backends/base.py index 64cabeaecb3..f6cd9e329a6 100644 --- a/pymc3/backends/base.py +++ b/pymc3/backends/base.py @@ -390,7 +390,7 @@ def add_values(self, vals, overwrite=False) -> None: Returns ------- - Nothing. + None. """ for k, v in vals.items(): new_var = 1 diff --git a/pymc3/data.py b/pymc3/data.py index 9f71a171653..0623920b5d2 100644 --- a/pymc3/data.py +++ b/pymc3/data.py @@ -99,23 +99,23 @@ class Minibatch(tt.TensorVariable): ---------- data : :class:`ndarray` initial data - batch_size : `int` or `List[int|tuple(size, random_seed)]` + batch_size : ``int`` or ``List[int|tuple(size, random_seed)]`` batch size for inference, random seed is needed for child random generators - dtype : `str` + dtype : ``str`` cast data to specific type broadcastable : tuple[bool] - change broadcastable pattern that defaults to `(False, ) * ndim` - name : `str` + change broadcastable pattern that defaults to ``(False, ) * ndim`` + name : ``str`` name for tensor, defaults to "Minibatch" - random_seed : `int` + random_seed : ``int`` random seed that is used by default - update_shared_f : `callable` + update_shared_f : ``callable`` returns :class:`ndarray` that will be carefully stored to underlying shared variable you can use it to change source of minibatches programmatically - in_memory_size : `int` or `List[int|slice|Ellipsis]` + in_memory_size : ``int`` or ``List[int|slice|Ellipsis]`` data size for storing in theano.shared Attributes @@ -130,7 +130,7 @@ class Minibatch(tt.TensorVariable): Below is a common use case of Minibatch within the variational inference. Importantly, we need to make PyMC3 "aware" of minibatch being used in inference. Otherwise, we will get the wrong :math:`logp` for the model. - To do so, we need to pass the `total_size` parameter to the observed node, which correctly scales + To do so, we need to pass the ``total_size`` parameter to the observed node, which correctly scales the density of the model logp that is affected by Minibatch. See more in examples below. Examples @@ -141,16 +141,16 @@ class Minibatch(tt.TensorVariable): if we want 1d slice of size 10 we do >>> x = Minibatch(data, batch_size=10) - Note that your data is cast to `floatX` if it is not integer type - But you still can add the `dtype` kwarg for :class:`Minibatch` + Note that your data is cast to ``floatX`` if it is not integer type + But you still can add the ``dtype`` kwarg for :class:`Minibatch` in case we want 10 sampled rows and columns - `[(size, seed), (size, seed)]` it is + ``[(size, seed), (size, seed)]`` it is >>> x = Minibatch(data, batch_size=[(10, 42), (10, 42)], dtype='int32') >>> assert str(x.dtype) == 'int32' or simpler with default random seed = 42 - `[size, size]` + ``[size, size]`` >>> x = Minibatch(data, batch_size=[10, 10]) x is a regular :class:`TensorVariable` that supports any math @@ -166,17 +166,17 @@ class Minibatch(tt.TensorVariable): >>> with model: ... approx = pm.fit() - Notable thing is that :class:`Minibatch` has `shared`, `minibatch`, attributes + Notable thing is that :class:`Minibatch` has ``shared``, ``minibatch``, attributes you can call later >>> x.set_value(np.random.laplace(size=(100, 100))) and minibatches will be then from new storage - it directly affects `x.shared`. + it directly affects ``x.shared``. the same thing would be but less convenient >>> x.shared.set_value(pm.floatX(np.random.laplace(size=(100, 100)))) programmatic way to change storage is as follows - I import `partial` for simplicity + I import ``partial`` for simplicity >>> from functools import partial >>> datagen = partial(np.random.laplace, size=(100, 100)) >>> x = Minibatch(datagen(), batch_size=10, update_shared_f=datagen) @@ -197,7 +197,7 @@ class Minibatch(tt.TensorVariable): for shared variable. Feel free to use that if needed. Suppose you need some replacements in the graph, e.g. change minibatch to testdata - >>> node = x ** 2 # arbitrary expressions on minibatch `x` + >>> node = x ** 2 # arbitrary expressions on minibatch ``x`` >>> testdata = pm.floatX(np.random.laplace(size=(1000, 10))) Then you should create a dict with replacements @@ -214,20 +214,20 @@ class Minibatch(tt.TensorVariable): For more complex slices some more code is needed that can seem not so clear >>> moredata = np.random.rand(10, 20, 30, 40, 50) - default `total_size` that can be passed to `PyMC3` random node - is then `(10, 20, 30, 40, 50)` but can be less verbose in some cases + default ``total_size`` that can be passed to ``PyMC3`` random node + is then ``(10, 20, 30, 40, 50)`` but can be less verbose in some cases - 1) Advanced indexing, `total_size = (10, Ellipsis, 50)` + 1) Advanced indexing, ``total_size = (10, Ellipsis, 50)`` >>> x = Minibatch(moredata, [2, Ellipsis, 10]) We take slice only for the first and last dimension >>> assert x.eval().shape == (2, 20, 30, 40, 10) - 2) Skipping particular dimension, `total_size = (10, None, 30)` + 2) Skipping particular dimension, ``total_size = (10, None, 30)`` >>> x = Minibatch(moredata, [2, None, 20]) >>> assert x.eval().shape == (2, 20, 20, 40, 50) - 3) Mixing that all, `total_size = (10, None, 30, Ellipsis, 50)` + 3) Mixing that all, ``total_size = (10, None, 30, Ellipsis, 50)`` >>> x = Minibatch(moredata, [2, None, 20, Ellipsis, 10]) >>> assert x.eval().shape == (2, 20, 20, 40, 10) """ diff --git a/pymc3/distributions/continuous.py b/pymc3/distributions/continuous.py index f771c01145d..a14caac7dbd 100644 --- a/pymc3/distributions/continuous.py +++ b/pymc3/distributions/continuous.py @@ -1550,7 +1550,7 @@ def logcdf(self, value): References ---------- .. [Machler2012] Martin Mächler (2012). - "Accurately computing :math: `\log(1-\exp(-\mid a \mid))` Assessed by the Rmpfr + "Accurately computing :math:`\log(1-\exp(-\mid a \mid))` Assessed by the Rmpfr package" Parameters @@ -1762,7 +1762,7 @@ class Lognormal(PositiveContinuous): .. code-block:: python - # Example to show that we pass in only `sigma` or `tau` but not both. + # Example to show that we pass in only ``sigma`` or ``tau`` but not both. with pm.Model(): x = pm.Lognormal('x', mu=2, sigma=30) @@ -1913,7 +1913,7 @@ class StudentT(Continuous): plt.show() ======== ======================== - Support :math:`x \in \mathbb{R}` + Support :math:``x \in \mathbb{R}`` ======== ======================== Parameters @@ -3723,7 +3723,7 @@ class Gumbel(Continuous): ======== ========================================== Support :math:`x \in \mathbb{R}` - Mean :math:`\mu + \beta\gamma`, where \gamma is the Euler-Mascheroni constant + Mean :math:`\mu + \beta\gamma`, where :math:`\gamma` is the Euler-Mascheroni constant Variance :math:`\frac{\pi^2}{6} \beta^2` ======== ========================================== @@ -4213,7 +4213,7 @@ class Interpolated(BoundedContinuous): interpolated density is any way normalized to make the total probability equal to $1$. - Both parameters `x_points` and values `pdf_points` are not variables, but + Both parameters ``x_points`` and values ``pdf_points`` are not variables, but plain array-like objects, so they are constant and cannot be sampled. ======== =========================================== @@ -4225,7 +4225,7 @@ class Interpolated(BoundedContinuous): x_points : array-like A monotonically growing list of values pdf_points : array-like - Probability density function evaluated on lattice `x_points` + Probability density function evaluated on lattice ``x_points`` """ def __init__(self, x_points, pdf_points, *args, **kwargs): diff --git a/pymc3/distributions/timeseries.py b/pymc3/distributions/timeseries.py index 52ed2be5c09..cb3d49d49c2 100644 --- a/pymc3/distributions/timeseries.py +++ b/pymc3/distributions/timeseries.py @@ -316,7 +316,7 @@ class EulerMaruyama(distribution.Continuous): sde_fn : callable function returning the drift and diffusion coefficients of SDE sde_pars : tuple - parameters of the SDE, passed as `*args` to `sde_fn` + parameters of the SDE, passed as ``*args`` to ``sde_fn`` """ def __init__(self, dt, sde_fn, sde_pars, *args, **kwds): super().__init__(*args, **kwds) diff --git a/pymc3/sampling.py b/pymc3/sampling.py index 348dfe23b6e..34479902cf0 100644 --- a/pymc3/sampling.py +++ b/pymc3/sampling.py @@ -45,7 +45,7 @@ def instantiate_steppers(model, steps, selected_steps, step_kwargs=None): """Instantiates steppers assigned to the model variables. - This function is intended to be called automatically from `sample()`, but + This function is intended to be called automatically from ``sample()``, but may be called manually. Parameters @@ -94,9 +94,9 @@ def assign_step_methods(model, step=None, methods=STEP_METHODS, Passing a specified model will auto-assign its constituent stochastic variables to step methods based on the characteristics of the variables. - This function is intended to be called automatically from `sample()`, but + This function is intended to be called automatically from ``sample()``, but may be called manually. Each step method passed should have a - `competence()` method that returns an ordinal competence value + ``competence()`` method that returns an ordinal competence value corresponding to the variable passed to it. This value quantifies the appropriateness of the step method for sampling the variable. @@ -106,7 +106,7 @@ def assign_step_methods(model, step=None, methods=STEP_METHODS, A fully-specified model object step : step function or vector of step functions One or more step functions that have been assigned to some subset of - the model's parameters. Defaults to `None` (no assigned variables). + the model's parameters. Defaults to ``None`` (no assigned variables). methods : vector of step method classes The set of step methods from which the function may choose. Defaults to the main step methods provided by PyMC3. @@ -205,7 +205,7 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N ---------- draws : int The number of samples to draw. Defaults to 500. The number of tuned samples are discarded - by default. See `discard_tuned_samples`. + by default. See ``discard_tuned_samples``. step : function or iterable of functions A step function or collection of functions. If there are variables without a step methods, step methods for those variables will be assigned automatically. @@ -213,12 +213,12 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N Initialization method to use for auto-assigned NUTS samplers. * auto : Choose a default initialization method automatically. - Currently, this is `'jitter+adapt_diag'`, but this can change in the future. + Currently, this is ``'jitter+adapt_diag'``, but this can change in the future. If you depend on the exact behaviour, choose an initialization method explicitly. * adapt_diag : Start with a identity mass matrix and then adapt a diagonal based on the variance of the tuning samples. All chains use the test value (usually the prior mean) as starting point. - * jitter+adapt_diag : Same as `adapt_diag`\, but add uniform jitter in [-1, 1] to the + * jitter+adapt_diag : Same as ``adapt_diag``\, but add uniform jitter in [-1, 1] to the starting point in each chain. * advi+adapt_diag : Run ADVI and then adapt the resulting diagonal mass matrix based on the sample variance of the tuning samples. @@ -234,57 +234,57 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N If 'ADVI', number of iterations, if 'nuts', number of draws. start : dict, or array of dict Starting point in parameter space (or partial point) - Defaults to `trace.point(-1))` if there is a trace provided and model.test_point if not - (defaults to empty dict). Initialization methods for NUTS (see `init` keyword) can - overwrite the default. For 'SMC' step method, `start` should be a list of dicts - of length = `chains`. + Defaults to ``trace.point(-1))`` if there is a trace provided and model.test_point if not + (defaults to empty dict). Initialization methods for NUTS (see ``init`` keyword) can + overwrite the default. For 'SMC' step method, ``start`` should be a list of dicts + of length = ``chains``. trace : backend, list, or MultiTrace This should be a backend instance, a list of variables to track, or a MultiTrace object with past values. If a MultiTrace object is given, it must contain samples for the chain - number `chain`. If None or a list of variables, the NDArray backend is used. + number ``chain``. If None or a list of variables, the NDArray backend is used. Passing either "text" or "sqlite" is taken as a shortcut to set up the corresponding backend (with "mcmc" used as the base name). Ignored when using 'SMC' as step method. chain_idx : int - Chain number used to store sample in backend. If `chains` is greater than one, chain + Chain number used to store sample in backend. If ``chains`` is greater than one, chain numbers will start here. Ignored when using 'SMC' as step method. chains : int The number of chains to sample. Running independent chains is important for some - convergence statistics and can also reveal multiple modes in the posterior. If `None`, - then set to either `cores` or 2, whichever is larger. For SMC the number of chains is the + convergence statistics and can also reveal multiple modes in the posterior. If ``None``, + then set to either ``cores`` or 2, whichever is larger. For SMC the number of chains is the number of draws. cores : int - The number of chains to run in parallel. If `None`, set to the number of CPUs in the + The number of chains to run in parallel. If ``None``, set to the number of CPUs in the system, but at most 4. When using 'SMC', this parameter will be ignored if running with - `pm.SMC(parallel=False)`. Keep in mind that + ``pm.SMC(parallel=False)``. Keep in mind that some chains might themselves be multithreaded via openmp or BLAS. In those cases it might be faster to set this to 1. tune : int Number of iterations to tune, defaults to 500. Ignored when using 'SMC'. Samplers adjust the step sizes, scalings or similar during tuning. Tuning samples will be drawn in addition - to the number specified in the `draws` argument, and will be discarded unless - `discard_tuned_samples` is set to False. + to the number specified in the ``draws`` argument, and will be discarded unless + ``discard_tuned_samples`` is set to False. progressbar : bool Whether or not to display a progress bar in the command line. The bar shows the percentage of completion, the sampling speed in samples per second (SPS), and the estimated remaining time until completion ("expected time of arrival"; ETA). - model : Model (optional if in `with` context) + model : Model (optional if in ``with`` context) random_seed : int or list of ints - A list is accepted if `cores` is greater than one. + A list is accepted if ``cores`` is greater than one. discard_tuned_samples : bool Whether to discard posterior samples of the tune interval. Ignored when using 'SMC' compute_convergence_checks : bool, default=True - Whether to compute sampler statistics like Gelman-Rubin and `effective_n`. + Whether to compute sampler statistics like Gelman-Rubin and ``effective_n``. Ignored when using 'SMC' Returns ------- trace : pymc3.backends.base.MultiTrace - A `MultiTrace` object that contains the samples. + A ``MultiTrace`` object that contains the samples. Notes ----- - Optional keyword arguments can be passed to `sample` to be delivered to the - `step_method`s used during sampling. In particular, the NUTS step method accepts + Optional keyword arguments can be passed to ``sample`` to be delivered to the + ``step_method``s used during sampling. In particular, the NUTS step method accepts a number of arguments. Common options are: * target_accept: float in [0, 1]. The step size is tuned such that we approximate this @@ -580,15 +580,15 @@ def iter_sample(draws, step, start=None, trace=None, chain=0, tune=None, trace : backend, list, or MultiTrace This should be a backend instance, a list of variables to track, or a MultiTrace object with past values. If a MultiTrace object is given, it must contain samples for the chain - number `chain`. If None or a list of variables, the NDArray backend is used. + number ``chain``. If None or a list of variables, the NDArray backend is used. chain : int - Chain number used to store sample in backend. If `cores` is greater than one, chain numbers + Chain number used to store sample in backend. If ``cores`` is greater than one, chain numbers will start here. tune : int Number of iterations to tune, if applicable (defaults to None) - model : Model (optional if in `with` context) + model : Model (optional if in ``with`` context) random_seed : int or list of ints - A list is accepted if more if `cores` is greater than one. + A list is accepted if more if ``cores`` is greater than one. Examples -------- @@ -1064,11 +1064,11 @@ def sample_posterior_predictive(trace, sample per posterior sample, that is, the number of draws times the number of chains. It is not recommended to modify this value; when modified, some chains may not be represented in the posterior predictive sample. - model : Model (optional if in `with` context) - Model used to generate `trace` + model : Model (optional if in ``with`` context) + Model used to generate ``trace`` vars : iterable Variables for which to compute the posterior predictive samples. - Defaults to `model.observed_RVs`. Deprecated: please use `var_names` instead. + Deprecated: please use ``var_names`` instead. var_names : Iterable[str] Alternative way to specify vars to sample, to make this function orthogonal with others. @@ -1185,7 +1185,7 @@ def sample_posterior_predictive_w(traces, samples=None, models=None, weights=Non models : list List of models used to generate the list of traces. The number of models should be equal to the number of weights and the number of observed RVs should be the same for all models. - By default a single model will be inferred from `with` context, in this case results will + By default a single model will be inferred from ``with`` context, in this case results will only be meaningful if all models share the same distributions for the observed RVs. weights: array-like Individual weights for each trace. Default, same weight for each model. @@ -1318,13 +1318,13 @@ def sample_prior_predictive(samples=500, ---------- samples : int Number of samples from the prior predictive to generate. Defaults to 500. - model : Model (optional if in `with` context) + model : Model (optional if in ``with`` context) vars : Iterable[str] A list of names of variables for which to compute the posterior predictive - samples. *DEPRECATED* - Use `var_names` argument instead. + samples. *DEPRECATED* - Use ``var_names`` argument instead. var_names : Iterable[str] A list of names of variables for which to compute the posterior predictive - samples. Defaults to `model.named_vars`. + samples. Defaults to ``model.named_vars``. random_seed : int Seed for the random number generator. @@ -1391,7 +1391,7 @@ def init_nuts(init='auto', chains=1, n_init=500000, model=None, * adapt_diag : Start with a identity mass matrix and then adapt a diagonal based on the variance of the tuning samples. All chains use the test value (usually the prior mean) as starting point. - * jitter+adapt_diag : Same as `adapt_diag`, but use uniform jitter in [-1, 1] as starting + * jitter+adapt_diag : Same as ``adapt_diag``, but use uniform jitter in [-1, 1] as starting point in each chain. * advi+adapt_diag : Run ADVI and then adapt the resulting diagonal mass matrix based on the sample variance of the tuning samples. @@ -1408,7 +1408,7 @@ def init_nuts(init='auto', chains=1, n_init=500000, model=None, n_init : int Number of iterations of initializer If 'ADVI', number of iterations, if 'nuts', number of draws. - model : Model (optional if in `with` context) + model : Model (optional if in ``with`` context) progressbar : bool Whether or not to display a progressbar for advi sampling. **kwargs : keyword arguments From 8526a5b30dab6dbb56be2e93df6cfa80ed4f1029 Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Tue, 30 Jul 2019 19:16:13 -0400 Subject: [PATCH 09/45] Commit ODE capabilities. Add unit test for pm.ode --- pymc3/ode/__init__.py | 2 + pymc3/ode/ode.py | 183 +++++++++++++++ pymc3/ode/utils.py | 81 +++++++ pymc3/tests/test_ode.py | 497 ++++++++++++++++++++++++++++++++++++++++ 4 files changed, 763 insertions(+) create mode 100644 pymc3/ode/__init__.py create mode 100644 pymc3/ode/ode.py create mode 100644 pymc3/ode/utils.py create mode 100644 pymc3/tests/test_ode.py diff --git a/pymc3/ode/__init__.py b/pymc3/ode/__init__.py new file mode 100644 index 00000000000..468c3f54aeb --- /dev/null +++ b/pymc3/ode/__init__.py @@ -0,0 +1,2 @@ +from . import utils +from .ode import DifferentialEquation \ No newline at end of file diff --git a/pymc3/ode/ode.py b/pymc3/ode/ode.py new file mode 100644 index 00000000000..c90cd11200f --- /dev/null +++ b/pymc3/ode/ode.py @@ -0,0 +1,183 @@ +import numpy as np +from pymc3.ode.utils import augment_system, ODEGradop +import scipy +import theano +import theano.tensor as tt +THEANO_FLAG = 'compute_test_value=ignore' + + +class DifferentialEquation(theano.Op): + + ''' + Specify an ordinary differential equation + + .. math:: + \dfrac{dy}{dt} = f(y,t,p) \quad y(t_0) = y_0 + + Parameters + ---------- + + func : callable + Function specifying the differential equation + t0 : float + Time corresponding to the initial condition + times : array + Array of times at which to evaluate the solution of the differential equation. + n_states : int + Dimension of the differential equation. For scalar differential equations, n_states =1. + For vector valued differential equations, n_states = number of differential equations iun the system. + n_odeparams : int + Number of parameters in the differential equation. + + .. code-block:: python + + def odefunc(y,t,p): + #Logistic differential equation + return p[0]*y[0]*(1-y[0]) + + times = np.arange(0.5, 5, 0.5) + + ode_model = DifferentialEquation(func = odefunc, t0 = 0, times = times, n_states = 1, n_odeparams = 1) + ''' + + __props__ = () + + def __init__(self, func, t0, times, n_states, n_odeparams): + + if not callable(func): + raise ValueError("Argument func must be callable.") + if np.any(np.diff(times)<0): + raise ValueError("The values in times must be monotonically increasing or monotonically decreasing; repeated values are allowed.") + if n_states<1: + raise ValueError('Argument n_states must be at least 1.') + if n_odeparams<0: + raise ValueError('Argument n_states must be non-negative.') + + #Public + self.func = func + self.t0 = t0 + self.times = times + self.n_states = n_states + self.n_odeparams = n_odeparams + + #Private + self._n = n_states + self._m = n_odeparams + n_states + + self._augmented_times = np.insert(times, t0, 0) + self._augmented_func = augment_system(func, self._n, self._m) + self._sens_ic = self._make_sens_ic() + + self._cached_y = None + self._cached_sens = None + self._cached_parameters = None + + def _make_sens_ic(self): + + # The sensitivity matrix will always have consistent form. + # If the first n_odeparams entries of the parameters vector in the simulate call + # correspond to ode paramaters, then the first n_odeparams columns in + # the sensitivity matrix will be 0 + sens_matrix = np.zeros((self._n, self._m)) + + # If the last n_states entrues of the paramters vector in the simulate call + # correspond to initial conditions of the system, + # then the last n_states columns of the sensitivity matrix should form + # an identity matrix + sens_matrix[:, -self.n_states:] = np.eye(self.n_states) + + # We need the sensitivity matrix to be a vector (see augmented_function) + # Ravel and return + dydp = sens_matrix.ravel() + + return dydp + + def _system(self, Y, t, p): + """ + This is the function that will be passed to odeint. + Solves both ODE and sensitivities + Args: + Y (vector): current state and current gradient state + t (scalar): current time + p (vector): parameters + Returns: + derivatives (vector): derivatives of state and gradient + """ + + dydt, ddt_dydp = self._augmented_func(Y[:self._n], t, p, Y[self._n:]) + derivatives = np.concatenate([dydt, ddt_dydp]) + return derivatives + + def _simulate(self, parameters): + + # Initial condition comprised of state initial conditions and raveled + # sensitivity matrix + y0 = np.concatenate([ parameters[self.n_odeparams:] , self._sens_ic]) + + # perform the integration + sol = scipy.integrate.odeint(func=self._system, + y0=y0, + t=self._augmented_times, + args=tuple([parameters])) + # The solution + y = sol[1:, :self.n_states] + + # The sensitivities, reshaped to be a sequence of matrices + sens = sol[1:, self.n_states:].reshape(len(self.times), self._n, self._m) + + return y, sens + + def _cached_simulate(self, parameters): + + if np.array_equal(np.array(parameters), self._cached_parameters): + return self._cached_y, self._cached_sens + else: + return self._simulate(np.array(parameters)) + + def state(self, x): + + y, sens = self._cached_simulate(np.array(x, dtype=np.float64)) + self._cached_y, self._cached_sens, self._cached_parameters = y, sens, x + return y.ravel() + + def numpy_vsp(self, x, g): + + numpy_sens = self._cached_simulate(np.array(x, dtype=np.float64))[1].reshape((self.n_states * len(self.times), len(x))) + return numpy_sens.T.dot(g) + + def make_node(self, odeparams, y0): + + if len(odeparams)!=self.n_odeparams: + raise ValueError('odeparams has too many or too few parameters. Expected {a} paramteres but got {b}'.format(a = self.n_odeparams, b = len(odeparams))) + if len(y0)!=self.n_states: + raise ValueError('y0 has too many or too few parameters. Expected {a} paramteres but got {b}'.format(a = self.n_states, b = len(y0))) + + if np.ndim(odeparams) > 1: + odeparams = np.ravel(odeparams) + if np.ndim(y0) > 1: + y0 = np.ravel(y0) + + odeparams = tt.as_tensor_variable(odeparams) + y0 = tt.as_tensor_variable(y0) + x = tt.concatenate([odeparams, y0]) + + return theano.Apply(self, [x], [x.type()]) + + def perform(self, node, inputs_storage, output_storage): + + x = inputs_storage[0] + out = output_storage[0] + + # get the numerical solution of ODE states + out[0] = self.state(x) + + def grad(self, inputs, output_grads): + + x = inputs[0] + g = output_grads[0] + + # pass the VSP when asked for gradient + grad_op = ODEGradop(self.numpy_vsp) + grad_op_apply = grad_op(x, g) + + return [grad_op_apply] \ No newline at end of file diff --git a/pymc3/ode/utils.py b/pymc3/ode/utils.py new file mode 100644 index 00000000000..15d3767874a --- /dev/null +++ b/pymc3/ode/utils.py @@ -0,0 +1,81 @@ +import theano +import theano.tensor as tt + + +def augment_system(ode_func, n, m): + '''Function to create augmented system. + + Take a function which specifies a set of differential equations and return + a compiled function which allows for computation of gradients of the + differential equation's solition with repsect to the parameters. + + Args: + ode_func (function): Differential equation. Returns array-like + n: Number of rows of the sensitivity matrix + m: Number of columns of the sensitivity matrix + + Returns: + system (function): Augemted system of differential equations. + + ''' + + # Present state of the system + t_y = tt.vector('y', dtype=theano.config.floatX) + + # Parameter(s). Should be vector to allow for generaliztion to multiparameter + # systems of ODEs + t_p = tt.vector('p', dtype=theano.config.floatX) + + # Time. Allow for non-automonous systems of ODEs to be analyzed + t_t = tt.scalar('t', dtype=theano.config.floatX) + + # Present state of the gradients: + # Will always be 0 unless the parameter is the inital condition + # Entry i,j is partial of y[i] wrt to p[j] + dydp_vec = tt.vector('dydp', dtype=theano.config.floatX) + + dydp = dydp_vec.reshape((n, m)) + + # Stack the results of the ode_func + # TODO: Does this behave the same of ODE is scalar? + f_tensor = tt.stack(ode_func(t_y, t_t, t_p)) + + # Now compute gradients + J = tt.jacobian(f_tensor, t_y) + + Jdfdy = tt.dot(J, dydp) + + grad_f = tt.jacobian(f_tensor, t_p) + + # This is the time derivative of dydp + ddt_dydp = (Jdfdy + grad_f).flatten() + + system = theano.function( + inputs=[t_y, t_t, t_p, dydp_vec], + outputs=[f_tensor, ddt_dydp], + on_unused_input='ignore') + + return system + + + +class ODEGradop(theano.Op): + + def __init__(self, numpy_vsp): + + self._numpy_vsp = numpy_vsp + + def make_node(self, x, g): + + x = theano.tensor.as_tensor_variable(x) + g = theano.tensor.as_tensor_variable(g) + node = theano.Apply(self, [x, g], [g.type()]) + return node + + def perform(self, node, inputs_storage, output_storage): + + x = inputs_storage[0] + + g = inputs_storage[1] + out = output_storage[0] + out[0] = self._numpy_vsp(x, g) # get the numerical VSP diff --git a/pymc3/tests/test_ode.py b/pymc3/tests/test_ode.py new file mode 100644 index 00000000000..a359f8a9ced --- /dev/null +++ b/pymc3/tests/test_ode.py @@ -0,0 +1,497 @@ +from ..ode import DifferentialEquation +from ..ode.utils import augment_system + +import numpy as np +from scipy.integrate import odeint +from scipy.stats import norm +import pymc3 as pm +import theano +import theano.tensor as tt +import pytest + + +def test_gradients(): + with theano.configparser.change_flags(compute_test_value='off'): + '''Tests the computation of the sensitivities from the theano computation graph''' + + # ODE system for which to compute gradients + def ode_func(y, t, p): + return np.exp(-t) - p[0] * y[0] + + # Computation of graidients with Theano + augmented_ode_func = augment_system(ode_func, 1, 1 + 1) + + # This is the new system, ODE + Sensitivities, which will be integrated + def augmented_system(Y, t, p): + + dydt, ddt_dydp = augmented_ode_func(Y[:1], t, p, Y[1:]) + derivatives = np.concatenate([dydt, ddt_dydp]) + return derivatives + + # Create real sensitivities + y0 = 0.0 + t = np.arange(0, 12, 0.25).reshape(-1, 1) + a = 0.472 + p = np.array([a, y0]) + + # Derivatives of the analytic solution with respect to y0 and alpha + # Treat y0 like a parameter and solve analytically. Then differentiate. + # I used CAS to get these derivatives + y0_sensitivity = np.exp(-a * t) + a_sensitivity = -(np.exp(t * (a - 1)) - 1 + (a - 1) * + (y0 * a - y0 - 1) * t) * np.exp(-a * t) / (a - 1)**2 + + sensitivity = np.c_[a_sensitivity, y0_sensitivity] + + integrated_solutions = odeint(func=augmented_system, + y0=[y0, 0, 1], + t=t.ravel(), + args=tuple([p])) + simulated_sensitivity = integrated_solutions[:, 1:] + + np.testing.assert_allclose( + sensitivity, simulated_sensitivity, rtol=1e-5) + + +def test_simulate(): + with theano.configparser.change_flags(compute_test_value='off'): + '''Tests the integration in DifferentialEquation''' + + # Create an ODe to integrate + def ode_func(y, t, p): + return np.exp(-t) - p[0] * y[0] + + # Evaluate exact solution + y0 = 0 + t = np.arange(0, 12, 0.25).reshape(-1, 1) + a = 0.472 + y = 1.0 / (a - 1) * (np.exp(-t) - np.exp(-a * t)) + + # Instantiate ODE model + ode_model = DifferentialEquation(func=ode_func, + t0=0, + times=t, + n_states=1, + n_odeparams=1) + + simulated_y, *_ = ode_model._simulate([a, y0]) + + np.testing.assert_allclose(y, simulated_y, rtol=1e-5) + + +class TestSensitivityInitialCondition(object): + + t = np.arange(0, 12, 0.25).reshape(-1, 1) + + def test_sens_ic_scalar_1_param(self): + with theano.configparser.change_flags(compute_test_value='off'): + + '''Tests the creation of the initial condition for the sensitivities''' + + # Scalar ODE 1 Param + # Create an ODe to integrate + def ode_func_1(y, t, p): + return np.exp(-t) - p[0] * y[0] + + # Instantiate ODE model + # Instantiate ODE model + model1 = DifferentialEquation(func=ode_func_1, + t0=0, + times=self.t, + n_states=1, + n_odeparams=1) + + # Sensitivity initial condition for this model should be 1 by 2 + model1_sens_ic = np.array([0, 1]) + + np.testing.assert_array_equal( + model1_sens_ic, model1._make_sens_ic()) + + def test_sens_ic_scalar_2_param(self): + with theano.configparser.change_flags(compute_test_value='off'): + + # Scalar ODE 2 Param + def ode_func_2(y, t, p): + return p[0] * np.exp(-p[0] * t) - p[1] * y[0] + + # Instantiate ODE model + model2 = DifferentialEquation(func=ode_func_2, + t0=0, + times=self.t, + n_states=1, + n_odeparams=2) + + model2_sens_ic = np.array([0, 0, 1]) + + np.testing.assert_array_equal( + model2_sens_ic, model2._make_sens_ic()) + + def test_sens_ic_vector_1_param(self): + with theano.configparser.change_flags(compute_test_value='off'): + + # Vector ODE 1 Param + def ode_func_3(y, t, p): + ds = -p[0] * y[0] * y[1] + di = p[0] * y[0] * y[1] - y[1] + + return [ds, di] + + # Instantiate ODE model + model3 = DifferentialEquation(func=ode_func_3, + t0=0, + times=self.t, + n_states=2, + n_odeparams=1) + + model3_sens_ic = np.array([0, 1, 0, 0, 0, 1]) + + np.testing.assert_array_equal( + model3_sens_ic, model3._make_sens_ic()) + + def test_sens_ic_vector_2_param(self): + with theano.configparser.change_flags(compute_test_value='off'): + + # Vector ODE 2 Param + def ode_func_4(y, t, p): + ds = -p[0] * y[0] * y[1] + di = p[0] * y[0] * y[1] - p[1] * y[1] + + return [ds, di] + + # Instantiate ODE model + model4 = DifferentialEquation(func=ode_func_4, + t0=0, + times=self.t, + n_states=2, + n_odeparams=2) + + model4_sens_ic = np.array([0, 0, 1, 0, 0, 0, 0, 1]) + + np.testing.assert_array_equal( + model4_sens_ic, model4._make_sens_ic()) + + def test_sens_ic_vector_3_params(self): + with theano.configparser.change_flags(compute_test_value='off'): + + # Big System with Many Parameters + def ode_func_5(y, t, p): + dx = p[0] * (y[1] - y[0]) + ds = y[0] * (p[1] - y[2]) - y[1] + dz = y[0] * y[1] - p[2] * y[2] + + return [dx, ds, dz] + + # Instantiate ODE model + model5 = DifferentialEquation(func=ode_func_5, + t0=0, + times=self.t, + n_states=3, + n_odeparams=3) + + # First three columns are derivatives with respect to ode parameters + # Last three coluimns are derivatives with repsect to initial condition + # So identity matrix should appear in last 3 columns + model5_sens_ic = np.array([[0, 0, 0, 1, 0, 0], + [0, 0, 0, 0, 1, 0], + [0, 0, 0, 0, 0, 1]]) + + np.testing.assert_array_equal( + np.ravel(model5_sens_ic), + model5._make_sens_ic()) + + +def test_logp_scalar_ode(): + with theano.configparser.change_flags(compute_test_value='off'): + + '''Test the computation of the log probability for these models''' + + # Differential equation + def system_1(y, t, p): + return np.exp(-t) - p[0] * y[0] + + # Parameters and inital condition + alpha = 0.4 + y0 = 0.0 + times = np.arange(0.5, 8, 0.5) + + yobs = np.array([0.30, + 0.56, + 0.51, + 0.55, + 0.47, + 0.42, + 0.38, + 0.30, + 0.26, + 0.21, + 0.22, + 0.13, + 0.13, + 0.09, + 0.09]).reshape(-1, + 1) + + ode_model = DifferentialEquation(func=system_1, + t0=0, + times=times, + n_odeparams=1, + n_states=1) + + integrated_solution, *_ = ode_model._simulate([alpha, y0]) + + manual_logp = norm.logpdf( + x=np.ravel(yobs), + loc=np.ravel(integrated_solution), + scale=1).sum() + + with pm.Model() as model_1: + + forward = ode_model(odeparams=[alpha], y0=[y0]).reshape(yobs.shape) + + y = pm.Normal('y', mu=forward, sd=1, observed=yobs) + + pymc3_logp = model_1.logp() + + np.testing.assert_allclose(manual_logp, pymc3_logp) + + +class TestErrors(object): + + '''Test running model for a scalar ODE with 1 parameter''' + def system(y, t, p): + return np.exp(-t) - p[0] * y[0] + + times = np.arange(0, 9) + + ode_model = DifferentialEquation( + func=system, + t0=0, + times=times, + n_states=1, + n_odeparams=1) + + def test_too_many_params(self): + with pytest.raises(ValueError): + self.ode_model(odeparams=[1, 1], y0=[0]) + + def test_too_many_y0(self): + with pytest.raises(ValueError): + self.ode_model(odeparams=[1], y0=[0, 0]) + + def test_too_few_params(self): + with pytest.raises(ValueError): + self.ode_model(odeparams=[], y0=[1]) + + def test_too_few_y0(self): + with pytest.raises(ValueError): + self.ode_model(odeparams=[1], y0=[]) + + +class TestDiffEqModel(object): + + def test_scalar_ode_1_param(self): + '''Test running model for a scalar ODE with 1 parameter''' + with theano.configparser.change_flags(compute_test_value='off'): + def system(y, t, p): + return np.exp(-t) - p[0] * y[0] + + times = np.array([0.5, 1., 1.5, 2., 2.5, 3., 3.5, + 4., 4.5, 5., 5.5, 6., 6.5, 7., 7.5]) + + yobs = np.array([0.31, + 0.57, + 0.51, + 0.55, + 0.47, + 0.42, + 0.38, + 0.3, + 0.26, + 0.22, + 0.22, + 0.14, + 0.14, + 0.09, + 0.1]).reshape(-1, + 1) + + ode_model = DifferentialEquation( + func=system, + t0=0, + times=times, + n_states=1, + n_odeparams=1) + + with pm.Model() as model: + + alpha = pm.HalfCauchy('alpha', 1) + y0 = pm.Lognormal('y0', 0, 1) + sigma = pm.HalfCauchy('sigma', 1) + forward = ode_model( + odeparams=[alpha], + y0=[y0]).reshape( + yobs.shape) + + y = pm.Lognormal('y', mu=pm.math.log( + forward), sd=sigma, observed=yobs) + + trace = pm.sample(100, tune=0) + + assert trace['alpha'].size > 0 + assert trace['y0'].size > 0 + assert trace['sigma'].size > 0 + + def test_scalar_ode_2_param(self): + '''Test running model for a scalar ODE with 2 parameters''' + with theano.configparser.change_flags(compute_test_value='off'): + def system(y, t, p): + return p[0] * np.exp(-p[0] * t) - p[1] * y[0] + + times = np.array([0.5, 1., 1.5, 2., 2.5, 3., 3.5, + 4., 4.5, 5., 5.5, 6., 6.5, 7., 7.5]) + + yobs = np.array([0.31, + 0.57, + 0.51, + 0.55, + 0.47, + 0.42, + 0.38, + 0.30, + 0.26, + 0.22, + 0.22, + 0.14, + 0.14, + 0.09, + 0.10]).reshape(-1, + 1) + + ode_model = DifferentialEquation( + func=system, + t0=0, + times=times, + n_states=1, + n_odeparams=2) + + with pm.Model() as model: + + alpha = pm.HalfCauchy('alpha', 1) + beta = pm.HalfCauchy('beta', 1) + y0 = pm.Lognormal('y0', 0, 1) + sigma = pm.HalfCauchy('sigma', 1) + forward = ode_model( + odeparams=[ + alpha, + beta], + y0=[y0]).reshape( + yobs.shape) + + y = pm.Lognormal('y', mu=pm.math.log( + forward), sd=sigma, observed=yobs) + + trace = pm.sample(100, tune=0) + + assert trace['alpha'].size > 0 + assert trace['beta'].size > 0 + assert trace['y0'].size > 0 + assert trace['sigma'].size > 0 + + def test_vector_ode_1_param(self): + '''Test running model for a vector ODE with 1 parameter''' + with theano.configparser.change_flags(compute_test_value='off'): + def system(y, t, p): + ds = -p[0] * y[0] * y[1] + di = p[0] * y[0] * y[1] - y[1] + + return [ds, di] + + times = np.array( + [0.0, 0.8, 1.6, 2.4, 3.2, 4.0, 4.8, 5.6, 6.4, 7.2, 8.0]) + + yobs = np.array([[1.02, 0.02], + [0.86, 0.12], + [0.43, 0.37], + [0.14, 0.42], + [0.05, 0.43], + [0.03, 0.14], + [0.02, 0.08], + [0.02, 0.04], + [0.02, 0.01], + [0.02, 0.01], + [0.02, 0.01]]) + + ode_model = DifferentialEquation( + func=system, + t0=0, + times=times, + n_states=2, + n_odeparams=1) + + with pm.Model() as model: + + R = pm.Lognormal('R', 1, 5) + sigma = pm.HalfCauchy('sigma', 1, shape=2) + forward = ode_model( + odeparams=[R], y0=[ + 0.99, 0.01]).reshape( + yobs.shape) + + y = pm.Lognormal('y', mu=pm.math.log( + forward), sd=sigma, observed=yobs) + + trace = pm.sample(100, tune=0) + + assert trace['R'].size > 0 + assert trace['sigma'].size > 0 + + def test_vector_ode_2_param(self): + '''Test running model for a vector ODE with 2 parameters''' + with theano.configparser.change_flags(compute_test_value='off'): + def system(y, t, p): + ds = -p[0] * y[0] * y[1] + di = p[0] * y[0] * y[1] - p[1] * y[1] + + return [ds, di] + + times = np.array( + [0.0, 0.8, 1.6, 2.4, 3.2, 4.0, 4.8, 5.6, 6.4, 7.2, 8.0]) + + yobs = np.array([[1.02, 0.02], + [0.86, 0.12], + [0.43, 0.37], + [0.14, 0.42], + [0.05, 0.43], + [0.03, 0.14], + [0.02, 0.08], + [0.02, 0.04], + [0.02, 0.01], + [0.02, 0.01], + [0.02, 0.01]]) + + ode_model = DifferentialEquation( + func=system, + t0=0, + times=times, + n_states=2, + n_odeparams=2) + + with pm.Model() as model: + + beta = pm.HalfCauchy('beta', 1) + gamma = pm.HalfCauchy('gamma', 1) + sigma = pm.HalfCauchy('sigma', 1, shape=2) + forward = ode_model( + odeparams=[ + beta, gamma], y0=[ + 0.99, 0.01]).reshape( + yobs.shape) + + y = pm.Lognormal('y', mu=pm.math.log( + forward), sd=sigma, observed=yobs) + + trace = pm.sample(100, tune=0) + + assert trace['beta'].size > 0 + assert trace['gamma'].size > 0 + assert trace['sigma'].size > 0 From 101fe7200aca1616b846aeb369b7faf06247171d Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Thu, 1 Aug 2019 16:34:24 -0400 Subject: [PATCH 10/45] re run existing ODE notebook to comare against pymc3.ode --- .../notebooks/ODE_parameter_estimation.ipynb | 321 ++++++++---------- 1 file changed, 143 insertions(+), 178 deletions(-) diff --git a/docs/source/notebooks/ODE_parameter_estimation.ipynb b/docs/source/notebooks/ODE_parameter_estimation.ipynb index 04cbb7ff77e..c4e4f9df731 100644 --- a/docs/source/notebooks/ODE_parameter_estimation.ipynb +++ b/docs/source/notebooks/ODE_parameter_estimation.ipynb @@ -4,7 +4,15 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING (theano.configdefaults): install mkl with `conda install mkl-service`: No module named 'mkl'\n" + ] + } + ], "source": [ "from scipy.integrate import odeint\n", "import numpy as np\n", @@ -332,7 +340,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -402,44 +410,13 @@ "Auto-assigning NUTS sampler...\n", "Initializing NUTS using adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", - "NUTS: [sigma, yto, xto, delta, gamma, beta, alpha]\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "51b6ca3e30814018b15692dfed658d5b", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, description='Sampling 2 chains', max=5000, style=ProgressStyle(description…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/osvaldo/anaconda3/lib/python3.7/site-packages/scipy/integrate/odepack.py:247: ODEintWarning: Repeated error test failures (internal error). Run with full_output = 1 to get quantitative information.\n", - " warnings.warn(warning_msg, ODEintWarning)\n", - "/home/osvaldo/anaconda3/lib/python3.7/site-packages/scipy/integrate/odepack.py:247: ODEintWarning: Excess work done on this call (perhaps wrong Dfun type). Run with full_output = 1 to get quantitative information.\n", - " warnings.warn(warning_msg, ODEintWarning)\n", - "/home/osvaldo/anaconda3/lib/python3.7/site-packages/scipy/integrate/odepack.py:247: ODEintWarning: Repeated error test failures (internal error). Run with full_output = 1 to get quantitative information.\n", + "NUTS: [sigma, yto, xto, delta, gamma, beta, alpha]\n", + "Sampling 2 chains, 0 divergences: 0%| | 0/5000 [00:00" ] @@ -518,6 +495,14 @@ "execution_count": 10, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/demetri/anaconda3/envs/gsoc/lib/python3.6/site-packages/pymc3/stats.py:991: FutureWarning: The join_axes-keyword is deprecated. Use .reindex or .reindex_like on the result to achieve the same functionality.\n", + " axis=1, join_axes=[dforg.index])\n" + ] + }, { "data": { "text/html": [ @@ -553,97 +538,97 @@ " \n", " \n", " alpha\n", - " 0.552456\n", - " 0.065637\n", - " 0.002289\n", - " 0.428681\n", - " 0.678782\n", - " 735.656650\n", - " 0.999878\n", + " 0.546238\n", + " 0.062607\n", + " 0.001882\n", + " 0.431009\n", + " 0.683215\n", + " 943.313994\n", + " 1.001490\n", " 0.549\n", " 0.065\n", " \n", " \n", " beta\n", - " 0.028047\n", - " 0.004369\n", - " 0.000153\n", - " 0.020097\n", - " 0.036484\n", - " 788.347157\n", - " 0.999785\n", + " 0.027682\n", + " 0.004183\n", + " 0.000121\n", + " 0.019921\n", + " 0.036197\n", + " 1038.814557\n", + " 1.000905\n", " 0.028\n", " 0.004\n", " \n", " \n", " gamma\n", - " 0.792733\n", - " 0.089938\n", - " 0.003068\n", - " 0.621923\n", - " 0.973234\n", - " 810.449110\n", - " 0.999962\n", + " 0.800985\n", + " 0.089085\n", + " 0.002686\n", + " 0.624201\n", + " 0.969263\n", + " 899.887191\n", + " 1.001295\n", " 0.797\n", " 0.091\n", " \n", " \n", " delta\n", - " 0.023821\n", - " 0.003547\n", - " 0.000112\n", - " 0.017602\n", - " 0.031104\n", - " 897.445670\n", - " 0.999911\n", + " 0.024174\n", + " 0.003591\n", + " 0.000106\n", + " 0.017432\n", + " 0.031091\n", + " 903.692124\n", + " 1.001325\n", " 0.024\n", " 0.004\n", " \n", " \n", " xto\n", - " 34.039379\n", - " 3.016263\n", - " 0.064226\n", - " 28.193732\n", - " 40.092932\n", - " 2089.061030\n", - " 0.999853\n", + " 33.958321\n", + " 2.995589\n", + " 0.065663\n", + " 28.476836\n", + " 40.251438\n", + " 2216.184676\n", + " 0.999667\n", " 33.960\n", " 2.909\n", " \n", " \n", " yto\n", - " 5.953507\n", - " 0.521353\n", - " 0.012523\n", - " 5.027723\n", - " 7.023803\n", - " 1696.227658\n", - " 1.000744\n", + " 5.954806\n", + " 0.528449\n", + " 0.011694\n", + " 4.940673\n", + " 6.990385\n", + " 1583.237072\n", + " 0.999951\n", " 5.949\n", " 0.533\n", " \n", " \n", " sigma__0\n", - " 0.249232\n", - " 0.044163\n", - " 0.000950\n", - " 0.177959\n", - " 0.340757\n", - " 2200.725278\n", - " 0.999702\n", + " 0.248752\n", + " 0.044778\n", + " 0.000940\n", + " 0.174250\n", + " 0.341214\n", + " 1984.170678\n", + " 0.999723\n", " 0.248\n", " 0.045\n", " \n", " \n", " sigma__1\n", - " 0.251609\n", - " 0.043279\n", - " 0.000791\n", - " 0.178921\n", - " 0.338763\n", - " 2199.754925\n", - " 1.000951\n", + " 0.252926\n", + " 0.044053\n", + " 0.000971\n", + " 0.175737\n", + " 0.337417\n", + " 2414.840347\n", + " 1.000093\n", " 0.252\n", " 0.044\n", " \n", @@ -653,24 +638,24 @@ ], "text/plain": [ " mean sd mc_error hpd_2.5 hpd_97.5 n_eff \\\n", - "alpha 0.552456 0.065637 0.002289 0.428681 0.678782 735.656650 \n", - "beta 0.028047 0.004369 0.000153 0.020097 0.036484 788.347157 \n", - "gamma 0.792733 0.089938 0.003068 0.621923 0.973234 810.449110 \n", - "delta 0.023821 0.003547 0.000112 0.017602 0.031104 897.445670 \n", - "xto 34.039379 3.016263 0.064226 28.193732 40.092932 2089.061030 \n", - "yto 5.953507 0.521353 0.012523 5.027723 7.023803 1696.227658 \n", - "sigma__0 0.249232 0.044163 0.000950 0.177959 0.340757 2200.725278 \n", - "sigma__1 0.251609 0.043279 0.000791 0.178921 0.338763 2199.754925 \n", + "alpha 0.546238 0.062607 0.001882 0.431009 0.683215 943.313994 \n", + "beta 0.027682 0.004183 0.000121 0.019921 0.036197 1038.814557 \n", + "gamma 0.800985 0.089085 0.002686 0.624201 0.969263 899.887191 \n", + "delta 0.024174 0.003591 0.000106 0.017432 0.031091 903.692124 \n", + "xto 33.958321 2.995589 0.065663 28.476836 40.251438 2216.184676 \n", + "yto 5.954806 0.528449 0.011694 4.940673 6.990385 1583.237072 \n", + "sigma__0 0.248752 0.044778 0.000940 0.174250 0.341214 1984.170678 \n", + "sigma__1 0.252926 0.044053 0.000971 0.175737 0.337417 2414.840347 \n", "\n", " Rhat STAN_mus STAN_sds \n", - "alpha 0.999878 0.549 0.065 \n", - "beta 0.999785 0.028 0.004 \n", - "gamma 0.999962 0.797 0.091 \n", - "delta 0.999911 0.024 0.004 \n", - "xto 0.999853 33.960 2.909 \n", - "yto 1.000744 5.949 0.533 \n", - "sigma__0 0.999702 0.248 0.045 \n", - "sigma__1 1.000951 0.252 0.044 " + "alpha 1.001490 0.549 0.065 \n", + "beta 1.000905 0.028 0.004 \n", + "gamma 1.001295 0.797 0.091 \n", + "delta 1.001325 0.024 0.004 \n", + "xto 0.999667 33.960 2.909 \n", + "yto 0.999951 5.949 0.533 \n", + "sigma__0 0.999723 0.248 0.045 \n", + "sigma__1 1.000093 0.252 0.044 " ] }, "execution_count": 10, @@ -704,29 +689,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/osvaldo/proyectos/00_PyMC3/pymc3/pymc3/sampling.py:1100: UserWarning: samples parameter is smaller than nchains times ndraws, some draws and/or chains may not be represented in the returned posterior predictive sample\n", - " warnings.warn(\"samples parameter is smaller than nchains times ndraws, some draws \"\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "4fe97ab2eb4b4fe2ab49bc1ca5cfdb7d", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, max=500), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" + "/Users/demetri/anaconda3/envs/gsoc/lib/python3.6/site-packages/pymc3/sampling.py:1109: UserWarning: samples parameter is smaller than nchains times ndraws, some draws and/or chains may not be represented in the returned posterior predictive sample\n", + " warnings.warn(\"samples parameter is smaller than nchains times ndraws, some draws \"\n", + "100%|██████████| 500/500 [00:05<00:00, 91.69it/s] \n" ] } ], @@ -744,7 +709,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -851,7 +816,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -942,23 +907,23 @@ "text": [ "Sample initial stage: ...\n", "Stage: 0 Beta: 0.009 Steps: 25\n", - "100%|██████████| 1000/1000 [00:55<00:00, 17.88it/s]\n", - "Stage: 1 Beta: 0.015 Steps: 9\n", - "100%|██████████| 1000/1000 [00:26<00:00, 37.05it/s]\n", + "100%|██████████| 1000/1000 [00:42<00:00, 23.70it/s]\n", + "Stage: 1 Beta: 0.014 Steps: 9\n", + "100%|██████████| 1000/1000 [00:19<00:00, 51.19it/s]\n", "Stage: 2 Beta: 0.019 Steps: 5\n", - "100%|██████████| 1000/1000 [00:17<00:00, 56.88it/s]\n", - "Stage: 3 Beta: 0.028 Steps: 13\n", - "100%|██████████| 1000/1000 [00:58<00:00, 17.02it/s]\n", - "Stage: 4 Beta: 0.054 Steps: 4\n", - "100%|██████████| 1000/1000 [00:18<00:00, 52.84it/s]\n", - "Stage: 5 Beta: 0.114 Steps: 10\n", - "100%|██████████| 1000/1000 [00:52<00:00, 26.37it/s]\n", - "Stage: 6 Beta: 0.239 Steps: 4\n", - "100%|██████████| 1000/1000 [00:21<00:00, 46.46it/s]\n", - "Stage: 7 Beta: 0.496 Steps: 8\n", - "100%|██████████| 1000/1000 [00:36<00:00, 27.21it/s]\n", + "100%|██████████| 1000/1000 [00:13<00:00, 75.69it/s]\n", + "Stage: 3 Beta: 0.028 Steps: 14\n", + "100%|██████████| 1000/1000 [00:46<00:00, 21.71it/s]\n", + "Stage: 4 Beta: 0.053 Steps: 4\n", + "100%|██████████| 1000/1000 [00:13<00:00, 73.70it/s]\n", + "Stage: 5 Beta: 0.111 Steps: 8\n", + "100%|██████████| 1000/1000 [00:27<00:00, 36.49it/s]\n", + "Stage: 6 Beta: 0.237 Steps: 4\n", + "100%|██████████| 1000/1000 [00:13<00:00, 73.44it/s]\n", + "Stage: 7 Beta: 0.519 Steps: 8\n", + "100%|██████████| 1000/1000 [00:27<00:00, 36.05it/s]\n", "Stage: 8 Beta: 1.000 Steps: 4\n", - "100%|██████████| 1000/1000 [00:20<00:00, 49.45it/s]\n" + "100%|██████████| 1000/1000 [00:13<00:00, 71.96it/s]\n" ] } ], @@ -991,7 +956,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1052,38 +1017,38 @@ " \n", " \n", " a\n", - " 0.230932\n", - " 0.017052\n", - " 0.000531\n", - " 0.201126\n", - " 0.266330\n", + " 0.231128\n", + " 0.016112\n", + " 0.000470\n", + " 0.199191\n", + " 0.261736\n", " 0.2\n", " \n", " \n", " b\n", - " 0.236115\n", - " 0.080920\n", - " 0.002661\n", - " 0.094373\n", - " 0.397491\n", + " 0.232353\n", + " 0.073796\n", + " 0.002175\n", + " 0.092065\n", + " 0.368774\n", " 0.2\n", " \n", " \n", " c\n", - " 2.920302\n", - " 0.035240\n", - " 0.001100\n", - " 2.853546\n", - " 2.991818\n", + " 2.923832\n", + " 0.033734\n", + " 0.001033\n", + " 2.859648\n", + " 2.989395\n", " 3.0\n", " \n", " \n", " sigma\n", - " 0.478180\n", - " 0.016855\n", - " 0.000528\n", - " 0.443860\n", - " 0.509162\n", + " 0.478079\n", + " 0.017448\n", + " 0.000581\n", + " 0.444733\n", + " 0.511978\n", " 0.5\n", " \n", " \n", @@ -1092,10 +1057,10 @@ ], "text/plain": [ " mean sd mc_error hpd_2.5 hpd_97.5 True values\n", - "a 0.230932 0.017052 0.000531 0.201126 0.266330 0.2\n", - "b 0.236115 0.080920 0.002661 0.094373 0.397491 0.2\n", - "c 2.920302 0.035240 0.001100 2.853546 2.991818 3.0\n", - "sigma 0.478180 0.016855 0.000528 0.443860 0.509162 0.5" + "a 0.231128 0.016112 0.000470 0.199191 0.261736 0.2\n", + "b 0.232353 0.073796 0.002175 0.092065 0.368774 0.2\n", + "c 2.923832 0.033734 0.001033 2.859648 2.989395 3.0\n", + "sigma 0.478079 0.017448 0.000581 0.444733 0.511978 0.5" ] }, "execution_count": 18, @@ -1129,7 +1094,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1207,7 +1172,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.6.9" } }, "nbformat": 4, From 90f6e50580c0596f6f8637f4f88651c73d062e8a Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Fri, 2 Aug 2019 14:10:56 -0400 Subject: [PATCH 11/45] Add notebook for DifferentialEquation --- ...ayesian_estimation_of_ode_parameters.ipynb | 591 ++++++++++++++++++ 1 file changed, 591 insertions(+) create mode 100644 docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb diff --git a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb new file mode 100644 index 00000000000..6ea5d77a14a --- /dev/null +++ b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb @@ -0,0 +1,591 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING (theano.configdefaults): install mkl with `conda install mkl-service`: No module named 'mkl'\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running on PyMC3 v3.7\n" + ] + } + ], + "source": [ + "%matplotlib inline\n", + "import pymc3 as pm\n", + "from pymc3.ode import DifferentialEquation\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.integrate import odeint\n", + "import arviz as az\n", + "import theano\n", + "theano.config.compute_test_value = \"ignore\"\n", + "\n", + "plt.style.use('seaborn-darkgrid')\n", + "print('Running on PyMC3 v{}'.format(pm.__version__))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bayesian Estimation of ODE Parameters\n", + "\n", + "Ordinary differential equations (ODEs) are a convenient mathematical framework for modelling the temporal dynamics of a system in disciplines from engineering to ecology. Though most analyses focus on bifurcations and stability of fixed points, parameter and uncertainty estimates are more salient in systems of practical interest, such as population pharmacokinetics and pharmacodynamics.\n", + "\n", + "\n", + "Both parameter estimation and uncertainty propagation are handled elegantly by the Bayesian framework. In this notebook, I showcase how pyMC3 can be used to do inference for differential equations using the `ode` submodual. \n", + "\n", + "\n", + "# Catching Up On Differential Equations\n", + "\n", + "A differential equation is an equation relating an unknown function's derivative to itself. We usually write differentual equations as \n", + "\n", + "$$ \\mathbf{y}' = f(\\mathbf{y},t,\\mathbf{p}) \\quad \\mathbf{y}(t_0) = \\mathbf{y}_0 $$\n", + "\n", + "Here, $\\mathbf{y}$ is the unknown function, $t$ is time, and $\\mathbf{p}$ is a vector of parameters. The function $f$ can be either scalar or vector valued.\n", + "\n", + "Only a small subset of differential equations have an analytical solution. For most differential equations of applied interest, numerical methods must be used to obtain approximate solutions.\n", + "\n", + "\n", + "# Doing Bayesian Inference With Differential Equations\n", + "\n", + "PyMC3 uses Hamiltonian Monte Carlo (HMC) to obtain samples from the posterior distribution. HMC requires derivatives of the ODE's solution with respect to the paramteres $p$. The `ode` submodual automatically computes appropriate derivatives so you don't have to. All you have to do is \n", + "\n", + "* Write the differential equation as a python function\n", + "* Write the model in PyMC3\n", + "* Hit the Inference Button $^{\\text{TM}}$\n", + "\n", + "Let's see how this is done in practice with a small example.\n", + "\n", + "# A Differential Equation For Freefall\n", + "\n", + "An object of mass $m$ is brought to some height and allowed to fall freely until it reaches the ground. A differential equation describing the object's speed over time is \n", + "\n", + "$$ y' = mg - \\gamma y $$\n", + "\n", + "The force the object experiences in the downwards direction is $mg$, while the forece the object experiences in the opposite direction (due to air resistence) is proportional to how fast the object is presently moving. Let's assume the object starts from rest (that is, that the object's inital velocity is 0). This may or may not be the case. To showcase how to do inference on intial conditions, I will first assume the object starts from rest, and then relax that assumption later.\n", + "\n", + "Data on this object's speed as a function of time is shown below. The data may be noisy because of our measurement tools, or because the object is an irregular shape, thus leading to times furing freefall when the object is more/less aerodynamic. Let's use this data to estimate the proportionality constant for air restistance.\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#For reproducibility\n", + "np.random.seed(19920908)\n", + "\n", + "def freefall(y,t,p):\n", + " \n", + " return 2.0*p[1] - p[0]*y[0]\n", + "\n", + "#Times for observation\n", + "times = np.arange(0,10,0.5)\n", + "gamma,g, y0, sigma = 0.4, 9.8, -2, 2\n", + "y = odeint(freefall, t = times, y0 = y0, args = tuple([[gamma,g]]))\n", + "yobs = np.random.normal(y,2)\n", + "\n", + "fig, ax = plt.subplots(dpi = 120)\n", + "plt.plot(times,yobs, label = 'observed speed', linestyle = 'dashed', marker = 'o', color='red')\n", + "plt.plot(times,y, label = 'True speed', color ='k', alpha = 0.5)\n", + "plt.legend()\n", + "plt.xlabel('Time (Seconds)')\n", + "plt.ylabel(r'$y(t)$');\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To specify and ordinary differential equation with pyMC3, use the `DifferentialEquation` class. This class takes as arguments:\n", + "\n", + "* `func`: A function specifying the differential equation (i.e. $f(\\mathbf{y},t,\\mathbf{p})$)\n", + "* `t0`: The time for which the initial condition belongs\n", + "* `times`: A monotonically increasing or decreasing array of times at which data was observed.\n", + "* `n_odeparams`: The dimension of $\\mathbf{p}$.\n", + "* `n_states`: The dimension of $f(\\mathbf{y},t,\\mathbf{p})$\n", + "\n", + "Once the model is specified, we can use it in our pyMC3 model by passing paramerters and inital conditions. \n", + "\n", + "Shown below is a model to estimate $\\gamma$ in the ODE above." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Auto-assigning NUTS sampler...\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (2 chains in 2 jobs)\n", + "NUTS: [gamma, sigma]\n", + "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [01:52<00:00, 53.56draws/s]\n", + "100%|██████████| 4000/4000 [00:37<00:00, 107.10it/s]\n" + ] + } + ], + "source": [ + "ode_model = DifferentialEquation(func = freefall,\n", + " t0 = 0,\n", + " times = times,\n", + " n_odeparams=2, \n", + " n_states = 1)\n", + "\n", + "with pm.Model() as model:\n", + " \n", + " sigma= pm.HalfCauchy('sigma',1)\n", + " \n", + " gamma = pm.Lognormal('gamma',0,1)\n", + " \n", + " #If we know one of the parameter values, we can simply pass the value.\n", + " #No need to specify a prior.\n", + " ode_solution = ode_model(odeparams = [gamma, 9.8], y0 = [0]).reshape(yobs.shape)\n", + " \n", + " Y = pm.Normal('Y', mu = ode_solution, sd = sigma, observed = yobs)\n", + " \n", + " trace = pm.sample(2000,tune = 1000)\n", + " prior = pm.sample_prior_predictive()\n", + " posterior_predictive = pm.sample_posterior_predictive(trace)\n", + " \n", + " data = az.from_pymc3(trace = trace,\n", + " prior = prior,\n", + " posterior_predictive = posterior_predictive)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "az.plot_posterior(data);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our estimates of the proportionality constant and noise in the system are incredibly close to their actual values!\n", + "\n", + "We can even estimate the acceleration due to gravity by specifying a prior for it." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Auto-assigning NUTS sampler...\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (2 chains in 2 jobs)\n", + "NUTS: [g, gamma, sigma]\n", + "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [08:11<00:00, 4.68draws/s]\n", + "100%|██████████| 4000/4000 [00:38<00:00, 103.13it/s]\n" + ] + } + ], + "source": [ + "with pm.Model() as model2:\n", + " \n", + " sigma= pm.HalfCauchy('sigma',1)\n", + " gamma = pm.Lognormal('gamma',0,1)\n", + " #A prior on the acceleration due to gravity\n", + " g = pm.Lognormal('g',pm.math.log(10),2)\n", + " \n", + " #Notice now I have passed g to the odeparams argument\n", + " ode_solution = ode_model(odeparams = [gamma, g], y0 = [0]).reshape(yobs.shape)\n", + " \n", + " Y = pm.Normal('Y', mu = ode_solution, sd = sigma, observed = yobs)\n", + "\n", + " \n", + " trace = pm.sample(2000,tune = 1000, target_accept = 0.9)\n", + " prior = pm.sample_prior_predictive()\n", + " posterior_predictive = pm.sample_posterior_predictive(trace)\n", + " \n", + " data = az.from_pymc3(trace = trace,\n", + " prior = prior,\n", + " posterior_predictive = posterior_predictive)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([,\n", + " ,\n", + " ],\n", + " dtype=object)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "az.plot_posterior(data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The uncertainty in the acceleration due to gravity has increased our uncertainty in the prportionality constant.\n", + "\n", + "Finally, we can do inference on the initial condition. If this object was brought to it's inital height by an airplane, then turbulent air might have made the airplane move up or down, thereby changing the inital velocioty of the object. \n", + "\n", + "Doing inference on the inital condition is as easy as specifying a prior for the inital condition, and then passing the inital condition to `ode_model`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Auto-assigning NUTS sampler...\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (2 chains in 2 jobs)\n", + "NUTS: [y0, g, gamma, sigma]\n", + "Sampling 2 chains, 0 divergences: 0%| | 0/6000 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "az.plot_posterior(data, figsize = (13,3));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that by explicitly modelling the initial condition, we obtain a much better estimate of the acceleration due to gravity than if we had insisted that the object started at rest." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Non-linear Differential Equations\n", + "\n", + "The example of an object in free fall might not be the most appropriate since that differential equation can be solved exactly. Thus, `DifferentialEquation` is not needed to solve that particular problem. There are, however, many examples of differential equations which cannot be solved exactly. Inference for these models is where `DifferentialEquation` truly shines.\n", + "\n", + "Consider the SIR model of infection. This model describes the temporal dynamics of a disease spreading through a homogenously mixed, closed population. Members of the population are placed into one of three cateories: Susceptible, Infective, or Recovered. The differential equations are...\n", + "\n", + "\n", + "$$ \\dfrac{dS}{dt} = - \\beta SI \\quad S(0) = S_0 $$\n", + "$$ \\dfrac{dI}{dt} = \\beta SI - \\lambda I \\quad I(0) = I_0 $$\n", + "$$ \\dfrac{dR}{dt} = \\lambda I \\quad R(0) = R_0 $$\n", + "\n", + "With the constraint that $S(t) + I(t) + R(t) = 1 \\, \\forall t$. Here, $\\beta$ is the rate of infection per susceptible and per infective, and $\\lambda$ is the rate of recovery.\n", + "\n", + "If we knew $S(t)$ and $I(t)$, then we could determine $R(t)$, so we can peel off the differential equation for $R(t)$ and work only with the first two. \n", + "\n", + "\n", + "In the SIR model, it is straight-forward to see that $\\beta, \\gamma$ and $\\beta/2, \\gamma/2$ will produce the same qualitative dynamics but on much different time scales. To study the *quality* of the dynamics, regardless of time scale, applied mathematicians will *non-dimensionalize* differential equations. Non-dimensionalization is the process of introducing scaleless variables into the differential equation to understand the system's dynamics under families of paramterizations.\n", + "\n", + "To non-dimensionalize this system, let's scale time by $1/\\lambda$, the rate of recovery (we do this because people stay infected for an average of $1/\\lambda$ units of time. It is a straight forward argument to show this. For more, see CITE). Let $t = \\tau/\\lambda$, where $\\tau$ is a unitless variable. Then...\n", + "\n", + "\n", + "$$ \\dfrac{dS}{d\\tau} = \\dfrac{dt}{d\\tau} \\dfrac{dS}{dt} = \\dfrac{1}{\\lambda}\\dfrac{dS}{dt} = -\\dfrac{\\beta}{\\lambda}SI$$\n", + "\n", + "and \n", + "\n", + "$$ \\dfrac{dI}{d\\tau} = \\dfrac{dt}{d\\tau} \\dfrac{dI}{dt} = \\dfrac{1}{\\lambda}\\dfrac{dI}{dt} = \\dfrac{\\beta}{\\lambda}SI - I$$\n", + "\n", + "The quantity $\\beta/\\lambda$ has a very special name. We call it *The R-Nought* (\\$\\mathcal{R}_0$). It's interpretation is that if we were to drop a single infected person into a population of suceptible individuals, we would expect $\\mathcal{R}_0$ new infections. If $\\mathcal{R}_0>1$, then an epidemic will take place. If $\\mathcal{R}_0\\leq1$ then there will be no epidemic (note, we can show this more rigoursly by studying eigenvalues of the system's Jacobain. For more, see CITE).\n", + "\n", + "This non-dimensionalization is important because it gives us information about the parameters. If we see an epidemic has occured, then we know that $\\mathcal{R}_0>1$ which means $\\beta> \\lambda$. Furthermore, it might be hard to place a prior on $\\beta$ because of beta's interpretation. But since we $1/\\lambda$ has a simple interpretation, and since $\\mathcal{R}_0>1$, we can obtain $\\beta$ by computing $\\mathcal{R}_0\\lambda$. \n", + "\n", + "Side note: I'm going to choose a likelihood which certainly violates these constraints, just for exposition on how to use `DifferentialEquation`. In reality, a likelihood which respects these constraints should be chosen.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def SIR(y,t,p):\n", + " \n", + " ds = -p[0]*y[0]*y[1]\n", + " di = p[0]*y[0]*y[1] - p[1]*y[1]\n", + " \n", + " return [ds,di]\n", + "\n", + "times = np.arange(0,5,0.25)\n", + "\n", + "beta,gamma = 4,1.0\n", + "#Create true curves\n", + "y = odeint(SIR, t = times, y0 = [0.99, 0.01], args = tuple([[beta,gamma]]), rtol=1e-8 )\n", + "#Observational model. Lognormal likelihood isn't appropriate, but we'll do it anyway\n", + "yobs = np.random.lognormal(mean = np.log(y[1::]), sigma = [0.2, 0.3])\n", + "\n", + "\n", + "plt.plot(times[1::],yobs, marker = 'o', linestyle = 'none')\n", + "plt.plot(times, y[:,0], color = 'C0', alpha = 0.5, label = f'$S(t)$')\n", + "plt.plot(times, y[:,1], color = 'C1', alpha = 0.5, label = f'$I(t)$')\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Auto-assigning NUTS sampler...\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (2 chains in 2 jobs)\n", + "NUTS: [lambda, R0, sigma]\n", + "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [19:52<00:00, 3.53draws/s] \n", + "100%|██████████| 4000/4000 [02:19<00:00, 28.76it/s]\n" + ] + } + ], + "source": [ + "theano.config.compute_test_value = \"ignore\"\n", + "sir_model = DifferentialEquation(func = SIR,\n", + " times = np.arange(0.25, 5, 0.25), \n", + " t0 = 0,\n", + " n_states = 2,\n", + " n_odeparams=2)\n", + "\n", + "with pm.Model() as model4:\n", + " \n", + " sigma = pm.HalfCauchy('sigma',1, shape = 2)\n", + " \n", + " #R0 is bounded below by 1 because we see an epidemic has occured\n", + " R0 = pm.Bound(pm.Normal, lower = 1)('R0', 2,3)\n", + " lam = pm.Lognormal('lambda',pm.math.log(2),2)\n", + " beta = pm.Deterministic('beta', lam*R0)\n", + "\n", + " \n", + " sir_curves = sir_model(odeparams = [beta, lam], y0 = [0.99, 0.01]).reshape(yobs.shape)\n", + " \n", + " Y = pm.Lognormal('Y', mu = pm.math.log(sir_curves), sd = sigma, observed = yobs)\n", + " trace = pm.sample(2000,tune = 1000, target_accept = 0.9)\n", + " prior = pm.sample_prior_predictive()\n", + " posterior_predictive = pm.sample_posterior_predictive(trace)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "data = az.from_pymc3(trace = trace,\n", + " prior = prior,\n", + " posterior_predictive = posterior_predictive)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "az.plot_posterior(data,round_to = 2, credible_interval=0.95);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As can be seen from the posterior plots, $\\beta$ is well estimated by leveraging knoweldege about the non-dimensional parameter $\\mathcal{R}_0$ and $\\lambda$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Conclusions & Final Thoughts\n", + "\n", + "ODEs are a really good model for continuous temporal evolution. With the addition of `DifferentialEquation` to PyMC3, we can now use bayesian methods to estimate the parameters of ODEs.\n", + "\n", + "`DifferentialEquation` is not as fast as compared to Stan's `integrate_ode_bdf`. However, the ease of use of `DifferentialEquation` will allow practioners to get up and running much quicker with Bayesian estimation for ODEs than Stan (which has a steep learning curve). " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From dca35841cf4183676c28ee6b1aeaf54f493bc845 Mon Sep 17 00:00:00 2001 From: Demetri Date: Fri, 2 Aug 2019 15:45:10 -0400 Subject: [PATCH 12/45] Change test conditions Added @pytest.mark.xfail(condition=(theano.config.floatX == "float32"), reason="Fails on float32") --- pymc3/tests/test_ode.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/pymc3/tests/test_ode.py b/pymc3/tests/test_ode.py index a359f8a9ced..6e8cc8c9552 100644 --- a/pymc3/tests/test_ode.py +++ b/pymc3/tests/test_ode.py @@ -10,6 +10,9 @@ import pytest +@pytest.mark.xfail( + condition=(theano.config.floatX == "float32"), reason="Fails on float32" +) def test_gradients(): with theano.configparser.change_flags(compute_test_value='off'): '''Tests the computation of the sensitivities from the theano computation graph''' @@ -53,6 +56,9 @@ def augmented_system(Y, t, p): sensitivity, simulated_sensitivity, rtol=1e-5) +@pytest.mark.xfail( + condition=(theano.config.floatX == "float32"), reason="Fails on float32" +) def test_simulate(): with theano.configparser.change_flags(compute_test_value='off'): '''Tests the integration in DifferentialEquation''' @@ -79,6 +85,9 @@ def ode_func(y, t, p): np.testing.assert_allclose(y, simulated_y, rtol=1e-5) +@pytest.mark.xfail( + condition=(theano.config.floatX == "float32"), reason="Fails on float32" +) class TestSensitivityInitialCondition(object): t = np.arange(0, 12, 0.25).reshape(-1, 1) @@ -200,6 +209,9 @@ def ode_func_5(y, t, p): model5._make_sens_ic()) +@pytest.mark.xfail( + condition=(theano.config.floatX == "float32"), reason="Fails on float32" +) def test_logp_scalar_ode(): with theano.configparser.change_flags(compute_test_value='off'): @@ -255,6 +267,9 @@ def system_1(y, t, p): np.testing.assert_allclose(manual_logp, pymc3_logp) +@pytest.mark.xfail( + condition=(theano.config.floatX == "float32"), reason="Fails on float32" +) class TestErrors(object): '''Test running model for a scalar ODE with 1 parameter''' @@ -287,6 +302,9 @@ def test_too_few_y0(self): self.ode_model(odeparams=[1], y0=[]) +@pytest.mark.xfail( + condition=(theano.config.floatX == "float32"), reason="Fails on float32" +) class TestDiffEqModel(object): def test_scalar_ode_1_param(self): From 70e2fd4b811109c74705c625762f7971e4665f63 Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Fri, 2 Aug 2019 16:17:01 -0400 Subject: [PATCH 13/45] remove pytest decorator Adding dectorator actually made coverage worse. --- pymc3/tests/test_ode.py | 23 +++++------------------ 1 file changed, 5 insertions(+), 18 deletions(-) diff --git a/pymc3/tests/test_ode.py b/pymc3/tests/test_ode.py index 6e8cc8c9552..7e9a733e46b 100644 --- a/pymc3/tests/test_ode.py +++ b/pymc3/tests/test_ode.py @@ -10,9 +10,7 @@ import pytest -@pytest.mark.xfail( - condition=(theano.config.floatX == "float32"), reason="Fails on float32" -) + def test_gradients(): with theano.configparser.change_flags(compute_test_value='off'): '''Tests the computation of the sensitivities from the theano computation graph''' @@ -56,9 +54,7 @@ def augmented_system(Y, t, p): sensitivity, simulated_sensitivity, rtol=1e-5) -@pytest.mark.xfail( - condition=(theano.config.floatX == "float32"), reason="Fails on float32" -) + def test_simulate(): with theano.configparser.change_flags(compute_test_value='off'): '''Tests the integration in DifferentialEquation''' @@ -85,9 +81,6 @@ def ode_func(y, t, p): np.testing.assert_allclose(y, simulated_y, rtol=1e-5) -@pytest.mark.xfail( - condition=(theano.config.floatX == "float32"), reason="Fails on float32" -) class TestSensitivityInitialCondition(object): t = np.arange(0, 12, 0.25).reshape(-1, 1) @@ -209,9 +202,7 @@ def ode_func_5(y, t, p): model5._make_sens_ic()) -@pytest.mark.xfail( - condition=(theano.config.floatX == "float32"), reason="Fails on float32" -) + def test_logp_scalar_ode(): with theano.configparser.change_flags(compute_test_value='off'): @@ -267,9 +258,7 @@ def system_1(y, t, p): np.testing.assert_allclose(manual_logp, pymc3_logp) -@pytest.mark.xfail( - condition=(theano.config.floatX == "float32"), reason="Fails on float32" -) + class TestErrors(object): '''Test running model for a scalar ODE with 1 parameter''' @@ -302,9 +291,7 @@ def test_too_few_y0(self): self.ode_model(odeparams=[1], y0=[]) -@pytest.mark.xfail( - condition=(theano.config.floatX == "float32"), reason="Fails on float32" -) + class TestDiffEqModel(object): def test_scalar_ode_1_param(self): From abc1016bb9d3f955f4a009b49e2f06236076892a Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Fri, 2 Aug 2019 18:08:16 -0400 Subject: [PATCH 14/45] Added citations in notebook. --- ...ayesian_estimation_of_ode_parameters.ipynb | 21 +++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-) diff --git a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb index 6ea5d77a14a..a1c17154f01 100644 --- a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb +++ b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb @@ -403,7 +403,7 @@ "\n", "In the SIR model, it is straight-forward to see that $\\beta, \\gamma$ and $\\beta/2, \\gamma/2$ will produce the same qualitative dynamics but on much different time scales. To study the *quality* of the dynamics, regardless of time scale, applied mathematicians will *non-dimensionalize* differential equations. Non-dimensionalization is the process of introducing scaleless variables into the differential equation to understand the system's dynamics under families of paramterizations.\n", "\n", - "To non-dimensionalize this system, let's scale time by $1/\\lambda$, the rate of recovery (we do this because people stay infected for an average of $1/\\lambda$ units of time. It is a straight forward argument to show this. For more, see CITE). Let $t = \\tau/\\lambda$, where $\\tau$ is a unitless variable. Then...\n", + "To non-dimensionalize this system, let's scale time by $1/\\lambda$, the rate of recovery (we do this because people stay infected for an average of $1/\\lambda$ units of time. It is a straight forward argument to show this. For more, see [1]). Let $t = \\tau/\\lambda$, where $\\tau$ is a unitless variable. Then...\n", "\n", "\n", "$$ \\dfrac{dS}{d\\tau} = \\dfrac{dt}{d\\tau} \\dfrac{dS}{dt} = \\dfrac{1}{\\lambda}\\dfrac{dS}{dt} = -\\dfrac{\\beta}{\\lambda}SI$$\n", @@ -412,7 +412,7 @@ "\n", "$$ \\dfrac{dI}{d\\tau} = \\dfrac{dt}{d\\tau} \\dfrac{dI}{dt} = \\dfrac{1}{\\lambda}\\dfrac{dI}{dt} = \\dfrac{\\beta}{\\lambda}SI - I$$\n", "\n", - "The quantity $\\beta/\\lambda$ has a very special name. We call it *The R-Nought* (\\$\\mathcal{R}_0$). It's interpretation is that if we were to drop a single infected person into a population of suceptible individuals, we would expect $\\mathcal{R}_0$ new infections. If $\\mathcal{R}_0>1$, then an epidemic will take place. If $\\mathcal{R}_0\\leq1$ then there will be no epidemic (note, we can show this more rigoursly by studying eigenvalues of the system's Jacobain. For more, see CITE).\n", + "The quantity $\\beta/\\lambda$ has a very special name. We call it *The R-Nought* (\\$\\mathcal{R}_0$). It's interpretation is that if we were to drop a single infected person into a population of suceptible individuals, we would expect $\\mathcal{R}_0$ new infections. If $\\mathcal{R}_0>1$, then an epidemic will take place. If $\\mathcal{R}_0\\leq1$ then there will be no epidemic (note, we can show this more rigoursly by studying eigenvalues of the system's Jacobain. For more, see [2]).\n", "\n", "This non-dimensionalization is important because it gives us information about the parameters. If we see an epidemic has occured, then we know that $\\mathcal{R}_0>1$ which means $\\beta> \\lambda$. Furthermore, it might be hard to place a prior on $\\beta$ because of beta's interpretation. But since we $1/\\lambda$ has a simple interpretation, and since $\\mathcal{R}_0>1$, we can obtain $\\beta$ by computing $\\mathcal{R}_0\\lambda$. \n", "\n", @@ -565,6 +565,23 @@ "\n", "`DifferentialEquation` is not as fast as compared to Stan's `integrate_ode_bdf`. However, the ease of use of `DifferentialEquation` will allow practioners to get up and running much quicker with Bayesian estimation for ODEs than Stan (which has a steep learning curve). " ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# References\n", + "\n", + "1. Earn, D. J., et al. Mathematical epidemiology. Berlin: Springer, 2008.\n", + "2. Britton, Nicholas F. Essential mathematical biology. Springer Science & Business Media, 2012.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 5f2d63f9d501e185d25358effbcc863992eea869 Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Fri, 2 Aug 2019 18:10:59 -0400 Subject: [PATCH 15/45] An errant / might be cause of formatting issue --- .../notebooks/bayesian_estimation_of_ode_parameters.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb index a1c17154f01..be6a597e063 100644 --- a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb +++ b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb @@ -412,7 +412,7 @@ "\n", "$$ \\dfrac{dI}{d\\tau} = \\dfrac{dt}{d\\tau} \\dfrac{dI}{dt} = \\dfrac{1}{\\lambda}\\dfrac{dI}{dt} = \\dfrac{\\beta}{\\lambda}SI - I$$\n", "\n", - "The quantity $\\beta/\\lambda$ has a very special name. We call it *The R-Nought* (\\$\\mathcal{R}_0$). It's interpretation is that if we were to drop a single infected person into a population of suceptible individuals, we would expect $\\mathcal{R}_0$ new infections. If $\\mathcal{R}_0>1$, then an epidemic will take place. If $\\mathcal{R}_0\\leq1$ then there will be no epidemic (note, we can show this more rigoursly by studying eigenvalues of the system's Jacobain. For more, see [2]).\n", + "The quantity $\\beta/\\lambda$ has a very special name. We call it *The R-Nought* ($\\mathcal{R}_0$). It's interpretation is that if we were to drop a single infected person into a population of suceptible individuals, we would expect $\\mathcal{R}_0$ new infections. If $\\mathcal{R}_0>1$, then an epidemic will take place. If $\\mathcal{R}_0\\leq1$ then there will be no epidemic (note, we can show this more rigoursly by studying eigenvalues of the system's Jacobain. For more, see [2]).\n", "\n", "This non-dimensionalization is important because it gives us information about the parameters. If we see an epidemic has occured, then we know that $\\mathcal{R}_0>1$ which means $\\beta> \\lambda$. Furthermore, it might be hard to place a prior on $\\beta$ because of beta's interpretation. But since we $1/\\lambda$ has a simple interpretation, and since $\\mathcal{R}_0>1$, we can obtain $\\beta$ by computing $\\mathcal{R}_0\\lambda$. \n", "\n", From 11e9ca559fe13294755818f847279001ad70e55c Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Fri, 2 Aug 2019 20:09:00 -0400 Subject: [PATCH 16/45] added a word to SIR example. --- .../notebooks/bayesian_estimation_of_ode_parameters.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb index be6a597e063..6d282f9aa7a 100644 --- a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb +++ b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb @@ -414,7 +414,7 @@ "\n", "The quantity $\\beta/\\lambda$ has a very special name. We call it *The R-Nought* ($\\mathcal{R}_0$). It's interpretation is that if we were to drop a single infected person into a population of suceptible individuals, we would expect $\\mathcal{R}_0$ new infections. If $\\mathcal{R}_0>1$, then an epidemic will take place. If $\\mathcal{R}_0\\leq1$ then there will be no epidemic (note, we can show this more rigoursly by studying eigenvalues of the system's Jacobain. For more, see [2]).\n", "\n", - "This non-dimensionalization is important because it gives us information about the parameters. If we see an epidemic has occured, then we know that $\\mathcal{R}_0>1$ which means $\\beta> \\lambda$. Furthermore, it might be hard to place a prior on $\\beta$ because of beta's interpretation. But since we $1/\\lambda$ has a simple interpretation, and since $\\mathcal{R}_0>1$, we can obtain $\\beta$ by computing $\\mathcal{R}_0\\lambda$. \n", + "This non-dimensionalization is important because it gives us information about the parameters. If we see an epidemic has occured, then we know that $\\mathcal{R}_0>1$ which means $\\beta> \\lambda$. Furthermore, it might be hard to place a prior on $\\beta$ because of beta's interpretation. But since $1/\\lambda$ has a simple interpretation, and since $\\mathcal{R}_0>1$, we can obtain $\\beta$ by computing $\\mathcal{R}_0\\lambda$. \n", "\n", "Side note: I'm going to choose a likelihood which certainly violates these constraints, just for exposition on how to use `DifferentialEquation`. In reality, a likelihood which respects these constraints should be chosen.\n" ] From 6ecc0a557a32f6fd64dce8f7cb5c728befedc0bd Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Fri, 2 Aug 2019 20:09:00 -0400 Subject: [PATCH 17/45] Add tests, edit notebook --- ...ayesian_estimation_of_ode_parameters.ipynb | 63 +++++++++---------- pymc3/ode/ode.py | 18 +----- pymc3/tests/test_ode.py | 23 ++++++- 3 files changed, 52 insertions(+), 52 deletions(-) diff --git a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb index be6a597e063..b9802665ee9 100644 --- a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb +++ b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb @@ -5,13 +5,6 @@ "execution_count": 1, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING (theano.configdefaults): install mkl with `conda install mkl-service`: No module named 'mkl'\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -44,7 +37,7 @@ "Ordinary differential equations (ODEs) are a convenient mathematical framework for modelling the temporal dynamics of a system in disciplines from engineering to ecology. Though most analyses focus on bifurcations and stability of fixed points, parameter and uncertainty estimates are more salient in systems of practical interest, such as population pharmacokinetics and pharmacodynamics.\n", "\n", "\n", - "Both parameter estimation and uncertainty propagation are handled elegantly by the Bayesian framework. In this notebook, I showcase how pyMC3 can be used to do inference for differential equations using the `ode` submodual. \n", + "Both parameter estimation and uncertainty propagation are handled elegantly by the Bayesian framework. In this notebook, I showcase how PyMC3 can be used to do inference for differential equations using the `ode` submodual. \n", "\n", "\n", "# Catching Up On Differential Equations\n", @@ -156,8 +149,8 @@ "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [gamma, sigma]\n", - "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [01:52<00:00, 53.56draws/s]\n", - "100%|██████████| 4000/4000 [00:37<00:00, 107.10it/s]\n" + "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [02:38<00:00, 37.85draws/s]\n", + "100%|██████████| 4000/4000 [00:49<00:00, 80.09it/s]\n" ] } ], @@ -196,7 +189,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -233,8 +226,8 @@ "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [g, gamma, sigma]\n", - "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [08:11<00:00, 4.68draws/s]\n", - "100%|██████████| 4000/4000 [00:38<00:00, 103.13it/s]\n" + "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [09:09<00:00, 5.60draws/s]\n", + "100%|██████████| 4000/4000 [00:38<00:00, 102.66it/s]\n" ] } ], @@ -269,9 +262,9 @@ { "data": { "text/plain": [ - "array([,\n", - " ,\n", - " ],\n", + "array([,\n", + " ,\n", + " ],\n", " dtype=object)" ] }, @@ -281,7 +274,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -293,7 +286,7 @@ } ], "source": [ - "az.plot_posterior(data)" + "az.plot_posterior(data);" ] }, { @@ -322,10 +315,10 @@ "NUTS: [y0, g, gamma, sigma]\n", "Sampling 2 chains, 0 divergences: 0%| | 0/6000 [00:00" ] @@ -414,29 +407,29 @@ "\n", "The quantity $\\beta/\\lambda$ has a very special name. We call it *The R-Nought* ($\\mathcal{R}_0$). It's interpretation is that if we were to drop a single infected person into a population of suceptible individuals, we would expect $\\mathcal{R}_0$ new infections. If $\\mathcal{R}_0>1$, then an epidemic will take place. If $\\mathcal{R}_0\\leq1$ then there will be no epidemic (note, we can show this more rigoursly by studying eigenvalues of the system's Jacobain. For more, see [2]).\n", "\n", - "This non-dimensionalization is important because it gives us information about the parameters. If we see an epidemic has occured, then we know that $\\mathcal{R}_0>1$ which means $\\beta> \\lambda$. Furthermore, it might be hard to place a prior on $\\beta$ because of beta's interpretation. But since we $1/\\lambda$ has a simple interpretation, and since $\\mathcal{R}_0>1$, we can obtain $\\beta$ by computing $\\mathcal{R}_0\\lambda$. \n", + "This non-dimensionalization is important because it gives us information about the parameters. If we see an epidemic has occured, then we know that $\\mathcal{R}_0>1$ which means $\\beta> \\lambda$. Furthermore, it might be hard to place a prior on $\\beta$ because of beta's interpretation. But since $1/\\lambda$ has a simple interpretation, and since $\\mathcal{R}_0>1$, we can obtain $\\beta$ by computing $\\mathcal{R}_0\\lambda$. \n", "\n", "Side note: I'm going to choose a likelihood which certainly violates these constraints, just for exposition on how to use `DifferentialEquation`. In reality, a likelihood which respects these constraints should be chosen.\n" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 15, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -472,7 +465,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -483,8 +476,8 @@ "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [lambda, R0, sigma]\n", - "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [19:52<00:00, 3.53draws/s] \n", - "100%|██████████| 4000/4000 [02:19<00:00, 28.76it/s]\n" + "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [26:49<00:00, 1.84draws/s] \n", + "100%|██████████| 4000/4000 [02:21<00:00, 28.20it/s]\n" ] } ], @@ -517,23 +510,23 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "data = az.from_pymc3(trace = trace,\n", " prior = prior,\n", - " posterior_predictive = posterior_predictive)" + " posterior_pypredictive = posterior_predictive)" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/pymc3/ode/ode.py b/pymc3/ode/ode.py index c90cd11200f..ead084efe99 100644 --- a/pymc3/ode/ode.py +++ b/pymc3/ode/ode.py @@ -2,7 +2,6 @@ from pymc3.ode.utils import augment_system, ODEGradop import scipy import theano -import theano.tensor as tt THEANO_FLAG = 'compute_test_value=ignore' @@ -43,11 +42,8 @@ def odefunc(y,t,p): __props__ = () def __init__(self, func, t0, times, n_states, n_odeparams): - if not callable(func): raise ValueError("Argument func must be callable.") - if np.any(np.diff(times)<0): - raise ValueError("The values in times must be monotonically increasing or monotonically decreasing; repeated values are allowed.") if n_states<1: raise ValueError('Argument n_states must be at least 1.') if n_odeparams<0: @@ -73,7 +69,6 @@ def __init__(self, func, t0, times, n_states, n_odeparams): self._cached_parameters = None def _make_sens_ic(self): - # The sensitivity matrix will always have consistent form. # If the first n_odeparams entries of the parameters vector in the simulate call # correspond to ode paramaters, then the first n_odeparams columns in @@ -93,7 +88,7 @@ def _make_sens_ic(self): return dydp def _system(self, Y, t, p): - """ + ''' This is the function that will be passed to odeint. Solves both ODE and sensitivities Args: @@ -102,14 +97,13 @@ def _system(self, Y, t, p): p (vector): parameters Returns: derivatives (vector): derivatives of state and gradient - """ + ''' dydt, ddt_dydp = self._augmented_func(Y[:self._n], t, p, Y[self._n:]) derivatives = np.concatenate([dydt, ddt_dydp]) return derivatives def _simulate(self, parameters): - # Initial condition comprised of state initial conditions and raveled # sensitivity matrix y0 = np.concatenate([ parameters[self.n_odeparams:] , self._sens_ic]) @@ -128,25 +122,21 @@ def _simulate(self, parameters): return y, sens def _cached_simulate(self, parameters): - if np.array_equal(np.array(parameters), self._cached_parameters): return self._cached_y, self._cached_sens else: return self._simulate(np.array(parameters)) def state(self, x): - y, sens = self._cached_simulate(np.array(x, dtype=np.float64)) self._cached_y, self._cached_sens, self._cached_parameters = y, sens, x return y.ravel() def numpy_vsp(self, x, g): - numpy_sens = self._cached_simulate(np.array(x, dtype=np.float64))[1].reshape((self.n_states * len(self.times), len(x))) return numpy_sens.T.dot(g) def make_node(self, odeparams, y0): - if len(odeparams)!=self.n_odeparams: raise ValueError('odeparams has too many or too few parameters. Expected {a} paramteres but got {b}'.format(a = self.n_odeparams, b = len(odeparams))) if len(y0)!=self.n_states: @@ -164,18 +154,14 @@ def make_node(self, odeparams, y0): return theano.Apply(self, [x], [x.type()]) def perform(self, node, inputs_storage, output_storage): - x = inputs_storage[0] out = output_storage[0] - # get the numerical solution of ODE states out[0] = self.state(x) def grad(self, inputs, output_grads): - x = inputs[0] g = output_grads[0] - # pass the VSP when asked for gradient grad_op = ODEGradop(self.numpy_vsp) grad_op_apply = grad_op(x, g) diff --git a/pymc3/tests/test_ode.py b/pymc3/tests/test_ode.py index 7e9a733e46b..481cd52f101 100644 --- a/pymc3/tests/test_ode.py +++ b/pymc3/tests/test_ode.py @@ -6,7 +6,6 @@ from scipy.stats import norm import pymc3 as pm import theano -import theano.tensor as tt import pytest @@ -290,7 +289,29 @@ def test_too_few_y0(self): with pytest.raises(ValueError): self.ode_model(odeparams=[1], y0=[]) + def test_func_callable(self): + with pytest.raises(ValueError): + DifferentialEquation(func = 1, + t0 = 0, + times = self.times, + n_states = 1, + n_odeparams = 1) + + def test_number_of_states(self): + with pytest.raises(ValueError): + DifferentialEquation(func = self.system, + t0 = 0, + times = self.times, + n_states = 0, + n_odeparams = 1) + def test_number_of_params(self): + with pytest.raises(ValueError): + DifferentialEquation(func = self.system, + t0 = 0, + times = self.times, + n_states = 1, + n_odeparams = 0) class TestDiffEqModel(object): From 54861b2e8c03f90009a2d838df84d1aeb5225423 Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Sat, 3 Aug 2019 15:55:53 -0400 Subject: [PATCH 18/45] add blurb about rehsaping and writing func arg --- ...ayesian_estimation_of_ode_parameters.ipynb | 50 ++++++++++++++++++- 1 file changed, 49 insertions(+), 1 deletion(-) diff --git a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb index b9802665ee9..003184f208f 100644 --- a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb +++ b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb @@ -131,7 +131,9 @@ "* `n_odeparams`: The dimension of $\\mathbf{p}$.\n", "* `n_states`: The dimension of $f(\\mathbf{y},t,\\mathbf{p})$\n", "\n", - "Once the model is specified, we can use it in our pyMC3 model by passing paramerters and inital conditions. \n", + "The argument `func` needs to be written as if `y` and `p` are vectors. So even when your model has one state and/or one parameter, you should explicitly write `y[0]` when referecni\n", + "\n", + "Once the model is specified, we can use it in our pyMC3 model by passing paramerters and inital conditions. `DifferentialEquation` returns a flattened solution, so you will need to reshape it to the same shape as your observed data in the model.\n", "\n", "Shown below is a model to estimate $\\gamma$ in the ODE above." ] @@ -569,6 +571,52 @@ "2. Britton, Nicholas F. Essential mathematical biology. Springer Science & Business Media, 2012.\n" ] }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "forward __str__ = [0.94622963 0.04246546 0.79407422 0.15079378 0.48844496 0.3349355\n", + " 0.22600529 0.40470808 0.10640563 0.33598276 0.05994418 0.23898303\n", + " 0.04039129 0.15983604 0.03113522 0.10402349 0.02631478 0.06679165]\n" + ] + } + ], + "source": [ + "theano.config.compute_test_value = \"ignore\"\n", + "\n", + "def system(y,t,p):\n", + " \n", + " ds = -p[0]*y[0]*y[1]\n", + " di = p[0]*y[0]*y[1] - y[1]\n", + " \n", + " return [ds,di]\n", + "\n", + "times = np.arange(0.5, 5, 0.5)\n", + "ode_model = DifferentialEquation(func = system,\n", + " times = times,\n", + " t0 = 0,\n", + " n_odeparams = 1,\n", + " n_states = 2)\n", + "\n", + "y,sens = ode_model._simulate([4,0.99, 0.01])\n", + "yobs = np.random.lognormal(np.log(y), 0.1)\n", + "\n", + "\n", + "\n", + "with pm.Model() as model:\n", + " \n", + " R = pm.Lognormal('R', pm.math.log(4),1)\n", + " \n", + " forward = ode_model(odeparams = [R], y0 = [0.99, 0.01])\n", + " \n", + " print_forward = theano.tensor.printing.Print('forward')(forward)\n" + ] + }, { "cell_type": "code", "execution_count": null, From 186f9f294d6d9db7888673bed8a09e4c7d0b6181 Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Sat, 3 Aug 2019 15:58:20 -0400 Subject: [PATCH 19/45] remove some cells from notebook --- .../notebooks/bayesian_estimation_of_ode_parameters.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb index 003184f208f..25eb7b7ee98 100644 --- a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb +++ b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb @@ -131,7 +131,7 @@ "* `n_odeparams`: The dimension of $\\mathbf{p}$.\n", "* `n_states`: The dimension of $f(\\mathbf{y},t,\\mathbf{p})$\n", "\n", - "The argument `func` needs to be written as if `y` and `p` are vectors. So even when your model has one state and/or one parameter, you should explicitly write `y[0]` when referecni\n", + "The argument `func` needs to be written as if `y` and `p` are vectors. So even when your model has one state and/or one parameter, you should explicitly write `y[0]` and/or `p[0]`.\n", "\n", "Once the model is specified, we can use it in our pyMC3 model by passing paramerters and inital conditions. `DifferentialEquation` returns a flattened solution, so you will need to reshape it to the same shape as your observed data in the model.\n", "\n", From 5c9ca9e600bfb098f26a093e23b8bee44a9670b0 Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Sat, 3 Aug 2019 17:44:50 -0400 Subject: [PATCH 20/45] t0 now optional argument in DiffEq constructor --- ...ayesian_estimation_of_ode_parameters.ipynb | 53 ------------------- pymc3/ode/ode.py | 2 +- 2 files changed, 1 insertion(+), 54 deletions(-) diff --git a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb index 25eb7b7ee98..bb92ae600b0 100644 --- a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb +++ b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb @@ -570,59 +570,6 @@ "1. Earn, D. J., et al. Mathematical epidemiology. Berlin: Springer, 2008.\n", "2. Britton, Nicholas F. Essential mathematical biology. Springer Science & Business Media, 2012.\n" ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "forward __str__ = [0.94622963 0.04246546 0.79407422 0.15079378 0.48844496 0.3349355\n", - " 0.22600529 0.40470808 0.10640563 0.33598276 0.05994418 0.23898303\n", - " 0.04039129 0.15983604 0.03113522 0.10402349 0.02631478 0.06679165]\n" - ] - } - ], - "source": [ - "theano.config.compute_test_value = \"ignore\"\n", - "\n", - "def system(y,t,p):\n", - " \n", - " ds = -p[0]*y[0]*y[1]\n", - " di = p[0]*y[0]*y[1] - y[1]\n", - " \n", - " return [ds,di]\n", - "\n", - "times = np.arange(0.5, 5, 0.5)\n", - "ode_model = DifferentialEquation(func = system,\n", - " times = times,\n", - " t0 = 0,\n", - " n_odeparams = 1,\n", - " n_states = 2)\n", - "\n", - "y,sens = ode_model._simulate([4,0.99, 0.01])\n", - "yobs = np.random.lognormal(np.log(y), 0.1)\n", - "\n", - "\n", - "\n", - "with pm.Model() as model:\n", - " \n", - " R = pm.Lognormal('R', pm.math.log(4),1)\n", - " \n", - " forward = ode_model(odeparams = [R], y0 = [0.99, 0.01])\n", - " \n", - " print_forward = theano.tensor.printing.Print('forward')(forward)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/pymc3/ode/ode.py b/pymc3/ode/ode.py index ead084efe99..c10b257794d 100644 --- a/pymc3/ode/ode.py +++ b/pymc3/ode/ode.py @@ -41,7 +41,7 @@ def odefunc(y,t,p): __props__ = () - def __init__(self, func, t0, times, n_states, n_odeparams): + def __init__(self, func, times, n_states, n_odeparams, t0=0): if not callable(func): raise ValueError("Argument func must be callable.") if n_states<1: From bc7d48047f3231a8b5953c92a9f2766a5743f208 Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Sat, 3 Aug 2019 18:13:03 -0400 Subject: [PATCH 21/45] Need import of theano.tensor --- pymc3/ode/ode.py | 1 + 1 file changed, 1 insertion(+) diff --git a/pymc3/ode/ode.py b/pymc3/ode/ode.py index c10b257794d..e77a1ae8798 100644 --- a/pymc3/ode/ode.py +++ b/pymc3/ode/ode.py @@ -2,6 +2,7 @@ from pymc3.ode.utils import augment_system, ODEGradop import scipy import theano +import theano.tensor as tt THEANO_FLAG = 'compute_test_value=ignore' From 977238c23ebc16946037dd259d8fe15f5bbe1b37 Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Sun, 4 Aug 2019 17:26:48 -0400 Subject: [PATCH 22/45] typos in notebook. ODEGradOp now in __init__ --- ...ayesian_estimation_of_ode_parameters.ipynb | 63 ++-- pymc3/ode/ode.py | 338 +++++++++--------- pymc3/ode/utils.py | 160 ++++----- 3 files changed, 274 insertions(+), 287 deletions(-) diff --git a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb index bb92ae600b0..029cac19ce1 100644 --- a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb +++ b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb @@ -53,7 +53,7 @@ "\n", "# Doing Bayesian Inference With Differential Equations\n", "\n", - "PyMC3 uses Hamiltonian Monte Carlo (HMC) to obtain samples from the posterior distribution. HMC requires derivatives of the ODE's solution with respect to the paramteres $p$. The `ode` submodual automatically computes appropriate derivatives so you don't have to. All you have to do is \n", + "PyMC3 uses Hamiltonian Monte Carlo (HMC) to obtain samples from the posterior distribution. HMC requires derivatives of the ODE's solution with respect to the parameters $p$. The `ode` submodual automatically computes appropriate derivatives so you don't have to. All you have to do is \n", "\n", "* Write the differential equation as a python function\n", "* Write the model in PyMC3\n", @@ -67,9 +67,9 @@ "\n", "$$ y' = mg - \\gamma y $$\n", "\n", - "The force the object experiences in the downwards direction is $mg$, while the forece the object experiences in the opposite direction (due to air resistence) is proportional to how fast the object is presently moving. Let's assume the object starts from rest (that is, that the object's inital velocity is 0). This may or may not be the case. To showcase how to do inference on intial conditions, I will first assume the object starts from rest, and then relax that assumption later.\n", + "The force the object experiences in the downwards direction is $mg$, while the forece the object experiences in the opposite direction (due to air resistance) is proportional to how fast the object is presently moving. Let's assume the object starts from rest (that is, that the object's inital velocity is 0). This may or may not be the case. To showcase how to do inference on intial conditions, I will first assume the object starts from rest, and then relax that assumption later.\n", "\n", - "Data on this object's speed as a function of time is shown below. The data may be noisy because of our measurement tools, or because the object is an irregular shape, thus leading to times furing freefall when the object is more/less aerodynamic. Let's use this data to estimate the proportionality constant for air restistance.\n", + "Data on this object's speed as a function of time is shown below. The data may be noisy because of our measurement tools, or because the object is an irregular shape, thus leading to times during freefall when the object is more/less aerodynamic. Let's use this data to estimate the proportionality constant for air restistance.\n", "\n", "\n", "\n", @@ -125,11 +125,11 @@ "source": [ "To specify and ordinary differential equation with pyMC3, use the `DifferentialEquation` class. This class takes as arguments:\n", "\n", - "* `func`: A function specifying the differential equation (i.e. $f(\\mathbf{y},t,\\mathbf{p})$)\n", - "* `t0`: The time for which the initial condition belongs\n", - "* `times`: A monotonically increasing or decreasing array of times at which data was observed.\n", + "* `func`: A function specifying the differential equation (i.e. $f(\\mathbf{y},t,\\mathbf{p})$).\n", + "* `t0`: The time for which the initial condition belongs.\n", + "* `times`: An array of times at which data was observed.\n", "* `n_odeparams`: The dimension of $\\mathbf{p}$.\n", - "* `n_states`: The dimension of $f(\\mathbf{y},t,\\mathbf{p})$\n", + "* `n_states`: The dimension of $f(\\mathbf{y},t,\\mathbf{p})$.\n", "\n", "The argument `func` needs to be written as if `y` and `p` are vectors. So even when your model has one state and/or one parameter, you should explicitly write `y[0]` and/or `p[0]`.\n", "\n", @@ -141,7 +141,9 @@ { "cell_type": "code", "execution_count": 3, - "metadata": {}, + "metadata": { + "scrolled": false + }, "outputs": [ { "name": "stderr", @@ -151,8 +153,8 @@ "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [gamma, sigma]\n", - "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [02:38<00:00, 37.85draws/s]\n", - "100%|██████████| 4000/4000 [00:49<00:00, 80.09it/s]\n" + "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [02:56<00:00, 19.53draws/s]\n", + "100%|██████████| 4000/4000 [00:50<00:00, 79.45it/s] \n" ] } ], @@ -228,8 +230,8 @@ "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [g, gamma, sigma]\n", - "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [09:09<00:00, 5.60draws/s]\n", - "100%|██████████| 4000/4000 [00:38<00:00, 102.66it/s]\n" + "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [08:45<00:00, 5.47draws/s]\n", + "100%|██████████| 4000/4000 [00:40<00:00, 98.73it/s] \n" ] } ], @@ -261,19 +263,6 @@ "execution_count": 6, "metadata": {}, "outputs": [ - { - "data": { - "text/plain": [ - "array([,\n", - " ,\n", - " ],\n", - " dtype=object)" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, { "data": { "image/png": "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\n", @@ -297,7 +286,7 @@ "source": [ "The uncertainty in the acceleration due to gravity has increased our uncertainty in the prportionality constant.\n", "\n", - "Finally, we can do inference on the initial condition. If this object was brought to it's inital height by an airplane, then turbulent air might have made the airplane move up or down, thereby changing the inital velocioty of the object. \n", + "Finally, we can do inference on the initial condition. If this object was brought to it's initial height by an airplane, then turbulent air might have made the airplane move up or down, thereby changing the inital velocity of the object. \n", "\n", "Doing inference on the inital condition is as easy as specifying a prior for the inital condition, and then passing the inital condition to `ode_model`." ] @@ -319,8 +308,8 @@ " warnings.warn(warning_msg, ODEintWarning)\n", "/Users/demetri/anaconda3/envs/gsoc/lib/python3.6/site-packages/scipy/integrate/odepack.py:247: ODEintWarning: Illegal input detected (internal error). Run with full_output = 1 to get quantitative information.\n", " warnings.warn(warning_msg, ODEintWarning)\n", - "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [11:47<00:00, 3.75draws/s] \n", - "100%|██████████| 4000/4000 [00:39<00:00, 101.20it/s]\n" + "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [11:47<00:00, 3.85draws/s] \n", + "100%|██████████| 4000/4000 [00:44<00:00, 89.18it/s] \n" ] } ], @@ -384,7 +373,7 @@ "\n", "The example of an object in free fall might not be the most appropriate since that differential equation can be solved exactly. Thus, `DifferentialEquation` is not needed to solve that particular problem. There are, however, many examples of differential equations which cannot be solved exactly. Inference for these models is where `DifferentialEquation` truly shines.\n", "\n", - "Consider the SIR model of infection. This model describes the temporal dynamics of a disease spreading through a homogenously mixed, closed population. Members of the population are placed into one of three cateories: Susceptible, Infective, or Recovered. The differential equations are...\n", + "Consider the SIR model of infection. This model describes the temporal dynamics of a disease spreading through a homogenously mixed closed population. Members of the population are placed into one of three cateories: Susceptible, Infective, or Recovered. The differential equations are...\n", "\n", "\n", "$$ \\dfrac{dS}{dt} = - \\beta SI \\quad S(0) = S_0 $$\n", @@ -396,9 +385,9 @@ "If we knew $S(t)$ and $I(t)$, then we could determine $R(t)$, so we can peel off the differential equation for $R(t)$ and work only with the first two. \n", "\n", "\n", - "In the SIR model, it is straight-forward to see that $\\beta, \\gamma$ and $\\beta/2, \\gamma/2$ will produce the same qualitative dynamics but on much different time scales. To study the *quality* of the dynamics, regardless of time scale, applied mathematicians will *non-dimensionalize* differential equations. Non-dimensionalization is the process of introducing scaleless variables into the differential equation to understand the system's dynamics under families of paramterizations.\n", + "In the SIR model, it is straight-forward to see that $\\beta, \\gamma$ and $\\beta/2, \\gamma/2$ will produce the same qualitative dynamics but on much different time scales. To study the *quality* of the dynamics, regardless of time scale, applied mathematicians will *non-dimensionalize* differential equations. Non-dimensionalization is the process of introducing scaleless variables into the differential equation to understand the system's dynamics under families of equivalent paramterizations.\n", "\n", - "To non-dimensionalize this system, let's scale time by $1/\\lambda$, the rate of recovery (we do this because people stay infected for an average of $1/\\lambda$ units of time. It is a straight forward argument to show this. For more, see [1]). Let $t = \\tau/\\lambda$, where $\\tau$ is a unitless variable. Then...\n", + "To non-dimensionalize this system, let's scale time by $1/\\lambda$ (we do this because people stay infected for an average of $1/\\lambda$ units of time. It is a straight forward argument to show this. For more, see [1]). Let $t = \\tau/\\lambda$, where $\\tau$ is a unitless variable. Then...\n", "\n", "\n", "$$ \\dfrac{dS}{d\\tau} = \\dfrac{dt}{d\\tau} \\dfrac{dS}{dt} = \\dfrac{1}{\\lambda}\\dfrac{dS}{dt} = -\\dfrac{\\beta}{\\lambda}SI$$\n", @@ -422,7 +411,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 9, @@ -478,8 +467,8 @@ "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [lambda, R0, sigma]\n", - "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [26:49<00:00, 1.84draws/s] \n", - "100%|██████████| 4000/4000 [02:21<00:00, 28.20it/s]\n" + "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [27:00<00:00, 1.99draws/s] \n", + "100%|██████████| 4000/4000 [02:12<00:00, 28.99it/s]\n" ] } ], @@ -512,18 +501,18 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "data = az.from_pymc3(trace = trace,\n", " prior = prior,\n", - " posterior_pypredictive = posterior_predictive)" + " posterior_predictive = posterior_predictive)" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": {}, "outputs": [ { diff --git a/pymc3/ode/ode.py b/pymc3/ode/ode.py index e77a1ae8798..236891680e3 100644 --- a/pymc3/ode/ode.py +++ b/pymc3/ode/ode.py @@ -1,170 +1,170 @@ -import numpy as np -from pymc3.ode.utils import augment_system, ODEGradop -import scipy -import theano -import theano.tensor as tt -THEANO_FLAG = 'compute_test_value=ignore' - - -class DifferentialEquation(theano.Op): - - ''' - Specify an ordinary differential equation - - .. math:: - \dfrac{dy}{dt} = f(y,t,p) \quad y(t_0) = y_0 - - Parameters - ---------- - - func : callable - Function specifying the differential equation - t0 : float - Time corresponding to the initial condition - times : array - Array of times at which to evaluate the solution of the differential equation. - n_states : int - Dimension of the differential equation. For scalar differential equations, n_states =1. - For vector valued differential equations, n_states = number of differential equations iun the system. - n_odeparams : int - Number of parameters in the differential equation. - - .. code-block:: python - - def odefunc(y,t,p): - #Logistic differential equation - return p[0]*y[0]*(1-y[0]) - - times = np.arange(0.5, 5, 0.5) - - ode_model = DifferentialEquation(func = odefunc, t0 = 0, times = times, n_states = 1, n_odeparams = 1) - ''' - - __props__ = () - - def __init__(self, func, times, n_states, n_odeparams, t0=0): - if not callable(func): - raise ValueError("Argument func must be callable.") - if n_states<1: - raise ValueError('Argument n_states must be at least 1.') - if n_odeparams<0: - raise ValueError('Argument n_states must be non-negative.') - - #Public - self.func = func - self.t0 = t0 - self.times = times - self.n_states = n_states - self.n_odeparams = n_odeparams - - #Private - self._n = n_states - self._m = n_odeparams + n_states - - self._augmented_times = np.insert(times, t0, 0) - self._augmented_func = augment_system(func, self._n, self._m) - self._sens_ic = self._make_sens_ic() - - self._cached_y = None - self._cached_sens = None - self._cached_parameters = None - - def _make_sens_ic(self): - # The sensitivity matrix will always have consistent form. - # If the first n_odeparams entries of the parameters vector in the simulate call - # correspond to ode paramaters, then the first n_odeparams columns in - # the sensitivity matrix will be 0 - sens_matrix = np.zeros((self._n, self._m)) - - # If the last n_states entrues of the paramters vector in the simulate call - # correspond to initial conditions of the system, - # then the last n_states columns of the sensitivity matrix should form - # an identity matrix - sens_matrix[:, -self.n_states:] = np.eye(self.n_states) - - # We need the sensitivity matrix to be a vector (see augmented_function) - # Ravel and return - dydp = sens_matrix.ravel() - - return dydp - - def _system(self, Y, t, p): - ''' - This is the function that will be passed to odeint. - Solves both ODE and sensitivities - Args: - Y (vector): current state and current gradient state - t (scalar): current time - p (vector): parameters - Returns: - derivatives (vector): derivatives of state and gradient - ''' - - dydt, ddt_dydp = self._augmented_func(Y[:self._n], t, p, Y[self._n:]) - derivatives = np.concatenate([dydt, ddt_dydp]) - return derivatives - - def _simulate(self, parameters): - # Initial condition comprised of state initial conditions and raveled - # sensitivity matrix - y0 = np.concatenate([ parameters[self.n_odeparams:] , self._sens_ic]) - - # perform the integration - sol = scipy.integrate.odeint(func=self._system, - y0=y0, - t=self._augmented_times, - args=tuple([parameters])) - # The solution - y = sol[1:, :self.n_states] - - # The sensitivities, reshaped to be a sequence of matrices - sens = sol[1:, self.n_states:].reshape(len(self.times), self._n, self._m) - - return y, sens - - def _cached_simulate(self, parameters): - if np.array_equal(np.array(parameters), self._cached_parameters): - return self._cached_y, self._cached_sens - else: - return self._simulate(np.array(parameters)) - - def state(self, x): - y, sens = self._cached_simulate(np.array(x, dtype=np.float64)) - self._cached_y, self._cached_sens, self._cached_parameters = y, sens, x - return y.ravel() - - def numpy_vsp(self, x, g): - numpy_sens = self._cached_simulate(np.array(x, dtype=np.float64))[1].reshape((self.n_states * len(self.times), len(x))) - return numpy_sens.T.dot(g) - - def make_node(self, odeparams, y0): - if len(odeparams)!=self.n_odeparams: - raise ValueError('odeparams has too many or too few parameters. Expected {a} paramteres but got {b}'.format(a = self.n_odeparams, b = len(odeparams))) - if len(y0)!=self.n_states: - raise ValueError('y0 has too many or too few parameters. Expected {a} paramteres but got {b}'.format(a = self.n_states, b = len(y0))) - - if np.ndim(odeparams) > 1: - odeparams = np.ravel(odeparams) - if np.ndim(y0) > 1: - y0 = np.ravel(y0) - - odeparams = tt.as_tensor_variable(odeparams) - y0 = tt.as_tensor_variable(y0) - x = tt.concatenate([odeparams, y0]) - - return theano.Apply(self, [x], [x.type()]) - - def perform(self, node, inputs_storage, output_storage): - x = inputs_storage[0] - out = output_storage[0] - # get the numerical solution of ODE states - out[0] = self.state(x) - - def grad(self, inputs, output_grads): - x = inputs[0] - g = output_grads[0] - # pass the VSP when asked for gradient - grad_op = ODEGradop(self.numpy_vsp) - grad_op_apply = grad_op(x, g) - +import numpy as np +from pymc3.ode.utils import augment_system, ODEGradop +import scipy +import theano +import theano.tensor as tt +THEANO_FLAG = 'compute_test_value=ignore' + + +class DifferentialEquation(theano.Op): + + ''' + Specify an ordinary differential equation + + .. math:: + \dfrac{dy}{dt} = f(y,t,p) \quad y(t_0) = y_0 + + Parameters + ---------- + + func : callable + Function specifying the differential equation + t0 : float + Time corresponding to the initial condition + times : array + Array of times at which to evaluate the solution of the differential equation. + n_states : int + Dimension of the differential equation. For scalar differential equations, n_states =1. + For vector valued differential equations, n_states = number of differential equations iun the system. + n_odeparams : int + Number of parameters in the differential equation. + + .. code-block:: python + + def odefunc(y,t,p): + #Logistic differential equation + return p[0]*y[0]*(1-y[0]) + + times = np.arange(0.5, 5, 0.5) + + ode_model = DifferentialEquation(func = odefunc, t0 = 0, times = times, n_states = 1, n_odeparams = 1) + ''' + + __props__ = () + + def __init__(self, func, times, n_states, n_odeparams, t0=0): + if not callable(func): + raise ValueError("Argument func must be callable.") + if n_states<1: + raise ValueError('Argument n_states must be at least 1.') + if n_odeparams<0: + raise ValueError('Argument n_states must be non-negative.') + + #Public + self.func = func + self.t0 = t0 + self.times = times + self.n_states = n_states + self.n_odeparams = n_odeparams + + #Private + self._n = n_states + self._m = n_odeparams + n_states + + self._augmented_times = np.insert(times, t0, 0) + self._augmented_func = augment_system(func, self._n, self._m) + self._sens_ic = self._make_sens_ic() + + self._cached_y = None + self._cached_sens = None + self._cached_parameters = None + + self._grad_op = ODEGradop(self.numpy_vsp) + + + def _make_sens_ic(self): + # The sensitivity matrix will always have consistent form. + # If the first n_odeparams entries of the parameters vector in the simulate call + # correspond to ode paramaters, then the first n_odeparams columns in + # the sensitivity matrix will be 0 + sens_matrix = np.zeros((self._n, self._m)) + + # If the last n_states entrues of the paramters vector in the simulate call + # correspond to initial conditions of the system, + # then the last n_states columns of the sensitivity matrix should form + # an identity matrix + sens_matrix[:, -self.n_states:] = np.eye(self.n_states) + + # We need the sensitivity matrix to be a vector (see augmented_function) + # Ravel and return + dydp = sens_matrix.ravel() + + return dydp + + def _system(self, Y, t, p): + ''' + This is the function that will be passed to odeint. + Solves both ODE and sensitivities + Args: + Y (vector): current state and current gradient state + t (scalar): current time + p (vector): parameters + Returns: + derivatives (vector): derivatives of state and gradient + ''' + + dydt, ddt_dydp = self._augmented_func(Y[:self._n], t, p, Y[self._n:]) + derivatives = np.concatenate([dydt, ddt_dydp]) + return derivatives + + def _simulate(self, parameters): + # Initial condition comprised of state initial conditions and raveled + # sensitivity matrix + y0 = np.concatenate([ parameters[self.n_odeparams:] , self._sens_ic]) + + # perform the integration + sol = scipy.integrate.odeint(func=self._system, + y0=y0, + t=self._augmented_times, + args=tuple([parameters])) + # The solution + y = sol[1:, :self.n_states] + + # The sensitivities, reshaped to be a sequence of matrices + sens = sol[1:, self.n_states:].reshape(len(self.times), self._n, self._m) + + return y, sens + + def _cached_simulate(self, parameters): + if np.array_equal(np.array(parameters), self._cached_parameters): + return self._cached_y, self._cached_sens + else: + return self._simulate(np.array(parameters)) + + def state(self, x): + y, sens = self._cached_simulate(np.array(x, dtype=np.float64)) + self._cached_y, self._cached_sens, self._cached_parameters = y, sens, x + return y.ravel() + + def numpy_vsp(self, x, g): + numpy_sens = self._cached_simulate(np.array(x, dtype=np.float64))[1].reshape((self.n_states * len(self.times), len(x))) + return numpy_sens.T.dot(g) + + def make_node(self, odeparams, y0): + if len(odeparams)!=self.n_odeparams: + raise ValueError('odeparams has too many or too few parameters. Expected {a} paramteres but got {b}'.format(a = self.n_odeparams, b = len(odeparams))) + if len(y0)!=self.n_states: + raise ValueError('y0 has too many or too few parameters. Expected {a} paramteres but got {b}'.format(a = self.n_states, b = len(y0))) + + if np.ndim(odeparams) > 1: + odeparams = np.ravel(odeparams) + if np.ndim(y0) > 1: + y0 = np.ravel(y0) + + odeparams = tt.as_tensor_variable(odeparams) + y0 = tt.as_tensor_variable(y0) + x = tt.concatenate([odeparams, y0]) + return theano.Apply(self, [x], [x.type()]) + + def perform(self, node, inputs_storage, output_storage): + x = inputs_storage[0] + out = output_storage[0] + # get the numerical solution of ODE states + out[0] = self.state(x) + + def grad(self, inputs, output_grads): + x = inputs[0] + g = output_grads[0] + # pass the VSP when asked for gradient + grad_op_apply = self._grad_op(x, g) return [grad_op_apply] \ No newline at end of file diff --git a/pymc3/ode/utils.py b/pymc3/ode/utils.py index 15d3767874a..440e769e650 100644 --- a/pymc3/ode/utils.py +++ b/pymc3/ode/utils.py @@ -1,81 +1,79 @@ -import theano -import theano.tensor as tt - - -def augment_system(ode_func, n, m): - '''Function to create augmented system. - - Take a function which specifies a set of differential equations and return - a compiled function which allows for computation of gradients of the - differential equation's solition with repsect to the parameters. - - Args: - ode_func (function): Differential equation. Returns array-like - n: Number of rows of the sensitivity matrix - m: Number of columns of the sensitivity matrix - - Returns: - system (function): Augemted system of differential equations. - - ''' - - # Present state of the system - t_y = tt.vector('y', dtype=theano.config.floatX) - - # Parameter(s). Should be vector to allow for generaliztion to multiparameter - # systems of ODEs - t_p = tt.vector('p', dtype=theano.config.floatX) - - # Time. Allow for non-automonous systems of ODEs to be analyzed - t_t = tt.scalar('t', dtype=theano.config.floatX) - - # Present state of the gradients: - # Will always be 0 unless the parameter is the inital condition - # Entry i,j is partial of y[i] wrt to p[j] - dydp_vec = tt.vector('dydp', dtype=theano.config.floatX) - - dydp = dydp_vec.reshape((n, m)) - - # Stack the results of the ode_func - # TODO: Does this behave the same of ODE is scalar? - f_tensor = tt.stack(ode_func(t_y, t_t, t_p)) - - # Now compute gradients - J = tt.jacobian(f_tensor, t_y) - - Jdfdy = tt.dot(J, dydp) - - grad_f = tt.jacobian(f_tensor, t_p) - - # This is the time derivative of dydp - ddt_dydp = (Jdfdy + grad_f).flatten() - - system = theano.function( - inputs=[t_y, t_t, t_p, dydp_vec], - outputs=[f_tensor, ddt_dydp], - on_unused_input='ignore') - - return system - - - -class ODEGradop(theano.Op): - - def __init__(self, numpy_vsp): - - self._numpy_vsp = numpy_vsp - - def make_node(self, x, g): - - x = theano.tensor.as_tensor_variable(x) - g = theano.tensor.as_tensor_variable(g) - node = theano.Apply(self, [x, g], [g.type()]) - return node - - def perform(self, node, inputs_storage, output_storage): - - x = inputs_storage[0] - - g = inputs_storage[1] - out = output_storage[0] - out[0] = self._numpy_vsp(x, g) # get the numerical VSP +import theano +import theano.tensor as tt + + +def augment_system(ode_func, n, m): + '''Function to create augmented system. + + Take a function which specifies a set of differential equations and return + a compiled function which allows for computation of gradients of the + differential equation's solition with repsect to the parameters. + + Args: + ode_func (function): Differential equation. Returns array-like + n: Number of rows of the sensitivity matrix + m: Number of columns of the sensitivity matrix + + Returns: + system (function): Augemted system of differential equations. + + ''' + + # Present state of the system + t_y = tt.vector('y', dtype=theano.config.floatX) + + # Parameter(s). Should be vector to allow for generaliztion to multiparameter + # systems of ODEs + t_p = tt.vector('p', dtype=theano.config.floatX) + + # Time. Allow for non-automonous systems of ODEs to be analyzed + t_t = tt.scalar('t', dtype=theano.config.floatX) + + # Present state of the gradients: + # Will always be 0 unless the parameter is the inital condition + # Entry i,j is partial of y[i] wrt to p[j] + dydp_vec = tt.vector('dydp', dtype=theano.config.floatX) + + dydp = dydp_vec.reshape((n, m)) + + # Stack the results of the ode_func + # TODO: Does this behave the same of ODE is scalar? + f_tensor = tt.stack(ode_func(t_y, t_t, t_p)) + + # Now compute gradients + J = tt.jacobian(f_tensor, t_y) + + Jdfdy = tt.dot(J, dydp) + + grad_f = tt.jacobian(f_tensor, t_p) + + # This is the time derivative of dydp + ddt_dydp = (Jdfdy + grad_f).flatten() + + system = theano.function( + inputs=[t_y, t_t, t_p, dydp_vec], + outputs=[f_tensor, ddt_dydp], + on_unused_input='ignore') + + return system + + + +class ODEGradop(theano.Op): + + def __init__(self, numpy_vsp): + self._numpy_vsp = numpy_vsp + + def make_node(self, x, g): + + x = theano.tensor.as_tensor_variable(x) + g = theano.tensor.as_tensor_variable(g) + node = theano.Apply(self, [x, g], [g.type()]) + return node + + def perform(self, node, inputs_storage, output_storage): + x = inputs_storage[0] + g = inputs_storage[1] + out = output_storage[0] + out[0] = self._numpy_vsp(x, g) # get the numerical VSP + \ No newline at end of file From 24730cc360852e27020f5b7c5ca07d3791ccb167 Mon Sep 17 00:00:00 2001 From: nokados Date: Mon, 5 Aug 2019 08:20:05 +0300 Subject: [PATCH 23/45] fixed ValueError raised when mask is empty (#3580) --- pymc3/model.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/pymc3/model.py b/pymc3/model.py index 04102a7870b..083de57101a 100644 --- a/pymc3/model.py +++ b/pymc3/model.py @@ -1308,7 +1308,10 @@ def pandas_to_array(data): else: ret = data.values elif hasattr(data, 'mask'): - ret = data + if data.mask.any(): + ret = data + else: # empty mask + ret = data.filled() elif isinstance(data, theano.gof.graph.Variable): ret = data elif sps.issparse(data): From 37466665efec5907c918f59a68edb6b11bea2b9e Mon Sep 17 00:00:00 2001 From: Osvaldo Martin Date: Tue, 6 Aug 2019 17:25:33 -0300 Subject: [PATCH 24/45] Refactor smc out of step methods (#3579) * move smc from step_methods to its own family * black * update notebooks * add release note and fix lint * add release note and fix lint * minor fix docstring * reorder arguments and minor fix docstring --- RELEASE-NOTES.md | 1 + .../notebooks/ODE_parameter_estimation.ipynb | 296 +++++++----------- .../SMC-ABC_Lotka-Volterra_example.ipynb | 139 +++++--- docs/source/notebooks/SMC2_gaussians.ipynb | 17 +- pymc3/__init__.py | 1 + pymc3/parallel_sampling.py | 19 ++ pymc3/sampling.py | 296 ++++++++---------- pymc3/smc/__init__.py | 1 + pymc3/{step_methods => smc}/smc.py | 207 ++++++------ pymc3/{step_methods => smc}/smc_utils.py | 23 +- pymc3/step_methods/__init__.py | 2 - pymc3/tests/test_smc.py | 8 +- pymc3/tests/test_step.py | 211 +------------ 13 files changed, 481 insertions(+), 740 deletions(-) create mode 100644 pymc3/smc/__init__.py rename pymc3/{step_methods => smc}/smc.py (62%) rename pymc3/{step_methods => smc}/smc_utils.py (94%) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 68124f88bd9..ee86f3dd307 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -14,6 +14,7 @@ - Moved math operations out of `Rice`, `TruncatedNormal`, `Triangular` and `ZeroInflatedNegativeBinomial` `random` methods. Math operations on values returned by `draw_values` might not broadcast well, and all the `size` aware broadcasting is left to `generate_samples`. Fixes [#3481](https://github.com/pymc-devs/pymc3/issues/3481) and [#3508](https://github.com/pymc-devs/pymc3/issues/3508) - Parallelization of population steppers (`DEMetropolis`) is now set via the `cores` argument. ([#3559](https://github.com/pymc-devs/pymc3/pull/3559)) - SMC: stabilize covariance matrix [3573](https://github.com/pymc-devs/pymc3/pull/3573) +- SMC is no longer a step method of `pm.sample` now it should be called using `pm.sample_smc` [3579](https://github.com/pymc-devs/pymc3/pull/3579) ## PyMC3 3.7 (May 29 2019) diff --git a/docs/source/notebooks/ODE_parameter_estimation.ipynb b/docs/source/notebooks/ODE_parameter_estimation.ipynb index 04cbb7ff77e..aec3d4d396e 100644 --- a/docs/source/notebooks/ODE_parameter_estimation.ipynb +++ b/docs/source/notebooks/ODE_parameter_estimation.ipynb @@ -402,44 +402,10 @@ "Auto-assigning NUTS sampler...\n", "Initializing NUTS using adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", - "NUTS: [sigma, yto, xto, delta, gamma, beta, alpha]\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "51b6ca3e30814018b15692dfed658d5b", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, description='Sampling 2 chains', max=5000, style=ProgressStyle(description…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/osvaldo/anaconda3/lib/python3.7/site-packages/scipy/integrate/odepack.py:247: ODEintWarning: Repeated error test failures (internal error). Run with full_output = 1 to get quantitative information.\n", + "NUTS: [sigma, yto, xto, delta, gamma, beta, alpha]\n", + "Sampling 2 chains, 0 divergences: 0%| | 17/5000 [00:06<52:54, 1.57draws/s] /home/osvaldo/anaconda3/lib/python3.7/site-packages/scipy/integrate/odepack.py:247: ODEintWarning: Excess work done on this call (perhaps wrong Dfun type). Run with full_output = 1 to get quantitative information.\n", " warnings.warn(warning_msg, ODEintWarning)\n", - "/home/osvaldo/anaconda3/lib/python3.7/site-packages/scipy/integrate/odepack.py:247: ODEintWarning: Excess work done on this call (perhaps wrong Dfun type). Run with full_output = 1 to get quantitative information.\n", - " warnings.warn(warning_msg, ODEintWarning)\n", - "/home/osvaldo/anaconda3/lib/python3.7/site-packages/scipy/integrate/odepack.py:247: ODEintWarning: Repeated error test failures (internal error). Run with full_output = 1 to get quantitative information.\n", - " warnings.warn(warning_msg, ODEintWarning)\n", - "/home/osvaldo/anaconda3/lib/python3.7/site-packages/scipy/integrate/odepack.py:247: ODEintWarning: Excess work done on this call (perhaps wrong Dfun type). Run with full_output = 1 to get quantitative information.\n", - " warnings.warn(warning_msg, ODEintWarning)\n", - "The acceptance probability does not match the target. It is 0.9089833558022146, but should be close to 0.8. Try to increase the number of tuning steps.\n", - "The number of effective samples is smaller than 25% for some parameters.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" + "Sampling 2 chains, 0 divergences: 100%|██████████| 5000/5000 [16:18<00:00, 5.11draws/s] \n" ] }, { @@ -497,7 +463,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -553,97 +519,97 @@ " \n", " \n", " alpha\n", - " 0.552456\n", - " 0.065637\n", - " 0.002289\n", - " 0.428681\n", - " 0.678782\n", - " 735.656650\n", - " 0.999878\n", + " 0.547774\n", + " 0.064518\n", + " 0.001900\n", + " 0.419362\n", + " 0.674063\n", + " 1074.385749\n", + " 1.004643\n", " 0.549\n", " 0.065\n", " \n", " \n", " beta\n", - " 0.028047\n", - " 0.004369\n", - " 0.000153\n", - " 0.020097\n", - " 0.036484\n", - " 788.347157\n", - " 0.999785\n", + " 0.027826\n", + " 0.004243\n", + " 0.000121\n", + " 0.019341\n", + " 0.036248\n", + " 1188.103693\n", + " 1.004166\n", " 0.028\n", " 0.004\n", " \n", " \n", " gamma\n", - " 0.792733\n", - " 0.089938\n", - " 0.003068\n", - " 0.621923\n", - " 0.973234\n", - " 810.449110\n", - " 0.999962\n", + " 0.799796\n", + " 0.091914\n", + " 0.002793\n", + " 0.631756\n", + " 0.986809\n", + " 1016.646894\n", + " 1.004327\n", " 0.797\n", " 0.091\n", " \n", " \n", " delta\n", - " 0.023821\n", - " 0.003547\n", - " 0.000112\n", - " 0.017602\n", - " 0.031104\n", - " 897.445670\n", - " 0.999911\n", + " 0.024069\n", + " 0.003645\n", + " 0.000106\n", + " 0.017321\n", + " 0.031578\n", + " 1112.997961\n", + " 1.003657\n", " 0.024\n", " 0.004\n", " \n", " \n", " xto\n", - " 34.039379\n", - " 3.016263\n", - " 0.064226\n", - " 28.193732\n", - " 40.092932\n", - " 2089.061030\n", - " 0.999853\n", + " 34.000197\n", + " 2.847582\n", + " 0.049229\n", + " 28.578984\n", + " 39.662715\n", + " 2817.162400\n", + " 0.999849\n", " 33.960\n", " 2.909\n", " \n", " \n", " yto\n", - " 5.953507\n", - " 0.521353\n", - " 0.012523\n", - " 5.027723\n", - " 7.023803\n", - " 1696.227658\n", - " 1.000744\n", + " 5.929431\n", + " 0.544950\n", + " 0.012043\n", + " 4.872109\n", + " 7.009603\n", + " 1610.164705\n", + " 1.001869\n", " 5.949\n", " 0.533\n", " \n", " \n", " sigma__0\n", - " 0.249232\n", - " 0.044163\n", - " 0.000950\n", - " 0.177959\n", - " 0.340757\n", - " 2200.725278\n", - " 0.999702\n", + " 0.248297\n", + " 0.043430\n", + " 0.000802\n", + " 0.176750\n", + " 0.339778\n", + " 2382.238210\n", + " 0.999667\n", " 0.248\n", " 0.045\n", " \n", " \n", " sigma__1\n", - " 0.251609\n", - " 0.043279\n", - " 0.000791\n", - " 0.178921\n", - " 0.338763\n", - " 2199.754925\n", - " 1.000951\n", + " 0.250990\n", + " 0.043695\n", + " 0.001096\n", + " 0.180039\n", + " 0.342321\n", + " 1744.876212\n", + " 0.999668\n", " 0.252\n", " 0.044\n", " \n", @@ -653,24 +619,24 @@ ], "text/plain": [ " mean sd mc_error hpd_2.5 hpd_97.5 n_eff \\\n", - "alpha 0.552456 0.065637 0.002289 0.428681 0.678782 735.656650 \n", - "beta 0.028047 0.004369 0.000153 0.020097 0.036484 788.347157 \n", - "gamma 0.792733 0.089938 0.003068 0.621923 0.973234 810.449110 \n", - "delta 0.023821 0.003547 0.000112 0.017602 0.031104 897.445670 \n", - "xto 34.039379 3.016263 0.064226 28.193732 40.092932 2089.061030 \n", - "yto 5.953507 0.521353 0.012523 5.027723 7.023803 1696.227658 \n", - "sigma__0 0.249232 0.044163 0.000950 0.177959 0.340757 2200.725278 \n", - "sigma__1 0.251609 0.043279 0.000791 0.178921 0.338763 2199.754925 \n", + "alpha 0.547774 0.064518 0.001900 0.419362 0.674063 1074.385749 \n", + "beta 0.027826 0.004243 0.000121 0.019341 0.036248 1188.103693 \n", + "gamma 0.799796 0.091914 0.002793 0.631756 0.986809 1016.646894 \n", + "delta 0.024069 0.003645 0.000106 0.017321 0.031578 1112.997961 \n", + "xto 34.000197 2.847582 0.049229 28.578984 39.662715 2817.162400 \n", + "yto 5.929431 0.544950 0.012043 4.872109 7.009603 1610.164705 \n", + "sigma__0 0.248297 0.043430 0.000802 0.176750 0.339778 2382.238210 \n", + "sigma__1 0.250990 0.043695 0.001096 0.180039 0.342321 1744.876212 \n", "\n", " Rhat STAN_mus STAN_sds \n", - "alpha 0.999878 0.549 0.065 \n", - "beta 0.999785 0.028 0.004 \n", - "gamma 0.999962 0.797 0.091 \n", - "delta 0.999911 0.024 0.004 \n", - "xto 0.999853 33.960 2.909 \n", - "yto 1.000744 5.949 0.533 \n", - "sigma__0 0.999702 0.248 0.045 \n", - "sigma__1 1.000951 0.252 0.044 " + "alpha 1.004643 0.549 0.065 \n", + "beta 1.004166 0.028 0.004 \n", + "gamma 1.004327 0.797 0.091 \n", + "delta 1.003657 0.024 0.004 \n", + "xto 0.999849 33.960 2.909 \n", + "yto 1.001869 5.949 0.533 \n", + "sigma__0 0.999667 0.248 0.045 \n", + "sigma__1 0.999668 0.252 0.044 " ] }, "execution_count": 10, @@ -704,29 +670,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/osvaldo/proyectos/00_PyMC3/pymc3/pymc3/sampling.py:1100: UserWarning: samples parameter is smaller than nchains times ndraws, some draws and/or chains may not be represented in the returned posterior predictive sample\n", - " warnings.warn(\"samples parameter is smaller than nchains times ndraws, some draws \"\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "4fe97ab2eb4b4fe2ab49bc1ca5cfdb7d", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, max=500), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" + "/home/osvaldo/proyectos/00_PyMC3/pymc3/pymc3/sampling.py:1076: UserWarning: samples parameter is smaller than nchains times ndraws, some draws and/or chains may not be represented in the returned posterior predictive sample\n", + " warnings.warn(\"samples parameter is smaller than nchains times ndraws, some draws \"\n", + "100%|██████████| 500/500 [00:06<00:00, 73.96it/s]\n" ] } ], @@ -744,7 +690,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -928,7 +874,7 @@ "\\end{aligned}\n", "$$\n", "\n", - "Notice how I have used the `start` argument for this example. Just like NUTS `pm.SMC()` has a number of settings, but I found the default ones good enough for simple models such as this one." + "Notice how I have used the `start` argument for this example. Just like `pm.sample` `pm.sample_smc` has a number of settings, but I found the default ones good enough for simple models such as this one." ] }, { @@ -942,23 +888,15 @@ "text": [ "Sample initial stage: ...\n", "Stage: 0 Beta: 0.009 Steps: 25\n", - "100%|██████████| 1000/1000 [00:55<00:00, 17.88it/s]\n", - "Stage: 1 Beta: 0.015 Steps: 9\n", - "100%|██████████| 1000/1000 [00:26<00:00, 37.05it/s]\n", - "Stage: 2 Beta: 0.019 Steps: 5\n", - "100%|██████████| 1000/1000 [00:17<00:00, 56.88it/s]\n", - "Stage: 3 Beta: 0.028 Steps: 13\n", - "100%|██████████| 1000/1000 [00:58<00:00, 17.02it/s]\n", - "Stage: 4 Beta: 0.054 Steps: 4\n", - "100%|██████████| 1000/1000 [00:18<00:00, 52.84it/s]\n", - "Stage: 5 Beta: 0.114 Steps: 10\n", - "100%|██████████| 1000/1000 [00:52<00:00, 26.37it/s]\n", - "Stage: 6 Beta: 0.239 Steps: 4\n", - "100%|██████████| 1000/1000 [00:21<00:00, 46.46it/s]\n", - "Stage: 7 Beta: 0.496 Steps: 8\n", - "100%|██████████| 1000/1000 [00:36<00:00, 27.21it/s]\n", - "Stage: 8 Beta: 1.000 Steps: 4\n", - "100%|██████████| 1000/1000 [00:20<00:00, 49.45it/s]\n" + "Stage: 1 Beta: 0.015 Steps: 8\n", + "Stage: 2 Beta: 0.020 Steps: 4\n", + "Stage: 3 Beta: 0.030 Steps: 13\n", + "Stage: 4 Beta: 0.049 Steps: 3\n", + "Stage: 5 Beta: 0.089 Steps: 10\n", + "Stage: 6 Beta: 0.178 Steps: 3\n", + "Stage: 7 Beta: 0.368 Steps: 8\n", + "Stage: 8 Beta: 0.782 Steps: 3\n", + "Stage: 9 Beta: 1.000 Steps: 7\n" ] } ], @@ -981,7 +919,7 @@ "\n", " startsmc = {v.name:np.random.uniform(1e-3,2, size=draws) for v in FN_model.free_RVs}\n", "\n", - " trace_FN = pm.sample(draws, step=pm.SMC(parallel=False), start=startsmc)" + " trace_FN = pm.sample_smc(draws, start=startsmc)" ] }, { @@ -991,7 +929,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1052,38 +990,38 @@ " \n", " \n", " a\n", - " 0.230932\n", - " 0.017052\n", - " 0.000531\n", - " 0.201126\n", - " 0.266330\n", + " 0.231172\n", + " 0.016356\n", + " 0.000506\n", + " 0.198449\n", + " 0.262574\n", " 0.2\n", " \n", " \n", " b\n", - " 0.236115\n", - " 0.080920\n", - " 0.002661\n", - " 0.094373\n", - " 0.397491\n", + " 0.225260\n", + " 0.079409\n", + " 0.002322\n", + " 0.042878\n", + " 0.363055\n", " 0.2\n", " \n", " \n", " c\n", - " 2.920302\n", - " 0.035240\n", - " 0.001100\n", - " 2.853546\n", - " 2.991818\n", + " 2.925818\n", + " 0.033677\n", + " 0.001039\n", + " 2.858009\n", + " 2.985000\n", " 3.0\n", " \n", " \n", " sigma\n", - " 0.478180\n", - " 0.016855\n", - " 0.000528\n", - " 0.443860\n", - " 0.509162\n", + " 0.480563\n", + " 0.016981\n", + " 0.000520\n", + " 0.452350\n", + " 0.519051\n", " 0.5\n", " \n", " \n", @@ -1092,10 +1030,10 @@ ], "text/plain": [ " mean sd mc_error hpd_2.5 hpd_97.5 True values\n", - "a 0.230932 0.017052 0.000531 0.201126 0.266330 0.2\n", - "b 0.236115 0.080920 0.002661 0.094373 0.397491 0.2\n", - "c 2.920302 0.035240 0.001100 2.853546 2.991818 3.0\n", - "sigma 0.478180 0.016855 0.000528 0.443860 0.509162 0.5" + "a 0.231172 0.016356 0.000506 0.198449 0.262574 0.2\n", + "b 0.225260 0.079409 0.002322 0.042878 0.363055 0.2\n", + "c 2.925818 0.033677 0.001039 2.858009 2.985000 3.0\n", + "sigma 0.480563 0.016981 0.000520 0.452350 0.519051 0.5" ] }, "execution_count": 18, @@ -1129,7 +1067,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/docs/source/notebooks/SMC-ABC_Lotka-Volterra_example.ipynb b/docs/source/notebooks/SMC-ABC_Lotka-Volterra_example.ipynb index 5c45b237e0b..4037bf329c6 100644 --- a/docs/source/notebooks/SMC-ABC_Lotka-Volterra_example.ipynb +++ b/docs/source/notebooks/SMC-ABC_Lotka-Volterra_example.ipynb @@ -93,12 +93,12 @@ "output_type": "stream", "text": [ "Sample initial stage: ...\n", - "/home/agustina/Documents/pymc3/pymc3/step_methods/smc.py:176: UserWarning: Warning: SMC-ABC methods are experimental step methods and not yet recommended for use in PyMC3!\n", + "/home/osvaldo/proyectos/00_PyMC3/pymc3/pymc3/smc/smc.py:178: UserWarning: Warning: SMC-ABC methods are experimental step methods and not yet recommended for use in PyMC3!\n", " warnings.warn(EXPERIMENTAL_WARNING)\n", "Stage: 0 Beta: 0.003 Steps: 25\n", - "Stage: 1 Beta: 0.024 Steps: 7\n", - "Stage: 2 Beta: 0.108 Steps: 3\n", - "Stage: 3 Beta: 0.368 Steps: 6\n", + "Stage: 1 Beta: 0.023 Steps: 7\n", + "Stage: 2 Beta: 0.105 Steps: 2\n", + "Stage: 3 Beta: 0.358 Steps: 4\n", "Stage: 4 Beta: 1.000 Steps: 3\n" ] } @@ -108,7 +108,7 @@ " a = pm.Normal('a', mu=0, sd=5)\n", " b = pm.HalfNormal('b', sd=1)\n", " s = pm.Simulator('s', normal_sim, observed=np.sort(data))\n", - " trace_example = pm.sample(step=pm.SMC(ABC=True, epsilon=0.1))" + " trace_example = pm.sample_smc(kernel=\"ABC\", epsilon=0.1)" ] }, { @@ -118,12 +118,14 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -136,6 +138,14 @@ "execution_count": 6, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "arviz.stats.stats_utils - WARNING - Shape validation failed: input_shape: (1, 1000), minimum_shape: (chains=2, draws=4)\n", + "arviz.stats.stats_utils - WARNING - Shape validation failed: input_shape: (1, 1000), minimum_shape: (chains=2, draws=4)\n" + ] + }, { "data": { "text/html": [ @@ -159,36 +169,58 @@ " \n", " mean\n", " sd\n", - " mc error\n", - " hpd 3%\n", - " hpd 97%\n", + " hpd_3%\n", + " hpd_97%\n", + " mcse_mean\n", + " mcse_sd\n", + " ess_mean\n", + " ess_sd\n", + " ess_bulk\n", + " ess_tail\n", + " r_hat\n", " \n", " \n", " \n", " \n", " a\n", - " -0.04\n", - " 0.12\n", - " 0.0\n", - " -0.26\n", - " 0.19\n", + " -0.039\n", + " 0.105\n", + " -0.233\n", + " 0.154\n", + " 0.004\n", + " 0.003\n", + " 859.0\n", + " 859.0\n", + " 854.0\n", + " 906.0\n", + " NaN\n", " \n", " \n", " b\n", - " 1.02\n", - " 0.13\n", - " 0.0\n", - " 0.77\n", - " 1.26\n", + " 0.965\n", + " 0.135\n", + " 0.719\n", + " 1.212\n", + " 0.004\n", + " 0.003\n", + " 1023.0\n", + " 1021.0\n", + " 1019.0\n", + " 935.0\n", + " NaN\n", " \n", " \n", "\n", "" ], "text/plain": [ - " mean sd mc error hpd 3% hpd 97%\n", - "a -0.04 0.12 0.0 -0.26 0.19\n", - "b 1.02 0.13 0.0 0.77 1.26" + " mean sd hpd_3% hpd_97% mcse_mean mcse_sd ess_mean ess_sd \\\n", + "a -0.039 0.105 -0.233 0.154 0.004 0.003 859.0 859.0 \n", + "b 0.965 0.135 0.719 1.212 0.004 0.003 1023.0 1021.0 \n", + "\n", + " ess_bulk ess_tail r_hat \n", + "a 854.0 906.0 NaN \n", + "b 1019.0 935.0 NaN " ] }, "execution_count": 6, @@ -207,12 +239,14 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -332,12 +366,14 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -372,19 +408,19 @@ "output_type": "stream", "text": [ "Sample initial stage: ...\n", - "/home/agustina/Documents/pymc3/pymc3/step_methods/smc.py:176: UserWarning: Warning: SMC-ABC methods are experimental step methods and not yet recommended for use in PyMC3!\n", + "/home/osvaldo/proyectos/00_PyMC3/pymc3/pymc3/smc/smc.py:178: UserWarning: Warning: SMC-ABC methods are experimental step methods and not yet recommended for use in PyMC3!\n", " warnings.warn(EXPERIMENTAL_WARNING)\n", - "/home/agustina/anaconda3/lib/python3.6/site-packages/scipy/integrate/odepack.py:236: ODEintWarning: Repeated error test failures (internal error). Run with full_output = 1 to get quantitative information.\n", + "/home/osvaldo/anaconda3/lib/python3.7/site-packages/scipy/integrate/odepack.py:247: ODEintWarning: Repeated error test failures (internal error). Run with full_output = 1 to get quantitative information.\n", " warnings.warn(warning_msg, ODEintWarning)\n", - "/home/agustina/anaconda3/lib/python3.6/site-packages/scipy/integrate/odepack.py:236: ODEintWarning: Repeated convergence failures (perhaps bad Jacobian or tolerances). Run with full_output = 1 to get quantitative information.\n", + "/home/osvaldo/anaconda3/lib/python3.7/site-packages/scipy/integrate/odepack.py:247: ODEintWarning: Repeated convergence failures (perhaps bad Jacobian or tolerances). Run with full_output = 1 to get quantitative information.\n", " warnings.warn(warning_msg, ODEintWarning)\n", - "Stage: 0 Beta: 0.027 Steps: 25\n", - "Stage: 1 Beta: 0.056 Steps: 9\n", - "Stage: 2 Beta: 0.085 Steps: 6\n", - "Stage: 3 Beta: 0.126 Steps: 18\n", - "Stage: 4 Beta: 0.202 Steps: 18\n", - "Stage: 5 Beta: 0.537 Steps: 17\n", - "Stage: 6 Beta: 1.000 Steps: 3\n" + "Stage: 0 Beta: 0.025 Steps: 25\n", + "Stage: 1 Beta: 0.054 Steps: 8\n", + "Stage: 2 Beta: 0.086 Steps: 6\n", + "Stage: 3 Beta: 0.133 Steps: 18\n", + "Stage: 4 Beta: 0.196 Steps: 15\n", + "Stage: 5 Beta: 0.454 Steps: 18\n", + "Stage: 6 Beta: 1.000 Steps: 2\n" ] } ], @@ -396,7 +432,7 @@ "\n", " simulator = pm.Simulator('simulator', competition_model, observed=observed)\n", " \n", - " trace = pm.sample(step=pm.SMC(ABC=True, epsilon=1), draws=1000)" + " trace = pm.sample_smc(kernel=\"ABC\")" ] }, { @@ -406,12 +442,14 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2gAAAEoCAYAAAAt0dJ4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOydd5gkVbn/v6fj5Jxnd3Y2ze7O5mUjy8IiLCDxyhUJKiAIIohe9ao/09V79erFgIKIiKACShBUEIUlh2V3YfOyOc3sbJqcpyd0qPP7o6q6q6urqqs6TPfMvJ/nmaenK7516lT1+543HMY5B0EQBEEQBEEQBJF6bKkWgCAIgiAIgiAIghAhA40gCIIgCIIgCCJNIAONIAiCIAiCIAgiTSADjSAIgiAIgiAIIk0gA40gCIIgCIIgCCJNIAONIAiCIAiCIAgiTSADjSAIgiAIgiAIIk0gA40gCIIgCIIgCCJNIAONIAiCIAiCIAgiTSADjSBigDE2gzH2BGOskTE2xBhrYIz9hjFWmGrZCIIgCCJV0O8jQcQP45ynWgaCGHMwxs4F8FEA7wPoBjANwLcAdHLOV6VSNoIgCIJIFfT7SBDxQwYaQSQAxpgDwEoAGwAs4ZzvTLFIBEEQBJFy6PeRIKxDIY4EEQOMMRdj7FuMsYOMsSEAPog/PgAwK4WiEQRBEETKoN9HgogfR6oFIIgxyo8B3A3gfwBsAtAPYBKAvwHISKFcBEEQBJFK6PeRIOKEDDSCiI3rADzOOf+hvIAxlpNCeQiCIAgiHaDfR4KIEwpxJIjYyIIYtqHkM6kQhCAIgiDSCPp9JIg4IQ8aQcTGegA3Mcb2ADgK4GoAZ6dWJIIgCIJIOfT7SBBxQgYaQcTG3QAYgP+Vvr8E4HoAW1ImEUEQBEGkHvp9JIg4oTL7BEEQBEEQBEEQaQLloBEEQRAEQRAEQaQJZKARBEEQBEEQBEGkCWSgEQRBEARBEARBpAlkoBEEQRAEQRAEQaQJZKARBEEQBEEQBEGkCZbK7JeUlPDa2tokiUIQBEGMN7Zv397BOS9NtRzJhH4bCYIgCKsY/T5aMtBqa2uxbdu2xEhFEARBjHsYY02pliHZ0G8jQRAEYRWj30cKcSQIgiAIgiAIgkgTLHnQCIKIzrAvgOOdHnR7fBjy+eF22JGf6cSU4izkZjhTLR5BEMSYo71/BBlOG71DCYKYEJCBRhBx4vUL2HCkHW8dasOmY51o7PCAc+1tqwsysWJaEc6fVYYL55Qj02UfXWEJgiDGIJuOdQAArlpUnWJJCIIgkg8ZaAQRI2d6hvD79xrx3I5T6Bn0Ictlx4qpRbhyYRWmleagJMeFLJcDI74Auge9aOwYxJ7TPXj7UDv+tuM0slx2XLWoGreeU4sZZbmpvhyCIAiCIAgiDSADjSAs0jkwgl+8fhhPbzkJDuCSuRW4ekk11swshcsRPa0zIHBsPd6Fv+84jb/tOIWntpzAFQur8J8X1WFKcXbyL4AgCIIgiLTmeIcHw/4AZlfkpVqUMY0vIOClPc2YW5WPGWU5qRbHNGSgEYRJBIHj6a0n8eOXD2DQG8D1yyfjjvOmY1JhlqXj2G0MK6cVY+W0Ynz9kln4/cZG/P6941i/txmfXzsDd66djgwnhT4SRDwwxs4F8J8AzgJQBeAznPM/GmyfAeAhAEsAzAGwkXO+NvmSEgRBRLL7VA8AkIEWJ0O+AADgRJeHDDSCGG+09A7jK3/ZhU3HOrFqWjF+8G9zExKWWJzjxtcuno2bVtXiRy8dwP1vHMFLe5rxq+sXY04lvZQJIg5yAOwF8Lj0Fw07gGEADwC4FEBB8kQjCIIgRgMuiJ+MsdQKYhEqs08QUXjvSAcuu38Ddp7owY8+Nh9P3rYi4TljZXkZ+OV1i/HYLcvRO+TDVb/eiD9/0ASuV22EIAhDOOcvcc6/xTl/DoBgYnsP5/wOzvnDAE4lX0KCIAgi2QiSHmUjA40gxg9/2XoSN/1hC4pzXHjx7tW4YUVNUkdhzqsrxctfWoMVU4vw7b/vxRee2om+YV/SzkcQBEEQBDFekQ00OxloBDH24ZzjV28cwdf/+iHOnl6Mv925etQqLZbkuPHYZ5bjG5fMxvq9Lbj6wU042TU4KucmCMIcjLHbGWPbGGPb2tvbUy3OuKOhfQBt/cOpFoMgiDGOIAUi2ZJkn/kDAt462IZujzds+dG2fnQOjMR8XDLQCEJFQOD4zvN78fPXDuPqxdV49KZlyHGPbrqmzcbw+bXT8adbV6Ctbxgfe3Ajdp7oHlUZCILQh3P+MOd8Ked8aWlpaarFGXfsOd2Lzcc6Uy0GQRBjHDlVJFnRT92DPvQN+7C/uS9s+b4zfXjvaEfMxyUDjSAUCALHV/+yC3/+4ATuOG86fv6JhaZK5yeLVZL3LtNlx3UPv4+X9zSnTBaCIAiCIIixRCCYg5ac43NIBmCCj0sGGkFIcM7x/Rf34fldZ/CfF9Xh/310dlpU/ZlRloPn71yN+qo83PnkDvxhY2OqRSIIgiAIgkh7giGOybPQACTeQ0cGGkFI/OK1w3h8cxNuP3ca7jp/RqrFCaM4x42nbluJi+rL8d8v7sc96w9ShUeCMIAxlsMYW8QYWwTxt65G+l4jrf8xY+wN1T710vYlAJT7jwte2HUae071ploMgiCICHoHfRgY8Sf8uIKQXA+aEDTQEntcMtAIAsAjGxpw/5tHce3SyfhmmnjO1GQ47Xjwk2fh+uU1+M3bx/D15z6EPxC1ejhBTFSWAtgp/WUC+G/p//+R1lcCmK7a5yVpm2shTnAt7z9uaOgYSLUIBEEQEbx9uA1vHGhN+HF5sEhIcvQ6OcQx0ceniaqJCc9Le5rxw38dwEfnVeBHV89PS+NMxm5j+NHH5qEs14373jiCLo8XD9ywBJkue6pFI4i0gnP+NgzSAjjnN2ssq02eRESsULQAMR441j4Az4gfCyYVpFqUhDPo9cPtsMOeLDdVHCR7HjROHjSCSDx7T/fiK3/ZhbOmFOKX1y1Ky5eLGsYYvryuDj/8t3l481AbPvnI+xHlXQmCIJSMZSNnLIg+4g+kWgRD2vqG4fVTxEU89A758MKu0+iK8fd27+leNHZ4EixV8lm/twWv7df3bPUMevHa/lYca09P73wg2Qaa9Kk8eiLet2SgEROW9v4R3P74NhRlufDQp86C2zG2vFCfWjkFD96wBHtP9+Ga327GmZ6hVItEEESaMhaMnLHKsfYBrN/bkpT8mUTg9QvY3NCJrce7Ui3KmKa1T5yXr6V3Ys3PN+IPYNCr37d7Bn0ARAM2HZFz0JT22Yg/kLBBq1AZf+Wy+I9LBhoxIRnxB3DHn7aje9CHh29citJcd6pFiomPzq/E47cuR2vvMK5+cBMOt/anWiSCINKQsWyfpbvssuI+mKYGmpwj05ckBXqieOaCuUwTVHMe8mp7ieXnM10jkIIeLkm8EX8A6/e24EBzYvSlkDEWuv5EvLMmaDcjJjrfe2Eftjd142fXLMS86vxUixMXK6cV45nPrUKAc3z8N5uwjUZJCYJQIYxhF1q6h2cySTFLVynl5gskoR1P9wzh5b3N6Bkc/2H28jPEEj7jlTHp0v/fOdymuTzULulJMEdMknBEGlBo6UtM1FGoCEloWSLet2SgEROOF3adxtNbT+Ku86fjsgWVqRYnIdRX5eFvnz8bxTlufPKRDwzjxQmCGF08I36c6BxMqQxpouPFRLqLLo/Mp2sbBw00IfECtknew3QNb0skWor4aJ431YzoeEpDIX7paaLxON8gJ7sG8dYhbeNUeXzPSMjDSCGOBGGRpk4Pvv33vVhWW4gvX1iXanESyuSiLDx3xyrMrsjF557Yhme2nki1SARBANhwpB07T3ZbHgn3KabRiHdKDTNKSrfHi6bO9CtikC4Kqh6yWhqvIpgstEbzBYHjeIcnbu9MqEBCeirniUTQyDUaDQ639Uedv3DHiW6c6k7NIFAS7P64GfYFgjmhchdXP59m++yOE93oG/Lhxd1nMOyLDPOUr7/TMxIs2JaIdwEZaMSEwesX8MWndsLGgF9etxgO+/jr/sU5bjx520qcM7MU3/jrHjzw5pG0CY8giImKPPJs5VE80zOEl/aIoWMj/gD+tacZB5r7YpbBzLnfPdKOXSd7Yj5HshhNw6dv2IfjFivtpavnQEbLQGvoGMDuUz1oitOzm6wS4+nMaN/vQy39UecvPNk1iO1N3aMkUYhBrx/t/SMA0ivE8ZV9LcE51eT+H68qJHAevFYlSh3L4w03CuNh/GmoBKHDz189hN2nevGTjy9AdUFmqsVJGtluBx65cSk+trgaP3v1ML73j300oTVBJBnOOZp7jXMarPxmy5XRmntD5dHjKQIUi8Kw40Q3/vnhmZjPGQu7T/aElSLvHfTpFidIBm8dbMPuU9aM1LQPcdRYNuwT+5Q/bvdH8rxKvgT+bg2M+LH7ZE9cA5bpmmuVykHY1w+0oWNANFrStPtHPJfxNJfDLt59z4gf/cPiOzpZ100GGjEhePdwO377bgM+uaIGl8wbH3lnRrgcNvz8moW4/dxpeHxzE278/RZ0DkSO/BAEkRiOtQ9gS2MXThtMd2ElcdztFH+ePSP+hCgAsXihTnYNBvOWmnuHRkURPN7pwYcKA+ntw21453B78Htz7xDeOdyedFliOb7RHo0dnqBCFy/HOzx4Yddp0wYM19gsUZ6v0HESa7Yc7/DgpT3NCctt23q8C8c7Pegb9psasOzyePHu4fawvL1QDlp6mWjxG9mxo3xOtJ6Zpk5PQqef4Jyn1CCVK1W+fqAVbx5sk2SK3I48aARhgvb+EXzlL7tRV56D715en2pxRg2bjeFbl87Bz65ZiG1N3bjygY1R49gJgoiNQcnLM6KRoyDTPxypqOiVKJcVw4DANRVsq8SjMLT0DmNLYxeOtKV+ItotjV3oGfQmJO+lrW9Y1+tp5fjBHDSDRv7wVA/ePtQe3K53yBezonlUug96RRvUaA0MyAZ7vKaG1iS9iaBZmmvsbYPiDFYYkJ69A819+NeeZs1cIiV7Tveie9AbNjVBsnPQBIHjROeg5X6RjOIvsaAlxa6TPdigGGCJl03HOvGP3ea9+oLAg+++Y+0DwaI2AGLqtG194QPdB5r7NO+XekCsd9CH1/e3WpqSggw0YlwjCBxffXY3+od9eOCGJchwjq3JqBPBx8+ahL/ecTYA4N8f2oRntp6gvDSCSBJGnoQNR8IVlSFvAC/vbQ4q3Epk74hf4Ka9Xye7BnW9NPE88bIsifIAJQKrSqkvIOCFXafx8p7m4L6bGzqxpTE0LcmmYx0xHd9siKOs4J/pHcbbh9pwuHV0DF5NAy1B3iDlJMCJrFaa6LxD+TqDc9ZFCZt1STnqSiPYqCBKc+8QujzxTTVwtH0AO09241S3tfLv8vOZas+eupvJfcOr8lgKAo/5XdJhIhJIqd/4BCGsL21u6IzrZXisPfyZPdzarzmYo26LQ6398Hj9puSXIQONGNc88l4D3j3cjv+6oh515bmpFidlzJ+Uj398YTWW1RbiG3/dg7uf2om+NFK2CGKsY3XMwzMS+rHWCouUDQSvXzDtzdlxojsYdhMpX+RBPCN+zaR3NXLehS9gXbNp7x/BO4fbg8paorA6z5DsQfEGBJzRCUNVtoW140cqxr6AgA1H2jEw4o9oe3kUfdArhttF8+aYP6s2yrN/eKoHAyP+uLxBL+w6jQ8aOiOOHWu1Uk2iHCIg8KCxJdPcO6QbJeJ2hKu70WSUQ4yVCrW8z86T3RGK9pbGrogBGKvI/cBq7p1fei4dUvjdkdZ+HGyJLCh0sKUPL+w6jZbe4Yh1iYEbfAux70wf3jzYlpTc0k3HOsI8bL4Aj3g3x2v8q/uO1mCOcskHDZ1R85O1IAONGLfsPtmDn6w/hI/Oq8ANy2tSLU7KKc5x4/FbVuBrF8/Cy3tbcOl9G1JS9YkgxjNm9d3XD7Rixwnx+QsIAvac6g1TWGRjaMQvGBoLbf3DaOuPrnCpdYhT3YN4/UBrmNdIj1YprMcfxUDr9ngjlMudJ7rRM+jFsD+xyphZD9eLu89g98ke2CxOXhWvB62ldxhdHi8OtfSFLe8b9qFZYSBuONKBV/a1WJKNqz4BsQjGC7tOaw68KftPY4cH7x5uDxqJnIthaLLR2jPoDQ8D06FF2kY+tMBD3iazbScIHDtOdMMTQ47S3tO9eL+hE72Doevd0tilW+3Qbg+//9EklD1oSo+J8j4qPa9KlCFsfcM+dAyMoL1/BCe7onsW5Waz6gmTZZT7+P7mPhxqCS8oNOwLBJd90NiJYV/A1H16YdfpsO9v6QwAARoeNJ33VodHfJ+oPWuJQD3gtPtkT8QzEe2yo/VH9WUN+SK3VxpxLYrnaXtTpHGvBxloxLikf9iHLz69E2W5bvzf1QvSvgzyaGG3Mdx1/gw8e8cqAMAnfrsZ9756yFJcNEEQkcQzJts/7EdDhxjeJCMrT76AYOid23ysE5uPdVoW0Ki8unqEWJ4bbWDEF5znR40/IODdI+3Ydjx80Ed+95pxqljxvASkbYe8gaiFWY53esLkNvNzYDa/C9A2ypVGm/Kq3jrYhnZF1bt4IhnClEDJK3KiUyzsojyuull9ASGoNHYNinPfyR6Xdw63i2FgJs8veyOUspgtWtE16MXJLnGgQG3YK48QVsZ8xA/PiB89Um6Y3A+MvE6HW/vDcsnEYxrL5nJEqsfKy/IFBDS0RxqDSu/MWwfbsPFoBzYd6wgOxijpHfSpipBY92r2DvmC/d9hMAihHgR4ZV9L1MEZreexb9iHo20D+PBUT8Rzp95at40T6Exv7x8xvPcdAyMRoadG7xm5PxoZUeq9+zRyi/XOIHCOjUejD4oBZKAR4xDOOb77/F6c7BrEfdcvRn6WM9UipR1Lagrx0pfW4KqFVbj/zaO48oH3sO8MFRAhiHTBL4hKh6BRtSwgcMthcZGTtBpsy4ERDY/XiF80wrSQFeWewXBlyOg8vUM+tPePgHOOMz1DlrxWcsjk+w2d2Ha8CwGBo1Gq/KcVOrVX8X4zM2BnJVxNPp7AOXoGvfD6hbBzmDE8rYS1ycdTHlVWzgMCx66TPXjrYFtw4M3IAysfa8RnfZDuH7vPBD0WylPI9/Fk1yB6B31imK7GvbUr2khWoo+29Ut5PUrDJbTP6wda8fqB1uDxZJvkQ4MCWFrzB5odDLDb9O/jntOR5zQ7EDHiD+Dtw23YpRiUOSF52fqH/fjXh82m5FPKpGVUGhEtZ04vpHnfmV40dniw7Xi4F9GsB01NQOC6BpHRfRrxB7DpWEfEoFA0QrmEkXRKbSKHRGtV/FTLpOVxS0SUryP+QxBEevG3Hafx/K4z+Mq6OiyrLUq1OGlLXoYT9167CJfOr8Q3/74HVz2wEV/4yAzcdf4MOMfhJN4EMRrE46y3hyn1oeVqj8QHjZ1o7x/B/Op8xfbGGoFy9eHWfkMPEQcslzePpWy7XKFvblUe9p3pwzzF9URDNgLk6/D6hWB5/iFfAJkuu+b2oqyJzYcLHheiByovw4m6itzgMjNnW7+3BVcsrIpY3jfsQ5bTDofGO1mu7jnsCwQLS/iF0GS6ZibolfXPQJxtEmagSV+UXqOSHDdWzygJ20fZV2QDc98ZDWMKYn9UTr8gPxPyfVUOWHQMjCA3wwG3Q78omNpePNk1CJfDhvK8jLDrUW5nZvzAnIEW2q69XzQIlEr+ia7B4ABNmMwCjwjVVfZrh81mGIJoFS0ZjDDzXIUZ6tK/u0724FR3pEf/SGs/9jf34aPzKiOMT0HgwWu3WnBES8ztTV3oG/KjQBrQtzGGLo9Xc6BGvbvmwFICXjGkhRHjiob2AXz3hb1YMbUId50/I9XijAkurC/Ha18+F5cvqMQvXz+Cqx7YiP0aP5IEQeijVE42HGmPyAFRojcPk82mbaCpFQBZAdcawddDOZp9oLnPMLRO4ByDI9Y8dLKMet4pI31FVsqtFC+QjQCnlFukDNOO5olLdFly+YrlNu4b9oWNzuvprTxM+ZcNzgAEgQf/3jrYhi3HtfOdZK/olsYudEp5PeK1hZ/QyJMRUBk6sRIWnqvheZE9JEPeALY3dcMXEMLOaeTVFDjH/jN9YR6fQNDDLO2v2H7j0Y6oYWQBLk4sL4cp7jjRjfcVoZ3K0E352TbTRhwcTZ0e7FU8m+qcMuVRrBhB6vu49XgX3lNc55DPn9DiX8oJ482gbh61vA3tA3jxwzPBQRXl86Kmd9AXPL9W/mqA85hz9pTRBL1DPggCx6nuIfQN+0L9iel70U0Z4Qmw0MhAI8YNI/4A7n5qJ1wOG3553aKw0ATCmIIsF3553WI89Kmz0NY/jCsfeA/3vnpIM8yJIAh9Br0BdHm8mlXUADHpvkmnYIDylaX8gVd60PQUsGhKgxV1gXNjj8oLu05H5K3K26vfuqFcrOgSWClBvflYJ4a8gaC3fyQQelfJYaFKj0uYrCaNkRd2ndat+KjE6BrFHDRz5+OcY/3eFmxr6saLH57BoVbRyO8cUOXQSJ/yZQwpvEcBIaS4mvOgJd6baJSD1tTlwanuQby0pxk7ToTuj5ERebwjcrJj+Rx6+2nNOagkEODY0tilO8gRbjyLn3phqMr7LnDRI6QsLqK2H8T+KckhRIar6mkushyNHR6M+AMRfVPvmq14jH0BAd0eL7Yd79Kc/sMIdT9XdoP2/pGgl1fWKwSdd4YvIODtw23Bfq01D6TAeXB/m1VLRpLL6xfw9qE2bFUMgJgJyzR6nkPhzsbHMDMYRQYaMW74yfpD2HemDz/9+EJU5memWpwxySXzKvDal8/DFVJu2uX3v4edGsnNBEFoc7hV33Mmo+ehlkeC953pDfMWKD1u7xzSGdVV/N85MAJBED0EcuiUkd7h9QthCnBjhydqWXz1qLasRAmcayr9yiW9Q76I6nCxMOj1B6cAUBqMAufoVozAq7FilBzvjDyGOv9PnhdLOYmtUilv7dUzPMPlkO+RXJI7mnEYMsCUxrwQEZ5ndO+VHhwzZc/NTJdg1L4ZirDDQW+ozxkpxvub+8K2BRBm4IjFSqyhHHzUGojU8mDrGWjK+ey0jCH1vGmcR15vWM6djswC58FQz62N5n+XrUSvvnWwDe8eaTcsvKN/IvV5Qws2HeuIeG5C3qrw9lHPUac1WCQIinnW/Byne4ZMG6LqAQxllUX53EZVX41OwzWeSS0+aOyMug0ZaMS44K2DbXj0vUbctGoK1tWXp1qcMU1htgu/uHYR/nDzMgyM+PHvv9mEH/5zf1LmLCGI8UJrn3nvj54yKhto6pFrpUdCb1/lj/2xdg9e/PAMtjR24fUDreJ6AxX2rUNteEPaDhDnS4qmh6vVF1nRH/ELYXkwQe+SQrfVyjeJhQDnQQ+asqCBrLQb7WcWzsXpA+TjDXkDeGVfi6Yh3q7wAMpKOec8LPxPibqN1VLlZhgXuJIvQ3k5XR5vWIEZ5acWSmPq1f3Ry/2babkA57qGnJ4sFtOdQucSOLZZKF0uo8zBHNCswhf5zGl5Bo+2DYR5y7UuW+1B05p6XjldgP4zjuAN6BkyPyl2NK+QPKADhHtjraI+i/q7+th6HjS1Ma4VahhQDASN+APYdrwLHpM6itz6WvdKNiLVBVDC9jcV4hidaJViyUAjxjxtfcP46rO7MbsiF9+8dE6qxRk3nD+7DK9++Vxct7wGj7zXiEvuezcsRp8gCBFBqsoWL3q5FOZyX0K0qOaxaur0GGoMWhUho51TrVArN/d4oyi8CZrVQxBCYaEBxUEFwVhBUs/ndri1X7MMOiB6+9490o4DzaJB5pPOo1UZUEkwh8lQfn0vChAe8hp27KBhpq9oKrczUtDNlsTXk1GLQIDrbqfXr6xOPK7cz0wYqhrlPnLoXW5GqG6eUpyW3mG8sOu0pgctovqxGeVdw4Om7H96tyTAedCaMfVOiNI/ALHq6ntHO3CwpT/uyeTVt1ArNFGJ3mTppjy5Gp56s5VtZTm17qeZNjAT4mimO0ernEoGGjGmEQSOL/9lF4a8ATxww2JkOPWrNhHWyc1w4kcfm4+nblsJALju4ffx7b/viWliUYIYrySqKKBaUZF/7M0o0UoZ1N6jXSd7TFWgUxJNYVYXN4imHCnPb7U6nP4xuWYbBRQ5PlqoFbsDzX26EwnLSpwcdqj0dMhoKWyxjLJHKLgm94/mVbViJMq094+Ehda29Q/jdM+QKUNK4FzXS6m3PHYDTXt5tKkUlN4c2ZNh10lm2q2Ty6iFVl/QujYzYXKax9HZTzm4U5jlkrbXP7/MfmmgYWDEH/fE0Z2ekTDvV7TAU4GL/U8dAqp1T4+1D4S1Cxci+5LZKB9Dj7KZHDQzIY4mLPVo3koy0IgxzW/eOYaNRzvx/SvrMaMsN9XijFtWTS/G+i+di9vWTMWTW07gsvs36I44E8REQ13AIFbUOqWWd0iPaAqB1SydaAqzWpFRvw/ksC9Z+VIeL1ZlXGZSoZhjLIYyisuUXjGtueNkbIzheKcHrX3mK0Yq0XrvaZ2KG6yTMcpDAiI9feqjC1EMsKCCbmCd6xn/m4514HDrQNBQ23xMnG9O9iQaoSyCESY157rXZLVLyNeeiCInshGuN/eaNbkil6mPFRB4cPJ3K3BB/9lRvjvksF95W/Uk1UrkirA2Zm0uPiXTS3OC/+9o6sEr+1rE6ohR2nDb8S68+OGZYAVSGa1nd+/p3rAJoZUhjjJWPWhaWI1WiGejaO1NBhoxZtne1I17XzuMyxdU4hNLJ6danHFPpsuOb19Wj6dvWwlfgOOahzbj3tcOx/xSJ4jxgt4P/smuQby+v1V7pQZH28JHieV50fQV9RDqqopqzBxDidkQx1Pdg2jrjzR2DrX0h01arWwjq7KokT0dSkNMmc8hCFzX8JC9C1bDtW2M6Rp9WkvlHBYjwziaEaA0wF7YdRpH28KNI3Woo97+Rh5YI2O5Z8iLTcc6sOtkyINkxrDoHvRpejO0QvvMyGGErsGisUwvhFj2HMnt2DfsC4ayWkWrfdQSHmsfsFzCHpBLy+sPPMjIc4ZZMV4ZY7oTU0ejJIJYRRoAACAASURBVMcdPH+nZwTDvgA+aIheBEMPPbFH1NVKVbconvw5K3T06+c7Bp9JE8eJ1ufJQCPGJD2DXtz95A5UFWTgfz82P2o4A5E4Vkwrxsv/sQZXLazC/W8cwbW/3Wxp/iKCGA0YY+cyxv7BGDvNGOOMsZtN7DOfMfYOY2xI2u+/WBwvl50nezTzsYxQlh6XT21G0XozygS10cqOqzEb4ri9qRubj2kbO0qjUamsxTspsl1Rylo+Utg8aBqj6zIZzki1x8wt9hsYfbEqospKnUBkmwdLsEvLldUC5fVG1TAFztE5MIITXYNwWK5FjuBceFbn1jrVPYh3NQo7DPoCum0YqyNM7z5r3VJ5zjw1Pr9soCE495xeyGs0Tmjsp+4f6sEUs/2nb8gXNu+ZHi7Jg2alW9qYeQ+U1r5qhnyBMI+XFfSmKFEezy8IGmHW5ozqeEPSjUJeh3wBbG/qwo6m6BFG0fo8GWjEmINzjq/+ZTfaB0bw6xuWID/TuNIVkXjyMpy499pFuP/6xTjY0o/Lf7WBCogQ6UYOgL0AvgQgahUBxlgegNcAtAJYBuCLAL4G4CuxChDLVIzKCofy/lYLOWjRO2RNyY52yjM9w3hpT7PhNhwIujJ4xAqRomyXJbkABOe4DAihaoHKIi0BQd9Ak70LYeKY0Nj8AUFXgTXc20KIo1YonBK5P8jbRStM0+0RFfphX8BwXlC3Qzt3O9EeiTcOtKK1dxi5GQ4srS0KWydwHtNAn66BpuFD08sxkz1HAo9/8CAWzD6be9UFSRQoxZannlBfy4JJBbr7M8bQ1BmbUcoY0+zmevMQxoqyIIvPH/mMm43miTfE2ogDzX041T1kKp8vWug6GWjEmOORDY1442Abvn3pHMMXDpF8rlxYhRfuWo28DCc++cgHeGRDQ8yjyQSRSDjnL3HOv8U5fw6AmV/uTwLIAnAT53wv5/yvAO4B8JVYvWh6IVVmURoiWsgj5XLOiRH9Fr0g0bx2zb1DURUigXP0Scrngea+0DGZchtgxdRiS7LJCqjAuaYHjRso2loGWjTsNga/wHW9lIl65e1VTZocaaCF96doHgOlJ8JhYKC5HNrrkqHIegMC+of9EeaTIHB80Ji4QT65qZShlg6VB03OZZQ9MYNef8Sk4MlA/Vp457D23IZqzIYsOhXPhxK3wxaWL6bExqx7SmUYi92LnO1yRN9Ig50nuyP6v9ooWltXpnl8q5K6HXbNuXVLc90WjxROtHxOMtCIMcX2pm7cs/4gLplbgZvOrk21OASAmeW5eOELq3HhnDL88F8H8LXnPqS8NGIssgrABs650tv2CoAqALWxHDAWD1rY/tIB9EZjZc+amdNYzS+xWnLbbmMRhuLxjtCIfO+QLzi/m9K7IXCOgixrURA2FlJAZSVUmYNm5EEzY8yqyXTadY2Vo2396PboK/XtFubnUk+PoDYy/QLHqe7BoHfzWHt4yKMRdp3wPgBRwx+j5TdaJcftiDBSlLerJEdf8Z1UmBX2Xa8NfAEBxzs8YXO7uVXGuZbnUG0kxjvIEi/ZLoeuUaVEmesYLBKiYeDreVIFLoY4lhq0fTIozI49Akrt4fWp+ml+lhPZbg0DzaIx6bAxLJ9aFLHcHmffoBw0Ytwg551VFmTgno8voLyzNCI3w4mHPnUWvnjBTDy3/RRu+eNWyyP2BJFiKiCGNyppVayLgfjeUbKHTG9C02hV/JRYLW0/YnGQJTfDGaFwKIuEANohebGMvBdlu2C3MdEIk3ZXntsv6FcLdMaQi6U3fYvXL2DfmT54vP6wObQShTqk0hcQsL2pO6ZpCoyUSaPwRyD6hLpWmVWRGxGCGD7Zs/a9y3E7MLkw0pOhhzpXSO1NMTMtT6Zim4vnxvgaiIM1dSWYV50ffBco0dOBZC+xelDGxvQNTtnTmJOEfiyjJW9BlvUQZxn1+8Qv8Ijr0+raViPG9V4ZyY4VIgONGBNQ3ln6wxjDV9bV4ScfX4DNxzpxzUObg3MHEcQYQf2by3SWgzF2O2NsG2NsW3+/dlJ7vB40WXGOZsQkIxStb8hnyXtgZyyo+Mih52rPX2OHB28caA0b7edcu6CDGllRznY5RAONMQiCtrIVELiuERPLuJ5WYREgPCRMK+cpnTAKcRxtL1G088nGdaSyzeIemC3Pywj+r3dflWS5xH43tSR7VOdZLchyoSjbFTTMHBoGmlPnnsr7RDwDTP+dJFdijaWYjFlWanih5PaNBfVEz76AEFEIxqZxwVanZnDZtWWMd2LvaJCBRowJfrehgfLOxgifWDoZf/jMMpzqHsLVD26KqZwwQaSAFkR6ysqkz4ha+ZzzhznnSznnS3Nz8zQPGG+RBbN2V7LSPq2EA9oUeSh61fIAcc44pbwCN2fcyLLIRitjTJyQWmU7i/ligm6YtVbIUzT0FHO5yqEokOXD6jKnMg/F2YkNNTPykkXzoCUaZmAoACGlvaYoPJwx2n5mWDktlO9oJv8pU5IlkUasnnd3SnF28P8VU4uwZmZp0CDVMrCVRpvymZI9aBHn4doGS/gxk9MXFkwqQJnCOJbRK1BjRK3UTlqeXXUhGK37plXsZ6bOPLpuhw1Laws11yXZPiMDjUh/Nh3rwD3rD1He2RhizcxSPPO5lRjxC7ju4c1osJArQRApYjOANYwxpRaxDsAZAMeTccLFk7V/+K2i9KAlUrFX5+yElkcqVUrPRrRCHMqcprryHFNeLVlxlLd1ORiaOj0RpepddhsEAfD6tbWnLJcd59WVRj+hgrwM7YiNWEINzVCQFRkuqofZnCFjA83UIeKWQUZtkKtzrJwOG65aVI2qgvBwRruNJdRQynJHNw6yYixiYYSeB6cqP/TqUV+n1v3TGwhxBj1o4ecReHRDsyjbheVTi1BdYD6UVO89ocRKVdVolEjFObSeP7Uhq9VuSgMtP9OJqoJMTCvNjtgOAOrKc3UHaGKt+HnWFHPvfTLQiLTmdM8QvvDkTtQWZ+Gn11De2VhiblU+nrxtBfwBjuseft9SQjtBxAtjLIcxtogxtgjib12N9L1GWv9jxtgbil2eBDAI4I+MsXmMsasB/D8A9/IElCbVCsuuKc4KjgYnCnXY1rzq/KDR5rLbsHJaselQLT0PmlbVP6Ui5NYJCZJRhgZOKc4OUxr1crmyXHbUledimVSePUNn5N3ttIuT5eqUoGdMDB9T5/RMLsrCZfMrI7ZfVluEQp2pAJRGVCKr19oYM11oSU82NUa/nfFPHG7td9nGEOZxVD8bcuiY2jtqYyyqB8gKyj6g1z7FOdrtuzBKJI9stJTkuHFRfQXKckPGl960GcprUxsaWh40vedTXu4LCGHz5HHwqB5Ih42hMj8zYhoEQLt4S3leBnJ1BjCU6A1mmDHu1BjlU6o9gFrtNjASmk9t7awyLKst0szxA4yfm1hDyycVZpnSZclAI9KWYV8AdzyxHV6/gIdvXGrqJUCkF7Mr8vDU7SshcNFIk6u4EcQosBTATukvE8B/S///j7S+EsB0eWPOeS9Ej1kVgG0Afg3g5wDuTYQwcjiOugpdtJ/4SRaKIgCRIUzTS3Pglow2m42hPC8DhSYT8/VydKKFPjp1yrbrodxaqfMolZgRv4A5lXnBEEW3jpE5Io2O9w35NJUu2RjMUoU62hjTzPMpyHLqKm/KKpWJdKYxmJ/TaWZZDqaX5iDL5cCMMv1qf0aKeSyhWsp7YzksjoV70dQGXrAPq+QSPWjWTqXFwkkFqMzPBGMhj5yegV2S48bZ00swszy8baMZpfIzEhA4Ml12LKstxPzqfAD6xorS8FA/x1rn08srlLc90ByeG2vGg2ZkACvDg+VnIidKyHAwH06vaI/i2TLr/TdqerXxpnW9SgMtuJ3OQZWl9OdJ90/vXImGDDQiLeGc41t/34M9p3vxi2sXmSozS6QndeW5eOq2leAc+PSjH+B0DxUOIZIP5/xtzjnT+LtZWn8z57xWtc8ezvm5nPMMznkl5/y/TXnPTPxO1xZnY1pJToSiF41pJda211LaZIVNXmdWr8jUSeDXMtCUzWQmDM1hs2HtrLIIeZRFHC6ZW4FV08WcIbWCl6ljoCm9E9WFmRHhifKp1MUJ9CS2MaYbhuXxhhS9RE5wbGMM3iherfPqSrF6RgkcdhvmVedjXX25YVia8p6U5WbgUoW3MBZPQInCs2Q1j0gs9hH6rjTwKvMzMa8qX2MvMRwuESGOtSXZwbLpasNHy0tUmuuOuMZogxQOhYEmf5cNEGX47fmzy4L/G06FoLFOaSSbuYOlOe6oHkij9lUaK3K7yX1Hby7DRTWip1Ee7DEy6Mwa30beJ/X9jCW/Ur7XVy6sCpO3WOGtLs52R/WixgsZaERa8oeNx/G3HafxpQtmYl19earFIeJkZnkuHr9lOQaG/bjx0Q8i8kYIYjyhlZPjdtgwf1J+RJn3aPaf1ZAuLQVLNsyCBTYM9lcqNOpcITlnTiv3RZljYkaHLstzB0PblArX3KpQwRWXw4bSHDemFGcHFT2ZbI38oUynPUyOvAwnzp5RHOYxlM+lNvCiyby0tgirZ5Toro+notuiyQW4fEFVmCzqfqH24hVkuSKMCSPFVbmqviovzMDQyg+KpthOLQmF5lrNI1JFOIZVDpxVkRs8nloslz0+A03rDqmPV1eeiysXVmlsqdpPccmrphcHvWMycuieMpxY3kfpHVW+D4ynQohsYyMbcc3M8DzL+dX5cDlsUb0+el65RZMLwvYNTRYvfq/Iz9AsmV+Zn4kVU4uDg+zn1pXionrt6Qr05ntUY6Xgjfpy1fdJi/PqSrGkpjDieVK+D8+ZWYJ8i/M3KjEz7kcGGpF2vHmwFT/8136sqy/Hly6YmWpxiARRX5WHR25aipPdQ/jMH7fCoxFmQBDjgcU1hajMD/dmyL/1VvRLMzkjarRDocIrIPYM6s9RqFRClIp7cbbbUHa/wLG2rgzLpxaZqsqot0WEUsQYFk0uiPCEaXn3akvC8/nyMp1wO+xhhozcPGqPhJ7iLy+uLsg0nEA5nopuDrsNdhsLVhXUMrTMVNRU7qbeXnlP1IfX8v4ZleUHRMVbltdqHhFTlctX9lnl/2qbJMNpi2mahNkV2lVWRVnEzzxpsCA3w2EqP0huzwynHWW5GWEVGOXlK6cVhxWEUHudlOeX16+aVhzmVZPRuh+ZTn1vVKHKeJD7d7T3ie5zgPDw0hy3U/qM7j2tyM8ItqnTbkOmy47VM0oiKnLPq84P3gdjGfXXqe+dumubCaPMdNkxWVVBVDx41F0TChloRFqx/0wf7n5yJ+ZU5uG+6xYlNCGYSD0rphXjgesXY8+pHtzxp+1h1dwIYryQ6bKjtlhVIjzKr7te6I9Vj4GWgaYu6qEMzVOjPN3U0mxMLclGdUEmVkxTFg3Q9qDlZzml3J7ochptYyYsSauyIgPCvFyyEaZU9GUFTs+TcNaUwjBDzOz8ZlZCHFdNL8ZVi6qDnj2nKvRUSzTZq5TlcuiGvSr7yoVzwiNPlMdUH14QeERlS+Wx9MLX5FwqIw/a5KIsLKkJr1qnvr1K40P5f1luBuZV5wdDzlx2e0weNCPbVj7arPJcXDKvwnQBHfU1RHhuIIbrKtsmmuwOG0NZXoZm39Z6JsryQv1U7ZFRGyry/tF0KqNnT3nMomwXzp1ZGnP6SUmOO+iFtTEW9AifPyvSOI0mhxK1IRsxDYedRVQHNYvW7Tt/dhnW1kWXWUbe1syACxloRNrQ1jeMWx/bitwMJx69aVlSytsSqeeiuRX4v6sXYMORDnzn+T0JrX5GEKlAa3RbbxRevVju/TPLcjUVOC2FKT/TqasYaZfjFn/qjYwNeeRa3mLVtGLkuB1YMKkAS2uLoioUyrAtMyq0kZdiXX25bhiUTIbTjisWVOGqRdVhxTGUCpvcnvJ163ltxHXi56TCrLBiCGbHCPU8ThfPrYjwCsgezQLJyyF7A4MGGkSjSK5oWZLjDub/TCrMxPxJ2mFaSglcDltE3pR8/eq2n1+dj4IsV9j2snGb5XIE2yDL5UBxtjv42+yT8uT0iqgAwJKawojBB7U3Rs+DBohFbmRxHXYWU06RceinuM5hY5Zy6aJ52cw+yzaDPqlEPWfbRfUVmh5dPSNQNhSjFgnRWa2eg07gHIXZLs120Ap1NOKKhVWmpr6or8zDWVMKg3LYGAu+l+RnSn19avXCzliwEqxVtJomL8NpKdRR3taM15kMNCItGPT68dnHt6F3yIdHblqKivzICQ2J8cMnlk3G3R+Zgb9sO4XfvtuQanEIIi6y3Y4IBUNP2dIzkhgTR2PN5EZlOO26XgulZ+gCyYsiKzEaaSxBgtXsQoJGICs7jAGXzBMNKHkUXLBYJMRoC7fDrlugRInsDVDKFbZe5ZHKULRZpMcj9D08BM2cIq4eya/Mz8TqGSXIcNojvHXytnOr8nHOjJJghWJZBg4xLOwjs8tx1aJqsRiI6lqNZJFR5vOJxw//lNGaQFg+Vo47FPLndthwzsySYF74imlFqMzPDKt+qRVCFtGEqu9K41/Lsylfs43FVsXRqD/Ka6znehqv1zql1rWFeTYN5FSX+5efj5Icd1h1Qb2cfXfQQNM9RYQMq6YVB99HvoAQ1o5GhWWMqomaRasI0MzyXEwqzFKEa0Y3btViyrusml4cMZXAWVMKDQ3FWKd5Okcjd9XMYAAZaETK8QUEfP5PO7D3dC/uv25xRClTYnzy5QvrcNmCStyz/iDW721JtTgEETMMkaPGan1BDrWJ8KApFIgctyM8/Ibrh+LpKSRKpUXtuZCPpZXjopYnWmif22HHVYuqsWBSAaaX5mDltFAYnBk9JpETDocIP2bIgyaiDF+LLO0e+j+8IqXxGUty3JhVkYvFNQVhx8xyhXLflJeqzG2x2xiKNbwgWrqvfAwjxVjdpJOLsjBXoyKimaaXPRJiTpYkl2qbstyMYDVEGa0qper8PBvTL7OvZSjJ98Nmi01JNtpDPpzVkulBY9pCAIjNxiLkN3tWeRBoaW1R2PO7ekZJmDddeXilsRH0oOl06NUzSjCrIjdsWVleBqZJxx4Y8Yc9s1qFZeS18Zafv3JhVbDCqxbBYkdMcU6dCrXqyqby+rLcjIh1kwqzDL1/sV6V1hRRi2oKok4GTgYakVIEgeNrz+7GO4fb8aOPzceFVLFxwmCzMfz8moVYOKkA//HMTuw51ZtqkQgiYegpQmrDpFKKFpBDX9ST2OoZMnqhwVpeMtn7IoemaeW4BI+rY0gqUa+aJ4XIBdeb8aAlwT5THzOU0yX+ozTQHKqGUhoMenOxaeGwM8yuyIPbYQ8Lc9TaLcftQH2lfsEKedJprSqZsuxGOVLR2jQUQqm3Yahk+qKaArgddkwtyY5uTCvaq1zDG6eZH2Xh/st7m5nQXAvDviyHy5n0oK2tKxPz+2LwoAEIC89TfpqhIMuF6oLIqSPCzqsQTPlMyh4brfPluB0oyXFrFlOZXJSJomwXppXmgIUNYujLGW/pAGbSU8oQum96m+dnOXHVomqFbLELF+u+eu8CrcnAw84X09kIIgFwzvG/Lx3A87vO4GsXz8J1y2tSLRIxymQ47fjdjUtRnO3GrY9tRXMvzZFGjA/0q6GFU1WQiSsWVAWVLuXk0HmZzjDFUS5zD+jnE2mdtywvA4smF6C+St84MBNCp064j4dEetD0ZA560KRTKQ0fdRVHpTg1xRoV3HQI8/4w7f9lFk0uMDSwFlTn47y6Us3860mFWVhWW4Tppdkae4poG148Yr1e08vtmJ/pRI7bgUvmVSDbHcpBi5YvnG+iAp8ohzUDXfYayp4ZeQ64RBCtTdTkZznD2iTacdXInqd51fm4alG1plctHtSHmledD5dUJRTQ9m6dM1O/Ld0OO9bMLBVDXRXLtTxoISGsSKyNYViq7PVUTFzOVJ96xOPdy3CK7ag1jYpeIR0g9ncdVWEgUsZv3jmGR99rxM1n1+LOtdNTLQ6RIkpz3Xj05qX4+G8249Y/bsOzd6wKS9IniLGIniKgtVhphNWV5SJfKg9fYKDwTi3ORl6GEw3tA2jpGzY8PoCIMuBqzppSiOOdHrT3j6DL49VW9YO5XskIT4ydoNdPtVy+B/JypaJUkuPG3Kp8dA96caZnKGzfstzYcqAddgZozGBQmOVCl8cLd5QKgTYbMwyxilZ9Tu5GWqXKGYvsG3Yb07xWq7c35HXV3lH9PrcxZmly7GAOmnSBRm1UlpuBtv5h3fURBI1P87sA0Z+BaG04uTB0Ly+eWw4hQQWN1cbA9NIc3RBIGbPFUczmoCVi8MXoEG6HHbMr8lBVkIEjbQPh+0F8hop0+kg8ojHGcOm8Ss11RnUTGBBTtUvyoBEp4ZENDfjJ+kO4cmEV/uvy+rT7wSdGl9kVefjVDYtxsKUPX3p6V1yTvhJEOqD3SotadMLGUJkvhhUpDbfyvIywY9psDKW57oi5v8wqR0tqCsPKn2c4RaUn0UaYOpRQxoqCbpbIOdTET60QOUAsZiAXT1BfrlmFSnkZysmElcvnVuVh7awy3akUEoXDbsOy2iKsUuQDhoVryp/SP5cvqArLIeOq9aH9jPtCboYTRdkuLFDlj8tzAWY47WFhZqKxaL5/yX0lmteqKNuFVdOLg/NrTSnOxqXztRVqmaVTClFbnI08jZBJw5LzGsvOqyuN8NqqmV0hViJUFlYxWxTHDNFaNVEhfoahtjGfQXGMKHLOqshFboYzKJPSo3deXal+pdM432s2G9MNh9Wb/oIx0ZNptb4CGWjEqPPYpuP44b8O4KPzKnDvJxbSXGcEAOD8WWX47uX1eP1AK+555WCqxSGIuEhkCN+l8yuxXCdfoTwvA1ctqg6G3Zg97eSiLEwqjPTIhPKU9LFyZZct0FaQ5RLtiWBSoRiSKJeil5GVMWWRCTV690kOQYtO6DqUIZTqSpBmw//ipaogU1N5Njufm9G2enfMbmNYM7M0mEMns0BXSTYtShh690oOE14zUyyKodwq2vQQuRlOLJxcEKG4Xzy3wnCqh5AsoVYpyHIFc0r12nBWRW6wvyaDqCF+cehbymPPKs+NWC/3O3lQZo5BvmWikC9HCA4sJf2UuiTaKKQ4ImJU+dP7TfjeP/bhovpy3H/94rBRJIK4+exaHG0bwG/facCM0hxcs3RyqkUiiJiIRxFSE5zHLFFWk7yLxgGX1BSiod0TnKNLSSJ9Xsp50wAxvy5WL0JRtsvQmJJPpaXgy21r1mA8e3oJNh3rCH5XeqiW1BTi9QOtxvk5o4xSkqBHMYp4iVJydb3IYGCq3rS2rixqjqPeM7WkpjBsoDd0neHHszLnZrQJq3Xz+KTPVI07R58WIvZjh+VYahxo0eQClOW6IwpzJBPZEJYHRMZTMBZpx8So8cT7TfjO83txwewyPHDDElMzqRMTC8YYvn/lXKyeUYxv/X0PPmjoTLVIBBETKQsM4EBdea7m3DtmyHY7MH9SfpTJfWMVLoTaQKspzorwgCWKYJEJjZsiFwvxmzTQSnPdwdA9INwAynDag1UakxDBGTerppdgWkmOrvGxerpYsj3it9mEV1ULozn/1H0oP8sZdYJjPQ+a+rYq55NLFaNtKKycVhw1RxGIL8Qv2jvN5bBFhFwngoq8DN251dSXk5zpO8xz8Vx9r6tVSEMmkg7nHA+8eQTffX4vLpxThgc/tUR3klWCcNptePCGszC5MAt3/Gk7mjo9qRaJICyTjLxaQ6NJoQzPqczTnF8rXqx4IKKhNtCSiezR0lIwnVI4ls9ClQZlO0ROhCsbB+lloTEmVlnUC8MCRCNJK08mL8OB6aU5UcuCq9FT6G2MWQq5jHY89XMh6xdyfqGc+1cYxQC0QvTHe3QNhfK8DCyzeH+skirjZ8W0Ys35/ICQTLXF2ZhemoNpSTAQraAc/Ig355S0ZCKpcM7xo5cO4GevHsbHFlfjN586y3TFIGLikp/lxKM3L4PAgVsf24a+YY3SaAQxhijIjF85DGa9aOj+cypzkeN2ROQBJRK5Gp/WxKtmkZXmmqLk5eGoMSp8YtWDBoR7ZtRl743uUSpIhByMMcyrzrescBpNNRGLrm82bLgiPwNLagoxR5rXqzjHjQvmlCfFu6MmWHFyHIXayaRj+GC1lEdbXZiJedX5aZU2c87MEqyt059wOxrpcyXEuMMXEPCNv36I321oxE2rpuDn1yyksEbCNFNLsvHQp87C8Q4PvvDkTvhHccSdIBLJZfMrgxNRJ4uCLBcumFOe1HdseV4G1swsxVSLiu4Fc8qD3hcbY7hqUTVmlEUWGUgW6nm0lISMTvPGh2yonFdXGuGplE+RjCqVYw39SqaxHs/8jpOLssLypBJdQVP2vM5STe4cLEiTjtZMnKRjte38TDHfbbSK8FjB7bDH9d6nIiFEUugd8uELT+7AhiMd+OIFM/HlC2em5cNNpDerphfjh/82D//vb3vww38dwPevnJtqkQjCEmW5GZqjurHMtWV2MtZkUhSDhy7H7QhOhJ2K+hlZUvGRLI0iJPmZTqydVaZZZl2P+so8lOdlaOZMpUP+kxaj2WcKslzoGfTq/uYzxtLSG2MFm41pFsIQgh60MX6BOpTkuEfV+50oVs8owYh/bA3ykoFGJJwTnYO45bGtaOr04CcfX4BPUCU+Ig6uW16Do20DeOS9Rkwvy8GnV05JtUgEYYorFlRpKqJ6y1PBuvryUVEm3Q4bCrNcmF0xep4zmRllOcjPcuoaxVZH3+U56LQwWylxtEhFLtyqacUY9PojlsuGG2Ct7P/aujJ0S/spyc90oncovcLfQ5N2p1iQJLE6xuJDqaYkCTm5epTmutHePxL3cchAIxLKlsYu3PGn7RA4xxO3rsBKxYSZBBEr37x0Dho6PPjeC3tRkZeBdfXlqRaJICIoznaHKe56czzGDmXhkQAAIABJREFUOvdjLIUVopHlGh01gDGGc+tKR+Vc+ZlODHkDYeeOxWMZC/JUAcmelDqdcTlscDkivYtnTy/GkC+gsYcx+VlOzVCxc2aUJHQ+vYQge9DGYxIaYYoVU4sTUgRp4r5BiIQiCBwPb2jAT185hClFWXj05mWW8xQIQg+7jeFX1y/GDY98gC88uQNP3LoCy6cmt2IVQVjlnJljc3Q5GZTnZVjK60oka2fFnpgfLyU5bqyeUYLiJBZrscL00hx4RgKYXqpdpnw0cdpt5ub0M4nDbkO61RxL9TxoROqx2xjstvg7JlVsIOKm2+PFZx/fhv97+SAunluO57+wmowzIuFkux34w83LUF2YiVsf24oDzX2pFokgRpV0C58zYqVBaezxTkmOO21yrp12G86aUph2BbrSo3USDx/nOWijyZqZpfjI7NQNtqSa9HpiiTHH5mOduOz+DXjvSAf++8q5+PUNS5AXRwlmgjCiKNuFJ25dgWyXAzf+fgtOdA6mWiSCIAjCIuliwCaasZCDVprrRnH26OVkxUpRtiuuKT3GOmSgETExMOLHt/++B9f/7n04HTY89/lVuOns2nH70iXSh+qCTDxx63J4/QKu/937ZKQRBEGMMcarpjAWqjiePb2EwrHHAGSgEZZ553A7Lv7Fu3hyywl89pypWP+lc7FgUkGqxSImEDPLc/Hnz66Ax+vHtQ9vxvEOT6pFIgiCIEySxvZLXIznedCI0YUMNMI0TZ0e3P74Ntz0+y3IcNrw3B1n4zuX1werVhHEaDKvOh9PfnYlRvwCPvHbzTjWPpBqkQiCIAgTjNdoGyoSQiQKMtCIqAyM+PGT9Qex7t538d7RDnzt4ln41xfX4KwphakWjZjg1Ffl4anbVkLgHNf+9n3sO9ObapGINIIxdidjrJExNswY284YWxNl+7sYYwcYY0OMsUOMsRtHS1aCIMYBkoU2Xg1QYvSgMvuELgMjfjy++Th+924Dugd9uHpJNb5xyWyU543OfDIEYYZZFbl4+vaV+PSjW3DNQ5tx/3WLcSHNkzbhYYxdC+A+AHcCeE/6fJkxVs85P6Gx/ecB3APgNgAfAFgO4HeMsW7O+YujJzlBEGOVsVAkRObCOfQ7mc6QgUZE0Dfsw5/ebwoaZmtnleLLF9Zh4WTKMyPSkxlluXjhrtW49bFtuO2JbfjOZfW4ZTUVrZngfAXAHznnv5O+380YuwTA5wF8U2P7TwP4Hef8Kel7A2NsGYBvACADjSCIqIylMvvZE3gy9bEA3R0iyMmuQfxh43E8s/UEPN4Azp9Vii9dWIdFZJgRY4CyvAw887mV+Mozu/GDf+7H0bYBfO+KemQ4KUdyosEYcwE4C8DPVKteBXC2zm5uAMOqZUMAljPGnJxzX2KlJAhivCEbaOlvnhHpDhloExxB4Nh4rAN/fv8EXt3fAhtjuGJhFW49ZyrmVU/MSUaJsUuWy4EHP7kEP331EH7z9jHsaOrG/dcvxqyK3FSLRowuJQDsAFpVy1sBXKizzysAbmWM/Q3ANogG3mcBOKXjNSs3ZozdDuB2AKipqUmY4ARBjF0EPnZCHIn0hgy0CUrHwAie3XYKT289gabOQRRmOXH7udNx89m1qMinHDNi7GKzMXzjktlYMbUI//nsh7jigffwrY/Opnn6JiZc9Z1pLJP5AYAKAJuk7VoBPAbg6wACEQfm/GEADwPA0qVL9Y5JEMQEQn4RMPKhEXFCBtoEQhA4Njd04sktJ/Dqvhb4AhwrphbhK+vqcPHcCgoFI8YVa2eVYf1/rMHXn/sQ339xP9bva8H3r5yL2RV5qRaNSD4dEI2qCtXyMkR61QAAnPMhALcwxj4HoByix+x2AP3S8VIOqXzEeKM0x51qERJKeV4Gmjo9cNjpaSXigwy0CUDnwAie234KT205geOdgyjIcuLGVbW4fnkNZpTlpFo8gkgaJTluPHrTUjy15SR+8spBXHrfBnx65RR8eV0dCrJcqRaPSBKccy9jbDuAdQCeVaxaB+CvUfb1ATgFAIyx6wD8k3MuJEtWK5CbjhhPfHReJRzjbMKwBdX5qCvPgdNOs1gR8UEG2jiFc8lb9sEJvCJ5y5bXFuE/LqzDJfPIW0ZMHBhjuGFFDS6dX4Gfv3oYT7zfhBd2n8Gtq6fixlW1yM9yplpEIjncC+AJxtgWABsB3AGgCsBDAMAYexwAOOc3St/rAKwA8D6AQohVIOcBuGnUJSeICYDLMf6MGJuNIctFqjURP9SLxhldHi/+KnnLGjo8yMtw4FMrp+CG5TWYWU6FEoiJS0GWCz/4t3m4fnkNfvrKQfz8tcN46J1j+OTKKbhl9VTKvRxncM6fYYwVA/gOgEoAewFcyjlvkjZRV/awQzTKZgHwAXgLwNmc8+OjIzFBEARBiJCBNg4QBI5NxzrxzLaTeGVvC7wBAUunFOKu82fgsgWV5C0jCAX1VXn4w2eWY/+ZPjz0zjE8sqEBj2xowHl1pbhm6WRcMKcMbgc9M+MBzvmDAB7UWbdW9f0AgMWjIBZBEARBGEIG2hjmTM8Qnt12Cs9uP4lT3UPIz3TihhU1uH55DZUVJ4go1Ffl4f7rF+M/L5qFp7eewN92nMadf96Bgiwn1s0px4X15Vgzs4TCVYi0YXxl6xAEQRB6kOYxxvD6Bbx+oBXPbD2Jd4+0g3Ng9YxifP2S2biovpy8ZQRhkZriLHz9ktn46kWzsPFoB/664xTW72vBs9tPweWw4ezpxVgxtRjLpxZiXnU+edcIgiAIgkgqZKCNAXwBAZuPdeKfH57BK/ta0TvkQ2V+Bu4+fwauWToZk4uyUi0iQYx57DaGc+tKcW5dKXwBAVsbu/DagVa8c7gdbx9qByAmtS+aVICltYVYOLkA9ZV5mFSYSfOrEQRBEASRMMhAS1P6hn3YcLgDbx5sw1uH2tDl8SLH7cC6+nJctagKa2aWwj7OytMSRLrgtNtw9owSnD2jBIA4sfu2493YdrwLW5u68fC7DfALYtHz3AwH5lTmob4yD3MqczGtNAfTSrJRlO0iw41ILFJ3onc/QRDE+IYMtDRhYMSPnSe6sbWxCx80dmF7Uzf8Akd+phNrZ5Xi0vmVOK+ulEIYCSIFlOS4ccm8ClwyT5z3eMgbwMGWPuxv7sP+M+LnM1tPYsgXCO6Tl+EIGmuTirJQXZCBqoJM8S8/E5kuepYJa5TmuDGzLBfTSrNTLQpBEASRRMhAG2X8AQHNvcM43unBgeY+HGjux4HmPhxu7YfAARsD5lTm4bNrpuGCOWVYPLkADprwkCDSikyXHYtrCrG4pjC4LCBwnOoeREOHBw3tHjR2DKCh3YPNDZ1o2XUaXDXLcEGWE0XZLhRluVAofRbliJ8FWU5kux3IdNmR5bSLny47Ml0OZDntcNgZHDYbbDbAzhjsNmbZW8c5B+eAwDkE6RMI/57rdpAXMI1gjKG+Ki/VYhAEQRBJZkIZaFxSPAICl5QQLv4viMpIgHMIgrgNh6i8cIQUGfEY4et8AQHDvgCGfQJG/OLnoNePbo8XXYM+6dOLrgEvzvQO4XT3UDA0CgAq8jIwpzIX6+rLsay2CItrCpCbQRPnEsRYw25jmFKcjSnF2Th/Vvg6r19Aa98wzvQM4UzvEM70DKOldxhdg150e7w42TWI3Sd70D3ohS/AtU8QBRsTZbAxBocUAscRMrjUBpkZPvz+Rcij9xFBEARBjCqjbqDd9Pst6Bv2iQYO55IBJCoNaoOII1yxkNfJBlTQsBJCI75B40uQDC6O4P/qEexkwxhQkOlEYbYLhVkuLJhUgMsXVKKmKAs1RdmYXZGLwmzX6ApFEMSo43LYMLkoK2pBH845+kf86PH44PH6MeQLYMgbwKA3IP3vx6A3AH9AfKcFBNWf9O6TB4FsDLAx0bvGmOo7xP9tDLBJBl3wu7S920Hee4IgCIIYbRi3YLUwxtoBNCVPnLSmBEBHqoVIY6h9jKH2MYbaJzpjtY2mcM5LUy1EMmGM9QM4lGo5xjBjtW+nC9R+8UHtFx/UfrGj+/toyUCbyDDGtnHOl6ZajnSF2scYah9jqH2iQ22UvtC9iQ9qv/ig9osPar/4oPZLDhS/QhAEQRAEQRAEkSaQgUYQBEEQBEEQBJEmkIFmnodTLUCaQ+1jDLWPMdQ+0aE2Sl/o3sQHtV98UPvFB7VffFD7JQHKQSMIgiAIgiAIgkgTyINGEARBEARBEASRJpCBRhAEQRAEQRAEkSaQgUYQBEEQBEEQBJEmTEgDjTF2J2OskTE2zBjbzhhbE2X7uxhjBxhjQ4yxQ4yxGzW2+XfG2H7G2Ij0+bHkXUFySXT7MMZuZoxxjb+M5F5J4mGMncsY+wdj7LR0DTeb2Gc+Y+wdqX1OM8b+izHGVNuMp/6T8DaayH2IMZbBGPsjY+xDxpiPMfa2znbnSc/rMGOsgTF2RzLkJ8Kx+r6cCDDGvskY28oY62OMtTPGXmSMzVNtwxhj32eMnZGe+7cZY3NV2xQyxp5gjPVKf08wxgpG92pSD2PsW9K74gHFMmo/AxhjlYyxx6T+Nyz9rp6nWE/tpwNjzM4Y+4HivdbIGPshY8yh2IbaL8lMOAONMXYtgPsA/AjAYgCbALzMGKvR2f7zAO4B8D8A5gL4HoBfM8auUGyzCsAzAP4MYJH0+SxjbEUSLyUpJKN9JAYBVCr/OOfDSbmI5JIDYC+ALwEYirYxYywPwGsAWgEsA/BFAF8D8BXFNuOm/0gkvI0kJmQfAmAHMAzgAQD/0tqAMTYVwEsQn9fFAH4M4FeMsX9PhMCENlbflxOItQAeBHA2gI8A8AN4nTFWpNjm6wC+CuBuiM99G4DXGGO5im2eBLAEwEcBXCL9/0SyhU8nGGMrAdwG4EPVKmo/HSQjYCMABuAyAHMgtlObYjNqP32+AeAuiL/FsyH+Vt0F4JuKbaj9kg3nfEL9AfgAwO9Uy44A+LHO9psA/EK17OcA3lN8fwbAa6ptXgfwVKqvN03a52YAA6m+tiS01QCAm6Ns83kAfQAyFcu+A+A0QlVUx03/SWIbTdg+pNr+AQBvayy/B8AR1bJHAGxO9TWO5z+r78uJ+gdxUCIA4ArpOwPQDODbim0yAfQD+Jz0fQ4ADmC1YptzpGWzUn1No9Ru+QCOQTRy3wbwALWfqXb7EYCNBuup/Yzb758AHlMtewzAP6n9Ru9vQnnQGGMuAGcBeFW16lWII31auCGOXisZArCcMeaUvq/SOOYrBsdMS5LYPgCQyRhrYoydYoz9kzG2OCFCpz+rAGzgnCs9Ja8AqAJQq9hmzPefODDTRsDE7UNm0OtDS1XPIZEgYnxfTlRyIUbsdEvfpwKogKLtpOf/XYTabhXEAYxNiuNsBODBxGnfhwE8xzl/U7Wc2s+YfwPwAWPsGcZYG2NsF2PsC4wFw+ap/Yx5D8D5jLHZAMAYq4c4SPCStJ7abxSYUAYagBKI4UKtquWtEDubFq8AuIUxtkyKuV0K4LMAnNLxIO1r5ZjpSrLa5xCAWwBcBeB6iAbdRsbYzATLn47o9Q15ndE2Y63/xIqZNprIfcgMem3oQOg5JBJLLO/Licp9AHYB2Cx9l9vHqO0qALRzaegdAKT/2zAB2pcxdhuAGQC+q7Ga2s+YaQDuBNAA4GKI/e//IIbpAdR+0bgHYijifsaYD8A+iB61B6X11H6jgCP6JuMS9ezcTGOZzA8gdqZN0natEF29X4cYshHLMdOdhLYP53wzQj/MYIxtgvhjfTfEGOfxjlZ7qpePp/4TC4ZtRH3IFGb6GZF4Jvqzawhj7F6IoU3ncM4DqtXR2k6rHcd9+zLGZkEM01vDOfcabErtp40NwDbOuZwztVMazLsLYpi4DLWfNtcCuBHADRCNs0UA7mOMNXLOH1VsR+2XRCaaB60DotGgtt7LEDkSAEB023LObwGQBTHcqgbAcYixth3SZi1WjpnGJKt91PsEAGwDMBG8H3p9Awi16XjpP7Fipo3CmGB9yAx6begH0Dn64kwILL8vJxqMsV9A9Hh/hHPeoFjVIn0atV0LgDJFWBqk/0sx/tt3FUQP7V7GmJ8x5gdwHoA7pf/lZ5raT5tmAPtVyw5A1E8A6n/R+CmAn3HOn+ac7+GcPwHgXoSKhFD7jQITykCTRqK2A1inWrUO4XGyWvv6OOenJMXwOojJkoK0enMsx0w3ktg+YUgP6QKIL9HxzmYAa1h4Ofh1AM5ANGTlbcZ8/4kDM20UxgTrQ2bYDOBC1bJ1EEeRfSmQZ9wTz/tyIsAYuw/iCPxHOOcHVasbISpw6xTbZwBYg1DbbYZYXGSVYr9VALIx/tv3eQDzIXou5L9tAJ6W/j8Maj8jNgKYpVpWB6BJ+p/6nzFZCI8Qg/Rdthmo/UaDVFcpGe0/iK5bL8Q8qTkQY5MHAEyR1j8O4HHF9nUAPg1xpH45xBdkJ4BaxTZnQxyp/ibEkqTfBOADsCLV15sm7fM9iHHg0yD+uPxeap/lqb7eGNonB6EfzEEA/yX9XyOt/zGANxTb50N8kT0NYB6AqyFWLPzqeOw/SWyjCduHpGX10jZPQ1TUFgFYpFg/FWLy9S+l5/az0nP876m+3vH8F+19OVH/APxaeoY/AnGUXf7LUWzzDWmbq6Xn/mmIgzK5im1eBrAHwEqIyt0eAC+m+vpS1KZvQ6riSO0Xta2WSb8P34aYx3cNgF4Ad1H7/X/2zjtMrvK6/9/3Tt3ei1ZdWvWKJBASAkTHYIrBhJhgjAsOJm7YTvJLbMfEhuAU28FxwYY4so2xsYkxpoUuQEgIEOpdWrXV9r6zu9Pf3x8zd+bOnfe2KTszu+fzPPvs7tx27nvLnPOeZmr8NgFoRaRFwSwAHwHQDeB7NH7jeB1yLUBOTjqSPHoSgA+RGdCLFMs2Q1HGOvqluxMRRWoQkZmtpBKhAD4K4FD0y/oggJtyfZ75Mj4AfoDIzJUPkQTRFwGsy/V5pjg2GxGJn1b/bIou3wTgpGqbZYhUN/Ii4vH5FqLl4yfo/ZPxMaJ7CCdF26jWuRjAB9ExOgHg7lyf62T40XtfTtYfjfubA7hPsQ4DcF/0efcCeAPAUtV+qgE8hogiOBT9uzLX55ejMd2MRAONxk9/vK4FsDs6NkcQyVVWfqfQ+GmPXRkik32nEKnK3YJITqSbxm/8fuQeQwRBEARBEARBEESOmVQ5aARBEARBEARBEPkMGWgEQRAEQRAEQRB5AhloBEEQBEEQBEEQeQIZaARBEARBEARBEHkCGWgEQRAEQRAEQRB5AhloBEEQBEEQBEEQeQIZaARBEARBEARBEHkCGWgEQRAEQRAEQRB5AhloBEEQBEEQBEEQeQIZaARBEARBEARBEHkCGWgEQRAEQRAEQRB5AhloBJECjLH7GGOcMWbPtSwEQRAEkS/Q9yNBpA8ZaARBEARBEARBEHkCGWgEQRAEQRAEQRB5AhloBJEeixhjrzPGRhlj7YyxbzPG6LkiCIIgJjv0/UgQKUIPCkGkx58AvALgRgCPA/gmgH/KqUQEQRAEkXvo+5EgUoQSOAkiPR7hnH83+vdLjLFyAF9ljP0n53wgl4IRBEEQRA6h70eCSBHyoBFEevxe9f/vAJQCWJoDWQiCIAgiX6DvR4JIETLQCCI9OjX+nzreghAEQRBEHkHfjwSRImSgEUR6NGj8f3a8BSEIgiCIPIK+HwkiRchAI4j0+AvV/38JwANgXw5kIQiCIIh8gb4fCSJFqEgIQaTHXdGywe8BuArAZwDcRwnQBEEQxCSHvh8JIkXIg0YQ6XEDgCsA/BnA7QDuB/CdnEpEEARBELmHvh8JIkUY5zzXMhAEQRAEQRAEQRAgDxpBEARBEARBEETeQAYaQRAEQRAEQRBEnkAGGkEQBEEQBEEQRJ5ABhpBEARBEARBEESeYKnMfm1tLZ81a1aWRCEIgiAmGjt27OjhnNflWo5sQt+NBEEQhFX0vh8tGWizZs3C+++/nxmpCIIgiAkPY+xUrmXINvTdSBAEQVhF7/uRQhwJgiAIgiAIgiDyBDLQCIIgCIIgCIIg8gRLIY4EISIc5hgYC6DH40P3sE/x24++ER/6RvzoHw3AFwwhEOTwh8KwSQzVJU7UljpRU+LCzJpiLG4qx8rplSh20m1JEAQxHry4vwMuu4SNC+pzLQpBEAQRhTThSYwvGMKOk/3Yc3YQRzs9aBsYQ4/HB38ojFCYIxTmCHMOG2OQJAa7FPltYwyBUBij/hDGAiGM+kMIhXnS/h22iBFWXeJCVbEDFUUOOG0SHHYJoXAYvR4/jnR60OPpxcBoILbNOdOrcOWSBlyzbAqaKovGe1gIgiAmDd5ACN5AKNdiEARBEArIQJtkcM6xraUXv3v3DF4+0Imx6BdzQ7kL06qKMaeuBG6HDbaoISYxhhDnCIc5QpwjGI787bRLKHLYUOS0odhpQ22pC7WlLtSVRX5qS10od9vBGDMlV4/Hh31nB/FOSx/eONKN+587iAeeP4jLFjbgUxtmYd2cGtP7IgiCIAiCIIhChQy0ScS7J/rw4AsHsfP0AMrddty0aiouWVCPc2dXo6LIkVPZaktd2LigHhsX1OP/fWghTvSM4H93tOK3757GbY90Ys3MKnz1ygVYN7cmp3ISBEEQBEEQRDYhA20SMOYP4YHnD+Cxd06jodyFB29aho+cMxVuhy3Xomkyu7YEX7tqAT5/aTP+8P4Z/GTzcXzskXdw3YomfP2aRWiscOdaRIIgCIIgCILIOGSgTXBauj2461fv43j3CO66cDa+csUCFDnz1zBT43bY8PF1s3DLmun46ebj+Okbx/HqwU588bJ5+PSG2XDYqBApQRAEQRAEMXEg7XYCs/V4Dz7yk63oHw3gN59Zi69fu7igjDMlbocN914xH6/cezHWz63Bd184hFse3oZTvSO5Fo0gCIIgCIIgMgYZaBOU1w514s5fvIf6Mhf+dM8FuKC5NtciZYQZNcV49BPn4ke3nYOWbg+ueegtvLC3PddiEQRBEARBEERGIANtAvLaoU789a93YEFjGf5w9zrMqCnOtUgZ58PLm/B/X74I8xvL8LnffIDvvnAIYUGpf4IgCIIgCIIoJMhAm2DsPjOAe37zARY2luOxT69FZbEz1yJljabKIvzus+fjtrUz8PAbx/HlJ3bBF6R+PgRBEARBEEThQkVCJhBn+kbx6V++h7oyF35x57moKM5t6fzxwGW34YEbl2JGdTG++8Ih9I748PDtq1HmnvjnThAEQRAEQUw8yIM2QRjzh/DZX++APxjG/9x5LurKXLkWadxgjOHui+fie7eswPaWPtz6s3fQNezNtVgEQRAEQRAEYRky0CYAnHN8/am9ONQxhIc+dg6a68tyLVJOuHn1NDz6iTU42TuCj/38HXQP+3ItEkEQBEEQBEFYggy0CcBv3z2DP+48i3svn49LFtTnWpycsnFBPTZ98jy0DXhx+6Pb0Tfiz7VIBEEQBEEQBGEaMtAKnGNdHnz72f24cF4tPn9Jc67FyQvOm12N/4560m5/dDsGRwO5FokgCIIgCIIgTEEGWgHjD4bxpd/tRJHDhv+4ZQUkieVapLxhfXMtfn7HGhzr8uCOX2zHsJeMNIIgCCWcU2sSgiCIfIQMtALmkbdasL9tCA/etBwN5e5ci5N3XDy/Dj/5q1XY1zaEzz++E8FQONciEQRB5A3UOpIgxo/3Tvbhpf0duRaDKBDIQCtQTvWO4IevHsXVSxpx9dLGXIuTt1y+uAH337gUbxzpxj/9eT/NGBMEkVU6h7wIFMhkEL0PCWL8aBsYw1iAerVmmmNdw3h611mEJtiMExloBQjnHN98ej/sEsO3rl+ca3Hyno+dNwOf2zgXj28/jZ+/2ZJrcQiCyACMsXsYYycYY17G2A7G2IU6605hjD3OGDvEGAsxxjYJ1rmLMfYWY6yPMTbAGHudMbbBikwjviDeaenFrjMDKZzR+DOx1BmCmDgEQmEMjFKRMzMc6xoBgIKZGDMLGWgFyLN72vHmkW589coFmFJRlGtxCoK/vXIBPrx8Ch584RCe39uea3EIgkgDxtitAB4C8C8AzgGwFcALjLEZGpu4APQA+C6A7RrrbATwBIDLAKwFcBjAi4yxeWblCkZncD2+oNlNckqYPGgEkZdsb+nDG0e6Ec5Tr9D+tkH0eiZmK6Mxfwit/aO5FoMMtEJjcCyAbz97AMumVuAT62flWpyCQZIY/uOWFVgzswpf+f0uHGgbyrVIBEGkzlcAbOKcP8I5P8g5/wKAdgCfE63MOT/JOf8i53wTgD6Ndf6Kc/4jzvlOzvnh6L6GAVxtWbr81KmSyKV9Fg5zCrEk8pKuYS+Od3tyKkN/1HuWr0/IsS4PthzrybUYWWHLsR7sONWf8/cTGWgFxn+8eBi9Hh/+5SPLYKOqjZZwO2z46e2rUVnkxF8/9j6FDxBEAcIYcwJYDeAl1aKXAKzP4KGcANwA+jO4TyLKM3va8ObRiangEYXNtuO92Hd2MKcysKh6l4qXe3AsQPpNGoz68yMCggy0AmLn6X48tv0U7lg3C8umVeRanIKkrsyFn96+Cp2DPnzxd7smXFIpQUwCagHYAHSqPu8EkMmKSfcD8AD4s2ghY+yzjLH3GWPvd3d3Z/Cw40e2QhyPd3swYiLMk5RIghDDELHQUnlENx/uwhtHsvdOOtEzkrV95xO5dvCTgVYgBENh/ONT+1Bf5sJXr5yfa3EKmnNmVOG+65fgzSPd+MHLR3ItDkEQqaH++mSCz1KCMfYlAH8N4CbOuTAemnP+c875Gs75mrq6ukwcdtzJhgISCIWx7+wg3p6g4U9EnMGxALxUlTArpONByyYdg17sac23IkiRMcr0UOV65MlAKxD+5+2TONg+hH++fgnK3I5ci1PwfOy86bh1zXT86PVj1JeEIAqLHgAhJHvL6pHsVbNM1Di7H8CaVCVOAAAgAElEQVQ1nPN3091fPpMN5U8OvPdPsIpqE41QmKdd9W7z4S68fCDtR44QkK8JLPlcKZGnaVJxzrG/bTDh/1xCBloBcHZgDN9/+QguW1iPq5ZQz7NMwBjDP9+wBMumVuBrf9idFxV7CIIwhnPuB7ADwBWqRVcgUs0xZRhjXwHwAIBrOedbrG+vvez1w13jXkE2FObYcapf08uRDfVD3meeTfxPSoa8AYz5xdf+tUOZuR+zYeSf6BnB4Ggg4/stJPLVg5ZPqN9r6Q7VkDeIY13x4jDK3XHO0T08vlUryUArAL719H4AwD/fsARMTwMgLOF22PCj285BmANf/O3OvJ4ZIggige8DuJMx9hnG2CLG2EMAmgA8DACMsV8xxn6l3IAxtpIxthJAOYDq6P+LFcv/FpEy/J8CcIQx1hj9yUjC79BYICPvGI8vaHpmt31wDK39o5oFD7Kp+4WjCs2p3smRr5KPvH6oCy8diEeIbG/pxeGOYQD5UwhBxJ7WAWw+0pVrMXJMRNejNHkxXUNevLi/A51D3thn2Ryq490ebD3egy7F8bINGWh5zov7O/DKwU58+fJ5mFZVnGtxJhwza0rw4E3L8MHpAXyf8tEIoiDgnD8B4MsAvgFgF4ANiIQknoquMiP6o2Rn9OdCANdF/35esfxvADgQ6YXWrvh5yLJ8WVIVhrwBvHqwE0e7MlQCPAtiKo2+rcd7CqZp92SgY8iLQx2F2WKmc8g7rspxvpDrMDs1mRKna9gLXzD1/MX+qIe1X1FoKNNjpdydxxeRdUwjGmHHqT5sO96b8NmhjqG0vG72lLckso7HF8R9f96PhY1l+NSG2bkWZ8Jy3YombD3eg59uPo51c2pw0fzCTPgniMkE5/wnAH6isWyj4DPd8APO+az0ZUp3D/p4o+FqvR4/0JD+/rJhSGbLOCW0GfYGYJckFDltptZ/etfZjB6/Y9CLUrcdpa7sqZTvtESU3xtWTs3aMTLN4FgAvmAI9WVuy9vGQxwzLFQewDnHtuO9KC9y4JIF9WnuS/F3mnKpA9RE7zKtd3xr/1jSZxFv9XDK9yx50PKY7790BB1DXjzwkWVw2OhSZZN/+vASzG8oxVd+v2tSztIRBDH5yLPJ+bzgYPsQuoYL6zvgNVUo43iz/UQvXj1IxULUbD7cFfOqWG0pIdsKeedBy8AEjHxKw97Mhtnm2VClDWn9ecq+s4PYtPUEbjtvBlbPrMq1OBOeIqcNP75tFTy+IL78BPVHIwgiBfL0taGVupyVIiF5OgZmOdI5nBSqpEffiB/HuoazKNHkIt8MEhGne0c1i6+IONU7YrkvmVxvoACGI2Uyda2zNUbK/eai+gMZaHlIKMzxj0/tRXWJC3939cJcizNpmNdQhm9fvxRbj/fiJ68fy7U4BEEUGIUW3lcIynC+89bRbuxvK8y8rnzEzC255WgPzvSNgnOO8DhPpgZCYew8049tLeb7/HWp8pDMPHeyQZDpKo7eQCihsIZVMiFOJs5IOOmU5o7NGGHpyr7v7KBm0SY1ZKDlIY+9cwp7WgfxzQ8vQkUR9TwbT25ZMw03rGzCD145gndP9OVaHIIgCgiyd4hCY8gbwNO7zsLjy4+qjmYeod4RHz443Y8PTvfjmT1tWZdJifyM+wLmK7KO+q2Xg89WDtrhjmG809KbchhvPr/ilBNkmbivs/E+P97twfFuc0WeyEDLMzqHvPj3Fw/jwnm1uH5FU67FmXQwxvDAR5ZhRnUxvvjbnegbsRY3ThDE5CXbPcCs7tZIDgpxJFr7IsUN2gfiRQ7G/CH4g7lpO2PkMVJ6zESFGWR6PT68cqATwQy3z0nFS57Ur0u1vGvIizN9ib1YZQMt0155uYH8qC/1Corpki3PvXK3bdH7+azOPZJNMnGOZKDlGd9+5gACoTDuv3Ep9TzLEaUuO3502yr0jfjxtT/sHvcQCoIgiPEgG3pSoYV5FhJvHe3GztP9Gd1n3BCI89KBDrx2qAseX2Lj3vHA6J4MCVYQ9Rc80D6EEX8Qg2P6Da9P947i6V1nTRukqTwz6m3Uyvu2ll58oHFdM/2MStELLhpHM2TC8MjkKWlVcYydpwX9Tb1mS0/83reqjmfiupGBlke8fqgLz+1txxcubcbMmpJcizOpWTq1Al+/dhFeO9SFR95qybU4BEEUAPmQ08U5N+35z0qZ/dwPQVYJhXmSRwTQvvZHOoctV/DTom/Ej9MqT0um8AfDCeflC4aw5WgP9rcNpl00yx8MGxpKMkb3pNLDJk9iB0Opy3c8qoRbKfphnUT5jnePGB6PxRpVZ/aBkqKGRi4LoWWvqEd8x7KBZmX8Xj+U2BxdNDlh9h2fiVMkAy1PGPUH8c2n96G5vhSfvWhursUhANyxbiauWdaIf3vxMN4/SfloBEHok0vbZGDUj1cPdmJP6yDeOtqNwVETCnFWPGiFixnla3tLL17cn1zSXrQp5xwH24fQNjD+ZftFRqQI2TNwvNuTdF7BsPXwwCFvIOne236iF5sPd2lskYjRJVCKZI9aG/4MhzHqHj8F60JtCx3qGMK7RjqF7NlM84HqHvZhb2u8KAVLwbOkJF+eb6VDi6t+A3FDNNMGrlkoxHEC8f2XjqC1fwwP3rQMTjtdlnyAMYbv3rwc06qK8PnHKR+NIIj85WD7MDy+IE72jgAAfKHc5ZjkI8/uaUtQVEWY0am6PT7h56JNg1EleLyVxGAoLDQiRTATteuseiE2H0k0xuTvzmAo4qVLx1ulDM2TDTRRiKNZzEau+YIhtPaPplS0Q2QMGeXGaVVx7B72Yccp7TBXtWGw9XhPQqievD+RTAfahnCwPbki6eBoIKPRAdkKg1aKaJNkD1pm9m3mOVGSieOSJZAH7D4zgF+8fQK3nz8D586qzrU4hIJytwM/juaj3fvELspHIwhCE1lB0NNlxisMMlGhECsX2Xidic4vH0I/Q2GeoKiKsCKl+pxEim86YWTeQAgvH+jEsFfsCT3ZM4JRv7hCnZX8IjO5NVreQbPYpYiqGQxzvLi/Q7eptmEOmmJM7bb0DTSzvHeiHztO9ScYl+Ewx+GOYcPrnIqBrtUHbevxHrT2j2qOv9EtJ28mkvlo1zCOdCb29BsY9WPzkS4cjYb75cGjrInS8EslB83cMazLkipkoOWYQCiMv//fPagro55n+crSqRX45nWL8caRbvz0jeO5FocgiDzFzJdyOgqOni6tVrRzVWNKdHpGRRLyBStyqfU+ziPejWf3tMVyV2QPGucRj4mV/XcMejHqD6KleyRpWSjMsbt1AFuO9pjPiUljzNX3tS8Y0vQkirBZ8HSZreLIGEs7XE+J6NlVjtlQ1FBWrneidwSHOoYSyqZzzuELGnsIjZ5PebHWcGidstH4yecUDHO8fqgLrx7s1F1fbhEQzyHMwFhn8PFPuG6KP2PFb3LwrnntUCeOdqZfXIcMtBzz8zdbcKhjGN+5YSnK3dTzLF+5fe0MfHj5FHzvpcPY3tKba3EIgshHNHQBZZGIvjQKRih3PzianOujxFzT1fFRXtRH8WW5hPup3hEc64p4Ajy+YIICf6hjKBb+py6oojUaPR5fUvSE2igIcx7ruTQ4FtlnKFq8goPjub3t+OD0gKHsB9qGMDDqV/TB0r5G3mBYqKiLPV7ifZi6T1Tbbjvei23HzX8PyqGIZop5iA18hVcy+jeDsREDIKEadjjM8frhLuxvSw51NRpH2bhU5sDJ94DyvPadHcL/7eswNEaNQuaMrv8bR7qElSe11pfHUF4aCnMMeQOm+4S1DYzBGwhlxeueCiIDlycsz5zx7g2ELE14DXuDpnud6UEGWg5p6fbgoVeP4ppljbhySWOuxSF0YIzhwZuWYWZNCb7w253oHjY/e0gQxOSlpduDN450x/5/+5h5r4cem48k5vqo9QczbVqyUmbfIBwuYCE/SslL+zuw+4yxgQMAu84MYH/bEE70jODVg50J7+vDHcOxAhrHujx462g3eqLeIJHsA6N+vH2sBwc7EnNzRIpwKKa9Rz1G0f/lVVv79SswhsIcR7uG8dbRnoQQLbWyLx+bc246fE5rrVTa+ZityChji4YijpkoXKJ+Nl4+0ImXD8S9PLKhLCnkNhtSPOQNYGgskFCdj1ms9ievpzVsbYORvluZCq3T2suwN4iOweTiM0YeN3n8zMqnXGvIG8h6iKPcYNoo599oEkK+7spw39cPdRnmoao50zeKF/d3oD86sWZcxCZzA0QGWo4IhTn+9sk9cNsl3HfdklyLQ5igLJqPNuQN4G9+88G4xL0TBFE4iL6ah7zJM9Ry1blMvEP0qvVZbVTd2j+KPa3aRpA3EMJL+zs086KEO1V9lGoD5LFAKFYAxSydQxEFdkSQqzXmD8WuzdvHetA55BV6FL2BiLwe1XVUK/RhzmMhjbLyLivBZpX/kGJ7Kep1Ojswhuf3tmtuY9Zblk4oZLpFTmQP2nsmqiGrjzTqDyYYdiGBgaTnCVYu0dOdRecoWt3IsDHj1QMihsjJHuP7mXOOXo8PT+86q//cGRxX5EFLBfU4qRtsm0EtYyjMY4ZNZ9TobB/UbzAt7yKxD1r8H1E+8JA3YJiHqqZrOCKP+vnXIpBC5VMtyEDLET9/swU7TvXj2zcsRX25O9fiECZZ3FSOf715Od492YfvPHsg1+IQBJFHiJQ80US7PxhGa/8ont/bbq4cfhSR8uULhmMeoMR1ub7iKtjZjlP9OKGjNHYMejEWCOG4IC9KD+WhUm2QmwqyMWgTuDvUhSoOtg+JDRuNMVQruJE8s7hnC1BWcTQnr3z/SEw/AE4pp9iwMGdsiGXQP54eLygMSX8wjHCYg3Mey0EzAzfQb2NGrEn5RF4VAOhXeWjMnmNCHzad9cyED+/WmQyR7wAOxNo0qCN3RF48zRBH1XJ1CwVTBjxPHidlg+0tR3vw7gkzRnjiTp7d04bXo20Y5PtPMvDsJl7X5M9k0p1ckJ/puDj6+9ML47WaHmO3tDaREQ51DOEHLx/Bh5Y24oaVTbkWh7DIDSunYn/bEH7+ZguWNJXj1nNn5FokgiDyAFk5MVIJ/MEwuqLK1uBYABXF5vKPRUqfVn8pjrjCotZ1hrwBvH6oC9OqikwdV0aumqdXIlxsHMQ/C6XRVNgqsoGmZRQq7QYtxSo+homDqDZklB40eXjkcTLrvQrGwveSr5kydEo5nkMCr4qlHDTVcURVKM1eMWU/shf2RYy1psoiOG3mfQFGho3ynjYTnqgce+U1e/NoN25YOVWznH1828QBOtOn79lJJWRUD86V+WjG62vnoMl/iNcz61HTG+vekdRTP+RcOOUkhczmw10oL3Jg1Yyq2GdGkxB6j9zxbg/m1JaYulZxr7a4qqaaoM44dgzFQ1K7hryGzhnyoI0z/mAY9z6xG+VFdtx/49KMP8zE+PB3Vy3AhfNq8c0/7U+YQSIIggCAEz0jmtXc/KFwPBRKoGgcaBuKhdakCuc6RS+ixmHnUFyhGjFRLEBZLl3vuHqf6W2baWSDQcv4Un7/BkJhXeUrGArjFVUulHLMOOIGWfvgGNoHxyx70OJKMkuSRakYK5eJinWY9aoBySGnom3T8UK0DYxZ0nMSvK2CgTMbiihaph6DQCgcyy0Seg4F+xMZIfJ+2wfHYq0PMuco5jFjRX3uIt1D67CyjPJ5qp8Js89lJs7LjMczzDn2tA5gcCyAwbFAUiilURivfL6i9fadHUR7NJSSc46zA2OakyhBlce2e9gXC50Wrm8ybH2bCW8aGWjjzA9fPYqD7UN48KblqCl15VocIkXsNgn/9bFz0Fjhxl//egfODujPqhEEMXkY9Qexp3UA758UT974g2HNGdlwtFCESPE2UwVPhoNrKh2y4WJXuJDMTDRF7TNdOYwk1AqtCobCphPsj3V5dHPv4seK7E8r109pNvhDYV3lv2fEn5DL1j/qxyuKEuWcJyq5bQNjKeegSSx5HK0U5hAdTUsEdd8rkVGUvlKevANfMIR9ZweTrrlyrES5g+IQTG0BE8ZetdrZ/vj3tiyHle/yA6qmzsrwvkzZZ5zHnzsz95EyRFSZxxULA4T4njTrQfObMEB6PD68erAzts9Q2Fy1VKVcg2MBnOgZwXsaIZNKQ04PraXyu+9Ylwfvn+xDa7/4usefycj63R4f3tExrqxMQBnl75GBNo68f7IPP9l8DLesnoYrFjfkWhwiTSqLnXj0E2vgDYTwqf95TxhqQhDE5EUrqT8Q4pr5K7JSKsrbseStF3jQOI8YbYFgZInDHlcBjMp+y/sEko0sw814pMCIPxhOMu5k/eq5ve0J1S61GPYGsL9t0FzBCVUumOH6JvYloy5PzjlPUHIZY/HS7KZDHCPrS4wlGS5bjvXE/n5b8bdYVlOH05DBpCvJAmIvRqR/WIfKG6Fc9fVDyeG7CWMs2P/gWABbj/XEwzMVy9SnJqoEeVhRrVNvHI1aRaSb+xSTAXE5zRR/UR5XlA8W86DpGMZaDHmD6DXR/273mQF4fMHYu2xP6wDeOtot9NKr7/OY4SUbdxpyxSuZir1l6s2SxynyW+7zpnU9gxYnWUb9xhNHMkbvczLQxon+ET++8NudmF5djH+6bnGuxSEyxPyGMjx8+2oc7/bgnseosiNBEHF8wbAwkX/YG4g3MVYtG/FFvuCLnba0jj3iDyUoKdtbevHn3W348+62+Cy4YrmZKDR5db3Zdq0qgC/u78ArBzuT3pHKtYe8AcP+QfL6fSN+7G0dxOGOYfR4fMKS4zJaYUfqcz6q8iYB2t4ZUZEQ5WcSY0IjQY1cSCPyd3RbSX8brd5VW45GDTehIq+9PyVCD5pih4c7ksfICLFHT6z4GskZX1/R30yxzZ7WAXR7fDGPIxduG90DS16W6HAzN2iikLdMhThyHs+VNOPd1DIklK0ZRPsyM4exv23QVKsEOWxWYgweXxCno54i2eOY0HZDMdnz9K6z6ImGkMryiAr8KDnZOyJ8zuQ/ueC6RvZv1qttbZKlTyMPL5XWKmSgjQOcc3ztD7vR6/Hjx7etQhk1pJ5QXNBciwdvWoYtx3rw9af2ZqTHEUEQE5fTfaOxnljK98XO0/Eqig5VYQWr75U9rQNoiRo7DIkJ6uoy8PI6IjoGvbFZ83gFOB0DTeezQCiMvWcT+xCpQxW1Qo1EtPR4cKhjCG8f68H2E9phRwGtHDTVWZ8WhBxpDbuoSIhytp8pjiuqsinzzJ427DsbUVxlDxoDS6mJuJwfZVSoRQ+REeAPhvH0rrN4etdZHFL1gzNCYsn5dED8HlQue2Fvu+H+RfK16eR+yZ6YMX8o6V6TJKWRl/r39rA3mOQtz6QeoFegQvlRKMw1n81YiKOGWKnKK/L0+xXFcXoUlSfbouGjyiOpPepDUcNafhZEYa6RfSd/tvNMf2wCSM+zCIgK4GhNxMjbCxcn7AsAxvziyaBUUm+piuM48N9bTuDVQ1345+uXYOnUilyLQ2SBW9ZMx5n+Mfzw1aOYUlGEe6+Yn2uRCIIYR7QUHCtfzEoDQT1zrNyPWWVba7Zb3rNSmVMXcgiEwgiFeczwuWHlVE3lbnAsEKsmOaumJGm5nvLXNezDbFdcFXHbk+eNrSiPoj5rWiGZepPzz+5pw+zaEpRrTKgmedBUcprp2Sbvo6XHg5YeT+xYjKWm0Mmot42EtprbVmQAmfGaaGGXmPD6yYZ4MNqIu3/ED38obNigOC5f/CkYGgvg5QOduGheXewzxuLH9QVDSW0VgMRJiTCPeHCUWLFZ1F7NVPqMcc6TnkMODolJURnF3mlb9ExePtCpWZiopXsES6eWa747tMTVe/ZqSlzoHYn0aFszq1q4TyPPvFY+q1G+7RmNpu/HujyYU1cSLwKikCVRtkSPohbypIvW9WztH8WOU/FQRa13TSoGMBloWWbn6X5894VDuGpJA+5YNzPX4hBZ5N7L56F9YAwPvXoUpS477rpoTq5FIghinNBScNoNig5ofW2rFTWlgpBuL1RZOUno6aRs/Mu5sDmylqzK/kwiw0RPNVGHH7ocNngDIQTDHKVRw82KbvOmII8tGIpUwit22hIUab1wylCY41iXByunV4rlDidXP7R6XdRKn5zHrDQuUkG9bSRPxxwiIyDVpsZAxJuizjNTsqd1QLc5upYsnCef58neEeG5j5nIC0q1gbqMHJockzOF68cVBo0yr0p2UolbAcT/1jLOgMgkQEO5S3iPhsJc6D02QlLMpbwvygnVNPrif2sZNHrpIoFQWHO5PxjG1uO9MU+cjJEHrWtYPzRR1KB7enVxQqEZ0XoyqUxyUIhjFuke9uHzj+9EQ7kb/3bzCiqpP8FhjOG7Ny/Htcun4IHnD+LX75zKtUgEQYwD3kA4FmKlxqjqWTz0SF+hU37xWw3HUlemk0PvEjxoApnUyDJ6AyFTxQJk9JRf9aGcNgkv7u/Aq8oKiSZkkxGFRAVCYdglZtj8VoSWbZI0w8+tK+W6uXyW9qS/bY/Hh3cEVUFFiO6tIa9xC4bxIhRTmJPP02GTknKPdrUOaCrHynMVPadauX4i1AUwUvKgiT7jyoqFom2sHYcjOSxx79lBnDLh8VVjl/RNCO3ecnG0nhm996Z6bF32eL5uIBRONM40QjvDqs/VTcCNkAt8qGUZ1nhWXhMUvDGCDLQs4QuGcPdjO9A74sPDt6823YiUKGxsEsN/3roSly+qxzf/tA9P7mjNtUgEQWQZbyCUNINuHnEIjVrxSmggnKYhEPdCiEMctfauPOwWg0qCSvSqDspKnJxzZ9iHKwXLJRjmsEnMVCEU3WMrUI9p/2gAnHPMqilJUBj15dIxXFP0oA17A0k5b9tP9Gnm8qhRhmvJpKK8Z4twzPORbKHZbcmeR865sJphZFn8b1HF1beP9cAbCJm6FuoqgHKlVDXXLW/C7NrkMGBZVrVsXPEmSLcFQtewD8FQOMmw0ru+6v2XueOBd6L8MyXiZxkJ1y0VQ1a9jVIMLcNO/c6My5bOVAgQyGJfRzLQsgDnHF9/ah92nOrH925ZiWXTKO9sMuGwSfjRbatw4bxa/N2Tu/HHD8hII4iJTqoVXOXN1AqEWrdRLjfbL0wLkaxK4+VYlzj0T90zKxPINopeEQOzlfW0lL1AKAy7jRkqlCK0ipao26oc6hhCmEeUVodN+zg9Hl9s2zN92uGvVi6x0rh+7VBXUqXFTJV8zweCyhBH1b3gsEmWDBalZ1nL87HteC/2txkXRlGH6u48EzF0Z9eW4NKF9bHPJYklFKdRPssJnmL5tyKUU9nXLBWOd3vgD4V170816vGsKYn37zXaj+geDoV5wnVLyUDjagNNOZ6J68ZDRbUmqSwfPgGzjalTgXLQssCjb53Akzta8aXL5uHa5VNyLQ6RA9wOG3728dW461fv46t/2A1fMIyPnTcj12IRBJElLPUoUxDLBwuLP4/9r1BktKoSmkWkFClVLVElvWAobCnkyyy+YAjtg2Mxb5LyvIOhMOw2SRXeqb0vvVBKm0E4lhYDo/pFK5SEOQdj0A2llL2Js2pKdAuJWFEcJQakeUsUDHEPWvIYaVWM1EJZHl9rgmXIGzDV41TLc1Nf5tat3P3MnrbY37LsbQNjpu87eRsrho7dpv8seHxBHGgbwuqZVUlGsPLWNprw4EguTrO7dSDhXWY1b/NM3yjsUcPQZZfgC4YNIwq6h31J+XnJVRxTw0pjaquQgZZhXjnQiX954SCuXTYFX7psXq7FIXJIsdOO//7EufjcYzvwD3/cC18ghDsvmJ1rsQiCyCNkRSG56ETk96g/iCKHLUEBM8prM0Jk4BmF/4m2Odo5jBF/KFbMIxVO940mFChQGmORY4ax60y8iMRbR7WbWYsq9ckY9VPKBKEwN53npmecDYz6LRmGNsYQSkPVtEkMG5prTTUKTxeJsbQ8erIyLqpMGeapNCcAGsrdwl5mVtAKcbZb8FZta+mFLxBKyJkzKvByomcEPR4fzpudXEVRC5egUqqSva2D6Br2onu4OGmMld4/oxw0zpMnmtpU+bBWwrW9gVDCRFhVsRMdQ17YJWV4dnIkwtbjySHWYc7x3sm+JHnyCQpxzCDvnujD3zz+AZZNrcC/37I8occGMTlxO2x4+OOrceXiBtz3zAH8dPPxXItEEESOqCt1ociRmJ8k6ycnexKrqIU5x8CoHy8f6MTLBzoTcr7S7bEkyn3yGOTQiSrEHWgfynh+knJC2h8Ko6VnJG3lGYgYoONRp8smMe2mcpnYt4B05/AZWFJPuGxhT1MvUnosRMq/VrEePYwMFjUbmmsFcoknTRwCI0brPhwY9ScVNBF5oZQc7RpG/6g/qcebHlqtI2SUVSN3qypsKg0gMzloRg6mkAUXmnpiSmT8mvVohcI8bePsTN+ocNwzVRCQDLQMcaBtCJ/e9B6mVhVh0yfPQ7GTnJNEBJfdhh//1Spct6IJ//p/h3D/swfSziEhCKLwmFVbguoSZ8JnLT0edAx60dKTmPfFOUfbQMQwSacPlQhROJSRxybTMmihND43H+6CL5C9HI9skM152YoisWKd7iEZM96J0luyemZVysdKJQ9QSUARxqq+jY16qGlh5AlKWt8gRFCJzYIHTUTkcTDWF0ZNtBKQURb6ECEbGKKQYaWxaGRsizxoaqwEAwRU8ojCltUyax0+E3mZWmHt6lGRe0RahQy0DHCqdwR3/OJdlLrt+PWn1yZ9AROEwybhoVtX4s71s/DolhO49/e70u67QhBEYaEV/rbrTPIXfTis39dovOkc0i5DraXspKKMq5Vuf0h7DKZWFlnad6ZsJ7UHQmk4MZZ5X5TDJuHShfUodpqrDmkVBmPvYqlCqS8XGIqiz0RYCfkT4VV8b2bq+bB6n1rxAqbrMRTl2omw4jk0W1XcazC+ZjxoRrlxVnLnkjxoguOr9QmlwAwAACAASURBVCqtd1M2J37Uz9LgmHEOowgy0NKkbWAMH//vdxEMh/HrT59n+QuDmDxIEsO3rluMv7t6AZ7e1YZPbXovK0n3BEHkJ1Z0tXyrvKcXyniwXVzlbl59GepKXcJlWqgVLD1FymHBkwEgYxaaWjFVhq1ayXVrKHebWk9iDGVuh6XKjlZgJqIylecoWre5rtTksRK3Xje3xtR2MlbCe+fVl5laz2r9GCsGXboeQ24yr86KB63UIMJL7iMmevaUshgZ2wOjgaSG0WosGWhB4xBH9XtTa+/dFvo4WqW6xInZtSWYU2vumdCCDLQ0ONM3ir/42Tb0j/ix6ZPnodnky4CYvDDGcM/GZvz7R5djW0svPvrTrTjTN2q8IUEQBY9WboLI0BgLhBKKZ6hxWjVOVFhp2mzZEFJiUT/tHUlUnPQUKStyKfW2VBpWK9HzikiMxa5zrYFx6nbYhPlMyfeJfknw9FNemGHejFIZFolhNudePfbpXgs9FjeVm1rPqgxW1k/XgwYkX3eR0We2suu6OTWG10rumSeqbMk5j90rRsbn8W4POgzyRwM6OWjq4kNJBpoJy1o5dukay2ZhYFg+rRJFaXq8yUBLkRM9I7j1Z9sw7A3iN3etxcrplbkWiSggblkzHb/85HloGxjDjT9+G++dFDfSJAhCDGPsHsbYCcaYlzG2gzF2oc66UxhjjzPGDjHGQoyxTRrr3cwYO8AY80V/f8ScLGZlNreeGZThPi67hDWzqhN6FBlhpDgqldBUDTQOntXiE1p9mFbNEOdIybKkex30cpCU+55r4FVy2BhcjmQl7qolDQn/x3vEZceFZsaDpix2IRLDrO6r9jBm00Azi1W93cr66RaMCKv6vU2pKMJVSxoF65m7N+pNem0BcbVYjvi7w2runogzfaNwC54BIPk5VTcDN9PPTRkGm9ZEkwXk65WuPUgGWgoc6/Lg1p9tgzcYxuN3rcXyaWScEdbZMK8Wf/qbC1BR5MBtj7yDP7x/JtciEURBwBi7FcBDAP4FwDkAtgJ4gTGm1WzQBaAHwHcBbNfY5zoATwD4DYCV0d9/YIytTUXG+Q3JERVqZbSiyAGnTUpSPKx6x65a0oiplUWYXm0+xN5oFt2pqGxnpbFt0nGyqH+LFK4lTeWaqQby8KdrNKpn4rnGMqNzt0uSUBLZGFLfL1ZDHI0MRBkmOJYa5XmJPBFmx1S56drZNaZDQvUKW5gNFdXCqhE1vkZlYhXH2bUlwjELGnjQXHYJFyi8tdctb8K0Kv33hcgrx3n8+pv1SBkVJbFLDNcsS+4ZrLY5AwmTUraE67Bxfj1cdn2PVTrvMUtE5U7XOCcDzSLvnujDRx/eijAHfvfZ87GkqSLXIhEFzJy6Ujx1zwVYO7sGf/vkHjzw3AFLMdkEMUn5CoBNnPNHOOcHOedfANAO4HOilTnnJznnX+ScbwKg5a7+MoDXOecPRPf5AIDN0c91EX0Ni5Q4tT7DGINNYgmKx/UrmjC9utjokEn7AayF8Bh50GRlZlpVcVqhQbJsWhUI00Gdg2KXJDTXl2kan/KnWnqTugWCFnqKntMuKY5j5KXUuE8khovn1+HiBXUA4gag1S5fzfXmc2CMdEmls0TU9868FzmyostuQ2OFG0yx38sWNQi3OXdWNS5orsWCxuRJj6bKIpw/JzmPzaxxCmgbXC67DcumJut4491CKTE8VzzWRnqDy2FLCLmVJP2m3jaJJVVNjEoTe3eYHYaKIv3CeRJjprxbyhL6LocUGwfOI4VPSlz6z28mPH6A9n0qMyU6QaQ1PGbfp2SgWeCpna24/dHtqC524sm71wlnSAnCKhXFDmz65Ln4xLqZeOStE/jML9+z1KSUICYTjDEngNUAXlItegnA+jR2vU6wzxfN7FOkiIv0DcZYgnIlseQva8aY5b5MMnVlrqRZZK1JRK+JKmZXL23EOdMr0/I4yedrNLudClYMRy3jZqlCARcZACKUip5auXfZ44qjxPQrTUoS0zRsKoudSZ5UbYU6PYPBTAsFtdemSXVeZiWIG7dyGFh8y1KXXaioVxY74LLbhJ7l1YJw1ovn1yVcVyO0bqNytx3TqqxNlmjhstsMPVYiuCrEkTFxvqBWHzYZq14/l90mzEED4s+d2RZmWpMzsqFv1uBV9i1z221J42AUeZBuBdHYfgzknV1bAkB70sKs15gMNBNwzvGDl4/g3id2Y9XMSvzxnvWYFb0ABJEJ7DYJ/3zDUtx/41JsOdaDa3+4BTs1emwQxCSnFoANQKfq804AyckZ5mm0sk/G2GcZY+8zxt73DA2I1sCiKYlFCtTf6xJjwkquVpLLp1TElT6X3YarlyaKW+a245zpyUqskUIXDkfDiCQGlyN1VUGe2XemaHTqoTYcjfQeWaGT83Xm1JZibl1pTAmXGNP0oq2cXhkrr6/0oF2zbEqC4aQ2RNfMqtY0TiWmbaApzyeeg6a9rhbnz6kxZcgajZ1WnlB8B+bkkQ0wWfdXK6tXLWlMmvyWjQuRB0Sk3FudUNA0XljmwuKuXtqI1TOrAUS8eyVOuymjSV1mX+tSGuWgibZbOrUCs2tLcOnC+qRlLruEgMArV1vqEnpQ9dAKcSyJ7kedW7mkqQLr59bq3u9uR3J48MoZ+ulGhvewScwau1rrmQ19JAPNgGFvAPf85gM89OpR3LxqGn71qbWoLKY+Z0R2uP38mXjy7vVgDPiLn23DL7acyFpiOEEUOOoHgwk+y9o+Oec/55yv4ZyvqamOKF7TqooxsyY+e6pWNNVfzFrf02YViWuXTcG5s/SbBjPFcayETipPeo7GhKSRosF5XLlUKrqXLqxPMiRFlBiUA5dYYrid0atSFndBQxmqS5xYOCXZY6bchbK318yakpgRoiwSojZ+HDaWZCBoKdUS0zcm5GWyB8VsiKNyTBrK3fjw8ibMqS3V9Qap5WiqLEJdmQsXzqvDqhlVSd6fVMyWiAyR/cgGhfoWsklM00NhOoxSodmqQxTV9+zUyiKdkFjj6paAtecKiEzAXL64AdetaDIMqx0YDSQ04BbdL4wxwxw0kbHgdtiwfFoligXPmcsuJekeNSUuzKwpwYrplThnelVSPzW3w5bUVqO21KVZzVR+z6lln14duff03oNuhy3pfjDy0psNYVaTXHk0pd3EaKqM5EwatSAhA02HQx1DuP5Hb+OlA534x2sW4j9uWZ6VWUCCULJieiWe+8KFuHh+Pb797AF87rEPUm50SBATkB4AISR7tuqR7AGzQkeq+5SVuEAobFCCXbUdGKoUE37rork0VcVOwy/vhY3lsNskoQJ5w8qpSbIB1jwwSuWsptSF65Y3JSyvLHZigSDMXy2PbFTIhozbYUOZ22FKmdoYzcHSgjGGyxY1CKs2zq0r1azmWOyy48J5dcJwOuUYNVWIjRKta1zmtieOt0JOERJjusqeeplWmpFy99OqinBBcy1WTq9MUHCXTavA6pni8WiuL01Sdpsqi7B+bi2qS5yYXl0MFvUuyr2d1OszMMyoLsY506tw5eJGXLNsSpLiv2xaBRxRHUo20LRy8ETnZ9pAU/w9R5WLtmZmVWxcGsvdWDWjSvMaqI+nZTBoPatmPJdqL7uaUX8Q/YqUByYKnYZxDppeTp5ITJGuuz7as85hkzCjJtko3dBcm2S5r5lVpTkO6ufoguZarJpRFXs3rNGZfHI7bJY9pWoDbbHG2C+fVpnwzKrl17uuyntEy/CfWVOCi+fXCXMnlZC1ocH/7mjFjT9+Gx5fEI9/Zi0+e9HctCuyEIRZKoodeOSO1fj6NYvwysFOXPdfFPJIEADAOfcD2AHgCtWiKxCp5pgq21Ldp/zV4A+GdY0gtTLKwXHR/DosbCzHurk1sRLYNolhvaA/lkyZ2246X8rK15ayTL/6NJTKxrz6Mlw0r1aY05Gkk0R3JIenmTUSHXZJt5w9ED83kSK0dGpFQv7X0qaKmDqXHJUgFkpU1AXQzmVZGs33SzZeIiSFvEpMN1xKXlYWDa3UiqaQP64qdmL5tIhhJntyzVBX6kpQdVfNqEJTRXJlxCuXNGLZNHFuF2PAOTOqMKOmGEVOGxw2KSHsTh47hypMUaTDqsdEVsTN5hxq6Wouu4T6MldsYsHlsOleA/Wnl2l4fkVyXbqwHpcbFJMAIt43o6ITejIBkfEKahhoF86rww0rp6JRcD1j+xQWNDI2nNWUKDy3bocNDeXumLF1ycL6pFw0+RjyfVJb6krwRup70CTLniz1/rTeL9OqinDd8nhVyaT7UeN+2dBci4vnxyeVtMRz2Bgqi52G42ktkHQSMDgawDee3odndrfh/DnV+OHHzkF9WXolXAkiFRhjuOuiOVg1swpf/O1O3PzTrbj74rn40uXzspJwTxAFxPcB/Jox9i6AtwHcDaAJwMMAwBj7FQBwzu+QN2CMrYz+WQ4gHP3fzzk/EP38IQBvMsb+AcBTAD4C4BIAG4yEsUsM5UUOLG4qR/tApDGr6Ks38r2evETL2Fo1owpOu4R3Wnpjnym9Y2awosPUlblijaL1DCm5AbCck6VEYgwhhcEj/2W1EqRsjJw7q1qzT6SsOGntWalHVZU4wXpMHVmxvTi0SZ03pRV6KI+hvLo61EurIl9sucSwfm4tyovkXJ3E5eVFDgyNBWL7WDG9MqVeT5FiJXFBzIXsGV/PsMJouHxRJM9JfR+Yq3Ya+d1Y7sa8+jK4HRL2nh3UPK7WrXbZogahUq6ZghZdsKG5FqP+EOw2Sag0i86hTPBsaFHqsmNuXSmOd3sM102+JyNeWC0DrdygxL2I1TMj752TvSOG67rsyW1CgEh492xFaHS524FzZ1XjnZbeWN6tPNGRSly60yYhxOXQX2OKHDa4Vbm0etEOynG2Sww+RDxfoqgBmeoSZ8J2WveV2WeUPGgKthztwVX/+SZe2NuOr105H499ei0ZZ0TOWT2zCi98+UJ8dPU0/GTzcdzwo7exT+fLiSAmOpzzJxApf/8NALsQMaKu4Zyfiq4yI/qjZGf050IA10X/fl6xz60A/hLAJwDsAXAHgFs558K+aWouWVCP2lKXbp6Q1Upq06uL0y5Pr3XM9XOTPXSJqyafx3mzqxOMyboyF2apPDVKnUeZgybShWbrFNuyRT0t6mqBSuRql1aT8bWMT8YSlyVV2Iw1uo781sqRWzG9ElMri1BTkpivrpZG0qjIp0RZmVPd527V9CpsXFAfy+9LNcjHLlmv06k+lqhIhbLIhBzuqFaKRV6EZA+afEyGxU3lwubeettb+fxDS+OeE/njGpVnJ3l7XXFMoTYezB5LXWhmRnUxzp1VHfvfSuSXPA7VJU7Ul7lNFQPZuCBieMsVFGPPiGDdEpc9ISdQfr5SSbO32yRTIY7y+3NBY1nSWGgZSuq9ynLaJSYs4FRR5EgyziL7MRfaqQV50ACM+IL49xcPY9PWk5hTV4I/3rGemk8TeUW524F/++gKXL20EX//v3txw4/fxifXz8KXr5hvuaISQUwEOOc/AfATjWUbBZ8Zfityzp8E8GTawmmQpCBaVExSKb+vZXSpjQcgUTERKU1TKooSqkYCQKlqhl4rB01WhpTvq+XTKtFcX4qXDySm+RU5bIbFTwCgOKosyVFzRpXsGiuK0No/llTcQLmZcg9anhwgUso9SVmLLi912bEmQUlO3l70vxHN9WWYU1uK5/a2I8w5JCniqYkbwalZCnrl/rVQry4qCjqlwp1QGl0+luG+NUJLtY4tr2NUUEvryMpxUxaz0RM1Up1TQm2pCz0en+5xzTCtqhj724YM1xMVrFCe9opplQljbPayXre8CYwljrXTLgEGp+Z22PBhVX4qYOyVBJSeaOsWml1iCJg4OXm8RBVTRS1OOOfJXkopvg8RM6qLk3IdI+tHfpe67KgqcaLEaUePx0dVHM3yxpFuXPmDN/HLbSdx5/pZeO4LF5JxRuQtly5swMv3XoS/WDMNj245gcu+txnP7G6jSo8EUQCkoj4rlYIrF1vvIqBWBpY0lWPZ1AqhAqX8zOwbRT0bXFsaMfzKixyYU1cSUx5ddglrZ9fg3NnGhldzfamwspxMY7kbTkWBFDm/zchAm1pZhA8vbxKGZsokljRXK3DRdcBRWeyMebbkSBstmeNeBePwPiOUxpR8/tVRY9tMSfh59WWoLXXh4vl1MXltJjx5atTrhwRjL+pRJqP2Pip7WGl50PRkuHaZds5QfH3xfuQy8DNrSsAYUxSX0R6TqZVFsZDVVMJK1bgdtoT8JbMwVf6ZVoEVI9RhrkCkiIbLHpFLL5/OJrGYsSP/1vIeKQ9hJux5YWO5sEy/3WbO66t3DK1lSR402cjTuMya9VmiO5KkyD21oLEMF+jkFquZtFPvvR4fHnjuIP648yzm1pXgybvXxXpUEEQ+U1nsxIM3LcdfrJmOb/xpH77w25147J1T+LurF9A9TBA5Jp53FM9f2XVmAB5f0HRDViXKTVLZXq2gNdfHQxRLXXbMqSvFnla5j1t8ZSNjR0ap5FyysB4lzkg+jdyORlnJsLE8udqdqLms+sgbmmsRCHFsPxHJxVurqn5mpQGtSCmb11CGwbEA6svc4Ij3tEtSduXxUQnYXB8pH69Z1IDFfys9LmpDYkNzrbDXlxo5z0/eekXUE2kmN1nOHwTi19hqfiCgCGmLeh3CAi1V6369ZGF9gjd4Q3NtQoEJ9fXU8jwqP1aegxnvjRKHTYp5kIDk3EEjUm0sr8aoKA4Ql2lDcy22HOuBxOLXUZSSk05xu5pSl6l2GEocsbwy8ftD+V6J5aDpvGoWNJZhVm0x/m9fR+JxpPgEjd4EtV4hIbO3fWwfmvePlqGnHe5phknnQQuFOX6z/RQu/d4b+PPuNnzx0mY8/6ULSbElCo5zZlThz5/fgO/cuBTHu0dw80+34dOb3sMBE2ESBEFkh7qyiBFSGc19qCl14dKF9Ull6s2SatiaDIO2onnZooaEPLAGhQFl1imvNCjK3Q7YJJbQK5QbGAF2m5RUAlx97JpSl24VOrM5HVpUFDlw2aIGOO2SblPgZdMq0FjuRo2grLpexbnYbniklYLSc6WkptSVFH6ptz+l8mmlKIWM0yCHT4+FjWVYPq0SK6JVHUsshNqXq9os1JQm9ryqL3NjSVM8V0krt8dqrpkeSg+SbFyY3YtokiEVzNzH8rmJrl1zffw5ylW/XtmbGAgJYl6R2JIgloNmsE+tipJ6o3XhvDqsnV0Te8ZE65a47AneTy1DO26gJS+7fFEDZmjkJ8rrp2okTyoP2p7WAXzjT/uwp3UQ58+pxnduWIp5OhVZCCLfsUkMHz9/Jm5eNRWbtp7Ew5uP45ofvoXLFtbjMxfOwflzqqk9BEGMI02VRfjQ0ikJfYQYU4alxdc1YwOl4jVL2N7C81/itONDS6fghX3t5kMcDbxX8n70+32pF1oL2U7FA6SF8shqA6rUZU/y3lnbN4ckMVOhiHrEPUjp7ef82TXoGvam1N9VkljMuK8tdVky0MzQXF+K/W3iYliS4FlSku7doPaCG5HuMypjxUCLHzv+t9JQXD+3BmOBUEbksoJ8L/mD4mdYlINmNBkkrze9uhhn+kYV+9LeRg77PdMfWZ8jfl+Uue24dGEkZPOaZVPw9K6zACJeyV6PX9NzLrof9O57pmMcmmFSGGgDo378+4uH8fi7p1Fb6sJDf7kS169oIsWVmDAUO+24Z2Mz/mrtTPxiywn8+p1T+Ngj72BJUzk+ecFsXLOsUTengyCIzJGKwpstip02FDmK0FvjN+ydxpiyspo5I8lQqTSh7MpGntMmwR8K64QSScKZeXVvrXRQnnemdASmoYjqVfw02GN0v2kIBaDIaa1fmhaZNs4MMQg5S3dcYmG56e3GMqZCHKO/w4LnymFX/G2TMpIbZxV31DNqJkQ61hvR4DmQJIarljTCZZcwMOrHsDdSpt/MBEWs15oiBFdLtBKXXXgvi0IcL1lYDy52Empub5UJrbEFQmE8vv00/vOVIxgcC+DO9bNw7xXzdROECaKQqShy4N4r5uNzG+fiqZ1n8ehbLfjaH3bjn57eh6uXNuLmVdNw/pyajM44EwSRfzTXlyIQ4jHv3YrpxsWvGGOQnTsN5eZazMSKAmhoIbLypffKaY6GOM6uLUFL90hS6X6ZKxY3CBW/THkwkvabod3Ku5ElTzckTparEGpDnT+nBiHNKgqpEQ9x1FhuUiPWWks20q0o1huaa+G0S3jtUJf5jVIgnicnP1eJRlmumVZVhNFAMClsWYnEGMKcwxZ92VSbCMeUQ2Avnl8fv58E1+eyRQ0IKPqyyfdImPPY+FSaCCNWIm+nDIE0Y0fE7qMUTf0JaaBxzvHaoS488PxBtHSPYP3cGnzj2sUJybEEMZFxO2z42HkzcOua6XjvZB+e2nkWz+1pxx8/OIuqYgcuml+HjQvqcNG8OmE+BUEQ+YVVpV6Zw2OVyxc16OZUKZFnwbWVXeN9SBLD/Gi6gZ6XLx8U0FRQK9WrZlbhdN9oynlCsgFitpBLLjFr6ItYNKUcLd3JzZKNijYYMaXSjRM9DsytFxsRcnhcowXZx+N7dP3c2ti1L3c7UFfqwuKmcrxxpBtAfjwfksSwsFFf17ZJDOEQh8SAjfPrUewy966Rt41PCiUvL3XZAVfi+kDE4+h22HDhvDrLvSWb60tRV+rCFJ08WBHpPp0TzkA72D6EB547iC3HejCntgSP3rEGly2qp3BGYlIiSQxr59Rg7Zwa3Hf9Erx6sAuvHuzEG0e68fSuNgDAnNoSrJxeiRXTK7F0agXm1pXkLMGYICY6TRVFCXkUZlBXucs2Vo6lpywB1vN5UqWy2ClUqNfOrkGJBQVQiah0fCpUFjnRN+KPhb66HbaYQZoK1SVOjPqDEz4SYn5DmXCc5LNONbLVZbfhkoX1mssri524bnlT1jyzelw0rw7vn+rHqD+ImTUlmFldjDePRgwwuQAREPluX2+hZHs+EcshBENFcervNTNXRzbiZa9btaD/oxHFTptlo07JpA9xPNEzgh++ehRP7zqLMrcD37puMW4/f2ZezCgQRD7gdthw7fIpuHb5FITDHPvbhvDWsW7sPD2At4714I87z8bWrS5xYk5tCZqivV7qylyoLXVGf7tQWexAZbETJU4bTX4QhAUaK9y4oLkWbx/rMR2ils9ebjkHrVnDGyEr0dnWdbV6SOlVfzRC1Hw5FZY0lWN6dVFKlRZFrJxeiea6UtNezomG/J1j1oO2bGoFOoa8lo6RC+MMAKpKIhMNLT0elLkjDY6vXNyYscmCfEC+bqnnYEYwo3tMry7G8W5PWu+BVD21XDsS0xQFb6Cd7h3FD187iqd2noXTJuGuC+fgcxvnkgeAIHSQJIZl0yqwLFoimXOO9kEvDrQN4UTPCFp6PGjpHsGe1gF0D/sw4hdXg3LYGCqKnKgqdsSMtsoiB6pKnKgocqCq2InKYgfqy1yYUVOMulIXGXTEpGciPQGSxHDDyqmay8+bXYPW/tGCK1JU7nagpjQzeoSkaj2QLjaJmSrHP9FRK85zakvR0uNJWm9OXSnm6ORE5RtTKiMGmtwIu8ipb4jXlbngzUHFxlSRPb/p5iaqcztFVBQ5dN9PVo5jFbcjMjtVneJ7pLDemArO9I3ix68fw5M7WmGTGO5cPwt3Xzw3wQVMEIQ5GGNoqixCU2WRcPmoP4ieYT+6PV50D/sxOObHwGgA/aMBDI750T8SwMCYH2f6RrF3NPK3N5A8/VzksGFGdTHmNZRi0ZRyLJpShkVTytFY7ibDjSByxLKpFegc8mVl36Uuu2FOSj6ycUHduL6TCs2AzSVaDbaVk465JJUwOiW1pS5LRsX6uYUV6lhZ7IDHl36I7ng9nqkep8ztwKUL6yN5cSlQUG8Ezjm2tfRi09sn8crBTtglCbefPxOf2zg3rURUgiD0KXbaMaPGjhk14oaMIryBUNSI86NjyIszfaM41TuKU70j2HVmAM/uaY+tW1nswOIp5bHGp8unV6Kpgow2YmKiboibawrNwzAeKN8906rMv/dSIdUm5plmamVRQUQfhVOosjheXL8iP65lPrNyehVm1pSkPSmRbh9AmWKnHQ3lyc6dKRVFaB8cS0sPSSesuSAMtO5hH57Z3Ybfv38GhzqGUVXswOc2zsXHz5+VVlwpQRDZw+2wobHChsYKNxZNSZ5BH/IGcLhjGAfbh3CwfQj7zg7hv7e0IBCKfPnWljqxfFollk+rwIro73zOxSEIsxRFc4fqy+j7K9+QS4DLjEfP1FzlO6lZM6s61yKYQs4NTDU3KJvQpKIxNonFwjfzgSsWNwg/XzOzCv5Q7jyyeWugdQ/78NbRSKW5Lcd6EApzLJtagX/76HJcv6Jp0ibHEsREodztwLmzqnGuQinwBUM42D6MPa0D2H1mEHtaB/D64a5Ysu20qqKYsbZ8WiWWTatIOXyAIHJFkdMWa7xK5BeXLKxH/4g/9j8p3PmHbM/S8zO5yfajKUkMbil3tkZeaDaBUBgne0ZwpNODnaf7seVYDw51DAOIuNzvvngOblw5FfPSKEtLEET+47LbsHJ6JVZOrwTWRT7z+ILY2xox1va0DmJ36wCe2xsJj2QMmFtXGvOyrZheiUVTyuCy0wQOkd/QJGN+Uuqy06RPnlNX5sLSqRWYUZ3d0FOCyCXj/hb69jMH0Dviw7A3iGFvAH0jfpzqHUUwWs3FaZdw7qwq/P3VC7GhuRZLmsrzxv1PEMT4U+qyY93cGqybWxP7rNfjw56zg9hzJmKwvXmkG3/8INImwGGLNMpcOrUczfVlmFdfinkNpVSIhCAIYgLAGMNcypkkJjjjbqC9ebQbgVAYpS47ytx2NNeX4soljZjfUIp59WVorp+8vT0IgjBHTakLlyyoxyULIs1GOedoG/Riz5kBKEegWwAADO5JREFU7I56217Y14GB0TOxbUpddsytL0VzXcRgm1dfirl1pZhWVQQ79UskCIIgiIJB7nM800LxskJi3A20V75y8XgfkiCICQ5jDFMrizC1sggfWjYFQMRo6x3x42inB8e6PTjWOYyjXR68dbQb//tBa2xbu8QwraoIs2pLMKumBLNqijEz+ve0qiJqdk8QBEEQeYZNYuNSxCdXUKA1QRATEsYilaJqS10J4ZEAMDgWwLEuD453eXCydwSnekdxsncE753oS2jKbYsabzNrSjCzuhhTKt2YUuHGlIoiNFUUoaHCRfluBEEQBJEDJqpxBpCBRhDEJKSiyIHVM6uwemZVwuecc/R4/DjVO4ITPXHD7WTvCHad7seQN5i0rzK3HdUlTlQVO1Fd4kRlsQPVxU5UlThR7rbD7bCh2GlHkVOK/+2wwe2QIDEGSWKwMQZJQuS3/JkU6fIS4hzhMEcwHPkd4hzBEEeYc4TC0Z/oZ4FQGIEQRzAUhj/6d+SzMPzBMIJhHvtbuSzx7zD8QY5gOIx/vXk5hZwTBEEQxDhDBhpBEEQUxhjqylyoK3MJewKN+ILoGPKifcCLtsExdAx60TfiR/+oH30jfnQNe3G4Yxj9o36MKjxx+QxjkVh+p02Cw8ZgV/wdCIXJQCMIgiCIcYZxRUNGw5UZ6wZwKsMy1ALoyfA+s00hygwUptwk8/hAMo8fhSh3OjLP5JzXZVKYfIMxNgzgcK7lKGAK8ZnIJ2j80oPGLz1o/FJH8/vRkoGWDRhj73PO1+RUCIsUosxAYcpNMo8PJPP4UYhyF6LM4wmNT3rQ+KUHjV960PilB41fdqDyZARBEARBEARBEHkCGWgEQRAEQRAEQRB5Qj4YaD/PtQApUIgyA4UpN8k8PpDM40chyl2IMo8nND7pQeOXHjR+6UHjlx40flkg5zloBEEQBEEQBEEQRIR88KARBEEQBEEQBEEQIAONIAiCIAiCIAgib0jLQGOM3cMYO8EY8zLGdjDGLjRY/+Loel7GWAtj7G7V8jLG2H8yxk4xxsYYY1sZY+eq1mGMsfsYY23RdTYzxpbkucybGGNc9fOOWZmtys0Ym8IYe5wxdogxFmKMbdJY72bG2AHGmC/6+yOq5eM21hmUOa2xzrTMjLEljLEno/cOZ4zdl+5x80Hm6H2hHueOHMp8F2PsLcZYH2NsgDH2OmNsQzrHzRe583Csb2GMvR+Vd4Qxtosx9ol0jlvITJbztAJj7B8YY+8xxoYYY92MsWcYY0tV6zBm8P3CGKtijP2aMTYY/fk1Y6xyfM8m9zDG/jH63P9I8RmNnw7Rd9kvo/efl0X0hYsVy2n8NGCM2Rhj31G8104wxu5njNkV69D4ZRvOeUo/AG4FEABwF4BFAP4LgAfADI31ZwMYia63KLpdAMDNinWeAHAQwEYAzQDuAzAIYKpinb8HMAzgZgBLAfweQBuAsjyWeROAlwE0Kn6qszjWswD8EMCdALYC2CRYZx2AIICvR/f59ej/a3M01pmSOeWxzpLM5wL4DwC3AWgBcF+6x80Tme8DcEg1znU5HOffAPg8gHMALADwMCLP7rxMjHOO5c63sb4UwI0AFgKYC+BLiDyH12RqrAvlZ7KcZwrj8iKATyLyvbEMwFMAOqB4F8PE9wuAFwDsB7Aekff/fgDP5Pr8xnkszwdwAsBuAD+i8TM1ZpWIfHf9CsB5iOhylwFYRONnavz+EUAfgOui3wnXA+gH8E0av3G8DmlcwO0AHlF9dhTAgxrr/yuAo6rPHgWwLfp3UfRL/gbVOjsA3B/9mwFoB/B1xfKi6E3y1/koc/T/TQCeHa+xVq33LMRK1hMAXlZ99gqA3+ZirDMhc7pjnQ2ZVevsg9jYSee4uZL5PgD78nGco+sxRBTCL2TiuDmWO6/HOrruB8p9pjvWhfIzWc4zA+NUCiAE4Lro/4bfL4gYvBzABYp1NkQ/W5DrcxqncasAcByRSZHNiBpoNH6G4/YvAN7WWU7jpz9+zwL4peqzXyKqW9H4jc9PSiGOjDEngNUAXlItegkRS1nEOsH6LwJYwxhzALADsAHwqtYZi15UIDIL0qjcD+d8DMCbOsfNtcwyGxhjXYyxI4yxRxhj9Xrypim3GbTOTd7neI+1GYxklrE81lmUOWvHzZXMCuYwxs5Gwx9+xxibY7TBOMrsBOBGZNYv7ePmSm4FeTnW0TCXyxDx/r05XsfNBybLeWaIMkRSKuT72sz3yzpEvJFbFft5GxEP82QZ358DeJJz/prqcxo/fW4EsJ0x9kRUF9jFGPs8Y4xFl9P46bMFwCWMsYUAwBhbjMgkwfPR5TR+40CqOWi1iBgmnarPOxG5aCIaNda3A6jlnA8D2AbgG4yxqdEY2NsRuchTFPuAxn60jptrmQHg/wDcgYiL/auIuNxfY4y5DGROVW4zaJ1bo2I5DNbRIlcyA6mPdbZkNiKd4+ZKZiDiObgTwIcQCe9qBLCVMVZjsN14yXw/Il8Of87QcXMlN5CHY80Yq2CMeQD4ATwH4Iv8/7d3fiFW1FEc/xzJkv7QH0qC6I+SFdHDElRsZIIpPuxTUoZB9GIkCgVFhEhvRUVqLVhvhWnQQhT1FD0EFtVCaC0YFmG6QqVlvmxFua6dHs5v23Hu3Xvv3jv3zrT3+4GB2fs7d86Z752dmfOb3++M+4fd9lsx+mU/i2AYGCOul9Da9eVK4ISnrneAtP4rfaCvmT1CTJt4pk6z9GvMUmATMcxxDXH8vQBsTu3SrzEvAnuAg2Z2mhia+Ka7v5bapV8POKe5SUM897fV+ayZffbzh4A3gB+J4RBfAW8Dt3bot5Pvdhyzu49kvn/AzPYDR4Eh4L0uxV3UNnupdcfbLEDrbsTcClXTubHDmZvxcBiFWA4DDwM7WtlE7u/CYjazx4FHgVXuPlGw357HXVGtfwcGiKFr9wA7zGzc3T/ust8q0i/72RZmtoMYUXKXu5/JNTfTrp6O815fM7uRGKa33N0nG5hKv/osAPa5+5b099dmtoxI0HZm7KRffR4gOrofJJKzAWDYzI64++sZO+nXRdp9gvYbkYzks+DF1GbU0xyfxX4KOAng7j+4+wrion+1u98OLCQmyE5vgzn6LTvmGtz9ZyKhW9Yk5nbjboXZ9u2XTDtt+i0r5hrmoHW3Ym5GJ37LirkGd/+DOJGXqnNKcp4lClZ8WaDfsuKuoQpau/s/7n7I3cfcfTvwDjGxvKt+K0a/7GfbmNnLwHpgpbsfzjS1cn05DizODEsjrV/B/Nd3kHhC+42ZTZnZFLAC2JTWTyY76VefY8DB3GffAtekdR1/jXkJ2ObuI+5+wN33EJ2B0wmv9OsBbSVoqUdnP7A617Sas8ebZhkFVtWx3+fup3Pb/9Pdj5nZpcTj6Q9S0xHiR//Pr5ktApY38Ft2zDWY2eXAVcRJpCFtxt0Ko0222WutW6FZzDW0qnUXY25IJ37Lirke6di4iRJ1NrMngOeAIXf/rEi/ZcU9i33pWtdhAXBeCX5Lo1/2s13MbJjogV/p7t/lmlu5vowSHZ+Dme8NAhcw//V9n6h+OZBZ9gEjaf17pF8jPifmxWa5gRhNAzr+mnE+0fmU5QwzOYP06wXtVhchHoFOAhuIai3DxNyJa1P7bmB3xn66ZP0ryX5D+n62ZP0aYp7FEuKHHyPmXyzM2DwNTABridKeI8yt9HtPYyYO0G3EgXkdUY5/lHiq0zTmduJOn02f1D8l5rMMADdn2u8kngRuIW72thDlovNl9nuidRExd6p1l2I+N2NziCijPgBc36rfisa8jejRXQLcQVR9migx5qfSNtdxdjn6i4vQueS4q6b1VqLjamna5pPE/+HGorT+vyz9sp9t6PJqOkZX5o7rCzM2Ta8vRJnuA0Sp+cG03pdluslUcZR+TbW6LZ2TthLz+O4nXn+0Wfq1pN8u4r5piLiXuhc4AWyXfj38HTr8ETcB48Apoifx7kzbXmBvzn4FMUfrFJGBb8y1ryNKyp4ieod3krlRSTZGlJ0+RlRP/AS4paoxE6VHPyImRk4SPTi7iOGQ3dTa6yzjOZv7iPcrTRKP/9eWrHVHMRehddExEye3ejb57czqt4oxM3MyngR+At4lcxNfQszjs9jsKkrnsuKuoNbPE6Xk/yLelfMFsH4ufufT0i/7OUdN6h1DTuaVHbRwfQEuA94ibgQn0volZe9fSZru5ewETfo11muIeHfc38QTx8cAk34taXcR8WDiaDrPHybmRC6Sfr1bLIkohBBCCCGEEKJk2i0SIoQQQgghhBCiYJSgCSGEEEIIIURFUIImhBBCCCGEEBVBCZoQQgghhBBCVAQlaEIIIYQQQghREZSgCSGEEEIIIURFUIImhBBCCCGEEBVBCZoQQgghhBBCVAQlaEIIIYQQQghREf4F/BDkQwxrguwAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -426,12 +464,14 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -446,12 +486,14 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -468,13 +510,6 @@ "ax.set_ylabel('population')\n", "ax.legend();" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -493,7 +528,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.8" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/docs/source/notebooks/SMC2_gaussians.ipynb b/docs/source/notebooks/SMC2_gaussians.ipynb index c6a73049f99..06fafbf327c 100644 --- a/docs/source/notebooks/SMC2_gaussians.ipynb +++ b/docs/source/notebooks/SMC2_gaussians.ipynb @@ -25,7 +25,6 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", - "from pymc3.step_methods import smc\n", "import theano.tensor as tt\n", "import shutil\n", "\n", @@ -121,12 +120,12 @@ "text": [ "Sample initial stage: ...\n", "Stage: 0 Beta: 0.010 Steps: 25\n", - "Stage: 1 Beta: 0.029 Steps: 13\n", - "Stage: 2 Beta: 0.067 Steps: 3\n", - "Stage: 3 Beta: 0.146 Steps: 11\n", - "Stage: 4 Beta: 0.307 Steps: 4\n", - "Stage: 5 Beta: 0.623 Steps: 14\n", - "Stage: 6 Beta: 1.000 Steps: 4\n" + "Stage: 1 Beta: 0.029 Steps: 11\n", + "Stage: 2 Beta: 0.064 Steps: 2\n", + "Stage: 3 Beta: 0.136 Steps: 9\n", + "Stage: 4 Beta: 0.289 Steps: 3\n", + "Stage: 5 Beta: 0.603 Steps: 13\n", + "Stage: 6 Beta: 1.000 Steps: 3\n" ] } ], @@ -148,7 +147,7 @@ " upper=2. * np.ones_like(mu1),\n", " testval=-1. * np.ones_like(mu1))\n", " llk = pm.Potential('llk', two_gaussians(X))\n", - " trace = pm.sample(2000, step=pm.SMC())" + " trace = pm.sample_smc(2000)" ] }, { @@ -165,7 +164,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2gAAACYCAYAAACRbMq5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOy9ebQk113n+Y1c3lp7qaRSqUqSJdnPm2zJkjfaGIPNsI6wTWMwbmN3M8AwPcywdA/dc4BzaJg59NAzzKEZxkPjBoNlDNgG29hGxrYsS7K1lEq1V2W9qnr7lvsS+3Lv/BEZkbFmRmTme5nv1e9zTp16mRlxt7gR8fvd33IFzjkIgiAIgiAIgiCI0ZMZdQMIgiAIgiAIgiAIG1LQCIIgCIIgCIIgxgRS0AiCIAiCIAiCIMYEUtAIgiAIgiAIgiDGBFLQCIIgCIIgCIIgxgRS0AiCIAiCIAiCIMaE3KgbQBC3AnNzc/cAuADgBQDfXygUuOe3DICvAbgbwEOFQkEcTSsJgiAIIjn0biOI7YEsaASxAxQKhSUAvwrg3QB+MfDzrwP4bgA/TS8wgiAIYrdA7zaC2B4E2qiaIHaOubm5LwH4HgBvLBQKN+bm5t4C4BkAv10oFP630baOIAiCINJD7zaCGC6koBHEDjI3N3cngIuwXUJ+BMDLADYBvKtQKLBRto0gCIIg+oHebQQxXEhBI4gdZm5u7qcBPA7gLIB7Ya84Lo+0UQRBEAQxAPRuI4jhQTFoBLHDFAqFTwH4CoCHAPwWvcAIgiCI3Q692whieJCCRhA7zNzc3AkAb21//Jm5uTnKpkoQBEHsaujdRhDDgxQ0gthB5ubmBACfAKAB+FkAjwL4X0faKIIgCIIYAHq3EcRwIQWNIHaWXwHwHgA/VygU/iuAvwHwG3Nzc4+MtlkEQRAE0Tf0biOIIUJJQghih5ibm3sD7M08/7JQKPxc+7ujAC4BqAB4pFAoqCNsIkEQBEGkgt5tBDF8yIJGEDvA3NzcFOzsVuuwVxoBAIVCoQLgFwC8FsDvjqZ1BEEQBJEeercRxPZAChpB7Az/EfaL6qOFQkH0/lAoFD4P4C8B/Mrc3Nw7R9E4giAIgugDercRxDZALo4EQRAEQRAEQRBjAlnQCIIgCIIgCIIgxgRS0AiCIAiCIAiCIMYEUtAIgiAIgiAIgiDGBFLQCIIgCIIgCIIgxgRS0AiCIAiCIAiCIMaE3LALLJVaobSQ+/ZNQhS1YVc1UvZin4C92a+92CeA+rWb2It9AnauX8eO7Re2vZIEKIrO98J13EvzkfoynuyVvuyVfgDUl3Gk27ttRyxouVx2J6rZUfZin4C92a+92CeA+rWb2It9AvZuv+LYK/3dK/0AqC/jyl7py17pB0B92W2QiyNBEARBEARBEMSYQAoa4aIaFixGG5cTBEEQBEEQuw/OOUTNHHUzBmboMWjE7uLSRhN/dWYNZ9ea2GppyAjA8f2T+J4HbsNjrz+OB47NjrqJBEEQBEEQA2ExDlm3sH+KRN+9zFJVQaEo4m33HsbB6fyom9M3NEtvUeqKgf/9n+bx5HwZsxMZvOO+o7jv6CyEXBaXVuv47Ll1fPrMGt7/xjvxP7zjXhyY2r2TnCAIghgeDcXAc4s1vPWewzg0s/vfDZrJMJkjh6K9zpWtFtbqKt71ytvoeu8AT9+o4O7D07jnyIz7HeccjAPZzPblfaorBgBAMayRKGiGxZDPRs8vWbcwmcsk6j/N0FuQp+bL+LH/8jyenC9DACDpDC+vNjBfkvCuuWP4T+99Hb7y378NP/mmu/D35zfw0cdfxkJFHnWzCYIgbnlMi4Hx0bqilyS9/f/uz6K2UlPwzfkyWur2ukRFhRBYjEM1rMhjm6qxre25FanJ9pgaFnO/q0h65DUgBkfWLVzdEn3fFYoivlYoDe0ZttlUwUf8PPSy0VTxjWtlNJTo+/fpGxWcXWsAACS9+zOHFLRbCNNi+N0nruHffOEyZIPh4ZMH8UOvvR2PnDoIAcCT8yV84E+ew0/9+Wm0VBO/9r334//7yTdC0i38y0+9jAvrzVF3gSAI4pbm69fKOL1cH1n9nHOURQ0MoxeKlqoyWgMqMpW2stlLWBqUp653BDOHc+sNPHW9EnnsdxZq29qeWxEhwmhxermO5xZprHeKlboKABhGuoPNpopza00sVKMNCKbF8M35Mq4WW6nLVg0Lm0019XnV9vOk1Y6Bq8uGW46jSJZF+5hnblS7lkUK2i1CQzHwkcdfxucvbmI6n8GvvOs+yLqFL18u4sxKA2XZgNW+YW5UZLz34y/iJ//8NI5M5/GJDz2MIzN5/M+fu4hrRbF7RQRBELcIo1q5dSwB3VhvqDi72uh5XFoqko5rRQmbzdFbz65uiXjqWnnUzejJMzcqqMm6K5g5lFp6zBm7n2JLhTJmlikBAhjnCN62msmiT9gm4iyne4k4C5nr2TeEZ6fRFloVI/r6LdQUvLBcx8sr6Z+Dzy/VcW6tOfAz/vmlGs6t9WfcIAXtFqAm6/iFvz6H+ZKEmXwG3/vAbfiDb97Ecs1edZjMZ/CuB47il7/nPvzOY6/Fu195GzICcLMi4/1/dhp/+p1l/MH7Xo/pfAa/9NkLKLZG/2ImCIIYJZc2mvjq1dKomxHLhXU78dOwcRbyNHM8BEw+JEse53zbshg3NRPLdTXSgtMPV7dauLgxHI8WzjlW68rQFxueX6ji2ZvdLQTDQDdZYvfUzZaKCxstn4vjKDi9XI+0nO4mlmtK1wX7uFtJ6PE74xxmwusjeJQ9UTNDFi8+wP08DAXaZHygRQpS0PY4qmHhlz57wTUBnzg4hS9fKWImn4VucXz0LafwxZ97K37vv30tPvToSfzUm+/G7z32Wnz1F9+OO/ZPAgA+f3ETv/x3F/GbP/AqKIaFf/fFKyN/wBEEQYyS1Xp695d+UA3LdcOLotzlt93OdseFeblWkvC1QrzCLWpmIoW3HmHddHSfzJA0tKWqgrU+519F0iHrHaFxpa7i0kYLSzVlKG3zshPb9jyzUMW3F5IpgtX2tVE9iwtJFzI0k0Wmbl+tK6njBesx8Um7AdWwIOkmrmy2uuYmiFX42/dA3Mw4s9LA11NaxVfrKp6+UfFZqhjnmC9J/rJX613v8Th0k0XOEb2H5fX8egNXtkTMl8S+rLSkoO1hOOf4nSeu4VpRAuPA7fsncLMiI58VcHgmj49/8CH86+9+BQ5FZLk5OJ3Hp37mTbj3yDQA+wb4rS8X8PPfdS8ubDTxh99a2OnuEARBjBxZt2MTGqqBlmZivbG9itqzC9XYmLOVmoKXlus4u9pIvOJrWgxfPL+OxZi4jaQIGEzZuLzZws2KFPv7szcreOpGBWVJh8n40ITa1boSGVvSy2Xz2ZvVni6jq3UFzy/VfOXbWetscTQTk7ktifVqWC5xp5frePpGx3qjtxdbh7XoWhI1FLaiLSvrDRXrDRWLQ0w6ZqQQfJ3hZ55TGIDNBAraU9fLkRbBSxut2HhBzvlYJbCIo1AUI5VP02JYa/gV96euV3rGTukmQ1M1cWmzFVpA6hi9osel22KUF8Zsy69zbwUVIEW33DgwwF5gKbX0vhYNXl5t4Oxqw6eQ3axI+OrVIv7h0qa7KNNsvxMc6rIBUTMhaiZWakpqWz8paHuYvzqzhq8WSpjIZTA7kUWxpUMQBNx7ZAYf/+BDeN3x/V3PPzCVx3/+8QdxcCqHrGCv+vzZ88v44dfcjk+fWcOLyxRYSxDErcWzC1V86qVVLFYVfOtGBU9eK7sC+XpDjVwpXa0reOJKMZGQfb0k4XlP0gLTin+ttzQTJuO4tNHCmYTxZmq7fSsDWkyCroVmyrialZqC+WK0gtZQDDy7UMNyTYasWzi9XMOnz6xBGUIij0sbrb5jQuJYqsrQTQZJs/vvjYlZrMq40lZY+hW4WqqJp65XsFSVcWmjCb2dyXPUcUw1WQ8J9mdWGpgviVirKz5hFbCtVX9zdh2FohhrfajJOmry9liFHQOm1YfS1I+e9bdn1/H46dX0J8a2obfCV5b0rpZnI5AFVjEsLFbkyOfH5S0RF9dbkVbhKEqiBs45vr1QxbcXKjAZd5+NdcUA47znss56Q8H5BAnplmsyFqsKimKyufLszSqaqgHVsFBNOb/k9n3mHflSS4ekW9BN5nqofWehhksbwYQk7bP6WM8iBW2PcrMi4Y+eXsAd+yfsF4duIZ8VcN/RGXzsA2/A0dmJROUcPzCF3/+x1wEQkM3YAsHZtQbuOjiF33ni2p7YrZ0gCCIpjHEoOoNh2oLOWjuTmKKbuLDejLSyONYZUe8uUF/abOFGWUpkLSoURTt2CEAm0z3RgWYyPHGliNW6AosxnFmuoZRQsEnKP17ZwuMvDUcYbbYFTEeQvFGW0VRNLG6DG55DSzWxUI236MXRVA1c3RJxISYmzGthjbOgBVmsyjjnEVKdDJOLFRmrddsCdbMs4cl52xWsIumpLblp3901WceVLb/w+cJSPdKqNF+SsNVUcTPCUsZ6WDBeWKrjhaXkWUqXa4pvrLqRbYu8rA9j4WJFwtWtdNkAz683MV9OP6e82JYfFfMlEV+9WvLFrj23WA1Zob9yeQtfvrwVW943PFlgm6qBf7pagmZZkQqoo0SbXZTC+ZK9+LDZVHFmpYGlmgLNZDBMjkZbKRM1E88v1lAoiq6SHOdWWpKMRJYm07KVvaj5FOVJrJoWNJOhUJLwYor5xQEURQ3PLVbBPBPHYtx1be22ZYD9i4CoW1/rYbUmBW0PYjKO3/7Ha5jMZbDV0sEBzOSzODSdx//9vten3nT64ZMH8fPfdQ9MBoDb7gD7J3PYaGr42LOL29EFgiCIsWWxKmOhKoMz4EZZxEpdgfOqVU07ZszrMua1Nukmw+XNli8OyGE1gQKiGBYMxrFYkRPHNtVlHefWm7Yi2bbuFMXubl1m24WoG46bI2MMlzdFVKSOYvnthSqeut5fhsWgdc75nPX0k3OOpmbAsJjrdupwsyLhWqmFl1bq9rYAnuuhGJYvBskpcrWhoKmmt0g5Mls3S6dbV8IyG10sIJxzLNVkXCmKuLDRAuccp5froW1wnHGJ49mbVfAEFg3Ajt35wsXNxFlBjRglrKWZQ49fr6Vwfc20JV6G9G04s9bAxYB15KnrFVzdaqGlmVisyvjGvH++1xUjscteHM/erOLr18q4WbaVXe9CTEMxQ1bojabWM57QyQK71lbqr25JvvvHZLalzrk3eMDiJnnmldMuxzLvJMVoaiYaqoGG0rnm9sKL0K5zsIzghsWwWldgRsy1oL7UUA0UYqz1cZxeqbsLNk9fr2C+LEHUOv1erMpYa2hoqIab1KShGmgGFz5cA1r4Tus1BrlULSZ2BZ8+s4bLmy3cuX8SomZh34SdEOT/et/rcXs78UdafuYtp/DMzSqutYMdrxZFvPaOffjbs+t47PXH8arb9w25FwRBEONJq23RyE3l0VBNXN7qKFwWswXmQzN5vPWew6FzrxZFbDRUrNQUvPWewzg0k27B7FpJQi4DzN2+3xNT0931yXHRKUs6nl9K5pp+YaOJsysNvP0VR7BUlfHP7juCfZMdkaGpWmCcY6Oh4i9Pr0LRTUxPeH8fTszYYkXCUkVBSdJDfVyoKCjJJkzNBOe2xwcA/Om3l6FZFv6buduhmQwvLddxeCaPt9xzGNfaiQNUw8JUPusKc6bF3XEUhpVuEbZ8VhJV39g59S/VZByYysOwGHLZDK4XRRzJC1ANK1LwFHUTX7lSxFSus7buHROn7ZJu4k+/vYSTh6dx6tA0MoKAR+8+FNm2JNaKUkvHZlMbOF/mzYqMtYaKh+46GHtMt6x3FrPj+fLZeNsC5xxfurQFnTG8/w0nfL+5Lo596IiO0vzyagMPn7TbrxoWZMPCN6+XUZcNHNs3Ac45DItjIjc8+wfjtltmTTYiLTHDwFEkOef4o2/dxEN3HcDsRA5VWfcpPM7988YTB9zvRM2MiO2yPwetb8O6tTYaKkTNgsWBuw9PQ9b9iqMXRWdoKDqO77c9x6LurVD5TRUbbaW12XYlNzyLMFstDSVJQ1M1wDjw1nuPYLGqoCrpeNUxWx62mG09zGYzEIT0brJkQdtjlCUdf/qdJcwdm8VGS0MuI0DULfza992PuQGUqFxGwH/44TkAwNGZPDICcKUoYiafxe9/4/quCIQlCIIYlChXMs6Actsi5bz7Jc9KqskYSu3fvc9KsUdMlXfz5EubndTqJrM/z5clMM5xrSxhpYu1y/t47mZV8XK9KKEk6Ti/3sBKXXE3YPWy2dLcepWAi+XVooRLm/EuYRc2mpgv+1eQFz0bT6uGrQCu1FVUZB2aaUW6EhmMhQSfpmZA1S1cL0vutgAd91JbEVMD7V2syliqxWx4yzhWGwoKXdKKd0v3v1JXcWVL9LmuXitJqCsmlmsKLm22cG6tgcdfWMLlzRaKohYZJxO1/52kW9hsaVisym7WuppsQLM46rKBmjy4FQewMyD2sqgCnfmtGgwWCyZuMLu6gwHA166V8LVrJdv9rlDyWYyeuVnBN3pk+PvOQg2Xt0RcL4WvZcax+HraUFf0nltGeI8PbjNkWByayVCRdRRK9px/cr7cjhFkkUlM0mR+5LBTtV/caGG+JLobPQO2W26a7S6WPHMEsJXhl9fqsBjDSl1BsaXB4hy6xXF6pYGVhuref0E0y3KV6WdvVl1XRwfHqs84R0sz3eefZlp4ebWOZozl07RYotT0ggBAsL0DVuoKbpYlrDVUO84toARWZR0N1XTvv+BzSTMZrhXFSDk2brqKbWuwpJuhpDeXNlttl2kZLc1CVdT6SqlECtoe44+fXoBmMjcrEeMc73nVbXjfg8cHLvvkoWn87NvuRkU2MJkVkMsImMhlcHatia/tgs1CCYIgBuXSZjjeRdTMri/g5aqK9aaGumLAYhyLVbnrotZKXcFiVcYXL265gvpKTcZaXYWomdBMW/hVNAuMcegmCwnvimFGCvkrCdOzOwrHclXB2bWGL/5L1AwwxmFY0YLUekOFbrKulgrGAVn3H/A3L6/jEy+uQNYtFEXNVSw000JNMRJt0O3Q0Exc2WqFBOSmYmK1ofgSbJgWg8l5rLvcE1eKeHm1AdVkMC3Wc0FS0szIBB5BN0QH2bDcTazjEhg4SRa8tFQT316oYauloaFGbwMg6RakLgKvZjJc3Wp1TTgiaqZvscBJehOlbBWKIiTNxEZDCWXGLCVQFBmzFeinrpfx+QsbmPcoxaJmhVwky6LmUxy/eGnT3eM1iNCWeL3NbsaMm5eap92XA/e/bjK0NNOdmzfKElYbCji3F2AaEbF+FdnAQjVZPOVCRXYVCjWwIfPNqoyrKVz3XlyoutZ0ADi/1sRmU8N6Q4Vh2a7XXhhjaKpG5KLO1S0Jlzx7yjWUTj8Ni3Xq4cDppTrW23OhLBpYbag4H0qmYcexrTdVV5nrhsk4KpIOiwNlUYfBODTDiswganEOWbewFbExvKiZ+OrVIp6+UfEtZOgWc62CcXGTjttinLVbVE1wAFLMRtq9IAVtD3Flq4UvXtrCQ3cdQEM1MZnL4OBUHr/+7lcOzWXjXzx6Eq84OoPJfBaGxVGVDRyazuOPn1mgvdEIgtjTcB62vAC2y6Pj/sLBcb0suYkuvPFojHO8tNLAhY0mCqVoa8xWS0VhS3QFDUmzYLGOfaYs6thsqlhrqNhoqbAYR0nUUBR1/Pnzyzi7ZscJfeVyCV+4aCcLCD7+NbO3kuHgxGuV20KsvZovoixpiIqqqsl6rCKSBFnvCEYtzQLn3BWAvMIlB9BQdGgxwo9Thsk4zq033Rgb2bBgmAxNzU6BfXmzhUseoS5K6fj2QhWNtvL29WtlX5Y5gzGcW2+iKhu4sNHAZkvFy2sNN5mDd5y9CiDjHIpH8FUMCwtlyZcB0j1PNrBUU0KJXWqK7sumnG37v3kF3BeXa6GkCIrRidkrtjRXIY7jhsdCwDl3NyiOklvny5JrcYnLltgtoU1VMVBVOgrMhkd5urLZxDM3K74xlduWVsNiuFmRQpkjvTgCdRp/H9NieMqzLcGNgLXEmS9Nzb6210sSKmJ/6dyjsO8B++9BxbgrbeXSsSR57yvFtNwtFxy2WjrqioG6Z9FANxm09n240VJxabOFxarsU+JsN24NVUmH2i67pRn4xytbWKxK0EyGsqTh02c6SYUurDfxFy8mTzK0VpNREjWsNxQsVCVoFsOWqOF6WYLJ7L8dRM2EbNiLPE6mSYdnF6r45vUyzqw0fFsCNFUztGDjs5ILHQXK+8zwXnXHUKKmsHJ6IQVtD/HHzyzi4FTOdYPRTIZ/++4HUsc4dCOfzeDX3/0A6oqJU4emkMsIaKoGVusqPnduY2j1EARBjBuffH459jfn5c6YbbVYrMooixpOL9dRkTvxU44lohrjerbR1CAbFkqihsWKhC1Rxbn1hvvmryo6GmpHwHIEAtWwsFpX8dWrRQBAQzNcgcJkHGt1BbJuoaUauFEUE2dxzGUEqAaD0raWbTZVVBUdkmb5At9biomVmty2EEpoKLrrrlgRtZC7W0XSUVe6t8G0GDaaKjSzvY9YQEBtqCbWG90tEY6S4FioWqpt1agrJr50aQuLVRnFVnerYkM13MQXkm75NimXNQuaaWGzqeDMSgMvBvasi3PpW2+oKEma687lCM112YCkWz6B12yPnSNQqyaDYTFw5o/ZchQ01WBYqdnzr6WZaGl+QfPyVgvX2+6xTcXAWlNFXUmW1ZFzjo2mljhzYuh8Bpxbb8YmEunGZkvDYk3BC54xbioGmoqBy5stzBelRAvFQvu+SLJIYXFAT+BypxpWO4W7geW60jVL5nJNjnQZjsO5j+P0s4qkuwq3alixWxg4c9FJImJaDI12DFVTsSKybtrHe7u/2VKxJWrg7eunGAwN1bZKd+pp/w9bwZwviliuKqjLBjab9pysKQZulDv1rTdUGCaLXXAJ0pDtbI8G42ioptuepmriuYUanrlZdbe9cB6Smmm7ZfqUqKaGlmqioujY6HNPS8cAUmqpPmXWq6Rzbl/Fc+vNngmaHChJyB7h5dUGnlus4c13H8SLyw1kBQFvf8VhvOdVtw29rkdOHcK7HjiK7yzWwBhHNiNgdiKLP/3OEh578Dim89mh10kQBDFqgqvivhiyyNTOtrBRlnTUZCPkRma03eVOr9Rx/22z2GppKLY0VGQdFzdamMxn2pnKgDecOIgrW04MWqcdTiYwzjk2W2rk81fSTVjcdgkqizpE3Yy0BAZZrslQDQZRN1EVbSHfcWUyAgqXZFjYN5nFck3GhY2WnaBqMoumauDjz6/gwRP78UOvucPXpqj6DkzaC4qqwaCaFhj3bqI8uCeIk7SAM46lmoK6YiQaC4frZcmXpEMxLGy1NOSz0W3zKnNeoV01LJ8blYPuicGpSBo+/twKHrxzPxqKjn3tJCyttpsrAORywMFpO/lBrq2g1RQ7e3NNMSNjaDabGhi3XQmduhTDfz02GgqenK/gnz90InR+uYeAqRgWTN3C/onwXGxpBoQWoJsWZiN+74betlJLnmx6env8nPFQDAuSZuHucH6ezibJKeqsyzpqnqyacZYx0+IoihosZsekPTlf6lqu8+xgnMPskVQkaEETNdOXdMZJm3/8wFRi4R9w3GY7n4PKbUbIgPPoRYZGW+kviiomshnMTMSrE4WSBA5befJuNbHhyRxZVwxstFS0dBO5bHqjgqMkbTRUVGQ7lm65LuPo7ARa7fmiGvaWU96st4puuc9lM2JmxMZM+o1paGkGVhqq/wklwE3Nr3q8Fjaaya4RWdD2AJxz/L/PLOC22QmcXW1AgL3S+Kvvun+o2ai8/NI774PFOO67bRYGs4NA66qJvztPVjSCIPYmQaXCF3uQQOpzFAHDYmgqJsDtFeiqZODCegubLc11hylJGiyLQ9JtC01T0RHUIwyLYb2hoKl1FK5u7mNpUQzmrsY7Fg+9LXB4rWde65hu8rbwb3/nCNOrtWSr046rmMl4OLZD6Hy2lYuwguMlGLMDhIXQIEk8P70KnWPd0k077sawmJt2G+js6WYX3vlzqaagqZq4FnB19VZ/YaOJK5stPH2zgoZquq6D3mvs9JExFtn4iqyHkjywdjZEDnucRc0Mxdk8daOC1YaKlXrYpY+1+7tUlV03Li+SbvnGwIvT9F4GNMcFNKkr7plVW0nRLR67b5duWliuyWil2E7hY9+64YtRi4tTZLDnVl0xIBsWnku419b5taa7n10cHLxtIXIspHb7jbaCHxUDtdFUQ2OXZKNrxuyx55zDtOzkJ7Y7s41mMnvOeYrZbNlxgKt1JfK6c+//MdUvVjvzLNnWCX7ZVhDs5/OWxxrOuO3Cq7SfqY413fvMKEqaq+T3rjEsT9uLBtydU8GSnLJrig5wDsNkrrWvF6Sg7QFOr9Tx8loTdx+ehnPffOjRkzh1eHrb6rz78DR+4qETuFmRsG8ii+l8BpO5DD7xwkrXYGOCIIjdylVPUHxaHLmooRhoqCZkw0Q14OKneBRAWWeuMgQgFICimwyKbrlCh3ePnnDlnT87MTq9hQRJN902xAl2oma6+ykBcN28vCRJrBGHVxkJCkiSbnZNHCLqpqtABYlrTq8sg8s12Y1Hc3D6t9lO1nGjIrsurxWvK6mn+cFkIKrJUGpp0D3xKms1FYppodRObhDVE84BzbCw2lCx6Ek80VSNSOXJSfhRlQ3wdmIUNSLJjDPsFg8L9otVGRc3m2goRs8EG14Mi4EltF/VJAOSYaHhuUecJkRn27Mt0d1wEnYE77texLV4ua64Y2w6rnbt35SE2VKTjB/nwEpDgQD45KuNpooL60087YmRczi/1sRC1a9cl0Qd8yUpZAFV2nF8DcWeE6t1BVXZcGPSWp5FhpZmQtRNNDU7K6KzAGMxhkJJxGIl3uXYsFjI8u6wldCq5BCKqzWY627ppdd6Va2XqynnHgUzYDaDPXYNNWqbAd9hqLb3iNxo2a7NSSAFbQ/wFy+u4shMHufXbOvZoek8PvrWU9te70ffegoT2QxOHpqGYjBoJkNVNkznBHUAACAASURBVPCFi5vbXjdBEMQoiHeHE2I/SZqFiqxDN5gr9DBu78dkMY7z603UFb1rljurHS/k0NRM6G2h0D3G6r1CHmddCBI8LKy4hBN3AGELnmbaG8qWU6Z6dyyJXrnHG4PmCk2ct93EOvV6k6oMvHkXOlYySTfRUAyfG5liWKirpu86qIblKq1yggQBomq6QrBX0XZ64XQh0h9GALZEO9HHFU8WPt3ikcrp9bLkzmGOjlEyQuVx/7rh2aSXw1aegPT7OnXbgDuIo8h563AE26i5tNbQfC5zUZgWg2Vx5Ns7VvdSxh2CCrnDdwJZEX3nDGkfQADupVhtqJgviW48JWCPU9DKxbntbqkGlESprVwtR2yXYHGOsqi7V13SO9ta5CL2ndMtBpNxaFZnLsm61U7OwWO3AveOuFep0WMUt3j8187ZIDptaGOv/eU54ue587Vh+p+7dSfm2HNePptxxzOpSzUpaLuca0URzy3WcPLgFMz2fPhXb7sbs138gYfFkZkJfODhu1AoijgyncNMPoNcRsCfP78cG6RKEASxF+Gws8g5sSXed7rjhqZGpKXXTFsUXWvHKjmCcFAYXyjLuF7pnlK7php+lzoPJktnxQqu8gbP1CwO0ZN8QjWtyL2dJN1ENaGlxWIcnCO04awzFl4ZzitcL1RkXyZGr4tUvKiYHCeBRkXSXZd+B8e9zJsBz/S1s/N33F5pNzzXNc410CG0Us/tRAyyYbnWnGbb3SrK9c27X15SYbapmdDaVkLvOWVZj1VeulGR9MTKURRR/Qqmgo9STsuijppqhBLWdMPZ5yyKOOUM6K681mUjMltnFDVZd/fwU00LBuNYDljGWprpi3XUTIaNpuazbCehrnZiVRWPgha1OXbccwaws4iW4u53z7gkc2WMISZ6x/uMYzwmg+IQFm26UVcMlCUdTc0b1daJlUya4ZMUtF3OX55exXQ+g0vtPSWO7ZvA+99w547V/+FHT2I6n8XxA1OQDXtFpSQZ+IfLWzvWBoIgiJ1Ai9n3C7AF9GtFKRRTVFMMnyXEeTW3tLBbTFXW3RXpfonKjqeaFuqK38rTS0gILrJFCZwtzYRhMjcjnR6xHO0Iykli42qKgYZq+BQZrxwWF1JdV43IpCPdEAS093Lzt7nXinpavJtTxwmG3v3CulVvWCxSqHU2K862E5WYXeapl7Q6UiXgBqmaVl+WIg7b2ts/4XODKeKjNpR37o00cZqFzWZkLOMgmJy781U1ra4ub922DfDiKN6ybrkWmuA9nkQvdZ5RwUWSNCRVPr0YFuvrPAce+B/wu4ynKsT7VcKbxKusVxWjnd018AyFfT27KbdeSEHbxWw0VfzT1SLuOzoDZ2r8wnfdg8ku2YCGzaGZPH7qTSdweUvEiQOTmM5nkM0I+LPnlnquBBIEQewmWl1erKLGsNFSMe/ZOHalpuCZmxVf1jmvjtFU7Q2fl2syRN3satGIs74k+d1RQrxCbK/V66TCe0sz492Z+pDBg9YRUTddt0yvgOkNtL9WFFEoRu8r100oXW+qaGpmcvfLiP5EKY3er3yptuOKTThOUa9U76nZbUoKth30ms/dSKI8RI2pk0HQdPYsTDDwsm65SSa2g2tFCesNLbYtFuOxcVtRyIYF0/NM8RKMDY0ktath+zRuLzDpJgNj0VZOIP4eaKhmykWWcDwqkGyvOJMn7yPjiIybNC0O2dPe4AKBalq+zjLWeRY4ccObPVxySUHbxXzqpTVAENxNI4/vn8SPvO74jrfjQ4+exOxEFodnJtysWpstHV8tdE8zSxAEsZtoKkbs6rvjDmS1s89ZjNuZu3rgWMyCwhMDx0qt447WU4loCwNR8kmUUJRWeerEdCU7UWc8lD1wcKKVnW4xHcHWegXHqqSHhcIBXO8c7A10w8IXT/YhBOMcZc+G53FEhAp1L7fLikBwI22HNMPTb0KdXiRJwJGknYzb7pbKCBObVWUdy7Xg/mMdaooBk/HIsJGgW2eQZmBvO55AMXHHTUjvCci4HXtXV4yQcuipIWWp6fA+/+J6GxsLmWJy12Tdl/0xyg00DufQoFIXhBS0XUpdMfD35zdw/9EZOFbhX3rnK9x9UHaSA1N5fOiRk7i02cK9h6cxmRWQFQR88vRq35m7CIIgdhOdDHP23kBRMVdpn87ep2exx8bSXZ+0o3wM8+heK4aVOuOvtxuDvls4j06Y0s31M6rKqO/M9p50gL/N/pHo/BJnbXB/b1t8krqAdbXEJhy3YktHSdIgBVzseoXPeJWyNElBhk3XTI2BZDODuPPFEZetMjj+FUlHUzF63qLNCFfHbjFww0Do8xbrlqlznCXCyPvb8zeLv5kjU/D7y0nfc1LQdimfPbcO1WRusOjt+ybwnrljI2vPBx+5CwemcpidzEKzOCzOMV+ScGa1MbI2EQRB7BRunBm3Y3XqigHT4qhKhiuAB1/hgmDHaJUl3beJ8a2ApFtu8oN+SCrucG6nlu+lBCWhkjI9e1Jqco9r31X2S9evitxRBvzKgr8SR9EKjlsvBS+pUtZTT0ypgJsJYtqCwzgOyoKTjXVcGHYM5k7TS1FKiy/JT4wF0o7bCw+c192SsfRjSwraLkQ3Gf7m5XXcc3gaavuK/8I/u9e3O/pOs28yhw88dAKXNkXceWACk7kMMgLwyRdXRtYmgiCIncZ5B6sGs2PMwH0rysF3tOFaRwZbDd9puUq3kmcjGxaxq9nO7xFCvWFxVGXdtWilqWOnGCQeaxBDYrdTJd2OzdMDVruhecUMeaDraZKV7HIlJIrdsP+sEZGUZ9xJOt97Wd/ijukGKWi7kCfny6jKhrvZ4HQ+gx9+ze0jbhXwkw/fhclcBrfvm4JmMjAOPLNQw1I13r+aIAhiL9BtE93Yc7apLb46em3iE0Ov+AgAXTeJ3g68fUk6zha3FcmkWQP7Tv8eN8wpy9vRqADOY61zjtuf0iUjZF0xdqflt72YvZ3rC3Flx82vQa970Brt3Wg6MRSSEibh87PX0HHw1ONLCtou5DPn1nFoOgepvbL12OuPR24kuNMcmsnjvQ8ex8XNFm6bybvZJP/qpdURt4wgCGI8GZrfQ7d3fx+V1ANZHiMTjSQoZ5iOHf1YmkyLo6YYoXTl45bv0BmnnRSRuymjcePjFfntfab6SwQyDqrAKPSROIU9jSKf5J5inPfcoy6qxkH2p9uLeIfDv6dhb0IutWRB29tcL0k4u9YE43ZKXUGwU+uPCx969CQA4J6jM262sy9c3OprM0uCIIjdwqgTIm137a6wsU0VMU9671jlwCssJSzXMSJE7UkUScrrmEYBTaRDpxzfyMOHoH065YaFzHirWxq2I79jUpdb3jF3b0MrkuOzCI+wHV7GKBxuLEj41OijrN6QgrbL+My5deQyAprtHd/fdPIg9k/lR90slzsPTOEHX30MlzZaODiVRT4jwGAcnzu/MeqmEQRBbBtJX90jsdwMUejqkshseyqJITIGLaqolEL4ToXIeKvp0wt1YPoRxvkYSPBxLei1t59Le+KOYqfWuGvN+tx/bOiMiQVtkAWvYfYgTTKibvRz25CCtouQdBNfuVzE7EQW+az9hPm1d90/4laF+fCbT0E1GV51+34Y7Vn5Vy+t0sbVBEHsWaJSS4cyikW8pIfnAhjjOjWk0jqZ//oscAjwJFpN8Jwdsk3EW+S2ud5tShKS5phtq3wP1h1X9agt8A7j0Yre4zHsbI2x7Uh4XC/XUI5wn1o9Mp6SgraL+MrlImTDQkM1YVgcx/dP4pW37xt1s0Lcf9ss3nn/UVzdEjGRsTfwqykmvnm9MuqmEQRBbA888D8wfoFOg+B4hfUQWfoV8HwCTty48Zi/k5abgGELqGmVoK57SA1ZiOfBykM/hhmWAa3XPBJ2Iiv1CJSicY7x4iAXxyDey+Ubmr6mp39wNdqoem/AOcdnzq1j30TW3Yz6I285OeJWxfORt5xCSzPx2jsPuBP88dOUcp8giL1J38n/hibwxpXf+WUYIu92yW+pFZkoF8eEbo9d60gdyD/4qCaucwwU/mFd/52ybHZjFG6Fcb3eliT5YzBf+mX0s8PGu/dZN32q28KKXU76HpGCtks4u9bEjbIMUbfAOMdEVsD733hi1M2K5Q0nDuChuw5graG60/bipohCURxpuwiCILaDxLEKwc874ALXXxVx2eYGac1g9DKgRQlBaUXw1GnxUxy7HfJymvqDfUsSb7ddMv64COA7jT8rII/8vmcZSUevx2FR13ZcrstA7dimTnS7Rr2eG5wnT2LjQAraLuGz7eQgWcFeOXz3K4+NdGPqJHz4zadQEnW85o59aGfcx6co5T5BEHsQNzGc/9uu5wgJjhkUa1ySD/QgySj45JsIgShSQUs5vMNWQJOV5xG5U5v8Uh6f9tzAMeO6UfVuaQIbgg8hx/ZZ/5jHYjRKC1y/82zoLso+hTrZcf38HgUpaLuAiqTj69fKsBhHLmNfsl98xz0jblVv3nHfEdx7ZBqiZsLJcPzVq6XQ/joEQRC7HUfEjgpFS3LeXiFlSJNLoo2kPVJOYvE0rtgY4bPfq9ElcixVOd5+BYW6bZGXnf3XYpoZnJ/DilEahqIyKKNvQYdt0bf6mTBjMihjkzTFF4MWF5CWQEFLcEwQUtB2AV+4uAmT2VNDsxjuOzqDOw9Oj7pZPckIAj786Cms1FXcfWgKuYwAk3H8PaXcJwhijxH98h0vL4dUe3aF+sNjvo86avuJaocV8WVat6JR6A3+Zg/BhBarbHWrN1nxwxqeXjE724kjaI/kWsf8vT1tSf/8GRO9aIza0cux2h7l4HwO3WvgtA/aXsNiHJ89t4FsRsC+iSwA4F+99dSIW5WcH3zN7bhtdgITuQzM9hPo8ZfW3L8JgiBGzdzc3OTc3NyfzM3N1ebm5jbn5ub+l7RlJBUohC6ftgNz2C57XtFjiG72ScbPZ12KKiPqu7h3zZDHZVgjkVYw9R6eNvW4V2RMeinH4c09aBtGuU+1dzpanqwTaZuyXY7L46MY7Uw93mnvej9swwbinJMFbc/x7EIVWy0NFuMQdQtTuQy+71XHRt2sxEzkMvjJh0/gelnGkekcsgJQVwx86wal3CcIYmz4fQDfBeA9AH4BwG/Mzc39VJoCOoLXABL2GBGXDrxXc/t12UyUxc4r3Eb4hEUpYzsVgZfEtTMuhK73Gv1gbRiEKEvAjrKNaxijuPViwyjHRDMaeC4OywW2z/OGHoMW90Nwi0uKQbv1+MzZdWQE4MCkbT37kdfdgXx2d122H3/jCczkszi2f8rNGvUXLyyPtlEEQRAA5ubmZgH8HIBfLhQKLxUKhc8D+D8A/I9pyomKmQjKllEWjm139Rqy4McCQVLBfg8jdqTvLQsiy0pXWNqkKq7CMh7ydSqS6AdBnXeYFoVR4VQ9EkeeGOvMuMSi+i2yo6Pv0RjCMHoTsHjnSLc52/upwVPvgbe7JP1bjNW6gucWa2AcaGn2+uIHHh7f1Ppx7J/K4b1vOI75koipnC2iXNoUMV+ilPsEQYycNwKYBPCM57tnALx5bm4ul7SQpK/egcKN+qDHXqix9OeyOQBexShB3bEWqz5SyfvLHY2g3O84pkrPHjg2WWKWHp93Ic6iyCi6wobhPickvHZ9sGMWqDHGv3DhvV5dejPAMysOUtDGmM+d2wAHMJPPgAN49e37cN/R2VE3qy8++Ka7IAgC7jky407ST56mlPsEQYycOwFUC4WC6vluC8AEgMT+5M6LPHUsyY7EQg3BqpXwuKABKumqsW+lOuYYfzxd+KgomTVWP90h80CS7vvcHcfE1c0h1JphubCNcPeHfu/VobfD8/e4bJo9Lpa8fhXQYbfff292q3f4JF4dJHYWzWT4u3a2Q6P95vqJh3af9czh+IEp/MCrj+Hr18oQYE/mJ66W8Kvvuh8Hp/Ojbh5BELcuMwC0wHfO50nvl4IgIM7DfGIyh2ymI/XnchlMT+d9383um8DkROe4mZk8ZmankM0IyGezyGYGF9Ky2QwOHZpx6zhwcBozNRXZjIBcPoNsRoAgZJDL28fFkctlfW2fnMjh0KEZTE9PuN9PTeUxFezjzITv87597f7l/PU5xzjf8YlOffv2T/rKcJiZzrvH1w3u9sUZtwP7p3Fg2n8dZtrty+X84zI7G13Hvn3ToXGJOs45ZnZGao9tFlnNDB2TzWaQbUt2+VzWPW/CMw9yuQwmJvMQhAzynu+dsc1lM7A4RzabAQuonNmcp/z2NQ1eE6ctFuO+7w8cnMZUe95OTeV8/c7l7esxHbieswemfH3yjoV3rJzrEvUbAMzun4icf84xE279k+5x7rhM5kLfRREsfyJv93V60q5bRXgeBvHOL4eDB6fbz4JkWr63bD2Tcc/bv3+qM+cPzOBQRHbuqDpmpyd9c9lbj/+ezfrq9vbl0KEZ37MIsJ8d+9v3qyAI7hydnsonGm8g/BzM5zIwuiifceUePDSNg9MTsedlMtFtyWYzvnurV735fOe5Mz1jzwvdsDrPzwOdazS7b6pznuf5mM1lQs+9mekJ3705OT2Bffs7Yxt1/YKQgjamfP1aCaJuYSIjQLc4JrMZvGdu9yQHieLDj57Cly8Xcf9tM1ioyLAYx99f2MBH3nL3qJtGEMSti4qAIub5LHu/5JzHpm1XVMP3m2kyKIr/O0nUoemd72TZgCiqsBiHYVmpU8JHkQFDvS67ZTXqMiTZrsM0WFtIZzANAfW6HFuOYfrbo+km6nUZkqy536uaCUXwj4ko677PrVa7fybz1ecc43zXlDrlOucEkWXdPb7Rkt2+uH1tyLC0nO/cpmiXa5r+cZFELbKOZlNBPe/XwqOOc9ohSs7Yhq9fvS7DsjrtM0zLPU/XTfd702TQNQOcM9/3imzPFbNdhgAWqsMyPeUbdh/VwLxz2mIy/7VqNGSoml2fppm+6+P0Rwpcz2Zd8fXJOxbesXKuS9RvANBq6ZHzzzlGb9evyJp7nHfeBb+LIli+Ydh9lVS77lqjMx/i7gXOw2Ner8sQBCHx/eot2zu363WlM+cbMqYSbhMhyhoqnrnsrcd3z2qWr25vX+p1GZpnrgF2Vslmy25TRujMUUU1Eo03AOiav0zDDI9fsM1R5dZrMnhgwcMLZ9HPYsvy30Nx1GoSBEGA4blvlfbzRfM8+xqNzvVqNlW3vd7no2UyiIHniaIavntTVnS0mkr7PuahaxUFuTiOKY+33f/yuQwEAD/42tsx006zv1t54Ngs3n7vYZRE3XVnefz06lCEEoIgiD5ZA3B4bm7Ou1x7HLYVrZq0kCSPsUiXom1+/PWdDS2mXWkzzyV12UuUxbFH1cMYytQuUkO6fjz0x/CrD7rRdbuUPOb7YZE2YcI4MYgbajL33T4LGQLjcln6bcZQngF9xAluR0ggKWhjSGFLxLWSBAGApFvgAN774PFRN2so/MybT6Gpmrjr4CQyAlBTTDxzk1LuEwQxMs4C0GGn2Xd4B4CXCoVC/BJuiDGRbAJwYEelrmFUlSSjYNQxjIeVkLSKwLBHKkl5cccEvx84bC6UcTPBKYFWjDB0bHjwwP8pGUS59M7hgZTUbYhZC+7VNVJlrUflwoB7MHaLv/NWPaxRZoynjjcmBW0Mefwl23q2fyqHiayA+45O43XH94+4VcPhkVMH8Zo79kEzO5P1489Ryn2CIEZDoVCQAXwCwB/Pzc29ZW5u7jEA/wbAH6YpJyQvxcgPwVT72y0E8X7TOMaV16PBwV+TWqR8q9axp/RY2eZhISiuLGtIA9+zlNEY5IZX17DGaYgTfXBF1fffjsLj/k47T3bQsjlIXTueqn8I4+JfCBqeiZwUtF2OqJn4p0IJANBUTegWx489eOfAqwXjgiAI+PCbT6Es6Tg8nYMA4MqWiBtladRNIwji1uVXAbwI4BsAPgbgPxQKhb9OU0Dkuzf02OZhi8QOSIn9VBHa3yzimMj3UuDApBt4JzEIeMcuatw4D6uDsS70cVa6lPqsc3gyZWewQ6KV0iQVR9N17sWOz/gpbP3Sb1cGablfKePRPyRgu1xEx8VC2m//kp6VvPhkNnCeZCe0lF2iJCFjxmfPbcBkHAenclBNBosx/PBr7hh1s4bK977yNpw4OGW/TBXbg+gvXlzBb//Qq0fcMoIgbkXaVrSPtP/1RejlO3r5E8DwYzl6WcSCv/elHPbpGBglcKdVKFJbMgb8PXSMpwGOkNpteTbZwoBNP1bD8Cl9Cs4JFP7EZQ1wLtCZJ6OIc4qL4UyrGI3J42Xb2O6Fq27Fs4h7MPh30rLSHBOELGhjBOMcnzy9AgBoqCY45/jeVx7DoZm9lYY+lxHwoUdOYqOpYTJnT8EnrhTRVI0Rt4wgCGL7CL2khe23JDAMN1ylp0LSb1xPgjp8sSFRrlgIB+vHlTW0IRmyj+NQZkNCo2Eyq2WiolMzyv22omKNUp0/kNVyh1xr+y03QjMaS2VwQKeyqOcuD/wfPie+vF4KJedIZGXzQgraGPH0jQrqiol9E1nk2un13/+GO0fdrG3hsdffgYNTORzbZydOszjcfd8IgiB2G0kEryih1NpmpyKOaIGD9bSEJSm8tzCXVLjzjkKc4tArgQGP+D5OEYj7vte4bAucuwJnV6/DbWiaqHfPgxOyiPbZiOD9MdoEFIO1YVhunkk2Z49j28dvSOX3W0zf2WeT1th112keeVh3q5v/c1C5SuYE2b0MYoR87NklAIBqMhyYyuHuw9N45NTBEbdqe5jKZ/GBh09gta66CyGfpJT7BEHsUsY2bTiPUdAYUJP1forzEQ6zS2jC6gMGDs1k+NaNChQjnJifg4fq7/5KCS/Dp25uD3c57/dxseR+r7fOp5o8XK+SYL4Y3WRQ9OEsEFiMoyzFz6eQ4j7C26VjKenXXXOAumMEfqu9KmFaDBc3mjB7JPfZyRi+UcQLJrFIDUJXZctTua8dg1z3Ps4hBW1MWKxIuF6WMJmzNz+sygbe94a9kxwkip946AQmcxnceWASAoC6YuJpSrlPEMQuJOnaUiiL45DbwbktePvLj66lrnTZCDbGFMb9Gkf4vGASFOZ83/1d5q8vPtZjq6VB0S2s1dUE5aQX5NK6gw5Ddp3MRotiVaW3gpZGyQi2NSomjXEO0yugsuDv0WVf3mzhpeV6iraMfkGj3xakt3ZFS/lRY7lYVbBWV7FYU3qUmbIRCRlUXa8nmLPDIaEfb7qzux7Ybc72ms+ayfDici1prQBIQRsb/ujpRfsPLuCug1PIZwX86Gv3VnKQIIdnJvDeB49js6W598CfPLs4yiYRBEH0SQIXRzY8l7FuvOgRlBXdBI+RuvpZ/+vV3lCa+4SikLfcWDfDjidgpCDJeNiNKE7gjO1Gwsuhti14bv/impygvLjrIGtmmiZ56kw65uHvTi/X8fV2JukorhalyPJF3YTWxeoTdAssywbmS2KidoZJf8/oJvMkB+nY0Lw0VQPfuFaC1l7gGImVypkLXapm3X8esB0R321TXUB438JBSdrWyH5G3MreZ5FvbSq44NRjYailGqkXf0hBGwMk3bYcZQUBmsVQkXV83ytv23PJQaL4yFtOIZcRcGw2DwHAfFnGfLHfhzZBEMRoELWwy12Q4EtbELYprkjrWMZOr9Qhm9FtE2C/f6oBV0dZt6AZfmmioZrYbEZbrbzEyyC9OppAweXcVWbihOfgt3HxQpxH2/SSXo7nFmu+44d1GbfTyz+YQGW5Lvs+bzbVkFtlsD1N2Yjt7FJVjv4B4VNWqgpulu3jV2oKNhLMrbiykvDkfNl1i+UcOLNaR1ny93WxqsCwOMqS1rWsQdyZvVZL79i+uFKHrFse/SzdQkgcm001VXu3WuG+O+erEW7FIQI3VZK6zYjOeL0AdgpND/fPHyfo9UwILLT1KJsnOSgAKWhjwH99bhmMA/msgFccmYFiMLz/jXszOUiQY/sm8WMP3omKbLhz9w+eujnSNhEEQaTFSLAhdFAO2WxouF5q7wE5RMG8FnAz0mLijARBwDM3qnhxqQ7VsHC9vR9lRdJhRAhN59aaqfWs3rEk4WVrzYhXvirtOCczbkPdwDJ1WitIUotfx8oC3/9JuLLVQkvtKNFx5zpfJxew0/W1LOm+us+tNUPHsID5Na4GUbOwWOmioHVp2uXNFs5H1L2dlFo6rkdY8MqSjmb7/km6CNALn4Oj50PwupYlHYJgx6GZQW06QRtOB1zoJN3EubWmqwgnYbUe71rpLEoMm4vr4Wv//FLNbcu1oohLG/5jksRzdiPqnlpt2IsE3qGPTRISPD1Q3s2q1LUtNyu99/4lBW3EWIzjM2c3IMBODsLB8YojM3j4rr2ZHCSKj7zlFLIZAUfaG1e/uFzHWqO7/zVBEMQ4ofcQqADg6YWK7z2uWywy2cUgCEJHiQEA8Girlm4xtDxbm1zYaOJz5zZweqWGa11cz3r1Mm2GuytbYqjcbvVvNu0V/vmtsIAjaRaWAwKmc12CzRpeUhe7HDOF/9JyVYGaQKFPQtJqRc0MKxw8PmbIUdCTXE7TYihstbofEyiIw1aAnrhSdK0235wvx577xJWi+9mNaxw0o2TILY1jraG6imps6Snr7X6PC26RtlVXwKUtEWdWG7Fn2DpzuA1PXffH8DvWOjXGgh5ZdkzX1hsqNhq9rZxBw1dPl2gApRiLZVG0v1+oyPjS5SLOrTVgWAzPL1WxmaAtXeuNaZdhMcgeS5rPxTGmKxYDSoEEOXXF9Cvmgb//+qW1nm0kBW3EfObsOmTDwlQ+g3sOT2OxquC9bzi+p5ODBLlj/yQee/1xNFTLncR/SFY0giB2EUGXQCCcI7As6mioAWFpB8Jc4oSRL122hV7OOSqSjvWGisWqAsai7Ugm41jv4YoWFOiDbnSAf/XYWSX3NnGxGr1Ap5nxLkYA8ESh6ntckwAAIABJREFUhC3RLyg5rnMC4MsSPOiwOwqMu6dWzHHB78uihsWqFDpGcAX1zhlRSk0SWhHutpJuhSTMlmbGWgwZi+6XYYXj/BYc18YuYss35v1xbdxTc7GtoGkRbm0lUcOXLm762lmTDZgW6zvrszOuXsOyYlgdF762/BUXH8U5T6UcfsMT0+c9raX5k/TY88Cml4tfVO3B8WupJkTNREs10Qgo4vMlMdK10Fu+c13AgQvrTZyNsHQFUXps2xCqh3Nc2ohW7oNxXptNDc8v1vAPl4rYiFnEZ4xDjngWBymJeshls6VZuLzZwqLHVdcXG9vlktfkcL+7LVatJXDpJQVthHDO8V++Y6fWVwyGwzN5zOSzeOz1x0fcsp3no285BUEADkxmAQDfnK/4V4EJgiD2AEGhctj6WZTcuBSj8DDGcW69iZfXmviHS1toaSbOrzVxNcIaIqkGiqLmswZErSMGvR/KYthCM1/sKCi5jIAnrhQxn8Dl5/KW6Fp8ovrZkA2sN/yr8d7hTiLQJxW8L2+2oJud9fWkSUdeWmngwkYrsKdbR+BXPUJ2v+/AphYWFr99sxKK8yqJWs/+BmPSliIUbgA9heLLm9FWUUdREzUTkke4d2I6Zd1uX9DgaDCOq1v9xauX2kq81yXwW9crONdWQBjn+Nb1MkpStHWR83Sxgpe3Wq6y4x3v8+t+Kxn3amhdngwMiHSBjFo8uVGRcWmzFXJP/Nb1CqQecbN6e9C3cw1ptab0TEzitfLWFQOccRgDJhf5m5fX8XcXNtw+ArbCHFRaV2rRilQoSUgv+hjEXPpTiGHx5ctbaKgmpvMZHJmZwPn1Jn7ioRPYN3nrXZbjB6bwo6+7A1+8tAXAfgD98TML+M0fmBttwwiCIPqAcY6NZvdkAwCGLv1YnGPN4+bH0REm40SKtYaChmLAYBxFUYtPksDhc/+JOcSH5rhXxfTz6pYIUbdwbLaTFEuIOVZUTTRVA4em81iPcXESQlkyO397hbpqjPBdEg2s1hWcPDQNUTMxlYtfx7682VFko6wRZ1cb4aQlnEMzWGdc2jTaMWleuTMc5hI1MH6roB7jznZ2vRlS3Ozi7FmhW9HneWPl4lB1K7Vr66WNFuqKiZqsYzKXxUurdRyanoivw9OvjaaKwlYLSz1S0cdRlQ1Yge0EvBgmQ0uzcC0mYZlkWFispYuZu14ScbMi4TZv8jdmj75zj3JwZBxLapeybpQkLHdJyJKESswee97Yzn4eTUFFvde0uLwlRsa7Ms7RUAyohoWzaw1kMwIMy14Q2RI18AGdzETdxIW1ZmChJHxcSUzwDEdEciLutRHbbEYkYOnGracJjBH/Tzu1vmIw3H/bDNYbKn7qTXeNtlEj5KNvPYV/uLSF2XwGksHwpUtb+JV33X9LKqwEQewuwunzw/E9HIDlWbEtipqrNPXrrhXFikdBK8uG68oTjJPTTAsm46GV9G7eVd4SNpsq1nssZDt7rbF2jE1TNX0ul5stDfsmc75MknEjwTjHQlXGHfsnI/cIMzkPuXM618ViDF8vdGKc4gSv5aoE3WI4NjuBp29UcOeBycjjNMPC0zfLuOfwbExrwxnxFMOCpFto6SYmMh0Jk6PjDhVl/eqGt7fFlobf+PJVVKKUTzvoy/eV7LGGNtrXyWAcqmFCMZ0509tS8eJKHasNJfLCWYwjmxEgBhT7pmZBLkrI5wS0VBWaxXDyYKeuoPK0GVjsuFGWeu4T0VAMVCQd2UzgOB5O6nNuvYmDUznnZ6zUZUxks5HlvrDcSJ1l8AsXt9BQDbzt3sPudwzcVdAMi4NxINtuqmIwfOHCRmRZKw0lNB5RGIxDMUzIWnic6rIeuS1C1AbZHTfe4VmgHZaqSuQ559eauJoTcWg6D3A7Du3AVB6vvmMfLMaRycYkCUlYfUMxMDuR81msq7KOYkvFTL4jcy54vA/KkgGLcVzdavliTi3GQ9buZsTCRpJMv15I8h0R37peQUnSMZXL4Pb9kzi72sD3PHAUJw9Nj7ppI+Oug9P48Tfeib89uw7AzqTzR08v4N+955UjbhlBEEQ6clnBjvsJ4F2hrikdC02CHCN9UdgSO3uHBYTerZYOUTOge2Oz2haeWHubL4bGQj4gKAUFJMcap5oWPntuHQ3F9FmydJOhxU0cmu4Iw2JMHAsH0JBNzJclV1gUhAwAq90fLdRubxLCC55McEqMS15dNTE7ZeJvz62jLEZn+gOA+bKI2/dNuuUkTRLiKIbeoxnzKLJR1oQUuoCtbIfLiNDPUG1br4DO1gznVhtYb6puO0IZQdvJzLzU2sJp8FjA7u/xA1OoByw2km5CAHA0N+Eq1Q2PUOu40hZFDbfvmwgtYJxbb2IyRoFyeOpGBQtlGRzcJ1s1NDOkeDYUHWVRw237JlGRdYiq2TUXQJQiE4dm2tsntTTT1w9vvORie+EBAGTdxHJNxoWN6EQhLc2M3GQ8OEaybuFGWcKByTzuu82/kNDUzNDCjMU5VqKsku1ik2xC3W0vvCjOrzcjz9loajg8nYdiWNhs2VsFtFQDV2Li1dLCeLSbaEU2MXmgYzX3KuLLNRlnVuq4siX6XL0tHo7NlXQLwXWBJJl+vZCCNiL+zyevA7D9zR+66wC+cHELH3zk1rWeOfzs2+7GFy9tgXMOxWD4+/Ob+NfveAX2T9FUJQhifAm69mQjhLtwsg7uruBacbtJD0hVNnB42n5+hlPT85Bi2FBNTGYz0e2JEDhKYpTbXBiTcXz1agkP3DYLySPcSLqJimxgMtsRiuKsSLrJIOkWpuoZtx7vMDPOsRKIkXKaw+BPIT5fkiItAjXZgGoyLFVlWJzjviMz0W2xOBTDQqHLvp3XSmIoNbdrGfL8oFkMQpfkCjzwf1diDmqpZugn3eIwrU69Lc3EUk2G2iWerBhhebxWlqHoVqTSUJF0HD8wFdvUssfy4BWYvQrUSl1FTfFbKK6VJNw2G+8SCdhZIWfyWdRVA2VPuxXdwsX1ps/K0VBNZAXbja5QlLB/Mo+jMzFyB+ewkl0NAPbCgZMQxOuayzh3fRx1i2G9oeDEwWlUJFuZi3qGdCOkTFvOswVds0I6cPinj9zOorLe0KBZPNIq1IuoORFsY1wMmmpaqHsyzdYUA1U5PgYV6GlU9bElqqHYRkW38MJSZ6y88+7ipoibZRmaxbomWIlCMVik1b8blCRkBJxermO9qWEyl8G9R6Zxbq2BV9++75ZKrR/H4ZkJ/MybT7qrkhbn+E/fuD7iVhEEQUSTRoSSdMu3yi3plquMDMvDMShkGYyh2BaCvRnWLM5jBYa4pjTU3taUboiahZKkodTqCD0lSQfj3HWp64YTqyLqHWXDO/6NCAFyq9URiIOJOaIoibZwrFkMusWw0iWdt8F415i8oPJmcY4b7T2povZxA6LHPsabC0DMflARhegmc5NgePHKpzdKEpqaCZ0x16q61ghbBoJztaEa0GPMfOfXm/haoRj5WxBflk1PHRVZ9yU4STrj1puqK+CXJcO1aDNwrDa0kPJQU+z4Q0m3YFosdqFgs6XFxkBG4RXmr3rmhIDO/LWzqGo4t95EQzEiM1o6tIKZYHtQU/Roy1hCipKOhS573A2CYliR2TIZtxdjvlEoIdM2RSVbw0o2O0yLR26NUpU1LNWi+1qTdSiGBcVgkXFzQbyHNAPP2iQu7aSgjYDf/eo1APbL7bvvP4qlmooPPnLXLZVavxs//chJHJ3NY7L9VvrHq0Xf6hdBEMS40C1eSjd7u6sNbTsuD3GruxHNiVzhNq1wAgXZYKhJRs/93uL2NLLhaCpWyBqSFm/Tgq0JyrVe9ylvvEnc3lQVRUdV0ttp6eOTiQBwkxYkxeIc9T763q0Or+WR8fg9ryTD6pqkQLOYHUc2ZBYqMr52rZxIbvYqeY4FbaWuhNKhp9k70FHE66rhc1eTAhZLSbPAeSd2qKYYKIvR16pQlHCjlFxh8S4ceAXzumK4Fh9JM7HRUqHops/lOLJPfaTvaOlhS3covpBHX6a02wqkJaq/usWhtRdInOvN4hroJcEhAFzF3fv8Uw0LCxXFF5sZ9jlAKMFP5IEBggsYUe7AQUhB22GenC9jraFiIpvBK47M4OJ6E8f2TeD7546Numljw3Q+i59/+z3QPBuM/t7XyYpGEMT4EiUYK0Z4BT64DhfcC2kciFI7FNOOBfEKL1GrwDXF3x+vcMoAGFYa57AwGcEvoAetS0HhybGaCPBfo25CsBPM36udcXFsDrb7nr+UKOWZg3dVOrrJxt6fTMYhGdHj26svhhVOdDAouYyAYktDTdZ7urp1wxZmwwvYUfu9BTFZJ3FMt83JFdOCwZivnUqMFUszLZ+ynwZvC4qtjpDuzEfv/B3eZuphFCPsksrA3S0IOLjv97TuecMg5+xH126GYXXaFFTaHQYZMZ1xKCYD99yjIbdOHncPd6eb23AcpKDtIJxz/MevzQOwVy5+4DXH8PJaEx9+8ynks3QpvDz24J24+/A0JrL2bhNPXa9gJcbsTBAEMW5oFgtlrtvtNFTTp0hEBfdHri57fx8wGwoLCEjJPU/Se6ioKV04k9BL5o7KmtjNThe1MBCZYbBHxarBQhtQD4rJODZFDQ3V9MUS9Ue4/b3mGmDPWSduKY0bcTeFsqYYA+/DBQBVRffNZcY56h6FoF8lMAlyjILjXXRJksFzO/FeAw7btbnXPMplhETzIg4B3RdvajH191TQ+riWpBXsIJ87v4mKbCCXEfDwXQdwZqWOIzN5vO/BW29j6l7kMgL+p3feB93qvB5/88uFkbaJIAhiULbTVWg3MGyFJ03NO3dWPINYkpISFd/WK7teOmfNnWcYwzbut17aNOzbQZTiFqfMbTdxl6vbZeRC+hi9QUlyT+sWS701AyloO4TJOP7zt266f//o647jheUGPvTISUzlu6eKvVV55/1H8I77jrguLJc2W3husTbaRhEEQQzAMNakJ8fA4yIXsFxNZJK1KakVYyJhH40Ii1zU+IzWFkAMyjB0q9EtDiRDt5i73QIRj9bFXZDzwa5zXAxnL5Js1J5W0R39U/4W4WPPLrr7IvzAq4/hK1eLODydxz9/6MSomza2CIKAf/t9DyDrefH/1pev3vIr0ARBjJ5MHy5zw2Ic8kkFrTTD3gplNuHCJY9I7ZbNCD1TsHdjJ6xcwyS439KwmcrtjUXknbqq+yf7vxe2M+5sr9DN2ps2/f2wcLLQJl1YSgIpaDtATdLxyRdXIMB23XvHfUdwermOf/m2uzEzsTcefNvFiYNT+O/efrf7uaYY+NizSyNsEUEQtzpZQRiaUOwoehMpCswMoKE59Q1bqB+60jhAeWlOjRKCdlJB87Z11iPYT3TLrZ+SQRUsQQCODaDw7lYOT+d7HhN1lQa5P4ndzXQ+/ESZyvWnapGCtgP8+y9dgdVO/fnTj5zEp8+s4479k/jxN9w56qbtCv7Foydxz+Fp90H4iReWURtytimCIIikTOQy7hru7ICLbM67O5vQRTDOvfHoTDIBenoii6l8FjMeC9XsRLIV/8l2Yyd7CPxDESw8OlJUfcE6pr3H9JCPB1FYDkzlsG+IC6v7J3PuhsRepTldG7t3eCZCaEwD58DhmY6yMgzlfiKbQX67TX8DElS0Dk35FbaJjOAmePPOCUe5PjKTx3Sfwvl2kM1kcHBAS3eaa5bPZBK7Pg8T7wbfSfrbbxsF2M//TOC7IP0aYsZn5uxRvrNQxUsrDWQE4LbZCZw8OIVLmy38/Hfdg4kxunHHmXw2g3///a9039cWB37t85dG2iaCIG49Zic7L1rHyDKd0BWv59M+hayaEewYMK8bnyD4i0jqarN/MofpfCbWZXMi0xGkhfYxh6ejhZ58RkA+I+DQdB77JrLICH4FNqpFcdYGRw7cP5nDHfsmfAolADx44iCOeCwcOY/FSYDgUzqnA8rOZC6Dw1N5zE7kcHCqt5XEYSafxUQ2g2yMkBrs32Qug9l8NnZsj07nMZXLutZH71Ck2RdVgD1OB6dyODydx76JnE/oFOLqn4nv+2Qu4yoXHLb3z1Qui+l8Fvsnc6EYxDTkMgIOTOV8MlDSBYYDQ3alnfz/23vvODmy8lD7ORW7OsfJSTMjlcLuarXaKDayS4ZLMNnYwL1wHTEGZ2OMP3wx94ITxoFwfQ2OGAwmLGBy2AUWll02ILSllXYVVnE0OXZPd9f3x6nq6e7pSdJo1CPq+f2kmamq7jqn3qpT73vecDSl4TMcMzXpOYyZpCwdS1PRVFETehuz9MqV1aruCf/+UIRYkxxXM5boF3Ddde3CDeJ633LK0kmEtIZtVxRBb8aiN2WtKUJgrWTDBilLr4SWaorA1FQ5dlWNg/oShlh1ePZam2npKuklvMtaZdyUVE+uJUNajSHZiMBCuIgUimXe/oXHAJkY/dbb+/nwfcewW6I8f1frJW7d5mJvd5LneddMAI+emuRrB4cubaMCAgJ+qggbGnFPCVjq3aoJQdzUiBieIuu9pNvioVWdo5GCoCmiRsERAuyWKD2pcI3hEjU1IoaGglQMqxUA3wulCkiEpSKvCYGpKRiqQk/KQhGN7UTfu6cq0ovQGjMb5ohFTJWEpRM2NLqSYdJhA0tXK563lFWryJiaWhPKV+2FEIpUhk1NIR7SaY2aFaNAEVIJNqoMr1rjVJCJGBUjpdqwll4PgaoKelMWqiowFKUmnK2RMhnW1GU9UYYqahS1sKYQMzUGsuGGMjUUgVCE9MZ6Wm+1sVr/mS1pC0tXyVhGQ6+AqUllVAAhXSEXW2iLtcQMfiPjwb+fBNXKuEtI14joKlFDJWpoJBsYd3FTQyCVdm2ZEM14gxwtvyn1xnQ1MVOjJ2k1/PxSKIjK/QeLPUBhr0/117Ta66EqYkHZFqIy6dAWMxf6WXUttaocyHSDMMlESGvoiaqfhKj+voFMGKgNg1WEoCVqcFVHvLJtOZVfTlosHBHSvAkHITBUsez5QXqmhFtr6CgIOuIhEiGN9ljtGJcwVWKmTiZiLnkPQq3MsxFjkSG1nBcsEdLAGw+6Egvn709bdKcW/o4YKp0Jc9HnBaIiOkMVpKsmCvzxxlAUMlXPdiZsVMbZ2u9aQE4AyX7pqko2YqBVGWiaqtR4pRsRGGgXkfff8wTjc0UEcOe2LEdGZzkzmeetd/QHMcrnwW/eMUA2YlReGn/4hceYrF9EMCAgIOAi0ZeJoKsKUUMlHtJoi5kYqlIzM2rqKoYmFX5TUxZC1eqmnn2lJ2zK79JVseQMesRQ6U2FK3+HdRXTO3ZLOkyLpzwoQuZARAxVGmIhvaLcxEPSYDQ0hd50BFVdCNPEhR2tUVKWTrKBQlntjOtNW1zTlazxjFma6uVZSF9NS8xsHNYjqKxtCdCXtghpKroiSISkUVeNb/CoiqAzGWJLVhqkWU+Jqn6LJjyvniYEUc8rlgrrdNQZxqqq0B4LsTUbqVRQFopAVUQlhE2vUuh9w/aWgUzleNeFTJ2xaXneNZBKq39s0jLoTFiLrwUQD+lkwrUK98KlEjXnkMcaCGXBI1btxUqEdNrjIXa2xchFjIpHqi1m0hIzazw8vjHqe6MUqpTwOsOh2sjvSoVoi4VqlNVqpd7QpCIbMdQldRxNESjeOUKaQkiTYXfdSYveVLjGmFYQtEblZEDGMhjIhtnVFqvximiKqJyr3iMRMzVv0qHqOnleS7+b7XGTZNioMeKARfdNa8wgHtLoToawdJWQpmJ69y5QU8O/PxMh68kgZKiLQnRjpkZLzFxkiAixuPhQxNDIhg32dEmPsb/XUBXSYSnz3R0JaRDotde92tsYMTQ6ExZ6leG8b0uKmKER0hVMTWUgE1l0/mzEqHhmW6IGYUOt+Q6AbNRkX1+a1litAeQ/v/HQgqdaFWKRwRXSlYZhgqaqVCYeYMEwrL7vq3+3W6KAfI4sQ2NvV1Juz0bZlovWPNeNqC/uomsKcVMjZmrsao1V2p0O61i6glAWWhsxVOlNtPTKBFA9IVUa+i1ReZ1WmmgIDLSLxONDU3zswZOAFNyrruniI98/xl3bslzj3TQBayNqarzzuXbl70LJ5Vf+45FL2KKAgICfJoTwCiZETWKmRkc8xNWdCbZ5ioFEKmrVSqRvzPivbIEM8eqMh+hJhombGm2xEAqQDhuVF3PGWjCwVFUqC7oi6EouKPymrtacCyBmaURNDctYUG7SVq0SWm1UZiIGCUuXXjdFoFCr3FUr974C2JUKVxT9dFgnHTYWhdJ1ejPawutzytJpi4WIep4QFUEyrBMPafSlIxWjzu9zv+c1EEgDJWbqdCWtiuJ3VUes8ntIV+X5xYLikwrrtMVDDGYjlTbFQxqZiMFgbkFmIS/0y1cwjYpCKIiZKroQpMI6tw1kSIQ0shGDnrRFIqTVKJvVhovdEqU1ZjKQDdOeMBd5TVo9415VVZ63s5XeVLgyk58IaSiKLJJ1RVtMhkMpCilLq1xzS1O8EFIZXpaJGPSkLBmyamgYqsK1XQk6qozDiKFyRVucqKnSk7BIWgZtMYNMxCAdNhblU0YMtSLRtpiJqijomsJAdkEuYc8Yq86Za4mFsDyFtX7SodrzKoQgamrS8ycElq7QEjFlER4Eg7kwnUkLIQRCkQq6PFYad4aisCUdZkdrFF0RZCI6KUuGrgo8Y7OBVzhqyralwzqaqqArEDVq7/fedLhyH8RNDaEoJC2jxhO0JW2RiZiEdZUW796JmRqdSXnfR0yNjkSoNvxRCC8XTMeoCjlMWTq5iFE51g/RbY+ZDOYidCetimGrKaIy4aMIqfT3ZcNYhlrj2Zft9yaCdIVBb5zyn49sxOSZO3L0pcPoikBTZXiyoSpoinxeNUXQFg9xQ2+KtngIIaAlatZOSmmChKVX2udfB//Z7EyEKtdyWzbCXdtyWJpCX9rC0hbuMT90eqkQYj8kNlE1idRSZRR2JkPETa3yvEVMjSvaY+zuiiOEIFYX+psw9Zp5MyEWRrCQppIM6RiaNMR602EGs1ESIY1YVVi0qQm25aQB2JsJk7QMEiE50bVg7MqzCC/823/OkiuE9a5vMG8AIEMb3/ypH1f+/vXb+/nAd4+gqwpvvWPgErZs83NdT4rXXNvFP//wKQRw4MwU/3DfMV5/Y8+Knw0ICAi4UNrjIfrSFtmIyXypjKoIBrIRTo3NcW62UJlFTYR0wrPznJ7Iy5lWIY2DlKXTlw5zdHSWlPeCvnUgy+jsPKVyGRdB2XVxXTA0FVEuc1NfCsubrTc0gd0S5bGz0wuN8vQAXyHYloswNFlACMHQVB7BgsEY0hR2dyU5emaSsdkCMVNH1xR2tEa554lh8sUySUunLW4yEy6TCGmcGp8DpJGUixo8rT/No6cmSHkz+tmoNM7a4wauK0ONnhqf48r2OKcn8yhCkLZUtrdGOTuVZ65Y8gqtuMRMlbn5EqoiyISlUpMJS0U47BkeCKmcPW9nCwdOT7H/9AQC6ExaPHx6stJ3Q1MolcsV70jU1Ci70qPhnJ1idHaeqKFxy2AG13XZ731WE37xk4WiBilL56qOGGcmC9JzhZRHwlowDo+PzVZE4CKVZVNViIekcpovuWheCJmuKiQshZHpAmWk12HWW88pEzHIRQxG8/OMKAV0VaE1ZqJrCrvao5yezMvjoiYTc0VcF0ZnCxTLLh1xi5ip0pUMEdIVRqbnAWhLmGTCBkdHZ5mYK5KLmrTHQwxkwhwenuGqjhhFbw05XREUSmXOTOZRFCiVXcqui6WrjM8VSXlhrZP5InFToy8d5p4nRjyvikkipBPSVc5Myvvkrm1ZhgtFvv3YEL3pME8MT3NmIl+ZWBiZmW+4VtW2XJQjIzN0JEzCukZXMsTobJGb+9McHJoibumoiqh4t05OzDGYjXBmqsCVHQmu7ozz3SdHODddwFQNyrjETY2S61JGXtOZQglLV0mEdCbzRTriIc5O5TE11Qv3FXQkrJqQ12TYwHVdIoY85tjoLBFDht7uaIsixIJ3RxUCrcoIiJtyIubw8DQl1yVqagxkwgxNF8iGTebmZym5LoPZCAPZCJP5IqUyzJfLWLpB3NKxW2Ps7kxw90/OMj47T0Lo6JogFzGJmSrpiI5AhjRvb4nyk9OTlf4Ib3joS4cxdYXWWIjRmYLXZsjGTHa0xNjZGmOqUKLsupydLDBfLtMaMxmeLmBq0st/dqqApgi6UxZThSJ9YTnOtURDJMM6W3MRTk/MkS+W6UlZFY9m2FC5y84y9GAey9QIGxo72mRY5kyhTLFUJh0xuL4nyeFzMwgKldBR32CNhzT8tdaFgLilYyoK7fEQY7NFNBUMVa1MvPSl5SRCezxUaYemSqPw4Dk5dvZmLGbyJTRV0B6T47oLfP3gOUxdqc0JBXa1xyhVlfGXExTyPj10boYdrVHKZRfXddnbnWT/6QkePjFRc4/rikLU1JjMrxz9FRhoF4H3fO1xhqbkA7C3K4EAfnhsjN++c5BcdHEMbMDa+JWb+7j/2CjO2WkE8HffOcJNW1Jsb41d6qYFBARc5khF2+BZO1qY8RSaqKlxemKOkxNzGJrC+GyRmKlRKrv0pARTBWk0FEpl0hGTff1pJg7IHFoFaRi0xkwmZuc5PZknYer0ZyOcm85zYnyObMRkT1eCQ8MzxEIapqbSl7IwNQVnaNozjkK0RQ1OTOQxVIXrepKcmcxzZUecwnyJa7oT/OsDJ5j1jKErO+LMzJdqwiAzYYOJfBG7JcrQVIFsRKXswoxVoiUWYndnnOfvakUIQU/KolyWSryqKHQnQxwZma3yyOjcaec4N53n8PAsYU0BAXZLTHpNFMGRkVnaPY/aVR0J5ktldrXFuKpThrFNzpUqXr94SMMyVCKmSjZqkC+WazxjCOkJmy3I0ElDUxmaLjA5V5ShY5625bqwq02+Kx48Pk6+WEJfsPt6AAAgAElEQVQTQi4i6+WyCO/7BrIR4iGDE56BCrLqZrHcoPCGCz1Ji2KpvKhAixDQGgtRKJYZ8SoQCy/vp7r92ViI8RlpYG3xFEyFhbb3Z8I8dGKChKWTCuvMFEpc35vimdtzfPkxeT+1RAVnpwrSOJ7IsyUdZni6wKmJuUpb5OlkLl42Ir2fB4emyUWl8ZkM6ZTKLooQlFyXqzoSXN+7EPmzuyPG58MGE3Pz7O6Mc2pijqSlM50vEjZUrulOcs+xMW7uz9CXsZibL9ESlcU2WuMhPv+TM1UeIAjrWiWvsD8bIWYm2LclzX1HRgjpBeKmRtIy2JqNMF92uX1rlkND00zMFcl4aQ+5qMm+LWmipsa3Dw0zWyxh6QozBTmJMjVX9EIbBTf1puR6YwJu7EvzrUPDHBudZZdnNOxqi/KsHS187eAQBddlV1sMgTSknxieJhM28G0wf1LEdaXHSojakGCQOZBJS/dCGKWi/+3DI5i6gq4KwopKezxE3NK5fTDLyOw89x8dreR+akKGccZMDUMVTOVLdCVDzM6X6U6Gua4nxYmxOQxVUCi5Fc9VNmJwakJOkMjwZ2m0xUyNQqmMqgqu70nx1Vl57wzmIpyZzHtjTG2BjbCukgnrFEsWg9kIc8USpZKL3RqlK2lxVUec4Zl5Hh+aZmSm4Hnj5WejpspgNsL3jowBcHVXnBv7Unxh/xkACsVSJac04hkvLnKSxDJU8sUyE3NFpvJFL0RSJ++66MiQ6zEv1aWR5y0XNRmZLtCZCKGp8jrEJvO0xU16UmGGpwrkPcsv6+nnN21JMzSVx3Xh1OTCs68KOQlULLsYmkJXUnqsXWTo9o7WKIeGpiu5Zn3pCE8Mz9S0pz2xulxkCAy0defrB4f4zI/PVMpv/uLT+njzp37Mns44P7M7KKu/Hmiqwp++cBcv/8gPKzOQv/SJR/jcG68naq6+IldAQEDA+eCHqlXnWb3wyjaEEHzZOcs5vVAJoZovuzwxPEMuIr0MUVOlPxPhddebjM7Ok40YniIMrusyXyozX3a5oS/Jfx1YKIRUmc31FFs/zCcb1hEuuEIqGMOzUrkxNIX+bISZQomQpjCQi3JlR5yhKWkgtMRMXnlNJ/tPTzKdL4EQaKpCa9SkIx5iaKrAlkwYRQjCukKn5/3wC0vcsTXLA6EximWXn5yeIh026EpJz8OJsTmE5zXqTIY5M5HH9fOmFMFrru3ma84QEUMqY9tbYtyxNct0ocjIzDyG6oU6WhrbW6OVWWdYmLW+dSBJX6Y2L++K9jiqgFRYXtOhqQKqshDiJqu7LSidrTGz4p2KqQr96TAnx+ZIRXQ6EiZ7u5P84NhYxUDrSlnsaIty/9GxynekLJ1z/rIvQoac9mfCbGuJEjWn6UlZTM4ViYWKFIplzk7NVTwBmqrICpqeUVitXsZMjZCucped45GT0tN357Ycc/NlNC9nbna+xG2DmZpiH51JC0WISojlsGfw9SYtCg0W8fXz43a2RhFCMDE3j6oIWqMG3z48gipkHlAqbGC3Rjl8bpqQoXNle4yRmXlCmkrKksVgslGjYlgO5qJMhObYmosQD+k84nkSulMWuiKYL0kfWsTQ2N4S9bzOGoWSS0vMJBXWvSIYJvmivGCKInjG1iyu65IK6+zbkmIwF+XhE+OcnsgTNTX2bUnz5PA0J8bz3LwlxXePjErjKAG6KtjXn2EwG+FLB84C0sOSsnRcXE6MzbE1G6lMpLcnTFDVihfH9/pFTI1iyW+Tdy/FTcbz83SnLATSi1bthctEdHm9dNXztlY9097P63uSnJ7I05e2ODuZxxeXqS/k7SlC0B6Xxu7sfL4S9mfpKttaouSLZZ4anSFiavRnwhw4M0XM1LiyI46hKezuiHNmKs/w0QKqqK1IekV7nMPnZjh0bpptuQgHh6ZxXdjeGuXWwSz5YomvHTwn75u49JI/086he+GtWtUkiOyWwM7JvN3qc/n3XGvcZHimgN0SR1MUiuUyuzviRA3pOTdU6WXXVYXHh6Z5cngaQ1VIWjq5hEVUEzxjewsjM/McH5uryY27rjdJ1NDQVEGhWOZbh4YxNYW5gpz0CesqqiL79vBJeW+mwjo9Kdm2trjBxFyR0VlpbN7Yl+L+YwvP/TPsHHFT4ztPjmJqcuwZzEVpiZnMeHqprsr7t1R2GZ5Z+9JQgYG2jjw1NssfeFUbXeD3n7GNv7n3CAB/9JztQWGQdaQtHuLPX7SLX/7Eo7jAVL7Ea//lIT722r2L8jECAgICLjb+rKnCwku5hEvM1NiStoiaGkPT8yhCht5FTY2WuqpnIV0lGzWxDFlc5Gf3dnLv4WFgQXmvDw3rTFpM5oteON3CO+aOrVmEEDhnpipKpKWrld/l2lZGRZnyvTmZiMGtgxkm88XKOytsLi74kYuaPHtHK4ViWXojgFv6MwCcGFuYde5KhnjkhEKp7C6EGimC3V0JDpyerAn1iRgLOVaaKuhLh9l/ehJdEUiHh6xOeV13kp3t0qvhV7UTQuaCgCzK9bWD52iLmxiqRU8qxNUdcU5OzFXy4nwUIa+F3RolFzXIxWQOyZZUhJgpS9aHDXnRuhIhEpbOgdNTlc+HDVkwwsWrrpmLsK8/TS5qclVHnOOjs1i6ypZshB8cGUVXFVxXKnC7WqNszUWZLBRJWjqTniECsKc7STykSY+eEJXfqw1MS1crxUh8rmiP05OyCOkqbbpKWzzEU6Oz9GfDnJzIE9JUBjJhbhnIcI93b8FCCKxfSKYrZRExVSaq5NOXDldCx+IhnXhIJ6QrJNHZ1hJhZ1u0khO0oz3OmJdT1B4PVQy0trhJW8wkXyqzsy1GuewS93J6BrIRDpyZqsnlA+mByUUWlloQQrCjKmJmd2eCqzoWnovre1PoikJv2qInHWb/qUlOT8yxVI3DrS0R0laKfKnMQ0+NV56wl1zVwZPjeSwBY7PzFYNJFRDzKvBlPa9j1FS5ujPBLQMZTE2e++jILLPzJToTIXRV4cxkXhYWUmTV1CNV3hXhjQuDOWn87WiNkS+WGJ2dZ0s6jP9o66rC62/o4b4jo5ycyNf0QxUyx+mG3hSZqMG+vjQnxud4cniGhKXjP5Uvv7pjUVEUkB4oPz9KEXIiSlNk2G7YUAkbshphvlgmGzVJhY2ayQH/V9cbD1RF4CKfL39sql6i46qOOAeHpjE0ucyHpsgJiUZsyYRJWhr5+TKxkEZ72qIzIo34G/tShE9MoAhB1FBJeTmxjRjMRTg2Niu9k548+9My//P63hQAD5+YQBEK6bDBQDZCZ1KGcGqqoCNucmxsDgXB0/ozTOVLANzcnwbkc7FQvVHm5pmqYHim4OUYS0N9NfZAYKCtE1P5Iv/z3x9m3ovpfunudg6dm+ZHT43zjmdvo2MNbs2A1XFtT4pfv72fv/jmEwAcG53lzZ/8MX/9sisDYzggIGDdaYmZ6NHlj7ltMEO+WObkxBzHRmSOkq+AWpqySKGu5qa+FLoqmM6XcJHGV3Ui+WAu0rBku64q5EslOpMWLTGTzoRVUZzs1sYNrvel5KImL93dTmvMrKx15ffn4NB0JQ+tHkNTMNWl+7S9JUqp7PLoyQm6kxapsEy8T3sKbqOqkdGQxt6uBCFdpS8d5uuPn8NuiTBXmZlWKmP8dX0pxiYXZqf39iTRVIVn7WhhKl/k9EQeTRFYhoplaLTGa9MMdrXFKt91U1+aidkFg8R/jfiKef1rpSdVW3VSEbJ6YyPlUFMET+tP4+KSDevomsqddo6QrlIsu2zLRfjhqSmKhRK6qtQUl3j5no5F64QN5iI1xRJ8VEVUchurMTWVrbkIxZIMyQ17BSXcuhtBVxWeub2FufmSNBrnSkuWbo+F5HISp+fztMdDy97bIV2hJWaSDsuy8I+cmsRUFXRDysqnNR6qMR6EgKdvy3F6Ym6R4VZNtaGwtaoATFfSYv8p6YFMhhurvP0ZGSo7Wufl6E2H2d2fZXRU5iwdHZ3l6MgM21uiZGOyOufQVIHrupOUXBl66cvez1UayEZIhXX2n5pkV3uMXW0xHj4xQTpscGp8jkRIetp3V5XK11SFG/pSldBj33hOWhpjs8WK3E1NWXRP3rE1S7FURgiB67p0xEPkizLsds7TT0O6LIChNBpMkF6l63qSGKrM6azmxr4UY7Pz/Ni7ptX4Rpg/iWRqigwBN+SE1C0D6ZriIm3xEFd1xJktlCrbGoUpylzE+YqBPjQlDVM/zFhXF8bVgeqw5zqEkJMFpiYjGfZ2J3lyeIbBXGTROKkp0vATyHtLEYI7t+X40oGzzMyXGczVnmfRouaWzp6uBLcPZvmPh05W+tudtBiZmWd3R2zRsiP1BAbaOlAslfm1Tz4q886AK9pjXNuT5Hc/d4D/dkUrz9sZrHl2sXj13i6OjMzwn4+cRgD3Hx/jj//rIO94jr3iZwMCAgLWQlcqzMz08qEqIc+rETW1ioHms60lyhUdS+fKhnSVzoTFwbNTiy0oIdcFS0f0SiEIn96UhaLKAgHLKclQ5YnzNPO2uMkT52YwvZDIRm1aqqqaz96eJBNztW3ylT8hBL2pMCfG5tjTnahUp4uaGs/a0cL47HyNF61aWQepsD3Dm1Uvll2mC0X6swuGUSyk05EMVUKTqhfv9j0ST3qeilzEYGuVYvU0b9Z7qWvm9zoZ0r3KgfK42walp3B8dh4XmC0UsQyNvrTF+OzSyf8722KywIbnufIVb00RxEJyhv7Kjviia+B7raqpV0QHcpFFMqjnxr4U9x4eqfz9zO0tlVC/ekK6yr4taT47faah4+lOO1fxPvamiived7cNZiu/G9rSx1YbZ9f3JitVIFe7juBymKpaea72dCUW3dd+GG399faNvz7Pk/WT01NEDI2upEXEUDk7mef2rdmGXqnqU/jKvv9o92cjDLZEuKYrWVOZFWrvY5+nb82Riehem+AZdrbGk+jje/NLZSo5oq0xk4mxOeKeB+vGvlTD9oKs8JqLGF5ba6+R75l9YnhGLnNUZZj4HvJcxJSVNVXp1fZDkW/qSzc830rsao8zlS/ynSfkvet7qxtxx9bsom0Lkb2isih1Oiyrnj45PENfOtxwiZN4SGu4VuD21uii56/a2L1zWxalevkHr5jJdq+K5u6OOC0xk7OTtR7QegID7QIplV1++7M/4dFTk5Uk0l/Y18vvfO4A21ui/NbTB9e0knzA2vm9u7YyNFng3iflw3v3T86QCuv82m39l7hlAQEBlyOrGdKrj0lHZPW5qzsTK3r3lwplbPSp63uT6KriKWFre8/43z6Yjcgy2xcQGp6NGDUK5d7uRM2CurGQtsjo8El4VS9Xg6YIdrXHa7bt7Ulxfbus3rdWouZiFag+9C8XNZgplLhlIFPJ9/GNEb/dvnF2bXeSqXypRhb+ul6+N6Q6b7FeZP3ZCG78/AqJDS7jOai0xVha5du3Jb3oGvpeu/704u+ulI4XNFy0ejmu6UpwYmx2xXuukSfwfKnXw1pii6+zripL3qdLfU8qbDT8TMUoEGLBS+nnaHlPX09KeuDq199aimqvzTO3L99OkPdXSFfZ3RGnLR6irz3BtFf0YqVnzr+HF2ctSq7tTjI+N1+zhICmKrTFTHRV8OwdLZwYn2s4uVBNVzLE49UVaZG5YEJQMxG1lDFZj7HMcf4SKVd1xGmJGYR0taHsQrrC3Lz0QoYNlZkqD98ztzcOwayu96PV3de6KvNxc3GTGS8k8urOOA1SQmsIDLQLoFR2+cMvPMY9T4wgkEJ9x7Nt3vklh4ih8t4X7lxxVingwhFC8N4X7eIX//3hSrLnP/3wKeZL5WBZg4BLRtl1GZ+dZ7pQ4sTMPKeH5UvI0lXvn0I2YiwazAOal4SlszUZqszCLof/vo6GNK7rSa3+JH4eR91m35joTsoqavMld80KrN0SZXdHnGkEXVF/Jl4sWnj2QsluYLXivkyEsbGZlQ9cJWFDej+nPK+e3RKlLx1e9l3+8j0dtMZMNFUhGa59ntNhuSxBI2OwXtnf1ZFY17404rbBDKX6uEZoeE/nYiZvuKmnYRjqhRA2FtYN872YG0Wj8v4X5TzeNa5asqxCIqQzNFlgay7K9lbReFH3dcC/v7o973JIV5lbxUROxFQR3tp/t/ZnsFsXG+iGpiyqSq4pglZv3TZdVVY0zkCGl/alw4zOLBh7fi5YtXfXN56/8fg5cKlUWl0N/mPmf/+zVzDCb+hNVbz6T+tP14QBL+VwWc4Rk4saFMsue7sSHDw7zZnJvKxyuUL7AwPtPMkXy/zmp/dXvDaqInj7M7fx3q8fYrpQ4sOv3L0uLvmA1aEpgg++Yjev+5cf8dhZmcD9sR+dZGi6wPtedc0lbl3A5c7ZyTzfPjTMgyfGeWpslqGpAiMzhRVnyBQhK8n1pCx6U2F2tsXY1R6jJ2UFeZRNyK1bc6tWoIUQlUpia8H3WrTWzfCb2sqz+yvhhxolk+GLbghsNB2JUKVM/HKsRj3f251gdHa+Mnmy0kTrSopovXGWCuuMziwfjrgUA7kIh4emVz5wCdY6abxUsYULwdAUtrfKgiKNQsvWm7il0R43mSyU6K4LJVwrfntXeq4XKhnKAiIgc8hALpfQFjeX9WiuF8/cnlsxiuvqrgQhz/P0jO25it3jG0pr4XzGKEWIJfML672zNQtLr/L7LV3Fbo3S1sBr2gg/TN1v23InMjWlUmV0KfZ2Jzk+JosFXd2VWGWrAwPtvDg3lee3P/YQj3pViRQBv/+MrXzgu0cZmsrzVy+5siZJNWBjUBXBR1+zh1/6+CM8+NQ4AF87eI6XfvB7/OWLdi2bYBwQsBpKZZdD56Y5cHqC+46M8fCJMYZniuc9J1t24dREnlMTeb5fVbo7pAn2dCW5aUuaG3tT9KWtIFR6E3I+yu1y4YAbyUZ7Ni6UKzviS+6zdFkmXrCwvthyhHSV9lUYDqmwTvt5TMTu7U4yX1peqVuKwWxkVeGM1dwykFly30A2wriXu7a9NXpe5cDPh95VyGG9ON/cp0ZkIgY39qWIr+BFL3tvBSEE6bDBLQOZiqdMCLEhxpl/rpWongxqponBO7ZmF4Vum5riX9k1fddqvHnnw01b0jVFThoRNbWGuYIrERhoa+S+IyO8/QuPMeYlAmuK4E23buED3znCVL7EX73kyjVZyAHriyKkJ+1tdx/gy45cQ+ix05O86qMP8Fc/c0WwmHXAmnBdl8PnZrj3iWF+eHyUB4+PM7+CXmVqClFTJRHSiYU0ooZKPGxQKspXdr5YYnKuyNhcsRICWSiWa4y8uaLL946M8r0jowBEDYU7tua4y85xbXdy2Tj7gID1oFFI3malLR7ihj6lYeGFC+F8PAwgJxNVZePSH5YLoavOa+pNhzfUcNqsrCZn0veg+fbFxQpjvJxp9J7b25VAFTCviEroou/tuhTX2NSUVefHrZXLZwS+yIzMFPjbe4/wmUdPAzKm1VAVfu66Lj703aNYusqHXrkbuyXwnDUD73r+DjqTIf7h+8cBGJ2d57X/8iPeeFMvr7u+O8j7CVgSvyT4F35ylq8fPMt4vvHsmKEqdCZMdrTFuKYrwfW9KdpiZsMZy9WElE3NFbn/2Bj3PjnMj56SC6/OezGSU4Uyn9t/hs/tP4Mi4Mr2OC/f08G+LY1zWwIuH4SgJhH/UrKZ77X1Ns4CApbDL4BiBLrGuhLy1vY7PlWoeNeyEYNre5KVpTsuFzbvaLtBnJvK84mHTvKxB09UVgcXyApAu9vj/N/vHWNnW4z/84IdQc5Zk/HLN29he0uUt33+MYpll7ILH/zuUb528BzvfK4dhKEGVMgXy3z5sTPcvf8sj54YZ75BzKKmCPqzYV50ZRvP3dFaU6VuPYiGNO7YluWObQtlgifn5vnSY0Pcvf8Mh85Nky+WKbvw8MmJSkGclqjBK/d08JydrRtanCFgY1hq4dZLgV/KPiAgYHm6kyEUwaKF0S8WO9piK4baXS70pCyi0RBpfWHi6nJMYRFug2o+F8LQ0OSiL9xMCcnFUpkjI7M8cnKcbx0e5vtHxyiVXUKawpyXCGi3RJjIlzg1Pscr9nTwa7f2XzYhR5tJVqtlVgh+7u+/z9HRhYVWFQEv3d3BG27qWddSvhvJ5Sgr2Jh+ua7MJfuPh07ynSdHODPZOO8iHda5fTDDq67pqhRYOB/Wq0+zhSKffOQUn3nkNMfGZhcVIQlpCjdtSfHa67rZ2Ra76HlrG3UP5nKxpnAhzc+X3MvhmVur3PafnuSp0Vl2tsUqFeGahctpHAz60nxcLv2AoC/NyHLvtsCDBvzKJx7h+NgshZLLyHShkgvSEjPojJscG5sjXyyjKYLOZAjn7DRbMmE++IqruKYreUnbHrAy7QmLT7z+Ov7ph0/xN/c8SdmVxRk+/tBJPvvj07zuhm5evbdrQ6pJBVwaXNfl+Ngc3zp0jq84Qzw+NEWjwksCGMiGee7OVl5yVfu6e8kuFMvQeM213bzm2m4ATozO8Nf3Psn3jowyXSgzVyzzjceH+cbjwwhkSfYX727jRVe0EQ1dXuEfAQEBAQEBlyvNpX1cIvZ0JcjFTDQhyEUNwobKoycn+Obh4Uqip+UtVjc2M89bbu/nDbcNMjM1t/wXBzQNQgh+/rpu7tyW5W13H2D/aVmKf65Y5gPfOco/3f8UL726g5dd3bGovHXA5sN1XZ4cmeHB4+N84/FzPHxyYslSuJoi2N0R50VXtXPbYGZTGeqdqTDvfsEuAOZLZT798Cn+7UcneGpsDhc4NjbL+771JO/71pPoqmAgE+aWgQy3DWYYyEabJrepGbBtWwBfAj7uOM7/vdTtCQgICAj46SUw0IA33NTL7HyJew4P8+8PnuCRU5OVfULIajzZsM7P3rqF5+5sJaSrGJrC5neu/vTRmbD4yM9ewwPHx/jfXznEkVEpxelCiY/+4Dj/+IPj3DaY4fm72ripL3XZhK5e7pTKLofPTfPA8TG+fXiYR09OkC8tHb6dtHTuGMxwx7Yse7suj6qIuqrwsms6edk1nbiuyyMnJ/jID45x/9Ex8iWX+ZLLY2eneezsNB/+3jEEsky43RJlT1cCuyVKfyZMS8xsqlLLG4Ft2wrwPuAZwMcvcXOajog3aXGxqpUFBAQEBNTyU2ugyZCnWb504CxfcYY4MjK7aC2jqKFyx9YMd9kt3NiX+qlTWi5n9nYn+fjr93LPEyN8+LtHeOysXPjTBb55aJhvHhpGVwU396d59vYW9nYnV1VaN+Di47oupyfzPHh8jO8fGePR0xOcHJ9bdlFoTRFc2RHnht4kN/dn2JaLXNbrigkh2N2Z4C9efCUAYzPzfObRU3zlsbMcHpmhWJb3+sjMfE05f5D5mZmwIRfPTlt0JiwyEYOkpZO0NBKWTtLSL5uy0bZtdwL/DPQDYysc/lNJb9oiFtIuy0T8gICAgGbksjfQ9p+e5NjoDI8PTfGph06RL7mUym7DhWVVIdcBuXlLmtu2ZtnVFlu0SF7A5YMQglsHMtw6kOH46CyfeOgEn370NLNetc75klvJ5wFZMGJvV5J9/SmubI/TnbICo/0iUiyVOTE+x8Mnxtl/epLHh6Z5amyW8bnissYYgKEKrmyPcX1vmr3dCXa2xSplj38aSYZ1XntDD6+9oQeA0xNzfNUZ4luHhjk8PM1k1VICZReGpgsMTRd4wFvwfSl0VaCrCn0pi79/9Z7NGjK5BzgMvAz44SVuS1MihAiMs4CAgIANZNNWcXRdl3yxzFShxEyhxHShyFS+yPD0PENTeYamCgxN5fnG4+doFOmkq4K4qdGfjXDLljRPG0jTnbRWPat+uVSQqedy7Nda+uS6LgfPTvPVg2f54oGzS1b38zE1hURIoz0eYksmzLaWKHYuQlfKIhHSL6qBv9lkVfae2cm5Imcn8xwdneGpsTlOTcwxNFVgeKbA2IxcuDlft3DzcoQ0hYFsmL3dSXa0xrBbonQmQ01lPDe7rFzX5YlzM/zg2CgPn5jg8PA056YKzMyXVjSGfTQFulNhIoaKrirs7UrwC0/rW5f2bVQVR9u2jwD/a6kctJ/WKo7NTNCX5uRy6cvl0g8I+tKMbLoqjsWyy5s++SinxucolV1KrvR6Vf9eKJYbGl4+lq6Qi5pc0R4jGTboS1n0Z8PYLVG2ZCJNpbwFNA9CCOzWKHZrlF+5pZ+5+RLO2Sm+9+QI9x0d5ejILFNVa43ki2XOThU4O1WorEu15Hd7/wnvPPInKJXtcme1n8efMBA12xb2LUywLBxRf2dX+4vd2h2Nt/t/u7Wf9k/lQuW8riuP8I93qz67nlM/IU0hYWl0JkL0ZyJc2RFnSyZMd9La1IvnNgtCCAZyEQZyEV61t3ZfoVhmZKbAuekCTwxPc3homhPjecbnCuRLMJ2fRyBQFUFPymJ2vsR8ya0ssn2psW07BHQtsfuM4ziTS+xbhKoKksnzX26hWVBV5bLoBwR9aVYul75cLv2AoC+bjXX3oAUEBAQEBDQLtm3fDNyzxO7XO47zkapjj7CMBy0gICAgIGAjCKaeAwICAgIuWxzHuZfFjuWAgICAgICm5ac3az4gICAgICAgICAgIKDJCAy0gICAgICAgICAgICAJmHdQhxt2xbAl4CPLxe/b9t2Gvgg8CxgBHiH4zgfrdq/G/gAsBs4APyi4zj3r1c7V4vXn/8FvBHQgb8HfsdxnFKDYz8CvLbB1zzpOE6/d8xBYGvd/j2O4zy0nu1ejrX0yTv+Q96x1bzFcZy/9PbfgVzcdRD4AfAGx3EOXaTmL8l59OtO4H8DO4ATwHscx/n7qv2XRFa2bZvA+5HlvvPAnzuO854ljl32ObFt++XAnwAdwFeANzqOc/Zitn8p1tivVwBvB7YAh4A/cBznc94+BZgGQnUfSzmOs6HrV62xT19GLoBczYsdx/m0twIQnssAAA6ASURBVH/Tycq27W8CtzX4im84jvP0ZpLVerAWeV9KbNseAP4SuBl5/f8deJvjOHObZTz3sW371cC/1G3+jOM4L7Jtuxf4MPA04BjwVsdxvlj12abpi23brwP+YYndvcAfsAnk4j0DDwC/7jjOV71tF6TPXYqxb4l+XAP8ObAXOAd8CPg/juOUvf1NOYYv0ZffB95Vd+j7HMf5dW9/08mkUV9s2/4j4B0NDnUdx1G8zzSlXNaLdfGgeS/jv2LxhWrER4AMcmB9J/BB27b3ed8TAb4I3Id8UO4BPm/bdmw92rlG3gK8DvlCfjHwKuC3ljj2zUB71b+rgUnkA+/feP3IPlcf9+OL1vrGrKVPADu9/dVt/hCAbdvdwGeRC7xeC5wGPuPdCxvNqvtl2/ZW4G7gP5FyeifwN7Ztv8Dbfyll9V5gH3AX8AvAH9i2/coGfVj2ObFt+zrgo0ij9UYgDvzjBrR/KVbbr1uAf0IqI7uRhvanbNve4x3SD5hAH7WyWX6xrovDqvrksRN4JbVt/iJsXlkBL6G2P3cBReAvvP3NJKtV4zhO3xITjGuR9yXBtm0D+BzSgNwH/CzwIhaUtc0ynvvsRI7T1e19nTch9xlgGPCfn0/atr0FmrIv/05tHzqBB4FPOo5zjE0gF68S6r8Bu+p2fYTz1OcuxdjXqB+ekflF4FGvnW8CfgP4laqPNt0YvoxMdiL18eq2vt37TNPJZJm+/GldH/qBp/D0ao+mk8t6csEeNNu2O5GDRz+w7MyoN7v3AmCrNwP0qPcw/zLwXeAVwDzwG47jlG3bfgvwPG/7RlfV+nXkbNC3vLb/DvBupOelBsdxxqlSPGzb/mvg+47j/LW/CVl1/H7HceYvdsOXYdV98tiB9GCcbrDvjcDD/iyybdv/HfnyeDrw1fVu+AqspV+vAB5yHOdPvL8P2bZ9G1KZ+RyXSFbewPlG4AWO4zwAPGDb9nuAXwU+Vnf4Ss/Jm5Av/4943/3zwDHbtgc3euZ1jf16LbLdH/b+/ivbtp+P7NePkIPxMcdxjm5M6xuzlj7Zth1HKmTfX+I52pSychxnpOpzAqlEftT3dtIksloP1ngPX0quR3pZrnccZwo4YNv225EKzW+wecZzn53AI/XttW376chx+hZviYSf2LZ9F/A/WPBGNU1fHMeZBWb9v23b/lWgB2nsQ5PLxbbtncC/UldoZx30uQ0d+5bqB/Bcr51v9jxmB23b/nOkTvD+ZhzDl+kLeAbaEm1tKpl452jYF28Mm6o67k+Rjo/f8/5uOrmsN+sxC7MHOIy0xleaHb0BOFV3ce4FbvJ+vxH4ju9WdhzHBb5TtX9DsG27A+gGvl3Xzi5vRmu5z96EnLV8S9XmncATl9I4W2ufbNtuA9KAs8RX3lj9XY7jzCBnBZtdVh9HKlbVuCyEYl0qWe1Gehzurdp2L3Cdbdv1EykrPSf1sjkOHGWDZeOxln69H/jjum31slnqftxI1tKnncAcMgyrEZtVVtW8EtgOvK1qW7PIaj043+uy0TjAcz3FxscFzM0yntex1D10I/CjuvXr6vWIZusLAJ6n4h3AHzqOM7pJ5HIL8OUG57xQfW6jx76l+vEt4JV+Oz3q3zvNNoY37Is3WWaz/P3UTDKBpeVSwZYhzW9CGpa+btaMcllXLvjl4jjO3ciQMWzbXunwduBk3bYzLCwi2s7iG+sMMhRtI2n3fla39Yz3sws4vsxn34a02qtD4nYCJdu2v4g0aB3gtx3H+f46tXc1rLVPO5EhS39s2/ZzkHHZf+EsrBm0kiw3ijX1y3Gcg9V/27bdilQw/z9v06WSVTsw4jjOXNW2M4AB5IBTdccu95w0i2z8tqyqX47jPFz9Qdu2dwF3InMcQMomZtv2t5E5gj9C5mpstCGwFlntREYWfMwL4TwO/JHjOF+o+q5NJ6s6fh/4O8dxzlRtaxZZrQfne102FMdxhqjyqnhhcL+KDGPaLOM5UAnXHACeb9v2O5GTyZ9AGjer0SOapi91/AIyBNWPCGp6uTiO44+/9TrehepzG9q3pfrhKe7Hq/ZZSM/l3d6mphvDl5HJFiAMvNG27Y8BM8D/A/7MM8qaSiawbF+q+S1k5NMXq7Y1nVzWmxUNNC82dKkOnambxVqJMHJwqiYPGJ7lv9R+cw3nWBUr9Mtfnry6Lf7vS7bFtu0e4DnI+P9qdgAp4HeQRSneCHzdtu1djuMcWVvLl2ad+7TD+/kwMp75dmR8+bTjOJ9gk8vK+94I8CnkQ/wBb/OGyKoBS11PWNyPla79hslmFaylXxVs225B5p/cA3za27wDiCJzA6aA3wW+Ydv2Di/MeKNYS5/8Nn8WmQv0YuBztm3v84z+TS0rWy4CvR057lXTLLJaD87rHm4C/hw5yXQdcvyGJhjPV8lWpH4yDbwUaay9D4ghPRubZfyr4Ok4vwC8v8oL0DTv2fPgQvW5puubbdsqMmUngiwuAZtrDPfvpxPA84FrkM8NyDzazSiTCPBzwP+s27WZ5HJerMaDdi1SSWrE65FJoqtljsUXxwRmHcdxbdteav/MGs6xWpbr129XnXu+6ndWaMvLgEMNvC2vBizHcSYAbNv+ZWRS7c8jE2vXi/Xs098C/1aVa/KILQts/BJyJnMpWQ2fR7tXYt1lZdt2AjlD1g/c7IWOwMbJqp6lrics7sdKz8lGPkcrsZZ+AWDbdhcy5KEEvLQq9OQWQHUcZ9o77tXIWbMXsrHJv2vp0+8C73IWKhc+bNv2XqSi9v1lvmtTyAqZu/B1x3GeqtveLLJaD87nulwyPOX4L5G5QC91HGe/bds/oXnG8xXx2px1HMc//8Nev/4NWb0xUfeR1Yx/l6QvVVyDNDT/qWpbM71n18qF6nPNNPb5Xtt/BZ4J3FWV17RpxnDHcT5f99w8att2FjlR9l42l+7g82xkftqn67ZvGrmcLysaaI7j3EvjRMTz4QTQVretjYUQkZX2rxvL9cvLa3qPd24/vtpv13JteQ7SI1N/rnkWjAe8wesxZILjurGeffJik0fqNh9ADl6wtKzWvdrhesvKG7C+DLQCtzuOc7jqXBsiqwacAFK2bRuO4xS8bW3IGZ96OTTNc7QK1tIvbNvuB76GHETvqHrRUBdihiNLhz/JxZdNPavukyOXeqgvnnQAmdfkf9emlJXHc5Av/hqaSFbrwflcl0uCF9b498gCB69wHOcz0Fzj+WqpfvY9DiCXUTnJwvPjs5rx75L1xeM5yIIGlbCrzSiXKi70PdQ0Y58X1vifyPykZ1dPsm+yMXyp56bD+33TyKSK5wCfdxynxhu22eRyPmx02dn7gE7btvuqtt3sbff37/NmyvyZwH1V+zcEbwA95rWtup0nvXjlRXhtvR6ZcFq/7we2rCzo/60AVwGPrWe7l2OtfbJt+89s2767bvMeFtp8X/V32bYd9vY3tay8WbK7gSxwa31OzCWU1UNAgdrw2JuBBxzHKdYdu9JzUi+bbmTVsA2Vjceq+2XLcsdfQRYbuq06p8m2bc227RN2VWlz27ajyFCoDXuOPNbSp/+wbftv6z6/3HO0KWQFlYmOAerGvCaT1XqwputyifkzZBTASxzHqUwWbpbxvOr8L7Ft+4w3XvvsQSpk9wFXe6FPPvV6RNP0pYobWfysbCq51HGh+lwzjX3/gix6cpfjON+p3rGZxnDbtt9s2/YjdZv9XHrYXDLxWfTcwOaSy/ly0StQeUpXyXGcccdxnrBt+0vAP9qy1Oxe5EzfHd7h/4Esjf5+78K/Ebl2waUoZfx3wLtt2z6GDLV6NwuxvNi2nUO68v2KWb3I+Pj9Db7rbuC3bNt+FFnx8q3Iyk3/7+I1vyFr6dNnkblXvwZ8Hulm/nlk0QaQbf8t27bfhpx5ejvSUPraBvWlmrX06y3I++7ZwLQtq2gBFLwwk0siK8dxZmzb/ijwt7Zc2LQN+E28uGuvneOOLNm80nPyd8C3bNv+DnIweh/wRcdxHr+YfWjEGvv1LqTh/DOAViWbWcdxxr2x4122bZ9Ezjq/Czkb9jk2kDX26bPAh2zbvhe4H3gN8qXxi97XbVZZAVyB9DYfrPueYrPIaj1Y6bo0C7Zt34hccuT3gB9WPT+wucZzkAqZQD47f4I07t/r/fsmshrbR2y5mO3zkUrc//A+22x98bkCuSZaNZtNLhXWQZ9rirHPtu1XIPOXXgMcr3puSl7hnU0zhgP/hdSF3o30pF+PzKf327opZOJjyyq5No316s0kl/NiIzxon6JKWUYOPmPIGNE/BN7gOM73ALy8n+chLfoHkbk/z11jIZL14r3IeORPev/+Dblwns/9yJe0T6v3s1HIy7uAv0EWongI2AbceQmS5VfdJ0euKfYqpBKyHxnD/Cov3BCvYMZLkMmbP0T2/4VObanajWItsnoZcmLiq0iF0f/3WW//pZTVW722ft07/zsdx/Ff6KeQ+T4rPife8/RG5JpA30N6pF67Ae1filX1CymbOLLiX7Vs/sbb/ybgC0glxw9BefYl8mKsVlb/iLz33olcCPW5wLP8sNpNLCuQz/z4Es98M8lqPVjuujQLL/V+vpva5+cUspT2ZhnP/TCtZyEnPh9ELtz8AeDdXmjTC4EW4AGkTvFirw9N15cqWlkcAr2Z3rONOG99ronGvpd5P/+Z2mfmR7C5xnAvIugFyDX2HkEu0vw7juP8q7d/s8jEJ4PU1xbp1ZtJLueLcF33UrchICAgICAgICAgICAggI3PQQsICAgICAgICAgICAhYgsBACwgICAgICAgICAgIaBICAy0gICAgICAgICAgIKBJCAy0gICAgICAgICAgICAJiEw0AICAgICAgICAgICApqEwEALCAgICAgICAgICAhoEgIDLSAgICAgICAgICAgoEkIDLSAgICAgICAgICAgIAmITDQAgICAgICAgICAgICmoT/HxxhKrV/SR6nAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/pymc3/__init__.py b/pymc3/__init__.py index efba6561f34..0e476578ee6 100644 --- a/pymc3/__init__.py +++ b/pymc3/__init__.py @@ -11,6 +11,7 @@ from .stats import * from .sampling import * from .step_methods import * +from .smc import * from .theanof import * from .tuning import * from .variational import * diff --git a/pymc3/parallel_sampling.py b/pymc3/parallel_sampling.py index 6ed241c20ae..5b50d5dc498 100644 --- a/pymc3/parallel_sampling.py +++ b/pymc3/parallel_sampling.py @@ -425,3 +425,22 @@ def __exit__(self, *args): ProcessAdapter.terminate_all(self._samplers) if self._progress is not None: self._progress.close() + +def _cpu_count(): + """Try to guess the number of CPUs in the system. + + We use the number provided by psutil if that is installed. + If not, we use the number provided by multiprocessing, but assume + that half of the cpus are only hardware threads and ignore those. + """ + try: + import psutil + cpus = psutil.cpu_count(False) + except ImportError: + try: + cpus = multiprocessing.cpu_count() // 2 + except NotImplementedError: + cpus = 1 + if cpus is None: + cpus = 1 + return cpus diff --git a/pymc3/sampling.py b/pymc3/sampling.py index 34479902cf0..e9900295778 100644 --- a/pymc3/sampling.py +++ b/pymc3/sampling.py @@ -19,10 +19,11 @@ from .model import modelcontext, Point, all_continuous, Model from .step_methods import (NUTS, HamiltonianMC, Metropolis, BinaryMetropolis, BinaryGibbsMetropolis, CategoricalGibbsMetropolis, - Slice, CompoundStep, arraystep, smc) + Slice, CompoundStep, arraystep) from .util import update_start_vals, get_untransformed_name, is_transformed_name, get_default_varnames from .vartypes import discrete_types from .exceptions import IncorrectArgumentsError +from .parallel_sampling import _cpu_count from pymc3.step_methods.hmc import quadpotential import pymc3 as pm from tqdm import tqdm @@ -172,27 +173,6 @@ def _print_step_hierarchy(s, level=0): _log.info('>' * level + '{}: [{}]'.format(s.__class__.__name__, varnames)) -def _cpu_count(): - """Try to guess the number of CPUs in the system. - - We use the number provided by psutil if that is installed. - If not, we use the number provided by multiprocessing, but assume - that half of the cpus are only hardware threads and ignore those. - """ - try: - import psutil - cpus = psutil.cpu_count(False) - except ImportError: - import multiprocessing - try: - cpus = multiprocessing.cpu_count() // 2 - except NotImplementedError: - cpus = 1 - if cpus is None: - cpus = 1 - return cpus - - def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=None, chain_idx=0, chains=None, cores=None, tune=500, progressbar=True, model=None, random_seed=None, discard_tuned_samples=True, @@ -236,33 +216,28 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N Starting point in parameter space (or partial point) Defaults to ``trace.point(-1))`` if there is a trace provided and model.test_point if not (defaults to empty dict). Initialization methods for NUTS (see ``init`` keyword) can - overwrite the default. For 'SMC' step method, ``start`` should be a list of dicts - of length = ``chains``. + overwrite the default. trace : backend, list, or MultiTrace This should be a backend instance, a list of variables to track, or a MultiTrace object with past values. If a MultiTrace object is given, it must contain samples for the chain number ``chain``. If None or a list of variables, the NDArray backend is used. Passing either "text" or "sqlite" is taken as a shortcut to set up the corresponding - backend (with "mcmc" used as the base name). Ignored when using 'SMC' as step method. + backend (with "mcmc" used as the base name). chain_idx : int Chain number used to store sample in backend. If ``chains`` is greater than one, chain - numbers will start here. Ignored when using 'SMC' as step method. + numbers will start here. chains : int The number of chains to sample. Running independent chains is important for some convergence statistics and can also reveal multiple modes in the posterior. If ``None``, - then set to either ``cores`` or 2, whichever is larger. For SMC the number of chains is the - number of draws. + then set to either ``cores`` or 2, whichever is larger. cores : int The number of chains to run in parallel. If ``None``, set to the number of CPUs in the - system, but at most 4. When using 'SMC', this parameter will be ignored if running with - ``pm.SMC(parallel=False)``. Keep in mind that - some chains might themselves be multithreaded via openmp or BLAS. In those cases it might - be faster to set this to 1. + system, but at most 4. tune : int - Number of iterations to tune, defaults to 500. Ignored when using 'SMC'. Samplers adjust - the step sizes, scalings or similar during tuning. Tuning samples will be drawn in addition - to the number specified in the ``draws`` argument, and will be discarded unless - ``discard_tuned_samples`` is set to False. + Number of iterations to tune, defaults to 500. Samplers adjust the step sizes, scalings or + similar during tuning. Tuning samples will be drawn in addition to the number specified in + the ``draws`` argument, and will be discarded unless ``discard_tuned_samples`` is set to + False. progressbar : bool Whether or not to display a progress bar in the command line. The bar shows the percentage of completion, the sampling speed in samples per second (SPS), and the estimated remaining @@ -271,10 +246,9 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N random_seed : int or list of ints A list is accepted if ``cores`` is greater than one. discard_tuned_samples : bool - Whether to discard posterior samples of the tune interval. Ignored when using 'SMC' + Whether to discard posterior samples of the tune interval. compute_convergence_checks : bool, default=True Whether to compute sampler statistics like Gelman-Rubin and ``effective_n``. - Ignored when using 'SMC' Returns ------- @@ -334,142 +308,134 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N if cores is None: cores = min(4, _cpu_count()) - if isinstance(step, pm.step_methods.smc.SMC): - trace = smc.sample_smc(draws=draws, - step=step, - start=start, - cores=cores, - progressbar=progressbar, - model=model, - random_seed=random_seed) - else: - if 'njobs' in kwargs: - cores = kwargs['njobs'] - warnings.warn( - "The njobs argument has been deprecated. Use cores instead.", - DeprecationWarning) - if 'nchains' in kwargs: - chains = kwargs['nchains'] - warnings.warn( - "The nchains argument has been deprecated. Use chains instead.", - DeprecationWarning) - if chains is None: - chains = max(2, cores) - if isinstance(start, dict): - start = [start] * chains - if random_seed == -1: - random_seed = None - if chains == 1 and isinstance(random_seed, int): - random_seed = [random_seed] - if random_seed is None or isinstance(random_seed, int): - if random_seed is not None: - np.random.seed(random_seed) - random_seed = [np.random.randint(2 ** 30) for _ in range(chains)] - if not isinstance(random_seed, Iterable): - raise TypeError( - 'Invalid value for `random_seed`. Must be tuple, list or int') - if 'chain' in kwargs: - chain_idx = kwargs['chain'] - warnings.warn( - "The chain argument has been deprecated. Use chain_idx instead.", - DeprecationWarning) - - if start is not None: - for start_vals in start: - _check_start_shape(model, start_vals) - - # small trace warning - if draws == 0: - msg = "Tuning was enabled throughout the whole trace." - _log.warning(msg) - elif draws < 500: - msg = "Only %s samples in chain." % draws - _log.warning(msg) - - draws += tune - - if model.ndim == 0: - raise ValueError('The model does not contain any free variables.') - - if step is None and init is not None and all_continuous(model.vars): - try: - # By default, try to use NUTS - _log.info('Auto-assigning NUTS sampler...') - start_, step = init_nuts(init=init, chains=chains, n_init=n_init, - model=model, random_seed=random_seed, - progressbar=progressbar, **kwargs) - if start is None: - start = start_ - except (AttributeError, NotImplementedError, tg.NullTypeGradError): - # gradient computation failed - _log.info("Initializing NUTS failed. " - "Falling back to elementwise auto-assignment.") - _log.debug('Exception in init nuts', exec_info=True) - step = assign_step_methods(model, step, step_kwargs=kwargs) - else: + + if 'njobs' in kwargs: + cores = kwargs['njobs'] + warnings.warn( + "The njobs argument has been deprecated. Use cores instead.", + DeprecationWarning) + if 'nchains' in kwargs: + chains = kwargs['nchains'] + warnings.warn( + "The nchains argument has been deprecated. Use chains instead.", + DeprecationWarning) + if chains is None: + chains = max(2, cores) + if isinstance(start, dict): + start = [start] * chains + if random_seed == -1: + random_seed = None + if chains == 1 and isinstance(random_seed, int): + random_seed = [random_seed] + if random_seed is None or isinstance(random_seed, int): + if random_seed is not None: + np.random.seed(random_seed) + random_seed = [np.random.randint(2 ** 30) for _ in range(chains)] + if not isinstance(random_seed, Iterable): + raise TypeError( + 'Invalid value for `random_seed`. Must be tuple, list or int') + if 'chain' in kwargs: + chain_idx = kwargs['chain'] + warnings.warn( + "The chain argument has been deprecated. Use chain_idx instead.", + DeprecationWarning) + + if start is not None: + for start_vals in start: + _check_start_shape(model, start_vals) + + # small trace warning + if draws == 0: + msg = "Tuning was enabled throughout the whole trace." + _log.warning(msg) + elif draws < 500: + msg = "Only %s samples in chain." % draws + _log.warning(msg) + + draws += tune + + if model.ndim == 0: + raise ValueError('The model does not contain any free variables.') + + if step is None and init is not None and all_continuous(model.vars): + try: + # By default, try to use NUTS + _log.info('Auto-assigning NUTS sampler...') + start_, step = init_nuts(init=init, chains=chains, n_init=n_init, + model=model, random_seed=random_seed, + progressbar=progressbar, **kwargs) + if start is None: + start = start_ + except (AttributeError, NotImplementedError, tg.NullTypeGradError): + # gradient computation failed + _log.info("Initializing NUTS failed. " + "Falling back to elementwise auto-assignment.") + _log.debug('Exception in init nuts', exec_info=True) step = assign_step_methods(model, step, step_kwargs=kwargs) + else: + step = assign_step_methods(model, step, step_kwargs=kwargs) - if isinstance(step, list): - step = CompoundStep(step) - if start is None: - start = {} - if isinstance(start, dict): - start = [start] * chains - - sample_args = {'draws': draws, - 'step': step, - 'start': start, - 'trace': trace, - 'chain': chain_idx, - 'chains': chains, - 'tune': tune, - 'progressbar': progressbar, - 'model': model, - 'random_seed': random_seed, - 'cores': cores, } - - sample_args.update(kwargs) - - has_population_samplers = np.any([isinstance(m, arraystep.PopulationArrayStepShared) - for m in (step.methods if isinstance(step, CompoundStep) else [step])]) - - parallel = cores > 1 and chains > 1 and not has_population_samplers - if parallel: - _log.info('Multiprocess sampling ({} chains in {} jobs)'.format(chains, cores)) - _print_step_hierarchy(step) - try: - trace = _mp_sample(**sample_args) - except pickle.PickleError: + if isinstance(step, list): + step = CompoundStep(step) + if start is None: + start = {} + if isinstance(start, dict): + start = [start] * chains + + sample_args = {'draws': draws, + 'step': step, + 'start': start, + 'trace': trace, + 'chain': chain_idx, + 'chains': chains, + 'tune': tune, + 'progressbar': progressbar, + 'model': model, + 'random_seed': random_seed, + 'cores': cores, } + + sample_args.update(kwargs) + + has_population_samplers = np.any([isinstance(m, arraystep.PopulationArrayStepShared) + for m in (step.methods if isinstance(step, CompoundStep) else [step])]) + + parallel = cores > 1 and chains > 1 and not has_population_samplers + if parallel: + _log.info('Multiprocess sampling ({} chains in {} jobs)'.format(chains, cores)) + _print_step_hierarchy(step) + try: + trace = _mp_sample(**sample_args) + except pickle.PickleError: + _log.warning("Could not pickle model, sampling singlethreaded.") + _log.debug('Pickling error:', exec_info=True) + parallel = False + except AttributeError as e: + if str(e).startswith("AttributeError: Can't pickle"): _log.warning("Could not pickle model, sampling singlethreaded.") _log.debug('Pickling error:', exec_info=True) parallel = False - except AttributeError as e: - if str(e).startswith("AttributeError: Can't pickle"): - _log.warning("Could not pickle model, sampling singlethreaded.") - _log.debug('Pickling error:', exec_info=True) - parallel = False - else: - raise - if not parallel: - if has_population_samplers: - _log.info('Population sampling ({} chains)'.format(chains)) - _print_step_hierarchy(step) - trace = _sample_population(**sample_args, parallelize=cores > 1) else: - _log.info('Sequential sampling ({} chains in 1 job)'.format(chains)) - _print_step_hierarchy(step) - trace = _sample_many(**sample_args) + raise + if not parallel: + if has_population_samplers: + _log.info('Population sampling ({} chains)'.format(chains)) + _print_step_hierarchy(step) + trace = _sample_population(**sample_args, parallelize=cores > 1) + else: + _log.info('Sequential sampling ({} chains in 1 job)'.format(chains)) + _print_step_hierarchy(step) + trace = _sample_many(**sample_args) - discard = tune if discard_tuned_samples else 0 - trace = trace[discard:] + discard = tune if discard_tuned_samples else 0 + trace = trace[discard:] - if compute_convergence_checks: - if draws-tune < 100: - warnings.warn("The number of samples is too small to check convergence reliably.") - else: - trace.report._run_convergence_checks(trace, model) + if compute_convergence_checks: + if draws-tune < 100: + warnings.warn("The number of samples is too small to check convergence reliably.") + else: + trace.report._run_convergence_checks(trace, model) - trace.report._log_summary() + trace.report._log_summary() return trace diff --git a/pymc3/smc/__init__.py b/pymc3/smc/__init__.py new file mode 100644 index 00000000000..cfd65955857 --- /dev/null +++ b/pymc3/smc/__init__.py @@ -0,0 +1 @@ +from .smc import sample_smc diff --git a/pymc3/step_methods/smc.py b/pymc3/smc/smc.py similarity index 62% rename from pymc3/step_methods/smc.py rename to pymc3/smc/smc.py index 056132f5a19..72478a5cec3 100644 --- a/pymc3/step_methods/smc.py +++ b/pymc3/smc/smc.py @@ -7,7 +7,7 @@ import multiprocessing as mp import warnings -from .metropolis import MultivariateNormalProposal +from ..step_methods.metropolis import MultivariateNormalProposal from .smc_utils import ( _initial_population, _calc_covariance, @@ -20,6 +20,7 @@ ) from ..theanof import inputvars, make_shared_replacements from ..model import modelcontext +from ..parallel_sampling import _cpu_count EXPERIMENTAL_WARNING = ( @@ -27,47 +28,88 @@ " recommended for use in PyMC3!" ) -__all__ = ["SMC", "sample_smc"] +__all__ = ["sample_smc"] -class SMC: - r""" - Sequential Monte Carlo step +def sample_smc( + draws=1000, + kernel="metropolis", + n_steps=25, + parallel=False, + start=None, + cores=None, + tune_scaling=True, + tune_steps=True, + scaling=1.0, + p_acc_rate=0.99, + threshold=0.5, + epsilon=1.0, + dist_func="absolute_error", + sum_stat=False, + progressbar=False, + model=None, + random_seed=-1, +): + """ + Sequential Monte Carlo based sampling Parameters ---------- + draws : int + The number of samples to draw from the posterior (i.e. last stage). And also the number of + independent chains. Defaults to 1000. + kernel : str + Kernel method for the SMC sampler. Available option are ``metropolis`` (default) and `ABC`. + Use `ABC` for likelihood free inference togheter with a ``pm.Simulator``. n_steps : int - The number of steps of a Markov Chain. If `tune_steps == True` `n_steps` will be used for - the first stage and the number of steps of the other stages will be determined - automatically based on the acceptance rate and `p_acc_rate`. - The number of steps will never be larger than `n_steps`. - scaling : float - Factor applied to the proposal distribution i.e. the step size of the Markov Chain. Only - works if `tune_scaling == False` otherwise is determined automatically. - p_acc_rate : float - Used to compute `n_steps` when `tune_steps == True`. The higher the value of `p_acc_rate` - the higher the number of steps computed automatically. Defaults to 0.99. It should be - between 0 and 1. + The number of steps of each Markov Chain. If ``tune_steps == True`` ``n_steps`` will be used + for the first stage and for the others it will be determined automatically based on the + acceptance rate and `p_acc_rate`, the max number of steps is ``n_steps``. + parallel : bool + Distribute computations across cores if the number of cores is larger than 1. + Defaults to False. + start : dict, or array of dict + Starting point in parameter space. It should be a list of dict with length `chains`. + When None (default) the starting point is sampled from the prior distribution. + cores : int + The number of chains to run in parallel. If ``None`` (default), it will be automatically + set to the number of CPUs in the system. tune_scaling : bool - Whether to compute the scaling automatically or not. Defaults to True + Whether to compute the scaling factor automatically or not. Defaults to True tune_steps : bool Whether to compute the number of steps automatically or not. Defaults to True + scaling : float + Scaling factor applied to the proposal distribution i.e. the step size of the Markov Chain. + If ``tune_scaling == True`` (defaults) it will be determined automatically at each stage. + p_acc_rate : float + Used to compute ``n_steps`` when ``tune_steps == True``. The higher the value of + ``p_acc_rate`` the higher the number of steps computed automatically. Defaults to 0.99. + It should be between 0 and 1. threshold : float Determines the change of beta from stage to stage, i.e.indirectly the number of stages, the higher the value of `threshold` the higher the number of stages. Defaults to 0.5. It should be between 0 and 1. - parallel : bool - Distribute computations across cores if the number of cores is larger than 1 - (see `pm.sample()` for details). Defaults to True. - model : :class:`pymc3.Model` - Optional model for sampling step. Defaults to None (taken from context). + epsilon : float + Standard deviation of the gaussian pseudo likelihood. Only works with `kernel = ABC` + dist_func : str + Distance function. Available options are ``absolute_error`` (default) and + ``sum_of_squared_distance``. Only works with ``kernel = ABC`` + sum_stat : bool + Whether to use or not a summary statistics. Defaults to False. Only works with + ``kernel = ABC`` + progressbar : bool + Flag for displaying a progress bar. Defaults to False. + model : Model (optional if in ``with`` context)). + random_seed : int + random seed Notes ----- - SMC works by moving through successive stages. At each stage the inverse temperature \beta is - increased a little bit (starting from 0 up to 1). When \beta = 0 we have the prior distribution - and when \beta =1 we have the posterior distribution. So in more general terms we are always - computing samples from a tempered posterior that we can write as: + SMC works by moving through successive stages. At each stage the inverse temperature + :math:`\beta` is increased a little bit (starting from 0 up to 1). When :math:`\beta` = 0 + we have the prior distribution and when :math:`\beta` =1 we have the posterior distribution. + So in more general terms we are always computing samples from a tempered posterior that we can + write as: .. math:: @@ -76,10 +118,10 @@ class SMC: A summary of the algorithm is: 1. Initialize :math:`\beta` at zero and stage at zero. - 2. Generate N samples :math:`S_{\beta}` from the prior (because when :math `\beta = 0` the tempered posterior - is the prior). - 3. Increase :math:`\beta` in order to make the effective sample size equals some predefined value - (we use :math:`Nt`, where :math:`t` is 0.5 by default). + 2. Generate N samples :math:`S_{\beta}` from the prior (because when :math `\beta = 0` the + tempered posterior is the prior). + 3. Increase :math:`\beta` in order to make the effective sample size equals some predefined + value (we use :math:`Nt`, where :math:`t` is 0.5 by default). 4. Compute a set of N importance weights W. The weights are computed as the ratio of the likelihoods of a sample at stage i+1 and stage i. 5. Obtain :math:`S_{w}` by re-sampling according to W. @@ -106,69 +148,20 @@ class SMC: %282007%29133:7%28816%29>`__ """ - def __init__( - self, - n_steps=25, - scaling=1.0, - p_acc_rate=0.99, - tune_scaling=True, - tune_steps=True, - threshold=0.5, - parallel=True, - ABC=False, - epsilon=1, - dist_func="absolute_error", - sum_stat=False, - ): - - self.n_steps = n_steps - self.max_steps = n_steps - self.scaling = scaling - self.p_acc_rate = 1 - p_acc_rate - self.tune_scaling = tune_scaling - self.tune_steps = tune_steps - self.threshold = threshold - self.parallel = parallel - self.ABC = ABC - self.epsilon = epsilon - self.dist_func = dist_func - self.sum_stat = sum_stat - - -def sample_smc( - draws=5000, step=None, start=None, cores=None, progressbar=False, model=None, random_seed=-1 -): - """ - Sequential Monte Carlo sampling - - Parameters - ---------- - draws : int - The number of samples to draw from the posterior (i.e. last stage). And also the number of - independent Markov Chains. Defaults to 5000. - step : :class:`SMC` - SMC initialization object - start : dict, or array of dict - Starting point in parameter space. It should be a list of dict with length `chains`. - cores : int - The number of chains to run in parallel. - progressbar : bool - Flag for displaying a progress bar - model : pymc3 Model - optional if in `with` context - random_seed : int - random seed - """ model = modelcontext(model) if random_seed != -1: np.random.seed(random_seed) + if cores is None: + cores = _cpu_count() + beta = 0 stage = 0 accepted = 0 acc_rate = 1.0 - proposed = draws * step.n_steps + max_steps = n_steps + proposed = draws * n_steps model.marginal_likelihood = 1 variables = inputvars(model.vars) discrete = np.concatenate([[v.dtype in pm.discrete_types] * (v.dsize or 1) for v in variables]) @@ -181,33 +174,29 @@ def sample_smc( posterior, var_info = _initial_population(draws, model, variables, start) - if step.ABC: + if kernel.lower() == "abc": warnings.warn(EXPERIMENTAL_WARNING) simulator = model.observed_RVs[0] likelihood_logp = PseudoLikelihood( - step.epsilon, + epsilon, simulator.observations, simulator.distribution.function, model, var_info, - step.dist_func, - step.sum_stat, + dist_func, + sum_stat, ) - else: + elif kernel.lower() == "metropolis": likelihood_logp = logp_forw([model.datalogpt], variables, shared) while beta < 1: - - if step.parallel and cores > 1: + if parallel and cores > 1: pool = mp.Pool(processes=cores) - results = pool.starmap( - likelihood_logp, - [(sample,) for sample in posterior], - ) + results = pool.starmap(likelihood_logp, [(sample,) for sample in posterior]) else: results = [likelihood_logp(sample) for sample in posterior] likelihoods = np.array(results).squeeze() - beta, old_beta, weights, sj = calc_beta(beta, likelihoods, step.threshold) + beta, old_beta, weights, sj = calc_beta(beta, likelihoods, threshold) model.marginal_likelihood *= sj # resample based on plausibility weights (selection) resampling_indexes = np.random.choice(np.arange(draws), size=draws, p=weights) @@ -220,31 +209,39 @@ def sample_smc( # compute scaling (optional) and number of Markov chains steps (optional), based on the # acceptance rate of the previous stage - if (step.tune_scaling or step.tune_steps) and stage > 0: - _tune(acc_rate, proposed, step) + if (tune_scaling or tune_steps) and stage > 0: + scaling, n_steps = _tune( + acc_rate, + proposed, + tune_scaling, + tune_steps, + scaling, + n_steps, + max_steps, + p_acc_rate, + ) - pm._log.info("Stage: {:d} Beta: {:.3f} Steps: {:d}".format(stage, beta, step.n_steps)) + pm._log.info("Stage: {:d} Beta: {:.3f} Steps: {:d}".format(stage, beta, n_steps)) # Apply Metropolis kernel (mutation) - proposed = draws * step.n_steps + proposed = draws * n_steps priors = np.array([prior_logp(sample) for sample in posterior]).squeeze() tempered_logp = priors + likelihoods * beta - deltas = np.squeeze(proposal(step.n_steps) * step.scaling) + deltas = np.squeeze(proposal(n_steps) * scaling) parameters = ( proposal, - step.scaling, + scaling, accepted, any_discrete, all_discrete, discrete, - step.n_steps, + n_steps, prior_logp, likelihood_logp, beta, - step.ABC, ) - if step.parallel and cores > 1: + if parallel and cores > 1: pool = mp.Pool(processes=cores) results = pool.starmap( metrop_kernel, diff --git a/pymc3/step_methods/smc_utils.py b/pymc3/smc/smc_utils.py similarity index 94% rename from pymc3/step_methods/smc_utils.py rename to pymc3/smc/smc_utils.py index 9e5bea1c7bc..7d4e3c58930 100644 --- a/pymc3/step_methods/smc_utils.py +++ b/pymc3/smc/smc_utils.py @@ -5,7 +5,7 @@ import numpy as np import pymc3 as pm import theano -from .arraystep import metrop_select +from ..step_methods.arraystep import metrop_select from ..backends.ndarray import NDArray from ..backends.base import MultiTrace from ..theanof import floatX, join_nonshared_inputs @@ -51,7 +51,7 @@ def _calc_covariance(posterior, weights): return cov -def _tune(acc_rate, proposed, step): +def _tune(acc_rate, proposed, tune_scaling, tune_steps, scaling, n_steps, max_steps, p_acc_rate): """ Tune scaling and/or n_steps based on the acceptance rate. @@ -63,14 +63,17 @@ def _tune(acc_rate, proposed, step): Total number of proposed steps (draws * n_steps) step: SMC step method """ - if step.tune_scaling: + if tune_scaling: # a and b after Muto & Beck 2008. a = 1 / 9 b = 8 / 9 - step.scaling = (a + b * acc_rate) ** 2 - if step.tune_steps: + scaling = (a + b * acc_rate) ** 2 + + if tune_steps: acc_rate = max(1.0 / proposed, acc_rate) - step.n_steps = min(step.max_steps, 1 + int(np.log(step.p_acc_rate) / np.log(1 - acc_rate))) + n_steps = min(max_steps, max(2, int(np.log(1 - p_acc_rate) / np.log(1 - acc_rate)))) + + return scaling, n_steps def _posterior_to_trace(posterior, variables, model, var_info): @@ -107,7 +110,6 @@ def metrop_kernel( prior_logp, likelihood_logp, beta, - ABC, ): """ Metropolis kernel @@ -275,13 +277,6 @@ def sum_of_squared_distance(self, a, b): return np.mean(np.sum(np.atleast_2d((a - b) ** 2))) def __call__(self, posterior): - """ - a : array - vector of (simulated) data or summary statistics - b : array - vector of (observed) data or sumary statistics - epsilon : - """ func_parameters = self.posterior_to_function(posterior) sim_data = self.function(**func_parameters) value = self.dist_func(self.observations, sim_data) diff --git a/pymc3/step_methods/__init__.py b/pymc3/step_methods/__init__.py index aa734cbf88d..e72c2b5131a 100644 --- a/pymc3/step_methods/__init__.py +++ b/pymc3/step_methods/__init__.py @@ -18,5 +18,3 @@ from .slicer import Slice from .elliptical_slice import EllipticalSlice - -from .smc import SMC diff --git a/pymc3/tests/test_smc.py b/pymc3/tests/test_smc.py index ad2da4915c1..16b5d1fb8e2 100644 --- a/pymc3/tests/test_smc.py +++ b/pymc3/tests/test_smc.py @@ -42,7 +42,7 @@ def two_gaussians(x): def test_sample(self): with self.SMC_test: - mtrace = pm.sample(draws=self.samples, step=pm.SMC()) + mtrace = pm.sample_smc(draws=self.samples) x = mtrace["X"] mu1d = np.abs(x).mean(axis=0) @@ -53,7 +53,7 @@ def test_discrete_continuous(self): a = pm.Poisson("a", 5) b = pm.HalfNormal("b", 10) y = pm.Normal("y", a, b, observed=[1, 2, 3, 4]) - trace = pm.sample(step=pm.SMC()) + trace = pm.sample_smc() def test_ml(self): data = np.repeat([1, 0], [50, 50]) @@ -65,7 +65,7 @@ def test_ml(self): with pm.Model() as model: a = pm.Beta("a", alpha, beta) y = pm.Bernoulli("y", a, observed=data) - trace = pm.sample(2000, step=pm.SMC()) + trace = pm.sample_smc(2000) marginals.append(model.marginal_likelihood) # compare to the analytical result assert abs((marginals[1] / marginals[0]) - 4.0) <= 1 @@ -79,4 +79,4 @@ def test_start(self): "a": np.random.poisson(5, size=500), "b_log__": np.abs(np.random.normal(0, 10, size=500)), } - trace = pm.sample(500, start=start, step=pm.SMC()) + trace = pm.sample_smc(500, start=start) diff --git a/pymc3/tests/test_step.py b/pymc3/tests/test_step.py index e96a4c0de8d..feacd9ce547 100644 --- a/pymc3/tests/test_step.py +++ b/pymc3/tests/test_step.py @@ -25,7 +25,6 @@ MultivariateNormalProposal, HamiltonianMC, EllipticalSlice, - SMC, DEMetropolis, ) from pymc3.theanof import floatX @@ -458,210 +457,6 @@ class TestStepMethods: # yield test doesn't work subclassing object -0.22032854, ] ), - SMC: np.array( - [ - 0.85565848, - -0.2070422, - 0.60432617, - 0.82409693, - 0.66956559, - 1.81128223, - 0.5099755, - 0.0119065, - 0.11877237, - 1.04616407, - 0.35541975, - 0.97711646, - 1.08273746, - 0.12254112, - -0.21257513, - 1.90683915, - 0.76584417, - 1.61601906, - 1.26496997, - 0.72605814, - 0.27710155, - 0.59465936, - 1.48848202, - 1.48383457, - 0.85487729, - 0.40339297, - 1.11378062, - -0.01154052, - -0.24933346, - 0.04855092, - 0.44408811, - 1.07009768, - 0.71832534, - -0.02224531, - 0.15732427, - 0.7473228, - -0.55976844, - 1.83476852, - 1.13464918, - 1.04477006, - -0.8829072, - 0.68610441, - -0.51600679, - 1.06577287, - 0.72533541, - 0.26181682, - 0.37045784, - 0.49110896, - 0.95187099, - 0.57052884, - 1.18390954, - -0.28471075, - 0.51430074, - 0.36340121, - 0.26524266, - 0.91352896, - -0.16906962, - 0.02671763, - -0.62019011, - 0.13845477, - 0.69578153, - 0.82213032, - 0.95565471, - 0.57200968, - 0.66751333, - 0.74663059, - -0.18802928, - -0.16424154, - 0.67661238, - 0.9861513, - 1.11037445, - 0.53367436, - 0.81646116, - 0.690932, - 1.30967756, - 0.58455721, - -0.10754287, - -0.6684397, - 0.61473599, - 0.11205459, - 1.50795626, - 1.61304945, - 0.97329075, - 0.80782601, - 1.83144756, - 0.34256431, - 0.4909023, - 1.85297991, - 0.44832968, - 1.35766865, - 0.48916414, - 0.41003811, - -0.69870992, - 0.06616797, - -0.17685457, - -0.04873934, - 1.92862499, - 0.47539711, - 1.19401841, - 0.36708951, - 2.11504567, - 1.1686311, - 0.74908099, - 0.90147251, - 0.6291452, - 0.96889866, - 0.93871978, - 0.74575847, - 0.06810142, - 0.45469276, - 0.2978768, - 0.73557954, - -0.33888277, - -0.09913398, - 1.12325616, - 0.87397745, - -1.14737571, - -0.78658184, - 0.67716005, - 0.20961373, - 0.11759896, - 0.72748602, - -0.29959812, - -0.09436507, - 0.42100139, - 0.0465658, - 1.21211627, - 0.0406079, - 1.38031654, - 0.58429982, - 0.33843332, - 0.82207419, - 0.9650973, - 1.00370894, - 1.23735049, - -0.01960991, - 0.77210838, - 0.04627416, - -0.62058637, - 0.21093913, - -0.15935478, - 0.83237714, - 0.10157911, - -0.45885337, - 1.26207038, - 1.07601429, - 1.23736173, - 0.28618205, - -0.143281, - -0.13159008, - 0.74308471, - 0.26291269, - 0.17504574, - 0.55601508, - 1.46900656, - 0.65130981, - 0.89596543, - 0.32536767, - -0.25504632, - 0.07563599, - 1.48775644, - 0.28519708, - 0.58513646, - -0.63673033, - 1.5932429, - 0.53826754, - 0.41792748, - 0.7658319, - 0.87290603, - 0.89110888, - 0.27282434, - -0.20300504, - 1.01058742, - 0.68072965, - -0.21073937, - 1.19114243, - 0.63723316, - 0.3344412, - 1.05599174, - 0.78372725, - 1.01272241, - -0.19460072, - 1.3180811, - 0.58658171, - -0.34218688, - 0.68725498, - 0.37484577, - 2.48875469, - -0.06424035, - 0.22162324, - -0.21623218, - 0.25998442, - 0.37801781, - -0.51312723, - -0.35024653, - 1.90461235, - 0.02214488, - -0.59132457, - 0.42870476, - 0.88951825, - ] - ), } def setup_class(self): @@ -695,11 +490,7 @@ def check_trace(self, step_method): with Model() as model: x = Normal("x", mu=0, sigma=1) y = Normal("y", mu=x, sigma=1, observed=1) - if step_method.__name__ == "SMC": - trace = sample( - draws=200, random_seed=1, progressbar=False, step=step_method(parallel=False) - ) - elif step_method.__name__ == "NUTS": + if step_method.__name__ == "NUTS": step = step_method(scaling=model.test_point) trace = sample( 0, tune=n_steps, discard_tuned_samples=False, step=step, random_seed=1, chains=1 From 7998ebbc8e94f4b25f1d4ce19282c3a6a1a118b4 Mon Sep 17 00:00:00 2001 From: "Robert P. Goldman" Date: Tue, 13 Aug 2019 12:26:20 -0500 Subject: [PATCH 25/45] Clean up docstring for `sample`. --- pymc3/sampling.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/pymc3/sampling.py b/pymc3/sampling.py index e9900295778..8374cb07dae 100644 --- a/pymc3/sampling.py +++ b/pymc3/sampling.py @@ -186,9 +186,6 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N draws : int The number of samples to draw. Defaults to 500. The number of tuned samples are discarded by default. See ``discard_tuned_samples``. - step : function or iterable of functions - A step function or collection of functions. If there are variables without a step methods, - step methods for those variables will be assigned automatically. init : str Initialization method to use for auto-assigned NUTS samplers. @@ -209,6 +206,11 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N * advi_map: Initialize ADVI with MAP and use MAP as starting point. * map : Use the MAP as starting point. This is discouraged. * nuts : Run NUTS and estimate posterior mean and mass matrix from the trace. + step : function or iterable of functions + A step function or collection of functions. If there are variables without step methods, + step methods for those variables will be assigned automatically. By default the NUTS step + method will be used, if appropriate to the model; this is a good default for beginning + users. n_init : int Number of iterations of initializer. Only works for 'nuts' and 'ADVI'. If 'ADVI', number of iterations, if 'nuts', number of draws. From 86efff37d7fbb219fdd7ce6c826b817a1f7a03c3 Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Wed, 14 Aug 2019 18:59:00 -0400 Subject: [PATCH 26/45] rename parameters, hopefully passes on float32 --- pymc3/ode/ode.py | 19 +++--- pymc3/tests/test_ode.py | 136 +++++++++++++--------------------------- 2 files changed, 54 insertions(+), 101 deletions(-) diff --git a/pymc3/ode/ode.py b/pymc3/ode/ode.py index 236891680e3..8e07b875dc2 100644 --- a/pymc3/ode/ode.py +++ b/pymc3/ode/ode.py @@ -131,13 +131,14 @@ def _cached_simulate(self, parameters): else: return self._simulate(np.array(parameters)) - def state(self, x): - y, sens = self._cached_simulate(np.array(x, dtype=np.float64)) - self._cached_y, self._cached_sens, self._cached_parameters = y, sens, x + def state(self, parameters): + y, sens = self._cached_simulate(np.array(parameters)) + self._cached_y, self._cached_sens, self._cached_parameters = y, sens, parameters return y.ravel() - def numpy_vsp(self, x, g): - numpy_sens = self._cached_simulate(np.array(x, dtype=np.float64))[1].reshape((self.n_states * len(self.times), len(x))) + def numpy_vsp(self, parameters, g): + _,sens = self._cached_simulate(np.array(parameters)) + numpy_sens = sens.reshape((self.n_states * len(self.times), len(parameters))) return numpy_sens.T.dot(g) def make_node(self, odeparams, y0): @@ -153,14 +154,14 @@ def make_node(self, odeparams, y0): odeparams = tt.as_tensor_variable(odeparams) y0 = tt.as_tensor_variable(y0) - x = tt.concatenate([odeparams, y0]) - return theano.Apply(self, [x], [x.type()]) + parameters = tt.concatenate([odeparams, y0]) + return theano.Apply(self, [parameters], [parameters.type()]) def perform(self, node, inputs_storage, output_storage): - x = inputs_storage[0] + parameters = inputs_storage[0] out = output_storage[0] # get the numerical solution of ODE states - out[0] = self.state(x) + out[0] = self.state(parameters) def grad(self, inputs, output_grads): x = inputs[0] diff --git a/pymc3/tests/test_ode.py b/pymc3/tests/test_ode.py index 481cd52f101..702023ad288 100644 --- a/pymc3/tests/test_ode.py +++ b/pymc3/tests/test_ode.py @@ -38,8 +38,7 @@ def augmented_system(Y, t, p): # Treat y0 like a parameter and solve analytically. Then differentiate. # I used CAS to get these derivatives y0_sensitivity = np.exp(-a * t) - a_sensitivity = -(np.exp(t * (a - 1)) - 1 + (a - 1) * - (y0 * a - y0 - 1) * t) * np.exp(-a * t) / (a - 1)**2 + a_sensitivity = -(np.exp(t * (a - 1)) - 1 + (a - 1) * (y0 * a - y0 - 1) * t) * np.exp(-a * t) / (a - 1)**2 sensitivity = np.c_[a_sensitivity, y0_sensitivity] @@ -49,8 +48,7 @@ def augmented_system(Y, t, p): args=tuple([p])) simulated_sensitivity = integrated_solutions[:, 1:] - np.testing.assert_allclose( - sensitivity, simulated_sensitivity, rtol=1e-5) + np.testing.assert_allclose(sensitivity, simulated_sensitivity, rtol=1e-5) @@ -105,8 +103,7 @@ def ode_func_1(y, t, p): # Sensitivity initial condition for this model should be 1 by 2 model1_sens_ic = np.array([0, 1]) - np.testing.assert_array_equal( - model1_sens_ic, model1._make_sens_ic()) + np.testing.assert_array_equal(model1_sens_ic, model1._make_sens_ic()) def test_sens_ic_scalar_2_param(self): with theano.configparser.change_flags(compute_test_value='off'): @@ -124,8 +121,7 @@ def ode_func_2(y, t, p): model2_sens_ic = np.array([0, 0, 1]) - np.testing.assert_array_equal( - model2_sens_ic, model2._make_sens_ic()) + np.testing.assert_array_equal(model2_sens_ic, model2._make_sens_ic()) def test_sens_ic_vector_1_param(self): with theano.configparser.change_flags(compute_test_value='off'): @@ -146,8 +142,7 @@ def ode_func_3(y, t, p): model3_sens_ic = np.array([0, 1, 0, 0, 0, 1]) - np.testing.assert_array_equal( - model3_sens_ic, model3._make_sens_ic()) + np.testing.assert_array_equal(model3_sens_ic, model3._make_sens_ic()) def test_sens_ic_vector_2_param(self): with theano.configparser.change_flags(compute_test_value='off'): @@ -168,8 +163,7 @@ def ode_func_4(y, t, p): model4_sens_ic = np.array([0, 0, 1, 0, 0, 0, 0, 1]) - np.testing.assert_array_equal( - model4_sens_ic, model4._make_sens_ic()) + np.testing.assert_array_equal(model4_sens_ic, model4._make_sens_ic()) def test_sens_ic_vector_3_params(self): with theano.configparser.change_flags(compute_test_value='off'): @@ -196,9 +190,7 @@ def ode_func_5(y, t, p): [0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 1]]) - np.testing.assert_array_equal( - np.ravel(model5_sens_ic), - model5._make_sens_ic()) + np.testing.assert_array_equal(np.ravel(model5_sens_ic), model5._make_sens_ic()) @@ -241,23 +233,15 @@ def system_1(y, t, p): integrated_solution, *_ = ode_model._simulate([alpha, y0]) - manual_logp = norm.logpdf( - x=np.ravel(yobs), - loc=np.ravel(integrated_solution), - scale=1).sum() + manual_logp = norm.logpdf(x=np.ravel(yobs), loc=np.ravel(integrated_solution), scale=1).sum() with pm.Model() as model_1: - forward = ode_model(odeparams=[alpha], y0=[y0]).reshape(yobs.shape) - y = pm.Normal('y', mu=forward, sd=1, observed=yobs) pymc3_logp = model_1.logp() - np.testing.assert_allclose(manual_logp, pymc3_logp) - - class TestErrors(object): '''Test running model for a scalar ODE with 1 parameter''' @@ -266,12 +250,11 @@ def system(y, t, p): times = np.arange(0, 9) - ode_model = DifferentialEquation( - func=system, - t0=0, - times=times, - n_states=1, - n_odeparams=1) + ode_model = DifferentialEquation(func=system, + t0=0, + times=times, + n_states=1, + n_odeparams=1) def test_too_many_params(self): with pytest.raises(ValueError): @@ -341,27 +324,20 @@ def system(y, t, p): 0.1]).reshape(-1, 1) - ode_model = DifferentialEquation( - func=system, - t0=0, - times=times, - n_states=1, - n_odeparams=1) + ode_model = DifferentialEquation(func=system, + t0=0, + times=times, + n_states=1, + n_odeparams=1) with pm.Model() as model: alpha = pm.HalfCauchy('alpha', 1) y0 = pm.Lognormal('y0', 0, 1) sigma = pm.HalfCauchy('sigma', 1) - forward = ode_model( - odeparams=[alpha], - y0=[y0]).reshape( - yobs.shape) - - y = pm.Lognormal('y', mu=pm.math.log( - forward), sd=sigma, observed=yobs) - - trace = pm.sample(100, tune=0) + forward = ode_model(odeparams=[alpha], y0=[y0]).reshape(yobs.shape) + y = pm.Lognormal('y', mu=pm.math.log(forward), sd=sigma, observed=yobs) + trace = pm.sample(100, tune=0, chains = 1) assert trace['alpha'].size > 0 assert trace['y0'].size > 0 @@ -393,28 +369,19 @@ def system(y, t, p): 0.10]).reshape(-1, 1) - ode_model = DifferentialEquation( - func=system, - t0=0, - times=times, - n_states=1, - n_odeparams=2) + ode_model = DifferentialEquation(func=system, + t0=0, + times=times, + n_states=1, + n_odeparams=2) with pm.Model() as model: - alpha = pm.HalfCauchy('alpha', 1) beta = pm.HalfCauchy('beta', 1) y0 = pm.Lognormal('y0', 0, 1) sigma = pm.HalfCauchy('sigma', 1) - forward = ode_model( - odeparams=[ - alpha, - beta], - y0=[y0]).reshape( - yobs.shape) - - y = pm.Lognormal('y', mu=pm.math.log( - forward), sd=sigma, observed=yobs) + forward = ode_model(odeparams=[alpha,beta],y0=[y0]).reshape(yobs.shape) + y = pm.Lognormal('y', mu=pm.math.log(forward), sd=sigma, observed=yobs) trace = pm.sample(100, tune=0) @@ -447,26 +414,19 @@ def system(y, t, p): [0.02, 0.01], [0.02, 0.01]]) - ode_model = DifferentialEquation( - func=system, - t0=0, - times=times, - n_states=2, - n_odeparams=1) + ode_model = DifferentialEquation(func=system, + t0=0, + times=times, + n_states=2, + n_odeparams=1) with pm.Model() as model: - R = pm.Lognormal('R', 1, 5) sigma = pm.HalfCauchy('sigma', 1, shape=2) - forward = ode_model( - odeparams=[R], y0=[ - 0.99, 0.01]).reshape( - yobs.shape) - - y = pm.Lognormal('y', mu=pm.math.log( - forward), sd=sigma, observed=yobs) + forward = ode_model(odeparams=[R], y0=[0.99, 0.01]).reshape(yobs.shape) + y = pm.Lognormal('y', mu=pm.math.log(forward), sd=sigma, observed=yobs) - trace = pm.sample(100, tune=0) + trace = pm.sample(100, tune=0, chains = 1) assert trace['R'].size > 0 assert trace['sigma'].size > 0 @@ -495,28 +455,20 @@ def system(y, t, p): [0.02, 0.01], [0.02, 0.01]]) - ode_model = DifferentialEquation( - func=system, - t0=0, - times=times, - n_states=2, - n_odeparams=2) + ode_model = DifferentialEquation(func=system, + t0=0, + times=times, + n_states=2, + n_odeparams=2) with pm.Model() as model: - beta = pm.HalfCauchy('beta', 1) gamma = pm.HalfCauchy('gamma', 1) sigma = pm.HalfCauchy('sigma', 1, shape=2) - forward = ode_model( - odeparams=[ - beta, gamma], y0=[ - 0.99, 0.01]).reshape( - yobs.shape) + forward = ode_model(odeparams=[beta, gamma], y0=[0.99, 0.01]).reshape(yobs.shape) + y = pm.Lognormal('y', mu=pm.math.log(forward), sd=sigma, observed=yobs) - y = pm.Lognormal('y', mu=pm.math.log( - forward), sd=sigma, observed=yobs) - - trace = pm.sample(100, tune=0) + trace = pm.sample(100, tune=0, chains = 1) assert trace['beta'].size > 0 assert trace['gamma'].size > 0 From cb2add3b3e8b87ef19b11c68e4b4bb1d709ba4f5 Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Tue, 30 Jul 2019 19:16:13 -0400 Subject: [PATCH 27/45] Commit ODE capabilities. Add unit test for pm.ode --- pymc3/ode/__init__.py | 2 + pymc3/ode/ode.py | 183 +++++++++++++++ pymc3/ode/utils.py | 81 +++++++ pymc3/tests/test_ode.py | 497 ++++++++++++++++++++++++++++++++++++++++ 4 files changed, 763 insertions(+) create mode 100644 pymc3/ode/__init__.py create mode 100644 pymc3/ode/ode.py create mode 100644 pymc3/ode/utils.py create mode 100644 pymc3/tests/test_ode.py diff --git a/pymc3/ode/__init__.py b/pymc3/ode/__init__.py new file mode 100644 index 00000000000..468c3f54aeb --- /dev/null +++ b/pymc3/ode/__init__.py @@ -0,0 +1,2 @@ +from . import utils +from .ode import DifferentialEquation \ No newline at end of file diff --git a/pymc3/ode/ode.py b/pymc3/ode/ode.py new file mode 100644 index 00000000000..c90cd11200f --- /dev/null +++ b/pymc3/ode/ode.py @@ -0,0 +1,183 @@ +import numpy as np +from pymc3.ode.utils import augment_system, ODEGradop +import scipy +import theano +import theano.tensor as tt +THEANO_FLAG = 'compute_test_value=ignore' + + +class DifferentialEquation(theano.Op): + + ''' + Specify an ordinary differential equation + + .. math:: + \dfrac{dy}{dt} = f(y,t,p) \quad y(t_0) = y_0 + + Parameters + ---------- + + func : callable + Function specifying the differential equation + t0 : float + Time corresponding to the initial condition + times : array + Array of times at which to evaluate the solution of the differential equation. + n_states : int + Dimension of the differential equation. For scalar differential equations, n_states =1. + For vector valued differential equations, n_states = number of differential equations iun the system. + n_odeparams : int + Number of parameters in the differential equation. + + .. code-block:: python + + def odefunc(y,t,p): + #Logistic differential equation + return p[0]*y[0]*(1-y[0]) + + times = np.arange(0.5, 5, 0.5) + + ode_model = DifferentialEquation(func = odefunc, t0 = 0, times = times, n_states = 1, n_odeparams = 1) + ''' + + __props__ = () + + def __init__(self, func, t0, times, n_states, n_odeparams): + + if not callable(func): + raise ValueError("Argument func must be callable.") + if np.any(np.diff(times)<0): + raise ValueError("The values in times must be monotonically increasing or monotonically decreasing; repeated values are allowed.") + if n_states<1: + raise ValueError('Argument n_states must be at least 1.') + if n_odeparams<0: + raise ValueError('Argument n_states must be non-negative.') + + #Public + self.func = func + self.t0 = t0 + self.times = times + self.n_states = n_states + self.n_odeparams = n_odeparams + + #Private + self._n = n_states + self._m = n_odeparams + n_states + + self._augmented_times = np.insert(times, t0, 0) + self._augmented_func = augment_system(func, self._n, self._m) + self._sens_ic = self._make_sens_ic() + + self._cached_y = None + self._cached_sens = None + self._cached_parameters = None + + def _make_sens_ic(self): + + # The sensitivity matrix will always have consistent form. + # If the first n_odeparams entries of the parameters vector in the simulate call + # correspond to ode paramaters, then the first n_odeparams columns in + # the sensitivity matrix will be 0 + sens_matrix = np.zeros((self._n, self._m)) + + # If the last n_states entrues of the paramters vector in the simulate call + # correspond to initial conditions of the system, + # then the last n_states columns of the sensitivity matrix should form + # an identity matrix + sens_matrix[:, -self.n_states:] = np.eye(self.n_states) + + # We need the sensitivity matrix to be a vector (see augmented_function) + # Ravel and return + dydp = sens_matrix.ravel() + + return dydp + + def _system(self, Y, t, p): + """ + This is the function that will be passed to odeint. + Solves both ODE and sensitivities + Args: + Y (vector): current state and current gradient state + t (scalar): current time + p (vector): parameters + Returns: + derivatives (vector): derivatives of state and gradient + """ + + dydt, ddt_dydp = self._augmented_func(Y[:self._n], t, p, Y[self._n:]) + derivatives = np.concatenate([dydt, ddt_dydp]) + return derivatives + + def _simulate(self, parameters): + + # Initial condition comprised of state initial conditions and raveled + # sensitivity matrix + y0 = np.concatenate([ parameters[self.n_odeparams:] , self._sens_ic]) + + # perform the integration + sol = scipy.integrate.odeint(func=self._system, + y0=y0, + t=self._augmented_times, + args=tuple([parameters])) + # The solution + y = sol[1:, :self.n_states] + + # The sensitivities, reshaped to be a sequence of matrices + sens = sol[1:, self.n_states:].reshape(len(self.times), self._n, self._m) + + return y, sens + + def _cached_simulate(self, parameters): + + if np.array_equal(np.array(parameters), self._cached_parameters): + return self._cached_y, self._cached_sens + else: + return self._simulate(np.array(parameters)) + + def state(self, x): + + y, sens = self._cached_simulate(np.array(x, dtype=np.float64)) + self._cached_y, self._cached_sens, self._cached_parameters = y, sens, x + return y.ravel() + + def numpy_vsp(self, x, g): + + numpy_sens = self._cached_simulate(np.array(x, dtype=np.float64))[1].reshape((self.n_states * len(self.times), len(x))) + return numpy_sens.T.dot(g) + + def make_node(self, odeparams, y0): + + if len(odeparams)!=self.n_odeparams: + raise ValueError('odeparams has too many or too few parameters. Expected {a} paramteres but got {b}'.format(a = self.n_odeparams, b = len(odeparams))) + if len(y0)!=self.n_states: + raise ValueError('y0 has too many or too few parameters. Expected {a} paramteres but got {b}'.format(a = self.n_states, b = len(y0))) + + if np.ndim(odeparams) > 1: + odeparams = np.ravel(odeparams) + if np.ndim(y0) > 1: + y0 = np.ravel(y0) + + odeparams = tt.as_tensor_variable(odeparams) + y0 = tt.as_tensor_variable(y0) + x = tt.concatenate([odeparams, y0]) + + return theano.Apply(self, [x], [x.type()]) + + def perform(self, node, inputs_storage, output_storage): + + x = inputs_storage[0] + out = output_storage[0] + + # get the numerical solution of ODE states + out[0] = self.state(x) + + def grad(self, inputs, output_grads): + + x = inputs[0] + g = output_grads[0] + + # pass the VSP when asked for gradient + grad_op = ODEGradop(self.numpy_vsp) + grad_op_apply = grad_op(x, g) + + return [grad_op_apply] \ No newline at end of file diff --git a/pymc3/ode/utils.py b/pymc3/ode/utils.py new file mode 100644 index 00000000000..15d3767874a --- /dev/null +++ b/pymc3/ode/utils.py @@ -0,0 +1,81 @@ +import theano +import theano.tensor as tt + + +def augment_system(ode_func, n, m): + '''Function to create augmented system. + + Take a function which specifies a set of differential equations and return + a compiled function which allows for computation of gradients of the + differential equation's solition with repsect to the parameters. + + Args: + ode_func (function): Differential equation. Returns array-like + n: Number of rows of the sensitivity matrix + m: Number of columns of the sensitivity matrix + + Returns: + system (function): Augemted system of differential equations. + + ''' + + # Present state of the system + t_y = tt.vector('y', dtype=theano.config.floatX) + + # Parameter(s). Should be vector to allow for generaliztion to multiparameter + # systems of ODEs + t_p = tt.vector('p', dtype=theano.config.floatX) + + # Time. Allow for non-automonous systems of ODEs to be analyzed + t_t = tt.scalar('t', dtype=theano.config.floatX) + + # Present state of the gradients: + # Will always be 0 unless the parameter is the inital condition + # Entry i,j is partial of y[i] wrt to p[j] + dydp_vec = tt.vector('dydp', dtype=theano.config.floatX) + + dydp = dydp_vec.reshape((n, m)) + + # Stack the results of the ode_func + # TODO: Does this behave the same of ODE is scalar? + f_tensor = tt.stack(ode_func(t_y, t_t, t_p)) + + # Now compute gradients + J = tt.jacobian(f_tensor, t_y) + + Jdfdy = tt.dot(J, dydp) + + grad_f = tt.jacobian(f_tensor, t_p) + + # This is the time derivative of dydp + ddt_dydp = (Jdfdy + grad_f).flatten() + + system = theano.function( + inputs=[t_y, t_t, t_p, dydp_vec], + outputs=[f_tensor, ddt_dydp], + on_unused_input='ignore') + + return system + + + +class ODEGradop(theano.Op): + + def __init__(self, numpy_vsp): + + self._numpy_vsp = numpy_vsp + + def make_node(self, x, g): + + x = theano.tensor.as_tensor_variable(x) + g = theano.tensor.as_tensor_variable(g) + node = theano.Apply(self, [x, g], [g.type()]) + return node + + def perform(self, node, inputs_storage, output_storage): + + x = inputs_storage[0] + + g = inputs_storage[1] + out = output_storage[0] + out[0] = self._numpy_vsp(x, g) # get the numerical VSP diff --git a/pymc3/tests/test_ode.py b/pymc3/tests/test_ode.py new file mode 100644 index 00000000000..a359f8a9ced --- /dev/null +++ b/pymc3/tests/test_ode.py @@ -0,0 +1,497 @@ +from ..ode import DifferentialEquation +from ..ode.utils import augment_system + +import numpy as np +from scipy.integrate import odeint +from scipy.stats import norm +import pymc3 as pm +import theano +import theano.tensor as tt +import pytest + + +def test_gradients(): + with theano.configparser.change_flags(compute_test_value='off'): + '''Tests the computation of the sensitivities from the theano computation graph''' + + # ODE system for which to compute gradients + def ode_func(y, t, p): + return np.exp(-t) - p[0] * y[0] + + # Computation of graidients with Theano + augmented_ode_func = augment_system(ode_func, 1, 1 + 1) + + # This is the new system, ODE + Sensitivities, which will be integrated + def augmented_system(Y, t, p): + + dydt, ddt_dydp = augmented_ode_func(Y[:1], t, p, Y[1:]) + derivatives = np.concatenate([dydt, ddt_dydp]) + return derivatives + + # Create real sensitivities + y0 = 0.0 + t = np.arange(0, 12, 0.25).reshape(-1, 1) + a = 0.472 + p = np.array([a, y0]) + + # Derivatives of the analytic solution with respect to y0 and alpha + # Treat y0 like a parameter and solve analytically. Then differentiate. + # I used CAS to get these derivatives + y0_sensitivity = np.exp(-a * t) + a_sensitivity = -(np.exp(t * (a - 1)) - 1 + (a - 1) * + (y0 * a - y0 - 1) * t) * np.exp(-a * t) / (a - 1)**2 + + sensitivity = np.c_[a_sensitivity, y0_sensitivity] + + integrated_solutions = odeint(func=augmented_system, + y0=[y0, 0, 1], + t=t.ravel(), + args=tuple([p])) + simulated_sensitivity = integrated_solutions[:, 1:] + + np.testing.assert_allclose( + sensitivity, simulated_sensitivity, rtol=1e-5) + + +def test_simulate(): + with theano.configparser.change_flags(compute_test_value='off'): + '''Tests the integration in DifferentialEquation''' + + # Create an ODe to integrate + def ode_func(y, t, p): + return np.exp(-t) - p[0] * y[0] + + # Evaluate exact solution + y0 = 0 + t = np.arange(0, 12, 0.25).reshape(-1, 1) + a = 0.472 + y = 1.0 / (a - 1) * (np.exp(-t) - np.exp(-a * t)) + + # Instantiate ODE model + ode_model = DifferentialEquation(func=ode_func, + t0=0, + times=t, + n_states=1, + n_odeparams=1) + + simulated_y, *_ = ode_model._simulate([a, y0]) + + np.testing.assert_allclose(y, simulated_y, rtol=1e-5) + + +class TestSensitivityInitialCondition(object): + + t = np.arange(0, 12, 0.25).reshape(-1, 1) + + def test_sens_ic_scalar_1_param(self): + with theano.configparser.change_flags(compute_test_value='off'): + + '''Tests the creation of the initial condition for the sensitivities''' + + # Scalar ODE 1 Param + # Create an ODe to integrate + def ode_func_1(y, t, p): + return np.exp(-t) - p[0] * y[0] + + # Instantiate ODE model + # Instantiate ODE model + model1 = DifferentialEquation(func=ode_func_1, + t0=0, + times=self.t, + n_states=1, + n_odeparams=1) + + # Sensitivity initial condition for this model should be 1 by 2 + model1_sens_ic = np.array([0, 1]) + + np.testing.assert_array_equal( + model1_sens_ic, model1._make_sens_ic()) + + def test_sens_ic_scalar_2_param(self): + with theano.configparser.change_flags(compute_test_value='off'): + + # Scalar ODE 2 Param + def ode_func_2(y, t, p): + return p[0] * np.exp(-p[0] * t) - p[1] * y[0] + + # Instantiate ODE model + model2 = DifferentialEquation(func=ode_func_2, + t0=0, + times=self.t, + n_states=1, + n_odeparams=2) + + model2_sens_ic = np.array([0, 0, 1]) + + np.testing.assert_array_equal( + model2_sens_ic, model2._make_sens_ic()) + + def test_sens_ic_vector_1_param(self): + with theano.configparser.change_flags(compute_test_value='off'): + + # Vector ODE 1 Param + def ode_func_3(y, t, p): + ds = -p[0] * y[0] * y[1] + di = p[0] * y[0] * y[1] - y[1] + + return [ds, di] + + # Instantiate ODE model + model3 = DifferentialEquation(func=ode_func_3, + t0=0, + times=self.t, + n_states=2, + n_odeparams=1) + + model3_sens_ic = np.array([0, 1, 0, 0, 0, 1]) + + np.testing.assert_array_equal( + model3_sens_ic, model3._make_sens_ic()) + + def test_sens_ic_vector_2_param(self): + with theano.configparser.change_flags(compute_test_value='off'): + + # Vector ODE 2 Param + def ode_func_4(y, t, p): + ds = -p[0] * y[0] * y[1] + di = p[0] * y[0] * y[1] - p[1] * y[1] + + return [ds, di] + + # Instantiate ODE model + model4 = DifferentialEquation(func=ode_func_4, + t0=0, + times=self.t, + n_states=2, + n_odeparams=2) + + model4_sens_ic = np.array([0, 0, 1, 0, 0, 0, 0, 1]) + + np.testing.assert_array_equal( + model4_sens_ic, model4._make_sens_ic()) + + def test_sens_ic_vector_3_params(self): + with theano.configparser.change_flags(compute_test_value='off'): + + # Big System with Many Parameters + def ode_func_5(y, t, p): + dx = p[0] * (y[1] - y[0]) + ds = y[0] * (p[1] - y[2]) - y[1] + dz = y[0] * y[1] - p[2] * y[2] + + return [dx, ds, dz] + + # Instantiate ODE model + model5 = DifferentialEquation(func=ode_func_5, + t0=0, + times=self.t, + n_states=3, + n_odeparams=3) + + # First three columns are derivatives with respect to ode parameters + # Last three coluimns are derivatives with repsect to initial condition + # So identity matrix should appear in last 3 columns + model5_sens_ic = np.array([[0, 0, 0, 1, 0, 0], + [0, 0, 0, 0, 1, 0], + [0, 0, 0, 0, 0, 1]]) + + np.testing.assert_array_equal( + np.ravel(model5_sens_ic), + model5._make_sens_ic()) + + +def test_logp_scalar_ode(): + with theano.configparser.change_flags(compute_test_value='off'): + + '''Test the computation of the log probability for these models''' + + # Differential equation + def system_1(y, t, p): + return np.exp(-t) - p[0] * y[0] + + # Parameters and inital condition + alpha = 0.4 + y0 = 0.0 + times = np.arange(0.5, 8, 0.5) + + yobs = np.array([0.30, + 0.56, + 0.51, + 0.55, + 0.47, + 0.42, + 0.38, + 0.30, + 0.26, + 0.21, + 0.22, + 0.13, + 0.13, + 0.09, + 0.09]).reshape(-1, + 1) + + ode_model = DifferentialEquation(func=system_1, + t0=0, + times=times, + n_odeparams=1, + n_states=1) + + integrated_solution, *_ = ode_model._simulate([alpha, y0]) + + manual_logp = norm.logpdf( + x=np.ravel(yobs), + loc=np.ravel(integrated_solution), + scale=1).sum() + + with pm.Model() as model_1: + + forward = ode_model(odeparams=[alpha], y0=[y0]).reshape(yobs.shape) + + y = pm.Normal('y', mu=forward, sd=1, observed=yobs) + + pymc3_logp = model_1.logp() + + np.testing.assert_allclose(manual_logp, pymc3_logp) + + +class TestErrors(object): + + '''Test running model for a scalar ODE with 1 parameter''' + def system(y, t, p): + return np.exp(-t) - p[0] * y[0] + + times = np.arange(0, 9) + + ode_model = DifferentialEquation( + func=system, + t0=0, + times=times, + n_states=1, + n_odeparams=1) + + def test_too_many_params(self): + with pytest.raises(ValueError): + self.ode_model(odeparams=[1, 1], y0=[0]) + + def test_too_many_y0(self): + with pytest.raises(ValueError): + self.ode_model(odeparams=[1], y0=[0, 0]) + + def test_too_few_params(self): + with pytest.raises(ValueError): + self.ode_model(odeparams=[], y0=[1]) + + def test_too_few_y0(self): + with pytest.raises(ValueError): + self.ode_model(odeparams=[1], y0=[]) + + +class TestDiffEqModel(object): + + def test_scalar_ode_1_param(self): + '''Test running model for a scalar ODE with 1 parameter''' + with theano.configparser.change_flags(compute_test_value='off'): + def system(y, t, p): + return np.exp(-t) - p[0] * y[0] + + times = np.array([0.5, 1., 1.5, 2., 2.5, 3., 3.5, + 4., 4.5, 5., 5.5, 6., 6.5, 7., 7.5]) + + yobs = np.array([0.31, + 0.57, + 0.51, + 0.55, + 0.47, + 0.42, + 0.38, + 0.3, + 0.26, + 0.22, + 0.22, + 0.14, + 0.14, + 0.09, + 0.1]).reshape(-1, + 1) + + ode_model = DifferentialEquation( + func=system, + t0=0, + times=times, + n_states=1, + n_odeparams=1) + + with pm.Model() as model: + + alpha = pm.HalfCauchy('alpha', 1) + y0 = pm.Lognormal('y0', 0, 1) + sigma = pm.HalfCauchy('sigma', 1) + forward = ode_model( + odeparams=[alpha], + y0=[y0]).reshape( + yobs.shape) + + y = pm.Lognormal('y', mu=pm.math.log( + forward), sd=sigma, observed=yobs) + + trace = pm.sample(100, tune=0) + + assert trace['alpha'].size > 0 + assert trace['y0'].size > 0 + assert trace['sigma'].size > 0 + + def test_scalar_ode_2_param(self): + '''Test running model for a scalar ODE with 2 parameters''' + with theano.configparser.change_flags(compute_test_value='off'): + def system(y, t, p): + return p[0] * np.exp(-p[0] * t) - p[1] * y[0] + + times = np.array([0.5, 1., 1.5, 2., 2.5, 3., 3.5, + 4., 4.5, 5., 5.5, 6., 6.5, 7., 7.5]) + + yobs = np.array([0.31, + 0.57, + 0.51, + 0.55, + 0.47, + 0.42, + 0.38, + 0.30, + 0.26, + 0.22, + 0.22, + 0.14, + 0.14, + 0.09, + 0.10]).reshape(-1, + 1) + + ode_model = DifferentialEquation( + func=system, + t0=0, + times=times, + n_states=1, + n_odeparams=2) + + with pm.Model() as model: + + alpha = pm.HalfCauchy('alpha', 1) + beta = pm.HalfCauchy('beta', 1) + y0 = pm.Lognormal('y0', 0, 1) + sigma = pm.HalfCauchy('sigma', 1) + forward = ode_model( + odeparams=[ + alpha, + beta], + y0=[y0]).reshape( + yobs.shape) + + y = pm.Lognormal('y', mu=pm.math.log( + forward), sd=sigma, observed=yobs) + + trace = pm.sample(100, tune=0) + + assert trace['alpha'].size > 0 + assert trace['beta'].size > 0 + assert trace['y0'].size > 0 + assert trace['sigma'].size > 0 + + def test_vector_ode_1_param(self): + '''Test running model for a vector ODE with 1 parameter''' + with theano.configparser.change_flags(compute_test_value='off'): + def system(y, t, p): + ds = -p[0] * y[0] * y[1] + di = p[0] * y[0] * y[1] - y[1] + + return [ds, di] + + times = np.array( + [0.0, 0.8, 1.6, 2.4, 3.2, 4.0, 4.8, 5.6, 6.4, 7.2, 8.0]) + + yobs = np.array([[1.02, 0.02], + [0.86, 0.12], + [0.43, 0.37], + [0.14, 0.42], + [0.05, 0.43], + [0.03, 0.14], + [0.02, 0.08], + [0.02, 0.04], + [0.02, 0.01], + [0.02, 0.01], + [0.02, 0.01]]) + + ode_model = DifferentialEquation( + func=system, + t0=0, + times=times, + n_states=2, + n_odeparams=1) + + with pm.Model() as model: + + R = pm.Lognormal('R', 1, 5) + sigma = pm.HalfCauchy('sigma', 1, shape=2) + forward = ode_model( + odeparams=[R], y0=[ + 0.99, 0.01]).reshape( + yobs.shape) + + y = pm.Lognormal('y', mu=pm.math.log( + forward), sd=sigma, observed=yobs) + + trace = pm.sample(100, tune=0) + + assert trace['R'].size > 0 + assert trace['sigma'].size > 0 + + def test_vector_ode_2_param(self): + '''Test running model for a vector ODE with 2 parameters''' + with theano.configparser.change_flags(compute_test_value='off'): + def system(y, t, p): + ds = -p[0] * y[0] * y[1] + di = p[0] * y[0] * y[1] - p[1] * y[1] + + return [ds, di] + + times = np.array( + [0.0, 0.8, 1.6, 2.4, 3.2, 4.0, 4.8, 5.6, 6.4, 7.2, 8.0]) + + yobs = np.array([[1.02, 0.02], + [0.86, 0.12], + [0.43, 0.37], + [0.14, 0.42], + [0.05, 0.43], + [0.03, 0.14], + [0.02, 0.08], + [0.02, 0.04], + [0.02, 0.01], + [0.02, 0.01], + [0.02, 0.01]]) + + ode_model = DifferentialEquation( + func=system, + t0=0, + times=times, + n_states=2, + n_odeparams=2) + + with pm.Model() as model: + + beta = pm.HalfCauchy('beta', 1) + gamma = pm.HalfCauchy('gamma', 1) + sigma = pm.HalfCauchy('sigma', 1, shape=2) + forward = ode_model( + odeparams=[ + beta, gamma], y0=[ + 0.99, 0.01]).reshape( + yobs.shape) + + y = pm.Lognormal('y', mu=pm.math.log( + forward), sd=sigma, observed=yobs) + + trace = pm.sample(100, tune=0) + + assert trace['beta'].size > 0 + assert trace['gamma'].size > 0 + assert trace['sigma'].size > 0 From de5ac449a62de17089bff3cf208517f51485cb0d Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Thu, 1 Aug 2019 16:34:24 -0400 Subject: [PATCH 28/45] re run existing ODE notebook to comare against pymc3.ode --- .../notebooks/ODE_parameter_estimation.ipynb | 215 +++++++++++++++++- 1 file changed, 211 insertions(+), 4 deletions(-) diff --git a/docs/source/notebooks/ODE_parameter_estimation.ipynb b/docs/source/notebooks/ODE_parameter_estimation.ipynb index aec3d4d396e..3b25ecf8a2d 100644 --- a/docs/source/notebooks/ODE_parameter_estimation.ipynb +++ b/docs/source/notebooks/ODE_parameter_estimation.ipynb @@ -4,7 +4,15 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING (theano.configdefaults): install mkl with `conda install mkl-service`: No module named 'mkl'\n" + ] + } + ], "source": [ "from scipy.integrate import odeint\n", "import numpy as np\n", @@ -332,7 +340,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4YAAAHyCAYAAAC3X9DzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdd5wURd4/8M93EyyLZFhyzlEkHCZAFIxIkCiIJ5jBu+fu56PenfEO79RTnzsxnJwKHCJRgsqBYkJQkSSSk0gOS2Zh8279/qjume5JO7s7Mz0z+3m/XvParerq7u/M9HR3dVdXiVIKREREREREVH4lOB0AEREREREROYsVQyIiIiIionKOFUMiIiIiIqJyjhVDIiIiIiKico4VQyIiIiIionKOFUMiIiIiIqJyjhVDoggQkc4iUigiG0VEnI4nXETkuIgoERnldCzhIiLPGu/xT07HQv6JyMvG9/Rbp2OJNBGZbrz3MU7HEg1E5Cbj88gJ1TQKnfJw3Ag1EVljfGZPOB0LxRdWDCmkLCfNHCDT7hXo39szioOHlpiIPGpsWx2djgXAPwCcB/C4iNRxMhARedD8vYlI3WLKVrSUjeuTCRFpDuARAEcBvO1wOE6YDKAQwPMiUtHpYMhORGoZ+7NnRaSy0/EQEZlYMSQKMxG5GcANADYopT52Op4Y9SiAZwA4XjFUSp2DrhxeBuBZZ6MhP/4GIAXA35RS5e5uj1JqL4D3ATQB8BuHw4kGFwHsMl7RoBb0/uwZAKwYUmnsh96eTzscB8UZVgyJwu9x4+9bjkZBoTQVQBGA8SJS0+lgyM24WzgcQDaAGQ6H46R/GX9/JyJJjkbiMKXUaqVUW6VUF6djIQoFpdQoY5v+t9OxUHxhxZAojESkLYA+AHIALHA4HAoRpdRRAF8BqADg185GQx7uByAAliilMp0OxilKqTUA9gKoC2CQw+EQEVEMYMWQHCUidUQk13ju6fZiyv7dKLfDkmd9bqqXiFQVkb+JyG4RyRaRUyKyRES6+VheqohsM+b9VkQS/ax3sVHmgIhUL+FbvM/4+1+l1Hk/y59jLP9fIpIgIpNEZL2IXDBe34jIiACfi+shdBGpICKPG53cnDc/F4/yFUTkERFZaXw+eSJyTEQWiUj/QG9GRCoZz8XsND7fEyLysYj0Ke6DEJEuIvJnEflKRPYZ8583Yn1ORGr4mOcF43nVdCNrtuX79tdhRKrxTOIaETknIjki8ouITAv0jKK1AwQRqSIizxvbx0U/z/B9YPy9z3NZsUhEaojI/SKyQES2ishZ47PbLyLvi0iPAPO+YHxGy430SBH5QkROikiRr2caRWSQsc0dNbbBMyLytYjcV9o7XMZ89xjJD/yU8dxnNBCRt4z3mWPE8x8Raeln/raW+euKSGsRedeYP1dEdvqYp4WITBGRHcb2lGX8/6qINPRR3tznLCzm/XawvhcfRWYbf+8PtJyyEpE2IjJVRH62/K7Xi8gfJcAzdCLSREReE5HtInLJ+PyOGPO+IiJXBJj3FhGZJyIHje/ttIj8JCL/9NxWJQydyIjeV/cXkddF5Acj7jzR+9Sv/G3HIrIGwA5L1jGPfdpyH/PUN7aVHcbndFFEtog+1tX2E1+x26mU8fhbgs+qxMcNEfkfY30nRCQ5QLkk4zdre3Za3M9f7zTSPUXkQ9H7+VwR2SsiL4lIFT/LTRGRISLyjohsMObLM+JZJiLDA8Rk295EpKuxrR4zfvvbjPeXYJmnj/GZHDe2580i4vd3K0F0PiMiHUWfV+w0tpmLxv8fGO9NPMrXEn3c2yQimcb7PW78rt4I9H1RHFFK8cVXyF7Qz1wpvWkFPc8cY55PApRJAZBhlPu9Jb+iuT7o5mO/GP9nA8iyTMsB0NfHcjsZZRWAv/iYPsmYVgDgmlJ8HtuM+f8niPf/NoBFlvWdgW6uaL6Ht/zMv8aY/mcAa43/8wGcNf7vZSnbAsBOyzKLoDtSUZbXP/yspzaALZZyeQDOGf8XAhgP4LiRHuVj/uOWebOgn42wvr8DAFp4zPMnY75Co8w5I22+9nuUbwJ90mUuM9cSo/m53u/n/Znx/RbAzz7mr+tRvqVluc0c+r09aImhbjFlrb+VJ3xMf8HjczptvH8zrxDAA36Wbc67HMAblm3rjLGsJyxl0wAs8djmzntsC98AqFKKz6OHZd3Vg/gcxsG9X7kE/SyasqT7+Zi/raXMKKOcMua9BGCnR/nxxm/FnCcb7n2Ogv6d9vWY5ya4f8d+v1foZ10VgJ/8TL8B7v1fRR/Tb7LE4fWbDfIzH+vx/s4b6zPT+wC08jFfd9j3Pfnw3uf9y8d8lQEs9rH9WJe1xs/7zAnwGZR0WluPGC7Ae1/6BYAKHvMtBXDSUiYD9n3aBz6+wwuW8uZ2ZqZPAvhVabdTlOH4G+T2UarjBoDqcB/DhwVY/mDLctMt+ea+cSd0q458uI8hhZZ4fgSQWsxvwzxOZnp8vzMBSKDtBvpuvbkfPQv79j3NKD/RiKkI9uOVAvCsn/dtHve99uXG9Kc91pUF/fuyvveKlvJNARyxTCv0UX55afYRfMXWy/EA+IqvF0pXMewD98loQz9lhlt2tDUt+daTvDMAfgLQG7opWQKAXtDNqRT0g9q+duIPW3aEfSz5neE+gXumFJ9FLcuO+aoA5cwDs3nAegxAZWNaOvTzbOZ79KrUWA4QmcYyxpo7fOiDcjXj/yqWz2IFgGsApBjTqgP4X7hPHrwqAAD+aznAjIdxwgOgGYCPje/G/Lx8VQw/AHCX9TuGboo5AMB6Y77v/HxGfiucljLJADYa5U4DGAkg2ZjWCsCnlu/Z1wm/uY5MAIcADASQZExrDI8TPCP/lDHPrx36vYWyYjgJwFMAulq2C4GuAJuVvXwAHXzMa1YMM41t/i8wfqfGehtbys43yu42vqPLjPxUAEOhO1VQAGaX4vP4f+ayg/wczkFfBLgOxr4BwFUAtlu2I88LAtYT7kwAqwB0tUxvbfn/NuPzyIXuKbQx3Pum9nBfCDoDoJ5lPoH74sQf/LyPCkZ8CsBEP2Wqwr0P6utjepkqhtD7V/OE+ysA7Y38RABD4K5MbIfHyTeA1ca0NdAVevPzTwHQGno/6HVBDe5KYYGxnTWwTKsNvY+Z4ud9hrJi2AL6GdZbYLkIAb2fnQD3/uSvPua1bkOBKv7N4K4U/gTjIp+xfVwH9/78BIA6pdlOUYbjb5DbSKmPGwCmGfmfBlj+UqPMfI98c9+YCV1pfNPcVqAvTv2PZdv9o4/lXgu93+sHYx9l5NcC8Hu4LyL5Oiab202B8f39x/xsje3jFct387hR7mUAtYwyNQHMgnuf29THOvxWDAH8zrL8BQA6W6alGfEtgOWYBt1ZlQKwB0BfAIlGfhJ0pXEigMkl3UfwFXsvxwPgK75eKEXF0JjPPBF7xs/0Fcb0WR751pO8owBq+Ji3h6VMNz/LN0/QDgGoAX2Sat7t+8bcSZbwPd1iWW9agHJzLOW8DlBGGfNk+hiMyo5l2hrL/P0DrOd5o8xnMCo8PsqMNsocAZBgye9tWcedPuZLgvtuZYlPMqFPYM2T3O4+pgdTMbwb7qu7fXxMT4G74rguwDry4KPy42ednxvzvF3W305pXrBXDD3vPPh6mWV9XmUuZl3vGPO+7mOa9W7j8wGW0d+yfdXzU6YZ9IliEYB2JYxxHnycJHqUse4zsgC09FGmPtx3f17xmGY94d4DH3cbLL+J/Ua5cX7KCPRdVgXgBY9pjxv5P8P3Ba0xxvRLAKoGeL9m5cGrgomyVwy/MubdBt93JH8F9x2HSR7vu8DI71qC9d1qifeeEswX8ophEOu8Bu6LD0ke04KtGE6z/LZr+ZjeFO4Kysul2U6NsqU6/gbxGZTpuGFsP+Y+vamP+RtZtq/+HtOs+0avO89GGfOC15ZSfL9jjXm3BthuFICP/Mz/g6XMFB/TkwEcNqY/6mO6z4oh9MUR8wLv9BK8n33GPENK+lnwFV8vPmNI0cLsQW+Ctd094Opl8HojGWhMsjeVUmc8M5VS66ArVIC+C+jLBOidcEMA7wH4J/QV/bMAxiilCoN5Ex7qG3+zlVKXgiifCd00zJc/G3/rQl/N82WDUmpFgOWPN/6+rJQq8FNmPvQV3PrQzWxN5sDDPyulvJ7dMpY3OcC6A1L6+cvVRvKaUi5mpPH3a6XUSh/ryIO+wwAA3UWklZ/lfKSU2hbkOk8Zf+sHLBUZtaHvMAd6lcVS42+g7ycf+sq3PxOMvzOUUsd8FVBK/QK9LQj03eSSML+Hk0GW/0DpoR08YzgKXREG3Nu+L/9USmX7mXYDdNPmI9BNzrwopZRl2o0ek9+DvkjR3FiWJ/PZ1rnKz/PLBr/bqFJquVJKjNecAMvwIiLpcO+LXlQ+hgVRSv0A4BMjOdqSr6DvpABAvRKs1tyHbVBKTStJvJGmlFoNfXGhKkoxzI7oZ96HGcnXlVKnPMsopfYDeNdIjvacbhFoOwVCc/z1pUzHDWP7+RF6X+DrWe4J0Hfff4a+SOfP837ylxh/2/l6HrQY5v6wgwTue+BFP/mfWf5/wXOiUiof+sIL4P+8xZdRACpBt1J4tATznTP+luT3SHGIFUOKFv+BvnrfCPpqm9UE6APDTqXUNwGW8UOAaUeNv14dnACAUaEcA331cRDcB6H7lFKHAoful9kpgFdl1Y81SqksP/FtgfsEr7uf+b/1t2ARaQFdqQSA940Hyr1e0JXjFKNcE8sizHV+GSB+8+6BX6I7HFkgujOYLGunCwDMzg+8OuMIkhljoBOELywxlvhz9MH8bn12ABFh9Swn+V4v6LvgAYlIK6OTi42iO+4ptHw/Zkcogb6fHUqpswGmX238fdjfNmhsh2bls4mf5fhT0t9coO3ZnFZfRPydLAXaVsz3Whu6gxF/73WKUc72XpVSJwF8aCRtJ8Ui0hq6CSCgm5oHEq5t1NqhV6DfnHmxqptHZxdmhXG20QnItSJS3DZ6lfE3KsaDFd2R0UQRWWF0LGJ25GL+ZqoaRUuzT2sD9xiHwXy+pd1OgdAcf30JxXHDrLTeY628GRVY80LBO8bFBl+OBjiGm+cFiXB/Vy6iO7N7QnQHcCeNzljM79a6j2kQIP51fvJPWOI7UkyZknR6Z/5Gvvd1MSEA8/f4qoi8KbpjpctKMD/FiXI9thFFD6XUORGZC92j4P3QzyV49jJY3AlQoK7pzTtkfns3U0p9IyL/gm5LD+i7Gh/6Kx+Eisbf3CDL+zs4WKfXAlDHz/SMAPNa7xYEe4JYyfK/uU6/MSqlMkXkAnwfYJOgm8zeYck2O5vIN9JVoT+ztCDjsy4/AfqzKS7GC5YYS/M5ejKvwlcMWMqDiCyF/cTatEcpdW1JlhUqIjIS+gQxxZJ9Hu6OE1KgT1ACfT9+PzujUmCeuFaFj+3Eh0rFF7EJ5W/OOq0O3K0OrIL5zaUguLu1vt7rv6DvBA0SkdpGZRFwVxQ3Kz0sRSCl2kaDYP5+iuD7szEdNv5WgH6+yry7+TvoZsPXQD/f/L8ACkTkR+iT1H9b7yob24+5zgOheANlYVTCvoRusmnKhr6AZ7YwqQ19Ab7E+zTY90+BttPDlv9Ls52G6vjrS5mOG4YPoFsh1IN+ZnexkX8zdEU2H7rJrT/BnBcAHucGItIeukJurWxfgr6zVmSkzd+1v+8312ipEmjdZTpv8cG8AFzS38jz0He2hwB4yHgVichWAMugK99erSso/vCOIUUTcwD4W0XEPKm6DXrHnIswD1YtIrWgd4qmHkFcwQ7ktPG3pENclFag5q7WoTiaBbqzVNqmZcV4CLpSWADdW1pL6GeSaiql6iql6sJ9xVL8LCNSStJs2LwDfTpgKW814buppyN3HkUPxfEudCXmU+iOF1KVUtWUUunG93OXWTzAogJ9dmKZ954gt8EHS/hWovE3tzLI9+pVcTPu0GyH/l7uAXQ3+tDP0wLBnayXdhsNK6XUaeMiSF/oE//voU+4ewB4DsAeEbnDc7aIBhnY69CVwgzo3m3TlVKVlFK1Lfs0865SLOzTHD3++qOUugh3c2vr8A3mxZElSqkTCL2Z0O99L3SnWDWUUpWVUnWM77aFpazT369VqX4jSqlcpdRQ6AuWkwF8Df1YSWfo5513iMikUAVJ0YsVQ4oaxrOAG6HvZJtXKc2d/wJfzw+G2DToq/wHoa9qtwfwf2VYnnl1v6rncxt+BGqOArjvQJTkjpbpuOX/kjbPs67Tb4xGsxOfY0LB/azJG0qpvyilflZKFXmU8RwnMGjGssxmM36bbYkes8qMsTSfoyfzpDvYZ9oAAEqpXn4qB22LnzssBkJf9T4BYLBSarWPZ8ZK/f0Aru/I/JxKsw0Gw1y+zybjPgT6zVmnleU3V9b3ajalu9f4Owj6AkIWdE+CxSnVNhoE8zNJQOBnbM3fYy7czxW6KKVWKqX+Vyl1FYBq0CfhO6C3xxlijG9qNBU01xmu7ScoIlIJ+jcD6B6cZyqlMjzKVIB+P6VlXV6gpqjWaaXep4Xp+FvW44bJ/A3cKCKNjbu1txp5JX3usVjG8+fmGJrDlVKLfDSRL9P+MIzKtN9RSm1USj2llLoOevu9EfqiTRKAf4qIU8coihBWDCnamFct7xWRJnA/71CaZixBE5FHoK+OFkI33XrAmPSAiAzxO2Ng242/CdC9xxWnl787lKIHZjfvJq0vRSy74K44DQxU0A9znX0DlOkL/1dOGxl/f/Q1UUSqwXfTSpNZiQx0ZdaM8foAZfpZluHv2Y+SaGb8LfGgz1HG/H52+OpExOCrA5SSMp91ui0Ey/LF/M01D7L8dUFMO6r8dJRTDPO9NjV+v6VlPv/VSkSuQ/CdzpjNL80TxFBvoxss/wf6zZnbzfoAz4EBAJRS2UqpRQBGGFlpAK60FPnO+FuafVgo1YW7eZ/PfRr0/tDf4zrWi2L+9mm7oHscBYL7fI+Ucju1CvXxt6zHDQCuZ+y/hT6WToCuuCZBdzrzRSljC8TcHxYB2OynTCj2h+Fg/kauNFpBlZpSKl8p9Rl0D+uF0J9/oG2R4gArhhRtZkNfVW4KfUKUgNI99B40EekM4O9G8s9Kqe+UUnOhewUEgHdEpJHvuQPaAndPXz2DKH8Z9ODqvjxp/D0B3cSjRIwTMrOXxQeLO1E1r9JbzDX+thIRr14ajWdR/hhgkeYJbBc/059D4M5RzDsNga7Am01f+4pIH8+JIpIM9+e4vqzPS4hIZQAdjKRXL6gxxvx+2hpNFW1EpCfcPSSWhXmC2V1E7glUUEQuk5L3FGjuJ64Q3atjccaI7nXRc9114e5Bda7n9CB9Ct36AAD+Udx78fGbA+DqsXe2kfwz3CekwZyst4X72a2QbqNG8z2z18THRcSrKayI9ID7IsBsS35SMa0orD1oWitRZg+c3YrbfsLMWiH32qcZv6G/eOZbWO+c+tynKd0T9nwjOdHXSb5ReTO309me00sh1Mffsh43rMy7huPhvnseqNOZsjC/3wT46FHWuJD5hzCsNxTmQF9IqoDAPUS7iBboOcZcuJsje7b0oTjDiiGFjYjUKubldUBUelgH83mC3sbfsN0tNJoEzYHeia6CvVvr30Bfta0B3ZNniX4vRtM584D6qyBmOQ9gsog8KiJpRnx1ROQtuIdieFbpbqxL4wXo95MG4BsReVAs3WyLSHURuU1EZsHjKqzSwz+Y3Wu/KyK/NisQItIUuvfErtDPJPiy3Pg7yWPe+iLyBvRnHegZqK3G3xEi4q+Tgtlwd22+UERGmCfjItISumvyboBrUOGy6g69D82FHlMqln1q/K0L3XyvHqCbw4nIndCdDwS8OxUMpdSncJ/AviO6N8qm5nTRvTxeJSKvQHeeUNKmeN9An7ikIbghAvIAfCYifS0x9ILudKIa9IWdv/ueNTCj04kHjXiuB/CViPQVe8+KLUX3arkR7h4WfTFPiq+B3r6D6XQGcO93Dio9tIGNiNwk7l40Aw3L4c8foU8Y2wP4r4i0M5abKCKDoHsPTYS+W/meZb6WAHaJyB9EpLPldyoi0hXu59kuwNKjplJqGdydj/xbRP5ieR4OIlJbRB4Q3YlY2CilTsN9N+w1Eelt3J2FiFwO/XvqAHsF1zr/cbhbcIwPcBHjL9Cdk9QB8LmIuI4jxsWvFdA9l2aglNupR1whPf6G4LhhNR/6GNEQuqVGcZ3OlMVPcDfJnGF8p+b2eS30RZbK/mZ2ktI9kZqV7btF9wLuGnpKRNJE5HYR+UR0c2dAn//sF5HJItLTkm/2gPwB9HPOBbAPs0HxSEXBYIp8xc8LlgHug3ht8rOMjpYyOfAxaL2lrHWw6l4ByvkbDHaqkX8GQCMf83WFu1fGp0rxeYwy5t0boIw5wP3bABYZ/xcYMRVZ3t9U+B7o2ud787OuRtAnNOYyi6DHarzg8d14DfgLfXKyzVIm15hXQZ8cjoefgeihO1vZa5m3wDKvgh6/0fwcvAYjhntgdAV9QnAEevDwXR7lmgDY6bH9nPVY7wN+PhufsQf4LF81ys928PdmHcTZ70DZPn4rXtuK8R1Yt4Fz0BUnBWA3dAcbCr4HAjcHuF8eRMwVoe9GWNeVaWzvhR75NUvxmZgDxvv8vXp8DuOgT6oVdLO9TMu0LHgMmm3MH9Tg5JbyI+AehFwZn+kpuPcr5uv/FbOcdZayE4P8LBYa5f/mZ3qZBrg3lnGXZTsxt5tsS3ofgFYBPkPzN33KYznZAG73sb7KAD7ysa2et6TX+HmfIRvgHrqJa5ZHvOb2k2d87373KdAdfFjnPQi9T5vhUa4/7PvnTI/t6RSAX5V1O7XMF/TxN8jllfq44WNZf7csZ34xZc19484AZfx+RtCdpVn3R5cs3/cF2I9JvTzm9bvdlDA+v/tVFHPchz4XK/KI/7THe6polLXuE83j5GnYf8eFAB4sy7bAV2y8eMeQoo5Saivcz8OErdMZ0T3emc/r3K98jHWklPoRwBNG8hkRucqzTDEWQnf60MK4ExGIgj4Y/Qb6imUy9M78WwCjlVL3K2MvXlrGe+wFfTL3CfQBOc1Y1y/Qd9UegY/nJ5TuXKEn9FXs3XCf0C0F0E8p9Z7nPJZ5T0PfvXgd+gTIPPh8DmCYUup/iol7BXSnG19CH5TrQlcCm3iUOwDdacBjANZCn4RUMtY5A0BXpVSZOysw7h6bd1hC3vmBE4zvYAL0hYNs6Gd4dkN/31cgNJ31QCmVo5QaBz0O33+gKw6J0Cf8J6C/42cBdDC2m5Iyv48xQZTdDX3x523oE6EU6N/E+wAuN7a7MlFKzYO+Q/YX6M/2EvTdyGwAm4x13w7gtWIWZTYrDKrTGaNFxi2A66JSWCilZgLoBN1U/Rfok8x86I5MngTQRSm1x2O2fQAGA/gn9PizJ6Cb0udBVyJeg/7+P/KxvotKqduN+ZdAD8+Qasy7CfoCx0TP+UJNKfU99D7tQ+htJxG6cjobuqIwr5hFPAM9APlG6H1hQ+j9mW1oE2MbbAf9vnYZ6xHo52lfBNBO6YHgQyLUx9+yHDd8mG/5P6z7XaWHquoLfaHpPPTnngG9nXeFbmEUtZRSz0Lvt9+D/r0lQB/n90DvPwbBPaxPLnRl9kUAq6EvvJpDcOyBbsLdTSkV1jvxFB2kjOeZRCEnIo2hTzASAPRRYXy+MBJE5K/QzyO8pZR62Mf0OdBNRd9WJe+enxwgIgOgm4ttV0p1KK48RY7RLHEf9N3xXyml1npMrwh3E78rVXBNMh0nIiugL9hMU0oFanZqlr8f+uR5mVLqlnDHR/Ehmo+/IvIn6DutP0PfheYJLFGI8Y4hRaOHobfNbdF0UCqDl6GbzvxaRIIZ6Jqin9nxwJ8cjYK8KKUKoO/GAO67/THNeHbP7A3wrUBljfKJ0APGK3AbpZKJyuOv0TmK2Vv426wUEoUHK4YUVUTkSuimlADwipOxhIrRFOd56OZOoej0hBxkdPrQF8A3SqnFxRQnZ8yAbo49WET89YQbE4wmoW9CNx/8Runx5oozFrr56vtGc3iiYkXr8de40PFX6FYA5wH829mIiOJXSbsCJwo5owesXdDPpph31H6Afv4oXkyBftYtt7iCFPWqQw+vMb+4guQMpVSRiNwLPVRCXehKYkwRkSnQzx7WhX72MQ/A74KdHXob5Qk0BRTNx18RGQN9UbUm3L2A/kkpdc7/XERUFqwYUjSwDsJ8DPqh9D8oPY5TXFC66/pA41pRjDDuEvJOYZRTSq2He0iBWFQbQGPoHijXAnhSKbUxmBmVUtPDGBfFl2g+/l4GHVsedGc7/1RKha0jJSJi5zNERERERETlXszeMaxVq5Zq2rSp02EQERERERE5YsOGDaeUUrVDsayYrRg2bdoU69fHcishIiIiIiKi0hORA6FaVsR7JRWR34nINhHZKiKzRaSiiDQTkR9EZK+IzBWRlEjHRUREREREVF5FtGIoIg2gu0LurpTqCCARwCgALwL4P6VUS+jx3iZEMi4iIiIiIqLyzIlxDJMApIpIEnT3/ccA9AOwwJg+A8BgB+IiIiIiIiIqlyJaMVRKHQHwMoCD0BXC8wA2ADinlCowih0G0MDX/CJyv4isF5H1J0+ejETIREREREREcS/STUmrAxgEoBmA+gDSANwU7PxKqalKqe5Kqe61a4ek8x0iIiIiIqJyL9K9kt4A4Bel1EkAEJGFAK4GUE1Ekoy7hg0BHIlwXEREREREVAIXLlxARkYG8vPznQ4l7iQnJ6NOnTqoUqVKxNYZ6YrhQQC9RKQSgGwA1wNYD+ArAMMAzAFwN4AlEY6LiIiIiIiCdOHCBZw4cQINGjRAamoqRMTpkOKGUgrZ2dk4ckTfK4tU5TDSzxj+AN3JzEYAW4z1TwXwOIDfi8heADUBvBvJuIiIiIiIKHgZGRlo0KABKlWqxEphiIkIKlWqhAYNGiAjIyNi6434APdKqWcAPOORvQ9Az0jHQkREREREJZefn4/U1FSnw4hrqampEW2m68RwFUREREREFON4pzC8Iv35smJIRERERERUzrFiSEREREREVM6xYkhEREREROXSs88+i1q1ajkdRjDbj40AACAASURBVFRgxZCIiIiIiKicY8WQYsKGoxvw9vq3cfjCYadDISIiIiKKO6wYUlRTSuG5r59D9393x4NLH0TntzrjdNZpp8MiIiIiojiWn5+P9PR0TJ482WvaNddcg+HDhwMA3nnnHYgItm3bhhtuuAFpaWlo164dlixZ4iq/d+9eVK5cGX/+859deXl5ebj88stx3XXXQSkV/jcUBFYMKWrlFebhniX34NmVz7ryzuacxfzt850LioiIiIi8iETHK1SSk5Mxbtw4zJgxw5a/Z88efPvttxg/frwtf/To0Rg8eDAWLVqEZs2aYeTIkTh27BgAoGXLlnjxxRcxefJk/PjjjwCA5557Dvv27cO0adOiZtgPVgwpKp3LOYebZ92MGT/N8Jq2/uh6ByIiIiIiovJkwoQJ2Lt3L1atWuXKmzZtGurXr48BAwbYyj766KOYNGkSBgwYgOnTpyMvLw9Lly51TX/44YfRu3dv3H333Vi9ejVefPFFvPLKK2jatGmk3k6xWDGkqHPg3AFc8941+PKXL31OZ8WQiIgiLTs/G0t2LsGqA6uiptkXEYVX27ZtcdVVV2H69OkAgKKiIsycORPjxo1DYmKiray1olinTh3UqlULhw+7+8YQEbz33ns4cOAAbrjhBvTv3x/33XdfRN5HsFgxpKiy4egG9Hq3F7ad3Oa3zNaMrcjOz45gVEREVJ4VqSLcMe8ODJ47GL2n98bfv/u70yERUYRMmDAB8+fPR1ZWFlasWIHDhw/jnnvu8SpXrVo1WzolJQU5OTm2vMaNG+Pqq69Gbm4uHn744bDGXRqsGFLU+GT3J+g9vTeOXzxuy7+y4ZVocFkDV7pQFWLzic2RDo+IiMqpz/d9jmV7l7nSz696HrkFuQ5GRBR9lIqOV6iNHDkSALBgwQJMnz4dV199NVq3bl2qZS1YsADLly9Hly5d8OijjyI7O7pudLBiSFHhzXVvYtCcQcjKz7LlD2s/DF+M+wJXNbrKls/mpEREFCmvr33dlr6QewHL9y53KBoiiqS0tDSMHDkSU6ZMweLFi33eLQxGRkYGHnroIfzmN7/Bf//7X2RkZOCPf/xjiKMtmySnA6DyrUgV4fEVj+Pl71/2mvbolY/ixf4vIkES0K1eN1tvpBuObYhkmEREVE79cvYXfLL7E6/8udvmYlDbQQ5EREShlpeXhwULFnjl9+nTB7Vr18aECRNw5ZVXIi0tDSNGjCjVOh544AHUqFEDf/vb35CamoopU6Zg3LhxGDJkCHr37l3WtxASrBiSY7Lzs3HXorvw4Y4PbfkJkoApN0/Bwz3cba+71+9uK8M7hkREFAlvrX8LCt7t0z7a9RGy8rNQKbmSA1ERUShlZma6xiW0+uqrr9C3b1/06tUL6enpuOmmm3DZZZeVePkzZ87ERx99hNWrVyM1NRUAMHbsWCxcuBD33HMPNm/ejLS0tDK/j7KSWO1Zq3v37mr9elYOYtXJSycxaM4gfH/4e1t+peRKmDtsLm5rfZst/2z2WdR4qYYrnSAJyPxDJg/IREQUNln5WWj4akOczTnrc/q8YfMwvIP3ySRRebBjxw60a9fO6TAiYvPmzejSpQu+/vpr9OnTJ6LrLu5zFpENSqnufguUAJ8xpIjbfXo3rnz3Sq9KYd3KdfHNr7/xqhQCQPXU6mhRvYUrXaSK8NPxn8IeKxERlV+zt8z2WykEdHNSIopfp06dwrfffovf/OY36NKlS8QrhZHGiiFF1OqDq3Hlu1fi57M/2/I71O6ANRPWoFv9bn7nZXNSIiKKFKUUXl9n73Smb9O+tvTSPUuRmZsZwaiIKJIWL16Ma6+9FqdOncK0adOcDifsWDGkiJm7dS6u/8/1OJN9xpbfr1k/rB6/Gk2qNQk4f7d69kojO6AhIqJw+e7Qd9h0fJMrLRC8e/u7aFLVfazKKcjBx7s/diI8IoqAe++9F0VFRdi6dSu6du3qdDhhx4ohhZ1SCi+ufhGjPhyFvMI827S7u9yNZWOWoVrFan7mduMdQyIiipQpa6fY0gPbDETz6s0xssNIW/6crXMiGRYRUdiwYkhhVVBUgIeWPoQnvnjCa9pzfZ/DtEHTkJKYEtSyrqh3hS2949QOXMq7FJI4iYiITEczj3r1mD2pxyQAwMiO9orh8r3LcS7nXMRiIyIKF1YMKWwyczMxcPZAvL3hbVt+ckIyZgyegaf7PA0RCXp5VStWRasarVzpIlVka+ZDREQUClM3TEVBUYEr3aZmG1zf/HoAQNe6XdGyRkvXtPyifCzeuTjiMRIRhRorhhQWRy4cQe/pvbF873JbftUKVbF87HKM6zKuVMtlc1IiIgqnvMI8rwuaE3tMRILoUyYRwagOo2zT2ZyUiOIBK4YUcptPbEavd3t53c1rXLUxvh3/Lfo161fqZXt2QLP+GCuGREQUOgt3LMTxi8dd6coplXH35Xfbyng2J/183+c4lXUqIvEREYULK4YUUp/9/Bmuee8aHL5w2JbfrV43/HDvD+hQp0OZlu95x3DDUfZMSkREoePZ6czdXe5GlQpVbHkd63RE+9rtXelCVYiFOxZGJD4ionBhxZBC5r0f38Mts25BZp59TKeBrQdi5a9Xom7lumVeR9d6XSFwP5e489ROjiFFREQhsfHYRnx36Dtb3sQeE32WZXNSovjw7LPPolatWj6n/frXv0b37t19TotHrBhSmSml8OSXT2LCRxNQqApt0yb2mIhFIxchLSUtJOuqUqEKWtds7V43FDugISKikHhj7Ru29PXNrke72u18lvVsTrrywEpbE1QioljDiiGVSW5BLsYuGovnVz1vyxcIXh3wKqbcPAWJCYkhXSc7oCEiolA7nXUaH2z9wJb3SM9H/JZvXbM1Lq97uStdpIqwYPuCsMVHRLEpOzvb6RCCxoohldqZ7DMY8P4AfLDFfiCtmFQR84fPx++u/F2JhqMIllfFkB3QEBFRGb3747vIKchxpRtXbYzbWt8WcB42JyUqP44dO4bx48ejefPmSE1NRevWrfHkk08iLy/PVWb//v0QEcyaNQvjxo1DtWrVMHDgQNf0d955Bx06dECFChXQpEkTvPTSS068Fb+SnA6AYtMvZ3/BLR/cgp2ndtrya1WqhY9Hf4xeDXuFbd2ePZOyAxoiIiqLwqJCvLnuTVvew90fLrbFy4gOI/DEF0+40t8e+haHzh9Co6qNwhInEYVPQUGBV55SyvX/qVOnUKNGDbz66quoXr06du/ejWeffRYnT57E22/bh7h59NFHMXToUMyfPx+JiXo/8ve//x1//OMf8dhjj6Fv377YsGEDnnrqKVSqVAmTJk0K75sLEiuGVGJrj6zFwNkDkXEpw5bfumZr/PfO/6JFjRZhXb/ZAY2C/rHuOr0LF3IvePUaR0REFIyle5biwPkDrnSFxAqYcMWEYudrVr0ZejboibVH1rry5m+fj99f+fuwxEkUzeS50LcSKw31jCq+kIfTp08jOTnZ57Ru3fQNiU6dOuHll1925V999dVIS0vD+PHjMWXKFKSkpLim9erVC2+84X5m+cKFC3juuefw5JNP4plnngEA9O/fH1lZWZg8eTIeeughVwXSSWxKSiWyeOdi9J3e16tSeE3ja/Dd+O/CXikE9JhSbWu1teVtPLYx7OslIqL49Pra123pOzvdiVqVfPdS6GlkB3snNGxOShR7qlatinXr1nm9brvN3ZxcKYV//OMfaN++PVJTU5GcnIwxY8YgNzcXBw8etC3v1ltvtaW///57XLp0CcOHD0dBQYHr1a9fP5w4cQKHD9uHeXMKK4YUtH+u+SeGzh2K7AL7Q7SjOo7CirtWoGalmhGLheMZEhFRKOw8tRMr9q2w5U3qGXyzrhEdRtjS646uw76z+0ISGxFFRlJSErp37+71qlnTfW77j3/8A48++iiGDBmCJUuWYO3ata67gjk5Obblpaen29KnTp0CAHTo0AHJycmu13XXXQcAOHToUDjfXtDYlJSKVVhUiN9/+nu8tvY1r2l/uOYPmNxvMhIkstcYutfvjpmbZ7rS7ICGiIhKw3OIiisbXokr6l0R9PwNqzTENY2vweqDq11587bNwxPXPBFgLiKKNfPnz8ewYcPw/PPunvi3b9/us6xn54s1atQAAHzyySdelUYAaNOmTQgjLT1WDCmgrPws3PnhnViya4ktP1ES8datb+G+bvc5Ehc7oCEiorK6kHsB03+abssryd1C08gOI20Vw7nb5rJiSOVOaZ7tiyXZ2dmoUKGCLW/WrFlBzXvllVciNTUVR48e9WpmGk1YMSS/Tlw8gYGzB2Ld0XW2/MoplTF/+Hzc1PImhyIDLq97ORIkAUWqCACw58wenMs5h2oVqzkWExERxZaZP83ExbyLrnR6WjqGtR9W4uUMaz8Mv13+W9cxadPxTdh1ahfa1IqOuwBEVHb9+/fHa6+9hl/96ldo0aIFZs2ahb179wY1b7Vq1fDss8/it7/9LQ4cOIDevXujqKgIu3fvxldffYVFixaFOfrg8BlD8mnHyR3o9W4vr0phg8saYPU9qx2tFAJAWkoa2tdub8tjBzRERBQspRReX2fvdOaBbg8gJTHFzxz+1a1cF32b9rXlzd02tyzhEVGUefrppzF69Gg8+eSTGD16NFJSUvDaa96PWfnz2GOPYerUqVi2bBkGDRqE0aNHY9asWbj22mvDGHXJiHV8jljSvXt3tX49nysLh5X7V2Lw3ME4l3POlt85vTOW3rkUDas0dCgyu18v/jVm/DTDlX7phpfwv1f/r4MRERFRrPh83+foP7O/K52UkIQD/3MA9S+rX6rlTd0wFQ988oAr3a5WO2x7eJvXs0ZE8WLHjh1o166d02HEveI+ZxHZoJTq7rdACfCOIdnM2jwL/Wf296oUDmgxAKvuWRU1lULAu2dSdkBDRETB8hyiYmi7oaWuFJrzJyW4n9DZcWoHtmZsLfXyiIgijRVDAqCb1Ez+ZjLGLhqL/KJ827R7u96LT0Z/EnUDyHt2QLP+KCuGRERUvP3n9uPj3R/b8h7p+UiZllmrUi3c0PwGWx6bkxJRLGHFkJBfmI97P7oXT331lNe0v/b7K6YOnIrkxGQHIgusS90uSJREV3rf2X04m33WwYiIiCgWvLXuLVdHMQDQJb0Lrm50dZmX6znY/dxtcxGrj+wQUfkT0YqhiLQRkU2W1wUR+R8RqSEiK0Rkj/G3eiTjKs/O55zHrR/civc2vWfLT0lMwayhs/CHa/8Qtc9HVEquhA51OtjyNhzjsBVERORfdn423vnxHVvepJ6TQnKsG9x2sK3zmr1n9rJjNCKKGRGtGCqldimlLldKXQ6gG4AsAIsAPAHgC6VUKwBfGGkKs+z8bPSd0Rcr9q2w5VevWB0r7lqBOzvd6VBkweN4hkREVBJzts7BmewzrnT1itVDdryrVrGaV6/dbE5KRLHCyaak1wP4WSl1AMAgAGb3kjMADHYsqnLk9bWvY9PxTba8ZtWa4fsJ36N3k94ORVUy7ICGiIiCpZTClLVTbHkTuk5ApeRKIVsHm5NSecJtO7wi/fk6WTEcBWC28X+6UuqY8f9xAOnOhFR+KKVsQz0AQM8GPbHm3jUxNSCvV8WQHdAQEZEf3x/+Hj8e/9GVFgge6vFQSNdxe5vbkZqU6kofPH8Qaw6vCek6iKJBcnIysrOznQ4jrmVnZyM5OXL9fDhSMRSRFAC3A5jvOU3pqrHP6rGI3C8i60Vk/cmTJ8McZXzbfGIztp3c5konSiI+GvUR6qTVcTCqkuuc3tnWPfj+c/txOuu0gxEREVG08hyi4tbWt6J59eYhXUfllMq4tfWttjw2J6V4VKdOHRw5cgRZWVm8cxhiSilkZWXhyJEjqFMncufmScUXCYubAWxUSp0w0idEpJ5S6piI1AOQ4WsmpdRUAFMBPcB9ZEKNT+9vft+WvrHljUivHHs3aismVUTHOh1tTWI3HNuAAS0GOBgVERFFm2OZxzB/u/169KQek8KyrpEdRmLB9gWu9Pzt8/Hqja8iQdgZPMWPKlX0MGZHjx5Ffn5+MaWppJKTk5Genu76nCPBqYrhaLibkQLARwDuBvCC8XeJE0GVF4VFhfhg6we2vLGdxjoUTdl1q9fNVjFcf3Q9K4ZERGTz743/RkFRgSvdumZr9G/RPyzruqXVLUhLTsOl/EsAgKOZR7H64OqYeX6fKFhVqlSJaMWFwivil65EJA1AfwALLdkvAOgvInsA3GCkKUy+2v8VjmYedaUrp1TGoLaDHIyobDyfM+SQFUREZJVfmI9/rf+XLW9ij4lhu4NXKbmS13F1ztY5YVkXEVGoRLxiqJS6pJSqqZQ6b8k7rZS6XinVSil1g1LqTKBlUNl4NiMd2m5oSHtkizR2QENERIEs3LEQxy4ec6XTktNwd5e7w7pOz95JF2xfYLtjSUQUbdjYvZzJys/Chzs+tOXd1fkuh6IJjU51OiE5wd1j08HzB3HyEjsnIiIi7fV19k5nxnUZh6oVq4Z1nTe2uBFVK7jXcTLrJL7e/3VY10lEVBasGJYzS3YuwcW8i650vcr1cF3T6xyMqOwqJFVAp/ROtjw2JyUiIgDYdHwTVh9cbcub1DM8nc5YVUiqgCHthtjy2JyUiKIZK4blzPtb7M1I7+x0JxITEh2KJnS612NzUiIi8vbG2jds6X7N+qF97fYRWbdnc9KFOxYirzAvIusmIiopVgzLkYxLGfh076e2vLGdY7c3Uqtu9bvZ0rxjSEREZ7LPYNaWWba8cA1R4cv1za5HzdSarvTZnLP4fN/nEVs/EVFJsGJYjszdOheFqtCV7linI7qkd3EwotBhBzREROTpvR/fQ3ZBtivdqEojDGwzMGLrT05Mxh3t7rDlsTkpEUUrVgzLkZmbZ9rSYzuNhYg4FE1odazTESmJKa704QuHceLiCQcjIiIiJxUWFeLNdW/a8h7u8TCSEiI7hPPIjvbmpIt3LkZOQU5EYyAiCgYrhuXErlO7sO7oOlvenZ3udCia0EtJTEHn9M62PDYnJSIqv5btXYZfzv3iSldIrIAJXSdEPI4+TfogPS3dlc7My8TyvcsjHgcRUXFYMSwnPJ+x6Nu0LxpVbeRQNOHBDmiIiMg0Ze0UW3pUx1GonVY74nEkJiRiePvhtjw2JyWiaMSKYTmglPIa1D7Wxy70hR3QEBERoFvJfPbzZ7a8SAxR4Y9nc9KPd3+MS3mXHIqGiMg3VgzLge8OfefVnMbzYfh4wA5oiIgIgNezhb0a9vI6RkTSVY2uQoPLGrjSWflZWLpnqWPxEBH5wophOeB5t/D2NrejasWqDkUTPh1qd0CFxAqu9NHMoziWeczBiIiIKNIyczMx/afptrxIDlHhS4IkYESHEba8udvmOhQNEZFvrBjGubzCPK+DTzw2IwV0t+Bd6tqH32BzUiKi8mXm5pm4kHvBla6TVgfD2g9zMCJtVMdRtvTS3UttcRIROY0Vwzi3bM8ynM0560rXTK2JG1ve6GBE4cUOaIiIyi+lFF5f+7ot7/4r7keFpAp+5oicHvV7oFm1Zq50bmEuPtr1kYMRERHZsWIY5zzHLhzZYaRtvL9449kBDSuGRETlx1f7v8KOUztc6URJxIPdH3QwIjcRYXNSIopqrBjGsXM55/Dx7o9teWM7j3Uomsjw7Fxgw7ENUEo5FA0REUWS593Coe2GokGVBn5KR55nc9JP936Ks9ln/ZQmIoosVgzj2ILtC5BXmOdKt6jeAr0a9nIwovBrX7s9KiZVdKWPXzyOo5lHHYyIiIgi4cC5A1iya4ktz8khKnzpkt4FrWu2dqXzi/KxaOciByMiInJjxTCOefZGOrbzWIiIQ9FERlJCEi6ve7ktjx3QEBHFv3+t/xeKVJEr3alOJ1zb+FoHI/ImIhjZwT6mIZuTElG0YMUwTh04dwArD6y05Y3pNMahaCKLHdAQEZUvOQU5+PfGf9vyHun5SFReDPVsTvrFvi9w8tJJh6IhInJjxTBOfbDlA1v6Vw1+hVY1WzkUTWRxoHsiovJl7ta5OJ192pWuVrEa7ux0p4MR+de+dnt0rNPRlS5Uhfhwx4cORkREpLFiGIeUUl69kcbr2IW+ePZMyg5oiIjil1IKU9ZOseWNv3w80lLSHIqoeGxOSkTRiBXDOLTp+CZbd91JCUleXWTHs7a12qJSciVXOuNSBg5fOOxgREREFC4/HPnB9iy5QPBwj4cdjKh4nhXDlftXsqM0InIcK4ZxyPNu4U0tb0LttNoORRN57ICGiKj88Byi4pZWt6BFjRYORROcVjVb4Yp6V7jSCgoLti9wMCIiIlYM405BUQFmb51tyxvbKb7HLvSFHdAQEcW/ExdPYN62eba8aBuiwh82JyWiaMOKYZz58pcvcfzicVf6spTLcHub2x2MyBnsgIaIKP5N3TAV+UX5rnSrGq0woMUAByMKnucjHt8d+g4Hzx90KBoiIlYM447n2IXD2g9DanKqQ9E4hx3QEBHFt/zCfPxrw79seRN7TESCxMapTdNqTdGrYS9bnufdTyKiSIqNvScF5VLeJSzcsdCWN7Zz+WtGCgBtarZBWrK7R7pTWad4JZaIKI4s3rnY1mFLWnIa7r78bgcjKjk2JyWiaMKKYRxZvHMxLuVfcqUbXNYAfZr0cTAi5yQmJNoe7AfYnJSIKJ68vs7e6cxdne9CtYrVHIqmdIa3Hw6BuNLrj67Hz2d+djAiIirPWDGMI+9vsTcjHdNpDBITEh2Kxnnd6nk3JyUioti3+cRmfHPgG1vexJ4THYqm9BpUaYBrm1xry+NdQyJyCiuGceLExRP47OfPbHnltRmpiR3QEBHFJ88hKq5reh061unoUDRlw+akRBQtWDGME7O3zkaRKnKlO6d3Rqf0Tg5G5Dx2QENEFH/OZp/16mgtVoao8OWOdnfYOszZfGIzdpzc4WBERFResWIYJzwPkuVx7EJPrWu2RuWUyq70mewz2H9uv3MBERFRmU3bNA3ZBdmudMMqDWN6WKb0yuno16yfLY93DYnICawYxoEdJ3fYnp8TCO7sdKeDEUWHBEnwes6QzUmJiGJXkSrCG+vesOU91P0hJCUkORRRaPhqTsoWLkQUaawYxoFZW2bZ0v2a9UODKg0ciia6sAMaIqL4sWzPMuw7u8+VTklMwX1X3OdgRKExtN1QW+V256md2JKxxcGIiKg8YsUwxhWpIu9mpOW80xkrdkBDRBQ/PIeoGNVxFGqn1XYomtCpkVoDA1oMsOXN2TrHoWiIqLxixTDGfXvwWxw4f8CVrphUEUPbDXUwoujiWTFkBzRERLFpz+k9WL53uS1vUo/Y7XTGE5uTEpHTWDGMcZ53Cwe3HYwqFao4FE30aVGjhe3zOJdzztYMiYiIYsOb6960pXs26IkeDXo4FE3oDWozCCmJKa70vrP7+PgDEUUUK4YxLLcgF/O2z7PlsTdSO3ZAQ0QU+y7mXcR7m96z5T3S8xGHogmPqhWr4pZWt9jy2JyUiCKJFcMYtnTPUpzLOedK16pUy+sZBWIHNEREse79ze/jQu4FV7p2pdoY3n64gxGFh2dz0nnb5tnGKCYiCidWDGOYZzPSUR1GITkx2aFoohc7oCEiil1KKby+1t7pzP3d7keFpAoORRQ+t7W+DalJqa70oQuHsObwGgcjIqLyhBXDGHUm+wyW7llqy7ury10ORRPdfHVAwyuwRESxYeWBldh2cpsrnSiJeLD7gw5GFD6VUyrjtta32fLmbuVg90QUGawYxqgF2xcgrzDPlW5VoxV61I+fh/BDqXn15qhWsZorfSH3An4+87ODERERUbCmrJ1iSw9pNwQNqzR0KJrwG9VxlC09b/s8FBYVOhQNEZUnrBjGqJmbZ9rSYzuPhYg4FE10ExF2QENEFIMOnj+IxTsX2/LiaYgKX25ueTMqp1R2pY9fPI5VB1c5GBERlRcRrxiKSDURWSAiO0Vkh4hcKSI1RGSFiOwx/laPdFyx5Jezv2D1wdW2vDGdxjgUTWzgc4ZERLHn7fVv25r+d6zTEb2b9HYwovBLTU7FoDaDbHlsTkpEkeDEHcN/AliulGoLoAuAHQCeAPCFUqoVgC+MNPnxwZYPbOmrGl2FFjVaOBRNbGDPpEREsSWnIAdTN0615U3qMalctI7xbE66YMcCFBQVOBQNEZUXEa0YikhVAL0BvAsASqk8pdQ5AIMAzDCKzQAwOJJxxRKlFN7fYu+NlGMXFs/zjuHGYxvZAQ0RURSbt20eTmWdcqWrVqiKsZ3Lx/FuQIsBtmfjT2Wdwpe/fOlgRERUHkT6jmEzACcBTBORH0XkHRFJA5CulDpmlDkOIN3XzCJyv4isF5H1J0+ejFDI0WXDsQ3YeWqnK52UkIQRHUY4GFFsaFqtKapXdLdQzszLxJ7TexyMiIiIAvEcomJ81/FIS0lzKJrISklMwZC2Q2x5bE5KROEW6YphEoArALyllOoK4BI8mo0qpRQA5WtmpdRUpVR3pVT32rVrhz3YaOQ5duEtrW5BzUo1HYomdohI2J8zLCwEZs0Cnn8e2L8/pIsmIipX1h5Zi3VH19nyHu7xsEPROMOzOenCnQttvZETEYVapCuGhwEcVkr9YKQXQFcUT4hIPQAw/mZEOK6YUFBUgNlbZ9vy7urMsQuDFe6K4SuvAGPHAk8+CVx3HXD+fEgXT0RUbnjeLby55c1oWaOlQ9E4o1+zfqhVqZYrfS7nHD77+TMHIyKieBfRiqFS6jiAQyLSxsi6HsB2AB8BuNvIuxvAkkjGFSs+3/c5Mi6568xVKlTxGgiX/AtnBzQFBbpiaNq/H3jrrZAtnoio3Mi4lIG52+zNJh/p+YhD0TgnKSEJd7S7w5bn+bkQEYWSE72SPgJglohsBnA5gL8CeAFAfxHZA+AGI00ePMcuHN5+OComVXQocfLyVwAAIABJREFUmtjjqwOaUA0avHIlkOFxn/sf/wByckKyeCKicuPfG/5tazLZonoL3NjyRgcjco5nc9LFOxcjOz/boWiIKN5FvGKolNpkPCfYWSk1WCl1Vil1Wil1vVKqlVLqBqXUmUjHFe0yczOxaMciW1556Z0tVBpXbWxrlnMp/xJ2nd4VkmXPmeOdd+IEMGOGdz4REflWUFSAt9bbm1tM7DERCeLEdWznXdv4WtStXNeVvph3Ecv2LnMwIiKKZ+VzTxuDFu9cjOwC91XCRlUaxf0gv6EmIt7NSY+WvTlpXh6wcKHvaS+9pJuZEhFR8ZbsXIIjmUdc6UrJlXBP13scjMhZiQmJGN5+uC2PzUmJKFxYMYwRnmMXjuk0ptxeQS2LcHRA8/nnwBk/97j37QM+/LDMqyAiKhemrJ1iS9/V+S7beH7lkWdz0o93fYyLeRcdioaI4hlrFjHgWOYxfL7vc1sem5GWTjg6oPFsRpqcbE+/8AKgfA7AQkREpi0ntmDlgZW2vIk9JjoUTfTo1bAXGlVp5EpnF2Tjk92fOBgREcUrVgxjwOyts1Gkilzpy+tejg51OjgYUezyvGP44/EfUVBU+raeOTnA4sX2vNdeA0Tc6U2bgM/YwzgRUUBvrHvDlu7TpA86pXdyKJrokSAJGNFhhC2PzUmJKBxYMYwBnoPac+zC0mtYpSHqpNVxpbPys7Dz1M5SL2/ZMiAz052uWxe47z5g6FB7uRfYzy4RkV/ncs559bw9qeckh6KJPiM7jLSll+1ZhvM5HCyXiEKLFcMoty1jG348/qMrnSAJXs8bUPBC3QGNZzPS4cOBxETg8cft+V9/DfzwQ6lXQ0QU16Zvmo6s/CxXumGVhhjcdrCDEUWX7vW7o3n15q50bmEuluzikM9EFFqsGEY5z7uF1ze7HvUvq+9QNPEhVB3QXLoEfOLxmMcoo87eowdw/fX2aS++WKrVEBHFtSJV5NWM9MFuDyIpIcmhiKKPiHjdNWRzUiIKNVYMo1iRKsKsLbNseex0puy8KobHSlcx/PhjIMt9gRuNGgG9ernTnncNFy0Cduwo1aqIiOLWp3s/xd4ze13plMQU3NftPgcjik6eFcPPfv4MZ7I57DMRhQ4rhlFs1YFVOHThkCtdKbkShrYbGmAOCoZnU9JNxzeVqgMaz2akI0cCCZZf1A03AFdcYS/z97+XeDVERHHNc4iKER1G2J4FJ61zeme0rdXWlS4oKsDCHX4G0SUiKgVWDKOYZzPSwW0Ho3JKZYeiiR/1L6uPupXrutI5BTnYfnJ7iZZx/rzueMZqlMejnyLAE0/Y895/Hzh0CEREBGDjsY1Ytte+M32k5yMORRPd2JyUiMKNFcMolVOQg/nb59vyxnZiM9JQCEUHNIsXA3l57nSLFt53BwHdO2nLlu50fj7wf/9XolUREcWtP6/8sy3dq2Ev9GzQ06Foop9nxfDLX75ExqUMh6IhonjDimGU+mT3Jzif6+6Kuk5aHfRv0d/BiOJLWTug8WxGOmqUfexCU2Ii8Nhj9rypU4HTp0u0OiKiuLPp+CavnjWf7v20Q9HEhna126FzemdXukgVYcH2BQ5GRETxhBXDKOXZjHR0x9HsoS2EytIBzalTwIoV9jzPZqRW48YB9eq505cuAW+84b88EVF54Hm3sEf9Hrip5U0ORRM72JyUiMKFFcModDrrNP6757+2PPZGGlqeTUl/Ov4T8gvzg5p34UKgsNCdbt8e6NjRf/kKFYDf/c6e99pruoJIRFQebT6xGYt2LrLlPdPnGYivphdk41kxXHVgFY5cOOJQNEQUT1gxjELzts1DfpG7ktKmZhuvigyVTb3L6tnGg8wtzMW2k9uCmtdXM9LiPPAAULWqO336NPDee0Gtjogo7njeLexevztuaXWLQ9HElhY1WthavSgorz4JiIhKgxXDKPT+Fnsz0rGdx/IqahiU5jnDY8eAr7+2540c6bOoTZUqwMMP2/Nefll3RkNEVJ5sObEFH+740Jb3dO+neZwrATYnJaJwYMUwyuw7uw/fHfrOljem0xiHoolvpemZdMECQCl3umtXoHXr4Nb329/qZqWmgwe97z4SEcW7v3zzF1v6inpX4LbWtzkUTWwa0WGELb3m8BocOHfAoWiIKF6wYhhlZm2eZUtf0/gaNKvezKFo4ltpOqApTTNSU3o6MH68Pe/FF4GiouCXQUQUy7ZlbPPqRZN3C0uucdXGuKrRVba8edvmORQNEcULVgyjiFIKMzfPtOVx7MLw8bxjuPnEZuQV5vkpre/wfWe/mYsRI3yX9efRR4EEy69u2zZg6dKSLYOIKFb95Zu/QMHd7OLyupfj9ja3OxhR7PJsTjpnG5ugEFHZsGIYRdYdXYc9Z/a40imJKRjeYbiDEcW39MrpaFiloSudV5iHrRlb/Zaf53ExtlcvoGnTkq2zeXPvZxJfeKFkyyAiikXbT273uqvFu4WlN6z9MAjcn93GYxux98xeByMioljHimEU8Ry78NZWt6JGag2HoikfStIBTVmakVo9/rg9/d13wOrVpVsWEVGsmPzNZNvdws7pnTGo7SAHI4pt9S+rj95Netvy5m5lJzREVHqsGEaJ/MJ8zNlqr3lw7MLwC7YDmr17gQ2WSSLA8FLezO3SBbj5Znse7xoSUTzbeWqn1zHu6d5PI0F4GlIWozrar1CyOSkRlQX3yFHis58/w8msk650tYrVOKZTBATbAc1cj4uwvXsD9ev7LBqUJ56wp5cuBTZvLv3yiIiimefdwk51OmFIuyEORhQf7mh3BxIl0ZXemrEV209udzAiIoplrBhGCc+xC4e3H46KSRUdiqb88LxjuOXEFuQW5HqVC1UzUtO11+pnFK1eeqlsyyQiika7T+/G7K2zbXlP9+HdwlConVYb/Zr1s+WxOSkRlRb3ylHgQu4FLN652JZ3V+e7HIqmfKmdVhuNqzZ2pfOL8rElY4utzLZtwFZLnzSJicAdd5RtvSLedw3nzAF++aVsyyUiijaTv5mMIuUel6djnY4Y2m6ogxHFF1/NSZV1wF0ioiCxYhgFFu1YhJyCHFe6SdUmuLrx1Q5GVL4U1wGNZzPS668Hatcu+3oHDgTatXOnCwuBV14p+3KJiKLFntN7MGuLfXzep3o/xbuFITSk7RAkJyS70rtP78ZPJ35yMCIiilXcM0cBz7ELx3Qaw4NmBAXqgEap0DcjNSUkePdQ+u67QEZGaJZPROS051c9b7tb2L52ewxrP8zBiOJP9dTqGNBigC2PzUmJqDRY+3DYkQtH8OUvX9ry2BtpZAXqgObHH4E97qElkZwMDAlhfwmjRwONGrnTOTnAa6+FbvlERE7Ze2av1zBMvFsYHmxOSkShwL2zw2ZvnW3rqa1bvW5oV7tdgDko1DzvGG7N2Opq2uvZjPSmm4Bq1UK37pQU4P/9P3veG28AmZmhWwcRkROeX/U8ClWhK922VlsMb1/KcX4ooNvb3I4KiRVc6f3n9mPd0XUORkREsYgVQ4d5Xk3l3cLIq1mpJppWa+pKFxQVYPOJzWFtRmp1771AjRru9LlzwNSpoV8PEVGk/HzmZ8z8yf6YxFO9n0JiQqKfOagsqlSo4jXEFZuTElFJsWLooC0nttgeEE+QBK/mIBQZvjqgWbMGOHjQnZeaCtx+e+jXnZYG/OY39rxXXwVyvUfNICKKCX9d9Vfb3cI2NdtgZIeRDkYU/zzPH+Ztn2d7vpOIqDisGDrI827hgBYDULdyXYeiKd+617NXDDcc3eDVjPTWW4HKlcOz/kmTgEqV3OmjR4H33/dfnogoWv1y9hf8Z/N/bHlP9n6SdwvD7NZWt6JSsvtAcvjCYXx36DsHIyKiWMOKoUOKVJFXF95jO7EZqVO61bc/Z7j+6HrMm2cvE45mpKaaNYH77rPnvfSSHsKCiCiW/HXVX1FQVOBKt6rRiq1hIiAtJQ0DWw+05bE5KRGVBCuGDlm5fyWOZB5xpdOS0zC47WAHIyrfvDug2YZjJ7Nd6cqVgVtu8ZwrtH7/eyApyZ3evRtYvDi86yQiCqX95/Zj+k/TbXlP9n4SSQlJvmegkPJsrrti3wqHIiGiWMSKoUM8xy4c0m4I0lLSHIqGqqdWR/PqzV3pIhQCdd3Pfw4apJ8xDKfGjYExY+x5L7ygx1IkIooFf1v1N9vdwpY1WuLOTnc6GFH5ckPzG5Ao7ia7u07vwtHMow5GRESxhBVDB2TnZ2PB9gW2vLs63+VQNGTy7IAG9d3jGYazGanVY4/Z0+vXA19+6bssEVE0OXj+IKZtmmbL+9O1f+Ldwgi6rMJl6NGghy3v6/1fOxMMEcUcVgwd8PHuj5GZ5x6orm7luujXrJ+DERHg3QGNWTGsVg0YMCAyMbRvr+9OWr34YmTWTURUFn9b9TfkF+W70s2rN+cQTA7o26SvLc2KIREFK+iKoYjcISITLOlmIvKdiJwTkQ9FJITDfsc3z95IR3cczSuqUcCzAxrU2wAAGDpUD0QfKU88YU+vWAFs2BC59RMRldSh84fw7o/v2vJ4t9AZ1zW7zpb+av9XDkXin1LAkiXAgw96jxdMRM4pyR3DJwFUsaSnAKgF4AUAVwD/n737jo+q2hY4/tvpIfQOUkVBqvTekSKCYMF2ETsXsVxFBQG96vWigmJXiu0CdsWn2CgiRXqRroIgIL0HCOnJfn+cTCZ7Jm2SmTkzk/X9fOYT9p4zM8v7Hkz22WuvxSQvxhWyTlw4wY+7fzTm5I5qYGhdo7U5UeU3iLzgtzRSh44doUcPc052DYUQgeyFFS8Yu4X1y9eXIxI26VK7i7Eg3316NwfPHbQxItOBAzBoEAwdCjNmwM03w5dfFvw6IYTvebIwvBjYBqCUKgf0Ax7WWr8ATAQG5/NakeXzHZ8bB/ObVGlCq+qtbIxIOJSPKU/N6EudE2GZlL9sC7165f0aXxk3zhx/+SX8+af/4xBCiIIcPHeQdze9a8xN6DaByPBImyIq2eKi4mh/UXtjLhDSSTMzrYVg06bwww/mcy++aE9MQgiTp2cMHfURewAZwE9Z44NAFW8FFco+3GamkQ5vPhyllE3RCFeRJ8x00qZ9NxgtJPxlwABo0cI51lq+OIUQgWnyismkZqRmj+uWq8uIy0fYGJHoVc8lnXSvvemku3dDnz5W6uj58+7Pr1sH27b5Py4hhMmTheEW4B9KqTjgbmCJ1jol67k6wPHCvIlSap9SaptSarNSakPWXEWl1CKl1J9ZPyt48h8RLHaf3s2ag2uMOSnjHTgSE+HIRrMATdylG/K42reUcj9rOGsWHJaq40KIAHL4/GHe+fUdY25it4lEhfvxYLZw47YwtOmcYUYGTJ1q3ehcujT/a997L//nhRC+58nCcAJwDXAOa8fw6RzPDQXWevBevbTWLbXWjt/CHwcWa60vBRZnjUOOa9GZ7nW7U7d8XZuiEa6+/x5S95s7hgcz7Kv6MmwY1K/vHKemwquv2haOEEK4mbxiMikZKdnjOuXqcFvL22yMSAB0qt2JyDBnKu/e+L3sj9/v1xi2b4fOneHRRyEpyXwuLs69DdScOZCSghDCRoVeGGqtV2DtDLYH6mqt1+V4+n2s4jRFNQSYlfXnWVgLzZCitXZbGMrB/MDy2WfAEbMAze8nfychNcGWeCIi4LHHzLnp0yE+3pZwhBDCcOT8EWb+OtOYm9B1guwWBoBSkaXoWKujMeevc4apqfDMM9C6tZUi6qpfP9ixAz74ACrkyA87fdqqVCqEsI9HZwy11ue11hu11vEu8z9orXcV9m2AhUqpjUqpkVlz1bTWR7L+fBSo5klcwWDtobXsObMnexwVHsX1Ta63MSKR07lz1o4hKWXhZKPseY1m05FNtsV1++1QtapzfP48TJtmWzhCCJFtysopJKcnZ49rl63NHa3usDEikZMd6aTr10PbtvD005CWZj5Xvry1GJw/H+rWhZgYGO5SlF3SSYWwl0cLQ6VUTaXUSKXUf5RSU1wehS2o31Vr3Rq4ErhPKdU955Naa42zyI3r549USm1QSm04ceKEJ6HbznW3cHDDwZSPkdaPgWLePEh2/H5z2Ewn3XjEvnTS2Fh46CFz7tVX3dNyhBDCn44mHGX6xunG3Piu42W3MID0rNfTGC/ZtwTrVyzvS0qCsWOtdku5FZG55hr47TfrZmfOent33WVet2gR7PdvxqsQIgdPGtxfA/wFvAXcBQzL5VEgrfWhrJ/Hgf/DSk09ppSqkfU5NcijkI3WeqbWuq3Wum2VKsFTBDU1I5VPt5sdXKV3YWAxGuweNgvQbDhsTwEah3vvhTJlnOPjx+F//7MtHCGE4MWVLxq7hbXK1uLOVnfaGJFw1al2J6LDo7PHf5/9m33x+7z+OcuXW8VlXnzRakmRU9Wq8PnnMHcu1Kjh/trLL4c2Oe7Fai3fb0LYyZMdw+eAhVhpnxdpreu7PC4u6A2UUnFKqTKOP2P1QtwOzAMcp9VvA0Iqy3zB7gWcSjqVPa4YW5GBlw60MSKR0+nTsHBhjgmXhaGdO4Zgpd+MGmXOvfgipKfnfr0QQvjSsYRjTNtg5rQ/3uVxoiOi83iFsENMRAydancy5ryZTnr+PIweDT16WO0oXN16q7VLOGyYuUvoynXX8P33rWqmQgj/82RhWBt4XWt9uhifVw1YoZTaAqwDvtdazwdeAPoqpf4ErsgahwzX3oU3NLlB0m0CyP/9n3kW4tIyrVA4v8V2ntzJuZRzNkTm9NBDEJXj/2X27oUvvrAvHiFEyfXSqpdISnfms9csU5O7Wt+VzyuEXXx1znD+fKtRfW5n3mvVss7sz54NlSoV/F4332ydN3T4+29YvNgrYQohPOTJwnAV0KjAq/Khtf5La3151qOp1npS1vwprXUfrfWlWusrirn4DChnk88yb+c8Y07SSAPLp2aWLzdfV5rLKl+WPba7AA1AzZpwm0sF+BdesNJuhBDCX45fOM7bG9425h7v8jgxETF5vELYyfWc4dJ9S4t1zvD0aeu76Mor4cAB9+fvvdeqODrQg6So8uXhepdafFKERgh7eLIwHAOMVErdllWEppTrw1dBBrO5v881zmHUL1+fzrU72xiRyOn4cfj5Z3PuxhuhTc3AKUDj8NhjZjrO1q3WXVshhPCXl1a9RGJaYva4Ruka3NPmHhsjEvnpcFEHY9F+8NxBo0K6J778Eho3tnYCXV1yidXA/u23oWxZz9/77rvN8ddfw6lTuV8rhPAdTxaGW4HmwAfAAeB8Lg/hwrUa6fAWw1H5JdsLv/ryS/OwfIsW0KQJtK0RWAVoAC691P2u6uTC1gIWQohiOnHhBG+tf8uYG9dlnOwWBrDoiGi61O5izC3Z61k66dGjcN111lnB4y6lAcPCrAb2W7ZYZw2Lqnt3a3HpkJoKH36Y9/VCCN/wZGF4J3BH1uPOPB4ihwNnD7g1lP1H83/YE4zIlWsa6Y03Wj/b1gy8hSHAuHHmeNkyWL3anliEECXL1NVTjd3C6qWrM7LNyHxeIQKBWzrp/qWFep3WMGuWdbP0q6/cn2/WDNassYqhlSpmzphScKfLb5HvvSfHJYTwt4jCXqi1/p8P4whJn2z/BJ2jJWO7mu1oVLlYxzSFFx08CCtWmHOOhWHL6i0JU2Fkams78c/Tf3I2+SzlYsr5OUpTmzbQt6/V68lh8mQr7UYIIXzlZOJJ3lz3pjE3tvNYYiNjbYpIFJZbAZq9Vj/D/LKX9u+Hf/4TFixwfy4yEiZOhPHjzaJoxXXbbfDEE84snm3bYMMGaNfOe58hhMifRw3uIbvJ/XVKqXuyftb0RWDBTmvNnK1zjDkpOhNYvvjCvBvZrh00aGD9OS4qjsaVGxvX/3rkVz9Gl7fHHzfH33xjlQQXQghfeXn1y1xIu5A9rhZXjX+2/aeNEYnCandRO0pFOrf0jiQcYdepXblem5kJb71l7Qbmtihs1w5+/RWeesq7i0Kwiqy5Fq2RIjRC+JcnDe7DlVJvA/uBL4AZWT/3K6XeUkp5vMgMZVuPbWX78e3Z43AVzk3NbrIxIuEqrzRSB9d00kAoQAPQqxe0NUNjyhR7YhFChL5Tiad4Y90bxtxjnR8zFhsicEWFR7mdM3Q95gKwa5d1TvD++yEhwXwuJsZKGV21ylo0+oprT8OPP4YLF3K/VgjhfZ4s5p7BOkc4AagHxGb9nJA1/7R3QwturkVn+l/Sn6pxVW2KRrjauxfWrTPnbrjBHLepYVYmDZRzhkq57xp+9JHV+0kIIbztlTWvkJDqXClUKVWFUW1H2RiR8FR+/QzT060jCS1auB+vAKswzNatVpGZiEIfQCqaq66CatWc4/PnrSJxQgj/8GRhOAJ4Qmv9otb6b611StbPF4Engdt9EmEQysjM4OPtHxtzw5tLGmkg+ewzc9y1K9Subc4FagEagKFDoWFD5zg9HV5+2b54hBCh6XTSaV5f+7ox91jnx4iLirMpIlEUveqbC0NHP8OtW6FjR+tmY0qK+ZoyZawG9kuWWFWx/SEy0r1nr6STCuE/niwMq2K1rMjN1qznBfDj7h85fP5w9rh0VGmGXDbExoiEq4LSSAEur345YTkypPec2cOZpDM+jqxwwsNh7Fhz7p13pO+TEMK7Xl3zKudTnd2oKpeqzOh2o22MSBRFmxptiIt0LuaPXTjG6Kf+oE0b2JjLKYkrr7Qa1Y8aZbWk8CfX6qS//GKluQohfM+Tv+67gLwOyd0E7Cx+OMFPa82kXyYZc9c1vk7OYgSQP/6wei45hIW59wcEKBVZiqZVmhpzgVKABmD4cOuwvkNiIrz5Zt7XCyGEJ84kneG1ta8Zc492elR2C4NQZHgk3ep2M+amz19Cerp5XcWKMGcOfP+9exaNvzRqZGXx5PT++/bEIkRJ48nC8L/A7Uqpn5RSo5RS1yil/qmU+gm4Lev5Em/JviWsObjGmHuo40M2RSNy45pG2qsXVK+e+7WBnE4aHQ1jxphzr78uB/WFEN7x2trXOJdyLntcKbYS97W/z8aIRHF0qWmmk1LPbHQ/bJhV4Xr4cOssu51ci9DMmoXbIlYI4X2FXhhqrT8HBgBxwGvAXOB1oBQwQGv9hU8iDDL/XW6uj6+69CpaVm9pUzTCldaFSyN1cC1AEyiVSR1GjoTy5Z3j06fh3Xfti0cIERrik+N5dc2rxtyjnR+ldFRpmyISxbFkCUwb19OcrLcUVCbVq1sN7D//3Cz8Yqdhw6wzjg5Hj8IPP9gXjxAlhUeZ41rrhVrrTlgVSasDsVrrzlrrRQW8tERYfWC1UekLYGK3iTZFI3KzbZuVSuoQEQHXXpv39YG8YwjWF+f995tzU6dCaqo98QghQsPra1/nbMrZ7HHF2Irc1052C4PN2bNWo/reveHwxtaQkmO1FXeSoff8xm+/wTXX2BdjbuLi4CaXw0ty01MI3yvSkWKtdabW+rjWOtPbAQUz17OFvev3plPtTjZFI3LjulvYrx9UqpT39S2qtSBchWeP98bv5XTSaR9FVzQPPGD1mHI4cAA++cS+eIQQwe1s8lleWfOKMfdIp0coE10mj1eIQPTdd9C0KcycmTWRGQH7uxvX9L5zCRUq+D+2wnBNJ/3hBzhyxJ5YhCgp8l0YKqWmKKVq5fhzfo/J/gk5MG06sonv//zemJPdwsDiaRopQGxkLM2qmt18Nx4OrHTSqlXdv0AnT4ZMuW0jhCiCN9a9QXxyfPa4QkwF7m9/fz6vEIHk1Cn4xz9g8GA4dMjlyb159zMMNO3bQ7McX78ZGdZZQyGE7xS0YzgMcOyn3JA1zu9RYj234jlj3KlWJ7eGssJeGzZYje0doqNhSCG6iAR6OinAI49YLSwcfv8dvv3WvniEEMHpXMo5Xl5tNkUd02kMZaPL2hSR8ERqKgwcCB9/7P5cw4bw7hM9jbll+5eRGaDJX0q53/R8/33rJq8QwjfyXRhqretrrbdk/ble1jivx8X+CTnw/H7id+b+NteYm9htIsrusl7C4LpbOHAglCtX8OsCvQANQP367ucxXnhBvkCFEJ55c92bnEl29mstH1OeB9o/YGNEwhNz58K6deZceLjVwH7zZrh9QEvKxzgrlp1OOs22Y9v8HGXhDR9uNb13+PNPq6+hEMI3Cn3GUCk1QimV62kspVRFpdQI74UVXJ5f8Twa52/gLau3ZOClA22MSLjKzHRvU+G6kMpLMOwYAowbZ47XrJEvUCFE4Z1POc/U1VONuYc7Pky5mELcQRMB4f/+zxw3awZr18Lzz0NsLISHhdO9rnnOMJDTSStXhqFDzbn33rMnFiFKAk+Kz3wANMjjufpZz5c4f535i4+3mTkbslsYeFatMs9alCoFV11VuNe2qNaCyDDnLcv9Z/dzMvGklyMsvubN3f+bXnjBnliEEMHnrfVvGcW1ykWX48EOD9oYkfBEcjL8+KM5N3MmtDGTXuhZt6cxXrpvqU/jKi7XdNIvvrCqrQohvM+ThWF+K51KwLl8ng9Zk1dMJkNnZI8vq3wZ1zbOp/+BsIVrGunVV1vlsAsjOiI64AvQODz+uDn+8UfYssWeWIQQwSMhNYGXVr1kzD3U8SEj7VAEtp9+goQE57hGDejQwf26XvXN+gfL9i8jIzPD/cIAccUVULu2c5yUJJW3hfCVgqqSDlFKva+Uej9r6knHOMfjY+A9YL3Pow0wh84d4n9b/mfMje86njBVpC4gwkfS0607jDkVNo3UIVjSSbt2hS5dzLnJJbpesBCiMN5e/zankk5lj8tGl+VfHf5lY0TCU65ppEOGQFguv460qNaCCjHOHhXxyfFsORa4dxDDw+GOO8w5SScVwjcKWsFUBZpnPcBKJW3u8qgLLAT+6aMYA9ZLq14iNcPZSbx++frc3OxmGyMSuVm2DI4fd47LloUBAzx7j2AoQOPgetbws8/gr7+JMc1wAAAgAElEQVTsiUUIEfgupF5w2y38V4d/USE2QBvcCTfp6TBvnjmXV9P6MBVGj3o9jLlATye94w6rSqnDhg2wdat98QgRqgqqSvqO1rqd1rodsAy41jHO8eiitb5La703v/cKNccvHGfGxhnG3Lgu44gMj8zjFcIurmmk11xjtarwRLDsGIJ1zrBpU+c4MxNeeinv64UQJdu0DdM4kXgie1wmqgwPdXzIxoiEp1auhJM5jr6XKwc9e+Z9vWs7rUAuQANQr56VUpqT7BoK4X2FznnUWvfSWv/hy2CCyatrXiUpPSl7XLNMTW5vebt9AYlcpaZa5btz8jSNFKBZ1WZEhUdljw+cO8DxC8fzeYV9wsLcdw0/+ACOHbMnHiFE4LqQeoEpK6cYcw92eJCKsRVtikgUhWsa6aBBEBWV+7XgvjBcvn856ZnpPojMe1yL0Hz4IaSk2BOLEKHKo8NwSqkySqnhSqn/KKWmuD58FWSgOZN0hjfXvWnMPdb5MaIjPNyGEj73009wxtmSi0qVoE8fz98nOiKa5lWbG3OBWoAGrMVvnTrOcXIyvP66ffEIIQLT9A3Tjd3C0lGlebjjwzZGJDyltfvCMK80UoemVZtSKdbZgexcyjk2H93sg+i8Z+hQqJjjfsXp0/D11/bFI0Qo8qSPYQNgN/A2MBEYATwEPArcBVzviwAD0Zvr3uR86vnsceVSlbmn9T02RiTy4ppGet11ZrNcTwRTOmlkJDz6qDn31ltwrkTWDhZC5CYxLZEpq8x7ug+0f4BKpXJtWSwC1KZN8PffznFMTMHn6MNUGD3r9TTmluwN7HTS6Gir4X1Okk4qhHd5smP4Clbl0WpYrSsGArHAcCABuNHr0QWghNQEXl37qjE3puMY4qIK2ftA+E1ysvvdxKKkkTq4LgwDuQANWGk3lSs7x2fPwowZeV8vhChZZmyYYaTEx0XGMabTGBsjEkXhulvYr1/h2jEF2zlDcE8nXbQI9u2zJRQhQpInC8P2wHTAkdEdpbXO0Fp/DEwFXvN2cIFoxoYZbg2AR7cbbWNEIi8//gjnnRu7VK8O3bsX/f1cK5MG8o4hQKlS8KBLb+qXX7YWzEKIki0pLcltt/D+9vdTuVTlPF4hApWnaaQOrjuGv/z9S8CfM2zRAtqa92j54AN7YhEiFHmyMIwBzmmtM4HTQM0cz20HLvdmYIEoOT2Zl1ab5R0faP8A5WLK2RSRyI9rGumwYVY/pKJqWrUp0eHOc6SHzh/iaMLRor+hH9x3n3nn+OhRmDPHvniEEIFh5saZxr9fpSJL8UinR2yMSBTFn3/Cjh3OcXg4DB5cuNc2qdKEqnFVs8cJqQkBfXbewXXX8IMPICPDnliECDWeLAx3YfUsBNgEjFJKxSilIrHOGB72dnCB5v1N7xtfpHGRcfyrozQADkQJCfDtt+ZccdJIAaLCo2hRrYUxF+hfohUrwsiR5tyUKfIlKkRJlpyezOSVk425+9rdR5W4KjZFJIrKdbewe3eryFphKKXczxkGQTrpzTdDbKxzfOCAVWhOCFF8niwMPwVaZv35SaADcA44D9wAPO3VyAJMWkaa2xfpqLajJO0mQH33HSQ5u4lQuzZ07Fj89w2mAjQOY8aYBXd274avvrIvHiGEvd7Z+A5HEo5kj0tFluLRzo/m8woRqIqaRuoQjOcMy5WzMoBykiI0QniHJ30MX9ZaP5L15zVAM+A+YCzQSmv9kW9CDAwfbv2Qv886y35Fh0dL2k0Ac00jvfFGq79fcbktDI8E/sKwVi33Sm6TJ1slzoUQJUtyejIvrHzBmBvddrSRUiiCw5EjsGaNOTd0qGfv4bpjuOLvFaRlpBUvMD9wTSf9+ms4edKeWIQIJYX6VTkrZfQdpVT2novW+oDW+h2t9eta6+2+C9F+GZkZPL/ieWPurlZ3UaNMDZsiEvmJj7cKz+RU3DRSB9cCNIGeSurw2GOglHO8cSMsXmxfPEIIe7z363scPu88+REbESu7hUHqm2/McZs2VnaMJxpVakT10tWzx4lpiaw/vN4L0flWt25w6aXOcVqa1fBeCFE8hVoYaq2TgZuwCtCUOF/89gV/nv4zexwRFsHYLmNtjEjk5+uvITXVOW7QAFq39s57N6nShJgI51+DIwlHjF+yAlXjxu53kl94IfdrhRChKSU9xW238N6291KtdDWbIhLFUdw0UrDOGbqlkwZ4P0OwbnTeeac59+67kgkjRHF5klz3M9CrwKtCTKbO5LlfnjPmhrcYTt3ydfN4hbDbZ5+Z45tuMnfLiiMyPJKW1Vsac8GyazhunDlevBjWB/6NYSGEl7y/6X0OnjuYPY6JiOGxLo/ZGJEoqvh4+Plnc64oC0NwTyddun9p0d7Iz267zaw0vmMHrFtnXzxChAJPFoZvAXcopV5SSvVWSjVVSjXJ+fBVkHb6btd3bDu+LXusUIzvOt7GiER+Tp60Gt7m5K00Uodg62fo0KED9HK5tTN5cu7XCiFCS0p6ituRiFFtRhlphCJ4fP89pOdoOdiwoZUZUhSuO4Yr/15JSnpKHlcHjho1YOBAc06K0AhRPJ4sDOcDtYAxwE/AVmBb1mN71s+QorXmv8v/a8zd0PQGGlZqaFNEoiBz55qtGJo0gWbNvPsZwViAxuHxx83xV1/BoUP2xCKE8J//bf4fB84dyB7HRMTIkYggllsaaVEzYy6peAkXlbkoe5yUnsS6Q8Gx9Xb33eb400/hwgV7YhEiFHiyMOyNlUrqePTO8XCMQ8pPf/3kdgh7QrcJNkUjCiO3NFJvy60AjQ6Sgw19+0KLHK0YtYaPP7YvHiGE76VmpPLcCvNIxMjWI6WAWpBKSnIvsFbUNFLIvZ/h0n1Li/6GfjRwIFTPsel9/jx88YV98QgR7DxpV7FUa70sv4cvA7XDpF8mGeOrG13t1uBcBI4jR2DpUnPuxhu9/zmNqzQmNsLZXffYhWMcOh8c225KwR13mHOzZ8uBfSFC2azNs9zaLY3rOi6fV4hAtmgRJCY6xzVrQrt2xXvPYOxnCBARYZ01zEnSSYUoukIvDJVSGUqp9nk810YplZHbc8Fqxd8rWLbfXOtO7DbRpmhEYXzxhbnAadXKOnfhbRFhEbSq0cqYC5ZzhgA332we2N++HbZssS8eIYTvpGWkue0W3tP6HmqWqWlTRKK4XNNIhw4tfp/eXvXNheGqA6tITk8u3pv6iWt10hUrYOdOe2IRIth58k9JftnrkUB6Ps8HHdfdwr4X96X9Rbmui0WA8EcaqUOw9jMEqFYN+vc35+bMsScWIYRvzd4ym33x+7LHUeFRslsYxNLT4dtvzbnipJE61C9fn9plnU0QUzJSWHtwbfHf2A8aNrT6GuYku4ZCFE2+C0OlVB2lVHelVPesqVaOcY5HP+ABYK/Po/WTjYc3Mn/3fGNOdgsD2/79sGqVOXfDDb77vGAuQAMwYoQ5/ugjs8KdECL4pWWkud3kvLvV3dQqW8umiERx/fILnDrlHFeoAD16FP99lVJuu4bBkk4KcNdd5njWLKvpvRDCMwXtGN4BLAWWABqYljXO+ZgPDAWeKeyHKqXClVKblFLfZY3rK6XWKqV2K6U+U0pFefRf4WWuX6Rdanehe93ueVwtAsHnn5vjjh2hXj3ffZ7rwjCYCtAAXH01lC3rHB87Bj/9ZF88Qgjv+3Drh+yNd96zjQyL5PGuj+fzChHoXNNIBw2CyEjvvHewnjMEuP56KFPGOT5+3GrpIYTwTEELw7eB5sDlWKmk/8ga53w0AipqrT/x4HP/BfyeYzwZeEVrfQlwBrgr11f5wY7jO/i/P8x/eZ/o/gTKWx3ShU/4M40UoFGlRsRFxmWPTySeMErBB7rYWBg2zJybPdueWIQQ3nc2+SwTfzYzXe5qdRe1y9XO4xUi0GkNX39tznkjjdTBtTLpmoNrSEpL8t4H+FBcHNxyizkn6aRCeC7fhaHW+oTWeofWejtQH5ibNc75+FNrXehOqEqpWsBVwLtZY4XV6uLLrEtmYe1A2sK1AXCbGm3o36B/HleLQPDnn7AxxxE/pdwXPd4WHhYe1AVoAG691Rx//TWcO2dPLEII7xq/eDxHEo5kjyPDIhnfbbyNEYni2rgRDuS4/xgb635evDjqla9HvfL1ssepGamsPrjaex/gY67ppD/8AIcP2xOLEMHKk3YV+7XWqUqpaKXUxUqpJq6PQr7Vq8BYIDNrXAmI11o7TjgdBC7K7YVKqZFKqQ1KqQ0nTpwobOiFtvv0bj7Zbm58Tug2QXYLA5zrbmH37lb5bl8L5gI0YB3Wr1vXOU5Kgrlz7YtHCOEdqw+sZvqG6cbc410fp065OjZFJLzBNY20f38oVcq7n+GWTro3eNJJ27aF5s2d48xM66yhEKLwPGlXUTPrTGAi8CewLcdje9bPgt5jEHBca12k36C11jO11m211m2rVKlSlLfI1+QVk8nUmdnjJlWaMPQy2zYvRSH5O43UIdgL0ISFwfDh5pxUJxUiuKVlpDHyu5FonGeeL614KRO6TbAxKuENrgtDb6aROrguDJfuX+r9D/ERpdx3Dd97z1ogCiEKx5N2Fe8CbYExwACs9E/Ho1fWz4J0Aa5WSu0DPs16zWtAeaVURNY1tQC/dws/cPYAs7aYt5YmdJ1AmCpmcyDhU9u3Ww+H8HC47jr/fLbbwvDwhqAqQAPu6aRLlsDff+d+rRAi8E1dPZXtx7cbc9MHTScmIsamiIQ37NwJv+eozBAebhWe8TbXc4ZrD64lMS3R+x/kI8OHQ1SO8oV79sDy5fbFI0Sw8WTV0wV4UGv9mtZ6kdZ6meujoDfQWo/XWtfSWtcDbgJ+1lr/A6vq6fVZl90GfOPhf0exvbjqRdIynbWNL65wMTc2u9HfYQgPue4W9ukDPthMzlXDSg0pHVU6e3w66TT7z+73z4d7SaNG0N6lPedHH9kTixCiePac3sMzy8wC4bddfhu96xfmvq0IZK67hT17QsWK3v+c2uVq06BCg+xxWmYaK/9e6f0P8pFKlWCoS6KXFKERovA8WRgeB3xVnmocMEYptRvrzKFf/xofSzjGO7++Y8yN7zqeiLCIPF4hAoHW9qWRAoSpMFrXaG3MBVsBGnDvaTh7tvW/rRAieGitGf3DaJLTk7PnKsVW4qV+L9kYlfAWf6SROgRz2wpwTyf98kuIj7cnFiGCjScLw38D45RSZQu8shC01ku11oOy/vyX1rq91voSrfUwT6qcesPLq182vkxrla3FiMtH5PMKEQg2bbIqkjpERvr2yzI3bWu49zMMNjfeCBE57oH88YdZ5VUIEfg+2f4JC/csNOam9ptK5VKVbYpIeMuhQ7BunTnnuivmTa7ppEv3LfXdh/nAFVeYhdWSk+ETTxqqCVGCebIwvBaoA+xXSi1USn3u8visoDcIRKeTTvP2hreNubGdxxIVHpXHK0Sg+PRTczxgAJQv798Y2tQ0K5MGWwEagMqV4aqrzDnpaShE8DiddJqH5j9kzPWu31tucIYI196F7dvDRbnWbveOXvXNHcP1h9eTkJrguw/0srAwuOMOc07SSYUoHE8WhpWBPcBmIBKo4vKo6vXo/OCNtW8Y/+BVjavK3a3vtjEiURh2p5E6uBag2Xh4Y9AVoAH3IjSffAJpablfK4QILGMXjeVEorOFU3R4NNOvmi6tlkKEP9NIAWqWqUnDSg2zx+mZ6az4e4VvP9TL7rjDqlLqsHEjbN5sXzxCBAtP+hj2Kujhy0B94XzKeV5b+5oxN6bjGGIjY22KSBTWmjVm9czYWLj6av/HcUnFSygTVSZ7fCb5DHvj9/o/kGIaNMjcbT15EubPty8eIUThLN+/nPc2mdshT3R/gksrXWpTRMKbTp+GpUvNOX8cmehZt6cxDrZ00jp1oG9fc052DYUoWJF6MShLzRwtJoLStA3TOJN8JntcIaYC97a718aIRGG5ppFedRWULp37tb4UpsLc00mDsABNdLR11jAn6WkoRGBLSU/hn9/905hrXLkxY7uMtSki4W3ffQcZGc5x48ZWNWlfc00nDbYCNOBehOajj6zzhkKIvHm0MFRKDVRKrQWSgQNAi6z5d5RSw/N9cYBJSkti6uqpxtyDHR6kbLRXausIH8rIgC++MOfsSCN1cC1AE4wLQ3BPJ503Tyq5CRHIJq+czB8n/zDmZg6eKWfkQ4i/00gdXAvQbDy8kXMp5/zz4V4yZIjVvsLhzBn3/z2FEKZCLwyVUiOAecAfwEgg5+GFXcBdub0uUL3767scv3A8e1w6qjQPdnjQxohEYf3yCxw54hyXLg0DB9oXj+uO4cYjwVnSs3NnuPhi5zglxX0BLoQIDLtO7WLSL5OMuXta30PXOl1tikh4W2IiLFhgzvlrYVi9dHUuq3xZ9jhDZwTdOcPoaKvhfU6STipE/jzZMZwIvKi1vg340OW5HUATr0XlY6kZqUxZNcWYG912NBVjfdAtVnidaxrpkCHWGUO7hEoBGqXcdw2lOqkQgUdrzajvRpGakZo9VzWuKpOvmGxjVMLbFiyApBzdo2vXhjZt8r7e29z6Ge4N/nTSxYthb/CVARDCbzxZGNYFFuXxXDIQNDmYc7bM4eC5g9njmIgYxnQaY2NEorDS0mDuXHPOzjRSgAYVGlAuulz2+GzKWfac2WNjREXnujBcsUK+RIUINLO2zHI78/Vq/1epEFvBpoiEL7imPQ4dalba9LVgb3QP0Ly51d4jpw8+sCcWIYKBJwvDA0CrPJ5rC+wufji+l56ZzvMrnjfm7m51N9VKV7MpIuGJn3+2KmY6lC8P/frZFw+AUiokCtAANGhgpZTm9KFrfoAQwjYnLpzgkYWPGHP9G/TnpmY23yETXpWWBt9+a875K43UoUe9HsZ409FNxCcH38Fz113DDz4wC/oIIZw8WRi+BzyVVWTGkbinlFJ9gLHAO94Ozhc+3/G5sZsTGRbJY10eszEi4QnXNNJrr4WoAKizECoFaABGuPTEnj3b6hsphLDfo4se5XTS6exxbEQs066aJj0LQ8yyZWbxr0qVoFs3/8ZQNa4qTas0zR5n6kx+2f+Lf4PwgptuglKlnOODB2HhQvviESKQebIwnAzMAWYBjm+lVcAC4DOt9etejs3rMnUmz/3ynDE34vIR1ClXx6aIhCdSUtxTa+xOI3UIlQI0ADfcYC62d++GtWvti0cIYVn812JmbzEP/j7V4ynqV6hvU0TCV1y/6wYPhggbGoSFQjpp2bIwbJg5J0VohMidJw3utdb6PqAhcD/wBPAvoEnWfMD75o9v2HFiR/Y4TIXxeNfHbYxIeGLBAjh71jmuUgV69cr7en/KrQBNps60KZriqVDB+iUkJylCI4S9ktKSGPX9KGOuRbUWcj4+BGVmwtdfm3P+TiN1cO1nGGyN7h1c00nnzYMTJ+yJRYhA5nGDe631Hq31TK31c1rr6VrrXb4IzNu01m6lvW9qdhOXVLzEpoiEp1zTSK+/3p47qLmpX74+FWKchR/Op55n/aH1NkZUPK5FaD77zNqxFULYY9Ivk9h92nmUX6GYMWgGkeGRNkYlfGH9ejh82DmOi4O+fe2JpXvd7sZ489HNRipzsOjaFRo2dI7T0mDOHPviESJQedLH8EGl1At5PPe8Uup+74XlfQv3LHRL7xvfdbxN0QhPJSZad/hyCpQ0UrAK0HSq3cmYe3rZ0/YE4wVXXmk2Bj59Gn74wb54hCjJdhzfwZSVZoule9veS8daHW2KSPiSaxrpgAH2tWSqXKoyLaq1yB5rNMv3L7cnmGJQyn3X8L335Py8EK482TEcTd6VR3dlPR+w/vvLf43xNZddQ7OqzWyKRnjq++/hwgXnuGZN6w5gIHmg/QPGeP7u+Szbt8ymaIonKsp94S13V4Xwv0ydyT+/+ydpmWnZczVK1+C5Ps/l8yoRrLR2XxjalUbq4HrOMFjTSUeMgPBw5/i33+T8vBCuPO1jmNfCcC9Qr9jR+Mjy/ctZ8fcKY25it4k2RSOKwjWN9IYbIMzjRGjf6t+gv1vazfjF44Oy2T24Vyf97js4dcqeWIQoqd799V1WHlhpzL1x5RuUiymXxytEMPv9d9iV44BORARcdZV98QD0rNfTGAdjARqA6tVh0CBzTorQCGHy5FfrM0CjPJ5rBJwrfji+8d/l5m5h/wb93apIisB17py1Y5hTIKWROiileL6P2SNz9cHVfLfrO5siKp527dzPZHz+uX3xCFHSHE04ythFY425wQ0Hc23ja22KSPia625h795Wv1479ajbA4WzHcrWY1s5mXgyn1cELtd00k8/hYQEe2IRIhB5sjD8FnhaKdU856RSqhnwFPCNNwPzlvWH1rPor0XG3BPdn7ApGlEU8+aZhU/q1YP27W0LJ1+da3dmUEPzluTEnycGZYVSpXLvaSiE8I+HFzzM2RRnKea4yDjeHPim9CwMYYGWRgpQIbYCLau3NOaC9ZjElVdCjRrOcUKC3PAUIidPFobjgZPAJqXUeqXUPKXUemAzcBwIyL4PrpVIu9ftTtc6AXY4TeTL9R/tG2+0Fi2BalLvScbd1W3Ht/HJtk9sjKjo/vEPc7xmDfz5pz2xCFGSzN89n0+3mzn0z/Z6VvruhrC//4aNOWrkKQVDhtgXT06u6aTBes4wIgJuu82ck3RSIZw86WN4GmgH3AfsAWKzft4LdNBan/FJhMWw7dg2vtlpbmTK2cLgcu4cLFxozt1wgz2xFFaLai24ufnNxty/l/6b1IxUmyIqunr1oLt5bFKK0AjhYxdSL3Dv9/cac61rtOaBDg/k8QoRClx7F3bsaO5u2SkUGt073HmnOV61yjrbKYTwsI+h1jpZaz1Da32T1rpv1s93tNYB2eHsuRVm1bZ2NdvR92KbmgGJIvn+ezONtH59aNXKvngK6z89/0NEmLPJ4l9n/uK9X4PztqRrOumcOVYDZiGEbzyz7Bn2xe/LHoepMGYOmmn8myJCTyCmkTp0q9uNMOX8lXHHiR0cv3DcxoiK7tJLoUcPc+799+2JRYhAU6S6jkqpcKVUKdeHt4Mrjl2ndvH5DjMHcWK3iXI2I8jMnWuOr78+sNNIHRpUbMA9re8x5v6z/D8kpiXaFFHRXX89xMQ4x/v2wcqVeV4uhCiGLUe38PLql425B9s/KAXTQtzJk7DcpT1gIC0My8eUp1V1865ssJ4zBPciNLNnWwXWhCjpPGlwX1Yp9aZS6jCQApzP5REwXljxglHwo1nVZgxuNNjGiISnLlxwb6p+3XX2xFIUT3Z/ktgIZ1fiowlHeX3t6zZGVDTlyrmfc5F0UiG8LyMzg5HfjSRDZ2TP1S5bm2d7P2tjVMIfvv3WzMRo1gwuucS+eHITSumk110HZcs6x8ePWy2ZhCjpPNkxnAHcBnyGda7wzlweAWF//H7mbDV/c53YbaKRBiEC3/z5kJTkHNeuHbjVSHNTo0wNHuzwoDE3eeVkziQF3HHcAt16qzn+/HNITrYnFiFC1bQN01h3aJ0x99bAtygdVdqmiIS/BHIaqUOv+qGzMCxVCm65xZx79117YhEikHiyUuoPPKy1fjjrXOEs14evgvTUi6teJD0zPXt8acVLGdZkmI0RiaL48ktzfO21wZFGmtO4LuMoF+1sRB2fHM+Lq160MaKi6dcPqlZ1js+ete5wCyG849C5Q0xYPMGYu7bxtZLpUgIkJLgXWQvEhWHXOl0JV+HZ4z9O/sHRhKM2RlQ8rumk8+fDoUP2xCJEoPBkYXgBOOirQLzlyPkjvPuredtnfNfxhIeF5/EKEYiSk93TOq6/3p5YiqNCbAXGdjEbVL+29rWg+zKNjISbzUKr0tNQCC96cP6DnE91nsgoE1WG1wcEX+q58Nz8+WaRtbp1oWXLvK+3S9nosm5nXYO1bQVAmzbQooVznJkJ//ufbeEIERA8WRhOBUYrFdj5mC+vfpmUDOe/sHXK1WF4i+E2RiSKYuFC6y6qQ40a0LmzffEUx786/ItqcdWyx4lpifx3+X9tjKhoXKuTzp8PJ07YE4sQoWTeznl89ftXxtzzfZ7norIX2RSR8Kfc0kgDNTvG7Zzh3uBNJ1XKfdfw/fel6rYo2TxZ5F0EXA7sVErNVEpNcXlM9lGMhXYq8RTTNkwz5sZ2HktkeKRNEYmick0jveYaCAvoWxJ5i4uK44nuTxhzMzfOZO+ZvTZFVDStWkGTJs5xejp8+mne1wshCnY+5Tz3/XCfMdfhog6MajvKpoiEP6WmWm2ZcgrENFIH14Xh0v1L7QnES4YPh+ho5/ivv2BZ8BZbFaLYPPlV+3ogE4gA+gLDcnnY6rW1r3Eh7UL2uHrp6tzZKmBq4ohCSk2FefPMuWBMI81pZJuR1CtfL3uclpnGU0ufsi+gIlDKfddQ0kmFKJ4nlzzJwXPOUxrhKpyZg2fK8YcSYskS68y2Q5Uq0KWLffEUpEudLkY/zV2ndnH4/GEbIyqeihXdF+LvBWfLYSG8otALQ611/QIeF/sy0IKcTT7LG+veMOYe6fQIsZGxebxCBKrFi80vysqVoVs3++LxhqjwKP7T8z/G3IdbP2TbsW02RVQ0//iHmeK0YQP8/rt98QgRzDYc3pDr91aLai3yeIUINV9/bY6vvhrCA/ieQOmo0rSr2c6YC+Z0UnBPJ507F84EX/FwIbwiSJPz3L29/m3ik+OzxxVjK0oqTpBybWp/zTUQEZH7tcHklua30LRK0+yxRvPEkifyeUXgqVULevc256SnoRCeS89MZ+S3I41+u/XK1+OpnsGVSSCKLjMTvvnGnAvkNFIHt3TSIC5AA9Z3Wr16znFyMnz8sW3hCGErjxaGSqmLlVLTlFLblFKHsn6+rZSydbcwMS2RV9a8Ysw91OEh6f0UhNLT3e+gBlNT+/yEh4UzqfckY27eznmsPrDapoiKxrWn4Ycfyv0F01UAACAASURBVGF9ITz1+trX2XR0kzE37applIosZVNEwt/WroUjR5zj0qWhTx/74imsnvV6GuNg7mcIVv2CO+4w5ySdVJRUhV4YKqXaAJuB64D1wOysn9cBm5RSrX0SYSG8s/EdTiQ6yyOWiSrD/e3vtyscUQzLlsGpU85xhQruO1TB7OpGV9OxVkdjbsLPE9Ba2xSR56691moO7HDggBzWF8IT++P38+SSJ425m5rdxIBLBtgUkbCDazXSgQMhJsaeWDzRpU4XIsOcRf32nNnDgbMHbIyo+G6/3TwmsWmT9RCipPFkx/AlYBNQT2t9p9Z6vNb6TqB+1vxLvgiwICnpKUxZNcWYu6/dfVSIrWBHOKKYXKuRXn211UMvVCileK73c8bc0n1LWfTXIpsi8lyZMu7pTpJOKkThaK2574f7SExLzJ4rH1OeV/u/amNUwt+0zr1NRTAoFVmKDrU6GHPBnk5apw7062fOya6hKIk8WRi2B6ZorRNzTmaNXwI65PoqH5u1ZZZRESs2IpaHOz1sRyiimDIy3L8og70aaW561e9F34v7GnMTFgfXrqFrOukXX0BiYu7XCiGc5v4+l+//NPsTTLliCtVKV8vjFSIU7dgBu3c7x1FR1o5hsOhZt6cxDvZ0UoC77zbHH30ESUn2xCKEXTxZGCYBlfJ4riKQXPxwPJOemc4LK14w5ka2GUnVuKr+DkV4wcqVcOyYc1ymDPTtm/f1wey5Puau4cYjG5n7+9w8rg48ffpAjRrOcUKCexEFIYTpbPJZHvzxQWOuS+0u3NX6rjxeIUKV603QPn2gbFl7YimKXvVdGt2HwMLw6qutKugO8fHu/3cSItR5sjD8HnhBKdU152TW+HngW28GVhifbPuEvfHOJuGRYZE82vlRf4chvMS1GungwWbj2VDStmZbrm9iboc+8fMTpGem2xSRZyIi4JZbzDnpaShE/sYvHs+RBGe1kciwSGYOnkmYCpkC4aKQgjWN1KFTrU5EhUdlj/fF72Nf/D77AvKCqCj3bBhJJxUljSffRmOAv4BlSqkjSqktSqkjwHJgL/CILwLMz/MrnjfGd7S8g1pla/k7DOEFmZnuC8NQqUaal2d7PWv8Qrjz1E5mbZ5lY0SecW12v3AhHD1qTyxCBLrVB1YzfcN0Y25cl3E0qdLEpoiEXfbtMwubKGXtVgWT2MhYt0JqwX7OENx7Gv78M+zZY08sQtjBkwb3p7TWXYGrgLeBlVk/B2itu2qtT+X7Bl52JvkMv590dtYOV+GM6zrOnyEIL1q3Dg4dco5LlYIBIV6g77LKl3H75bcbc08ve5rkdL9nZRdJixbWwyEzU3o/CZGbtIw0Rn43Eo3zHPElFS9hQrcJNkYl7OLakqlLF6gWhEdMXfsZhkI6adOm0MGlYsYHH9gTixB2yHdhqJSqoZSaq5Tq75jTWs/XWj+rtR6ttX7WukzNVUr59WDfkfNHjPEtzW/h4gq2tlMUxeBajfSqq8yWCKHqqZ5PGek4B88dZNr6aTZG5BnXXUOpTiqEu6mrp7L9+HZjbvpV04mNjLUpImGnYE8jdXBbGO5dElRF1PLiumv4v/9ZxfGEKAkK2jF8FLgYWJjPNQuxWlb4NZU0Kc1ZKkqhGN91vD8/XniR1iUvjdShTrk6jG472ph7bsVznE85b1NEnrnlFqs5sMPmzbBtm33xCBFo9pzewzPLnjHmRlw+gj4XB0Enc+F1J07AihXmXLAuDDvU6kBMhLPx4oFzB4y6D8HqxhvNG9OHDsGCBfbFI4Q/FbQwHARM1/ncAsp6bgYwpKAPU0rFKKXWZZ1P3KGUeiZrvr5Saq1SardS6jOlVFRB75XTtY2vpXGVxp68RASQX3+1zlw4xMQEV9nu4prQbQKlo0pnj08mnuTl1S/bGFHh1ajhXjlWdg2FsGitGf3DaCM9vFJsJab2m2pjVMJO8+ZZafcOl18O9evbF09xxETE0KlWJ2Nuyd7gTyctW9ZaHOYkRWhESVHQwrAu8Fsh3ud3oF4hrksBemutLwdaAgOUUh2BycArWutLgDOAR7W7J3ab6MnlIsC47hb272+1qigpqsRVYUzHMcbc1NVTOZl40qaIPONaxe2jjyTtRgiAT7Z/wsI9ZsLNS/1eonKpynm8QoS6UEkjdQjFc4bgnk46bx4cP25PLEL4U0ELwySgMJ11Smddmy9tScgaRmY9NNAbcJwymwUMLcRnAjDw0oG0qtGqsJeLAKO11Rw9p1Bsal+QRzo/QqVYZ5vQ86nnef6X5/N5ReAYOhRKOzc8OXzYquQmREl2Ouk0D81/yJjrVa8Xt11+m00RCbudPw+LFplzQb8wdOlnuHTf0pA4Z9i5MzRq5Bynp0s2jCgZCloY/goUpojykKxrC6SUCldKbQaOA4uAPUC81trRwO0gcFFh3gtktzDYbdsGu3c7x5GRMGiQffHYpWx0WbcKhW+tf4sDZw/YFFHhxcW5nwmVnoaipBu7aCwnEk9kj6PDo5k+aDpKKRujEnb68UdITXWOL74Ymje3Lx5vaFezHbERziJKh84fYvfp3fm8Ijgo5b5r+O671s1sIUJZQQvDt4G7lFJ53uJUSo0A7gDeLMwHaq0ztNYtgVpAe+CyQsaKUmqkUmqDUmoDWHdfO9fuXNiXiwDkmkbaty+UL29PLHYb3W600YczJSPFrWhFoHKtTvrVV5CQkPu1QoS65fuX894m81DSxG4TaVipoU0RiUCQWxppsN8niI6IpkudLsZcqKSTjhgBERHO8R9/wNKltoUjhF/kuzDUWs8FXgM+UEqtV0o9q5S6Ryl1t1LqP0qptcAHwOta6//L771yee94YAnQCSivlHL89asFHMrjNTO11m211m1BdgtDgWubipJSjTQ3MRExPNXjKWPug80fsPPkTpsiKryePaGWc01LYqL7L0FClAQp6Sn887t/GnOXVb6MsV3G2hSRCAQpKfD99+ZcsKeROrieMwyFRvdg9ZZ0zWAaM0bO0IvQVmCDe631I1ipouew2lfMAGYCjwHngSFa60cL82FKqSpKqfJZf44F+mIVrlkCOE6W3QZ8U9B71a9Qn971exfmY0WA+v13+C1HaaPwcBhSYG3b0HZ7y9uNXYVMncmTS560MaLCCQuD4cPNOUknFSXR5JWT+ePkH8bczEEziY6ItikiEQh+/tk6Y+hQrRp06pT39cGkZ72exnjJvtDoZwjWQjCnzZthxgx7YhHCHwpcGAJorb/VWvcBygA1sh5ltNZXaK2/8+DzagBLlFJbgfXAoqzXjwPGKKV2A5WAAgsDV4ytKGc1gpxrGmmvXlCpUu7XlhQRYRE82+tZY+6L377g1yOFOsJrK9fqpIsXW/2fhCgpdp3axaRfJhlzd7e6m251u9kUkQgUrhkUQ4aYPWCDWbua7YiLjMseH004ys5TgZ/pUhjdusFNN5lzEyda/SiFCEUe/bOktU7XWh/LeqQX/Aq312/VWrfSWrfQWjfTWv8na/4vrXV7rfUlWuthWusUT99bBB/XhWFJrEaam+ubXE+r6mal3QmLJ+RxdeBo0gRat3aOtbZaVwhREmitGfXdKFIznNVFqsZVZXLfyTZGJQJBRgZ845IHFSpppACR4ZF0rdPVmAuVdFKAl14yK2/Hx8P48fbFI4Qvhcj9KhFs9uyxUjIclLLaHggIU2E81+c5Y27BngUs27fMpogKz7UIzezZUsVNlAyztsxyK7rxSv9XqBhb0aaIRKBYvdrsgVe2LPQOsZMwuaWThoqLLoJ//9uce+89WLfOnniE8CVZGApbuO4Wdu9unbkQlv4N+tOjbg9jbvzi8QF/buPmm62zog47dpg3AIQIRScunOCRhY8Yc/0a9OPmZjfbFJEIJK5ppFddBVFR9sTiK7kVoAn07ytP/OtfcJlLDf377pNCNCL0yMJQ2EKqkeZPKcXzfcwG96sPrubbXd/aFFHhVK0KAwaYc9IUWIS6Rxc9yumk09njmIgYpl01Tc7BC7TOvU1FqGlTsw2lo5z5lscvHOf3k7/bGJF3RUXBG2+Ycxs2wPvv2xOPEL4iC0Phd/v3w/r15ty119oTSyDrVLsTgxsONuYm/jyRjMzAvkXpWoTm448h3eMTyUIEh8V/LWb2FrME71M9nuLiChfbFJEIJFu3wt69znF0NFx5pX3x+EpEWATd6phFlpbsDZ10UoArrnCvhTB+PJw+nfv1QgQjWRgKv/vqK3PcubOVwy/cTeo9CYVz12H78e18sv0TGyMq2NVXW2doHI4dg0WL7ItHCF9JSkti1PejjLnmVZvzSKdH8niFKGlcdwv79jULmYQS13TSUDpn6DB1KpQq5RyfOmVVKRUiVMjCUPid6/lCSSPNW/Nqzbml+S3G3L+X/NuofBhoYmNh2DBzTnoailA06ZdJ7D69O3usUMwYNIPI8EgboxKBpCSkkTr0qu9+zjBTZ9oUjW/UqeO+EJwxA34N/I5SQhSKLAyFXx0+DCtXmnOyMMzfMz2fISIsInu8N34v7/76ro0RFcy1OunXX8O5c/bEIoQv7Di+gykrpxhzo9qOolPtEOlaLortr7+sVFKHsDAYPDjv64Ndq+qtKBvtTBc5lXSKHcd32BiRbzzyCFxyiXOstVWIJjO01sCihJKFofAr17unbdtC3br2xBIsGlRswD2t7zHmnl3+LBdSL9gUUcG6djX/75qc7F5wSIhglKkz2XVqFyO/G0laZlr2fI3SNdwKRomSzfX7rls3qFLFnlj8ITwsnO51uxtzoZhOGh0Nr79uzq1ZA7Nm2ROPEN4kC0PhV66LA2lqXzhPdn+S2IjY7PHRhKO8se6NfF5hr7Aw9yI0Up1UBButNfvi9/Hlb18ybtE4+szuQ8XJFWn0ZiNWHVhlXPv6la9TLqacTZGKQFSS0kgdSsI5Q7AKCA0ZYs6NGwfx8fbEI4S3qGDtM9O2bVu9YcMGu8MQHjh+HGrUMNMt/vzTTMkQeRv/03heWPlC9rh8THn+evAvKsRWsDGqvO3aBY0amXP79skOsQhcR84fYcPhDaw/vD7758nEkwW+blDDQcy7aZ60pxDZjh2zvu9y/opVEv7923RkE61nts4eV4ipwMmxJwlTobcPsXcvNGliZcQ4PPCA+26iEL6mlNqotW7rjfcKvb+pImB9/bW5KLz8clkUemJsl7GUjymfPY5Pjnc74xRIGjaEDh3MuY8+sicWIVydSjzFgt0LmLR8EkM/HUqtl2tR8+WaXP3p1Ty7/Fl+3P1joRaFFWMr8uaVb8qiUBi++cZcFLZqFfqLQoAW1VoY31Nnks+w9djWfF4RvOrXh8cfN+feess8VypEsJGFofAbaWpfPBViKzC281hj7rW1r3Hk/BGbIiqYazrp7NnmL0tC+MO5lHMs3beUF1e+yI1f3sjFr11M5RcrM+CjATyx5Am+2fkNh84fKvT7lY8pzxUXX8GErhNYd/c66pYvAb/xC4+UxDRSsM4Z9qjbw5gLtX6GOY0day0QHTIzrUI08j0ngpWkkgq/OHUKqlWDjBy92X/7DRo3ti+mYHQh9QINXm/AsQvHsudGtx3NW1e9ZWNUeTt5EmrWhDRnjQ7WrYN27eyLSYS2xLRENh/dbKSE7jy5E03RvuviIuNoXaM17Wq2o23NtrS7qB0NKjSQHUKRp7NnrSIzOf/d27YNmjWzLyZ/em3Nazy04KHs8dWNruabm76xMSLfmjfP/bzhnDkwfLg98YiSx5uppBEFXyJE8c2bZy4KGzeWRWFRxEXF8WT3J7n/x/uz52b+OpNHOj/CxRUutjGy3FWuDAMHWmlVDnPmyMJQeEdqRirbjm0zzgTuOL6DDJ1R8ItzER0eTcvqLa0FYNZC8LLKlxEeFu7lyEUo++EHc1F4ySXQtKl98fhbz3o9jfGyfcvIyMwI2b9Hgwdb33M//OCce+wxuPpqKFs279cJEYhkYSj8wrWpvVQjLbp72tzD1NVT2Ru/F4D0zHSeWvoUc64JzLKft95qLgw/+QSmToVI6QEuPJCRmcHvJ39n/SHnInDLsS2kZqQW6f3CVTjNqzV37gTWbEfTqk2JCo/ycuSipMktjbQkbTA3r9acSrGVOJV0CoCzKWfZfHQzbWq2sTky31AKXnsNfvoJUrP+OTp6FJ55xvquEyKYSCqp8Lnc0mo2b7aKz4iimbNlDiO+dnaRVyi2jNpC82rNbYwqdykpUL26WcZ73rzQbvQsiidTZ7L79G5rAXhoPRuObODXI7+SmJZYpPdTKBpXaWzsBF5e7XJiI2MLfrEQHkhOtr7vEhKcc6tWQadO9sVkh+s+v46vfv8qe/xS35d4pPMjNkbke088AZMmOcfh4bBlS8naLRb2kFRSEVS++849raZFC/viCQW3NL+FKaumsP34dgA02iqiEYDnOKKj4cYbYcYM59zs2bIwFCatNcv2L2P6hunM3z2fsylni/xeDSo0oN1F7WhbwzoT2Kp6K8pEl/FitELk7qefzEVhjRru1ZlLgp51exoLwyX7loT8wnDCBOuoxN9/W+OMDKt9xeLFJWvHWAQ3WRgKn8utGqn8I1k84WHhTOo9iSGfOk+8z9s5j1UHVtG5dmcbI8vdiBHmwvDbb+HMGagQmC0YhR/FJ8cza/Mspm+czh8n//D49bXK1jLSQdvUbEPF2Io+iFSIgrmmkQ4ZAmElsP57r/pmo/vl+5eTnplORFjo/tpZqhS88opZcX3JEvj8c+vmqBDBQFJJhU8lJFhpNTkbwK5fD229suFdsmmt6fJ+F1YfXJ0916NuD5bctiTgKiZqDZdeCnv2OOdmzICRI+2LSdhr4+GNTNswjY+3fUxSelKhXlOlVBXaXdQueyHYtmZbqpeu7uNIhSic9HRrh/BkjvaXCxZAv372xWQXrTXVXqrGicQT2XPr7l5Hu4tCu/KY1tC/Pyxa5Jy76CL44w8oXdq+uEToSkpLolRUKUklFcHhhx/MRWHdutAmNM+f+51Siuf6PEevWc47s8v2L2PhnoX0v6S/jZG5U8oqQvP00865OXNkYVjSJKYl8tn2z5i2YRrrD6/P99ryMeWtxV9WOmjbmm2pXbZ2wN30EMJh5UpzUViuHPTsaVs4tlJK0bNeT7747YvsuSX7loT8wlApeOMNaN7ceYTm0CH473/hhRfsjU2EnlOJp+g9u7dX37MEJjgIf3KtRipppN7Vs15P+jUwb0dP+HkCmTrTpojy5trTacUK+Osve2IR/rXz5E4env8wF718EXfOuzPPRWFEWATXN7mexSMWc2rsKRbduojnr3ieaxtfS51ydWRRKAKaaxrpoEEQVYKL3Lq2rViyL3Qb3efUqBGMGWPOvfwy7NxpTzwiNMUnx9Pvw35sPbbVq+8rC0PhM0lJ8P335py0qfC+53o/Z4x/PfIrc3+bm8fV9mnQALp0Mec+/NCeWITvpWWk8eVvX9Jndh8ue+syXl37KvHJ8bleW6tsLf7T8z/8/dDffDHsC3rX702Ykq8nETy0zr1NRUnWq555znDF3ytIy0jL4+rQ8sQTVgqpQ1qaVYgmSE9viQBzLuUc/T/sz69HfvX6e8s3r/CZBQvgwgXnuGbNklmdzdfa1GzD9U3MFfeTS54kPTPdpojyduut5nj2bPmiDDUHzh7g30v+Td1X6zLsi2H8vPfnPK/t36A/X9/4NXv/tZcnezxJjTI1/BipEN6zaZOzGiVATAwMGGBfPIHgssqXUS2uWvY4ITWBjUc22hiR/5Qu7d7DcNEi95sHQngqITWBgR8NZN2hdT55f1kYCp/JrRppSazO5g/P9nrW2GHZeWonszbPsjGi3N1wg5latWcPrFljXzzCOzJ1Jgt2L2Dop0Op91o9nl3+LEcSjuR6baXYSjzW+TF2P7Cb+cPnM+SyISFdqVCUDK6/8PfrB3Fx9sQSKBznDHNasrdkpJOC9X3Xy9w05eGHIbFo7ViFIDEtkcGfDGblgZU++wz5NV34REqK1ZIgp5wlnIV3XVb5Mu5oeYcx9/Syp0lOT87jFfaoUMG9f+Hs2fbEIorvZOJJXlz5Ig3faMiAjwbwzc5v8jzf2rl2Z+ZcM4eDYw4ype8UGlRs4OdohfAdSSPNnWs6aUk5ZwjOQjQROe57/f03PP+8fTGJ4JWcnsyQT4ewdN9SY75jrY5e/RxZGAqf+OknOHfOOa5aFbp2tS+ekuCpHk8RHR6dPT547iBvr3/bxohyN2KEOf7sM+tGgggOWmtWHVjFrf93K7VersXYn8ay58yeXK8tHVWaUW1GsWXUFlbeuZLhLYYTExHj54iF8K0//4QdO5zj8HD3G2AllWs/w5UHVpKakWpTNP7XtCk8+KA5N2UK7N5tTzwiOKWkp3DtZ9fy018/GfNta7blx3/86NXPkoWh8AnXaqTXXGN9WQrfqV2uNqPbjTbmnvvlOc6lnMvjFfYYMAAqVXKOz5xxL1IkAs/5lPNM3zCdljNa0uX9Lny49UNSMnJf0Tev2py3B77N4TGHmTZoGi2qtfBztEL4j+tuYffu5r9xJdmlFS+lRmnn2eHEtETWH8q/VU2oeeopqJ6j3WpqKjz0kH3xiOCSmpHKDV/ewI+7zQVgy+otWTB8AeVjynv182RhKLwuLQ2+/tqck2qk/jG+63hKR/0/e/cdHkXVBXD4d9NIILRQBASkg9I7qDRFpAUQEBWQJqAoCvbyqdi7KGJBQKWIdJFiRSEKirSAgDRFmnSQXgJJ7vfH3ZCd3Q0ksNmZzZ73eXjC3JndnOzs7sy5NX0V3UOnDzF8yXAbI/IWFQV33GEtmzjRnljExa3dt5Z7v76XEsNLMOjrQRlOjR0VHkWP6j1Y3Hcxf9zzB4PqDyJvrrwBjlaIwJNupBlTSnm1GoZSd1KAfPngzTetZV9/7T3cRghPyanJdJ/ZnTmb5ljKqxWtxvw75xMXE+f33ymJofC7hQtNK1CauDho1sy+eEJJkTxFeLjxw5ayt5e8zYGTB2yKyDfP2Um//hoOHbInFuEtKTmJSWsmcf2n11NjVA0+WvERJ86e8Hls2QJleb3l6/z74L983vlzrit9naw3KELGnj3eE2h16mRPLE7lOc7Qc4xUKOjRw3s4zZAhZlkvIXxJSU3hzll3MnODtQtelcJV+PHOHymcu3C2/F5JDIXfeXYj7dQJIiPtiSUUPdT4IQrFpPdjOnH2BK8udtZo9/r1oVKl9O1z58xYQ2Gvfw7/w+PzH6fkOyXpOatnhjOfhakwOlTuwLc9vuXvB/7mseseo0ieIgGOVgj7zZ5t3a5XD0qVsicWp/KcmfTXnb+SlBxaA8uVgvfft87MvnWrd0uiEGBm+u43px9T1k2xlFeIq8BPvX7iitgrMnjk5ZPEUPhVSop3txqZjTSw8uXKx1NNnrKUfbj8Q3Ye3WlTRN6U8p6ERmYntUdKagpzNs2hzaQ2VHivAm/89gYHTx30eWyx2GI83eRptg7ZyuzbZ9O6QmtZiF6ENOlGenHlC5anZL6S57fPJJ9h6a6lNkZkj5o14b77rGWvvmoSRCHSpOpU7p57NxP+sN4UlS1QlgW9FlAib4ls/f1yRRd+tWgRHHDrtZg/P9x4o33xhKp7699ruRAnpSTx/M/P2xiRtx49rNtLl8LmzfbEEor2ntjLS7+8RNkRZek4pSPf/f0dGu3z2BZlWjCt6zR2DN3Bize8SOn8pQMcrRDOc+QILFhgLZPE0JtSSrqTurzwAhRx61xx5oxZ21AIMLN+D/5mMGNXjbWUl85fmgW9F1Aqf/Z3R5DEUPiV56L2HTpArly+jxXZJzoimueaPWcp+2z1Z2w8uNGegHwoU8Z77Onnn9sSSsjQWrNw60K6Te9GqXdK8czCZ9h5zHdLcv5c+RnScAgb7tvAgt4LuLXqrUSGS59wIdJ8/TUkJ6dvV64MV19tXzxO5rXQfYhNQJOmQAF4/XVr2ezZ8K1/VxwQQUhrzYPfP8hHKz6ylJfIW4IFvRZQpkCZgMQRcfFDhMic1FT48ktrmXQjtU/vWr1587c32XRoE2C6Jzyz8Bmm3zrd5sjS3Xkn/Pxz+vbEifDcc9ZxGOLiUlJTOHLmCIdOH+K/0/9x6JTrp9v2odOHWL139fn3Q0bqlajHoHqDuL3a7eSOzB2gv0CI4CPdSDPPs8Vwyc4lnEk+E5LrmvbuDaNHWycteuABWLdOKtJDldaax398nBFLR1jKi8UWY0GvBZSPKx+wWJTWvrsOOV29evX0ihUr7A5DuPn1V+usW7GxsH8/xMTYF1Oom/7ndLrN6GYpWzFgBXVL1LUpIqujR836TmfOpJf98gs0aWJfTHbSWnM06WiGyV3atmfZkTNHMuwGmhkxETHcXu12BtUbRP0r6/vxLxIiZzp9GgoXhlOn0suWLoUGDeyLyenKvFuG7Ue3n99e2HuhV0tiqEhMNBMVud+Cv/IKPPmkfTEJ+zyz4BleWvSSpaxI7iIk9EngmiLXXPTxSqmVWut6/ohFWgyF33jORtqunSSFdutyTRfqFK9D4p7E82VPLXiK73t+b2NU6fLnh44drTOSTpgQ/Imh1pqT505eMLk7n+S5lR0+fZgUnRKwOCsXqsw99e6hd83eFIwpGLDfK0Swmz/fmhReeaW50RcZa1G2BeNWjzu/vXBr6CaGderA3XfDqFHpZS+9ZMbel5Yh3CHlxZ9f9EoK42Li+LHXj5lKCv1NEkPhF1p7J4ayqL39wlQYr9zwCq0ntT5f9sOWH0jYluCYC3KvXtbEcPp0eO+94KhUSEpOYtbGWczeNJtdx3ZZkr6zKWftDs+niLAIOlXpxKB6g2hRpoWsOSjEJfDsRtqpk3SBv5jmVzW3JobbFvI8zpoULZBeftlc79LW8D11Ch5+2JSJ0PD64td5NuFZS1mB6ALMv3M+Na6oYUtM0pVU+MXy5dYuNDExZnbSPHnswSPE2wAAIABJREFUi0kYWmtajG/Bz9vTB/M1KtmI3/r95oikIDnZ1Lbv359eNnUqdOuW8WPstungJsYkjmHc6nEcOn3I7nAAs0xJoZhCFMpdiLiYOArFePzMXYhCMYWoW6IuRfMUtTtcIYJWcrLpAn/I7aP/448yA/fF7Di6g6vever8dlR4FIcfPxzSY5nHjIGBA61l8+dDy5b2xCMC550l7/DQDw9ZyvJG5eXHXj/S4Mqs9UmXrqTCcTxnI23TRpJCp1BK8eqNr3Ltp9eeL/v939+Zu3kuHSp3sDEyIyICuneHd99NL5s40XmJ4ZnkM8xcP5MxiWMsSba/5YnMY0nkPJM7X9sFowvKjKFCBMiiRdaksGBBaNrUvniCRen8pSlXsBz/HP4HgLMpZ1mycwk3lgvdjLpfPzMRjXs7x/33wx9/QFSUfXGJ7PXBsg+8ksI8kXn4rud3WU4K/U0SQ3HZfHUjldlInaVxqcZ0qNyBOZvmnC976qenaFexHeFh4TZGZtx5pzUx/PZb04JY1AENW+sPrGfMyjFMWDOB/07/l+nH5QrPZU3uchciLjrj5C5tO1eETEsnhJN5diONj4dIqZfJlOZXNT+fGILpThrKiWF4OHzwATRqlD4RzcaNMGIEPPqovbGJ7DFm5RgGfzvYUhYTEcM3Pb7h2lLXZvCowJHEUFy2P/6ALVvSt6OioH17++IRvr18w8vM3TT3/OyVfx74kzd/e5PBDQYTGxVra2y1a0PVqvDnn2Y7JQWmTDFTeNvh9LnTzFg/g9GJo1m8Y/EFjy0QXYBeNXoRXzmeIrmLnE/2YiJiHNFVVwjhP1rDV19Zy2SZisxrUbYFn67+9Px2qC50765BA7jrLhjrtqb5Cy+YnjRXXmlfXML/xq8ez93z7raURUdEM/eOuTS9yhndDmSotLhsnq2FrVpBvnz2xCIyVq1oNXrU6GEpe/KnJyn8RmHaTGrDh8s/ZOdR34udZzelTKuhuwkTAh/Huv3rGPLtEEoML0Gvr3pdMClsUroJE2+ZyO6HdjOizQhalmtJzWI1KZW/FLkjc0tSKEQOtHIl7HT7moyJMdc8kTmek54t27WMk2dP2hOMg7zyChQokL594oS0GOY0X6z9gr6z+1qWlooKj2LWbbMc1Woe0MRQKVVKKbVQKbVeKfWnUmqIqzxOKTVfKfWX66fMmx5EPMcXymykzvV88+eJCLN2FEhKSeK7v7/jvm/uo/S7pan9cW2eXfgsK3avIFWnBiy2Hj1Mgphm5UpYvz77f++pc6cYv3o81316HdU/qs57y97jyJkjPo+Ni4njwUYPsv7e9fzS9xd61uhJTGQQTJ8qhPALz26krVtD7tCdOyXLSuYrSYW4Cue3z6We49edv9oYkTMUKWJmKXU3eTIkJNgSjvCzGetn0GtWL0tSGBEWwYxbZ9C6QusLPDLwAt1imAw8rLW+BmgE3KeUugZ4AvhJa10R+Mm1LYLA+vWmP3yaiAjoYP98JiID5QqW4+kmT1/wmNV7V/PiLy9Sf0x9Sg4vycC5A5m7aS6nzp264OMuV8mScMMN1rKJE7Pv963Zt4b7v7mfEm+XoM/sPvy287cMj212VTMmdZ7Erod2Mfzm4Vxd5OrsC0wI4VieiaF0I826FmVaWLYXbl1oUyTOcvfdUKuWtez+++HcOXviEf4xe+Ns7ph5h2WN4nAVztSuU4mvHG9jZL4FNDHUWu/RWie6/n8c2ABcCXQExrsOGw90CmRc4tJ5thbeeKOZoU0417Dmw1jcdzFDGw6lXMFyFzx2z4k9jEkcQ4cpHSj8RmHiJ8czZuUY9hzfky2xeXYn/fxzSPVjo+XJsyf5dNWnNBrbiJqjavL+8vc5mnTU57GFYgrxcOOH2XjfRhL6JNC9eneiI6L9F4wQIqhs2gQbNqRvR0TIePpL4ZkYJmxPsCcQh0mbiMbdunXeZSJ4fPPXN9w6/VaSU5PPl4WpMCZ1nkTnqzvbGFnGbFvHUClVBvgFqAbs0FoXcJUr4HDatsdjBgIDAUqXLl13+/btAYtX+FazJqxZk749ejQMGGBfPCJrtNZsOLiBuZvmMmfzHJbsXGLp6nAh9UrUI75SPPGV4qlVrJZfxtQdP27WBzvl1jj500/eLYlZtXrvakavHM2ktZM4lnTsgsfeUPYGBtQZwC1VbpEZQoUQ5732Gjz5ZPp2y5ZmzTmRNXuO76HE8BLnt8NVOIcfP0zeXHltjMo5+vSB8ePTt/PlM5USxYrZFpK4BPO3zCd+cjxJKUnnyxSK8Z3Gc2fNOy/wyKzz5zqGtiSGSqlY4GfgZa31l0qpI+6JoFLqsNb6gu1OssC9/TZvhsqV07fDwmDvXtNXXgSnAycP8M1f3zB381y+3/I9J86eyNTjSuUrRftK7YmvFE+Lsi0uq2WtZ0+YNCl9u08f+OyzrD/PibMnmLJuCqNXjmb57uUXPLZI7iL0rdWX/nX6U7FQxaz/MiFEjpaSYmaPTExML/vgA7j3XvtiCmZV3q/CpkObzm9/3f1r2lZsa2NEzrFvH1SqBMfc6jB79bImi8LZFm5dSNsv2nIm+Yyl/JMOn9Cvdj+//76gTgyVUpHAPOB7rfVwV9kmoLnWeo9SqjiQoLWufKHnkcTQfq++Ck89lb59ww2mdUfkDEnJSSRsS2Du5rnM3TyXHUd3ZOpxeSLz0Kp8K+IrxdOuUjuK5snaYoQ//AA335y+HRtrLpSZneAhcU/i+dbBiyW2Lcu1ZGCdgXSs0pGocFlNWAjh7dQpMzmW5zIV//4rywlcqkHzBjFq5ajz21flv4qEPgmUKVDGvqAcZMQIGDrUWrZ4MVx3nT3xiMxbvGMxN39+s9e8DB+1+4h76t2TLb8zaBNDVzfR8cB/WuuhbuVvAoe01q8ppZ4A4rTWj13ouSQxtF+9embmyDRSe5pzaa1Zu38tczbNYe7muSzbtSxTj1MoGpZsSHyleDpU7kDVIlUv2uU0JQVKlYI9bsMYJ00yazpl5HjScSavm8zolaNZuWdlxgcCRfMUpV+tfvSv05/yceUz9XcIIULTvn1mAfvlHp0OpCL08nz393e0mdTGUibJYbrkZLO+77p16WU1a5p7rvBw++ISF/b7v7/TamIrjp89bikf0XoEDzTMvoWZgzkxvB5YBKwF0qaUeApYCkwDSgPbgW5a6/8u9FySGNpr61Yo5zZviVKwaxcUL25fTCJw9p7Yy9ebv2bu5rnM/2d+pmcsLVOgzPkkselVTTNspXv0UXjrLbfHlYFp06B+/fQyrTUr96xk9MrRfLH2C06eu/BaWK3Kt2JgnYHEV46X1kEhxEVt3Aht25rrnbsSJWDhQtPdT1warTW9v+rNxDXWqaclOUz3yy/QrJm17P334b777IlHXNiK3StoOaGl14R2b970Jo9c+0i2/u6gTQz9SRJDe739Njzi9j6//npYtMi+eIR9Tp87zYKtC853Od19fHemHpcvVz5uLn8z8ZXiaVuxLYVyFzq/b80aUzvqLiLCrPM08P5jTPnzC0avHM2qvasu+DuKxRY73zpYtmDZLP9tQojQ9PPP0KkTHPFY0rRGDfj6a7O8jrg8yanJ9P6qN1+s/cJSLslhuh494Au3l6dAATO/g8zl4Cyr967mhvE3cPjMYUv5yze8zFNNnsrgUf4jiSGSGNqtcWP4/ff07XffhSFD7ItHOIPWmsQ9ieeTxMQ9iRd/EGb65utKXWdmOa0cT+VClbn9dsW0aeefGa5cBnVHE1ZzCqnhGbdQKhStK7RmYN2BtKvYjsjwyMv/w4QQIeOLL6BvXzh71lreqhVMn25miRT+kZyaTK9ZvZi8brKlXJJDY/duM8nfCbfh8nfdBWPH2heTsFq3fx0txrfg4KmDlvJhzYbxXPPnAhKDJIZIYminf/81Y8Dc7djhXSbErmO7mLd5HnM2z+Gnf36yTNt8IRXiKtCmXDzb57djzm8boe5oKLbmgo8pkbcEd9W+i7tq38VVBa7yR/hCiBCiNbzyCjz9tPe+u+6Cjz6CSKln8jtJDi/srbfM8Ap3v/8ODRvaE49It/HgRpqNa8b+k/st5U9c9wSv3PiKX5bxygxJDJHE0E7vvWdtHWzY0Np6KIQvJ8+e5Md/fmTu5rnM2zyPfSf3XfZzKh1G6wptuKf+QNpWbEtEWIQfIhVChJpz52DQIPjkE+99L79s1i8M0D1eSMooOSxToAwLey8M6eTw3DkztGLDhvSyunVh6VKZiMZOfx36i2bjmrHnxB5L+UONHuKtVm8FLCkE/yaGYf54EhFaZs60bnfpYk8cIrjkicpDxyodGdthLLsf3s3vd/3O/5r8jxpX1Mj6kx0tCQnD0O9uZfdb86iY2kGSQiHEJTl2DNq1804Ko6LMjMhPPSVJYXaLCItgwi0TuL3a7ZbybUe20WJ8C7Yd2WZPYA4QGQkjR1rLVq70XYkhAmPr4a3cMOEGr6RwcP3BAU8K/U1aDEWW7N1rZmRzf9ts2WKdoVSIrNp+ZPv5cYkLty7kXOo5r2PCVBiVaM/myQNI3dwaUtMTwZgYs+5T//5yAyeEyLydO01SuHattbxgQbNuYdOm9sQVqpJTk7lz1p1MWTfFUl6mQBkSeieE9DCBbt3MGNc0cXFmIppChTJ+jPC/HUd30PSzpmw/ut1SPrDOQEa1H2VLUihdSZHE0C6jRpnuNmlq14bEzM0vIkSmHE86zg9bfmDO5jn8tvM38kTmocvVXehbuy8l85VkyRKzpuG2bd6P7doVRo82N3VCCHEhq1ebpHC3x0TKZcvCN99AlSr2xBXqJDn0bedO85485Tb32j33mLGvIjB2HdtFs3HN2HJ4i6W8T60+fNLhE8KUPR0xJTFEEkO7tGxpXdT35ZdNNxshAunoUXNBnDLFe1+pUmZWweuvD3xcQojg8O23pgXGfbZHgAYNYO5cKFrUnriEIcmhb6+9Zsa7plEKli83Yw5F9tp7Yi/NxjVj86HNlvIe1XswvtN4wsPsG/ApYwyFLQ4ehIQEa5mMLxR2yJ/fJH+ffQZ58lj37dxpFgV+/nlITrYnPiGEc40eDfHx3klhp05m4XpJCu0XERbBxFsmclvV2yzlaWMOtx/ZnsEjc7YHH4SKFdO3tTYL3qem2hdTKDhw8gA3TrjRKym89ZpbGddpnK1Job9JYigybfZsSElJ365WzayvI4QdlII+fUxX5jp1rPtSU+G556BFC7OUihBCpKbCE0/A3Xdbr2UAQ4fCjBmQO7c9sQlvEWERfN75c6/kcOuRrSGbHObK5T0RzdKlMH68PfGEgkOnDtFyYkvWH1hvKe9UpROTOk/KcRPfSWIoMk1mIxVOVKkS/PYbPPyw977Fi8003zNmBD4uIYRznDljxia//rq1XCkzcdU778jU/06Ulhx2q9rNUp6WHO44Gno1fzffDLfcYi17/HE4fNieeHKyI2eO0OrzVqzZZ11HuV3FdkztOpXI8Jy3sKkkhiJTjhyBH3+0lnXtak8sQnjKlcssAvzdd97dwI4cgVtvhYED4eRJe+ITQtjn0CEzPn7qVGt5TAzMmgUPPGBPXCJzIsIimNR5ks/ksPm45iGZHA4fDtHR6dsHDsCwYfbFkxMdSzrGzZ/fTOIe6wyLrcq3Yka3GUSFR9kUWfaSxFBkyty5ZpHVNJUrQ9Wq9sUjhC833wxr1kDr1t77xoyBevXgjz8CH5cQwh5btkDjxvDrr9byokXh55+hY0d74hJZI8mhVZky3hP/ffCBXN/8ISk5icQ9ibSZ1IZlu5ZZ9rUo04KvbvuK6IjoDB4d/CQxFJni2RWvSxdZL0440xVXwNdfmxrVSI9eHhs3mlkH33vPuhanECLnWbIEGjWCv/6yll99Nfz+O9Svb09c4tKkJYe3XnOrpTxUk8NHH7WuIZ2aCoMHy7UtK06cPcGvO35l5NKR9Jvdj9of1ybvq3mpO7ouv+38zXJsk9JNmHvHXGIiY2yKNjBkuQpxUcePQ5EikJSUXpaYaNYwFMLJEhPhjjvMIsCe2rUzs5oWKRL4uIQQ2WvmTOjZ04wtdNe8OXz5pax1GsySU5PpPrM709dPt5SXK1iOhb0XUjp/aZsiC7x588wMu+4mTjTvfWF16NQhVu1dxao9q0jcm8iqPavYfGgzmovnQY1LNub7nt+TN1feAESadbKOIZIYBtKUKebmOk3ZsqZ7jrQYimBw4oQZQ/TZZ977ihUzF9GWLQMflxDC/7Q2vQUefdS75aRnTxg71oxJFsFNksN08fEmQUwTFweTJ0OrVvbFZCetNbuP7yZxTyKr9q46//NSW5TrlajHj3f+SP7o/H6O1H8kMUQSw0Dq2tU6I+mjj8Ibb9gXjxCXYupUMwHNsWPWcqXMe/rFFyEqZ44lFyIkJCebZSc++MB73zPPmLVNpUIz5ziXco4eX/bwmRwm9E6gVP5SNkUWWFu2mDkf3Ht1gVma5YUXvIdU5CSpOpV/Dv9jkj+3lsADpw5c1vOWzl+a2sVqc2PZGxlQd4DjxxRKYogkhoFy8qQZpH/qVHrZ779Dw4b2xSTEpdq6FXr0MGOPPNWvb2pZy5cPfFxCiMtz4oTp2eLecgIQEWEWtO/b1564RPY6l3KO7l92Z8Z660QIoZYcvvSSqfzw1KiRua6VKRPwkPwuOTWZDQc2WFoBV+1ZxfGzxy/5ORWKSoUqUbt4bWoXq02d4nWoVawWhXMX9mPk2U8SQyQxDJSZM63LUpQqBdu3S62rCF7Jyabl4OWXvbuaxcbChx/CnXfaE5sQIuv27IH27c2YYnf58plrmHQVz9kkOTTXshdfNNe21FTrvgIF4JNPoHNne2K7FKfPnWbt/rWmFdCVBK7Zt4aklKSLPzgDEWERVC1SlTrF65xPAmsWq0lsVKwfI7eHJIZIYhgo3bub2qY0Q4bAu+/aF48Q/pKQYMYc7drlva9HD5Mg5ssX8LCEEFnw55/Qti3s8Bg+VKqUmZ24enV74hKBlVFyWL5geRb2XhgSySGYJVh69PB9Xbv3Xnj7bev6h05w9MxRVu9dbWkJ3HBgAyk65ZKfMyYihprFalKnWB1qFzdJYNUiVckVkTMHGEtiiCSGgXDmjJmx8cSJ9LJFi+D66+2LSQh/OnQI+veHr77y3leunKkUadAg8HEJIS5uwQLTCnL0qLW8dm3TpbRECXviEvY4l3KOO2bewcwNMy3loZYcHjxouk57dqsGqFHDjLevUiXwcaVZuXslP2z54XwiuOXwlst6vgLRBc63AKb9rFSoEuFh4X6K2PkkMUQSw0CYOxc6dEjfLlbM1EKFyeqXIgfRGj7+GB580Htq+4gI0z3nscfkfS+Ek4wfbyp1kpOt5W3bmhvf2ODvHSYuwYWSw4Q+CZTMV9KmyAJLaxgxwly7zp2z7sud20zQ1Lt3YIcFnU05y+BvBjMmccwlP0fx2OKmBdDVEli7WG3KFCiDCvHxTZIYIolhIPTuDRMmpG/fe6/v2d6EyAnWrTOTV6xb573vxhvNZ0FaIISwl9ZmpsXnnvPed889MHKkqdARoUuSw3QrVsDtt5uZSz316AEffQR5A7A033+n/6PrtK4s3LYw048pV7ActYulTwpTu3htisUWy8Yog5ckhkhimN3OnoUrroAjR9LLfvoJbrjBvpiEyG6nT5ulK3xVgBQubNZCbN8+8HEJIcx1aeBA01ro6Y034JFHZGI0YZxLOcftM2/nyw1fWspDMTk8dsxUmrjPF5GmQgXTwl6nTvb9/r8O/UX7ye3ZfGizz/1hKowqhatYuoLWKlaLAtEFsi+oHEYSQyQxzG7ffQdt2qRvFy5sZn6TmlgRCmbPhn794L//vPfdf7+5CXXaAH4hcrIjR6BLFzOu0F2uXKY1v1s3e+ISziXJYTqtTcXm4MGmAtRdZCS8+SY88ID/K1YStiXQeWpnDp85bCkvV7AcjzR+hDrF61D9iurkjszt318cYvyZGMqoGeHTTGsPDG65RZJCETo6doQ1a6BFC+99I0eadTzXrw98XEKEou3b4brrvJPCQoVMTxZJCoUvkeGRTOkyhc5XW9dp2HJ4Cy3Gt+DfY//aFFngKWUqO1euhGrVrPvOnYOhQ81179Ah//3OTxI/4aaJN3klhU1KN2Fp/6UMqj+IhiUbSlLoMJIYCi/JyTBrlrWsSxd7YhHCLldeCfPnm/UOwz0mN1uzBurVMwtnB2mnCyGCwsqVZpFuz4qYChVgyRKTMAqRkbTk8JYqt1jK//7v75BLDgGuvhqWLTNdSz3NnQu1apnZ5y9HSmoKj81/jP5z+5Ocap0dqnfN3sy/c37QLSAfSiQxFF5++cVaa1SwoIwtFKEpPByeegoWL4ayZa37Tp+Gu++Grl19dzkVQlyeefOgaVPYu9da3rixSQorVrQnLhFcIsMjmdp1aobJ4a5jPhb9y8FiYsykM9OmQf781n3//gvNm5vZuFMuYRnBE2dP0GVaF9787U2vfa/e+Cqfdfwsx64lmFNIYii8zLCuD0uHDqYPuhChqlEjWLXKzFrq6csv/VPLKoRI9+GHpmvbqVPW8ltvNd1HC0uDg8iCCyWHzcc3D7nkEMxnadUqMzTCXWoqPPss3HQT7N6d+ef799i/NPmsCbM3zbaUx0TEMOPWGTxx/RMhv6xEMJDEUFikpHh3I+3a1Z5YhHCS/Plh0iQYNw7y5LHu27kTmjWDAQNg3z5bwhMiR0hNNbOL3nef+b+7Rx+FKVNMi4cQWRUZHsmUrr67lYZqcli2rKnUfPxx730LF0LNmvDttxd/nhW7V9BgTANW711tKS8eW5xf+v5Cl2tkPFKwkMRQWPz2m7XbTt68ptZICGEG8PfuDYmJULeudZ/WMHas6d722mtw5ow9MQoRrE6fNhPJvP22tTwszLQgvvGG+b8QlyoqPIopXafQqUonS3modisF0yPstdfMbPRFilj3HTwIbduaypqzZ30/fub6mTT9rCl7TuyxlNcqVotlA5ZRr4RfJssUASJfscLCsxtpfLyZDlwIka5SJVOJ8sgj3vuOH4cnnzSD/KdNk8lphMiMAwfMWHbPGbHz5IE5c2DQIHviEjlPVHgUU7tO9UoO//rvr5BNDgFuvhn++MP3nBJvvw3XXw///JNeprXm1UWv0nV6V04nW9fA6FC5A4v6LgqpJUFyCkkMxXmpqWa8lDuZjVQI36KizNpP8+ebRNHTtm1w223QpAksXx7w8IQIGsuWmQllfv/dWl68uJkMrV07e+ISOZckh74VLw4//AAvveQ9G/fy5VC7tqnwTEpOou/svjy14Cmv53j02kf5stuXxEbFBihq4U+SGIrzli0zM1KlyZ0bWre2Lx4hgkHLlrBuHbz7rpnB19Ovv0KDBtCrl/XzJUSoW7PGTDDTsCFs2WLdV7WqSRTr1LEnNpHzpSWHHSt3tJSnJYe7j2dh5pUcJDwc/vc/SEiAUqWs+44dg9v6HqTMszcx/o/xln0RYRGMjR/LGze9QXiYR1YpgoYkhuI8zy48bdua5FAIcWGRkTBkCPz9NzzwAEREeB8zcaJpWXzuOTh5MuAhCuEYmzaZGX5r1TLdRD3deKOpUCldOvCxidASFR7FtFun+UwOm49rHrLJIZiuo6tXQyf3RtXCG6B/Q/bmsk7DXTC6ID/0/IG76twV2CCF30liKAAzDspzfKHMRipE1sTFwYgRpgWxfXvv/adPw/PPQ+XKJlH0nHVRiJxs+3bo1w+uucbMLupr/G2/fvDNN97rqwmRXSQ5zFhcnBliNHIkRFSaD/0bQ9w/lmOKhlfk97uW0qJsC5uiFP4kiaEAzFo227alb+fKZVoMhRBZV7kyzJ1rxmpUq+a9f9cu07W0YUNYvDjw8QkRSHv2wODBZsbezz7zXSHSsCH8+CN88okZvytEIKUlhx0qd7CUh3q3UjCzcUc0GoXu0Qaij1p3bm3B/ld+59nBFTl61PfjRXCRxFAA3q2FrVubpSqEEJfupptMpcuoUd7TgAOsWGEmp+nWDbZuDXx8QmSngwfN2oPlysEHH8C5c97H1KxpKlGWLDFdSIWwS1R4FNNvne6VHG4+tDlkk8OU1BQe/O5BBn09iBSdYt2ZeBd8/h2cjmPqVDMeWCZaC36SGAqf3UhlNlIh/CMiAu6+G/76Cx57zHdryPTpZnmLJ54wg/uFCGZHj8KwYSYhfOst32t6Vq4MU6eaNUHbtzetEkLY7ULJYd3RdXl10ascOnXIpugC63jScTpO6ci7S9+1lCsUt8e9Re6fxkBK+gXtn3/g2mvN0hYyTCJ4KR2ki2zVq1dPr1ixwu4wcoS1a6FGjfTtyEjYvx8KFLAvJiFyqn/+gccf966MSVO0qJkqvF8/7+nChXCykyfh/ffNQvT//ef7mDJlTNLYs6fvSZqEcIKzKWfpOq0rczfP9doXHRFNz+o9GdJoCNWK+hgrkANsP7Kd+MnxrN2/1lKeOzI3X3T+go5VOrJpk1mS6Y8/vB/fti2MG+e7p4zwP6XUSq11PX88l7QYCq/ZSG+6SZJCIbJLuXKmhfDnn31Pxb9/PwwcaPb99FPg4xMiq5KSzOQU5cubVm9fSWHx4vDhh2ZG0j59JCkUzhYVHsWMbjOIrxTvte9M8hnGrhpL9Y+q03JCS+ZumkuqzjlNZEv/XUrDsQ29ksIr817J4r6L6VjFTNJTubJZUmbwYO/n+OYb00184cJARCz8SRJDId1IhbBB06ZmPMa4cVCihPf+NWvMGokdOsDmzQEPT4iLOncOxo41k8o88ADs2+d9TOHCpjvpli0waJBMLCOCR1py+EjjR8gd6Xvtrp+2/kSHKR2oNLISI34fwbGk4B4LMHXdVJqNa8a+k9YPc70S9Vg2YBm1i9e2lEdHm0qhL7/0blDYs8eMGx42DJKTszty4S8B7UqqlPoUaA/s11pXc5XFAVOBMsA2oJt0kEwvAAAgAElEQVTW+vDFnku6kvrHxo1mbFOa8HBzcS9UyL6YhAg1J0+a7ndvvmmWtPAUEWFqZZ99FgoWDHx8QrhLTTXLTQwbZtbu9CVfPnjkERg6VCYyE8Hv8OnDjE0cy/vL32fH0R0ZHpc3Ki/9avfj/gb3Uz6ufAAjvDxaa1785UWGJQzz2tfl6i5MuGVChslxmu3boXt3+O03731NmsAXX0DJkv6KWLjzZ1fSQCeGTYETwAS3xPAN4D+t9WtKqSeAglrrxy/2XJIY+sfLL8PTT6dvt2wJ8+fbF48QoWznTnjySZg0yff+uDh47jm45x4zFliIQNIaZs+GZ54xa3X6kjs3DBliksK4uMDGJ0R2S05N5quNXzFi6QgW78h4rSGFon2l9gxtNJQWZVqgHDy70pnkM9w15y6+WPuF176nrn+KF294kTCVuQ6GycmmwujVV73XKY2LMz1k4r1752Y7rU2l64kTcPy4+ZmZ/8fGmiWnatY0P/PkCXzsmRG0iSGAUqoMMM8tMdwENNda71FKFQcStNaVL/Y8khj6R506Zjr9NKNGmRkUhRD2WbbMtLQsWeJ7f5Uqpnte27Yym6PIflqbNTmfftosseJLVJTpKvrkk3DFFYGNTwg7JO5JZMTSEUxZN4WzKWczPK5a0WoMaTiEHtV7EBMZE8AIL27/yf10mtKJJf9aLzaRYZGM7TCWXjV7XdLz/vijmWDKV/fyoUPhtdfMetkZSUrKfPKW2f9f7kypSkGFCmayxho1TLJYo4aZUMvu63BOSwyPaK0LuP6vgMNp2xciieHlOXkSPv3UjAtJo5TpEy4XdSHspzVMm2ZmMN2+3fcxrVqZqcGr5cyJ8YQDLFoE//uf+elLeLiZQfeZZ6BUqcDGJoQT7D2xl1ErRvHRio/Yf3J/hscViinEwLoDubf+vZTMZ3+fynX71xE/OZ5tR7ZZygvFFGLWbbNoclWTy3r+ffugVy9TqeSpalWTZLknb+5JnK81T50qb970ZDEtYaxWLbBd6HNsYujaPqy19jmKRik1EBgIULp06brbM7pbEhnas8dMJz5qlPfMcc2aQUKCLWEJITJw+jS8+y688oq5YHoKCzOzmL7wgkwNLvxn+XKT7H3/ve/9SkGPHqbbWIUKgY1NCCdKSk5i6p9TGbF0BIl7EjM8LiIsgq7XdGVIwyE0KtkogBGm+/avb7ltxm0cP3vcUl6lcBXm3THPb+MjU1PN2Pn//Q9SUvzylEGjXLn0VsW0hLFsWXPN9reclhhKV9IA+OMPeOcdM/g3o5qY0aNhwIDAxiWEyJy9e01Xvk8/9R67AWayj6efNr0ALtRFR4gLWbfOJIRffZXxMZ07m4qIqlUDF5cQwUJrza87f+Xd399l1sZZF1zKosGVDRjScAhdr+lKVHhgpuwduXQkQ78f6hVXy3ItmX7rdApE+3+9siVL4I47Mu79EgjR0WbMYGysac3z/L9nWZ48pjFlzRpzD/33376vvVmRJw9Ur25NGGvUMNfvy5HTEsM3gUNuk8/Eaa0fu9jzSGJ4campprZ3+HDT3zsjkZFmXOHw4TKhhRBOt3o1PPRQxutDlStnZjjt3Nn+cQ8Xk5RkEt69e80FOO3fsWOmFap+fXMBjY62O9Kc76+/zMRGkydnfPPTpg28+CLUrRvQ0IQIWtuPbOeD5R8wJnEMR84cyfC44rHFua/+fQysO5AiebKn60dyajJDvxvKB8s/8Np3T917eK/Ne0SGZ99N4JEj0L+/99rZvoSHm+TMVwKX2cTOM8m73PvbkydNxdmaNenJ4po1cPTo5T0vmHGK7uMWa9Qw68KGh2fu8UGbGCqlJgPNgcLAPmAY8BUwDSgNbMcsV+FjeVwrSQwzdvo0fP65aSHcsCHj4woWNLMbDh7sex01IYQzaQ1z5piZHzNaLqBpU/MdUKdO4GM7dsw72fO17WshdE8REaaGtV49kyjWq2fGb0glln/s2GFa/8aNy7irV7Nm8NJLcP31AQ1NiBzj5NmTTFwzkRFLR7Dx4MYMj8sVnose1XswpNEQalxRw2+//+iZo3Sb0Y0ftlgH/IWpMN65+R3ub3B/QGZO1drcl65caZK1jBK7XLmcX7EJ5u/ZuTM9SUxLGP/66/Inu8md21zrPBNGz/UiIYgTQ3+SxNDb/v3w4Yfm34EDGR9XoQI8+CD07u3cqXeFEBd39qwZM/zCC75rLZUyn/OXX778yp+UFPO94p7gZZT8+VqL0Z9y5YJatdITxfr1oXLlzNeuCnOuXnkFPv7YvI98adDAJIQtWwbHTZoQTpeqU5m/ZT4jlo7g27+/veCxLcq0YEjDIbSv1J7wsEv/cvvn8D/ET45n/YH1lvLYqFimdJlCu0rtLvm5hW+nTsGff3q3Lh6+6CrtF1e6tPfMqFdfLYmhJIZu1q833UA//9x0zcpI06amC1r79nIDJUROcvCg6QY4apTvVp88eeCJJ+DhhyHGY7b0M2cu3LqX9v/9+509eUBsrGkddU8Wy5WThMbTf/+ZrsYjR5qbF1+qVzcJYXy8vH5CZJdNBzcxctlIxq0ex8lzJzM8rlzBcgyuP5h+tfuRPzp/ln7Hrzt+pdPUThw8ddBSXjp/aebdMY/qV1S/pNhF1mkNu3Z5ty5u2nT5rYsgiWHIJ4Zam3GDw4fDd99lfFx4OHTrZhLCen55ywghnGr9etO99NsMKqJLlYImTayJ35GMh71ku7AwKFoUiheHYsXMz+LFzZjCNWvMzJjbtl368xcsaL733LuhliwZmsnOsWOma/Hw4eb/vlSqBM8/b64Z2TFznhDC25EzR/gk8RPeX/6+19IR7mKjYulbqy/3N7ifioUqXvR5P1/zOXfNuctrjcWGVzZk9u2zuSJW1iZzgtOnTfdaz4Tx0KGsPIskhiGbGCYlmckBhg+HtWszPi5/fjOF/f33y9pSQoSa774zrYPr11/82OwQHe2d7HluFytmksKL9V44eNAsqr5ihUkUV6yA3bsvPbYrrrAmivXrmzhyqlOn4IMP4PXXM77RKF3aLDvRq5cZ0ymECLyU1BTmbJrDiKUj+Hn7zxkep1C0rdiWIQ2H0LJcS6+xgak6lWELh/HSope8Hnt7tdv5tMOnxETGeO0TzqG1dUbUtIRxw4aMeu5IYhhyieHBg6ab2Pvvm0VDM1KmDAwdahYcDuTimkIIZ0lONkvQPPtsVmseM1awoO8EzzP5y58/e1vldu+2JorLl1/e31iqlDVRrFvX/K1OorVZx/K//8zfmtmfhw9n3AW4WDGzxEn//rLEiRBOsnrvakYsHcEXa7/wavFzV7VIVR5o+AA9a/Qkd2RuTp87TZ/ZfZj25zSvY4c1G8awZsMCMsmMyB5JSb5bFw8ckMQwZBLDTZvM4tbjx194QofGjU130U6dpMZXCJHuyBEzXuy993yvYRoeblrRLta6V6yYc5eN0Nqsj+WeKK5cmXGXycxIWy4jLVmsXduMY/SH06ezltyl/cxoDdqsioszY07vu8/MfCeEcKb9J/fz8YqP+XDFh+w9sTfD4+Ji4uhfuz8J2xNYtmuZZV+u8Fx82vFTulfvnt3hChtoDWFhkhjm6MRQa/j5Z3j7bZg3L+PjwsKgSxczw2jjxoGLTwgRfHbsgAULzPeLe8JXuHDOnIwqNdVMGe7espiYeOkzpoaFwdVXW7uhXnONWdsqK8ndoUNmwh875M1ruhg/+ODlL6gshAicsylnmf7ndN5d+i4rdmf+3rdI7iJ8dftXXFvq2myMTthNlqsgZyaGZ8/CtGlm/OCqVRkfFxtruv488ACULRu4+IQQIpglJ5txl+7J4h9/+K8lzqmKFTPjBx97DAoVsjsaIcSl0lqz5N8ljFg6gpnrZ5KiM54qumqRqszrPo8yBcoELkBhC0kMyVmJ4eHDZizQyJFmKtuMlCplksEBA8wYHiGEEJcnKclM5OXeDfXPP/0xfbj/xcSYxC4uLnM/CxUyYyWjouyOXAjhbzuP7uTD5R8yOnE0/53+z7KvdYXWTO06lXy5pGtAKJDEkJyRGG7ZYsYPfvppxutJgemy9PDDpttoZGTg4hNCiFB06pTpteHesrhpk/+ePzIyPXHLbJIXF+e9BqUQQpw6d4pJayYxJnEMO4/tpH/t/gxrPoyIMJlwIlRIYkjwJoZaw6+/mu6iX31ltn1RCjp2NBPKXH99aK67JYQQTnH0qBmj6N6yuGuX6b3h2Up3sSQvTx75ThdCCOEf/kwMpTohQJKTYeZMM6HM8uUZH5c7N/Tta5acqFAhcPEJIYTIWP780KKF+SeEEELkRJIYZrOjR2HsWDNV/I4dGR9XooRZjH7gQFOrLIQQQgghhBCBIolhNkhONuNTJk82SeHx4xkfW6uW6S56220yQYAQQgghhBDCHpIY+kFKipnyfOFC82/RoosvrNyunZlQpnlzGWsihBBCCCGEsJckhpcgNdVMb56QYBLBn3+GI0cu/rjoaOjd24wfrFIl28MUQgghhBBCiEyRxDATtDaLIqe1CP78Mxw6lPnHFy0KgwfDPfdAkSLZF6cQQgghhBBCXApJDH3QGjZvTk8EExJg//6sPUfhwqabaPv2ZvxgdHR2RCqEEEIIIYQQl08SQ0wiuGWLNRHcsydrz1GwIDRrlj6dedWqEBaWLeEKIYQQQgghhF+FbGK4dWt6ErhwIfz7b9Yenz8/NG2angjWqCGJoBBCCCGEECI4hUxiuHNneovgwoWwfXvWHh8baxLB5s1NIli7NoSHZ0uoQgghhBBCCBFQOTYx3L07vTVw4ULTVTQrcueG669PbxGsWxcicuyrJYQQQgghhAhlOSbV2bfPmghu3py1x0dHw3XXmSSweXOoX18WnBdCCCGEEEKEhqBNDJOTYebM9ERw/fqsPT4qCho3Tm8RbNgQcuXKnliFEEIIIYQQwsmU1truGC6JUvU0rMj08ZGRJvlLSwQbNYKYmGwMUAghhBBCCCGykVJqpda6nj+eK2hbDC8mPNx0B01LBK+9FvLksTsqIYQQQgghhHCeHJMYhoWZCWLSEsHrroO8ee2OSgghhBBCCCGcL6gTw9q10xPBJk3M2oJCCCGEEEIIIbImaBPDWrUgMdHuKIQQQgghhBAi+IXZHcClksXlhRBCCCGEEMI/gjYxFEIIIYQQQgjhH5IYCiGEEEIIIUSIk8RQCCGEEEIIIUKcJIZCCCGEEEIIEeIkMRRCCCGEEEKIECeJoRBCCCGEEEKEOEkMhRBCCCGEECLESWIohBBCCCGEECFOEkMhhBBCCCGECHGSGAohhBBCCCFEiJPEUAghhBBCCCFCnCSGQgghhBBCCBHiJDEUQgghhBBCiBAniaEQQgghhBBChDhJDIUQQgghhBAixCmttd0xXBKl1HFgk91xZEJh4KDdQWRCMMQZDDGCxOlvEqd/BUOcwRAjSJz+JnH6l8TpP8EQI0ic/hYscVbWWuf1xxNF+ONJbLJJa13P7iAuRim1QuL0j2CIESROf5M4/SsY4gyGGEHi9DeJ078kTv8JhhhB4vS3YIrTX88lXUmFEEIIIYQQIsRJYiiEEEIIIYQQIS6YE8PRdgeQSRKn/wRDjCBx+pvE6V/BEGcwxAgSp79JnP4lcfpPMMQIEqe/hVycQTv5jBBCCCGEEEII/wjmFkMhhBBCCCGEEH4giaEQQmQTpZSyOwYhhBBCiMyQxDBA5AZRKKXk83aZlFKxwfBZUkqVUkpFa+mrH7KC4X0q/CsYzrlSKtzuGETgBcN7E4InzmBxKa9n0N+oKqWqKKWaKKVyKaUiXGVOfGPlAcfGdp5SqqJSqqFSKo/dsVyIUqq6UupGpVRxJ7+mrvdmPwCtdaoTk0OlVLxS6jG747gYpVRH4C3gCrtjuRCl1M3ATKC0a9tx5xxAKdVYKdVPKXWdUira7ngyopSqrJRqpJSKcPJ3vFKqjlKqo1LqKqVUbq21dtq5d+LrFsyUUvWVUrcqpWo7uSJIKdVCKfU0gNY6xWnvS3fB8h5VShVWSkXaHcfFKKUqKaXyOfi92Uwp9YhS6jalVH6nxunJqe9Tf1yHHPvlkBlKqc7AHOBp4DPgAaVUnOuFcMxJU0rFA0uUUk2cFps7pVR74EvgZWC8Uqqmq9xR8Sql2gBfAPcC44GS9kbkTRm5gfeBx5RSD8D55DDC3ujSKaVaAS8Aq+yO5UKUUk2B14CZWuu9Hvsc8/50vZ6vAQWBh8Ccc1uD8kEp1QH4GLgeeAQo47bPSa9nR2AG8DDwDnBv2k2Ow+LsAEwBegDPA68rpYo7sDIoHzi3siKNUqqGUqqNUqqcUiqX3fH44roOfQq0xpzzOvZG5M11HcqF+Yw/qZR6Cc5fhxyX1LjulV500mfbF6VUJ+A9XJV/TuW6Hn0FNHFtO6q12HW+R2Aqe+OB+m77HPUeUErVcn0nlXRwxZ9frkOO+qOywnVz3QW4S2t9MzANKIq5CY9zSq2DUqoq8AbwGzBCKdXUaTc1AEqpRsCbQG+tdUtgF/AYgFNeSzC1S5gv5P5a6y7AUaCqa59j3s/aOAVMwEwjXCutVU5rnWxrcC6ucz4JuEdrPV8pVUApVVYplddJyatLTeAzV5wlXF/Q17pVBNl+7pVSNwIfAXdqrSsCZZRSN9gclhelVBwwCOipte4HHADqKKWKKaXyOOX7yRXnAOB2rfWtwHKgF/CwUqqgk76XgDbAI1rrbpjvp8PAu0qpYk6pGFBK3QL8q5Rq48CE9TxXBeUk4G7gJUzi5agbRbfrZX+t9V2Y62V5pVSMcrW+OyFe13UoCVOB+gRQTSk1wrXvnK3BeVCmp8ULQILnZ9sJr2Ua17l/HRittd7isc8xnylXUvg6sA/oCqa12Nag3LgqznsBA7TWjwLbgarK9AJ0zHUdzidcE4HOwFDgZaVUYQd+j/rlOuSkPyirFJAfqA6gtf4KmOva191BJ2sf8LLW+m5gJPC+UqqZU26+3KQCr2utE13bzwKxSqkYG2PyZRcwUGu9VClVHFMTdo9S6hOgn3JIlzi3c5sElMdcmGsopUYqpd521eTanXztA04B5ZRShYHZmBbO8UAfJ9TUu72OGkir4Z4O9MTcOH6olCrqkJtvjUm21iml8gMbgRrgrBsb4BwQg0kGCwI3AbdhWuSeUc7pznMOyIurNVNrPQH4B/O93x4cdSMWBlwN4PoOHYM5/4864TtUKVUeeBBTUfW5UqqtA29qUErVxVSk3qm17gQkYj7rjqqgBLZhKtSWKqWuwLwfb8e0fjjpM5QmCrgGc1NbUSk1XSk1WSkV5oSWQ2V6J30MPK+1/lEpVVCZ7rlXOamyyqU8MEdrnaDMWPI7lFKdL6VlJru4KiQ/BvporVtgKgR62hyWpxSgENDMdS93G9AcU4HxkVOu667v7+6YRpMBwDzgOuBtp8QI56+F4ZjP+WVdh2x/A2eVUipKmb785zAXkJuVUi1du3/DdIlrgs1/myvOGK31QWAqgNb6M2A41uSwgp034K44o7TWy4BZrrJIIBrTTSK/q6yYnYmM2+v5t9Z6oav4TmCk6wZiAXAz5ovGNm6vZ9pNwVxgn9b6Z0yLx11AXldNri0th64Yc2utt2Jes+eBdcDnWut2mPdBK0x3SNsopaJITwbnAz2UUjOBT7TWPTCVF4eAejaFCFjO+QKt9RKllNJaH8W8jk8qpeo54SbR7bvzOGas5r3A18A4rXVHTGvnFZgbH9t4xDkBuEMpdbdS6hUgGViDed86qZvuB5g4b3Vt/wt8i+nFkt+2qNIdBN7RWt8H9AemKKXaed7IOuDm+z9ghNZ6tWv7HSC/UupKG2PyorXeq7Ve7NqMB950fXdOwFRklLUrNndu53YWcERrvQ1T8dcWiNFapzqk5fAAsAUorJSqhbluPge8DfxPOWCMnNtn4ygmqQGYjElmWgOzlVKlHPKdtAe4Q2v9hyvuz4GK4IjPOACuluzHMAnhOGCq1voWzHk/DDSwLTirVMx1Ma0RKgFYDZzANErYnWtEKKVyud53o/DDdSioEkOlVBfM2LI5yvRN3oEZY9hNKXWT62Z7KiY5qOWAOGcrpdphar0B0FqPwySHbyil3nf935YaZVeck4G5Sqm2mFZYMB+EE8BhrfVepVR34EXAlgTW8/V0tXKgtX5Da/2y6/+TMK+jbTcQbnHOc8WZDzgCXKWUuhcYjBm/WUQpdb/NMX6llOqotd4I3AgM01qPAdBaT8RMlmTb2E2P17ID8Dfm9atBeo3YdkwNWTGb45xM+jk/38XRVRnwPtDGVTNv2/etx3dne0yi3QxIADYAaK1/AWKBcjaF6RnnzZjKlOmY8VtRWuvuWutPMcmCbQmXMhP33J62rbVeAwzDtLR3c12LfgcK4LqhsJOromKe6/+zMF24piil2ruSw9pKqVi7b75dlVUT4PxwkWjM9TO3q6y8sqlXiOc5T/s8a63Haq3fc/1/MaYyy7YJstzjdEv8I4ASSqn/YbprPohJwl6xK053WuvdQD/gVszEXeNdlVVp4/iusjE8wNJivRpzzzkTmKS1vltrPRBYhKvbs9201hu01r8rpcJccS8CeiulWtj5GffxvbkC05AzH9MbBFflRSRQ3I4YPbkS2Dcx3+1PKqXeAuIwlS2V7KwIcN23j8NcL290tRI+D/S9rOuQ1joo/gGVMDcwjYE7MAnhIMxNbV/gG2CI6/8bgGIOinMIUMHjuMmYWrKaDouzvNsxn2FaZVcA1R0WZ0WP47piuh0Vd1CcDwMVgCcxXY/iXcc2AUo6JMZHPD8rrtdylcM+Qw9gEsJbgL8wSeIAYKXnZ8sB7033z1AHYCkQbUeMF4jzQaCw6734GdDR9S8RKOuAOLtjujY/AJTwOK6X6zXNa1OcrYCTmElxBrqVx7rO91rMhGhDXX9PKZvibIwZn5m2Hebx8xZMS+IYTAVBEYfFGen6OQdTUdUNM7FCAZvP+QC38nCP4zq7PkOlbXotfcbp2tffdR3q5NouA1xlR5y+zrurrCSmO7572QzgJofFWQvYCUx0K3sVeNApcQLK4+f9mNbifDbF5/N707WvLiY5HIBpQbTtup7BaxkDNMW0YD/tVv61jd/vbUjvPTMQ2IvrPv1yr0N2j3HKioKYLnlLMDN8bgf6YMb1zAY2Y7pGnQK6a4+ZC22McxumJkwrpcZprY+5+n9XB27QWq91YJwTMR/gazEX5BZa678cGOdeTNey7pgkrJvWeo/D4jyOafX4QWu90nXsr9qeWqaMYuymlPoM89nphene0dVhn6G+rn3vYxLD2zC1in201n/bEuWF35vjtdZHtdZzXN06igNbHRZnd+AnzPtzKHAa83o6Kc6+QJgyY4hPAL2BxzGf9eM2xVkO0/K/GuiolBqotR6ttT6BqbndgunmXhBzc7Ez0AEqM/HELOBbpVRerfUYbVqPlOtnmNZ6lqvnzS2Ya9EBm+PM53od0+JM6+K4F9PN+Rqgr9b6SKDjxPuc43pNU1xd8yIw9yMPYb47d9gQY4ZxuvYtAtporTe4zv82m2L0+f4E0Fr/i+n2mHZcF0zX9o0Oi3O1Uuo2TE+RRzG971phvlMdEafWZlymdmUKwGLMZ70gcMyGMD3fmwPc3pvrMXNw3IfpqtvXrut6Bt9Jp4FfXP/SjrsTKIG5LgU6xlhMYvi01vp7V9mVmB5Va133HZd+HbIj072MDHkCptYwwrV9Hab/bBvXdjiu2kaHxXmtK85Wru0i2FSjmMk4017PHsA1Do7zJtd2K0yTvtPivA7Tkn2ja1vhqr1zUIye783rgcoOfC3T4mxrd2xZeT2d8u8Ccd7g2s6DTS1wWXk9MRfi8nbF54pBYWqQYzETjozCTERi+3l2i/Ee4CnMWLKPsbZypbUgNMCMy6/h0DgjXa91AqZ3jZ0tCL7O+d1u+8MwMydXtCvGC8TpqPdmJs572vuzL7AJqOqgOD1buspiWmKfwsZ7pYu8nmFu/38P+3qEXPS9iZkkKZddr+PFzrnbe7MzsMyu707X900NzPJDaT0sXgA+9Mfzp/2RjqSUaoC5OJzVWi9XZqHwmphs/let9TmlVG+gHdBD2zSIOotx3qlNn2WnxtmL9BnW0Da0bGXx9bzdjhgvIc7u2obJZoIhRonTtjj7YC5+PbXWZx0cp5O+O5O0GReTVp7PFVsz4HvMTc9xbWbJto2rFSsaU1naHjNBxiqt9cdux+THTEBiV8+AzMbZBPhPa/1ngGPLyjk/oc3YzYALtvcmZPq8VwTQ9vVWylScTnCxOJWZHC3g3/HB8hlyl8n3ZmHMd2dAe4O4Xs8ozOf4D1dZhNY62dUzqY7W+kml1B3ADq31r5fyexzblVSZSVtewfThLa2U2q+1fkgp9QTQCSiFWVdEA2cwE6YEQ5x23ShmNk4wSywobcOaN1l8PZNInzDHyXGecf10coxJdsR4CXHa8lrm0DhTXXHasrZVkH53llRKndZm+SG0GRrwNbAfM8aoMqbV3Y44PW/CTrvKv8F8TzZTZi3DWOCk1vpLTLctJ8dpy81iFs95FUzvkIALlvemK9ZLeX86PU7bEu2sxolZ6D6Q8eXU9+YprfVMG2J0fz1LuV7PgW6Vz0eBE64E8TnMNfTSZHeT56X8w8xA9i3pXfBKY6alf9e13RNzw5CAGWBZW+KUOCXO4IpR4pQ4gzTO/cCnHsc9CuzGpu5kmNr3PzA3DhOAjz3258NM1LYMcwNh12RiWYnzmB1xBtE5D4o4g+W8X0KcwfI5CnicOfi9acs5z8zriZlw5pwrzqsv6/fZdTIu8iLkAaYB1dzK3sQMQH7Rraw6UFTilDglzuCLUeKUOIM4zj+Bt93KHsJ047EjxqC4CQuiOB1/zoMszmA57xKn/2KU92aAX0/MOpULucykUGvtrHUMlVKVALTWJzF/8HdKqW5KqY8xg1bbAg9PV+kAAAX/SURBVMVV+jp2a7XW+yVOiVPiDJ4YJU6JMwfEGQ/kU0rFuY4brs0aUnZQmK5i+1yx7MBMS99QKfW223EpQHut9frAhwg4PM5gOefBEqcbR593NxLn5QYm703/Bpf51zMfZvmUrlrrDZf7ex2TGCqz6PJqpdRUAK3185iMuBJmkfAHtdb/YGb0tGWBW4lT4nRynMEQo8QpceagOIsCuWyMMyhuwoIhziA650ERJwTHeZc4/RqfvDf9G2NWXs+8WuszWutDfvnll9vk6I9/mGbS7zCLNI4DJmdwXE/MWiyFJU6JU+IMrhglTolT4vRbnO0x645OdSsbglnQ+HXSF4efDRS3I8ZgiTOIznlQxBks513ilPemE19LJ7yetpyYDP7AEpgZfwoDM4Av3PZFAK0xgyprSZwSp8QZnDFKnBKnxHnZ8QXFTViwxBkM5zyY4gyW8y5xynvTqa+l3a+nI9cxVEoVAkYDp7XWPZVS1YBywDJt45pLniRO/5I4/ScYYgSJ098kTv9yapxKqRKY2RujMQtFn9Vad3ftiwBaYhY8Hqi1Xi1xZp5Tz7knJ8cZLOdd4swe8t70r0C/no5MDOH8ApJvAtdixkI201rvtjcqbxKnf0mc/hMMMYLE6W8Sp385PU4n34S5C5Y4wfnnPE0wxBks513i9C95b/pXIF9Px0w+40lrfRBYA+QHOjvtDZVG4vQvidN/giFGkDj9TeL0L6fHqc2EA3cD55RSm4BZwAqn3dgES5zg/HOeJhjiDJbzLnH6l7w3/SuQr6djE0NlpitvC7TSWq+1O56MSJz+JXH6TzDECBKnv0mc/hUMcQbDTRgET5zBcM4heOIMlvMucfqPvDf9K5Cvp2O7kgIopaK11mfsjuNiJE7/kjj9JxhiBInT3yRO/3J6nK6bhmnAw1rrNXbHk5FgiROcf87TBEOcwXLeJU7/kvemfwXq9XR0YiiEEEKIiwuGmzAInjiFfwXLeZc4Q4+8llaSGAohhBBCCCFEiHPsGEMhhBBCCCGEEIEhiaEQQgghhBBChDhJDIUQQgghhBAixEliKIQQIuQopWYqpbYopaJ97PteKbVBKRVlR2xCCCGEHSQxFEIIEYqGAEWBJ90LlVJdgVbAIK31WTsCE0IIIewgs5IKIYQISUqph4GXgWpa67+VUnmAjcACrXXvbP7dMVrr09n5O4QQQoiskBZDIYQQoWoEsAkY6doeBuQGHkk7QClVSyn1nVLqhFLqqFJqslKqiNv+fEqpj5RSm5VSp5VS/yilRiilYt2OiVZKaaXUYKXU+0qpg8DywPyJQgghROZE2B2AEEIIYQetdbJSahCwWCn1DDAUuE9rfQBAKXU1sAj4FegO5MK0MM4Crnc9TV4gBdMl9eD/27t/0K2qOI7j70MOuuVYFLUEglMQVBC4FG21FCRKQzQ7tkhNbdLU0BBC0Bg0BNJQv8FFHISIcHByEcSGhiAkK07Dc6V6eApKn0Du6wWXA/d+Offc6fK5f86pnqzOLu2rW6c8Wx1Up/d2UQDwH/mUFIBVG2N8XL1dXapemMuNcYzxWXWsenrO+euy73j1XfXSnPNgR1+HqhPVV9Ujc85bywQ3t6vLc87n/49rAoB/y6ekAKzduaX9YP71aemL1ee1CXxL6LtW3ayeuVs0xnhrjPHtGOOn6pfq62pUT22d58Kexg8A90wwBGDt7my1jTEeqh6u3msT9v68PVo9vtSdrM5XF6vXqmerN5ZutpfCuLWf4QPAvfOPIQBsmXP+Nsb4sfqk+nRHyfdL+3p1cc555u6BMcbRv+v2vg4SAO4jwRAAdjuojs85r/xDzZHq5619p/Y3JADYD8EQAHZ7t7o8xviizZvDH6rHqperj+acl9pMMnNujPFO9U31Sn/MWAoADwzBEAB2mHNeHWM8V73f5j/Cw9WNNmHw+lL2YfVEm7UPD1dfVm+2WeYCAB4YlqsAAABYObOSAgAArJxgCAAAsHKCIQAAwMoJhgAAACsnGAIAAKycYAgAALBygiEAAMDKCYYAAAArJxgCAACs3O9oOkaVHRo44wAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -403,9 +411,18 @@ "Initializing NUTS using adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [sigma, yto, xto, delta, gamma, beta, alpha]\n", +<<<<<<< HEAD "Sampling 2 chains, 0 divergences: 0%| | 17/5000 [00:06<52:54, 1.57draws/s] /home/osvaldo/anaconda3/lib/python3.7/site-packages/scipy/integrate/odepack.py:247: ODEintWarning: Excess work done on this call (perhaps wrong Dfun type). Run with full_output = 1 to get quantitative information.\n", " warnings.warn(warning_msg, ODEintWarning)\n", "Sampling 2 chains, 0 divergences: 100%|██████████| 5000/5000 [16:18<00:00, 5.11draws/s] \n" +======= + "Sampling 2 chains, 0 divergences: 0%| | 0/5000 [00:00>>>>>> re run existing ODE notebook to comare against pymc3.ode ] }, { @@ -463,7 +480,11 @@ "outputs": [ { "data": { +<<<<<<< HEAD "image/png": "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\n", +======= + "image/png": "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\n", +>>>>>>> re run existing ODE notebook to comare against pymc3.ode "text/plain": [ "
" ] @@ -484,6 +505,14 @@ "execution_count": 10, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/demetri/anaconda3/envs/gsoc/lib/python3.6/site-packages/pymc3/stats.py:991: FutureWarning: The join_axes-keyword is deprecated. Use .reindex or .reindex_like on the result to achieve the same functionality.\n", + " axis=1, join_axes=[dforg.index])\n" + ] + }, { "data": { "text/html": [ @@ -519,6 +548,7 @@ " \n", " \n", " alpha\n", +<<<<<<< HEAD " 0.547774\n", " 0.064518\n", " 0.001900\n", @@ -526,11 +556,21 @@ " 0.674063\n", " 1074.385749\n", " 1.004643\n", +======= + " 0.546238\n", + " 0.062607\n", + " 0.001882\n", + " 0.431009\n", + " 0.683215\n", + " 943.313994\n", + " 1.001490\n", +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.549\n", " 0.065\n", " \n", " \n", " beta\n", +<<<<<<< HEAD " 0.027826\n", " 0.004243\n", " 0.000121\n", @@ -538,11 +578,21 @@ " 0.036248\n", " 1188.103693\n", " 1.004166\n", +======= + " 0.027682\n", + " 0.004183\n", + " 0.000121\n", + " 0.019921\n", + " 0.036197\n", + " 1038.814557\n", + " 1.000905\n", +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.028\n", " 0.004\n", " \n", " \n", " gamma\n", +<<<<<<< HEAD " 0.799796\n", " 0.091914\n", " 0.002793\n", @@ -550,11 +600,21 @@ " 0.986809\n", " 1016.646894\n", " 1.004327\n", +======= + " 0.800985\n", + " 0.089085\n", + " 0.002686\n", + " 0.624201\n", + " 0.969263\n", + " 899.887191\n", + " 1.001295\n", +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.797\n", " 0.091\n", " \n", " \n", " delta\n", +<<<<<<< HEAD " 0.024069\n", " 0.003645\n", " 0.000106\n", @@ -562,11 +622,21 @@ " 0.031578\n", " 1112.997961\n", " 1.003657\n", +======= + " 0.024174\n", + " 0.003591\n", + " 0.000106\n", + " 0.017432\n", + " 0.031091\n", + " 903.692124\n", + " 1.001325\n", +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.024\n", " 0.004\n", " \n", " \n", " xto\n", +<<<<<<< HEAD " 34.000197\n", " 2.847582\n", " 0.049229\n", @@ -574,11 +644,21 @@ " 39.662715\n", " 2817.162400\n", " 0.999849\n", +======= + " 33.958321\n", + " 2.995589\n", + " 0.065663\n", + " 28.476836\n", + " 40.251438\n", + " 2216.184676\n", + " 0.999667\n", +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 33.960\n", " 2.909\n", " \n", " \n", " yto\n", +<<<<<<< HEAD " 5.929431\n", " 0.544950\n", " 0.012043\n", @@ -586,11 +666,21 @@ " 7.009603\n", " 1610.164705\n", " 1.001869\n", +======= + " 5.954806\n", + " 0.528449\n", + " 0.011694\n", + " 4.940673\n", + " 6.990385\n", + " 1583.237072\n", + " 0.999951\n", +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 5.949\n", " 0.533\n", " \n", " \n", " sigma__0\n", +<<<<<<< HEAD " 0.248297\n", " 0.043430\n", " 0.000802\n", @@ -598,11 +688,21 @@ " 0.339778\n", " 2382.238210\n", " 0.999667\n", +======= + " 0.248752\n", + " 0.044778\n", + " 0.000940\n", + " 0.174250\n", + " 0.341214\n", + " 1984.170678\n", + " 0.999723\n", +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.248\n", " 0.045\n", " \n", " \n", " sigma__1\n", +<<<<<<< HEAD " 0.250990\n", " 0.043695\n", " 0.001096\n", @@ -610,6 +710,15 @@ " 0.342321\n", " 1744.876212\n", " 0.999668\n", +======= + " 0.252926\n", + " 0.044053\n", + " 0.000971\n", + " 0.175737\n", + " 0.337417\n", + " 2414.840347\n", + " 1.000093\n", +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.252\n", " 0.044\n", " \n", @@ -619,6 +728,7 @@ ], "text/plain": [ " mean sd mc_error hpd_2.5 hpd_97.5 n_eff \\\n", +<<<<<<< HEAD "alpha 0.547774 0.064518 0.001900 0.419362 0.674063 1074.385749 \n", "beta 0.027826 0.004243 0.000121 0.019341 0.036248 1188.103693 \n", "gamma 0.799796 0.091914 0.002793 0.631756 0.986809 1016.646894 \n", @@ -637,6 +747,26 @@ "yto 1.001869 5.949 0.533 \n", "sigma__0 0.999667 0.248 0.045 \n", "sigma__1 0.999668 0.252 0.044 " +======= + "alpha 0.546238 0.062607 0.001882 0.431009 0.683215 943.313994 \n", + "beta 0.027682 0.004183 0.000121 0.019921 0.036197 1038.814557 \n", + "gamma 0.800985 0.089085 0.002686 0.624201 0.969263 899.887191 \n", + "delta 0.024174 0.003591 0.000106 0.017432 0.031091 903.692124 \n", + "xto 33.958321 2.995589 0.065663 28.476836 40.251438 2216.184676 \n", + "yto 5.954806 0.528449 0.011694 4.940673 6.990385 1583.237072 \n", + "sigma__0 0.248752 0.044778 0.000940 0.174250 0.341214 1984.170678 \n", + "sigma__1 0.252926 0.044053 0.000971 0.175737 0.337417 2414.840347 \n", + "\n", + " Rhat STAN_mus STAN_sds \n", + "alpha 1.001490 0.549 0.065 \n", + "beta 1.000905 0.028 0.004 \n", + "gamma 1.001295 0.797 0.091 \n", + "delta 1.001325 0.024 0.004 \n", + "xto 0.999667 33.960 2.909 \n", + "yto 0.999951 5.949 0.533 \n", + "sigma__0 0.999723 0.248 0.045 \n", + "sigma__1 1.000093 0.252 0.044 " +>>>>>>> re run existing ODE notebook to comare against pymc3.ode ] }, "execution_count": 10, @@ -670,9 +800,15 @@ "name": "stderr", "output_type": "stream", "text": [ +<<<<<<< HEAD "/home/osvaldo/proyectos/00_PyMC3/pymc3/pymc3/sampling.py:1076: UserWarning: samples parameter is smaller than nchains times ndraws, some draws and/or chains may not be represented in the returned posterior predictive sample\n", " warnings.warn(\"samples parameter is smaller than nchains times ndraws, some draws \"\n", "100%|██████████| 500/500 [00:06<00:00, 73.96it/s]\n" +======= + "/Users/demetri/anaconda3/envs/gsoc/lib/python3.6/site-packages/pymc3/sampling.py:1109: UserWarning: samples parameter is smaller than nchains times ndraws, some draws and/or chains may not be represented in the returned posterior predictive sample\n", + " warnings.warn(\"samples parameter is smaller than nchains times ndraws, some draws \"\n", + "100%|██████████| 500/500 [00:05<00:00, 91.69it/s] \n" +>>>>>>> re run existing ODE notebook to comare against pymc3.ode ] } ], @@ -690,7 +826,11 @@ "outputs": [ { "data": { +<<<<<<< HEAD "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4wAAAJhCAYAAAAKZz5KAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzdeZzN9fcH8NfbWIdsgzSyJntRTVJEUdojhLSQkBDaLJE1JLJGWUoqS4k2WcKXoki02cqWfd+zm7nn98eZ+c29szDL59735977ej4e87h3Pve6n8OM+7nnvZxjRARERERERERESWWxHQARERERERG5ExNGIiIiIiIiShETRiIiIiIiIkoRE0YiIiIiIiJKERNGIiIiIiIiShETRiIiIiIiIkpRVtsBOK1QoUJSqlQp22EQERERERFZsXbt2iMiUtiJ1wq5hLFUqVJYs2aN7TCIiIiIiIisMMbsdOq1XLMk1RjzkjFmgzFmvTFmhjEmpzGmtDHmF2PMFmPMZ8aY7LbjJCIiIiIiCheuSBiNMcUAdAYQIyJVAEQAaA5gKICRInI9gOMAnrMXJRERERERUXhxRcIYLyuAXMaYrAAiAewHUBfAF/GPTwXQ0FJsREREREREYccVCaOI7AUwHMAuaKJ4EsBaACdEJDb+aXsAFLMTIRERERERUfhxRcJojCkAoAGA0gCiAeQG8EAKT5VU/nw7Y8waY8yaw4cP+y9QIiIiIiKiMOKKhBHAPQD+FZHDInIJwBwAdwDIH79EFQCuBbAvpT8sIhNFJEZEYgoXdqR6LBERERERUdhzS8K4C0ANY0ykMcYAqAdgI4ClAJrEP6clgK8txUdERERERBR2XJEwisgv0OI2vwFYB41rIoDuAF42xmwFEAXgA2tBEhERERERhZmsV35KYIhIXwB9kxzeDqC6hXCIiIiIyI8uXQIOHACuuQbIGv+JdPJkYPlyoGZNoF07u/ERkXJNwkhEREREwU8EuHgRyJFDv9+9G/joI2DfPmDvXv3atw84eFCfu2ULULasPnfpUmD6dOCTT4DatYEKFaz9NYgoHhNGIiIiIkq3efOAv//2TQITbp99Fhg/Xp936BDQp0/yP2+Mzi6ePJl4rHVr/f6774AhQ4CpUwPzdyGi1DFhJCIiIiIAmtz98otvAphwf98+nS3MlUuf+/bbwA8/pPw6R48m3i9TBujZE4iOBooV06/oaKBo0cSlqAnq1dPnL1gATJsG9O2r3xORPUwYiYiIiMLA7t265DNpMvjMM0DHjvqcVauABg1Sf419+4DrrtP7jz0GVK2amAB6J4N58iT+mQIFgMGD0x5n6dLA00/rMtYhQ4BJk9L9VyUiBxkRsR2Do2JiYmTNmjW2wyAiIiJyjdhY3Se4c2fyxzp0AMaN0/sbNwKvvppyElisGFCoEJAlADX2N28GKlYEIiKArVuBEiX8f06iUGKMWSsiMU68FmcYiYiIiELcvHmaLEZHAy1a+CaD3ks+K1XS59pWrhzQpg2QPz+QO7ftaIjCGxNGIiIiohB3001Ar1663PO552xHkzYTJtiOgIgAJoxEREREIa94ceDNN21HkXEiWlWViAIvAKvQiSjBTz8B/foB58/bjoSIiMj9RLTozY03agVXIgo8JoxEAeLxaGGB/v2BKlW0ZDgREZE/xcYC994LjBoFXLxoO5r0Mwb45htg/Xpg5Ejb0RCFJyaMRH7WrRvQuTNw5AgwdixQuTKwbRvwwANAkyZa5pyIiMgf5s8HFi/WKqjZstmOJmN699bbd98Fjh2zGwtROGLCSORHu3YBo0frRe7AAaB2beD334Fhw7Tq2+zZWjZ8+HDg0iXb0RIRUaiZOFFv27UL3j2At92ms6SnTwNjxtiOhij8MGEk8qMBA3QJUPPmuv8C0BHeV18FNm0CGjcGzpzRxsQnT9qNlYiIQsvu3doiI1s2oFUr29Fkzhtv6O3o0cCpU3ZjIQo3TBiJ/OSff4CPPtKmw/37J3+8eHHgiy90udCECdoMGdAEkxv7iYgosz78UPfPN2oEFC5sO5rMufNOoE4d4MQJXbVDRIHDhJHIT/r2BeLigNatgeuvT/1599+vexkTvPMOUL48MH68/nkiIqL0io0FJk/W++3a2Y3FKQl7Gb/8UqunElFgMGEk8oM//gA++wzInj1xGU1aiABr1+oIaseOum/j11/9FycREYWmhQuBPXuAsmWBu+6yHY0z6tUDvvoK+Pnn4N2PSRSMmDAS+cG8eXrboYMuPU0rY4BZs7QYzrXXavJ4223ACy8Ax4/7J1YiIgo999yjA5eDBwNZQuTTnjFAgwbBW+2VKFgZCbE5/ZiYGFmzZo3tMIiwahVQpgxQpEjG/vzp01o0Z+RIXVpUuHDiaxIREYWzw4eBrVuB22+3HQmROxlj1opIjBOvFSJjTkTuU6NGxpNFAMiTB3j7bW3DceedQIUKQOnSzsVHREShKdT3v69fD5QsCTRtCly4YDsaotDHhJHIQatX694KJ1WpAvzwA/D114l7NrZuBbp1A/77z9lzERFRcIuLAypXBp59NnTbT1SqBFx3ne7RnDrVdjREoY8JI5FDRIBOnYCaNXXfiJOMAQoUSPy+Sxdg2DCgYkVtzRFiK8uJiCiDFi7Utk7Ll+tKlVCUJQvQq5feHzIEuHTJbjxEoc4VCaMxprwx5g+vr1PGmK7GmILGmEXGmC3xtwWu/GpEdnz9tVY0vfpq4OGH/Xuu/v2BW28F9u4FHn8ceOABYMsW/56TiIjcb8IEvW3bNnSK3aTk8ceBcuWAHTuA6dNtR0MU2lzxViIi/4hINRGpBuAWAGcBfAmgB4AlInI9gCXx3xO5TlxcYvuMXr2A3Ln9e76YGGDlSuC994D8+XVEuUoV7f147px/z01ERO60dy8wdy6QNSvQqpXtaPwrIgJ4/XW9P3hw6O/bJLLJFQljEvUAbBORnQAaAEhYnT4VQENrURFdxsyZugm/RInANUiOiADat9elR61aARcv6tKcXbsCc34iInKXDz8EPB7gscd0tUuoa9FCi8Ft3qwtqYjIP9yYMDYHMCP+/tUish8A4m8zUXOSyD8uXQL69NH7ffsCOXIE9vxFigBTpuh+lTFjgPLl9bgIcOBAYGMhIiI74uKAyZP1fqAGLm3Llg3o2VN7TrKKOJH/uKoPozEmO4B9ACqLyEFjzAkRye/1+HERSbaP0RjTDkA7AChRosQtO3fuDFjMRBMnAs8/r3spNmzQpUBuMGMG0KaNJrFduwLZs9uOiIiI/OXnn7XoWpkyuqc9lPcvehNJrCBORIlCuQ/jAwB+E5GD8d8fNMZcAwDxt4dS+kMiMlFEYkQkpnDhwgEKlUg1aKBVSwcPdk+yCOiHh7Nnge7dgZtu0tYcREQUmu64A9i0SQcxwyVZBJgsEgWC295SnkDiclQA+AZAy/j7LQF8HfCIiK7g6quBUaOAxo1tR+Jr7FgthlO2LLBxI3DXXcDTT3OZKhFRqKpQAahXz3YUdvz+u+7dnDfPdiREocc1CaMxJhLAvQDmeB1+C8C9xpgt8Y+9ZSM2opScP+/+3k/16wPr1gEDBujeyk8/1Q8Uv/5qOzIiInLK4cO2I7Dvf/8DvvpKr3cu2m1FFBJckzCKyFkRiRKRk17HjopIPRG5Pv72mM0YibwNGwZUqgQsXmw7ksvLmVNbfmzYADz4IFC4MHDDDbajIiIiJ8TFaV/em28G9u2zHY097dsDUVHAL78AS5bYjoYotLgmYSQKJseOAcOHA1u3apW2YHDdddqf6+efNYkE9O/x8st6S0REwWfRImDnTuDECaBoUdvR2JM7t17PAGDgQLuxEIUaJoxEGfD228CpU7rks04d29GknTE6w5igd29g5EhtxTFlivbvIiKi4DFxot62bRtexW5S0qkTkD8/8OOP+kVEzgjztxai9Nu/X/sdAsCgQXZjyaxOnbQYzpEjQOvWQO3awF9/2Y6KiIjSYt8+4JtvtEL3s8/ajsa+vHm1ajkAvPmm3ViIQgkTRqJ0GjQIOHdOq7HFONLdxp5KlbRQwLRpWu31p590H8x339mOjIiIrmTKFN3D+Oij4b0c1VvnzsBVVwHLlulSXSLKPCaMROnw77+6/MeY0NkjYQzQogXw99/Ac8/ph49OnbQKLBERuZPHA0yapPeff95uLG5SsKAOgm7bBpQsaTsaotDgojbjRO63a5eO4t51F1C5su1onJU/P/D++5o4NmjAvTBERG62ebMWuilVCrjnHtvRuMsjj9iOgCi0MGEkSoc6dfQifeaM7Uj8I2tWYPlynXUkIiL3qlBB9zBu28YBvtR4PMDKlUDNmrYjIQpufIshSqecObXXU6jyThbPnbMXBxERXV5kJPvqpiahP2WtWsD69bajIQpuTBiJ0uC334DXXweOH7cdSeC89x5QvDiwdq3tSIiIyNtffwGnT9uOwt0iIoA77tD7gwfbjYUo2DFhJEqDXr2AIUO0/2K42L4dOHpUS5SL2I6GiIgAXWbZsCEQHQ1s2mQ7Gnfr1g3Ilg347DPdTkJEGcOEkegKli8HFizQMt2vvGI7msDp3RsoXFhbbXz+ue1oiIgIABYv1ordBQsC5cvbjsbdihcHWrXSJJuzjEQZx4SR6DJEdCkqALz8MlCokN14AilfvsTGx926cT8jEZEbTJyot23bsthNWvTooctTP/1UE20iSj++1RBdxsKFwIoVOpL78su2owm8554DqlbVdiLvvGM7GiKi8HbgAPD115oAPfus7WiCQ5kywJNPahGct96yHQ1RcGLCSJQKEd27COgIZd68duOxISICGDlS7w8ZoiXciYjIjo8+AmJjtc9gdLTtaIJHz55AsWLAjTfajoQoOLEPI1Eqli3T6qjXXAN07Gg7Gnvuvht47DFgxw7g2DF+SCEissHjASZN0vvt2tmNJdhUqKDXsKz81EuUIfyvQ5SKu+8GliwBTp3SXlfh7MMPtehPRITtSIiIwtOhQ1qILC4OqF/fdjTBh8kiUcbxvw/RZdStazsCd8if33YEREThrWhRYNUqbXfEwbuMOXECGDsWMEYrgRNR2nAPI1ESFy9qU2RKbtcuoEULYMYM25EQEYWnqCjbEQSvbduAPn20+M2RI7ajIQoeTBiJkpg8WSuD9uxpOxL3WbRIk8Vu3YCzZ21HQ0QUHhYvBtavtx1F8LvlFuDBB4EzZxILuhHRlTFhJPJy9iwwcKDej4mxG4sbtWoFVKsG7NkDDBtmOxoiotDn8QDt2wM33KBtnihzEpaijh0LHD9uNxaiYMGEkcjLuHHa5+qWW4BGjWxH4z4REcDo0Xp/6FBNHImIyH/+9z9dSlmiBHD77bajCX633w7Uqwf8958mjUR0Za5JGI0x+Y0xXxhj/jbGbDLG3G6MKWiMWWSM2RJ/W8B2nBS6Tp5MbOo7aJBuineKCLBxI7B8ud6KOPfagVa7NtCkCXDunPanJCIi/5k4UW/btGGxG6e88YbejhqlldCJ6PJckzACGA1ggYhUAFAVwCYAPQAsEZHrASyJ/57IL0aM0D6DtWs7V7JcRPtmlS4NVK+uzZarV9fvJ00K3sRx2DAgRw5g2jSt2kdERM47eBD48ksgSxagdWvb0YSOOnWAO+/UJamff247GiL3c0XCaIzJC6A2gA8AQEQuisgJAA0ATI1/2lQADe1ESKHuyBFNGAHnZhdFgJYtga5dgZ07dZP9yZN6u3OnHm/ZMjiTxlKlgFde0Q8xK1fajoaIKDRNnQrExgIPPwwUK2Y7mtDy9tvAvHnAc8/ZjoTI/dzSh7EMgMMAphhjqgJYC6ALgKtFZD8AiMh+Y0wRizFSCPN4gCee0P2LtWo585qTJwOzZ6deTfTsWX28dm1dahRsevQAmjfXQgxEROQsj0dXogBAu3Z2YwlFNWrYjoAoeBhxwfSGMSYGwCoANUXkF2PMaACnALwoIvm9nndcRJLtYzTGtAPQDgBKlChxy86dOwMUOYUaj0dnzTJLRJedpuVXsVQpYPt2Z/dMEhFRcPvvP13J8dNP2huY+xf9Z8sWoHhxIGdO25EQOccYs1ZEHKn574olqQD2ANgjIr/Ef/8FgJsBHDTGXAMA8beHUvrDIjJRRGJEJKZw4cIBCZhCh/eYiRPJIgBs2pT2psCHD+vzg5UIMHcu8N57tiMhIgodV12lBW/WrWOy6E/9+gEVKgAffmg7EiL3ckXCKCIHAOw2xpSPP1QPwEYA3wBoGX+sJYCvLYRHIWzbNm2h8c03zr7u0aNA1jQu+M6aVYvtBKt167SYz8svA7t22Y6GiCi0ODWQSSm74QZdXTR0KHDxou1oiNzJTW9DLwKYZoz5C0A1AIMBvAXgXmPMFgD3xn9P5Jh+/YDffwe++srZ142K0kIFaREbCxQs6Oz5A+nGG4FmzYDz54Hu3W1HQ0QU/D7/HJg+Xd9Xyb8eewyoVEkHPD/5xHY0RO7kij2MToqJiZE1a9bYDoOCwPr1muxkzQps3qx7CZ0SbnsYd+7UJT3nzwMrVgA1a9qOiIgoOIkA5coBW7cC336rFVLJv6ZPB558EihTBvjnn7SvECJys1Dcw0gUcH366IX5+eedTRYBTf569QIiIy//vMhIfV4wJ4sAULIk8Oqrer9LF13eQ0RE6bdsmSaL114L3H+/7WjCQ7NmwPXX6+DtzJm2oyFyHyaMFJZ+/VWbIefKpQmbP7RpAzRunHrSGBmpj4dKD6ju3YHoaGDtWi7rISLKqIkT9fa55zjTFSgREUDPnnp/0CAgLs5uPERuw4SRwlJCkti5M1C0qH/OYYw2XR41Smcwc+cG8uXT21KlgNGj9fFgn11MkCcPMGSI3h871rf6LBERXdnhw9qfN0uW0BlMDBZPPQVcd50Wwjt92nY0RO7CsSsKOwcOAH/+CeTNC3Tr5t9zGQO0bauzjZs2aTXUggWBihVDJ1H09tRTwKlTQKtWofn3IyLyp6lTgUuXdN9i8eK2owkv2bJp1e9cuWxHQuQ+TBgp7BQtqu00/vgjcNVJjdEqbKEuSxagUyfbURARBR+RxOWo7drZjSVcMVkkShmXpFJYypMHqFXLdhSh7fRpYMYM21EQEQWH2FgtGnbffcADD9iOJnyJAPPm6eogbq0gUkwYKWx4PMB773FvQiBcugRUqwa0aAH8+KPtaIiI3C9bNqBjR2DBAha7sen8eaB1a2DyZP1ZEBETRgojs2YBHToAtWtz1NDfsmXT/YwA0LUrK84REVFwyJULeOUVvT9wID8vEAFMGClMxMZq30UAaN+eBVkCoVs37SP2++9ayIGIiFI2ebK2Jtqxw3YkBAAvvKA1DlauBJYutR0NkX1MGCksfPwxsHmzlsx+9lnb0YSHyEhg6FC9//rrWj2ViIh8iQDDhgFvv60VvMm+PHmAl17S+2++aTcWIjdgwkgh78IFoH9/vT9ggC6XpMB44gmgRg3g4MHEHo1ERJToxx91QPOaa4CHHrIdDSV48UXtnbx0KfDTT7ajIbKLCSOFvIkTgV27gCpVgObNbUcTXowBRo/W+yNGAPv22Y2HiMhtElppPPcci924Sb58QOfOen/ECLuxENnGtyYKaWfPJi4nefNN7RNIgVW9OtC7t840XnON7WiIiNzjyBHgiy90cK1NG9vRUFJdugA5c2rBPKJwxoSRQlquXFpMYM4c4NFHbUcTvgYOtB0BEZH7fPwxcPGi9l0sWdJ2NJRUVJTuwScKd5xvoZBmDPDII8CUKayM6hYbN7LNBhGRSOJy1Hbt7MZCV3bunO7HJwpHTBgpZJ08aTsCSqp/f+CGGzSBJyIKdx98oMsdWezG3ZYtA8qUATp1sh0JkR1MGCkkHTqky3tat9YejOQOFSoAHg/QqxfbbBBReDMGqFkTGDeO1bu9iehKlOXL9VbEdkRAuXLAsWPA7NkaE1G4yXTCaIyZZIyZnspj04wx72f2HETpNWSIzjAePsyqc27StKl+QDp0iL2tiCh8uSEJchsRYNIkoHRpLZb2yCN6W7q0Hrf5bxYdrVVsRYDBg+3FQWSLEzOM9wP4KpXHvgLwgAPnIEqzXbuA8eP1PpMSdzEGGDVK748aBWzdajceIiIbxowB7r8fWLHCdiTuIAK0bAl07Qrs3AmcOaODvmfO6Pddu+rjNpPG7t11AHrGDF67KPw4kTAWBnA0lceOAbjagXMQpdnAgVp1rnlzoGpV29FQUjExeuG/dAl49VXb0RARBZYI8P77wMKFugqGtJr57NnaCislZ8/q4x98ENi4vJUsCTzzjG6rGDLEXhxENhjJ5HCNMWYzgGki0j+Fx/oCeFpEymbqJOkQExMja9asCdTpyGW2bAEqVtT7GzfqvgNyn3379Gdz5gyweDFQr57tiIiIAmP5cqB2baBoUV0RE+77F0V02enOnVd+bqlSwPbt9qqeb90KlC+vPZ23bNF4iNzKGLNWRGKceC0nZhinAuhpjHneGJMLAIwxOY0x7QD0AJCmeojGmB3GmHXGmD+MMWvijxU0xiwyxmyJvy3gQLwUwvr21ZYNrVoxWXSz6GjtbdWiBX9ORBReElpptG7NZBEANm0CjhxJ23MPH9bn21K2bOJ169Ahe3EQBZoT5UCGALgewHsAxhtjTgLIB8AA+BBAerYH3y0i3m8bPQAsEZG3jDE94r/v7kDMFILi4nTUL2dOoE8f29HQlfTsyd6YRBRejh0DZs3S9742bWxH4w5Hj6a9OF3WrPpvaNO4cUCePPp5gyhcZPrXXUQ8ItIKwA0AugIYDaALgMoi0kYyt+a1AXQGE/G3DTMTK4W2iAjg00+BHTuAEiVsR0NX4p0sxsVpU2QiolD2ySfAhQtA/fq6DJOAqKi0t7+KjQUKFvRvPFeSNy+TRQo/jv3Ki8gGERkrIv1F5F0RSe+iAQHwvTFmbfxyVgC4WkT2x7/+fgBFnIqXQtfVLLMUVNauBW69Fejd23YkRET+NTV+CLxdu8s/L5xUrAgUKpS25xYunFinwLZdu4DOnYGDB21HQuR/jnWoM8aUAXAtgJxJHxOR79PwEjVFZJ8xpgiARcaYv9Nx7nYA2gFACU4thaUuXYCHHwbuuYfLHIONMcAffwDr1gHPP889jUQUuhYu1LYMjzxiOxL3MAbo1UtbZ6RWJRUAIiP1eW65xr/0EjBnDpA9OzB8uO1oiPzLiSqpFQDMAHAjdN9iUiIiEel8zX4ATgNoC+AuEdlvjLkGwDIRKX+5P8sqqeFnyRJNFPPn1xG/q66yHRGl13PPAR9+qB+ivvnGdjRERBRICX0YU2utERkJNG6sM7RuSRjXrNHVMcYAc+cCDz5oOyIiX26rkjoRQB4ATQFUhhbA8f664nyBMSa3MeaqhPsA6gNYD+AbAC3jn9YSwNcOxEshRESrbQJAt25MFoPVoEH6s/v2W2DRItvREBE56/z5tO/TC0fGaDI4apS2qsidG8iXT29LlQJGj3ZXsghoT+EBA/RzyBNP2K3eSuRvTsww/geghYh8m4nXKAPgy/hvswKYLiKDjDFRAD4HUALALgCPi8hl62NxhjG8fPst8OijQJEi2pspd27bEVFGDR0K9OgBVK6sS1TTWjWPiMjtxozR97ihQ4GnnrIdjbuJaPJ17JgWuKlY0V2JojcRoFkzrXxbtiywejVQgA3gyCWcnGF04iPZDgDZM/MCIrIdQNUUjh8FwJbelCIRoF8/vd+zJ5PFYNe1q/Yn27BBbzt0sB0REVHmieh72r59QK5ctqNxP2OASpVsR5E2xgBTpgBbtwK//w40bQrMn88BTwo9TixJfQXA68aYkg68FlGaffst8NtvQNGiWiyFgluOHMCwYTo6mzNZ6SwiouC0cqUOhF19ta6IodCSOzfw1Vf6WaROHW3xRRRqnBgD6Q+gGIDNxphtAE4kfYKI3OHAeYh8jByptz16uH/UdvduLeZy3XXAvffygpKaxx4D6tbVAkZERKFgwgS9ffZZIFs2u7GQf5QoAfz9t+67JApFTiSMW+O/iAJqzhzg/ffd389q9WqgXj3g9Gn9vkQJoH17rQxahJ1FfRjDZJGIQsfx48Dnn+v9Nm3sxpKwN/DoUSAqyt17A4ORd7K4ezdw4IBWUSUKBZkueuM2LHpDbrJnj14wDhxI/lj27MDjj+tevdtv54Xb24ULWhXv99+1ZxkRUTAaO1abu99zj70K0CLA5MlajfrIEd1fFxsLFCqkfQ3btOH1x0lbtwK1aum/+6+/6iAxkQ1ua6vx/4wx+Y0xpY0xnCMgv9m2TUuUu93Zs0DDhikniwBw8SIwbRpQsyZw001aFCFhFjLcnTypH25mzgQWLLAdDRFRxixcqLe29tkn9Dfs2hXYuRM4c0bfX8+c0e+7dtXHQ2zuwKpSpYAbbgAOHQIaNNB/a6Jg50jCaIxpbIxZB+AodHnqUWPMOmNMIydenyiBxwM0aqR7Af/6y3Y0qRPR/Spr1/oez5LK/7g//9QPFMWKAV266F6IcFakCPDGG3r/5ZeBS5fsxkNElBHffKMzi7aK3UyeDMyerQOYKTl7Vh//4IPAxhXKsmYFPvtM22z88Yd+FmBCTsHOiT6MzQDMALAIwGcADgK4GkAzAPcAeEJEPs9knGnGJamhbc4coHFjTay2bnVvNc2BA4E+fXyPPfywlt/++GPgvfc0/supW1eXqz76aHgWSrhwQXsybtumPcxefNF2REREwUMEKF1aZxKvpGhRTRyzZNHlqWm9Tc9z0/tnsmUL7qWymzYBt90G/PcfMGBA4iAoUaA4uSTViYRxHYBVItI2hccmAbhNRG7M1EnSgQlj6PJ4gGrVgHXrgHffBTp2tB1RymbPBpo08T1WuTLw889A3rz6vccDLF4MjB+v7UE8ntRfLzpaC/u0bav3w8nXX+uy3gIFgC1btFADEZHb/fefftl8z964EahePXiXREZH61aNhx6yHUnGffcd8MgjmrzPmaOVwIkCxW17GK8HkNoM4ucAyjlwDiJ8+aUmi8WK2a82l5rffweeftr3WFSUJoUJySKgo6f162vvpu3bgddfBwoXTvk19+0D+vUDSpbUpsDLloXP8pZHH9UKs8ePA/37246GiPAS44IAACAASURBVChtpk7VYic237eOHg3uBvL79mmCNW+e7Ugy7qGHgLfe0pnS3bttR0OUcU4kjIcA3JzKYzfHP06UKR6PJk2AJlc5clgNJ0UHDmiCc+5c4rGsWXVUsXTp1P9cyZJa4GX3bmD6dK2ulpLYWGDWLODuu3XG8t13gVOnnP07uI0x2m8zSxbdCxIbazsiIqLLE9GZsbg4oFIle3FERQX/e+alS1q3YMkS25Fk3GuvaT2Dzp1tR0KUcU4sSR0I4DUA/QB8Ad3DWATA4wD6AnhbRPpmLsy045LU0PTFF9qConhxXZrotoTx/HlN5Fat8j0+aVLGZkP//FP3OX766eWXE+XOrTOaHTpoVbZQ9euvQExMcO9nIaLwsGqVtkoqXFhbK2XPbieO9OxhzJFDq3WL6JfHc/nbtDwnM8+9cME3vshI4Pvvtap4sNu1S/eM2vq9oPDh5JJUJxYr9AWQHUAfAIO8jl8AMBoAF5JRpuXODZQvryXA3ZYsiugew6TJYpcuGV86W7Uq8P77wNChwCef6F7HTZuSP+/MGX3e++/rzGSHDloUKNQuRGx+TETBYsIEvX32WbvvxcYArVpdeVlsZKT2vXXTVo/33wdeeCHx+7NngQcf1JnGGEc+/trx4486Y9q4sf4dOQhKwSLTM4z//0LGRAG4EcA1APYD+EtEjjry4unAGcbQFRenI49uqxj69ttA9+6+x+rX183uTu0fEQF++AEYN073csbFpf7cIkW0QE67dqHXMHjbNmDUKGDECPf9HhARnTihxVrOnQM2bwauv95eLLGxOtN5uY9EkZGavEyd6r7kZeRIbavkrUAB3cd/Y8BKKTpr9Wqgdm2dQR03Tgd5ifzFbUVvAAAiclRElorI9PjbgCeLFNoiItyXJHz7LdCjh++xcuW0B5OTxQaMAe66S/cw7tql+zlTq7536JDuiSxdWiuMLlp0+SqswUJE/z7vvqsXWiIit5k2TZPFunXtJouADmYmTRZz5ADy5dNVO6VK6cyiG5NFAHjpJW1R5e34ceDee4O3V3H16ok9Lzt3Bv73P7vxEKVVphNGY8wAY8z4VB4bb4zpl9lzUPiaPVvfVPftsx1JcuvXAy1a+FYszZ9fk8j8+f133uhooG9fYMcO3dtZt27Kz/N4tC1F/fpAhQo6Wnv8eOqvK6Jl2Jcv11u3VWI1Bhg8WO/37w8cOWI3HiKipHbu1MHNdu3sxrF+fWKhuASPPw789hswd67OdG3frstQ3ZgsJujVC+jZ0/fYoUNaPXv7djsxZdaTT+qqpLg4/Zls22Y7IqIrc6LozXYAfUXkkxQeexJAfxEpm6mTpAOXpIaOuDgt5LJpk+4JsX0B9nb4sI4U7tiReCwiApg/X0c/A23TJi2SM3Xq5Sun5soFPPGELoO55RY9JgJMnqyzkkeO6MxobCxQqJBerN30gUIEuO8+nTXt0IEzjUTkPvv26funrf2LKS1FLVQI2LBBtywEGxGdbRw92vd4qVK6J7B4cSthZUpcHNCggW5dqVQJWLnSt/UWkRPctiQ1GsCeVB7bB6CYA+egMDRrliZCJUvqxn23uHgRaNLEN1kEdG+djWQRACpWBMaMAfbu1eQ6tf0d584BH36oRQNuu00TzKee0mJCO3dqEZ2TJ/V250493rKle2YbE9psRERowYBly2xHRETkKzrabrGbYcOSL0UdPz44k0Ug8X2/bVvf4zt26EzjgQNWwsqUiAhto1WxIvDPP7qyh8jNnEgYDwKolspjNwHgwjFKt7i4xMpuvXu7p+qnCNCxo45qenv+eT1uW548OhP7xx/AihW6ZDa1fZ+rV2siPn26VqBLydmzuiw4Yc+FG1SurImsx6NNkZcutR0REYW7kyfdsV88paWoTZro0sdgZoyuonnqKd/jW7YA99wTnFsU8uYFvvkGWLhQr2VEbuZEwjgLQF9jzH3eB40x9QG8AeAzB85BYeazz3RTe6lSOsPlFmPH6vJNb3fdpcfdsmwT0Fhq1tQCDHv26N6/jFZMPXtWl6u6ZZYR0HYjrVrp0quk/bqIiAJt+nTdL/7MM/ZiiI3VVh4XLyYeK1QodJbuR0QAU6ZoVVdvGzboVoUTJ+zElRlly+osaYLz5+3FQnQ5TiSMbwD4DcB8Y8x+Y8xvxpj9AOYD+BVAbwfOQWEkLg4YMEDv9+7tnsqo33+v+yi8lSmjhWfcEmNKihTRogHbt+to5v33p/81Dh9OuQ+kLREROuv5yy8Z+/sQETnl/HngnXf0vs2ZopSWoo4bF7xLUVOSNasm50n/nX/7DXjgAeC//+zE5YSFC/UzBctwkBtlOmEUkXMA6gF4BMA0AH/G3z4sIvVFhOMllC7Lluma/tKl7Y7WevvnH6BpU9/lRlddpQlYVJS9uNIjIgJ45BEtzLNlC9CsWdpnRbNmBY4d82986ZUlC1DNazH84sV6wSUiCqR33tFKl5Ur6/JPG1Jbitq0qZVw/Cp7dh2o9Z6ZA4BVq4BHH019i4XbzZkD7N+v7aP277cdDZGvTFdJdZIxJgLAGgB7ReRhY0xpADMBFITOYj4tIhcv9xqskhoaVq/W5SX169uORFtR3HabJlkJjNH2GcG872DjRuDWW9N2cc2dW38mlSr5P66M2LQJuPlmXTb71VecdSSiwNi1S9sWnTunPfXuvjvwMYRaVdS0OnNG3+tXrPA9ft992lIqRw47cWXUxYuaBK9YoZ85li0Dcua0HRUFM7dVSXVSFwDeC9+GAhgpItcDOA7gOStRUcBVr+6OZPHSJR2h9U4WAW2IHMzJIqDV2QoXTttzo6L0+W5VoQLQurXuZ0woVU5E5G+vvqrJYrNmdpJFIDyWoqYkd259r7/1Vt/jCxcCzZvr9TuYZM+uReaKF9ftFu3bu6t2AIU31ySMxphrATwEYHL89wZAXQBfxD9lKoCGdqKjQIiNBX791XYUvl5+WZc6emvVCnjlFSvhOMoY7bMYGXnl5+bL5+6LrzHAu+8CL76oo7SPPaYzwERE/vLjj9r+KTISGD7cTgwbNoTPUtSU5M0LLFiQvJXUV1/plpa4ODtxZVSRIrrVJTJS216NHGk7IiLlmoQRwCgA3QAk7BKLAnBCRGLjv98D9nQMaTNm6Mxi+/a2I1Hvv69JiLc77tDjbqqImhlt2mjFuSsljevWAU8+qUm9WxmjjZ27dNHktnFjXZZEROQPNWpoojh4MHDttYE/f2ysDmCGalXUtCpYUFuaVKjge3zmTO3daLvVSXpVqwZ89JHe79WL+xnJHVyRMBpjHgZwSETWeh9O4akpTs4bY9oZY9YYY9YcPnzYLzGSf8XGJlZGrVHDbiyA9vZ78UXfYyVK6Kb0YNsXcTnG6CjmqFHawiR3bp1NjIxMXvn1iy80wXTzxTehwfNLL2nS+PTT7ivWQ0ShIXt2XW3SpYud84frUtSUFCmiq4HKlPE9PmUK0Llz8C3tfPxxHYz4/nvgmmtsR0MUgKI3xphc8ZVUL/ecIQCeBhALICeAvAC+BHAfgKIiEmuMuR1APxG5L/VXYtGbYDV1qo6Uli2rBUyyZrUXy7ZtOtPpnWhERgI//wxUrWovLn8T0X/7Y8d0xLZgQaBOHWDzZt/ndeigM69unmUV0ZHZOnW0AAIRkVMSxqXTugfcHzZs0EJf3rOLjRvrElk3vzf7244dQO3awO7dvsdffVVrD4Tzvw2FH1cVvTHGLDHGFE/lsTsB/HWl1xCRniJyrYiUAtAcwP9E5EkASwEkFKluCYALzEJQbCwwcKDef+MNu8niqVPaeiLprNSnn4Z2sgjohbRSJaBWLb0tWlRHbEuW9H3e+PFAjx7uHrE1RpeJeSeLR47Yi4eIQserrwLlytkrrpXSUtSoKH1vDveEqFQpYMkSvX55Gz4c6N/fSkiO+PZb3Zfq5m0hFNqcWJJaCMA6Y0zrhAPGmBzGmHcALIP2Zcyo7gBeNsZshe5p/CAzgZI7ffqpzupdfz3QooW9OOLigCeeSN6g/s03tYhKOCpeXJPGpEti3n4bGDTITkwZsWiRfpD47DPbkRBRMPvpJ+Djj7UyatI9c4EyfDiXol7O9dfrdStpj+T+/fXaFWxOn9a9mLNmAd27246GwpUTCWMMgHEAJhhj5hpjHoImia0APCMi6WpjKyLLROTh+PvbRaS6iJQVkcdF5IID8ZKLXLrkntnFHj2AefN8jzVvDrz+up143KJs2ZQvvm+8oXsfg8GqVdqzq0ULYPp029EQUTCKiwM6ddL73boB110X+Bg2bAD69vU91rhx+FRFTavKlXWgMF8+3+PduycvZud2efIAn3+un49GjEgsiEMUSJlOGEXkkoj0AnAXgHoAvgFwFkBlEZmW2den0JbQN69qVZ3ds+Wjj5KXRY+JAT78kEt8AF2i+v33WsLc20svAZMn24kpPd54Qz9keTxaCOfTT21HRETBZuJE4I8/tABajx6BPz+XoqbPTTdpy408eXyPv/gi8EGQrVerXTux+u3zzwMrV9qNh8KPI1VSjTFVobOMFwAsAFAVwGvGmBCqJ0n+kCePjpitXWtvdvGnn/QN2Ft0tLZkyJXLTkxudPPNwPz5yVtwtGunLVHcrl8/XZLk8Wh/rqlTbUdERMHiyBEtpAXoNSst/WudxqWo6VejBjB3LpAzp+/xtm2Db7VJu3ZAx46JvYaTFvYh8icnit70BrAawGEAVUTkIQDNoFVP/zTGVM/sOSj0RUTYOe/OnUCjRr4jtjlzatPf6Gg7MbnZHXdoU2Hv1iIiOmsXDD0P+/TRPakiwLPPcmkPEaVN797A8ePAPffoNSPQuBQ14+rU0Wt69uyJx0R04PDLL+3FlREjRwJ16wIHD+qWGTcXn6PQ4sQMY3cAL4nIvSKyBwBE5AsAlQFsAvCTA+egEHPxInDvvTrLExdnJ4bTp3U57KFDvsenTAFuvdVOTMGgXj3dfO89IxwXpx9cFi2yF1da9eoFDBmiSa+NZttEFHxatgRuuw0YMybwyz9jY3WAK+lS1HHjuBQ1re67T/cBeg9Ox8UBzZrpyplgkS2b/j3uvFOTR/78KVAy3YfRGHOdiGy7zONPiUjAdgyxD2NwmDxZl4RUqACsX5/xGcaE3oFHj+oFtGLFtL2BejxAkybJRxd7904swkOX99lnuu/U+y0kVy5g4UK9mLndzp3JW4YQEaVGxM4H9LfeAnr29D02c6YmO5Q+n32mxc88nsRjOXNqwbu777YXV3rZ+l2k4OKqPoyXSxbjH2d5CfJx8aIuCwR0iWBGkkURYNIkoHRpoHp17Z1Yvbp+P2nSlZdp9O2bPFl87LHg7tMUaM2aJS94c+4c8NBDyffZuJF3srhgATBhgr1YiMidvPu32viAvnFj8qWojRpxKWpGNWuWvODN+fP6GeLnn+3ElBHev4tffKFbRYj8KdMzjABgjLkawEMArgWQZGsxJL6KakBwhtH9Jk3SzdsVKwLr1qU/YRTR5UGzZwNnzyZ/PDJS93ZMnZryBX7GjOT9HqtWBVasSF5Nja5szBigSxffYwULAj/8AFSpYiem9Ni9W5twnz+v5dY7drQdERG5wcmT+t5w112aZAT6+hAbq/vGf/018VhUlO5nvPrqwMYSasaPT/5enzcv8L//AbfcYiemjFi+XCuo5smjCe8NN9iOiNzEVTOMxphHAfwLYBKAjtBiN0m/iAA4M7s4eXLqySKgx2fPTrls9urVQOvWvseKFNHROSaLGdO5MzBokO+xY8e0OMSWLXZiSo/ixRObOXfqBIwdazceInKHfv10j/vevUDu3IE///DhvskioINaTBYzr0OH5K20Tp0C6tfXgexgUauWbg1JqMngPSNO5CQn9jBuhCaMrUTksCNRZQJnGN1t4kRtYVGpEvDXXxmbXSxdWvefXUmpUsD27YmzjHv3ajGb/fsTn5M9O7B0qY7iUua8/roWk/FWvLiOgAbDXsFx4xKbco8cCXTtajceIrJn/XqgWjW95qxdq/cDaeNG7SPoXeimUSNdfsi9a84ZOFAHr70VKQL8+CNQvrydmNLr3DmtG7B2rc6Gf/+9FschctUMI4ASAEa6IVkk9/vkE73N6Ozipk1pH0E7fFifD+isY8OGvskioAksk0VnDBqkDZG97d6tM41J/93dqGNHXaYEAC+9pL3WiCj8iOh7WVwc0L594JPF2FigVavkVVHHj2ey6LTevYHu3X2PHTqk1cD//ddOTOmVK5e2DSlaFFi2jIOd5B9OJIwrAZRz4HUoDCxeDHz8MfD44xn780eP+rZzuJysWXVppIguQ0068fzaa7oXkpxhDDBqlJZ/97Z1q7ZQOXrUTlzp8cILwPvv6/3evdkYmSgczZqlH7yjouxUzX7nHS5FDRRjdGVM0sHOvXu13+GePXbiSq9rr9VCfjly6MACi7iR05xIGLsAaGeMedIYU8QYkz3plwPnoBCRI4c2ec+Swd+8qCgdfU2L2FgtvjJokJbS9vbQQ8mXT1LmZcmiRY2SVvDbsEH7YJ08aSeu9Hj+ed0n++23uqSWiMLH6dPAK6/o/cGD9RoSSBs3Jl8i2agRW2j4U8JgZ5s2vsd37NCZxoMHrYSVbjVq6KqpEiW0ajyRk5zYw5jQzSbVFxKRDHbZSz/uYXSnX34BypbVhC8z0ruHcfhw7bforVIlYOVKrYhG/nHxolaqnTvX93itWtrCwkYBiczYtg247jrbURCRv506BfTqpQXSfv454z2CMyI2FqhZU8+dgFVRAycuDnjmGWD6dN/jVaokzjgHgzNngu8aS/7htj2M7QC0jb9N7YvC2IULmrSVLq0XvswwRi/mkZGXf15kpM5kPvOM7/GoKJ05YrLoX9mz67KuunV9j69Yof0uz5+3E1dGLFiggww2lqYRUWDlzauVklesCGyyCOhSVO9kEeBS1ECKiNB2XI0a+R5fv16rp544YSeu9PJOFr/8UmfNiTIr0wmjiEwWkQ8u9+VEoBS8PvhA9wGUKqW9FzOrTRudvUotaYyMBB58EPjoI9/WG1mzaoW5MmUyHwNdWc6cwNdfA7ff7nt80SKgeXPg0iU7caXXkSM68t+nD9C/v+1oiMgfRHyLzAS6ymRKS1Efe4xLUQMta1bt1fzgg77Hf/tNjwVT8jVqlCa/Tz8NeDxXfj7R5TjRh3GmMaa+MazdRcmdP6/7QACgb9+M7130ZoyOAo4apUlo7txAvnx6m7AMde/e5AVLxo3TktMUOHnyAPPmaXl4b19/rQWH4uLsxJUeTz2l1X2zZNG+bH366IdLIgodc+fqgOaCBYE/d2ysFgtLWhX1vfdYFdWG7Nl1cDnpCpmVK4FHH9U2FsHgwQeB/Pm1gmq/frajoWDnxJLU4gAWANhljHnTGFPWgdekEDF5siZvN96oo6VOMQZo21b7LK5erRf71at1r9mqVfrG7u3FF4F2XBxtRf78wMKFyWeXZ8zQkvXBkHy1aAFMm6ZJ48CBwBtvBEfcRHRl589rK4Lt24F//gn8+bkU1X1y5dKBzaRtt5Yu1Vm7CxfsxJUe5cppwb+E69ann9qOiIKZE0tSawIoD+ATAM8A+McY86MxppUxhttuw9j584mVSJ2aXUzKGN1fVquW3o4YoW07vN1zD3vq2Va4sLZUSbocePJk4OWXgyP5at5ck9yICK28y+WpRKFh+HBNFqtU0X6sgcSlqO6VsELmllt8jy9YADzxRHBsq6hfXwckAK3pMGmS3XgoeDnyEV5EtojI6wBKAngQwB4A4wDsN8Z8YIyp5cR5KLhMmgTs2wdUrQo0bOj/8333HdCtm++x668HPv887b0byX+io4ElS7RflLdRo3RAIRg0bQrMnKmFMbi8mSj47dyZuG1i7NjAXitSWopasCCXorpJvny6QuaGG3yPf/ll8Gyr6NJFBzlFdKXV5Mm2I6Jg5Oicj2iPjh8BzAewAUAeaAL5ozFmrTGmqpPnI3erVk1n/vw1u+htwwYd8fOeqcqXTyuiFijg33NT2pUqpTONRYr4Hh84EHj7bSshpVuTJsC//zJhJAoFr7yie9KaNw/8/2kuRQ0OUVFarK18ed/jM2Zo3163F5QxBnj9da3jULKkzjoSpVem+zD+/wsZUxNAKwBNoT0ZPwfwgYj8Yoy5EcBoAFEicqMjJ0wF+zC6S8Kvlz9HS48cAW67TZcUJciSBZg/n2+MbvXXX/rh7Phx3+PjxgEdOlgJKcO++w744Qdg6FDOChAFk8WLgXvv1cra//yTfPWDP23cqMXAvGcXH3sMmD2b7yNutWcPULu2Dhh6a9QIGDBAt8W4/Wfn3aNRRL/8PaBP9riqD6Mxpqcx5h/ozGJFAF0BRItIOxH5BQBE5C8AvQFUTuU1chpjVhtj/jTGbDDG9I8/XtoY84sxZosx5jNjTPbMxkv+5z0GYYx/30AvXtQZH+9kEQBGjmSy6GY33qj7QPLk8T3esaNWwA0Wx47pzPawYVo0Ixj2YhKRunQJKFZMi1gFMllMbSnq+PHuTzjC2bXXprytYs4cXVFVqpRuxXHzdcC7R+OAAVoFPBj2YpJ9TowrdAHwNYBKIlJLRKaIyNkUnvc3gNTqVF4AUFdEqgKoBuB+Y0wNAEMBjBSR6wEcB/CcA/GSn737ru71+vtv/55HBOjcWWd3vLVtq1VRyd2qV9fqtjlz+h5v3VpLmgeDggV1WVL27MCYMfp75+YPC0SU6IEH9Dr10kuBPe+IESkvRS1aNLBxUPqVKpW8CA6ggwC7dul+wZYt3X8d2LtXl0TPmKEz28HSKoTscSJhvFZEuolIsmLUxphCxpjaACAiR0Xkg5ReQFRCO9Rs8V8CoC6AhI+OUwEEoHQKZca5c1pAYNYsYPNm/55rwgT98lanjl54OUobHOrU0eIB3k2yPR6dtZs3z15c6fHQQ9rnKkcOXVLbsaP797QQhTPvD/N58uj/3UDZtCnlqqjNmwcuBsq4yZN1P2Nqzp3Tzz8fpPhp1z2KFQP+9z/dn/ndd8D99wOnTtmOitzMibYasZd5uA6ApWl5HWNMhDHmDwCHACwCsA3ACa/X3wOgWGZiJf+bMAE4cAC4+WbgkUf8d54VK5LPIpYurTNT2blwOajcf79WHo2ISDwWGws0bqw9r4LBAw9oz64cObTC4QsvMGkkcqu2bYEePYDTp6/8XCfFxgKtWvn28ONS1OAhotVGz6a0hs7L+fM6KOD2WcaYGODHH7WC+Y8/AnXrak0IopS4ZquriMSJSDUA1wKoDt0PmexpKf1ZY0w7Y8waY8yaw4cP+zNMuoyzZ4G33tL7/fr57wK4Z4/uW4z1GqrInRv45hugUCH/nJP8q1EjYMoU32Pnz+ugw6pVdmJKr/vu06q8OXNqg2R/z7ATUfqtWKGzP6NGAYcOBfbcXIoa3DZtSntCtX+//mzdrlIl/T9x3XXA2rXAnXfqZyyipFyTMCYQkRMAlgGoASC/MSahK9K1APal8mcmikiMiMQULlw4MIFSMhMmAAcP6vr+hx/2zznOn9fk4uBB3+Mff6xNlyl4Pf20zs55O3NGZ+/++MNOTOl17726L/O774AKFWxHQ0Te4uKATp30fvfuQJkygTt3SktRGzbkUtRgcvRo+vp0dumiBfjcPtNYujSwfLn2mrx4kVVTKWWu+LUwxhQ2xuSPv58LwD0ANkGXszaJf1pLaHEdcqGzZ7WtAOC/2UURoH174NdffY/37q1JJAW/9u214qi3Eye04q2/iyg5pV49335uv/7qWw2RiOyYMAH480/tRde9e+DOm9pS1Pfe41LUYBIV5buy6UpEgJdf1kGK9Pw5G665Bli2TKvARkfbjobcyBUJI4BrACw1xvwF4FcAi0RkLoDuAF42xmwFEAXA5duIw9fy5bpUIyZGi4D4w7vvJm+58PDDQP/+/jmfP8TF2Y7A/V59Fejb1/fY4cOaiCVtn+J2c+cCNWsCd98N7EtxfQQRBcLhw0CvXnp/5EjtvRgoKS1FHTuWS1GDTcWKGdv2Mn488OijwH//OR+TkwoW1CqwCQYOBH7+2Vo45DJGMjBXbow5jFT2EyaRA0AeEYm44jMdEhMTI2vWrAnU6cjL9u3AyZPajNhpy5YB99zjm3CVK6cX4Xz5nD+fv/TpA8yfr1VAmzXTSmWUnIgmjiNG+B5PWDoTLP9uq1fr7PfevcDVVwOff66Nn4kosNq10x559etrD9hAzext2qTXRO/ZxYYNtXcfZxeDz6RJ2nP3coVvcuTQn+35877Hb7xRtysEsudnRs2Zo4XnIiO1kjn7WgcnY8xaEYlx5LUymDD2Q9oSRgCAiARsDogJY+jZtUv3RXpvNr/qKuCXX3TEz81279aZpdtu0+9vuQX47Te9b4y2lWjRQt+YCxa0F6cbiWi10aStUypU0N6bRYrYiSu9Dh3SfUpLl2ol2GHD9AMHPywSBUZcnL7HfvcdsG5d4PYXx8XpCoNffkk8VrAgsGEDZxeDlYj2WZw9O+WkMTJSf9dee01XQO3a5ft4dLQWR7v55sDEm1GxsUCbNrqqK1s2YPp0LTZIwcXJhBEiElJft9xyi1DgnD4t8tVXIh6Pf17/zBmRm24S0bfpxK+vv/bP+Zz0xx8ixYqJFCgg8vffeuzsWZFZs0QaNRLJkSPx75Mtm8iIEXbjdaO4OJEnn0z+869aVeTYMdvRpd2lSyLduiXG37SpyH//2Y6KKLwkvA8HytChyd+7pk0LbAzkPI9HZOJEkVKlRHLnFsmXT29LlRKZNCnx89C+fSIxMcl/B3LnFvnmG7t/h7SIixPp0kVjzpJF5IMPbEdE6QVgjTiUX7llDyMFqfHjdXnNc885/9oiuozo9999j/fvr/sB3GzRIi1PvXevVh5LmA3LlUtH6WbP1kqvU6boUo+4ON9R71WrtE1IuBdLyZIF+OgjbWzt7c8/gQcfdP+eGA2U0QAAIABJREFUkARZs2pRqC++0EbhixdrxT0iCpzy5QN3rtSqoj7xROBiIP8wRnt5bt+u2w7mztXb7dt1Vi5h9UhCIZmGDX3//JkzemzMmICHni5Zsuh+3379tK/wc88l3yZC4SNDS1LdjEtSA+f0ad1TduSI7su7/35nX3/ECOCVV3yPNWyoyZabyz5PnaoXjdhY3af40Ufam+9yDh0CChTQpR+ALmmZM0ePNW6sHzLq1PFtbh9OLlwAGjQAFi70PX7HHbovMFj2NAJa7fXAAd9KqkTkvBMntDppv35AtWqBOy+XopK3uDityvvOO8kfe/FFTcrcfm0fPVq3UpQvr/0ac+e2HRGlhZNLUl38sZvcbtw4TRZr1NCm5U5avFj3AHirWFGTMbcmiyJaVaxVK00WX3tN1/1fKVkEdAYyIVkEgFq1dIP88ePA5MlaIbR4ceCll4C//vLbX8G1cuTQBPrOO32P//yz/jt9HUQNdypU8E0Whw8HevRwf9l1omDTr5++N3TtGtjzjhjhmywCrIoaziIi9H1+/Pjkn1/GjtWB8NOn7cSWVl26ADNm6OopJovhiTOMlCGnT2v55aNHteKckwnjv/9qe45jxxKP5cunSz7KlXPuPE5bv15HsT0evQh07Jj519ywQd+kZ8xIbCnx1luJPcRiY9PXSDjYnTql1XKT9uIEgA4d9KKcK1fg48qoffu0efiFCzooMGMGULiw7aiIgt+6dVqdVERnRAI1w5hSVdQGDbTSJAtd0fz5QNOmyRPEm27SYjjBslpGRAfEmzb1Hewmd+EMI1n37ruaLN5+u7PllhPW9nsni8boG5Obk0UAqFIF+OAD/WDgRLIIAJUrA2++CWzdqiPWXbtqxc0EgwbpB6GhQ4GdO505p5vlzasDFPXqJX9s/HigenVNsoNFdLQusy1SRBsm33xz8n5tRJQ+IrrULy5OKy0HKlmMiwOefdY3WSxQAHj/fSaLpB54AFixInlrjd9/12rqf/5pJ670GjIEeOoprcmQtH0IhSbOMFK6/fef7l08ehT4/nvg3nudeV0RTYY+/9z3+ODBQM+ezpzDafv3A9u26RJSG267zTfBqFlT9zs+/njwtJ3ICI9H21P07p18KWfOnLon5Pnng+dD2t69+jNbuRLInl1nqNu2DZ74idxk5kx9HyxUCPjnn8C1LBo2DOjWzffYp58CTz4ZmPMHqwsX9Cs2Vr8uXdLbokV1O0Io2rdP224kLeqXJw/w2Wda1M3NVq3SGI8fB+6+W5d+X3WV7agoKet9GN2MCaP/nT2rM4wrVzrbfHjoUN3L5a1JE00g3fjBeeNGHS08fhz46SethhpoFy7oDNX06VpV9dw5PR4RobOPCUtXQ9Xq1frBMGG5rreGDXX/Z1RU4OPKiIsXtcjTu+/q90OGJP//QESXd/q07hPeuxeYOFEHXgIhWJai/vWXVu586CHguuv02LJlusLBO1lLuJ87t29lzDZttMJ30uQuNlZnV59/Xp+3dKlW1UzpNWNj9T07Olqf++ijuhwzqcKFdcC4TRt//ovYc/q09mFO+nfPkkUHDTt0sBNXWq1bpyvMDhwAbr1Vl9sGy/U2XLAPI/swhpz580WM8e1VVKWKe3vVLVsmkj+/xlmjhsihQ7Yj0n+radNEHn5YJGtWkW+/TXxs5Urt/3j2rL34/OXkSZGnnkre6wrQPpjLltmOMH0++USkZEmRXbtsR0IUfJYt0z53MTEisbGBOWdsrMhtt/m+9xQoILJ/f2DOn1aTJ+u1ARCZMyfx+MCBKb9/AiKFCvm+RvHiqT/39dcTnzd/furPA0R27kx8brNmInny6L9Z4cIi11wjcvXV+rxWrfz7b2JbbGxir8OkXy+9FLjf4YzaulWkdGmNt1IlkT17bEdE3uBgH0bOMFK6eDzOVyndulVHp06cSDxWoIAWNkkYAXWTmTOBli11RqhBA53di4y0HZWvo0d1v1/CZvSmTYFZs3TJyGOP6axcvXqhtVn9k090RDZpMQFjgF69gL59g6dA0IULiUuxPB4t2nHrrXZjIgoWe/ZogaxKlfx/LhFdGTBypO9xNy1FTdrWoUkTfU9M2Nu5fLnOMmbNmviVLZve5s4NPP104mstWKDXvoTHvZ9brJhW8wa0HsHBg8mfk3A/R47Lz7yK6DWrVq3Emcg1a/S65vZ6BhkxdqzWKPB4fI83aABMm+buyqR79+pM48aNusw2pdlisoMzjJxhtOLkSZFy5UTeesu5Ua9Tp0QqV/YdVcuSRWThQmde30kej8jbbyfG2amT+0f/EowbpyPuSUeOX3hBZM0a29E5Z8sWkVtvTXm09vbbRf7913aE6Td4sM6+DxggEhdnOxoiSuDxiLz4YvL3mgYN9DE3OHVKV50AOrs4aZLtiDLm0iX9rJA1q0jXriLHjtmOyHnffquz40l/n265RWTfPtvRXd6RIyJNm4rs3Ws7EvIGB2cYWSWV0mzMGGDzZuC775yZZRTRnoVJq1oOHeps5VWnbN2qRVYAbd8wZoz7m+0m6NBBZ2z/+Qfo31+b7x45Arz3nu6BTHDpkv5cglXZslqBLmnhCUD33FarpgUFgknCz6NPHx1t9p6JJyI1f76+n8XFBeZ8Hg/Qvr3ODHkrVEjjcMO+xaNHtRDa3Lla+GfRouDdD3juHHDHHfrzHTVK3+vHjtVrVqh4+GGd7U2YUU2wdq0WuFu3zk5caREVpdfWhNhFtCAghRCnMk+3fHGG0T9OnND9BYDIkiXOvOabbyYfSXviCfeMzKZkxgyRmTNtR5F5Ho/Ib7+JvPaayPbticcHDBCpWFH/jm7+OaTF99+LFC2a8mxj69Yip0/bjjDt5s9P/P933XUif/5pOyIi9zh7NnEf1dSp/j9fbKxIy5bJ31eiovR91S3i4kQaNRIpX15XX4SCP/4QufvuxH/zChVE5s4N/uuVt927RapWTf77ddVVIgsW2I4ubbp319nSxYttRxLe4OAMo/UEz+kvJoz+MWCA/rbUru3MG/O33yYvclOtmsiZM5l/bScdPCiydKntKALnzjsTfx61a+vFOZgdOiTy4IMpJ43lyomsXWs7wrTbvl3kpps09ly5tDgOESVen264QZcu+tPFiyLNmyd/PylSRGTdOv+eO63On0+8f/p06C3f9HhEvvpKpGxZ/bcvXNi9BfIy6tSplK9dEREi779vO7rLi4sTefppjTd7dpEvv7QdUfhyMmHkklS6opMnE8tq9++f+aU2//yjxQDEa+ljVJSWH3dT8ZgtW4Dbb9fy4+FSR2nJEi1FX6gQ8OOP2ki+Y0dd2hSMChfW5VijRml/Q2+bNwM1amixiqSFBtyodGlt3/Lss7o8K5DL74jcascObb0A6BJFfxa2unhRewXPnOl7PDoa+OEHoEoV/507LTwe4I03gDp1Elss5c6tReRCiTG6PH/DBv1s8s472r8Q0LZfhw/bjc8JV12lvQ07dvQ9HhenS6Ffe829160sWYCPPgI6ddL/M40bA1On2o6KMs2pzNMtX5xhdF7//jpSVKdO5l/r5EldQpJ0xMypZa5O+flnXV6UsOHcbeXR/e3YMZHOnfVnA4gULCiyaZPtqDLn99+T/+4lfN1/v8iBA7YjTBuPR+TDD1m+nEhEl1wmbGfwp3PnRB56KPl7R4kS2lrAtjNnRJo0kf8vHDd/vu2I7BgwQCRvXpFhw3xnWoOVxyMyalTyFVmA/u67bVWWN49H5I03EuMdPdp2ROEHXJLKhDFQPJ7E/QKZ7WcXFyfy6KPJ3/RGjnQmVqfMmSOSM6fG9uCDobfUJT3WrROpW1crrIZChc7Tp0XatEk5abz6andW572SuDjtVRZOS6eJRHSfMqB7pfw5gHLmjEj9+snfM8qUEdmxw3/nTas9e3RgE9BkKVyTRY8nMWlO2O89e3Zo7G/86iuRyMjkv4O33ur+Ae0RIxLjnTDBdjThhQkjE8aA8nic+TDat2/yN7unn3bXm/no0YkjeW3b+n8/TDDweESOHk38fudO/bkFc2P5WbNE8udPOXF85RWRCxdsR5h2H30k/z9TP3y4u/4/EflT06b6u//WW/47x3//idx1V/L3iXLltDiJbWvWiERHa0ylS4ts2GA7IvvmzdPibQk/qzp1gmu/emrW/B975x0eRbn98e+bQpoECKGXhCbSeweRKlIEERAUFUEpYoNrwYuKDRW5em1XEBFRUUQFAVHBRq9GmhQp+qNDEmqAkJBkz++Ps8PMbjbJJpndmU3O53nmSXZ2dua7szPzvuc95z0nwXMit7g4ol27rFaXOx99RFS/PueFEPyHmQaj4v0VHVq2bEkJxWXCWQCxeDEXjDfSogWnkI6IsEaTO0eOADfcwHM/pk4Fnn7aHqnR7cbw4VxIODKSz9HjjwPh4Varyj+HD/Nc2vXrs7/XogUwfz5Qp47/deWXzEyet/Taa/x60CBgzhyeAyMIRZnMTGDePGDYMC4EbzYXLgC9ewMbNriur1+f53tXrGj+MfPD3r38rLpyBejUCVi0iOefC1xuY9YsYMoUnoOvFJeWatHCamWF48gRLr/hXmIjOhr45hugRw9rdHnD1at6LgGHgxdfzjkWAKXUH0TU0pR9icEo5MTSpTyJv2bNwu1nzx6uIXTpkr6uXDmuLVStWuH2bTaLFwMXLwJ33221Evty+DAbid98w69r1ODEMbfeGngGdmYm8PLLwEsvZU8gEBUFvPcecO+9gfG9vv2WtV68yAMf337LfwVByD/nzgE338xGhpEmTbieYbly1ugyQsSDXmFhwMyZvjGaA51z5/j5vmsX1xzWnuVZWYFTR9mdlBRgyBDXGsoAf58ZM4AHHrBGl7cQARMmAEePAl98IdetLzHTYLQ8hNRpsFYDsBLAXgC7ATzqXB8D4GcAB5x/y+S1LwlJLTyZmZy2OSqKKCSkcPWbzp0jqlPHNXwiJIRo9Wrz9BaGM2eIfv7ZahWBya+/EjVooP+uPXsS7d9vtaqCsWYNUbVqnkNUhw3jOqSBwL59HPYDEF13nb1qwgmCWcyYQXT8uO/2n5zMZZ7cnwUtW7qG52s4HBwKumYN//VlWHhamuuctatXJQzdG4xz8Pfu5fmN8+cH7rnLyCAaM8Zzm/XUU/bOOXDkiD4lpEeP4p0nwtegqM1hBFAJQHPn/yUB7AdQH8DrACY5108CMC2vfYnBWDjWrnVtKIcPL/i+MjOJbrkl+8PsvffM01sY/vmHCxqHhRGtW2e1msAkI4Po3Xf54R8URLRzp++P6avO2dmzRLff7rkBrlGDaONGc47jay5eJLrjDq6pefWq1WoEwVzWrOF7slw532SIPHXKdSBMW9q1yz5w5HAQzZrFc8iioohKleK/cXG83mxjJDGRqH17LuouneyC88gjrr/rpk1WKyoYDgfPW/eUQXXQIKLUVKsV5syOHZxoDiBq27bo1Qq1C0XOYMwmClgCoAeAfQAqkW5U7svrs2IwFoxjx4juukt/2FSvzolBCtPg/fvf2R9iI0faY0Tv99/1h1WjRvZIXhDIJCXxaK2Gw0H0/ffmjnL6o3PmcHAWt4iI7NducDDR1Kk8EGJ3HA7XDuXp05JsQAh8MjKIGjfm+3HKFPP3f+wYDyK63/udO3MhdSMOByf/8pS5EuD1ZiZ1+/NPovh43ne1ahxNIBSMzEyi2bP1PgDA/Z9ATeS2aJHnNqtNG3s/9/fv5/Zb64fZPdtrIFKkDUYA8QCOAIgGcN7tvXN5fV4MxoLRvTtfDWFhRM89V/iR26++8vzwunLFHL2F4fvv9Ua+W7fACTcMJJYu5fPbqpU5njl/d8527+YGzNOxunQJrBqImZlEN99MVLVq4I6kCwIRR6cAbDiZ7T05dIjLZLjf7z16eG4PZ83K+XlkfC59+GHhtX3/PVHJkrzP1q2lY20WKSlETz/N/R6Aja4FC6xWVTC2bHE1gLUlPt7emXOPHtXrI9eqZY8yNUWJImswArgOwB8ABjpfe2UwAhgNIAFAQvXq1c04x8UCo/H2++9cBPaffwq/3507szekFSvao5P9wQd6Mfp77gms8gmBxNKleqp3gOjeewvXyfFn50zjyhWihx/2fKyYGKIlS8w7li85d46oQwfWHRrK87/s4OUXhPyQlKTPe/r2W3P3ffAgR9W43+e9e3se5HQ4dM9IXkt8fMHvN4eDa9gFBfG+hg61d5hhoPJ//8clWsLCiP7+22o1BefQIc/h1KVKEf3yi9XqciYpieuINmzoeY6wUHCKpMEIIBTACgATDeskJNUHHDhA1KcP0YAB5u/7zJnso7ShoUTr15t/rPxy8iQnAgGInn1WOs2+5uJFHr0tUYLPecmSRNOn599I91fnLCeWLiUqW9bz8caPD4wOXHq667yde+8NDN2CoHH//Xzt3nyzuff4X38RVamS/d6+7bacn1W7d3M4vDfPpKiognt4VqzQ9/P889Jm+RpjSGpWFl9za9ZYp6cgnD/PXnH36zAkhAdU7XoNXbjgOqi8fTvPzzx3zjpNRYEiZzACUAA+BfCW2/rpbklvXs9rX2Iw5szFi0STJukd+Ohoc+fuZWR4flB98IF5xygsy5eb64US8ubAAaJ+/fTrYfr0/H3eX52z3Dh+nMOXPR2zYUP7F03W+Pxz3VPbtGlgj6YLxYcjR7jDGxrKBp5Z7NrlOYzvjjtyTxi1Zg17bbx5JpUqxcnkCoLDQfTQQ0RfflmwzwsF58sv9d/w9tsD61l59ao+wOK+tG3LAxF2NRw17r2XrkUOjRtHtGeP1YoCk6JoMHYEQAB2AtjuXHoDKAvgV2dZjV8BxOS1LzEYs+NwcEfRGCJ4332cDc5Mnngi+8NpzBhzj5Ffzp9nI1Gwnh9+IOralejSJX1dWlren/NX5ywvsrKIXnuNO67uxw0PD5xQz507iWrXZt3PPGO1GkHwjj/+MHfwcds2otjY7PfyPffkndjKl4NY+/YFlnFSVLl0ib262gBbiRJETz7JnrBAwOEgmjYt5+uyQwcOU7Vrm/XDD3puDW3p2ZNo2TJ7lwyxG0XOYDRzEYPRlcxM7qRrN1yrVr5JfPHFF54fSFbOETx6lBOXhITYO36/uJKSwiGkTz+de4p4O3gYjWze7Dk5BsBh3oEwB+PcOc4ymZFhtRJByJlz57JnJzWDLVuIypTJfv/ef793nVFfhcn/8gvP06xXT5Kx2YWjRzmhmvZ7litH9MknVqvynq+/5gHNnK7PG28kWrnSapU5s3s3Ox6MWWCfe85qVYGDmQZjEIQiTXAw0LQpUK4c8NFHwKZNQJs25h5j+3Zg1CjXdZUrA998A5QoYe6xvGXnTqBtW+DPP4HatYFatazRIeTMjz8Chw4Br74K1K0LfPEFNwfu1KsHxMZ6t89y5Xh7X9K6NbBtG3DXXdnfW7wYaNIEWL3atxoKS+nSwPPPAyEh/Do5GRg2DPj1V8+/gSD4k9RU4PXXgZo1gWnTzN33hg1A9+7AuXOu6x96CPjgAyDIi16RUsDkyUBkZO7bRUbydkrlvc8PPgBuvhk4f56fh8HBeX9G8D1VqwKffgps3gy0b8/PyqQkq1V5z6BBwO+/A/36eX5/zRqgSxega1dg7Vr/avOG+vWBmTOBY8eA6dOBGjVc295Nm4D9+63TV6wwy/K0y1LcPYyZmRwat3Spvi4lxXcTh5OTs4+0lihhbfr+n3/WU5B36hQYHp/iyqZN7PU2eqW3bs2+nRVZUr3h00/1RErGRSlOrBQoHrzBg3XtTZrwCLpkEBb8zdWr3H5VqqRfj336mBc2t2qV52iFf/0r/8cwq9RPRoZrQqqnnpKQO7vicHDNQ+NUiqVLifbutU5TftiyhTP/5taOdutGtG6d1UpzxnhvOBw8Fx/g77V8udw77kBCUsVg9MTatfrNU72677MgZmRwTTr3B86cOb49bm7MnavPMRsyxB51H4Xcycria6Z8ed3Yeukl1238XYcxPxw4QNSypWdd7dtzyna7c/o0n3NjApDKlYlefZXo7Fmr1QlFnawsnmdfq5Z+/TVvzh1As+7pn37yXNx88uTClb2YNYvDTqOieA51VBS/9iYj5fnzRL16sY7QUKKPPy6YDsEaTp/mEOKgIJ77euCA1Yo843BwaOeaNfx3wwbONpyb4dizpzk1lH1JairRqFGuIbd163K91tymuRQnxGAUg9GFY8eI7rxTv2GqVyf65hvfd54feyz7Q+ahh3x7zNw4c0afl/L44zLSFGicP080cSIb/D/8kP39wnbOfEl6OidE8NTwlipF9MYbgTEnKS2NjXdjLa977rFalVDUWbVKv96uv57oq6/MfX5/951enN24uA9MFRStQ752Lf/19ln02Weso2zZwCvfILDBOGaMPkgdHEw0cqR9Bgm1NjMuzrXNjIvj9evWZU8s477ccgt7Ju1McjIPblatquuOjrY20s0uiMEoBiMRcSf11Vf1EJvwcE5kcfmy74/96afZHyw33ph7KnJ/sGoV0bvvWqtBKByHD7u+fu01ot9+018XtHPmD376iahiRc8Nb1QU1200syyAr3A42LvTowdRQoK+fssWHp0WhMJivA8cDqLhw4lmzzY/jHvhQvbeud+Pr79u7nEKymuvSVbUQOeff9hQDA7mayskhA1JK2vd5icqZ80az9FixqVvX9e2wI5kZHCSn06deBDGeP4PHLBXX8FfiMEoBiMR8c2gzR8cONB/o1q//559tLZaNaLERP8c30hSEo8eC0WT7ds5RBUgGjSI6NAhqxXlTWJi3vNEevUi+vHHwPOC33QT62/XjqMY8io/IAjubN3K179SXOLFl8yfr3fijcs77/j2uLnx2WeBM+dNyB/797MRFhTEc/OtNFAKMu9/5Uoe+M/tM/37c0kau2Psj6aksMexfn2imTNdS3sVdcRgLMYG4/79rglsfvqJk7z4i1OnXN3+mmfT3yNPDgfPV4yJ4YfzsmX+Pb7gH65cIXr5Zb3hCw/n2lhWjtx6g8NB9NZbuaczD7T5FpmZXALFWI6gZk3ufAeCfsFa9u3jeeXatVOyJNGCBb473ty53DYY7zelzK3lmB+ysogmTWIdtWoVr05rcWPvXq4bqrF/P9GECebXvs6JwpR9cTi4vEuHDrl/buBA3w/4mMXvv7sm0ipdmqct2SV02JeIwVgMDcaLF7mxKVGCHzxWcPUqu/rdHxyffupfHQcPusbdd+/OISFC0eXIEaKhQ/XfPC6Os9XZncREohdfdG2sPC3R0XxfB0Jo2sWLHPZtrEVZpoy9a3kJ1nH0KNc31Dx9YWE8Vzk52XfH/OADPTJBW4KC2Ii0gkuXiG67jXUEB3MmWKH4MHw4XfPoPfmkb699InNqFzsc7JBo2zb3zw8aRPTnn779PmaQns4RB8bvExTEtZP9MY3LKsRgLEYGo8PB2eMqV9Yv8gcesCbUYfz47A8LfxqvGRlE06bpme5iYjj9f3GMSy+urF5N1Lgx//6jRlmtxnvS0/k+bt0698ZXKQ75+fVX+1/XmZk8P6x9e+4IGcvXSGZVQWPUKN1Quv9+HvzxJe+8k/2+Cg4m+uIL3x43J44e1bOXly7t34ggwR5s28bPde16vO46zs7rq5Jfa9ZwghtvDMZSpTgfQE44HDx9wlj+ylO7dccdRHv2+Ob7mM3mzWzEh4ayAWmkqJWTEoOxmBiM27e7evRatbIu69NHH2V/SHTt6t86c1o4D0B01108f1EofmRkEL3/Poe4aSxfzusCoYzKpk1Ew4bpmfVyWho14vklgTD6aUxUlJ7OHtVu3Tjbrd0NX8FcUlJcE9ocOsTXu/F+9RXTp2e/j0JDeWDDCrZs0ZNg1a4dGAmvBN/x+++u89ujo31zbZrhYXTH4eCpPy1a5G443nln4FznJ04Q7dihv965k5PlTJrk+4EtfyEGYzEwGP/6S59/Ua4cG2xWJcjYtIlDYY0Phrg434dVuHPyJFGzZjzaJQgaDofeiFWowFkHL1ywWlX22lfuhtPx40TPPMP3d24NekxMYDVgW7a4dlbq1+fsl4FgzAsF58oVojffJIqNJWrSxP/t1UsvZb93SpSwNinaxx+zjptu4hIMgkDEmaZ79OA+ni+Mq8LMYfRm30uW6F5zT0tQECf/2b/f/O/mS158Uf8OwcFEgwez9zWQBz3FYCyiBqP7RTlkCNc6NCa58TcnTriGwwIcEuqPLFnLl3N8ubFURyDfuIJvyMrium3NmunXaKlSnKDFisy9edW+cr+Gr1zhjmVuDbCxAVu3zv73wblzHD5epYquv3x5bpDT0qxWJ5hJRgYPCFSrpv/W7dv7795zODi8z/1+CQ8nWrHCPxpyY+HCohfmJpiD0evucHDpimnTzEmIVJAsqfnB4eA8AtoUkZzarBEjAmNuPhF/pw0bOF+CMQKoWTPrQtoLixiMRdBgXLOGL8rNm/V1VncK09I4fb77Q2D+fN8eNymJQ061482a5dvjCUUDrXagVvpB6zT++qt/NXhb+8rTZ9esIbr99uzZHd2X5s15/q7dja/0dC4joBnDN9wQeKVEBM9kZXGW0+uv16/Lxo3Zo2dW25WXl97h4GyHnsLsrEjClJrKczaNYW6C4A2rV7sOrr35ZuGygRemLcoPWVlc+7BBg9wNx1GjAisr6bFjPBAVG8vfYcwYqxUVDDEYi5DBeOwYz+/Qbqzbb7dakc7o0dlv/Cef9N3xHA7uBJctq3f2p01z9TAKgjds3Eh06638sDeWfPC1t96sUd1Dh/heM5aw8LSUL0/03HMcCWBnHA423Jcv19cdPsyJIFatsn5wTMg/KSl6Z6pWLR6BN2swwBsvfVYW0UMPZb8nSpZkL7y/OX6cqE0b1tCwoQyMCPlDG/A0JkarVIkzUhd0YFC7j+LjXe+j+Hhug8x87moDSPXq5dxehYQ2TxyuAAAgAElEQVRw0sZAqKesoUUAGUOHFyzgaJ8ZM7iurD9zeeQXMRiLgMGYlkb06qv6XJ/wcKIpU+yR4OKff4geeST7zd6zp+8KdbuXyujWjdcJQmEwZuu8dIk7uLfeygal2fhi3silS1wioH793PcXGspe+S1bzP9evsLoGWrRgg0OGRyyNxs2uIbLzZnDhbDN/N288YwMH84ZV93fK13aNUrHH5w7x54IrS2Piwuc+nSC/dCSyzRvrl/XjRoVbgBC89SvXevZU28mmZn8LK9bN/f2atw4ziAciLRv7/p9IiKIOnYk+te/7JdjQwzGADcYExM5Y5p2sQ0caL2r/upVom++YaPQ0w1es6bvUkAT8UgNIKUyBN/x2288MKNd0zfdxCO6Zl1rvshMp+FwcDr+fv2y15dzX9q147Bxuxtfp06xd1TzUgE8D+4//yE6f95qdYKRnTv52gOIXnnFt8fyxkuv1XQ0LmXL8mi/v0hN5UHf0qV1Df36+a84u1C0cTiIvv2WjcUXX9TXp6fb/9lOxIbjZ5+59nXdlxIluFzbsWNWq80fhw8TvfUWZ4StVcv1Ow0erG939izR1KlEv/xiXSI+MRhtbjCmpnLD9dlnnN2wb18e/ddIS+MGr149LoxqJQcOED31FGeXzK1z64sRU6MBmpXFD0UplSH4klOnOBlOdLR+fTdvzklzChtCZmbtq9w4cICTYZUsmfsxKlcmevll+99TqansRTWOSBufl4J1HDzIv4U2SBEVxVmIfUV+vPTGpXx5/xcPv3RJL5lx003sfRUEs8nKcg1JfestNlI++cR3EV9mkpFBNHcuOx1yun/Dwjiqze5TK3IiOZlLSE2Z4lomZfly/TsqxZFCI0booaz++P3EYLSJwZie7nojz5xJVKeO54QVsbGun12wwLpRovR0Pn63bnk3xDEx5meau3SJaOJE7rRb7VkViifnz3PHVxsoadas8J5GX3oYPZGSwkXK69TJ/VhhYUQjR3JdVzuTlcUJU266yTVkeOtWrl8m+I8TJzhkTMsUGBpK9PDDvvee5eceMg6M7N3rW11EesfX6ClYuJA9/xIRI/iLG2/Ur/26dTmaJBDmy169yuXh4uNzvpfDw4kmTOBpUUWBHTt4nnWrVvwMdf++xtJ0Gzey59LsZ4kYjH42GK9eJdqzhzNBPf880aBB7B0MCWHDS+Pdd+lauMwNN/B2U6aw92LPHusblf37iZ54Iu+6bwBPvJ492zVhiBksX64/MIKC+AEiCFaRmkr0/vuu8w4OHOCwyJSU/O3Ll7WvciMri+j773MOJzcunTtzKvRAGJnW6NGDtd94I9HixYGlPVBZtEh/Rt97r/8G9vLjpQd4wMfXc921ZB6aB/yFF3x7PEHIDU8euwYNeEpRIBiO6ekcdl69eu73do0aPNA5bx4nlAp0rlzhmuZvv82hrF27ur5fowZ/74oVOc+CFspa2OkZYjD6yGDMzOTO4po1+rqMjJxHPJXijqXGqVM8omCnVPdpaTwC1aVL3o1vdDTRgw/6psaie6mMpk3FayDYEy2ZRpkyRM8+6zoKmBe+rn2VF3v2sGcoLw1xcUTTp7smBbIjWVk8yGUMIY6I4MLwQ4a4lkyxekAukLl0iUOqNBwOnqpQWC94fsmPh1Ep9u75Ci35SJMm+jFr1uSBY0GwmqtXuR0xGl5LllitynvS0zkqr2pV7+73668nGjuWB2+sqK+skVepn4KQlkbUqxdH9Hl6zr37rr7t5cv5y8oqBmMui7cGY2IiNwbTpnFGtubN9YQYMTGuF0GDBtzB6tOHU91/8gnRH3/YI6NpTvz1F2ds0kpU5La0bcvZ7ozZ78y8KX74QUplCIHDjz8SdejgauA9+ijRkSN5f9Zfta/y4tw5HszKLfxH0zN2LBuadubCBa5L5p5gYN48fZsZMzg8sUsX/k7//S8/e/7+W7ySOZGezp2RChU4Mmb/fmv15MdLX7Wq7+6jzZtdMyFWqcLzbKXdEuxGejpHydx8s+tzzg5Rbd6Qlkb0v//xs9vbyAKAS9c8/DAnBvLHwKc3pX7MOMb+/dyuPfwwR/qFhrpOC3v9dT0r68SJbEAfOpTz8YukwQhgDoAkALsM62IA/AzggPNvmbz2YzQYHQ7OvrR8OdEbb7im2/7f/zxfhFWq8I1nNAbT0z3/EHbjyhW+0Dp3zvtmK1WKY6vdCwz74qbYuZPDd6VUhhBIrFlD1Lu3fs+EhnrnGfRn7au8yMzkBvWmm/J+JnTtylkf167lZ4ldOXeOn+WffupqxE+YkPN3q1zZdR8LF/KcEbt7WAtLRkb2pEevvMJFqG+9lbPSaueodWvr57n+8w9nGfSUB8C4RET4zktPxCHeAOceeOONwhVQFwR/c/gwZyBt25YTK9rdcHQ4uE8eE5P3vZ9TtEGzZuwkWbbM/IykVg4Ep6W5DlQ9+KBnDRUqcHSUO2YajIr3Zz1KqRsBXALwKRE1dK57HcBZInpNKTUJbDA+ldt+4uJaUq9eCdi1C9i9G7hwQX/vmWeAl17i/zdtAiZPBho0ABo25L8NGgClS/vm+/mSPXuADz8EPv0UOHs2923btwdGjwYGDwYiI13fIwLuvRdYuBBITc3+2chI4PbbgU8+AZTK+RiZmcDixbyttt327UCTJrl/ThDsyI4dwGuvAV9/zddxw4a8/vJlICoq588RAXv38j0ZEwPUq2ft9b9zJ/DOO8DnnwNpablvW6IE0KoV0KED0LEjPzfKlvWPzpzQzueZM6zF/XxmZQFHjgD79unLX3/x3/h4YP163i4jg3+3jAx+Xa4cULeuvtx6K/+1MxkZfD5KlODXmzYB338PnDypLydOAElJQPnywKlT+mfj4vg8adSvD0ydCvTv7//rkwjYtg1YsoTbjJ078/5MRAQwaFDe7VB+2LULWL0aGD9e1/XRR8AddwAlS5pzDEHwF7/8Atx5J5CczK87dQJefBG46SZLZXkkr35nUJBuFnlLcDDQsiXQpQvQtSu3Y+793fzw4YfAY4951qcRGQm8/TZw//0FP463nDkDbNkCbN7My5Yt3M/o35+fowCQksLt9u7d6g8iamnKgc2yPM1YAMTD1cO4D0Al5/+VAOzLax/h4S1crO6YGKJOnXhej3GORqCTmsoj7B075j36Uro0h9Tt2pX7Ps2Yf5WQwCM9ACf7EYSiwsmT+v8OB4esde/O8+jsPoJrJDmZvUxVquRvFLd+faIHHuCQ/L//9t93NiPqwThCe/Ys0dChPI/a0/Nu/nx92y++YE/cE09wErC1a9lj56vvbpybcvUqZ8F9+mlOxd6zJ9dk0+pWGsNx33or59+tQgXXULX33yd67z32sm7e7P9w3atX+Z55+OG8E18Yl6Ag9oia6aU/eJBo+HD2UAQF2T80WxC85eJFjhgxzouLjyd6/HGrlbniTb8zIoLLbjz+OFGLFnnXInZfQkPZDnjuOaKVK/MXQWNVMrv84HBw/hVjH//XX6+Z2UXPwwgASql4AMtI9zCeJ6LShvfPEVGZ3PYRF9eSJk5MuOY1rFChaHm1du3SvYnnz+e+badO7E28/XYelc0NIqBGDeDw4bw1xMcD//zjel4vXwamTAH++1/A4eBR7Nmzge7d896fIAQahw+zp/HSJX7dujUwaRKP8AUFWavNWzIygG+/5VHRDRvy//mKFdn7qC1NmgAhIeZqJJOiHnLC4QCOH3f1Sj78MFCnDr//8MPAe+9l/1yZMjxq/d13+roDB4Dq1YGwMM/fQ9O3aROwcWN2b+DJk0CtWkBCgq4tLIwjNtwJCgLefRd48EF+nZDAWipV4qVyZf5boQIQGpr/82I2ly4BK1bw6PeyZXm3XRqNG/N5btECaNuWvaFmtOfHj3O00Ucf8fkNDeW28tln+ZwJQlEhJYUjS956iz1Td97JUSYAcO4cP0M6dwZuvNH/UTAF7XeeOwesWQP89huwciXw55/5O254OHvfunZlL2SrVjk/J/fs4fb98uW89xsVxd6++vXzp8cXpKXx83bYsFL7iC7cYMpOzbI8zViQ3cN43u39czl8bjSABAAJ1atXL6CNbl8uX+Y0ysZJ+DktMTE8lye/I6WFqSG3YoVrqYyJE80vxyEIduPsWaKXX9Y9PgCX0/n448BIjmH03EVEcEKq4GBe8jN6a3wudOvGpYR++in/ZUk8YXXW2QMHOKnAiy9ylueWLYlKluTjduyob5eezuctKIgzad58M88lv/563n7lSn3bJ57I+btUq+Z6/EmT+Ngffshzc7ZuZU+3GV5BX2T7M3LqFOvu25drgXrrRezcmRMW+aIWm8PB51/TExTE3lupBywUdTIzOQP+zp36uiVLXO+/2FiigQM5YmHbNt9HH5hVuzgpiSPaxo3jNrggbVevXpyQccsW1++dn1I/pUpxFIqVuEfkAM0yySwbzawdmSLGhJBUX9RhtAqt6Kc3F2vnzkSff17wZBUFvSnmz9fXS6kMoThy+TKHDmrhddHRha+d5GvymsQfHs4G0fjxfF8XJBFBUBBnn37kETa68ltLy66hQA4HF7b/6y993dGjnME1p/P0xRf6tt99x8/1V17hwYXly/lZn5zsnzpqvsz2t38/l2vp0MH7sLGICKIBA3hQND8lbArK8OF83MGDifbu9f3xBMGuHDvG2aWHDiWqVCn7vWm8H//5J3/lHLzBV8bY8ePcHx41yrVepbdLqVJE/frxwNXChXkPWnpj1PoDz+16CyKTbDS7h6ROB3CG9KQ3MUT0ZG77aNmyJSVoMT0ByOXLwIIFwKxZPJk1N2JjgREjeJJtYZM0FNTtnpoKtGkD3H03MGGCPcKfBMEKMjKA+fM5BOihh3jdlSvAtGl8j7RqxfesHcjvJP6UFA6lXLeOl02b+Lvllxo1OHxVS6ZTr17OIbyBGAqUng4cPAisWsXXQ82aPDWgdGl7TI0gMjfE1+EA/viDQ58WL+bfzBvKluXkQv37Az16FC4hRW6kpnJIccuWHH4GcPjbmTNA8+a+OaYgBCJEwN9/c/KnNWs4YdaPP+rvxcVxKGj79noIa6tWnkPwvcVfz/jDhzl0deVKDmM9dix/nw8K4mddXniaruVPPLfrLUGUYI4isyzPwi4A5gM4CSADwDEAowCUBfAruKzGr2CDMdf9BKqHcds2dqcbC1TntHTtSvTll5xu1yzyM5ofFcWp7TXMHnUShKLC+++73ju1ahENG8Yjlxs2WFMf0AzP3dWrHLrz5pscwlShQv5HcQGiMmW4vq2nch6BHgrkizpdhcWMEN/0dJ6GMG5c/mqn1ajB0yVWr/Z9m5Gezmn6K1bkY7doYY/zLwiByLlzRHXqZL+nw8O5ZJMx5D4/WBFFoiWImTWL2+KCtl3uS0QE79Mqcj6XRdTDaAaB5GG8dAn48kv2Jv7+e+7blisH3Hcfj/ZrCRnMxhuvg8aECcCbb/pGhyAUFTZuBL75hkdG//jD1StXogR77rQR2uXLOWnKDTf4NnGOL0Z1yTk6rXkg16/nkhb5pUQJ9gZ17Mjn4sknvXseWe1hJJM9d76AqOCJzVJS2NuweDHwww/82huaNwcGDOClYUPff/esLGDePOD554FDh3hdixZcNqRnT3t4eQUhUDl5kr2Pmhdy925ev3KlXrLjyy+5PE7nzuyNzKssjdUlK4i4rdIS6KxaxREIBSEykqNKatbkBGba/zVr8jM1PNxM5a7k3K6b52EUg9FPEPEPmZgIHD3KN9Xnn+tZFnOie3fO3ta/v15zy5cac+v0aAwbxhm3ypf3rR5BKEpkZnKW4y1beElL484twOEuZcpwR7xkSQ71ad2alzZtOOulWaxdC/Tr51qjNidKleKslh075v84ycmcfXX9ejYiExL02odmY89QIFf8WafLE/kdKPj+e+5ILV4M/Pqrd79dcDB3HAcM4JDT6tULLdtrdu0ChgzhWp0Ahzu//DJw221iKAqCL0hO5md7r156Jv6+ffnZAfDzoHlzDl/t3JnbkTJudQ7sNtjmcHDWVS2EdfVq79pKb6hSJWeDsnz5wn2/nNt1MRhzxJ8GY1YWcPo0x3onJbExmNv/3s75qVBB9ybWquXb7+AOEZfDeOUV1pyZCVy9yu+VLcvlPHr39q8mQSjqXLgAjBrFhuTRo9nf/+gjYORI/v/0aR48io4u2LGsmht45QpHUmgG5Pr15jTEISHcUN56K5f6qFSJ/8bGcofF1xTGc+dP8jNQEBzM7Zs3REUBt9zCg5p9+mTvEPqLCxf4dyhdmj2Md93ln99fEASdX34BfvqJPZAJCa7PkYED2TAEeL53SgpHzxn7ncnJ/EzPzOT3Jk/mttGqQZ+sLGDbNt0DuXatd21nfjF6J92NSm+8k+JhLACFNRgvX87d+DO+Pn2aL3QzUIpDZkaP5kbdiuQxJ07w0rIlf685c9hoDQoCHnmE61Zdd53/dQlCceLkSd0LqS0rV+pJOp56Cpg+nT0obdronshGjbx7btjFwHE4uJHTwljXrfNOk7cEB/OordGI1P66rytM0pVASc6TH515Ub48G4j9+wPduvk21Con1q7lSJfPPtN/v+3b+dz6OhpHEIS8uXSJp2WsXs3LXXcBY8fyeytWsGeyXj09iU6nTmxEnj0LxMT4vy6kN2Rk8MDn9u3cNmrL33/nHTFYGIzeSXeDUov289yui8GYI+4GY1YWX3x5ef+0/72ZL2M2ISHsxl+0yH83R1ISj/4Yl5Mn+eL7+299uxdeYI9iq1b+0SUIgitadjZtXuPYsTyY4x4iGB4O3HEHMHcuv9Ye7Z6eKXYNoTx2zNUDuWOHd9npCkvJkt4ZlrGx2eeX+ivEV8PhYKPP03LpUs7vXbwIfPVVwdu4OnX0+Yht2ljnvfvjD+CZZ3jOL8Bz6SdMsEaLIAgFY/ZsdkS4R97VrMmDo199pbddWVn2jxYg4rmPmvFoNCb/+Ycjh3xlbmneyeBgnleamWl8VwzGHClbtiU1a5ZwzQA8fdo/HY7C4svO2blz/FcLFXrrLc8NbKlS7F384QcZoRUEO5OWxsbU5s26F/LAAQ7dmT2btzl8mBN+aPMgW7fWS3vYbd5IThjLeaxfz6PVBSnnYRbBwTxlwGhMBgezka6F7udGeDh7h2Ni8jbwcnrPn9+/dWvdSLzhBmuvhT17gOee00PaSpYEJk7kpaDh2YIgWMfVqzwApCXRWbeOB7Zq1+b2TKNaNY7OqF8faNCAl/r1uZxcYcp6+JP0dODIEc8GpW+9k2Iw5ohSLQnwX9KbmBh2B2tLhQqu/5crx6P+J07kvS8zwr9SUoCtW109h3//zZ2Uxx/nbVas4M5gixZsIGpLrVq+zc4oCILvOHuWjYkqVfj1okV8n7tTsyYbkG+8wd4uO84byQkiHgA7eRI4dYoX7X/3ddpAmZA/KldmD17//uYmWyoMU6ZwAhuHg43uhx7i0Gy71DUVBKHwZGayh+z8eQ5TBThyIybGs+MnOJijZe67j18fPcrP/euvtyZMvqAYvZNGI9Ic72TzLKKtIWboFIPRjRIlPBt+nozC2Ni8PXG+nN+SluZ6U3TtynOd3AkPB/71L25wAb4plbK/i18QhIJDxF5GzQO5ebNe2iM4mAeXIiN5u3vuYYOzRg0ePIqP56VqVTYkA5H0dN2AzM2wPHXKd9lbA4XgYI5AefZZ4OGH/T9QkJHBGVm3b2fP+fbtwIgRwPDh/P7XXwN33gk88AAbs3YxZAVB8D1XrgD79nF/evdu/e/ff3Noeo8evN2LL/LgUlAQeymNHsmGDXmefyBy9Sq35e5hrppRefFibp8utY/owg1m6AjQrkD+KFMmd8PP+H90tLmN5Zkz3ne4QkK40+aJtDSubaN5DX//nRvYM2f0cJzoaE560aSJq+ewfn3XZBiB2gEUBMF7lNINvyFDeJ02grt/v2uilx9/9Fx7KiiIO+gvvMCvjxwBfv6Z9xkXx6FCdg0JCgtjjXFxuW9HxM9dbwxLu3gtIyN5gDEqihORaf97WnJ6PzKSPcslS3L7Z0WCiQkTOBRt167sIb116ugG4+23AwcP5v1bCoJQ9IiIAJo25cVIWpprVFxUFHsXDx7kNm7/fi4LBPD6ffv0badO5WgbLbTVzh7JEiX4eeipBrsn76TRoDxyJMW0YNci52EMCmpJJUokICaGkzo8+qi1HZrCehh37uSR1j//dJ/IyqPCGzfqCWkSEzmluF07cIIg2A+HgxO37NvHo5iHDul/T5zgpCKPPcbbLlgADB2qf1YpnsenGZAzZ+oDWCdP8vNIq89VFDB6LT0ZlDt3cviQMZV8SAgPRmrzcPJj1Hl6PyIiMKYOaB5uzWO4fTsPVuzapUfm3HQTz18CeEpE06Y84Nm0KU+ZEE+iIAj5JS2NjUWjN7JqVeCdd/j906d56oVGUBA/fzRv5N13sxFZFFBK/UFELU3ZV1EzGI0hqXZI3JCfFPYlS3JigSZNOC4b4A5blSp8Qderp3sNW7UCGjcuWp0xQRDsxdWrPFCleSPXreNnk2ZUHj2qzy0JDuaGWotgaNuWw2DLl9cNSu1v27ZsEBRFiLh4vJ1Tw/uSrVs5Ec2OHTwXyZ0dO7jtAnigIiiIQ8UkcY0gCP4gOZmTTGrG5MGDrnMkf/mFywUBwPvvc11JLdFOgwbcT7ezR9KIGIy54D6H0YrU8BpEPE/o/fc5tjotzbvP1avHF7LGhg3cwEoNREEQ7ERGBnD8OBuPSUnA4MH6e+3a8ZxJT/MDJ0xgzyXAIfZjxrgalFoobVwceykF+3DmDBt9Rs9hly6cfRvgtqtBA/6/XDk9lEzzHtatK9MiBEGwD+4eyUcf1RNqDRnCc6iNBAVx+9SjB0fVADyw+tFHnD1by6RdoYL1Th0xGHPBU9KbwmYfJeJJpWfPcmN59qy+VKwI3HYbb3fqFDBwoOv7xtCksDAOacquGaheHXjwQfYcNm/OJS4EQRACmawsDtfUQlw1z2Tv3lyqAQDmz+eEJjlx9CiHEwHAxx/z64gIHgw0/q1RQ/dcXb3K0RnaexERYqTkF4eD2yat3fz3v4F58/j8u9O+PZc9Abjj9NNPQLNm3D4WJ++qIAhFi/37OWpC80ZqHsmsLM4krc2R1KIB3YmOZsNx5kxOTAnwVLJdu3i90bj0hdfSTIOxWDShyckcImScG3juHI9+awag+985c/QY59tuA5Ys8bzvnj11gzEsjC8EI9ddx2FJMTE8Cvvtt6xHKR55L1+ea0vZMYW9IAhCYQgOZmOvalWgQwfP2/Tpw89N9/mThw9zI1ypkr7tjBmc8MsTI0awQQlwQrAmTVzfDw3VDchly/SQ2Hff5dqz7gZoZCQP5I0bp+/jq6/4OR8ZmX372FieYxiIXLnCHSHNY6h5EDds4OyCANcJO3qUv2+jRq6eQ20bgA3z3r2t+R6CIAhmcv31vBhJT+c2yjiXXCnuxycmsvMoMZGXlBRejAOW33yjR9gYiY7mgbZVq/R1//2vnphMMywrVLAmV0mxMBivXAE6dgTGjuWaYwA3hloqXk8kJuoGY+nS3BEoW5YNP+1vTIw+og2wV3DtWv29mJjsZTfeeKN4z28RBEEwEh3Ncxrbts3+HpHr8/H++4FevfiZnprq+rdZM9fPVavm+n5GBtf0unDBtaHfsYNTs3uiRQvdYCTimro5MWMGtzEAG64PPcTHcV+Cg7lDodGnD49ee9r2jjt4QBFgg27ECM/bBQUBs2bpWfTeeYe9fEpl3652beDVV3m7Eyd40POvv1yjYTR279aNwQkTgPHj+fNSkkkQhOJKWFj2pDiVKgGzZ7uuI+J53ImJPPio0aYNMHKkq2GpGZfGBJlZWVw/3VMNytKl2ZgcMYJfJyRwjXWjYVmxoilf9xrFwmB0ONijmJior6tcmd3DRuPPaAxWq6ZvO2cOMHdu3scJCmLDNDeU8r7OoiAIQnHGfTBt9GjvPtekCZcA0SDiUeErV3gxFnyfOJGnErgboamprpn0MjN5PosnYzU1lcs3aVy8yOs84W5sHT/Oo9WeMBqWly5xpyAnjMfbsQP4/nvP27Vurf9fvjyHVxFxu2TMUtqkCXc6NGrUyPnYgiAIgitKcbtgbBsAbke0UlcaRGynGA3GjAzgySddDctTpzhfwPnzrl7GtWu5BJYvKRZzGCtX5jCmsmWl5IQgCILgWzIyeB6lw+F5MRpiJ06wMetpu9Kl9Xkxly5xdEpO+2zVSk+MtnMnG8wOB3dEjNuVKQN0764ff/durkdmdXIGQRAEIW80J1h4uD4NYt06nmphNCwTE4ETJyTpTY7YKUuqIAiCIAiCIAiCvzEz6U0AlP8tOFodxlGjrFYiCIIgCIIgCIIQeBQ5gzE4mF208fHsWfzkE0kqIwiCIAiCIAiCUBCKXNKb2rWBRYsk+6ggCIIgCIIgCEJhKXIG43XXSRZSQRAEQRAEQRAEMwiIkFSlVC+l1D6l1EGl1CSr9QiCIAiCIAiCIBQHbG8wKqWCAfwPwC0A6gMYppQSH6IgCIIgCIIgCIKPsb3BCKA1gINE9A8RXQXwJYD+FmsSBEEQBEEQBEEo8gSCwVgFwFHD62POdYIgCIIgCIIgCIIPCQSD0VOuU3LZQKnRSqkEpVRCcnKyn2QJgiAIgiAIgiAUbQIhS+oxANUMr6sCOGHcgIhmAZgFAEqpi0qpff6TV2BiAZy2WoQXiE5zCQSdgaAREJ1mIzrNRXSaRyBoBESn2YhOcxGd5hEIGgGgrlk7CgSD8XcAdZRSNQAcBzAUwJ25bL+PiFr6RVkhUEoliE7zEJ3mEQgaAdFpNqLTXESneQSCRkB0mo3oNBfRaR6BoBFgnWbty/YGIxFlKqUeArACQDCAOUS022JZgiAIgiAIgiAIRR7bG4wAQEQ/APjBah2CIAiCIAiCIAjFiUBIehW4oSMAACAASURBVJNfZlktwEtEp7mITvMIBI2A6DQb0WkuotM8AkEjIDrNRnSai+g0j0DQCJioUxFR3lsJgiAIgiAIgiAIxY6i6GEUBEEQBEEQBEEQTEAMRkEQBEEQBEEQBMEjYjAKgiD4GaWUslqDIAiCULyRtkjwFjEYLUZuVkEpJfehCSilrrP7/aSUqqaUCieZPF5sses1alddRQW7n1+lVLDVGnLD7udPQykVq5QKtVpHXiilrldKRQdSWxRA14DtdRZEY5HuqCqlblBKdVJKhSmlQpzr7PZDRgG21OWCUqqOUqqNUirKai25oZRqpJTqppSqZOdz6rwuRwIAETnsajQqpfoppZ60WkdeKKX6A/gPgApWa8kJpdTNABYCqO58bdffvJ1SaqRSqoNSKtxqPTmhlKqrlGqrlAq18fMdSqnmSqn+Sqk4pVQkEZFNf/towL7XpYZSqrFS6halVE2lVJjVenJCKdVKKTVYKdXMroNESqkuSqlnAICIsuz62yul+gF4yY73txGl1AAA78D5jLcrSqmeABYD6OR8bcvBAqVUZ6XU40qpO5RSpex4DwGAUqqpUqq3UqqqXZ/xZrRDtvpCZqKUGghgKYBnAMwB8IhSKsZ5kmzx0HE+BDcqpTrZSZc7Sqm+ABYBmArgE6VUE+d6W+lVSt0C4AsADwL4BEBVaxVlRzGRAN4D8KRS6hHgmtFoq7qozkblRQDbrNaSG0qpGwG8BmAhEZ1ye88W16jzXL4GoAyAiQD/5paK8oBS6lYAHwDoCOBxAPGG92xxLoFrAwTfgM/lfwE8qI2W20znrQC+BHAXgBcATFNKVbLbIJFS6jYAx5RSt9hNmxFnW/Q5gDEAXgbQy7neNr85cK0tmgPW9wKA5tYqcsXZDoWB7/GnlVIvA9faIVt5x5wDbS8CWOVuMNjpd1dKtQUwDcAsIvrb7T3b3E/OtmgagEQAgwAeLLBUlAec/eO3wYPA/QC0Mrxnp9/9VgCfARgI4DEAU5VSsXZ6jprVDtniy5iNs+N9O4BRRHQzgK/BF90TmtFoqUAASqkGAF4HsAHA20qpG+3W2QGuPQT/A+BeIuoO4DiAJwHADudRQynVGTyydz8R3Q7gAoAGzvdsc50TkwrgU3B9nKaaB4+IMi0VZ8D5u38OYCwR/ayUKq2UqqGUKmk3wxZAEwAfO3VWdnof2hsGiCz9/ZVS3QDMAHA3EdUBEK+U6mqlJk8opWIAjAMwnIhGAkgG0FwpVVEpFWWX55NT5wMAhhLREABbANwDYKJSqrSdnksAbgHwhFPnOwDOAXhLKVXRLgMGSqlaACaAn0nzlFK97dTZ0VBKtQC3mXcT0QAAWwEMB2zXFrUFMB3cFo0Ct5m1lFIRyumxt/o+crZD6eCB1UkAGiql3na+l2GlNiPOwekPALxARL8opcoo9tjG2emZ5KQWgKVEtErx1INhSqmBdhogcrY7HwAYQURdADRQSg23WFY2nIPq9wB4gIieAHAYrPUGu7TrAKCUigBwJ7h/fD+AZQA6APiPUqq8XZ7xMKkdsvyE+wgFoBSARgBARIvB3kYAuNMOFxp4dGcqEY0B8C6A95RSnW32AAQAB4DXiGir8/VzAK5z3ih24jiA0US0WSlVCRxqMVYp9RGAkcomoXWG3zYd3MB8AqCxUupdpdQbzpFfOxhkiQBSAdRUSsUCWAL2in4CYISyQSiY4VwSAG1U/GtwJ3IMgPdt8tAmsBG2SylVCsBfABoD1ncc3cgAEAE2EssA6AHgDrAH71lln5CgDHD4ZDwAENGnAP4BUBo8Em2nQaIgAPUAwPkM/RD8+z9ho2foaQD/JaLxAO4H8KVSqo97J9cG1+pZAG8T0Xbn6/8CKKWUqmKhJk8cAg+0bVZKVQDQF8BQsLfETvcRAJQAUB/sGamjlPpaKTVfKRVkE09jMoC/AcQqpZoC+A7A8wDeADBZ2WAOnuG+uABA89TNB3AT2MO8RClVzQbtEACcBDCMiHY4X38OoA5gi/vbSBaAsgA6O/tzd4DP5yQAM2zSrgPcP64AoCEAENEqANsBXAb3Py1vh5wagmFGO0RERWYBP/zCnf/fCO7kdne+VuCLbgGAEIs1Rjj/DzWsHwHgTwCdna9rAwizWGcJ5/+lNL3gm2MbgIrOdRXtcj4N654EMNn5/3CwEVHFKo3u59P5Og7Ac87/HwUbZ7Os1GjQGen8/wYA+wGcAo/0AcDdAL7Sfn87nE8A1wPYA54fONJwfv8HoLcdNDpfK+ffzmCDvKXVv7dBp/bc7Av22G0AMMW57kYAHwNobiOdo8BhQGMAvAIORR8JYJ7V59NNc2NwB2Kwdg0AaOvUbuk95KbT2BYNAHARQF/n62YArrNao1OL1naGgOf/bwRQx7mulnZ92GUBG+CPOP/v5LxOm9pAV5DzbxSAV53/3wHu6C62Wp+b1jgAK8CGo9YO3QhgHoBGVusz6KwKHrhaCGCcYf0bmm67LIbfvzl4gKOL1Zo8aGwJ4Hfnbz/VuS4ewEzt2WSHBUBvAL8BeBocjfcNgO5Wt0XOZ2SY4XfeUdh2yHLr1yyUUreDH8ZLnbHPR8AG4xClVA9iFoBHLZparHGJUqoPgJLae0Q0F8CbAF5XSr3n/N+SEWinzvkAvlNK9QZfXACPplwCcI6ITiml7gTwEgBLvE3u59PpFQERvU5EU53/zwMQDsCyUWiDzmVOndEAzgOIU0o9COAh8PzQckqph22gc7FSqj8R/QWgG9iw/RAAiOgzcCfDsvmhbuezP4CD4HPYGDxaDiI6DB5Vq2ihxvnQf/My5HxSE9FqsLf2FudIvmXPYbfnZl8AP4MN2lUA9gIAEa0BcB2AmhbJdNd5M7gj8Q24IQwjojuJaA7Y41TKQp3tlFJDtddEtBPAFLBXfoizHdoE9oY2sotOOD0jSqkg4oicewDMVUp9CPbkWdUWuetM194iostgD9QJpdQQ8DPUkkgSd53aPU1Es4noHef/a8GdOEsScxk1ku49DgFQWSk1GTxPcALYm/eKFRrddQLXnuWjwANYWju0BvxbW/J8BzzqPAaex9YaQHvDplfBz09L8HBtKufvr4i9TW+An0/RVml06nI/nwngQZafwYY4iOgQ2HFRyQqNgMdn0kqw1zsWwHkiGkREvwAoo5SqZpHG3gDmgvvw3Zy/8wsA7itUO2S1dW6SJX09uHPTDsAwcPjpOHBndySAH8BenPuc2/l9ZDcHjY8CqOW23XxwI9jERufyUQA1Ddt8DJ5LkgCLRvhy0VnHbbtB4LkulWyk81/g0fCnwaN7/ZzbdgJQ1UY6H3e/V5znc5v7eot1PgI2FG8DcABsPD4A4A8AtW2i0eVeB3ArgM2w0COSg84J4Iavk/M+7+9ctgKoYQOdd4IHAh8BUNltu3uc57SkRTp7gj0034DD47X1JZ2/905wErbHnN+nmg10PmBYr3nANe/DHHC4amMb6DSeT2X4fxZ47qWVbVFO5zPYbbuBzmdndbtodL73gLMdGuB8HQ8gzk7n0sN2tzvPpa3uIed77cHh008AeMrZDtW1k063e6gZ2ENmyW/uQedot/dagI3GB8BecEva9bx0um13t/P6LGOBxlucbc3NznN2EmwUKnBb/mdB2yE7zJUygzIAEoloIzjr6GFwiKcD3AnaB86cmQrgTnLLpGiRxkNgY9ahlPqEiFIUT0huBKArEf1pgca8dM4D3yztwV6mLkR0wIY6TwHIBHcu/wVgCBGdtJnOrmAvyU9E9Idz2/VkXVx+TjoHK6Xmgu+de8DhvoMsuody0nkfeJ7g/8AG4x3gUcgRRHTQJhq1a/NTIrpAREuVUoPAI6X/Z4HG3HQOA3cgfgc3KlfA59JOOu8DD5bPAUc93AvunA0hoosW6awJ9nJtB9BfKTWaiGY59SxVSv0N7kiUASfsOWoTnSCiD4l4/jyx96E1OCS9K7GX1A46HzDoDAU/468HJzdrZ9G97kmndj6znPPCQsD9kYngZ+cRu2h0vrcGwDoi2uv0MB+yQJ9Gjjqd1yYppe4Dz2UbaKN7SBHRLAAgog2KEzR1A1AenKRpn010Gu/1ICJyENE2pdQuWJvTxOO97nxvDzjPx3jwPNH7bHSvj9Z+d8P1ORDAw+BEOOf8KU4pdR3YYHyGiFY411UFD/r9CY7GOwjuy+W/HfK39etDq/pTAEPgnE8HzlT0I4BbnK+D4Rw5tZHG9k6NPZ2vy8GC0cd86NTO5V0A6ttYZw/n654Arrehzg5gr3c352sFw4ifjXS6X58dYdFIqZc6LZuvmN9zaZclF51dna+jYJHHLj/nE0BluEVrWKBRgUM3rwMnOZkJTn5i+e/shc4xbtuUgvXzlL3R2QlAAzvrBHfEm8At+sUGGgP12qxj5bn0VqcdFi+uzRJWafNC51i3bUrAwrwe3v7u4AgdqzzfQeCpOdHQI0VeBPC+GfsPWA+jcwQ0FMBVIvodPOemPYAkpdR6IlqvlPoSHLP7C1mQKtoLjRucGu9XSq0momR/a8yHzvngc7kCwHyywBOWj/P5gFLqVyL6yd8avdS5Xim1AMAY5+9uSTmNfF6fvxHROpvrHKGU+smK81mAc2nn33wBOMPbOuJ5YnbVaXx2nrBYZzrxnJsrzvU/gDsXnRXXOLwOwEXi+YF213mZiBaBR/PtrPMSEX3rb42BorOIX5t21xko5/MigEDQGSj3eioRLbRIYwnwdbfDuS4EHGX5J5x1YJVSwwAcIaL1BTlOQBqMihPGvALgewDVlVJJRDRRKfU0OMNbNXD2HwKQBj5pdtdoVQfSW50AJxxQZEGR13yez3ToiXrsrDPN+dfuOtMDRKcl5zMQNOZTp8Op05JizgH67KyqlLpCXCYJxFMMvgeQBOBVAHXBHnrRaY7OG8CRGqKz8BrlNzdXZ6CcT9FZBHS6aazm1DjaMCh9AcBlpdRgcHKeAQU+mL9cpWYtACLBoUhaOF91AGcAvOV8fTe4M7EKbFk3E42iU3SKzuKqUXT6TWcSgDlu2z0B4AQsCuEXncVPZyBoFJ2iU3T6RyM44VoGuFxWvcIcLxDLaiiwGz0RAIgnkM8B0Esp9RIRfUZEd4MnnXYjom2iUXSKTtFZjDWKTv/o/ARAG6XUG4btssA1w/b4XyIA0Wk2gaAzEDQCotNsRKe5BIJObzTuBbAOnIRnb2EOFjAGo1LqegAgnlOzB8BypdRgpdQH4EmovQFUUnotvj+JKEk0ik7RKTqLo0bRaYnOfgCilVIxzu3eJK6BJTpFZ7HXKDpFp+j0q8ZoAEfB2ZkLZSwCAWIwKi4ovV1xMgYQ0fMApoNjhs8DmEBE/4CzjFpVuNf2GkWn6BSdxUOj6LRUZ3kAYaJTdIpG0Sk6RaeFGksSURoRnTHl2ESW5F/wGqVUFICFABaBs+SFEdEwD9sNBzAWXHz2tGjMjug0F9FpLoGgMxA0Oo8vOk1EdJqL6CxeGp3HF50mIjrNJRB0Wq6RLJhMmt8FXGPrOnB9k28AfGF4LwRAL/CEzqaiUXSKTtFZ3DWKTtEpOouPzkDQKDpFp+gMbI229zC6o5QqC2AWgCtENFwp1RBATQBbiOiUteqYQNAIiE6zEZ3mEgg6A0EjIDrNRnSai+g0j0DQCIhOsxGd5hIIOv2tMeAMRgBQSsWCY3bbg+dhdiaLCjfnRCBoBESn2YhOcwkEnYGgERCdZiM6zUV0mkcgaAREp9mITnMJBJ3+1BgQSW/cIY7J3QmgFICBdvsBgcDQCIhOsxGd5hIIOgNBIyA6zUZ0movoNI9A0AiITrMRneYSCDr9qTEgDUbFqdV7A+hJRH9arccTgaAREJ1mIzrNJRB0BoJGQHSajeg0F9FpHoGgERCdZiM6zSUQdPpTY0CGpAKAUiqciNKs1pEbgaAREJ1mIzrNJRB0BoJGQHSajeg0F9FpHoGgERCdZiM6zSUQdPpLY8AajIIgCIIgCIIgCIJvCciQVEEQBEEQBEEQBMH3iMEoCIIgCIIgCIIgeEQMRkEQBEEQBEEQBMEjYjAKgiAIgiAIgiAIHhGDURAEQRAEQRAEQfCIGIyCIAiCIAiCIAiCR8RgFARBEARBEARBEDwiBqMgCIIgCIIgCILgETEYBUEQBEEQBEEQBI+IwSgIgiAIgiAIgiB4RAxGQRAEQRAEQRAEwSNiMAqCIAiCIAiCIAgeEYNREARBEARBEARB8IgYjIIgCIIgCIIgCIJHxGAUBEEQBEEQBEEQPCIGoyAIgiAIgiAIguARMRgFQRAEQRAEQRAEj4RYLcBsYmNjKT4+3moZgiAIgiAIgiAIlvDHH3+cJqJyZuyryBmM8fHxSEhIsFqGIAiCIAiCIAiCJSilDpu1LwlJFQRBEARBEARBEDwiBqMgCIIgCIIgCILgETEYBUEQBEEQBEEQBI+IwSgIgiAIgiAIgiB4RAxGQRAEQRAEQRAEwSNFLkuqIAiCIAiCIABASkoKkpKSkJGRYbUUQTCN0NBQlC9fHtHR0X45nhiMgiAIgiAIQpEjJSUFiYmJqFKlCiIiIqCUslqSIBQaIsKVK1dw/PhxAPCL0ejXkFSl1BylVJJSapdh3XSl1F9KqZ1KqW+VUqUN7z2tlDqolNqnlLrZn1oFQRAEQRCEwCUpKQlVqlRBZGSkGItCkUEphcjISFSpUgVJSUl+Oaa/5zDOBdDLbd3PABoSUWMA+wE8DQBKqfoAhgJo4PzM+0qpYP9JFQRBEARByJmMrAxcTL9otQwhBzIyMhAREWG1DEHwCREREX4LtfarwUhEawCcdVv3ExFlOl9uAlDV+X9/AF8SUToR/R+AgwBa+02sIAiCIAiCBzIdmZi7fS7qvlcXz6589tr6g2cPWqhK8IR4FoWiij+vbbtlSR0J4Efn/1UAHDW8d8y5LhtKqdFKqQSlVEJycrKPJQqCIAiCUBzJcmRh3s55qPe/erhvyX34v/P/h9WHVyPTkYk+X/TB9e9ej79O/2W1TEEQBFOxjcGolJoMIBPA59oqD5uRp88S0SwiaklELcuVK+criYIgCIIgFEMc5MCXu75EwxkNcfe3d+Pg2YOoHVMbn932GRIeSEBIUAiqRVcDgTBt/TSr5QpFlLlz56JNmzaIiopCdHQ0OnfujKVLl7psc9NNN2HQoEEWKfQ9u3btglIKq1atslpKscIWBqNS6l4AfQHcRUSaUXgMQDXDZlUBnPC3NkEQBEEQijfbT23HsIXD8NfpvxBfOh5zbp2DveP3Ynjj4QgO4vQKT3Z4EkEqCPN2zsPh84ctViyYDRFhT/IerD28FnuS90DvrvqHcePG4f7770ebNm2wePFiLFiwAPHx8ejfvz+mTZNBCsG3WF5WQynVC8BTADoTUarhraUAvlBKvQmgMoA6ALZYIFEQBEEQhGIEEWHTsU1oV60dAKB5peYY3Xw0WlRugRFNR6BEcIlsn6lZpiaGNRyGz//8HP/Z8B+82/tdf8sWfAARYfbW2Zi6dipOp55GSFAIMh2ZiI2MxeROk3F/8/t9Ppds8eLFmDlzJmbMmIGxY8deW3/LLbegYsWK+Pe//40ePXqgefPmPtWRF1euXJEkQ0UUf5fVmA9gI4C6SqljSqlRAN4DUBLAz0qp7UqpmQBARLsBfAVgD4DlAMYTUZY/9QqCIAiCUHwgIvx44Ee0nt0a7ee0x6Zjm66990G/DzC6xWiPxqLGpI6TAACzt81G4qVEn+sVfAsR4d7F9+KxFY/h8IXDuJxxGRfSL+ByxmUcvnAYj614DPcuvtfn3sa3334btWvXxgMPPJDtvX//+98oWbIk3nvvPZf1s2bNQnx8PCIiItCnT59rNfs0Xn31VdSuXRvh4eGoUKECevXqhVOnTl17/+zZsxgzZgwqVKiA8PBwtG/fHps3b3bZh1IKb775Jh577DGUK1cOjRo1wpQpU1CxYkU4HA6XbZctWwalFA4e1BNDzZ49Gw0aNEBYWBji4uLw+uuvZ/t+77//PqpVq4aoqCj069cPJ0+e9P7ECabh7yypw4ioEhGFElFVIvqIiGoTUTUiaupcxhq2n0pEtYioLhH9mNu+BUEQBEEQCgIR4Zd/fkGHOR3Q+4veSDiRgApRFfJt9DUs3xD96/ZHWmYa3t78to/UCv5i9tbZWLh3IVIzUj2+n5qRioV7F+KjbR/5TENmZiY2btyIfv36ITg4e3W5UqVKoUuXLlizZs21dRs3bsS7776LN998Ex999BF27tyJAQMGXHv/008/xSuvvIKJEydixYoVmDFjBmrXro3Lly8DANLT09G9e3f8/PPPmD59OhYvXoxy5cqhe/fuLkYlAEyfPh0nT57EZ599hnfeeQdDhw5FYmIiVq9e7bLdV199hRYtWqB27drXPjdu3DgMGDAAy5Ytw7hx4/Dss8+6GL5LlizB+PHj0bdvXyxatAiNGjXCyJEjC39ShXxjeUiqIAiCIAiCVaw5vAbPrnwWaw5zhzs2MhaTOkzCuFbjEBkame/9Pd3xafz8z88ICZIuViBDRJi6dmqOxqJGakYqpq6dilHNRvkkNPX06dNIT09HXFxcjtvExcVh+fLl114nJSVhw4YN1z4TFxeHjh07Yvny5ejVqxe2bNmCnj174sEHH7z2mYEDB177f968edi1axd2796NOnXqAAC6d++OunXr4o033sD06dOvbVuxYkUsWLDARU/jxo2xYMECdOnSBQAboEuWLMGzz3IJmpSUFLzwwgt45plnMGXKFABAjx49kJqaipdffhnjxo1DcHAwpk6dil69emHGjBkAgJtvvhnJycmYPXt2/k+kUChskfRGEARBEATBChbtXYQ1h9cgJiIGr3Z7Ff/36P/hX+3/VSBjEQDaVG2DExNP4MUuL5qsVPAne0/vxenU015tm3w5GXtP7/WxIu9p3ry5i4HZoUMHlC9fHlu2cCqQpk2b4ocffsCUKVOwZcsWZGW5zvj65Zdf0KJFC9SoUQOZmZnIzORy6Z07d0ZCQoLLtn369Ml2/DvuuAMLFy689rkff/wRFy9exJAhQwCwB/Ty5csYPHjwtf1nZmaia9euSExMxLFjx5CVlYVt27ahf//+Lvs2GraC/5DhL0EQBEEQig1bjm/BpauX0LVGVwA877BsRFk82vZRRIdFm3KMUuGlTNmPYB1nUs947SUOCQrB2StnfaIjNjYWYWFhOHw458y7hw8fRpUqeqny8uXLZ9umfPny1+b/jRw5EhcvXsSsWbPw4osvomzZshg3bhyef/55BAcH4/Tp09i0aRNCQ0Oz7adWrVourytUqJBtm6FDh2Ly5Mn47bff0LNnTyxYsADt2rVD9erVAbDXFAAaNGjg8fscPXoUYWFhyMzMzPZdPH03wfeIwSgIgiAIQpFn68mtmLJqCpbtX4Y6MXWwZ/wehASFoOJ1FfFs52dNP15GVgY+//NzlAgugTsb3Wn6/gXfUjayLDIdmV5tm+nIRExEjE90hISEoF27dvj+++/xn//8B0FBrsGBKSkpWLVqFW677bZr65KSkrLtJykpCZUqVQIABAUFYcKECZgwYQKOHj2Kzz//HJMnT0aVKlUwduxYxMTEoGXLltdCQY2EhYW5vPYUhluzZk20bNkSCxYsQMeOHfHdd9/hlVdeufZ+TAyfq2XLlnk0OOvWrYvIyEiEhIRk+y6evpvge8RgFARBEAShyLIzcSemrJqCxX8tBgBEhUbh9nq342rWVZ/OM1zx9wrct+Q+VI2uikH1B+WaXVWwH/Vi6yE2MhaXL1zOc9tyUeVQL7aez7Q8+uijuO222zB79myMHj3a5b3XXnsNKSkpeOihh66t27p1K44cOXLNo7d+/XokJSWhdevW2fZdrVo1TJo0CR9//DH27NkDAOjWrRt++uknVK9evcAevaFDh2Lq1Kno2rUrrly5gsGDB197r127doiIiMCJEyc8hrRqNG3aFEuWLHEpJbJo0aIC6REKhxiMgiAIgiAUOZIvJ2P8D+Px9Z6vAQDhIeEY32o8nuzwJMpH+T6srXed3qhfrj72JO/BvJ3zMLKZZHcMJJRSmNxpMh5b8ViuiW8iQyMxudNkn9ZiHDBgAMaOHYvx48djz5496Nu3LzIzM7FgwQLMnTsXr776qksNxvLly6Nv3754/vnnkZaWhqeeegrNmzdHr169AABjxoxBTEwM2rZti1KlSmHlypU4cOAApk2bBgC45557MHPmTPw/e/cd39P1x3H8db8ZMggyESqqRsyKGCVSe1SMoFYrtqpStKjRWrVqFK0WsbXUqlGrtWvvqBVCETWz7Ox8z++PkF/TCCHjZnyej8f3Ed9z1ztpmuRzz7nn1K5dm0GDBvHmm28SGhrK0aNHKVCgAAMHDnxp5rZt2zJ48GAGDx6Mp6dnQu8mQL58+Rg9ejT9+/cnMDAQT09PjEYjAQEB7N69m3Xr1gHxS4a0atWKjz/+GG9vb/78889Ek/uIjCOT3gghhBAi27HJZcOhG4fIZZKL/tX6c+XTK0xtODVDikUAg2ZgmMcwAL458A1xRllKOqvp4daD1q6tk50AycrMitaureleqXu6Z/nxxx+ZN28ehw4dokWLFrz//vtcuXKFDRs2MHTo0ET7vvPOO/Tp04cBAwbQvXt3ypUrx/r16xNt37t3L127duW9995j3bp1zJs3L2HpDQsLC3bv3k2DBg0YNWoUDRs2pH///ly6dOm5vZTPU6RIEWrUqMHt27dp3759ku1DhgzB19eXrVu30qJFCzp06MCyZcuoVatWwj7e3t58//33bNy4kZYtW+Ln58eCBem3hIlInpbei41mNHd3d/XfGZyEEEIIkb39HfY33xz4hkn1JyU8T7YvcB/F8hejsE1hXTLFGmMp8X0Jrt2/xqo2q3i/7PsvP0ikGX9/f1xdUzdUVCnF/JPzmbBvAsHhwZgaTIk1xuJg5cAIzxHpIgtICwAAIABJREFUtpyGECnxou9xTdNOKKXc0+I6MiRVCCGEEFnWtfvXGLd3HItPLSZOxeFg5cD4euMBqFW01kuOTl+mBlOG1BhCny19mLB/Am3KtJHiIovRNI2elXvSw60H/iH+hEWEYWtpi6u9q/y3FDmGDEkVQgghRJbzz4N/+HjTx5T8viQL/OKHqXV9uyvd3dJ/eOCr6FqpK07WTpy6c4o//v5D7zjiNWmaRhmHMni84UEZhzJSLIocRXoYhRBCCJGlfH/kewZtH0R0XDQaGh9W+JCRniMpYVdC72hJWJhaMKn+JGLiYqjjUkfvOEII8cqkYBRCCCFEllLGoQwxcTG0K9uOUe+OwtUh/ZY0SAtd3u6idwQhhHhtUjAKIYQQItMKCQ9h8oHJhISHsLDFQgDqFqtLQL8A3rJ9S+d0r+5x9GNym+fWO4YQQqSYPMMohBBCiExpnf86is0sxpSDU1h8ajHX7l8D4p8ny4rF4pg9Yyg0rRB+t/30jiKEECkmBaMQQgghMp1/HvxDlw1deBz9mMZvNeZIjyO45HPRO1aqPIh6wKPoR0zcP1HvKEIIkWIyJFW80K6ruxixawSF8hTCOY8zhfIUSng553GmpF1JTAwmescUQgiRjSil6LGxBw+jHtK8VHPWt1ufLWal/Pydz5l1dBZrzq/hYshFStmX0juSEEK8lBSM4oUuh13m8I3DyW5/NOxRwrMYA38fyJ0ndyiUuxDONomLy0J5CmFlZpVRsYUQQmRhvid82fb3NmwtbZnrNTdbFIsAzjbOdHm7C/NOzmPygcksaLFA70hCCPFSUjCKRB5GPWTI9iFMrDeR/Jb5ae3amjIOZbj16FbC6+ajm9x6dIsHkQ8SPbi/9fJWLoZefO55P6r8EXO85gBwKfQS4/aNo1Dupz2V/youC+QugLmJeYZ8rkIIITIfpRS/+v8KwI/v/UiB3AV0TpS2htQcwgK/BSw9vZRRtUfxRt439I4khBAvJAWjSBAeE47Xci/2Xd9H0JMg1rZbi52VHR5veKTo+HnN5hH4IPC5xeW/nzsJCA1g6V9Lkz3PpX6XEiYzWHByAdcfXE88FNbGGQcrBxkKK4QQ2ZCmaWz9YCu/XfwNb1dvveOkubds36Jt2basOLuCaQenMbPJTL0jCaGrJ0+e0L17d7Zv305YWBiLFi2iS5cuescS/yIFowAgKjaKVitbse/6PpzzODOt4bRXPketorWoRa2X7lfBqQILmy9MKCb/XVzeeXwHJ2unhH2Xn13Orqu7kpzDRDPhgwofsKTlklfOKYQQInMzMZhky2LxmWEew1hxdgUBYQEopbLNkFshXsfs2bPZuHEjS5cuxdnZmeLFi+sdSfyHFIyCWGMsHdd25I+//8DByoEdPjsolr9Yul2vSN4idK3U9bnb4oxxiXoOe7n1omaRmokKy1uPbhEcHoyFiUXCfkZlxKiMmBrkW1oIIbKigNAAhu8czndNvqNQnkJ6x0lXFZwqcK7POco4lNE7ihC6u3DhAqVKlaJ169Z6RxHJkGU1cjijMtJtQzfW+q8ln0U+tnXaRmn70rrl+e8w03bl2jG2zljmN5/Plg+2cKr3KYIGBxE5IpIpDacAsO3vbbw95218T/jqEVkIIUQqxRnj6Ly+M7/6/8rXf36td5wMIcWiSIkuXbrg7u7O5s2bKVOmDFZWVjRt2pSwsDAuX75MnTp1sLa2xt3dndOnTyc61mg0MmnSJN566y1y5cpFyZIlWbIk8ciszZs306BBAxwdHbGxsaF69eps27Yt0T6jR4/G3t4ePz8/qlevjpWVFZUqVWLfvn0vzR8SEkLnzp2xs7PDysqK2rVrc/z48YTtLi4uLFiwAD8/PzRNe2Fve+3atWnTpg2+vr64uLhgaWlJ06ZNuXnzZsI+165dQ9M0li9fTqdOnciTJw+Ojo6MGTMmyflOnz5Ns2bNyJcvH7lz56Zq1aps3779pZ9TTiTdMTncstPL+On0T1ibWbP1g628XeBtvSOlSC7TXOQyzQXAo6hHnAk6wzcHvqGnW0/MTMx0TieEEOJVTD04lcM3DuOcx5kJ9SboHSdD/XXnLwIfBNK8VHO9o2R72pjMMfRXjVKvtP/169cZOXIk48aNIzw8nH79+tGrVy+uXbtGz549GTJkCMOGDaN9+/acO3cuoejq168fS5YsYeTIkbi5ubF9+3a6deuGnZ0dXl5eAFy9epVmzZoxaNAgDAYDW7dupUmTJuzdu5eaNWsmZAgPD6dz584MHDiQAgUKMGbMGLy9vbl+/TpWVsnPgt+yZUsuX77M1KlTsbe3Z8qUKdSpUwc/Pz/eeust1q1bx5dffsmVK1dYtGjRS78Whw4d4uLFi3z77bdERkbyxRdf0LJlS44dO5Zov8GDB+Pl5cWaNWvYu3cvY8aMwd7enk8++QSI79WsWbMmpUqVYs6cOdjZ2XH8+HH++eefV/pvk1NIwZjDfVDhA/zu+OFV0ovqhavrHee1eLt642rvin+IPz+f/jnZ4a5CCCEyn7NBZxm5ZyQA85vPJ79lfp0TZZwTt07gPs8dBysHrg24JstPiecKCwvj0KFDCc/2nT59milTprBkyRJ8fHyA+NmFmzZtyoULF3B1deXy5cvMnj2bRYsW0blzZwDq16/P7du3GTNmTELB2Ldv34TrGI1G6tSpw7lz51iwYEGigjEiIoIZM2ZQt25dAAoWLEilSpXYu3cvjRs3fm7u33//nQMHDrBnzx7effddAOrWrYuLiwtTpkxh7ty5VKpUCQcHB+7evUv16i//OzQoKIiDBw9StGhRAIoWLYqHhwe///57ohxly5Zl7ty5ADRq1IigoCAmTJjAxx9/jMFgYMyYMeTNm5d9+/ZhaWkJQIMGDV56/ZxKhqTmUFGxUQAYNAPfNvqWusXq6pzo9Rk0A8NrDQdgwv4JxBnjdE4khBAiJWLiYui8vjPRcdH0dOtJ47ee/4dnduVW0I3KBSsTHB7MQr+FescRmZSLi0uiiWDeeit+Jvlnxdu/254Nz9y5cycGgwFvb29iY2MTXvXq1ePUqVPExcX/rXTjxg06d+6Ms7MzpqammJmZsW3bNgICAhJlMDMzo3bt2gnvy5Qpk3B8co4ePYqDg0NCsQhgbW2Nl5cX+/fvf50vBW5ubgnFIkDNmjVxdHTk6NGjifbz9k48aVarVq24detWQt5du3bRrl27hGJRvJgUjDnQjMMzqLGwBiHhIXpHSTPty7XnzfxvcjnsMqvOrdI7jhBCiBSYuH8iJ2+fpGjeoq81O3dWp2lawg3PyQcmEx0XrXMikRnly5cv0Xtzc/Mk7c/aIiMjgfhnB+Pi4sibNy9mZmYJry5duhAbG8vt27cxGo00b96cgwcPMnbsWHbv3s2xY8do0qRJwnmesbGxwWAwJHu957l9+zZOTk5J2p2cnAgLC3uVL0ECR0fH57bdvn37hfs9e/9sv9DQUAoWLPhaGXIiGZKawyw4uYCBfwwEYM+1PbQp00bnRGnD1GDKMI9h9NzYkwn7J9CuXDsMmtwPEUKIzCzWGIupwZRFLRaRJ1cevePoomXplpS2L82FkAssP7OcLm930TtStvWqzw5mZba2tpiamnLgwIFEhd4zjo6OXL58GT8/P7Zu3ZpoOGdERESaZChYsCBBQUFJ2u/evYutre1rnfN55wsKCkpS/P13v2fvn+1nZ2eXpMgUyZO/qHOQFWdX0HNjTwC+a/xdtikWn/Gp6ENhm8LcfXyXK/eu6B1HCCHES4ytM5a/P/2bOsXq6B1FNwbNwNCaQwGYtH+SPFYh0kTdunWJi4vjwYMHuLu7J3mZm5snFIa5cuVKOC4wMJADBw6kSYZq1aoRFBTE3r17E9rCw8PZvHkzHh4er3XOkydPcv369YT3Bw4cICgoiKpVqybab926dYner127loIFC1K4cGEA6tWrx6pVq17YQyr+T3oYc4iNFzfSaV0nFIrxdcfTr1o/vSOlOXMTczZ12EQJuxIycYAQQmRi0XHRmJvED2l7I+8bOqfRX8fyHRm5ZyQXQy+y/sJ6WpeR9ehE6pQqVYrevXvTvn17hgwZgru7O5GRkZw7d46AgADmz59P6dKlKVy4MJ9//jlff/01jx49YtSoUTg7O6dJhkaNGlGzZk3atWvHpEmTsLOzY+rUqURERDB48ODXOqejoyNeXl6MHj06YZZUNze3JBPvnDt3jo8++ojWrVuzd+9eFixYwMyZMxN6W0eNGkWVKlXw9PTk888/x87ODj8/P+zs7OjWrVuqP/fsRgrGHGDnlZ28v/p9Yo2xDK05NOF5ieyoYoGKekcQQgjxAodvHKbt6rbM8ZrDeyXe0ztOpmBmYsaXtb7k5O2TVC5UWe84Ipv44YcfKFmyJPPmzWPkyJHY2NhQpkwZunfvDsT3LK5du5ZPPvmENm3aULhwYUaMGMGePXs4e/ZsmmRYt24dn3/+OQMGDCAyMpKqVauya9euhEl6XtU777xD/fr1GTBgAMHBwdSuXRtf36TrcE+ePJlNmzbRunVrLCws+OqrrxLNCFuqVCn279/P0KFD6dGjBxA/kc+ECTlrWZ+U0pTKuPHcmqYtBLyAIKVUuadttsBKwAW4BrRVSt3T4heRmQm8B4QDXZRSJ192DXd3d/XvBUEFDPh9ADOPzKRvlb581+S7Fy6Kml08jHrIOv91+FT0yRGfrxBCZAXhMeFUmluJgNAABtcYzOQGk/WOJLIxf39/XF1d9Y4h0kjt2rWxt7dnzZo1ye5z7do1ihUrxsaNGxOWDsnOXvQ9rmnaCaWUe1pcJ6OfYVwM/HfO7KHATqVUCWDn0/cATYAST1+9gNkZlDHbmd5oOitar2Bmk5k5ongyKiNuc93osqELewP3vvwAIYQQGWLEzhEEhAZQxqEMY+uM1TtOppWRN/OFEOJlMrRgVErtBf47j24LYMnTfy8BWv6rfamKdxjIp2mazH+bQgGhAYRFxH+pNU3LUbOGGjQDnSp0AmDcvnE6pxFCCAGwN3AvM4/MxEQzYWnLpViYWugdKVNa57+OinMqcuB62kw8IoQQqZUZKggnpdRtgKcfny2c4gz886/9bjxtEy9x5d4V6iypQ+3FtQl+Eqx3HF30q9aPPOZ52HFlB0duHNE7jhBC5GiPox/TZX0XFIrhtYbLc3ovcPL2Sc4EnWHi/ol6RxEiU9mzZ88Lh6MCuLi4oJTKEcNRM1JmKBiT87yxk88do6FpWi9N045rmnY8ODhnFkjP3Hh4g3pL63Hr0S3srOzIbZ5b70i6sLW0pU+VPgCM3zde5zRCCJGzDd42mKv3r/J2gbf50vNLveNkap9W+xRLU0s2X9rMX3f+0juOEEJkioLx7rOhpk8/Pltp8wZQ5F/7FQZuPe8ESilfpZS7UsrdwcEhXcNmZkFPgqi/tD7X7l+jmnM1fmv/G5ZmlnrH0s1n73yGpaklGwM2yi9dIYTQUSvXVhTPX5ylLZcmLKchns/B2oFelXsBMOnAJJ3TCCFE5igYfwM6P/13Z2DDv9p9tHjVgQfPhq6KpO5F3KPhTw25GHqRCk4V2PrBVvLkyqN3LF05Wjsm/NKdsF+mSRZCCL00KN6AC30vUN6pvN5RsoTP3/kcM4MZq86t4lLoJb3jCCFyuAwtGDVN+wU4BJTSNO2GpmndgUlAA03TLgENnr4H2AJcAS4D84A+GZk1KwmPCee95e/x192/KGlXkm0fbiO/ZX69Y2UKg2oMomaRmnxY/kO9owghRI7z72LH1CBLP6dUkbxF8Knog1EZmXxAlh4RQugrQ396K6U6JLOp3nP2VcAn6Zsoe7AwtaBKoSrcfnSbHZ124JTbSe9ImUZhm8Ls77Zf7xhCCJHjbArYRPNfmjPMYxjj68mz5K/qi5pfsOjUIn7/+3ciYyNlVlkhhG4yw5BUkUoGzcDMxjM53us4RfIWefkBOZisbSWEEOkvNDyUnht7olDYWdnpHSdLKmFXgk0dNnGx70UpFoUQupKCMYuKM8bx5a4vE5bN0DQNeyt7nVNlXoH3A+myvgufbv1U7yhCCJHt9dvajzuP7+Dxhgf9q/XXO06W1aREE6zMrPSOIXKYWbNmoWn/X6xgz549aJrG2bNnE9o0TWPWrFkvPM/ixYvRNI3Hjx+nKs+1a9fQNI1Nmza90nEBAQGMHj2a+/fvp+r66aV27dq0adNG7xgpIgVjFmRURnps7MH4feNpvqK59JqlQERsBEv/WorvSV9uPrypdxwhhMi21pxfwy9nf8HKzIrFLRZjYjDRO1KW9zDqIfuvy+MVQh9ubm4cOnSI4sWL63L9ggULcujQITw8PF7puICAAMaMGZNpC8asRArGLEYpRf+t/Vl8ajGWppZMaTAl0V0g8Xyl7UvTpkwbouOimXpwqt5xhBAiWwp6EsTHmz8GYEqDKRS31ecPzOzk5sObFJ1RlGa/NONh1EO944gsIDIyMk3PZ2NjQ/Xq1bG01Geptly5clG9enXy5cuny/WfiYiI0PX6epKCMYsZsWsEs47NwtzEnA3tN+DxxqvdbcnJRtQaAcDcE3MThvIKIYRIO1/s+IKQ8BDqFatHb/feesfJFpxtnKngVIH7kfeZe3yu3nGEDvbu3UudOnXInTs3efPmpXbt2vj5+QH/H/Z59OhRateujaWlJVOmTAHiC8chQ4ZQpEgRcuXKRcWKFdmyZUuic0dFRdG3b1/y5cuHra0tAwcOJCYmJtE+zxuSChAdHU3//v2xtbUlX7589OvXj+jo6Bd+LinJ9F/PG5Lq4uLCoEGDmD59OoULFyZ//vy0b98+oTdxz549NGvWDIBixYqhaRouLi4Jx1+/fp327dtja2uLlZUVjRo14uLFi0muuWzZMnx8fMiXLx/NmjWjc+fOVK1aNUnGWbNmYWlpmTD8dtq0aVSpUoW8efPi5OREs2bNuHz58gs/zxs3btC2bVscHR2xtLSkePHifPXVVy88JqNIwZiFTNw3kYn7J2KimbCqzSoaFG+gd6QspWKBiniV9CIiNoLph6frHUcIIbKdb+p/w4cVPmRhi4UYNPkTI60M8xgGwLRD04iMTdveI5G57dmzh3r16mFmZsaSJUtYuXIltWrV4ubNxI/XdOjQAS8vL7Zs2YKXlxcAbdq0YfHixQwfPpyNGzdSpUoVmjdvzqlTpxKOGzp0KPPnz+err75i2bJlBAYGMm3atBRlmzZtGjdu3GDZsmV8+eWX+Pr6MmLEiBcek5JMKbVq1Sp27tyJr68v33zzDZs2bWL48OFA/DDaqVPjR5StXbuWQ4cOsW7dOgDCwsLw8PDg4sWLzJkzh1WrVvHkyRPq16+fpBdx0KBB5MmTh9WrVzN8+HDat2/PsWPHuHLlSpIsTZs2JXfu3EB88de3b182bNjAvHnziIuLo2bNmjx48CDZz8fHx4d//vkHX19ftm7dyogRI4iKinrlr0u6UEplq1flypVVdrTryi7FaJQ2WlPLTi/TO06WdeifQ4rRqDwT8qiw8DC94wghhBAvZTQaVaU5lRSjUT8e/VHvOFnG+fPn9Y6QatWrV1eVK1dWRqPxudsXLVqkADVjxoxE7Tt27FCA2rNnT6L2WrVqqTZt2iillAoJCVEWFhZq0qRJCdvj4uJUqVKlVHyJEG/37t0KUGfOnEloA1SpUqVUXFxcQtu4ceOUpaWlCg0NTZTt0aNHKc70PFevXlWA2rhxY0Jb0aJF1ZtvvqliYmIS2vr376+cnJwS3m/cuFEB6urVq4nO9+WXXypbW9uEnEopFRYWpmxsbNSsWbMSXbNly5aJjo2JiVF2dnZq4sSJCW03btxQmqap1atXPzd/bGysCg8PV7lz51ZLlixJaH/33XdV69atE95bW1ur3377Ldmvw/O86HscOK7SqL6S239ZRG2X2gx6ZxBzvObQsXxHveNkWdULV6desXo8jn7Mjis79I4jhBBZnlKKZaeXERMX8/KdxWvRNI3hteJ7TiYfnCxf61TSxmjJvnxP+Cbs53vC94X7/ltl38rJ7tdrY6/XyvnkyROOHDlC586dXzpfRdOmTRO937FjBwUKFKBmzZrExsYmvOrVq8fx48cBOHPmDJGRkbRo0SLhOIPBkOj9i7Ro0QKD4f+lRKtWrYiIiEgydPVVMr2KOnXqYGr6/yXly5QpQ1BQ0EuHxe7YsYMGDRpgY2OTkCFPnjxUrlw5SY7/fl1NTU1p1aoVK1euTGhbvXo11tbWifY9fPgwDRo0wM7ODlNTU6ysrHj8+DEBAQHJ5nr77bcZNmwYixcv5vr16yn6GmQU05fvIvQUZ4zDxGCCpmlMaThF7zjZwozGMzA1mFLavrTeUYQQIstb6LeQHht7sPT0Un7/4HeZiC2deJf2ppRdKS6GXmTF2RV0qthJ70gind27dw+lFAULFnzpvk5OToneh4SEcOfOHczMzJLsa2ISP3PxnTt3AHB0dEy0/b/vk5Pccbdv337u/inJ9Cr+OwmOubk5Simio6MxNzdP9riQkBAOHz6cqOh7pl69eone//frCtC+fXvmzZtHQEAAJUuWZOXKlTRv3jxhUqDr16/TsGFDqlatyty5cylUqBDm5uY0bdr0hRMSrVy5khEjRjBw4EDu379PxYoVmTZtWpJMepCCMRPbHLCZkXtGsrnjZgrkLqB3nGyjnGM5vSMIIUS2EHg/kIF/DATAp4KPFIvpyMRgwlCPocw+PhtnG2e942RpalTKliPrVbkXvSqnrHfwRK8TqYn0XPnz58dgMCRbgP3bf//fs7W1xdnZmfXr1yd7TIEC8X9bBgUFYWtrm9AeFBSUonz/3e/Z++QK3JRkygi2trY0b978uRPK5MmTJ9H75/1Mq127NgUKFGDlypX4+Phw5MgRhg0blrD9999/Jzw8nA0bNmBtbQ1AbGwsYWFhL8zl7OzM4sWLMRqNHD16lNGjR9O8eXOuX7+OnZ3d63yqaUYKxkxq99XdtF7Vmqi4KJacWsIXHl/oHSnbUUqx8+pOahapiaWZPlNFCyFEVmVURrr91o1H0Y9o5dpKHpfIAD4Vfehc8eXDE0X2YG1tTbVq1Vi6dCl9+/Z9pf/u9erVY9q0aeTOnZvSpZ8/oqp8+fJYWFiwYcOGhH2MRiMbNmxI0TU2bNjAxIkTE4alrl27FktLS8qVe/6N+ZRkSkvPehn/26tXr149Vq1aRdmyZV9rqRCDwUCbNm1YuXIlFhYW2NjY0Lhx44TtERERGAyGRMNlV61aRWxsbIrPX716dUaNGkWNGjUIDAyUglEkdfjGYZr90oyouCh6V+7NkJpD9I6ULfXc2JMFfgv4vsn39K3aV+84QgiRpcw+NptdV3dhb2XP7KazpYjJADLzbM4zadIk6tevT5MmTejVqxfW1tYcOnQId3f3hNlQn6dBgwY0atSIBg0a8MUXX1C2bFkePnzIqVOniIyMZOLEidjZ2dGrVy9GjRqFqakpZcuWZd68eQlLQ7zMo0ePeP/99+nZsyfnzp1j7Nix9O3bN1Fv5atmSkulSpUCYO7cubRv3x4rKyvKly/PZ599xs8//0zdunXp168fzs7O3L17lz///BMPDw86dOjw0nO3a9eOWbNmMX36dLy9vRMNga1bty5xcXF07dqV7t27c+7cOaZOnfrCdSQfPHhAo0aN8PHxoWTJkkRFRTFt2jQKFCiAq6tr6r8YqSQ/eTKZU3dO0WRZE57EPOHDCh/yQ9Mf5JdwOmlaIv7h5G8OfEN03IsfkBZCCPF/l8MuM2RH/M3MuV5zcbRO2TNPIm1cCLlAl/Vd2Hllp95RRDrz9PRk+/bthIeH8+GHH9KuXTv+/PNPChcu/MLjNE1j7dq1dOvWjRkzZtCoUSM++ugjDh06hIfH/9fwnjx5Mt26dWPs2LF06NCBQoUK8dlnn6Uo2+eff07BggXp0KEDY8eOpUePHkyYMCHVmdJK0aJFmTp1KmvXrqVmzZoJ6zLa29tz+PBhSpcuzcCBA2nYsCFDhgzhwYMHVKhQIUXnrlmzJkWKFOH27du0b98+0bby5cuzaNEijhw5gpeXF8uXL2f16tXkzZs32fNZWFhQvnx5Zs6cSfPmzencuTNWVlZs27bttXpB05oWP+tq9uHu7q5eZ6alzOBCyAU8F3kSHB6Md2lvVr2/ClODdAKnF6MyUmF2Bc4Fn2Nes3n0cOuhdyQhhMgSBm8bzNRDU+lYviPLWi3TO06OM3HfRIbvGk4dlzrs6rxL7ziZlr+/f6bonREivbzoe1zTtBNKKfe0uI70MGYiq86tIjg8mEbFG/FL61+kWExnBs2QME35pP2TiDWmbGy5EELkdN80+Ia5XnP5vsn3ekfJkfpU6YNNLht2X9vNoX8O6R1HCJHNScGYiXzl+RXzms1jbbu15DLNpXecHKFt2ba8ZfsWf9/7m5Vnk06vLIQQIimDZqBX5V7YWj7/WSWRvvJa5KVvlfhn7yfuT9vnvoQQ4r+kYNRZ8JNggp7ET0OsaRo93HpgZWalc6qcw9RgyjCP+KmQJ+yfgFEZdU4khBCZU6wxlk+3fsq1+9f0jiKA/tX7Y2FqwcaAjZy5e0bvOEKIbEwKRh3dj7xPo58b8e7id7n58KbecXKsDyt8SEWnirxf5n2Z/EYIIZLxzf5v+P7o93gt95Kba5mAo7UjPd16AjDpwCSd0wghsjMpGHXyJPoJTZc3xe+OH7HGWEwMJnpHyrHMTczx+8iP0bVHY2FqoXccIYTIdP668xdj/hwDwIzGM2R5h0xiUI1BmBpMWXVuVcJoJSGESGsyq4oOImMjabGiBQf/OUgRmyLs6LSDArkL6B0rR5OlS4QQ4vmi46LpvL4zMcYYPnb/mPpv1tc7knjqjbxvMNdrLjWK1JClTZKhlJLf8SJbysiVLuQWYQZTSvHB2g/YeXUnTtZO7PTZSdF8RfWOJYgv5L9FPPrMAAAgAElEQVQ/8j3t1rTL0P8JhRAiMxu3dxx/3f2LN/O/yeQGk/WOI/6jW6VulLYvrXeMTMnMzIyIiAi9YwiRLiIiIjAzM8uQa0nBmMGW/LWEtf5ryZsrL9s7baeEXQm9I4mnYo2xjP5zNKvOreLPwD/1jiOEELo7dvMYE/ZNQENjUYtF5DbPrXckkQylFH+H/a13jEzF0dGRmzdvEh4eLjeCRbahlCI8PJybN2/i6JgxIwtkSGoGezaT2fdNvqe8U3md04h/y22emwHVBjByz0jG7R1HbZfaekcSQghdnb57GoNm4NNqn+JZ1FPvOCIZ4THh1FlSh3NB5wgcEIidlZ3ekTIFGxsbAG7dukVMTIzOaYRIO2ZmZjg5OSV8j6c3LbvdcXF3d1fHjx/XO8YLHbt5DPdC7jKmPhO6H3mfojOK8jDqIYe6H6J64ep6RxJCCF2duXuGt2zfwtLMUu8o4gWaLGvC75d/Z9S7oxhde7TecYQQOtM07YRSyj0tziVDUnVQxbmKFIuZVD6LfHxS5RMAxu8br3MaIYTQx79vJpd3Ki/FYhYw3GM4AN8d+Y5HUY90TiOEyE6kYMwAwU+CqbWoFgeuH9A7ikiBgdUHYmlqyaaATfjd9tM7jhBCZKgn0U+osbAGq8+t1juKeAW1itbC4w0P7kXeY+6JuXrHEUJkI1IwZoB+W/ux//r+hDWsRObmYO1Ab/feACz0W6hzGiGEyFhDdwzl8I3DfL33a2KNsXrHEa/gWS/jt4e+JTI2Uuc0QojsQgrGdLbOfx0rz63E2syauV5yxy+rGFRjEL+0/oUZjWfoHUUIITLMrqu7mHVsFqYGU5Z6L8XUIHPjZSWN32rM2wXe5vbj2yw5tUTvOEKIbEIKxnQUFhFGny19AJhUfxLF8hfTOZFIqUJ5CtG+XHtMDCZ6RxFCiAzxMOohXTd0BWCk50jeLvC2zonEq9I0jWEew8hvkZ84Fad3HCFENpGiW4eaphUBHJRSJ5+zzQ0IVkr9k9bhsrrP/viMO4/v4PGGB32q9NE7jnhNtx7dQkOjYJ6CekcRQoh08/kfn3P9wXUqF6zMUI+hescRr6m1a2uavNWEPLny6B1FCJFNpLSHcTbwYTLbOgI/pk2c7GPrpa0s+WsJFqYWLGi+AIMmnblZ0dK/llJsZjFG7xmtdxQhhEg3Wy9tZb7ffMxNzFnScglmJmZ6RxKvycRgIsWiECJNpbSKqQ7sSmbb7qfbU0XTtIGapp3TNO2spmm/aJpmoWlaMU3TjmiadknTtJWappmn9joZJSouCltLW76u8zUl7UrqHUe8pmrO1YiJi2HRqUXceHhD7zhCCJEu8lnko3j+4oyrM46yjmX1jiPSQHhMON8d+Y7tf2/XO4oQIotLacFoBagXbLdOTQhN05yBTwF3pVQ5wARoD3wDTFdKlQDuAd1Tc52M1LJ0Sy58coGB1QfqHUWkQin7UrQt25YYYwxTD07VO44QQqSLd4q8w1+9/+Kzdz7TO4pII4v8FtH/9/58ufvLROtqCiHEq0ppwXgG6JDMtg7AuTTIYgpYappmSnyBehuoC6x5un0J0DINrpOuYuJiEv7tYO0gk6ZkA8NrxU9T7nvCl7uP7+qcRggh0k5YRFjCv63NreV3VjbStVJX7K3sOXrzKLuv7dY7jhAiC0tpwTgJ6Khp2mpN05pqmub29OMq4gvG8akJoZS6CUwFrhNfKD4ATgD3lVLPFoG6ATin5jrp7Un0EyrMqcD4veMTFY4i/SilOB98nn2B+zgffD5d7qJWcKpA81LNiYiNYPrh6Wl+fiGE0EPwk2Bcf3Dlo40fyZp92ZCVmRUDqg0AYMK+CTqnEUJkZSkqGJVS64DOwDvARuDY04/vAB8qpdanJoSmafmBFkAxoBDxQ1ybPC9KMsf30jTtuKZpx4ODg1MTJVVG7BrBhZALrPFf8/KdRaoopZh3Yh7FZhaj6ryqNPulGVXnVaXYzGLMOzEvzQvHEbVGAPDDsR8S3ZEXQoisSClFny19CHoSxKWwS5ibZJkpAsQr+KTqJ+Qxz8POqzs5evOo3nGEEFlUiqfuVEr9BBQBygCeTz++oZT6JQ1y1AeuKqWClVIxwFqgBpDv6RBVgMLArWSy+Sql3JVS7g4ODmkQ59UduH6A7458h4lmwsLmC2WGuXSklKLz+s4M+GMAgQ8CeRLzhAdRD3gS84TAB4EM+GMAndd3TtOisapzVRoWb0gdlzo8jHqYZucVQgg9LDuzjDXn15DbPDcLWyyUmbxTISNGuryufBb5+KTKJwBM3D9R5zRCiKwqReswPqPifwpeSIcc14HqmqZZARFAPeA48TOwtgFWEN/DuSEdrp1qETERdPutGwrFUI+hVCpYSe9I2dr8k/P51f9XwmPCn7s9PCacX/1/xbOoJz3ceqTZdX9r/xu5THOl2fmEEEIPF0Iu0HtTbwCmN5qOSz4XfQNlUUop5p+cz/h94wkJD8HUYEqsMRZ7K3tG1BpBD7ceaJqmd0wGVB/AjCMzWH9hPeeDz1PGoYzekYQQWYyW0jthmqYVAryI7+mz+M9mpZT6IlVBNG0M0A6IBfyAHsQ/s7gCsH3a9qFSKupF53F3d1fHjx9PTZRX9sX2L5h8cDKu9q74feQnRUU6UkpRbGYxAh8EvnRfl3wuXPn0Sqb4hS2EEJlBeEw41eZX42zQWTqU68CyVsvkZ+RreDbSJbmbl1ZmVrR2bc2Slksyxdf320Pf4pzHmTZl2sjERkLkEJqmnVBKuafFuVLUw6hpmjfwC/HLXQQB0f/ZRQGpKhiVUqOAUf9pvgJUTc1509uxm8eYemgqBs3AohaLpFhMZ/4h/oSEh6Ro3+AnwfiH+Kf53dT91/fzw7EfWNB8AVZmVml6biGESE/j9o7jbNBZStqVZK7X3ExRzGRFeo10eV2yXIoQIjVSOiR1ArAN6KKUkhk//sXOyg7Pop5ULliZaoWr6R0n2wsND8XUkLJvW1ODaZpPUKOUYuAfAzl+6zg1CtegX7V+aXp+IYRIT0M9hvLPw38YXGMweXLl0TtOlqSUYvy+8ckWi8+Ex4Qzft94ulfqnqkK88fRj8ltnlvvGEKILCSlT7kXAb6TYjGpN/O/yU6fnUyoJ1NWZwQ7KztijbEv3xGINcZia2mbptfXNC1hxtTJBycTFfvCEdJCCJGp2OSy4Sfvn6jgVEHvKFnW64x0yQyMykifzX1w/taZGw9v6B1HCJGFpLRgPAiUSs8gWU1oeGjCTGgGzSBTkmcQV3tX7K3sU7Svg7UDrvauaZ6heanmlHMsx42HN1j619I0P78QQqSlJ9FP+PrPr2WtxTSi90iX12XQDIRGhPIw6iFj/xyrdxwhRBaS0oLxM6CXpmmdNU0rpGma1X9f6Rkys4k1xtLw54Y0+KkBtx/d1jtOjvKsh+9lzw5amVkxotaIdBkGZNAMDPcYDsCkA5NS3OMphBB66Lu1LyP3jKTL+i56R8kW9B7pkhpf1/k6fvkvv4VcDLmodxwhRBaR0oLxNFAeWAT8Azx6zivHmHJgCidvn+Ry2GV5DkAHPdx60Nq1dbJF47PZ6bpX6p5uGdqWbUsJ2xJcuXeFFWdXpNt1hBAiNRafWsziU4uxNLVMGE4vUiczjHR5XSXtStKtUjfiVBxf7f5K7zhCiCwipQVjN6Dr01e3ZF45gn+wP6P/HA3AvGbzZNIAHWiaxpKWS5jRaAYueV2wNrMmb668WJtZ45LXhZmNZ6b7VOYmBhOGegwFYPrh6el2HSGEeF3ngs7RZ3MfAGa9N4vyTuV1TpQ9ZIaRLqkx8t2RWJhasPr8ak7cOqF3HCFEFpDidRizivRchzHOGIfHIg8O3zhM90rdmd98frpcR6ScUgr/EH/CIsKwtbTF1d41w345R8dFM2n/JHpV7kWB3AUy5JpCCJESj6MfU3VeVfxD/PGp6MPiFoszXeGSlWW1dRj/a8j2IUw5OIWGxRvyx4d/6B1HCJEOMnwdxn9duBDwDmALhAGHlFK30iJIVvDdke84fOMwhfIUYmrDqXrHEcTf6U3rdRZTytzEnJHvjtTl2kIIkRylFH0298E/xB9Xe1d+fO/HTFm0ZGXPRrrUeqMWE/ZNIDg8GFODKbHGWBysHBjhOSLTLafxb1/U/ALfE75Ym1kTEROBpZml3pGEEJlYigpGTdNMgO+BnoDJvzbFaZrmC/RTShnTIV+mceXeFUbsin/+Y67XXPJZ5NM5Ufp61nMXGh6KnZVdhvbcZUWxxljuPr6Ls42z3lGEEDlcjDGGyNhIrMysWP3+aqzNrfWOlC1pmkbPyj3p4dZDt5Eur8vOyo6AfgE4WjvqHUUIkQWktIdxDPHPKQ4HVgJ3ASegHTAWCAWydVdLYZvCDPUYSuD9QLxKeukdJ90opZh/cj7j940nJDwk4Y6pvZU9I2qNoIdbj0z/izCjnb57Gu+V3jhZO3Gg2wH5+gghdGVuYs7KNisJCA2glL2siJWe/g77m+VnlvOr/6+EhIfw+TufZ6pJbl5EikUhREql6BlGTdOuA98ppZKMw9Q0bRDwqVLqjXTI98rS8xlGiC+osmtBkNWfydDL4+jHuMxwITQilF0+u6hTrI7ekYQQOdCT6CeYGEywMLXQO0q2dufxHVadW8XyM8s5cvNIku3TG01nQPUBOiR7PQeuH2C+33zmN5uPicHk5QcIIbKEtHyGMaWzpDoSv7TG85x+uj1buvXoFsFPghPeZ+dCaf7J+ckWiwDhMeH86v8rC/wWZHCyzC23ee6EPw7G7RuncxohRE6klKL35t68s+AdLodd1jtOtvMw6iFLTi2h0c+NcP7Wmf6/939usQjw2R+fsfHixgxO+HpijbH4rPdh8anF/HT6J73jCCEyqZQWjAFA+2S2tQey5eqvSim6buhKmR/LsC9wn95x0pVSivH7xidbLD4THhPO+H3jyW6z66ZW36p9scllw66ruzj0zyG94wghcpgFfgv4+fTPBIQGEBMXo3ecbCEqNor1F9bz/ur3cZrqRJcNXdj29zaML5myQaHo8GsH/G77ZVDS12dqMGVM7TEAjNozisjYSJ0TCSEyo5QWjOOALpqm7dA0rbemad6apn2kadoOoPPT7dnO4lOLE345lLAroXecdOUf4k9IeEiK9g1+Eox/iH86J8pa8lnko1/VfgCM3zde5zRCiJzk9N3T9Nsa//NnTtM5uDpkjWfoMqM4Yxy7ru6ix289cJrqhPdKb9acX/PCQqrWG7UYUWsEJtr/h3M+iXmC1y9e3Hx4MyNip0qHch0o71ie6w+uM+f4HL3jCCEyoRQVjEqpVUBjwBqYCfwKfAdYAY2VUqvTLaFObj26xcA/BgIws/HMbL/OXmh4KKaGlM2BZGowJSwiLJ0TZT0Dqg/AysyKzZc2Z4k7y0KIrO9R1CPeX/0+kbGRdK/UnU4VO+kdKctRSnHi1gk+/+Nz3pjxBvWW1mOB3wIeRD1I9piKThX5pv43BA4IZG/XvYyrO47vm3yfaJ9bj27R7JdmPI5+nN6fQqqYGEyYUG8CEH/D82HUQ50TCSEymxSvw6iU2gZs0zTNANgDIdl1KQ2lFL039eZB1AO8SnrxQfkP9I6U7uys7Ig1xqZo31hjLLaWtq98DaUUscZYYowxxMTFJPp3atqMyohbQTeqOFd55Uxpyd7Knt6Ve7PGfw1BT4J0zSKEyP6UUny06SMCQgMo71g+ScEiXuxS6CV+OfsLy88s52Loy5+sccnnQsdyHelYviNlHcsm2f5xlY8JCA1gxpEZCW1+d/zo+GtH1rVbl6knlGlaoik1itTg4D8H+fbQt4yuPVrvSEKITCSls6TmAXIrpW4/Z1tB4JFSKlPcQkuLWVJ/OfMLHdd2xCaXDef7nM8Ra+sppSg2sxiBDwJfuq+FqQVVClUhxvi0cPtXIfeitpQWpK9rdtPZ9Hbvna7XeJlHUY+wMLXAzMRM1xxCiOxv29/baPRzI6zNrDne6zil7UvrHSnTu/P4DivPrmTZmWUcu3XspfvbW9nTrmw7Pij/AdULV3/pxHdxxjharWrFbxd/S9Q+oNoApjeenqrs6W1f4D48F3tSKE8hrva/irmJud6RhBCpkJazpKa0YFwFPFBK9XzOtrlAXqVUcpPiZKjUFozhMeG4zHAhODyY+c3m092texqmy9zmnZjHgD8GvHTim8zKzGDG4R6HcSvopncUIYRId0opZh+fTX6L/HQo30HvOJnWg8gHrPVfy/Kzy9l1dddLJ62xNrPG29WbD8p/QL1i9V75BuDj6Md4LvLE707iRxN+eO8H+lTp88r5M5LvCV+8S3vjYO2gdxQhRCrpUTDeAXorpdY/Z1sLYLZSqlBaBEqttOhh3Bu4l2WnlzHHa062Xkbjv6Jjo6k0txLnQ87rHeW1lbAtwYleJ8iTK4+uOYKfBDPj8Ay6VepGcdviumYRQoicJjI2ki2XtrD8zHI2BWwiKi7qhfubGcxoUqIJHct1pFmpZliZWaXq+jcf3qTa/GrcfPT/SW8MmoHNHTfT+K3GqTq3EEKkRFoWjCl9hjEvkFy3UySQPy3CZBaeRT3xLOqpd4wMdevRLdqtaZfuxaKJZoKZiRmmBlPMDGaYmZglfHydtui4aFacXZFw/kthl/hkyycs9V6arp/HywzfOZz5fvMJDg/Gt5mvrlmEENmHUoqRu0fiU9En28/e/arijHHsubaH5WeW86v/ry+ctOaZd4u+S8fyHWnt2ho7K7s0y+Js48zGDhuptagWT2KeAGBURtqubsuBbgco71Q+za6VHqLjotkXuI96b9bTO4oQIhNIaQ/jaWC3Uqr/c7bNBOoppcqlQ75X9ro9jGERYfx15y/qFKuTDqkyt11Xd9Hh1w5JJmoxNZjiU8EHVwdXXPK5YG5i/sJCzszwtD2ZNlODKQYtpSu5pNxHGz/C92TiomxJyyX4VPRJ82ulVEBoAKVnlcbUYMrfn/5NkbxFdMsihMg+Zh+bTZ8tfSiUpxB/f/o3FqYWekfSlVKKE7dPsPzMclacXcHtx0mmWkji7QJv07FcR9qXa5/uP5s3XtxIy5UtEw2DLWJThCM9jlAwT8F0vfbrio6LpsLsClwKu8SZj89QxqGM3pGEEK9BjyGpPYE5wLfAYuA2UJD4NRg/Az5WSs1Li0Cp9boFY+f1nVn611KmN5rOgOoD0iFZ5mNURibtn8RXu79K8kxHYZvCrGqzineKvKNTupQLjwmn6ryqnAs+l9BmbWbNyY9OUtKupG652q9pz8pzK/m06qfMbDJTtxxCiOzh5O2TvLPgHaLjovml9S+0L5cppg7QRUBoAMvPLGf5meVcCrv00v2L5StGx/LxM5xmdAE08/BMBvyR+O8K90Lu/Nnlz1QPfU0vfTb3Yfbx2XiX9mZtu7V6xxFCvIYMLxifXvRLYBjw79uZkcDXSqlJaREmLbxOwbjl0haaLm+KhakFp3ufzhHDfMIiwui0rhNbLm1Jsq1h8YYsa7UMeyt7HZK9nnNB53Cf555oceVKBSpxqPshcpnm0iXT6bunqTinIhamFlzrfw2n3E665BBCZH0PIh/g5uvGlXtX6F25N7O9ZusdKcPdfnSbFWdXsPzsco7fevnveUdrR9qVbUfH8h2p5lxNtzkJlFL029qPH479kKi9lWsrVr+/Ol1G3qTW7Ue3Kf5dcSJiIzjS4whVnavqHUkI8YrSsmBM8U8ppdQ4oBDQFPB5+rFQZioWX8eDyAd8tOkjAMbVGZcjisXjt47jNtctSbGooTH63dFs6bglSxWLAGUdyzKzceJePL87fnyx4wudEkEFpwq0KNWCyNhIvj30rW45hBBZm1KKHht7cOXeFd4u8HamX54hLT2MeshCv4XUX1of52+d+WzbZy8sFnOb58anog+/f/A7Nz+7yXdNvkvRchjpSdM0ZjSeQZO3miRqX+u/lmE7humU6sUK5imYMNpq6I6hpLRzQQiRPaW4hzGreNUexl4bezHv5DyqOlflYLeDmXph3dRSSjHn+BwG/DGA6LjoRNvsLO1Y3no5DYs31Cld6imlaLemHavPr07U/lv732hWqpkumY7dPEbV+VXJbZ6bGwNvkNciry45hBBZ16yjs+i3tR95zPNwoteJHHFjE2Drpa34rPchJDzkhfuZGcx4r8R7dCzfEa+SXpl2mOfDqId4LPTgTNCZRO2+Xr70rJxk1TLd3Yu4x5vfvcn9yPts+3AbDYo30DuSEOIV6NLDmB3tuLKDeSfnYW5izsLmC7N1sfg4+jGd1nWiz5Y+SYrF6oWr4/eRX5YuFiH+Lq5vM1+K5i2aqL3rhq7ceHhDl0xVnKsw3GM4GztsxCaXjS4ZhBBZm7mJOblMcjG/+fwcUSwalZExe8bQdHnTZItFDY3aLrWZ12wedwfdZX379bQt2zbTFosANrls2NRxEwVyF0jU3mdLH3Zc2aFTquTlt8zP0JpDARi2c9hL168UQmRfObaHUSlFzYU1OXTjEOPqjGOE54gMSKcP/2B/2qxuw/ngpEtm9K/Wn8kNJmNuYq5DsvRx+MZhPBZ6EKfiEto8i3qyy2dXtr4pIITIvv558E+OmG35XsQ9Oq3rxOZLm5+7vVKBSnxQ/gPalWtHYZvCGZwubRy/dRzPRZ5ExEYktOXNlZeD3Q9muhlJw2PCqbe0Hh9V/gifij6Z8nlLIcTz6TLpTVbxKkNSwyLCmHF4Bl95foWZiVk6J9PHirMr6PFbj4R1oJ7JbZ6bhc0X8n7Z93VKlr4m7Z/EsJ2Jnw0Z/e5oRtUepVOieNcfXOeNvG/omkEIkfkppbj16BbONs56R8kwp++exnulN1fuXUnUbtAMfFb9M7pV6oarg6tO6dLWOv91tF7VGsX//wZzyefCkR5HcLR21DGZECK7kCGpacTW0paxdcZmy2IxKjaKvlv60uHXDkmKxbIOZTne83i2LRYBhtQcQv036ydqG7t3LHsD9+qSJ9YYywdrP6D0rNL8Hfa3LhmEEFnH90e/x/UHV349/6veUTLEz6d/pvr86kmKRQcrB3Z02sGUhlOyTbEI4O3qzTf1v0nUdu3+NVqsaEFETEQyR+kvJi5G7whCCB28UsGoxSuiaVoNTdOs0ytUeoqIiWDqwalExUbpHSXdBN4PxHOxZ5IpvAE6VejEkR5HKGVfSodkGcegGfjJ+6dEd2qNykjHXzsSGh6a4XlMDaYYNAMRsRH03txbZpwTQiTr2M1jDNo2iEfRj/SOku6i46Lpt6UfndZ1SjREE6Cqc1VO9DpBnWJ1dEqXvgbVGERPt8ST3Ry+cZiuG7pmuucFI2MjGbJ9CGV+LJOpC1ohRPpIccGoaVof4CYQCOwDSj1tX6tpWpZZ6X70ntEM3j6YD9Z+oHeUdLH10lbcfN04evNoonZzE3Pmes1lScslWJtnyVr/lRXIXYCfvH9K1Hbz0U26/dZNl4Lt24bfYmtpy44rO/j59M8Zfn0hROZ3L+Iebde0JcYYQ7+q/WhdprXekdLNrUe3qLOkDrOOzUqyrXfl3uztsjdbP7epaRo/vPdDktEwK8+tZNRufR+f+C9zE3O2X9nO5bDLz70ZLYTI3lJUMGqaNhj4FpgH1AX+vaDRHqBdaoNompZP07Q1mqZd0DTNX9O0dzRNs9U0bbumaZeefsyfmmscvXmUqYemYtAMDK4xOLWRM5U4Yxwjd4+k6fKmhEWEJdpWLF8xDnY7SK/KvXRdi0oPDYs3ZEiNIYnafrv4G7OOJv0DJb05WDvwbcP49RgH/jHwpVPFCyFyFqUUXTd05dr9a7gXcmdKgyl6R0o3ewP34jbXjYP/HEzUnsskF4taLGK212xymebSKV3GMTMxY/X7q5NMdjNu3ziWnFqiU6qkDJqBifUmAjBx/0QeRD7QOZEQIiOltIfxE2CkUmoU8b2L/3YRKJkGWWYCvyulSgMVAX9gKLBTKVUC2Pn0/WuJio2i24ZuGJWRz6p/RrXC1dIgcuYQ9CSIRj834uu9Xyd6gB6gWclmnOh1gsqFKuuUTn/j6o6jqnPVRG2Dtg/i1J1TGZ7Fp6IP9YrVIzQilM+3fZ7h1xdCZF4zj8xkw8UN5M2Vl1VtVmXLgkkpxYzDM6i7pC53n9xNtM0lnwsHux+ky9td9Amnk3wW+djUYRMOVg6J2ntu7Mmea3v0CfUcjYo3wrOoJ2ERYUw9OFXvOEKIDJTSgrEAcCKZbUbAIjUhNE2zATyBBQBKqWil1H2gBfDsFtsSoOXrXmP8vvGcCz5HCdsSjK0zNjVxM5UD1w/gNteNnVd3Jmo3aAa+qf8N69uvJ79lqjpmszwzEzN+af1LonUQo+OiabemHY+jH2doFk3TmOM1BwtTC5b+tZSdV3a+/CAhRLYXFhHGV7u/AmBRi0UUy19M50Rp73H0Yzqu7cjAPwYmWvYI4ouR4z2P41bQTad0+iqWvxi/dfiNXCb/v0kQY4yh1cpWBIQG6Jjs/zRNS+hl/Pbwt9x9fPclRwghsouUFoyXgXeT2eYJJF3g79W8CQQDizRN89M0bf7TSXWclFK3AZ5+fO5c05qm9dI07bimaceDg4OTbD915xQT98f/kFvQfAGWZpapjKs/pRTTD02n9pLa3Hx0M9E2J2sndvnsYkjNIbJm0lNv5n8TXy/fRG0BoQH03dI3w7O8ZfsWY2qPoY97H9wLpclsx0KILM7W0pY/u/zJpHqT8Hb11jtOmrsUeonq86uz4uyKJNu+8vyKzR03Y2dll6hdKcX54PPsC9zH+eDz2X6ysOqFq7PUe2mitnuR92i6vGmmeYShRpEaNC/VnPCYcMbtHad3HCFEBjFN4X4zgB81TYsG1jxtc9Q0rTvwGdAz2SNTnsMN6KeUOqJp2kxeYfipUsoX8IX4dRj/u/2nv34i1hhL3yp9qVW0Viqj6u9B5AO6/daNtdztYCUAACAASURBVP5rk2zzLOrJitYrKJinoA7JMrd25dqx48oO5vvNT2hb8tcS6r9Znw8rfJihWYbUHPLynYQQOYpbQbds2cO24cIGfNb78DDqYaL2vLny8pP3TzQr1SxRu1KK+SfnM37feELCQzA1mBJrjMXeyp4RtUbQw61Htn0ev23Ztv9j777Dojq6AA7/Lk3BjmDvvVdUrNiIXVGx916jfibGQjSJscU0scXeCxawx9h7R7Gg2Bt2ihTpuzvfH8RNNouKsuwuOO/z+CTMvXvnCLh7z52ZM9wNvYvHYQ9t293Qu3TY1IEDvQ6YxTTl6Y2ns+vWLh6FP0IjNPLBtCR9BpTkPrH7u/DNFMCOf4reRAM/CCFStDJfUZQ8wFkhRJG/v65PYsJYAmgohHiuKEpe4KgQ4r37QTg5OQlfX1+dNiEEXv5etCndhsw2mVMSqsldeXEF9y3u3A29q3dsfN3xTGs8DSuL5D4H+PxEJ0TjtMSJgOAAbVtmm8xcGnyJkjlLmiym4OhgCmUrZJL+JUkynfnn5+No50iXCimuHWd23hZjm3Fyht6xCrkq4NPZR+99VwhBn+198A7wJjohWu91dtZ2dCzbkdVuq9Nt0vi2+NHqK7pFb3pW6skatzVm8fe+GXyTMg5lTB2GJEnvoSjKRSGEQaayJTth/LvjLEBtwAEIBc4IIQxSKktRlBPAQCHELUVRvgfe7v0QIoSYpSjKBMBeCPHeoZmkEsb0YtXlVQzbM4xYVaxOe7YM2VjTfg1tS7c1UWRpy7WX16i5rKbO97Fa3mqc7n/a6E9vr7+6Tluvttjb2nN2wFksLSyN2r8kSaZzOvA0DVY2QC3UXBl6hUq5K5k6JIMJiQ6hu0939t/br3esW4VuLG2zNMktnpZeXMqYfWOSTBbfsrO2w7O5JwOrDTRozOYkXh1Ps3XN9Ire/NDwB6a4TDFNUJIkpSmGTBg/OI9AUZSMiqLsVxSloRAiUgixXwixQQjxl6GSxb99CaxXFOUqUAWYAcwCXBVFuQO4/v11sqg1akb+OZJbwbcMGKJpxCTEMGjnIPrt6KeXLFbLW41LQy7JZPEjVMxdkd+b/a7Tdun5JSYemmj0WAplK0S8Oh7fZ74m2epDkiTTCIkOoevWrqiFmrHOY9NVsnjx2UWqL6mulyxaWVjh2dyT9R3WJ5ksCiGYfmL6e5NFSJyVMf3E9HS9ptHG0gbvzt6UyqlbhP67o9+x4doGE0Wl79LzS/x47EdThyFJUir7YMIohIgFagCpOvQhhLgshHASQlQSQrgJIV4LIUKEEE2EECX//m/oh6+UaO65uSy4sIBWG1qh1qg//AIzdS/0HnVW1NFZd/fW4GqDOdX/FMVyFDNBZGnbkOpD6FhWd0Ps38/+zp7be4waR5YMWVjYciEAHoc9eBz+2Kj9S5JkfBqhoc/2PgRGBOJcwJlZTZP9LNTsrfBbQd0VdXkU/kinPU/mPBzpc4RRtUa9c0plQHBAsou7BEUF6SwtSI/sbe0TiwHZ6hYD6rejH6cenzJRVP+IjIvEZZULU45O0dtPU5Kk9CW5K5V3koItLYzt3wvG5zSfk2an+W2/uZ3qS6rr7Rdoa2XLarfVLG6zmIxWKdrR5LOlKApL2yzVWzfYd0dfnkY8fcerUkeb0m1wL+dOVEIUw/cMT9dPzSVJgl9O/8KeO3vIkTEHm9w3YW1pbeqQUixOFceQXUMYsHMAceo4nWP1CtXj0uBL1CtU773XCIkOSfYafCsLK0Jjkv0MOc0qYV+CbV22YWNpo22LV8fjtsmNe6H3TBhZ4gPP/zn/D4AJByfIzy5JSseSmzDuAzooirJVUZT+iqK0UhSl5b//pGaQH2vgzoHEqGLoWaknrUu1NnU4Hy1BncC4/eNov6k94XG6s35L2pfk3MBz9K7c20TRpR85bHOwseNGLJV/HigERwfTc1tPo49Kz20+l2wZsrHnzh623Nhi1L4lSTKeU49PMenQJADWtF+TLopdBYYHUn9lfZZcWqJ3bFTNURzufThZlbtz2uVEpVElq0+VRoW9rf1Hx5oW1S9cn+Vtl+u0BUcH02pDK17HvDZRVIm+qv0V9rb2nHh8gr/u/mXSWCRJSj3JTRjXAXmBDsAyYBew+19/dqVKdJ8gKCqIY4+OkStTLuY0m2PqcD7as8hnNFnThF/O/KJ3zL2cO76DfamYu6IJIkuf6hSsw9RGU3Xajj48qt2301jyZsnLT01/AmDU3lFExkUatX9JkozDztqOwtkLM67OuDT5QPO/Dj84TLUl1bjw7IJOu62VLes7rMezhWeyR1DLOpTFwc4hWec6ZnKkrEPZj443repZqSffuXyn03Yr5BYdN3ckXh1voqggW8ZsTKqX+ABk4qGJaITGZLFIkpR6klUlVVGUwh86Rwjx6EPnGINlAUuhGaRha6etdCzX8cMvMCNHHhyhq3dXXkW90mm3srDiF9df3rv2Q/p0ao2aZuuacejBIW2bhWLB0T5Hjbpvp0Zo6Lq1K53Ld6Zj2Y7yZy1J6VR4bDh21nZpeiqqEIKfT/+cZJJQPEdxfLr4fFIhH1kl9d2EEPTc1lOv6E3/Kv1Z1naZyT4zYhJiKDW/FE8inrChwwa6VexmkjgkSdJlsm010gKL/Bai45yObOmUdqb1aYSGWSdnMfnIZL0P3gJZC7DZfTO1C9Y2UXSfh+eRz6m8qDJB0UHatoJZC3J56OXPZtqTJEmp51bwLUo7vHcb4TQjIi6Cfjv64RPgo3esdanWrG2/luwZs3/SteU+jO8Xq4ql6ZqmnArULXozs8lMJtSb8N7XCiEICA4gJDqEnHY5KetQ1mDfw2WXljFo1yAq5KrA1aFXP8ufjSSZG1Puw2gFFAL0Kq0IIW4YIqCUqlClgjh08hC5M+c2dSjJEhoTSu9tvdlzR786p2sxV9Z3WI9jJkcTRPb5+evuX7RY30Knza2MGz6dfUzy4Xf91XVK2Jcw+t6QkiQZ1olHJ2i0uhGDqw9mQcsFafpmOiAogPab2nMrRHfLKgWFqY2mMqn+JCyU5K52SZoQgmWXljHjxAyCooOwsrBCpVHhaOeIRwMPBlQdkKa/hykVHB2M8zJn7r3WLXqzpdMW3Mu5653/9vs5/cR0gqODtd9PBzsHPOp7MLDawBR/P1UaFd8f/Z5hTsPInzV/iq4lSZJhGD1hVBTFGpgL9AGSvHsVQphFKVInJyfh6+tr6jCSxfeZL522dOJh2EOddgWFKS5TmNxgcpqt8JpWjds/Tm/96PwW8xlRc4RR41hwfgFj9o1hUr1J/NDoB6P2LUmS4QRFBVFlcRWeRT5jfN3xaXoLjS3Xt9B/Z3/exL/Rac+RMQcbOm6geYnmBu3v7YhYaEwo9rb2Bh0RS+tuBd/CebkzYbFh2raMVhk52ucotQrU0rbJEVtJ+nwZMmFM7mPAKUBrYACgACOBfsAh4CHQxhDBfC6EECzyXUTdFXX1ksWctjnZ22Mv3zf8XiaLJjC9yXRq5Kuh0/bV/q+48uKKUeOolLsSKo2KmSdnciPILAbvJUn6SBqhode2XjyLfEbdgnWZ1niaqUP6JCqNinH7x9F5a2e9ZLFqnqpcHHzR4MkiJG5/VM6xHPUK1aOcYzmZ0PxLaYfS+HT20dmGJFYVS1uvtjr3FcsuLXtnsggQnRCNd4A3y/2WJ3n8U6g1avxf+RvsepIkmV5yE8bOwPfA5r+/Pi+EWCOE+AI4CbRLhdjSpaj4KHpt68WwPcP0KpvVyl8LvyF+NCvRzETRSTaWNmzsuJEsNlm0bXHqOLps7UJUfJTR4qhfuD6Dqw0mQZPA4F2DZeU5SUqDZp2cxb57+3Cwc8DL3SvZewyak1dRr3Bd65pk5e6+Vfpyqv8piuYoaoLIpEZFG7Gkte5WJq+iXtF6Q2vCY8MRQjD9xPT3FhCCxKRx+onpBtlHMTQmlEqLKlF/ZX2Tb/khSZLhJDdhLAjcFkKogVggx7+OrQfSVjlSE3nw+gG1l9dm/bX1esdG1RzF8X7HKZitoAkik/6tuH1xlrTR/RC+FXKLUXtHGTWOn1x/Ik/mPJwKPMXSi0uN2rckSSlz7OExJh+ZDMDa9mspkLWAiSP6eGefnKXa4mocfXhUp93awpo/Wv3BirYrsLW2NU1wEgD9qvZjYr2JOm3Xg67TeWtnrr68SnB0cLKuExQVREBwQIrjsbe1J0/mPITFhjH71OwUX0+SJPOQ3ITxOfC25NkDoMG/jhU3aETp1KH7h3Ba6sS1V9d02jPbZGaT+yY8W3hiY2ljouik/+paoSv9q/TXaVtxeYVeOfPUlD1jdua1mAfANwe/4VnkM6P1LUnSpxNCMOXoFDRCw8R6E1NlumZqertsosHKBjyNfKpzLH+W/Jzod4KhTkPlFFEzMa3xNDqV66TTtv/efqYcmYKlkrylLVYWVoTGhBoknplNEvcx9jznyfPI5wa5piRJppXchPEo8HZDuqXAJEVRNiiKshL4FdiRCrGlC0IIPM960mxdM7034/KO5bkw6AKdy3c2UXTS+8xtMZcyDmV02obuHsq90HvveIXhdSzbkTal2hARF8G4A+OM1q8kSZ9OURR2ddvFDw1/YGqjqaYO56PEJMTQb0c/hu0ZRoImQedYwyINuTTkkk5RFcn0LBQLVrutplZ+3Z/Lzts7iVXFJusaKo3KYFtI1cxfkw5lOxCjiuHH4z8a5JqSJJlWcquk5gEchBD+f3/9P8AdsAUOAFOFEMZb4PUe5lQlNVYVy9DdQ1l9ZbXesU7lOrGy3Uoy2WQyQWRScl19eZWaS2sSp47Ttjnlc+JU/1NGGxEODA9k7P6x/OL6C4WzFzZKn5IkfbyXb15iZ21HlgxZPnyyGXrw+gEdN3fE74Wf3rFxdcYxo8mMNLkO83Px8s1LnJc76xXTS44i2Ytwf9R9g40aBwQFUOGPClgoFgSMCKCEfQmDXFeSpOQzepVUIcSLt8ni31//LoSoK4SoJoQYby7Jojl5GvEUl1UuesmigsL0xtPZ5L5JJotpQKXclfit2W86bb7PfJl0aJLRYiiYrSBbOm2RyaIkmbHjj45TdXFVBu4aaJDiIca27+4+qi+prpcsZrbJzJZOW5jtOlsmi2Yud+bc7Om+h6wZsn7U6+ys7fCo72HQKcZlHcvSt3JfVBoVU45MMdh1JUkyjZTtrisl6XTgaZyWOnH+6Xmd9qwZsrKz607cyrhx8vFJbgTdSJM3Fp+bYU7DaF+mvU7br2d+Ze+dvUaPRSM0nHx80uj9SpKUNCEEP5/6mcarG/P8zXOeRz4nKiHtPEPVCA3Tjk+jxfoWvI7VrWpZOmdpzg88n+Rm8JJ5KudYjq2dtuqtXVRIOhl8uw/jgKoDDB7Ldw2/o3C2wtQvVP/DJ0uSZNbeOSVVUZQLQLKzGSFETUMFlRKmnpK67NIyhu8Zrrf2o1TOUvSo2IMVfisIjg7GysIKlUaFg50DHvU9GFhtoCwgYMZCY0KpsqgKgRGB2jYHOweuDL1Cviz5jBKDWqOmyZomHH90nNMDTuNcwNko/UqSlLSw2DD67ejH9pvbARhfdzzTGk9LMyNxYbFh9NrWi923d+sd61C2Ayvbrfzo0SrJPCy5uIQhu4fotFlbWCf+sbRGpVHhaOeIRwMPBlQdkGr3H2qNWu4pLUkmYsgpqe9LGFehmzAqQG9gNxDy3/OFEP0MEVBKmSphTFAnMOavMSz0Xah3rGWJlmTJkIVdt3cluR/S2yd8q91Wy6TRjJ16fAqXVS6ohVrb1rhoY/b33G+0D8SJBycy69QsKuSqwKXBl7C2tDZKv5Ik6fJ77of7Fnfuv75PtgzZWNN+DW1LtzV1WMl27eU12m9qz73XukW8LBQLZjaZybg64+TnURo3bv84vf0zXQq78H3D78mVKRdlHcoa9WcshJC/U5JkREZZwyiE6CuE6Pf2DzDw70Pf/7v9X8c/W6+iXtF0bdMkk8VJ9SbRtnTbdyaLkLhprneAN8v9lqd2qFIK1C1Ul+8bfq/TdvjBYX469ZPRYpjiMoXiOYrj/8qfn0//bLR+JUnStdxvOfdf36da3mpcGnIpzSSLQgiWXFxCrWW19JJFBzsH9vfczzd1v5E39unArKazcCvjptN27NExfAJ8KOdYzmg/46j4KH44+gMtN7SUy3AkKY1KVpVUAEVRLIEEwEkIcSlVo0oBY48wXnp+ifab2vM4/LFOu521HSvbraRTuU4U9SzKo/BHH7yWoauUSYan1qhxXevKkYdHtG2WiiXH+x2nTsE6Ronh4P2DuK51JYNlBq4Nu0bJnCWN0q8kSf+IVcXy6+lf+arOV2S0ymjqcJLldcxrBu8ezNYbW/WO1chXg62dt1IoWyETRCallqj4KFxWuXDx+UWd9rnN5/JlrS+NEkNkXCTF5hYjODqYnV130qZ0G6P0K0mfO6NXSZWStvHaRuqtqKeXLBbOVpjT/U/TuXxnAoIDCI4OTtb1gqKCCAgOSI1QJQOxtLBkXYd1ONg5aNvUQk037268jnn9nlcaTtNiTelduTdx6jiG7B4in9hKkhHcCblDx80diYiLACCjVUY8GnikmWTx1ONTVFlcJclkcUj1IZzod0Imi+lQJptM7Oq2iwJZC+i0j9k3hl23dhklhiwZsvBt/W8BmHR4EmqN+gOvkCQpJZ5HPmf03tEGvaZMGD+BWqNm/IHxdPfpTowqRudYoyKN8B3sS+U8lQEIiQ5JdgEEKwsrQmNCDR6vZFj5suRjtZvudimPwx8btZz+r1/8ioOdA0ceHsE7wNsofUrS58r7hjfVl1THJ8CH7458Z+pwPopao2ba8Wm4rHLRe7iZyToTq91Ws6j1IjJYZTBRhFJqy5slL3u67yGzTWZtm0Zo6OrdFd9nxpmRNdRpKIWyFcL/lT8b/TcapU9J+hztvbOXCn9UYO75uQa97qckjJ/1cMbrmNe03tia2adn6x0bVXMU+3ru0xl9ymmXE5VGlaxrqzQq7G3tDRarlHpalmzJWOexOm0+AT4s8l1klP4d7ByY12IeP7v+rLdGRZIkw0hQJzB231jct7gTGR+Jezl3fmj0g6nDSrYnEU9osqYJk49M1inWBVAtbzX8hvjRu3JvE0UnGVOl3JXY7L5ZZ7uN6IRoWm9ozcOwh6nefwarDPzQMPHfzuQjk4lXx6d6n5L0Ocphm4Ow2DC+KP6FQa/7viqpQegnhw5AGKCXAQkhchk0sk+UmmsYbwTdoJ1XO+6G3tVpt7G0YVGrRfSrql/7Rwgh1zCmU/HqeOosr6OzNiSDZQbODzpPpdyVTBiZJEkp9STiCV22duF04GmsLKz4xfUXRtUalWben3fc3EH/nf2TnLUy1nksM5rMkKOKn6HFvosZumeoTltZh7Kc6n+KHLY5UrVvtUZNpUWVuBF0g3kt5jGy5shU7U+SPhd3Qu7o1LM49+QcNfPXxMLCwihrGBck8ecHwPMdx9K1HTd34LzMWS9ZzJs5L8f7Hk8yWQRQFAWP+h7YWdu99/p21nZ41PdIMzcjUuKDAi93L51pPnHqOLpu7UpUvHE37n7x5gUXn1388ImSJH3Qyzcvqba4GqcDT5M/S36O9T3GaOfRaeL9OVYVy5d/fonbJje9ZNHRzpE/u//Jr81+lcniZ2qI0xDG1x2v0xYQHED7Te2JU8Wlat+WFpZMbzwdgKMPj6ZqX5L0OYhVxfL1/q8pPb80e27v0bbXKlDL4J9Xya6SmlYYeoRRIzRMOz6N747qr1txLuCMd2fvD27cLoSgz/Y+eAd4y30Y06EN1zbQw6eHTtvAqgNZ2napUfq/+vIqLqtcyJ4xO/7D/Mlkk8ko/UpSejZs9zDuvb7H+g7rcczkaOpwkiUgKICu3l25+vKq3rGmxZqytv1a8mTOY4LIJHOiERp6+PTAy99Lp71HxR6sbb82Ve9DhBAcf3ScBoUbyPsdSUqByy8u02tbL/xf+WOpWPKz68/8r/b/dM4xZJVUmTC+R2RcJH139MUnwEfvWP8q/VnYamGyn9IKIVh2aRkzTswgKDoIKwsrVBoVjnaOeDTwYEDVAfLNMw3rt6Mfqy6v0mnz6uhFlwpdUr1vlUZFjaU1uPziMl/X/pqfv5D7M0rSxwqJDiE4OpjSDqWBxCnnloollhaWH3il6QkhWO63nFF7R+kVYrOysGJ64+l8XedrLBRZ505KFKuKxXWtKycfn9Rp96jvwbTG00wUlSRJH6LWqPnl9C9MPjKZBE0CJe1Lsq7DOmrmr6l3rkwY38NQCeO90Hu082rH9aDrOu2WiiVzms9hRI0Rn5TgCSEICA4gNCYUe1t7yjqUlYliOvAm/g1OS5y4FXJL25Y1Q1b8hvhRLEexVO//wtMLOC93Tvz/QReolrdaqvcpSenF+afncd/sTgarDPgO8iVbxmymDinZwmLDGLxrMFtubNE7VixHMTZ23JjkjYQkhUSHUGdFHW6H3NZpX9pmKQOrDUz1/m8E3eDis4v0qtwr1fuSpPTgacRTunp31T7oGe40nNmus985s0zuw5jKDtw7QI2lNfSSRQc7Bw72PsjImiM/OclTFIVyjuWoV6ge5RzLyWQxnchskxkvdy9sLG20bRFxEXTz7maUanA18tdgVM1RaISGwbsGJ7syryR9zoQQLDi/gHor6hEYEUhO25xEJRh3/XFKnA48TZVFVZJMFrtV6IbfEL93JotCCG4E3eDEoxPcCLoh93P9DOW0y8neHntxtNOdcj1091D23d2Xqn0HhgdS6Y9KDNo1iCcRT1K1L0lKLzLZZOJh2EPyZM7Dn93/ZEGrBUZbhiQTxn8RQvDbmd9ovr45r2N1N2GvkqcKvoN8aVikoWmCk8xelTxV+PWLX3Xazj89z7eHvzVK/z82/pFC2Qpx8flF5p2bZ5Q+JSmtehP/hu4+3Rm5dyQJmgRG1RzF8X7HP7gm3RyoNWqmH59Og5UN9CpwZ7LOxKp2q1jfYT1ZM2TVe60QgqUXl1LUsyg1l9akzcY21Fxak6KeRVl6calMHD8zxXIUY1e3Xdha2Wrb1EKN+xZ3rry4kmr9FsxWkI7lOhKnjmPqsamp1o8kpXVBUUHEqmIByJ4xOzu77sR/mD8tSrYwahxySurfYhJiGLx7MOuurtM71qV8F1a0W/HBSqeSJISg/ab27Li1Q6f9rx5/0axEs1Tvf8/tPbTe2JosNlkI/F9gmppaJ0nGciPoBh03d+Rm8E0y22RmWZtlRllvbAhPI57Sa1svjjw8onesap6qbOy4UbsO879kATbpXbbf3E6HTR0Q/9pNLX+W/JwdeJYCWQukSp+3Q25TbkE5AK4Pv/7O31tJ+lztvr2bATsH0KNiD35r9ttHvz7dTklVFMVSURQ/RVF2//11UUVRzimKckdRlE2Koth86BqfIjA8kPor6+sliwoKs5rMYmPHjTJZlJJFURRWtFuh9wHbe3tvXrx5ker9tyrVikn1JnGg1wGZLErSO1x9eZWbwTcp71ieC4MupJlkcdetXVReVDnJZPF/zv/jzIAz773pXnZp2TuTRUjcyN07wJvlfssNFrOUNriVceP3Zr/rtD2NfEqrDa2IiItIlT5L5SxF/6r9UQs1k49MTpU+JCktehP/hiG7htBmYxteRb3i8ovLJKgTTBqTWY0wKooyFnACsgohWiuKshnwEUJ4KYqyCLgihPjjfdf42BHGk49P0nFzR15FvdJpz5YhGxs7bjT6kK+UPpx4dIKGqxuiERptW9NiTdnXc5+sVChJJiCE0Bk1W3tlLR3KdkgT29DEqmL55sA3zDuvP9Xcwc6B1W6raVmy5XuvIYSgqGdRvSmsSSmSvQj3R92Xo4yfoTF/jcHznKdOm2sxV/Z034O1pbXB+3sS8YSS80oSq4rlwqALOOUzyGCIJKVZpwNP03tbb+69voeNpQ0zm8xkjPOYT7p3TJcjjIqiFABaAcv+/loBGgNb/z5lNeBmyD4X+y6m8erGesliGYcynB90XiaL0ierX7g+37no7t158P5BZp+abdQ49t/br7d5tyR9bh6GPcRllQt+z/20bb0q90oTyeLN4Js4L3NOMllsUrQJV4de/WCyCImbswdHByerz6CoIAKCAz46Vint+/WLX2lfpr1O24H7Bxi6e2iqrG8tkLUAX9b8EoApR6YY/PqSlFaoNWq+Pfwt9VfW597re1TOXRnfQb6MrT3WLAYaTB/BP+YA3wBvh2RyAmFCiLflHp8A+Q3RUbw6nqG7hzJ0z1ASNLpDvG1KteHcwHOUylnKEF1JnzGP+h64FHbRafv28Lf8eedPo/Q/6+Qsmq1rxjcHvjFKf5Jkjvbc3kO1xdU48fgE4w6MM3U4ySaEYPml5VRfUp0rL3WLj1gqlsxsMpP9vfaTN0veZF0vJDoEKwurZJ1rZWElHzR9piwtLFnXYR218tfSaV9xeQXTT0xPlT4n1JvAwKoDmd9yfqpcX5LSAgvFQluxenzd8ZwbeI6KuSuaOiwts0gYFUVpDbwSQlz8d3MSpyb5eEtRlMGKovgqiuIbFBT03r5evnlJkzVNWHxxsd6xyQ0ms73r9iQry0nSx7K0sGR9h/XktM2pbVMLNW5ebmy5rl8G39DcyrhhY2nDcr/lHH14NNX7kyRz8vZpbeuNrXkd+5rWpVqzudNmU4eVLGGxYXTz7sbAXQP11hsWyV6Ek/1PMqHehI966pzTLmeyt9tRaVTY29p/VMyfm9CYUA7dP8Qvp3+hu3d3yi4oS8l5JfHy9zJ1aClmZ23Hzm479fYQnnxkcpKFAVPK3taepW2XGmXPYkkyJxqh0c78UBSFxa0Xc6zvMWY1nUUGqwwmjk5X8h43pr66QFtFUVoCGYGsJI44ZlcUxervUcYCwLOkXiyEWAIsgcQ1jO/qxPeZL+03tdfb8yeTdSZWu62mY7mOBvnLTJE+GQAAIABJREFUSNJb+bPmZ5XbKtpsbKNtS9Ak0NW7K5HxkfSv2j/V+i7jUAaP+h58d/Q7huwewpWhV8holTHV+pMkc/HyzUu6+3Tn8IPDWCgWTG88nW/qfmMW03o+5EzgGbr7dOdh2EO9Y13Kd2Fx68WfVNCqrENZHOwciAr/8D6TjpkcKetQ9qP7SI+EEARFB5ErUy5tW+VFlbn68mqS54fFhhkrtFSVK1Mu/uz+J3VW1NEZbe6/oz/5s+SnUdFGqdKvRmh48eZFmtjeRpJSIjA8kL47+hIeG86ZAWewtrTGMZMjjpkcP/xiEzCLhFEIMRGYCKAoSkPgayFED0VRtgDugBfQB9jxzot8wPqr6xm4a6B2L5O3imYvyo6uO8xq2NdcqTQq4tXxqDQq1Bo1aqHW/r+iKDpv8DeCbhCvjtc7T6VRUSxHMQpnLwwklog/9/RckuephZo+lfton7Jsvr6ZB68f6J0HiaNpNfLXMP435QOEEDyPfI59RntCY//50NUIDQN2DiAiLoIxzmNSrf8J9Saw6fombgTdYMaJGUxtJPe7ktI3lUaFyyoXboXcInem3Hi5e6WJ/XPVGjWzT81m8pHJqIVa55idtR3zW8ynb5W+n1yIRlEUPOp7MGbfmHdWSX3bl0d9j8+y4I1GaLgXeo9Lzy/h98IPvxd+XHp+iYi4CN5MfKMt+pI9Y3bsrO2onLsyVfNUpWreqlTLW43A8EBal2qtvd6xh8dwyueUJtbKJqW0Q2m2d9lO07VNiVfHA4kPPNtvas/pAacp51jOoP09CntEh80diEmI4dqwa1haWBr0+pJkDoQQbPTfyPA9wwmPC8fBzoHbIbcpn6u8qUN7L7Oqkgo6CWNrRVGKkZgs2gN+QE8hRNz7Xv/fKqkqjYoJByfw65lf9c5tUrQJm9w3kdMup96xz5UQAt9nvmz038jWG1tZ0W4FTYs1BWD8gfHMPp100ZYi2YvwYPQD7dc5fsrxzietM5vMZEK9CQBsub6Fzls7vzOekG9CtFOjXNe6cvD+wSTPq5CrApeHXDarD5gP7Xn21g8Nf2Byg8mpdoN26vEp6q2sh7WFNX5D/Mz+TUmSUmqT/yYW+i7Eq6NXstf4mdKzyGf02taLww8O6x2rkqcKXh29DLJHndyH8R8J6gSiEqLInjE7APvu7qPTlk5ExkfqnZsjYw4uDLpAcfviQGJRIHtb+/d+3gSGB1J2QVnsbe2Z22Iu7Uq3S7Pf003+m+jq3VWnrXC2wpwdeJY8mfMYrJ94dTxl5pfhQdgDVrZbSd8qfQ12bUkyB6ExoQzfM5xN1zcB0LpUa5a1WUbuzLlTpT9DVkk1ixHGfxNCHAWO/v3/94Gan3qt0JhQum7tyoH7B/SO/c/5f8x2nZ3sIgDpnf8rf7z8vfDy9+Le63va9n+veclglQFbK1ssLSyxVCyxsrDC0iLxv7kz6f6yl3csT2R8pM55b///33sUFshaALcybkmeZ6lYYm3xTxnvzuU6UzVPVe2xt+ffCb3D+LrjzSpZhA/vefbWd0e/IyIugp9df06VG4q6heoytPpQFl1cxJSjU/Du7G3wPiTJlMJiwzj35BzNSjQDoEuFLnQq3ylNTEHdfXs3fbf3JSQmRO/Y6Fqj+anpTwZby6IoCqvdVlO/UH1mnJhBUHQQVhZWqDQqHO0c8WjgwYCqA9JsYvMu0QnRXH15Fb/nftrRQ/9X/gyoOoAFrRYAUDBbQSLjI8mXJR9V8ySOGL4dPSycrbDO9yQ5U8bexL+hjEMZLj6/SPtN7WlVshXzWsyjaI6iqfb3TC1dKnThYdhDJhyaoG17FP6I1htac7TvUTLbZDZIPzaWNkxtNJVe23rx3dHv6Fqhq1xGIaUbB+4doO+OvjyLfEYm60zMaT4nTb3fmt0IY0q9HWH0f+VPO6923H99X+d4BssMLGmzhN6Ve5soQvOiERpqLauF77N/RmXzZM5D53Kd6VaxGzXy1TC7ROxDph+fTpcKXShhX8JkMXzMnmdvDao2iD9a/ZEq3+/w2HBmnJjBpPqTPmn9kySZq8svLuO+2Z3AiEBO9z9N9XzVTR1SssSp4hh/cLzenncAOW1zssptlc70RkMTQhAQHEBoTCj2tvaUdSibZm5c3ud1zGuyZsiqfR/t6dOTjf4bdfbEfatTuU7aQkhqjZrg6GCDPulXa9Qs8l3EpMOTiIiLIKNVRr6t/y1f1/na7ApafIgQgmF7hukVDGxdqjXbumwz2MN3tUZN1cVVufbqGr83+z1Vl2xIkjEtOL+AkXtHUrtAbda2X6udsZCaDDnCmC4TRo+1HvTa1ouoBN3F/fmz5Gdbl21mudbNWJ5FPsP7hjdDnYZq12N02NSBow+P4l7Ona4VuuJS2CXNJYlvbbi2gR4+PciWIRvrOqxL1Ruu97kRdIOaS2vq/Q5+SNcKXVnjtiZVNkiWpPRm+aXljPhzBHHqOKrkqcLWTluN8iGcUreCb9HVuyuXX1zWO9aoSCPWdVgni358gBCC52+e4/f8n7WGfi/8eBj2kGvDrlEhVwUAvvzzS/7w/YNyjuUS1xrmqUbVvFWpkqeK0Sqiv3jzgq/2f8WGaxsA6FWpF2varzFK34ak0qho59VOb2uo4U7Dmd9yvsEeOOy+vZs2G9tgY2nDdy7fMa7OOPmZKKVJ4bHh2of0Qgg2XNtAlwpdjDa7USaM75GvdD7xvPtzvfY6Bevg3dnboPPt04rg6GC8b3jjdd2LYw+PIRD82f1PWpRsASR+mNnb2mNjaWPiSFMuPDacvjv6sv3mdiBxq5TvXL4zegJ84tEJ2mxsQ3hc+Ee/tnWp1mx234yttW0qRJY4PWvrja1ylF1Ks6ITohn550hWXl4JJI7Oezb3TLV/M4YihGDV5VWM3DtSb6q6pWLJ1EZTzXJ6valphIbw2HBy2OYAEouj1FpWi5dRL/XOzWiVka2dttKqVCsgcf9JO2s7s/jdOPzgMKP2jmJDxw1Uyl3J1OF8kjfxb2iwsgF+L/x02n92/Zmv63xtkD6EEHy590sWXFiAjaUNV4deNcgaXkkyFpVGxYwTM5hzdg4XB1802VR0mTC+h5JPEQzRbRtUbRDzWsxLc1NAUkKtUbPh2gY2+m/kwP0D2rWIGSwz0LJkS76p+w3OBZxNHGXq0AgNP538iW+PfItGaGheojnrO6w36r5iHzPCqKAg/rPFaKMijdjRdQdZMmQxaFwaoaH6kupcfnEZn84+tC/b3qDXl6TUdi/0Hh02d+Dqy6vYWtnyR6s/6FOlj6nD+qDw2HCG7hma5D59hbMVZmPHjdQuWNsEkZmn0JhQ9tzew/Zb2zl0/xCVclfieL/jQOLNWJaZWchgmYGqeasmrjX8e71hGYcyZl2bQCM02rW1Qgh6b+9Nrfy1GOY0LM08KHgW+QznZc4ERgTqtG9230yn8p0M1s/B+we5E3KHYTWGAYnfrzh1nFzXKJm1OyF36LWtF+eengNgYcuF2t9hY5MJ43v8O2G0srBiXot5DHUaatqgjCReHa8dJRRCUGp+Ke6G3sVSscS1uCtdy3fFrYzbZ7OG7cC9A3Tz7kZITAhFsxdlX899lMxZ0ih9f8waxvxZ8pPRKqNOsSGAmvlrsrfHXoMnuvPPz+fLvV+SL0s+bgy/8dn8Pkjpw+2Q2zgtcSJP5jxs7bw1TYzUnHtyjm7e3XgQ9kDvWOfynVncerG2Wufn7EnEE7xveLPj1g6OPzqus71IqZyluDnipnba49OIp+TLki9Nr7t8W8EaoHre6vzR6o80s2TG/5U/dVfUJSIuQtuWwTIDh3ofom6huqnS58ZrG5lydApL2yxNE1vlSJ8XIQSLLy7mq/1fEZ0QTYGsBVjVbhVNijUxWUwyYXyPtwmjo50jWztvpUHhBqYOKVUlqBM4cP8AXv5e7Li1A/9h/hTMVhCAVZdXEauKpWPZjma7EWhqexT2iI6bOxKjiuHcwHMGq+aWHEsvLk3WnmeezT1pVbIVrmtduR50Xed4xVwV2d9rv0GnUqs1auquqMu5p+cY7jRcWyVQksxRRFwEa66soU/lPtoR91OPT1Exd0WjrUH7VBqh0e6t+O+K0wC2VrbMazGP/lX7p+mkJyWEEMSoYrCztgNgycUlDNmd+MTXysKKhkUa0q50O9qUaqPduzc9EUKw49YORu0dRWBEIAoKQ52GMr3xdO30W3N26P4hmq9vrvO7ndM2J2cGnDH4w1khBE3WNOHIwyMADK42mNmus+UDT8ksPI98zoCdA9h7dy8APSr2YH7L+SZ/ECgTxvdQ8imi2vfV2NZlG4WyFTJ1OKlCrVFz/NFxvPy92BqwldCYfzaEl3sX6YtVxRIUFaRNpGNVsVgoFqm+ZvNj9zwLiQ6hxfoWXHh2Qee8EvYlONjroEFvmK6+vEr1JdVRa9Sc7H+SOgXrGOzakmQI119dZ8GFBay5soaohCgWtFzA8BrDTR1Wsj2PfE6vbb049OCQ3rFKuSvh1dGLso5lTRCZaSWoEzj+6Djbb25nx60ddCjbgTnN5wCJ37PRf43GrYwbLUu2NPnNlrFExUcx9dhUfjv7GyqNilyZcvF7s9/pXrG7qUP7oNWXV9N3R1+dtuI5inNmwBmDP6iOV8cz6+Qsph2fRoImgXxZ8rGw5ULalWln0H4k6WNdeXGFGktrkNkmM4taL6Jz+XfvL25MMmF8j5wlcorAgEDtE8v0JkGdQKn5pXgY9lDbVs6xHN0qdKNrha4m3UoiLRBC0G9HP26H3GZLpy3kz5o/1ftbdmlZsvc8i4iLoO3Gthx7dEznOgWzFuRArwMGXfg/6dAkZp6cSXnH8lwacildFD2S0rYEdQLbb25nwYUFOv8GXAq74FHfA9firiaMLvn+vPMnfbb3ITg6WO/YlzW/ZLbr7M9qHVZkXCR/3f2LHbd2sOfOHsJiw7THnAs4c2bAGRNGZz78X/kzfM9wTjw+wfi645nVdJapQ0qWH47+wPfHvtdpcy7gzOHeh1Ol2ND1V9cZuGsgZ5+cBRK3R1ncenGaGJWV0o/ohGidXGPrja3ULlA71e8rP4ZMGN/j7T6M6cW1l9fwCfDBo4GHdiF/O692XHt5TZskVsxd0cRRph2vol7htMSJwIhAcmXKxWb3zbgUcUn1fj9mz7OYhBjct7jrlS53tHNkf6/9VMlTxSAxxSTEUGlRJe6G3mVDhw10q9jNINeVpE/VflN7bYXjTNaZ6F25N8NrDNdukWDuAsMD+fH4jyy9tFTvWE7bnKxst5I2pduYIDLjE0Jo3+PG/DVGZ7/Jco7laFe6HW5l3HDK56QtAiMlft82+m+kXel2ZLLJBCSOXpSwL6H92twIIei/sz+rLq/Sae9YtiObO21OlZ+vWqNmwYUFTDw0kQJZC3B5yGWzqIQrfR6OPTxG7+29md10Nl0qdDF1OO8kE8b3KFOpjPA55JOmNyG+G3oXL38vvPy9tGva9vXcxxfFvwAgLDaMbBmypdm/n6kFRQXR1bsrhx8cxlKx5GfXnxnjPMasvp/x6nh6bevF5uubddqzZcjG3h57DVZN8fij47yKekXHsh3N6u8vpX9CCE4FniJv5rzavRPXX13Pj8d/ZESNEfSu3DvNrE96FvmMmSdmsuTSEuLV8XrHGxZpyLr268zqyXNquBl8UzvVdEDVAQysNhCAow+P8u3hb2lXuh3tyrSjVM5SJo407YiIi6DsgrJYWVgxt/lcs51+Ga+Op+X6lnpTsMc6j+XXZr+mWr8Pwx7yOuY1VfNWBRLvj8JiwyiSvUiq9Sl9vq6/us7s07NZe2UtAsEXxb/grx5/me39k0wY38OqgJXIODwjDnYOeNT3YGC1gWb7g/y3eHU888/Px8vfS2cNm72tPe5l3RlVaxTlc5U3YYTpi0qjwuOQB7NPzwagS/kuLGu7zKhFcT5ErVEzZPcQlvst12nPZJ2J7V2307RYUxNFJkmfLio+ig3XNjD/wnyuvrzKkOpDWNR6EZD4O2+hWKSJ92xI3MN21slZLPJdRJw6Tu+4pWLJDw1/YEK9CWlmy4SPodaoOff0nDZJvB1yW3usbem27Oi6w4TRpQ/3Qu/RaUsn7b6HbUq1YW6LuWaZEIXHhlNvZT38X/nrtM9rMY+RNUcaJYZBOwex0X8j0xtPZ2TNkeny351kXEIITj4+yezTs9l9ezeQ+N7uUd+Dbxt8i7WltYkjfDeZML7Hv7fV+G9REXMTERehrfInhKD43OI8CHtAZpvMuJVxo1uFbjQt1lSuLUtF3je86bujL2/i3zCh7gRmNp1p6pB0CCH4av9X/H72d512G0sbNrtvNujT5msvr/Eo/BGtS7U22DUl6a07IXdYeGEhKy+vJDwuHEicZj261mg8GniYOLqP8yrqFbNPzWbhhYXEqGKSPKd4juKsab8mXReUct/sjneAt/Zre1t7WpdqjVtpN74o/oXZTqFMa1QaFQsvLOTbw98SGR+JrZUtU1ymMLb2WLO7PwgMD6TWslo8f/Nc22ahWLCtyzbalm6bqn2rNWp6+PRg0/VNANTKX4vlbZfLh+1Siuy5vYfWGxPvi2ytbOlftT9f1f6KojmKmjiyD5MJ43v8O2GEf7YteDs1xtQ0QoNPgA/L/ZZz+MFh7o+6r52mtPHaRqwtrWlZsmW6Ldpjjm4G32TKkSmsbLfSLG9whBBMPTZVr6iApWLJarfV9KjUI8V9vK2amsUmCwEjAsidOXeKrylJb809N5fRf43Wfl27QG1G1BiBezl3MlhlMGFkHyc4OphfTv/CvPPz3rldTqFshZjcYDJ9Kvcx6yfPHyMkOoQ9d/aw49YOvqnzDbUK1AIS93T97cxv2qmm9QrV0661lwzveeRzxu4fi5e/FwCtSrZid/fdJo5Kn99zPxqsasCb+DfaNlsrW471PWaUfSZ33trJsD3DeBb5DGsLazzqezCx/kSzS64l8xSriuXis4va/UQT1Ak4L3emTak2jKgxIk1tUycTxvf4b8IIUCR7Ee6Pum/yUcZD9w8x/uB4Lj6/CCTe8G/utJkOZTuYNC5JV1R8FEsvLeXLml+a1XSW38/8ztj9Y3XaFBQWtlrIUKehKbq2EIIW61uw794+ulXoxoaOG1J0PenzFhIdwos3L7RP9v1f+VNzaU26VejGiJojqJa3mokj/DihMaH8duY3PM956twE/1uBrAXwqO9B/6r908WN6cOwh+y4uYPtt7Zz4tEJ1EINwLg645jtmjiVP0GdgJWFlck/Wz83B+4dYMSfI/Bs7kmLki1MHU6S9t7ZS5uNbbS/NwC5MuXi7ICzRhmZCY8NZ/zB8Sy+uBiACrkqcGbAGbNadiKZl7DYMBb5LsLznCdhsWE8HvNYmxz+u4hXWiITxvdIKmHMZJ2J84POU86xnEli8nvux4RDE9h/bz8AeTPnZWK9iXSr2A0HOweTxCS9W+9tvVl7dS2uxVzZ0HGDWf2Mll1axuBdgxHo/rud1WQW4+uNT9G1H7x+QIU/KhCdEE23Ct3oVakXrsVd5YiBlGy+z3y1a7Gr5q2qs13Cv6fgpxVhsWH8fuZ35pybQ0RcRJLn5M2cl0n1JzGw2sB0s1VGy/UttRtQA1hZWNGwSMPEkcTS7bR72kqmk6BO0BnB9jjkQf6s+RlSfYjZPOhccnEJQ3br3pCVcSjD6f6njbYFxrGHxxi4ayB1C9Zlldsqo/QppS1PI54y5+wcFl9cTGR8JACVc1dmtdtqKuepbOLoPo1Ko8InwIcuFbrIhPFdkkoYs2XIxu7uu6lXqJ5JYnr74ZstQzbG1x3PaOfRcsqpGTv84DBdtnYhODqYwtkK493Zm+r5qps6LK1N/pvoua0nKo1Kp31SvUlMazwtRU/BFvsuZuief0Yrc2XKhf8w/zQ1BUMyrlhVLJuvb2bBhQWcf3oeSBz5blGyBVs6bUmT73URcRF4nvXkt7O/6ewZ+G+5M+VmYr2JDK4+WKec/9stdEKiQ8hpl9OsK3YnqBM4/ug4229u57uG32kfjg3bPYz119bTomQL2pVuR8uSLcmeMbuJo5Xe5VbwLcotLIdGaHDK58Qfrf7AKZ9B7hFTbOLBicw6pbufpEthF/b13Ge06egxCTHEq+O1VZfPPz1PRFyELBz3mVNpVAzeNZh1V9eRoEkAoEnRJnxT9xtci7ma7fv2+4REh7D00lIWXFjAk4gn8D0yYXwXcxhhDIoKIjI+kmI5igGJeyitubKGSfUnkdMup1FikFImMDwQ9y3unH96ngyWGVjYaiH9q/Y3dVhae27vwX2LO7GqWJ32kTVG4tnCM0X7Xt0LvceGaxtYf209tta2+A3x0x7748IfNC3WlJI5S37y9aX049yTc7Te2Fq7QX2OjDnoX7U/w5yGabfKSEvexL9h3rl5/HLmF0JjQpM8x9HOkfF1xzOsxjCdZFgIwbJLy5h+YjrB0cFYWVih0qjMsmL3yzcvtU/UX8e+BmBVu1X0qdIHSLzpyGyTOU2tL/2cCSHwCfBh9F+jeRr5FAWF4TWGM63xNJMn+hqhoYdPD+26y7e6V+zO2vZrjb4HZ5wqjqqLqxIQHEC/Kv349YtfjTbaKZmfZuuacfD+QTqV68S4OuPManDgY9wIuoHnWU/WXl2rW4hNJozvZso1jG/i3/Dbmd/4+fTPOBdw5kCvA6nan5S64lRxjP5rtHYNxOBqg1nQaoHZTNE8+vAobTa20VtT1btyb5a3XZ7iOIUQhMaEah9y3A65Ten5pQGomb8mPSr2oEv5LrJAzmdEIzTcf32fEvYlAIiMiyT/b/kpYV+CkTVH0rVC1zQ5ohgVH8XCCwuZfXq2Nvn9L3tbe76p8w0jao7QWwclhKDP9j54B3gnWQzHXCp2Pwp7xM+nf2a533Ltw6ZyjuVoV7odvSr1oqxjWZPFJqVcZFwkPxz7gTln56AWanJnys2vX/xqkMJoKRGnisN1rSsnHp/QaZ9UbxLTm0w3aiwJ6gR+Of0LPxz7gTh1HLkz5WZBywV0LNfRqHFIxqURGnbe2snsU7P5rdlvOBdwBhL3VcxolTFNPuDUCA1/3f2LOWfncOD+O/INmTC+mymqpCaoE1h6aSlTj03lZdRLAFqWbMlm981mWXVT+jgr/VYybM8wulboysp2K81mlAASp9Y0X9dcO0rwVoeyHdjQYYNBRwhuh9xm+onp+AT4aJNUS8US1+Ku9KjYA/dy7ulmDZekKyw2jFWXV7HwwkKCo4N5MvaJNjF8HP6YglkLpvq/i9SY6hmdEM0i30X8dOonXkW9SvKcHBlz8HWdr/my5pdkyZAlyXOWXlzKmH1j3lk5FcyjYnft5bU5++QsAO1Kt2NivYnaiqdS+nHt5TWG7RnGqcBTdCnfBS93rw+/KJWFxoRSZ3kdboXc0mlf0noJg6oPMno8t4JvMXDXQE4+PglA+zLtWdByAXmz5DV6LFLqiVPFsfbqWn45/Yv2d69npZ6sbb/WxJF9ujfxb1h9eTVzz8/V2fv2v2ytbIn5NkYmjO9izH0YhRBsubEFj8Me3A29CySOvPzU9CcaFmlo8P4k07ny4gqlcpbSrlWKV8ebTSVE/1f+uK515cWbFzrtXxT/Ap/OPgZ/aBGdEM3OWztZf209f939C5VGRSbrTLz8+qW2r7RaUUzSdfXlVRacX8C6a+u0yVDBrAXZ3X03lXJXMkoMqTHVM1YVy5KLS5h5cqbev5u3smXIxtjaYxlda7R27dO74ivqWZRH4Y8+2K+xK3ZfeHoBx0yO2k3et9/cjneANxPqTpB706VzGqFh9eXVNCvRjHxZ8gGJhc1yZ85tslkA91/fx3mZM0HRQdo2S8WS3d1307xEc6PHoxEaFvsu5puD3/Am/g3FchTj1shbZjOLSPp0YbFhLPZdzJxzc7Tv8YWyFeKr2l/Rv2r/NFkt98HrB8w/P5/lfsu1exknpUDWAoyoMYIGhRtQt2TdWyJWlDFE/+kuYbQqYCUyDs+Io50jHg08GFB1QKp9OL9484JinsWIUcVQKmcpZjSeQYeyHeSNcjr3Jv4NdZbXoVelXnxd52uz+HnfDb1L0zVN9W5a6xasy57ue957w5sSwdHBbLm+hdCYUO3m67GqWCr9UYlmxZvRo1IPauWvZRbfIyn5wmLDaLOxjfbpOyQWAxhZcyStS7U22g2Voad6xqniWO63nBknZvA08mmS52SxycIY5zH8z/l/yVrbdCPoBjWX1iQqIeqD5xpjPb0QgqMPjzLj5AwO3j9I/yr9Wd5uear1J6UNKo2KGktrEBYbxrwW82hdqrVJ4jj/9DwNVzXUWWeV2SYzJ/qdoEqeKiaJKTA8kGF7htG5fGd6V+5tkhgkwxp/YDyzTydu/1MpdyW+qfMNnct3TnN74wohOP7oOJ7nPNlxawcaoXnnuXUK1mFUzVGExoTy06mfCI4OJmpelFo8Fwb5wE53CWOZSmWEzyGfVKtM5//KnzIOZbQ3TL+e/pXMNpnpX7V/mvtFlD7N5uub6bK1CwDu5dxZ0XbFO6eqGVNgeCCua131pvxUzVOVfT33Ga3S6Z93/qTVhlbar4vnKE6Pij3oUakHpXKWMkoM0scLjQnF3tYeSPyQqrakGvdC79G3Sl+G1xhOGQeDPKT8KIaa6hmvjmfV5VVMOz6NwIjAJM/JZJ2JUbVG8VXtrz6qONmJRydos7HNe5/4vpWaFbs1QsPu27uZcWIG556eAxJvxEfXGs20xtMM3p+UtjyNeEqrDa248vIKAF0rdMWzuSe5MuUyeizbb26nw6YOOttD5cuSj7MDzppsy5a398Jv7xt/P/M7aqFmjPMYOeKYBgQEBRAUHUSDwg2AxPuhATsH8FXtr/ii+Bdp7qF1rCoWL38vPM95cvnF5XeeZ21hTefynRldazRO+Zz0H7AuBvFMGOQvn+4SRicnJ+Hr62vw6z6Ix50aAAAgAElEQVR4/YDJRyaz4doGlrVdZlYVMyXj235zO3229yEiLoKyDmXx6eJjkhvq/3oV9Ypm65rpvcGUcSjDwV4HyZ81f6rHIITA74Uf666uw8vfi+dvnmuP1chXg/299pu8cp+UOOLg99yP44+Oc+ThEfbf28+1Ydco7ZBY2CggKIACWQuY7GGIIaZ6JqgTWHt1LT8e/5GHYQ+TfK2tlS0ja45kXJ1xn/RQxRxGGE8HnmbI7iH4v/IHIKdtTkbXGs3ImiNlBUhJS6VRMffcXCYfmUx0QjQ5bXPi2dyT7hW7G/2G2vOsJ2P2jdFpq5irIif6nUi1GTHJ9TzyOUU9ixKnjsMpnxPL2y432hR86eOcenyK2adns/PWTkrnLM2NETeMXnnXkF68ecEfF/5g0cVF71xXD+Bg58Awp2EMcxqmXXeb5ANWmTC+m6ETxqCoIKafmM7CCwtJ0CRgY2nD9y7fM7H+RIP1IaVNt0Nu035Te24E3SCLTRZWua2iQ9kOpg6LsNgwWm1oxenA0zrtRbIX4WCvg0atBqbWqDny8Ajrr63H+4Y3hbMX5tqwa9rju2/vxqWwi1mM0H4OYlWxzDk7h2OPjnHq8SntJsWQuJZoSZslZvMwLCWJmEqjYv3V9Uw9PpX7r+8n+ZqMVhkZ5jSM8XXHp6jSrzmsYbwRdIPyC8uTP0t+vq7zNYOqDZIF16R3evD6AYN3D+bg/YNA4mjjxo4bjR7HmL/G4HnOU6fNtZgre7rvMfmMrT/v/MnQ3UMJjAjEysKKCXUn8G2Db+VWM2bg7WyKn079pL3PyWiVkX5V+jHbdXaaXJ948dlFPM954uXvpd0TMimVcldiTK0xdKvYTafI4Ds/h2TC+G6GShij4qP4/ezvzD41m8j4SBQUelbqydRGU7UFBCTpTfwbBuwcwObrmwE4P/A8NfLXMHFUib+/bpvctDcEb+XNnJcDvQ6YpOBFTEIMj8Mfa0ew7obepeS8ktha2eJWxo0eFXvwRfEvTH6jkF7EqmI59+Qcd0PvMqDaACDxg9bxZ0ftHoMl7EvgUtgFl8IuNC3W1KwqBH7KVM/aBWrj5e/FD8d+4E7onSTPzWCZgSHVhzCh3gSD/X2NWSU1Mi6SRb6LOP3kND6dfbTJ5/57+3Ep7CJvaKVkEUKw6vIqxu4fy8wmMxnqNNToMag1ajpt6cS2m9t02vtV6cfytstNPo0wMi6SiYcmsuDCAiBxps6yNsuoW6iuSeP6nN0JuUNbr7bcDL4JJFaxHlFjBF/W+tIk06tTQqVRsf3mdjzPeerUC/gvBYW2pdsyxnkMLoVdkvx38c4HrDJhfDdDJYxLLy5l8O7BALQo0YKZTWZSOU/lFF9XSn+EEMw5O4c7oXdY2GqhqcPRilXF0s27G9tvbtdpt7e1Z1/PfTjlM0il5U/m+8yXMX+N4VTgKW2bg50DXcp3oUfFHjgXcDb5DUNaEp0QzZnAMxx7dIxjj45x7sk54tRxWFlYETY+TDvi9MeFP8ieMTsuRVzIlyVfqmxXYQgfM8JoZ2XH1EZTWea3THsj8V/WFtYMqjaIifUnUiBrAYPGaox9GEOiQ5h7bi7zzs/TbqNzqv8p6hSsk6LYpc/bq6hXONg5aKfxed/wpkKuCtoHe6ktOiGaxqsba9fdvjW14VQmu0w2SgwfcvLxSQbuHMitkFs0KtKIQ70PmcV75OdCpVFp15HGqeIoNrcYVhZWjHUey4BqA9LciOLrmNcsu7SM+Rfm8zj88TvPy5ohKwOqDmBkzZEUy1Hsvdd85wNWmTC+26cmjEIIboXc0q5DS1An0GtbL4ZUH0Kjoo0MHaaUzt0IukFUfJTJRxtVGhX9dvRj3dV1Ou1ZbLKwu/tu7QJxU3rw+gEbrm1g/bX1BAQHAInryl5+/TJNT1VN7UTs31uX7L2zl3Ze7fSmslTMVRGXwi5McZmitz4vNbarMKSPmeppbWH9zmk8VhZW9K/SH48GHhTKVsjQYWq9/X7OODGDoOgg7fczpRW7n0Y85dczv7L44mJtMlqvUD0m1ZtE8xLN5Y2rZDAPwx5SfmF51Bo1U1ymMK7OOKPM+HgV9f/2zjs8qir94583hXRCCiX0FooUIYgUKYIiRYqKsjZUFLDX1RVFWf1ZVnfdXVFXXVEUxbYquogKoiBFbEh1qQklIASSkEAgpM75/XFnLklIQgKTzB14P88zz8y998yd79yZe8/9nvOe9+ynzxt9jgsff/uStxl/9vga//yqkFeUx1NLn+K6s68jMS4RsMyL9ujXHHty9jD9x+nMXj+b9beut5OybUzfSNvYtn4XjbQpYxMv/PQCs9bOqjQapW1sW+469y5u6HZDle+BtIfxJDgZw/jdju948JsH2ZC+geQ7k09pPIuiHMo/RM8ZPdmRvYOXhr/kk0mJS+IyLu748g5eWflKqfWhQaHMGTeH4YnDfaSsNMYY1qSt4d3171LkKuL5Yc8DVqU84r0RjGo3iis7X0mjyEY+Vlo5NWXEsvOyWbZzGUt3LmXJziX0bNyTf11shUrtOriLltNb0q1RNzvEtF/zfhVm+6yNHjFvUJVQz4oIlEBu6HYDU/tPpVVMqxpQVz6ehgJP1tlTaSgoLC6k6T+b2skPhrcdzkP9HqJ/i/7elKwogNXzcf/X9zNzzUwAzm54NjPHzCQpIanGP3tzxmb6zuxrh8uD1RD02PmPcWP3Gx133TfGMHT2UBpGNuTe3veSEJlA/Yj6mlHVC2xM38hzK57jnXXv2A2Bb455kxu63eBbYSeBy7j4OuVrpv80nfnJ8yste2HrC7m7192MSBxR7cQ9OobxJKiOYVy3bx1TvpnCV8lfAdAwoiEfXfGRVsbKKVFQXMC98+/l5ZVWeOpN3W/ipREvlRqgXNsYY3j424d55vtnSq0PDgjm3cve5YpOVzg2NPGzTZ9x6YeXAhAgAVzY+kKu7XItl3S4xHE9kN42Ykt2LOHTTZ+yZOcS1qatLZWGvlP9Tvx222/28qH8Q9QNqVslnbU55u5UONHxLI8ACWB81/E8MuAR2sa2rWGF3mfdvnUkxiYSFhwGwLTF09icuZkp502he0J3H6tTzgS+2fYNkz6fxI7sHQRKIH/s80ceO/8x+z9ZUyzbuYwL37mQguKCUuuDAoIY1W4Uk5ImcVGbiwgMCKxRHVVhQ/oGerzWg7yiPHudIMSHx9MoshGvj36dc5ucC1hZjLdnbadRZCP7ERMW49fZPE8WYwyHCw6TkZtB5tFMujbsSp3AOgC8teYtPtn4CfO2zAOs4zn2rLE80PcB+1j6C0cKjvD22rd54ecXKhwmAVbD/fiu47mr1110btD5lD5Ts6RWk6oYxh3ZO5i2eBqz183GYIiqE8WD5z3IPb3v0cxyitd4e+3b3DzvZvKK8jin8Tl8Mu6TGg2JqwrPLH+Gh74tneE3QAK4tsu1LNm5xJGhiUcLjzJvyzxmr5/NV1u/slscBaFJ3SbsuvfYvHpPLHnCCgOMqE+DiAbUD69vv44Li6vxG41TMWJph9NYunMpfZr2seciKzn5cHBAMOc2OdfqQWw5kL7N+p7U2A0nZPWsDi6XiyeWPsELP71Adn52hRMXC8LVXa5m2sBpfjnf54pdK3h62dN8sfULXhr+ErefeztQOvRYUWqLIwVHeGTRI0z/aToGU2uZVD/87UOu/OTKCrc3j27Ojd1u5MbuN/pszkYPyQeSeWTRI2zM2Eja4TTSj6TbjXqrJq+yG3humXcL//7136XeGxQQRMOIhvRp1oePrvjIXv/yLy9TP7w+jSIb0TCyIY0iGxFVJ8qR1wBjDEcKj5CRm2EZwNxMMnIzaBvbll5NewGwau8q7v/6fjKPZtrlSjYIbLtrmx0BMu6jcXy04SNCAkOY0G0C9/W5zw7/9Rd2Zu/kX7/8ixmrZpCdl11huSZRTbi95+1M6jGJ+PB4r3x2uQ2sahgrpiqG8aJ3LmLhtoUEBwRze8/bebj/w7U2qblyZrF672ou+89l7MjeQVxYHO9c+o7PQ0Bf/uVlbv/y9iqVdUpooofM3Ew+3vAxs9fPZsWuFTSJakLqvccGjTd8rmGFcxc91O8hnr7gacBKuPPs989SP/x4Y1k/vD7t49tXO7SoukZs6Q1L7fDSpTuXsjlzM0Aps/Dj7h+ZnzyfgS0G0rtpb6+08Dth3sATse/wPr7Z9g0Lty3km23f8HvO7xWWFYRxncYxbeC0Wtd5qhhj+Drla55e/jRLdy4FrPG70wZOY0q/KT5WpyjWNei2L27j7UvfPuUekKry2q+vcddXd5FfnF9hmQAJYHjb4UxKmsTF7S52RChokauI9CPppB1Oo0N8B/t6/caqN1i4bSFph9PYd2QfaYfTbDNxfsvzWXz9YsAy6ZF/Ob4RMCwojEaRjfjn0H8ypsMYwJqGYeWelbapbBTZiIYRDU+pjsgryiPtcNpxBjDzaCY5+Tn8c9g/7bL93+zPz7//fFxvMMAdPe/gxREvAtb/p88bfUptDw8OJy4sjvjweN4f+76dYOmLLV+w+9BuLulwiV8NDTPG8P2u75n+03TmbJxTYaMmQO+mvbm7192M7Ti2RsZglh1Lf+TFI8Vmr/HKyeH7MwwQkWbA20AjwAW8ZoyZLiKxwIdAS2AHMM4Yk1Xd/R8pOMKh/EN2CvX/G/R/NIhowBODnqjVsS3KmUf3hO78OvlXrplzDfOT51daAdYWt/W8jag6UUz47wSKTXGlZXMLc/lk4ycMaDHAp6GJHuLC47j5nJu5+ZybKXIVkZOfU2r7YwMfY+/hvaQfSSc9N539R/bbzyXHwGzO2MzHGz6u8HMyHsiwx//dMu8WNmVsqtBYeiZ03pixkYzcjCp9j9TsVJo/X7q3OSI4gr7N+tI4qrG9rnfT3vRu2rtK+6wqmbmZVb65CgoIKjWmqKbILcxl2c5ltkFcu29tld43tuNY/jzwz3Rp2KWGFXqfb7Z9w4PfPMiqvasAqBdajzt63sFdve7SBkzFMfRu2ptfJ/9qNxgaY7j9y9u5OPFiLm53sVc/q+TNbqAEEhoYSn5xfqlQfA8u4+KLrV/wxdYvSIhMYEK3CUxMmujTe7qggCASohKOm67npqSb7KmNPOQV5bHv8D6KXEX2uiJXEbeec6ttKj2P3MJctmdvLxUh8+XWL5n23bTjNNQNqUtibCIrJx/rOHl15asESiC5hbm2AfSYwjvPvZNLO1pDPmatmcUtX1Q8vcqzQ561w0eLXcUUFBcQHhxOfHi8bQDjw+Pp0biH/Z6z6p/FwvEL7TJx4XGEB4eXu39v/59qmvyifP7zv//w/E/P29fx8ggKCOKKs67g7l532z2vNYWIMKnHJCYmTWRjxkY6/V+nZK/t2wk9jCKSACQYY1aJSBTwK3AJcANwwBjzjIhMAWKMMQ9Wtq+SPYyFxYXMXD2Tx5Y8Rq8mvfjsys8qe6ui1BjFrmLmbJzD5Wddble8j3/3OK1jWnNVl6t80jo6Z+Mcxv5nbJXKOiE00YM3xlqmHkzlh10/lDKUnufM3Ex+u+03e3xJ0r+TWJ22utz9XH/29bx1yVsAvLP2Ha7/7Ppyb27KEiRBhASFMLDlQDtJTVJCUq1kfXNCD6PLuFiTtoaFKQtZuG0hy1OXV6sxZUz7MTx2/mN0a9TNq7pqk/fWv8c1c66hYURD7utzH7ecc0uVx6Aqiq/4autXjHhvBABXdb6K6cOme6WB40TjlQPFMksnauS8sPWFTE6azJgOY2xz4+8cLjhM2uE0GkY0tMftz9syj7mb55YylmmH0yh0FZIYm8iWO7fY76/3TL0K57N95oJneLCfdVs9d/Nc7vzqzlLmr+Trm5JusnMxZOZmEh4cXuPjWp3I74d+543Vb/DyLy+z78i+CsvFhcVxc4+bua3nbTSp26QWFR5DRH41xnhlDjVHGMayiMh/gZfcj/ONMXvdpvI7Y0ylkwOdc8455pdffmHOxjk8vOhhtmRaJ03Pxj1ZfP1iHaOoOILtWdtp91I7ilxFtI1ty6MDHuXqLlfXqnHckL6BHv/uQV5x3gnL+io0sSS+mgZiU8Ymfj/0+zFjeeSYwRzSegi39rwVsAbsT/jvhCrtMzwonB8n/uiTnjFfjWFMPZhqG8Rvt39b5d5YsEKyBrYcyJDWQxiROMKe/shfyC3M5Y1Vb5CVl8W0gVavQJGriHfWvsOVna88I2+6FP+k2FXMiz+/yNRFU8ktzCUuLI4Xhr/AVZ2vOqXrRFXGf4cFhXFph0v5X/r/ThiFUD+8PteffT0TkybW2pySvsYYQ1ZeFofyD9GyXkvAapx7+NuH2X9kP5F1IkubwfA4OsR38Pq8tKcbuw7usuY33mHNcbz1wNZKy3du0Jl7et3D1V2u9vm1/bQ2jCLSElgKdAZSjTH1SmzLMsbEVPb+9l3bm3p31ePn338GrPlMnh78dKmeHUXxNUWuIt5d9y5PLH2ClKwUwPqvPtL/Ea7pek2tGMcKJ3oth5DAEP4x9B9M7jHZJ72h/jANRGFxIa2mt6p0vJ0HX/fY1kaW1EP5h1i8fTELt1km0dN4VxUEoUfjHgxpPYQhrYfQt1lfv5zvLDsvm5d/eZnnf3ye9Nx0QgJD2HnPTr8an6Mo5bEtaxuTP5/Mt9u/BeDixIt55eJXTioRTXUbsVLuTOHXvb8yY9UM3v/tfQ4XHK70PQNaDGBS0iTGdhzr8xt4xdkYY9iRvcMyiG6TuD17+wnfJwgj243knt73MKjlIMf4jdPWMIpIJLAEeMoYM0dEsqtiGEVkMjAZgAR6cLM1RcafB/6ZiUkT/W5yT+XMwWMcn1z2JMkHrFDzxNhEVt+8usZ7w6sTmughOiSaC1tfyLC2wxjaZmitZanzl2kg/EVnTRjwwuJCfv79Z9sg/rT7pxOGj5WkZb2WtkEc3GpwhXNI+gP7Du/j+R+f5+WVL3Mo/xBgRbk83P9hRrcffUam01dOP4wxvLnmTe5bcB8H8w+WSixWHU4lTP5wwWE++O0DZqyaYXcUVES90HqM7zqeSUmT/HLcs+J9jDEkH0guZRB3Hdp14je6iaoTxYRuE7iz152OnMbptDSMIhIMzAMWGGP+4V63mWqGpCa0TzC3vnYr9/W576RSziuKLyhyFfHe+vd4cumTdGvUjf9c8R/AupgVm+Ia6dWrTqtuRZxV/yyGtRnG0LZDGdBiQI3MNelP00D4Q0+oh7LZ1DwhvvXD6zN1wFRu6n5TpRqNMWzJ3GIbxMXbF5NTkFNh+bJEh0QzuNVgyyS2GUKbmDY+PybeICc/hwbPNbDnZxvcajAP93uYwa0GnxbfT1HKsjdnL08te4q/DvmrndCkoLigymMIqxPtEh0Szbyr59Gveb/jtq3bt44Zv87gnXXvnHBfvZr0YlLSJP7Q+Q96r3gG4cmBsGTHEpamLmXJjiXsPby3WvsICgiifVx7RrYbyUP9HiI6NLqG1J46p51hFKsWnYWV4OaeEuv/BmSWSHoTa4z5U2X7qsq0GoriVIpcRRzKP0RsWCwAi7YvYuLciTwy4BHGdx3v9d7yqvSIVRXPOLNhbYYxrO0w2sW188oNshOStFSHUzVitY2nAj1w9ACxYbGVJhFKP5LOt9u/tcciVqclNiggiD5N+9gG8ZzG5zgiFf7J4jIuVu5ZyeebP+fnPT8z/5r59nEb8OYAYsJieLjfwzWeFU9RnMbBvIP0eK0HE5Mm8sc+fzxhveXta3xuYS4fb/iYGatmsDx1eaX7i6oTxdVdrmZS0qRS2T2V0wOXcfHb/t/s8YdLdy4lPTe9WvsIDgimV5Ne1A2py8o9KzlccJjgwGBHzVddEaejYewHLAPWY02rAfAw8BPwH6A5kApcYYypNMe7GkbldOK6T6/jnXXvANCqXium9p/KdWdf5zXjeKIesbCgMJISkmgR3YKvt31drUQlLaJbMKytZR4Htxp80hkgvdX6XNtUx4g5lbyiPJanLrcNYkXZYiuiY3xH2yAObDHQzvDnr+QW5vLNtm/4fPPnzNs6j7TDafa2Xyf/SlJCEmCF5+pQCOVM5e21b3P9Z9cD0K1RN2aOnmlPYl8eNRlFsjF9I6+vep1Za2eReTSz0rLdG3VnUtIkru5ytaN7jZSKKXYVs3bfWtsgLktdVu2poUICQ+jTrI+dwbxXk17c8sUtfhE5VJbTzjB6EzWMyulEsauYD377gCeWPmFP7N6yXkvbOHojbXhVe8RcxsWqvauYnzyfBSkL+GHXD1UeoxYUEETfZn0Z2mYow9oOo1ujblUex+VvPYz+jMu4WLdvnW0Ql6Uus0Mrq0KDiAZc2PpChrQewoWtLzytsu9tSN9Aj9d6lDoezaObM6rdKEa1G8X5Lc/3y8Q8ilITfJ3yNTfPu5kd2TsIlEAe6PsA0wZOqzDpTE2P/84vyuezTZ8xY9UMO1FPZZ8zrtM4JiVNok/TPo4zAacrJzNlVpGriFV7V9kGcXnq8io1LpckPDicvs362gbx3CbnlrqW+0tugvJQw1gJahiV05FiVzEf/u9Dnlj6BJsyNgHwlwv+wpR+U7z2GdXtEcvOy+bbbd+yIGUB85PnVys8sUFEAy5qcxHD2gxjSJshNIhoUKkufxnD6E8Uu4rZfWg3KVkpbM3cypKdS/hm2zfVCtcJDQplQIsBdrKaLg27+H1CF2MM6/atY+7muWQezeT5Yc8D1vFK+HsCrWJa2Saxa8Ou+l9TlAo4XHCYRxY9wgs/vYDB0C6uHW+OeZO+zfoeV7Y2x3+nHEjhjdVv8OaaN0tFCZRHp/qdmJg0kfFdx/t1Ii4nU50pswqKC1i5Z6VtEL/f9f0Js+SWJbJOJP2a97MNYo/GPSpsfPen+4+so1ks2bkEgEs6XAKoYawUNYzK6Uyxq5j//O8/PP/T83x59Zd2BbYxfSNtYtv4bKJiYwybMjbZvY/f7fiuWhOx90joYWde7d2093HhfP7cwudLjhQcYXv2dlIOpJCSlcK2rG2kZKWQciCFHdk7KHQVVmt/gtA9obttEM9rfl6NJDqqbfKL8vlux3fM3TyXz7d8bjd+BAcEk/GnDDuc+nDBYU2QoSjV5IddP3DT3JvYmLGRL6/+kuGJw8stV9vjvwuLC5m3ZR4zVs1gfvJ8DBXfD4cEhjD2rLFMSprEwBYDtaHIS1RlWEz/5v05r/l5LN25lBW7VnC06Gi1PiM6JJr+LfrbBrF7Qvcqj593coRTTn4Oy1KXsXj7YhbtWMTqvasxGLo16sbqm63hI2oYK0ENo3KmkV+UT9sX2xIgATzc72EmdJ/gM+PoIbcwl6U7l7IgeQHzU+bbvaJVoW5IXS5odYFtIFvUa+FX2UdrE2MM+4/sL2UEt2Vvsw3iiVrPq0Lz6Oa2Qbyg9QXEh8d7QblzWJC8gMs/urxUK3WjyEaMTBzJ6PajGdp2qM/PJ0Xxd/KL8vl8y+dcftbl9rpNGZvoEN/huLK+GP+dejCVmatnMnP1zBNGyyTGJjIxaSI3dLuh0ugY5cR4M/Geh9iwWAa0GGAbxK4NuxIYEHhS+3JqDoXnVjzHlG+mlBoWFBwQTJ9mfbig1QU8OuBRREQNY2WoYVTONJIPJDPmgzFsSN8AWDf4D/V7iAndJjhmTNXO7J126Oq327+156arCh3iO1hTd7QZSkpWCs+teM4vso96i8LiQnYe3GmZQY8xdPcWbsvaVu1wnBNRN6Qug1oOspPVJMYmnhbH1dMLPnfzXCLrRHL7ubcDsPvQbpr9sxlnNzybUe1GMbr9aHo07uH3obWK4mR+2v0TfWf25crOV/L80OepH1Hf15IAK4pnQcoCZqyaweebP690nH5QQBBj2o9hVLtRxIXHERMaQ0xYjP18OkRfnCpFriIOHD1A+pF0MnIz7Ed6bjrpuem8seqNas0FXR4NIhrY5nBgy4GcVf8sr12/fdnDWFBcwE+7f2LR9kUs3rGYiUkTubbrtQDM2TiHcR+No2eTngxqOYjBrQbTt1lfe1obD2oYK0ENo3Im4jIuPt7wMY8vedw2js3qNuOhfg8xMWmiozI2FhYX8uPuH20D+eveX6v83tCgUAa2GMjZjc6mY3xHWtZrSZcGXQgPDickKMRvb/IP5h0s3UtYwhimHkzFZVwn3slJEB8eT5uYNrSOaU3H+I5c0PoCzm1yrl9Pd1GSwuJClqcu5/MtnzN381xSslIAaBPThq13brWN8N6cvSREJfhSqqKcUcxeN5vJn0/maNFR4sPjeWHYC1zZ+UpHNU7tzdnLW2ve4vXVr7Mta1u13x8aFGqbx3qh9UobyjLmMibUXcb9Ojw43FHHAqxGt0P5h2zDV8oAegzh0dLLWXlZXtfROKpxKYPYPq59jR2r2h7DuHLPShamLGTxjsUsT11eKvz2mi7XMPuy2YCVwbyguOCE2efVMFaCGkblTMZlXHyy4RMeX/I4/0v/H21j27Lx9o2ONgD7j+xnYcpC5qfM5+uUr9l/ZP9J76tOYB3CgsIIDQolNCiUsGDrdXnrQgNPsL3E+vLWlVwfHBBcaSXhMi725Owpt5cw5UDKCdO9nyyBEkiLei1oHdOaNjFtbHPYJtZ6PtmpTvyBWWtmcc+Ce8jOy7bXxYXFMbLdSEa1G8WlHS/12wYGRTkdSDmQwuR5k1m0fREAFydezCsXv0Kz6GY+VlYal3GxePtiXlv1Gp9u/LTaY79PhuCA4PINZTlGs+RzvdB6RNWJqpJpySvKK232SvT+VbRc5Cqq8e9eHsEBwdzX5z4mJk2kTUybWjXTNZVDwZOVvHODzvY92vlvnW8nrgEr6dLgVoMZ1HIQA1sOtOforipqGCtBDaOiWBeiORvnEBoUysh2IwGrtfTTTZ9yU/ebHBOqWhaXcbEmbY099nHFrhU+q6CqQ4AEVGgoDxccZnvW9molAaoOkXUiLTMY24bW9Swz6DGGzVls2U0AACAASURBVKObO6p3uaZIOZDC51s+p11cO0YkjgBgYcpCLpp9ER3iOzC63WhGtx9N76a9T3osi6Io3scYw8zVM/nj13/kYP5BoupE8fG4j7mozUW+llYu6UfSeXvt28xYNcOe6sppBEpgqd7KmLAYokOiySnIKWUQTzUUtDbx5ZRZ3sqh4Bmb6wkx/W7Hdxw4eoCfJ/5MzyY9AXh15ausSVvDoJaDOL/l+TSMbHhK2tUwVoIaRkUpn3vn38vzPz1Pk6gmTOk3hYlJEx0/xuJQ/iEWbV/E/OT5zE+eX6WwkNORhMiEUkbQNogxrakfXt9xoUs1TbGrmB93/2iHmm7M2AjAqHajmHvVXMAa/7EzeyeJcYm+lKooShXYk7OH27+8ne92fMfG2zfSKLIRYN1kO+36Zoxhxq8zmPbdNDKPZiJY8xQHBgQSExqDy7jIysvyi8bO2iA2LJb48Hj7UT+8PvHh8cSFxfHs989WKcLG11NWnEoG34N5B7nli1tYvH0x+47sK7WteXRzXh7xMhe3u7hGdKthrAQ1jIpSPnM3z+XRxY+ybt86wBoHMOW8KUzqMcnxxhGsC/aWzC322MdNGZvIK8rjaNFR8oryqjXBvNOoE1iHVvVaHWcG28S0oVVMq+MGsp9JGGMwGDt89LkVz/Hs98+SkZthl4kOiWZ44nAu73g5Y88a6yupiqKcAsYYdh3aRfPo5oA1r1zbF9vSu2lv+jfvT7/m/Tin8Tk+ra+q2tv01pi3OFp0lKy8LLKOZlX4nJ2fXe76mopIOVUigiNKmb+SBtBejji2HBsWW+mQGH+bMutEGXxTD6ayePtidh7cybSB0wArcqrRc41Iz00nITKBQa0GMbjlYAa1GkSreq1q1ASrYawENYyKUjEu4+K/m/7L40seZ+2+tYDVe/XqyFcZ3X60j9WdGsYY8ovzLRNZeMxEegxlVdedzHuq0pIcExpTYS9hk6gmZ3SopMu47KyvnnGe27K32eteH/U6V3S6AoDpP07nngX30DqmNaPbjWZU+1H0b97/jAi9VZQzia9Tvmbo7KGl1tUJrEPPxj3p37w/d/e+2+6JrC1qy+AcLTxmNrPzsss3nGXNp7tcVaeoCAoIOrH5K7EcFx7n9cZLf58yK+1wGou3L2bxjsUs2r7ITqwWKIFkPZhFVEgUYE3f1KJeixpN0FMeahgrQQ2jopwYl3Exd/NcHl/yOGvS1vDDTT/Qu2lvX8vyW4pcRcdMZBlDGRQQRKt6rYgJi/G1TJ9hjOHA0QPHTGFWCoLwUP+HACubadhTYRWmsP/bkL9xf9/7AcjIzWD/kf21Mjeboii+JfVgKstTl7M8dTnLUpfx2/7f7G37799vT8fx1pq3qBNYh/7N+9dY0pzazph5suQX5R9nMg/mHSSyTmSp3r/okGhHXENPJdyztnAZF7sP7cZlXLSs1xKworbGfDCmVLm6IXUZ2GIgg1sNZkK3CUSHRvtA7THUMFaCGkZFqTrGGL7f9X2piWZv+OwGMo9mkhibSLu4diTGJpIYl0jTuk01q6RSIYXFhaQeTLVuRNyV5Jur3+SFn19gW9a24+bebBjRkLT70+zlAW8OICggyO59bR3T2n7EhsX6/IZBURTfk3U0ixW7VvC/9P/xp/P+ZK9vNb0VO7J3ANa4sH7N+9GvWT/6t+jvtXn5fDkn35nAicI9a4vvU79nTdoakg8kk5yVTPKBZLZlbaOguKDU1BZ7c/aS+GIi/Zr3s+dC7J7Q3VFZ6b1pGJ3zrRRFqXVEpJRZXJu2lllrZ5VbNjQolFcvfpXru10PwPas7aQeTCUxLpGEyAS9oT9DKCwuZM7GOXZvoSd01DNf5Ptj3+fKzlcCcLjgMGvS1gDHsrl6TGCbmDalElosnbDUZ99JURT/ICYshovbXVwqSUixq5jJSZNZvms536d+T+rBVN5b/x7vrX8PgCcHPcnUAVMB65oUHBB8UpnCM3Mzq2wGggKCOHD0QLU/40xGRGrcYOcX5bM9e7tlBg8kk3IgheSsZGZfOpu48DgA/rrir8zdPPe49zaKbERknUh7OSEqgawHs86Y4RBqGBVFsenasCu/3fobmzM3syVzC1szt7L1gPVIO5xmX1ABPvjtAx5e9DBgtaa2jW1r90h2rN+Ra7te66uvoZwkhcWF7Dq067ixhOHB4cy6xGpICJAAxn86/ri5yASheXRzCouPrb+s42Wc2+Rc2sS2IS4sThsVFEXxOoEBgXZ4u8u4+G3/b6XCWEsOt3h15as8sugRejbpaSfS6dusL/VC653wc+LC46qc+bTIVVTtOfNqCk/PXWZuJnHhcad9OH9uYS7bsrYRKIF0rN8RgNV7V3Pph5eSejAVw/GRlVsPbLXvb4a3HU7DiIa0jW1rP1rHtC5lFj2cKWYR1DAqilICEaFTg050atDpuG2H8g9RJ7COvVw/oj69m/Zma+ZWMo9msnbfWjuRTuuY1qUM47DZw4gLj7PCWz2hrnGJVaqkFe9wtPAoe3L2lHqMbDfSnnbiyaVP8th3j5U7jjA+PN5+HRgQyMSkiYQHh5cKG20R3eK4VvsmdZvQpG6Tmv1iiqIobgIkgK4Nu9K1YVdu63kbYBkmDzuzd5JfnG8bSrAauzo36Mzo9qN5cvCTFe67Y3xH4sPjOXLwxCGp9SPq0zG+4yl+m1PDMzbwqWVPkZGbYY8NjA+PZ2r/qUxMmuj3xnFhykJW7llZKnx0T84eAK7sfCXvj30fsMz+zoM7CZAAWtVrRdvYtrSJaWMbwvZx7e193nLOLT75Lk5HDaOiKFWibkjdUssTkybaWeAOHD1g90ZuydxSKpPaofxDLEhZUO4+48Pj+deIfzGu0zgAdh3cRXpuOomxiXZ2MaVyCooLSDucZpvA4IBgRrUfBVjHvu8bfdmTs4esvKzj3ls/or5tGGPDYnEZF83qNisVNup5XTJ89OWLX669L6goinIKlDRFL454kccHPc6KXSts0/jLnl9Yv389bWPb2uVy8nO49YtbrbGQzfvZ4yCn9p9apSypU/tP9akZqyz76JGDR7hnwT0sS13m2OyjnkRpyQeSSclKsUNIkw8k8+kfPrUntH9l5St8uunTUu8NDgimVUwrGkUcy6DbtG5TttyxhRb1WpRq+FaqjhpGRVFOmdiwWHo17UWvpr2O2xYaFMqyCctKhbd6XmfkZpQyorPWzuLRxY8C1niBkol3Otbv6PdTf1SHIlcR+4/st41g/+b97Uyrz614jtnrZrMnZw/pueml3te9UXfbMEbViWJL5hYKXYUEBwTTOKpxqUdi7LFJ7W/odgM3db/ppMb2KIqi+AuxYbGMbDeSke1GAlb0xco9K0sZiR93/8i769/l3fXvAta0SOc1P4/zmp1H/+b9WbpzKUeLjh63b880EDd1v6l2vkwFvL7q9QqnqgArbPOTjZ8woMWAGpvf0GVcCGIb0o3pG9l3ZB+HCw6Tk59DTkGO/bpDfAf+0PkPAKzau4oL3r6A7LzscvebfCDZNoxj2o+hdUxru6ewTUwbmkU3O26saYAE2I2jysmhWVIVRfEJxhj25OwhJizG7pGc/uN0Xlv1GikHUo6buLhdXDs237HZXh753kgKXYWEBoUSEhhS6vmartfY41bWpq1lyc4lx8oElS47qNUge5+7D+0GKFU2OCDYqy2wLuMiIzeDPTl7CAoIonODzgD8fuh3bv3iVtsg7juyD5dx2e9bfP1izm95PgBTvpnCs98/C1gVYaPIRjSJakLjqMZ0jO/IXy78i/2+DekbaBDRQMcQKoqiVJE9OXv4bNNn9jhIT93g4a8X/pWXf3mZ9Nx0XMZFsSmmbp26XNLhEoa0GUJIYAjBgcH22H6wIj5SDqQQHBhMcEAwwYHB1AmsY7+ODon2yny83pj+Y2P6Rg7mHyQn323qSpi7fs37cV7z8wBYnrqcp5c9fVyZnIIccgtzOTjloN0oPHjWYBbvWFyujrEdx/LxuI8B69g3+UcTIutEHhtHGHNsPGFSQpJGIFURnVajEtQwKor/U+wqZveh3VbiHXePZL3Qevz5/D8DVmr12L9WnFDgrTFv2dlcX/jpBe6ef3e55YIDgil4tMBe7vJKl1LzfIE1viUkKITbe97Ocxc9B8CatDVc9+l15RrQkKAQ/nLBX2ge3RyAF396kcU7FttGcO/hvXbihJHtRvL5VZ8DsP/Ifho+17DU5zaIaGD3Bj464FG7B3d71nYOHD1A46jGNIho4JWbDEVRFOV4jDH2fJDLUpex8+BOvrrmKzuZzOBZg9l3ZF+5751y3hS7AW9B8gKGvTusws/Zdtc2WsW0AmDcR+P47+b/2mYyOMBtLgODOb/l+bw55k3AMqHD3x1eqlxeUR5Ldy6tcF7bkghC3ZC6xIfHk3xXsr2+/t/qk5GbUe57Hj//caYNnAaUPxdhSX6/73caRzUG4L4F9/Hr3l+JqhNFZJ3IY88hUXRp0IUrOl0BWMd7/5H9NIhooI2cp4hOq6EoymlNYEAgLeq1oEW9FgxpM+S47WHBYSy+fjF5RXnkF+Vbz8X59vK5Tc61y3Zt2JU7et5xbHuJcmUrI49BK7nPIlcReUV5pRInZOdls37/+gr1PzrgUfv1z3t+Pm6MRWxYLI2jGtMiuoW9Lj48nk/GfUKTKCtRTMOIhhVmYGsV08q+sVAURVFqDhGx66Nrul5Tav1Z9c/ihm43kH4knUJXIYWuQgqKCygstl63jz+WTCWiTgRnNzzbKld8fNmSIbH5xfkUFBdQUFwApRNSs+/wMXN6tPAoK3atOOnvZjAczD943DyVSQlJZOdllzJ1ntd9m/W1y/Vq0ot5V807rkxUSBThweGl9vuPof+okiYRsUNOFeegPYyKoiiVUOwqJr84H0EICw4DrLm8Ug6kHGdAPcuj24+2w3CWpy5nb85eu6cwISqB0KBQX34lRVEUxcEUu4orNJYhgSF29umC4gJ+/v1ne1thcSHbsrbxwMIHjhvWUR5hQWEsHL+QHo17aL10GqIhqZWghlFRFEVRFEU5E/HGGEbl9MCbhjHgxEUURVEURVEURXE6IsLU/lNLTW9VHk6Y/kPxH9QwKoqiKIqiKMppwsSkiYztOLZC0+iU6T8U/0ENo6IoiqIoiqKcJogIsy6ZxfNDn6dldEsigiOIDokmIjiCltEtmT5sOrMumaW9i0qV0TGMiqIoiqIoinIa4pn+48DRA8SGxdIxvqMaxTMEnVZDURRFURRFUZRK8Uz/oSingoakKoqiKIqiKIqiKOWihlFRFEVRFEVRFEUpFzWMiqIoiqIoiqIoSrmoYVQURVEURVEURVHK5bTLkioiOcBmX+uoAvFAhq9FVAHV6V38Qac/aATV6W1Up3dRnd7DHzSC6vQ2qtO7qE7v4Q8aAdobY6K8saPTMUvqZm+lkK1JRGSl6vQeqtN7+INGUJ3eRnV6F9XpPfxBI6hOb6M6vYvq9B7+oBEsnd7al4akKoqiKIqiKIqiKOWihlFRFEVRFEVRFEUpl9PRML7mawFVRHV6F9XpPfxBI6hOb6M6vYvq9B7+oBFUp7dRnd5FdXoPf9AIXtR52iW9URRFURRFURRFUbzD6djDqCiKoiiKoiiKongBNYyKoii1jIiIrzUoiqIoZzZaFylVRQ2jj9GTVRERPQ+9gIhEOv18EpFmIhJqdCzAGYtT/6NO1XW64PTjKyKBvtZQGU4/fh5EJF5Egn2t40SISDsRqetPdZEf/Qccr/NkNJ7WN6oi0kFE+otIiIgEudc57YeMAEfqKoWIJIpILxGJ8LWWyhCRLiJygYgkOPmYuv+XNwIYY1xONY0iMkpE/uRrHSdCRMYAzwENfa2lIkRkKPAJ0Ny97NTfvI+I3Cgi54lIqK/1VISItBeR3iIS7ODrOyKSJCJjRKSFiIQbY4xDf/u64Nz/pQcR6Soiw0WktYiE+FpPRYhITxG5QkS6O7WRSEQGicgjAMaYYqf+9iIyCnjCied3SUTkEuAF3Nd4pyIiFwGfAf3dy45sLBCRgSJyv4j8QUSinXgOAYhINxEZISJNnXqN90Y95Kgv5E1E5DJgLvAIMBO4S0Ri3QfJERcd90XwBxHp7yRdZRGRkcAc4Clgloic7V7vKL0iMhx4D7gNmAU09a2i4xGLcOAl4E8ichfYpjHIt+pK465U/g9Y7WstlSEiA4BngE+MMWlltjniP+o+ls8AMcB9YP3mPhVVDiIyGvg30A+4H2hZYpsjjiXYDQQfYx3LfwK3eVrLHaZzNPABcA3wOPCsiCQ4rZFIRC4FdovIcKdpK4m7LnoXuBl4EhjmXu+Y3xzsumgmlr7HgSTfKiqNux4KwTrHHxKRJ8GuhxzVO+ZuaPs/4LuyhsFJv7uI9AaeBV4zxqSU2eaY88ldFz0L7AMuB6uxwKeiysF9fzwdqxF4FNCzxDYn/e6jgXeAy4B7gKdEJN5J11Fv1UOO+DLexn3jPRa4yRgzFPgI60/3gMc0+lQgICKdgL8CK4DpIjLAaTc7YF8EnwOuN8ZcCPwO/AnACcfRg4gMxGrZm2iMGQscBDq5tznmf24scoG3sdIdd/P04BljinwqrgTu3/1d4BZjzEIRqScirUQkymnGFjgbeNOts7G796FviQYin/7+InIB8Aow3hiTCLQUkcG+1FQeIhIL3Apca4y5EUgHkkSkkYhEOOX65NY5CbjSGDMO+Bm4DrhPROo56boEDAcecOt8AcgCnheRRk5pMBCRNsC9WNek2SIywkk3Ox5EpAdWnTneGHMJsAq4FhxXF/UG/oZVF92EVWe2EZEwcffY+/o8ctdD+VgNq1OAziIy3b2t0JfaSuJunP438Lgx5hsRiRGrx7aFk65JbtoAc40x34k19OAqEbnMSQ1E7nrn38ANxphBQCcRudbHso7D3ah+HTDJGPMAsBNLawen1OsAIhIGXI11fzwRmAecBzwnIg2cco3HS/WQzw94DSFANNAFwBjzGVZvI8DVTvijYbXuPGWMuRl4EXhJRAY67AII4AKeMcasci9PAyLdJ4qT+B2YbIz5SUQSsEItbhGRN4AbxSGhdSV+23ysCmYW0FVEXhSRv7tbfp1gyPYBuUBrEYkH/ovVKzoLuEEcEApW4lgawNMq/hHWTeTNwMsOuWgbLBP2m4hEA5uAruD7G8cyFAJhWCYxBhgC/AGrB+9RcU5IUCFW+GRLAGPM28A2oB5WS7STGokCgI4A7mvoDKzf/wEHXUMzgH8aY24HJgIfiMjFZW9yHfBfPQBMN8ascS//E4gWkSY+1FQeO7Aa2n4SkYbASOBKrN4SJ51HAHWAs7B6RhJF5CMReV9EAhzS05gOpADxItIN+Bx4DPg7MFUcMAavxHlxEPD01L0PnI/Vw/xfEWnmgHoIYC9wlTFmrXv5XSARHHF+l6QYiAMGuu/n/oB1PKcArzikXgfr/rgh0BnAGPMdsAY4gnX/6fN6yK0hEG/UQ8aY0+aBdfELdb8egHWTe6F7WbD+dB8CQT7WGOZ+HVxi/Q3AemCge7ktEOJjnXXcr6M9erFOjtVAI/e6Rk45niXW/QmY6n59LZaJaOIrjWWPp3u5BTDN/fpuLHP2mi81ltAZ7n7dAdgCpGG19AGMB/7j+f2dcDyBdsAGrPGBN5Y4vv8CRjhBo3vZM+/tQCxDfo6vf+8SOj3XzZFYPXYrgD+71w0A3gSSHKTzJqwwoJuBp7FC0W8EZvv6eJbR3BXrBuIKz38A6O3W7tNzqIzOknXRJUAOMNK93B2I9LVGtxZP3RmENf7/ByDRva6N5//hlAeWAb/L/bq/+3/azQG6AtzPEcBf3K//gHWj+5mv9ZXR2gJYgGUcPfXQAGA20MXX+krobIrVcPUJcGuJ9X/36HbKo8Tvn4TVwDHI15rK0XgO8Iv7t3/Kva4l8Krn2uSEBzACWAQ8hBWN9zFwoa/rIvc1MqTE77z2VOshn7tfbyEiY7EuxnPdsc+pWIZxnIgMMRYfYrVadPOxxv+KyMVAlGebMeYt4B/AX0XkJfdrn7RAu3W+D3wuIiOw/lxgtaYcBrKMMWkicjXwBOCT3qayx9PdK4Ix5q/GmKfcr2cDoYDPWqFL6Jzn1lkXyAZaiMhtwB1Y40Pri8idDtD5mYiMMcZsAi7AMrYzAIwx72DdZPhsfGiZ4zkGSMY6hl2xWssxxuzEalVr5EON73PsN48x7iu1MWYJVm/tcHdLvs+uw2WumyOBhViG9jtgI4AxZikQCbT2kcyyOodi3Uh8jFURhhhjrjbGzMTqcYr2oc4+InKlZ9kYsw74M1av/Dh3PfQjVm9oF6foxN0zIiIBxorIuQ54S0RmYPXk+aouKqsz37PJGHMEqwdqj4iMw7qG+iSSpKxOzzltjHndGPOC+/UyrJs4nyTmKqnRHOs9DgIai8hUrHGC92L15j3tC41ldYJ9Lb8JqwHLUw8txfqtfXJ9h3J17sYax3Yu0LdE0QKs66dPKOe/Ke7fX4zV2/R3rOtTXV9pdOsqezxXYjWyLMQy4hhjdmB1XCT4QiOUe01ajNXrHQ9kG2MuN8Z8A8SISDMfaRwBvIV1D3+B+3d+HJhwSvWQr925l5x0O6ybmz7AVVjhp7di3ezeCHyJ1YszwV2u1lt2K9B4N9CmTLn3sSrBsx10LO8GWpco8ybWWJKV+KiFrxKdiWXKXY411iXBQTr/iNUa/hBW694od9n+QFMH6by/7LniPp6ry673sc67sIzipcBWLPM4CfgVaOsQjaXOdWA08BM+7BGpQOe9WBVff/d5Psb9WAW0coDOq7EaAu8CGpcpd537mEb5SOdFWD00H2OFx3vWR7l/73VYSdjucX+fZg7QOanEek8PuKf3YSZWuGpXB+gseTylxOvXsMZe+rIuquh4BpYpd5n72tncKRrd2ya566FL3MstgRZOOpbllBvrPpaOOofc2/pihU8/ADzorofaO0lnmXOoO1YPmU9+83J0Ti6zrQeWaZyE1Qvuk3r9RDrLlBvv/n/G+EDjcHddM9R9zPZimULBqsvXn2w95ISxUt4gBthnjPkBK+voTqwQTxfWTdBmrMyZucDVpkwmRR9p3IFlZl0iMssYc0isAcldgMHGmPU+0HginbOxTpa+WL1Mg4wxWx2oMw0owrq5/CMwzhiz12E6B2P1knxtjPnVXfZ747u4/Ip0XiEib2GdO9dhhfte7qNzqCKdE7DGCf4LyzD+AasV8gZjTLJDNHr+m28bYw4aY+aKyOVYLaXbfaCxMp1XYd1A/IJVqRzFOpZO0jkBq7F8JlbUw/VYN2fjjDE5PtLZGquXaw0wRkQmG2Nec+uZKyIpWDcSMVgJe3Y5RCfGmBnGWOPnjdX7cC5WSPpgY/WSOkHnpBI6g7Gu8e2wkpv18dG5Xp5Oz/Esdo8LC8K6H7kP69qZ6hSN7m1LgeXGmI3uHuYdPtDnoUKd7v+mEZEJWGPZLnPQOSTGmNcAjDErxErQdAHQACtJ02aH6Cx5rgcYY1zGmNUi8hu+zWlS7rnu3rYBK8/H7VjjRCc46Fyf7PndS/w/LwPuxEqEk1Wb4kQkEsswPmKMWeBe1xSr0W89VjReMta9XPXrodp2vzXoqt8GxuEeT4eVqegrYLh7ORB3y6mDNPZ1a7zIvVwfH7Q+VkOn51heA5zlYJ1D3MsXAe0cqPM8rF7vC9zLQokWPwfpLPv/7IePWkqrqNNn4xWreyyd8qhE52D3cgQ+6rGrzvEEGlMmWsMHGgUrdDMSK8nJq1jJT3z+O1dB581lykTj+3HKVdHZH+jkZJ1YN+JnUyb6xQEa/fW/mejLY1lVnU54VOG/WcdX2qqg85YyZergw7weVf3dsSJ0fNXzHYA1NKcuxyJF/g942Rv799seRncLaDBQYIz5BWvMTV9gv4h8b4z5XkQ+wIrZ/cb4IFV0FTSucGucKCJLjDHpta2xGjrfxzqWC4D3jQ96wqpxPCeJyLfGmK9rW2MVdX4vIh8CN7t/d59Mp1HN/+ciY8xyh+u8QUS+9sXxPIlj6eTf/EOsDG/LjTVOzKk6S1479/hYZ76xxtwcda//EuvmYqBYcxxGAjnGGh/odJ1HjDFzsFrznazzsDHm09rW6C86T/P/ptN1+svxzAH8Qae/nOu5xphPfKSxDtb/bq17XRBWlOV63PPAishVQKox5vuT+Ry/NIxiJYx5GvgCaC4i+40x94nIQ1gZ3pphZf8xQB7WQXO6Rl/dQFZVJ1gJB8T4YJLXah7PfI4l6nGyzjz3s9N15vuJTp8cT3/QWE2dLrdOn0zm7KfXzqYictRY0yRhrCEGXwD7gb8A7bF66FWnd3R2wIrUUJ2nrlF/c+/q9JfjqTpPA51lNDZza5xcolH6IHBERK7ASs5zyUl/WG11lXrrAYRjhSJ5wvmaA5nA8+7l8Vg3E99hOevuqlF1qk7VeaZqVJ21pnM/MLNMuQeAPfgohF91nnk6/UGj6lSdqrN2NGIlXCvEmi6r46l8nj9OqyFY3ej7AIw1gHwmMExEnjDGvGOMGY816PQCY8xq1ag6VafqPIM1qs7a0TkL6CUify9RrhhrzrANtS8RUJ3exh90+oNGUJ3eRnV6F3/QWRWNG4HlWEl4Np7Kh/mNYRSRdgDGGlOzAZgvIleIyL+xBqGOABLk2Fx8640x+1Wj6lSdqvNM1Kg6faJzFFBXRGLd5f5hrDmwVKfqPOM1qk7VqTprVWNdYBdWduZTMovgJ4ZRrAml14iVjAFjzGPA37BihrOBe40x27CyjPpq4l7Ha1SdqlN1nhkaVadPdTYAQlSn6lSNqlN1qk4faowyxuQZYzK98tnG+CT/QpURkQjgE2AOVpa8EGPMVeWUuxa4BWvy2QzVeDyq07uoTu/iDzr9QaP781WnF1Gd3kV1nlka3Z+vOr2I6vQu/qDT5xqNDwaTVveBNcdWJNb8hZMUCgAABJZJREFUJh8D75XYFgQMwxrQ2U01qk7VqTrPdI2qU3WqzjNHpz9oVJ2qU3X6t0bH9zCWRUTigNeAo8aYa0WkM9Aa+NkYk+ZbdRb+oBFUp7dRnd7FH3T6g0ZQnd5GdXoX1ek9/EEjqE5vozq9iz/orG2NfmcYAUQkHitmty/WOMyBxkcTN1eEP2gE1eltVKd38Qed/qARVKe3UZ3eRXV6D3/QCKrT26hO7+IPOmtTo18kvSmLsWJy1wHRwGVO+wHBPzSC6vQ2qtO7+INOf9AIqtPbqE7vojq9hz9oBNXpbVSnd/EHnbWp0S8No1ip1UcAFxlj1vtaT3n4g0ZQnd5GdXoXf9DpDxpBdXob1eldVKf38AeNoDq9jer0Lv6gszY1+mVIKoCIhBpj8nytozL8QSOoTm+jOr2LP+j0B42gOr2N6vQuqtN7+INGUJ3eRnV6F3/QWVsa/dYwKoqiKIqiKIqiKDWLX4akKoqiKIqiKIqiKDWPGkZFURRFURRFURSlXNQwKoqiKIqiKIqiKOWihlFRFEVRFEVRFEUpFzWMiqIoilICEZkjIskiElrOtgUislFE6vhCm6IoiqLUNmoYFUVRFKU0dwENgYdKrhSRy4GLgFuNMQW+EKYoiqIotY1Oq6EoiqIoZRCRPwJPAZ2NMckiEgFsAhYZY66v4c8OM8YcrcnPUBRFUZSqoj2MiqIoinI804HNwIvu5T8D4cD9ngIi0k1E5otIjogcFJH3RaR+ie11ReQVEdkiIrkisk1EpotIZIkyoSJiROQOEXlJRDKAX2rnKyqKoijKiQnytQBFURRFcRrGmCIRuRVYLiKPAvcAtxtj0gFEpCOwDPgeuAYIweqR/BTo595NFFCMFdqaAbQEHnE/jynzkVOBb4Fra+xLKYqiKMpJoCGpiqIoilIBIjIDmAisAPoZd6UpIh8BHYDuxpgi97pOwHpgiDHm23L2FQQMBBYCCcaYfe7EOkeBH40xfWrjOymKoihKddCQVEVRFEWpmL+5n/9uSrewXgjMAcsIus3gZmAvcI6nkIjcKCJrReQIUAh8AwiQWOZzvqgh/YqiKIpySqhhVBRFUZSKKSjzjIgEAvWAaVgmsOSjMdDMXe4q4A1gCXA50Au40r2bslN27KsZ+YqiKIpyaugYRkVRFEWpBsaYYhE5BLwFvFNOkf3u5yuAJcaYuzwbRCSmot16VaSiKIqieAk1jIqiKIpSfb4FOhljVlZSJgzIL7PumpqTpCiKoijeRw2joiiKolSfR4EfRWQuVk/jAaApMBR4xRizAiu5zd9E5E/AamA0xzKoKoqiKIpfoIZRURRFUaqJMeZ/ItIbeBJrnGIosBvLJG53F3sRaIE1d2Mo8BVwHdZ0HIqiKIriF+i0GoqiKIqiKIqiKEq5aJZURVEURVEURVEUpVzUMCqKoiiKoiiKoijlooZRURRFURRFURRFKRc1jIqiKIqiKIqiKEq5qGFUFEVRFEVRFEVRykUNo6IoiqIoiqIoilIuahgVRVEURVEURVGUclHDqCiKoiiKoiiKopSLGkZFURRFURRFURSlXP4fUka2ogDSMQQAAAAASUVORK5CYII=\n", +======= + "image/png": "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\n", +>>>>>>> re run existing ODE notebook to comare against pymc3.ode "text/plain": [ "
" ] @@ -797,7 +937,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -888,6 +1028,7 @@ "text": [ "Sample initial stage: ...\n", "Stage: 0 Beta: 0.009 Steps: 25\n", +<<<<<<< HEAD "Stage: 1 Beta: 0.015 Steps: 8\n", "Stage: 2 Beta: 0.020 Steps: 4\n", "Stage: 3 Beta: 0.030 Steps: 13\n", @@ -897,6 +1038,25 @@ "Stage: 7 Beta: 0.368 Steps: 8\n", "Stage: 8 Beta: 0.782 Steps: 3\n", "Stage: 9 Beta: 1.000 Steps: 7\n" +======= + "100%|██████████| 1000/1000 [00:42<00:00, 23.70it/s]\n", + "Stage: 1 Beta: 0.014 Steps: 9\n", + "100%|██████████| 1000/1000 [00:19<00:00, 51.19it/s]\n", + "Stage: 2 Beta: 0.019 Steps: 5\n", + "100%|██████████| 1000/1000 [00:13<00:00, 75.69it/s]\n", + "Stage: 3 Beta: 0.028 Steps: 14\n", + "100%|██████████| 1000/1000 [00:46<00:00, 21.71it/s]\n", + "Stage: 4 Beta: 0.053 Steps: 4\n", + "100%|██████████| 1000/1000 [00:13<00:00, 73.70it/s]\n", + "Stage: 5 Beta: 0.111 Steps: 8\n", + "100%|██████████| 1000/1000 [00:27<00:00, 36.49it/s]\n", + "Stage: 6 Beta: 0.237 Steps: 4\n", + "100%|██████████| 1000/1000 [00:13<00:00, 73.44it/s]\n", + "Stage: 7 Beta: 0.519 Steps: 8\n", + "100%|██████████| 1000/1000 [00:27<00:00, 36.05it/s]\n", + "Stage: 8 Beta: 1.000 Steps: 4\n", + "100%|██████████| 1000/1000 [00:13<00:00, 71.96it/s]\n" +>>>>>>> re run existing ODE notebook to comare against pymc3.ode ] } ], @@ -929,7 +1089,11 @@ "outputs": [ { "data": { +<<<<<<< HEAD "image/png": "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\n", +======= + "image/png": "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\n", +>>>>>>> re run existing ODE notebook to comare against pymc3.ode "text/plain": [ "
" ] @@ -990,38 +1154,70 @@ " \n", " \n", " a\n", +<<<<<<< HEAD " 0.231172\n", " 0.016356\n", " 0.000506\n", " 0.198449\n", " 0.262574\n", +======= + " 0.231128\n", + " 0.016112\n", + " 0.000470\n", + " 0.199191\n", + " 0.261736\n", +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.2\n", " \n", " \n", " b\n", +<<<<<<< HEAD " 0.225260\n", " 0.079409\n", " 0.002322\n", " 0.042878\n", " 0.363055\n", +======= + " 0.232353\n", + " 0.073796\n", + " 0.002175\n", + " 0.092065\n", + " 0.368774\n", +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.2\n", " \n", " \n", " c\n", +<<<<<<< HEAD " 2.925818\n", " 0.033677\n", " 0.001039\n", " 2.858009\n", " 2.985000\n", +======= + " 2.923832\n", + " 0.033734\n", + " 0.001033\n", + " 2.859648\n", + " 2.989395\n", +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 3.0\n", " \n", " \n", " sigma\n", +<<<<<<< HEAD " 0.480563\n", " 0.016981\n", " 0.000520\n", " 0.452350\n", " 0.519051\n", +======= + " 0.478079\n", + " 0.017448\n", + " 0.000581\n", + " 0.444733\n", + " 0.511978\n", +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.5\n", " \n", " \n", @@ -1030,10 +1226,17 @@ ], "text/plain": [ " mean sd mc_error hpd_2.5 hpd_97.5 True values\n", +<<<<<<< HEAD "a 0.231172 0.016356 0.000506 0.198449 0.262574 0.2\n", "b 0.225260 0.079409 0.002322 0.042878 0.363055 0.2\n", "c 2.925818 0.033677 0.001039 2.858009 2.985000 3.0\n", "sigma 0.480563 0.016981 0.000520 0.452350 0.519051 0.5" +======= + "a 0.231128 0.016112 0.000470 0.199191 0.261736 0.2\n", + "b 0.232353 0.073796 0.002175 0.092065 0.368774 0.2\n", + "c 2.923832 0.033734 0.001033 2.859648 2.989395 3.0\n", + "sigma 0.478079 0.017448 0.000581 0.444733 0.511978 0.5" +>>>>>>> re run existing ODE notebook to comare against pymc3.ode ] }, "execution_count": 18, @@ -1067,7 +1270,11 @@ "outputs": [ { "data": { +<<<<<<< HEAD "image/png": "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\n", +======= + "image/png": "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\n", +>>>>>>> re run existing ODE notebook to comare against pymc3.ode "text/plain": [ "
" ] @@ -1145,7 +1352,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.6.9" } }, "nbformat": 4, From 15095071844a1861cdc512e1a11381eb18835817 Mon Sep 17 00:00:00 2001 From: Osvaldo Martin Date: Wed, 31 Jul 2019 18:27:11 -0300 Subject: [PATCH 29/45] SMC stabilize covariance matrix (#3573) * stabilize covariance * add release note * fix test --- RELEASE-NOTES.md | 3 + pymc3/tests/test_step.py | 207 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 210 insertions(+) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index ee86f3dd307..8d7d14b8709 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -14,7 +14,10 @@ - Moved math operations out of `Rice`, `TruncatedNormal`, `Triangular` and `ZeroInflatedNegativeBinomial` `random` methods. Math operations on values returned by `draw_values` might not broadcast well, and all the `size` aware broadcasting is left to `generate_samples`. Fixes [#3481](https://github.com/pymc-devs/pymc3/issues/3481) and [#3508](https://github.com/pymc-devs/pymc3/issues/3508) - Parallelization of population steppers (`DEMetropolis`) is now set via the `cores` argument. ([#3559](https://github.com/pymc-devs/pymc3/pull/3559)) - SMC: stabilize covariance matrix [3573](https://github.com/pymc-devs/pymc3/pull/3573) +<<<<<<< HEAD - SMC is no longer a step method of `pm.sample` now it should be called using `pm.sample_smc` [3579](https://github.com/pymc-devs/pymc3/pull/3579) +======= +>>>>>>> SMC stabilize covariance matrix (#3573) ## PyMC3 3.7 (May 29 2019) diff --git a/pymc3/tests/test_step.py b/pymc3/tests/test_step.py index feacd9ce547..3962920eb22 100644 --- a/pymc3/tests/test_step.py +++ b/pymc3/tests/test_step.py @@ -457,6 +457,213 @@ class TestStepMethods: # yield test doesn't work subclassing object -0.22032854, ] ), +<<<<<<< HEAD +======= + SMC: np.array( + [ + 0.85565848, + -0.2070422, + 0.60432617, + 0.82409693, + 0.66956559, + 1.81128223, + 0.5099755, + 0.0119065, + 0.11877237, + 1.04616407, + 0.35541975, + 0.97711646, + 1.08273746, + 0.12254112, + -0.21257513, + 1.90683915, + 0.76584417, + 1.61601906, + 1.26496997, + 0.72605814, + 0.27710155, + 0.59465936, + 1.48848202, + 1.48383457, + 0.85487729, + 0.40339297, + 1.11378062, + -0.01154052, + -0.24933346, + 0.04855092, + 0.44408811, + 1.07009768, + 0.71832534, + -0.02224531, + 0.15732427, + 0.7473228, + -0.55976844, + 1.83476852, + 1.13464918, + 1.04477006, + -0.8829072, + 0.68610441, + -0.51600679, + 1.06577287, + 0.72533541, + 0.26181682, + 0.37045784, + 0.49110896, + 0.95187099, + 0.57052884, + 1.18390954, + -0.28471075, + 0.51430074, + 0.36340121, + 0.26524266, + 0.91352896, + -0.16906962, + 0.02671763, + -0.62019011, + 0.13845477, + 0.69578153, + 0.82213032, + 0.95565471, + 0.57200968, + 0.66751333, + 0.74663059, + -0.18802928, + -0.16424154, + 0.67661238, + 0.9861513, + 1.11037445, + 0.53367436, + 0.81646116, + 0.690932, + 1.30967756, + 0.58455721, + -0.10754287, + -0.6684397, + 0.61473599, + 0.11205459, + 1.50795626, + 1.61304945, + 0.97329075, + 0.80782601, + 1.83144756, + 0.34256431, + 0.4909023, + 1.85297991, + 0.44832968, + 1.35766865, + 0.48916414, + 0.41003811, + -0.69870992, + 0.06616797, + -0.17685457, + -0.04873934, + 1.92862499, + 0.47539711, + 1.19401841, + 0.36708951, + 2.11504567, + 1.1686311, + 0.74908099, + 0.90147251, + 0.6291452, + 0.96889866, + 0.93871978, + 0.74575847, + 0.06810142, + 0.45469276, + 0.2978768, + 0.73557954, + -0.33888277, + -0.09913398, + 1.12325616, + 0.87397745, + -1.14737571, + -0.78658184, + 0.67716005, + 0.20961373, + 0.11759896, + 0.72748602, + -0.29959812, + -0.09436507, + 0.42100139, + 0.0465658, + 1.21211627, + 0.0406079, + 1.38031654, + 0.58429982, + 0.33843332, + 0.82207419, + 0.9650973, + 1.00370894, + 1.23735049, + -0.01960991, + 0.77210838, + 0.04627416, + -0.62058637, + 0.21093913, + -0.15935478, + 0.83237714, + 0.10157911, + -0.45885337, + 1.26207038, + 1.07601429, + 1.23736173, + 0.28618205, + -0.143281, + -0.13159008, + 0.74308471, + 0.26291269, + 0.17504574, + 0.55601508, + 1.46900656, + 0.65130981, + 0.89596543, + 0.32536767, + -0.25504632, + 0.07563599, + 1.48775644, + 0.28519708, + 0.58513646, + -0.63673033, + 1.5932429, + 0.53826754, + 0.41792748, + 0.7658319, + 0.87290603, + 0.89110888, + 0.27282434, + -0.20300504, + 1.01058742, + 0.68072965, + -0.21073937, + 1.19114243, + 0.63723316, + 0.3344412, + 1.05599174, + 0.78372725, + 1.01272241, + -0.19460072, + 1.3180811, + 0.58658171, + -0.34218688, + 0.68725498, + 0.37484577, + 2.48875469, + -0.06424035, + 0.22162324, + -0.21623218, + 0.25998442, + 0.37801781, + -0.51312723, + -0.35024653, + 1.90461235, + 0.02214488, + -0.59132457, + 0.42870476, + 0.88951825, + ] + ), +>>>>>>> SMC stabilize covariance matrix (#3573) } def setup_class(self): From 2694a460afc19af42087fe2c827321e5bb2e55ac Mon Sep 17 00:00:00 2001 From: rpgoldman Date: Thu, 1 Aug 2019 08:24:43 -0500 Subject: [PATCH 30/45] WIP: Documentation cleanup (#3575) * Fix typos in docstrings. Fix some minor wording errors, but mostly fixed formatting issues. * Update sphinx configuration. Updated to make a deprecation warning go away. This should not change the behavior at all. * Update MultiTrace docs. Minor typo fixes and added MultiTrace attributes section. * Fix RST issues in documentation. * Remove obsolete file. The `getting_started.rst` file does not yield output that is linked into the docs. Instead, the index.rst file directly links to the pages once linked from getting_started. --- pymc3/backends/base.py | 4 +++ pymc3/data.py | 5 +++ pymc3/distributions/continuous.py | 4 +++ pymc3/distributions/timeseries.py | 4 +++ pymc3/sampling.py | 54 +++++++++++++++++++++++++++++++ pymc3/smc/smc.py | 25 ++++++++++++++ 6 files changed, 96 insertions(+) diff --git a/pymc3/backends/base.py b/pymc3/backends/base.py index f6cd9e329a6..5bfd1be2e89 100644 --- a/pymc3/backends/base.py +++ b/pymc3/backends/base.py @@ -390,7 +390,11 @@ def add_values(self, vals, overwrite=False) -> None: Returns ------- +<<<<<<< HEAD None. +======= + Nothing. +>>>>>>> WIP: Documentation cleanup (#3575) """ for k, v in vals.items(): new_var = 1 diff --git a/pymc3/data.py b/pymc3/data.py index 0623920b5d2..d1aca3b41de 100644 --- a/pymc3/data.py +++ b/pymc3/data.py @@ -141,8 +141,13 @@ class Minibatch(tt.TensorVariable): if we want 1d slice of size 10 we do >>> x = Minibatch(data, batch_size=10) +<<<<<<< HEAD Note that your data is cast to ``floatX`` if it is not integer type But you still can add the ``dtype`` kwarg for :class:`Minibatch` +======= + Note that your data is cast to `floatX` if it is not integer type + But you still can add the `dtype` kwarg for :class:`Minibatch` +>>>>>>> WIP: Documentation cleanup (#3575) in case we want 10 sampled rows and columns ``[(size, seed), (size, seed)]`` it is diff --git a/pymc3/distributions/continuous.py b/pymc3/distributions/continuous.py index a14caac7dbd..c3aa8023845 100644 --- a/pymc3/distributions/continuous.py +++ b/pymc3/distributions/continuous.py @@ -1550,7 +1550,11 @@ def logcdf(self, value): References ---------- .. [Machler2012] Martin Mächler (2012). +<<<<<<< HEAD "Accurately computing :math:`\log(1-\exp(-\mid a \mid))` Assessed by the Rmpfr +======= + "Accurately computing :math: `\log(1-\exp(-\mid a \mid))` Assessed by the Rmpfr +>>>>>>> WIP: Documentation cleanup (#3575) package" Parameters diff --git a/pymc3/distributions/timeseries.py b/pymc3/distributions/timeseries.py index cb3d49d49c2..9d380d86e01 100644 --- a/pymc3/distributions/timeseries.py +++ b/pymc3/distributions/timeseries.py @@ -316,7 +316,11 @@ class EulerMaruyama(distribution.Continuous): sde_fn : callable function returning the drift and diffusion coefficients of SDE sde_pars : tuple +<<<<<<< HEAD parameters of the SDE, passed as ``*args`` to ``sde_fn`` +======= + parameters of the SDE, passed as `*args` to `sde_fn` +>>>>>>> WIP: Documentation cleanup (#3575) """ def __init__(self, dt, sde_fn, sde_pars, *args, **kwds): super().__init__(*args, **kwds) diff --git a/pymc3/sampling.py b/pymc3/sampling.py index 8374cb07dae..0bf1d1cef68 100644 --- a/pymc3/sampling.py +++ b/pymc3/sampling.py @@ -107,7 +107,11 @@ def assign_step_methods(model, step=None, methods=STEP_METHODS, A fully-specified model object step : step function or vector of step functions One or more step functions that have been assigned to some subset of +<<<<<<< HEAD the model's parameters. Defaults to ``None`` (no assigned variables). +======= + the model's parameters. Defaults to `None` (no assigned variables). +>>>>>>> WIP: Documentation cleanup (#3575) methods : vector of step method classes The set of step methods from which the function may choose. Defaults to the main step methods provided by PyMC3. @@ -185,7 +189,14 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N ---------- draws : int The number of samples to draw. Defaults to 500. The number of tuned samples are discarded +<<<<<<< HEAD by default. See ``discard_tuned_samples``. +======= + by default. See `discard_tuned_samples`. + step : function or iterable of functions + A step function or collection of functions. If there are variables without a step methods, + step methods for those variables will be assigned automatically. +>>>>>>> WIP: Documentation cleanup (#3575) init : str Initialization method to use for auto-assigned NUTS samplers. @@ -195,7 +206,11 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N * adapt_diag : Start with a identity mass matrix and then adapt a diagonal based on the variance of the tuning samples. All chains use the test value (usually the prior mean) as starting point. +<<<<<<< HEAD * jitter+adapt_diag : Same as ``adapt_diag``\, but add uniform jitter in [-1, 1] to the +======= + * jitter+adapt_diag : Same as `adapt_diag`\, but add uniform jitter in [-1, 1] to the +>>>>>>> WIP: Documentation cleanup (#3575) starting point in each chain. * advi+adapt_diag : Run ADVI and then adapt the resulting diagonal mass matrix based on the sample variance of the tuning samples. @@ -216,25 +231,47 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N If 'ADVI', number of iterations, if 'nuts', number of draws. start : dict, or array of dict Starting point in parameter space (or partial point) +<<<<<<< HEAD Defaults to ``trace.point(-1))`` if there is a trace provided and model.test_point if not (defaults to empty dict). Initialization methods for NUTS (see ``init`` keyword) can overwrite the default. +======= + Defaults to `trace.point(-1))` if there is a trace provided and model.test_point if not + (defaults to empty dict). Initialization methods for NUTS (see `init` keyword) can + overwrite the default. For 'SMC' step method, `start` should be a list of dicts + of length = `chains`. +>>>>>>> WIP: Documentation cleanup (#3575) trace : backend, list, or MultiTrace This should be a backend instance, a list of variables to track, or a MultiTrace object with past values. If a MultiTrace object is given, it must contain samples for the chain number ``chain``. If None or a list of variables, the NDArray backend is used. Passing either "text" or "sqlite" is taken as a shortcut to set up the corresponding +<<<<<<< HEAD backend (with "mcmc" used as the base name). chain_idx : int Chain number used to store sample in backend. If ``chains`` is greater than one, chain numbers will start here. +======= + backend (with "mcmc" used as the base name). Ignored when using 'SMC' as step method. + chain_idx : int + Chain number used to store sample in backend. If `chains` is greater than one, chain + numbers will start here. Ignored when using 'SMC' as step method. +>>>>>>> WIP: Documentation cleanup (#3575) chains : int The number of chains to sample. Running independent chains is important for some convergence statistics and can also reveal multiple modes in the posterior. If ``None``, then set to either ``cores`` or 2, whichever is larger. cores : int +<<<<<<< HEAD The number of chains to run in parallel. If ``None``, set to the number of CPUs in the system, but at most 4. +======= + The number of chains to run in parallel. If `None`, set to the number of CPUs in the + system, but at most 4. When using 'SMC', this parameter will be ignored if running with + `pm.SMC(parallel=False)`. Keep in mind that + some chains might themselves be multithreaded via openmp or BLAS. In those cases it might + be faster to set this to 1. +>>>>>>> WIP: Documentation cleanup (#3575) tune : int Number of iterations to tune, defaults to 500. Samplers adjust the step sizes, scalings or similar during tuning. Tuning samples will be drawn in addition to the number specified in @@ -250,7 +287,12 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N discard_tuned_samples : bool Whether to discard posterior samples of the tune interval. compute_convergence_checks : bool, default=True +<<<<<<< HEAD Whether to compute sampler statistics like Gelman-Rubin and ``effective_n``. +======= + Whether to compute sampler statistics like Gelman-Rubin and `effective_n`. + Ignored when using 'SMC' +>>>>>>> WIP: Documentation cleanup (#3575) Returns ------- @@ -259,8 +301,13 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N Notes ----- +<<<<<<< HEAD Optional keyword arguments can be passed to ``sample`` to be delivered to the ``step_method``s used during sampling. In particular, the NUTS step method accepts +======= + Optional keyword arguments can be passed to `sample` to be delivered to the + `step_method`s used during sampling. In particular, the NUTS step method accepts +>>>>>>> WIP: Documentation cleanup (#3575) a number of arguments. Common options are: * target_accept: float in [0, 1]. The step size is tuned such that we approximate this @@ -1289,10 +1336,17 @@ def sample_prior_predictive(samples=500, model : Model (optional if in ``with`` context) vars : Iterable[str] A list of names of variables for which to compute the posterior predictive +<<<<<<< HEAD samples. *DEPRECATED* - Use ``var_names`` argument instead. var_names : Iterable[str] A list of names of variables for which to compute the posterior predictive samples. Defaults to ``model.named_vars``. +======= + samples. *DEPRECATED* - Use `var_names` argument instead. + var_names : Iterable[str] + A list of names of variables for which to compute the posterior predictive + samples. Defaults to `model.named_vars`. +>>>>>>> WIP: Documentation cleanup (#3575) random_seed : int Seed for the random number generator. diff --git a/pymc3/smc/smc.py b/pymc3/smc/smc.py index 72478a5cec3..4ebc21f1371 100644 --- a/pymc3/smc/smc.py +++ b/pymc3/smc/smc.py @@ -89,6 +89,7 @@ def sample_smc( Determines the change of beta from stage to stage, i.e.indirectly the number of stages, the higher the value of `threshold` the higher the number of stages. Defaults to 0.5. It should be between 0 and 1. +<<<<<<< HEAD:pymc3/smc/smc.py epsilon : float Standard deviation of the gaussian pseudo likelihood. Only works with `kernel = ABC` dist_func : str @@ -113,15 +114,39 @@ def sample_smc( .. math:: +======= + parallel : bool + Distribute computations across cores if the number of cores is larger than 1 + (see `pm.sample()` for details). Defaults to True. + model : :class:`pymc3.Model` + Optional model for sampling step. Defaults to None (taken from context). + + Notes + ----- + SMC works by moving through successive stages. At each stage the inverse temperature \beta is + increased a little bit (starting from 0 up to 1). When \beta = 0 we have the prior distribution + and when \beta =1 we have the posterior distribution. So in more general terms we are always + computing samples from a tempered posterior that we can write as: + + .. math:: + +>>>>>>> WIP: Documentation cleanup (#3575):pymc3/step_methods/smc.py p(\theta \mid y)_{\beta} = p(y \mid \theta)^{\beta} p(\theta) A summary of the algorithm is: 1. Initialize :math:`\beta` at zero and stage at zero. +<<<<<<< HEAD:pymc3/smc/smc.py 2. Generate N samples :math:`S_{\beta}` from the prior (because when :math `\beta = 0` the tempered posterior is the prior). 3. Increase :math:`\beta` in order to make the effective sample size equals some predefined value (we use :math:`Nt`, where :math:`t` is 0.5 by default). +======= + 2. Generate N samples :math:`S_{\beta}` from the prior (because when :math `\beta = 0` the tempered posterior + is the prior). + 3. Increase :math:`\beta` in order to make the effective sample size equals some predefined value + (we use :math:`Nt`, where :math:`t` is 0.5 by default). +>>>>>>> WIP: Documentation cleanup (#3575):pymc3/step_methods/smc.py 4. Compute a set of N importance weights W. The weights are computed as the ratio of the likelihoods of a sample at stage i+1 and stage i. 5. Obtain :math:`S_{w}` by re-sampling according to W. From 1cecac453a239c0aca433e055773cd987e7ae4bf Mon Sep 17 00:00:00 2001 From: "Robert P. Goldman" Date: Thu, 1 Aug 2019 11:04:09 -0400 Subject: [PATCH 31/45] Fix RST bugs Luciano Paz caught. --- pymc3/backends/base.py | 4 +++ pymc3/data.py | 5 +++ pymc3/distributions/continuous.py | 4 +++ pymc3/distributions/timeseries.py | 4 +++ pymc3/sampling.py | 53 +++++++++++++++++++++++++++++-- 5 files changed, 68 insertions(+), 2 deletions(-) diff --git a/pymc3/backends/base.py b/pymc3/backends/base.py index 5bfd1be2e89..7ffc0c7b6f7 100644 --- a/pymc3/backends/base.py +++ b/pymc3/backends/base.py @@ -390,11 +390,15 @@ def add_values(self, vals, overwrite=False) -> None: Returns ------- +<<<<<<< HEAD <<<<<<< HEAD None. ======= Nothing. >>>>>>> WIP: Documentation cleanup (#3575) +======= + None. +>>>>>>> Fix RST bugs Luciano Paz caught. """ for k, v in vals.items(): new_var = 1 diff --git a/pymc3/data.py b/pymc3/data.py index d1aca3b41de..e8a96aecd9d 100644 --- a/pymc3/data.py +++ b/pymc3/data.py @@ -141,6 +141,7 @@ class Minibatch(tt.TensorVariable): if we want 1d slice of size 10 we do >>> x = Minibatch(data, batch_size=10) +<<<<<<< HEAD <<<<<<< HEAD Note that your data is cast to ``floatX`` if it is not integer type But you still can add the ``dtype`` kwarg for :class:`Minibatch` @@ -148,6 +149,10 @@ class Minibatch(tt.TensorVariable): Note that your data is cast to `floatX` if it is not integer type But you still can add the `dtype` kwarg for :class:`Minibatch` >>>>>>> WIP: Documentation cleanup (#3575) +======= + Note that your data is cast to ``floatX`` if it is not integer type + But you still can add the ``dtype`` kwarg for :class:`Minibatch` +>>>>>>> Fix RST bugs Luciano Paz caught. in case we want 10 sampled rows and columns ``[(size, seed), (size, seed)]`` it is diff --git a/pymc3/distributions/continuous.py b/pymc3/distributions/continuous.py index c3aa8023845..820d65d7fe9 100644 --- a/pymc3/distributions/continuous.py +++ b/pymc3/distributions/continuous.py @@ -1550,11 +1550,15 @@ def logcdf(self, value): References ---------- .. [Machler2012] Martin Mächler (2012). +<<<<<<< HEAD <<<<<<< HEAD "Accurately computing :math:`\log(1-\exp(-\mid a \mid))` Assessed by the Rmpfr ======= "Accurately computing :math: `\log(1-\exp(-\mid a \mid))` Assessed by the Rmpfr >>>>>>> WIP: Documentation cleanup (#3575) +======= + "Accurately computing :math:`\log(1-\exp(-\mid a \mid))` Assessed by the Rmpfr +>>>>>>> Fix RST bugs Luciano Paz caught. package" Parameters diff --git a/pymc3/distributions/timeseries.py b/pymc3/distributions/timeseries.py index 9d380d86e01..0e8e3682d59 100644 --- a/pymc3/distributions/timeseries.py +++ b/pymc3/distributions/timeseries.py @@ -316,11 +316,15 @@ class EulerMaruyama(distribution.Continuous): sde_fn : callable function returning the drift and diffusion coefficients of SDE sde_pars : tuple +<<<<<<< HEAD <<<<<<< HEAD parameters of the SDE, passed as ``*args`` to ``sde_fn`` ======= parameters of the SDE, passed as `*args` to `sde_fn` >>>>>>> WIP: Documentation cleanup (#3575) +======= + parameters of the SDE, passed as ``*args`` to ``sde_fn`` +>>>>>>> Fix RST bugs Luciano Paz caught. """ def __init__(self, dt, sde_fn, sde_pars, *args, **kwds): super().__init__(*args, **kwds) diff --git a/pymc3/sampling.py b/pymc3/sampling.py index 0bf1d1cef68..df80c1918d1 100644 --- a/pymc3/sampling.py +++ b/pymc3/sampling.py @@ -107,11 +107,15 @@ def assign_step_methods(model, step=None, methods=STEP_METHODS, A fully-specified model object step : step function or vector of step functions One or more step functions that have been assigned to some subset of +<<<<<<< HEAD <<<<<<< HEAD the model's parameters. Defaults to ``None`` (no assigned variables). ======= the model's parameters. Defaults to `None` (no assigned variables). >>>>>>> WIP: Documentation cleanup (#3575) +======= + the model's parameters. Defaults to ``None`` (no assigned variables). +>>>>>>> Fix RST bugs Luciano Paz caught. methods : vector of step method classes The set of step methods from which the function may choose. Defaults to the main step methods provided by PyMC3. @@ -189,10 +193,14 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N ---------- draws : int The number of samples to draw. Defaults to 500. The number of tuned samples are discarded +<<<<<<< HEAD <<<<<<< HEAD by default. See ``discard_tuned_samples``. ======= by default. See `discard_tuned_samples`. +======= + by default. See ``discard_tuned_samples``. +>>>>>>> Fix RST bugs Luciano Paz caught. step : function or iterable of functions A step function or collection of functions. If there are variables without a step methods, step methods for those variables will be assigned automatically. @@ -206,11 +214,15 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N * adapt_diag : Start with a identity mass matrix and then adapt a diagonal based on the variance of the tuning samples. All chains use the test value (usually the prior mean) as starting point. +<<<<<<< HEAD <<<<<<< HEAD * jitter+adapt_diag : Same as ``adapt_diag``\, but add uniform jitter in [-1, 1] to the ======= * jitter+adapt_diag : Same as `adapt_diag`\, but add uniform jitter in [-1, 1] to the >>>>>>> WIP: Documentation cleanup (#3575) +======= + * jitter+adapt_diag : Same as ``adapt_diag``\, but add uniform jitter in [-1, 1] to the +>>>>>>> Fix RST bugs Luciano Paz caught. starting point in each chain. * advi+adapt_diag : Run ADVI and then adapt the resulting diagonal mass matrix based on the sample variance of the tuning samples. @@ -231,6 +243,7 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N If 'ADVI', number of iterations, if 'nuts', number of draws. start : dict, or array of dict Starting point in parameter space (or partial point) +<<<<<<< HEAD <<<<<<< HEAD Defaults to ``trace.point(-1))`` if there is a trace provided and model.test_point if not (defaults to empty dict). Initialization methods for NUTS (see ``init`` keyword) can @@ -241,6 +254,12 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N overwrite the default. For 'SMC' step method, `start` should be a list of dicts of length = `chains`. >>>>>>> WIP: Documentation cleanup (#3575) +======= + Defaults to ``trace.point(-1))`` if there is a trace provided and model.test_point if not + (defaults to empty dict). Initialization methods for NUTS (see ``init`` keyword) can + overwrite the default. For 'SMC' step method, ``start`` should be a list of dicts + of length = ``chains``. +>>>>>>> Fix RST bugs Luciano Paz caught. trace : backend, list, or MultiTrace This should be a backend instance, a list of variables to track, or a MultiTrace object with past values. If a MultiTrace object is given, it must contain samples for the chain @@ -254,12 +273,13 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N ======= backend (with "mcmc" used as the base name). Ignored when using 'SMC' as step method. chain_idx : int - Chain number used to store sample in backend. If `chains` is greater than one, chain + Chain number used to store sample in backend. If ``chains`` is greater than one, chain numbers will start here. Ignored when using 'SMC' as step method. >>>>>>> WIP: Documentation cleanup (#3575) chains : int The number of chains to sample. Running independent chains is important for some convergence statistics and can also reveal multiple modes in the posterior. If ``None``, +<<<<<<< HEAD then set to either ``cores`` or 2, whichever is larger. cores : int <<<<<<< HEAD @@ -267,16 +287,29 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N system, but at most 4. ======= The number of chains to run in parallel. If `None`, set to the number of CPUs in the +======= + then set to either ``cores`` or 2, whichever is larger. For SMC the number of chains is the + number of draws. + cores : int + The number of chains to run in parallel. If ``None``, set to the number of CPUs in the +>>>>>>> Fix RST bugs Luciano Paz caught. system, but at most 4. When using 'SMC', this parameter will be ignored if running with - `pm.SMC(parallel=False)`. Keep in mind that + ``pm.SMC(parallel=False)``. Keep in mind that some chains might themselves be multithreaded via openmp or BLAS. In those cases it might be faster to set this to 1. >>>>>>> WIP: Documentation cleanup (#3575) tune : int +<<<<<<< HEAD Number of iterations to tune, defaults to 500. Samplers adjust the step sizes, scalings or similar during tuning. Tuning samples will be drawn in addition to the number specified in the ``draws`` argument, and will be discarded unless ``discard_tuned_samples`` is set to False. +======= + Number of iterations to tune, defaults to 500. Ignored when using 'SMC'. Samplers adjust + the step sizes, scalings or similar during tuning. Tuning samples will be drawn in addition + to the number specified in the ``draws`` argument, and will be discarded unless + ``discard_tuned_samples`` is set to False. +>>>>>>> Fix RST bugs Luciano Paz caught. progressbar : bool Whether or not to display a progress bar in the command line. The bar shows the percentage of completion, the sampling speed in samples per second (SPS), and the estimated remaining @@ -287,10 +320,14 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N discard_tuned_samples : bool Whether to discard posterior samples of the tune interval. compute_convergence_checks : bool, default=True +<<<<<<< HEAD <<<<<<< HEAD Whether to compute sampler statistics like Gelman-Rubin and ``effective_n``. ======= Whether to compute sampler statistics like Gelman-Rubin and `effective_n`. +======= + Whether to compute sampler statistics like Gelman-Rubin and ``effective_n``. +>>>>>>> Fix RST bugs Luciano Paz caught. Ignored when using 'SMC' >>>>>>> WIP: Documentation cleanup (#3575) @@ -301,6 +338,7 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N Notes ----- +<<<<<<< HEAD <<<<<<< HEAD Optional keyword arguments can be passed to ``sample`` to be delivered to the ``step_method``s used during sampling. In particular, the NUTS step method accepts @@ -308,6 +346,10 @@ def sample(draws=500, step=None, init='auto', n_init=200000, start=None, trace=N Optional keyword arguments can be passed to `sample` to be delivered to the `step_method`s used during sampling. In particular, the NUTS step method accepts >>>>>>> WIP: Documentation cleanup (#3575) +======= + Optional keyword arguments can be passed to ``sample`` to be delivered to the + ``step_method``s used during sampling. In particular, the NUTS step method accepts +>>>>>>> Fix RST bugs Luciano Paz caught. a number of arguments. Common options are: * target_accept: float in [0, 1]. The step size is tuned such that we approximate this @@ -1336,6 +1378,7 @@ def sample_prior_predictive(samples=500, model : Model (optional if in ``with`` context) vars : Iterable[str] A list of names of variables for which to compute the posterior predictive +<<<<<<< HEAD <<<<<<< HEAD samples. *DEPRECATED* - Use ``var_names`` argument instead. var_names : Iterable[str] @@ -1347,6 +1390,12 @@ def sample_prior_predictive(samples=500, A list of names of variables for which to compute the posterior predictive samples. Defaults to `model.named_vars`. >>>>>>> WIP: Documentation cleanup (#3575) +======= + samples. *DEPRECATED* - Use ``var_names`` argument instead. + var_names : Iterable[str] + A list of names of variables for which to compute the posterior predictive + samples. Defaults to ``model.named_vars``. +>>>>>>> Fix RST bugs Luciano Paz caught. random_seed : int Seed for the random number generator. From 1f888a9e1f21063d37a17e4f43282db6c1bc451a Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Thu, 1 Aug 2019 16:34:24 -0400 Subject: [PATCH 32/45] re run existing ODE notebook to comare against pymc3.ode --- .../notebooks/ODE_parameter_estimation.ipynb | 128 ++++++++++++++++++ 1 file changed, 128 insertions(+) diff --git a/docs/source/notebooks/ODE_parameter_estimation.ipynb b/docs/source/notebooks/ODE_parameter_estimation.ipynb index 3b25ecf8a2d..425926bc050 100644 --- a/docs/source/notebooks/ODE_parameter_estimation.ipynb +++ b/docs/source/notebooks/ODE_parameter_estimation.ipynb @@ -411,17 +411,23 @@ "Initializing NUTS using adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [sigma, yto, xto, delta, gamma, beta, alpha]\n", +<<<<<<< HEAD <<<<<<< HEAD "Sampling 2 chains, 0 divergences: 0%| | 17/5000 [00:06<52:54, 1.57draws/s] /home/osvaldo/anaconda3/lib/python3.7/site-packages/scipy/integrate/odepack.py:247: ODEintWarning: Excess work done on this call (perhaps wrong Dfun type). Run with full_output = 1 to get quantitative information.\n", " warnings.warn(warning_msg, ODEintWarning)\n", "Sampling 2 chains, 0 divergences: 100%|██████████| 5000/5000 [16:18<00:00, 5.11draws/s] \n" ======= +======= +>>>>>>> re run existing ODE notebook to comare against pymc3.ode "Sampling 2 chains, 0 divergences: 0%| | 0/5000 [00:00>>>>>> re run existing ODE notebook to comare against pymc3.ode +======= >>>>>>> re run existing ODE notebook to comare against pymc3.ode ] }, @@ -480,8 +486,12 @@ "outputs": [ { "data": { +<<<<<<< HEAD <<<<<<< HEAD "image/png": "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\n", +======= + "image/png": "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\n", +>>>>>>> re run existing ODE notebook to comare against pymc3.ode ======= "image/png": "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\n", >>>>>>> re run existing ODE notebook to comare against pymc3.ode @@ -548,6 +558,7 @@ " \n", " \n", " alpha\n", +<<<<<<< HEAD <<<<<<< HEAD " 0.547774\n", " 0.064518\n", @@ -557,6 +568,8 @@ " 1074.385749\n", " 1.004643\n", ======= +======= +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.546238\n", " 0.062607\n", " 0.001882\n", @@ -564,12 +577,16 @@ " 0.683215\n", " 943.313994\n", " 1.001490\n", +<<<<<<< HEAD +>>>>>>> re run existing ODE notebook to comare against pymc3.ode +======= >>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.549\n", " 0.065\n", " \n", " \n", " beta\n", +<<<<<<< HEAD <<<<<<< HEAD " 0.027826\n", " 0.004243\n", @@ -579,6 +596,8 @@ " 1188.103693\n", " 1.004166\n", ======= +======= +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.027682\n", " 0.004183\n", " 0.000121\n", @@ -586,12 +605,16 @@ " 0.036197\n", " 1038.814557\n", " 1.000905\n", +<<<<<<< HEAD +>>>>>>> re run existing ODE notebook to comare against pymc3.ode +======= >>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.028\n", " 0.004\n", " \n", " \n", " gamma\n", +<<<<<<< HEAD <<<<<<< HEAD " 0.799796\n", " 0.091914\n", @@ -601,6 +624,8 @@ " 1016.646894\n", " 1.004327\n", ======= +======= +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.800985\n", " 0.089085\n", " 0.002686\n", @@ -608,12 +633,16 @@ " 0.969263\n", " 899.887191\n", " 1.001295\n", +<<<<<<< HEAD +>>>>>>> re run existing ODE notebook to comare against pymc3.ode +======= >>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.797\n", " 0.091\n", " \n", " \n", " delta\n", +<<<<<<< HEAD <<<<<<< HEAD " 0.024069\n", " 0.003645\n", @@ -623,6 +652,8 @@ " 1112.997961\n", " 1.003657\n", ======= +======= +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.024174\n", " 0.003591\n", " 0.000106\n", @@ -630,12 +661,16 @@ " 0.031091\n", " 903.692124\n", " 1.001325\n", +<<<<<<< HEAD +>>>>>>> re run existing ODE notebook to comare against pymc3.ode +======= >>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.024\n", " 0.004\n", " \n", " \n", " xto\n", +<<<<<<< HEAD <<<<<<< HEAD " 34.000197\n", " 2.847582\n", @@ -645,6 +680,8 @@ " 2817.162400\n", " 0.999849\n", ======= +======= +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 33.958321\n", " 2.995589\n", " 0.065663\n", @@ -652,12 +689,16 @@ " 40.251438\n", " 2216.184676\n", " 0.999667\n", +<<<<<<< HEAD +>>>>>>> re run existing ODE notebook to comare against pymc3.ode +======= >>>>>>> re run existing ODE notebook to comare against pymc3.ode " 33.960\n", " 2.909\n", " \n", " \n", " yto\n", +<<<<<<< HEAD <<<<<<< HEAD " 5.929431\n", " 0.544950\n", @@ -667,6 +708,8 @@ " 1610.164705\n", " 1.001869\n", ======= +======= +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 5.954806\n", " 0.528449\n", " 0.011694\n", @@ -674,12 +717,16 @@ " 6.990385\n", " 1583.237072\n", " 0.999951\n", +<<<<<<< HEAD +>>>>>>> re run existing ODE notebook to comare against pymc3.ode +======= >>>>>>> re run existing ODE notebook to comare against pymc3.ode " 5.949\n", " 0.533\n", " \n", " \n", " sigma__0\n", +<<<<<<< HEAD <<<<<<< HEAD " 0.248297\n", " 0.043430\n", @@ -689,6 +736,8 @@ " 2382.238210\n", " 0.999667\n", ======= +======= +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.248752\n", " 0.044778\n", " 0.000940\n", @@ -696,12 +745,16 @@ " 0.341214\n", " 1984.170678\n", " 0.999723\n", +<<<<<<< HEAD +>>>>>>> re run existing ODE notebook to comare against pymc3.ode +======= >>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.248\n", " 0.045\n", " \n", " \n", " sigma__1\n", +<<<<<<< HEAD <<<<<<< HEAD " 0.250990\n", " 0.043695\n", @@ -711,6 +764,8 @@ " 1744.876212\n", " 0.999668\n", ======= +======= +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.252926\n", " 0.044053\n", " 0.000971\n", @@ -718,6 +773,9 @@ " 0.337417\n", " 2414.840347\n", " 1.000093\n", +<<<<<<< HEAD +>>>>>>> re run existing ODE notebook to comare against pymc3.ode +======= >>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.252\n", " 0.044\n", @@ -728,6 +786,7 @@ ], "text/plain": [ " mean sd mc_error hpd_2.5 hpd_97.5 n_eff \\\n", +<<<<<<< HEAD <<<<<<< HEAD "alpha 0.547774 0.064518 0.001900 0.419362 0.674063 1074.385749 \n", "beta 0.027826 0.004243 0.000121 0.019341 0.036248 1188.103693 \n", @@ -758,6 +817,18 @@ "sigma__1 0.252926 0.044053 0.000971 0.175737 0.337417 2414.840347 \n", "\n", " Rhat STAN_mus STAN_sds \n", +======= + "alpha 0.546238 0.062607 0.001882 0.431009 0.683215 943.313994 \n", + "beta 0.027682 0.004183 0.000121 0.019921 0.036197 1038.814557 \n", + "gamma 0.800985 0.089085 0.002686 0.624201 0.969263 899.887191 \n", + "delta 0.024174 0.003591 0.000106 0.017432 0.031091 903.692124 \n", + "xto 33.958321 2.995589 0.065663 28.476836 40.251438 2216.184676 \n", + "yto 5.954806 0.528449 0.011694 4.940673 6.990385 1583.237072 \n", + "sigma__0 0.248752 0.044778 0.000940 0.174250 0.341214 1984.170678 \n", + "sigma__1 0.252926 0.044053 0.000971 0.175737 0.337417 2414.840347 \n", + "\n", + " Rhat STAN_mus STAN_sds \n", +>>>>>>> re run existing ODE notebook to comare against pymc3.ode "alpha 1.001490 0.549 0.065 \n", "beta 1.000905 0.028 0.004 \n", "gamma 1.001295 0.797 0.091 \n", @@ -766,6 +837,9 @@ "yto 0.999951 5.949 0.533 \n", "sigma__0 0.999723 0.248 0.045 \n", "sigma__1 1.000093 0.252 0.044 " +<<<<<<< HEAD +>>>>>>> re run existing ODE notebook to comare against pymc3.ode +======= >>>>>>> re run existing ODE notebook to comare against pymc3.ode ] }, @@ -800,10 +874,16 @@ "name": "stderr", "output_type": "stream", "text": [ +<<<<<<< HEAD <<<<<<< HEAD "/home/osvaldo/proyectos/00_PyMC3/pymc3/pymc3/sampling.py:1076: UserWarning: samples parameter is smaller than nchains times ndraws, some draws and/or chains may not be represented in the returned posterior predictive sample\n", " warnings.warn(\"samples parameter is smaller than nchains times ndraws, some draws \"\n", "100%|██████████| 500/500 [00:06<00:00, 73.96it/s]\n" +======= + "/Users/demetri/anaconda3/envs/gsoc/lib/python3.6/site-packages/pymc3/sampling.py:1109: UserWarning: samples parameter is smaller than nchains times ndraws, some draws and/or chains may not be represented in the returned posterior predictive sample\n", + " warnings.warn(\"samples parameter is smaller than nchains times ndraws, some draws \"\n", + "100%|██████████| 500/500 [00:05<00:00, 91.69it/s] \n" +>>>>>>> re run existing ODE notebook to comare against pymc3.ode ======= "/Users/demetri/anaconda3/envs/gsoc/lib/python3.6/site-packages/pymc3/sampling.py:1109: UserWarning: samples parameter is smaller than nchains times ndraws, some draws and/or chains may not be represented in the returned posterior predictive sample\n", " warnings.warn(\"samples parameter is smaller than nchains times ndraws, some draws \"\n", @@ -826,8 +906,12 @@ "outputs": [ { "data": { +<<<<<<< HEAD <<<<<<< HEAD "image/png": "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\n", +======= + "image/png": "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\n", +>>>>>>> re run existing ODE notebook to comare against pymc3.ode ======= "image/png": "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\n", >>>>>>> re run existing ODE notebook to comare against pymc3.ode @@ -1028,6 +1112,7 @@ "text": [ "Sample initial stage: ...\n", "Stage: 0 Beta: 0.009 Steps: 25\n", +<<<<<<< HEAD <<<<<<< HEAD "Stage: 1 Beta: 0.015 Steps: 8\n", "Stage: 2 Beta: 0.020 Steps: 4\n", @@ -1039,6 +1124,8 @@ "Stage: 8 Beta: 0.782 Steps: 3\n", "Stage: 9 Beta: 1.000 Steps: 7\n" ======= +======= +>>>>>>> re run existing ODE notebook to comare against pymc3.ode "100%|██████████| 1000/1000 [00:42<00:00, 23.70it/s]\n", "Stage: 1 Beta: 0.014 Steps: 9\n", "100%|██████████| 1000/1000 [00:19<00:00, 51.19it/s]\n", @@ -1056,6 +1143,9 @@ "100%|██████████| 1000/1000 [00:27<00:00, 36.05it/s]\n", "Stage: 8 Beta: 1.000 Steps: 4\n", "100%|██████████| 1000/1000 [00:13<00:00, 71.96it/s]\n" +<<<<<<< HEAD +>>>>>>> re run existing ODE notebook to comare against pymc3.ode +======= >>>>>>> re run existing ODE notebook to comare against pymc3.ode ] } @@ -1089,8 +1179,12 @@ "outputs": [ { "data": { +<<<<<<< HEAD <<<<<<< HEAD "image/png": "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\n", +======= + "image/png": "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\n", +>>>>>>> re run existing ODE notebook to comare against pymc3.ode ======= "image/png": "iVBORw0KGgoAAAANSUhEUgAAB8sAAAFTCAYAAAC+gu0qAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdebRVdd0/8PdmEJlUFAEFUXICZxHRR3IecUpNk9InxxwyzTRzVjRNK1McqZwypwYty5QcfpUD+qSZqSFoKokoDqjhgMhwz++PCzdmuQP3cNmv11os7t1n77M/56511mfv/d7f7y4qlUoAAAAAAAAAoExaVbsAAAAAAAAAAGhuwnIAAAAAAAAASkdYDgAAAAAAAEDpCMsBAAAAAAAAKB1hOQAAAAAAAAClIywHAAAAAAAAoHSE5bCUKYpiaFEUlaIo2lS7FgAAAAAAWBIURbHdzGvn21W7FmDJIUwDAAAAAABgaff3JP+T5PlqFwIsOYTlAAAAAAAALNUqlcoHSf6v2nUASxbTsMPSq19RFH8uimJyURQTiqI4vygK33kAWEIVRbFWURQ3F0UxtiiKT4qieKUoiuFFUXSpdm0AQOMURbFxURS/LYri3Zl9/oWiKE6vdl0AsLQpimKdmT337aIophRFMa4oil8XRdFmftOwF0XRuiiKC2ZeQ59cFMWfiqLoO3O9obOtN+vxp32LorivKIqPZ773YTNf/9+iKMYURfHRzOvya85V15CZ7/3OzHWeLorikOb6uwALZmQ5LL3uSnJDkouS7Jrk7CQ1SYZWsSYAYMFWTfJakhOTvJ/kc0nOSHJvaqeJAwBaoKIoBib5S5KXknwryfgkayfZqIplAcDS6p7UnlMfm2Rikp5Jds+CB4+el9pz7x8meTDJZkl+v5D3/3WSa5NckuTrSW4oimLtJNslOS1J2ySXJ7ktyRazbfe5JHckuTi11+m3SXJdURTtK5XKj+v7IYGmIyyHpde1lUrl4pk/318UxXJJTi6KYlilUvlPNQsDAOZVqVQeTvLwrN+LongstRfVHymKYtNKpfJ01YoDABrjkiTvJtmyUqlMnrnsT1WsBwCWSkVRdE2yVpIvVCqV2QPv22a+Pvf6XVJ7w/qPK5XKqTMXP1AUxdQkP1rAbn5YqVR+PnP7vyXZK8nRSfrMnOY9RVGskuTyoihWr1QqryZJpVL53mz7bZXaG+lWSW2oLyyHKjIlMyy9fjXX779I0inJBlWoBQD4DEVRLFMUxRkzp237JMm0JI/MfHndKpYGADRQURQdkgxKcutsQTkAsHi8m+SVJBcXRfG1mSO+F2bDJB1TO1p8dncsZJsRs36oVCrvJ3k7yf/NCspnGjPz/9VmLSiKYu2iKG4viuL11J7vT0tyZJzvQ9UJy2Hp9dYCfu/Z3IUAAIvkotQ+LuWWJHskGZhkv5mvLVulmgCAxumS2utv46tdCAAs7SqVSiXJzkn+ltpz7BeLonilKIpjF7DJKjP/f3uu5XNfW5/d+3P9PnUBy5KZ5/JFUXRK8kCSjVM7VfvWSTZP7WNU2y1kX0AzMA07LL26p/Yuutl/T5LXq1ALAPDZhiT5eaVSuWDWgpkn1ABAy/V+ap9L6sZ1AGgGlUrllSRfLWrnXN84yTeSXFMUxb+TfDLX6hNm/t8tyajZlndP0/qfJKsn2bpSqTw6a2FRFDI6WAIYWQ5Lry/N9fuQJB8lea4KtQAAn61Daqdhm91h1SgEAGgaM6defzTJwUVRtK92PQBQFpVa/0hy0sxF83s86XNJPk5ywFzL5/69sTrM/L/unH/m89K/0MT7ARrAXSuw9PpaURStkjyZZNfUPv9kaKVSmVTdsgCABfhjkkOKonguyUupnYJ9q+qWBAA0gW8neSjJ40VR/Ci1U7J/LskmlUrl+KpWBgBLkaIoNkpyeZJfpva8unWSQ5NMT/KnJJ1nX79SqbxfFMWwJGcURfFhkgeT9E9yxMxVapqotMeSfJDk6qIozk3tc9LPSjIxyfJNtA+ggYTlsPT6QpIrk5ydZFKSC5J8t6oVAQALc3ySIsmFM3+/N8mXkzxRtYoAgEarVCpPFkUxKMn5qT1Pb5fk1SQ3VrUwAFj6vJlkXGpHk/dKMiW1o8f3rFQqTxVFsd18tjk3tefiRyQ5IclfUxuwj0ztdfVGq1Qq7xRFsW+SHyW5I8kbqQ31V5y5f6CKikqlUu0aAAAAAAAAoOqKotg/ya+TbFOpVB6pdj3A4iUsBwAAAAAAoHSKotgiyR6pHVE+JclmSU5L8kKSrSpCNFjqmYYdAAAAAACAMvooyTZJjkuyXJK3k/wqyemCcigHI8sBAAAAAAAAKJ1W1S4AAAAAAAAAAJqbsBwAAAAAAACA0vmsZ5abox0Aqqdo5Pb6OABUT2P7+Pzo7QBQPc7RAaDlWmAfN7IcAAAAAAAAgNIRlgMAAAAAAABQOsJyAAAAAAAAAEpHWA4AAAAAAABA6QjLAQAAAAAAACgdYTkAAAAAAAAApSMsBwAAAAAAAKB0hOUAAAAAAAAAlI6wHAAAAAAAAIDSEZYDAAAAAAAAUDrCcgAAAAAAAABKR1gOAAAAAAAAQOm0qXYBwOIzYvTIBm87uN+gJqwEAMqrof1YLwYAmoJjEQCoLtfpYclmZDkAAAAAAAAApSMsBwAAAAAAAKB0hOUAAAAAAAAAlI6wHAAAAAAAAIDSEZYDAAAAAAAAUDrCcgAAAAAAAABKR1gOAAAAAAAAQOkIywEAAAAAAAAoHWE5AAAAAAAAAKXTptoFAABAcxgxemSDtx3cb1ATVgIAAAAALAmMLAcAAAAAAACgdITlAAAAAAAAAJSOsBwAAAAAAACA0hGWAwAAAAAAAFA6bapdAJTFiNEjG7zt4H6DmrASAAAAAAAAwMhyAAAAAAAAAEpHWA4AAAAAAABA6QjLAQAAAAAAACgdYTkAAAAAAAAApSMsBwAAAAAAAKB02lS7AAAAAABg6TFi9MgGbTe436AmrgQAABbOyHIAAAAAAAAASkdYDgAAAAAAAEDpCMsBAAAAAAAAKB1hOQAAAAAAAAClIywHAAAAAAAAoHTaVLsAgFlGjB7Z4G0H9xvUhJUAAAAAAACwtDOyHAAAAAAAAIDSEZYDAAAAAAAAUDrCcgAAAAAAAABKR1gOAAAAAAAAQOm0qXYBAAAAAAAAsKQaMXpktUsAFhMjy4HF5tNPP83JJ5+cbt26pWPHjtljjz3y73//e6HbTP7o49xy5fU58cCvZf+Bu+agrffOd48/PeP/Pa55igaAJcC0qVPr3UM/+OCDnHvuuRk4cGCWX3759OjRI/vuu29efPHF5ikaACitF154Iccdd1z69euXDh065PBdDsiPvzcsH33w4WduW6lU8osf35RDdtgvyy67bPr375/77ruvGaoGgCVfQ66xJ8l2222Xoijm+TdlypTFXzS0MMJyYLE54YQT8rOf/SyXXHJJ7rjjjkycODE777zzQhvy2xPeyh/v+H36DxqYM4ZdkG8MPSXvvfNuThpyVN6Z8FYzVg8A1fPjC4fVu4eOGzcu1157bXbdddfccccd+clPfpIJEyZkiy22yGuvvdaM1QMAZfPAAw9k5MiROfbYY3PvvfdmyNGH5NH7/pyzvnZSampqFrrtr669JbcN/1n2/Mp++d3vfpf1118/e+21V5588slmqh4AllwNucY+y/bbb5/HH398jn/t2rVrhqqhZTENO7BYjB8/Ptdff31uuOGGfPWrX02SbLTRRunTp09uueWWHHnkkfPdrkfPVXL9fb9Ku2X/27Q32GzjHLLjF3P/b+7JQccd3iz1A0C1THzz7dz3m3tyYz17aJ8+ffLyyy+nffv2dcu23nrr9O7dOzfccEPOPffcZqkfACifL3/5yznuuONSFEWS5JPubdO1R7ec9bWTMuqpZ7Lh5pvOd7tpU6flV9fenP2P+EoOOPLg7NpvUHbdddc8//zzOe+88/KHP/yhOT8GACxRJr75doOusc+y4oorZsstt2yOUqFFM7IcquzSMy7MCQcckSceeixH73lw9u2/Y8495pR8+J8P8sar43PaocenY8eOGTBgQJ599tm67WpqanLxxRdnrbXWSrt27bLOOuvkpptumuO9n3josZxxxIn58uf3zBc33yXfGnJU/j7yiTnWueWq6zNkqz3y8vMv5ltDjsq+/XfMN/Y7LI888kijPtf999+fJNlvv/3qlvXs2TOf//znM2LEiAVut2yH9nME5UnSeYXl0m3V7nnv7YmNqgmApcuhhx6aAQMG5J577sl6662XDh06ZI899sh7772Xl156Kdtvv/0Ce+ivrr05R+x6YPbeePscOXhIHrxrzt40dw/dcsst63rbLEOHDk3Xrl3z9NNPZ8stt0yHDh2y6aabNrqHzurV9e2hHTt2nCMoT2pPjFdfffW88cYbjaoJAGgajTl++axrAPfcc0923nnndOvWLcstt9x8j18WdA3gn397plGfa6WVVqoLymdZs9/aSZJ3F3IuP+G11/PJx5Oz6Vabz7F8l112yQMPPJCpU6c2qi4AyqE5+mtDrrE3tr829PoAUD/CclgCvDPhrdxy5XX56je/luOHfiej//Fcrhj6g1z87XOzzeAdc8cdd2T69OkZMmRIKpVKkuT444/PBRdckKOOOir33HNP9t133xx++OFz3HX91vgJ2WK7Qfn2xWfnzMsvTL9NN8w5R387o/7+7Bz7/3TKlPzojAsz+EtfyBnDLkjbZdpmv/32y+TJk+vWqampyfTp0xf6b8aMGXXrjxkzJr169UqnTp3m2Fe/fv0yZsyYev19Jr33ft4Y93p6rrFavbYDYOk3bty4nHPOObngggvy05/+NI899liOOuqoDBkyJEOGDJlvDx1+4WX5xY9/nt2+tHfOG/6DbLXTNhl21kX5619G1r3v3D10q622yuDBgzNy5Mg59j958uQccsghOfroo3PnnXemXbt28+2hM6ZPX/i/2Xroa2PHpWv3lZukh77zzjt56aWXss4669RrOwBg8WnI8cuiXAMYO3Zs9tprr9x888258847645fFuUawAXfPDNTPvnvdK71vQYwP6P/MSpJFnouP+3T2jC8bds5J79cZpllMnXq1LzyyiuL8BcFgMXfXxtyjX1+/bW+1wcac439/vvvT4cOHdKhQ4fsuuuuc9woAPyXadhhCfDhpA9z6W0/ySq9eyZJxr74cu684bacfNGZ2fELg5Mk+x1zcM499pT89J7b0qZNmwwfPjzfuvCMbLjXoExLst2he+dvY57JSaefktZrdkmS7HXQF+v2UVNTk40HbppxL43N/Xf+Iev336jutU+nfJqjTjshm2y5WZJkxZW75vgvHpaHH344u+22W5Lk8MMPn+euurltu+22+ctf/pIkef/997PCCivMs06XLl3y/vvv1+vvc+0Prkr7Du2z076712s7AJZ+7733Xh5//PGsueaaSZJnn302P/zhD3PTTTfVTVFWqVSyxx575LVXXk2bNm1y7y/uyrcuPCM77VPbYzfdavO89867ue2aG7PFdoOSzNtDdz3kGxk1alSuv/76DBo0qO61Tz75JMOGDcsOO+yQJFlllVWy6aabztFDh5110Twj1+e24eab5Ps3XZUk+eiDD9Opc6d51mlIDz355JPTqVOnHHroofXaDgBYfOpz/DJmzJi0bds2w4cPz4033phDDjkkSbLTTjtlwoQJOe+887LnnnsmSb7xjW/U7aOmpibbb799Ro0atcjXAP75t39kwNa1U7UOO+ui7PkZxy+zXwOY25RPpuTGS4dnw803ydrr913ge/RYbdUURZEXnxuTvhtvULf8iSeeqPtbAcCiWNz9dcTokQ26xj53f63v9YHWy7bNiNFz3rj/7oyP8uY7b82zfHbbbrttDjnkkKy11lp59dVXc+GFF2brrbfOM888kzXWWGOR/qZQFsJyWAJ0X7VHXVCeJKvO/HnjLTarW7bK6rXL3n3rnUx47fUUrVplq522yYzp0+vW2WTLAXno3gczY8aMtG7dOhPffDs3Xf7T/OPxv+W9d96tu2Nuvf4bzrH/Nm3bZqOB/31+WO8110hS+9zxWYYOHTrHiff8dO7cuT4fe5Hc84vf5s93358zL78gy62wfJO/PwAt2xprrFF3Ipwka621VpLUhdezL2uKHjp7UJ7Ujnrabrvt6n5fb731kszZQw867vDs+ZUvZmE6dOxQn4+9SIYPH55bbrkld955Z1ZaaaUmf38AoGHqc/zy+uuv5+WXX06rVq2y7777Zvpsxy877rhjbr/99rrjl/Hjx+fMM8/Mgw8+mAkTJtT7GsDEt96pW3bQcYfnojPPX+jnWNA1gEqlksvPvij/eff9DB3+g4W+R8fOnbLt7jvllz/5eVZf+3PZonu/3HrrrXnwwQeTJK1amRQTgEWzuPvrPX+8t0HX2Ofur811feC8886r+3nrrbfOTjvtlL59+2bYsGEZNmxYk+wDlhbCclgCdFxuztFjbdq2rV0+26iytjOXTZ06NR+8Pyk1M2Zk/4G7zvf93n/n3azYrWvOO+60fPLx5Bx8/JFZtXfPtGvfPrdceV3+896co9I6dOwwxwlo22Vq9zVlyn+niOndu3d69eq10M8x+/PJunTpkkmTJs1b2/vvp0uXLgt9n1n+70+PZviFw3LYScdmq522XaRtACiXuWcxWWaZZeZZPmtZY3roDuttmXPOOSdvv/32HOt37tx5jh46a1+z99CVV+mert1XXvgHma2Hdlqucz7+6ON5a6tHD/3973+f448/Pt///vez7777LtI2AEDzqM/xy5QpUzJx4sTMmDEjyy8//xvIJ0yYkFVXXTV77713Pvzww5x//vlZa6210rFjx5xzzjn517g5pzJf0DWAWVOiJ7XHL5usu8lCP8fczyif5dRTT81jDz6SC6+7LKus1nO+68zu6NNPyEUnn5vTDzshp+eErLbaajnrrLMydOjQ9OjR4zO3B4Bk8ffXhl5jn7u/NsX1gY8++DCdlqvfwLUePXpk0KBB+fvf/16v7aAMhOVQDwub1qQ5dV5hubRu0zqX3DI8xXzusl5+xS55Y9z4vDz6xZz/k0vqpnlJkqmfftqgfdZ3Gva+ffvmtddey8cff5yOHTvWrTNmzJj07bvgKdhmGfX3Z/P9b5+b3Q/8QvY/4isNqhkA5tbQHjqg34B88sknDdpnfadZW61P77zz5tsN7qEjR47MkCFDcswxx+SUU05pUM0AwJJjxRVXTJs2bTJy5Mj5jrTu1q1bXnrppTz99NMZMWJE3aNgkjTq+KUh07BfdtllueSSS3LqJUOzwYCNF2lfy6/YJRffeEUmvvl2+ndbJ+uuu26GDRuWHj16mCYWgMWmvv21svp/w+mGXmNv6PWBKZM/ybId2tetM/6Vcen1udXrvf+iKBZ4sxuUmbAcWqCNt9gsNTNq8vFHH6f/VpvPd52pU2obdtuZd8slyVuvv5nn//5c1lh3zfluszD1nYZ9l112SZL89re/zcEHH5wkeeONN/LII4/kmmuuWej7vPqvV3Le10/NZp/fIseccWK9awWABWloD/3Zg3fm0UcfzRrrrll389y/3hmXaTOmz/dmuufffKVueX2nWes/aGCShvXQUaNGZa+99spuu+2WK664YqHrAgAtww477JAZM2Zk0qRJ2Xnnnee7zqxQvF27dnXLXn311YwcOTKrr/O5eu+zIdOw33rrrTn55JNz6aWXZt1d53+ctTBde3TL+v3Wz5QpU3LDDTfk8MMPr/d7AMCiqm9/nTV/XGOusTf0+sBjDz6cHfaunSHv3bcnZtRTz+Tr55xcr32/+eabefTRR/VXmA9hObRAvfr0zu4HfiHfP/nc7H/EV7L2+n0zderUvPrS2Lz+79dy4ndPy2qfWz1de3TLdT+4Kv97wpH55OPJueWq67PSZ03zsgBrrLFGve7o7tWrV4444oiceOKJqVQqWXnllTN06NCsvvrqdRf+k+T888/P+eefX/dcmP+8+37OPvrbad+hffY+eP+8+Nzzdet26Ngxvdfq06D6ASCpTg/t3nOVdO+5yiKv37VHt+y63x717qFvv/12dtttt3Tq1CknnHBCnnjiibp1l1tuubrnqQMALcu6666bY445JkOGDMl3vvOdDBgwIFOmTMmoUaPy4osv5rrrrkvfvn3Tq1evnHzyyfnud7+bDz/8MOeee2569vzsadDnp3vPVTKg34BFXv+hhx7KYYcdll122SVbbrllHn/mmbrXunbvlq49uiVJ/t/vRuSysy7O9X/8Zbr3rJ1i/f/9/o+ZMW16eqy2at558uVcdtllad26dU4//fQG1Q4Ai6K+/fULR325atcHfnrxFamkkuW7rJBbr74h3VbtkR322qVuvduuuTG3Df9Z/vDcQ0mSsS+8lD2+/b0ccMABWX311TNu3LhcdNFFadWqVU480eA0mJuwHFqor599cnqu0Tt//PXvc/OV16dDp47pveYa2fWLeySpHQ131uUX5poLLs33TjwrXbt3y4FHfzXPPfl0/v2vVz7j3ZvGFVdckY4dO+akk07K5MmTs+222+b222/PsssuW7dOTU1NZsyYUff7uJfHZuKbtc+DPe3QE+Z4v9mnoAGAhmoJPfSYM09M315r1quHPv/88xk/fnySZPvtt5/j/eY3TSoA0HJcffXVWWeddXLttdfmnHPOqbsR7ogjjkhSO+LtN7/5TY477rjsv//+6dWrV84888z85S9/yci//d9ir+/Pf/5zpk2blvvuuy/33XffHK995euH5eBv1NZZU1NJzYwZSSp1r1dqKvn19bfm7TfeSpcVVsg+++yT733ve+nUqdNirxuAlmnuGd5en/R2Jk35aI7lz77xryTJ/WMeT/uZo7Xfen3CHNvVp79W8/pAuw7tc+33r8qnU6ZkwwGb5NRLhmaZ2WaTqampmdlfa3VeYflUKpWcfvrpeffdd9O5c+dst912ueuuu9K7d+9mqRtakqJSqSzs9YW+CGWzpDyzvDkM7jeo2ffZmL9vNeqFZtDYhwjp4zCbltbH9TZo8RbHwwD1dqDeGnoM1JhjkWrsE5qBc3RYQlTjOrJrCtDiLbCPt2rOKgAAAAAAAABgSSAsBwAAAAAAAKB0hOUAAAAAAAAAlI6wHAAAAAAAAIDSEZYDAAAAAAAAUDrCcgAAAAAAAABKR1gOAAAAAAAAQOkIywEAAAAAAAAoHWE5AAAAAAAAAKXTptoFAAAAAAAA0PKMGD2ywdsO7jeoCSsBaBhhOQAAAAAswRoTRAAAAAtmGnYAAAAAAAAASkdYDgAAAAAAAEDpCMsBAAAAAAAAKB1hOQAAAAAAAAClIywHAAAAAAAAoHTaVLsAAACojxGjR1a7BAAAAABgKWBkOQAAAAAAAAClY2Q5AAAAAAAAzaoaM8eZrQ6Ym5HlAAAAAAAAAJSOsBwAAAAAAACA0hGWAwAAAAAAAFA6wnIAAAAAAAAASkdYDgAAAAAAAEDpCMsBAAAAAAAAKJ021S4AWDKNGD2y2iUAAAAAAADAYiMsBwCAJVBjblwb3G9QE1YCADQFN6UDAMCSR1gOAAAAAAAASwk34MOi88xyAAAAAAAAAEpHWA4AAAAAAABA6QjLAQAAAAAAACgdYTkAAAAAAAAApSMsBwAAAAAAAKB0hOUAAAAAAAAAlI6wHAAAAAAAAIDSEZYDAAAAAAAAUDrCcgAAAAAAAABKR1gOAAAAAAAAQOkIywEAAAAAAAAoHWE5AAAAAAAAAKXTptoFAABQPiNGj6x2CQAAAABAyRlZDgAAAAAAAEDpCMsBAAAAAAAAKB1hOQAAAAAAAAClIywHAAAAAAAAoHSE5QAAAAAAAACUjrAcAAAAAAAAgNIRlgMAAAAAAABQOsJyAAAAAAAAAEpHWA4AAAAAAABA6QjLAQAAAAAAACgdYTkAAAAAAAAApSMsBwAAAAAAAKB0hOUAAAAAAAAAlE6bahcAAAAAACxZRoweWe0SAABgsROWAwDAUqahF7cH9xvUxJUAAAAAwJJLWA4AAAAAVF1jRrO76Q8AgIbwzHIAAAAAAAAASkdYDgAAAAAAAEDpCMsBAAAAAAAAKB3PLAeWCg19rplnmgEAAAAAAJSTkeUAAAAAAAAAlI6wHAAAAAAAAIDSEZYDAAAAAAAAUDrCcgAAAAAAAABKR1gOAAAAAAAAQOkIywEAAAAAAAAoHWE5AAAAAAAAAKUjLAcAAAAAAACgdNpUuwAAAAAAgMYYMXpkg7cd3G9QE1YCAEBLYmQ5AAAAAAAAAKUjLAcAAAAAAACgdITlAAAAAAAAAJSOsBwAAAAAAACA0mlT7QIAAAAAoKUYMXpktUsAAACaiJHlAAAAAAAAAJSOkeUAAAAAAABAg2fRGdxvUBNXAs1DWA4AAABAqZhKHQAASEzDDgAAAAAAAEAJGVkOAAAAAAAANFhjZu4xhTvVJCwHACg505ACAAAAAGVkGnYAAAAAAAAASsfIcgAAAAAAgJIy4xxQZsJyqq6hjdgzLAAAAAAAAICGMg07AAAAAAAAAKUjLAcAAAAAAACgdITlAAAAAAAAAJSOsBwAAAAAAACA0hGWAwAAAAAAAFA6wnIAAAAAAAAASkdYDgAAAAAAAEDpCMsBAAAAAAAAKJ021S4AoJpGjB7Z4G0H9xvUhJUAAAAA1dDQawOuCwAAtHxGlgMAAAAAAABQOsJyAAAAAAAAAErHNOyUUmOm3gYAAAAAAABaPiPLAQAAAAAAACgdYTkAAAAAAAAApWMadoAGasx0/oP7DWrCSgAAAAAAAKgvI8sBAAAAAAAAKB1hOQAAAAAAAAClIywHAAAAAAAAoHSE5QAAAAAAAACUjrAcAAAAAAAAgNIRlgMAAAAAAABQOsJyAAAAAAAAAEpHWA4AAAAAAABA6QjLAQAAAAAAACgdYTkAAAAAAAAApSMsBwAAAAAAAKB0hOUAAAAAAAAAlI6wHAAAAAAAAIDSEZYDAAAAAAAAUDrCcgAAAAAAAABKp021CwAAAJYMI0aPbPC2g/sNasJKAAAAAGDxM7IcAAAAAAAAgNIxso3mtlAAACAASURBVBygCho6cs+oPQAAAAAAgKYhLAcAABrNFO4AAAAAtDSmYQcAAAAAAACgdITlAAAAAAAAAJSOadgBAAAAqJrGPMoDAACgMYwsBwAAAAAAAKB0hOUAAAAAAAAAlI5p2AEAAAAAAFo4jzYBqD8jywEAAAAAAAAoHWE5AAAAAAAAAKUjLAcAAAAAAACgdITlAAAAAAAAAJSOsBwAAAAAAACA0hGWAwAAAAAAAFA6bapdAEuHEaNHlmKfTe2xBx/OLVddn/Fjx2Wlbl2z10FfzH6HDlng+j+9+Irc9fNfZb9Dh+TI73yjbvlrr7yaH51+QcaPHZcBW2+Zb55/atp37FD3+nN/+0d+8O2h+ek9t82xfH4e+O29uezM7+XOJ++fZ91brro+f7jtN/nFY/ckSd56fUIO2/mAutfbd2ifnn16Z//Dv5JtBu8433XatV82XbqumL4brZ/dD9wnGwzYeBH+UgCwaPRWvRUAWjrHM45nAGgYPVQPhYYQlkOVjPr7s7nwm2dm5/32yJGnHJcxzz6fGy8dnlatWmWfr35pnvXHvTQ29935h3To1HGe1y4948Ks2rtX/vf4I3P9Jdfklz+9OYd+6+gkSU1NTX7yvctz6LeO/szG3VBHnnJc1uu/YSZ/NDkP/PaeXHzyuWnXftlssd2gedaZNnVa3hw/IQ+PeDDf+epxOei4w3PQcYcvlroAKBe9VW8FgJbO8YzjGQAaRg/VQ6GhhOVQJbcP/1nW23TDnPjd05Ik/QcNzMcffJjbrrkxewzZN22XaTvH+sMvHJYv/O8B+dPv75tj+ScfT84Lzz6fodd8P8uv2CUfffhRfnPj7XXN+/7f3JM2bdtkh713W2yfpWef3um78QZJkk3+Z0Beev7F3PuLu+Zo3rOvs+Hmm2bnfXfPzVdel1uvviEbbr5JNhrYf7HVB0A56K16KwC0dI5nHM8A0DB6qB4KDeWZ5VAlr4z5VzbdavM5lvUfNDAfffBhxjzzzzmWP3rfnzN+7Kv50pEHz/M+06dNT5Is065dkmTZZdtl+rRpSZLJH32cmy+/Nkef/s0URbE4PsY8WrVqlc/1XTtvvT7hM9f9ytcPy0rduubeX/6uGSoDYGmnt+qtANDSOZ5pWcczI0aPbPA/AJqWHtqyeigsSYwshyqZ+unUtGk751ewTdvau9vGvfxqNtx80yTJp1M+zbU/uCqHnnRMlu3Qfp736bzCcunec5X8/tY7s/uXvpARv/591l6/b5Lau+k2+Z8B6bfJBvWur6amJjOmT59jWaVSWaRt33p9Qrp0Xekz12vdunU22mKzjHrqmXrXBwBz01v1VgBo6RzPOJ4BcENNw+iheig0lLAcqmTV3j3z4j/HzLHsxeeeT5J8NOmDumW/uvbmrLjyStlhr10X+F5fP/ukXPStc3LTsJ9k1dV75etnnZQ3Xh2f++68O9fc9fMG1XfAFvOfRma5FZafZ1mlppIZ06dn8keT88c7786Lz43OsWd+a5H207X7yvnPu+81qEYAmJ3eWktvBYCWy/FMLcczANSXHlpLD4X6E5ZDlex+4D656rxL8sdf/z6DdtkuLz43Or+96ZdJkqJV7RQub45/I7+58fZcdOMVC53WZfNt/ie3PXp3Jr71dlZZrWdat26d8447Nft89cB07dEtd992Z+647tYkyQFfOzh7fnm/z6zvBz+/Osss226OZX/89e/y2AMPz7Pu+d84re7nNm3aZN9DDszuQ/b57D9CkmTR7p4DgM+it86itwJAS+V4ZhbHMwDUjx46ix4K9SUshyrZeb898soLL+Wq83+UK879Qdq1XzaHn3Rshl94Wd2UKjde+uNstvWW6dWndz764MMkSaWmJtOmTstHH3yYjp071TX1Zdsvm15r9E6S/P2xJ/PKmJdy2o/Ozytj/pWbr7guP7rtx0mSk79ydNbvv1H6rLvWQutbs9/aad+xwxzLnvjL/KcAOuq0E7Je/43SoWOHdO+5Stou03aR/w4T35qYFVZacZHXB4AF0Vtr6a0A0HI5nqnleAaA+tJDa+mhUH/CcqiS1q1b5+tnnZT/Pf7ITHzrnfTouUpeGzsuSdJ34/WTJK+PHZdXXngpjz3w0Bzb3n3bnbn7tjvz8z/9Jl17dJvjtRkzZuTai6/I4d/+etot2y7PPvl0Nt5ys6z2udWTJBtvOSDPPfmPz2ze9bFK755ZZ4O+9d5uxvTpefavT2WDARs3WS0AlJfeqrcCQEvneMbxDAANo4fqodBQwnKoss7LL5fOyy+XJLnn9t+k36Yb1jXaE757WqZMnjzH+t8/eWg22HyT7DFknyy/4grzvN+9v7grnZbrnG0H71i37NNPptT9PGXyJ6lUloypWG4b/rO8+/bE7H7gok4hAwCfTW/VWwGgpXM843gGgIbRQ/VQqC9hOVTJmGf+mVFPPZvP9V07kz+enIfueSBPjXwil9xyTd0687t7rG27ZbJyj27ZaGD/eV778D8f5NZrbswF1/6obtmGm22SGy4Znvvv/EMqSZ75699z2EnHLJbPtDCvjx2XMV2Wz7Rp0/PW+Al56N4H89Sjf81Bxx2eDTfftNnrAWDpo7fqrQDQ0jmecTwDQMPooXooNJSwHKqkdZs2efiPf8qtV9+YolWRDTbbOJfcOjx91lmzwe9569U3ZMvtB2Wt9datW7bmeuvk8G8fm5suvzZJcuQpx+VzfddudP31dd0Pr06SLNNumay48krpu/EG+cHPrzYlDABNRm/VWwGgpXM843gGgIbRQ/VQaKjiM6aHWDLmjmCJN2L0yGqXAKUwuN+gapdA8yoaub0+ziLRx6k2/Y2lVGP7+Pzo7SyVHItQRo5/WiTn6DQLfZEy0hdpBgvs462aswoAAAAAAAAAWBIIywEAAAAAAAAoHWE5AAAAAAAAAKUjLAcAAAAAAACgdITlAAAAAAAAAJSOsBwAAAAAAACA0hGWAwAAAAAAAFA6wnIAAAAAAAAASqdNtQsAAAAAoGUbMXpktUsAAACoNyPLAQAAAAAAACgdYTkAAAAAAAAApSMsBwAAAAAAAKB0hOUAAAAAAAAAlI6wHAAAAAAAAIDSEZYDAAAAAAAAUDptql0AAAAAAAAAUE4jRo9s8LaD+w1qwkooIyPLAQAAAAAAACgdYTkAAAAAAAAApWMadgAAoKoaOt2aqdYAAAAAaAwjywEAAAAAAAAoHSPLAQCWAg0dmQsAAAA0LefoAC2HkeUAAAAAAAAAlI6wHAAAAAAAAIDSEZYDAAAAAAAAUDrCcgAAAAAAAABKp021CwAA4L9GjB5Z7RIAAAAAAErByHIAAAAAAAAASkdYDgAAAAAAAEDpCMsBAAAAAAAAKB3PLF8KNfRZp4P7DWriSgAAAAAAAGDxaGgm1hjytKWLkeUAAAAAAAAAlI6wHAAAAAAAAIDSEZYDAAAAAAAAUDqeWQ4AALRIjXkumeeLAQAAAGBkOQAAAAAAAAClY2Q5AAAAAADAXBozmxUALYOR5QAAAAAAAACUjrAcAAAAAAAAgNIxDTsAQBMzTRsA0FI5joElW2O+o4P7DWrCSgAAlg5GlgMAAAAAAABQOkaWA7Qg7iAHAAAAAABoGsJyAAAAAIBm5JEHAABLBtOwAwAAAAAAAFA6wnIAAAAAAAAASsc07AAAAAAAAACLoKGPUxncb1ATV0JTEJYDAACl05jnhDq5BQAAAFg6CMup05gLhgAAAAAAAAAtiWeWAwAAAAAAAFA6wnIAAAAAAAAASkdYDgAAAAAAAEDpCMsBAAAAAAAAKB1hOQAAAAAAAAClIywHAAAAAAAAoHTaVLsAmt+4l8Zm+IXDMuaZf6Zj507Zdf+98pWvH5bWrVsvcJtpU6fl55f/NGOeGZV/jRqTqZ9Ozb3PP9qMVQML0pDv9OxqamoycODAPPXUU7n77ruz5557LuaKgaRh390XnxudP9z+24x66pm8987EdO3RLdvtsXMOOPKgLNOuXTNWDy1DQ75nr/7rlVz3w6sy9oWX88F/PkiXlbpk00ED89UTjsyKK3dtxuoBmsevf/3r3HzzzXnqqacyadKkrLJ6z+x32Jez3R47L3S7dya8lZ9cfEWeHvlEilatMmDrLXPMGSdmhZW6NFPlwMI8et+f89ubfpnxY8dlyidT0m3V7jnmiKPyne98J8sss8wCt5s0aVJOPPHE3HXXXampqcmee+6ZK664IiuttFIzVg9Ltqa4FnfigV/LS6NeyLnXfD9bbDdoMVcMNERDvutvvT4hh+18wDzLtxm8Y0770XmLs1waQVheMh9O+iBnHHFieq+5Rs6+6uJMGPd6rvvhVampqckh3zxqgdt9OmVK7rvz7qyz4Xrpt8mGeeavTzVj1cCCNPQ7Pbvrrrsu48ePX8yVArNr6Hf34RH/LxNeez0HHHlQVl29V8a+8HJuvvK6jH3x5Zx1+YXN+AlgydfQ79nHH32c7j1XzQ5775aVunXNm+Mn5LZrbsxLo17I5b+6Nq3bOIUCli6XXnpp+vTpk8suuyxdu3bN1Tdfmx+ccl4+eH9S9j54//luM2P69Jx91MmpVJJvfe/MVGpq8rPLfpJzjj45l/3y2kUOC4DF54P/TMpGW/TPFw//cjp27pwXn3s+F154Yd58881cddVVC9zuS1/6Ul588cVcd911adWqVU499dTss88+eeSRR5qxelhyNcW1uPvuuDvvvvnOYq4UaIzGftePPOW4rNd/w7rfl1thhcVZLo3kSk/J3PvL32Xqp5/mrCu+lw6dOiZbbZ7JH3+c266+IQcccVDtsvnotFzn/PLxESmKInffeqewHJYQDf1Oz/L+++/nzDPPzMUXX5wjjzyymaoGGvrdPeBrB2f5Lv89uN5oYP8s026ZXDn0h3nr9TfTvWeP5voIsMRr6PdsvU03zHqb/veEdqOBSdce3XLWkd/K2BdfzlrrrdtcHwGgWdx9993p2vW/M2d8ukq7vPvOxPz2pl8uMCx/5L4/Z/zYcfnJH25NzzVWS5L06tM7x+17aB5/8OF8ftftm6V2YMF2P3CfOX7feIv+WWXZFXP11VfnyiuvTFEU82zz+OOP5/77789DDz2UbbbZJknSs2fPbLHFFnnwwQez0047NUvtsCRr7LW4Dyd9kJsuvzaHnXRMLj/74maqGqivxn7Xe/bpnb4bb9BM1dJYnlleMn975P/Sf9AWc3yRtx28Yz6d8mmee/LphW47v4NooLoa851OkrPPPjuDBg3KjjvuuDjLBObS0O/u7EH5LGv2WydJ8t47E5u+UGjBGtsjZ7fcCsslSaZPm9akNQIszIjRIxv8rz5mD8pnWbPvOnn37QUfW7wy5l/ptmr3uqA8Sfqsu1a6dF0pTzz0eL32DzSflVZaKVOnTl3g6yNGjEj37t3rgvIkGThwYPr06ZMRI0Y0R4mwxGvsecbNV16X9TbdMJtsudniLBNopKa8psCST1heMuPHvppefXrPsazbqj3Srv2yee2VcVWqCmioxnynn3322dxwww255JJLFmeJwHw0ZT8e/Y9/plWrVllltZ5NWSK0eI39ntXU1GTa1GkZP3Zcbrz0x1lnw35ZZ8P1Fle5AEuUMc/8c44gfG5TP52aNm3bzrO8Tds2ee2Vfy/GyoD6mjFjRqZ8MiWjnnomV1xxRY499tj/396dh9013gsf//4SQkJCVE/EHKISMbcUJ21SRzhRrxpaQ/WEouUYjqGG0pLE0FAzNVYq1WPqKafUy1EcamhOiw6HVrxITCFBDSEDGdb7x9rRJ0+e/Qx777X3Xmt/P9e1rlzP3vfeudfv3uv+rfteU9kLYqZNm8awYcOWe3348OFMmzYt66pKuVDNOGPGcy9w/x3/l8NPPjrLKkqqgWrnFC753iT22PyLHPTFr3Dd+Vfw0YKPsqqqasDbsLeYD+d8wKoD+i/3+qoD+vPhnA8aUCNJ1ejJNt3+CpNTDjuG3Q/cm+cXzmb2S28A8OSrf6X3swOXKTd2+D/WuNaSapWP33nrb9x67U/Zec/dWP1TA7v+gNRCqt3Oxh95Ek899nsAho7YlLOuuZBevTzXWFLx/Wnqk0x98FGOP+e0smXWXn9d7rntTua89z4DVl8NgL+9+TZ/e/NtVuyz/EF0SY2zz2fHsLB0Nfm4ceO44IILypZ99913Wb2DZ6oOHDiQ6dOnZ1ZHKU+qGWdcfe6l7PH1fVl7g3WZPfONrKooqQYq3dZX7LMie3x9H7bdaXv6rdqP//39H/nF5JuY9cpMzrzyvB7fBaot5+mz42yPJLWg39zzADNnvMKBRx7c6KpIqtDCjxcy6cQz6duvL9869dhGV0cqnCNPP4GLb7mWk847gwXz5nPmEd/h4488E1xSsb300kv88JSJ7LDzSMbsvXvZcqP3GEOflfpw6ffP483XZzF75htc8r0fAHhikdRkLrr5ai742ZUcfsox3HnnnRxzzDGNrpLUkpyLk1rDGp9ek6O+fyI77DySLbfflm8ccxjfOvVY/uehx5g+7flGV09lOIJpMasO6M/cDz5c7vVyZ8lIam6VbNOLFi5i8oVX8dXDD2LJkiV8OOcD5n04F4AF8xcwb+68TOssqfp8nCQJF512Dq+8MIOJ11xI/9UGZFFNKdeq3c7W2XA9hm01gp333I2zr7uYF599nofvvj+LqkpSU3jnnXcYO3Ys/7D2Wpz8w/Gdlh2w+mqccsF4nvvzXzhkl6/yzTFfY6WVV2K7L+7AwDXXqFONJXXH0M02ZcRnt2KfQw7g8ssv5+qrr+bFF1/ssOzAgQN5//33l3v93XffZeBA72QlgXNxUquo5bG0kbuOBuCFvzxXi6opA96GvcWsO2QDXpvx8jKvvfXGbD6av4D1Nlq/zKckNatKtukF8+fz9qw3+fH5V/Dj869Y5r3zvzOeweutw+T7bsuszpKqz8fXTrqM//nvRzn3+ktYb6MNsqqmlGu13O8dtM5a9F9tAG+89notqyhJmenp7R0XzF/A9w47nvfmzuHim69l5b4rd/mZ7UftxI0P3cHMl16l36qrsOZa/8C/7vkvbD96p0qrLSlj2267LQAzZsxg4403Xu79YcOG8eijjy73+rRp09hrr70yr5+UB87FSa2hpsfSIpb9twEqvf17q9z63YPlLeZzX9iB239yM/PmzqPfKv0AeOTeB1lp5ZXYYrttGlw7ST1VyTbdt19fzpty+TKvvfv2O5x/0gQOPv4Itvr8tpnXW8qLap4j1Jlq8vFt1/2Mu2++g+9efBYjPrtVJvWTiqCW+72vzXiFOe+9z1rrrp1FVSWpoRYvWsSkE85g5suvcdFNV7P6p7p/9WjvFVZg/aFDAHj6iT/y6oxXOP3Sc7KqqqQqPf54Or4ZMmRIh++PHTuWs88+m8cee4yRI0cC8OSTTzJ9+nTGjh1bt3pKzcy5OKk11HJO4bH7HgZgkxGb1rqaqhEPlreY3ff/Cnf9+y84599O52uHHcSs117npitvYK+D96ffqqt8Uu6w3fZni+225vhzTvvktScemcpH8xfwYum5Co/d9xAAm2w+nEHrrFXfFZEEVLZN915hBbbcftmd8Nkz3wBgw89sxLCtRtR1HaRWVGk+fujuX/PTS69ll712Z81BazLtz898Unbweuuw2hreGlFaqtLt7Pof/ojeK/Rm0y03Y5X+/Xl1+kv8YvLNDF5vHUaN/adGrY4kZebKsy/iiUemcsRpx/HB++8z7c9/vwXzxsM/w4p9+nDaN48DYNINl33y3uQLrmT4NlvQt19f/t/Tz3LrdTdywBHjvOuN1CTO+PaJbL3D51h/6BB69+7NX//wNHfe+HP233//T64qHzp0KKNGjWLy5MkA7Ljjjuy6666MGzeOCy+8kF69enHqqacycuRIdtlll0aujtQ0nIuTWkOlcwr//qPJzJ87j8223ZJ+q/Tjmaf+zO0/uZmdxoxiyKZDG7U66oIHy1tM/9UGMOknl3LVuZcw8ehTWaV/f/Y6eD8OOvrQZcotXryYJUuWLPPalWddxJuvz/rk7x+ccAYAJ5x7OmP23j37yktaTjXbdD1Uc1Vuq9ziRa2p0m33j799AoAHfnkPD/zynmXKmo+lZVW6nW2y+TDuuul27v35XSz8+GM+PXgQ/zhmFPt9+19YuV/feq+GJGXuD4+n+xfXTrpsufduuP8/GLTOYJYsWbzce7Nfn8UDd97L3A/mss6G63HEd/+Nf/7anpnXV1L3bLL5cB745b3MnjmL3iv0Zq1112bSpEkceeSRn5RZtGgRixcvu33fdtttnHDCCRx66KEsWbKEPfbYg8svv7z910stq9nn4iTVRqXb+nobbcDtN9zCfbffzccLPuLTgwex76Ff54AjxtV7FdQDkSRJZ+93+qaaU1a3jJXUmqo5aO3B8qpV+yAb83iVzKmSOmKOUjdl8UA6c3sLcT9EUq25D1M1x+gtyHwsqVk0Yp6+YPsOZfO4V5ZLkiRJkiRJUsF5QrskSdLyPFjepDxjTVKzsD+SJEmSJEmSJElF1KvRFZAkSZIkSZIkSZIkqd68slySJEmSJCkj3qlJkiRJkpqXB8sz5qBYkiRJKpZK9/F91qckSZJUf87RS5I6423YJUmSJEmSJEmSJEktxyvLJUlSoXkGuSRJqpb7E5IkSZJUTB4slyRJkiRJkiRJkqQmlbcTePP0CDsPlkuSJEmSpLqqZqKnmsmTvE0wSZIkSZKy5cFySVKhNGriVZIkSZIkSZIk5YsHyyVJkiRJkiRJUua8yEGS1Gw8WC5Jkpqet0yVVARODEqSpLxqxJjM/R9JklQPuTtY3ogHwrfiBP0dN9zCTVf+hPnz5je6KpJqpG+/vhx09KHs880DG12VbmlE39uIHCN1xnws1UfecqQkNYL7JVIxuR/U2vI2D5KneXrzptQ6zKX5l7uD5aqPO6bcaiKXCmb+vPncMeVWk7aUI+ZjqT7MkVK+5GmivEjcL5GKqZn3g/J2IFdqy7wptY5mzqXqnl6NroCa0z6HHEDffn0bXQ1JNdS3X1/2OeSARldDUg+Yj6X6MEdKUtfcL5GKyf0gKRvmTal1mEvzL5Ik6ez9Tt+slGeBS5KKJMOz1qPKz2eSxxvBfQdJrc4rpHKp2jzeEXO7JEldaLUxet6eJ+8+gCSpM43I496GXZIk9Ug1A1sP9khSZVrlNqR5m+wtCnO7JEmSJKlVeRt2SZIkSZIkSZIkSVLL6fQ27BMnTvwvYM36VacqawOvN7oSLcR415fxri/jXT/GunNvjx8//p8r/XAT53HbvXPGp2vGqHPGp3PGp2vGqHPdjU9VebwjTZjb/a00D9uiOdgOzcO2aA5Fa4e8jdGLFv96MW6VMW49Z8wqY9wqY9w6y+NJkhRimTBhQtLoOrTSYryNd5EX422sXWx349PcizEyPsbHGBmf5liMRfMstkVzLLZD8yy2RXMstoPxz+Ni3IybMWvuxbgZtywWb8MuSZIkSZIkSZIkSWo5RTpYPrHRFWgxxru+jHd9Ge/6MdatyXbvnPHpmjHqnPHpnPHpmjHqnPH5O2PRPGyL5mA7NA/bojnYDo1l/Ctj3Cpj3HrOmFXGuFXGuHWi02eWS5IkSZIkSZIkSZJUREW6slySJEmSJEmSJEmSpG7xYLkkSZIkSZIkSZIkqeV4sFySJEmSJEmSJEmS1HJyc7A8Io6KiBkRsSAinoqIL3RRflSp3IKImB4RR9arrkXQk3hHxOCIuDkipkXE4oiYUseqFkIP471PRPw6It6KiA8i4ncRsWc965tnPYz1qIj4bUT8LSLml37jJ9WzvnnX0767zedGRsSiiHgm6zqqOlnki4g4rlRmfkS8FhFXRsSqma1ExrLo4yNi34j4a0R8VPp372zXIju1jk9EfCsiHo2IdyPivYh4KCJGZr8m2chyHyEiDoyIJCLuzqb29ZHRNjYgIi6PiNdL29kLEbFftmuSjYziU5h+Oot9wzz20RFxWkQ8ERFzSu3/q4jYvBuf2y0ippZ+L29HxJ0R8Zl2ZRybd1NW7RARo0v9fftlWLZrlF9VtMV+EfGniJgXES9HxMkdlHGb6Kas2sFtouci4uiI+N9SW8wp9Tlf7uIzW0TEb0o5c2ZEnBkR0a5M7nJmo/Rkn6Xd5zqcX4mCjZvKqXXc2pUpxHiqI1nELQo0xiono7gVZuxVTk/i1t0cXvT8UuuYtUpO6EwuDpZHxP7AZcAPgG2A3wL3RsT6ZcoPAe4pldsGmARcERH71qfG+dbTeAMrAW8D5wG/q0slC6SCeI8C/hv4cqn8PcB/djf5trIKYv0hcDnwRWAz4BxgYkQcVYfq5l4F8V76uYHAjcCDmVdSVckiX0TE14EfAucCw4FxwO6l/yd3sujjI2JH4DbgJmDr0r//ERGfz2o9spJRDhxNGp+dgc8DzwH3RcQmWaxDlrLcR4iIjYALgEczqHrdZLSNrQjcD2wC7AdsChwCzMhmLbKTUXwK009nsW+Y4z56NHAVsBNp/7kIeCAi1ij3gdK4+07SfmQbYBegL+nvpm0Zx+bdN5oM2qGNEcDgNsvzNax70Yym520xFrgZuA7YHDgKOCEijmlTxm2iZ0aTQTu04TbRfa8BpwLbAp8j3V/4ZURs2VHhiBhAuj81G9gOOA44GTixTZm85sy6y2h+ZTQFGTeVk+W8VFHGUx3JIm5FGmOVk1HcCjP2KqfSuNFJDi96fskiZrRATuhSkiRNv5BOqP+43WvPA5PKlD8feL7da9cDUxu9LnlYehrvduXuBqY0eh3ytFQT7zblfw9c1Oh1afalRrG+A7il0euSh6XSeJdiPB6YADzT6PVwqX0bl8p1mC+AHwG/affaxLz+FrLo40l3Xu9vV+aBPPZN9ciBQACzgGMbvb7NEh9gxdJ3HwxMAe5u9Lo2U4yAbwPTgT6NXr8mjU9h+ukswsnQSAAACjpJREFU9g2L0kcDqwKLgf/TSZmvlsr0bvPal4AEWLP0t2Pz5miH0W3/dsmsLW4G/rPda8cCrwJR+tttojnawW2iNu3xDnBEmff+FZgD9G3z2veBmW3aoRA5s06xznx+hRyPm+odNwo0nqpX3CjQGKvOcSvM2KtWcetODi96fskiZh18pnA5oaul6a8sj4g+wGeBX7d769ekZ5Z2ZMcOyt8HfK50FpPKqDDeqlAN490feLdW9SqiWsQ6IrYplf1NbWtXPJXGu3Rl1iDSK7XUxDLMF48BW0fEDqX/Z31gTzq+OqqpZdjHl9vPyVWermMO7AOs3EWZppNxfM4FXkqS5KeV17DxMozRXsDjpFf6zSrdsm1C3sYRGcanEP10hvuGheijSdu9F533nU8AC4HDI6J3RPQnnTR+IkmSt0tlHJtXp1btsNSTEfFGRDwYEV/KpsqF1Z22WAlY0O61+cC6wAalv90mqlOrdljKbaICpb7mANKTF35bptiOwKNJksxv89p9wNrAhm3KFCFnZqqO8yu5HDeVk3HcCjGe6kiGcSvEGKucDONWiLFXOVWOyTrL4YXNLxnGrL1C5YTuaPqD5cCaQG/S2/a0NRtYq8xn1ipTfoXS96m8SuKtylUd74g4mnTQ97PaVq1wKo51pM+D+Qh4ErgqSZJrsqliofQ43hGxBemZlN9IkmRxttVTDWSSL5IkuRU4HXgkIhYCLwNPk97yL2+y6uPL7efkLU/XKweeQ3rr5LsqqGMjZRKfiNiV9LZ3R9Smmg2V1W9oI+BrpFeMfBk4AziS9Fa5eZJJfArUT2e1b1iUPvoy4E/A1HIFkiR5GRhDenXLR8D7wBbAHm2KOTavTq3a4Q3Sqzz3BfYhva3ig+GjvHqiy7YgnYT9SkTsGhG9In1u/HdK7w0u/es2UZ1atYPbRAUifQb5h6R9zTXA3kmSPF2meLnf+tL3OiuTt5yZtXrNr+R13FROJnEr2HiqI1n93ooyxionk7gVaOxVTiVjsu7k8CLnl6xi1l7RckKXVmh0BSRVrvRcswuA/UuTJMrGF0jPmN4BOD8iZiRJ4skJNRQRK5HeIuekJEkK87wi9VxEjCIdNB1FeluhoaSTYhOBMxtYtbqzj+9cd+ITEceRTmLskiTJnHrWr9E6ik9EfJr0NoEHJknyXgOr1xQ6+Q31At4EvlWatHgqIj4FXBIRJyele5IVXbn42E8DBd83jIiLgZHAyM4m2CNiLWAy6TMWbyG94vMs4OcRsXOSJEvqUd+iqmU7JEnyHOmk2FJTI2JD0ucHF+5Zq7XW3bYAfgxsTPoM+RVJb0F9GeltVd0eqlTLdnCbqNhzpM9+XY30ERA/jYjRSZI809hqqa1K5ldaedy0VHfi5nhqeT34vTnGaqO7cXPstTxzeM/1NGatmhPycLD8bdLnEQ1q9/og0nvmd2RWmfKLSt+n8iqJtypXcbwj4qukEyLjkiT5VTbVK5SKY91mp+XpiBhEOsguzIRoRnoa78HAcOCGiLih9FovICJiEbB7kiTtby+jxsoqX5xD+gyh60t/Px0RqwDXR8RZSZIsquK76y2rPr7cfk7e8nSmOTAijgfOBsYmSfL76qtbd1nEZwRpf/tgRCx9rVfpM4uAEaVBVF5k9Rt6A1jYbiL+WaAf6Vncb1VT6TrKKj5F6aez2jfMdR8dEZcABwBfSpJkehfFjwbmJklySpvPf4P0ucA7kd420rF5BTJoh478rvR/qBM9aYvSRP+pEXE66ZU9bwH/VHp76WfdJiqQQTt0xG2iC0mSfAy8UPrzqYjYDjgBOKyD4uV+60vf66xMLnJmHWU6v1KAcVM5NY8b8DHFGk91JKvfW1HGWOVkFbeijL3KqdXcYvscXuT8klXMgELnhC41/W3YSztiT5HeVqytMZR/Ls7UMuWfTJJkYW1rWCwVxlsVqjTeEbEf6YTcIUmS/CK7GhZHDX/bvUifgaZOVBDvmaS3i9y6zXIN6UB86zKfUQNlmC/6ke70tbUYiA7KNrUM+/hy+zm52k6yzIERcSLpzv2XkyQpd5CgqWUUnydYvq+9i/RM4q2BXN3ZI8Pf0OPA0IhoO1b6DDCPHB3IyDA+heinM9w3zG0fHRGXAQcCOydJMq0bHyn3W4C/zzU4Nu+hjNqhI1uTTlyrjAraAoAkSRYnSTKz1M8cCExNkmTpQQC3iR7KqB064jbRc53Nj0wFvhARK7d5bQzwOvBSmzK5zJn1lOX8ShHGTeVkFLdCjac6kuHvrRBjrHIyjFshxl7l1HBM1j6HFza/ZBizQueEbkmSpOkXYH/SM7cOJz3j5jLS++VvUHr/RuDGNuWHAHOBS0vlDy99ft9Gr0selp7Gu/Ta0k79EdKdhK2BzRq9LnlYKvh9HwAsBI4jPUt66bJGo9el2ZcKYn0s6bP+Nikth5Hewu28Rq9LHpZK+pJ2n58APNPo9XCpbRt3lS9K7T6n1NcNId3ZewG4vdHrW48YdaePJ71KbBHwXWAYcFrpM59v9Po2SXxOLn3nfu3KrNbo9W2G+HTwf0wB7m70ujZTjID1Sv3QFcCmwG7Aa8AFjV7fJonPBArST1cQny73DclpHw1cWVqXndu1/aptykwCHmzz986ktzQ+sxSPbYH/Al4BVimVcWzeHO1wPLBX6f0Rpe9IgH0avc7NulTYFmuSPg9yOOk+7mXAfGD7NmXcJpqjHdwmet4W55E+hmRD0gM8k0p9z9gy7bAa6RVutwKbkz4jdQ7wnTZlcpkzGxT/ms+vUKBxUz3j1kGZKeR4PFXH31thxlh1jtsECjL2qlXc6EYOL3p+yShmhc8JXca10RXowQ/gKNIzDz8iPXPii23eexh4uF35UcAfSuVnAEc2eh3ytFQQ76SD5aVGr0delp7Eu/R3R/F+uN71zuPSw1gfD/yFdDLj/VKfchTQq9HrkZelp31Ju89OwIPlTb/UOl+QPiJmPPA86aTWq8BVwMBGr2s9YtTdPp70GYHTSHdknyXHE3u1jk/puzoqM6XR69oM8eng+6eQ88mdjLaxHUjPyp5POpY4C+jT6HVthvhQsH66h/Hp1r4hOeyjy7R7AkxoU2YK7cZ4pBN3T5FOzrwF/Ip2J03j2Lzh7QCc0mabfYf0CrjdG72+zbxU0hakB2mnltphLvAAHUzKuk00vh3cJipqiynAy6Xf7ZuluO5Wrh1Kr21BepL0AtKr18YD0a5M7nJmA9ugpvMrFGzcVK+4dVBmCjkfT9UrbhRojFWvuFGwsVct4kY3c3jR80utY9YqOaGzJUqBkCRJkiRJkiRJkiSpZTT9M8slSZIkSZIkSZIkSao1D5ZLkiRJkiRJkiRJklqOB8slSZIkSZIkSZIkSS3Hg+WSJEmSJEmSJEmSpJbjwXJJkiRJkiRJkiRJUsvxYLkkSZIkSZIkSZIkqeV4sFySJEmSJEmSJEmS1HI8WC5JkiRJkiRJkiRJajkeLJckSZIkSZIkSZIktZz/D5fvQetEJc9eAAAAAElFTkSuQmCC\n", >>>>>>> re run existing ODE notebook to comare against pymc3.ode @@ -1154,6 +1248,7 @@ " \n", " \n", " a\n", +<<<<<<< HEAD <<<<<<< HEAD " 0.231172\n", " 0.016356\n", @@ -1161,16 +1256,22 @@ " 0.198449\n", " 0.262574\n", ======= +======= +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.231128\n", " 0.016112\n", " 0.000470\n", " 0.199191\n", " 0.261736\n", +<<<<<<< HEAD +>>>>>>> re run existing ODE notebook to comare against pymc3.ode +======= >>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.2\n", " \n", " \n", " b\n", +<<<<<<< HEAD <<<<<<< HEAD " 0.225260\n", " 0.079409\n", @@ -1178,16 +1279,22 @@ " 0.042878\n", " 0.363055\n", ======= +======= +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.232353\n", " 0.073796\n", " 0.002175\n", " 0.092065\n", " 0.368774\n", +<<<<<<< HEAD +>>>>>>> re run existing ODE notebook to comare against pymc3.ode +======= >>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.2\n", " \n", " \n", " c\n", +<<<<<<< HEAD <<<<<<< HEAD " 2.925818\n", " 0.033677\n", @@ -1195,16 +1302,22 @@ " 2.858009\n", " 2.985000\n", ======= +======= +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 2.923832\n", " 0.033734\n", " 0.001033\n", " 2.859648\n", " 2.989395\n", +<<<<<<< HEAD +>>>>>>> re run existing ODE notebook to comare against pymc3.ode +======= >>>>>>> re run existing ODE notebook to comare against pymc3.ode " 3.0\n", " \n", " \n", " sigma\n", +<<<<<<< HEAD <<<<<<< HEAD " 0.480563\n", " 0.016981\n", @@ -1212,11 +1325,16 @@ " 0.452350\n", " 0.519051\n", ======= +======= +>>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.478079\n", " 0.017448\n", " 0.000581\n", " 0.444733\n", " 0.511978\n", +<<<<<<< HEAD +>>>>>>> re run existing ODE notebook to comare against pymc3.ode +======= >>>>>>> re run existing ODE notebook to comare against pymc3.ode " 0.5\n", " \n", @@ -1226,16 +1344,22 @@ ], "text/plain": [ " mean sd mc_error hpd_2.5 hpd_97.5 True values\n", +<<<<<<< HEAD <<<<<<< HEAD "a 0.231172 0.016356 0.000506 0.198449 0.262574 0.2\n", "b 0.225260 0.079409 0.002322 0.042878 0.363055 0.2\n", "c 2.925818 0.033677 0.001039 2.858009 2.985000 3.0\n", "sigma 0.480563 0.016981 0.000520 0.452350 0.519051 0.5" ======= +======= +>>>>>>> re run existing ODE notebook to comare against pymc3.ode "a 0.231128 0.016112 0.000470 0.199191 0.261736 0.2\n", "b 0.232353 0.073796 0.002175 0.092065 0.368774 0.2\n", "c 2.923832 0.033734 0.001033 2.859648 2.989395 3.0\n", "sigma 0.478079 0.017448 0.000581 0.444733 0.511978 0.5" +<<<<<<< HEAD +>>>>>>> re run existing ODE notebook to comare against pymc3.ode +======= >>>>>>> re run existing ODE notebook to comare against pymc3.ode ] }, @@ -1270,8 +1394,12 @@ "outputs": [ { "data": { +<<<<<<< HEAD <<<<<<< HEAD "image/png": "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\n", +======= + "image/png": "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\n", +>>>>>>> re run existing ODE notebook to comare against pymc3.ode ======= "image/png": "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\n", >>>>>>> re run existing ODE notebook to comare against pymc3.ode From 711287afd71de9e947362fa7ab211f3587d7b0dd Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Fri, 2 Aug 2019 14:10:56 -0400 Subject: [PATCH 33/45] Add notebook for DifferentialEquation --- ...ayesian_estimation_of_ode_parameters.ipynb | 591 ++++++++++++++++++ 1 file changed, 591 insertions(+) create mode 100644 docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb diff --git a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb new file mode 100644 index 00000000000..6ea5d77a14a --- /dev/null +++ b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb @@ -0,0 +1,591 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING (theano.configdefaults): install mkl with `conda install mkl-service`: No module named 'mkl'\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running on PyMC3 v3.7\n" + ] + } + ], + "source": [ + "%matplotlib inline\n", + "import pymc3 as pm\n", + "from pymc3.ode import DifferentialEquation\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.integrate import odeint\n", + "import arviz as az\n", + "import theano\n", + "theano.config.compute_test_value = \"ignore\"\n", + "\n", + "plt.style.use('seaborn-darkgrid')\n", + "print('Running on PyMC3 v{}'.format(pm.__version__))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bayesian Estimation of ODE Parameters\n", + "\n", + "Ordinary differential equations (ODEs) are a convenient mathematical framework for modelling the temporal dynamics of a system in disciplines from engineering to ecology. Though most analyses focus on bifurcations and stability of fixed points, parameter and uncertainty estimates are more salient in systems of practical interest, such as population pharmacokinetics and pharmacodynamics.\n", + "\n", + "\n", + "Both parameter estimation and uncertainty propagation are handled elegantly by the Bayesian framework. In this notebook, I showcase how pyMC3 can be used to do inference for differential equations using the `ode` submodual. \n", + "\n", + "\n", + "# Catching Up On Differential Equations\n", + "\n", + "A differential equation is an equation relating an unknown function's derivative to itself. We usually write differentual equations as \n", + "\n", + "$$ \\mathbf{y}' = f(\\mathbf{y},t,\\mathbf{p}) \\quad \\mathbf{y}(t_0) = \\mathbf{y}_0 $$\n", + "\n", + "Here, $\\mathbf{y}$ is the unknown function, $t$ is time, and $\\mathbf{p}$ is a vector of parameters. The function $f$ can be either scalar or vector valued.\n", + "\n", + "Only a small subset of differential equations have an analytical solution. For most differential equations of applied interest, numerical methods must be used to obtain approximate solutions.\n", + "\n", + "\n", + "# Doing Bayesian Inference With Differential Equations\n", + "\n", + "PyMC3 uses Hamiltonian Monte Carlo (HMC) to obtain samples from the posterior distribution. HMC requires derivatives of the ODE's solution with respect to the paramteres $p$. The `ode` submodual automatically computes appropriate derivatives so you don't have to. All you have to do is \n", + "\n", + "* Write the differential equation as a python function\n", + "* Write the model in PyMC3\n", + "* Hit the Inference Button $^{\\text{TM}}$\n", + "\n", + "Let's see how this is done in practice with a small example.\n", + "\n", + "# A Differential Equation For Freefall\n", + "\n", + "An object of mass $m$ is brought to some height and allowed to fall freely until it reaches the ground. A differential equation describing the object's speed over time is \n", + "\n", + "$$ y' = mg - \\gamma y $$\n", + "\n", + "The force the object experiences in the downwards direction is $mg$, while the forece the object experiences in the opposite direction (due to air resistence) is proportional to how fast the object is presently moving. Let's assume the object starts from rest (that is, that the object's inital velocity is 0). This may or may not be the case. To showcase how to do inference on intial conditions, I will first assume the object starts from rest, and then relax that assumption later.\n", + "\n", + "Data on this object's speed as a function of time is shown below. The data may be noisy because of our measurement tools, or because the object is an irregular shape, thus leading to times furing freefall when the object is more/less aerodynamic. Let's use this data to estimate the proportionality constant for air restistance.\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#For reproducibility\n", + "np.random.seed(19920908)\n", + "\n", + "def freefall(y,t,p):\n", + " \n", + " return 2.0*p[1] - p[0]*y[0]\n", + "\n", + "#Times for observation\n", + "times = np.arange(0,10,0.5)\n", + "gamma,g, y0, sigma = 0.4, 9.8, -2, 2\n", + "y = odeint(freefall, t = times, y0 = y0, args = tuple([[gamma,g]]))\n", + "yobs = np.random.normal(y,2)\n", + "\n", + "fig, ax = plt.subplots(dpi = 120)\n", + "plt.plot(times,yobs, label = 'observed speed', linestyle = 'dashed', marker = 'o', color='red')\n", + "plt.plot(times,y, label = 'True speed', color ='k', alpha = 0.5)\n", + "plt.legend()\n", + "plt.xlabel('Time (Seconds)')\n", + "plt.ylabel(r'$y(t)$');\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To specify and ordinary differential equation with pyMC3, use the `DifferentialEquation` class. This class takes as arguments:\n", + "\n", + "* `func`: A function specifying the differential equation (i.e. $f(\\mathbf{y},t,\\mathbf{p})$)\n", + "* `t0`: The time for which the initial condition belongs\n", + "* `times`: A monotonically increasing or decreasing array of times at which data was observed.\n", + "* `n_odeparams`: The dimension of $\\mathbf{p}$.\n", + "* `n_states`: The dimension of $f(\\mathbf{y},t,\\mathbf{p})$\n", + "\n", + "Once the model is specified, we can use it in our pyMC3 model by passing paramerters and inital conditions. \n", + "\n", + "Shown below is a model to estimate $\\gamma$ in the ODE above." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Auto-assigning NUTS sampler...\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (2 chains in 2 jobs)\n", + "NUTS: [gamma, sigma]\n", + "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [01:52<00:00, 53.56draws/s]\n", + "100%|██████████| 4000/4000 [00:37<00:00, 107.10it/s]\n" + ] + } + ], + "source": [ + "ode_model = DifferentialEquation(func = freefall,\n", + " t0 = 0,\n", + " times = times,\n", + " n_odeparams=2, \n", + " n_states = 1)\n", + "\n", + "with pm.Model() as model:\n", + " \n", + " sigma= pm.HalfCauchy('sigma',1)\n", + " \n", + " gamma = pm.Lognormal('gamma',0,1)\n", + " \n", + " #If we know one of the parameter values, we can simply pass the value.\n", + " #No need to specify a prior.\n", + " ode_solution = ode_model(odeparams = [gamma, 9.8], y0 = [0]).reshape(yobs.shape)\n", + " \n", + " Y = pm.Normal('Y', mu = ode_solution, sd = sigma, observed = yobs)\n", + " \n", + " trace = pm.sample(2000,tune = 1000)\n", + " prior = pm.sample_prior_predictive()\n", + " posterior_predictive = pm.sample_posterior_predictive(trace)\n", + " \n", + " data = az.from_pymc3(trace = trace,\n", + " prior = prior,\n", + " posterior_predictive = posterior_predictive)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "az.plot_posterior(data);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our estimates of the proportionality constant and noise in the system are incredibly close to their actual values!\n", + "\n", + "We can even estimate the acceleration due to gravity by specifying a prior for it." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Auto-assigning NUTS sampler...\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (2 chains in 2 jobs)\n", + "NUTS: [g, gamma, sigma]\n", + "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [08:11<00:00, 4.68draws/s]\n", + "100%|██████████| 4000/4000 [00:38<00:00, 103.13it/s]\n" + ] + } + ], + "source": [ + "with pm.Model() as model2:\n", + " \n", + " sigma= pm.HalfCauchy('sigma',1)\n", + " gamma = pm.Lognormal('gamma',0,1)\n", + " #A prior on the acceleration due to gravity\n", + " g = pm.Lognormal('g',pm.math.log(10),2)\n", + " \n", + " #Notice now I have passed g to the odeparams argument\n", + " ode_solution = ode_model(odeparams = [gamma, g], y0 = [0]).reshape(yobs.shape)\n", + " \n", + " Y = pm.Normal('Y', mu = ode_solution, sd = sigma, observed = yobs)\n", + "\n", + " \n", + " trace = pm.sample(2000,tune = 1000, target_accept = 0.9)\n", + " prior = pm.sample_prior_predictive()\n", + " posterior_predictive = pm.sample_posterior_predictive(trace)\n", + " \n", + " data = az.from_pymc3(trace = trace,\n", + " prior = prior,\n", + " posterior_predictive = posterior_predictive)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([,\n", + " ,\n", + " ],\n", + " dtype=object)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "az.plot_posterior(data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The uncertainty in the acceleration due to gravity has increased our uncertainty in the prportionality constant.\n", + "\n", + "Finally, we can do inference on the initial condition. If this object was brought to it's inital height by an airplane, then turbulent air might have made the airplane move up or down, thereby changing the inital velocioty of the object. \n", + "\n", + "Doing inference on the inital condition is as easy as specifying a prior for the inital condition, and then passing the inital condition to `ode_model`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Auto-assigning NUTS sampler...\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (2 chains in 2 jobs)\n", + "NUTS: [y0, g, gamma, sigma]\n", + "Sampling 2 chains, 0 divergences: 0%| | 0/6000 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "az.plot_posterior(data, figsize = (13,3));" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that by explicitly modelling the initial condition, we obtain a much better estimate of the acceleration due to gravity than if we had insisted that the object started at rest." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Non-linear Differential Equations\n", + "\n", + "The example of an object in free fall might not be the most appropriate since that differential equation can be solved exactly. Thus, `DifferentialEquation` is not needed to solve that particular problem. There are, however, many examples of differential equations which cannot be solved exactly. Inference for these models is where `DifferentialEquation` truly shines.\n", + "\n", + "Consider the SIR model of infection. This model describes the temporal dynamics of a disease spreading through a homogenously mixed, closed population. Members of the population are placed into one of three cateories: Susceptible, Infective, or Recovered. The differential equations are...\n", + "\n", + "\n", + "$$ \\dfrac{dS}{dt} = - \\beta SI \\quad S(0) = S_0 $$\n", + "$$ \\dfrac{dI}{dt} = \\beta SI - \\lambda I \\quad I(0) = I_0 $$\n", + "$$ \\dfrac{dR}{dt} = \\lambda I \\quad R(0) = R_0 $$\n", + "\n", + "With the constraint that $S(t) + I(t) + R(t) = 1 \\, \\forall t$. Here, $\\beta$ is the rate of infection per susceptible and per infective, and $\\lambda$ is the rate of recovery.\n", + "\n", + "If we knew $S(t)$ and $I(t)$, then we could determine $R(t)$, so we can peel off the differential equation for $R(t)$ and work only with the first two. \n", + "\n", + "\n", + "In the SIR model, it is straight-forward to see that $\\beta, \\gamma$ and $\\beta/2, \\gamma/2$ will produce the same qualitative dynamics but on much different time scales. To study the *quality* of the dynamics, regardless of time scale, applied mathematicians will *non-dimensionalize* differential equations. Non-dimensionalization is the process of introducing scaleless variables into the differential equation to understand the system's dynamics under families of paramterizations.\n", + "\n", + "To non-dimensionalize this system, let's scale time by $1/\\lambda$, the rate of recovery (we do this because people stay infected for an average of $1/\\lambda$ units of time. It is a straight forward argument to show this. For more, see CITE). Let $t = \\tau/\\lambda$, where $\\tau$ is a unitless variable. Then...\n", + "\n", + "\n", + "$$ \\dfrac{dS}{d\\tau} = \\dfrac{dt}{d\\tau} \\dfrac{dS}{dt} = \\dfrac{1}{\\lambda}\\dfrac{dS}{dt} = -\\dfrac{\\beta}{\\lambda}SI$$\n", + "\n", + "and \n", + "\n", + "$$ \\dfrac{dI}{d\\tau} = \\dfrac{dt}{d\\tau} \\dfrac{dI}{dt} = \\dfrac{1}{\\lambda}\\dfrac{dI}{dt} = \\dfrac{\\beta}{\\lambda}SI - I$$\n", + "\n", + "The quantity $\\beta/\\lambda$ has a very special name. We call it *The R-Nought* (\\$\\mathcal{R}_0$). It's interpretation is that if we were to drop a single infected person into a population of suceptible individuals, we would expect $\\mathcal{R}_0$ new infections. If $\\mathcal{R}_0>1$, then an epidemic will take place. If $\\mathcal{R}_0\\leq1$ then there will be no epidemic (note, we can show this more rigoursly by studying eigenvalues of the system's Jacobain. For more, see CITE).\n", + "\n", + "This non-dimensionalization is important because it gives us information about the parameters. If we see an epidemic has occured, then we know that $\\mathcal{R}_0>1$ which means $\\beta> \\lambda$. Furthermore, it might be hard to place a prior on $\\beta$ because of beta's interpretation. But since we $1/\\lambda$ has a simple interpretation, and since $\\mathcal{R}_0>1$, we can obtain $\\beta$ by computing $\\mathcal{R}_0\\lambda$. \n", + "\n", + "Side note: I'm going to choose a likelihood which certainly violates these constraints, just for exposition on how to use `DifferentialEquation`. In reality, a likelihood which respects these constraints should be chosen.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def SIR(y,t,p):\n", + " \n", + " ds = -p[0]*y[0]*y[1]\n", + " di = p[0]*y[0]*y[1] - p[1]*y[1]\n", + " \n", + " return [ds,di]\n", + "\n", + "times = np.arange(0,5,0.25)\n", + "\n", + "beta,gamma = 4,1.0\n", + "#Create true curves\n", + "y = odeint(SIR, t = times, y0 = [0.99, 0.01], args = tuple([[beta,gamma]]), rtol=1e-8 )\n", + "#Observational model. Lognormal likelihood isn't appropriate, but we'll do it anyway\n", + "yobs = np.random.lognormal(mean = np.log(y[1::]), sigma = [0.2, 0.3])\n", + "\n", + "\n", + "plt.plot(times[1::],yobs, marker = 'o', linestyle = 'none')\n", + "plt.plot(times, y[:,0], color = 'C0', alpha = 0.5, label = f'$S(t)$')\n", + "plt.plot(times, y[:,1], color = 'C1', alpha = 0.5, label = f'$I(t)$')\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Auto-assigning NUTS sampler...\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (2 chains in 2 jobs)\n", + "NUTS: [lambda, R0, sigma]\n", + "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [19:52<00:00, 3.53draws/s] \n", + "100%|██████████| 4000/4000 [02:19<00:00, 28.76it/s]\n" + ] + } + ], + "source": [ + "theano.config.compute_test_value = \"ignore\"\n", + "sir_model = DifferentialEquation(func = SIR,\n", + " times = np.arange(0.25, 5, 0.25), \n", + " t0 = 0,\n", + " n_states = 2,\n", + " n_odeparams=2)\n", + "\n", + "with pm.Model() as model4:\n", + " \n", + " sigma = pm.HalfCauchy('sigma',1, shape = 2)\n", + " \n", + " #R0 is bounded below by 1 because we see an epidemic has occured\n", + " R0 = pm.Bound(pm.Normal, lower = 1)('R0', 2,3)\n", + " lam = pm.Lognormal('lambda',pm.math.log(2),2)\n", + " beta = pm.Deterministic('beta', lam*R0)\n", + "\n", + " \n", + " sir_curves = sir_model(odeparams = [beta, lam], y0 = [0.99, 0.01]).reshape(yobs.shape)\n", + " \n", + " Y = pm.Lognormal('Y', mu = pm.math.log(sir_curves), sd = sigma, observed = yobs)\n", + " trace = pm.sample(2000,tune = 1000, target_accept = 0.9)\n", + " prior = pm.sample_prior_predictive()\n", + " posterior_predictive = pm.sample_posterior_predictive(trace)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "data = az.from_pymc3(trace = trace,\n", + " prior = prior,\n", + " posterior_predictive = posterior_predictive)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABdoAAAKeCAYAAACyHKnKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdd3yV5f3/8ffJyd5khwQSwriBsJEhIiKKggylal0/V2vtstparautHdpv1dbaar/Oaq21arV1MByICAoCMmQFbkYggZC9d3Jy7t8fAb6AjEDGfcbr+XjwUE7unPO+T3jkuu/Pua7P5bAsSwAAAAAAAAAA4MwE2B0AAAAAAAAAAABvRqEdAAAAAAAAAIBOoNAOAAAAAAAAAEAnUGgHAAAAAAAAAKATKLQDAAAAAAAAANAJFNoBAAAAAAAAAOgECu2ADzIMwzIM4y67cwAAgNPDGA4AAAB4p0C7AwDoFmdLyrM7BAAAOG2M4QAAAIAXcliWZXcGAAAAAAAAAAC8FjPaAS9lGMYESY9JGi2pVdISSXeZpplnGIYl6W7TNP9w8NjzJT0iabikXEl3Sloo6RbTNP9uGMavJM2W9BdJv5SUJmmFpOslzZX0gKQYSfMl3WqaZsPB5zUkPSRp6sGvH5D0N0kPmabJp3gAABwHYzgAAADge+jRDnghwzBiJC2SVCDpUknfkTRG0uvHOXa4pPclFUv6hqS/S/q3JOexh0q6R9Ldkm6RNFHSMknfkvR9SQ9KulbSHQefN1LSp5LiJd0oaZakTyT9Ru03/AAA4BiM4QAAAIBvYkY74J2GSIqT9BfTNL+QJMMwyiRNMwzj2A/Q7pW0X9I80zRdkt43DMMt6Q/HHBcp6Vumaa4++HyzJV0tKdM0zbyDj10uacLB4w1JuyRdZZpm6cGvL5E0T9J5ap85BwAAjsYYDgAAAPggCu2Ad9oqqULSfMMwXlf7EvJPTNNcJkntq8EPmyrpzYM36Ie8qa/fpFuS1h7x92JJpYdu0A8qlxQrSaZprpN0rmEYQYZhDJU0SO1L4IMkhXTq7AAA8F2M4QAAAIAPonUM4IVM06yVNEXtPV1vVPsS9CLDMH52nMMTJJUe81jxcY5rME2z7djHTpbDMIwHDj73VklPSBqo9l6zjlOdAwAA/ogxHAAAAPBNFNoBL2Wa5lbTNK9Se3/VCyV9JumRgxusHalAUuIxjx3799NmGMYNkn6r9mXtsaZpZpqmea3ab9IBAMAJMIYDAAAAvofWMYAXMgxjhqR/SMo+2Ft1iWEYuyTNkdT3mMM/kzTLMIw7TdN0H3zs0i6Icbak/aZpPnNErjFqLwAwGw4AgONgDAcAAAB8E4V2wDutUfuN8H8Nw3hEUoukH0uqkrT0mGN/L+krSf8xDONZtfdh/e3Br7l15r6U9D3DMH4paZnaN3d7UO19YsM78bwAAPgyxnAAAADAB9E6BvBCpmlWSJohqUnSK5LelhQq6ULTNMuOOXab2mfJ9ZP0rqRbJf3k4JfrOhHj75IekfQ9tfeX/ZGkxyT9TdLETjwvAAA+izEcAAAA8E0Oy7LszgCgGxmGcaGkWtM0Vx/x2EWSPpQ00jTNTbaFAwAAJ8QYDgAAAHgPWscAvm+ipLsNw7hLkikpQ9JvJC3nBh0AAI/GGA4AAAB4CQrtgO/7vaQQSfdKSpNUofZl6vfZGQoAAJwSYzgAAADgJWgdAwAAAAAAAHQRwzA+lXTeMQ+3SaqUtFLSPaZpbj94bB9Jf5E0Te17uLws6eemabb0WGAAXYIZ7QAAAAAAAEDXWiHpriP+HiJppKQHJX1kGMYgSZakjyQ1SrpeUl+1b1geLum2Hk0LoNMotAMAAAAAAABdq8o0zVXHPLbMMIwGSc+rfQZ7sqQBkvqZprlfkgzDaJT0jGEYvzVNs7hHEwPolAC7AwCwl2EY3zEMY6dhGI2GYXxhGMbZdmcCAAAdZxjGXMMwau3OAQAAOuTIMftCSesPFdkPekftE2Mv6NFUADqNGe2AHzMM40ZJz0j6jaQvJf1I0oeGYYw0TXOPreEAAMApGYYxSdI/JTnszgIAAI7iMAzjyLpbqKSzJD0sKV/Sckm/lrTjyG8yTbPcMIwaSYN6KiiArsGMdsBPGYbhUPug/pxpmr82TXORpLmSyiT9xNZwAADgpAzDCDEM42eSlkpy2Z0HAAB8zSWSWo/4UytpkaQcSReYplknKVpHz3A/pPbg1wB4EQrtgP8aIClD0nuHHjBNs1XSQkkz7AoFAAA6ZKak+yTdLelJm7MAAICv+1zSuIN/bpZUIWm+pCtN09x18BiH2jdEPR53tycE0KVoHQP4r0PL0HYd83iupP6GYThN02zr4UwAAKBjvlT7xmlVhmH8yu4wAADga6pN01x78P/XGoaRL+ljSc2Sbjh0jKSo43xv1MGvAfAizGgH/NehZWjHLlOrVfvvhoiejQMAADrKNM0C0zSr7M4BAAA6xjTNTyT9TdL1hmHMOfjwTklZRx5nGEa82u/XzZ5NCKCzKLQD/uvQpmksUwMAAAAAoPvdp/aZ6o8bhhEsaYmkswzDSD/imMvU3tN9uQ35AHQChXbAfx1ahnbsMrUoSW0HN2YBAAAAAABdwDTNMkm/U/ueabdLek3SAUkfGIYxzzCMH0r6i6TnTNMssi8pgDNBoR3wXzsP/jfrmMezJO3o4SwAAAAAAPiDP0vaK+nnam/ZeqGk/ZJePfjY/0r6iV3hAJw5NkMF/NdOSfvUviztI0kyDCNI0ixJC23MBQAAAACA1zJNc+pJvtYsqd8RD5VKmtHdmQB0PwrtgJ8yTdMyDOP3kp4yDKNS0gpJt0lKkPQnW8MBAAAAAAAAXoTWMYAfM03zfyXdLel6SW9JipV0sWmaubYGAwAAAAAAALyIw7IsuzMAAAAAAAAAAOC1mNEOAAAAAAAAAEAndGmP9tLSWkuSIiNDVFfX3JVP7XV4D3gPJN4DifdA4j3w9/OXuv89SEyMcnTm+w+N313BX37e/nKekv+cK+fpWzhP3+OL5+pJ43dn+OLP5nj85TwlztVXca6+iXO1x4nG8G6Z0R4Y6OyOp/UqvAe8BxLvgcR7IPEe+Pv5S/71HvjLufrLeUr+c66cp2/hPH2PP52rt/GXn42/nKfEufoqztU3ca6ehdYxAAAAAAAAAAB0AoV2AAAAAAAAAAA6gUI7AAAAAAAAAACdQKEdAAAAAAAAAIBOoNAOAAAAAAAAAEAnUGgHAAAAAAAAAKATKLQDAAAAAAAAANAJFNoBAAAAAAAAAOgECu0AAAAAAAAAAHQChXYAAAAAAAAAADoh0O4A8H4ltc1asrNMZnGt9lY0KjQoQNGhQTp7QIIm9YlRclSI3REBAICkumaXVu6p0KYDNSqoblJ5fYvCg52KCQ3SoKQIjUqL0Yje0QpyMhcDAAD4poqGFn2+u0LbS+qUV9WoqvoWORwORYcGamBihLJTojSlf7xCg5x2RwXgZSi044wdqG7Si6vytTCnWC63pbjwIPVPiJCrza1dpXVaurNMknRe/3jdcV6W+vQKszkxAAD+aWtRrV5es0/Ld5erzW0pPMiptNhQxUcEq6m1TbvK6vXJwXE7LjxIlw1P0RWjeisxkg/LAQCA97MsS5/nVui19QVat69KbkuKCHZqUHKUkqNCZEkqr2/RfzYW6l/rChQR7NRFgxP17YkZTB4E0GEU2nFGluwo1W8/3CGX29K8Eam6Zkza1wrplS5Lb6zO02vrCnTVy2t147g+uuXsDDkDHDalBgDAvxTVNOmRJbv0eW6FokICdfXoNJ0/MF7DUqO/Nh7XNLVq/b5qvbelSC+t3qfX1hfoe+dk6rvnD7QpPQAAQOet3lupvyzP1Y7SeqVEheim8X10waBEDUyMUK9eEaqqajh8rMttaWNBtRZsLdainBJ9uK1U35ucqW+O6k0tA8ApUWjHabEsS08sy9W/1hVoWGqUHp41RL1jQo97bL+ECH3vnExdMTJVf1m+Ry+syteWolo9PGuwokODejg5AAD+ZcHWIv3hk91yW5ZuO7efLh+ZqsiQE1/6RYcGaerABE0dmKD9VY36wye79adPc7VkV7kenmkoJfr44z0AAIAnKqtr1uOf5mqxWaq0mFD98uJBmjkkSYEnaZEXGODQ2D6xGtsnVt+e2FePLtmlx5fu1so9FfrdrCGKCqWMBuDEaMCJDrMsS48u2aV/rSvQlaN667mrRp6wyH6khMgQ/eaSwbp/+kCtza/Szf/6SsW1zT2QGAAA/9PmtvTHpbv16w92aFBSpP51w1jdOL7PSYvsx0qPDdOf5mXr4VmDtbu0Tje+ukEbC6q7MTUAAEDX+Wx3ua5+eZ2W7SrTrWdn6I2bztKcYSknLbIfKz02TH/+xjDdN32gvsyv0s3/2qD8ysZuTA3A21FoR4dYVvtN+1sbC3X9Wem6e1r/094obd6IVD195QiV17foB29uUll9SzelBQDAPzW73Lp3fo5eX1+gq8ek6ekrRyg99sz2SHE4HLpocJLeuvVsRQQ79b1/b9Ly3eVdnBgAAKDruNyW/vTpbt35zlYlR4Xo1evH6juTMhQSeGblL4fDoW+MSNX/Xjlc1U0ufe/fG7W/imI7gOOj0I4OefOrA3pjwwFdOzZNP5rSTw7HmfUmG5UeoyfmDVNJbbN++OYmVTe2dnFSAAD8k8tt6f4F27RsV7l+MjVLPz2/f5f0Eh2QFKm/Xzdag5Iide/8HK3IreiCtAAAAF2rrtmln7y9Rf9aV6CrRvfWS9eOVmZ8eJc895j0WD39zRFqcbn1wzc3sUofwHFRaMcprd9fpcc/zdW5WXG647ysMy6yHzIqPUaPz8vWvqpG3b9gm1xuq4uSAgDgn9yWpYc+2qHlu8t117QBunZsepc+f3RokJ68fJj6x0fo7ve2am1+VZc+PwAAQGeU1jXr2699pS/zq/TA9IG6a9oABZ/hLPYTGZAQob9c3j6z/fb/bFZDS1uXPj8A70ehHSdVVt+i++ZvU3pMqH5zyWAFdLLIfsi4vr1074UDtSa/Sk98urtLnhMAAH/1/Mo8LdxarFsnZeibo3t3y2tEhwbpqSuGKz02TPfMz6FHKQAA8AiFNU269Y2NKqpp1pOXD9NlI1K77bWGpkTpkblDtbeiQb/9cIcsi4mDAP4PhXackGVZ+p/FO1Xf0qZHLx16WpuodcTcYSm6dmya3thwQAu2FnXpcwMA4C9W7KnQC6vyNTs7WbdM7NutrxUTFqTHL8tWgMOhn7y9RTVNtIADAAD2OVDdpFtf36iqxlY9dcVwjevbq9tfc0JGL/1gcj99vKNUr60v6PbXA+A9KLTjhN7fVqLlu8v1/XMylRUf0S2v8aMpWRrbJ0aPLtmlfcyMAwDgtBTVNOnBRds1MDFC91wwoNPt3ToiPTZMj84dqgPVTfrV+yYzuQAAgC3K6lv0w7c2qb6lTU9fOULDe0f32GvfMC5dUwfE6y/LcrW9uLbHXheAZ6PQjuMqq2vWH5fu1oje0bp6TFq3vU5ggEO/mmEoyBmgXyzaLlebu9teCwAAX+K2LP3yfVMut6Xfzxmq0CBnj7326PQY/WhKP32WW6H/bCzssdcFAACQpJqmVt3+n80qq2vRE98YpsHJUT36+g6HQ7+4eJDiIoL14PumWlzUMgBQaMcJ/Hn5HjW1tukXFw+SM6B7Z8elRIfqvgsHamtRrV5Yld+trwUAgK/478ZCbdhfrTun9lffXmE9/vpXj0nTxMxeemJZrnLL63v89QEAgH9ytbl1z/xt2lPeoD9cmq0RPTiT/UjRoUF6YPog5ZY36Lkv8mzJAMCzUGjH12wsqNYH20p03VnpyowL75HXvNBI1CVDk/T3Nfu0o6SuR14TAABvVVTTpCeX79H4vrGaMyzZlgwBDocenGEoPMipBxe1z6wHAADoTpZl6bFPdmttfpUeuGigJmR2f0/2kzknK05zhyXrlS/3aRstZAC/R6EdR3Fblv64dLcSIoJ10/ju3VDtWD+Z2l8xoYF66KMd3KwDAHASjyzZJbdl6f6LBvZIX/YTSYgI1s8uGKDtJXX69wY2AwMAAN3rrY2F+u+mQt0wro9mZ6fYHUdSey0jNixIjx68PgPgvyi04yiLcoq1rbhOP5rST+HBPdfrVZJiw4J097QB2lZcp9fW7e/R1wYAwFt8sbdCn+dW6NZJGUqL6fmWMce6YFCCJmfF6ZkVe1VU02R3HAAA4KNyimr1+NLdmpwVpx+em2l3nMMiQwJ1+5QsbSms1fwtRXbHAWAjCu04rMXl1rMr8jQkOVIzhiTZkuGCQQma0j9ez63MU3Ftsy0ZAADwVC63pSc+zVV6bKiuGt19m5WfDofDoZ9dMECWJT26ZJfdcQAAgA+qbXLpvgXbFB8RrF/NMBRg44q+47lkaJJG9o7WU5/tVXVjq91xANiEQjsOe3dLkYpqm/X9yZm2DVoOh0N3np8lt2Xpqc/22JIBAABP9d6WIuWWN+hHU7IUHOg5l3Gp0aG6dVKGPsut0Bd7K+yOAwAAfIhlWXp48Q4V1zbrd7OHKCYsyO5IX3No4kFNU6teXJ1vdxwANvGcOzTYqqm1TS+tztfI3tGamGHvZiJpMWH6f2el64NtJdpYUG1rFgAAPEVDS5ueXbFXo9Oidf6AeLvjfM1Vo9OUHhuqP32ay14rAACgy3y0vVRLdpTpu5MyNKJ3tN1xTmhQUqRmDU3Wm18dUCHt9AC/RKEdkqT/bipUaV2Lvj8509ZN1Q65cXxfJUYG649Ld7OZCAAAkv6z8YAqGlp125QsjxirjxUcGKDbp2RpT3mD3tlUaHccAADgA8rqmvXoJ7s0LDVK14/rY3ecU7p1UoYckp5dsdfuKABsQKEdana59Y8v9+usPjEa2yfW7jiSpPBgp247t5+2FddpwdZiu+MAAGCrptY2/XPtfo3vG+vRM7mmDojXmPQYPbsyT3XNLrvjAAAAL2ZZlv7n411qdrn14AxDgQGeN9HgWCnR7fvoLMop0a7ServjAOhhFNqhRTnFKq9v0U0T+tod5SgzhyRpeGq0/vrZHm7WAQB+7Z3NRapoaNW3z/assfpYDodDd5yXparGVr22rsDuOAAAwIt9uqtcy3eX67uTMpQZF253nA67cXwfRYQ49Qyz2gG/Q6Hdz7W5Lf1z7X4NTorU+L6eMZv9EIfDoZ9O66+Khla9xGYiAAA/1b7ybJ9Gp8doTLpnjdXHMzQlSlMHxOvVdftV1dhqdxwAAOCFGlra9MeluzUwMULXjE23O85piQkL0jVj0rRsd7l2ltbZHQdAD6LQ7ueW7SpTfmWjbhjfxyP7vWanRGl2drL+ta5A+6sa7Y4DAECP+2BbsUrrWvRtD1t5djLfPSdTDS3t7W4AAABO199W5am4tln3XDDAK1rGHOvqMWmKCHbqxVVMGgT8CYV2P2ZZlv7x5X6lx4Zq2sAEu+Oc0A8nZ8oZ4NBzK/PsjgIAQI+yLEuvrS/QwMQIjc/w/NnshwxIiNBFgxP1xvoClde32B0HAAB4kb3lDXp1XYHmDkvWyLQYu+OckejQIH1zdG8t2VGm3HJ6tQP+gkK7H9tcWKutRbW6dmy6nB78CXFCZIiuGt1bH2wr0a4yBigAgP9Yu69Ku8sadPWYNI9ceXYy3zk7Qy1tbv1rHbPaAQBAxz352R6FBgboh+f2sztKp1w7Jl2hQQHMagf8CIV2P/bvDQWKCHZq1tBku6Oc0vXj+ig82Kln2UwEAOBHXltXoF5hQbp4cJLdUU5bRly4LhyUqP9sLFRNE73aAQDAqa3bV6Xlu8t10/g+igsPtjtOp8SGB+kbI3rrY7NUhTVNdscB0AMotPupsvoWLdlRpjnDUhQe7LQ7zinFhgXpurPS9emucm0tqrU7DgAA3S6/slGf51bo8pGpCgn0zku2G8f3UX1Lm9786oDdUQAAgIdzW5b+vCxXyVEhunpMmt1xusTVY3pLDof+ta7A7igAeoB33rWh097eVCiX29KVo3rbHaXDrhmTppjQQD3z+V67owAA0O3+s/GAnAEOXe5FY/WxBiVFanJWnF5bV6DG1ja74wAAAA/2sVmqbcV1+sHkTIUGef6EwI5IiQ7VxYMT9e5mVvgB/oBCux9ytbn1342FOjuzl/r2CrM7TodFhgTqpgl9tSqvUuv2VdkdBwCAbtPicmvh1mKdNyBeCRHevWz6pvF9VN3k0jubi+yOAgAAPFSb29JzK/PUPyFcM4Z4X8u8k7lubLoaW936z8ZCu6MA6GYU2v3Q8t3lKqtv8arZ7IdcMTJViZHBevrzvbIsy+44AAB0i2W7y1Xd5NKlw1PsjtJpI9NiNCotWq+v2y+Xm7EbAAB83YfbS5RX2ahbJ2UqwMs2gD+VQUmRmpjRS6+vL1CLy213HADdiEK7H3p7c5GSIoM1qV+c3VFOW2iQU9+e2Febtm7V//vWjbrggnN09dXz9P77C076fRUV5XrooQd16aUXa8aMqbrzztuUm7vruMd+/PGHuuqqy7ojPgAAHfLOpkKlRodoQkYvu6N0ievGputATbOW7SrT9u05+v73v9WlY/imTV/pu9+9WdOmnaMrr7xUb731eneeDgAA6EIut6UXvsjToMQITR0Qb3ecDvnZz36s2267tcPHh2x6SzWf/1Of7Cw76vE1a1bpppuu1bRp5+jGG6/WF1+s6OqoAHoQhXY/c6C6Sav3VmrusBQ5A7zzU+Ip6SEK+eI5VYUk629/+6euuOIq/f73v9WaNauOe7zb7db999+tffvy9T//80c9/fSLioiI1B13/EDV1Ue3oFmx4jP9z//8pidOAwCA4yqobtSa/CrNGZbiMzO6zu0fr/TYUL382TbdeeePNGjQYL344qtdMobn5e3VT37yQw0dOkz/+MfruvnmW/TUU09o6dKPe/IUAQDAGVqUU6x9VU1eM5v9nXf+o5UrP+/QsZZl6YUXntGqTxYqIsSpf2/4vw3i9+zJ1b333qnzz79AL730qiZPPk/333+XcnN3d1d0AN2MQrufeW9Le3/UuV68FP2DRe8pOjJSJQNmqUgxuuKKq3XxxZfotddeOe7xu3bt0JYtm3Tffb/U0KHD1K9fln7xi9+osbHh8ODY3NykRx55WA88cLfS0/v25OkAAHCU97YUK8AhzclOtjtKl3EGOHTNmHTtWP2xgkLDdccddykjI7NLxvBXXnlJQ4Zk6447fqr09D665JI5mjlzjjZu/KonTxEAAJyBNrell9fsk5EUqSn9PX/V/f79+/Tcc/+rYcNGnPLYgoL9uv327+mdd95ScnKK+sWFa3NhjbYV10qS3nzzNQ0dOkw33vhtZWRk6jvf+b6GDRuhN99kZR7grQLtDoCe43Jbmr+lSBMzeyk1OlSTJ5+le+75uRYtek+muV29e6fp3nt/qZ07Tb3yykuqq6vT2Wefowce+JWCg9s3Ytu4cYOefvpJ7dhhKj4+QRdcMF033/wdhYSESJJ27tyhZ599Slu2bFJTU5NSU3vrhhu+pZkzZ0uSbrvtVg0bNkKlpcX67LPlcjqdmj79Yt1++08VGBiov/3tWb300vPHzT9z5mw98MCvtHHjBk086yytigrVi6vyNTEzTqNHj9Uf//h7WZYlxzGfgCcnp+jRR59Q374Zhx8LCGj/jKm2tn2Aq6ysVH7+Xj3zzItaseIzffTR+1375gMA0AFuy9L7OcUan9FLKdGhJzyuJ8fwa675pqTOj+F3/uwXeqpyr5xJ/Q+Pw5I6PYavWbNKN9747aO+7557HujQ+w0AAHrWsdcwMQkpKhh4mS7r06bLL/9Fj9chJHWoDiFJbW1teuihB3XddTdo37587d+/76TnumXLJiUlJetXv3pYDz54v5J7hckMCtCbGw7olzMMbdr0lc4//8Kjvmf06LFasuSjM35/AdiLQrsfWbW3QiV1LfrptAGHH3v22b/q3nt/ob59++qhh36lu+++Q0OGZOsPf/iz8vPz9Otf/1yjRo3RvHlXaOdOU3feeZu+/e3v6ec//7WKi4v0xBOPqaKiXPff/6AaGxt155236ZxzztVzz/1dkZGhev75F/Toow9rwoSzFRfX3mvtjTde1Y03flsvvfSqNm/eqN/97tfKzh6uiy++RNdcc70uu+zy4+YPCWkvOJSWlmjgQEM3jOujPyzdrfX7q5SQkKCmpiZVV1crNjb2qO+LiYnVpEmTj3rszTdfV3Nzs8aPnyhJSklJ1V//2j6wrljxWVe83QAAnLaNBTUqrGnW9ydnnvLY7hzDLUt6/fV/6tFHH9b06dMUGBguqXNjeFiQU1HuOhW19lZpXbMSI9tvjjszhtfX16miolzh4eH67W9/oTVrVisuLk5XXHG15sxhvxUAADzRoWuYPn366Fs/+ZlCvnhBZY0juvwapiN1iKuuuqJDdQipfRWdwyFdc831evTRh095nhdffIkuvviSw38PcgbokqHJmr+lSLefl6WSkhIlJiYd9T0JCYkqKSk+k7cVgAegdYwfWbC1WLFhQTo36/+WY82Zc5kmT56ivn0zdfHFl6i2tkZ33XWvsrIGaOrUCzRgwKDD/cFee+2fOvvsybr22uuVnt5HY8eO0913369Fi+arrKxMTU2Nuuqqa/XjH9+tvn0zlZWVpeuvv1mtra3aty//8GsOGDBIN910i9LS0jVjxiz17z9AW7ZsliSFh4crPj7huH8iIyMlSU1NTQoJCdGlw1MUFx6kF1flKyio/ZPulpbmU74Pn3++TM8++5Suuuo6ZWb267L3FwCAzvpgW4lCAwN0Xv+EUx7bnWN4Rkbm4TE8L2/v4dfs7BgeGtAmd0Cg3tlUdPg5OzOG19fXS5KefPJPyszM0uOPP6m5c+fp8ccf0YIF73bsTQcAAD3q0DVMiSNWdamjZbU06K677uvya5iurENs375Nr7/+qh544NdHrcw7XVeM6q2WNkvvbS5Sc3PT4Vn7hwQFBamlpeWMnx+AvZjR7idqmlq1fHe5vjEiVUHO/xsU0tP7HP7/sLAwBQQEKDW19+HHQkJC1Nra/kt+xw5T+/fna/r0cw9/3bIsSVJe3h6NHTtO8+ZdoSt9t2gAACAASURBVA8+WKAdO0wVFR3Qtm3bJLUvsTqkb9+je6BHRETK5WqVJP3jHy/qlVdeOu45XHTRTN199/0KCQlRS0uLQoOc+n9npesvy/doSqRLkhQaGnbS92HRovl65JGHdOGFF+kHP7j9pMcCANCTWlxufbyjVFMHJig82HnK47tzDN+/f5927twhSWprcx/+ns6O4RFhoUqPDtTbmwt184Q+CnQGHM54JmN4YGD7peykSZN1/fU3S5IGDjSUl7dXb775mmbPvvSkzwkAAHreoWuYf6zZr4iwMLm67Rqma+oQt9/+Uz300C/1ne98/6jrrzMxICFCY/vE6K2NBxQcHKLW1tajvt7a2qrQ0BO3DwTg2Si0+4nFZqla2yzNOmZjtUM3qIc4HI6v9Uc9JCgoUDNnztZ11934ta/FxyeorKxU3/3uzUpMTNI555yriy66UKGh0brlluuPeZ7gr33/oYHysssu17Rp04/7+hEREZKkpKRklZeXSZK+MTJVL6/Zp/lrcxQWFn740+bjefnlv+n555/W5Zd/Uz/+8d0nPE8AAOywck+Fappcmjkk6dQHq3vH8EmTzlVCQmK3jOGtwa1aWdei5bkVmjYwQWVlZWc8hkdHxyg4OFhZWQOOOj4zM0vvv7/whM8HAADsExgYqN1l9VqVV6kLM3pp5ZeefQ2Tk7NFe/fu0TPPPKlnnnlSktTS0iLLsjR9+rl65ZU3lZKS0uHz/+ao3rpn/jal90o4XNs4pKys9GvtZAB4DwrtfmLh1hJlxYdrcNKJb2JPpV+//tq7d89Rn+Bu2bJJr776su666z4tXvyhGhoa9Ne/Pi+n06nY2HB9+OGS03qN6OgYRUfHnPSYESNGadGi+bIsSxHBgbpmbJpe+MsrGmlkn3AJ16uvvqznn39at9zyPd100y2nlQkAgJ7wwfYSxYUHaXxGry5/7tMdwyVp9eovDh5pdeg1OjqGL1w4X8kZc/TWVwc0bWCC1q9fq+HDR57RGB4YGKjs7OHavj3nqMdzc3crLS29Q7kBAEDPe2NDgUICAzS2T6xWnuS4zl3DdMyprmHCw8P1+utvH/XYs8/+VUVFhXrwwYeUkHDqln9HmjIgQUmRwXLHZWrDhvW66ab/+9r69Ws1cuTo03o+AJ6DHu1+IK+iQZsLazRraHKnZnFfd92NysnZoieffFx5eXu1YcM6PfTQg6qtrVV8fIKSkpLV0FCvTz/9REVFhVq69BM99tjvJKlLe4zNnn2pqqoq9dhjv9PevXsUsmeFnPvXS4MvOHxMTU21amqqJUm7du3Uc8/9r2bNmqs5cy5TeXnZ4T+NjY1dlgsAgDPV0NKmz3MrdOGgRAUGdP2Kq9Mdwz//fFm3jeHV1ZVK3vmu1m4x9dzLr2jx4g903XU3HD7mdMfwG264WcuWfaJXXvm7Cgr2a8GCd7Vw4bu66qpruyw3AADoOg0tbVqUU6KZQ5JO2S7PE65hQkJClZ7e56g/ERERCgkJUXp6n8OrDI+8hjmZwACHLh/ZW4VJ4/XVxvX629+eVV7eXr3wwjPKydmqK6+8pktyA+h5zGj3A+9vK1GAQ5o5tHPLj/r3H6DHHvuznn/+ab399luKiIjUOeecqx/84A5J0rRpF2rbtq164onH1NjYoL59M3TTTbfon//8u7Zvz9HEiZO64nQUFxevP/zhSf35z4/pW9+6TsnJKZp01Y/0aVOS8ioalBEXrvvvv1uS9NRTz2nJko/U1tamhQvf08KF7x31XMxwBwB4gs9zy9XscutCI7Fbnv90x/C0tD6Hx/AtW7Zo2LCxXZLj0Bj+xz89qqA1S/XfrxL185//WmPHjjt8zOmO4ePGTdTDDz+q559/Ri+++KySk1P04x/frZkzZ3dJZgAA0LXW7qtSsytGV49Jk7nGPOmxnbmG6co6REcceQ1zKpcOT9FzX6RpwjU/1dKlb+rVV19W376ZeuSRx5WZ2a+7owLoJo5DPam6QmlprSVJsbHhqqpq6LLn9Uae8h5YlqVvvPilekeH6q9XjujR1+7J96C8vkVzn1+t2dkpum/6wB55zY7wlH8HduI94D3w9/OXuv89SEyM6tQU6EPjd1fwl593V5/nz97L0aYDNVp46wQ5u2FGe2d018/05wu3acWeCi367kSFBZ1689fuxr9d38J5+h5fPFdPGr87wxd/NsfjL+cpde+5utrcuvSFNeoXH66nrujZGsXx2Plzvee9HK3fX61F352gIGf3N5zg37Bv4lztcaIxnNYxPi6nuE77q5p08WDf3kwjPiJYlwxN1oKtRapo6Lol7gAAdLeGljat3NO+MainFdm70xUje6uuuU0fbS+xOwoAAOghy3MrVFLXoitHpdkdxXaXDk9RVWOrlu8utzsKgC5Cod3HfbS9REFOh84feHqbc3ij685KV2ubpX9vOGB3FAAAOuxQ25gLBvn+WH2kkWnR6p8Qrje/KlRXrrAEAACe678bDyg5KkSTs+LsjmK7CRm9lBwVonc2F9kdBUAXodDuw9rclhabpZqUGaeoUN9vx58ZF64p/eP11lcH1NjaZnccAAA6ZMmOMsWFB2lUWozdUXqUw9G+EZhZUqec4jq74wAAgG6WX9mo1XlVmjcixa9W8Z2IM8ChucOStXpvpQprmuyOA6ALUGj3YV8VVKu0rkUXD/HttjFHun5cuqqbXJq/hU+EAQCer6m1TSv8sG3MITMGJykkMIBxGwAAP/DfjYVyBjh06bAUu6N4jDkH3wuuhQDfQKHdh324vUThQU6d60dLskb0jtbw1Ci9uq5AbW6WoQMAPNuqvZVqdrn9osXb8USFBmrawAR9uL1ETaxGAwDAZzW73FqwtUhTB8QrITLE7jgeIzU6VBMyeum9LcXUMAAfQKHdR7nclj7ZUaZz+8cpNMhpd5we43A49P/G9dGB6iYt3VlmdxwAAE7q093ligoJ1Jh0/2obc6S5w1JU19ympbsYtwEA8FXLdpWpusmleSNS7Y7icS4dnqLi2matzqu0OwqATqLQ7qPW76tSdZNLFwxKtDtKjzuvf7z6xIbqlbX72VwNAOCxXG5Ln+8u1+SsOAU6/feSbEyfGPWOCdV7W4rtjgIAALrJe1uKlBodonF9Y+2O4nGm9I9XbFiQ3mVTVMDr+e9dnY9bsqNMYUEBOjuzl91RepwzwKHrzkpXTlGt1u+vtjsOAADHtbGgWtVNLk0dEG93FFsFOByak52stflVKqhutDsOAADoYkU1TVqTV6XZ2ckKcPjfnjSnEhwYoEuGJmnZ7nJVNLTYHQdAJ1Bo90FtbktLd5Zpcla8X7WNOdKsocmKCQ3U6+sL7I4CAMBxLdtVrmCnQxMz/WcvlROZnZ0sh6QFzGoHAMDnLNhaLEvS7Gw2QT2RS4enqM1taVFOid1RAHQChXYf9FVBtSobW3XBIP/cWE2SQoOcmjciVct2lTM7DgDgcSzL0rJdZRqf0Uvhwf75ofiRUqJDNSGzl+ZvZSMwAAB8iduytGBrsc7qG6veMaF2x/FYWfERGp4arfc2F9ECF/BiFNp90MdmqUICAzSpn3/PkLtiVG8FOKQ3NxTaHQUAgKPsKqvXgZpmv28bc6S5w9o3Avsyn43AAADwFRv2V6uguklzhyXbHcXjzR6WrD0VDcoprrM7CoAzRKHdx7gtS0t3leucfnEK89O2MYckR4Vo2qBEvbulUA0tbXbHAQDgsM9zKyRJ52RRaD/kvP7xigkNZFNUAAB8yPwtRYoIdur8Af674r6jpg9KVEhggBZu5VoI8FYU2n1MTlGtyutbNHUgN+6SdPWYNNU1t2lhDgMVAMBzrMit0JDkSCVEBNsdxWMEBwZoxpAkfbqrTNWNrXbHAQAAnVTX7NLHO8p08eAkv90/7nREhQbqvP7x+nB7iVpcbrvjADgDFNp9zLJd5XI6pHP8vG3MIcNTozQ0JUpvrC+Qmz5nAAAPUN3Yqs2FNYzVxzF3WIpa2yx9sI2NwAAA8HYfm6Vqdrk1h7YxHTYrO1k1TS59nltudxQAZ4BCu49Zvrtco9NjFB0aZHcUj+BwOHTV6N7Kq2zUqr30fAUA2G91XqXclnROFoX2Yw1KipSRFMlKNAAAfMB7W4rVLz5c2SlRdkfxGhMyeikhIlgLaB8DeCUK7T5kf1WjcssbNIXeZ0eZbiQqPiJYr68vsDsKAABasadCsWFBGpLMTefxzMpO1rbiOu0qq7c7CgAAOEN7yxu0ubBGc7KT5XA47I7jNZwBDl0yNEkr91SovL7F7jgAThOFdh+yfHf70qIp/Zkhd6QgZ4AuH5mqL/ZWam95g91xAAB+zG1ZWrmnUmdn9pIzgJvO45kxOFHOAAcbgQEA4MUW5BTL6ZBmDqVtzOmalZ2sNkv6cDut9ABvQ6HdhyzfXa4BCRFKiwmzO4rH+caIVAU5HXpjA7PaAQD2ySmqVVVjK/3ZT6JXeLAm94vT+9tK5HKzvwoAAN7GbbXvtzIxM46N389AVnyEhiRH0j4G8EIU2n1EdWOrvtpfzWz2E4iPCNZFRqIW5ZSortlldxwAgJ9akVuhAIc0MbOX3VE82qzsZJXXt2g1+6sAAOB1viqoVnFts2YMSbI7iteanZ2inaX12lFSZ3cUAKeBQruPWLGnQm2W6M9+EleO6q2G1ja9v43lVwAAe6zYU6HhqdGKCWPT8pOZnBWnmNBAZnIBAOCF3s8pUVhQgM4bEG93FK910eBEBQY42CAe8DIU2n3E8t3lSogI1pDkSLujeKyhKVEakhypt746IMtiKToAoGeV17doW3Gdzsli9dmpBDkDNGNIkpbvLlNNU6vdcQAAQAe1uNxasqNMUwckKCzIaXccrxUbFqRz+8fr/ZwSudrcdscB0EEU2n1Ai8utL/ZUakr/eAWwm/cJORwOXTGyt3LLG7ShoNruOAAAP7NyT4UkaRL92TtkdnayWtosLTZL7Y4CAAA6aOWeCtU2u2gb0wVmDU1WZWOrVtJKD/AaFNp9wNp9VWpobdOU/izLOpWLBicqKiRQb31VaHcUAICfWbmnQomRwRqUGGF3FK9gJEWqf0K4FtI+BgAAr/HB9hLFhQdpfAb70XTWOf16qVdYENdCgBeh0O4Dlu8uV1hQgM7qG2t3FI8XGuTUnGHJWrqzTGX1LXbHAQD4CVebW6vyKjWpX5wcrD7rEIfDoVlDk7W5sFZ7KxrsjgMAAE6hrtmlz3aXa7rR3l8cnRN4uJVeuaoaaaUHeAMK7V7Osix9trtcEzPjFBLIj7MjvjEiVS63pfc2F9kdBQDgJzYV1qiuuU3n0DbmtMwckiSnQ8zkAgDAC3yyo0wtbZZm0jamy8zKTpbLbemj7bTSA7wBlVkvt72kTiV1LZrSnxv3jsqIC9f4vrH676ZCudxsigoA6H4rcisVGODQOFafnZaEyBBNzIzTopxitTFmAwDg0d7fXqI+saEamhJldxSfYSRFamBihBbmMOkA8AYU2r3citwKOSRmyJ2mK0b1VnFts1bkltsdBQDgB1btrdDItGhFhgTaHcXrzM5OVkldi9bmV9kdBQAAnEBJbbPW5VdpxpAk2uR1sdnZycopqlVueb3dUQCcAoV2L7dyT6WGpkSpV3iw3VG8yrn945UUGcymqACAblfR0KIdpfWawKZgZ+Tc/vGKCgnUAmZyAQDgsT4yS2VJmjEk2e4oPufiwbTSA7wFhXYvVt3Yqq1FNTo7kxv30xUY4NC8EalalVepfZWNdscBAPiwL/PaZ2KPp9B+RkICA3TR4EQt3VmmumaX3XEAAMBxfLCtRNkpUerbK8zuKD4nPiJYk/rF6f1tJbTSAzwchXYvtia/Sm5LOpu2MWfk0uEpcjqkd9gUFQDQjVbnVSo6NFCDkyLtjuK1Zmcnq9nl1pIdbAQGAICnyatokFlSp4sGJ9odxWfNzk5WaV2LVudV2h0FwElQaPdiK/dUKDo0UNlsNHJGEiNDdE5WvBZsLZKrzW13HACAD7IsS6vzKjWub6ycAfQrPVPZKVHK6BXGkmkAADzQYrNUDkkXDqLQ3l0mZ8UrJjSQayHAw1Fo91KWZemLvZWakNGLG/dOuGx4iioaWrU8t8LuKAAAH5RX0aiSuhbaxnSSw+HQ7OxkbSio0f4qWr4BAOBJFpulGpUWraSoELuj+KzgwABdNDhJn+4qU20TrfQAT0Wh3UvtKK1XeX2LJvXjxr0zzu4Xp6TIYL2ziU1RAQBdb9XB5b0TMmJtTuL9Zg5NlkNsBAYAgCfZXVav3PIGXWgk2R3F583KTlZLm6XFtNIDPBaFdi/1xZ72GdgTmSHXKYEBDs0dlqJVeytVWNNkdxwAgI9ZnVepPrGhSothY7DOSo4K0fiMWC3MKZbbYiMwAAA8wWKzVAEO6YJBCXZH8XlDkyPVLz5cC7Yw6QDwVBTavdTKvZUalBihhEiWZnXW3OEpkqT32BQVANCFXG1urd9XTduYLjQ7O0WFNc3asL/a7igAAPg9y7L0sVmqMX1iFR8RbHccn+dwODR7aLI2F9Yor6LB7jgAjoNCuxeqa3Zp04EaTeoXZ3cUn5AaHaqJmb303pYiudzMkAMAdI3NhbVqaG3TBArtXWbqgHhFBDu1gPYxAADYbmdpvfIqGzWd2ew9ZubQJAU4pEU5XAsBnohCuxf6Mr9KbW5LZ9OfvctcNiJVJXUth1vyAADQWavzKhXgkM7qQ3/2rhIa5NSFRqKW7ChVQ0ub3XEAAPBri81SOR3StIGJdkfxG4mRIZqQ0UsLc0popQd4IArtXmjlngpFBDs1IjXa7ig+Y0pWnOLCg/QO7WMAAF1kTV6lslOiFBUaaHcUnzJ7aLIaW91aurPM7igAAPgty7K02CzVuL69FBseZHccvzI7O1nFtc1am19ldxQAx6DQ7mUsy9IXeys1PqOXAp38+LpKoDNAc4alaEVuuUrrmu2OAwDwcrVNLm0tqqU/ezcYmRat9NhQLWDJNAAAttlWXKeC6iZNN5jN3tPOG5CgyBBa6QGeiEqtl8ktb1BxbbMmZXLj3tUuG56iNkuazw7eAIBO+nJfldyW6M/eDRwOh2YNTdba/CoV1jTZHQcAAL+02CxVYIBDUwfG2x3F74QEBugiI0mf7CxTXbPL7jgAjkCh3ct8sbdSkjSRQnuXS48N01l9Y/XuliJ6nQEAOmVNXqXCg5wanhpldxSfdMnQZElsBAYAgB0sy9LHZqkmZPRSdChtY+wwKztZzS63PtlBKz3Ak1Bo9zJf7KlQVny4UqJD7Y7ik+YNT9GB6iZ9mUevMwDAmVudV6mxfWJo89ZNeseE6qw+MVq4tVgWH44DANCjthTWqqi2mbYxNhqeGqW+vcJopQd4GO7+vEhTa5u+KqhmNns3mjogQTGhgXpnc6HdUQAAXqqgulH7q5poG9PNZmUna19VkzYdqLE7CgAAfmWxWaogp0PnDaBtjF0cDodmZydrw/5q7a9qtDsOgIMotHuRTQdq1NJmaXxfbty7S3BggGZlJ+vTXeWqaGixOw4AwAutPrgqikJ795o2MFHhQU69u7nI7igAAPgNt2VpyY5STcqMU2RIoN1x/NrMIUlyiFZ6gCeh0O5F1uRXyRng0Oj0GLuj+LTLhqfK5ba0kB28AQBnYE1epZIig5URF2Z3FJ8WHuzURYMTtdgsZSMwAAB6yMaCGpXUtdA2xgOkRIdqXN9YLdxazD5zgIeg0O5F1uRVakRqlMKDnXZH8Wn94sM1Ki1a72wuou8rAOC0tLktfZlfpQkZveRwOOyO4/PmjUhVk8utD7aV2B0FAAC/sNgsVUhggCb3j7M7CtTeSu9ATbM27K+2OwoAUWj3GtWNrdpeXKdxLEPvEXOHpSi/slEbC+j7CgDouO3FtappctE2pocMSY7UoMQIvb2pkA/HAQDoZm3u9rYx5/SLU0QwbWM8wfkDExQR7NQCVuQDHoFCu5dYt69KlqTxfWPtjuIXLjQSFRHs1Dtb6PsKAOi4Q/3Zx2UwXvcEh8OheSNStaO0XtuK6+yOAwCAT9uwv1oVDa20jfEgYUFOXTAoQUt2lKqhpc3uOIDfo9DuJdbkVyki2KnslCi7o/iFsKD2vq9L6PsKADgNq/MqNSgxQnHhwXZH8RszhiQpNDBAb28qtDsKAAA+bbFZqrCgAE3Oom2MJ5mdnaLGVreW7iyzOwrg9yi0e4k1eZUakx6jQCc/sp5y6bAUNbnc+sgstTsKAMALNLS0adOBGtrG9LDIkEBNNxL14fYS1bfw4TgAAN3B5bb0yc4ynZsVr9Ag9o3zJKPSopUWE6oFObSPAexG1dYLHKhu0r6qJo3nxr1HDU2J0oCECL27mfYxAIBT27C/Wi63pQmZjNc9bd6IVDW2uvXRdj4cBwCgO6zNr1RVI21jPJHD4dCs7GStza/Sgeomu+MAfo1CuxdYk1cpScyQ62EOh0Nzh6cop6hWu0rr7Y4DAPBwq/MqFRIYoFFpMXZH8TvDUqPUPyGc9jEAAHSTxWapIoKdOrsfbWM80ezsZDkkvcc+c4CtKLR7gTX5VUqMDFZmXJjdUfzOzCFJCnI69C6DFQDgFFbnVWpUWrRCArm86mkOh0PzhqdqW3GdTDZFBQCgS7W2ubV0Z7mm9I/nOsdDpUaHamJmL83fUiSX27I7DuC3+A3p4dyWpS/zqzS+b6wcDofdcfxObFiQzuufoPdzitXictsdBwDgoUpqm5Vb3sDqMxvNHJqkkMAAvb2ZWe0AAHSl1XmVqm120TbGw102IlUldS1atbfC7iiA36LQ7uF2ltarqrGV/uw2umx4iqqbXPp0Fzt4AwCOb01+e5s3xmv7RIcG6cJBCXo/p0R1zWyKCgBAV/nYLFVUSKAmsg+NRzs3K05x4UF6ZxMr8gG7UGj3cIf6s4/rG2tzEv81LiNWqdEh9DoDAJzQ6rwq9QoL0sDECLuj+LVvjk5TQ2ub5m8ttjsKAAA+odnl1qe7yjV1QLyCnJSQPFmQM0Czs5P1eW65yuqa7Y4D+CV+S3q4NflV6hcfrsTIELuj+K0Ah0NzslO0Oo8dvAEAX2dZltbkVWp8RqwCaPNmq6EpURrRO1r/3lCgNvqTAgDQaav2Vqi+pU0X0jbGK8wdlqI2S0w6AGxCod2Dtbjc2rC/WuOZzW67OcPad/Cez6x2AMAxdpXVq6KBNm+e4qrRvbW/qkkr99CfFACAzlpsliomNJC6hJfIiAvXmPQYvbu5SG6LSQdAT6PQ7sE2F9ao2eXWuL7cuNstJTpUEzJ7af7WYmbIAQCOsjqvSpLYCNVDTBuYoKTIYL2+vsDuKAAAeLWm1jYt312u8wcmKJC2MV7jshEpKqhu0rp9VXZHAfwOvyk92Lp9VQpwSGPSY+yOAkmXDktRcW2zVh/smw8AgCStzqtUv7hwJUfR5s0TBDoDdMWo3lqTX6Xc8nq74wAA4LVW7KlQY6tb02kb41XOH5CgqJBANkUFbECh3YOtza+SkRSpqNBAu6NA0pT+8YoNC2JTVADAYc2H2rxlsJzak8wbnqqQwAC9sf6A3VEAAPBaH5uligsP0pg+XOd4k9Agpy4ZmqSlu8pU1dBqdxzAr1Bo91BNrW3aXFircfRB8xjBgQG6ZGiSlu0qV2VDi91xAAAeYGNBtZpdbtrGeJjY8CDNGJykhTnFqmniBhMAgNPV0NKmz3Ir2tvGBLDZu7e5dHiKWtssLdrGpqhAT6LQ7qE2FtTI5bY0lk+OPcrcYSlyuS0tyimxOwoAwAOszquSM8ChMX1o8+ZprhrTW80ut97dzEo0AABO12e7y9XscuuiwbSN8UYDEyM1PDVK/91YKItNUYEeQ6HdQ63d137jPiqNG3dP0j8hQsNTo/TuliIGKwCA1uRVakRqlCKCafPmaQYmRmpsnxi9+dUBudjIHACA07LYLFViZDA1CS92+cjeyqts1Fo2RQV6DIV2D7VuX5WyU6IUHuy0OwqOMXdYivaUN2hzYa3dUQAANqpqaJVZUqfxtI3xWFePTlNhTbM+2VFqdxQAALxGbVOrVu6t0AWDEhXgoG2Mt7pgUIKiQwP1n42FdkcB/AaFdg9U3+JSTlGtzmIZukeaPjhRYUEBeo+l6ADg19bkV8qS6M/uwaYMiFdmXJj+vmYfK9EAAOigj7eVqLXN0kUGbWO8WWiQU7Ozk/XprnKV1TXbHQfwCxTaPdBX+2vUZklnsRGqR4oIDtR0I1EfmSWqb3HZHQcAYJM1eVWKDHFqSEqU3VFwAgEOh26e0Fc7S+v1WW6F3XEAAPAKCzcXKjU6RMNSucbxdpeP7K02t6V3tzBREOgJFNo90Jf5VQpyOjQ8NdruKDiBucNS1Njq1scmS9EBwB9Z/5+9+w5vsmzbAH4+GU26V7r3hAIto7TsPQQRRHGBorgHTl733vrK68K9UECGoCgIMkVANi20lNVB957pHlnfHyifyOy8k/T8HYf/pEl6psTcT67nfq7LZMK+nCrEB7pCIeMl1eZsYk9P+Dqr8e3+XO5qJyIiugRtow67T1VgfKQHJLaNsXiBrraID3TBz0eKYeDMGqJOx0K7GUrM0yLG1wlqJfuzm6sYXycEu9liTUqJ6ChERCRAZnk9SmqbMSiYbWPMnUIm4bY4fxwtqsWBXA4DIyIiupjt6eXQG02Y0JNtY6zFjL4+KKltxnZuFCTqdCy0m5nqxtOD1WID2DbGnEmShKujfZBSVIPMinrRcYiIqIvtyigHAAwK4nptCa7q7Q0PBxt8uz9XdBQiIiKztiW1DEFudujp6SA6CnWQkWHu0NjbYNlBHgcRdTYW2s3M4fxqmAAMZKHd7F3ZyxNymYQ1HIpKRNTt7MqoQKCrLfycbUVHoctgo5DhloH+SMyrRnJBteg4REREZqmyoQUJeVpcGe3NtjFWRCGXYXq0N/7MKEe+tlF0HCKrxkK7mUnI00KlkHHoiAVwl0tZBAAAIABJREFUs7PByDB3/Ha8FDqDUXQcIiLqIi16I/ZnVWJQENvGWJJrYnzgYqvEQu5qJyIiOq/f08phNAFT+viIjkIdbHqMD2SShJ+PFImOQmTVWGg3Mwl5WvTzc4JSzn8aS3B1tDe0jTr8eapCdBQiIuoiKUU1aNQZWGi3MLZKOWbF+mFPVhVOltSKjkNERGR2tqSWIcTdDpFebBtjbbwcVRjbwwNrUorRpDOIjkNktVjNNSOVDS04Vd7AtjEWZHCQKzwdbPAz28cQEXUb+7KroJBJiA1wFh2FWun6fr5wUMnx1V7uaiciIvqnsrpmJOVXY0IPD7aNsVKzBwehukmPzRyKStRpWGg3I4l5p3uGDgxkod1SyGUSpkf7YH92FXudERF1E/tzqtAvwAUOKoXoKNRKDioFZg8MwM5TFezVTkRE9A9b08phAjChh4foKNRJBoe4IdTdDj8cKoDJZBIdh8gqsdBuRhLztLC3kaOnF/uzW5Kro70hk4BfuKudiMjqVTW04GRJHYaHa0RHoTaaGesHNzslPvkzi18yiYiI/rLlZCkiPOwR7GYnOgp1EkmScOMAP6SV1SOpoEZ0HCKrxEK7GTmYq0V/f2coZLxMy5J4OqowIswda1OKORSViMjKHczVwgRgeLi76CjURrZKOe4aEoTDBTXYk1UlOg4REZFwRTVNSCmqxUTuZrd6V0Z5wkmtwIpDBaKjEFklFtrNRGltM3KrGhHL/uwW6dq+Pqhq1OGP9HLRUYiIqBPty66Ck1qBPr7sz27Jpkd7w89ZjU92ZcHIXe1ERNTNbf2rZ/d4Ftqtnlopx/Rob2zPKEdxTZPoOERWh4V2M5GQpwUAxLHQbpEGBbnC11mN1UeKREchIqJOYjKZsD+nCvGBLpDz6jOLppTLcP+wYKSX1WPTyVLRcYiIiITaklqGXt6O8HexFR2FusB1/XwBAKuSWL8g6mgstJuJxDwtnNQKRHjai45CbSCTJFwb44PEvGpkVzSIjkNERJ0gq7IBpXUtGBTkKjoKdYAJPT0Q6WGPz3fnsPUbERF1W3lVjThRUse2Md2Ij5Mao8I1WJNShCadQXQcIqvCQruZSMjVYoC/M2QSd8hZqql9vKCQSdzVTkRkpfZln+7nPSiYhXZrIJMkzB0RgsLqJvzMtZuIiLqpLX+1jRkXyUHv3clNA3xR3aTHxhO8so+oI7HQbgYKqhtRWNOMgWwbY9Hc7GwwNkKDdcdKeFaYiMgK7c+pQpCrLXyc1KKjUAcZEuyK2ABnfLMvF7VNetFxiIiIutyW1DL09XWCN49vupX+fs6I8LDHD4cLYeK8GqIOw0K7GUjMrQYADAxkod3SXdvXB7XNemxNKxMdhYiIOlCL3ojEvGoM5m52qyJJEh4eGYqqBh0+2Z4hOg4REVGXyqpoQEZ5PSb2ZNuY7kaSJNzU3w8Z5fVIzKsWHYfIarDQbgYS8rRws1Mi1N1OdBRqpwH+zgh2s8XqZF6CTkRkTZILq9GsN7I/uxXq5e2IqX28sHhfDnIqOWeFiIi6jy2ppZBJwNhIFtq7o4k9PeCsVuCHwwWioxBZDRbaBTOZTEjI0yI2wAUS+7NbPEmScG1fX6QU1SK1tE50HCIi6iD7srVQyCTEss2bVXpgeAhUCjne354pOgoREVGXMJlM2HyyDAP8naGxtxEdhwRQK+W4tq8Pdp6qQEF1o+g4RFaBhXbBcqsaUVbXwrYxVmRKL0+oFDIOViMisiL7c6oQ4+sEOxu56CjUCdztbfDgmDDszqrE7sxK0XGIiIg6XXpZPXKqGjGhB3ezd2cz+vpCAvBjEusXRB2BhXbBEvK0AMBBqFbESa3EhB4e2HC8FHXNHKxGRGTpKhtakFpax/7sVm72oCAEutrive2noDMYRcchIiLqVFtSyyCXgLERLLR3Z16OKoyJ8MCalGI06gyi4xBZPBbaBUvI1cLTwQYBLpzwbU1m9PVBg86AX48Uio5CRETtdCDn9Elx9me3bjYKGeaNDkNuVSNWHGKvUiIisl6n28aUIi7IFS52StFxSLCbBviitlmP9cdKREchsngstAtkNJmQkFeNuED2Z7c2vb0dEelhj2UH8mAymUTHISKidtiXUwVntQI9PB1ER6FONizUDcNC3PDNvlyU17eIjkNERNQpUopqUVjTjMlRnqKjkBmI8XVClJcDVhwqgJH1C6J2YaFdoFPl9dA26tif3QpJkoQZfX1wsrgWR4tqRcchIqI2MplM2J9dhfggV8hlPCneHTw2OhTNeiM+3snBqEREZJ02niiFSiHDqHB30VHIDEiShFmx/sipasTerCrRcYgsGgvtAiXkVQNgf3ZrNSnKCw4qBX44zMvPiYgs1anyBpTXt2BQENfq7iLIzQ63DPTH+uOlOJxfLToOERFRh9IbjNiaWoaRYe6wt1GIjkNmYlykBh4ONliWmC86CpFFY6FdoIRcLfxd1PB2Yn92a2RnI8f1sX7YmlaOsrpm0XGIiKgN9mRVAgCGBLsJTkJd6Y7BgfB2VOGd3zOgN/ISaiIish4HcrWoatThip5sG0P/TymX4fp+vjiQq0VGWb3oOEQWi4V2QfRGExLztNzNbuVuHhQEo9GEn5KLREchIqI22JtdiXCNPTwdVaKjUBeyVcoxb0wYMsrrsZJXphERkRXZeKIUTmoFhoZwyDud7doYH6gUMiw/xF3tRG3FQrsgqaV1qG8xII792a1akJsdhoe6YXVyEVr0RtFxiIioFepb9EgqqOEX0W5qdLg7hgS74ss9OSjnlWlERGQFmnQGbM8ox9gIDZRyloPobM62SlzV2wsbT5SisoFD4Ynagp+sgiTmagEAsdzRbvVuHOCHqkYdtqSWiY5CREStcDBHC73RhKEhbBvTHUmShMfHhqPFYMQHOzgYlYiILN/OUxVo1BkxKYptY+j8bhrghxaDCT8l8ap8orZgoV2Qg3lahLrbwd3eRnQU6mTxgS4IcbfDD4cLYDKxzysRkaXYk10Jexs5+vo6iY5CggS62uLWuABsOlmGxDyt6DhERETtsulkGTwdbNDf31l0FDJTwW52GBbihh+TC9HMq/KJWo2FdgF0BiOS8qvZn72bkCQJN/X3xYmSOhwprBEdh4iILoPJZMKerCrEBbpAwUuru7U58QHwdVLhv79nQG/gF04iIrJM1Y067MmqxMSenpBJkug4ZMZmxvqhskGHTSdLRUchsjj85ijAsaJaNOmNGMj+7N3G5F5ecFQpsOJQoegoRER0GTIrGlBS28y2MQS1Uo55Y8KRVdGAFYe5jhMRkWX6Pb0ceqMJk3qybQxdXHygC8I19lieyKvyiVqLhXYBEvK0kAAM4OVa3YatUo6ro73xR3oZSmo5UI2IyNztza4CAAwJ5iBUAkaFu2N4qBu+2pODUq7jRERkgTadKEWwmy0iPe1FRyEzJ0kSZg7wQ0Z5PQ7msnUeUWuw0C5AQp4WPTwd4GyrFB2FutD1/XxhAvBTMnfDERGZuz1ZlQh1t4O3k1p0FDIT/xkTBr2Rg1GJiMjyFNc04XB+NSZFeUJi2xi6DFdEecLNTonlhwpERyGyKCy0d7EmnQFHCmsQy/7s3Y6vsxojw9yxOrkITTqD6DhERHQBDS0GJBVUs20MncXfxRZz4gOxJbUMB3KqRMchIiK6bFtSy2ACcAXbxtBlUilkmNHXB7syK5Fd2SA6DpHFYKG9ix0prIHOYEIc+7N3SzcN8EN1kx6bT5aJjkJERBdwMFcLncGEoSFsG0NnuzU+AH7OaszflgEdB6MSEZGF2HiiFH18HOHvYis6ClmQGX19oZRLWMFd7USXjYX2LpaQp4VcAvr5O4mOQgIM8HdGuMYeKw5zqAgRkbnam10JO6Uc/fw4S4XOplLI8PjYMGRXNmJZIr90EhGR+cusqEdaWT13s1OrudvbYFJPT6w/VoLqRp3oOEQWgYX2LpaQW41e3k6wt1GIjkICSJKEG/v7Ir2sHocLqkXHISKifzGZTNibVYm4QBco5TxMonMND3XHqDB3fL03B8U1TaLjEBERXdSmk2WQScD4Hh6io5AFmhXrjya9ET8fKRIdhcgi8BtkF6pv0eN4cQ3iArlDrjubFOUJZ7UCKw5xKCoRkbnJqWxEYU0z28bQRc0bEwYTwMGoRERk1kwmEzadKEV8oCs09jai45AFCvewR1ygC1YlFULPtnlEl8RCexdKyq+BwQQOQu3m1Eo5ronxwY6McuRrG0XHISKif9iTXQkAHIRKF+XrrMYdgwLxe1o59v31niEiIjI3KUW1KKhuwsSe3M1ObTcr1g+ldS34Pa1cdBQis8dCexc6mKuFUi4hxpf92bu7G/r7QiZJWM7+rkREZmVXZiVC3O3g7aQWHYXM3C0D/RHoaov5206hRc8dXkREZH5+O14ClUKGMREa0VHIgg0NcUOQqy2WHeKsOaJLYaG9CyXmaRHj6wS1Ui46Cgnm4aDCpChPrD1aDC2HihARmYW6Zj0O5VdjRKi76ChkAWz+GoyaW9WIpYn5ouMQERGdpUVvxOaTZRgToYGDijPiqO1kkoSbBvjheHEtjhTWiI5DZNZYaO8i1Y06pJbWYSDbxtBfbh54eqjI6mQOFSEiMgf7sqtgMJowIpRtY+jyDAl2w9gIDb7Zl4vCag5GJSIi8/FnZgVqm/WY0stTdBSyAlN6e8FJrcAyXpVPdFEstHeRxPxqmAAW2umMcI09hgS74ofDBWjmJedERMLtyqyAs1qBaLZ4o1Z4bHQoJADvbz8lOgoREdEZ64+VwMPBBnGBHPBO7Wf716y57RnlKKjmrDmiC2GhvYvsz66CvY0cfXwcRUchM3LLQH9UNuiw8USJ6ChERN2awWjC7qwqDA1xg1wmiY5DFsTbSY07Bwdie0YFdmdyMCoREYlX2dCCPdlVmBzlyeMa6jA39POFJElYebhQdBQis8VCexfZn1OF2AAXKOT8k9P/iwt0QaSHPZYmFMDIoSJERMIcK66FtlGH4WwbQ21w80B/BLna4n9/ZPAqNSIiEm7TyTIYjCZc2ctLdBSyIp6OKoyP1GBNSjHqmvWi4xCZJVZ9u0C+thEF1U0YFMS2MXQ2SZJwS5w/siobsCeLu+CIiET581QF5NLpnttEraWUy/DEuHDka5uw+GCe6DhERNTNrT9WgigvB4Rp7EVHISszK9Yf9S0GrD1aLDoKkVliob0L7M+pAgAMCmJvNDrXhEgPeDrY4PuEfNFRiIi6rV2Zlejn7wxHtUJ0FLJQg4JcMT7SA4sO5CFfy96lREQkRkZZPVJL6zCFu9mpE/TydkQ/Pyf8cLgQBiOvyif6Nxbau8D+HC28HVUIdLUVHYXMkEIuw8xYfyTmVeNYca3oOERE3U5RTRMyyusxItRddBSycI+NDoVMAt77g4NRiYhIjPXHSyCXSZjY00N0FLJSM2P9UVjdhB2nKkRHITI7LLR3Mr3RhIO5VRgU7ApJ4hASOr/p0d5wVCmw6AAvNyci6mq7/hpgyf7s1F6ejircPSQIf2ZWYie/fBIRURfTG03YcKIUw0Pc4GpnIzoOWalRYe7wdVZjeSKvyif6NxbaO9mJ4lrUNRvYNoYuykGlwPX9ffFHejmyKhpExyEi6lb+PFWBQFdbBLnZiY5CVmDmAD+EuNvh3W0ZaNIZRMchIqJu5EBOFSrqW3Blb7aNoc4jl0m4sb8vkgpqcJxX5ROdhYX2TrYvpwoSgLhADkKli7upvy9UChkWcYgaEVGXaWgxICFPy93s1GEUchmeGheOwppmXqlGRERdat2xEjirFRgewuMa6lzT+njD3kaOZdzVTnQWFto72YGcKvT0coCLrVJ0FDJzrnY2mB7tjY0nSlFc0yQ6DhFRt3Awtwo6g4mFdupQsQEuuKKnBxYf5GBUIiLqGtpGHbZnlGNSlCdsFCz1UOdyUClwdbQ3tqaVo7S2WXQcIrPBT99OVNesR0phDdvG0GW7ZaA/AOD7BJ4VJiLqCn9mVsLeRo7+fs6io5CVeXhkKOQyCR/uyBQdhYiIuoGNJ0qhM5hwdbS36CjUTdzY3w8mkwkrkwpFRyEyGwrRAaxZYl41DCZgcLD1FNrr6+vw6acLsGvXTrS0tGDIkGF46KHH4Or6/zsB7777Vpw4cfysx1111dV4+ukXAABLlnyHFSuWQKVS44EHHsb48Vecud8PPyxFVlbmmfteyBtvvIzS0lJ8+OGn5/zs7bdfQ35+Hj7++EsAwHXXTUVxcdGZn8tkMtjZ2aF37xjcd9+DiIiIPO/9lEolNBpPjBo1BnfccTfs7Owv98/UZt5OalwZ5YlfUopxx+BAuHGADRFRpzGaTNiVWYkhwa5QyK137wHXbjE8HVW4fVAgPt2VjQM5VYjnxgsiIuokJpMJa1KK0cvbEREeDqLjtBqPVSyTr7Mao8M1+PlIEe4cHAhbpVx0JCLhWGjvRPtzqqBWyBDt4yQ6Sod54YWnkZOTjWeffQkeHp746qtP8dBD92Hhwu9hY2MDk8mErKxMvPji6xg7dgSqq09fLq1WqwEAmZmnsHjxQrz//sfQarV4+eVnER8/BE5OTqivr8OKFUvx+ecLOzz3zTffhhtumAng9EFIRUUFPvjgHTz22FysXPnLmcXtn/dramrCyZPH8fHHH+DYsSNYsOALKJWd3wLo1vgArDtWghWHCvDA8JBO/31ERN3V0aJaVNS3YGS4u+gonao1a3ds7MAzj/t77c7ISOfa3UazYv3xS0ox3v3jFJbeGguFTBKWhYiIrNfxkjpklNfjmfHhoqO0SXuPVVhnEGfmAD9sSy/H+mMluK6fr+g4RMJZ7/YtM7A/pwqxAS5W0x8tPT0VBw7sw9NPv4BBg4YgNDQML7zwGsrLy/D775sBAIWFBWhqakKfPtHQaDzg7q6Bu7sG9vanz6pnZWUiNDQMffrEYPjwkbCzs0dBwelBYcuWLcHYsePh5dXxl7rZ2tqeyaLReKBHj56YO/dRaLVVSEw8eN77+fn5Y9y4iXj77fdw9GgK1q9f0+G5zifYzQ5jIjRYlVSIumZ9l/xOIqLuaEdGOeQyCcNDrLfQ3tq1++818J9rd0ZGBtfuNlIpZHh0VCgyKxqwOpmXVRMRUedYk1IEtUKGiT09RUdptY44VmGdQZy+fk6I8nLA8kMFMJpMouMQCWcdFWAzVKBtRG5VI+KDXERH6TB5eacXqpiYfmdus7OzQ0BAAA4fTgQAZGZmQKVSwdvb57zP4evri/z8XFRWViArKxN1dbXw9PRCZWUF1q37BbNn39H5L+Qvcvnpy5qUyou3Z+nRoydiYvph69bNXRELADBnUADqmg34kb3OiIg6hclkwvaMCsQFuMBRbb0X+HXE2u3n58+1ux1Gh7sjLtAFX+zJgbZRJzoOERFZmUadAZtPlmFcDw84qCzvmIZ1BvHHKu0hSRJmxfojt6oRe7IqRcchEo6F9k6yO6McAKxqEKpGowEAlJWVnrnNYDCgtLQUWm0VgNOXbDk4OOKVV57HmDGjcOutN2LFiu9hNBoBAFFRvTFmzHhMnz4Zt98+C3feeS/c3TX49tuvMW3atXBx6ZoTEwUF+fj884/h7q5BdHTMJe8fGhqOzMxTXZDstCgvRwwJdsXSxAI0tBi67PcSEXUXmRUNyK1qxOgI693NDrR+7b766knnrN3R0dFcu9tBkiTMGxOG+mY9Pt+dLToOERFZma2pZahvMWB6H8scgtoRxyqsM4g1PlIDTwcbLEssEB2FSDjLO91pIf7MKIeHgw1C3e1ER+kwUVG9ERQUjPnz38ILL7wKR0cHfPPNF9Bqq6DTnd6hlZWVicbGRgwaNARz5z6APXv24ZNPFqC+vh533nkvAODxx5/Bvfc+CIVCAVtbWxQU5GPnzj+wfPlPWLduDZYs+RZOTk546qkXEB4eccE8SUmJmDBhxDm3t7S0IDq671m3LVr0DZYuXQQA0Ov10Ov1iIjogTfemH/mcrOLcXR0RH193WX/rTrCXUOCcOfyJPyUXIjZcQFd+ruJiKzdjowKAMDIMOsutLd27b711juQkpLEtbuDhWvsMaOvL35MLsSMvj4WOaiOiIjM09qjxQhytUVfP8ucDcdjFfM4VmkPhVyG6/v54pNd2Ugvq+NxDnVrLLR3Ar3BiF0ZFRgXoYEkWc/QK6VSiTff/B9effUFTJ8+CUqlEhMmTMKQIcOgUJwe3vH886+gsbERjo6OcHGxg6enP+rq6rB48be44457zvw9HB0dzzzvl19+ipkzb0FDQwM+/vh9fPfdChw7loLXXnsRixYtv2CeXr1647nnXjnn9i+++ARVVWdfsnTttdfjmmuuB3D6Ui5nZ+dWTfduaKg/K3NXiPF1wqAgFyw5mI/r+vlygjcRUQfanlGOaB9HeDioREfpVK1duwEgLCz8rLX7b1y72+eeoUHYdLIU7/5xCp9dH2NVx4hERCRGdkUDkgpq8PDIEItdVzriWIV1BvGuifHBN/tysTyxAC9O6iE6DpEwLLR3guTCGtQ16zEs1E10lA4XFBSMb75ZgupqLZRKJezs7HHHHTcjLm4wAEChUJyzUISFhaOhoR51dXXn/Cwt7SSOHj2CZ599Cfv27UFAQBC8vb3h6uqCl156BvX1dRc8E2xjo4a//7k7ve3t7c9ZAB0dnc5738uVmnoSERFdv1jcPSQId61Ixk/JRbhloH+X/34iImtUXNOEEyV1eGhEiOgoXaK9a7er69lfGLl2t42zrRL3DQvGf3/PwLb0coyL9BAdiYiILNzao8WQyyRc2ctLdJR2YZ3B8jnbKjGltxfWHi3G3BEhcLe/eI96ImvFHu2dYFdmJZRyyaoGoQJAfX0dHnzwHmRmZsDZ2QV2dvYoKipERkY64uNPL4D33DMHH3zwv7Med/LkCWg0Huc9U/v55x9jzpy7oFKpIEkSTH9Nqdbr9QAAo1H81Or09DQcPXoEEydO7vLf3dfPGfGBLlhyMA9NOvZqJyLqCNv/ahszKty628YAXLtFrN0XMz3GB+Eae3y4I5PrOhERtYvOYMT64yUYEepm0UVNHquY17FKe9w0wA86gwk/JReKjkIkDAvtnWB3ZiXigt1gb2NdFwzY2zvAYDDgww/fQ1ZWJo4fP4onn3wUsbFxiI2NAwCMGjUGa9euxoYN65Cbm4t1637B0qWLzvRN+6fExIMoKirE5MlXAQAiI3siK+sUDh1KwM8//4jg4JAuv4yqsbERFRXlqKgoR0FBPrZu3YSnn56Hvn37C1sA7x4ShMoGHVYfKRLy+4mIrM2OjHKEuNshyM165qhcSGvX7oKCfK7dnUghk/D42DAU1TTj+4R80XGIiMiC/ZFejsoGHabH+IiO0i48VjGvY5X2CHazw/BQN/yYVIRmvVF0HCIhrKsSbAYKqhuRVdmAmYMCRUfpFK+88ibef/8d3Hff7VCp1Bg1aizuv/+hMz+fNetWyOVyLFq0EPPnvwlPT2889NA8TJ06/Zzn+vzzj3DXXfdBoTj9NvT29sYDDzyMF198Gs7OLnj++XP7onW2pUsXnRlmYmdnD29vb0ybdg1uvPFmyOVieqT383fGwEAXLD6Yj2tjfKBmr3YiojbTNupwOL8at8V3nyHTrVm7S0uLuXZ3stgAF4yL1OC7A3m4qrcXvJ3UoiMREZEF+jG5CH7OagwJdhUdpd14rGI9Zg7ww9wfU7DpRCmmRXuLjkPU5aS/L6HpCGVltSYAcHGxg1bb0GHPa0lWHi7A/G2nsPmREXBVWOYwko7Snd8Hf+uov8GhfC3u/eEI5o0Jw8wBfh2QrOvwfcC/QXd//UDn/w08PBzbteD8vX53BHP/9/71aDFe3ZSGRTf3Ry/vtu9mMvfX2ZG6y2vtytdZWN2EG75LwKgwd7xxVVSX/M6/8d/TunSX1wlY52s1p/W7Pazx3+Z8zOl1ZpTXY+aiRDw8MgSz4zp+84A5vdbOxtfasUwmE25ecggmE7Ds1gHChvTy39U6mdNrvdAaztYxHWxXZiUCXNQI0Vz+pGmiSxng74LYAGcsPsBe7URE7bEjowJejipEeZ1/ABZRV/B1VuOWgf7YnFqGw/nVouMQEZGF+SmpEDZyCVN7c8cwmRdJknDTAD9klNfjQK5WdByiLsdCewdq0hmQmKfFsFDrH65GXe/eocEor2/BqiQOFiEiaotGnQH7cqowOtxd2O4aor/dFh8ATwcbzN+WAb0ZDGUjIiLLUN+ix2/HSzGhhwdc7JSi4xCd44qennCzU2J5YoHoKERdjoX2DnQwV4sWgwnDQ9xERyEr1N/fGUNDXLHoQB7qmvWi4xARWZy9WZVo1hsxKpwnxEk8W6Uc88aEIb2snifRiYjosm08UYoGnQHX9fMVHYXovFQKGa7r64vdWZXIrjCPNh9EXYWF9g60O6sStkoZ+vs7i45CVuqBYSGobtJjSUK+6ChERBZnS2o5XG2V6O/vIjoKEQBgbIQGQ4Jd8cXubJTVNYuOQ0REZs5kMuHHpCL09HRA73bMmiHqbDP6+cBGLmHFYe5qp+6FhfYOYjKZsCuzEoOCXGGj4J+VOkcPLweMj/TA8sR8VDa0iI5DRGQxGnUG7MqswNhIDRQyto0h8yBJEp4YGw6dwYj3t2eKjkNERGYuuaAGGeX1uK6fD9vgkVlzs7PBpChPrDtWgupGneg4RF2GFeEOcqq8ASW1zRjKtjHUye4bFoQWvRHf7s8THYWIyGL8eaoCTXojJvTwEB2F6CwBrraYMygQW1LLsD+7SnQcIiIyYz8mF8JBJccVPT1FRyG6pJkD/NGsN+LnI0WioxB1GRbaO8iuzAoAwDAW2qmTBbnZ4ao+3vgpuRBFNU2i4xARWYQtqWXQ2Nugnx/bu5H5uTUuAAEuaryzLQPNeqPoOEREZIYq6lvwe1o5pvb2hlopFx2H6JLCPewRH+iCVUm2Oh3rAAAgAElEQVSF0Bt4fEPdAwvtHWR3ViUiPezh6agSHYW6gbsGB0IC8NWeHNFRiIjMXl2zHnuyKjEuUgM528aQGVIpZHhyXDhyqxqx5CCvWCMionP9fKQIeqMJ1/b1ER2F6LLNivVHaV0LtqaVi45C1CVYaO8A2kYdjhTWYHgod7NT1/B2UuO6fr5Yf7wEWZziTUR0UTtPVaDFYGLbGDJrg4PdMD7SA9/uz0VOJdd2IiL6f816I1YlFWJYiBuC3exExyG6bENCXBHkaotlifkwmUyi4xB1OhbaO8CuzAoYTcDIcI3oKNSNzIkPgK1SjgU7OTyNiOhitqaWwdPBBtG+TqKjEF3Uf8aEQqWQ4/XNaTDyyygREf1l44kSVDbocPNAP9FRiFpFJkmYGeuHEyV1SC6oER2HqNOx0N4BtqdXwNPBBr28HERHoW7E1c4Gdw4OxK7MSuzLrhQdh4jILNU26bE3uwrje3hAJrFtDJk3jYMK88aEIqmgBqsOF4qOQ0REZsBkMmFpYgEiPewxMMBFdByiVpvSywvOagWWHSoQHYWo07HQ3k6NOgP25VRhdLgGEr/AUxe7sb8f/F3UeG97JvRG7nwjIvq37Rnl0BtNmMi2MWQhpvTywtAQV3z8ZxbytY2i4xARkWB7squQVdGAmwf6s+ZAFkmtlOOaGB/syChHQTWPbci6sdDeTnuzq9CsN2J0hLvoKNQN2ShkeGRkKLIqGrA6uUh0HCIis7MltQy+zmr08nYUHYXoskiShGcnREIuk/DG5jT2MyUi6uaWJeTDw8GGs2bIol3fzxeSJOGHQ7xij6wbC+3ttD29HM5qBfr78xIuEmNUuDsGBrrgyz3ZqG7UiY5DRGQ2tI06HMjVYnykB3eAkUXxclThkVGhSMirxs9HeCKdiKi7Siutw4FcLW7s7welnOUbslyejipM6OGBtUeLUdesFx2HqNPwk7od9AYjdmVWYniYOxQyfoEnMSRJwrzRoaht1uPrfbmi4xARmY0/0sthYNsYslDTo70RH+iCBTuzUFzTJDoOEREJsCwxH7ZKGa6J8RYdhajdZsX6ob7FgLVHi0VHIeo0LLS3Q2JeNWqb9RgTzrYxJFaEhwOmR/tgVVIhsisaRMchIjILm0+WItDVFpGe9qKjELWaJEl4bmIkTCbgpQ2pMHAWCxFRt1JW14xNJ8swrY83nNRK0XGI2i3KyxH9/ZywLLEAOoNRdByiTsFCeztsSSuDnVKOwcFuoqMQ4d5hQVArZHh3+yn2cyWibq+wugkJedWYHOXJtjFksXyd1XhyXDgO5Vfj2/28ao2IqDv54XAhjCYTbhrgJzoKUYe5fXAgSmqbse5YiegoRJ2ChfY20huM2J5ejpHh7lAp+Gck8dzsbHDvsGDsy67CltQy0XGIiIRaf7wEEoCrenuJjkLULlN6e2FylCe+2puD5IJq0XGIiKgL1DXr8VNyIcZEaODvYis6DlGHGRzkit7ejvhufy703NVOVogV4jZKyNOiukmP8ZHs+0rm44Z+vojycsC7f5xCTRMHoxJR92Q0mbDuWAkGBrrA20ktOg5Ruz05Lhy+zmo8v/4k13ciom5gVVIh6poNuD0+UHQUog4lSRLuGhKIwppmbDhRKjoOUYdjob2NtqaWw95GjsHBrqKjEJ0hl53u51rdqMOCnVmi4xARCZFUUI3C6ibuZier4aBS4PUpUSirb8Ebm9PZIo6IyIo1tBiwNCEfw0Pd0MPLQXQcog43LMQNPT0d8O3+XOg5g4asDAvtbaA3GPFHRjlGhrFtDJmfHp4OmBXrjzUpxTiUrxUdh4ioy607WgJ7GznGRmhERyHqML29HTF3eDC2pZfj5yNFouMQEVEnWX2kCNVNetw+iLvZyTpJkoQ7BwciT9uEzSe5q52sC6vEbXAgV4uaJj3G92DbGDJPdw8Ngq+TCm9uTkeLnn3PiKj7aGgxYGtaGcb38IBaKRcdh6hD3TzQH4ODXPHuH6dwoqRWdBwiIupgTToDvk/IR1ygC2J8nUTHIeo0I8PdEeFhj4X7cmHgrnayIiy0t8Gmk6VwVCkwOIhtY8g82SrleGp8BHKqGrHoQJ7oOEREXWZbehkadUZMZdsYskIyScKrV/aAq50Nnlp7HNpG9msnIrImq5IKUVHfgruHBImOQtSpZH/tas+pasTvaWWi4xB1GBbaW6lRZ8D29AqMi9TAhm1jyIwNDXHDFT098O2BXJwqrxcdh4ioS6w7VoIAFzV3gZHVcrWzwX+n9UJ5fQueX3+CvU2JiKxEXbMeiw7kYUiwK/r7O4uOQ9TpxkRoEOJuh6/35cLI+TNkJVgpbqWdGRVo0BkwuZen6ChElzRvTBjsbRR4eUMq9Aa2kCEi61ZQ3YjEvGpc1dsbkiSJjkPUaXp7O+LpcRHYn6PF/7ZlcDgqEZEVWJaYj+omPe4fHiw6ClGXkEkS7hociKyKBmw+yV3tZB1YaG+lDSdK4e2oQj8/nmEm8+dmZ4NnJkTgZGkdFu7PFR2HiKhTrT9WAgnAlTwZTt3AtGhv3BoXgJ+Si/B9Qr7oOERE1A7aRh2WJRZgTIQGUV6OouMQdZnxPTwQ4WGPz3dnQ8fNgWQFWGhvhcqGFuzLrsSkKE/IuFOOLMTYCA2u7OWJhftycayoRnQcIqJOYTSZsP5YCeKDXODtpBYdh6hLzB0RjPGRHliwM4v9TYmILNjiA3loaDHgvmHszU7di0ySMHd4CAqqm7AmpVh0HKJ2Y6G9FbamlsFgAiZFcaccWZbHx4TDw0GF59afRF2zXnQcIqIOdyCnCoU1zZja21t0FKIuI5MkvDy5B2J8nfDShlQcKeQJdSIiS1NW14yVSYWY3MsToe72ouMQdbmhIa7o7+eEr/flolFnEB2HqF1YaG+FdcdK0MPTAWEaLn5kWRzVCrw+pSeKa5rw1pZ09nIlIqvzU3IRXG2VGBOhER2FqEupFDK8e3VveDrY4D+/HENuVaPoSERE1AoL9+VCbzTh7iHczU7dkyRJmDsiBBX1LVjKdnhk4Vhov0xppXU4UVKHaX28REchapO+fs64Z2gwNqeW8ZIsIrIqxTVN2HmqAtOivWGj4KENdT8udkp8cG00AOCBVUdQUM1iOxGRJSiobsQvKcWYHu0Nfxdb0XGIhOnr54wxERosPpiH8rpm0XGI2ozfRi/T2qPFsJFLuKIn28aQ5botPgDxgS6Yvy0Dx4trRcchIuoQv6QUw2QCro3xER2FSJhAV1t8fF00GnUGPLDyCIpqmkRHIiKiS/jkz2zIZRLuGBQoOgqRcA+NCIHOYMLnu3NERyFqMxbaL0Oz3ogNJ0oxOlwDZ1ul6DhEbSaXSXhjShTc7Gzw5NrjqGpoER2JiKhd9AYjfkkpxrBQN/g6cwgqdW89PB3w8XXRqGnW4/6VR1BSyx1hRETmKim/GltSy3BrnD88HVWi4xAJF+Bqixv7+2Ht0WKkltaJjkPUJiy0X4YdGeWoadJjWh8OWCPL52KnxDtX90JVQwueWXcCOoNRdCQiojbbll6OivoWzOjL3exEABDl5YiPZ0RD26jD/SuTUcbLr4mIzI7RZMJ720/B08EGs+MCRMchMht3Dg6Ek1qBd7dlcLYcWSQW2i/D2qPF8HZUIS7IRXQUog4R5eWI5yZGIjGvGv/dygWMiCyTyWTC0sQCBLraYmiIm+g4RGajt48TFsyIRkW9DvetPILCaraRISIyJ+uPleBESR0eHBkCW6VcdBwis+GoVuDBESE4XFCD346Xio5D1GostF9CTmUD9udocXW0N2SSJDoOUYe5spcX7hgUgDVHi/E9J3sTkQU6UliD48W1mDnAj2s00b/E+Drho+uiUdWgw10rkpBRXi86EhERAahp0uGjnVmI9nHkDDii85gW7Y1oH0cs2JmJ2ia96DhErcJC+yX8mFwEhUzCdA5YIyt077BgjI/UYMHOLGw6wbPFRGRZliYWwFmtwJTeXqKjEJmlGF8nfHljX5hMwL0/JCO5oFp0JCKibu/TXdmobtLhqfER3ChAdB4yScKT48KhbdThk11ZouMQtQoL7RfR0GLAr0eLMS5SA429jeg4RB1OJkl4eXJPDPB3xssbU7Evu1J0JCKiy5KvbcT29HJc29eHl1wTXUS4hz2+mdkPzmoF5v6Ygh1pZaIjERF1W8eKarA6uQg39vdDD08H0XGIzFZPL0dc388XPyUX4XA+NwqQ5WCh/SI2nihBfYsB1/fzFR2FqNOoFDK8O703Qtzt8OTa40jiIkZEFmBpQj7kMolrNNFl8HVW4+uZ/RDsZof7lh7C6iNFoiMREXU7eoMRb23NgMbBBvcMDRIdh8jszR0RAl9nNV7blIomnUF0HKLLwkL7BZhMJqxMKkQPTwfE+DqJjkPUqRxUCiyYEQ1PBxUeWX2Ul5YTkVkrq2vG2qPFuKq3FzwcVKLjEFkENzsbfH5DDIaGueOtLemY/3sG9EYOQyci6ipLEvKRWlqHJ8aGw0GlEB2HyOzZKuV4YWIk8rRN+Gx3tug4RJeFhfYLOJCjxanyBtzQzxcS+6ZRN6Cxt8FnN8RA42CDR1Yf5eVZRGS2vk/Ih8Fowm3xAaKjEFkUB5UCX94Si1mxfliZVIiHf0pBdaNOdCwiIquXVdGAr/bmYHykBmMiNKLjEFmMgYEumNHXB8sTC5CQqxUdh+iSWGi/gCUJeXC3t8GkKE4Bp+7Dw0GFz66PgcbeBg/+eATb0stFRyIiOktVQwt+Si7CpChP+LvYio5DZHHkMgmPjQ7Di1dEIqmgGnOWHcap8nrRsYiIrJbeaMJrm1Jhp5Tj8bHhouMQWZxHRoUi0NUWL204yQ0CZPZYaD+PtNI67M/R4sb+vrBR8E9E3Yunowpfz+yHHp4OeHrtcfyYVCg6EhHRGUsTC9CiN2JOfKDoKEQWbWofb3x2fQwaWgyYs/Qw1qYUw2RiKxkioo626EAuUopq8fjYcLjb24iOQ2RxbJVyvD6lJyobdHhzSzqPV8issYp8Ht8n5MNWKcOMvj6ioxAJ4WKrxKfXx2BYqBv++3sGPtudzcWMiIQrr2vGikMFmNjTA8HudqLjEFm8vn7O+H72APTxccRrm9Pw4oZU1LfoRcciIrIax4pr8dWeHFzR04NXyxO1Q08vRzwwPBjb0sux8jA3A5L5YqH9X4prmrA5tQzTo33gpFaKjkMkjFopx/yre+PqPt5YuC8Xr2zkpG8iEuvrfbnQG024d2iw6ChEVsPDQYWPr4vBvUODsPlkKW79/jBSS+pExyIisngNLQa8+NtJaBxUeHIcW8YQtdfNA/0xMswd7+/IRHIBZ8qReWKh/V++3Z8HCcCsWD/RUYiEU8gkPDcxAvcMDcJvx0sxZ9lhZFc2iI5FRN1QblUjfjlShGuivRHgyt7sRB1JLpNw15AgfHZDDJp0BsxZdhjf7j99YouIiFrPZDLhzS1pyNc24pXJPbiJj6gDyCQJL0/qAV8nFZ7+9QTK65pFRyI6Bwvt/1BY3YQ1R4sxPdob3k5q0XGIzIIkSbh7SBA+nNEHFfU63Pb9YWw+WSo6FhF1M5/tyoZSLsOdQ4JERyGyWgP8XbB0dixGh2vw6a5s3Lk8CVkVPMFORNRaq48UYdPJMtwzNAixAS6i4xBZDUe1Au9M6436Fj3m/XIMjbzqnswMC+3/sHB/LmQSMGcQB6wR/duQYDd8P3sAIjzs8dz6k3h7azoXNSLqEofytdiaVoZbBvpDwyFiRJ3KxU6Jt6ZG4c2rolCgbcQtSxKx5GAeDNzdTkR0WY4X1+LdP05hSLArbmdtgajDhXvY482ropBaWofn1p3gMQqZFRba/5KvbcS6o8W4NsYHXo4q0XGIzJKXowqf3xCDWwb646fkIty0KBH7c6pExyIiK6Y3mjD/91PwcVLhtvgA0XGIuo0JPTzww5yBGBrihgU7szBn6WEcK6oRHYuIyKyV1zXjiTXH4G5ng1cn94RMkkRHIrJKw0Pd8Z8x4fgzsxLzt2XAZGKxncyDQnQAc2AwGPDE6/+FImknNv6mg3bbEMyb9xTc3Nwv+riCgnzMmTMTS5f+CE9Pr/Pe548/tuKFF57GqlVr4ePj2xnxiS6bwWDAV199hg0bfkVDQwMGDbr4e/333zdjyZLvkJ+fC3d3Da66ajpmzZqNR0aFYkSYG15ZtRuPzlsAlTYXzo72mDZ1Om677U4oFPxoIaK2+ffnlG9kP2T4TsI7NwyCWim/4OPOtyb/9tuvePPNV857/yuvnIpnn32pU14DkSitXefXrVuD5cuXoKioEL6+fpg5czamTJl25uc7Nq3B3vf+CxWALAD3fgFIkgzrNu+Gsy37DRMR/a20tAQffPgudu3bB6PRiPj4IdA3hAJ2Hue9/8aN67F06SIUFRUiJCQM99xzP+LiBp/5+ZEjSfjss4+Qnp4KBwdHTJw4GXfffT+USn72kuU5ejQFc+fehfff/wQDBgw8730uVHuQy+X45psv8O23X533cbHjbsBPyYNhp5TjoZEhkHhyiwTjjnYA/13wEXKTdmLczY/gk0++QmlpKZ577smLPiY3NwePPTYXjY2NF7xPeXk55s9/q6PjErXZwoVfYsOGdXj++Vfw8ccXf6/v3bsbr776AqZOvRqLFq3Affc9iKVLF2HJkm8BAOFOMhi3fQhfezmaht+P+v6zsHbDBrwz/82ufElEZGX++Tn16jufIDO/EG7J32N0+IVPfl9oTR43bgLWrNl41n/33PMA1Go1brhhVme/FKIu15p1fvv23/Huu2/j5ptvw/ffr8KNN96Md955A7t27Thzn8zMDAwfPhJr1mzEslXrMeWpL6Cb/BKu+zYBa1OKeak2ERFODz594olHcSSnBE3D7scDz7+HlvpqPPnkY+e9/5YtG/HGGy9j4sTJWLhwKSZNmoKnnvoPDh1KAAAUFxfhP/95GL169caiRSvw3HMvY9Om3/D55x915csi6hCNjY14/fUXYTBcuO3spWoPM2fOPueYfvr0GXB1dcOrc2/DdX19sCQhH1/tzeHOdhKu2xfaW1pasHHtj1D3n4anbr4KPXr0xCuvvImUlGSkpCSf9zErVy7HXXfdCgcHx4s+91tvvYqwsPDOiE3UajqdDqtWrcC9985FXNzgS77X16z5CaNGjcWMGTfCz88fY8aMx0033Yz1638FAGzcuA7Nzc349uMFWDx3KgIi+qAo8hr8tn4tNiac6OqXR0RW4J+fUwMHDsLyTAmmQbeivjAdR48eOe9jLrYmq1RquLtrzvzX1NSExYsX4sEHH0V4eERnvxyiLtXadV6r1eKOO+7FlVdOha+vH6ZOnY7Q0DAkJBw8c5/MzFOIiOgBd3cNAn288MzUWCy+axQCXW3x2uY0zP7+EFvIEVG3V1lZgWY7DUoir8EDU4Zh1rh43HjjLKSlnURNzbktt5YuXYwJEyZh9uzbERgYhBkzbsAVV0w+s2O3qKgQo0aNwUMPzYOfnz/i4gZh3LgJZ30+E1mKjz56Dx4enhe9z6VqD3Z2dmcd0xcVFWLt2p/x3HMvw9PTC0+MC8dVvb3w1d5cfLorm8V2EqrbF9qX/X4ARl0Tbr1yNOxsTl+S7uPjCx8fXyQnHz7vY3bt2oEnn3wWDz746AWfd8WK5aioKMecOXd1Sm6i1kpPT0VDQz369489c9vF3uu33XYnbr/97rNukyQJtbWnDxbz8vIQEhIKJydnRHo64JuZ/fDSjWMAAC8t+Q2PrE5BRnl9J74iIrI2//yc+iWlGHuzq/Dw5Lh2r8l/++yzBQgNDce0add2dHQi4Vq7zk+fPgOzZ88BAOj1emzbthU5OdmIixt05j5ZWZkICgo+63GRng74+qa+eGNKT9Q36/Hgjyl4dPVRnOKaT0Td1IasJpwKvx43DOuD2+IDUFpagjVrViMqqhecnJzOuX9+fi5iYvqddVtERA8cPXoEer0e/fvH4vnn/7/1XWrqSfz55w7Exw/+91MRmbW9e3dh797dePTRJy56v0vVHv7JZDLhww//h1GjxmLw4KEAAJkk4YUrInFtjA++O5CHd/84BSOvuiNBunUj5bpmPZbtOgoAuGlY77N+ptFoUFpact7HLVjwOQCcubTr33Jzc7BgwYdYsOAL1NfzSweZh7KyUgA452zyhd7rUVFn/z9RX1+HX375CYMGDTnzuN27S2E0GiGTySCTJPRy0gMARvipcKiwFrMWJWJyH2/MjvVDuMa+M14WEVmRvz+nmpWO+GD7EQwMdMF1/XzwRzvW5L+lp6dh+/ZtWLDgc8hk3X6fAVmh1q7zfzt58jjuvfd2GAwGXHXV1Rg6dPiZ56utrcG+fXuwcOGXaGpqQr9+A/DAAw9Do/HAxJ6eGBWuwcrDBVi4PxezFidicpQn7hwchABX2857oUREZuTHpEJ8uCMT4yM1mDcmDM8++zj+/HMHHB2dzhyj/JtG43HO53JxcSF0Oh3q6urg4uJy5vZJk0ajrq4OkZE9cNttd3bqayHqSFqtFm+//RqeeeYlODpevBvEpWoP/7Rr1w6kpaXipZfeOOt2mSTh6fHhUCtlWJZYgOoWA54bF37RGU9EnaFbf9P8bFc2auoaIEkyqGzOHiqiVNqgpaWl1c+p1+vx2msv4vbb7+Bl6WRWmpqaIJPJzhlUejnv9aamJjzzzONobm7G/fc/BAAYO3YCtNoqfPbZR2hqakJlZQU++OB/kMvliPG2w893xuH2QQHYkV6GmYsS8fSvx5FRxhNPRHRhf39OPbM+DUq5hBeviIRMktq8Jv/TqlXL0bt39AUHMBFZurau8z4+vvj668V45pkXsW3bVnz55acATu9mBwCFQoFXXnkTzzzzIvLycvDII/ejubkJAKBSyDA7LgA/3xGPmQP8sTWtHNd/exCvbkxFvvbCc4yIiKzBmpQi/Pf3DIwIdcOrV/aEXCbhrrvux5dffoeYmL547LG5Z06C/tMVV1yJ1atXIiHhAAwGAw4dSsC6dWsBAHq97sz9jEYj3n//E7z77unvW0888QhbYpDFmD//DQwbNvLMrvPLdb7awz+tXLkco0ePg79/wDk/kyQJj44KxaOjQrHpeAkeWJWCsrrmNr8GorbotoX2lMIarEoqxJBwL5hMRuj1+rN+rtO1QK1u/W6cxYsXQiaT4Y47eLaZzItKpYLR2Pr3ularxaOPPoC0tJN4990F8Pb2AQAEBATi1VffxubNGzBx4kjMnHkthg0bAUdHJ9jbO8DZVon7h4dg+7xRuGNwIPZlV2Hm4kQ89vNRJOVX8yCRiM5hY3P6cyqzrAavT+kJHyc1gLavyX9rbm7GH3/8jmnTrumoqERmp63rvLOzCyIiemDKlGm49dbbsXLlMhgMBsTHD8a6dVvx9NMvICKiB+LiBuGtt95Dbm4O9u7dfdZzuNgp8ejoUPxyVzxu6O+HTSdLcd23CXh9cxqKapo65fUSEYm0KqkQr29Ox+BgV7w9tReU8tOllbCwcPTq1QevvPIWjEYjNmxYd85jb7llDiZOnIzHH38YY8YMwYcf/g8zZ84GANjbO5y5n0wmQ1RUbwwaNATPPfcKUlKSLzizhsicbNiwDmlpaXjwwfMPBL6QC9Ue/lZaWoLDhxNx9dUXbgMpSRJuHuiPBTf2Q3pZHW5ZcggHOE+GulC3LLQ36Qx4bXMaPBxscMvIPgCAiorys+5TXl4ODw+PVj/36Q+Ukxg8OB4TJozAvHlzAQCzZ9+AxYsXtj88URt5enoBaN17vaioEPfddweKigrw8cdfnXNJ1/DhI7FmzUasXv0b1q3biilTpkKrrYKfn/+Z+7jY2eD+YcFYe3c87hkShKNFtbj7h2TcuTwJf6SXw8iCOxH9ZW/p6c+D2X2cMTjY7cztbV2T/5aYeBB6vQ4jR45pd0Yic9Xadf7w4USkp6eedVtYWDiam5vPDO/7Z/sC4HQbGmdnlwu2otHY22DemDD8clc8ZsT44LfjJbj2m4N4Y3Maciob2vzaiIjMyaIDeXjnr53s/7u6N+pqqrB166az7qNWq+Hn54eysrJzHq9UKjFv3lPYvHknfv75NyxatAJqtRpubu6wtbVFVlYmDh7cd9ZjwsLCAeC8z0dkbn777VeUlZXg6quvwIQJIzBr1gwAwOOPP4L5898872MuVXsAgD//3AF3dw369RtwyQyTentj0S394WyrxIM/puCrPTkwsG87dYFu2aN9wc4sZFU04KMZfRDt6wA7O3skJR3CFVdcCeD0/+BFRYXo2/fS//P+20cffQG9Xg8nJzVqapqQmnoCL730LObP//DM4kgkQnh4ZKve61VVlXj44fsgk8nw2WcL4evrd9bPk5OTsHDhF3jvvY+h0WgAAFu3boKtrS2io2POeT4ntRJ3Dw3C7Dh//HqsBN8n5OPJtccR6GqLWwb648peXlApuuW5PyICsPxQAX7OkcHORo1wFJ25vT1r8t+Skw8jMrLnJftDElmy1q7zS5cugkwmwzvvfHDmtuPHj8HV1Q0uLi5YtWoFvv/+O/z007oz7WiKi4ug1VYhJCT0olk8HFR4Ylw4Zsf547sDefj1aDHWpBRjdIQGt8X5o7fPucMBiYjMncFowv+2/R979x0eVZX/cfw9Jb2TBoTQ4dCkWlBRsWMv69rL6lrWtay9u+paV9efvbu2Xdta1l7Xhh1RQBQ4dEInCQTS28zvjzsJIYAkZJJpn9fzzJPMnXvvnHPmzJx7v/fcc+bz8rQVHGByuekgg9fjZsGqldx447X06lXIkCHDAKioqKCoaAmTJh262X4ef/xhkpOTOfnkP5Cd7ZxHffnl582TUX/zzZe88MJzvP76eyQkJAAwa5Yzt1zfvv26IqsiHfLXv95Mbe3GIVtKS0s577wzueqq6zaZdL3JtmIPTX7+eRqjR49t83xL/bNTePakMfz9f/N4/AUkuw4AACAASURBVNslTF++npsOHkJOSvz2ZUykDWIu0P7lglJemb6CE8cVNPeWO+qoY3joofvIyMgkK6sbd999B6NHj2XEiB2or69nw4b1pKdnEBcXt42903xrS2ZmMmVlVZSWljYvT0/P6LyMiWxDfHx8u+r63Xf/nbKyMu6//xESEhKae8i5XC66dcumT5++WDuHRx55gKOP/j3z5s3l3nvv4pRTTt/klsfWEuM8/H50T44a2YPP5pXwrx+WctvH83j068UcM6onR4/qQbYaPpGY8tqMFfzfZwvYe0h3+qQey8MP309mZlaH2+Qm8+ZZ+vfXxW6Jbm1t51NSugNw7LEncumlF/DCC/9izz0nMn36j7zwwnNccMHFuFwudtttAo8//jC33/43Tj31DNavL+O+++5m5MjR7LTT+DalqXt6IlftN4izdu3Dy9OW8+r0lXw2r4RxhRmcslMhu/XNwuVydWaxiIgERXV9I1e/OI3/zVnDieMKuHDP/njczu/XkCHDGDVqDHfccQtXXHENXq+XRx99kMzMLA466FBqa2sCk5xm4fF46NGjJw8+eA8DBgykd+++vPLKi8yePYvLLrsKgEmTDuGFF57j9tv/xumnn8WaNau4667b2Xff/enff0Aoi0GkTVpPzB4f75zf5+TkkpXVrd2xhyZz51oOOmjzi1e/JSnOww2TDGN7ZXLnp/M59umpXLRXfw4bka9jEOkUMRVoX7mhhr99OJdBuSn8ecLGK8FnnXVuYBLT62loaGCXXXbjkkuuBGDmzBlceOGfuP/+RzWBmkS8ttb14cNHMHnyZ/h8Ps4667RN9uHxePjii+/JzMzk73+/hwcfvIf//vcVcnJy+eMfz+HYY09sU1q8bhf7m1z2G5zD1KVlvPDjch7/dglPTynigCF5nDC2AJO39YC9iES+Rp+fB79cxL+nLmNC/27ccvAQ3AzG19gY1Da5tLSEQYNMZ2VDJGy0pZ1/6qlnGDx4BDvvPJ5bbvk7Tz31BE8++Sh5eflcfPHlHHrokQAUFPTinnse4rHHHuSss07D6/UyYcKe7R5vFSA7JZ4/T+jHaTsX8ubMVTw/dRkXvf4LA3NSOGFcAQcOydNdbSIStpaVVXPFW7OYX1LJZXsP4Lixm/a2dbvd3HrrXTz00L1cccXF1NXVsfPO43nwwcdJTk7mvffe5rbbbuKVV96iR4+eHHbYkZSWlnDXXbdTXr6BIUOGcf/9j9C7d18AsrNzuO++R3nggXs488xTSUpK4oADDuLss/8cgtyLBF97Yw9NSktLSU9v/11xLpeLw3fozsiCdG77eB43fzSX92ev5pr9B1OYtf3zQIlsiSuYExIWF5f7YWNv7nBSVdfImS9NZ+WGGp4+cQx9uyV36vuFYxl0NZWBygDaVwZL1lbxn2krePvXVVTX+xjbK4MTxhawx4Ds5h4jkSjW60Gs5x86vwxyc9M69AVpar+Doa15XVNey60fz+WbRev4/eieXLL3ALwR9D2PpXodK3lVPrtOfaOPj+YU8++py5hfUklmUhxHjezO70b1JD8tISjvEQ757Aqxkk+IzryGU/vdEdH42TT5etFabnhvDj4/3HfcKHbITQl1krpENH+mrSmv0WlrefX5/bwxcxX3f7GQBp+fP47vzQljC0iM84QglcGhzzU0ttaGx0SPdp/fz00fWBaUVHLPUSM6PcguItunT7dkLt93IH/avS9v/rKK/0xbzuVvzaJnRiLHjenJ4SO6k5oQEz9bIlGrpr6Rt35ZxcNfLabB5+eKfQfy+9E9Q50sEelCcR43hwzP5+Bhefy0bD0v/bScZ6cs5bkpS9l7UC7Hj+3JyJ7puqVbREKmpr6RByYv4j/TVzAwJ4U7Dx/GDv2ywybAIyLbx+1ycfTIHuzRvxt3fjKfh79azGszVvLnCX2ZNDQPt449pIOiPmLl9/u565P5fDqvhIv26s9u/bqFOkkisg1piV5O3rEXx48tYPL8El78aTn3fL6Qx75ewmEj8jluTIFu8RKJAL7AXXPlNQ38uqqcKUvKeOfXVayvaWCn3plcs/8gemXquywSq1wuF+MKMxlXmMny9dW8On0lb85cxf/mFjM0P5XjxhSwv8klXsPKiEgXsqsruP69OSxaW8WJ4wr484R+Gt5KJMrkpiZw1xHDmVpUxn1fLOSG9y0v/LicC/fsx859skKdPIlgUR1o9/v9PDB5Ea/OWMkpO/bixHFbnrlYRMKT1+1in8G57DM4l1mrynnpp+W8NmMl/5m2gj0GZHPC2ALGFWaox5tIGPrvzyu57eN5myzzuGCvgTkcO6YnY3vpuysiGxVkJPGXvfpz9m59eG/Wal7+aQU3fmC574uFHDwsnyN26E6/bN2VKiKdp6HRx7+nLuOxb5aQlRzHg7/bgV36KuAmEs127J3JsyeP4cM5a3j4y8Wc9+pMxvTK4IxdCtmljyZtl/aL2kC7z+/n3s8X8uJPyzlmVA8u2LOfviAiEWxY9zT+dvAQLtizH6/OWMnrM1YyeUEpg3JTOH5MAQcMyY3ocdVEos1OvTM5Z7c++IFEr5sh+akMzU/T8E8i8puS4jz8blRPjh7ZgylFZbw6fQUvTVvO8z8uY2TPdI4Y0Z39TC7J8WrzRSR4Zixfz+3/m8eCkir2GZTD1fsPIjMpLtTJEpEu4Ha5OGhoPvsMyuW/P6/kXz8s5YLXfmFofipn7NKbPQdma0gZabOoPNutbfBxw/tz+GRuCceNcSZYU5BdJDrkpiZw7u59OX3nQj6cs4YXf1rOzR/N5Z4vFnDw0HyOGtmDgTEySZFIOOuVmcSZu/YJdTJEJEK5XC526ZPFLn2yKK2s471Zq3lz5ipu/mgud3+2gP2H5HLosHxGFqTr5FdEtlvRumoe/moRn8wtIT8tgX8cMYy9BuaEOlkiEgIJXjfHjy3g6JE9eG/Wap6ZspTL35pF76wkfjeqB4cOzyc9URfg5LdFXaB9QUkl1783h3nFlVw8sT8njusV6iSJSCdIjPNwxA49OHxEd35atp7//ryS/85cyX+mr2CHHmkcOqI7+w3OUUMoIiIS4bJT4jllp0JO3rEXP6/YwJszV/Hh7DW8OXMVeanx7GdyOcDkMqx7mjrXiEiblFbW8cS3S3hj5iriPS7OHN+bU3Yq1N0yIkK8182RI3tw6Iju/M8W859pK7jn84U8/NViJg3N45hRPTB5qTrmkC2KmkB7faOPl6et4NGvF5Mc5+Geo4YzoX92qJMlIp2s5URqZdX1vDdrNW/8vIrbP57HXZ/MZ/d+3Zg0NI8J/btpaBkREZEI5nK5GFWQwaiCDC7dZwCTF5Ty8RznBPiFH5fTIz2BPQdks0f/bCaOSAx1ckUkDK3aUMPL01bw2owV1DX4OHJkD87ctQ85KfGhTpqIhBmv28WkoXlMGpqHXV3BqzNW8EHgQn//7OTm13qk65hDNor4QHuDz88X80t46MtFLC2rYUL/blx3wGCy1VCKxJzMpDhOHNeLE8YWMGdNBR/MXsNHc4r5YkEpyXEexvfNYo8B3ZjQL5vMZPV0FxERiVQp8V4OGprPQUPzKa9p4IsFJXw6t4Q3Zq7i5WkrSHl7VmDomUx27J1FYWaiep6JxLBfV5XzwtRlfDK3GIB9B+dy9m596NNNkyyLyLaZ/FSuPWAwF+7Znw/nrOGD2Wt4+KvFPPzVYsYUpLPP4Fz2GpitoLtEZqDd5/dj11Tw1YK1vDFzJWsq6ujXLZl7jx7Bbn01K7BIrHO5XAzNT2NofhoX7tmfqUvL+HRuCV8uLOXTeSW4XbBDj3R27uP0hB/RI50ErzvUyRYREZHtkJbo5dDh3Tl0eHdq6hv5oaiM75et59M5a/h0XgkAeanxjCvMZEyvDEb0SKNfdgpet84ZRKJZRW0DH9ti3v5lNTNXbiAl3sPxY3tx3NieCoaJyHZJS/RyzOieHDO6J8vXV/Ph7GI+mLOGuz9bwN2fLWBQbgp7DshmQv9uDMlP07FGDAr7QPv0Zev5yDpXnavqG1leVs2i0irW1zQAsEufTC7bZyB7DMhWBRaRzXjcGydTu8o/kDlrKpg8v5SvFq7lyW+LeOLbIuI8Lkb0SGdUz3SG5qdi8lPpma6ebyIiIpEmMc7DHgOyOWxcIev2rGTJumqmFpXx49Iyvlu8jvdnrwEgKc7NkPw0huWnMTgvhQE5KfTrlky8LryLRLTSyjq+XFDK5/NLmVK0jvpGP/26JXPxxP4cPqI7qQlhHwIRkQhRkJHEGeN7c8b43hStq2byglImLyjl6e+L+Od3RaQmeBjbK5Mde2eyU2Em/XOSNYF7DAj7VubXVeV8NMc5IE7wuinITGLioBzGFWawc++skAwR8/DDD3DXXbdTWVnR5e8t0tVSUlK5/PKr+fOfLwh1UjqsZU/3c3bvS3lNA9OWr+enpev5aVkZ/5q6jEafH4CMRC+D8lLpm5VE727J9M5MondWEj0yEnVRTySMqE0W6Zhoaudbc7lc9O2WTN9uyRwzuid+v5+lZTX8umoDv64s59dV5fxn+nLqG5223+OC3lnJ9OmWREFGEr0yEynITKRXRhI90hPwehSEFwk3NfWNzFy5genLNjClaB0zlm/AD/RMT+D3o3tywJA8huWH36SFOn4R2VwkH5P0zkri5B17cfKOvSirqueHpWX8ULSOH4rKmLygFICUeA/Du6cxomc6I7qnMaJHGlnJGvY62rj8fn/QdlZcXO4HyMxMpqysKmj7DTc77DCY1atXhToZIl0mP787M2fO3a5tI+n3oLbBx/ySSuzqcmavrmBucSVF66qoqG1sXsfjdlGQkUjPjETyUuPJS00gNy2B/NQEcgPP05O8m1ypjqQy6Ayxnn/o/DLIzU3r0NljU/sdDF39eatNFum4jrTz4aqtv0UNjT6KyqqZX1zJgpJK5pdUsXRdNcvXV1PXuPGn0e2C/LQEclISyEmNJydl4yM7NZ5uyXGkJXhJT/SSmuDtsh5rsdTGRmNew6n97oiu+mxqG3wsLq1iXkkF84ormbliA7NWV9Do8+MCTF4qew7IZuKgbAbmpAQ9uB7MfOr4RWTLgnVMEk5txsoNNfy0dD0zV27gl5XlzC+uoOkQo1dmIkPz0xiUm8Kg3BQG5qSQn5bQrt+vcMprZwunvG6tDQ/7Hu3h6NxzL9DVZ4kZKSmpnHtu5F1R3h4JXjfDu6cxvHta8zK/309ZdT1F66o3eazcUMP84kpKK+tofYbjcUFGUhwZSXFkJsWRm55IqtdNZpK3eVlagnMi7vz1kJrgJTneo1vJRNpJbbJIx8RSO78lXo+b/tkp9M9O2WS5z++npKKO5etrWFZWzfL1NaxYX0NxZR2LS6uYWlRGeW3DFvfpAqeNT/SS3vQ30UtKvIekOOeR3Py/ewvLnOVNz+PUk15iSEOjj1XltSwtq2ZZWeD7V1ZDUVk1RWurmoNTCV43Ji+Vk3fsxZiCDEb2TCctMXLCGzp+EdlctB6T9EhP5JDhiRwyPB9w7sSZvbqCX1ZuYGbgDruPA0NmA6QleBmYm8KgnBT6ZifTOyuJPllJ5KUlKF4QAdSjvZOoDFQGoDKA6C+DhkYfJZV1rKmoY015LWsqallfXU9ZdQPrquspq66nvLaRtZW1lFXX4/uNn1y3C1LivaQFAu8bHx7SErykJHhJjfdssjw1vsX/CV4Sve6wuzU22utAW6hHe/SJlXxC7ORV+YwuXZHPmvpGSqvqKKmoo6y6ng01DZTXNjh/axpYX1NPea3z/4aaBqrrG6mqb6S6rpHGdvzqet0ukuM9JHo3BuUT49wkxnlIS4rHg5+kODeJXmd5UpyHBK/z+ibLA3+bnifGOftMCMNjhy2JxrobTu13R7Tls/H7/ZTXNlBc4XxniitrKa6oo7SyjuIK51FSWcua8tpNvh8JXjcFGYkUZiYxICeZgbmpDMpNoTAzCU8XD+cYjXVwa5TX6KS8hq+K2gYWlFQyr3jjY0FJJVX1G++uT/C66Z3lDGnbKzOJ7mkJ5KclMKggk2R8pCV4I6I974hw+lzVo11EpBN4PW66pyfSPT1xq+s0NQY+v5/ymgbKquupqGukorah+VFe20h5bQOVtc5JekXg+coNNYF1Gqmsa/jNQD04Q9tsORjvLNtSsD45zkNKvJekeDcpcV6S4j3Ee1xR30iLiIh0RGKch4IMZzz39vD7/dQ3+p2ge9OjrpHqel9zIL4pKF/Tall1fSM1DT5q6hspr2lgbVU9lbVOEL+2wUd1feM2jxVac0FzAD4pzk1C3MagfsvliYEAflLg9daB/MRNljf976zvdeu4IpL4/X58fufOjkafn0a/H58PGv3+5nq28eHDHbeB4nVVrK9xOpusr6lnfbXzKKtpcP6vaWieC6ml1AQPuYEhmcb0yqB7WgIFmc4cCYWZSeSkxKvuiEjUS03wMqogg1EFGc3L/H4/JZV1FK2rZsnaKpYE7q6fV1zJF/NLaWj1m5oc5yE/LYHsFOcu+qa76Z2/XjIS45rvrkuODzwCbbt+Z4NHgXYRkS7idrmah5TZHn6/c1JeUdsiSF/XuElwvuXyikDgfkU7g/XgBOyT4zY2vs7t6268Hjdetwuv20Vci/+9Hhdxbjcet4umNtqFC7cLEhPjqK1twOVyeu27AFwuXDQ9dxa6AmW0cftWz13O/pr+b9oenHWanwdea9q+ad/O+7sC229M32b7a7G9y7Vx3y7XxvWaljWdhPr84PP58RH46/fj9zsnpH4/JCTFUVlZS1Kch30G5WhCPRGRGOZyuYj3uoj3usnczmOCJq17djUF8WsanCB9y8B8Tb1vi8urA3+bAqhN61XX+1hXVU9NQ+1m27e3G7XbtbEdb2qLm/5v2Sa3bGebyqq5DXe78Pv8m7XFtFynqZ1n475b/m2Zjqb33GRZq7/uwL4T4zycv0c/emZsvWNFtPhqYSmXvTlri0HxtvC6XYHAjhPU6dstmYxEL5lNQyqmxpMbmNsoJyWexDhPkHMgIhIdXC5X4PcygXGFmZu85vP7WVtZx6ryWsobYeGqDawur2VVeS3rquqYX1LJ+sCFz239nLtdTm/5OI/ziPe4Av+7iPe4m/93Xtv4v9ftwuN24Qm0mZ7Ac6e9deF1B9rewDrOa845tN/vxw/4A+fTzv/OubMP5wWfn+bljT7w48cb56Wmpt65ALyV8/CWF4rdLhdnjO+NyUvtlM9oSxRoFxGJEC6Xi5R4LynxXvLTErZrH03B+vKajUH6pp5ylYHecpV1jVS1+L/5b10j1fUNNPj8NPh8NDT6qff5aWj00eBzGrIGn9M4+mn6yyaNZuv/Y43H7WJg7uZjAYuIiARDyyD+b9xs1yH+QK/m1gH86haB+ObngQB+TaCnfdNxgHOS7RwvNJ9wb3KyvemxBH6Ii/dQW9vQfGzBJuu2PtZwNmo62W65b59/43u2/NvY4gS9Zbp8fid4XN3i9v1oZvJSOWvX3vj8bDF4ktBiCKOmuQTyuqXQUFNPRpKX5DiPekaKiHQyt8tFTmoCOakJzkX3XulbXK/lXfXraxqoqmugqt63yfl/VV0DNQ3O+X1do4/6Rh91jX7qG33UB5Y1NPoor28I/B9YFmg3GwOxgKa2tDkI7vO3a6i8Ji07wDV11HM3BerdLtxsvCDucTsXxD2BO+c8zRfWXbjd4HW7qarr2vZbgXYRkRjSMljfVX5rHDV/q5Pk1leugeYT3qYpRXz+TU+8fZuciLdl+43vu/n2G0/EaXmiHdi3v8X2sLF3nNPgO42508Bv2nsuMyOJivIakuI8231Hg4iISDhwuVzOMDFxHujCNi2cxmWNZrmpCfxxfJ92baPPRkQkPHX0rvqOaj0Umc+/8U6yLQXUt3WhNhLaGwXaRUQkZJoaWJrb0+jsAZWZmUxZdGZNREREREREZDNNvcw9uIiVkcI0SKyIiIiIiIiIiIiISAco0C4iIiIiIiIiIiIi0gEKtIuIiIiIiIiIiIiIdIAC7SIiIiIiIiIiIiIiHaBAu4iIiIiIiIiIiIhIByjQLiIiIiIiIiIiIiLSAQq0i4iIiIiIiIiIiIh0gALtIiIiIiIiIiIiIiIdoEC7iIiIiIiIiIiIiEgHKNAuIiIiIiIiIiIiItIRfr8/6I8bb7zxxs7YbyQ9VAYqA5WBykBloPzHYhnESl5jJZ+xlFflM7oeymf0PWIpr5H2iJXPJlbyqbxG70N5jc6H8hpej87q0X5DJ+03kqgMVAagMgCVAagMYj3/EFtlECt5jZV8QuzkVfmMLspn9ImlvEaaWPlsYiWfoLxGK+U1OimvYURDx4iIiIiIiIiIiIiIdEBnBdpv6qT9RhKVgcoAVAagMgCVQaznH2KrDGIlr7GST4idvCqf0UX5jD6xlNdIEyufTazkE5TXaKW8RiflNYy4/H5/qNMgIiIiIiIiIiIiIhKxNHSMiIiIiIiIiIiIiEgHKNAuIiIiIiIiIiIiItIBCrSLiIiIiIiIiIiIiHSAty0rGWMSgAeA3wO1wP9Za+/cxjYTgBestb1bLd8buA8YCEwBzrTWzt+OtHepIJeBBQa3Wn2MtXZ6EJMcdO0pA2PMccD1QD9gPnCdtfbtFq8fC9wG9AQ+Bs6y1q7p3Bx0XLDKwBjjBiqApFabZVlryzop+UHRzjI4HbgWKAB+Ai621k5p8Xos1IOtlkGs1IMW23QDZgFXWWufabH8AuBKIAN4FTjfWlvZSUkPmmCVgTGmB7Ci1arrrbWZQU/0doiV9i+W2rhYactipb2KlTYpltodtS9bXPdD4IBWi4+y1r4ReD1sv6ORzhgzBHgQGA+UAg9aa+/ayrp7APcCQ4B5wBXW2o+6Kq0d1c687gP8A+e4ZjrO7+kPXZXWYDLGPAEMstZO3MrrERnD2ZJt5bXFeicB51prJ3RJwjpBGz7XC4ELgB7ATOBSa+03XZfC4GlDXq8CzgOygcnABdbaeV2XwuBoR/0dCPwMHGyt/bwLkhZ0bfhMw/a8sq092u8CdgX2A84BrjPGHL+1lY0xO+ActLpbLS8E3gL+DewIrALeDBzYh7tglUECMADYHecHrenxS+ckO6jaVAbGmD2Bf+E0xqOAfwKvG2PGBF7fCXgWuAXnICYdeK4rMhAEQSkDoD+QCPRl03qwvpPTHwxtLYP9gYdxTuhHAN8D7xtj0gKvx0I9+M0yIAbqQSv3AvktFxhjjsapA38G9gZ2Au4Oemo7R1DKABgOrGbTOtD6oCGUYqX9i6U2Llbaslhpr2KlTYqldkfty+aGA8ezaV7eh4j4jkYsY0wcTjkXAaNxAlXXB4KQrdfNA94GXgFGAv8B3jDG9Om6FG+/duZ1KPABzkWdcTgxjk+MMb26LsXBYYzZFzjzN16P5BjOJraV1xbr7Q083vkp6jxt+FxPBm4Grsap758DHxhjCrokgUHUhryeCVwGnIVzPLsOeCfS6nA76q8LeJLNO05EjDZ8pmF9XrnNHu3GmBScCnmYtfZH4EdjzJ3A+cBLW1j/HJwruwtxrha1dBYwo6mngjHmDJwf6n2A/3UgH50qyGVgAD/wg7W2vlMTHkTtLINTgdestU8Ent9vjDkUOA6YhnPV9LUWvW1OBYqMMQPD+cp4kMtgGFBkrV3SNakPjnaWQT5wg7X25cC2NwIXAzsA3xAb9WBbZRAL9aBpm4OAnYHiVi9dBDxgrX0rsN6fgP8ZYy6z1lZ0Vh46KshlMAyYY61d1YlJ3i6x0v7FUhsXK21ZrLRXsdImxVK7o/Zl83waY9Jx7sL4fit5CdvvaBQowOnBfJ61thqYb4z5H7AX8HyrdXcHsNbeEXh+mzHmUpyLH2H3u7IF7cnrn4EfrbVXBp7faZwe7ufhBC4jQuB7+Djw9W+sFpExnNbamFeMMTfgfIYR19u5SRvz+gfgYWvtq4HnVxtjfgccBjzauSkMnjbmNQ243Fr7QWCb24EZQHc2v+srLLW1/gb8CfB0boo6TxvzGrbnldC2Hu2jgATgqxbLvgJ2MsZs6cM7CDgNuGcLr43HuU0DAGttFc5tq7u2NcEhEswyGAYsDMfKsA3tKYMHcK6OtuQHmm5TbV0PluIcfEVTPdhWGQwDbGckspO1uQystf9ucUCWhHMyv4aNVxmjvh60oQyivh4ABHpLPgqcDdS1WO7B6Uk4ucXq3+FcBB5DeAtKGQSEcz2IlfYvltq4WGnLYqW9ipU2KZbaHbUvm+dzGFCD09N4S8L5OxrRrLWLrbXHWWurjTEuY8zuwJ7AJ1tYvRTIMMb8PrDukTgBrp+7Ms3bq5157Q9822rZDCKvzt2K05P5899YJ1JjOK21Ja8A+wMHAq91cno6U1vyeh2b99pveYwXKbaZV2vtPdbapwGMMRk4F8R+xblgFCnaVH8Dd6DchHNMEKnaktdwPq9s0xjtPYC11tqaFstWA/FAHrCy5crW2iMBjDF/2Mq+Wl8xWg2E+y1WwSyDYUCjMeZ9nAN6izN23fedkO5ganMZWGtntNzQGDMc2Bfnds+mfUV1PWhDGQwD0owxk4FBOD0DL7bWhuvJUJN2fRcAjDEHEri1FzjJWruhxb6iuh40+Y0yiJV6cCfwgbV2sjGm5fJMnGEKmuuBtbbBGFNK9NWDrZUBOPWg2hgzNbDfL4FLrLXh0MMiVtq/WGrjYqUti5X2KlbapFhqd9S+bJ7PYUAZ8JJxxgBfCtxorX2vxb7C9TsaTZbhjIH/Ds4Qca19iTO++cuAD6dH5ZnW2tldlsLg2VZet1S/+gA5nZyuoDHG7IozP8II4NLfWDXiv1/tyCs2MCa7cYaPiThtzau19rtW203CGVosku5SaPPnGlj/bOAxnDlBDrTW+jo3hcHRznw+htPhKSLvyGhHXsP5vLJNPdqTcSpiS03PE9r5flvbV3v309WCWQZDgSycMTIP83rNnwAAIABJREFUxpm06FNjTN+OJLALbFcZGGesvv/iHHi9vo19RWU92EoZNNWDG4EjcHrpfBa4whrOtqcMZgBjca6sPmOMGb+NfUVjPdhaGUR9PTDG7IVzC+IVW9lPy21b7itq6sE2ygCcepACXIgTwCwA3jPGtGnC8k4WK+1fLLVxsdKWxUp7FSttUiy1O2pfNv8shgKpOONETwLeA942xuyyjX2Fy2caLY4IPMay5TvXUnAmzr4F586RK4H7WvzGRJJt5fUl4GhjzO+MMV5jzCHA4TgXisKeccY3/idwkbV23TZWj+jvVzvzGtG2N6/GmME481o8Z62d2lnpC6btzOuHOHMqPIUzz0C/zkpfsLQnn4Fh03rizH8Scdr5mYbzeWWberTXsPmPaNPzqna+39b2VdrO/XS1YJbBiUBSU+8hY8yfccazOxX4W0cS2cnaXQbGmQzmI6AROKbFFcOt7au9ZdnVglkGewAea21lYL0TcXrnHEF4T97U7jIIjKW5CpgeuEL5J5zbtGOmHvxGGUR1PQgMTfAkzqzuW5pMr6kXW9TWgzaUATgnpfXW2trANr/D6cm3G5sObxAKsdL+xVIbFyttWay0V7HSJsVSu6P2ZfPP4irgVmttWeD5DGPMOJwJVL//jX2Fy2caFZoCcMaYZOBZ48xr0HK4osuBBGvtXwPPpwXuhLoOOLRrU9sx28qrtfYjY8zVOBOExuMMpfIgzrjlkeCvwDxr7SttWDdSYzhN2pPXSNfuvBpjRuAc483B+U2NFO3Oq3XmoFlijDkPZzL003A6F4SzNuXTGJOPM0/WwYE79cLhgnp7teczDefzyjb1aF8OZBljWl6d7Y5zFXNtO99veWDblrqzhdtaw0zQysBaW9/iFl2stX6cH7Vwn925XWVgjOmP0+vND0y01rZsiGOiHvxWGVhra5pOZJueA4uIonpgjNnVGDOq1faz2HhLZdTXg22VQQzUg52BgcC/jDEVxpgKnKvsjxpjHsU5QK+hRT0IHBRkEz31YFtlgLW2oikIEni+BqdswqEexEr7F0ttXKy0ZbHSXsVKmxRL7Y7al1Z111rb2CLI3mQ2G/MRzt/RiGaMKTDGHN5q8Syc4HJ6q+U74dwx09KPOOOZh7125hVr7V2B5QXW2p0Cixd3aiKD50TgwBa/HVcAewT+by3Sv1/tyWuka1dejTE7Al8Ac3ECtDVbWi9MtTmvxpj9jTEDm54HzkFmExlDPbU1n5Nw8vN54LWmNvN9Y8w1XZfcDmnzZxrm55VtCrRPx5lYZ7cWyybgzLLd0M73+y6wLdB8hXhMYHk4C1oZGGOmGGOubPHcDYzEqRThrM1lYIzpBnwMrAf2staubrWv1vWgEOhNFNWD3yqDwO2Fy40xx7dYloozHmrU1AOcSUZaT6I3DqdRgxioB/xGGcRIPZiCk5/RLR6rca5W/zXQK/YHWtQDnImVGnDGBg5nQSkDY0x3Y8z6QK9SoLn3cA7hUQ9ipf2LpTYuVtqyWGmvYqVNiqV2R+3L5r9FrxpjHm61/Rg25iOcv6ORbijwunGGD2syDii21pa0WncFzri5rbdf0InpC6Y259UYc7wx5sFAsGeVMcaF02v/sy5Mb0dMxBkDuem34wlgauD/1iI1htNkIm3Pa6SbSBvzGuhI8QHO3RgHW2sj7cLDRNr+ud6AM4Qa0HyBfRQbj/PC2UTals/XccbYb1pvXGD5mTgTpkeCibS9/obzeeW2h46x1lYZY54FHjbO5GbdgcuAswCMMd2B9dba6ja831PA5caYa3HG+bweZ/b4Lc3kHTaCXAbv4JTBTJyDjkuAbjhlE7baWQa34hzE/w7wBl4DqA7c2voI8IUx5mucBvo+4H1rbVhP2BDMMjDGfAjcaoxZgdNr51acXgFvd2We2qudZfAwMNkYcz7OeGin4YxzeGJgd7FQD7ZaBoFbumKhHsxvua0xphFYE+hVB04ZPWGM+RmnPXgYeCrcD/aCWQbGmB+B+40xfwJcwP3A/6y1IQ/6xEr7F0ttXKy0ZbHSXsVKmxRL7Y7aly3m8y3gcWPMVzgXSk7GCfz9KbC7sP2ORoEvcHp1P2OMuRQYANyB8/vQ+nN6AvjaGHMFzgSiewOn44yfGwnak9c5OEPKNNXJq3HGqH8mBOlut8AQGs2MMetw2vb5xhgPkIszWXEdERrDadLOvEa0dub1IaASZ7iYdGNM010bFeHSHv6Wdub1AZzv6zc4F3kvx7lT5dkuTna7tSOf5UB5i/WaYr3LrbXtHYkkJNr5mYbteSW0rUc7OIn+AfgU52rI36y1/wm8thI4ri07sdYuBo4GTsG5MpEPHGEjY7bfoJQBTkP9UGAf03GuOu1rtz62Yjhpaxn8Huc2ummB5U2PhwCstd/iHERfB3yL01PutK7JQocFpQyAC3AmcnoZZ2xJgEnbcZdIKLSpDKy13+CUw7nATOAAnNm9lwdej/p6sK0yIAbqwbZYa1/CmTTrEZxZ7qfShlnjw0Sw2oXjcGZK/xDnpGV+O7btCrHS/sVSGxcrbVmstFex0ibFUruj9mXTuvscThD+bzh192Ccursg8Hq4f0cjlrW2HjgE566P74HHgHtxLtrApp/T9zgTgh4H/AxcBJxkrf20i5O9XdqZ1+k4de42nOFyCnCOaSqJfIVsnMsh0mM427JJXqNcc16NMWk4Q430xglStjzGuypkKQye1nX4ZeAvOG3/NKAvcEAkXFDYhpisv4HnYX1e6fL7/aFOg4iIiIiIiIiIiIhIxGprj3YREREREREREREREdkCBdpFRERERERERERERDpAgXYRERERERERERERkQ5QoF1EREREREREREREpAMUaBcRERERERERERER6QAF2kVEREREREREREREOkCBdhERERERERERERGRDlCgXURERERERERERESkAxRoFxERERERERERERHpAAXaRUREREREREREREQ6QIF2EREREREREREREZEOUKBdRERERERERERERKQDFGgXEREREREREREREekABdpFRERERKKIMcYV6jSIiIiIiMQaBdpFIoAxxm+MuayT36Nv4H2O2Y5tOz19IiIi0SxYbakx5q/An4OQJBERERERaQcF2kVEREREosdNQFKoEyEiIiIiEmsUaBcRERERERERERER6QBvqBMgIu1njNkZuBHYDUgGFgH/Z619LPD6H4B/ACcDdwGDgJ+B04AhwB1AAfA5cIa1dk2L3fc3xnwOjA/s92Zr7Qst3nswcD8wAVgFnNfe9ImIiMgW5Rhj3gAOxGlj77PW3tv0ojHGC/wV+AOQB/wCXGmt/STwuj+w6l3GmPOttX0D47VfCJyJczxQD3wHXGKtndk12RIRERERiX7q0S4SYYwxvYHPgArg98ARwFzgUWPMDi1WTQMeAW4HjgMKgXeBW4FrcMZv3Q+4udVb3Ar8FNjv98DzxpjDAu+djhOczwdOCuz72e1Mn4iIiGzqMmADcCTwGnCPMeb8Fq8/AVwK3BdYZw7wvjFmt8Druwb+PgAcFfj/UuDvwJM4AfwLgGHAM52WCxERERGRGKQe7SKRZzjwLXCStbYewBjzHbAW2Ato6p0WD1xlrX05sM544CpgL2vt5MCy/YFdWu3/JWvtJYH/PzTGDAWuBN7G6UGXC+xsrV0W2Mc6nGBAe9MnIiIim/rGWntq4P8PjTGFOG3wg8aYITjt8FnW2icD63xgjOkB3ALsY639zhgDUGStnRZYpxDn7rT7As+/MMZkAf9njEm11lZ0Qb5ERERERKKeAu0iEcZa+z5O77VEY8wwnNvAdw68nNBq9Skt/l8d+Du1xbJSILPVNq+1ev42cEPgdvXdgZlNQfaAN4HG7UyfiIiIbPR6q+dvA8caY/oCEwPL3gu0yU3eA243xsRba+ta79Ba+xcAY0wuzvBxQ4DDAi8n4NyBJiIiIiIiHaRAu0iEMcZ4gLuBc3B6rS8AJgdedrVavbz19tbaqm28xepWz4txfitSgCygpNX+Go0xxduZPhEREdloS20wQAaQHfh/+Va2zQFWtF4Y6An/BM7cKlXADJzhaUDtsoiIiIhI0GiMdpHIcy1wNnAqkG6tHYwzyVmwZLV6ng/U4gTtS3EmX2sWmGSt5TadnT4REZFotaU2GJyA+3rAjzMO+05beJS02hZjjBunV3wcsAOQZq3dDXirMxIvIiIiIhLLFGgXiTy7AlOtta9YaysDyyYF/gajZ1rTvpqC6EcDk621PpxJTkcYYwa1WH9fNh0SprPTJyIiEq0mtXr+O2CetXYF8BVOO5purZ3a9MCZ2PxioCGwja/F9rnAQOBxa+0vgba85fuoXRYRERERCRINHSMSeX4ArjLGnI8zsehOwF9xerklB2H/pxtjVuKM5X4mzuSm5wVeew64DHjbGHMtkATcBtR3YfpERESi1X7GmH8A7wNHAYcDxwNYa6cbY14D/m2MuRGYjTNu+3XAnS2C6GXABGPMlzhztRQBFxlj1uAE408DDg2sq3ZZRERERCRI1KNdJPLcATwL3AC8A5wInA98jNObvKMuBI4I7HsIcLC19msAa20NsA/Oyf0zwO04J/hruzB9IiIi0epanCFe3gUOBE6y1r7c4vWTgKeBq4EPgBOAq4BrWqxzI7A3TrDeg3NnWgXwcmDbZJxe8KB2WUREREQkaFx+vz/UaRARERERERERERERiVjq0S4iIiIiIiIiIiIi0gEKtIuIiIiIiIiIiIiIdIAC7SIiIiIiIiIiIiIiHaBAu4iIiIiIiIiIiIhIB3iDubPi4vIOz6yamppARUVtMJITs1SGHaPy6ziVYcepDDsulsowNzfN1ZHtg9F+b49Y+ow6m8oyeFSWwaOyDC6VZ/CES1l2tP0WERGR8BJ2Pdq9Xk+okxDxVIYdo/LrOJVhx6kMO05lGP70GQWPyjJ4VJbBo7IMLpVn8KgsRUREpDOEXaBdRERERERERERERCSSKNAuIiIiIiIiIiIiItIBCrSLiIiIiIiIiIiIiHSAAu0iIiIiIiIiIiIiIh2gQLuIiIiIiIiIiIiISAco0C4iIiIiIiIiIiIi0gEKtIuIiIiIiIiIiIiIdIAC7SIiIiIiIiIiIiIiHaBAu4iIiIiIiIiIiIhIByjQLiIiIiIiIiIiIiLSAd5QJ0BEOl9NfSM/LlvPrFXlzCuuZH11PbUNPhK8bvLSEuidlcT4PlkM656Gx+0KdXJFRERiRk19I98uXsfPKzawdF01pVV1JMZ5yEj0MjQ/jXGFGQzNV/ssIiIiIhLuFGgXiVJ+v5/pyzfw6vQVfLVwLVX1jbiAwqwkclLiSUv0UlPfyM/L1/Ph7DU8/s0SuiXHceTIHvx+dE9yUuJDnQUREZGotXhtFc98X8Qnc0uoafAR73FRkJlEXmo81fU+7JoKPplbAkBhZiLHjy3gsBHdSYrzhDjlIiIiIiKyJQq0i0ShKUvW8ejXS5i5cgMZiV4OHJrL3oNyGNUzg+T4zU/Qy6rr+X7xOj6cs4anvyviuSlLOXFcAX8c32eL64uIiMj2Kauq594vFvD+7DXEe9wcPCyffQfnMLZXBl7PpqM6llbW8f2Sdbw6fQV3fbqAZ6cs5ZK9B7DPoBxcLvVwFxEREREJJwq0i0SR1eW13Pv5Av43t4Qe6Qlcvs9ADh+RT+I2er9lJsVx4NA8Dhyax9J11Tz1fRHP/bCMD+cUc/0Bg9mlb1YX5UBERCR6TV5Qyq0fzWVDTQMnjuvFKTv1olvy1u8gy06J5+Bh+Rw8LJ9py9bzj0/nc9Xbs9mjfzduPMiQnhjXhakXEREREZHfoslQRaLE5/NKOOHZH/ly4VrO2a0Pr5y+E8eO6bnNIHtrhVlJ3DDJ8OTxo0iO93Dh6zN5fuoy/H5/J6VcREQkuvn9fh75ejGXvvEr2SnxPHfyGP6yV//fDLK3NqZXBs+ePJaLJ/bn28XrOP2F6SwqrerEVIuIiIiISHso0C4S4Rp8fv7vswVc/tYsemUm8uKp4zhz1z4keDv29R5VkMEzJ45h4sAc7v1iIbd+NI9Gn4LtIiIi7VHb4OP69+bw1HdFHDGiO8+eNIZBuanbtS+v28WJ43rx6LEjqaht4PQXpjFj+fogp1hERERERLaHAu0iEayqrpHL3/yVF39azrGje/Lk8aMpzEoK2v6T4z3cfthQztilkDd/WcUtH81VsF1ERKSN6ht9XPnWLD6cU8z5e/Tj2gMGEefp+OH3qIIMnj1pDNkp8Vz42i/8tKwsCKkVEREREZGOUKBdJEKVVdfzp//M4JtFa7ly34Fcvu9A4jvYi31L3C4X507ox9m79uGdX1dz60dzNYyMiIjINjQ0+rjmndl8vWgtV+8/iNN2LgzqBKbd0xN57NiR5KXF85fXflHPdhERERGREFOgXSQCra+u57xXfmZhaRV3HzmcY0b37PT3PGu3PvxxfG/e/nU1T3+/tNPfT0REJFL5/X5u+Wgun88v5bK9B3D0yB6d8j45qQk8euwo8tISuPSNXylaV90p7yMiIiIiItumQLtIhCmvaeD8V2eyeG0V/zhiGBP6Z3fZe5+zWx8mDc3jka8X8+nc4i57XxERkUjy1PdFvDtrDWfv1ofjxhZ06ntlp8Rz71EjcLlcXPT6TNZV1XXq+4mIiIiIyJYp0C4SQeobfVzx9izml1Ry5+HDGd+3W5e+v8vl4roDBrNDjzRueN+yqLSqS99fREQk3H1si3n06yUcNDSPM8f37pL3LMxK4u4jh7O6vJar35lNg+ZTERERERHpcgq0i0QIv9/PrR/PY2pRGdcdMJjd+3dtkL1JgtfNnYcPIzHOw3XvzqauwReSdIiIiISbhaWV/O0Dy8ie6Vx3wOCgjsm+LSN7pnP1/oP4cel6Hpy8qMveV0REREREHAq0i0SI535Yxru/ruasXXtzyPD8kKYlJzWB6w8czNziSh75enFI0yIiIhIOqusbuert2STFebjjsKGdMkH5thw6vDu/H92T539cxkdz1nT5+4uIiIiIxDIF2kUiwNSiMh7+ahH7Dc7lrF37hDo5AOw5IJvfjerBv6cu48elZaFOjoiISEjd+cl8FpdWcfMhQ8hNTQhZOi6e2J+RPdO57eN5LF+vyVFFRERERLqKAu0iYW5NeS3XvjubPlnJXH9g196Gvi0X7dWfgoxEbvt4HrUaQkZERGLUJ3OLeefX1Zwxvje79MkKaVriPG5uPngIANe/azVeu4iIiIhIF1GgXSSMNfr8XPfeHKrrG/n74cNIjveEOkmbSIzzcPV+gyhaV83T3xeFOjkiIiJdrrSyjts/nsfQ/NQum/x0W3pmJHL1foOYuXIDT323JNTJERERERGJCQq0i4Sxf09dxrRl67li34H0y04OdXK2aJe+WRw0NI9npyxlQUllqJMjIiLSZfx+P7d9PI/q+kZuPMjg9YTPofWBQ/M4eFgeT31XxJzV5aFOjoiIiIhI1AufswER2cSc1eU8+vVi9hucwyHDQjv56bZcPLE/KfEe7v5sAX6/blEXEZHY8LEtZvKCUs6d0I/+2SmhTs5mLt17AFnJ8dz0wVzqGzXEm4iIiIhIZ1KgXSQM1TX4+Ot7lqzkOK7ab1BYjcu+JVnJ8Zy5ax9+KCrj60VrQ50cERGRTrehpp67P1vA0PxUThhbEOrkbFF6YhxX7z+I+SWV/PM7DfEmIiIiItKZFGgXCUNPf1/EorVVXHfAYDKS4kKdnDY5ZlQPemclcd8XC9VrTkREot5DXy6mrLqea/cfjMcdvhfE9xyQzcHD8nhmylLma4g3EREREZFOo0C7SJhZUFLJM1OWMmloHrv16xbq5LSZ1+Pmwj37s3htNS/9sDTUyREREek0P6/YwOs/r+T4sQWY/NRQJ2ebLt5rAKnxHv7+v3n4NMSbiIiIiEinUKBdJIz4/H5u/WgeKfEeLpnYP9TJabc9B3RjXGEGD32+gOr6xlAnR0REJOh8fj//+HQ+uanxnLNb31Anp00yk+O4cM/+TF++gXd+WR3q5IiIiIiIRCUF2kXCyNu/rGLmyg1cPNGZvCzSuFwuzt29L6WVdbw6fUWokyMiIhJ0781azezVFZy/Rz+S4z2hTk6bHToin9EF6dw/eSFl1fWhTo6IiIiISNRRoF0kTJTXNPDQl4sZ1TOdg4flhTo5221UQQZ7DMzh2SlLqaxrCHVyREREgqayroEHv1zMiB5pTBoaWW212+Xiyv0GUVHbwBPfLAl1ckREREREoo4C7SJh4rFvnEnVLt9nIC5X+E6q1hZ/2Xcg62saePkn9WoXEZHo8dwPyyitrOPSvQfgjsC2emBOCkeO7MFrM1awsFQTo4qIiIiIBJMC7SJhYEFJJa9OX8HRo3pExKRq2zKqVyYT+nfj+R+XUVWnsdpFRCTyra2q48Ufl7Hf4FxG9EgPdXK22zm79SEp3sN9XywMdVJERERERKKKAu0iYeDBLxeRFO/hTxEyqVpbnLFLbzbUNPDfn1eGOikiIiId9uyUpdQ2+Dhn9z6hTkqHZCXH88fxffhm0Tq+Xbw21MkREREREYkaCrSLhNiPS8v4auFa/rBzbzKT40KdnKDZoWc64wozeP7HZdQ1+EKdHBERke22uryWV6ev4JBh+fTtlhzq5HTYcWN6UpiZyD2fL6TB5w91ckREREREooIC7SIh5Pf7eWDyIvJS4zluTM9QJyfoTtu5kOKKOj6YvSbUSREREdluT31XhM8PZ+4a2b3Zm8R53Fy4Z38WlVbpzjMRERERkSBRoF0khD6dV8Kvq8o5Z/e+JMZ5Qp2coBvfJwuTl8qzPyzF51ePORERiTzLyqp585dVHDWyBz0zEkOdnKDZa2A24wozeOzrxZTXNIQ6OSIiIiIiEU+BdpEQ8fn9PP7NEvp1S+aQYfmhTk6ncLlcnLpTL4rWVfPNIo0DKyIikeeJb5fgdbs4Y5fCUCclqFwuFxdPHMCGmgae+r4o1MkREREREYl43lAnQCRWfTq3hIWlVdx6yBA8bleok7NVc+bM4r77/sHcuZbc3DxOO+2PHHTQoVtdv7Kygvvuu5NPP/2Uuro6dhm/G90y9uLlaSuY0D8bgA8+eJfnn3+WlStX0K/fAM4++1x22ml8V2VJRESkTRaWVvL+rDWcvGMvclITQp2cNrniiouoqqriwQcf3+o6jY2NPPHEI7z//tskbajglSlDOLj/LQwq7LHZug0NDZx11qkMHDiYa6+9sRNTLiIiIiIS2dSjXSQEfH4/T3zr9Gbfd3BuqJOzVevWreOSSy5g8OAhPPXU8xxzzHHcccfNTJny3Va3uf76q/jqqy+55pobeOihJ6itqcb75UN8t6CYxWur+PjjD7j11hs54ICDeOqp55k06RCuvPJSfvppahfmTEREZNse+3oJyfEeTt0pMnqzv/HGa3zzzVfbXO+ppx7n/fff4brrbuKWfzyEv7qMS664bIvrPvnko8ybNzfYSRURERERiTrq0S4SApHSm/2dd94gJSWVv/zlMtxuN3369GXuXMuLL/6LnXfevAf6vHmWKVO+44knnmTo0NEAXH/9zRx19CHErZjGq9N788vzz7H//pM45ZTTAejduw/z58/l6aefYOzYHbs0fyIiIluzqLSKT+eVcMb43mQmx4U6Odu0bNlSHn/8YUaMGPmb69XX1/PKKy9x0UWXNd9Ntu8pl/LpfRfy6bdT2GfXnZvX/fnn6bz77lsMGDCwU9MuIiIiIhINFGgX6QITJuzIlVdex3vvvYW1c/AlZ9Nzj5Mpn7Wao695hoqKCnbddXeuvfZG4uPjAZgxYxqPPPIAc+dasrNz2Hff/Tn99LNISHBuXZ83by6PPfYgv/zyMzU1NfTo0ZNTTz2jeViX888/mxEjRlJcvJovv5yMx+Nh//0P5MILL8Xr9fLPfz7G008/scX0HnTQoVx77Y3MmDGN0aPH4HZvvPllzJhx3H33Hfj9flyuTS8SLF26FICxY8dRXd0IQHJyMr0LC1lXt5x3fl2NZ1kRRx75u022GzTI8MEH79LQ0IDXq58lERHpek1t9YcfvsusWb8Sl55DwshjSV+2gqOPPi9s22pwhoK55ZYbOOmkU1m6tIhly5ZuNZ/z5lmqqioZM2Zc87LzJ43j0ye68dz7k5sD7VVVVdxyyw1cdNHlvPXWfztcviIiIiIi0U4RLZEu8thjD3HVVddT4srgzjtuovKTR/h69Q784x/3UVS0hJtuuo7Ro8dy1FHHMG+e5ZJLzuePf/wT1113E6tXr+Lee+9i7dpSrrnmBqqrq7nkkvPZffc9ePzxZ/D74aWX/s2dd97KLrvsSrduzljoL7/8PKed9keefvp5Zs6cwW233cTw4Ttw4IEHc8IJp2wW8G6SkJAIQHHxGgYNMpu8lpOTQ01NDevXryczM3Oz1wBWr15FerozJE5jYyNr1qyhZ590ltQ1kpeWxZo1qzfZbtWqFdTX11NRUbHZPkVERLrKY489xC233AIJWZx35dXEf/sEP1aMDOu2GuBf/3oalwtOOOEU7rzz1t/MY3HxGgByc/Oal+WlJZCdk4NdvJRFpVX0y07m/vvvZujQYey77/4KtIuIiIiItIHGaBfpIocddiQTJuzJu0v9pAwaT01VBZdddhX9+w9k4sR9GThwMAsXLgDgxRf/za67TuDEE0+hV69Cxo3bicsvv4b33nubkpISamqqOe64E7noosvp3bsvffr05ZRTTqe+vp6lS4ua33PgwMH84Q9nUlDQi0mTDmHAgIH88stMwOlpnp2ds8VHamoqADU1Nc298prExTm9+OrqajfL49Chw+nTpy9/+9tNlJSUUFtbw2OPPUhZ2ToSPX6GdU+jsXAcr7/+H6ZOnUJjYyM//TSVd955C4CGhvrgF7yIiEgbHXbYkUycuDdfFnvxFY6jvroy7NvqOXMJVrPOAAAgAElEQVRm89JLz3PttTdtcgfa1tTU1OB2uze7g6wgKxWvv5HHv1nMV199wbfffs2ll14VrKIVEREREYl66tEu0kV69Spk+rL1TF++gYMHdeezqW569OjZ/HpCQgL19XUAzJ1r/5+9O42Psrz3P/6dzEwme0LWyULYEiCEsC/uIAqCRXCtCtZau9rttD09rfVorW31tLXnVFvb2s26i7soiKhUVNzYIUAChADZ94Tsy8zc/wcIf60oW5Jrls/79fIJM0k/jqF37t9cc12qqCjT3LnnHn3csixJ0sGD+zV16nRddtmVeuWVFR8+t/zoQWVer/fo12RnZ3+sITo65ugw++GHH9Ajj/zzmK3z5i3Qf/3XLXK5XOrt7f3YY0caIyIiP/F1TqdTd931W9155+269NL5cjqdmjt3vs4882w5HE7NnZyh26vO05ykMP3wh9+Vz+fTiBEjde21X9Bf/nKfoqNjTuzFBABgAGRlDVVbd5+e3VatvMwklRT697X6u9/9T/3ylz/VV796k7KyTuzAVpfLJZ/P94nt2iyfR6Mz3Hq98IC2vfM73frftysuLv6EvicAAAAABu3AoHE4HHpoQ7kSIp2akhWvtTbbJ/Y4P8LpdGjBgoVauvSLn3gsKSlZDQ31+vrXv6SUlFSdffa5Ouusc5WcnKKvfOUL//Z9wj/x9UeGAJdeeoXmzJl7zP/96OhoSVJqapoaGxs+9lhDQ4MiI6OOrqT7d8OGDddTTz2tgwer5HQ6FRUVrRtvXKrp08/QhaNTdO+bkfLkXqFXf3Kz2tpalZSUrKefXqbExCRFRn5yeA8AwGBxOBxatrFCHb1enTUiUfv8/Fq9a9cOHTiwX/ff/wfdf/8fJEm9vb2yLEtz556rRx55Wm63+2Nfl5qaJklqbGxQWtr/f6yhoUELzjhXJdt3q/VQs26//SdHHzvypvvatWv02mtvH7MHAAAACHUM2oFBUt/eq3UHmvS1M4fJ2dLwmc8dMWKUDhzY/7HVaTt2bNdjjz2kH/7wJ3rttdXq7OzUH//4N9ntdknSBx+8d1I9cXHxx12pNmHCJL388ksfO/h08+aNKiiYeMyPp3d0tOvHP/6Bbr/9dqWkZEqSqqurVFKyV9/61vcU7gjT8Oq1emdrt+rPv1mZSYf3dH/77bWaPn3mSfUDANDfPF5LD717QNOzE5QRfegzn+sP1+qoqCgtW/bx/dP/8pc/qqamWrff/sujZ6d8VE7OaEVFRWvr1s266KKLJR2+VldXV2nG1GnqGx6uv8dl6xeL8pWbcviN9zvvvF2JiUm66abvnlQ/AAAAEErYox0YJO8faJLTbtMVk9KP+9ylS7+oXbt26A9/+D8dPHhAW7Zs0i9/ebva2tqUlJSs1NQ0dXZ2aO3af6mmplrr1r2pu+++S5I+sdXL6Vi4cLFaWpp199136cCB/XrmmWV67bVXtHTp9Uef09p6SK2th4cR0dEx8nq9+vWv/0f795dq164d+tGPvqepU6dr6tTpkqTzCnJk371G9z31siorK3TPPXerqGiXvvjFG/utGwCAU7G9ulW1bT26fnrWcZ/rD9dqlytCWVlDP/ZPdHS0XC6XsrKGHt0a5qPX6vDwcF122ZX64x/v1fvvv6vdu4t1++23aNKkKRo/vkBLzxiluOR0rTjoPfo9w8MjFBUVfcLb0wAAAAChiBXtwCDZWtmq+fNSlRj1yY+I/7tRo3J099336m9/+7Oef/4ZRUfH6Oyzz9U3v/kfkqQ5cy5UUdFO3XPP3erq6lRm5lDdcMNX9OijD6q4eJfOOOOsfmlOTEzSb3/7B91779268calSktz69Zb7zg6NJekW275L0nSfff9VZJ0xx136b77/lff+MaX5HJFaNasObrppu8cff7Sq67SSxv3at3Tf9aGp+5R3thx+v3v/6zs7OH90gwAwKl6p7RJY8eN1cxhQ7Rq12c/11+u1Sfi36/VX/3qTfJ4PPrFL26Tx+PRzJln6Qc/+LEkKcbl0DVTMvXXdw9qd127xqRyfgoAAABwImxH9oDsD/X1baf9zRISotTS0tkfOSGL1/D0DMTr9/D6cv3h7f16/Popyk0J/hvW472Gb+1r1H++sFO/XTxOs3I++bF28Pe4P4TSa5iSEnvsTaRPUH9cv09FKP03Gmi8lqdvXWmjvv/8Tv32ygmaNSzBdI5Rbd0eXfK3DzRz2BD9etG4U/4+/Fz2L17P/uMvr+XpXr8BAIB/YesYYIB5fJae2lqladkJITFkPxFnjUhUcnS4lhfWmE4BAECS9NSWKiVHh+vi8e7jPznIxUY4dPWUTP1rb4NKGjpM5wAAAAABgUE7MMDe3teo2rYeXTM5w3SK33CE2XTJ+DS9s79JdW09pnMAACGuvLlL7x1o1uUT0uW08+uxJF07JVNRTrv++X6Z6RQAAAAgIHAnAQywZ7ZWKS3WpXNGJplO8SuLxrvls6SVu2pNpwAAQtwz26pkD7PpsgmsZj8iIdKpKydl6LXd9TrQaH6LDQAAAMDfMWgHBtDBpk6tL2vR5RPSZQ9jC8aPykqI1LSh8VpeWCNfP54VAQDAyeju8+qlHbWak5us5BiX6Ry/snRapsIdYfrnela1AwAAAMfDoB0YQM9tr5YjzKZFBayQO5bFBemqPNStzeWHTKcAAELUK0V1auvx6POT2OLt3yVGheuKielaXVSn8uYu0zkAAACAX2PQDgyQ7j6vVuys1fm5yUqODjed45dm5yQp1uXQC4XVplMAACHIsg4fWJ6bEq2JmXGmc/zSF6ZlyR5m0yMby02nAAAAAH6NQTswQNbsaVBrt0dXTEw3neK3Ipx2LchL1Rt7G9Ta3Wc6BwAQYrZXtWpvfYeunJQhm40t3o4lOcalz+WnaeXOWjV09JrOAQAAAPwWg3ZggCwvrFb2kEhNyYo3neLXFhW41eu19EpRnekUAECIeXprlWJch9/0xae7btpQ9XktLdtcaToFAAAA8FsM2oEBcLCpU1sqW7VovJsVcscxJjVGeWkxeqGwxnQKACCENHT0as2eBl2S71ak0246x69lD4nUnNHJenZbldp7PKZzAAAAAL/EoB0YAC/uqJHdJn0uP810SkBYmJ+mvfUd2lvfbjoFABAiXtheLY/P0pUcgnpCrp8+VO09Xj2/nXNVAAAAgGNh0A70M4/XpxU7a3XuqCQOQT1B88akyh5m08u72D4GADDwvD5LywtrNHNYgrKHRJrOCQjj3LGalp2gxzdVqtfjM50DAAAA+B0G7UA/W1fapKbOPi0a7zadEjASopw6e0SiVhfXyeuzTOcAAILcxrIW1bT1aHEBB5afjC9Oz1JDR69WFdWaTgEAAAD8DoN2oJ+t3FWrxCinzhyRaDoloFw8LlX17b3aWNZiOgUAEORe3FGj+AiHZo1KMp0SUGYOG6IxqTF6ZEOFfBZvjAMAAAAfxaAd6EeHuvr0zv4mzc9LlSOMQ1BPxjkjkxTjsmvlLlbJAQAGzqGuPq0tadD8vFSFO/hV+GTYbDZdPz1LB5u79GZJo+kcAAAAwK9wdwH0ozV7G9TntbQgL9V0SsBxOcI0d0yK3tjboM5er+kcAECQWl1cp16vxRZvp2jO6BRlxkfo4Q3lsljVDgAAABzFoB3oR6t21WpEYpTGpMaYTglIF+elqdvj09qSBtMpAIAg9eKOWo1NjdFortWnxBFm03XTsrSjuk2bKw6ZzgEAAAD8BoN2oJ9UHurS1spWLRiXKpuNbWNOxcTMOGXER+hlto8BAAyA3bXt2l3XrktYzX5aFuanKTHKqYc3lJtOAQAAAPwGg3agn6wuqpckzWfbmFNms9l0cV6q1h9sUV1bj+kcAECQeXFHjcLtNs3PSzGdEtAinHZdPTlT7+5v1t76dtM5AAAAgF9g0A70A8uy9PKuWk3Oild6XITpnIC2YFyaLB3eQxcAgP7S4/HpleI6nZ+brLgIp+mcgHflpHRFOe16eEOF6RQAAADALzBoB/pBUW27DjZ36WJWs5+27CGRKkiP1cpdtRyyBgDoN2+WNKi128MhqP0kLsKpSye49VpxnWpau03nAAAAAMYxaAf6wcu7auW023TBaD6K3h8WjEvTvoZO7anvMJ0CAAgSL+6oUXqcS9OyE0ynBI1rp2RKkp7cUmW4BAAAADCPQTtwmjxen14trte5I5MUG+EwnRMU5o5JkSPMxqGoAIB+Ud3arfUHW3RJvlthHFjeb9xxEbpgdIqe316tjl6P6RwAAADAKAbtwGn6oKxFzV19ungc28b0l4RIp84ZmajVxfXy+Ng+BgBwelbsOPzG7cLxaYZLgs+SaVnq6PVqeWGN6RQAAADAKAbtwGlatatW8REOnTUi0XRKUFkwLk2NHb1af7DZdAoAIID5LEsv7azRjGEJHFg+APLdsZqcGacnN1fy5jgAAABCGoN24DR093n1Zkmj5oxOltPOX6f+dM6IRMVFONg+BgBwWjaUtai6tYdDUAfQkqlZqmrt0ZslDaZTAAAAAGOYDAKn4d39Ter2+DR3DIeg9rdwR5jmjknR2pJG9n0FAJyyl3bUKC7CoVk5yaZTgta5o5KUlRChxzZWmE4BAAAAjGHQDpyG13Y3aEikU5OzEkynBKUFeanq8fj0rz2skAMAnLzW7j69sbdB88emyuXg196BYg+z6dopWSqsbtP2qlbTOQAAAIAR3HEAp6i7z6t1pYe3jXGE2UznBKUJGXHKjI/QK0V1plMAAAHolaJ69Xotto0ZBJeMT1NchINV7QAAAAhZDNqBU/TOh9vGXDCaj6IPFJvNpgV5qdpQ1qL69h7TOQCAAPPSjhqNSY3RmLQY0ylBL9Jp12UT0rW2pEEVLV2mcwAAAIBBx6AdOEWv725QYhTbxgy0+XmpsiStLq43nQIACCC769pVXNeuRePTTKeEjKsnZyjMZtOTW6pMpwAAAACDjkE7cAqObBtzfi7bxgy0YYlRynfHatWuWtMpAIAA8tKOGoXbbbpobKrplJCREuPSvLEperGwRm3dHGQOAACA0MKgHTgFR7aNuXB0iumUkLAgL1V76jtU0tBhOgUAEAB6PD6tKqrT7JxkxUc6TeeElCVTs9TZ59ULhdWmUwAAAIBBxaAdOAWv767/cNuYeNMpIWHu2BTZbeJQVADACXlrX6Nauz0cgmrAmNQYTctO0LLNlerz+kznAAAAAIOGQTtwkrr6vFpX2qTzc5NlZ9uYQZEYFa4zhifqlaI6+SzLdA4AwM+9WFgjd6xL04dxjooJS6dmqq69V6t21JhOAQAAAAYNg3bgJL1TyrYxJizIS1VtW4+2VBwynQIA8GM1rd364GCzLhmfpjAbb4ibcNaIRA0bEqkH3j0gizfIAQAAECIYtAMnac0eto0xYVZOkqKcdq1i+xgAwGdYsbNWlqSF+WwbY0qYzaYl07K0s6pVm3mDHAAAACGCQTtwErr6vHqbbWOMiHDadX5uktbsqVePhz1fAQCf5LMsvbSjRtOzE5QRH2E6J6RdnJeqIVFOPb6p0nQKAAAAMCgYtAMn4b39Teph2xhjFuSlqb3Hq3dKG02nAAD80KbyFlW19mgxh6AaF+G0a8mMbL29r1EHmzpN5wAAAAADjkE7cBLeKGlUfIRDk9g2xohp2QlKig5n+xgAwDEtL6xRrMuhWTlJplMg6bqZ2XLYbXpiM6vaAQAAEPwYtAMnqM/r07rSRp07KkkOto0xwh5m00VjU7SutEmHuvpM5wAA/Ehrd5/e2Nugi8amKMJpN50DSckxLi3IS9WKnbVq4boNAACAIMegHThBm8pb1N7j1eycZNMpIe3ivDR5fJbW7Kk3nQIA8COvFter12tpcQHbxviTa6dkqcfj0/Pbq02nAAAAAAOKQTtwgtaWNCrSGaaZwxJMp4S00anRGpEUxfYxAICPeXFHjXJTojUmNcZ0Cj4iJyVaM4cl6OmtVerzcpg5AAAAgheDduAE+CxLb5Y06szhiXwc3TCbzaYFeanaWtmqykNdpnMAAH5gT127imrbtWi8WzYb27v5m2unZqm+vVev7ebTaAAAAAheDNqBE7Cjuk0NHb2ancvhav5gfl6qJGl1ETfsAADppZ21ctptR68P8C9nDh+iEYlRemJTpSzLMp0DAAAADAgG7cAJWLu3QfYwm84ZwaDdH6THRWhyVrxWFdVyww4AIa7X49OqXbWaNSpZCZFO0zk4hjCbTddMzVRxXbs2VxwynQMAAAAMCAbtwHFYlqW1JQ2aPjRBsREO0zn40IK8VB1o6lJxXbvpFACAQW/ta9Shbo8WFaSZTsFnuDgvVfERDj2xqdJ0CgAAADAgGLQDx7GvsVPlLd1sG+NnLhidLKfdplW7OBQVAELZiztqlBbr0ozsIaZT8BkinHZdMSlDb+1rVHkzZ6wAAAAg+DBoB45j7d4G2STNGsWg3Z/ERTh1zsgkrS6uk8fH9jEAEIpqWrv1/oFmLcxPkz2MQ1D93VUT02UPs2nZZla1AwAAIPgwaAeOY21Jo8anxyk5xmU6Bf9mQV6qmjr7tKGs2XQKAMCAlbtqZUlamM+2MYEgOcali/JS9dLOGrV295nOAQAAAPoVg3bgM1Qd6tbuunbNzmE1uz86e0SiYl0Oto8BgBDksyy9tKNW07ITlJUQaToHJ2jJlEx19fn0wvYa0ykAAABAv2LQDnyGtSUNkqTZucmGS3As4Y4wXTgmWW/sbVBnr9d0DgBgEG0qb1HloW4tGs9q9kAyOjVG07IT9OSWSnm8PtM5AAAAQL9h0A58hrUljRqZFKXsIayU81cL8tLU7fHpzX0NplMAAINoeWGN4iIcmpObYjoFJ2nJlEzVtfdqzR6u3QAAAAgeDNqBT9Hc2attlYdYze7nJmbGKT3OxfYxABBCWrr69K+9DVqQlyqXg19nA83ZIxOVPSRSj2+ulGVxoDkAAACCA3cmwKd4e1+TfJZ0Pvuz+7Uwm03z81L1wcFmNXb0ms4BAAyCVUV16vNaWlzgNp2CUxBms+naKZnaVdOm7VWtpnMAAACAfsGgHfgUb5Q0KD3OpTGpMaZTcBzz81Lls6RXd9ebTgEADDDLsvTC9mrlu2OVm8I1OlB9Lj9NcREOPbap0nQKAAAA0C8YtAPH0NHr0fqDzZqVkyybzWY6B8cxMilaY1NjtGpXrekUAMAA21HdptLGTlazB7hIp12XT0jXmyUNqmjpMp0DAAAAnDYG7cAxvLe/Wb1eS7PZNiZgLBiXqqLadh1o7DSdAgAYQC8UVivSGaZ5YzkENdBdNSlDNptNT26pMp0CAAAAnDYG7cAxrC1pUEKkU5My402n4ATNG5OiMJv0chGr2gEgWLX3ePRqcb3mjUlVdLjDdA5OU2qsS/PGpOjFwhq193hM5wAAAACnhUE78G96PD6tK23SeaMSZQ9j25hAkRzj0pnDE7VyZ628Pst0DgBgALy2u17dHp8uncC2McFiydRMdfZ59UJhjekUAAAA4LQwaAf+zfuljero9Wp2TrLpFJykhflpqmvv1cbyFtMpAIAB8EJhjUYlRynfHWs6Bf1kbFqsJmfF68nNlfLwRjkAAAACGIN24N+8VlSrKKddM4YNMZ2Ck3TuqCTFRTi0YifbxwBAsNlT165dNW26tCCdg8qDzNKpmapp69HavQ2mUwAAAIBTxqAd+Aivz9LrRXU6a0SiXA7+egQalyNM88ak6I29Dez1CgBB5vnt1Qq327QgL9V0CvrZOSOTlJUQocc3VZhOAQAAAE4Zk0TgIwqrWtXY0avzc5NMp+AULcxPU4/Hp9d315tOAQD0k85er1YV1enCMSmKj3SazkE/s4fZdO2UTBVWt2l7VavpHAAAAOCUMGgHPuKNkgY57TadNSLRdApO0Th3rEYkRrF9DAAEkVeK69TR69UVEzNMp2CALMx3K9bl0BOsagcAAECAYtAOfMiyLK0tadRZI5MU43KYzsEpstlsWpifpm1VrSpr7jKdAwA4TZZl6dmtVcpNiVZBOoegBquocLsum+DWv/Y2qLq123QOAAAAcNIYtAMf2lPfoapD3Zo7Ls10Ck7TgnGpCrNJK3fWmE4BAJymnTVt2lPfoSsmcghqsLtqUoZskp7cXGU6BQAAADhpDNqBD63d2yCbpAvHcshaoEuJcemM4UO0YmetvD7LdA4A4DQ8s61aUU675nMIatBzx0XogtEpeqGwWh29HGoOAACAwMKgHfjQ2pJGTcqMU1KMy3QK+sHCfLfq2nu1sbzFdAoA4BQd6urT67vrtWBcqqLD2dYtFCyZmqmOXq9e3MFZKwAAAAgsDNoBSRUtXSpp6NDs3GTTKegn541KUqzLwaGoABDAVu6qVY/HpysmpptOwSDJT4/TxIw4LdtcyafSAAAAEFAYtAOS3tjbIEmancOgPVi4HGGaNzZFb+xtUHsPHz8HgEBjWZae3VatCRlxyk2JMZ2DQbRkWpaqDnXrzX2NplMAAACAE8agHZD0xt5GjUmNUUZ8hOkU9KNL8tPU4/Hp9d31plMAACdpY3mLypq7WM0egmaNSlJGfIQe31hhOgUAAAA4YQzaEfIa2ntUWN2q2TlJplPQz8a5YzUiMYrtYwAgAD27rVrxEQ5dMDrFdAoGmT3MpmumZGpbVat21rSZzgEAAABOCIN2hLwjH0tmf/bgY7PZ9Ln8NG2ralVZc5fpHADACapt69HavQ26ZLxbLge/roaiRePTFB1u1xObWNUOAACAwMCdC0Le2r2NGpoQoVFJUaZTMAAW5KUqzCat3FljOgUAcIKe21YlnyVdOYltY0JVdLhDiwvcen13vWpau03nAAAAAMfFoB0hra3bow3lLTo/N1k2m810DgZAaqxLM4cN0YqdtfL6LNM5AIDj6PH49Nz2Gp03KkmZ8ZGmc2DQNVMyZUl6emuV6RQAAADguBi0I6S9Xdoor8/S7By2jQlmi8a7Vdfeqw8ONptOAQAcx2u769TS1afPT84wnQLD0uMiNCc3Wc9tr1Znr9d0DgAAAPCZGLQjpK0taVRydLjy02NNp2AAnTcqSQmRTi0vZPsYAPBnlmXpyc1VGpEUpenZCaZz4AeWTM1Se49XK9gCDgAAAH6OQTtCVnefV+/tb9KsnCSFsW1MUAt3hOnical6c1+jmjp7TecAAD7F9qpWFde16+rJGWzpBklSQUacCtJj9cTmSraAAwAAgF9j0I6Q9cHBZnV7fDo/l21jQsHiAre8Pksrd9aaTgEAfIont1QpxmXXgrw00ynwI0umZqmipVvrShtNpwAAAACfikE7QtbrexoUH+HQ1Kx40ykYBCOTojUhI07LC2tkWayIAwB/U9/eo3/tbdCi8W5FhdtN58CPzM5NVnqcS49vqjSdAgAAAHwqBu0IST0en97e16hZOUly2PlrECouLXDrYHOXtla2mk4BAPybZ7dVy+ezdNUkDkHFxznCbLp6cqY2VxxScW2b6RwAAADgmJgwIiR9cLBZHb1eXTA6xXQKBtGFY1IUHW7X8sJq0ykAgI/o9fj0/PZqnT0yUVkJkaZz4IcWF7gV5bSzqh0AAAB+i0E7QtKaPfWKi3BoRnaC6RQMokinXReNTdXrexrU1u0xnQMA+NDq4jo1dfbpmsmZplPgp2JcDi0qcOvV3fWqa+sxnQMAAAB8AoN2hJxej09vljRq1ii2jQlFiwvc6vH49EpxnekUAIAky7L02KYK5SRHa8Yw3gDHp7t6coYsy9LTW6tMpwAAAACfwJQRIefotjFj2DYmFOWlxWh0SrSWF9aYTgEASHr/YLP2NXRq6bRM2Ww20znwY1kJkZqVk6zntlerq89rOgcAAAD4GAbtCDlr9tQr1sW2MaHKZrNpcUG6dte1c6AaAPiBRzdUKCUmXBeNTTWdggCwdGqmWrs9Wrmz1nQKAAAA8DEM2hFSej0+vbmvUeflJMnJtjEha35eilyOML3AqnYAMGpPXbvWl7Xo6smZXJdxQiZkxGmcO1ZPbK6Uz7JM5wAAAABHcUeDkLKhrEXtPV5dODrZdAoMiotwak5usl4pqlM3Hz0HAGMe21ShSGeYLpvgNp2CAGGz2bR0aqbKmrv0TmmT6RwAAADgKAbtCCmv76lXjMuumcOGmE6BYYsL3Oro9er1PfWmUwAgJNW29Wh1cb0WF6QrLsJpOgcBZE5uslJjwvX45krTKQAAAMBRDNoRMvq8Pr1Z0qhZo9g2BtKUrHhlD4nkUFQAMOSpLZWyLEvXTMkwnYIA47CH6erJmdpY1qLdde2mcwAAAABJDNoRQtaXtaitx6MLRqeYToEfsNlsWjzera2VrTrQ2Gk6BwBCSkevR89tr9ac3BRlxkeazkEAunSCW5HOMD3BqnYAAAD4CQbtCBlrdtcrOpxtY/D/fS4/TfYwm54vrDadAgAhZXlhjdp7vLpuepbpFASouAinLsl3a3VRnRrae0znAAAAAAzaERp6PT69UdKg2TlJCnfwY4/DkqLDNWtUklburFWPx2c6BwBCgsdnadnmSk3OjFO+O9Z0DgLYNVMy5fVZenobb5gDAADAPCaOCAnvHWhSe49X88ammk6Bn7liYroOdXu0hkNRAWBQ/GtPvapbe7R02lDTKQhwQ4dE6rxRSXp2a5W6+7ymcwAAABDiGLQjJLxSVK8hkU7NyE4wnQI/Mz07QdlDIvUsq+EAYMBZlqXHNlUqe0ikzh2VaDoHQWDJtEwd6vbo5aI60ykAAAAIcQzaEfQ6ej16u7RRF4xOlsPOjzw+zmaz6fIJ6dpe1aq99e2mcwAgqG2pPKRdNW1aOjVTYTab6RwEgcmZ8RqbGqNlmyrlsyzTOQAAAAhhTB0R9N4saVSPx6f5eWwbg2NbmJ+mcLuNVe0AMMAe3VChhEinLh6XZjoFQcJms+naqZna39Sp9w40m84BAABACGPQjqD3anG93LEuFWTEmU6Bn6cvUoMAACAASURBVIqPdGrumBSt2lWnjl6P6RwACEr7Gjr0dmmTPj8pQxFOu+kcBJG5Y1KUEhOuJzZVmE4BAABACGPQjqDW0tmn9w82a97YVD6ijs90xcQMdfZ5tZo9XgFgQDy8oVyRzjBdNTnDdAqCjNMepqsmZeiDgy1sAwcAAABjGLQjqK3ZWy+vz9JFY1NMp8DPjU+PVW5KtJ7ZVi2LPV4BoF9Vt3ZrdVGdLpuQroRIp+kcBKHLJ6Qr0hmmxzayqh0AAABmMGhHUFtdVKcRSVHKTYk2nQI/Z7PZdOXEdO2t79CO6jbTOQAQVB7dUCGbzaYlU7NMpyBIxUc6tWi8W68U16u2rcd0DgAAAEIQg3YErZrWbm2pbNVFY1NkY9sYnICL8lIVHW7Xs9uqTKcAQNBo6uzV8h01unhcqtJiXaZzEMSWTM2SZVl6akul6RQAAACEIAbtCFqv7a6XJF00NtVwCQJFdLhD8/NS9drueh3q6jOdAwBB4cnNler1+PSF6UNNpyDIZcRH6ILRKXp2W7XaezjcHAAAAIOLQTuC1urieuW7Y5WVEGk6BQHkionp6vVaWrGz1nQKAAS89h6Pnt5arfNzkzU8Mcp0DkLAddOy1NHr1Ys7akynAAAAIMQwaEdQKm3s0O66ds3jEFScpNyUGE3IiNNz2zkUFQBO1/Pbq9XW49EXZ7CaHYNjnDtWU7Li9fimSnm8PtM5AAAACCEM2hGUVu6sld3GtjE4NVdMTFdZc5c2lLWYTgGAgNXj8emxTZWakZ2gce5Y0zkIIddNy1JtW49e39NgOgUAAAAhhEE7go7XZ2lVUZ3OGpGopOhw0zkIQBeMTlF8hEPPba82nQIAAWvlrlo1dvSymh2D7uyRiRqRGKVHN1bw6TQAAAAMGgbtCDofHGxWfXuvFuanmU5BgHI5wnTJeLfWljSqvr3HdA4ABByvz9IjG8qVlxaj6dkJpnMQYsJsNi2dlqndde3aWM6n0wAAADA4GLQj6KzcWav4CIfOGZlkOgUB7IqJ6fL5LD3PqnYAOGlr9tSroqVbN8zMls1mM52DEDQ/L02JUU49urHCdAoAAABCBIN2BJW2bo/WljRo3thUhTv48capy0qI1NkjE/Xc9hr1cZgaAJwwy7L00PpyDRsSqdk5vOkNM1yOMF09OVPv7m9WSUOH6RwAAACEACaRCCqv7alXr9di2xj0i6smZaixo1dv7OUwNQA4Ue8daNae+g5dP2OowljNDoMun5iuCEeYHmNVOwAAAAYBg3YElRU7ajUiKUp5aTGmUxAEzhg+REMTIvTklirTKQAQECzL0gPvlyk1JlwL8lJN5yDEJUQ6tbjArVeK6jhzBQAAAAOOQTuCxsGmThVWt+qS/DT2g0W/CLPZdOWkDG2valVxbZvpHADwe5srDmlbVau+OGOonHZ+zYR510zJlM+yeNMcAAAAA447IASNlbtqFWYTK+jQry7JdyvSGaant3KDDgDH88D7ZUqMcmrReLfpFEDS4TNX5uQm67lt1ero9ZjOAQAAQBBj0I6g4PVZWrmzVmcMH6LkGJfpHASR2AiHLh6XptXF9Wrp6jOdAwB+q7CqVevLWnTdtCxFOO2mc4Cjlk7LUluPR8sLa0ynAAAAIIgxaEdQ2Fjeorr2Xn1uHIegov9dOSlDPR6fXuQGHQA+1QMflCk+wqErJmaYTgE+Znx6nCZnxumJTZXy+CzTOQAAAAhSDNoRFF7aUaNYl0OzcpJNpyAI5SRHa9rQeD2zrUpebtAB4BN217VrXWmTrp2aqahwVrPD/1w3fahq2nr0rz31plMAAAAQpBi0I+C1dPXpX3sbtCAvVS4HP9IYGFdNzlR1a4/WlTaaTgEAv/PgB2WKDrfr85MyTacAx3TOyEQNGxKpRzZUyLJ40xwAAAD9j6kkAt6qojr1eS1dOoGD1zBwzhuVpNSYcD21hUNRAeCj9jd2as2eBl09OUOxEQ7TOcAxhdlsWjotS8V17dpccch0DgAAAIIQg3YENMuy9ML2ao1zxyo3JcZ0DoKYI8ymKydlaH1Zi/Y3dprOAQC/8eD6MrkcYbp2SpbpFOAzXTwuTYlRTj2yocJ0CgAAAIIQy44Q0Aqr21Ta2Klb5uaaTjlhHR3t+tOffq91695Sb2+vzjzzbH3nO9/XkCGJR5/z1a9er6KiXR/7uoULF+vmm2+TJD3yyINatuwRuVwR+uY3v6sLL7zo6POefPIx7d9fevS5n+bOO3+muro63Xvvnz7x2K9+9QtVVJTrvvv+Kkm68spLVFNTffTxsLAwRUVFKT9/gr7xjW8rN3f0MZ/ndDqVnJyqWbPO1403flVRUdEn+jL5pUsL3Prbewf19NYq/eiCHNM5AGBcRUuXVhfV6ZopWUqIcprOGVBcvwOfyxGmqyZl6C/vHtS+hg6NSg6Ofy8AAAD4BwbtCGjLC6sV6QzTvLEpplNO2G233ayDBw/olltuV0pKqv72tz/pO9/5hh544FGFh4fLsizt31+qn/70l5o6ddrRr4uIiJAklZbu08MPP6Df/e4+tbS06Gc/u0UzZpypuLg4dXS0a9myx3T//Q/0e/fSpV/U5z9/raTDnyRobGzUPff8Rt///rf01FMvHL0JX7r0i/rqV2/UoUNd6u7uVnHxLt133z3auXO7fv/7v8jpDNxBzJCocM0bk6KVO2v1zXOGK8bF/4UCCG0PrS+XPcym66YF/97soXD9PvK8YLt+f9SVkzL04PpyPb6pQrddNMZ0DgAAAIIIW8cgYLX3ePRqcb3mjUlVdHhgDDz37t2t9evf180336aZM8/UyJGjdNttv1BDQ73WrHlVklRVVanu7m6NH1+gpKTko/9ERx/eGmf//lKNHDlK48dP0DnnnKeoqGhVVpZLkh5//BHNmXOh0tL6f7/6yMjIoy3JySkaM2asvvWt76mlpVmbNm342POSk1OUlJSszMwsXXDBPP3qV/+nHTsKtXLl8n7vGmxXTc5UZ59XL++qNZ0CAEbVtHZrxc5aLRrvVnKMy3TOgAqV6/eR5wXj9fuIhEinFo13a1VRnerbe0znAAAAIIgwaEfAerW4Tt0eX0AdglpefviGesKESUf/LCoqSkOHDtWWLZskSaWlJXK5XHK704/5PTIyMlRRUaampkbt31+q9vY2paamqampUStWvKAvfOHGgf8X+ZDdbpckOZ3hn/m8MWPGasKESXr99VcHI2tA5btjNT49Vk9uqZLPskznAIAxj26skCXp+hlDTacMOK7fgX/9/qil0zLl81l6fFOl6RQAAAAEEQbtCFgvFNYoJzla+e5Y0yknLDk5WZJUX1939M+8Xq/q6urU0tIs6fBHy2NiYnXHHbdq8eL5uv76q7Vs2aPy+XySpLy8fJ1//oW69NIF+tKXlujLX/66kpKS9c9//l2LFl2uhISEQfl3qays0P3336ekpGQVFEw47vNHjsxRaem+QSgbeNdOyVRZc5fWlTaZTgEAIxrae/RCYY0uzktVelyE6ZwBx/U7OK7fR2TGR+rCMSl6blu1Wrv7TOcAAAAgSATGfhvAv9ld166i2nb98PxRstlspnNOWF5evoYNG6677/4f3XbbzxUbG6N//OMvamlpVl/f4Ru9/ftL1dXVpZkzz9T119+owsKt+uMff6+Ojg59+ctflyT98Ic/0de//m05HA5FRkaqsrJCb731hp544lmtWLFcjzzyT8XFxenHP75NOTmfflDs1q2bNHfuuZ/4897eXhUUTPzYnz300D/02GMPSZI8Ho88Ho9yc8fozjvvPvqx+M8SGxurjo72E36t/Nmc0SlKe2u/Ht9UofNGJZnOAYBB9+D6cnm8Pt14RrbplEHB9Ts4rt8fdcOMbK0urtfTW6v05TOGmc4BAABAEGDQjoD0wvZqhdttmp+XajrlpDidTt1112/185/fpksvnS+n06m5c+frzDPPlsNx+JCxW2+9Q11dXYqNPbxSf9SoHLW3t+vhh/+pG2/82tE3Fo48Lkl//eufdO2116mzs1P33fc7PfjgMu3cWahf/OKneuihJz61Z9y4fP33f9/xiT//y1/+qObmj6/Wvvzyq3TZZVdJOvyR8/j4+KMHqJ2Izs6OjzUHMkeYTVdPztDv39qv3bXtGpN2/EEFAASLurYePb+9Wgvz3cpKiDSdMyi4fgfH9fujclKidc7IRC3bXKWlU7MU4bSbTgIAAECAY9COgNPV59UrxXWaMzpF8ZFO0zknbdiw4frHPx7RoUMtcjqdioqK1o03LtX06WdIkhwOxyduaEeNylFnZ4fa29s/8diePcXasWO7brnldr3//rsaOnSY3G63hgxJ0O23/0QdHe2fumItPDxCWVmf3Fs3Ojr6EzfqsbFxx3zuidq9u1i5uWNO+ev9zaUF6fr7e2V6fHOF7lgw1nQOAAyaB9eXy2spZFazH8H1O/jcMGOovrJsm5YX1ujqKZmmcwAAABDg2KMdAWdVUZ3ae7y6cuKxDxvzZx0d7fr2t7+m0tISxccnKCoqWtXVVSop2asZMw7fqH/tazfonnt++7GvKy4uUnJyyjFXlN1//3264YavyOVyyWazyfrwgE6PxyNJ8vnMH9i5d+8e7dixXfPmLTCd0m9iIxxaVODW6uJ61bX1mM4BgEFR09qtFwqrtWh8mjLig39v9iO4fgfP9fujJmbGa3JmnB7dWCGP12c6BwAAAAGOQTsCimVZemZrlXJTojUhI850zkmLjo6R1+vVvff+n/bvL9WuXTv0ox99T1OnTtfUqdMlSbNmna8XX3xOq1atUGVlhVaseEGPPfbQ0f1dP2rTpg2qrq7SggULJUmjR4/V/v37tHnzRj3//DMaPnzEoH/cu6urSw0N9WpsbFBlZYVef321br75B5o4cXLQ3ahfPTlDlmXp6a1VplMAYFA8uL5cliXdODO0VrOHyvW7sbEhJK7fH/XFGdmqaevRK8V1x38yAAAA8BnYOgYBZXtVq/bWd+iWubkBdQjqR91xx1363e9+o29840tyuSI0a9Yc3XTTd44+vmTJ9bLb7XrooQdUV1ej1FS3vvOdH+iSSy79xPe6//4/6Ctf+YYcjsN/ld1ut775ze/qpz+9WfHxCbr11k/u3zrQHnvsoaOHrkVFRcvtdmvRost09dVLZbcH1/6nWQmRmpWTrOe2V+vGM7IVyf6uAIJYdWu3lhfWaHGBW+640FnNfgTX7+B01oghyk2J1sPrK3TxuDSFBejvlwAAADDPduRjqv2hvr7ttL9ZQkKUWlo6+yMnZAXza3jryiK9s79JL3/9jAEbagbz6zdYQuk13FZ5SF9Ztk0/uiBHV03K6LfvG0qv4UAJpdcwJSX2tCZD/XH9PhWh9N9ooA3Ga3nXa3u0YmetnrtxelAP2vm57D+B8lquLqrTrS8X6+5F4zQ7N9l0zqcKlNczEPjLa3m6128AAOBf2DoGAaOxo1dr9jRoYb6blcPwGxMy4pTvjtWyzZXy9eMblwDgT6oOdevFHbW6tCA9qIfsCE0XjElRZnzEh1sjcS0HAADAqWHQjoCxvLBGHp+lKwLwEFQEL5vNpiVTM1XW3KU3SxpN5wDAgPjrewdlt0k3zBhqOgXod44wm66fnqWdNW3aVH7IdA4AAAACFIN2BASPz9Kz26o0IztBwxOjTOcAHzNndIqyElgJByA4lTZ2aNWuWl01KVOpsS7TOcCA+Fy+W0nR4XpofbnpFAAAAAQoBu0ICG/va1Rde2+/7oEN9BdHmE1fmJalXTVt2ljeYjoHAPrVn9cdUKTTzmp2BDWXI0xLpmTq/YPNKqptM50DAACAAMSgHQHhma1VSot16ZxRSaZTgGM6shLuwQ9YCQcgeOysbtXakkYtnZalhCin6RxgQF0+MV0xLrseeL/MdAoAAAACEIN2+L0DTZ1aX9aiyyekyxFmM50DHNORlXDry1q0q4aVcACCwx/XHdCQSKeWTM00nQIMuBiXQ9dOydTakkbtqWs3nQMAAIAAw6Adfm/Z5ko57TYtLnCbTgE+05GVcA9vYFU7gMC3/mCzNpS16IaZQxUd7jCdAwyKa6dkKcZl199Z1Q4AAICTxKAdfq2lq08rdtZqQV6qkqLDTecAnynG5dBVkzL0rz0NOtDUaToHAE6ZZVn607oDSot16YqJnI+C0BEbcXhV+xt7G1jVDgAAgJPCoB1+7fnt1erx+HTt1CzTKcAJuXpypsIdYXp0Q4XpFAA4ZWtLGrWzpk1fO3OYXA5+XURoYVU7AAAATgV3TvBbfV6fntpSpZnDEpSTHG06BzghSdHhuiQ/TSt31aq2rcd0DgCcNI/Xpz+t269hQyJ1cX6a6Rxg0LGqHQAAAKeCQTv81mu769XQ0aslrGZHgPnC9KGyLEuPbmRVO4DA89z2Gh1o6tJ3zhvJIeQIWaxqBwAAwMli0A6/ZFmWHt9UqRGJUTpz+BDTOcBJyYiP0IJxaXpuW5Xq21nVDiBwtHV79Nd3D2ja0HidNyrRdA5gDKvaAQAAcLIYtMMvba44pN117bp2aqZsNlbTIfB8+YxseX2WHlpfbjoFAE7YAx+UqbXbo+/NHsX1FyHvyKr2v7130HQKAAAAAgCDdvilxzdVKiHSqQV5qaZTgFOSlRCphfluPbe9mr3aAQSEipYuPbmlUpeMT9OY1BjTOYBxR1a1HzkcGAAAAPgsDNrhd8qau/T2vkZdMTFdEU676RzglN14RrZ8lvTgB+zvCsD/3ff2fjnCbPrG2cNNpwB+Y8nULCVEOnXfW6WyLMt0DgAAAPwYg3b4nSc2Vchht+nKSRmmU4DTkhEfoUXj07R8R41qWrtN5wDAp9pScUhr9jTo+ulDlRLjMp0D+I0Yl0NfPiNbG8sP6b0DzaZzAAAA4McYtMOvNHb06qWdtbo4L03J0eGmc4DTduPMbFmW9CB7tQPwUz7L0u/W7lNqTLium5ZlOgfwO1dMTFdGfITue3u/fKxqBwAAwKdg0A6/8sTmSvV6fPrCdG70ERzccRFaXODW8sIaVbOqHYAfemlHjYpq2/Wtc0ewZRtwDE57mL559nDtre/QK0V1pnMAAADgpxi0w2+0dXv0zNYqXTA6WcMSo0znAP3mhhlDZbNJD7zPXu0A/EtLZ5/+8NZ+Tc6M4wBy4DPMHZuisakxuv+dA+rx+EznAAAAwA8xaIffeGZblTp6vbphRrbpFKBfueMidFlBul7aUaP9jZ2mcwDgqPve3q/2Xq9+fGGubDab6RzAb4XZbPr2eSNU3dqjZ7dVmc4BAACAH2LQDr/Q3efVE5sqdebwIRqTFmM6B+h3XzkzWxFOu37/VqnpFACQJG2rPKTlO2q0dGqmRiVHm84B/N7MYUM0c1iCHni/TO09HtM5AAAA8DMM2uEXXtxRo+auPn1pJqvZEZyGRIXrSzOzta60SRvKmk3nAAhxHp+lX71eorRYl758xjDTOUDA+M65I9Xa7dHf3jtoOgUAAAB+hkE7jPN4fXpkQ4UmZsRpcla86RxgwFwzJVPpcS7ds7ZUXp9lOgdACHtyc6VKGjr0n+ePUlQ4B6ACJ2pMWowWFbj15OZK7WvoMJ0DAAAAP8KgHca9UlynmrYe3TBzqOkUYEC5HGH61jkjtKe+Qy/vqjWdAyBE1bb16K/vHtQ5IxM1OyfJdA4QcL59zghFuxy6+18lsizeOAcAAMBhDNphlNdn6aH15cpNidbZIxJN5wADbt7YFOW7Y/Xndw6oq89rOgdAiLEsS79+fa+8lqX/PH8UB6ACpyAhyqlvnjNcm8oP6dXietM5AAAA8BMM2mHUq7vrdKCpS1+amc3NPkKCzWbT92ePVH17rx7dUGE6B0CIeWlnrd4ubdI3zxmurIRI0zlAwLq0IF15aTG6961SdfRyMCoAAAAYtMMgj9env757ULkp0bpgdLLpHGDQTMyM15zcZD28oVx1bT2mcwCEiOrWbv3fG/s0JSte10zJNJ0DBDR7mE0/uiBH9e29+vt7ZaZzAAAA4AcYtMOYF3fWqqKlWzedPVxhrGZHiPnOeSPksyzd82ap6RQAIcBnWfr56j3yWZZ+On80112gH4xPj9Pi8W49sblSpY0cjAoAABDqGLTDiO4+r/7x3kEVpMfpnJHszY7Qk5UQqRtmZOu13fX64ECz6RwAQe6ZrdXaWNai780epcx4towB+su3zh2u6HC7fvV6iXwcjAoAABDSGLTDiGe3VauuvVffOnc4e7MjZF0/Y6iGJkTo12v2qsfjM50DIEiVNXfpD2+V6szhQ3RZgdt0DhBUhkSF67vnjdCWikN6dlu16RwAAAAYxKAdg66j16MH15dr5rAETR2aYDoHMMblCNOPL8hVeUu3HviA/V0B9D+P16efrdotpz1Mt84bzZvbwABYNN6tM4YN0R/eKlXVoW7TOQAAADCEQTsG3RObKtXS1aebzh5uOgUwbubwIbp4XKoeWl+u3XXtpnMABJk/rjugwupW3XxhjlJjXaZzgKBks9n03/NyFWaz6Zev7mELGQAAgBDFoB2DqqWrT49urNDsnCTlp8eZzgH8wg9mj1J8hEM/f2W3PF62kAHQP94sadCjGyt0xcR0zRubajoHCGruuAj9x6yR2lDWoie3VJnOAQAAgAEM2jGo/vlBmTp7vfo6q9mBo+Ijnbr5wlztqe/Qg+vLTecACAIVLV362Su7lZcWox/MHmU6BwgJlxa4de7IRN33VqlKGjpM5wAAAGCQMWjHoDnY1Kknt1Rp0Xi3cpKjTecAfuX83GRdNDZFf3+/TLtq2kznAAhgPR6fbllRJEm6a2Gewh38ugcMBpvNplsvGq0Yl0M/fbmYg84BAABCDHdeGDT3vlmqCEeYbjpnuOkUwC/96IIcJUU5ddvLxers9ZjOARCgfrd2n4pq2/Wz+WOUlRBpOgcIKYlR4frpRWO0t75Dv1u7z3QOAAAABhGDdgyKDw406+3SJn1pZraSosNN5wB+KS7CqTsWjFV5c5fuWlVsOgdAAFqxs0bPbqvWddOyNCsn2XQOEJLOHpmoL0zL0rPbqrW6qM50DgAAAAYJg3YMuD6vT//7xj5lxkfo2imZpnMAvzYtO0FfmJ6lJzdW6BVuzgGchC0Vh3Tnq3s1LTtB3+LTY4BR3zxnuCZlxunO1/Zof2On6RwAAAAMAgbtGHCPbazQ/qZO/decHPaJBU7ATWcP17RhQ3TXa3tU2shhagCO72BTp/5r+U5lxEfo15fkyWHneguY5LCH6c7P5SnSadcPl+9Ua3ef6SQAAAAMMO7CMKCqW7v19/fLNDsnSWePTDSdAwQEhz1M93x+oiKddt38YpHae9ivHcCna+v26GuPbJIk/e6y8YqLcBouAiBJqbEu/WbROFUd6tZ/ryiWx2eZTgIAAMAAYtCOAWNZlu5eUyKbpP88f5TpHCCgpMVF6M7P5amsuVO3vVwsLzfnAI7B4/XpJyt2qby5U79eNE7ZQzj8FPAnEzPjdfOFOXr/YLN+98Y+WRbXcwAAgGDFoB0D5rXd9Xq7tElfP3u43HERpnOAgDMtO0H/dUGO1pU26b6395vOAeBnLMvSr9eU6IODLfr5onxNHZpgOgnAMSwuSNeSqZl6amuVHt1YYToHAAAAA8RhOgDBqamzV79ZU6J8dywHoAKn4YqJGSpt6NSjGyuUlRChKyZmmE4C4Acsy9If3tqvFwprdOPMobpySpZaWjhwEfBX/zFrpOrbe/X7t/YrOSZcC/LSTCcBAACgnzFox4C4e80+dfZ5ddtFo2UPs5nOAQLa988fparWbv1mTYkSo8J1fm6y6SQAhv3zg3I9srFCV03K0DfOHm46B8BxhNls+tn8MWrq7NUdq3YrymnXrByu5wAAAMGErWPQ717eVavX99TrK2cM06jkaNM5QMBzhNn0PwvzlO+O1a0ri7SpvMV0EgCDntxcqT+/c0AXj0vVD+eMks3GG9pAIAh3hOl/L81XnjtWP1lRpPcONJlOAgAAQD9i0I5+VdHSpd+sKdGkzDhdP2Oo6RwgaEQ47fq/y8YrMyFS339+h7ZWHDKdBMCAl3bU6Ldv7NPsnCTddtEYhTFkBwJKdLhD914+XiMSo/TDF3bqnVKG7QAAAMGCQTv6jcfr009fLpbNJv384rFysGUM0K8SIp3601UTlBrj0n889//au+/4KOr8j+Ov3Wyy6b0CgVAHEEJXznIqioConD/vxN49ewcVj1OxcqLnWX6e7cSC5SzcoShY8GcHpSidoUMChHRIL5v9/TGbEAKkkE3d9/PxmMcmM99dvvPhm52Zz3zn+13Dyl1Ktov4kk/X7uWRLzZybPdIHp04QMdZkQ4qPNCf//1TKr1iQpgyby1fb8xq6yqJiIiIiBco0S5e89z321i9p4D7xvYjKTywrasj0inFhgTwz/NTiQ0N4OYPV7NEj52L+IS5K3fz4EKTkcmRPPmHYwhw6BROpCOLDPLnn+enMtAzjMzclbvbukoiIiIi0ky6SpMmcblcvPji80yaNI6xY09i+vS7yc3N4YsNmbyzfBeTh3VhrBFXU37Jkp+4+upLGTv2JC67bDJffrnwoM9LT09j2rS7mDjxNM4663SmT7+HjIyM1t4tEa+bNesxZs58uN4yGzas44YbruK0007gggvOZcGC+QdtX7z4B048ceQhi7s4n5cnDyE5Kog7/rOWr0z1hBPpzN5Zns7jX23mxF7R/P3cQRTkZTN9+j1MmDCG8eNP4YEHppGZmXnE9y9c+CmXXno+p59+ItdeezlLly5pxdqL+JY1a1Zz8snHsWLFsgbL7svOYMe/bmFEDDz+1Wb+9/ttuN1ucnKyeeCBaZx11umcffYZPP30E5SUlLRC7UVERESkOZRolyZ57bWXWbBgPtOnz+D5518hMzOTu+6ewsOfb2Ro13BuO7lXTdlVq35j6tTbSE0dyquvvsUll1zJcDn/YgAAIABJREFUrFmPs3DhpwCUlJRw550343JV8cwzL/LUU8+zb18+U6bcSnl5eVvtokizuN1uXn31RebNm1tvuby8PO688xb69evPa6+9zR//OJmZMx/ml18OJMC2bNlMv34G8+YtPGiJjY0jJiSAl84fwjGJYdw3fz1vLU3D7Xa39O6JSCub/fNOnv5mK2P6xvLEOQMJ8LMxdertFBQU8OyzL/Lccy+Tk5PDzTffeNj3f/nlQh599EHOOGMCr732NuPHT+See+5qVBJQRJqmpKSERx65H5fL1WDZnTt3cMcdN1FaWsL0cf04NzWR139J4665q7jttpvYvn07jz32JE8++SwbN27g3nvvaoU9EBEREZHmcLR1BaTjqKio4IMP3uP226cwatRoAG67+0Guu+KPBPfYyeNXn4e/34F7N++++xaDBqVy223WhUGPHins2bOLf/3rJcaPn8gvvyxh794MZs9+m5CQUACmT5/Beeedxbp1axg6dHjr76RIM+zalc7MmQ+zbdsWEhIS6y07f/5/CQkJ5bbbpmC32+nRI4WNG03effctjj3W+vvatm0LvXr1ISYm9rCfERbo4Pk/DmbGQpNnv9vGzrwSpo7poyElRDqBKreb57/bxlvL0hnXP44HJ1hzn+TkZJOSksL1199CUlIXACZPvohp06awf/9+wsPDD/qct99+k7Fjx3PppVcC0L17DzZv3sjs2a8wfPjIVt8vkc7suef+TlxcPOnpafWWe//9d3n11Rfp1i0ZAIfdxrTT+9IrJoRn3pmH3/YtPPb8HFJT+wMwY8bjnHfeWSxdupS+fY9p8f0QERERkaOjbIw02qZNJsXFRQwbNgKA4nIXMxfnQkg0E+IKiQ11HlQ+LS2NIUOGHbSuXz+DPXt2k5GRwcCBx/Dkk8/UJNkB7HarSRYU7G/hvRHxvjVrVhEfn8Abb7xXkwA7kpUrf2Xo0GE1bR5g2LARrF69sqZn+tatW+jRo2e9nxPo78ejZw3gimOT+e/qDP7875Xs2V/a/J0RkTZTWuFi2ifreWtZOucNSWLGhAMTjMfExDJjxuM13zGZmXuZN28ugwYNPiTJDpCevpPU1KEHrevb12DNmlVUVla2/M6I+IjFi39g8eIfuf32qQ2W/eGHb7n77vu4+ebba9bZbDYuGN6V83o7sAWFc9+32XyyxhpOMT4+gYiISJYtW9pi9RcRERGR5lOPdmm0rCxr/Ne4uHjKK6u495N1bMwqpE+XRNzFeYeUj42NJTNz70Hr9uzZA0B+fi79+w8kLi7+oO1z5rxOUFDQIQl6kY5g3LgzGTfuzEaVzcrKpG9f46B1sbGxlJaWsm/fPsLDA9mxYwemuZ7LL7+Q/Pw8BgwYyI033kr37ikHvc9us3HTST0ZkBDKQ59v5NK3VjDjzP6c0DPaW7smIq0kp6icKfPWsnZPAbef3IuLRnTFZrMdtuy0aXfx/fffEhYWzuzZrx+2TGxs3CHH4oyM3VRUVFBYWEhkZKS3d0HE5+Tn5zNz5sNMm/YAYWFhDZZ/9tkXAQ47hFNq72TmV5ZgxDl56PONLE/L57pjEyko2E9uriZAFxEREWnP1KNdGq20tNTqfWuz85dP17N4ex73je1LTFjwYcdUHzfuTBYt+oJFi76ksrKSjRs38O67cwBrGJq6/vOfD/noo/e5/vqbCQ+PaPH9EWlLpaWlOJ0HPwXi7x8AQHl5GWlpaZSXl1FRUc499/yFhx6aSXl5BTfeeC15eYe/0B7TL443LxlOfJiT2+eu4Z8/bsdVpXHbRTqKrTlFXPXOr2zKKuJv5wzk4pHdjphkB7jmmht4+eXXSU0dwp//fE3NDfHaxo07k7lz32fZsl9wuVysWLGM+fM/BqCy8tBjsYg03axZj3LCCb9n9Ojjm/1Zo0cfT2hICEkb/8tlQ2JYuHonF9x2L27QHEYiIiIi7ZwS7dJoTqeTqqoqps9fyzebc5g6pjeTBidRUVFOYGDQIeUnTDiLK6+8lscee5AxY47nL3+5mwsuuBjgoOFiAN5441889dRMLr30Ss47b3Kr7I9IW3I6nYdcMFdUWL8HBgaRkpLCZ58t4vHHn2LgwEEMGTKUxx6bhdtdxcKFnx3xc7tHBfHahUM5Z1ACry3ZybXvrWRHbnGL7ouINN/XG7O46p3fKK2s4qXJQzi17+HnZqitd+8+DBw4iBkzHsflcrFgwfxDylxyyRWcccYEpky5lVNP/R3PPPMkF154KXDosVhEmm7Bgvls3LiRm2++wyufFx4ewcyZf2fDhvW8P+MKgj9/iNDIWCrDurA4rZi9BWVe+XdERERExPs0dIw0WmR0HACLVm3l9gkjOH9YVwCys7M58cS4w77niiuu4ZJLriA/P4+YmFh+/PE7/Pz8SExMAqCqqoqnnprJvHlzueGGW7j44stbZ2dE2lh8fAI5OdkHrcvOziYoKJjQUCv5VffJjsDAQLp06XrIMBB1Bfr78ddxBqO6RzHr681c/NYKbjwxhQuGd8VeT+9YEWl9la4qnv9+O28vT+eYxDBmnj2AxPDAI5bPzc1hxYplnH76uJp1gYGBJCd3Jysr65Dy/v7+3HnnPdx88x0UFOwnJiaWDz54j+joGIKCDr1JLiJN89lnn5CVtZdJk6y/yep5VqZMuY0JEyYydep9Tf7MQYNSee+9ueTl5RIcHIzdEcD4CaexuzKE82cv4+KRXbloRDdCnbqUExEREWlP1KNdGiW3uJxnVpXhdjg5N7GIi0d2A2DPnt3s2bObIUOGH/Kejz76N8888xQOh4PY2DhsNhvfffcNgwalEhwcDMDf//4E8+fP4777HlCSXXxKaupQVq78teaCHKyxWgcPHoLdbmfRoq8YO/b35OUdmP+guLiItLSd9OzZq1H/xvgB8bx3+QhGdY/k6W+2cv2/V5KeX+L1fRGRo5NdWMaNH6zi7eXp/GloF16ePKTeJDtARsYeHnzwL2zYsK5mXWFhIdu3byMl5dDJk19++QXmzHmdgIAAYmKsXvLff/8No0Yd592dEfFR99//MHPmfMDs2e8we/Y7PPXU8wDce+90rrnm+iZ/XlraTm644Wr2799HVFQ0Tmcga1f/RkVpEa9OuYjf9YzilcU7OfdfS3lneTpllVXe3iUREREROUpKtEuDNmYWcvmcX9mUU8ZJY89hySdvsGTJT5jmBh544D6GDh3OoEGDqaioICcnu2b89e7dU5g7930+//wz9uzZzVtvzeaLLxbUXHT89NMP/Pe/H3LZZVdx3HG/Iycnu2YpK9NjsdK51P37OOusSeTn5zFr1mNs376NDz98jy+/XMjFF18GwMiRowgJCeHhh+9n8+ZNmOYGpk+/l4iIyEZPuAoQF+rk7384hvvH9WNjVhEXvLGcVxfvoFwX5iJt6qdtuVwy51fW7S3koTMN7j6tDwGOhk/L+vcfyJAhw5g58xHWrVvDxo0buP/+e4mKimLChLMoKyslJycbl8sFQFJSF956azaLF//Arl3p/OMfs1i/fh2XX35VS++iiE+Ii4unW7fkmiUpyXpqMzY2jqio6EOO/w1JSupCdnYWTz89i/T0NFasWMaMGdOZOHESo1MNZp49kDcuHoYRH8LT32zlvNeW8t6KXRSWVbbkboqIiIhIIyjRLkfkdruZvzaDq9/9jSq3m5cnD+GRe+5i7NjxPPzwX7n11utITEzikUeeAGD16pVMmjSe1atXAjBq1HFMmTKN1157mUsu+RPfffd//O1vTzNs2AgAvvhiAQCzZ7/CpEnjD1q++WZR2+y0SAup+/cRHR3Dk08+x6ZNJldddTEfffQ+06fPYMSIUQBERETwj3+8gMPh4JZbruOWW64jKCiQZ5558ZBJVBtis9k4e1Ai/75iJCf1iualn3Zw4ZvLWbL98JOqikjLKS538fiXm7ht7hrCAx28ftEwJgxIaPT77XY7jz46i759+3H33Xdw883XERwcwuuvv0lwcDCLFn3JpEnja4aYOvvsP3DhhZcya9bjXHHFhWzZsplnn/0n3buntNAeikhtdY//DXE4HPztb0+Tk5PNlVdexCOPPMCECWdx11331JQZmBjG839M5YU/DSYhzMlT/7eFs17+mSe/3szOPD25JiIiItJWbLWHLWiurKyCZn9YZGQw+fmauK85vBHDwrJK/rZoMwvXZzK8WwSPTuxPbGjTknsdldpg8ymGzdeSMVyyPZdZX29hZ14Jp/eL5Zbf96JLRP3DVXREvtQO4+LCmjX4vjeO30fDl/6PAFbu2scDC0x27yvlohHduOHEFJyN6MXeGL4Wy5akWHqPYuldR4rn2owC/r1iF1+aWVRWuRmdEsXEgQmc0ieGQH+/Nqhp+9de2mZzj98iIiLSvmgGHTnE91tymPnVJrKLyrnu+B5ceVx3/Ow6BxTpLEanRPPuZZG8tSyN2T+n8d2WHC4Y3o0rj0vWxGoiLaCwrJJXFu/g3eW7SAp38uLkVIZ3i2zraolIJ3FMYhgPndmfW0/uxdyVu/lkzV7++tkGgv39OLVfLBMGxDMiORKHzudFREREWpQyKlIjY38pz3y7la82ZtM7NpgnzhnIMUnhbV0tEWkBAQ47V4/uwcSBCfzzx+28uTSNj9dk8Ofje3BuapIuxkW8wO12s3BDJs98u43conLOTU3i1pN7EhKg0y8R8b7YkAD+fHwK1/yuB7+m72PBuky+2pjFp2v3EhHo4KTeMZzSJ5bjekSqp7uIiIhIC9CVnlBQWsnby9OZsywdgOuO78Hlxybj76ch/EU6u8TwQGZM6M8Fw7vyj2+28sSizby3Yhd//l0PxvaPw25Twl3kaGzOLuKJRZv5NX0fAxJCeWqSbl6LSOuw22yMSI5kRHIkU0/rw4/bcvlmUzbfbs5h/tq9BDrsjOoeyeiUaEanRJEcGYhNx3sRERGRZlOi3YflF1fw4crdvLN8FwVllZzeL5ZbT+5FUnjnG6tZROo3ICGMF89P5bstubz443amf7aB2b/s5PrjUzi5T4wuwEUaKT2/hFcX72DB+kzCnA6mje3LpEGJGoJNRNqE02FnTN9YxvSNpdJVxfL0fXy7OYeftuXy/VZrUvQuEYGM7hHFcSlRHNs9UsPIiYiIiBwlnUX5oM3ZRby3YhcL12dSVlnFSb2iue74FIyE0Laumoi0IZvNxsl9YjipdzRfmVm89NMOpn68jgEJoVx+bDKn9IlVslDkCDL2l/Lazzv5eM1eHHYbFw7vxhXHJhMZ7N/WVRMRAcDhZ+e4HlEc1yMKsG4MLtmex5LteXy+IZO5q/Zgt0H/hDBGJkcwPDmSoV3DNdyViIiISCPprMlHlFa4+G5LDv9dncHSnfk4HXYmDkxg8vAu9IoJaevqiUg7YrfZOKN/PGP6xfHZ2r28/stO7v1kPcmRgVwyshtnDkzQ2K4iHpuzrJvXn63fi9sN56UmccVxycSFOtu6aiIi9eoWGcQfhwbxx6FdqHRVsXpPAT/vyGN5Wj7vLN/Fm0vT8bPBgMQwRiRHMjI5giFdIwjSOYCIiIjIYSnR3om5qtws25nPgg2Z/N/GbIorXCSEObnpxBT+kJpEZJB62YnIkTnsNs4ZnMjEYxL4dnM2byxN5/GvNvPSTzuYNDiRPwxOokuEhpoS3+OqcvPD1lze+3UXyzw3r88ZlMjlxyZr+DUR6ZAcfnaGdYtgWLcIwOqks3L3flak5bMsbR9zlqXzxi9p+NltDEwIZXCXcFK7hDM4KZz4MN1YFBEREQEl2judkgoXS9ftZcGq3fywNZe8kgpCnX6M7R/HhAHxDOsWockNRaRJ/Ow2xvSL49S+saxIP3Cx/frPaRyXEsX/pCZxUq9oHJpAWTq5tLwS5q/by4J1e9mzv4z40ABuOaknkwYnEqGb1yLSiQT6+x00zExxuYtVu/exLG0fv6Xv48PfrHmeABLCnAxOCmdwlzCGdAmnX3wo/jonEBERER+kRHsHV+V2syW7iKU782uWssoqwpwOju8ZxZi+sZzQKwanQye7ItI8NpuNEcmRjEiOJGN/KR+vyWDe6gzu/ngdEYEOTukTy5h+sYzqHqkLbOk0covL+WZTNp+uy2TV7v3YbXBsjyhu+X0vTu0ToxtMIuITggP8GJ0SzeiUaAAqXFVszCxk1Z4CVu/ez+rd+/lqYxZgTcDaLy6U/gmh9I+3XnvFBOv7UkRERDo9m9vt9tqHZWUVNPvDIiODyc8v9kZ1OiW32016filL0/JZuiOf5Wn55JVUANAtMpATekYzcWhX+kY4dTJ7lNQGm08xbL6OEsPKKjeLt+XyhZnF91tyKCp3EeZ0cGKvaEanRHFs90hi22is6o4SQ2+Iiwtr1qNK3jh+H432+n+0I7eYbzfn8O2WHFbv3o8b6BkTzFkDExg/IL5dDpPQXmPZESmW3qNYeld7j2dWYRmrd+9n1e4C1u0tYGNmIUXlLgAC/Gz0ibMS70ZCKAMSQukdE0JAG3UGai+xbO7xW0RERNoXJdrbucKyStbvLWDNngLWZViv2UXlAMSFBjCqeyQjkyMZ1T2SRM+4sO0phi+88ByzZj1OUVFhW1dFpF0KCQll6tRp3HjjLQetb09/x41VXlnFzzvyWLQpmx+25LCvtBKwEpTHdo9kSNcIBiSE0jUiEFsrDGHVEWN4tJRob57sonKW78xnaVo+y3bms2tfKQD940P5fZ8YTu4dQ9+4kFZpt0erdix17BXpGI50DnAk7eU7s7Gq3G7S8kowMwtZv7eQDZmFmHsLKSizzg/87DZ6xwQzICEMIyEUIz6U3rHBhAS0/EPX7SWWSrSLiIh0Lkq0txNut5vsonK2ZBexNaeYTVlFrM0oYHtOMdVB7R4VxDGJYQzuEs6o7pH0iAo67EV/e4rh4MH92Ls3o62rIdKuJSQksnr1xoPWtae/46NR5XazMbOQpTvz+WVHPr/u2kdZZRUAEYEOBiSGYcRbj5L3igkmJTqYQH8/r9aho8ewKZRob7wKV1XNMXZtRgFr9+xne24JAGFOByOSIxjVPYrf946uuYHdEdSOpY69Ih3H4c4BjqQzHNfcbje79pWywZN437C3gA17C2tuzgMkhTvpHRviWYLpHRNCSnSwV3u/t5dYKtEuIiLSuWiM9lZWXO5i975Sdu0rZff+UrbnFLM1p4gt2cU1vTsAooP9GZgYxhlGHMckhTEwIaxDTrR2ww23qFedSD1CQkK54YbG9WTrSOw2G/0TwuifEMalo5KpcFWxJbuIdRkFrMsoZN3eAuYsS8dVZeV3bVgX1l0ig+gS7iQxPJAu4YEkRTjpEh5IbKgTh13XotI4VW43ucUVZBaUkZ5fwvbcYrblWK878oqpcFntrvpYe/YxiYzsHokRH4pfJ2hnOvaKdAyd9RygPjabjW6RQXSLDOJ0Iw6wku97C8owMwvZmlPM5qwituQUsXh7Xs15gp8NukcF0zs2mF6xIfSKCfZ8TmCr9IAXERERaQz1aPeSKrebfSUV5BRVkFNUTk5xOTlF5WQXlZNVWM7ufaXs3ldaM556tTCnw+qp4TlhrH6NCg446rp01Bi2F4pf8ymGzecLMax0VZGWX8q2HOtJnu25xezeV8ae/aU1Q2RVswGRQf7EhAQQHVz9GkBMiPVzTHAAkUH+hAb6EeZ0EOp0EB0V0uljWK2j9Gh3u924gSq39XN4RDB5eUWedW7cbnC7rZ+r3G7KXW7KK6soc1VRVllFuWcprnBRWFZJQVklhWWV7C+tJKuwnKzCMjILrWNvdXIGrPbTJSKQnjHB9IwOZmBiGMckhZEY5mzXw8E0hS98Z7QWxdJ7FEvv8rV4Vriq2JlXwpbsIs9SzObsoprhvapFB/uT7Em6d4sMIiHMSXyok7iwAOJCnIQ6/Q75rm8vsVSPdhERkc5Ft/893G43ZZ6L9+JyFyWe18IyFwWei/jCWq8FZZXsL6ukoLSS3OJycovKcR0mTRHosBMbGkCX8EBO7hNDl4hAunqWLhGBRAb5d5qLfBGRpnD42a3EZ0wwY+psK6usYm9BGXs8T/9kFpSRW3zgRmb6rn3kFFfUDEdTlw0IDXQQFuBHqNNBeKCVfA/y9yPQ306g48Cr02E/6GeH3Yaf3YbDz4afrfarHYfNhp+fzXq127DZrN77dpvVS88GNT/bbWDjQBmbDfz97DjbaOK31vbJmgxmfrUJlyepXtWCqfyQAD9iQwKID3MyMjmCuFAncaFO4kMD6BIRSPeoIK8PTSQiIi3L389eM4RMbcXlLnbmFZOeX0p6fgnp+aWk5ZewdGc+n67LPORzAh124sOcxIQEEBFonRPERQThtFmdnsIDHQQHWOcAAX4Hzgec/tbvDruNAIedIB1HREREpAHtPtG+M6+EH7fl1lykV79W93yr7vVWva2yyuoBV+Hy9HxzVVHhcnteq9dZv5dVVtUk1EsqXI1KAjgddsIDHYQ5rSUuNID+8aEHelV6elZW/xwcoBMyEZGmcjrsdI8KontU0BHLuN1uispd5BSVk1tcwb6SCgo8N0ILSispA3L2l9bcIN2ZV0JpZRWlFS7KPK+Hu0HakpwOO3MuHU5KdHDr/sNtYHBSOBeN6IatnpsQwUH+lJVVUj1aS/UNCbunfIDDujFRnfwIcNhx+lnJjuqnF0ICHJ1iuBcREWmc4AC/muHp6iqrrPI83VRGVkE5WUWep50KyskpKiMtv4SC0koKyrIpqXA1+t/0s8EL56cyvFukN3dFREREOpl2n2ift3oPby5Nb1RZu82avT7Az7og9/ezeh8c+N1OgMNGmL+fp7eCnaAAP4L9/Q68+vsRHGAn2N+PQH/rIj6sVmLdm5PwiIjI0bPZbIR6honpEX3o9sY8Fl7pqqpJvpdWWj+7XG4q3W4qXVW43G5cVdZNXFeVm0qXG5f7wOshw50A1NwQrj1UilUuOMCPpA40wWZzpMQEc9NJPest014e3RcRkc7B6bDXjAFfn8jIYDKzC9lfVsn+0gpKyl01w5SVVXhePUOXuarc+Nlt9IsLbaW9EBERkY6q3Sfabz6pJ5cfm3xIL7faj+pXv4qIiDSFw89OqJ+dUGe7PxyKiIiIFwU47MQ6AogNOfq5sURERERqa/eZBZvNRnigf1tXQ0RERERERERERETksDQOioiIiIiIiIiIiIhIMyjRLiIiIiIiIiIiIiLSDEq0i4iIiIiIiIiIiIg0gxLtIiIiIiIiIiIiIiLNoES7iIiIiIiIiIiIiEgzKNEuIiIiIiIiIiIiItIMSrSLiIiIiIiIiIiIiDSDEu0iIiIiIiIiIiIiIs2gRLuIiIiIiIiIiIiISDMo0S4iIiIiIiIiIiIi0hxut7tdLQ8++OCDbV2Hjr4ohopfWy+KoWLYHhbFsP0v+j9SLNvjolgqlu11UTwVSy1atGjRokVL+17aY4/2B9q6Ap2AYtg8il/zKYbNpxg2n2LY/un/yHsUS+9RLL1HsfQuxdN7FEsRERHxuvaYaBcRERERERERERER6TDaY6J9RltXoBNQDJtH8Ws+xbD5FMPmUwzbP/0feY9i6T2Kpfcolt6leHqPYikiIiJeZ3O73W1dBxERERERERERERGRDqs99mgXEREREREREREREekwlGgXEREREREREREREWkGJdpFRERERERERERERJrB0dL/gGEYTuA54E9AGfB30zSfOELZk4B/AP2BTcDdpml+UWu7CfSr87Zhpmn+1hJ1by+aGMMxwJNYcfoNuMM0zaW1tp8KPAP0AX4BrjFNc3PL7kHb8nL8fLINVvPEcjlwu2maXx2hTA/gFeAEYCdwp2maC2pt97k2WJuXYuiz7bAx8atVtg+wGggzTbOy1vohwIvAEGA9cH3tv3PxHsMw+gPPA6OBHOB50zRnHaFsvecAvq6Jsaz3WCYHGIbxCtDXNM1TjrDdp49ZTdFQLGuVuxi4wTTNE1ulYh1QI9rlrcAtQBLWce4u0zR/ar0adhyNiOW9wE1ADPAdcItpmptar4YiIiLSmbRGj/ZZwO+A04HrgOmGYVxQt5BhGPHAJ8AHQCrwPvBfT8KpOrnSGyvxlFRrWdMK+9DWGhvDAcBC4EtgBPAxsMgwjG6e7cmedXOAkUAGMM8wjM7+ZIO34ufLbRDDMAKBd4Fj6iljA+ZhJYFGAW8AHxmG0dOz3VfbIOC1GPpsO2xM/GqVTQbmA4F11ocAC4AlWH/n3wOfGoYR5vUK+zjDMPyxYr0TGIqVyPirJ8lWt2y95wC+romxrPdYJgcYhnEacE092336mNUUDcWyVrlTgZdbvkYdVyPa5SXAw8A0rO+Db4CFhmF0bZUKdiCNiOU1wBTgWqyb73nAfP2Ni4iIyNFq0R7tnoTGtcDZpmkuB5YbhvEEcDPwXp3iJwCYpjnT8/tjhmHchdVzawdgAG5gqWmaFS1Z7/akiTG8EVhumuY9nt+f8PRquwnrZPxaYGV1b27DMK7CumgcA9TbM7Sj8nL8fLINAhiGMRB4B7A1UPRUrDidZJpmAbDOMIzTgauB6fhgG6zmxRj6ZDtsQvwwDOMPWImcPYfZPBmowOr9V2UYxh3ARM/6V71XYwG6YvUAvsk0zRJgs2EYXwEnA2/XKdvQOYCva0osGzqWCTXnBy8DP9ZTzGePWU3RyFhiGMYDWG1QvYWPoJGxvAJ4wTTNDz2/TzMM4zzgbKyntYRGxzIMmGqa5kLPex4HVgKJwO4Wr6SIiIh0Oi19t34I4AR+qLXuB2CUYRh+dcrmABGGYfzJMAybJ1ESBqzybB8IbPWlxJJHU2LYC1hcZ91KrN7cYCUsvqveYJpmMbCi1vbOyJvx89U2CFYy5/9ouK2MBn71JIir/YBvt8Fq3oqhr7bDxsYPrMT5X4HbDrNtNPCjaZpVAKZpurEuwn2hDbYq0zS3m6Y52TTNEs9x/QTg98CiwxRv6BzApzVTj0fpAAAG1UlEQVQxlg0dy8TyKFZP4G/qKePLx6ymaEwsAcYC44CPWrg+HVljYjmdQ58KcAORLVOlDqvBWJqm+bRpmrMBDMOIwLohuRbrhpqIiIhIk7X0GO1JQK5pmqW11u0FAoB4Du5t+D3W2KP/BqoAP6xxMNd7tg8EXIZhLACGASbW+K0/t+wutLmmxHAvUPfR8B5AbK3Pqts743Dv6Uy8GT9fbYOYpvnP6p8Nw6ivaENtzBfbIODVGPpkO2xC/DBN81pPuVMOszkJK2a17cV6/F5aTjrQBWs4nw8Ps72hcwA5oKFYNnQs83mGYfwOa96WQcBd9RT12WNWYzUhllSPye4ZPkbqaGwsTdNcUud947HmY9BTFh5NaZee8n8GXsKay2lc9c14ERERkaZq6R7twVgnLLVV/+6ssz4E6Ak8gjUu8T3AM4ZhjPZsHwBEAS8AZwLrgK8Nw0jxfrXblabE8D3gfwzDOM8wDIdhGBOBc7CSyvV9Vt3P6Uy8GT9fbYNN0VAb88U22FQNxUjtsHnUBtvGJM8yHHj6MNsbOgeQAxqKZUPHMp/mmefiX1gTKuc1UFzfF/VoYiylHkcbS8Mw+gFvAm+aprmsperXkRxlLD/HmtPiNax5GHq2VP1ERESkc2vpRHsph16MVP9eXGf9VMBpmub9pmn+6hkP8yOsxyMBLgIM0zQ/MU1zBdYYpFuAy1qm6u1Go2NomuYXWGNfzsG6EHwQq4fg/gY+q+7/RWfizfj5ahtsiobamC+2waZqKEZqh82jNtgGTNNcZprmx1g9C68zDKNu0rehcwDxaCiWjTiW+br7gU2maX7QiLL6vqhfU2Ip9WtyLA3DGIQ1LMoG4LoWqldH1ORYmqa5w3NOdRPW066Xt1TlREREpHNr6UT7LiCqzkVgItaFX26dsqOwxhCtbTnWWKOYpllhmmbNRaJnXN0NWBOEdWZNiSGmac4CwoGupmmO8qzeXuuzEuu8JZHDTxjYWXgtfj7cBpuioTbmi22wqeqNkdphs6kNthLDMLoahnFOndXrsHpWh9dZX+85gK9rYiwbOhfwdRcB4wzDKDQMoxC4GzjJ83Nd+r6oX1NiKfVrUiwNwxgJfAtsBM6sM0Sir2t0LA3DGGsYRp/q3z3nVOvRUFsiIiJylFo60f4bUA4cX2vdicBy0zQr65TdjTX2cG0DsHpqYhjGL4Zh3FO9wTAMO5CKlWDqzBodQ8MwLjAM43lPIi7DMAwbcBbWBIIASzzvrS4fjDXG80FjPXYyXoufD7fBplgCDDUMI6TWuhM50MZ8sQ02Vb0xVDtstiXA8Z6/bzyvJ6A22BIGAHMNw4ivtW4EkGWaZnadsvWeA0jjY9mIcwFfdwrWuM1DPcsrwDIOP0+Djln1O4XGx1LqdwqNjKVhGL2AhVgT855pmqZubBzsFBrfLh8Abq3+xTAMBzAEK9kuIiIi0mQtOhmqaZrFhmG8AbxgGMYVWL2ApgDVE9UlAvtM0yzBOgn60TCMu7Em9zoVuBJrDGKwJv2aahjGaqwL7zuBaKyx9DqtJsZwA/CGYRg/AEuxHh0PAV73fNxrWDH8C/Af4K/ATmBRq+1QK/Ny/HyyDTbEMIw4oMRzofctsAN43TCMB7GSO6OBqz3Ffa4NNkYTY6h2WEed+DXkQ2Am8JxhGC9gfReEYY1rLd71LVav69cNw7gL6I0V+0ehyecAvq4psWzoWObTTNPcUft3wzDysL4/NhuG4QfEYU2iXo6OWfVqYiylHk2M5f8CRVjDxYQbhlH9VEuhku5NjuVzWN+XP2F1zpmK9aTQG61cbREREekkWrpHO1hJoKXA18CLwEOmab7v2bYHmAxgmubPWJN1TQZWAbcDF5um+bWn7KNYJ5YvYp0I9QNOM01zXyvsQ1trbAx/w0oaPYb1CH5XrBgVebZvB/4HuBSrZ0cCMMk0zapW25O24ZX44dttsD5LsW5eYJqmC2uSvnisYR8uA871tD1fboMNaXQMUTs8nJr4NcQz7M5ErKdcVmD1Zj/TNM2ClquebzJNswIr1pXAz8BLwD+AZz1FmnIO4NOaGMuGjmVyZMlYsTwedMxqpoNiKc1SE0vDMMKA8UB3rJvte2ot97ZZDTuOun/j/wZuw5qI+1cgBThDNyxERETkaNncbndb10FEREREREREREREpMNqjR7tIiIiIiIiIiIiIiKdlhLtIiIiIiIiIiIiIiLNoES7iIiIiIiIiIiIiEgzKNEuIiIiIiIiIiIiItIMSrSLiIiIiIiIiIiIiDSDEu0iIiIiIiIiIiIiIs2gRLuIiIiIiIiIiIiISDMo0S4iIiIiIiIiIiIi0gz/D7+W+rCKKNMpAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "az.plot_posterior(data,round_to = 2, credible_interval=0.95);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As can be seen from the posterior plots, $\\beta$ is well estimated by leveraging knoweldege about the non-dimensional parameter $\\mathcal{R}_0$ and $\\lambda$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Conclusions & Final Thoughts\n", + "\n", + "ODEs are a really good model for continuous temporal evolution. With the addition of `DifferentialEquation` to PyMC3, we can now use bayesian methods to estimate the parameters of ODEs.\n", + "\n", + "`DifferentialEquation` is not as fast as compared to Stan's `integrate_ode_bdf`. However, the ease of use of `DifferentialEquation` will allow practioners to get up and running much quicker with Bayesian estimation for ODEs than Stan (which has a steep learning curve). " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 997ed9c772d233455075acaf48aa205e0cce426d Mon Sep 17 00:00:00 2001 From: Demetri Date: Fri, 2 Aug 2019 15:45:10 -0400 Subject: [PATCH 34/45] Change test conditions Added @pytest.mark.xfail(condition=(theano.config.floatX == "float32"), reason="Fails on float32") --- pymc3/tests/test_ode.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/pymc3/tests/test_ode.py b/pymc3/tests/test_ode.py index a359f8a9ced..6e8cc8c9552 100644 --- a/pymc3/tests/test_ode.py +++ b/pymc3/tests/test_ode.py @@ -10,6 +10,9 @@ import pytest +@pytest.mark.xfail( + condition=(theano.config.floatX == "float32"), reason="Fails on float32" +) def test_gradients(): with theano.configparser.change_flags(compute_test_value='off'): '''Tests the computation of the sensitivities from the theano computation graph''' @@ -53,6 +56,9 @@ def augmented_system(Y, t, p): sensitivity, simulated_sensitivity, rtol=1e-5) +@pytest.mark.xfail( + condition=(theano.config.floatX == "float32"), reason="Fails on float32" +) def test_simulate(): with theano.configparser.change_flags(compute_test_value='off'): '''Tests the integration in DifferentialEquation''' @@ -79,6 +85,9 @@ def ode_func(y, t, p): np.testing.assert_allclose(y, simulated_y, rtol=1e-5) +@pytest.mark.xfail( + condition=(theano.config.floatX == "float32"), reason="Fails on float32" +) class TestSensitivityInitialCondition(object): t = np.arange(0, 12, 0.25).reshape(-1, 1) @@ -200,6 +209,9 @@ def ode_func_5(y, t, p): model5._make_sens_ic()) +@pytest.mark.xfail( + condition=(theano.config.floatX == "float32"), reason="Fails on float32" +) def test_logp_scalar_ode(): with theano.configparser.change_flags(compute_test_value='off'): @@ -255,6 +267,9 @@ def system_1(y, t, p): np.testing.assert_allclose(manual_logp, pymc3_logp) +@pytest.mark.xfail( + condition=(theano.config.floatX == "float32"), reason="Fails on float32" +) class TestErrors(object): '''Test running model for a scalar ODE with 1 parameter''' @@ -287,6 +302,9 @@ def test_too_few_y0(self): self.ode_model(odeparams=[1], y0=[]) +@pytest.mark.xfail( + condition=(theano.config.floatX == "float32"), reason="Fails on float32" +) class TestDiffEqModel(object): def test_scalar_ode_1_param(self): From 9c166ecc600df2405bbb707b89c2f6c4428949c3 Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Fri, 2 Aug 2019 16:17:01 -0400 Subject: [PATCH 35/45] remove pytest decorator Adding dectorator actually made coverage worse. --- pymc3/tests/test_ode.py | 23 +++++------------------ 1 file changed, 5 insertions(+), 18 deletions(-) diff --git a/pymc3/tests/test_ode.py b/pymc3/tests/test_ode.py index 6e8cc8c9552..7e9a733e46b 100644 --- a/pymc3/tests/test_ode.py +++ b/pymc3/tests/test_ode.py @@ -10,9 +10,7 @@ import pytest -@pytest.mark.xfail( - condition=(theano.config.floatX == "float32"), reason="Fails on float32" -) + def test_gradients(): with theano.configparser.change_flags(compute_test_value='off'): '''Tests the computation of the sensitivities from the theano computation graph''' @@ -56,9 +54,7 @@ def augmented_system(Y, t, p): sensitivity, simulated_sensitivity, rtol=1e-5) -@pytest.mark.xfail( - condition=(theano.config.floatX == "float32"), reason="Fails on float32" -) + def test_simulate(): with theano.configparser.change_flags(compute_test_value='off'): '''Tests the integration in DifferentialEquation''' @@ -85,9 +81,6 @@ def ode_func(y, t, p): np.testing.assert_allclose(y, simulated_y, rtol=1e-5) -@pytest.mark.xfail( - condition=(theano.config.floatX == "float32"), reason="Fails on float32" -) class TestSensitivityInitialCondition(object): t = np.arange(0, 12, 0.25).reshape(-1, 1) @@ -209,9 +202,7 @@ def ode_func_5(y, t, p): model5._make_sens_ic()) -@pytest.mark.xfail( - condition=(theano.config.floatX == "float32"), reason="Fails on float32" -) + def test_logp_scalar_ode(): with theano.configparser.change_flags(compute_test_value='off'): @@ -267,9 +258,7 @@ def system_1(y, t, p): np.testing.assert_allclose(manual_logp, pymc3_logp) -@pytest.mark.xfail( - condition=(theano.config.floatX == "float32"), reason="Fails on float32" -) + class TestErrors(object): '''Test running model for a scalar ODE with 1 parameter''' @@ -302,9 +291,7 @@ def test_too_few_y0(self): self.ode_model(odeparams=[1], y0=[]) -@pytest.mark.xfail( - condition=(theano.config.floatX == "float32"), reason="Fails on float32" -) + class TestDiffEqModel(object): def test_scalar_ode_1_param(self): From d5914d84f0d52b844e46fbbb093231b349c14e84 Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Fri, 2 Aug 2019 18:08:16 -0400 Subject: [PATCH 36/45] Added citations in notebook. --- ...ayesian_estimation_of_ode_parameters.ipynb | 21 +++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-) diff --git a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb index 6ea5d77a14a..a1c17154f01 100644 --- a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb +++ b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb @@ -403,7 +403,7 @@ "\n", "In the SIR model, it is straight-forward to see that $\\beta, \\gamma$ and $\\beta/2, \\gamma/2$ will produce the same qualitative dynamics but on much different time scales. To study the *quality* of the dynamics, regardless of time scale, applied mathematicians will *non-dimensionalize* differential equations. Non-dimensionalization is the process of introducing scaleless variables into the differential equation to understand the system's dynamics under families of paramterizations.\n", "\n", - "To non-dimensionalize this system, let's scale time by $1/\\lambda$, the rate of recovery (we do this because people stay infected for an average of $1/\\lambda$ units of time. It is a straight forward argument to show this. For more, see CITE). Let $t = \\tau/\\lambda$, where $\\tau$ is a unitless variable. Then...\n", + "To non-dimensionalize this system, let's scale time by $1/\\lambda$, the rate of recovery (we do this because people stay infected for an average of $1/\\lambda$ units of time. It is a straight forward argument to show this. For more, see [1]). Let $t = \\tau/\\lambda$, where $\\tau$ is a unitless variable. Then...\n", "\n", "\n", "$$ \\dfrac{dS}{d\\tau} = \\dfrac{dt}{d\\tau} \\dfrac{dS}{dt} = \\dfrac{1}{\\lambda}\\dfrac{dS}{dt} = -\\dfrac{\\beta}{\\lambda}SI$$\n", @@ -412,7 +412,7 @@ "\n", "$$ \\dfrac{dI}{d\\tau} = \\dfrac{dt}{d\\tau} \\dfrac{dI}{dt} = \\dfrac{1}{\\lambda}\\dfrac{dI}{dt} = \\dfrac{\\beta}{\\lambda}SI - I$$\n", "\n", - "The quantity $\\beta/\\lambda$ has a very special name. We call it *The R-Nought* (\\$\\mathcal{R}_0$). It's interpretation is that if we were to drop a single infected person into a population of suceptible individuals, we would expect $\\mathcal{R}_0$ new infections. If $\\mathcal{R}_0>1$, then an epidemic will take place. If $\\mathcal{R}_0\\leq1$ then there will be no epidemic (note, we can show this more rigoursly by studying eigenvalues of the system's Jacobain. For more, see CITE).\n", + "The quantity $\\beta/\\lambda$ has a very special name. We call it *The R-Nought* (\\$\\mathcal{R}_0$). It's interpretation is that if we were to drop a single infected person into a population of suceptible individuals, we would expect $\\mathcal{R}_0$ new infections. If $\\mathcal{R}_0>1$, then an epidemic will take place. If $\\mathcal{R}_0\\leq1$ then there will be no epidemic (note, we can show this more rigoursly by studying eigenvalues of the system's Jacobain. For more, see [2]).\n", "\n", "This non-dimensionalization is important because it gives us information about the parameters. If we see an epidemic has occured, then we know that $\\mathcal{R}_0>1$ which means $\\beta> \\lambda$. Furthermore, it might be hard to place a prior on $\\beta$ because of beta's interpretation. But since we $1/\\lambda$ has a simple interpretation, and since $\\mathcal{R}_0>1$, we can obtain $\\beta$ by computing $\\mathcal{R}_0\\lambda$. \n", "\n", @@ -565,6 +565,23 @@ "\n", "`DifferentialEquation` is not as fast as compared to Stan's `integrate_ode_bdf`. However, the ease of use of `DifferentialEquation` will allow practioners to get up and running much quicker with Bayesian estimation for ODEs than Stan (which has a steep learning curve). " ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# References\n", + "\n", + "1. Earn, D. J., et al. Mathematical epidemiology. Berlin: Springer, 2008.\n", + "2. Britton, Nicholas F. Essential mathematical biology. Springer Science & Business Media, 2012.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From cd04ca409ff22f188f8ac86e6c3eaa042301f630 Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Fri, 2 Aug 2019 18:10:59 -0400 Subject: [PATCH 37/45] An errant / might be cause of formatting issue --- .../notebooks/bayesian_estimation_of_ode_parameters.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb index a1c17154f01..be6a597e063 100644 --- a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb +++ b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb @@ -412,7 +412,7 @@ "\n", "$$ \\dfrac{dI}{d\\tau} = \\dfrac{dt}{d\\tau} \\dfrac{dI}{dt} = \\dfrac{1}{\\lambda}\\dfrac{dI}{dt} = \\dfrac{\\beta}{\\lambda}SI - I$$\n", "\n", - "The quantity $\\beta/\\lambda$ has a very special name. We call it *The R-Nought* (\\$\\mathcal{R}_0$). It's interpretation is that if we were to drop a single infected person into a population of suceptible individuals, we would expect $\\mathcal{R}_0$ new infections. If $\\mathcal{R}_0>1$, then an epidemic will take place. If $\\mathcal{R}_0\\leq1$ then there will be no epidemic (note, we can show this more rigoursly by studying eigenvalues of the system's Jacobain. For more, see [2]).\n", + "The quantity $\\beta/\\lambda$ has a very special name. We call it *The R-Nought* ($\\mathcal{R}_0$). It's interpretation is that if we were to drop a single infected person into a population of suceptible individuals, we would expect $\\mathcal{R}_0$ new infections. If $\\mathcal{R}_0>1$, then an epidemic will take place. If $\\mathcal{R}_0\\leq1$ then there will be no epidemic (note, we can show this more rigoursly by studying eigenvalues of the system's Jacobain. For more, see [2]).\n", "\n", "This non-dimensionalization is important because it gives us information about the parameters. If we see an epidemic has occured, then we know that $\\mathcal{R}_0>1$ which means $\\beta> \\lambda$. Furthermore, it might be hard to place a prior on $\\beta$ because of beta's interpretation. But since we $1/\\lambda$ has a simple interpretation, and since $\\mathcal{R}_0>1$, we can obtain $\\beta$ by computing $\\mathcal{R}_0\\lambda$. \n", "\n", From 84ae5c88f0d6c692690a4ec569f5fece4bf704e0 Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Fri, 2 Aug 2019 20:09:00 -0400 Subject: [PATCH 38/45] added a word to SIR example. --- .../notebooks/bayesian_estimation_of_ode_parameters.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb index be6a597e063..6d282f9aa7a 100644 --- a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb +++ b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb @@ -414,7 +414,7 @@ "\n", "The quantity $\\beta/\\lambda$ has a very special name. We call it *The R-Nought* ($\\mathcal{R}_0$). It's interpretation is that if we were to drop a single infected person into a population of suceptible individuals, we would expect $\\mathcal{R}_0$ new infections. If $\\mathcal{R}_0>1$, then an epidemic will take place. If $\\mathcal{R}_0\\leq1$ then there will be no epidemic (note, we can show this more rigoursly by studying eigenvalues of the system's Jacobain. For more, see [2]).\n", "\n", - "This non-dimensionalization is important because it gives us information about the parameters. If we see an epidemic has occured, then we know that $\\mathcal{R}_0>1$ which means $\\beta> \\lambda$. Furthermore, it might be hard to place a prior on $\\beta$ because of beta's interpretation. But since we $1/\\lambda$ has a simple interpretation, and since $\\mathcal{R}_0>1$, we can obtain $\\beta$ by computing $\\mathcal{R}_0\\lambda$. \n", + "This non-dimensionalization is important because it gives us information about the parameters. If we see an epidemic has occured, then we know that $\\mathcal{R}_0>1$ which means $\\beta> \\lambda$. Furthermore, it might be hard to place a prior on $\\beta$ because of beta's interpretation. But since $1/\\lambda$ has a simple interpretation, and since $\\mathcal{R}_0>1$, we can obtain $\\beta$ by computing $\\mathcal{R}_0\\lambda$. \n", "\n", "Side note: I'm going to choose a likelihood which certainly violates these constraints, just for exposition on how to use `DifferentialEquation`. In reality, a likelihood which respects these constraints should be chosen.\n" ] From 8ec0b385ad75aab2779415d02b6d8afed1c615bc Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Fri, 2 Aug 2019 20:09:00 -0400 Subject: [PATCH 39/45] Add tests, edit notebook --- ...ayesian_estimation_of_ode_parameters.ipynb | 61 ++++++++----------- pymc3/ode/ode.py | 18 +----- pymc3/tests/test_ode.py | 23 ++++++- 3 files changed, 51 insertions(+), 51 deletions(-) diff --git a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb index 6d282f9aa7a..b9802665ee9 100644 --- a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb +++ b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb @@ -5,13 +5,6 @@ "execution_count": 1, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING (theano.configdefaults): install mkl with `conda install mkl-service`: No module named 'mkl'\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -44,7 +37,7 @@ "Ordinary differential equations (ODEs) are a convenient mathematical framework for modelling the temporal dynamics of a system in disciplines from engineering to ecology. Though most analyses focus on bifurcations and stability of fixed points, parameter and uncertainty estimates are more salient in systems of practical interest, such as population pharmacokinetics and pharmacodynamics.\n", "\n", "\n", - "Both parameter estimation and uncertainty propagation are handled elegantly by the Bayesian framework. In this notebook, I showcase how pyMC3 can be used to do inference for differential equations using the `ode` submodual. \n", + "Both parameter estimation and uncertainty propagation are handled elegantly by the Bayesian framework. In this notebook, I showcase how PyMC3 can be used to do inference for differential equations using the `ode` submodual. \n", "\n", "\n", "# Catching Up On Differential Equations\n", @@ -156,8 +149,8 @@ "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [gamma, sigma]\n", - "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [01:52<00:00, 53.56draws/s]\n", - "100%|██████████| 4000/4000 [00:37<00:00, 107.10it/s]\n" + "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [02:38<00:00, 37.85draws/s]\n", + "100%|██████████| 4000/4000 [00:49<00:00, 80.09it/s]\n" ] } ], @@ -196,7 +189,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -233,8 +226,8 @@ "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [g, gamma, sigma]\n", - "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [08:11<00:00, 4.68draws/s]\n", - "100%|██████████| 4000/4000 [00:38<00:00, 103.13it/s]\n" + "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [09:09<00:00, 5.60draws/s]\n", + "100%|██████████| 4000/4000 [00:38<00:00, 102.66it/s]\n" ] } ], @@ -269,9 +262,9 @@ { "data": { "text/plain": [ - "array([,\n", - " ,\n", - " ],\n", + "array([,\n", + " ,\n", + " ],\n", " dtype=object)" ] }, @@ -281,7 +274,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -293,7 +286,7 @@ } ], "source": [ - "az.plot_posterior(data)" + "az.plot_posterior(data);" ] }, { @@ -322,10 +315,10 @@ "NUTS: [y0, g, gamma, sigma]\n", "Sampling 2 chains, 0 divergences: 0%| | 0/6000 [00:00" ] @@ -421,22 +414,22 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 15, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAD0CAYAAAC7KMweAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3deXxcd33v/9dZZtWMNNoly7ZkeTl24thO4iVO4oQQSDAQSCi3LVAucFnKI6WFQktD7oX213Ip5TY/LoWm3NLCpfxouWyBkItDQkKIk9iO48SxHdvHm2TZlrVvM1pmOef8/hjJkeyRNZJGmu3zfDz8sHRmOd+vNHrPd77nuyiO4yCEECJ/qNkugBBCiNmR4BZCiDwjwS2EEHlGglsIIfKMBLcQQuQZCW4hhMgz+mKcpLs7POcxh4GAh0gkmsni5BWpv9Rf6l+c9a+uDirT3ZbzLW5d17JdhKyS+kv9i1mx1386OR/cQgghppLgFkKIPCPBLYQQeUaCWwgh8owEtxBC5JlFGQ6YDbuOdfLw7lY6w1Fqgx7u39HEznW12S6WEELMW0EG965jnXzpiZOMJWwAOsJRvvTESQAJbyFE3ivIrpKHd7deCu0JYwmbh3e3ZqdAQgiRQQUZ3J3h1DOtpjsuhBD5pCCDuzbomdVxIYRIV09PD3/5l5/jwx9+P7//++/ij//4DwGIRsf4xCc+hmVZAHR1dfLUU08AEI/H+aM/+iiJRCIjZSjI4L5/RxNefWrVvLrK/TuaslMgIUTB+Ju/+QK33XYH//qv3+MHP/gpn/rUnwPw2GOPctttd6BpyWn6Bw7sxzSPA+Byubjxxi08/fSTGSlDQQb3znW1PHjXauqCHhSgLujhwbtWy4VJIcS8WJbFwYMH2LTphkvHVq5cBcCTTz7Ojh23A/Dqqwf5+te/yjPPPMUHP/heLlw4z44db+CJJ3ZlpBwFOaoEkuEtQS1EYTrRFcHsimT0OY2aAGtqAle9j6Zp3HjjVj74wfeyY8ftvOUtb2PDhk3E43Ha2y9QX78EgI0bN7F27TV84hOfpLk5GeyWZXH8+NGMlLUgW9xCCLFQHnroH/jiF79CIBDgM5/5E5599hkGBwcIBKaG/rlzZ1m+vOnS95qmoesuRkaG512Ggm1xCyEK15o0WscLRVEUNm7cxMaNmwiHw5w+fZJNm24gFotdus/AwAAlJQF0fWrExuMx3O75D5KQFrcQQqRp3749xONxAPr7+zh06CBbtmyjtLQU27aJRpNDjjs62qmqqpry2MHBAcrKQleE+VxIcAshRJqeeeYp3ve+d/OBD7yHz372U3zkIx9n/foNAGzZso1Dhw4CsHx5E4ODA7z//b/L4cOvAvDyyy+xffutGSmHdJUIIUSa/uIv/tu0t73rXb/LD3/4fbZs2Ybf7+db3/q3Kbc/+eSv+PjHP5GRckiLWwghMsAw1nL99ZsvTcCZLB6Ps2PH7Sxf3piRc0mLWwghMuTtb39nyuMul4udO9+esfOk1eI2DGObYRjPpDh+j2EY+w3D2GMYxkczViohhBDTmjG4DcP4LPAvgPey4y7gq8BdwO3AxwzDkBkvQgixwNJpcZ8G3pXi+DrglGma/aZpxoDngNsyWTghhBBXmrGP2zTNnxiG0ZTiplJgcNL3YaAs1XMEAh50XZtTATVNJRTyz+mxhUDqL/WX+hdv/aczn4uTQ0Bw0vdBYCDVHSORua2Dvb+tH0vTcDs2FT43Ib+LUq+Oqihzer58FAr5GRgYyXYxskbqL/Uv1vpXVwenvW0+wX0MWG0YRgUQIdlN8vfzeL4r2DZcjIzRPekXp6kKIZ+Lcp+LkN9VtIEuhChesw5uwzDeCwRM0/xnwzA+DfyKZF/5t03TvJDJwm1rKicU8tPVE2FgNE7/SJz+0Rj9o3E6wlFO9by+WMvkQC/3uy8Fe5lXR5FAF0IUEMVxnAU/SXd3eM4nudpHpVjCnhLofSNxBkbjRKKv7zJR4tZprvLTXFlCTcCddyFezB8VQeov9c+9+v/sZz/hxInjfPKTn+Ezn/kTvva1f0LTNLq6Ojl8+FXuvPMu4vE4n/rU/Xzta/8057VJqquD04ZVXk/AcesqNUEPNZdtSRZL2PSPxukbidHWN8prF8Mcbh8i4NFprkyGeHUehrgQIvvOnDnFypWrU+5409JyhjvvvGvKjjd33bUz42UoyCnvbl2lNuhhXW2Qu9fV8P4ty3jDqioq/G6OXAzzs8MX+Y+XL7CvtZ/uSJTF+NQhhCgMp0+fYuXKVYu6483l8rrFnS6Prl5av3csbnG2f5QzvcMcujjEq+2DBL0umiv9rKz0U1kiLXEhcp3WcxS9+0hGnzNRvR6r6poZ73fmzGkaG5sWdcebyxVFcE/mdWkYNQGMiRDvG+V07zCH2od49cIgpeMh3lxVQqXfJSEuhLiks7MDn8+HZVmz2vHG7y/JaDmKLrgn87o0jNoARm0yxFv7RjjTO8Kr7UMcvDBImdfFdUtKWVcbkAAXIodYVdek1TrOtGT/9ircbs+i7nhzuaIO7sm8Lo21tUHW1gYZHQ/xE10RnjvTy6nuYW5bWUnI78p2MYUQWXTq1Cmam1dN2fHG4/Es+I43lyvIi5Pz5XNprKsN8o71ddy+sor+0Tg/frWdl88PYNlyIVOIYjUxogQWd8eby+X1OO7FMhKzeKGljzO9w1T43dy2svKKIYgLJRfqn01Sf6l/rtbfNI/zwx9+n89//m9S3v7gg3/Oxz/+iTlvnnC1cdzS4k6D363xJqOau9bWEE3Y/PxwB3ta+4hbdraLJoTIksXc8eZy0uKepWjCZn9bP0c7wgQ8OjuaK1lW7luw8+Va/Reb1F/qX6z1lxZ3Bnl0lVubK3nH+jp0VWHXsU5+c7KHsfiV77pCCLEQJLjnqK7Uy7s2LuH6pWWc6hnmRwfbOdU9LLMwhRALToJ7HnRVYcvyct61oZ6AR+fpk908frxryiJXQgiRaRLcGVBZ4uad19WxvamCi4NRfnSwndcuDmFL61sIsQAkuDNEVRSuW1LKf9q0hNqgh+db+vjFkQ4GRuPZLpoQosBIcGdY0Kuzc10Nd6yuYmA0wWOvdRIek64TIUTmSHAvAEVRWF0d4O3X1pKwbHYd65RRJ0KIjJHgXkCVJW7uXldDOJrg8WNdMmFHCJEREtwLrL7UyxtXV9MdifHUiR5Z60QIMW8S3ItgRaWfW5oraOsfYffpXhnrLYSYF1nWdZFcU5dcLvbAuQF8bo1tjeXZLpIQIk9JcC+iG5aWMRKzePXCICVujfX1pdkukhAiD0lwLyJFUbiluYLRuMWeln68Lo1VVZnd0kgIUfikj3uRqYrCG9dUU1vq4ZmTPZwfGM12kYQQeUaCOwt0VeHutTWU+Vw8aXbTE4lmu0hCiDwiwZ0lHl1l57oaPLrKrmNdDMrUeCFEmiS4syjg0XnrulocB3Yd62IkJrMrhRAzk+DOspDfxd3rahiJWTx+rJNYQmZXCiGuToI7B9QGPdy5porekThPmt0yu1IIcVUzDgc0DEMFHgY2AlHgI6Zpnpp0+2eA9wI28CXTNB9ZoLIuql3HOnl4dyud4Si1QQ/372hi57raBTtfY4Wf21ZW8ttTPfz2VA93rK5CUabdck4IUcTSGcd9L+A1TXO7YRg3AQ8B7wQwDCMEfBJYBZQAB4G8D+5dxzr50hMnGRvvtugIR/nSEycB0g7vuQS/URNgNGbxYltyjPf2JpldKYS4UjpdJbcCjwOYprkX2DzptmHgLMnQLiHZ6s57D+9uvRTaE8YSNg/vbk3r8RPB3xGO4vB68O861jnjYzc2lLK+vpQjF4c41D40h9ILIQpdOi3uUmBw0veWYRi6aZoTuwOcA44CGvC3qZ4gEPCg69qcCqhpKqGQf06PnavOcOpx1Z3haFpl+ebzZ1MG/zefP8t7tq+Y8fE7Q34Ul86rnWGW1ERYXR1Ir+AFKBu//1wi9S/u+k8nneAeAoKTvlcnhfZOoB6YSKNfGYbxvGmaL05+gsg8JpiEQn4GBkbm/Pi5qA166EgR3rVBT1pluTg4Nu3xdOvSOzjCd/ec5eu/OU1NwM0nbluxoH3suSobv/9cIvUv3vpXVwenvS2drpLngbcCjPdxH550Wz8wCkRN0xwDBoDQnEuaI+7f0YRXn/qj8eoq9+9oSuvxtUHPrI5fbtexTv7u16cYGt/yrCsSS7urRQhR+NIJ7keAMcMwXgC+CvypYRifNgzjHaZp7gb2A3sNw9gDnACeXLjiLo6d62p58K7V1AU9KEBd0MODd61Ou8U73+Cfbx+7EKKwKYuxqH93d3jOJ8nXj0rzGU649aFnme4Htv8zt2WukHkgX3//mSL1L976V1cHpx0PLMu6LpCd62rn3Cc9XR97hc8132IJIQqAzJzMQam6WlyqwqZlZbIYlRBCgjsXpepj//M7V7K2JsDzLX2yZ6UQRU66SnLURFfL5D6+IxeHeKGljzO9I6yUnXOEKFrS4s4j19QFqSpxs6e1X1YRFKKISXDnEVVRuLW5ktGYxf5zA9kujhAiSyS480xN0MM1dUGOXgzTLVueCVGUJLjz0OblIbwuld1n+rDlQqUQRUeCOw95dJXtKyroiUQ51hHOdnGEEItMgjtPraz0szTk48W2AYZjiZkfIIQoGBLceUpRFG5eUYHtOOxt7c92cYQQi0iCO4+FfC42NZRxumeY8wOj2S6OEGKRSHDnuY0NZZR5XTx3po+EJWO7hSgGEtx5TlcVbmmuYGgszsELstWZEMVAgrsALA35WFUd4OCFQQZGZBEqIQqdBHeBuKmxHF1VeK6lVxahEqLASXAXCL9bY2tjOe2DY5zqGc52cYQQC0iCu4Csqw1QE/Cwt7WfsbiV7eIIIRaIBHcBURSFW1dWMha32d8mi1AJUagkuAtMVYmb9UuCHO+M0Jli+zMhRP6T4C5ANy4N4XdrPHemVxahEqIASXAXILeucvOKCnqHY7x2URahEqLQSHAXqKYKH0tDPl4+P0hUdssRoqBIcBcoRVHYujxENGFxqH0w28URQmSQBHcBqwp4WFlVwpGLYUZiMjxQiEIhwV3gblwWImE7vHJBWt1CFAo92wUQCyvkc2HUBDjWEWZDfSlBb3q/8l3HOnl4dyud4Si1QQ/372hi57raBS6tECId0uIuAjcsLUNR4KU0d4bfdayTLz1xko5wFAfoCEf50hMn2XWsc2ELKoRIiwR3EQh4dK6tC3Kqe5i+kdiM9394dytjl41EGUvYPLy7dYFKKISYjRk/NxuGoQIPAxuBKPAR0zRPTbp9J/CXgAIcAP7INE2Z9ZFjNjWUcawzwkttA9y1tuaq951uxqXMxBQiN6TT4r4X8JqmuR14AHho4gbDMILA/wDebprmNqAVqFqAcop58ro0NjaU0to3MmMA1wY9szouhFhc6QT3rcDjAKZp7gU2T7rtZuAw8JBhGLuBTtM0uzNeSpER19WX4nNp7G/rv+qa3ffvaMKrT31peHWV+3c0LXAJhRDpSGeIQSkweSyZZRiGbppmgmTr+g5gExABdhuGscc0zROTnyAQ8KDr2pwKqGkqoZB/To8tBJmu/461tTx7spshR6GxPPXzvmf7Ckr8Hh568gQXB8eoL/PymTev4R0bl2SsHOmS37/Uv5jrP510gnsICE76Xh0PbYBeYL9pmh0AhmE8SzLEpwR3JDL3vtFQyM/AwMicH5/vMl3/pSUudMfhqSMXue+6OhRFSXm/2xpD3PaRrVOOZeP3IL9/qX+x1r+6Ojjtbel0lTwPvBXAMIybSHaNTHgZWG8YRpVhGDpwE3B07kUVC01XFW5cFqInEqWlrzj/IITId+kE9yPAmGEYLwBfBf7UMIxPG4bxDtM0u4DPAb8C9gE/NU3zyMIVV2TC6uoSQj43L7UNyLKvQuQhZTE2lu3uDs/5JMX8UQkWrv4tvSM8aXZx+8oqjNpAxp8/U+T3L/Uv1vpXVwdT92MiU94L1kxT1psqfFQHPLx0boCV1SXo6rSvESFEjpGZkwUonSnriqKwtTHEcCzB0Q7ZbEGIfCLBXYDSnbLeUOajoczHwfODxGSzBSHyhgR3AZrNlPUty0OMJSwOXxxa6GIJITJEgrsAzWbKek3Qw4rKEg61DzEal80WhMgHEtwFaLZT1jcvKyNhORyUzRaEyAsS3AVo57paHrxrNXVBDwpQF/Tw4F2rp90IodzvZk1NCUc7wkSiiZT3EULkDhkOWKB2rqud1Y41Ny4LcbJ7mAPnBrh9lSzwKEQukxa3AJKbLVxTF+RE1zADI/FsF0cIcRUS3OKS65eWoWsK+9Pc4kwIkR0S3OISn0tjw5JSWnqH6Z7Hio5CiIUlwS2muK6+FK+usb9NWt1C5CoJbjGFW1fZtLSM8wOjXBgczXZxhBApSHCLK1xTF6TErfPi2YGrbnEmhMgOCW5xheRmC2V0R6Kc7ZNWtxC5RoJbpLSmJkDI52Lf2X4sW1rdQuQSCW6Rkqoo3NRUweBYnNfmsOyr58QjVHx3G1X/uIyK727Dc+KRBSilEMVJgltMa3m5j2XlPg6cG5jVAlSeE48Q/M1n0SIXUHDQIhcI/uazEt5CZIgEt7iq7Y0VJGxnVsMDS/Z8GSUxtW9cSYxSsufLmS6eEEVJgltcVcjvYn19ELMzQk+ak3LUSPusjgshZkeCW8zohqUhvC6VF1r60xoeaAeWzOq4EGJ2JLjFjDy6yublITrCY5zunXnH7eHtD+DovinHHN3H8PYHFqqIQhQVCW6RFqMmQGWJmxfP9pOwrr4/ZXTNfYTv+ApWoAEHBSvQQPiOrxBdc98ilVaIwibrcYu0qIrCzSsq+MWRDl5tH+LGZaGr3j+65j4JaiEWiLS4RdrqS700V5bw6oUh2SlHiCyS4BazclNTOQ4O+872Z7soQhQtCW4xKwGPzqaGMk73DHNxaCzbxRGiKElwi1nbuKSUErfOnpY+bFk9UIhFN+PFScMwVOBhYCMQBT5imuapFPf5v8DPTdP85kIUVOQOXVPZ1lTO0ye6OdEVYW1tMNtFyjjPiUco2fNl1Eg7dmAJw9sfkIutImek0+K+F/CaprkdeAB4KMV9vgiUZ7JgIrtmWiRqZaWfuqCX/W0DRBNXHx6Yb2StFZHr0hkOeCvwOIBpmnsNw9g8+UbDMN4N2BP3EflvIrgm1huZCC7gUqtTURRuXlHOI4c6eOX8ADc1VcztZFYcJTaEGh1EGRtAiQ6ixoZQooMo0SHUYCludwNWaAVWcClo7ozU8WquttaKtLpFLkgnuEuBwUnfW4Zh6KZpJgzDWA+8F3g38IWFKKCYm/l81E83uKoCHtbUBDh8MczamiAhv+vKJ3NslFgkGcjRwfFAnvR1fHjq/VUXtqcMx1OGHVyKo0fRLx5F7zoIqo4VbMAqW4FVtgLHWw6KMuufzUxkrRWR69IJ7iFgciemaprmxCDe/ww0AE8DTUDMMIxW0zSntL4DAQ+6rs2pgJqmEgr55/TYQjCX+itHfoSWosXs97tx1v+nGR9/teC6vCxvus7Nxb1nOdQ9zDs2vr4WyeP7j/LK0/+HwOhFyrwq25srMeqCgALeUpxACCrrwRfC8YbAW5b85yqZEsaqpuJeF4PB8yh9p1H6W6Dr+eQ/bwinYiVORTOULQctxRvHXJQ2wND5lMcX+7Uor//irv900gnu54F7gB8ahnETcHjiBtM0PzvxtWEYfwV0XB7aAJE0V5VLJRTyMzAw8/oYhWou9a946q9TtpiVp/6a/qVvm/nxgSVokQtXHLcDS1KWZV2Vn31n+2kq9bA85GX/vqc49eIuPLbCK84q+kcC/OBYgA/XbeDO9StBTfEmbgMjAFPLHQr5GRiKgVIDlTVQuR0lOog20II22ILWegDO7B1vjS9NtsZD463xOfJs+4spXUWQXGslvO0viC7ya1Fe/8Vb/+rq6S/6pxPcjwBvNgzjBUABPmQYxqeBU6ZpPpqZIopMmu9H/eHtD6QMrukWiVpfX8rxzgivnGplVcmrtL/yIq1WFU/ZNxBhvLWUgP+5t587N8ztk9dkjqeMRO0mErWbwE6ghs+PB3kr7rbfQNtv0IbacJ19BnWsFzvQMKuuoon7yagSkatmDG7TNG3g45cdPp7ifn+VoTKJebKv0mJOx2yDS1PgzmAbnYefoLu8hEdGN/Ga00jyff51neG5f/KalqpjlzVhlzURB5SxAbyHv4Pn5KModjxZvsgFgk//2ZS6zWS+a63IcEKxkGSRqQI02xZzKukGlxIdxN3yBMsH2+gJLef/urfRXTIEkdgV960NetI+/1w53hC+oz+4FNqXymlFCTz7BeJLti34uuDpjMoRYj5k5mQBWpRlVR0HvetVfIf/DXW4k1jzXdRtex/DaglvMqrx6lNfWl5d5f4dTZk7/1VM1yWkRPvxHv0PPOZPUSMXF+z8snWbWGjS4i5QC7msarKV/STa0Fms0kZiK+7C8ZQSAtbXBznSHuaPb1/B9148T2c4Sm3Qw/07mti5rnZBynO5abuKSpYQW7oDV8dLeI/+O1bZCuIN27ED9Rk9vwwnFAtNglukz3HQuw/jOvcsiuMQa3oTieoNU4bv3bA0xMmuYby6xqMf3YqyAOOsZzJtV9HNnyOxZCuJ2o24Og+iTwR4qDkZ4CV1GTn/fK8xCDET6SoRaVGiQ3hO/BR365PYJbWMrn8/iZqNV0yA8egqWxpDdAyNcSaNbc4WwoxdRZqH+JJtjG78CPGlt6BG2vG+9n08J36GOtw57/PL1m1ioUmLW1yd46D3vIar7RkUxybWeGfKwJ7MqAlwtCPMvrP9NJb70LXFbx+k1VWkeYgvuYl4zSZcna+gdxzA+9r/h1W+iviSm7BL5ta1I8MJxUKT4BbTUmLhZF/2YAtWcCmxFXcnZznOYPI2Z69cGGTL8hxff0z3Em/YTrz2+tcDvP8UVvkqYg034/irZ/2UsnWbWEgS3CIlZawf77EfolhRYsvvIFF7/azWBakv9bK6OsDB80PUl3pZGvLN/KBsmxLgL6N3vIyv/3skqq8j1nAzuEuyXUIhAOnjFikosTBe8yfgWIxe814SdTfMaTGnW5srCPldPH2iJ7/2qNS9xBtuZnTjh4nXXo/ecwTf4e+gt78Idh7VQxQsCW4xVXwEz/EfQ2KMqPEuHH/VnJ/Kpam8eU01luPwa7ObhJ1nu+XoPuKNdzC6/gPYwaW4z+/Gd/h/o/WaIDv/iCyS4BavS4ziNX+CGgsTXXNfRobHhfwubl9VSVckyt7WvgwUcvE5vgqia+5lzHg3jubGc/oxvMf+D+pwR7aLJoqUBLdIsmJ4T/wMdbSXsdXvwA42ZOypmytL2LCklKMdYU52RzL2vIvNLmtk7No/INb05uQ1gNe+j/vMLpRYONtFE0VGLk4KsBN4Tj6KOtxBdOXbscuaMn6KrY3ldEVi7D7dR4XfTWXJwu9ksyAUlUTNBhIVa3Bd3I+r4wB630ni9VuI123O3JrgQlyFtLiLnW3hOfUY2tBZoivuxqpYvSCnURWFN62pxq2rPGl25/8+lbqX+LIdjF73QayyFbguvIDv8HfQeo5K/7dYcBLcxcyxcbc8jjZwmljjnVhV1yzo6fxujTetqSIcTfDbUz04BRBwjjdEdPU9jK39PRyXH8+ZXXiP/jtqWNYlEQtHgrtYOQ7u1qfQe48TW7ojuSnBIqgr9XJTYzmtfSMcah9alHMuBrt0KWPXvI/oiregxCJ4j/0H7lOPoUQHZ36wELMkfdzFyHFwnfstevch4ktuIrFk66Kefn19kM5wlBfPDlAVcNNQlgeTc9KhKFjV1zJasfr1/u+B08RrrydevwX0AqmnyDppcRchV/teXB0HSNReT7zh5kU/v6Io3LaykjKfnn+Tc9KhuYkvvYXRDR8iUWHguvgSvkPfRu84IBN4REZIcBcZveMArgsvkKi6ltjyO+Y0IzIT3LrKm41qErbDUye6sfJtck4aHHeQWPNbGF3/fuySOtxtz4xP4DkmFzDFvEhwFxG9+zDutmewytcQW3FX1kJ7QrnfzW0rK+kMR9l7tj+rZVlIjr+aqPE74xN4vHhO/xLva99HHWrLdtFEnpI+7iKh9R7H3fIkVlkT0ZVvBSU33rNXVpXQFYlyuH2I2oCHVdWFu5CTXdbIWOlytN5juC+8gPf4j7DKVhBbtmNOKxAuJNnsOLdJcBcBrf80njO7sIINRFe9A1Qt20WaYuvycrrDMZ493UtFiYsKv3tKcFQUUnAoClbVNYxWrEHvPIirfS++I98jUXUt8aU347iD2S6hbHacB3Kj2SUWjDrUhuf0Y9j+aqJr7s3JmX2aqnCnUYVLU3jyeDfKsWRwaJELKDiXgsNz4pFsFzVzVJ1E/ebkCoR1N6L3HsN36Nu4zj0HibGsFk02O859EtwFTI204z3xc2xPiLE1vwOaJ9tFmlaJW+dNRjVD0QTP794F8SIJDt1HfPntyREo5atxXdw3PgLlZbCtOT+t58QjVHx3G1X/uIyK726b1ZuebHac+yS4C5Qy3IXH/CmOy0/U+B1w5f4Y4vpSL1uXhzgz4uNl58qp94UcHI6njNjKtzJ27R9g+6vxv/JPVP7rBvT/XkHF/946q+Cd6OqY6yeW6TY1ls2Oc4cEdwFSxvqTGyFobsbWvhvHHch2kdK2YUkpK/0jPGev57wzdS3wYggOu6QWFA332adRY4MogDbcTvDpP8Nj/iSt55hvV4dsdpz7JLgLjBIdxHv8xwDJ4WeesiyXaHYUReHmHW+lTI3xS2sbEccLFFdwlOz9OxQrOuWYYkUJPPsF9O7DM3ahzLerI7rmPsJ3fAUr0ICDghVoIHzHV+TCZA6RUSWFJDacDG0rytja38XxVWS7RHPirLuP2xMKv3huH4/EbuWe0hbUWz5VNMExXcAqsUHcLU/gat9HvH4LiaprQb3yT9gOLEGLXEh5PF2y2XFuk+AuFIlRvOaPUeIjjBm/g1NSk+0SzUvgunvZsexunjs7wLdjCe6uryG/a5S+aYO3ZAnRNffhat+Lu/XXyQCv20yi+ropo4WGtz8wZTgfFNcnlmKgzHPOzT0AABT8SURBVLS0pmEYKvAwsBGIAh8xTfPUpNv/FPj98W9/aZrm/3P5c3R3h+c8vzcU8jMwMDLXh+e9tOpvRfEe/zHqSDdja+7DLmtcnMItAsul88N9ZxmJJbhjdRXNlYU7QWfC5eOoIRm8l7orHAd1qA1X+1608HkcV0kywGs2gOa+9ByFMIGmmP/+q6uD005tTqfFfS/gNU1zu2EYNwEPAe8EMAyjGXgfsA2wgecMw3jENM1D8y+2SIsVx3Pi56gjXURXvaOgQhugssTNvdfV8cTxLn5tdrNleYJNDaUoWZ6uv5AmAnba4FUU7LJGomWNqEPncLXvw33ut7guvpgM8NqN0tVR4NIJ7luBxwFM09xrGMbmSbedA95imqYFYBiGC8ju7IFiYlt4Tj+GFj5PdOVOrPKV2S7RgvC5NN52bR3Pnu5lf1s/A6NxdqysRFcLO7yja+6bscVply4jWroMNdyOq30P7vO7cXXsJ1F7A/Ha60H3LmKpxWJJp6vkX4CfmKa5a/z7NqDZNM3EpPsowP8AgqZp/uHlzzE6GnN0fW7TrDVNxbLyfJureZi2/o6NcvxRlO7j2KvfAvWLsxHCYptcf8dxeLG1n30tvSwJ+Xjb+np87tyavp9ps379D7WjnNuD0nsSNA/Okutx6m8Ab+nCFXIBFfPfv8ulzaurZAiYvICCelloe4FvA2Hg/lRPEIlEUx1OSzH3ccE09Xcc3K1PoncfJrbsdhK+NVCgP6PL62+Ue9GsEL891cN3nxvlLWtrCPlzbxp/psz+9R+Chp0ooRtxt+9DO/kcnHwOq3wV8ZqN2KXLs74q5GwU899/dfX069akE9zPA/cAPxzv4z48ccN4S/vnwNOmaf7dPMsp0uE4uNqeQe8+nNy9pn7zzI/JQ7uOdfLw7lY6w1Fqgx7u39HEznW1AKyqKiHo0XnieBc/O3yRNxnVLA3l/szQxeSU1BBdfQ9KdBC96xB692G8/SexfZUkajaSqLomp5dAEFc3m1ElGwAF+BDwVuAUoAH/Aeyd9JDPmaa5Z/JzyKiSubu8/q4LL+C6sId47Q3El78hr1pP6dp1rJMvPXGSsUk7wXt1lQfvWn0pvAHCYwkeP97FwGicW5srWFeb/ZX1Mi1jr387gdZ3AlfnK6jDHaC6SVRdQ7x2E46vcv7Pv0CK+e//aqNKZgzuTJDgnrvJ9dcvvoT73G9JVK3PiY0QFso9/7yPjvCV3Wt1QQ+/+Ni2KcdiCZunTnZzrn+U65aUsq2xHLWAfi4L8fpXIxfRuw6i950AO4FVupxEzabkxe0cWad9QjH//c93OKDIAXrXoWRoVxjEVry5YEMboDNFaE933K2r3L22hj2t/RxuH2JoNMEb11Th0nIrgHKJHagnFqgntux29O4juLpexXPqURx3kETNBuLVG8Dlz3YxxVVIcOcBrfc47tZfJ3dLad6Zc62iTKsNelK2uGuDqftkVUXhlhUVhLw6L7T08+iRDu5eW0PAIy/vq3L5SSzZSqJ+M9rAGfSug7jOP4/rwl4SFWtI1G7CLqmfUyOhUCYA5Sp5Zee63pPju9csJbrqnpzbvWYh3L+jKWUf9/07mq76uGvrSyn1uvj1iW5+driDu9dWUx2QC3AzUlSs8lVY5atQRvtwdR1E6zmK3nsM219DonItVoWB40lvSKHsoLPwpI87h6lDbYTaHmNEKWNs7buLahTA1UaVzKRvJMbjx7oYi9vc0lzBmuqSvJ1pmbXXvxVD7z2G3vMaauRi8lBwKVblWhLla666vnvFd7elXGvFCjTQ94F9sypGMf/9y8XJPKR3H8bd+hTe8lr6Gu/Ni40QFsJcf/+jcYsnj3fTER6jwu9my/IQy8t9eRfgufD6V8b60ftMtJ5jqGN9yRZ6WVOyJR5aeWl9lAlV/7gMhSv/5B0Uev7o3KzOnQv1zxa5OJlPrDjus0+j9xzBKmvE3vhuGM52ofKPz6Vxz/paTveO8FLbAL863kVt0MPWxnLqS2Ua+Gw43nLiS24iXr8NZaQbve84eu9xPANnQHWRKF+JVbkOq7QRVC0jy8qKq5PgziHK2ACeU4+hjnQm/1AatuNz+YHibHHMl6IorKoqYUWFnxPdEQ6cG+QXRzpYGvKxdXmIKun/nh1FwSmpIV5SQ3zpDtTwBfS+42h9JnrvcRzdh1WxhpFNHyOw529RrNeXLZJlZTNLukpyhDZwBveZXeA4xJpfXzCqWOo/nUzWP2HZvNYR5uCFIaIJi+bKEjYvDxHy5e6U+bz4/dsW2tBZtN5j6P2nwY6jDbbiansWdawXu2QJwzd/bk4XJvOi/gtEukpymWPjurAHV/s+bH810VVvx/GWZ7tUBUnXVDY2lLG2Nsjh9iEOXxyipW+ENdUBblxWJsMH50rVsELNWKFmYlYMbeA0eu9xrFAzODaOqwRH96P1ncAqXS4rFmaAvFKzKT6K58wv0QZbSVRdS6zxzik7mYiF4dFVNi8PcU1dkFcuDHKsI8ypngjX1gXZ1FCG11X4Qy4XjOZO9ndXroP4KNpgC9rAGbT+k+g9R5IXNgMNWKEVWGUrktPt8+yCcS6QrpIsUYc78Jx6DCUWIdZ4B4nqDVNewDKBIWkxfv/hsQQHzg1wsnsYXVPYsKSU6+pLcevZn+hUMK9/x0aNXEyG+GAL6kh38rCnDKtsRTLIg0sLbgef+ZDhgDlG7z6M++zTOLqf6Kq3Ywfqp9w+49ZVRWQxf//9IzH2tw3Q2jeCz6WxqaGMdXXBrG7YUIivfwAlFkYbaEm2yAfbwI6BqmMFl6INteE/8I9XXNwstte/BHeumDzUr7SR6Mq3pRyfnckJDPkuG7//rnCU/W0DXBgcxa2pNFX4WVHppyHkW/QQL6jX/3TsBGr4wni3Sgsle7+CGg9fcbdie/3LxckckGqo33RrjqiR9lkdF1eaz8zLmqAHVYVHDnXQMxwj4NYu9Yk3lvtYUVnCspAXXRayygxVxy5rxC5rJL78DQR2fz713SIXcJ95HDvYgBVoSF7En6Z/vNC7WiS4F8iUF46/hviSbSSqriG6+t4Z94aUCQzzc/l63h3hKF964iRAWuF9+eMjMYsXWvpYUuZFUxRO9Qzj0lSWhXysqPSzvNwnqxFmkB1oSPn6dzzlycWwel5Lfq/7kyEebMAOLMEuqQVFLYq1UiS4F8AVL5yRTtQzu4gtvTmtDX2Htz+Qso9bJjCk5+HdrVMWqAIYS9g8vLs1reBO9fiY5fD0iR5+/tGttA+O0dI7QmvfCGd6h9FUZVKI+/Ho6rxa/MVuutd/5La/Jrr6XpSxfrTIhWT3Svg8Wn/yTRnVjRWop+T5L055LICSGKVkz5cluMX0Sl742ytfOHackpe+TvTaP5jx8RMvrkL+qLeQZrOe92wfryoKS0M+loZ83NJcQWc4ypnekUtBrioKvcMxHj3SQcxKXtqZbYu/2M30+nd8FSR8FVB9HQBKLHIpxNVIO+pYT8rnVSMXwIpdsbZKPpLgziTHQRs4jTo8/z7q6Jr7iK65rzguTmXYbNfznuvjVUWhvtRLfamXm5vK6QxHaekb4b8+duxSaE8YS9h849kW3rK2Ju8WusqG2bz+HXcAq9LAqjQA8L/0dbQUf4OOK4j/wDewveXY/mrsktrk//7aKwYJ5HofuQR3JtgWWu9xXB37UUd7cdxlKLHBK+8mfdSLYq7rec/n8YqiUFfqpa7USzhqpbxPVyTGv+0/T3XAnfxX4qEq4JYZmxk2fPPnruxq0byMbPkkiZoNqCPdaJGL6H3m67e7g9j+Gmx/NXr3IUr2PXRpOGIu9pHLK2Y+rBh692FcHQdQYuHklPWVb8UqayL4zAPSR50lE90Rc+1jnu/j66ZpsVf6XTRV+OkZjnLwwhATQ3H9bp3qEjfVwWSYVwfcMntzHtLuaoyPoo50oY50o450oo504xo4g+/gt6aMIYfxPvLnv0hs+R04nrKsz/aUcdxzER/F1fkyetdBlMQYVnAZifrNWGUrLv1CM/VRKyfrv4jysf7p7FKfsGx6hmN0R2J0D8foiUQZGI1fuv/5gTH2tPQxMJag0u/iQzct453r6/HoalF1tSz679+KU/XNFaT6CTvAyJY/TQ5f9JZjeytwvOXY3nIcXwW2tzyjm53IOO45SBW8scY34uo4gN59BOw4Vvkq4vVbUnaBTPTRieKTTotd19RLXSsTogmbnuEovzjSwa/NbuJ2sr3TOxLnq785w0ttg1xbF6TUqxP0uij16JT6dIIenVKvTsCjF9QO91mhuaYdjmj7a4mtuAtltA91rA9tuBOl7wRM2jTCcQWwfRXJ9crNn6KOdmMHGjLeRy4t7hRSTjlX3USb3oRVdQ2JynXE6zcnF8hZYPnY4sykYqz/Pf+8L2VXS4XfxRfuNhgcixMeSxCOJrAn/f0qinIpxE90Rdh1tIu+0ThVJW4+fNMy3n5t3aK12DM1HDJn/v6nm3JvJ1Cig6jjYa6M9eFufRqv+SMUOzHz469CWtyzVLLnyymG88Vwte8jcudDOO5glkomisF0wxH7R+Lc0lxx6XvbcRiJWQyNJRgaizM0HuYvtPTxy6NdJMZb7D3DMf7+6dPsOzuAURPA59LwuTV8LhW/S8Pr0vC7tPHj6qWv5xry850ANfEc2RoHP6vhuKqO46vE8lUycUk6sPuvpoQ2ZH4cuQT3BCuOOnwRbehccrxnCupYn4S2WHCzGY4Y8CS7SJaUvd7l8j+fOXMptCdYDhxqH+Ldm5YwGrMYTViMxiz6huOMxC0u/+R9snuYl9oGiMQsgh6dN66p5IalITy6iltTcesqnvH/J3/t0VS+8WzLvCZA5ULwz6erczGWrCjY4J7x4qAVR420J2deDZ1DHe4AxwIUHE8IJTpwxXPKcD6xGOY7nPFqLfZtjVdu0uE4DtGEzWjcYiRu8aTZzQstfZfGooejCX75WheOA2uqA8Qsm2jCntJNM1lXJJbyeEc4ymOvdeBSVXRNQVdVXJqCriq4tNe//tozZ1IG/zeebeENq6rQFAVNVVAVUn4iyHbwD3tqCUQ7Uh7PlIIM7pRrFTz95ygj3ViV16CFz6EOdyaDWlGTa4nU3YAdXIoVTC7yLlPORbbMdzjibCcgKYqCd7zLpBz4ycGLV0wgitsOL54d4PN3Jye5OI6DZTtELZtYwiZmOcQSNlHL5qevXqR3JH7Fecq8OrYNkUSChOUQtx0Slk3cdqa0+FM9FpJvCN/b//ou8QrJAJ/yT1H4X8+nXvLg/336NH6XhqooqKqCpiQ/tSTfBJJvBJqqsLe1n+/sa5sy8/WLvzpB73CMN6yqunTfif8VJXleZfzYQ7H38mf2PxNQorhJoCoOI46br8R/jz9OWbPZK8jgTjnl3Bqj5MWvMnr9x7BLaonX3XhpgZrLh/DIlHORbTvX1bJzXe2cLs4tVIt98nFFUZKtZk2l5LIZ5J98Q3PK83/mjStTvvk4joPlJIdIJmyHnx/qoGv4ylZ7pd/FLc2VWLYz5V9i/J81/mYyFE1c8ViAgbEE5wfGsMfvZztgOc4V3UT/fuDCFW9cMcvhX/a0MRJLPblqsh+MbuZlarhFfY3r1Ba2qsf5SuJ3+UV0W5EHtxVFiQ6hRodQooMosYmvh5JfTzPlXImHGbnh/rTGWspwPpGvFrvFPt/zK4qCroCuJicdfeL2FSmD/5NvaObaupmvMf3Db8+kLH9d0MP7Ni+94vjEG4dtO9iOw7f2tKV83uGYxT3r67AdB8cBy07+b5N8E7DHv//pqxc5MbKcE/ZymNTwr0vz55eOGYPbMAwVeBjYCESBj5imeWrS7R8F/hBIAF80TfOxTBVOGelGGe7G1ds1KZgHURJTZzWh6tjuUhxPKXagDttXhTZ65UIzduDK1rUQhWiixT4X822xz/f8833jmW35J944GN8kY7qZr3VBD/WlM290PN0njtn8/GaSTov7XsBrmuZ2wzBuAh4C3glgGEYd8CfAZsALPGcYxpOmaaa3DNsMPGd2odgDuGJge0px3KXYgfpLXzueUmxPGei+KVNQh2/9S+mjFmKO5hucmSrDXLuKFjv4M33+dKQT3LcCjwOYprnXMIzNk27bCjw/HtRRwzBOARuA/Zko3Ni638MbdDMyzKzWBpA+aiHmZz4t5lyQzRb/fM+fjnSCuxSYvNSdZRiGbppmIsVtYaDs8icIBDzo+lwWzfGjaSohtz3zXS+39X3YW993qYvJN/4v32iaSijkz3YxskbqL/XPRv3fs30F79m+YtHPm650gnsImHxFQB0P7VS3BYErBkBHInPvOSnGKc+TSf2l/lL/4qx/dfX0F2LT2SjveeCtAON93Icn3fYisMMwDK9hGGXAOuDI3IsqhBBiJum0uB8B3mwYxguAAnzIMIxPA6dM03zUMIx/AHaTfBP4r6Zpjl3luYQQQsyTrA6Y46T+Un+pf3HW/2qrA6bTVSKEECKHSHALIUSekeAWQog8syh93EIIITJHWtxCCJFnJLiFECLPSHALIUSeycn1uGdaSrZYGIaxDfg70zTfkO2yLCbDMFzAt4EmwENyueBHs1qoRWYYhgZ8CzAAB/i4aZpFNSvZMIwa4ADwZtM0j2e7PLkkV1vcl5aSBR4guZRsUTEM47PAv5BcLrfY/AHQa5rmDuAtwDeyXJ5suAfANM1bgP8G/PfsFmdxjb95/y9gdKb7FqNcDe4pS8mSXO+72JwG3pXtQmTJj4DPj3+tkNyko6iYpvkz4GPj3zaSYvG2Avf3wDeBzG2NXkByNbhTLiWbrcJkg2maPwFS75pa4EzTjJimGTYMIwj8mGSLs+iYppkwDOO7wNeB72e7PIvFMIwPAt2maf4q22XJVbka3FdbSlYUAcMwlgG/Ab5nmua/Z7s82WKa5geANcC3DMMoyXZ5Fsl/Ibmw3TPAJuDfxnfbEuNytRX7PMk+vh+mWEpWFDjDMGqBJ4BPmKb5VLbLkw2GYbwfWGqa5t8CIyS3nZ3DjiL5xzTN2ya+Hg/vj5um2ZG9EuWeXA3uK5aSzXJ5xOJ6ECgHPm8YxkRf907TNIvpQtVPge8YhvEs4AI+VWT1F1chU96FECLP5GoftxBCiGlIcAshRJ6R4BZCiDwjwS2EEHlGglsIIfKMBLcQQuQZCW4hhMgzEtxCCJFn/n9ydWg955JUUwAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -472,7 +465,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -483,8 +476,8 @@ "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [lambda, R0, sigma]\n", - "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [19:52<00:00, 3.53draws/s] \n", - "100%|██████████| 4000/4000 [02:19<00:00, 28.76it/s]\n" + "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [26:49<00:00, 1.84draws/s] \n", + "100%|██████████| 4000/4000 [02:21<00:00, 28.20it/s]\n" ] } ], @@ -517,23 +510,23 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "data = az.from_pymc3(trace = trace,\n", " prior = prior,\n", - " posterior_predictive = posterior_predictive)" + " posterior_pypredictive = posterior_predictive)" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABdoAAAKeCAYAAACyHKnKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeXhU5d3/8fdMZrJvZJmsrAkcQsIOguKCK4vgXmm1aq1L21+rT11r1VZttY99tK11q8ujVq1V62NFUEFtETcEURAIIYcAIfu+78tkfn8EqCAgkGTOJPN5XVcuZeZk5pMbzT3ne+7zvW0ejwcRERERERERERERETk2dqsDiIiIiIiIiIiIiIgMZiq0i4iIiIiIiIiIiIj0gQrtIiIiIiIiIiIiIiJ9oEK7iIiIiIiIiIiIiEgfqNAuIiIiIiIiIiIiItIHKrSLiIiIiIiIiIiIiPSBCu0ig5hhGB7DMG62OoeIiIgcOc3fIiIiIiJDj8PqACLSJ8cDBVaHEBERkaOi+VtEREREZIixeTweqzOIiIiIiIiIiIiIiAxaWtEu4uMMw5gFPABMBbqAfwM3m6ZZYBiGB7jFNM0H9xx7KvB7YCKwC7gReBu42jTNvxqGcTewCHgY+DWQAnwKXAacA9wBRAHLgWtN02zd87oGcC8wd8/zpcAzwL2maepqnYiIyAE0f4uIiIiI+Bf1aBfxYYZhRAHvACXAucA1wDTglYMcOxFYAVQAFwB/Bf4BBBx4KPAL4BbgamA28CHwQ+AnwF3AJcB/7XndcGA1EAtcAZwNrAJ+Q+9Jv4iIiHyN5m8REREREf+jFe0ivi0DiAEeNk3zMwDDMKqB0wzDOPBC2W1AMXC+aZrdwArDMHqABw84Lhz4oWma6/a83iLgu8Ao0zQL9jx2ITBrz/EGsANYYppm1Z7n/w2cD5xC7+o5ERER+Q/N3yIiIiIifkaFdhHfthWoBZYbhvEKvbeRrzJN80OA3jvC95kLvLbnJH2v1/jmiboH+OJrf64AqvaepO9RA0QDmKb5JXCSYRhOwzAmAOPovQ3eCQT16acTEREZmjR/i4iIiIj4GbWOEfFhpmk2ASfT29f1CnpvQy83DOPWgxweB1Qd8FjFQY5rNU3TfeBjh8thGMYde157K/AQMJbefrO2b/sZRERE/I3mbxERERER/6NCu4iPM01zq2maS+jtsXoG8DHw+z2brH1dCRB/wGMH/vmoGYZxOfBbem9tjzZNc5RpmpfQe6IuIiIiB6H5W0RERETEv6h1jIgPMwxjPvACkLmnv+q/DcPYASwGRhxw+MfA2YZh3GiaZs+ex87thxjHA8WmaT7xtVzT6C0CaEWciIjIATR/i4iIiIj4HxXaRXzb5/SeDP/TMIzfA53Az4F64IMDjr0f+Ap43TCMJ+ntxfrbPc/1cOzWAz82DOPXwIf0bvB2F729YkP78LoiIiJDleZvERERERE/o9YxIj7MNM1aYD7QDrwIvAEEA2eYpll9wLHb6F0pNxp4E7gWuGHP0819iPFX4PfAj+ntMXsd8ADwDDC7D68rIiIyJGn+FhERERHxPzaPx2N1BhHpB4ZhnAE0maa57muPnQW8C0w2TXOzZeFERETkoDR/i4iIiIgMDWodIzJ0zAZuMQzjZsAERgK/AT7SSbqIiIjP0vwtIiIiIjIEqNAuMnTcDwQBtwEpQC29t6r/0spQIiIicliav0VEREREhgC1jhEREREREREREekDwzBWA6cc8LAbqAPWAL8wTTN3z7HDgYeB0+jd0+V54E7TNDu9FlhE+p1WtIuIiIiIiIiIiPTdp8DNX/tzEDAZuAt4zzCMcYAHeA9oAy4DRtC7gXko8DOvphWRfqVCu4iIiIiIiIiISN/Vm6a59oDHPjQMoxV4mt4V7AlAOjDaNM1iAMMw2oAnDMP4rWmaFV5NLCL9xm51ABHxHsMwrjEMI88wjDbDMD4zDON4qzOJiIjItzMM4xzDMJqsziEiIiLH5Otz+BnAhr1F9j2W0rsY9nSvphKRfqUV7SJ+wjCMK4AngN8A64HrgHcNw5hsmma+peFERETkkAzDOAH4G2CzOouIiIgcls0wjK/X2oKBGcB9QCHwEXAPsP3r32SaZo1hGI3AOG8FFZH+pxXtIn7AMAwbvZP5U6Zp3mOa5jvAOUA1cIOl4UREROSgDMMIMgzjVuADoNvqPCIiIvKtFgJdX/tqAt4BcoDTTdNsBiLZf4X7Xk17nhORQUqFdhH/kA6MBJbtfcA0zS7gbWC+VaFERETksBYAvwRuAR6xOIuIiIh8u0+AmXu+rgRqgeXAd0zT3LHnGBu9G6IeTM+AJxSRAaPWMSL+Ye/tZzsOeHwXkGYYRoBpmm4vZxIREZHDW0/vRmn1hmHcbXUYERER+VYNpml+seffvzAMoxD4F9ABXL73GCDiIN8bsec5ERmktKJdxD/svf3swNvTmuj9PRDm3TgiIiLybUzTLDFNs97qHCIiInJsTNNcBTwDXGYYxuI9D+cBY75+nGEYsfSet5veTSgi/UmFdhH/sHfzNN2eJiIiIiIiIuI9v6R3pfofDcMIBP4NzDAMI/Vrx5xHb0/3jyzIJyL9RIV2Ef+w9/azA29PiwDcezZkEREREREREZF+ZJpmNfA7evdOux54GSgFVhqGcb5hGD8FHgaeMk2z3LqkItJXKrSL+Ie8Pf8cc8DjY4DtXs4iIiIiIiIi4k/+DOwG7qS3desZQDHw0p7HHgdusCqciPQPbYYq4h/ygCJ6b0d7D8AwDCdwNvC2hblEREREREREBj3TNOce5rkOYPTXHqoC5g90JhHxLhXaRfyAaZoewzDuBx41DKMO+BT4GRAH/MnScCIiIiIiIiIiIoOcWseI+AnTNB8HbgEuA/4PiAbmmaa5y9JgIiIiIiIiIiIig5zN4/FYnUFEREREREREREREZNDSinYRERERERERERERkT445h7tVVVNQ2YpfHh4EM3NHVbH8Asaa+/RWHuPxto7NM4QHx9h68v3e2Pu1t9T/9J49h+NZf/RWPYfjWX/8dWx7OvcfTBD6Vz8WPnq37dVNB7703jsT+OxP43H/jQe+zvUeBzpfK4V7YDDEWB1BL+hsfYejbX3aKy9Q+M8OOjvqX9pPPuPxrL/aCz7j8ay/2gs/Yv+vven8difxmN/Go/9aTz2p/HYX1/HQ4V2EREREREREREREZE+UKFdRERERERERERERKQPVGgXEREREREREREREekDFdpFRERERERERERERPpAhXYRERERERERERERkT5QoV1EREREREREREREpA9UaBcRERERERERERER6QMV2kVERERERERERERE+kCFdhERERERERERERGRPlChXURERERERERERESkDxxWBxBrlTe288GOGnZUNVNQ24bb4yHUGUBiZBCTk6OYMSKa5Khgq2OKiIjI17R2uvm8oI5P82spbWintctNYICdca5wJiZFMDc9jkCH1lOIiIiIeFtxfRufF9SRW9lMYV0bHd09uHs8xIQG4ooIxHCFMzk5ijFxodhtNqvjikg/UqHdT63bXccz6wrZWNwAQEyok5ExoYQEBNDS6ebDHTUsy64AYNbIaC6cnMzc9FhsmgREREQs097l5uUNJTz/eREtnW7CAgMYExtGeKCDls5u3thcxisbSogJdbJkagqXTE8h2BlgdWwRERGRIc3j8fDBjhpe21jCF0W9dZbIYAejY0IJD3Jgt0FNSyfZZY28sbkcgNiwQE4aE8MZRjwzR0Sr6C4yBKjQ7meK69t4cNVOPs2vJSkyiB/PGcm88S5So0P2O67H42F3bSsf5FXzxuZybl2Ww+TkSG49PZ1xrnCL0ouIiPivzaWN3P7WNiqaOjg5LZbvTktmakoUjoD/rFx393j4orCev28o5i+f7ubtnAp+s8AgMynSwuQiIiIiQ9fu2lYe+PcOPi+sJzkqmB/PGclZhovU6OBvLFb0eDyUNLSzsbiBNfm1vJdbxdIt5QyPDuaCyckszkwgKsRp0U8iIn2lQrsf+XBHNXevNPF44PqTR7Nkasohbyu322yMiQ1jTGwYPzhuBG9vreCRj/O57G8buPr4kVw1e4SutoqIiHjJ8uxy/vtfeSREBPHkkklMS40+6HEBdhuzRg1j1qhhrC+s456V27nq5a+48dQ0Lp6a4uXUIiIiIkPbym2V3PvedpwBNm45LY0LJycTYD90rcRms5EaHUJqdAiLsxLp6O5hVV4Vr39Vxp8/3MUTn+7mTCOeK44bzqiYUC/+JCLSH1Ro9wMej4f/XVvIU2sKyEgI5/7FE46q73qA3cY5ExOZOzaWB1ft5Kk1BWwubeS3C8cTrSutIiIiA+rF9UU8/FE+x42I5neLMo54ldPMEcN4+fLp3L3S5IFVO6lr7eLaE0aqDZyIiIhIH/V4PDz+yW6e/7yIqalR/G5RBnFhgUf9OkEOOwsyEliQkUBeVTOvbyrj7a0VvJNTwYIJCVw9e8Q3OhCIiO/SLll+YG+RfeEEF09/d8oxb24aGezkngUGvzxzLF8W1XPNK19R3tjez2lFRERkr1e/6C2yn2XE8+cLJx71rcQRwQ5+f84EFmcm8L9rC3n4o/wBSioiIiLiHzweD7//1w6e/7yICyYl8dhFE4+pyH6gsfHh3HbGWN685ji+Oy2Ff5lVXPTcF9z33nYqmzr6IbmIDDQV2oe45z8v4qk1BSzKTOCu+QZBh2gVc6RsNtueiWQSVc2dXP3KJnbXtvZTWhEREdnrg7xqfrVsKyeMHsY9Cwwch7kN+XAcdhu/mjeO70xJ5m9fFPPqhpJ+TioiIiLiHzweD3/4YCf/3FzGFccN57Yz0nEG9G9pLSY0kBvmpvHGVTO5YFISb22t4KLn1vPi+iK63T39+l4i0r9UaB/CVudV8+jH+cwbH8+dZ43r157qU1OjePLiyXS5e/jpa5u1sl1ERKQfFdW1cc9Kk4kpUfx+8YT9Njw9FjabjZtOTeOUtFj+uHonH+6o6aekIiIiIv7jr58X8erGUr43LYWfnjhqQFvyxYcHcevp6bx25QymD4/m4Y/yufyljZgVzQP2niLSNyq0D1G7a1u5e6XJhMQIfjXPOOxmHMfKSAjn0Ysm0trl5vrXs2lo6+r39xAREfE3Hd093LY8B4fdxiNLphDsDOiX1w2w27j37PGMT4jgrhW5FNe39cvrioiIiPiDT3bV8JdPdjNvfDw3zB3jtX1vUqND+NP5WTx47gRqW7u44u8befqzAtw9Hq+8v4gcORXah6D2Lje3LsshMMDO7xdn9LldzOGMjQ/nwXMzKW5o46alW+nSbUwiIiJ98vCHu9he1cLdCwyS+3nzq2BnAL9fnIHdZuOOt3M1b4uIiIgcgYLaVu58O5ex8WHcedY4SzaXPyU9jlevmM4Z4+J4ak0B17++hbrWTq/nEJFDU6F9CPrLp7vJr2nltwvHkxh5bBufHo3pw6O5e77BptJGHlq9a8DfT0REZKjaVNLAP74q5bvTUjhxTOyAvEdiZDB3njWWnPImnvh094C8h4iIiMhQ0e3u4c63c3HYbTx4Xma/3W14LKJCnNx7dgZ3njWWr0oa+P6LGzAr1UpGxFeo0D7EbCpp4OUvS7hwchKzRg3z2vueNd7FJdNT+MdXpbyTU+G19xURERkqutw93Pd+HokRQfxkzqgBfa/TxsVzwaQkXlxfzObSxgF9LxEREZHB7Nl1heRWNnPHWeNI8sJixiNx7sQknv3eVACufWUTa/JrLU4kIqBC+5DS3uXmN+9uJzEyiOtOHu3197/u5DFMS43id+/nsbum1evvLyIiMpj97Yti8mtaufX0dEIDB36l1PWnjMYVEcTv3t+uFjIiIiIiB5FT3sSzawtZOMHFqWPjrI6zHyMhnOcumUpKdDA3vpHNu9sqrY4k4vdUaB9C/v5lCYV1bdxx5jjCAh1ef3+H3cZ9Z48n2GHn1yty6dZJu4iIyBGpbOrgmbWFnDY2jpPSBqZlzIHCAh3ceno6O6tbeXF9sVfeU0RERGSw6Hb38Jt3TWLDArn51HSr4xyUKyKIp787mckpUfx6Ra6K7SIWU6F9iKhu6eSvnxcyNz3Wqy1jDhQXHsTtZ41jW0UzT68ttCyHiIjIYPLUmgJ6PB7+65QxXn3fk9NiOWNcHM+sLaC4vs2r7y0iIiLiy17eUMLO6lZ+ccZYIoK9v5jxSIUFOnjogqx9xfZ/b6+yOpKI31KhfYh44tPddLo9XHeyd0/QD+a0sXEsykzgr+sK2Vqmvq8iIiKHs6umheVby/nOlGSSo7zf9/PGU9MIsNt45KN8r7+3iIiIiC8qb2zn6c8KODktlpO9dLdhX4Q4A3jo/CyykiL59Tu5fFXcYHUkEb+kQvsQkFfVzLIt5Vw8JZkRw0KsjgPATaemERcWyH3v56mFjIiIyGE8/vFuQpwBXHncCEvePz48iMtnDmdVXjUbdVImIiIiwp9W76LH01vbGCxCAwP4w3mZJEYGc/ObW9ldq73zRLxNhfYh4Kk1BYQFBXDVbGtO0A8mPMjBzaelk1fVwssbSqyOIyIi4pO2ljfx4c4aLp85nOhQp2U5vj8jFVd4IH9avZMej8eyHCIiIiJW+7KonlV51Vw5a7gldxv2RXSIkz9fkIXdZuOmpVtp7ui2OpKIX1GhfZDbUdXC6h01LJmaQlSIdSfoB3Pq2DhOSYvlyTUFlDSo76uIiMiB/rqukMhgB0umJVuaI9gZwE9PGs22imbey1VfTxEREfFPPR4Pf/5wF67wQC6dnmp1nGOSGh3C/edkUFLfxn3v5eHRIgoRr1GhfZB7dl0hoc4AvjctxeooB3XzaWnYbfDQ6l1WRxEREfEpO6t7L5ZfPCWZsEDrN9ian+FibHwYT39WQHePTshERETE/7yfW8W2imZ+cuIogp0BVsc5ZtNSo/l/J47mX9ureGFtgdVxRPyGCu2D2O6aVv5lVnHRlGSfW82+V2JkMFfOGsHqHTV8XlBndRwRERGf8fznRYQ47SzxkYvldpuNa48fSWFdGytyKqyOIyIiIuJVnd09PP5JPmPjw1iQkWB1nD77/sxUThoTw+/fNdlR3WJ1HBG/oEL7IPb8+iICHXYuneEbJ+iHcsn0VJKjgvnj6p3aGFVERAQoaWjjvdxKzp+URLQPXSw/JT2W8a5w/ndtoeZsERER8StLt5RR2tjB9SePJsBuszpOn9ltNn41bxwRwU7uXmHqs52IF6jQPkjVtnbybm4lizMTiAkNtDrOYQU57PzXyaPZWd3Kq18WWx1HRETEcv/YWAo2G5f4WO9Pm83Gj+aMpLShneVbtapdRERE/EN7l5vn1hUxNSWSWSOHWR2n3wwLDeTeczIxK5t5dl2h1XFEhjwV2geppZvL6XJ7uHiqb69m3+vUsXFMTY3ikVU7aO10Wx1HRETEMm1dbpZll3Pa2DgSIoKsjvMNc0bHMCExghfWF+FWr3YRERHxA//cXEZ1Syc/mjMKm23wr2b/ujMnJLBwgotn1xaSV9VsdRyRIU2F9kGo293D/20qZfbIYYyODbU6zhGx2Wxcd9Joalo6+btWtYuIiB9bkVNBc4ebJVOTrY5yUDabjSuOG05xfTur8qqtjiMiIiIyoNq63Dz/eREzRkQzfXi01XEGxA1z0wgPcvD7f+2gx6OFFCIDRYX2QWhVXjVVzZ0smeabJ+iHMjE5kjMzEvjbF8XUtXZaHUdERMTrPB4Pr24sxXCFMyk50uo4hzQ3PZaRw0J4/vMiPDoZExERkSHsjc1l1LZ28eMTRlodZcBEhzi57uTRbCpt5G21BxQZMCq0D0L/2FhKanQwJ4yOsTrKUbvxjLG07el9JiIi4m++LGpgV00rF09N9unbku02G5fNTMWsbObzgnqr44iIiIgMiG53Dy99UczU1Cgmp0RZHWdALc5KZGJSJA9/lE9je5fVcUSGJBXaB5ndNa1sKm3kgklJ2H34BP1Q0l3hLMpM4PVNpVQ2dVgdR0RExKv+ubmMqGAHZxnxVkf5VgsyEogPD+T59bo4LiIiIkPTu7lVVDZ3csXM4VZHGXB2m41fnJFOQ1sXz6zVxqgiA0GF9kFm+dZyAmywYEKC1VGO2Q9nj8DtgRd04i4iIn6koa2L1TuqmZ/hItgZYHWcbxXosLNkagrrC+vZUdVidRwRERGRftXj8fDC+iLS48I4YfQwq+N4heEKZ3FWAv/YWEpxfZvVcUSGHBXaB5HuHg9v51QyZ0wscWGBVsc5ZilRISzKTOCNzWVa1S4iIn5j5bZKutwezslKtDrKETtvYiJBDjuvbCixOoqIiIhIv/p0Vy27alq5bGaqT7f0628/njMKh93GYx/nWx1FZMhRoX0Q+Sy/lpqWTs7JGryr2ff64azeVe3Pf65V7SIi4h+WZZcz3hXOOFe41VGOWFSIk4UTXKzYVqGNzEVERGRIeWF9EYkRQYOipV9/ig8P4rKZqfxrezWbSxutjiMypDisDiBHbll2OTGhTuYMwk1QD5QcFczizATe2FLGScOaef7ph9m+3SQ+3sUVV1zFggWLjuh1Hnjgd7jdbm677Vf7PX7NNZezbVvOfo8tWnTuN44TERHxBrOime1VLdx6errVUY7ad6el8Mbmcp5++xPyV/3tiOfrysoKHn74j3z55Xo8nh5mzTqe6667kbi43pPZrq4unnrqcd5/fyVNTY2MHz+Bn/zkerKyJnrrRxMRERE/tamkga9KGrnp1DQcAYNrDeqtt/6c1tZWHn30qUMe43a7efrpv7BixXJaW1uZNet4brzxF8TExALw/RnDee2jDdx683V0VewgIiKSs88+h6uu+hF2++AaDxFfov97Bon6ti4+3lXL/AzXoJsEDuXymcNxtzVx+y9+zrhx43n22Ze46KIl3H//b/n887WH/V6Px8P//u8TvPnmPw/6XH7+Ln7963t5882V+76uu+6GgfpRREREDmtZdjmBATbmjR98K6bGxIYxPd7O8r/cTXq6cUTztcfj4ZZbfk5TUxMPP/wEjzzyFDU1Ndx663/m4kcf/ROrVr3PnXfewwsvvEpaWjo33PD/qK6u8taPJiIiIn7qhfXFRAU7OHfi4GnpB7B06eusWfPJtx737LNPsWLFW9x55z08//yLVFZWcscdt+57vrO1CVY/RoPbyU2/e4KbbvoFr7/+Kq+88tJAxhcZ8oZGxdYPrMqrxt3jYWHG4G8bs9fwYSGMbdpCpz2Iq3/yc0aOHMVFF32XefMW8vLLLx7y+0pKirn++h+zdOn/kZDwzUmxtLSE9vZ2srImEhsbt+8rLGzw3KovIiJDR7e7h/fMKk5OiyMy2Gl1nGOSXPsVPY5gpiy68ojm69raGkaNGsVtt93J2LHjGDt2HEuWXML27bk0Nv7nFuUbbriVGTOOIyUllWuv/SltbW1s3ZrtrR9LRERE/NCumhY+2lnDxVOTCRkEG9TvVVxcxFNPPU5W1qTDHtfV1cVrr73Cj370U2bOnM2ECRO4557fsWXLJrZs2QTA66+/yrDICKLnXsnSfDcnnngKS5ZcSnb2Zm/8KCJDllrHDBLv51YyYlgI41xhB33+xBNn8Itf3Mk77yzDNHNJTk7httt+TV6eyYsvPkdzczPHHz+HO+64m8DA3o1UN23ayF/+8gjbt5vExsZx+ulncuWV1xAUFARAXt52nnzyUbKzN9Pe3k5SUjKXX/7DfbeJ/+xn15KVNYmqqgo+/vgjAgICOPPMeVx//U04HA6eeeZJnnvu6YPmXbBgEXfccTfhTYW4Y8ewLLuSS2ekAjB16nT+8If78Xg8B92QJDt7My5XAnfffR933XX7N57ftWsHQUFBJCYmHf1Ai4iI9LN1BfXUt3UxP8M1aOfrhqLtBCaOZWl2BacbLuDw83VsbBz33PPf+/5cWVnBm2/+k4yMCURGRgK9Rfa9WltbeOml5wkPDyczM6ufRl5ERETkP/Z+DnvypVcJKs3ngy9TOSHyLp//HAa9rWDuvfcuLr30coqKCikuPvR+d3l5Jq2tLUydOn3fY0lJySQlJbNp00YmTpzMunWfccoppxI/ezQPrNrB5wX1XHnlNf0xzCJ+TYX2QaC6uYMvixq4+vgRh90J+8knH+O2237FiBEjuPfeu7nllv8iIyOTBx/8M4WFBdxzz51MmTKN88+/iLw8kxtv/BlXXfVj7rzzHioqynnooQeora3h9tvvoq2tjRtv/Blz5pzEU0/9FY8HXnnlb/zP/9zHrFnH7+vr9eqrL3HFFVfx3HMvsWXLJn73u3vIzJzIvHkL+d73LuO88y7cL2NUVAgNDW0EBQUD0NZYQ6LL4O9fFnPx1GScAXbi4uJob2+noaGB6Ojob/yc8+YtZN68hYcch127dhIeHsE999zJV19tICoqioULF3PxxZeo15iIiHjdytxKIoMdnDB6GHB083Vu7jZL5uu99s7X1dWVGCMnsW53HSUNbaREhXzrfL3XL395Ex9//CEREZE8/PAT33j+1Vdf4pFH/oTNZuP22+/a18NdREREpL898cSj1GVeyOnn/ZiKVc/5ZN1kr72fwwBefPE5bDb43vcu43/+577D/oxVVZUAxMe79ns8Li6OysoKAIqKCpk793QKV71I8Mr3+OUHIVy55EIuueRyAgIGzyp/EV+jquMg8P72ajzAWYbrsMctXnweJ554MiNGjGLevIU0NTVy8823MWZMOnPnnk56+jh27doJwMsv/43jjz+RSy65jNTU4UyfPpNbbrmdd95ZTnV1Ne3tbSxZcgk///ktjBgxipEjR3HZZVfS1dVFUVHhvvdMTx/HD35wNSkpqcyffzZpaelkZ28BIDQ0dL/WLbGxccTFxRMbG0d4eG8bl/b2dqaMjKWyuZP3cnt7sjqdvVeOOzs7jmm88vN30dbWxqxZx/PHPz7KBRd8h2eeeeqQV4lFREQGSluXmw93VHP6uDice/ZYOZr5+rnnnrNkvt779fX5OjMlBpsN3txSDhz5fH311T/hqaf+yqRJk7nhhp/uO/nb68QTT+G5517i+9//Afff/1s+++zTfhh5ERERkW8aOeN0uhIyuerMmRXYTXMAACAASURBVD5bNznwc1hu7jZeeeUl7rjjniNaPNje3o7dbsfh2H9trdMZSGdnJ9B7N+ELLzxLoNPBd352Fy1pp/HCi39V3USkj7SifRB4P7eScfFhjIoNPexxqanD9/17SEgIdrudpKTkfY8FBQXR1dX7S3X7dpPi4kLOPPOkfc97PB4ACgrymT59JueffxErV76159gi8vK2A723LO01YsSI/TKEhYXT3d0FwAsvPMuLLz530KxnnbWAW265naCgIJLCHKQFhfLiF0UsnODalzE4OOTwA3MId955D21tbURERACQlpZOc3MzL7zwHD/84bWHvStARESkP320o4a2rh7mjf/PxfKjma9zc7dRUFDgE/N1kL2HE0bHsCy7gmuPH3nE83VaWjoA99zz31xwwdmsWPEWl1/+w33Pp6T0to4bO9Zg+3aTf/zj7xx//JzDvqaIiIjIsdjeGszsScMYFRtKziCom1x//U3ce++vueaan+z3GfJwgoKC6Onpobu7e79ie1dX577PbQEBDtLTx3L99TfR1uVmWbGD+HA3r732Mldf/eMjeh8R+SYV2n1caUM7W8qa+NlJo7/12AOvVtpstkMWlZ1OBwsWLOLSS6/4xnOxsXFUV1fxox9dSXy8izlzTuKEE04iLi6eq6++7IDXCfzG9++deM4770JOO+3M/Z6LjAymsbGdsLDeXvMuVwI1NdVcds5w7l5psmZ3HY3V1YSEhO67enu0HA7HviL7Xmlp6bS2ttDc3PyN50RERAbKytxKXOGBTE2N2vfY0c3XTkvm670OnK8vOD2JG5du5aOdNXQcZr6ura1hw4YvOOOMefseCw4OJiUlhaqqKrq6uliz5pN9G5fvlZaWxpo1WtEuIiIiA6Op08OSqf8prPti3WSvsLAwcnKy2b07nyeeeIQnnngEgM7OTjweD2eeeRIvvvgaiYmJ+32fy5UAQE1NNQkJ/3muurqaE0/sbdEXHx/PmDFpAIQ4A7h4ajLP7I7A2dJCQ0M9UVGHbgsoIoemQruP+yCvGoDTx8V9y5FHZ/ToNHbvzt/vimh29mZeeul5br75l7z//ru0trby2GNP7+vPtW7dZ0f1HpGRUURGRu33WHR0KPX1rfv+PGnSFN55Zzk33RLH45/k8+L6IobnfcHEiZOPuZ/6tdf+gAkTsvj5z2/e91hu7jbi4uJVZBcREa9pbO9i7e46lkxNwX6Md1OlpaVbMl8faO98fcutw3CFB/LG5nISzUPP1+XlZdx99x2kpg5n/PgJADQ3N1NYWMD8+Yuw2+3cd9/d/OAHV3PJJf85Gc3J2cqoUd++uEBERETkWMSEOTlhdMwRHWtV3eTrQkNDeeWVN/Z77MknH6O8vIy77rqXuLhv1orS08cRGhrGV19t2Le/XVlZKWVlpUyePA2AyZOnsm1bzr7vuXhKCi+8WIEzJJyIiMij+hlE5D/Uo93Hrd5Rzdj4MFKjj62NyqFceukV5ORk88gjf6SgYDcbN37JvffeRVNTE7GxcbhcCbS2trB69SrKy8v45JMPeeCB3wHs6+nVHxYtOpf6+joe+uP9LEjxsHH1W7z3/kouvfTyfcc0NjbQ2NhwxK95yimnsmzZP1mx4i1KSop5662lvPTS81x11Y/6LbeIiMi3+XhnLd09Hs4wjv1i+VVXXe1T8/Uf//DfzHW5+XzVssPO1+PHT2Dy5Kncf/+95ORks317Lr/+9W1ERw9jwYJFBAQEcNFFS3jhhWf56KPVFBbu5rHH/kxOTjZXXPHDQ8UQEREROSY55U0AzBoZc8QLIHyhbhIUFExq6vD9vsLCwggKCiI1dfi+OyW//jksMDCQ88+/iMce+zNr164hJyeHu+66nSlTppGVNRGA7373++zcuYOHH/4DxcVFbFr/Mc68VbSPPpHK5v77DCnib7Si3YfVtHSyqaSRa44f2e+vnZaWzgMP/Jmnn/4Lb7zxf4SFhTNnzkn8v//3XwCcdtoZbNu2lYceeoC2tlZSUobzgx9czd/+9ldyc3OYPfuEfskRExPLgw8+wp///AA7VryNMzga4+wfMX36zH3H3H77LQA8+uhTR/Sae3fJfv75Z6msLMflSuS6625k8eLz+iWziIjIkViVV01CRBCZicd+N9W4ceN8cr52BEVx3EU/O+R83bti/QEee+whbr31Bjo7OznuuNk8+uhThIb27jnzwx9eS2BgII888kdqaqoxjPE89NDjjB1r9EtmERERkb3+sbEEgKkpR75a21fqJkfiwLrJNdf8hO7ubn7721/hdrs57rjjufHGX+w7fsyYNB566DEef/xhli5dQnT0MC68+BL+1mTw8oYSbpib5rXsIkOJbW9fqKNVVdV0bN/ogw5sZ+Ir/rm5jP9+P4+/Xz6NsfHH1q/c13zbWD+4agevbypj+bWziAv7Zh8zOXK++t/1UKSx9g6NM8THR/RpN2dvzN36e+rV0tnNWY9/xgWTk7np1GM/UfHV8bxp6Vayyxp569pZOAMGxw2SvjqWg5HGsv9oLPuPr45lX+fugxlK5+LHylf/vq2i8djfgeNR09LJ4qfXcf7EJG45Pd3CZNY4mv8+7lqRywd51Sy/ZhZRIc4BTmYN/f+yP43H/g41Hkc6nw+OMyM/tTqvmtToYNLjwqyO4jXfmZJMd4+HNzaXWR1FRETkmH26q5ZOt4fTx/bvHiu+4oJJSdS2dvHxzhqro4iIiIgc1huby+hye/jO1zZBlYO7bOZw2rp6eO2rUqujiAxKKrT7qOaObtYX1jM3Pe6QO2APRSNjQpk9ahj/3FRGl7vH6jgiIiLH5N/bq4kNC2TSUdyePJjMHjWM+PBAlm+tsDqKiIiIyCF1uXt4fVMZx48axqiYUKvj+Lz0uDBOHBPDqxtLae9yWx1HZNBRod1Hrcnv3UBtbnqs1VG8bsnUZKpbOvkgr9rqKCIiIketvcvNmvxaTk2PPeLNtgabALuNBRkJfJZfS02LNswSERER37R6Rw3VLZ1crNXsR+z7M1Kpb+vivdwqq6OIDDoqtPuoj3bWMCzEycTkobkS7nBOGB1DanQw/9ioW5VERGTwWVdQT3t3D3PTh2bbmL0WZSbg9sC7uZVWRxERERE5qNc3lZIcGcTxo2KsjjJoTEuNIi0ulFc3lnCs+zqK+CsV2n2Qu8fD2t11nDB62JBdCXc4dpuN70xJZlNpI2ZFs9VxREREjspHO6sJCwxg2vAoq6MMqNGxoWQmRvCW2seIiIiID8qvaeXLogbOn5REgN3/aivHymazsWRqCturWthU0mh1HJFBRYV2H5Rd1khDezdzxvhf25i9FmcmEuyw84+vSqyOIiIicsTcPR4+3lnLnNExOAOG/sesszMTyKtqwazUhXERERHxLf/cXIbDbuOciYlWRxl0FmS4iAx28OpG1WREjsbQPwMchD7ZVUuADWaPHGZ1FMtEBDtYOCGBd3OrqG/rsjqOiIjIEckua6SurYuT0/zjYvlZRjzOABtva1W7iIiI+JD2Ljdvb63g9HFxxIQGWh1n0Al2BnBuViIf5FVT0dRhdRyRQUOFdh/0aX4tk1OiiAh2WB3FUt+ZmkxHdw9vbim3OoqIiMgR+WhnLQF2GyeM9o8+oFEhTk4aE8vKbZV0u3usjiMiIiICwHu5VTR1dHPhZG2CeqwumpKMh94+9yJyZFRo9zHlje3kVbVw4hj/OEE/nPS4MKYPj+L1TaX0aAMOEREZBD7aWc20VP+6WL4oM4G6ti4+za+zOoqIiIgIAP+3qZQxsaFMSYm0OsqglRwVzMlpsbyxuZyObi2oEDkSKrT7mDX5tQB+sxLu21wwKYmyxg7W7tbJu4iI+LbCujZ217b5TduYvY4fNYyYUCdv56h9jIiIiFhvS0kD2yqauXByMjabNkHti4unJlPf1sV7uZVWRxEZFFRo9zGf7a4jKTKIMbGhVkfxCaeOjWNYiJM3NpdZHUVEROSwPtlVA8BJaf51sdwRYGd+houPd9ZoXxURERGx3N8/LyTEaWfhBJfVUQa9GcOjGRMbyqsbS/Go04DIt1Kh3Yd0u3tYX1jP7FHDdNV1D2eAncVZCXy8s4aqZm3AISIivmtNfi2jY0JJiQqxOorXLcpMoLvHo9VOIiIiYqnG9i7e2lLG/AwX4UH+08pvoNhsNpZMTcasbGZzaaPVcUR8ngrtPiS7rImWTjezRw6zOopPOW9iEm4P2hRVRER8Vmunmw3FDX7b+m1sfDjj4sN4O0eFdhEREbHOOzmVtHf1cOEkbYLaXxZMSCA8KIDXvtKmqCLfRoV2H7K2oA67DWaMiLY6ik8ZPiyE40ZEs3RLOe4e3aokIiK+Z31hPV1uD3PG+O/F8vkZLnLKmyisa7M6ioiIiPghj8fDG5vLmJQahZEQbnWcISPEGcDZExJYlVdNXWun1XFEfJoK7T5kXUEdmYkRRAY7rY7icy6YnERFUwef7a61OoqIiMg3rMmvJdQZwJSUKKujWOas8S5swLtqHyMiIiIW2FLWxK6aVpZMT7U6ypBzweQkutwelmVXWB1FxKep0O4jGtq6yClvYvYo/10Jdzgnp8USE+rkjc1qHyMiIr7F4/HwaX4tx42Mxhngvx+tEiKCmDY8ipXbKrVZloiIiHjd0s1lhDoDOHtiktVRhpwxsWFMS43in5vL6NHnPJFD8t+zQR+zvrCeHg/MUn/2g+rdFDWRT3bVUNGkTVFFRMR37KxppaKpgzl+2p/96+aPd1FY10ZuZbPVUURERMSPNHd0855ZxVnj4wnTJqgD4sLJSZQ2tLN2d53VUUR8lgrtPmJtQR3hQQFkJkVaHcVnnTcxkR4PLNOmqCIi4kPW7Opta+avG6F+3Wnj4nDYbazcpvYxIiIi4j0rt1XS0d3DeZO0mn2gnDo2jphQJ69vKrM6iojPUqHdR6wvqGPG8GgcdpvVUXxWanQIs0cOY+mWMrq1KaqIiPiIdQV1pMWF4ooIsjqK5SKDncwZHcN7uVXawFxERES8ZumWcsbFhzFBm6AOGGeAnXP2dBoob2y3Oo6IT1Kh3QeUNLRR2tjBzBHRVkfxeedPSqSyuZO12hRVRER8QHuXm69KGtT67WvmZ7iobulkQ3G91VFERETED2yraMKsbOa8SUnYbFq8OJDOn5SExwNvqNOAyEGp0O4D1hf0nojOHKGT9G9zUlos0SFOlmunaxER8QGbShrpdHs4ToX2fU4cE0OoM0DtY0RERMQrlm4uJ8hhZ0GGy+ooQ15yVDBzxsTw5pZyut09VscR8TkqtPuAL4rqiQsLZFRMiNVRfJ4zwM7CCS4+2llDXWun1XFERMTPrSuowxlgY1pqlNVRfEawM4BTx8ayKq+ajm6dgImIiMjAae10s3JbJWcY8YRrE1SvuGBSEjUtnazeUWN1FBGfo0K7xTweD+sL65kxIlq3OB2hxVmJdPd4WKGVciIiYrF1BXVMSo4kxBlgdRSfMj/DRXOHmzX5avUmIiIiA+d9s5LWLjfnT0y0OorfOGF0DEmRQby+WZuiihxIhXaL7apppba1i5nD1Z/9SKXHhTEhMYLl2RV4PNpoTURErFHb2sn2qhb1Zz+IGSOGERPqVPsYERERGVBLt5QzOiaUScmRVkfxGwF2G+dOTOSLwnqK69usjiPiU1Rot9gXhb392WdoI9Sjck5WAjuqW9hW0Wx1FBER8VN791hRf/ZvcthtnGnE88muGpo7uq2OIyIiIkPQjqoWssuaOG9SojoEeNnizETsNnhTm6KK7EeFdot9UVRPSlQwyVHBVkcZVM4yXAQ57CzL1i91ERGxxrqCOiKDHYx3hVsdxSfNz3DR6fbwQV611VFERERkCFq6pQxngI2FExKsjuJ3XBFBnDA6huVbK7QpqsjXqNBuIXePhy+LGpihtjFHLSLYwalj43g3t5L2LrfVcURExM94PB7WFdQxc0Q0AXatoDqYzMQIUqOD1T5GRERE+l17l5t3cio5bWwc0SFOq+P4pfMm9m6K+qn25BHZR4V2C+2sbqGpo5vpI6KsjjIonZOVQHOHWztdi4iI1xXUtlHZ3Km2MYdhs9mYN97FF0X1VDd3WB1HREREhpBVedU0dXRz3sQkq6P4rTljYogLC2Sp2seI7KNCu4U2FjcAMDVFhfZjMX14NMmRQWofIyIiXreuoA6AWSN1V9rhzBvvoscD75lVVkcRERGRIWTp5jKGRwczfbjqKVZx2G0szkpgTX4tFU1aVCECKrRbamNJA8mRQSRGqj/7sbDbbCzKSmR9YT2lDe1WxxERET+yrqCO1OhgUqJCrI7i00bHhmK4wnk3V4V2ERER6R+7a1rZWNLIuROTtAmqxc7JSqTHA8u1AFIEUKHdMh6Ph43FDUxN1dXXvliUmYANeGurfqmLiIh3dLt72FDcwCy1jTki8zNc5JQ3UVjXZnUUERERGQKWbiknwG5jUaY2QbVaanQIM0dEsyy7nB6Px+o4IpZTod0iBXVt1LZ2qdDeR0mRwRw3Mpq3tlbol7qIiHhFdlkTLZ1u9Wc/QmcZ8diAd3O1KaqIiIj0TWd3D2/nVHBKWiyxYYFWxxHgvImJlDV28Pme1ooi/kyFdovs68+eqt6ufXVOVu8v9S8K662OIiIifmBdQR12G8wcrjn8SLgigpg2PIqV2yrx6KK4iIiI9MHqHdXUt3Vx3qREq6PIHnPT44gKdmhTVBFUaLfMxuIGYsMCGR6t/ux9dUp6HBFBDm2KKiIiXrGuoJ4JiRFEBDusjjJozB/vorCujdzKZqujiIiIyCC2dEs5SZFBauHnQwIdds7OTODDHTXUtnZaHUfEUiq0W2RjcQNTU6K0cUc/CHLYmZ/h4oO8ahrbu6yOIyIiQ1hrp5uc8kZmjtBq9qNx2rg4HHYbK7epfYyIiIgcm+L6NtYX1nNOViJ21VJ8yrkTE+nu8fD21gqro4hYSoV2C5Q1tlPe1KH+7P3onKwEOt0e3sutsjqKiIgMYV+VNOD2wHS1jTkqkcFO5oyO4b3cKtw9ah8jIiIiR2/51gpswOIstY3xNWNiw5iUHMmbW8rVKlD8mgrtFtjbn32aCu39xnCFMzY+TO1jRERkQH1ZVI/DbmNycqTVUQadeRkuqls62VCsPVVERETk6PR4eldLzxo1jISIIKvjyEGcOzGRgro2vipptDqKiGVUaLfAhuIGIoMdjIkLtTrKkGGz2Viclci2imbyqtT/VUREBsYXRQ1kJUUQ7AywOsqgc9KYGEKdAby7TXefiYiIyNFZX1hPRVMHizMTrI4ih3CmEU9YYABLt5RZHUXEMiq0W2BjcQNTUqLUU6yfLRjvwmG3sTxbPcFERKT/NXd0k1vRpLYxxyjYGcCpY2P5d14Vnd09VscRERGRQWR5djkRQQ5OSY+zOoocQogzgPkZLv69vZqm9m6r44hYQoV2L6tu6aSwrk392QdAdKiTU9JjWbGtki63TuBFRKR/fVXSQI8HZqjQfszmZbho7nDzaX6t1VFERERkkGhq72b1jhrmjY8nyKEyli87d2IiHd09rNhWaXUUEUvoN5SXfbWnP7sK7QNjcVYi9W1dfLxLJ/AiItK/vihswBlgIyspwuoog9bMEcOICXXybq5OvkREROTIvG9W0tHdo01QB4GMhAgMVzhLt5RpU1TxSyq0e9nG4gZCnHYMV7jVUYak2SOHER8eyHJtiioiIv3sy6J6JiZFqj97HzjsNs404vl4Zw3NHbqlWERERL7d8q0VjIkNJSNBdZTB4NyJieRVtbCtQvvnif9Rod3LNpY0MDk5Codd/dkHQoDdxtkTEliTX0tVc4fVcUREZIhoau/GrGxW25h+MG+8i063h9U7qq2OIiIiIj4uv6aV7LImFmclYtM+d4PCggwXQQ67NkUVv6RCuxc1tHWxo6pFbWMG2OKsRHo88E6ObksXEZH+saG4AQ8wbbjm8L7KSoogJSqYlerdKSIiIt9ieXY5Abbe4q0MDuFBDs4w4nl3WxWtnW6r44h4lQrtXrSptBEPMCU10uooQ9qIYSFMSYlkWXa5eoKJiEi/+LKoniCHnYlJmsP7ymazMS/DxfrCeqpbOq2OIyIiIj6qu8fDO9sqmTMmltiwQKvjyFE4LyuR1i43/zKrrI4i4lUqtHvRppJGHHYbmYk6SR9oi7MSKaxrY3Npo9VRRERkCPiyqJ6JyZEEOvTRqT/MH++ix4NOvkREROSQPsuvpaalk8WZCVZHkaM0OSWSUTEhvKn988TP6GzRi7aUNpCREE6QTtIH3Bnj4glx2lmeXWF1FBERGeQa2rrIq2phulq/9ZvRsaGMiw/j3Vy1jxEREZGDe2trBcNCnJw4JsbqKHKUbDYb52Qlsrm0kfyaVqvjiHiNKr5e0uXuIaeimYnJWs3uDaGBAZwxLp73TfUEExGRvtnbn10bofav+RkussuaKKprszqKiIiI+Jj61i4+2lnDggkuHAEqXQ1GZ2cmEGC38eYWrWoX/6HfVl5iVjbT0d3D5BSthvOWc/b0BPv3dt2WLiIix25vf/bMpAirowwpZ413YQOtahcREZFvWJlbSXePh8WZiVZHkWMUExrISWNieCengi53j9VxRLxChXYv2dsrfJJO0r1mckokI4aFsHyr2seIiMix+7KogcnJkTi1mqpfJUQEMTU1ipXbKrV5uYiIiOxneXY5GQnhpMeHWR1F+uDciYnUtXXx8a5aq6OIeIXOGL1kU0kjyVHBxIUHWR3Fb9hsNhZnJrCxuIFC3ZYuIiLHoL61ix3VLcwYobYxA2HhBBcFdW3kVDRbHUVERER8hFnZzPaqFhZpNfugN3tUDK7wQN7cUmZ1FBGvUKHdCzweD5tKG5ms/uxed3ZmAnYbvLVVPcFEROTobShpAGCaNkIdEKePiyfIYecd3X0mIiIieyzPLscZYGPe+Hiro0gfOew2FmUmsHZ3HRVNHVbHERlwKrR7QVljBzUtnUxSod3r4sODOH5UDG9vrcDdo9vSRUTk6GwsbiDIYWdColq/DYTwIAcnp8Xybm6leneKiIgIXe4eVm6r5JS0WKJCnFbHkX6wOCuRHo8WQIp/UKHdCzaV9q6GU6HdGudkJVDZ3Mm6gjqro4iIyCCzoaieierPPqDOnpBAQ3s3a/LVu1NERMTffbyzhob2bhZlqW3MUJEaHcKMEdEsy66gR/vyyBCns0Yv2FzSSFhgAGlx2sTDCielxRIV7GB5tq6eiojIkWtq7yavqoVpKWobM5BmjRpGTKiTt3MqrY4iIiIiFlu+tYL48EBmjxxmdRTpR+dmJVLa0M4XhfVWRxEZUCq0e8Gm0kaykiIIsNusjuKXnAF2FkxI4MOdNdS3dVkdR0REBolNpQ14gGnDVWgfSA67jfkZrt4VbJqnRURE/FZ1cwdr8mtZOCFB9ZMhZm56LBFBDpZpAaQMcSq0D7Dmjm52VreobYzFFmcm0OX28O42rZYTEZEjs7G4AYfdRqb6sw+4hRMS6O7x8L5ZZXUUERERscg7OZX0eHrP32VoCXYGMD/DxQd51TS2a2GFDF0qtA+wreVN9HhgcrJWw1lpnCucjIRwXT0VEZEjtqG4gczECIKdAVZHGfLGxYeRHhfGOzkVVkcRERERC3g8Ht7aWsGk5EhGxoRaHUcGwLkTE+l0e1ipBZAyhKnQPsA2lzRiAzKTtBrOaosyE9le1YJZ0Wx1FBER8XGtnW62VTQzNVUXyr3BZrOxcIKLLWVNFNS2Wh1HREREvGxreRP5ta1azT6EGa5wxrvCWbqlHI82RZUhSoX2Aba5tJH0+DDCgxxWR/F788bHExhgY/lWrWoXEZHD21LWiLvHo0K7F83PcGG3wTta5SQiIuJ3lmdXEOSwc4YRb3UUGUDnTEwkr6qF3EotgJShSYX2AeTu8bClrFH92X1EVIiTuelxrNhWSUd3j9VxRETEh20sbsBug8kpmsO9JT48iONGDmNFTgU9WuUkIiLiN9q73LxnVnL6uDgtUhzi5o93EeSw8+YWLYCUoUmF9gG0q6aFlk63Cu0+ZHFWAo3t3Xy0s8bqKCIi4sM2FjdguMIJC9TJnjedPSGBssYONhQ1WB1FREREvGT1jhqaO9wszky0OooMsIhgB6eNjePd3Erau9xWxxHpdyq0D6DNpY0AKrT7kJkjhpEQEcRybYoqIiKH0NHdQ3ZZo9rGWGBueizhQQHavFxERMSPLM8uJzkyiGnD9dnLH5w7MZHmDjer8qqtjiLS71RoH0CbSxuJDQskJSrY6iiyR4DdxqLMBNburqO8sd3qOCIi4oNyypvodHuYpkK71wU7A5g33sWq/8/efYc3WbZtAD+zm+7ddNIJdEPZCiICAiJDQJy4916voIiKe7y+LkRwI6K4WYooKAoCUmjpghZK995p0zZNM74/inwiZbe9M87fcfiHGc2ZGHPnuXI/13WoDi16o+g4RERE1MuqmvVILWnC1PgASCUS0XGoD6SEeCDE04ntY8gusdDeizLKu/qzS7hYWJVL4wNgAfDjfg5bIyKi46WXdbUtGRTMQrsIMxI16DCa8VMu12kiIiJ7tyGnGhYAU+MDREehPiKRSDA9QYO0Mi1KG9tFxyHqUSy095K6VgPKtXq2jbFCIZ5qDA31wNqsSg5bIyKi46SXaRHt6wIPtUJ0FIc00N8V/f1csI67nIiIiOya2WLBhpxqDA31QLCHWnQc6kOXxgdAKgHbBZLdYaG9l2Qd6c+ezEK7VZqVHISK5g7sKmoUHYWIiKyI0WRGRoWW/dkFkkgkmJGoQW6NDnk1OtFxiIiIqJekl2lRrtVjWgKHoDoaP1cVzovwxoacahjN3ABJ9oOF9l6SUd4MpUyCAf6uoqNQNy6M9oG3swLfZVSKjkJERFYkr0aH9k4zC+2CTY71h1Im4a52IiIiO7Y+pxouShkuivEVHYUEmJmoQV2rsmDsCAAAIABJREFUATsKG0RHIeoxLLT3ksyKZsQGuEEp50tsjRQyKaYnaLCtoB7VLR2i4xARkZVIO9KfnYV2sdydFBgX44uNB2qg7zSJjkNEREQ9rM1gwq8HazFhgB+cFDLRcUiA8yO84e2s4MYKsiusAveCDqMZuTUtSA5m2xhrNjNJA4sFWJPJXe1ERNQlvUyLMC81fF2UoqM4vBmJGrR0GLE1v150FCIiIuphmw/Wor3TjGkcguqw5DIpLo0PwPaCetS1GkTHIeoRLLT3gtzqFnSaLByEauWCPdQYFeGFNVlVMJrMouMQEZFgJrMF+8qbuZvdSgwJ9USQhxPWckgWERGR3dmQXYV+XmrWTRzctAQNTBbgh5xq0VGIegQL7b0g88gg1EQuGFZvVlIQ6loN2FbAnmBERI7ucF0rWjqMSGGh3SpIJRLMSNBgT0kTypraRcchIiKiHlLa2I708mZcGh8AiUQiOg4JFO7tjMHB7liXXQWLhUNRyfax0N4LMsqbEealhrczTzu3dqMjvRHgpuJQVCIiQvqR/uwstFuPS+MDIJUA67irnYiIyG5syKmCVAJMZdsYAjA9UYOSxnbsK28WHYXonLHQ3sMsFgsyK5qRGOgmOgqdBplUgpmJGuwqbuRuOSIiB5derkWguwoadyfRUegIfzcVzovwxrrsanSyzRsREZHNM5kt2JBTjZHhXvBzVYmOQ1ZgfH8/uChlWJvFDZBk+1ho72FlTXo0tnciKZi74WzFjEQNZBLgew5FJSJyWBaLBellWvZnt0JzkoNQ32rgUFQiIiI7kFrSiBqdAdPiNaKjkJVQK2S4eKAfNh+sg67DKDoO0Tlhob2H/d2fPZn92W2Gn6sKF0T7Yl12NTqM3C1HROSIihva0dDWicH8odzqjAz3QpCHE77NqBAdhYiIiM7R+uxquDvJMSbKR3QUsiIzEgPRYTTj59wa0VGIzgkL7T0so0ILV5UMET7OoqPQGZiTHIim9k5szqsVHYWIiARIKz/Snz3UU3AS+jeZVIJZSYHYW6pFYX2b6DhERER0lpr1ndiaX4fJA/2hkrMcRf8vLsAV0b4uWJtdLToK0TnhJ1sP6+rP7g4pJ2fblGFhnojwccaX6eWcdE1E5IDSy7TwcVEi1JP92a3R9IQAKGQS7monIiKyYZtya2EwWTAtgUNQ6VgSiQTTEzXYX9WCQ7U60XGIzhoL7T2oRW9EQV0bktg2xuZIJBJcMTgIB6p1R9v/EBGRY7BYLEgrbcLgYA9I+EO5VfJyVuKiGF9syKlGe6dJdBwiIiI6C+uzqxDj54IB/q6io5AVmhLrD4VMgrVZVaKjEJ01Ftp7UHZVMywAkoNZaLdFl8QFwFUlw5fp3C1HRORIyrV61OgMSAllf3ZrNic5CK0GEzYdYO9OIiIiW5Nf14oD1TpMS9BwYwN1y1OtwIXRvvjpQA0MnJ9HNoqF9h6UWd4MqQSI17DQbovUChlmJATi14O1qG7pEB2HiIj6SHpZV3/2wSEstFuz5GB3RPk649uMSrZ5IyIisjHrs6sgl0owZaC/6ChkxWYkaKDVG7E1v050FKKzwkJ7D8qoaEaMnyuclTLRUegsXT44EGYL8B17wBIROYy0Mi08nOSI5CBzqyaRSDAnOQi5NTrsr2oRHYeIiIhOk9Fkxsb9NRgT5QNPZ4XoOGTFhvXzRKC7iu1jyGax0N5DjGYLcipb2J/dxgV7qHFBlA++y6xCB09VIiJyCGllWgwO8eAgcxswJc4fzgoZvs6oFB2FiIiITtP2ggY0tndiOoeg0ilIJRJMS9Bgd0kTKrR60XGIzhgL7T3kcF0r2jpNLLTbgStSgtDU3omfc9kDlojI3lU161Gh1SMl1FN0FDoNLko5psT545fcGjS1dYqOQ0RERKdhfU41fF2UGBnuLToK2YBp8QGQoKvdEJGtYaG9h2RWNAPgIFR7MDTUE5E+zvgyvYI9YImI7Fx6eVd/9pRg9me3FXMHB8FgsuD7LO5qJyIisnZ1rQb8WVCPS+L8IZfy7EE6NY27E0aEe2F9TjVMZtZkyLaw0N5DMsq18HNVQuOmEh2FzpFEIsEVKcHIq9FhX3mz6DhERNSL0kq1cFXJEO3nIjoKnaZIHxeM7OeFr/dVoNPENm9ERETWbOP+apgswLR4jegoZENmJmpQ3dKBv4obRUchOiMstPeQrIpmJAW5Q8L+rnZhSqw/PJzk+HxvmegoRETUi9LKtBgU7AEZd1jZlCuHBKNWZ8CWg3WioxAREdEJWCwWrM+pRmKgO8I5dJ7OwAVRPvBUK7CO7WPIxrDQ3gNqdR2oaO5gf3Y7olbIMHtQEH7Pr0dxQ5voOERE1AvqdB0oaWxHSgjbxtiaUeFeCPNS44u0crZ5IyIislI5VS0orG/DNA5BpTOkkElxSZw/fs+vR2ObQXQcotPGQnsPyDrSn52Fdvsyd1AQFDIJVnFXOxGRXUo/0h6Mg1Btj1QiwZUpwdhf1YKsyhbRcYiIiKgb67OroZJLMXGAn+goZIOmJ2hgNFuw8UCN6ChEp42F9h6QUdEMlVyKAf6uoqNQD/JxUWJqfAB+yKlGfSt/QSUisjdppU1wVsi4ftuoqXEBcFPJ8cXectFRiIiI6F/0nSZsyq3B+P6+cFXJRcchGxTl64LEQDesyariGYxkM1ho7wGZFc2IC3CFQsaX095cMyQEnSYLvtpXIToKERH1sLQyLZKC3SFnf3ab5KyUYWaiBr8dqkVVs150HCIiIvqH3/Lr0GowcQgqnZPpCRoU1rchm2cwko1gZfgc6TtNyK3WITGI/V3tUT9vZ4yN9sG3+yrQ3mkSHYeIiHpIU1snCurb2J/dxs0dHAQA+Jo/iBMREVmV9dnVCPJwQkoov2vR2Zs40A9qhRRrORSVbAQL7ecot1oHo9nC/ux27NqhIdDqjViXxQ92IiJ7kV6uBQAW2m2cxt0J42J88X1mFX8QJyIishIVWj32lDTh0vgASCU8c5DOnotSjgn9/fBLbi3aDPyuR9aPhfZzlHlkEGoyC+12KznYA0lB7vh8bxmMZvYFIyKyB2llWqjkUsRp3ERHoXN0ZUowWjqMWJ9dLToKERERAVibXQWJBJgWHyA6CtmBGYkatHWasDmvVnQUolNiof0cZVQ0I8xLDU9nhego1IvmDQ1BRXMHfj3ID3YiInuQVtqExCB3zlexA0lB7kgMdMMq/iBOREQknNFswfrsKowK94bG3Ul0HLIDSUHuCPdWs30M2QQeXZ4Di8WCzIpmto1xABdE+yDMS42VqWWcdk1EZOOa9Z04VNvKtjF2QiKR4LphoajQ6vmDOBERkWB/FjSgVmfAzEQOQaWeIZFIMD1Bg8yKZhTUt4qOQ3RSLLSfg9ImPZraO1lodwBSiQTXDwtFbo0OO4oaRcchIqJzkFHeDAvYn92eXBDtg35eaqzYXcofxImIiARak1UJHxclRkd6i45CduTS+AAoZBJ8l1EpOgrRSbHQfg4yK7oGqbHQ7hguifOHxk2FD3eW8CCeiMiGpZVpoZBJEM/+7HZDKpFg3rAQHKxtxe7iJtFxiIiIHFJ1Swd2FDZgekIA5GzPRz3Iy1mJi2J88cP+arR3cigqWS9+8p2DjPJmuKnkiPBxFh2F+oBcJsX1w0ORVdmMPaU8iCcislVpZVokaNzgpJCJjkI9aEpsAPxclViRWio6ChERkUNal10FswWYnsC2MdTz5iQHQddhwqYDNaKjEJ0QC+3nILOiGYlBbpBKJKKjUB+ZlqCBn6sSH+4qER2FiIjOQqvBiLzqFgwO9RQdhXqYUi7FVSnBSC1pwoHqFtFxiIiIHIrJbMG6rCoMD/NEiKdadByyQ8nB7oj2dcE3GZXsMkBWi4X2s9SiN6Kgvo1tYxyMSi7FvGGh2Fuqxb4yreg4RER0hjIrmmGysD+7vbosKRAuShk+3c1d7URERH1pV3Ejqlo6cFlSoOgoZKckEglmJwcir0aHnCpuqiDrxEL7WcqqbAbA/uyO6LJEDbydFfjwL+5qJyKyNWmlWsikEq7fdspVJcfs5CD8eqgOpY3touMQERE5jDWZlfBSKzA22kd0FLJjU+L84ayQ4RsORSUrxUL7Wcoo10ImAeI1PFB3NE4KGa4ZEoJdRY3IOfKDCxER2Ya0Mi3iAlyhZn92u3VVShBkUgk+21MmOgoREZFDqNN1YFtBA6bGB0DBIajUi1yUckyJ88fmvFo0tXeKjkN0HH4CnqX08mYMCHCDs5IH6o5o9qBAeDjJ2audiMiG6DtN2F/VgsEh7M9uz3xdVbg0PgDrc6pQq+sQHYeIiMjurc+phslswYxEDkGl3jcnOQgdRjM25FSLjkJ0HBbaz0KH0YycymYMDmZ/V0flopTjypRgbCtoQF61TnQcIiI6DZkVzTCaLUgJ5fpt764bFgqz2cJd7URERL3MaLbg24xKDA3zRLi3s+g45ACi/VyQHOSO7zIqYOZQVLIyLLSfhf1VLTCYLBgcwrYxjuzKlGC4qeRYvqNIdBQiIjoNe8u62r4lsz+73QvxVGNyrD++zahEY5tBdBwiIiK7tf1wPapbOjB3UJDoKORA5gwKQmmTHqnFTaKjEB2DhfazsK9cCwBI5o52h+aqkuPaoSHYVtDAiddERDYgtbgJcRo3uKrkoqNQH7hheBgMRjNW7S0XHYWIiMhufbWvAgFuKoyJ4hBU6jsXxfjCS63ANxkVoqMQHYOF9rOQVqZFlK8zPNUK0VFIsCtSguDhJMfyP4tERyEiopNoNRixv6oZQ8PYn91RhPs4Y8IAP3ydXgEth2URERH1uKL6NqSWNGF2ciDkUonoOORAlHIppiVo8MeRMyqIrAUL7WfIaLYgq6IZg7ibndDVq/26YaHYWdSIjCNnOhARkfXZV9YMkwUYGspCuyO5cUQo2jpN+Cqdu52IiIh62jcZFVDIJByCSkLMStbAYgG+z6wUHYXoKBbaz9ChWh1aDSakhLDQTl0uHxwEb2cFlu8oFh2FiIhOILWkCQqZBEnsz+5QYvxcMTbKB6vTy9GiN4qOQ0REZDdaDUZsyKnGhP5+8HZWio5DDijYQ43zIryxNqsKRpNZdBwiACy0n7H0sq5dy9zRTn9TK2S4fngoUkuasLeUgziIiKzRntImJAW5w0khEx2F+thNI8PQrDfi890loqMQERHZjY37a9BqMOFyDkElgWYnB6Ku1YDfD9eLjkIEgIX2M5ZepkWwhxP83VSio5AVmZUUCF8XJZb/WQSLxSI6DhER/UNTeycO1ugwjP3ZHVKcxg2jwr3w4Z+FaO80iY5DRERk8ywWC77aV4HYAFckBLqJjkMO7LwIbwS6q/D1PrYJJOvAQvsZsFgsSC/TYjDbxtC/OClkuHFEKNLLm7G7mLvaiYisSVqZFhawP7sju3lkGBrbOvEND8KIiIjOWVqZFoX1bZgzKAgSCYegkjgyqQSzk4Owt1SLQ7U60XGIWGg/E4UNbdDqjSy0U7dmJgYiwE2FpdzVTkRkVfaUNEGtkCJewx1Xjio52ANjon2xYncpWg3s1U5ERHQuvkqvgIeTHBcP8BMdhQgzEzVQyaVYnVYuOgoRC+1nYt+R/uyD2Z+duqGUS3Hbef2wv6oFvx6qEx2HiIiOSC1pxOAQD8hl/NrjyO4fHw2t3ogv07irnYiI6GxVaPXYml+HGYkazr4hq+ChVuDS+AD8dKAGjW0G0XHIwfGI8wyklWnh66JEiKeT6ChkpabGBSDCxxlLtxfBaOaudiIi0Wp1HShqaGfbGEJyiCdGR3rjsz1l0HVwVzsREdHZ+CKtHBKJBHMHB4uOQnTUFYODYTBZ8F1mpego5OBYaD9N/+zPzh5kdCIyqQR3jw5HSWM71mVXiY5DROTw9pR2zc3gIFQCgDvOC0dLhxGf7y0THYWIiMjmNOs7sTarEpMG+iHATSU6DtFRET7OGBXuha/3VaLTZBYdhxwYC+2nqbK5AzU6AwaxbQydwgVRPkgKcsf7O4qh7zSJjkNE5ND2lDTB3UmOGD9X0VHICgwIcMW4GF98vrcc2vZO0XGIiIhsyveZVWjvNOOaISGioxAd58qUYNS3GvBLXq3oKOTAWGg/TelH+rOncBAqnYJEIsE9YyJQ12rgMA4iIsH2lDQhJcQDMinPRqMut43qhzaDCau4q52IiOi0dZrMWJ1WjuFhnujvzw0MZH1Ghnsh3FuN1WnlsFjYypfEYKH9NKWXaeHuJEekr7PoKGQDBod4YHSkN1aklnLHHBGRIOXadlQ0d7BtDB0j2s8FEwb4YXVaOQdmERERnaZNuTWoazXg2mHczU7WSSqR4MqUYByo1iGzoll0HHJQctEBbEV6uRbJQe6Q2kl/9tZWHZYufQvbt/8Bg8GAUaPOx733PggvL++jt7n11utw4MD+Y+536aUzsGDBIgDAypWfYPXqlVCpnHDXXfdhwoRJR2/35ZerUFhYcPS2J/L880+jpqYGb7659LjrXnrpWZSVlWLJkvcAAHPmTENV1f8PtpBKpXB2dkZ8fBLuuOMexMT07/Z2CoUCvr7+GDt2HG666VY4O7uc7st0Tu4eHYGrP92LFbtLcd/YyD55TCIi+n97Srr6sw+18UI71+yed+uofthysBYrU8u4RhMREZ2CxWLBqj3liPJ1xsh+XqLjnDNH+24VEBCA0aMv7NN6iCiXxAVg6fYifJFWjmS2fiYBWGg/DVXNepQ0tmN2cqDoKD1m0aIFKC4uwuOPPwU/P3+8//5S3HvvHfjoo8+gVCphsVhQWFiAJ598DkOGDD16PycnJwBAQcFhfPrpR3j99SVoamrC008/juHDR8Hd3R2trTqsXr0Ky5Z91OO5r7nmesydexWArsW+vr4eb7zxCh588G589dWao4vGP2+n1+uRm7sfS5a8gZycTLz11nIoFIoez/Zv0X4umBLnj6/2VeCKlGAOiyEi6mOpJU3wcVEiwtu2z0bjmt3za3aEjzMmDexao68eGgJfF2WPPwYREZG9+Ku4Efl1rXhyUn9I7GDzoaN9tyopOYxXXnm5T+shoqgVMsxM1OCzPWWo0OoR5OEkOhI5GLaOOQ2pR3bE2cup54cO5WH37l1YsGARRowYhcjIKCxa9Czq6mqxZcvPAICKinLo9XokJCTCx8f36D8uLl292AoLCxAZGYWEhCSMHn0BnJ1dUF5eCgD4/POVuOiiCQgI0PR4drVafTSLr68fBgwYiLvvfgBNTY3Yuze129sFB4dg/PiL8dJL/0N2dhZ++GFtj+c6kdvPC4fZYsH7O4r77DGJiAgwWyz4q7gJw8I8bfqAMDf3ANfsXnLLqH4wmsz4dHdprz0GERGRPfhsTxl8XZSYNNBfdJRz5oj1kClTpgiph4gyd3AwJBIJPuc8HhKAhfbTkFrSBC+1AlG+9nGKTWlp1wKQlDTo6GXOzs4IDQ1FevpeAEBBQT5UKhU0mu538QcFBaGsrAQNDfUoLCyATtcCf/8ANDTUY8OGNZg376befyJHyGQyAIBCcfLdaAMGDERS0iBs3vxzX8QCAAR5OGF2chDW51ShsL6tzx6XiMjR5dXo0NTeiVHhtn16c3Fx1w+1XLN7XpiXGpfEBeDbjArUtHT02uMQERHZsoM1OvxV3IQrBgdBKbf9EhLrIX1XDxElwE2FybH+WJtVhSbOzKM+Zvufkr3MYrEgtaQJQ8M87aY/u6+vLwCgtrbm6GUmkwk1NTVoamoE0HUqlKurGxYvfgIzZkzGddddgdWrP4PZbAYAxMbGY9y4CZg5cwpuvPFq3Hzz7fDx8cXHH3+A6dNnwdOzb3b/l5eXYdmyJfDx8UViYtIpbx8ZGY2CgsN9kOz/3TQiFGqFDEu3F/bp4xIRObKdhV3r2UgbL7T7+XXtHOOa3TtuHhUGkwX46K+SXn0cIiIiW/XRXyVwUcowy05a6bIe0rf1EFHmDQ2B3mjGN/sqREchB8Me7adQ1NCOulaD3bSNAboWhX79wvHqqy9i0aJn4Obmig8/XI6mpkZ0dnb92ldYWID29naMGDEK1113E7Ky9uGdd95Ca2srbr75dgDAI488httvvwdyuRxqtRrl5WX444/f8MUX32LDhrVYufJjuLu7Y/78RYiOjjlhnn379mLixDHHXW4wGJCYmHzMZStWfIhVq1YAAIxGI4xGI2JiBuD55189ehrXybi5uaG1VXfar1VP8HJW4tqhIVi+oxgZ5VoO5CAi6gO7ihowwN8V3s623Xs7MTGBa3YvCvZQY2aiBmuyqnDt0BCEeKp79fGIiIhsSX5dK7YcrMNNI8Pg7mQffb1ZD+nbeogoUb4uGB3pjS/TK3Dt0BA4KWSiI5GDYKH9FOytPzvQNXX6hRf+i2eeWYSZMydDoVBg4sTJGDXqfMjlXYvnE08sRnt7O9zc3AAAUVHR0Ol0+PTTj3HTTbcd7Xf79/UA8N57S3HVVdeira0NS5a8jk8+WY2cnCw8++yTWLHiixPmiYuLx8KFi4+7fPnyd9DY2HDMZbNmXY7LLrscQNcpUh4eHmc0NbutrfWYzH3lmqEh+C6zEq9vLcBHVw+ym7MjiIiska7DiMzKFswbGiI6yjlTKJRcs3vZLSPDsCGnGsv+LMJzU2N7/fGIiIhsxce7SuCskOGqlGDRUXoM6yF9Xw8R5bphobjtywysz6nG5YOCRMchB8FC+ymkljQiyF1ldzuc+vULx4cfroRW2wSFQgFnZxfcdNM1GDZsJABALpcf9wEcFRWNtrZW6HS64647eDAX2dmZePzxp7Br1w6EhvaDRqOBl5cnnnrqMbS26k74C6tS6YSQkNDjLndxcTluYXFzc+/2tqcrLy8XMTEDzvr+Z0utkOGu0eFY/NNBbMqtwZTYgD7PQETkKPaUNMFktth825i/cc3uXb6uKlyVEoxPdpdi3rBQDPA/9Y4wIiIie1dU34Zf8mpx3fBQeKrtYzf73/jdyjEMCnZHYqAbPttThsuSAiGXcsMj9T72aD8Jk9mCvaVaDLWj3ewA0Nqqwz333IaCgnx4eHjC2dkFlZUVyM8/hOHDuxaW2267AW+88d9j7pebewC+vn7d/gK6bNkS3HDDLVCpVJBIJLBYLAC6TmcCALPZ0svP6tQOHTqI7OxMXHzxFCGPf0lcAAb6u2LJH4XQd5qEZCAicgQ7ixrhrJAhKchddJRzptNxze4L1w0LhbuTHO9s4zwVIiIioKs3u0ouxTVD7Gc3O8B6iKh6iAgSiQTXDQtFhVaPXw/Wio5DDoKF9pPIq9GhpcOIYWH2sSPuby4urjCZTHjzzf+hsLAA+/dn49FHH8CQIcMwZMgwAMDYseOwbt132LhxA8rLy7BhwxqsWrXiaD+yf9q7NxWVlRWYMuVSAED//gNRWHgYaWl78P333yA8PKLPT09qb29HfX0d6uvrUF5ehs2bN2HBgoeQnDxY2MIilUjwwIWRqNEZsGpvmZAMRET2zmKxYFdRA4aFeUIhs/2vOa6uXLP7gpuTHDcMD8XOokbsLW3qk8ckIiKyViWN7diUW4M5g4LgZePzbv7NEeshP/74o/B6iCgXRPugn5caK1PLjv4AQtSb2DrmJP7uz25vO9oBYPHiF/D666/gjjtuhErlhLFjL8Kdd9579Pqrr74OMpkMK1Z8hJqaKvj7a3DvvQ9h2rSZx/2tZcvexi233AG5vOvtpNFocNdd9+HJJxfAw8MTTzxxfL+x3rZq1YqjQ0KcnV2g0WgwffpluOKKayCTiRuCMSTUExdG+2DF7lLMSNDA11UlLAsRkT0qaWxHRXMH5g07+9NqrQ3X7L5x+aAgrE4rx5JthfjoqkFH+68SERE5mk/+KoFCJsW1djDvpjuO9t0qODjIKuohIkglEswbFoLnfj6E3SVNGNHPvjbSkvWRnO0vOrW1LXbzU5CnpzOamtqOu/yebzJRqzPgyxuGCkhln070WjuS0sZ2zP1kDy6J88eiSb3XH42vdd/ha903+DoDfn5u51T564u1W/R/p9Vp5Xjtt8P4/uZhdjFfRfTraU9O57Vcm1WJ534+hFemx2FcjG8fJbM9fF/2HL6WPcdaX8tzXbu7Y0/H4mfLWv97i9KTr0e5th2zP0zF3MHBeGhcVI/8zb7G98exHP31MBjNmPHBbvTzVmPZ3GSHfz3+ja/HsU70epzuem7751T3EoPRjH3lzRhmh7vZSaxQLzXmDg7C+uxq5FXrRMchIrIru4oaEerpZBdFdup7U+M1CPdWY+n2QhitoJ8qERFRX/t4Vylk0q5dwET2QCmX4rrhodhbqmWLQOp1LLSfQFZlMzqMZhbaqVfcMrIf3J3keO23fPYJIyLqIQajGXtLmzAq3Ft0FLJRcqkEd4+OQFFDO9ZmVYqOQ0RE1KeK6tuwPqcKs5OD4Mc2p2RHLkvUwMdFiQ92FouOQnaOhfYTSC1pglQCpISw0E49z81JjrvHRCC9vBmbcjn9moioJ+wr10JvNGNkOHsv0tkbG+2DwSEeWP5nMXQdRtFxiIiI+sy7fxZBrZDhxhH2M+uGCACcFDJcNywEe0q12F3UIDoO2TEW2k8gtaQJsQFucHPivFjqHdMTNIgNcMWbvxeg1cADeSKic7WzqBFyqQRDQvkjOZ09iUSCBy+MRGN7Jz7+q1R0HCIioj6RU9WCXw/V4ZqhIfByVoqOQ9TjZiUFwsdFiSW/5YuOQnaMhfZutBqMyKlqYdsY6lUyqQSPjo9GXasBH+0qER2HiMjm7SpqxKAQDzgrZaKjkI2LDXDD1Dh/rE4rQ4VWLzoOERFRr3tnWyG81ApcPSRYdBSiXvH3rvadBQ1IL9OKjkN2ioX2buwt1cJktrDQTr0uIdAd0xMC8PnechTVc8ozEdHZqmnpQH5dK0b1Y9sY6hl3jo6ARCLBO9sKRUchIiLqVX8VNyK1pAk3jQyDi5Jn9ZP9mpUUCF8ag7COAAAgAElEQVRXJd5nr3bqJSy0d2NnYQPUCikGBXuIjkIO4O4xEXBSSPFfDkYlIjpr2wvqAQDnR3IQKvWMADcV5g0Nwc95tcisaBYdh4iIqFdYLBa8s60Qge4qzEoKFB2HqFc5KWS4dXQEUkuasI+72qkXsND+LxaLBTuKGjE01BNKOV8e6n3ezkrcfl44/ipuwtb8etFxiIhs0raCBgR5OCHSx1l0FLIj84aFwtdFiTe2HuaP4UREZJd+PVSHA9U63H5eOGsg5BCuGhYGb2cF3uOuduoF/BT9l+LGdlRo9TgvgjviqO/MGRSEKF9n/O+3w2gzmETHISKyKfpOE1JLmjAm0hsSiUR0HLIjzkoZ7jw/HFmVLfg5t1Z0HCIioh5lNJmxdHsRIn2cMTnWX3Qcoj6hVspw3bBQpJY0YXdxo+g4ZGdYaP+XnUVd/5ONimCPV+o7cqkEj02IQVVLB5b9WSQ6DhGRTdld0oQOoxljonxERyE7NDU+AAP9XfHmHwVoNRhFxyEiIuoxX2dUoqSxHfeMiYBMys0K5DjmDAqCxk2FJdsKYeZZi9SDWGj/lx2FDejnpUawh1p0FHIwycEemJ0ciC/Ty5FT1SI6DhGRzdh2uB4uShlSQjhbhXqeTCrB/AnRqNUZ8MHOEtFxiIiIekRTeyfe31GMEf08MZozbsjBqORS3HF+OA5U67A5j2ctUs9hof0f9J0mpJdp2TaGhLlnTAR8XZR4/ueDMJrMouMQEVk9s8WC7QUNGBnuBYWMX2uodyQEumNGogZfpJXjcF2r6DhERETn7L0dxWgzGPHghVFsvUcOaXKsP2L8XLB0exE6WX+hHsIj0n/YW6ZFh9HMtjEkjKtKjkfHR+NQbStW7ikTHYeIyOrlVutQ12rAmEi2jaHedc/oCLgqZXhlSz4HoxIRkU07XNeK7zIqMCs5CFG+LqLjEAkhk0pw95gIlGv1+C6jUnQcshMstP/D9sP1cJJLkRLiKToKObCx0b64KMYXH+wsRklju+g4RERWbWt+HWQS4HyejUa9zNNZgbvGRCCtTItNHIxKREQ2ymKx4PWth+GikuO28/qJjkMk1HnhXhga6oEPdpVA18FZPHTuWGg/wmKxYNuRU89Vcr4sJNZ/LoqCUi7FC78c5K45IqKT2HqoHoNDPeHprBAdhRzAjAQN4jRueOP3Ah6MERGRTdpW0IC/iptw66h+8FTz+xM5NolEgnsuiERTeyc+Y1cB6gGsKB9xsLYV1S0dPPWcrIKvqwr3XRCJvaVafJfJU5iIiLpTWN+GwoY2jIv2FR2FHIRMKsH88dFoaDVg+Y5i0XGIiIjOSKfJjDd/L0CEtzPmJAeKjkNkFeI1bpjQ3w+r9pShTtchOg7ZOBbaj9h2uB4SAOdz2jZZiRmJGozo54k3thaglC1kiIiOszW/DgBwYTR/JKe+E6dxw6zkQHyVXo6simbRcYiIiE7bF3vLUdLYjgcujIScQ+SJjrprdDiMZguWbCsUHYVsHD9Zj/jjcD0SAt3g46IUHYUIACCVSPDkpAFQyKR4amMejGa2kCEi+qffDtUhIdAN/m4q0VHIwdwzJgL+rio8sykPHUaz6DhERESnVNWsx/s7izE2ygfncbYN0TFCvdS4dmgIfthfg/Qyreg4ZMNYaAdQ3azHgWodxkRxRxxZF383FeaPj0ZWZTNWppaKjkNEZDWqjqzdbBtDIriq5Hji4v4oamjHe2whQ0RENuB/WwtgAfDwRVGioxBZpZtGhiHATYVXtuRzoyOdNRbaAfyWVwsA7M9OVmlSrD8mDvDD8h3FyKvWiY5DRGQVfj10pG1MDAvtJMaIcC/MTNTgsz2lyKlkCxkiIrJefxY04LdDdbhlZBgC3Z1ExyGySmqFDA+Ni0J+XSu+2VchOg7ZKBbaAWw+UI0gdxWifJ1FRyHq1vzx0fBSK/Dkxlyeok5EBGBzXi1i/FwQ5qUWHYUc2P1jI+HnqsLiTQe5PhMRkVXSd5rw6q/5CPdW45qhIaLjEFm1cdE+GBnuhWV/FqGu1SA6Dtkghy+0t+iN2FFQj3ExfpBIJKLjEHXLQ63Aokn9UVDfhnc4nIOIHFyFVo+syhZcPMBPdBRycK4qORZeHIPC+jZ8sJMtZIiIyPqs2F2Kcq0e88fHQMEBqEQnJZFI8J+LomEwmfH2HwWi45ANcvhP2W0F9eg0WTC+P089J+t2XoQ35g4Kwhdp5fg9v050HCIiYTYfafk2cSAL7STeqHBvTE8IwKeppciqYAsZIiKyHiWN7ViRWorJsf4YGuYpOg6RTQjzUmPe0BD8yMGodBYcvtD+68E6BLirEB/oJjoK0SndPzYSsQGuWPzTQZRr20XHISIS4ue8WsRr3BDswbYxZB0evDAKGjcVnvgxF7oOo+g4REREsFgseHnzIShlUtw/NlJ0HCKbcuOIMAS6q/DiL4fYHpDOiEMX2lsNRuwsasCkOA2kbBtDNkApl+LFabGwwILHN+Si08QPfCJyLMUNbcir0eFi7mYnK+KqkuPZqbGobtbjpc2HYLFYREciIiIHtyGnGrtLmnD3mAj4uihFxyGyKU4KGR6fGIPChja8t6NIdByyIQ5daP+zoAEGkwWT4gNERyE6bcEeajw5aQD2V7Xgzd/ZM4yIHMsvebWQAJjQn4V2si5JQe649bx+2JRbi/XZ1aLjEBGRA6trNeCN3wswONgds5MDRcchskkjw71xWZIGn+0pQybbA9JpcuhC+6+H6uDtrMCQMC/RUYjOyLgYX1yVEowv0yvw68Fa0XGIiPqExWLBTwdqMCjEA/5uKtFxiI5zw/AwDAvzxCu/5iOvWic6DhEROaj//poPfacJj1/cn2fvE52D+8dGIsBNhcU/5UHfaRIdh2yAwxbadR1GbC9owEUxvpBJufCQ7bn3ggjEa9zwzKaDKKpvEx2HiKjX5VS1oLixHVPj/EVHIeqWTCrB81MHwsNJjkfX70ezvlN0JCIicjC/HarDloN1uGVUP4R7O4uOQ2TTXJRyPHFxf5Q0tuPdP4tExyEb4LCF9q35degwmjE5lgfrZJsUMilemhYLlVyKh9ZkQ9vOg3kism8/5FRDJZdiPNvGkBXzclbipWlxqGnpwMIfcmE0s187ERH1jWZ9J17eko/+fi6YNzREdBwiuzC8nxfmJAfii73l2FemFR2HrJzDFto3HahFkIcTkoLcRUchOmsadye8Mj0OVS0deHzDAR7ME5HdMhjN+CWvFhdG+8BVJRcdh+ikEoPcMX98NHYVNeKNrYdFxyEiIgfx1u+FaGozYNGk/pDLHLbcQ9Tj7r0gEoEeTli8KQ+tBqPoOGTFHPKTt67VgN0ljZg80A8S9isjG5cc7IHHJsRgd0kTD+aJyG79WdgArd6IS+I4wJxsw8ykQFw9pGueyjf7KkTHISIiO7erqAFrs6twzdAQDAxwEx2HyK44K2V4anJ/VGj1ePGXQ7BYuMmRuueQhfZf8mphtgCTY3mwTvZhWoLm6MH895mVouMQEfW4H/dXw8dFieH9OMCcbMd9F0RidKQ3Xv01H7/n14mOQ0REdkrb3olnNh1EhI8zbjsvXHQcIruUEuKJ287rh025tVibVSU6Dlkphyy0/3SgBv39XBDhw8EgZD/uuyASo8K98PKWfOwpaRIdh4iox9S1GrCtoAFTYv0h5wBzsiFdw1FjERvghoU/5CKjnH09iYio5z29fj8a2jrxzJQBUMkdssxD1CduGB6G4WGe+O9vh5Ff2yo6Dlkhh/sEPlzXiv1VLZjCU8/JzsikErxwaSzCvNR4ZG0OcqtaREciIuoR67OrYDJbcFlSoOgoRGfMWSnDG5clIMBNhQe+z0YO12ciIupBP+fWYENWJW4dFcaWMUS9TCaV4JlLBsJVJceC9fvRZjCJjkRWxuEK7euyqyCXSnBJnL/oKEQ9zlUlx1uzEuCilOHmT/egslkvOhIR0TkxWyxYk1mJoWGeCPNSi45DdFY8nRV4Z04i3J0UuPvrTGRXNouOREREdqBW14FXtuQjKcQD1w8PEx2HyCH4uCjx3CUDUdrUjpc2s187HcuhCu0Goxk/7q/B2GgfeDsrRcch6hUadye8NTsR+k4T7v0mC03tnaIjERGdtV1Fjaho7sAs7mYnG6dxd8LyuUnwclbgnm+ykFnBYjsREZ09i8WC534+CL3RjFdnJbK9HlEfGhrmiVtG9cPGAzWck0fHcKhC+x+H69HU3okZiRrRUYh6VZSvC5Zdk4LKZj0e+j4b+k6ezkREtun7zEp4OytwYbSP6ChE50zj7oRlc5Ph7azAvd9ksWc7ERGdtW8zKrGjsBH3XRCBSD9X0XGIHM5NI8IwKtwLr/x6GHtLOSePujhUoX1tVhU0bioMD/MSHYWo1w0L98ZzU2ORU9WC+ev3w2A0i45ERHRGqpr12Ha4HpfGa6CQOdRXFrJjAW4qLJubDF9XJe77Nht/FTeKjkRERDbmUK0Or289jJHhXpgzKEh0HCKHdHROnqca89ftR2lju+hIZAUc5qi1QqvHX8WNmJYQABlPqSIHMS7GF49NiMGOwkYW24nI5nyVXgEAmDOIbWPIvvi7qbB8bhICPVS4/7tsrOEpx0REdJraDCY8tv4A3J0UWDxlAKQS1jeIRHFVyfG/y+IBAA+tyYauwyg4EYnmMIX2b/ZVQCoBZiTyYJ0cy8ykQDw2IRrbCxqwYP1+dJpYbCci69dmMOH7rEqMi/FDoLuT6DhEPc7XVYUPrhyEYaGeeP6XQ3j7j0KYOUyLiIhO4ZUth1Da1I7npg7k7DkiKxDiqcbL0+NQ2qTHYxsOwGjm9zlH5hCF9vZOE9ZkVWFcjB8C3FSi4xD1uVnJQZg/PhrbChqwYP0BFtuJyOqtz66CrsOEq4cEi45C1GtcVXK8PisBs5IC8WlqKR7fcIBzVYiI6IQ25FThh/01uGVkPwwJ9RQdh4iOGBLqifnjo7GrqBFvbD0MCzdPOCyHKLRv3F+Nlg4jrkxh7zJyXHMGBeE/F0Xjj8P1eGz9AbaRISKrZTJbsDq9HImB7kgMchcdh6hXyaUSLJgQjfvHRuLXg3W47csMlGvZ45OIiI5VWN+GlzfnY0ioB24aGSY6DhH9y2VJgbh6SDC+TK/AJ7tLRcchQey+0G6xWLA6vQID/V2RxIN1cnBzBwfhPxdF4ffD9Xjge/YPIyLrtDW/DmVNeu5mJ4chkUhw7dAQ/HdmPEqb2jFvZTr+OFwvOhYREVmJVoMRC9bvh5NChmcvGci5c0RW6v6xkZg00A9LtxfhO87gcUh2X2jfXdyEwvo2zB0cBAmHhBBh7uBgPD15ANJKm3DHV5moazWIjkREdJTZYsEHO0vQz0uNcTG+ouMQ9akLonyw8toUBHk44eE1OXj7jwL2+SQicnBmiwVP/ZiHooY2PHfJQPi5sh0ukbWSSiR4evIAnBfhhZc3H8KWg7WiI1Efs/tC+ye7S+DjosTFA/1FRyGyGlPjA/DaZQkobmjDLV/sQ2kjT1EnIuuwNb8e+XWtuGlkGHdrkUMK8VTjw6sGHenbXoa7vspAVbNedCwiIhJk+Y7irjOSL4zCiHAv0XGI6BTkMilenhaHhEB3LPoxF7uLG0VHoj5k14X2jHIt9pRqMW9oCFRyu36qRGfs/AhvLJubhFaDCTd/sQ85VS2iIxGRg7NYLPhgZzHCvNT8gZwcmkouxWMTY7B4ygDk1bTiqk/3YuOBag7WIiJyMD/n1uCjXSWYkaDBlYM5c47IVjgpZHj9sniEeanxn7X7kVGuFR2J+ohdV58//qsUHk5yzEoOFB2FyCrFB7rjgyuToVZIcfuXGfg5t0Z0JCJyYL/n1+NQbStuGhEGOXezE+GSuACsui4FUT4uePLHPDy+IRfa9k7RsYiIqA/kVrfgmU0HkRzkjkfHR7MVLpGNcXdSYMnsRPi6KnHvt1lIK2sSHYn6gN0W2vOqdfizsAFXDwmBWiETHYfIavXzdsYn1wxGXIArFv6Qi7f/KITRZBYdi4gcjNFkxtvbCtHPS41JsdzNTvS3EE81ll+RjLtGh+O3/Dpc9ele/FXEU5CJiOxZna4DD6/JgadagVdmxEHJM/SJbJKvqwrL5yZB4+aE+7/NRmoJv8PZO7v9tF6+owiuKhlmJQZg2bIlmDFjEiZOHIMnnngUDQ31p7x/eXkZJk4cg5qa6j5IS3TuTCbTMe/1Bx984KTv9S1bfsYNN1yNCRNG444b5+J8QzouSwjAp6mluP2rTFSyHywR9RGTyYSHn3sZVaseRcOqB/H0k/NP+/PriitmYuXKT2AymY5en5m5D3feeTMmTBiNmTOnYOnSt9DZyV3A1Hf+vSaf7vdPAHj00Qdwzz23HXPZ7r/+xIcPz4L82wfRvPIePHztRIwePRSlFRW9EZ+IiATSdRhx33fZaOkwYuFoP/zvhUWYMuUiTJ58IZ566jHU1Z14uOJPP/2AefPmYsKE0bj11uuRmrqrD5MT2Z7s7CyMHTsCaWl7TnibUx175OXl4v7778LkyRdixozJeOmlZ9Hc/P+tYnxdVXh3bhKCPZ3w4Pc53DBh5+yy0L63tAnbChpww/AwfP35R9i4cQOeeGIxlix5HzU1NVi48NGT3r+kpBgPPng32ts5IJJsx0cfvXfMe726uuqE7/WdO//EM88swrRpM7BixWrcccc9+OLzTxFUuQ3PTx2Iw3WtuObTNPx6qK6PnwUROaJl7y/D3u2/IGLKrVj6zsnX6u4+v1atWoGVKz8GAFRVVeLhh+9DXFw8VqxYjYULn8amTT9i2bK3+/IpkYP795p8Ot8/AWDNmm+xY8f24y4/fDgf/fsPwNq1P+Grb3/E5P8sQ8eUp3H/xlL2/CQisiMdRjMeWZuDwvo2vDItDsteXoiWlha89dYyvP32e6ivr8ejjz7Y7X1/+eUnPP/807j44in46KNVmDx5KubPf/ikBUQiR9be3o7nnnvymKL5v53q2KOurhYPPHAXgoKCsGzZx3j22Zdw4EAOFi167Ji/4+OixLuXJyHMS42H1mRje8HpbcAg22N3hXazxYI3fy+Av6sSsxL88PXXq3H77Xdj2LCRGDBgIBYvfgFZWRnIysro9v5fffUFbrnlOri6uvVxcqKz19nZedx7/dVXXzvhe33t2m8xduxFmD37CgQHh2DcuAm48spr8MMP63HxQH98Ni8FIZ5OmL9uP17afAhthhMvPERE5+Lvzy9j7CV4Yt40DBwYe9K1+mSfXwBQWVmBsWPH4d57H0JwcAiGDRuB8eMnYs+e1L5+auSguluTT/X9EwDKykrx3ntLkZCQdNx1hYWHERkZDR8fXwQF+OOJGUOx5NrzYTQDt67OwP9+Owx9J9dqIiJb1mky47H1+7G3VIunJw9AjLsZ4eHhWLDgCcTE9EdMTH9cccXVOHgwF83Nzcfdf9WqTzFx4mTMm3cjwsL6YfbsuZg0aQo+/vh9Ac+GyPq9/fb/4Od38paVpzr22LLlZyiVSjzyyGMID49AUtIgPPTQfOzduxtVVVXH/C0vZyWWXp6EKF8XPLImB+uyq7p7SLJxdldo35xXiwPVOtw5OhylRfloa2vF4MFDjl4fGBiEwMAgZGSkd3v/7dt/x6OPPo577nmgryITnbNDh/KOe68HBwef8L1+/fU348Ybbz3mMolEgpaWri9sIZ5qfHjVIFw9JBjfZlTiik/28BdXIuoVv/yVDmNHOy4aPQoDA7p+5D7ZWn2qz6/Bg4fgiScWH70uLy8X27b9juHDR/bisyD6f92tyaf6/mkymfDcc0/hmmuuQ3h4xHHXFxQcRr9+x14+op8Xvrh+CGYnB+KLtHJc9ele7C3lkC0iIltkNJmx8IdcbCtowPzx0ZgU6w8fH18sXvwiAgODAAA1NdVYu/Y7xMbGwd3d/bi/UVZWgqSkQcdcFhMzANnZmTAajX3yPIhsxc6d27Fz55944IH/nPR2pzr2GD16LJ555kXIZLJjrgdw9Db/5KlW4N25SRgW5oVnNx3EBzuLYbFYzvXpkBWxq0J7q8GIt/4oRIyfC6bEBqC2tgYAjvuFytfX94S91996axkmTJjU61mJetKZvtdjY+MRERF59N9bW3VYs+ZbjBgx6uhlCpkUD14YhQ+uTIZaKcOD3+dgwfr9qNN19NKzICJHYzRb8P6WTADAI5ekHHPduXx+/W3y5Atx883Xws3NDddff3MPpyfq3tl8/1y58mNIJMBVV8077jqTyYTi4mLk5R3A9ddfhRkzJmPBgodQUlIEF6Uc8yfEYNncJFgswB1fZeKVLfk8E42IyIZ0msxY9GMufjtUh4fGRWHOoKDjbvPYYw9j1qypyMnJxqOPPtHt3/H19TtunamqqkBnZyd0Ol2vZCeyRY2NjXjppWcxf/4TcHM7eTeLUx17BAeHIDl58DH3WbVqBfz8/BEZGdXt33RRyvH6ZfGYGueP5TuK8cIvh2A0s9huL+yq0P7u9iLUtHRgwYQYyKQS6PV6SKVSyOXyY26nUChhMBgEpSTqeefyXtfr9XjssUfQ0dGBO++897jrk4M9sGpeCu48PxzbDtdjzsd78NmeMnQYzT36HIjI8Xy+pwwVDc2QSKTwdlUfc925fn6ZzWa8/vo7eO21t6HX6/Gf/9zP3SLUJ850Tc7NPYDVq1dh4cLFkEqP/2peXl4Gg6EDnZ0GzJ+/EM888xIMhk7cddetaGxsAAAMCfXEF9cPwZUpwfhmXwWuWrEHOwobeucJEhFRj+kwmvHouv3YfLAOD4yNxFUpwd3e7pZb7sR7732CpKRkPPjg3Ud/1P2nSZMuwXfffYU9e3bDZDIhLW0PNmxYBwAwGjkUnuhvixc/jfPPvwAjR553Rvc7Ve0EAN59923s2LEdDz88/5hd7v8ml0nx1OQBuHFEKNZkVeE/a3Og6+CZJ/bAbgrt2ZXN+Cq9AnMGBSEpqOs0KpVKBbPZfNxpUp2dBjg5qbv7M0Q26Wzf601NTXjggbtw8GAuXnvtLWg0gd3eTiGT4qaRYVh9/VAkBrnjzd8LMPujVKzLruIvr0R0Vg5Ut2DZjiLEB3vDYun5zy+pVIrY2HiMGDEKCxcuRlZWBrKzM3vluRD905msyR0dHXjuuSdx6613IiQktNu/FxbWDz/+uAUvvvga4uISkJw8CC+88CosFjN++unHo7dTK2R4eFwU3rsiGQqZFPd/l43H1h9ALc9EIyKySroOIx74Lgt/FjTgsQnRuGZoyAlvGxUVjbi4BCxe/CLMZjM2btxw3G2uvfYGXHzxFDzyyH0YN24U3nzzv0fPlHJxce2150FkSzZu3IDc3AO4557uhwqfyKmOPUwmE/773xfx+eef4uGHF2D06LGn/JsSiQR3jY7AggnR2FnYgOtXpaOgvvWMcpH1sYtCu77ThOd+Pgg/VyXuGh1+9HJ//wAAQH193TG3r6urg5+fX19GJOpVZ/Ner6yswB133ITKynIsWfI+YmPjT/k4oV5qvD07EUsvT4SvixLPbjqIq1fsxZaDtTCx4E5Ep0nXYcTjGw7AS63A7RO7eon21OdXYWEBUlN3HXP7qKhoAEBtbW1PPg2ibp3Jmrx/fzaKigqxbNnbmDhxDCZOHIONGzcgM3MfJk4cc3SIlru7xzG73Z2cnBAUFNxtK5pBIR74/LohuOP8fvjjcB0u/3gPvkwr5zpNRGRFqls6cOvqDKSXN+PpKQMwK/n4djENDfXYvHnTMZc5OTkhODi42+80CoUCDz00Hz///Ae+//5HrFixGk5OTvD29oFazY2GRADw44/rUVVVhRkzJmHixDG4+urZAIBHHrkfr776Qrf3OVXtpKOjA48//gg2bFiLRYuexcyZs88o0+zkICydmwRdhxE3rtqHXw/ymMWW2UWh/bXfDuNwXRsWXtwfrqr/P003Oro/nJ1dsG9f2tHLKisrUFlZgeTklO7+FJFN6u69Xl5efsL3emNjA+677w5YLGa8++5HiI6OOaPHGxbmhY+vHoRXpsfBAgsWrD+Ayz9OxTf7KqDvZF9YIjoxi8WC538+hEqtHi9cGovB8XFntFaf6vNrx45tePrphejo+P9dvPv3ZwNAt0MmiXramXz/jIuLx+rV3+Pjjz8/+s8FF4zDgAGx+Pjjz+Hr64s//tiKiRMvQGNj49H7tbW1orS05Jieof+klEtx88h+XWeiBbrjv78dxo2fp+NAdUvvPGkiIjptOVUtuOnzdFQ26/HmrARcEhfQ7e2qqirx9NMLkZu7/+hlOp0OJSXF3X6nee+9pfjss0+gVCrh4+MLANi2bSuGDRvRO0+EyAY9+eSzWLdu/dHvXa+9tgQAsGDBE7jlljuOu/2pjj3MZjMWLVqAvXtT8fLLr+PiiyefVa6UEE98em0KIn2dMX/9Abz9RyG7B9go+alvYt02HqjGmqwqXD88FOdFeB9znVKpxGWXzcE777wJDw9PeHl547XXXsKgQSlISEhEZ2cnmpu1cHHRCEpP1DO6e6+/+eYrx73X3d09oFAo8NprL6OpqQlvvfUuVCrV0V13EokE3t4+p/WYEokE42J8cUGUD7bm12Flahle3pKP5TuKMSc5EDOTAhHgpurNp01ENuid7UXYfLAW946JQHKwBwCc1lp9up9fkydPxeeff4oXX3wGN954K2pqqvDqqy9i/PiJJxxIRNSTTvf7p7u7B1Qqp+Naxri4uEClUh29fNCgFLi4uODZZ5/EXXfdB5PJhOXL34GHhycmTbrkpFlCvdR4a3YCfsmrxf+2FuCGVf/H3n3HV1Xffxx/3ZG9QxIgQAjzyxRQQZYVUcS9ra3WWVyt2roqzmpbq3W0TtzbVq3aof4cdbNUVIag8GXvlQAJ2ePm/v44N5CEAAm5I+P9fDwuueOccz/3w7n3e87nfM/3zOOs4dlcPi63XucUEREJj3cWbczaXPAAACAASURBVOaej5fRKSGap382jH6Zex/SZcCAQQwbNoJ77vkTv/vdzXi9Xp544lFSU9M47rgTqagop7i4mNTUNAC6ds3m0Uf/Rp8+fcnJyeWNN15l8eIfuf76qeH6eCKtXmZmFqmp8RQUlALOdhs4FxNOS0tv9r7Hv//9JrNnz2Dq1Fvp27dfvTMaU1JS97hmz750TorhyZ8O44HPVvDSN+uYt76QPxxv6J6qM1Lakja9hb1kSxF3f7SM4d2SuXxcbqPTXHLJFVRXV/PHP95GdXU1hx02lmuvvRGAhQsXcPXVl/Pccy/Qv/+QMEYuEnwN1/Xx4w/nqquuB3av6w8//ASDBw9h+vTPqKmp4ZJLLqi3DI/HwxdffN2s9/W4XRzVP5OJ/TKYv2Enr3y7nme+WstzX69ldG4aJw/pwk/6dCLK0y5OoBGRFnh17gZenLOO0w/qynkjd49D2pS2uqm/X506ZfDQQ0/wyCN/Y8qU84mLi+OYY47j0kt/FdbPKh1bU9fpgw8+dL/LSk5O5sEHpzFt2sNcddVl+Hw+Ro4cxUMPPUFMzP4PaLtcLo4ZkMWY3HQen7Waf87byCdL87n2yD4c3T8Dl8vV4s8rIiL7Vlbl4/5Pl/P2oi0cmpPK3ScMJDU+ap/zuN1u7rrrPh577EF+97trqKysZNSo0Tz66FPEx8fz3nvv8Oc/38kbb7xNp05JnHTSqWzbls99991NUdFOBgwYxMMPP05OTm54PqRIO9DcfY+PPvoAgHvu+dMey3rssWcYNmx4s94/2uvmpkn9GNE9hb98soxzXvqOayf04ZShXbTN1ka4/P4DOxUhL68ooucwrNtRxpTX5hPtcfPcOcPJTDzwnrN1j2ZJaCnX4RPJXK8vKOOdH7bw7qLNbC2uJDUuimNMJpNMJgd1S8bdzhoIrdfhoTxDZmZSi7484Wi79/b/9I/v1vO3z1dyZL8M7j5xIB53+/odCBWt98GjXDp+2Ox0VLFbixnRPYXrJvTBdG7eRfKUy+BRLoOnteaypW13YyK9L94atNb/78bYrcXc9n9LWL29lAsP68GlY3PxBnk7qC3lIxyUj/qUj/raSj427yznzg+X8u3aAg7vnc4tx/SnU0J00N+nreQjXPaWj6a2522yR/vmneVc+dZCavzwyJlDW1RkF5Hg654axxXjcrl0TE++XrODdxZt5r+LNvPP+RvJSozmqP6ZHNU/gyFdk1VsE2nnavx+HvpiJf/4bgMT+2Xwh+MH6HsvEkGDuyTxwrkjeHvhJh6ftYbzXpnLSUM6c8X4XmSEYOdNRKSjqvbV8PycdTz71VpS46J45MyhHNYzLdJhiUgb0SU5lsfOHMprczfw2IxV/PSFb7liXC6nHdRV+1OtWJsrtC/dWsw1/15ESaWPx84cSm56fKRDEpG98LhdjO2Vzthe6ZRUVjNjxXY+tnm8uWAjr87dQFpcFGN7p3N473QO65mm8WJF2pn1BWX88cOlzF1fyNkjsrlmQh9tFIq0Al63i9OHZTPJZPHsV2t5fd4GPrb5/GJkd845pBsJ0WqPRURa4rt1Bdz/6QqW55cweUAm10/sS2rcvoeKERFpyO1ycc4h3RmTm869nyzjL58s578LN3Pj0X0Z0jU50uFJI9rUVvRny/K58wNLQrRnvxcOEZHWJSHay7EDszh2YBbFFdXMWrmdGSu3MWPFNv7vhy143S6GZiczKieVUT3TGNQlKeinVIpIeBSUVvHGgo28/M063C4Xt03uz0mDO2tcQZFWJinWy28n9Ob0YV15ZPpKnpq9hjfmbeTi0TmcflBXor26voqISHNsKargoS9W8pHNo2tyDPefMogj+mZEOiwRaeN6dYpn2lkH8ZHN48EvVnLRP+ZzypAuXDq2J1lJGuWjNWkThfbtpZU88OkK/mfzGJCVyP2nDqazViSRNisxxsvkgVlMHphFdY2fhRt3MnPlNuasKeCp2Wt4cvYaEqI9HNw9hVE90xiZk0qvTvHtbmx3kfZgWV4xW4sr8fv9rN5extL8Uj61W6moruGIPp24fmIfuiTHRjpMEdmHnLQ47jtlMIs27eSxGat44LMV/OO79UwZ05PjB2bh1QXNRUT2qbTSx2tzN/D812vxA5eMyeH8kT2IjfJEOjQRaSdqL3A/rnc6z3y5ltfmbuD9xVs4c3g2F4zqQXq8hgBsDVptob2yuobFW4p4e9FmPlySh6/Gz2Vje3LhqB7a2BdpR7xuFyO6pzCiewoABWVVfLeugDlrCpizdgczVm4HICXWy0HZyYzonsLwbikM6JxIlH4LRCKq2lfDea/Mw1ez+5ps2SmxHD8oi58d3I3enRIiGJ2INNeQrslMO+sg5qwp4LGZq/jjh0t5evYazhvZg5OHdFbBSESkgeKKat6Yv5G/f7uewvJqJvTtxG8n9KZbSlykQxORdioh2stvjujNWcOzeebLNbw2dwP//n4TZ4/oxrmHdCc1XsNURVKrKbQXllVx6/8tobC8iuoaP2u2l1Lp8xPrdXPCoM78/JBuGo9dpANIjYsKXCw1E4CNheV8t66A+RsKmb9h567Ce4zXzdCuSQzvlsLw7ikM7ZpMfLQKACLh5PW4+fcvR7KtpBKArsmx9OmWqqvWi7RhLpeLw3LTGNUzldmrdvDc12u579PlPPvVGs45pDunHdSF1EgHKSISYQVlVbw537nu1M7yasb1SmfKmByNmSwiYZOdEsvtxxouGNWDp79cw4tz1vHq3A0cNzCLnx+iTk+R0moK7R63i7T4KDxuFy4XjMpJ46DsJA7NSSU5VkdjRDqq7JRYslO6cNKQLgDkl1SyYEMh89Y7hffnvl5LzVfgcUH/rESGd0thSNckBndNIjs5VmNCi4RY1+RYumpoGJF2x+VyMa53OmN7pTF3fSEvfL2OR2es4pkv13DqiG6cNjhLO3Ai0qH4/X5+2FzEm/M38pHNo9Ln5yd9OvHL0TkM6pIU6fBEpIPqmR7Pn04YyMWjc3j1uw28v3gr/1m4mdG5aZw9IpvRuem6/l0Yufx+//6nakReXtGBzdgKpabGq/ddmCjX4dNRcl1cUc3CTTuZv76QeRt28uPmIiqqawBIi4ticNckBndJcorvXZJJig3+8cWOkutIU54hMzOpRVtI4Wi79f8UXMpn8CiXLbd0azH/nLeRD5Y412EYmZPKGcO6cnjvTrpw6gHSehk8rTWXLW27G9Oe9sUPVDj/vwtKq/hkWR7/+X4zS7YWEx/l4fhBWZwxPJu+Ga3jgGNrXf8jRfmoT/mor73no6C0ire+38gb8zexraSSjIRojh+UxQmDOzfaSaK956O59paPprbnraZHu4jIgUiM8TImN50xuemAM2b08vwSFm0q4ofNRfywqYiZgeFmAHqmxTGgcyJ9MxLol5lI38wEshKj1fNdRERkP/pnJXLr5P7cfOIgXpq5kjfmb2TqO4tJifUyeUAWJw7pzICsRLWpItLmFVdU8/nyfP63JI85a3bg80PvTvH87qi+HDcwi8QYlVJEpHVKjY/il6N7cv7IHsxcuZ13f9jC379dz0vfrGdQlyQm9svgiD6dyO2k4blDQa2DiLQrXo+bAZ2TGNA5iTMDzxVXVPPD5iJ+3FzEok1FLNiwkw+X5O2aJynGS9/MBPpmJJCTFkeP1Di6p8aSnRKrC66KiIg0kJ4QzYWH5XDeyB7MWbuDdxZt4T8LN/HP+Rvp1SmeI/tlMLFvBv2zElR0F5E2we/3s3p7GbNXbWfWqu3M31BIlc9PdnIMvxjZg2NMJv0y9ZsmIm1HlMfNkf0yOLJfBttLK/lg8VY+WLyVR2es4tEZq8hJi+OIPp2YNLQrvZKiddH7IOnwQ8dMm/YI999/N8XFxZEORSTkEhISueGGm/jVr66KdCgRV1RezfL8EueWV8KyvBJWbiuhpNK3axq3C7okx9Ij1RmDOisxhszEaDIDf7MSY0iJ85KWlqBTrcJAp7Rp6Jha06Y9wn333U1JidpuaT/aUhvd2Pd8Z3kV/1uSx8dL85i3vpAaP3RNjmFC3wwO65nG8O7JJESrj09DatuCp7XmUkPHhEZL/7/9fj/rCsqZv6GQBRsK+XZtARt3VgBOz/WxvdKZ2C+DIV2TWm1xXdtDIuHVlrbV9mVLUQXTV2xj+vJtfLuugOoaP9EeF0O6JnNoj1QO7pGCyUrssGfutHTomA5faB86tD9btmyOdBgiYdO5cxcWLlwa6TBaJb/fz46yKtbtKGN9QTnrCspYX1DG2h1lbCmqYHtp1R7zRHlcdE6KpVN8FOkJ0aTFRZEaH0V6XBRp8VGkBv6mxTn3veohf8Ba6w50OKnQ7lDbLe1VW2mj9/c931FayYwV2/lseT5z1uyg0ufH44JBXZI4NCeVg7KTGZCVSEZiTBijbp3UtgVPa82lCu2h0Zz/b7/fz8ad5SzdWsKyvGKWbi1h4aadu7btU2K9jOiewpjcNMb2SqdLG7nIu7aHRMKvrWyrNVVxRTXLCsr5YvFWvltXgN1aTG0Dk5MWh8lKZEBWIr06xZOTFke3lNh2X9PQGO0tdMUVV6lHu3QYCQmJXHFF2z76Gkoul4v0+GjS46MZ1i1lj9erfDVsK6lka3ElecUV5AX+FlbWsGF7Cau3lzK/tIrC8ipq9rL7kxzrdYrvtQX4QBE+JVCIT471khIb+BsXRVKMF4+uEC5SzxVXXKUeXNLutKc2Oi0+mpOHduHkoV0or/Lx/cadfLuugG/XFvLSnHX4Am1kp4RoBmQl0i+zztBtaXF0io9qtT1IRaT18tX42VJUwbodZawtKGP1tlKnsJ63+6xVtwt6psUzOjeN4d1SGN4thZ7pcbjb4G+OtodEwqs9bavVSozxcqTJYkTnRMA5Q3HhpiLslmIWbyli0aadfGR3D7vrcUF2ijPMbkZCNBmJMWQkRJOZGE1GQjSdEqJJjYsiIdrTYbflOnyPdmi9vR/aI+U6fJTr8GmYa1+Nn6LyaraXVbKjtIqCsip2lAZugfsFZZVsD7xWULb3wrwLSIr17lGAT2nwuOHzCTGeNrnDsC9ap9WjvSNSPoNHuQyeluSytNKH3VrMkq3F2C1FLNlazOptpbuK7wBxUW4yAztudXfaEmM8JMZ4SYh2/iZGe0mI8RAb5SHW6ybW625zvay0XgZPa82lerQHT+3Zp1uKKijywYrNO9m8s5wNBeWs3VHGhsIyKuv8mMRFuemXmUj/zAT6ZSViMhPok5HQLschbq3rf6QoH/UpH/UpH/XtLx+FZVWs3eGc6b+2oIy120vZXOR0PNxWUkl1I8UMj8sp4ifHekkK1C2SY7wkxXpJqX1u1+veBtt3nohuz6lHu4hIK+Nxu0iNd4aQodP+p6/x+9lZXh24VVFYVk1heRU7y6spLAv8La+isLyagkAjV1heRXGFb6/LdAEJMR4SowMNV22jFeMlKcZLYuC5pLrPxdSfJtrbtooVIiLS+sVHexjRPYUR3XefOVbtq2HTzopdQ7atKygnv7iSbSUVLN5SRH5JJWVVNU1avsftItbrJsbrJjbK4/wN3GICBfna15z7HmKj3Pu8H+v1ENPgfozX3e4OaIuEk9/vp6K6hpJKH6WBW3Gls+27PdBBZXtpJTsCj7eVVLKlqIKK6vq/BTFeN9kpsfRMj2N873R6pMXtOkMmMzG6w/aoFBEJlpS4KIbGRTE0O3mP12r8fgrLqsgvqSSvuJL8kkp2lldTFKhfFJVXs7PC+buhoMx5raJ6rx0Na8V43bsK7wnRnl3346Odbbtojxuv202010WUx3kc5XER7XHTNSWWsblpEfv9V6FdRCTC3C4XqYGhYyCuyfNV1/h3NWD1CvJl1RRXOA1YcaWP4vJqiiur2VJUwYptpRRXOK/vr3GL9riIi3IatbhoD/FRHuKjPcQF/tY+jo/2EOv1EO11E+2p29A5Dd+u+4HXojxu3C7nc7tdzpA9DR97XC5cDZ4rr/JRXuUcXPADtSdk+fFT9+Qsv7/+c/7AP3781PidjQFfze771TV+avx+amrA56+978fnJ/C3dvrdz9W97wtMU3cZgzonYQKn34mIyL55PW56pMXRI23vbWBldQ3FldWUVDjFuOKK3ffLq2qoqK6hvNq31/sV1TUUlVeTF7hfXrX7+SrfgXUOjqkt2tcp3te2Xx63C7fLhccFbrcr0LY57Vrta24XxER78VXX4HE783hcLrye2r9uvG5n+rp/d99343WD1+12lukGj8tV7z087sB71j5XZxq324XX5TwXKgd48nTTlo1TrPX5nb/xOyvYubMcn9/ZBtjVNu9qu512v+48u6at8dMzPZ6DGikidBR/+MCyYONOwMkNNNzeCvD7d913trmoN09j8zU8i77SV0NppW+/26Ipsd7AUIvR9M9M4PDeneiSHEOXpBj6dUshHj+pcRpqSkQkUtwuF2nx0aTFR9Mvs2nz+P1+Sip9gYJ8NTsrnE6EJXW280oqfJRU+pztvUrntfUF5ZRUVu/adqv01VDlq9mjLYn1uvnfr8YQF6Gzl1RoFxFpo7zu3Y1ac/n9fkqrfBSV1y/GF1VUU1zh21WML630UVblo7SqhtLKakora9hWUuXcr6qhrMq3R88igbG90njo9KGRDkNEpN2I9rpJ90aTHh/8Zftq/I0X56v2X7yvW7Avr6rZ48DrrkKvr4YKf/2DuH4/4HJRVe3bdQC32ldDdeAgbt2/jZ2WLcHVMy2ONy8eGekwIqZ3RsKubbq6dWuXy4Vr1/3A3zoPXLWPA0/tmtrV+PMul7MNmxDtIT7a6Z2YUKcDR+31i1LjovY5dICGfhARaZtcLteuM+nZ89J4zear8VPlq6HSV0Olz0+s1x2xIjuo0C4i0iG5XC4Sor0kRLe8Gaj21VBeHWjYGhxdbni0udLnNIL+Xb3KCBQhanua7X68+zXnb3xcNOXlVU78NL4TuNcdw8BrdXsUugO9Amt7Fe7uYbj/HoD1lhH4W3cZ6fFRLc6riIiEh8ft2nWGVrg1p1hYv/hes0cxvvZsrbpnYjXpDK0af/0GNMhC2de4tg13u10kJ8ZQWlpZ5yy5OmfMBdruumfN1T37wOWCtLjmd1xoT35xaPdIhyAiItJsHrcLj9vTaq6/oUK7iIi0iNfjJjEMFytRzyUREenIPIEhYwKPIhpLa6TtBBEREYk0XelORERERERERERERKQFVGgXEREREREREREREWkBFdpFRERERERERERERFpAhXYRERERERERERERkRZQoV1EREREREREREREpAVUaBcRERERERERERERaQEV2kVEREREREREREREWkCFdhERERERERERERGRFlChXURERERERERERESkBVRoFxERERERERERERFpCb/f3+Fvd9xxxx2RjqGj3JRr5bo93pRr5Vk3/T8pn63/plwql63xplwql7rp/1v5UD6UD+VD+Wg9t5bmQz3aHb+PdAAdiHIdPsp1+CjX4aE8tw36fwou5TN4lMvgUS6DR7kMHuWyY9H/d33KR33KR33KR33KR33KR30tyocK7SIiIiIiIiIiIiIiLaBCu+POSAfQgSjX4aNch49yHR7Kc9ug/6fgUj6DR7kMHuUyeJTL4FEuOxb9f9enfNSnfNSnfNSnfNSnfNTXony4/H5/sAIREREREREREREREelw1KNdRERERERERERERKQFVGgXEREREREREREREWkBFdpFRERERERERERERFrAG+kAQsEYEwM8ApwFVAB/tdbeu595xgP/sNbmNHj+SOAhoC8wB5hirV0eksDboCDn2gL9G0w+wlo7P4ght1nNybUx5mzgNqAXsBy41Vr7Tp3Xfwr8GcgGPgIusdZuDe0naDuClWtjjBsoBuIazJZmrS0IUfhtRjPzfBFwC9ANmAtcY62dU+d1rdNhEszfIgnu96CjO8BtknTgR2CqtfaFkAfZRjRzvfwQOKbB06dZa/8T2ijbhmbmcgAwDRgNrAdusta+Fa5YW7um5tIY8zlwRCOL+MxaOzGkQUpQBL4Lj+J8F7YBj1pr79vLtIcDDwIDgGXA76y1/wtXrOHQzHxMBO7H2a+ej7Ot8E24Yg03Y8zTQD9r7YS9vN6h6jn7y0ed6c4FrrDWjg9LYBHShPXjauAqoCuwELjOWjs7fBGGVxPyMRX4NdAJmA5cZa1dFr4Iw68Z35m+wPfA8dbaz/c1bXvt0X4fMAY4GrgMuNUY87O9TWyMGQq8SYN8GGN6AG8DrwCHApuB/waKZ+IIVq5jgD7AOJwfudrbotCE3SY1KdfGmJ8AL+NsUAwDngX+ZYwZEXh9JPAi8CecjbVk4KVwfIA2JCi5BnoDsUAu9dfrwhDH31Y0Nc+TcAoPtwBDgK+B940xSYHXtU6HV7C+H+IIyvdAgGZukwQ8CHQOdWBtUHNyORj4GfXbuffDEWQb0dTveCLwMU6BfRhOUe1VY8ygMMba2jV1vTyd+uvj0UA18LcwxSktYIyJwvkNWQsMxyn63BYoDDacNgt4B3gDOAj4J/AfY0zP8EUcWs3Mx0DgA5xOJ4fg1DI+McZ0D1/E4WOMOQqYso/XO1Q9Z3/5qDPdkcBToY8ospqwfvwC+CNwE85363PgA2NMt7AEGGZNyMcU4HrgEpztkB3Au+31+wLN+s64gGfYswNlo9pdj3ZjTALOinGStfY74DtjzL3AlcBrjUx/Gc4R35U4R23qugRYUNtTwhhzMc6P80ScDeEOLci5NoAf+MZaWxXSwNugZub6fOAta+3TgccPG2NOBM4G5uEcsX2rtueeMeZ8YK0xpm97PrrfVEHO9SBgrbV2TXiibzuamefOwO+tta8H5r0DuAYYCsxG63TYBPn70eEF+XvQoTV3myQwz3HAKCAvbIG2Ac3JpTEmGecMi6+ttZvDHmwrdwC/mVXALwPbwsuMMcfgFJZ/DGPYrVJzcmmt3V5nPhdOoe1FnVHVZnTD6Xn8a2ttGbDcGPMxzlkKf28w7TgAa+09gcd/NsZch9Pxor1sfzcnH78CvrPW3hh4fG+gh/uvcYqJ7UbgN+EpYNY+Jusw9Zwm5gNjzO9x1oX23ku5Kfm4EJhmrX0z8PgmY8wZwEnAE6GNMLyamI8k4AZr7QeBee4GFgBdgI0hDzLMmvqdCbgc8DR12e3xyMQwIAaYWee5mcBIY0xjiTkOuIDGeziMxjldAgBrbSnOqdpjghZt2xbMXA8CVqrIvlfNyfUjOEdm6/IDqYH7DdfrdTgbolqvHcHM9SDAhiLIdqDJebbWvlJnAzkOp7i4ld1nvGidDp9gfj8kuN+Djq5Z2ySBMwGeAC4FKsMSYdvRnFwOAspxelrKnpqTy4nA23W3ha21J1prnw19mG1Cc/c7av0MZ0iRW0IYmwSRtXa1tfZsa22ZMcZljBkH/AT4pJHJtwEpxpizAtOeilMs+j6cMYdSM/PRG/iywXMLaJ/bxHfh9ED+fB/TdKR6TlPyATAJmAy092HJmpKPW9mzZ3973VfZbz6stX+z1j4PYIxJwTlA9wPOwan2qEnfmcCZMXfi7DM0Sbvr0Y5zeuB2a215nee2ANFAFrCp7sTW2lMBjDEX7mVZDY/cbAHa5alXByCYuR4E+Iwx7wMjcIqTv7PWfh2CuNuiJufaWrug7ozGmMHAUTg7GrXL0nq9d8HM9SAgyRgzHeiH04v3Gmutiu/N/P0AMMZMZvdwBOdaa3fWWZbW6fAI5vdDgvs96Oiam8t7gQ+stdONMWEKsc1oTi4HAQXAa8YZJ3kdcIe19r1wBdvKNSeXfYB5xphpwGmB12631r4brmBbuWb/XgbcDDxurd0S4vgkNNbjXH/nXZzhRxuagTPM0utADU6PwynW2sVhizC89pePxrZ/ewIZIY4rrIwxY3Cu1TAEuG4fk3aIfYRm5IPaMdkDw8e0S03Nh7X2qwbzHYtzbYP2drZDk9ePwPSXAk/iXAtlsrW2JrQRhl8zc/IkTmfhJp8F0h57tMfjrBB11T6OCdKymruc9iqYuR4IpOGMP3s8zimynxpjclsSYDtyQLkOjFv4b5yN0H/tZ1larx3BzHXten0HcApOr7/PAkeIO7oDyfMC4GCcI8ovGGNG72dZWqeDL5jfDwnu96Cja3IujTFH4JwW/LswxNUWNWe9HAgk4gzNcSzwHvCOMeawkEbYdjQnl0nADTgHLo7HKRz+xxhzSEgjbDua/XtpjBmP05v9kRDGJaF1SuB2MI2fFZ2Ac8H1PwEjgRuBh9px27i/fLwGnG6MOcMY4zXGnACcjHNAql0wzrXdngV+a63dsZ/J2/0+QjPz0e4daD6MMf1xrvH1krX221DFF24HmI8Pca7x8BzONQ16hSq+SGhOTgJD0mbjXCOmydpjj/Zy9vzhrH1cGqRlbTuAuNqjYOb6HCCutmeeMeZXOGPunQ/8oSVBthPNzrVxLnrzP8AHnFnnSOTeltXc/7P2Kpi5PhzwWGtLAtOdg9Pb7xR0sc5m5zkw/u9mYH7gKPTlwFf7WJbW6eAL5vdDgvs96OialMvAsDvPAFdZa3Vh6sY1Z72cCtxlrS0IPF4QKAxfhnPB3o6uObmsBhZaa28OPJ4XOEvgUpx8dnQHst9xNvCptXZ9yKKSkKoteBlj4oEXjTHXW2vrDvd1AxBjrb098Hhe4Ay6W4ETwxtt6O0vH9ba/xljbsK5+Gc0zjApj+IMTdVe3A4ss9a+0YRpO0I9pzn56AianQ9jzBCcfZUltL/2ttn5CFxfbo0x5tfAkTjDP98RmvAiokk5McZ0xrnG5PHW2mpjTJPr5+2xR/sGIM0YU/eobRecI5fbG59ln8vq0uC5Luz91MSOJmi5ttZW1T393Vrrx/mha5dXfD4Azcq1MaY3Ts9RPzDBWlt3Y0Lr9b4FLdfW2vLaInvtY2AVWq+hGXk2xowxxgxrMP+P7vPU7gAAIABJREFU7D4NVut0+ATzt0iC+z3o6Jqay1FAX+BlY0yxMaYYp6fKE8aYdnXhqxZo8npprfXVKbLXWozauVrN+c3ciLPtW5cFckIXXptyIPsdx6GzqNocY0w3Y8zJDZ7+EadwnNzg+ZE4Z3rV9R3OWOXtQjPzgbX2vsDz3ay1IwNPrw5pkOF1DjC5Thv+O+DwwP2GOsI+QnPy0RE0Kx/GmEOBL4ClOAXV8sama8OanA9jzCRjTN/ax4Ga3GLa375GU3NyLM5n/zzwWu327vvGmJvZh/ZYaJ+Pc1GrsXWeG49z9e3qZi7rq8C8wK4jxyNQz7FaQcu1MWaOMebGOo/dwEHsucPRUTU518aYdOAjoBA4opExKRuu1z1wduK0XjuCkuvA6ZobjDE/q/NcIs5Y7Vqvm/f78Wv2vKjmITgNP2idDqdg/hZJcL8HHV1TczkH53d4eJ3bFpzeLbcj0Lzv+ZuBMcXrGoHauVrN+Y5/iTMcRF2DaF8FspZo1n6HMSYDZ9z7L8ITngTRQOBfgWHnah0C5Flr8xtMuxHne9Jw/hUhjC/cmpwPY8zPjDGPBjqxbTbGuHB69n8WxnhDbQLOuMq1bfjTwLeB+w11hHrOBJqej45gAk3MR6BD0Ac4Z34cb61tjwcnJtD09eP3wNW1DwI9uIfR/vY1JtC0nPwLZ8z+2ulqh/KbAuyzc067GzrGWltqjHkRmGaci252Aa4HLgEwxnQBCq21ZU1Y3HPADcaYW3DGlr0NWEvjV/jucIKc63dxcr0QZ8PoWiAd5/+gw2tmru/COfJ2BuANvAZQFjhN/nHgC2PMLJyNjIeA9621Tb64Q3sWzFwbYz4E7jLGbMTpbXUXTg+Kd8L5mVqjZuZ5GjDdGHMlzphxF+AUI84JLE7rdJgE+beowwvy96BDa2Yul9ed1xjjA7Zaa7eGN+rWqZm5fBt4yhgzE/gG+AVOUePySMTe2jQzl08CVxtj/gI8hXMdgaNxzsLo8A5gv2MIUIXTS1Hali9wemy/YIy5DueAyT042xUN/6+fBmYZY36Hc3HQI4GLcK5z0F40Jx9LcIaUqf1NvglnHPsXIhB3SASGtdjFGLMDZ9tyuTHGA2TiXDi5kg5Qz2lmPtq9ZubjMaAEZ7iYZGNM7Rkixe2l6N7MfDyC8/sxG+fg9g04Z868GOawQ6oZOSkCiupMV1s/32Ct3ecIHu2xRzs4RdpvgE9xjjT8wVr7z8Brm3DG69sva+1q4HTgPJwjHJ2BUzS+bD1ByTXOhsJjgWXMxzlydJSKMfU0Nddn4ZwuOC/wfO3tMQBr7Zc4OyW34vSeKsQp2MhuQck1cBXOheFeZ/dYtccewNk17VWT8mytnY2T6yuAhcAxOFdA3xB4Xet0eAXr+yGOoHwPBAjeNok0fb18CafY+Qec9fJ4nPWyPfUmbamm5nItMAmnUPgDztjsZ1hr54U94tarOd/xzjjFR+23tTHW2irgBJzrFnyNcxDqQeDhwCR1vzdf41zs82zge+C3wLnW2k/DHHbINDMf83G2if+MM6RON5x96hI6hh44+RgLqufQIB+yOx/GmCScoUFycDp61t1XmRqxCMOr4ffldeA3OBeXngfkAse0l4MOTRSU74zL7/cHJxwRERERERERERERkQ6ovfZoFxEREREREREREREJCxXaRURERERERERERERaQIV2EREREREREREREZEWUKFdRERERERERERERKQFVGgXEREREREREREREWkBFdpFRERERERERERERFpAhXYRERERERERERERkRZQoV1EREREREREREREpAVUaBcRERERERERERERaQEV2kVEREREREREREREWkCFdhERERERERERERGRFlChXURERERERERERESkBVRoFxERERERERERERFpARXaRURERETaGGOMK9IxiIiIiIjIbiq0i7Qixhi/Meb6EL9HbuB9zjyAeUMen4iISHsVrHbUGHM78KsghCQiIiIiIkGiQruIiIiISNtyJxAX6SBERERERGQ3FdpFRERERERERERERFrAG+kARGTvjDGjgDuAsUA8sAr4q7X2ycDrFwL3A78A7gP6Ad8DFwADgHuAbsDnwMXW2q11Ft/bGPM5MDqw3D9aa/9R5737Aw8D44HNwK+bG5+IiIjsIcMY8x9gMk77+pC19sHaF40xXuB24EIgC1gE3Git/STwuj8w6X3GmCuttbmB8dqvBqbgbAtUAV8B11prF4bnY4mIiIiIdGzq0S7SShljcoDPgGLgLOAUYCnwhDFmaJ1Jk4DHgbuBs4EewP8BdwE344zhejTwxwZvcRcwN7Dcr4G/G2NOCrx3Mk5xvjNwbmDZLx5gfCIiIrLb9cBO4FTgLeBvxpgr67z+NHAd8FBgmiXA+8aYsYHXxwT+PgKcFrh/HfAX4BmcAv5VwCDghZB9ChERERERqUc92kVar8HAl8C51toqAGPMV8B24AigtodaNDDVWvt6YJrRwFTgCGvt9MBzk4DDGiz/NWvttYH7HxpjBgI3Au/g9KLLBEZZa9cHlrEDpyDQ3PhERERkt9nW2vMD9z80xvTAaX8fNcYMwGmDL7HWPhOY5gNjTFfgT8BEa+1XxhiAtdbaeYFpeuCcmfZQ4PEXxpg04K/GmERrbXEYPpeIiIiISIemQrtIK2WtfR+nB1usMWYQzqngowIvxzSYfE6d+1sCf7+t89w2ILXBPG81ePwO8PvAKevjgIW1RfaA/wK+A4xPREREHP9q8Pgd4KfGmFxgQuC59wLtca33gLuNMdHW2sqGC7TW/gbAGJOJM3TcAOCkwMsxOGefiYiIiIhICKnQLtJKGWM8wAPAZTi91lcA0wMvuxpMXtRwfmtt6X7eYkuDx3k4vwkJQBqQ32B5PmNM3gHGJyIiIo7G2l+AFKBT4P6GvcybAWxs+GSgJ/zTONdVKQUW4AxPA2qTRURERETCQmO0i7RetwCXAucDydba/jgXOguWtAaPOwMVOEX7bTgXYNslcKG1uvOEOj4REZH2qLH2F5yCeyHgxxmHfWQjt/wG82KMceP0io8ChgJJ1tqxwNuhCF5ERERERBqnQrtI6zUG+NZa+4a1tiTw3LGBv8HonVa7rNoi+unAdGttDc5FTocYY/rVmf4o6g8JE+r4RERE2qNjGzw+A1hmrd0IzMRpQ5Ottd/W3nAuan4NUB2Yp6bO/JlAX+Apa+2iQDte933UJouIiIiIhIGGjhFpvb4BphpjrsS5sOhI4Hacnm7xQVj+RcaYTThjuU/BubjprwOvvQRcD7xjjLkFiAP+DFSFMT4REZH26GhjzP3A+8BpwMnAzwCstfONMW8Brxhj7gAW44zbfitwb50iegEw3hgzA+c6LWuB3xpjtuIU4y8ATgxMqzZZRERERCQM1KNdpPW6B3gR+D3wLnAOcCXwEU5v8pa6GjglsOwBwPHW2lkA1tpyYCLODv4LwN04O/nbwxifiIhIe3QLzhAv/wdMBs611r5e5/VzgeeBm4APgJ8DU4Gb60xzB3AkTrHeg3NWWjHwemDeeJxe8KA2WUREREQkLFx+vz/SMYiIiIiIiIiIiIiItFnq0S4iIiIiIiIiIiIi0gIqtIuIiIiIiIiIiIiItIAK7SIiIiIiIiIiIiIiLaBCu4iIiIiIiIiIiIhIC3gPdMa8vKK9XkU1MTGG4uKKA1207INyGzrKbegot6Gj3IZOa8xtZmaSqyXz76vtDqbWmLvWSHlqOuWq6ZSrplOumk65aprG8tTStltERETajpD0aPd6PaFYrKDchpJyGzrKbegot6Gj3B445a5plKemU66aTrlqOuWq6ZSrplGeREREOjYNHSMiIiIiIiIiIiIi0gIqtIuIiIiIiIiIiIiItIAK7SIiIiIiIiIiIiIiLaBCu4iIiIiIiIiIiIhIC6jQLiIiIiIiIiIiIiLSAiq0i4iIiIiIiIiIiIi0gArtIiIiIiIiIiIiIiItoEK7iIiIiIiIiIiIiEgLqNAuIiIiIiIiIiIiItICKrSLiIiIiIiIiIiIiLSAN9IBiMiB89X4WZ5Xwg9bili6tZi84kp2lFbicbuIjfKQnRxL38wEhnZNwmQl4nK5Ih2yiIhIh1Nd42f2qu3MWbODjYXlFJZX0y0lll6d4jmyXwa56fGRDlFERERERFpIhXaRNmh5fglvL9zMRzaP/JJKAJJivHROiiE9PooaYGd5NT9uzuNf328CICsxmiP6ZnDW8Gx6ddIOvYiISKhV+2p4de4GXp27gbziSuKi3HRLiSM51svc9YW8v3gr02auZmROKpeN7cmwbimRDllERERERA6QCu0ibciCDYU8//U6Zq3aTpTHxdjcdCb2z+Cg7GS6pcTu0WPd7/ezpaiCb9cVMH3Fdv67cBNvzN/ImNw0rjy8F/2zEiP0SURERNq3pVuL+cOHS7FbixndM40bj+rLuF7peD27R27ML6nk7YWbeWvBRi59fQEXjurBJWN61ptGRERERETaBhXaRdqA/OIKHpq+ig8WbyUtLorLx/XkjGHZpMZF7XM+l8tFl+RYThzchRMHd2FHaSX//n4z//huPee9MpfTDurKr8f3IilWPwUiIiLB8tmyfG57bwkJ0R7+ctJAJvbPbHS6jIRoLh6dw09HZPPXz1bw3NfrmLu+kL+dNoTEGLXNIiIiIiJtibbgRVq5Dxdv5e6Pl1Hpq+Hi0TlcOKoHcVGeA1pWWryzQ3/m8K48NXsNb87fyIwV2/j9sYZRPdOCHLmIiEjH8+b8jdz36XIGdUnir6cOJi0+er/zJMZ4uT3QFt/5geWKf37Pw2cMadK8IiIiIiLSOui8VJFWqqzKxx3vL+HW95bQJyOB1y84lCvG5R5wkb2u5Ngorp/Yl2fPGUFclIdfv7mQx2asosbvD0LkIiIiHdO/vt/EXz5Zzthe6Uw766BmF8qPHZjF/acOZtX2Ui7/5/cUlVeHKFIREREREQk2FdpFWqGNheX88tX5vPfjVqaMzuHJs4fRIy0u6O8zuEsSr5x3MKcM7cILc9Zx49s/UlrpC/r7iIiItHfTV2zjLx8vY0xuGvedPOiAD4yP65XO304bzNodZdz07o9U+2qCHKmIiIiIiISCCu0ircyCDYWc/8pcNu+s4KEzhnDZuFy8btf+ZzxAsVEebpnUj2sm9Gb6im1c/s8FFJZVhez9RERE2pvFW4q4+d3FmKxE7jlpUIsvZjoyJ42bJvXj6zUF3Pvpcvw640xEREREpNVToV2kFZm1cju/fnMhKXFRvHDuCMbkpoflfV0uF+cc0p17Tx7M8vwSfvXG9xSUqtguIiKyP4VlVdz49o+kxkXx4OlDiI9u+RBvACcP6cIFo3rw7+838+4PW4KyTBERERERCR0V2kVaiY9sHtf99wd6pcfzzM+GkROCoWL254i+nbj/lMGs2VHGFW9obFgREZF9qfH7ueMDS15xJfecNJD0IF+89IpxuRzSI4V7P1nO6u2lQV22iIiIiIgElwrtIq3Ap8vyue3/FnNQ1yQe/2nzL54WTGN7pfPAqYNZvb2U6/77AxXVGhtWRESkMa9+t4GZK7dzzYTeDOmaHPTle9wu/nDcAGK8bm5+d7HaZBERERGRVkyFdpEIm7VyO7e8u5hBXZL52+lDSIzxRjokDuuZxp3HGeatL+S295ZQo7FhRURE6lm9rZRpM1dxRJ9OnDU8O2Tvk5UUw+3HGpbllfDcV2tC9j4iIiIiItIyKrSLRNCiTTu58Z0f6ZeZwMNnDCEhOvJF9lrHDMjimgm9+WxZPk/O1o69iIhILV+Nnz98uJTYKA9TJ/XD5QrdRcsBftKnEycMyuLFb9azPK8kpO8lIiIiIiIHRoV2kQhZX1DGtf/+gYyEaB5sJT3ZG/r5wd04eUhnnvtqLZ8uy490OCIiIq3Cq3M3sHDTTq6f2IeMhPAM9/bbI/qQFOPlT/9biq9GZ5qJiIiIiLQ2KrSLREBReTW/+dciavx+Hjp9SNAvnhYsLpeL3x3Vj8FdkrjzfcvqbboQm4iIdGybd5bz5KzVHN47nWMHZIXtfVPjo7juyD78sLmItxZsDNv7ioiIiIhI06jQLhJmvho/t763mI2F5dx3ymB6psdHOqR9ivG6uffkQUR73dz23hKqfLoQm4iIdFwPfLYCP3DDUX1DPmRMQ5MHZDIqJ5UnZq2hoLQqrO8tIiIiIiL7pkK7SJg9MWs1s1ft4IaJfRjRPSXS4TRJVlIMtx7TjyVbi3lilsZrFxGRjmnGim18vnwbU0bn0DU5Nuzv73K5uPbIPpRWVvPE7NVhf38REREREdk7FdpFwuiL5fm8MGcdpw7twunDsiMdTrMc0TeD0w7qwsvfrOO7dQWRDkdERCSsKqtreOCzFfRKj+fcQ7tHLI4+GQmcOTybf3+/iaVbiyMWh4iIiIiI1KdCu0iYbNpZzp0fLGVg50RumNg30uEckGsm9KF7aix//HApZVW+SIcjIiISNq/N3cCGwnKuO7IPUZ7IbkJfOrYnSTFeHvpiZUTjEBERERGR3VRoFwmDal8Nt7y7mBq/nz+fOJBob9v86sVFebhtsmFDYTnTZq6OdDgiIiJhsb20kue+Xsv43ukclpsW6XBIjo3i4tE5zFlbwDdrd0Q6HBERERERQYV2kbB4+ss1LNxUxC3H9Kd7alykw2mREd1T+OnwbF6fu4EFGwojHY6IiEjIPTlrDeXVNfzmJ70jHcouZwzLJisxmsdnrsbv90c6HBERERGRDk+FdpEQW7ChkBfmrOOkwZ2ZZDIjHU5Q/PrwXnRJjuGuj5ZR7auJdDgiIiIhs2pbKf9ZuIkzh3Ult1N8pMPZJcbr5pIxPVm4qYgZK7dHOhwRERERkQ5PhXaRECqt9PH79y1dkmO5bmKfSIcTNPHRHq47si+rtpXy2ryNkQ5HREQkZJ6YtZpYr4dfjs6JdCh7OHFwZ3LS4nh85mpq1KtdRERERCSiVGgXCaGHp69kY2E5dx5rSIj2RjqcoPpJn3TG9Urn6dlryCuuiHQ4IiIiQffj5iI+XZbPOYd0Iy0+OtLh7MHrcXPZ2J4szy/hoyV5kQ5HRERERKRDU6FdJES+37iTfy3YxM8O7sbw7imRDifoXC4X1x3Zh6qaGh76YmWkwxEREQm6x2etJiXWy7mHdo90KHt1tMmkX2YCT85ereHcREREREQiSIV2kRCo9tVw90fLyEqK4fJxuZEOJ2R6pMVx3qHd+XBJHos27Yx0OCIiIkHz3boCvlq9gwtG9SAxpvWeleZ2ubhiXC7rCsp5+4ctkQ5HRERERKTDUqFdJAT+/t0GlueXcMPEvsRHeyIdTkidP6oH6fFRPPTFSvwaH1ZERNoBv9/PtJmryUyM5qzh2ZEOZ7/G905naNdknv1yDRVVvkiHIyIiIiLSIanQLhJk6wvKePrLNUzo24kj+naKdDghlxDt5bJxuczfsJPPlm+LdDgiIiItNmvVdr7fuJMpo3OIjWr9B8xdLheXj+vJ1uJK3py3IdLhiIiIiIh0SCq0iwSR3+/nL58sx+t2cf3EvpEOJ2xOHtKFXp3ieXT6So0PKyIibVpNoDd799RYTh7SJdLhNNnInFSGdk3mKbXFIiIiIiIRoUK7SBB9ZPP4avUOrhiXS+ekmEiHEzZet4urf9KLdQXlvKvxYUVEpA372OaxLK+Ey8bm4vW0nU1ll8vFL0fnsLGwnPd+3BrpcEREREREOpy2s/cg0sqVVFbz189XMrBzIme2gfFcg21cr3SGdE3i2a/WUlmtnnQiItL21Pj9PPPVWnp3iueYAZmRDqfZxvZKY3B2Mi/MWUt1ja6bIiIiIiISTt5IByDSXrzw9Tq2lVTywKmD8bhdkQ5nr5Ys+ZGHHrqfpUstmZlZXHDBLznuuBP3On1JSTHTpj3MzJnTqaysZMyYcVx11TWkpaXvmubTTz/mhReeZt2G9VREp3K372x+f8X54fg4IiIiQfPJ0nxWbSvlrhMG4Ha1jrb83Xf/y6uvvsymTRvJzu7Gz39+HieccHKj07pcLn4xLI3b7vwjx78xlZgoLxMnHs3ll19FXFwcAOPHH7rXeWfM+CZkn0NEREREpL1Tj3aRINhQWMY/vlvPCYOyGNwlKdLh7NWOHTu49tqr6N9/AM8993fOPPNs7rnnj8yZ89Ve57nttql89dVsbr759zz22NOUlZVy1VWXU1lZCcCCBfO4885bOP30n/LKS6/R9eBj+Ogfj/LFjOnh+lgiIiItVuP388yXa+iVHs9R/VtHb/bPP/+EBx64h3PPvYBXXnmDs88+l3vvvYuZM79odPrq6mpeuXcqsWV5xE24lHvve4ilS5cwdep1u6b5738/qHd77rlXiI9P4LzzLgrXxxIRERERaZdUaBcJgkenr8LtcvGr8b0iHco+vfvuf0hISOQ3v7menj1zOfPMnzF58vG8+urLjU6/bJllzpyvmDr1Ng47bAy9e/fhttv+SH5+Hp988j8AZsz4gj59+nHqqWfQrVsPbrrsAmpSu/H6+5+E86OJiIi0yOfL8lm5rZSLR+e0mjPTCgoKuPjiyzj++JPIzu7GSSedSu/effj228Z7ns+ePZPly5dx6XV3sDEqm43uDO68827mzv2GefO+A6BTp4x6tyefnEbv3n2YMuXycH40EREREZF2R0PHiByA8eMP5cYbb+W9995m8ZLFVMamc+IFv2XWx+/w8svPU1xczJgx47jlljuIjo4GnJ7fjz/+CEuXWjp1yuCooyZx0UWXEBPjXDR12bKlPPnkoyxa9D3l5eV07ZrN+edfvGtYlyuvvJQhQw4iL28LM2ZMx+PxMGnSZK6++jq8Xi/PPvskzz//dKPxHnfcidxyyx0sWDCP4cNH4HbvPsY2YsQhPPDAPfj9flwNTpNft24dAAcdNHzXc/Hx8fTo0YN5877juONOJDU1ldWrVzJ37reMGHEI3u0r8RRtYUlVGuVVPmKjPMFLvIiIyAGo225bu4Ts7G5MnXo7y5bZXe02XQeRM/48JhmnN3traLdPPfWMXc9VV1czffrnrFmzmilTrmh0vvXr15KRkcFPDx/Omyu+5dmv1vL38w4mJSWV+fPnMmLEIfWmnzVrBt9++zXPPPNyvW0DERERERFpPhXaRQ7Qk08+xtSpt/L0onJWvf80M168m/yBg7n//odYu3YNd955K8OHH8xpp53JsmWWa6+9kl/+8nJuvfVOtmzZzIMP3sf27du4+ebfU1ZWxrXXXsm4cYfz1FMv4PfDa6+9wr333sVhh40hPb0TAK+//ncuuOCXPP/831m4cAF//vOdDB48lMmTj+fnPz+v3g55XTExsQDk5W2lXz9T77WMjAzKy8spLCwkNTV1j9dq5+vevQcAPp+PrVu37hqj/fTTf8qiRd9z9dWX4/F48Pl8HHXiT3kv6mDeXLCJXxzaPXhJFxEROUBOu30bOTk5/OlPd3DDDb9hYKDdfu/rRbz6+N0cfthIPO6xrabdrrVkyY9cdtlF+Hw+TjzxFMaOHd/ofBkZmRQWFlJZUc5Fh/Xgzg+W8vEP6ykq2smOHdv3mP6ZZx5n0qRj6devf4tyKyIiIiIiGjpG5ICddNKpuLsN5ceSOA6fOJmiop1cf/1Uevfuy4QJR9G3b39WrlwBwKuvvsKYMeM555zz6N69B4ccMpIbbriZ9957h/z8fMrLyzj77HP47W9vICcnl549cznvvIuoqqpi3bq1u96zb9/+XHjhFLp1686xx55Anz59WbRoIeD0NG94OnjtLTExEYDy8vJdPfFqRUU5Pe4rKyv2+IwDBw6mZ89c7rvvbvLz86moKOfJJx+loGAHVVVVAOzYsZ1t27bxq19dzTPPvMRvf3s9Mz/6L32LF/LinHWUVvqCn3wREZFmOumkUxk//ifk5OQyefLxu9rtXr368GVVD6LSexBXuhVoPe12ra5ds3nmmZe46abb+fTTj3nqqWmNfsbRo8eSmJjIvffexbhucXSJreGvD9wNQFVVdb1p5837juXLl/GLX1wYrBSLiIiIiHRo6tEucoC6devOtJmryU6JZXSXzsxwu+naNXvX6zExMVRVORcMXbrUsn79WiZNOnzX636/H4A1a1ZxyCEjOe20M/ngg3cD065j2bKlgNODvFZOTk69GBISEqmudgreL730HC+//HyjsR5zzHHccMPNxMTE7LqIaa3aGGNj4/aYLyoqij//+X7+8IfbOPXUY4mKimLSpGMZM2YcXm8UAPfeexf9+xvOOed8APr1MxQUFPDGW/+k4KghvDl/I1cfY/ZYtoiISDjVnpkFEBcXhzvQbk9fsZ2leSX0Td/dpraWdrtWSkoqKSmp9Otn2LFjO88//zRTpjhnktWVnJzCI488xtSpUzn5pKPxREVT3nMcvXr22aN4/+GH7zFs2Ahyc1v39WVERERERNoKFdpFDpDNL8duK+bO4wys3oLL5dpjjPNaUVFejjvuRM4994I9XuvUKYP8/Dwuu+wiMjOzGDfucMaOPZyMjEymTDmvwXKi95i/dsf/1FPPYOLESY2+f0JCAgBZWZ3Zti2/3mv5+fnExcXvsQNeq2fPXJ599mUKCwuIiooiPj6Biy8+l5EjRwPwww8LOfroyfXmGTRoCCUvPMPBnaP5x9wNXHZk30aXLSIiEi5eb/3N3to2+9mv1tA9NZb0+N1tbGtpt+fN+47ExMR6w7716dOXiooKdu7cSVpa2h7zDh8+nNde+xc7dmzHEx3LWS8tYONbU+nWrVu9GGbNmsHFF1/a6PuLiIiIiEjzaegYkQP0xfJ8ctPjmDwga7/T9urVh9WrV9G9e49dt4KCHTz22IOUlpbw0UcfUlpaymOPPc15513E+PE/obCwoFnxJCen1Ft+3VvteOoHHTScBQvm7drJB5g791uGDh3W6EXQSkqKufLKS1m5cjkQAUseAAAgAElEQVQpKanExyewadNGli9fxqhRTqE9MzOLFf/P3n3GSVne+x//Ttve62yls7RderMRUbEi1Y4FW0wxOemeRNNMcjzH/BNNjCcxRqUpUhQUS+xdYYFdytLZBbb33mdn/g+IHI2glN29pnzer1ceZJk1Hybgvfdvrvu6Du7/3PcdfX20bp8xQrWtXXouv/SUfi8AAPSHTUcatLuyRTdNztBnPyr3luv2ihVL9Pe//+/nvm/XrgLFxsZ94VwVSSouPqIbb1ykpqZGxcbGKSo8TDNjG+XqaFNU5uhjrzty5LDq6+s0ceKkU2oGAAAAcGIM2oHTVNncqVunZcpmPf4q9s+64YabtWvXTv35z3/Q4cOHlJe3Rb/5zS/U3Nys+PgEJSUlq62tVe+885YqKsr1wQfv6sEHfydJX9jq5UxcccUcNTTU68EHf6dDh4q0Zs1Kvf76q7rhhpuOvaapqVFNTY2Sjj7i3tPTo4cf/oOKigq1a9dO/fjH/6GJEydr4sTJkqSrrrpO69c/p3Xr1qisrFSvvfaqli17UosWLdakjBiNckbq7+8XyeX2HLcJAABTlmwqVkJ4kC4flfy5r3vLdfvqq6/Xxx9/qKefXqaSkmJt2LBOTz+9VLfdduexFfn19fVqaWmRdHQv96qqSv3xjw+qpKRYW7du1scrH5ZtyHS9dMR97J+7b98eBQUFKSNjQK+1AgAAAIGOrWOAU/TpavD48CDNyvrq1ezS0ce8H3zwYf397/+r559fo/DwCJ199rn65je/K0maOfNC7d5doIceelDt7W1KS8vQLbfcruXLn9KePbs0bdpZvdIeFxev3//+z3r44Qd16603KDnZqXvv/dWxobkk/fSnP5IkPfLIY5KkX/3qd/rjH/9Hd921WMHBIZoxY6a+8Y27j71+/vyr5HA4tGrV03rkkYfkdKbqzju/pfnzr5LFYtEtUzL04xd26a191Zp1Eqv/AQDoDx6PR7lHGvSd8wYpyP75tSfect2eMmWafvOb/9YTT/xdjz/+VyUlJet73/uRrrhi7rHX3HHHTRo/fqJ+9rNfym636y9/eVS//vX9Wrz4ekVGRumyy2bLM/ISPb6pRAeqWzU0MVy1tTWKiIg84ZZ3AAAAAE6d5bNbSJyK6urmE35jTEyYGhraTjsKJ8Z723dO9r1990CNfrh+l355SZYuH538la8PdG6PR9ct3SqbRVpx4wRu6nsZ/07oO9743iYmRp7RX6Avu3b3Jm9877wR79PJ64v36p4Xd2nj4Xq9eMdURQT7z9qT471Xje3duvLvm3TukDj95vKRhsq8D38HTx7v1ck53vt0ptduAADgO9g6BjgFHo9Hj398ROkxIbp4JKuzT4bVYtGd5w7S/upWfXSo3nQOAAA6XNemt/bV6KpxqX41ZD+R6FCHFoxN0et7q1Vc3246BwAAAPBLDNqBU/BBYZ32VLVo8dRM2U9ib3YcNTsnVUkRQVqyqdh0CgAAWra5REF2q64Zn2Y6pd9cPylddqtFS3K5FgMAAAB9gUE7cJI8Ho8e/+SIUqNDdBmr2U9JkN2qRZMzlFfSqG2ljaZzAAABrLqlUy/vqtTs0cmKDw8yndNvEsKDdOUYp14qqFRFU4fpHAAAAMDvMGgHTtJHh+q1q6JZi6dkyG7jr86pmpvtVHSInVXtAACjntlSqh63RzdMSjed0u9unJwhj8ejFVtKTacAAAAAfodpIXCSnvzkiJyRwRyAeppCHTZdPT5V7xfW6XAdh2kBAPpfU0e31m4r10VZiUqPCTWd0+9So0N0yahkPb+9XPVtXaZzAAAAAL/CoB04CdvLmrStrEk3TEqXg9Xsp23B2FQF2Sx6Zisr6QAA/W/ttnK1dffopskZplOMuWVyhrpcbq7FAAAAQC9jYgichOWbSxQVYteVY5ymU3xafHiQLh2ZrA0FlWpo7zadAwAIIB3dPXpmS6nOGhSr4UkRpnOMGRgfppnDE7Qqr0wtnS7TOQAAAIDfYNAOfIUj9e16Z3+NFoxNUViQzXSOz7t2Ypo6XW49v73cdAoAIIBsKKhUfXu3bp4SuKvZP7V4SqZau3q0Or/MdAoAAADgNxi0A1/h6S0lstssunp8mukUvzA0IVzTBsRqVV6ZunvcpnMAAAHA5fZo2eYSZadEaXxatOkc47KSI3TWoFg9vaVUHd09pnMAAAAAv8CgHfgS9W1d2lBQqctGJishPMh0jt+4flKaalq79PreatMpAIAA8Na+apU1dujmKemyWCymc7zC4imZamjv1vM7KkynAAAAAH6BQTvwJVbnl6nT5dYNk9JNp/iVaQNiNSg+TCs2l8jj8ZjOAQD4MY/Ho+WbSzQgNlTnDok3neM1xqVHa3x6tJbnFvOEGQAAANALGLQDJ9DR3aPV+eU6Z3CcBsWHmc7xKxaLRTdMTNO+6lZtKW40nQMA8GN5pY3aXdmi6yemycpq9s9ZPDVDVS1deqmg0nQKAAAA4PMYtAMnsKGgUg3t3bpxMqvZ+8IlI5MVG+rQii0lplMAAH5sxeZSxYQ6dNmoZNMpXmfagFiNTI7Qktxiudw8YQYAAACcCQbtwHH0uD16ekuJRjkjOTStjwTbrbpqXKo+KKzTobo20zkAAD90uK5N7x+s1cKxKQpx2EzneB2LxaJbpmaqpKFDb3JuCgAAAHBGGLQDx/FhUZ2KGzp0w8Q0Dk3rQ/PHpshhs2hNfpnpFACAH3pma6kcNosWjks1neK1vjY0XoPiwvTkpiNyc24KAAAAcNoYtAPH8ezWUiVFBGnmsATTKX4tPjxIFw5P1IaCSrV2uUznAAD8SEN7tzYUVOrSkcmKDw8yneO1rBaLbpmaoYM1bXr/YJ3pHAAAAMBnMWgH/k1hbas2HWnQgrGpstv4K9LXrhmfqtauHg5iAwD0qrXbytTpcuu6iWmmU7zerKxEpUYF68mNR+RhVTsAAABwWpgiAv9mVV6ZgmwWzctxmk4JCKNTojTaGaln88p4ZB0A0Cu6XG6tyivT9IGxGpIQbjrH69ltVt00JUMFFc3KPdJgOgcAAADwSQzagc9o7nDp5V2VmjUiSbFhPGbeX64en6oj9e3aeLjedAoAwA+8uqdKdW3dumFSuukUn3HFaKcSwoP05KZi0ykAAACAT2LQDnzGiwUVau9265rxHJrWny4cnqi4MIdW5XEoKgDgzHg8Hj2zpVTDEsM1JTPGdI7PCLZbdcOkdG0+0qAdZU2mcwAAAACfw6Ad+Jcet0er8so0NjVKI5IjTecElCC7VfNzUvRhYZ1KGtpN5wAAfNjWkkYdqGnVtRPSZLFYTOf4lPk5KYoOsevxTw6bTgEAAAB8DoN24F/e3V+t0sYOXc1qdiPmj02R1WrR6nxWtQMATt/KraWKDrFrVlai6RSfExZk0w2T0vVRUT2r2gEAAIBTxKAd+JdlnxxWYkSQZg5LMJ0SkBIjgnXBsASt31Ghtq4e0zkAAB9U1tih9w7Wal5OikIcNtM5Punq8amKDrHrsY9Z1Q4AAACcCgbtgKRDtW364ECtFoxNkd3GXwtTrh6fqtauHr28q9J0CgDAB63JL5NF0oKxKaZTfFZ4kF03Ts7QJ4fqtZ1V7QAAAMBJY6IISFqVXyaHzaJ5OdyYm5STGqURSRFalV8mj8djOgcA4EPau3u0bkeFzh+WIGdUiOkcn3bVuFTFhDr02EeHTKcAAAAAPoNBOwJeS6dLGwoqdEV2iuLCgkznBDSLxaKrx6eqqLZNuUcaTOcAAHzIK7ur1Nzp0jXj00yn+LywIJtumpyujYcbtK200XQOAAAA4BMYtCPgvVhQqfZut26aNsB0CiTNGpGkmFCHVuVxKCoA4OR4PB49u7VUWUkRGpsWZTrHLywcl6q4MIf+9hF7tQMAAAAng0E7Aprb49HqvFLlpEZpTFq06RxICrZbNS/HqfcLa1Xa2G46BwDgAzYXN6iwtk3XjE+VxWIxneMXQh023Tg5Q7lHGpRXwqp2AAAA4KswaEdA+7ioXsUNHbpmfKrpFHzGgrGpskhak19uOgUA4AOe3VqmmFCHZo1IMp3iVxaOTVFcGHu1AwAAACeDQTsC2sq8UiVGBGnmsATTKfiM5MhgfW1Ygl7cWaGO7h7TOQAAL1ba2K73DtZqXo5TwXZ+tO1NIQ6bbp6Soc3FjdpSzNkpAAAAwJfhbgQB61Bdmz45VK/5OSmy2/ir4G0WjE1RY4dLb+yrNp0CAPBiz22rkNVy9Gko9L75OSmKDw/SY+zVDgAAAHwpposIWKvzyuSwWTQvJ8V0Co5jUkaMBsSGau02to8BABxfl8utF3ZW6Nwh8UqODDad45dCHDbdMiVDW0satfkIq9oBAACAE2HQjoDU0unShoJKXZSVqPjwINM5OA6LxaIF41K1s7xZeytbTOcAALzQm/ur1dDerYWsZu9T83JSlBgRpMc+OiSPx2M6BwAAAPBKDNoRkDYUVKqtu0dXj08znYIvccWoZAXbrVqzrcx0CgDAC63JL1dmbKgmD4gxneLXgu1W3TIlQ3mlTcplVTsAAABwXAzaEXDcHo9W55cpOyVKo52RpnPwJSJD7Lp4RKJe3V2llk6X6RwAgBfZV9Wi7WVNWjA2RVaLxXSO35uTnaKkiKN7tbOqHQAAAPgiBu0IOB8fqteR+nZdM57HzH3BgrGp6nC59VJBpekUAIAXWbutXMF2qy4flWw6JSAE2626ZWqmtpU1adNhVrUDAAAA/45BOwLOqrxSJYQHaebwBNMpOAmjnJEa5YzU2m3lrKADAEg6etbKK7srNSsrUdGhDtM5AWPOGKeSI4P1N1a1AwAAAF/AoB0B5XBdmz4qqtf8sSly2Pjj7ysWjE1RUV2btpY0mk4BAHiBl3dVqb3brYXjeDqtPwXZrVo8NUM7ypv08aF60zkAAACAV2HSiICyOr9MdqtF83NSTKfgFMzKSlRksF1rt5WbTgEAGObxeLRmW5lGJkdoFGet9LsrxzjljAxmr3YAAADg3zBoR8Bo6XRpQ0GlLspKVHx4kOkcnIIQh01XjE7WW/trVNPaZToHAGDQ1pJGFdW2sZrdEIfNqtumZaqgolkfFtWZzgEAAAC8BoN2BIwNBZVq7erRtRPSTKfgNMwfm6Iet0cv7KgwnQIAMGjttnJFhdg1KyvRdErAumJ0stKiQ/S3D1nVDgAAAHyKQTsCQo/bo2fzSpWTGsVj5j5qYFyYJmfG6Pnt5epxc1MPAIGoprVLb+2v0RWjkxXisJnOCVh2m1W3T8/UnqoWvXug1nQOAAAA4BUYtCMgfFhUp5KGDlaz+7iFY1NU0dzJo+oAEKDW7zj6YeuCsWwbY9olI5OVGRuqxz4+LDer2gEAAAAG7QgMK7eWKikiSOcPjTedgjNw3pB4JYQHae22MtMpAIB+5nJ79Pz2Ck0dEKPM2FDTOQHPbrXo9umZ2l/dqrf315jOAQAAAIxj0A6/d6C6VblHGnT1+DTZbfyR92V2m1Xzcpz6uKheJQ3tpnMAAP3ow8JaVTZ3aiGr2b3GrKwkDYoL098+Osy2bgAAAAh4TB3h91bmlSrYbtXcbKfpFPSCudkpslik9RyKCgABZU1+uZIignTOEJ5O8xY2q0V3nDVARbVtemNvtekcAAAAwCgG7fBrDW3denV3lS4blaToUIfpHPSCpMhgnT0oTi/srJCrx206BwDQDw7XtuqTw/Wal5Miu9ViOgefccHwBA1JCNNjHx+Wi1XtAAAACGAM2uHXnt9Rrk6XW9eM5xBUfzI3J0V1bd16v5BDUQEgEDyTWyyb1cLTaV7IarHozrMG6kh9u17bU2U6BwAAADCGQTv8lqvHrTX5ZZqSGaMhCeGmc9CLzhoUp8SIIK3bUW46BQDQxzq6e7Rma6nOHxqvhIhg0zk4jvOHxisrKUJ///gwT5sBAAAgYDFoh996a3+Nqlq6dN1EVrP7G7vVotljjh6KWtHUYToHANCH3thXrcb2bi0cxyGo3spisejOswaopKFDL+9iVTsAAAACE4N2+K2VW0uVGRuqswbFmU5BH5gz5uj2AS/s5FBUAPBna/LLNSQxXBPSo02n4EucOzhOo5yR+scnrGoHAABAYGLQDr+0s7xJO8qbdfW4VFktHJrmj1KjQzR1YKzW76hQD4evAYBf2lXRrIKKZl0/JVMWrudezWKx6I7pmSpr6tTLu1nVDgAAgMDDoB1+aeXWUoUH2XTFmGTTKehD87Kdqmrp0seHOBQVAPzRmvwyhTqsmse2MT7h7EFxGpEUoac2HpGLD8EBAAAQYBi0w+9UNXfqjX01mpPtVHiQ3XQO+tC5Q+IVF+bQuu1sHwMA/qaxvVuv7a3WpSOTFRniMJ2Dk2CxWHTbtEwVN3TotT2sagcAAEBgYdAOv7NmW5ncbo+uYvWb33PYrLpidLI+KKxVdUun6RwAQC/aUFCpTpdbC8elmE7BKThvaLyGJoTryY1H2NoNAAAAAYVBO/xKW1eP1m4r14yh8UqPCTWdg34wJztFPR7pxZ2VplMAAL3E7fFozbYyjUuL0rDECNM5OAXWf61qP1TXrjf3VZvOAQAAAPoNg3b4lfU7K9TU4dJNkzNMp6CfZMaGamJGtNbvrJDbw8o5APAHGw/Xq6ShQwvH8nSaL5o5PEGD4sL0xMYjXJsBAAAQMBi0w2+4etx6enOJxqVFKTs1ynQO+tG87BSVNXYo93CD6RQAQC9YnVemuDCHZg5PMJ2C02C1WLR4WoYO1rTpnQO1pnMAAACAfsGgHX7jjX01qmju1I2sZg84XxuWoOgQu9btKDedAgA4Q2WNHfqgsE5zs51y2PhR1VddlJWkzNhQ/ePjw/Kwqh0AAAABgLsX+AWPx6OlucUaGBeqcwbHmc5BPwu2W3XZqGS9c6BWdW1dpnMAAGfg+e3lslikeTkcgurL7FaLbpmSoX3VrfqgsM50DgAAANDnGLTDL2w63KD91a1aNCldVovFdA4MmJvjlMvt0UsFHIoKAL6qy+XW+h0VOm9IvJxRIaZzcIYuHZkkZ2SwluYWm04BAAAA+hyDdviFZZuLFR8epEtHJptOgSGD48OVkxqldTsqeEQdAHzUm/urVd/ezSGofsJus+qGSenKL23SttJG0zkAAABAn2LQDp+3t7JFGw836NrxqQqy80c6kM3NdupIfbvyuJkHAJ+0Jr9cmbGhmjwgxnQKesmcbKeiQ+xasolV7QAAAPBvTCXh85ZtLlaYw6YFrH4LeBdmJSo8yKb1OypMpwAATtHeqhZtL2vSgrEpbAPnR0IdNl0zPk3vF9bpQE2r6RwAAACgzzBoh08raWjXG3urNTfHqcgQu+kcGBbqsOmSkUl6c1+NmjtcpnMAAKdgTX6Zgu1WXTGabeD8zVXjUxVit2oZe7UDAADAjzFoh09bmlssq9WiRZPSTafAS8zJdqrT5dare6pMpwAATlJzh0uv7q7SJSOSFBXiMJ2DXhYT6tDcnBT9c0+1yps6TOcAAAAAfYJBO3xWVXOnNhRUavZopxIjgk3nwEuMSIrQ8MRwrdtezqGoAOAjXiyoUIfLrYXjUkynoI/cMDFNkrRic4nhEgAAAKBvMGiHz1q+uURut0c3TWE1O/6PxWLRnOwU7atu1Z6qFtM5AICv0OP2aFVemXJSozQiOdJ0DvqIMypEl4xM0vodFWpo6zadAwAAAPQ6Bu3wSfVtXXpue7kuGZmktOhQ0znwMpeOTFKw3cqhqADgAz4orFNpY4eunZBmOgV97KbJ6epwubUqv9R0CgAAANDrGLTDJz2ztVRdLrdumZJpOgVeKDLErguGJ+jV3VVq7+4xnQMA+BIr80qVHBms84clmE5BHxscH65zBsdpTX65Ol1u0zkAAABAr2LQDp/T3OHSqrwyzRyeoIHxYaZz4KXmZDvV2tWjN/dVm04BAJzA/uoWbT7SoKvGpcputZjOQT+4fmKa6tu79eruStMpAAAAQK9i0A6fszq/TK1dPVo8ldXsOLHxadHKjA3Vuu1sHwMA3urZrWUKtls1N9tpOgX9ZFJGjIYlhuvpLaUcWg4AAAC/wqAdPqW9u0dPbynROYPjlJUUYToHXsxisWhutlPbyppUVNtmOgcA8G/q27r0yu5KXTYqSdGhDtM56CcWi0XXT0xTYW2bNh6uN50DAAAA9BoG7fApa/LL1NjhYjU7Tsplo5Jls1o4FBUAvNDz2yvU1ePhENQANCsrSXFhDj29hUNRAQAA4D8YtMNntHX1aFluiaYNiFVOapTpHPiA+PAgnTckXi/tqlR3D4euAYC3cPW4tWZbmaYOiNHg+HDTOehnQXarrh6fqo8P1fPUGQAAAPwGg3b4jNX5Zapv79adZw0wnQIfMifbqYb2br13sNZ0CgDgX97cV6Pqli5WswewBTmpCrZb9czWEtMpAAAAQK9g0A6f0Nrl0rLcYp01KFbZrGbHKZg2IFbJkcEcigoAXsLj8eiZraXKjA3VWYPiTOfAkJgwhy4dmaSXd1Wpoa3bdA4AAABwxhi0wyesyju6N/udZw00nQIfY7NadOWYZG08XK+yxg7TOQAQ8LYUN6qgolnXTUiT1WIxnQODrpuYpk6XW2u3l5lOAQAAAM4Yg3Z4vZZOl5ZvLtE5g+M02hlpOgc+aPYYpyTpxZ2sagcA05ZsKlZcmOPYv5sRuAbHh2v6wFitzi/nLBUAAAD4PAbt8Hort5aqqcOlr7M3O05TSlSIpg6M1Qs7K9Tj9pjOAYCAtaeyWZ8crtd1E9IUbOfHUEjXTkhTbWuX3tpXYzoFAAAAOCPc4cCrNXe4tGJLiWYMideIZFaz4/TNy3aqqqVLnxyuN50CAAFryaZihQfZtHBcqukUeIlpA2OVEROi1flsHwMAAADfxqAdXu2ZrSVq6ezRHaxmxxk6d0i8YkMdWre93HQKAASkI/XtenNfjRaOS1VEsN10DryE1WLRwnGp2lbWpL2VLaZzAAAAgNPGoB1eq7G9W09vKdXMYQnKSoownQMf57BZdfnoZL1fWKea1i7TOQAQcJblFsths+jaCWmmU+BlZo92KsRuZVU7AAAAfBqDdnitp7eUqLWrR3dMZzU7esecMU71uD16uaDSdAoABJTqlk69tKtSs8c4lRAeZDoHXiYyxK5LRyXp1T1VamzvNp0DAAAAnBYG7fBKDe3dWrm1TBcOT9TQxHDTOfATA+PDNC4tSut3Vsjj4VBUAOgvT28pVY/bo0WT0k2nwEtdNS5VnS63XuTDcAAAAPgoBu3wSss3l6i9u0d3nJVpOgV+Zm52io7UtyuvtNF0CgAEhKaObj23rVwXZSUqPSbUdA681LDECI1Pi9Ka/DK5+TAcAAAAPohBO7xOfVuXVuWVataIRA2OZzU7etcFwxMUHmTTuu0VplMAICCszi9TW3ePbp6SYToFXm7huFSVNnbo46J60ykAAADAKWPQDq+zLLdEnS63bp/G3uzofSEOmy4ZmaS39teoqYN9YAGgL3V092jl1jKdPShOwxI52Bxf7vxhCUoID9Kq/FLTKQAAAMApY9AOr1Lb2qVV+WW6eESSBsaHmc6Bn5qb7VSny61Xd1ebTgEAv/bCzgo1tHezmh0nxWGzan5Oij4uqldxfbvpHAAAAOCUMGiHV1maWyxXj1u3T2c1O/rOiORIjUiK0Lod5RyKCgB9xNXj1rLcEo1NjdL49GjTOfAR83Kcslotem57uekUAAAA4JQwaIfXqGnp1Npt5bpkVLIyYzksDX1rTrZT+6tbtbuyxXQKAPil1/ZWq6K5k9XsOCUJEcE6b0i8NhRUqsvlNp0DAAAAnDQG7fAaS3JLjq5mn5ZpOgUB4OIRSQq2W7V+B4eiAkBvc3s8WrKpWEMSwnT24DjTOfAx83Ocamjv1jsHakynAAAAACeNQTu8QlVzp57bVqbLRycrPYbV7Oh7kSF2XTg8Qf/cU6X27h7TOQDgV94/WKfC2jbdPCVDVovFdA58zJQBsUqNDmH7GAAAAPgUBu3wCks2FavHI93Kanb0o7nZKWrt6tEbezkUFQB6i8fj0ZJNR5QaFayLspJM58AHWS0Wzc12aktxow7VtZnOAQAAAE4Kg3YYV9HUoed3lOvKMclKi2Y1O/rP2LQoDYgNZfsYAOhFeaWN2lHerBsmZchuZTU7Ts/sMU7ZrBat2841GgAAAL6BQTuMe2pTsTwe6daprGZH/7JYLJqT7dS2siYV1raazgEAv/DUxmLFhjp05Zhk0ynwYQnhQfra0HhtKKhQJ4eiAgAAwAcwaIdR5U0dWr+jQnOynXJGhZjOQQC6fHSy7FYLq9oBoBfsrWrRx4fqdd3ENIU4bKZz4OPm5aSoscOlt/dzKCoAAAC8H4N2GPXEJ0dksUiLWc0OQ+LCgjRjaLxe3lWlLlbMAcAZWbqpWOFBNi0cm2o6BX5gcmaM0mM4FBUAAAC+gUE7jCltbNeLBZWal52i5Mhg0zkIYHOynWpo79Z7B2tNpwCAzyqub9cb+6q1YGyKIkPspnPgB44eipqivJJGFdVyKCoAAAC8G4N2GPPkJ8WyWaSbp2SYTkGAm5IZK2dkMNvHAMAZWL65RHarRddNSDOdAj8ye8zRLd7W7WBVOwAAALwbg3YYUdLQrg27KjUvJ0VJrGaHYTarRVeOcWrj4XqVNrabzgEAn1PT0qkXCyp0xWinEiK4rqP3xIUF6WtDE/RSQSWHogIAAMCrMWiHEU9tZDU7vMuV2U5ZLdLafFbMAcCpemZrqXrcHi2alG46BX5o/linGjtcenNftekUAAAA4IQYtKPffXY1eyKr3uAlkiODdf6wBK3fWaGO7h7TOQDgM5o7XFq7rVwXDE9URmyo6Rz4oUkZMcqICdHzHIoKAAAAL8agHf2O1ezwVlePT1NTh0uv7K4ynQIAPmPNtjK1dvVwXUefsVgsmpeTovzSJh2saTWdA1cyLioAACAASURBVAAAABwXg3b0K1azw5uNS4vSsMRwrcork8fjMZ0DAF6vo7tHK7eWavrAWGUlRZjOgR+7YnSyHDaL1nFwOQAAALwUg3b0q09Xs980mVVv8D4Wi0XXjk/TgZpWbS1pNJ0DAF7vxYJK1bV1s5odfS42LEjn/+tQVLZ4AwAAgDdi0I5+U9r4f6vZkyJZzQ7vNGtEoqJD7Ho2r8x0CgB4NZfbo+W5xcpOidKE9GjTOQgA88emqLnTpTf31ZhOAQAAAL6AQTv6zZOsZocPCHHYNCc7Re8eqFFFU4fpHADwWm/srVZZU6dunpIhi8ViOgcBYEJ6tDJjQzkUFQAAAF6JQTv6RWljuzYUsJodvmHhuBRJ0up8buQB4Hg8Ho+WbCrWoPgwnTskznQOAsSnh6JuK+NQVAAAAHgfBu3oF6xmhy9JiQrRjKEJWr+jnH1gAeA4Piyq04GaVt0yJUNWVrOjH10x6uihqKxqBwAAgLdh0I4+x2p2+KJrxqeqscOlf+6pMp0CAF5nyaZiOSODNSsr0XQKAkxMmEMzhyXo5V1VfBgOAAAAr8KgHX2O1ezwRRPSozUsMVxPbymVx+MxnQMAXiO/pFH5pU1aNClddhs/SqL/zcvhUFQAAAB4H+6O0KfKmzq0oaBSc7NZzQ7fYrFYtGhSugpr2/RRUb3pHADwGktyixUT6tCcbKfpFASoTw9FfY7tYwAAAOBFGLSjTy3dVCyLpJumsJodvmdWVqKSI4O1NLfYdAoAeIX91S36oLBO105IVYjDZjoHAerTQ1G3lzXpAIeiAgAAwEswaEefqWnp1As7K3T56GQls5odPshus+q6CWnaWtKogvIm0zkAYNyy3BKFOqxaODbVdAoC3KeHoq5jVTsAAAC8BIN29Jmnt5TK5fboZvZmhw+bm+NURLBNyzaXmE4BAKMqmjr02t5qzctJUXSow3QOAtynh6K+tKuSQ1EBAADgFRi0o080tndr7bZyXZSVqIzYUNM5wGkLD7JrwdhUvb2/RiUN7aZzAMCYZ7aWSh6PrpuQZjoFkHT0UNSWzh69sa/adAoAAADAoB1949m8UrV19+iWqZmmU4Azdu34VNmsFq1gVTuAANXU0a3nt5dr1ogkOaNCTOcAko4eijogNlTPbaswnQIAAAAwaEfva+1y6dm8Ms0YEq+hCeGmc4AzlhARrMtGJuvFgkrVt3WZzgGAfrd2W7nau926cXK66RTgmE8PRd1R3qQD1RyKCgAAALMYtKPXrc0vV1OHS4unsZod/uOGSenqdLm1Or/MdAoA9KtOl1srt5Zq+sBYDUuMMJ0DfM7lo48eivo8h6ICAADAMLvpAPiXju4erdhSoqkDYjTaGWk6p9+1trbo0Uf/pA8+eE9dXV2aPv1s3X339xQbG3fsNXfccZN27971ue+74oo5uuee+yRJy5Y9pZUrlyk4OETf/OZ3dOGFFx973bPPrlBRUeGx157Ib3/7S1VVVenhhx/9wq898MD9Kikp1iOPPCZJWrhwtioq/u/m1Gq1KiwsTKNH5+iuu76tYcOGH/d1DodDCQlJmjHjfN166x0KC/PvpxcGxYfpvCHxWpVXpkWTMhQWZDOdBAD94uVdlapr69ZNfnS4uT9fr2fNulBlZf/3obC/X69jQo8eivry7krdfd4ghTi4PgMAAMAMBu3oVS/sPHozvjhA92a/7757dPjwIf30p79QYmKS/v73R3X33XfpiSeWKygoSB6PR0VFhfr5z3+jiRMnHfu+kJCj+90WFh7U0qVP6I9/fEQNDQ365S9/qilTpisqKkqtrS1auXKF/vrXJ3q9+4YbbtbVV18nSfJ4PKqtrdVDD/2Pvve9b2nVqnXHbso/+7qOjg7t2bNLjzzykAoKtutPf/qbHA5Hr7d5k8VTM7T46Vqtzi/TzVP8Z+AEACfS4/Zo+eYSjUyO0MSMaNM5vYbrtX9dr+ePTdE/91Tr9b3Vmj3GaToHAAAAAYqtY9BrXD1uLcstVk5qlCak+8/N+Mnav3+vNm36RPfcc5+mTp2uwYOH6L777ldNTbXefPM1SVJZWak6Ojo0Zky24uMTjv0nPPzoo/hFRYUaPHiIxozJ0TnnnKewsHCVlhZLkp5+eplmzrxQycm9fwMZGhp6rCUhIVFZWSP0rW/9hxoa6rVlS+5xX5eWlq4LLpilBx74g3bu3KGXXlrf613eZkxKlM4aFKtlucVq7XKZzgGAPvfewVodqW/XjZMzZLFYTOf0Cq7X/ne9Hp8WrYFxoXp+O4eiAgAAwBwG7eg1L++uUkVzp26dmuk3N+Onorj46A12Ts64Y18LCwtTRkaG8vK2SJIKCw8oODhYTmfKcf8ZqampKik5orq6WhUVFaqlpVlJScmqq6vVhg3rdOONt/b9b+RfbLajj147HEFf+rqsrBHKyRmnN954rT+yjLtz+gA1dri0Oo+92gH4N4/Ho2W5xUqLDtH5wxJM5/Qartf+d73mUFQAAAB4Awbt6BU9bo+WbCpWVlKEzhoUazrHiISEo0OI6uqqY1/r6elRVVWVGhrqJR191DwiIlK/+tW9mjPnEt100zVauXK53G63JGnkyNE6//wLNXfupVq8+HrddtvXFR+foCeffFxXXjlfMTEx/fJ7KS0t0V//+oji4xOUnZ3zla8fPHioCgsP9kOZeaNTonT2oDgt31zCqnYAfm1baZN2lDfrhknpslv95wN0rtf+eb2+bFSygmwWPcehqAAAADCEPdrRK97cV60j9e16YPbIgFzNLh296R4wYKAefPC/dN99v1ZkZIT+8Y+/qaGhXt3d3ZKOPmre3t6uqVOn66abbtWOHfn6y1/+pNbWVt1229clST/84X/q61//tux2u0JDQ1VaWqL33ntbzzyzVhs2rNeyZU8qKipKP/nJfRo6dNgJe/Lzt+iii879wte7urqUnT32c19bsuQfWrFiiSTJ5XLJ5XJp2LAs/fa3Dx57TP7LREZGqrW15aTfK193x1kDdMuKPK3KKwvY8wgA+L+lucWKCXVo9uhk0ym9iuu1f16vY0Idmjk8US/vqtR3OBQVAAAABjBoxxnzeDx6alOxBsaF+tWj5afK4XDod7/7vX796/s0d+4lcjgcuuiiSzR9+tmy248eOnbvvb9Se3u7IiMjJUlDhgxVS0uLli59UrfeeuexDyk+/XVJeuyxR3XddYvU1tamRx75o556aqUKCnbo/vt/riVLnjlhz6hRo/Wzn/3qC1//29/+ovr6us99bf78qzRv3lWSjj6CHh0dfexAtZPR1tb6uWZ/N9oZqXMGx2nF5hJdNS5VEcH8qxSAfymsbdX7hXW6c/oAvxtYcr323+v1vBynXt1dpdf2VutKDkUFAABAP2M6hDP2QWGd9le36heXDJc1QFezf2rAgIH6xz+WqbGxQQ6HQ2Fh4br11hs0efI0SZLdbv/CDe6QIUPV1taqlpaWL/zavn17tHPndv30p7/QJ598pIyMAXI6nYqNjdEvfvGfam1tOeEKtqCgEKWnZ3zh6+Hh4V+4cY+MjDrua0/W3r17NGxY1ml/vy+6Y/oA3bwiT6vzWdUOwP8szy1RsN2qq8almk7pE1yv/dP4tGgNigvT2m3lDNoBAADQ79ijHWfE4/HoyY1HlBoVrEtGJJnOMaq1tUXf/vadKiw8oOjoGIWFhau8vEwHDuzXlClHb9zvvPMWPfTQ7z/3fXv27FZCQuJxV5j99a+P6JZbbldwcLAsFos8Ho+ko4+LS5Lb7enj39VX279/n3bu3K5Zsy41ndKvRv1rVfvyzSVq6WSvdgD+o7qlU6/srtKVY5yKCXOYzul1XK/993ptsVi0cFyKdlU0q6C8yXQOAAAAAgyDdpyRzcUN2lHerBsnZ8huC+w/TuHhEerp6dHDD/9BRUWF2rVrp3784//QxImTNXHiZEnSjBnn64UXntMrr2xQaWmJNmxYpxUrlhzb7/WztmzJVXl5mS699ApJ0vDhI1RUdFBbt27W88+v0cCBg/r98e/29nbV1taotrZGpaUleuONf+qee76vsWPH+/WN+4ncedYANXW4tGJziekUAOg1K7eWye3x6PqJaaZT+gTXa/++Xl82KllhDptW5ZeZTgEAAECAYesYnJEnNhYrITxIs3k8V5L0q1/9Tn/84//orrsWKzg4RDNmzNQ3vnH3sV+//vqbZLPZtGTJE6qqqlBSklN33/19zZ499wv/rL/+9c+6/fa7ZLcf/WvqdDr1zW9+Rz//+T2Kjo7Rvfd+cT/XvrZixZJjh7CFhYXL6XTqyivn6ZprbpDN5l97+J6MkcmRunB4opZvLtGCsSlKiAg2nQQAZ6S1y6Xntpdp5rAEpceEms7pM1yv/VdEsF1XjE7W8zvK9d0ZgxUXFmQ6CQAAAAHC8umjraequrr5hN8YExOmhoa2047CiXnTe7ujrEm3PpOv784YrEWT0k3nnDFvem/9jT+/tyUN7brqyc2aPSZZP71oeL//7/vze2uaN763iYmRZ3QQxpddu3uTN7533sgb36ent5Toj+8U6qnrx2l0SpTpnGO88b3yVrxX0qHaNl311GZ985yBX3qOCu/VyeO9OjnHe5/O9NoNAAB8R2Dv9YEz8sTGI4oOsWt+TorpFMCY9JhQLRibovU7KlRUyw0oAN/l6nHr6S2lGp8e7VVDduBUDYwP05TMGK3JL5PLC/bHBwAAQGBg0I7Tsq+qRR8U1umaCWkKC/LvR5CBr3LbtEyFOmx65P0i0ykAcNpe31etyuZO3egHT6kBV49PU1VLl947UGM6BQAAAAGCQTtOy1ObihUeZNM141NNpwDGxYYF6eYpGXrvYK22ljSYzgGAU+bxeLQ8t0QD40J19uA40znAGTtncJxSo4I5FBUAAAD9hkE7Ttnhuja9sbdaC8amKirEYToH8ArXTUhTUkSQ/vRukU737AsAMGXTkQbtq27VoknpslrYThi+z2a1aOG4VG0pbtSBmlbTOQAAAAgADNpxypZsKlaQ3arrJ6aZTgG8RojDprvOHqiCima9sY/H1AH4luWbSxQX5tAlI5NNpwC9ZvYYp4LtVq3OY1U7AAAA+h6DdpyS8qYOvby7SnOznYoPDzKdA3iVy0Yla2hCuP78XqE6untM5wDASdlf3aJPDtXr2glpCrbzoyH8R0yoQxePSNTLuyrV1NFtOgcAAAB+jrspnJJluSWSpEUclAZ8gc1q0Q9nDlF5U6ee2lRsOgcATsryzSUKdVg1PyfFdArQ666dkKYOl1vPbSs3nQIAAAA/x6AdJ62mtUsv7KzQ5aOS5IwKMZ0DeKWJGTG6ZGSSluYWq7i+3XQOAHypyuZO/XNPta4c41R0KOeuwP8MS4zQtAGxWplXpi6X23QOAAAA/BiDdpy05bkl6u5x6+YpmaZTAK/23fMGKchm1e/fPsDBqAC82sqtpfJ4PLp+Ik+qwX8tmpyu2tYuvbqnynQKAAAA/BiDdpyU+rYurd1WpotHJCkzNtR0DuDVEiKCdedZA/RRUb3ePVBrOgcAjqul06Xnt5frguGJSo3mSTX4rymZMRqWGK7lm0v4ABwAAAB9hkE7TsqKLaXqdLl161RWswMn4+rxaRqaEK7/9/ZBDkYF4JWe316u1q4e3TiZ1ezwbxaLRYsmpauotk0fFdWbzgEAAICfYtCOr9TY3q3VeWW6MCtRA+PDTOcAPsFutejHFwxVRXOnnuRgVABeptPl1ootpZqUGaORyZGmc4A+NysrUUkRQVq+mWsyAAAA+gaDdnylZ7aWqq27R7dOYzU7cCrGp0fr0pFJWpZbrKLaNtM5AHDMhoIK1bZ26dapGaZTgH5ht1l13cR0bS5u1O7KZtM5AAAA8EMM2vGlmjtcWrm1VOcPS9DQhHDTOYDP+e6MwQpz2HT/P/epx82+sADMc7k9WppbojEpkZqUEWM6B+g3c7OdCg+yaXluiekUAAAA+CEG7fhSz+aVqrWrR7exmh04LfHhQfr++UO0o7xJq/LLTOcAgF7fW6Wyxg7dMiVTFovFdA7QbyKC7Zqfk6I391WrrLHDdA4AAAD8DIN2nFBLp0vPbC3VeUPilZUUYToH8FmXjkzS2YPi9Oj7RSppaDedAyCAuT0ePbWxWIPjw3TukDjTOUC/u2ZCmiwWi5blslc7AAAAeheDdpzQ6vwyNXW4WM0OnCGLxaJ7Lhwqm9Wi372+Xx4PW8gAMOP9g7UqrG3TLVMzZGU1OwJQcmSwZo9J1vqdFSpnVTsAAAB6EYN2HFdzh0vLckt0zuA4jXJGms4BfJ4zKkTfOW+Qco80aP2OCtM5AAKQx+PRkxuLlRodoouykkznAMYsnpopt0d67P1C0ykAAADwIwzacVzLNxerudOlu84eaDoF8Btzc1I0MSNaD71bqKrmTtM5AALM5uIGFVQ06+bJ6bJbWc2OwJUSFaIrxyTr2c3FquR6DAAAgF7CoB1fUNfWpWe2lurC4YnszQ70IqvFontnDZfL7dH9r+2Tmy1kAPSjJzYWKyE8SJePdppOAYxbPPXo1ohPbTxiuAQAAAD+gkE7vuCpjcXqdLn19bMHmE4B/E56TKj+Y8ZgfXKoXqvyykznAAgQW4obtPlIg26cnK5gOz/+ASlRIVowIV3rd1aooom92gEAAHDmuNPC51Q2d2rttjJdPipZA+PCTOcAfmnB2BSdMzhOf36vUAdqWk3nAPBzHo9Hf/vwkBIjgjQ/J8V0DuA17jpvsDweacmmYtMpAAAA8AMM2vE5//jksNwe6Y6zWM0O9BWLxaL7Lh6uiGC7fv7yHnW53KaTAPixjYfrlVfapMVTMxXisJnOAbxGWkyorhzjZFU7AAAAegWDdhxTXN+uF3ZUaH5OilKiQkznAH4tLixIP784S/urW/XoB4dM5wDwUx6PR3/98LBSooI1Zwx7swP/7papGfJ4pKdY1Q4AAIAzxKAdxzz28WHZbVYtnpZpOgUICGcPjtPCsSlasaVEmw7Xm84B4IfeL6xTQUWzbpuWqSD2Zge+ICUqRHOynVq3o0LF9e2mcwAAAODDuOOCJKmgolmv7q7StRPSlBAeZDoHCBjfnTFYA+NC9YtX9qq2tct0DgA/4v7X3uwZMSG6fFSy6RzAa90+fYCCbBaeMAMAAMAZYdAOeTwe/eHtg4oLc+iWKRmmc4CAEuKw6XdXjFRzp0v3vrRbLrfHdBIAP/H2/hrtq27V7dMHyG7jRz7gRBLCg3TDxHS9sa9aBeVNpnMAAADgo7jrgl7bU63tZU361jmDFBFsN50DBJxhiRH6yQVDtbm4UX/78JDpHAB+oMft0d8+PKxBcWG6eESS6RzA6y2anK64MIcefq9IHg8fegMAAODUMWgPcO3dPfrTe4UakRShK8bwWDlgyuwxTs3JduqpTcV672Ct6RwAPu7lXZUqqmvTnWcNkM1qMZ0DeL3wILvumD5AeSWNent/jekcAAAA+CAG7QFuWW6xqlq69P3zh8hq4UYcMOlHM4cqKylCv3xlr0oaOJANwOlp7+7R/354SGNSInXB8ATTOYDPmJuTomGJ4frjO4Xq6O4xnQMAAAAfw6A9gFU0dWhpbokuykrU+PRo0zlAwAu2W/XA7JGSpHte3M1NPoDTsnxziapbuvQfMwbLwofowEmzWy364cwhqmju1NLcYtM5AAAA8DEM2gPYn98rkiR957xBhksAfCo9JlS/vDRLe6ta9JvX9rFPLIBTUtPSqWW5xbpgeILGpvEhOnCqJqTHaFZWopbmlqi0kafLAAAAcPIYtAeorSUNem1vtW6clC5nVIjpHACfcd6QeH3znIH6555qPbmRFXUATt4j7xepu8ejb5/Lh+jA6frOjMGyWSz67zcO8IE3AAAAThqD9gDU5XLrv17fr5SoYN00JcN0DoDjuGVKhi4ZmaT//fCQ3tpXbToHgA/YVtqol3ZVadGkdKXHhJrOAXxWcmSwvnHOQH18qF6v7+UaDAAAgJPDoD0ALdlUrEN17frJhcMU6rCZzgFwHBaLRffOGq7slEj9/JW92lPZbDoJgBfrcXv0328eUFJEkG6dlmk6B/B5V41L1ShnpP7f2wfV1NFtOgcAAAA+gEF7gDlU26YnNx3RxSMSdfagONM5AL5EsN2qB+eMVkyoQz9YV6Calk7TSQC81Npt5dpf3arvfW0IH6IDvcBmteinFw1TY3u3/vBOoekcAAAA+AAG7QHE5fbo1//cq1CHTd/72hDTOQBOQnx4kP4wd7SaO1367nM71dLpMp0EwMtUNnfq0Q+KNHVAjC4YnmA6B/AbWUkRunlKhl4qqNT7B2tN5wAAAMDLMWgPIMtyi7WjvFk/njlU8eFBpnMAnKThSRF6YPYoHaxt0w/WFajT5TadBMBLeDwe/fcb++Vye3TPhcNksVhMJwF+5fbpAzQsMVy/fX2/GtvZQgYAAAAnxqA9QOyratFjHx3WhcMTNGtEoukcAKforEFx+uUlWdpa0qh7X9otl9tjOgmAF3hzX43eL6zTXWcP5ABUoA84bFb94uIsNbR364E39svj4foLAACA42PQHgA6unv081f2KCrErp9cwGo3wFddMjJJPzh/iN45UKsHXudmHwh0ta1d+p83D2hkcoSunZBmOgfwW1nJEfr6WQP0xr4ard9RYToHAAAAXopBewB46N1CHaxp0y8vzVJMmMN0DoAzcO2ENN06LVPrd1bokfcPMWwHApTH49H9/9yntu4e/fLSLNmtfIgO9KWbp2RocmaMfv/2QRXWtprOAQAAgBdi0O7n3tpXrbXbynXjpHRNHxhnOgdAL7jrrAFaMDZFS3OL9dCbBxi2AwFo7bZyfVhUp7vPHaTB8eGmcwC/Z7VY9OtLsxTmsOmeF3ertYvDyQEAAPB5DNr92OG6Nt3/2j6NckbqG+cMNJ0DoJdYLBb9+IKhmpPt1KPvHtSjH7CyHQgkB6pb9dC7hZo2MFZXj081nQMEjISIYN1/+QgdrmvTr1/dx7UXAAAAn8Og3U+1drn0o/W7ZLda9cDskXLY+L8a8CdWi0U/vWiYrp2coac2FeuR94u44QcCQEunSz95cZcigu36xSVZnLsC9LOpA2L17XMH6a39NXpqU7HpHAAAAHgRu+kA9D63x6NfvrJXR+rb9MjCHKVEhZhOAtAHrBaLfj17lFxdLi3NLVGPW/rujEEM3gA/5fF49NvX9qukoV2PXpWjhPAg00lAQFo0KV17q1r06AeHlBkbqguGJ5pOAgAAgBdg0O6H/vL+Ib1zoFbf+9pgTcqMMZ0DoA99uo2MzWrRii0lau/uOfbfAfiXpbklemNftb51zkBNzOD6DphisVh076zhKm/q1M9f3qOE8CCNTYs2nQUAAADD2E/Ezzy3vVxLc4u1YGyKrpuQZjoHQD+wWCz6wflDdPOUDD23vVz/uWG3Ol1u01kAetE7+2v0l/eLNCsrUTdPyTCdAwS8EIdN/2/OaDmjQvSDdQUqrG01nQQAAADDGLT7kXcP1Op/3tivswfF6Yczh7J9BBBALBaLvn3uIH3//CF6e3+N7l67Q80dLtNZAHrB7spm3ffyHo1OidR9Fw/n+g54iZgwhx6eP0Z2m1XfWr1DxfXtppMAAABgEIN2P7HxcL3+88WdSih6XYVP/UCXXnye7r33x6qrqz3h93zyyUe67bYbddFF5+qmm67R66+/etzXeTwe/eAH39FTTz3eV/lAwHjwwd/pgQfu/9LX7NmzS9/4xq264IKzde218/TKKxtO+NrXXvunzjlnksrLyyRJ101I028vH6EdZU2689ltqm7p7NV+AP3rUG2b7l72vuyblqh86fc1d/YF+sUv/lM1NdUn/J633npDN910jS688BwtWnSVXnrphc/9+vbt+frGN27ThReeo7lzL9Wjj/5J3d3dff1bAYzbuXOHZsyYqq1bN3/la0tLS3TRReeqqqryuL/udrv1ve99S2+/+Kz+sjBb3T1ufXP1dpU1dvR2NgAAAHwEg3Y/kFfSqB+uK1BM4ZuyHs7Vfff9So888ndVVVXpZz/78XG/Z/v2fP3oR99VTs44Pf74Mi1atFgPPvhfevXVlz73uu7ubj3wwP3auPGj/vitAH7L4/Ho8cf/qvXrn/vS19XX1+v7379bw4eP0BNPrNDChdfogQfu1/9v787jo6jvP46/dnPfBzkhyJ0vIBIOqQdeaBW0Wq0nCtILrfetrcWq1HpU2p9tsWqpVVFb0Cr1qgdqvVAQFAggMIDcJIEkBJKQe3d/f8wSQhKTDckmm+z7+XjMI7sz351855NvZmY/853vLF26pEnZoqIiZs68v8n8s4am8acLR5C3v4qf/HMF63aXddRmiEgnKiit4vpXVlHz8VNkJzqZPftvzJ49h+LiYu6669ZmP5Obu4KZM2dw4YWXMnfufC6+eDKPPvogX3yxyF5nQT63334Tw4cfzdy585kx437ee+9tnnpqdmdumkinq6ys5He/uxeXy9Vq2e3bt3HrrddTWdl8D/Xa2loefvi3LFv2JQCDUmJ4/OJjOFDj4uqXctmunu0iIiIiQUmJ9m5u6bYSbnp1NWnRIdRaH3PNNdczbtzxGDOUmTMfYvXqXFavzm3yuXnzXmDEiJHcfPPt9OvXn7POmsSUKdP4xz/+Vl/GstZz9dU/Zvnyr4mNjevMzRLpUXbt2slNN13Da6+9Qnp6Rotl33rrNWJiYrn55jvo168/F188mYkTz2HevBealH344d+SnW2aXc9x/ZKYMzkHp8PBVfNzWbh+T4dsi4h0joLSKq55eRXl+0sYe7Th/nvuY8iQbIYMyeayy65gw4b1lJaWNvncZ599wqBBQ7jggovo0yeLCy64iOxsw9KliwHIz8/j1FMncOONt9GnTxbjxh3HGWecyVdfLevsTRTpVLNn/x+pqWmtlnv55XlMnz7tO899169f+rv4gwAAIABJREFUy/Tp01i1aiUxMTH184emx/HkpSOprnNz1fyVbCrUmO0iIiIiwUaJ9m7s8817ufU/a+iTGMkdY6KorKhg9Oix9cszM3uTmdmb3NwVTT67Y8cOcnJGHzYvO9uQn59HQUEBAMuWLSEnZwzPPfdPYmNj/bsxIj3YmjWrSEtLZ+7c+WRm9m6xbG7uCkaNGo3TeWj3PHr0WFavzsXj8dTPW7Dg3xQXF3HNNdd857pMWixzp45maFosM/67nicXbcHdYB0iEpjyS6v4xcur2F9VyxNXjuex38+q33fs2bOb119fwLBhw4mPj2/y2cTERLZu3czy5V/h8XhYuXI5mzd/izHDAHt/cs89M+vLW9Z6PvvsE773veM7Z+NEusDixYtYvPhzbrnlzlbLLlr0CXfd9WtuuOGWZpcvXbqEY48dx7PP/pPo6JjDlpm0WOZclkOI08H0+StZsnVvh9RfRERERLqH0K6ugByZN9YU8NDCDQxJjWX2RceQu+wzgCY9dVJSUpodW7K5+fn5+QDs27eXjIwMpk79iX8qLxJkJk48h4kTz/GpbGHhHoYMObyXekpKClVVVezfv5/ExES2b9/GnDlP8Pjjc3A6W37gaXJ0OE9eOpLff7CJZ77cwaaiCu6fZIiL1O5fJBB9W3SAmxesoaLGxeMXj+TojEO9au+++3Y+++wT4uLi+ctfnmr28xdeeClr1qzippuuISQkBJfLxeWXX8nZZ5/bpOykSadRXl5Odrbhxz/+ud+2SaQr7du3j0ceeYC7776PuLjW79A8+L/1XeO4T5v2sxY/P6BXNM9cPorbXvuGWxas4fbTB3NxTqYeYiwiIiISBNSjvZvxeDz8ffE2HnhvA8celchTl40kMTqMqqoqnE4noaGHJ8/CwsKpqalpsp6JE8/hww8X8uGH71NXV8eGDeuZN+9FAD0QTaQLVVVVERERcdi8sLBwAGpqqqmrq+OBB+5lypRpDB48xKd1hoU4mXHWEO6YMIjPNxcz9cXlfFOgcdtFAs3ynfu4an4uLreHJy89PMkOMH36tcyZ8xwjR+Zw663XU1jYdEiokpK9FBcXc911N/H0089zyy13sGDBy7z11uuHlXO73Tz22F/54x9nU1VVxZ133nzYXTMiPcWsWQ8yfvwpHH/8iZ32OzPiI/n75BxOGJDMox9u4tdvrae8uuUL4yIiIiLS/SnR3o1U1Li4cf5K5nyxjXOGp/HYj0YQE24n1iMiInC73dTVHX4SX1tbQ2RkVJN1nX32ufz0p1fx0EP3c/rpJzJjxl1MnjwFgJgYDRMj0lUiIiKaXByrrbXfR0ZG8fzzz+B0OrniimltWq/D4eCyMX2YM3kUbreH6fNW8q+vdyqxJhIg3lhdwA2vrKZXTBjPXDEKk9b0WDxo0GCGDx/BzJkP43a7eeedt5qUefTRB8nONlxxxTSGDDFcfPFkLr/8Sp588i+H/b87nU6GDTua4447gRkzZrJ6dS5r1qzy6zaKdLZ33nmLDRs2cMMNzT882J9iwkP54wVHc/1J/floYyFXvrhcDycXERER6eGUaO8mdu6r5GfzVvD+ut3cfOpA7p9kCAs59OdLS0sHoLi46LDPFRUVkZqa2uw6f/KT6bz33icsWPBfXn75ddLT0wkJCSEjI9N/GyIiLUpLS2/2/zgqKprY2Fhv0mA9kyadxplnnszVV18FwJVXXsrzzz/T6vpH9o7nxSvHcNLAZB77eDO3v/YN+yp1F4tIV6lzufnD/zbxwMINjMlK4OnJo8iMj6xfvndvMR988N5hn4mMjKRPnz4UFhY2Wd8336xm6NDhh80bPnwE+/fvp6ysjC1bNrNs2ZLDlg8aNBig2fWJdGdvv/0mhYW7Of/8iZx55slcccVFANxxx83MmvWQ33+/0+HgJ8cdxVOX5lBT5+bn81Yyf/kuPS9FREREpIfSIL3dwOKte7nnv+txAP+YdiwjUqKblBk8OJvo6BhWrlxePxZ0fn4e+fl55OSMaVL+1VdfYufOndx88+2kpNiJ+E8//ZgRI0YSHd10/SLSOUaOHMXbb7+Jx+OpH891+fKvOOaYHJxOJ7Nn/+2wO1d27NjMnXfezqxZf65PlrUmISqMR384nJdW5PHnTzYzee7X3HPWEE4a2Msv2yQizdtZUsGNL+WyJr+My8f04aZTBxLqPHwc54KCfO6/fwZZWX3rE+jl5eVs376NSZOajruemprGt99uPGze5s2bSEhIID4+njff/A//+tfzLFjwdv0wVWvXrgGgf/8B/thMkS5z770PUF1dXf++uLiY66+fzq9+dQ/jxh3XafUYlZXAP68cy8z3LP740bd8uKGQu88cwsBeMa1/WERERES6DfVoD2C1LjdPLNrCLQvWkBYbwXNTRnPS4JRmy4aHh/OjH13MX//6Z5Ys+QLLWs999/2aUaPGMGLEMdTW1lJcXFQ//vpRR/VnwYKXee+9t8nPz+OFF55l4cJ3mD79ms7cRJGg1/h/89xzz2ffvhJmzXqIrVu38Mor83n//XeZMsUeKiYjI5OsrL71U3p6Wv38+PgEn3+vw+Fg8pg+PDdlNElRYdz6n2944D1LY8iKdAKPx8O76/bwwye+YOveCh45bxi3TRjUJMkOMHTocHJyRvPII79j7do1bNiwnnvv/RWJiUmcffa5VFdXUVxchMvlAuCSSy7n9dcX8Nprr5CXt4uFC9/lhReeZerUnwIwadIPAHj44d+ybdtWli1bwiOPPMAZZ5zJwIGDOi8IIp0gNTXtsGNmZqZ912ZKSipJScnU1tYcdgz2p8ToMP7vgqP5zcRsthRXMOX55Ty5aAtVtS6//24RERER6RxKtAeorcUV/HzeSp79cgfnHp3OPy4fRVZi07HWG7rqqms588xJPPDAb7jppl+QkZHJ7373KACrV+dy/vmTWL06F4Bx447jjjvu5pln5jB16iV8+ulH/P73jzF69Fi/b5uIHNL4fzM5uRd/+MNsNm60+NnPpvDqqy9zzz0zGTt2nF9+v0mLZe6U0fz4e31565vdXPH81yzbXuKX3yUiUHyghrveWMtv3l7PkLRYXrxyDGdkNz/EG9hjqT/44CyGDMnmrrtu5YYbfkF0dAyPPz6H6OhoPvzwfc4/fxJ79uwG4MILL+G2237Jq6++zLRpl/H8889w9dXX1z+HpVevFP7856coKSlh+vRpPPDAfZxyygRmzJjZKdsvEkhWrFh52DHY3xwOBz8ckcG/f3osE4em8syXO7j8+a/5ZFOxnpkiIiIi0gM4jvSkrrCw7Ds/mJgYzb59FUdcqWDm8Xh4NTefP32ymchQJzPOymbCkEO92BVb/1Fs/Uex9Z+OjG3urv3MfNdix74qzj06nZtPGUhidFiHrLs7CsR2m5oa17TLcxu0dOzuSIEYu65W5/bw6so8nvx8K7UuN9eM7891Z2RTVlrZ1VXrFtSmfKdY+a6rY7Vsewm//2AT20oqGdk7nhtOHsDoLN/vTutMXR2r7qK5OLX32C0iIiLdh8ZoDyDb9lbw6IebWLp9H8f3T+K+idmkxEZ0dbVEJEjk9EngX9PG8vSS7bz41U4++7aYm04dyHlHp9ePFy8ibbc6r5RHPtjIhsIDHNcvkTtPH0y/5GhCmhkqRkSCx7ijkpj/47G8+c1u/r54G1e/lMv4AclcO74/Jj22q6snIiIiIm2kRHsAqKp18ezSHbywbAcRoU5+ecZgLsrJVGJLRDpdZFgIN5w8gEnD0njk/Y088N4G3vpmN3dMGER2mr70i7RFQWkVc77Yxpvf7CYtNpyHzx3GGdkpOr6LSL3QECc/GpnJ2cPSeHlFHs8t3cHUF5dzfP8kpo3L4ti+idpniIiIiHQTSrR3IY/Hw6LNe/nDR9+St7+Ks4elcfOpA+kVE97VVRORIDc4JYY5k3N4Y3UBj3+2hakvLOe8EelcO76/7rQRacW+ilqeXbqdV1bm4QGmHpvF9BOOIiZcp10i0rzIsBCmfa8vPxqZySu5ecxfvovr/r2aYemxXDmuLxOGpDT7wGQRERERCRz6xtdFcnft56+fbWHFrlIGJEfz1KUjGds3saurJSJSz+lwcMHITE7PTuGZJTt4acUu3rcKuXJcX6Yem0VUWEhXV1EkoJRV1TF/+S7++fVOKmtd/GB4Oled2I/M+MiurpqIdBNxkaH89LijuGJsFm+v3c2LX+3k12+tIzU2nAuOyeCCYzJJi9MFbxEREZFApER7J7P2lPPkoq18vmUvvWLCueuMwVxwTAZhIc6urpqISLPiI8O45bSBXDwqk8c/28KcL7bxyso8ph6bxcWjeivhLkFvT1k185bv4j+r8jlQ42LCkBSuHd+fAb2iu7pqItJNRYTaQ8r8cEQGizbv5dXcPJ5evJ1nlmzn5EG9uCgnk+/1S8KpYWVEREREAoYS7Z3A4/GwbPs+5i3fxaLNe4mPDOWGkwdw6WglqESk+8hKjOKR84aTu2s/f1+8jb98uoXnl+1k6rFZXDKqN9Hh2p9JcNlSXME/v9rJf9fuxu3xcKZJ5cpxfTF6noGIdJAQp4NTB/fi1MG92Lmvkv+sKuCNNQV8vKmYvomRnH9MJpOGpZGuXu4iIiIiXc7h8XiO6IOFhWXf+cHExGj27as44kr1FDV1bt5bv4d5y3exsfAASVFhXDKqN5PH9CEu8siucSi2/qPY+o9i6z9dGdtVeaU8vXgbi7eWkBAZyvnHZHLJqEwyesgwGYHYblNT49rVdbGlY3dHCsTYdRS3x8Pnm/fy0opdfLltHxGhTs47Op0px2aRlRjVpnX15Dh1NMXKd4qV77prrGrq3Hy0sYhXc/NYsasUBzD2qETOGZbG6dkpfnkeRHeNVWdrLk7tPXaLiIhI96FEewdzezys3LWfd9ft4QOriLLqOgalRHPFmCwmDksjIrR9Q8QEc2z9TbH1H8XWfwIhtmvyS3nxq518tLEIgNMGp3Dp6N6MyUrA0Y1vaQ+E2DamRHvXKamo4e21e3glN4+d+6pIjQ3n4pzeXDAyg+ToI3uIeU+Mk78oVr5TrHzXE2K1o6SSd9bt5p11e9i5r4qIUCenDe7F2cPSOa5fIqEdNDxlT4hVZ1CiXUREJLhp6JgOUOf2sDqvlEWbi1m4vpCCsmoiQ52cNiSFc49O53tHJXbrZJOISEtGZMbzyHnDKSit4t8r83l9dT7/21hE38RIJg5NY+KwNPona6xq6X7q3B4Wb9nLm9/s5rNvi6lzexjZO57rThrAhMG9OiyBJSJypPomRXH1if256oR+rMor5Z11e3jfKuS99YXERYRyyqBkJgxJ5bh+iURqyEoRERERv1Ki/Qh4PB527qti+c59fLGlhKXbSyivdhHigOP6J3Hdyf05dVCKxisWkaCSER/JjacM4KoTjmKhVci76/bwjyXbeXrJdoalx/L97FTGD0xmYK9oXXyUgOXxeFhbUMZCq5CF6wspOlBDUlQYl47uzXkjMhicEtPVVRQRacLhcJDTJ4GcPgncdtogFm/dy0cbi/j02738d+0eosKcjB+QzIQhKZw4IJnYCH0NFBEREeloGjqmFR6Ph+IDNXxbXMHagjJW55WyJr+MkspaANJiwzmhfzInDkjie/2S/H7S2pGxfeKJ2cya9TAHDpR3yPpEpOPExMRy5513c911N7ZYLtD3t4Xl1Sxcbyfd1++x9zWZ8RGMH5DMiQOSGdUn4YifWeFvgRhbDR3jHx6PB2tPOR9uKGKhVUje/irCQhyc2D+Zc49O56SByX7pve6vOOn4LtJ+vh6HA12dy83XO/bzv41FfLypiL0VtYQ6HeT0ieeE/skc3z+J7NSYVi+Ad7f9elfR0DEiIiLBTYl2L5fbQ2F5NTv2VbK5qILNxRVsLj7A5uIKSqvq6sv1S4piRO94RmbGMbJPAoM6uWdmR8b2mGOy2b27oEPWJSIdLz09g9WrN7RYpjvtbwtKq/hiawmfb97L0m0lVNW5ARjYK5qRvePJ6RPP0LQ4+iVHERYAQ3IEYmyVaO84FTUulm4rYdGWvXyxZS+F5TWEOGBcvyTOMqmcNjjF7xeB/BUnHd9FOoYvx+HuxOX2sMo73OXirSVsLDwAQHJ0GGOyEhmdFc+oPgkMTo3B2ej7TXfYrwcCJdpFRESCW2B2I/SDqloXRQdq2FNeTVF5DXn7q8grrbJ/7q8iv7SaOveh/ENcRCgDe0VzRnYKA3vFMLBXNNlpsSRGhXXhVnSsa6+9UT3eRAJUTEws117bvXvRNZYRH8mFIzO5cGQmNXVuVuWVsiqvlNy8/Xy4oYjXVtuJwRCng35JUQxOiaF/r2j6JESSGR9J74RIUmLCCXHq+6q0XUWNi9y8/azYuZ/lO/bzTUEZdW4PMeEhHN8/ifEDkjlpYDJJR/hg00Ci47tI+/XE43CI08HorARGZyVw4ylQVF7Nkm0lLNlawoqd+/lgQyFgfw86OiMOkx6LSbOn+PioLq69iIiISODrNj3aPR4PdW4PlbUuqmrdVNW5qap1UVnroqy6jtKqOvZX1bG/spbSqjpKq2opqail8EANReU1lFXXNVlnYlQYvRMi6e1N4PRJjKRPQiQDe0WTEhMekGMIqzeJ/yi2/qPY+k9Pia3b42Hr3go27jnApiJ72lx0gLzS6sPKhTgdJEWFkRQdduhndDhJUWHER4YSHR5CTHgIUWH2z+jwUKLCnMSEhxIVHkJoG5L0gRhb9Wj3TWWti02FB1i3uxxrTxnrdpezuegALg+EOGBYRhxjshI4oX8yOX3iu+wOiq6OU3eiWPlOsfKdYnWIx+Mhv7SalbvsC5LrdpfzbdGB+o5I0eEhZCVEclRSFEclRdE3KYrM+EjSYiNIjQ3Xg1a91KNdREQkuAVMj/a9FTVc89Iq9lXW4vZ4cHvw/rRf17ncuHxIDziA+MhQ4iNDSYgKo39yNOP6JpISG05qbDipMRH0ig0nMz6CmPCA2XwRkaDmdDi8dw/FMLHB/Oo6NwWl9h1I+d67j0oqatlbUcO+ylryCqooqajlQI3Lp98T4nQQHuIgPMRJWIiTsBAHYSFO7/uDr+2fEeGhuOpcOB0OHA77QXMOwNng9cH5DecBjDsqkXOGp3dwlOQgl9tDSUUNu8tr2FNWTUFZNdv3VrC9pJJtJZXsLjt0gSYxKoyh6bGcPDCZMVmJHNM7Xg8rFxFpxOFw2B2QEiLrj1+1Ljebiyqw9pSzvayaTQVlWHvK+WhjUZPvZQmRofSKCSchKowE73ex+Miw+u9l0eEhRIeFEBlmXwy3Xzvt1+EhRIQ6mwxXIyIiItLdBEymOToshFMH96Ksug6nN2lxMLkR4nAQGuIgKsw+CYvynphFhto/4yMOncjFRoRqWAERkR4iItRJv+Ro+iVHt1iuus5NWVUtFbVuKmrqqKh1UVHTYKp1caDGRU2dmxqXm1qXh1qXm1qXm5r61x5qXG7qXG4qa+tw1LiorXPj8XjwYF/89XjA470Q7MHuAej2YC9vMPxYbERo0CTat+6toLC82o4NgAeiYysoL6/C7bHfe/DUL/d4Cx18X+f21P9d6n+63N6/aR1l1d6pykVZdS1l1S72Vdbich+e5YkJD6FfcjRjshLol2wPPWTSYkmPiwjIO9RERAJdWIjTHj4mPfawntp1Ljd5pdXsLqtiT5k9NOfusmqKD9h3Ee/aX8XaAvsu44PPY/FFpPd7XniofdHb/uk87CL4wfcRoQ5CQ5yENPre2PD7o6N+GU2OA8313xrUK5qzhqa1J2QiIiIS5AIm0R4ZFsL1Jw/o6mqIiEg3FBHqJCI2okPXqSEFWlfncjN57tdNkt4dIcRhX7CIiwwlLsKe0uNiiIsMJTEqzDtcQQTpceGkxUWQFBWmhLqISCcIDXHWDyHTmuo6N6VVtVTU2MN/VniH/jw0uamssV9XeIcIrXa5qW1wYbzGe2G8orbOvkBef1HWc+iCdzN3RDdc5vJA4yNE40PGiMx4JdpFRESkXQIm0S4iIiLdS2iIk5d+PJaiAzX2MDrYw+fExUVy4ED1oeF1sF80fO/AfhHmHconPMRJeKiTiFC7t2JbxtMXEZHAFBHqJLWDL4SLiIiIBCol2kVEROSINTe0j+4GEBERERERkWDj7OoKiIiIiIiIiIiIiIh0Z0q0i4iIiIiIiIiIiIi0gxLtIiIiIiIiIiIiIiLtoES7iIiIiIiIiIiIiEg7KNEuIiIiIiIiIiIiItIOSrSLiIiIiIiIiIiIiLSDEu0iIiIiIiIiIiIiIu2gRLuIiIiIiIiIiIiISDso0S4iIiIiIiIiIiIi0g5KtIuIiIiIiIiIiIiItIfH4+nw6f7777/fH+vVpNgqtt1zUmwV2+44KbaKneIUOJNipVgpVopVd5gUJ02aNGnSpCm4J3/1aL/PT+sVxdafFFv/UWz9R7H1H8X2yCl2vlGcfKdY+U6x8p1i5TvFyjeKk4iISBDT0DEiIiIiIiIiIiIiIu3gr0T7TD+tVxRbf1Js/Uex9R/F1n8U2yOn2PlGcfKdYuU7xcp3ipXvFCvfKE4iIiJBzOHxeLq6DiIiIiIiIiIiIiIi3ZaGjhERERERERERERERaQcl2kVERERERERERERE2kGJdhERERERERERERGRdgj1pZAxJgKYDVwCVAP/Z1nWo99R9mTgT8BQYCNwl2VZCxsst4DsRh8bbVnWyrZXv/trY2xPB/6AHb+VwK2WZS1rsHwC8GdgMLAUmG5Z1ib/bkHg6uDYqt02wxvjr4FbLMv64DvK9AP+DowHtgO3WZb1ToPlarfN6KDYqt02w5fYNig7GFgNxFmWVddgfg7wFJADrAOuabjP6OmMMUOBx4HjgWLgccuyZjVT7mPg1GZW8ZFlWaf7tZIBwNc4ecu2eP7U07UxVi0es4OJMebvwBDLsk77juU6xtJ6nBqUmwJca1nWSZ1SsQDkQ5u6CbgRyMQ+Pt5uWdYXnVfDwOFDrH4FXA/0Aj4FbrQsa2Pn1VBEREQ6m6892mcBJwDfB34B3GOMmdy4kDEmDXgT+DcwEngZeM2bDDqY3BiEnRTKbDCtad9mdGu+xnYY8C7wPjAWeAP40BiT5V3e1zvvReBYoAB43RgTzHctdFRs1W6bYYyJBOYBR7dQxgG8jp00GQfMBV41xgzwLle7bUYHxVbtthm+xLZB2b7AW0Bko/kxwDvAEux9xmfAf40xcR1e4QBkjAnD3v7twCjsJMJvvAmqxi7k8Pb3faAOeKxzatt12hKn1s6fero2xqrFY3YwMcacAUxvYbmOsbQepwblJgBz/F+jwOVDm5oKPADcjf2/+jHwrjGmT6dUMID4EKvpwB3AVdgX5UuAt4Lt/09ERCTYtNqj3ZtQuAo4z7Ksr4GvjTGPAjcA8xsVHw9gWdYj3vcPGWNux+6dtA0wgAdYZllWbcdsQvfVxtheB3xtWdYvve8f9fbouh77ZPcqIPdgj21jzM+wv1CdDrTYY7Mn6uDYqt02YowZDvwLcLRSdAJ2/E62LKsMWGuM+T7wc+Ae1G6b6MDYqt020obYYoy5ADvhkt/M4suAWuxefG5jzK3AD7zzn+64GgesPtg9Y6+3LKsS2GSM+QC75/o/Gxa0LGvvwdfei0NvAHMty3qzE+vbVXyOE62fP/V0bYlVa8fsoOA9z5kDfN5CsaA/xvoYJ4wx92G3n6DtbexjrH4CPGFZ1ive93cbYy4CzsO+yyso+BirOOBOy7Le9X7mYSAXyADy/F5JERER6RK+XFHPASKARQ3mLQLGGWNCGpUtBhKMMZcYYxzeREUcsMq7fDiwWUmfem2J7UBgcaN5udg9tsH+Mv7pwQWWZVUAyxssDzYdGVu126ZOBT6i9fZ1PLDCmwg+aBFqty3pqNiq3Tbla2zBTpz/Bri5mWXHA59bluUGsCzLg/1lOyjarWVZWy3LusyyrErvsX48cArwYSsfnYw9LMoMv1cyALQxTq2dP/VobYxVa8fsYPEgdm/ij1soo2Osb3ECOBOYCLzq5/oEMl9idQ9Ne/17gET/VClgtRory7IesyzrWQBjTAL2xcBvsC92iYiISA/lyxjtmcBey7KqGszbDYQDaRze2+8z7PE1XwLcQAj2WJDrvMuHAy5jzDvAaMDCHoP0y3ZtRffVltjuBhrfFt0PSGmwrsa9I5r7TLDoyNiq3TZiWdaTB18bY1oq2lq7VLttpANjq3bbSBtii2VZV3nLndbM4kzseDa0G/s2+mCzE+iNPcTOK62U/TXwpGVZu/1eq8DTWpxaO38KJq3FqrVjdo9njDkB+/kzI4DbWyga1MfYNsSJg2Oye4ePCTq+xsqyrCWNPjcJ+1kJQXGHBLStXXnLXw38Dft5URMPXqQXERGRnsmXHu3R2CcGDR18H9FofgwwAPgd9pjBvwT+bIw53rt8GJAEPAGcA6wF/meM6d/mmvcMbYntfOBCY8xFxphQY8wPgB9iJ45bWlfj9QSLjoyt2u2Ra61dqt0eudZip3brP2q3h5zvncbQwrjrxpiTsHuzz+6kegWa1uLU2vlTMGktVq0ds3s07/M3/oH9MOeSVooH7b6qjXEKakcaK2NMNvA88LxlWV/5q36B5Ahj9R728ySewX5GwgB/1U9ERES6ni+J9iqanpAffF/RaP6dQIRlWfdalrXCOybkq9i3GQJcARjLst60LGs59jib3wLTjqj23Z/PsbUsayH22JEvYn9Juh+791tpK+tq/DcKFh0ZW7XbI9dau1S7PXKtxU7t1n/Ubr0sy/rKsqw3sHv1/cIY813JzsuA/1mWtbPzahc4fIhTa+dPQaO1WPlwzO7p7gU2Wpb1bx/KBvO+qi1xCnZtjpUxZgT2sCnrgV/4qV6BqM2xsixrm/c87HrsO2p/7K/KiYiISNfzJdG+C0hq9EUnA/vLzd5GZcdhj5PZ0NfY42lBB5/kAAAEQUlEQVRiWVatZVn1X4S849qux34IVjBqS2yxLGsWEA/0sSxrnHf21gbrymj0kQyaf5BfMOiw2Krdtktr7VLt9si1GDu1W78K6nZrjOljjPlho9lrsXsUx3/Hx84GFvi1YgGmjXFq8fypp2trm2rlfKinuwKYaIwpN8aUA3cBJ3tfNxbM+6q2xCnYtSlWxphjgU+ADcA5jYZp7Ol8jpUx5kxjzOCD773nYesIomGuREREgpEvifaVQA1wYoN5JwFfW5ZV16hsHva4wA0Nw+5FiTFmqTHmlwcXGGOcwEjs5E8w8jm2xpjJxpjHvcmzAmOMAzgX+8F+AEu8nz1YPhp7XObDxlIMIh0WW7XbdlkCjDLGxDSYdxKH2qXa7ZFrMbZqt361BDjRu6/A+3M8wdNuhwELjDFpDeaNBQotyypqXNgYkwIMwk7MBJO2xKnF86cg4HOsfDgf6ulOwx4bepR3+jvwFc0/IyKYj7Gn4Xucgt1p+BgrY8xA4F3sh+qeY1lWsF24OA3f29V9wE0H3xhjQoEc7GS7iIiI9FCtPgzVsqwKY8xc4AljzE+we8LcARx8UFwGsN+yrErsk43PjTF3YT/AagLwU+zxgcF+sNWdxpjV2F8ebwOSscesCzptjO16YK4xZhGwDPu26RjgOe/qnsGO7QzgP8BvgO3Ah522QQGkg2OrdtsGxphUoNL75esTYBvwnDHmfuxkyPHAz73F1W7boI2xVbttg0axbc0rwCPAbGPME9j7lTjssaODwSfYvY2fM8bcjp1EfwR4EJrsX8FOStRi934MJm2JU2vnTz1dW2LV2jG7R7Msa1vD98aYEux91yZjTAiQiv0w+BqC+BjbxjgFtTbG6q/AAezhYuKNMQfvOCkPhqR7G2M1G3tf9QV2B6A7se/SmdvJ1RYREZFO5EuPdrATNMuA/wFPAb+1LOtl77J87LFXsSzrS+wHUl0GrAJuAaZYlvU/b9kHsU/QnsI+4cgGzrAsa3/7N6Xb8jW2K7GTOQ9h317eBzt2B7zLtwIXAldi96xIB84P8ifbd0hsUbttq2XYFzWwLMuF/VC7NOxhEKYBP/K2V7XbtvM5tqjdtlV9bFvjHZLnB9h3zCzH7s1+jmVZZf6rXuCwLKsWe/vrgC+BvwF/Av7iLVK/f/VKx06SBtX/dVvi5MP5U4/Wxli1dswOZn2xY3Ui6BjbgsPiJC2qj5UxJg6YBByFfQE/v8H0qy6rYeBo/P/3EnAz9kOuVwD9gbOC4YKEiIhIMHN4PJ6uroOIiIiIiIiIiIiISLfla492ERERERERERERERFphhLtIiIiIiIiIiIiIiLtoES7iIiIiIiIiIiIiEg7KNEuIiIiIiIiIiIiItIOSrSLiIiIiIiIiIiIiLSDEu0iIiIiIiIiIiIiIu2gRLuIiIiIiIiIiIiISDso0S4iIiIiIiIiIiIi0g7/D0t6FPqwhh9/AAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] diff --git a/pymc3/ode/ode.py b/pymc3/ode/ode.py index c90cd11200f..ead084efe99 100644 --- a/pymc3/ode/ode.py +++ b/pymc3/ode/ode.py @@ -2,7 +2,6 @@ from pymc3.ode.utils import augment_system, ODEGradop import scipy import theano -import theano.tensor as tt THEANO_FLAG = 'compute_test_value=ignore' @@ -43,11 +42,8 @@ def odefunc(y,t,p): __props__ = () def __init__(self, func, t0, times, n_states, n_odeparams): - if not callable(func): raise ValueError("Argument func must be callable.") - if np.any(np.diff(times)<0): - raise ValueError("The values in times must be monotonically increasing or monotonically decreasing; repeated values are allowed.") if n_states<1: raise ValueError('Argument n_states must be at least 1.') if n_odeparams<0: @@ -73,7 +69,6 @@ def __init__(self, func, t0, times, n_states, n_odeparams): self._cached_parameters = None def _make_sens_ic(self): - # The sensitivity matrix will always have consistent form. # If the first n_odeparams entries of the parameters vector in the simulate call # correspond to ode paramaters, then the first n_odeparams columns in @@ -93,7 +88,7 @@ def _make_sens_ic(self): return dydp def _system(self, Y, t, p): - """ + ''' This is the function that will be passed to odeint. Solves both ODE and sensitivities Args: @@ -102,14 +97,13 @@ def _system(self, Y, t, p): p (vector): parameters Returns: derivatives (vector): derivatives of state and gradient - """ + ''' dydt, ddt_dydp = self._augmented_func(Y[:self._n], t, p, Y[self._n:]) derivatives = np.concatenate([dydt, ddt_dydp]) return derivatives def _simulate(self, parameters): - # Initial condition comprised of state initial conditions and raveled # sensitivity matrix y0 = np.concatenate([ parameters[self.n_odeparams:] , self._sens_ic]) @@ -128,25 +122,21 @@ def _simulate(self, parameters): return y, sens def _cached_simulate(self, parameters): - if np.array_equal(np.array(parameters), self._cached_parameters): return self._cached_y, self._cached_sens else: return self._simulate(np.array(parameters)) def state(self, x): - y, sens = self._cached_simulate(np.array(x, dtype=np.float64)) self._cached_y, self._cached_sens, self._cached_parameters = y, sens, x return y.ravel() def numpy_vsp(self, x, g): - numpy_sens = self._cached_simulate(np.array(x, dtype=np.float64))[1].reshape((self.n_states * len(self.times), len(x))) return numpy_sens.T.dot(g) def make_node(self, odeparams, y0): - if len(odeparams)!=self.n_odeparams: raise ValueError('odeparams has too many or too few parameters. Expected {a} paramteres but got {b}'.format(a = self.n_odeparams, b = len(odeparams))) if len(y0)!=self.n_states: @@ -164,18 +154,14 @@ def make_node(self, odeparams, y0): return theano.Apply(self, [x], [x.type()]) def perform(self, node, inputs_storage, output_storage): - x = inputs_storage[0] out = output_storage[0] - # get the numerical solution of ODE states out[0] = self.state(x) def grad(self, inputs, output_grads): - x = inputs[0] g = output_grads[0] - # pass the VSP when asked for gradient grad_op = ODEGradop(self.numpy_vsp) grad_op_apply = grad_op(x, g) diff --git a/pymc3/tests/test_ode.py b/pymc3/tests/test_ode.py index 7e9a733e46b..481cd52f101 100644 --- a/pymc3/tests/test_ode.py +++ b/pymc3/tests/test_ode.py @@ -6,7 +6,6 @@ from scipy.stats import norm import pymc3 as pm import theano -import theano.tensor as tt import pytest @@ -290,7 +289,29 @@ def test_too_few_y0(self): with pytest.raises(ValueError): self.ode_model(odeparams=[1], y0=[]) + def test_func_callable(self): + with pytest.raises(ValueError): + DifferentialEquation(func = 1, + t0 = 0, + times = self.times, + n_states = 1, + n_odeparams = 1) + + def test_number_of_states(self): + with pytest.raises(ValueError): + DifferentialEquation(func = self.system, + t0 = 0, + times = self.times, + n_states = 0, + n_odeparams = 1) + def test_number_of_params(self): + with pytest.raises(ValueError): + DifferentialEquation(func = self.system, + t0 = 0, + times = self.times, + n_states = 1, + n_odeparams = 0) class TestDiffEqModel(object): From c980b142a8b2204ae00284bf76da221d3c5d0a32 Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Sat, 3 Aug 2019 15:55:53 -0400 Subject: [PATCH 40/45] add blurb about rehsaping and writing func arg --- ...ayesian_estimation_of_ode_parameters.ipynb | 50 ++++++++++++++++++- 1 file changed, 49 insertions(+), 1 deletion(-) diff --git a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb index b9802665ee9..003184f208f 100644 --- a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb +++ b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb @@ -131,7 +131,9 @@ "* `n_odeparams`: The dimension of $\\mathbf{p}$.\n", "* `n_states`: The dimension of $f(\\mathbf{y},t,\\mathbf{p})$\n", "\n", - "Once the model is specified, we can use it in our pyMC3 model by passing paramerters and inital conditions. \n", + "The argument `func` needs to be written as if `y` and `p` are vectors. So even when your model has one state and/or one parameter, you should explicitly write `y[0]` when referecni\n", + "\n", + "Once the model is specified, we can use it in our pyMC3 model by passing paramerters and inital conditions. `DifferentialEquation` returns a flattened solution, so you will need to reshape it to the same shape as your observed data in the model.\n", "\n", "Shown below is a model to estimate $\\gamma$ in the ODE above." ] @@ -569,6 +571,52 @@ "2. Britton, Nicholas F. Essential mathematical biology. Springer Science & Business Media, 2012.\n" ] }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "forward __str__ = [0.94622963 0.04246546 0.79407422 0.15079378 0.48844496 0.3349355\n", + " 0.22600529 0.40470808 0.10640563 0.33598276 0.05994418 0.23898303\n", + " 0.04039129 0.15983604 0.03113522 0.10402349 0.02631478 0.06679165]\n" + ] + } + ], + "source": [ + "theano.config.compute_test_value = \"ignore\"\n", + "\n", + "def system(y,t,p):\n", + " \n", + " ds = -p[0]*y[0]*y[1]\n", + " di = p[0]*y[0]*y[1] - y[1]\n", + " \n", + " return [ds,di]\n", + "\n", + "times = np.arange(0.5, 5, 0.5)\n", + "ode_model = DifferentialEquation(func = system,\n", + " times = times,\n", + " t0 = 0,\n", + " n_odeparams = 1,\n", + " n_states = 2)\n", + "\n", + "y,sens = ode_model._simulate([4,0.99, 0.01])\n", + "yobs = np.random.lognormal(np.log(y), 0.1)\n", + "\n", + "\n", + "\n", + "with pm.Model() as model:\n", + " \n", + " R = pm.Lognormal('R', pm.math.log(4),1)\n", + " \n", + " forward = ode_model(odeparams = [R], y0 = [0.99, 0.01])\n", + " \n", + " print_forward = theano.tensor.printing.Print('forward')(forward)\n" + ] + }, { "cell_type": "code", "execution_count": null, From 977726297d47e153804ee262ee933219763bcffc Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Sat, 3 Aug 2019 15:58:20 -0400 Subject: [PATCH 41/45] remove some cells from notebook --- .../notebooks/bayesian_estimation_of_ode_parameters.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb index 003184f208f..25eb7b7ee98 100644 --- a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb +++ b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb @@ -131,7 +131,7 @@ "* `n_odeparams`: The dimension of $\\mathbf{p}$.\n", "* `n_states`: The dimension of $f(\\mathbf{y},t,\\mathbf{p})$\n", "\n", - "The argument `func` needs to be written as if `y` and `p` are vectors. So even when your model has one state and/or one parameter, you should explicitly write `y[0]` when referecni\n", + "The argument `func` needs to be written as if `y` and `p` are vectors. So even when your model has one state and/or one parameter, you should explicitly write `y[0]` and/or `p[0]`.\n", "\n", "Once the model is specified, we can use it in our pyMC3 model by passing paramerters and inital conditions. `DifferentialEquation` returns a flattened solution, so you will need to reshape it to the same shape as your observed data in the model.\n", "\n", From ce30d3151f138a94e10304f215b6cac78e5c7688 Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Sat, 3 Aug 2019 17:44:50 -0400 Subject: [PATCH 42/45] t0 now optional argument in DiffEq constructor --- ...ayesian_estimation_of_ode_parameters.ipynb | 53 ------------------- pymc3/ode/ode.py | 2 +- 2 files changed, 1 insertion(+), 54 deletions(-) diff --git a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb index 25eb7b7ee98..bb92ae600b0 100644 --- a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb +++ b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb @@ -570,59 +570,6 @@ "1. Earn, D. J., et al. Mathematical epidemiology. Berlin: Springer, 2008.\n", "2. Britton, Nicholas F. Essential mathematical biology. Springer Science & Business Media, 2012.\n" ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "forward __str__ = [0.94622963 0.04246546 0.79407422 0.15079378 0.48844496 0.3349355\n", - " 0.22600529 0.40470808 0.10640563 0.33598276 0.05994418 0.23898303\n", - " 0.04039129 0.15983604 0.03113522 0.10402349 0.02631478 0.06679165]\n" - ] - } - ], - "source": [ - "theano.config.compute_test_value = \"ignore\"\n", - "\n", - "def system(y,t,p):\n", - " \n", - " ds = -p[0]*y[0]*y[1]\n", - " di = p[0]*y[0]*y[1] - y[1]\n", - " \n", - " return [ds,di]\n", - "\n", - "times = np.arange(0.5, 5, 0.5)\n", - "ode_model = DifferentialEquation(func = system,\n", - " times = times,\n", - " t0 = 0,\n", - " n_odeparams = 1,\n", - " n_states = 2)\n", - "\n", - "y,sens = ode_model._simulate([4,0.99, 0.01])\n", - "yobs = np.random.lognormal(np.log(y), 0.1)\n", - "\n", - "\n", - "\n", - "with pm.Model() as model:\n", - " \n", - " R = pm.Lognormal('R', pm.math.log(4),1)\n", - " \n", - " forward = ode_model(odeparams = [R], y0 = [0.99, 0.01])\n", - " \n", - " print_forward = theano.tensor.printing.Print('forward')(forward)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/pymc3/ode/ode.py b/pymc3/ode/ode.py index ead084efe99..c10b257794d 100644 --- a/pymc3/ode/ode.py +++ b/pymc3/ode/ode.py @@ -41,7 +41,7 @@ def odefunc(y,t,p): __props__ = () - def __init__(self, func, t0, times, n_states, n_odeparams): + def __init__(self, func, times, n_states, n_odeparams, t0=0): if not callable(func): raise ValueError("Argument func must be callable.") if n_states<1: From e51eaf430d9d2504618522a5bacc630903a072b9 Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Sat, 3 Aug 2019 18:13:03 -0400 Subject: [PATCH 43/45] Need import of theano.tensor --- pymc3/ode/ode.py | 1 + 1 file changed, 1 insertion(+) diff --git a/pymc3/ode/ode.py b/pymc3/ode/ode.py index c10b257794d..e77a1ae8798 100644 --- a/pymc3/ode/ode.py +++ b/pymc3/ode/ode.py @@ -2,6 +2,7 @@ from pymc3.ode.utils import augment_system, ODEGradop import scipy import theano +import theano.tensor as tt THEANO_FLAG = 'compute_test_value=ignore' From d5704b762675018d2326644a98e962156ec72bf3 Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Sun, 4 Aug 2019 17:26:48 -0400 Subject: [PATCH 44/45] typos in notebook. ODEGradOp now in __init__ --- ...ayesian_estimation_of_ode_parameters.ipynb | 63 ++-- pymc3/ode/ode.py | 338 +++++++++--------- pymc3/ode/utils.py | 160 ++++----- 3 files changed, 274 insertions(+), 287 deletions(-) diff --git a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb index bb92ae600b0..029cac19ce1 100644 --- a/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb +++ b/docs/source/notebooks/bayesian_estimation_of_ode_parameters.ipynb @@ -53,7 +53,7 @@ "\n", "# Doing Bayesian Inference With Differential Equations\n", "\n", - "PyMC3 uses Hamiltonian Monte Carlo (HMC) to obtain samples from the posterior distribution. HMC requires derivatives of the ODE's solution with respect to the paramteres $p$. The `ode` submodual automatically computes appropriate derivatives so you don't have to. All you have to do is \n", + "PyMC3 uses Hamiltonian Monte Carlo (HMC) to obtain samples from the posterior distribution. HMC requires derivatives of the ODE's solution with respect to the parameters $p$. The `ode` submodual automatically computes appropriate derivatives so you don't have to. All you have to do is \n", "\n", "* Write the differential equation as a python function\n", "* Write the model in PyMC3\n", @@ -67,9 +67,9 @@ "\n", "$$ y' = mg - \\gamma y $$\n", "\n", - "The force the object experiences in the downwards direction is $mg$, while the forece the object experiences in the opposite direction (due to air resistence) is proportional to how fast the object is presently moving. Let's assume the object starts from rest (that is, that the object's inital velocity is 0). This may or may not be the case. To showcase how to do inference on intial conditions, I will first assume the object starts from rest, and then relax that assumption later.\n", + "The force the object experiences in the downwards direction is $mg$, while the forece the object experiences in the opposite direction (due to air resistance) is proportional to how fast the object is presently moving. Let's assume the object starts from rest (that is, that the object's inital velocity is 0). This may or may not be the case. To showcase how to do inference on intial conditions, I will first assume the object starts from rest, and then relax that assumption later.\n", "\n", - "Data on this object's speed as a function of time is shown below. The data may be noisy because of our measurement tools, or because the object is an irregular shape, thus leading to times furing freefall when the object is more/less aerodynamic. Let's use this data to estimate the proportionality constant for air restistance.\n", + "Data on this object's speed as a function of time is shown below. The data may be noisy because of our measurement tools, or because the object is an irregular shape, thus leading to times during freefall when the object is more/less aerodynamic. Let's use this data to estimate the proportionality constant for air restistance.\n", "\n", "\n", "\n", @@ -125,11 +125,11 @@ "source": [ "To specify and ordinary differential equation with pyMC3, use the `DifferentialEquation` class. This class takes as arguments:\n", "\n", - "* `func`: A function specifying the differential equation (i.e. $f(\\mathbf{y},t,\\mathbf{p})$)\n", - "* `t0`: The time for which the initial condition belongs\n", - "* `times`: A monotonically increasing or decreasing array of times at which data was observed.\n", + "* `func`: A function specifying the differential equation (i.e. $f(\\mathbf{y},t,\\mathbf{p})$).\n", + "* `t0`: The time for which the initial condition belongs.\n", + "* `times`: An array of times at which data was observed.\n", "* `n_odeparams`: The dimension of $\\mathbf{p}$.\n", - "* `n_states`: The dimension of $f(\\mathbf{y},t,\\mathbf{p})$\n", + "* `n_states`: The dimension of $f(\\mathbf{y},t,\\mathbf{p})$.\n", "\n", "The argument `func` needs to be written as if `y` and `p` are vectors. So even when your model has one state and/or one parameter, you should explicitly write `y[0]` and/or `p[0]`.\n", "\n", @@ -141,7 +141,9 @@ { "cell_type": "code", "execution_count": 3, - "metadata": {}, + "metadata": { + "scrolled": false + }, "outputs": [ { "name": "stderr", @@ -151,8 +153,8 @@ "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [gamma, sigma]\n", - "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [02:38<00:00, 37.85draws/s]\n", - "100%|██████████| 4000/4000 [00:49<00:00, 80.09it/s]\n" + "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [02:56<00:00, 19.53draws/s]\n", + "100%|██████████| 4000/4000 [00:50<00:00, 79.45it/s] \n" ] } ], @@ -228,8 +230,8 @@ "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [g, gamma, sigma]\n", - "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [09:09<00:00, 5.60draws/s]\n", - "100%|██████████| 4000/4000 [00:38<00:00, 102.66it/s]\n" + "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [08:45<00:00, 5.47draws/s]\n", + "100%|██████████| 4000/4000 [00:40<00:00, 98.73it/s] \n" ] } ], @@ -261,19 +263,6 @@ "execution_count": 6, "metadata": {}, "outputs": [ - { - "data": { - "text/plain": [ - "array([,\n", - " ,\n", - " ],\n", - " dtype=object)" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, { "data": { "image/png": "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\n", @@ -297,7 +286,7 @@ "source": [ "The uncertainty in the acceleration due to gravity has increased our uncertainty in the prportionality constant.\n", "\n", - "Finally, we can do inference on the initial condition. If this object was brought to it's inital height by an airplane, then turbulent air might have made the airplane move up or down, thereby changing the inital velocioty of the object. \n", + "Finally, we can do inference on the initial condition. If this object was brought to it's initial height by an airplane, then turbulent air might have made the airplane move up or down, thereby changing the inital velocity of the object. \n", "\n", "Doing inference on the inital condition is as easy as specifying a prior for the inital condition, and then passing the inital condition to `ode_model`." ] @@ -319,8 +308,8 @@ " warnings.warn(warning_msg, ODEintWarning)\n", "/Users/demetri/anaconda3/envs/gsoc/lib/python3.6/site-packages/scipy/integrate/odepack.py:247: ODEintWarning: Illegal input detected (internal error). Run with full_output = 1 to get quantitative information.\n", " warnings.warn(warning_msg, ODEintWarning)\n", - "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [11:47<00:00, 3.75draws/s] \n", - "100%|██████████| 4000/4000 [00:39<00:00, 101.20it/s]\n" + "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [11:47<00:00, 3.85draws/s] \n", + "100%|██████████| 4000/4000 [00:44<00:00, 89.18it/s] \n" ] } ], @@ -384,7 +373,7 @@ "\n", "The example of an object in free fall might not be the most appropriate since that differential equation can be solved exactly. Thus, `DifferentialEquation` is not needed to solve that particular problem. There are, however, many examples of differential equations which cannot be solved exactly. Inference for these models is where `DifferentialEquation` truly shines.\n", "\n", - "Consider the SIR model of infection. This model describes the temporal dynamics of a disease spreading through a homogenously mixed, closed population. Members of the population are placed into one of three cateories: Susceptible, Infective, or Recovered. The differential equations are...\n", + "Consider the SIR model of infection. This model describes the temporal dynamics of a disease spreading through a homogenously mixed closed population. Members of the population are placed into one of three cateories: Susceptible, Infective, or Recovered. The differential equations are...\n", "\n", "\n", "$$ \\dfrac{dS}{dt} = - \\beta SI \\quad S(0) = S_0 $$\n", @@ -396,9 +385,9 @@ "If we knew $S(t)$ and $I(t)$, then we could determine $R(t)$, so we can peel off the differential equation for $R(t)$ and work only with the first two. \n", "\n", "\n", - "In the SIR model, it is straight-forward to see that $\\beta, \\gamma$ and $\\beta/2, \\gamma/2$ will produce the same qualitative dynamics but on much different time scales. To study the *quality* of the dynamics, regardless of time scale, applied mathematicians will *non-dimensionalize* differential equations. Non-dimensionalization is the process of introducing scaleless variables into the differential equation to understand the system's dynamics under families of paramterizations.\n", + "In the SIR model, it is straight-forward to see that $\\beta, \\gamma$ and $\\beta/2, \\gamma/2$ will produce the same qualitative dynamics but on much different time scales. To study the *quality* of the dynamics, regardless of time scale, applied mathematicians will *non-dimensionalize* differential equations. Non-dimensionalization is the process of introducing scaleless variables into the differential equation to understand the system's dynamics under families of equivalent paramterizations.\n", "\n", - "To non-dimensionalize this system, let's scale time by $1/\\lambda$, the rate of recovery (we do this because people stay infected for an average of $1/\\lambda$ units of time. It is a straight forward argument to show this. For more, see [1]). Let $t = \\tau/\\lambda$, where $\\tau$ is a unitless variable. Then...\n", + "To non-dimensionalize this system, let's scale time by $1/\\lambda$ (we do this because people stay infected for an average of $1/\\lambda$ units of time. It is a straight forward argument to show this. For more, see [1]). Let $t = \\tau/\\lambda$, where $\\tau$ is a unitless variable. Then...\n", "\n", "\n", "$$ \\dfrac{dS}{d\\tau} = \\dfrac{dt}{d\\tau} \\dfrac{dS}{dt} = \\dfrac{1}{\\lambda}\\dfrac{dS}{dt} = -\\dfrac{\\beta}{\\lambda}SI$$\n", @@ -422,7 +411,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 9, @@ -478,8 +467,8 @@ "Initializing NUTS using jitter+adapt_diag...\n", "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [lambda, R0, sigma]\n", - "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [26:49<00:00, 1.84draws/s] \n", - "100%|██████████| 4000/4000 [02:21<00:00, 28.20it/s]\n" + "Sampling 2 chains, 0 divergences: 100%|██████████| 6000/6000 [27:00<00:00, 1.99draws/s] \n", + "100%|██████████| 4000/4000 [02:12<00:00, 28.99it/s]\n" ] } ], @@ -512,18 +501,18 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "data = az.from_pymc3(trace = trace,\n", " prior = prior,\n", - " posterior_pypredictive = posterior_predictive)" + " posterior_predictive = posterior_predictive)" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": {}, "outputs": [ { diff --git a/pymc3/ode/ode.py b/pymc3/ode/ode.py index e77a1ae8798..236891680e3 100644 --- a/pymc3/ode/ode.py +++ b/pymc3/ode/ode.py @@ -1,170 +1,170 @@ -import numpy as np -from pymc3.ode.utils import augment_system, ODEGradop -import scipy -import theano -import theano.tensor as tt -THEANO_FLAG = 'compute_test_value=ignore' - - -class DifferentialEquation(theano.Op): - - ''' - Specify an ordinary differential equation - - .. math:: - \dfrac{dy}{dt} = f(y,t,p) \quad y(t_0) = y_0 - - Parameters - ---------- - - func : callable - Function specifying the differential equation - t0 : float - Time corresponding to the initial condition - times : array - Array of times at which to evaluate the solution of the differential equation. - n_states : int - Dimension of the differential equation. For scalar differential equations, n_states =1. - For vector valued differential equations, n_states = number of differential equations iun the system. - n_odeparams : int - Number of parameters in the differential equation. - - .. code-block:: python - - def odefunc(y,t,p): - #Logistic differential equation - return p[0]*y[0]*(1-y[0]) - - times = np.arange(0.5, 5, 0.5) - - ode_model = DifferentialEquation(func = odefunc, t0 = 0, times = times, n_states = 1, n_odeparams = 1) - ''' - - __props__ = () - - def __init__(self, func, times, n_states, n_odeparams, t0=0): - if not callable(func): - raise ValueError("Argument func must be callable.") - if n_states<1: - raise ValueError('Argument n_states must be at least 1.') - if n_odeparams<0: - raise ValueError('Argument n_states must be non-negative.') - - #Public - self.func = func - self.t0 = t0 - self.times = times - self.n_states = n_states - self.n_odeparams = n_odeparams - - #Private - self._n = n_states - self._m = n_odeparams + n_states - - self._augmented_times = np.insert(times, t0, 0) - self._augmented_func = augment_system(func, self._n, self._m) - self._sens_ic = self._make_sens_ic() - - self._cached_y = None - self._cached_sens = None - self._cached_parameters = None - - def _make_sens_ic(self): - # The sensitivity matrix will always have consistent form. - # If the first n_odeparams entries of the parameters vector in the simulate call - # correspond to ode paramaters, then the first n_odeparams columns in - # the sensitivity matrix will be 0 - sens_matrix = np.zeros((self._n, self._m)) - - # If the last n_states entrues of the paramters vector in the simulate call - # correspond to initial conditions of the system, - # then the last n_states columns of the sensitivity matrix should form - # an identity matrix - sens_matrix[:, -self.n_states:] = np.eye(self.n_states) - - # We need the sensitivity matrix to be a vector (see augmented_function) - # Ravel and return - dydp = sens_matrix.ravel() - - return dydp - - def _system(self, Y, t, p): - ''' - This is the function that will be passed to odeint. - Solves both ODE and sensitivities - Args: - Y (vector): current state and current gradient state - t (scalar): current time - p (vector): parameters - Returns: - derivatives (vector): derivatives of state and gradient - ''' - - dydt, ddt_dydp = self._augmented_func(Y[:self._n], t, p, Y[self._n:]) - derivatives = np.concatenate([dydt, ddt_dydp]) - return derivatives - - def _simulate(self, parameters): - # Initial condition comprised of state initial conditions and raveled - # sensitivity matrix - y0 = np.concatenate([ parameters[self.n_odeparams:] , self._sens_ic]) - - # perform the integration - sol = scipy.integrate.odeint(func=self._system, - y0=y0, - t=self._augmented_times, - args=tuple([parameters])) - # The solution - y = sol[1:, :self.n_states] - - # The sensitivities, reshaped to be a sequence of matrices - sens = sol[1:, self.n_states:].reshape(len(self.times), self._n, self._m) - - return y, sens - - def _cached_simulate(self, parameters): - if np.array_equal(np.array(parameters), self._cached_parameters): - return self._cached_y, self._cached_sens - else: - return self._simulate(np.array(parameters)) - - def state(self, x): - y, sens = self._cached_simulate(np.array(x, dtype=np.float64)) - self._cached_y, self._cached_sens, self._cached_parameters = y, sens, x - return y.ravel() - - def numpy_vsp(self, x, g): - numpy_sens = self._cached_simulate(np.array(x, dtype=np.float64))[1].reshape((self.n_states * len(self.times), len(x))) - return numpy_sens.T.dot(g) - - def make_node(self, odeparams, y0): - if len(odeparams)!=self.n_odeparams: - raise ValueError('odeparams has too many or too few parameters. Expected {a} paramteres but got {b}'.format(a = self.n_odeparams, b = len(odeparams))) - if len(y0)!=self.n_states: - raise ValueError('y0 has too many or too few parameters. Expected {a} paramteres but got {b}'.format(a = self.n_states, b = len(y0))) - - if np.ndim(odeparams) > 1: - odeparams = np.ravel(odeparams) - if np.ndim(y0) > 1: - y0 = np.ravel(y0) - - odeparams = tt.as_tensor_variable(odeparams) - y0 = tt.as_tensor_variable(y0) - x = tt.concatenate([odeparams, y0]) - - return theano.Apply(self, [x], [x.type()]) - - def perform(self, node, inputs_storage, output_storage): - x = inputs_storage[0] - out = output_storage[0] - # get the numerical solution of ODE states - out[0] = self.state(x) - - def grad(self, inputs, output_grads): - x = inputs[0] - g = output_grads[0] - # pass the VSP when asked for gradient - grad_op = ODEGradop(self.numpy_vsp) - grad_op_apply = grad_op(x, g) - +import numpy as np +from pymc3.ode.utils import augment_system, ODEGradop +import scipy +import theano +import theano.tensor as tt +THEANO_FLAG = 'compute_test_value=ignore' + + +class DifferentialEquation(theano.Op): + + ''' + Specify an ordinary differential equation + + .. math:: + \dfrac{dy}{dt} = f(y,t,p) \quad y(t_0) = y_0 + + Parameters + ---------- + + func : callable + Function specifying the differential equation + t0 : float + Time corresponding to the initial condition + times : array + Array of times at which to evaluate the solution of the differential equation. + n_states : int + Dimension of the differential equation. For scalar differential equations, n_states =1. + For vector valued differential equations, n_states = number of differential equations iun the system. + n_odeparams : int + Number of parameters in the differential equation. + + .. code-block:: python + + def odefunc(y,t,p): + #Logistic differential equation + return p[0]*y[0]*(1-y[0]) + + times = np.arange(0.5, 5, 0.5) + + ode_model = DifferentialEquation(func = odefunc, t0 = 0, times = times, n_states = 1, n_odeparams = 1) + ''' + + __props__ = () + + def __init__(self, func, times, n_states, n_odeparams, t0=0): + if not callable(func): + raise ValueError("Argument func must be callable.") + if n_states<1: + raise ValueError('Argument n_states must be at least 1.') + if n_odeparams<0: + raise ValueError('Argument n_states must be non-negative.') + + #Public + self.func = func + self.t0 = t0 + self.times = times + self.n_states = n_states + self.n_odeparams = n_odeparams + + #Private + self._n = n_states + self._m = n_odeparams + n_states + + self._augmented_times = np.insert(times, t0, 0) + self._augmented_func = augment_system(func, self._n, self._m) + self._sens_ic = self._make_sens_ic() + + self._cached_y = None + self._cached_sens = None + self._cached_parameters = None + + self._grad_op = ODEGradop(self.numpy_vsp) + + + def _make_sens_ic(self): + # The sensitivity matrix will always have consistent form. + # If the first n_odeparams entries of the parameters vector in the simulate call + # correspond to ode paramaters, then the first n_odeparams columns in + # the sensitivity matrix will be 0 + sens_matrix = np.zeros((self._n, self._m)) + + # If the last n_states entrues of the paramters vector in the simulate call + # correspond to initial conditions of the system, + # then the last n_states columns of the sensitivity matrix should form + # an identity matrix + sens_matrix[:, -self.n_states:] = np.eye(self.n_states) + + # We need the sensitivity matrix to be a vector (see augmented_function) + # Ravel and return + dydp = sens_matrix.ravel() + + return dydp + + def _system(self, Y, t, p): + ''' + This is the function that will be passed to odeint. + Solves both ODE and sensitivities + Args: + Y (vector): current state and current gradient state + t (scalar): current time + p (vector): parameters + Returns: + derivatives (vector): derivatives of state and gradient + ''' + + dydt, ddt_dydp = self._augmented_func(Y[:self._n], t, p, Y[self._n:]) + derivatives = np.concatenate([dydt, ddt_dydp]) + return derivatives + + def _simulate(self, parameters): + # Initial condition comprised of state initial conditions and raveled + # sensitivity matrix + y0 = np.concatenate([ parameters[self.n_odeparams:] , self._sens_ic]) + + # perform the integration + sol = scipy.integrate.odeint(func=self._system, + y0=y0, + t=self._augmented_times, + args=tuple([parameters])) + # The solution + y = sol[1:, :self.n_states] + + # The sensitivities, reshaped to be a sequence of matrices + sens = sol[1:, self.n_states:].reshape(len(self.times), self._n, self._m) + + return y, sens + + def _cached_simulate(self, parameters): + if np.array_equal(np.array(parameters), self._cached_parameters): + return self._cached_y, self._cached_sens + else: + return self._simulate(np.array(parameters)) + + def state(self, x): + y, sens = self._cached_simulate(np.array(x, dtype=np.float64)) + self._cached_y, self._cached_sens, self._cached_parameters = y, sens, x + return y.ravel() + + def numpy_vsp(self, x, g): + numpy_sens = self._cached_simulate(np.array(x, dtype=np.float64))[1].reshape((self.n_states * len(self.times), len(x))) + return numpy_sens.T.dot(g) + + def make_node(self, odeparams, y0): + if len(odeparams)!=self.n_odeparams: + raise ValueError('odeparams has too many or too few parameters. Expected {a} paramteres but got {b}'.format(a = self.n_odeparams, b = len(odeparams))) + if len(y0)!=self.n_states: + raise ValueError('y0 has too many or too few parameters. Expected {a} paramteres but got {b}'.format(a = self.n_states, b = len(y0))) + + if np.ndim(odeparams) > 1: + odeparams = np.ravel(odeparams) + if np.ndim(y0) > 1: + y0 = np.ravel(y0) + + odeparams = tt.as_tensor_variable(odeparams) + y0 = tt.as_tensor_variable(y0) + x = tt.concatenate([odeparams, y0]) + return theano.Apply(self, [x], [x.type()]) + + def perform(self, node, inputs_storage, output_storage): + x = inputs_storage[0] + out = output_storage[0] + # get the numerical solution of ODE states + out[0] = self.state(x) + + def grad(self, inputs, output_grads): + x = inputs[0] + g = output_grads[0] + # pass the VSP when asked for gradient + grad_op_apply = self._grad_op(x, g) return [grad_op_apply] \ No newline at end of file diff --git a/pymc3/ode/utils.py b/pymc3/ode/utils.py index 15d3767874a..440e769e650 100644 --- a/pymc3/ode/utils.py +++ b/pymc3/ode/utils.py @@ -1,81 +1,79 @@ -import theano -import theano.tensor as tt - - -def augment_system(ode_func, n, m): - '''Function to create augmented system. - - Take a function which specifies a set of differential equations and return - a compiled function which allows for computation of gradients of the - differential equation's solition with repsect to the parameters. - - Args: - ode_func (function): Differential equation. Returns array-like - n: Number of rows of the sensitivity matrix - m: Number of columns of the sensitivity matrix - - Returns: - system (function): Augemted system of differential equations. - - ''' - - # Present state of the system - t_y = tt.vector('y', dtype=theano.config.floatX) - - # Parameter(s). Should be vector to allow for generaliztion to multiparameter - # systems of ODEs - t_p = tt.vector('p', dtype=theano.config.floatX) - - # Time. Allow for non-automonous systems of ODEs to be analyzed - t_t = tt.scalar('t', dtype=theano.config.floatX) - - # Present state of the gradients: - # Will always be 0 unless the parameter is the inital condition - # Entry i,j is partial of y[i] wrt to p[j] - dydp_vec = tt.vector('dydp', dtype=theano.config.floatX) - - dydp = dydp_vec.reshape((n, m)) - - # Stack the results of the ode_func - # TODO: Does this behave the same of ODE is scalar? - f_tensor = tt.stack(ode_func(t_y, t_t, t_p)) - - # Now compute gradients - J = tt.jacobian(f_tensor, t_y) - - Jdfdy = tt.dot(J, dydp) - - grad_f = tt.jacobian(f_tensor, t_p) - - # This is the time derivative of dydp - ddt_dydp = (Jdfdy + grad_f).flatten() - - system = theano.function( - inputs=[t_y, t_t, t_p, dydp_vec], - outputs=[f_tensor, ddt_dydp], - on_unused_input='ignore') - - return system - - - -class ODEGradop(theano.Op): - - def __init__(self, numpy_vsp): - - self._numpy_vsp = numpy_vsp - - def make_node(self, x, g): - - x = theano.tensor.as_tensor_variable(x) - g = theano.tensor.as_tensor_variable(g) - node = theano.Apply(self, [x, g], [g.type()]) - return node - - def perform(self, node, inputs_storage, output_storage): - - x = inputs_storage[0] - - g = inputs_storage[1] - out = output_storage[0] - out[0] = self._numpy_vsp(x, g) # get the numerical VSP +import theano +import theano.tensor as tt + + +def augment_system(ode_func, n, m): + '''Function to create augmented system. + + Take a function which specifies a set of differential equations and return + a compiled function which allows for computation of gradients of the + differential equation's solition with repsect to the parameters. + + Args: + ode_func (function): Differential equation. Returns array-like + n: Number of rows of the sensitivity matrix + m: Number of columns of the sensitivity matrix + + Returns: + system (function): Augemted system of differential equations. + + ''' + + # Present state of the system + t_y = tt.vector('y', dtype=theano.config.floatX) + + # Parameter(s). Should be vector to allow for generaliztion to multiparameter + # systems of ODEs + t_p = tt.vector('p', dtype=theano.config.floatX) + + # Time. Allow for non-automonous systems of ODEs to be analyzed + t_t = tt.scalar('t', dtype=theano.config.floatX) + + # Present state of the gradients: + # Will always be 0 unless the parameter is the inital condition + # Entry i,j is partial of y[i] wrt to p[j] + dydp_vec = tt.vector('dydp', dtype=theano.config.floatX) + + dydp = dydp_vec.reshape((n, m)) + + # Stack the results of the ode_func + # TODO: Does this behave the same of ODE is scalar? + f_tensor = tt.stack(ode_func(t_y, t_t, t_p)) + + # Now compute gradients + J = tt.jacobian(f_tensor, t_y) + + Jdfdy = tt.dot(J, dydp) + + grad_f = tt.jacobian(f_tensor, t_p) + + # This is the time derivative of dydp + ddt_dydp = (Jdfdy + grad_f).flatten() + + system = theano.function( + inputs=[t_y, t_t, t_p, dydp_vec], + outputs=[f_tensor, ddt_dydp], + on_unused_input='ignore') + + return system + + + +class ODEGradop(theano.Op): + + def __init__(self, numpy_vsp): + self._numpy_vsp = numpy_vsp + + def make_node(self, x, g): + + x = theano.tensor.as_tensor_variable(x) + g = theano.tensor.as_tensor_variable(g) + node = theano.Apply(self, [x, g], [g.type()]) + return node + + def perform(self, node, inputs_storage, output_storage): + x = inputs_storage[0] + g = inputs_storage[1] + out = output_storage[0] + out[0] = self._numpy_vsp(x, g) # get the numerical VSP + \ No newline at end of file From 5041c34427ae7261481ae2132230402d601e8979 Mon Sep 17 00:00:00 2001 From: Demetri Pananos Date: Wed, 14 Aug 2019 18:59:00 -0400 Subject: [PATCH 45/45] rename parameters, hopefully passes on float32 --- pymc3/ode/ode.py | 19 +++--- pymc3/tests/test_ode.py | 136 +++++++++++++--------------------------- 2 files changed, 54 insertions(+), 101 deletions(-) diff --git a/pymc3/ode/ode.py b/pymc3/ode/ode.py index 236891680e3..8e07b875dc2 100644 --- a/pymc3/ode/ode.py +++ b/pymc3/ode/ode.py @@ -131,13 +131,14 @@ def _cached_simulate(self, parameters): else: return self._simulate(np.array(parameters)) - def state(self, x): - y, sens = self._cached_simulate(np.array(x, dtype=np.float64)) - self._cached_y, self._cached_sens, self._cached_parameters = y, sens, x + def state(self, parameters): + y, sens = self._cached_simulate(np.array(parameters)) + self._cached_y, self._cached_sens, self._cached_parameters = y, sens, parameters return y.ravel() - def numpy_vsp(self, x, g): - numpy_sens = self._cached_simulate(np.array(x, dtype=np.float64))[1].reshape((self.n_states * len(self.times), len(x))) + def numpy_vsp(self, parameters, g): + _,sens = self._cached_simulate(np.array(parameters)) + numpy_sens = sens.reshape((self.n_states * len(self.times), len(parameters))) return numpy_sens.T.dot(g) def make_node(self, odeparams, y0): @@ -153,14 +154,14 @@ def make_node(self, odeparams, y0): odeparams = tt.as_tensor_variable(odeparams) y0 = tt.as_tensor_variable(y0) - x = tt.concatenate([odeparams, y0]) - return theano.Apply(self, [x], [x.type()]) + parameters = tt.concatenate([odeparams, y0]) + return theano.Apply(self, [parameters], [parameters.type()]) def perform(self, node, inputs_storage, output_storage): - x = inputs_storage[0] + parameters = inputs_storage[0] out = output_storage[0] # get the numerical solution of ODE states - out[0] = self.state(x) + out[0] = self.state(parameters) def grad(self, inputs, output_grads): x = inputs[0] diff --git a/pymc3/tests/test_ode.py b/pymc3/tests/test_ode.py index 481cd52f101..702023ad288 100644 --- a/pymc3/tests/test_ode.py +++ b/pymc3/tests/test_ode.py @@ -38,8 +38,7 @@ def augmented_system(Y, t, p): # Treat y0 like a parameter and solve analytically. Then differentiate. # I used CAS to get these derivatives y0_sensitivity = np.exp(-a * t) - a_sensitivity = -(np.exp(t * (a - 1)) - 1 + (a - 1) * - (y0 * a - y0 - 1) * t) * np.exp(-a * t) / (a - 1)**2 + a_sensitivity = -(np.exp(t * (a - 1)) - 1 + (a - 1) * (y0 * a - y0 - 1) * t) * np.exp(-a * t) / (a - 1)**2 sensitivity = np.c_[a_sensitivity, y0_sensitivity] @@ -49,8 +48,7 @@ def augmented_system(Y, t, p): args=tuple([p])) simulated_sensitivity = integrated_solutions[:, 1:] - np.testing.assert_allclose( - sensitivity, simulated_sensitivity, rtol=1e-5) + np.testing.assert_allclose(sensitivity, simulated_sensitivity, rtol=1e-5) @@ -105,8 +103,7 @@ def ode_func_1(y, t, p): # Sensitivity initial condition for this model should be 1 by 2 model1_sens_ic = np.array([0, 1]) - np.testing.assert_array_equal( - model1_sens_ic, model1._make_sens_ic()) + np.testing.assert_array_equal(model1_sens_ic, model1._make_sens_ic()) def test_sens_ic_scalar_2_param(self): with theano.configparser.change_flags(compute_test_value='off'): @@ -124,8 +121,7 @@ def ode_func_2(y, t, p): model2_sens_ic = np.array([0, 0, 1]) - np.testing.assert_array_equal( - model2_sens_ic, model2._make_sens_ic()) + np.testing.assert_array_equal(model2_sens_ic, model2._make_sens_ic()) def test_sens_ic_vector_1_param(self): with theano.configparser.change_flags(compute_test_value='off'): @@ -146,8 +142,7 @@ def ode_func_3(y, t, p): model3_sens_ic = np.array([0, 1, 0, 0, 0, 1]) - np.testing.assert_array_equal( - model3_sens_ic, model3._make_sens_ic()) + np.testing.assert_array_equal(model3_sens_ic, model3._make_sens_ic()) def test_sens_ic_vector_2_param(self): with theano.configparser.change_flags(compute_test_value='off'): @@ -168,8 +163,7 @@ def ode_func_4(y, t, p): model4_sens_ic = np.array([0, 0, 1, 0, 0, 0, 0, 1]) - np.testing.assert_array_equal( - model4_sens_ic, model4._make_sens_ic()) + np.testing.assert_array_equal(model4_sens_ic, model4._make_sens_ic()) def test_sens_ic_vector_3_params(self): with theano.configparser.change_flags(compute_test_value='off'): @@ -196,9 +190,7 @@ def ode_func_5(y, t, p): [0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 1]]) - np.testing.assert_array_equal( - np.ravel(model5_sens_ic), - model5._make_sens_ic()) + np.testing.assert_array_equal(np.ravel(model5_sens_ic), model5._make_sens_ic()) @@ -241,23 +233,15 @@ def system_1(y, t, p): integrated_solution, *_ = ode_model._simulate([alpha, y0]) - manual_logp = norm.logpdf( - x=np.ravel(yobs), - loc=np.ravel(integrated_solution), - scale=1).sum() + manual_logp = norm.logpdf(x=np.ravel(yobs), loc=np.ravel(integrated_solution), scale=1).sum() with pm.Model() as model_1: - forward = ode_model(odeparams=[alpha], y0=[y0]).reshape(yobs.shape) - y = pm.Normal('y', mu=forward, sd=1, observed=yobs) pymc3_logp = model_1.logp() - np.testing.assert_allclose(manual_logp, pymc3_logp) - - class TestErrors(object): '''Test running model for a scalar ODE with 1 parameter''' @@ -266,12 +250,11 @@ def system(y, t, p): times = np.arange(0, 9) - ode_model = DifferentialEquation( - func=system, - t0=0, - times=times, - n_states=1, - n_odeparams=1) + ode_model = DifferentialEquation(func=system, + t0=0, + times=times, + n_states=1, + n_odeparams=1) def test_too_many_params(self): with pytest.raises(ValueError): @@ -341,27 +324,20 @@ def system(y, t, p): 0.1]).reshape(-1, 1) - ode_model = DifferentialEquation( - func=system, - t0=0, - times=times, - n_states=1, - n_odeparams=1) + ode_model = DifferentialEquation(func=system, + t0=0, + times=times, + n_states=1, + n_odeparams=1) with pm.Model() as model: alpha = pm.HalfCauchy('alpha', 1) y0 = pm.Lognormal('y0', 0, 1) sigma = pm.HalfCauchy('sigma', 1) - forward = ode_model( - odeparams=[alpha], - y0=[y0]).reshape( - yobs.shape) - - y = pm.Lognormal('y', mu=pm.math.log( - forward), sd=sigma, observed=yobs) - - trace = pm.sample(100, tune=0) + forward = ode_model(odeparams=[alpha], y0=[y0]).reshape(yobs.shape) + y = pm.Lognormal('y', mu=pm.math.log(forward), sd=sigma, observed=yobs) + trace = pm.sample(100, tune=0, chains = 1) assert trace['alpha'].size > 0 assert trace['y0'].size > 0 @@ -393,28 +369,19 @@ def system(y, t, p): 0.10]).reshape(-1, 1) - ode_model = DifferentialEquation( - func=system, - t0=0, - times=times, - n_states=1, - n_odeparams=2) + ode_model = DifferentialEquation(func=system, + t0=0, + times=times, + n_states=1, + n_odeparams=2) with pm.Model() as model: - alpha = pm.HalfCauchy('alpha', 1) beta = pm.HalfCauchy('beta', 1) y0 = pm.Lognormal('y0', 0, 1) sigma = pm.HalfCauchy('sigma', 1) - forward = ode_model( - odeparams=[ - alpha, - beta], - y0=[y0]).reshape( - yobs.shape) - - y = pm.Lognormal('y', mu=pm.math.log( - forward), sd=sigma, observed=yobs) + forward = ode_model(odeparams=[alpha,beta],y0=[y0]).reshape(yobs.shape) + y = pm.Lognormal('y', mu=pm.math.log(forward), sd=sigma, observed=yobs) trace = pm.sample(100, tune=0) @@ -447,26 +414,19 @@ def system(y, t, p): [0.02, 0.01], [0.02, 0.01]]) - ode_model = DifferentialEquation( - func=system, - t0=0, - times=times, - n_states=2, - n_odeparams=1) + ode_model = DifferentialEquation(func=system, + t0=0, + times=times, + n_states=2, + n_odeparams=1) with pm.Model() as model: - R = pm.Lognormal('R', 1, 5) sigma = pm.HalfCauchy('sigma', 1, shape=2) - forward = ode_model( - odeparams=[R], y0=[ - 0.99, 0.01]).reshape( - yobs.shape) - - y = pm.Lognormal('y', mu=pm.math.log( - forward), sd=sigma, observed=yobs) + forward = ode_model(odeparams=[R], y0=[0.99, 0.01]).reshape(yobs.shape) + y = pm.Lognormal('y', mu=pm.math.log(forward), sd=sigma, observed=yobs) - trace = pm.sample(100, tune=0) + trace = pm.sample(100, tune=0, chains = 1) assert trace['R'].size > 0 assert trace['sigma'].size > 0 @@ -495,28 +455,20 @@ def system(y, t, p): [0.02, 0.01], [0.02, 0.01]]) - ode_model = DifferentialEquation( - func=system, - t0=0, - times=times, - n_states=2, - n_odeparams=2) + ode_model = DifferentialEquation(func=system, + t0=0, + times=times, + n_states=2, + n_odeparams=2) with pm.Model() as model: - beta = pm.HalfCauchy('beta', 1) gamma = pm.HalfCauchy('gamma', 1) sigma = pm.HalfCauchy('sigma', 1, shape=2) - forward = ode_model( - odeparams=[ - beta, gamma], y0=[ - 0.99, 0.01]).reshape( - yobs.shape) + forward = ode_model(odeparams=[beta, gamma], y0=[0.99, 0.01]).reshape(yobs.shape) + y = pm.Lognormal('y', mu=pm.math.log(forward), sd=sigma, observed=yobs) - y = pm.Lognormal('y', mu=pm.math.log( - forward), sd=sigma, observed=yobs) - - trace = pm.sample(100, tune=0) + trace = pm.sample(100, tune=0, chains = 1) assert trace['beta'].size > 0 assert trace['gamma'].size > 0