From 881cd840c42549895fb718cc531d87f3a484a7f5 Mon Sep 17 00:00:00 2001 From: andyElking Date: Wed, 26 Jun 2024 12:41:06 +0100 Subject: [PATCH 01/15] Langevin PR --- diffrax/__init__.py | 5 + diffrax/_integrate.py | 14 +- diffrax/_solver/__init__.py | 4 + diffrax/_solver/align.py | 164 ++++++++++++++++++ diffrax/_solver/langevin_srk.py | 289 ++++++++++++++++++++++++++++++++ diffrax/_solver/should.py | 210 +++++++++++++++++++++++ diffrax/_solver/sort_uld.py | 191 +++++++++++++++++++++ diffrax/_solver/ubu3.py | 228 +++++++++++++++++++++++++ diffrax/_term.py | 149 +++++++++++++++- test/helpers.py | 234 ++++++++++++++++++++++---- test/test_integrate.py | 2 + test/test_langevin.py | 165 ++++++++++++++++++ test/test_sde.py | 14 +- 13 files changed, 1627 insertions(+), 42 deletions(-) create mode 100644 diffrax/_solver/align.py create mode 100644 diffrax/_solver/langevin_srk.py create mode 100644 diffrax/_solver/should.py create mode 100644 diffrax/_solver/sort_uld.py create mode 100644 diffrax/_solver/ubu3.py create mode 100644 test/test_langevin.py diff --git a/diffrax/__init__.py b/diffrax/__init__.py index 67b4ca50..f7adb78f 100644 --- a/diffrax/__init__.py +++ b/diffrax/__init__.py @@ -79,6 +79,7 @@ AbstractSRK as AbstractSRK, AbstractStratonovichSolver as AbstractStratonovichSolver, AbstractWrappedSolver as AbstractWrappedSolver, + ALIGN as ALIGN, Bosh3 as Bosh3, ButcherTableau as ButcherTableau, CalculateJacobian as CalculateJacobian, @@ -105,13 +106,16 @@ SEA as SEA, SemiImplicitEuler as SemiImplicitEuler, ShARK as ShARK, + ShOULD as ShOULD, Sil3 as Sil3, SlowRK as SlowRK, + SORT as SORT, SPaRK as SPaRK, SRA1 as SRA1, StochasticButcherTableau as StochasticButcherTableau, StratonovichMilstein as StratonovichMilstein, Tsit5 as Tsit5, + UBU3 as UBU3, ) from ._step_size_controller import ( AbstractAdaptiveStepSizeController as AbstractAdaptiveStepSizeController, @@ -123,6 +127,7 @@ from ._term import ( AbstractTerm as AbstractTerm, ControlTerm as ControlTerm, + LangevinTerm as LangevinTerm, MultiTerm as MultiTerm, ODETerm as ODETerm, WeaklyDiagonalControlTerm as WeaklyDiagonalControlTerm, diff --git a/diffrax/_integrate.py b/diffrax/_integrate.py index 615eafe9..13cf5661 100644 --- a/diffrax/_integrate.py +++ b/diffrax/_integrate.py @@ -63,7 +63,7 @@ ConstantStepSize, StepTo, ) -from ._term import AbstractTerm, MultiTerm, ODETerm, WrapTerm +from ._term import AbstractTerm, LangevinTerm, MultiTerm, ODETerm, WrapTerm from ._typing import better_isinstance, get_args_of, get_origin_no_specials @@ -123,6 +123,9 @@ def _term_compatible( term_structure: PyTree, contr_kwargs: PyTree[dict], ) -> bool: + if term_structure == LangevinTerm and isinstance(terms, LangevinTerm): + return True + error_msg = "term_structure" def _check(term_cls, term, term_contr_kwargs, yi): @@ -1005,6 +1008,10 @@ def _promote(yi): y0 = jtu.tree_map(_promote, y0) del timelikes + # Langevin terms must be unwrapped unless `term_structure=LangevinTerm + if isinstance(terms, LangevinTerm) and solver.term_structure != LangevinTerm: + terms = terms.term + # Backward compatibility if isinstance( solver, (EulerHeun, ItoMilstein, StratonovichMilstein) @@ -1063,13 +1070,14 @@ def _promote(yi): def _wrap(term): assert isinstance(term, AbstractTerm) - assert not isinstance(term, MultiTerm) + assert not isinstance(term, (MultiTerm, LangevinTerm)) return WrapTerm(term, direction) terms = jtu.tree_map( _wrap, terms, - is_leaf=lambda x: isinstance(x, AbstractTerm) and not isinstance(x, MultiTerm), + is_leaf=lambda x: isinstance(x, AbstractTerm) + and not isinstance(x, (MultiTerm, LangevinTerm)), ) if isinstance(solver, AbstractImplicitSolver): diff --git a/diffrax/_solver/__init__.py b/diffrax/_solver/__init__.py index da6fe6c9..fa6d1b63 100644 --- a/diffrax/_solver/__init__.py +++ b/diffrax/_solver/__init__.py @@ -1,3 +1,4 @@ +from .align import ALIGN as ALIGN from .base import ( AbstractAdaptiveSolver as AbstractAdaptiveSolver, AbstractImplicitSolver as AbstractImplicitSolver, @@ -42,8 +43,10 @@ from .semi_implicit_euler import SemiImplicitEuler as SemiImplicitEuler from .shark import ShARK as ShARK from .shark_general import GeneralShARK as GeneralShARK +from .should import ShOULD as ShOULD from .sil3 import Sil3 as Sil3 from .slowrk import SlowRK as SlowRK +from .sort_uld import SORT as SORT from .spark import SPaRK as SPaRK from .sra1 import SRA1 as SRA1 from .srk import ( @@ -51,3 +54,4 @@ StochasticButcherTableau as StochasticButcherTableau, ) from .tsit5 import Tsit5 as Tsit5 +from .ubu3 import UBU3 as UBU3 diff --git a/diffrax/_solver/align.py b/diffrax/_solver/align.py new file mode 100644 index 00000000..693fdf9a --- /dev/null +++ b/diffrax/_solver/align.py @@ -0,0 +1,164 @@ +import equinox as eqx +import jax.numpy as jnp +import jax.tree_util as jtu +from equinox.internal import ω +from jaxtyping import Array, PyTree + +from .._custom_types import ( + AbstractSpaceTimeLevyArea, + RealScalarLike, +) +from .._local_interpolation import LocalLinearInterpolation +from .._term import _LangevinArgs, LangevinTerm, LangevinTuple, LangevinX +from .langevin_srk import _AbstractCoeffs, _SolverState, AbstractLangevinSRK + + +# UBU evaluates at l = (3 -sqrt(3))/6, at r = (3 + sqrt(3))/6 and at 1, +# so we need 3 versions of each coefficient + + +class _ALIGNCoeffs(_AbstractCoeffs): + @property + def dtype(self): + return jtu.tree_leaves(self.beta)[0].dtype + + beta: PyTree[Array] + a1: PyTree[Array] + b1: PyTree[Array] + aa: PyTree[Array] + chh: PyTree[Array] + + +_ErrorEstimate = LangevinTuple + + +class ALIGN(AbstractLangevinSRK[_ALIGNCoeffs, _ErrorEstimate]): + r"""The Adaptive Langevin via Interpolated Gradients and Noise method + designed by James Foster. Only works for Underdamped Langevin Diffusion + of the form + + $$d x_t = v_t dt$$ + + $$d v_t = - gamma v_t dt - u ∇f(x_t) dt + (2gammau)^(1/2) dW_t$$ + + where $v$ is the velocity, $f$ is the potential, $gamma$ is the friction, and + $W$ is a Brownian motion. + """ + + term_structure = LangevinTerm + interpolation_cls = LocalLinearInterpolation + taylor_threshold: RealScalarLike = eqx.field(static=True) + _coeffs_structure = jtu.tree_structure( + _ALIGNCoeffs( + beta=jnp.array(0.0), + a1=jnp.array(0.0), + b1=jnp.array(0.0), + aa=jnp.array(0.0), + chh=jnp.array(0.0), + ) + ) + + @property + def minimal_levy_area(self): + return AbstractSpaceTimeLevyArea + + def __init__(self, taylor_threshold: RealScalarLike = 0.0): + r"""**Arguments:** + + - `taylor_threshold`: If the product `h*gamma` is less than this, then + the Taylor expansion will be used to compute the coefficients. + Otherwise they will be computed directly. When using float32, the + empirically optimal value is 0.1, and for float64 about 0.01. + """ + self.taylor_threshold = taylor_threshold + + def order(self, terms): + return 2 + + def strong_order(self, terms): + return 2.0 + + @staticmethod + def _directly_compute_coeffs_leaf(h, c) -> _ALIGNCoeffs: + # c is a leaf of gamma + # compute the coefficients directly (as opposed to via Taylor expansion) + al = c * h + beta = jnp.exp(-al) + a1 = (1 - beta) / c + b1 = (beta + al - 1) / (c * al) + aa = a1 / h + + al2 = al**2 + chh = 6 * (beta * (al + 2) + al - 2) / (al2 * c) + + out = _ALIGNCoeffs( + beta=beta, + a1=a1, + b1=b1, + aa=aa, + chh=chh, + ) + return jtu.tree_map(lambda x: jnp.array(x, dtype=jnp.dtype(c)), out) + + @staticmethod + def _tay_cfs_single(c: Array) -> _ALIGNCoeffs: + # c is a leaf of gamma + dtype = jnp.dtype(c) + zero = jnp.zeros_like(c) + one = jnp.ones_like(c) + c2 = jnp.square(c) + c3 = c2 * c + c4 = c3 * c + c5 = c4 * c + + beta = jnp.stack([one, -c, c2 / 2, -c3 / 6, c4 / 24, -c5 / 120], axis=-1) + a1 = jnp.stack([zero, one, -c / 2, c2 / 6, -c3 / 24, c4 / 120], axis=-1) + b1 = jnp.stack([zero, one / 2, -c / 6, c2 / 24, -c3 / 120, c4 / 720], axis=-1) + aa = jnp.stack([one, -c / 2, c2 / 6, -c3 / 24, c4 / 120, -c5 / 720], axis=-1) + chh = jnp.stack([zero, one, -c / 2, 3 * c2 / 20, -c3 / 30, c4 / 168], axis=-1) + + out = _ALIGNCoeffs( + beta=beta, + a1=a1, + b1=b1, + aa=aa, + chh=chh, + ) + return jtu.tree_map(lambda x: jnp.array(x, dtype=dtype), out) + + @staticmethod + def _compute_step( + h: RealScalarLike, + levy: AbstractSpaceTimeLevyArea, + x0: LangevinX, + v0: LangevinX, + langevin_args: _LangevinArgs, + cfs: _ALIGNCoeffs, + st: _SolverState, + ) -> tuple[LangevinX, LangevinX, LangevinX, LangevinTuple]: + w: LangevinX = levy.W + hh: LangevinX = levy.H + + gamma, u, f = langevin_args + + uh = (u**ω * h).ω + f0 = st.prev_f + x1 = ( + x0**ω + + cfs.a1**ω * v0**ω + - cfs.b1**ω * uh**ω * f0**ω + + st.rho**ω * (cfs.b1**ω * w**ω + cfs.chh**ω * hh**ω) + ).ω + f1 = f(x1) + v1 = ( + cfs.beta**ω * v0**ω + - u**ω * ((cfs.a1**ω - cfs.b1**ω) * f0**ω + cfs.b1**ω * f1**ω) + + st.rho**ω * (cfs.aa**ω * w**ω - gamma**ω * cfs.chh**ω * hh**ω) + ).ω + + error_estimate = ( + jtu.tree_map(lambda leaf: jnp.zeros_like(leaf), x0), + (-(u**ω) * cfs.b1**ω * (f1**ω - f0**ω)).ω, + ) + + return x1, v1, f1, error_estimate diff --git a/diffrax/_solver/langevin_srk.py b/diffrax/_solver/langevin_srk.py new file mode 100644 index 00000000..96938b02 --- /dev/null +++ b/diffrax/_solver/langevin_srk.py @@ -0,0 +1,289 @@ +import abc +from typing import Generic, TypeVar + +import equinox as eqx +import jax.lax as lax +import jax.numpy as jnp +import jax.tree_util as jtu +from jax import vmap +from jax._src.tree_util import PyTreeDef +from jaxtyping import Array, ArrayLike, PyTree + +from .._custom_types import ( + AbstractBrownianIncrement, + BoolScalarLike, + DenseInfo, + RealScalarLike, +) +from .._local_interpolation import LocalLinearInterpolation +from .._solution import RESULTS +from .._term import _LangevinArgs, LangevinTerm, LangevinTuple, LangevinX +from .base import AbstractItoSolver, AbstractStratonovichSolver + + +_ErrorEstimate = TypeVar("_ErrorEstimate", None, LangevinTuple) + + +class _AbstractCoeffs(eqx.Module): + @property + @abc.abstractmethod + def dtype(self): + raise NotImplementedError + + +_Coeffs = TypeVar("_Coeffs", bound=_AbstractCoeffs) + + +# TODO: I'm not sure if I can use the _Coeffs type here, +# given that I do not use Generic[_Coeffs] in the class definition. +# How should I work around this? +class _SolverState(eqx.Module): + h: RealScalarLike + taylor_coeffs: PyTree[_Coeffs, "LangevinX"] + coeffs: _Coeffs # type: ignore + rho: LangevinX + prev_f: LangevinX + + +# CONCERNING COEFFICIENTS: +# The coefficients used in a step of this SRK depend on +# the time increment h, and the parameter gamma. +# Assuming the modelled SDE stays the same (i.e. gamma is fixed), +# then these coefficients must be recomputed each time h changes. +# Furthermore, for very small h, directly computing the coefficients +# via the function below can cause large floating point errors. +# Hence, we pre-compute the Taylor expansion of the SRK coefficients +# around h=0. Then we can compute the SRK coefficients either via +# the Taylor expansion, or via direct computation. +# In short the Taylor coefficients give a Taylor expansion with which +# one can compute the SRK coefficients more precisely for a small h. + + +class AbstractLangevinSRK( + AbstractStratonovichSolver[_SolverState], + AbstractItoSolver[_SolverState], + Generic[_Coeffs, _ErrorEstimate], +): + term_structure = LangevinTerm + interpolation_cls = LocalLinearInterpolation + taylor_threshold: RealScalarLike = eqx.field(static=True) + _coeffs_structure: eqx.AbstractClassVar[PyTreeDef] + minimal_levy_area: eqx.AbstractClassVar[type[AbstractBrownianIncrement]] + + @staticmethod + @abc.abstractmethod + def _directly_compute_coeffs_leaf(h, c) -> _Coeffs: + raise NotImplementedError + + @staticmethod + @abc.abstractmethod + def _tay_cfs_single(c: Array) -> _Coeffs: + raise NotImplementedError + + def _comp_taylor_coeffs_leaf(self, c: Array) -> _Coeffs: + # c is a leaf of gamma + + # When the step-size h is small the coefficients (which depend on h) need + # to be computed via Taylor expansion to ensure numerical stability. + # This precomputes the Taylor coefficients (depending on gamma and u), which + # are then multiplied by powers of h, to get the coefficients of ALIGN. + # if jnp.ndim(c) == 0: + # out = self._tay_cfs_single(c) + # else: + # c_axes = tuple(range(c.ndim)) + # out = jax.vmap(self._tay_cfs_single, in_axes=c_axes, out_axes=c_axes)(c) + out = self._tay_cfs_single(c) + + def check_shape(coeff_leaf): + permitted_shapes = [c.shape + (3, 6), c.shape + (1, 6), c.shape + (6,)] + assert ( + coeff_leaf.shape in permitted_shapes + ), f"leaf shape: {coeff_leaf.shape}, c shape: {c.shape}" + + jtu.tree_map(check_shape, out) + return out + + @staticmethod + def _eval_taylor(h, tay_cfs: _Coeffs) -> _Coeffs: + # Multiplies the pre-computed Taylor coefficients by powers of h. + # jax.debug.print("eval taylor for h = {h}", h=h) + dtype = tay_cfs.dtype + h_powers = jnp.power(h, jnp.arange(0, 6, dtype=h.dtype)).astype(dtype) + return jtu.tree_map( + lambda tay_leaf: jnp.tensordot(tay_leaf, h_powers, axes=1), tay_cfs + ) + + def _recompute_coeffs( + self, h, gamma: LangevinX, tay_cfs: PyTree[_Coeffs] + ) -> _Coeffs: + def recompute_coeffs_leaf(c: ArrayLike, _tay_cfs: _Coeffs): + # Used when the step-size h changes and coefficients need to be recomputed + # Depending on the size of h*gamma choose whether the Taylor expansion or + # direct computation is more accurate. + cond = h * c < self.taylor_threshold # c is a leaf of gamma + if jnp.ndim(c) == 0: + return lax.cond( + cond, + lambda h_: self._eval_taylor(h_, _tay_cfs), + lambda h_: self._directly_compute_coeffs_leaf(h_, c), + h, + ) + else: + tay_out = self._eval_taylor(h, _tay_cfs) + if cond.ndim < jtu.tree_leaves(tay_out)[0].ndim: + cond = jnp.expand_dims(cond, axis=-1) + + def select_tay_or_direct(dummy): + fun = lambda _c: self._directly_compute_coeffs_leaf(h, _c) + direct_out = vmap(fun)(c) + + def _choose(tay_leaf, direct_leaf): + assert tay_leaf.ndim == direct_leaf.ndim == cond.ndim, ( + f"tay_leaf.ndim: {tay_leaf.ndim}," + f" direct_leaf.ndim: {direct_leaf.ndim}," + f" cond.ndim: {cond.ndim}" + ) + return jnp.where(cond, tay_leaf, direct_leaf) + + return jtu.tree_map(_choose, tay_out, direct_out) + + # If all entries of h*gamma are below threshold, only compute tay_out + # otherwise, compute both tay_out and direct_out and select the + # correct one for each dimension + return lax.cond( + jnp.all(cond), lambda _: tay_out, select_tay_or_direct, None + ) + + tree_with_cfs = jtu.tree_map(recompute_coeffs_leaf, gamma, tay_cfs) + outer = jtu.tree_structure(gamma) + inner = self._coeffs_structure + cfs_with_tree = jtu.tree_transpose(outer, inner, tree_with_cfs) + return cfs_with_tree + + def init( + self, + terms: LangevinTerm, + t0: RealScalarLike, + t1: RealScalarLike, + y0: LangevinTuple, + args: PyTree, + ) -> _SolverState: + """Precompute _SolverState which carries the Taylor coefficients and the + ALIGN coefficients (which can be computed from h and the Taylor coeffs). + This method is FSAL, so _SolverState also carries the previous evaluation + of grad_f. + """ + assert isinstance(terms, LangevinTerm) + gamma, u, f = terms.args # f is in fact grad(f) + + x0, v0 = y0 + + def _check_shapes(_c, _u, _x, _v): + # assert _x.ndim in [0, 1] + assert _c.shape == _u.shape == _x.shape == _v.shape + + assert jtu.tree_all(jtu.tree_map(_check_shapes, gamma, u, x0, v0)) + + h = t1 - t0 + + tay_cfs = jtu.tree_map(self._comp_taylor_coeffs_leaf, gamma) + # tay_cfs have the same tree structure as gamma, with each leaf being a _Coeffs + # and the arrays have an extra trailing dimension of 6 + + coeffs = self._recompute_coeffs(h, gamma, tay_cfs) + rho = jtu.tree_map(lambda c, _u: jnp.sqrt(2 * c * _u), gamma, u) + + state_out = _SolverState( + h=h, + taylor_coeffs=tay_cfs, + coeffs=coeffs, + rho=rho, + prev_f=f(x0), + ) + + return state_out + + @staticmethod + @abc.abstractmethod + def _compute_step( + h: RealScalarLike, + levy, + x0: LangevinX, + v0: LangevinX, + langevin_args: _LangevinArgs, + cfs: _Coeffs, + st: _SolverState, + ) -> tuple[LangevinX, LangevinX, LangevinX, _ErrorEstimate]: + raise NotImplementedError + + def step( + self, + terms: LangevinTerm, + t0: RealScalarLike, + t1: RealScalarLike, + y0: LangevinTuple, + args: PyTree, + solver_state: _SolverState, + made_jump: BoolScalarLike, + ) -> tuple[LangevinTuple, _ErrorEstimate, DenseInfo, _SolverState, RESULTS]: + del made_jump, args + st = solver_state + h = t1 - t0 + assert isinstance(terms, LangevinTerm) + gamma, u, f = terms.args + + h_state = st.h + tay: PyTree[_Coeffs] = st.taylor_coeffs + cfs: _Coeffs = st.coeffs # type: ignore + + # If h changed recompute coefficients + cond = jnp.isclose(h_state, h) + cfs = lax.cond( + cond, lambda x: x, lambda _: self._recompute_coeffs(h, gamma, tay), cfs + ) + + drift, diffusion = terms.term.terms + # compute the Brownian increment and space-time Levy area + levy = diffusion.contr(t0, t1, use_levy=True) + assert isinstance(levy, self.minimal_levy_area), ( + f"The Brownian motion must have" + f" `levy_area={self.minimal_levy_area.__name__}`" + ) + + x0, v0 = y0 + x_out, v_out, f_fsal, error = self._compute_step( + h, levy, x0, v0, terms.args, cfs, st + ) + + def check_shapes_dtypes(_x, _v, _f, _x0): + assert _x.dtype == _v.dtype == _f.dtype == _x0.dtype, ( + f"dtypes don't match. x0: {x0.dtype}," + f" v_out: {_v.dtype}, x_out: {_x.dtype}, f_fsal: {_f.dtype}" + ) + assert _x.shape == _v.shape == _f.shape == _x0.shape, ( + f"Shapes don't match. x0: {x0.shape}," + f" v_out: {_v.shape}, x_out: {_x.shape}, f_fsal: {_f.shape}" + ) + + jtu.tree_map(check_shapes_dtypes, x_out, v_out, f_fsal, x0) + + y1 = (x_out, v_out) + + dense_info = dict(y0=y0, y1=y1) + st = _SolverState( + h=h, + taylor_coeffs=tay, + coeffs=cfs, + rho=st.rho, + prev_f=f_fsal, + ) + return y1, error, dense_info, st, RESULTS.successful + + def func( + self, + terms: LangevinTerm, + t0: RealScalarLike, + y0: LangevinTuple, + args: PyTree, + ): + return terms.vf(t0, y0, args) diff --git a/diffrax/_solver/should.py b/diffrax/_solver/should.py new file mode 100644 index 00000000..b2d48546 --- /dev/null +++ b/diffrax/_solver/should.py @@ -0,0 +1,210 @@ +import equinox as eqx +import jax.numpy as jnp +import jax.tree_util as jtu +from equinox.internal import ω +from jaxtyping import Array, PyTree + +from .._custom_types import ( + AbstractSpaceTimeTimeLevyArea, + RealScalarLike, +) +from .._local_interpolation import LocalLinearInterpolation +from .._term import _LangevinArgs, LangevinTerm, LangevinX +from .langevin_srk import _AbstractCoeffs, _SolverState, AbstractLangevinSRK + + +# UBU evaluates at l = (3 -sqrt(3))/6, at r = (3 + sqrt(3))/6 and at 1, +# so we need 3 versions of each coefficient + + +class _ShOULDCoeffs(_AbstractCoeffs): + @property + def dtype(self): + return jtu.tree_leaves(self.beta1)[0].dtype + + beta_half: PyTree[Array] + a_half: PyTree[Array] + b_half: PyTree[Array] + beta1: PyTree[Array] + a1: PyTree[Array] + b1: PyTree[Array] + aa: PyTree[Array] + chh: PyTree[Array] + ckk: PyTree[Array] + + +class ShOULD(AbstractLangevinSRK[_ShOULDCoeffs, None]): + r"""The Shifted-ODE Runge-Kutta Three method + designed by James Foster. Only works for Underdamped Langevin Diffusion + of the form + + $$d x_t = v_t dt$$ + + $$d v_t = - gamma v_t dt - u ∇f(x_t) dt + (2gammau)^(1/2) dW_t$$ + + where $v$ is the velocity, $f$ is the potential, $gamma$ is the friction, and + $W$ is a Brownian motion. + """ + + term_structure = LangevinTerm + interpolation_cls = LocalLinearInterpolation + taylor_threshold: RealScalarLike = eqx.field(static=True) + _coeffs_structure = jtu.tree_structure( + _ShOULDCoeffs( + beta_half=jnp.array(0.0), + a_half=jnp.array(0.0), + b_half=jnp.array(0.0), + beta1=jnp.array(0.0), + a1=jnp.array(0.0), + b1=jnp.array(0.0), + aa=jnp.array(0.0), + chh=jnp.array(0.0), + ckk=jnp.array(0.0), + ) + ) + + @property + def minimal_levy_area(self): + return AbstractSpaceTimeTimeLevyArea + + def __init__(self, taylor_threshold: RealScalarLike = 0.0): + r"""**Arguments:** + + - `taylor_threshold`: If the product `h*gamma` is less than this, then + the Taylor expansion will be used to compute the coefficients. + Otherwise they will be computed directly. When using float32, the + empirically optimal value is 0.1, and for float64 about 0.01. + """ + self.taylor_threshold = taylor_threshold + + def order(self, terms): + return 3 + + def strong_order(self, terms): + return 3.0 + + @staticmethod + def _directly_compute_coeffs_leaf(h, c) -> _ShOULDCoeffs: + # c is a leaf of gamma + # compute the coefficients directly (as opposed to via Taylor expansion) + al = c * h + beta_half = jnp.exp(-al / 2) + beta1 = jnp.exp(-al) + a_half = (1 - beta_half) / c + a1 = (1 - beta1) / c + b_half = (beta_half + al / 2 - 1) / (al * c) + b1 = (beta1 + al - 1) / (al * c) + aa = a1 / h + + al2 = al**2 + al3 = al2 * al + chh = 6 * (beta1 * (al + 2) + al - 2) / (al2 * c) + ckk = 60 * (beta1 * (al * (al + 6) + 12) - al * (al - 6) - 12) / (al3 * c) + + out = _ShOULDCoeffs( + beta_half=beta_half, + a_half=a_half, + b_half=b_half, + beta1=beta1, + a1=a1, + b1=b1, + aa=aa, + chh=chh, + ckk=ckk, + ) + return jtu.tree_map(lambda x: jnp.array(x, dtype=jnp.dtype(c)), out) + + @staticmethod + def _tay_cfs_single(c: Array) -> _ShOULDCoeffs: + # c is a leaf of gamma + zero = jnp.zeros_like(c) + one = jnp.ones_like(c) + dtype = jnp.dtype(c) + c2 = jnp.square(c) + c3 = c2 * c + c4 = c3 * c + c5 = c4 * c + + beta_half = jnp.stack( + [one, -c / 2, c2 / 8, -c3 / 48, c4 / 384, -c5 / 3840], axis=-1 + ) + beta1 = jnp.stack([one, -c, c2 / 2, -c3 / 6, c4 / 24, -c5 / 120], axis=-1) + + a_half = jnp.stack( + [zero, one / 2, -c / 8, c2 / 48, -c3 / 384, c4 / 3840], axis=-1 + ) + a1 = jnp.stack([zero, one, -c / 2, c2 / 6, -c3 / 24, c4 / 120], axis=-1) + # aa = a1/h + aa = jnp.stack([one, -c / 2, c2 / 6, -c3 / 24, c4 / 120, -c5 / 720], axis=-1) + + # b_half is not exactly b(1/2 h), but 1/2 * b(1/2 h) + b_half = jnp.stack( + [zero, one / 8, -c / 48, c2 / 384, -c3 / 3840, c4 / 46080], axis=-1 + ) + b1 = jnp.stack([zero, one / 2, -c / 6, c2 / 24, -c3 / 120, c4 / 720], axis=-1) + + chh = jnp.stack([zero, one, -c / 2, 3 * c2 / 20, -c3 / 30, c4 / 168], axis=-1) + ckk = jnp.stack([zero, zero, -c, c2 / 2, -c3 / 7, 5 * c4 / 168], axis=-1) + + out = _ShOULDCoeffs( + beta_half=beta_half, + a_half=a_half, + b_half=b_half, + beta1=beta1, + a1=a1, + b1=b1, + aa=aa, + chh=chh, + ckk=ckk, + ) + return jtu.tree_map(lambda x: jnp.array(x, dtype=dtype), out) + + @staticmethod + def _compute_step( + h: RealScalarLike, + levy: AbstractSpaceTimeTimeLevyArea, + x0: LangevinX, + v0: LangevinX, + langevin_args: _LangevinArgs, + cfs: _ShOULDCoeffs, + st: _SolverState, + ) -> tuple[LangevinX, LangevinX, LangevinX, None]: + w: LangevinX = levy.W + hh: LangevinX = levy.H + kk: LangevinX = levy.K + + gamma, u, f = langevin_args + + rho_w_k = (st.rho**ω * (w**ω - 12 * kk**ω)).ω + uh = (u**ω * h).ω + + f0 = st.prev_f + v1 = (v0**ω + st.rho**ω * (hh**ω + 6 * kk**ω)).ω + x1 = ( + x0**ω + + cfs.a_half**ω * v1**ω + + cfs.b_half**ω * (-(uh**ω) * f0**ω + rho_w_k**ω) + ).ω + f1 = f(x1) + + chh_hh_plus_ckk_kk = (cfs.chh**ω * hh**ω + cfs.ckk**ω * kk**ω).ω + + x_out = ( + x0**ω + + cfs.a1**ω * v0**ω + - uh**ω * cfs.b1**ω * (1 / 3 * f0**ω + 2 / 3 * f1**ω) + + st.rho**ω * (cfs.b1**ω * w**ω + chh_hh_plus_ckk_kk**ω) + ).ω + f_out = f(x_out) + v_out = ( + cfs.beta1**ω * v0**ω + - uh**ω + * ( + cfs.beta1**ω / 6 * f0**ω + + 2 / 3 * cfs.beta_half**ω * f1**ω + + 1 / 6 * f_out**ω + ) + + st.rho**ω * (cfs.aa**ω * w**ω - gamma**ω * chh_hh_plus_ckk_kk**ω) + ).ω + + return x_out, v_out, f_out, None diff --git a/diffrax/_solver/sort_uld.py b/diffrax/_solver/sort_uld.py new file mode 100644 index 00000000..00b13675 --- /dev/null +++ b/diffrax/_solver/sort_uld.py @@ -0,0 +1,191 @@ +import equinox as eqx +import jax.numpy as jnp +import jax.tree_util as jtu +from equinox.internal import ω +from jaxtyping import Array, PyTree + +from .._custom_types import ( + AbstractSpaceTimeTimeLevyArea, + RealScalarLike, +) +from .._local_interpolation import LocalLinearInterpolation +from .._term import _LangevinArgs, LangevinTerm, LangevinX +from .langevin_srk import _AbstractCoeffs, _SolverState, AbstractLangevinSRK + + +# UBU evaluates at l = (3 -sqrt(3))/6, at r = (3 + sqrt(3))/6 and at 1, +# so we need 3 versions of each coefficient + + +class _SORTCoeffs(_AbstractCoeffs): + @property + def dtype(self): + return jtu.tree_leaves(self.beta1)[0].dtype + + beta_half: PyTree[Array] + a_half: PyTree[Array] + b_half: PyTree[Array] + beta1: PyTree[Array] + a1: PyTree[Array] + b1: PyTree[Array] + aa: PyTree[Array] + + +class SORT(AbstractLangevinSRK[_SORTCoeffs, None]): + r"""The Shifted-ODE Runge-Kutta Three method + designed by James Foster. Only works for Underdamped Langevin Diffusion + of the form + + $$d x_t = v_t dt$$ + + $$d v_t = - gamma v_t dt - u ∇f(x_t) dt + (2gammau)^(1/2) dW_t$$ + + where $v$ is the velocity, $f$ is the potential, $gamma$ is the friction, and + $W$ is a Brownian motion. + """ + + term_structure = LangevinTerm + interpolation_cls = LocalLinearInterpolation + taylor_threshold: RealScalarLike = eqx.field(static=True) + _coeffs_structure = jtu.tree_structure( + _SORTCoeffs( + beta_half=jnp.array(0.0), + a_half=jnp.array(0.0), + b_half=jnp.array(0.0), + beta1=jnp.array(0.0), + a1=jnp.array(0.0), + b1=jnp.array(0.0), + aa=jnp.array(0.0), + ) + ) + + @property + def minimal_levy_area(self): + return AbstractSpaceTimeTimeLevyArea + + def __init__(self, taylor_threshold: RealScalarLike = 0.0): + r"""**Arguments:** + + - `taylor_threshold`: If the product `h*gamma` is less than this, then + the Taylor expansion will be used to compute the coefficients. + Otherwise they will be computed directly. When using float32, the + empirically optimal value is 0.1, and for float64 about 0.01. + """ + self.taylor_threshold = taylor_threshold + + def order(self, terms): + return 3 + + def strong_order(self, terms): + return 3.0 + + @staticmethod + def _directly_compute_coeffs_leaf(h, c) -> _SORTCoeffs: + # c is a leaf of gamma + # compute the coefficients directly (as opposed to via Taylor expansion) + al = c * h + beta_half = jnp.exp(-al / 2) + beta1 = jnp.exp(-al) + a_half = (1 - beta_half) / c + a1 = (1 - beta1) / c + b_half = (beta_half + al / 2 - 1) / (al * c) + b1 = (beta1 + al - 1) / (al * c) + aa = a1 / h + + out = _SORTCoeffs( + beta_half=beta_half, + a_half=a_half, + b_half=b_half, + beta1=beta1, + a1=a1, + b1=b1, + aa=aa, + ) + return jtu.tree_map(lambda x: jnp.array(x, dtype=jnp.dtype(c)), out) + + @staticmethod + def _tay_cfs_single(c: Array) -> _SORTCoeffs: + # c is a leaf of gamma + dtype = jnp.dtype(c) + zero = jnp.zeros_like(c) + one = jnp.ones_like(c) + c2 = jnp.square(c) + c3 = c2 * c + c4 = c3 * c + c5 = c4 * c + + beta_half = jnp.stack( + [one, -c / 2, c2 / 8, -c3 / 48, c4 / 384, -c5 / 3840], axis=-1 + ) + beta1 = jnp.stack([one, -c, c2 / 2, -c3 / 6, c4 / 24, -c5 / 120], axis=-1) + + a_half = jnp.stack( + [zero, one / 2, -c / 8, c2 / 48, -c3 / 384, c4 / 3840], axis=-1 + ) + a1 = jnp.stack([zero, one, -c / 2, c2 / 6, -c3 / 24, c4 / 120], axis=-1) + # aa = a1/h + aa = jnp.stack([one, -c / 2, c2 / 6, -c3 / 24, c4 / 120, -c5 / 720], axis=-1) + + # b_half is not exactly b(1/2 h), but 1/2 * b(1/2 h) + b_half = jnp.stack( + [zero, one / 8, -c / 48, c2 / 384, -c3 / 3840, c4 / 46080], axis=-1 + ) + b1 = jnp.stack([zero, one / 2, -c / 6, c2 / 24, -c3 / 120, c4 / 720], axis=-1) + out = _SORTCoeffs( + beta_half=beta_half, + a_half=a_half, + b_half=b_half, + beta1=beta1, + a1=a1, + b1=b1, + aa=aa, + ) + + return jtu.tree_map(lambda x: jnp.array(x, dtype=dtype), out) + + @staticmethod + def _compute_step( + h: RealScalarLike, + levy: AbstractSpaceTimeTimeLevyArea, + x0: LangevinX, + v0: LangevinX, + langevin_args: _LangevinArgs, + cfs: _SORTCoeffs, + st: _SolverState, + ) -> tuple[LangevinX, LangevinX, LangevinX, None]: + w: LangevinX = levy.W + hh: LangevinX = levy.H + kk: LangevinX = levy.K + + gamma, u, f = langevin_args + + rho_w_k = (st.rho**ω * (w**ω - 12 * kk**ω)).ω + uh = (u**ω * h).ω + + f0 = st.prev_f + v1 = (v0**ω + st.rho**ω * (hh**ω + 6 * kk**ω)).ω + x1 = ( + x0**ω + + cfs.a_half**ω * v1**ω + + cfs.b_half**ω * (-(uh**ω) * f0**ω + rho_w_k**ω) + ).ω + f1 = f(x1) + x_out = ( + x0**ω + + cfs.a1**ω * v1**ω + + cfs.b1**ω * (-(uh**ω) * (1 / 3 * f0**ω + 2 / 3 * f1**ω) + rho_w_k**ω) + ).ω + f_out = f(x_out) + v_out = ( + cfs.beta1**ω * v1**ω + - uh**ω + * ( + cfs.beta1**ω / 6 * f0**ω + + 2 / 3 * cfs.beta_half**ω * f1**ω + + 1 / 6 * f_out**ω + ) + + cfs.aa**ω * rho_w_k**ω + - st.rho**ω * (hh**ω - 6 * kk**ω) + ).ω + + return x_out, v_out, f_out, None diff --git a/diffrax/_solver/ubu3.py b/diffrax/_solver/ubu3.py new file mode 100644 index 00000000..0f1db131 --- /dev/null +++ b/diffrax/_solver/ubu3.py @@ -0,0 +1,228 @@ +import math + +import equinox as eqx +import jax +import jax.numpy as jnp +import jax.tree_util as jtu +from equinox.internal import ω +from jaxtyping import Array, PyTree + +from .._custom_types import ( + AbstractSpaceTimeTimeLevyArea, + RealScalarLike, +) +from .._local_interpolation import LocalLinearInterpolation +from .._term import _LangevinArgs, LangevinTerm, LangevinX +from .langevin_srk import _AbstractCoeffs, _SolverState, AbstractLangevinSRK + + +# UBU evaluates at l = (3 -sqrt(3))/6, at r = (3 + sqrt(3))/6 and at 1, +# so we need 3 versions of each coefficient + + +class _UBU3Coeffs(_AbstractCoeffs): + @property + def dtype(self): + return jtu.tree_leaves(self.beta_lr1)[0].dtype + + beta_lr1: PyTree[Array] # (gamma, 3, *taylor) + a_lr1: PyTree[Array] # (gamma, 3, *taylor) + b_lr1: PyTree[Array] # (gamma, 3, *taylor) + a_third: PyTree[Array] # (gamma, 1, *taylor) + a_div_h: PyTree[Array] # (gamma, 1, *taylor) + + +class UBU3(AbstractLangevinSRK[_UBU3Coeffs, None]): + r"""The third order version of the UBU method by Daire O'Kane and James Foster. + Works for underdamped Langevin SDEs of the form + + $$d x_t = v_t dt$$ + + $$d v_t = - gamma v_t dt - u ∇f(x_t) dt + (2gammau)^(1/2) dW_t$$ + + where $v$ is the velocity, $f$ is the potential, $gamma$ is the friction, and + $W$ is a Brownian motion. + """ + + term_structure = LangevinTerm + interpolation_cls = LocalLinearInterpolation + taylor_threshold: RealScalarLike = eqx.field(static=True) + _coeffs_structure = jtu.tree_structure( + _UBU3Coeffs( + beta_lr1=jnp.array(0.0), + a_lr1=jnp.array(0.0), + b_lr1=jnp.array(0.0), + a_third=jnp.array(0.0), + a_div_h=jnp.array(0.0), + ) + ) + + @property + def minimal_levy_area(self): + return AbstractSpaceTimeTimeLevyArea + + def __init__(self, taylor_threshold: RealScalarLike = 0.0): + r"""**Arguments:** + + - `taylor_threshold`: If the product `h*gamma` is less than this, then + the Taylor expansion will be used to compute the coefficients. + Otherwise they will be computed directly. When using float32, the + empirically optimal value is 0.1, and for float64 about 0.01. + """ + self.taylor_threshold = taylor_threshold + + def order(self, terms): + return 3 + + def strong_order(self, terms): + return 3.0 + + @staticmethod + def _directly_compute_coeffs_leaf(h, c) -> _UBU3Coeffs: + # compute the coefficients directly (as opposed to via Taylor expansion) + dtype = jnp.dtype(c) + original_shape = c.shape + c = jnp.expand_dims(c, axis=c.ndim) + alpha = c * h + l = 0.5 - math.sqrt(3) / 6 + r = 0.5 + math.sqrt(3) / 6 + l_r_1 = jnp.array([l, r, 1.0], dtype=jnp.dtype(c)) + alpha_lr1 = alpha * l_r_1 + assert alpha_lr1.shape == original_shape + ( + 3, + ), f"expected {original_shape + (3,)}, got {alpha_lr1.shape}" + beta_lr1 = jnp.exp(-alpha_lr1) + a_lr1 = (1.0 - beta_lr1) / c + b_lr1 = (beta_lr1 + alpha_lr1 - 1.0) / (c**2 * h) + a_third = (1.0 - jnp.exp(-alpha / 3)) / c + a_div_h = (1.0 - jnp.exp(-alpha)) / (c * h) + + assert a_third.shape == a_div_h.shape == original_shape + (1,) + + out = _UBU3Coeffs( + beta_lr1=beta_lr1, + a_lr1=a_lr1, + b_lr1=b_lr1, + a_third=a_third, + a_div_h=a_div_h, + ) + return jtu.tree_map(lambda x: jnp.array(x, dtype=dtype), out) + + @staticmethod + def _tay_cfs_single(c: Array) -> _UBU3Coeffs: + # c is a leaf of gamma + dtype = jnp.dtype(c) + zero = jnp.zeros_like(c) + one = jnp.ones_like(c) + c2 = jnp.square(c) + c3 = c2 * c + c4 = c3 * c + c5 = c4 * c + + l = 0.5 - math.sqrt(3) / 6 + r = 0.5 + math.sqrt(3) / 6 + lr1 = jnp.expand_dims(jnp.array([l, r, 1.0], dtype=dtype), axis=-1) + exponents = jnp.expand_dims(jnp.arange(0, 6, dtype=dtype), axis=0) + lr1_pows = jnp.power(lr1, exponents) + assert lr1_pows.shape == (3, 6) + + beta = jnp.stack([one, -c, c2 / 2, -c3 / 6, c4 / 24, -c5 / 120], axis=-1) + a = jnp.stack([zero, one, -c / 2, c2 / 6, -c3 / 24, c4 / 120], axis=-1) + b = jnp.stack([zero, one / 2, -c / 6, c2 / 24, -c3 / 120, c4 / 720], axis=-1) + + with jax.numpy_rank_promotion("allow"): + beta_lr1 = lr1_pows * jnp.expand_dims(beta, axis=c.ndim) + a_lr1 = lr1_pows * jnp.expand_dims(a, axis=c.ndim) + # b needs an extra power of l and r + b_lr1 = lr1_pows * lr1 * jnp.expand_dims(b, axis=c.ndim) + assert beta_lr1.shape == a_lr1.shape == b_lr1.shape == c.shape + (3, 6) + + # a_third = (1 - exp(-1/3 * gamma * h))/gamma + a_third = jnp.stack( + [zero, one / 3, -c / 18, c2 / 162, -c3 / 1944, c4 / 29160], axis=-1 + ) + a_third = jnp.expand_dims(a_third, axis=c.ndim) + a_div_h = jnp.stack( + [one, -c / 2, c2 / 6, -c3 / 24, c4 / 120, -c5 / 720], axis=-1 + ) + a_div_h = jnp.expand_dims(a_div_h, axis=c.ndim) + assert a_third.shape == a_div_h.shape == c.shape + (1, 6) + + out = _UBU3Coeffs( + beta_lr1=beta_lr1, + a_lr1=a_lr1, + b_lr1=b_lr1, + a_third=a_third, + a_div_h=a_div_h, + ) + return jtu.tree_map(lambda x: jnp.array(x, dtype=dtype), out) + + @staticmethod + def _compute_step( + h: RealScalarLike, + levy: AbstractSpaceTimeTimeLevyArea, + x0: LangevinX, + v0: LangevinX, + langevin_args: _LangevinArgs, + cfs: _UBU3Coeffs, + st: _SolverState, + ) -> tuple[LangevinX, LangevinX, LangevinX, None]: + w: LangevinX = levy.W + hh: LangevinX = levy.H + kk: LangevinX = levy.K + + gamma, u, f = langevin_args + + def _l(coeff): + return jtu.tree_map(lambda arr: arr[..., 0], coeff) + + def _r(coeff): + return jtu.tree_map(lambda arr: arr[..., 1], coeff) + + def _one(coeff): + return jtu.tree_map(lambda arr: arr[..., 2], coeff) + + beta_l = _l(cfs.beta_lr1) + beta_r = _r(cfs.beta_lr1) + beta_1 = _one(cfs.beta_lr1) + a_l = _l(cfs.a_lr1) + a_r = _r(cfs.a_lr1) + a_1 = _one(cfs.a_lr1) + b_l = _l(cfs.b_lr1) + b_r = _r(cfs.b_lr1) + b_1 = _one(cfs.b_lr1) + a_third = _l(cfs.a_third) + a_div_h = _l(cfs.a_div_h) + + rho_w_k = (st.rho**ω * (w**ω - 12 * kk**ω)).ω + uh = (u**ω * h).ω + v_tilde = (v0**ω + st.rho**ω * (hh**ω + 6 * kk**ω)).ω + + x1 = (x0**ω + a_l**ω * v_tilde**ω + b_l**ω * rho_w_k**ω).ω + f1uh = (f(x1) ** ω * uh**ω).ω + + x2 = ( + x0**ω + a_r**ω * v_tilde**ω + b_r**ω * rho_w_k**ω - a_third**ω * f1uh**ω + ).ω + f2uh = (f(x2) ** ω * uh**ω).ω + + x_out = ( + x0**ω + + a_1**ω * v_tilde**ω + + b_1**ω * rho_w_k**ω + - 0.5 * (a_r**ω * f1uh**ω + a_l**ω * f2uh**ω) + ).ω + + v_out_tilde = ( + beta_1**ω * v_tilde**ω + - 0.5 * (beta_r**ω * f1uh**ω + beta_l**ω * f2uh**ω) + + a_div_h**ω * rho_w_k**ω + ).ω + v_out = (v_out_tilde**ω - st.rho**ω * (hh**ω - 6 * kk**ω)).ω + + f_fsal = ( + st.prev_f + ) # this method is not FSAL, but this is for compatibility with the base class + + # TODO: compute error estimate + return x_out, v_out, f_fsal, None diff --git a/diffrax/_term.py b/diffrax/_term.py index 8d031b95..8037d40f 100644 --- a/diffrax/_term.py +++ b/diffrax/_term.py @@ -2,7 +2,7 @@ import operator import warnings from collections.abc import Callable -from typing import cast, Generic, Optional, TypeVar, Union +from typing import Any, cast, Generic, Optional, TypeVar, Union import equinox as eqx import jax @@ -11,9 +11,18 @@ import lineax as lx import numpy as np from equinox.internal import ω -from jaxtyping import ArrayLike, PyTree, PyTreeDef - -from ._custom_types import Args, Control, IntScalarLike, RealScalarLike, VF, Y +from jaxtyping import Array, ArrayLike, PyTree, PyTreeDef, Shaped + +from ._brownian import AbstractBrownianPath +from ._custom_types import ( + AbstractBrownianIncrement, + Args, + Control, + IntScalarLike, + RealScalarLike, + VF, + Y, +) from ._misc import upcast_or_raise from ._path import AbstractPath @@ -776,3 +785,135 @@ def _to_vjp(_y, _diff_args, _diff_term): dy, vjp = jax.vjp(_to_vjp, y, diff_args, diff_term) da_y, da_diff_args, da_diff_term = vjp((-(a_y**ω)).ω) return dy, da_y, da_diff_args, da_diff_term + + +LangevinX = PyTree[Shaped[Array, "?*langevin"], "LangevinX"] +LangevinTuple = tuple[LangevinX, LangevinX] +_LangevinBM = TypeVar("_LangevinBM", bound=Union[LangevinX, AbstractBrownianIncrement]) + + +class _LangevinDiffusionTerm(AbstractTerm[LangevinX, _LangevinBM]): + r"""Represents the diffusion term in the Langevin SDE: + + $d \mathbf{x}_t = \mathbf{v}_t \, dt$ + + $d \mathbf{v}_t = - \gamma \, \mathbf{v}_t \, dt - u \, + \nabla \! f( \mathbf{x}_t ) \, dt + \sqrt{2 \gamma u} \, d W_t.$ + """ + + gamma: LangevinX + u: LangevinX + control: AbstractBrownianPath + + def __init__(self, gamma, u, control: AbstractBrownianPath): + self.gamma = gamma + self.u = u + self.control = control + + def vf(self, t: RealScalarLike, y: LangevinTuple, args: Args) -> LangevinX: + x, v = y + + def _fun(_gamma, _u, _v): + return jnp.sqrt(2 * _gamma * _u) * jnp.ones(_v.shape, _v.dtype) + + d_v = jtu.tree_map(_fun, self.gamma, self.u, v) + return d_v + + def contr(self, t0: RealScalarLike, t1: RealScalarLike, **kwargs) -> _LangevinBM: + return self.control.evaluate(t0, t1, **kwargs) + + def prod(self, vf: LangevinX, control: LangevinX) -> LangevinTuple: + if isinstance(control, AbstractBrownianIncrement): + control = control.W + + dv = vf + dw = control + v_out = jtu.tree_map(operator.mul, dv, dw) + x_out = jtu.tree_map(jnp.zeros_like, v_out) + return x_out, v_out + + +_LangevinArgs = tuple[LangevinX, LangevinX, Callable[[LangevinX], LangevinX]] + + +def _langevin_drift(t, y: LangevinTuple, args: _LangevinArgs) -> LangevinTuple: + gamma, u, grad_f = args + x, v = y + f_x = grad_f(x) + d_x = v + d_v = jtu.tree_map( + lambda _gamma, _u, _v, _f_x: -_gamma * _v - _u * _f_x, + gamma, + u, + v, + f_x, + ) + d_y = (d_x, d_v) + return d_y + + +def _broadcast_pytree(source, target_tree_shape): + # Requires that source is a prefix tree of target_tree_shape + def _inner_broadcast(_src_arr, _inner_tree_shape): + _arr = jnp.asarray(_src_arr) + return jtu.tree_map( + lambda _leaf: jnp.broadcast_to(_arr, _leaf.shape), _inner_tree_shape + ) + + return jtu.tree_map(_inner_broadcast, source, target_tree_shape) + + +class LangevinTerm(AbstractTerm): + r"""Used to represent the Langevin SDE, given by: + + $d \mathbf{x}_t = \mathbf{v}_t \, dt$ + + $d \mathbf{v}_t = - \gamma \, \mathbf{v}_t \, dt - u \, + \nabla \! f( \mathbf{x}_t ) \, dt + \sqrt{2 \gamma u} \, d W_t.$ + + where $\mathbf{x}_t, \mathbf{v}_t \in \mathbb{R}^d$ represent the position + and velocity, $W$ is a Brownian motion in $\mathbb{R}^d$, + $f: \mathbb{R}^d \rightarrow \mathbb{R}$ is a potential function, and + $ \gamma,\, u\in\mathbb{R}^{d\times d}$ are diagonal matrices representing + friction and a dampening parameter. + """ + + args: _LangevinArgs = eqx.field(static=True) + term: MultiTerm[tuple[ODETerm, _LangevinDiffusionTerm]] + + def __init__(self, args, bm: AbstractBrownianPath, x0: LangevinX): + r"""**Arguments:** + + - `args`: a tuple of the form $(\gamma, \, u, \, \nabla \! f)$ + - `bm`: a Brownian path + - `x0`: a point in the state space of the process (position only), + needed to determine the PyTree structure and shape of the process. + """ + g1, u1, grad_f = args + # the PyTree structure of g1 and u1 must be a prefix of the PyTree + # structure of x0, and the shapes must be broadcastable to the shape of + # each leaf of x0. + gamma = _broadcast_pytree(g1, x0) + u = _broadcast_pytree(u1, x0) + grad_f_shape = jax.eval_shape(grad_f, x0) + + def _shape_check_fun(_x, _g, _u, _fx): + return _x.shape == _g.shape == _u.shape == _fx.shape + + assert jtu.tree_all( + jtu.tree_map(_shape_check_fun, x0, gamma, u, grad_f_shape) + ), "The shapes of gamma, u, and grad_f(x0) must be the same as x0." + + self.args = (gamma, u, grad_f) + drift = ODETerm(lambda t, y, _: _langevin_drift(t, y, self.args)) + diffusion = _LangevinDiffusionTerm(gamma, u, bm) + self.term = MultiTerm(drift, diffusion) + + def vf(self, t: RealScalarLike, y: LangevinTuple, args: Args) -> tuple[Any, ...]: + return self.term.vf(t, y, args) + + def contr(self, t0: RealScalarLike, t1: RealScalarLike, **kwargs) -> Any: + return self.term.contr(t0, t1, **kwargs) + + def prod(self, vf: tuple[Any, ...], control: Any) -> LangevinTuple: + return self.term.prod(vf, control) diff --git a/test/helpers.py b/test/helpers.py index fd4097dd..ab03598b 100644 --- a/test/helpers.py +++ b/test/helpers.py @@ -12,10 +12,12 @@ AbstractBrownianPath, AbstractTerm, ControlTerm, + LangevinTerm, MultiTerm, ODETerm, VirtualBrownianTree, ) +from diffrax._misc import is_tuple_of_ints from jax import Array from jaxtyping import PRNGKeyArray, PyTree, Shaped @@ -116,7 +118,7 @@ def sum_square_diff(y1, y2): def _get_minimal_la(solver): while isinstance(solver, diffrax.HalfSolver): solver = solver.solver - return getattr(solver, "minimal_levy_area", diffrax.BrownianIncrement) + return getattr(solver, "minimal_levy_area", diffrax.AbstractBrownianIncrement) def _abstract_la_to_la(abstract_la): @@ -137,7 +139,7 @@ def _abstract_la_to_la(abstract_la): def _batch_sde_solve( key: PRNGKeyArray, get_terms: Callable[[diffrax.AbstractBrownianPath], diffrax.AbstractTerm], - w_shape: tuple[int, ...], + w_shape: Union[tuple[int, ...], PyTree[jax.ShapeDtypeStruct]], t0: float, t1: float, y0: PyTree[Array], @@ -152,7 +154,10 @@ def _batch_sde_solve( abstract_levy_area = _get_minimal_la(solver) if levy_area is None else levy_area concrete_la = _abstract_la_to_la(abstract_levy_area) dtype = jnp.result_type(*jtu.tree_leaves(y0)) - struct = jax.ShapeDtypeStruct(w_shape, dtype) + if is_tuple_of_ints(w_shape): + struct = jax.ShapeDtypeStruct(w_shape, dtype) + else: + struct = w_shape bm = diffrax.VirtualBrownianTree( t0=t0, t1=t1, @@ -176,7 +181,10 @@ def _batch_sde_solve( stepsize_controller=controller, saveat=saveat, ) - return sol.ys, sol.stats["num_accepted_steps"] + steps = sol.stats["num_accepted_steps"] + if isinstance(solver, diffrax.HalfSolver): + steps *= 3 + return sol.ys, steps def _resulting_levy_area( @@ -220,7 +228,7 @@ def sde_solver_strong_order( y0: PyTree[Array], args: PyTree, solver: diffrax.AbstractSolver, - ref_solver: diffrax.AbstractSolver, + ref_solver: Optional[diffrax.AbstractSolver], levels: tuple[int, int], ref_level: int, get_dt_and_controller: Callable[ @@ -228,30 +236,37 @@ def sde_solver_strong_order( ], saveat: diffrax.SaveAt, bm_tol: float, + levy_area: Optional[type[diffrax.AbstractBrownianIncrement]], + ref_solution: Optional[PyTree[Array]], ): - levy_area1 = _get_minimal_la(solver) - levy_area2 = _get_minimal_la(ref_solver) - # Stricter levy_area requirements inherit from less strict ones - levy_area = _resulting_levy_area(levy_area1, levy_area2) + if levy_area is None: + levy_area1 = _get_minimal_la(solver) + levy_area2 = _get_minimal_la(ref_solver) + # Stricter levy_area requirements inherit from less strict ones + levy_area = _resulting_levy_area(levy_area1, levy_area2) level_coarse, level_fine = levels - dt, step_controller = get_dt_and_controller(ref_level) - correct_sols, _ = _batch_sde_solve( - keys, - get_terms, - w_shape, - t0, - t1, - y0, - args, - ref_solver, - levy_area, - dt, - step_controller, - bm_tol, - saveat, - ) + if ref_solution is None: + assert ref_solver is not None + dt, step_controller = get_dt_and_controller(ref_level) + correct_sols, _ = _batch_sde_solve( + keys, + get_terms, + w_shape, + t0, + t1, + y0, + args, + ref_solver, + levy_area, + dt, + step_controller, + bm_tol, + saveat, + ) + else: + correct_sols = ref_solution errs_list, steps_list = [], [] for level in range(level_coarse, level_fine + 1): @@ -281,14 +296,21 @@ def sde_solver_strong_order( return steps_arr, errs_arr, order -@dataclasses.dataclass(frozen=True) +@dataclasses.dataclass(unsafe_hash=True) class SDE: get_terms: Callable[[AbstractBrownianPath], AbstractTerm] args: PyTree y0: PyTree[Array] t0: float t1: float - w_shape: tuple[int, ...] + _w_shape: Union[tuple[int, ...], PyTree[jax.ShapeDtypeStruct]] + + @property + def w_shape(self): + if is_tuple_of_ints(self._w_shape): + return self._w_shape + else: + return self._w_shape def get_dtype(self): return jnp.result_type(*jtu.tree_leaves(self.y0)) @@ -299,8 +321,9 @@ def get_bm( levy_area: type[Union[diffrax.BrownianIncrement, diffrax.SpaceTimeLevyArea]], tol: float, ): - shp_dtype = jax.ShapeDtypeStruct(self.w_shape, dtype=self.get_dtype()) - return VirtualBrownianTree(self.t0, self.t1, tol, shp_dtype, bm_key, levy_area) + return VirtualBrownianTree( + self.t0, self.t1, tol, self.w_shape, bm_key, levy_area + ) # A more concise function for use in the examples @@ -313,6 +336,8 @@ def simple_sde_order( get_dt_and_controller, saveat, bm_tol, + levy_area, + ref_solution, ): _, level_fine = levels ref_level = level_fine + 2 @@ -331,6 +356,8 @@ def simple_sde_order( get_dt_and_controller, saveat, bm_tol, + levy_area, + ref_solution, ) @@ -466,3 +493,152 @@ def get_terms(bm): return MultiTerm(ODETerm(_drift), ControlTerm(_diffusion, bm)) return SDE(get_terms, args, y0, t0, t1, (noise_dim,)) + + +def get_bqp(t0=0.3, t1=15.0, dtype=jnp.float32): + grad_f_bqp = lambda x: 4 * x * (jnp.square(x) - 1) + args_bqp = (dtype(0.8), dtype(0.2), grad_f_bqp) + y0_bqp = (dtype(0), dtype(0)) + w_shape_bqp = () + + def get_terms_bqp(bm): + return LangevinTerm(args_bqp, bm, x0=y0_bqp[0]) + + return SDE(get_terms_bqp, None, y0_bqp, t0, t1, w_shape_bqp) + + +def get_harmonic_oscillator(t0=0.3, t1=15.0, dtype=jnp.float32): + gamma_hosc = jnp.array([2, 0.5], dtype=dtype) + u_hosc = jnp.array([0.5, 2], dtype=dtype) + args_hosc = (gamma_hosc, u_hosc, lambda x: 2 * x) + x0 = jnp.zeros((2,), dtype=dtype) + v0 = jnp.zeros((2,), dtype=dtype) + y0_hosc = (x0, v0) + w_shape_hosc = (2,) + + def get_terms_hosc(bm): + return LangevinTerm(args_hosc, bm, x0) + + return SDE(get_terms_hosc, None, y0_hosc, t0, t1, w_shape_hosc) + + +def get_neals_funnel(t0=0.0, t1=16.0, dtype=jnp.float32): + def log_p(x): + z_term = x[0] ** 2 / 6.0 + y_term = jnp.sum(x[1:] ** 2) / jax.lax.stop_gradient(2.0 * jnp.exp(x[0] / 4.0)) + return z_term + y_term + + grad_log_p = jax.grad(log_p) + + gamma = 2.0 + u = 1.0 + args_neal = (gamma, u, grad_log_p) + x0 = jnp.zeros((10,), dtype=dtype) + v0 = jnp.zeros((10,), dtype=dtype) + y0_neal = (x0, v0) + w_shape_neal = (10,) + + def get_terms_neal(bm): + return LangevinTerm(args_neal, bm, x0) + + return SDE(get_terms_neal, None, y0_neal, t0, t1, w_shape_neal) + + +def get_uld3_langevin(t0=0.3, t1=15.0, dtype=jnp.float32): + # Three particles in 3D space with a potential that has three local minima, + # at (2, 2, 2), (-2, -2, -2) and (3, -1, 0). + def single_particle_potential(x): + assert x.shape == (3,) + return 1.0 * ( + jnp.sum((x - 2.0 * jnp.ones((3,), dtype=dtype)) ** 2) + * jnp.sum((x + 2.0 * jnp.ones((3,), dtype=dtype)) ** 2) + * jnp.sum((x - jnp.array([3, -1, 0], dtype=dtype)) ** 2) + ) + + def potential(x): + assert x.shape == (9,) + return ( + single_particle_potential(x[:3]) + + single_particle_potential(x[3:6]) + + single_particle_potential(x[6:]) + ) + + grad_potential = jax.grad(potential) + + def single_circ(x): + assert x.shape == (3,) + return 0.1 * jnp.array([x[1], -x[0], 0.0]) + + def circular_term(x): + assert x.shape == (9,) + return jnp.concatenate( + [ + single_circ(x[:3]), + single_circ(x[3:6]), + single_circ(x[6:]), + ] + ) + + def grad_f(x): + assert x.shape == (9,) + # x0 and x1 will do a circular motion, so we will add a term of the form + force = grad_potential(x) + circular_term(x) + return 10.0 * force / (jnp.sum(jnp.abs(force)) + 10.0) + + u = 1.0 + gamma = 2.0 + args = (u, gamma, grad_f) + x0 = jnp.array([-1, 0, 1, 1, 0, -1, 1, 0, -1], dtype=dtype) + v0 = jnp.zeros((9,), dtype=dtype) + y0_uld3 = (x0, v0) + w_shape_uld3 = (9,) + + def get_terms_uld3(bm): + return LangevinTerm(args, bm, x0) + + return SDE(get_terms_uld3, None, y0_uld3, t0, t1, w_shape_uld3) + + +def get_pytree_langevin(t0=0.3, t1=15.0, dtype=jnp.float32): + def make_pytree(array_factory): + return { + "rr": ( + array_factory((2,), dtype), + array_factory((2,), dtype), + array_factory((2,), dtype), + ), + "qq": ( + array_factory((5,), dtype), + array_factory((3,), dtype), + ), + } + + x0 = make_pytree(jnp.ones) + v0 = make_pytree(jnp.zeros) + y0 = (x0, v0) + + g1 = { + "rr": 0.5 * jnp.ones((2,), dtype), + "qq": ( + jnp.ones((), dtype), + jnp.ones((3,), dtype), + ), + } + + u1 = { + "rr": (jnp.ones((), dtype), 10.0, 5 * jnp.ones((2,), dtype)), + "qq": jnp.ones((), dtype), + } + + def grad_f(x): + xa = x["rr"] + xb = x["qq"] + return {"rr": jtu.tree_map(lambda _x: 0.2 * _x, xa), "qq": xb} + + args = g1, u1, grad_f + w_shape = jtu.tree_map(lambda _x: jax.ShapeDtypeStruct(_x.shape, _x.dtype), x0) + + def get_terms(bm): + return LangevinTerm(args, bm, x0) + + return SDE(get_terms, None, y0, t0, t1, w_shape) diff --git a/test/test_integrate.py b/test/test_integrate.py index 9ed39499..cc16b748 100644 --- a/test/test_integrate.py +++ b/test/test_integrate.py @@ -316,6 +316,8 @@ def get_dt_and_controller(level): get_dt_and_controller, diffrax.SaveAt(t1=True), bm_tol=2.0 ** -(ref_level + 2), + levy_area=None, + ref_solution=None, ) assert -0.2 < order - theoretical_order < 0.2 diff --git a/test/test_langevin.py b/test/test_langevin.py new file mode 100644 index 00000000..ce59e130 --- /dev/null +++ b/test/test_langevin.py @@ -0,0 +1,165 @@ +import diffrax +import jax +import jax.numpy as jnp +import jax.random as jr +import pytest +from diffrax import diffeqsolve, LangevinTerm, SaveAt, VirtualBrownianTree + +from .helpers import ( + _abstract_la_to_la, + get_bqp, + get_harmonic_oscillator, + simple_batch_sde_solve, + simple_sde_order, +) + + +def _only_langevin_solvers_cls(): + yield diffrax.ALIGN + yield diffrax.SORT + yield diffrax.ShOULD + yield diffrax.UBU3 + + +def _solvers_and_orders(): + # solver, order + yield diffrax.ALIGN(0.1), 2.0 + yield diffrax.SORT(0.01), 3.0 + yield diffrax.ShOULD(0.01), 3.0 + yield diffrax.UBU3(0.0), 3.0 + + +@pytest.mark.parametrize("solver_cls", _only_langevin_solvers_cls()) +@pytest.mark.parametrize("taylor", [True, False]) +@pytest.mark.parametrize("dtype", [jnp.float16, jnp.float32, jnp.float64]) +@pytest.mark.parametrize("dim", [1, 4]) +def test_shape(solver_cls, taylor, dtype, dim): + if taylor: + solver = solver_cls(100.0) + else: + solver = solver_cls(0.0) + + t0, t1 = 0.3, 1.0 + saveat = SaveAt(ts=jnp.linspace(t0, t1, 10, dtype=dtype)) + u = jnp.astype(1.0, dtype) + gam = jnp.astype(1.0, dtype) + vec_u = jnp.ones((dim,), dtype=dtype) + vec_gam = jnp.ones((dim,), dtype=dtype) + x0 = jnp.zeros((dim,), dtype=dtype) + v0 = jnp.zeros((dim,), dtype=dtype) + y0 = (x0, v0) + f = lambda x: 0.5 * x + shp_dtype = jax.ShapeDtypeStruct((dim,), dtype) + levy_area = _abstract_la_to_la(solver.minimal_levy_area) + bm = VirtualBrownianTree( + t0, + t1, + tol=2**-4, + shape=shp_dtype, + key=jr.key(4), + levy_area=levy_area, + ) + for args in [ + (gam, u, f), + (vec_gam, u, f), + (gam, vec_u, f), + (vec_gam, vec_u, f), + ]: + terms = LangevinTerm(args, bm, x0) + sol = diffeqsolve( + terms, solver, t0, t1, dt0=0.3, y0=y0, args=None, saveat=saveat + ) + assert sol.ys is not None + for entry in sol.ys: + assert entry.shape == (10, dim) + assert jnp.dtype(entry) == dtype + + +sdes = ( + (get_harmonic_oscillator, "hosc"), + (get_bqp, "bqp"), +) + + +@pytest.fixture(scope="module") +def fine_langevin_solutions(): + bmkey = jr.key(5678) + num_samples = 2000 + bmkeys = jr.split(bmkey, num=num_samples) + t0 = 0.1 + t1 = 5.3 + level_precise = 10 + level_coarse, level_fine = 3, 6 + saveat = diffrax.SaveAt(ts=jnp.linspace(t0, t1, 2**level_coarse + 1, endpoint=True)) + ref_solver = diffrax.ShARK() + levy_area = diffrax.SpaceTimeTimeLevyArea + controller = diffrax.StepTo( + ts=jnp.linspace(t0, t1, 2**level_precise + 1, endpoint=True) + ) + bm_tol = 0.5 * (t1 - t0) * 2**-level_precise + + hosc_sde = get_harmonic_oscillator(t0, t1, jnp.float64) + hosc_sol, _ = simple_batch_sde_solve( + bmkeys, hosc_sde, ref_solver, levy_area, None, controller, bm_tol, saveat + ) + + bqp_sde = get_bqp(t0, t1, jnp.float64) + bqp_sol, _ = simple_batch_sde_solve( + bmkeys, bqp_sde, ref_solver, levy_area, None, controller, bm_tol, saveat + ) + + sols = { + "hosc": hosc_sol, + "bqp": bqp_sol, + } + return sols, t0, t1, bmkeys, saveat, level_coarse, level_fine, levy_area, bm_tol + + +@pytest.mark.parametrize("get_sde,sde_name", sdes) +@pytest.mark.parametrize("solver,theoretical_order", _solvers_and_orders()) +def test_langevin_strong_order( + get_sde, sde_name, solver, theoretical_order, fine_langevin_solutions +): + ( + true_sols, + t0, + t1, + bmkeys, + saveat, + level_coarse, + level_fine, + levy_area, + bm_tol, + ) = fine_langevin_solutions + true_sol = true_sols[sde_name] + + if theoretical_order < 3: + level_fine += 1 + + sde = get_sde(t0, t1, jnp.float64) + + # We specify the times to which we step in way that each level contains all the + # steps of the previous level. This is so that we can compare the solutions at + # all the times in saveat, and not just at the end time. + def get_dt_and_controller(level): + step_ts = jnp.linspace(t0, t1, 2**level + 1, endpoint=True) + return None, diffrax.StepTo(ts=step_ts) + + hs, errors, order = simple_sde_order( + bmkeys, + sde, + solver, + None, + (level_coarse, level_fine), + get_dt_and_controller, + saveat, + bm_tol=bm_tol, + levy_area=levy_area, + ref_solution=true_sol, + ) + # The upper bound needs to be 0.25, otherwise we fail. + # This still preserves a 0.05 buffer between the intervals + # corresponding to the different orders. + assert ( + -0.2 < order - theoretical_order < 0.25 + ), f"order={order}, theoretical_order={theoretical_order}" diff --git a/test/test_sde.py b/test/test_sde.py index d44283d8..cdac924f 100644 --- a/test/test_sde.py +++ b/test/test_sde.py @@ -51,8 +51,8 @@ def _solvers_and_orders(): def test_sde_strong_order_new( solver_ctr, noise: Literal["any", "com", "add"], theoretical_order, dtype ): - bmkey = jr.PRNGKey(5678) - sde_key = jr.PRNGKey(11) + bmkey = jr.key(5678) + sde_key = jr.key(11) num_samples = 100 bmkeys = jr.split(bmkey, num=num_samples) t0 = 0.3 @@ -90,6 +90,8 @@ def get_dt_and_controller(level): get_dt_and_controller, saveat, bm_tol=2**-14, + levy_area=None, + ref_solution=None, ) # The upper bound needs to be 0.25, otherwise we fail. # This still preserves a 0.05 buffer between the intervals @@ -124,8 +126,8 @@ def get_dt_and_controller(level): def test_sde_strong_limit( solver_ctr, noise: Literal["any", "com", "add"], theoretical_order, dtype ): - bmkey = jr.PRNGKey(5678) - sde_key = jr.PRNGKey(11) + bmkey = jr.key(5678) + sde_key = jr.key(11) num_samples = 100 bmkeys = jr.split(bmkey, num=num_samples) t0 = 0.3 @@ -229,7 +231,7 @@ def test_sde_solver_shape(shape, solver_ctr, dtype): additive = solver_ctr in [diffrax.ShARK, diffrax.SRA1, diffrax.SEA] args = (pytree, additive) solver = solver_ctr() - bmkey = jr.PRNGKey(1) + bmkey = jr.key(1) struct = jax.ShapeDtypeStruct((3,), dtype) bm_shape = jtu.tree_map(lambda _: struct, pytree) bm = diffrax.VirtualBrownianTree( @@ -259,7 +261,7 @@ def _drift(t, y, args): y0 = jnp.ones(w_shape, dtype) bm = diffrax.VirtualBrownianTree( - 0.0, 1.0, 0.05, w_shape, jr.PRNGKey(0), diffrax.SpaceTimeLevyArea + 0.0, 1.0, 0.05, w_shape, jr.key(0), diffrax.SpaceTimeLevyArea ) terms = MultiTerm(ODETerm(_drift), WeaklyDiagonalControlTerm(_diffusion, bm)) From cd0ec5e921e8e9d2ffe998f0d16cdd4df45ac76e Mon Sep 17 00:00:00 2001 From: andyElking Date: Sun, 21 Jul 2024 21:58:08 +0100 Subject: [PATCH 02/15] Minor fixes --- diffrax/__init__.py | 2 +- diffrax/_solver/__init__.py | 2 +- diffrax/_solver/align.py | 79 +++++++-------- diffrax/_solver/langevin_srk.py | 116 ++++++++++++---------- diffrax/_solver/{ubu3.py => quicsort.py} | 113 ++++++++++++--------- diffrax/_solver/should.py | 119 +++++++++++++---------- diffrax/_solver/sort_uld.py | 104 +++++++++++--------- diffrax/_term.py | 20 ++-- test/helpers.py | 53 ++-------- test/test_langevin.py | 115 ++++++++++++++-------- 10 files changed, 389 insertions(+), 334 deletions(-) rename diffrax/_solver/{ubu3.py => quicsort.py} (69%) diff --git a/diffrax/__init__.py b/diffrax/__init__.py index f7adb78f..0c3a0a8b 100644 --- a/diffrax/__init__.py +++ b/diffrax/__init__.py @@ -101,6 +101,7 @@ LeapfrogMidpoint as LeapfrogMidpoint, Midpoint as Midpoint, MultiButcherTableau as MultiButcherTableau, + QUICSORT as QUICSORT, Ralston as Ralston, ReversibleHeun as ReversibleHeun, SEA as SEA, @@ -115,7 +116,6 @@ StochasticButcherTableau as StochasticButcherTableau, StratonovichMilstein as StratonovichMilstein, Tsit5 as Tsit5, - UBU3 as UBU3, ) from ._step_size_controller import ( AbstractAdaptiveStepSizeController as AbstractAdaptiveStepSizeController, diff --git a/diffrax/_solver/__init__.py b/diffrax/_solver/__init__.py index fa6d1b63..160a4464 100644 --- a/diffrax/_solver/__init__.py +++ b/diffrax/_solver/__init__.py @@ -27,6 +27,7 @@ ItoMilstein as ItoMilstein, StratonovichMilstein as StratonovichMilstein, ) +from .quicsort import QUICSORT as QUICSORT from .ralston import Ralston as Ralston from .reversible_heun import ReversibleHeun as ReversibleHeun from .runge_kutta import ( @@ -54,4 +55,3 @@ StochasticButcherTableau as StochasticButcherTableau, ) from .tsit5 import Tsit5 as Tsit5 -from .ubu3 import UBU3 as UBU3 diff --git a/diffrax/_solver/align.py b/diffrax/_solver/align.py index 693fdf9a..df25cc15 100644 --- a/diffrax/_solver/align.py +++ b/diffrax/_solver/align.py @@ -1,8 +1,9 @@ import equinox as eqx import jax.numpy as jnp import jax.tree_util as jtu +import numpy as np from equinox.internal import ω -from jaxtyping import Array, PyTree +from jaxtyping import Array, ArrayLike, PyTree from .._custom_types import ( AbstractSpaceTimeLevyArea, @@ -10,23 +11,29 @@ ) from .._local_interpolation import LocalLinearInterpolation from .._term import _LangevinArgs, LangevinTerm, LangevinTuple, LangevinX -from .langevin_srk import _AbstractCoeffs, _SolverState, AbstractLangevinSRK +from .langevin_srk import AbstractCoeffs, AbstractLangevinSRK, SolverState # UBU evaluates at l = (3 -sqrt(3))/6, at r = (3 + sqrt(3))/6 and at 1, # so we need 3 versions of each coefficient -class _ALIGNCoeffs(_AbstractCoeffs): - @property - def dtype(self): - return jtu.tree_leaves(self.beta)[0].dtype +class _ALIGNCoeffs(AbstractCoeffs): + beta: PyTree[ArrayLike] + a1: PyTree[ArrayLike] + b1: PyTree[ArrayLike] + aa: PyTree[ArrayLike] + chh: PyTree[ArrayLike] + dtype: jnp.dtype = eqx.field(static=True) - beta: PyTree[Array] - a1: PyTree[Array] - b1: PyTree[Array] - aa: PyTree[Array] - chh: PyTree[Array] + def __init__(self, beta, a1, b1, aa, chh): + self.beta = beta + self.a1 = a1 + self.b1 = b1 + self.aa = aa + self.chh = chh + all_leaves = jtu.tree_leaves([self.beta, self.a1, self.b1, self.aa, self.chh]) + self.dtype = jnp.result_type(*all_leaves) _ErrorEstimate = LangevinTuple @@ -50,19 +57,16 @@ class ALIGN(AbstractLangevinSRK[_ALIGNCoeffs, _ErrorEstimate]): taylor_threshold: RealScalarLike = eqx.field(static=True) _coeffs_structure = jtu.tree_structure( _ALIGNCoeffs( - beta=jnp.array(0.0), - a1=jnp.array(0.0), - b1=jnp.array(0.0), - aa=jnp.array(0.0), - chh=jnp.array(0.0), + beta=np.array(0.0), + a1=np.array(0.0), + b1=np.array(0.0), + aa=np.array(0.0), + chh=np.array(0.0), ) ) + minimal_levy_area = AbstractSpaceTimeLevyArea - @property - def minimal_levy_area(self): - return AbstractSpaceTimeLevyArea - - def __init__(self, taylor_threshold: RealScalarLike = 0.0): + def __init__(self, taylor_threshold: RealScalarLike = 0.1): r"""**Arguments:** - `taylor_threshold`: If the product `h*gamma` is less than this, then @@ -78,8 +82,8 @@ def order(self, terms): def strong_order(self, terms): return 2.0 - @staticmethod - def _directly_compute_coeffs_leaf(h, c) -> _ALIGNCoeffs: + def _directly_compute_coeffs_leaf(self, h, c) -> _ALIGNCoeffs: + del self # c is a leaf of gamma # compute the coefficients directly (as opposed to via Taylor expansion) al = c * h @@ -91,19 +95,17 @@ def _directly_compute_coeffs_leaf(h, c) -> _ALIGNCoeffs: al2 = al**2 chh = 6 * (beta * (al + 2) + al - 2) / (al2 * c) - out = _ALIGNCoeffs( + return _ALIGNCoeffs( beta=beta, a1=a1, b1=b1, aa=aa, chh=chh, ) - return jtu.tree_map(lambda x: jnp.array(x, dtype=jnp.dtype(c)), out) - @staticmethod - def _tay_cfs_single(c: Array) -> _ALIGNCoeffs: + def _tay_coeffs_single(self, c: Array) -> _ALIGNCoeffs: + del self # c is a leaf of gamma - dtype = jnp.dtype(c) zero = jnp.zeros_like(c) one = jnp.ones_like(c) c2 = jnp.square(c) @@ -117,14 +119,13 @@ def _tay_cfs_single(c: Array) -> _ALIGNCoeffs: aa = jnp.stack([one, -c / 2, c2 / 6, -c3 / 24, c4 / 120, -c5 / 720], axis=-1) chh = jnp.stack([zero, one, -c / 2, 3 * c2 / 20, -c3 / 30, c4 / 168], axis=-1) - out = _ALIGNCoeffs( + return _ALIGNCoeffs( beta=beta, a1=a1, b1=b1, aa=aa, chh=chh, ) - return jtu.tree_map(lambda x: jnp.array(x, dtype=dtype), out) @staticmethod def _compute_step( @@ -133,8 +134,8 @@ def _compute_step( x0: LangevinX, v0: LangevinX, langevin_args: _LangevinArgs, - cfs: _ALIGNCoeffs, - st: _SolverState, + coeffs: _ALIGNCoeffs, + st: SolverState, ) -> tuple[LangevinX, LangevinX, LangevinX, LangevinTuple]: w: LangevinX = levy.W hh: LangevinX = levy.H @@ -145,20 +146,20 @@ def _compute_step( f0 = st.prev_f x1 = ( x0**ω - + cfs.a1**ω * v0**ω - - cfs.b1**ω * uh**ω * f0**ω - + st.rho**ω * (cfs.b1**ω * w**ω + cfs.chh**ω * hh**ω) + + coeffs.a1**ω * v0**ω + - coeffs.b1**ω * uh**ω * f0**ω + + st.rho**ω * (coeffs.b1**ω * w**ω + coeffs.chh**ω * hh**ω) ).ω f1 = f(x1) v1 = ( - cfs.beta**ω * v0**ω - - u**ω * ((cfs.a1**ω - cfs.b1**ω) * f0**ω + cfs.b1**ω * f1**ω) - + st.rho**ω * (cfs.aa**ω * w**ω - gamma**ω * cfs.chh**ω * hh**ω) + coeffs.beta**ω * v0**ω + - u**ω * ((coeffs.a1**ω - coeffs.b1**ω) * f0**ω + coeffs.b1**ω * f1**ω) + + st.rho**ω * (coeffs.aa**ω * w**ω - gamma**ω * coeffs.chh**ω * hh**ω) ).ω error_estimate = ( jtu.tree_map(lambda leaf: jnp.zeros_like(leaf), x0), - (-(u**ω) * cfs.b1**ω * (f1**ω - f0**ω)).ω, + (-(u**ω) * coeffs.b1**ω * (f1**ω - f0**ω)).ω, ) return x1, v1, f1, error_estimate diff --git a/diffrax/_solver/langevin_srk.py b/diffrax/_solver/langevin_srk.py index 96938b02..52022274 100644 --- a/diffrax/_solver/langevin_srk.py +++ b/diffrax/_solver/langevin_srk.py @@ -2,9 +2,11 @@ from typing import Generic, TypeVar import equinox as eqx +import equinox.internal as eqxi import jax.lax as lax import jax.numpy as jnp import jax.tree_util as jtu +from equinox import AbstractVar from jax import vmap from jax._src.tree_util import PyTreeDef from jaxtyping import Array, ArrayLike, PyTree @@ -24,23 +26,20 @@ _ErrorEstimate = TypeVar("_ErrorEstimate", None, LangevinTuple) -class _AbstractCoeffs(eqx.Module): - @property - @abc.abstractmethod - def dtype(self): - raise NotImplementedError +class AbstractCoeffs(eqx.Module): + dtype: AbstractVar[jnp.dtype] -_Coeffs = TypeVar("_Coeffs", bound=_AbstractCoeffs) +_Coeffs = TypeVar("_Coeffs", bound=AbstractCoeffs) # TODO: I'm not sure if I can use the _Coeffs type here, # given that I do not use Generic[_Coeffs] in the class definition. # How should I work around this? -class _SolverState(eqx.Module): +class SolverState(eqx.Module, Generic[_Coeffs]): h: RealScalarLike taylor_coeffs: PyTree[_Coeffs, "LangevinX"] - coeffs: _Coeffs # type: ignore + coeffs: _Coeffs rho: LangevinX prev_f: LangevinX @@ -60,24 +59,36 @@ class _SolverState(eqx.Module): class AbstractLangevinSRK( - AbstractStratonovichSolver[_SolverState], - AbstractItoSolver[_SolverState], + AbstractStratonovichSolver[SolverState], + AbstractItoSolver[SolverState], Generic[_Coeffs, _ErrorEstimate], ): + """Abstract class for Stochastic Runge Kutta methods specifically designed + for Underdamped Langevin Diffusion of the form + + $$d x_t = v_t dt$$ + + $$d v_t = - gamma v_t dt - u ∇f(x_t) dt + (2gammau)^(1/2) dW_t$$ + + where $v$ is the velocity, $f$ is the potential, $gamma$ and $u$ are the + friction and momentum parameters, and $W$ is a Brownian motion. + + Solvers which inherit from this class include ALIGN, SORT, ShOULD, and + QUIC_SORT. + """ + term_structure = LangevinTerm interpolation_cls = LocalLinearInterpolation taylor_threshold: RealScalarLike = eqx.field(static=True) _coeffs_structure: eqx.AbstractClassVar[PyTreeDef] minimal_levy_area: eqx.AbstractClassVar[type[AbstractBrownianIncrement]] - @staticmethod @abc.abstractmethod - def _directly_compute_coeffs_leaf(h, c) -> _Coeffs: + def _directly_compute_coeffs_leaf(self, h, c) -> _Coeffs: raise NotImplementedError - @staticmethod @abc.abstractmethod - def _tay_cfs_single(c: Array) -> _Coeffs: + def _tay_coeffs_single(self, c: Array) -> _Coeffs: raise NotImplementedError def _comp_taylor_coeffs_leaf(self, c: Array) -> _Coeffs: @@ -86,13 +97,8 @@ def _comp_taylor_coeffs_leaf(self, c: Array) -> _Coeffs: # When the step-size h is small the coefficients (which depend on h) need # to be computed via Taylor expansion to ensure numerical stability. # This precomputes the Taylor coefficients (depending on gamma and u), which - # are then multiplied by powers of h, to get the coefficients of ALIGN. - # if jnp.ndim(c) == 0: - # out = self._tay_cfs_single(c) - # else: - # c_axes = tuple(range(c.ndim)) - # out = jax.vmap(self._tay_cfs_single, in_axes=c_axes, out_axes=c_axes)(c) - out = self._tay_cfs_single(c) + # are then multiplied by powers of h, to get the SRK coefficients. + out = self._tay_coeffs_single(c) def check_shape(coeff_leaf): permitted_shapes = [c.shape + (3, 6), c.shape + (1, 6), c.shape + (6,)] @@ -104,19 +110,18 @@ def check_shape(coeff_leaf): return out @staticmethod - def _eval_taylor(h, tay_cfs: _Coeffs) -> _Coeffs: + def _eval_taylor(h, tay_coeffs: _Coeffs) -> _Coeffs: # Multiplies the pre-computed Taylor coefficients by powers of h. - # jax.debug.print("eval taylor for h = {h}", h=h) - dtype = tay_cfs.dtype + dtype = tay_coeffs.dtype h_powers = jnp.power(h, jnp.arange(0, 6, dtype=h.dtype)).astype(dtype) return jtu.tree_map( - lambda tay_leaf: jnp.tensordot(tay_leaf, h_powers, axes=1), tay_cfs + lambda tay_leaf: jnp.tensordot(tay_leaf, h_powers, axes=1), tay_coeffs ) def _recompute_coeffs( - self, h, gamma: LangevinX, tay_cfs: PyTree[_Coeffs] + self, h, gamma: LangevinX, tay_coeffs: PyTree[_Coeffs], state_h ) -> _Coeffs: - def recompute_coeffs_leaf(c: ArrayLike, _tay_cfs: _Coeffs): + def recompute_coeffs_leaf(c: ArrayLike, _tay_coeffs: _Coeffs): # Used when the step-size h changes and coefficients need to be recomputed # Depending on the size of h*gamma choose whether the Taylor expansion or # direct computation is more accurate. @@ -124,12 +129,12 @@ def recompute_coeffs_leaf(c: ArrayLike, _tay_cfs: _Coeffs): if jnp.ndim(c) == 0: return lax.cond( cond, - lambda h_: self._eval_taylor(h_, _tay_cfs), + lambda h_: self._eval_taylor(h_, _tay_coeffs), lambda h_: self._directly_compute_coeffs_leaf(h_, c), h, ) else: - tay_out = self._eval_taylor(h, _tay_cfs) + tay_out = self._eval_taylor(h, _tay_coeffs) if cond.ndim < jtu.tree_leaves(tay_out)[0].ndim: cond = jnp.expand_dims(cond, axis=-1) @@ -151,14 +156,14 @@ def _choose(tay_leaf, direct_leaf): # otherwise, compute both tay_out and direct_out and select the # correct one for each dimension return lax.cond( - jnp.all(cond), lambda _: tay_out, select_tay_or_direct, None + eqxi.unvmap_all(cond), lambda _: tay_out, select_tay_or_direct, None ) - tree_with_cfs = jtu.tree_map(recompute_coeffs_leaf, gamma, tay_cfs) + tree_with_coeffs = jtu.tree_map(recompute_coeffs_leaf, gamma, tay_coeffs) outer = jtu.tree_structure(gamma) inner = self._coeffs_structure - cfs_with_tree = jtu.tree_transpose(outer, inner, tree_with_cfs) - return cfs_with_tree + coeffs_with_tree = jtu.tree_transpose(outer, inner, tree_with_coeffs) + return coeffs_with_tree def init( self, @@ -167,11 +172,11 @@ def init( t1: RealScalarLike, y0: LangevinTuple, args: PyTree, - ) -> _SolverState: + ) -> SolverState: """Precompute _SolverState which carries the Taylor coefficients and the - ALIGN coefficients (which can be computed from h and the Taylor coeffs). - This method is FSAL, so _SolverState also carries the previous evaluation - of grad_f. + SRK coefficients (which can be computed from h and the Taylor coeffs). + Some solvers of this type are FSAL, so _SolverState also carries the previous + evaluation of grad_f. """ assert isinstance(terms, LangevinTerm) gamma, u, f = terms.args # f is in fact grad(f) @@ -186,16 +191,16 @@ def _check_shapes(_c, _u, _x, _v): h = t1 - t0 - tay_cfs = jtu.tree_map(self._comp_taylor_coeffs_leaf, gamma) - # tay_cfs have the same tree structure as gamma, with each leaf being a _Coeffs - # and the arrays have an extra trailing dimension of 6 + tay_coeffs = jtu.tree_map(self._comp_taylor_coeffs_leaf, gamma) + # tay_coeffs have the same tree structure as gamma, with each leaf being a + # _Coeffs and the arrays have an extra trailing dimension of 6 - coeffs = self._recompute_coeffs(h, gamma, tay_cfs) + coeffs = self._recompute_coeffs(h, gamma, tay_coeffs, -1.0) rho = jtu.tree_map(lambda c, _u: jnp.sqrt(2 * c * _u), gamma, u) - state_out = _SolverState( + state_out = SolverState( h=h, - taylor_coeffs=tay_cfs, + taylor_coeffs=tay_coeffs, coeffs=coeffs, rho=rho, prev_f=f(x0), @@ -211,8 +216,8 @@ def _compute_step( x0: LangevinX, v0: LangevinX, langevin_args: _LangevinArgs, - cfs: _Coeffs, - st: _SolverState, + coeffs: _Coeffs, + st: SolverState, ) -> tuple[LangevinX, LangevinX, LangevinX, _ErrorEstimate]: raise NotImplementedError @@ -223,9 +228,9 @@ def step( t1: RealScalarLike, y0: LangevinTuple, args: PyTree, - solver_state: _SolverState, + solver_state: SolverState, made_jump: BoolScalarLike, - ) -> tuple[LangevinTuple, _ErrorEstimate, DenseInfo, _SolverState, RESULTS]: + ) -> tuple[LangevinTuple, _ErrorEstimate, DenseInfo, SolverState, RESULTS]: del made_jump, args st = solver_state h = t1 - t0 @@ -234,12 +239,15 @@ def step( h_state = st.h tay: PyTree[_Coeffs] = st.taylor_coeffs - cfs: _Coeffs = st.coeffs # type: ignore + coeffs: _Coeffs = st.coeffs # If h changed recompute coefficients - cond = jnp.isclose(h_state, h) - cfs = lax.cond( - cond, lambda x: x, lambda _: self._recompute_coeffs(h, gamma, tay), cfs + cond = jnp.isclose(h_state, h, rtol=1e-10, atol=1e-12) + coeffs = lax.cond( + cond, + lambda x: x, + lambda _: self._recompute_coeffs(h, gamma, tay, h_state), + coeffs, ) drift, diffusion = terms.term.terms @@ -252,7 +260,7 @@ def step( x0, v0 = y0 x_out, v_out, f_fsal, error = self._compute_step( - h, levy, x0, v0, terms.args, cfs, st + h, levy, x0, v0, terms.args, coeffs, st ) def check_shapes_dtypes(_x, _v, _f, _x0): @@ -270,10 +278,10 @@ def check_shapes_dtypes(_x, _v, _f, _x0): y1 = (x_out, v_out) dense_info = dict(y0=y0, y1=y1) - st = _SolverState( + st = SolverState( h=h, taylor_coeffs=tay, - coeffs=cfs, + coeffs=coeffs, rho=st.rho, prev_f=f_fsal, ) diff --git a/diffrax/_solver/ubu3.py b/diffrax/_solver/quicsort.py similarity index 69% rename from diffrax/_solver/ubu3.py rename to diffrax/_solver/quicsort.py index 0f1db131..d6b6e4fd 100644 --- a/diffrax/_solver/ubu3.py +++ b/diffrax/_solver/quicsort.py @@ -4,8 +4,9 @@ import jax import jax.numpy as jnp import jax.tree_util as jtu +import numpy as np from equinox.internal import ω -from jaxtyping import Array, PyTree +from jaxtyping import Array, ArrayLike, PyTree from .._custom_types import ( AbstractSpaceTimeTimeLevyArea, @@ -13,27 +14,53 @@ ) from .._local_interpolation import LocalLinearInterpolation from .._term import _LangevinArgs, LangevinTerm, LangevinX -from .langevin_srk import _AbstractCoeffs, _SolverState, AbstractLangevinSRK +from .langevin_srk import AbstractCoeffs, AbstractLangevinSRK, SolverState # UBU evaluates at l = (3 -sqrt(3))/6, at r = (3 + sqrt(3))/6 and at 1, # so we need 3 versions of each coefficient -class _UBU3Coeffs(_AbstractCoeffs): - @property - def dtype(self): - return jtu.tree_leaves(self.beta_lr1)[0].dtype +class _QUICSORTCoeffs(AbstractCoeffs): + beta_lr1: PyTree[ArrayLike] # (gamma, 3, *taylor) + a_lr1: PyTree[ArrayLike] # (gamma, 3, *taylor) + b_lr1: PyTree[ArrayLike] # (gamma, 3, *taylor) + a_third: PyTree[ArrayLike] # (gamma, 1, *taylor) + a_div_h: PyTree[ArrayLike] # (gamma, 1, *taylor) + dtype: jnp.dtype = eqx.field(static=True) + + def __init__(self, beta_lr1, a_lr1, b_lr1, a_third, a_div_h): + self.beta_lr1 = beta_lr1 + self.a_lr1 = a_lr1 + self.b_lr1 = b_lr1 + self.a_third = a_third + self.a_div_h = a_div_h + all_leaves = jtu.tree_leaves( + [self.beta_lr1, self.a_lr1, self.b_lr1, self.a_third, self.a_div_h] + ) + self.dtype = jnp.result_type(*all_leaves) + - beta_lr1: PyTree[Array] # (gamma, 3, *taylor) - a_lr1: PyTree[Array] # (gamma, 3, *taylor) - b_lr1: PyTree[Array] # (gamma, 3, *taylor) - a_third: PyTree[Array] # (gamma, 1, *taylor) - a_div_h: PyTree[Array] # (gamma, 1, *taylor) +class QUICSORT(AbstractLangevinSRK[_QUICSORTCoeffs, None]): + r"""The QUadrature Inspired and Contractive Shifted ODE with Runge-Kutta Three + method by Daire O'Kane and James Foster, which is a third order version of the + UBU method from + ??? cite "Reference" + + ```bibtex + @misc{chada2024unbiased, + title={Unbiased Kinetic Langevin Monte Carlo with Inexact Gradients}, + author={Neil K. Chada and Benedict Leimkuhler and Daniel Paulin + and Peter A. Whalley}, + year={2024}, + eprint={2311.05025}, + archivePrefix={arXiv}, + primaryClass={stat.CO}, + url={https://arxiv.org/abs/2311.05025}, + } + ``` -class UBU3(AbstractLangevinSRK[_UBU3Coeffs, None]): - r"""The third order version of the UBU method by Daire O'Kane and James Foster. Works for underdamped Langevin SDEs of the form $$d x_t = v_t dt$$ @@ -48,20 +75,17 @@ class UBU3(AbstractLangevinSRK[_UBU3Coeffs, None]): interpolation_cls = LocalLinearInterpolation taylor_threshold: RealScalarLike = eqx.field(static=True) _coeffs_structure = jtu.tree_structure( - _UBU3Coeffs( - beta_lr1=jnp.array(0.0), - a_lr1=jnp.array(0.0), - b_lr1=jnp.array(0.0), - a_third=jnp.array(0.0), - a_div_h=jnp.array(0.0), + _QUICSORTCoeffs( + beta_lr1=np.array(0.0), + a_lr1=np.array(0.0), + b_lr1=np.array(0.0), + a_third=np.array(0.0), + a_div_h=np.array(0.0), ) ) + minimal_levy_area = AbstractSpaceTimeTimeLevyArea - @property - def minimal_levy_area(self): - return AbstractSpaceTimeTimeLevyArea - - def __init__(self, taylor_threshold: RealScalarLike = 0.0): + def __init__(self, taylor_threshold: RealScalarLike = 0.1): r"""**Arguments:** - `taylor_threshold`: If the product `h*gamma` is less than this, then @@ -77,10 +101,9 @@ def order(self, terms): def strong_order(self, terms): return 3.0 - @staticmethod - def _directly_compute_coeffs_leaf(h, c) -> _UBU3Coeffs: + def _directly_compute_coeffs_leaf(self, h, c) -> _QUICSORTCoeffs: + del self # compute the coefficients directly (as opposed to via Taylor expansion) - dtype = jnp.dtype(c) original_shape = c.shape c = jnp.expand_dims(c, axis=c.ndim) alpha = c * h @@ -99,17 +122,16 @@ def _directly_compute_coeffs_leaf(h, c) -> _UBU3Coeffs: assert a_third.shape == a_div_h.shape == original_shape + (1,) - out = _UBU3Coeffs( + return _QUICSORTCoeffs( beta_lr1=beta_lr1, a_lr1=a_lr1, b_lr1=b_lr1, a_third=a_third, a_div_h=a_div_h, ) - return jtu.tree_map(lambda x: jnp.array(x, dtype=dtype), out) - @staticmethod - def _tay_cfs_single(c: Array) -> _UBU3Coeffs: + def _tay_coeffs_single(self, c: Array) -> _QUICSORTCoeffs: + del self # c is a leaf of gamma dtype = jnp.dtype(c) zero = jnp.zeros_like(c) @@ -148,14 +170,13 @@ def _tay_cfs_single(c: Array) -> _UBU3Coeffs: a_div_h = jnp.expand_dims(a_div_h, axis=c.ndim) assert a_third.shape == a_div_h.shape == c.shape + (1, 6) - out = _UBU3Coeffs( + return _QUICSORTCoeffs( beta_lr1=beta_lr1, a_lr1=a_lr1, b_lr1=b_lr1, a_third=a_third, a_div_h=a_div_h, ) - return jtu.tree_map(lambda x: jnp.array(x, dtype=dtype), out) @staticmethod def _compute_step( @@ -164,8 +185,8 @@ def _compute_step( x0: LangevinX, v0: LangevinX, langevin_args: _LangevinArgs, - cfs: _UBU3Coeffs, - st: _SolverState, + coeffs: _QUICSORTCoeffs, + st: SolverState, ) -> tuple[LangevinX, LangevinX, LangevinX, None]: w: LangevinX = levy.W hh: LangevinX = levy.H @@ -182,17 +203,17 @@ def _r(coeff): def _one(coeff): return jtu.tree_map(lambda arr: arr[..., 2], coeff) - beta_l = _l(cfs.beta_lr1) - beta_r = _r(cfs.beta_lr1) - beta_1 = _one(cfs.beta_lr1) - a_l = _l(cfs.a_lr1) - a_r = _r(cfs.a_lr1) - a_1 = _one(cfs.a_lr1) - b_l = _l(cfs.b_lr1) - b_r = _r(cfs.b_lr1) - b_1 = _one(cfs.b_lr1) - a_third = _l(cfs.a_third) - a_div_h = _l(cfs.a_div_h) + beta_l = _l(coeffs.beta_lr1) + beta_r = _r(coeffs.beta_lr1) + beta_1 = _one(coeffs.beta_lr1) + a_l = _l(coeffs.a_lr1) + a_r = _r(coeffs.a_lr1) + a_1 = _one(coeffs.a_lr1) + b_l = _l(coeffs.b_lr1) + b_r = _r(coeffs.b_lr1) + b_1 = _one(coeffs.b_lr1) + a_third = _l(coeffs.a_third) + a_div_h = _l(coeffs.a_div_h) rho_w_k = (st.rho**ω * (w**ω - 12 * kk**ω)).ω uh = (u**ω * h).ω diff --git a/diffrax/_solver/should.py b/diffrax/_solver/should.py index b2d48546..c84b88e1 100644 --- a/diffrax/_solver/should.py +++ b/diffrax/_solver/should.py @@ -1,8 +1,9 @@ import equinox as eqx import jax.numpy as jnp import jax.tree_util as jtu +import numpy as np from equinox.internal import ω -from jaxtyping import Array, PyTree +from jaxtyping import Array, ArrayLike, PyTree from .._custom_types import ( AbstractSpaceTimeTimeLevyArea, @@ -10,27 +11,49 @@ ) from .._local_interpolation import LocalLinearInterpolation from .._term import _LangevinArgs, LangevinTerm, LangevinX -from .langevin_srk import _AbstractCoeffs, _SolverState, AbstractLangevinSRK +from .langevin_srk import AbstractCoeffs, AbstractLangevinSRK, SolverState # UBU evaluates at l = (3 -sqrt(3))/6, at r = (3 + sqrt(3))/6 and at 1, # so we need 3 versions of each coefficient -class _ShOULDCoeffs(_AbstractCoeffs): - @property - def dtype(self): - return jtu.tree_leaves(self.beta1)[0].dtype - - beta_half: PyTree[Array] - a_half: PyTree[Array] - b_half: PyTree[Array] - beta1: PyTree[Array] - a1: PyTree[Array] - b1: PyTree[Array] - aa: PyTree[Array] - chh: PyTree[Array] - ckk: PyTree[Array] +class _ShOULDCoeffs(AbstractCoeffs): + beta_half: PyTree[ArrayLike] + a_half: PyTree[ArrayLike] + b_half: PyTree[ArrayLike] + beta1: PyTree[ArrayLike] + a1: PyTree[ArrayLike] + b1: PyTree[ArrayLike] + aa: PyTree[ArrayLike] + chh: PyTree[ArrayLike] + ckk: PyTree[ArrayLike] + dtype: jnp.dtype = eqx.field(static=True) + + def __init__(self, beta_half, a_half, b_half, beta1, a1, b1, aa, chh, ckk): + self.beta_half = beta_half + self.a_half = a_half + self.b_half = b_half + self.beta1 = beta1 + self.a1 = a1 + self.b1 = b1 + self.aa = aa + self.chh = chh + self.ckk = ckk + all_leaves = jtu.tree_leaves( + [ + self.beta_half, + self.a_half, + self.b_half, + self.beta1, + self.a1, + self.b1, + self.aa, + self.chh, + self.ckk, + ] + ) + self.dtype = jnp.result_type(*all_leaves) class ShOULD(AbstractLangevinSRK[_ShOULDCoeffs, None]): @@ -51,23 +74,20 @@ class ShOULD(AbstractLangevinSRK[_ShOULDCoeffs, None]): taylor_threshold: RealScalarLike = eqx.field(static=True) _coeffs_structure = jtu.tree_structure( _ShOULDCoeffs( - beta_half=jnp.array(0.0), - a_half=jnp.array(0.0), - b_half=jnp.array(0.0), - beta1=jnp.array(0.0), - a1=jnp.array(0.0), - b1=jnp.array(0.0), - aa=jnp.array(0.0), - chh=jnp.array(0.0), - ckk=jnp.array(0.0), + beta_half=np.array(0.0), + a_half=np.array(0.0), + b_half=np.array(0.0), + beta1=np.array(0.0), + a1=np.array(0.0), + b1=np.array(0.0), + aa=np.array(0.0), + chh=np.array(0.0), + ckk=np.array(0.0), ) ) + minimal_levy_area = AbstractSpaceTimeTimeLevyArea - @property - def minimal_levy_area(self): - return AbstractSpaceTimeTimeLevyArea - - def __init__(self, taylor_threshold: RealScalarLike = 0.0): + def __init__(self, taylor_threshold: RealScalarLike = 0.1): r"""**Arguments:** - `taylor_threshold`: If the product `h*gamma` is less than this, then @@ -83,8 +103,8 @@ def order(self, terms): def strong_order(self, terms): return 3.0 - @staticmethod - def _directly_compute_coeffs_leaf(h, c) -> _ShOULDCoeffs: + def _directly_compute_coeffs_leaf(self, h, c) -> _ShOULDCoeffs: + del self # c is a leaf of gamma # compute the coefficients directly (as opposed to via Taylor expansion) al = c * h @@ -101,7 +121,7 @@ def _directly_compute_coeffs_leaf(h, c) -> _ShOULDCoeffs: chh = 6 * (beta1 * (al + 2) + al - 2) / (al2 * c) ckk = 60 * (beta1 * (al * (al + 6) + 12) - al * (al - 6) - 12) / (al3 * c) - out = _ShOULDCoeffs( + return _ShOULDCoeffs( beta_half=beta_half, a_half=a_half, b_half=b_half, @@ -112,14 +132,12 @@ def _directly_compute_coeffs_leaf(h, c) -> _ShOULDCoeffs: chh=chh, ckk=ckk, ) - return jtu.tree_map(lambda x: jnp.array(x, dtype=jnp.dtype(c)), out) - @staticmethod - def _tay_cfs_single(c: Array) -> _ShOULDCoeffs: + def _tay_coeffs_single(self, c: Array) -> _ShOULDCoeffs: + del self # c is a leaf of gamma zero = jnp.zeros_like(c) one = jnp.ones_like(c) - dtype = jnp.dtype(c) c2 = jnp.square(c) c3 = c2 * c c4 = c3 * c @@ -146,7 +164,7 @@ def _tay_cfs_single(c: Array) -> _ShOULDCoeffs: chh = jnp.stack([zero, one, -c / 2, 3 * c2 / 20, -c3 / 30, c4 / 168], axis=-1) ckk = jnp.stack([zero, zero, -c, c2 / 2, -c3 / 7, 5 * c4 / 168], axis=-1) - out = _ShOULDCoeffs( + return _ShOULDCoeffs( beta_half=beta_half, a_half=a_half, b_half=b_half, @@ -157,7 +175,6 @@ def _tay_cfs_single(c: Array) -> _ShOULDCoeffs: chh=chh, ckk=ckk, ) - return jtu.tree_map(lambda x: jnp.array(x, dtype=dtype), out) @staticmethod def _compute_step( @@ -166,8 +183,8 @@ def _compute_step( x0: LangevinX, v0: LangevinX, langevin_args: _LangevinArgs, - cfs: _ShOULDCoeffs, - st: _SolverState, + coeffs: _ShOULDCoeffs, + st: SolverState, ) -> tuple[LangevinX, LangevinX, LangevinX, None]: w: LangevinX = levy.W hh: LangevinX = levy.H @@ -182,29 +199,29 @@ def _compute_step( v1 = (v0**ω + st.rho**ω * (hh**ω + 6 * kk**ω)).ω x1 = ( x0**ω - + cfs.a_half**ω * v1**ω - + cfs.b_half**ω * (-(uh**ω) * f0**ω + rho_w_k**ω) + + coeffs.a_half**ω * v1**ω + + coeffs.b_half**ω * (-(uh**ω) * f0**ω + rho_w_k**ω) ).ω f1 = f(x1) - chh_hh_plus_ckk_kk = (cfs.chh**ω * hh**ω + cfs.ckk**ω * kk**ω).ω + chh_hh_plus_ckk_kk = (coeffs.chh**ω * hh**ω + coeffs.ckk**ω * kk**ω).ω x_out = ( x0**ω - + cfs.a1**ω * v0**ω - - uh**ω * cfs.b1**ω * (1 / 3 * f0**ω + 2 / 3 * f1**ω) - + st.rho**ω * (cfs.b1**ω * w**ω + chh_hh_plus_ckk_kk**ω) + + coeffs.a1**ω * v0**ω + - uh**ω * coeffs.b1**ω * (1 / 3 * f0**ω + 2 / 3 * f1**ω) + + st.rho**ω * (coeffs.b1**ω * w**ω + chh_hh_plus_ckk_kk**ω) ).ω f_out = f(x_out) v_out = ( - cfs.beta1**ω * v0**ω + coeffs.beta1**ω * v0**ω - uh**ω * ( - cfs.beta1**ω / 6 * f0**ω - + 2 / 3 * cfs.beta_half**ω * f1**ω + coeffs.beta1**ω / 6 * f0**ω + + 2 / 3 * coeffs.beta_half**ω * f1**ω + 1 / 6 * f_out**ω ) - + st.rho**ω * (cfs.aa**ω * w**ω - gamma**ω * chh_hh_plus_ckk_kk**ω) + + st.rho**ω * (coeffs.aa**ω * w**ω - gamma**ω * chh_hh_plus_ckk_kk**ω) ).ω return x_out, v_out, f_out, None diff --git a/diffrax/_solver/sort_uld.py b/diffrax/_solver/sort_uld.py index 00b13675..ce5efd19 100644 --- a/diffrax/_solver/sort_uld.py +++ b/diffrax/_solver/sort_uld.py @@ -1,8 +1,9 @@ import equinox as eqx import jax.numpy as jnp import jax.tree_util as jtu +import numpy as np from equinox.internal import ω -from jaxtyping import Array, PyTree +from jaxtyping import Array, ArrayLike, PyTree from .._custom_types import ( AbstractSpaceTimeTimeLevyArea, @@ -10,25 +11,43 @@ ) from .._local_interpolation import LocalLinearInterpolation from .._term import _LangevinArgs, LangevinTerm, LangevinX -from .langevin_srk import _AbstractCoeffs, _SolverState, AbstractLangevinSRK +from .langevin_srk import AbstractCoeffs, AbstractLangevinSRK, SolverState # UBU evaluates at l = (3 -sqrt(3))/6, at r = (3 + sqrt(3))/6 and at 1, # so we need 3 versions of each coefficient -class _SORTCoeffs(_AbstractCoeffs): - @property - def dtype(self): - return jtu.tree_leaves(self.beta1)[0].dtype - - beta_half: PyTree[Array] - a_half: PyTree[Array] - b_half: PyTree[Array] - beta1: PyTree[Array] - a1: PyTree[Array] - b1: PyTree[Array] - aa: PyTree[Array] +class _SORTCoeffs(AbstractCoeffs): + beta_half: PyTree[ArrayLike] + a_half: PyTree[ArrayLike] + b_half: PyTree[ArrayLike] + beta1: PyTree[ArrayLike] + a1: PyTree[ArrayLike] + b1: PyTree[ArrayLike] + aa: PyTree[ArrayLike] + dtype: jnp.dtype = eqx.field(static=True) + + def __init__(self, beta_half, a_half, b_half, beta1, a1, b1, aa): + self.beta_half = beta_half + self.a_half = a_half + self.b_half = b_half + self.beta1 = beta1 + self.a1 = a1 + self.b1 = b1 + self.aa = aa + all_leaves = jtu.tree_leaves( + [ + self.beta_half, + self.a_half, + self.b_half, + self.beta1, + self.a1, + self.b1, + self.aa, + ] + ) + self.dtype = jnp.result_type(*all_leaves) class SORT(AbstractLangevinSRK[_SORTCoeffs, None]): @@ -49,21 +68,18 @@ class SORT(AbstractLangevinSRK[_SORTCoeffs, None]): taylor_threshold: RealScalarLike = eqx.field(static=True) _coeffs_structure = jtu.tree_structure( _SORTCoeffs( - beta_half=jnp.array(0.0), - a_half=jnp.array(0.0), - b_half=jnp.array(0.0), - beta1=jnp.array(0.0), - a1=jnp.array(0.0), - b1=jnp.array(0.0), - aa=jnp.array(0.0), + beta_half=np.array(0.0), + a_half=np.array(0.0), + b_half=np.array(0.0), + beta1=np.array(0.0), + a1=np.array(0.0), + b1=np.array(0.0), + aa=np.array(0.0), ) ) + minimal_levy_area = AbstractSpaceTimeTimeLevyArea - @property - def minimal_levy_area(self): - return AbstractSpaceTimeTimeLevyArea - - def __init__(self, taylor_threshold: RealScalarLike = 0.0): + def __init__(self, taylor_threshold: RealScalarLike = 0.1): r"""**Arguments:** - `taylor_threshold`: If the product `h*gamma` is less than this, then @@ -79,8 +95,8 @@ def order(self, terms): def strong_order(self, terms): return 3.0 - @staticmethod - def _directly_compute_coeffs_leaf(h, c) -> _SORTCoeffs: + def _directly_compute_coeffs_leaf(self, h, c) -> _SORTCoeffs: + del self # c is a leaf of gamma # compute the coefficients directly (as opposed to via Taylor expansion) al = c * h @@ -92,7 +108,7 @@ def _directly_compute_coeffs_leaf(h, c) -> _SORTCoeffs: b1 = (beta1 + al - 1) / (al * c) aa = a1 / h - out = _SORTCoeffs( + return _SORTCoeffs( beta_half=beta_half, a_half=a_half, b_half=b_half, @@ -101,12 +117,10 @@ def _directly_compute_coeffs_leaf(h, c) -> _SORTCoeffs: b1=b1, aa=aa, ) - return jtu.tree_map(lambda x: jnp.array(x, dtype=jnp.dtype(c)), out) - @staticmethod - def _tay_cfs_single(c: Array) -> _SORTCoeffs: + def _tay_coeffs_single(self, c: Array) -> _SORTCoeffs: + del self # c is a leaf of gamma - dtype = jnp.dtype(c) zero = jnp.zeros_like(c) one = jnp.ones_like(c) c2 = jnp.square(c) @@ -131,7 +145,7 @@ def _tay_cfs_single(c: Array) -> _SORTCoeffs: [zero, one / 8, -c / 48, c2 / 384, -c3 / 3840, c4 / 46080], axis=-1 ) b1 = jnp.stack([zero, one / 2, -c / 6, c2 / 24, -c3 / 120, c4 / 720], axis=-1) - out = _SORTCoeffs( + return _SORTCoeffs( beta_half=beta_half, a_half=a_half, b_half=b_half, @@ -141,8 +155,6 @@ def _tay_cfs_single(c: Array) -> _SORTCoeffs: aa=aa, ) - return jtu.tree_map(lambda x: jnp.array(x, dtype=dtype), out) - @staticmethod def _compute_step( h: RealScalarLike, @@ -150,8 +162,8 @@ def _compute_step( x0: LangevinX, v0: LangevinX, langevin_args: _LangevinArgs, - cfs: _SORTCoeffs, - st: _SolverState, + coeffs: _SORTCoeffs, + st: SolverState, ) -> tuple[LangevinX, LangevinX, LangevinX, None]: w: LangevinX = levy.W hh: LangevinX = levy.H @@ -166,25 +178,25 @@ def _compute_step( v1 = (v0**ω + st.rho**ω * (hh**ω + 6 * kk**ω)).ω x1 = ( x0**ω - + cfs.a_half**ω * v1**ω - + cfs.b_half**ω * (-(uh**ω) * f0**ω + rho_w_k**ω) + + coeffs.a_half**ω * v1**ω + + coeffs.b_half**ω * (-(uh**ω) * f0**ω + rho_w_k**ω) ).ω f1 = f(x1) x_out = ( x0**ω - + cfs.a1**ω * v1**ω - + cfs.b1**ω * (-(uh**ω) * (1 / 3 * f0**ω + 2 / 3 * f1**ω) + rho_w_k**ω) + + coeffs.a1**ω * v1**ω + + coeffs.b1**ω * (-(uh**ω) * (1 / 3 * f0**ω + 2 / 3 * f1**ω) + rho_w_k**ω) ).ω f_out = f(x_out) v_out = ( - cfs.beta1**ω * v1**ω + coeffs.beta1**ω * v1**ω - uh**ω * ( - cfs.beta1**ω / 6 * f0**ω - + 2 / 3 * cfs.beta_half**ω * f1**ω + coeffs.beta1**ω / 6 * f0**ω + + 2 / 3 * coeffs.beta_half**ω * f1**ω + 1 / 6 * f_out**ω ) - + cfs.aa**ω * rho_w_k**ω + + coeffs.aa**ω * rho_w_k**ω - st.rho**ω * (hh**ω - 6 * kk**ω) ).ω diff --git a/diffrax/_term.py b/diffrax/_term.py index 8037d40f..2b6272a0 100644 --- a/diffrax/_term.py +++ b/diffrax/_term.py @@ -787,6 +787,10 @@ def _to_vjp(_y, _diff_args, _diff_term): return dy, da_y, da_diff_args, da_diff_term +# The Underdamped Langevin SDE trajectory consists of two components: the position +# `x` and the velocity `v`. Both of these have the same shape. So, by LangevinX we +# denote the shape of the x component, and by LangevinTuple we denote the shape of +# the tuple (x, v). LangevinX = PyTree[Shaped[Array, "?*langevin"], "LangevinX"] LangevinTuple = tuple[LangevinX, LangevinX] _LangevinBM = TypeVar("_LangevinBM", bound=Union[LangevinX, AbstractBrownianIncrement]) @@ -795,10 +799,10 @@ def _to_vjp(_y, _diff_args, _diff_term): class _LangevinDiffusionTerm(AbstractTerm[LangevinX, _LangevinBM]): r"""Represents the diffusion term in the Langevin SDE: - $d \mathbf{x}_t = \mathbf{v}_t \, dt$ + $d \mathbf{x}_t = \mathbf{v}_t dt$ - $d \mathbf{v}_t = - \gamma \, \mathbf{v}_t \, dt - u \, - \nabla \! f( \mathbf{x}_t ) \, dt + \sqrt{2 \gamma u} \, d W_t.$ + $d \mathbf{v}_t = - \gamma \mathbf{v}_t dt - u + \nabla f( \mathbf{x}_t ) dt + \sqrt{2 \gamma u} d W_t.$ """ gamma: LangevinX @@ -866,15 +870,15 @@ def _inner_broadcast(_src_arr, _inner_tree_shape): class LangevinTerm(AbstractTerm): r"""Used to represent the Langevin SDE, given by: - $d \mathbf{x}_t = \mathbf{v}_t \, dt$ + $d \mathbf{x}_t = \mathbf{v}_t dt$ - $d \mathbf{v}_t = - \gamma \, \mathbf{v}_t \, dt - u \, - \nabla \! f( \mathbf{x}_t ) \, dt + \sqrt{2 \gamma u} \, d W_t.$ + $d \mathbf{v}_t = - \gamma \mathbf{v}_t dt - u + \nabla f( \mathbf{x}_t ) dt + \sqrt{2 \gamma u} d W_t.$ where $\mathbf{x}_t, \mathbf{v}_t \in \mathbb{R}^d$ represent the position and velocity, $W$ is a Brownian motion in $\mathbb{R}^d$, $f: \mathbb{R}^d \rightarrow \mathbb{R}$ is a potential function, and - $ \gamma,\, u\in\mathbb{R}^{d\times d}$ are diagonal matrices representing + $ \gamma,u\in\mathbb{R}^{d\times d}$ are diagonal matrices representing friction and a dampening parameter. """ @@ -884,7 +888,7 @@ class LangevinTerm(AbstractTerm): def __init__(self, args, bm: AbstractBrownianPath, x0: LangevinX): r"""**Arguments:** - - `args`: a tuple of the form $(\gamma, \, u, \, \nabla \! f)$ + - `args`: a tuple of the form $(\gamma, u, \nabla f)$ - `bm`: a Brownian path - `x0`: a point in the state space of the process (position only), needed to determine the PyTree structure and shape of the process. diff --git a/test/helpers.py b/test/helpers.py index ab03598b..ac7af0a1 100644 --- a/test/helpers.py +++ b/test/helpers.py @@ -318,7 +318,13 @@ def get_dtype(self): def get_bm( self, bm_key: PRNGKeyArray, - levy_area: type[Union[diffrax.BrownianIncrement, diffrax.SpaceTimeLevyArea]], + levy_area: type[ + Union[ + diffrax.BrownianIncrement, + diffrax.SpaceTimeLevyArea, + diffrax.SpaceTimeTimeLevyArea, + ] + ], tol: float, ): return VirtualBrownianTree( @@ -597,48 +603,3 @@ def get_terms_uld3(bm): return LangevinTerm(args, bm, x0) return SDE(get_terms_uld3, None, y0_uld3, t0, t1, w_shape_uld3) - - -def get_pytree_langevin(t0=0.3, t1=15.0, dtype=jnp.float32): - def make_pytree(array_factory): - return { - "rr": ( - array_factory((2,), dtype), - array_factory((2,), dtype), - array_factory((2,), dtype), - ), - "qq": ( - array_factory((5,), dtype), - array_factory((3,), dtype), - ), - } - - x0 = make_pytree(jnp.ones) - v0 = make_pytree(jnp.zeros) - y0 = (x0, v0) - - g1 = { - "rr": 0.5 * jnp.ones((2,), dtype), - "qq": ( - jnp.ones((), dtype), - jnp.ones((3,), dtype), - ), - } - - u1 = { - "rr": (jnp.ones((), dtype), 10.0, 5 * jnp.ones((2,), dtype)), - "qq": jnp.ones((), dtype), - } - - def grad_f(x): - xa = x["rr"] - xb = x["qq"] - return {"rr": jtu.tree_map(lambda _x: 0.2 * _x, xa), "qq": xb} - - args = g1, u1, grad_f - w_shape = jtu.tree_map(lambda _x: jax.ShapeDtypeStruct(_x.shape, _x.dtype), x0) - - def get_terms(bm): - return LangevinTerm(args, bm, x0) - - return SDE(get_terms, None, y0, t0, t1, w_shape) diff --git a/test/test_langevin.py b/test/test_langevin.py index ce59e130..6690ca8b 100644 --- a/test/test_langevin.py +++ b/test/test_langevin.py @@ -2,13 +2,14 @@ import jax import jax.numpy as jnp import jax.random as jr +import jax.tree_util as jtu import pytest -from diffrax import diffeqsolve, LangevinTerm, SaveAt, VirtualBrownianTree +from diffrax import diffeqsolve, LangevinTerm, SaveAt from .helpers import ( - _abstract_la_to_la, get_bqp, get_harmonic_oscillator, + SDE, simple_batch_sde_solve, simple_sde_order, ) @@ -16,63 +17,93 @@ def _only_langevin_solvers_cls(): yield diffrax.ALIGN - yield diffrax.SORT yield diffrax.ShOULD - yield diffrax.UBU3 + yield diffrax.QUICSORT def _solvers_and_orders(): # solver, order yield diffrax.ALIGN(0.1), 2.0 - yield diffrax.SORT(0.01), 3.0 - yield diffrax.ShOULD(0.01), 3.0 - yield diffrax.UBU3(0.0), 3.0 + yield diffrax.ShOULD(0.1), 3.0 + yield diffrax.QUICSORT(0.1), 3.0 + + +def get_pytree_langevin(t0=0.3, t1=1.0, dtype=jnp.float32): + def make_pytree(array_factory): + return { + "rr": ( + array_factory((2,), dtype), + array_factory((2,), dtype), + ), + "qq": ( + array_factory((2,), dtype), + array_factory((3,), dtype), + ), + } + + x0 = make_pytree(jnp.ones) + v0 = make_pytree(jnp.zeros) + y0 = (x0, v0) + + g1 = { + "rr": 0.001 * jnp.ones((2,), dtype), + "qq": ( + jnp.ones((), dtype), + 10 * jnp.ones((3,), dtype), + ), + } + + u1 = { + "rr": (jnp.ones((), dtype), 10.0), + "qq": jnp.ones((), dtype), + } + + def grad_f(x): + xa = x["rr"] + xb = x["qq"] + return {"rr": jtu.tree_map(lambda _x: 0.2 * _x, xa), "qq": xb} + + args = g1, u1, grad_f + w_shape = jtu.tree_map(lambda _x: jax.ShapeDtypeStruct(_x.shape, _x.dtype), x0) + + def get_terms(bm): + return LangevinTerm(args, bm, x0) + + return SDE(get_terms, None, y0, t0, t1, w_shape) @pytest.mark.parametrize("solver_cls", _only_langevin_solvers_cls()) @pytest.mark.parametrize("taylor", [True, False]) @pytest.mark.parametrize("dtype", [jnp.float16, jnp.float32, jnp.float64]) -@pytest.mark.parametrize("dim", [1, 4]) -def test_shape(solver_cls, taylor, dtype, dim): +def test_shape(solver_cls, taylor, dtype): if taylor: solver = solver_cls(100.0) else: - solver = solver_cls(0.0) + solver = solver_cls(0.01) t0, t1 = 0.3, 1.0 - saveat = SaveAt(ts=jnp.linspace(t0, t1, 10, dtype=dtype)) - u = jnp.astype(1.0, dtype) - gam = jnp.astype(1.0, dtype) - vec_u = jnp.ones((dim,), dtype=dtype) - vec_gam = jnp.ones((dim,), dtype=dtype) - x0 = jnp.zeros((dim,), dtype=dtype) - v0 = jnp.zeros((dim,), dtype=dtype) - y0 = (x0, v0) - f = lambda x: 0.5 * x - shp_dtype = jax.ShapeDtypeStruct((dim,), dtype) - levy_area = _abstract_la_to_la(solver.minimal_levy_area) - bm = VirtualBrownianTree( - t0, - t1, - tol=2**-4, - shape=shp_dtype, - key=jr.key(4), - levy_area=levy_area, + dt0 = 0.3 + saveat = SaveAt(ts=jnp.linspace(t0, t1, 7, dtype=dtype)) + + sde = get_pytree_langevin(t0, t1, dtype) + bm = sde.get_bm(jr.key(5678), diffrax.SpaceTimeTimeLevyArea, tol=0.2) + terms = sde.get_terms(bm) + + sol = diffeqsolve( + terms, solver, t0, t1, dt0=dt0, y0=sde.y0, args=None, saveat=saveat ) - for args in [ - (gam, u, f), - (vec_gam, u, f), - (gam, vec_u, f), - (vec_gam, vec_u, f), - ]: - terms = LangevinTerm(args, bm, x0) - sol = diffeqsolve( - terms, solver, t0, t1, dt0=0.3, y0=y0, args=None, saveat=saveat - ) - assert sol.ys is not None - for entry in sol.ys: - assert entry.shape == (10, dim) - assert jnp.dtype(entry) == dtype + assert sol.ys is not None + assert sol.ts is not None + + # check that the output has the correct pytree structure and shape + def check_shape(y0_leaf, sol_leaf): + assert ( + sol_leaf.shape == (7,) + y0_leaf.shape + ), f"shape={sol_leaf.shape}, expected={(7,) + y0_leaf.shape}" + assert sol_leaf.dtype == dtype, f"dtype={sol_leaf.dtype}, expected={dtype}" + return sol_leaf.shape + + jtu.tree_map(check_shape, sde.y0, sol.ys) sdes = ( From 15c21a66206690dde470cb0d4f77b25471758d32 Mon Sep 17 00:00:00 2001 From: andyElking Date: Wed, 24 Jul 2024 20:34:57 +0100 Subject: [PATCH 03/15] removed the SORT solver (superseded by QUICSORT) --- diffrax/__init__.py | 1 - diffrax/_solver/__init__.py | 1 - diffrax/_solver/sort_uld.py | 203 ------------------------------------ 3 files changed, 205 deletions(-) delete mode 100644 diffrax/_solver/sort_uld.py diff --git a/diffrax/__init__.py b/diffrax/__init__.py index 0c3a0a8b..5fe2ae59 100644 --- a/diffrax/__init__.py +++ b/diffrax/__init__.py @@ -110,7 +110,6 @@ ShOULD as ShOULD, Sil3 as Sil3, SlowRK as SlowRK, - SORT as SORT, SPaRK as SPaRK, SRA1 as SRA1, StochasticButcherTableau as StochasticButcherTableau, diff --git a/diffrax/_solver/__init__.py b/diffrax/_solver/__init__.py index 160a4464..7525b437 100644 --- a/diffrax/_solver/__init__.py +++ b/diffrax/_solver/__init__.py @@ -47,7 +47,6 @@ from .should import ShOULD as ShOULD from .sil3 import Sil3 as Sil3 from .slowrk import SlowRK as SlowRK -from .sort_uld import SORT as SORT from .spark import SPaRK as SPaRK from .sra1 import SRA1 as SRA1 from .srk import ( diff --git a/diffrax/_solver/sort_uld.py b/diffrax/_solver/sort_uld.py deleted file mode 100644 index ce5efd19..00000000 --- a/diffrax/_solver/sort_uld.py +++ /dev/null @@ -1,203 +0,0 @@ -import equinox as eqx -import jax.numpy as jnp -import jax.tree_util as jtu -import numpy as np -from equinox.internal import ω -from jaxtyping import Array, ArrayLike, PyTree - -from .._custom_types import ( - AbstractSpaceTimeTimeLevyArea, - RealScalarLike, -) -from .._local_interpolation import LocalLinearInterpolation -from .._term import _LangevinArgs, LangevinTerm, LangevinX -from .langevin_srk import AbstractCoeffs, AbstractLangevinSRK, SolverState - - -# UBU evaluates at l = (3 -sqrt(3))/6, at r = (3 + sqrt(3))/6 and at 1, -# so we need 3 versions of each coefficient - - -class _SORTCoeffs(AbstractCoeffs): - beta_half: PyTree[ArrayLike] - a_half: PyTree[ArrayLike] - b_half: PyTree[ArrayLike] - beta1: PyTree[ArrayLike] - a1: PyTree[ArrayLike] - b1: PyTree[ArrayLike] - aa: PyTree[ArrayLike] - dtype: jnp.dtype = eqx.field(static=True) - - def __init__(self, beta_half, a_half, b_half, beta1, a1, b1, aa): - self.beta_half = beta_half - self.a_half = a_half - self.b_half = b_half - self.beta1 = beta1 - self.a1 = a1 - self.b1 = b1 - self.aa = aa - all_leaves = jtu.tree_leaves( - [ - self.beta_half, - self.a_half, - self.b_half, - self.beta1, - self.a1, - self.b1, - self.aa, - ] - ) - self.dtype = jnp.result_type(*all_leaves) - - -class SORT(AbstractLangevinSRK[_SORTCoeffs, None]): - r"""The Shifted-ODE Runge-Kutta Three method - designed by James Foster. Only works for Underdamped Langevin Diffusion - of the form - - $$d x_t = v_t dt$$ - - $$d v_t = - gamma v_t dt - u ∇f(x_t) dt + (2gammau)^(1/2) dW_t$$ - - where $v$ is the velocity, $f$ is the potential, $gamma$ is the friction, and - $W$ is a Brownian motion. - """ - - term_structure = LangevinTerm - interpolation_cls = LocalLinearInterpolation - taylor_threshold: RealScalarLike = eqx.field(static=True) - _coeffs_structure = jtu.tree_structure( - _SORTCoeffs( - beta_half=np.array(0.0), - a_half=np.array(0.0), - b_half=np.array(0.0), - beta1=np.array(0.0), - a1=np.array(0.0), - b1=np.array(0.0), - aa=np.array(0.0), - ) - ) - minimal_levy_area = AbstractSpaceTimeTimeLevyArea - - def __init__(self, taylor_threshold: RealScalarLike = 0.1): - r"""**Arguments:** - - - `taylor_threshold`: If the product `h*gamma` is less than this, then - the Taylor expansion will be used to compute the coefficients. - Otherwise they will be computed directly. When using float32, the - empirically optimal value is 0.1, and for float64 about 0.01. - """ - self.taylor_threshold = taylor_threshold - - def order(self, terms): - return 3 - - def strong_order(self, terms): - return 3.0 - - def _directly_compute_coeffs_leaf(self, h, c) -> _SORTCoeffs: - del self - # c is a leaf of gamma - # compute the coefficients directly (as opposed to via Taylor expansion) - al = c * h - beta_half = jnp.exp(-al / 2) - beta1 = jnp.exp(-al) - a_half = (1 - beta_half) / c - a1 = (1 - beta1) / c - b_half = (beta_half + al / 2 - 1) / (al * c) - b1 = (beta1 + al - 1) / (al * c) - aa = a1 / h - - return _SORTCoeffs( - beta_half=beta_half, - a_half=a_half, - b_half=b_half, - beta1=beta1, - a1=a1, - b1=b1, - aa=aa, - ) - - def _tay_coeffs_single(self, c: Array) -> _SORTCoeffs: - del self - # c is a leaf of gamma - zero = jnp.zeros_like(c) - one = jnp.ones_like(c) - c2 = jnp.square(c) - c3 = c2 * c - c4 = c3 * c - c5 = c4 * c - - beta_half = jnp.stack( - [one, -c / 2, c2 / 8, -c3 / 48, c4 / 384, -c5 / 3840], axis=-1 - ) - beta1 = jnp.stack([one, -c, c2 / 2, -c3 / 6, c4 / 24, -c5 / 120], axis=-1) - - a_half = jnp.stack( - [zero, one / 2, -c / 8, c2 / 48, -c3 / 384, c4 / 3840], axis=-1 - ) - a1 = jnp.stack([zero, one, -c / 2, c2 / 6, -c3 / 24, c4 / 120], axis=-1) - # aa = a1/h - aa = jnp.stack([one, -c / 2, c2 / 6, -c3 / 24, c4 / 120, -c5 / 720], axis=-1) - - # b_half is not exactly b(1/2 h), but 1/2 * b(1/2 h) - b_half = jnp.stack( - [zero, one / 8, -c / 48, c2 / 384, -c3 / 3840, c4 / 46080], axis=-1 - ) - b1 = jnp.stack([zero, one / 2, -c / 6, c2 / 24, -c3 / 120, c4 / 720], axis=-1) - return _SORTCoeffs( - beta_half=beta_half, - a_half=a_half, - b_half=b_half, - beta1=beta1, - a1=a1, - b1=b1, - aa=aa, - ) - - @staticmethod - def _compute_step( - h: RealScalarLike, - levy: AbstractSpaceTimeTimeLevyArea, - x0: LangevinX, - v0: LangevinX, - langevin_args: _LangevinArgs, - coeffs: _SORTCoeffs, - st: SolverState, - ) -> tuple[LangevinX, LangevinX, LangevinX, None]: - w: LangevinX = levy.W - hh: LangevinX = levy.H - kk: LangevinX = levy.K - - gamma, u, f = langevin_args - - rho_w_k = (st.rho**ω * (w**ω - 12 * kk**ω)).ω - uh = (u**ω * h).ω - - f0 = st.prev_f - v1 = (v0**ω + st.rho**ω * (hh**ω + 6 * kk**ω)).ω - x1 = ( - x0**ω - + coeffs.a_half**ω * v1**ω - + coeffs.b_half**ω * (-(uh**ω) * f0**ω + rho_w_k**ω) - ).ω - f1 = f(x1) - x_out = ( - x0**ω - + coeffs.a1**ω * v1**ω - + coeffs.b1**ω * (-(uh**ω) * (1 / 3 * f0**ω + 2 / 3 * f1**ω) + rho_w_k**ω) - ).ω - f_out = f(x_out) - v_out = ( - coeffs.beta1**ω * v1**ω - - uh**ω - * ( - coeffs.beta1**ω / 6 * f0**ω - + 2 / 3 * coeffs.beta_half**ω * f1**ω - + 1 / 6 * f_out**ω - ) - + coeffs.aa**ω * rho_w_k**ω - - st.rho**ω * (hh**ω - 6 * kk**ω) - ).ω - - return x_out, v_out, f_out, None From 34c51a9db00d50a8475591873555778d5c1714a0 Mon Sep 17 00:00:00 2001 From: andyElking Date: Fri, 2 Aug 2024 15:53:02 +0100 Subject: [PATCH 04/15] made LangevinTerm.term a static field --- diffrax/_integrate.py | 3 --- diffrax/_term.py | 2 +- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/diffrax/_integrate.py b/diffrax/_integrate.py index 13cf5661..ec084050 100644 --- a/diffrax/_integrate.py +++ b/diffrax/_integrate.py @@ -123,9 +123,6 @@ def _term_compatible( term_structure: PyTree, contr_kwargs: PyTree[dict], ) -> bool: - if term_structure == LangevinTerm and isinstance(terms, LangevinTerm): - return True - error_msg = "term_structure" def _check(term_cls, term, term_contr_kwargs, yi): diff --git a/diffrax/_term.py b/diffrax/_term.py index 2b6272a0..d095aa1d 100644 --- a/diffrax/_term.py +++ b/diffrax/_term.py @@ -883,7 +883,7 @@ class LangevinTerm(AbstractTerm): """ args: _LangevinArgs = eqx.field(static=True) - term: MultiTerm[tuple[ODETerm, _LangevinDiffusionTerm]] + term: MultiTerm[tuple[ODETerm, _LangevinDiffusionTerm]] = eqx.field(static=True) def __init__(self, args, bm: AbstractBrownianPath, x0: LangevinX): r"""**Arguments:** From 34aa6cbbef6b2d8dbcc96f7a30bbeba274dbebc7 Mon Sep 17 00:00:00 2001 From: andyElking Date: Sun, 4 Aug 2024 15:56:46 +0100 Subject: [PATCH 05/15] temporary fix for _term_compatible and LangevinTerm --- diffrax/_integrate.py | 15 +++++++++------ diffrax/_solver/align.py | 5 +++-- diffrax/_solver/quicsort.py | 7 ++++--- diffrax/_solver/should.py | 7 ++++--- diffrax/_term.py | 2 +- 5 files changed, 21 insertions(+), 15 deletions(-) diff --git a/diffrax/_integrate.py b/diffrax/_integrate.py index ec084050..a904f13d 100644 --- a/diffrax/_integrate.py +++ b/diffrax/_integrate.py @@ -162,12 +162,15 @@ def _check(term_cls, term, term_contr_kwargs, yi): pass elif n_term_args == 2: vf_type_expected, control_type_expected = term_args - vf_type = eqx.filter_eval_shape(term.vf, 0.0, yi, args) - vf_type_compatible = eqx.filter_eval_shape( - better_isinstance, vf_type, vf_type_expected - ) - if not vf_type_compatible: - raise ValueError + if not isinstance(term, LangevinTerm): + # TODO: The line below causes problems with LangevinTerm + # Please help me fix this + vf_type = eqx.filter_eval_shape(term.vf, 0.0, yi, args) + vf_type_compatible = eqx.filter_eval_shape( + better_isinstance, vf_type, vf_type_expected + ) + if not vf_type_compatible: + raise ValueError contr = ft.partial(term.contr, **term_contr_kwargs) # Work around https://github.com/google/jax/issues/21825 diff --git a/diffrax/_solver/align.py b/diffrax/_solver/align.py index df25cc15..1be6defb 100644 --- a/diffrax/_solver/align.py +++ b/diffrax/_solver/align.py @@ -137,8 +137,9 @@ def _compute_step( coeffs: _ALIGNCoeffs, st: SolverState, ) -> tuple[LangevinX, LangevinX, LangevinX, LangevinTuple]: - w: LangevinX = levy.W - hh: LangevinX = levy.H + dtypes = jtu.tree_map(jnp.dtype, x0) + w: LangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) + hh: LangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) gamma, u, f = langevin_args diff --git a/diffrax/_solver/quicsort.py b/diffrax/_solver/quicsort.py index d6b6e4fd..b7c88d74 100644 --- a/diffrax/_solver/quicsort.py +++ b/diffrax/_solver/quicsort.py @@ -188,9 +188,10 @@ def _compute_step( coeffs: _QUICSORTCoeffs, st: SolverState, ) -> tuple[LangevinX, LangevinX, LangevinX, None]: - w: LangevinX = levy.W - hh: LangevinX = levy.H - kk: LangevinX = levy.K + dtypes = jtu.tree_map(jnp.dtype, x0) + w: LangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) + hh: LangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) + kk: LangevinX = jtu.tree_map(jnp.asarray, levy.K, dtypes) gamma, u, f = langevin_args diff --git a/diffrax/_solver/should.py b/diffrax/_solver/should.py index c84b88e1..5c1d9199 100644 --- a/diffrax/_solver/should.py +++ b/diffrax/_solver/should.py @@ -186,9 +186,10 @@ def _compute_step( coeffs: _ShOULDCoeffs, st: SolverState, ) -> tuple[LangevinX, LangevinX, LangevinX, None]: - w: LangevinX = levy.W - hh: LangevinX = levy.H - kk: LangevinX = levy.K + dtypes = jtu.tree_map(jnp.dtype, x0) + w: LangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) + hh: LangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) + kk: LangevinX = jtu.tree_map(jnp.asarray, levy.K, dtypes) gamma, u, f = langevin_args diff --git a/diffrax/_term.py b/diffrax/_term.py index d095aa1d..2b6272a0 100644 --- a/diffrax/_term.py +++ b/diffrax/_term.py @@ -883,7 +883,7 @@ class LangevinTerm(AbstractTerm): """ args: _LangevinArgs = eqx.field(static=True) - term: MultiTerm[tuple[ODETerm, _LangevinDiffusionTerm]] = eqx.field(static=True) + term: MultiTerm[tuple[ODETerm, _LangevinDiffusionTerm]] def __init__(self, args, bm: AbstractBrownianPath, x0: LangevinX): r"""**Arguments:** From 3e3656bc8f917f7acf6bff7213541eb5d9d40adf Mon Sep 17 00:00:00 2001 From: andyElking Date: Fri, 9 Aug 2024 21:58:45 +0100 Subject: [PATCH 06/15] Fixed LangevinTerm YAAAYYYYY --- diffrax/__init__.py | 2 +- diffrax/_integrate.py | 26 ++---- diffrax/_solver/align.py | 22 +++-- diffrax/_solver/euler_heun.py | 12 +-- diffrax/_solver/langevin_srk.py | 84 ++++++++++++------ diffrax/_solver/milstein.py | 22 +++-- diffrax/_solver/quicsort.py | 22 +++-- diffrax/_solver/should.py | 22 +++-- diffrax/_solver/srk.py | 30 +++++-- diffrax/_term.py | 147 ++++++++++++++++---------------- test/helpers.py | 15 ++-- test/test_langevin.py | 6 +- 12 files changed, 231 insertions(+), 179 deletions(-) diff --git a/diffrax/__init__.py b/diffrax/__init__.py index 5fe2ae59..71d6b503 100644 --- a/diffrax/__init__.py +++ b/diffrax/__init__.py @@ -126,7 +126,7 @@ from ._term import ( AbstractTerm as AbstractTerm, ControlTerm as ControlTerm, - LangevinTerm as LangevinTerm, + make_langevin_term as make_langevin_term, MultiTerm as MultiTerm, ODETerm as ODETerm, WeaklyDiagonalControlTerm as WeaklyDiagonalControlTerm, diff --git a/diffrax/_integrate.py b/diffrax/_integrate.py index a904f13d..615eafe9 100644 --- a/diffrax/_integrate.py +++ b/diffrax/_integrate.py @@ -63,7 +63,7 @@ ConstantStepSize, StepTo, ) -from ._term import AbstractTerm, LangevinTerm, MultiTerm, ODETerm, WrapTerm +from ._term import AbstractTerm, MultiTerm, ODETerm, WrapTerm from ._typing import better_isinstance, get_args_of, get_origin_no_specials @@ -162,15 +162,12 @@ def _check(term_cls, term, term_contr_kwargs, yi): pass elif n_term_args == 2: vf_type_expected, control_type_expected = term_args - if not isinstance(term, LangevinTerm): - # TODO: The line below causes problems with LangevinTerm - # Please help me fix this - vf_type = eqx.filter_eval_shape(term.vf, 0.0, yi, args) - vf_type_compatible = eqx.filter_eval_shape( - better_isinstance, vf_type, vf_type_expected - ) - if not vf_type_compatible: - raise ValueError + vf_type = eqx.filter_eval_shape(term.vf, 0.0, yi, args) + vf_type_compatible = eqx.filter_eval_shape( + better_isinstance, vf_type, vf_type_expected + ) + if not vf_type_compatible: + raise ValueError contr = ft.partial(term.contr, **term_contr_kwargs) # Work around https://github.com/google/jax/issues/21825 @@ -1008,10 +1005,6 @@ def _promote(yi): y0 = jtu.tree_map(_promote, y0) del timelikes - # Langevin terms must be unwrapped unless `term_structure=LangevinTerm - if isinstance(terms, LangevinTerm) and solver.term_structure != LangevinTerm: - terms = terms.term - # Backward compatibility if isinstance( solver, (EulerHeun, ItoMilstein, StratonovichMilstein) @@ -1070,14 +1063,13 @@ def _promote(yi): def _wrap(term): assert isinstance(term, AbstractTerm) - assert not isinstance(term, (MultiTerm, LangevinTerm)) + assert not isinstance(term, MultiTerm) return WrapTerm(term, direction) terms = jtu.tree_map( _wrap, terms, - is_leaf=lambda x: isinstance(x, AbstractTerm) - and not isinstance(x, (MultiTerm, LangevinTerm)), + is_leaf=lambda x: isinstance(x, AbstractTerm) and not isinstance(x, MultiTerm), ) if isinstance(solver, AbstractImplicitSolver): diff --git a/diffrax/_solver/align.py b/diffrax/_solver/align.py index 1be6defb..53427bb8 100644 --- a/diffrax/_solver/align.py +++ b/diffrax/_solver/align.py @@ -10,8 +10,13 @@ RealScalarLike, ) from .._local_interpolation import LocalLinearInterpolation -from .._term import _LangevinArgs, LangevinTerm, LangevinTuple, LangevinX -from .langevin_srk import AbstractCoeffs, AbstractLangevinSRK, SolverState +from .._term import _LangevinTuple, _LangevinX +from .langevin_srk import ( + _LangevinArgs, + AbstractCoeffs, + AbstractLangevinSRK, + SolverState, +) # UBU evaluates at l = (3 -sqrt(3))/6, at r = (3 + sqrt(3))/6 and at 1, @@ -36,7 +41,7 @@ def __init__(self, beta, a1, b1, aa, chh): self.dtype = jnp.result_type(*all_leaves) -_ErrorEstimate = LangevinTuple +_ErrorEstimate = _LangevinTuple class ALIGN(AbstractLangevinSRK[_ALIGNCoeffs, _ErrorEstimate]): @@ -52,7 +57,6 @@ class ALIGN(AbstractLangevinSRK[_ALIGNCoeffs, _ErrorEstimate]): $W$ is a Brownian motion. """ - term_structure = LangevinTerm interpolation_cls = LocalLinearInterpolation taylor_threshold: RealScalarLike = eqx.field(static=True) _coeffs_structure = jtu.tree_structure( @@ -131,15 +135,15 @@ def _tay_coeffs_single(self, c: Array) -> _ALIGNCoeffs: def _compute_step( h: RealScalarLike, levy: AbstractSpaceTimeLevyArea, - x0: LangevinX, - v0: LangevinX, + x0: _LangevinX, + v0: _LangevinX, langevin_args: _LangevinArgs, coeffs: _ALIGNCoeffs, st: SolverState, - ) -> tuple[LangevinX, LangevinX, LangevinX, LangevinTuple]: + ) -> tuple[_LangevinX, _LangevinX, _LangevinX, _LangevinTuple]: dtypes = jtu.tree_map(jnp.dtype, x0) - w: LangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) - hh: LangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) + w: _LangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) + hh: _LangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) gamma, u, f = langevin_args diff --git a/diffrax/_solver/euler_heun.py b/diffrax/_solver/euler_heun.py index 88b99776..c8338c88 100644 --- a/diffrax/_solver/euler_heun.py +++ b/diffrax/_solver/euler_heun.py @@ -1,5 +1,5 @@ from collections.abc import Callable -from typing import ClassVar +from typing import Any, ClassVar from typing_extensions import TypeAlias from equinox.internal import ω @@ -7,7 +7,7 @@ from .._custom_types import Args, BoolScalarLike, DenseInfo, RealScalarLike, VF, Y from .._local_interpolation import LocalLinearInterpolation from .._solution import RESULTS -from .._term import AbstractTerm, MultiTerm, ODETerm +from .._term import AbstractTerm, MultiTerm from .base import AbstractStratonovichSolver @@ -26,7 +26,9 @@ class EulerHeun(AbstractStratonovichSolver): Used to solve SDEs, and converges to the Stratonovich solution. """ - term_structure: ClassVar = MultiTerm[tuple[ODETerm, AbstractTerm]] + term_structure: ClassVar = MultiTerm[ + tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm] + ] interpolation_cls: ClassVar[ Callable[..., LocalLinearInterpolation] ] = LocalLinearInterpolation @@ -39,7 +41,7 @@ def strong_order(self, terms): def init( self, - terms: MultiTerm[tuple[ODETerm, AbstractTerm]], + terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], t0: RealScalarLike, t1: RealScalarLike, y0: Y, @@ -49,7 +51,7 @@ def init( def step( self, - terms: MultiTerm[tuple[ODETerm, AbstractTerm]], + terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], t0: RealScalarLike, t1: RealScalarLike, y0: Y, diff --git a/diffrax/_solver/langevin_srk.py b/diffrax/_solver/langevin_srk.py index 52022274..526c2ebb 100644 --- a/diffrax/_solver/langevin_srk.py +++ b/diffrax/_solver/langevin_srk.py @@ -1,5 +1,5 @@ import abc -from typing import Generic, TypeVar +from typing import Any, Callable, Generic, TypeVar import equinox as eqx import equinox.internal as eqxi @@ -19,11 +19,42 @@ ) from .._local_interpolation import LocalLinearInterpolation from .._solution import RESULTS -from .._term import _LangevinArgs, LangevinTerm, LangevinTuple, LangevinX +from .._term import ( + _LangevinDiffusionTerm, + _LangevinDriftTerm, + _LangevinTuple, + _LangevinX, + AbstractTerm, + MultiTerm, + WrapTerm, +) from .base import AbstractItoSolver, AbstractStratonovichSolver -_ErrorEstimate = TypeVar("_ErrorEstimate", None, LangevinTuple) +_ErrorEstimate = TypeVar("_ErrorEstimate", None, _LangevinTuple) +_LangevinArgs = tuple[_LangevinX, _LangevinX, Callable[[_LangevinX], _LangevinX]] + + +def get_args_from_terms( + terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], +) -> _LangevinArgs: + drift, diffusion = terms.terms + if isinstance(drift, WrapTerm): + unwrapped_drift = drift.term + assert isinstance(diffusion, WrapTerm) + unwrapped_diffusion = diffusion.term + assert isinstance(unwrapped_drift, _LangevinDriftTerm) + assert isinstance(unwrapped_diffusion, _LangevinDiffusionTerm) + gamma = unwrapped_drift.gamma + u = unwrapped_drift.u + f = unwrapped_drift.grad_f + else: + assert isinstance(drift, _LangevinDriftTerm) + assert isinstance(diffusion, _LangevinDiffusionTerm) + gamma = drift.gamma + u = drift.u + f = drift.grad_f + return gamma, u, f class AbstractCoeffs(eqx.Module): @@ -38,10 +69,10 @@ class AbstractCoeffs(eqx.Module): # How should I work around this? class SolverState(eqx.Module, Generic[_Coeffs]): h: RealScalarLike - taylor_coeffs: PyTree[_Coeffs, "LangevinX"] + taylor_coeffs: PyTree[_Coeffs, "_LangevinX"] coeffs: _Coeffs - rho: LangevinX - prev_f: LangevinX + rho: _LangevinX + prev_f: _LangevinX # CONCERNING COEFFICIENTS: @@ -77,7 +108,7 @@ class AbstractLangevinSRK( QUIC_SORT. """ - term_structure = LangevinTerm + term_structure = MultiTerm[tuple[_LangevinDriftTerm, _LangevinDiffusionTerm]] interpolation_cls = LocalLinearInterpolation taylor_threshold: RealScalarLike = eqx.field(static=True) _coeffs_structure: eqx.AbstractClassVar[PyTreeDef] @@ -119,7 +150,7 @@ def _eval_taylor(h, tay_coeffs: _Coeffs) -> _Coeffs: ) def _recompute_coeffs( - self, h, gamma: LangevinX, tay_coeffs: PyTree[_Coeffs], state_h + self, h, gamma: _LangevinX, tay_coeffs: PyTree[_Coeffs], state_h ) -> _Coeffs: def recompute_coeffs_leaf(c: ArrayLike, _tay_coeffs: _Coeffs): # Used when the step-size h changes and coefficients need to be recomputed @@ -167,10 +198,10 @@ def _choose(tay_leaf, direct_leaf): def init( self, - terms: LangevinTerm, + terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], t0: RealScalarLike, t1: RealScalarLike, - y0: LangevinTuple, + y0: _LangevinTuple, args: PyTree, ) -> SolverState: """Precompute _SolverState which carries the Taylor coefficients and the @@ -178,19 +209,17 @@ def init( Some solvers of this type are FSAL, so _SolverState also carries the previous evaluation of grad_f. """ - assert isinstance(terms, LangevinTerm) - gamma, u, f = terms.args # f is in fact grad(f) + drift, diffusion = terms.terms + gamma, u, f = get_args_from_terms(terms) + h = drift.contr(t0, t1) x0, v0 = y0 def _check_shapes(_c, _u, _x, _v): - # assert _x.ndim in [0, 1] assert _c.shape == _u.shape == _x.shape == _v.shape assert jtu.tree_all(jtu.tree_map(_check_shapes, gamma, u, x0, v0)) - h = t1 - t0 - tay_coeffs = jtu.tree_map(self._comp_taylor_coeffs_leaf, gamma) # tay_coeffs have the same tree structure as gamma, with each leaf being a # _Coeffs and the arrays have an extra trailing dimension of 6 @@ -213,30 +242,30 @@ def _check_shapes(_c, _u, _x, _v): def _compute_step( h: RealScalarLike, levy, - x0: LangevinX, - v0: LangevinX, + x0: _LangevinX, + v0: _LangevinX, langevin_args: _LangevinArgs, coeffs: _Coeffs, st: SolverState, - ) -> tuple[LangevinX, LangevinX, LangevinX, _ErrorEstimate]: + ) -> tuple[_LangevinX, _LangevinX, _LangevinX, _ErrorEstimate]: raise NotImplementedError def step( self, - terms: LangevinTerm, + terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], t0: RealScalarLike, t1: RealScalarLike, - y0: LangevinTuple, + y0: _LangevinTuple, args: PyTree, solver_state: SolverState, made_jump: BoolScalarLike, - ) -> tuple[LangevinTuple, _ErrorEstimate, DenseInfo, SolverState, RESULTS]: + ) -> tuple[_LangevinTuple, _ErrorEstimate, DenseInfo, SolverState, RESULTS]: del made_jump, args st = solver_state - h = t1 - t0 - assert isinstance(terms, LangevinTerm) - gamma, u, f = terms.args + drift, diffusion = terms.terms + gamma, u, f = get_args_from_terms(terms) + h = drift.contr(t0, t1) h_state = st.h tay: PyTree[_Coeffs] = st.taylor_coeffs coeffs: _Coeffs = st.coeffs @@ -250,7 +279,6 @@ def step( coeffs, ) - drift, diffusion = terms.term.terms # compute the Brownian increment and space-time Levy area levy = diffusion.contr(t0, t1, use_levy=True) assert isinstance(levy, self.minimal_levy_area), ( @@ -260,7 +288,7 @@ def step( x0, v0 = y0 x_out, v_out, f_fsal, error = self._compute_step( - h, levy, x0, v0, terms.args, coeffs, st + h, levy, x0, v0, (gamma, u, f), coeffs, st ) def check_shapes_dtypes(_x, _v, _f, _x0): @@ -289,9 +317,9 @@ def check_shapes_dtypes(_x, _v, _f, _x0): def func( self, - terms: LangevinTerm, + terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], t0: RealScalarLike, - y0: LangevinTuple, + y0: _LangevinTuple, args: PyTree, ): return terms.vf(t0, y0, args) diff --git a/diffrax/_solver/milstein.py b/diffrax/_solver/milstein.py index 3d14e343..5ab037d2 100644 --- a/diffrax/_solver/milstein.py +++ b/diffrax/_solver/milstein.py @@ -1,5 +1,5 @@ from collections.abc import Callable -from typing import ClassVar +from typing import Any, ClassVar from typing_extensions import TypeAlias import jax @@ -10,7 +10,7 @@ from .._custom_types import Args, BoolScalarLike, DenseInfo, RealScalarLike, VF, Y from .._local_interpolation import LocalLinearInterpolation from .._solution import RESULTS -from .._term import AbstractTerm, MultiTerm, ODETerm +from .._term import AbstractTerm, MultiTerm from .base import AbstractItoSolver, AbstractStratonovichSolver @@ -42,7 +42,9 @@ class StratonovichMilstein(AbstractStratonovichSolver): Note that this commutativity condition is not checked. """ # noqa: E501 - term_structure: ClassVar = MultiTerm[tuple[ODETerm, AbstractTerm]] + term_structure: ClassVar = MultiTerm[ + tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm] + ] interpolation_cls: ClassVar[ Callable[..., LocalLinearInterpolation] ] = LocalLinearInterpolation @@ -55,7 +57,7 @@ def strong_order(self, terms): def init( self, - terms: MultiTerm[tuple[ODETerm, AbstractTerm]], + terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], t0: RealScalarLike, t1: RealScalarLike, y0: Y, @@ -65,7 +67,7 @@ def init( def step( self, - terms: MultiTerm[tuple[ODETerm, AbstractTerm]], + terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], t0: RealScalarLike, t1: RealScalarLike, y0: Y, @@ -116,7 +118,9 @@ class ItoMilstein(AbstractItoSolver): Note that this commutativity condition is not checked. """ # noqa: E501 - term_structure: ClassVar = MultiTerm[tuple[ODETerm, AbstractTerm]] + term_structure: ClassVar = MultiTerm[ + tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm] + ] interpolation_cls: ClassVar[ Callable[..., LocalLinearInterpolation] ] = LocalLinearInterpolation @@ -129,7 +133,7 @@ def strong_order(self, terms): def init( self, - terms: MultiTerm[tuple[ODETerm, AbstractTerm]], + terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], t0: RealScalarLike, t1: RealScalarLike, y0: Y, @@ -139,7 +143,7 @@ def init( def step( self, - terms: MultiTerm[tuple[ODETerm, AbstractTerm]], + terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], t0: RealScalarLike, t1: RealScalarLike, y0: Y, @@ -365,7 +369,7 @@ def _dot(_, _v0): def func( self, - terms: MultiTerm[tuple[ODETerm, AbstractTerm]], + terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], t0: RealScalarLike, y0: Y, args: Args, diff --git a/diffrax/_solver/quicsort.py b/diffrax/_solver/quicsort.py index b7c88d74..1dfe2649 100644 --- a/diffrax/_solver/quicsort.py +++ b/diffrax/_solver/quicsort.py @@ -13,8 +13,13 @@ RealScalarLike, ) from .._local_interpolation import LocalLinearInterpolation -from .._term import _LangevinArgs, LangevinTerm, LangevinX -from .langevin_srk import AbstractCoeffs, AbstractLangevinSRK, SolverState +from .._term import _LangevinX +from .langevin_srk import ( + _LangevinArgs, + AbstractCoeffs, + AbstractLangevinSRK, + SolverState, +) # UBU evaluates at l = (3 -sqrt(3))/6, at r = (3 + sqrt(3))/6 and at 1, @@ -71,7 +76,6 @@ class QUICSORT(AbstractLangevinSRK[_QUICSORTCoeffs, None]): $W$ is a Brownian motion. """ - term_structure = LangevinTerm interpolation_cls = LocalLinearInterpolation taylor_threshold: RealScalarLike = eqx.field(static=True) _coeffs_structure = jtu.tree_structure( @@ -182,16 +186,16 @@ def _tay_coeffs_single(self, c: Array) -> _QUICSORTCoeffs: def _compute_step( h: RealScalarLike, levy: AbstractSpaceTimeTimeLevyArea, - x0: LangevinX, - v0: LangevinX, + x0: _LangevinX, + v0: _LangevinX, langevin_args: _LangevinArgs, coeffs: _QUICSORTCoeffs, st: SolverState, - ) -> tuple[LangevinX, LangevinX, LangevinX, None]: + ) -> tuple[_LangevinX, _LangevinX, _LangevinX, None]: dtypes = jtu.tree_map(jnp.dtype, x0) - w: LangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) - hh: LangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) - kk: LangevinX = jtu.tree_map(jnp.asarray, levy.K, dtypes) + w: _LangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) + hh: _LangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) + kk: _LangevinX = jtu.tree_map(jnp.asarray, levy.K, dtypes) gamma, u, f = langevin_args diff --git a/diffrax/_solver/should.py b/diffrax/_solver/should.py index 5c1d9199..0940a58f 100644 --- a/diffrax/_solver/should.py +++ b/diffrax/_solver/should.py @@ -10,8 +10,13 @@ RealScalarLike, ) from .._local_interpolation import LocalLinearInterpolation -from .._term import _LangevinArgs, LangevinTerm, LangevinX -from .langevin_srk import AbstractCoeffs, AbstractLangevinSRK, SolverState +from .._term import _LangevinX +from .langevin_srk import ( + _LangevinArgs, + AbstractCoeffs, + AbstractLangevinSRK, + SolverState, +) # UBU evaluates at l = (3 -sqrt(3))/6, at r = (3 + sqrt(3))/6 and at 1, @@ -69,7 +74,6 @@ class ShOULD(AbstractLangevinSRK[_ShOULDCoeffs, None]): $W$ is a Brownian motion. """ - term_structure = LangevinTerm interpolation_cls = LocalLinearInterpolation taylor_threshold: RealScalarLike = eqx.field(static=True) _coeffs_structure = jtu.tree_structure( @@ -180,16 +184,16 @@ def _tay_coeffs_single(self, c: Array) -> _ShOULDCoeffs: def _compute_step( h: RealScalarLike, levy: AbstractSpaceTimeTimeLevyArea, - x0: LangevinX, - v0: LangevinX, + x0: _LangevinX, + v0: _LangevinX, langevin_args: _LangevinArgs, coeffs: _ShOULDCoeffs, st: SolverState, - ) -> tuple[LangevinX, LangevinX, LangevinX, None]: + ) -> tuple[_LangevinX, _LangevinX, _LangevinX, None]: dtypes = jtu.tree_map(jnp.dtype, x0) - w: LangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) - hh: LangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) - kk: LangevinX = jtu.tree_map(jnp.asarray, levy.K, dtypes) + w: _LangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) + hh: _LangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) + kk: _LangevinX = jtu.tree_map(jnp.asarray, levy.K, dtypes) gamma, u, f = langevin_args diff --git a/diffrax/_solver/srk.py b/diffrax/_solver/srk.py index 8ac53715..508b4d71 100644 --- a/diffrax/_solver/srk.py +++ b/diffrax/_solver/srk.py @@ -28,7 +28,7 @@ ) from .._local_interpolation import LocalLinearInterpolation from .._solution import RESULTS -from .._term import AbstractTerm, MultiTerm, ODETerm +from .._term import AbstractTerm, MultiTerm from .base import AbstractSolver @@ -276,11 +276,21 @@ def minimal_levy_area(self) -> type[AbstractBrownianIncrement]: @property def term_structure(self): - return MultiTerm[tuple[ODETerm, AbstractTerm[Any, self.minimal_levy_area]]] + return MultiTerm[ + tuple[ + AbstractTerm[Any, RealScalarLike], + AbstractTerm[Any, self.minimal_levy_area], + ] + ] def init( self, - terms: MultiTerm[tuple[ODETerm, AbstractTerm[Any, AbstractBrownianIncrement]]], + terms: MultiTerm[ + tuple[ + AbstractTerm[Any, RealScalarLike], + AbstractTerm[Any, AbstractBrownianIncrement], + ] + ], t0: RealScalarLike, t1: RealScalarLike, y0: Y, @@ -314,7 +324,12 @@ def _embed_a_lower(self, _a, dtype): def step( self, - terms: MultiTerm[tuple[ODETerm, AbstractTerm[Any, AbstractBrownianIncrement]]], + terms: MultiTerm[ + tuple[ + AbstractTerm[Any, RealScalarLike], + AbstractTerm[Any, AbstractBrownianIncrement], + ] + ], t0: RealScalarLike, t1: RealScalarLike, y0: Y, @@ -643,7 +658,12 @@ def compute_and_insert_kg_j(_w_kgs_in, _levylist_kgs_in): def func( self, - terms: MultiTerm[tuple[ODETerm, AbstractTerm[Any, AbstractBrownianIncrement]]], + terms: MultiTerm[ + tuple[ + AbstractTerm[Any, RealScalarLike], + AbstractTerm[Any, AbstractBrownianIncrement], + ] + ], t0: RealScalarLike, y0: Y, args: PyTree, diff --git a/diffrax/_term.py b/diffrax/_term.py index 2b6272a0..86467c07 100644 --- a/diffrax/_term.py +++ b/diffrax/_term.py @@ -2,7 +2,7 @@ import operator import warnings from collections.abc import Callable -from typing import Any, cast, Generic, Optional, TypeVar, Union +from typing import cast, Generic, Optional, TypeVar, Union import equinox as eqx import jax @@ -791,12 +791,12 @@ def _to_vjp(_y, _diff_args, _diff_term): # `x` and the velocity `v`. Both of these have the same shape. So, by LangevinX we # denote the shape of the x component, and by LangevinTuple we denote the shape of # the tuple (x, v). -LangevinX = PyTree[Shaped[Array, "?*langevin"], "LangevinX"] -LangevinTuple = tuple[LangevinX, LangevinX] -_LangevinBM = TypeVar("_LangevinBM", bound=Union[LangevinX, AbstractBrownianIncrement]) +_LangevinX = PyTree[Shaped[Array, "?*langevin"], "LangevinX"] +_LangevinTuple = tuple[_LangevinX, _LangevinX] +_LangevinBM = TypeVar("_LangevinBM", bound=Union[_LangevinX, AbstractBrownianIncrement]) -class _LangevinDiffusionTerm(AbstractTerm[LangevinX, _LangevinBM]): +class _LangevinDiffusionTerm(AbstractTerm[_LangevinX, _LangevinBM]): r"""Represents the diffusion term in the Langevin SDE: $d \mathbf{x}_t = \mathbf{v}_t dt$ @@ -805,16 +805,11 @@ class _LangevinDiffusionTerm(AbstractTerm[LangevinX, _LangevinBM]): \nabla f( \mathbf{x}_t ) dt + \sqrt{2 \gamma u} d W_t.$ """ - gamma: LangevinX - u: LangevinX + gamma: _LangevinX + u: _LangevinX control: AbstractBrownianPath - def __init__(self, gamma, u, control: AbstractBrownianPath): - self.gamma = gamma - self.u = u - self.control = control - - def vf(self, t: RealScalarLike, y: LangevinTuple, args: Args) -> LangevinX: + def vf(self, t: RealScalarLike, y: _LangevinTuple, args: Args) -> _LangevinX: x, v = y def _fun(_gamma, _u, _v): @@ -826,7 +821,7 @@ def _fun(_gamma, _u, _v): def contr(self, t0: RealScalarLike, t1: RealScalarLike, **kwargs) -> _LangevinBM: return self.control.evaluate(t0, t1, **kwargs) - def prod(self, vf: LangevinX, control: LangevinX) -> LangevinTuple: + def prod(self, vf: _LangevinX, control: _LangevinX) -> _LangevinTuple: if isinstance(control, AbstractBrownianIncrement): control = control.W @@ -837,25 +832,6 @@ def prod(self, vf: LangevinX, control: LangevinX) -> LangevinTuple: return x_out, v_out -_LangevinArgs = tuple[LangevinX, LangevinX, Callable[[LangevinX], LangevinX]] - - -def _langevin_drift(t, y: LangevinTuple, args: _LangevinArgs) -> LangevinTuple: - gamma, u, grad_f = args - x, v = y - f_x = grad_f(x) - d_x = v - d_v = jtu.tree_map( - lambda _gamma, _u, _v, _f_x: -_gamma * _v - _u * _f_x, - gamma, - u, - v, - f_x, - ) - d_y = (d_x, d_v) - return d_y - - def _broadcast_pytree(source, target_tree_shape): # Requires that source is a prefix tree of target_tree_shape def _inner_broadcast(_src_arr, _inner_tree_shape): @@ -867,57 +843,78 @@ def _inner_broadcast(_src_arr, _inner_tree_shape): return jtu.tree_map(_inner_broadcast, source, target_tree_shape) -class LangevinTerm(AbstractTerm): - r"""Used to represent the Langevin SDE, given by: +class _LangevinDriftTerm(AbstractTerm): + gamma: _LangevinX + u: _LangevinX + grad_f: Callable[[_LangevinX], _LangevinX] - $d \mathbf{x}_t = \mathbf{v}_t dt$ + def vf(self, t: RealScalarLike, y: _LangevinTuple, args: Args) -> _LangevinTuple: + x, v = y + f_x = self.grad_f(x) + d_x = v + d_v = jtu.tree_map( + lambda _gamma, _u, _v, _f_x: -_gamma * _v - _u * _f_x, + self.gamma, + self.u, + v, + f_x, + ) + d_y = (d_x, d_v) + return d_y + + def contr(self, t0: RealScalarLike, t1: RealScalarLike, **kwargs) -> RealScalarLike: + return t1 - t0 + + def prod(self, vf: _LangevinTuple, control: RealScalarLike) -> _LangevinTuple: + return jtu.tree_map(lambda _vf: control * _vf, vf) + +def make_langevin_term( + gamma: PyTree[ArrayLike], + u: PyTree[ArrayLike], + grad_f: Callable, + bm: AbstractBrownianPath, + x0: _LangevinX, +) -> MultiTerm[tuple[_LangevinDriftTerm, _LangevinDiffusionTerm]]: + r"""Creates a term that represents the Underdamped Langevin Diffusion, given by: + $d \mathbf{x}_t = \mathbf{v}_t dt$ $d \mathbf{v}_t = - \gamma \mathbf{v}_t dt - u \nabla f( \mathbf{x}_t ) dt + \sqrt{2 \gamma u} d W_t.$ - where $\mathbf{x}_t, \mathbf{v}_t \in \mathbb{R}^d$ represent the position and velocity, $W$ is a Brownian motion in $\mathbb{R}^d$, $f: \mathbb{R}^d \rightarrow \mathbb{R}$ is a potential function, and - $ \gamma,u\in\mathbb{R}^{d\times d}$ are diagonal matrices representing - friction and a dampening parameter. - """ + $ \gamma,u\in\mathbb{R}^{d\times d}$ are diagonal matrices governing + the friction and the dampening of the system. - args: _LangevinArgs = eqx.field(static=True) - term: MultiTerm[tuple[ODETerm, _LangevinDiffusionTerm]] + **Arguments:** - def __init__(self, args, bm: AbstractBrownianPath, x0: LangevinX): - r"""**Arguments:** + - `gamma`: A vector containing the diagonal entries of the friction matrix; + a PyTree of the same shape as `x0`. + - `u`: A vector containing the diagonal entries of the dampening matrix; + a PyTree of the same shape as `x0`. + - `grad_f`: A callable representing the gradient of the potential function $f$. + This callable should take a PyTree of the same shape as `x0` and + return a PyTree of the same shape. + - `bm`: A Brownian path representing the Brownian motion $W$. + - `x0`: The initial state of the system (just the position without velocity); + only needed to check the PyTree structure of the other arguments. - - `args`: a tuple of the form $(\gamma, u, \nabla f)$ - - `bm`: a Brownian path - - `x0`: a point in the state space of the process (position only), - needed to determine the PyTree structure and shape of the process. - """ - g1, u1, grad_f = args - # the PyTree structure of g1 and u1 must be a prefix of the PyTree - # structure of x0, and the shapes must be broadcastable to the shape of - # each leaf of x0. - gamma = _broadcast_pytree(g1, x0) - u = _broadcast_pytree(u1, x0) - grad_f_shape = jax.eval_shape(grad_f, x0) - - def _shape_check_fun(_x, _g, _u, _fx): - return _x.shape == _g.shape == _u.shape == _fx.shape - - assert jtu.tree_all( - jtu.tree_map(_shape_check_fun, x0, gamma, u, grad_f_shape) - ), "The shapes of gamma, u, and grad_f(x0) must be the same as x0." - - self.args = (gamma, u, grad_f) - drift = ODETerm(lambda t, y, _: _langevin_drift(t, y, self.args)) - diffusion = _LangevinDiffusionTerm(gamma, u, bm) - self.term = MultiTerm(drift, diffusion) - - def vf(self, t: RealScalarLike, y: LangevinTuple, args: Args) -> tuple[Any, ...]: - return self.term.vf(t, y, args) + **Returns:** - def contr(self, t0: RealScalarLike, t1: RealScalarLike, **kwargs) -> Any: - return self.term.contr(t0, t1, **kwargs) + A `MultiTerm` representing the Langevin SDE. + """ + + gamma = _broadcast_pytree(gamma, x0) + u = _broadcast_pytree(u, x0) + grad_f_shape = jax.eval_shape(grad_f, x0) + + def _shape_check_fun(_x, _g, _u, _fx): + return _x.shape == _g.shape == _u.shape == _fx.shape + + assert jtu.tree_all( + jtu.tree_map(_shape_check_fun, x0, gamma, u, grad_f_shape) + ), "The shapes of gamma, u, and grad_f(x0) must be the same as x0." - def prod(self, vf: tuple[Any, ...], control: Any) -> LangevinTuple: - return self.term.prod(vf, control) + drift = _LangevinDriftTerm(gamma, u, grad_f) + diffusion = _LangevinDiffusionTerm(gamma, u, bm) + return MultiTerm(drift, diffusion) diff --git a/test/helpers.py b/test/helpers.py index ac7af0a1..d27e465c 100644 --- a/test/helpers.py +++ b/test/helpers.py @@ -12,7 +12,7 @@ AbstractBrownianPath, AbstractTerm, ControlTerm, - LangevinTerm, + make_langevin_term, MultiTerm, ODETerm, VirtualBrownianTree, @@ -503,12 +503,12 @@ def get_terms(bm): def get_bqp(t0=0.3, t1=15.0, dtype=jnp.float32): grad_f_bqp = lambda x: 4 * x * (jnp.square(x) - 1) - args_bqp = (dtype(0.8), dtype(0.2), grad_f_bqp) + gamma, u = dtype(0.8), dtype(0.2) y0_bqp = (dtype(0), dtype(0)) w_shape_bqp = () def get_terms_bqp(bm): - return LangevinTerm(args_bqp, bm, x0=y0_bqp[0]) + return make_langevin_term(gamma, u, grad_f_bqp, bm, y0_bqp[0]) return SDE(get_terms_bqp, None, y0_bqp, t0, t1, w_shape_bqp) @@ -516,14 +516,13 @@ def get_terms_bqp(bm): def get_harmonic_oscillator(t0=0.3, t1=15.0, dtype=jnp.float32): gamma_hosc = jnp.array([2, 0.5], dtype=dtype) u_hosc = jnp.array([0.5, 2], dtype=dtype) - args_hosc = (gamma_hosc, u_hosc, lambda x: 2 * x) x0 = jnp.zeros((2,), dtype=dtype) v0 = jnp.zeros((2,), dtype=dtype) y0_hosc = (x0, v0) w_shape_hosc = (2,) def get_terms_hosc(bm): - return LangevinTerm(args_hosc, bm, x0) + return make_langevin_term(gamma_hosc, u_hosc, lambda x: 2 * x, bm, x0) return SDE(get_terms_hosc, None, y0_hosc, t0, t1, w_shape_hosc) @@ -538,14 +537,13 @@ def log_p(x): gamma = 2.0 u = 1.0 - args_neal = (gamma, u, grad_log_p) x0 = jnp.zeros((10,), dtype=dtype) v0 = jnp.zeros((10,), dtype=dtype) y0_neal = (x0, v0) w_shape_neal = (10,) def get_terms_neal(bm): - return LangevinTerm(args_neal, bm, x0) + return make_langevin_term(gamma, u, grad_log_p, bm, x0) return SDE(get_terms_neal, None, y0_neal, t0, t1, w_shape_neal) @@ -593,13 +591,12 @@ def grad_f(x): u = 1.0 gamma = 2.0 - args = (u, gamma, grad_f) x0 = jnp.array([-1, 0, 1, 1, 0, -1, 1, 0, -1], dtype=dtype) v0 = jnp.zeros((9,), dtype=dtype) y0_uld3 = (x0, v0) w_shape_uld3 = (9,) def get_terms_uld3(bm): - return LangevinTerm(args, bm, x0) + return make_langevin_term(u, gamma, grad_f, bm, x0) return SDE(get_terms_uld3, None, y0_uld3, t0, t1, w_shape_uld3) diff --git a/test/test_langevin.py b/test/test_langevin.py index 6690ca8b..8625d7e6 100644 --- a/test/test_langevin.py +++ b/test/test_langevin.py @@ -4,7 +4,7 @@ import jax.random as jr import jax.tree_util as jtu import pytest -from diffrax import diffeqsolve, LangevinTerm, SaveAt +from diffrax import diffeqsolve, make_langevin_term, SaveAt from .helpers import ( get_bqp, @@ -26,6 +26,7 @@ def _solvers_and_orders(): yield diffrax.ALIGN(0.1), 2.0 yield diffrax.ShOULD(0.1), 3.0 yield diffrax.QUICSORT(0.1), 3.0 + yield diffrax.ShARK(), 2.0 def get_pytree_langevin(t0=0.3, t1=1.0, dtype=jnp.float32): @@ -63,11 +64,10 @@ def grad_f(x): xb = x["qq"] return {"rr": jtu.tree_map(lambda _x: 0.2 * _x, xa), "qq": xb} - args = g1, u1, grad_f w_shape = jtu.tree_map(lambda _x: jax.ShapeDtypeStruct(_x.shape, _x.dtype), x0) def get_terms(bm): - return LangevinTerm(args, bm, x0) + return make_langevin_term(g1, u1, grad_f, bm, x0) return SDE(get_terms, None, y0, t0, t1, w_shape) From 2b80e3b019a3de3efc83dfd485e97ce53ef684d4 Mon Sep 17 00:00:00 2001 From: andyElking Date: Sat, 17 Aug 2024 23:23:43 +0100 Subject: [PATCH 07/15] Nits --- diffrax/_solver/align.py | 14 +++---- diffrax/_solver/langevin_srk.py | 69 +++++++++++++++------------------ diffrax/_solver/quicsort.py | 14 +++---- diffrax/_solver/should.py | 14 +++---- diffrax/_term.py | 49 ++++++++++++----------- docs/api/terms.md | 2 + test/helpers.py | 13 +------ 7 files changed, 82 insertions(+), 93 deletions(-) diff --git a/diffrax/_solver/align.py b/diffrax/_solver/align.py index 53427bb8..fae453ea 100644 --- a/diffrax/_solver/align.py +++ b/diffrax/_solver/align.py @@ -10,7 +10,7 @@ RealScalarLike, ) from .._local_interpolation import LocalLinearInterpolation -from .._term import _LangevinTuple, _LangevinX +from .._term import LangevinTuple, LangevinX from .langevin_srk import ( _LangevinArgs, AbstractCoeffs, @@ -41,7 +41,7 @@ def __init__(self, beta, a1, b1, aa, chh): self.dtype = jnp.result_type(*all_leaves) -_ErrorEstimate = _LangevinTuple +_ErrorEstimate = LangevinTuple class ALIGN(AbstractLangevinSRK[_ALIGNCoeffs, _ErrorEstimate]): @@ -135,15 +135,15 @@ def _tay_coeffs_single(self, c: Array) -> _ALIGNCoeffs: def _compute_step( h: RealScalarLike, levy: AbstractSpaceTimeLevyArea, - x0: _LangevinX, - v0: _LangevinX, + x0: LangevinX, + v0: LangevinX, langevin_args: _LangevinArgs, coeffs: _ALIGNCoeffs, st: SolverState, - ) -> tuple[_LangevinX, _LangevinX, _LangevinX, _LangevinTuple]: + ) -> tuple[LangevinX, LangevinX, LangevinX, LangevinTuple]: dtypes = jtu.tree_map(jnp.dtype, x0) - w: _LangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) - hh: _LangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) + w: LangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) + hh: LangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) gamma, u, f = langevin_args diff --git a/diffrax/_solver/langevin_srk.py b/diffrax/_solver/langevin_srk.py index 526c2ebb..5884c917 100644 --- a/diffrax/_solver/langevin_srk.py +++ b/diffrax/_solver/langevin_srk.py @@ -1,5 +1,6 @@ import abc -from typing import Any, Callable, Generic, TypeVar +from collections.abc import Callable +from typing import Any, Generic, TypeVar import equinox as eqx import equinox.internal as eqxi @@ -8,7 +9,7 @@ import jax.tree_util as jtu from equinox import AbstractVar from jax import vmap -from jax._src.tree_util import PyTreeDef +from jax.tree_util import PyTreeDef from jaxtyping import Array, ArrayLike, PyTree from .._custom_types import ( @@ -20,19 +21,19 @@ from .._local_interpolation import LocalLinearInterpolation from .._solution import RESULTS from .._term import ( - _LangevinDiffusionTerm, - _LangevinDriftTerm, - _LangevinTuple, - _LangevinX, AbstractTerm, + LangevinDiffusionTerm, + LangevinDriftTerm, + LangevinTuple, + LangevinX, MultiTerm, WrapTerm, ) from .base import AbstractItoSolver, AbstractStratonovichSolver -_ErrorEstimate = TypeVar("_ErrorEstimate", None, _LangevinTuple) -_LangevinArgs = tuple[_LangevinX, _LangevinX, Callable[[_LangevinX], _LangevinX]] +_ErrorEstimate = TypeVar("_ErrorEstimate", None, LangevinTuple) +_LangevinArgs = tuple[LangevinX, LangevinX, Callable[[LangevinX], LangevinX]] def get_args_from_terms( @@ -40,20 +41,15 @@ def get_args_from_terms( ) -> _LangevinArgs: drift, diffusion = terms.terms if isinstance(drift, WrapTerm): - unwrapped_drift = drift.term assert isinstance(diffusion, WrapTerm) - unwrapped_diffusion = diffusion.term - assert isinstance(unwrapped_drift, _LangevinDriftTerm) - assert isinstance(unwrapped_diffusion, _LangevinDiffusionTerm) - gamma = unwrapped_drift.gamma - u = unwrapped_drift.u - f = unwrapped_drift.grad_f - else: - assert isinstance(drift, _LangevinDriftTerm) - assert isinstance(diffusion, _LangevinDiffusionTerm) - gamma = drift.gamma - u = drift.u - f = drift.grad_f + drift = drift.term + diffusion = diffusion.term + + assert isinstance(drift, LangevinDriftTerm) + assert isinstance(diffusion, LangevinDiffusionTerm) + gamma = drift.gamma + u = drift.u + f = drift.grad_f return gamma, u, f @@ -64,15 +60,12 @@ class AbstractCoeffs(eqx.Module): _Coeffs = TypeVar("_Coeffs", bound=AbstractCoeffs) -# TODO: I'm not sure if I can use the _Coeffs type here, -# given that I do not use Generic[_Coeffs] in the class definition. -# How should I work around this? class SolverState(eqx.Module, Generic[_Coeffs]): h: RealScalarLike - taylor_coeffs: PyTree[_Coeffs, "_LangevinX"] + taylor_coeffs: PyTree[_Coeffs, "LangevinX"] coeffs: _Coeffs - rho: _LangevinX - prev_f: _LangevinX + rho: LangevinX + prev_f: LangevinX # CONCERNING COEFFICIENTS: @@ -104,11 +97,11 @@ class AbstractLangevinSRK( where $v$ is the velocity, $f$ is the potential, $gamma$ and $u$ are the friction and momentum parameters, and $W$ is a Brownian motion. - Solvers which inherit from this class include ALIGN, SORT, ShOULD, and - QUIC_SORT. + Solvers which inherit from this class include [`diffrax.ALIGN`][], + [`diffrax.ShOULD`][], and [`diffrax.QUIC_SORT`][]. """ - term_structure = MultiTerm[tuple[_LangevinDriftTerm, _LangevinDiffusionTerm]] + term_structure = MultiTerm[tuple[LangevinDriftTerm, LangevinDiffusionTerm]] interpolation_cls = LocalLinearInterpolation taylor_threshold: RealScalarLike = eqx.field(static=True) _coeffs_structure: eqx.AbstractClassVar[PyTreeDef] @@ -150,7 +143,7 @@ def _eval_taylor(h, tay_coeffs: _Coeffs) -> _Coeffs: ) def _recompute_coeffs( - self, h, gamma: _LangevinX, tay_coeffs: PyTree[_Coeffs], state_h + self, h, gamma: LangevinX, tay_coeffs: PyTree[_Coeffs], state_h ) -> _Coeffs: def recompute_coeffs_leaf(c: ArrayLike, _tay_coeffs: _Coeffs): # Used when the step-size h changes and coefficients need to be recomputed @@ -201,7 +194,7 @@ def init( terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], t0: RealScalarLike, t1: RealScalarLike, - y0: _LangevinTuple, + y0: LangevinTuple, args: PyTree, ) -> SolverState: """Precompute _SolverState which carries the Taylor coefficients and the @@ -242,12 +235,12 @@ def _check_shapes(_c, _u, _x, _v): def _compute_step( h: RealScalarLike, levy, - x0: _LangevinX, - v0: _LangevinX, + x0: LangevinX, + v0: LangevinX, langevin_args: _LangevinArgs, coeffs: _Coeffs, st: SolverState, - ) -> tuple[_LangevinX, _LangevinX, _LangevinX, _ErrorEstimate]: + ) -> tuple[LangevinX, LangevinX, LangevinX, _ErrorEstimate]: raise NotImplementedError def step( @@ -255,11 +248,11 @@ def step( terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], t0: RealScalarLike, t1: RealScalarLike, - y0: _LangevinTuple, + y0: LangevinTuple, args: PyTree, solver_state: SolverState, made_jump: BoolScalarLike, - ) -> tuple[_LangevinTuple, _ErrorEstimate, DenseInfo, SolverState, RESULTS]: + ) -> tuple[LangevinTuple, _ErrorEstimate, DenseInfo, SolverState, RESULTS]: del made_jump, args st = solver_state drift, diffusion = terms.terms @@ -319,7 +312,7 @@ def func( self, terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], t0: RealScalarLike, - y0: _LangevinTuple, + y0: LangevinTuple, args: PyTree, ): return terms.vf(t0, y0, args) diff --git a/diffrax/_solver/quicsort.py b/diffrax/_solver/quicsort.py index 1dfe2649..6b128116 100644 --- a/diffrax/_solver/quicsort.py +++ b/diffrax/_solver/quicsort.py @@ -13,7 +13,7 @@ RealScalarLike, ) from .._local_interpolation import LocalLinearInterpolation -from .._term import _LangevinX +from .._term import LangevinX from .langevin_srk import ( _LangevinArgs, AbstractCoeffs, @@ -186,16 +186,16 @@ def _tay_coeffs_single(self, c: Array) -> _QUICSORTCoeffs: def _compute_step( h: RealScalarLike, levy: AbstractSpaceTimeTimeLevyArea, - x0: _LangevinX, - v0: _LangevinX, + x0: LangevinX, + v0: LangevinX, langevin_args: _LangevinArgs, coeffs: _QUICSORTCoeffs, st: SolverState, - ) -> tuple[_LangevinX, _LangevinX, _LangevinX, None]: + ) -> tuple[LangevinX, LangevinX, LangevinX, None]: dtypes = jtu.tree_map(jnp.dtype, x0) - w: _LangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) - hh: _LangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) - kk: _LangevinX = jtu.tree_map(jnp.asarray, levy.K, dtypes) + w: LangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) + hh: LangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) + kk: LangevinX = jtu.tree_map(jnp.asarray, levy.K, dtypes) gamma, u, f = langevin_args diff --git a/diffrax/_solver/should.py b/diffrax/_solver/should.py index 0940a58f..813a31b5 100644 --- a/diffrax/_solver/should.py +++ b/diffrax/_solver/should.py @@ -10,7 +10,7 @@ RealScalarLike, ) from .._local_interpolation import LocalLinearInterpolation -from .._term import _LangevinX +from .._term import LangevinX from .langevin_srk import ( _LangevinArgs, AbstractCoeffs, @@ -184,16 +184,16 @@ def _tay_coeffs_single(self, c: Array) -> _ShOULDCoeffs: def _compute_step( h: RealScalarLike, levy: AbstractSpaceTimeTimeLevyArea, - x0: _LangevinX, - v0: _LangevinX, + x0: LangevinX, + v0: LangevinX, langevin_args: _LangevinArgs, coeffs: _ShOULDCoeffs, st: SolverState, - ) -> tuple[_LangevinX, _LangevinX, _LangevinX, None]: + ) -> tuple[LangevinX, LangevinX, LangevinX, None]: dtypes = jtu.tree_map(jnp.dtype, x0) - w: _LangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) - hh: _LangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) - kk: _LangevinX = jtu.tree_map(jnp.asarray, levy.K, dtypes) + w: LangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) + hh: LangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) + kk: LangevinX = jtu.tree_map(jnp.asarray, levy.K, dtypes) gamma, u, f = langevin_args diff --git a/diffrax/_term.py b/diffrax/_term.py index 86467c07..fc44462f 100644 --- a/diffrax/_term.py +++ b/diffrax/_term.py @@ -791,12 +791,13 @@ def _to_vjp(_y, _diff_args, _diff_term): # `x` and the velocity `v`. Both of these have the same shape. So, by LangevinX we # denote the shape of the x component, and by LangevinTuple we denote the shape of # the tuple (x, v). -_LangevinX = PyTree[Shaped[Array, "?*langevin"], "LangevinX"] -_LangevinTuple = tuple[_LangevinX, _LangevinX] -_LangevinBM = TypeVar("_LangevinBM", bound=Union[_LangevinX, AbstractBrownianIncrement]) +LangevinX = PyTree[Shaped[Array, "?*langevin"], "LangevinX"] +LangevinTuple = tuple[LangevinX, LangevinX] -class _LangevinDiffusionTerm(AbstractTerm[_LangevinX, _LangevinBM]): +class LangevinDiffusionTerm( + AbstractTerm[LangevinX, Union[LangevinX, AbstractBrownianIncrement]] +): r"""Represents the diffusion term in the Langevin SDE: $d \mathbf{x}_t = \mathbf{v}_t dt$ @@ -805,11 +806,11 @@ class _LangevinDiffusionTerm(AbstractTerm[_LangevinX, _LangevinBM]): \nabla f( \mathbf{x}_t ) dt + \sqrt{2 \gamma u} d W_t.$ """ - gamma: _LangevinX - u: _LangevinX + gamma: LangevinX + u: LangevinX control: AbstractBrownianPath - def vf(self, t: RealScalarLike, y: _LangevinTuple, args: Args) -> _LangevinX: + def vf(self, t: RealScalarLike, y: LangevinTuple, args: Args) -> LangevinX: x, v = y def _fun(_gamma, _u, _v): @@ -818,13 +819,12 @@ def _fun(_gamma, _u, _v): d_v = jtu.tree_map(_fun, self.gamma, self.u, v) return d_v - def contr(self, t0: RealScalarLike, t1: RealScalarLike, **kwargs) -> _LangevinBM: + def contr( + self, t0: RealScalarLike, t1: RealScalarLike, **kwargs + ) -> Union[LangevinX, AbstractBrownianIncrement]: return self.control.evaluate(t0, t1, **kwargs) - def prod(self, vf: _LangevinX, control: _LangevinX) -> _LangevinTuple: - if isinstance(control, AbstractBrownianIncrement): - control = control.W - + def prod(self, vf: LangevinX, control: LangevinX) -> LangevinTuple: dv = vf dw = control v_out = jtu.tree_map(operator.mul, dv, dw) @@ -843,12 +843,12 @@ def _inner_broadcast(_src_arr, _inner_tree_shape): return jtu.tree_map(_inner_broadcast, source, target_tree_shape) -class _LangevinDriftTerm(AbstractTerm): - gamma: _LangevinX - u: _LangevinX - grad_f: Callable[[_LangevinX], _LangevinX] +class LangevinDriftTerm(AbstractTerm): + gamma: LangevinX + u: LangevinX + grad_f: Callable[[LangevinX], LangevinX] - def vf(self, t: RealScalarLike, y: _LangevinTuple, args: Args) -> _LangevinTuple: + def vf(self, t: RealScalarLike, y: LangevinTuple, args: Args) -> LangevinTuple: x, v = y f_x = self.grad_f(x) d_x = v @@ -865,7 +865,7 @@ def vf(self, t: RealScalarLike, y: _LangevinTuple, args: Args) -> _LangevinTuple def contr(self, t0: RealScalarLike, t1: RealScalarLike, **kwargs) -> RealScalarLike: return t1 - t0 - def prod(self, vf: _LangevinTuple, control: RealScalarLike) -> _LangevinTuple: + def prod(self, vf: LangevinTuple, control: RealScalarLike) -> LangevinTuple: return jtu.tree_map(lambda _vf: control * _vf, vf) @@ -874,16 +874,19 @@ def make_langevin_term( u: PyTree[ArrayLike], grad_f: Callable, bm: AbstractBrownianPath, - x0: _LangevinX, -) -> MultiTerm[tuple[_LangevinDriftTerm, _LangevinDiffusionTerm]]: + x0: LangevinX, +) -> MultiTerm[tuple[LangevinDriftTerm, LangevinDiffusionTerm]]: r"""Creates a term that represents the Underdamped Langevin Diffusion, given by: + $d \mathbf{x}_t = \mathbf{v}_t dt$ + $d \mathbf{v}_t = - \gamma \mathbf{v}_t dt - u \nabla f( \mathbf{x}_t ) dt + \sqrt{2 \gamma u} d W_t.$ + where $\mathbf{x}_t, \mathbf{v}_t \in \mathbb{R}^d$ represent the position and velocity, $W$ is a Brownian motion in $\mathbb{R}^d$, $f: \mathbb{R}^d \rightarrow \mathbb{R}$ is a potential function, and - $ \gamma,u\in\mathbb{R}^{d\times d}$ are diagonal matrices governing + $\gamma , u \in \mathbb{R}^{d \times d}$ are diagonal matrices governing the friction and the dampening of the system. **Arguments:** @@ -915,6 +918,6 @@ def _shape_check_fun(_x, _g, _u, _fx): jtu.tree_map(_shape_check_fun, x0, gamma, u, grad_f_shape) ), "The shapes of gamma, u, and grad_f(x0) must be the same as x0." - drift = _LangevinDriftTerm(gamma, u, grad_f) - diffusion = _LangevinDiffusionTerm(gamma, u, bm) + drift = LangevinDriftTerm(gamma, u, grad_f) + diffusion = LangevinDiffusionTerm(gamma, u, bm) return MultiTerm(drift, diffusion) diff --git a/docs/api/terms.md b/docs/api/terms.md index 553b3fbb..6aee5b78 100644 --- a/docs/api/terms.md +++ b/docs/api/terms.md @@ -91,3 +91,5 @@ Some example term structures include: selection: members: - __init__ + +::: diffrax.make_langevin_term \ No newline at end of file diff --git a/test/helpers.py b/test/helpers.py index d27e465c..82bb4e1e 100644 --- a/test/helpers.py +++ b/test/helpers.py @@ -182,8 +182,6 @@ def _batch_sde_solve( saveat=saveat, ) steps = sol.stats["num_accepted_steps"] - if isinstance(solver, diffrax.HalfSolver): - steps *= 3 return sol.ys, steps @@ -296,21 +294,14 @@ def sde_solver_strong_order( return steps_arr, errs_arr, order -@dataclasses.dataclass(unsafe_hash=True) +@dataclasses.dataclass(frozen=True) class SDE: get_terms: Callable[[AbstractBrownianPath], AbstractTerm] args: PyTree y0: PyTree[Array] t0: float t1: float - _w_shape: Union[tuple[int, ...], PyTree[jax.ShapeDtypeStruct]] - - @property - def w_shape(self): - if is_tuple_of_ints(self._w_shape): - return self._w_shape - else: - return self._w_shape + w_shape: Union[tuple[int, ...], PyTree[jax.ShapeDtypeStruct]] def get_dtype(self): return jnp.result_type(*jtu.tree_leaves(self.y0)) From e38a9329283d774d869b453a5a5e364402204ca7 Mon Sep 17 00:00:00 2001 From: andyElking Date: Sun, 18 Aug 2024 15:44:28 +0100 Subject: [PATCH 08/15] Added Langevin docs, a Langevin example and backwards in time test --- diffrax/_solver/align.py | 16 +--- diffrax/_solver/langevin_srk.py | 10 ++- diffrax/_solver/quicsort.py | 17 +--- diffrax/_solver/should.py | 16 +--- docs/api/solvers/sde_solvers.md | 37 ++++++++ examples/langevin_example.ipynb | 151 ++++++++++++++++++++++++++++++++ mkdocs.yml | 1 + test/test_langevin.py | 37 ++++++++ 8 files changed, 242 insertions(+), 43 deletions(-) create mode 100644 examples/langevin_example.ipynb diff --git a/diffrax/_solver/align.py b/diffrax/_solver/align.py index fae453ea..7ce805e2 100644 --- a/diffrax/_solver/align.py +++ b/diffrax/_solver/align.py @@ -19,10 +19,7 @@ ) -# UBU evaluates at l = (3 -sqrt(3))/6, at r = (3 + sqrt(3))/6 and at 1, -# so we need 3 versions of each coefficient - - +# For an explanation of the coefficients, see langevin_srk.py class _ALIGNCoeffs(AbstractCoeffs): beta: PyTree[ArrayLike] a1: PyTree[ArrayLike] @@ -46,15 +43,8 @@ def __init__(self, beta, a1, b1, aa, chh): class ALIGN(AbstractLangevinSRK[_ALIGNCoeffs, _ErrorEstimate]): r"""The Adaptive Langevin via Interpolated Gradients and Noise method - designed by James Foster. Only works for Underdamped Langevin Diffusion - of the form - - $$d x_t = v_t dt$$ - - $$d v_t = - gamma v_t dt - u ∇f(x_t) dt + (2gammau)^(1/2) dW_t$$ - - where $v$ is the velocity, $f$ is the potential, $gamma$ is the friction, and - $W$ is a Brownian motion. + designed by James Foster. + Accepts only terms given by [`diffrax.make_langevin_term`][]. """ interpolation_cls = LocalLinearInterpolation diff --git a/diffrax/_solver/langevin_srk.py b/diffrax/_solver/langevin_srk.py index 5884c917..59a444f3 100644 --- a/diffrax/_solver/langevin_srk.py +++ b/diffrax/_solver/langevin_srk.py @@ -198,7 +198,7 @@ def init( args: PyTree, ) -> SolverState: """Precompute _SolverState which carries the Taylor coefficients and the - SRK coefficients (which can be computed from h and the Taylor coeffs). + SRK coefficients (which can be computed from h and the Taylor coefficients). Some solvers of this type are FSAL, so _SolverState also carries the previous evaluation of grad_f. """ @@ -259,16 +259,18 @@ def step( gamma, u, f = get_args_from_terms(terms) h = drift.contr(t0, t1) - h_state = st.h + h_prev = st.h tay: PyTree[_Coeffs] = st.taylor_coeffs coeffs: _Coeffs = st.coeffs # If h changed recompute coefficients - cond = jnp.isclose(h_state, h, rtol=1e-10, atol=1e-12) + # Even when using constant step sizes, h can fluctuate by small amounts, + # so we use `jnp.isclose` for comparison + cond = jnp.isclose(h_prev, h, rtol=1e-10, atol=1e-12) coeffs = lax.cond( cond, lambda x: x, - lambda _: self._recompute_coeffs(h, gamma, tay, h_state), + lambda _: self._recompute_coeffs(h, gamma, tay, h_prev), coeffs, ) diff --git a/diffrax/_solver/quicsort.py b/diffrax/_solver/quicsort.py index 6b128116..58749592 100644 --- a/diffrax/_solver/quicsort.py +++ b/diffrax/_solver/quicsort.py @@ -22,10 +22,9 @@ ) +# For an explanation of the coefficients, see langevin_srk.py # UBU evaluates at l = (3 -sqrt(3))/6, at r = (3 + sqrt(3))/6 and at 1, # so we need 3 versions of each coefficient - - class _QUICSORTCoeffs(AbstractCoeffs): beta_lr1: PyTree[ArrayLike] # (gamma, 3, *taylor) a_lr1: PyTree[ArrayLike] # (gamma, 3, *taylor) @@ -66,14 +65,7 @@ class QUICSORT(AbstractLangevinSRK[_QUICSORTCoeffs, None]): } ``` - Works for underdamped Langevin SDEs of the form - - $$d x_t = v_t dt$$ - - $$d v_t = - gamma v_t dt - u ∇f(x_t) dt + (2gammau)^(1/2) dW_t$$ - - where $v$ is the velocity, $f$ is the potential, $gamma$ is the friction, and - $W$ is a Brownian motion. + Accepts only terms given by [`diffrax.make_langevin_term`][]. """ interpolation_cls = LocalLinearInterpolation @@ -246,9 +238,8 @@ def _one(coeff): ).ω v_out = (v_out_tilde**ω - st.rho**ω * (hh**ω - 6 * kk**ω)).ω - f_fsal = ( - st.prev_f - ) # this method is not FSAL, but this is for compatibility with the base class + # this method is not FSAL, but for compatibility with the base class we set + f_fsal = st.prev_f # TODO: compute error estimate return x_out, v_out, f_fsal, None diff --git a/diffrax/_solver/should.py b/diffrax/_solver/should.py index 813a31b5..27138e01 100644 --- a/diffrax/_solver/should.py +++ b/diffrax/_solver/should.py @@ -19,10 +19,7 @@ ) -# UBU evaluates at l = (3 -sqrt(3))/6, at r = (3 + sqrt(3))/6 and at 1, -# so we need 3 versions of each coefficient - - +# For an explanation of the coefficients, see langevin_srk.py class _ShOULDCoeffs(AbstractCoeffs): beta_half: PyTree[ArrayLike] a_half: PyTree[ArrayLike] @@ -63,15 +60,8 @@ def __init__(self, beta_half, a_half, b_half, beta1, a1, b1, aa, chh, ckk): class ShOULD(AbstractLangevinSRK[_ShOULDCoeffs, None]): r"""The Shifted-ODE Runge-Kutta Three method - designed by James Foster. Only works for Underdamped Langevin Diffusion - of the form - - $$d x_t = v_t dt$$ - - $$d v_t = - gamma v_t dt - u ∇f(x_t) dt + (2gammau)^(1/2) dW_t$$ - - where $v$ is the velocity, $f$ is the potential, $gamma$ is the friction, and - $W$ is a Brownian motion. + designed by James Foster. + Accepts only terms given by [`diffrax.make_langevin_term`][]. """ interpolation_cls = LocalLinearInterpolation diff --git a/docs/api/solvers/sde_solvers.md b/docs/api/solvers/sde_solvers.md index ecc9fbf9..fc91e643 100644 --- a/docs/api/solvers/sde_solvers.md +++ b/docs/api/solvers/sde_solvers.md @@ -113,3 +113,40 @@ These are reversible in the same way as when applied to ODEs. [See here.](./ode_ selection: members: - __init__ + + +--- + +### Underdamped Langevin solvers + +These solvers are specifically designed for the Underdamped Langevin diffusion (ULD), +which takes the form + +$d \mathbf{x}_t = \mathbf{v}_t dt$ + +$d \mathbf{v}_t = - \gamma \mathbf{v}_t dt - u +\nabla f( \mathbf{x}_t ) dt + \sqrt{2 \gamma u} d W_t.$ + +where $\mathbf{x}_t, \mathbf{v}_t \in \mathbb{R}^d$ represent the position +and velocity, $W$ is a Brownian motion in $\mathbb{R}^d$, +$f: \mathbb{R}^d \rightarrow \mathbb{R}$ is a potential function, and +$\gamma , u \in \mathbb{R}^{d \times d}$ are diagonal matrices governing +the friction and the dampening of the system. + +They are more precise for this diffusion than the general-purpose solvers above, but +cannot be used for any other SDEs. They only accept terms generated by the +[`diffrax.make_langevin_term`][] function. They all have the same `__init__` signature. +For an example of their usage, see the [Langevin example](../../examples/langevin_example.ipynb). + +::: diffrax.ALIGN + selection: + members: + - __init__ + +::: diffrax.ShOULD + selection: + members: false + +::: diffrax.QUICSORT + selection: + members: false \ No newline at end of file diff --git a/examples/langevin_example.ipynb b/examples/langevin_example.ipynb new file mode 100644 index 00000000..818f6de0 --- /dev/null +++ b/examples/langevin_example.ipynb @@ -0,0 +1,151 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d0b76d478a4179b0", + "metadata": {}, + "source": [ + "# Underdamped Langevin Diffusion simulation\n", + "\n", + "The Underdamped Langevin diffusion (ULD) is an SDE of the form:\n", + "\n", + "\\begin{align*}\n", + " d \\mathbf{x}_t &= \\mathbf{v}_t \\, dt \\\\\n", + " d \\mathbf{v}_t &= - \\gamma \\, \\mathbf{v}_t \\, dt - u \\,\n", + " \\nabla \\! f( \\mathbf{x}_t ) \\, dt + \\sqrt{2 \\gamma u} \\, d W_t,\n", + "\\end{align*}\n", + "\n", + "where $\\mathbf{x}_t, \\mathbf{v}_t \\in \\mathbb{R}^d$ represent the position\n", + "and velocity, $W$ is a Brownian motion in $\\mathbb{R}^d$,\n", + "$f: \\mathbb{R}^d \\rightarrow \\mathbb{R}$ is a potential function, and\n", + "$\\gamma , u \\in \\mathbb{R}^{d \\times d}$ are diagonal matrices governing\n", + "the friction and the dampening of the system.\n", + "\n", + "## ULD for Monte Carlo and Bayesian inference\n", + "\n", + "ULD is commonly used in Monte Carlo applications since it allows us to sample from its stationary distribution $p = \\frac{\\exp(-f)}{C}$ even when its normalising constant $C = \\int p(x) dx$ is unknown. This is because only knowledge of $\\nabla f$ is required, which doesn't depend on $C$. For an example of such an application see section 5.2 of the paper on [Single-seed generation of Brownian paths](https://arxiv.org/abs/2405.06464).\n", + "\n", + "## ULD solvers in Diffrax\n", + "\n", + "In addition to generic SDE solvers (which can solve any SDE including ULD), Diffrax has some solvers designed specifically for ULD. These are `diffrax.ALIGN` which has a 2nd order of strong convergence, and `diffrax.QUICSORT` and `diffrax.ShOULD` which are 3rd order solvers. Note that unlike ODE solvers which can have orders of 5 or even higher, very few types of SDEs permit solvers with a strong order greater than $\\frac{1}{2}$.\n", + "\n", + "These Langevin-specific solvers only accept terms retuned by `diffrax.make_langevin_term`.\n", + "\n", + "## A 2D harmonic oscillator\n", + "\n", + "In this example we will simulate a simple harmonic oscillator in 2 dimensions. This system is given by the potential $f(x) = x^2$." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9deba250066ddc39", + "metadata": { + "ExecuteTime": { + "end_time": "2024-08-18T14:34:51.363600Z", + "start_time": "2024-08-18T14:34:48.606225Z" + } + }, + "outputs": [], + "source": [ + "from warnings import simplefilter\n", + "\n", + "\n", + "simplefilter(action=\"ignore\", category=FutureWarning)\n", + "import diffrax\n", + "import jax.numpy as jnp\n", + "import jax.random as jr\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "t0, t1 = 0.0, 20.0\n", + "dt0 = 0.05\n", + "saveat = diffrax.SaveAt(steps=True)\n", + "\n", + "# Parameters\n", + "gamma = jnp.array([2, 0.5], dtype=jnp.float32)\n", + "u = jnp.array([0.5, 2], dtype=jnp.float32)\n", + "x0 = jnp.zeros((2,), dtype=jnp.float32)\n", + "v0 = jnp.zeros((2,), dtype=jnp.float32)\n", + "y0 = (x0, v0)\n", + "\n", + "# Brownian motion\n", + "bm = diffrax.VirtualBrownianTree(\n", + " t0, t1, tol=0.01, shape=(2,), key=jr.key(0), levy_area=diffrax.SpaceTimeTimeLevyArea\n", + ")\n", + "\n", + "# Use the make_langevin_term function to create the terms\n", + "terms = diffrax.make_langevin_term(gamma, u, lambda x: 2 * x, bm, x0)\n", + "\n", + "solver = diffrax.QUICSORT(0.1)\n", + "sol = diffrax.diffeqsolve(\n", + " terms, solver, t0, t1, dt0=dt0, y0=y0, args=None, saveat=saveat\n", + ")\n", + "xs, vs = sol.ys" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "62da2ddbaaf98f47", + "metadata": { + "ExecuteTime": { + "end_time": "2024-08-18T14:34:52.378938Z", + "start_time": "2024-08-18T14:34:52.259089Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1kAAANBCAYAAAAShHTFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzddXhUV/rA8e+dibt7QgLBNbgUimtpabcu1Lv1dtluf9uV+rbdylapC3VvqeEOxQnBgyUhbsR97PfHmUmgJMRm5s4k5/M8PPeSzNz75kZm3nve8x7FZDKZkCRJkiRJkiRJkqxCo3YAkiRJkiRJkiRJXYlMsiRJkiRJkiRJkqxIJlmSJEmSJEmSJElWJJMsSZIkSZIkSZIkK5JJliRJkiRJkiRJkhXJJEuSJEmSJEmSJMmKZJIlSZIkSZIkSZJkRTLJkiRJkiRJkiRJsiIXtQNwdEajkdzcXHx9fVEURe1wJEmSJEmSJElSiclkorKykqioKDSalserZJLVitzcXGJjY9UOQ5IkSZIkSZIkB5GVlUVMTEyLn5dJVit8fX0BcSH9/PxUiUGn07Fq1SpmzpyJq6urKjF0dfIa25a8vrYlr6/tyWtsW/L62pa8vrYlr6/tOdI1rqioIDY2tjFHaIlMslphKRH08/NTNcny8vLCz89P9R+srkpeY9uS19e25PW1PXmNbUteX9uS19e25PW1PUe8xq1NI5KNLyRJkiRJkiRJkqxIJlmSJEmSJEmSJElWJJMsSZIkSZIkSZIkK5JzsiRJkiRJkiRJAkSLcr1ej8FgUDuURjqdDhcXF+rq6mwel1arxcXFpdNLN8kkS5IkSZIkSZIkGhoayMvLo6amRu1QzmIymYiIiCArK8su69Z6eXkRGRmJm5tbh48hkyxJkiRJkiRJ6uaMRiPp6elotVqioqJwc3OzS0LTFkajkaqqKnx8fM67AHBnmUwmGhoaKCoqIj09nd69e3f4fDLJkiRJkiRJkqRurqGhAaPRSGxsLF5eXmqHcxaj0UhDQwMeHh42TbIAPD09cXV15dSpU43n7AjZ+EKSJEmSJEmSJACbJzHOwBrXQF5FSZIkSZIkSZIkK5JJliRJkiRJkiRJkhXJJEuSJEmSJEmSJMmKZJIlSZLkiOoq4NBSyEkGo1HtaCRJkiTJKeXl5XHttdfSp08fNBoNDz74oF3OK7sLSpIkORKTCTa/CL+/DvXl4mN+MXDVJxA9Qt3YJEmSJMnJ1NfXExoayr/+9S9efvllu51XjmRJkiQ5kpQvYN3TIsEKiAM3H6jIhu9uhYZqtaOTJEmSugmTyURNg16VfyaTqc1xFhUVERERwTPPPNP4sa1bt+Lm5sbatWuJj4/n1VdfZeHChfj7+9viUjVLjmRJkiQ5ipoSWP1vsT/pYZj8CNRXwFvjoTQdVj8G815UN0ZJkiSpW6jVGRjw6EpVzn34yVl4ubUtTQkNDeXDDz9kwYIFzJw5k759+3LDDTdw7733Mm3aNBtH2jI5kiVJkuQo1j0FNachtB9c+DBoNOAZAJe8IT6/6z3I3qNqiJIkSZLkaObOncvtt9/Oddddx5133om3tzfPPvusqjHJkSxJkiRHUFMCyZ+I/Xkvgda16XO9psLQa2Dfl7D+abjhR3VilCRJkroNT1cth5+cpdq52+vFF19k0KBBfPvtt+zZswd3d3cbRNZ2MsmSJElyBEd+BqMewgdB/AXnfn7y3+HAt3ByHZzaCj3G2z9GSZIkqdtQFKXNJXuO4OTJk+Tm5mI0GsnIyGDw4MGqxiPLBSVJkhzBge/EdtCfmv98YDwk3SD21/3HLiFJkiRJkjNoaGjg+uuv56qrruKpp57itttuo7CwUNWYZJIlSZKktoo8yNgi9ltKsgAmPQQaVzi1BbJ32yc2SZIkSXJw//znPykvL+e1117j//7v/+jTpw+33HJL4+dTUlJISUmhqqqKoqIiUlJSOHz4sE1jkkmWJEmS2g4vBUwQMxoCe7T8OP8YGHyF2N/2hj0ikyRJkiSHtmHDBl555RU+/fRT/Pz80Gg0fPrpp2zevJm33noLgKSkJJKSktizZw9ffPEFSUlJzJ0716ZxOU+hpSRJUld1bIXYDrqs9ceOuwf2fQGHf4LSU+dPyiRJkiSpi5s8eTI6ne6sj8XHx1NeXt74//asu2UtciRLkiRJTSYT5OwV+z0mtP74iEHQcwqYjLDjHdvGJkmSJElSh8gkS5IkSU0laVBfDlp3COvftueMvUtsD3wDRoPtYpMkSZIkqUNkkiVJkqSmXPMoVsTgs9fGOp9eU8EjAKqL4NTvNgtNkiRJkqSOkUmWJEmSmixJVvTwtj9H6wr9LxL7h5ZaPSRJkiRJkjpHJlmSJElqykkW26ik9j1vwKVie+QXWTIoSZIkSQ5GJlmSJElqMRogb5/Yb2+S1fNCc8lgIUrWNquHJkmSJElSx8kkS5IkSS3Fx0FXDa7eENKnfc/VukI/UTKoHF1mg+AkSZIkSeoomWRJkiSpJddcKhg5FDTa9j+/zywANCfXWDEoSZIkSZI6SyZZkiRJaik4JLaRQzr2/J6TQeOCUpKGV32B1cKSJEmSJKlzZJIlSZKkluLjYtveUkELDz+IHQtAeMV+KwUlSZIkSV3HDz/8wIwZMwgNDcXPz49x48axcuVKm5/XqZKsTZs2MX/+fKKiolAUhaVLl5738Rs2bEBRlHP+5efn2ydgSZKk8yk+JrYdTbIAek8HIEwmWZIkSZJ0jk2bNjFjxgyWLVvGnj17mDJlCvPnz2fv3r02Pa9TJVnV1dUMHTqUxYsXt+t5R48eJS8vr/FfWFiYjSKUJElqI10dlJ0S+51JshJniENUHgF9nRUCkyRJkiTnUVRUREREBM8880zjx7Zu3Yqbmxtr167llVde4eGHH2bUqFH07t2bZ555ht69e/PLL7/YNC4Xmx7dyubMmcOcOXPa/bywsDACAgKsH5AkSVJHlaSByQju/uDTiRs/4QMx+UbiUpmHPmsn9JlmvRglSZKk7stkAl2NOud29QJFadNDQ0ND+fDDD1mwYAEzZ86kb9++3HDDDdx7771Mm3bua6LRaKSyspKgoCBrR30Wp0qyOmrYsGHU19czaNAgHn/8cSZMmNDiY+vr66mvr2/8f0VFBQA6nQ6dTmfzWJtjOa9a5+8O5DW2LXl9z6UUHMYFMAYnYtDrO3es6NG4pP6EMXsXuoRJ1glQOov8GbYteX1tS15f2+oq11en02EymTAajRiNRmioRvNcjCqxGP+eDW7ejf83mUyNW6PReM7jZ8+ezW233cZ1113HiBEj8Pb25j//+U+zj33hhReoqqri8ssvb/bzIBIxk8mETqdDqz27+29bv8+KyRK1k1EUhR9//JEFCxa0+JijR4+yYcMGRo4cSX19Pe+//z6ffvopO3bsYPjw4c0+5/HHH+eJJ5445+NffPEFXl5e1gpfkqRurk/+Uvrn/UBm0AXs7XFHp47Vq2A5g3K/JNd/BLt6PmClCCVJkqTuxMXFhYiICGJjY3FzcwNdDQGL+6sSS9k9R8RoVjvU1tYyfvx4cnJyWL9+PQMHDjznMd9++y0PPvggn3/+OZMnT27xWA0NDWRlZZGfn4/+DzdCa2pquPbaaykvL8fPz6/FY3TpJKs5F154IXFxcXz66afNfr65kazY2FiKi4vPeyFtSafTsXr1ambMmIGrq6sqMXR18hrblry+59Iu/TOaQ99jmPIoxvH3d+pYhrRNeHx5GUafSAwPHLBShNKZuvrPcFpRNSU1DQyL8cdFa//p2l39+qpNXl/b6irXt66ujqysLOLj4/Hw8HCockGTyURlZSW+vr4oLZQRHjx4kDFjxqDT6fj++++ZP3/+WZ//6quvuO222/j666+ZN2/eeU9fV1dHRkYGsbGx4lqcoaKigpCQkFaTrG5RLnim0aNHs2XLlhY/7+7ujru7+zkfd3V1Vf0XxxFi6OrkNbYteX3PUHICAG14P7SdvSYxwzGhoKnKQ1N3GnwjrBCg1Jyu+DN8vKCSS97aRp3OiL+nK1P7hTGtfxhhvh4EeLnSO8wHRVEorqrHx90FD9cOLJzdRl3x+joSeX1ty9mvr8FgQFEUNBoNGo35ZovWV92gzCxlfZb4/qihoYGFCxdy1VVX0bdvX+644w4OHDjQ2Ozuyy+/5NZbb+Wrr746J/lqjkajQVGUZr+nbf0ed7skKyUlhcjISLXDkCSpOzMaO79G1pncfKj0iMavLhtykqHf3M4fU+oW6nQG7vtyL3U6I1qNQnmtjh/35vDj3pzGx/SP9CPEx40tJ4qJ8vfkjWuTSIoLVDFqSZKks/3zn/+kvLyc1157DR8fH5YtW8Ytt9zCr7/+yhdffMGNN97Iq6++ypgxYxqXcvL09MTf399mMTlVklVVVcWJEyca/5+enk5KSgpBQUHExcXxyCOPkJOTwyeffALAK6+8QkJCAgMHDqSuro7333+fdevWsWrVKrW+BEmSJKjMFSUYGhcIjLfKIUu9EkSSlSuTLKntnv7tMKn5lYT4uPHrfRPJLKlh9eF8tqWdpqbeQE5ZLUfyKhofn1NWy5XvbON/Vw5j/tAoFSOXJEkSNmzYwCuvvML69esby/c+/fRThg4dyltvvcXXX3+NXq/nnnvu4Z577ml83o033siSJUtsFpdTJVm7d+9mypQpjf9ftGgR0HSR8vLyyMzMbPx8Q0MDf/3rX8nJycHLy4shQ4awZs2as44hSZJkd5ZRrMAE0FqntKTMqyc9SjaLkSxJaoOvdmby2XbxmvniFUOJ8Pcgwt+D0QlNbY3Lahr4cW8O1fV6pvYL5431x1l2IJ9//HCAUfFBRPh7tHR4SZIku5g8efI5Hf/i4+MpLy8H4K677lIjLOdKsiZPnsz5+nT8MRt9+OGHefjhh20clSRJUjuVpIltUE+rHbLMO0Hs5CaLycptXF9E6p62nizm3z8dBOCvM/owuW/za7UFeLlx84SExv+/fs1wcsq2si+rjMd+Psg7N4y0S7ySJEnOxv4thCRJkrq70nSxtWKSVe4Rh0nrBrWlTceXpGasTy3k5o92oTOYmDs4gnunJrb5uVqNwnOXDcZFo7DyUAFrjxTYMFJJkiTnJZMsSZIkeyuxfpJl0rhgCjOvCSJLBqVmnCyq4qFv93HbJ7up1xuZ1i+M/105rMV2yC3pH+nHrReI0a3X1h4/b4WJJElSd+VU5YKSJEldQmOSlXD+x7WTKSoJ8vZC7l4YfLlVjy05puKqejYfL6KsRkdOaS2p+ZX4uLswKiGIi4dGEerrTp3OwGtrj/PupjT0RpEQXTY8mv/+aQiuHVwT6/ZJPfl4Wwb7ssv5/cRpLugdYs0vS5IkyenJJEuSJMmeTCabzMkCMEUNhz0fypEsO6is0/HBlnQyiqvRGU3MHBDORUOi0GrsMxfudFU9H287xfub06hpMJzz+RWH8nl1zTGuGRPHzym55JXXATC1Xxj3TU3sdAv2EB93rh4Vx5KtGSxef0ImWZIkSX8gkyxJkiR7qswHfS0oGvCPteqhTZFJYidvHxgNoLHdorHd2ebjRfzfd/vJNScuAL/tz+ONdSd49eokBkT52ezcdToD/156kKUpOegMYlSqX4QvvcJ8CPVxp1+EL6U1On7Zl8vhvAre2SgS+ih/Dx67eCCzBlpvoerbJ/Xks+2n2JZ2ml0ZJYyKD2r9SZIkOTxZAmydayCTLEmSJHuyNKXwjwUXN+seOzgR3HygoQqKjkL4AOsev5sxGE38uj+X9OJqqut0VBQobPv5MF/tygYgLsiL68bEUVmn55NtGRwvrOLKd7bx5nXDmdQn1CYxvbTqKN/uEecfGuPPny/sxZxBEefMq7p9YgIf/Z7Br/tzuWRYNNeOicPD1bpJd3SAJ1eMjOHLnVm8sPIoX98xtt3zuyRJchyurmJJkZqaGjw9PVWORl01NTVA0zXpCJlkSZIk2ZONSgUBMXIVOQxObRGt3GWS1WHV9Xoe+Gova44UnvFRLaSJBOfGcT34vzn98HITL6O3TUzgzs/2sD2thFuW7OLTW8cwrlewVWPadvI0728RSfria4czb0hki4910Wq4fVJPbp9kg5+zM9w3tTff78lhZ3oJm48X2yy5lCTJ9rRaLQEBARQWir97Xl5eDnPjxGg00tDQQF1dHRqN7fr2mUwmampqKCwsJCAgAK224zenZJIlSZJkTzZqetEoOkkkWTl7IOl625yji6uq13PNu9s5kFOOu4uGS5OicdUq7DqSgX9QMA9M78P4XmfPQQrwcuPjW0bzwJcprDiUz12f7+GneybQI9jbKjHV6w387bt9mExwzejY8yZY9hQV4Ml1Y+P46PcMXlp1lIm9QxzmTZkkSe0XESFKii2JlqMwmUzU1tbi6elpl78xAQEBjdeio2SSJUmSZE+2HMkCiBoutrL5RYcYjSYWfZ3CgZxygrzdeP/GkQyPC0Sn07FMSWPu3FEtlo+4u2h55ephXPXONvZll/PnT/fwy30XdLiD35m+2Z1Ndmkt4X7u/GueY41Q3j05kS92ZLIvu5xdGaWMTpBzsyTJWSmKQmRkJGFhYeh0OrXDaaTT6di0aROTJk3qVAlfW7i6unZqBMtCJlmSJEn2ZEmyAm01kmVOsgoOgb4eXNxtc54u6o31J1h1uAA3raYxwWoPD1ct7y0cyaxXNpGaX8ln209x84TOfa/r9QbeXH8CEAmNt7tjvXSH+rpz2fBovtyZxYdb0mWSJUldgFartUqiYS1arRa9Xo+Hh4fNkyxrkYsRS5Ik2YvJZJOFiM8S0AO8gsGog/yDtjlHF1XbYODdTSIJfvrSQe1OsCzC/Dx4aFZfAF5efYzTVfWdiuubXVnkldcR4efBVaOs25HSWiyJ5KrD+WSV1KgcjSRJkvpkkiVJkmQvtaVQXy72A+Ntcw5FaSoZzJUlg+2x6nA+VfV6YoM8uXx4TKeOdfWoOAZE+lFRp+eJXw53uB1wnc7A4vUnAbhnSi+rdwi0lj7hvkzsHYLRBB9vzejQMWTXaEmSuhKZZEmSJNmLZRTLNxLcvGx3nmg5L6sjvjO3Rr80KQZNJxcV1moUnlowEK1G4ed9ubxjHiE7U2WdrtXk6+tdWeRX1BHp78GVDjqKZXHT+HgAlqbkoDcY2/Sc4qp6nlueyshn1vHYHi2P/HiIvPJaG0YpSZJkH45V2C1JktSV2brphUVj84s9tj1PF5JfXsfvJ4oB+NPwaKscc0SPIB6bP4BHfzrEf1eksuJgPgkh3igKHM6tIDW/kvG9gll87XACvc9dM61OZ+DNDea5WFMScXdxzFEsi0l9QgnydqO4qoEtJ4qZ3DfsvI9PKxLrihVXNZg/ovBdcg7Hi6r58a7xnU50JUmS1CRHsiRJkuzFshCxrZpeWFhGsoqPQX2lbc/VRfywNxujCUbFB1qt7TrADWN7cPOEeEwmSMkq48e9OfyQnENqvvi+bD15mksW/87qwwUYjE2jWhV1Ov767T4KKuqJ8vfgypGdK1+0B1ethovMreV/Ssk972Pzymu54YOdFFc1kBjmw1vXDuPO/ga83bXsyyrjh7059ghZkiTJZuRIliRJkr00jmTZOMnyCQO/GKjIhtwUSJho2/M5udoGAx9uyQDgipHWLclTFIXH5g9k4bh4DuSUk1dWiwmI9PcgOsCTRd/sI7Okhts/2U1MoCc3jO2BVqPw4ZZ0csvr0GoU/jlvgMOPYllcMiyaT7adYuWhfGoa9I2LNZ/JaDRxz+fJ5JTVkhDizVd3jMXfXUNDuol7Jvfk+ZXH+e+KVGYNDMfXwzm6iEmSJP2RTLIkSZLsxV5JFohFiSuyRfMLmWSd1+c7TlFcVU9MoCcLhlmnVPCPEkK8SQg5d4Tsp3sm8Pamk3y9K4vs0lqeXZ7a+Lm4IC9euXpYh7scqmF4XABxQV5kltSw6lABC5LOvZ7fJWeTnFmGt5uWT24ZTYiPe+N6PDeO7cG3e3JJL67mkR8O8Po1SXJxY0mSnJIsF5QkSbIXW7dvP1NUktjmH7D9uZxYbYOBtzeK5PfeKYm4udj3ZTHQ241H5vRn+yPTeP5PQ0iKC2BYbADPXjaYlQ9OcqoEC8TI3WXmOW0fb8s45/PlNTr+a04kH5jem9igsxvAuLloeOHyIbhoFH7dn8f7m9NtHrMkSZItyCRLkiTJHuorobpQ7Nt6ThZA2ECxLThs+3M5sdfWHW8cxbqsk23bO8PDVcuVo2L58e4JLL1nAteMjsPTzTlKBP/oujE9cNNq2JtZxp5TpY0fN5lMPPHLIU5Xi3lYLS3SPDI+iH9fNACA51akknlarrslSZLzkUmWJEmSPZRmiK1nEHgG2P584eJNKsXHwKCz/fmc0J5TpbyzUaxB9a95A+w+itVVhfq6c8mwKAA+2NLUuv7bPdn8sDcHjQLPXDoYV23L13vhuB5ckBiCwWjiq12ZNo9ZkiTJ2uQriiRJkj3Yq327hX8suPmCUQenT9jnnE6krKaBh77dh9EElyVFM3tQhNohdSm3ThSjVCsO5rP2SAGrDxfw6E8HAVg0ow+jE4LO+3xFUbhuTBwgkjNdG9fdkiRJchQyyZIkSbKHxvlYdigVBFAUCOsv9gsO2eecTqKqXs+NH+0ivbiaSH8PHps/UO2Qupx+EX7MGRSB0QS3fryb2z/ZTZ3OyIV9Qrl7cmKbjjGtfzjB3m4UVdazPrXQxhFLkiRZl0yyJEmS7MHeI1nQVDJYKOdlWZhMon34vqwyArxc+fiW0fh7yTbhtvDq1UncND6+8f+3XpDAewtHtnmRYTcXDZePEPPkvtqVZYsQJUmSbEa2cJckSbIHS5Jlj6YXFmGWJOuI/c7p4H5KyWXjsSLcXTR8csto+oT7qh1Sl+XmouHxiwcye1AErlqFET3OXyLYnCtHxfLOpjQ2HSuisk4n182SJMlpyJEsSZIke7A0vrDnSJYlyZLlggCU1+p4+jcxqnf/tN4MiQlQN6BuYmzP4A4lWAC9Qn3oGeKN3mji9xPFVo5MkiTJdmSSJUmSZGv6eijPFvtqJFllp0QL+W5u8foTFFc10CvUm9sn2vH7IHXKhX1DAdhwtEjlSCRJktpOJlmSJEm2VnoKMIGbD3iH2O+83sHgEy72i47a77wOqF5v4JvdYl7PP+b2l+3anciUvmEArD9aiMlkUjkaSZKktpGvMpIkSbbW2PQiQXT9s6cw2fwCYO2RQspqdET4eTDZ/KZdcg6jE4LwdNVSUFHPkTw5IitJknOQSZYkSZKtqdH0wiK0r9h285Gsb82jWJcNj0bbxu52kmPwcNUyvlcwABuOyVbukiQ5B5lkSVJXoKuDbYth7ZNQLSeHO5xSyxpZKswDkkkWBRV1bDwm5vNYWoJLzmVyPzH6uPaITLIkSXIOMsmSJGeXuQPeHAMr/wGbX4JXh8HW18FoUDsyyeLMckF7CzEnWcXdN8n6bX8eRhOM6BFIz1AftcOROmB6f5FkJWeWUlhZp3I0kiRJrZNJliQ5s9oy+GahaA/uGwkRg6GhElb9C5ZcBOU5akcoAZSoOZLVT2zLsqCh2v7ndwCbj4tRrJkDwlWOROqoSH9Phsb4YzLJ0SxJkpyDTLIkyZmtfQKq8iE4Ee7dBXdsgvmvii52mVvhu5tBduNSl0EvWqiDOkmWdzB4BQMmKD5u//OrrEFvZEd6CQAX9LZjZ0fJ6mYOjABg1aF8lSOxjYo6HblltWqHIUmSlcgkS5KcVeYO2P2h2L/oFXD3BY0GRtwEd2wEVy/I2gEHv1czSqkiG4x60LqDb5Q6MVhGs4qPqXN+Fe3NLKWmwUCwtxv9I/zUDkfqhFkDxUjk7ydOU1mnUzka68kvr+OfPx5g9H/WMP65dcx5dTNL98oqBElydjLJkiRnpG+AXx4Q+0nXQ8LEsz8fkggX/EXsr34MdPLuqGoaOwvGiyRYDSF9xLYoVZ3zq2jLCdEIZkJiCBrZVdCp9Qr1oWeINw0GI+u7yMLEO9NLmPfaZj7fkUmdzoiiwJG8Ch78OoVf9+eqHZ4kSZ0gkyxJckZbX4WiI+AVAjOeav4x4+4FvxgxkrLjbfvGJzVRs+mFhWUkqxt2GNx8XCRZslTQ+SmKwtzBkQB8vydb5Wg6b/mBPK59bzunqxvoH+nHV3eMZe+/Z3D92DgA/vrNPvacKlU5SkmSOkomWZLkbEpPwcYXxP7s58ArqPnHuXnB1H+K/a2vQ32VfeKTzqZm0wuLUPNIVjcrFyyv0bE/uwyAiTLJ6hKuGCla8G86XkR2aY3K0XTc+qOF3P/VXvRGE/MGR/LDXeMZ2zOYAC83nrh4ENP6hVGvN3LDBztYe6RA7XAlSeoAmWRJkrPZ/BIY6iFhEgy+/PyPHXylWAC35jTset8+8Ulnc4gkyzySdfqkKDXtJtYdLcBogt5hPkT6e6odjmQFPYK9Gd8rGJMJvt3tfKNZBqOJ9zen8edP96AzmLhoSCSvXZOEp5u28TFajcJr1yQxsXcINQ0Gbv9kN59uy1AvaEmSOkQmWZLkTMqyIOULsT/ln6C0MsdE6wIXPiz2t77WbVt4q8qyEHGgiuWCvpHg7g8mA5zuPh0Glx0QXejmmEvMpK7hqlGxAHy7O4uSaue5aWAymbjjk908/dsRGvRGZg0M5+WrhqFtZq6gt7sLH940iqtGxmI0wb9/OsTTvx7GJLvFSpLTkEmWJDmT318Bo06MYsWNbdtzBl8JAXFiNOvocpuGJ/2ByXTGSJaKSZaiQPgAsV9wSL047KiqXs/GY6I5wtzBESpHI1nTrIERBHi5kltex7hn1/Kf3w5Tr3f8xdeXH8xnbWoh7i4anr1sMG9fPwJXbctvw1y1Gp7702D+NkssKP7+lnQ+2JJur3AlSeokp0qyNm3axPz584mKikJRFJYuXdrqczZs2MDw4cNxd3cnMTGRJUuW2DxOSbKJ2jJI/lTsT3q47c/TusDgK8T+oR+tHpZ0HpX5oK8FRSsSXTWFDxTbgoPqxmEn61MLadAb6RniTd9wX7XDkazIw1XLewtHMijaj3q9kfc2p3Pl29s4ddpxR+p1BiPPrxDdPe+8sBfXjI5Daa0SAdHs454piTw+X9wkeW55KilZZbYMVZIkK3GqJKu6upqhQ4eyePHiNj0+PT2defPmMWXKFFJSUnjwwQe57bbbWLlypY0jlSQbSP1NzMUK7QfxF7TvuQMWiO2JNbIBhj1ZOgsGxILWVd1YwgeJbTcZyVp+MA+AOYMj2vRmVnIuo+KD+OXeC3hv4UgCvFzZl13O9P9t5F9LD1Beq84aWodzK3hhZSq3f7Kbfy09QH55HQBGo4nX150g43QNIT5u3D6p/fMzbxwfz7zBkeiNJu75PJnCyjprhy9JkpW5qB1Ae8yZM4c5c+a0+fFvv/02CQkJvPTSSwD079+fLVu28PLLLzNr1ixbhSlJtmFZVHjQ5a3PxfqjiMGi8UJJGhxb0XrDDMk6GtfIUrFU0MKSZOV3/ZGsOp2B9amiVHDOIDkfq6tSFIUZA8L59b4LeOSHA2w+Xsxn2zM5lFvBZ7eOwdvdPm9xsktrWPJ7Bh/+no7xjClTPyTnMCExhPzyOg7klAPwwPQ++HQgLkVRePZPgzmcV0F6cTW3LNnF13eMs9vXKElS+3Xp385t27Yxffr0sz42a9YsHnzwwRafU19fT319feP/KyoqANDpdOh06twds5xXrfN3Bw5/jauLcUnbgALo+s2HDsSp6XcJ2q0vYzz4A4Z+l1g/xvNw+OtrI5rik2gBQ0A8Rht+7W26vkGJuAJU5aMrywPvrtvSfOPRImp1BiL9PegT6mmVn7vu+jNsL525vuE+rny4cDjb0k5z/1f72ZtZxi1LdvL4Rf1JDPMB4HR1A7lltfQN98XNpXNFPJV1en7al8uujFIO5VZyqqSplfy0fqGMSQhixaECkjPLWH1YtF/3dtPywLRErhoe2eGfIU8tvHdDEle+u4ODORX89ZsUXr96aJueK39+bUteX9tzpGvc1hgUk5O2qlEUhR9//JEFCxa0+Jg+ffpw880388gjjzR+bNmyZcybN4+amho8Pc9t6fv444/zxBNPnPPxL774Ai8vL6vELkntFV+8jqFZSyjzjGdjvyc7dAz/mgwmH30UveLGsqHvYFK0rT9J6pSR6W8QXbaTg9HXcDKs7aPwtjLt0EP4NBTye+LfKfYdoHY4NvPVSQ3bCjVMDDdyeU+j2uFIdnSqEhYf1lJvFKP9AW4m9Cao0on/h3iYuKSHkSFB7X/rU2+A1TkaNuUr1Buaqgk0mOjhCzOijQwMFMc1mSC1XOF0HRhNMCTIRIC7Fb5AIKMSXj2oxYjCn/sZGBDolG/jJMlp1dTUcO2111JeXo6fn1+Lj+vSI1kd8cgjj7Bo0aLG/1dUVBAbG8vMmTPPeyFtSafTsXr1ambMmIGrq8rzOrooR7/G2k/eBMB3/E3MHTu3YwcxGTG9+DwuDVXMGZUIYf2tGOH5Ofr1tRXtB6JUud+4OfTt28HvWxu09fpqa76Bo78yNsEH42jbxaMmo9HE0y9sBBq4efZIJiZaZ8Suu/4M24s1r++k3AreWH+SdUeLKGtoSoa83LQU1xn44KiWxy/qx3Vj2t6MZs+pUhZ9e4Bc8zyrXqHeLBgaycAoP4bF+uPrcW7M8zr1VZxfhf9RPvj9FMsLfbjvyvG4u57/ppn8+bUteX1tz5GusaXKrTVdOsmKiIigoODsldILCgrw8/NrdhQLwN3dHXf3c283ubq6qv5NdYQYujqHvMZFxyBrOygatEOvQtuZ+CKHwqnfcS06BNFDrBdjGznk9bUVkwlKMwBwCesDdvi6W72+kYPh6K9oi4507ufIgaVklVFU1YCPuwsTeofh6mLdEdtu9TOsAmtc32E9gnn/pmAKK+vIK6vDRasQG+SFVlF4cdVRPvo9g6eXHWVAdCCjE4JaPV5qfgW3f7qXyno90QGe/PuiAcwaGK5qQ5W/zOzHL/vzySyp5ZOd2dw9ObFNz5M/v7Ylr6/tOcI1buv5naq7YHuNGzeOtWvXnvWx1atXM27cOJUikqQOSP5YbHvPAr+ozh0r0ly/n7evc8eRWldTAvVisjuB8aqG0sjSxj3/gLpx2NAa8xyYC/uE4m7lBEtyLmG+HgyNDWBglD9+Hq54u7vw6EUDmD80Cr3RxN2f7yGvvPa8xyioqOOmD3dRWa9ndHwQqxdNYvYg9TtW+ri78H+z+wHw3qY0quv1qsZjDccKKtl6opjkzFKMRlkCKTk/p0qyqqqqSElJISUlBRAt2lNSUsjMzAREqd/ChQsbH3/nnXeSlpbGww8/TGpqKm+++SbffPMNf/nLX9QIX5LaT18PKV+I/RE3df54Msmyn1LzoqG+UeDa/Mi53YWZ52EVHwOj4y/e2hFrjogka/qAMJUjkRyRoij890+D6RfhS3FVA3d+lnzehYyf+OUQ+RV19A7z4b2FI/Fyc5wCoEuGRZEQ4k1pjY5Ptp1SO5wO0xuMPPbTQWa+vIlr39/BZW9u5a2NJ9UOS5I6zamSrN27d5OUlERSUhIAixYtIikpiUcffRSAvLy8xoQLICEhgd9++43Vq1czdOhQXnrpJd5//33Zvl1yHqm/Qm2JeKOeOL31x7fGkmTl7wejbAhgU6fNbxKC2r8mjs0ExoOLB+jrGksZu5KskhpS8yvRahSm9JVJltQ8LzcX3r1hJP6eruzLKuPuz5LJPF1DZZ3urDW2Nh0rYtmBfLQahdeuScLfy7HKwFy0Gu6dIsoE39vsnKNZdToDNy/ZxcfmJDE+WDQYe39zGjUNzvf1SNKZHOeWTBtMnjyZ8zVDXLJkSbPP2bt3rw2jkiQb2rNEbIffAFor/LoG9wYXT2iogpKTENK788eUmnf6uNiGtG2uhF1otBDSRyTZhUcguJfaEVnVWvMo1sgegQR4uakcjeTI4oK9eP2aJG5esou1qYWsTS0EwEWj8Pc5/ViQFM1jP4uFuxeO60H/SHUaX7XmkmFRvL7uOBmna/j30oO8dOVQ1UsZ20pvMHL/l3vZfLwYLzct/7tyGDMGhDP1pQ2cOl3D17uyuHmCA6wxKEkd5FQjWZLUrZw+CembAAWSrrfOMbUuEGFelFaWDNrW6RNiG+xASRY0lQwWHVE3DhtYc0S8UZ4xIFzlSCRnMKlPKEvvnsCkPqGNH9MbTTz92xFmvryJ9OJqwnzd+cuMPipGeX4uWg3P/WkIWo3CD3tz+Gy785QNPv3bEVYdLsDNRcOHN41i9qAItBqFOyaJ0f/3NqWhM8iKC8l5ySRLkhxV8idimzgdAtrearhVkcPENi/FeseUzlVsSbIcbLQwTEyWpzBV3TisrKJOx/a00wBM6y+TLKltBsf488kto9n5j2kcfGJWY/ldSXUDCSHefHH7GPyaac/uSMb2DObv5iYYT/56mD2nSlWOqHWHcsv5eFsGAK9dPYyxPYMbP/en4TGE+LiTW17HsgN5KkUoSZ0nkyxJckT6Bkj5XOyPuNG6x5bNL2zPaBTlmOB4I1mh5vXRCrvWSNbGo0XojSYSw3xICPFWO5yOMejF6PWxVaI7pWQ3YX4e+Li78NeZfXji4oHcND6epfdMIDHMV+3Q2uS2iQnMHRyBziC6JhZV1qsd0nk9tzwVkwnmD41i9qDIsz7n4apl4bgeACzZmqFCdJJkHU41J0uSuo1jy6G6CHzCoc9s6x77zCTLZAInqd93KpW5oKsBjQsE9lA7mrNZRrJOHxdv6q0x188BNHYVdIZRLIMOastA0cCpLZC+GcqzIWe3+L236DEBxt8n/gbI31O7UBSFG8fHqx1GuymKwvOXD+VofiUni6r586e7+eTWMfi4O97v9+bjRWw+XoyrVuFvM/s2+5irR8fy+rrj7M0sY392GUNiAuwbpCRZgRzJkiRHZGl4Mew60Fq5VCW0H2jdoK4cypynft+pWOZjBcZb//vXWf5x4OoNhgYoSVM7GqvQGYysT7XMx3LwroK5KfDKYHgxEV7oCd8shF3vNd1Y8QxqKjE99Tt8eTVs/K+qIUvOwcfdhXduGIGvhwvJmWUs/GAHlXW61p9oZx9vFa87143pQZy5m+Afhfl6MG9w5FmPlyRnI5MsSXI0pRlwcr3YH77wvA/tEBe3puYHuSnWP74ExebOgo42HwtAo4FQ893jLtL8YldGCRV1eoK93RgWG6h2OC3L3AEfz4fKM+aZBPWCsXfDRS/Dwp/hoWNw3274y2EYc6d4zOb/Qal8oym1LjHMl89vG4OfOdH6548H1Q7pLPV6A1tPFgNw+YiY8z7WMqL4y75cCivrbB2aJFmdTLIkydEkfwqYoOcUCLJR+1o5L8u2LGtkOVL79jOFda15WWsOi1Gsqf3C0GoctKzOaIQfboP6ClEG+PdM+Fch3J8Ms5+FkbdAzwubRj79o2H2c5AwCQz1sOYxdeOXnMaQmACW3DIaRYGf9+WyM91x5vftziilpsFAiI87A1ppi58UF8jwuAAaDEaW/J5hnwAlyYpkkiVJjsRosF3DizPJJMu2LGtkOVrTC4tQ87ysIufvMGgymVh9JB+A6Y7cuj1nD5RlgpsPXPsNePiDi/v5n6MoMOsZQIFDP4pjSFIbDI8L5OpRoivtYz8fwmBseY1Re9pwVNwQubBPKJo23BC580Kxlt+n2085ZOmjJJ2PTLIkyZHkpYhSInd/6DvPdudpbONubn4hWZcjlwtCU/JnGXFzYscKqsgqqcXNRcPE3iFqh9Oyw0vFts9scPdp+/MiBsPgK8T+3s+sHpbUdT00sw9+Hi4cyavg8V+PYMmzSqsb+HzHKf67IpV/Lz3I4vUn2HPKPqNdG4+Jxi6T+4a28khhev9wEsN8qKzT88WOTFuGJklW53htZySpO0vfLLbxE8TcKVsJHwiKFmqKoSJXlCZJ1qGvFyMW4LgjWcHi7jAlaU7fYfI38zo6k3qH4OXmoC9pJhMc/lnsD7ik/c8fdg0c+EaMZs3+r23/NkhdRrCPO09fOpgHvtrLV7uy2e2nYUVFChuPF1OnO3eR37evH8HsQRE2iye3rJZjBVVoFNp8Q0RjXpz44e/2886mNK4eFYe/l4M1E5KkFsiRLElyJBlbxDZ+om3P4+rRNC9HlgxaV0kaYAJ3P/Bx0E53gfGifXhDFVQVqh1Nh5lMpsbFSucNiWzl0SrKTYbyTNHVsfeM9j8/4UKxnENtKZxcZ/34pC7r4qFRvHLVMLQahRMVGlYeLqROZ2RApB83jY/n3imJXJAoEp5//HjApg0m1pqXWUiKCyTAq+03Ci5NiqZ3mA8l1Q28vOaYrcKTJKuTSZYkOQqDDjK3if34C2x/PjkvyzYs7duDeznuCJGLO/ibO3uVOG/J4LGCKk4UVuGm1TDNkdfHOrRUbPvMBFfP9j9fo4VBfxL7B76xWlhS93DJsGi+uX00F8cZeGR2H76+Yyy/3X8Bj188kIdm9eXDm0bRP9KPkuoGHvgyhfIa28x9WpqSC8Ccdo6WuWo1PH7xQEDMzUrNr7B6bJJkCzLJkiRHkbdPjCx4BED4INufTyZZtuHo87EsGudlnVA3jk5oLBXsE4qfh4OWEJlMcPgnsT9gQcePM/hysU1dBvWVnQ5L6l6GxPgzLdrELRPiGdMzGOWMG0BuLhpevXoY7i4atqWdZu5rmzmQXW7V82eV1LDnVCmKAvOHRrX7+RMSQ5gzKAKD0cSLK49aNTZJshWZZEmSo0jfJLbxF4i1jGytMclKsf25upPG9u0OnmQFmedlOWnzC5PJxG/7xZ3xeUNsN4+k0/JSxKLfLp4dKxW0iBouvmf6Wkj9zWrhSRJAn3BfvvnzOOKCvMgpq+XOz/ZQ22Cw2vF/SskBYHyvYML9PDp0jIdm9UVRYM2RQo7kydEsyfHJJEuSHIW95mNZhA8CFNHNsLLAPufsDhrbt/dSN47WNDa/cM4k61BuBSeLqnFzcfBSQcsoVp+Z4Obd8eMoCgy5Uuwf+LbzcUnSHwyNDeDX+y8gOsCTnLJa3tpgnVFuk8nUWCp4ybCON1nqFerD3MFi7uXi9c47Ai91HzLJkiRHYDJB9m6x32Ocfc7p7tM02pK/3z7n7A4a52Q5y0hWmrpxdNAPyeLO+IwB4Y5dKmiZj9WRroJ/ZGnlfnI9VBV1/niS9Ad+Hq78+yLRFOntjWlkFFd3+pjb00rE3EkXTae7F94zWZQ5/3Ygj7Siqk7HJkm2JJMsSXIEJWlQXw5adwgbYL/zypJB66opgZrTYt9pRrLSwHhuO2dHpjcY+XmfSLL+NNyBlx/IPwCl6eDiAb1ndf54wb1E2aDJAId+6PzxJKkZswZGMLF3CA0GI29t6NxIt8lk4sVVYg7VlSNjOn1DZECUH9P6hWEywdsbnXMUXuo+ZJIlSY7AkuSEDwStHe/Kn7kosdR5lvlNftGdKw2zh4A40LiIOT6VuWpH0y6bjxdTXNVAiI8bE3u3bVFTVaStF9teU9u3APH5NJYMfmed40nSHyiKwv3TxEj8T/tyKK/teLfB9UcL2XOqFA9XDfdPtc7o/t1TxGjWD8k55JTVWuWYkmQLMsmSJEeQmyK2UcPse17ZYdC6nGU+FohkPqCH2Hey5hc/7BWjWPOHRuGqdeCXsdy9YhszynrH7HeR2ObsgYYa6x1Xks4wskcgfcN9qdMZ+SE5u0PHqG0w8NzyVABuHB9PWAcbXvzRiB6BjOsZjN5o4l05miU5MAd+dZKkbsQykmUZWbKXiMFiW5YpSt2kznGW+VgWTtj8QmcwsiFVLKB8cQdaQduVJcmKSrLeMf1jwCdClAzKMl/JRhRF4fqxcQB8tv0UJpOpXc83mUz888cDHCuoItjbjTsnWffG071TxWjWV7uyOF1Vb9VjS5K1yCRLktRmMjWNJNl7JMszAAITxH5usn3P3RVZ1shy9PbtFk7Yxj35VCmV9XqCvN0YGhOgdjgtqymB0gyxb83fa0WBmJFi39IsR5JsYEFSNN5uWk4WVfPZjszzPtZoNLH6cAFL9+aw6VgRD327nx/25qBR4PVrkwj0drNqbON7BTM42p96vZGvd2dZ9diSZC0uagcgSd1eaTrUlYPWDUL72//8PcaLGNI3QeJ0+5+/K2kcyUpUN462Cna+JGvDMdFVb1LvEDQapZVHq8hy4yQwATwDrXvsmJGQ+ivkyCRLsh1fD1fumZrI8yuO8thPB6mp16PVKGg1Cv6erozvFUKEvwc5ZbU8/N0+fj9x+pxj/GNuf8b3CrF6bIqicOP4eB76dh+fb8/kjok9cXHk0mGpW5JJliSpzTIfK3wguFj3bl+bJFwIKZ9D2gb7n7srMRqbkhVnS7KcqFxww1GRZE3uG6ZyJK1oLBUcZv1jR8uRLMk+7rqwF+lF1Xy7J5tnzfOrLBQFovw9G5tPeLpqGRTtR35FHSPiArlyVKxNEiyLi4ZE8p/fDpNTVsva1EJmDXTgRcmlbkkmWZKkNrXmY1n0vNAcx35R4uQVpE4czq48Cwz1YkQyIE7taNrGUi5YmgFGA2i0qobTmoKKOo7kVaAoMLG37d68WYUt5mNZRCWBooGKHKjIA79I659DkhAjRs9cNhhXFw1pRVWE+npgMpnILq0lJausMcEaFR/Ic38aQq9QK3XRbAMPVy1Xj47jrQ0nWfJ7hkyyJIcjkyxJUluOeS5U9HB1zu8bAaH9oCgVMjZbZ9HU7shSKhjU0+GTlUb+MSIpNDSIJDEwXu2IzmujeRRrSLQ/wT7uKkfTCsvNE1skWe4+Yj29goOiZNBvvvXPIUlmrloNz1w6+JyP55TVkl5UzcAoP6vPuWqr68f24L1NaWxLO83ezFKS4qxcmitJnSALWCVJTUZD0x1vSwmQGhLMo1lpG9WLwdk523wsEMmgpfGJE8zL2pYm5nxM6uPAa2OBGBEuMzcKsCyTYG3RI8Q2e5dtji9JrYgO8OSC3iGqJViWGC5NEguSv7HuhGpxSFJzZJIlSWoqSoWGKnDzgdC+6sVhKRmU87I6zhmTLGiK1wmSrN2nxDIDI+MdvKS14JDYBsaDh79tzmFJsuQad1I3d/eURDQKrE0t5GBOudrhSFIjmWRJkposE9ejktQtMYu/ABStaIBQekq9OJyZs7VvtwjuKbYO3vyisKKOrJJaFAWS4gLUDuf8iswNAkL72e4cEYPENv+gWAZCkrqphBBv5pvXzHtlzXGVo5GkJjLJkiQ1WVowx6hYKgjibnvsaLF/Yo26sTgrZ+ssaOEka2XtOVUKQN9wX/w8XFWOphVFR8XWlqPTYQNE84uaYqgqsN15JMkJ3De1NxoF1hwpYHdGidrhSBIgkyxJUlf2HrFVcz6WReI0sT2xVt04nJGuVjSOAAh2tpEs52jjvtucZI2Md4KJ7fYYyXL1bEro8w/a7jyS5AQSw3y4alQsAM8tT8UkR3clByCTLElSS30lFB4W+2qPZAEkzhDb9I2gb1A3FmdTkgaYwCPA+VrgN7ZxPwUGnbqxnIclyRrRwxmSLDuMZAGEm0sGCw7Y9jyS5AQemNYHD1cNu0+VNi5a7gwKK+tYvP4ED3+3j4KKOrXDkaxIJlmSpJbcvYAJ/GJEG3W1RQwB71DRiCNru9rROJcz52MpirqxtJdvJLh6gcngsPPxahsMHDJPaB/Zw8GT2JoSqC4U+yF9bHuuM+dlSVI3F+HvwbWjewDwza4slaNpm9WHC5jw3DpeWHmUb3Znc9mbW0krqlI7LMlKZJIlSWo5tU1sY0epG4eFRgOJ08W+nJfVPqfNSZazzccC8X0PEG9MKHPMJGt/dhl6o4kwX3diAj3VDuf8io+JrX8suPva9lyNI1kyyZIkgMtHxACw9kgh5TWOOzIPUK838PjPh9AZTAyN8Sc+2IucslqueHsb2aU1aocnWYFMsiRJLenmNakSJqkbx5ksSdbRFerG4WxOp4mtZX6TswmIE1vL2k4OJjmzDIDhcYEojj5SaJmPZetRLGhKsoqPg06WGUnSgCg/+kX40mAw8tuBPLXDOa/Pt2eSU1ZLhJ8HX/95HN/dNZ7+kX6crm7gz5/uobbBoHaIUifJJEuS1NBQDVk7xb5lIWBHkDgdNK5QfBQKU9WOxnmUpottUE914+goB0+y9maK+VjDewSoG0hbNM7HsmHTCwu/KPAMFKWeRfL3VZKAxsWJf9ybrXIkLauu17N4vVhb8f5pvfFw1RLi4877N44k2NuNQ7kVPPHLIZWjlDpLJlmSpIbMbWDUiZIiR3pj7hkAvaaK/cNL1YzEuZSYk6zABHXj6CgHTrJMJhN7s8oASIqTTS/OoihNo1n5svmFJAFcMiwaRYFdGaVklThm2d13e7I5Xd1Aj2AvrhgZ0/jx6ABPXr8mCYDvk7Mpq5FNqJyZTLIkSQ1pllLBCx2vUcLABWJ7+CdVw3AaDdVQlS/2g2SSZW05ZbUUVdbjolEYHO2vdjits+dIFkDkULHN22ef80mSg4vw92BMgmiQs/qw460hZzKZ+Gy7mP96y4QEXLVnvxUfnxhC/0g/dAYTyw/mqxGiZCUyyZIkNVjmY/V0oFJBi75zRclg4WEoOqZ2NI6vNENsPQJE6ZYzcuAkyzIfa0CUHx6uWnWDaU1DDVSYS5Ts1QQlcpjY5qXY53yS5ARmDBAde1cddrwkZUd6CccLq/B01XLp8OhmH3PJsCgAfkrJsWdokpXJJEuS7K36NOTtF/uO1PTCwjMAek0R+ymfqRqKU7CUCjrrKBY0dResyne4BgqW+VhJsQHqBtIWjQm3v/3WS4saJrb5B8Ggt885JcnBzRwQDoiSwdJqxyq5s4xiLUiKxs/DtdnHzB8qkqwd6SXklzvW32Sp7WSSJUn2dugHwCTWpXKE9bGaM/xGsd3+VtMaUFLzSp18PhaIhMDVW+yXO9Zk8b3mkSynmI9VYu4yGdTLfmXAQb3AzQf0tU3t4yWpm4sN8qJfhC8Go4l1qYVqh9Mor7yWlYfE6Nr1Y+NafFx0gCej44MwmeCXfbn2Ck+yMqdLshYvXkx8fDweHh6MGTOGnTt3tvjYJUuWoCjKWf88PDzsGK0kNSPlC7Edeo26cZxPv3mQOAMMDfDrX8BkUjsix9UVRrIU5YySQcdZK6teb+BwbgUg2rc7vJKTYmvPZjYajbhhA7JkUJLOYBnNcqSSwXc2pqEzmBiTEMTAqPPPMb1oaCTgWPFL7eNUSdbXX3/NokWLeOyxx0hOTmbo0KHMmjWLwsKW71L4+fmRl5fX+O/UKcd5AyF1Q0VHITcZNC4w+Aq1o2mZosC8F8HFEzI2w9FlakfkuLrCSBY45LysQ7kVNBiMBHu7ERvk4IsQwxkjWXbuGGopGcxNse95JcmBWeZlbT5ejM5gVDkaKKqs58ud4u/rfVN7t/r4af1FkrjnlOOVPEpt41RJ1v/+9z9uv/12br75ZgYMGMDbb7+Nl5cXH374YYvPURSFiIiIxn/h4eF2jFiS/mDfl2KbOAN8QtWNpTWB8TDmDrG/6wNVQ3FoJU6+RpaFAyZZyafM87HiAhx/EWJQL8lqbH4hOwxKksXAKD8CvVypaTCwP7tc7XD4YEs69Xojw2IDmJAY3OrjowM86Rfhi9EEG48V2SFCydpc1A6grRoaGtizZw+PPPJI48c0Gg3Tp09n27ZtLT6vqqqKHj16YDQaGT58OM888wwDBw5s8fH19fXU19c3/r+iQpSq6HQ6dDqdFb6S9rOcV63zdwd2ucZGPS77vkIB9IOuwOQM38+hN+D6+6twci26wuMi8eqALvszbNDhUpaJAuh8Y8GJ/0Zo/KLRAsbSDAwO8n1KPlUCwJBoP9V/dtpyjV1OnxS/3/497Pv7HTYIV8CUvx99fR1oHLwLYzO67N8IB9Fdr++o+EBWHS5k6/FChkT52Ow8rV3fvPI6lmwVN+TunBSPXt+2JjWT+4SQml/JmsP5zBsUZp1gnZQj/Qy3NQanSbKKi4sxGAznjESFh4eTmtr8Svd9+/blww8/ZMiQIZSXl/Piiy8yfvx4Dh06RExMTLPPefbZZ3niiSfO+fiqVavw8vLq/BfSCatXr1b1/N2BLa9xRHkyYyrzqHfxZdVJE8Z05yjBG+s7mPDKA2R89xiHo6/q1LG62s+wV30BM0wGDIoryzbvAUXd4oDOXN/I0mJGA2UZ+9m8zDF+Nrcd0wIK9blHWbas+b/z9tbSNdYYG5hfIdotr95zkob9drzzbDIyT+OOi66GzT9+SKVn822hnUFX+xvhaLrb9fWtUQAtv+06Rly17f+GtHR9PzmuoU6noZevibqTu1mW1rbjeVQCuLD2cB6//JaN1gkG9G3NEX6Ga2ratsi10yRZHTFu3DjGjRvX+P/x48fTv39/3nnnHZ566qlmn/PII4+waNGixv9XVFQQGxvLzJkz8fPzs3nMzdHpdKxevZoZM2bg6tp8u0+pc+xxjbVffwqAy8iFzJ52iU3OYQvKUeC7hSRWbSd+5jvg0v7mMV31Z1hJWw+HQRPck7nzLlItDmtcXyU3Ej56g0Clkrlz51o5wvYrqKijdNsmNArcdtkMfNzVfblq9RoXpcI+MLn7Mv3iq+y+yLimeBhk72BSH39Mg9X//rVXV/0b4Si66/XtmV/J94u3kVnryoxZU85Z+Ndaznd992aWsWfbThQFXrp+HAOj2v5e0mA08XHaBkprdIQPHMvoeDstDeGAHOln2FLl1hqnSbJCQkLQarUUFJy9endBQQEREW1rg+3q6kpSUhInTpxo8THu7u64u7s3+1y1v6mOEENXZ7NrXJYFJ9cCoB15C1pn+j72nwd+MSgV2bge+RGGL+zwobrcz3ClGLlQAuMd4uvq1PUN6QWAUlWAKwZwVbcT68G80wD0Cfcl0Mdxml60eI0rxFw2Jagnrm5udo4KiE6C7B24FB4E1+vsf34r6XJ/IxxMd7u+A6MDCfBypaxGR2phjc27lDZ3fT/cKv42XD48hmE9Wp+LddbxgMl9w/hxbw6bjpcwobfsK+AIP8NtPb/TNL5wc3NjxIgRrF27tvFjRqORtWvXnjVadT4Gg4EDBw4QGRlpqzAlqXnJn4DJCPETISRR7WjaR+sCY+8U+1vfAKP6XZochmVNqYBYdeOwBgdbK6txEWJnaN0OZ6+RpQZL8wvZYVCSGmk0CmMSxOjP9rTTdj9/Vb2e9UdFB+ybJsR36BhT+4m5WI603pfUNk6TZAEsWrSI9957j48//pgjR45w1113UV1dzc033wzAwoULz2qM8eSTT7Jq1SrS0tJITk7m+uuv59SpU9x2221qfQlSd2TQw15RKsjIm9WNpaOG3wjuflB8FE6oXw/tMCzJiH/zczydiqJAYA+x7wBrZTUtQhygahxtdlqFNbLOZGnjnr9f3giRpDOM7SlGj7aesH+StfZIAfV6Iwkh3gyI7NiUk0l9QtFqFI4XVpF5um1zgSTH4DTlggBXXXUVRUVFPProo+Tn5zNs2DBWrFjR2AwjMzMTjaYpbywtLeX2228nPz+fwMBARowYwdatWxkwYIBaX4LUHR1fCZV54BUM/dSbt9MpHn4w4kbY+jpsWwx9ZqkdkWOwJFl+XSDJAtHGvfCw6m3cdQYj+3PKABjuLElWqcqLUgf3FuvaNVTB6RMQ2kedOCT7y02Bo8uh5rQYVR95K7jbrpOes7kgMQSAnRkl1OkMeLjar/vmL/vyALhoSGSHl6Hw93RlVHwg29NKWJdawE0TnHxNxm7EqZIsgHvvvZd777232c9t2LDhrP+//PLLvPzyy3aISpLOY/dHYjvsOnA5d76f0xh1u0iyMjZDTYkoL+vuKrrQSBY4zFpZR/MrqdMZ8fNwoWeIk7xZLDWP/nVwmYNO07pAxGDI3gl5KTLJ6g7qKmD1o7BnCWBq+vi2xTD7ORh0mVqROZTEMB8i/T3IK69jZ3oJk/rYZ43Kijodm8zrW100JKpTx5raL4ztaSWsTS2USZYTcapyQUlyOmWZcGKN2B9xk6qhdFpgDwgfLOaWHV+ldjTqMxqhXDS+kEmWdVnmYw2LC0SjcYKexUYDlGeJfbWSLGgqGZSLEjs/kwmydkFtWfOfN+jh6+thz0eASVRJXPAXCEyAqgL47mbY8F9xnG5OURQm9hajWZvsuKjvqkMFNBiM9A7zoW+Eb6eONbWfqNjakVZCVX3b1tiS1CeTLEmypQPfASbR8CJYpQnx1mQpEzy6XN04HEF1IRh1Ym0s3y7STMdBkqxky3ys2ABV42izihww6kHjqu7Pgmx+0TUUHIKP5sAH0+HVIbDpBag6o+mByQQr/wHpG0Wzmht/gas/h+mPwz07Yfz94nEbnoGf7gF9gypfhiOxjF5tPl5st3P+uFdUOlwyrHOjWAC9Qr3pGepNg8HIL/tyO308yT5kkiVJtnRyndj2v1jdOKyl7xyxPblOvnBbRrF8I0WpVlfgIElWU2fBAFXjaDNLqWBALGjsN9/jHGeOZBkN6sUhdVxZFrw/AzK3if/XlcO6p+GlvvDhbFj+d3j3Qtj5jvj8Ze9AwqSm57u4wcyn4KKXQdFCyufw+Z+g4KD9vxYHMqFXCIoCRwsqyS+vs/n58spr2XpSNNq4ZFjnFwdXFIVrR4u/z59tP4VJjlA6BZlkSZKtNNRA1g6x32uKurFYS9Rw8A6D+grI3Kp2NOqylId1lVJBgABzd8GqfNDZ/o1Ic0qqG8gwd9BKinWS9u2lGWKrZqkgQGg/MbLRUAnFx9SNReqYbW+Arhoih8ID++Gy98TfXZNRJF473hJJtIsnzHke+s9v/jgjb4FrvwY3H0jfhOv7kxl//Fkxj6sbCvR2Y0hMAACbjtu+ZPDnlFxMJhgdH0RskJdVjvmn4TG4uWg4lFvB/uxyqxxTsq0OJVnV1dX8+9//Zvz48SQmJtKzZ8+z/kmSBJzaCoYG8I+FYCdbG6slGg30mSn2j61UNxa1NXYW7PxdSofhGSjelIFqa2WlZIlRrF6h3vh7OcmiqZaW95YkVS0aLUQPF/vZu9SNRWq/6mLY87HYn/6EmAc75Eq4Yz3cnwIXvwFj7oRpj8JfDsGYP5//eL1nwK2rYeClmDSuhFYdQfvTn7vtKOdkc8ngmsMFNj/Xj3tFpcOlw633+hDo7cZFg0U58mfb1V9mQ2pdh2pcbrvtNjZu3MgNN9xAZGTH21JKUpeWtl5se04WaxB1FT2nwN7PIHO72pGoq6KLNb0A8XPa2Mb9lCoLZyefKgOcaBFiOKOzoMpJFkDMSNEBNHs3DF+odjRSe+x4G/S1EJUkXjfOFJTQseUBwgfAFUswnNqJsmQu2hOrYf0zMO3fVgnZmcwcGM6ra4+z6XgRtQ0GPN1sU9p7orCK1PxK3LQa5g6y7hzN68bG8cPeHJam5HD3lEQSQrytenzJujqUZC1fvpzffvuNCRMmWDseSeo6LPOxukqpoEXMKLHN3w+6WnD1VDcetXTFckFQfa2sHeliHsOIHk6UZFlGstQuFwSIHim22bvVjUNqn7oK2Pmu2L9gkdVvzJmiktgXdysjTr0NW16GpOvUWzhbJQMi/YgJ9CS7tJaNx4qYPSjCJuexdDAc0zPI6qPxw+MCubBPKBuPFfH0r4f54KZRVj2+ZF0dKhcMDAwkKEiukSNJLaosEG9UUSBhssrBWFlAnJiXZdRD3n61o1FPeRdbI8tCxeYX1fV69po7C07oFWL383eYZU6W2uWCIEayQPz9qa9UNxap7fZ8JJpchPSx2aL12UHjMfacBiYDbHzeJuewi4ZqyElud9mjoijMGigSq5WH8m0RGdA058vSNt6aFEXh3xcNwEWjsDa1kPVHC1t/kqSaDiVZTz31FI8++ig1NTXWjkeSuoZTW8Q2YhB4B6sbi7UpStNoVnee99Hlkyz71/zvzChBbzQRE+hJXLB1JovbnK5WrEsEjjGS5Rsh5oFigty9akcjtYWuTiwgDDDhQTH31UaMF/6f2Nn/NRQ5YXOUynx4byq8NwVeHQpbXhFrhrWRZfRq7ZECdAaj1cOr1xnYniZG42216HFimA83T4gH4KlfDtOgt/7XIVlHh36TX3rpJVauXEl4eDiDBw9m+PDhZ/2TpG7vlLnzXo8L1I3DVix3y7trkqWrg2pzhyq/LpZk+ceKrQqNL7aZWx6P7+VENyYsI37ufqJxiCPo7r+fzmbfFyJR94uBwVfY9FSmqOHQZ47oVrjuKZuey+oqckUb+6JU8f/yLFjzGHx2qWga0gbD4wIJ8XGjok7fmAxZ057MMup0RsJ83ekb3rkFiM/nvmm9CfFxI624mo+3ZtjsPFLndGhO1oIFC6wchiR1MY1J1jh147CVxpGsbjrvo9K8GKSLB3h1sdJpy8icZR0wO/r9hHijNCHRSUsFHaXBTcwoOPRj9/39dCb1lbDhObE//j6xzpWtTfs3HF8JR36G9E1nr7PlyNY8AaXp4nftum9F86UVj4iv4a0JcMkboqPieWg1CjMGhPPlzixWHspnYm/rjjZtPiESt4m9Q23aFM7Pw5WHZ/fj4e/28+ra41ySFEWYr4fNzid1TIeSrMcee8zacUhS11FTYp6PBcSNVzcWW4lKAkUDFdni7qJf51e0dyqV5np+30jHeWNtLZYkqzJXlOHYaaHl0uoGDueJNXzGOdNIliN1FrQ4s/mFydT1fka7kk0viFGsoF4w8mb7nDN8IIy4GXZ/IBY3/vMmx19QvSwLDn4n9q9YAqF9xb/Y0fDNQrEu3OeXw6S/wZR/nvdnfubACL7cmcWqQwU8efEgNBrr/X5sOS5uFE3qY/sbRZcPj+Hz7afYl13Okt8zeHh2P5ufU2qfThX+7tmzh88++4zPPvuMvXtl7bckAU2tzYN7g49tarJV5+4DYQPFfncsSarME1tf67bndQjeYaBxFeVEVbabHP5H29JOYzJBn3Af57oje/qE2HakvbatRA4R38PqQtW6REptcPokbHtT7M9+Flzc7Xfuqf8CjwAoPCRaxzu67W+JZksJk5rWggMI6y+SxDF3iv9vegHWPS1uLrRgfK9gfNxdKKysJyW7zGohljdAakEVioLVR8iao9Eo3DGpFyDW5TIYW/6aJXV0KMkqLCxk6tSpjBo1ivvvv5/777+fESNGMG3aNIqKbL+StiQ5tExLqWAXHcWyiB0ttpbSyO6kcSTLNi2AVaXRNI1M2nFe1vpU0SXrgkQnuzFRbG4eENJX3TjO5OoJEYPFfne8CeIsNr0ARh0kToc+s+x7bq8gmP642F/7JBQese/526O2FPYsEfsTHjj3866eMOe/MOtZ8f/NL8LeT1s8nLuLlin9wgDrdhk8Wi5GxAZF+RPkbYeyT2Ba/zD8PV3JK69j68m2zUuT7KdDSdZ9991HZWUlhw4doqSkhJKSEg4ePEhFRQX333+/tWOUJOdyqpskWfHmdfIyflc3DjV05ZEssHvzC6PRxAbz2jJTzW9+nEbxcbEN6aNuHH8UI9fLcmilp2D/N2J/yj/ViWHETZA4Awz18MPtYNCpE0drkj8FXbWonug1reXHjbu76Vqu+lfTzbBmzBoYLh52qADTeUa92iO1TCRZ9igVtPBw1TJ/qHgd+n6P/ZsVSefXoSRrxYoVvPnmm/Tv37/xYwMGDGDx4sUsX77casFJktOpr4K8fWK/qydZls6JBQfFncbupCuPZAH4R4utnZKsQ7kVFFXW4+2mZVSCg3Toa4uGajEvESCkt7qx/JGlOU2OTLIc0tbXxHpVPaecXf5mT4oimkV4BkH+Adj1vjpxnI/RALveE/tj72x9fuEFiyBymFhzbPnDLT5sct8w3Fw0pBdXc7ywqvNhGk1NSZYdSgXP9KfhYh7tikP5VNY5aKLcTXUoyTIajbi6nruKtaurK0aj7NcvdWPZu0TduH9s03pDXZVvuJh3hglObVM7Gvs6s/FFV9TYYdA+SZZlQc0JiSG4u2jtck6rsMzH8gp2vC6TlpGsvH2gr1c3FulslQVidAZg4iJ1Y/GNgOnmZmYbnhONmxzJsRViXqFnYNva22td4OLXQdHC4Z8gb3+zD/Nxd+ECcxfTFQc7XzJ4JL+Sar2Ct5uW4T3se6NoWGwAvUK9qdMZWXYgz67nls6vQ0nW1KlTeeCBB8jNzW38WE5ODn/5y1+YNu08Q7mS1B65e2HvZ6BvUDuStss0JxtxXbR1+x9ZSgZPdbOSwcZywS46kuVnHsmqsE8b93Xm+ViyVNCKAhNE8mdoEKMUkuPY/qYo0YsZBfET1Y4Gkm6A8EFQVwYbnlU7mrPteEdshy8Uc6/aInII9J0j9lN/a/FhsweKv9/WmJe12dxVcGzPIFy1tltMujmKovCnEeLG2Pd77L/0htSyDv0kvPHGG1RUVBAfH0+vXr3o1asXCQkJVFRU8Prrr1s7Rqk7Ks+BJfPhp3vg/alQcFjtiNqmu8zHsrCUDGZsVjcOe+vyI1mWOVlZNj9VcVU9+8wdvib3dbYky9L0wsFKBUGUVUXLeVkOp7YMdn0g9i9Y5Bjt9TVamPWM2N+zRJTBOoLjqyF9o1guZNRt7Xtuv4vE9jxJ1rT+YWgUUa6cVVLTiUBhoznJmpiozvITlyXFoFFgZ0YJp047yPdP6liSFRsbS3JyMr/99hsPPvggDz74IMuWLSM5OZmYmBhrxyh1NyYT/PZXaKgU/88/AB9fJF6cHJm+oamTV3dJsiwjWfkHRA28SnQGIweyy6mwRz16fSU0mGv4fcNtfz41NM7Jsv1d0WUH8jCZYEiMPxH+TtS6Hc5IshxwJAsgapjYypEsx7HrPfHaFjYA+sxWO5omCZPEzRVDQ1NFhprqK+HXv4j9MXe1v/y+zyxRMlhwoGktuz8I9nFnVLwo8111uKDDoZ6uqic5swxQbzQ+wt+jcRH375PlaJaj6PCYpqIozJgxg/vuu4/77ruP6dOnWzMuqTs7/BMcWy7WeVn4s5j3U3Mati1WO7Lzy90L+jpRouOob7qszS8KgnqKNZUs64PZUUZxNf9eepBR/1nD/De2MP7ZdTy3PJXaBoPtTmoZxXLzBXdf251HTZY5WbUlNr+r/VOKKDu/eKgTLmhdbJ6TFeyAI1kgSsBAvNGU1FdXLtZ7ArjgL2K5BEehKNDzQrGftkHVUDCZYOU/xUh6QBxM7UD3Ra+gppudR5e1+LBZVigZXJdaiNEEMd4mIlW8UXR5Y8lgttU6Jkqd0+Ylvl977TXuuOMOPDw8eO211877WNnGXeowk0msHQJwwYPij/60R+GbG0Qd+5g/g7f92qO2i2V9rLhxjlECYi89JkBJGmRssdtaL4WVdTy3LJWlKTlY1l90d9FQVa/n7Y0nKaqs56Urh9rm5F19PhaAhz+4+0F9hRjNCrXNTYOskhr2nCpFUWC+syVZRiOctszJctAkK8KcZBWmgkEvmgJI6tnyirhhGNwbBl6mdjTn6jlFzINWO8na9AIkfyz2578Kbt4dO07fuaKUPfU3GHtXsw+ZOTCcJ389zO6MEk5X1RPs0/4FodccEaNggwLVTWxmDojA201LTlkte7PKGB7nRJ1au6g2/8V9+eWXue666/Dw8ODll19u8XGKosgkS+q4zO2iJbiLJ4y7R3ys/3zRkjUvBba8DLP+o2aELbOsF9VdSgUt4i8QCz/aqfnFmsMF/OXrFCrr9YAoz7h5Qjzjegaz/GA+93+1l++Ts5k3JIKp/WxQztfV27db+EVDUYVoUW6jJOvnfWIUa1zPYML9nKxUsDxLjFxr3SCgh9rRNC8gHtx8RHnr6eMQ1r/Vp0g2Up4tbhQCzHjSMRPehElim38AqovVuaG5/1tYb36Nn/0c9Jra8WP1mQUrHxHvK/T14HJuAhUT6MWgaD8O5lSw5kgBV41qX1linc7ApmNiPtagQHW7a3u6aZk+IJyfUnL5dV+eTLIcQJvHqtPT0wkODm7cb+lfWlqazYKVugHLOh2DLxctW0GMCk35h9jf+5ljtiPW1zclGZYXqu6ih3leVm6KqKO3oeKqev767T4q6/UMjfHnp3sm8OFNo5jYOxQXrYb5Q6O4dUICAI/8cMA2c7S6etMLCxu3cTeZTCzdK+YOXDLMyUaxoKmzYFAvx3zDDKIcLXyg2M8/qG4s3d2qf4ukvMeEps53jsYnrKnENH2j/c9v0MO6p8T+hAdbHH1qs6Ce4n2EUQeFLTfPmjXAUjLY/nlZv58oplZnIMLPnZgODrhZ07zB4nVp2YE8jEZZMqi2DhUEP/nkk9TUnNuJpba2lieffLLTQUnWtS+rjGeXHeGZZUca7xw7pKpCMR8Lzu0klDgdfKNEi9mjDrjgddZO0NWAd5hYlb47CYgVd/JNBsjaYdNTPfPbEcprdQyI9OP7u8YzNDbgnMc8NKsv8cFeFFTU8+GWdOsH0V1Gsmzc/GLjsSKOF1bh7aZl9iAnTFgbm14kqhtHa+S8LPXt+xoO/SAaMcz6j2OXk/ecLLYn19v/3Id+gLJTYl7zhf/X+eMpiqiCAbFeXAtmDRJ/y7ccL6bKXCHRVh/9niGOMTDcIb6tF/YNxdfdhfyKOvZklqodTrfXoSTriSeeoKrq3BWya2pqeOKJJzodlGQ9uWW1LPxwJ+9sSuPdTWnc/+VeNh4rUjus5u37Stxxih7Z1BXLQqOFoVeZH/el3UNr1cl1YttzsmNNZraXeEsr9y02O8WqQ/n8sDcHRYFnLhuMSwtrkXi4anloVl8APticTnmNlUezGudkOWFi0B42Hsl6Z6Ooerh6dBz+nucubu/wHL2zoIVlXpYcyVJHaYbolgsw+e8QlaRqOK2ylOcdWwlGGzYQ+iOjUUwHADGC5eZlneNGmufm5qa0+JDeYT4khHjTYDCy3rxmX1ukZJWx5UQxLhqFm8c7Rsmwu4uWGQNFmfyvjnxTvZvo0LtBk8mE0kzKvm/fPoKCHGzV+27MYDTx4NcplNfq6Bvuy6Q+oQD8/fv99ml13V6Hl4rt0Kub//zQa8X2+Gox6uVI0sx3/TpTP+7MLCWDGbaZl7XhaCH3frEXgBvHxTOsmRGsM80dFEm/CF8q6/W8v8XKJczdZSTLz5xkVVg/ydqfXca2tNO4aBRuuSDB6se3i9PmzoKOnmSFDxbbAplkqWL530XL9rhxMPGvakfTuoRJ4BEA1YVN6z7aQ9o6UdLn5gujbrfecS03bM8zkqUoCnPMo1nvb0lvc2e+N9eLvwGXDIsmOqCNCyXbgaWJ0E/7cqnT2TFRls7RriQrMDCQoKAgFEWhT58+BAUFNf7z9/dnxowZXHnllbaKVWqn9zensTO9BG83Le/cMIK3rx9OfLAXeeV1PPPbEbXDO1tZJuTsARTof3HzjwntI0a5TAY4+L1dwzuvmpKmu2SWUovuJmGi2ObsgVrrlSg06I28se44d3yyhwaDkTmDIvjXvNYn72s0Cg9OF29+39+cTlrRuSPvHSZHsjrFaDTx3PJUQLRtd6Q3J+3iyAsRnyl8AKBAVQFUOWgVQ1d1cr15ORIXmP+aqMhwdFrXpoV8LTc+7eHgD2I79GrwDLDecS0jWQWHwNDyzeWbJyTg5aZlX1ZZm9q5rz5cwKrDBSgK3DW5p7WitYpJvUOJ9PegrEbXqdb0Uue1K8l65ZVX+N///ofJZOKJJ57g5Zdfbvz39ttvs2XLFhYvdvC1jLqJ01X1vLFO3GV5dP4A4kO88XJz4fnLxR+cr3dnkZpfoWaIZzv8s9j2GH/+BV4HmBOw9M22j6mt0jYAJrG4pF8Xf+PdkoA4CO0vEuDja6xySJ3ByLXvbefFVcdoMBiZNziS165JarFM8I9mDQxnbM8ganUG7v9qLw16K3R+MpnOGMnqogsRW5yZZFlxzZV3N6ex9eRpPF213DfNwROUltSWiaQFHHeNLAs3bwjuJfbPczdfsjKjQaz1BGKOsY06dNrEwAVie/hn+5QM6hsg9VfzuS+17rEDE8DdHwz1UNjyzeVQX3duM4+qP7/yKHrD2a8XJpOJDUcLeXb5ERavP8G9XyQDcO3oOBLDHGu9RK1G4cqRsQB8tTNL5Wi6t3a1RLrxxhsBSEhIYPz48bi6OmEdfTfx2trjVNbrGRjlxxUjYhs/PjohiLmDI1h2IJ/nVxzlw5tGqRjlGSwNLwYsOP/j4szt0TO3iRpuR5j/1Dgfa4q6cait72woOiLu3A65otOHe3vDSXafKsXXw4WnFwzi4qFRzZYpt0RRFF6+ahhzXt3MwZwKnl+Ryr8uGtC5oOrKQV8r9n26ermgueOfvk6M1noHd/qQB3PKeXHlUQAemz+AhBAHaMfVEZZSQZ8I8PBTN5a2iBouYs7ZA72nqx1N93BsJRQeEqV31mjiYE8JF4q18qoLxWutZc6traRtEH9bfcIhbqx1j60oEDlErJeVt0/st+D2ST35dPsp0oqqeeznQzy9YBA6g4n1Rwv56Pd0tqeVnPX46f3DeOJix2x0deWoWF5bd5xtaadJL6523r+1Tq7N71ArKppGPZKSkqitraWioqLZf5K60oqq+HxHJgD/mNsfjebsN6YPzeyLVqOwLrWQHWmn1QjxbOXZkL0TUSo4//yPjRwq1tCqLWkq11GTydS0cGN3nY9l0cfclvj4mvOWZbTF8YJKXjePxD51ySAuGRbdrgTLItLfkxfMo7fvb0ln/dFOzuWzjGJ5+FtvYrajcnEXb3pArAllBa+sOY7eaGLWwHCuGhXb+hMclbOUClrEjBTbnN3qxtGdWErah10HXk42V93FDfqZX4vt0WjKUpY44BLblFRaSgbzUs77MF8PV565dDCKAp/vyGTBm1sZ8fRq/vzpHranleDmouGy4dFM6xfGFSNieP2a4W2urLC36ABPJpvn4b+3WS6tpJY2/3QEBgZSWCjeoAQEBBAYGHjOP8vHJXU9v+IoeqOJKX1DmZB47mKCPUN9Gt/gvLvJAX75jvwitnFjWy+3c3FresOQacdJuS05fUK8AdW6db9FiP8oZqRovVtf3ukJ088uT6XBYGRqv7BOr6E0Y0A4N44TnZ8e+mYfhRV1HT9Yd5mPZeFnbuNe0fk27kfzK1lzRMxheHh2vw4lzQ7DskaWoze9sIg2/83M3m3V0k+pBbrapqVGBl2mbiwdNfwGsT3wvVXn2Z5DX99UKthaJUtHWTo65u5t9aFzBkfynwWiWcy+rDIq6/SE+bpzx6SerPvrhfzvymF8cNMoXrhiKJ5ujj3H7s4LRZnwVzszOVZg2zUspea1uVxw3bp1jZ0D169XYf0EqU12ZZSw4lA+GgUemdtyg4Cbx8fzxY5MNhwroqiynlDfc1dCt5tDS8W2rX9g48aJof/M7TDyFltF1TaWtUTixnb9kY3WaLTQexbs+wKOrYCeF3boMKXVDWwyLzPwz3n9rfJm/JG5/dmRXkJqfiVP/3aE167pYBvl7tJZ0MI/BnKTrdL84u2NJwGYMyiCXqE+nT6eqpylfbtFxCBxI6i2BErTxSKtku0cXwW6avCPg+gRakfTMbFjxBprBQch5UsYd7dtzpP6qygV9I2yfqmgRfRwsc0/IOZ/ubid9+HXjokjyNuV7NJaRicEMTDKH63G+W4KjekZzKyB4aw8VMAzy46w5ObRaofU7bQ5ybrwwgub3Zcch9Fo4j/mroFXjoylT3jLkzF7h/syNDaAfVll/JSSw20TVXrRrciFrO1iv7VSQYse48T21DbbxNQecj7W2XrPEElW+qYOH2LV4Xz0RhMDIv2s9mbcw1XLi1cMZf4bW/h5Xy63XpDQ7ELGrepuI1mNzS86Vy6YU1bbuBD63ZMdfPHetmgcyXKSckEXd4gYLOZkZe+RSZatHfpRbAcucOyFh89HUWDUrfDrX2DX+zDmTtvMgd6zRGyH32C77ouBCeAZKEbkCg42JV3n4ZQLpDfj73P6sy61kA1Hi/jzp7v590UDiAlsuiG89UQxS1NyOJxXQaCXG69cNYxgHxVvuncxHfqNWbFiBVu2NC06unjxYoYNG8a1115LaalcYVotb6w/QUpWGZ6uWhbNaP0O6+UjxBuo7/Zkt3ldCKuzlArGjgH/6LY9J2Y0KFooz7TZQqltYtCJETWAXjLJAprWyyo4JDqwdcCv+0UiM2+IdV/kBkX7c2mS+Bn7z7IjHfuZ744jWQDlnSsX/HJHJgajifG9ghkU7W+FwFRk0EGJuczaWZIsaCoZlPOybEtXJ5pegPOWCloMvlKsW1VyUqxjZW2nT5pvyCmQdL31j2+hKE0jijl7bHceB5QQ4s0/5vZHq1FYeaiASc+v55p3t/PYTwe5+aOdXPv+Dr7Znc3BnAo2Hy/m6ne3U9CZknrpLB1Ksv72t781Nrg4cOAAixYtYu7cuaSnp7No0SKrBii1ze8ninl5jShhefKSgYT5ebT6nPlDInHTakjNr+RATrmtQ2xeW7sKnsndp6lDkJqjWVk7oKEKPIMgYqh6cTgS33DzXXKTuD7tdLqqnq0nRTOWi6ycZIFo+uLuomFnegmbjxe3/wDdbSTLMierEzczdAYjX+8WI2HXj+1hjajUVXYKjDrRgMeyYLMziDljXpZkO9m7QFcjOk9GDlM7ms5x92mam7X1DesfP/kTsU2cLpYBsaXGJCvZtudxQDdPSOC3+y9gfK9gjCbYlnaaj7edYv3RIrQahWvHxPG/K4cS6e/B8cIqblmyC4NRzt20hg4lWenp6QwYIFohf//998yfP59nnnmGxYsXs3z5cqsGKLWupkHPQ9/uw2SCK0fGcMXItnXtCvByY85gcUf++RVH7T+aVVsm2sNC20sFLeLMJYNqNr+wJIh9ZjlGK3lHYWmz34HmF6sOF2Awmhgc7U+PYOu3nI0K8OSa0eLF/JNtp9p/gG43kmX+W9KJxhdrDhc0zvucMcD51xZTLO3bQxKd6/fe8iYzf7+YlyLZhqW6IWGi85YKnmnMnaBoIG095B+03nH1DZDyudgfcZP1jtuSbjqSZdEvwo8vbh/L5oen8Nj8Adw7JZH7piay4oGJPHPpYC4bHsM3fx6Hn4cLh3Ir+Cml882OpA4mWW5ubtTU1ACwZs0aZs6cCUBQUJBs4a6CtzemkVdeR0ygJ09cPKhdz/3rjL64uWjYcqKYVYcLbBRhCzI2g8koJo8HtLOdc5zK87KMhqYka6CTl4RYm2XOXGb7vzebj4uGFzNt+Gb8BnOnwXWpBWSX1rTvyY1JVjcZybKUC1bmgUHf7qebTCaWbM0A4KqRsbg6aLvj9lBOO1lnQYugnmLpAUMDFB5WO5quK92cZMVPVDcOawns0VRpss2Ko1lHl0F1kRjx6zPLesdtSZR5HlbxMdFoo5uKDfLi5gkJPDSrL3+d2ZfeZ8zdjw3y4s7JoiPhS6uOUa+3w0LUXVyHXvEuuOACFi1axFNPPcXOnTuZN28eAMeOHSMmxonKJ7qAnLJa3jF37frH3P7tbikaF+zF7RPFKudP/3aYOp0df6ks60v1nNz+51qSrKIjYqFUe8vcBlUF4k1LR+Lvyizfm5xk0cq4jYxGE9vMpYLjEzu/8G1LeoX6MCFRlE18YV5Prk1MJqhynpGskuoGHv/5EJe/tZVL3/ydjeaOje3iHQoaV3EzxFIq2Q7PrzzKjvQSXDQKV4924nWxztA4khXsRPOxwLwoa9vWC5I6qKFGlAuCGMnqKsbfJ7YHvhXNqqzB0vAi6XrQulrnmOfjEyq6PWKC3BTbn89J3Tw+gXA/d3LKavl8ezteH6VmdSjJeuONN3BxceG7777jrbfeIjpa1O0vX76c2bNnWzVA6fz+uzyVer2R0fFBzBnUsTd+d09OJMLPg6ySWl5fd9zKEZ5HZ5Isn9CmNzkdmPvTaZbuUf3mt9oOttsJ6ikWsTXq2lWacbSgktIaHV5uWobEBNguPuAG89ygr3ZlUVRZ37Yn1ZaKUQBoWqTXgT307T6WbM1g96lS9maWceOHO3nsp4PoDMa2H0SjAT/zOmXtnJf1/uY03togbgA9c9ngszpaObXTTtZZ8EyWOULyTaZtZG0Xf/f8YkRHu64ierhoamTUw453On+8knRRfojSNOfLHixdBXO737ystvJ00/LANDFK/8b6E1TW6VSOyLl1KMmKi4vj119/Zd++fdx6662NH3/55Zd57bXXrBZccxYvXkx8fDweHh6MGTOGnTt3nvfx3377Lf369cPDw4PBgwezbNkym8ZnT3tOlfDzvlwUBR6dP6DD6wl5u7vw+MUDAXhnYxpH8+2waF1ZlljIV9FC/AUdO0ZjK3c7z8sy6OHwz2J/4KX2PbczUJQOlXNaGl6Mig+yeVnZ9P7h9Az1pqS6gVs/3kVNQxtK4SwjOV7BoiW2A9t8vIh1qYW4aBReuHxI42LMH287xa0f76aqvvmvN6ukhp9Scnh97XFOFlWJDzaWDLb9Dvbi9Sd42rycxN9m9eXKNs4TdQZOWy4IEDVMbOVIlm2kd7H5WGeyjGbt/gjqO/kewdLwotdUCIzv3LHao5vPy2qrK0fG0DNEvD6+tzld7XCcWoffyRgMBr7//nuefvppnn76aX788UcMBtuWmn399dcsWrSIxx57jOTkZIYOHcqsWbMoLCxs9vFbt27lmmuu4dZbb2Xv3r0sWLCABQsWcPCgFSdvqsRoNPHEL6Ku/soRsZ1uizx7UAQzB4SjN5r419IDtm+Ckb5RbKNHiJK7jojr+NyfTjm+CqoLxZvtDi642+X1MDe/aMf3xlIqOK6X7UoFLVy0Gj64cRSBXq7szy7n6ne3szO9lbJTJ+ksqDcYefpXkeDcMK4HV4yM5YlLBvH+wpF4umrZdKyIGf/byOL1JxqTLZPJxHub0pjy4gYe+CqFl1Yf49r3tlNYUdf09baxTOj7Pdm8sPIoAA9O783d5hr/rsBNX4lSa16mJNgJ1/uyjGQVHJLNL2zh1O9i21XmY52p9yxRPVJfDsmfdvw4Bh3s/Uzs26PhxZm6cYfB9nDRanhoVl9AVCQUV7Wx2kM6R4eSrBMnTtC/f38WLlzIDz/8wA8//MD111/PwIEDOXnypLVjbPS///2P22+/nZtvvpkBAwbw9ttv4+XlxYcfftjs41999VVmz57N3/72N/r3789TTz3F8OHDeeMNG7QitbM31p9gf3Y5Pu4u/HWWde6oPnHJQNxdNOzKKOX3E6etcswWdaZU0MKSZOXuFbXw9pL8sdgOu9Y+teTOyPK9ydopmoS0wmA0sSPdPB/LDkkWiPVDPrhpFN5uWvZnl3PlO9t4/OdDLbeudZLOgj/uzeFoQSUBXq48MK2ppG36gHC+umMs4X7u5JXX8cLKoyxY/DtbTxRz40e7+M+yI+iNJobE+BMd4ElBRT13frYHfTuSLKPRxOINYs7SPVN68eD0Ph0eYXdEPnXma+AfB25OWP4Y1BPczc0vio6oHU3Xom9oKsOMG6tqKDah0cC4e8T+7690fDTr6HJxk9I7DPrOsVp4bRI5VHRKrMiBivbPMe1O5gyKYEiMPzUNBt5Yd0LtcJxWh5Ks+++/n169epGVlUVycjLJyclkZmaSkJDA/fffb+0YAWhoaGDPnj1Mnz698WMajYbp06ezbVvzd8u3bdt21uMBZs2a1eLjnUFlnY53Np7kf6vFmlh/n9OPMN/W18Rqi0h/T64dI9pbv7r2mO1Gs0wmyLDc8etgqSCIMgOfCFEnnrvXKqG1qjxHjGQBDL/JPud0RuEDwd0PGioh/0CrDz+cW0FlnR5fDxcGRtlvsdrhcYGse2hyY1v3JVszuPeL5OYbwDSOZDlukqUzGHnNPK/yrgt7EeB19nzBobEBbPzbFF66YigRfh6cKKzi2vd3sOlYEW4uGp5eMIif7pnAZ7eNwc/DheTMMrYVmksj29DGfeOxItKKqvF1d+GuyU440tMKnzrzz0CIk35titK0xqCcl2VdBQfAUA+egea1ArugYdeKuWZVBbD5fx07hr0bXpzJ3QdC+4t9OS/rvBRF4f9m9wPg8x2nyDxtxxvZXYhLR560ceNGtm/fTlBQUOPHgoODee6555gwYYLVgjtTcXExBoOB8PCzJ5yHh4eTmpra7HPy8/ObfXx+fn6L56mvr6e+vmlo1NKSXqfTodOpMwFQp9PRYID7Xv+KyJKdfKQXzUXundyTq0ZEWTWuW8fH8fmOTDGadbyQMQlBrT+pvUozcK3MxaRxRR8xDDoRvzZmNJrUnzFkbMUYPbrDx7Fcw9aupWbPx2hNRoxx4zH49+hU7F2dNmY0mpNrMKRvQRcgRltbur670sXCwMNjAzAa9G0Z/LKaIE8tT87vx5j4AP72/QGWH8ynqHI7b1+XhL9n05sATXkuWsDgFY7Rwb7vluv63e4sskpqCfFx45qR0c1eby1w8ZBwRsf7c+fnezmUW8mEXsE8Oq8fPUO90ev1xPi78e95/fjb9wf5KR0mAsbyXAytfN3vbRaVDFeMiMZdY1Ltb6Yt6HQ6fOtFkmUISnS4n4G20kQMQZuxGUNOMsYh16odTqO2/g12VJpTO9ECxqgRGPTtX+7A1qxzfTUo05/E5dsbMG17A/2Qa9rX4KPsFC4n16EAuiHXqvL6qY0chqbwEIbMXRh7zbTacZ3957c5o3v4M6FXML+fPM2LK1N56YrBqsbjSNe4rTF0KMlyd3ensvLcoeKqqirc3Jy709qzzz7LE088cc7HV61ahZeXeuUhfobTvFLxf3i4NFCkjYDwwSTWHWPZsmNWP9eYYA2bCzT854ed3Nm/HZ3I2ij29GaGAyWe8WxZvaFTx+pZ6cNgoCj5V3aUd75scvXq1S1/0mRi2uGP8AH2KkPI7kJNVGyhd00gA4CCXUvZVSwaH7R0fZcd1wAaPGsLVGtOowB/7qvw/lENu0+VMe/ldVyfaCDOR3x+dNo+IoGDp4rJcMDvvcEEr6xOBRQmhtSyfs3KVp9zaywUhUK4ZwGpuwo483aV1gRB7lpO1PqBO9QVnmT1eb7u3GrYetIFBRMxtSdZtsx2peNqGWMuFzyYV++QPwNtEV1qYiRQnrqZzSbH+xrO+zfYgQ3P+JlY4Fi1L0cd+Gej09fXZGKc7yDCKg9S8MW97Em4p81P7Zf7HX0xUeg7iG3bDgP2X6+tR4kbw4DTB1axrTbJ6sd31p/flozzgt9x4Zf9ufQji2hvtSNyjGtsWSu4NR1Ksi666CLuuOMOPvjgA0aPFqMHO3bs4M477+Tiiy/uyCFbFRISglarpaDg7AVzCwoKiIhovnwnIiKiXY8HeOSRR1i0aFHj/ysqKoiNjWXmzJn4+fl14ivoOJ1Ox+rVqynrcwURxz7nde8P0V+9wWZlSwNP1zD9lS2klmsYNv5CogI8rXp87a8rIRMChsxh7tS5nTqWkhMBS74gXHeKuXNmi3rrDrBc4xkzZuDq2kIJQ94+XFMKMbl4MuTKRxji5gB/bRyYkhUEn3xLpC6DGdOns3rNmhav7yuvbAFquGLqKCb1DrF/sGeYnV/JrZ8mU1BRzyuHXLlyRDTXjIolvOAVKIeBY6cxoG/nfm6tTafT8fLXayipVwj0cuXJhdPwcG3fmnnNKQvO5J3fRKMHT305c2fPAk3zx33kx0NADrMGRnDDZUM7fW5Ho9PpMB36KwADJ1/KgB6dKHVWU1EvePdNAnX5nfqbaW1t+hvswFzeehyAxMlX06vXNHWDaYZVr29BD3h/MtFlOwkf+SKE9W/9OQYdLm/8DYCgGX9hbn+V/obmx8IHHxHakGXVn39n//k9nyOm/fx2MJ8dtRG8f8XwNj2ntsFAYVU93m5aQnys043Xka6xpcqtNR1Ksl577TVuuukmxo8fj4uLOIRer+fiiy/m1Vdf7cghW+Xm5saIESNYu3YtCxYsAMBoNLJ27VruvffeZp8zbtw41q5dy4MPPtj4sdWrVzNu3LgWz+Pu7o67+7k/EK6urqp/U4Mv/S8s2Y9ScADXX++FG5bapE1sYoQ/43sFs/Xkab5PyWfRDCu3Ks4Sc+K0CRPRdvaaxg4HF0+U2lJcyzMgtG+nDnfe7/Ox3wBQes/A1TugU+fpFuJGg9YdpboI18pTQPPXt7xGR7q53nt4j2DVf88GxQax7P6JPPHLYX7el8uXu7L5clc2+/2y8QNcAmLAAV9EtxeKvwWXj4jB18s68zSvGRPPm+uPozdocMGAa0NZszd3iqvq+Xm/KKW7fVJP1b+HNtFQhWuDWNDZJXKwQ/4MtEl4X9C6oeiqca3KhSDHWs/JEV5r262mBErSAHCJG+3QPxtWub4xSTDgEpTDP+G65QW4qg3dBk+sFHO5vEJwGXAxuKh0jaIGi/cM9RW4VmRafb07p/z5bcXfZvdj5eECNh4vZk9WBWN7ttycymQy8fKa47y5/gR6owlFgb/O6MM9UxKt1gTJEa5xW8/frhTeaDTy3//+l3nz5pGTk8OCBQv49ttv+e677zh69Cg//vgj/v62m7S+aNEi3nvvPT7++GOOHDnCXXfdRXV1NTfffDMACxcu5JFHHml8/AMPPMCKFSt46aWXSE1N5fHHH2f37t0tJmUOz8UDrvgIXDxFdz5LG1QbuNrcCODb3Vktd1vriIo884uRAnFjOn88rWvTAoO2XJTYZILDS8X+wAW2O09X4uIOsWKkW5OxpcWH7csuAyA+2ItAb8coNw72cee1a5L44rYxzB0cgYIRr3oxb8wRG18UVtZzqFS8gF01ynprUnm6aVk0awBFBABQkJ3W7OM+355Jg97I0NgAhscFWu38jkQpFqXZJu9Q8FZ3tLVTtK4QYr4ZVSg7DFqFZd2loF7gZYN5zI5o8iOAAkd+bttalZauvEnXgYuKf+e1rk2t3C1LyUjnFR/izdWjxevKoq9TeHvjSb7dncVXOzPJKmkqm6uo0/F/3+/ntbXH0RtNuLtoMJngxVXHuOuzZHLKatX6ElTTriTrP//5D//4xz/w8fEhOjqaZcuWsXTpUubPn09iou27LV111VW8+OKLPProowwbNoyUlBRWrFjR2NwiMzOTvLymtpzjx4/niy++4N1332Xo0KF89913LF26lEGDBtk8VpsJ6Q1T/iH2V/0LKgvO//gOmjUwnEAvV/LK69hwtPl1yDok0/zHOGJwx9fH+qNYc7KWacMkK/+ASA5dPMR6IVLbJIh1xJSMTS0+JCWrDBCd7xzN+MQQ3rxuBP83MQQXxYjRpHCwwvEWIv5xby5GFJJi/UkM87Xqsa8eFUulWxgAH6/4ndw/vFAeyC7no61iwcpbJsR3qZbtZykSa3+ZQjo3Wu4QLOVdhYfUjaOryN4ttjEj1Y3DnsL6i26DAN8shLKs5h9nNMLW1+G4eR7N8BvtE9/59JoitifWqRuHE7l/Wm/C/dzJLa/jueWp/O27/fz9hwNMfH49s17exMIPdzL+2XV8szsbjQLPXjaY1Kdm859LB+GiUVhxKJ8pL27gP78dprS6+6zR164k65NPPuHNN99k5cqVLF26lF9++YXPP/8co9H6zRFacu+993Lq1Cnq6+vZsWMHY8Y0jYZs2LCBJUuWnPX4K664gqNHj1JfX8/BgweZO9ex5lJ0yNi7xXoPdWWw9C6xuJ+VubtouXxEDACfbT9lvQNn7RTbuJZLNtvNcqyT68QfdFvY/7XYJk4XbWCltjGvg6ZkbAZT898bS5I1zAGTLIs7hol5iafxY9F3h6jX27H9YSvq9Qa+2Cne4FwxItrqx9doFKLiREvq6uIspr20kcve/J3L39rKrUt2ccU7Wymr0TEg0o+5gx17oebOUMzrSplC2zD/xNGFDxBbOZJlHVnbxTZmlLpx2NvcFyB8MFQXwZfXQN0f5qlUFcLnl4sbwphg5C0Q7ACLkyea58ylb5SLcrdRmK8HaxZdyLOXDebCPqFc2CeU0fFBaBQ4WlDJpmNFVNXr6R3mw4c3jeKa0XEoisJ1Y3rw490TGNsziAa9kfc2pzPphfWsOtRyl++upF1zsjIzM89KUqZPn46iKOTm5hITE2P14KQWaF3gksXw/gw4uRZ+uhcWvCUWC7Si68b04L3N6Ww4VkTm6Rrigq3QXTF7l9jGdrzd+jl6XihGxSpzIWOz+L811ZScsbbHDdY9dlcXlQTufih1ZQTUZpzzaZPJxD4nSLI01WLE+LQSxLGCKl5Zc7xxDRG1fbkjk9zyOvxcTVxkoyTHJ6QHnISkgBo+Pm0gObPsrM9P7hvK69ck4ap1jCYKtqCYR7I6O+/TIYSZk6wC+3d363IMesgyv65Z8+ahM3Dzhmu+hPeminXCvr4OrvtOlIqfWAM/3ikSMBdPmPOcY4xiAUQMBa8QqCmG7J2dW6+zG/H1cOWa0XGN60oCFFXWcyCnjMKKeqIDPZnQKwSN5uxqhsEx/nx5+1g2HiviueWppOZXcu+Xe/ns1jGMtsUyQQ6kXa+Ier0eD4+zJ1S7uro6RM/6bidiMFz5CSha2P8VbF9s9VPEh3gzqU8oJpNYjK7TdHWQt1/sW7OswsUdBl4q9vd/Y73jWmx/CxqqxDXvI0sF20XrAvETAQipPPcNXXpxNaerG3DTaugfqU73zjYxL0QcFNkDgHc2niQ1v23dhWyppkHPG+tPADArxoinW+c7CjbLTyRvl/RU+PqOsbxzwwjevG44z1w6mNevSeL9hSPx9ehak73/SCkWDe67xEiWJck6fVzeye+sggOgqwZ3/6br2p0ExMJ134KbL6Rvgveni+Tqsz+JBCtsANyxAUbcZJNGXR2i0ZxRMrhW3VicXKivO1P7hXP16Dgm9g49J8GyUBSFyX3D+O3+icwcEE6D3shtH+/inY0nKa6qb/Y5XUG7kiyTycRNN93EZZdd1vivrq6OO++886yPSXbSZ6YYrgdY/wyUZVr9FAvHijeVX+/Ook7XyRKp/P1g1IF3KAT0sEJ0Zxhyldge/gkarLgyeV057HhH7E/6m+O8SDgTc8lgaOW58z+2pZ0GICkuwCotx22mUpQ2hEX2YM6gCIwmeGlVx9aoK6luoLLOOjem3t6YRnFVA7GBnowLs2KDmj/yE2WISkUuY3oGM2tgBHMHR3LtmDjmD43CpQuPYAFQV45SkQOAKdQxRjA7xT8G3P3AqBeJltRxp0S3XOLGWL2axGlEDYOrPxcjVvn7Yd+X4uOjboPb10GYA/7OJE4X25MyybInrUbhtWuSGNEjkIo6Pc8uT2Xcs2u554tkDmSXqx2e1bXrL8KNN95IWFgY/v7+jf+uv/56oqKizvqYZEcjb4EeE0BXA8v+JrrgWdGUfmFEB3hSVqPj1/15rT/hfCylgjGjrJ+sxI6FgDhoqISjVlwI8vfXoL4cQvtBv/nWO253Yi7fDK46Boaz75pvOymSrHG9Wm4J6xDMI1n4RvLXmX3RKLD6cEHjfLLW6AxGPt6awdxXNzP8qdWMeHoN/12RSkUnkq3kzFIWm0exHprRG5vmOX5RYluZa8OTODBzqWCta6D1GvaoSVHOaH4h52V1SqYlyRqrbhxq63khPJACs/8L/efD1V/AvJfA1brrbFpNT/NIVt4+MSVAshsPVy2f3zaG//5pMENjA9AZTPy2P4/L3vqdr3Zaf7BATe2ak/XRRx/ZKg6poxQFLnoZ3poAx1bA8VVWLWnTahSuGxvH8yuO8un2U43NMDrEnGQVBQwhyGhC28KwcodoNDDkatj0PGx6EQYsEKVqnVGRC9vMZZhT/91971J2VkgfTJ5BaGtLMOUfhHjRrMZkMrE9Tby4jTvPuhsOwTyShW8EiWE+XJoUw/fJ2Ty/IpXPbxtz3o56R/MrueeLZE4UVjV+rEFv5K0NJ/no93RmDYzg3imJ9A5ve1fAqno9D36VgsFo4pJhUcwdHMGyFpp7WYWvea5XRa64kdPdRnQLRalrpUc0XaZBfdgAsexFwUEYfLna0TgnkwkyzU0vutt8rOb4RsDYO8U/R+cbDsG9xUhu1k7oO1vtiLoVD1ctV42K46pRcRzKLee1tcdZeaiAv/9wgNyyWhbN7AJzX2nnSJbkoEL7wti7xP7qx8Bo3c5nV46MxU2rYV9WGfvNaxq1V73eQOUJ0b79/s1arnl3u/XrcMfdDZ5BUHQEdn/Q+eOt+w/oa8WLZ795nT9ed6UomMzrkig5uxo/fKKwiuKqetxdNAyLC1ApuDZqTLJEsvHg9N64aTVsPXmaL3e2nN0UV9Vzy5JdnCisIsjbjScuHsjuf03n/YUj6RPuQ53OyE8pucx7fQvvb07D1MaR6NfWHiezpIboAE+eWmCHJSksSZa+DmpLbX8+R1MgSl0rPLpQg6cI889N/gF143BmJWlQXQhaN4garnY0UntZRh8z27DOl2QzA6P8efv6Efx1Rh8AXlt3gg+3pHMwp/ysm5POSCZZXcXEReARIBKMlC+seugQH3fmDhYLsH66rf0NMDKKq7njjZ/xrS/AYFLYb+zJzowSLn59CxnF1dYL1DMQpv1b7K//D1Sf7vixyrMh5XOxP+Op7nfn3spM0aK1sZKzu/FjlvlYI+MDcXdx4PlYcNZIFkBskBcPzxZ32p769TDpzfwcN+iN3PXZHnLKakkI8WbNogu5cXw8IT7uTB8QzsoHJ/HzvROY3DeUBr2Rp387wrubml/s90wni6r4cItYl+rpSwfhZ4+GE64eohsXgHluUrdiXmy2zLunyoFYUcRQsbU0I5La76R5naWo4eJ3RHIuPcaLrWU0UlKNoijcN603i8yJ1pO/Huai17cw8+WN/JTivK85MsnqKjwDRWMGEE0wrNwx6oZx8QD8vC+XsprzH9toNHGisJLyGh0/78vlote34FYoXsir/BL59v6Z9Az1Jre8jrs/T+58Q40zDb9RdAGsK4dtb3T8OId/AkxiFCu2m619YgOmaNFN8qwkyzIfy9FLBQ16cbcamkZ0gFsmJDCuZzC1OgN3fLKbkj8ssPj+ljR2ZZTi6+7CewtHEuTtdtbnFUVhSEwAH900qrEd/EurjnEkr+WuhUajiSd/OYzeaGJqvzCm9A2z0hfZBpZ5WRWdnJvpbPQNjaM9pV4JKgdjReEDQdGIn23LTQSpfQ7/JLb9usD6m92RZSQrJxl0ted/rGQX901N5Kbx8QD4erhgNMFfvk7ht872BFCJTLK6ktG3izeBlblw6EerHnp4XAADIv2o1xv5dnd2i49bcTCP2a9uYvr/NjH0yVXc/+Vequr1zAwU6wz59xzJgCg/vrx9LMHebhzOq+CJX87tOtdhGi1c+Hexv+t9kWx1xKGlYmtpDS91iikqCRMKSnkWVOZTrzew+XgxAOMTQ1SOrhXVRWIhZUUL3k2xajQK/7tqKBF+HhwvrOLGD3dSXisaWeSV1/LGOtGU4vGLB5IY1vIC1oqicOeFPZneP5wGg5Fbl+zib9/u4+7P97Bg8e88s+wIWSU11DToefDrFDYeK8JVq/Dvi+zcLroxyXLeu4odUnAQDA2YPAOpcbNjUmtrbl5iTgrI0ayOqCqCU7+L/QGXqBuL1DGBCeATLroe5ySrHY2EeD18/OKBHHt6DvsencmVI2MwmuChb/c5Zat3mWR1JS7uomUqiHWzrNhpUFEUFo4Tbdc/23EKo/HcY3+8NYM7P0vmWEEVbuZWZ4oC909N5E/R5u49EUMACPfz4NWrk1AU+HJnFmuPFFgtVvrOFd0A6ytg94ftf355tligEAX6X2y9uLozd9+m+SzZu9hyvJiqej3hfu4MiwlQNbRWWToL+oSLJP4Mkf6efHbbaIK83TiQU87817ew4mAe//f9AWoaDIzsEchlw6NbPYWiKDz3p8GE+rqTW17Ht3uyWXYgn5SsMt7dlMbE59cz4NGV/LwvFxeNwguXDyUhxNsWX23LGpOsbtZh0FwqaIoc3vXKhiPF32Py96kbhzNK/UXcfIlKgsB4taOROkJRmhqWyHlZDsXNRYNGo/DsZUMYGuNPrc7Au5sz1A6r3WSS1dWMuBlcPERbUivXGV88LApfDxdOna5h84nisz63I+00T/0qOnDdPCGeXf+azoHHZ5Ly6EwWzeyLxjK52vKiDlzQO4Q7Joo5Dv9aepCqer11AtVoYMKDYn/bm6Bv590PSwlI3NjGRVilziv1ThQ7WTtZflCUJ80ZFNni4oUO4w/zsf4oMcyXz24dQ0ygJ5klNdz5WTKbjhWhUeCJSwaet/PgmUJ83FnxwERevmoof53Rh3/N68+LVwxl/Bnt7QO9XPnwplEsSGo9cbO67trG3XyH2xQ1TN04bCFisNjKkaz2s1Q7yFEs52ZJsjK2qBuH1CytRmnsNPjFzizKnWztdJlkdTXewU0L83ZmTlIzvNxcuGJELACvrDmGzmAE4EB2OXd9nozeaOLioVE8etEA/D1d8fVwxd/TVaxBUWEuMbS8qJs9OL0PcUFe5JXX8cKKVOsFO/hy8IkQ8w3SNrTvuQd/EFtZKmhVJeYky5i1k9WHxcjl7EHNJy4OpXGNrJZjHRDlx2/3TeSSYVFEB3gye2AEH9w0ioFR7VtTKdjHnUuTYrhvWm9um9iTy0fE8MXtY0l9ajb7Hp3Jjn9MZ1Kf0M58NR3n201HsnItSVYX7B4XYRnJkklWu+SmQMZmsT9ggZqRSJ1lWZQ4fTNUFaobi9SsSb1DGNkjkHq9kdXZzpW2OFe0UtuMuwdQIPVXyD9o1UPfOjEBX3cX9maW8dzyVL7dncVV726jpLqBITH+/PdPQ869c59nLkUJTDhnIU9PNy3PXiYSr892ZJJWZKV2nVrXpjuMljuObVFwCHJ2g8ZFvnhaWal3LwBMuXuprq0lxMeNUfFBKkfVBn9o394Sfy9XXr06id//PpW3bxhh1aYUHq5a/L1ccXNR8U92dywXrKtoXIjYFJmkcjA2EGnuMFia0fH5q91NXQV8e5MoFew/H4K6UDOU7igkEaJHgMkAB79XOxqpGYqiNHYdzKtVmp2u4qhkktUVhfZtGoXZ+F+rHjo6wJPnLxd3Pz/Yks7fvttPTYOBCYnBfH7bGDzdmmnFbblLekap4JkmJIYwvX8YBqOJl9cct16wliTr6G9t7rao2fux2Ok3TyxWKFlNlXsEJo8AtIZ6+iuZzBwYYd0FqW2lDSNZ3YKfuUSxOyVZeSmACfxjwacLNb2w8AoCP/NcSSvfkHNKRcfEEihHV4gyUcvi2xZGI/x8L5Smg38cXPy6erFK1jPkarHd95W6cUgtGp8Ywle3jeLeAQbHn2JwBplkdVUXPgwocORnq794zhkcye0Txd27HsFePDi9Nx/eNArfltbrsdT7RzSfZAH81Vxz+8u+XA7nttzCul3ixopmBXXlkL6p1YdrDXVoDnwj/jPyFuvEIDVRNFSFDgNguOY4N4ztoW48bdXKnKxuwzI/sb4C6ivVjcVeLB3HortgqaBFZDcvGTSZRFL17hRYPAqW3gVfXgXvTYH/9Yf3poq/ASYTrPyHmLOrcYXLPxBLp0jOb9CfRPVKXkrjyLXkeEb0CHS63kMyyeqqwvrbbDQL4B9z+7Pzn9PY8NBkHpze5/yLyTaOZA1t8SH9I/2YP1SUI72x3kqjWRqtKOcAONx6S/uY0m0oDVUQ1AviJ1knBuksG6vjAZgXmE3/SD91g2mrNpYLdnnuvuBu/p51l7WyzJ0FiR6hbhy2ZLn51R2bX1Sfhs8uE0lVbrJ4ox03HiKHiTmIilZ8/IMZsOQi2PGWeN6lb0PsaFVDl6zIOxgSZ4j9dU+JEUtJsgKZZHVlNhzNUhSFMF+P1junNVRDsTlpOs9IFsA9U8ScnVWHCiiqtNJ6CJZ5VYeWigYcLTHqSSxcJvZH3iw6FEpWlV8DX+eLRGWYYsWyUFuT5YJNuttaWZaRrK7Y9MKiu45klWfDR7Ph5DrQuomOtItS4Zbl8OeN8NcjcN8eMZe4LBNObQEUmP2caKwkdS2THhIjlEd+gQ3Pqh2N1EXId5JdmY1Hs9qk4BBgEmV7rcxx6hfhx7DYAPRGE98nt7zgcbvEXyA6GjZUnbfbonLwO3zqCzB5BcOIm6xzbuksv2RqSDH2woiCW2Wmc3RyMuigxrxcQXcfyYIz2rh3g5GsygJzV1QFumL7dgvLza+i1PYvd+GsDHr4ZAEUHxNzDf+8GWY8AT5/6NwZlAC3rISxd4vk6v5kGHuXKiFLNhYzEua/KvY3PQ/7v1U3HqlLkElWV3fmaFbuXvuf39JZsJVRLItrRosW8V/vysJkjcWUFQUu/LvY3/Fu02iWvkG80AIY9Gi3vASAcew9oixKsqqdGSUcLNVQo/FGHyS6BJG9S92g2qLKvEi2xhU8naAToq35dqORLHPrdkL7de2/Cf4xYm6RUQ+Fh9WOxj5OroXTx8XXfctKCOvX8mN9w2H2syK5Cuppvxgl+0u6DiY8IPZ/ugeyd1vnuBW5cORX0NVZ53iS05BJVlcX1h8GXyH2f10ERoN9z29JslroLPhHFw2JwttNS3pxNdvTzlPe1x795kH4YGiohOd7wtPh8HQoPJ8AK/4BS+ailKZT7+KLccSt1jmn1MhoNPHflccAuGpkNG7xY8QnsnaqGFUbndn0QpaQdq827o3zsbpwqSCIG1HdbV5W8idiO/QaCIhVNxbJsUx7DPrOBUM9fHUt1JZ1/Fg1JfD19fDyQPj6Ovj8cqi30jI1klOQ7xq6g5lPiQnrucmw6wP7nrsNTS/O5O3uwsXDxBu5H6xVMqgoMPNJcPEATKA3302qr4DtiyFrByZXL/bF3Ahu3tY5p9Too60Z7M+uwE1j4r4pvSBmlPiEM4xkyflYZ5NJVtdkWSS+O8zLqiqEYyvEftIN6sYiOR6NFi57D4J7i0qGTS907DgmE/x0r5jjZTKKaoiMzaLRijUSrdMnxXptn10OS+9umj/aVRn0KFk7xLV0IjLJ6g58I2D6Y2J/7RNQeMQ+5zXoms7VxnJBgEuTxLotyw/mU6ez0shbr6nwSDY8dAIe2Af/lwHXfC1We0+6Af2dO8gLlN2irO1YQSX/XZEKwCU9jIT4uEOM+TrnJDeVbDoq2b79bN0lyTKZzmjf3oU7C1pYboJ1h5GsfV+K0sjokRA+QO1oJEfk7iPm4AHseEckNO2V/IlYo1PjCresEmWpHv6QtQN+uL1zVUUlabBkHhz6EU6shpTPxZIDP94FtaUdP64jS9+AyyfzmHTsybPXrnNwMsnqLkbcAvETRQOIL64SrWttrSgVDA3g7g+B8W1+2sgegUQHeFJVr2fNkQLrxaN1FRObA+NFLX7f2XD993DJG01rAElW9Y8fDtCgN3Jh7xAmhJv/MIb0ET8T+loocPAFUC0jWT4yyQK6T5JVkgZ1ZaLrXNhAtaOxPctNsIKD9i8ptyejoamaY7gcxZLOo/d00dbdqIPVj7bvuVVFsOIRsT/tUYgbAzEj4LrvQOsOR5fBD3eIrsenT7avZXz1afj4YvHaFNoPLlkM/8/efYe5UZ1vA35GZXvvu/a6916wjanGFUyHQOghhQRiSAjkl4QUShohyZcCJJRQEzC9g7ExYGzce7fX9nq9vfeqOt8fRyNpdyWttCtpVJ77unzNrHY0czyrMu+857xnxjfF7w6sBp46Dyjb7lt7w8GhtwEAzQljEE6TZTHIihYaDXD9f0WA0VIKfPSjwB/TPgnxdJ/eFBqNhCttXQbf3xcFA+wjVFFNO3aXNkOnkfD7q6Y4XgIajfjCAUK/yyAzWb2lDBPLrobIrkSnZLHyZgC6GHXbEgxZ4wF9AmDqEhX3ItWxD8X3X3wGMP16tVtDoW757wFIwPGPgVofisLsfQkwdYoM8cK7HY8Xzgeu+rdYP/w28Na3gCfmAH/MB/44HHh8NnDqc/f7lWVx7dZaLubzvO1DYPYtwDXPAt/9XBRmaasA/neNmHYgUpi6RbdLABXpC1VujG8YZEWThAzg+v+J9aJPPc8b5Q/28VjedxVUXD1bXMx9VVSPpk6jP1tFQaKU4V88KQd5KXG9f6l0GQz5IEsZk8VMJwCRAdbZ/paRXMa9Koq6CgJiHIoyF1iovycHS5aBLY+L9fl3ADEJ6raHQl/OJGDKFWJ9yz+9e47FBOx6Qayfvap/waTp3wBuehOYcxtQMFtktsw9ojBX02ng1euArU+43vfe/4qATxsDXP9y72lxCueJqQgKF4gA75OfhlW3Oo9OrAWMHZBTR6A5cZzarfEJg6xokz8DyJ0GyBbH4N9AsWeyfA+yxucmY9qwFJitsv8KYFDQmC1WvLtXZCG/MXd4/w2U4hehXmGw3dZdlZksQZIcAWckdxmMpqIXiuFniaW/ylaHmtItInjWxgLz7lC7NRQuzr1XLA+95VV2SDqxBmivAhKzgalXud5owgrgiieA738F/LIK+NF+4J69IvCSrcBnvwa2/bv3cxqLgbW26WgW/8ZRrMZZbJLYr0YPnFwHHH3fu/9jqLN1FbROvSasugoCDLKi06TLxNKWfg0Iq8VRvn2QE3neNH8kAODVHWX+mTOLgubrkw1o6DAgIzEGiybm9N9A6S7YXAJ0NgS3cb5gJqs/pctgpAZZFpPjsytaMlmAU9XPCAyyTD3AJ/eL9Vk39Z90mMidYXOAMYvEjemtT3rcVJIt0GyzbTP3dkAXO/D+tTox6XXmWODyx4GLfi0eX/eAyLx2NorPpHfvEN15R1/QuwtiX9kTgfPvE+uf/nxoJehDQXczcPIzAIB16rUqN8Z3DLKi0WRbkFX8JWDsDMwxGk6IlLU+URQ6GIQrZhUgKVaHkoZObCsOQqEO8gtZlvHClhIAwBUzCxCjc/ExE5/ueF2EaulZswHotnWpZSbLISXCJySuOya678SminEP0ULJZNUdBQzt6rbF3774rSjElJgDLP612q2hcHPeT8Ry73893hScXPUmNNX7gJgk4KxBzLkpScAFPwXmf1/8vP43wF/GAn8cJrLrcanAVU8PPGfjefcBmeNECfovHvG9HaHk2EeigFrOVDHva5hhkBWNcqcBaSPFhYSnQZZDUbVPLAtmif7+g5AUq8NVs8UF3as7ImgQZ4T76kQ9vj7ZgBitBt85d7T7DZUPzFAdaK8UvdDGiqCQBKUSZ1uEjslSugoWzIquCaiT84DUQgCy4/M73MmyGN+y/V/i5yufBBKz1G0ThZ/RF4rxU+ZuUdLdBeno+xhf96n44cp/Db5isSSJ8vErHrUNtZDFxMiQRKYrddjA+9DHAZfbxpDtfgEo3Ta4toSCg2+K5fRvqNuOQYqibxCykyRg8uVi/cS6wBxDyU4UzB7SbpQug+uO1KCuvWeoraIAM1us+OMnYm60b50zEiMyPQwuVzJZjSeD0LJBcK4sGGb9wAPK3l0wQjNZ9vFYUdRVUGEflxUBxS9kGfjwHjG+BRBdrCasULdNFJ4kyZHN2vkM0NPW+/d1x6D9+McAAMvCe9yPxfKWRgss/CFw59fA/50GfnwQuL/It/2OOk9UHgREV8NwnD+rrQo4s1msTwu/roIAg6zoNeYisVRewP5mz2QNLciaUpCCOSPSYLbKeGs3C2CEsm6jBT958wBO1nUgLUGPuy8a7/kJSpDVEKpBFsdjuRTpc2UpY5KiqeiFIpLGZRWtAfb9D5C0wCV/tpXjJhqkSZeJLng9rcD/rgY66sTjbdXA6zdDMnWiPmkKrIt+5d/jJmYC6SN7VxL01opHgfTRouT7B3eHX7XBw+8CkIHCs8U5CEMMsqLViAXiy6elFGgp9+++zUag5pBYH2KQBQC3nC3eXKt3lMFiDbMPiShR1dKN657Zio8OVEGnkfC7K6chNUHv+UmZtlKsIRtkcY4sl5QgKxJLuHfUA/UiE4sR56jbFjXYq37uCL8LMmdmI/DZb8T6uT8GFvyA2WgaGo0WuOopIC4NqNwN/Gs+sPoG4Im5QFMx5JRh2D3qh4BGp3ZLHeJSgG+8IKoNHv84cMNDAkGWgYNviPUZ16nbliFgkBWtYpPFRHmAKG3rT/XHRB/iuFQxOd4QrZyej7QEPSpburHpRL0fGkj+tPtME654cjMOV7YhIzEGr3xvAS6fWTDwE7Nsma7OutDsymDPZDHI6iVZCbJqAItZ3bb425mvxTJ3mriDHG3yZ4lJibsaRaGIcLX7eaCpWJTRVrp5EQ1V4Xzge1+IG4TdzcCJT0WBr+HzYL7hTRj1KWq3sL9hc4B53xPre19Wty2+KN0q5lrVxQFTrla7NYPGICuajTpPLP3dZdB5PJYf7h7G6bX4xhwx19J/t50Z8v7If7acasDNz+1AQ4cRk/NT8MGqc3H2GC8vTmOTHRfsDacC18jB6uAcWS4l5YgsuGwRAXIkKdkklqMvULcdatHFiAtJIHBdyQOtah/w+cNi/aJfibv5RP6SNQ64axvw7U+BpY8AN6wGvrtelE4PVXNuE8uiTx3dHEPdVtvE4bNuCusbXgyyopkSZPk7k2Ufj+W/MQ23nD0SkgRsKKpHUU2ElRcOU1uLG/Cdl3bBYLbioonZeOeuhSjM8FDowpUsW5fBUCx+wTFZrmm0kTshcbQHWQAwMkA334KhtQJ47SZROXf8csfFJZE/6WKAkecA590LTLo09Lui5k4Bhp0FWM3AgdfUbs3A6ouAE2sBSMDZq9RuzZAwyIpmI84GJA3QdNq/5Zir/FNZ0NmorERcMk1kFJ7ddNpv+6XBOV7Thh/8dw8MZisWT8rB07fORULMIPqi24tfhGAZd47Jci8lAoOs1krRxUzSiAuoaDXqXLEs3RI+47KsVuDr/wc8OR9orxKfK9c+N+jpQ4gizpxbxXLv/8T7JZRt/7dYTrrUcSM2TDHIimZxqUDedLGu3MEdKlO3mMwT8Ht1rh9cICYG/WB/Japbu/26b/JebVsPvv3iLrQbzFgwOgNP3TIHsbpBXsyEcoVBZrLci8QKg8p4rILZ4rMxWg2bK8ZBdNaH5vvSlR1PiQmHbeNjcNOb0f03JOpr2rVATLLoNXL4bbVb456hAzhka9+CO9Vtix8wyIp245aKZdEa/+yv5rBISSdmO+bT8ZOZhWk4e0wGzFYZb+zyc0VE8orRbMUPX92L6tYejM1OxLO3njX4AAsI3QqDxi5RqhdgJssV+1xZETStgnKjadT56rZDbbpYR5VBJfAMZR31wFePifWlD4vxMRkeJkEnikaxycD5tiIwX/xW3BAPRUffB4wdomiaMqQljDHIinYTLxXLU18AZsPQ9+c8HisA/ZSvmCku7rYVN/p93zSwP645hj2lzUiO0+H5b80buEz7QJRMVtPp0KpU12HrKqhPAGI5cL6fVFGIBq0REmTJMsdjOQvUeN1A2PB7wNAqquWe86PQHx9DpJazfyhukLWWA5v/rnZrXNv7P7GcfUtEvJcZZEW7gtlAUh5gbPfPXUtlPFaAJvJcMCYDALCvvAU9JktAjkGu7TrThJe2ngEA/P36WRiVlTj0naYMA3TxgNUEtJYNfX/+4jweKwI+6P0utVAs/T3HnlqaS8SFh0YvxqpGu5G2cVlnQnxcVt0xYO9/xfrFf+IYLCJP9PHAkofE+sbHgE/uF3PKhYqGk0D5djEuduZNarfGLxhkRTuNBph4sVg/7ocug5X+L3rhbExWIrKTY2E0W7G/vCUgxyDXnvqqGADwzbMKsXTKIGafd0WjcXTtaQqhgiYcj+VZmi3Iao2QIEvJYg2fB8T44eZBuBt+FqCNERndUHpf9vXF7wDZCky+PLqLlRB5a8b1wKIHAEjArueANT9Vu0UO+2xZrHHLHMWVwlzYBFlNTU24+eabkZKSgrS0NHz3u99FR0eHx+csWrQIkiT1+nfnneE/kM7vlC6DRZ8O7a6lod1RJS5AQZYkSVgwWmSzdpxuCsgxqL+imnZ8ebwOkgTcuWisf3euTFjdVOLf/Q6FkslK8lMwGWlSR4hlRy1g6lG3Lf5QYsvis6ugoI8XJZ+B0B2XVb4LKPpE3PVe/Bu1W0MUHiQJWPQL4JuviJ/3viyGi6jNYgL228rLK5UQI0DYBFk333wzjhw5gvXr1+Pjjz/Gpk2b8P3vf3/A591xxx2orq62//vzn/8chNaGmdEXAPpEUfq2ev/g91N9AIAMpAwXE5YGiDLZ7fbTHJcVLM9sElmsS6blYbQ/ugk6UzJZjcX+3e9Q2LsLRsbdNL9LyBDdPAGgrVLdtgwVx2O5Zp+sPgTHZcky8MUjYn3WTaE9ESxRKJp8GTD/B2L9wx8BPW3qtufkZ2Jy+8RsYMLF6rbFj8IiyDp27BjWrl2L5557DgsWLMB5552HJ554Aq+//jqqqjyXEE5ISEBeXp79X0oKB7H3o48Dxi0W60PpMli2TSyHnzX0Nnlwtm1c1t6yZhjMHJcVaFUt3fhwv3ifKWX0/cqeyQqhbkmcI8szSYqcLoP1ReLLXRcX8M+usBLK82UVfykybNoY4MJfqN0aovC09CEgfZSoErvrOXXbohS8mHkDoB1iQa0QMojZQ4Nv27ZtSEtLw1lnOb4Aly5dCo1Ggx07duDqq692+9xXX30Vr7zyCvLy8nD55ZfjN7/5DRISEtxubzAYYDA4quy1tYno3mQywWQy+eF/4zvluIE8vjTuYuiOfQT5+Ccwn/+zQe1DW7IZGgCWwoWwBrCtI9JikZkYg8ZOI/aeacRZI9OHvM9gnONw9Z9NxTBbZZw9Oh1T8hIHdY48nV8pdSR0AOTGUzCHyPnXtlVBA8CckA05RNrkiRqvX23KcGgaTsDceAZyYeifI3c0pzZAC8BauAAWWQO4OYdR9xmRNxs6jR5SWyVM9afExVgAeX1+ZSt0nz8MCYBl7ndgTcxz+zcjh6h7/QZZWJ5fKQbSeT+F7qO7Ie/8D8zz7lQnwOmohe7kZ5AAmKbfFBafwd62ISyCrJqaGuTk9O5+ptPpkJGRgZqaGrfPu+mmmzBy5EgUFBTg4MGD+PnPf46ioiK8++67bp/z6KOP4pFHHun3+GeffeYxOAuG9evXB2zfejNwMTTQ1B3BV++9jK7YbJ+eL8lmrCzdBg2AjaVmtNf5ad4tN4bFatDYqcHr67ejrsB/d1kDeY5DmSwDX9dIaDVJGJciY3yKDJ0G6DIDr+7RApAwK7YBa9YM7e/q6vzGGxuwHIDcfAaffvIRZEn9CmGLa4qRDGD7kVI0lgX2texPwXz9zmyVMQrAqT0bUFQ19Bsdapl3+m0UADjek4OTXry+o+kz4rz4UcjsPImjHz2JM1mLg3LMgc5vQfNOzKs5CLMmDuu7psE4xM+kaBNNr181hNv51VjjsUyXgrj2Kux//XeoSg9+ddWRDRswS7agOWEMNu08CcDzvJmhcI67urq82k7VIOsXv/gFHnvsMY/bHDt2bND7dx6zNX36dOTn52PJkiUoLi7G2LGuuz098MADuO++++w/t7W1obCwEMuXL1etq6HJZML69euxbNky6PUBvMvQ+ipQthWLhxtgnbfSp6dKlXuh22+AHJ+O86+5QwxGDqDypBIcXH8SPYn5WLly1pD3F7RzHKKe3FCMd86IMVGfVwIFqXG468Ix2H66CUZrDSblJuG+mxZCGmQ5c4/nV7ZCPv4ANBYDLjl3BpA2cqj/naGRZeiO3AUAWLD0CiBzvLrt8YIar1/NliLgqw2YkBOHsSt9+7wIGbIVur/9CAAwYcX3MH7YXLebRuNnhCb9FPDlbzFdW4wpK/8a0GN5dX5lGbrn/wIAkM69B0svuCGgbYok0fj6DaZwPr+alCLg6z9jrmknZq38bdCPr31DFOFImXcDVp7n/rsklM6x0sttIKoGWffffz9uv/12j9uMGTMGeXl5qKur6/W42WxGU1MT8vK8HzOxYMECAMCpU6fcBlmxsbGIjY3t97her1f9jxrwNky6FCjbCu2JT6E9Z5Vvz63cDgCQRpwDfUz/8+dvZ43OBHASByvb/HpOQuHvHGxv76nAP78UAdbiSTk4WNGKqtYe/ObDo/ZtVi0ej5iYmCEfy+35zRgN1B+HvrUUyB435OMMSXcLYOwEAOgzRgFh9HoI6us3XQTDmrZKaMLoHPVSfQDoaQFikqErPAvQDvyVGFWfEdOvBb78LTSlW6AxNAe0oJHC4/k9swWoPQTo4qFd+ENoo+Xv4EdR9fpVQVie3wV3AFv/AU3lbmiqdgMjFwbv2MYu4IwoPKSdfKlX7+lQOMfeHl/VICs7OxvZ2QN3S1u4cCFaWlqwZ88ezJ0r7jR++eWXsFqt9sDJG/v37wcA5OezYphLky8DPvsVcGazKKetVH3zRulWsQzSXCXTh6VCIwHVrT2oae1BXmpcUI4baXpMFvz+ExFMrbpoLP5vxSR0Gy34z9en8cnBaozPTcIVMwuwfGqAC0BkjAHqj9uKXywJ7LEG0lohlgmZQIy6XYRDWiQUvlCqCo4616sAK+qkjwIK5ohJ5o99CMz7nrrt2fGUWM78pqhwSURDl5QjCk7s/S+w+W/AyLeCd+zTXwHmHjEtSO7U4B03SMKiuuDkyZNx8cUX44477sDOnTuxZcsW3H333bjhhhtQUFAAAKisrMSkSZOwc+dOAEBxcTF+97vfYc+ePThz5gw+/PBD3HbbbbjgggswY8YMNf87oSt9FDB2CQAZ2P2C98+zmB2VBYMUZCXG6jAhNxkAsL+8OSjHjEQfHahCS5cJw9Licd8yUQY5PkaLHy0Zj3U/uQBP3jQn8AEWEFoVBpUgK3W4uu0IdalKkFUJWK3qtmWwOD/WwKbaCksdeV/VZqC5FDj+iVhfcJe6bSGKNOfeK4Z5nPwMqDkUvOOe+FQsJ14sqtZGmLAIsgBRJXDSpElYsmQJVq5cifPOOw/PPvus/fcmkwlFRUX2wWgxMTH4/PPPsXz5ckyaNAn3338/rr32Wnz00Udq/RfCg3Knct//AFO3d8859iHQ0yru/OcFL4CdPUIMtt9X3hK0Y0aa/20vBQDcfPYIaDUqfsApWdOQCLJsmRkliCDXkvMBSQtYTUCH+wJEIctidmTgR52vbltC2dSrxPLMZqClTL12bPknIFuBMRcBOZPUawdRJMocC0y5Sqxv/ntwjmkxA0VrxfrES4JzzCALm/4RGRkZWL16tdvfjxo1CrLTXB6FhYXYuHFjMJoWWSasEGnb1jLg8DvA7Fs8by/LwNYnxPq8O4La5WZ2YRpe21mGfWUtQTtmJNlf3oKDFa2I0WrwzbNUDigybeOwGk6o2w6AmSxvaXVAyjDxWdFSDqQUqN0i39QeAoztQFwakDtN7daErrQRItNXsgnY9m/gkj8Fvw2tFaIrEwBc8NPgH58oGpz3E+DIu8CR94CLfiUCr0BSJiBOyAJGnhfYY6kkbDJZFCQaLTDvO2L9yz+IIgCelG4V/fV1ccD8OwLePGezR6QBAA5VtMJsCdPuSipavUNksS6dkY/MpMAXK/Eox9YXu6kEMLSr2xYGWd5TzlE4jssq3yWWw+cBGn4VenTuvWK592Wgqyn4x//6/4mM6ajzgVGReTFGpLr8GcC4ZSJjvPXxwB9v78tiOetGQDf0wlqhiN8s1N/874sxMu1VwNoHPG+rpJVn3QQkZgW+bU7GZichXq9Ft8mCM43ezVlAQrfRgjWHRBevG+aFQLe4pGwgKQ+ADNQeHXDzgLIHWSFwXkJdOBe/qHAKssizsYtFV3BTF7Dz2YG396eWcmDv/8T6ol8E99hE0eZ82xRG+1cDbdWBO05rpchkAcCcbwXuOCpjkEX9xSQCVz0tBkEeWA289W2gcm//7U5/BZxaL8ZlLLw76M3UaCRMzBPFL47XeDdnAQnrjtSgw2BGYUY85o0KkSpdedPFsjaIg25dYZDlPeUctYRzkHWWuu0IB5IEnHevWN/xjH2Kg6DY/DdmsYiCZeQ5QOHZgMUIbP9X4I6z/1WRMRt5LpAV+nNRDhaDLHJtxALgQttdwyPvAv9ZDGz8i6OKmNUCrPuVWJ/3vcD33XVjcr4Iso5VM8jyxTt7RSBxzezh0KhZ8MJZnm1cTM1h9dpgMYsMLsDugt4I10xWRz3QXCLWPUxATE4mXykq0HY3AfteCc4xW8qcslgD9KogIv9Qslm7XghM92CrxTHGMoKzWACDLPJk0c+BH2wCpl4DQAY2/B7431VA8ZfAxz8Bag+LQeMqduGYnJ8CADherfI4njBS3dqNzacaAADXzgmhQELJZAWzfGxf7dXi7po2BkgceA6/qBeumazK3WKZNRGIT1O1KWFDqwPOuUesb30SsJgCf8yvbVms0ReIucyIKPDGLxfFgEydwM7/+H//xRvEjbm4VGDKFf7ffwhhkEWe5c8ErnsRuPJfgDYWKNkI/O9qx4DFJb9RdVLISXm2IKuGQZa33ttXCVkG5o1Kx4jMEJpsN9cWZNUdFXe61KBkZFKGsRiCN1KdMllO1V1DntJVsJDjsXwy62Zx86G1DDj8bmCP1dMmxoUAjl4VRBR4kiQqDQLAjqf93z1470tiOeMGQB/v332HGF5FkHdm3wL8cJv4ktXFAQVzgJvfccyrpRJlTFZlSzdau4JwZzXMybKMd/aIroIhlcUCRJdTXbwYXK/WfFmsLOgb5TwZO4CeFlWb4pNyMWk9i174SB8PLLhTrG97IrCB9fGPAYsByJoQtEnuichmylWO7sG7nvfffjvqgCLbBMRzI7urIMAgi3yRORa46t/Ar2uB728Axi9Vu0VIjddjWJq4E8LiFwM7UNGK4vpOxOo0WDkjX+3m9KbRArlTxLpaXQY5EbFvYhLEHCdA+HQZlGWg+oBY53gs3531HXEzpOaQmKA4UA69LZbTviHurBNR8Gh1wAX/J9Y3/11klv1hxzOA1QwMOwvIneqffYYwBlkU9pTiF+wyODAli7Viah5S4vQqt8YFZVJY1YIsZrJ8Fm7FL1rKAEMboNGLMVnkm4QMMa8NAGx/KjDH6KgX1WsBYPo3AnMMIvJsxg0ik9zdBGzzQ6XBxmLH/Fvn/mjo+wsDDLIo7Cnjslhh0DOj2YqPDorKedfODdEgomCWWFa5mDIgGJRsDIMs74Vb8YvaI2KZPTFiJ8AMuAV3iWXRGnHh5G9H3wdkC1AwW7XKtURRT6sDLrJVkd725NAy17IMrPk/URp+7BJgcmQXvFAwyKKwN4ll3L2y5VQDWrpMyE6OxXnjgjtxtNeUMTIVe9QpftF4SiwzxgT/2OEqNcwyWbW2KQKUrCn5LnsCMG4ZABnY+Gf/7luWgX22su3TmMUiUtXkK4AR54hxty9fMfiM1tEPgOIvRAG1lX+Jmi7ADLIo7E0rSAUAHKtuh9FsVbk1oWvt4RoAwMVT86ANlbmx+sqeDOgTAWM70HAiuMc2G4GWUrEewZMj+l24dRe0B1mRPx4goC76pVgefB2o2u+33UplW8WYOV08MPNGv+2XiAZBowFueUd0HZQtwLpfAp8/7FvRG0M7sNY2z915P4mq7DSDLAp7IzMTkBKng9FixYlajstyxWyx4rOjtiBrWp7KrfFAqwOGzRHrSpntYGkuEXNkxSQDSbnBPXY4C9fuggyyhmbYHGD69WJ93S8BU7dfdqvZ+bRYmXkDkJjpl30S0RDEJABXPw0sfUT8vPnvwPrfeP/8jY8B7VWiWuF59waihSGLQRaFPUmSMGN4GgDgYEWruo0JUTvPNKG5y4T0BD0WjFZvXjOvKBXfKnYH97gNJ8Uyc2zUdGXwi3DKZBk7HWOIlMmvafCW/EZ0/yndAvx9mug62NU06N0l9lRDOrFW/HD2D/3USCIaMkkSAdJl/xA/b30C2PPywM87s9nRxXDlXyN+Xqy+GGRRRJgxXHQZPFjRom5DQtQ6W1fBZVNyodOG+NvePi4ryEFWoy3IYldB3yiZrM56v2UzAqbuOABZTKiblKN2a8Jf2gjgGy+IZVcDsOEPIth64xZg65NAZ6P3+2qvwYLT/4AEGRi/XIz7IqLQcta3HcUwPrlPBFumHtfbdtQBb39H9BCZeRMwflnw2hkidGo3gMgfHEEWM1l9dRnN+PhgNYAQ7yqoGH6WWNYdFX25Y5ODc9wGW9GLTAZZPolPB2JTRFn05lIgZ5LaLXKP47H8b/JlwISLRUXAzf8Aag8Bxz4S/zY+Boy5ECjZBEhasW3udCAxCxi3FIgTlWFRsRu6d+9AsqEacsowSJf4uZgGEfnPBf8nxkwfegv47NfApr+IYlHD5op59HKnAvVFIsDqqBVjrS/9q9qtVgWDLIoI023dBYtq29FjsiBOr1W3QSHk5a2laOw0YkRGAs4fn612cwaWnAekjgBay4DKPcCYRcE5rlJZMGtccI4XKSRJ9LWvOSjGtYVFkMXKgn6l1Yn5rKZdK8ZSlm4VkwkrAZdi738d63FpYvu2KuDEWkiQ0RWTBf2tH0KfMTro/wUi8pIkAVc/A4y+EPjqUaCtEqjaJ/7tek7cdDN1A1aTmKz++peBmES1W60KBlkUEQpS45CVFIOGDiOOVrdhzoh0tZsUEtp6THh6oxiDcu/S8dCHeldBReF8EWSVbgtikKWMyWKQ5bOM0SLIajqtdks8sxe9YJAVEJIk3ruF84FzfgQcfU/c0R59objgKvpUBFW1h8VrZffz9qdaZ9yAjdbzsDRtpIr/ASLyikYLzLkVmPFNoKEIaCoBDr8NHPtY9GoAgDEXiYIZyWHQgyZAGGRRRJAkCdOHpWJDUT0OlrcwyLJ5btNptHabMC4nCVfOGqZ2c7w36jzxgT2UyQ990dUEdNnGjzDI8l26LfPQVKJuOzyRZUcmK49BVsBpNCJT5Uy5YWK1iO6FFbvFmL6RC2HJngbjmjXBbiURDYUuRhQRypsOTLkC6GkTY7FkC5A1IeqLSDHIoogxszANG4rqsau0Gbefy+4m5U1deGaTyCzcv2xC6M6N5cqo88WyYqfodhDoikRKV8GUYVHbrWFIlO5dzSEcZLVVAj2tgEYnvvxJPRqtCMCcgzCTSb32EJF/xKU4xloSqwtS5DhnbBYAYFtxI6xWHybKi1B/+OQYDGYrFo7JDI+CF84yxwLJ+YDFGJz5spQgi1mswckYI5ahnMmqsWWxsiYAulh120JERBGPQRZFjFmFaUiI0aKp04hjNW1qN0dVm082YO2RGmg1Eh6+YiqkcEvZS5LoMggAJV8H/ngNLN8+JEp3wZYy0RUsFLHoBRERBRGDLIoYMTqNfaLdLacaVG6NekwWKx7+SAzwv/XskZiYF6QS6P6mdBkMxrgsFr0YmpQCQBsjihu0VqjdGtfsRS9Yvp2IiAKPQRZFlHPHiS6Dm0/5MAlmhHl56xmcqutAZmIMfrIsjMeeKJmsil2AsSuwx+IcWUOj0QJKVbhQHZfFTBYREQURgyyKKMo8UDtLGmEwh2i3pQDacqoB//hcZGV+dvFEpMbrVW7REGSMEeOyrCYx/0agWC2O0uOcI2vwMkK4wqCp2zHujpUFiYgoCBhkUUSZkJuErKRY9Jis2FvaonZzguqZjcW45fkd6DCYMX9UBq6bW6h2k4ZGmXMHAMp3BO44reWAxQBoY0U5aRocexn3EJwrq/44IFuBhEwgKVft1hARURRgkEURRZIknDcuE0B0jcsqb+rCY2uPQ5aBG+ePwH+/Ox+acCrZ7s5wW5AVyAqD9q6CY0W3NxqcUC7jrlQWzJ0a9fO2EBFRcDDIoojjGJcVPUHWK9tLYZWBc8dl4tFrpiNOHyHBQuECsSzfISaTDQR70Yuxgdl/tAjlCYkr94hl/ixVm0FERNGDQRZFHCXIOljRgtbuyJ/gsstoxms7ywAA3z4nwiZhzp8huvF1NQauG5pSvp1FL4ZGKX/feAqwWtVtS18Vu8Vy+Dx120FERFGDQRZFnIK0eIzJToRVBrafjvwqg+/vq0JbjxkjMhJw0aQctZvjX7pYoGCWWC/fGZhjNHKOLL9IGynKuJt7xDi3UGHoAOps5dsZZBERUZAwyKKIdJ4tmxUN47Le2yfmJbpt4UhoI2EcVl+BLn7RWCyWzGQNjVYHZNi6XDacULctzqr3i6IXKcOAlHy1W0NERFGCQRZFpGgZl9VlNGNfWQsAYPmUPHUbEyj2cVkByGQZO4G2SrHOMVlDl22bly2UgiylaMrws9RtBxERRRUGWRSRzh6TCa1Gwun6Tpxp6FS7OQGz60wzzFYZw9PjMSIzQe3mBIZSYbDuKNDT5t99K3MnJWQCCRn+3Xc0yrIFWfVF6rbDmTIeaxiDLCIiCh4GWRSRUuP19i6D7+6tULk1gbPVlqk7Z2ymyi0JoORcMd4HMlC527/7VoIBJTigocmaKJZKMRG1yTKLXhARkSoYZFHEunbucADAO3srYbUGqPy3yrYWi8Ie54zNUrklARaoLoN1R8UyZ4p/9xutlOIhDSGSyWqrBDpqAEkL5M9UuzVERBRFGGRRxFo+JRfJsTpUtnRj55kmtZvjd61dJhyuagUALIzkTBbgVPzCz0FWrS3IymWQ5RdKkNXVCHSGQGXPsu1imTcdiInQ7rRERBSSGGRRxIrTa3HpDFFN7J09kddlcHtJI2QZGJudiNyUOLWbE1hKkFWxy79zMNUdE0tmsvwjJhFILRTroVD8QgmyRixUtx1ERBR1GGRRRPuGrcvgRwer0NhhULk1/vXJwWoAwPnjs1VuSRDkTAX0iYChDag/7p999rQBrWW2/U/2zz7JMb4tFIKsciXIOlvddhARUdRhkEURbe7IdMwYnooekxUvbz2jdnP8pqnTiLWHawAA184ZrnJrgkCrA4bNEesVfuoyqARryQVAfLp/9kmhE2T1tAK1tkmIGWQREVGQMciiiCZJEu68UMx/9PK2UnQazCq3yD/e2VMBo8WK6cNSMX14qtrNCQ6l+EXpNv/sz170glksv8q2VRj0V8ZxsCp2iUmI00cByRE6hxwREYWssAmy/vCHP+Ccc85BQkIC0tLSvHqOLMt48MEHkZ+fj/j4eCxduhQnT4ZIaWEKmhVT8zA6KxGt3Sa8vqtc7eYMmSzLeG2n6OZ24/wRKrcmiMYsEstT6wGrZej7s4/HYpDlV8r4NuX8qqVsh1hyPBYREakgbIIso9GI6667DnfddZfXz/nzn/+Mxx9/HE8//TR27NiBxMRErFixAj09PQFsKYUarUbCd84dBQB4b194F8Awmq341fuHcbqhE4kxWlwxq0DtJgXPiLOBuFRRua5i19D3x/LtgaFkstoqRZc9tZTZMp5KBpSIiCiIwibIeuSRR/CTn/wE06dP92p7WZbxj3/8A7/+9a9x5ZVXYsaMGfjvf/+LqqoqvP/++4FtLIWcldPzoZGAw5VtKGvsUrs5PpFlGf/vsyIsfPQLzPvD51i9owySBDywcjKSYnVqNy94tHpg/HKxXvTp0PfH8u2BEZ8mxrkBQJ1KXQZNPY5JiJnJIiIiFUTsFVpJSQlqamqwdOlS+2OpqalYsGABtm3bhhtuuMHl8wwGAwwGRxW6trY2AIDJZILJZApso91QjqvW8SNBSqwG80elY3tJMz45WInvnTeq1+9D9RxbrTIe/OgY3tjtyMAlxmrxt+tmYPHE7JBrrzv+Or/S2GXQHXoLctEamBf9evA76qyHvqsBMiSY08YAYXIe3Qm11682exI07VUw1xyGnD8n6MeXijdCZ+6GnJzvt79vqJ3jSMPzG1g8v4HF8xt4oXSOvW1DxAZZNTWi8lpubm6vx3Nzc+2/c+XRRx/FI4880u/xzz77DAkJ6k5muX79elWPH+6GQwKgxRtbilDQdtTlNqF2jt8/o8GGag0kyLh2tBVjkmVkxprRU7wLa4rVbp3vhnp+dWYLLoEWmoYT2Pjei+iMzR34SS5ktR/FuQA6Y3PwxfqvhtSmUBIqr9+p7TEYB6B011ocrs4K+vGnVbyCsQBKYybgwKd+yHo6CZVzHKl4fgOL5zeweH4DLxTOcVeXdz2iVA2yfvGLX+Cxxx7zuM2xY8cwadKkILUIeOCBB3DffffZf25ra0NhYSGWL1+OlJSUoLXDmclkwvr167Fs2TLo9XpV2hAJ5rb14O2/bMKZDgmzz12M/FTHBL6heI4/OVSDDdsOAgD+cu10XBnG46/8en7bVwNnvsZFw02wzls5qF1odlUAp4CEUWdh5crB7SOUhNrrV9rfDHyyFqMTezBChfOre0rcKBu+6NsYNsk/xw+1cxxpeH4Di+c3sHh+Ay+UzrHSy20gqgZZ999/P26//XaP24wZM2ZQ+87LEyV7a2trkZ+fb3+8trYWs2bNcvu82NhYxMbG9ntcr9er/kcNhTaEs+GZeswdmY49pc346mQjbls4qt82oXKOd59pwi/fF3P83HnhWHxj3kiVW+Qffjm/YxcDZ76GtmwrtOesGtw+GsRYIU3uVGhC4O/tL6Hy+kW+GDurqT8e/PPbdBpoKgY0OujGLwH8fPyQOccRiuc3sHh+A4vnN/BC4Rx7e3xVg6zs7GxkZ2cHZN+jR49GXl4evvjiC3tQ1dbWhh07dvhUoZAiy9LJuSLIKqp3GWSFgk8OVuMnb+6H0WzFueMy8dPlE9RuUmgZfYFYnvlalHLXaH3fB8u3B5ZSYbCzDuhsBBIzg3fsk5+LZeHZQJw6vQ+IiIjCprpgWVkZ9u/fj7KyMlgsFuzfvx/79+9HR0eHfZtJkybhvffeAyAmob333nvx+9//Hh9++CEOHTqE2267DQUFBbjqqqtU+l+Q2hZNFEH91uIG9Jj8MNfSENW29aC9xwRZlnG6vgP3vLYPq1bvhdFsxdLJOXjutnnQacPmbRoc+bOAmGRRHrzmkO/Pl2VHkJU71a9NI5vYJCDNNodbfZDnyypaI5bjl3rejoiIKIDCpvDFgw8+iJdfftn+8+zZswEAGzZswKJFiwAARUVFaG11zMvys5/9DJ2dnfj+97+PlpYWnHfeeVi7di3i4uJA0WlSXjLyUuJQ09aDHSVNuHBCYDKpA6lr68FvPz6Kjw9WAwDSE/Ro7hLVajQScMf5Y/B/KyYywHJFqwNGngOcXCeyWQWzfHt+Sxlg7AC0MUDG4LojkxdypohzXXsUGHVecI7ZWgGc/kqsT7kyOMckIiJyIWyu4F566SXIstzvnxJgAWI+IecxXpIk4be//S1qamrQ09ODzz//HBMmsOtVNJMkyR5YfVVUp0obmjuNuPSJzfYACwCau0zQayWcNy4LH959Hh5YOZkBlidKl8GSTb4/V8liZU0Qc29RYChZwtrDwTvmgdcAyMDIcxlAExGRqsImk0XkLxdNysYbu8vxVVE9Hro8+Md/Y3c56tsNKMyIx1M3z0V+ahwqmrsxITcZ8TGDGF8UjUafL5al2wCLWWS3vFVnK9/P8ViBZQ+yjgTneLIM7F8t1mfdHJxjEhERucFb5RR1zh2XBZ1GQklDJ07Xdwz8BD+yWGW8sr0UAHDPReMxbVgqMpNiMbMwjQGWL3KnA3FpgLEdqN7v23PtRS+m+LtV5CxXVBhE3VFRoCTQyraJyoIxSewqSEREqmOQRVEnOU6PhWNFtbNPD7ufmDoQviqqQ0VzN1Lj9bh8ZvjOe6U6jcYxzqdko2/PrT4glgyyAitjDKCLA0xdQPOZwB/v4JtiOeUqUXiDiIhIRQyyKCpdNkPMnfbRgaqgHve/20QW65vzCpm5Gir7uKyvvX9OVxPQUCTWC+f7v03koNUB2baJ5AM9LstiBo59JNanXxvYYxEREXmBQRZFpRVT86DTSDhe045TdcHpMljd2o1NJ+sBADcvGBGUY0a0UbZxWWXbAbPBu+eUbRPL7ElAQkZg2kUOedPEsibAQVbpZqCrAYjPAEZdENhjEREReYFBFkWltIQYnDc+C4CY/DcYPthfBVkG5o/KwMjMxKAcM6LlTAYSsgBzN1C5x7vnKEHWiLMD1y5yyLUFWYEufnFEzI+IKVf4VgSFiIgoQBhkUdS6dLqty+DBKsiyHNBjybKMd/dWAACunjMsoMeKGpLkqDLobZfBUiXIWhiYNlFv9iBrEJNGe8tiBo5+KNanXh244xAREfmAQRZFreVT8xCn1+BUXQf2lLUE9FhHqtpworYDMToNVtqCO/IDpcugN/NlGbsclQgZZAWHUsa9pQzoafW87WCVbgG6m4CETGBkkCY9JiIiGgCDLIpaqfF6XDlTZJVe2VEe0GO9t68SALBsci5S4zkBrt+MvlAsK3YCpm7P21buBqxmILkASOOYuKBIyABSC8W6UtXR3059Lpbjl7OrIBERhQwGWRTVbl04EgDw2dFatBkDcwxZlrHWVir+ilks2+5XmWOB5HzAYgTKd3rettRpPJYkBb5tJAybK5YVuwOz/+IvxXLsksDsn4iIaBAYZFFUmzYsFbNHpMFkkbG1NjAX3seq21HZ0o04vQYXjM8OyDGiliQ5lXIfoMugkvFQxnFRcChBlrfFSXzRXmMrDy8BYy/y//6JiIgGiUEWRb3bzxkFAPiiSoOqlgG6nA3C+qO1AIDzxmVzbqxAUMZlnfFQ/KKzEajYJdbHLw98m8hh+FliGYggS8liFcwCErP8v38iIqJBYpBFUe/yGQWYOyINRquEhz8+5vdKg+uPia6Cy6fk+nW/ZKNkpir3AAY3c56d+hyALKrdpQ4PWtMIQP5MQNIC7dVAm58n/z71hViyqyAREYUYBlkU9TQaCb+7cgq0kowNRQ34zJZ58oeqlm4crmyDJAGLJ+f4bb/kJH2UKGRhNYuJiV05+ZlYMosVfDGJQM4Use7PcVlWiyOTNY5BFhERhRYGWUQAxuck4aJ8kcF6/IuTfstmfXRA3LmfOyIdWUmxftknuTBKGZe1sf/vLGbHeKwJK4LXJnIYHoBxWdX7Ren2mGRg+Dz/7ZeIiMgPGGQR2SwusCIhRosjVW3YeKJ+yPvrMVnw3OYSAMB1Z7GLWkCNWSSWxz8G+gbIZ74GelqAuDRg2FlBbhgBcJx3fwZZp2xZrDEXAlpOi0BERKGFQRaRTaIeuMEWDP17Q/GQ9/fWngrUtxtQkBqHq2czyAqoSSuBmCSg6TRQts3xuNUKfP6wWJ92LedRUouSaarYDZh6/LPPYmU81mL/7I+IiMiPGGQROfnOuSMRo9Vg55kmvLl78BMUmyxWPLNRBGrfv2AMYnR8qwVUTCIw7Rqxvu8Vx+MHXhPdymJTgEW/UKVpBCB7IpCUB5i7gfIdQ99fT6tjXjSOxyIiohDEKz8iJ7kpcfjhRWMBAL967xC2n24c1H5e3noGFc3dyEqKwQ3zR/izieTOrFvE8sh7gKEdqDsGfP6QeOyC/wOSWHhENZLk6NJ5esPQ91eyCZAtQMZYUfiEiIgoxDDIIurjR4vH49IZ+TBZZNz5yh6UN3X59Py6th784/OTAID/WzERcXrOjRUUhfOBzPGAqQt4fjnw/Aqgsx7ImQosuFPt1pEyWXCxH4IspXQ7s1hERBSiGGQR9aHRSPh/183EzOGpaOky4a5X96DHZPH6+X9ccwwdBjNmFabhurmFAWwp9SJJwNKHAW0MUHcUMLQCIxYCt38M6GLUbh0pmazqA0BX0+D3Y7UCJ9aK9XFLh9wsIiKiQGCQReRCnF6Lf98yF+kJehyubMMPX92Lpk7jgM8rru/A+/urIEnAb6+cCo1GCkJryW7yZcD9RcBlfweWPAjc+j6QkKF2qwgAkvNs82XJwOmvBr+fip1iYuPYFEfgRkREFGIYZBG5MSwtHk/cOAd6rYQvj9dhxT824ZOD1R7n0Hrua1GyfcmkXMwYnhakllIvCRnAWd8Bzr8f0Mep3RpyNsbWZVCZHHowjrwvlhMvAXSce46IiEITgywiD84bn4X3fnguxmYnor7dgFWr9+KGZ7ejocPQb9uGDgPe3VsBQFQUJKI+plwhlkfeG1yXQasVOPahbV9X+q9dREREfsYgi2gA04al4pMfnY8fLxmPOL0GO0qacNvzO9Habeq13UtbzsBgtmLm8FTMG5WuUmuJQljhAiB3OmDu6V1q3xOr1bFeuRtoqwRikoGxLHpBREShi0EWkRfi9Fr8ZNkEfPKj85GVFIuj1W244snNePjDI9hxuhFbTjXgKdu8WD+4cCwkiWOxiPqRJGD+HWJ99/OAdYCCMl1NwFPnAI/PAQ68Dnx4j3h84sXsCkpERCGNQRaRD8ZmJ+F/352PtAQ9Shu78NLWM/jms9vxrRd2wmKVcc2cYbhkWp7azSQKXdOvA+JSgeYzotugO7IMfPRjoP4Y0FQMvPcDoP44kJwPXPjzoDWXiIhoMBhkEflocn4Kvrx/ER6/cTauP2s4YrQamK0yZg5PxR+vns4sFpEnMQnA/B+I9Y9/AjQWu95u/6ti/JVGB8y8CYAEFMwG7vgSyBoftOYSERENhk7tBhCFo4zEGFwxswBXzCzA/csnYmNRPVZMzePEw0TeuPBnwJmvgbJtwBu3At9ZC8SlOH7fUQes/aVYv+hXwPn3ASv+AMSlARreGyQiotDHbyuiIcpNicP18wqRmqBXuylE4UGrB657CUjMAeqOAKu/CRi7HL///GExmXT+TODcH4vHEjIYYBERUdjgNxYREQVfch5w85tiUuGyrcALK4A9LwFf/z/RVRAALv0boGF2mIiIwg+7CxIRkToKZgM3vw28cg1Qc1AUulDMvhUYfpZ6bSMiIhoCBllERKSeEQuAe/aIebOOfwIk5QCjzgPm3aF2y4iIiAaNQRYREakrOQ+44KfiHxERUQTgmCwiIiIiIiI/YpBFRERERETkRwyyiIiIiIiI/IhBFhERERERkR8xyCIiIiIiIvIjBllERERERER+FDZB1h/+8Aecc845SEhIQFpamlfPuf322yFJUq9/F198cWAbSkREREREUS1s5skyGo247rrrsHDhQjz//PNeP+/iiy/Giy++aP85NjY2EM0jIiIiIiICEEZB1iOPPAIAeOmll3x6XmxsLPLy8gLQIiIiIiIiov7CJsgarK+++go5OTlIT0/H4sWL8fvf/x6ZmZlutzcYDDAYDPaf29raAAAmkwkmkyng7XVFOa5ax48GPMeBxfMbWDy/gcdzHFg8v4HF8xtYPL+BF0rn2Ns2SLIsywFui1+99NJLuPfee9HS0jLgtq+//joSEhIwevRoFBcX45e//CWSkpKwbds2aLVal895+OGH7VkzZ6tXr0ZCQsJQm09ERERERGGqq6sLN910E1pbW5GSkuJ2O1WDrF/84hd47LHHPG5z7NgxTJo0yf6zL0FWX6dPn8bYsWPx+eefY8mSJS63cZXJKiwsRENDg8cTGUgmkwnr16/HsmXLoNfrVWlDpOM5Diye38Di+Q08nuPA4vkNLJ7fwOL5DbxQOsdtbW3IysoaMMhStbvg/fffj9tvv93jNmPGjPHb8caMGYOsrCycOnXKbZAVGxvrsjiGXq9X/Y8aCm2IdDzHgcXzG1g8v4HHcxxYPL+BxfMbWDy/gRcK59jb46saZGVnZyM7Oztox6uoqEBjYyPy8/O9fo6S6FPGZqnBZDKhq6sLbW1tqr+wIhXPcWDx/AYWz2/g8RwHFs9vYPH8BhbPb+CF0jlWYoKBOgOGTeGLsrIyNDU1oaysDBaLBfv37wcAjBs3DklJSQCASZMm4dFHH8XVV1+Njo4OPPLII7j22muRl5eH4uJi/OxnP8O4ceOwYsUKr4/b3t4OACgsLPT7/4mIiIiIiMJPe3s7UlNT3f4+bIKsBx98EC+//LL959mzZwMANmzYgEWLFgEAioqK0NraCgDQarU4ePAgXn75ZbS0tKCgoADLly/H7373O5/myiooKEB5eTmSk5MhSZL//kM+UMaFlZeXqzYuLNLxHAcWz29g8fwGHs9xYPH8BhbPb2Dx/AZeKJ1jWZbR3t6OgoICj9uFXXXBaNTW1obU1NQBB9jR4PEcBxbPb2Dx/AYez3Fg8fwGFs9vYPH8Bl44nmON2g0gIiIiIiKKJAyyiIiIiIiI/IhBVhiIjY3FQw895NNYMvINz3Fg8fwGFs9v4PEcBxbPb2Dx/AYWz2/gheM55pgsIiIiIiIiP2Imi4iIiIiIyI8YZBEREREREfkRgywiIiIiIiI/YpBFRERERETkRwyyQsS//vUvjBo1CnFxcViwYAF27tzpcfu33noLkyZNQlxcHKZPn441a9YEqaXh59FHH8W8efOQnJyMnJwcXHXVVSgqKvL4nJdeegmSJPX6FxcXF6QWh5eHH36437maNGmSx+fw9eu9UaNG9Tu/kiRh1apVLrfna3dgmzZtwuWXX46CggJIkoT333+/1+9lWcaDDz6I/Px8xMfHY+nSpTh58uSA+/X1czxSeTq/JpMJP//5zzF9+nQkJiaioKAAt912G6qqqjzuczCfM5FqoNfv7bff3u9cXXzxxQPul69fh4HOsavPZEmS8Je//MXtPvkaFry5Juvp6cGqVauQmZmJpKQkXHvttaitrfW438F+bgcSg6wQ8MYbb+C+++7DQw89hL1792LmzJlYsWIF6urqXG6/detW3Hjjjfjud7+Lffv24aqrrsJVV12Fw4cPB7nl4WHjxo1YtWoVtm/fjvXr18NkMmH58uXo7Oz0+LyUlBRUV1fb/5WWlgapxeFn6tSpvc7V5s2b3W7L169vdu3a1evcrl+/HgBw3XXXuX0OX7uedXZ2YubMmfjXv/7l8vd//vOf8fjjj+Ppp5/Gjh07kJiYiBUrVqCnp8ftPn39HI9kns5vV1cX9u7di9/85jfYu3cv3n33XRQVFeGKK64YcL++fM5EsoFevwBw8cUX9zpXr732msd98vXb20Dn2PncVldX44UXXoAkSbj22ms97pevYe+uyX7yk5/go48+wltvvYWNGzeiqqoK11xzjcf9DuZzO+BkUt38+fPlVatW2X+2WCxyQUGB/Oijj7rc/vrrr5cvvfTSXo8tWLBA/sEPfhDQdkaKuro6GYC8ceNGt9u8+OKLcmpqavAaFcYeeugheebMmV5vz9fv0Pz4xz+Wx44dK1utVpe/52vXNwDk9957z/6z1WqV8/Ly5L/85S/2x1paWuTY2Fj5tddec7sfXz/Ho0Xf8+vKzp07ZQByaWmp2218/ZyJFq7O77e+9S35yiuv9Gk/fP26581r+Morr5QXL17scRu+hl3re03W0tIi6/V6+a233rJvc+zYMRmAvG3bNpf7GOzndqAxk6Uyo9GIPXv2YOnSpfbHNBoNli5dim3btrl8zrZt23ptDwArVqxwuz311traCgDIyMjwuF1HRwdGjhyJwsJCXHnllThy5EgwmheWTp48iYKCAowZMwY333wzysrK3G7L1+/gGY1GvPLKK/jOd74DSZLcbsfX7uCVlJSgpqam12s0NTUVCxYscPsaHcznODm0trZCkiSkpaV53M6Xz5lo99VXXyEnJwcTJ07EXXfdhcbGRrfb8vU7NLW1tfjkk0/w3e9+d8Bt+Rrur+812Z49e2AymXq9HidNmoQRI0a4fT0O5nM7GBhkqayhoQEWiwW5ubm9Hs/NzUVNTY3L59TU1Pi0PTlYrVbce++9OPfcczFt2jS3202cOBEvvPACPvjgA7zyyiuwWq0455xzUFFREcTWhocFCxbgpZdewtq1a/HUU0+hpKQE559/Ptrb211uz9fv4L3//vtoaWnB7bff7nYbvnaHRnkd+vIaHcznOAk9PT34+c9/jhtvvBEpKSlut/P1cyaaXXzxxfjvf/+LL774Ao899hg2btyISy65BBaLxeX2fP0Ozcsvv4zk5OQBu7PxNdyfq2uympoaxMTE9LvpMtB1sbKNt88JBp1qRyZSwapVq3D48OEB+0EvXLgQCxcutP98zjnnYPLkyXjmmWfwu9/9LtDNDCuXXHKJfX3GjBlYsGABRo4ciTfffNOrO3vkveeffx6XXHIJCgoK3G7D1y6FC5PJhOuvvx6yLOOpp57yuC0/Z7x3ww032NenT5+OGTNmYOzYsfjqq6+wZMkSFVsWmV544QXcfPPNAxYY4mu4P2+vycIVM1kqy8rKglar7Vc1pba2Fnl5eS6fk5eX59P2JNx99934+OOPsWHDBgwfPtyn5+r1esyePRunTp0KUOsiR1paGiZMmOD2XPH1OzilpaX4/PPP8b3vfc+n5/G16xvldejLa3Qwn+PRTgmwSktLsX79eo9ZLFcG+pwhhzFjxiArK8vtueLrd/C+/vprFBUV+fy5DPA17O6aLC8vD0ajES0tLb22H+i6WNnG2+cEA4MslcXExGDu3Ln44osv7I9ZrVZ88cUXve5GO1u4cGGv7QFg/fr1brePdrIs4+6778Z7772HL7/8EqNHj/Z5HxaLBYcOHUJ+fn4AWhhZOjo6UFxc7PZc8fU7OC+++CJycnJw6aWX+vQ8vnZ9M3r0aOTl5fV6jba1tWHHjh1uX6OD+RyPZkqAdfLkSXz++efIzMz0eR8Dfc6QQ0VFBRobG92eK75+B+/555/H3LlzMXPmTJ+fG62v4YGuyebOnQu9Xt/r9VhUVISysjK3r8fBfG4HhWolN8ju9ddfl2NjY+WXXnpJPnr0qPz9739fTktLk2tqamRZluVbb71V/sUvfmHffsuWLbJOp5P/+te/yseOHZMfeughWa/Xy4cOHVLrvxDS7rrrLjk1NVX+6quv5Orqavu/rq4u+zZ9z/Ejjzwir1u3Ti4uLpb37Nkj33DDDXJcXJx85MgRNf4LIe3++++Xv/rqK7mkpETesmWLvHTpUjkrK0uuq6uTZZmvX3+wWCzyiBEj5J///Of9fsfXru/a29vlffv2yfv27ZMByH/729/kffv22avb/elPf5LT0tLkDz74QD548KB85ZVXyqNHj5a7u7vt+1i8eLH8xBNP2H8e6HM8mng6v0ajUb7iiivk4cOHy/v37+/1mWwwGOz76Ht+B/qciSaezm97e7v805/+VN62bZtcUlIif/755/KcOXPk8ePHyz09PfZ98PXr2UCfEbIsy62trXJCQoL81FNPudwHX8OueXNNduedd8ojRoyQv/zyS3n37t3ywoUL5YULF/baz8SJE+V3333X/rM3n9vBxiArRDzxxBPyiBEj5JiYGHn+/Pny9u3b7b+78MIL5W9961u9tn/zzTflCRMmyDExMfLUqVPlTz75JMgtDh8AXP578cUX7dv0Pcf33nuv/e+Rm5srr1y5Ut67d2/wGx8GvvnNb8r5+flyTEyMPGzYMPmb3/ymfOrUKfvv+fodunXr1skA5KKion6/42vXdxs2bHD5maCcR6vVKv/mN7+Rc3Nz5djYWHnJkiX9zv3IkSPlhx56qNdjnj7Ho4mn81tSUuL2M3nDhg32ffQ9vwN9zkQTT+e3q6tLXr58uZydnS3r9Xp55MiR8h133NEvWOLr17OBPiNkWZafeeYZOT4+Xm5paXG5D76GXfPmmqy7u1v+4Q9/KKenp8sJCQny1VdfLVdXV/fbj/NzvPncDjZJlmU5MDkyIiIiIiKi6MMxWURERERERH7EIIuIiIiIiMiPGGQRERERERH5EYMsIiIiIiIiP2KQRURERERE5EcMsoiIiIiIiPyIQRYREREREZEfMcgiIiICcPvtt+Oqq65SuxlERBQBdGo3gIiIKNAkSfL4+4ceegj//Oc/IctykFpERESRjEEWERFFvOrqavv6G2+8gQcffBBFRUX2x5KSkpCUlKRG04iIKAKxuyAREUW8vLw8+7/U1FRIktTrsaSkpH7dBRctWoR77rkH9957L9LT05Gbm4v//Oc/6OzsxLe//W0kJydj3Lhx+PTTT3sd6/Dhw7jkkkuQlJSE3Nxc3HrrrWhoaAjy/5iIiNTEIIuIiMiNl19+GVlZWdi5cyfuuece3HXXXbjuuutwzjnnYO/evVi+fDluvfVWdHV1AQBaWlqwePFizJ49G7t378batWtRW1uL66+/XuX/CRERBRODLCIiIjdmzpyJX//61xg/fjweeOABxMXFISsrC3fccQfGjx+PBx98EI2NjTh48CAA4Mknn8Ts2bPxxz/+EZMmTcLs2bPxwgsvYMOGDThx4oTK/xsiIgoWjskiIiJyY8aMGfZ1rVaLzMxMTJ8+3f5Ybm4uAKCurg4AcODAAWzYsMHl+K7i4mJMmDAhwC0mIqJQwCCLiIjIDb1e3+tnSZJ6PaZULbRarQCAjo4OXH755Xjsscf67Ss/Pz+ALSUiolDCIIuIiMhP5syZg3feeQejRo2CTsevWCKiaMUxWURERH6yatUqNDU14cYbb8SuXbtQXFyMdevW4dvf/jYsFovazSMioiBhkEVEROQnBQUF2LJlCywWC5YvX47p06fj3nvvRVpaGjQafuUSEUULSeb09kRERERERH7D22pERERERER+xCCLiIiIiIjIjxhkERERERER+RGDLCIiIiIiIj9ikEVERERERORHDLKIiIiIiIj8iEEWERERERGRHzHIIiIiIiIi8iMGWURERERERH7EIIuIiIiIiMiPGGQRERERERH5EYMsIiIiIiIiP2KQRURERERE5EcMsoiIiIiIiPyIQRYREREREZEfMcgiIiIiIiLyIwZZREREREREfsQgi4iIiIiIyI8YZBEREREREfkRgywiIiIiIiI/YpBFRERERETkRwyyiIiIiIiI/IhBFhERERERkR8xyCIiIiIiIvIjBllERERERER+xCCLiIiIiIjIjxhkERERERER+RGDLCIiIiIiIj/Sqd2AUGe1WlFVVYXk5GRIkqR2c4iIiIiISCWyLKO9vR0FBQXQaNznqxhkDaCqqgqFhYVqN4OIiIiIiEJEeXk5hg8f7vb3DLIGkJycDECcyJSUFFXaYDKZ8Nlnn2H58uXQ6/WqtCHS8RwHFs9vYPH8Bh7PcWDx/AYWz29g8fwGXiid47a2NhQWFtpjBHcYZA1A6SKYkpKiapCVkJCAlJQU1V9YkYrnOLB4fgOL5zfweI4Di+c3sHh+A4vnN/BC8RwPNIyIhS+IiIiIiIj8iEEWERERERGRHzHIIiIiIiIi8iOOySIiIiIiIgCiRLnZbIbFYlG7KXYmkwk6nQ49PT0Bb5dWq4VOpxvy1E0MsoiIiIiICEajEdXV1ejq6lK7Kb3Isoy8vDyUl5cHZd7ahIQE5OfnIyYmZtD7YJBFRERERBTlrFYrSkpKoNVqUVBQgJiYmKAENN6wWq3o6OhAUlKSxwmAh0qWZRiNRtTX16OkpATjx48f9PEYZBERERERRTmj0Qir1YrCwkIkJCSo3ZxerFYrjEYj4uLiAhpkAUB8fDz0ej1KS0vtxxwMFr4gIiIiIiIACHgQEw78cQ54FomIiIiIiPyIQRYREREREZEfMcgiIiIiIiLyIwZZRETulGwCGovVbgURERENUnV1NW666SZMmDABGo0G9957b1COyyCLiMiV5lLg5cuBN25RuyVEREQ0SAaDAdnZ2fj1r3+NmTNnBu24LOFORORKa4VYNpWo2w4iIiIVyLKMbpNFlWPH67Vez9H17LPP4uGHH0ZFRUWvqoBXXnklMjMz8cILL+Cf//wnAOCFF14ISHtdYZBFROSKoU0szd2AqRvQx6vbHiIioiDqNlkw5cF1qhz76G9XICHGuzDluuuuwz333IMNGzZgyZIlAICmpiasXbsWa9asCWQzPWJ3QSIiVwztjvXuZrHsqAe++C3w8X2AVZ27e0REROSQnp6OSy65BKtXr7Y/9vbbbyMrKwsXXXSRau1iJouIyJWeVsd6VxNQsRt47weAqUs8NutmYPhcddpGREQUYPF6LY7+doVqx/bFzTffjDvuuAP//ve/ERsbi1dffRU33HCDqhMrM8giInJF6S4IAN1NwIHXHAEWALRXAWCQRUREkUmSJK+77Knt8ssvhyzL+OSTTzBv3jx8/fXX+Pvf/65qm8LjzBERBVvf7oIdtbYfJAAy0F6jRquIiIioj7i4OFxzzTV49dVXcerUKUycOBFz5sxRtU0MsoiIXOlxymR1NYnxWACQNx2oOcggi4iIKITcfPPNuOyyy3DkyBHcckvv6Vf2798PAOjo6EB9fT3279+PmJgYTJkyJWDtYZBFRORKr0xWE9BZJ9bzZ4ggq4NBFhERUahYvHgxMjIyUFRUhJtuuqnX72bPnm1f37NnD1avXo2RI0fizJkzAWsPgywiIlecx2S1lAHmHrGeN0MsmckiIiIKGRqNBlVVVS5/J8tykFvDEu5ERK45Z7Lqi8RSnwhkjBHr7bX9n0NEREQEBllERK45j8mqPy6WSdlAcp5Yb68OfpuIiIgoLDDIIiJyxeA0T5YyGXFSLpBkC7K6GgCLKfjtIiIiopDHIIuIyBXn7oKKxGwgIRPQ2IazdtQFt01EREQUFhhkERH1Jcu9uwsqknIAjUZktAAWvyAiIiKXGGQREfVl6gZkS//HE3PEUhmXxTLuRERE5AKDLCKivgwusliAKHwBOMZlsfgFERERucAgi4ioL2U8VlwqoIt3PN43k8Uy7kREROQCgywior6U8VixqUB8uuPxpL5BFjNZRERE1B+DLCKivpTugrHJQEKG4/FEW3dB+5gsZrKIiIhC2bvvvotly5YhOzsbKSkpWLhwIdatWxfw4zLIIiLqSwmy4lJcZ7I4JouIiCgsbNq0CcuWLcOaNWuwZ88eXHTRRbj88suxb9++gB5XF9C9ExGFox6nTJbeNiZLFw/EJIl1jskiIiIKCc8++ywefvhhVFRUQKNx5I+uvPJKZGZm4oUXXui1/R//+Ed88MEH+OijjzB79uyAtYtBFhFRX0rhi9gUINYWWCXlAJJkW7fNk9XVAFgtgEYb/DYSEREFkiwDpi51jq1PcHznDuC6667DPffcgw0bNmDJkiUAgKamJqxduxZr1qzpt73VakV7ezsyMjL6/c6fGGQREfXlPCZL6S6odBUEHOO0ZCvQ3QwkZgW3fURERIFm6gL+WKDOsX9ZBcQkerVpeno6LrnkEqxevdoeZL399tvIysrCRRdd1G/7v/71r+jo6MD111/v1yb3FdFjsp566inMmDEDKSkp9oFun376qdrNIqJQZy/hngIkZIp1JXsFAFq9I/jqbAhu24iIiKiXm2++Ge+88w4MBgMA4NVXX8UNN9zQq/sgAKxevRqPPPII3nzzTeTk5Ljald9EdCZr+PDh+NOf/oTx48dDlmW8/PLLuPLKK7Fv3z5MnTpV7eYRUajqaRXL2BRgyhVAyUZg3vd6b5OYLbJYnfUAJgW9iURERAGlTxAZJbWO7YPLL78csizjk08+wbx58/D111/j73//e69tXn/9dXzve9/DW2+9haVLl/qztS5FdJB1+eWX9/r5D3/4A5566ils376dQRYRuec8JittBHDzW/23ScgCcEKMyyIiIoo0kuR1lz21xcXF4ZprrsGrr76KU6dOYeLEiZgzZ47996+99hq+853v4PXXX8ell14alDZFdJDlzGKx4K233kJnZycWLlyodnOIKJQ5l3B3RxmHxe6CREREqrv55ptx2WWX4ciRI7jlllvsj69evRrf+ta38M9//hMLFixATU0NACA+Ph6pqakBa0/EB1mHDh3CwoUL0dPTg6SkJLz33nuYMmWK2+0NBoO9PycAtLWJiy2TyQSTyRTw9rqiHFet40cDnuPACrfzq+1uhQaAWRsP2U2bNfEZ0AKwtNXAqvL/K9zObzjiOQ4snt/A4vkNrEg5vyaTCbIsw2q1wmq1qt2cXmRZti/dtW3RokXIyMhAUVERbrjhBvt2zz77LMxmM1atWoVVq1bZt7/tttvw4osvutyX1WqFLMswmUzQantXEPb27yzJSqsjlNFoRFlZGVpbW/H222/jueeew8aNG90GWg8//DAeeeSRfo+vXr0aCQm+9Q8lovC0+NgvkNxThc3jHkBj8mSX20ysfheTat5HSdZiHCy8PbgNJCIi8jOdToe8vDwUFhYiJiZG7eaoymg0ory8HDU1NTCbzb1+19XVhZtuugmtra1ISXHf4yXig6y+li5dirFjx+KZZ55x+XtXmazCwkI0NDR4PJGBZDKZsH79eixbtgx6vV6VNkQ6nuPACrfzq/vnNEgdNTB95wsgf6bLbTS7noP2s1/AOulyWK51fScsWMLt/IYjnuPA4vkNLJ7fwIqU89vT04Py8nKMGjUKcXFxajenF1mW0d7ejuTkZEhezp81FD09PThz5gwKCwv7nYu2tjZkZWUNGGRFfHfBvqxWa68gqq/Y2FjExsb2e1yv16v+xgmFNkQ6nuPACovzK8v2MVn6pAzAXXtTREl3TXcTNCHyfwqL8xvmeI4Di+c3sHh+Ayvcz6/FYoEkSdBoNP1Kn6tN6fqntC/QNBoNJEly+Tf19m8c0UHWAw88gEsuuQQjRoxAe3s7Vq9eja+++grr1q1Tu2lEFKo6G2wz3EtAyjD329kLX9QHpVlEREQUPiI6yKqrq8Ntt92G6upqpKamYsaMGVi3bh2WLVumdtOIKFQ1l4hlyjBA1z+rbZeYLZasLkhERER9RHSQ9fzzz6vdBCIKN022ICtjtOftEmyZrO4mwGIGtBH9cUpEREQ+CK0Ol0REalMyWemjPG+XkAHANvi2uymQLSIiIgqaKKuJ55I/zgGDLCIiZ95msjRaICFTrHNcFhERhTmloENXV5fKLVGfcg6GUsiE/VuIiJzZM1kDBFmAKH7R1eB5XFZLObD9KWDB9wfOjhEREalEq9UiLS0NdXV1AICEhISglEv3htVqhdFoRE9PT0CrC8qyjK6uLtTV1SEtLa3fRMS+YJBFROTM20wWIIpf1B/3nMna9R9g+79E5mv57/zTRiIiogDIy8sDAHugFSpkWUZ3dzfi4+ODEvilpaXZz8VgMcgiIlIYOoBO2xeLN5kspbtgV6P7bZpLB96GiIgoBEiShPz8fOTk5MBkMqndHDuTyYRNmzbhggsuCPhcZHq9fkgZLAWDLCIiRfMZsYxPB+LTBt7eXsbdQyarrVIse1qH0jIiIqKg0Wq1fgk0/EWr1cJsNiMuLi5sJnxm4QsiIoUv47EApwmJPYzJamWQRUREFG0YZBERKXwZjwU4BVluMlkWM9BRI9Z7WobUNCIiIgofDLKIiBS+ZrKUCYm73MyT1V4NyFaxrmSyNv0V+Ow3g28jERERhTyOySIiUrSUiaW3pdYHKnyhjMcCgJ42wGwAvvw9ABk4+y4gpWCwLSUiIqIQxkwWEZFCGVuVlOPd9gMFWa0VjnVDm23/tlnk26oH1UQKMfVFwNPnA0Vr1W4JERGFEAZZRESKblu3v/gM77ZXgqzuJsBq7f9750yWbHVkygDRlZDC39EPgJqDwGe/AmRZ7dYQEVGIYJBFRKRQxlYleBtk2baTra4LW7RW9v656bRjnUFWZOhuFsvGU0DpVnXbQkREIYNBFhERAJiNgLFDrHsbZGn1QGyqWHdV/KLNU5BV43sbKfQoQRYA7H1ZvXYQEVFIYZBFRAQ4ugpKGkfg5A0lIHM1LotBVuRzDrKOftD7ZyIiiloMsoiIAEeQFJ8OaHz4aPRU/ELpLqiLE0t2F4w8zkGVuQc4sU69thARUchgkEVEBDiNx8r07XnuMllmA9BZJ9azJ4qlMtkxwExWpFCCrLQRYulcUZKIiKIWgywiIsD3yoIKd5mstiqx1MUBGWPEuqHV8XtmsiJDd4tYZk8Sy8561ZpCREShg0EWERHge2VBhdsgy9ZVMKUAiEvr/7zuJpHtovAly45MVtYEseyoVa89REQUMhhkEREBTmOyfA2ylO6CfaoL1h0Ty4wxQFyK6+eyy2B4M3YCVpNYV7qEdtSp1x4iIgoZDLKIiABHRsJfmayqfWJZMAeIc1OtkEFWeFNeM9oYIH2UWGeQRUREYJBFRCQMtbtgd59Mlj3Imt0/yEouEEuOywpvSpAVnw4k5Yl1BllERAQGWUREgj8LXxg7gfrjYn3YnP5jsnKniiUzWeGtp0Us49OBpGyxbmgFTD2qNYmIiEIDgywiIsARJPmju2D1AUC2ioxVcl7vTJY2FsgcK9aZyQorenM7pNNfAVaLeMA5kxWXJroNAo7S/UREFLV0ajeAiCgkDHqeLKW7YAtwfA1Qvh2ITRaPFcwWS+cgKyETSM4X68xkhZVZZS9Ad2gPkDcDuOwfjiArLg2QJCApF2gtF10GlXmziIgoKjHIIiICBt9dMC4NgARABt75LmDqAjS2j9ZhAwVZzGSFk0SjbQ6smoPAK1cDZ31X/Byfbtsg2xZksYw7EVG0Y3dBIiKrxTGprK/dBbU6ID5NrJu6bPszi6XLTFaG6EIIOObSorCgs3Q5fuhpBUq3inUlyErKFUsWvyAiinoMsoiIulsAyGJduWD2hXMXw5RhthVJlG8H+meyMseJ9eYzgNno+/FIFXolyEobKZZVe8XSHmTliCWDLCKiqMfugkRESlfB2FRAq/f9+QmZQOMpsX7F40DtESA2xZEV08WJoggWo3gspQCISQaM7UDTaSBnkn/+HxQ4shV6S7dYL1wAtJSKvyfgyGTagyx2FyQiinbMZBER2YteDCKLBTgyWXFpwOgLgXN/DJz1bcfvJcmRzUrIFD9nTxQ/K6XeKbQZOiAp2c7C+b1/17e7IKsLEhFFPQZZRERK+XVfi14oErPEctJl7jNhsSliqQRk2bbsVX3R4I5JwWVoBQDIujggf2bv3/XLZDHIIiKKduwuSETRzdgpxkYBvhe9UCy4U0xAu+gX7rdRLsTtQRYzWWGlRwRZiE0Bsib0/p29uiC7CxIRkcAgi4iiV0s58K8FgKlT/OzrHFmK3KnAtf/xvM287wH6BGDsYvEzM1lhRVKCrLhUETAn5ztK8PcrfFEf9PYREVFoYXdBIopeZdscAZZG5wiAAmHWTcDtHzuyZUomq/EkYDEH7rjkH7YgS1a6fSp/P6D/mCxTJ2DoCGLjiIgo1DDIIqLopVQEnH0L8MsqYOYNwTt2aqHIbFmMju6KFLoM7WKpFDBRMpGQRFVKAIhNAvSJYp1zoBERRbWIDrIeffRRzJs3D8nJycjJycFVV12FoiJ2zSEim4aTYpk1AdDFBvfYGo1jbA/HZYU8yaB0F+yTyYpLFX9LRf4MsSzdErzGERFRyInoIGvjxo1YtWoVtm/fjvXr18NkMmH58uXo7OxUu2lEFAqUTFbmeHWObx+XxSAr5Nm7C9qyVnm2YCqloPd2Y5eI5akvgtQwIiIKRRFd+GLt2rW9fn7ppZeQk5ODPXv24IILLlCpVUQUEmQZaCwW65nj1GmDctymEnWOH21Kvga2/QtY+WcgbYRvz3UufAEAw+YClz8O5E7rvd3YxcCG3wMlm8RYO21Ef80SEZEbUfXp39oqviQzMtyXaTYYDDAYDPaf29raAAAmkwkmkymwDXRDOa5ax48GPMeBFZLnt60aelMnZEkLc/IwQIW2aWJSoAVg7W6BZQjHD8nzG4K02/4NzYlPYRk+D9aFP/LpuVJ3CwDAok+CVTnPM24SS+fznj0Vuvh0SN3NMJftgDy8z8TF5BJfw4HF8xtYPL+BF0rn2Ns2SLIsywFuS0iwWq244oor0NLSgs2bN7vd7uGHH8YjjzzS7/HVq1cjISEhkE0koiDKaj+Kc0/9CR2xufhiyl9UacPwpi2YW/oM6pKnYtu4n6vShmhy4fEHkdZ9BqeyL8aR4Tf59Nx5p/+JgtY9OFB4O85kea5CeVbJkxjWshPH865CUf41Q2kyERGFmK6uLtx0001obW1FSkqK2+2iJpO1atUqHD582GOABQAPPPAA7rvvPvvPbW1tKCwsxPLlyz2eyEAymUxYv349li1bBr1er0obIh3PcWCF4vnV7KkFTgEJw6dj5cqVqrRBOqEBSp9BVnLskNoQiuc3FOmKfgIAGJObhJE+nm/N/54BWoFJsxZgygzPz5X2NwGf7MQEbQXGqvTaCjd8DQcWz29g8fwGXiidY6WX20CiIsi6++678fHHH2PTpk0YPny4x21jY2MRG9u/ypher1f9jxoKbYh0PMeBFVLnt+UMAECTPREatdqUKOZX0hg7/NKGkDq/ocbUDXQ1AgA0XQ0+n2/ZIL5UtYkZ0A303NHniePUHVXvtRWm+BoOLJ7fwOL5DbxQOMfeHj+iqwvKsoy7774b7733Hr788kuMHj1a7SYRUaiwVxYcq14bYpPFUpmDiQKnrcqx3tng+/OVv1GsFz0akvPE0tQFGFnNlogoGkV0JmvVqlVYvXo1PvjgAyQnJ6OmpgYAkJqaivj4eJVbR0SqarTNkaVWZUHAEWT1eNf1gIagtdyx3lHn+/Nt82TJSnVBT2KSAF08YO4GOuuBmETfj0dERGEtojNZTz31FFpbW7Fo0SLk5+fb/73xxhtqNy26FH8JHF+jditCV2Mx8NlvgJYytVsSPZpLxT8AyFJpjizAkRUxdQJWi3rtiAatlY71rgbfzrcsO0q4e5PJkiQgMVusd9R7fxwiIooYEZ3JipLCiaGtpxVY/U1xQXPfUUc3GnLY+gSw50Vg6+PAT44CqcPUblFkk2Vgzf8BsgUYdX7/yWSDSclkAaI7Wnyaak2JeK0VjnXZCnQ1AUnZ3j3X2AFJtop1bzJZgNh3axnQOYisGRERhb2IzmRRCCjdCliM4oK2ar/arQlN9UWO9f9eAZh61GtLNDj2EXByHaDRA5f+Td226GIBra3QDsdlBVZbRe+fO33IMNmyWBZJB+jivHuOksny5ThERBQxGGSR/5V8DfxjBnDyc6Bkk+Px6gPqtSmkOWVcG08BFbvUa0o02PG0WJ77IyB7grptAVj8Ilha+wZZPmSYbEGWSZsgugJ6g90FiYiiGoMs8r+DbwAtpcDnDwOnNzoeZ5DlWndz759NXeq0I1p01IrluKXqtkPBIMulrcUNeOKLk7Ba/dTtWxmTpbH1kvcl+LEFWWatDxPSJ+WIJbsLEhFFJQZZ5H9NJWJZewioO+J4nEGWa11NYhlrG+vBICuwlAIG3o6tCTR7kMUKg84e/OAI/t/6E9h8ahDl1vuSZaDNFmTlTBHLQXQXNPkSZLG7YPQo2w78ZwlQsUftlhBRCGGQRf7XVNz757SRYtlWAXQ2Br89oUyWHZkspeCFkUFWwDhXiQuZIMtWrY5Blp0sy6hoFu+DgxUtQ99hTwtg7BDrBbPE0qfuguJvM6ggi90FI9+ht4DK3cDht9VuCRGFEAZZ5F/GTqC9uvdjEy8BMmwTvtYwm9WLsROwmsR6ii3IYiYrcMw9ohALEEJBFrsL9tXWbUaPSVTzO1zph+BT6SoYnwGkjRDrg+guyEwWuaTcuBnM/GtEFLEYZJF/KV0F49OBwgVifcIKIH+mWK8+AFit6rQt2FrKAUOH5226bV0FtTFAQqZYN3UHtl3RTLkYkjRiwthQwCCrn5o2R4XNQ5WtQ9+hUvQidTiQOIixUh1iInufgiyOyYoeymTiDKiJyAmDLPIvpatgxhjghtXAtz4Gxi52BFmb/gr8PhvY94p6bQyGtirg8dnAq9/wvJ3SVTA+A4ixXcAxyAqc7haxjEv1vkpcoMUp3QUZZCmcg6zKlm40dxqHtkNlou/U4U7Bj5cXxGe2AFufBAC0xRd6f0wlmOtuBiwm759H4Ue5ecMgi4icMMgi/2o6LZYZY4HELGD0+eLnYXPE0tgBWM3AiXXqtC9Yao+IboDOc2C5ohS9iE8H9EqQ1RnYtkWzUBuPBTCT5UJNa+8bDYerhpjNUoru5E71baxUySbgtRsBiwHWCStRkrXE+2PGpwOSVqx3+qF4B4UuBllE5AKDLPKvRqdMlrNR5wMX/wmYcYP4ub0muO0KtrYqsTS0i2IL7iiZrIQMpyCLmayACeUgq4eFLxQ1rYZePw+5y2DVXrEsmO00VqrO/XtTloFt/wL+exVgaAVGLITlqmdEN1NvaTTiRpNyLIpcStGarkbAalG3LaSqgxWteG9fxcAbUlRgkEX+pYzJyhzb+3FJAs6+CzjrO+LnjggPspTiH1YTYDa4387eXTAd0MeLdRa+CJyQDLJYXbAvpbtgcpyY0+pwZSu6jGbInm5YuGPsBOqPi/WCOY7ughaj63Nu7ATe+R6w7peAbBE3hm59z/H+9EWij10TKTwpnyuy1dE7gaLSfW8dwk/eOIDi+gHGY1NUYJBF/tXkJpOlSM4Ty/YazxmecOdcYdFTNzCl8EV8miOTFWUl3P++/gT+9tkA3Sr9padFLEMqyGJ3wb5qbUHWookiSFl7uAZTHlyHBz844ulprtUcEhe/SXlASr4IlmJs59xVRv2Du0Upbo0OuOTPwNVPDy7AAhyZLJZxj1wWs2N6AIABdRSzykBFi+iJUus0rpSiF4Ms8h/n8u0DBVkWoyOLE4nanIMsDxkKpRBDlBa+aOky4p9fnMTjX55CXTC+lOyZrLTAH8tbDLL6qWkVr4Wlk3OQEKOF1XY/5rOjg8iAV+0Ty4LZjsdybRMSb/5H722tVuDkZ2L9htXAgh8MrUAKKwxGvr6f7/xbR61OM2CxfVi195hVbg2FAgZZ5D/O5dsTMlxvo4sVvwcie1xWe5Vj3dPFs8vCF9GTyapodgSUp+qC0L0ipLsLMshSKHeBx+ck490fnoNnb51re9yAli4fKw26CrKW/x6ABBxYDRRvcDzeeEpkJXTxwLilQ/gf2HCurMjX02e8IIucRK02p48mBlkEMMgif2otF8u0kZ63S84Xy76TFkeSNm+7CzoXvlDGZEVPJqui2RFQngpGH3ZmskKewWxBo61ke15qHCblpWD51DwMTxfvj6IaH89Tpa3ohVLhFAAK5wPzvy/W1/zU0XVZqUKYNx3QaAf7X3DwpZIhhad+QRb/1tGqzeTIerf3cNoGYpBF/qRcJManed7OeVxWJDIbgC6nu5neBFlRWvjCOZN1sjYYQVaLWIZUJotBlrO6NlEoJkanQXqC3v74xFxxnopqfThPnQ1A40mxnj+r9+8W/1qMu2o85bhBVL1fLAv6bDtY7C4Y+fp2F+zg3zpaMZNFfTHIIv9RLhJjkjxvp2SyIrXCYN/g0avCF+mAPlGsR1GQVdnC7oL27oLGdpZ/hqOyYF5KHCSn8VAT80SQddzbTFZHvSjBDgDZk4Ck7N6/j0sRGSsAqNgllkomS5k8fajYXTDyMZNFNm1OyStmsghgkEX+pFRYGijISsoVy0jNZPULsjwVvlAyWdHaXdApyApqd8FQCrKSHetGlv1Vil7kpcT1elwJsk54G2S9eRtQe0iUUf/GC663GT5PLCt2i6IX9iBrlq/Ndo3dBSMfgyyyaTM6dxdkJosYZJE/GWwXiLFeZrIiNsiq6v2zu0yWLPfpLhh9JdwrnYKs+nYDWrsDfPcvFIMsXSygsXWLY5dBe9GL3FTXQVZRbfvA82VZLUD5drF+67tA7lTX29mDrF1Ac4m4IaKNBbInDrr9vShBVleDCOIo8iiTiCs9ERhkRS3nTFYbM1kEBlnkT95msiJ9TFZbn4Ie7i6cDe2A1Xa3q1fhC++DLKVcbLhSCl9obDcAA95lMBSDLEniuCwnjkxWbK/Hx2QlQaeR0N5jRlWr63L/RrMtkOluFnNjAaKroDvDzxLL6gNA+U6xnjcN0OrdP8cXSpBlNTvGA1JkUT5TMseKJbOWUYuZrCHqqAc+uheo2q92S/yGQRb5j3KBOGAmK0KDrNojwJZ/ijviztxdOCtZLF2cbYJUWybLagIsA98F23yyAdMeWoc3d5UPodHqaesxoc32RTSrMA0AcKougEGGLIdmkAWI8UEAgywAZU0i8B6W1nsC4BidBmOzxWdLUU3/Lrgbiuow9aG1eHVHqaOMdlya54ApfTSQkCXm7dv2L/GYv8ZjAYAuxlHJkgURIpM9yBonlp31jmqVFFV6Z7IYZPns8DvAnheBrU+o3RK/YZBF/mPPZCV73k4JsjpqIuvLaO0DwPoHgV3Pi58TbZXF3AZZTkUvAEd3QcCrcVk7zzSh22TBRwerBtw2FCldBdMT9JgxPA1AgDNZpi5H5jDUgix7JsvD+L0oUWwbmzcmu//Nmgkeil9sLKqHySJj04l6R3XPxCzPB5MkR5fB2kOApAGmfWPwjXeFxS8im/KeVYIsczdg7FSvPaSa3tUF2V3QZ12NYhlBWX8GWeQ/yhdLTKLn7ZTCFxajI5sTCWqPiKVsqxCnjOsYKJMVb5u4WRsjLvIAr7oMdhlEwHCkqm3gMSohSAmyhqXHY1yOuKAOaJDV3SKWGt3Ar9FgUyoM9kR3kGWyWO2ZrLE5/YOs0Vni7+Y8lg8WE1B3HFX14gu6sqXbkclKGCDIAhxdBgExSfGocwfXeHdYxj2yKZmslHzHjTL+raNOh8EMo5XdBYdEuWERQT06GGSR/3hb+EIX6wgsImVC4q6m3nNjAUDWBLF0l51QLgSVTJYk+VTGvcskgrmmTqO97HU4UcZjDU9LwOR8kaHYX94Ca6DGmTl3FXQqDR4SOCYLAFDe1AWTRUa8Xov8PtUFASAnWYzTqm8Xc2nhwx8Bjw4H/r0A3656BABQ1dLjfSYLAKZcJbLOC+8Gzv6hP/4bvSlt6GzwvB2FJ+VzJTbFKWvJv3W0aegw9PqZmaxBUN5LEfQ9yCCL/MeozJM1QHdBIPIqDNYXiaVz0Y+cyWLp7gPj8LtimTfN8ZgPZdyVTBYAHK4MvwyIMkfWsPR4zBiehqRYHZq7TDhSFaD/S6iOxwIYZNmcrhfZ8NFZidBo+gfC2UqQ1WEAWsqAvS8DZnGDYbL5GABx08HYZuual5A58EGzxgE/PQGs+ENggm+l2zDHZEUm++dKGpAyTKw3nFStOaSOOtuNH2UC9R6TFSYLK4r6pIeZLCL3vM1kAaJrBQA0nQ5ce4KpwRZkFS4ArnoaWPEokGsLnlx9YDSdBk6sFevzvud4XAmyvCjj3mV0TFx7pKrVw5ahyR5kpcVDr9Vg4VhxQbzpZIDGrjDICnnKeCxXXQUBpyCr3QCc2SIezBLdctOkTiRABFxdLbabN7YsUm1bD+783x5sK250feBAZjbZXTCyOX+ujDhbrJ/5Wr32kCrq28WALKVLM8Augz5jJovIA29LuAOOL6NTXwSuPcFUf0IssycCs24EFv7Q84XzzucAyMC4pUDWeMfjSp9+b7oLOgVZYZnJchqTBQAXjBcXxJtORGOQxeqCgCOTNSbL9Zi57CQRZNW1GyCf2SwenHgxTHrxXsuXRBBlbFUyWeI19caucqw9UoOXtvap/BkM7C4Y2Zw/V0ZfINZLvo6sok40oHpbd8G8lFgkxGgBAG2Bnvcx0hicgqwIef8wyCL/8SWTNeFisSzZCJjCbzxRP0omSxmHBbgPsoxdwL7/ifUFd/b+nVLG3ZvugkbHXbJwzGQ1dIg7f0p24oIJYjzDntJmdBgCcAcwpIMsVhcEvM9kGc1WWJUga9T5aI8RxXSGSSKQsSqV/GwBzoHyFgAI/GTXrrC7YOSSZcd7Ni5F9GTQ6IG2isjppUFeUcaJZifHIjlOB4CZLJ8p39GyxatroHDAIIv8w2IWpWsB78Zk5U4T/ddNXYBysRTOnDNZCuXC2dzde96rxpPiizk+Axi7pPd+BpnJqm7tQWOfgbehrrlLBFkZCTEAgJGZiRiRkQCzVXbfrWsoQjrIUjJZDLIA95msOL0WyXE65KMR2pYzgKQFChegQSsC9HxJTIugsU2PUG9NgizL2G8Lstq6VbjoYXfByGXscEx6HZcqbpIVzhc/l2xSr10UdPYgKykWloSHlgAA98xJREFUKXFiXBaLX/jIubpuhPTqYJBF/mFymhfEm/LYkgSMXybWT64LTJuCxdgFtJaJ9SynIMu526TzB0abraJiWiGg6fMWtBe+8C3IAhC4ghEB0GOy2NufkRRjf/x8W5fBnSUBCLKUkvkhGWRxTFZTpxHNXeKiZEy2+8+Q7ORYLNCIIhfInwnEpaDcKsbzTU0QgXSsQQRZd75bip0lTWjsFAF9mxoXPewuGLmUGzfaGDGpPACMOl8sOS4rqhTbujqPyIi3Z7I4IbEPnLPCgGP4CSCCL3N43URWMMgi/1C6Cmp0okS7N5QugyfWhm//27IdwIlPxXpCJpDoVM1M5/TF63zx3G6bPDi5oP/+fKkuaOsuONw2pqm8eeDALFQoWSydRkJyrM7++MhMkclTuhL6VVulWLo672pjkIXTtizWsLR4JMTo3G6XneQUZI06DwBQbBCB87TkDkiwItHSAgCoNCbitx8ftT9XlTESSndBU5fjc5LUc/hd4JVrgU4/3MhR7rzHpjiKp9jHZW0K3++1ADGarXhnTwVqWiNgiIATq1XGSdscjxNyk5HMTJbvnLPCQO85s/45A3jhYnXaNUQMssg/nIteeFupa/QF4g5gSxnQfCZgTQuYit3AC8uBt78jfnYej6VwdfGsZLKUCovOfJkny5YJKkgTQZYq400GqcmWWUhPjIHk9HpJjRdfTgH5v7RW2A4y3P/7HioGWTjd4Cjf7kl2cixmaYoBAI2Zc7GvrBnHukSQNVLbhBR0QQfxZd2ElF4Z3naDOXDzsLkTkwjobDdPOgNU1IW8t+Np4NTnQLEfii656oI8/CwAkvhb8+/dy6eHq3H/Wwfw6KfH1G6KX5U1daHbZIVOkjHSKZPFMVk+6Okzrlz5Lmw8JXqhVO0DrOF3PhlkkX/Yi154MR5LEZMIZIwV6+EySLi9RlSOAsQXtbO8Gf23d3Xx7E0ma4AS7larjG7bZMQFqSJbFo5BljIeS5EaL35u6QpgJotBVkgqbRRBlpLNdCc7SY/RkrhR8d1PO3D1v7eiytZdMNVUi0xJBFXtcjyM0Pd6riwDHcYgf1FLEpCkTFLLi27VddkyWH0v6gbDVZCli3XMz8ZiJ72U2G6klDaGT68LbxyvEZ/beQmATquxZ7Laekz48EAVqloio4hDQPX0Ge6gfBe219oekIGupqA2yR8YZJF/2Cci9qKyoLP0UWLZfEZ0kdv279DOar1xK/DyZUDxl0DpVvHYOfcAFz8GXPjz/tv7nMlyMyarcg+w9UnAKgKrHrPF3hMlX8lkdYVhkJXYN8gKUCbLbHRMfJ1a6N99+4NykRbFQVZZk7gQGSjIGqNvRpxkghE6HOwQ560S4qJW216FPK04h01IxqKJ2f2er2qXQV50q0+5UPNHkKUUM+k76XWSqHaJjlqQQ22bGFfTEGZFmgZSZAuy8hPEl3KKLZP1+s5y/Oi1fXjkoyOqtS3kNZwCqg+4z2Q5v4e6wm9ca8QHWZs2bcLll1+OgoICSJKE999/X+0mRSZfyrc7cw6yDrwOrHsA+OK3/myZ/zSVABU7xfr+14CKXWJ95k3A2Xf2Ho+lcFU1rt0WZCW7CLKUoiHOY7JOrgdeuAT47FciuEPvohd5KSKT1RJGQVazmyArLSFAQVZ7FQAZ0MY6ChGEEudg3Gr1vG2EKmtUBo577i44UhaZ4DPWXFihwfnjs/DsDy+DDAmSxYA5CeLC1xCTge+cOxqAeF1l2l5rqlQYTGQmKyRYrUBPi1j3R5DVZuuVkDqs9+NJDKpdqWsTY7Hq2w2QI2i8WlGt+H4vsAVZSnfBGtv/91h19N4888hiBl66FHh+BdDcZw5De5DleA9JYVg8KOKDrM7OTsycORP/+te/1G5KZLOPyfKisqAz5yCr5qBjXU3rHwSePt9RjU5x7CPH+uG3RbYpLg3InuR+X8rFs3OlHOWLOcWLwhdlO4DXbwIstjt/tnPTZRBBVkKMNnCByRCZLe6DhSZbQJie2Ls7l3Mmy69fwvbxWMO8HzMYTPZutnLv10qEsFplPPTBYby7t8LtNqVNIns7UCYr31wOADgti/fPWSMzMKUwG5ItezBHXwoAiE3Jxvnjs/C7K6fiiRtnIzXB0YUn6NhdMDT0tDgG1/slyHJTTIdl+12qbRdBh8FsDcxciCo5bguiCmwfXSnxvb/XKlu6YfLwfRi16o4AHTVimpvKPb1/5zKTFX6fnxEfZF1yySX4/e9/j6uvvlrtpkQ258IXvnAOsupsg2GVbl1qkGVg90si4DvRp7T8sQ+dtrN9YI5Y2L8MuzPbxbNs62/c09XhuJPqKpNlnyfLVhL/wGrA4jQ+yRagdZnEF5QIsmzjmEIoyHp1RymmPbwO20+7ruDV1CmCxv5jssSXk8niGHPmF60hPB4LEFUoNbaKehHYZfBwVSte3laKP68tcvn71m6TPRNbmOE5yMrsEUFUsSzeP7NHpIlf2P62Z8eLIGzYsEJIkoRbF47C+eOz7XPXqNNdkEFWSHC+ceaPOensXb/dBFnMZPVS0+roJtjQYRSZjDAcZ+Osx2TBGVsWPr9PJkthscocl+VK2XbHes3h3r+zB1mO60Fmsih6DabwBdAnyLKVWm6vsY89CrquBsBgu8OpjLkCxEV6xS4AEjDhEsfjIxd63F1lt/iwXb+vGD0mC+566mMAgKxPcD1fU99MVqOoombPltkC0E57JkuHNCX746FYxNZTDXhxS0nQumhsLW5Ej8nqNshq7hQXun27CybEaKHXikyTX7s/tooL75AcjwWI7FoEF79Q/pZNnUaXr8FyWxYrKykGSbHuy7cDQFKH6FZy2ioubGcWpolf2IKshAbxZa1L7j0eS7m7rMrcNRyTFRqcL+j92V2wb5DFv3c/JosVjZ2OIKulthx4+lzgb1OA018BLeXAO3f0v7kZ4k7WdsAqA+kJeqTYEljJsfp+20VasQ+/cL7Gqu0zbs1Fd8FwnGvQ87dZFDIYDDAYHB8EbW3ibpfJZILJpE6mQDmuWsf3hqa7DVoAFl0CrL60Mylf1P9yvqsoW2BqrXYMHg4C5dxa6ors9cjksm0w2x7XHPkAWgDW4fNhnftd6GxzY5mHzYfs4f9b2q7BMADlNbW49fkd0DaWAzFAT1wOdOb+F3uSJhY6AFZjJywmE3SNxZAAWAoXQlt/HNa2SlhMJrR3i9dovF6DRL0ISlq73b9Gf/b2AVS09GBybiLmjkz3+fz4qsOWLWjsMPR67yjLxg7RbSQlTtuvzSlxejR2GtHY3o3sRP98RGmay8TrMynft9dnEOlikiF1N8Pc1ezxNeVKqH9GNNv+3kaLFW1dPf3mwTpdJ97/henxA/4f9M3ixsNpOR9jshKRoBP/b01yPrQAABHEWeLSe/2tk2PEb5s7ewZ1noZyjqX4DPG+7qiFJUT/RmoLxmtYaq+zX/RYu1uH/LfQtVVCAmBKyAWc9iXFZ4q/d3tNyPy91f6MqG7tsRdrykQrxn16I9AhqgrLb90OxCRBai2HtfkMLKMXq9LGwThaJbKj47MTIUndMJlMiO8fY+F0fTsWjk4LbuNCmSxDV7YN9s77tuJpMiRIkGHtaRPXQO219m3kjlpAGxrfc962gUFWH48++igeeeSRfo9/9tlnSEjw3I0l0NavX6/q8T2ZVnEIYwEUV9Ti2Jo1Pj13hS4VcebedxW3rH0brQmj/dhC7xzb/BFm29alhhP4/MM3YNQlY1bpGowEcMJcgBPH2nBhXCE0sGDDvirIB9z/f822akrjpErsPdOAyzTiTmqtMR4HXJynvNajWACgpa4KWz9+D5fZyr3vbUrAPAAd1aewYc0aHGySAGhh6GzHzs1fAdCh02jBhx+vga5PftoqA1UtWgAS/rduO2qH+57NeuWkBu0m4AeTrdB4MaSpvEYc7+ipM1izxlGeX3kNl9aK3588vB9rKvb1eq7OKn63bsNmnE71T+ZtQfF+5AE4WNqEMh9fn8GyyAikAtj59ReoTxncHfBQ/YzYWiterwDw3iefIb3PfOXrK8XvNd3NWOPh76O19OAyW+GYYjkfk6R2+/a5rXFYYPuCBoDdp5tR0+TYV3O9BoAGew4eRU7z4Kt9DeYcZ7UX41wAnbVn8GWIvv5CRSBfw4WNmzHHtt7ZWDWkv4XWYsBltq7fn20/DLO22P677LYzOAdAR81pbAixv7danxGl7YByyflj3btI7jiNbn0GDLoUpHWfsXfl7Ko7gy9C7Jx5sqlCfHZJtizp+vXrUdkJKP/XEYkyyjolbNx9BOkNh1RrZ6hJMNRhmYvqmz36NMSbmlFbdgo7P/kEl7ZV2QOV+tJjwJiLQ+J7rqvLu8wkg6w+HnjgAdx33332n9va2lBYWIjly5cjJSVFlTaZTCasX78ey5Ytg17v4hZJCNB+vA6oB8ZOnonR56707bn1Tzqq9tmcN2Ms5AnBm+FbOcfT8uOBMsfjyyYmQ564EtrXXgSagHFnXYSxM68ALrkUkCRcInnucfu/1ibg9Ju4UHsQb0i/w27rRACAnDkGK1f2P09SSSJw+h9IT4rFivkTgQOAHJeKWStuBp75F5LldqxcuRKmA9VA0SEU5Gbimsvn4ld71kOWgXMWLUFWUu8r2MZOI6zbvwIAtMflYOXKuT6dG6PZih9vE3OCTV94AUYOMGYGAJ4u2Qa0tyM+LRsrV87t9xr+w+GNAAxYsehcTC3o/b56qWIHastbMXnmHCyf4p9spu7ZR0X7z7sE08Zc5Jd9+pu24d9AeRnmz5wMebJv76FQ/4yo+LoEOH0SADDn7PMxOb93t+It7x8ByiqxcNo4rFwyzv2Oqg8AB4EWKRVtSMKlZ0/GyvlKF9CVMLd/F1LNAcDcgzmTLgec3p9HPjuBrbVnkFc4GitXeihW48aQznH9WODUn5Akdbt831NwXsOanWX2z/cknWVof4vGU8BBQI5JwvLLr+39u7pRQPGfkawJnb+32p8R64/WAYf3AwBm2iYT11/2Z+iGL4D82rWA1Qyp6TQS0RUy58wbe9ccB8rLMH38KEA+jWXLlqHNYMVfD21EUqwOt1wwFn/8tAja1FysXDl7wP1FC+ngG8BRQNboIVkdWaHY7DFA1R7kpidg5dILoNvvGAaRkyg+z0Phe07p5TYQBll9xMbGIjY2tt/jer1e9T9qKLTBLVuhBm18KrS+tjFjdL8gS9dVB6jwf9W2nLE1IA4w90BXuROYdqV9LJQuvdDWLu/adiRuDu4x3o2/xL2Is3ACszWnAACtumyMdvX/ixMXn5KpG/pWMcBfyhgLfbq4kJQMbdDLRhgs4m59UqwecbExSI7Voa3HjE4TkN9nvy09jgG3+8paodHqcKquA8PS4wcc/wIAbU7dZ5u6LBiXO/D/vctWtKK129zrNavX66HT6dBsGz+Wm5bQ7zWdnijefx1Gq/9e77YqYLqMUaq8rrxiG6OnM3cOuo3dZsAE2CvphYouk6Oylqu/a0WL6E44OjvZ89+8RYzHMqaNxbzcdFw2c1jv7TMKxT8X0vz0uhrU53CqKNIh9bRAL8mALmaAJ0SvgH7PGRw9JiRD29CO0yWyzVLKsP77SRVjtKSuRug1ALSh835U6zqiwTYuU4IV4yXb5/GwWUDmCOCHO8Tf5rFRkIwd0MMC6OMcT5Zl4PgnQO5Ucb0QQlpsU0JkpcQBreL85iXo8fzt85CREIMm23ddeXNP6F6/qaFSXPNJ45cBRY7MpSatEKjaA42xA5qe3kVRNLaJxEPhWtjb40d84YuOjg7s378f+/fvBwCUlJRg//79KCsr8/xE8s1gS7gDjuIXAJBgm8NIpQqDUpOty8fkK8RSGZipDHDuW6rXhfKmLhyvEXc5Og1mfGQ9BxvPehIAoIW42KzXuJhTCwBilOqC3YDSlsyxQFyKo3Jjew26jY4S7gDsFQZbu/sXv2hodzzWbjDjT58ew4p/bMKyv23EDjeFKZw5Fwqotc37MZBOW3leZdJhZ+0GM0y2IDE9of/Fpt8nJO5pdYz56zufTSgZYuELgwVY+eRWLP37RjSG2GSfznNTuaqCqQwKH6h8OxrFTYqc0dPw1p3nIDOp/w0xd1StLhifDkjivRqOE2pGDOfCF+YewDyE94mnqTgSMhx/7zAcrB8IynfHGF0jEiQDTJIeSLcFTBqNmA5FqbDa9z1SsQt442bg/buC12AvKd9xfSvlXjQxBzML0zAqU1wTlTV1RdTcYENWukUsp3+j9+NKBWBDh6N8u9Z2blnCPfTs3r0bs2fPxuzZIk173333Yfbs2XjwwQdVblmEUaoL+lrCHegdZI21deWyjUUKKtkKNNnGD82+RSyrD4i+4sodUFdfqM67kGVc/8w2XPHkFrR2m9BpFBeXHbnzgfHL7dvVym6KT9hLuHc5KgtmjBXL5DyxbKtyVBe0ZaKUubJcVeSr7+gdGP3na5ENqG7twY3/2Y4tpzxfBDgHO94HWRZbe/oHWcpExAkxWsTptf1+7/cgSynfHp8xuJsAwTLEIOtIs4TaNgPq2w1uS6WrxXluqr6vUaPZiupWkW0dMVBXVKUEt1K9zQeO6oIqBFkajaOMOyvOqae7T7nwniGUcVfmyHL1naDROiY9dzHuJBrV2sYnL84QN/bKNYWA1qknhSQ5TXXQ5ztJmUOz4USgm+mzxg5bkJXoOrMxLC0eGgnoNllQ3x5aN79U01opbphJGmDsEsfNdQBIsd0INbQ73jvZYpiFZOyE1hpe5zDig6xFixZBluV+/1566SW1mxZZjLZ5nWKHEGRp9MDIc8W6CpmseFMTJIvB0Q59IiBbHHM5xCSJjJIHDR1GVLf2wGi2oratxz7hYmKsDlj8G/t2FWZ3QZathLux0xHwZSpBlm1erfZqxzxZtiDFU2Di6oO9MCMeiyZmwyoDnxyq9vh/cr7zX+fFl4TF6pjjqtNogcHcuxy/cufPVRYLcPxf/FbC3Xki4lA2xCBrb4OjIskbu8uxt6zZw9bB5fwaaumTbV17pAZWGUiK1SE7eYDMlMk22Fh5n/ggxTZ3jXNWLajcXUBSfy1lwJ6X/D+VR985mYZSxt1TJgtwmpC4z9332qPA1ieBL37Xe56gCKfcoJufKL7bT8ou5ixULrb7vkcabd+FXY2O6U1ChFKWvu90JIoYnQYFaeLzSplwPeqd+Vos82cB8WlAmlMX71TnIMt2QypjLKAV3w0x5vCa4iTigywKElv5TcT4OE8WABTMBgrmAHO/BaSNEI+1eb7wD4SkHltglzFa3GHLHCN+LrF9IAyQxQKAsqZO+3pbt8nebS4pVgfkz8Dh6T/Ha+aLcMA6yvUO4tPFeDDn4E7JZCnHb69GV59MlqfARAmy7PMJAXjgksm4erb4MCuq8fyh5Xzn35tMlpK9U/RtkxJkZSZ5DrL8lsnqtH1QJ+X5Z3+BEmsL4AcxSWpbtwlHW0SQNW+UCOD/8flJvzVtqNqdupw6vx6aOo145ENR6e+7542GJA1QulK5wBpERlLVTBYAJClBFjNZA/r058BHPxaBlj/1y2QFMsiyFe3pm8n639XAZ78Cvv4r8MatQJR0IauzZbImQMxZeMg0rH/3OSX71zcwbXJUqLWf9xAgy7Kju6CbIAtwdINWukW/tKUE/9teGvgGhirlmmr0+WLpPH+l0l3Q1OnIFifn2W9SxZr8MIl4EDHIIv+wT0Y8iEyWPh74/gbg0v/XK1sTbIkGW5CVaatupgQ3ZzaJpdI2D5wnHGzvMdu7zSXG2ubomXEHHjDfgeZuq8vnQx8PLLhTrMu2u7hKsGfvLliNrn5jsmxBlodM1vIpuVg2JRc3zCvEJdPyMClPXNSfqGn32Ffc+c6/N0GWEgAqmvt0GRwok6X8X/wXZNnuiiZmed5ObUqWdBCZrPXH6mCRJYzPScRPl4uuFRUhdNe0d3dBx+vh958cRWOnERNzk7HqIg9VBRVDymR5Nybrb58VYcXfN7ns6joknKDWexW7xfLEWv/ut6tPdtcwhCBL6dKe4iZD7urvbewEOmzfM9oYEXDXHxc/Wy3A3v8Cm/4akYFXje27I8dwBgBw1DIM7YY+WWXlM7rvmCxlfDIQUkGW8/jivmOynI3IcIzLauww4OGPjuI37x9GZUtoZeWCQpaBko1iffQFYukcZKU4ZTiV4Dopx/7aiDUzyKJoZBzCmCxnKbZAprsJMHk3/sdfkuxBli24UoKtmsO2tg2cyXIOstp6HGOylCp+SmDRN/Do5fz7xPghQCzjbV0Lk50yWbb9KkGWkv1xdQFZbyuCUJAWh//cdhb+dO0MSJKEMdmJ0GsltBvMHj/snS+QlbuRnnT0+eJs7uzdJuX/7u7On/8zWba7ogluio2ECqW74CDGiaw5LF67l07Pd8rYBLdbXGuXCd9+cafLO7S9Cl/YMlmyLOPTQ6Ldv7tqGmL6TvDmij3I8n3OwpR48R5sN5hhtbq+iDWYLfjP1yUoqm3HjpIml9sMmru79NRbR60j21eyqX/3sIo9wNvfHVxvByWTpdwwC0Z3QecgS7nho40FRp4j1ku+BppKgOeXAx/eA3z5O6Cq99yB4a7HZEFrtwk6mBHXKgKmE3Jh/67s9i61Tu8RqwVoPuP4WcluhICmDsf44viY/uOLFcPTxU2hyuZuVDQ7Xs8bjkfhDZfmM0BruShyUni2eMy5u2BilhiyATjGpSc5ZbIYZFGwdfa9GxRsFrOo1AQ4LhQHKy5NdJcDHHf8giS7/ahYyZshlkqwZZvc1Lvugs5Bltn+t0ns062vucvkPnsUlwosesDWlmmOx5VMVrtzJstW+CJeBCyu7r4rX2TZSXG9HtdrNRibLYJiT10GfS180ff12DegbByge4Xfx2TZyr7av8BD1SDHZFmtMvaUtQAAFk/MRrIy9ijI3eJe3VmKDUX1ePqr4n6/65XJsr2eatsM6DZZoJGAWU5dWT1SLrgHE2TZMlmyDHQYXX9m7iltto8n9Gb8oU/cjdGhXqTaw44fzD3Amc1iLJXR9tm65n7g8NvA5r/7tmNTjyNIV6raDTbIMhscf0d3mSx7kOXUXbDLKas+ytZV6szXwAd3A5W7HdvVHRtcu0LUNlsV2wn6ekgWI7oQh0o5Ew39gizlRoRT1dvWCsDi9B0SQkHWQN9limG2MVlVLd2oaonyIEsZjzXsLEfPJ6WLYEyyKBqjfBfaqskiKdf+/R3DIIuC6YXNJZj28Dp8eVzFCkbOY0iGWr1Nkhx3GYM5LqulDCk9FZAlLTBuqXhM6S6o8Kq7oGNMVmOHwd6VQAmy0m0fxkaz1X4x59L8O4BvvAhc/rjjMSXIa3ORyfKiu6CrogIT88SH2XEPQZZzdqzTaOmXqeproCBrny0gGOWmXHfUdhccZJBV0tiJToMFeo2M8TmJ9kyW0WxFj6fXmB/Jsoy3dosCI9Wt3TCaHd1hzRar/aYA4LgRUNIg3iuFGQmus1h7XgbeuKV3Rts4+O6CcXqt/Tjuugx+fdLRTcnvlcBc3aX3kdUqR3wZ6F5BFgB89Sjw/yYC/7lIZLGULM+xDwGrm27XrihZLEnruKgbbHVBJTul0Tt6GvSljMly/nsrwUNCpiPIOvkZULpZ3NmfaJuEV+lCGAGO17ThR6vF3+zm0eI9X6kfCRkaNHT0uSmY4CLb29Tnpk0IdRe0jy8eIMhSCl9UtnT36jWypbghaJ/RIUPJThXMcjyWbZscXil6oXwXKpMUp+Q7ugtyTBYF09biBsgysOuMipXElFR+Yg6g837eGrdUGJelObkOACAXzhdznACO7oIKd3csnThnsmpaHReHibZgKDFGC71WDO5v9pSpkSRg2jW9J150ri5ocN1dsG9gYjRb7cfxFGR5ymT17XY2UDar09j7S6PZaa6s9h4T9pSK1+qFE1yX4XYuUOCuW5dP7N0FIzPIOlQh7sYPTwR0Wg2SYnRQ6ke0B6nL4M6SJnvQZJXR625t3zYoGcozthsSyjwy/Xz9V+DYR0D5DsdjQ+guCDiPy3J9Xr4+6bi483+QpWQ2BhdkybKMG/6zHUv+trFfxc5IItUeEivD54tl5R6Ryag/Drx+k2PD9urer42BKJUF49NFRTNg8JksJWBLyADcFWtRMlnO32PKZ1Fitij4pE9w9AKZerXjBl8EBVn3vXEA7QYzFozOwDdHis+2+ngxzriuvc93iasbEc5FLwDHlBwhoGmAyoKKYbbugtWtvbsL9pis2O7FXJURxd6zxOn7OGs8cMNrwHUviZ9jnao4504HcqaIzwEA4+r9PE4zwBhkhbnKFvEh1S/tHkzNYt4lv83Ebu8WF7zugpISZI1f4XgwIUN03VOkeM5kdRjMve7MVdmCrDi9BjqteKtJkmSfOLjZxUS9HiXlirudVhMKekQa3dFd0BZk9QnclPKyOo1k38bZJG+CrD6B24BBVr9MluP5W4qbYLHKGJOViBFuMllKwCjLfgoSwqa74OAKXxy0BVmFiSIg1Wgk+xjAYHUZfGN3ea+fS5t6j0101tItusoqQdnoLBdBltXiuGOtjPcEnLoL+p7JAhzjslydl8YOAw5XOu6S1ve9AByqIVYX3F/egp0lTThd34kyp7GfkcaeyTrnbsckpMqdbqULuTLtx9H3vd+xc2A0hEqeAJwCtgz32yjZstZKRyEL5+6CuhigcIFj+7Pvcvw/IyTIkmUZp+rE+/exa2dA1yDm7+tIGQ9AjFHqRfmMdi58oZRvzxTPCc3ugp5vLucmx0KrkWCyyNhf3gIAiLdNvxJ1XQa7nLK5ziatBHImi3Xn+xbn3yduZIxZBAAwaIc47j/IGGSFucpm8WWrFDdQRZMtyEr3U5CldL8YyqBkX/S0QbLNPm51DrIkqXc2a4BMVt8LnxrbBKvKBa8ifbDd4XQxwOQrAABXGj4A4Fxd0DYmq88+lbvxWUmx0Gj633GdaKswWFzf0auLl7O+F6QDFb/oV/jCqbvgJlt3rAsnug94YnVa+xfQkLsMyrJTd8FQL3zhdOHnQ5ewQ5UtAIARSY7nKBmbYGSyzBYr1tjmWstPFeP+eo1NtGWNkm3vA9GN0eo5yOqoBay2titz8AGOTNYguyV7qjC4uc+k3IHrLtjgWzc3m08OOjIi/bpZRQitxeDoTjRioeguff79wA82iTEcgCgAtPwPYv3Q28C7PwD2/m/gnTsHRsrNM39kstxRvi/M3Y5jO2eyAGDMhWJZuAAYNtcRZLWU9X7dhymD2QqjRbzWs5Jj7WPNNHlTAQBn+t4sUD6jnefJUroLjjpPLEOou6AyEbG76UgUOq0GeSnis/FwpXjNXTZD3LRVtReSGtwFWc5qDjnWp1wpluf9BOZL/4GNEx8JXNsCgEFWGGvvMdm7cqk6k7g9kzXGP/sb6hegr0o2QbKa0BGb67hbplDGZWn0A3Y3c54jCwCqbVnGxD5BVpo3FQbdWbgKALDcuhnZaOlXwr21u3dBDU/jsQCgIDUOyXE6mK0yTjd0uNxGCXQKbBfQNQNksrr6FBVQMnay7AiyFk103VVQYS9+0T3Ei0ljp7jIAcKnuyDk3tkbD8wWqz37omSyADiKX/hrXJsH7T1m9JjEhdSyKWIcSrlTkNVuC9LzUuOcusoaccYWZI1yFWQ5dwnqlcka/JgsAB4rLyqVDs8eIy6c/V74Qnn9yRag27cLK6tVtgeygCND7Q8vbinBlU9uRqOaN+psUnrKIUEWWfukHGDWjcCSB0U39Mv/IboOLXkQGL9M3JToagAOvg58ct/AExc7B0ZD/Y5x7nroji7WMS6r1Zbp7exzgTn/B8DiXwPXPCt+Tsx0BGANJwbXthCifP5oJCBRY7IHTEkjpgPoPYYZgOP/bupyBJlKd0Gl3HdXQ9ArD7vj7ZgswFH8wmzrAn/eePF5UNUaZWXcvQmyLviZWF79jCiEAQBaPeRZt6A7NsR7pPQRlCBr1KhR+O1vf4uysrJgHC5qVLU4PmgaXHxBWq0y9pU1w2Tx/a6pT5rOiKW/ugsGO8iydT9ojR/Z/3dKhcHkPEDj+e2ilG9XAh9lDpDEGNeZLI9jstwZfhbk4fMRAzNu0a3vV7XQYpV7ZZIGCrIkSbJPlFjlpoy7kokYnyuCgIG6C3bY5snKTRHHVP6fVV2iolycXoMFoz3cAYYfi18o3U50cUMvyhJo+ngxKB/wustgcX0nuk0WJMZokeMUdwQzk6W83uL1WoyxBUxljf27C6bE65Fqq4LZ1Gm0v1/GuAqy2ioc68ocfBazo8rYoMdkifdL3yqclS3d+OyoCLLuvFC85xs6DP4ZE6jQxYjqqYDPXQb3lbfYux8Djjvo/vD85hIcqGjFTn+XrB+E1G7bNULe9P6/zJsO3LVZBF66WHEBNudbACTxuuhs6P8cZ70yWbas8WALXyhBsqdMFuDUZdD2eu6byYpJAC74P0f3R8Cpy2DR4NoWQpzf+1LDSUC2AnFpGDZsFADRrbjXeywmSZS3B2wZX6fy7cPmOt737aGRzXJVXVA68BrwyU/7Bf3KuCzFvFHitdPSZVK/QnQw2YMsDzc9Fz0A3F8EzLwhOG0KoKAEWffeey/effddjBkzBsuWLcPrr78Og0H9u2bhrrLFcSHT0GHsd0Hw8EdHcPW/t+KVQM8s3uzn7oLBDrJsX7QmrYu748oXXpqLAKwPZRzKlPyUXo8rExEr7OXWfR2TZWOeLyYr/p52DRI6xd82Tq9FrK1yWpPTfpXgOzvJfZ/xgealUr4ox+eIvtADdRdUvjAK08UXonJBe6xFZDEWjslEnN79nCKAI8hydfPAJ51O47HcDVAPFZLkGJA/wAWjxSrjzd3leHqjuDM8pSAFzr1BPY098jflGElxOvs4u1IX3QVT4nT2v+vR6jYYLVbEaDX2ylu9tDoFWcodbbPTTYBBBlk5ySIb2zfz/79tpbDKwLnjMnHOWPHlb7LILqt1DomS2XAu6+2Fjw/2vqj0V9aprcdkH4gfrCIpniQYbEFI36JDrkxaCVzxuCNgGWjKD/vFnT8zWT4GWc5jstzJFpOJR8K4LOU7JSVO7yhLnzMF+Wnx0GslGM3W3j0jJKl3t9rWchFAa2PEuVQq7IZI8Qul8IVzd0Htht8Bu/7jmHDXpiDNMYVKcqwOBWnx9h4H7m5wRhyLGehuEeueMlkajWNsfpgLWpC1f/9+7Ny5E5MnT8Y999yD/Px83H333di7d28wmhCRKp0yWRZr7wuCw5Wt9klBD1UGMFgx9Tj6SIdrJss2+NmscXGxN+lSYPFvgBV/GHA3ShepqQV9g6w+3QUTh5DJAtAx5lJss0xBomRA0sc/FB9ccIxtOVHbgdYuEx764DDe3Se+jNxlsgDniYz7X2T1mCz2sVoTvMxkKd0FlTt3StB3rEV83AzUVdD5WEer+t9prm7txktbSryrsKbiRMRtPSb87O0DWH/UhwvqtBFi2eI56/9VUR1+9vZBvGf7+84Y1vs1l2zPZAU+yOqwXZwnx+kwIkO8BsubuuzdVp3vZitZXGXw94jMBGhdjBV02V1QKd8OadBVTJUxY9VOWaEekwWv7xLn+1sLRyFGp7G30+/dsJXiOT5MT2E0W/HRAfEZO832d24Y5A2avo5XOzKmwSqS0tZjwqs7Sl0GinGmFrHixXQZdsm2wLV9gPeZUnY9KReItX3HDLbwhTdjsgAg1TbJat/ugp6K8ERSJsv2nZIarwfqlSBrMnRajf0m3Jl+XQZtAWhXg6OrYPoo0W3MPo1JaGSymjqMSEIXJp94Gmg8BclqhqRkqUu39dp2WJrjxpByY2mYU2n3qNDTAvu8o5662kaQoI7JmjNnDh5//HFUVVXhoYcewnPPPYd58+Zh1qxZeOGFFyJ+/g9/61uZR7kgsFplPPjBYfvY+X4VfPyppRSALPrH++tCNuhBlrjQMGld3B3X6oELftp7Tgc3lPM/Lrf3hMx9g6x0pUjFYMZkAegyy7jfdCfa5ARIlbuBnc8AENkMQAQmr+0qw8vbSnG6XnyBjcl231VO6VrmKpOlXHhpJMc+BhqTpXQXVGa5b+sxo6XLhNO267lFHopeKKYPE68BpXKeQpZl3PXKXjz80VF8fMCLC1Vv7hwHyH82ncabuyvwt/U+jK1QMqYtnrPPStGIERkJuHF+Ib61sHemNcU+Jivw2QklA5Icq7P/zTsMZvtNBGX8U0qco7ugY640N6/LNheZLOfy7YPMSua6GFf4xbE6tHSZMDw9Hksmiwt25aaE34OsQUxP8eXxWjR0GJGdHItrZovMiL8yWceqHUFGsDJZf1lbhF+9dxjXPrUVFc29Cx/EmWzd8HwJsrzNDiq/T8pRL5PlzU0fJZMVARMSO26w6JwyWaKCnNJNvbRf8QunubKUIijK2GilmEgIVBiUZRmNnUZcrt2G/L1/g3bTY4g1O72eyvoEWU7dBZV1xyTFXo4x2/RX4J07Bh5/GKqUbHJcGqDVedw0UgQ1yDKZTHjzzTdxxRVX4P7778dZZ52F5557Dtdeey1++ctf4uabbw5mc8Je3xSzckHw+bFa7LVdxAABHljpfKfJX92xlHELwc5kaeMG2NAzpWvb2D5jTJLcjMkabFekLoMZVcjCM5rrxQMnPwPg6KZ4tLoVu8+Ii4ArZhbg3zfPweUzC9zuz1N3QWXgcnKcHvm2L4Tath6PY1WU7oLOd+4+PVIDqyxhVGYCRrq7sHYyY3gaAJGRdT7W9tNN9ixItTev675jIIKkw2DGf7eJQKnvhaRH6bZgqdlzkKXMwbZiai4evWaGPUOjCGomy6BksvSI02vtVbSUQe2O15Cju6BycT86y023v17dBW2ZLKV8e8zgugoCjkyW8xx2Sqb/wgnZ9qyaEmT1m8dnqAYRZL2+S2RBvjF3OPJs7ffXmKxgB1ldRrM9+3qmsQvXPb0NdU4BryPI8qGrUJJt24G6C9ozWTmOMVmGNrcXrLIs46mvivH6zrL+N4C9zmQ5BVnORXg8fR4p3e5bK3yqMhqK2np1FzwqHsyZAgD27wGlAI6d81xZSuViZWx0CGWyuowWGMxWZMN2ndJ8BvFKJhYAKnYDZsf7dJhTd0Gl62CBPcjy4rvMagU2/n/23jvOjepcH39m1Otqe6/uvdtgU4zppoZAeoHkJr8UIDeQ3IR803NJuekkpCekEEhCAgkhxmCKMS5g3HtZ2+vtfbWrXuf3xzlnZjQa1ZW22Ho+n/1IK42k0WjmnPO+z/M+7/8Bh/8G9B0d9/5PCtIxvbjAMCFB1r59+2IkggsWLMCRI0ewfft23HPPPfjSl76El156Cc8888xE7M4FAyXFzBb5T+0lC5Rb6cK6x+lHJJcF3HKwQTBXUkFg0pissFpNVpqIRAVRFtesYI1y6i4IMrgDwDHdQvJA9wFAEEQm62j3mNjw9551Tdi4qBo6TeJL3Z4kyBpl9TQmLSpsBnAcqVUZSiJXYkGW3aQVGZWn9pKF1RWz0mOUZpRbYNJp4AlGYlwPf7ntjHjfmY7cktU2TfCg/pfd7eLxdPnD6Uux0mSy+mhCpdKunhiQarImgsmiNVn0PGd1WczGXS4XVPZqW1hbBFXEyAWVTFb21ykLAHvH/OLC+RgNNObLZL6JarfGjQwXid1OH7adIomCd6ysF13Mkl1/meC4rD/eRATkzx3qgTsQRl2xCS1lFvSM+vGrbVKz2ZzLBbv2Al20JMEjlwvK5LUJTGbODXrwnc0n8PmnD+Mjf9wT24MwYyarQ0z4RHgDnjmaxF2S1WVGQ1JiYZqCjT9lupAkgaZMVlNpArkgu0aGzkj27Wx9odZHa5LAEh3FGjIucWNdMMiDrLAP6Dko/iuvPWUJyJpM5ILeQSBCxyN5Emo6oRBk5QerVq3C6dOn8fOf/xxdXV343ve+h7lz58Zs09zcjHe9a/o7iUwkmAyQDVYDrgCG3AGxud0nrpoBLc8hHBVyn5FlyLXpBSAFWYGxrPrJZIxkcsE0MewJIioQMq/cahAdBgHAqjC+kOSCWdZk0SCm19BMCoL9TmCkTWSyOkd8GPGGYNDyWFCTYBErg1STlVguaDfqoNPwqKAZfjkToIQnKLkqsgX3YWozfuXs9IIsrYYX60+YZPB4zxi2nhwQt0mLCVTrLp9nRKMCfrv9XMxjaRc2p8lk9dHjnyjImkgmyxWQarIAImEEpBpFyfhCJ+4XQJJANy9WYVjDgVj3PZHJkskFs0QFdbwMhqOinJGxOXLDGonJypdcML1G6/851IOoAKxuLkFzmQWl1MBm3IYwIImhk70Ty2Q9uZsstN+zpgFfumW++NioLwQE3dBF6XWSCyZr4CTw2+uAP9xCEnbMEdBSAeiMgI4mwxKYzPTJDH5eOt6Pb2+WyffSZrJojaW7D2P95JrujVjx6b8dSszE662Sy2iqRKO7n0jIUtWjTRJYoqmBp/tnLhWPWSNVfMTJBWtXkNuuvfFyQeZIx8b1SQRro1Cho3OhZwDm4EDsRu07xbtmvVZ0IWRMFpMNphVksbo+oBBkTSNMSJB19uxZbN68GXfddRd0Op3qNhaLBY899thE7M4FgVAkij4aOC2tdwAgE++/DnQjHBWwuK4Ic6vsorwkb+41eWGy2GJHyL4wORMwJkvN+CJNsEVPiVkPrYYX65wANSaLGV9kl41mr7NZLaL0Aj0H4DDrxV5WALCkzgG9NvUlnozJipF7AKgqovKGJFI9D63Jshi0+Nl7VuByyl6ZNQJWN6Vf7Lqo1gFACrL+QRla9p3SY7JYDcTEBVlDniB6Rv3gOMmRMe3rz9FEbp3nk0qF2LVfVZSAyRKb7k5cTZaVBlmsdm83bbLpktVlrGouhobncMeyWvzgHUvUTS+ULE9AIRccB5Nl0GpENqh31I9+lx8DrgA4DphTJdVSVkyRmqxzNMt/SQtZlJRRFzOXP5ye8UsStA15xP5mAOAK5Dcgb+13YX+7E1qew50r6rB+djlmV1rhCUZI8EVrpgSdRdYzLg1YqZGOMtB48UukoXXQTaRbAMBrpYJ7xpgksANX9iIT60MjYSn4ScVkmUsALTlfX311C3lfQUqGqYLj0ldz7Pgx8Mo3gDceTb7dJIHNHxVwkgdsUlKF1WO2DXli5Zis6XT/cSmJy+SCLKhlTOIkgilXSnjyO3IQ4PC2kSc11G1QYX6xuK4IHCcx+ExCmNb8IA+s5AHXdEDfUaDn0KQpSyYTExJkXXXVVRgais88OJ1OtLTkqIHtRYbeUT8EgSw451SRQXvAFcA/9pEL8e3LiUyB0dEJB/TxIBoBeg+R++lY7qYLrUGcmCZEMuhnNVnjD7LKaKaZZfUBlSBLxhxlY/bCmvuWmPVAzTLyYPcBALGSpxVpBjRJa7L84Zhtqu3xNS1KMKbNYtCgodSMP35oNR7/0ErctzCS0rpdjsV1zPzCCUEQ8NJxsoi6YUEV3d80glQ2qE9gTZZb1h+NNdpN23zGUQ+AI6xNggy7IAji8a+0JWKyJs7CXXIXJOfITYtIIPH66QF0OX3iOWQz6rB2RhkOf/U6/OCdS6FNJGFVZmnj5ILj63dWJZpf+HCcuus1l1lgltVO5q0myy5jstIoXmeMJaslsxt10NLAdHickkF5PRaQfybrGD3WyxocqLAZwXEcPnI5mf8f23EOUea4aKvKrL6XsV5y44szrwCnX5D+Z0GWpVzqd5hCusmOL+vjJjbY9juljVI5pHGcKBm0jZA6mmEaZPWO+uENhvHb7efi6zbFIMuJpKDjPgZPJ99uksDGnzLOSR5gATGI6YOG5+APRfGJP+/D3/bQwMFWSV1WBRIka/SS4QVbnKfqiTYBYJJdBy/9dsVeyrzNuJrctu+KUeP87L3L8dpnrsKMcpJ8Y+uz3tE0SjpigqxpxGQFvcDvbgQeu1EKmlMxwBcQJiTIamtrQyQSP6EEAgF0dU2+S8x0BKOXa4qMYtZ1d9swjnaPQafhxHqsukzdazJB23YysRkdQN3q3L73RNZlBVifrOyNL8Qgy0YyWHZZ7YlVEWSx56IC4AmqL7S8wTDufWIfnj8cn/Ee9pCJq9iil1wPu/cDiJU8rWjILMhSW2SJTBat8al2xFtgx+07DTLY9+Y4DmuaS1CTocqLBVlHu8dwss+FtiEv9BpeNPFIywJ/EuSCHlmQKVn0pnn9aQ0S25GgLmvUF0KA2uoz+ZsS9iS/aa7BmCob/b0bSy24pKUEggD8fU+njA0lz5sVRjBxYM5hrG6GBVnB8ddkAbK6rNGAqlQQyKO7oKUC4HhAiEgsaxKw64wFhjzPiZKj8ZpfHKESXsY85vtcYY6IFTKJ661La6DX8OgbC2Csn0gJhUz748jdBVnS6rX/i92mczfdVtY+IoVTHTu+S6hSZMwfJokoxqIYitJzSKNBVnOQBEI+PRmXe0f9+Me+LnzjuWP40UuKICmd+U8QgL7D5P7wucTbTSIYk+6IUKkm+61AEsQz6Ln3/JFefOHpw/CH6HxYt0p6k+JmYt8OyOzdhybdFIQF4TZINWXWAA30Z19HZM1+JzAoWfGbZRJ6gNR+atIt6ZiuQVbvISAwShjlM1vJYwUmKzd49tln8eyzzwIAXnjhBfH/Z599Fs888wy+8Y1voKmpKZ+7cMGCZcZri03igoCxVZfOKCMLcMgLKzNwOEsXh58itwtuB7T6pJtmjIkKsgRBZnyRfa0HW4ylw2QZtDz0NIuvVgcFAJuP9OK5Qz34vxfie6UwuWCJRQdULyUP9hyMMb8AgOWNOWCyFHJBqc+QD95gGEe7Y3+faFQQA8eUi+kUaCq1oMxqQCAcxX1PkCDykhmlYuCSUi4oCJPSJ8stCzKz6oMi1mW1qT7NakUcZl1CZnBCmSxFTRYAvHMV6Q/0+JvnMUAX13aTulQ8DmwBways42qyxhlkiQ6DPrEP2zxFkFWRr5osjZYEWkBakkFmNS93j8xVXdbrp8m1cfVcsj/5D7LIuFVmkeYKg1YjyqeDI/R4WLMMssJ+Ml8EXEAHDarm3UpuRSZLHmQlZ7KYXLCu2CRKTDtHvLJ6rDSlzyzIEghTo7ESVr13zI8z/eTcjpOLMfOLZPPfaIf0/EjbpAcdahCbEUfoMZMHuQB++p7l+MLGubAZtAhHBbE1RUyQxaSCgCTPjIYmppQgCViQZRXc8U8WNQB1VPZ4fmf88xQanhOTPiklg9MoyOod9ePHL50mgSMzngGk1hyFICs3uP3223H77beD4zh88IMfFP+//fbb8a53vQtbtmzB97///XzuwgULafI1iQt7husXSNkiVliZcyYrHACOkQAaC+9Ez6gvoYTMHQirLuCTgtVl5TvICvlIVhlAaFw1WXQBQX+L2Jqs2IUwx3Ey9zf148L6W50b9MSZF7DBvdisJzVZMvOLVU0lcJh1uGxmmZjxTgXGMLgDYYQjsUYjcmc4QKrJ6hn14xvPHcNNj2zHi0elgnNvSGLmlAxepuB5Dp+5bjYA4DRdjFwzr0JclI36gsnllkEPWXgBEysX9MuCLPH6yyDISuEwyK79qgSmF4B0/rkD4aR2+7nAmKImCwBuXFgNm1GLAVcAwXAUVXajGHCmfkPKLMiDLEGQWbiPUy4ocxg8ruIsCEhsi8sfFpnJnCHNhsT+UES81uW/NavLGg+T1Tfmx9HuMXAcRPORfJuksKClVDFfsXGKyQUzZrL0Zon1dPcB7W+QMb24CWi6jDzOZHcyJiVduWCpRY860czFl76zIANrLkxhdJDv1zvmFyWIcb8lSzL6nInft/ewdD/sS90nbBLA5g9LkCoK5McfpOn8R6+Ygdm0HpKN8zFBVomspERvloxvJtn8gv1mpohKkGWrBBrWkvuKfllKSOYXGTBZrh4gMjHNw7PBr7adxQ9fOoU/7jwPdO+L32AS+lZOFvIaZEWjUUSjUTQ0NKC/v1/8PxqNIhAI4OTJk7j55pvzuQsXLLplckHGZAFEAn7tfGkgE5msXNdknd5CKGBbDfw1a3DTI9tx0yOvxwVT0aiAmx55HRu+txW+BNI4VUwUk0WzYQLHI8KrS6/SwWASJkst2EhlTCC3LWd1IwwSk6UnDGLlAvJEzwGUWg3Y+fkN+O3dK9PedznDoMxmS85w5DvUyJisl44TB7jnDkmLRSYV5DnAqBv/8PKOlfVY3uAQ/796XqUYZIUigmhnr4qhVnJrKh73wjwTiO6KBm12118Kh8G+seTOgoB0/gmC5P6XLyhrsgDAqNPgwWtno7nMggevnY0XH7gi/Xo8xj4yx9JoGIgEc85knRv04MwAuc4WKJgsu1EnBjOt/SqLqPGAFf8nMFxgYL+zUceLbDMgjTFKY4ZMsPUkuXYX1zlEA4JAOIpgOH9uriwRVWqNTf6w65lj7oCZMllArGSw7XVyv+kyKWEhbidLtjB79QRyQba/JVaD2GQ7lslKMxu/8h74Z9wo/msvI0F236gfHbQWK+63TGf+6z0S+/8UlAwyJYQxSGuoFEwWAzMIEq+1qkWSeUSJom5fdBicXPOLYU8AHKLQRzzxT9qqgcZLyf3zKYKsdHtlxbBXwpToFZYIrXRc7RjxxjJZDAUmK7c4d+4cysounsh1ItAravVNKLHowUy6ltU7xB4vAGLkStmYLCTEmZfJ7fzb0OEMYNgTxJAniKf2xLre9LsCOD/kxZAnKPajSQsTFmTRAMZgG1czZSaJYgGvPHBRk82Jcq4EDB9jsgDSkFcOkcliTFUZYXuYvMys18KgTd9gQqfhYaGW88ogmWUii8yMySLnVsewT5RIvnZqQCzalUwvtOBy0Jya5zn87+2LYNFrsG4mkQqadBpRbpnUxp1leqsW5a5RdhpQkwv2ufwIRdJcwKZgsiT79sRJAaNOI7ow5puhYK50ymTC3eua8epn1uO+q2fFMLsp4aEZ6uIm6bGgJycW7oB0Dr/VNoKoQORg8kQVw6wKkl0/1afeRylryM0vkqB3VFIryK+l0hzUZL16ggSyV80pj2Eg83musJqsUos6k6X1UnfBTHpkMTD2y9UHnGNB1uVSwoJBjckaVQ+y2DhbZtGjvpicc50jMiYr3eJ9vQXnrv4lvhi6By9zlwCzrwdA1AAdwz7xs2IYZ6OD3CYzvmCmUwwJ5MVqCEWi2HykZ9zmKckg7H8cf498Ci1cN/Q+mjhRMFkMM8Ugi15rWgPQsh4AB9Qr6r3ZcZ9k84shTxA2eMEhdl0l8FrCctauJFb8Y52AM7EbYJVKg/Q4hPxSWwtmtjKFHQbFRvQjg1KvMzkuoiBrfHqeJHjkkUfw0Y9+FEajEY888kjSbe+///587cYFix6Z65SG51BiMWDQHcD1C2KzgKwfgzsQxpg/HJMRHReY1KV8Tky9yWM72nD32ibROUzeaPBY9yhWpFknFNMrK59g76/PwDJYBZJckCwYUjJZzGFQtqg53jOGU30u3LK4RtKmAziiqHuKcRcEqBMTpGaPWaDIpIMnGIkLshhrxs6bSrsRHBcr/x/1hXCgYwQrGksk+/Zx1mPJMb/Gjp0PXQ0TZUI4jkORWYcBVwBObzCxDE0MshbnbF/SgVwuWGrRQ6/lEQxH0TvqR31JGgFCKibLlVouCBD2cdAdJGxk+s75GYN9X7sxR7+5V5b11hqJ5DPozomFOxBb3wQAd69tUk0IzK60YtfZIUnClCuwgCCFXDCRLFSqycpugRwMR7G9lRzjq+ZUQMNzsOhJ42+XPxwn58sVlGMkA2vObmQL8UzlgoC0eB86DfQcIPebLot3/1MzvvAOkkWsLvY4ixbdVj3qS8g51zHsBcwZygVBTHoej1yLN21vw2MVNQBOxsybUYEkjESJd1pMFh3fSlqA4bOSc1sa+M+hHvz3Xw/gHSvr8H93Lkn7dZkgevCvmMF143p+DzReGiAk+G1nKpksALjjV+QaqZwfu7Hc/GISMeQOws6p1LpbK4mDpcEKVC8hcrn2XdQ5Nh4saZI04GVsq9ZEkobntk3ZuqxQJCr6A5SMHiMPOhqJvJGx9xeRu2Degqwf/vCHeO973wuj0Ygf/vCHCbfjOK4QZGUB1siQub1dO78Sr5zow21La2O2Yw3whj1BdI34chdkMf23tTKm3qvL6cOWY324kdo4t8saDR7tnuJM1jigtHBPVpMlf14uz3vwbwdxrGcM/lBEdI8DgKNdscdtWC4XBIAiOngnyZalgt2kQ/eoPy7IGlLUmuk0PMqthjhDgK0nB0iQJUrl0mfS0oHyvC2mQdZoMvMLOZM1gfDI2Dye51DrMOHcoAddTl96QRZjskY7ic03H3sse0fjXdrUYDfqMOgOpsVOBMIRnB/yQstzaCgxJ7ZXV0AQhLg+WeOG2EuljDRmDftJr6wcMVlymaXNoBVNOpSYVZmYyQpHoogIQkaMsfSh6ckFlc6CDExul61ccH/7CNyBMEoteiyi/XpsRp0YZOULIpOlCOKKzToAgtjIVchGLsgW70f/CQhRIjVlckBLuSRBlRtfmIqlIN7VE9PrMRIVxARTqcWAOjmTVZIhkwVpzC626Kl9fbxPxZA7oBJkOdXf0D8qMd3zbiH9sjKQC56k53TbYG4MsX617Qx6Rv343A1zRVlw1NUHDYDFmnPg2DybSC5Ir7Vzgx6EI1Ey/piK1S3yGQsyyUHWsCeIFsjaSoRIYlSwVkFM2TSuJUHW+Z3A4neovg/7zZP2zWRBVlGd1OB6ijJZnSM+UdlS4z1O9HK1y0kiw9VN2D1D0eTu5AQib3LBc+fOobS0VLyf6O/s2bP52oULFv5QRLSvrraTDNu37liENx66WrU5abWsL0zO4KaZKWulqCVmEq4ndkuMipzJmpJBFu2RJYwjyIpGBTELxWRHMe6CKqyOaHxBg5poVBB1zL95nUyWxVSi1zrgFq1tfcGI2EBUlAuyDNk4mCw1Zk0QBDHIkptoyJmA62j936u0xsOjsG/PFxwmsj8J5YKCAPTRmoUJDrLclM1jQUdNJg0nASJj4nXEQUtFd9+fJpMlOQymXji/45dv4LofbsOG77+G9/7mzfT2E6SOJ0wnVFsmksBEiEYAH7V7tpRJtXRBj8zCfXxBls2oE8/P96xpSLjfs+nC73RfLJMlCALe9rOd2PC917JrCJyhXFA5picyvnhydzu++uzRlEYnbJxZUu8AT3Xm7FzNl1zQF4yIrqPKmqxisx52eKAXaNCYQFKWFGzxzuyymy+XnpPVZX38X5144yxdnHNcQvOLEW9QDIKKzTrU05qsjhEvIkzOmqpHVsz7keNaYibMtlIyCSiYSfbeiea/PtJzC/Y6qVdiBnJBxjQMjNOhEiDrkW8/f4KoWB7bLcqleZqIvYQ/TjbUGiWDEgVqioww6zUIRQScH04R+IlB1uTJBX3BCHyhCOwcXd8U1UFgY5X8/GUOg2wuUkFxOkwWY62K6qTkwRRlsuRrvvkCrYuuWSa1mzGXSL3qLgJcPN/0AgKbfM16jbhYB5CwBkZyGstiQaAGQZAxWRXi4vHqeWSikxs1yAfMk72u9OtSJpzJUh/808GINyhmblgwwoIWs14jLmTkEI0v6KJmwB0Qi86ZPGl1cwnKrHpEogJO9JL9ZBlRvayOSmI+OrK28VWzcXcFwgjS30u+KKgukuRaD1D3vyNdY+hy+sQJdrz27Sn3lwagCW3cneeJFFSjl2rWJghuRY1SbabmF7xGmkhVAmexEXEqJkvslZV84dzl9OFgh1P8f1/7SNr1m+z85TjAnEGj6YTwDgOsxsFUQpgsIKdyQQC4fkEVah0mfOiy5oTbzK4kny0/rwHCPh/uGkWX04fzQ1kwAazmKEXheq+iETED+93PDXpEM6FQJIqvPnsUv9/Zhr3tI0nfl52HzMwByCwgzwaMddNreLGfGkOxWY9K2qw2qLFk9/vaZQoOex2wVqaOkdVl7ejl8e+D3fGvU/wWLIAtNuug1fCiA5w3GMGR1jYAwGDUmvbujYh1tKy2NT7Iillkp5r/GGtVNksyiMlALthFDTdy0QeuZ9QPFte/cXYY//P3g0A4AE3ACQAoBk2uWisS1sZyHCdKBpVJjThMASZLdMrk6ZhkcojnUow7JjPtSMIyFlO57MiFEmTJSh1mcZSBq1oE1Cwn97NhqqcxJiTIevvb347vfOc7cY//3//9H+66666J2IULCt1UKlhVZEzLXIBJt7y5chnzjZAsOwBYK0Rt+bqZRCs96A6Ii6/zsqxGMBIV3bxSYsKDrPQnTCVYNrDYrIOOsnksiFL2yGIQmSPq3tc5Er9Yaym3YkENOQ7M/EI+WYu/PVsohLxZOy6x/ZUHWcN0oWHRa2DSSwtolllvKjVjbpUda2eQSe/X286K5iY5k6UmgIO+f0KJBZMKVswDNPndFyWkujRyzFjRfFsmC3K2MFSYX4QjUVGaWqmyUJMjlbkKw64zZLEyhzI3KV0bZZDXn6klEzIGy06biklPKTmTxeSCOXCK/P47lmD7565KGqg6zHqRmZbXirBaKSBL19aiegAckYIlKd7vSVCTNa/KjvoSE9yBMJ4/Quq6TvS4RInxyd7kRh1svJbXMtqM6QXk2WJIVo+lnLNKLHo0cCRp59NlWasx+wYSWN3+c+D+/ST4YKBJqBC0GIMl1pI/QUNitohmSTODViMazRhCZCw+PBy/fPrzm+fx/t++mbztBtRZ6Bj5ZyoLdyYVc9RLBjGeAWk+SwF2DrgDYXiD41sXsGuAXf67z42oN9pOwVDOLFeYXySCGGRNnrug2FrBQH8zYxEEJgOWf08WAHsHE/42rLZ6JJn0nf3eRfWyBNzUkgv6QxF4g2FZ4klAHcecYpuAmVcDV34euOGbk7WLk4IJCbK2bduGjRs3xj1+4403Ytu2bROxCxcUEmU4E4GxCu5cBVlMKmh0AFqDGPTNqbKJTTzPDXggCIJ4wbHiTmV9UUKk0qRni7OvAX/7AHGhAqSBbxzGF4Ou2LolAFhYa8fls8pw99om1dfYFc1iO1UWay1lFiyuI8dh73mSnVZO1gBIwTYb2BM40qVCkSLoA2QLDYW8h2Uc19Kg+hPrZwIgcqXHtrcBAG5fVpPVfqQLqVdWgolpkuqxAJm7IF24xjlnpQPGTirML5gjnl7Do0xFciSHWt2fGliQtWFeRXqujTKw91ayE1lDXo8FSMmPoDtnFu4M6SSoGJslr8vqHZMWw52Z9D9jMFil+h95ryMFemXJNDl4nsM7VxKJ8F/eIgutAx0Se6UWZP3k5dN42892wOUPiWNNrQqTla+arEQ9sgByLc+mGe8xU112H2CwAtd9A1j6HtLWQg6asBgQigBwomwRgCQXPPoM8IMFwDfrgJ+sQKCXyA7lDH59sRkcoqjnyPy33xkb7AfCRDb3+ulBvHYqNsgYUdTRyoN7xnjHyAVTJRnli26TQ5IXJjDLid3PaExNLZu/skWXk1yXTF474g1CUJPCpgqyKlXML9TAgqxJdBccYkGWnl7/RgeEWdchzOshNF4mbWi0S/ubQM7J2E1fKJK4zQ0zybHXUGUGR6SxSRodTyT8oQiu+t5W3PKT7eL4U4YxGLkQBHCEXeY1wFUPAc1XTPLeTiwmJMhyu93Q6+Mbo+p0OoyNTW7X7umIHpm1bzoQmaxM+lQlg8z0IhIVxKCvxmFCcxmZeM4OujHiDYmT9nW0QXLadVmihW2OmaxdPwWO/Yv8AaTXFwDBmL1cUGl6AZDM558+vAafvGqm6muUNVBs4SNf97WUW3FJCxmgd7QOQhCEuMlahGN8xbBqckGxr41iMX/nijo8+p7l+J/rSbPYdTNLsaTeQfrsRKK4fFZZnMtlrsEcyZwyJqt9yCvVyEySsyAgt3An190s2eIh7TYKKkxWMBzFl/5FtP1vX1GbkjliC+dkjcAFQRBrVC5tKZXJMNNbeLHvmpN6LECSADEHMZHJyq1cMF0wG/fT8iBrdJxMFiAF//JaDc8g0LkXAGEsmZRLrc72zhX14Dlg97lhnB1wY3+7U3xOLcj6y1sd2N/uxI7WIZlcUKpts+c5yErUIwsgY9lsnoxbLmNt3PPjRvVSAMDpKHnvWCaLBlk9B4jVdtAFDLXCcfa5uP1tLrOgBkOwcAEEBQ1eHYhVP+xoHRSPX4+isWwyJosl0obk9VFs/guMAVEVib1cPgZIbFYadVm9o/4YVfmAO0UT3BRg5xNTXUSiArzDKlLYBKYXDM20X1tHqmtqCrgLisysjh47YxGiqz6K/yz+FYT6NbEbMzYrgWTQatBCpyFjeUJlhrw3W1EtsOKD5P//fAaI5LcPYjo4M+BGz6gfZwY82EXnkxVFZK3n1lfEJz4uIkxIkLVo0SL89a9/jXv8L3/5C+bPn6/yigKSQXQWTJPJYsYLnnHKAkSIphcVGHQHEIoI4Dmg0mZAC6X8zw14RKlgdZERyxpIpu1od5pBU77kgmzfmTwkF0yWokdWOlA2I2ZywQ1zpIloRrkFKxqLodfy6HcFcGbAHd8ji2GcDoNFpnhpmdgnRrEwMuo0uGlxtRjocByHe2kwqdNw+NqtC3LSIyv5/sbWZL16sh9XfPdVfPv5E2SDwVPktnxuXvdDDXJ3QQBoLLVAy5MMek+yXihyqDBZv379LFr73Siz6vG5G1J/r6oiqVg/ETqGfehy+qDTcFjZVCzKMBPWuinAZFE5cxZkckGW/RVrsuR9siausfRs0WFQXS6YtpmJEpU0yJIzWX/7APCbDUDHbgy4A4gKgJbnVBnLqiIj1tOx4i9vdeCArKbuRO9YXDDPruWj3aNiCwA1uSCrJ8w1hhIkbACSMJnDkaBhxJAlk5UMNUvxymVP4lOhTwJQBlmyoK5xHXDFZwEAVicxa5Ans+7bMAufXU6O61mhBsf7vKIhEQD855DE3iivc3Y9sfeTB85L6x0AFEYmbP4ToiTwU0IMsupjv4creVsAADHW8QDQPza+uizG5raUW2CmEmmfapCVnMliCZ5U8ubJNL74w842XPF/r2LveRL0lLCaLPZ7cSpLajEAVg+yOI4Tg++E5hfMDIgxlld/hdzvPwrsfSzTr5FztKtI4S8rp422dVkY2VxAyG91OsWXvvQl3HHHHThz5gw2bNgAAHj55Zfx5JNP4qmnnpqIXbigkMh1KhHMdLHnzZXxhYzJYgN2ld0IrYZHC2Wyzgx60EIvvIYSM5bRiWR/hxOeQDhhrZIIMciimbxcudEwiQGbjOQW7ln2HGUZ57IM+svYEsgFr19YhWqHEVaDTgxiVjYWY+eZIexoHYrvkcUwTodBNXfBRM1D1XDNvAp8/bYFqCs2iYF2PsHkgkzW9hfqaCk2bg7QRbHJkfd9UcIlq1MCiO19Y6kZZwY8aO13oyZRXy852MRMmSxBEPC77WSS/n83zRPPjWRgUrdkheQ7z5DrYWm9A2a9Vpzs0w+yGJOVK7kgzU6LQRYNqAKTw2TNqSJB1rEeKXDpky1KlQvWtMGYrF7KZI31AOd3AAB69v4bX3eTxWql3ZiQsXzvmga8cqIff9p1Hj662Oc5Yl7RO+YXlQ7MCQ0grRYEATBo+ZjkCZN75k0uKLL98eetXQ8YObIo79XmIcgC8LqvEU60AVDI5qsWAryWMFrv+CPQfwzY9l2UukiyRi5vbCg1o6HODRwD2jX1CAcFHOsZw/KGYgTDUWw5Jg+yYs8LZXKMzd16DY951faYbQAQCbjGAEQCJNHI5kOAmBspmSzRJVG9sbIcXQqWbbwOg3IjlWKzHt6gD6FRMr+OCWapl1QKJktpBpUQbGzwj5LeS3msuY1EBXz3hZNY3VyMDXMr8cddbWgf9qLzLfKdHDz9bsnmmZLkTBZAgu9+VyAxk6VsgG0uIQmBF74AHP83sPojGXyr3EPpCGnU8VhgcgIAelCBponfpSmDCWGybrnlFvzzn/9Ea2srPvGJT+DBBx9EZ2cnXnrpJdx+++0TsQsXFFiWrCZduSDNLuWOyZKCLCaLYAvHlnKyKCJMFrnwmkotmFlhRX2JCcFwFK+fTiMDJbr9CeqZvGwgCFJBLguyRAv37OWCYtPQFEYEckjOb+Q36RiWAtL/vX0RPn+jxFQwQ5EdrYMx/VZikEe5oLImSw0cx+EDlzZhw9yJyVoxC/dRbwjuQBivniS/q1g8PAmsBwO7zuQ29qLsLN3GtozJGusGwgGcGfBgyBOEUcfjpkXp1buxz2wb8iS0Gt/dRibvS6ksVZQL+tKTCyoDynGDZadFuaCMycqRhXsmmF9th4bnMOAKoI8mU8ZtfAGQxT1A6irCAeD0i+JTbftfwfNHyIL9Mnrtq2HD3AosrLWLAVRTqVlMcJyQSQblC7fDNAlRW2yKYZvzXZM14vZCg4iqXJAbaYOBC8ErGNDHJf6+44G8FjhGNu9oAD65G/jYDnLOVZLfpSTYAzs8Yi2xiAESfHntMwAAhzqcGPEE8diOczHOjN0KJkuUedMkxrxqO0w6DVY1F4sKiEFl3zO2cFeqObxDpLcXZBb0omNlaiZLyb6O12FQbqTCmLoIrXl+IzpP2jCFq5zaHKQKUzHAOlExhidPePVEP37x2hn8z98PY9QXwpkBos5hbop2UGMveRCsRBruj0mZrGhEOgfkbQPqVpHboTMpv0cytPa78cddbaJDcjZop+sXvZaEFE2lFpRHiWrofDQ/1/R0wYRZuN90003YsWMHPB4PBgcH8corr+DKK6+cqI+/oJCoSWUi5J7JkuSCbMBmQRaryTo36BH7JTSUmsFxHK6dRwbZLcf6Un+Gzkj6agC5kwwGXCQzCEiTUQ6aEfeNpWepLYckFwwhEhXEiUpuq8zAgqxdZ4fEIuUSsyJ7xxoUZslkqU1wrLg3bqExBeCQBQMvH+8T7e9HPEESTAfp5KefuAU5QBgnpVwQkJtfuNE35k/NgFjKaDBBstZ7aDC0tN4hTmSpUGk3wGbUIioAZ+niQBAE/HzrGWyniQ4WJMyksrhM5YI5r8lSGl/EWLjn1vgiHZj0Gsyiv90RulBnzaABoM/lT78thRz2WrJgiobJwv3UC+JTS3AaVl0U//j4pfjWHYmNWziOw6evkdoTLKl3iMzbqQRBFkOtgk21pcsiZINIGJ9p/SCe038BpcpxCyDsEYDTQi08kdw2MQdID0LmegqoGECVziAGBQBhCOhYOpdrjw8KB4ghhq6KBA9/2HUea771Mr5FZcrLGhwAgB7Z9U1c18jc66AmB2VWA9546Gr8/p7VCfueJXQYZGO8tRLQ0sQeC7ZSNLgGpKCISfsyCbIEQcCzB7vFUgB5TXZtsUlM/nE0yHozOo8YH7D9TQKWePSHosn7z/EaKdjIs/nFoU4nAFIS8K8D8SyhRUgjyEqTyQIS2Lj7RyG2tWC1egBQSuu9xzqlBFSG6B/z412/egNf/tdR/PnN7EyzAEkueN9VM7GysRgfXNsER4CssU4Hs3QMvUAwoX2y9u7di8cffxyPP/449u/fP5EffUHgtzva8OirrWK2YyowWV2KIKu+xAwtz8EXiogNalngdc18Ihd45URfelmTVDa2mUJuK6smF8wSTD6UUZBFa6DCUQHnhzwIRQRoeE7V2ndRbRFsRi1c/rBYVBrPZI23JiteDz/syVwGOVFwyPpkPXdIyt46fSEI4QAg0El6AlkPgDh3hSLk3JbXKTHzi33nR3Djj1/Hxh+/nthJCiAOKGJdVpvIOK1qSn/C4jhOVlNEzvPDXaP4zuYT+OI/SS2QWHdHz6eUro0KsJqsnMkF45gsykT6nVLbiAkOnBfV0jYK1LRHzmQJQqwRRjrwhyK48ZHtOBaliZHOt4CzrwIAopwWZi6A9fZerGgsSWlusmFuBZZQ44RVTSWiDb/c/GLEE/9bKpM5eWWyxrpQHe7EPL4DNRoV5qGfBCinonXw5OHjzw97YwIrTyCc3ICGSjkX8G2xBkOCIAZZZc3EUOfcoAfBcBQzK6z40LpmfPsO8viAOyAG3yzI1fJcjAtnEW35UULl2KO+UGzAnqguWSkVBGRyQRUm6+g/gcc2is8xuSAz3MgkyNpzfgT3P7kfd/5iF5zeIPrG/AhHBWh5DhU2o5j80/rIXNshlKO/5moSuFYkryO1GbSi8VPK83CCzC8Y8wuQmlglTBF6ncmDHyWY9Hu0k8gb1TahwfewWnKLsXV6W6yBhLlECjaH4/ctFUKRKD75xD6xpvz3O9tSNjJPhPPDJNhc01KKv398Ld69ugEmDzlPT/iKEc4mEXWBYEKCrP7+fmzYsAGrVq3C/fffj/vvvx8rVqzA1VdfjYEBlX4KOcajjz6KpqYmGI1GrFmzBrt37877Z+YDv3r9HL77AhnkrQZtTCPiZGAW7rlzF4xnsmodJDjQaXg0lJBFkNMbQnWREevnlAMAVjeVoMikw4g3JFqSJwUbQHIlCZAPyEE3kQqO0/hCEISsmCyTTgMtXUCxLGuNg9S1KaHhOVw7n2QB2eI3zl2QFUAHRrMKSqWaLGkBMpTEEWyywWqSAuEottJgHiCZ1TG3TF6ag55KmUBeVG+RNWSeQWVcJ/tcGPYEMeoLia0PEkLmMPgWDbJWZhBkARBZGGaLzBIC3aN+CIIgBllMEqrm2pgMIpOVMwt3RU0Ws3CXZ6wnOHBmi9EjXWMIRKSGvSz5oNZ+IRleOzWA4z1j2OmhC+NdjxKWzlaDnvJ1AIDL9KfSei+O4/DL96/EN25bgHeuqheZrERyQYZETJa8v1PfmD/rRVcMZHbelREVa2/KZJ0U6qESD44b7Nph10JUIGxJIghUMjifO49yeYLJ1UPc/jgNZs1bCr2GB88Bn79xLrZ8+gp8+Zb5mFVhhV7DQxAkhQMLcost8T3CAMIes1h6JJ2GxCzIYok1AGA9mtSML/b8Dji/A/zp5wFIcsGl9WR+zaQmi5UADLgC+Nq/j4nnfrXDCA3PieOH0U+u136hGH03/gb41IGUYzHPc6LsOGWSZwLMLwRBwGGZzLRjmHzXhbVSaYE+zIKsJEyWtYqocoSIupw/HMCS4AEYEFRnspSmF3IwNmuoNel3UcMTb7bjrbYR2AxaWA1anB3wYHtr5sczFImimwbujaV0bBYEaFzkPG0XysZd9zedMSFB1n333QeXy4WjR49ieHgYw8PDOHLkCMbGxnD//fenfoNx4K9//SseeOABfOUrX8G+ffuwZMkSXH/99ejv70/94imGty2twV0r6nDTomr87+0L03ZwYxbunmz7ZAkCqRtgkDFZ4iArY9VYXRYAfPnm+WKQp9Xw2DCXsFkvn0hDMpjrgVTZINHVI7Nwzy7IcgXCYvDKmlWmA47jxMDmGM2Q1zkSLx4/c90cmHSSlKZYaXxgsErZtDQcppQosehh0PKIRAWxbkisyZqCckGLXgpSQxEBq5qKxePjGnOSjXjdpDUiNuk00MhYiBnlVigv1yF3EAc7nNjwva3YfERafEaiAh56+jCOeB0AAHfvGXQM+8BzwHIqR0oXsxRMFmMng+EoxnxhscaPmZswJitpY0wZWMCRc3dBJZPFEjscD2gm9nxcVOcAQJgsJ10DWQ1azKUBTaYOgy/Q3/potIk8wLLQs69Hq4kwIYsjx9N+v6oiI95/aRN0Gh7zqsgCsLXfHcekyCG3bwfimaxNh3uw5psv47fbE0uc0kVUNh6VBDrjN+gn3/W0kD2TNeoN4XsvnMRBmcsiw6snyLlzw0KpJiiZqqPPQlpTLNScR1OZLDCg9VgoaUFJkQ1/+f8uwbP3XoaPXTlDnIt5nhObhDNZv7IeSwme50Q2K7ZXloPcsl6RkRAxQFBlsmhNFkseysESFJ4BRASghyZamLQxEyZLbjP/zP4u/GFXGwApaCdzhQBLiHzmgFCEKoeJSPzSgJqiQhVMeqjWjytH6BsLiCyPHA9cO1u0XNcG6bFOZnzB8xKbpSYZfPOXuOvYvfio5jlxPI6BaHqR2yCL1cZ/4qqZuGslOZd+v7Mt4/fpGvEhEhVg0PJin1S4+8GF/YiAR69QmjHbfyFhQoKszZs342c/+xnmzZOKIOfPn49HH30Uzz//fF4/+wc/+AE+8pGP4J577sH8+fPxi1/8AmazGb/73e/y+rn5wOdvmIPv3rUEj753OW5fln4/EfN4Ldz/+j7gB/NJRiUSEhkhv6FUXLyxDCoAzKUT/eWzymImNgBYSKU33c40Lrpcd3ZXBlljXeNmsvppttJm1IrHOV2w3jSMyVKrx2KocZhw7wap55Zq4MPcm5TfMw3oNDzWUPODbacGEI1KPbmmolyQ4zhUU/b0+gWVeOye1SimAYKL9d6bYFkZALgC6pbmJr0m7vcddAfw4rFenB304LlDUi3F/vYRPLm7Hc+cow6U3YTVmFdtz7j2SekwOCyjCk73u8R+OezYyQ1F0oFbdBfMQTArCBLbrKzJYue0zoK4aDXPmFtlg5bnMOQJos1FPruqyCguLDNxGAxFonjpOEkwbYquwZH69wIL3w4sex9w+YM4wJE5stl3GEi3p5oMdcUm2AxaBCNRkb1kbCVbGAKxjYiB+MbVbB//czjzhI0S/mGplsXqVQRZkTAwTAr3iVww89921BvC+3/3Jn76aiu+uSk2OJUbLV09r1KsQ0qWcDwUIQzRTK4LOkG2HZUKopwEYcsbisX5TA6WcGTBt+QsmPgaEeuy5OYXSibrqbuBHy6QTFKKZEyW3gIY6PbKJBtLXLj7MRokSRydhsOCGjJPD7oDaTOWLOhgjNN/qFS7liYIiy162OGBViDjh1PjSNk0XQ52HqZksphlfRpuitmC1WO1lFlgoHWwGp7DpS1leORdy/C/t8wGH1ZYuCdCMvMLel6t4k9OGJMlCAL2tZP3XdNSgg9e2gSAtEJJV8XA0C4z7eICY2S9+Pr3AADDfClC0GbM9l9ImBAL92g0Cp0ufoDR6XSIqjXayxGCwSD27t2Lhx56SHyM53lcc8012LVrl+prAoEAAgFpoGPNkkOhEEKh/PQQSQX2udl+voEnA6gnEM7qPbRnt4ILuhHuPgyhuAk6CBA4Hnv7BYSjAiptBlRateJ7f/CSetiNGty+tBrhcOxkZtGRSXTUG0i5L7yxGBoAEVc/ojk49vxYH+T5tMjAaWgEcv6FeDIxZnp8uqgWucJmyPi1LHvMsq81Rcnf44OX1ONVWs9WYtLEbasxl4IHEB7rhZDF8bpsRgm2nRrA1pP9uHVxpVg3Z9Vx4z73x3sOq+HH71iM9mEfblxQCZ4XUGTSoXvUj7FREpQLOjPCE3zNjtJFkkUf//vcvKgKf9vThWKzDq0DHvSPetFLJYP9Y35x+yNdTgDACYEuonoOAiAsVqLjl+j4NpWQQLRtyAO3L4BBlzTZHaWf4zDpIEQjCEUjsOpZU8zU12c0KqCL9uAyaXPw2/qc0EXJeBHSFwGhEDjeQCYpms0XdKYJ/001IFKz470uHB6mQZbdgEo7WRgf7XLiiTfasGFueUqTmB1nhkT2LwA9/mj/KB6+bYH4/Bu+OtwrcDCFnAiNdAK2zJt6z6224a22ERzqGMbMMpPIPiypK8Ke804AQKVVF/N7GbXkWveFIvD6AzhGa1GOdo/C5fXj888cxeGuUdyxrBbvWV0Xz6QngXeoEyzdwY+cjT1PRjugi4YR4XToRTFqQ5mdR9GogHt+/xYOdZL9be13x7z+zbPDcAfCKLXoMa/CDIteA28wAqfHjxq7+nfY2W/EasECB+dBqOeIWKOl6TkMHkCkZFbS+aiKZvO7RjwIhULiNecw6RJ+N5bk6B7xIBRyAAB4vY3Mf94RRIMBaM+8Ai7kBYZOAwDClqqYcV5rqwIXGEV4pAOCo4U8KAjQeofAARDcfegLkfO3vtgEh5HMhqGIgEGXN63fdIAmFT+0rhHPHSIJIgCotusRCoVQZOBRwTkBAE7BgmKbDZFIGJE0KxVsdJ9G3P6k5wFvrYQGQNTZiUiexoODHSQIWVpfhEq7AbvODmN2hRVaLopr5pYBHgHYQrYN8aakcxxvryW/5UhH3LmjGesGD2A+fx7DrvjvzbsHyHc1FMV9V87RDC2A6ODpjI7D+SEvhj1B6DQcZpebYdDyKDJpMeoLo2fEI67T0sHZAZKori82IXzsOWiP/1t8zmWsBrzAyZ5R3DC/POZ1oUgUY75QTJuEVMjHOiJbpLsPExJkbdiwAZ/61Kfw5JNPoqaGaIe7urrw6U9/GldffXXePndwcBCRSASVlbGuNpWVlThx4oTqa771rW/ha1/7WtzjL774Iszmic+My7Fly5asXjfkBwAtXL4gNm3alNFr+WgItwRJRnTf9i3w6suwHkBAY8OTL+8BoEG1zhfHSFYC2LX1aNz7nRriAGjQ3jOYcl/mdo9gDoDzx/fhsDuz/VbDws49mCH7//zeLWgBEAWPLVu3AxyX8THePUC+jyboyvjYBtw8AF6UZoV6T2HTppNJX/O+apLIf2FzPAO8ciyMWgDH3noN59oyZ58ELwBo8eaZQfztuZcAaGHWCHjpxc0Zv1ciZHsOJwIHYDOVuUd85HgeOngAawB4glG8nOFvMl4cHSHnQ8TviTsf5gL40iLgqXM8WsHjjQPHcN4NADzaeofF7becJd/jcJQslGqEPlRpxlDjPYtNm5IXOCuPryAAJo0GvgiHPz6zGYd7yHsDwJbdRwHwMEAaFzo9AKBF34g75fn8SjeH1gENdLyAwZN7sakt1dFJDou/F9cACPFGbHrxZQBAkbcN62XbeEMCXprg3xQAiqLkuJ1wUonq6ACGzvcD0OCFY/144Vg/1lVG8Y6W5EnDp+hva9MJcIU47D7ZiU2bJFevk70a9KMY1RjGzs1PwWmZkfjNEsDsJ5+xaedhGHsO4uhp8n9ZZBg6noOeB/ZufwVyT42IAPDQIAoOj/9zM071awBwCEUE/O/jL+I/Z8ni90cvt+LpN07jwcWKVbMgYHHnH+HXOXCq6raYp1paD4GZOI+2HcQ22e9X4j6JywE4+WII4OEJRzMaIwZ8wL52LTScgIhA2Ma/P7sJZrqy+Wcb+e4zzH5s3vw8ECbf6+XXtqMtQdeObUc1uC7aiLWaYziy5c9oL70CALDhxCuwAdjTK6A3yTnoGSSf+cbBk6gdO45/nST/e4Z6sGmTOvOi9ZBtHv73EYyePYhKEzCzrwcLAHS3HsUJz59wLXPXpNh+uA2jZ6T9uDSgQwWAQ9s3o+M4CX50YQ820sTFWNdpdFJi2CG48fKLm2HWauANc3h600uoTmN5c4Iez8Hzp3BblYAfDWoggMNQx2ls2nQKp0c5lHMk4B0QHNBHfBnNi75R8v479xwA35nYHK1mpA+rAIycP4rteRoPXj1O9oUb6UCFAAAaVHKj4vex+ntwNYCQxoxNmyV3ULXzd07PEOYC6Dh5EAd9sfu7vvs0igCUcWMIjXTEHa85PW9hLoDzAy4cUjxn93XjKgDh3uN4PoPj8BZdt9SZo3iZzu/aKLk2Xnh1G05lIOx5jZ4TkbE+tO5+EXJ7k6EoeaPth1oxKxBbZ/qPczy293K4f2EEzRkKiXK9jsgGXm96jo4TEmT99Kc/xa233oqmpibU15PsbEdHBxYuXIjHH398InYhbTz00EN44IEHxP/HxsZQX1+P6667DnZ79r2UxoNQKIQtW7bg2muvVWUEU2HYE8TX929FKMrh+htujKkVSYmxHoAk0rF8XhMpsD0JGEob4DVWARjAxjXzsHFtY1pvV3J2GL87tQcakxUbN65Lui2/uwPY8iyaKqyo37gx/X1OAM0zzwADgKCzgAt50KQj0iTO5MC1112X1THu2HYOaD2NBc212Lgxsd2yGjaNHsCpUVIvoNfy+PidV8OoS0+7rgZ+81Zg71tY0FiJeeszP16CIOCxc9vQOxaAp3gWgHOodFiwceNlWe8Tw3jP4XTwgusgTo32oba6EhgALI4KbMzBeZMJood6gBOHUVNRgo0bV6luc+aVVuzoO4vi6ga0tTsBuOGDDhs3Xg8A+NNvdgNw4n1XLkLPnlpUR7rw/F12WBdcl/Bzkx3fP3S9if0do6iduxwmfzcwQORDAVMpgBHUVxRj48bVAIj07buHXodf0ODGG69LWPd5vMeFTbvfACDgyzcvwLtWjb+JLNe5GzgOaO1V0u821Aqc/LK4jbmodMJ/UwAoaxvGm7/dg5BAjseqBTNx6YwS/PnMHnEbwVqGjRtXJnyPaFTAw9/bBiCAT2yYg++8cAoDQa14nMORKB5482X0aEtQzQ1j3aImCHMz/67+/V147emj8BpLsXHjKvytfy8wNISr1yzGxyuJMQNrKSDHn+h50mFsQVSQWkG83G8CEEStw4gupx+DIa14rooYaoXuFyQwnvm2h6QaFADDv/w5QNvDOaIj2HjjjcQAoKgO3BE3cBrE5toDeEJcRmPEnvMjwIG3UOMwIxiOos8VwOzl60Szkh//eAcAD9571VJsXFSFX53fhYFuFxYvX4UrZ5fHvV84EsXn97yCY0Ij1uIYFlfyWHjdRsDVC93+HgjgsPz2e5PW4Ay/2Y6Xu0/AUFwFx5x6HNi1FzwHfOaOtZhfrb6GuNQbxPt/twcn+9z47VkLNt+/DrZjg0D3X1Fbakb1wirgWOxr1t307hgJmebfzwOHjmBJSwUWrZNdP4fpsdcF0ekm5++1K+di42VN+EnrDrQOeDBv2RqsnVGa8nj/sm0XMOrCVWtXYv3sctga2/HsoR586q5lKLXocbLXhfYTbwAA+gUH5jVVY+PGxSnfl2Fb4AgODXejYcYcbLyyJeF2XGc50PYoSrT+vIwHgiDgG4dfAxDEO6+9FItq7bj+5CDWzigRW3PwOx8h41X5TGzcuDHpGMzv6QF6n0FDuRW1iv3Vnvy0eL9J6MCNN34mZtzlN78G9AINc5aiTjmvh7zAiS9CH/Fg4/pLpGbFKfDmv48B6MSGxU3YeAORv/76/BsY6h7D/KWrcNWc+GsjEZ574gDQ048rl8/H7H4D0AsIegu4oAdFc68A3gDcGlvceu/nj+5CFC6M2FrwyY3JnSfFrzsB64h0wVRuqTAhQVZ9fT327duHl156SWSQ5s2bh2uuuSavn1tWVgaNRoO+vliThb6+PlRVqcswDAYDDIZ4FkCn0036j5rtPhRZpNK7kMDBmMl7BJ3iXW3ACejosbFVYv9Z8tyq5tK096vYSuRLLn849WtspMaI942Az8Wx9xEZGVe5AOjcDb57H/m/ca24L5ke4wFaqFztMGf82zjM0nm2srEYNnP67oSqsBHGVuMfgibL43Xl7Ar8dU8Hnj1ECorLbIacnvf5vI5K6bkVDpAsLqe3TPg166cJfpsx8fessBNp6og3LJ4/Ln8YEfAwaHmcpPVTtyytRbV3LXD4KRSPHgN0N6X8fLXjW19iwf6OUfS7Q3D6JPnuKfo55Taj+JpyO5ncg+EowuBh1qlPEb94/RxCEQHXzq/E+y5tStuEJykCTgAAZymTvoPZEbMJZ7BNyji8blYl7tswA4+8QuqHakssWNNSjg+ta8aYP4S/7+1E31gg6b7tax9BvysAq0GLD6xtxg9eOg1PMIJ+Txh1xWb0e0gBea9QCqAVWncvkMV3XVxPFlonelzQaLQYpY6BZTYTljQkXkivm1mO/R2j+Me+WLaFmTHcvbYZD286Dm8wgijHw6CVJYTobwcAumNPA+s/J/3vk2pEOb8Tujd+DLzyv8BN3xedUIWiOqADcIczGyOcPnLBldsM0Gt59LkC6HAGsKJZh1FvSJSzrZ9XBZ1OB4uB9mKKIOYzekf9+M7mE1ha74AvFEWrnizwNf1HyVja9SbZ/6pF0NmTL0DrSkgA2z7swzeoMuH9lzQmPfYVRTo88ZFLcNMj29E75see9jFcamuGFUCo6zAMTUQiiLk3E4dDowM6W3lsfaKDJDo07l5p/A9KC0HOM4gOqnBaXF8MnU6HCrsRrQMejPgiaR1zVtNZVUTG1g9dPgMfulxiW8uLzGjmyNzRDwfqijObF9mc6A6pl5iIKCHtDzhXD3QaDTGXyCGG3AHxvF9YXwyTXouNS2R18CE/sPsXZB8u+UTMvqqev1bC5catZcLBGNfj2cJ5BAUeVnl9NzXn0lhK4+d1XRFgrwPGOqEbOw8UJe9FxrC/g5wXK5uktRtrRO8NCWn/Zv5QBMd6iFywudwG/jRJznA3/whwNMJimQe88TrahrwQOE1Mj0fmvvnmuZGMx/Spsh5PBxPWJ4vjSIbqvvvuw3333Zf3AAsA9Ho9VqxYgZdffll8LBqN4uWXX8all16a98+fKjBoeZG9ytjGXW577hkSnQXd2hKMeEPQa3ksqElR9CmDssA6KVhWJle9MJjLUrUiszbvlqzfMpseWQxyC37WcHhcsNDJfxwNGpndPivmL82gaHmyweoagj5mZpIbea/LH8KPXjqFMwPulNuygnprEktzpkHvHfOLDZ8B4vLVM+qHyx+GlueI7XvNcvIkTQhkg2ratLxn1C+6CwLq7QDMeo1okJCoIbHTG8RLxwgD++lrZucmwAKAQSonYU5pADFzqVwE8FqgYgGw7lO5+aws8MkrW7CkJAqdhsPKxmJoNTy+fMt8fGI9WWT2UFv8RHjhKFl8rp9TDotBK9r6M/Mg1hh6zEAXSlkW9c+kNuKuQBidI74YC/FkYEwGmyNWNclYEp7DHctrRYlh3Lkhd4A9+GSMaYfRr3Dyff0H5PbMq6JTnqGUKCGc1JghXTAjhjKrAc1l5HiywKqD1guWWfWiax27LpXGF795/Sye2d+FrzxLJO7hCmLjjt7DQDQKtG0n/zddnnKf2PV2ss+F1n43Si16PHDdnJSvK7UaRHZt7/kRPNFdjpCggcHXC5x+ib75UuCD/wbe+ad4AxgbvW7kxhey34UL+xAIkIUtM72oovt6No2xTRAE0ZgjUVsPh0mLWzU7AQA7owvE908XkrtgivWBtZI4jUZDebFxP0Obt9c6TOqGVgf+DHj6SYCz6M7Ub8hMvHwKEy93LAEwn2+LN79gr0nEUpXSILcvvjxDDe5AGCd7SZC1vFG6xtmxT7dHIgB874WTWD32In5s+jVW1FuAkTZpnxrWoKbEBoteI/YDZfCHImKZxIleV4xrpRyj3hB6UrU6meLIG5P1yCOPpL1tPm3cH3jgAXzwgx/EypUrsXr1avzoRz+Cx+PBPffck7fPnGrgOA5mvQYufzhzG3d5gOMdEpu8doaIiHZJXVFMdiIVmNmDLxRBKBKFTqUvlAjmMJazIItmVKtkQRanAWYllmGlQq/YIyvzYMQuc2RLR6qREizIcvcn3y4JrltQhTuW1+Jpms0umYI9shKB9WgJ+alWOkf9lN7z6zdxuGsUBzqc+P09q5Nuy5IHliRBFnNrZItrhn5XQLQubim3kOuqlgZZXdkHWVVikOXDsDsY97y88JjjOBSZ9Bh0B+D0hsQm43L8+1APgpEo5lbZML8mhxLqs6+R20aZPJXXAB97HYiGJ9yOXwme53DP7CiuuvYaFFmk48KOrzcYgSsQjrmuGQRBEK3bmePq7EobTvS6cLLXjQ1zK9HlJOdtwFwDjEGy6s4QOg2P2VVWHOkaw9HuUakXWgpjg+WNxdBreASp9fudK+pwpGsMvlAEa5pLUGo1wGHWY9gTxIg3GJtYkid2Rs6RBsv1q4FwAOYIWdCNmJtR7D1HJE4AsUQPk/HTUtEEDc8hEiV9m+oN6Y07jAkusxnQXErs1s/RIKtL7OEo/VbsunQHYpONr5yIHTNLGxcCIwbCGjnPy4Ks1NLpallgUWLR45fvXyEuYFNhRWMx/rqnA/vOj0Cn5bBaaMJS7gxwnn5+eZJgTWxILDmVKhNu5dwoHEUl4li5uqkET+/rwvbWwZSB4JgvLDZaT9TWw9C7HzP4HngFAzZF1uDqDIMs5rib0sJdoyOBlquHJCOYs26OwBJqM1RktQCAN35Obtfel964lChhrLCgn8+dx7AniPoS2dyVzF0QABrXAudeA7Z9F1h4R0qnw/3tI4gK5LqQX8OZBFmt/W48d6gbv9l+DtsNT6FOGATaXpQCfOqmyHEcZlbacLDDidP9brGliNLS/Y2zw7hpsZRc8wTC+PnWM/jdjnMIRaLY8bkNqMgikT0VkLcg64c//GFa23Ecl9cg653vfCcGBgbw5S9/Gb29vVi6dCk2b94cZ4ZxocOi19IgK0MmSz5Ie4eACMk4nPOTwWdZQ4ILPwFsMmtrlz+cvAeTaOE+RDKj48mYR6NSxkvOZDVdRgbALN1q+rNoRMzA+mTZDFosUrECzhgik5V9g28Nz+H7dy3BysYS/HFXG26WDXxTHcwiORqgWdksGhELgoCtJwfw6KutCISj+Oz1c3CYOq3tbUvdFDs9Jouc80pWecAVEBeIs+lkhKrFJGPr7iWLJ7aQygDMUrptyAuPCpOtdMRzmHUkyPKpW/n+Yy9Z/N+5Yvx1WCJCfqCdOr62rI99juMmPcBi4DjEZbbNei2KTDqM+kLoHfWrBlmn+txoG/JCr+Wxfg5ZEM6psgEHpWCbtbUQ7LUkyBqHPfWC6iIc6RrDvvYR+ELkN3cksRAHAKNOg+WNDrxxlmTOF9U6sLKpGK+fHhQXQMVmHQmylF2DlWzCwb+QIIsuIgOCDq7SxSTIYhg+S4JnALyjAZW2KLpH/egZ9aO+NL1KeNbjqdxqQHMZC7LI9c+YQbldvZX2jPTKko1nB9w4O+iBludwxexyvHKiH+vn1wLd84CeA0DrS9TRjwMaUytgSix6XL+gEiPeEL5/15LYBXMKMGbhYKcTAoC3MAdL+TPSBhXz1F8IpGSyAKAMo3DI6sIum1VGP28UY/6Q6rnLMEhZLJtBm7h2+MCfAQDPR1fBAxOqiuKTNMnAJGtj/jTmY3sNDbK6gZplGX1OKpyh7Q9mlKvMIZGwZJm+4G3pvaG8HY18LeOmQZajAXC2o5nrxavDw0C9g/SPs1TIgqwETNba+8j1NnIOePGLwK0/Sborr54g64N1M2MTu/Y0g6xdZ4bwnt+8AUEAeERRzdH9O/oMuTXYYwLCWRVWHOxw4lSfCxsXkXO0W8FO7To7GBNkPbzpOJ54U6oLPd3vLgRZSpw7N/4mhrnCvffei3vvvXeyd2NSYWYNiTPtlaVksmgWsidCBuqaDDNVWg0Pi14DTzCCMV8ovSArEiT9rIzjyJr7RgBq147yeWThKkTTlgpGowLahjxoLrOI8qhoVEC/K3u5IOuOftXcCmiTMXrpIgdyQYAkPt6zpgHvWdMw/n2aQLDsbDSQPZP16Kut+N6LkgvSB363W7wv7wWXCOz6ShZkJeobM+AOiDIO1ugWejM5X/uPEjYrqyCLnJut/S7V55XXoINNtipywTMDbhzocELDc7htafq9+lKi403Calirkmfrpyiqi4wY9YXQM+qXAmQZXqRSwctmlonnBvuNWRDPesnoSuqBTmTNZAHAwlo7/roH2HqSLKi0PAdbknOSYe2MMrxxdhg6DYeZFVY8fPsibG8dxDtXEcMqYvPtiW9w7KHzRMUCcq6efpEsJmmQ1S84SHa7Q/YaISrJi4rqUePoI0FWOj0UKUS5oM2AZrogPjfggSAI6kwWDZDdsnmQsVhrWkrw2w+uxJgvTBb7RxaRIGs7TRhXLUrMJsjAcRx++f7EBijJ0FJmgcOsE+WYb/Fz8BFQ1ziNXuq3pAY2Nrj7gB8uBFZ9WPpdKMo5J2bL2Oe6YjNayiw4O+jBrjNDuH5B4pYBQ5Q1TCQVRMgPHHkaAPD3yJUAMl8fsCAvJZMFkO/btTeWucsRmOSUSXpj4HcCoJJWc5oKFBYgRUNkLWOwAdGIxGRVL4HL7YYtPIxtr7+KDUXd4P5wC1C7EvCmYLL0FuD2nwGPbQT2/RFY8zGgcoHqpoIg4OUTRKK4YW4s0ZDusT/Q4YQgkHP1/tVWaF6hibtT1GHR0RiTEJ9F2cBDnaN45OXTWNNcIjJZjDnf0ToUo2w62Rs7V7H6remICavJAkjfqpMnT8b1Tiog/2CTizfjIGsw9j7VEHeFyUDtyKBfCoMt3bosvVlaKI9XMsi+h9EB6IxAw1oy8M27Na2XP7azDRu+/xqe2E2yK9GogI4RL8JRARxHCq8zxZWzy/H0J9bi4bctzPi1qrBQeWXQBYSmt445G4hyqBDVfmfBZP3rAJmw37GyLs6BTY0FUiIduaDdpI1pDMsw4ArgRC9r7i1LKDDmdeB43GvSAQuymNRHSQgrF03smnaqTLZ7z5MJf1VTcVbnfEKco1LBlvUT3mw4F2CSwd4E9QMnKVt1aYu0KFtS7wBApDejvpAYFNjKm8gGrl7S/D0LrG4mn3OaZuSLLfq0aueunlcBDc9hdXMJ9FoeDaVmvGdNg1jTy86NuCCLja/zbwV4HXEPHD4rZur7UAxdOXWLM9hJbZEcRbWooomq7tHMg6xyqx71xWbwHLlOB1wBicmSBVlmlZqsl4+TIGvD3Eoil6VsiigrZ4zi6o+kvV/Zguc5LJepQ/ZEZQmHstmAJkmgbC6TGhSPdgA7fxrHZJVzo1hQE5sEYGzW66eTKyBY3UzCvkZnXgECoxjSlOON6DxoeS6jHkhA+mwK2ZgmecaRjEgEUS6oFmR5aY2UsSj57yGH3gxo6XnoGQB+dgnw66ukfbdWQdO0FgBwWd+fMfafr5AkROdu0fgiaYDfuBaYTR0/T8a3d2E4O+jB+SEvdBpO/N0Z0pULshqpGxdV4fYW2ZhCpb8ojnWaZkmnV0704wdbTuGhpw+jh17j6+eUg+eIxHf517fgV9sIa8uuXTYH9xaCrOTwer348Ic/DLPZjAULFqC9nSxU77vvPnz729+eiF246GFhTFamcsEYJmtYrPfpCJILx2HOXMbDDB/SkgTIJYPjAZPQMbbn/U8D9+8XHflS4Vg3YRiOdo8hGhVw449fx5Xf3QqAmEMkrS1LAI4jE6otiUQjIxiLSLYTGDebNR3BmmnyoeyYrEA4Isr1/vua2fjrRy/BHctrccsSkiFOp54xHbkgx3GqhiJdIz5xcp8rZ83EhVN28rEyqwFaWduG+uLY46LcF3ZNxy2kAXQOk2PLTAZyhrNbya1SKjhNIDcXUQNrQCw3nyizGtBApWT720dwlDJaVbX1JFCBECv9ygCzK62okAXBxWmO0wtqirD5U5fjp+9ervo8e5844ws23jgagPo15P7ZrQiNkqRFn+CAecFGYhxx9ZeBmqXSay3lgM6EGkfyY6gGufGFXsuL0ryzgx6JyZKd71bFPDjmD+GtNrJovmaeoq5HLiu/9F5g+QfS3q/xYIXMjEBjK8eZKJVRlaewueZ5Ur94938AcIB3EIEe4vsu6Mn1WsaNiswCw2XUdGn76eRzxiCt7StLxGSdJkzGMftlEMCj0m7MrF0MZMYX6RhjqdWg5QD+UAQddJybUaGSqGNrkXRZLAZWl9W9n9Qj9h4CzlBTNlsVzNd/GRFOg2s1e1E0sCf+9alYVFZb3vpSwk1eoQmFS1pK4+aodIMsJmuuLjKpS5pl7RsAxCUrzw560EqTP3OqbPjM9XNQatHDFQjjJ6+00lYM5DNW0IRD/5i6McZ0wIQEWQ899BAOHjyIrVu3wmiU6ONrrrkGf/3rXydiFy56WPRaaBCBz58hwyGXGwTdpBAYQJufDD7jY7ImMcjSGpL2OlGCubINuAIY9ATEzDQgOTVNOjguJ3VZ0xWs5kQfpYs0XWb1AOcGPQhHBdgMWlQXGVFqNeAH71iKT15F3JuSBVnBcBRvnB1CL50MrMbkGU45e8RMU14/PYBQRECxWYc6WR0JimjGNssaHZ7nYuSstQ4TLHqppiKOyUoiF2SStpj9Gy/8o2ThAQAtV+bufScQVdSWX1nQzcAkOHbFebG8wQEA+MPONgx5grAZtFjWWCItILMMrDkuNlNdnME4PavSltCJkD0e54DGGBNzmRQon90K/zBZAA+hGPbiMuDu5wgjJA8YaBKhJkWgqoQgCFJNFg0opbosKciSn6sWBZO1p20Y4aiAplIzGksVC+ralUTpsOZjwLXfSGufcgE5k/Xu1Q14PUr7L9alIUE0FZM6YweRemv7jwAAImXkeJfDiTLFb3vJjFJoeA5tQ160DXqQCEmZLEEATpMGse2lxIExU2dBIFaylsypk2zMxsXcBlnnh7yICqT2rFztu+YiyGLopU3MbNVA+RyElktsqaCRHT+DPTVrNutactuxW2yNoASTxm6YG28UkimTVeMwqieBFEFWrcOEFY3FmFlhFaXpr50i65OqIiM+sX4mdnx+AziOKEGOdo9CEACjjse8anWjjOmECQmy/vnPf+KnP/0pLrvsshjJwoIFC3DmzJkkrywgVzDrNXhW/0Vc99odpHAzXajZo2qN6PKTCzLdDKkckoNQOjbuuQqy6PewlCXfLgGY1faAKyBmVcqsevz1o5fgkXfltuh2XGDf7yJksmwGLbQ8BxNHs14ZygWZDnx2lS1mnGJS20T1jKPeEN71q11416/ewPEekoRIJhcEJIdBAFhIWyCw+r7FdY5YaVcOFhNKxzO2KOW4+AW4IxFbAckWO5Ni/pQYbCXSGFt1VjVnUwFVRZItvxoYa29XuMwx46BXae3UFbPLCSteRE1FOt4Anvs0MHg64326PMsgKxmKRbmg0viCSqgspVKQdW4bQsOkCMujL489p2OCLPJd2aJcWRSfCJ5gBP4QqbNl19NMKu9669yw6KoYa3wRey0f6CDsodzKWoRGS6zSb/xOzvswJcPyRgeumF2O96xpwKUtpfhu+J34iuGzwKr/Sv9N6PHVcCRQ8TqI7LCKd8KgMK2wG3Wiu+3jb5wHAJzoHYsrLWA1WcogDQDQd4QkgXRmuKovARA75qQLpnIJR4XU7WZEJit7gxg1MDv7lgqrusSWrUUSGVEkAtu+52D8c1RRY7z2C+hBGYYEG/rWPCR7bRoGY44GoGwOcYA++2rc091On8jaqgVZbGxKVcbBkiDpMlk8z+HvH7sUWz59BZZRiTS7Ntk5YtRpUENNUhijWuOQjFMYszUdMSEjx8DAACoq4n9Uj8eTux4rBSRFidaPBfx5OLxtcb0ZkkIluBEsFfAGyeTmMGXPZGUkFxxv0OB3ktsU9qaJwCaYAVdALMKsLjJhTUuppOGfCriImSyO4+Aw62AGDbLSlAuGI1FEooLo8qY0uGABkz8URZjaWzO4/CG881e7sK/dCYteg+oiI+ZW2bCMMhSJIGePlEzokjrFOZqD2oNqWV1KiUUvLkodJl2cpKeILqSH1eSClMmqzyWT5SQLOzgak283hcEWA4mZLLJwscUxWbGLp6vY4ocFWS9/HdjzO+DNX2S8T/Lee6l6ZKULSS4oOzcEQRqfzWXE6c1gB/xOWDtJrV3ArJBly13yRCaLHMN0maxBmpQw6TTiNXoJrXnbdIRk2G1GbYxjnmh8QeWChzqdAICldPE3FWDQavDHD63GN9+2CDPKLfDAhD+NLYM/mnq59tSeDvxhZ1ucecywhbDxFfyYyquAD11GDDX+8lYHvrnpOG740ev40j9j+y4NJmOyTm0mt81X4qZlzbhhQRXuWdeUcn+VMOmkPn0p1wdyueDJzcBwbszWpHqsBEk6sW9VpkwW3V41yKKSUGMRPmH/KTYEvo/2ymul59MJsgCJzTodLxn82dZWhKMCLmkpiWdtkR6T5Q9FYgMklvirXiJtpAiyADI3cxwX1/KjWuY+yVjo11vJWEIs5sm5VpALpsDKlSvxn//8R/yfBVa/+c1vLqqmwJOJEl6WHUyXFYpGZUWeDvHhsJks5HkuftGQDqSarDSYLMbMjJfJYrbehvSsgZUYkskFWQPiilwW/ucKYpCVfa+s6QyHWQ8T6AIwjWbEvaN+LP36FnzqL/txspfqxCuVQZaU+VWaXzx/uBcnel0os+rxj0+sxa6Hrsbm/74iqRUyEMtkLVDY9y+uc8RuzOSCficQTCznSQZ5VrlYFmSpLZiq7czEIXaxGwhHRKamrjiHTNYotZxzTC83SzlS1WQxabTyvJhbbYNRR6ZhjpOagYuBNXNEzaL3XYXNKNb2laSwb08XDrUAPOgWW3vAUkYYINq0Vx8g80fIomgFYa2UEl4OGmTRmqxhTwj+UOraYclZUAogmfSNMVy1ij5vostuIAxBEHCwwwkAWKK85qYIym0G2AxaRAUiYwOA5w5145UT8YlSfyiCh54+jK88exQd2tiERa+RmI6Uwan6OVfOKseMcgvcgTB+te0sAOCfB2JZiqTugqdeJLezr0N9iRm/eP8KrGjMkOkBWRuyaySl+QULTCIB4Ml3Ao8sA558N+BsT/66FGCNiFVNLwCZXDDD78e2D6gEulbJ1dFgdWAUVvSiGCihZjHpBlkzryG3irqsbqcPf32LjLOfunq26ktZkOUOhOOSiQxsfDPpNGR7FmQxAzFeJ9UQq2B+tTLIkuYlFmTtbyfmSnXFJpHd7hvzI5pBk/KphLwGWUeOED3wt771LXzhC1/Axz/+cYRCIfz4xz/Gddddh8ceewwPP/xwPnehAIpijVf6R9l1PBH8TrH5MMqkCzNgJIFPkUkHPsPCVkBaaKRXk5WgiV+mYItTfeYF+95gWJy0g5EoTlMr7CnZt+EilgsCxGHQxLGarNRywd1tw3AHwnjuUA/ePEvOMaUFt17Di8YRSgnNGdqT5+bFNZhblX5tXlkSJmtxvYLJMhYBerpPWdboVMnO1VKLXlyYqrVQqCshC9POEW/M4z1OPwSBTLAJi9+zAVsUORJPzlMdbDEw6gvFnSP+UASBMBk/lHJBnYbH4loHALLQF4NvFlgzsF45GeJd1Hp9TXMOmp0jgfEFG2u0Jkmie8VngFnXobXkSjwavhUj5ati34jjpN5GdG6xG7Uw8GQh1e1MLRmU98hisBq0oiQJiK8dtMpqsjqGfRjxhqDX8JhbnV3yLd/gOA4t1Digtd+Nf+7vwr1P7MdH/7g3lk0ECTrDdCH6RJuUBAkIOnRxZBFfjFHCPCrA85zIZjE0KCTBrE9WnGlPOAB0UaMGtsgfB9g1krKcQGsAVn2EJGcqFgAQgJObgKf/v3F9ftsQWSu0lCWYP7zjZLJE0LUTr4sJ2ErkdY+N6+hr0wzoWN2eu1dKLAP4xWtnEIoQFuvSGer7rexhGoOt3wb+8l70DhF5bbXDSMgSFmQ1riX9ue74FXFvToAFNdLcZtTxMU26WZDFXHBrHSaUWQ3gOCIfVVNWTAfkNchavHgx1qxZg2PHjmHHjh0Ih8NYvHgxXnzxRVRUVGDXrl1YsWJFPnehAAo7lwWTxbYz2AG7rBu3jlyk2ZheADK5oC+M//fMYbzjF7sQSpA5yVlNlhhkZW7rzTJ4DEep0yCjsqcULmK5IIBYuWAaTFb7kMQMuWgx/OzK2ECc47i4gnkGVijeVJoZs8MWKjxHJBNssqkuMqLCpjJJieYX2UkGGUsAECar3Gqk+xF/DbPs/4g3BLfs+7J6rLpiU25l3mKQNX2ZLJtBK5qJ3P3YW7j1p9vF2g62YOE4qPaq2kBd7W5fKqtHU0onvWkmxhT44NomnPjGDbhidnlWr1dCNL6QL3jY2Cyvd61dDrz3Kfyu/mF8N/wulNtVro9bfwLc+Tug5SoAVO5Lh9R0JINyZ0E55IYfSiZLfh0foFLBeTV2GLQJmutOAcyh49HX/n0UDz1NjBLCUQHbW2MTaSzoBIA/nZau6yHYcNxFrncdIpJ0XoE7ltVhZWOxeMyUSVA2D5bbFGPGyHnCuOqtSVmMdCEFWWkkYW/6HvDfh4FP7AQ+toO467bvBNrfyPrzmeHP0hM/AJ57ID4oFYOsLGuyGJouI7e2qpi2FazuccgTBJa+l7Bcczam9xkGm5SQk5lSvEETiB9al7jPmo72MAVUWMSdPwVOPIfwue0AqLRXEKQgy15D3DcX3pF09+qKTeIYWF0UO480K4LaumIzdBpenCunq/lFXoOs1157DQsWLMCDDz6ItWvXIhgM4nvf+x6OHTuGxx9/HIsWLcrnxxcgQxEnkxmlO2HLXXTM0sTl0rIgKzsJCpMLDnkCeHJ3O3a3DYv1MHEw50guGKTvb8icyRpSOGkxO3fVxfBkw0JrOi7SIKvYrIeZGV/oLBAEIaH0AQDah2PZmjKrQVVCJ2XAY2VMbYPk9U2Jsp4JwCQ3ZVYDNDwnGlEsVtZjMYh1WVkyWTLte6lFj6vnVaCl3IJbl8QbTdiMOvHalrNZHcN5cBYEACeVC+ZggTZZ4DhOZLN2nxvGoc5R3PmLXTjQ4RRrS6x6rSrz/5HLW7Dp/svxwbVN0oMtVxHb8Kv+H/k/XfWByn4ZdbkLINgCcNQXQoTJd8R6rPgMudL9LwaOBmDh22NMJYr15D270mGymBGD4r0vk9Wi1SZisoIRHGh3AgCWJrrmpgjuvWoWWsot6HcF4AtFxJql107GjvHyIMstmNApkOMwLNhxpM+PEYHOfQnaApj0Gvz942vxt4+REo4xX1h0+AuGo+LCO47JGibyQpS05KTHHTPGSqtXlhxVC4El7yL3WQPpLDDqC6EMo6g++itgz2+lhsEMWbsLKrZfeQ+5LYuV75XGMFmXAp85CSy6M/3PsVHpoauHBEIj5zFGA0d5DZQaVOuywkFx/WTofpO+j5GsI5lM2FaNdMDzHOZRyaDSGEUZZLFrl5kK9U9T84u8BlmXX345fve736Gnpwc/+clP0NbWhvXr12P27Nn4zne+g97e3tRvUkBOYBWyCLLkk6dsgHDyDgCS1XOmYEzWka4xsHl60J2ACs45k5V5kMXs2xlYdr/AZE09lFj1MFEmK6Qx4pofvIbbHt2RsMaD1TkwzKlSPz/MeqmWgyEaFURpiXKCSIVlDcWYUW7B25aR4IlJnuLqsRjGaeMeU5Nl1mNhbRFeeXA9blykPjmyQKpzWFrsdubDWVAQZEzW9DW+AKQFjN2oxfxqO4Y9QTzwtwMik6WUCjJoeFIQHsMOarTA9Q9Li0bvsKrMa6LBgm9BkDEN3sRBVn+yIEsFxXSzdOSCiZisJfUOMZiqdcSeq+w6jkQF7G4bErefymgoNWPT/Zfj4+tn4IYFVfjuncRkYNvpgRib835X7DzVGiVjxrBgw/EeF3oE8vtwKcYQFuQEI1FR5sr6B1r0mhiJF/kA6hDN6ofGCZHJSqecQIl1/w2AI0YcfccyfrkgCBj1hbCAb5MeVAal47VwBwjjNv9twAeeBd4Wa2rD2OKs5XFMdTTWA+x6FPjxYlwdIPb6LMGd8KVqQZYswVM6vA8ANVJi55GlnEg30wQzv1Ba/NcVm2L6OTJGtdLGaoSnp/nFhBhfWCwW3HPPPXjttddw6tQp3HXXXXj00UfR0NCAW2+9dSJ24aJHbJCVrlxQZnsuG1AGQYows5ULskGcTZJAbBYuBrmqMWL65CzkgokCwCnJZFlpkDXaSYxLLjKUWvSiXLDPx+PMgAdHu8fw+51tqtszJuuO5WRBsnaGusU/kxnJ5XO9Y34EwlFoeS5OlpQKRSYdXn5wPR7aSFzW3rW6HkvqHarMEgDATt3msnQYLLMaYNFrwHPp9a+po4vTGCYrHz2yvMNAiI5NzFFvmuLDlzXjqjnl+MtHL8Xv7iY1SG2DHlFal41JkCgxigSAkDf5thMAnYYX5T6iZFBNLkjB+mmpyVLVUGwgQUOPM3XWOhFLptPw+NiVLVhQY8e6mbELYeYuCJAkH5AksTGFYNRp8Lkb5uIX71+BGxZWwajj0TcW269ROYeeFsiYNgQ7Rn0hdAvkXEoVZFn0WrC1Lgukj/WQWpz5NfZ4NlbOZOUA6fZrUkXpDMlhT8XGPBV8oQjCUQELOJlTYaIgK1MLd3mQVVRPGNyWKwFrrPN2SaJedOnCRucQVzdpAQFgTpQEwqLxzmgX0HsEcMcmY1UDXNl6sc5zFFqESU87dlzSZLEY3rW6HmtnlOLdq2Pl4VoNL9YBamW9HStl5hfTERPX/IFi5syZ+MIXvoAvfvGLsNlsMa6DBaRAOAB07SX3o1Hg6D9jmwWrgfbEMkWlIsi0pScxckFpsuoXiLwiW7mgTcV5TR5wxYC56vid6QUNoQQZ0HExWeqD3ZRkssrnEuty3wjQfzT19hcYSi1amDjyew0GJJnUo6+0xv2O/pDklvf/Ns7DSw9cif/vCvWFAnMYlPduYfVY9SVmaDXjG0pvW1qLf31yXWKWSG5XnAU0PIdffWAlHn3PclWzCyVEJmtEhcnKqbMgZbGslUkLpqcDrppbgcfuWY35NXaU2wzgOSAqSOdJIiYrKfQWkvUGxs/m5wis6bcYZMnt2xVgC+V054pi+lXT6ZXF5oxyFROWezfMwn/uvzwuEcjznMhmAaSWMqFV9xSFUacRreq3nZIWyQP0eLDv86phA9oNs/FMhNT+dFP5YCrJMc9zcW1WjtKAVOkOByBvQZZan760UDqT3GbSqoaCna+LNOelB+VBViRMmqcD45MLJjH5YZLcROuOlJAzWcNtAIAqjqz5rEYt6Uv4wwXAL9YB35sJ7PuT+FLVAFemfDIIASzk2kiijgXrTMqeJuZW2fHERy7Bqqb4IJUpQqqKjGJrEcZkFeSCaWDbtm24++67UVVVhc9+9rO44447sGPHjonchWkLPhqE9gezgV9vIBrhI/8Anvog8Oc7SfDRvR848ESspOTI08C3aoFjz8IUkQVZ6U7WHlmQZZEGiJ4IGWiz6ZEFAEUqlHVCJssgG9SDCeq2GI49C3yzFtj/5/jngozJyqImi05e8n5CPJegX8hkQ2uQCmrPZJ7Jm+4oM0iB+IAsyHIFwvjJK7ENXTtHfBAEIoEpsegxs8KaMFiS+utITNa5oexML7LCOOWCAOmblEgeqIRakMVqsnIqF7wATC/UoOE5lNDalbPUEtqeDZPFcVLGPEvzi1xDbEjsYXJBxmTFLjqjUSFhE+aE702H1HRqsiRL8czGYXmj8NuW1k7LXp1XUiOT109LCg/WS+h9lzTi/Zc04j233YQ/LPoDtkWJvLCbyQVdXWSd0LE7YVKSycpGqcMfM3uSu8OJGKJywdIZ4/xWBKq92DKBlfZkc2UfZC3kZUHWmCzI8jsB0DVWurbqDCYFk5UALAmWKsjqGPbitkd34PnDCqaNMUuubmCEMHIV3AjMeg1pdN5/FOJ3AICzW6XdUg2yYteLK/mTqHGYYk0vcgQWZMmVIWKj94LxhTq6u7vxzW9+E7Nnz8b69evR2tqKRx55BN3d3fj1r3+NSy65JN+7cEEgyuulTNH5ncC5reR+9z5g67eAx24C/vlxoG279KJz24CwHzi7FYawLEBJd7JmTUIVTFZnkLjXFGfZeyUjJktnlDK5fvVGitKO7abdzrfGP8eCrAyML473jOHMgFs0vpBbujLDgimJGRvI7ZlXJnc/JgFlBolp6vOR4Y1l0f9zqCemhqF9mCx+G0otKRdaVhV3QdFZMMN6rKwgygWzD7IyAeuD1ekk7JUvGBGv0ZzKBVmQNY1NLxKBydjOUpv/VL3TEoLJjLI0v8g1xCArBZPlCoTFnF9cHU8COPSSXFBIUYPGrsVMj6u8PvP2ZZll4acKmEEOC+ABicmqcZjwjdsX4ubFNTFSSonJ6gSO/xv47bXEPQ8A3vot8K97gSg5NnYZkyUIAo71UCZL0W4C4aDU5y5HTJZDPL+yZLKY8YM785r/UW8INnhRD9lr5cYXLOAwOkjdZCbQWwAN/T2S1J+WyBw8k10DT+3pwMEOJ/70xvnYJ1iQ1XtYXPdUck7pOmFMHAP7/SBdpzH2+YpxZzV/AtV2A9BGCZIcyryXN5LAVW4AxVrl9E3ThsR5DbJuvPFGNDY24ic/+Qne9ra34fjx49i+fTvuueceWCzTi6KfCojW04C0fRfJQjFs+z+pruHMy9LjzKrV0w99pkFW517gBJVyNl1OBgWdGSidiQGaUEh34lRCbVJMyGQBUgPhQAomi2Xl1OpWMrRw7x/z420/24G7frFLzKDMlUklKqdijywGFmSd35lYPpkKo13Ai18k9rzTCCU6MjF7BQMG3OT+hrkVMGh59LsCODMgMbrM9KIxDWZGbGIqkwueo86CmZpeZAXGZAVd8ZNkHiD1yiLnD6v9KLHos77uVcGcBS8wJguQeqGd6R+HXBCYgkyWQs4lr92VgdXzGHV82hbpzMLdF4qklIt5aD8yufwvHch7AE3ItZsHMMluz6hPbH8ySOfQCllgJe8h1s8z44tuoO118uDRpwkT9fz/APv/BHQRYwMxyPKF0OX0YdQXgpbnMEvR3gLOdmLfrjNLDNI4wYL47JksWuOUBZM15g9jHqeY81wyiXa29u0AYaXZ69KQC4YigthWRA37aSPtDkU/Q5FZGmkTHyqHE0UGmkhk80cJZR5l6yXVRtA0sHTbiQzzcs1h2LZ9jVjla03EITRHuHFhFZ7/1OX47PVzxceq7IWarITQ6XT4+9//js7OTnznO9/BnDlz8vlxFzyEBhpkndoMDJ4i99nAxtGJ5uxr0gt8TnLr7oc2JAUoQqqMaDQC/OcBAAKw5N1A3QrA5AA++SbwoRfFyS9b4wujjhdtaBmSB1k0uFHrlC4HCyiUvYQiYcLoAQnlghFFN/Etx/vgD0Ux7AliTxtpBDq3SmpYOSXrsRjKZpPi10gA2P846f6eqQnG3t8DO39C/qYRHFoaZMEgOmLVOUxY2UQyZDvPSNIHMchKQ+6n1ierTZQLTsBCTW8h2VNAYn/yCMZkOb0huPwhHKI9hRbXFRV6ZKUJxiKwur+s5IIAYKaypCwbEucaDiWTxYrnFUwWW6hlEpTreCk4TSYZjEQFsUF8pkEWM+F49+rpy56W2wwwaHlEBeLEKAiCqhFIhWye8plYrU4XYTkAMi/+7YNAlI5rdG3A5IJj/rDYsmRWpS0+WM6xfTsgBfFyJmvYE8S1P3gN39p0PPUbWBmTlZ1ccCFzFmTrDjUmK9N6LIayWeS2KnH7IpNeAxNtu5DI/CIaFXCQBlndTn9smxIVIwotF0WdgQZjLMiqXEBuXT1AhF2r9HePCbLIuPO8fxG2RpbAhCCw66fkuSseBIpz5wrLccTiXa+VQhNm5T7kCcbI9acL8hpkPfvss7jtttug0UzdRn/TCQJjstjCpHQWsf9suhx4F61D6jkgTcbs1t0PbVAKULigm5hoJMKJ58j7GIqAa78uPe5oACyl4uRZnKXxBcdxcZLBQXcAgiCgtd8d35jYSAe7VHJBxlaNdYuyB/K4rB5NJcg62j2KJd94GZvapcthyzFpgA7S/ZEHWeVT0VmQgeMkNmvTZ4DH3w4c+mtm78Gy0/1pTGpTCAaBnNc+wSD2XiuzGUTXwB2yBp4dw+lbklv1sUFWJCqgfWgCmSwAqFlGbk9uzvtHWQ1a8frucvpwqJNMzDl1YvOPAgP0/LqAgywGNZl0WhDbWEwVJksWZHmHJfMSZjhAkU2QBYA4lyF5Q2JvUFpsWVQaPCfD7+9ZjQeunY2v3bowo9dNJXAcJ45b7cNejPpC4jwlt7SXn4NRaxUEcOCiIaBzj/RmfYel+zQxK2eyWD2WuulFbu3bAZUgHmTcPt3vxi+3ncXucymuAyYX9A0TOWO68A6j+ejPcJeGJqpnXk1u5WZD4w2y7vw98F+vSAFOAqSqyzo35MGYX5qLYq4VawWA+IC3Tuskd1iQVTaLlGIIUbHWt8ic2MK91WPE5zSfRbiO9FFD6Uxg7f1Jv0cuYDfqxMSIsuXKdMCEuwsWMA5YK2MHs4Y1ZDF993PAnBsJgyFEpbosJhd094MPKCRGySZslp2ac2OcvSggDX7ZGl8AUlZ3NpUfjHhDeOFoL675wWv4pjJblSmTFQ0D7n7pcRZ88TpAG7/Pu84MIRCOYks3h84RH9yBMHa2xpuDzKywSo43U5nJAoAl7wQZaOlge357sq3jwQLagRO53Kv8g/7WXhhEaWCZ1YC1M8ik+MbZYZG1PD+cPpNlljUxBYADHSMIRqLQa3lSBDwRWHQXuT38twnpmSTWZQ37JCarNkeNW9t2AD9ZSSQtWiNQOX0XvIlQrjBkSNWjJiFEueDUcBesp1LS5w72oPvIVvJg2ew444tsgyzWYqDb6cOYP6QqE/LR65DjAIM2s2XMoroi3H/1rJhs+XREPc3wdwz7RBbLbtTGNJ+Wtxkptprg11FWNBoCOJXvTxOzcitvVo+1QFmPBeTcWRCQAgyXPywyNOeHpNqzrzx7NE55EgNTMZnrgczYrDd+jhVnH8U8niYN5tH2Qn6ntLbI1r6dwVJKlEEpIK/LUgNjsRhiJIManeq6rVZD14BM4WQqluqpqGTQrnCVBCB+5xFY8V8bFkD7/qeAjd8D3v9MRv2xxgM2RxeCrALyj4a10n3GbDE0X0lumWSQXUwhT+Ku5RRfffYo7n5sNykKZrVPxvgFlT8UEWUajiyNLwApq7u8oVhsQPfsQZIxYnaxIth+pKpFkfeRkddlpTC9YMYWUYHDo1vP4rWTAwhGorAoZCjlNoOYUZnSNVkA0HwF8FAn8I4/kP97Dmb2enYOeAfH36NsIkHPAR8MCEXIRFxmNWBRbRFsBi1GfSEc6x5Dl9Mn9shqLEnNRFlZTVYgDEEQ8J3nTwIAbl1SM3EGKPNuIQHJ4CnCNOcZzODiYKcTrf3kGlpcn6Mg682fA55+kg1971OS7fAFBCWTdaEYX9y8uAarmorhCoSxdcuz5MGGS+K2Gy+T1e304c6f78SV3301rj6HJTsseu20dAfMBRiT1THiTdgzzGHSifNrqdUAr14WCJfNiV9D0MSsxGSFxWtfruQQMUgdW3MYZBWZdKLy0EnPoTbZ4vp4zxj+vrdD7aUEHCeVUWQSZHlIYnZ7ZAGem/FVYMHbSK0ZINm4s2swm5qsDMAaEg8l6NF5QBFkyZvGA4iRDEZB5q5KauMurqOMDslwiNbGMpOo/rGAaLoRcpO1ohM2vHtNA6mRX/2RCVUfMHOptkKQVUDe0XipdL9+TexzLevJ7dmtpAZHHpREyMU6ItBAQzZh+0MR/H5nG7aeHMB/DvVIjXsN8YMqq8fS8JzYlDIbsKzujHIrSqkGfzu1o+0ZUwwYmTJZQGxdVgr79mHZQPbMgW58fwtZQL97dYPIuBl1PMx6rbjwzKnDWr5gsEoSs/4TySWiSsiP9cDJ3O5XPkGZLJ8gLTbKrHpoNTzWtJCJ8av/Por3/+ZNBMNRzK2ypfVbymuyXjrej91twzBoeTx43ew8fIkEMNoJuwwAh57K+8cx9u+X284iKgDVRcbcNeBmTPPVXyEJgQsQZXFM1oVhfKHX8vj5+1ag1mHC7ADpxRdVLtYhBVmZfm/GDO88M4RTfW74Q1GxfQADk+1mWo91IYGZX3QMe0VnQeX1yfOceB6WWvTw6WRBVuUCYON3gZUfApa9nzwmMlnMwj0o1sbFyaojIaDzLXK/ZmmuvhY0PCcGeawmiTFZTLIol/OrwpZFkEXXPa9Gl6Gr4VYSrDHpIUtSi8YXWcoF00SJWJeWPMhiSd+E5hcAesxkjioTlEFWkRRkUYfBuVV26DQcesf8Yk1zyEVqLk32ctFld6LRTOue24YLQVYB+UbzFURHW9QgFVEyNNAAbOg04BlATC8EivMCoZFDrvjaFAB4Yne7xGKoBVk+ctGTbFP2GcSbF9egucyCa+ZXitk3pjHuGw0gKpcDpFuTlYjJYkFjAmdBxmRpOQGRqCDa4t60uFpsmFdKe958/baF+NLN88UanymPonoiC4iGMquvkh/r6SQZpOeAF7Igi55fd69thk7DYe/5EZwd9KDWYcLv7l4FPg0mivXJ8gTDeORlkr398GXNqC6a4GB78TvJ7dGn8/5Rd66oR6lFj2CYMNdyW91xw0PNEizluXvPKYYLlckCSAD56/cswGKOyMWe7InvlZO1XJBKsQ93SUnCmBoREPdBIPN6rAsJTLbZMeITe2QpzzlAMr8os+rh08sYmMoFQPVi4OYfSmsJRU3WuUEvguEoeE6ScYrofIskMM1lQGViI4dsoDS/YDKxd6wk8rYDHc7kFv9WRXCUDmiCzgOjdM7aFE3gGaM1QUzWsCcU95w/FMFxKuHcSPsetiuDDxYcAjhtJL9NSUQlyHLEBlkWgxZrmkkA+epJMkbzfhJ4V1Xlrh9WpmBMVnuBySog73A0AB/eAnzw2Xg3H3OJ1FOKuQ/KIGiNGOZJcNDdI/XbkVOwe8+PwDVGL8YkTJYjS9MLhnevbsCrn1mP5jJLXO1CMBLFsDyDI1q4ZxJkSd+vd5BKIxMwWUMeMkG9vTmKL980F1+9ZT4eu2cVljUUY3UzDbIo27awtggfvqx56vbIUoLjgGrSjDIjyeB0ZbIom+mjQZZey4uM62WzyvDqZ9bjXavqsaqpGH/68Oq066nYYm7UJ9UovO+S3LkqpQ3G+rh6JDlwnmDSa3DPuibx/5yaXjAJ6oUcZCnGNVu27oJTjMlimC+chZ4LY0Aowpe3e8XMN0PWckGVa1IZZDEmy6S7eJksqWZSYrLUgqyZ5WTeay6zwCeXC8rrIJlzKZML0t+stZ8kXCvtRtLIVg7Wh7FlPcDndikpN7/wBsPop3LIjYuqodNwGHQHYxqlx4HVJGXCZFHFi1eQB1myYM07LNW716auqxoPSsUgK1590jbkQSgioMikwyUt5PfsiAuyaEBkdOA8T2R9RWGa2FJjspyS/HL9HDImbz3ZD0TCMNL2Pw31k+fG2VyQCxYwoahZCpQ0xz8u1yKrBFmcsQh6G7koe3skx5w2xeTYP0AXQKpBFjO9yF2vHKWsBlB09zaky2TJBl2amekY9uJb/6JOSgmYLObgU2kS8P5LGnD3umZcNYcM0rcurcGcShvumKZNKwEAVYvJbdZB1jRispjxBZULlln0MYxrXbEZ3377Yjz1sbVoKU+/MbWF1mR1jvgQiQow6nhUKzO7EwG9RZKqjCapS8gR3n9Jk1ibuLTekZs3Dfml88syTRjhLFAkq4cBxiEXFJmsqWHhLqJ9FwDgnHkRIlHgb3tiz8fx1mSpvReDl9VkGS7eIIvJ94Y8QXEOVwuyvnLLAjzxX2uwflaZIsiSOdyZYtsEMJk8q2utVUtGnXmV3M64ajxfQxVSL7agyGI5zDpU2I2YRyWDyrqkGChlfumABlluGKVrVXyfHuDIP0jZReWipBbsuUAyJmuEPlZuM8SwmTFgNa7FTeiOOgAAliBd18UEWcz4Qrp2ry/tRzlG8ObZYXhGB8THZzVOXpDFjC+GPEHI2txNCxSCrAsNLDOsEmTBWARbCQnCnEPS4MP6/Syhiyivi07mKkEWk9Yx95tcQG1iiLEkZXLBdJsRA6Il6blBDywg7xXWJQiyaE2WVWUtUF1kwgufvgJ3r1MJaqcLMmWyBCH2WPcfB17+OrDpf8R+GlMWCrlgmcq5lQ2YXJApVJpKLZNXcM8KjiegX1aRWYefv28FPnfDXLFGa9xg7QF4naq5zoUCeT0MMA4miwXVgbHMLKnzAXlrDDqe2GcSmfrT+zpjXN/GsgyySi36uD6KiZgss/7ilQsWmXRiMLSvnczZFSrjXZFZh7Uzy8DzHDx6yvCYS2PqdmBykFvKjhcplCq1yrpV3wjQTRoXoyUfQRZjskJiPVYjrcthyR5lkNU76scnn9iHna2DMuOLfqQN0ZlWxmSxY+TqAQ4+Se4vfU9mXyYLlKjY2DOM+qREN6vLG3AFiGkZw6zrSWufS+9FR9gBADAF+sn8HaJJdZNDJhfsJJNb/3HUPXUjnjY9jEgkhK0HiIrFKViwoC6/EslksBl1Yv+8gWnWk7gQZF1oYIOLmsTLWISqasLI+Ef7xYmLZYreu6YBc6tsMAk0WFEJsiTtd+6y+OpMlixgStv4QiEXdHYg1HcSZhpkOcPxgWEgHBG7qttyR85NLVQvJbd9R0lj5lQIukkrAAZPP/D694HdvwRe+mo+9jB3CErugoD6uZUNlLUfE9KAOBFUJB75xBWzy/Hx9TNyF1TK67EucGc4lkAy6zXxcqt0YSyC2IphMtksZzvww4XAU3eT/2mdyow5i1Bs1qFvLIDXT0uZ72yZLJ7n4modE9VkXczGF4DEZg26g9DwnJgoTQSXqQ6R674FvP03sdcekwuKTJYiyGJMlncY+O31wK83kDmibA5QlHuVh1wuyNYnTZTNSBRkPbO/C/851IOP/mkvuiM0eePOoiZLTS54bhvQtRfgtVIrjTyCMVlqzYjlJRsOs040o+iUm19Yy0lrn8V34XyIrOP0gZHYoNNgB+y1ADjSlNozCJzaDE6Iol7oxk38m/jnjkMAADdvn/T6RzbnDvin15xRCLIuNDAtcgImq6KC0MhFggubDpMiTsZktZRZcN+GWbByJMBxgwysbYMe7DpD6pqYNlotY5Yt5EzWnEoyIKgyWcnkguGg1LUeIIHBz9fiiq13oZpalw4E4id7JhXU8hxMF+p8XdJC6tHCPmCoNfX27DjzWknbzRZ5u34KHHs2L7uZE4QUckFrbhhXpSypsSx1b628gTFZEyAXzAvEeqwLVyrIwM6/rFksAOA1MqZhEuuyNj8EuLqBk8+TrDc1AdA5anHbUrLQfmqvZDiUbZAFADUOksQz6viY92LwBFiQdfEyWYDkMAgA/331LMxIQwIdXfURqVk9A5ML+p2AIMRJW8U6uSP/ADrekPpjzb4+211PClEu6AmJdTiMyWKB5JGuUYQiUjKwhyZm3YEwHt5GrxNX+jVZAlVveGCUgszyeeSWJYZmXksCmDyjSNanTAmneF0RKXydrF+aGjp9JgQEep0M0uS7wU7GFa1BSsyPtkvtfwB8XPcceDrehA3F4/5O4wUzvygwWQVMLliQReVyMMjkOMYicHRhU8y58I+9nQiEI+imFq2NpRbcuLAKdo6cxf88ThbbH/7DW3j3r9/A+SEPBlzkuYocNuOVB1lXzSX7H1uTRb5DwDOCUW8CuZqcxWLmH4Ex6CJeLODbAAA9vvgoivWhKLHoL9ykOs9LfTM8A8m3BWTuknag+XJyf+N3pe7uW7+d+33MFWiA6AJZfOSKyTLpNJB7nTRPJpM1gXLBvOAicBZkYGNb1s6CDJNtftH6EnDiOXI/7Ce/IXNas1XjzhWktuOlY31iA9nxBFl3r23GpS2l+OClTQDiF5veIEmoXcw1WQAwu5IEVaubSvCJq2Zm/0YsiI8EgZAPFn3seCfKBVkd1tL3AXf8Grjyc9l/ZhI4LHImi8oFKWvXXGqB3ahFIBzF3vMSsytPzO4domsATz9pZ5MKghAjFxSTIpXzgQ+9AFz7deDSe4EbvjXer5YWxGbQvnCciyJjsth11UCPy//+5xg2H4ll7gRBgCsQRr9Ag6R+Wl8tl2mz+aRzL9D+BrnPazGPa8PtOvI/b82vZX06YOYXA77ptVArBFkXGlhWgqFc1sfHWCRmrIo4D/acH8GO1kFEBcCi16DMqgePKMwgQdeO9gA8gTDOUEvz031uGZOVO7lgS7kFOg2HedV2seGhGpPlc43gC88cVn8TVo/FaeKa5M3kSMDZ7ok/3cUas3G6JU55pNvQGZBkmUY7cOtPgE8dIs0HmRY9EwnGRINm3py0H1yugiyO48S6LEDKqk0KRLngdA+yLgYmiwZZ4zUKYuYXk/Wbb/lK7P89B6lygAOsFZhfbYdFr0EgHEXbkAfRqJB1TRYA3LCwCk9+9BLMpsqGsQTGFxc7k/Xhy1rwjdsX4lcfWDE+x1u9lSgXAMA3Ao7jYs7ZOoeJSM3bXicPrPowsPgdpBdjHiAZX4QkuSBVD/A8h3Uzydjxod+/hWcPEtkqS8w2lJgxCDrfRcPpsb/hADiBnFOcwRrb1qPhEmDdp4DrH1Y3HMsDWK1dMBJFIBwbJIo1WfQYvXtNA2xGLc4MePCxx/eKjpAAadodFYBu0CCp7wi5lQdZczeS25e/RtQulgpg1UcAADdyxNymunryjb8KcsECpgYYk8VQpgiyqPa6VEMGru++QGSFjayQnzXuBXBkMBpjy9vl9CXsLD8eVNiM2PLpK/HEf60Re3H0jsmZLDLRWuHDjtYB9f4YjMnSmaUaJFowXsaRoKHTw4kF0wzMIjWXRh5TEixTmU6QxeSCBhuRExRTq3J5oJasR8lkgmb6fVoSmOfK+AIAzLKs+aTWZCl6m0w7XAT27QwSkzXOYKBxLbl95X/Tu4ZziWgU6D9G7jP5MGtCa60ANDrwPIc5NEF2rMcFdzAM5oExngCTBWjx7oKFZsQAMah4/yWNYg1T1uC4eBt3GftaW2wiNUmBMZKoZWZKeQIzvuhy+tBNZYANJdKY+/XbFuLSllJ4gxE8+LcDGHQHxDXDyqZihKGFS8PqstKQDMrWPXpTfgLHTGDRa0UmUZlgULbRuWpOBbZ/boPowNfllNZO7LUdoMn37v3kVh5krfwQUa2wY9ByJXD5A1ItPACddfITYpe0lODxD63Eh+ZEUm88hVAIsi40WJRBlqxhsbFIXGxbBQ84RMWmdoyKZY17g4IGHa5oTHFp54hXDLJyWZMFEGag2KIXbbF7Rn1iMHWUtrnSclEEfW517bEYZJmAW34EfGwHsPS9MZu4BROOdsfWdcnlghc0MmKy6DZyqan8PaLhWHnmVAJ1x+Jp5r8yh+cpK/w16TSozKFcNmMwJss7JEpcphUuopqs6xdUYd3MUrx3zTh7ql3xP0BxEzDWCbzwhZzsW9oIuiQjHGZd3bGb3DIZMoC51Fr7eM+YKOs2aHkYx9HLirncJa7JuriDrJxCrPuj5hcmMt49YHoO5ifvAPb8ljzffCWp58kjWADR5fRBEIiFt7y+ttxmwOP/tQb1JSaEIgKOdY9hkPYKW9VExv4xga5p0pnzaIDhE/SwmiahNYcCPM/BZlSvy1LKBdl9Zk7CzDJO9I6hjwaevRqaHGHtWFhADZB5fdWHpf+bryTJkw1flO3Q5F9npVYD1jSXoGiaLdUKQdaFBiWTZauWMhLGInGhzAlR3LFAWkSzLAirx/FyZgActhyTskBHusYQpunJXMmwlKi0kwHOH4qKE+vv3+pHWCCnqg1eHOx0xr+QyQV1JsLAVC2UFqMUXsGIw12xA24+LOmnJDIKsqjcwGiPfVxnliQlE51NTxdUGvLu9Utw99omrGjMXcEuc3FqLDVPnn07QBZDLACeIIfBnOIiqsmqcZjw5/+6BNfMr0y9cTIYrMDtPwfAAfsfz6z/z3jBrnWNASildT9de8mtzAac9S860TM2rnosOVIxWZPteHZBQeyV5QRAmKx3a17G/cITwLnXgEN/Jc/noS+WEsUKZu7quZVxY66G58RGy7vPDUMQAJ2Gw+I6MjY6o7SOLFV/TUBMVrnl9u2TDBbkjvpi1TfsWlCyl8UyR8a950dww49ex71PEOZqUE/lfixZomydsebjgNZEyi1a1pPHVn4YouEV67VZQMYoBFkXGpQ1WUaHtJgxFpEgREMCpC9uqBE7i4uNWekCO6ghQdfOM4PiWx2iwU2JRQ+9Nj+njlGnEQOenlE/3IEwnj3UIzodWjmfuB8xYMyKvOGwIzbIcsOIYwoma7jAZMVDLheUg+Mye5+JRjgoZiSvWDIHX711AbTZ2margGXNJ1UqyDCdJYMXUZCVUzSuJU6hADB4euI+ly66YXJIdt2sblPGZM2vJuPF8R7XuOqx5BBd1nwhRGU9uKSarMnPsF8wUMgFl+A0vq79PXnMJgXT+eiLpYQyyLpmXoXqds1lZN3C1imVdqNoaz8SoYxUkrnKH4ogGI6KCh6vMIWCrARMlhhkKfaTsX8j3hCOUYVSFzU1GzXVxb65MsiyVQJ3/wf4wD+luUWjBT5zmiR35t823q9z0aIQZF1oMFgJ48BgKgbq15AMRSWVelBZQDHvxWP3rMIn1s/AzYvpZEknz6iOTJis4ztAiiiB3EsFlWCSwd5RP072jiEQjsLLkYWtHV4c6lQZNOVMFoOSyYJRpM8ZGJNVWgiyJLAFlMEe/9xUDrJYDyGOj5c65gCMyZpU0wuG6ewweBHJBXMOFmQxC+2JALvWjUVAkWKxZpeCrDlVZLzoHfOLttu5CrKiAuAOShl9T8H4IvcQmSwyjl7pfQE6LoLjjiuB+/cRd731X5BqdPO5K3qNaN9vM2ixskm9EW5zORmLD9I1QXURsV8vMukwBlYCoc5kBcNRXP3913DTI69DoMk571RisoxSgkEOpzfW+IKBBaZObxBDVDrJ4DbHroVUm8DXrQCar4h9zFpODK80U+OYTEcUgqwLEXLJoMkB3PYo8NlWyWlQlrFaXOfA/9wwV9LNUyaLM8Y3ImbIpemFGliQ1T3qw+k+MviFdCRjZeO8ONI1iogsqwlAqk2RBZiCokmiRzDGGmoAGBKNLy7wQSQbJkspF8z0fSYazEXK6CC29TkGK+xf3Tz5PUOmrcOgIBSYrPFgUoIsJ7k1OgC7IsiSMRxWg1a0k37zHCmkHe+C1ajTiKoJefsOLzUwshSYrNxBrMlyAgBaDGQe0M25niQvr38YWJ8fy3Y1sKDhijnlCZUzrJUGWw+wcoO6YhNcAl0LJJirekZ96HL6cLrfDaeTBJZTUS445peSC8FwVEwwOEyxiWE5k8VqzRm05mKpDQSgHmQVkBdc0EHWww8/jLVr18JsNsPhcEz27kwc5OYXbMFpll1gisE0BjSjo7dIF6GW58SsEpBb+3Y1MDnWqV4XWvvJ/giUVSnVBuAJRnB2wB37IhUmy81ZMSZI/3tUmKzhQk1WPOR9shK9j9q5M9lgTJYpP0HQg9fOwfbPXYUNc8dZX5MLTNeGxAEXEKFZVnOBycoYk8lkmRxJmSwAmEclg2+eJQmPXCxY1eqyRLlgoSYrd1AwWRUc+d1ntsyYlN2poAFTIqkgIDFZDCxBW19sxhiSB1mDskBkcIgkBbyCUWx6PNlQY7LYNcBx8Q3O5UzWoILJsht10tgBSGvAAvKOCzrICgaDuOuuu/Dxj398sndlYqFkspRItuCmC2yTVXpdY6kZdbLO8rlsRKyGRbRw9XDXKE7TIEtrIgv+OQ5SuBknGRSDLGk/nd4QugVpIecRjHD5w2LRNCDVZBXkgjIEEtRkZfo+Ew3WqNWsLi0ZL3iei7kOJhUsyBppm9TdyBiMxdJbAf0UOZbTCWKQdW7iPpMlVIxFhH3kZYGTvFYHwFyZZBDIQX8wxNZlMRQs3PMARU0W3P3kVmmmNUH48s3z8Nnr5+DWJYl7NFXbjTDIWC5VJiuBXFAuqRtxOgGQROzMism3cAdk571fHmSR9YrdqIvt5QUpUTziDcYxWTajNrbHV4HJmjBc0EHW1772NXz605/GokWLJntXJhbM/EJrIn2OlFAOpnLQIMtgKRJ7u8wot6LGITFC+a7JWlhLBoBjPWM41Uf2x2gjWbZrozvwkv4z8LW9FfsieZ8silFfCF2yIEugphh9Y2RwDYQjcFHZyYXPZDnIbVpyQVkNRtz7TIEgKxIGBk7F9+rKM5M1pVBKs8tDZyZ3PzIFq8eiPewKyBBsoTR8duJ61YnjgYOoIuQybFtVzKaXzoj9XeW229mCzUNyJstTML7IPeQKl2gU8LAga3KY+xWNJfjkVTOTNlnmeS7GiKi6iKxT6kvMcCG5u6CcyRp2kgSdR5g6QZZdTC5ISWFljyw5RLmgJ4RBWgaxcRG5Ppc3FscyWYUga8JwQQdZFy1Y5ikRJZxMLkizPpzBJg42MyqsYg8GIP9yweZSC6wGLfyhKHpoF3ernbATM9x7MZPvxprzv4p9kYpccMQbjAmy7DYysLDO8Czbo+W58TcLnerIufGFMye7lRW2fBl4dBVw+sXYx1lNlik/TNaUQjFdbPudEoM3HVCoxxofHA3E2CXkkZiGfEOsyaLXPqsH1JnjFmuXtJRi839fjs/fOBcfvLQR71ilKLjPAkq5YDgSJY5wIE1bC8gR5HJB3wjphwhMGpOVLpplRkRVRRKTlapPlpzJ6u4jyZ+I1jxlEq5sTSJnssQgS4UhjjW+IGubT18zGwe/fB1uXFhVCLImCYURSoFAIIBAQLr4xsbIgjMUCiEUCiV6WV7BPjfdz+dNpdAAEIxFCKu8htfboAEQ8Q4jqnie942R53QWrJtRgn3tTqxudMT0lyoxa/J+LOZV2/BWG2EmSiw66Myxg8IYZ43ZBz7gIvutMYjfacjlR7dAMquC1oQyuwmtQ350j3gQCtnxynHSa6a5zIxwmEwok/Ub5x0aM3QAhMAYwsEAWaglgNY/Bg5AWGuGoDw/dOTciXpHEMngWGV6DieDpvcweACRjj2INm+Q9s09SM4BY1HceX3BgdNBa68FN9aFcN8JhCqXApj65y831gstgKi5NKPzZyogl+dw9uChtdeBG21HeOA0BGP+Ewoa7zC53vQ2REMhaGzV4AEItipx3JRjRqkJM9Y2iP+ne7wSHV8brbsa8QQQCoXgki06dbww5c/5qYJU5y+ns0ILQPCNIOzsIvOFuRThKIDo1D3GDSVS0reMrk2qbXqRyYr6R8Wx5niPC398ox33b5iBfpesPjvoBrSA3mzP+nzK9fhg0TPDl6D4nkNukky2G7Vxn2PVE8aPsLyE6bUbeJh1QDgcBmevFxf8Ia0FmIbXzdQYg5HRPky7IOvzn/88vvOd7yTd5vjx45g7d25W7/+tb30LX/va1+Ief/HFF2E2T24NwZYtW9LartQ1jMsA9AZN2L1pU9zzLf09WASg5+wx7FU8v6LtJOoAHDvTgRnlp/CtVcDYqTfRP8ABINKMY3t3of/o+L5LKlgCPBjRWswHcaKtGwtkzzs9fmyS7fvijhNoBnD6fDdO0sd39HLwUyYrAB3CriEAPF7bfQDarv345SENAA7zTWPisU33GE838NEgbgHAQcCL//4HwtrExb03uAZhALBt9wG4Dg/FPNc00IklAHrPn8JbKudWKuTi+K7va0MRgI5jb+KgW9qHJe2H0ATgVMcATmWxb9MNa6NFKEcXDr36DDpKCUM01c/f2b27MA9Ax5AXB6bpbzTZx/jSqA0VAA5t/Sc6SodSbj9erGk/jSoAh063o314E+b2+zEHwGDQgJ15+A2Vx3ekn8wF+46cwKaxY3AGAEALHgJeemEzJrMv+HREovPX5uvCBgChsX7seeXfWAvAFTXh1Sl+nbr6ydqEg4C921/FAR4IRAAXNb5wDXZjK/0Of27lsXuAh7u/HX0+DmyNYQYJuIIRIWZdkQ1yNT6cGibfq6N3UNynXd3kMc/IQNx+RgWAgwYCbSDMQcDOrS+BqS31oTHcSLd9cdtuhDWHc7Kfk4HJHoMBwOv1prXdtAuyHnzwQdx9991Jt2lpaUn6fDI89NBDeOCBB8T/x8bGUF9fj+uuuw52u4p8agIQCoWwZcsWXHvttdDp0igkFm5E+NxylFXMx0YVqp876AS6nkBNiRWVGzeSB53tQNADjcsGjADzlq7G3KUbxdeUt43g8VZSB3XXzdfDlGctfOhgD7b+nQwCq+fWY27pLKBbet6uB67YKO2f5t/PA4PArHmLMWMtebxt61m80Ebc1wwl9VjW0II929tQUtuMhiU16Nj1BnQaDl9499Ww6bnMjvE0hHD0XnBhP667Yo1knKAC7SHC5F5+zU1xbmLcES/Q+UdUOUzYKDv+qZDxOZwE2lZiI9xQpEGt/Bz4+9+AIWD24kswc2X6+zZdwW96Gdh/DEvqrZi77tppcf7yW3YAPUDdnKWo2TC9fqNcnsPjAf/8K8C+o1hSb8ei9fk/hpo//BQYAxatuhwL524EdyIK/ONZlMy/Ahuvzd3nJzq+p15uxeu9Z1Fe24CNG+fj7IAH2LcDFqMON910fc4+/0JHyvPXOwSceAj6iAdrZlcAZwBr9YyMxvnJQFW7E0+e2Y0KuxG33Hyl+Pi/jvYCEcDIh8Xv8NQf9gIDQzCV1cEw6geGiFrGwpEgq76+Eauz/L65Hh/K20bw65NvgTdYsHHjZQCAky+1AufPYv7MRmzcOC/uNV8/9CpGqKSw1GrAzTetj3k+Yj8DQMB1V7193Ps3GZgqYzAgqdxSYdoFWeXl5Sgvz5+e32AwwGCIN3bQ6XST/qNmtA9zrk38nIVI6PjAKHidDgh6gd/fQGpx7KSoWWt2ALLPmlNdBJ2GQ4XNCLslvzVZALC0QZLBzK6yQ1Mcy0xqI77YYxEhg6TGaIWGPu4KRHBMaMKzM76KW6/ZgJqzJLM14A7hb/tIxHbjwmpUOiwi9TsVfue8wVgEuP3QhT0xv20MQn4gQvTcOmtJ/HbiuTNGzp0MMe7jKwiiwQXv6o7dhwCRtGqspeI5cEGD9r3TOM+Jx3TKn7+0vkdjLZ+2v9GkH2NqeqIZbZuYY0hrNLUWOh4svB0oex2a8jnQaHP/+crjW2wh8/HrrUO49DuvYcNcMv9b9Nqpfa5PUSQ8f4uqiCGNdwiajl0AAN5WldU4P5FY1VyGT6yfgcV1RTHfa35zA9AKcIEx8XFmdtHlDIjBCABYKJNVUlo67nMqV+NDCa19dwXC6HWFsO30AEZ8zKjLoPoZJRa9+L3KrCrbXPdVAEyTNH0x6WMw3Yd0MO2CrEzQ3t6O4eFhtLe3IxKJ4MCBAwCAmTNnwmqdGg4ykwKl8cXRpyUnoWHqVqaw7y61GvDMJ9aJvRvyjZYyCyx6DTzBCDHgmHEzcOtPcKqtE7MPfQe6qC/2BUHmLigZXzhpoXRX/a1A9QxUDvYAADpHvDh7ijQvfvfqxIzOBQdjEeDuS25+Ibe71efAwr3vKDB4Cph9c/r7mQwhLxCmWvqx7tjn8mzhPuUgOgy2Tu5+ZAIvlbcV3AWzx0T3ymLzBJs3OA6oXjwxnw3J+KJjmIz5/9jXBQAwG6b7UnEKomwO0L4TOPc6+X+Km14AxGHwf26ILw+5YlEL0Aroo35EQkFodHoxyOoc8cJPzVNmV1phGSFzSnnJ1BmXpD5ZYXz9uWPYcqwPWqr9S9QagZhfkLVNaQ6cPQsYPy5od8Evf/nLWLZsGb7yla/A7XZj2bJlWLZsGfbs2TPZuza5UFq4v/Xb+G1UnOUW1hahoXRi6tJ4nsNDG+fhzhV1uKSllFgHL/8AwqUke6+PKIIsFQt3p5cMqMzalPXQONg5ClcgjFKLHmuaL5IFOZBegMQaEett5Jin+x6CALz4JWD/n2Mf//uHgafuBvqPZbXLcfDKalACY7H2vKK74EVg4Q4ApTPJ7dAE2nmPF4Uga/xgFuqu3on5vGQtHSYAyobGkSg51wv27XlA+RxyK9q3VyXedopjzTypL9S+U+cRiQoYptbmPWN+jND1waqmErEmq8QxdeYOFkgFI1HsaSNzW5ie+w6zegAlf7zMmt9WOwWkhws6yPr9738PQRDi/tavXz/Zuza5YBlJ/yjQvR/o3he/jVoj2gnG+y5pxPfuWgKdRjpNdWYS/BkFZZCl3owYkOxOKxVNlK+cUx7X0O+CRjpBlrigSlB/KH8P+cK+/xiw8xFg02eAKHE2QjQqsixcrprmKu3K5WyW2CfrIgmcHY0yO+8JWnCPF4Uga/zQUxVGML3C63EhHADCdGxlybkJhjLIYjAX7Ntzj3IFIzRJPbJyAb1ejwBPlC2vHzmDYU8QNEaBIJA/jgNWNhWLckHeOPnrHgaLXiOaVsiljYC6hTsAFMv6Z5VaCkHWVMAFHWQVkABsoRwJAm/8nNyvWxW7jX5qyikNJjIIJg6y4uWCRXTgUfb3umrO1JdC5BRpMVlJemTJ30OIENtbBpZVD3mBwdPkvndQtP7l3H1Z7rQCXoWb2lgnuQ3KZIQXi1xQqxcNTLiJko6NF6KksxBkZQ2WSAp58v9Z4ljBJR4T8gzW+wgg0i4GS4HJyj0Yk8UwDeSCSUHP2QOnz2NQ1heLocSsxw0LqlGmp0GMPrHr7kSD47iEskC1ZsQAUCzr8VWQC04NFIKsixF6K8DRCerEf8jtlZ+LXfhMASZLDXoz2S+T4I99gi04VJksMtjotTxK6SDEc8AVsy6yhqjpBFn9J8gtkyQpoTMBvC7+fViTWQDoPURux7pkz+eocaqSyRqln8FYLF47ZRMEeQGTDLJayqmMkF8KzC+WQDgf0NMxLhoGwsH8fharxzLa1eXDE4DGUgt+/K6leOpjl2LtDKm5fIHJygMuICYLALQWBwAg5B3FucH4pESpVQ+TXgM7T6+jKRRkAYipgZ9fbRdrshJJAeXBV1khyJoSKARZFyM4TpIMBt0AOKB+NVC3WtpmigZZRgvJTJnhRzgckZ5gTBZdgIz5Q2JNVrFFGnhYXdaKxmKR4bpokE6Q1UYLnhvXqj/Pcerv45YFUT0Hye1ol/rz44EvgVxQrMcqwUXVOKeC2PjypzZP8o6kAfYbcRrAMDn1PRcEdLKFYL7ZrEmux2K4bWktVjWVYEGNxKYVarLyAFtV7LU5zZksDT1v7fBi7/mRuOdLLQaiG2TJnym27rGbpETC5bPK8Mi7l+GLN81DU5l6MFgsq8kqyAWnBgpB1sUKub6+fA6ZROtWkv91FoCfmhMYC7I0nACvT7bAUNRkPbOvC+GogJkVVlTZJblJbTGRE66/2KSCgCw4cqo/H40C53eS+02Xp/E+CZgsFmTJ6qW4nDFZCeSC3ovM9IJh+d0Ax4NvfRFF3rbJ3pvkkNdjTRIrckFAqyeMLZC/uqzRTmJYw5Iuk1SPpcTCWikAsBgKTFbOwXFiawho9NN/PGVBFufBvnaVIMuqp6ZZtFhrCjNZsytt2LioGv91eeI+sDFBVoHJmhIozHQXK+SZSVaPVb+G3DKWawrCYJKkYH6PzFlOdBc0QRAEPP7GeQDA+9Y0gJMxGw9cOxufWD8D96xrmojdnVpIxWQNHCdsg84M1CzL7H2UckFBiJUL5orJYgt1O22SrJQLXmwytLKZwELSWHJ2778meWdSoGB6kTswNiuUpyDrrd8AR58BXn2Y/D/JTBbDzAor9FqybCkwWXkCq8uyVk5/VQA1cLLBhyNdZL6qdUh122VWAxBkyVouptxgKkAeZM2pSs2yFcfIBQtM1lRAIci6WCEPpFiQ1bgOWPffwLVfn4w9SgucRguvQAYPMcgKB0l9AgDoTNh9bhin+90w6TS4Y0VdzOvnVdvxPzfMvTj1/KmCrLYd5LZ+DaBJIqVMJRf0jwLO9pggK3dMFmWsqhaRW8aWDZ4it7bq3HzOdMLln4EADjWje6d2z6xCkJU7sLqsYJ7kguw8YuPqFEm86TQ85lSSxWYhyMoTWF3WNJcKAhCNL2zwIhQhbNXSeof4dJlVL2tbYp1yQSWTC/IcSTCkQsH4YuqhEGRdrJDLP+ppLRbPA9d+DVh056TsUrrwcyTICnjp4CjP5uos+MOuNgDA7ctqJqx58rRAyiCLSoOaLkv+PvIWAAzKIKr3UKy9ursvu15O/jGJpQKkhboYZHWR9z3zKvm/+YrMP2O6o2IuhFoi9eX6j07yziTBxdYsOp9gLqr5YrKGFG6VU4TJAoB1M4n5RXPZRWRwM5GYeS0JTmZdP9l7Mn6IckHpOlnW4BDvl8qZrCkmFQQkJqup1AKjLnVSocZhglmvQa3DdHEmkqcgCr/CxQq2UDbYSZf3aQQ/ZwKEMQR9bmDoDFnAAwCnwckBP54/QuzEP3Bp0+Tt5FSE2IRaJcgSBOA8ZbJSBVmqcsFBclu5COg7DPQcInUdFFwkCF0kwwVhNAr89loSWN23j0g/2EK9ejG5DbrJ53TuJv/PuCqzz7hQYK8BugBuohrUZoMCk5U7MLlgPmqyBAFQtgSYIjVZAJF837G8FrPSyOwXkAUq5gKfa5uyddkZwSgxWQyzKm2w6DXwBCOxckHD1DufWI+42ZXpGXJYDVo8/6nL0wrICpgYFJisixVs0qxdMe2K0FmDwYh7EPjNNcBjN5IndGb8+JXTEATgxoVVmFc9OX1dpixYcMRsmeUYPksWwRoDULM8vfdhQVY0KtVkzbya3Ha8Cbh6Yl5mCKt8bjL0HAAGTpD37jlA950GWfZawEztnF/7NpE1lcwAipsy+4wLBIKtityZyk2JC0FW7qDPY68sV4/UgJhhisgFAdKKY3alLabWtoAc40IIsABxrrLJmKwyqx6L6sjjMyusUm/IKchk3bKkBlfPrcCHL29O+zWNpRbRRbmAycf0Wl0XkDu0XElYrCXvmuw9yRhBGmRpnW0xlt5hjRGbDveC44D/vmb2JO3dFAZzigq6gEhsB3nREbByAXEvSwYWoDOmyu+UajcW3UVuz20jza7BAcVkgjCGkljHq+HMy7L9o2Ya8oX60veQ+/sfJ7czNmT2/hcSrCTIKjBZFwlYgX4+mKwh2nPNXgto6WJtCjFZBRSQNqgdvYOXkgblNgN++b6V2PLpK9BcZgH2/p48wXoOTiE0lVnw27tXYVVTQWI9XVEIsi5WtKwHPt8+LYOskIYGWa72mMc1PiJZu35+VVpOPBcdjA4ANPvrU9jZsiCreknq92FywtMvAgG3xGIZikiQVtIC0RLXWgkUEfMRQ6ZBVusr0v3eQ6T+JEybUJtLgcsfjF2wX8RBVoHJusjAsu75YLJYY+uKecDcm6X7BRQw3UDlgqVaMm9wHFBi1qPIrMOsShtw5hXg5CbSEuHKz0/mnhZwgaIQZF3MmKZyi7CGZHFN7s6Yxzm6sC8EWAmg0UqyH6+iqS8LsmqWpn6fulVEmhfyAsf/LTkLWsvJOTX7Bmlbew0JtAAYwjTIOvMq8LO1QOfexJ/hH5PqrACg97C0zxo9WWSaHMD6h8hjvDZ1LdmFjAKTdXFhIpiskhnALT8GPrr14r62Cpi+oHJBB5ULllr00GrosjcaBTZ/gdxf/VGpP1gBBeQQhSCrgGmHsJZkcc1eGmTZ6wC9DTvsNwGQikULUIGJyg7kTX0FQap5SofJ4jhgybvJ/YNPSs6CFmr5O1vmSlVUKwZZolzwpa8C/UeBw08l/oxz24gEke3vwEnJEt5cKiUIVtwDXHovsPG7YtbyYsT0YLIK7oI5g1iTlYcgi5lelM4gZgDJeuYVUMBUBrVwt1Dji5jeUYMnSW9InRm48n8mY+8KuAhQCLIKmHaI0iyuzUcX3Y1rgc+cxC/s9wMoBFlJwVgEeZA12kHkg7wWqJif3vssfge5PbcN6D5A7luoEUXDWkBP2UR7rdhvxRhyAn1HpIAuWUDA6rEWvp3ssxAB2rbHfgeAsHPXPwys/FB6+32hgjFZAReRcE41KOvpChgf8tmMWM5kFVDAdAZN6JjCY+AQRblNFmR17SO3NcukeuUCCsgxCkFWAdMOUbrA0EdpMaulDNBbMOYn5guFICsJ2AJXZhgiSgUr5gHaNLvEFzcCjZcBEIC9fyCPseaVWj0w+zpyv2xWjFyQP/Bn6T2SSdv6aL+nxrVAFbVrP7uVfocCExIHgw1hnpoUsJYGUwnKeroCxgd9GnLB0S7SqD0TRKPAyDlyvyR9R7MCCpiSoGMNjyjes9CKj18pSxx0y4KsAgrIEwpBVgHTDzqF1SodSEd9xDGvyFwIshLCrCIXzMT0Qg5mmhKgMkAmFwSAjd8Dbv4RsOz9YvBlDg6APyKTCCos3mPA6rxs1VJPrPZd9DsUFulq8Osc5A47rmM9wJYvAyPnJ22fRLDzTWOYklbJ0w66FHLBM68CP1xApLmZwNVNgmFeCzgax7WLBRQw6dDoRJbq4euqsbbUA2z9Nmk/0lUIsgrIPwpBVgHTDwbFIo3K1MQgq8BkJYYYZKkwWdVLM3uv+bcBWpP0P5MLss9ZeQ9hxmi9kDXQB87vBPS06aOrl8jI1MCaG1srJCYrGiamFyvuzmw/LxL4dFTywhjC3b8CdvwYePOXk7dTDOz3lNfTFZA9WKAaTOAuuP9PAASg863M3rfvGLktbiJS3AIKmO5g/RQ9A8D2HwBbvwW88P+IdB0AalP0hSyggHGgEGQVMO3AKzPh5jIIglCQC6YDsSZLFmQxaV7Voszey2gH5t0s/W+tUN/O0QCBujwJpbOAOx8jj4f9pMeWEiEf6eUFkMCtcR3J3Bc3Ax/eQtoPFBCHOCZr4AS5ZRb7kwm2T8ygo4DxIRmTFQ4Ap14k9zP97Vu3kNvGddnvWwEFTCVYysmtZwAYaSP39z9O+jiaisU+jgUUkA8UUlUFTDtojNbYByxlcAfCiEQJK1IIspJAaXwRcEmufeVzMn+/Je+SXAItCYIsgw3h/3oN217ejCve9mHo9HrSs8vvBFx98UXHbGGo0RN3KGMR8OAJIhMtZNcTQgqyKJM1eJo+4ZyM3YnFWDe5tddM7n5cKEhWk3Vum5SkyCTIEgTS+w6IdQgtoIDpDKaw8AzK6oCpgqJmWYFZLyCvKDBZBUw78AZFkGUuE6WCei0Po04zCXs1TaC0cB88RW4tFdk5LLVcRVzIdGZi+ZwIRXVwG2ukCc1WTW7V6rLYwtBSIW1vLCoEWCngF+WCPUAkLBkY+JyTtk8iRCarenL340KB6C6oIhc8/m/pftCdfi+twdMk06/RA81XjnsXCyhgSoAxWd7B+PmmpiAVLCC/KKxaCph20Jlimw3/46QPc5sL9VhpQekuOECDrGxYLADgNcCHXiCLPXlNVirYqkiPEjWHQVa/k8n7FRDLZDnPkxo2YIowWXRxYy8EWTlBIiYrGgFObop9zDMA6JOYWLRtB069ICU0GteR/lgFFHAhgAVZznZieAGQREIkWKjHKiDvKARZBUw7yIOskKDBZ587j1++n0jVCkFWCijlgoMnyW3ZOLrdW8sBlGf2mmRMFnMWtGT4nhc5YpgsJhUEpgiTReWCtoJcMCdI1CfrlW+QoMpUTJwc3b3k/+IkQdYLX5DMbwBg1nW5398CCpgssGRd72FyqzMDN/2AuNXOvHby9quAiwIFuWAB0w56s128PwwbogKHEz1jAApBVkowd0H/KJGUjZfJyhY20jtLncmicsFERhoFqCKGyfr/27v36Kjqe+/jn0kymSTkShJykYT7xWrgAK0Y2j4iIkI9Aq31gi4qirRVtGLtc+Csp4qcrlVL5fSsVl3UtoL2sd54vC211aICtYqogFUUIyCCXMIlkAuEhCHze/7YmVsykxuzZzKT92utrNmzZ+89P775sTPf+f32d9cEJFlNteGrOEaL75osRrIiwjeSFTBd8JMXpH/+j7X8nRX+WJ84bBWTORHi+iyPx38O8OJ6LCQS75d13kJAWSXSv82RZv7OuqcjYCOSLMQdV4Z/JOuYsRKuz6qtC71JsjqRliupdVrQqeORGcnqiQ6vyWK6YE80OfNkklKs0Y3tL/tfaDntvxFwrHinCzKSFRltqwueOi699BNrufI2qeL7/kI0J49I/+8m6bdj2idU9fulM6ekJKc0dZl02X0dX1sJxBtvkuWdPs11oYgikizEnbR+/pGsGmMlXNurGcnqkuQUKT3XWm44KB1rLY4Q9ZGs1lLeIUeymC7YE56kVBnv9Jev3g1+MZZTBpsb/NXuGMmKDO9tLM40WddhvfOANTpdeK6VLEmt03hljWR9sd5KyD56Kvg43hHP/kOkby2SKm+NRuuB6Gn7d4RzEKKIJAtxJyMzx7d8TFbC9eVRa9oMSVYXeK/L2ve+ZFqk1Kzof7vnG8nqYLpguJLwCMtTcU3oFwKLX0R76qB3FMuVLbmyOt4WXeMdyZKsioDvrrSWp/zcX4XT++Gy+l/+Ea9PXgj+/R/daT3mj7CztUDstJ0Rwb36EEUkWYg7Llea3MYq017TOl2w9RZZyibJ6py3jPvejdZjwYjo3yvE+4fuRHX7D/1MF+wxM/zS4FL8Ga0x9I5kNdVJv/s36ZW7otcoX9ELvkGOGGe6fNN+N/zaSqLOmSCNvty/jfdLir0Bo5rHdkmHtvmfe2/hUDDc1uYCMZOWKyUF1HjjPIQoIslC3HEkJemUXJKkYyb4m3FGsrrAO5K1pzXJivZUQUnKbC180XLaup4kENUFey7FJZ1/pbXcr1DKLbeWvSNZBz60Rj4Cr9myG+XbI8/h8I9mfbHeerzgR8FflmQGXJMV6NMX/cve6YKMZCFRJSX5v2ySSLIQVSRZiEunHGmSpNOu/kHrSbK6wJtk1e+zHkvGRr8NKS5/OwKLX3g81k0jJaoL9tTX51sfwIdf6r/+zjuS5Y2t934x0UD5dnt4KwyeaJ1yW9imeE3bkeDsc6zHT573jx57pwtGu/ANEE2BX9iRZCGKSLIQl5od6ZKk8rLg+7+QZHVBRkBi6sqWxs6JTTsyQxS/OHVcMh5r2ZuEoXuKvibdVSXNelBKa71+0TuSdbL1/mhnTklnmqPTHsq32yPwuixJyhsS/LztNY0X/FBKSZdqdkr7PrDKv3u/aClgJAsJLPALB67JQhSRZCEu7cgYqwaTrnO/flHQepKsLghMsi5Y4B/tiDbv+waOqngrC6bnScn8LnssLVtKSm4t2S9/jL03oZakpnr73t/j8S/7yreTZEWUt8KgZH0h0fb/cduR4NJx0nmzreWtf5ZqdlnL6f2DzwlAomEkCzFCkoW4VPHDVdp2/WaNr6hQfj//DQVJsrrAO0LkzJAujGHJZt8oS2CSRWXBiAo3XVCyb8rgztelX5VLH62xnnunC2YzXTCiAkey+oe4t1V6nuQI+BOfP0waN9da/vhZ6eCH1jKjWEh03pGs9DzJmRbbtqBPIclCXBqQk67KkdY1BiW5/pMmSVYXDL9UGnCedOl/xbaCn6v1fmfNASMqviSLohcR4RvJqrUeg0aybEqyPn/Nui/Wjr9bz32FL0iyIio1MMka2v71pGT/Bf8p6dY1cYMmWQmZ+6T0+r3WaxS9QKLz/p3julBEGUkW4l5JTrpvmSSrC7JLpFvfsaYKxlJaa5IV+GH/hDfJonx7RLQdyToZOJJVa897em9wfaJaajnjnwLKB5zIcgZMF8wPMZIl+acM5g+zqqw5HNL4H1jrGmus0taBZd+BROQt+pJbFtt2oM9J6XwToHcrzbFGslKTk5Tm5HuDuOGbLhgwklW7x3rk4uTIiMVI1vEvrceGaunEIauQSVIKo5OR1tlIluSPeWAS9o2bpdq91rUp4+fyfw2J79yZVp8f/e+xbgn6mIT9RPrll19q/vz5GjJkiNLT0zVs2DAtXbpUp0+fjnXTEGEludZIVna6U45o31QXPecKMZK15x3r8ZyvR789icibyPquybI5yfK0+BPlhkP+8vyZxdZICiIn6JqsIaG38Y1kBdxs2JUp/ftvpIv+NwkW+obUDOmi/7AqrwJRlLAjWZ999pk8Ho8efvhhDR8+XNu2bdOCBQt08uRJrVixItbNQwSVtI5k5aQnbHdOTN4EwHtNVlO9VP2RtTxoUmzalGgCKzgaY3+SVX/AusG0JDXX+SvYUb498gKrC4Ybyfr6TdZtEcZeF502AQB8EvZT6fTp0zV9+nTf86FDh6qqqkorV64kyUowFwzpr9wMpy4aSUW6uOK7Jqs1yfrqPWtqWd5gKeecmDUroQROF2yqlTxn/K/ZkWR5pwp6HdhqPVI2OfK8I1np/a2qaaGUXyhdvyZ6bQIA+CRskhVKXV2d+vfv+H4gzc3Nam7236Szvt76AOh2u+V2u21tXzje943V+/d2BRkpenfxZCUnOXocI2Jsr1DxdaT0U4ok01SrM263kna/pWRJnrJKtfB76Jaw/TclU05JcjfKfXyfAsvCtDQelyfCcXYc3Rn0R8Wzf4uSJLVkFkf8vaKtt50jkpLTrP8veUMS4v9Lb4tvoiG+9iK+9utNMe5qGxzGGGNzW3qFnTt3asKECVqxYoUWLAhfVe3ee+/VsmXL2q1/4oknlJGREWIPAD2Re3KXLvp8mRqd+Vp7/v/oW5//Qvknd2hr+c3am/+/Yt28xGA8mvnhjXLIaNOQOzRx9299L+3Lu1CbB0f2PmnnHlijkYde8j0/40hVijmtT0qv0c4iqthFUlnNWxq/94/anX+xPiq/MdbNAYA+o7GxUdddd53q6uqUnZ0ddru4S7KWLFmi5cuXd7jN9u3bNXr0aN/z/fv366KLLtLkyZP1pz/9qcN9Q41klZWV6ejRox0G0k5ut1tr167VpZdeKqeTEuV2IMb2Chnfmh1y/r5SxpWlM3d8opQVw+TwuOW+9X0pL8yF/Aipo/6b8t/D5GiqU8uUe5T85n/51nuGTVXLtU9FtB3Jz9+spE9faLf+zKzfy5z//Yi+V7T1unPEmWY5drwqM+jbUkbHMzTiQa+Lb4IhvvYivvbrTTGur69XQUFBp0lW3E0XvOuuuzRv3rwOtxk61H8R8IEDB3TxxRdr0qRJ+sMf/tDp8V0ul1wuV7v1Tqcz5r/U3tCGREeM7RUU3375kiRH8wk5D38sedxSZrGchSOs+/mg20L237QcqalOybVftq5wSDJKaq5XUqT7ureyYE65VLfXtzolr0xKkP9XveYc4XRKY+I7cQ2l18Q3QRFfexFf+/WGGHf1/eMuySosLFRhYdfut7J//35dfPHFmjBhglavXq0kSggDvYe3uqCMdHi7tVg4kgQr0tJyJe31V/rLGSjVfWVP4QvvjYjLL5Q+9idZFL4AAPQ1CZt17N+/X5MnT1Z5eblWrFihI0eOqLq6WtXV1bFuGgBJcqZJyanW8pHPrMes0ti1J1Flt1Zq9Fb685b7jnSSdeq4/6bH5RPbtIHfKwCgb4m7kayuWrt2rXbu3KmdO3dq4MCBQa/F2WVoQOJKy5FOHpGOVFnPuTlq5I2YKn3+N8ndaD3vP1TavSHySZa3fHu/Qqn/MP/6tFzJmR7Z9wIAoJdL2JGsefPmyRgT8gdAL+FqvWDUl2QxrSziRn0n+Hl+awJ05pR0prn99j114rD1mF0anCwzigUA6IMSNskCEAe8NyQ+2foBnZGsyMsulUrH+58HVm703gg6ErzHSsuRMov860mcAQB9EEkWgNjxFb9oxQdye4wOGM3KLPKPIEZyyqD3eixXtpSeJyW3VmllJAsA0AeRZAGIHVeb+0swkmWPUQE3As7o709uI5lkNQeMZDkcUlbraBZJFgCgDyLJAhA77UaySLJsMeBc6bzvScOmSHmDA5Ks2si9h3e6oDdxzmz9XTI6CQDogxK2uiCAOBCYZGXkSyntbwSOCHA4pKtW+5/bOpLVmmSNn2sV1xg+NXLvAQBAnCDJAhA7gdMFGfGIHjuSrMDCF5I0/gfWDwAAfRDTBQHETuBIFlMFo8cb900PS6umS8f3nP0xm9tMFwQAoA8jyQIQO2mBI1kkWVHjTbKObJf2bpS2PHb2x/SOiqWRZAEAQJIFIHaCpgtShS5qklODn3+x/uyP2bbwBQAAfRhJFoDYYbpgbBRXWI/ZA63HA1ulU8fP7pjNba7JAgCgDyPJAhA7aRS+iInzr5Ru/Jt0+2apYJRkPNLut87umG0LXwAA0IeRZAGIHUayYiMpWRo0SXKmSUMnW+vOZsqgp0U63WAtM10QAACSLAAxRAn32PMlWet6fgzvVEGJwhcAAIj7ZAGIpfQ8afC3relqmUWxbk3fNPhbkiNZOvaFVLdfyjmn+8fwThVMdnFDaQAARJIFIJYcDumGl/zLiL60bCm3XDq+W6rd07Mki6IXAAAEYboggNhyOEiwYs17PVxDdc/29xW9YKogAAASSRYAwDtV88Shnu3fzD2yAAAIRJIFAH3d2SZZjGQBABCEJAsA+rqs1iSroadJVp31yDVZAABIIskCAGS2XpN1oofXZDW3JllMFwQAQBJJFgDgrEeyqC4IAEAgkiwA6OvOeiSLwhcAAAQiyQKAvs5b+KKxRjpzuvv7M5IFAEAQkiwA6Osy8qWk1nvTnzzS/f19hS8YyQIAQCLJAgAkJUn9BljLPZkyyHRBAACCkGQBAM6u+AX3yQIAIAhJFgDg7IpfMJIFAEAQkiwAgJTZOl3w89ek+4dL767s+r4UvgAAIAhJFgBAymodyfr8Vav4xbbnurZfU53kPmktk2QBACCJJAsAIPnLuHsd3921/bb8X+uxcLSUnhfZNgEAEKdIsgAA/pEsr5NHpOaGjvdpOSNtethavvAWyeGwp20AAMQZkiwAgL/whSSpNVk6/mXH+3z2slS317rP1phr7GoZAABxhyQLACANOFfKHyGNmCaVjrPWdZZkfbDKevz6TZIz3dbmAQAQT0iyAABSaoZ0+wfSdc9I/YdY6451cF3WmWZp77vWcsXV9rcPAIA4ktBJ1syZM1VeXq60tDSVlJRo7ty5OnDgQKybBQC9l8Mh5bUmWR0Vvzj4L6ml2ZoqWDAiOm0DACBOJHSSdfHFF+uZZ55RVVWVnn32We3atUvf//73Y90sAOjdujKS5R3FKruQghcAALSREusG2OnOO+/0LQ8aNEhLlizR7Nmz5Xa75XQ6Y9gyAOjFujKS5U2yyi+0vz0AAMSZhB7JCnTs2DH95S9/0aRJk0iwAKAj3pGs2q+kFre1fKTKXwjDGOkrkiwAAMJJ6JEsSVq8eLEefPBBNTY26sILL9TLL7/c4fbNzc1qbm72Pa+vr5ckud1uud1uW9sajvd9Y/X+fQExthfxtVfE45uWr5SUNDnONMlds1vKKFDKHyZLqZk685OPpeNfyNlYI5Ps0pmCr0l94PdKH7YX8bUX8bUX8bVfb4pxV9vgMMYYm9sSUUuWLNHy5cs73Gb79u0aPXq0JOno0aM6duyY9uzZo2XLliknJ0cvv/yyHGGuIbj33nu1bNmyduufeOIJZWRknP0/AADiwJTtS5TVdEDvDPsPNTuzdfFnP5ck/f1r/63CE59q3N5HdLTfKL098v/EuKUAAERPY2OjrrvuOtXV1Sk7OzvsdnGXZB05ckQ1NTUdbjN06FClpqa2W79v3z6VlZXpnXfeUWVlZch9Q41klZWV6ejRox0G0k5ut1tr167VpZdeylRHmxBjexFfe9kR3+Snr1PSzr+rZfr9MrnlSnnKutnwmTlr5PjsJSVv/bNaKn8iz5R7IvJ+vR192F7E117E117E1369Kcb19fUqKCjoNMmKu+mChYWFKiws7NG+Ho9HkoKSqLZcLpdcLle79U6nM+a/1N7QhkRHjO1FfO0V0fi2XpeV3LBfSk3zrU6p/VI6WmW9VjpWyX3s90kfthfxtRfxtRfxtV9viHFX3z/ukqyu2rRpk95//31961vfUl5ennbt2qW7775bw4YNCzuKBQBolVtmPdbtk1L7+dfX7JAOb7eWB3wt+u0CACAOJGx1wYyMDD333HO65JJLNGrUKM2fP19jxozRhg0bQo5UAQAC5Ay0Huu+kuoDbuL+xXqpuV5Kckr5w2PSNAAAeruEHcmqqKjQm2++GetmAEB8yim3Huv2Sen9/euPfm49FoyQUtpf+woAABI4yQIAnAXvSFbDQSk9r/3rTBUEACCshJ0uCAA4C/0KpWSXZDz+a7ACDTg3+m0CACBOkGQBANpLSpJyzrGWTYv1mFPmf73ovOi3CQCAOEGSBQAILTCpSkqRyib6nzNdEACAsEiyAAChBSZZmcVS4ShrOTUz+DUAABCEJAsAEFpuQCKVVey/Dqt4jDWdEAAAhER1QQBAaN4Kg5KUXSKNnCFd9ktp6OSYNQkAgHhAkgUACC1wSmBWiZScIlUujF17AACIE8z3AACEFjiSlVUcu3YAABBnSLIAAKFln+NfziqNXTsAAIgzJFkAgNCcaVJmkbXMSBYAAF3GNVkAgPC+eYe0a51UfmGsWwIAQNwgyQIAhFe5kGIXAAB0E9MFAQAAACCCSLIAAAAAIIJIsgAAAAAggkiyAAAAACCCSLIAAAAAIIJIsgAAAAAggkiyAAAAACCCSLIAAAAAIIJIsgAAAAAggkiyAAAAACCCSLIAAAAAIIJIsgAAAAAggkiyAAAAACCCUmLdgN7OGCNJqq+vj1kb3G63GhsbVV9fL6fTGbN2JDJibC/iay/iaz9ibC/iay/iay/ia7/eFGNvTuDNEcIhyepEQ0ODJKmsrCzGLQEAAADQGzQ0NCgnJyfs6w7TWRrWx3k8Hh04cEBZWVlyOBwxaUN9fb3Kysr01VdfKTs7OyZtSHTE2F7E117E137E2F7E117E117E1369KcbGGDU0NKi0tFRJSeGvvGIkqxNJSUkaOHBgrJshScrOzo55x0p0xNhexNdexNd+xNhexNdexNdexNd+vSXGHY1geVH4AgAAAAAiiCQLAAAAACKIJCsOuFwuLV26VC6XK9ZNSVjE2F7E117E137E2F7E117E117E137xGGMKXwAAAABABDGSBQAAAAARRJIFAAAAABFEkgUAAAAAEUSSBQAAAAARRJLVSzz00EMaPHiw0tLSNHHiRL333nsdbr9mzRqNHj1aaWlpqqio0F//+tcotTT+3HffffrGN76hrKwsDRgwQLNnz1ZVVVWH+zz66KNyOBxBP2lpaVFqcXy5995728Vq9OjRHe5D/+26wYMHt4uvw+HQwoULQ25P3+3cP/7xD11xxRUqLS2Vw+HQCy+8EPS6MUb33HOPSkpKlJ6erqlTp2rHjh2dHre75/FE1VF83W63Fi9erIqKCvXr10+lpaX6wQ9+oAMHDnR4zJ6cZxJVZ/133rx57WI1ffr0To9L//XrLMahzskOh0P3339/2GPShy1d+UzW1NSkhQsXKj8/X5mZmbryyit16NChDo/b0/O2nUiyeoGnn35aP/3pT7V06VJt2bJFY8eO1WWXXabDhw+H3P6dd97RnDlzNH/+fG3dulWzZ8/W7NmztW3btii3PD5s2LBBCxcu1Lvvvqu1a9fK7XZr2rRpOnnyZIf7ZWdn6+DBg76fPXv2RKnF8ee8884LitU///nPsNvSf7vn/fffD4rt2rVrJUlXXXVV2H3oux07efKkxo4dq4ceeijk67/+9a/1u9/9Tr///e+1adMm9evXT5dddpmamprCHrO75/FE1lF8GxsbtWXLFt19993asmWLnnvuOVVVVWnmzJmdHrc755lE1ln/laTp06cHxerJJ5/s8Jj032CdxTgwtgcPHtSqVavkcDh05ZVXdnhc+nDXPpPdeeedeumll7RmzRpt2LBBBw4c0Pe+970Oj9uT87btDGLuggsuMAsXLvQ9b2lpMaWlpea+++4Luf3VV19tLr/88qB1EydOND/60Y9sbWeiOHz4sJFkNmzYEHab1atXm5ycnOg1Ko4tXbrUjB07tsvb03/Pzh133GGGDRtmPB5PyNfpu90jyTz//PO+5x6PxxQXF5v777/ft662tta4XC7z5JNPhj1Od8/jfUXb+Iby3nvvGUlmz549Ybfp7nmmrwgV3xtuuMHMmjWrW8eh/4bXlT48a9YsM2XKlA63oQ+H1vYzWW1trXE6nWbNmjW+bbZv324kmY0bN4Y8Rk/P23ZjJCvGTp8+rc2bN2vq1Km+dUlJSZo6dao2btwYcp+NGzcGbS9Jl112WdjtEayurk6S1L9//w63O3HihAYNGqSysjLNmjVLn3zySTSaF5d27Nih0tJSDR06VNdff7327t0bdlv6b8+dPn1ajz/+uG666SY5HI6w29F3e2737t2qrq4O6qM5OTmaOHFi2D7ak/M4/Orq6uRwOJSbm9vhdt05z/R169ev14ABAzRq1CjdcsstqqmpCbst/ffsHDp0SK+88ormz5/f6bb04fbafibbvHmz3G53UH8cPXq0ysvLw/bHnpy3o4EkK8aOHj2qlpYWFRUVBa0vKipSdXV1yH2qq6u7tT38PB6PFi1apG9+85s6//zzw243atQorVq1Si+++KIef/xxeTweTZo0Sfv27Ytia+PDxIkT9eijj+rVV1/VypUrtXv3bn37299WQ0NDyO3pvz33wgsvqLa2VvPmzQu7DX337Hj7YXf6aE/O47A0NTVp8eLFmjNnjrKzs8Nu193zTF82ffp0/fnPf9Ybb7yh5cuXa8OGDZoxY4ZaWlpCbk//PTuPPfaYsrKyOp3ORh9uL9RnsurqaqWmprb70qWzz8Xebbq6TzSkxOydgRhYuHChtm3b1uk86MrKSlVWVvqeT5o0Seeee64efvhh/eIXv7C7mXFlxowZvuUxY8Zo4sSJGjRokJ555pkufbOHrnvkkUc0Y8YMlZaWht2Gvot44Xa7dfXVV8sYo5UrV3a4LeeZrrv22mt9yxUVFRozZoyGDRum9evX65JLLolhyxLTqlWrdP3113daYIg+3F5XP5PFK0ayYqygoEDJycntqqYcOnRIxcXFIfcpLi7u1vaw3HbbbXr55Ze1bt06DRw4sFv7Op1OjRs3Tjt37rSpdYkjNzdXI0eODBsr+m/P7NmzR6+//rpuvvnmbu1H3+0ebz/sTh/tyXm8r/MmWHv27NHatWs7HMUKpbPzDPyGDh2qgoKCsLGi//bcW2+9paqqqm6flyX6cLjPZMXFxTp9+rRqa2uDtu/sc7F3m67uEw0kWTGWmpqqCRMm6I033vCt83g8euONN4K+jQ5UWVkZtL0krV27Nuz2fZ0xRrfddpuef/55vfnmmxoyZEi3j9HS0qKPP/5YJSUlNrQwsZw4cUK7du0KGyv6b8+sXr1aAwYM0OWXX96t/ei73TNkyBAVFxcH9dH6+npt2rQpbB/tyXm8L/MmWDt27NDrr7+u/Pz8bh+js/MM/Pbt26eampqwsaL/9twjjzyiCRMmaOzYsd3et6/24c4+k02YMEFOpzOoP1ZVVWnv3r1h+2NPzttREbOSG/B56qmnjMvlMo8++qj59NNPzQ9/+EOTm5trqqurjTHGzJ071yxZssS3/dtvv21SUlLMihUrzPbt283SpUuN0+k0H3/8caz+Cb3aLbfcYnJycsz69evNwYMHfT+NjY2+bdrGeNmyZea1114zu3btMps3bzbXXnutSUtLM5988kks/gm92l133WXWr19vdu/ebd5++20zdepUU1BQYA4fPmyMof9GQktLiykvLzeLFy9u9xp9t/saGhrM1q1bzdatW40k85vf/MZs3brVV93uV7/6lcnNzTUvvvii+eijj8ysWbPMkCFDzKlTp3zHmDJlinnggQd8zzs7j/clHcX39OnTZubMmWbgwIHmww8/DDonNzc3+47RNr6dnWf6ko7i29DQYH72s5+ZjRs3mt27d5vXX3/djB8/3owYMcI0NTX5jkH/7Vhn5whjjKmrqzMZGRlm5cqVIY9BHw6tK5/JfvzjH5vy8nLz5ptvmg8++MBUVlaaysrKoOOMGjXKPPfcc77nXTlvRxtJVi/xwAMPmPLycpOammouuOAC8+677/peu+iii8wNN9wQtP0zzzxjRo4caVJTU815551nXnnllSi3OH5ICvmzevVq3zZtY7xo0SLf76OoqMh85zvfMVu2bIl+4+PANddcY0pKSkxqaqo555xzzDXXXGN27tzpe53+e/Zee+01I8lUVVW1e42+233r1q0LeU7wxtHj8Zi7777bFBUVGZfLZS655JJ2sR80aJBZunRp0LqOzuN9SUfx3b17d9hz8rp163zHaBvfzs4zfUlH8W1sbDTTpk0zhYWFxul0mkGDBpkFCxa0S5bovx3r7BxhjDEPP/ywSU9PN7W1tSGPQR8OrSufyU6dOmVuvfVWk5eXZzIyMsx3v/tdc/DgwXbHCdynK+ftaHMYY4w9Y2QAAAAA0PdwTRYAAAAARBBJFgAAAABEEEkWAAAAAEQQSRYAAAAARBBJFgAAAABEEEkWAAAAAEQQSRYAAAAARBBJFgAAkubNm6fZs2fHuhkAgASQEusGAABgN4fD0eHrS5cu1W9/+1sZY6LUIgBAIiPJAgAkvIMHD/qWn376ad1zzz2qqqryrcvMzFRmZmYsmgYASEBMFwQAJLzi4mLfT05OjhwOR9C6zMzMdtMFJ0+erNtvv12LFi1SXl6eioqK9Mc//lEnT57UjTfeqKysLA0fPlx/+9vfgt5r27ZtmjFjhjIzM1VUVKS5c+fq6NGjUf4XAwBiiSQLAIAwHnvsMRUUFOi9997T7bffrltuuUVXXXWVJk2apC1btmjatGmaO3euGhsbJUm1tbWaMmWKxo0bpw8++ECvvvqqDh06pKuvvjrG/xIAQDSRZAEAEMbYsWP185//XCNGjNB//ud/Ki0tTQUFBVqwYIFGjBihe+65RzU1Nfroo48kSQ8++KDGjRunX/7ylxo9erTGjRunVatWad26dfr8889j/K8BAEQL12QBABDGmDFjfMvJycnKz89XRUWFb11RUZEk6fDhw5Kkf/3rX1q3bl3I67t27dqlkSNH2txiAEBvQJIFAEAYTqcz6LnD4Qha561a6PF4JEknTpzQFVdcoeXLl7c7VklJiY0tBQD0JiRZAABEyPjx4/Xss89q8ODBSknhTywA9FVckwUAQIQsXLhQx44d05w5c/T+++9r165deu2113TjjTeqpaUl1s0DAEQJSRYAABFSWlqqt99+Wy0tLZo2bZoqKiq0aNEi5ebmKimJP7kA0Fc4DLe3BwAAAICI4Ws1AAAAAIggkiwAAAAAiCCSLAAAAACIIJIsAAAAAIggkiwAAAAAiCCSLAAAAACIIJIsAAAAAIggkiwAAAAAiCCSLAAAAACIIJIsAAAAAIggkiwAAAAAiCCSLAAAAACIoP8PCne0acbnROsAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the trajectory against time and velocity against time in a separate plot\n", + "fig, axs = plt.subplots(2, 1, figsize=(10, 10))\n", + "axs[0].plot(sol.ts, xs[:, 0], label=\"x1\")\n", + "axs[0].plot(sol.ts, xs[:, 1], label=\"x2\")\n", + "axs[0].set_xlabel(\"Time\")\n", + "axs[0].set_ylabel(\"Position\")\n", + "axs[0].legend()\n", + "axs[0].grid()\n", + "\n", + "axs[1].plot(sol.ts, vs[:, 0], label=\"v1\")\n", + "axs[1].plot(sol.ts, vs[:, 1], label=\"v2\")\n", + "axs[1].set_xlabel(\"Time\")\n", + "axs[1].set_ylabel(\"Velocity\")\n", + "axs[1].legend()\n", + "axs[1].grid()\n", + "\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/mkdocs.yml b/mkdocs.yml index 6b4c2547..71205be8 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -112,6 +112,7 @@ nav: - Kalman filter: 'examples/kalman_filter.ipynb' - Second-order sensitivities: 'examples/hessian.ipynb' - Nonlinear heat PDE: 'examples/nonlinear_heat_pde.ipynb' + - Langevin diffusion: 'examples/langevin_example.ipynb' - Basic API: - 'api/diffeqsolve.md' - Solvers: diff --git a/test/test_langevin.py b/test/test_langevin.py index 8625d7e6..4ec872be 100644 --- a/test/test_langevin.py +++ b/test/test_langevin.py @@ -9,6 +9,7 @@ from .helpers import ( get_bqp, get_harmonic_oscillator, + path_l2_dist, SDE, simple_batch_sde_solve, simple_sde_order, @@ -194,3 +195,39 @@ def get_dt_and_controller(level): assert ( -0.2 < order - theoretical_order < 0.25 ), f"order={order}, theoretical_order={theoretical_order}" + + +@pytest.mark.parametrize("solver_cls", _only_langevin_solvers_cls()) +def test_reverse_solve(solver_cls): + t0, t1 = 0.7, -1.2 + dt0 = -0.01 + saveat = SaveAt(ts=jnp.linspace(t0, t1, 20, endpoint=True)) + + gamma = jnp.array([2, 0.5], dtype=jnp.float64) + u = jnp.array([0.5, 2], dtype=jnp.float64) + x0 = jnp.zeros((2,), dtype=jnp.float64) + v0 = jnp.zeros((2,), dtype=jnp.float64) + y0 = (x0, v0) + + bm = diffrax.VirtualBrownianTree( + t1, + t0, + tol=0.005, + shape=(2,), + key=jr.key(0), + levy_area=diffrax.SpaceTimeTimeLevyArea, + ) + terms = diffrax.make_langevin_term(gamma, u, lambda x: 2 * x, bm, x0) + + solver = solver_cls(0.01) + sol = diffeqsolve(terms, solver, t0, t1, dt0=dt0, y0=y0, args=None, saveat=saveat) + + ref_solver = diffrax.Heun() + ref_sol = diffeqsolve( + terms, ref_solver, t0, t1, dt0=dt0, y0=y0, args=None, saveat=saveat + ) + + # print(jtu.tree_map(lambda x: x.shape, sol.ys)) + # print(jtu.tree_map(lambda x: x.shape, ref_sol.ys)) + error = path_l2_dist(sol.ys, ref_sol.ys) + assert error < 0.1 From 52e9f4472ffd27dc6f8eb758131e59925b5cb053 Mon Sep 17 00:00:00 2001 From: andyElking Date: Wed, 21 Aug 2024 17:16:11 +0100 Subject: [PATCH 09/15] Fixed Patrick's comments --- diffrax/__init__.py | 2 +- diffrax/_solver/align.py | 82 ++++---- diffrax/_solver/langevin_srk.py | 275 +++++++++++++++++---------- diffrax/_solver/quicsort.py | 139 +++++++------- diffrax/_solver/should.py | 109 ++++++----- diffrax/_term.py | 147 ++++++++------ docs/api/solvers/sde_solvers.md | 25 +-- docs/api/terms.md | 2 +- docs/usage/how-to-choose-a-solver.md | 5 + examples/langevin_example.ipynb | 74 +++---- test/helpers.py | 10 +- test/test_langevin.py | 40 ++-- 12 files changed, 535 insertions(+), 375 deletions(-) diff --git a/diffrax/__init__.py b/diffrax/__init__.py index 71d6b503..bb2be025 100644 --- a/diffrax/__init__.py +++ b/diffrax/__init__.py @@ -126,7 +126,7 @@ from ._term import ( AbstractTerm as AbstractTerm, ControlTerm as ControlTerm, - make_langevin_term as make_langevin_term, + make_underdamped_langevin_term as make_underdamped_langevin_term, MultiTerm as MultiTerm, ODETerm as ODETerm, WeaklyDiagonalControlTerm as WeaklyDiagonalControlTerm, diff --git a/diffrax/_solver/align.py b/diffrax/_solver/align.py index 7ce805e2..68f2f74c 100644 --- a/diffrax/_solver/align.py +++ b/diffrax/_solver/align.py @@ -1,21 +1,19 @@ import equinox as eqx import jax.numpy as jnp import jax.tree_util as jtu -import numpy as np from equinox.internal import ω -from jaxtyping import Array, ArrayLike, PyTree +from jaxtyping import ArrayLike, PyTree from .._custom_types import ( AbstractSpaceTimeLevyArea, RealScalarLike, ) from .._local_interpolation import LocalLinearInterpolation -from .._term import LangevinTuple, LangevinX +from .._term import LangevinLeaf, LangevinTuple, LangevinX from .langevin_srk import ( _LangevinArgs, AbstractCoeffs, - AbstractLangevinSRK, - SolverState, + AbstractFosterLangevinSRK, ) @@ -41,24 +39,34 @@ def __init__(self, beta, a1, b1, aa, chh): _ErrorEstimate = LangevinTuple -class ALIGN(AbstractLangevinSRK[_ALIGNCoeffs, _ErrorEstimate]): +class ALIGN(AbstractFosterLangevinSRK[_ALIGNCoeffs, _ErrorEstimate]): r"""The Adaptive Langevin via Interpolated Gradients and Noise method - designed by James Foster. - Accepts only terms given by [`diffrax.make_langevin_term`][]. + designed by James Foster. This is a second order solver for the + Underdamped Langevin Diffusion, the terms for which can be created using + [`diffrax.make_underdamped_langevin_term`][]. Uses two evaluations of the vector + field per step, but is FSAL, so in practice it only requires one. + + ??? cite "Reference" + + This is a modification of the Strang-Splitting method from Definition 4.2 of + + ```bibtex + @misc{foster2021shiftedode, + title={The shifted ODE method for underdamped Langevin MCMC}, + author={James Foster and Terry Lyons and Harald Oberhauser}, + year={2021}, + eprint={2101.03446}, + archivePrefix={arXiv}, + primaryClass={math.NA}, + url={https://arxiv.org/abs/2101.03446}, + } + ``` + """ interpolation_cls = LocalLinearInterpolation - taylor_threshold: RealScalarLike = eqx.field(static=True) - _coeffs_structure = jtu.tree_structure( - _ALIGNCoeffs( - beta=np.array(0.0), - a1=np.array(0.0), - b1=np.array(0.0), - aa=np.array(0.0), - chh=np.array(0.0), - ) - ) minimal_levy_area = AbstractSpaceTimeLevyArea + taylor_threshold: RealScalarLike = eqx.field(static=True) def __init__(self, taylor_threshold: RealScalarLike = 0.1): r"""**Arguments:** @@ -76,7 +84,9 @@ def order(self, terms): def strong_order(self, terms): return 2.0 - def _directly_compute_coeffs_leaf(self, h, c) -> _ALIGNCoeffs: + def _directly_compute_coeffs_leaf( + self, h: RealScalarLike, c: LangevinLeaf + ) -> _ALIGNCoeffs: del self # c is a leaf of gamma # compute the coefficients directly (as opposed to via Taylor expansion) @@ -97,7 +107,7 @@ def _directly_compute_coeffs_leaf(self, h, c) -> _ALIGNCoeffs: chh=chh, ) - def _tay_coeffs_single(self, c: Array) -> _ALIGNCoeffs: + def _tay_coeffs_single(self, c: LangevinLeaf) -> _ALIGNCoeffs: del self # c is a leaf of gamma zero = jnp.zeros_like(c) @@ -107,11 +117,18 @@ def _tay_coeffs_single(self, c: Array) -> _ALIGNCoeffs: c4 = c3 * c c5 = c4 * c - beta = jnp.stack([one, -c, c2 / 2, -c3 / 6, c4 / 24, -c5 / 120], axis=-1) - a1 = jnp.stack([zero, one, -c / 2, c2 / 6, -c3 / 24, c4 / 120], axis=-1) - b1 = jnp.stack([zero, one / 2, -c / 6, c2 / 24, -c3 / 120, c4 / 720], axis=-1) - aa = jnp.stack([one, -c / 2, c2 / 6, -c3 / 24, c4 / 120, -c5 / 720], axis=-1) - chh = jnp.stack([zero, one, -c / 2, 3 * c2 / 20, -c3 / 30, c4 / 168], axis=-1) + # Coefficients of the Taylor expansion, starting from 5th power + # to 0th power. The descending power order is because of jnp.polyval + beta = jnp.stack([-c5 / 120, c4 / 24, -c3 / 6, c2 / 2, -c, one], axis=-1) + a1 = jnp.stack([c4 / 120, -c3 / 24, c2 / 6, -c / 2, one, zero], axis=-1) + b1 = jnp.stack([c4 / 720, -c3 / 120, c2 / 24, -c / 6, one / 2, zero], axis=-1) + aa = jnp.stack([-c5 / 720, c4 / 120, -c3 / 24, c2 / 6, -c / 2, one], axis=-1) + chh = jnp.stack([c4 / 168, -c3 / 30, 3 * c2 / 20, -c / 2, one, zero], axis=-1) + + correct_shape = c.shape + (6,) + assert ( + beta.shape == a1.shape == b1.shape == aa.shape == chh.shape == correct_shape + ) return _ALIGNCoeffs( beta=beta, @@ -121,39 +138,40 @@ def _tay_coeffs_single(self, c: Array) -> _ALIGNCoeffs: chh=chh, ) - @staticmethod def _compute_step( + self, h: RealScalarLike, levy: AbstractSpaceTimeLevyArea, x0: LangevinX, v0: LangevinX, langevin_args: _LangevinArgs, coeffs: _ALIGNCoeffs, - st: SolverState, + rho: LangevinX, + prev_f: LangevinX, ) -> tuple[LangevinX, LangevinX, LangevinX, LangevinTuple]: - dtypes = jtu.tree_map(jnp.dtype, x0) + dtypes = jtu.tree_map(jnp.result_type, x0) w: LangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) hh: LangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) gamma, u, f = langevin_args uh = (u**ω * h).ω - f0 = st.prev_f + f0 = prev_f x1 = ( x0**ω + coeffs.a1**ω * v0**ω - coeffs.b1**ω * uh**ω * f0**ω - + st.rho**ω * (coeffs.b1**ω * w**ω + coeffs.chh**ω * hh**ω) + + rho**ω * (coeffs.b1**ω * w**ω + coeffs.chh**ω * hh**ω) ).ω f1 = f(x1) v1 = ( coeffs.beta**ω * v0**ω - u**ω * ((coeffs.a1**ω - coeffs.b1**ω) * f0**ω + coeffs.b1**ω * f1**ω) - + st.rho**ω * (coeffs.aa**ω * w**ω - gamma**ω * coeffs.chh**ω * hh**ω) + + rho**ω * (coeffs.aa**ω * w**ω - gamma**ω * coeffs.chh**ω * hh**ω) ).ω error_estimate = ( - jtu.tree_map(lambda leaf: jnp.zeros_like(leaf), x0), + jtu.tree_map(jnp.zeros_like, x0), (-(u**ω) * coeffs.b1**ω * (f1**ω - f0**ω)).ω, ) diff --git a/diffrax/_solver/langevin_srk.py b/diffrax/_solver/langevin_srk.py index 59a444f3..eee4161c 100644 --- a/diffrax/_solver/langevin_srk.py +++ b/diffrax/_solver/langevin_srk.py @@ -4,13 +4,13 @@ import equinox as eqx import equinox.internal as eqxi +import jax import jax.lax as lax import jax.numpy as jnp import jax.tree_util as jtu from equinox import AbstractVar from jax import vmap -from jax.tree_util import PyTreeDef -from jaxtyping import Array, ArrayLike, PyTree +from jaxtyping import PyTree from .._custom_types import ( AbstractBrownianIncrement, @@ -24,6 +24,7 @@ AbstractTerm, LangevinDiffusionTerm, LangevinDriftTerm, + LangevinLeaf, LangevinTuple, LangevinX, MultiTerm, @@ -36,9 +37,9 @@ _LangevinArgs = tuple[LangevinX, LangevinX, Callable[[LangevinX], LangevinX]] -def get_args_from_terms( +def _get_args_from_terms( terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], -) -> _LangevinArgs: +) -> tuple[PyTree, PyTree, Callable[[LangevinX], LangevinX]]: drift, diffusion = terms.terms if isinstance(drift, WrapTerm): assert isinstance(diffusion, WrapTerm) @@ -53,19 +54,21 @@ def get_args_from_terms( return gamma, u, f -class AbstractCoeffs(eqx.Module): - dtype: AbstractVar[jnp.dtype] +def _broadcast_pytree(source, target_tree): + # Broadcasts the source PyTree to the shape and PyTree structure of + # target_tree_shape. Requires that source is a prefix tree of target_tree + # This is used to case gamma and u to the shape of x0 and v0 + def _inner_broadcast(_src_arr, _inner_target_tree): + _arr = jnp.asarray(_src_arr) + def fun(_leaf): + return jnp.asarray( + jnp.broadcast_to(_arr, _leaf.shape), dtype=jnp.result_type(_leaf) + ) -_Coeffs = TypeVar("_Coeffs", bound=AbstractCoeffs) + return jtu.tree_map(fun, _inner_target_tree) - -class SolverState(eqx.Module, Generic[_Coeffs]): - h: RealScalarLike - taylor_coeffs: PyTree[_Coeffs, "LangevinX"] - coeffs: _Coeffs - rho: LangevinX - prev_f: LangevinX + return jtu.tree_map(_inner_broadcast, source, target_tree) # CONCERNING COEFFICIENTS: @@ -82,20 +85,42 @@ class SolverState(eqx.Module, Generic[_Coeffs]): # one can compute the SRK coefficients more precisely for a small h. -class AbstractLangevinSRK( +class AbstractCoeffs(eqx.Module): + dtype: AbstractVar[jnp.dtype] + + +_Coeffs = TypeVar("_Coeffs", bound=AbstractCoeffs) + + +class SolverState(eqx.Module, Generic[_Coeffs]): + gamma: LangevinX + u: LangevinX + h: RealScalarLike + taylor_coeffs: PyTree[_Coeffs, "LangevinX"] + coeffs: _Coeffs + rho: LangevinX + prev_f: LangevinX + + +class AbstractFosterLangevinSRK( AbstractStratonovichSolver[SolverState], AbstractItoSolver[SolverState], Generic[_Coeffs, _ErrorEstimate], ): - """Abstract class for Stochastic Runge Kutta methods specifically designed + r"""Abstract class for Stochastic Runge Kutta methods specifically designed for Underdamped Langevin Diffusion of the form - $$d x_t = v_t dt$$ - - $$d v_t = - gamma v_t dt - u ∇f(x_t) dt + (2gammau)^(1/2) dW_t$$ + \begin{align*} + \mathrm{d} x(t) &= v(t) \, \mathrm{d}t \\ + \mathrm{d} v(t) &= - \gamma \, v(t) \, \mathrm{d}t - u \, + \nabla \! f( x(t) ) \, \mathrm{d}t + \sqrt{2 \gamma u} \, \mathrm{d} w(t), + \end{align*} - where $v$ is the velocity, $f$ is the potential, $gamma$ and $u$ are the - friction and momentum parameters, and $W$ is a Brownian motion. + where $x(t), v(t) \in \mathbb{R}^d$ represent the position + and velocity, $w$ is a Brownian motion in $\mathbb{R}^d$, + $f: \mathbb{R}^d \rightarrow \mathbb{R}$ is a potential function, and + $\gamma , u \in \mathbb{R}^{d \times d}$ are diagonal matrices governing + the friction and the inertia of the system. Solvers which inherit from this class include [`diffrax.ALIGN`][], [`diffrax.ShOULD`][], and [`diffrax.QUIC_SORT`][]. @@ -103,90 +128,121 @@ class AbstractLangevinSRK( term_structure = MultiTerm[tuple[LangevinDriftTerm, LangevinDiffusionTerm]] interpolation_cls = LocalLinearInterpolation - taylor_threshold: RealScalarLike = eqx.field(static=True) - _coeffs_structure: eqx.AbstractClassVar[PyTreeDef] minimal_levy_area: eqx.AbstractClassVar[type[AbstractBrownianIncrement]] + taylor_threshold: AbstractVar[RealScalarLike] @abc.abstractmethod - def _directly_compute_coeffs_leaf(self, h, c) -> _Coeffs: + def _directly_compute_coeffs_leaf( + self, h: RealScalarLike, c: LangevinLeaf + ) -> _Coeffs: + r"""This method specifies how to compute the SRK coefficients directly + (as opposed to via Taylor expansion). This function is then mapped over the + PyTree of gamma to compute the coefficients for the entire system. + + **Arguments:** + + - `h`: The time increment. + - `c`: A leaf of gamma. + + **Returns:** + + The SRK coefficients for the given leaf of gamma. + """ raise NotImplementedError @abc.abstractmethod - def _tay_coeffs_single(self, c: Array) -> _Coeffs: - raise NotImplementedError + def _tay_coeffs_single(self, c: LangevinLeaf) -> _Coeffs: + r"""This method specifies how to compute the Taylor coefficients for a + single leaf of gamma. These coefficients are then used to compute the SRK + coefficients using the Taylor expansion. This function is then mapped over + the PyTree of gamma to compute the coefficients for the entire system. - def _comp_taylor_coeffs_leaf(self, c: Array) -> _Coeffs: - # c is a leaf of gamma + **Arguments:** - # When the step-size h is small the coefficients (which depend on h) need - # to be computed via Taylor expansion to ensure numerical stability. - # This precomputes the Taylor coefficients (depending on gamma and u), which - # are then multiplied by powers of h, to get the SRK coefficients. - out = self._tay_coeffs_single(c) + - `c`: A leaf of gamma. - def check_shape(coeff_leaf): - permitted_shapes = [c.shape + (3, 6), c.shape + (1, 6), c.shape + (6,)] - assert ( - coeff_leaf.shape in permitted_shapes - ), f"leaf shape: {coeff_leaf.shape}, c shape: {c.shape}" + **Returns:** - jtu.tree_map(check_shape, out) - return out + The Taylor coefficients for the given leaf of gamma. + """ + raise NotImplementedError @staticmethod - def _eval_taylor(h, tay_coeffs: _Coeffs) -> _Coeffs: - # Multiplies the pre-computed Taylor coefficients by powers of h. - dtype = tay_coeffs.dtype - h_powers = jnp.power(h, jnp.arange(0, 6, dtype=h.dtype)).astype(dtype) - return jtu.tree_map( - lambda tay_leaf: jnp.tensordot(tay_leaf, h_powers, axes=1), tay_coeffs - ) + def _eval_taylor(h: RealScalarLike, tay_coeffs: _Coeffs) -> _Coeffs: + r"""Computes the SRK coefficients via the Taylor expansion, using the + precomputed Taylor coefficients and the step-size h.""" + h = jnp.asarray(h, dtype=tay_coeffs.dtype) + + def eval_taylor_fun(tay_leaf): + # jnp.polyval performs the Taylor expansion along + # the first axis, so we need to move the trailing + # axis to 0th position + transposed = jnp.moveaxis(tay_leaf, -1, 0) + assert transposed.shape[0] == 6 + return jnp.polyval(transposed, h, unroll=6) + + return jtu.tree_map(eval_taylor_fun, tay_coeffs) def _recompute_coeffs( - self, h, gamma: LangevinX, tay_coeffs: PyTree[_Coeffs], state_h + self, h: RealScalarLike, gamma: LangevinX, tay_coeffs: PyTree[_Coeffs] ) -> _Coeffs: - def recompute_coeffs_leaf(c: ArrayLike, _tay_coeffs: _Coeffs): - # Used when the step-size h changes and coefficients need to be recomputed + r"""When h changes, the SRK coefficients (which depend on h) are recomputed + using this function.""" + # Inner will record the tree structure of the coefficients + inner = sentinel = object() + + def recompute_coeffs_leaf(c: LangevinLeaf, _tay_coeffs: _Coeffs): + # c is a leaf of gamma # Depending on the size of h*gamma choose whether the Taylor expansion or # direct computation is more accurate. - cond = h * c < self.taylor_threshold # c is a leaf of gamma - if jnp.ndim(c) == 0: - return lax.cond( - cond, - lambda h_: self._eval_taylor(h_, _tay_coeffs), - lambda h_: self._directly_compute_coeffs_leaf(h_, c), - h, - ) - else: - tay_out = self._eval_taylor(h, _tay_coeffs) - if cond.ndim < jtu.tree_leaves(tay_out)[0].ndim: - cond = jnp.expand_dims(cond, axis=-1) - - def select_tay_or_direct(dummy): + cond = h * c < self.taylor_threshold + tay_out = self._eval_taylor(h, _tay_coeffs) + if cond.ndim < jtu.tree_leaves(tay_out)[0].ndim: + # This happens when c is a scalar + cond = jnp.expand_dims(cond, axis=-1) + + def select_tay_or_direct(): + if jnp.ndim(c) == 0: + direct_out = self._directly_compute_coeffs_leaf(h, c) + else: fun = lambda _c: self._directly_compute_coeffs_leaf(h, _c) direct_out = vmap(fun)(c) - def _choose(tay_leaf, direct_leaf): - assert tay_leaf.ndim == direct_leaf.ndim == cond.ndim, ( - f"tay_leaf.ndim: {tay_leaf.ndim}," - f" direct_leaf.ndim: {direct_leaf.ndim}," - f" cond.ndim: {cond.ndim}" - ) - return jnp.where(cond, tay_leaf, direct_leaf) + def _choose(tay_leaf, direct_leaf): + assert tay_leaf.ndim == direct_leaf.ndim == cond.ndim, ( + f"tay_leaf.ndim: {tay_leaf.ndim}," + f" direct_leaf.ndim: {direct_leaf.ndim}," + f" cond.ndim: {cond.ndim}" + ) + return jnp.where(cond, tay_leaf, direct_leaf) + + return jtu.tree_map(_choose, tay_out, direct_out) + + # If all entries of h*gamma are below threshold, only compute tay_out + # otherwise, compute both tay_out and direct_out and select the + # correct one for each dimension + out = lax.cond( + eqxi.unvmap_all(cond), + lambda: tay_out, + select_tay_or_direct, + ) - return jtu.tree_map(_choose, tay_out, direct_out) + # The inner tree structure is just the structure of _Coeffs, + # but we need to record it for the tree transpose + nonlocal inner + if inner is sentinel: + inner = jtu.tree_structure(out) + else: + assert ( + jtu.tree_structure(out) == inner + ), f"Expected {inner}, got {jtu.tree_structure(out)}" - # If all entries of h*gamma are below threshold, only compute tay_out - # otherwise, compute both tay_out and direct_out and select the - # correct one for each dimension - return lax.cond( - eqxi.unvmap_all(cond), lambda _: tay_out, select_tay_or_direct, None - ) + return out tree_with_coeffs = jtu.tree_map(recompute_coeffs_leaf, gamma, tay_coeffs) outer = jtu.tree_structure(gamma) - inner = self._coeffs_structure - coeffs_with_tree = jtu.tree_transpose(outer, inner, tree_with_coeffs) + assert inner is not sentinel, "inner tree structure not set" + coeffs_with_tree = jtu.tree_transpose(outer, inner, tree_with_coeffs) # type: ignore return coeffs_with_tree def init( @@ -203,44 +259,57 @@ def init( evaluation of grad_f. """ drift, diffusion = terms.terms - gamma, u, f = get_args_from_terms(terms) + gamma, u, grad_f = _get_args_from_terms(terms) h = drift.contr(t0, t1) x0, v0 = y0 - def _check_shapes(_c, _u, _x, _v): - assert _c.shape == _u.shape == _x.shape == _v.shape + gamma = _broadcast_pytree(gamma, x0) + u = _broadcast_pytree(u, x0) + grad_f_shape = jax.eval_shape(grad_f, x0) + + def _shape_check_fun(_x, _g, _u, _fx): + return _x.shape == _g.shape == _u.shape == _fx.shape - assert jtu.tree_all(jtu.tree_map(_check_shapes, gamma, u, x0, v0)) + assert jtu.tree_all( + jtu.tree_map(_shape_check_fun, x0, gamma, u, grad_f_shape) + ), "The shapes of gamma, u, and grad_f(x0) must be the same as x0." - tay_coeffs = jtu.tree_map(self._comp_taylor_coeffs_leaf, gamma) + tay_coeffs = jtu.tree_map(self._tay_coeffs_single, gamma) # tay_coeffs have the same tree structure as gamma, with each leaf being a - # _Coeffs and the arrays have an extra trailing dimension of 6 + # _Coeffs object and the arrays inside have an extra trailing dimension of 6 + # (or in the case of QUICSORT either (3, 6) or (1, 6)) - coeffs = self._recompute_coeffs(h, gamma, tay_coeffs, -1.0) + coeffs = self._recompute_coeffs(h, gamma, tay_coeffs) rho = jtu.tree_map(lambda c, _u: jnp.sqrt(2 * c * _u), gamma, u) state_out = SolverState( + gamma=gamma, + u=u, h=h, taylor_coeffs=tay_coeffs, coeffs=coeffs, rho=rho, - prev_f=f(x0), + prev_f=grad_f(x0), ) return state_out - @staticmethod @abc.abstractmethod def _compute_step( + self, h: RealScalarLike, levy, x0: LangevinX, v0: LangevinX, langevin_args: _LangevinArgs, coeffs: _Coeffs, - st: SolverState, + rho: LangevinX, + prev_f: LangevinX, ) -> tuple[LangevinX, LangevinX, LangevinX, _ErrorEstimate]: + r"""This method specifies how to compute a single step of the Langevin SRK + method. This holds just the computation that differs between the different + SRK methods. The common bits are handled by the `step` method.""" raise NotImplementedError def step( @@ -253,28 +322,29 @@ def step( solver_state: SolverState, made_jump: BoolScalarLike, ) -> tuple[LangevinTuple, _ErrorEstimate, DenseInfo, SolverState, RESULTS]: - del made_jump, args + del args st = solver_state drift, diffusion = terms.terms - gamma, u, f = get_args_from_terms(terms) h = drift.contr(t0, t1) h_prev = st.h tay: PyTree[_Coeffs] = st.taylor_coeffs - coeffs: _Coeffs = st.coeffs + old_coeffs: _Coeffs = st.coeffs + + gamma, u, rho = st.gamma, st.u, st.rho + _, _, grad_f = _get_args_from_terms(terms) - # If h changed recompute coefficients + # If h changed, recompute coefficients # Even when using constant step sizes, h can fluctuate by small amounts, # so we use `jnp.isclose` for comparison cond = jnp.isclose(h_prev, h, rtol=1e-10, atol=1e-12) coeffs = lax.cond( - cond, - lambda x: x, - lambda _: self._recompute_coeffs(h, gamma, tay, h_prev), - coeffs, + eqxi.unvmap_all(cond), + lambda: old_coeffs, + lambda: self._recompute_coeffs(h, gamma, tay), ) - # compute the Brownian increment and space-time Levy area + # compute the Brownian increment and space-time(-time) Levy area levy = diffusion.contr(t0, t1, use_levy=True) assert isinstance(levy, self.minimal_levy_area), ( f"The Brownian motion must have" @@ -282,8 +352,11 @@ def step( ) x0, v0 = y0 + prev_f = lax.cond(made_jump, lambda: grad_f(x0), lambda: st.prev_f) + + # The actual step computation, handled by the subclass x_out, v_out, f_fsal, error = self._compute_step( - h, levy, x0, v0, (gamma, u, f), coeffs, st + h, levy, x0, v0, (gamma, u, grad_f), coeffs, rho, prev_f ) def check_shapes_dtypes(_x, _v, _f, _x0): @@ -302,6 +375,8 @@ def check_shapes_dtypes(_x, _v, _f, _x0): dense_info = dict(y0=y0, y1=y1) st = SolverState( + gamma=gamma, + u=u, h=h, taylor_coeffs=tay, coeffs=coeffs, diff --git a/diffrax/_solver/quicsort.py b/diffrax/_solver/quicsort.py index 58749592..033ff460 100644 --- a/diffrax/_solver/quicsort.py +++ b/diffrax/_solver/quicsort.py @@ -4,21 +4,19 @@ import jax import jax.numpy as jnp import jax.tree_util as jtu -import numpy as np from equinox.internal import ω -from jaxtyping import Array, ArrayLike, PyTree +from jaxtyping import ArrayLike, PyTree from .._custom_types import ( AbstractSpaceTimeTimeLevyArea, RealScalarLike, ) from .._local_interpolation import LocalLinearInterpolation -from .._term import LangevinX +from .._term import LangevinLeaf, LangevinX from .langevin_srk import ( _LangevinArgs, AbstractCoeffs, - AbstractLangevinSRK, - SolverState, + AbstractFosterLangevinSRK, ) @@ -26,11 +24,11 @@ # UBU evaluates at l = (3 -sqrt(3))/6, at r = (3 + sqrt(3))/6 and at 1, # so we need 3 versions of each coefficient class _QUICSORTCoeffs(AbstractCoeffs): - beta_lr1: PyTree[ArrayLike] # (gamma, 3, *taylor) - a_lr1: PyTree[ArrayLike] # (gamma, 3, *taylor) - b_lr1: PyTree[ArrayLike] # (gamma, 3, *taylor) - a_third: PyTree[ArrayLike] # (gamma, 1, *taylor) - a_div_h: PyTree[ArrayLike] # (gamma, 1, *taylor) + beta_lr1: PyTree[ArrayLike] # gamma.shape + (3, *taylor) + a_lr1: PyTree[ArrayLike] # gamma.shape + (3, *taylor) + b_lr1: PyTree[ArrayLike] # gamma.shape + (3, *taylor) + a_third: PyTree[ArrayLike] # gamma.shape + (1, *taylor) + a_div_h: PyTree[ArrayLike] # gamma.shape + (1, *taylor) dtype: jnp.dtype = eqx.field(static=True) def __init__(self, beta_lr1, a_lr1, b_lr1, a_third, a_div_h): @@ -45,13 +43,31 @@ def __init__(self, beta_lr1, a_lr1, b_lr1, a_third, a_div_h): self.dtype = jnp.result_type(*all_leaves) -class QUICSORT(AbstractLangevinSRK[_QUICSORTCoeffs, None]): +class QUICSORT(AbstractFosterLangevinSRK[_QUICSORTCoeffs, None]): r"""The QUadrature Inspired and Contractive Shifted ODE with Runge-Kutta Three - method by Daire O'Kane and James Foster, which is a third order version of the - UBU method from + method by James Foster and Daire O'Kane. This is a third order solver for the + Underdamped Langevin Diffusion, the terms for which can be created using + [`diffrax.make_underdamped_langevin_term`][]. Uses two evaluations of the vector + field per step. ??? cite "Reference" + This is a variant of the SORT method from Definition 1.2 of + + ```bibtex + @misc{foster2021shiftedode, + title={The shifted ODE method for underdamped Langevin MCMC}, + author={James Foster and Terry Lyons and Harald Oberhauser}, + year={2021}, + eprint={2101.03446}, + archivePrefix={arXiv}, + primaryClass={math.NA}, + url={https://arxiv.org/abs/2101.03446}, + } + ``` + + with the modifications inspired by the UBU method from + ```bibtex @misc{chada2024unbiased, title={Unbiased Kinetic Langevin Monte Carlo with Inexact Gradients}, @@ -64,22 +80,11 @@ class QUICSORT(AbstractLangevinSRK[_QUICSORTCoeffs, None]): url={https://arxiv.org/abs/2311.05025}, } ``` - - Accepts only terms given by [`diffrax.make_langevin_term`][]. """ interpolation_cls = LocalLinearInterpolation - taylor_threshold: RealScalarLike = eqx.field(static=True) - _coeffs_structure = jtu.tree_structure( - _QUICSORTCoeffs( - beta_lr1=np.array(0.0), - a_lr1=np.array(0.0), - b_lr1=np.array(0.0), - a_third=np.array(0.0), - a_div_h=np.array(0.0), - ) - ) minimal_levy_area = AbstractSpaceTimeTimeLevyArea + taylor_threshold: RealScalarLike = eqx.field(static=True) def __init__(self, taylor_threshold: RealScalarLike = 0.1): r"""**Arguments:** @@ -97,7 +102,9 @@ def order(self, terms): def strong_order(self, terms): return 3.0 - def _directly_compute_coeffs_leaf(self, h, c) -> _QUICSORTCoeffs: + def _directly_compute_coeffs_leaf( + self, h: RealScalarLike, c: LangevinLeaf + ) -> _QUICSORTCoeffs: del self # compute the coefficients directly (as opposed to via Taylor expansion) original_shape = c.shape @@ -105,11 +112,9 @@ def _directly_compute_coeffs_leaf(self, h, c) -> _QUICSORTCoeffs: alpha = c * h l = 0.5 - math.sqrt(3) / 6 r = 0.5 + math.sqrt(3) / 6 - l_r_1 = jnp.array([l, r, 1.0], dtype=jnp.dtype(c)) + l_r_1 = jnp.array([l, r, 1.0], dtype=jnp.result_type(c)) alpha_lr1 = alpha * l_r_1 - assert alpha_lr1.shape == original_shape + ( - 3, - ), f"expected {original_shape + (3,)}, got {alpha_lr1.shape}" + assert alpha_lr1.shape == original_shape + (3,) beta_lr1 = jnp.exp(-alpha_lr1) a_lr1 = (1.0 - beta_lr1) / c b_lr1 = (beta_lr1 + alpha_lr1 - 1.0) / (c**2 * h) @@ -126,10 +131,10 @@ def _directly_compute_coeffs_leaf(self, h, c) -> _QUICSORTCoeffs: a_div_h=a_div_h, ) - def _tay_coeffs_single(self, c: Array) -> _QUICSORTCoeffs: + def _tay_coeffs_single(self, c: LangevinLeaf) -> _QUICSORTCoeffs: del self # c is a leaf of gamma - dtype = jnp.dtype(c) + dtype = jnp.result_type(c) zero = jnp.zeros_like(c) one = jnp.ones_like(c) c2 = jnp.square(c) @@ -137,31 +142,36 @@ def _tay_coeffs_single(self, c: Array) -> _QUICSORTCoeffs: c4 = c3 * c c5 = c4 * c + # Compute the coefficients of the Taylor expansion, starting from 5th power + # to 0th power. The descending power order is because of jnp.polyval + + # Some coefficients must be computed at h*l, h*r and h*1, so we + # pre-multiply the coefficients with powers of l, r and 1. l = 0.5 - math.sqrt(3) / 6 r = 0.5 + math.sqrt(3) / 6 lr1 = jnp.expand_dims(jnp.array([l, r, 1.0], dtype=dtype), axis=-1) - exponents = jnp.expand_dims(jnp.arange(0, 6, dtype=dtype), axis=0) + exponents = jnp.expand_dims(jnp.arange(5, -1, step=-1, dtype=dtype), axis=0) lr1_pows = jnp.power(lr1, exponents) assert lr1_pows.shape == (3, 6) - beta = jnp.stack([one, -c, c2 / 2, -c3 / 6, c4 / 24, -c5 / 120], axis=-1) - a = jnp.stack([zero, one, -c / 2, c2 / 6, -c3 / 24, c4 / 120], axis=-1) - b = jnp.stack([zero, one / 2, -c / 6, c2 / 24, -c3 / 120, c4 / 720], axis=-1) + beta = jnp.stack([-c5 / 120, c4 / 24, -c3 / 6, c2 / 2, -c, one], axis=-1) + a = jnp.stack([c4 / 120, -c3 / 24, c2 / 6, -c / 2, one, zero], axis=-1) + b = jnp.stack([c4 / 720, -c3 / 120, c2 / 24, -c / 6, one / 2, zero], axis=-1) with jax.numpy_rank_promotion("allow"): beta_lr1 = lr1_pows * jnp.expand_dims(beta, axis=c.ndim) a_lr1 = lr1_pows * jnp.expand_dims(a, axis=c.ndim) - # b needs an extra power of l and r + # b needs an extra power of lr1 (just work out the expansion to see why) b_lr1 = lr1_pows * lr1 * jnp.expand_dims(b, axis=c.ndim) assert beta_lr1.shape == a_lr1.shape == b_lr1.shape == c.shape + (3, 6) # a_third = (1 - exp(-1/3 * gamma * h))/gamma a_third = jnp.stack( - [zero, one / 3, -c / 18, c2 / 162, -c3 / 1944, c4 / 29160], axis=-1 + [c4 / 29160, -c3 / 1944, c2 / 162, -c / 18, one / 3, zero], axis=-1 ) a_third = jnp.expand_dims(a_third, axis=c.ndim) a_div_h = jnp.stack( - [one, -c / 2, c2 / 6, -c3 / 24, c4 / 120, -c5 / 720], axis=-1 + [-c5 / 720, c4 / 120, -c3 / 24, c2 / 6, -c / 2, one], axis=-1 ) a_div_h = jnp.expand_dims(a_div_h, axis=c.ndim) assert a_third.shape == a_div_h.shape == c.shape + (1, 6) @@ -174,47 +184,42 @@ def _tay_coeffs_single(self, c: Array) -> _QUICSORTCoeffs: a_div_h=a_div_h, ) - @staticmethod def _compute_step( + self, h: RealScalarLike, levy: AbstractSpaceTimeTimeLevyArea, x0: LangevinX, v0: LangevinX, langevin_args: _LangevinArgs, coeffs: _QUICSORTCoeffs, - st: SolverState, + rho: LangevinX, + prev_f: LangevinX, ) -> tuple[LangevinX, LangevinX, LangevinX, None]: - dtypes = jtu.tree_map(jnp.dtype, x0) + dtypes = jtu.tree_map(jnp.result_type, x0) w: LangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) hh: LangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) kk: LangevinX = jtu.tree_map(jnp.asarray, levy.K, dtypes) gamma, u, f = langevin_args - def _l(coeff): - return jtu.tree_map(lambda arr: arr[..., 0], coeff) - - def _r(coeff): - return jtu.tree_map(lambda arr: arr[..., 1], coeff) - - def _one(coeff): - return jtu.tree_map(lambda arr: arr[..., 2], coeff) - - beta_l = _l(coeffs.beta_lr1) - beta_r = _r(coeffs.beta_lr1) - beta_1 = _one(coeffs.beta_lr1) - a_l = _l(coeffs.a_lr1) - a_r = _r(coeffs.a_lr1) - a_1 = _one(coeffs.a_lr1) - b_l = _l(coeffs.b_lr1) - b_r = _r(coeffs.b_lr1) - b_1 = _one(coeffs.b_lr1) - a_third = _l(coeffs.a_third) - a_div_h = _l(coeffs.a_div_h) - - rho_w_k = (st.rho**ω * (w**ω - 12 * kk**ω)).ω + def _extract_coeffs(coeff, index): + return jtu.tree_map(lambda arr: arr[..., index], coeff) + + beta_l = _extract_coeffs(coeffs.beta_lr1, 0) + beta_r = _extract_coeffs(coeffs.beta_lr1, 1) + beta_1 = _extract_coeffs(coeffs.beta_lr1, 2) + a_l = _extract_coeffs(coeffs.a_lr1, 0) + a_r = _extract_coeffs(coeffs.a_lr1, 1) + a_1 = _extract_coeffs(coeffs.a_lr1, 2) + b_l = _extract_coeffs(coeffs.b_lr1, 0) + b_r = _extract_coeffs(coeffs.b_lr1, 1) + b_1 = _extract_coeffs(coeffs.b_lr1, 2) + a_third = _extract_coeffs(coeffs.a_third, 0) + a_div_h = _extract_coeffs(coeffs.a_div_h, 0) + + rho_w_k = (rho**ω * (w**ω - 12 * kk**ω)).ω uh = (u**ω * h).ω - v_tilde = (v0**ω + st.rho**ω * (hh**ω + 6 * kk**ω)).ω + v_tilde = (v0**ω + rho**ω * (hh**ω + 6 * kk**ω)).ω x1 = (x0**ω + a_l**ω * v_tilde**ω + b_l**ω * rho_w_k**ω).ω f1uh = (f(x1) ** ω * uh**ω).ω @@ -236,10 +241,10 @@ def _one(coeff): - 0.5 * (beta_r**ω * f1uh**ω + beta_l**ω * f2uh**ω) + a_div_h**ω * rho_w_k**ω ).ω - v_out = (v_out_tilde**ω - st.rho**ω * (hh**ω - 6 * kk**ω)).ω + v_out = (v_out_tilde**ω - rho**ω * (hh**ω - 6 * kk**ω)).ω # this method is not FSAL, but for compatibility with the base class we set - f_fsal = st.prev_f + f_fsal = prev_f # TODO: compute error estimate return x_out, v_out, f_fsal, None diff --git a/diffrax/_solver/should.py b/diffrax/_solver/should.py index 27138e01..7de6b882 100644 --- a/diffrax/_solver/should.py +++ b/diffrax/_solver/should.py @@ -1,21 +1,19 @@ import equinox as eqx import jax.numpy as jnp import jax.tree_util as jtu -import numpy as np from equinox.internal import ω -from jaxtyping import Array, ArrayLike, PyTree +from jaxtyping import ArrayLike, PyTree from .._custom_types import ( AbstractSpaceTimeTimeLevyArea, RealScalarLike, ) from .._local_interpolation import LocalLinearInterpolation -from .._term import LangevinX +from .._term import LangevinLeaf, LangevinX from .langevin_srk import ( _LangevinArgs, AbstractCoeffs, - AbstractLangevinSRK, - SolverState, + AbstractFosterLangevinSRK, ) @@ -58,28 +56,33 @@ def __init__(self, beta_half, a_half, b_half, beta1, a1, b1, aa, chh, ckk): self.dtype = jnp.result_type(*all_leaves) -class ShOULD(AbstractLangevinSRK[_ShOULDCoeffs, None]): +class ShOULD(AbstractFosterLangevinSRK[_ShOULDCoeffs, None]): r"""The Shifted-ODE Runge-Kutta Three method - designed by James Foster. - Accepts only terms given by [`diffrax.make_langevin_term`][]. + designed by James Foster. This is a third order solver for the + Underdamped Langevin Diffusion, the terms for which can be created using + [`diffrax.make_underdamped_langevin_term`][]. Uses three evaluations of the vector + field per step, but is FSAL, so in practice it only requires two. + + ??? cite "Reference" + + This solver is based on Definition 7.1 from + + ```bibtex + @misc{foster2021shiftedode, + title={The shifted ODE method for underdamped Langevin MCMC}, + author={James Foster and Terry Lyons and Harald Oberhauser}, + year={2021}, + eprint={2101.03446}, + archivePrefix={arXiv}, + primaryClass={math.NA}, + url={https://arxiv.org/abs/2101.03446}, + } + ``` """ interpolation_cls = LocalLinearInterpolation - taylor_threshold: RealScalarLike = eqx.field(static=True) - _coeffs_structure = jtu.tree_structure( - _ShOULDCoeffs( - beta_half=np.array(0.0), - a_half=np.array(0.0), - b_half=np.array(0.0), - beta1=np.array(0.0), - a1=np.array(0.0), - b1=np.array(0.0), - aa=np.array(0.0), - chh=np.array(0.0), - ckk=np.array(0.0), - ) - ) minimal_levy_area = AbstractSpaceTimeTimeLevyArea + taylor_threshold: RealScalarLike = eqx.field(static=True) def __init__(self, taylor_threshold: RealScalarLike = 0.1): r"""**Arguments:** @@ -97,7 +100,9 @@ def order(self, terms): def strong_order(self, terms): return 3.0 - def _directly_compute_coeffs_leaf(self, h, c) -> _ShOULDCoeffs: + def _directly_compute_coeffs_leaf( + self, h: RealScalarLike, c: LangevinLeaf + ) -> _ShOULDCoeffs: del self # c is a leaf of gamma # compute the coefficients directly (as opposed to via Taylor expansion) @@ -127,7 +132,7 @@ def _directly_compute_coeffs_leaf(self, h, c) -> _ShOULDCoeffs: ckk=ckk, ) - def _tay_coeffs_single(self, c: Array) -> _ShOULDCoeffs: + def _tay_coeffs_single(self, c: LangevinLeaf) -> _ShOULDCoeffs: del self # c is a leaf of gamma zero = jnp.zeros_like(c) @@ -137,26 +142,37 @@ def _tay_coeffs_single(self, c: Array) -> _ShOULDCoeffs: c4 = c3 * c c5 = c4 * c + # Coefficients of the Taylor expansion, starting from 5th power + # to 0th power. The descending power order is because of jnp.polyval beta_half = jnp.stack( - [one, -c / 2, c2 / 8, -c3 / 48, c4 / 384, -c5 / 3840], axis=-1 + [-c5 / 3840, c4 / 384, -c3 / 48, c2 / 8, -c / 2, one], axis=-1 ) - beta1 = jnp.stack([one, -c, c2 / 2, -c3 / 6, c4 / 24, -c5 / 120], axis=-1) - + beta1 = jnp.stack([-c5 / 120, c4 / 24, -c3 / 6, c2 / 2, -c, one], axis=-1) a_half = jnp.stack( - [zero, one / 2, -c / 8, c2 / 48, -c3 / 384, c4 / 3840], axis=-1 + [c4 / 3840, -c3 / 384, c2 / 48, -c / 8, one / 2, zero], axis=-1 ) - a1 = jnp.stack([zero, one, -c / 2, c2 / 6, -c3 / 24, c4 / 120], axis=-1) - # aa = a1/h - aa = jnp.stack([one, -c / 2, c2 / 6, -c3 / 24, c4 / 120, -c5 / 720], axis=-1) - - # b_half is not exactly b(1/2 h), but 1/2 * b(1/2 h) + a1 = jnp.stack([c4 / 120, -c3 / 24, c2 / 6, -c / 2, one, zero], axis=-1) + aa = jnp.stack([-c5 / 720, c4 / 120, -c3 / 24, c2 / 6, -c / 2, one], axis=-1) b_half = jnp.stack( - [zero, one / 8, -c / 48, c2 / 384, -c3 / 3840, c4 / 46080], axis=-1 + [c4 / 46080, -c3 / 3840, c2 / 384, -c / 48, one / 8, zero], axis=-1 + ) + b1 = jnp.stack([c4 / 720, -c3 / 120, c2 / 24, -c / 6, one / 2, zero], axis=-1) + chh = jnp.stack([c4 / 168, -c3 / 30, 3 * c2 / 20, -c / 2, one, zero], axis=-1) + ckk = jnp.stack([5 * c4 / 168, -c3 / 7, c2 / 2, -c, zero, zero], axis=-1) + + correct_shape = c.shape + (6,) + assert ( + beta_half.shape + == a_half.shape + == b_half.shape + == beta1.shape + == a1.shape + == b1.shape + == aa.shape + == chh.shape + == ckk.shape + == correct_shape ) - b1 = jnp.stack([zero, one / 2, -c / 6, c2 / 24, -c3 / 120, c4 / 720], axis=-1) - - chh = jnp.stack([zero, one, -c / 2, 3 * c2 / 20, -c3 / 30, c4 / 168], axis=-1) - ckk = jnp.stack([zero, zero, -c, c2 / 2, -c3 / 7, 5 * c4 / 168], axis=-1) return _ShOULDCoeffs( beta_half=beta_half, @@ -170,28 +186,29 @@ def _tay_coeffs_single(self, c: Array) -> _ShOULDCoeffs: ckk=ckk, ) - @staticmethod def _compute_step( + self, h: RealScalarLike, levy: AbstractSpaceTimeTimeLevyArea, x0: LangevinX, v0: LangevinX, langevin_args: _LangevinArgs, coeffs: _ShOULDCoeffs, - st: SolverState, + rho: LangevinX, + prev_f: LangevinX, ) -> tuple[LangevinX, LangevinX, LangevinX, None]: - dtypes = jtu.tree_map(jnp.dtype, x0) + dtypes = jtu.tree_map(jnp.result_type, x0) w: LangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) hh: LangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) kk: LangevinX = jtu.tree_map(jnp.asarray, levy.K, dtypes) gamma, u, f = langevin_args - rho_w_k = (st.rho**ω * (w**ω - 12 * kk**ω)).ω + rho_w_k = (rho**ω * (w**ω - 12 * kk**ω)).ω uh = (u**ω * h).ω - f0 = st.prev_f - v1 = (v0**ω + st.rho**ω * (hh**ω + 6 * kk**ω)).ω + f0 = prev_f + v1 = (v0**ω + rho**ω * (hh**ω + 6 * kk**ω)).ω x1 = ( x0**ω + coeffs.a_half**ω * v1**ω @@ -205,7 +222,7 @@ def _compute_step( x0**ω + coeffs.a1**ω * v0**ω - uh**ω * coeffs.b1**ω * (1 / 3 * f0**ω + 2 / 3 * f1**ω) - + st.rho**ω * (coeffs.b1**ω * w**ω + chh_hh_plus_ckk_kk**ω) + + rho**ω * (coeffs.b1**ω * w**ω + chh_hh_plus_ckk_kk**ω) ).ω f_out = f(x_out) v_out = ( @@ -216,7 +233,7 @@ def _compute_step( + 2 / 3 * coeffs.beta_half**ω * f1**ω + 1 / 6 * f_out**ω ) - + st.rho**ω * (coeffs.aa**ω * w**ω - gamma**ω * chh_hh_plus_ckk_kk**ω) + + rho**ω * (coeffs.aa**ω * w**ω - gamma**ω * chh_hh_plus_ckk_kk**ω) ).ω return x_out, v_out, f_out, None diff --git a/diffrax/_term.py b/diffrax/_term.py index fc44462f..9f2a07c3 100644 --- a/diffrax/_term.py +++ b/diffrax/_term.py @@ -791,33 +791,63 @@ def _to_vjp(_y, _diff_args, _diff_term): # `x` and the velocity `v`. Both of these have the same shape. So, by LangevinX we # denote the shape of the x component, and by LangevinTuple we denote the shape of # the tuple (x, v). +LangevinLeaf = Shaped[Array, "*langevin"] LangevinX = PyTree[Shaped[Array, "?*langevin"], "LangevinX"] LangevinTuple = tuple[LangevinX, LangevinX] +def _broadcast_pytree(source, target_tree): + # Broadcasts the source PyTree to the shape and PyTree structure of + # target_tree_shape. Requires that source is a prefix tree of target_tree + # This is used to case gamma and u to the shape of x0 and v0 + def _inner_broadcast(_src_arr, _inner_target_tree): + _arr = jnp.asarray(_src_arr) + + def fun(_leaf): + return jnp.asarray( + jnp.broadcast_to(_arr, _leaf.shape), dtype=jnp.result_type(_leaf) + ) + + return jtu.tree_map(fun, _inner_target_tree) + + return jtu.tree_map(_inner_broadcast, source, target_tree) + + class LangevinDiffusionTerm( AbstractTerm[LangevinX, Union[LangevinX, AbstractBrownianIncrement]] ): - r"""Represents the diffusion term in the Langevin SDE: + r"""Represents the diffusion term in the Underdamped Langevin Diffusion (ULD). + The ULD SDE takes the form: - $d \mathbf{x}_t = \mathbf{v}_t dt$ + \begin{align*} + \mathrm{d} x(t) &= v(t) \, \mathrm{d}t \\ + \mathrm{d} v(t) &= - \gamma \, v(t) \, \mathrm{d}t - u \, + \nabla \! f( x(t) ) \, \mathrm{d}t + \sqrt{2 \gamma u} \, \mathrm{d} w(t), + \end{align*} - $d \mathbf{v}_t = - \gamma \mathbf{v}_t dt - u - \nabla f( \mathbf{x}_t ) dt + \sqrt{2 \gamma u} d W_t.$ + where $x(t), v(t) \in \mathbb{R}^d$ represent the position + and velocity, $w$ is a Brownian motion in $\mathbb{R}^d$, + $f: \mathbb{R}^d \rightarrow \mathbb{R}$ is a potential function, and + $\gamma , u \in \mathbb{R}^{d \times d}$ are diagonal matrices governing + the friction and the inertia of the system. """ - gamma: LangevinX - u: LangevinX + gamma: PyTree[ArrayLike] + u: PyTree[ArrayLike] control: AbstractBrownianPath def vf(self, t: RealScalarLike, y: LangevinTuple, args: Args) -> LangevinX: x, v = y + # gamma, u and v can all have different pytree structures, we only know that + # gamma and u are prefixes of v + gamma = _broadcast_pytree(self.gamma, v) + u = _broadcast_pytree(self.u, v) def _fun(_gamma, _u, _v): - return jnp.sqrt(2 * _gamma * _u) * jnp.ones(_v.shape, _v.dtype) + return jnp.sqrt(2 * _gamma * _u) - d_v = jtu.tree_map(_fun, self.gamma, self.u, v) - return d_v + vf_v = jtu.tree_map(_fun, gamma, u, v) + return vf_v def contr( self, t0: RealScalarLike, t1: RealScalarLike, **kwargs @@ -825,42 +855,51 @@ def contr( return self.control.evaluate(t0, t1, **kwargs) def prod(self, vf: LangevinX, control: LangevinX) -> LangevinTuple: - dv = vf + # The vf is only for the velocity component. The position component is + # unaffected by the diffusion. dw = control - v_out = jtu.tree_map(operator.mul, dv, dw) + v_out = jtu.tree_map(operator.mul, vf, dw) x_out = jtu.tree_map(jnp.zeros_like, v_out) return x_out, v_out -def _broadcast_pytree(source, target_tree_shape): - # Requires that source is a prefix tree of target_tree_shape - def _inner_broadcast(_src_arr, _inner_tree_shape): - _arr = jnp.asarray(_src_arr) - return jtu.tree_map( - lambda _leaf: jnp.broadcast_to(_arr, _leaf.shape), _inner_tree_shape - ) +class LangevinDriftTerm(AbstractTerm): + r"""Represents the drift term in the Underdamped Langevin Diffusion (ULD). + The ULD SDE takes the form: - return jtu.tree_map(_inner_broadcast, source, target_tree_shape) + \begin{align*} + \mathrm{d} x(t) &= v(t) \, \mathrm{d}t \\ + \mathrm{d} v(t) &= - \gamma \, v(t) \, \mathrm{d}t - u \, + \nabla \! f( x(t) ) \, \mathrm{d}t + \sqrt{2 \gamma u} \, \mathrm{d} w(t), + \end{align*} + where $x(t), v(t) \in \mathbb{R}^d$ represent the position + and velocity, $w$ is a Brownian motion in $\mathbb{R}^d$, + $f: \mathbb{R}^d \rightarrow \mathbb{R}$ is a potential function, and + $\gamma , u \in \mathbb{R}^{d \times d}$ are diagonal matrices governing + the friction and the inertia of the system. + """ -class LangevinDriftTerm(AbstractTerm): - gamma: LangevinX - u: LangevinX + gamma: PyTree[ArrayLike] + u: PyTree[ArrayLike] grad_f: Callable[[LangevinX], LangevinX] def vf(self, t: RealScalarLike, y: LangevinTuple, args: Args) -> LangevinTuple: x, v = y + # gamma, u and v can all have different pytree structures, we only know that + # gamma and u are prefixes of v (which is the same as x) + gamma = _broadcast_pytree(self.gamma, v) + u = _broadcast_pytree(self.u, v) + f_x = self.grad_f(x) - d_x = v - d_v = jtu.tree_map( - lambda _gamma, _u, _v, _f_x: -_gamma * _v - _u * _f_x, - self.gamma, - self.u, - v, - f_x, - ) - d_y = (d_x, d_v) - return d_y + vf_x = v + + def fun(_gamma, _u, _v, _f_x): + return -_gamma * _v - _u * _f_x + + vf_v = jtu.tree_map(fun, gamma, u, v, f_x) + vf_y = (vf_x, vf_v) + return vf_y def contr(self, t0: RealScalarLike, t1: RealScalarLike, **kwargs) -> RealScalarLike: return t1 - t0 @@ -869,54 +908,44 @@ def prod(self, vf: LangevinTuple, control: RealScalarLike) -> LangevinTuple: return jtu.tree_map(lambda _vf: control * _vf, vf) -def make_langevin_term( +def make_underdamped_langevin_term( gamma: PyTree[ArrayLike], u: PyTree[ArrayLike], - grad_f: Callable, + grad_f: Callable[[LangevinX], LangevinX], bm: AbstractBrownianPath, - x0: LangevinX, ) -> MultiTerm[tuple[LangevinDriftTerm, LangevinDiffusionTerm]]: r"""Creates a term that represents the Underdamped Langevin Diffusion, given by: - $d \mathbf{x}_t = \mathbf{v}_t dt$ - - $d \mathbf{v}_t = - \gamma \mathbf{v}_t dt - u - \nabla f( \mathbf{x}_t ) dt + \sqrt{2 \gamma u} d W_t.$ + \begin{align*} + \mathrm{d} x(t) &= v(t) \, \mathrm{d}t \\ + \mathrm{d} v(t) &= - \gamma \, v(t) \, \mathrm{d}t - u \, + \nabla \! f( x(t) ) \, \mathrm{d}t + \sqrt{2 \gamma u} \, \mathrm{d} w(t), + \end{align*} - where $\mathbf{x}_t, \mathbf{v}_t \in \mathbb{R}^d$ represent the position - and velocity, $W$ is a Brownian motion in $\mathbb{R}^d$, + where $x(t), v(t) \in \mathbb{R}^d$ represent the position + and velocity, $w$ is a Brownian motion in $\mathbb{R}^d$, $f: \mathbb{R}^d \rightarrow \mathbb{R}$ is a potential function, and $\gamma , u \in \mathbb{R}^{d \times d}$ are diagonal matrices governing - the friction and the dampening of the system. + the friction and the inertia of the system. **Arguments:** - `gamma`: A vector containing the diagonal entries of the friction matrix; - a PyTree of the same shape as `x0`. + a scalar or a PyTree of the same shape as the position vector $x$. - `u`: A vector containing the diagonal entries of the dampening matrix; - a PyTree of the same shape as `x0`. + a scalar or a PyTree of the same shape as the position vector $x$. - `grad_f`: A callable representing the gradient of the potential function $f$. - This callable should take a PyTree of the same shape as `x0` and + This callable should take a PyTree of the same shape as $x$ and return a PyTree of the same shape. - - `bm`: A Brownian path representing the Brownian motion $W$. - - `x0`: The initial state of the system (just the position without velocity); - only needed to check the PyTree structure of the other arguments. + - `bm`: A Brownian path representing the Brownian motion $w$. **Returns:** A `MultiTerm` representing the Langevin SDE. """ - - gamma = _broadcast_pytree(gamma, x0) - u = _broadcast_pytree(u, x0) - grad_f_shape = jax.eval_shape(grad_f, x0) - - def _shape_check_fun(_x, _g, _u, _fx): - return _x.shape == _g.shape == _u.shape == _fx.shape - - assert jtu.tree_all( - jtu.tree_map(_shape_check_fun, x0, gamma, u, grad_f_shape) - ), "The shapes of gamma, u, and grad_f(x0) must be the same as x0." + # In practice we don't require the PyTree structure of gamma and u to be the same + # as x and v. We only require that they are prefixes of x and v, in a way that + # allows us to call _broadcast_pytree(gamma, x) and _broadcast_pytree(u, x). drift = LangevinDriftTerm(gamma, u, grad_f) diffusion = LangevinDiffusionTerm(gamma, u, bm) diff --git a/docs/api/solvers/sde_solvers.md b/docs/api/solvers/sde_solvers.md index fc91e643..0a5be40a 100644 --- a/docs/api/solvers/sde_solvers.md +++ b/docs/api/solvers/sde_solvers.md @@ -122,20 +122,21 @@ These are reversible in the same way as when applied to ODEs. [See here.](./ode_ These solvers are specifically designed for the Underdamped Langevin diffusion (ULD), which takes the form -$d \mathbf{x}_t = \mathbf{v}_t dt$ - -$d \mathbf{v}_t = - \gamma \mathbf{v}_t dt - u -\nabla f( \mathbf{x}_t ) dt + \sqrt{2 \gamma u} d W_t.$ - -where $\mathbf{x}_t, \mathbf{v}_t \in \mathbb{R}^d$ represent the position -and velocity, $W$ is a Brownian motion in $\mathbb{R}^d$, +\begin{align*} + \mathrm{d} x(t) &= v(t) \, \mathrm{d}t \\ + \mathrm{d} v(t) &= - \gamma \, v(t) \, \mathrm{d}t - u \, + \nabla \! f( x(t) ) \, \mathrm{d}t + \sqrt{2 \gamma u} \, \mathrm{d} w(t), +\end{align*} + +where $x(t), v(t) \in \mathbb{R}^d$ represent the position +and velocity, $w$ is a Brownian motion in $\mathbb{R}^d$, $f: \mathbb{R}^d \rightarrow \mathbb{R}$ is a potential function, and $\gamma , u \in \mathbb{R}^{d \times d}$ are diagonal matrices governing -the friction and the dampening of the system. +the friction and the inertia of the system. They are more precise for this diffusion than the general-purpose solvers above, but cannot be used for any other SDEs. They only accept terms generated by the -[`diffrax.make_langevin_term`][] function. They all have the same `__init__` signature. +[`diffrax.make_underdamped_langevin_term`][] function. For an example of their usage, see the [Langevin example](../../examples/langevin_example.ipynb). ::: diffrax.ALIGN @@ -145,8 +146,10 @@ For an example of their usage, see the [Langevin example](../../examples/langevi ::: diffrax.ShOULD selection: - members: false + members: + - __init__ ::: diffrax.QUICSORT selection: - members: false \ No newline at end of file + members: + - __init__ \ No newline at end of file diff --git a/docs/api/terms.md b/docs/api/terms.md index 6aee5b78..6672d82f 100644 --- a/docs/api/terms.md +++ b/docs/api/terms.md @@ -92,4 +92,4 @@ Some example term structures include: members: - __init__ -::: diffrax.make_langevin_term \ No newline at end of file +::: diffrax.make_underdamped_langevin_term \ No newline at end of file diff --git a/docs/usage/how-to-choose-a-solver.md b/docs/usage/how-to-choose-a-solver.md index 669ef2e9..01b4dcc5 100644 --- a/docs/usage/how-to-choose-a-solver.md +++ b/docs/usage/how-to-choose-a-solver.md @@ -91,6 +91,11 @@ In this case the Itô solution and the Stratonovich solution coincide, and mathe - The cheapest (but least accurate) solver is [`diffrax.SEA`][]. - Otherwise [`diffrax.ShARK`][] or [`diffrax.SRA1`][] are good choices. +### Underdamped Langevin Diffusion + +The Underdamped Langevin Diffusion is a special case of an SDE with additive noise. +For details on the form of this SDE and appropriate solvers refer to the section on [Underdamped Langevin solvers](../api/solvers/sde_solvers.md#underdamped-langevin-solvers). + --- ## Controlled differential equations diff --git a/examples/langevin_example.ipynb b/examples/langevin_example.ipynb index 818f6de0..55042271 100644 --- a/examples/langevin_example.ipynb +++ b/examples/langevin_example.ipynb @@ -10,16 +10,16 @@ "The Underdamped Langevin diffusion (ULD) is an SDE of the form:\n", "\n", "\\begin{align*}\n", - " d \\mathbf{x}_t &= \\mathbf{v}_t \\, dt \\\\\n", - " d \\mathbf{v}_t &= - \\gamma \\, \\mathbf{v}_t \\, dt - u \\,\n", - " \\nabla \\! f( \\mathbf{x}_t ) \\, dt + \\sqrt{2 \\gamma u} \\, d W_t,\n", + " \\mathrm{d} x(t) &= v(t) \\, \\mathrm{d}t \\\\\n", + " \\mathrm{d} v(t) &= - \\gamma \\, v(t) \\, \\mathrm{d}t - u \\,\n", + " \\nabla \\! f( x(t) ) \\, \\mathrm{d}t + \\sqrt{2 \\gamma u} \\, \\mathrm{d} w(t),\n", "\\end{align*}\n", "\n", - "where $\\mathbf{x}_t, \\mathbf{v}_t \\in \\mathbb{R}^d$ represent the position\n", - "and velocity, $W$ is a Brownian motion in $\\mathbb{R}^d$,\n", + "where $x(t), v(t) \\in \\mathbb{R}^d$ represent the position\n", + "and velocity, $w$ is a Brownian motion in $\\mathbb{R}^d$,\n", "$f: \\mathbb{R}^d \\rightarrow \\mathbb{R}$ is a potential function, and\n", "$\\gamma , u \\in \\mathbb{R}^{d \\times d}$ are diagonal matrices governing\n", - "the friction and the dampening of the system.\n", + "the friction and the inertia of the system.\n", "\n", "## ULD for Monte Carlo and Bayesian inference\n", "\n", @@ -29,7 +29,7 @@ "\n", "In addition to generic SDE solvers (which can solve any SDE including ULD), Diffrax has some solvers designed specifically for ULD. These are `diffrax.ALIGN` which has a 2nd order of strong convergence, and `diffrax.QUICSORT` and `diffrax.ShOULD` which are 3rd order solvers. Note that unlike ODE solvers which can have orders of 5 or even higher, very few types of SDEs permit solvers with a strong order greater than $\\frac{1}{2}$.\n", "\n", - "These Langevin-specific solvers only accept terms retuned by `diffrax.make_langevin_term`.\n", + "These Langevin-specific solvers only accept terms retuned by `diffrax.make_underdamped_langevin_term`.\n", "\n", "## A 2D harmonic oscillator\n", "\n", @@ -38,15 +38,13 @@ }, { "cell_type": "code", - "execution_count": 7, "id": "9deba250066ddc39", "metadata": { "ExecuteTime": { - "end_time": "2024-08-18T14:34:51.363600Z", - "start_time": "2024-08-18T14:34:48.606225Z" + "end_time": "2024-08-21T21:09:04.966129Z", + "start_time": "2024-08-21T21:09:01.522578Z" } }, - "outputs": [], "source": [ "from warnings import simplefilter\n", "\n", @@ -74,57 +72,67 @@ " t0, t1, tol=0.01, shape=(2,), key=jr.key(0), levy_area=diffrax.SpaceTimeTimeLevyArea\n", ")\n", "\n", - "# Use the make_langevin_term function to create the terms\n", - "terms = diffrax.make_langevin_term(gamma, u, lambda x: 2 * x, bm, x0)\n", + "# Use the make_underdamped_langevin_term function to create the terms\n", + "terms = diffrax.make_underdamped_langevin_term(gamma, u, lambda x: 2 * x, bm)\n", "\n", - "solver = diffrax.QUICSORT(0.1)\n", + "solver = diffrax.QUICSORT(100.0)\n", "sol = diffrax.diffeqsolve(\n", " terms, solver, t0, t1, dt0=dt0, y0=y0, args=None, saveat=saveat\n", ")\n", "xs, vs = sol.ys" - ] + ], + "outputs": [], + "execution_count": 1 }, { "cell_type": "code", - "execution_count": 8, "id": "62da2ddbaaf98f47", "metadata": { "ExecuteTime": { - "end_time": "2024-08-18T14:34:52.378938Z", - "start_time": "2024-08-18T14:34:52.259089Z" + "end_time": "2024-08-21T21:09:08.676505Z", + "start_time": "2024-08-21T21:09:08.520037Z" } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "# Plot the trajectory against time and velocity against time in a separate plot\n", "fig, axs = plt.subplots(2, 1, figsize=(10, 10))\n", "axs[0].plot(sol.ts, xs[:, 0], label=\"x1\")\n", - "axs[0].plot(sol.ts, xs[:, 1], label=\"x2\")\n", + "axs[0].plot(sol.ts, xs[:, 1], label=\"x4\")\n", "axs[0].set_xlabel(\"Time\")\n", "axs[0].set_ylabel(\"Position\")\n", "axs[0].legend()\n", "axs[0].grid()\n", "\n", "axs[1].plot(sol.ts, vs[:, 0], label=\"v1\")\n", - "axs[1].plot(sol.ts, vs[:, 1], label=\"v2\")\n", + "axs[1].plot(sol.ts, vs[:, 1], label=\"v3\")\n", "axs[1].set_xlabel(\"Time\")\n", "axs[1].set_ylabel(\"Velocity\")\n", "axs[1].legend()\n", "axs[1].grid()\n", "\n", "plt.show()" - ] + ], + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 2 + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "db7dce5e7d80b522" } ], "metadata": { diff --git a/test/helpers.py b/test/helpers.py index 82bb4e1e..8b3b2811 100644 --- a/test/helpers.py +++ b/test/helpers.py @@ -12,7 +12,7 @@ AbstractBrownianPath, AbstractTerm, ControlTerm, - make_langevin_term, + make_underdamped_langevin_term, MultiTerm, ODETerm, VirtualBrownianTree, @@ -499,7 +499,7 @@ def get_bqp(t0=0.3, t1=15.0, dtype=jnp.float32): w_shape_bqp = () def get_terms_bqp(bm): - return make_langevin_term(gamma, u, grad_f_bqp, bm, y0_bqp[0]) + return make_underdamped_langevin_term(gamma, u, grad_f_bqp, bm) return SDE(get_terms_bqp, None, y0_bqp, t0, t1, w_shape_bqp) @@ -513,7 +513,7 @@ def get_harmonic_oscillator(t0=0.3, t1=15.0, dtype=jnp.float32): w_shape_hosc = (2,) def get_terms_hosc(bm): - return make_langevin_term(gamma_hosc, u_hosc, lambda x: 2 * x, bm, x0) + return make_underdamped_langevin_term(gamma_hosc, u_hosc, lambda x: 2 * x, bm) return SDE(get_terms_hosc, None, y0_hosc, t0, t1, w_shape_hosc) @@ -534,7 +534,7 @@ def log_p(x): w_shape_neal = (10,) def get_terms_neal(bm): - return make_langevin_term(gamma, u, grad_log_p, bm, x0) + return make_underdamped_langevin_term(gamma, u, grad_log_p, bm) return SDE(get_terms_neal, None, y0_neal, t0, t1, w_shape_neal) @@ -588,6 +588,6 @@ def grad_f(x): w_shape_uld3 = (9,) def get_terms_uld3(bm): - return make_langevin_term(u, gamma, grad_f, bm, x0) + return make_underdamped_langevin_term(u, gamma, grad_f, bm) return SDE(get_terms_uld3, None, y0_uld3, t0, t1, w_shape_uld3) diff --git a/test/test_langevin.py b/test/test_langevin.py index 4ec872be..46c58e72 100644 --- a/test/test_langevin.py +++ b/test/test_langevin.py @@ -4,7 +4,7 @@ import jax.random as jr import jax.tree_util as jtu import pytest -from diffrax import diffeqsolve, make_langevin_term, SaveAt +from diffrax import diffeqsolve, make_underdamped_langevin_term, SaveAt from .helpers import ( get_bqp, @@ -68,20 +68,23 @@ def grad_f(x): w_shape = jtu.tree_map(lambda _x: jax.ShapeDtypeStruct(_x.shape, _x.dtype), x0) def get_terms(bm): - return make_langevin_term(g1, u1, grad_f, bm, x0) + return make_underdamped_langevin_term(g1, u1, grad_f, bm) return SDE(get_terms, None, y0, t0, t1, w_shape) -@pytest.mark.parametrize("solver_cls", _only_langevin_solvers_cls()) -@pytest.mark.parametrize("taylor", [True, False]) -@pytest.mark.parametrize("dtype", [jnp.float16, jnp.float32, jnp.float64]) -def test_shape(solver_cls, taylor, dtype): - if taylor: - solver = solver_cls(100.0) - else: - solver = solver_cls(0.01) +# All combinations of solvers with and without Taylor expansion +_langevin_solvers_taylor_non_taylor = [ + solver_cls(taylor_threshold) + for solver_cls in _only_langevin_solvers_cls() + for taylor_threshold in [0.0, 100.0] +] +_langevin_plus_shark = [diffrax.ShARK()] + list(_langevin_solvers_taylor_non_taylor) + +@pytest.mark.parametrize("solver", _langevin_plus_shark) +@pytest.mark.parametrize("dtype", [jnp.float16, jnp.float32, jnp.float64]) +def test_shape(solver, dtype): t0, t1 = 0.3, 1.0 dt0 = 0.3 saveat = SaveAt(ts=jnp.linspace(t0, t1, 7, dtype=dtype)) @@ -102,7 +105,6 @@ def check_shape(y0_leaf, sol_leaf): sol_leaf.shape == (7,) + y0_leaf.shape ), f"shape={sol_leaf.shape}, expected={(7,) + y0_leaf.shape}" assert sol_leaf.dtype == dtype, f"dtype={sol_leaf.dtype}, expected={dtype}" - return sol_leaf.shape jtu.tree_map(check_shape, sde.y0, sol.ys) @@ -166,13 +168,15 @@ def test_langevin_strong_order( true_sol = true_sols[sde_name] if theoretical_order < 3: + # When the order is 3 the solver gets more precise than the reference + # solution already at level 6, but when the order is 2, we can go up + # to level 7. level_fine += 1 sde = get_sde(t0, t1, jnp.float64) - # We specify the times to which we step in way that each level contains all the - # steps of the previous level. This is so that we can compare the solutions at - # all the times in saveat, and not just at the end time. + # We specify the times to which we step in a way that saveat is a subset + # of step_ts. This way the SDE was evaluated at all the times we compare at. def get_dt_and_controller(level): step_ts = jnp.linspace(t0, t1, 2**level + 1, endpoint=True) return None, diffrax.StepTo(ts=step_ts) @@ -189,9 +193,7 @@ def get_dt_and_controller(level): levy_area=levy_area, ref_solution=true_sol, ) - # The upper bound needs to be 0.25, otherwise we fail. - # This still preserves a 0.05 buffer between the intervals - # corresponding to the different orders. + assert ( -0.2 < order - theoretical_order < 0.25 ), f"order={order}, theoretical_order={theoretical_order}" @@ -217,7 +219,7 @@ def test_reverse_solve(solver_cls): key=jr.key(0), levy_area=diffrax.SpaceTimeTimeLevyArea, ) - terms = diffrax.make_langevin_term(gamma, u, lambda x: 2 * x, bm, x0) + terms = diffrax.make_underdamped_langevin_term(gamma, u, lambda x: 2 * x, bm) solver = solver_cls(0.01) sol = diffeqsolve(terms, solver, t0, t1, dt0=dt0, y0=y0, args=None, saveat=saveat) @@ -227,7 +229,5 @@ def test_reverse_solve(solver_cls): terms, ref_solver, t0, t1, dt0=dt0, y0=y0, args=None, saveat=saveat ) - # print(jtu.tree_map(lambda x: x.shape, sol.ys)) - # print(jtu.tree_map(lambda x: x.shape, ref_sol.ys)) error = path_l2_dist(sol.ys, ref_sol.ys) assert error < 0.1 From d2093ee81c278e474c62bea4046f79ef2dfd574b Mon Sep 17 00:00:00 2001 From: andyElking Date: Sat, 31 Aug 2024 14:01:32 +0100 Subject: [PATCH 10/15] langevin -> underdamped_langevin --- diffrax/_solver/align.py | 41 ++++---- ...langevin_srk.py => foster_langevin_srk.py} | 79 +++++++++------- diffrax/_solver/quicsort.py | 32 +++---- diffrax/_solver/should.py | 32 +++---- diffrax/_term.py | 56 ++++++----- docs/api/solvers/sde_solvers.md | 2 +- docs/devdocs/srk_example.ipynb | 94 ++++--------------- docs/usage/how-to-choose-a-solver.md | 2 +- ...ynb => underdamped_langevin_example.ipynb} | 10 +- mkdocs.yml | 2 +- ...ngevin.py => test_underdamped_langevin.py} | 24 ++--- 11 files changed, 171 insertions(+), 203 deletions(-) rename diffrax/_solver/{langevin_srk.py => foster_langevin_srk.py} (87%) rename examples/{langevin_example.ipynb => underdamped_langevin_example.ipynb} (99%) rename test/{test_langevin.py => test_underdamped_langevin.py} (90%) diff --git a/diffrax/_solver/align.py b/diffrax/_solver/align.py index 68f2f74c..c263ec18 100644 --- a/diffrax/_solver/align.py +++ b/diffrax/_solver/align.py @@ -9,15 +9,19 @@ RealScalarLike, ) from .._local_interpolation import LocalLinearInterpolation -from .._term import LangevinLeaf, LangevinTuple, LangevinX -from .langevin_srk import ( - _LangevinArgs, +from .._term import ( + UnderdampedLangevinLeaf, + UnderdampedLangevinTuple, + UnderdampedLangevinX, +) +from .foster_langevin_srk import ( AbstractCoeffs, AbstractFosterLangevinSRK, + ULDArgs, ) -# For an explanation of the coefficients, see langevin_srk.py +# For an explanation of the coefficients, see foster_langevin_srk.py class _ALIGNCoeffs(AbstractCoeffs): beta: PyTree[ArrayLike] a1: PyTree[ArrayLike] @@ -36,7 +40,7 @@ def __init__(self, beta, a1, b1, aa, chh): self.dtype = jnp.result_type(*all_leaves) -_ErrorEstimate = LangevinTuple +_ErrorEstimate = UnderdampedLangevinTuple class ALIGN(AbstractFosterLangevinSRK[_ALIGNCoeffs, _ErrorEstimate]): @@ -85,7 +89,7 @@ def strong_order(self, terms): return 2.0 def _directly_compute_coeffs_leaf( - self, h: RealScalarLike, c: LangevinLeaf + self, h: RealScalarLike, c: UnderdampedLangevinLeaf ) -> _ALIGNCoeffs: del self # c is a leaf of gamma @@ -107,7 +111,7 @@ def _directly_compute_coeffs_leaf( chh=chh, ) - def _tay_coeffs_single(self, c: LangevinLeaf) -> _ALIGNCoeffs: + def _tay_coeffs_single(self, c: UnderdampedLangevinLeaf) -> _ALIGNCoeffs: del self # c is a leaf of gamma zero = jnp.zeros_like(c) @@ -142,18 +146,23 @@ def _compute_step( self, h: RealScalarLike, levy: AbstractSpaceTimeLevyArea, - x0: LangevinX, - v0: LangevinX, - langevin_args: _LangevinArgs, + x0: UnderdampedLangevinX, + v0: UnderdampedLangevinX, + uld_args: ULDArgs, coeffs: _ALIGNCoeffs, - rho: LangevinX, - prev_f: LangevinX, - ) -> tuple[LangevinX, LangevinX, LangevinX, LangevinTuple]: + rho: UnderdampedLangevinX, + prev_f: UnderdampedLangevinX, + ) -> tuple[ + UnderdampedLangevinX, + UnderdampedLangevinX, + UnderdampedLangevinX, + UnderdampedLangevinTuple, + ]: dtypes = jtu.tree_map(jnp.result_type, x0) - w: LangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) - hh: LangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) + w: UnderdampedLangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) + hh: UnderdampedLangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) - gamma, u, f = langevin_args + gamma, u, f = uld_args uh = (u**ω * h).ω f0 = prev_f diff --git a/diffrax/_solver/langevin_srk.py b/diffrax/_solver/foster_langevin_srk.py similarity index 87% rename from diffrax/_solver/langevin_srk.py rename to diffrax/_solver/foster_langevin_srk.py index eee4161c..75be3304 100644 --- a/diffrax/_solver/langevin_srk.py +++ b/diffrax/_solver/foster_langevin_srk.py @@ -22,32 +22,36 @@ from .._solution import RESULTS from .._term import ( AbstractTerm, - LangevinDiffusionTerm, - LangevinDriftTerm, - LangevinLeaf, - LangevinTuple, - LangevinX, MultiTerm, + UnderdampedLangevinDiffusionTerm, + UnderdampedLangevinDriftTerm, + UnderdampedLangevinLeaf, + UnderdampedLangevinTuple, + UnderdampedLangevinX, WrapTerm, ) from .base import AbstractItoSolver, AbstractStratonovichSolver -_ErrorEstimate = TypeVar("_ErrorEstimate", None, LangevinTuple) -_LangevinArgs = tuple[LangevinX, LangevinX, Callable[[LangevinX], LangevinX]] +_ErrorEstimate = TypeVar("_ErrorEstimate", None, UnderdampedLangevinTuple) +ULDArgs = tuple[ + UnderdampedLangevinX, + UnderdampedLangevinX, + Callable[[UnderdampedLangevinX], UnderdampedLangevinX], +] def _get_args_from_terms( terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], -) -> tuple[PyTree, PyTree, Callable[[LangevinX], LangevinX]]: +) -> tuple[PyTree, PyTree, Callable[[UnderdampedLangevinX], UnderdampedLangevinX]]: drift, diffusion = terms.terms if isinstance(drift, WrapTerm): assert isinstance(diffusion, WrapTerm) drift = drift.term diffusion = diffusion.term - assert isinstance(drift, LangevinDriftTerm) - assert isinstance(diffusion, LangevinDiffusionTerm) + assert isinstance(drift, UnderdampedLangevinDriftTerm) + assert isinstance(diffusion, UnderdampedLangevinDiffusionTerm) gamma = drift.gamma u = drift.u f = drift.grad_f @@ -93,13 +97,13 @@ class AbstractCoeffs(eqx.Module): class SolverState(eqx.Module, Generic[_Coeffs]): - gamma: LangevinX - u: LangevinX + gamma: UnderdampedLangevinX + u: UnderdampedLangevinX h: RealScalarLike - taylor_coeffs: PyTree[_Coeffs, "LangevinX"] + taylor_coeffs: PyTree[_Coeffs, "UnderdampedLangevinX"] coeffs: _Coeffs - rho: LangevinX - prev_f: LangevinX + rho: UnderdampedLangevinX + prev_f: UnderdampedLangevinX class AbstractFosterLangevinSRK( @@ -126,14 +130,16 @@ class AbstractFosterLangevinSRK( [`diffrax.ShOULD`][], and [`diffrax.QUIC_SORT`][]. """ - term_structure = MultiTerm[tuple[LangevinDriftTerm, LangevinDiffusionTerm]] + term_structure = MultiTerm[ + tuple[UnderdampedLangevinDriftTerm, UnderdampedLangevinDiffusionTerm] + ] interpolation_cls = LocalLinearInterpolation minimal_levy_area: eqx.AbstractClassVar[type[AbstractBrownianIncrement]] taylor_threshold: AbstractVar[RealScalarLike] @abc.abstractmethod def _directly_compute_coeffs_leaf( - self, h: RealScalarLike, c: LangevinLeaf + self, h: RealScalarLike, c: UnderdampedLangevinLeaf ) -> _Coeffs: r"""This method specifies how to compute the SRK coefficients directly (as opposed to via Taylor expansion). This function is then mapped over the @@ -151,7 +157,7 @@ def _directly_compute_coeffs_leaf( raise NotImplementedError @abc.abstractmethod - def _tay_coeffs_single(self, c: LangevinLeaf) -> _Coeffs: + def _tay_coeffs_single(self, c: UnderdampedLangevinLeaf) -> _Coeffs: r"""This method specifies how to compute the Taylor coefficients for a single leaf of gamma. These coefficients are then used to compute the SRK coefficients using the Taylor expansion. This function is then mapped over @@ -184,14 +190,17 @@ def eval_taylor_fun(tay_leaf): return jtu.tree_map(eval_taylor_fun, tay_coeffs) def _recompute_coeffs( - self, h: RealScalarLike, gamma: LangevinX, tay_coeffs: PyTree[_Coeffs] + self, + h: RealScalarLike, + gamma: UnderdampedLangevinX, + tay_coeffs: PyTree[_Coeffs], ) -> _Coeffs: r"""When h changes, the SRK coefficients (which depend on h) are recomputed using this function.""" # Inner will record the tree structure of the coefficients inner = sentinel = object() - def recompute_coeffs_leaf(c: LangevinLeaf, _tay_coeffs: _Coeffs): + def recompute_coeffs_leaf(c: UnderdampedLangevinLeaf, _tay_coeffs: _Coeffs): # c is a leaf of gamma # Depending on the size of h*gamma choose whether the Taylor expansion or # direct computation is more accurate. @@ -250,7 +259,7 @@ def init( terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], t0: RealScalarLike, t1: RealScalarLike, - y0: LangevinTuple, + y0: UnderdampedLangevinTuple, args: PyTree, ) -> SolverState: """Precompute _SolverState which carries the Taylor coefficients and the @@ -300,14 +309,16 @@ def _compute_step( self, h: RealScalarLike, levy, - x0: LangevinX, - v0: LangevinX, - langevin_args: _LangevinArgs, + x0: UnderdampedLangevinX, + v0: UnderdampedLangevinX, + uld_args: ULDArgs, coeffs: _Coeffs, - rho: LangevinX, - prev_f: LangevinX, - ) -> tuple[LangevinX, LangevinX, LangevinX, _ErrorEstimate]: - r"""This method specifies how to compute a single step of the Langevin SRK + rho: UnderdampedLangevinX, + prev_f: UnderdampedLangevinX, + ) -> tuple[ + UnderdampedLangevinX, UnderdampedLangevinX, UnderdampedLangevinX, _ErrorEstimate + ]: + r"""This method specifies how to compute a single step of the ULD SRK method. This holds just the computation that differs between the different SRK methods. The common bits are handled by the `step` method.""" raise NotImplementedError @@ -317,11 +328,13 @@ def step( terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], t0: RealScalarLike, t1: RealScalarLike, - y0: LangevinTuple, + y0: UnderdampedLangevinTuple, args: PyTree, solver_state: SolverState, made_jump: BoolScalarLike, - ) -> tuple[LangevinTuple, _ErrorEstimate, DenseInfo, SolverState, RESULTS]: + ) -> tuple[ + UnderdampedLangevinTuple, _ErrorEstimate, DenseInfo, SolverState, RESULTS + ]: del args st = solver_state drift, diffusion = terms.terms @@ -352,7 +365,9 @@ def step( ) x0, v0 = y0 - prev_f = lax.cond(made_jump, lambda: grad_f(x0), lambda: st.prev_f) + prev_f = lax.cond( + eqxi.unvmap_any(made_jump), lambda: grad_f(x0), lambda: st.prev_f + ) # The actual step computation, handled by the subclass x_out, v_out, f_fsal, error = self._compute_step( @@ -389,7 +404,7 @@ def func( self, terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], t0: RealScalarLike, - y0: LangevinTuple, + y0: UnderdampedLangevinTuple, args: PyTree, ): return terms.vf(t0, y0, args) diff --git a/diffrax/_solver/quicsort.py b/diffrax/_solver/quicsort.py index 033ff460..c2f83d61 100644 --- a/diffrax/_solver/quicsort.py +++ b/diffrax/_solver/quicsort.py @@ -12,15 +12,15 @@ RealScalarLike, ) from .._local_interpolation import LocalLinearInterpolation -from .._term import LangevinLeaf, LangevinX -from .langevin_srk import ( - _LangevinArgs, +from .._term import UnderdampedLangevinLeaf, UnderdampedLangevinX +from .foster_langevin_srk import ( AbstractCoeffs, AbstractFosterLangevinSRK, + ULDArgs, ) -# For an explanation of the coefficients, see langevin_srk.py +# For an explanation of the coefficients, see foster_langevin_srk.py # UBU evaluates at l = (3 -sqrt(3))/6, at r = (3 + sqrt(3))/6 and at 1, # so we need 3 versions of each coefficient class _QUICSORTCoeffs(AbstractCoeffs): @@ -103,7 +103,7 @@ def strong_order(self, terms): return 3.0 def _directly_compute_coeffs_leaf( - self, h: RealScalarLike, c: LangevinLeaf + self, h: RealScalarLike, c: UnderdampedLangevinLeaf ) -> _QUICSORTCoeffs: del self # compute the coefficients directly (as opposed to via Taylor expansion) @@ -131,7 +131,7 @@ def _directly_compute_coeffs_leaf( a_div_h=a_div_h, ) - def _tay_coeffs_single(self, c: LangevinLeaf) -> _QUICSORTCoeffs: + def _tay_coeffs_single(self, c: UnderdampedLangevinLeaf) -> _QUICSORTCoeffs: del self # c is a leaf of gamma dtype = jnp.result_type(c) @@ -188,19 +188,19 @@ def _compute_step( self, h: RealScalarLike, levy: AbstractSpaceTimeTimeLevyArea, - x0: LangevinX, - v0: LangevinX, - langevin_args: _LangevinArgs, + x0: UnderdampedLangevinX, + v0: UnderdampedLangevinX, + uld_args: ULDArgs, coeffs: _QUICSORTCoeffs, - rho: LangevinX, - prev_f: LangevinX, - ) -> tuple[LangevinX, LangevinX, LangevinX, None]: + rho: UnderdampedLangevinX, + prev_f: UnderdampedLangevinX, + ) -> tuple[UnderdampedLangevinX, UnderdampedLangevinX, UnderdampedLangevinX, None]: dtypes = jtu.tree_map(jnp.result_type, x0) - w: LangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) - hh: LangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) - kk: LangevinX = jtu.tree_map(jnp.asarray, levy.K, dtypes) + w: UnderdampedLangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) + hh: UnderdampedLangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) + kk: UnderdampedLangevinX = jtu.tree_map(jnp.asarray, levy.K, dtypes) - gamma, u, f = langevin_args + gamma, u, f = uld_args def _extract_coeffs(coeff, index): return jtu.tree_map(lambda arr: arr[..., index], coeff) diff --git a/diffrax/_solver/should.py b/diffrax/_solver/should.py index 7de6b882..8143acdd 100644 --- a/diffrax/_solver/should.py +++ b/diffrax/_solver/should.py @@ -9,15 +9,15 @@ RealScalarLike, ) from .._local_interpolation import LocalLinearInterpolation -from .._term import LangevinLeaf, LangevinX -from .langevin_srk import ( - _LangevinArgs, +from .._term import UnderdampedLangevinLeaf, UnderdampedLangevinX +from .foster_langevin_srk import ( AbstractCoeffs, AbstractFosterLangevinSRK, + ULDArgs, ) -# For an explanation of the coefficients, see langevin_srk.py +# For an explanation of the coefficients, see foster_langevin_srk.py class _ShOULDCoeffs(AbstractCoeffs): beta_half: PyTree[ArrayLike] a_half: PyTree[ArrayLike] @@ -101,7 +101,7 @@ def strong_order(self, terms): return 3.0 def _directly_compute_coeffs_leaf( - self, h: RealScalarLike, c: LangevinLeaf + self, h: RealScalarLike, c: UnderdampedLangevinLeaf ) -> _ShOULDCoeffs: del self # c is a leaf of gamma @@ -132,7 +132,7 @@ def _directly_compute_coeffs_leaf( ckk=ckk, ) - def _tay_coeffs_single(self, c: LangevinLeaf) -> _ShOULDCoeffs: + def _tay_coeffs_single(self, c: UnderdampedLangevinLeaf) -> _ShOULDCoeffs: del self # c is a leaf of gamma zero = jnp.zeros_like(c) @@ -190,19 +190,19 @@ def _compute_step( self, h: RealScalarLike, levy: AbstractSpaceTimeTimeLevyArea, - x0: LangevinX, - v0: LangevinX, - langevin_args: _LangevinArgs, + x0: UnderdampedLangevinX, + v0: UnderdampedLangevinX, + uld_args: ULDArgs, coeffs: _ShOULDCoeffs, - rho: LangevinX, - prev_f: LangevinX, - ) -> tuple[LangevinX, LangevinX, LangevinX, None]: + rho: UnderdampedLangevinX, + prev_f: UnderdampedLangevinX, + ) -> tuple[UnderdampedLangevinX, UnderdampedLangevinX, UnderdampedLangevinX, None]: dtypes = jtu.tree_map(jnp.result_type, x0) - w: LangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) - hh: LangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) - kk: LangevinX = jtu.tree_map(jnp.asarray, levy.K, dtypes) + w: UnderdampedLangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) + hh: UnderdampedLangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) + kk: UnderdampedLangevinX = jtu.tree_map(jnp.asarray, levy.K, dtypes) - gamma, u, f = langevin_args + gamma, u, f = uld_args rho_w_k = (rho**ω * (w**ω - 12 * kk**ω)).ω uh = (u**ω * h).ω diff --git a/diffrax/_term.py b/diffrax/_term.py index 9f2a07c3..71c22ca4 100644 --- a/diffrax/_term.py +++ b/diffrax/_term.py @@ -788,12 +788,14 @@ def _to_vjp(_y, _diff_args, _diff_term): # The Underdamped Langevin SDE trajectory consists of two components: the position -# `x` and the velocity `v`. Both of these have the same shape. So, by LangevinX we -# denote the shape of the x component, and by LangevinTuple we denote the shape of -# the tuple (x, v). -LangevinLeaf = Shaped[Array, "*langevin"] -LangevinX = PyTree[Shaped[Array, "?*langevin"], "LangevinX"] -LangevinTuple = tuple[LangevinX, LangevinX] +# `x` and the velocity `v`. Both of these have the same shape. +# So, by UnderdampedLangevinX we denote the shape of the x component, and by +# UnderdampedLangevinTuple we denote the shape of the tuple (x, v). +UnderdampedLangevinLeaf = Shaped[Array, "*underdamped_langevin"] +UnderdampedLangevinX = PyTree[ + Shaped[Array, "?*underdamped_langevin"], "UnderdampedLangevinX" +] +UnderdampedLangevinTuple = tuple[UnderdampedLangevinX, UnderdampedLangevinX] def _broadcast_pytree(source, target_tree): @@ -813,8 +815,10 @@ def fun(_leaf): return jtu.tree_map(_inner_broadcast, source, target_tree) -class LangevinDiffusionTerm( - AbstractTerm[LangevinX, Union[LangevinX, AbstractBrownianIncrement]] +class UnderdampedLangevinDiffusionTerm( + AbstractTerm[ + UnderdampedLangevinX, Union[UnderdampedLangevinX, AbstractBrownianIncrement] + ] ): r"""Represents the diffusion term in the Underdamped Langevin Diffusion (ULD). The ULD SDE takes the form: @@ -836,25 +840,29 @@ class LangevinDiffusionTerm( u: PyTree[ArrayLike] control: AbstractBrownianPath - def vf(self, t: RealScalarLike, y: LangevinTuple, args: Args) -> LangevinX: + def vf( + self, t: RealScalarLike, y: UnderdampedLangevinTuple, args: Args + ) -> UnderdampedLangevinX: x, v = y # gamma, u and v can all have different pytree structures, we only know that # gamma and u are prefixes of v gamma = _broadcast_pytree(self.gamma, v) u = _broadcast_pytree(self.u, v) - def _fun(_gamma, _u, _v): + def _fun(_gamma, _u): return jnp.sqrt(2 * _gamma * _u) - vf_v = jtu.tree_map(_fun, gamma, u, v) + vf_v = jtu.tree_map(_fun, gamma, u) return vf_v def contr( self, t0: RealScalarLike, t1: RealScalarLike, **kwargs - ) -> Union[LangevinX, AbstractBrownianIncrement]: + ) -> Union[UnderdampedLangevinX, AbstractBrownianIncrement]: return self.control.evaluate(t0, t1, **kwargs) - def prod(self, vf: LangevinX, control: LangevinX) -> LangevinTuple: + def prod( + self, vf: UnderdampedLangevinX, control: UnderdampedLangevinX + ) -> UnderdampedLangevinTuple: # The vf is only for the velocity component. The position component is # unaffected by the diffusion. dw = control @@ -863,7 +871,7 @@ def prod(self, vf: LangevinX, control: LangevinX) -> LangevinTuple: return x_out, v_out -class LangevinDriftTerm(AbstractTerm): +class UnderdampedLangevinDriftTerm(AbstractTerm): r"""Represents the drift term in the Underdamped Langevin Diffusion (ULD). The ULD SDE takes the form: @@ -882,9 +890,11 @@ class LangevinDriftTerm(AbstractTerm): gamma: PyTree[ArrayLike] u: PyTree[ArrayLike] - grad_f: Callable[[LangevinX], LangevinX] + grad_f: Callable[[UnderdampedLangevinX], UnderdampedLangevinX] - def vf(self, t: RealScalarLike, y: LangevinTuple, args: Args) -> LangevinTuple: + def vf( + self, t: RealScalarLike, y: UnderdampedLangevinTuple, args: Args + ) -> UnderdampedLangevinTuple: x, v = y # gamma, u and v can all have different pytree structures, we only know that # gamma and u are prefixes of v (which is the same as x) @@ -904,16 +914,18 @@ def fun(_gamma, _u, _v, _f_x): def contr(self, t0: RealScalarLike, t1: RealScalarLike, **kwargs) -> RealScalarLike: return t1 - t0 - def prod(self, vf: LangevinTuple, control: RealScalarLike) -> LangevinTuple: + def prod( + self, vf: UnderdampedLangevinTuple, control: RealScalarLike + ) -> UnderdampedLangevinTuple: return jtu.tree_map(lambda _vf: control * _vf, vf) def make_underdamped_langevin_term( gamma: PyTree[ArrayLike], u: PyTree[ArrayLike], - grad_f: Callable[[LangevinX], LangevinX], + grad_f: Callable[[UnderdampedLangevinX], UnderdampedLangevinX], bm: AbstractBrownianPath, -) -> MultiTerm[tuple[LangevinDriftTerm, LangevinDiffusionTerm]]: +) -> MultiTerm[tuple[UnderdampedLangevinDriftTerm, UnderdampedLangevinDiffusionTerm]]: r"""Creates a term that represents the Underdamped Langevin Diffusion, given by: \begin{align*} @@ -941,12 +953,12 @@ def make_underdamped_langevin_term( **Returns:** - A `MultiTerm` representing the Langevin SDE. + A `MultiTerm` representing the Underdamped Langevin SDE. """ # In practice we don't require the PyTree structure of gamma and u to be the same # as x and v. We only require that they are prefixes of x and v, in a way that # allows us to call _broadcast_pytree(gamma, x) and _broadcast_pytree(u, x). - drift = LangevinDriftTerm(gamma, u, grad_f) - diffusion = LangevinDiffusionTerm(gamma, u, bm) + drift = UnderdampedLangevinDriftTerm(gamma, u, grad_f) + diffusion = UnderdampedLangevinDiffusionTerm(gamma, u, bm) return MultiTerm(drift, diffusion) diff --git a/docs/api/solvers/sde_solvers.md b/docs/api/solvers/sde_solvers.md index 0a5be40a..bf7bd48b 100644 --- a/docs/api/solvers/sde_solvers.md +++ b/docs/api/solvers/sde_solvers.md @@ -137,7 +137,7 @@ the friction and the inertia of the system. They are more precise for this diffusion than the general-purpose solvers above, but cannot be used for any other SDEs. They only accept terms generated by the [`diffrax.make_underdamped_langevin_term`][] function. -For an example of their usage, see the [Langevin example](../../examples/langevin_example.ipynb). +For an example of their usage, see the [Underdamped Langevin example](../../examples/underdamped_langevin_example.ipynb). ::: diffrax.ALIGN selection: diff --git a/docs/devdocs/srk_example.ipynb b/docs/devdocs/srk_example.ipynb index aa2a38cf..b3ed16db 100644 --- a/docs/devdocs/srk_example.ipynb +++ b/docs/devdocs/srk_example.ipynb @@ -24,6 +24,7 @@ "- just the Brownian motion $W$, without any Lévy area\n", "- $W$ and the space-time Lévy area $H$\n", "- $W$, $H$ and the space-time-time Lévy area $K$.\n", + "\n", "For more information see the documentation of the `StochasticButcherTableau` class.\n", "\n", "First we will demonstrate an additive-noise-only SRK method, the ShARK method, on an SDE with additive, time-dependent noise.\n", @@ -42,15 +43,7 @@ }, "collapsed": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "env: JAX_PLATFORM_NAME=cuda\n" - ] - } - ], + "outputs": [], "source": [ "%env JAX_PLATFORM_NAME=cuda\n", "\n", @@ -158,14 +151,17 @@ " save_ts_pid = jnp.linspace(sde.t0, sde.t1, 65, endpoint=True)\n", "\n", " def get_pid(level):\n", - " return diffrax.PIDController(\n", + " pid = diffrax.PIDController(\n", " pcoeff=0.1,\n", " icoeff=0.3,\n", " rtol=2 ** -(level - 1),\n", " atol=2 ** -(level + 3),\n", - " step_ts=save_ts_pid,\n", " dtmin=2**-14,\n", " )\n", + " return diffrax.JumpStepWrapper(\n", + " pid,\n", + " step_ts=save_ts_pid,\n", + " )\n", "\n", " saveat_pid = diffrax.SaveAt(ts=save_ts_pid)\n", " return simple_sde_order(\n", @@ -203,16 +199,7 @@ }, "collapsed": false }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": "
" - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# A plot of the solution of the SDE used to compare the methods\n", "sol_general = diffeqsolve(\n", @@ -236,7 +223,7 @@ }, "source": [ "### ShARK\n", - "`ShARK` is an SRK method for additive-noise SDEs. It uses two vector-field evaluations per step and has strong order 1.5, but applied to a Langevin SDE it has order 2.\n", + "`ShARK` is an SRK method for additive-noise SDEs. It uses two vector-field evaluations per step and has strong order 1.5, but applied to an Underdamped Langevin SDE it has order 2.\n", " While it has the same order as `SRA1`, it has a better proportionality constant.\n", "\n", "Based on equation (6.1) in\n", @@ -247,7 +234,7 @@ "\n", "### General ShARK\n", "`GeneralShARK` is a generalisation of the ShARK method which now works for any SDE, not only those with additive noise. It uses three evaluations of the vector field per step and has the following strong orders of convergence:\n", - "- 2 for the Langevin SDEs\n", + "- 2 for the Underdamped Langevin SDEs\n", "- 1.5 for additive noise SDEs\n", "- 1 for commutative noise SDEs\n", "- 0.5 for general SDEs.\n", @@ -255,7 +242,7 @@ "\n", "### SRA1\n", "Another method for additive-noise SDEs.\n", - "`SRA1` normally has strong order 1.5, but when applied to a Langevin SDE it has order 2. It natively supports adaptive-stepping via an embedded method for error estimation. Uses two evaluations of the vector-field per step.\n", + "`SRA1` normally has strong order 1.5, but when applied to an Underdamped Langevin SDE it has order 2. It natively supports adaptive-stepping via an embedded method for error estimation. Uses two evaluations of the vector-field per step.\n", "\n", "Based on the SRA1 method from\n", " A. Rößler, Runge–Kutta methods for the strong approximation of solutions of stochastic differential equations,\n", @@ -276,7 +263,7 @@ "For general SDEs, this has order 0.5.\n", "When the noise is commutative it has order 1.\n", "When the noise is additive it has order 1.5.\n", - "For the Langevin SDE it has order 2.\n", + "For the Underdamped Langevin SDE it has order 2.\n", "Requires the space-time Lévy area H.\n", "It also natively supports adaptive time-stepping.\n", "\n", @@ -334,16 +321,7 @@ }, "collapsed": false }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": "
" - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "draw_order_multiple(\n", " [out_SLOWRK_mlp_sde, out_SPaRK_mlp_sde, out_GenShARK_mlp_sde],\n", @@ -373,16 +351,7 @@ }, "collapsed": false }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": "
" - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# A plot of the solution of the commutative-noise SDE used to compare the methods\n", "# A plot of the solution of the SDE\n", @@ -437,16 +406,7 @@ }, "collapsed": false }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": "
" - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "draw_order_multiple(\n", " [\n", @@ -480,16 +440,7 @@ }, "collapsed": false }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": "
" - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# A plot of the solution of the additive-noise SDE used to compare the methods\n", "# A plot of the solution of the SDE\n", @@ -550,18 +501,7 @@ }, "collapsed": false }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "draw_order_multiple(\n", " [\n", diff --git a/docs/usage/how-to-choose-a-solver.md b/docs/usage/how-to-choose-a-solver.md index 01b4dcc5..2dce12d1 100644 --- a/docs/usage/how-to-choose-a-solver.md +++ b/docs/usage/how-to-choose-a-solver.md @@ -94,7 +94,7 @@ In this case the Itô solution and the Stratonovich solution coincide, and mathe ### Underdamped Langevin Diffusion The Underdamped Langevin Diffusion is a special case of an SDE with additive noise. -For details on the form of this SDE and appropriate solvers refer to the section on [Underdamped Langevin solvers](../api/solvers/sde_solvers.md#underdamped-langevin-solvers). +For details on the form of this SDE and appropriate solvers, please refer to the section on [Underdamped Langevin solvers](../api/solvers/sde_solvers.md#underdamped-langevin-solvers). --- diff --git a/examples/langevin_example.ipynb b/examples/underdamped_langevin_example.ipynb similarity index 99% rename from examples/langevin_example.ipynb rename to examples/underdamped_langevin_example.ipynb index 55042271..67fa4d9b 100644 --- a/examples/langevin_example.ipynb +++ b/examples/underdamped_langevin_example.ipynb @@ -29,7 +29,7 @@ "\n", "In addition to generic SDE solvers (which can solve any SDE including ULD), Diffrax has some solvers designed specifically for ULD. These are `diffrax.ALIGN` which has a 2nd order of strong convergence, and `diffrax.QUICSORT` and `diffrax.ShOULD` which are 3rd order solvers. Note that unlike ODE solvers which can have orders of 5 or even higher, very few types of SDEs permit solvers with a strong order greater than $\\frac{1}{2}$.\n", "\n", - "These Langevin-specific solvers only accept terms retuned by `diffrax.make_underdamped_langevin_term`.\n", + "These ULD-specific solvers only accept terms retuned by `diffrax.make_underdamped_langevin_term`.\n", "\n", "## A 2D harmonic oscillator\n", "\n", @@ -125,14 +125,6 @@ } ], "execution_count": 2 - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "source": "", - "id": "db7dce5e7d80b522" } ], "metadata": { diff --git a/mkdocs.yml b/mkdocs.yml index 71205be8..4004ec82 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -112,7 +112,7 @@ nav: - Kalman filter: 'examples/kalman_filter.ipynb' - Second-order sensitivities: 'examples/hessian.ipynb' - Nonlinear heat PDE: 'examples/nonlinear_heat_pde.ipynb' - - Langevin diffusion: 'examples/langevin_example.ipynb' + - Underdamped Langevin diffusion: 'examples/underdamped_langevin_example.ipynb' - Basic API: - 'api/diffeqsolve.md' - Solvers: diff --git a/test/test_langevin.py b/test/test_underdamped_langevin.py similarity index 90% rename from test/test_langevin.py rename to test/test_underdamped_langevin.py index 46c58e72..5c8f91fe 100644 --- a/test/test_langevin.py +++ b/test/test_underdamped_langevin.py @@ -16,7 +16,7 @@ ) -def _only_langevin_solvers_cls(): +def _only_uld_solvers_cls(): yield diffrax.ALIGN yield diffrax.ShOULD yield diffrax.QUICSORT @@ -30,7 +30,7 @@ def _solvers_and_orders(): yield diffrax.ShARK(), 2.0 -def get_pytree_langevin(t0=0.3, t1=1.0, dtype=jnp.float32): +def get_pytree_uld(t0=0.3, t1=1.0, dtype=jnp.float32): def make_pytree(array_factory): return { "rr": ( @@ -74,22 +74,22 @@ def get_terms(bm): # All combinations of solvers with and without Taylor expansion -_langevin_solvers_taylor_non_taylor = [ +_uld_solvers_taylor_non_taylor = [ solver_cls(taylor_threshold) - for solver_cls in _only_langevin_solvers_cls() + for solver_cls in _only_uld_solvers_cls() for taylor_threshold in [0.0, 100.0] ] -_langevin_plus_shark = [diffrax.ShARK()] + list(_langevin_solvers_taylor_non_taylor) +_uld_plus_shark = [diffrax.ShARK()] + list(_uld_solvers_taylor_non_taylor) -@pytest.mark.parametrize("solver", _langevin_plus_shark) +@pytest.mark.parametrize("solver", _uld_plus_shark) @pytest.mark.parametrize("dtype", [jnp.float16, jnp.float32, jnp.float64]) def test_shape(solver, dtype): t0, t1 = 0.3, 1.0 dt0 = 0.3 saveat = SaveAt(ts=jnp.linspace(t0, t1, 7, dtype=dtype)) - sde = get_pytree_langevin(t0, t1, dtype) + sde = get_pytree_uld(t0, t1, dtype) bm = sde.get_bm(jr.key(5678), diffrax.SpaceTimeTimeLevyArea, tol=0.2) terms = sde.get_terms(bm) @@ -116,7 +116,7 @@ def check_shape(y0_leaf, sol_leaf): @pytest.fixture(scope="module") -def fine_langevin_solutions(): +def fine_uld_solutions(): bmkey = jr.key(5678) num_samples = 2000 bmkeys = jr.split(bmkey, num=num_samples) @@ -151,8 +151,8 @@ def fine_langevin_solutions(): @pytest.mark.parametrize("get_sde,sde_name", sdes) @pytest.mark.parametrize("solver,theoretical_order", _solvers_and_orders()) -def test_langevin_strong_order( - get_sde, sde_name, solver, theoretical_order, fine_langevin_solutions +def test_uld_strong_order( + get_sde, sde_name, solver, theoretical_order, fine_uld_solutions ): ( true_sols, @@ -164,7 +164,7 @@ def test_langevin_strong_order( level_fine, levy_area, bm_tol, - ) = fine_langevin_solutions + ) = fine_uld_solutions true_sol = true_sols[sde_name] if theoretical_order < 3: @@ -199,7 +199,7 @@ def get_dt_and_controller(level): ), f"order={order}, theoretical_order={theoretical_order}" -@pytest.mark.parametrize("solver_cls", _only_langevin_solvers_cls()) +@pytest.mark.parametrize("solver_cls", _only_uld_solvers_cls()) def test_reverse_solve(solver_cls): t0, t1 = 0.7, -1.2 dt0 = -0.01 From 0a5ffebe15e70e81074c2ff5938a4d45eb72bf9b Mon Sep 17 00:00:00 2001 From: andyElking Date: Sun, 1 Sep 2024 14:59:26 +0100 Subject: [PATCH 11/15] round of small fixes --- diffrax/__init__.py | 3 + diffrax/_solver/__init__.py | 1 + diffrax/_solver/align.py | 7 +- diffrax/_solver/foster_langevin_srk.py | 111 ++++++------ diffrax/_solver/quicsort.py | 21 +-- diffrax/_solver/should.py | 7 +- diffrax/_term.py | 116 +++++++++++-- docs/api/solvers/abstract_solvers.md | 6 +- docs/api/solvers/sde_solvers.md | 6 +- docs/api/terms.md | 36 ++++ docs/devdocs/srk_example.ipynb | 176 +++++++++++++++----- examples/underdamped_langevin_example.ipynb | 2 +- test/test_underdamped_langevin.py | 15 +- 13 files changed, 373 insertions(+), 134 deletions(-) diff --git a/diffrax/__init__.py b/diffrax/__init__.py index bb2be025..fca3f02b 100644 --- a/diffrax/__init__.py +++ b/diffrax/__init__.py @@ -71,6 +71,7 @@ AbstractDIRK as AbstractDIRK, AbstractERK as AbstractERK, AbstractESDIRK as AbstractESDIRK, + AbstractFosterLangevinSRK as AbstractFosterLangevinSRK, AbstractImplicitSolver as AbstractImplicitSolver, AbstractItoSolver as AbstractItoSolver, AbstractRungeKutta as AbstractRungeKutta, @@ -129,6 +130,8 @@ make_underdamped_langevin_term as make_underdamped_langevin_term, MultiTerm as MultiTerm, ODETerm as ODETerm, + UnderdampedLangevinDiffusionTerm as UnderdampedLangevinDiffusionTerm, + UnderdampedLangevinDriftTerm as UnderdampedLangevinDriftTerm, WeaklyDiagonalControlTerm as WeaklyDiagonalControlTerm, ) diff --git a/diffrax/_solver/__init__.py b/diffrax/_solver/__init__.py index 7525b437..0a840413 100644 --- a/diffrax/_solver/__init__.py +++ b/diffrax/_solver/__init__.py @@ -13,6 +13,7 @@ from .dopri8 import Dopri8 as Dopri8 from .euler import Euler as Euler from .euler_heun import EulerHeun as EulerHeun +from .foster_langevin_srk import AbstractFosterLangevinSRK as AbstractFosterLangevinSRK from .heun import Heun as Heun from .implicit_euler import ImplicitEuler as ImplicitEuler from .kencarp3 import KenCarp3 as KenCarp3 diff --git a/diffrax/_solver/align.py b/diffrax/_solver/align.py index c263ec18..b682fcbe 100644 --- a/diffrax/_solver/align.py +++ b/diffrax/_solver/align.py @@ -17,7 +17,7 @@ from .foster_langevin_srk import ( AbstractCoeffs, AbstractFosterLangevinSRK, - ULDArgs, + UnderdampedLangevinArgs, ) @@ -71,6 +71,7 @@ class ALIGN(AbstractFosterLangevinSRK[_ALIGNCoeffs, _ErrorEstimate]): interpolation_cls = LocalLinearInterpolation minimal_levy_area = AbstractSpaceTimeLevyArea taylor_threshold: RealScalarLike = eqx.field(static=True) + _is_fsal = True def __init__(self, taylor_threshold: RealScalarLike = 0.1): r"""**Arguments:** @@ -129,7 +130,7 @@ def _tay_coeffs_single(self, c: UnderdampedLangevinLeaf) -> _ALIGNCoeffs: aa = jnp.stack([-c5 / 720, c4 / 120, -c3 / 24, c2 / 6, -c / 2, one], axis=-1) chh = jnp.stack([c4 / 168, -c3 / 30, 3 * c2 / 20, -c / 2, one, zero], axis=-1) - correct_shape = c.shape + (6,) + correct_shape = jnp.shape(c) + (6,) assert ( beta.shape == a1.shape == b1.shape == aa.shape == chh.shape == correct_shape ) @@ -148,7 +149,7 @@ def _compute_step( levy: AbstractSpaceTimeLevyArea, x0: UnderdampedLangevinX, v0: UnderdampedLangevinX, - uld_args: ULDArgs, + uld_args: UnderdampedLangevinArgs, coeffs: _ALIGNCoeffs, rho: UnderdampedLangevinX, prev_f: UnderdampedLangevinX, diff --git a/diffrax/_solver/foster_langevin_srk.py b/diffrax/_solver/foster_langevin_srk.py index 75be3304..0264b1a4 100644 --- a/diffrax/_solver/foster_langevin_srk.py +++ b/diffrax/_solver/foster_langevin_srk.py @@ -1,6 +1,6 @@ import abc from collections.abc import Callable -from typing import Any, Generic, TypeVar +from typing import Any, Generic, Optional, TypeVar import equinox as eqx import equinox.internal as eqxi @@ -9,7 +9,6 @@ import jax.numpy as jnp import jax.tree_util as jtu from equinox import AbstractVar -from jax import vmap from jaxtyping import PyTree from .._custom_types import ( @@ -22,19 +21,21 @@ from .._solution import RESULTS from .._term import ( AbstractTerm, + broadcast_underdamped_langevin_arg, MultiTerm, UnderdampedLangevinDiffusionTerm, UnderdampedLangevinDriftTerm, UnderdampedLangevinLeaf, + UnderdampedLangevinStructureError, UnderdampedLangevinTuple, UnderdampedLangevinX, WrapTerm, ) -from .base import AbstractItoSolver, AbstractStratonovichSolver +from .base import AbstractStratonovichSolver _ErrorEstimate = TypeVar("_ErrorEstimate", None, UnderdampedLangevinTuple) -ULDArgs = tuple[ +UnderdampedLangevinArgs = tuple[ UnderdampedLangevinX, UnderdampedLangevinX, Callable[[UnderdampedLangevinX], UnderdampedLangevinX], @@ -58,23 +59,6 @@ def _get_args_from_terms( return gamma, u, f -def _broadcast_pytree(source, target_tree): - # Broadcasts the source PyTree to the shape and PyTree structure of - # target_tree_shape. Requires that source is a prefix tree of target_tree - # This is used to case gamma and u to the shape of x0 and v0 - def _inner_broadcast(_src_arr, _inner_target_tree): - _arr = jnp.asarray(_src_arr) - - def fun(_leaf): - return jnp.asarray( - jnp.broadcast_to(_arr, _leaf.shape), dtype=jnp.result_type(_leaf) - ) - - return jtu.tree_map(fun, _inner_target_tree) - - return jtu.tree_map(_inner_broadcast, source, target_tree) - - # CONCERNING COEFFICIENTS: # The coefficients used in a step of this SRK depend on # the time increment h, and the parameter gamma. @@ -103,12 +87,11 @@ class SolverState(eqx.Module, Generic[_Coeffs]): taylor_coeffs: PyTree[_Coeffs, "UnderdampedLangevinX"] coeffs: _Coeffs rho: UnderdampedLangevinX - prev_f: UnderdampedLangevinX + prev_f: Optional[UnderdampedLangevinX] class AbstractFosterLangevinSRK( AbstractStratonovichSolver[SolverState], - AbstractItoSolver[SolverState], Generic[_Coeffs, _ErrorEstimate], ): r"""Abstract class for Stochastic Runge Kutta methods specifically designed @@ -124,10 +107,10 @@ class AbstractFosterLangevinSRK( and velocity, $w$ is a Brownian motion in $\mathbb{R}^d$, $f: \mathbb{R}^d \rightarrow \mathbb{R}$ is a potential function, and $\gamma , u \in \mathbb{R}^{d \times d}$ are diagonal matrices governing - the friction and the inertia of the system. + the friction and the damping of the system. Solvers which inherit from this class include [`diffrax.ALIGN`][], - [`diffrax.ShOULD`][], and [`diffrax.QUIC_SORT`][]. + [`diffrax.ShOULD`][], and [`diffrax.QUICSORT`][]. """ term_structure = MultiTerm[ @@ -136,6 +119,7 @@ class AbstractFosterLangevinSRK( interpolation_cls = LocalLinearInterpolation minimal_levy_area: eqx.AbstractClassVar[type[AbstractBrownianIncrement]] taylor_threshold: AbstractVar[RealScalarLike] + _is_fsal: eqx.AbstractClassVar[bool] @abc.abstractmethod def _directly_compute_coeffs_leaf( @@ -211,11 +195,7 @@ def recompute_coeffs_leaf(c: UnderdampedLangevinLeaf, _tay_coeffs: _Coeffs): cond = jnp.expand_dims(cond, axis=-1) def select_tay_or_direct(): - if jnp.ndim(c) == 0: - direct_out = self._directly_compute_coeffs_leaf(h, c) - else: - fun = lambda _c: self._directly_compute_coeffs_leaf(h, _c) - direct_out = vmap(fun)(c) + direct_out = self._directly_compute_coeffs_leaf(h, c) def _choose(tay_leaf, direct_leaf): assert tay_leaf.ndim == direct_leaf.ndim == cond.ndim, ( @@ -251,7 +231,7 @@ def _choose(tay_leaf, direct_leaf): tree_with_coeffs = jtu.tree_map(recompute_coeffs_leaf, gamma, tay_coeffs) outer = jtu.tree_structure(gamma) assert inner is not sentinel, "inner tree structure not set" - coeffs_with_tree = jtu.tree_transpose(outer, inner, tree_with_coeffs) # type: ignore + coeffs_with_tree = jtu.tree_transpose(outer, inner, tree_with_coeffs) # pyright: ignore return coeffs_with_tree def init( @@ -273,16 +253,19 @@ def init( h = drift.contr(t0, t1) x0, v0 = y0 - gamma = _broadcast_pytree(gamma, x0) - u = _broadcast_pytree(u, x0) - grad_f_shape = jax.eval_shape(grad_f, x0) + gamma = broadcast_underdamped_langevin_arg(gamma, x0, "gamma") + u = broadcast_underdamped_langevin_arg(u, x0, "u") + + try: + grad_f_shape = jax.eval_shape(grad_f, x0) + except ValueError: + raise UnderdampedLangevinStructureError("grad_f") def _shape_check_fun(_x, _g, _u, _fx): return _x.shape == _g.shape == _u.shape == _fx.shape - assert jtu.tree_all( - jtu.tree_map(_shape_check_fun, x0, gamma, u, grad_f_shape) - ), "The shapes of gamma, u, and grad_f(x0) must be the same as x0." + if not jtu.tree_all(jtu.tree_map(_shape_check_fun, x0, gamma, u, grad_f_shape)): + raise UnderdampedLangevinStructureError(None) tay_coeffs = jtu.tree_map(self._tay_coeffs_single, gamma) # tay_coeffs have the same tree structure as gamma, with each leaf being a @@ -291,6 +274,7 @@ def _shape_check_fun(_x, _g, _u, _fx): coeffs = self._recompute_coeffs(h, gamma, tay_coeffs) rho = jtu.tree_map(lambda c, _u: jnp.sqrt(2 * c * _u), gamma, u) + prev_f = grad_f(x0) if self._is_fsal else None state_out = SolverState( gamma=gamma, @@ -299,7 +283,7 @@ def _shape_check_fun(_x, _g, _u, _fx): taylor_coeffs=tay_coeffs, coeffs=coeffs, rho=rho, - prev_f=grad_f(x0), + prev_f=prev_f, ) return state_out @@ -311,16 +295,29 @@ def _compute_step( levy, x0: UnderdampedLangevinX, v0: UnderdampedLangevinX, - uld_args: ULDArgs, + uld_args: UnderdampedLangevinArgs, coeffs: _Coeffs, rho: UnderdampedLangevinX, - prev_f: UnderdampedLangevinX, + prev_f: Optional[UnderdampedLangevinX], ) -> tuple[ - UnderdampedLangevinX, UnderdampedLangevinX, UnderdampedLangevinX, _ErrorEstimate + UnderdampedLangevinX, + UnderdampedLangevinX, + Optional[UnderdampedLangevinX], + _ErrorEstimate, ]: - r"""This method specifies how to compute a single step of the ULD SRK - method. This holds just the computation that differs between the different - SRK methods. The common bits are handled by the `step` method.""" + r"""This method specifies how to compute a single step of the Underdamped + Langevin SRK method. + This holds just the computation that differs between the different + SRK methods. The common bits are handled by the `step` method. + + **Returns:** + + (x_out, v_out, f_fsal, error), where: + + - `x_out` and `v_out` are the new position and velocity. + - `f_fsal` is the new evaluation of the gradient of the potential function. + - `error` is the error estimate. + """ raise NotImplementedError def step( @@ -359,15 +356,19 @@ def step( # compute the Brownian increment and space-time(-time) Levy area levy = diffusion.contr(t0, t1, use_levy=True) - assert isinstance(levy, self.minimal_levy_area), ( - f"The Brownian motion must have" - f" `levy_area={self.minimal_levy_area.__name__}`" - ) + if not isinstance(levy, self.minimal_levy_area): + raise ValueError( + f"The Brownian motion must have" + f" `levy_area={self.minimal_levy_area.__name__}`" + ) x0, v0 = y0 - prev_f = lax.cond( - eqxi.unvmap_any(made_jump), lambda: grad_f(x0), lambda: st.prev_f - ) + if made_jump is False: + prev_f = st.prev_f + else: + prev_f = lax.cond( + eqxi.unvmap_any(made_jump), lambda: grad_f(x0), lambda: st.prev_f + ) # The actual step computation, handled by the subclass x_out, v_out, f_fsal, error = self._compute_step( @@ -384,7 +385,13 @@ def check_shapes_dtypes(_x, _v, _f, _x0): f" v_out: {_v.shape}, x_out: {_x.shape}, f_fsal: {_f.shape}" ) - jtu.tree_map(check_shapes_dtypes, x_out, v_out, f_fsal, x0) + # Some children classes may not use f_fsal, so we allow it to be None + if self._is_fsal: + _f_fsal = f_fsal + else: + assert f_fsal is None + _f_fsal = x0 + jtu.tree_map(check_shapes_dtypes, x_out, v_out, _f_fsal, x0) y1 = (x_out, v_out) diff --git a/diffrax/_solver/quicsort.py b/diffrax/_solver/quicsort.py index c2f83d61..303d2af2 100644 --- a/diffrax/_solver/quicsort.py +++ b/diffrax/_solver/quicsort.py @@ -1,4 +1,5 @@ import math +from typing import Optional import equinox as eqx import jax @@ -16,7 +17,7 @@ from .foster_langevin_srk import ( AbstractCoeffs, AbstractFosterLangevinSRK, - ULDArgs, + UnderdampedLangevinArgs, ) @@ -85,6 +86,7 @@ class QUICSORT(AbstractFosterLangevinSRK[_QUICSORTCoeffs, None]): interpolation_cls = LocalLinearInterpolation minimal_levy_area = AbstractSpaceTimeTimeLevyArea taylor_threshold: RealScalarLike = eqx.field(static=True) + _is_fsal = False def __init__(self, taylor_threshold: RealScalarLike = 0.1): r"""**Arguments:** @@ -107,12 +109,13 @@ def _directly_compute_coeffs_leaf( ) -> _QUICSORTCoeffs: del self # compute the coefficients directly (as opposed to via Taylor expansion) - original_shape = c.shape + original_shape = jnp.shape(c) c = jnp.expand_dims(c, axis=c.ndim) alpha = c * h l = 0.5 - math.sqrt(3) / 6 r = 0.5 + math.sqrt(3) / 6 l_r_1 = jnp.array([l, r, 1.0], dtype=jnp.result_type(c)) + l_r_1 = jnp.broadcast_to(l_r_1, original_shape + (3,)) alpha_lr1 = alpha * l_r_1 assert alpha_lr1.shape == original_shape + (3,) beta_lr1 = jnp.exp(-alpha_lr1) @@ -163,7 +166,7 @@ def _tay_coeffs_single(self, c: UnderdampedLangevinLeaf) -> _QUICSORTCoeffs: a_lr1 = lr1_pows * jnp.expand_dims(a, axis=c.ndim) # b needs an extra power of lr1 (just work out the expansion to see why) b_lr1 = lr1_pows * lr1 * jnp.expand_dims(b, axis=c.ndim) - assert beta_lr1.shape == a_lr1.shape == b_lr1.shape == c.shape + (3, 6) + assert beta_lr1.shape == a_lr1.shape == b_lr1.shape == jnp.shape(c) + (3, 6) # a_third = (1 - exp(-1/3 * gamma * h))/gamma a_third = jnp.stack( @@ -174,7 +177,7 @@ def _tay_coeffs_single(self, c: UnderdampedLangevinLeaf) -> _QUICSORTCoeffs: [-c5 / 720, c4 / 120, -c3 / 24, c2 / 6, -c / 2, one], axis=-1 ) a_div_h = jnp.expand_dims(a_div_h, axis=c.ndim) - assert a_third.shape == a_div_h.shape == c.shape + (1, 6) + assert a_third.shape == a_div_h.shape == jnp.shape(c) + (1, 6) return _QUICSORTCoeffs( beta_lr1=beta_lr1, @@ -190,11 +193,12 @@ def _compute_step( levy: AbstractSpaceTimeTimeLevyArea, x0: UnderdampedLangevinX, v0: UnderdampedLangevinX, - uld_args: ULDArgs, + uld_args: UnderdampedLangevinArgs, coeffs: _QUICSORTCoeffs, rho: UnderdampedLangevinX, - prev_f: UnderdampedLangevinX, + prev_f: Optional[UnderdampedLangevinX], ) -> tuple[UnderdampedLangevinX, UnderdampedLangevinX, UnderdampedLangevinX, None]: + del prev_f dtypes = jtu.tree_map(jnp.result_type, x0) w: UnderdampedLangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) hh: UnderdampedLangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) @@ -243,8 +247,5 @@ def _extract_coeffs(coeff, index): ).ω v_out = (v_out_tilde**ω - rho**ω * (hh**ω - 6 * kk**ω)).ω - # this method is not FSAL, but for compatibility with the base class we set - f_fsal = prev_f - # TODO: compute error estimate - return x_out, v_out, f_fsal, None + return x_out, v_out, None, None diff --git a/diffrax/_solver/should.py b/diffrax/_solver/should.py index 8143acdd..9955baf6 100644 --- a/diffrax/_solver/should.py +++ b/diffrax/_solver/should.py @@ -13,7 +13,7 @@ from .foster_langevin_srk import ( AbstractCoeffs, AbstractFosterLangevinSRK, - ULDArgs, + UnderdampedLangevinArgs, ) @@ -83,6 +83,7 @@ class ShOULD(AbstractFosterLangevinSRK[_ShOULDCoeffs, None]): interpolation_cls = LocalLinearInterpolation minimal_levy_area = AbstractSpaceTimeTimeLevyArea taylor_threshold: RealScalarLike = eqx.field(static=True) + _is_fsal = True def __init__(self, taylor_threshold: RealScalarLike = 0.1): r"""**Arguments:** @@ -160,7 +161,7 @@ def _tay_coeffs_single(self, c: UnderdampedLangevinLeaf) -> _ShOULDCoeffs: chh = jnp.stack([c4 / 168, -c3 / 30, 3 * c2 / 20, -c / 2, one, zero], axis=-1) ckk = jnp.stack([5 * c4 / 168, -c3 / 7, c2 / 2, -c, zero, zero], axis=-1) - correct_shape = c.shape + (6,) + correct_shape = jnp.shape(c) + (6,) assert ( beta_half.shape == a_half.shape @@ -192,7 +193,7 @@ def _compute_step( levy: AbstractSpaceTimeTimeLevyArea, x0: UnderdampedLangevinX, v0: UnderdampedLangevinX, - uld_args: ULDArgs, + uld_args: UnderdampedLangevinArgs, coeffs: _ShOULDCoeffs, rho: UnderdampedLangevinX, prev_f: UnderdampedLangevinX, diff --git a/diffrax/_term.py b/diffrax/_term.py index 71c22ca4..6be83043 100644 --- a/diffrax/_term.py +++ b/diffrax/_term.py @@ -798,11 +798,42 @@ def _to_vjp(_y, _diff_args, _diff_term): UnderdampedLangevinTuple = tuple[UnderdampedLangevinX, UnderdampedLangevinX] +class UnderdampedLangevinStructureError(Exception): + """Raised when the structure of the arguments in the Underdamped Langevin + terms is incorrect.""" + + # Without this, the ValueError would be caught in _integrate._term_compatible, + # which would then give a less informative error message. + def __init__(self, problematic_arg: Optional[str]): + if problematic_arg is None: + msg = ( + "If `x` is the position of the Underdamped Langevin diffusion," + " then the PyTree structures and shapes of `grad_f(x)` and of " + "the arguments `gamma` and `u` must be the same as the structure" + " and shapes of x." + ) + elif problematic_arg == "grad_f": + msg = ( + "The function `grad_f` in the Underdamped Langevin term must be" + " a callable, whose input and output have the same PyTree structure" + " and shapes as the position `x`." + ) + else: + msg = ( + f"If `x` is the position of the Underdamped Langevin diffusion," + f" then the PyTree structure and shapes of the argument" + f" `{problematic_arg}` must be the same as the structure and" + f" shapes of x." + ) + + super().__init__(msg) + + def _broadcast_pytree(source, target_tree): # Broadcasts the source PyTree to the shape and PyTree structure of # target_tree_shape. Requires that source is a prefix tree of target_tree - # This is used to case gamma and u to the shape of x0 and v0 - def _inner_broadcast(_src_arr, _inner_target_tree): + # This is used to broadcast gamma and u to the shape of x0 and v0 + def inner_broadcast(_src_arr, _inner_target_tree): _arr = jnp.asarray(_src_arr) def fun(_leaf): @@ -812,7 +843,17 @@ def fun(_leaf): return jtu.tree_map(fun, _inner_target_tree) - return jtu.tree_map(_inner_broadcast, source, target_tree) + return jtu.tree_map(inner_broadcast, source, target_tree) + + +def broadcast_underdamped_langevin_arg( + arg: PyTree[ArrayLike], x: UnderdampedLangevinX, arg_name: str +) -> UnderdampedLangevinX: + """Broadcasts the argument `arg` to the same structure as the position `x`.""" + try: + return _broadcast_pytree(arg, x) + except ValueError: + raise UnderdampedLangevinStructureError(arg_name) class UnderdampedLangevinDiffusionTerm( @@ -833,21 +874,41 @@ class UnderdampedLangevinDiffusionTerm( and velocity, $w$ is a Brownian motion in $\mathbb{R}^d$, $f: \mathbb{R}^d \rightarrow \mathbb{R}$ is a potential function, and $\gamma , u \in \mathbb{R}^{d \times d}$ are diagonal matrices governing - the friction and the inertia of the system. + the friction and the damping of the system. """ gamma: PyTree[ArrayLike] u: PyTree[ArrayLike] control: AbstractBrownianPath + def __init__( + self, + gamma: PyTree[ArrayLike], + u: PyTree[ArrayLike], + bm: AbstractBrownianPath, + ): + r""" + **Arguments:** + + - `gamma`: A vector containing the diagonal entries of the friction matrix; + a scalar or a PyTree of the same shape as the position vector $x$. + - `u`: A vector containing the diagonal entries of the damping matrix; + a scalar or a PyTree of the same shape as the position vector $x$. + - `bm`: A Brownian path representing the Brownian motion $w$. + """ + self.gamma = gamma + self.u = u + self.control = bm + def vf( self, t: RealScalarLike, y: UnderdampedLangevinTuple, args: Args ) -> UnderdampedLangevinX: x, v = y # gamma, u and v can all have different pytree structures, we only know that # gamma and u are prefixes of v - gamma = _broadcast_pytree(self.gamma, v) - u = _broadcast_pytree(self.u, v) + + gamma = broadcast_underdamped_langevin_arg(self.gamma, v, "gamma") + u = broadcast_underdamped_langevin_arg(self.u, v, "u") def _fun(_gamma, _u): return jnp.sqrt(2 * _gamma * _u) @@ -885,29 +946,53 @@ class UnderdampedLangevinDriftTerm(AbstractTerm): and velocity, $w$ is a Brownian motion in $\mathbb{R}^d$, $f: \mathbb{R}^d \rightarrow \mathbb{R}$ is a potential function, and $\gamma , u \in \mathbb{R}^{d \times d}$ are diagonal matrices governing - the friction and the inertia of the system. + the friction and the damping of the system. """ gamma: PyTree[ArrayLike] u: PyTree[ArrayLike] grad_f: Callable[[UnderdampedLangevinX], UnderdampedLangevinX] + def __init__( + self, + gamma: PyTree[ArrayLike], + u: PyTree[ArrayLike], + grad_f: Callable[[UnderdampedLangevinX], UnderdampedLangevinX], + ): + r""" + **Arguments:** + + - `gamma`: A vector containing the diagonal entries of the friction matrix; + a scalar or a PyTree of the same shape as the position vector $x$. + - `u`: A vector containing the diagonal entries of the damping matrix; + a scalar or a PyTree of the same shape as the position vector $x$. + - `grad_f`: A callable representing the gradient of the potential function $f$. + This callable should take a PyTree of the same shape as $x$ and + return a PyTree of the same shape. + """ + self.gamma = gamma + self.u = u + self.grad_f = grad_f + def vf( self, t: RealScalarLike, y: UnderdampedLangevinTuple, args: Args ) -> UnderdampedLangevinTuple: x, v = y # gamma, u and v can all have different pytree structures, we only know that # gamma and u are prefixes of v (which is the same as x) - gamma = _broadcast_pytree(self.gamma, v) - u = _broadcast_pytree(self.u, v) - f_x = self.grad_f(x) - vf_x = v + gamma = broadcast_underdamped_langevin_arg(self.gamma, v, "gamma") + u = broadcast_underdamped_langevin_arg(self.u, v, "u") def fun(_gamma, _u, _v, _f_x): return -_gamma * _v - _u * _f_x - vf_v = jtu.tree_map(fun, gamma, u, v, f_x) + vf_x = v + try: + f_x = self.grad_f(x) + vf_v = jtu.tree_map(fun, gamma, u, v, f_x) + except ValueError: + raise UnderdampedLangevinStructureError("grad_f") vf_y = (vf_x, vf_v) return vf_y @@ -938,13 +1023,13 @@ def make_underdamped_langevin_term( and velocity, $w$ is a Brownian motion in $\mathbb{R}^d$, $f: \mathbb{R}^d \rightarrow \mathbb{R}$ is a potential function, and $\gamma , u \in \mathbb{R}^{d \times d}$ are diagonal matrices governing - the friction and the inertia of the system. + the friction and the damping of the system. **Arguments:** - `gamma`: A vector containing the diagonal entries of the friction matrix; a scalar or a PyTree of the same shape as the position vector $x$. - - `u`: A vector containing the diagonal entries of the dampening matrix; + - `u`: A vector containing the diagonal entries of the damping matrix; a scalar or a PyTree of the same shape as the position vector $x$. - `grad_f`: A callable representing the gradient of the potential function $f$. This callable should take a PyTree of the same shape as $x$ and @@ -953,7 +1038,8 @@ def make_underdamped_langevin_term( **Returns:** - A `MultiTerm` representing the Underdamped Langevin SDE. + `MultiTerm(UnderdampedLangevinDriftTerm(gamma, u, grad_f), + UnderdampedLangevinDiffusionTerm(gamma, u, bm))` """ # In practice we don't require the PyTree structure of gamma and u to be the same # as x and v. We only require that they are prefixes of x and v, in a way that diff --git a/docs/api/solvers/abstract_solvers.md b/docs/api/solvers/abstract_solvers.md index 1dbbb54b..65c99b99 100644 --- a/docs/api/solvers/abstract_solvers.md +++ b/docs/api/solvers/abstract_solvers.md @@ -96,4 +96,8 @@ In addition [`diffrax.AbstractSolver`][] has several subclasses that you can use ::: diffrax.StochasticButcherTableau selection: members: - - __init__ \ No newline at end of file + - __init__ + +::: diffrax.AbstractFosterLangevinSRK + selection: + members: false \ No newline at end of file diff --git a/docs/api/solvers/sde_solvers.md b/docs/api/solvers/sde_solvers.md index bf7bd48b..a1a87b74 100644 --- a/docs/api/solvers/sde_solvers.md +++ b/docs/api/solvers/sde_solvers.md @@ -132,11 +132,11 @@ where $x(t), v(t) \in \mathbb{R}^d$ represent the position and velocity, $w$ is a Brownian motion in $\mathbb{R}^d$, $f: \mathbb{R}^d \rightarrow \mathbb{R}$ is a potential function, and $\gamma , u \in \mathbb{R}^{d \times d}$ are diagonal matrices governing -the friction and the inertia of the system. +the friction and the damping of the system. They are more precise for this diffusion than the general-purpose solvers above, but -cannot be used for any other SDEs. They only accept terms generated by the -[`diffrax.make_underdamped_langevin_term`][] function. +cannot be used for any other SDEs. They only accept special terms as described in the +[Underdamped Langevin terms](../terms.md#underdamped-langevin-terms) section. For an example of their usage, see the [Underdamped Langevin example](../../examples/underdamped_langevin_example.ipynb). ::: diffrax.ALIGN diff --git a/docs/api/terms.md b/docs/api/terms.md index 6672d82f..aff1f5a3 100644 --- a/docs/api/terms.md +++ b/docs/api/terms.md @@ -92,4 +92,40 @@ Some example term structures include: members: - __init__ + +--- + +#### Underdamped Langevin terms + +These are special terms which describe the Underdamped Langevin diffusion (ULD), +which takes the form + +\begin{align*} + \mathrm{d} x(t) &= v(t) \, \mathrm{d}t \\ + \mathrm{d} v(t) &= - \gamma \, v(t) \, \mathrm{d}t - u \, + \nabla \! f( x(t) ) \, \mathrm{d}t + \sqrt{2 \gamma u} \, \mathrm{d} w(t), +\end{align*} + +where $x(t), v(t) \in \mathbb{R}^d$ represent the position +and velocity, $w$ is a Brownian motion in $\mathbb{R}^d$, +$f: \mathbb{R}^d \rightarrow \mathbb{R}$ is a potential function, and +$\gamma , u \in \mathbb{R}^{d \times d}$ are diagonal matrices governing +the friction and the damping of the system. + +These terms enable the use of ULD-specific solvers which can be found +[here](./solvers/sde_solvers.md#underdamped-langevin-solvers). Note that these ULD solvers will only work if given +terms with structure `MultiTerm(UnderdampedLangevinDriftTerm(gamma, u, grad_f), UnderdampedLangevinDiffusionTerm(gamma, u, bm))`, +where `bm` is an [`diffrax.AbstractBrownianPath`][] and the same values of `gammma` and `u` are passed to both terms. It is recommended to +use the helper function [`diffrax.make_underdamped_langevin_term`][], which will ensure that the terms are structured correctly. + +::: diffrax.UnderdampedLangevinDriftTerm + selection: + members: + - __init__ + +::: diffrax.UnderdampedLangevinDiffusionTerm + selection: + members: + - __init__ + ::: diffrax.make_underdamped_langevin_term \ No newline at end of file diff --git a/docs/devdocs/srk_example.ipynb b/docs/devdocs/srk_example.ipynb index b3ed16db..39364def 100644 --- a/docs/devdocs/srk_example.ipynb +++ b/docs/devdocs/srk_example.ipynb @@ -38,12 +38,20 @@ "id": "initial_id", "metadata": { "ExecuteTime": { - "end_time": "2024-05-21T16:52:30.728542Z", - "start_time": "2024-05-21T16:52:28.959147Z" + "end_time": "2024-09-01T12:42:23.369354Z", + "start_time": "2024-09-01T12:42:19.091025Z" }, "collapsed": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "env: JAX_PLATFORM_NAME=cuda\n" + ] + } + ], "source": [ "%env JAX_PLATFORM_NAME=cuda\n", "\n", @@ -52,6 +60,7 @@ " get_time_sde,\n", " simple_sde_order,\n", ")\n", + "from warnings import simplefilter\n", "\n", "import diffrax\n", "import jax.numpy as jnp\n", @@ -69,6 +78,7 @@ "from jax import config\n", "\n", "\n", + "simplefilter(\"ignore\", category=FutureWarning)\n", "config.update(\"jax_enable_x64\", True)\n", "jnp.set_printoptions(precision=4, suppress=True)\n", "\n", @@ -130,6 +140,7 @@ "t_short = 4.0\n", "t_long = 32.0\n", "save_at_solver_steps = diffrax.SaveAt(steps=True)\n", + "levy_area = SpaceTimeLevyArea\n", "\n", "\n", "def constant_step_strong_order(keys, sde, solver, levels, bm_tol=None):\n", @@ -143,7 +154,16 @@ " if bm_tol is None:\n", " bm_tol = (sde.t1 - sde.t0) * (2 ** -(levels[1] + 5))\n", " return simple_sde_order(\n", - " keys, sde, solver, solver, levels, get_controller, _saveat, bm_tol\n", + " keys,\n", + " sde,\n", + " solver,\n", + " solver,\n", + " levels,\n", + " get_controller,\n", + " _saveat,\n", + " bm_tol,\n", + " levy_area,\n", + " ref_solution=None,\n", " )\n", "\n", "\n", @@ -151,21 +171,27 @@ " save_ts_pid = jnp.linspace(sde.t0, sde.t1, 65, endpoint=True)\n", "\n", " def get_pid(level):\n", - " pid = diffrax.PIDController(\n", + " return diffrax.PIDController(\n", " pcoeff=0.1,\n", " icoeff=0.3,\n", " rtol=2 ** -(level - 1),\n", " atol=2 ** -(level + 3),\n", " dtmin=2**-14,\n", - " )\n", - " return diffrax.JumpStepWrapper(\n", - " pid,\n", " step_ts=save_ts_pid,\n", " )\n", "\n", " saveat_pid = diffrax.SaveAt(ts=save_ts_pid)\n", " return simple_sde_order(\n", - " keys, sde, solver, solver, levels, get_pid, saveat_pid, bm_tol\n", + " keys,\n", + " sde,\n", + " solver,\n", + " solver,\n", + " levels,\n", + " get_pid,\n", + " saveat_pid,\n", + " bm_tol,\n", + " levy_area,\n", + " ref_solution=None,\n", " )\n", "\n", "\n", @@ -190,16 +216,27 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "id": "3b0a11dc7bb9f9bc", "metadata": { "ExecuteTime": { - "end_time": "2024-04-02T15:04:57.426134Z", - "start_time": "2024-04-02T15:04:56.415910Z" + "end_time": "2024-09-01T12:42:26.644732Z", + "start_time": "2024-09-01T12:42:23.374494Z" }, "collapsed": false }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# A plot of the solution of the SDE used to compare the methods\n", "sol_general = diffeqsolve(\n", @@ -286,12 +323,12 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "id": "5a8d281b0522bb92", "metadata": { "ExecuteTime": { - "end_time": "2024-04-02T15:06:25.955243Z", - "start_time": "2024-04-02T15:04:57.426878Z" + "end_time": "2024-09-01T12:44:19.717452Z", + "start_time": "2024-09-01T12:42:26.711388Z" }, "collapsed": false }, @@ -312,16 +349,27 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "id": "5beb86506adfa933", "metadata": { "ExecuteTime": { - "end_time": "2024-04-02T15:06:26.185839Z", - "start_time": "2024-04-02T15:06:25.956242Z" + "end_time": "2024-09-01T12:44:19.934834Z", + "start_time": "2024-09-01T12:44:19.762547Z" }, "collapsed": false }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "draw_order_multiple(\n", " [out_SLOWRK_mlp_sde, out_SPaRK_mlp_sde, out_GenShARK_mlp_sde],\n", @@ -342,16 +390,27 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "id": "4c72a44488366e9d", "metadata": { "ExecuteTime": { - "end_time": "2024-04-02T15:06:28.473708Z", - "start_time": "2024-04-02T15:06:26.187052Z" + "end_time": "2024-09-01T12:44:23.182726Z", + "start_time": "2024-09-01T12:44:19.952467Z" }, "collapsed": false }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAGeCAYAAACpVGq5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAChDklEQVR4nOzddXhU19bA4d9M3D0hIQnu7u6UUiilRo0K1Fvqt+1Xt9te6re3rrTU3WgLLYWipbi7BUJC3D2Zme+PPZqZhMhMMknW+zx55tics4NkVvZee22NwWAwIIQQQgjRDLTN3QAhhBBCtF0SiAghhBCi2UggIoQQQohmI4GIEEIIIZqNBCJCCCGEaDYSiAghhBCi2UggIoQQQohmI4GIEEIIIZqNBCJCCCGEaDaezd2A2uj1elJTUwkKCkKj0TR3c4QQQghRBwaDgcLCQuLi4tBqa+/zcFkgotPpeOKJJ/j0009JS0sjLi6OefPm8cgjj9Q5qEhNTSUhIcFVTRRCCCGECyUnJxMfH1/rNS4LRJ577jneeustFi9eTJ8+fdiyZQvz588nJCSEO+64o073CAoKAtQ3Ehwc7KqmCiGEEMKJCgoKSEhIMH+O18Zlgcjff//N7NmzmTlzJgAdO3bkiy++YNOmTXW+h6nnJDg4WAIRIYQQooWpywiIy5JVR48ezYoVKzh06BAAO3fuZN26dZxzzjk1vqe8vJyCggKbLyGEEEK0Xi7rEXnggQcoKCigZ8+eeHh4oNPpeOaZZ5g7d26N71m4cCFPPvmkq5okhBBCCDfjsh6Rr7/+ms8++4zPP/+cbdu2sXjxYl588UUWL15c43sefPBB8vPzzV/Jycmuap4QQggh3IDGYDAYXHHjhIQEHnjgARYsWGA+9vTTT/Ppp59y4MCBOt2joKCAkJAQ8vPzJUdECCGEaCHq8/ntsh6RkpISu7nDHh4e6PV6Vz1SCCGEEC2My3JEZs2axTPPPENiYiJ9+vRh+/btvPzyy1x77bWueqQQQgghWhiXDc0UFhby6KOP8sMPP5CRkUFcXByXX345jz32GN7e3nW6hwzNCCGEEC1PfT6/XRaIOIMEIkIIIUTL4xY5IkIIIYQQZyKBiBBCCCGajQQiQgghhGg2EogIIYQQotlIICKEEKLVSs0r5Y2/jpBXUtHcTRE1cFkdESGEEKK5Xb94C/tOF3A0o4iXLx3Y3M0RDkiPiBBCiFZr32m1ivsvu083c0tETSQQEUII0Srp9JYyWT6e8nHnruRvRgghRKt0PKvIvK3TG3Dj+p1tmgQiQgghWqUdyfnm7ZIKHZlF5c3YGlETCUSEEEK0OhmFZdz7zU6bY0lZJc3UGlEbCUSEEEK0OuuPZJm3vY35IdZDNcJ9SCAihBCi1TmVUwrA4MRQrhieCMCxzOLmbJKogQQiQgghWqQ9Kfk8+P0uMgvtcz+Sc9UwzMQe0fRsFwTA1hO5Tdo+UTdS0EwIIYTLVOr0vLbiMEezinns3N7EBPs65b5llTrOfW0dAD6eHjxxXh+b86dyVY9IfJgfwzqGA7A9OY+CskqCfb2c0gbhHNIjIoQQwiWyi8p5468jvLryCL/uOs1Xm5Oddu9/jmWbt/86mIHBYOCrzSfZeiIHsA5E/EkI9yc2xBed3sDhdMkTcTfSIyKEEMLpft11mgWfb7M5djijcUGAXm/gWFYRXaIC2ZGcZz5+IruEP/al83/f7QZgSs9oUvNUIJIQ7gdATLAvp/PLyJIpvG5HAhEhhBBOVz0IATjSyEDkxT8O8uaqo/zf9J42gQjAJxtOmLdXHMgAwMtDQ3SQGgqKCvIBcJhPIpqXBCJCCCGc6i9jIFDdscwiTueXEhPki1arqfd931x1FIDnlh0g1N82z2Od1XRdk7hQPzyMz5FAxH1JjogQQgin+nqL41yQ8io9oxau5Jnf9jf6GXkllXh7ahnVOcLm+KwBcebt+DA/83ZUoApE/tiXLqXe3YwEIkIIIZzqYFqhzb5WA12jA837H29Icspz+sYF2+R8TOsdw9Re0VbnQ8zbph6R/acL2HZSpvG6EwlEhBBCOE1ZpY6kbNvCYSF+XszoF2ve7xAR0KB7+3rZfmQNTAjjmtEdAQj19+L5i/szqaclELlwcLzVtaHm7X2pBQ16vnANyRERQgjhNEnZxeirjXyE+Xtzw7hOnM4r5Zutpygsq2zQvQN9vCirtPSA9GgXyIWD4+kcFcCwjuF4eahA5YsbRlJcXkUPYyEzgL7tQ7hocDzfbTvF4YwiSit0+Hl7NKgdwrmkR0QIIYTTnM4vA6BDhL/5mI+XB0G+XtwxpRug8jsawt8qcPDUapjWux1eHlpGd4k0ByEAo7pEMLV3jN37e8cFA/DxhhNMe2U12TKV1y1IICKEELU4klHI2sOZzd2MFiPdGIh0jrQMv7QPVVNowwK8AZW0Wlapq/e9K6r0APx7dh+O/GeG+X51ZZ28mpxTyvvrjte7DcL5JBARQohqTmQXs/jvJMoqdVzx3kau+mAT39QwE0TYMvWItAuxfOgP6aBKrAd4e+BpnE7bkF6R4ooqAMZ0jWxQ23paDdWAfVKtaB6SIyKEENVMeGEVAGsPZ5JhrDtx37e7SM0ro2/7YN746wgA14/rbJOEKSC9wBiIBPsyf0xHtp7I5apRHQDQaDSE+nuRVVRBXmkFTy7Zy+n8Mj65bjhp+WV8vOEEt03uarMezdHMIm7+ZCuFZVUUlqlAJMCnYR9dHSICuHZMJxatVz0hKw9k8PWWZOYMiUejqX9dE+EcEogIIYRRaYWOWz/bat7/c79tYa7//nnIZv8/v+13i0Dkz33pfPLPCV64uD/RTlpUriFeXXGYL43rycSG+HLn1G5214T4qUAkJbeUpXvSAHjpj0OsPJDByZwSjmUV8dn1I83XrzucZVca3r8RSaaPntuLi4fEM+PVtQDc/+0uvD20nD+ofYPvKRpHhmaEEAIwGAxMfXk1fx2sez7IqdxSc66DTm8w9wY0tes/3sLqQ5k8/WvjC4U1xsvLLYGaKTG0OlM9jz0plim0H/2dxMmcEgDWH8m2ub6ovMruHv7eDf8dWqPR0LNdEN6elo+/JTtTG3w/0XgSiAghBFBQVkWKcaG06jpF2ta98PHUEmgcHkg2foDe8/UORvxnBVuSclzbUKOSiipKKmw/pI9lNd/KspU6vc1+j2r5GCaxxtyRXafyaryXdeVT03CMNY8GlIe3ptVqiLRKdD2SKSvyNicJRIQQAsyrtToyODHMZj8y0MccnFzx/kaOZxXz0w71W7VpPRRXKq3QMeGFVZz9yhqbyqLllfpa3uVa1mu4TO0VYzOd1pop/2Pnqfwa7/XFpmTz1NpiY4/I1F4x9I4N5pKh8TW+rz6sa4icyC5BV734iWgyEogIIQRwOt82EOkdaxlasC5PDhAZ6M3UXqpORWZhuc3aKtV7Blxh3+l8MgvLSc4pZejTfzrl2dlF5Y36ME6zGpZ65bKBNV4XG6ICEVMANbN/LE/M6m1zzUM/7Gbaf9dQWFZpHpoZ3imM3+4cx/MXD2hwG61V71XZcDS7hiuFq0kgIoQQQGqebX7Hb3eOY/nd4/nj7vF2v4UH+Xpx++Su5rLhOUUV5nNVOtf/Zr3vtONpp/ml9Z8Sm1FYxnUfbWbI03/ywHe76v3+Q+mFLFy6n6PGhNKhHcLMw1aOtAuxTaaNDvLhkmEJjK02JTe7uIJBTy1n6wm1Lkygj+1qu42lrTZL5sEf6v+9C+eQQEQIIcBhfki3mCC6xwQREejD3ifPNh+vqNKj1Wq4aLCaaZGcW2I+1xQ9IgdOO14rJa+0Er2DXo2KKr1dj4/JO6uPseKAmh30zdZTDpNDa3PRW3/zzupj3Pet+iBPtKqo6sjQDrbDXH3jQvD39uTT60fw30ttezuq9AZzEmuAj3PLsVefrpucU2oumCaalgQiQggBHDpDcasAH08+mj+MhHA/bpnUBYAQf5XweNQq2TG3pMLh+50pvcBxaXKDAYqqJbCm5JUyauEKRi1cyd7UfJtAxWAwsMw4hdZk8/H6JdtWTyY9p2/t05kjAn345Lrh5v3x3aPM2+f2j6NHjOMk1yBf51absE5hMQ3T5BS7/u9O2JNARAjRZry24jBXfbCR8ir78uL7rXoZ3pw72OH7J/aIZu39k5nUQ63wGuqnhgusA4OaggRnqr5o3N1Tu5unoxZYDc9U6fSMe24l2cYP2JmvruOCN9ebc0FySyrNPUGDE0OB+g3vVP9z9PbQMr77maueju4SyVUjO3Df2T3M03kBvDy0fHfraLY8MpXbJnW1eY+zh2ZirSq/hhtn0Nz+xTabfweiaUggIoRoE55deoCXlh9i7eEsVlQrVJZfUkmqsTT5riem1blIWai//YdjUXlVvYc36qt6L0RMsA/BvqotBaXqXFp+GQs+32a3Eu7OU/n8vlf1gpjqnoQHeBMZqAKC4oq6t/1kdonNfoVOj4/nmYdQPLQa/n1+XxZUCzYAAn08iQz0sesBcfbQzBPn9WFEp3DevnKI+XvfnJTL3Pc3OvU54swkEBFCtHoFZZW8vdoyrbb67JD0QvWBHObvZf5Ar4tQP8eLrqXlu7awWWG5ba9FZKAPwcYP7hmvrqWsUsftX2zj973pDt+/yTj8YprpEhPsay6bbpouq9cbeHPVEfO11X2x6STXLNpkc+ymCZ0b+B3ZC6r291BbAmxDtA/146ubRjG9bzsiAy1/jzI80/SkxLsQotUzFR0zKag2tJFtnPVS39VcQ6r1iPh7e1BSoSMtv8xuyq8zFVXrEfH18qDcKtHy/m93sTkpt8b3m4ZqMszrwviYexyKy9Vwy/fbU3h+2UEAkp6daX7v15uTub/a7JoZ/dpxVu8YpvVu19BvyU6wn+3HU01BnzOYekRE85AeESFEq3cq13bGiPV025ziCtYeVmXdI+oZiARV+y29l7H2yJUfbCSjsIzrF29m8d9JDWhxzQwGg3loxt/bAy8PDQMSQsi0Kmz28xlKlpuKhW07kQcYe0SMZdNN1Vr3pFgKjpl6CY5mFtkFIQB94kK4YFB8gxejc8S6R8RDq3F6sqo161V5/bycOwQkzkx6RIQQrdarKw6z8kCGObnU5KXlh/hpZypHM4uwqiZOmH/9AhFttaJY3WOCzHUvpry0msKyKv7cn8E1ozs2qP2OlFXqqTIOLa29fxJenlqCfL1qnXp61cgOfPLPCfN+dlEFOcUVfLXFtECdJXGzuEL1iBzPKjYf23kqj0k9oknJdTwFuHO1EvjOEGwVeIT6edn9WTvTvDEd+XjDCVLySm2SZ0XTkB4RIUSrVFap4+Xlh9iRnMf7a48B4OVh+TA7kmEbhABEBNa/+9/6nrdP7mr+zd3RGinOsPqQ6r3RalSSqSmnpaZpr89d1I8bx6vcDVOeRXZxubk+B8ClwxLMQzO7TuUx/ZU15ucA7EzOo6JKzyM/7nH4jPiw2muHNIR1j4ijpGBn8vH04P1rhgLYrd8jXE8CESFEq7TZavG5QmMCZtdoxx/WJsF+9f/A87Xqyo8L9eOlOc4pQe7Ikp2p3PzpVkAFFdZFud66cjBXj+rA5J62vT/ju0eREO7Ppoen8Pvd4wE11GKqd9KzXRDtQizJqntSCjhQrabKzuQ8Pt94why8nNU7xuZ89WqpzmAdfFivC+MqpiDNVQGkqJkEIkKIVmmXg0XV/nVWd4Z0CGPe6I6EOAo6GlCd3VTm3SQ62P5DuaEVO3/fm8bCpfvNRche+uOg+Vz1oKlzVCBPze5r1x5Tkmd0kC8xQT5oNKA3wLFMNfRi+nPwd/Bh/8YVqp7K+iPZ/Lr7tPl4XIgvswbEmffrm1tTF9b3dPUsJLAEIuVVeqqaoDqusJAcESFEq3Q43b5S6pAOYXx3y2gA7pjSjcH/Xg6oD+HEcH/mjuhQ7+c8f3F/nv51P/ONeSAxwfY5BsXlVXh71v/D+qZPVO/HwPhQzukXS5ZVkm37UD+H74m2ynHw9tTi62X5fdPTQ0v36CAOphfymTFnxBSIWE+P1Whg+6NnEeTrxeDEULadzLOZhWMAyistxcxckb9h3dtj/X27inWibXG5jhB/+T29qciftBCiVTqcUWSz3zkywGZ6bphV1/8rlw5k2V3jz7hOiiOxIX68ccVghnYMB9RU0GrLmNSrSJiJda5CSl4pOr3B5lhcDYGI9fEwfy+7NVXGGBeXO2ZMRg0294hYPoh7xAQR6u+Nh1bD8xf3t3tGfmklEU0w5fWes7oD8NCMni5/lrenFm9j3ffqZfKFa0mPiBCi1TEYDOahB5PHz+tjs6/RaHhz7mCSc0rsch4aw8tDS0SAt81v8abaHPVxwqpqaUFpJbklFeYqqSF+XuYP6ep6WE1F7RBhP5vloiHtWbT+uHnf1CMSH2YJYKyHd7pGBxHq70VeiaX2yiVDE+gWE8ip3BIuH55Yv2+sHhZM6sr0vu3oGuW6mizWAnw8qCjRm4u6iaYhPSJCiFanoKyK0krbD//qy8wDzOgXy00Tutj1GjRWdJBtnkhDSr4fserRSc4tJctY+yM8wJudj08jIdxx74310IyjvI8+cSF8eeNIu+MJ4f48eE5PooJ87IIL64Jfr18xiDFdI4kO8uWT60bUuRx+Q3hoNXSPCXLp1F1rph6zzELXrxckLCQQEUK0OpnGku0+nlpm9o/lhYv7m1dYbQrR1fJEGvIb9scbkszbS/ec5qBxJsuZEkM1Gg0J4ap3Y/bAOIfXjOwcYd7OtiqEdtOELmx+eCoDqiW8Whf5ql6TpTXpYux5sQ4CP9t4gsve3VCvxQBF/bg0EElJSeHKK68kIiICPz8/+vXrx5YtW1z5SCGEIMO4Am5CuD9vXDGYOUMTmvT53h62P1q/3HyyXr0iZZU6m+TQsko9d365A6hbOfKvbxrFu1cN4fyB7Wu8xtQJVH2WjSPWs36cWT3V3ZjK8h/OsCQ6P/zDHv45lsN7a441V7NaPZf9i8rNzWXMmDFMmjSJpUuXEhUVxeHDhwkLC3PVI4UQAoAMY9d6dDNVyayqtqjeb7vT8PX04OVLB9bp/aahAV8vLXNHdOCDdfY5HbWJDfGzqZbqyMp/TWTd4UwuHXbmHI/yqvrnuLRE3YyByME0+xlXppWKhfO5LBB57rnnSEhI4MMPPzQf69Spk6seJ4QQZqYPjeYKRBytV/L99pQ6ByKmQCoqyMc8XGAyo79zcjI6RQbQqY6l2RMjAkjKLjnzhS2cqXdoZ3I+pRU6m6nPFVJbxGVcNjTz888/M3ToUObMmUN0dDSDBg3ivffeq/U95eXlFBQU2HwJIUR9peSpNVHanaFXwFX+Na070UE+NgFJffJhTTkuUYE+5nwPgM0PT+W8AY7zPlzpmfP7MrFHFJ9fP6LJn92UOkUG0C7Ylwqdnm0nc20SnhtalE6cmcsCkWPHjvHWW2/RrVs3fv/9d2655RbuuOMOFi9eXON7Fi5cSEhIiPkrIaFpx3WFEK2DqWu9e0zTTPusrnNUIBsfmsKzF/UzH6u+Um9tMq16RIZ3CmdSjyhuGt+52RZkSwj356P5wxntYOZRa6LRaOgVq6Y/n8otIddqynJDZj6JunHZ0Ixer2fo0KH85z//AWDQoEHs2bOHt99+m2uuucbhex588EHuuece835BQYEEI0KIejEYDBxKNwUita8t40oajYZEqym21ou41WbNoUwe/WkvoAIRH08PPpw/3CVtFPZMKzDnllSSV2KpBWNKgBbO57IekdjYWHr37m1zrFevXpw8ebLG9/j4+BAcHGzzJYQQ9ZFeUE5uSSVajWUWRHPp1z7EXDq9Sl9z135yTgn3fLWDA2kF3PP1DvPxmlbUFa4TagxEnl16gKd/2W8+nl4oyaqu4rJAZMyYMRw8eNDm2KFDh+jQof5rOQghRF3tSFbTXrvHBNmsjNscPD20LL1zHIBNZVJQPTcmr688wvfbU5j+ylqbiqwXDI5vmoYKM+vS/xuOZZu380oqKatsG7OHmprLApG7776bf/75h//85z8cOXKEzz//nHfffZcFCxa46pFCCMH25DwABiW6R6kA03L25VV68wfZygPpDH36T77fdgqA7GL7Rd1+v2u8zUJ0ommE1lIwTiquuobLApFhw4bxww8/8MUXX9C3b1/+/e9/88orrzB37lxXPVIIIdh+Mg+AQYmhzdoOk0AfTzyNVV1P55cx/vm/uPajLWQXV/D+WlUfxLp3BCA2xNdmzRjRdKx7RC4fnsD1YzvRLliV7M9owPDMpuM5/HUgw2nta41cGm6fe+65nHvuua58hBBCmFXp9Ow+lQ/AoDpUDG0KGo2GuFA/TuaUsPJABidzLPU4gv3Uj+DqPSJ3TunWpG0UFp5ay+/nD83oRZCvFzuS80grKCO9WsJqpU7Pr7tOM6lHNCH+Xqw/koW3p5ZhxpWYy6t0XPLOBgB2PHaWOf9E2JJ+PyFEq3Eks4jSSh1BPp52hcCaU8fIAE7mlLDtRK7N8dIKNVSTYwxEPr9+BJ2iAs5YFVW4jvUqxKaZTrGhfnAi12YNmq+3JPP5xpPsSM7jrN4x/OeCfsx9fyMAR545B08PLYfTLdcXlFZJIFIDWfROCNFqZBsTPeNC/Zpsxda66BihpvFuNQYi3p7qR29BWRVllTpzL0m7EF8JQppZ3/Yh/O+ygfy4YIz52MjOqodj1UE1xLL1RC73f7uLHcZ8pOX70tl/2lKA09TDtS/VcqykUuqQ1EQCESFEq2EqOhXg07yzZarrEKFKqacZS893NpZWLyit5JlfLVNEI+qwoJ1wvdkD29ssBmhacXjbyTx2JOex8Xi23XuuXrTJvG2qOWKqZwNQUiEzbmoiQzNCiFajqEwFIoF1LB7WVKrXA+kYEcCBtELySyvZZ/WbdLCv/Eh2R3GhfgT7elJQVsX5b6xnep92tV7/+l+HSQz3JzW/1HysTAKRGsm/eiFEq2HqEalPOfWmYCobbtLR2CNSpTeYh2u+v3U0mvosSCOaVLeYIPPf1bK9abVe+/vedLtj0iNSMxmaEUK0Gu46NBMR6ENMsGXYxXohOxN3Sq4V9h6f1bvGc/ed3YNu0YFM6B5V4zUlUgytRhKICCFaDVMgEujjXkMzgE3OQd+4EEL8bNtYfV+4l/7xocwb3dHhuQWTurL8ngkM6VBzEb3SCkuyql5v4FhmET9sP2VXQ6Ytcq/+SyGEaARLjoj7/Wgb2TnC3GXfr30I14zqwJrDWQT6eHLFiMRmbp2oiy5RAbWeH9stkpeXHwLUTKmkbEvNGNPQzIaj2Vz70WZKjT0kfl4eTO8b66IWtwzu979VCCEaqNjcI+JeQzMAc0d0IC2/jNFdI9FqNdwzrQf3TOvR3M0S9TCjX6x5ZWST7jGWIbWB8aF0jgogq7Cc2QPb878Vh83nTIHIh+uPm4MQgDWHs+oUiKTklVJQWkmv2Na3GKwEIkKIFu9oZhFPLdnHrlN5gHsOzXh7anlwRq/mboZohIhAH96/eig7kvOY1DOat1Yd4YFzLH+nWq2GH24ZQ4VObzfF11S8LjrYdor2UasiaTVJLyhj+itrKK/Us/r+ia2u1owEIkKIFu/2z7fbTIN1x6EZ0TpM7R3D1N4xALx/zTC78yHGtWoGV1t00dQjUlqhByA8wJuc4gqbaq2OVOr0XPjm3xQahx03Hc9h9sD2jfsm3IwkqwohWjzrIAQgSAIR0cziQv1YcttYLhysgoZSY2XVovJKAK4d0xFQVVjLaplRcyK7hJQ8Sz0S06KOrYkEIkKIVic2xLe5myAE/eJD6G3M6TD1iJh6NhLC/fH1Uh/Bp3JL+HLTSU5bFUAzScoqttk3DT+2JvJrgxCiRdPp7ac/xga3rjF00XKZFrozLWxoLrrn60lciB/Hsoq5/9tdbDuZR7/2ISy5fSwAf+5LZ1dKPj9sPwVAt+hADmcUcTCtEL3e4FZrKTWWBCJCiBYtr6TC7liwn/xoE+4hKkglp2YVVZCcU0KycYHDQB8vYkN9OZZVzDbjcMvulHwAKqr0XP/xFpv7TO4ZzYmcEoordCTnlpjXL2oNZGhGCNGimbq6rUmpdOEuIgNVj8j+0wVMfXk1uSUqRyTQR/WIOLJkZ6rdsXP7x5mn7q7Yn+Gi1jYPCUSEEC1a9UBkcs/oZmqJEPZMPSIA5VV683aQryexofaByNdbknn61302xw4/cw794kOYMyQegG+3nnJRa5uH9F8KIVq0wjL1G2bX6EDumtqNQYk1l9kWoqmF+3uj0UD1Su4qR8Q+qfr+b3fZ7PdrH4KXh+ozGNctElB1c1pTnogEIkKIFq3AGIiE+Hlxbv+4Zm6NELY8PbREBHiTVWTJZRqcGEqwr5fDHhGTjhH+vDBngM1iiHGhfnhoNZRX6ckoLKddK5kdJkMzQogWraDMMgtBCHcUE2wJGG6d2IXvbx2DVqupdZq53gDDOoYTHuBtPubloaW9MXh57Kc9DhO1WyIJRIQQLVqhORBxv7LuQgDm4AFsa9x0igygX/sQRneJsMklAcgoLHN4rw4R/gD8sS+dqz7Y5ILWNj0JRIQQLVpBqRqaCZYeEeGm4sP8zduJVtNuvTy0LLl9LJ/fMJJJPaJs3nPrxK4O7zW0Q7h5e3dKPgs+38bfR7Kc3OKmJf9zhRAtmvSICHfn7Wn5nX9QYqjDax6e0ZvsogrGdI2kS3QgozpHOLxuRr92/PfPQ+b9X3ed5tddp0l6dqZT29yUJBARQrRopmRVKWIm3FXvuGDzdnANAXOIvxcfzLNfRK+6bjFBfDR/GA99v5vUfMvwTUlFFf7eLfP/QMtstRBCGOUaS2eH+3uf4Uohmses/rGUlFcxtKNzppZP7BHNxUMTeHXFYfOxA2mFdiv+thSSIyKEaNFyjDMHwgIkEBHuSaPRcNnwRLpGBzntnhO62+aUHMkoctq9m5oEIkKIFs3cIyKBiGhDhnQI45GZvcz7mYXlzdiaxpFARAjRomVLICLaqOvHdebWiV0AyChwPN23JZBARAjRYlXq9OZZM5IjItqiaGP9kcUbTpiXO2hpJBARQrRYucb8EK0Ggv1k+q5oe6KtqrY+v+ygw2t+2pHCLZ9urbFIWnOTQEQI0WLllVjWmfFoJQuACVEf1kOSf+xLszt/NLOIO7/cwdI9aSxal9SELas7CUSEEC1WobmGiPSGiLbJukaJTm/AUG2Z38Pphebtt1cf5dutp5qsbXUlgYgQosUyLXgX6CMlkUTbFOzrxa4npgGQVVRBQWmVzXlTr6HJvd/sZF9qQZO1ry4kEBFCtFhFsvKuEAT7epmD8exi22m8eaX2Caxfb0luknbVlQQiQogWq9DcIyJDM6JtCwtQ/wdMCdwmpv0rRiQyo187AA6kSY+IEEI4RVG5+m1PekREWxceoKbxZhdZApHHftrDO6uPARAb7Mt1YzsB8M+xHLeaQSOBiBCixSqUoRkhAAj3t+0RqdTp+XjDCfP5UH8vEsMDzPvDn1nBFe/94xal4SUQEUK0WIWSrCoEYNUjYqw0nJZv2+MR6u9NZKBt0b+/j2bz5JK9TdPAWkggIoRosSw9IpIjItq2cGOOSI5xaOa0XSDihUajYe6IRJvjOcW2OSXNQQIRIUSLZaojEihDM6KNiwxUPSKZRWrWzOn8Upvz3WPUyr/PXNCPmyd0MR+PsarM2lwkEBFCtEiFZZVsTsoBIEIWvBNtXEK4PwDJOSUApOTZBiLWAceVIy29IpU6fRO0rnYSiAghWqT1R7LJLakkJtiHST2im7s5QjSrRGMgcjJHBSCn8yxDM32sqq8CxIf588LF/QEZmhFCiAYzdT0P7RCOn7dHM7dGiOZl6hHJKipn+8lc8/+PKT2j+eS6EXbXm4ZqciUQEUIIWwfTCpn12jpW7E+v9TrTrAB3GOMWormFWK239OSSfaQYe0SuHNnBZmE8E9OxnBIJRIQQwsZDP+xmd0o+1y3eUut1aQXqB227EJ+maJYQbu/OKd0AyCwsN/eIxIX6Obw2ItAbjQbKKvVkFpY7vKapSCAihHAreTX8hvb+2mOc/8Z68w/Y09IjIoSNucYk1JS8UvNid7Ghjv9/+Ht70jUqEIAdyXlN0r6aSCAihHAr1l3M1kuaP/3rfnYk5zFq4Uq2JOWYh2baSSAiBABRgT74eFo+1vu2Dya4lho7gxPDANh2MtflbauNBCJCCLcSYFUlNcPYZVxRZTvF8Ikle0k1Tk+MNybpCdHWaTQa2odZhmKuGdWx1usHdwjF10tLWaXOxS2rnVQBEkK4laLyKvN2ck4JMcG+nMotsblmT4paPVSjkR4RIazFh/lzLLMYgPY15IeYzB7YngsHx+Pl0bx9Ek329GeffRaNRsNdd93VVI8UQrRAprFtsPSI7DvteNlygwE8tJomaZcQLUGCVY9IdHDtidy+Xh7NHoRAEwUimzdv5p133qF///5N8TghRAuWa5Wsmm6cGfPmX0ebqzlCtCimUu8AUUEto7fQ5YFIUVERc+fO5b333iMsLMzVjxNCtGB6vYH8UkuPSHpBOZU6fY09Ii9fMqCpmiZEi+DjZflYD24hazC5PBBZsGABM2fOZOrUqWe8try8nIKCApsvIUTbUVBWidVEGd5efZQHvtsNgJeHhh8XjCE6SP3Gd9/ZPbhwcHxzNFMItzUk0fILv0bTMoYtXRouffnll2zbto3NmzfX6fqFCxfy5JNPurJJQgg3lmuVH2Ly3bZTAEQH+TIwIZRV901kw9FsxnSNbOrmCeH2RnSO4M25g+kcFdDcTakzl/WIJCcnc+edd/LZZ5/h61u3caoHH3yQ/Px881dycrKrmieEcBMH0woZ8+xKvtx00lzMLMDbg5Gdw22uK6lQs2n8vT2Z0isGXy9ZX0YIR2b0i6Vnu+AzX+gmXBaIbN26lYyMDAYPHoynpyeenp6sXr2aV199FU9PT3Q6+3nLPj4+BAcH23wJIVq3p3/dR0peKQ98v9s8Y6ZTVABf3jiKAKvF7Bz1lgghWj6XBSJTpkxh9+7d7Nixw/w1dOhQ5s6dy44dO/DwkN9mhBBQbFU35K3VanZMqJ9akOvD+cPN564Z1aFpGyaEaBIuyxEJCgqib9++NscCAgKIiIiwOy6EaLush1g2Hc8BINRflaUe3imcI8+cw+pDmYzqEtEs7RNCuFbzVzIRQri9/NJKFq07TmGZ84dHSh2Ulw7ztyxb7umhZUqvGPy9W8ZURCFE/TTp/+xVq1Y15eOEEE7y+E97+HFHKn8dzOCT60Y47b6peaVsP5lnd9zUIyKEaP2kR0QIcUY/7kgFYO3hLKfed/HfSQ6Px4bUvkaGEHW243N4KhKOrmzulrgl6xWum4sEIkKIM4oIsAyVZBjLrjtDUrZanGt6n3ZEBlqeER8mgYhwkh9vAX0lfHdDc7fE7aQWpXLl0is5kHOgWdshgYgQolZF5VU2678cNa7s6QwpeaUAXDwknvAACUSEk+mscpoqipqvHW7IYDDw4NoH2ZW5i+c3P9+sPSMSiAghapRRUEbfx39Hb/Uz6niWEwORXBWItA/zs1kFNO4My5cLUScp2yzb+iqoqqj52lYiqzSL8348j8fWP1bjNQaDgfd2v8e2jG14a715avRTzVoOXgIRIUSNft6ZanfseJZzfrMsLq8yFylrH+bHvWf3wNtTy4D4EKmaKhqvsgwWTbPs66sgc3/ztaeJfLz3Y47nH+eHIz/w3Kbn7Ho6juYd5aqlV/Ha9tcAGNZuGPFBzbtmkwQiQggzg8HAxxuS+PuISkqt0tt3157ILnHKs7KKygHw8/Ig2NeLST2i2fzwVL66aZRT7i/auIO/2R87vbPp29GEkguT+XDvh+b9T/d/Sv+P+/PkhifRG/SUVpVy3e/XsTPT8ucwu+vs5miqDZmYL4Qw23oil8d+2gvA8YUzSDXmcFjLNAYQjWUq5x5mNVU3xE+m7QonyTxo3NDAqAWw4XU4tRkGX92szXKVcl051/5+LQBhPmFE+EVwJO8IAN8e+haANafWkF2WDcADwx9gcsJk2gW0a54GW5EeESGEmXX+x+GMIj7ecMK8/8A5PQHILHRSIFKqApEQq+JlQtTL3h/g/amQvs/+XKZxJshZT0GXSWp7/5JWmyey9PhS0orTAHh18qu8NfUtm/PfHvqWjJIMPDQevDLpFeb2mktsYGyz5oaYSCAihDBLy7dMzT37lTXm7U+vG8HMfrGACkSckWFvWmk3VHpBWr/SPMg+Cs6cmZGfAt/MU70cqxaqY+n7oFB9GJN1SL1G9YROE8EvHEpzIX2389rgRlacWAHAgoELGBg9kHYB7fjknE+4ru915mvGtR/HkvOXMCVxSnM10yEZmhFCUKXTozdAklX+h+kzY+GF/RjTNYLyKj0A5VV6CsqqGj2Mkm/sEZEqqq3cyY3w6UVQUQiXfAK9z2vc/fR60Grh0DLLscN/wMl/4MNzwKCHHjMh67A6F9UdPDwhshskb4S8k9B+SOPa4EYMBgMvb32ZVadWATApYZL53MDogQyMHsjY9mMxYGBozFC36AGpTgIRIdo4g8HArNfXU1xeZRcU+Ht7cNmwBDQaDb5eHgT5elJYVkVmYXmjAxFTjogEIq1U5kH4+Q5I/sdy7PAfjQtE9nwHP98Jcz6yrZRaVQZ/PqGCEICDv6pXTz8ISVTbIQnGQCS54c93QxvTNvLR3o8A6B/Vn+5h3e2uGdpuaBO3qn5kaEaINi6toIz9pws4mVPCrlP5NudKKnQ2v0ElhPkDsHT36UY/1xSIhPhJjkir9MZw2yAEbOt6NMS316qelc8ugmOrbc+d3GB/fWQ31XsCEGoMSNa+pHpVWriyqjKe/udpbvjDUjH2+fHPu2WPx5lIICJEG3fcQaXUeaM7AnDHlG42x68d2wmAH7anoHcwtbc+8kqNOSLSI9L6bH7f8fGMvfDB2XBwmePz9VFRCP4R0K6f5Vh4Z5WcahLb37IdmqBey/LgWMted2Zr+lau/+N6vjr4lfnYlzO/pH1g+2ZsVcNJICJEG3ck07ZAWUSAN4+d25uvbhzJrRO72JwblBgKwLGsYq75cFOjnpuco/JR2gX7Nuo+wg3t/dH+mF+4ek3+B/56pmH31VT7yOo8CbpPt+yf9xoMnAuexn9Tw2+0nOsy2bKduh10VQ1rQzNbcnQJ85bNs6kFsmDgAvpE9mnGVjWO5IgI0QYdzyrmlk+3ct7AOD7756TNuY6RAWi1GkZ0jrB7X3ur0utrD2eh1xvQauvfFazXG9h/uhCA3nHB9X6/cGO6KkjZanvMJxgGXqFqeYBlZkt9+YVBSbZlv9M46HMB+IbCgMsgIFIdv2aJWlsmdoDl2rCOMPkRWPm0+tr5FVz9E4S0nF6EksoSXtryknn/pv43sWDgghY5HGNNAhEh2qCvNidzIK2QA8sO2p0blBBa4/uql17PL60kLKD+OR7JuSUUlVfh7amlc2RAvd8v3Fj2YaisVn03MBrG3gP5ybDvJzDoGnZv70BLIOIfCb1ng28IjL7N9rqE4Y7fH9XTtp1/vwrnPNewtjiZwWDg79S/Kasq48ejP3LHoDtIK04jNiCW0qpS+kb25ZmNz5Bdlk37wPYsuWAJXtrWMawpgYgQbdCGY9k2++O6RbL2sCrrPigxrM73ySwqb1Agcsq42F2HcH88PWSEuFXJOaZeo3pZ1nbxDoSACJjxkgpESnLUyrge9fwgrTDmM132OfScWf+2JYyw3T+0DPpfCu0H1/9eTlJYUYiHxoO3d75tU559VfIqh9d7aDz495h/t5ogBCRHRIg2Z/2RLHYm59kc6x4TxFtzB3P75K6c07f2ks/3TrNMD1x9MNPhNUlZxXyw7jhllY5/8801FjNrSBAj3FzOcfUa3ctyzPRB7x8OGg/AAMVZkHHAMpNGV6kKklUvelaWDz8tgE8vhhIVLNOuPw0SGA1X/wwxfdV+bhK8NwmOrGjY/erhaN5RCisKbY7lleVx3o/nMfqL0TZBSG3uHHwnw9oNc0UTm430iAjRxny/LQWAi4fEk5RVzJYTuYztFsmkHtGcY6yeWpvbJnfjh+0pHM0s5pnf9jN3ZCL+3rY/Ss7672oqdQb0egM3jO9sdw/TqrtSVbUVylbrmxDeCbqfAylbYPz96pjWQ+VxFKVD4Wn47GI11HLZF5C+RyWxznwZhlmqgbLne9j+qe0zfBuRV9R5Aty0Bv4Tp+qPAKz/H3R1XbXRv1P+5uY/bybMN4zZXWfTLbQbs7rM4qejP5FVmmVz7X1D72NE7Aj2Zauy9VM6TOHPE39yJO8I7QPbc0XPK1zWzuYigYgQbczWEzkAzOwfy5gukRzOKKR3bP1+sJdVWuownMotRac3EBXkQ2SgDzq9gUqd+q12T2q+w/fnFRt7RFrCOjMGg1pCvr7DCG3RTwssQUN4Z5j8KFSVg5fVzKjAGBWIpG6z5Ht8ebnl/K/32AYixbYf1AB4BzWunVoP1Y4841pKja1vcgaL9i7CgIGcshw+3PMhGjSMihtlnn7bP6o/qUWpXN/veub2mgtAj/Ae5vdf2O1Cl7avucnQjBBtSH5JpbmM++DEMLw9tfSJC6l31v3js3qbt1cfzOSc/63lvNfWAbDzVJ75XEwNU3PNPSIBbvrhXlkKGftVEPLJ+fBSD1Wq3F2lboc/HoHyojNf60rWPRcdRoNGYxuEgOopATi2qub76CotQzRlebbngttbipQ1hqePZbuiEA793vh7OpBWnMam07ZT3Q0YmPT1JJILkwnyCuK9s97jr0v+MgchbY0EIkK0UqdyS/h+2ynzAnV7U/N5+lfV3Rvm79WoEu3T+rRjaq8YABZvSAIgNb+M9IIy7v3aUt+gsKzS7r3PLTvAovXHje1wwx4RgwG+vQ7eHAl//Ud9YJZkw6Jp8NWVsOxBeLYDPBkOvz/c3K1V3p0If7/W8PoczlCSY7sfbj8kp44ba9McXVXzvf4dCd9drxbLK81VxyY/Ald8rb6cQVttQOCn2xxf1wgnC07y7aFvMWBgYNRAvj/ve6YmTrW55paBt+Dv5e/0Z7ckMjQjRCt1ydsbSM0vo7CsirkjEpn56jrzuYhAn1reWTfxYaqmiGkGDMBHfydxLMtSqTW/tJKSiirKKvWE+nlxMqeEt1YdNZ8Pc7eqqllHVN5CrjHhcs3ztuf3L7Hd37oYpj2tfvPXVar6GKYKnq529C9VuKvDKMux6mXPm5IpSRXg2j9qvs4UoJgSNwddCSMXwFujbK/b8636CjQmT/tHQveznddeje1UdIozoKygcfknRgaDgeP5x5mzZA4VejUMOSRmCN3CunHXkLvQGXQMiRlC19CujI4b3ejntXQSiAjRSqXmq0S8V/48xOM/77U5F+GE2So929mP01sHGQDHMouZt2gze1LzOat3DD/tSLU571Y9Ino9vF7PVVkrCtXMi/BO8MPN6oNz3m/QcYxLmmhWmKZWtDXoVCVRk6rSmt9TE4NB9foc+AX6XFj/th/4VSV7djau+tphLCSOqPn6uIG2+9F9IKY33LYFDv4Gyx+zPV9kLH7mF1q/dp2J1ioQ8Q1VQ0CfXwLnPG9bGr4eiiuL+dfqf3Ew5yDlunJzEALQJVT1BHUI7sCrk19tRMNbHxmaEaIVyi4qN2+b8jGsRTqhR+SiIfHEhTjOAelkLFJ2IK2QTUk5lFTo7IKQjhH+jOka2eh2OE1BSs3nuk2z3Q+Ks0whfXWg6onY863aX/eyS5pn48TflqJgOz6zHC8vdHx9bbYsUnkwm9+H766DqoozvsXGl1eoVW1XP6v248+w0mu7fjDuXst+nwvUa2Q3GHU79D5fVWL1qdYz4Vf3+jZ1MuNFNTwz4f8gJF4dO7lB9YjVQVZpFh/s/oCiiiKSC5P5aM9HnPvDuaxPWU9WaZbdVN2uoV2d2/5WRHpEhGiFDmfUnrQYEdj4nggvDy29YoPNPS/W4sP8OJ5lv5ieSftQP365YxwBPm70IyjnaM3nOo1XS9ibhLRXH6Bpu9T+wd8s56rKcbmT/zg+XpwFep3tb/tV5SrIOLgULv3UtmfBYICNb1v2C09D0hroapvHUCN99ToxGhh+g8NLbUx+RCWxBsZAsNWUca0WLlmstte+DCuetJzzDcWpEobBAyfBOwBSd6jpw6Bm9NSgXFfOwo0L2Ze9j/05qljbK9tewc/Tj9JqvVEXdbuIy3tezsPrHqZKXyWBSC3c6KeAEMJZMgpr/zCs1DlnGXTryTYDE0LZYSyUFh9We/Lduf1jCXSnIAQs9S9M7j+upph6+qk1Sza/r4ZhQP0mPWqB+tBa/z/b/AhdPXsUGsI07dSOQSV3mtZc0evho5lwarPaf64DxA+Heb+CpzcUZ0LWIUCjejJObYYix0XqHKr+Z+YdYOldqI1GA+Pvq/0a/2prHTm7RwRUe8Eyk6cWuWW5XPzzxWSUZtidsw5Cov2j+e3C3/DxUL2OX89SybXa6gv2CTP5kxGiFcovtR+Oee3yQVw3Vv3AndkvzinPObe/uk9iuL85eRWgX/sQ7pzSjWcu6Mv903vYvS8qqPFDQ06XccB23z9c9Qx0HAM+gXDnThhgrHdhSpo0Dc+c3mF5X5H9B5XTVZ+hMu0ZS49BgXEILOsIvDvBEoSYnNoE2z9W26bAKri9JYAoM9Z+0etVr8SJv+2fn7IV3hgBb1Rb02XiAw35bhyrHogExjjv3tWNvMWyHWy/CF5ZVRm3/nmrOQgJ8QmxOX9+1/PZcdUOVl2yiu9mfWcOQkAFIBKE1M7NfiURQjhDgYNAJDzAm0dm9mLBpK6EO6m0+nkD4vDx1DIoMYyP/k4yHw/y9eSKEaoU/Ndbku3e12yBSPZRtfBa54n256yHO7qf4/j9578FI26ylAgPiFKv1t35+clqBVoPF/54LbFdK4jQBBU4leXBO+NU0PTlFZBlv6ghoIYiwBKIhHVUi8eBJRDZ9aVlaOTxPNWLUVECL/e0XGMy/CYYOh8iu+M01oGIb4h9PRJnCusIN6+Ht8fYL9gHvLb9NfZkq6Gba/tey12D72J96nqi/aMJ8wkj0i8SjUZDhJ/9itXizCQQEaIVMvWIhPh5mbfDA7zRaDROC0IAtFqNuSx85yjLKrpBvpYfLTP7xbJifzqxIX7mYCXKCcmy9XZ4uSUR8ZYNaqaGSVmBJUdgzkfQ9SzH99BoIG6QZT8w2v4afZUKRurQ3d9gpdV6RPzCbYODt8Zapsc6Yuo12f6JenUUiCStt1yfdQiieqien+pBCKg/E+u1ZZzBOhAJrH39I6cwDmeVledzz5+3AhATEMPW9K0cz1dDb/+b9D8mJ04GYGz7sa5vUxshgYgQrVC+cabM6C4RLN2jpj86MwBxpHuMZTpvkK+lPkiAjyfvXDWU41nFlkCkqXtEKkpsZ0Ok77ENRPJOAgb14WeaxVEXAdUDEY26z9EVEH69GtYITaxb3kRd6XWq0BdAl8nqe0scadtLUj0I8fS1rKsCaoZQ3kk4vkbtR/UAvbEXLfc4/PEo7LCqknpkhar/8f2Njtvk7CAEIKgJgg9rxqGttb4+rE1Za3c6xj+GiQkTm7ZNbYQMXAnRCpl6QYZ1DCc+zI/EcH+n1A6pTdfoQPO2p9a+ZHywVS+JMwqq1Uv2Ydv98gLbfVMPQVA9c2eqJ1Cahnx+/ResfAY+PAf+N7B+9zyT9D2Asfz55V/Bdb+rdXBqqmQ65i41VOMTbMlpKUiFPKshs2HXWXpEDv4Gf1erc3HwNzW7Jt/4nh4zbM+7ovfHurBYTUNMzuTlC55+/BFgSbS2XuV2XPw4yfVwEekREaIVKjCWVo8I9ObPeyZgMICnh2t/iAb6eDKjXzuOZhTTM9a+2FlEoA+XD09A6+ThoVrlnlAzO6rnVGxepKa6pu5Q504Z1wKp72/h1dc86TULjv2ltk1VWfX2+ToNdmw1fHye2vYOUjNfTOYshrUvQUURHPnTcnzUAjWEdO9hNWy0sL0KxEwzXhJGqtkjjqbHXvSBqi2StFZ9mYQkQM9zVRE0sAQxzjbsBtj8Hkx80DX3r2ZtcDjLAtXU58XTFzM4ZjBv73yb5SeWc3P/m5ukDW2RBCJCtCIGg4Fnlx7g76PqgzfYzwtfL48zvMt53pw7BIPBUOMiegsvbFjFygYxGOB/xud1qbbEe8Ze9VWddU2LuvLytyQ4DrtOJY1+M8++LfVcWBCAXd+oYmHnPKdqg/xoNbvDNEXXJLa/qsGx4U1LIKLRWnItTMme4Z0h5xgsucP2PtbBhKcf3HdEzRZK3wPr/mv7rLJ8S6KuK53zHPQ+DxJqqdTqRK+H+AEVXBkxmMExgwG4OSOVmw/uhAlVTdKGtkj6mYRoRX7emco7a46Z9109HONIfVfydZlTWyzbR1eoV9Nsl5p4B9Z+3pFuxsRW0we5aVE3a5UNLL3+/fWqR2DPd+pYcZblfE15J9ZDNP6RtsXNQJVxt2YKRPzDLce6TFJBCMDkR+2rnPabo6bqdhoPFy+q2/fTEFoP9QxP1w/lZZdmsw9VA+a6Sqvnrf+fqrey/hWXt6GtkkBEiFaivErHv3/Zb3PMOoG0zTENkVg760mV4Dn6Dug4zv58+3quNQMw82UYfqMqEgYQ1sH+mupL2ddF4WnLdv4p1QuhsypUN6KGoYL2gy3bEQ6ColELbGtlmIKv2EGW2UIDr7Cc13rYXn/Bu9B1ihrGumYJ9L2obt+PG9uesZ2JX08070ee2KACQWumBGHhdDI0I0QrkZRVQlaRbUXVphyWcTsp22z3NR7QYYylfLmuUi03DzDpETXzo0cN9UNqExAJM16w7PuGqCRW0/L1oD7EguuZCGvd/swDkG+1Fs7VP0PnCY7fZz2lOKqn/Xn/cLh7LzwZqvZNNVC0Wpj7jUpkDalW1Mu6l6vvRQ0bZnJDKUUpRPtF88aON8zHzioph7x0VVU3ymo2UEMWFBR1IoGIEK1EeoFlemb7UD/uPsuJxaVaotTttvvDbwAvS/VXPLxg4kNqRsbo251bMCu0g20gUt8eEYMBVj9n2d/1lWWKbEzfmoMQk9lvwM4vYdLDjs9rNGoGTdou6D3b9nj1IARsh5ZcWaitCa1LWcctf95ic2xW51ncdHwXkA7pe21rmVSvZiucpnX8ixJCmAOR8d2j+Pja4We4upUrL7QsH28y9Qn76yb+n2ueHxRrW/Z95xcQOxC8a1+Dx6wsz7KgnsZDrbT75xNq30EJcjuDrlRftbnmZ/Vh22HMme+XMELVF/Fww9L8DfTSlpds9i/qdhFPjH4CchYAa2Hvj7Y5Obk1re8jGksCESFasLJKHd9tO8W5/ePMC93FuOM6Lk0t76R69fKH7tPVcIx1b4irGaqtSrvtY/DwhpkvOb6+OlOND/8IVQdk+aOWc+36OaWJ+IVBxzpWBz37GbVq76CrnPPsZlRSWcKW9C2kFFmGumZ0mqGCELBUcT26wpLkDKoIXFWF7ZRp4RQSiAjRgj320x6+3nKKP/amkxiuftuOCXbhmhwthSkQiewGcz5s+ucHOZgGvPn9ugcipsJhoYm2gcfFi6DXeY1vX30FRKqptC1cfnk+l/96OcmFlmJuN/a/kRv7W1WMrbGWjEH9vThKAK7N7m9VD9ew6+vd3rZCZs0I0YJ9veUUAKsPZXIiR9WyiAmRQMTcjR7qYAZLU5j0kJqVYz0Lp67DGlUVcNxYPCwkQfVa9L9MTaPte5HKbWkjNqdtZu5vc9mWvu3MF59BSWUJ1yy9xhyEhPiEsHj6Ym4fdLvNark2yb4T/g+mPAYR3dS+aZFAk8oy2PwBFGWq/e2fWaZag5rp9N11qtKu6RphR3pEhGgl1hxSP+iGJIad4co2wFQSPKxj8zw/qB3M+8W2Eqp1nY7qdFUqpyRukBqG2fi2Oh6aqAKPC99xeZPdTbmunGt/vxaAZzc9y9ezvq7zeyt1legMOnw9LUH5N4e+4Wj+UQCeHvM0Z3c82+a8mafVEN74+9Sff/JmtUxA+l41dVmvh7+eVr1cZfmqwuyMF+EntVge3c9R+UAnN1ruVZYHgU1QBK4Fkh4RIVqonOIKu2ORgd70bNeGa4eYmIqZNaQuiDMljlTVTQEM+pqv2/4xvD8Fvr7aEoSAKhzWRu3K3GXe3p+zn5yyHHLKcigxVbGtQVpxGrN/ms3oL0bz/eHvAdUb8vVBFchM7zid87qc5zgIATUjqdN4GHuPpfepq7Ey7y5jMHTwV1VO37QS8dGV8JpV/ZZ81VNJ8j+WY9XXNxJm0iMiRAv1844Uu2Mz+8WidbDgXJtSXqR+cwWIH1b7ta7m6QN374OXe6oZGHqdKhCWugP+fBzG/Ut96B1erq43rd0CMP05iBvYHK1uVhklGezJ2sObO960OX7Fr1eQUpRCn4g+LDp7EQUVBbQLaMfRvKMs3LiQgooC+kb2ZWv6VvPwy+N/P06lrpKkgiROFp4k3DecR0Y+Unv1X08fVajNWt+LYOn9kL4bXhuqiuLV5tv5qjfOesXj8sIaL2/rJBARogU6llnEE0v2ATCuWyTn9o9l9aFM7jmrRzO3zA2cWK9mrYQmOq6J0dQCIgGNalNBCnx0LuQZc1j0OhWI6KvNsonsDiPb1iJrFboKdmTs4LaVt1FqVTzMU+NJlaHKPMtlb/ZeRnyu1p65e8jdbE3fysY0NQSyP0dVFg7yCiLYJ5iUohSe3vi0+V7PjH2GEJ8GLNDnH65K52cfUUM0OUdrvz59j3GVZCsSiNRIAhEh3JhOb+CfY9n0iw8h2Fd1E5dV6jj7lTXmawYnhnHpsEQuHZbYXM10L0eMUy6rL3TXXDy8IDRBzeTZ+4MlCAG1Ui6oaqYA0b1VMbNz/2t/n1akQlfBWzvfwkvrxfy+89mQuoF/rfoXVQbLwnLRftHc0P8GOoV04oY/biDEJ4S88jyb+/x3q+XP6bwu51GlryLMN4wrel6BRqPhhj9uMAcwI9qNYExcHWqm1GTqk/DVXLVdfZhtxouw7ye1EODe7x2/3xSI6HWqx64oQy1DMOWxJllLx51JICKEG/t4QxJPLtnHkA5hfHfLaAA+/ecElTq1DoanVsP8MR2bsYVuyFT7oaubBCIAMf1UIHLoD9vjVRVq5kX6brV/0fsQ06fp29eEMkoyuOyXy8gsVcnVb+18y+Z8qE8oi89ZTIegDngYF+xbf/l6/Dz9+L81/8cfJ9Sf4S0DbuG9Xe9RZajiur7XcdeQu+yeteyiZfxz+h9+PvIztwy8pXELMvY6F8bcqRbBq274Deprz/eWQMTTz7YsvCkQ2f0t/GA1XTi0A4yw2q9J6nYoybYsUdCKSLKqaFMWblzI/avvp0rfMpb0/mKTqoex9YSlXPgP2y25IZsfnkqovxRYMss7qbrPNcZVW92FqRbIiXXq1TStuCRLzb4wcVR/xA3szdrLtG+n8c2hbyiuLAYgKT+Js789m0V76rf67pcHvjQHIdYi/SLpGd6Tt6e+TeeQzuYgBCDIOwhPrScPjXiIe4feyz9X/MOtA2/lj4v/YMn5SxwGISYjY0fyn3H/ISEooV7tdMhREBBoVXek57lqyrV3oFo2wFqZMVn1cLVg9PjqMz93/xJ4dyJ8ejFkHalXk1sCl/aILFy4kO+//54DBw7g5+fH6NGjee655+jRQ8axRdNLK07j8wOfA3BJj0sY2m5oM7fozHR62xVAi8qr2Hda/UDb9PAUwgIkCLGRc1y9RnRVi8+5C+sVcQFi+6shmuIsNcUXAI2qduqGXtn2CqeLT/PUhqd4asNTPDHqCZ7Y8ASghke0aPk79W9md53NOZ3OQatx/DuuwWDgt+O/AfDcuOfYnrGdtJI07ht6H4nBZx5ajPCL4Jo+15j3o/yjiKIJp8R2Gq9Wbj65Qa24vPYlOO91y3lPb7jhL6gsUSXx11i91zRrpnqFX9MMr5qU5sI384w7BjVDJ7JrI78R9+LSHpHVq1ezYMEC/vnnH5YvX05lZSXTpk2juLjYlY8VwiHrokh/p/7djC2xVaXTs+CzbUx+aRU7k/NszlUPRHafysdggLgQX6KDpHCZHdNCc7XV7GgOCcMBq2GBdv3Vq0FnWVPm9q3NvqqtwWCwmR5rMBh4bftr/HP6H5vrTEGIyUtbX2LD6Q08sPYBBnw8gM/3f47BYODHIz/y7w3/JrMkk9NFp7n+j+tJKUrBS+vFxISJPDzyYV6b/FqdghC3Me3fcP2f0P8SWLAREqrNzAqMgrAO0HE8DLjCctw0NGP6NzrlcfValKbOlReq+iTVpe0B6x7cuvSgtDAu7RFZtmyZzf5HH31EdHQ0W7duZfx4N+o2FW3C1vStDreb24G0Qn7dfRqAR37cg5+XB1eMSOT8Qe3RGWwDkb2pqm5Bv3g3+m3fnZhWufUNbc5W2PMLg3Z9Ic2YCxLZ3bKYnUlYpyZtUrmunBMFJ+geplZprtRXcvvK2/k75W8SgxPpHd6bbRnbSC9JB2BA1AB2Zu60u0+wdzAFFbY1MhZuWoiPhw/PbX6O0qpSDuQewFPjybYM9cvAsHbD8Peq4wKALZVWCxe8pYblfn/Q8m/TFIiEdVTJrcWZai2iPx5VlVxNCzHu+R6OrYJti9V+YDsVtCSttUwDbyWaNFk1P1/9EA0Pd/zbSnl5OeXl5eb9ggIpACMaxmAw2CSmVegq+Cv5L/P+toxtpBenExMQ0xzNs5FbYilMtjtF/R/ZlJSjAhGdbSByKlclv3WKDGy6BrYkph/y7jjE0f0cSyDS7SzoNQv2/aj2pz6pPriaSG5ZLlcvvZqkgiTenvo2Y9qPYePpjaxPWQ/AiYITnCiwzO65a/BdXNv3WjQaDQdzDqLVaGkf2B4/Tz/SitNYm7KWWV1m8fKWl/ny4JeAba+JdXGyK3tdyRW9rHoKWjvT2jUFp9VQnKnYmX+4GkIszoTfH1LHVv1HBSJl+aoWibXBV8HGd9S5k/9Ax0bMAHIzTfYvX6/Xc9dddzFmzBj69u3r8JqFCxcSEhJi/kpIcEJykWhTCisKmb9sPuO/Gs/+bFVTIK04jfFfjTcnyGmMXeT3rr6XP5L+4M8TfzZLW0/llpCUVUxuSWWN11RZDc0YDAZS8lQg0j6sCVeSbUlK89SrX2hztsKx0bdB79kw+w3wDoA5H8FjufBEPoy9q8masT5lPVO/mUpSQRIAN/95M0UVReb/L0FeQUxOmMzVva8m2i+a87uebw5CAHqE96BbWDf8vfzRaDTEBsZySY9L8PP04+GRD7Plyi30DO/p8NmPjXqM/xv+f85JHG0pQo3DTqnb4ZX+lunbfmEQ7mABvfIi+Ok222PdzoaRt0Jv43IBa15wXXubQZP1iCxYsIA9e/awbt26Gq958MEHueeee8z7BQUFEoyIevnm0DdsSVfJX5f8cgmTEiYR5htmzvS/qvdVhPuG879t/2NH5g52rN4BwPKLl9MuoKZVN52voKySWa+to6xSz9WjHS/Mdv3iLWQUWnoIv9iUTLJxYbv2oS0zP+RAzgE0aOgR7qKEdXfuEfENgUs+tuxrNC7LCUkuTGbT6U3M7DzTXMpcp9dRqa/kgbUPUKG3XR7g9pW3k12WDajVaOf1nQfAvUPvrfeUVx8PH96f9j4/HfmJ1OJUpnecTnZpNvFB8a77e3dnIfHqVVeuvkz8wh2v5LvQQRG+ucbS8qNug+2fQvLGVjU80ySByG233cYvv/zCmjVriI+Pr/E6Hx8ffHzadmEX0TjLjtvmJVkPx9w5+E6u73c9Or2O/22zrQWw8uTKJu0u/npzsrkn5J3Vxxxe8+f+dJv9h37Ybd6OC21ZPSJ6g57CikKu+u0qynRlrJyzkgi/iBpnV9RbcRZseB1SjQnJ7pYj0oRKKku49vdrSStOY2XySl6d9Cqrkldx/5r7zQFIlF8Uyy5axkPrHuL3pN/NwTvAyLiR5u2G1t0I8Qnh6j5XN+r7aDUCosHDG3TV1obyj1BDMzUJbKeGY7qdbTkW2R08fdWsnMPLofvZzZ7g7AwuDUQMBgO33347P/zwA6tWraJTp6ZNxhJtR3JBMvN+n0dGSQYAr0x6hS8OfMHG05bVL0e0U2WhPbQe+Hn62ZSR/uLAF1za41Kb2gWutHRPWqPenxDmnol+KUUpFFUU2fzmeyDnAPOXzaeossh8bPI3kwn3DeezGZ8RH1TzLyd19vMdaiEyE3fsEanmaN5R/kj6g20Z2wjzCeOeoffQLqAd5bpy22XpUavJemg9KKsqqzHJ02AwUFBRwG/HfyOtWP37WnNqDQM/GWh37fRO0/H28ObFCS/SJ6IP3x3+jmj/aC7veXmNwyqigbRaVVvEVBY+KA7OeU6tzuuoR8Ta5Eeq3csDonupYZ4vLoWh18G5L7um3U3IpYHIggUL+Pzzz/npp58ICgoiLU395wgJCcHPr2X9RifcV05ZDhctucgmsJiSOIUpiVOY+s1Uc9Z/74je5vOvT36dpUlLubHfjcz5ZQ5JBUksS1rGzM4zXd7e/NJKtp/MtTt+w7hO+Hp58NHfSRSW1Vxwbf6YjgT4uF9R5LyyPOYsmUN5VTm/XPALH+79kPUp6zlZeNLh9TllOfx09CcWDFzQ+IdbByEAARGNv6eTFVYU8uaON0kMTuSyHpdx65+3klqcaj6/NGkp/SP7sytLJXZOjFfTWw0GA5f/ejlFlUWU68q5steVDIoexKTESXhpvczv/+LAFyzctPCM7Tin0zncMuAW8/78vvOZ33d+Le8QjRbZ3RKIjL3bkusR2UMtReAbDMmb1FpEJuE1/OKeOEoFIgBbPlCVhEfdpiq7tlAag6Ha/EBn3ryGLqMPP/yQefPmnfH9BQUFhISEkJ+fT3BwsJNbJ1qqSn0l962+j6zSLB4a8RDH84/zwNoHzOf/NeRf5jHuP0/8yd2r7mZW51n8Z9x/HN7vvV3v8er2Vwn0CmTJBUuI9It0afv3pRYw49W1RAZ607d9CKsOqiTaa0Z14MnZfdl/uoA5b2+gqNxxMPLrHWPpE+c+03e3Z2ynS2gXnt/0PD8d/QmAwdGDzVM1TWZ2nkl5VTkJQQl8efBLSqtKCfMJ45tZ3zR+9tIT1f487typpke6CYPBwK0rbmVdisqR6xnekwM5B874Pq1GS7hvOFmlWXbnpneczlkdziKzNJMrel7BeT+eZ05A7RLShbuG3MVHez8iwCuAjJIMxseP55YBt+Cpdb8gttX7/WE1dAgwfxl0GGV/TdI6+Hg2BMaoNYfOec5xj0nWEXhzJOirJbk/nudWwzT1+fx2aSDSWBKIiOoKKgoY84Vl2lq0XzR69GSVZjGvzzxuGXALfp5+NkHw3qy9dAzpSIBXgMN7phSlMP276QAkBCXw6wW/1mts3GAwYMBQ53yHdYezuPKDjXSPCeSX28fx4Pe7WbIzlR8XjKF3XLD5nltO5PL7njRmD2zP8v3pvLriMAAH/j0dXy/3SFL74fAPPPb3Y7Ve89+J/yXaP5r+Uf3Nx0oqS7j0l0tJKkgyrxNyuug0b+58kx5hPbiy95Xmayt1laxPXc+I2BH4efqRUpTCmlNr8PP0Y0riFIL0eni2WkGsR7PBw30+cFecXMFdf91ld3xYu2EsOnuR+c9xSMwQZneZzdLjS9lweoP5Ok+NJw+NfIj/bvkvhZW1r+I6v+98bh90u01viWhma1+CFU+p7dr+beaeULkjPmeYnn96Fyx/VNUZMVmwCaLcJxm4Pp/f7vM/VYgaVOoqOV18Gg0aXtzyos25jNIM8/a49uMcjp/3iax9EbH2gZYs9eTCZN7b/R439q/DIlSoD9Q5S+aYhx8SghL45JxPiPCreWggu1hlzocHeOPtqeXFOf15anYfm+EWjUbDsI7hDOuoau50iwnk10Nr6Bwe7TZByIbUDXZBSKBXICE+IeYVT58a/RRTO9ivz+Hv5c/NA27mgbUP8MeJP7ht0G08uv5R83LufSL70Cu8F4v2LDIvitYvsh+BXoE2H9DfHPqGj0c8gd2fiBsFIQaDwbxK7Jzuc1iXso6iiiJiAmKY12ceABd0u4Dx8eMJ9w1Ho9FwQbcL+ObQNzy1QX14vTr5VcbFj2NC/AR+PvqzXbK1SZhPGPcMucfhOdGMhsyHIyuh7wW1/9sMczyDzk5sfxh6rW0gcmqLWwUi9eE+/1uFcOBw7mGuWXYNhRW2vwWOiB3BM2Oe4f4197MtYxuJQYmNWjvm1UmvcsdfdwDw2vbXCPMNY073OWd83/ITy21yIJILk/n+8Pf0DO/JipMrmNtrLt3Cutm8xzQUExGgEhI1Go3DnA+dXkdKUQrZZdks3ruYjMAVZFTAg2s38MzYZ5w346QB1p5ay60rbgUgwCsAvUHPkJghvDnlTTQaDWnFaWxL38a0jtNqvMf4+PH4e/qTXJjMoE8G2Zx7ccuLpBal2gxJ7M7aXf0W7Mrcxb+3vcJjmIoiadRMAzdRWlXK9O+mk1OWg5fWi38N/RcPjXjI4fBI9eB1Tvc5DG83nJTCFEa3VysvR/tHc32/6ynXlfP2zrft7nH3kLtd842IxvEPh/m/nvm6+uh1Hoy/z1JTJM9xLlZLIEMzwm29sPkFPt73sd3xcN9wllywhGDvYPQGPb8n/U6P8B50DuncqOclFybzzD/PsD5VVZe8steVXNbzMrJLsxkQNQC9QU96iarGuvLkStoHtufyXy+v9Z7hvuG8OOFFyqrKeG31VjbtSQSDD1DFVSO78O/z7Yv75Zfn88GeD/hwz4c13veOQXcwOm40Xh5edAvtxs7MnWxJ38KE+Al2gY+zfXfoO5uqmX9d8hchPiF4ajzrPd3zs/2f8eymZ837nlpPu5WRE4MSCfUNtanO+Z+x/2F/zn4+2fcJAP9Nz2RqSHe45BNVydKzecsAlFaV8u6udzmWd4yVySsB6BbWje/P+94p96/SV/H+7vfx1HpyTe9rqNBXcCj3EAOjBjZuqXvR8piHfTTwSHrN//Z1VU3aUyg5IqLFyy/PZ+yXY837z417jhMFJ0gpSuGxUY/h7eGaVWcr9ZVcsuQSjuTZLrU9rcM0juQd4Xj+cTqGdOR4/nGb8+9Pex9vD2+e2vCU3XurM+i9QFPFuIDHefXC81iZvJLNaZu5steVfLr/U5YlLSO/PN/ufb4evvh5+pFbbj/jxsRT48kbU97gdPFpRsSOcM7UWCtZpVlM+nqSef+j6R8xJGZIo+655OgSHl73MMNjh/Pi+BeZ9t008wyod6a+Y+4N+PPEn2w8vZHLe11O55DOlFWVMfqL0VTqK7mooIgnQgfCVT80qi3O8u6ud3lt+2s2x16f/DoTEiY0U4tEq7X7W/juOrU9+RHVS2JNVwVfXqGSYa/8FjqMbpJmSSAiWrzfjv3G/639P/P+zqt3NtlQRH55PhO/mkiVoeYptNaGtxvOB2d/AKjfVI/nHyenLIdNaZtYtGeR3W/4JhGePYgO1rI/Z7/D8z4ePpRbVWLcfc1udHodL255kc8PfI7e4GClTishPiF8c+43PLHhCTw0Hrw2+TU+2fcJq06t4olRT9AxpKPN9Tq9Dr1Bj5dHzUmO85bNMy8YeNfgu7iu33W1tqGuSipLzEnGj65/lB+P/IiX1ostV26p9e99dfJqblt5G+0rq1gaMgrNnEVOaU9jGAwGzv7ubE4XnzYf++WCX+gQXMfxfyHq4+Q/sMhY9Mw3BB6oNkRzdCV8coFl/8rvoesUlzdLklVFi3Yo95BNEDKvz7wmzYcI8Qnhw+kfctXSq4j0iySvLK/GoGRah2m8MMGy7oOn1tM8NDIidgS3D7qdbenb2Jh8mFf/+RZP3ywiArzJrkglu+og2TmO2zCz80wWjl3Ir8d/5cG1D3JJ90sAVYzt/4b/H/83/P/IKcth2fFlvLvrXW4bdBtj24/lvB/PM/cm5Jfnc/GSi80ro1oXtnpz55s8N+45vjr4FVvTtzKryywW7VnEvux9PDn6Scp15by/+33GxI2hS2gXAr0C6RbWzRyEfDHzC/pGOl4zqiGsk4zvGnwX3lpvLu156Rn/3oe1G4afxoMUL9jl7cEAp7Wo7gwGAzsyd9A7ord5yMQ6CAE1vCSES8QNVhVas49ARQlUldsOzxTY/lvk0wvhxtUQN7BJm1kb6RERbmf+svnmktOLpy9mcMzgZmnHrsxdtA9sz7H8Y5RUljAhYQJ/nfyLYJ9gViWv4lDuIV6Y8ALB3rX/21y2J42bP1Uf4H3igvn1jnF8sPsD3tv9Hv6e/tw+6Hb+s/E/VOgruGPQHUztMJV2Ae3M1TX3Zu+lU3CnWitqmvICUopS2J21m1+P/sqqU6uc9mdhbXz8eN6Y8oZL7t0QD34xlV8q0pnh35G4LlOZmjj1jDOlnMmU53Jel/Pw0HjwwxE1PDSr8yyKK4sZHjucub3mNll7RBtkMMAz7aCqzL6GztqXYcWTttcPuBwusE92diYZmhEtTkllCQUVBTy/+XmWn1gOwKDoQXx49odNVnbdFTIKyxj+zArz/qQeUXw4fzighnEMGPDSepFTloPeoHdaMbXkgmRm/TgLnUHH0JihRPlHUamrJDE4keLKYr46+NUZ76HVaB0O/zRncOjIsk/P4T7dKfN+lF8Uv1zwS42BmzPp9DqHJdRnd5nNIyMfMS84J4TL/W8A5CbZFkw7+Q98f4OaUTNygSo3//drgEYN4fi67nNVhmZEi2IwGLhy6ZUczj1sPnb7oNvrXMvDnW1Nsk0sjQqydJlaT+EM9w136nMTghP44OwPWHNqDdf1u86u1+bavtey9PhShsQMYWD0QL448AUVugrO7ng2Ny6/ke5h3Xlh/AvoDXq+PvQ1K0+uZOPpjczrM8+tghCAkcVFYPV5n1mayarkVczoPMPlz3Y0pTguII5/j/m3zF4RTSsoTgUihcZlA/R6S+4IQEh76HmuMRAxwLMJEDsALnwforo3R4vNJBARzUan1/HHiT/46uBXNkHI7C6zW0UQArD/dIHN/thuUU327CExQ2qc0RIXGGeTaHp5T8s05J/P/9m87aHx4PKel3N5z8vJL88nxMd9SsubhBZmcGdJCf8LDzUf25K+pd6BSFlV2Rl7MPZk7WHJ0SVc1fsqjuQd4faVtwNwVoezOJhzkJOFJ7m+//UShIimFxyrXk05IYWptucDoiG0Wq7S6Z3w6z0w7xfXt68WEog4ydurjxLk68ncEZIZfyam1UUfXv8wvx6zLfIzIX4C9w+/v5la5lw7kvN4daVlKu/cEYnM6h/bjC1qHHcMQtBVQXEG1xv0zJq7jD2lady16i6WHl/K1MSp5qm/NXn6n6fZeHojSQVJeGo9eXvq24yIHWF3XVlVGfesuoe1KWsB+PzA5+ZzQV5BXNbjMuKD4tmesZ1zOp3j3O9RiLoIMv5sKTQGItlHq51vp9aiOXsh/P6g5biuomnaVwsJRJwgo6CMZ5eqBazOGxBHkG/bWeNh/RFV+XJM15pzGx7/+3FSilJ4dtyz/HD4B17d/qrD6+4beh9X97naJe10NoPBgN4AHtqaf/N96HtLt/2f90yga/QZ1o8Q9VecCQY9aDyIiexJmKEbA6IGsDNzJwtWLuDds95Fq9Hi6+FL74jeaDQaNqdtZkvaFt7d/a7N1OoqfRXPb36eAVEDuLDbhZRWlfLilhfpHtad9oHtzUGItZ7hPflsxmfmujZxgXFN9q0LYSMkQb3mJqnX7Gr1jNobh1RH3apKwX96odr3bv6fSxKIOEF2sSWiPJhWyNCOzh3vd1efbTzBwz/swctDw9ZHzyLYKgDT6XW8seMNSqtK+f6wqiZpXQjLpH1gex4d+ShFlUWc1eGsJmt7Y12/eAv7Txew7O7xNt+3icFg4EhGEQC/3D5WghBXKTauNRQQBVoPvPFg0dmLeGDtAyw/sZxrf7/WfGmv8F4MbTfUXI3VmqfGkypDFYdyD3Eo9xDfHPrGfG5f9j6ba0fFjiLUN5ShMUOZ2Xmmy4rrCVEv0T3Va4bx32v1HhFvq0U/u06BYdfD5vehKL1p2lcLCUScINcqENl/uqDVBSIGg4EKnR4fTw+bYx+tTwKgUmcgLb/M5gN5fep63tv9Xq33HRg1kBv738iY9mNqvc4drTigPgB/3J7C1aM62p0vKKuiQqdmnEgQ4kIlxkIs/pb/c94e3jw28jHWp6ynpKrEfHx/zn6b4nEXd7+YPhF9OK/LeXh7ePPpvk95bvNzDh+j1Wi5pvc1XN7zcmIDW+7wmmjFoo1T1nOOwaHfLT0iQXFwzc/21w+9VgUihaftzzUxCUScIKfEEogczSxuxpY4n8Fg4M4vd7B8Xzq/3zWexAg1JTI1v4zDxt/4ATIKyukaHYAGDQ+sfYDfjv9mPhfuG84FXS/ggz0f0CG4A29NeQtfT1+i/JsucdOZyqt05u3D6UV25zMKLUN1QT6ebrNabqtUapyV5BdmczjUN5SnxjzFA2seQGfQ8X/D/89mTZsvZ35pV2tkbq+5HMg5wE9Hf6J3RG8i/SJ5fNTjeGg80Gg0Tp/ZJIRTBUaBRquGKlf+GypVYUMueBsiHaw/ZcopKcmGsnxVlbWZSCDiBDlWPSL5pZXN2JLGsS6MZbJ0Txo/71TZ1xuPZ5sDkfSCMpvrvj76AQs2qAQ+69oTUxOn8sKEF/DUejIxYSKJwYkt+gd6fkklheWWv+OkbPvA8/rFW9h1Sq0VExnUvIuvtXqlxh6RaoEIwNkdz6ZPRB9yy3LpF9WPbqHdOJx3mK6hXR0WPNNoNDw99mmeHvu0q1sthGtc8I6qG5JmNa08oovja/3DLRVZj62C3rObpImONN864q2IdSBS0EIDkSVHlzD8s+GsOLnC5vgH6yyLu+WWVJCWX8bVizbxzZZTVlfp2ZD5M3qD3iYICfIK4t5h95rrZQyMHtiig5Cc4gpGPbuCyS+tNh9Ly7cNyFYdzDAHIQCRgZI/4FI19IiYxAfF0y+qH4C5wqmjWTFCtAq9zweNVQ9scHs1NFOTbtPU6+E/XNqsM5EeESewCUTKWl4gUlxZzEPrHgLgf9v+x5REtSCSTm9g16k883WZheU89cte1hzKtHm/1jeVMr2ql3Fd3+uI8o9iTvc5aNDUuoBaS3MovZCSCp3NscMZRXy4/jjzx3QCMA/JmEQGSo+IS5UYAxH/lhvgCuE0nt6qByTrkNofe7eqplqTnjNV1dUurl8ErzYSiDRSaYWO5fssWcfuOjSTV5ZHpb7SLi+juLKY+9dY6nZklGSg0+vw0HpwOr+USp1pBQADG3O/IKP0NFrfYRj0Phgq1L08Aw8CMDF+MncNuaspvp0mdTq/lCqdwSYp2dqTS/Yxf0wncosrOJBWCECgjyflVTom9Yhuyqa2PWfoERGizYnqYQlEYgfWfm3HseqrmUkg0kjrjmRx2qp7vqC0bkvHO8PRvKP8c/of5nSf43AKod6g51DuITJKMrh39b2UVpUyIX4CL054EV9PX5Lyk5j/+3yySrPM7ymuLObDvR9yfb/rOZltmXGg9T3Fcd2P4A0BnTaq+1dEMDH0XlYXrgego797lf52Br3ewLT/rqGwrIr7zu5R43UGg4Gdxt6jzlEBrPzXRIc5N8KJDAbINPZA+UmPiBAAhFvlhFSvpOqmJEekEXR6Aws+2wbAmK4RQN16RF5efogxz67k76NZZ7y2JgUVBdy4/Eae3fQsL215CYBP9n3CZb9cxppTa6jSV3HHyjuYs2QOC1YsMC8Nv/rUal7f/joA7+1+j6zSLDy1niw6exGPjnwUUMMz/Rb3476Nl+Db/jO8PPT4RK60a4PWO5s1JQ+i8SjBoPOlo9/wBn8/7qqgrJLCMhVcvvD7wRqvKyyvIrtI9Zi0D/UDkCDE1ZI3Qqr6/0fcoOZtixDuwifIsh3YMnpkpUekEf7Ym2auFTGlZwzrj2RTWqmjokqPt2fNMd4bfx1Bpzcwb9FmDj1zDhkFZSTnljCkQ91/q3tpy0tklKhaFp8f+Jzssmx+T/odgAUrFjh8j5fWi0p9JV8c+ILzu55vvv7Dsz9kYPRABkYN5PXtr5Nbrrq7C6oy8QrOJDJYTz77MRi0aHTB4Jlnd++ytAuoqgywO95SGQwGVh7IwNOjbrF6Sm4pb61WBYTCAyRBtUmYZgZ0mQKx/Zu3LUK4i96z1fTdqJ6qpHsLID0iDVRWqePRn/aa968YYekCqy1htUqnR6dXeRemIGbqy6u56K0NbD+ZW+P7rO3N3muuVjq2vRrfMwUV1Z3f9Xzm95nPbxf+xtYrtzIwaiAV+gou+PkCynXl9AzvyYCoAQB4eXjx0sSXGNN+DOG+4fhg7OVBfZ+VeUMpOnYblfkDKTl5LdrS3gAEaOKoKuxNTrF75sc0xIaj2Vy3eAvXLNpU4zUz+rWjU6QKvh7/aa+5kqoEIo2UfRQ+uRCOr6n9OlMp6+heLm+SEC1GZDe4bStc6/gzwR1Jj0gDPbv0AFlF5QDcO607vl4eBPl4UlheRUFpZY2zJd5cZSm7a+o1KTB2/f91IINBifZJd5X6SpYdX0ZicCJ/p/7NmzveBKBjcEfenPImK0+u5LnNz1GuK+f1ya+TVJDEX8l/4aHx4NGRj9rkjzw66lHm/nolZTo1VHN+50tshhCGtRvGxn2hbDx4nNLKKoj6DK+QXYCGyryhGHSBlKVeBsA5vafwwMxEXl1+ikWGE+SWNP/iSc6yPTnPZn9AQig7jceuHtWBUZ0jGNstkms/2szxrGI2JeWYrw33l0CkUZbeD0dXqK8nLFOhyTkO6XtVpr9Go/YBwjo2SzOFcFuRXZu7BfUigUgDffrPCfN2Qrgq8hXs56UCkbKaE1ZfXn7IvF1Rpaes0jIdtKxKb3Ntpb6SO1bewbqUdXb30aDhxv43otFomNJhCpMTJ1Olr8LLw4t+Uf2Y1WWWw+d3D+vOIwMX8dCG2zDofegVNNHmvMFg4MU/LG0k9QoWz/43Kw+d5p39eTbXnjcgjlDfUCICVa5LTg2zSlqiYF/b/xrh/l48dm5vvth0kpsndCHOmAcS5aBgWaj0iDROQarj42+OhCpjYvidOyHXFIh0app2CSFcQgKRBtDpDTZDb9FBvoAKRFLySmtMWC2tVoMC4FSuZWZKcbltALMmeY1dEBLjH8Ntg25jdpfZNj0ZGk3da3YUFAVRfPRfgJZTuZUMtkqsXn8k2+76AXEdOJnpBeSZj31xw0hGdVFDN6ahiJqmt7ZEReW2f1dhAd5cO7YT1461/dCLDfGzf7PBYH9M1J1/hGW7rAB8g0FXaQlCAH6+w7K4V02VI4UQLYLkiDRAck6Jub7GdWM7MbKzSjIN8VNx3UfrjzP9lTU2QQZgHsqxlpRlueazjSc5YSwZrtPrWLRnkflctF80G6/YyJ9z/uT8ruc3akbG0YwiTH/1J7JsS5Q//avtSqPL7hqHr5cH0cG+5mNjukaYgxCAMONQRE4rGprJK7X9XmoabjH1jFgLlaGZxtFZBfKmegg5x2yvOW6pbktoB9e3SQjhMtIj0gCH0lXRqt6xwTx6bm/zcdPqs38dVJVHxz73F5/fMAJvDy2dowLJNvYYxIX4Ul6lJ7u4wm6tkm93HCCy3R4+2/8Zp4vVqojj2o/jvmH34e/l3+i25xZX8PWWZPN+crVgKSVX5Y5cNiyB8we1p2e7YABigi1DED1igm3e0xp7RKxL9Ws0MKGH4wX62of62uxfMSKRc/q2c2nbWj3rZclzkyB+KGxdXPP1tVWOFEK4PQlEGsC06mz3GNvl3YP97IdGrnhPFf+a0iuaS4aomv+RQT7klZZR6L+U5zasBsYCGnyil/LRqbVgXMbFU+vJC+NfYGqHqU5r+85TeTZlytMKLL00ZZU6Co3DQw+e04sQf8v30z7UDz8vD0ordVw9yvY30PAAdV1uSSUZhWVoNRo8tRqOZhYzpEPLrHiZV6ICkbN6x3DrxC4Ok4jB0hsEsOOxs6Q3xBmKMizbuUmg18OWRY6vHXVbkzRJCOE6EojUQ2FZJXd/tYM/96sflL1ibXsGQhwEIgAajyI2lP2PjVvS8Qi4Bj+vUeR4rcLHV3Uv+8YstXuPrjyKOwc+5NQgBOBYpuqBCfTxpKi8inSrqrCmHhsvDw3Bfrb/NIJ8vfj2llH4eGrpGGlbL8T0YZxfWsnUl1ZTWqkzD139cvtY+rZvvuWlG8rU63Vu/9gagxCAHu0sxYNq+vsX9VBeBJVWvYQr/w1Zh8FYkI8Rt8DGt9R2j5kw+ZGmb6MQwqkkEKnGUVnu4spiDuYcZP3eAHMQAjCtj20XfIC3B7Z0aDyL8I5ciYevGmbxT/wQb69wKsp3OXx+Wdq5VOaOAjx4+lg5Vw7S4etV/b4NdzRT9eaM6hLB8n3ppBVYBSLGHJaIAB+HOSh94hwHFCF+Xmg0Kkez+oyhpOxicyCSUVBGkK8XfnZ/Tu7l7yNZHDUGbGcKLkL9vVlz3yR8vbVSSbUxirNUkmpxhv25XV+q1+D2cM6zMOF+OLoSuk8HLwfJwkKIFkUGV628svUVxn01jn3ZKmHzcO5hbvnzFiZ8NYFrll3D2qzPzNcmhvubi1mZ5JZUgkcxUIVP9K8E9XqYwG4L8Q7baHPdjsqXKNWqqYflmZZVD6cnziawfBJg+aBeuue0U7/H48bk1FGdLSXpTVOITcm0kUH1G17w9NDW+IFdZAxMjmQUMerZlSz4fFuD2t2Uftlt+TMf2vHM1W4TI/zNM6dEAxxbDS90gT+fsAzL+EeoJc2tFaQYz4VDv4vBx3ZoVAjRMrXZQKRKp6e8ypIrUa4r54M9H5Bfns+9q+/FYDBw+8rbWZeyjnKd+oA+XLYUjbG8eai//QfvkB45BHV7mqBej+AdsdbmnK60PSUn59scM+i9qMiawh19n+SKnlfw9PhHWXXfJD6/YYR52OfXXc4NREwL9PWOC8bf2DNhOpZVqIZmIgLqv3R9QQ1Tlk3rtPy0IwWdXpVNP5JRaJ4d5I7+PqLqonxwzVACfaTT0OX+fEK9rn8FDi9X2xFd4ZLFahlzk4QRTd0yIUQTaLM/Ze/6agerD2byyx2jKNCfYPnJ5eZzyYXJLEtaRkqR+g0s2i+aCL8I9ufsJ7Dbs+grwkF/h9099xWsA41tDYmrel3Dyt16Dp5qj6EqlE662zjuoRadU0MwWi7qeS7hARcC4OMHo7tE8sLF/Tn3tXX8cyyH5JwS4sP8Gt31bzAYOJ2vxtpjQ3yJD/PjUHoRyTkldIoMMM/gcTQl9UwGJISy/WSe3fFCY7l7D62l7VNfVqW72wX7ctOEzswf4z4FqcoqdSQZVx0emBDavI1pKzytAt+1L6pX02Jdkx6GrlNh748w6tYmb5oQwvXaZCCSVVTOL8aehsfXvMbWgi/trrl/zf0AJAYl8uH0D8kvz+fCn1WwoPXO4ThP8MNhLR1DOjIoWq38uT1jOwAzO8/E39Ofq3pfRaeQTpSm7+XA4SQAugSM4LuLr+V4ThbTXtpGVJAPYQ56V7rHBOGp1VBUXsW45//inrO6c8eUbnX+HnV6A1qN7QqwahhGVW+NCfYlMdyfQ+lFnMxRH7wH01SCZk+rBMy6untqd37ZlcrdZ3Vn1ELLSr2vrjzCrAFxnM4rs3tPWkEZTy7Z51aBSJqxd8jPy0PWjKlOrwOtC/J79A4qEQfGqFcPL+g4Vn0JIVqlNhmIrNiv6hRovTPsgpBLe1zKD4eWUGEowYsgPpz+IdH+0UT7RxNRfAPZAe+Zr33s78cAGBg1kAdHPMihXFV86Z4h9xDtb1l+uVc7y+yaqCAfvDy86B4Vy7r/m4S3p+MkR29PLZ2jAjiUrpJLX15+qM6BiMFg4PJ3/yE1v5Tld08wJ4eahmDCA7zx9fIwl6Y/kFZgfG14IDK+exTju6taG59eN4KHf9zNCWPPwln/rX3xsrWHM9FqNIzpGlnv5zpbap7qMYoL9ZXkU2t7f4Bv5sNF76v8DGc5uhJObbY/HiS1WIRoK9pkjkiwnwbf2G8J6PIyAFqNB73DhhDsGcmCgQvIPXITFTmjyDt2LVF+6sP1VG4JJ5I7U5J8De9M/Ir+UZZlx3dk7uDSXy5Fb9ATHxhvE4QANtNXO0ZYElzjw2pPcuwWU/+AAOBkTgmbknI4lVvK3lTLomGm3/bbGaukJhoDkU//OcmRjCJSjB/CnaICaIyx3SK5flznOl9/7Uebmfv+RpbsrGGNkSaUYg5EZDaGjZ/vBAzw3XXOve+e7yzbGqsfRxF17/0TQrRsbTIQSWcFXqFbzPvFKeez8e+LSdl9L4dPG/DUxVKePht9eSwHjfUk/tyXjsGgYWjUGEZ36M0H0z7guXHPcX7X823uPThmsN3zescF89KcATx/cX8uHZZQ53bGh9l+GJZV6th+MhfDGdYyWbYnzby96mAm7645SnF5lTkHxHTfyT0tAdMrf1oWunNGPQz7qcw1M9UcWXc4q9HPbaxTxsqycY7WkBFKforz7pV1WL1e8A6EW60ZE9XDec8QQri1Njk0MzB6IAOiBrArLYmiE/PRl1u6gf/Ym0aFzrIK7o6TefRsF2ye9jowMRQAX09fZnSewYzOM7im9zVc8PMFAMzpPsfhMy8aEl/vdlb/MOz56DIAnr2wH5cNT7Q599hPeziYVsi/z+/LS1Yr/L7+1xEAlu9LJ91YRbVzlJr22CEigMXXDueaRZvMOTPenlp8PBufB1DsYIG/XrHB7D+thoHC/L0oq9RTarX6cE2LBTYlUw9StxiZGgqo4jAbXodyS88ap3dCSHvn3DvzoNqO6QN+VoXjwuveoyaEaNnaZI/IwOiBfDrjU76Z8ZtNEAKw61S+zf6O5DwAThgTOjuE2w9bdA3rylOjn+K5cc8xMHqg09oZG+J42OaB73dz91c72GlsW0peKR9vOMHG4zlc/NbfVFTp7d6zOSnXnJTa2WroZXy3SMZ1s+RmBPs6JzbtFm3/QT44MZQrRqgA6s4p3WyCEFDr3pgCleZQXqVjrbFXZnALLU3vdIeXwx/Vqpem7XbOvUtzoSxPbYd3gWlPQ7v+MPga25k0QohWrU0GIiY92gXbfdhvSsoBMBcrO2bsCTlpTLzsGOF44bkLul3AjM4znNq+djUEIgA/bE/hnq93AKoXx8RU2fTKkYmO3gZAlyhLkKDRaJjQ3bKgW5Cvc8qUj+gUzmuXD+LDecPMx3rHBfP4rN58f+torhrVkQHxtpVa96YWcM7/1prLqze1N1YeobxKT4C3B72rle9vUw4vh/S9ajtjr/359D3OeU6hsUaOfwR4+0PiCLh5LZz3qnPuL4RoEdp0IALUOEVzkHEIZtPxHH7akWLOHTDNNGkKsQ7yFG6aYOmyNpUhX38k2+66i4c4zkVpH+rHYOP3ZtLVqvfCWQW8NBoNswbEMapLhPlYx4gAfDw9GJwYhodWw1Oz+zp879YTuU5pQ33tSlG9YXNHdnBqWf0W5fRO+OxieGu0GjrJOW5/Td5J5zzLVEU1ILr264QQrVqbD0QCvB1/8FpPub3zyx1U6PRoNbX3UjhbVJAP7141hOcu6sfgxFBevXwQd0/tziTjkvQdIvyp1OnZdNw+EOkRE8RVIzvYHX/h4v5201KtAxF/J68D4+vlwcx+sQxODGVYtXLpAxJC2f7oWdw03jYfILekwqltqKtc44q7Q9vysEzKVsv2+ldg22LL/sUfqtf8U855VnGmeg2Mqv06IUSr1iaTVa2dyi1xeLyHg1oaqgZI08ZupoX1Lh1mGWp5bFYf/jq4iqzCcpbvS6egrMq8mi5AkI8nft4ePDW7D5cMTSCruJz5H6paDYkOhpask2JdkTD6xlz7mUQmYQHeXD+uM++sOWY+5qj4WVPIMwZAYW25kFnWEcu2qfS6fwTcvB68jEF4SRZUlKjhlMaQHhEhBNIjwp1Tu6HRQEK47TCIoyGYdm4ypTMqSCXyFVfo+GmHmkp5pVXvh6ntGo2GfvEhTOwexdWjOjB3RCLtHdTH0FqVX08vaPogINjPNh7+5J8T6PS1T1F2ttdWHDYXYHNU6bbV++Vu+O4GSHeQiHrPfgiOBd9Q8DYG6FmH7K+rL9NKuwHSIyJEW9bmA5FLhyWy98mzue/snjbHHeWOxAa7xwqrAd4e+BlzGP45ppJrByaEmiuiWueRgApInprdl2cu6HfGaqGmEvBNydF04W+3JjdpG6ynPIf5t7EekcI02LIIdn8Nx6tVwfXyt8xg0WggdoDaXv+/xj+3SIZmhBASiADg7+1JhFXg4anVEOzryb/O6m5zXVPmh9RGo9EQE6w+HExDKV2iAlg0bxiLrx3O7IH1r/HwxhWD8fPy4JXLBjqzqXX230sH2JSwX3Uws1naAc4p6NainN5V7YAGZv1PvU77t+2p8feq173fw+rnG/dcU+9LmPusNSSEaHptPkfEJDLQUrcgLMAbjUbD7VO6cdOELnyzNZkV+zPqVRXV1XrHBZtXidVqVO6Hj6dHg0uTz+wfy/S+7WxWyW1KFwxSBd8mdI/iorf+ZuPxHAwGQ7Os9+LZxHlAzaKqHLZ+BJ0nqVdr4Z1hyDzoNwe8q9XNaW+V7/PXMzDuXtA24M+rLB/SjNOAO4yu//uFEK2Gy3/ivvHGG3Ts2BFfX19GjBjBpk2bXP3IBokMtPSImHobQFUanTuiA4vmDaOXG9WWGBAfat5OCPd3SjXU5gpCrJnqd+QUV/DMr/ub5Jn6Js5HcQtbPoSl98Mbw+Dgr7bnEkao1+pBCICvbe0X88yX+krfCxggJFEWuBOijXNpIPLVV19xzz338Pjjj7Nt2zYGDBjA2WefTUZGhisf2yDWeQH+Xu7fUTQwIdS8bV2grKXz8/bA10v9s3x/3fEmSZ4tLLcsQ7/2/kkuf16zMxhg9ze2x2Ksarp0P7v293tY5dA4Sm4FKEhVPS26KsfnC41F+ELdp5dRCNE8XBqIvPzyy9xwww3Mnz+f3r178/bbb+Pv78+iRYtc+dgGsZ454uPl/l3z1iv6BjipCJm7sE6YzSoqd/nzCox5Nj6e2iYtWNdsdn4JKVtsj/WYAVd8A1OfgF7n1f7+G/6ybH96kRrmqe61obDkTtj2keN7FMmMGSGE4rJP3IqKCrZu3crUqVMtD9NqmTp1Khs2bHD4nvLycgoKCmy+mkNLSFa0Dj5qWpOmpQqy+t5yil1f3KygTAUiwS3g790pdn2lXsfdC2PvUcMj/S6G7tNg7N1nzvlo11etCWOSfUTNojnyp9ovK4BKVfWXU1vt3w9QlK5eA2Ma/n0IIVoFlwUiWVlZ6HQ6YmJsf9DExMSQlpbm8D0LFy4kJCTE/JWQ0LTdtndM7qpmy0xrGUuQL5o3lFkD4rh9ctfmbopTvX/NUPN2dlETBCKlavjAWQv+ubWKEjixXm0PuAymPg5374aoev6bP+spy/a6V2D5Y8bekQr47V7LOV8HeVVrXoR1L6vtQClmJkRb51ZjEA8++CD5+fnmr+Tkpq0lcc+0Hux4bJp5wTt3N7lnDK9dPshpC9W5ixGdIzhvQBwAn288SUpeqUuf12p7RPJOws6vVE4IqBoh384HXQX4hEBEIwLYLpNgwOVqe/fXluOb3rH0uIAagslNghN/Q2kebH4fVlpNCZYeESHaPJf9ChgZGYmHhwfp6ek2x9PT02nXznGWvI+PDz4+zbv8t9YNZo4IS0G5TUk5THpxFYeePsdlz8osVDkOEa2ttPvi8yD3OJTlQUwfWDzLci6kvSpQ1hgxDhYt/OMR2/2936uvmoR3rvmcEKJNcFmPiLe3N0OGDGHFihXmY3q9nhUrVjBq1ChXPVa0EtbTqSuqXFvtNdXY49LQGixuSa9TQQioabofzbQ9HxzX+GcMmVdzj0Z0nzO/f+w9UkNECOHaoZl77rmH9957j8WLF7N//35uueUWiouLmT9/visfK1qBiMCm6xlrlYFIxhlqsDgjEPEJtE1atRbZzfFxkxG3qPyUZihYJ4RwLy7Nzrv00kvJzMzkscceIy0tjYEDB7Js2TK7BFYhqmvKYZLUfFWrpFUFItlHaj/vbb+6dIO0HwJHlqvtHjPg4G9qO3EUFGeBX6h6Tf7H9n2hiQghBDRBiffbbruN2267zdWPEa1MRKBtIFJWqcPXy756rE5v4K1VRxjZOYKhHcMb9CxTj0j70FY0DdpRxdM5H0HmITVjpfds5zxn7N1QUQS9ZsGhZZZAJDAa5hsrth76Az6fY/u+kHjnPF8I0eK1gfmKoiWKCLAdmskvreTB73ez/3QB390y2lxH5dutybz4h1o5N+nZmXb3OROd3kBaa+wRKcm2PxYUC30uUAvXaRu/JAAAXr5w9jNqu9BqWr6/VVDYdSrMeBH8wuC769QxqagqhDByq+m7QphU7xFJzSvlh+0pHEgrZO3hLPPxrSdyG/WczMJyqvQGPLQaooNaYY9I/HDLMdOaLs4KQqprP8Sy7WU1BV6rheE3QKfxlmPB9V8hWgjROkkgItxSYLWy9f8cyzFv/7wzxbxdUqEzb5vqgdSHqUZJu2Bft1j0z2mKjcFazxnq1S8MgpyQoFqbkHhVpdU70HGBtIAoGHglDL5aSrsLIcxkaEa4JU212RTvrT1m3v5tdxrbT+YyID6UQ+mF5uOn88oIbmdblMxgMLA3tYAuUYH4edv3BJzON82YaUW9ISU5llkzIQlwzwE1O8XTxQnAGg0s+AcqyxxXVNVo4Pw3XNsGIUSLIz0iwm29feVg83b1NWcOphWydE8ah9KLzMdS8+0rsP66+zTnvraOGz62XeRtc1IOj/20hyMZ6v2xIa0kPyT/FLwxArIOqv2ASAiOtQzLuJp3AARENM2zhBCtgvSICLc1vW8sD8/oxTO/2dfEyCoqZ+epfJtj6cakU2uL/04CYN2RLJvjc962XXgxKqh5K/o6hV4P38yH4gzLsciWsW6SEKLtkh4R4dam922HKXVjeMdwbp3YBYCUvDK2nlB5I0HGxepyS+xzREzLrJxJeGso7559BE5tsj0WHNs8bRFCiDqSHhHh1hLC/Vn5r4kE+noSGejDxxuSAPhi00nzNZN6RPPzzlTySu1X6q1jHEKofytY8C43ybId2gEmPtBsTRFCiLqSQES4vY5WqyGHVFshN8TPi27RgQDkFTvqETHYbFdPgjUJ92/BPSLlhWqmSt4Jtd9jJlz+efO2SQgh6kiGZkSL0ifOdjZG56gAQo3DKidzSnh1xWFOZpeYz1v3iBSUVdV439CWGojs/REWxsPWDy09ImEdmrNFQghRLxKIiBala3QQ143tZN7vEhVImHFYZcOxbF5efogrP9hoPl9SbqkzkldiGbrx8rDtGWmxOSLfXKNef7kbMg+o7VAJRIQQLYcEIqLFuXSYpTz4uG6RhFXrzTiZY+kRybEKPvKMyawVVXoqdbbZI2EtMUekeibukT/Va+eJTd4UIYRoKMkRES1O58gAxnaNxN/bg1n949h3usDhdVU6PdlF5eb9XGNQUlJhGaKJCvLBx1PbMntEco7ZH4vsAdE9m74tQgjRQBKIiBbH00PLp9ePMO93skpmtZZVVIHeqtPA1CNSbCwL7+2pZe39k9AbDHh6tLDOwZIceM1Y8C2sE1QUq4XuznmuedslhBD11MJ++gphL8DHk+9vHW13/HS1SqvmHpFy1SMS4O2Br5cH/t5uHI/r9XByowo0TMqL4CWrQmU9Z8KdO9RXl0lN3UIhhGgUCUREqzAgPpSYYEt1VJ3eQFJ2sc01poJnRcZAxK0DEJNti2HRNPjqKsuxv18DnVXNlJG3qNLqoYlN3z4hhGgkCUREq+Ch1bD6PktvwMvLD3L3VzttrjHNmskrVQFJgI/9InhuZ+Pb6vXoCvVqMMDWj9R2cHt46LRa9VYIIVooCUREq+Hr5UGQj+rl+Gpzsvl4ZKBKRDXliHy79RQAcaFutNDdyY0qwKistl6Ovlrtk8wDUJQGnn5wx3bw9m+yJgohhCu0gL5pIeouLMCbwvIqsopU78fT5/fF21PL/d/u4uedqdw2uStbk3IBmDe6YzO21Er+KVh0NmCA1O3g4QN9LoAOo+wDkaR16jVxJHi2goX6hBBtnvSIiFbFOk/E20PLpcMSiLCamjv3/Y3mHJGOEY5n2zS57KOYa8Bu/Qg2vQNfXKb2dQ56RADiBjZR44QQwrWkR0S0KtHBvubtjpH+eHlo6RMXYj6WWWipKxLo28z//A//CRVF9r0eAGV5kL4X9Fbr51SUqBV2ASK6NUkThRDC1SQQEa1KTJAlEEkIU/kT7UJ82f3ENPo98YfNtUHNGYhk7IfP54BBD92mOb7mrWpTkv8Ta9mO6Oq6tgkhRBOSoRnRqlgPzSSEWxI5g3y9CLUq4+7tocXHsxlnzax7RQUhAIf/qPVShyKlR0QI0TpIICJalRiroZn4MNtZMaF+lkCkWXtDKkpg/8/2x3vNgph+Z35/vzngH+78dgkhRDOQQES0KuO7R6E1Lqzbs12wzbkQq0CkWfNDco5CZQn4hUPCSMvxyO5wyzq4cRUEtqv5/RMfdHkThRCiqUiOiGhVwgO82fDgFHadymdM1wibcyFWq/Q2a49IYZp6DWkPV30P6/4LB36D4Teq43GD4N6DkHsCkjdC9+kqeHl3ojof3rlZmi2EEK4ggYhodWKCfTmrt6/dcZseEZ9mTlQFCIpVpdknP6K+qgvroL5ABSfXrwDfUNBomqypQgjhahKIiDbDNkfEq5YrXWTlM7DnO9W7ARBUy/CLI/FDnd8mIYRoZhKIiDbDukckuKkDEV0VrHne9php1owQQrRhkqwq2gzr6bvW202iMNX+WLv+TdsGIYRwQ9IjItqMYKseEethGpfLS4Y/jDkgoYlw9U9wcBkMvbbp2iCEEG5KAhHRZlgHHyFN1SNSVgBvDFfTdQHCOqpZL6NubZrnCyGEm5OhGdFmhFpN3w1pqh6RY6ssQQhASGLTPFcIIVoICUREm2EdfFgHJS6j18Ffz9ge6zXL9c8VQogWRIZmRJthnaAa3BQFzX5/GDIPqO2EkTBoLvSY7vrnCiFECyKBiGgzrHtEvDwa2Rm4+1vIOQ7j7625wNiOz9Vrjxlw8YfgZV9kTQgh2joJRJxBr4cvrwC/ULjg7eZuTdNJ3wffzgcvP7juT/Bw739Ovl4edIzwJ7u4gq7RgY272XfXqdfono6HW8oKoDxfbV/4ngQhQghRA/f+5Ggp8k7AoaVqe/IjEBLfvO1pKkvvtww95J2AiC7N2546+OPuCej0Bny9PBp+k6oKy/bRv+wDkaR1KjAF8A0Bn0YGPUII0YpJsqozFGVYtk/+03ztcAWDAX69F/7bF/JTLMcLUiFprWU/P7np29YA3p5a/LwbEYRsWQR7v7fsmwIxk+Js+GgmlBl7Q4LbSFAqhBANJIGIMxSlWbZTtzdfO1xhx2ew+T0VaBxfrY7lHIecY7bX5bWMQKRRMvbDL3fDDzdZjp1YD6e2Wvatz4FaYVcIIUSNZGjGGQrTLdvWvSOtwZoXLdv5KWq5+i8vB89qOQ/5p5q2XU2pogT0lZB7wvH59yfDE/lQmgvH/rI9Fz/c9e0TQogWTAIRZ7DuESnJar52OFtpHuQet+wXnIL9P6vtqjLba/d+DxPuB20jhj3ckcEA706Esjzoc0HN1+n1kLwJ9FUQ0Q1uXqfyZsLdP29GCCGakwzNNJZer6pnmpRkN1tTnC7zoO1+/inAYHus57mABrIOQcpWWp2SHMg6CEXpsLGWGVElWZC+V21HdFGzZKJ6uP1MIiGEaG7yU7KxktbYfgAX1yEQKc5WH26Jo2quQeEOMvapV41WLVmfcwy8/G2v6TAaijMheaNKYG0tygrgi8shvFPdrt/xOax4Um0HxriuXUII0cpIj0hjlBfCx7PVdsdx6rUuPSLfXQcfngM/3ab2DQaoKndNG2uiq1IlyGtjmhHS/zLw8FGBSPoe22u6TLF88Bal02rs/BJOrIPtn9ifSxgJcYPVKrrth6hjfz5uOR8U2zRtFEKIVkACkcbY+4Nle8g89VpVChXFNb/HYLAkNO74VL1+fyO80A0KTrukmXaqKuCtUfDuBDW0VF3yJlWePGWb2u84BnrOtL+u3xxV0CuondovTLO/pqUyVPtz6TIZRt4KWi847zW48S/oPNFxzZjAqCZpohBCtAYSiDTUkRXw8+1qOzge+l6keg2g9l6Rv1+zbHsYF17b/bWqwrn1Q9e0tbr0PSqnI223bTKqyQdnwYbX4dQmtR/VCyK721/X3bhuSmvsEamsFkwGtoNpT8NDKRBl9WfhKBnVuuCZEEKIWkkg0lA/LbBsT7hP5Xr4R6j94hpmzhgMsPxRy76uwrb3pLaeFGcy5X5U3wbYv8T++qgeEFpt+fpz/6uCL2idPSLV/w5D4tWMIE8f2+MRXe3fKyvsCiFEnUkg0hC6Kii0GkYx/VYcYAxE8k/ByY0q8LBWXmB/rwyrypwbXlf3drWkdZZt00wPkz+fsN2fv1SVKLcORHrMgKHXWhJtA42BSGvqEbEOROIGwbDrHV9nPTRzwTtw31EITXBt24QQohVxSSCSlJTEddddR6dOnfDz86NLly48/vjjVFS0ki5r67Leo26DDmPUtqlH5OurYNE0+HCGKvVdXqSCEutZJV4B6jWjWiBgyhtxlZxjsPMLy372Ecu2Xg95J9X2jBfhti1qVgzYBiLdptneM8g4NFOYpu6fm6Sqr+7/xT4Yawms83jOfxtuXGX5Hqtr10+9ar2g/6UQENkkTRRCiNbCJdN3Dxw4gF6v55133qFr167s2bOHG264geLiYl588cUz38DdpZqSOMfB2c9YjvtX+xA6+Tc8m6hyQQbOhV7nquPRfaCiEPKKLXkmJvt+UkmrA6+AsA7Ob3vyZtv93CTLdkm2Gi5CA4OvAU9vy7nQRBV0eXipc9ZMPSIlWfDGCOM9jK79AxJHOPM7cL0Dv6gpyQCB0bVf6x8Od2xX05rdeSq2EEK4KZcEItOnT2f69Onm/c6dO3Pw4EHeeuutlh2IVFXAX8/Arq/VfvvBtudNPSLV6SpUIqopGTUgwliB9KTlmsgeqrbI0ZXqa/WzMPxGmPGCc7+HtF3qNWGEqv1hXba8wLioXWC0bRAC6kPWOuiy5h8BWk9VVVRXrdcr74QKRCqK4Yebocc5KshyZzu/VK/eQZYeodqEd3Zte4QQohVrshyR/Px8wsPDa72mvLycgoICmy+3sv0TWP8KFBqHWHrNtj3v5Wv3Focie4BfqO2xSz6GHtWmyG561/mL6JnqgJgSKoszLEmypqGj4Lj63VOrBe8Ax+dKc9Xrjs9Vefgfb7EM37gjvV4FggDzfwMvv+ZtjxBCtHJNEogcOXKE1157jZtuuqnW6xYuXEhISIj5KyHBzZL+so9atsM6QvwQ2/O+IXW7z7h7bIdxpj+n6nFc+gmM+5fttf+81aCm1ijbuGpu/HDwDVXbppV0TfkhwQ1YMTaghiEMU3Bjnfz56iD43wB4KhJWPVv/Z7lSQQpUlqicj+jezd0aIYRo9eoViDzwwANoNJpavw4cOGDznpSUFKZPn86cOXO44YYbar3/gw8+SH5+vvkrOdmFS8tnHVEryTaUX5j9sWHXw+Cr4brlcMkn0O8SGHYDhFmVCU8crXocEkdZjvU+T71qPWDKY2ol12v/UMd2fQWbP1BrnjRWVYVauA5UIBXVU22b1pQx5b6YEjDrY+QtENMP5v1qe3z9K/DrvfbThEGtaLtqIVSWuk/tjRxjsBnWUdaJEUKIJlCvn7T/+te/mDdvXq3XdO5sGS9PTU1l0qRJjB49mnffffeM9/fx8cHHx+eM1zWaXg/vTVLTaa/+SVXItGYwQH4yhCTYJiDmWwVGjj6sfUNU1U0TU4Dxy92wxVg4LMTY29BrFiy9TxVDc1QSvP0QlQBZWQK/3qOGNa7+qe7f41//UdNpZ/5XDZ2A6vEw6NV9A6NVfZDkf1Rxtn4Xq4qqAPFD6/4ck2HXqS9Qgdgfj6p7A2x+r/b3vj4MKorgss/rlpPhSqZZRI7qgwghhHC6egUiUVFRREXVrXx1SkoKkyZNYsiQIXz44YdotW5UsuT4KktNjz3f2QciO79QuQxTHrMdKjENXWg94ayn6v68+OGwZZHaNg17BMeq2Raevo5nW3h4qvoVJ9arfesVfs+kIBVWP6e2B19jSao1VVEN66ieGd1L7e/8HIbOt5xv17/uz3IkYTgMvsoSiJyJKcDb9VXzByKnjcm8kd2atx1CCNFGuCQ6SElJYeLEiSQmJvLiiy+SmZlJWloaaWluUnkzdYdle9vHsPtbOLwc1r6sekN+uUedW/GUpcBY+l44vQPQqPoajoZmatJ5gqobovW0DXrCO9eeGBrT13a/JAeO/uW4NkdZARQaC4qtfdlyfM0L8PH5qv2m4RHTh2zv2WpmCMCXVjNZ/GpPKq4TR4v4nWl2SU0VaZtKZSns/VFtmxYxFEII4VIuGQRfvnw5R44c4ciRI8TH2y4KZnCHAlfj7lFDI68bhyC+u85yLqqnWrjOJGULJI6Eg8Z8kh7n1H1peJPgOLhzB6Cp34JoEdXWMXne+NwJ/wcjblbBkEajhpo+nKF6NKY+YTsUYmr3W1Y9DaYej+A4uGW9Ghox1c3wDXFOboSjoasuU1Qeze8PqVlC38wHg9UKwAd+gc8vhYsX1TwLx5X+fEKt+ePlrxb6E0II4XIu6RGZN28eBoPB4ZfbiOymSpVXt+db233TkEjGfvWaMLxhzwuMrv+qrDX1IKx+TgUla4w1Ro6uhPTdKs/it3vVMVNPhyOxAyzbYR1g7F2W/fr09NQmYThc/iXMX2Y5Fj9MrWB772HodZ5avbe6Q8vg0O/OaUN9mZJ2h17bPIGQEEK0QW6UuNEMLnjb/tjhP233kzeqV9OaMFG9XNsma46WmI8fZtn+y1hgbM939tddWEtycPU8jHir4MpZgQio3qPEkZb9jmNUD05gtHo9/02Y/Sb4BNu+L9+Fs6VqU5ShXrtMbp7nCyFEG9S2AxHfEFVu3Vp5vno1/bZ+dCX88zZkHVL70T2brn2RPdSHoilnY/iNMOtVy/ngeKgsg0NL7d/baRwMvNL++Lxf7X/bt+4h8ahWUbWxNMacmpvW2AdWWg8YNBdu32Z73FTXpClt+dCy7k9gDevKCCGEcDoplKD1cHw8fhjs/kZtL/s/47VeakpvU9Fq4aof1Hb+KVU0zNNbzbZ5dZBaG2bbx6p6aUCUbZ6HT5CaSjziJpWH8e5Edc5RkS7rIaM8F/RGnGkGin+15NitH6mgK6aPw8td4pe7LNsSiAghRJNp2z0iUPNqqXGD7Y+Fdag5cHG1kHjL+i+mKcBVpWrKK8CYOy3XdpmiXrVaiO2vpgFf/TNc+Z39h351ppLsTUnrYT9leNMZao+4Uk1rBgkhhHA6CUSmPK7WeBl1m+1x62XvTcLqOVvGVTx9VA8IqFk9oPI8Zr6kpp2e85z9ezpPgK5Ta77n7DcBDcx+3enNrZNrf4f7j8NM49Tjg785nqbsCtWf4041b4QQopWTn7hxA+Hyz6HzJMsxjVb1lPS/zPZad1pl1aYHQaOGMYZdD/N+OfPS9Y4MmgsPpagKq83B21/11gy8AtCoqrDvjAe97oxvbbTKEsv21Cdc/zwhhBBmEoiYWBcWC4xRwwXnvwX3HICz/g19LlT5Fu7CujBaRBfwCWz8Pd1hyqqXH2DsoUjb1TSr9JZkq1cPHxhzl+ufJ4QQwkySVU1CrFacNa39otWqUuxj7mieNtXGOhCJasKZPE2t8LR9YTdnMwUi/hGOy+0LIYRwGekRMfENsWy7Q8/AmViXf/d2Qm+IO5n9pmW74LTrn2cdiAghhGhSEog4Ur3AljvSamHcvaqCqvXCfK3BwCtUAjHA99fDnu9d+zzTGj01zaASQgjhMhKIWBtxsyroNfmR5m5J3Ux5FB46BVHdm7slzqXRQGRXy/638137vJyj6rW+awgJIYRoNMkRsTb9WTWd19u/uVsigmpZldjZsk2BiItzUYQQQtiRHhFrGo0EIe4iuFogUltNkcZO8TX1iLg6KVYIIYQdCUSEe6oeiFQUQ8o2OPCb7fH8U/B8Z/j13oY9x2CAbOPaNtIjIoQQTU4CEeGeTFOoTYoz4L1J8OXlkLbbcnz9q1CWB5sbWBK+KB0qi1URu7CODW2tEEKIBpJARLin6gvPHVtt2V7zgmXbtNAfqF6T+jLlh4QkWNbyEUII0WQkEBHuyaNaHrX16rj7foKT/0BZgXo1yTlmf5+SHPjhZji+xvZ4eSGc3Cj5IUII0cwkEBHua/YbNZ9L3wPbFkNhquWYqXfD2oqnYOcXsHiW7fGvroRF02Ddf9W+DMsIIUSzkEBEuK9BV8KF79se8wtXr3nJcHi57blCB1VYMw84vvexVerV1IsS2K7BzRRCCNFwEogI99b7POh3CUT1gjkfWarIrn8FjhvzRrpMVq9FGfbvN+jr9pygmDNfI4QQwumkoJlwb54+cJHVjJg939me9w2BxNFwdKWaWaPXqZWTTazrj+iq7HNPTKonxwohhGgS0iMiWpb2Q2332/WHwGi1ved7WBgPWxZZzusrLdslWTXf13QPIYQQTUoCEdGyhHWA89+27McNsvRmVJaor1/utpwvtgo+ioyL2+msghMT6RERQohmIUMzouXpOcOyQvLIWxwnqYIairE+V2SsOVJeaDkW3kUN5UiyqhBCNAsJRETL4xsCN68FDx8IjrUEJdUVnAJ9lWXf1CNSlqdevfzhlr9VIFJT7ogQQgiXkqEZ0TKFdVRBCIBPINy+zf6anOO2+8XGWTVlBcb3BYOXL3h4uayZQgghaieBiGgdIrrAhP+z7O/5Hj453/Ya0/ReU8+Ibw09KUIIIZqMBCKi9Zj4oBpuAfjjUctxT1/1agpENhuLpEk1VSGEaHYyMC5aD41GzX7JPa7yQwDG3g2hHdRaNXu+haiecHqnOjfipmZrqhBCCEV6RETrEppo2fYNgcmPQWQ3y7FVCy1TeqN6Nm3bhBBC2JFARLQu1oFITF/QaiFxFIxcoI4ZdOoLwC+s6dsnhBDChgQionUJ62DZNvWEaD1g+n/AN9RyzsPbkk8ihBCi2UggIlqXsE6W7cgetucCIi3bfmEqp0QIIUSzkkBEtC49zoHYAYAGOo6xPRcQZdn2C2/SZgkhhHBMZs2I1sU7AG74C0pyIDDK9lz1HhEhhBDNTnpEROuj9bAPQqBaj0hokzVHCCFEzSQQEW2HdSDiH9F87RBCCGEmgYhoO6wDkQAHPSZCCCGanAQiou2wzhGRQEQIIdyCBCKi7fCXQEQIIdyNBCKi7bAZmpEcESGEcAcSiIj/b+9uY9oq3zCAX4VCQWRVWHg5bh0wUZQhQwvEsUjMiGiWzbko0zCGLjGZ6TLKDLLF1H1Qx5hvc7jAMMbsg/MlRnDMzA2RoYsylFoncbKphKFkVI3SjmVI2uf/wdD/mJPX0z5wev2S8+GctvS6c+DpzTnP6QkelzciEUZ5OYiIyIeNCAWPy787JDpRXg4iIvLhF5pR8AgJATYcAobdwDxFdhoiIgIbEQo2KfmyExAR0WV4aoaIiIikYSNCRERE0rARISIiImnYiBAREZE0fm9EhoeHsXTpUuh0OjgcDn+/HREREc0hfm9EnnrqKSgKL5UkIiKif/NrI3LkyBEcO3YML774oj/fhoiIiOYov32PyMDAAB5//HE0NjbimmuumdRrhoeHMTw87Ft3uVz+ikdERESzgF+OiAgh8Oijj2LTpk0wm82Tfl1VVRWMRqNvWbhwoT/iERER0SwxpUZk27Zt0Ol04y4//PADampq4Ha7sX379imF2b59OwYHB31LX1/flF5PREREc4tOCCEm++TffvsNf/zxx7jPSUlJQVFREZqamqDT6XzbPR4PQkNDUVxcjAMHDkzq/VwuF4xGIwYHBzFv3rzJxiQiIiKJpvL5PaVGZLLOnTs3Zn5Hf38/CgsL8f777yM3NxcLFiyY1M9hI0JERDT3TOXz2y+TVU0m05j1a6+9FgCwePHiSTchREREpH2z+u67owdrePUMERHR3DH6uT2Zky4BaUSSkpImFeZKbrcbAHj1DBER0RzkdrthNBrHfY5f5oioxev1or+/H9HR0WMmvs6Uy+XCwoUL0dfXp9m5J1qvkfXNfVqvUev1AdqvUev1Af6rUQgBt9sNRVEQEjL+Bbqz+tRMSEiIX+eUzJs3T7O/XKO0XiPrm/u0XqPW6wO0X6PW6wP8U+NER0JG8e67REREJA0bESIiIpImKBsRg8GAHTt2wGAwyI7iN1qvkfXNfVqvUev1AdqvUev1AbOjxlk9WZWIiIi0LSiPiBAREdHswEaEiIiIpGEjQkRERNKwESEiIiJpgrIR2bdvH5KSkhAREYHc3Fx0dHTIjqSKqqoqZGdnIzo6GnFxcVizZg26u7tlx/KbXbt2QafTwWq1yo6iql9//RXr169HbGwsIiMjkZGRga+//lp2LFV4PB7YbDYkJycjMjISixcvxrPPPjutW0DMFp999hlWrVoFRVGg0+nQ2Ng45nEhBJ555hkkJiYiMjISBQUFOHv2rJyw0zBefSMjI6isrERGRgaioqKgKAo2bNiA/v5+eYGnYaJ9eLlNmzZBp9Nhz549Acs3U5Op7/Tp01i9ejWMRiOioqKQnZ2Nc+fOBSRf0DUi7777LrZu3YodO3bAbrcjMzMThYWFcDqdsqPNWFtbGywWC9rb29Hc3IyRkRHcc889GBoakh1NdV999RX279+P2267TXYUVf3555/Iy8tDWFgYjhw5gu+//x4vvfQSrr/+etnRVFFdXY3a2lq89tprOH36NKqrq7F7927U1NTIjjZtQ0NDyMzMxL59+676+O7du7F3717U1dXh5MmTiIqKQmFhIS5duhTgpNMzXn0XL16E3W6HzWaD3W7HBx98gO7ubqxevVpC0umbaB+OamhoQHt7OxRFCVAydUxU308//YTly5cjLS0Nx48fx6lTp2Cz2RARERGYgCLI5OTkCIvF4lv3eDxCURRRVVUlMZV/OJ1OAUC0tbXJjqIqt9stUlNTRXNzs8jPzxdlZWWyI6mmsrJSLF++XHYMv1m5cqXYuHHjmG1r164VxcXFkhKpC4BoaGjwrXu9XpGQkCBeeOEF37a//vpLGAwG8fbbb0tIODNX1nc1HR0dAoDo7e0NTCiV/VeNv/zyi7jhhhtEV1eXWLRokXjllVcCnk0NV6tv3bp1Yv369XICCSGC6ojI33//jc7OThQUFPi2hYSEoKCgAF9++aXEZP4xODgIAIiJiZGcRF0WiwUrV64csx+14tChQzCbzXjooYcQFxeHrKwsvP7667JjqWbZsmVoaWnBmTNnAADffvstTpw4gfvuu09yMv/o6enB+fPnx/yuGo1G5ObmanLMAf4Zd3Q6Ha677jrZUVTj9XpRUlKCiooKpKeny46jKq/Xi48++gg33XQTCgsLERcXh9zc3HFPT6ktqBqR33//HR6PB/Hx8WO2x8fH4/z585JS+YfX64XVakVeXh6WLFkiO45q3nnnHdjtdlRVVcmO4hc///wzamtrkZqaiqNHj+KJJ57Ali1bcODAAdnRVLFt2zY8/PDDSEtLQ1hYGLKysmC1WlFcXCw7ml+MjivBMOYAwKVLl1BZWYlHHnlEUzeJq66uhl6vx5YtW2RHUZ3T6cSFCxewa9cu3HvvvTh27BgeeOABrF27Fm1tbQHJMKvvvkvTZ7FY0NXVhRMnTsiOopq+vj6UlZWhubk5cOcuA8zr9cJsNmPnzp0AgKysLHR1daGurg6lpaWS083ce++9h7feegsHDx5Eeno6HA4HrFYrFEXRRH3BbGRkBEVFRRBCoLa2VnYc1XR2duLVV1+F3W6HTqeTHUd1Xq8XAHD//fejvLwcALB06VJ88cUXqKurQ35+vt8zBNURkfnz5yM0NBQDAwNjtg8MDCAhIUFSKvVt3rwZhw8fRmtrKxYsWCA7jmo6OzvhdDpx++23Q6/XQ6/Xo62tDXv37oVer4fH45EdccYSExNx6623jtl2yy23BGz2ur9VVFT4jopkZGSgpKQE5eXlmj3CNTquaH3MGW1Cent70dzcrKmjIZ9//jmcTidMJpNv3Ont7cWTTz6JpKQk2fFmbP78+dDr9VLHnaBqRMLDw3HHHXegpaXFt83r9aKlpQV33nmnxGTqEEJg8+bNaGhowKeffork5GTZkVS1YsUKfPfdd3A4HL7FbDajuLgYDocDoaGhsiPOWF5e3r8uuT5z5gwWLVokKZG6Ll68iJCQscNOaGio778yrUlOTkZCQsKYMcflcuHkyZOaGHOA/zchZ8+exSeffILY2FjZkVRVUlKCU6dOjRl3FEVBRUUFjh49KjvejIWHhyM7O1vquBN0p2a2bt2K0tJSmM1m5OTkYM+ePRgaGsJjjz0mO9qMWSwWHDx4EB9++CGio6N956CNRiMiIyMlp5u56Ojof813iYqKQmxsrGbmwZSXl2PZsmXYuXMnioqK0NHRgfr6etTX18uOpopVq1bh+eefh8lkQnp6Or755hu8/PLL2Lhxo+xo03bhwgX8+OOPvvWenh44HA7ExMTAZDLBarXiueeeQ2pqKpKTk2Gz2aAoCtasWSMv9BSMV19iYiIefPBB2O12HD58GB6PxzfuxMTEIDw8XFbsKZloH17ZXIWFhSEhIQE333xzoKNOy0T1VVRUYN26dbjrrrtw99134+OPP0ZTUxOOHz8emIDSrteRqKamRphMJhEeHi5ycnJEe3u77EiqAHDV5c0335QdzW+0dvmuEEI0NTWJJUuWCIPBINLS0kR9fb3sSKpxuVyirKxMmEwmERERIVJSUsTTTz8thoeHZUebttbW1qv+3ZWWlgoh/rmE12azifj4eGEwGMSKFStEd3e33NBTMF59PT09/znutLa2yo4+aRPtwyvNtct3J1PfG2+8IW688UYREREhMjMzRWNjY8Dy6YSYw19pSERERHNaUM0RISIiotmFjQgRERFJw0aEiIiIpGEjQkRERNKwESEiIiJp2IgQERGRNGxEiIiISBo2IkRERCQNGxEiIiKSho0IERERScNGhIiIiKRhI0JERETS/A+HQONdx2ahnwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# A plot of the solution of the commutative-noise SDE used to compare the methods\n", "# A plot of the solution of the SDE\n", @@ -371,12 +430,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "id": "3f6e04f29792d26a", "metadata": { "ExecuteTime": { - "end_time": "2024-04-02T15:07:43.564266Z", - "start_time": "2024-04-02T15:06:28.474256Z" + "end_time": "2024-09-01T12:46:39.311682Z", + "start_time": "2024-09-01T12:44:23.197063Z" }, "collapsed": false }, @@ -397,16 +456,27 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "id": "9a887a880a90ecd4", "metadata": { "ExecuteTime": { - "end_time": "2024-04-02T15:07:44.059675Z", - "start_time": "2024-04-02T15:07:43.564994Z" + "end_time": "2024-09-01T12:46:39.529828Z", + "start_time": "2024-09-01T12:46:39.356969Z" }, "collapsed": false }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "draw_order_multiple(\n", " [\n", @@ -431,16 +501,27 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "id": "9b82db9458a6d31a", "metadata": { "ExecuteTime": { - "end_time": "2024-04-02T15:07:46.653744Z", - "start_time": "2024-04-02T15:07:44.060391Z" + "end_time": "2024-09-01T12:46:43.068266Z", + "start_time": "2024-09-01T12:46:39.544111Z" }, "collapsed": false }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAGdCAYAAAA8F1jjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOxdZZgcZdY9Ve020+OSmcnEhbgSJQQSkiABAsF9kUU+3BZZ3H0J7osTLCEhEE8gxJ34SMa93buqvh9vacsIyUTYOs+TJ9NlXV1dXe957z33XIrjOA4qVKhQoUKFChXHIOijfQIqVKhQoUKFChXJoBIVFSpUqFChQsUxC5WoqFChQoUKFSqOWahERYUKFSpUqFBxzEIlKipUqFChQoWKYxYqUVGhQoUKFSpUHLNQiYoKFSpUqFCh4piFSlRUqFChQoUKFccstEf7BA4VLMuipqYGNpsNFEUd7dNRoUKFChUqVLQDHMfB4/EgPz8fNJ08bnLcE5WamhoUFhYe7dNQoUKFChUqVPwFVFZWoqCgIOn6456o2Gw2AOSDpqSkHOWzUaFChQoVKlS0B263G4WFheI4ngzHPVER0j0pKSkqUVGhQoUKFSqOM7Ql21DFtCpUqFChQoWKYxYqUVGhQoUKFSpUHLNQiYoKFSpUqFCh4piFSlRUqFChQoUKFccsVKKiQoUKFSpUqDhm0alE5emnn8bIkSNhs9mQnZ2Ns88+G3v37lVsEwwGcdNNNyEjIwNWqxWzZs1CfX19Z56WChUqVKhQoeI4QacSlZUrV+Kmm27C2rVrsXjxYkQiEUydOhU+n0/c5vbbb8f8+fPxzTffYOXKlaipqcG5557bmaelQoUKFSpUqDhOQHEcxx2pN2tsbER2djZWrlyJiRMnwuVyISsrC59//jnOO+88AMCePXvQr18//PHHHzjxxBPbPKbb7UZqaipcLpfqo6JChQoVKlQcJ2jv+H1ENSoulwsAkJ6eDgDYtGkTIpEITj31VHGbvn37oqioCH/88UfCY4RCIbjdbsU/FSpUqFChQsXfE0eMqLAsi9tuuw3jxo3DgAEDAAB1dXXQ6/Ww2+2KbXNyclBXV5fwOE8//TRSU1PFf2qfHxUqVKhQoeLviyNGVG666Sbs3LkTX3755SEd5/7774fL5RL/VVZWHqYzVKFChQoVKlQcazgivX5uvvlm/PTTT1i1apWiQ2Jubi7C4TCcTqciqlJfX4/c3NyExzIYDDAYDJ19yipUqFChQoWKYwCdGlHhOA4333wzvv/+eyxbtgzdunVTrB8+fDh0Oh2WLl0qLtu7dy8qKiowZsyYzjw1FSpUHAdwBB34dNen2NG442ifigoVKo4SOjWictNNN+Hzzz/Hjz/+CJvNJupOUlNTYTKZkJqaimuuuQZ33HEH0tPTkZKSgltuuQVjxoxpV8WPChUq/t64dfmt2NKwBYW2Qiw8d+HRPh0VKlQcBXQqUXnzzTcBAJMmTVIs//DDD3HllVcCAF5++WXQNI1Zs2YhFArhtNNOwxtvvNGZp6VChYrjBHta9gAAKj2V8Ef8MOvMR/mMVKhQcaTRqUSlPRYtRqMRc+bMwZw5czrzVFSoUHGcgWEZhJmw+Pqg+yD6ZfSL284T9uDiBRcj3ZiO1ya/hlRD6pE8TRUqVHQy1F4/KlSoOCbRFGgCwzHi61JXacLttjRsQbm7HJsbNuOrvV8dqdNToULFEYJKVFSoUHFMot6v7PlV461JuN0B5wHpb8eBhNuoUKHi+IVKVFSoUHFMos6nNH18bctr2NKwRXwdYSL495p/4+VNL4vLSlwlR+z8VKhQcWSgEhUVKlQck0hEOm5ddqv4948lP+K7/d8p1pe7ysGwTOxuKlSoOI6hEhUVKlQck9jv2A8AGJY9TFzmCDmwoHQBAKkiSI4wG0a1txoAsKFuA2b+MBNbG7Z2/smqUKGi06ASFRUqVByTELQnY/PHKpbft/o+AKRkWY4u1i4AgBInicRc/cvVKHWV4v+W/R++2/8dZs+fjXJXeSeftQoVKg43VKKiQoWKYxKCRmVk7siE6yvcFYrXg7IGAQB2Nu9UWCM4Qg78e82/sbtlN65YdEUnna0KFSo6CypRUaFCxTGHQDSAQDQAAOid1huPjHlEsT4YDaLGp6wCGpg5EADw2e7PkpYytwRb1FSQChXHGVSiokJFKwhXVcE5dy64aPRon8r/FJxBJwBAS2th0Vlwbq9zFevP+fEcsBwLAJjSdQpeOfkVXNDnAuhoHXwRH9bWrk167Mt+vgyOoKPTzl2FChWHFypRUaGiFRy85FLUPvgQWj7++Gifyv8UHCFCJNIMaaAoChRF4eszvhbXV3mrAAC90nrhpUkv4ZSiU6DX6FFoKwQA7HPsa/X4C8vUvkEqVBwvUImKChWtIFpPTMdc8+Yf5TP534IQUbEb7eKyfhn98NmMz3Bx34uT7peiTwEA7G3ZCwDon9Ef6cZ0cf2UrlMAAIsPLj7MZ6xChYrOgkpUVKhoB6LNzUf7FP6nIERU0g3piuWDsgbh/tH3i68LrAWK9SkGnqg4CFGZ0GUC3pnyDnS0Dmf3PBt3jrgTALCpfhMWlS3qtPNXoULF4UOnNiVUoeLvAqap6Wifwv8UnCEnAGVERY7vzvoO72x/B7cNv02xXIioRFmiKcqx5KBPeh8sn70cZp0ZOlqH3mm9sc+xD1/s+QLTuk3rrI+gQoWKwwQ1oqJCRRKw4bDiNceojqdHCoLY1W6wJ1zfK60Xnj/pedE7RYBAVARkGjMBAKmGVOhoHQDgrhF3ASAVQCpUqDj2oRIVFSqSgHE4Fa+d33xzdE7kfxBCRCXNmNah/YTUj4AMU0bcNjnmHABAc1CZzmMDAYX/igoVKo4NqERFhYokYJxOxeu6Rx4FGwgcnZP5H0NbEZVkiI2oyIW0scs8YQ8iTAQAEKmpwb6x41B21ky4f/4Z/i1b4vZToULF0YFKVFSoSALGEZ8aYNyeo3Am/3uQlyd3BEJ5soBERCXFkAINpVG8j2vePHCBAEL796P69jtw8KKL44iqChUqjg5UoqJCRRJ4li2LW8b6fcptli9H/dNPg/X54rb9uyDEhNAcOLJVT2JEJYmYNhkmdJmgiKqYdea4bWiKFiM1wvvQ5vjtwpVVHXpvFSpUdA5UoqJCRRJ4V64EAGRce624jPV6FTPt2gceRMvHn6DqttuP9OkdMdy/+n5MmTslYbfizsB+x36xIWFHIyoaWoPrB13f5nbpJhJpaQqQaq5ERNM5d26H3luFChWdA5WoqFCRBKzTBQBInXkW9N27AwCq77wL+8aOQ3D3bgAA00LSQ77Vq4/OSR4mOINOzCuZB3/EH7du8cHFiLARnD//fDz0+0PwR/xYULogring4cKjfzwq/t1RMS0AXNj3QpzZ/Uw8Nf6ppNsUpxQDAHY170K0qQmBHTvjtnF+9RX8mzZ1+P1VqFBxeKESFRUqEoDjODBeLwCAtqWAtlgAAJGKCoBl0fDCi0fz9A477lp1Fx747QE8t+E5xXLBj0TADwd+wOjPR+O+1ffhqkVXHfbzYDkW2xq3ia8TaUzagl6jx1MTnsKZPc5Muo3QkXlj9VqUX3AhvHyaL2XGdBj69hW3c379dcL9VahQceSgEhUVKhKA8/sB3jdFY7PGaRjClZVgQ6GjcWqdgnW16wAA3+7/VrG8Na+RhkBDx8t5WRZwHEy6utJTKf793+n/hV6j79jx24lh2cMAAPS6bYhUV4vLrSefjJz77hNfB7Zui9v3SMK/cSN8a9cd1XNQoeJoQyUqKlQkgBBNgUYDymQSIyoCorW1YN1uxTL5oM0xDMKVlTge8N6O95Kua/Q3AgCyTdnYdvk2PHTiQ4r1QtVMUoS8wJ4FQDQElCwHHksDXh1EliWAIG7tYu2CIdlD2v8hOohuqd2goTTot0eZ6tJmZcFy4mikz/sKwNElpGw4jIOXXoaKK69EpK7uqJyDChXHAlSiouKoYGvDVpz89cnHZHO4oC+Cbcuq0ZzWFxqbDRRFxUVUOIYB41GWKnMyj5WmOXNQMmUqXPN/OiLnfCh4dfOrSdcJXYizzFmgKRqz+8zG4+MeF9eXOEtaP/jih4AvLwZ+eQBYeLe0fO2bABvv9CtoZCw6S9y6wwm9Ro+ilCL0qSbkUpuTg/SrroJ55EgsLF2IU9dcjIjFALAswqWlnXouyRBtaBD/9q9Toyoq/nehEhUVRwwcx2HJwSWo9dbi8bWPoynQhDtW3HG0TysO25ZVYt1KJ7YNvgXR1CwAiIuogGVROuN05SK+coRjGDS98SYAoPYhZQTieECUjeLFjS9iQekCMdpSlFIkrj+759mYXDgZAPDprk9bP9jGD8j/G94FmveDCVPwVBvAlawGnikCfntZsbkvSq5hrk+PCN+5urPQz1iMAhIwQrdv5yLn3nvA0RTuXX0vQFEoSSORlHBZWaeeRzJEZZ/fv2lz3HqOZY/k6ahQcdSgEhUVRwzLK5fj9hW3Y9a8WdDSUj/MRJUmAoLR4BHvyeJtDop/R1JyASQgKgkQ+PNPlF9wIRpefElcxgWD4CKRw3+SnYjnNzyPj/78CPetvg8VHlLZc+PgGxXb3DiEvF5WuQxVnlb8Rqy5ipcVKzNQtToDjgMWIOwFljyiWO+L+KBhOFzzwk4cmHwKPEuWHPoHSoLemnzQAKI6GtpM0hOo3FUurm+2UQCAg6Vbsb1xe6edRyIEduxE9Z13ia9jzQejLS3YP/Ek1D322BE9LxUqjgZUoqLiiGFD3QYAgCfiERvEAcC7O94FQGbyq6pWYX3tery+5XUEogHcvOxmnDb3NJS5jtysNuCTiEWII4QqkSFYLOr+/QgC27ah5YMPFMuPVYfTCBvB/JL5ccs/3/O54nWuJRfFqcWKZX3S+8CmswEApn83Hetr1yd+E0uW4mWwmYhj3ZXGhJv7Ij5kOwGTLwowDDzLlsOzfDlCnRDVKNbnAQDCOkpcJq84cljJ/ws3fIpLFl6CMKNsUtmZOHjJJYjKdCmMx6tY7/zqKzBNTXB8/sUROycVKo4WVKKi4ohBTk7kA8KWBtJX5fsD3+OmpTfhml+vwdvb38abW9/Eutp1CDJB/GfLf47YeQY90oC0IfM87F1Xh1BKDtqqb4kmSVUwLtdhPLvDh3kH5uFfv/2rze1MWlPC5dO6TRP//uDPDxJug4Akto0GpMeNITUKjgPcFUaESiSdiz/iR5ZLutLeVatQ9c8bUTp9Rpvn2VEU6bLJe2oZTPt2GpZWLBVN7c7sfiYcVkJg0niOcCQje1xM5242Vg+lpn1U/A9BJSoqjggibCRupi7AGyYjwS9lvyiWL6uULOxLnUdO0BhwK6s8lny4Cz+uSUdd7olx22bffTf0PXu0erxjNaKyoX5D3LJTik4R/75v1H3INGXi9mEJXHeZKG7td4WYAvq9+nec8f0ZeGHDC8rtAtLg7m+WlRpTgLfGgOo16Sg9/QyyrHoTvFXrkC3jdUxTU8c/WDuRpyFmckEdUO2txoc7PxSrjvqm94XfbgBwdIhKLBiv2mNKxf8uVKKi4ojg57KfEWISl3l6I2QkyLPmKZYfdEt+GxRF4a+A47gOe30EfdGEy6vzJ8Qts005Fdr0jITba7KI7qEjEZV3t7/btkD1MGFvy964ZTQlPRIu6nsRls9ejpOLTlZu5KkDXh+B1NeG4QZNLvIt+QDI9/Xxro8RYfnU2b5fAJn+KNAkERU2QsFXb5COufm/qPtgCj5oXKeIqHQmuADRImWlFQAg10MgI2nGNBiyib7G7iXnI5CYIwFNmtKRl/Um7yXVYS8bFSqOM6hE5W+MD3d+iJc3vdz2hkcAicSIs3rNAgB4wm3PFgPRQJvbxIKLRlE+6zxUXtd27xcBDMMiHEocVnenFCOYUYS8J6TyXG12NugUW8LtDT16kmO2M6LSHGjGa1tew/Mbn09K6g4XIkwEpS5llOqxsY8hzyKRRTlpUaBiLeAoA9goqJ/vxpndldVP+x37UeGuwMofr1YsD7ZIqT82SoGNyI4/72Z8ZyOikGxn4rcV0h0cE1/W/Fewb+dWLO9bBCo1C2atGUEmiM0NpLom1ZAKXRGpdMp1AKYghxuW3IBlFfGNKjsTBW++ASA+9aPAcSbWVqGio1CJyt8UYSaMlza9hA92ftBpPVk6glgrdgD45+B/AiACSo7j4Aw5k+7vi7SvOzEXDsOzYgVYnw+h0lIEd+2Cb/XquJx/IkTCDILe1h/6kTteQeq55yL9iiuQddutoI1GkZDEQptNhKSMs30RlcYAqZVlObbTZ++1vlqwHAujxoi1F6/Ftsu34Zxe5+Dagdfi5MKT8cqkV5LvHJINmr5GzNBlKlZva9yG078/HTdnp+NzmxV1Gg0AgAlLjxs2QoONSFEyjgG0fGQgWUSl5cOPsLtvP+wfNx7RQ0wJsZEIVqxegoBBhwNUBAMzBwKAGA2yG+ywFXZDTTqgZYEBB8k53br81kN633afn59EonR5hDhy4TBY+T0su0RsoOMkXoWK4wmdSlRWrVqFM888E/n5+aAoCj/88INi/ZVXXgmKohT/pk2blvhgKtqNCBPBrHmzxNftiVh0NoSB964Rd2FI1hBc1v8ypBhSAAAMxyAQDcAdcifdv71EpeGll1F1wz9R+/C/QdHS7R1rzhaLxgoP3r1tFX55lzSn00Z8GBxYGb9dfQQUTSPn/vuQecMNAABjn94Jj6mx28l7dyCiIqCziUq1l9jG51vzYdFZxOiJ3WjHa5NfwyldT0m+c0h5LbuV/K54vb1ihfj305npuOGEMQBIFEUAa+2qiKgwERoe/vvKTsLrGp5/nmzrdMKz7NAiG/W/fyP+rdVoMCZ/jGK93WBHriUXW7uTcx5SeuTSK1w0Co53w9VmSVVT8qgKF5UItUpUVPzd0alExefzYfDgwZgzZ07SbaZNm4ba2lrx3xdfqOV2h4p1detQ7i4XXzcHm5NvfIQg5P7zrfn474z/4p6R98CoMUJLkfJfT9gDV4iMUF2sXXDXiLsU+0fYSJvloYEdO9Hy0UcAAPeCBWCDUvqEcRESxPp8cC1YoJydAijd2giO5VB7gJyDMeRAV2M9zKlEV1E8kOhQmio9Ck1A0BuBJ00S06ZfcQUAwDZlCjSpqfx7Jx5568vdWPDGdjjqCAlrCkhRgiNJVDoMXvyMdPK5qT0/Ye7pX2FS4SQAwLYapYtqiacCG2a9Ab/GKh2i0Qe/U0qZOSMaNGo10Ec42NvBSeUk9K/AV1cu/h2J+nFa8WmgIBGpVEMqTFqTkqgcIS2IYBwIABqbTSyNVxAVGTlh/SpRUfH3RqcSlenTp+OJJ57AOeeck3Qbg8GA3Nxc8V9ajIhMRcexumq14rV8pn60IPSESTNI3y9FUbDqyeDlCXvE1M+rJ7+KS/pdohg4gLajKtV3KF1uuYAk5GQ9hKjUPPAgau68C40vKrsfR4JK3YM+5AKdkoJZdw/H5Mv7YvzsXgAAryOE1V/vJ/uEGHzx2Dr88HE19Hc/idTHXkDWvfeg56qV6PLyS9DYyEDMepUeGALmPrsR5dubsPDNHQCUhLIl1LkVJkLzvy7WLh3fWYio9JoKaE1A0Ik+0OORMY+QY1PxGpKrNz+DSEAy0mM9HnAhiSweWJOBiEeDzORBNQWizYd2ffxNUiPCUMSHAlsBrht0nbjMprch15KL3YXkHsxyA+YQMGEHi31TpiC0n9wDZa4ysWrtcEFI+0CnA6XXg7YTwhttcci2kchJaM/uw/r+KlQcazjqGpUVK1YgOzsbffr0wT//+U80N7c+qIZCIbjdbsU/FRJKXaVxZcBHs6xSPAe+TDXdlK5YbtURotIYaBSJSpoxDVpai8XnLcYzE54Rt22LqERkTQA1drsiJM643QiVlsKzaBE5n48/UaQPvA5pEAUAfcQLjc2KsMWHmoLdsKZLFSo7lhMn1pItDfC7yWC7aIMd3y8zYd/6euiys0FptaAt5LMxviQDGT9Bd9aTgelIpn4EH5u+6X07vrMwMJvsQDa/f8Of5HujNIn34TgYW5H/pDpoTF+ogY3/yqg2DPaizYemUQk4pD46IY4D1r2NK0+4EsUpxZhcOBk0RWN8l/G4aOhVYE3ku0/xA7f8xIKprMK+e2/HPsc+nPXDWfjHr/84pHOJhRBR0fDXQN+1KwCllT8blO7X6jvuVLxWoeLvhqNKVKZNm4ZPPvkES5cuxbPPPouVK1di+vTpYFpR9T/99NNITU0V/xUWFh7BMz72UemO79h7tIlKiAnBEyGz8AyjspTXpidRh1VVq8BwDHItucgykbx8jiUHp3c/HelGQm7aIiqGPn3Ev7U5OWBlM3jG7Ub9E08otq+68SYE9xCDr5Jq5XWL6KxARjpuWHwDblt+G+bun4v+46U0STgQhac5fnAo2yoNoLSVEJXWSksFvL3tbfxW/Zv4ujOJSpWnCpvrSXXL8JzhHT9AiCcqeiuQfQL5u3oz6ANLkR5JnJ7TMQDdRuYkr4GCJUA20uXktLot03QIUcKgGwFZOi5EaYGf74HV24B5Z8/Dq5NJk0aaonHniDthyCTGcJlBqWqpobEcyyuWAwD+bP7zsH5fAlGhLISoGLqTFJvcGI8NKNtOeFcro6gqVPydcFSJyoUXXoizzjoLAwcOxNlnn42ffvoJGzZswIoVK5Luc//998Plcon/KivjB+b/ZQiEYFj2MIzLHwdAqiY5Wmjwk9mrUWNEij5FsU4gIZ/uJt4hI3NGxnmmCJ10/dHkPYEAgDLKfDk0tOJhzrrd8K35I26fSHU1ItEoAi3K6b7FV40HvJ9hr4N4jXy972ucfGlfWHjNyru3r8KBTQ1xx6svkwZA2krOOzb1w0RZ/D53v2LZ61tfV5QLdxa5bPA3YPZPs8GBQ7fUbihOKe74QYTUj8EKFJN7DBveAz47D5lMYg8aYzvc54MGIDtASpC1SYiKoS+J4ETbiLwmxf7FmHfzVGyqlDxd/JQeVf4UwF2b0K9Hm07u0dyw5NDLsgy+P/C9+Hp9XZIWAn8BYkSF7y9l6CkQlQMAgMY5c+BdslSxT2DL1sP2/ipUHGs46qkfObp3747MzEwcOHAg6TYGgwEpKSmKfyokCBU+GaYMXNDnAgBAibOktV06HfU+Yi2fbc6OGwgyTMoIS7fUbnH7C+mhtiIq8sgFFwgqBIeM2wN9j3gHWY5hsG7pPpiiNgQ1PuTNqEdRxa8oqPwVWzIl8aIgdM3plioua6mRnQ8FUBTgc4XhbgrgpznbsG0XzZ+XkqjsXVuHrUtaJ9idFVE54Dgg3iNvnfrWXzPSC8siKoMuAIx2cVkmo/SgOangJACAgeeBrE4D6KTIRIukr0VAD3T3kv01iVsBIfvOOwG0nvpx//wzqu+5B5GGeCLpWvAE9nsy45Z/dXAw3NWJnzsanqiYPRKZpThJkAwAtd7apOfTEXAcJ1aJ0SnkXhPIWXD7DkQdDjT95/W4/RiX87C8f3sQjTCY9+oWbFxYfsTeU8X/No4polJVVYXm5mbk5eW1vbGKhBCEfTa9DX3SSSqk1FWKCHP0TKGEiEqOJX6WHJsKyjTFDyJC1KXGWwOA9IOZVzIP+xz7FNvJCQEbDCoEh4zLBcZNoh1yy/uw04sdP5Hmb5sKf4Hfsx09S3+EwxpARCsN4kKEo3hQ/PkNObUQlz85FqnZJFT/89s7cHBHM7ZuCoClaLBeL/wbN6LyjjuwffdKeJxtV2kI4uPDDXnE7S9V/ACyiIoNoDVAiiTIzZKlbftn9Me9I+/FWT3OEiMqYT2NsFkiKvu7SNc4oAfyWZIK1CCelFomToA2h6RhWkv9NLzwItzz5qPiaqXhHJyVKC1V9mNKCUiVYRW79yQ8niaD3H+X/iTdX7H0riEQT4r+Ciqvux7VdxAyJpS3G084AZTBAMbhgOPzxG0o2COo1Tu4oxmVux1YN69UdcVVcUTQqUTF6/Vi69at2Lp1KwCgrKwMW7duRUVFBbxeL+6++26sXbsW5eXlWLp0KWbOnImePXvitNNO68zT+ltDmC1bdVbkWfJg09sQZaNxLqRHEvV+KaISi9iISuxrABiQOQCAJAC9d9W9eOC3B3DRTxdhztY5WFW1Cv6IX1HWyfn9YIMSIYjU1IB1k2tT8Oqr4nJnYwBsBAhrgtiRuxKeSnKdGlPjIw0RJoLeo3PQY5jyc/QelQtbuhGp2SQ10FQpDWh+cy4Yvx8HL70M3oU/Y+s9/8QGx9q4Y8eisyIqQlRK0Ab9JcgjKgBgkiq5BoSkgX9X8y4UphTiyfFP4rLuswEAbm0EDVopJVcp430hHZDBknSHpnE9ci4/FannnIPib76G/YILkP/ss9Bm8m0JnE4wbnechwjHcYhUk0hH+EBMJPHbf6A5rBTpjiqpgU1PyFVVeVXCj5uwRULM+NzoP/T0Ksey8Mm0Jpo0OwCA1uth7NcPABJGUwCp/P5IgNbIyKVHdcVV0fnoVKKyceNGDB06FEOHDgUA3HHHHRg6dCgefvhhaDQabN++HWeddRZ69+6Na665BsOHD8fq1athMBjaOLKKRJhXMg8f/vkhADIQURQlRijc4SNbHcVyUgqg1kfC4jnm+IiKJqZKJBFRGZI9BAD5fLctvw3bm4gdf5gN461tb+GmpTfhxfUvKIgKG1SmfjyLFkkmWtnZSL2ApMW8TqKpcBobAAooWkSO3ZQgo1jrq4VGQ2PadQPQfxyJ+plS9LDnkMEvJTO+y7Db1hUMI41qhY0c1lati9suFp2lURGIrKD76TA4DvDwUQkLzzJMdnH1eR4f+qaQ9N2w7GHi8hSGaEJCOsArS+us6yM9gnRRwM4S8kNrI0gPf4L8B++AaeBA5D36CLRpacSbhvdQ2T9hIkpmnK7wxGEcEsETxMwiKtfCFZbePNPjh57lMP6kwQAAjytxalGXHx95EoTBdi+H0XtYNHrr8e62d3D1giuxpnpNwuO0Bfn9CwBaPqICKI3f5Mj5F+l+3Zah4eECx3Io3Sal3YSKNRUqOhPazjz4pEmTWg0N/vLLL0nXqeg4HvjtAfFvYcZs5JP9weiRK19cWbkSd6+6G4+NfQzTuk0TozmJhJtmnXKGG5sKAoBRuaNQYC1AlbcKSyuWxq0HgI0Hf8N5snuNC4XA+BIMPBSFxgYGCxrHoqigCWYPmU27jU0oruPQnWSB0Jwg4FDlqUJRCun/MunSvhgwqQCpWSboDIRsDZvaVSxdFrCn76Uo6T4TY9Y9Ai0ThJYBdNEkAgwZ3GE3ImwEOlrX5rYdwSFHVLz1QNgDUDSQVkyWmZTeRx9PnoNPD/6MKV2niMvsLPnMIR2xpBdQkw7cf4UGT3/MwByhYGEtCALQ6PiN9iwgOhgd2Z/SaKBJTwfT1AQuFEK0thbhsnIY+/RGcO9eHLz4EvHYXDRG2Ks1wskLYsd1M8AyrxTa7GzosgsA7EQgiXGavlu8bkqIKTz3CQW7i8GXdBm0OzfimmoOd/xjI16b+QFG5Y1Kfh0TIFbLJG9MqJGRFjl0RaTqke1A48tDwb4N9dizRtLjOOv9yO9lPyLvreJ/F8eURkXFX4c8ggFIA5FBQ6JTnd3kTo6bl92MQDSAu1fdDUAS8/a0x/fEmdFthiIllIio6DV6fDjtw1bf09FSE7eMaYlPn9A2G0q3NSHManGg57nY7yIdcj2GFuQ4JaKzpzA+9VPllUgIRVHIKrRBb5S4vjXNgP4T4mffEb0NjjSiF9IygJ5JTFSG5wzHfaPuE43uBKfejsIf8ePHAz9iU/2muHWHHFFp5gWn9q6Alo98xhAVszUX1w26TiGM7qshOhafgVI4z0Z0FIJ8AU4ma0a0gqRQtCZe6zL//4Bf7lccX5uhvEcEf5HqO+9Upv+CQbGRIQAw1i5wR8g5dx11IbQsB21ODoz5pAVCIMQkdJ/VdyuOWyZobuwuQoa673TgxL0c0r3AqH0cllcuj9unLcRGReTkJLabsnhuBaTzM3OENCpl25QproC3HeVcKlQcIlSi8jdBbHdhm44nKvxgEmSOjiGUK+QSK2a627vHrTdqjVh83mKcVnwaLu13KXSaxBGEXEsu8i1KEiD3ADHzPIy2SZECT4KIHRcKKfQFAY6QBrexGSl8FLskF9jRTfppCIO6nKgkQ7IamjBfuaRlExMViqPwn8n/wSX9LhFFrruad7X5fonwxtY38ODvD+K6X6+LS/kJERWhkqrDEIhKhpx0xgzuCb5DtoroRtj8LNhj/O/uO+lR8ofHh2htHWirFZYLbpc22PiBYvvYNEi4vAyR2tp4TQqUVvN1bgosaJhMBhhChAhpMzNhyueraqIawBNfvZMo7WIJAla/9Ln1YYkQpfiRkCS2hVi/HUVEJQlREZazXu9h6yrdGmKrxKJhNsmWKlQcPqhE5ThHrbcWC0sXKkp3zVqz6DgqpH5C0c6LqAgOnYIBlhwLyxYCAPIseUln8TRF44WTXsC9o+5t9X28EWmEu2rAVXjhpBdww+Ab0DWlKwqayKChLywEZVQSgR5Llojhe+PAAQgH470++pY34dpfyEO3NFf5ML5x8I0AgGpPddx+sWCZxKlOPx81MrEa6BIQFS2jh1lL0mCC/81NS2/6S1GVFVUrABANT2xp+vZGosERWhd0GC7+GthlRouRtquYwgcPAgD6DJqEd6eRx87X48n/E3qTFFFN3ljs6ns5zJMmgx4U03ZD5s9iHqE0qfMsXoIDJ09O+L5sIAD4W4D3T0NlA/kNFPbrB4bvvqzNyoLRTiI0UU6DSOUW5QE4DhRFofD992A9+WRxsZYFnjRdJL4uapS+94Imrl2kNu5cvcqIiq5Lgfi3JkUi4IZevWTLJTHVkYiqxFazR0KdT45UqFCJynEMjuMw9dupuHf1vVh8cDEAMvtffeFq5FmJ2FNI/XRmROXFjS+izFWG/1v+f3Hrnlr3FIDE0ZSOQk5Ubht2GzJNmbhpyE0otBWiex0ZKCry9eD00ozeeMIJ0Bd0QdF77yL3sUfR5dlnEQ7EE5WZf0ghbXeMe3uBjQwYct+MZBhyahFoDYX+4/Jw4tnSZw6YCFHRhBlkeuLF4imUHRqaaF3O6HGGuPyP2niTutZQ76vHQfdB8XWpU6r22li3ESUuQlz+ckTFy4t4rLnSshNvlP7urex+HiotQ90TT8K/fgMAwFjcHcsH07jxRg3mjqeQa8kVm+7t6XMJ6nJHo6nHSUBWH6DrOOlArgrxz7RLLoGhd2+RfAb//DPp6bJ+P7DnJ6ByLRy8PiWnR29EBaKSmQm9yQyaH4CD6z8FFt4D7J5PyrD/Mxz44SZYx41D4ZtvoMtLUo+o/jXSqJ0uixIVNnLwhD0dtgSQa1QMvXsn78qdKnn5UDodaN4Yrr1dug8FFK1kKpGwSlRUdD5UonIc481tb4p/b2sgpbsWrQV6jeS6adTyEZVO1KgYZe5cyRog9kyN16d0FJf0I0LJU4tOBU1Jt26qIRU9eYnKD9rtqKOlmWnx3G8AALouXZA2ezZ0XbogFCAPV4tXMl0zyqps3Gblw1ho3NeeWXJ6vgVXvzABky7ti2FTu2LoVCK+DRns4jYZwXiSYKWkwWdo9lCcUnQKACXRaA+agkojNIGYAMCaGqkaRUv/RR29UPFjk1VwZfQAHnEBd5cCF3yq2PzgpZfC8emnYHgnWVsfvsw2lTjkvXjSi6C0WugKpOgBCnuSqfvlP4odmrHvV3G1xmZD93k/ovvCBdB1iW+qWPTRh6jsmo+l/buioawEqCVRpCBDPrPRlo5weTm5DlmZoCgKRjO5hwN7VwLr3wa+uhTY8hnQUgJs/RRgyT2TMmMGzCNHkuPtTEyQCpoBiuU67IXDeAhRoS0WFH/1pWKdnJzQsr8ByZBOXvHUWYiV8ETViIqKIwCVqByncIfdeHfHu4rXQHwVjSim7cTUj0CGAOClTS8l3KZXWq+EyzuCW4beghdPehGPj3tcsTydMaJfJXmC7uxKYU1/QjQokymh82qET/1ogjvEZTQnPXDPKZiOM7ufCQCY0nWKSFRcIRf8keTlmAzLYEvDFrC6CCiKAkVT6DWCDOghWesAmk0QUYFy8BmaTUr6O+oq7A4pw/+CKzCgJCcn5p2YcP+ow4GK66+He1GCiryy1UAJ38hRHlERYMmI06cwLRIB1OXnI6vnQPG1TWfDoKxBAID8Z6Xmk2LqTqMDhl1O/t74ftzbURQVX5Gj08Fy4onYYTchpNPi9x8+BzaQ30mAIefm/fRz+NeREnFtNp+Ss2cqtgEA1O+U/nZJJFUoVw7ukO4fOfRRIMcJOAIdKzEXUj+2U08BbVKWultPPhn2889H3pNPIOe+e6Hv2QN5T5LeVYLF/19uK9ABRGLSppEQg6Avohq/qehUqETlOMWqqlWIstJDQ0hLJCMqnZn6cYUlHcW8knkAiBX+rcNuFZdPKpx0yO9j0powtXhqnL4iv9QNLQvUpgF16RS+GU/j+8kmFH/xecIHaDBAQvIBTQmGbH0VdMujivVDz70OT45/Et+d9R2enfCs4pq21m/os92f4fKfL1eUiUeN5LqH9SngeKktS5FQfYVdEstaoTRu6WEnkYSOGvXFimfl6TJB73LtwGuRZkwszmx64034Vq5C9W23KVd4G4CPzwBYPp1hjTfvi0XstTePGgWTziRWdsnTgcahw5AITO8Z+LmmN7aWJml2WFigfJ2VpXhfpkVKGQX5687t2i29b//+AABLGt/4svh06WAVsrSbICIGYOhFooNcJD61U8HrbqduZtG8/auE55wMjFeIqMRH3CiNBnmPPwb7rFnQFxaix08/wT5rFgBZRCVBldvhRigmbVqxqwXv37kaa384eoaSKv7+UInKcYoqjzINIRIVrZKomLRkZtaZqZ/YWTxA7NPP730+RuaOxO3Db0eqITXBnocHtJsIiQU3WUZD4YvREbzj/RVzn9mIn17fptg+5CcDjNsUQLpzHyZtJ/bn2vw8dP95IYy9e4OiKPRK6wWdRgeaosXr2Jofzfs7yaxf0AsBwP+tvQksWICiETp3Jhhah6iWDJhLen2CRisZSM1Q+poU2UjKqMpT1aHZahxRCUtExRlyAkCr3wWTbFYeWw2T0rb9vjyaAkik4tMZn+KM7mfg0bESQYzKtA7ySvuqyibscuVgaXUhVnz4JoI+ZcmQvrBI8Tr/+efgl/W90fARMO663xGk7eQ8ZP2IdLkkMmSx80Sl8BSgG+lPJCcnrgObMPfJh7Bv/nuwRRL7P7lNAIaRyOEZGzjonv6iQ98dy7vL0qkd61+mSSekk3F0Xpd0juOw8PUXUbf3KyURjJBrufmXg8l2BcsyiIbDKNm0Hi01beu8/i4IR8m1iTAsWJYDw6pRp7+KTjV8U9F5EKp80gxpcIQciPAz3djKGjGi0omGb4kqUwZkDECqIRUfnPZBgj0OLygvqToJ8BmVXEsu6nx12Fa6G5qDxH4/HIyKnifhIBkUnWblNdHY7TAkMPcCiA4nEA20eh1jxZMcx2GPYzdG6tywROyozJ+NzHTSn4ihwghrAgjR5HhmKL+3PEseaIpGkAmiOdis6IG0snIlAOCkwpPizkHwScm35KPGVwNPxANXyIWNdRtFW/7WiIq8YopjWYA3TaNCMoIw/nbAliD1E4NwqXKWLZCCAlsBnp7wtGKdvHpEPhD6A1IkZdOiBQj4A5h+0x3iMoNMcNpz+TLo8vJQsXO7uCzAagGNHtUvfoigxw1QFHRR8l6ZN0oiYCGisnnRfIyYnC2WmbMc8G3FQFTsXgUAqNu5ATf3+QMpQ4bBvbVO8RlSoMVAbg0OgoRVrBUUwhUVMHTtKm7D+nyofeRR2KZOQcqUKYr9Gd60TZPaMVIvpX46j6iUbd2I3atJVZ8hdRxAtd8w8LunH8HB7VI11Z1f/XTYz+9Yw+YKBy56Zy1CURY6DYUIw6F3jhU/3zoRGjo+Ha2idagRleMUQkhfqEgREBtREfQjnZH64TgOc7bOQYWHRAXO7XWuuG5at2nJdjvsKKRJKsFvICTl+YnPA1A29vM5SUSJZVhEQ2Sm02JVXpPQvv1J30O4jrF+NXKEWWV6QrjmPj2ZKVfudGDLgJvIOq0LoICIhmxjZJVERafRIddMBvYdjZIWwhv24uZlN+PmZTcn1MsI0S3Bi8UTcuO5dU/hthW3iRVEdpmwNxaUrLNxtKkJ5Zddhr2jRsO9jO9Bkz8UOPWRpPvLEeKN2ARoc5KTG3lERU5a/DFdgXetVpbAW8aORcGbb6DnsqXQ8c1MW6olkbQnYkBLWSa2rV8Djtcr6RgWKWecgaz/u0XczsoTFW9zE/Y0SGJ0Z9iECr9dOjeWPDJzpsanvqhwGC6TEXtPNMHJS0xc376q2Kb5gw/hnj8f1bf8H+lLVF8vEjORqCRxoU0GDW+A5/ruu07RqXiam/D9M1L0i2M9mHbdgHbtu3v1cgVJAYD/3nsrqvfuTrLH3wObyh0IiREV8v3uq/eiph0NSVXEQyUqxyl8YRJRiSMqR1BMu7F+I97a9pb4+rpB12F279l4dOyjCbsgdxZ66YnYdUyvU/H9Wd+L3ZabvNIM0+ciJKKpygtwQEjjR0OK0mDLNHAgkkFM/bRC+MKMkqgIpMGvj484MRQ5TkRD9snRx3cMz7WQgV1e9i10ogaA5qA0KIWZMD7b/Rl2t5ABQCAqXn8T5vFeNgJai6jInV2b33kXwW3bwQWDcC76jSw0tH8mHS4rV7zW5STXtciNwwRSSf6O0V1wHNyN0jWgKAq2k09W9ONprpZ0KWGtFh/6emBPvuRma+reHTkP/EtxWI1OIifVDimi00QpU1wmLYmaaW1mpF16KfQpUhRNZ2HwefkQlATysbo/Sce4ly8US2U4joPja0m34vnlVxw4aRIaXyQlz0J5cUcjKtaJJwE0DdbnQ/Wtt3Vo3/agvkwp6I745sOSFm/qF5vmCvn9WPj6i3HbNZSX4MuH7z68J3mMwRVIXJoukBcVHYNKVI5TiBEVq5KoxA5CnSWmdYVcWFW1SrEs25yNh8Y8pIisHAkI/hMFub1h1VtFoqJlpYfpis/2gOM4VO4ng3u9rRwp3ZQl0/nPPZv0PdoTUeFkDq0cx4lpGEFQK4dPS3L6QkSln+2EuG1O7y4JOwXhtNCJGgCafQ3A769i347PccXPV+CZ9c+IJchCpVKQppAT0/NGuD6JwMh6xjg+lUqNoy6+5NvQPv0Ex3Hwb9yoWKbNiW9KKcArIye719SiscKDSDCIhvJ4keYPzz3W6nvLIyqxyM7MQbfvv4M2xum1aMBg8W9jhvSbaqKV5c+BqI7wDk8dch98AD1mNKJoUhOM6WHkn+gUtwvzKVhXBbB2zw/k7+++B9MolY+75hHhefN776P8kksRriTnrUm1t/r5YmHo3g0Z110LAPBv2nRYoirhYBQHNjUgHIzC09SgWMexPhxYtyRun1jzt5DfG7eNHEw0Co5lFcTz74JkRMUTVLtN/xWoROU4hVBpU2grVCyPtZnvLB+VSxZego/+/Eix7HA30GsvWMF/wkaqJQSdjoaVJFiuhgDWzivB2rkkHdFgrYDDIhELQ+/e0Bcqr6UcbTV3ZFjlQzoQDcATIYM7Z4p/OFWbvgUARDTke6Gj8XKxc3pJ7qyCKFYRUdn8EXxL/o1Zm5/Gzuadin3l90WET3lkm7Lxf0P/D11TuiIZGHdiJ1zGyQ867XS0DWzZiuCOHaBMJuS/8AKKPvxA4aIqx67fa/DTf5SC5x0rqvD14/8S0wYnZkhRksaK8rhjcByHX956FUs/eAuuBkLm0r1KUmm3peLS198DrdfH7Z+e3wX9JxDn2SAtRY2aOaI3GZdF3pMFjQirATw1oreKJTeMblObYCqWiJiGM8BtAswhCs999xAAwPH558pzDkr3UmDTJrGxoMbeceF59m23kQomjoN3xcoO7x+LtT+U4pd3d2L5p7ux7MO349aXbY03Igx6lfd5KFFTUBkaykuw+ed5ePfmq7Hik/f+ViXOTp6oPHRGf8VyTwJXbBVtQyUqxyHml8wXrdBzzDkKfwzBkVaAkLIQZvdy1Hhr8NS6p1DpST4DTYQwE1a4nwJQlCIfCTARFhyvomd4/wkN3+dH8E6RR1QAYPPP0mDn0ztxQGaGxnjjr48cwnVMFlGJvb5/1P4hpn50ungSMiGDlONGaEJUElmR62idqDlyh92IMBE8+PuD4vrmvfPQqNEkPJ8+6X1g4p/7Lfw2r5/yOq4ddG3iD8iDdSqJimCoFvUESCShnamfSDWpSjMNHozUM06HZcyYpNtuXxZ//1nsBtQd2Ce+zjO1bg/vaWrEzuWLsfWXn5ISlbxuPRL66gjI6U4ibEF/AJh4D9BtIpp85LvLHTweWv5pGWC0gLuWdJKWgbNJkwR9ENjfhbxXrxryRWhzlRqd4N69Cc+jo6kfAYLFv3fFir+0vxw7VpDvb++ateKyzK7Sd+iqr4Y9x4Ts4hRY7CRq21RFyCwTjWDtt1+iPEabEova/Xuxbx2JAG5a8AM2/vT9IZ/3sQIhopJqUj6DVKLy16ASleMQ//pNyq9b9VakGaQwdmxEpQ/ftXefY19c6erDax7GF3u+wE1Lb+rQ+8d6e9wy9BZcPeDqDh3jUOBqDOCDu1dj8YfEh0SMqMT4T2jY5BEev86DYdnDxId7+iWXtPqeAlHZVL8J7+14T6yyEiCU/gq4bflt+PUgcVPVa6UZvA5hDNz5Nsa8sxYf156OVCsZ+CPBxA6fKXyqxR12iz18BDRTLLx04p9wN0MWUlhlPrytEnEuGkWkQRmGF+ztwXJgwlS7iYqQfhAqUlpDapY5bhmtVc6ui1Ik0qEzmoB1bwOvDgF2/QgAcDfFpg84pPmV0a+RM85u9TwM/P0T9HmByQ8getG3cNSTyp7M854CSxHC91tjMcCEEH2hPyEtPMImpQZnXx75bgSiEmtxL5SCUzHmbskiT23BOnECAMSl3P7SsdIJ+WCjUlfy1LyJMNhvAUAh5Pdh5q19cN49w5GWS74/gdzs+X0Vfv/6U6z6VFnx12fMBEy89Gp0Hz4KAFB3YB8ssjRXzV7yez7Q4MFVH67HhvLOq2LqbLj8RHsWT1TU1M9fgUpUjnNYdVZQsp69sRGVPGseilOKwXIsttQrZzjraok7Z5lLWZ3RFnY3KxX75/c+X2Fp39nYtrQS4SCD/RvqEfJHwHpINENI/QDAl2d8iZnFZyc9xlkDZ+CpCU8h//nnUfjee0i//PJW31NIoX1/4Hu8uvlVzN03FwDpn/PO9ncS2qUL5neRnk3Qm7ToNTIHM8xLkNVEomGmj37E9SNIhCPW8VOATU+IgTvkxq/lvyrWNWs08KQSYtpTY0XfKBkQ+4dC0K1+ATkxhmQpmnhCIEdwz15wgQBomw2ZN/4TAJB9772g+YGTCWraTVQE8zGhIqU1JOoXE/JJFU3dh4+C1p6HK7qRjsRcyAv8fA/gKAO+uRKIBOBuaow5AgVzSPr8I0tqkNG7T6vnYeRJY9DrhauhDq9edi44loXRlgKLPQ1aPRm897gJIVlQ3Rfv7h8FR9go7idHdQYZpHrVcAhGg4jWEi8ay0kTFdvpiyQvGPPo0YrKq45Ax6cuGYcDXPTQZu4mKyHXHEPOecp1tyASNIKidDCnEvLprKsBRVMYOIloehx15DvzNDclOCJwxm33YuSZ56LvOFJW73W0IBSQvmcfX+E1Z3kJlu9txPlv/QF/+PiMQAgRFbtZjagcDqhE5TiEIJQESJVPQ0CaTSbqUCxoEpoCygeIMAgCHfNZiW2Ul8zltLNQXy5Fhqr2OKSyzhQpYnBCxgmYkDcxbl8BFw49D12sXaCxWmAdP67NwUHeJgAADjiIGdhVv1yF/2z5D77Y80XSfc2pelz13DhMubo/NBYlWdAZyCw9WRfaFN563x1xi2Xgo3PJjNRD0/AWkb9tHIe36pvxUFMLnm5sBv54HTmM8pgWrvWKg8C2rQAA06CByDT9iNyzWCz9YTe297gILKVBNEi3P6LSIkRU2r43Qn7p4c1xUYTcX2Dv75+Jy06/5S6A1sCqI7PUKKdBlOXJOccCruqEgkxTRDquJRwRm/clg0BU6kv3o2bfHnH5sGlngqIoTLj4Stl5Age8mYhwGqxp7AqAQrDPLMXxnBYdWADZLqD+4B4xWpVzr7JLuF7ms2I/77xWz7E1aFJTAT7Cdqh9f4I+MtCyDDnOgc0s/B5y/W0ZhKh5WsjzJLPAqthHm0ADNOa8i8W/TTZyTwfcLoRlRCXA/453Vkvpx101nd8RuqOYv60GX66vaHWb5KmfYzei8lPpT7h31b2dag76V6ESleMQWaYs8e9UQ6pIOIpTihNuL1jOy+3UOY5TWPDHak6SIcpG8Vv1b+JreWXKkYLPIZEqV6Nf6oSbrQy9CyWvLaYYV1UA5pT4h2lrEFI/AvQavUL8t6UheT4+25wNrU4DiqJAm5XH0RkJUQknS/0IRCXkFhs+FvEW9D5aAy9vZW+NhJAR9mO2x4vu/ACtiREnUuHWqzAi1STMb8gygKreiLWhy1Hl7Y6G1EHYOPwehEN6ID2xIV4sxIhKetsRFaGbdVaRDdlFLeCYWjhriTjYYk+D3mQGmg/AQEcBvrIqxGqBFL46x1Mbl/oZllYNmgMGVjSgb00TzO2YmZtsEgn7Y64kfD3x3AsAAD1GEFJIgVP0BNrjzkbj5esQyFCWt4/kMlDNV+k7v/wPEI2C0uuh79oVtOy99F2liIouN3llVFugNBpo+GqmaMuhpU0CnjA4jgU4QiRq9kfgdxOiYuY1NAE+kmm0kmvBRFhEwgxCMe7B3YaOwJjzLhJfm1OE/d0IB6SUns/lhCcYQWmTJMItaWz9nj3SYFgOt3yxBfd9t6NVTxQhcmIzavHAjH7icvcxHFG5f/X9WFi2ED8e+PFon0ocVKJyHEIgGHcMvwMmrQlvnPIGTi48Ge9MeSfh9lYdISpywacj5FAIQ8vc7Uv/rKxaCU/Yg1RDKlZdsApPjX+qfefc0oLqe+6B97ffE/ZIaS84jkPAI+3va3ADLAvQNLQZSj2EYO/tMCkdRAFAq0ssQk0GeYdogBAVoaoHkK7tiJwRcfvmmKXBhzIrIypaDRl424yohN1o4Ts8d9XwxFNnhIf3/7AGZCLYPFJqK6cpNzmcQKh1wXC0kaRPtFWLEGLNKAuNEtd5rQXYT50GdJvU6jEECPoLTRsRlcYKD5z1ZDCcfHlfaLXKSIDexF+vGS+AogAjTe79YK9zJdLkqUOAr1Y65Zobcd2lwzAxh9zPhQ4PujcmrmSKRVpuPvJ6kfSQo5aQtv4TTgbFRykMZr5XECg0hZTfY21ZGdwNSnHtWDoPISuvT/ltBQBAV1QISqMR05UAoOsilUPHku2OQtAEJW2F0A5Ewgwh+VwA5C6iAMoMNsoBFGBNtwMgRAMgUUFaQyJcQW8krs1BZmFXhYhZjKh43Aj7JVISCQYwb+NBhdV8SWPrlUNHGoGI9Dtt8SXuPxVhWET5z2DSaXDtxO64fiLpa3WspX4YlkFToEnpBt1K49WjBZWoHIcQCMYJGcR7Y0j2ELw2+bU4fYoAIeIi2O4DyjJXALh75d1t3qD+iB93rrgTADAufxzSjGnt1qY0PPss3PPmo/If/0DdY637YLSGkD8KVvYg8zeTh6I2IwOUVlldwwjOkJow6q3lAID1hQtw4UOj0FHEGulx4BSdiYVr2zutNx4c/aBiW8G4DZCJU3nU3XIDOcckDzAhrVbqLBUFvIVr3iDvqdHAy19/myCcTSkAhl2BIGvBOU4yOIyKUrjB6W4XUYlqDNhkvBB/+k8DByWZO6gbD2ja7rrBRaMIl5cDAHRtDLzfvbAJLOMAx3rgaa5G2eYFivUG4XqNIGJto4Zcp7lrw/Dr+WN7asVSWGPJAtg2vQoNxaHo1lPaPFc5KJrGBY88K6aAAEAv+750BiMo/no3BJXC7bDfj/JtmwEAGj6NGIjSCPIl8Lpact30xcUAgJQZMwAAqTPPAmSW6tosKVr6VyBogg7FTt/nIKF/juUJB2UWP7fJqoMlVYqIAKTKzmghnznojcRpdQwxIncTH1FhGQbemP5Em/aQlEq2jeiBSo8xoiLXzCQzbwvKyIyRnxAVpJP76FhL/czZOgcnf30y5mydIy6TP+tWVq7EXSvviivEONJQicpxCIGoxKYjkkHQrcgjKrFEBQA2N2xu9TiVnkowHPkRdrTKJ1wtNSNzfjO3Q/vKEfAoZzEH9gQRNKQlNBOL8hEVho6g10Um7Jm8ENNnjURGl/Z5gcgR67Trj/gV5msCCmwFSDUqq2taIypUC4lihJM8wHqnkV42QrrNqjUjndee7KEZVEXJoGAViIolA6wpE980v4B91c9irmEkXo/y59MWUamvw8Gi07Bfeyr+8BJxcb5uJ/r5SSjYQ7UvLeHfuAmMywWN3Q7jCfFGdnJEgh6E3R8i5P4E5Vt+j1svRlRoDTD7Exh4ouJtacK7C5qwy5UFeOrEWbyxROojYxnSD71+/w322bNR/M037Tp3jVYrRlUU7w8yIOv51F1dUKnVCQUCqNlPdC19xxJtVCDMIWIh34s2SB61gh4l58EHkPfkE8h7/HGFn0rs/dFRaA9Dg8KWGkIOOJb8T9GStodlOBitJCIS9EiDl5D+CfoiCPmV5CKjSyHARIDF/wb2LIDWoXS6BQAtX/vtd5A07tAiOwCg2Xds6SWCMgdlt+w3y3Ec1tSsgSPoQDAibWPgP1cK32fsWIqocByHd3e8CwB4e7vklSN32L552c34pfwXvLf9vSN+fnKoROU4hD9KIh/tJSo2HXmoyjUqgrBWLswVfD9YjsW8knmodCv9LRoDZFDtk9YHfdJbr6CIhcamLLnk2MSzkbYQS1QAYHefSxLORBl+ZjO7//m4bPhF+M/sF3Bh3wv/0vvGln37Ij5FRAUgPXTO6XmOmGoTICcqsaF9DSP4qLAJDa9OyCQDvVBVlK41wyqLKM0vJ/b4NmGZOQPOYDrcTC78bDoM3GiYhLLkBF2u5YjW18IdYwZn19agD0e6QQc5g+hd0xqCf/L6krFj4qJccnAsBzbKE1guBFdjvJZISLcAAPqdBWPxcOl8oyx+rukLb0MVgh6S3hGIDABAZ4I2IwN5jz0K08D29aYBgLyeMqJiVP7GhPOpoXsAAGjeoyYc8ItRnYxCcg0DrAExLZxg7Ev0Ctr0dNhnzQKl14seMx3t8ZMINB/tYFztnwGXbm3E54+sRX2ZGyzD4ue3SW8pmiLVaXKiEgkzMKVIqRsBBrMWkcAa7P1jWVzqJ7tbD2DdW8DvrwBfXgysjHeAztUTYhVtIb+pHlnkN+RIkl45WvDLBNruQASukAuLyhZhXsk8XL/4ety98m4xomLU0WLKyyYQFb4S7Yv1Ffhhy9HtJF3uLk+4XD5OCKj2Ht1zVbsnH0dwBp14ev3TomdHbDoiGRKJaYWIyol5J8IddmPxwcX4/sD36GLrggp3BR747QEAwBPjnsDU4qkwaU1o9BOikmnueB+faIw/B9Pc/JfC3H43+aFTbBQcb3Tnt+RCVxivQxAiKgZDx4SziZBnUabVvBFvXETl+kHXw6q3KojKw2MeVlRixbrfakSFPYX188uQ0y0FxSekAX9+DxRPQHFKMbS0VtQl5dFGKXoig23IJcDe34Ghl6GpzgqAEJsaTxGKeeHmjlX1cK5dgfFXnwQqpoMrGwyC9YfAUspHQpq2ClaDA+BYcBSNgDfSphA5Uks0QXLtRSL4XGGwjHRflGxcG7eNPKIBioIxPRfAPsU2FRVN8DoIYTDKiQrz18LsaXky47aYCIdwPh4nGaTzevVF9Z4/EfS4EQ2T79KeTYhpMMRCN2wGsFwqKzf26w2EvIDeAvCDmKFXL3SfPy/p74GJsIiEGDFq0RponlixwfY3v1vx2R4EPBHMfXYjzr59KACA40IIeYlfkkYviYRPnNkDJht5DsiJCsfUgQmuxbZf1iItT9l2wLb0DmD3PGnBn99hen4Wfq7pKy7KMXpR5bcj2FQDZHRHd56oNB9rREVWSu8ORHD3yrsVVZDr6tah2U+eRUaZDs5mJN+dJxhFiy+M+78jZHBPnQf3TZeuw5FEMqNPf8SPD3Z+gDqfpO3TaY6O67gANaJyHOGZDc9goazBXHsjKsLA6Q17EWWj8Ef8IunIMmeJgs21tWtx6cJLFT18Hvz9Qby7nYQHhYhKtqnjgr9IvXJQj9TGz55bQ8NBN5Z+tAu1B5wAgFSZ+NcYbIGhW3w1iiCm1eoO/TbPsSjTHr6ITyQqZ3Q/A2+c8gYu6UdM4wZnDcYtQ2/Bqye/ivN7n6/YT5euHPg0TIiU2ALYuLAcC+ZsBz6fDXx7DfDlxaApGvNmSg/50TDBkoCopHWbDNywGhhwLppbpIdKdZ0ZMNrBccCq7X2xfSOLivW74vYXKqeCJmWVTl/TMmh1Uej5HLVw/VtDpI58t9q85N2Sfa4Qvnx8HTgmXvSpMQwT/26pt6Bil7SN0RKftvt5By1GowxdRwBTHgPyhwEDz4/btj2wZUr3t8Gk/L4MMuJCazQo6EciXl6HdI4p2eReCXjciAw/ATW8nlhjZKD/70jg6S7AfKnRJEDISrKIyvzXt+H9u1bD09K2hQBtIqJvLtB+uwFaI/0+6svd4DgWYfeXZAFlgUYv9cQaPLlA7DTtqKtByO8HE43i4NZ3xW0ctWT2Pfa8i3HRGAqUnKTw6H/a+bji6tPE1+l6QqyGuncgM9SEHll8ujoYRYQ5dhr5BWRExRWIxFk1AMCOJtIOwqiVExUp9VPvlr6bt1aW4EBD6ynZzoAr5Epq9OkMOfHyppcVlgvuNqKxnQ2VqBxHiDVsazdRkUVUrv31Wpz89cnY79wPgJQ6xzqWxrquCuRoUfkiso+5Y5EQNhQCww+EgpgwUtMxovL73APYs7YO25cT98tU1wF0KyN6hIjWgmBGMaIRZeWMEFHRHAaiotfooaGkB4837BVTP6NyR2FCwQQxzEtRFK4bdB0mF02OO44mqtQOUJBHVXgc4Bu+VW9E0BtB41oWFxdfhl5pvXBeiIOZ46CPGjF5/2UodJDZmNzLxtkiPdgbaxkE+8xGkJM0FT99VC8KjQVEGxsRNNgRkrkcn3//CBhvWgL6rBcR4QXZi97ZCSbKIpwg1y6QhagQUclNTlTWzysl/ilczIyZoqDRS+WcLbW5mP+a1AdIZ1RWX8XCmJEPjLsVuG45YG7bFTcRUjKl+1tniKn2khGXcRdchvR8EjXyCE68egMsdnINg14vLOZU3HaDFt9eRKHr5GaIxS+bP2n3+VTvJdGxPX/E/2aE5oFC1RglRlTaT1TkRH7PH7VgoxXgWIF4Sb+pnG4poDU0MouKkZ5fgGgohP3r16B003pwrPJ+oLUmZGQMQL5T2bhUxKmPIvO0W3D+Q0/iiudfR8Qs3XcX1XyD4gyLqDF2+I+dqIqcqCQrNW7iu5qb9IkiKhE0eJS/99jXRwKf7/k86Tp5JEVc5o9fdiShEpXjCPJyWEDqjNwWhKqfg+6D2Fi/Ef6oX/T9yLfmxxGVPS17FK/tBjt2NO7AfgchN7F6jbYQ4bvC0lYrjP3JINTRiIqrURnKNvsbkN1IxL9+Sy6++y6Aea9sVWwj+KgcjogKAPww8wexp5E8oiLXoLQJVxUyByhnJ9qYztZRTkqtfPXUevzxXQkmNJyD7876DmmuWkRZM67e8Cx6N43A6XuIg2wG763CsRzczdLxOA5o1g6Bl1FGSip3KwlTpKICrlSiu8jICOOaFycgu2sKkNMfVLdRyJL5xLx/52p8dO/vCr3Q2h9K8PF9v8PrCCFS1zZR8fMl5pyMqGgNBpz3r8cx+YqJ0FtnQ2+7QKGPaA9oe+vppvbAIuusHAkpv5uuA0lqJKu4O0aceY6UCuLNz/QmE8ypqaA1WnAcC2OAjLYlI4bCMHoGYJKVa/vaLiGWa4LcjfHpnGWf7MEv7+7EH98TgSrNEzmOT/0Ed+1C3WOPtdpRWfBHAYi7LBveL77W6CW9jlCCTFEUCvoTzY+nqRGuxnhROZCNxV/HONRa+fuhaAzAt5UoGjAYmUXFCMdE8lJNOtjNZBuH79iplPHLJkMuf+LzagmQ35YgpAWkiEqE4eK0KY1Hgai0ZvCZiJSUucriDEOPJFSicpyA4zhFeTGAVhusydHaQJpvyUeqXklUYoVTUTaKtbVEP2DT2TC92/R2va+AcAUpOdQXFUGXT0hOpLamtV3iIDi4CjAHGsV0hIDaEqVOJcrPfmL3/asoTi3GxAJS0eGNeFHrI2RL7pPSJtzVyBrgRXofSS8U+zmCLO/0SWfD20IeYnWlLmDfr0DjbvzqvEOxvSlsQ5oxDUs+2oUP7v4NTZXk2CZeS+JpCcLHKHVFXlkagXE6UXPvffBYiX4mvwvEclMAoPQG9Cr5FhQ/a46EGERCDCp2SWRn06KD8LnC2Pxzqejhoc1LXC4PEPElAIAjD/szb78P17z6LroOGgKL3QBaVwBa2yVuv9Y67Fq1ISD10IkKTUv3S2ZRsWLd8NNn4qYPvsSlT78MmtaIRCUaIt+TwWwGTWuQyoum9z/zCQwhGi4mAFzwX+DecsDOC5Y3fgBUxOty5JBHrhKlfko2E43PzpUk0kjxqR+WT/2UnTsLjs+/QNOcOXH7CseP9fDhWPI7yuneE1rjWHF5Qi8UrxvOuvhJB6VJYPR34efAkEuB2f+NWxWMidKy0QjSePv5ZH4lRwMBWXmyJ5SYqAgaQrlGxarXitG0748BoiLvDxeLRBGVKBvFt/u+7cxTahUqUTlO4I/6wfJahmnF03D78Nvbva+gQUmEXEsuLPrEs9bpxYSQ7HXsFcvYbhp6U7tFvALCBwlR0XUtEgevaAcjKvJZHwBYfLXQRgPQtDIzEB7AWv3hISqApPdpCbbAF/FBR+tQaCtsYy8ZXGRAobMlN1J9KJaokAiYBxLBtOq9wOfnI8DaUBEertg+z9MDhqgZe9fWiTbmANClt50cpzkI74j7Fft4HNLDMbCdVHf4+EhZeo5SLEsb9DCE3ehd/oNiuYafMSrMonhfG8pgUGgu1n3/Nb5/7jEwfA8aluHARCrAsYTspGTliNqHWLGuSGogVdkAwCVPvoTrz+2KK7pvwsXFW3FR8dbDQlQA4OpX3sasBx5HdnH3uHVGi1UkM4YkYlv5NRm2zy5qwgAAOXzJ9vIngA9OAyLJ72F5e4FQ1T5g2ZPS64CsRYA5AjgrQXuIwzQbDCjOQW4PIMfu38nvkKYp2fdJzmfc7Etx+dNS+lIuwBa0QmWbN2LbYl43R1lk29qVb5TRCygYDpw9B7DGp45bDMrJVMDrRrqFj6j8hdRPIMzAHYzgy/UVaHC3Pw3WnuMK8Mf0qBqdNxoA4I44ARCzNwE0TcGqT1y7cjSISrIu8InW5ZhzMCRrSIcrPQ8nVKJynEDwQNFSWjw38bnD0q04zZAGs86M/un944zbKFB4aMxD4mvh5h2dO7rD7xOuIA9PfVFX6PiKCs/iJQju3Zdwe9+69aj51wNg3GQAj0YY0WZdgJYJggJgjqm8kT+cBaJyuCIqQHwvpV5pvTqmiHeTAUNTJPmL0JzygRfiIyqBoPRgC/K9W9zR+OhYlrcQVbuVjq7mFD3S83hBYksQHq1SbOxtCaLhIClHDVcR8uTlK5uE/QRQBpJitDmUXbNDfOhbPphGPKR0XpebK87AOY7Db19+gtJN61G+jTQWDHrDiHglPx259iSWqIQDUfF7HT5jJiz2NIw481zk9uwN6wVzkFlYjDyTBym68GEjKml5XVA8aGib28WamdF8OTYli8rkNRvhDDmlASC7v/IgnuTRRQVRCXHAqucAlmiEvvz3anGdJVwKvDIA9JrnARAxrdASAQD0CSqwyrY34bdvSJonNceMkWcUk89Ak4HdZEtBSoakg0vLkUiZYIrnrJcmHBqD9LkojZ2cBweS7rr4q6SfEQAqoSQvQa8XaXzqp6MRFac/jInPL8egR37Ffd/twAu/7u3Q/q1BnvrxhiUClGnKxClFxGCw0U8iisaYlHNKTN+frhnkeh4NoiJYXPS092xjS+DSfpfivzP+i0mFkzr5rJJDJSrHCbx8nxar3trulI8ciXQlhSkkElCUUoRfZ/2KsflSmDfNmAab3oZPpkuiv572nuiZ1vaNHYtIBdGo6IuKoC+WfDo8vyq7ATNeLxr/8zoqrrgCru++Q8PLLwMAfvvmgGK74uY14t8WvzIyIw9jC3/rjZ1HVPql90uyZRK4CFGh7ckrpwTha4CRNY3kn4luhjzQ83qkot85dgBAf3YYmquU3gfWNANSMsjgX7a1CQ18I8csHdEy7Ftfj2+e3ohdqw4icvAgohojQkYS0UgvtCuORfEkwuKrhlYvPTJ2rqoGx3HwyqIzHicZVDS5edi6pAINB92KhoGC5iLgVYbN5X4l5hQ9bBlGMZLCcdJ3abGn4fq3PsFJl8qIer5UJYSU+HRRZ0IuvAWA2v1kUJx63c3Q8Z8pxa+DIURLIfWcGKLiTh5dlEdNwoIpi/Mgqvc64HXHp8EoLW/Z73IhuHOHuDy2bUXQG8HCN7aLr9NyzRg2tSum3zAAFMUTFd4vZebtQ9F3TC5OPFuKLsndewVoDUOk86BJOjkKPXDeB0BGj6SfEQDKY1KTQY8sotJBorJ0d4Ni8P96Y1WH9m8N8oiKNyJFQheeuxDZZvKbLneQ+90Y06YjTZZOvXpcN9x+KjFz3N9wePoZrdjbgPPfWoPSdvRHElzIp3adih6prX83R7rpbCKoROU4geCBIu943BG8eeqbcct62XuJf+dYchTNDtP5QSuw2obn9B/i4j4X49Gxj3boPSP19dg3bjx8vxPHUX3XIhi6d4eugMzuYt0zG197TZFLD+3Zi6o9LfhzFRncU7NMOO++Eei+R3IZtcTkUxWzezGicvjsgrS0VlFtFVu23Cb41A9lk651rEYlxKUAFI0AK6XsQryzqafv9QAAW6YRA/oS0pjqzUFLrbL9gd6kRdcBmbCk6hH0RVC1h0RcumYqr9f6H/fBX1qGVRNeBABY6GYYY8pkab4broaN4oxreyONj7g0VXqx67ca+JzSoOB0AVGNEQ3pg/D73AP4+qn1eO+Wa8T10XAIDMOisdKpeA95RIXW0Ljo4dG47MmxoLWElMu/1ziiniULSce4Anc25KkoAMjuSgbzgn4D8H8ffyNWBWU5DRJRKRipPMhHMwBP4qqKkCyVF+LM4DgKaNgtistNNPleQzyJofneUeGyMlTfJqWH2RgTtvULlL29UjJNaCgvwbwXrkc0TIiBoEMp6JOGU86xwwBJzG+0KZ9DQ6dfBIq2QWMYDo1+oJj6CbMWILXt1OjeoHIwDHg9SOOJSktM6ofjOFS2+BPqlTiOw887lcTPqKMVbTcOBfJ0jz9KtDxphjSYtCZR90Fp/Pz7xhAVsxQpPH9EAcb0IDqenTWuQza2C0YYXPnhBmwod+CD39vu2+aLEr2jWWfGyye/jKldp+L1ya8n3FZDH76J3l9FpxKVVatW4cwzz0R+fj4oisIPP/ygWM9xHB5++GHk5eXBZDLh1FNPxf79+xMf7H8cQuon1vW0vehu747F5y1W6ClitRXdUqX0QIYpAz5XCFsWV6B0pRvnUldhUNagDr2n86uvFM3RdEVEl5F+xRVgKRpNX85FxbXXiaWUgW3bFPtzkQh2/UbC1xotjan/OAGZ6QAi0o/a7lTeL3KNRmekfgBlVCXd0IESWJYBPOQhKicqxQd/RoqrFBRHBmMH1RMcy6KlSZplBiNkNuaOkGUpGSak5ZLzCHojKN9OFPmF/dOhN2ow/vxeMFp1OOUq5ey9x5nTMNomheFzuU1oPCDpF3SaSHxZr04nmpPl5OrQe6REzlZ8thcNB2XGX5QGtbmjEcgiA7YgzBQ/h8+HnSuqwTFKYXhsGbDOoIHBpIXBREhmbOpPgeFXAl2GAyfeCPyFaOPhxIxb7lS8zutNyseznAbUePlUjL0IuOBT5Y5LH094vFBduewVjTBnwrp35+H3uSTKmKMj/4c4nqhoE3uOeH9fA8+KFeA4DvXPPY+GLUob++HTuuLLf98Lho+8aLRaMSKEuh3AK4OAN8cCHAeO4xBeskzc9/yHnsSw6ecAAHTmk6CzTBHJZJgzt5mO+7PGhd1OGud32ykuC279EWdVPAsNmLhB/LWlBzDhueX4Yn28Ydn2KheW7FaaSwYjLCodEpH3hqJ/ibiUNHrx/m8SCQhwJO1cYCOfT9QC8qmzWKIiT/2kW/TISTGie6YFHAfsqG5f48xkWL4nviVKaxAiKmadGd1Su+HFSS9iWM6whNvK3cuPFjqVqPh8PgwePBhzkijOn3vuObz22mt46623sG7dOlgsFpx22mkIdsAD4H8FAlH5qxEVgAhnF5yzAGPyxoCmaIzvMl6xfka3GeLfeZY8RUh/yYe74G5uv9slEG/yJjhv0mnpWDfyIawb+QDqNx3A3k9+AQCw5hQwtDTr4CIRVPLai7PvGIrsrilimSVtJYQthRcPChBmoBzHdYqYFlCSxXRTB4iKpw7gGIDWQlsohVsNYTdGbHkRo1M3AACqDFPhrTbC2SIRlShnRLTXTLgDZECyZRihM2hgTVeWqE+95gRc+8pJYj+jwr7pipB9Sv+hGPH48ygybgUAcBwNP2MX15sKugExmhuKosT0DxsKxfnVrJ+vnMGVdp8JuidJicUaugW9HmIaxymJiiaJ1b6eJyryiEocjCnAtcuAaU8n36YTMf6iKwAAU2/4P2QUFCnW5fcSiIoeB5yyFGa/M4GcARBpRe1WyUk3EiDpoO1fw7/sbfnhEGIt2OibLb7OFomKDRwHUJrEAzDrcqHqhn/C/dNPaPngA2h2bRDXnXbtABjMWtFZFwCMthRCNup2Am+NB9gIIdn1fyKwZSvcb0nnld2tB8ypid2KQ4YugK51v6fP11UAoECnpGGgnRB597ZF6FfzHabRG+LcaV9eQrRt//p+R+yhsLeOPCfH9shA+TOnY3hXEuX45U8SsdpS4cCQR3/Fs7/sidu3LZwzR9mLKghyrsIET/CrojSk63SsRkUjI9FCdCWLb77oDPz1EuyKZj/++ZnUp82XpBO7HIJGxayVdEfyvwEiDn5i3BMYmt22Vquz0alEZfr06XjiiSdwzjnnxK3jOA6vvPIKHnzwQcycORODBg3CJ598gpqamrjIiwop9fNXIyoCKIrC66e8jkXnLopTcedZ8/DcxOdwef/Lcf2g6xUhfQCo3KVM1bSF4M4/xb/TzzkFVPlqIOxDxJyGgDkbQVMW1o96EMs22/D2rSuxyHAR/hj9b5GsREKMGCER0g1ChEaTkY7cRx4BBQ5nTJQIlM8ZQjTMgImyoh5Cdxg1KoCydUFrZX5x4IW0sOXDNHIU0q+6SrE6I40ct6mBg8+fjoAxphHilDfg4cuVUzLJw1+IqgDAyZf1VZQVCxh2WlecdHEfnHpVf+iNWsCYgr7nnQkACEYtCpO3ky4bGLc/IKV/uFAoaYRq4M63YQg5wGgM2L6MpLiEqh4BQZ8XTdVeseFdW2hXROUoY9RZs3DNa+9hwKQpcesyi4gmy+bXiSaLAv4YfSXGdi3AfKsZqN8JPNcdqN4MfHwW8FJf4LtrURZSpok24kbF664GIk5mOS2i0IupHwEruwxWvPZvItvLJwTFAzMUdvgAYE61kz82faj8QCXLwPp8MEQZ9KlpxqRZF8NosZL7KgHC1l4JlwuIMCx+3EoiTYYug5BtJPeF0PRxAr29Q2LTlftIdVV33tn23GEkGrB4F5k03fnNNkRZDm+vLE18gCRo9obiDN4YLTmmQFSEiApFsQAVwcl9lDo0Vpaq0vMVVql8lMX9F4lKIMxgYUyqqy3xMcdxKHeVA1CSEw2tUaS1pxRNwcyeM//SeR1uHDWNSllZGerq6nDqqaeKy1JTUzF69Gj88Ue8LbGAUCgEt9ut+Pe/ADH1oz80ogIQl9U8a2KPi+ndpuPukXejwFaArUsqFOtiTcJaA+vzIcSn8XJGOJGp+wz4+Ezgp9vBmON1BFF+FhA22OHnfUk8LvJg0MtSAEL7em16BtIuvAC9N25A14tPR9cBJN+75KPd+PThtQgHpFmFTn94b3M5WTTSyUu/4yB4ZqR2AUVRyLn3Htgvkpok6l0NREDKAe7BN8HFPwAF/5LKvS4468lMSBDK9h9HRNJ6kxa9R8XrZfybN6PhhRfQf3Qm+oyWKoYMvKlZiLEgyBOVoVOLkJGf+P4SKn+4UAgDTipA9yFZGHeqHXpKeiimukqR1ah0T+YYJ9mf78sUcLvhagy0m6gIJDPW6+NYAkXTsOfkJhS5m1PJtTWGaext2QuGlT7HzX++BR9N419ZPCENuYFF9wNV6wEAUU6HhggRXOoM5B7e3TQEAKBBBFdnX44sbalIHPf2egvUGc8o3n9PmiRe5wCU1JrgsRYgyg9IJ1/WF1q9Bp6mRsV+Qqk4qBhS2rCLpDAB9Gh0oqcp/v7XUgF00ZNoR8BQFLdejoPNfnhDUZj1GmScMBm5RvKcqw3YEGFpnKdZhWD9PjFS0hpW7mvEgh1k0C7iW1X0yiaEp9ETwjcbK1HaKN13HUn/nP9WzJhERUGZyfNN6HBu0poAjnxPb1/eHxN7K4XWid5NSAe5k3RPbw0sy2HGa6vxzM8kOiR8Zmcb5dwrKleIZpWxVhPyZ5tcCnC0cdSISh3vXpmTo3y45uTkiOsS4emnn0Zqaqr4r7CwbaHW3wGHKqZtD1iGRW2JCyzLoa7MhdoDJG+akkUeaiWbG1Ff1j5iGNy1C2BZUGYaC1JfxHznI6RUcftXiBha/wwhQypqc0Zh3eC7AQC2dDIoe1asgPun+QAAbSYhJho+BSSf5fucITgbyICu0dGKXiaHA3JH4Ive3IlNB2UErmoT8MlMYAuvQfjzB2DVC8SFdDFf7i1LF2XfeRcM/UiaJNrcDDtfAlrmyQNH62AItiCzmTz0V3wmlVla08g59ByejXPvGoZz7hwKrS4+0nHw4kvQ8v4HaPngA8VyPf+AdFDFCJgy+WMmt6cXiAobDCG0YjH6r30Jhgcvgb2eVI5oI17oI17k1a1T7MexZIDRGcnv3FHnADhAb2rfLFkQQkfCxy5RaQ1mvpuxjqHh9bmwTnZ9wmyCAaVSMoAT/HQoCkiPIZDmNBNMxQNBTX0Mw04jZGRHaQHoMVKUbs3AAdiU0wcBQzpC+lS0pPXFNmokNoy4Hx5enyZMACr+3K44vs5gBDb/F1ivTD2hcQ/YgBTBFKwHAEDL/wbTNDVI1ZAoiSNjWrJLAwB44RdyT/fKtoIuGoUsow9WbQhhVovNLV2gpVgMoUqwer9EpOT+JL6QFOX4eoOkWclJIfdyhpVEjsqb/bh7rvIzlrSjOgYgEYjSpphUpbkEtNaLTGMWxuST7tcURQEseV9aFy9fKEyL958SIiouWUTFF4qivKltIu8KRFAm225cT/JMdCRxzBXw/YHvxb+N2pgWERpZpC21uM1zOFI47qp+7r//frhcLvFfZWXiDpB/NxyqmLYtcByH5Z/uwXfPb8Ku1dUo3ybZJQ88qQvS80kodcXn7cvthkpIaDWSkwU3k4vq8EDURvgBWdN6zjpksKMpUxLuGsxaRBsbUXXDP+FZTPrgaNKVzpex6QhPE3mY6g6zPgWQvAfYqBmegA6z3vwD1c4AEA2RqFHpCnAL78bqHQeAb64Alj0OPC8zDusiidY0VgtyHyIExvfHH7CZiWqh3kkeIGZ/fVxlk8mmU5CvvJ52ZBbISpn37kW4SmnwFZCl4QAoQvXNGSTdk5ab3MiPNvIRlXAI1bffAf9aMqD23j8XXapXYcTmFwAANm8VeurLkF2cgpMv7QuOJYOB0UqISu2+zYiGtsNsIw9Ta0YmLn36laTvK3yvkeDxSVR0BiO0enLtjGEN1lST0vrWHHYFCH46RosWFrtSi2RKMQFX/wyM+z8MnNQFtIZCS40PbkcUXf85HF1PbURB3xZENSb8MeZxrB31EBxpUpfesMEOgETi/G4XVn2qJLJanRaYd3P8STXuU1QQRRslAjHr7mHokXEAU+wvI0NLorHNzcmHmIpmPxbx2pEuaSYgrRgaisPwdHLv1gTIPd2NrsP8bTV4Z1UJftxaDYNM+/HTdskrptYlEaiT+GhGpiW+zYhgbX/hO2vhD7edUmzyxhNKjY48j4tTekJHS+lWjicqDYGDcfvcdHIPzBySj/evGCEuSzEKqR9yHjXOAE56fgVOfnEFfj+Q2LI+wrB4+ufdeHOlUhA9qhvfLLKN1I9Q0QkgrjRZ7kourwI92jhqRCWX7wNSHyO4rK+vF9clgsFgQEpKiuLf/wI6O6Ky5rsS7PmDPDRWfrEPmxaRH1p6vgX9x+dj/Pkk1+xpjp8pJALjJCLYsFn6fg6GyAAtGIVlZGmRm6D76N7eF4HNLRZf9xmdi3B5uWIbbYZSxBqrQ3Hy5ZuHu+IHAG4ddituG/AsAhXXQfgJnfbyKmD3fIBvc0BF/Djw1b/id7YXAWOUXUtNQ4dA36MHEI0CawkR80QJmTOGnEh1KR9IVzw9Lum5RRsbUTbzbJSceio4WZdlLqx8eAkiVTlyuycv7aX4wbbiSqWuRh/xoM/+r2AOSAPW4Jx6nH/fCPQfnw+dnr9faJkw2L8EFEjEa+z5FyOne3JvHpGoHMOpn9ZAUZQYVTGFaNT4yMBa5lYKkBPRFsFPx2AhvjJymGSmeAazDtld+RRHpQfmUWNgzozgNM1G9NaR753RmlBZGN8kk92/C3t+j28cqOOS/M4jPrDf3SK9lJnKZRbYMO3EP5GmrUaGljw/mquTRy1Km6R1s6vWoebRJ8FGKWQbyXIHbwLXlarDtioXnlq4B7d+uRVOWcTglSX78fGacjAshz18emjJHRPFPkEpJi20MkfdR87sj9cuGgqaApp9Yfy0rW2H7IPNQtQiCnPxHPQeMA8GPYkIbj8YFjUhHMeB41Ohz2x+IO44NqMOr144FKf0k7IIKfzvUEj9bChvQZM3BI4Dvtuc2E34j5JmvL2yFO+sUupsJvQi18sTiiIc03RUDsHi/4HRD7QqJfgrfl2dhaNGVLp164bc3FwsXbpUXOZ2u7Fu3TqMGTPmaJ3WUQHHcdjbshcRJnHI7sOdH2JB6QIAnRNRYRkWWxdXJFw3+fJ+0Bu1yCoiD8KQPxpX9ZEIjMMJAAjL+gj5mAyA1iLEz1BSMw3ov/dTnLT535jxz4Ho1vybuG0zQ3L7o7Vr0X98PsIVyshZWxEVB+8rYrAcPg8V8b1pDczMALAhiVB7Q1GgUpn2uEr7S/zOs96Pq4KgKEqMqmhrlQOYxUoj3bEHxhBJLw2dWiRanSdCqExWPrl1q/h3nOHXcuW5FfS1t0rqhNRPe0BbSfQtEg4hHCQPeSZiV56n3wkAsNpbr5oSImLHK1EBAHMK+Q0YwxqxRPmXMuX1d878T9x+QurHaNHFufWarErRtCCqdtT6gOFXocVItCEjxS7IpHQ8Fs1PPoKavbsAAGPH98egYh10WhojG2S+SzkDiWmbhQyEHCMNYL7Vq+GUFz+ECFnI0JHniac5GNdpm2E5/FHSTHQnHIc5699Bzof/gWvut2jcYUO6nkwynD4OUZZCMZWo6SFBrSuIf8/7E2+vKhE9ToS0D0B+W4JxHABk2gw47YRcXD6mGABQ0tR2+ueHrbybtKkKGlMlapk10BlIWtwb0OOlxSR9FYywoLXS8WK70CdCrJi2ziURxBV7GxJG3mqc8dWXpw/MQ4ZFDz0faf1qQ+LnOQA4gmQSKY+sCLi036UAgKfGP9XmuR9JdCpR8Xq92Lp1K7byD8yysjJs3boVFRUVoCgKt912G5544gnMmzcPO3bswOWXX478/HycffbZnXlaRxWN/ka8tvk11HoJk+c4Dm9sewPnzT8PT657UrEtx3Go9FTipU0vicsOh5g2FIgqZjqt6U4E0abBrBUHyNi+O4nAOJ3kvfR2cZmfTQPYKIJuPh3Al+ZpPM3I8uxDZtnq2MOAriCCtbiISmYbRKXOx593B+zt24sdc+Et2xS3OFBFcuBNg5WVGZ5eZwMXfQU83AIUjkp4SPOokaCMRuiDSiv8jBMHgQKHwdtex7Sr+2DMOa27SDIt0v7uBQul5S6lT0NonRTJGtPXhan/GNDqcYXUT3ug4Qdmb4swSGoRiSgdfd2NpCrIktYGUTkOxLRtQaigMYUIUeE4DovKFym2aUqgo5KnfmLJqcmqJC4CUWms9AJ6M5ZkXAKG08IQUopZM5p3Kl5rfS3w7yfpKHvpdzjVuAw39liFVA3/fBh8EfDP34ABswBeEM1GlTPtuof/Lb0IOMk5n/ucWLLcUqPUW/zz00246N21ePrnPbCHvOheI7XScFXYYNaEodNS4DgO7ogRxVS8ZlGvpWGX/bafW0TIgpamYI0xeMywSveuQFoKeeFpVUvrlgscx+HbTYSoXDlRigrSZjIh4BgTShrI5/OHo+A46TkUiratwxJSPxvKW7Cnzo1aGVFp9oWxen8TmBjRb71bedwMix4vzh5MBPqp5LM+9OOfWLA9cbRIiKgkcpy9ddit+HHmjzizx5ltnvuRRKcSlY0bN2Lo0KEYOpTUYd9xxx0YOnQoHn74YQDAPffcg1tuuQXXXXcdRo4cCa/Xi0WLFsFoTC7qO97x2B+P4d0d7+LaxdeC5Vh8sPMDvLXtLQDAt/ul7pR3r7wbZ3x/BpoDSh8Km+7QUz/zXtmCLx9fLxp1tdSSH1pB3/gb18jP3CiKEmd1HSEqQa1dXObjCLkIuQSiwn/PHAfXDz/A5q1C14MxUYjKA2BDIYRKlWFOTXpM6ifm4SR8pkTluoeEuh3At9fg2t1X4gqNdK5pcJPSUgCledPxcVQqVa3NnwL0mQa04vBI0TT0hQUwhJWEIrVLGmibDRZ/PfK09W2GY+WaAbmBXrRGCtGz4TD869Zi8LbXMWFoAMNuOydu4Is7P1PbjSiLPvwA5unTsdHThP/edyu2/kKigFpDGigq8W/a2hZREVM/x255cltIySKhfqtfC0fIgX2OfSh1lUJH62DntSI+rez65xDSGBSJig7dhyj1Akab8r7OKiLblm9vQmOFB2UROxoiPRFmldf3xC7fQMubffXa9wUq0/SobCIk0KyNgKIALS0bGAtlvb34iC8XQ1S4cFiK2AV4omxKQwava2uStXf4s8aFX3dJEZJCjzJawgQ4hHr/HyzppLQ3wOhg4QJIZ52K7QrSTPj0mtGYPkApE7CbdXG/kZwUiahk8qSlII1ENascxOE2kESs7QszCPAR5FpGmkiFaBLh5RgzglGy3h9mEKiQWjsEmbbT5AXp5DyCERbTXlmNj9aUK9Zf/sF6PPPzbsWyupgmi6cPyoszlwOAj/8oj1sGSBEV4d6Tw6g1ors9vhHn0UanEpVJkyaRvF3Mv48++ggAGfwee+wx1NXVIRgMYsmSJejdu3dnntJRx8b6jQCAg+6DmDJ3Cl7Z/ErcNlE2ikXli1DhqcCyimWKdYeqUQl6I2g4SMKzJVsa4az3Y9968rBIz7fEGXvKf/TCDMkRY9eeCAJR8WokLwEfS4iKv4U8uEwyFXxoDxHpZk5Wpv30ITeY5max1FmANkMZUYnr58M/a43Ww0xUGqXKm0d1H+M0egMGUqX4t+4TmKgwytgc/PeACR8w08XtKox9Ex0pDrqirjCEJKJi8xxEfncLrCedBADwLFmabFcRcqIS2iudK+NygfUR8tb44kuI1tUhw7EbPYcl7zkkR8qM6W1uYxkzBvtP6Imdv69AQ1kJNi/8keyblQtQ8REZWqMRbdqTQSIqyXPuxzrsOWQwTQ8SsiY8A7qmdEWuhazzaWREexAxdJM0KjrY0o04+VLpPjLblMSyS5805HQj13Lbskpwu4vwp38qAMBPcSjUb8VI6xfomrodYzc8jImr74DWtwV78qUogUUTBnRmYOS1/Il3BQZL5fPgUxksE0+Wa+7ju3PLiEpWGvnODmySXFMX7lDO8gu9ZJ31pJNgmTCBfG7DIJhS7ACAFU198NrecTi7dr6ieefU/rkY0CUVb146HJP7SvdwbOM/ACjOkDlJCxEV/tmzrcqF6a+uxsgnl6BeRgB8ER84jhOFqUZrDVZXr4w7NseaUO0gUZlAhAHj7wGw5D2EJpQsx+Kg+2DCNE7f3BTRlE6ONFm06N3VynRwbDfo3FRpEuCW+Q2VJOghxLAMXPxk6Fjo4dNeHHdVP8c7Mk3Sg6HBH2977Aq5FC3hXTEz7ENN/VTvl1IDzdVefPHoOtTsdwIA7NlmnH2nVJEidzQFIFYe/PG9sklgIjBOJ1iKRjMtpSpCjBleJgPOJvJDsx/8HLSZPDBCB8gxT5hUCJNstqhhwwiVlCISU92liylLT6avMJoPs0bFo3zQvq1/GfMND+JsDQmfPxW9BPN3NuAgl4P3o9PxTvR0VETb516rLyyELiI9XPJr1kBjNsE8glQJhMvKku0qQk5UYnUpEb7sv+Xjj8Vl2rz4ZpWJkDJjBnIffwyF77yN1JlnicszriWDWsoZZyDgcWPHsnhdTmp2Higq/lFjtqeBolt/BB3vYloASM0hnkV2nqhsbdgKgFRVCIZbXr0FGHg+MPRS0goAUv8eoTmjXdG9ON49uKAPGXj2rq2DLWLE3uDJAIBqbQhnpT+KUdavQVFAaoYDWiYEh0UZ5TIgAoy+ATj9BeDuEuD6lQo9FTv9ZXiqjIgGyHdiGSeJut0LSPTMX+6Gt9aAiJeF/uXbyPvvdYjf364aZZq50EPuV323btB1IfdipKZGbIhY5+MbYoa96O4vhxV+ABxmDJQiKY+eJXUiTxQZkWtUBEdYIZIBAHvqPPCGotjK959aU70GE7+ciOc2PCe64tpsSXQyrAGN3hCiDCtqZCiOfDdC6ueVza/gjO/PwBd7vkh4iFcvHIIHT++HFFklnlxwCxDDOQB4/7cyLI2xy++fJ5H9DFlktNkXjjPL84Q9YDlCIFMNR7Yv1qFAJSpHGHKikgj7HPsw/Ttp9lrpUQ7Qh1oy5nNKaZuDO5oVpkf2XDPye9px01uTcdNbkzF8WrFi30GTSE+LgCfSpq9FyOXBjgHXIQoj9EaN6IWyyTcLLid50NnLPgJlVgpLTfvexZVPj0XPEdno5SE6isprr+X7xUsQnFIFJCUqhzuiwnc/fj86HfVc/IxkFSuUVVN4PHoZnopegqZ2NhzTdy0CBQ7dsR8Zzt3IrV8H2miEJp28D+NwtLo/x7IKAW0sIrV1YEPKB5cup30RFYqikHb++bBOnAg6RXrAZd5yMwrefAO5jzyC+rISsAwDW0aWollfanbiKj6rve0Z3d8h9WPPJoOOyUsiEZvrSYow25wtTjx8UR8w6z1g5hxAo0P1OW+gxUr8UYRrIK9sM9niU3Wp2YnTc5RGObPOG+FC2unj4TMoj1H7e29w4/leRZZMwKT8fppX16Hqt3R4qshvVpuljGpyoRAO/mxA5coM+HeVwxRoAs2Qe9/P6yp215Jo7l1Te4OigP40OTddUSF0+cRFNlpTA5MtfhDtG9yP7YZr8Yz2XQzsIq0X9CYA0OSN14X0yJImdxq+AkjQhshRxUdGrl9yPcJsGJ/u/hQtPnI8gymxjo/jNOA4UsLs5UXDNMh1FVI/H+4k7r7Pb3w+4TEK0sz4x4Tu+PzaE3FK32y8euEQjOmuvLYljT6wLIfHf9oVt/8J+amArwkoWYYXzx+M3jnS593foDTKc4TIM8SmsynKqo91qETlCIPhWh/gF5QuUGxz0CXV408unHxIEZWAJ4zVX+1Luj6vlfJUAMjvbYeW9zDwu+IfCH53GPVlbmxfVoF9WaeK/hzp+VYMPoVEQGrC/RHl9KDAwKZpAG2Q/VhoDpp9X4D+/h84baoPfei9ce8BAMZBCZojJpFuHHYxrZuIQA9y2TigUUacHrI+ihDiB5D2WoDrConwsXflfAze/gY0bASU0QgN3804sHUryi+8SIyMxMK/bl2rUZdITbUYuQKArDvvAKXr+PXJvOF6GAcMQO6/Hwat18N28snQWC1oLCc6orxefWDPkZyPU2KEzwIsaYmXy6H9G0RUrOlkcqIJs9AwQEOAzIizzdmwaEnUxBfxodxVjgd+ewBLDy7FtK3P4I8oGeQFoiJPb8ZW/QCAPTuxP5GFVurcdBYGOc+8Do9Rea8yjQ6wkeT+Lq7585THSVO+X6RKKqP/fv5GUJA6g7c0B/DBb2WivuKyMcVYdOtE9Kf9aMoYgJ+35aKWIhOhSHUNNLr4SOgglICmOFyoXZFUqxVh4s9/2oBcXDK6CM+cm7g9hIDnFu1BlFGmGFv4Fh60jgzw/dL7KdZnacizaPKLK7DoTxJt1fBpTiH1I0BuT58IA7qk4v0rR2LmkC7IsyujXdVOv6Ln0asXDoHdrMOQfAvpF/TGicB/z8HQyFb8evtJuD7vAB7S/hcOj1LILAhp7UZ7q+dyrEElKkcYgnFbLB4d+ygA4NfyXxXLhYdaF2sXvDDpBcU6jmHA+tvWiwj45b0/k64bNLkgafM+juFDmhQl6lR8LmWUoLHSg4/v+x1zn92I1V8fQHWXk8R11jQDUnl325YomSWmaauhoRjQfqmMLmuAh2hk/vwO+O/ZYH3KWYw1P4ickX4UPhPvUSB3ZdXKDKFim/YdMpwkwlXDZcKrkw20N63Heo2y++iEXmSAOtjsb5fTpL4rISrh0lKA90ChTSZo06SZbWDrVlTffkfC/f1biH298YQTFMsNfUhPp9CevYjwolrT4MHI5NM2HQVrNmHH2KGoK1KmjRorygEA2cXdpV4xAFIyyd9a0yTF9raMtonK3yH1Y7BYxAiTISzdp9nmbFj0hKg8t+E53LLsFswrmYfbVtwGANCx5N4VIinyezxRRCW7OLHeJ11DooC72UI8HrkUc7q/ibqGZgT54w2obMS4fbw4tJWGsNpMZTSXZpW/z2i5LCXMV+npI+R5d8N7G/AYHw0YXGhHqkmHPrk2ROsbsH3gP+F0AXuqSGQkUlsLv8sZ9/4Uk1yndN1EMmm4/qR4IaiGpvDkOQNx4ajW7fxDURZXfqLUodz1DYl+sRpivtY/Q+pG/tzE55CTQr4/f5jBp2vJs0zLE5VgVHktjZr2F4nkpypJTY0ziAYPOV6mVY+ZQ7pg7YwGfO88D1j/LuDjU74HfwfCftzveBjXaH+GvexnxXEEIe3xpE8BVKJyRFHpqVR2UAVxOX107KMYlk0GOU8kMZGZ0W1GXKiu8vobsG/sOETbSAkAwI4VVajem3i7yZf3xbhZiU23vKtWYe/wEaJXgqBT8ccQlYZyd9LeGRa7IS4Fk68jpElrlB4+pkzZMSN+sA5l/xF9ShTpPZzQro4nKnk9UzF0ShFOvbIfRp7RDUUnZGDCBb1R0Psw/yAd5QCACi4bm1NOIcsGXQhk9UFUZrA25+JhuIL3alhf3oJJL6zA7lpyjWJFdfXuIPbUuaHLywO0WkWaizYYxIiKgMCWLfDI/IfCBw8iUlOD4HZitW89aaJi+4yriUmbZ9kyVN/yfwAAbXb7Uj6JsG/t79i/bg0WvvY8Gsqlaiyfg8zcUzKzFCLZlCyi0dEah8Fgvx39J05G8ZDhGDaj7YZnfweiQirmSLRyhI3MwDWUBgMzByp8kcrd5Yr9dAxPVPgJhMVuwKDJBRg+vWvCVKdGS2P2U0oxepqmEmcb5wIAAtpUvM/MwJI/yvD5HdcBFAUaFIqhRWqA/PZYGVFh/X60fPKJ6HKszVSmrY26KsXrwHapymx0PalU0fMTM6Ps67v3NEKcGY8HvrD0XHA6OXAg+rYufZVkGwCsuuTD1d2n9cHcG8bgzil9km4Ti9MHkqifXMOypqxcsQ2l9QJUBB6ORLaH5wwX16XqU5Fji58I6WieqDBBxW891q6+NcRGVKocATTwkdksvlrS+NNNoNgIsPAuaUONHtizQHypdSv9VMTS5I40Uz0GcPjdsFQkxdW/XB237PmJz6NnWk+wHAuz1iy2345FIuGT7zdikOb55VekXXgB6p9+BqGSEhS+9SYorfKrXRWT8knJMsHNu7dmFdmS9sOpvvsecMEgau+7HykzZsDMl/p5HUFEI4w4y2utZFln0MQRlbxMNxABtCbpCaY1KGdMnKcBwi1qzg4hox9P4spWkciGXRLUUhSFsTKyJfQ/OawIOICgEwBQyWWhNr07cNEWIJXM1OR+B6cPysOOKqUQevqrq1GUboaGprDw/ybAxA9AF76zFmVNPiz4v/EwdMlH5CD/cNFoAJ0OmtT4777m7ntQPHcutOlpKDnjTFAUBQ0foTCPPhH6BQsRbW5GzxXLwfG9WaKylNFfJSosy8DTLFl7L5rzEi5//nVyefgGoaaUVBit0gBsy5DOn6IoTL8pcUQoEYQBOXocExUAMKXa4XW04K4TbsWNhUak6lNRYCvAssplSfcRiYqMlEyY3XpVZFQDfGgLQk9TeK/bfnSpeh2pGiIEpTTkNzi+RfLQScnJRbdn/4OSaUQXJ+/j0/z+B2iaMwdNb76F3n+sEY38AMDaJYBIcAvyn38JNXffAwBoePvzuPMRUj8WTkrVdOFTRqH9BxCQae7CIRYhgx1GnxODJ58GrU6P4n594P7PZHxTMQghuU4pEgR00mCu09AYUdw+0bqAp84ZiPG9MjFjQB4u/3A9tlU6QWmVE0VK68b0YRRWeyLINmdjaPZQcV2KIQU5CYJYetoAMCSi8urmV8XllZ5KbK7fjGE5w+J3ioFBq8Hqe07GNxsr8dqyA6hy+NHI63yyBXJE68RKLBG+RsArCX+NXiVRaQkS48hEpcnHMtSIyhFCmAmjzhevLRBq1mmKRr8MKf8ZGz3JsShV4Ap7dL66o+Xjj+H77Tf41qyJex9jjFYjv6c0eCQKIwuQ54LrHnoYFjvZ9ve5B/DhPb/D1UiIVaAVosKyXLyT5uSLAI1BQU40134H3HUAGE8GsryRTlAaDrnDneg6uRnai96RDrBC2SX2iMBBZlU+XToCMJKZWHp3gC8tjc2PZyWYbVW0+FHW5MP0V1fBF4qC4zixsdg3G6ugL5IIFm00gqIoUHq9Qkti6N0brN8Px+efI7BjBxCJgAuHEa0lOXJtVhaKv52LnksWQ2O1QpOZCTqm1YQ2q3VRdyKwDIPPH7gLa775TFzWVFkBJkoGEL+HJyq2FNCycluT7a+X1MsjKu3pj3OsQoio+F1OnJBxAgpsRI/hCrmS7qPjy1xjPYJagy/EoEnDwWfWoP+5U5BqcIrr8tn4548tMwv64mLo8kkaT5768a8nXZwFETcXkn7jXU50whppAk6Z2ur5CESlp01KZeTxaQ3/+nUKogIAHiuZfFDBIIacdjrsRT1htJJ7NyjXzwSdOFSkmnW4aFQRUs063DGFEMBY4XHXnADG9SPPqEGZgxQDvEFjUJQGS8vJskA0gKUVSkuBKxZd0e7zK0w3ix2YSxq8YupHJCr2wvidfE1A1UbpM/qVPYec/HVTUz8qEmJvS7wwNNOUCVpWtjkiR2pWNS5/HCiZQrS3XTmTkmtTuEhE8RCPtrQotmWiLEIBZdVERhdpxptImCeAlg0yrh9/RH5Pu/g6HIhi62KS2/Z7yENswgW9cMk0NwZvnyOd+8icuN4yqUPHAw/Wg+p9qrhM03ssYM0C+AZ2lpww+syqRVovP5DZm/hLXPw12bhqfdJz7jTwaZ8mHXmo22PI3xmDSChZUN1ntGKiVt7sx1MLdyu6pm6pdGKxU7pOHmhx79ztuOKD9eBk90nqOecAIANI8M/4KgBNmp0QFD5lRFEU9F2VESYu3LG28kw0ipcvnon6UqWfDcexWPLeHOxY/qsioiI35NFodQl7C7UHAlHhOICJHL9eKoJmx+9WEhNfJF67tPDchbhv1H3QJoiotAWhyZ5FrwGy+wG3bASmPQuAwry0+EEyJYtE1oTqOzYgERVtlkQiau67H2yQRFtqrrwZ0AJaisXmHfH3nxwmvgdUgUb6regFh+vNm+E3Kydg3nRiZyB3UjYahVSK7PfmVwqEDxVCiW9sROXkwX64Q+S+TjOmwaKTokr51nyJNMhg5EWzwWgQXIIuTu5w+zrQA0CvHPL8rXEFcYD3RRFbBEQSuOr++R3QIH0nxb7tYH55AJyLpOmEqh81oqIiIYRmZABwUd+L8NjYx/D5DGWo9MS8E8W/003pipupKEUpBGM90g+K9fkUnhmsW/ljczcFwLEctAYN+p6YC3uOGSdM7IJJl/TB1H+ckDTtAwC0RWl9XjQgQzHoVPG6FyH1Y7LpwTgcyGjZhTPKrselt+cho4s1TqWvN2oBigLVTXK+pLT8g8gizfap0x4DLvwCuJyYhyFvMPm/+UDiH2pngicqtTR5uGZYlETk9im98dx5g/DpP8hn0mlosRwyET5bV4Ehjy0WX2+rdGKdVhocPByNrzZWYuW+RtSapRkQbSGiQzYQgPe3mLYDNA1Ngkad+iLl/WMaMjjpeSWCozZxgzQA2Ll8MX596zWwDBkkTSkpccaB3Yd0PIIDQCHwPp51Kmb+O4kViV4z4Jq4bbNMWbDpbVLqJ9bMsBX4+GtkFqIw9iLgxBuAB+qwPWMaACBMSQO+0BCSNgpEhTi1ctGoom+U64cfwAVJ6qGF1aIJJEKUvVlq7yHAn27EVVPuh2H2hbDyzz3aHcEFwwvw0mzpvguXH4TbRu5LoSGmN5UQatbtBuMlpmtGnqgxHI0Iyz+r3j2l3dekPciyGXDL5J6g9YQAsWGSRtrWtFmqlDHYQVEUVsxegSXnLYFFZ1H0FRJg5rUoQSaIlkBL3Pp9LckrL2ORatIhj4/a/HaAnFt2ioGI7QUBbVo3YKzUKBKMMrqt+eN1/PifOxGKMq3a5x/LUInKEYKQ9plePB3/Gv0vnNPrHORZ8xTbDMkeIv7tj/jxzMRnoKW1GJM3BlpaOSNlZESFcbQoQraMR8nYnQ1kQLdnm3DKlf1x8SOjodNrcMKELug1QjmjiQOjjMTo9Bqcc+dQjDmBsHuBBAU8hCiZU/RgyolQ1mDmkNpLigT1H08iEYX9pVyy/YILocnKhH32bOlNZEQFRWOAvjOAFL7CxJoDmDMAjgUa97R+7ocbPFEpYwiZyItR5ht1GsweUYhsm/TwWnTrBHz2j9G4aFQhXpo9GOv+dQom9UnuhbM5S7peWlYamDfbu4l/07ydffDPPxHYqOw5RBmNoDTxA5u+h1QNYb/wAtEFtL0IyO6pWf96DKffeg+6Dhoat53OYIROb0BBP2Up6PjZvdFrRDZOvzFBaXkroGkKWj15TB3PRMVoITPjoFeZWuiZ1hPLZy9Hhq8LxpfOQiZyYNQaYdVYoeWNw/5yREUOnVFcFqJlTfoKiwGQNCMARGtrsX/8BOwZMBCh3ZJ1uzYrS4yo/Li7GQ2cHQBwQv085AxTRokqi7Phy8hB5oSxMPvrQHEsQv4oHjq1L84dRlJeXCSCUG09vFbindJ7FHkOBXmRZ9Obb2Hf6NFoeP4F6M58DlqaRNPcET6CEQ0ALcq2GoeKO6b0xsjehIxFXERHUuYqEytlBJ1ghilDTMVnp8RHVMy8SZ4r5EpYHFHra7tjsxzds/hWBLxHTKHWCeycC7D8s/mmdcCIeP2jHN3C+1DlCIipHy2sKG1suyHjsQKVqBwhCERFsMxOBC2txUuTXkLXlK64esDVGJs/Fr/O+hWvTX4tblt5RCXa4lCo9Zv+8zqa3pb0HM56kiYSnC070r47ylvhC+DCYWQW2GB4435QLAOW4bDqy33ie1jsBgS3kzJZQ88eiv42ky7ugxn/HIjJl0lW4Nq0NPRauRJ5jz0qvYncaCovZuZPUUAmr+xvLsERBU9U9gaJaDVWmZ8IvXJsGNczE0+fOwjnDitATooRH101CpedmFjs22S2i39nBiVy8FH/6diU3RsvDrsA+1xRcADqfG6ENTSMg6XBn0tSrm4/91zpuNde2+EW7gJRye/TH8WDh6Hv2IlIyYwnXIKjaO8Tx2H6zXfiqpdJHyuDSYup/xiA4kEdj6z8HSp/jHwVVNAbP3BlGDNw/vZ7MKB+IkaXkEooE6TUbEeIio83YjTrYyY20ShSytbBGvWAlXVR1uaR+5AykcHVvfBnMM3xaRU2HBYjKiGNTmF2mN7bh7Te0qC3nu6LPjk20CYzNGwUJobcO64G6d6M1NbCa8wBR+tgtGjFiEqY95XxrlgBMAxaPvkE6H4ScnqT/ke1Nlnvof1L4s6zOdCMy3++HB//+XHcuvagwkOiSOf1mwINpUWEjWCPg0yIEqVL5JMSAakG8l3vd5A0qZbWKqqFhA7abWFj3UZsqNuALnblhGj80nOB73hrgdQiQGsgWrliafLBapXmfzowcAUiYurngbllmPziSlQ52m9vcTShEpUjhHo/UWLHimJjMaXrFPx0zk+isDbLnJWwrE0RUWluBheO8TV5+WVEqkm43sk/IOxJnCuTgeM4sE7lbCnqcAIAaI6FMUTCmjtX8eWLOhq2DCMCpYSUmUadpNiXoil0G5wFa5oxZnnMbZg7iAhqZ75BfoSxSOMHeefB+HWdhUgAqCPdkXcFSUQo1uugI0gkwkuG7lkWePVmPDj2OiwpGomDAQ41aVas75GPTd1yoe9S0OYxdLm56Pr55+jy2qvQdenS4fMN8vebsuw4/l62pJIBjKIo9J9wMtLz2z63tvC3ICp8FVQioiInjVlOcm+bODJgsxQT1zm5Nfj5yhhLDLnZ+ssCGDb8iMsrP4eOJc+KL/LPR4Ql2wkRFcEzKRas1ytGVEIavRhREUBrJS1GGZ2Pa8Z3A20ixzSFyeDoapJSteGKSrhtxQCI/4sg6A9TRnBy98ZoFKH9+5HXi0xualLGAhl8dV/M798T9mDS15OwpWELXtio9JyKxe7m3XENX5dXLocj5IBJa8LDp01GIS94LnMR8pKIqKRb9Hh85gmKFG/vdHJ+6+uIji7dmI4PT/sQN/Jd1dsTUfGEPbjql6tw9S9XIztF+f3rgrLznnC79Pfgi8Q/aZOyUrCAaoTTHxajQ94Aea5uKI9PTR2LUInKEUIFX8+eb2lfb5W2oIyotCQ0aqp77HG0zFuAqt3kZkzL7SBR8ftF7QvF9+RhHC2icNcYaFJsn24PIrL+V7AhFpSGhWHirA69nwiKAk79NzD0ksTr7bzewnEEiArHAcufBt6bAvibwZgysZPrBpNOEyem7QjkIrw+OTZ8f+NYvH/FCPxrRl/sSZPU/PNuHofnZg1StK5vjFAo403UHBYTdAUFSLuYPKT03aQUUSzMw4YiZWrrVRrJEBAreiRxtSDEVLxHO2zxOwqh6uV4Jioma/KIihwGju9tEyXXOawJIMK0X/icLKIiiKA1YGFmybMiTOvhjxBiQ/GkItoQ338MAMAwYPhJS1ijQ9dipbHaekqKkl44oSemD8wDxZMfU4g8JwQ7BACI1tfBlUruVUJUyG+JA41oTDQgUlWNrgNIZHX/lq1ghlxOVsjKcAHg233fKl4zbOL7pdRZitk/zcbMH2diTc0ahHlNh9AA9vze58OoNcbpApP1xrlsTDGuGS/97gbnkEmm4DCeYcwARVHIt5Jnf3siKutrpWIBvVF+z8SIc3vItDpW2e/RqDzXFMoPtnINvHwvMS5KiPCc5SUIR499kbpKVI4A/BE/9jvJg0LubHgoUERUWlrABuNt2r0rV2LbC1/A3RSEOUXf4bC7oLyndDro+YZhjIwUdStfqNg+27sUvldJrtScx4HK7qRO2HY+orJvEbD6RWDpY3G9gA4b9v4MrHwGqCdmalVD74AfRmTa9B1On8hhk/Ua+fbGsRhalIZT+uXglH45eH74xai0ZuHlobPRxW7CiOJ0bP/3VDx4OnkA7l67GG6zRHRCWTnIvuceZN15BwrffOMvn1NrCHjIvaCMqMQTFWtaZxCVv4FGJUFEZd0P32D9j3MV29EMIRicg0QYnKYGVHqV/b5aQ7KIiiFGFA8AYVonNvETdE/y9gw9ly5Bz5UrxNdCSojRG9C3Vy/FsbbJmo9aUm2KY5p40eemRQexbRn5LJ6qJjRmEY1TYd90aLS02HzR8o8bkX3XnTCfSIoLWK8HhQMGw2ixIuj1YOVa/nrIiMrC0oV4fevrinNqiplICdjauBUA0ZBcv/h6fLablNsLUe8+6SS1LC9uAFoXoAYj0r05OKeHQlOYbiIR2CwzSZU2BROfl4DmQLPoTgwAtKwS6V+TldFQL5uFBXO2oeaAE7DIUrGGFGD87YptB68lz2YKAFhCIg80ePHtZqVx37EIlah0MkqcJZhfMh8sxyLbnN1m6qe9YGXle4zTCdaf2KJdeBj0G5dHKm06AIbXp2jsdmh4V8poU5NIkuzuUpzev5w0ECyoxSjbl/A3kgespVcW4ko/DheyeI2Kt56QlNUvAo4EPW7cNcDGDw+tOqhyneLlD+FRAABzgl4kHYE87yyPltQs/xFDfJtw78Rr8WvXUWK3V5qmkJtqhIEJomtIGUl6ch8D2mhE5rXXQl9cfEjnlQwB/js3WqWIii09nvha7B0z3WoP/h6pH3LdAl4POI6D3+XEb198jNWff4SgT9J3cCzgaQnCUUfStS2mOjEa2x54RTGt8v70u1xx24ZpPQL8ACukfsB74tCXXAFdly7Q5eSIHc6FyUC3IiA9R9JYOTkLqjXSvZCSSkiZkPoxOqTz/+1rMmGrqAJYWoc0YwB5vKeT0Ppi0Z5irPGPQMRGBl7G44FGq8WIs4jOqryET514SfSnJdiCe1ffixCjnKwlS7EI3YMFvLntTQBSN/scvmT63F7nomsK+ZxXnnAlimzJLfiFhoQAYNTpxWMAJKIi/3+/Yz/qffV4ceOLuGnpTYiyyoKFLQ1bFK+7ZkdFMf51I2SREls+Vn51AOU7mvH9C5uVERW9GTjl38Cd+7DfRp5ZDbzI3hqlIB/6jwediupMe5jxyJpH0OBvwOunvI6mQBPO/vFscV3vtMMXYYg2yfKUHIdofeI25K4UEqItHthxEaNEVFKh451MI/X1YL0SKTJHnDjtHwOA+e8i8EsA3mrycDEVdmIL8S7Dgd7TgX2yPhZNB4igTI4PppE8tvMgcOojHXuPkBdY+SywWSnKe/k38jAzJumL1F4MLEjFo2edgEJZu3m/y4n1336BHgB8GgtWZk4ALct9Z1gM0HHxaYBF4cMbxYiEQ5j34lNIzc7FwMlT8cOzj8LrIOlDs6xzckpWNnqPmYB9f0gl0pZOiaj8DVI/fMqMiUQQDYfgrJciF94WpVZi65IKuJtI1NJpqsdBd+IUpz/iR0uwBV/s+QKX9rsUedY8+GPLk4VtY8qiWYoGS2nEiIqQ+hHwztYm9Ftdin9M6A7aYlH4NpVb3gds/xFfL2RGwydruJeaRj6rkPqx+uJL22s9JMJTlMdgT8seMByDtC5msYdYxa4WaI0noBjzwXoIkcvjm/K5m51ALsSIipyQmLVm5FvzccB5ALW+WgzBkLj3FnQaAgLRAMpd5SJRyTaTZ51FZ8GPM38ETdFtRk89Md29cy25qPaSzy0QlHSjROLP+uEs0YV8fd16jM0fC4DoAnc07VAcqznYiKfPPZ28qJJV+V27DM4XpXsjasiSBvSaLWSiaMuBy9oD8KxHOW8amR2hIU8+6TUafL6uAtMH5CItxnLhWIEaUTmMYFgG3+7/FqurV2N3y258vlvpk5JjPjzRFIBENuSI1MTPHlhKg7CePDRSMlsXfgZ2/on6558HIyMhQupHk2oXLdejDY1gZeFrVpgNOg6icpX0QzRMOq8Dn6aDoCjiDSFH8/747QSx3b5fkh+LiQCVG8QmgCJ+fQBY8xoQTOwcamql70h7ccXYYkzuK90TPqf0ADUx8bOcYV3tGJEXrzPScRE0NTZh4X9eQNWunYd8XpU7t6N86yZs+3UBPr3vVpGkAEBqjlS1RlEUzrztXpx9z0PiskRRlkOF0DU4HGNaeDxBZzSJjQkDHg+c9dLv1dWo7GlVX+YWdWU1KQcSRgYa/A046auTMP276fhk1ye4YwVxc27hB/NUk1I/FUdUNHyHXz6iIjd3AwCPzownFuyGNxSN81Jya9yATdLafcacgqBGGuAEoiK0fjAGlYJNlmHhYO0AAHtXCrN/mo3Lfr4MJYN/R1nadukcOLK/8LyJLCINWxmaQpjRkJYWYT+aNr4n7vP9zO/RPZVMWFqCiYWiwvIhWUPEZbcuv1XUb8if0xpa064Ur1DFJzQiVURUTISoyDsWy1ulOGUuuw/89gA+2PkBAEK6AIiEB75mYOkj5O+8IUBKHlhZo8bGSh+Qz9vzyyqAPHwX+4M8UekdCUADifS/vGQf/vX9Dtz+9dY2P+fRgkpUDiPknZFLnaX4au9XivWHK+0DJCAqtfECrZDBDlA0aBqiWC0Zys87Dy3vf4Cm16U8rxBRoe2p0GaTc482NICVeUEwwt8tpWBknWE1J7bfKvovoWgM0E3WfK+pFROlZM3AmAiJurx/KvElkKMkvgfLF9GTxb+NukOLqCSCPDxvYoP4h0ygB5D+H0+dGR+VM7AhLP3wHez+bQW+evS+Qz4PeaPBWNhz8+KWdR82CtNuvB0nzroQRQM7ZiTXHuh57ULIf/wSFYqixPRP0OuBs04iH866eKISjbCgU6NoslQlbL0xr2QegowkoN/ZTAhqvZssy40xIosjKlpCLISIirGfUjvn1ZNBckeVC7Ssb1NYC/iNAFLygJPuAyY/hH7DJiAsc55NEyIqNI0ur70KCkBWREr/rP+pDGGaP76eeC5F2Sg+LH8Hv/R9H98OfBEA4GF4AT8fUWErKqDlB2avjk9zrHoOjTvJc3ZiwUTkW/NF0WtsewKOIw1BBaIyvst4cV2pi9zzNp0NZl3Hig4AYGLvLCy/axLev2IkAKUNhRBJiW2LIuDHkh9x54o74Qg6ML90vrj8vN5ksje/dD4ZW366lfQ5AwBzBtzNAbibZbYUVV5ijDn5IWDG8+LyrJHno5LNQjmfru4X9eECk9J/CQBW7G2MW3asQE39HEbIrZH/vebfiMQ0jDpcEZVIXR0Cm5Q3WrQuPvUT4svpLOZ47xSOZVF1403QZKQj/8knxeVBmcmTGFGxyyIq9fUSOQFIWLZ6E+A8CFqbBzZKofCdtxX+KYcCv8sJv8uJzKJi5QqtAbhiPrDtK+D760jqh2Wk95WLa3VJoklfXw5U830x9i4kFv3iB5OlGXqdhpYuJ+OJRdKs09QZRMXtFP8+IV2Dy6f1jdsmHIzX2xjYMJrKDsQt/6tobIWoWBNoUCiKwgknHV6nUDkMfHVVbBuI4w1Gqw1+lxPuxga4ZBEVd2MjgPgy7rT+5PFc74v/bf8/e9cdHkd1fc/MbO/q1bIk9947BgM2tjG99x46BAghQAJJ+CVAQiCQEEggEDqmJvRqwOAO7r2r97a9Tfn98abuzqpZtiRb5/v8eXd2dnZ2NfPeeefee67NoD+Z1klExa0t64+GtQqdYNQqKpaR2q7DdTbyd/7+wF6cCD+kzKSadECQxpIT7wMAPCYIqM/wolVsMWa0K+dmSCfHmVD9Hr4uJsmd6z9TwhUHrC1AQiFUm4V83whrAMtYEK+rRdUdd4Ktr4fZMwgsY4LfORLp3lpg3b/RaCP3YpaZfJZURiy5sAJE7b7is8vB8iziArmO8h35uGjERVi6e6m835jM5K7NnUVJpqI8FTiUpFcp9JMKq2rIDyflw0i4ZeIt+OzgZ2gMN+Kg9yDG7/xYedGVh91r6jRFQI2VfmBeIXC80k2ZF3iMHpSJC21/RJnhGQAtKI6zOGlkEJSpCK+v7Xz+U29iQFHpQagVFYmkMCpzJSn2eaho+te/5MfGQjLAcQnGbJaxY2WXR5s5ObYfO3AAge++g/e99zUeLOHNm+Wmhr4viNTKuN0w5pOVdKyyUo4ZA8RfAfuWgecAniUDmHXixEP8hgrefOCXePmXt6K5KsUNlSl6KpSvAB4pBOrJCg1RlTuvnqJSsZaQEwlxVXl3LAj4RLmVYoAlj6NyyMUIQiE8h4WoqBQVb00lIm3J1QHxsA5R4aKIx5KrvroLb6N+iWpO6dBkz5sjALPYsiEW6lp/or4GKU/lg7/8AdV7lAXBxs+/hiDwcKSZNXb5RWPIxFsXSlZUzEyyv5AgCGgQO+yqrd05ltU0MQUASERFVFSqI0BYFb4pcxFF4I3K+7AByr1XnZEcBqEoCk5VqIkyK+cm9ZtCayMcadpzNsQDaLUkj01xQxRml9iV3ZaD4PLv4f/8cwCAVSynro6IFTRsUE4SzaTJ8T2MAxQv4M1db6Ip3IQ4F8eZ7y3Glqat2NGyUzZiy7Xn4tczf41sqzIuT8sligjPcfj82Sex+SttZWNnsbhkMc4cciZm5s3UOI6PSh+V8j3SeUmwGW3ynNESadEaYaYPQWMFmW/yh3kAAM3V2oKKOBfHuR+ei1u+uQWW7GKETWTcLo7H4eD8yE8wkqMoALWbga8eBFRmk30BA0SlB+GNJeczSBc+0HMeKuGNm+THUrM5qcOpBNuM6cAoEq+0GpNXouqBi/MpF6UQiaDimmvh//Zb2ULbkJUF89ChAE2Da25G9IDiCBuvrwd81eCi4qVkNGoaGR4KBEGQY/k7fvhWf6cMVZlkPETUHQDwq1ah+5cB2/+rfV/5CvK/6CIpuc4CUBxvrenAA02AZxBaQ1pDvUNNplUjFg7h06cfx5avP9Ns//jJPyXvq6OoWPkIuB4kKnGdz0jPL8Sim+/U2fvww3wUhH4AwGxXQiheVTKtwLdA4JpRPC4TNpdCFgryiALbHG6WvVSkCpEwm/w3ag5GERNDI2rHVDbBDBIAaJPY4VdUVD7ZWouPS0lCZ701DTzNAODBM02oSVfIiURUEtVidY6LmswyYnI17/PBZNBaCIzb9jxCnPI91A3/rBnkGL6ESpuCFjI5b9zVhE9DeViYV4R3XWS8yeIFxOvrMeXKp3DLx+R3uPGLa7G6ZhXKQ9o8n4lZEzE5m4yP90y/B26zG8PThuP00tMBAGWbN2D7d1/j638/061FgNPkxB+O+wOeP+V5TSjpuQXP6fZ3AoCVNSvlxy8vIkn8UtioNdKaQFRK4RV9aQaPI4qN2qcGALY3b8e+tn1YUb0C6a4AKDoGSqBQGGdh5bxJbRbsJgPwr+OBlU+RQoI+hAGi0oNI7IrpMXs03VFL3KnNuLoCg1gqnHbppWAyyIUcK9dWBqRdcAFi4g1ippJXomqDOLYxOTbZ9M9/yo89Z50F2mqVS1/9n30uvxavqABXXykTFYPHc0j+ImqoJ8yUTfEsCQ34wiJh8yckIL5zlfZ5zSby/1jRWr5xp9I7pFkMo2QQcgYgmagYuk9UDm5ajxVLXwEvhpd2r1mBnT98i5YarZ9B7d7kjtsxUcK3uT0onkhsuW1cCEJcOT+9iakriEWTzQPHz1+MzEH6tv+HG1ITzEg/Jyo8m3z+Riu5fgUhgjnnD5VLdAEgLysTRtoIAQIaw414c9ebmPnGTKytXavbdfnjbSRPK9dlkTsUAwCrM9HSJq2iUtkSwsujFmPNKZfigdnXAQAoAxnPalXRvu2Dyb2dmP9hHjoUub/7HQqf0fr4SAm1EATwBxQVaej+95Hm3ScnlT583MP48rwv5cpIJo0QjT3DL0LISkgQZTQiS3SqjkTi2Fk+FCduUAhSZtiP4MpVoCMxHL9dQFabgN3eA3js+/uSvv+loy8FI4aJFxYvxIqLVuC9M96T+6+pe1u9ft+dmu70qVC7bzd+/Oh9+b7Wg8fiwcUjL9Z9TSJ/Qz1DMTlnMsCxSIuRe7G5ebdmrBOcefCKPdyKRhOiEgnG5fBo5c4WHPgiAEog18EuliQcW+I2GAGYY17YEyrD1N47BzYt7/D7HkkMEJUexLt7tAmZQzxDcN04ctNfO/baHpvAJQXEPme23PVUQsZ112L4j+tgGjwYcYYQFROSByo+qAx0iSQHAKI7yKBiGTNGlm9tU8gKJF6jTdwN76sCGyEXOdOD5anqUIhPh0zJuFiJMctEJZAc10e4jfwvCIryMvpMQEpy+9skoHKdoqhIVt0AWoNastdOw+kO8f4jv8Xa/76NvWtJiK25qvOGXjEx9FMyaSrcouFaUbgSlMob4ucvfY9GfwTlWzbJxKYjlG3ZiNfuuwP1B/eD1XE5Nlm73y7gUCEpKg1lPhzYRK6Dxgo/PvnHZngb+74HhAS1XwpAyKZRzKcYMd0DQ0I40WQyynltdcE6PLz2YUS5KH676re6ROUfP5Br+qo5xZrtesSVMWsVlXpfBBzNwHTp5ah0ks+cWCqGhVThnj1i6kVjKPl+TLvoQjhPOlGzjTIYQIv9n4wRJTRuibTAMf9khOJiew+zBy6TS84vEVzKmFWfTQh5HByEhMk1r0VRjrJ++g+Eg6vk55P2E3JRxmqTYK7In4f5RfOTzl8NX5MS/myuqsD+9etQtWMb/C2pzdre+PUv8P1rL2Ld/95NuQ9AiirunX4vfjHlF7qvl/vKyRi08q/I2LsMAPDU7tdRKVUKOfPgt44Dx/KgDRTS8+1yscSBjQ2IRVh8+NQm1K6MoaSF9AGriZJk64xmUgFER9s0/k0AYFApYfUBDg3+5HGgtzBAVHoILZEWrK3VmoNNzJqIEwediC/P/RK3T769Rz4nuG4dYgfIyp9xOkEnTCDpV18NRgy9xClyExuF5AtO7YsQK0smKpJ1vjrjP+vOOwGdzryxuhawEVFRyWw/cUzCxi8+xj9vvAK7V69IuY86uTTY1k5PihGLgXn3k8epFBVA6bbcvJ/koDAmYNBM0pFZwhsXAGWiL4iqk3FNm1ZW5RJC/t1BUCz7bU1QUobNIBJ8RmGywZQU+jFZrbC5PQCA0lCZZp/SZU/ilevOw7t//A1WvfN6x+fR1or3/vgA6g/sw2v3/jxpQgUAo0Unz+cIwaxqVfDDW0Q1ePdPP6FsazNee2ANIsH+kbvCJ/TRmXr6OQCIQsAYpO+gXcxIlYKSayoARNiILlFpjTYiz23BVbOLNdv1iYrYhDBMPrdeym1xWvDOjbNw9qQCnD2N/M0rsyn87XQav72UAceQ80v0+mgPkhJrU+XaOBw08h/9k6yoSGEfqWKHH67c761pYqIvx6MWLaAS1A1a/FmzWA7cbiV8MqgpWQV5tq4Bv8ycmdSNXo2yzRuw6m3tffPBY/+Ht35/L5Y+eE+H5H/78uRmiYm4dNSluGrsVfLzOQVz5FDU2YMXAX+fDHzzB5hV3/UVWvybX/wmvI1kTHdnWkHTlNxw9ptXduHz5xSLAndEsQuIeyeC9k4EAFChliSvHUqlkrGg8VNZq9hC5GFga/vk63BjgKj0ENS18BKOKzgOFEUhz5EHmjr0nzqwYiUqrrhSLg+mXS6NUROTkQFDhkIUYuIgaOKS49lqRSW8cWPS6xLURMWQng7rBKX81FhAZFLWG0E8YBC3ddyELh6J4JsX/4lgawu+fuEZrHrnjaRBHABCqtyZYFtrckKgGlL8dv1LwNJLgRV/Td7nxYXA3q+AMrHEb9AM4uCoKuVDuBU4KMqeOePkzQebtBMD303Lfo5VJlWDmHTYXK1VVMbPXwxAPx9FUlRMFhts7o7Vq/WffNDhPm/85m7d7RZVToXJ0vuKCkC6cwMAzym//7t/+kn2k2itC+Lfv/geG744gg0rO4kTr7pe83ziwiXgOPJ9KFoiE9rrSipzrfQr1whDMwiy5Hq8e+rdsjpAGb2YWuTGZ3/9I/77p9/L4Qq90E+GmxCDz7fXoTkQVcqa3RZMK07HXy+ciBiU+2/FWBo7ixQStb4+ubw1FcxDiL2+068k5eacOg+Mwy4rKlIeh5ST0YwGXHA/ye8L2shvQPNAi5mFMaE3jSdA8noyOQ5cUCFlgxq1v+XVbT4cF44AgeTkZDW+ePZJ+XHxhMma13yNDdjxw3ftvl9det5ZnF56Ol5c+CKePPFJ3JYzR95uUymle6QQvtklN5p1i41mp5+mpBVU7lD5HoWV0BgXKkWrIN7T4RY4E9osuGKKiuSgItha7SXO3Mv/BLx3LRBtv0/V4cQAUekhqFc4Dx/3MB474TFMzZ3ao5/R+Pe/aZ4zLpfcTwNQGgdKiApkJWpkk1dfge++Ux4vTx2PZBxasycp/AMAFjtRL9gwg7iJDEbGQYPQESIhZcUe8fuw+t03sP37ZajYtgV71iorIrX3g8DzCPn0zdcAaBPNdn2sKCtjzgFyxiqvvXMVUCeuOPJE0jXyVOCBZhIGUiM3NVFh2yNN7SCsIl+MwYh4LApvgzZM5Ugjg3U8mjzBRMVWCWabTe4fI8F92nVJ+0uqS3vwNeq7GnvylOTv3lRUHGlmmO2ErJisBgS92t/F2xDGxq/IJLjuo4OIBlms/u/+pOP0NgpHjsHNL7yJweMnYcH1t0HgGLAx8r1omnynOeeR5PCJC4iaJoV+pE68AEmklcYbu9EuV4Y4Mj/C4I8ewoH163Bgw48ItBLHW0lRUZv1ZZs4DM6wIRLnsbW6FX7Ps7AWvowsp5LM61NXzomQSmjX16/vVN4GAJiHEAM2j5fkfhljfuRedSEAxfhMKrfOs5PFT12wDs4Mcs3FTS5wtBE0gPo0wJiwqMnwmeA0kNwLzqtMpkVN0NgU5Ek5Qn796x0A4tGIbHBIUTSmn5lsXFm1Q1GT4k1hcMG4ZgHSlcq4pUuW4lfTfoXFJYvB0AxOLjoZnrAyzl3oC2CSGIrdbjIizJvhD1vx/VKiLEpKSuHIdMw4szTp+CMbZyIjSOJ184ono0UqNOdiGJtB4YwJ+bhiaC5yWAq5gkJUsqg21PsiYMt2Yv+nWahakQZhZ/cqoHoCA0SlhyDdcEM9Q3H6kNOxqHhRjx4/sHw5Ipu3aLbRTpfcT6M5bRS+KbkD+9YrF1tMbHBmjGmZcHjbdvg+1VaYpAJt106GnnOVjshWG7nh4yEGMY4w948agLd/rEQoljrxMaZTYttaW4N3/u9+fPTEI/LEHU4gJmrn1iRYU6gLpScAk69QfXgA+OkF8jitWNnOGDRum8gYCoixepbjUdGilXu7G/pRJ+mxsShaa6oBQYDF7sDxl12Dc3/9fzCK+QN6uSLSb2D3pCEtT/FqqLAUYj2rlFnyYvlpyOfVDKKdBc0Y4MpSQmK9qahQFIWTryBlndFgHG31ydL7uo8Oork6gPqDyu/rb+k7MXYJVocT5/36/zD+5IWoPeAFKPJ34lhyroNGpeOavxyH2ecQ4i+REHVY2R/zyyZwdqMdefY8GOMURpU7NblKIdGyYOMXxH/DaFLKg4NtrRiUZgPA4dql78Lg2AODcydsZuX9icUBAHDZqMtgoAyoD9WjJqjfBTjOx/HspmfxY92PAADPRWJn73gQs1f/GvN/UQKD00l6HiUoKpKC9NGBj9AqNMFgIVNURFRa6tIoGBNuvgyvCXaTAzE/A+8+ZUpzhAG3dKkIAF+Rg9WNRUA4dRhZqsYy2+24880PUDhKWeScfM1NAIDq3TsAAJwvivq//IS6v/yIiMpbqiu5iGMyx+Cy0ZcRxZ2Lk07t/7tJft02YgleQh5yglmYUHkG/tPwCl75wy759bRcZXGaXaRfbXn+lnvgDmfj8bMW4qM7F8ihbpP3IP58+lhkr6vC5T4OpVCUphy0otXnR+PrHyLmM8JfZUXjC0t1j38kMEBUegjSCqc7roadgU9VaSOBtttAiTkqmyfcCpa24KsXiY9IxY5mRFki7ZkSVkahtdpcGgCgTCZkXH89su74ecJnaBUVU3ExCp58Ej+efxMiYp8alnUgXksI0huVHO55bwuue/mnlN8lrjMBc6o4utT7JNFNU1oh6iIVURl9FjDlKtKgK6H1OdISqrBcKtfVE34lP2wLx8Hy2tUjz3cv9KNWheLRqBz2SS8swrTTz0Hx+EmyesHGY0kVBFJei82ThpySITjjrvthufBefJB3Oj7brRC5VtgQpwyAIKC6ogaCIGBHjQ8vrDiIi59bA6+Ym5AqnGa0mGVlhzzvPUUFUPJUGsr9Gmm7eHwmikang+cELP2/dRpysv6zsiN9mp2GIAhY/2kZKDGPbPOXn2DF0lcBAFaH0plbytlIxO4WUhFmN9qxqGQRFq/JxZTd2nsg0NoCf0sTdq8ioU7aYEDpFNKgbsKCU+Fy+OEY9kfYihVfpiivLCKkyp6LRlwEhmKQZc3CWUPPwuhM4mKbKvyzqnoVntn8DK754hrsbd0LxmFH+tVXAwAs0TY8VEGcZyv8FRDEUFeiogIAj/30GAwucn2GLSTXok7nNi+uM2BMnRlNe5J9qq7/jEeaX4A7aEBdXT5WNQ1G3J+aqLTWEfLlyckDRVGgaBqXPfIkzvv1H+TcsUBrC3ieQ6yakBMhzGHp3SqTNY7r1uIAPzxBOrVLGHkacNHroG2ZOK5yASbXLIAAbS+eoVOU79xem5SJNSfCaTLDWB/F0pqHUB8fCjTtRWNlM6Le5xH1/gf5UeVaM1Ic7K17ENmvVFvaLtQPER8JDBCVHkKihHmo4Hw+1PzqXtl8LahHLigqqerHYGIQCcbx0d82AwDswRoYE/rVqEtZJZiGDEH2XXci4zpt+IBOCC80+CJ4yViKB+NDYLSQ48SDFNgWcvM3WcnFvmp/s6b1uRp6Ph1NKkM36SZPDPU0V7bjopg5LHnbLT8CVg9xsZ17F3D5/7SvqxUVADCpvmvJCfLDVlX/lKtmF8NqZHDziUPQHahVouWvvoCNn34IAMguVmRbNSlgE8I/QZG8OTxkxB42YzYyByUn3XIUg5BY9fXo/37Cm+sqcerffsD/fbwDqw8049OtJI7+8VN/1j9RARgxay7saenIKirWqCu9AXWeyvrPSf7JmOMLsOTm8ZiyWL9sunxbO8S2lxEJxlG73ysTFQBY+1+l5QbL8WjwR+A26RMVaYJ3m93IsWYj3Z/cTO5/f35IUy0Xj0Zx+p334aonnsWQKdMhWA6CMmjVKbU/i+QLNTlnMt5Y8gZePfVVWAwWTMkhVThqorK9aTtu++Y2/OK7X2i6/57z4TmYu3QudoWV7ubrGzbgnu/vkfsTAYBFNGVUW89/Vf4VKkHet2X8zWhOH42adApBs9aKPruNxg3/OIhQizIWmj1kDJm2V8D5K3j8ab/yPfVCyIIg4JuX/oUPH38YAOBOVxhRTulQDB4/UQm1CgKioRCEuELy3YK2x5Weatwh1vxD+9zqIf9b3EiLupJ2nzB/EEwW5b6QQmV6GBuYhdX/249PntmC5lA2Pmn9NdC0B1WyE3kM/pYsHNg+BMF6ci0t8L0r+3MNuu8yOI6bk+Lohx8DRKWHIEmYatOiQ0HDXx6H94MPUHHNteCjUbC1ZGJxnEysyrPvJSt+2mZFzKhMsGm5NgTblMktv2Yl+EhYs3KOVyd7kliGk4meMhg05IROyFG58+1NeOKrPQAEeKziiiIaAzgOPCh4Tcr+UkVBIqQkUWemkuilbqb35b/+Bp7n5AElvYDkvdQfbCfvwOICrlum3ZZIXgomA+e/TJxq8yYkExVVObIU9gGAVtERNc1mxO/OGINNv12AwRnd+zurQz8A8V4AgClLzpK3GYwm0SYSiKnUJ46NIyK+3+ZRBtI0W/IkxVEMYjTZvq2sAX/9WtsLyWygIQgC9qzRr7qKhoLIHz4SNzz7Mq547GkYjO33ijrcUFf+SHBlkoE5a3DyIA4AIW8MQjeVr8ONSIBcUxbXEE3/JKni6pHPdmH6H5fhyn/v0LxvqGeo5nm6JR3NKZyEAeDAemWBEwuHYDAakSHeTwYjuQ/5uPL7SUQlzsXl0I3b5MbojNGyLfzUHJJ7903FN2gONyMUD+GiTy7Cd5Xf4cvyL/HCthc059AWbcOf7aSSrlH8qM8OfoY9rco1KRUb5NnzNF2GKw1Ka4gdo65EINOG0oYWQBBQ0tBGzlX0CoiLfW+GLKlHxgQlUfTU+gj2Nym/ccifnBTaXFWBjZ8pfXbGBT/RulWD5JRJYdloIAA+oIxv6aZczb6xcAhrPzyAtx/+EWF/J3yNtr2X3ABVqkyyemCPO5Le4kzTEhPGkHo650IUNn6pLPTCvAd7d3FoLCuTt7GhZdjdNAwV3xLSdSazSvbHMo6d2fF3OIwYICo9BDnWqqOoCIKA8JYtmh45HSG8RclH4ZrJypAyGpH/p0dR/M7byLjqKrLNYoHPVSzvS9OU7OBJUUBh9XJwjU3YP38BDl5wIdiWFsSqtOWwAGAervT6UCfEMgmKysp95FzsiMBk5EGbFALkNdtFR0uCtpREhQwAabl5OP8BsoLhOSWnxdtQj10rv0dYVA9KRGOz2r272k/gK5wKnPM8eTz1Wnmy12DMWcD9NcD1y0leiholxwNnPA3c8L1ms9SRVmqBbj4Eszd1JZMEq9MFT0JXYmlAjKvM14JSk0jGAKtDiUenq1qzb3OSXI61adMRo8jkbqXiGJat/TtGWb79UJrqXPoC1IoKANAGSja6MpoYjT37efdOBUWR8FyoM5NEF9DZBNKOEBYnOZsrDdc+9TwsTjKDS/lZL6wgSoLAaceTCVnapo8ZlgxUlyffzxJq9ylkIHGV77CS34YLjEKe6JodZsPY3bIbk19TkuYTw08z8magwFGAtmgbPi/7HBsaNnTwbYGKbAp3XcfgnmuS7527pyohBYqi8Oz8Z+XnLTZVBY3NgdL0oRAMPizcehCDWsi9FDcw8JuNEADYJ4+B6bS74b7/PygQiw+qGDcao8r1Hwomqx3q+6zU0Yxi7CZ28gkwi+NhJOAHF1CureHuqSh1jJefR0Mh/PRpGRor/Hjxlys0JEEXn+h4qkhEyeIGxZH7/f2xT8gvMypzwBgXw9WfX93+ZyTgy63Ho/6gtq/XjuwgOPGeFziAZ2kIAAwlk7p07J7GAFHpIUjlgno5KoFvvkHZBRei4hp962Q9cCp5UuqUzGRmgnE4YB2nVKPQVhu8LiVsEIuwsjthRgYNCgJi5eWI19QgsmULWt98E5x4PMl+nzxWwge5DzxAHCVpGpaxY1HdFsZJj3+HV9coJZ8uEGLGqJLv/EYb5gzNwOAM8ht4UxAVKfRjtFiRP2IUrK5kebulugq+ZiJbD506E0azBb7GBjmRLSXGnQ/c8AOwOEVIAyCNC/UmYIoCJl+uVAOJaBNdafWUi64iUVEByKCWCKNYuqzO52mqLAMAuLKyNJUFaSqi8m3GCXhx0BWotBaCEzvkMmwMLKedYINRFi3VyROcFIfvazCYlO97wf3TcOPf5iGzUJl8HKrVZVquDVbRir6pMtBjSbUN5T689sBqfP2fHYes1MiKioOQyTRRVfE21IFVJYsmEpVsk6ISWhgLrAYranUWHhKqdipKpTrkKggCmlii5l01czTs4rgVZsN4etPTmmO4TFrFysyYMW/QPADE+E2vu7PuuWRRCFq1992svFm4coy207q6J1qbVanQsXqsKHQU4kAuBUYQ5E7KLEPjh5FFqE5zIP2WO4ET7wcGz4YhPR37sz34KaNAc/xQKKZtOgptiHVBrthz58VTgLX/0uxnFYsL/K3NCNZqif60rMWwMERpbatr07y26v12moYKAhDXCRWJCdaC2YMoT4jKuRYBm/O+BesMYehk5XdaXrUchf9dhzHbiZq1ovhd7MvomEAGE3rEAUB1ZiEEAWBj5J4rLzoFf/vjFrz3zs6kfY8Uep2o/O53vyNJS6p/I0cmd43t60jMXlej7d33AACRLVvQ8PgTaPrXcx0ej/eqqkNEYiFZ56thzMuF36koILEwJzdvk5q5qRHduw9cGyFB+U88Lk/YlvHKasA2eRKGfr8cw9etg3nIELz9YyUONAbxwP9URkIUIWZxv/IZRYEG5Lgs8IgNyrwpmsgpXiBWGIxGzL3kyqR9Nn7+IaKi14s7JxdDps4AAFRsTV7laEBRQN74ZLXkECCFfjw64YeuIrGSCQCmLDkzaZtUZSOVKLPxOP776O8BQFOJAADpagJFUQgayGBpFI9h5GPYWaslSMEoh71iKXjJpKk44+5f47JHnsSCn92KIVNn4oy7f92dr3fYQFEUTr1pHE68fCSyipygaO2EN2RyFigKmH56CUwWA+xi9+CPn96MV+5fhaYqP+LR1NbmHaGpyo/3/7IBvqYIdq+tkx1yuwuJqFgloiJWcDWWH0R5SwgQBNAU8NBpWh+Pxz9VEkHZuA1Pf7MPLSqn6FZHDB/NrsXpd94LIHWy9BdlX2BN7RoAQJ4zA1YDuVbC8TDW1Sql0PMK56HAWZD0/jSx4ekL215IcuTuCKcMPkV+LDnRqqEO/TTZq1DhIYuTWIhFrj0X78ylsWMQkqp/dg8vhmOOkkfBuN3Ynaf4SpVOIspsmDUkhVnidYS05Vj8cBhV49Zn92hKnC2ikvnhX/6Iyp+Sx6IT8kgH9qaq5ArFlOTWWymTEg3SSbJ/hEqDAKJEDbEasbr4f/hy1rPY4P0RvFjlxQs8LlnOI6dxA8Zu/CW25f2AA5NW4IL7p8ml7vJ5CAIysBKCwIHX8dgKWdPRtt+Glt2ElDWlDYcpyKO+F6voep2oAMCYMWNQW1sr/1uxIrVbaV+F7Gtg0MldUA0Wzc8/j8a//lXTsTgRgiBoDNnidWTFojZzk2DMy0PAoZisqRUVky15so7t3wdOtKY3eDwYuuxrlH70IYzZ2ox52myWPVRMOrFPF8j50XnKzbcjfTByXBa4RKJS2arv4CipBFLSaE7J0KR91DK1PS0NmUXFAIC2Ov2SyMMJqc9Pek8oKglEZcH1t2H2BZcl7WcS/XGiYs5C2WZldZRoQuW26hMoo0VsocDH4Y+QwbdA7JgaCgax9RvSHXvyotMxbNos5JQOhdXpwlm//A2GTZvV5e92uFEyIQuj5+g39pw4vwg/e+oETFtCBvfExMK3/vAjvn1Vf0XIxfUnczW2Lq/W7NckVXwIQpeccdtCMeytaMPuteSelhSVgpGkkmbNe0vx4f0349qKlzEpy4B8j3bhw8eUSTwateLxr/bA10iOtW5UCz44vhbNnhgos841oVIRX9z2ovzYbXYrRIUNy/ki75/xPv5+8t91zSrTLEqO1PZmUmk4K097zdw3/T6cPfRsXDP2Gnmb3WhHvkP5G+pVNdEUjctHX07y/Shg7ej3AZAEZNfmofDaKTx2LgNaEECpJv9oJIx9P65Rvq6qOeriW+5CeiFRkEOcEQhpK3/iBwhpN1A614LK5VpqLGllnMi1kmuN5ZWx3GMk46i/mdznJtVicd+GFLlELWKisbrBauYI4DiSbBzmyW9kpvwYZiNzQIW/Ajd8fQM+PUi8TWKccg4cTcbdxcMWIavIiezB2rLl7MIKVLeuRSzwLiAkE5XKguNQvqUILbscEEAh4CTfM6tUPxfsSKBPEBWDwYDc3Fz5X6aOctDXIVf96CgqeqsaTiehS34tQY6LHSAXsiEr+XcJ+WKIqaTZaIjF9h/IZK6XgBjdu08mSbTbA2N+PszDdCpmVEgM4eS4zHj5IlL1Eppihf3Sy7B18kn4y+SLkeM0w2Uhn/v7j3bIE6Tm+8g28OS3aq/Z3YLrbwNNM0gTzcd2rvgOr/zq9m51NO0uWhNyVA4FiaGf8Scv1E1UlXJWpEaFQVU+yfAZ2ux7mqZgEhMKc1xKroaXI9vG+7bh2oqXkRupQ66bTOCR2jLwHAdHRqbc3LC/w6jqBqtHaPb+lDxRbFtehX/d/h22fNt+v6WDm4mqWTDCAwAIiImbK9/dhxfu/gF1B9sxI1ThyhfX4f1H1qNmbxsAwOIg19Sg0Uo4l/e1wMaHMRvlyHaZEalfAoBYoAuscq/z4uOQaNjnsyl5XjFD8phz/m/+KD8ucimrbKfRKROVhlADAnFCwgqdqV2m9ZSQkelaJXx2/mw8NOchLC5ZLG/LsmYhy6ok0XssyccBgHum3YM1l6zBv0/5N94853Wk55NFU/RHB3L8xQhaSLMBY8LYqm4ZEZNUN0HA0DETYBXzgHw+C+J/PUETbmFriTeJkdZR3RqUcLOkqGRZCsHQBnhjjfhv+VOa3SlQiATJfDB8upKU/+W/t8tKmgZb3ib/pxUDN64Ezn0BuHWd3IQwJP6dbbQXRbYcGGllvPj0ACEq6iaRUSOw4bINuHHCjQCAoZOzMWXRYGQPDuPyP0yC3U2uZYGthsCLhIpiwfDk/hHA4kDJGQCIKzBvsCAGASVDPcnnfoTQJ4jK3r17kZ+fj9LSUlx66aWoqEideBSNRuHz+TT/+gIkF0enKdl0R9Cpqee8qc87nhBzlkqUjTplqH5xwDRZlD9lS43oXuo0J+0vw2gEbe9cKXVbQufgPLcV1jBZxdVYMxG74ed4a+6lqHVkIttlwZ56hYT9Z2UZar1a1i7nqIgJozTDYOFNdwAUhcmnnqkphbWKqyK1uVlj2QHUqZIEDzd6MvTTrruuCumFJJzXIvqsSA0ax5+8SNf58ss7j8fcYZl45JxxKM0kg3pBlgcAYOPDsPFhnNL4NXJd5DcX6gn5LRg+qvtfpg+jaEy67nZ1MmwswmL5m3sgCMAPb+1FOKCvckaCcYR95LWhU8i16W8l993mZZWAAKx4e2+H5+SLxFFb5oNDUJQNdehn2Ky5mv1L08zIcpoRb5mLwP5fIFJ7LmwmIzzhsxD3TkS07mxAEBBvJQSsNFcJIUYMWsPFaWeci6KxSng306oseiiKkonKfi+prEu3pMvb9KBWVCSMSB+heZ5hJav/kekj8ejcR7Fg8ALcP+N+2d0W0Cc8aszIm4E8Rx4u+PU0FI0hxxtdNwegKHy7OA9UAslvq6vF7tU/oLWuBmHRxdnE8oDfD7ON3BfeZisqv7Eg+vkz5Hrg4oi3kjHXSOsoKg2KEmcTGyxaGTIutcUaAIZCmV8Ji1sYByIBQlQsdu35SdeNjKr1wKbXyGN3IZA7FhindcP1xclv7WQaYIiHNaEx6bE32iZvEyxmGBnlcymaQsl4ARWbnsXzt1yOXSuTnciPL3LCERdVSCGOMBPHD8MLsWmQCzzXgkaGR0H64fEI6wx6najMmDEDL730Ej7//HM8++yzOHjwIObOnQt/CsXhkUcegdvtlv8N6oRl+5FAU5iwVPVqQQLXnGwwxLczYcUSiJrUhNA+JznRkRW9Smzu5Bp6syM1UWHc7k5VdAiCgC1V2nPNdVkAL7mxa4RMtARjcq+QHJcZJ49SiMYTX+3BnEe/0bxfSh41qyz/x86bj5+/8h5OvPJnKBw1Rt5udZCBIS2vAHaVAVlDQrb64URPhX4EntcoKury7ERIJdlbv/kSP7zxktyg0ebW99UozrTj1Wtn4KSROXj3ptm4b/FIzBunJbY2LowckaiwtYSo5I8Y3e3v05eR6tqOhZUJPDHJtnKnvhGYr4kQa5vLhPQ8Mtm11oaw5gOlXD4aYiHwAgRekO/JRGyt8iKf0w657iyFDEy59AbNa+ZIGzLs5B4WYlmAYMRlMwdjWvq5iNRcBIF1wcqHYeDjEACcNuEKFIsVgBFauzgyWbWTTESVE3FcwXEyKakNkDCHejLUg17IZkbeDM1zh8o2YUnpEjwx7wnMyp+F4WlKs8/O+k4xDI2JJ5N7It83DJ5QDn5aWAzGpShMJqsN8WgEHz/5J7zxm7vRWE6ucRPLIlZZJfugxBka0VYTDvzy3/C/8x+gbgtYsX+QwZ0DnK5tVaImKi6xY7lVDPEXTB4Hq8uNtU2fwB9vFb+3W25cmEhU1NYRAICt7yiPJd8UFdoaQvj2v+S4TqYBGDwH149XekZJ7sGhFiVnqjQ7OcezpTbZkkINw37AHBMXlEIcLcYy+K1m+CwsYr6X0EaHke3sPdPHXicqixcvxvnnn4/x48dj4cKF+PTTT9HW1oa3335bd//77rsPXq9X/ldZ2b5k2xMIrl2HeENqrwJAISrSKkINtjm5DLS90E9sf/IkTJlMsIxSVr8ttUG8/5f1OLhFTLQ10TBZtKV/FpdVv7oFhKh0Bu9vqMauOu255roVolIrZKDRH0WD2H0122nBrSdpc04Sc8gkrwhzgj2/wUSIgDNDWe1Jg4vBaMTVT/xT7DgLVO7QthPoScRYHpzqpCWi4jlEohINheQw4CV/fBxX/PnvKffNHqxUcq374F0EReMlq8vT4eek20244YQhcLm0v69RYOFc9i8c17wSDvHvVzDi6FRUAGDyouSQYtCrqCYhr1ZB+eqFHdixMjkHyttABnB3tlXOfQn5Ylj/mVIF11YfwjM3f4tnbv4W/7ptORrKkxXTnbU+pCcQlZiVxrZqshDwczS+y1BUFX9DLUwGWs5Bcse9mDfYprk23XHyOX7GgTGFGXCZycQdpLUTojmhD5jkl3L31LthYkyy4VpzRLQf6MAPSk8JUas0QGqyqDZ1i/Odz++RfntnLA0Xbb4f1rJcLLzp53CkZ2D8/EWYdd7F8r4Rvw9f//sZAICZ5RD66Sd5vGEZ5W/Q9MTDwPMnIS6GPYwjFhCbAjVUoR9XJiEqFoYcK2PYYHBip/kgS/6OdoNHRVS0eYKB1ihJzv34LuDLB4CK1cqL029I6nStLmt2TD4FGHM2zh9+Ps4YQkIzDSEyL7EqLx2LkJybGNGpNpRACQzo7dtgixCizkbWIp6gLA1uegX8EQy3J6LXiUoiPB4Phg8fjn379Mu5zGYzXC6X5t/hRHD1alRceSX2nTw/5T4cz6E1SiaSxJsV0HYqlt/TTugnsJIkE1vGKMoC7XZpJP+v/7MDtfu82Pw1IWqMgYbRor1A3dlW2WIf0JKTzhKVv3y5O2lbjssC+AhDrxEysGxnPWJiBn6W0wyH2YBbEpxbY6qOp1HRT8aSQFQkONIUsif5SwBksB0x8zgAwP6f1qKhrOdVlUicw7zHvsWF/1ot2+S3SYZv9kML/UhhH5PViryhI1J+fwBIT+hC3SquiFIpKnqwOJLDkHztfkzybYGZj4FnjMgaXKLzzqMD008vQd4Q7e8VUjU0DInhHCmhFQC+fXUXyrY2ad7jbRQ71WZZNQ0S28PaD8m12VITxO61dfA2hlHXFEIGr528z311Hc5+ZiXqvBG0BGPY6hqL98QQjtRK4mdzS5DDRHB5zVtY/9gvcfu8UuS4zFg8NheeOLmmItY0DEq3yk62ASEMSpUEm0pRkZQU6f8WcbLqSOnItmXjl1N/iSWlJH/mwhEXdvibSKAoClePvRrFrmIsLF7Y6fepvXIAwFmXi5KJUzH9nIcwcu4lmLLkLFz420ex4PpbASjeKGaWQ3jTJpjE8TPOKAs6iib3eFwQjc0sZsCZBw0adsnlzLKiIhIVxmUCJzY7DMbbABCiIn/2it9rDhVojQCtZaTf2Kq/AU1iCPuGH1BV1Yy/X3UB1n1AqqjaGkLYsUIhzuZBIwGaQVtdDU6OEgsFiagw1Yqiwuv4dUUSttlVYywjkN/DIOf7cBB4rbpo4CNYqcr/OdLoc0QlEAhg//79yMvL63jnI4DgSrGbbzw182+NtoIXeNAULZftSRA4DoJOb5uau+/WrfxhW1oQ2UK6c+Y+pFzkjGpSa6kJorFCq3IYTDQYg3YQzMh3gFbZsTOqJGXnySel/D5qDM1OnEwFXLbnNqCKuFbWCul4fyOZRD02IyxGctHne7Tx7aaAMkFIikqqidqkIleJk23u0OHIF/MqXv3V7Umdhw8VP5W1osYbwU/lrRj/+y/xwoqDco7OoYZ+pLCPnm9MIiiKwsSFp8nPpRYDtk68V0Lx+ElIz0+dEMlmDALNMClf7+9gGBpLbiEW+zY3+dupwz1SF+ai0ek45VplUfDJP7bA16yykpcUlSwbKIrSLftPRMX2Fnz/1h68+dBafP2fHXjtgdWw/dCEjARFJcQLiHMCdtb50CpWD4UZsQJHzL+79aRhePeSYaB4DrFwCLF9G7H2/vl49rIp+Pl0EqKZOXE4KIqSFRVfzAeTTWUpb9MqJJKiIhEUKdQjE5VO9Cy7YswVeHTuo/ji3C9wz7R7AGjVkvZw15S78NHZH6XsZaQHg0l7rQ6qG4sDGxux6r39+PDJTeBZAYWjx2LsiQtgUDVgtMRYsA0NoJvJYjKuUlQk0YflafEzLIAxIcTBhuXKHElRsRrIuMQ4TcgpJYuysFgJ6TC4wYphFEuLth9SsC0KBFTqvGhrAWcuVrz1CniOxQ9vvAQA2LlSqTZyplswajaZE1+84wZsfO4V5Dda0BhuxI7mHbBUKsfUJyra+SI9X8n5Y0CIOpOifNrnOAVxRyaGTpmh+/qRQK8TlbvvvhvLly9HWVkZVq1ahbPPPhsMw+Diiy/u+M1HAp3I42gOk5VPmjkNDK29mXgdMy8J4W3bNM+FeBx7Z88BBAHm0aNgHqoKoajcUD96elPSsRgDk2ShbHObNMlmgqrkN/2aa9AZ2E3KoHzx9CK8fEY6nDUr5W1eszIw5ahimFJsXYKUwwKoQj8OfaKizkXRq4hRt6v//rUXk14/FKirlAJRFv/38Q45dHWooR+pNNnq7JwKeMLlKoNAMQnUkd75ijij2YJLH/krRiQkaUrw6vhjHG0w24yYeeYQjJhOrpm6/Uq+lRT6sbnNGDZN28vo1V+vlsv8vY1K6AcAJpxMcn/UnWvVsIukaOu32qR4c4iHU0yk/cAWxYtO5Z4obwrKIcYZo8nxo6Gg3Pcqqrp3m6uUcLchSu6lnFxy/lJeSJANalSUVKEfiagkOt52pWdZviMfJoZ858eOfwx2ox2/mfGbTr//UPDFv7fLj8u3k3GYphlkFCq5i7YYC7a5GZTY94hjaEjagdRsWg79mFPk9dWRULPRYsGcMy+D00gWpIYcOxbfchfGnXQKJp1LwjF2oxtsnJBgC62QhnjoB+xZ9SziTWXaY1MMBGsGjGblN3/rDx9rcqYu/8OsJKI2qZzsf+HHF8JaoaiAegp+MlFRFjAWUf1hdKpTP827DG9lDEHTKbejcPTYpNePFHqdqFRVVeHiiy/GiBEjcMEFFyAjIwNr1qxBVlbqRMMji46JyrYmQjj0yvnaIyqxg2Wa59G9SuWAc96JoHVumpp9bQi0JMcKDUZaY6k84aRBxEDPohyDVyk7nbVGl0qTHz57HB45ZxxOMO3SvH7CRCXHIVtVGpueUMr7xtoKROIc8Z0Qbxq1ovLBpmp8t5usCorGjMeEBYtx4lXXQw/OdEW29Dc36e7TXTQF9Ss/HGaDrp9MVyCFfjqrihiMRuQN1VZSOLtYum+yWHHaHb/SqFQSymypy8KPNuQN8wAAavaRvwHH8nLTQoeHXLeTF2p/j6pdLRAEAW0SURETX8edUIBLfz8TF/92Bs6/b2rSZw1ROYbqwWg3YI+JRzOjrGDLW0JyGbzHo4R5pWsmFlImn2CbYiYmq5Oi8igRjwgbgVlFVJJCP5w29DMmY4ymyqe7XeAnZk/EqotX4cKRnQ8FdQVkXFOeq03U1HlBabkKUTEIJvA+H4QKhTjGxYUfGyH/x3NJib6sxJz+N6BoFjBarKSq2yq/d/w40m/NkGMDYzfClZmNU264HWnDyWfaDR7wHBmjTaIxpiBw4KI/ItR2EHt/+AK+Sgv8NeJnObKx58cGVOxQyET19ndk1fzMOyYmGRwCwOzNcdjDAu59i8NxO5TfgQsGIQgCuFgUZZdciuq7fiFfJxLUlhAu0VMmSVGhKBw02xChAYruXeW114nK0qVLUVNTg2g0iqqqKixduhRDhnSvM+1hgequkEobvyr/Crctuw07mkmS1XdV3wEAji88PuntfDA1UYnu3y//f+Ccc9Dy8ivyaxnX/0y7s3gNSTkpiWCMtKbN93EXEG8Udcgo98EHAQCZt9yS8pwSIRGVfI+olpRpzfhmD1MG5TxV5VFaQinvO+ur8MbaCsRVDRIlovL5tlr8fOkmXPWfHxGJc6BoGvOvuwWTF5+he07qJFz6EPru6KG2Tb/raY+40kqhH2fn5W6rKgfL6nLDaEqx4usAPKtUojAmM8qsRdjNp/dY75q+juwiMpF7G0LgWB5bv6tCW30IFocRQ6eSa3jGmaUakvH5v7bhmZu+lUuTJaJC0RQ8OSQMlD3YhTPvmAizzQCzzYAz7piIWecMwXm/moqbnjkRp948Holw5ySTgG93NaBGLOPPcFpk1U0K/0RUq+SQlxCVWCSM/WLTQauoTkpJsWE2DIvK8KwqrrW5T1RUjIwR5w1XymIPpQu8nkFcT2HO+UNx7RPH4/TbJiS91lZPxtpIMI6KXcp3ry1cBACI790Lo3gfRDMkokKD44Ddu0n42igt7KZcCVzzOVAgElGvMu7Gq0RFuFirjDJiDo3N4AQtkM8xUhGcPmsDBE4pqKhevhnVK9NR9X0GBB4oj+XjqxfXJpivkXFX4CPY9MVLsuGj+n6lIOAPr3CYfCDhHo7H0bJ3N/557SVY11AJ36efJhlNSgaDgFi+DYBNsD1wpKXj1vkj4bIYcOO83p2Te52o9CcIkQg+2PcB7vruLnxX9R0u/PhC8AKPMm8ZAGBSdnLjJj0ZLvtXpPNxdD9JGPZ/9TWiO3bC+8EHAADL2LGa3BLy4eRilLweFl47UiNXG4w0jjt/GPKGunHKdaokXLsSm3YtWohhP3yPzFu7TlTcViM5hwSiMq1YCdNcOE1ZxeiZo322rVZm9ozBABiM2FbtxY2vKa6r22s69sVRq0FRnd83FQRBQDDKtrtPnVffJron+vxInij2tGQPilRQ5+jwbPvn3h54VW+Tq55+CV/ln4rWUBx7GzrfKLM/w+Y2wWCkIQjEe2jXajJxzzijVLbbp2kKJ14+EkMmJau5OSUuXQNFACgcmY7rnjge1z1xPAaNTIfByCCnxAWaplAyPhPzrx6NU+6YgH0GDiwEjJqRi0fPGQeaAp64YAKsRgZlzSG8t55Mlrkui6y66SkqgVayAv74yT/JFSdSGNXCiIZ+bAR2t3KdPbb5r5pzDse1RAUAjss/Tn5sNab2UOlNSDlC9rRkwi4RlaZKPzi+BBSdAYp2oy19OgAguns3zBQxAlxXMhE/TbwNe0vPxb56RaW0exLuTZdoHOhXiF68jvwtjHna0DVtNwJinqCdMUEQWHxeU4JA0wZMWqD8nvUh5Z4u93vw7iYbot6XIQjKolYQOKTl2uDJ2oTdq77Bew8/iO9e+TdWvf2a5jMLEirqDWJu54d/egiRWBSVGaJpXKvW0j9D5cnFi+NpIlFxZWbjrgXDsenBUzAkK3Xi/5HAAFHpAvhwGL9ZqY297mzZKSegpVvS4du2FdsXLUTrm29i/+JTUXFlch8byxjCZmP7iKIiJCTqqslFIuLiqtz4/mUYkq2KVRtpONMtOOfuKRg2VSEwiccyZGV1qSOuTyQqLquRlCQHVMmr065Dut2Ef142BU9fMglTBiukxaNj6z44wy5nn5vtDlz10o847e9a4rOpsq3DcxozT6nAaqosR9Wu7e3sreCxL3ZjzG+/wJxHv8GWKv3PSWX777R0nEDZHjiWlVe/JRM67wSbXayUKecP734PLJ5TiIrH7cSc4eQa+Xqn8vd856dKLF3XQZfXfgqKouASFZHW+hBaxcmmaLTWL8RsNeCkK5NLtsfNS52U3BFGzMhF3GXEfx0xvFrAY/wJhbhoehEOPLIE50wuxJyhZKKUKudyXBa5usvfRPIqomHlugyJoZ+DG3+St1nsZPJTKypm1b1fx2lDpGGxx4u0P6BtBngoisqRgLoJpYS2hjAEXkCgLQqKYmByXQqT6yq4WPJ7RWvrEE8/EwCDWLgZrXYTKgedjGXBSwEAZrMVJRMTQnlOMR/Op1TfxGoloqIdWymKAuUm48QI13ggvh17/Fn4bJ0PoTblPmt02sHSFChrOuL0H1BkHwUgDoFXFBWGYXHJ72bC36iURq//5H9Y8/5b8vM9eRn4fngh/BZlEWUZMxoCgDaVgiJACRcazGaMmTcflCqlwREli98cn3bRJ1U40TphpyONAaLSAQRVV029fJPVNatl0500Sxpe/eNv8LnbiMr/+wMEqhiUcwiY3AmwTLkWTCYxOpIs6+PV1eBDIfAJ7dfbJSqi7GukQrC2Khnl6vyUzh4rJUItgCCA4wX4RQXCbTXKJcnwDAZu3yh3KF40NhenjddalhtUmfVZokNuIMLKUjYsdqzcl+wvs7+x4xW+zeXGXUs/QtG4iQCATV980qmvJU3K1W1hvLyqXHef8mZ9okJ3gdzpwdtQh2gwCKPZgvyRnfcumXzqmbjgwYcxafHpmHvJVd3+/Mmnkli71B15RC6Z2CT/m1CMxS/f3YJ739+KOY9+o9v6oKchCAI+31aLA40BhGIsQrHuK0adgRS6Kd/WDJ4TYLQwST2BAMBkMWDwOCUP6pTrxmis0LsD2RBRx5gx121OeG5B/giiin75r7+hta5G7vkEAEFvm0YhAxTlTSIYES6iyUsJ8xGwvPL7JoZ+ACDLpihJBrrnmnoeDpgsDGiG3JMZBXbQDAUuzuPTZ7dg748k142iDKAoBn5jJlZP/y287iGgaAdog0g6RWIQo8lEnWnWqYKTSpX9dYAggI9x4MVQoDE7mcwxYtfuUucYMJTyex9c+4X8mKcprBpZCsfCR2E1FmNWthjiVikqHBtFLBJGyNvW7u8QsJqxM9+JrydS2Hb/2bCOHYeNg3PAq8hF0GwEy5Fzufnfb2DRTXfA9+lnmLOnEiNqmlHQQnJhXJEYLnvkSfl9nlz9vlq9gQGi0gHUCah6+Sbbm8hqngIFB21HRBxAQnkjYBl/MWyzboNt5i0wDpoB67QrkHH99TCkpYFJJyu5yltuAR/WHpdWZejbxW6gaZdcAgCIs2K9PxWGefeb8n6JRGXvulV45Ve3IzydNLAzDe5k4uSeL4A/lwDfPYpmsaSYohKIiisfSC8FxAQrX1MjPn/2yZS+JtkSUYmyCPkJ02/j9UMpqUIviaAoCrPOvQgAULFts24/JUEQ8NsPtuHJr4lXQYsqUXbNgeak/IxwjEOD//CYGgVaiOrmyMgE3YXENIqiMGjMeJx01Q2H5Hky9+Ircebdv8Gim+4AANjNZCKSyIH6d69uC+PfPxzs9md1Ft/tacSNr23ASY8vx+l/X4H5jy9HJIWra09AUlS2f0+u48wCR0p1ceHPxmLmWaU4/76pGDY1p0sqZCKCURZXv0TK+aUWBmrkJDh+5rosGHfiAvn51m++lN2cAeJw7EswoLQk5KhE2Iim0ifEhnDq+6ciFA9hdc1qsDwLA23QlAe7VD3DArG+HRKkKArTTy9B8bgMLLp+nExCy7Y2o0Ks/hkxU6kODNuyUVVwgvhmsY2EQK55nm+FmbZhjPMkNL++E7y6y7ZEVOJBIOoD7ydjCGWkQVmS72PPEiWXwySownVB7bgyNEfPHkI7Hj1381Upvr0WbXYjnlvMwH7ccfBceAHqPNowjddKxl+L1SbnuMWrKuEOxzCksU1DAnJKh+Lqv/4Tcy+5CpMWnYa+ggGi0gHUJCIaTLa9lzqHus1ucKIvSq61BFljL0/al8kqRPZddwIALONIqVfsYBmEUGpFpfDvf8Pg119D2kgO+OFxxDkSUjFSEU3pm0FFVKKhID58/GE0lh3Ator9GPzmGyh+a2nnvvDHpGMnlj8K3w/PYRa9HcUZdhgZGvCJdf0uLdP++vmnsf27r/Hqr27XbP/9GWMwe0gGrj+ehC/8UVZO6qqK6E/WNSmSWfWQN2wEaIZB2OeFvyVZndla7cXLq8vx5Nd74Q3H0aTq5VLdFsY7P2nLRytaUic+H6KggoDYVNCZ3r41+eGCwWTC0Gkz5VW2VfS7CcU4BKIsTnpc2//jqWV7ccnzaw6rsrK+TImb728MosYbQWU7f4NDhTtTm3cx4eTU7TeMJgZTFhUje/ChG0pKRBlQwjtqqFUWk4FGhsMMV1Y2Ji06HQDgratFNKSV5at2aq0NpMR0dY5K4QwSxqhPIxNybbAWX5R9gV99T3LkzhxypkZR0eR+cb3nQtpZTFlUjCW3TIAnxwaOTf5dC0do803a3MTuwZlOyFmJ5SCyGjeCidZgSuYCpJncCG9tQugnVeKxyQbYxZBY7RZwIlGJCnLaoAaWQjdiPLmGjXTyb0gbyTkMsuuHcdXhus7m38UZE0qr7ciKOSHo9G9rs5NrwmZWrjNapwqQEqtM0/MLMf3M87rk2XS4MUBUUuC/G6tw/Ss/obJGyVYK+1qT9qsNksnbbXYj3ETiwCfkXgCzjkOtusQs76H/AwCwjY3gEkrH1IoKbbPBNmkSqI9vg/D1Q4gL5GIyUlGYaeVC5jhy1wg8j9ZaJZ5au3c3rBMngvF4OvfFVWZHQ398AG+a/oipGaKEKcVpE4hKY6V+GOXK2cV442czkeOygBY4WOt2o62e/F4BaOVuaeKs7aSiAgCMwSjfTIlZ7QA01v8vrSwDANhNDG4WM9g/2lKTsP/haXAZbGvFZ08/Tj5f5QjZm7CbFaKyen8yyQOAVfub8fKqssN2DpzOSN94mBQtQNtXx5FmRqlO0uzhgPo6PGdysndNjkpluWLmYDDiOCGFNr2N9fA2kMlTIprlWzfJ78kqLpVDFnKOChdGzEHjzfmV+GKGkh/x4KoHZRftO6fcmXQul426DG6zGxeMuKDL37M3MXy61mguq8iZ5I0TFxvG2j1kzDAWZmDkzhdhMbtRaFNsANiE1goYSnLiuO3L4FtFxi9/hE0y3ZQ/R1RqGC55LDNYZiA7YIEvrr3nKHEqtum0yJD6fqUCJRhx/OZM7F/6sS65Kc8k39equt04Hzl3U0kJSt5/D7Zp01D00n/a/ZzeRN8ORPYi9tYH8OWOelzkC0LilZFAW8r9eYGH/8d17R5TUMnahox0gKYBjkO8StswSu19AgAIEQLEwgSJWxqpMAyUckNxMR4f/OUP2PfjGo3VfsjbhkBLs6Z/TrvQ6Zj6WPm5QMWXgF+c2J1aomK22tCeUOwwGzDZuwnTWtdho7i4jDBaufvP543HbW9uhDccRyjGwmbq3KVpc6ch0NqCoDeZRG5VNVP8q7iqzfNYsWhsLp75bj+21/ggCIK8ktxcmUx2Mh0mNAViuHxm9z1Hti9f1u33Hi5YTUroR+0PU5ppx4EmZbD7Yns9bj1p2GE5B17HCXPV/mbsqffjkhmDD9m3JhEuFVEpGZ95SOGcrsAfIUT/z+eOx9mTkpNyJxV5MDTbgTH5LvxykTJherLJRFt/QGknMuq4E7D5q8/kDriDRo/DOfc/JL8uKSTheBiNoUZETTrdgAEUOYt0XWF/Nf1XuHvq3UnGlX0dkxYUwZFmxrCpOfC3ROBItyQZYEpwZngAAJzDgbZBecgw52uuBSGxMnDYfGDzG2haNwrxmJjczAONFX7kFCcrbjwleagkj2EUbQdv9CDKaZVDC2NDmAsk+d0ApJRYqhhsD9U7t2s8dhJRAiPi1dWo/uU9CG8glZaO44+HZfRoDH71lZTv6wsYUFRSQLKCp6MKK4762+THy85fhny7MmGfM+wc+LZuBaNzcUrgIwpRoQwGGDLI6jpWrlUkEkNB8BMWzwrK5G64fTXgUFYRsUgU+35cQ96fkK+x/LUXO+eX0XIQqN+q/9qrZwNh8SawaVUBtT03p1NC67QYMN6nPa5kEy5hUpEHDjFvoiuqilQdEfISkvHBpmqc8fQKfL+nUVcheeiMMRie4wRDU2gJxvDUMsVkb2t1GwDgxhOUOPPS62fh8zvmYsHo7idTVu5QvntGB6ujIwW7SVFUQqqBORLnsPT6mThnEln5b632Hra8EV7nmnz623343Uc78Mrqsh7/PFeGBa5MC2xuE6acWtzjx08FKXxWlKFfSeOyGPH1XSfgqYsmwazyBXJna1UCd05uUp7S1DPO0bg3y4ZvXAT1odTtJdprOtjfSAoAmKwGjJlbAJPVgIwCh9zmoHBkshWAO4eEX3ev/gE/eiywGz2a14VowvU+iFjHx2PKeB8RBN3GkwDAiwvIWdlngAKFaRmVmJJeBZe5CBTtQNyUAQOlrYq0GcQyYrFLuuZ8s1KPPUyCc/fOH76VH8/ZoyU3OaEoqu68SyYpQDeLLXoBA0QlBSxizget6hgZ30eSRQscBci2ZeO/Z/4Xry5+FRsu24Drxl2HaGsLzHQ7/gOcAEEVSzVkk9inkFD1wyVmevvJgBPnCVExUFHQmaVA8Rx5l5C3Eamwe9X3qHz+emBV6m69AIAPb0v9WjwIHPiOPLZoV2KMQSFnek6xDrMBjKAlT+GE36nAY5UN4zqbUAsANrcHAFGOGnwR/HzpJmyp8uLd9VXYU6/VeaaXpGP20ExYjAzGFZDvoM5TaW5oRGG4CqeMzsbF04uwZFwehmTZMTLXdUir75Zq8hnFE6dg8pIzu32cnoRVRVR8qjyUCMtjZmkGHr9ggnwPvLDioKZXU09BJ11DxoaK1CvD7oJmaFz04Axc+ruZsnfKkUBAJIISEe8sjBYL8lQl6UOnzYJD5cpcNHZ8UjmtOpm2Ptg9onI0YfGVo3DuuHTMHqfkhqXnk8cOQxqmZi5CjrUYAOm7BECbTAsAroKkRoURHoiG9KvUBChK9wUl98BEmTEv5yDSvYT8xyy5MNDaYoLZ2WfBwth1x091S5FEJPZwWv/J/8gphyJwh7UhLK6lFZEt2q7ztE5OS1/EAFFJAUlRMYVVMb91mwAo9tI2ow0TsyfCyBBWG/X5YGba/8OrbwJjgTZeHTUwEAAYmTbtm0RFJS4qKkZGvEEcuTBQZFJ3prc/kUR3LQO+/A3QuEf39U2VbeDLVrV7DBkJREXt8bBnzYrEveGwGGSnRgkBgx0ZKlM4iqKQKxKVriTUqonKFzuUgXlbtVc2q5MwZ4gS/nrtOrJKqm4Lo7IlBEEQcMqO/+Dsuo+AugN45Jxx+Melkw85PNBSUwVfIzmvBT+7tdvOsj0NqYdTOMbBF1YG3LhIpCmKkitUHvtiNx7+ZGePn4OeoiLBQB+eocloYmDqRFPBnkRADP10x4tnzPHErj2jsAgzz7lQ01m8cPS4pOtTSqYNxAN4bafWHEwNI33oTsv9AYEvy8FW+pFV6Uf+UDeKxmQgt5SomrOyz8AQ5wRkW8hzr5Tnl0hUKApC6SLNpqgggE3cT4QfZZrntoJFEHjAHCOqr9uahxwrCSVvatuMICfAZnCi0DYcJ1x2DRb87FbN++2eNLjdycoQAHhy9Jv3WhxOFDz5JLKKigEAaYEwuNZk8j+gqPRzWAwMIAiwqfJS6LJqQBA0mfJqxAIBDVHxG9qS9hEiyqTgPvss+bHPYsKyMcXYMiYT6ZMTJjPRZC0uiHbX0vzuzMFFGbcg0/AfbPvm1c59sX9MU6p3VDjrHyuxne9kWCKRqKgqEg5s+DFpd7OBSVJU/AYnHj5nHM6dXIjXriWkId9Nvl93FZWNqlW4Os9CwpyhyiDvMBswqYi8d93BFrQGojAK5G8Trtrf6c/vCP+580blM9tZGR1p2ERFJRhjNYrKXy+cKD9WJ7tuSmGQdyhol6gwvW8y1RPgeAHBGJnQuqqoAMD4kxfiot//GZc+/AQsdodGUZE6+aqhNnCTjCj1wKMdOesoQlQVnjntylE47dbxsEddGDNnPtLN2tCan9MqKnwoDv+KarS8vRsRj7adR4QH4jF9osIihA8rnpGfGwvngL3gI5jiROE9IU1ZoIbAw1hCwj7TF5+HKaeeifHzF+H8B/4o72P3pGHh+OkoalJy6IZOm4nr/v5vLLj+VuSUDsWZv3wAOaVKE1vPtOlwLVqIc+77PSbOW4BJ5fX6RMXWPxSVgWTaFDAbadjYCIysIp9RcRbmOKNxbRRYHoG1tbAMT0MgEoLZQ16rC5ehKVKFsWnHaY6rVlRskyfLj8szycVabXCDqf+R1L5RFAn7rHwKALA3Qo5lNIoDvCMXbVEeVY36MnnJxCk4uImYwsUFVdz5iZEAKGDOz4EFv5c3x8XLYS0/EjNobfNBDRKJiqqteLBNf3BkEgbGIGPDhEIPFo5RBgtZUekCUbGKRlctLW14v7o66fVTRudgSLYDLYEYJhVpVyXTS9KxsaINK/c1wVmhmOe5umBx3xUkmUn1ImzipNkWimOVWPVz3XElmK/Kxan3KSpdnTeiSTzuCcQSSkpH5bmws1Z0Xj5MisqRRlBlYufohqJC0bSmL4u6ZFTdB0r+DKMDDqMDgXj7PijHQo8nQRDAeZVrOFbpR6zch9Z392Jy8YmI2YJASBmPA2Loh21qQ/TAQQTXRRHaRELqIWgVqIggwBzTJ3s8b0aYC6MquAeF9uEwUCawQjrsgZqkfcdnR5Fe7EKgwg+rxSkXQqjzk2xuD9jaOgytb0WFWMEz/uRF8j6SSRsXj+HjJ/8EQGmp4EjPwEnX3YxdT/1T91z7C1E5OkaDwwCLkUF6hJRw0Q4HKBORMYbUChqiElhZA+9HB9Dwt43Y4zDBRJPJNsaFEWKTy9fUsiLtdJLKHyR0rmzYDpT9QB6/di4gmi+VRYn1eslo0dDHmobWaOqcmFNv+6X8OCa2MRcEoDbsRJSjgZVPavZ3gYRw/sqeh9Ojf8AT8fPwD+sNOj+OMlgKPK8xowq2tSXtzsa0sdI4ZYBA0bIRnASp8WGtt/OhH8mRc8uBZJUIAIbnOPGrRSPxp/PGy2WfEmaUEIVj3aq12Lr0eeV84/odlLuKvjwZ2IwKaVpfTohuToIZ2ZJxiqwcinEaH5qeQChhRepUKQ5Hi6IiVfyYDLQmUba7oGgaExacisJRYzFYLF9Wg6EZfHPBN3h07qO4btx1eHnRy1h62lJMzp6MVxcrqisvHP2KCh+MA5xyD7LNEQRWELIQK/PB6NFe70HxcuS8QRw86yyZpOghygOsnqIiCIiyZpjdP0OMJwsuIcqDbWxEWttuTPF+qt3/008gRIn6y6tCsK7MLAwaMx6DRo+D3e0B19wCk6qxqMmWHLJRV3bmlCgFAZTRCNqtjNnGIqXPT18eo9QYUFRSgBAVsrozZGWB8/vBNTXhd2/weGOWwq4j+9sAAEKcxxDnRJhpQmJYIY4Qm5wVzqtCPxRNy05iaqIS5RiY9y0DSo6Xq3BqYyPh48jEMWwBCZXA7EBLTJ+ojDpuHiwOB8accDK2L1+GOE8DEy/FD9uj+HFXPUa5GnBqwW7yeeIN4KII4fAJNuwQirGVK8UiJw+E/6U9uEm5ScIBPwTVoBePhBGLhGGykPMSeB6V27UJXBHajKtmFyf1kMjtRuhHcuQ0sfrvGZKdOgYr9SYaFNYav8XCnSdK7UHdX2f2+Zf2yDF7CjZz8qTpSsjdePC00Rid58JjX+5GjOVR0RKS2yH0BNSW+UaGgjlFG4j+DDk/pRthn1SYf93N7b5uNVixpHSJZtvLi1/WPBfQPyaoQwGX4IfCNYfBhZQwJ2XU3gMRcdKmDGYIsRj4SDNoi77vUVQATKKiEquoQMPjTyDjuutgHTUMEc4OirYiLhIVphEINLKg7dkoyEho7sdG4PvwfTA5J2nSAiiaxgUPPiyrmJzfDxrAuDGTELZZkD9sBBLhzFB8gYrGartLGzwexMTKSPuMGWirID29hFjPLj4OF46+kaGHYDHQGqIiqFSD/EZVq21Vrf7UzIUYk0Z6qZhcdoQ4hagwHjLAq1kzAECczATVnB1gTUTt+Pp35D0CjfdbHpFfl5MBzU60xAgxOumaG5GXrhCoxbf+AgCpHABERcVThB+3kHyXnT4xvs2xcr8XNwiz9wrK5G6weZJ+G7VNq6+BHM+RngGj6HwYUqkq37/xEt5/9Heat6/JnovfnTEGicjvIJlWj/3v95LBwsIrEu/1x5fCZTHgtPF5WDxWP9kMENsCAHJuioR4pPNEqT1wKmVm6hnn9MgxewomJvnWz3RoSUia3YSfHV+K8WKFVFcIZGegVlRMjFZxCB9GK/0jCak0uTthn8OJY0FRUYd9AIBtiRCVRUQsobyYFYcXymABZbWBD+gbIR4QVXFWvEZrfnUv/F98gbLzzwdiQUR5QkYEkXibvSZwXgssEy8H5ThZcyyBjSJWSapJk+YGqN2C80G7CjFn/mKcefevNV5ZEhzpGZi06HRMWXJmUp8eRuWIbRk/Tu43Z585U/c79jUMEJUUsBgZOOOEnDAej6YhYU6dMmAnmQNJ73fZNYqKMYcQCl6npC1O0wiZFJLhj1uwPzITke+fw3Lf9dgYPEuzv8kqDugmB1rE0E92mhmz7aQ+ftTYEvkCN4rKRpxnEGWUmLaZFm/YqA8N/ijMiMFMkW0+KETFalNakuvBK1a0uLJy5BbpatOh+v2KT0mdORtv5Z+LXRb9njV5HnKuvgiLYMLvGoiyOP3pFbj032sQjnG4+fX1eHV1GR79hqwMzHxU9rS+Y/4wbPndQjx9yWS5eisV7l88AukxMiDxYkfRWKRnbNzVIS+D0dTOnkceFEXhDbHySUJxpr76JFm8S431JKwvb8Wtb2zoUpWWhD31fjk3BiChEYtKUVm1rxmcjiFcf8OBRkL+9Xr89AbOHELK428cf2MHe/Z/SESFSSe/Pdsc1oSCEsGElFCP8awrQTHJ9+yGIIuymFiFKSkqB1V9saJ+RAQyZg6ft1jzXkNWsgoCNgpBnGfUPltqxGqDMAw6HfaTHgRlTT0eUxSFk66+AfOu+FlSLpmaqJgKClDy3rsYvma17OXV1zFAVFLAYmRg5sjEndgXYdRz34BtbYUgCGCb9Adpe1YGOIHFNuMaZF4zVr5Z1IweIG2ovh09WNNIalPgJHze9iu82PAytoUWY01A2zfIKMr2cZjgZ8lx02q/RrGjDdcPXYtFIxSCZBJVjjjPwMcquTWswJB5PeJFTVtYzk/hBQoBKIOqx24CbGLsc+x5wIXakkevqKi4s7LhEC/61jpVS/SI8vusTJuFBnNypYIEh9kgS+SJpm/PfX8A26p9WLmvGS+vLsOnW+vwwAfbsaeN3Nw0BJgEQgw662oLAMMOfoNBEXK+IbFiq6dCP1KuC2M0HjEX1K5g1hDtIDUoTT+xTmqapyYqoRiLc59dhY+31OI/K7vWwDDKcjjlr99rtpkMNArSlPuszhfBv3/Qb3LZn7Cxsg0AMFGsMOttPDTnIXxz/jeYXTC7t0/lsINtJPexZZgHAMAH2+/OXXLwI9lLZXPbGMQtZHJvjCvqU4AHXAxpCMnGOAiCoC3xjXgR5clzi6f9RNWsmyfANmO6QlR0FBUAciNEAIhV6e7SIQzpSoGAISsLlMnU+bYqfQADRCUFLEYaFrHih7JZYR41SvN66McfEdnenBQHleDIJpP7/ur1sAxPA20jigkf0hKVqIEBmyDDl0cnAgAE6KsB0qTXKrbntjBx2DaSrG6nMQa6dpO8r1FcpcZ4Bj5GIQmcQJNwUKQNeesfw48WEvdugAeC6rJwW43AzzcBd+0CznsBGHW6/JogCCjbTFQcd04u8oaSFUPN7h3K9xN7T+ybfhVqrESOPG9Kso24BGmyOtCorVr4brfSLfZjVY8ejjaAFd2Ah3tonDs59bH1sOGzD+XHQZGo9FToR1JUDKa+paZIoCgKaTZFyUtlWZ8rmqOpicoPexVjqq5UaQFELUmE2cDg5nlDNdse+aydyrN+gs0iUZk0yNOr5yGBpmhk2Y5Mj6MjCSHOI7ytSWOoGW8kBMBU6ATtaN83xjbBgNyG9WBaCTk2sDR4M1Ev9kZ5HIhy2BBk0coJcFLiWCQAHMtrKme4UJtMVNhdG9AezEUu0A4HECPnqc5RkRCrqkZkj9JCIbjB360EWNquLISZzE62U+lDGCAqKWAxMrBwZKKhLRYU/u0prD1O/APTBtTc8yBCm/Sb8QGA2UUu1mgoBIHnwdjIZJoY+rHccE3ym4XOdaxtbSSTRZopQQFoLQPE/BpjSJQpaTt8Ia20GOaMwOvnY2rFi/K2z7lpGJKlrBDcNhNgdgKu5FyP5spyVG7fApphMOq4eXIZZc0eZYKJiB4rPl5ROf549tiU32lCoQcA8OHmGvywtxFbqtoQjLLYXqOoRNuqtbHluOgd8e8Lx+DxC7RJZKnAsXGs/e/bmm05uWQAV6tAhwKZqPSxsI8ab90wCyNzSWVUKkjVQHUiUflyex1ueFUp5+5qI8GfypNL2E0GGm6rES9cOVXnHf0THC9gn0i4R+Udehfm/gyBF+BbVoHInp53HAYA3zcVaH5tJ1qWKmNPvJ4QAEO2DYaM1NWR+Q/OhH0GKcunvMR23sFQ8jIxwgvY529DZZwQBGNMqeZkYzwom3LscFUdQJFpte3FR8G1VbR73ozDASFOxhs+zEJQhTsje/bgwGmnofGviqO4EObaDV+lhConqT8pKRIGiEoKWAwMzCJREcxWmAYNwjunurByFAXzuItgX/gnhLfpJ1sBgNEuVr0IPGKRCGi7qKgkhH64Ij0TsPYlSgkhsRGfwyCqOo4cYvcMAPXbAQCmauI2GzdnIOTTTvAhzggElbjsWn4kNhZegfOnKsZvavfYRDSUE8k/b9gIpOcXwpNDFJPmqgq8cs9tKN+6CTGRqHhZhai0V6Y5ebAHAPDxllpc/sI6nPH0Sizf09huvkKEJiv+SLB97wg1tiz7AiuWahtxjRtK1JieCv1wcfK3ZvowURme48TndxyPm+YNSbmPVOkjEZLrVSQFAKpaupbT0yLeA+qiLym515qQU1TR3DP5Qr2BipYQYiwPi5FGYYqw2rGC0OZG+L4qR9OL2zr9HoEX4P2irFPkJrCSqKzhbc3wfn4QDf/cDN4XA2gKxmwbDGmpq9UoiwGmkhJk3XEHHCeSvC0LTcEgXp9pTZtx+g3D5f1tXBQ0yDXMxjgIMWVMr3njawAAw0ZAs1GEVvwFkU3acLl7SSmyf048tGiHQw79QAAEVYK5/+uvIUQioAzac0+y+O8EBFVpc18MQ3eEAaKSAmZV6IczkwvFF/PBZwNMJceDomgAhIyYSpK7kBpsJrlhVDQUUIV+tCSkZpfOjSt0kqj4SLmZjRGJitkF5I4jj+u3AREfTPVkUokY0xELawf9+rAiB94bvw7clZ/gyRtOw2UzB+O8KYW4ePogzBuRWiZuFImK1ChNKhWWXnv3D7+RS3QvPI5kmS8c035zv3kjknNYnv2OOMWqwxTXHack5AYpkagE9Nuu66G5MnmlI/XUSPydugtW7BPVV0M/nYXHSs5/f2MQ17yU7Dxc64t0qXFhW4hcr789fQxuOL4UAPCbJSS0GktoAPTuhm4G5fsA9taT63FIliPJw+dYQ1S0cegKwlsb4f+2slPkxqDqjO3/rgqxMrIoc55QCNpqkMffRJiHp4GiKVAUhcwbb4BtIlF7i0w0GHFCX/T0NciaNhqLx1Sg9MCHyArVyZ3r2SgHXrUAbNtOCJOBDUGIRAA2gnj1T8oHMhQcx+XDlEdUa9rhAPg4IBpiqu0r5ErThKReIYUjbntwHD+XfJ6z/eKIvooBopICZgMth344kwW8wMMX84HWWdg7jytAFNrVPGVi5IZR0WBQVlQ4lWlWyOfFto27k44nCCxGzc5D5iBtzX08vAJR3+uywZpUBmwziIze4gJyxLBK3RZg/zI4aLJvwB+SJ2BpQt7SpoRzDvB5GJLlAEVRcJgN+Mv5E/DIOePbTUyVWo9nDiJ9K8x2R8p9L5k9DP+7ZQ6eumhSyn0AEmZ45Jxxmm1bqwkhu3CaYlS0eFyeTFaK8khILhLovKJi1ulxIRGu5qoKBFpT24+nAs9zqNqxTc5xYUVFpS+HfjoDt2qQ/2aXkiv0yjXTke00QxBIr6jOok3M0/LYjLh38Uhs+d0pmD2U/A0ld2IJVa39W1EBgJIU1VTHErg2JTwodDJ0oc7/k/IyBJZH6//2wb9C60ItsPrl1s65RGGmdHyDACDzaq1NAqXj5cOIYfycKcNRXPEF4nVBGGhybvGq7eBU406MI/e6Ma5q4RFXXcO81t2ZdkjXBrkn+BCL1jffxP5Tl6Dtv/8j59QDRMV+/PEY9PzzKP344y6/ty9ggKikAEVRsInKRnmQx7OfbsJJrdOQRSX3w2FcJpTH1mnfryIqn/ztMdAucrHxwbh8U/mbGjWJUUptfBwjZubiwl9Px+m3k5wLgfeBi6yDwNWjbDNRSaSW4HYp9GNxK4rKlneAdf+Gy0gGiJC3DSGxK/OYE0gtf3PMgZXCeGznB2OzMARZjq6ZeUkutI50MskYjEbZSyURDENj4iBPh+XCAHDx9CKUPboET100UbN9UpEHT144EfcsGoHJRR7cs2gk3r95NkYNJipNVxQVtRmbhOzBpcgbPhICz+PAhnU672ofXzzzJN76/b34YSkx1zpaFBXJb0aNsQUuHD88C9NEd98fD3ae2LWFJaJiAkVRcFmU44/MdeGZSyfjfDHhOtyNQbmvoKaNENYCTzsd1Y8BCIIAtkGZrPlw53Lw1KQhesALIc6j9uG1CK6phffjA4jXK2RAXRkDALYpOci6fryspNAWZdwxDnKCththm5KTFAZJNIFTbzMNIeHReE0t7BbyeU17y8H7lXEnLjasNbBagh1e9y8AAtyLtdYMjKhC8yGiyggRFq1vvIHYgQPgmsXUgsTQT5iFb1kFoge86CwoioJj7nEw5qSuuuzLGCAq7cAl5or856c6HP+DD7+ovRInDPpN0n60w4hoTNsEjzLSiIsTVXNVBby+BoChSKa4j1zkYT+5ODPNQdx+13mYde7F5M0CC1cmGdwyC4lUx8XL5GNLBCEoEg8bI974ZhdQegJgdgNsGChfATPNwmg0yOcBAOn5hTBZbRAEAbf5r8eS2COIwpTkFNsRIkGx6sihyInqx4eKxAF+UpEHZ00qwM3zhoKiKJgMNCYXpcEqypldISp6+xotFmSLqoq/OXX+kR7YWAw7fvgWALBnzUqyTVJUTO1XHPR12E3Jg7dUyjxF7J+0pbrzg6YU+vHoECAAOHVcHqaLBCjRZr8/QWoFkefuGx4qvQW2KSyPeQDg+yJ1EYIaAqss4pqe34rG57ZoQudtHx1A9KAXAssnhdTTzx8Oc6kSkqdUzsDmUjfy7p+O9POHIxF6igoltnNgpB5gPI9BOWT8OLgzDvCKmsOK7VWMCUSFrVkPU8F2OOYWaLbTIlERxOIH3zfbEd2nbYpKMVqi0vreXpLv88oOHCsYICrtwCFW37hNbqSlKBUGgA/+/kfUerUTG8VQCLQo2xrL9oMRyzwlI6KwOFlamTiMOcPAceJnUCwcopOtzWXCBfdPw4STlFwRX1MDoqEQmirIDa+EftyANQ24VKlmoSjAJdbQS54nJpsNGYVEGUqPk0S17qz6pMlenZti0QmpjD7+pC4fG4DGVyPfbUG2U3/Al8jR+k/+p+nk3B5SERWb2E491Na16gRJ3QKAYGsL6g/sAxeTfFT6t6KSuOp0W4248QSyupSqWaRmgp2BFPpJs6X+XaSQY/9WVAhRyT/GFZVYhfZeC/5Yh/qnNiC4sSHFOwj4hHLdWKX2ONF9bWj81xY0v75T3mabmIWs68cnHUutqDB2IygdZ2YAoEypp0TaZJKJRXERIVFlDdkIWZWxOW4k458m9CPCXDxIJ5GVPBc4VvxOPChzQs6jUUtUJH8YvXJmPsIisKZGk2JwNGCAqLQDK08uBJuOdM8270eZbwXWN32Jsu0b4Ys3g+UVSZO2G2WnVACoP5hMVFqryI1qYTggvQQcS24mg1EApVI3soqcYAzKRelrrMf2775CPBKG1WpGlkWMkVrEEshBWsdRV47WTrklRsNnJPs6xcaJL141rTM/CQCgqbIc1bt3yh4pVpWKYlaRlimnnY3bX3kXi26+s9PHVkNNTEbnpy7vVJOjLV9/3qljh0W5dsntv0TukGEoHDUWRrMFDjF/J5CiC3QqhBKaMf7vzw/1eR+V7sBtNWLNfSdjgugLMiqP/O2rWsPwRTqW9CNxTrbHd6dIcAQAm6jihOKdSyzvi5D8ZY51oqLOT5EQrw2i9a3dYFtSe/AIKQzQ7NNzNc8jO8m9ahzkRPpFIzVKigRKpQqmSqwF9EM/akiqittlRb5xOwTQaHMPBSW2KpEUlcTQDwCYigcnbbOMIrYAtEMJyTDppZp9bFO147l8rjp5N63v7UXb//aj5Y3+70GkxgBRaQdmltxgnqyNSa/FgzVY27wS+/zkNU5g8UHF04hk7kLW9ePBOEwoUnU3DXnbwLjJhBXZ04roAS/WfUoSaQPCIMCRCzZOyAnNaFeR/pYmeOvr5Oct1VVoqiRqyvhZU2CiRelRYuIJrD29sFjz/LZ3d2BNJSEZRj6OK2cNxohchWwIgoC9P66Gv7kJiRAEAS/ffQuWPqh0ZlaHe4wmhf3POf9SGM2WbpfDMTSFqYPTYKAp3L1Qx35aOidV6TJj6JwrraSoWF1uXPLHJ3DBbx8heUme7ikqUhhOQqC1RXam7e/JtGpkOEywqgZ9j82ETAf5fp0pJfaK+QkMTcHVTv8b6TP6a+gnynJyOfexHvpJ7LmjRrw2tQKaqKhIkBZ8iTDlpk5aVisqtD31dZcY+rFO1FY9SkSFY03wGEhCb9TsAW23g3Y6EZdCP3EdojI4maiYhw5F0YsvALRCnpg0LVEBpU+shDifZP4W3krG7K7kr/QHDBCVdmAQc0zSaLLK/tK9Gg2ONgBAW9WKpP1ZIQb3uEEyoz/11l/Ak0sqaziWBSMy+dCGBjQ+twVWcf5uYMeC5QRwcfLnoChlcI4EA3jupquwe/UP8rbmqgqUbSEEKX3EVGDYKYDRBgzWt8VOy9e6tcYoI2I0mVxMfBxjCrQrkF0rvsOHf/kj/nPXTUnHklQUCSarDTSjDAJj5s2H1eXGyDknyA0RDwUvXj0N399zIkbmplZURh53gvxYnSS7ffkyPH/rtWgoS7Zil/KDrE4XKIqSyZRD7lfU1qXzlEI/Um8liqYRj4rdU48iojJ1cFrStgw7mTjaElyXfZE4+AT/m1YxP8Vtbb+tgKSo9NfQT704OZsNNNLb8SI6msG2ROD9qhzxutRkhPOnDlGk6n1DO41SxEQDY35qoqLOUZEqMHX3U5Fwx9wCpF+oXSAxaR4AABcGHAwJ7UfNHtAmAxinE5yB3P8GLtmLiXHpj2H22bPhOllxi6WdebJCI27RP1leUDopHuUYICrtgI5FQNmzsCh8CgCg3tiEj2euh3MuD1+sUfc9GfMXyI/tnjRMPe1sAADPsqBtWiZvFyd4irJi/WfliEco8blyg9btTS5fBkjFEACkFQwGLn0HuL8GKJ6ju296vjaBK0abEBdZupmPIqtpt1wRBAD7NxCvjLiOQ2vQq1UaEpNnR8yai5uffx1Lbv8legIui7FD6dxid2D8/EUAgJjK/v7zZ/4KX2M9vn3pOc3+B66+bQAAayFJREFUPM8hLHof2NwezWt2sXmXv7kR/pZkRSkVpNDP0GkzQVE0BJ6XVTCTtf9L/+/dNBsXTy/Cr08dnfRamjjwt4SUSae8OYipf/gat72pVSPVpcntwdbPFZUar5Kf0h8NtnoCza/vhH9ZhZyjknHFaLjmF2n2aZeoiKEfQ7bWLI9xmHRVFev41J5PiTkqKfdTKSq0LZlMG8TQMOvzw24l5x41p4EKVoF22sGJpcSZZ5wEy/jxKHjqKZT8778Y+s2ylJ8JALaJ+QitfBIAQNnSteoLT85JTwniUzTFld3qjhIMEJUUEHgedCwGY6ESH6w1NYGxm2HMsSMiVtJYnVqWrFYXAIAWQxEcGwdt1V5oNloiKjZs+bYKMWmOVVnoN1drDa9oRnsMSbFJDPeo4crSlqTFaBNiotQ4OrALG/7zJN76/X3y6wKv70kAAGGvVlJ0ZfaNviFSWbSkYqjBJ3yfiN8PQeABioLNpVWTHGkZMrF47qardI+nB18TyTdypGfALlpUS1VWZpst1dv6DaYMTsMj54zTzSuRFIOWgCLxf7ylFjGWxydbazWqikxUUlT8SLD282RaKZH2WA77xKu1vkbGHBscx2kXTYllxWpIyaK2CaoxhiLEJf3ikWA8ZqRfMhKuBYORceXodgkIlUBAOrOfrqeKm4wXvNcLh5tcoxGzB7RBgMkSBidW6DjGj0LJ22/BtfAUWEaOhDE/P+lYahiys8CHiUJDWzNgKlIIndhrFYwn+VoSVC616jAQ3cH91d8wQFRSQBBt1A2igdp+cyVWODfCbcoG7XIhLA6kY48/GXmtZMUwddHpScdhDKLRG8smSY5WSVGhnXBlWhAVBQxB5UzbVFmmeY8nR0kkM5otnSoHtji0ZIqlDIjT2nORzNuaqyqwZ01yWEtCYi7GtDPP7fDzjwSkkEs8SiZLNdlKrEQKivknVqcriVhSFCW3AgA6V6YsCAIObCTukwUjRsGRTroSN1eR31Ty0zlaIVXvtKhCP2pPnt99tF1OtJVLk9up+AEAm5jUGON4sFxq4txXIXX/znP3fzWtq2Cbw5q8MQCwTc6GIcMK2mJA2nnDwGSQSbczigrjUa4l67hMGDOtMA92Ie/e6bCNz4Lr5CJYR2WkOgwAgHaaYJ2YBdvUnKQFoxrq0A+lY9cgdUrmgkG4ssgCJGzNgmBg4HZuASeG1I0JSm1HoE0mWIaTSkzKaIGxSMlT4YLk+jcNSh7r1eExNWlJ/I4CL8D/fVVS5VR/wQBRSQFeJCqUlcTkn8p7HXGaxYysU2AeMgRBO7lILf4AJlQ04OTtZTj+0quTjiMld/Isq6OoiDcg7UTYF0NUzL/iWGVlGkxI6pQVFACOjMzUsvJ5/wEMVuDC15NDDxSFOJU8UYT9Pnzw+MP6xxMRSgj9lEyY0u7+RwpGsc2BFK5SV+1IJEaCRLbsKQaTeVdeJz+OdqJ/UFt9LQLNTTAYSQK1FE6S1BjTUaCotAepH1RrUJl0IqreIq+sLsfSdURdUszeOlJUlAmjoYtND/sCpETaHFfXTBT7O0JbGlH32E9o+3C/JvyQdrbSGds+NReeJWQibi/RVkqmVRMVy9DkHKnOgKIoZFw0EunnJXunaMBQ+o9FSESFDwbhLsyFRWgFz5jQ5iiFszAC2kGuW2M3/KQGPfs0eNFPhbKQEBNlcpImhBRgHZ1MxgRV6CfRS0aN8JZGeD89iIZ/bOpW9+XeRp8gKv/4xz9QXFwMi8WCGTNmYN26rruC9jR4MdeBEp0G/QxJCBM4O0DT8NnIzbN7mx0UAAtFg9IpQ5VCPywbRzyBVFgNpJSXou0IemMI+ci+0ZBfTgpNTF51qxQVZ3o7q4ix5wD3VwOjTtOSGfFxjE6eKGr37UZrjTbUxPNa6T2UoKgobrq9CylxNx6NIOTz4uW7b5FfSwzfSN8hMT9FwqDR42Q7/c4QFX8TyWVxZWXDaDInhQMtttStBY4GpEmhH1WOSiAhdl7dSghkq2z21r6iYjYo19W972/tkfM8kmgRSduxlkjr+5JUIwbX1MqJnrm/nJpU9mvMIeNqvD6ka38v8IKsEBjSlJCHmrQcDqjHSl1FRXKSDYZAZQ1HNks8XNrsIvESc1SMHVzfemDcbggxMt6Yh5AkXsqWLn6uCaYiFfkR7w+1QsKrFM1Em/14o5Jv2FnDvb6EXp9l3nrrLdx111347W9/iw0bNmDChAlYuHAhGhraNwM63OBDIYA2yJ0rA0wIAmuHNxyHv6kRMYEHQMPLD0bc6JSZdiLUikooodzORFtgM7AwWkR/Fc4CgAIEAUFvKwTxfzXUYQlnRibaBa1jBy22IE8M/QDAwY3rk7bFI9oVT1jV1+Kka25s//OPIEyialK+ZSPefOBuDcGr2LoZZZs3yM8lIz67J/XqzCL2LepMR+aAmHTrEP8eieG4o11RkSbjRpXyEUro8ColxXpls7f2FRX1hPH9Hv3E9b4MiZAda0QlMa+DMtFg0pNzK5h0CyirAeAEeD87mPS6EOMAceHPOE1yCxLNZH2YIX2mZpukqAQCQPZIOFgyT0VsJPeGFch3NbRjHNcezCUkN8VUOgzDVq5AwV+fAUAIGm0xwHniIFgnZsGQTuYM72dl8nt5le+MENeSP15lABdYWd3vVJVeJypPPPEEfvazn+Hqq6/G6NGj8c9//hM2mw0vvvhir56XEA7LagoPHkE6ApqzEKIiTnQU7QRFMYiaPeAc6UmlmADAMEqOSiyhps5EW+C0MXCJ8VqKogCK3AjBlhYse/GfcuXI8FlzMfX0c5BTqkiozsyu923gxAs0phP62fbdV0nbEit/JIXhhMuvxaSFp3X58w8XpNBPLBxGW12t5jU2FsV7Dz+Ip644F2G/D211pMOpOoyWCLNMVDp2upX8Zpxiz6NEReVoz1GR8jDqfYpyJSkqUohHylGRTNCynB2vjJ1iSalFJ6mxr6NZnBjSjnGiwrjMuuFpiqJkVSWwqiZp4pQnXQMNykgj964pyHtgJuh2vHd6CukXjoBjbgEsw5MXMrQY8ueDQSBnLCw2cu1H7IXANV8iLpDr2qDTdqIzoF3k+EKMgyEjA2DI8RkHuY/cC4uRcdFImEuUIgDpt1OHfhIVFbZZuTeFOA8+2Ll+S30FvToCxGIxrF+/HvPnz5e30TSN+fPnY/Xq1brviUaj8Pl8mn+HA3xjGSiTSBroMARKQGbjFHjDcSUcQBGC0eYegm+G/gIf/31T0nEYueqHRTAYx+feOFb4yQVlYqxwuh2wqZg7RZPPDLS2YPOXn8jbj7/kSpxw2TVwZ+fIqojUXLBL3wupQz9sNDlerC73BSBb1Ot1H+5NJOah6IGNRrH1my/RWkuISlpeQcp9pbYAnQr9iMRVSqJNIip97LfqaUiVLbXeiDxoBkWikusir/nEiae8mVw/xZ3oKPz+zcQXqDONLPsaJEUl41gjKoZEopL6+6edM4w8EJJdaCWiQlvJ3562GNqt6ulJ2CZlw7OkVJdgqXNUQFGwZJOQT9iQDr5gGniQczSm6NbcEWiR4EhEQxCTZRMJmuc0Jdk2vK0J/u+rtKGfBDM4tkm74ORa+1feV68SlaamJnAch5ycHM32nJwc1NXV6b7nkUcegdvtlv8NGpTczbgnwG/5EMaSEwGQsM9HlTVYFv83vOG4HA6gKMKeywcvBABU7kx2M6Xl0E8cQW8UET4Gb4TYG5toC5wZOYio2K2Ud9JYrpVDzWKegyMtHRc8+DCuevxZTQVQR9hjJ0rMevckAMDcsckuiXpIVlTIRNPX8i4kRaUj/PDGS6jauQ1A+0TF3InQz8q3X8er9/4cW5d9AaAdonKUKyo5IhmJsTxaxcEyGCMTjeSB0xiI4u2fKlEuutcWZ3T8m0iVQd5wsnFcX4YgCGgWc1Ta62d0NIJPIBztERVjtk32llI3LQSU0uQjoaB0BRqiAsDKk/GhLWbHe39WQufdDf1IVUfhrU0QeEH+PSlLAvEx0ICYQ9Py+i54Pz2IyG7t/COFf4Q4LyctG0T1nm3tnO1CX0G/01Tvu+8+eL1e+V9lZeVh+RyBN8JUOg8AkBfPQjHLggLgC8VUiooYbjApE5NQuwWoVJKBNYqKNwY29B3CQTKx0RQNV04JSkSfAJqmMOaEyQCAVe+8rjkfk01RDApHj5WbCnYWyzLn4f3cM/CThxzf4Uwd61WX7MYSiUpfVVTMXfSroKgkIzw1LCK5iAT0iYrA81jz3ptoOLgfvNhQTKoiohJKno92omIy0MgUy5GljsEBMUdFUlv2NQRwz7tb5PdkdyL04xa9IAQB8KewUz+SEAQBH2yqxrPf7UcknuzvIggCVu9vRlVrGDExQTTDcYwRlYSQAt1B1ZNEZBKJCh/WVxJ6G4yUTCuOC6awUl3YUE4SWykKYAzdJCpi6CyyuxWhDQ1y5VNixShFURoTOwCI12rHKkmVYVsjgEB6A0klzokeN30dvUpUMjMzwTAM6uvrNdvr6+uRm6uvFpjNZrhcLs2/wwGO1x9gwiGfSlFJnhw3P/EYfnzqOaCVZFYzRiVHJdASARfbAU5g5QaGzpzhmLJoMOZdOgJXPjoHM84+L8nUDQBoncTYroCljai2FoCnyHHcNiPOuucBGMxmnH7nvfJ+rqxs3PH6/5BVVAwASa6uEknra5NvWl77hkpJEASYrKmTXKXmitGQ/g0d1um+LCkpuao8oisee7rT/Yf6M6RO1/sayO8VimoVFc2+HitonYqKRJgMtOxQ2xbu/W6w26p9+PnSTfjT57sw5f++QoNfuyr9aEstLn5+Deb++VsA5Hta+2HYqrsQBAFcQhuF9hQVAEmNWiVIz6l2PE96A7KiEgpB4HkwLbVJ+xjMTLfdiNU+LpFdzSlDPwBAJWzjvNp7JLy5EQ3/2ozoXqK0GDIssIglzoFVNRB0yHZfRa8SFZPJhClTpmDZMsVemOd5LFu2DLNmzerFMwN4VrnB/puxVNneXKlUx1DJq4WV/quxLnAJ2jYR0zR11U9LTVDOa4nxZJBLzx8BxkBjzNwC2FwmMAYDJp96Ro9+lyibfEG6LAYMmTIDP3/lPQyfeZy83WQhlt9SBUtrnTbRLSIrKn0r9GOy2rD41l8kbR8zbz4W3vhz3PLiUtz15ocYOo1cV9POPK/d40lVP6lyVMK+5KZfVpE0O9IzcO1Tz+PmF96UCd/RjhklpIzyh70ksVhKptVzZn35mumdPq7kYCs1M+xN7GtUyGkwxuGllWWa119brS37XDQ295iyzxdifFLvmVQNBOXXXfpEJbSZVHpZhiR3Qu5NqKs7gytXgmtMrkjrDAlPBUoVMqKMjCpXR2fx2kEeTNtHBxA76EPbR6TXmSHTCuu4TFAWA4Q4r0mw7evo9dDPXXfdheeffx4vv/wydu7ciZtuugnBYBBXX51snnYkIREVTohjtesr8GLyaeba91C7l+SYMAINW0g/lyZeQbwfJGfaeDQGb2NYVmEkouJ0JHuhzDznIs3z2edfekjfpTmQvBp1pbBYlnJqpF49bDQqh3s4lpUTbvuiLfzouSdi1nmXyM+tLjdmn38Jxp64ABa7AxRNY/Etd2LRzXditmo/PcjlyQH9qh+9poVWlR2/JzcP1m6YPvVXzBlKiO368lbwvIBq0UK+NCuZ0Lq7YO/tFnM8WkO9T1SqWrRh0K3VWrLaFNBOtrOHtO+WerRBr5JEyolIBVqsZuFU7xU4HrFKsWnouL7RokMCZbHIZKXyZ9cjuncfHAGt9xQb676TstpvhjLScugnKUclxbb2YMggi1BDFlE5ExNs+zJ6XVe78MIL0djYiAcffBB1dXWYOHEiPv/886QE2yMNnhON2vgobBlDEQ1Uw+ovgyGmtO828ICJ8yFkSw5TxcSJTE6mFfMYJBUmzPrhMWXpOjOabTakFwySbe1nnXfxIX0XXaJi0Z8spPCF2WaH1elC2O+Dv6kRFrtDJizS630R0886H7lDhqFw1BgYLckN4UxWW6eqpdTJtKveeR3p+YUYOUfp0pzo0Aso5OZYRFE6Ia4NvghW7W+GP8LCamQwNt+FexePxKOf7ZL37QpRcYirxlCq5mtHEBL5clkM8EVY8AkltY0JRGVsQd9SAw43dIlKZvvVeFJbEfV7ubYowAMw0Ifd4K2roCgKTEaGnEwLAGN2/Adrpz8gPx83L3XuW4fHV6kxlJFWFBWd0E+q/B1TsQuxsuRqWIk0GjOtiFf6EW8Ko780eOh1RQUAbr31VpSXlyMajWLt2rWYMWNGx286zIjHRWM0IYrbChZAsLiR6JHDCAxMMf3eCdEgGbSU/AQBscAnEDgS0wxz5H2JcUUJna1i6QyaxHNR+1G4EqTEk665EY6MTJx45fXyNqfYcFDyCfE2EPXI6nIn9cjpKzAYjSidPA0mq+2QZHepPNnXWI/V776JT/72GARBQDwWxTt/+A2+ffn5pPf01d/kSEDyRQnGOFz2wloAwLhCNwwMjWuPK9Hsa+pCoqFN7KkV7APNCatEd92TR5FFVJOqT40gCJqE3wy7qVMJw0cTEvNTAKXcNhUYHaIihSQMGRZdd9heR0KTU3u8GSUTFfPNUXO6mC+ngsal10ArOSpdCP2Yh3h0txvSCS2RyGO8rmOPqL6CPkFU+iLoU08CALRaoxifNgK01YM4r1wYtHEozHx6SqISEW9aVsVD+Phu+XGRbT+A1L0uDDp2/N2FpKiML/DI2xJJ16SFp+GGZ17SVBNJnZF9jcR9sbGMlExnF5fiaIeeOhIJ+LFr5XJUbN2U1ErgWIfdxCQljt50whAAgJHp/jAjJdOGY72vqFS1EjV1QiFRStShHkltkZDl1Dc6O5ohkQ0pJGEq7rjQQU9RaftEzKnQcbTtC8j97W81z405ORrfFPMhJACriUpgeZU8P0ghMjXUybQmlQGcKV9f7TaIBnvS3yW8qRGhrf3D9XmAqKRARCAXXpSJgjI7wNg8iPJSt2MGRvvpsJeUwjRjju77o1EaYGNorArpvm6myQXCtukTldLJJOGwy2W3OmgWB1SpMgMABmd0nGMi9cIJiYmjDWVkADkWiIpe+bW3oR4Rv5aYXvnY0yidMh0Lrr/tSJ1anwRFURq32fGFbpw4UnFOdnazzLSvKCo8L6Cmjaz0JxYRx9KWUEzu7LzmQItm//5oUneo4IOETFpGpCPn7qnIunZsh++RiAoXIEQl3hgCW0/GTFNh38zxcsw9DkOXL5efMxnpmtdNtp4hKjJoCoyOOsc4lcWsulRZL9yWdsFwWb0yD1YIpP+7KghxDuHtzeCjva9apkKv56j0VUTiAkwAWCoC0AYYbGmI8uTnYowWUBQFa2Eu0godQDXJ9j/J9TesjvwM4ZgVUd4BBBvRXJ1CMaEbwAmpFZUpS86C2WbH4HETD/m7SCu/DLsJn98xF7XeCIZmdzwIJFa++JqIstKeUdrRAsZghMFs1rj1+hrrNQ0OjWYLMouKcfY9D/bGKfY5ZDnNqGghk8yYfO1q+hcLhuN3H+3A5CJPl44pKSqhXiYqjYEoYhwPhqYwKs8JhqbA8QJqvRGs2NeE+xIaJ/ZH23+ANAPsbrhFUkUYuxHGDnJTJEhKAR+II7CmFoJI/GinCc55h8fMsydgzFFIuMGTBp5TJGrDIfzt7VNyEFytLXlm3CZQOp2cGbdCVCzD0hDZScgyo+NdYx2jJHZTBhqu+UXwfV0BzhuFb1kF/N9VwTohCxkXjwQf4zoM2R1pDBCVFIjGOAA0ISqCAMqRjSgnKiqM0s9hYtEOhK2rMNy6HAWm7fA5p+Gn6lmI8nYgUIfQnnIQ4UrLlE10C6KcfgIaQHJbJixY3CPfRQr9ZDrNGJnrwsjcznnPqBNKeY6T/WOk/I2jHRa7AwEVUfE21MPf3Cw/pw1962bubQxKs2J9OUkyXjRW20fpytnFGJRuw5j8riWY2vpIMu3+RnLt57osMBsYjC1wY3NlG95cV4FnviNhXIm8AIC5H14b8bogGp7dDOfxhXCdXNSp9/ARFr6vK2CbmCXnPDBpnVeB1bb4gRXVspuqc26B7uTcl5Bx4w1oeeVVZP/qHmz/Ssn3OJSQn6nQCee8QfB/pxiZGlL8nmpCYhrsQtb148C4zUnVQMZCB2izdqq3Tc6B7+sK8IE4/N+RqqXw5kb4sqzwfVOJrBvHw1x0eDzKuoP+SfuPAGLiBMVTUSB/IuDKQ0xUVNgo+d9gomH54DKc6H4GBabtAACLmygVEcEB1O9A6OAu6P3MZppMeHwwDs4bRcs7ezQtu3sSTcHu9R2RCEnljq34+9UXoHYPqdww9zH7/MOFRA8Ub2MD/M1KTFcqPR8AwR3zh2N6STrOmVyA44dpO3tTFIWTR+UgV8dXpT3YjOReCx0hc6p9DQFNc0UJD320AwBQKIZP54rl2J9tU+wJOJXNf39UVLxflkOIcvB9Vd7xziJ831YisKIaDU9vQrSMhIjNJZ2f4CgDDadIitimMDhvFLTNAPuMzrcH6S1k33EHRm5YD3NpKTiu51o8SOXDEvS6TwNaRYUyMzCXeuQSZGUfM7Jvmpj8Xqf+2OX7ugLgBbT9d183zvzwof/dTUcI8YiYBZuWBZjsgDMPUbFkmRI7DxuZ5FWebcoSAECQywAOfIcgnwZAu1+WOQAT1UaeCEDtI+sQWl+Phmc2HY6vIueoSDbnnYUU+vE3NWpCIMeKojLu5IWa576GOjRVKoP4oNHjjvQp9WkUZ9rx9g2z8MQFE3sskVQO/RwBRaXeF8H8J5ZjxsPLNNsrW0LYVUcWET+bS/KzxokJtQeblJX0vYtHyo9Tlf/3aaiIVmI3Yz2EtzchsFzxEBEiHCgjDWNe18YH17xBmpnIWOhMUgD6OoQe7EWV2IHaMVu/ikhtppfYDNJxXAFohxGZ147VVaaoDnKoErsv9zb619VwBMFFxZCMmMwHZ56cTCt5oRi4hFr1BQ/BmZcJoBx+Lgs48B1C3ALNLhOGu3Hi3Kmg2wYDGxI+9DD1XZNCP13tO5LKfbaveqj0NIZM0ZbJV+/eiViY5GCMO+kUHHfxlb1xWscU5NDPERg4N1e2yY95XpAdRiW33WnFaZg/mpQml+p0f/7Z3FJwvIA31lbgzgXDD/v59jhUExrvj2vs76MH2uD9qhxpZw2FMccOLhhH86s7kw5hyLB2OWRDGWkYMqxgG0nlVF+t9mkPeUPdKN/W3PGOnYCadGReOxamfP1xmLYYYJuSAyHKatQVgHRXdi8p6faCgY9xxGKfopJIUG+g98+gj6I8uxHPZ7+HpgKxaseZh6DoViu5yzIRVY+iwmnApMvhFG+yIJ+OoJ+Dn88GY54q72axWsCc8jvggpePyPcgnVwPTVFJ2n6MKCo0w+Dc+36P3KFk0pFISlZRMU654XbYXMeWoVdvQFJU9jcG8PCnO+US4Z6EpB5EVBUXQVU5dHWblCCs/L2LMmxQzwEnj8wGQ1O45cShWHnvSbo9jvo6+IDKy0TlWioIAhqf24rYQR+8XxBFMVVuXUdOtKmgrlTpj0Rl4slFOO78Ybjkd4fuAaYmesYUJEVC+vnDkXHZaF1C0hFJsU3OTvka74+j+vdrUPPHtSkrU48kBohKCsyZeTJmn7MY02bOJRvsWWiMkouGYkh8mt/zDXlt8pXAdV8DtnTYXCbQDCCAwUuNLwIAnDalSR1jav8mjFX5OyW7dha+MIu4GD9N72aOSiJMlv43CHcXxROn4KLf/wnqWSktv7AXz+jYglSevL8xiOe+P4AbXl3fY8fmeAHnPrsKFz+/BpE4hxaVL4ravC0olm06VOEIs4FBgYqMOPpYl9/2EC33ofH5LYjVaPtYqSsQ1Zb2ktIBKARFckxNBJPRvbHBoHqfIbvvtefoCIyRxoSTByEt99DVZkHVL+lwdo9OO0+r+lnHafPKwPIQwiwCq2sO2zl0FgNEJQWGeIZgYfFCjMoYRTbQNBpjJFFWIipxQVQohpwov4+iKdg9WjIywf61/DguKBee88Tk8ruGpzchuretJ74CAMWV1mk2dNnbQbLTTwRFH1uXDWMwwpmu3MTOjMx29h5AT8KWUCa5vcaHt3+sTLF311Dni2B9eSvWHGjBI5/uxO/EhFkA8EWUiVpqsGhLcALNdSn3eXd9YnoDjc9uRnS/Fy2vK6EbPswS63oRgoqoqbdzohtvKkXFmNU9oqJO7rSkcFY9dqAQlcNZ+UTRFCyjiAeMfXpuUm6MBKnsuTdxbM04hwA2Hoc3Sm4mWiQqrCAOVEPna/YdNVtbmplurJYfx1XysuuUwbqfFfyRVBKQDpdh8IeQSNjd/BSA9MU5+1e/7XjHYwDubKX3lDOjbzVKO5qhl5R6z3tbeuTYAdVk/HJi5+Mnf8B/VhIn5qB4/zkSEjzVBncOc/9LnuV8im12rEpbcciriYpaaWmNQGB5XUWFthmSV+WdhH16Hiwj0pB24YiUE+axAsvwdBgLHEek8intnGFIO284PGcOSfm7s00hfSO6I4j+swzoZQSamwBQABiAItKkhfYDl7wNmLXmaZMXDsb6z8rBiX9cG90GgEx0DpW9cqoYonTBNL++E5FdhM2mXzIStvFdnyDbQmQw8ti6Z8lfOnkaJi48DfUH9sKZnoniSVO6dZz+DldWNiAuQJ2ZA4rKkcLwHCcMNAU2oarCF4kfcmWNP6KvCkj4/Uc7cNXsYllRsZu0w6W6l09/UlQkCHEewR/rYJuag1i1NgykJiJqQgMBaHl3D8KblDL9rJsmAJwAQ5a126EK2mpA5tUdO9keC6CMNHJum3REPotxmmCfSuYmddKs1AySD8YhxHnEKnwwl3qOyDnpof/dXb0EXxO5MWnaDoqi4KAbMdn+PlDy56R9GQON4y8ajm9fI74jNroVZw9qxF5fJiZf8VyHnyUNDBJJAYCWN3Z1i6iERf+JxD4sXcHJ19zY7fceLfDkKCqZa0BROWKwmhiMyHVie422wu6LbXWobA3j8pmDNcpGV+DvhFK5o9YnKyr2dhSV/kJUEstoW9/bS7r0JjQUlJrhAQDn0yZTqkmKfWaexpJ9AP0X6sTd3F9OBXig6dUdiO5pRduHB5D980m91r+qf9xdfQCS0RdNE/XkjPTfwUIHAKN+TFbdpMrGeFHqiKH05peB9NSdNY25dsTrgmCbw7qvd8faOCo6PfZHA6q+hDHz5qOpshxWpxM5pUM7fsMAegzHD89KIiq/fJeEf3bX+fCvy6fqva1DqBNmU2FPvV8ujbYn5KioVcq0biqWRxKtH+xDaH1D0vbgT/VypQ1lYiDEOI2iwramrvpQVwcNoH/DNikbnD8Gc7ELFEMDDClzrn9qA+J1QcQq/L1GSgdmr05C6nMj0KRE0UBFAVtGyv2dqjI9w5XvAKf+BSg9od3PyLyGSJ9cW1QTI5bAh7qeqyIrKn2sd0N/gyszC6ffeS/mX3fLMZdM3Nu4a8FwXDlLP5/r+z1N3T5uQOceYxL63OxrCCihnwRFpUTlpXLSyNSlnn0FwdW1ukZe8dqAPN5Ikn9oYwOEOIe2Tw8guqc16T3mUjIOpjIjG0D/A0VTcM0bBHOxUoZvzLbBNoEoyKH19aneetgxoKh0Ei3VxIGRoknnVCMVA4pSE4/cUjfmnDcU7mwbUJoJlM7r8DNopxGUkSYxQR07fT4YBzxdk7kjIlGx9MPeIwMYAAAYGRq/P3Ms7GaD3FdHQjjOYUNFKyaLHY27gkA0OUflrIkFeG+D4rb6zHf7YRDJS2Iy7ewhGXjozDGYOjg9icT0NbRnecAHWfBiqIfxmME2EN8Y37eVCIlhHspiAG03gGsm7QUyLhsFzheDIaf/lRIPoGtwzM6HaZBTJiy9gb59d/UiDm5uROWOFuQOceDAT29j10rS1psykFwFJncYcOpj7R5j4vzONfaSQFEUDBkWxOtCiJUTqVtqMsXWh5LiyJ1BRAz9mI/BtvMDOLpwz6KRmD86B+c8s0qz/ZxnVqHs0SVdPp5e6OfB00fjoumDYGRonPWPlRAEyD5EiWSEoihcMau4y5/bGxBi7VdtcG2EgNA25Tv6v1HKwDOvGYOWpbvl55TFAKOt/1U6DaDrMBU6YSp0drzjYcSAhp0CdQd82Lq8Gpu//ATbl5PeHxRFgTbkQoAA7mdfAa6elz2ZdJLzEtnXBoC0QafFAaG90E+U1bcYj7CHnkw7gAH0FeS79XPC9tZ3vaGnHlFxW42YVpyOiYM8WDRGWx7qMPXfdV0q3xMJbAPJNbGKvhqJMBU4Nb2AKLp3kioHcGxigKikgMFEfpqgV+mOanG6QVEmxAFE44enMY9luAcAECsTFRWXCYy4ykmlqLy8qgxjf/sFVu5LjteHxZj0QDLtAI4GpKrwefzLPV0+VkfJtHNUHaDdVmNSMm1/AheIdbwTAEO6FXm/TraBpxjqsPUiG8AAOsLA7JUCBjH5lI0pLd+NFhKPjVNKkuqhQkpGk1xq7VNzNV0xDdk20HZRUUmxKvrth9sR5wTc/ubGpNckpaWrrrQDGEBfRGKyq4S9DV1XVLxhMnkfN5QQkvmjcjSvD8tWyjV/f8YYGJj+O1x2pKhIoMwMGKd+BVNPtvYYwAC6gv6rZR5mtNVsRzy0CpFWxQXTaLIgFgdYCHIlwKHCvaQUtsnZcg07ZaBhn54L31fEKdOYbZPLlSX76lSIJrgHVjSH8OY6EmceCP0M4GjERdMGYemPlWjwd71xWpOoMlw2czB+vWSUpooHAKYOTsO5kwsxNNuBsyYV9Mj59hbUDQfbQ7uGbQNEZQC9hP67RDjMaKvfDy6aqFCQnytOAff/dytq2sKo80bwwaZq3PLGBoRiXScvFEPBVOjUxHzt05XYuDHHJnscsC2RpPerEUsgKrctVc5/IPQzgKMFT18yCdOL07H6vpNw/xLSi8sfYeUwZ2fREiREJdNhwqg8V5LqaGBoPH7BBNw0b0jPnHgvQs/uQA+UhfwGaecOk7dl/myceJAeP60BDKBTGFBUUsDqcidtk9YTLAVsqmjDKX/9HhYjLa/Mxua7e2RQY5wmpF80AmxLBMYCh5yxzzZ3QFQ4ZSR5d30VNle2yc8Hqn4GcLTgtPH5OG08CZkKggCLkUYkzqPBH8HgjM53r20WuyVnOLrnbNufIJUfW8dlwjYxG82v7kjaxzjIKRtK2qbmwDIyHbTDqLiRDigqA+glDCyzU8CmR1TErPc4BMQ4HoEoK5MUAKhqDekei+cF2c+k058/MRuuk4pIyXImUVS4lkinV0a//u9WzfOB0M8AjkZQFIUcsYtxV8I/kTiHoKjApNv7vqvsoULqhmzIsMA6JgOUKXnoTz9/uPyYoigwTpPGMp1JtyS9ZwADOBIYICopYHN7krZJCwo2RWVeYuhFwnWv/IRZjyyDtxs+KABAO02gHSSh1vdleQd7E+R7tGWcxn6cCDiAAbQHiajUtHXezr1ZDPsYGQquftKn51AgKSqU6AUjhXbU5INxtO+Lkn7RSJiHpyHrhvGH6SwHMAB9DMxeKWBP03G6FJlKPAVRqWpVBspAlIUgCBAEAd/sakBrKI5lu7pnQUxRFJzzSFVQYFUN4o2KchPZ24q7YEHiWmdwhtYxMthDyb8DGEBfQ7F4rR9sCnb6PXVecq+m20291mjtSEJSVGgxB8U2IRt590+H62TFlJKytk/YjJlWZF0zFuaSZLV5AAM4nBggKing0CEqgkAGtEGZNpgMNN6+YZbm9b0NAQiCgLKmIKb831f4+dJN2FLlVb2/++djGaGcT/2TGyCIoaSmF7bhHJhwJoh87RNb1yeGmkyGgT/1AI5OlGaRirn9jZ0nKst2kt5dkwZ13Xq/P4KPkvFAXdXDuMwwF4tN5gz0MUHYBtA/cfRrnt2E3eNJ2paWPwZ1ZcCUoRn48ZzpcFuNeP/m2fhiWx3+9f0BNAWiqG4L46sd9YiyPD7cXIMPN9fI728Ldy/0A0Cu/AEAcALq/7YR2bdOlDelgwwyy3c34vQJ+QiKA9PisbmwGhksGqt12RzAAI4WlIplxQcaA53aPxBl8fZPpGz/1PF5h+28+hKk3DapqkeCIcOKnDsny15NAxhAX8QAUUkBk8UIxjwRXGwHpp9xBjIGDUZTdR7qympgsRngtpIbe3JRGiYXpWHV/mZsrfZiU2VbygZlDf72q3baA8XQoF0m8D4SW2cbw2h9W3HjDIk1SevLW0WiQgamq+eUYHqJvi32AAZwNKAgjeRj1fs6d3/987v9aArEUJJpT7LJP1ohiDkqtM7YZMzpfKXUAAbQGxiIB6SAwUTDaDsJFs+tmH3hFRg990Swom2+USf5bnQekVD3NwThTaGcLF1XeUjujtkJSWzh7c3yY6eoqEgExS+3ph+o9hnA0Q2pq3Gokz4qS38kaso9C0ccMyHRVIrKAAbQH3Bs3KXdgEFVvseJPiaxMBkITTpEpUhM6KtoCaUkKt5wHD+Vt3b/nDKsyL51IhwnFIJKICASUWkOxvBjWQsaxVLNxNb0AxjA0QabSSEq/kj74dVglEWT6J+i7uVztEOq+mnXeXYAA+ijGCAqKcAYaIhzP9g4ISpxcVVisiavSorSCVGp1CEqF0wtlB9XNOt7rXQWpkInPItLYMzXyrVu8WS/2dWA8/+5Wt4+QFQGcLRDrRpO/cPXiHOpLVSrxRJmt9UIl+XYyMsQWB4QrRPoAUVlAP0QvUpUiouLQVGU5t+jjz7am6ckg6IomMQBMCr6n8QkoqIz+UtEpbwlCJ9IVH57+miUPboEfz5vAk4Tk/ZSqS1dheRWK8EF/Yz9VPkyAxjA0QKLQZl8oyyPHTW+lPtKpoyFadaU+xxtkCp+AIAaUFQG0A/R64rKQw89hNraWvnfbbfd1tunJMOZQQYzbyNZhcVE+dSoo6iUZNlBUUC9L4r9YvWBlHALAC7x8V++3I1X13TOtK3dczuBqDSxNGL/nYqomI+RGPwAjl3QCR2V1x1sSblvZQu5l48loiJ5qFAmWtNTbAAD6C/o9VnM6XQiNzdX/me3950MdHcWGcx8TSJRCYuKis6qxGUxYmQuSajdVUdazquJivQ4FOPwwP+2gW1HngaAcIzDo5/t0vTrUcM6LhM5d05G9fGkaiEHNHJA4TnYsRxO3FeYiRtPGDLgjTCAYw576v0pX5NyxEbkOI/U6RxxtL6/Fy3v7pET92VX2gE1ZQD9FL1OVB599FFkZGRg0qRJeOyxx8Cy7TuoRqNR+Hw+zb/DBZdIVLwNYXBxHoFWkoRnShHnnTLYo3nusakUlYR4eDDafoXCX7/eg38u348z/7FS93WKomDMscNvMyACAVZQ+AtsGA0GDCgsqYrh3sUj2/2MAQzgaISULJsInhewYm8jAGDu8KwjeUpHDHyYRXBdHUI/1ctWBtF9hJwN5KcMoL+iV4nK7bffjqVLl+Lbb7/FDTfcgIcffhj33HNPu+955JFH4Ha75X+DBg06bOeXlkPyTvZvbMTqD/bL2/UUFQDIdlpSPncl2FMHYqkJ2cp9TXju+wOdOscoz+OA2H+9BNqBiFM1TBzAAI4VfLu7ET+VJYd/moMxtIbioChgQqHnyJ/YEYA6H6X2kXXgvFF4PysDAFCmAaIygP6JHicq9957b1KCbOK/Xbt2AQDuuusuzJs3D+PHj8eNN96Ixx9/HH//+98RjabugnrffffB6/XK/yorK3v6K8gYOjUbZrsBwbYoNn+tfI7Npd9tNbG5WbbLrHotUVFJTVQue2Ftp88xEuexH/rqTJuKXA1gAMcSzlNVvkmQDOEyHeaj1j9FSOiuHtraJD/mQwP9vgbQP9HjQctf/OIXuOqqq9rdp7S0VHf7jBkzwLIsysrKMGLECN19zGYzzGaz7ms9DZPFgMxCB6p3t8nbLv/DrJQJaU4VGUmzGWFWVSPYElYzN762Hg+fPQ4zSzM02+99b0uXegJF4xz2pSAq4W1NEDgekV0tMBY4YPAMtGkfwLELyRk6x3Vkxo/eAJ8YUuaVwYT3DyisA+if6HGikpWVhays7sV/N23aBJqmkZ2d3cNn1X1YVD0wzHYDnBmpJ3uXKnlWaj0vIc+trTI40BjERc+tQdmjS1TbArJrZmcRZXnsR4rEXAEIrKiB97ODoJ1G5P96ZpeOPYABHC2IshzWHSS5GjnOo5ewJyoqnE8hJ0K8/QT+AQygr6LX9M/Vq1fjySefxObNm3HgwAG8/vrruPPOO3HZZZchTadzcW/B4lDCPI40S7tVNE5V6CeRqIzOd+Gfl01p14CtJai/4nniqz262wFCVPamUFQAwP9DFQCA98cPyb5/AAPoy5hc5EnaFlLlgT34v+3453ISCs12Hb1EJVFR4XxKGN154uHL5xvAAA4neo2omM1mLF26FCeccALGjBmDP/7xj7jzzjvx3HPP9dYp6cJiV4iFw9O+ZKzOQ8n3JPs0LBqbiymDtSQsyioDS0DMWynOsGHHQwvl7X9btjflZ0ZZDkEA701w4WIE8Dli4GkKxgIHAIAPKAZzXGvq3J8BDKA/44Urp+HvF0/Cp7fPlbc1qCbpt35SlMqCozgEKjUflMB5xcUPQ8E1f3AvnNEABnDo6LXC+smTJ2PNmjW99fGdhlWlqNjT2icqakWlJNOmu4+R0XLDypYwhmYTUiE1Vct2WuT+JakgCAIEAYiKcm7IY0IlePwBEQy/dAwmVIQRr9a2vY9VB8A4TaCMR2ci4QCOXaTZTTh9Qj4AoCTTjoNNQVS2hlCcaUeM5cHQFDhewKnjcnHR9KJePtvDBz4x9OMlZM08xAOKGfBUGkD/xIADUAfokqKiylEp8OgTlVpvWPO8pk0hKoF2Oh4LgiCHnQRBwAX/Wv3/7d15eFvllT/w71202vIir3FiZ99jEichIQllGTIkLYVS2rCHddItHQjQDPDrJEyhEKAtU2AyUDqFwBQKTFtoWVpIKaS0EAIxJoTsu7PYjlfZkrXde39/XN0rXe2yJF9JPp/n8fNEsmS/im3p6LznPQdun4jGMaUAABPP4ZZ/moSDp51YMr0Gbld7xNfofn43AKByVSNM40vh7xoEX2mhpnCkoMxtKMfhTif+0HISX5pchdYeFwRRgtXIYePVcwv69z1i6ycQqLA0RZ3kMQpUErCEHEWOV0gLaAcA1pZGv234UEJHyLRXVyBQsUapY3F6BfXr97h8+PiIXBio9Gcx8SxWnz9JvT0fZ62dv/wcpinl8OzrQfk3p6Bofk3cx0VIPrm0qQ6/az6OjwO9VJS/ubEVRQUdpAAhxbQsABFAoCyNeqiQfEZ7AAmMmVqOxvPGYO6yBkycG/80EscyWPWl8bhkdh2a6sui3uaGJeM0lx2DwVStM7D1UxzY9rlmYTBFPRB4ApIkCf/6m2b1+q5AU7fwmT58ZfxZJp59cqDT92ZyjeUIyRdKIbsyHFR5M1BmKfxpyYJTfqy8Xfv3zxjpqZ7kL8qoJMByLM65ckrSt//hRTPifv77/zQJ88fZ8fLHrXjj81OaacpONaMiv/v58aWz8PvmExj0CTh4egBun4DeQR/+caBLvc/pfjm1azZo3zGxNiNYmwFif/xpzdQEihQapai9x+VDj9Or1n6NhEni/g45e2Sst8HfGdxmpq0fks8ozB5mJp7DuVOq1K61yru9ltZe/O+H8lTlokBGhWEYVNrkradr/ucjfOWx99ETdoS5yxk9o8IwDGpunYuKa6ej/LLJ2XtAhOSY0KL2pvs2q28AotV+FRJJlODrkIMT41jt0EXa+iH5jAIVnSjv+j461IXfbj+OSzf+A/3qE2rwidZmCqarXV45sxKNyRD5RMQVG2GZVQm2OPg1zFNzp0cNIdkQ3gX6aKBGpdAzKv5uN+AXAZ6BYVSx5nNMgQdppLAV9l9uDlNOCDUf60XzsV7N50Lf+RWHzQ9q7dYW46r3ifOOyTylHMZxJTCOsUGMMqhQ9Apg6R0XKRDhBbOfn+gDgLjNFguBZ79cd2YcYwNr1T5W1lr49TmkcFFGRSelcQr7PCGtrsMHHbb2DIbfHEDsU0YAwPAsqr8zG2VfnQAmyuTn0KZwhBSanYFAJTzTUmjc+3sBAOZpdrBh09rDLxOSTyhQ0Ul4AMIywLlTqmA2sLhgevB00eiwDrexMiq1SbYFj1ZUJ9CwMlLA/IHBfIWeUfG3OwHIhbRs+POLtbAfOyls9NurkzHlwYZwZ02w44V/OQsMAwiiBD6ke+0ZY8oAHFUvHw9kVIw8C68/mHmxFwX7vcQTLaNy+onPYL9mOqyNlSk+CkLyR6Juz/lMEkT4e+Tp0IYqCxieBXhWrlkBwNHWD8ljlFHRyYy6Elw+fwwAYO2yqWBZBgzDaIIUAJgTNmxt0Ccftbx+kXZuR7KNrFhz9PS30rWWkEIwO9CxOVQhn/px7+8FRLlfChs4KciG9E6hjArJZxSo6Oihb5yBHf9xIeaNtce8zcSqYjx65RzMrCvRXF9mNeLer80EAEypKY5216iiZVQUkiSh/x8n4HivNeZtCMkHm25cgCevnQeeDQbwRQWaUZFECd0v7gUA8FXW4KgNMTgtPd7fPSG5jn57dcQwjGbicixfmzMabp+AO3/3uXqdzcxj5VljUW0zYdboyHePsfBxBisOvH8CfW8eBgBY51SBL+Aps6SwlRcZsXxWLerKLDjWXdjHkz0HetXW+aVfGa9ez3CM0kEfDFvYowNIYaOMSp646Iw6zeWqYhMYhsHyWaM09S6J8FXB25oml6Hqu7PVy47NwVoY6lhLCkG1LRiYV9niDxXNV742uYjWMrsK5oll6vX2K6YBHAPT5LLodyQkT1CgkieKTTweuTwYVJw3Nf7coVi4omAGhzXzMI0tQeVNswAAUsixaMlNgQrJf6GlWw325AP6fCIG5oWF16GYp5Rj1F0LUHn9TD2WRUjGFGYutEBdPLsOe9v6sWhiBSxp9IQwTSqD50AvihfLWRrTxDL5fHTInrYy3IyQfOb0COq/jXxhvC8Lb9AoBt5UROuVwtmSOw1ISC6jQCWPGDgWd39letpfp+La6RD6PDDUFAGQ97K5MhOEbrd6G9FJGRWS/+rtFuw65RjSfSVRQt/rh8CWGGE7e7R85Fdng190out/d8M8zY7yb0wGZzNCUjIqVDBLChT9Zo9ArJmPeFLj7eawQIUyKiT/rb94JnyChJuWjE984zC+kwMY+OAkAMC9uxtV3z5D16LUwV1d6PpfuY2Ae083et84hIorp0F0y1kj6j5LCpX+bxFITig6s0ZzmQIVUghGl1nw9A1n4uzJqTczDO3Y7D3qwODOzoT38bU7MfDhSc3R4EzwHHOg67ldmusGW04DCNao0BFkUqjoN5sAACyzqgDsVS8LLgpUyMgWPgOr99UDME8qizvgr2PjZ5C8AiS/BNuXRmdmHW4/Tv/3ZxHXK1PR1RqVGM0cCcl3lFEhAOQ6lVC+U04M7urK+DtDQnKVMOCFq6UDgsOjXgYA84wKAPKRfe9JZ9yvIXnlbRhXS0fG1tX/t+NRrxedPkiCpJ7Qo60fUqgoUCFR+dtd6HpuFwY/P633UggZFn2vH0L3i3vR/mgzfB0uuJrlYMNQZYF5ajkAwN8tz9oS+r3wd7shunxw7++BJGkDet+JAYgZykoKjihDQ1kAEiA6vRAHAzUqtPVDChT9ZpO43Pt7YZ09tJ4thOQT74kBAPKJt/ZHtqvXs8VGcHY5GOj9/QFYZlSg/efNmjou08RSVKycofl6zo/bYTt3TNrrighUOAZckQGCwwt/r0fN4jCUUSEFijIqJC56l0ZGAkmSomcuAHAlBs04id7XDkUUm3sO9qFz0xdAyBaq79RARtbm73BpLjMcq9an+LuCJ/WoRoUUKgpUiMrSGHkygp78yEggDfohhTSHU5in22GeaodlZoV63eBn0bdDvUccgBDcAvK1u6LeLhWixw+h16O5zthgAxOYBC30yZ9jDCwYjp7OSWGi32yiKl8xBRU3hrXbpmFmZATw93giritZPg6V188Ea+bBV1pQc8e8iNuwJbE7v/o6XDGzNEmvq0OuiWFtBlR9bzYss6tQ/s0pamdaNVChbR9SwChQISrWyMEy1a65LnT+DyGFSuhxR1zHlWqHGEacquEYVH9nNiLwDIwNNkCQMPDBibTW5Qts+xiqrTA1lKDiqmngy0xqRsX54Sl5bbRFSwoYBSokQuioeKVQj5BC5g9sr3D2YC0KF5YtCQ8GWBMH3m5GzQ/mwziuRHN90YJRAADP0aG171cogQpfrR2oyBi0W7J0NJkUMgpUSATbOWPUPXnKqJCRQMmomEICDq5Y29gtfNaP6JL7lxgqLXIGRbmdiYexvhiAfEw5nV5E/kCdi6FGG6iwJm2gwpiolowULgpUSFTKO0TKqJCRQKlRMdbbYKi1gis3ga+wxL1P6VcnqP/mQ7aJWCMHvsoKxsBC8opRt5WSFbr1E4oJm56eqZ4thOQiyheSqJTUskgZFTICKMEEV25G9b82AVJkBiVc8ZI69d+hRbWMiQPDMmCLDBB6PRCcvoRBTzSiV1DXFbH1Y9KuLfwIMyGFJGsZlfvvvx+LFy+G1WpFWVlZ1NscO3YMF110EaxWK6qrq7F27Vr4/f5sLYmkgDHIvxq09UNGAmWwH2vlwXBswiCFrzCDYYIn4jhbMFBRalvYosAsHtfQntP8pwcBCWCLeHDF2nqZ8BqV4kV1IKRQZS1Q8Xq9WLFiBb773e9G/bwgCLjooovg9XrxwQcf4Nlnn8WmTZuwfv36bC2JpIAxBgIVrwD3wV44m9t1XhEh2SO6U2tDz1dpMxxcSXDrR8mesFb5a/W+egDufT0prylWIW04+1XTULK0IeWvT0i+yFqg8qMf/Qi33XYbGhsbo37+7bffxq5du/DrX/8ac+bMwZe//GXcd9992LhxI7ze9HoPkPQp79gkn4jOX36Onpf3wdcWfyAbIflIkiRInuQmEFf+yyyYZ1Sg7OuTNNeHZlSUrrHKSRyh14POp3emvC5/4O8tvD5F/qLBAl3LGZURGRZCColuxbQffvghGhsbUVNTo163bNkyOBwOfPHFFzHv5/F44HA4NB8k89Stn5Bunf7eyKZYhOQ7ySsCgdd9JkFGxTypHJXXzdAUzwLBvxcgZOvHqj01lOrpH/fBXgCAcYwt4nOSGNySDd2CIqQQ6RaotLW1aYIUAOrltra2mPfbsGEDSktL1Y/6+vqsrnOkUjpf+jsHdV4JIdkluQM1JKw24EhV6VfGw3JGpXq0X9n6UQiO5AN9wemD77g8K8g8zR7x+ahZFkIKVEp/lXfddRcYhon7sWfPnmytFQBw9913o6+vT/1obW3N6vcbqZhoKXB//hXW+jpc6Pr1rhG5beXvGoTnUK/ey8h5YiBQYUx8WtkJ2zljUHH1dHXmjuTWHu0XupM/pqy03meLDZptJYV5RgXKLpmI6tVzhrxeQvJFSseT77jjDtxwww1xbzNhwoS4n1fU1tZi27Ztmuva29vVz8ViMplgMplifp5kRrROl2KUoW25ruu5XfB3DsJz2IG6dWfpvZxh1faTTwAA1f/aBOPoYp1Xk7uU3+tMD+C0NlVj4IOT6mXHX46hYmVxUl1klf5FsRq5MQyD4sV00oeMDCkFKlVVVaiqqsrIN160aBHuv/9+dHR0oLq6GgCwefNmlJSUYMaMGRn5HmToWIsh4jo1RZ4HBj46hd4/HlSLDkWnD4O7umCaUDri5qJ4DvZSoBKHlOKJn2QZ622o+49F8Lb2o+u5XfAc6sPAP06gZOnYxGtSgicjFckSkrUalWPHjqGlpQXHjh2DIAhoaWlBS0sLBgbkfdcLL7wQM2bMwMqVK/HZZ5/hrbfewr//+79j9erVlDHJAQwXmQLv/9txnPzxVvjac38bpfeVA5qTEYCcXel8dpdOKxpeUshjH85MmOgR4PrsNERP/gS1wa2fzAcFrJmHeXI5Si4cBwDwnUrub0f5mVFrfEKyGKisX78eTU1NuOeeezAwMICmpiY0NTXhk0/kdDTHcXj99dfBcRwWLVqEa6+9Ftdddx3uvffebC2JpEno80Ic8GHgHycT3zhHeQ/3QRgo7OPvolfA4I7T6uXhzIT1vnYQ3b/Zg57/2zds3zNd2cqohDJUy71VfEkWp6tbP5RRISR7LfQ3bdqETZs2xb3N2LFj8eabb2ZrCSRLuLLcznhJkgSwDBDjOGjHxhaMunPBMK8qu/y9HvS/14qieTXof/84Bnd0qp8T+ocvMHN9IteZDe7sGrbvmS4lo5LpGpVQfKUcqPi7BiGJEhg2ftGuEqiEDx8kZCQaWZv1ZESQ3ELMIAUAhB4PJJ+Y1lHUXCIJEtp/9gkknzwAz71X2wVVGbg3HBgLD2kwf7Z9gJCtnyxmVLhyMxijPKTQc7gP5ollMW87uLMTvX84KK+JMiqEUKBCYmPMXMQRSwCQcvyYsuiMPknWftU09PxuHySvCH+vG4YqK/xdg3A2d8C2pC6iQVcu6/vTYfT//UREHU54kAIAvtZ+uA/0wDypPOvr4ooN8OdZoCJl6dRPKIZlYJ1bA+fWU3Btb48ZqEiShK5f71YvU0aFEB0bvpHcV/29OSg+ezRqfzAfljlVMNQWAdAWauYiIUqgUrt2Pqyzq8CVm+XbBLIM7Y9/iv53jsHxzrFhXWO6+rccjwhS4un8n53ylliWKYP4gOCgv1ynzPnJZkYFAMxT5EAxXkGtc5u22SVlVAihQIXEYai2ouyrE8BXWlBx5bRgh8wcn6gsBoplDWOKUbJ8HMq+PkkdFMcHApXOp3di4KNTasbIe2IArh2n0f3iHoje3O4Xk2ordkXv7w9oghVfhwve4/2ZWlYEoS8/Ri4oxcbZzl4YauRusr7Trpg/w95XDmguMyZ6iiaEtn5I0hheLgCUhNwMVJzN7eDtZgxsPQUAMNQUoeQ87YgF3m5W/x36ouA94kD3EXlulHFsCYoX5V4zLcHhBVvEQxpioOj8uA3Oj9sw+r7FAM/i9FM7IA74YJ1bjeKzR8NYl36vFSkkyBMcXjULl8uCDd+y+3TIlZvBGFhIPhH+zsGINvjRtlQpo0IIZVRIKvhAa3B/7m39eE8OoOflfTj95A54DvQCAGznR86BMk1NXKcheXMvEBvc041TD25Dz2/3a/qiFC0IdnEuWdoQcb+ySyfBNKlMc533lBOiyw9xQN4iczV3qMWb6Qr9v1PawA835/Z2dD63K+ppp+6X96L7pb2azFKwmDa7QQHDMjA2yAMGXdvbIz4frd8N1agQQoEKSYE6wyQHi2mFnpA5KhLAlhhhCBwJDWWeWJawiVa2X7CGomvTF4AowfVpR3Crwsqj+Jwx6m2KFo6CpbFScz9jvQ3ll02GdW61ep3Q7Ubfnw5rbufvyszwSU1GpV+frZ+e3+6De1cXTv9ih+Z6wemDq7kDrk87NAXXah8VU/YTzNa58uDV/i3H4T3eD3/XIE49/DG6fr0Lnf/zecTtw4NMQkYi2vohSWMMgd4PORiohBduxmoZz/AsRt15Jk7euzXm1xrq1kq2hBfBhhZ/8hVmFJ01CqyZB2czonzFFNjOq4erpQOST4ShrggMw8B++VSAYeDa3o7uF/eqX0s52SUO+CD5RTB8eu9dxLCtH10E/rv8nYPwHu+HcYycxQj9HZE8AhD4FRmujAoQmP/z/gn42pxw7+2B77QLQrcbgyEDCxkDC2ODDeZpFeDLzHG+GiEjAwUqJGm5nFHxBOpLFJYzYs+kYq0G2K+ehu4Xok/6lnJs+KKmLwkbcpzWxIFhGJRfOin4aSMH4+jiqIEaXx7ZqI9hGUgcAwgSBIdXU8MzpLWGbP2IOgUqrM0IMbDt420NCVRCsihKsCeJkhrAJDMsMF0My8A6rxp9bxyG7+QAom2isiVGVK06I+trISRf0NYPSZrybtt7cgBtP/0Erk87dF6RzNfmVDuiAkDRwlpYZ8cfnmmNE8jk2qkfTWZCBESX/IKbagaAr7JGXCe6/OBKTYHvk95WjeQXNY329DqeHJoRC92K0gYq8tqEHrd8zJtn1P+HbDMEipa9JweiZrBoECEhWpRRIckLPKmK/T6I/T50v7QX1qbqBHfKPs+RPvXfJUsbkppOCwCVN86Ea0cnWCsPrtgA0Sui/51jOZdR8fdqAwhfhwtA6qdUzJPLIq+bUQHR5YPQ7Ya/xwPTuKGuUhsUAHoGKiHBSWiGxxValyKvTfm/NFRaE7a1zxTlmLLQ4wHqopz0oQJaQjQoUCFJU44n55yQ/Hl4MWk85ql2mKfa1cv9W47LXy7HApXwfiT9f20FkPqJENZqgHVuNVwtHSi/bDKEAR+K5teg/6+t8B5xwHvMgaI0Ak/RrX+gIomSphGeJmhxBtcjDsrX+zvkImK+OrLwOlu4YiNYKw/R5Ye3NbKPTXjAR8hIR4EKSVq6hZbZorwgWpuqYagZet8O5Z1srm39+APv+sOxNmPKX6v8m1NQftlkzc/SOK4E+OAkvGF1PqkK3zrSJVAJK4TWHJd2abd+PEcd6umn8J4m2cZXW+E94ohacCz0FfZ0b0JSlZuvPCQnKcW0CtaaG3GuWgxpS29WjxKo5FpGxdcePVCJdbIpHoZlIgJO07hS+fu0OdXajaFQMj984EVf8ghD7qKbKtfnnWh75BN4j2mDLSU7IQmSprhXcvtx+qng8WV+mAMVZftHUbw42GAw1qwqQkYqClRI0sKnDYsuP1wtw1dQK4kS/F2Dkcd1M3RqQylizLXUe8xAJXCaJV1ciRFchRmQAPe+yKGGiUiSBF+bE/7T8jaKoTb4IjxcWZXu53fD3zGInrAW9ILDi/bHmnHqga2abRZx0K/ZIhrujIoSHCqKFtbCPLMCAHKi7ouQXJIbb4lJfuAia1S6X9wL65zheWId/Ow0ul/aC77SgqpVjeopDeX4brot0JW5KuG1FnqSfIJ61LZk2Ti4mtvBGDnwFWY5uMgQ88QyOLva0Penw7DMqkypsNS9uxtdz+1SL/PlZjBGDpJXkH82RcM4lTrs6LzSpRjQ1qh4TwxobqfMghouxgnaQIW1GmBfMQWDM7tgmVExrGshJNdRoEKSFqtGpev53Sj9ynh14F+29L11BIDcyKv3jUOouHo6gMxlVLhiueZDGWqYC4T+wDYAz8J23hiURBkLkAklFzTAua0NQo8Hosun/l8kwxnWDp4rM4G18BC8AgSXDzyyGwSETstmbcakGs2F1uNU3DgzIluYbVyJ9v+XtfJgOBZFgc61hJAg2vohyZOi1xsMft6Jzk1fZKUeIXSbxzAqWCg7uKMTgHzk1HtcfnfMpBuoBDI0osufMwW1yrwazmYAw2Tv1BVXagoWE6eYUeKs2owJV2oCXykHrb6wzEWmiS4f2h7+WL2cqBkhW8Rrfo8ss6tgCTn5NVzCf5bh9V+EkCD66yBJ4yst4GusMEcZ7Odvd2W8HsFzpA+n7tsK5ydtmh4YgPyOVJIktD/+qVpTkkoWIBrGzKnTanVr/x5GVAOV9B5bMthAAzkpxYLa8KJqrtQE08QyANqtl2zof/+Epvg5USEqY+Y12Qz7FVOztjZCSGZQoEKSxnAsatbMReWNs9Tr7FdPU9PmmT4t0/Pb/RBdfvT8dj9O/vgjuHd3q58TXD6I/V65aRbk+g1D3dCPJgPyu1yuVH4RE3r1GagXTsmoDOUocqqYQI1Pqid/mLBOqlypEabxcg2G97hcwCq6fOjc9AVcO05nYKVB4ROS1UAlRvKJNXIoWTYO4BgUL6kbtiZvhJChoxoVkhIlZV25qhHe1n5YGivR+8eDkHxi1DH16dBkaMK3lfwSvCedAOSaiEzVbnBlJvhPD0Y0WdOLMKwZlUCgMpjazzF8u4UtMsAQqGcS+rwQnD443joC955uuPd0xx1fkLLwrZ7ArwlrNUTNrjAmDsa6Yoz+j0WA3tstDBB12A8hRIMyKmRIzBPLUHJePRiGCek/kuGjqFFOGYVSembwGTz9wgZOqIgufdq/h1O2oHJ56yc0UOGrLWAYRp7mHPi5DO7sjHnEOl3+nugBJRejp47SzZcxcLpnU4bjZ0pIIaBAhaRN7T+SoYyKe283/H0eQIhRGBl4gVFObvD2zJ0qYYe4/ZEtw1mjEtz6GVpGhTGyKL9ssnq9sv3Tv+V4RI3RUEmShP73j6s9Ufzdcu+W8Lop49iSqPfPpTk6FStngK+0oOK6GXovhZCcRls/JG3qaZEMBCqDu7rQ9dwuMGY+5jt741gbvIcd8ByShxHytZlr1sXmWHdaYUB+gWdLhi+jkmqQprStt53foGlkZjuvHq5P2iH0edLucaNw7+5G3xty2/u6exdDDBzfLlo4Cu69wWZ1htro9Urh9TR6MtbbUPuD+Xovg5CcRxkVkrZMvri7muWeHGqQwgC2c8eoR0pZKw/zFO1xUvPkyFNIQzXUgtJscH3WoR7v5Yqz3zRNeexD3foJ77PDKaeBBCljbeFDv073C3vk72vm1aPlilgN3FId5EgI0R9lVEjaMplRURucBRhGFaH0y+NhO3cM3Ad7YZpQBqHXA0eg+Zuhtgh8VSa3foZWp5FposeP7t/sVS+HNwjLBqVhXspBRSCjwhjCeoPEyF5IkjTknjCh9TDuPfIpML7CDMaoDZJ4uxmMhVe7FqtrokCFkLxDgQpJG2sKvBMfYqAiiRIcfzkKzmaMOG6qdLtlrQZYG+XTIlyRAfarpsK9rxclSxsy2ghNzajovPXjPdqvucwWZT9QMVTJW2ipFr7GyqjEnLbtlwDD0H5m0Xr18HazNihiAa7chKpVjXD85Ri4UiOcH56SP2WipzxC8g391ZK0qRmVIXRzlUQJru3t6P9ra+CLaT/P2aOf6LHOroZ1duZnDClbA579vZB8AhiDPu/AQ49HFy2oBZPgBFQmKMMEfaeccB/shTnQtC2RWIFKLKJXADfElvXRTmNxdrOaCQMCJ3o4Fsa6YlReNwPO7e1wQg5UKKNCSP6hGhWSNiaNGpXeVw+g53f7g1eE9ZXgK4d3WFzoC55DCZ6ySHB40fP7/fCeDLaalwQJfZuPAgCs82s0J2myiSsPZiY6n/ki6TodyS//0BIGKoFgK53p1LEyKqGZkvDfQ4YPBnnscA5IJIRkBAUqJG1KC/VUh/lJkgTntra4tzFUZ+5ETzKYkNMpAx+czPr3635xD5zb2tD17Bfqdf1bWiEq/VPCikSziWEZlH8jEBT5RXgO9iV1P8knBwaJBvupRddZCFQAwNokZ9isc7WZNr4y8DvEM7BMG/65PoSQ9NDWD0mbUkcSq/lWLEISt+eHOVAJPRUSOrwuW5Qj1kJfMMgLDd446/D+iVpnV8HV3A733h6Ig8kV1aoFrgkyKoyRA1x+SN74gwPjUQIV47iSkD468u9f+TcmwzS5DJbpFZr7GEcXo+o7Z8BQbR32KcmEkPRRoELSxgUCFaHHndL9fCfjT9blK8zghjlVz9nNYMwcJLcAZHFaMYCY06ZDswaMDsWfTIqt9NWtnwRBgLKtlE6hsnIiyXbuGAwYTwGSpP7+MTyLork1Ue8X2t+FEJJfsvb24v7778fixYthtVpRVlYW9TYMw0R8vPjii9laEskS3i5vT4guP/y97ojZL7H4AwWjlsbKiM9V39KEylWNmVtkkhiGQcU10wEAUpIZhaFSesYAAFsUODkliGqNhWVWBaxNGZyLkyT1mHKyNSq+5IpplSPEQ9366Xn1APwdLoAJZElumoWqmxt1b4VPCMmurL1d83q9WLFiBRYtWoRf/epXMW/3zDPPYPny5erlWEENyV2siQdr5SG6/Gh78GMA8gkS+5XTYnYIBQBR6bpabIB5ml3ti2GeZoexrjj7C49BeaEWsjzvx/VZcJKw6BEhSZKmfb39qunDctonXKq9ZJKuUVECoCh1Jgm/hxisZzI2lIArGb7aHUKIvrIWqPzoRz8CAGzatCnu7crKylBbW5utZZBhwhYbNEdHfW0udD63C7V3zAMTY0qtksbnio0ouaABruYOcOVmmKdkrtPsULBWZTChL63mZPFIgqjWWAAA/CIkr6g2KGNMnC5BChC69ZM4oJBESd4mA+K2yWfMXMj/6xACFa+gTtC2Xzk15fsTQvKX7pVlq1evRmVlJRYsWICnn34akhR/7rnH44HD4dB8EP0pL0KhhG43/KcHo95ecPrUxmJssQFcsRG2c8bA2lipe5tzZRsGfknd1sgkf58HJ374D0g+EYyFBwLHZ0WnT91uydRsnKEIbv0ICf8eQ7Muyv1CVVw3A1yZCZU3zAyeDhvCgEI1uOEZtXibEDIy6Bqo3HvvvXj55ZexefNmfOMb38D3vvc9PP7443Hvs2HDBpSWlqof9fX1w7RaEk9o0avtn+rV0zq+NmfEbSW/iI7HmuE96oi4by5gjJza8yNTM2pCDbx/Qv23cVQRuEDXWdHpU7MYrEW/YE3Z+nHv6sKpH2/F4M7OmLdV1ssY2Kg1KpYZFRh11wKYxpWqway/243+vx2P6EIcT/D/Jbd+Vwgh2ZdSoHLXXXdFLYAN/dizZ0/SX2/dunVYsmQJmpqacOedd+Lf/u3f8JOf/CTufe6++2709fWpH62t2W/KRRILbaTFV1jA2eTL3S/uhb9Lm1Vx7+vRHMdlbdlvD58KhmHAFctrSuXFNFma01Eco2ZwhJCMCqNnRiXke4tOP7p+vTvmbYMBROL1KhmVwc9Oo+/Nw3C8cyyp9Uh+ER2Pf5r09yGEFJaU/urvuOMO3HDDDXFvM2HChCEvZuHChbjvvvvg8XhgMkUvljOZTDE/R/QTuvVjqLGCLQ4GH87mDpT+81gA8rvprud2ae7LV+ReKp8tMULo86iN1zJF8glwHwo2UgstIhYHfGodhp4vyKl0b1UzKkmslwvbHnR92oHySyclvJ/naMj2boKtKEJI4Unp2bCqqgpVVdk7LtnS0oLy8nIKRPKQcvIDkCcaQwjWdjA8C0mU4DnQC39Yr5XKm2ep2YtcwtmM8AEQUuy2m8jg7m61YLbsskkoml8LX6s8gDB0m0nPGhVDXTEMo4rgOxW5bRduKBmVUMkUK4euQxjI7pFxQkjuydqz4bFjx9Dd3Y1jx45BEAS0tLQAACZNmoTi4mK89tpraG9vx1lnnQWz2YzNmzfjgQcewA9+8INsLYlkUWhGheFZCM5gkaXY74Vre7t2pg/kOT7myfqe8IlF2boSMpxR8XfIBcRFZ9aieMEoAMEMhuPdVnUwoJ4ZFYZlYJ1Xg77XDyW8bUqBSlhAKnkECA4v+ARjAkIbA0pDONpMCMlvWXs2XL9+PZ599ln1clNTEwDg3XffxXnnnQeDwYCNGzfitttugyRJmDRpEh555BGsWrUqW0siWVS8pA7+rkFYZ8sZN9u5Y9B1WN7i8Pd54DnUG3Ef0ZO7LzpcoG5G7I98By+JEiSPMKRgwt8rN7njyoIvzmyxHKhIbr96ZDmZrZRs4sOmVseaJJ1KoGKoiRyHILr8QIJAJTTTZBxXkvD7EEIKS9aeDTdt2hS3h8ry5cs1jd5IfmPNPOyXB/tbWKbZUfqV8eh78zD8Ha6odQ/KELlcpLz7F6Kc+un/23E4/nwElTfPSjkjJAS68YYOG4z2f6Pn1g8QOQxRcHjBV0ROslaOGkc7nh4u2qkgKYlgVWm5z1daqIcKISOQ7n1USOGyzqsBY2DhPz2obW4GwDSpDCVLx+q0ssTU7qxR2r07/nwEAND9m+RPuCmEKBkV4xhb5PfX8XgyINcZGcYEuwOHntIKFdpdOBlV3zoD5qnlanCWzNwfpaFc2dcmgi/LvcJrQkh2UaBCsoYrMqDoTG3X4erVc1B60QRU3jQLrFHfF+N4Yg3QC22AluwsnFBqRiU0UKkrxqj/t0DTgl7vjArDMahePQfG8fJWi9AffdK1UtzKJRmomCaUovLGWWqfHcmdOFBRtggZnRsBEkL0QYEKyaqiBcFAhS3iYay3wfal0Tk/SE55UQyfd6NkRAAAYuwJyNGIXgGSVz4NpRTrKrgSk/riDehfowIE+skEZurEzKg4lYxKaie3lO7DUhIZFTGJFv2EkMJFgQrJqtChhMqLdD6I9UKqtP1XpDIJWC0K5Rg1YxOKC2l8lyuNzbjSQK1OjNNPYuD4dqrdhZVAMNHWjyRJah2Lsh1HCBlZKFAhWVf6VbkJYFkSzb1yRawX0vCRAMlkBBRq9qHIELV3SGjju1zJHnC2QEbFEbn1I0mSuvWTbI2KQq0BSlBMK/lEIBDfMqbc+D8hhAwv+ssnWVe8pA6WWZXqu/N8wAZeFCWvoGlK5g8LVESPgGTf5yuD9WJlH4wNJcA/TsrfP0cyKuogwSi1JJJHAIRAJ91sZVSUzzMAY6T3VYSMRPSXT7KOYRjwZaaEHUhzCaNsM0jQTFD2dWrnFqWy9SOEZFSiMU0oDX7/HCkcVbaoomWOlGwKY+RSLoxm43zdUOrsIxOXV78/hJDMyY23bYTkGMbAAgzkQMUjAMopoLAGcPEyApIkwX96EHylBQzLBLd+orSSB+QalepbmsBwTM4UG6u1OlECMqU+JdVtHyA4dDFRRkXJQrG07UPIiEV//YREwTBywavkESC6/eBsxkBNRuDF2WaA2O+LmxFwNXeg5//2RVwfb5vEWFcc83N6ULZbogcqqR1NDqVsbflODsD1aQcss6uiBmfuXV0AAMPo3Pp/IYQMH9r6ISQGJZvQ/rPt6Hxul9zzI1CTwdvlLq3RAhVvaz9Et18zoyaUct98oPaTiXJiK9FWVjym8fI2l//0ILpf2ovBHaej3s59oBcAYJ1dmfL3IIQUBgpUCImBD5lN497VpU5+ZkxczM6qg3u70bGxBaef3KF+jgk7VmuoK0K+UAOVfi86/rsF/t7g9OtgRiX1ImneboZhVPD/wROYCxVO6VvDV0XOCSKEjAwUqBASQ+X1MzWXvUflMQCczRizz4rrk3YA8jFmpb6idPl4zW2Mo/InUGFDTtp4j/XDvadbvRxs9pZ6RgUA7FdNU//tOeLAYGCbRyH5RfV7hM8eIoSMHBSoEBIDw7OouX2eern3DwcByC/MyqkcpSW+IrSWQ50sbOVhnlkBAOCrLUkN8MsV4Y3pel89iNNP74QkSsGtnxjFwYkYqq0ou1juseNvd6HruV0Y3C0HK/5eNzo2tgQWMfTvQQjJfxSoEBKHodoaMeXZWG9Ti0EHPjgJf7cbg7u6IImSppZDGgy8kFt4lC4bh5KlDaj+zuzhW3wGROug69nXA3+HSx0vkE7PF9am3TZyftwOSZLQ8/I++E4FetZIoKPJhIxg9DaFkATCX0zNk8rA2c3of7cVAND1wm74jkcWzgpOJaNigKHaCkMOT4uOJdYxadHly8gMnvD6FsHhQd+fj8BzKFizMpRiXUJI4aBAhZAEwrcdTJPLwbAMuAozhC531CAFkAtQgdzpMptJgsOrbm2lM0CRDRvO6Ds+oP5/Fp8zGgzDqNtmhJCRqfCeQQnJsNBApezrk9QsA2vmkUxf2kKsrxAcXrVrbFoZFVv0E0N8pQWly8fnTOM7Qoh+qEaFkARYS/Bdf2jQEZ4pCW2BrzBPt+fMgMFMEvo8kAbTn2oca1SAZVYFBSmEEAAUqBCSkDY4CQlawl6gy742EZX/0qi5zr5iSnYXNwyqvnWGPFIghNDnUWcgpbO1FatItujM2iF/TUJIYSm8t3qEZFjoC3Hov5mwTAlr5mGoCfZIYUxcXh1FjsU0oRQl/zwWfW8eVq8THF7130ym5vCwQN09i2iuDyFEgzIqhCQQGmxogpaw2hMlcDHUysGK7fz6YVjd8GD4sIxKIFBhTBwYLkNbNCINHySERKJnBUIS0Gz9hP47NKPCBgf4VVw3A95WByxnVA3bGrMtIlAJNLrLZP1NIRYdE0LSR88MhCTAGjlUXDcDECXNC7NmG8jEq/UWvN0M3m4e9nVmVViNCuTZjGCL0n8KqVzViL7XD6Hs0klpfy1CSOGhQIWQJFhmRPbyMIwuVv8dXmxaaGJt72SiGZt5YhnMt85N++sQQgpTYT+7EpJFpoYSGMeXAAAMNYU93Td860dRCMXChJDcRhkVQtJQdXMjPIf71ALaQhUrY8RRe3tCSJZRoEJIGhiehXlyud7LyDqGi5VRoacQQkh20dYPISShWBkVGhhICMk2ClQIIYnFaJVCNSqEkGyjQIUQkpDSLh8AwAejFs5GgQohJLsoUCGEJGSst4GvtMhDFkMGCbIxph8TQkimUKBCCEmI4VnU3D4PFdfN0BTWchSoEEKyLGuBypEjR3DzzTdj/PjxsFgsmDhxIu655x54vV7N7Xbs2IEvfelLMJvNqK+vx8MPP5ytJRFC0sCwDBiG0Zz0YUxcnHsQQkj6sna2cM+ePRBFEb/4xS8wadIk7Ny5E6tWrYLT6cRPf/pTAIDD4cCFF16IpUuX4sknn8Tnn3+Om266CWVlZfjWt76VraURQtLAFhsBuABAHRtACCHZkrVAZfny5Vi+fLl6ecKECdi7dy+eeOIJNVB5/vnn4fV68fTTT8NoNGLmzJloaWnBI488QoEKITnKMqsCngO9BT82gBCSG4a1W1NfXx/sdrt6+cMPP8Q555wDozG4z71s2TI89NBD6OnpQXl5ZCMtj8cDj8ejXnY4HNldNCFEo2jBKAAMTIHxAYQQkk3D9pbowIEDePzxx/Htb39bva6trQ01NTWa2ymX29raon6dDRs2oLS0VP2or6/P3qIJIREYlkHxWaNgqCnssQGEkNyQcqBy1113gWGYuB979uzR3OfEiRNYvnw5VqxYgVWrVqW14Lvvvht9fX3qR2tra1pfjxBCCCG5K+WtnzvuuAM33HBD3NtMmDBB/ffJkydx/vnnY/HixXjqqac0t6utrUV7e7vmOuVybW1t1K9tMplgMplSXTYhhBBC8lDKgUpVVRWqqqqSuu2JEydw/vnnY968eXjmmWfAstoEzqJFi/DDH/4QPp8PBoPc4XLz5s2YOnVq1PoUQgghhIwsWatROXHiBM477zw0NDTgpz/9KU6fPo22tjZN7cnVV18No9GIm2++GV988QVeeuklPProo7j99tuztSxCCCGE5JGsnfrZvHkzDhw4gAMHDmDMmDGaz0mSBAAoLS3F22+/jdWrV2PevHmorKzE+vXr6WgyIYQQQgAAjKREDXnK4XCgtLQUfX19KCmh45KEEEJIPkj29Zs6NhFCCCEkZ1GgQgghhJCcRYEKIYQQQnIWBSqEEEIIyVkUqBBCCCEkZ1GgQgghhJCcRYEKIYQQQnJW1hq+DRelDYzD4dB5JYQQQghJlvK6naidW94HKv39/QCA+vp6nVdCCCGEkFT19/ejtLQ05ufzvjOtKIo4efIkbDYbGIbJ2Nd1OByor69Ha2trQXa8LfTHBxT+Yyz0xwcU/mMs9McHFP5jpMc3dJIkob+/H3V1dRFDi0PlfUaFZdmIWUKZVFJSUpC/fIpCf3xA4T/GQn98QOE/xkJ/fEDhP0Z6fEMTL5OioGJaQgghhOQsClQIIYQQkrMoUInBZDLhnnvugclk0nspWVHojw8o/MdY6I8PKPzHWOiPDyj8x0iPL/vyvpiWEEIIIYWLMiqEEEIIyVkUqBBCCCEkZ1GgQgghhJCcRYEKIYQQQnIWBSpRbNy4EePGjYPZbMbChQuxbds2vZeUMRs2bMCZZ54Jm82G6upqXHrppdi7d6/ey8qaBx98EAzDYM2aNXovJaNOnDiBa6+9FhUVFbBYLGhsbMQnn3yi97IyQhAErFu3DuPHj4fFYsHEiRNx3333JZwHksv+9re/4eKLL0ZdXR0YhsGrr76q+bwkSVi/fj1GjRoFi8WCpUuXYv/+/fosdgjiPT6fz4c777wTjY2NKCoqQl1dHa677jqcPHlSvwUPQaKfYajvfOc7YBgGP//5z4dtfelK5vHt3r0bl1xyCUpLS1FUVIQzzzwTx44dy/raKFAJ89JLL+H222/HPffcg+bmZsyePRvLli1DR0eH3kvLiC1btmD16tXYunUrNm/eDJ/PhwsvvBBOp1PvpWXcxx9/jF/84hc444wz9F5KRvX09GDJkiUwGAz405/+hF27duFnP/sZysvL9V5aRjz00EN44okn8F//9V/YvXs3HnroITz88MN4/PHH9V7akDmdTsyePRsbN26M+vmHH34Yjz32GJ588kl89NFHKCoqwrJly+B2u4d5pUMT7/G5XC40Nzdj3bp1aG5uxu9//3vs3bsXl1xyiQ4rHbpEP0PFK6+8gq1bt6Kurm6YVpYZiR7fwYMHcfbZZ2PatGl47733sGPHDqxbtw5mszn7i5OIxoIFC6TVq1erlwVBkOrq6qQNGzbouKrs6ejokABIW7Zs0XspGdXf3y9NnjxZ2rx5s3TuuedKt956q95Lypg777xTOvvss/VeRtZcdNFF0k033aS57rLLLpOuueYanVaUWQCkV155Rb0siqJUW1sr/eQnP1Gv6+3tlUwmk/Sb3/xGhxWmJ/zxRbNt2zYJgHT06NHhWVSGxXqMx48fl0aPHi3t3LlTGjt2rPSf//mfw762TIj2+K644grp2muv1WU9lFEJ4fV6sX37dixdulS9jmVZLF26FB9++KGOK8uevr4+AIDdbtd5JZm1evVqXHTRRZqfZaH44x//iPnz52PFihWorq5GU1MTfvnLX+q9rIxZvHgx3nnnHezbtw8A8Nlnn+Hvf/87vvzlL+u8suw4fPgw2traNL+rpaWlWLhwYUE/7zAMg7KyMr2XkjGiKGLlypVYu3YtZs6cqfdyMkoURbzxxhuYMmUKli1bhurqaixcuDDu9lcmUaASorOzE4IgoKamRnN9TU0N2tradFpV9oiiiDVr1mDJkiWYNWuW3svJmBdffBHNzc3YsGGD3kvJikOHDuGJJ57A5MmT8dZbb+G73/0ubrnlFjz77LN6Ly0j7rrrLlx55ZWYNm0aDAYDmpqasGbNGlxzzTV6Ly0rlOeWkfK843a7ceedd+Kqq64qqCF+Dz30EHiexy233KL3UjKuo6MDAwMDePDBB7F8+XK8/fbb+PrXv47LLrsMW7Zsyfr3z/vpyWToVq9ejZ07d+Lvf/+73kvJmNbWVtx6663YvHnz8Oyd6kAURcyfPx8PPPAAAKCpqQk7d+7Ek08+ieuvv17n1aXv5ZdfxvPPP48XXngBM2fOREtLC9asWYO6urqCeHwjmc/nw+WXXw5JkvDEE0/ovZyM2b59Ox599FE0NzeDYRi9l5NxoigCAL72ta/htttuAwDMmTMHH3zwAZ588kmce+65Wf3+lFEJUVlZCY7j0N7errm+vb0dtbW1Oq0qO77//e/j9ddfx7vvvosxY8bovZyM2b59Ozo6OjB37lzwPA+e57FlyxY89thj4HkegiDovcS0jRo1CjNmzNBcN3369GGpvh8Oa9euVbMqjY2NWLlyJW677baCzZApzy2F/ryjBClHjx7F5s2bCyqb8v7776OjowMNDQ3q887Ro0dxxx13YNy4cXovL22VlZXgeV635x0KVEIYjUbMmzcP77zzjnqdKIp45513sGjRIh1XljmSJOH73/8+XnnlFfz1r3/F+PHj9V5SRl1wwQX4/PPP0dLSon7Mnz8f11xzDVpaWsBxnN5LTNuSJUsijpTv27cPY8eO1WlFmeVyucCy2qcmjuPUd3WFZvz48aitrdU87zgcDnz00UcF87yjBCn79+/HX/7yF1RUVOi9pIxauXIlduzYoXneqaurw9q1a/HWW2/pvby0GY1GnHnmmbo979DWT5jbb78d119/PebPn48FCxbg5z//OZxOJ2688Ua9l5YRq1evxgsvvIA//OEPsNls6h54aWkpLBaLzqtLn81mi6i3KSoqQkVFRcHU4dx2221YvHgxHnjgAVx++eXYtm0bnnrqKTz11FN6Ly0jLr74Ytx///1oaGjAzJkz8emnn+KRRx7BTTfdpPfShmxgYAAHDhxQLx8+fBgtLS2w2+1oaGjAmjVr8OMf/xiTJ0/G+PHjsW7dOtTV1eHSSy/Vb9EpiPf4Ro0ahW9+85tobm7G66+/DkEQ1Ocdu90Oo9Go17JTkuhnGB58GQwG1NbWYurUqcO91CFJ9PjWrl2LK664Aueccw7OP/98/PnPf8Zrr72G9957L/uL0+WsUY57/PHHpYaGBsloNEoLFiyQtm7dqveSMgZA1I9nnnlG76VlTaEdT5YkSXrttdekWbNmSSaTSZo2bZr01FNP6b2kjHE4HNKtt94qNTQ0SGazWZowYYL0wx/+UPJ4PHovbcjefffdqH93119/vSRJ8hHldevWSTU1NZLJZJIuuOACae/evfouOgXxHt/hw4djPu+8++67ei89aYl+huHy7XhyMo/vV7/6lTRp0iTJbDZLs2fPll599dVhWRsjSXnc7pEQQgghBY1qVAghhBCSsyhQIYQQQkjOokCFEEIIITmLAhVCCCGE5CwKVAghhBCSsyhQIYQQQkjOokCFEEIIITmLAhVCCCGE5CwKVAghhBCSsyhQIYQQQkjOokCFEEIIITmLAhVCCCGE5Kz/D0n7pBLJHJcvAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# A plot of the solution of the additive-noise SDE used to compare the methods\n", "# A plot of the solution of the SDE\n", @@ -460,12 +541,12 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 9, "id": "a8aeb3aa7e69b296", "metadata": { "ExecuteTime": { - "end_time": "2024-05-21T17:02:49.709780Z", - "start_time": "2024-05-21T16:52:59.106411Z" + "end_time": "2024-09-01T12:52:01.992655Z", + "start_time": "2024-09-01T12:46:43.083729Z" }, "collapsed": false }, @@ -492,16 +573,27 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 10, "id": "78fed5faa530d9eb", "metadata": { "ExecuteTime": { - "end_time": "2024-05-21T17:02:49.986970Z", - "start_time": "2024-05-21T17:02:49.710860Z" + "end_time": "2024-09-01T12:52:02.173591Z", + "start_time": "2024-09-01T12:52:02.015409Z" }, "collapsed": false }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIMAAAOOCAYAAACTMtKnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAB7CAAAewgFu0HU+AAEAAElEQVR4nOzddXgU19fA8e/G3SBocAKU4G7B3R0KFCuUFikValCBUqe0hdKW4q5FimuwACEEa3CHBA0hCXGd94/8Mu8uu8luHMj5PM8+2d25c+fO7mR298y952oURVEQQgghhBBCCCGEEAWCWX43QAghhBBCCCGEEELkHQkGCSGEEEIIIYQQQhQgEgwSQgghhBBCCCGEKEAkGCSEEEIIIYQQQghRgEgwSAghhBBCCCGEEKIAkWCQEEIIIYQQQgghRAEiwSAhhBBCCCGEEEKIAkSCQUIIIYQQQgghhBAFiASDhBBCCCGEEEIIIQoQCQYJIYQQQgghhBBCFCASDBJCCCGEEEIIIYQoQCQYJIQQQgghhBBCCFGASDBICCGEEEIIIYQQogCRYJAQQgghhBBCCCFEASLBICGEEEIIIYQQQogCRIJBQgghhBBCCCGEEAWIBIOEEEIIIYQQQgghChAJBgkhhBBCCCGEEEIUIBIMEkIIIYQQQgghhChAJBgkhHjhLVmyBI1Gg0ajYfjw4fndnJdCaGgo06ZNo2HDhri6umJubq6+hkuWLMnv5gkhhMgFZcuWVc/1t2/fzpE6hw8fbvTzY+rUqWqZqVOn5sh2AQ4ePKjW27JlyxyrV2RPbr3fQoi8ZZHfDRBC5J07d+7w77//snPnTm7cuMGjR49ISEigaNGilCxZkjZt2tCtWzfq16+f300V2XDz5k2aN2/OvXv38rspQgghhBAvvVOnTrFy5Ur8/Py4ceMG4eHhaDQaHBwc8PDwwNPTk7p169K0aVMaN26MhYXhn9lLlixhxIgRBpeZmZnh5OSEs7MzLi4uVK1albp169KoUSOaNGmCRqMxub3Dhw9n6dKlWdrXFi1acPDgwSytK14uEgwSogB48uQJU6dO5e+//yYpKUlv+Z07d7hz5w7Hjh1j+vTpdOjQgZ9//plq1arlQ2tFdo0ZM0YNBNna2tK2bVtKliyJubk5AK+99lp+Nk8IIUQBdPDgQVq1agXIj03x8ggODmbMmDHs2LHD4PL4+HhCQ0M5d+4c//zzDwDOzs6Ehoaq37tMlZKSQnh4OOHh4dy5c4dz586xevVqACpWrMhbb73FuHHjsLOzy95OCfE/EgwS4hV38eJFOnbsSFBQkPqchYUFjRo1okyZMlhbW3P//n2OHTvGs2fPANi9ezcHDx5k5cqV9OnTJ7+aLrLgwYMH7Nu3DwBra2vOnTuHp6dnPrdKCCGEEOLlcufOHZo3b87du3fV51xcXGjQoAElS5bE0tKSp0+fcvnyZS5dukRycjIAERERKIpitH5HR0eGDh2q81x0dDTh4eEEBwdz7tw5EhMTAbh+/Toff/wxCxcuZMWKFdSrV8/k/ahSpQpt2rQxubx8byw4JBgkxCvs4sWLNGvWjLCwMAAsLS2ZNGkSH374IYUKFdIpGx8fz9q1a5k0aRIhISHEx8fTv39/li1bxuDBg/Oj+SILzpw5o9739vaWD3QhhBC5burUqbmSO6Zly5Ym/agWeSu33u8XzciRI9VAkJOTE7NmzWLw4MFYWlrqlX327Bnbtm1j1apV7Ny506T63dzcmDNnTrrL4+Li2LdvH7/++is+Pj4AXLlyhWbNmrF//36aNm1q0nYaNmyY4XZEwSUJpIV4RcXFxTFgwAA1EGRnZ8fevXv57rvv9AJBkNqLZOjQoTo9SVJSUhgzZgxXr17N07aLrEt7vwGKFy+ejy0RQgghhHg5nTx5Ug3AaDQatm7dyvDhww0GgiA1WDRo0CC2bdvGtWvXMj1EzBAbGxu6du3K/v37Wbx4Mba2tkDqBdxevXrp9FgSIiskGCTEK+q7777j/Pnz6uPly5fTokULo+sVL16cvXv34ujoCKR2Vx09enSutVPkrLTuxJCaiFAIIYQQQmTOnj171PsNGzakefPmJq9bvnz5TCV7NsXzCaFDQkIKRO8skbvkl4IQr6CYmBj++OMP9XHPnj3p3bu3yeuXKVOGadOmqY8PHz6Mv7+/wbItW7ZUpxdNSwb54MEDvvvuOxo0aECxYsUwNzfHxcXF4PqnT59m9OjRlC9fHltbW9zd3WnQoAE//fQTT58+NbnNzzt58iTvv/8+tWrVwt3dHSsrK4oVK0aLFi348ccfdXrQpMfQFL03btxgypQp1K5dG3d3d8zMzKhVq1aW25kmKiqK2bNn06FDBzw8PLCxscHV1ZVq1aoxfvx4Tpw4ke662lPvas9QsXTpUvX5tNvw4cOz3VaAnTt3MmbMGKpVq0ahQoWwtLTExcWFOnXqMGbMGLZs2WIwWbk2RVFYv349r7/+OhUqVMDBwQEHBwcqVKjAoEGD+Oeff0waHmDoGHz69Ck//vgj9evXp3Dhwtja2lK+fHnefPNNnSDp83755Re1rg4dOpj8ehw7dkxdz83Njfj4+HTLRkdH89dff9GtWzfKlCmDnZ0djo6OeHp6MnLkSPVKZEaWLFmi954mJyezZs0aevToof4/aTQaNm/erLd+WFgY33zzDfXq1cPV1RUHBwcqV67MqFGjOHnypFpO+9gxRWhoKDNnzqRdu3aUKlUKGxsbdUaUcePGERAQYLQOQ1MWJyUlsWzZMjUZurW1NcWLF6dnz55s27bNpLZp+++///j0009p2LAhxYoVw8rKSn0NBgwYwMKFC4mIiMiT/c2qCxcu8NFHH1G7dm0KFy6MtbU1JUqUoGXLlvz444+EhoYarcPQcQSwadMmunXrRunSpbG2tqZIkSK0b9+eFStW5PiQndjYWDZv3sy7775Ls2bNKFq0qPp+lC1bll69erFw4UISEhKM1pXeNOQ+Pj4MHDiQ8uXLY2NjQ6FChWjevDlz5szRCaDnhMTERHbv3s3HH39Mq1atKFGiBDY2Ntja2uLh4UGnTp347bffiIqKylS98fHx/P7773h7e+Pu7o6tra16rjxw4ECW27t582Z69Oih/l95eHjQrl07li9fbvQcri2jqcbTlqUljwY4dOiQ3ueTRqOhbNmyOutmNLV8YmIihQsXVpcfP37c5Pa2b99eXW/GjBkZls2J7xOmyotjePfu3YwcOZJKlSrh5OSEra0tZcqUoVevXixZssSk+jIztbyPjw9vvvkm1atXx8XFBQsLC+zs7PDw8MDb25v33nuPbdu2mfQ/npfnXO0ZWcuUKZNj9WZHv379GDRokPp4xYoV3LlzJx9bJF56ihDilbNkyRIFUG+HDx/OdB2RkZGKg4ODWsfw4cMNlmvRooVa5sCBA8rmzZsVV1dXne0DirOzs966U6ZMUczNzfXKpt08PDyU48ePK4sXL1afGzZsWIbtfvr0qdKnT59060y7ubi4KOvXr8+wrjJlyqjlb926pfz999+KjY2NXl01a9Y08VU1bOvWrUqxYsWMtnnQoEFKdHS03voHDhwwuq6pr58x58+fV+rVq2fStgYMGJBuPVevXlVq165ttI66desqN27cyLBNzx+Dvr6+SsmSJdOt09zcXJk3b57Buu7fv68ek+bm5sqDBw9Mel3eeecdtf633nor3XLr1q0z6b3u2rWrEh4enm49z/9P3Lt3T2nWrJnBujZt2qSzro+Pj1K0aNF0t21mZqZMnTpVURRF53lj5syZozg7O2e4XxqNRhk5cqQSHx+fbj1fffWVWv6rr75SgoODlSZNmmRY74gRI5Tk5GSjbQwLC1MGDBigaDQao+9B0aJF82R/MysxMVGZMGFChufOtHPckiVLMqzr+eMoPDxc6d69e4b1duzYUYmJicmRffHz89P5nMnoVrZsWeX06dMZ1qd9LmzRooUSHx+vjB49OsN669Spo4SEhOTI/ty9e1cpVKiQSftTqFAhZc+ePSbVe/HiRaVy5coZ1vf2228rCQkJep9b6YmMjFQ6d+6cYZ3NmjVTHjx4oAwbNkx9bvHixQbre/7/Nr1lxm5lypTRWff59/R52ufesWPHmvR6ap/nzczMlODgYIPlcvL7hKly8xh+9OiR0qZNG6P74+npqZw8eTLDujJ6v9NERUUZPZ9o3+bPn5/hNvP6nDtu3Di13gYNGmS7vjTa593nj3dTnDp1Smeff/nlF4PltP9vs/vdT7y6JIG0EK8g7auEpUqVwtvbO9N1ODg40KNHD1auXAlg0hSwx44dY+rUqSQmJqpXrQoXLszjx491EhsDTJ48me+//159bGdnR+vWrSlevDgPHz7Ex8eH4OBgOnfuzHvvvWdSmx8+fEjr1q25dOmS+pyXlxc1a9bEwcGBx48fc+TIEUJDQwkPD6d///4sX77cpATZ69ev5+OPPwagRIkSNG3aFGdnZ+7fv5+tHkxr165l8ODB6gwU5ubmNGvWjIoVKxIVFcWRI0e4f/8+AKtWreLWrVv4+PhgY2Oj1lGyZEnGjRsHwOXLl9m/fz9gePaIRo0aZbmtBw8epHv37kRGRqrPlS5dmgYNGuDm5kZ0dDRXrlxRZ7+Ii4szWM+lS5do0aIFISEh6nPVq1enVq1aaDQazpw5Q2BgIACnTp2iSZMmHD58mEqVKhlt4/nz5/nss8+IioqiSJEieHt7U6hQIe7du4ePjw+xsbEkJyfz9ttvU716db3Xo3jx4rRu3Zq9e/eqPW2MHX+JiYmsW7dOffzGG28YLPfrr7/y4Ycfqj0rnJycaNy4MR4eHiQnJ3PhwgUCAgJQFIVt27bRsmVLjh49anQK2fj4eLp3786pU6ewsLCgSZMmVKhQgfj4eE6fPq1T1s/Pj65duxITEwOk9vypX78+Xl5eJCQk4O/vz7Vr15g6dSqFCxfOcLva3nvvPWbNmqU+Lly4MI0bN6ZYsWLExcVx5swZzp8/j6IoLFq0iPv377N9+3ajQxmjoqLo2LEj58+fx87ODm9vb0qVKkVkZCQHDhzg8ePHACxevJjKlSvzySefpFvX/fv3ad26NVeuXFGfc3FxoWnTphQvXpzExETu3r3LqVOnePbsWbrHb27urzEpKSn06dOHLVu2qM+5ubnRsmVL3NzcCAoK4sCBAyQkJBAeHs7w4cMJDw9n4sSJRutOSkqiT58+7N+/HysrK/U4iouL48iRI2puil27dvHBBx/w119/ZWtfILWHWloPmSJFiuDl5YWHhwf29vbExMRw/fp1/P39SUpK4vbt27Ro0YLTp09TsWJFk+p/6623WLp0KWZmZjRs2JAqVaqQkpKCn5+fehycPn2aoUOHpjttdGZER0erPbJcXV3x8vKiTJkyODg4kJCQwK1bt/Dz8yMuLo7Q0FA6d+7MoUOHaNKkSbp13rlzhzZt2vDgwQP1OS8vL+rUqYNGo+H06dOcP3+euXPnmjzddGJiIl26dOHw4cPqc8WKFaN58+Y4Ojpy/fp1fH198fX1pVevXpQvXz6Lr0iqBg0aMG7cOO7du6f2VCxRogS9evXSK2sop2FGhgwZoh6L69atY9asWVhYZPzzZs2aNepnbqtWrShZsqRemdz8PpEZOXUMP3r0iKZNm3Ljxg31uQoVKtCwYUOsra25ePGi2gP52rVrtGrVil27dpmcoNiQIUOG6JyrKlasSO3atXFzcyMxMZGQkBACAwPVntcZyY9zboUKFdT7AQEB7N+/P1MzcuWWOnXqUL58eW7evAnAkSNHeP/99/O5VeKlla+hKCFErqhQoYJ6NaBv375Zrmf27Nk6Vx8MXT3T7pVhYWGhaDQaZfr06UpCQoJOubi4OPX+oUOHdK7M9+3bV3n69KlO+fDwcGXgwIEKoFhZWRm9upGcnKy0atVK5yqOoavIsbGxytSpU9Xt29vbKzdv3jRYp/YVVgsLC8XKykqZN2+ekpKSku6+Zcb169d1roo3aNBAuXbtmt5+zZw5UzEzM1PLTZgwId06M9OLKjPu3r2rFC5cWK27XLlyys6dOw2Wffr0qTJ37lxl0qRJesvi4+OVmjVrqvUUKVJE2bt3r1653bt362yvTp06esdUGu1j0NraWjE3N1dmzpypJCYm6u1DtWrV1LKtWrUyWN/SpUvVMnXr1jX20ihbtmzReV2ePz4URVH27dunvodWVlbKDz/8YLCX15kzZ5SqVauq9b3zzjsGt6n9PltYWKhXkQ31BEg7PmNjYxVPT0+dtvr7++uVX7t2rWJnZ6dYW1vr/P+nZ+HChWoZJycnZf78+QbfKx8fH50eWz/++KPB+rSvOKe1YdiwYUpoaKhOuejoaOX1119Xyzo4OChRUVEG60xMTFSaNm2qlrW1tVXmzJljsJ3x8fHKli1blJ49e+bJ/mbGjz/+qPOefPrpp3pXwB88eKC0b99e5/jw8/MzWJ/2cZT2Wnfq1EnvXJ+YmKhMmjRJ5+p7Rr1OTOXn56dMnjxZCQwMTLfMo0ePlDfeeEPddps2bdItq92rIm1/6tevr1y6dEmnXEpKivLbb7/pvJaHDh3K9v7cvn1bmTBhgnLixIl0e6pFREQoH374obrdSpUqZdirTbsnh7Ozs7J161a9Mjt27FB75FpaWqrl03uPvv76a5338ttvv1WSkpJ0yly5ckU9V2t/BmelZ1AaY718srpO+fLl1TKGXp/n1alTJ8P9yY3vE6bKrWO4U6dOajl7e3tl9erVemVOnjyp81qWKlVKCQsLM1ifsff77NmzOufmHTt2pNu2GzduKN98842yZcsWg8vz65x77do1ne9ednZ2yhdffKH3PS2zstszSFEUnc++4sWLGywjPYOEKSQYJMQrKO3HIaAO98gKHx8fnS8avr6+emW0f4gDyjfffGO0Xu0hH23atNH7EpomOTlZ50dNRh9oy5YtU8s0atTI6DAG7S8yb7/9tsEy2sEgQFmxYoXRfcuMoUOHqnVXrFgxw2FBv/zyi1rWzMws3S+cuRUMGjx4sM6Xl4cPH2apnkWLFqn1WFpaZjjsw9/fX+dYXrp0qcFyzx+Df//9d7p1BgYGql/cNRqNcv/+fb0ykZGRip2dnVrf5cuXM9ynAQMGqGU///xzveXJyck6QZiNGzdmWN+DBw/UYVyWlpZKUFCQXhnt9xlQqlevbvSY/+uvv3S+1F6/fj3dshs3btSpHwx/XXj27Jni4uKi/mBML+iQ5uLFi+pQy0KFChkMiD0/pOT1119Pt77Y2FilVKlSatk1a9YYLDd//nyd4y4rQ2cVJXf211QRERE6wWNDwdY0cXFxSv369dWy6QU+nz+OvL299YKoaVJSUnTq/OGHH7K8L1mh/WP24sWLBss8P2TW09NTiYyMTLfOvn37Gv0cyC1vv/22uu30fijv2bNHJ2jj4+OTbn2HDx/WG/5oKBgUHh6uc37L6DvC48ePleLFi+vU+SIGg7788ku1zMCBAzOs79KlS2pZW1tb5dmzZ3plcuP7hKly4xh+/rvctm3b0q3v1q1bOkOxpk2bZrCcsff7999/V5dPmTIl453OQH6ecxVFUSZMmKD3WQipw1YHDBigzJgxQzl8+HCmLgrmRDBo6tSpah0WFhYGy2gHg6pUqaKMGzfO5NvVq1ez1C7x8pFgkBCvmIiICJ0PrFmzZmW5rjNnzujUZeiqjfYP8RIlSqT7QyLNxYsXdeq8cOFChuWvXLmi8wU3vQBHrVq11DJnz541um+xsbHqFwxnZ2eDV2a1g0E5OV5cUVJzl2j3vDAWIEhOTla8vLzU8p9++qnBcrkRDAoODtYJyqTXI8gUDRs2VOt59913jZbXzgfRqFEjg2W0j8Hq1asbrbNBgwYZHtOKoiiDBg3KMMCT5tmzZ4qtra1a1lDgaPPmzery9HqbPO/7779X15k5c6be8ud/xGd01TWNdq6nyZMnGy2vfWUcDH9d0L4y/d577xnfMUVRxowZo66zYcMGveXaPzKsrKyM5m36+OOP1fIffPCBwTJVqlRRy3zyyScmtdOQ3NhfU2kH84oWLWr0B+qJEyd03j9Dx+bzx9GpU6cyrPPPP/9Uy/bu3TvL+5IVa9euVbc9e/Zsg2We/yFt7PXesWOHWrZOnTq50ex0ab8/6R23/fv3V8v069fPaJ3a5y0wHAzSfg89PDyM5laZN2+eTp0vYjDo6tWrahk7OzuDAZ40U6ZMUcumFzjKje8TpsqNY1j7gkX37t2NtkG7B2Lx4sUN9nY19n5/++236vLffvvN6DbTk5/nXEVJ7RWp/T0kvZu1tbXStWtXvRx9huREMOjXX3/V2X5ERIReGe1gUGZvBw4cyFK7xMtHZhMT4hWjnc8FwN7ePst1OTg46Dx+9uxZhuX79u1rdKy+dj6junXrUrVq1QzLV6pUyWiemwcPHnD27FkAqlatSs2aNTMsD2BjY0Pjxo0BiIiIyHCGKYCBAwcarTMzjh07ps44VbhwYbp165ZheTMzM0aOHKk+zs7sMZm1b98+dVYZT09POnbsmKV6IiMjdWb60N6f9IwaNUq9f/LkSaKjozMs369fP6N11q5dW72fXq6CIUOGqPdXrVqVbl0bN24kNjYWgHr16lG5cmW9Mtp5HLRnAclI69at1fu+vr4ZlnV1daV9+/YZlomMjNTJH6S9f+kxpUxu71uzZs0oVqxYhmWMvZ937tzh8uXL6uPx48eb1E5Dcnt/M6I9y9zrr7+Ora1thuUbNGhA9erV1cfGzhnly5enTp06GZYx5X8nq2JiYvDx8WHWrFl8/vnnTJw4kfHjx6u31atXq2XTzvcZsbGxMXpezc39SUxMxNfXlz/++IMvvviC9957T2d/tGf8TG9/tN+zoUOHGt3msGHDjJbRrnPAgAFYWVllWH7gwIFGy+Q3T09PGjRoAKQeR5s2bUq3rPb53NA5Li++T5gqp45h7ffclM/dESNGqLl2Hjx4oJNnzVSlSpVS7y9btkzNU5dZ+XnOBbCwsODPP//k2LFj9OzZM93/hfj4eLZt20avXr1o2rSpmmMttzz//fz57/5CmEoSSAvxinF0dNR5bOzHc0aen/rWyckpw/J169Y1Wqd2Ium0L0/GNG7cOMMpY7WXxcbGmvxjTzuRYlBQEDVq1Ei3rCn7lhnar0ODBg2MBtEAnUSOZ86cQVEUk6f8zg4/Pz/1/vNT+2bGf//9pybtdHBwyPD1TlOrVi3s7e2Jjo4mOTmZc+fOZZhsVfvHb3q0E5SmF+Bs164dRYoU4fHjx9y8eZNjx44Z3O6KFSvU++kljtY+Pjds2MChQ4eMtlF7WvOgoKAMy9aqVQtzc/MMy/z333+kpKQAqf/HVapUMdqGhg0bGi2jvW/z5s1j6dKlRtcJDg5W7xvbt5x4P7WPX09PTzw8PIzWmZ7c3t+MaJ8zMvof0Na0aVM1GfvzycSfl1P/O5n19OlTvvzyS5YtW2byD5onT54YLVO5cmUsLS0zLJMb+xMbG8t3333H3LlzTWonGN6fe/fu6STZNyX5f6NGjdBoNGqSekMy+xns6OhItWrVjB4/+W3IkCH4+/sDqedlQ8Gzo0ePcuvWLQDc3d3p0KGDXpm8+D5hqpw4hu/du6cm2gfTzh3u7u5UqlRJDaKfPn3apM8MbZ07d1Y/u9PWf/PNN+nSpQu1a9c2+pmVJj/PudoaN27Mpk2biIiI4PDhw/j6+nLq1ClOnz5NWFiYTtljx47RqFEjTp48aTA5eU54/lxp7Pv5sGHDWLJkSa60RbzcJBgkxCvGyckJCwsLtSdHdma6ev4Dzs3NLcPy7u7uRuvU/nJbunRpk9phrFzabFsAt27d0rniaqrn9/V5puxbZmi/DmXKlDFpnbJly6r3ExISiIyMNPoFICc8evRIvZ+dWWW097lUqVImBbLMzMwoVaqU+qXU2I8rZ2dno3Vqf7lOTEw0WMbCwoKBAwcye/ZsAFauXKn3JfrBgwdqb4208oZoH59r16412r7n5cSxqf3ae3h4mPTaGwuaREVF6XwhXbBggdE6n2ds33Li/cyp4zcv9jcj2T1n5NX/TmbcuXOH5s2bZ/oquilBo8zuT9pnZnaEhYXRunVrk3ouaTO0P9rvt52dnUmz+zk5OeHs7Ex4eHi6ZbL6GfyiB4MGDhzIBx98QFJSEj4+Pjx8+FCvV2Ha7Khp5Q1dhMmL7xOmyoljWPv9trW1Nfm7TNmyZU3+3DWkUKFCLFiwgKFDh5KYmEhQUBBTp05l6tSpODg40LBhQ1q0aEG3bt2oVauWwTry+5xriLOzM926dVN7bCmKwpkzZ1ixYgV///232gPqwYMHvPPOOzqzqeUk7QtGlpaWeheChTCVDBMT4hWk/UMhO92Vn19X+4eFIcaGLYBubyNTp8E1NtRN+0Mxq4z9EDBl3zJD+3UwdSjf8+Xyqluw9nae75qcGVnZ5+fLGtvnnOwppd3TZ926dXo/flevXq32tmnfvj1FihQxWE92j8+cODaz8n9n7L3Oi/+7nHg/c+r4zYv9zUh2zxl5+b9jqkGDBqmBIEdHR95//3127drFzZs3iYqKIjk5GSU1v6XOUJe0/7uM5Mf+jBs3Tg0EWVlZMWrUKP7991+uXr1KZGQkSUlJ6v6k9VABw/uTlf9ZMH5s5MZn8ItAu6dPcnKyzrBCSA1erlu3Tn2cXk/O/P4/15YTx3BefO6mZ+DAgfj7+9OrVy+doFVUVBT79+/nyy+/pHbt2tSrV48jR47orf8ivRfp0Wg01KlTh19++YXTp09TvHhxddnWrVt1/s9zkvbQ56JFi+bKNkTBID2DhHgFNW3aVO2yfOLEiSzXo71u2bJlc6S7q/aPMVPHkBsb6qb9paV79+78+++/WWtcHtJ+HUwdyvd8uby6EqS9neeHDmZGVvb5+bJ5efWrXr16VKlShcuXL/PkyRN2795N165d1eXaV5kzyq9jb2+vfqk9ffq0To6HvJLb/3eQ2gvR1dU1843LZTl1/Ob3/jo4OKjHUVbOGS/aleNjx45x7NgxIHXf/Pz8Mswh96LnxLh37x5r1qwBUns07tq1i1atWqVb3tj+ZOV/FowfG9rHUU6dC14UQ4YMYfv27UDq+fn9999Xl+3atYvQ0FAgdfhV/fr1DdbxMn6fyEh+f+7WqlWLjRs3Eh4erg6v8vX1JSAgQL3AcurUKVq1asXq1at18v7l9zk3sypXrszMmTN1chsdOXKEcuXK5fi2tL+fmzKEVIj0SM8gIV5B2l9Ag4ODOXz4cKbriIqK0vkSlNGX2szQ7qJs6tAAY2O+ta+KPHz4MGsNy2NZeR20k0NaWVnl2Y877dc3O1e5tPc5ODg4w7wWaVJSUnTef1OGSuSkwYMHq/e18wNdunRJHTbh6OhIz549063jRTg+tV+3e/fumbSOdt4FQ1xcXLC2tlYfv6j/ezl1/Ob3/mb3nJHX/zvG7N+/X70/bNgwo5MJ3LlzJ7eblC0+Pj7qOa1Tp05GPzON7Y/2+x0TE6MGMjISGRlptDdFbnwGvyh69Oihfi6eOnVKp/eE9vk7o+D9i3C+zkna73dsbKzJQ75y+tzh4uJC9+7d+emnnzh27BhPnjxh8eLF6lDF5ORkxo4dq07IkLbOy/AZo+35CTYePHiQ49sICAjQeX+aN2+e49sQBYcEg4R4BfXr10/n6skvv/yS6Trmz5+vcxX97bffzpG2afeK0E7smpGMkkeDbqLbs2fPvhRXMbVfB39/fzWxckbSrqKnrZ9XwyC0rzplZxazGjVqqEkjIyMj1cS2GTl37pz6fpqbm5s0s0tOGjx4sPo6b9myRb2ar90rqHfv3hkO1dI+Po8ePZpLLc1YjRo11NlhIiIidH4kpSctGWtG0mbwgfzbN2O0j9+rV68aDXJlJD/3V/ucoX0uyIh2OWMzheU17dwspiSvzspFjbyU0/tTsmRJnR/ypnxe+vn5GQ2yZ/YzOCoqKsdmx8rtzyxbW1t69+6tPk47T0dGRrJ161a1DdpB/ue9jN8nMlKyZEmdIcymnDuePHnC1atX1ce5ce5wcnJi+PDh+Pj4qAGfJ0+e6H3fexk+Y7TZ2NjoPNYOZuUU7e/0VlZWOse8EJklwSAhXkH29vaMHTtWffzvv/9mONXq8+7cucOXX36pPm7evLnOB3J2aF8tDQgIMPqj9Pr160aDQeXLl+e1114DUhMrL1y4MPsNzWVNmjRRvySEhISoXdvTk5KSwuLFi9XH2lOn5rZ27dqpiTavXbvG7t27s1SPo6Mj9erVUx+bMrOF9nvZoEGDPM9dUa5cOTVxdGxsLBs3bkRRFKPTE2vTHlq2aNEi4uLicqexGXByctL5EagdzEqP9pX09Gjv219//WVSb6+8VqZMGfX8AGQpIWya/Nxf7f/5NWvWGD2OAgIC+O+//9THOdW7M6ekBSfB+HCl+/fvv/DDdTKzPzExMSxbtsxondrv2fLly42Wz2yda9euNZoIfO3atcTHxxut1xTaP5RzIgG5Idrn47Tz3IYNG9QeJ02aNMlw2M7L+H3CGO333JTP3SVLlqh5rEqUKEHlypVzq2lUqFABLy8v9bF2wn94OT5jtJ07d07nsalJ2k21fv16nXxYw4cPz7UZy0TBIMEgIV5RkydP1ul2P2TIEJOurD58+JD27durvYLs7e2ZP39+jrXrtdde05mVaeLEiekmA01JSeHdd9816cP/k08+Ue9//vnnJvU6SZMfXY9dXFwYMGCA+vijjz7KMIfEnDlz1H0yMzPjrbfeyvU2pilRooROW8eMGaP3hc1UY8aMUe//8ccfOj9Wn3fq1Cn+/vtv9XFO9U7LLO1EoytXruTYsWPqcKOSJUsaDcz16dOHihUrAqldxseOHWvyF9qoqKgcuzI9cuRI9f5vv/2W4ZCpLVu26AzjSc+YMWNwcXEBUvMhTZs2zeT2PHnyxKQecTnhgw8+UO/PnDnTYLJSU+Tn/g4aNEjN//HgwYMMt52QkMCECRPUx61atcrVH3RZoT2zW0Yz7iQnJ/PWW2+RkJCQF83KMu392bFjR4bv9YcffmjSOXTUqFHq/XXr1mX4GX706FGdIHV6Bg0apCaODgoK4scff0y3bGhoqM6FoezSngbd1OGqmdW6dWv1x/GtW7c4duyYTvA7vcTR2l627xPGaH/ubtq0KcMLOnfu3OHbb7/VWTcrPbpMHY6WnJysM5Tq+YkY8vOcu2TJEv755x+TP6+Tk5P56quv1MeWlpa0adMmy9t/3tKlSxk2bJj6uFixYjn6/ykKKEUI8coKDAxUnJ2dFUABFEtLS2Xy5MnKkydP9MrGx8crS5cuVYoUKaKWNzMzU1asWJHhNlq0aKGWP3DggEntOnDggKLRaNT1BgwYoISFhemUiYiIUAYNGqQAipWVlVp22LBhButMSkpSWrdurZZzcnJS5s6dq8THxxssHxERoaxYsUJp0aKF0rdvX4NlypQpo9Z369Ytk/YtM65fv644ODio22jcuLFy48YNnTLJycnKb7/9ppibm6vlJkyYkG6dixcvNvpaZcXdu3cVNzc3te5y5copu3btMlg2LCxM+fvvv5WPPvpIb1l8fLxSs2ZNtZ5ixYopPj4+euX27t2ruLu7q+Xq1KmjJCQkGNxeZo/Br776Si3/1VdfGS3/9OlT9Rg0NzdXevbsqa4/adIko+un7Y/2e9ipUyfl4sWL6ZY/c+aM8vHHHysuLi5KYGCg3vKsvM8xMTFKxYoV1fXKly+vBAQE6JVbv369Ym9vr1hbW6tlM/q6oN0WQBk6dKhy584dg2VTUlIUX19f5Z133lFsbW2VyMhIvTKZfX8OHDiglm/RooXBMomJiUqTJk3UcnZ2dsoff/xh8JiKj49XtmzZovTs2TNP9jczfvzxR51tf/7553rnuIcPHyodO3ZUy1hYWCh+fn5G98WU4+jWrVtq+TJlymRrXy5duqTzOfDhhx8qMTExOmUePHig9OjRQwEUe3t7o++zKcfC80w5xk3x9OlTxc7OTq1r8ODBBj/XRo8erbc/Gb2WrVq1Usu5uroq27dv1yuze/du9fxsaWlp9HNr6tSpahmNRqP88MMPSlJSkk6Zq1evKrVr19b7DF68eLHBOk35v01KStJ5jfz9/dPd7zRZeU8nTZqkrtOzZ0/FzMxM3Y+nT58aXT83vk+YKreO4U6dOqllHBwclHXr1umVCQgI0PmMKFWqlN4xnMbY+z18+HDF29tbWbp0abp1PHnyRBkxYoTO6/z8OUBR8u+c+8knnyiAUqVKFeXHH39Ubt++nW7ZCxcuKO3bt9dp57vvvmuwrPb+GDuPxsbGKtu2bVPatm2rU7etra1y4sSJDNcdNmxYrnwfFK8WmU1MiFdYtWrV8PX1pVOnTgQHB5OYmMh3333HTz/9ROPGjSlTpgxWVlY8ePCAY8eO6SSetLa2Zvny5TozO+SUli1bMmnSJGbMmAGkdkPftm0brVu3plixYjx69AgfHx+ioqJwdXVl4sSJTJ06NcM6zc3NWbduHe3atePMmTM8e/aMt99+m48//pjGjRtTsmRJzM3NCQsL48qVK1y6dEmdcrRPnz45vo+mqFChAgsWLGDw4MEkJydz/PhxKleujLe3NxUqVCAqKoojR47oXEFt1KgRP/30U563tVSpUqxbt46ePXsSFRXFrVu36NixI2XKlKFBgwa4ubkRFRXF1atXOXv2LImJifTo0UOvHisrK1avXk2LFi0ICQnh4cOHtG7dmpo1a1KrVi0gNU+DdlfrIkWKsHr1ap2pafOSq6srnTt3ZvPmzSQnJ7N582Z1mSlXmQHatm3LX3/9xTvvvENycjI7d+5k165dVK1alRo1auDk5ERMTAwPHjzg3LlzhISE5Ph+2NrasmTJEtq1a0dsbCw3b96kfv36NGzYkKpVq5KQkIC/v7+aK2LOnDmMHz8eyDjXx/Dhw7l58ybTp08HUoeqrFy5klq1alGlShUcHByIiooiODiYs2fP5sh0wZllYWHB2rVrad26NdeuXSMmJoZx48YxZcoUmjZtSvHixUlKSuLOnTucOnWKZ8+e4ezsbLCu/NzfSZMm4evrq+Y/+eabb/jrr79o1aoVrq6uBAUFceDAAZ1hPTNmzNDJg/KiqFKlCm+88YY6tGnmzJmsWrWK+vXrU6RIEW7fvs3hw4dJSEjA0dGRGTNm5FvvQFO4uroyadIkvv76ayC1F+HOnTtp2LAhJUuW5MGDBxw8eJDo6GgsLCz4888/da7yp2fhwoU0btyYR48eERYWRpcuXahWrRp16tRBo9Fw5swZtYflBx98wIYNG4wmp/7ss8/Yu3cvR48eRVEUPv30U2bNmkWLFi1wcHDg+vXrHDlyhOTkZBo2bEiFChVM6nVkjLm5OT179lTratmyJR07dqR06dJqPjk3NzcmT56cre0MGTKEn3/+GUDnfN2lSxeTZqN6Gb9PGLN48WJ1ptmoqCj69++Pp6cnDRs2xMrKiosXL3LixAm1F4y9vT2rV69We+VklqIoHDlyhCNHjmBubk6VKlV47bXXcHV1JTY2lnv37nH06FGdHn8///yzwfx7+f0Zc/nyZT755BM++eQTPDw8qFGjBu7u7tjY2PD06VPOnz/PpUuXdNZp0qSJTg+r9Dx9+lT9nE0TExNDeHi4uj/PD6n08vJixYoV6ncmU5w4cUJvO8bMmDEjw3yI4hWRz8EoIUQeePTokfL2228rFhYWOlcW0ru1b99e+e+//0yqOys9g9J8+umn6hU7Q7cSJUoox44dy9TV65iYmEztq62trfLdd98ZrCu3ewal2bp1q1K0aFGjbX399deV6OjoDOvKrZ5Bac6ePavTsyej2+DBg9Ot58qVK+pV54xuderUUa5fv55hm3K7Z5CiKMo///yj17bq1aubtK42Hx8fxdPT06TXD1C8vLyUe/fu6dWTnff5+V5Xz9/MzMyUqVOnKgkJCepzzs7ORutdu3atUqJECZP3rUGDBkpcXJxePbnRMyhNaGio0qtXL5PaV7JkyTzZ38xKTExUxo8fr9PTzNDN2dk53V4cafKzZ5CiKEp0dLTe1fTnbx4eHoqvr69J73N+9gxSlNQeJUOHDs1wf1xcXJRNmzZl6rU8f/680fPG6NGjlYSEBJM/tyIiInR6kBm6NWnSRLl//75OD4Ps9AxSFEW5ffu2UqxYsXS3+fxrkZX3VFEUpVq1anp1b9iwweT1FSVnv0+YKjeP4YcPH+r0eErvVrFiRaO9toy93+PHjzf53Ojo6KjMmzfP6H7m9Tl38+bNStWqVU3eHqT2xJw4caISFRWVbr3P93Qy9VapUiVl5syZSmxsrEnt1/6/zcotvR5d4tUiPYOEKACKFCnCX3/9xSeffMLmzZvZtWsX169f5/HjxyQmJuLu7o6HhwetW7emR48e1K9fP0/a9f3339O3b1/+/PNPfHx8ePDgAQ4ODpQtW5bevXvz1ltvUbhwYa5cuWJynba2tuq+rlixAh8fH65evUpoaCgpKSk4OztTvnx5atasSZs2bejYsSNOTk65uJfGde3alevXr7No0SK2bdvGhQsXePLkCba2tpQoUYJWrVoxdOjQF+Lqfs2aNTlz5gybN29m8+bNHD9+nEePHhEdHY2TkxPly5enQYMGdOvWjQ4dOqRbT6VKlQgICOCff/5hw4YN+Pv78/jxYyD1eG3YsCF9+/alT58+eTZrWka6du2Ki4sL4eHh6nPGEkcb0qpVKy5dusTmzZvZvn07fn5+PHz4kGfPnmFnZ0fRokWpUqUKTZo0oVOnTpm68meqtm3bcvnyZebMmcPmzZu5efMmiYmJlCxZkubNmzNmzBjq16+vk9PElKvD/fv3p0ePHqxZs4bdu3dz8uRJQkJCiIqKwt7enpIlS/Laa6/h7e1N586dqVSpUo7vmzFubm5s3LiRkydPsmrVKg4ePEhwcDBhYWHY2tri4eFBrVq16NixI3379s2wrvzaXwsLC37//XfefvttFi1axP79+wkKCiIyMhI3NzcqVapE586dGT16tE6OlheRnZ0dO3fuZNWqVSxdulTthVG4cGHKly9Pnz59GD58OK6urhw8eDC/m2uUubk5S5cupV+/fsybN48TJ04QFhaGq6srpUuXpkePHowcOZISJUroTA1tjJeXF//99x/z5s1j7dq1XL58mZiYGIoXL079+vUZNWoU7dq1y1RbnZyc2LlzJxs3bmTJkiWcPHmSp0+fUrhwYV577TUGDx7MkCFDcrxHZpkyZTh37hxz5sxhz549XL16lcjISLVnTU554403dHL/uLi40KVLl0zV8TJ+n8hI0aJF2b9/P7t27WLt2rX4+vry8OFDEhMTKVKkCLVr16Znz5458r7//vvvjB07ln379uHn58eFCxe4e/cukZGRWFhYUKhQIby8vGjfvj1vvPGGXq4gQ/L6nNujRw969OjBjRs3OHjwIMeOHePSpUvcunWL8PBwkpKScHBwoEiRIlSrVo1mzZoxcOBAihcvnuVtmpmZ4ejoiJOTE66urlStWpV69erRpEkTGjdunK39EcIQjaK84GnZhRBCCJHn9u7dS/v27QHo2LEjO3fuzOcWCSGEEEKInCKziQkhhBBCz9q1a9X7edVbUAghhBBC5A3pGSSEEEIIHSdOnMDb21tNXHnp0iWqVKmSz60SQgghhBA5RXoGCSGEEAXE3bt36devH76+vhi6FpScnMyKFSvo0KGDGgjq3r27BIKEEEIIIV4x0jNICCGEKCBu375NuXLlgNRE3XXr1qV48eKYm5vz6NEjjh8/rjOtffHixTl16lS2EmIKIYQQQogXjwSDhBBCiAJCOxhkTL169fjnn38oU6ZMLrdKCCGEEELkNQkGCSGEEAWIv78/W7duxc/Pj+DgYJ48eUJ4eDgODg4ULVqUxo0b07t3b7p165bfTRVCCCGEELlEgkFCCCGEEEIIIYQQBYgkkBZCCCGEEEIIIYQoQCQYJIQQQgghhBBCCFGASDBICCGEEEIIIYQQogCRYJAQQgghhBBCCCFEASLBICGEEEIIIYQQQogCRIJBQgghhBBCCCGEEAWIRX43QLx84uLiCAwMBMDd3R0LCzmMhBBCCCGEEEKInJaUlERISAgA1atXx8bGJkfqlV/xItMCAwNp0KBBfjdDCCGEEEIIIYQoMPz9/alfv36O1CXDxIQQQgghhBBCCCEKEOkZJDLN3d1dve/v70/x4sXzsTVCCCGEEEIIIcSr6cGDB+rIHO3f4tklwSCRado5gooXL46Hh0c+tkYIIYQQQgghhHj15WS+XhkmJoQQQgghhBBCCFGASDBICCGEEEIIIYQQogCRYJAQQgghhBBCCCFEASLBICGEEEIIIYQQQogCRIJBQgghhBBCCCGEEAWIBIOEEEIIIYQQQgghChAJBgkhhBBCCCGEEEIUIBIMEkIIIYQQQgghhChAJBgkhBBCCCGEEEIIUYBIMEgIIYQQQgghhBCiALHI7wYIIYQQQgghRHalpKQQFRXFs2fPSEhIIDk5Ob+bJIQQmJubY2dnh4uLCzY2NvndHJUEg4QQQgghhBAvtcjISO7du4eiKPndFCGE0JGUlER8fDxhYWE4OztTvHhxNBpNfjdLgkFCCCGEEEKIl5ehQJBGo8Hc3DwfWyWEEKmSkpLU+xEREVhZWVG4cOF8bFEqCQYJIYQQQgghXkopKSk6gSAHBwfc3Nyws7N7Ia68CyFEcnIy4eHhPH78GICQkBCcnJywsrLK13ZJAmkhhBBCCCHESykqKkonEOTh4YG9vb0EgoQQLwxzc3MKFSpEoUKF1OeioqLysUWpJBgkhBBCCCGEeCk9e/ZMve/m5iZBICHEC8vJyUm9Hx0dnY8tSSXBICGEEEIIIcRLKSEhAUjNEWRnZ5fPrRFCiPRZW1urAeu0c1d+kmCQEEIIIYQQ4qWUNn28ubm59AoSQrzQtBPbp6Sk5HNrJBgkhBBCCCGEEEIIUaBIMEgIIYQQQgghhBCiAJFgkBBCCCGEEEIIIUQBIsGgV8CKFSsYM2YM9erVU5NSLVmyJL+bJYQQQgghhBBCiBeQRX43QGTf559/zp07dyhcuDDFixfnzp07+d0kIYQQQgghhBBCvKCkZ9ArYMGCBdy+fZuQkBDefvvt/G6OEEIIIYQQQqSrZcuWaDQaWrZsmd9NEaLAkmDQK6Bt27aUKVMmv5shhBBCCCGEKCCio6OZO3cunTt3pmTJktjY2GBtbY27uzv169dn5MiRzJ8/n6CgoPxuao46ePAgGo3G4M3Ozo5SpUrRtWtXFi1aRHx8vNH60tY1FhhLSkpiwIABavlGjRoRHh6eMzslCqQCPUzs8ePH+Pv74+/vz8mTJzl58iShoaEADBs2LFN5d+7cucPs2bPZvn07QUFBWFtbU6FCBfr378+4ceOws7PLpb0QQgghhBBCiLxz/PhxBg4cyN27d/WWPXnyhCdPnhAQEMDixYspWrQoDx8+zIdW5r3Y2FiCg4MJDg5m+/bt/PLLL2zbto2yZctmq97ExEQGDBjApk2bAGjWrBk7duzA0dExB1otCqoCHQwqWrRojtSzdetWhgwZwrNnz9TnYmJiCAgIICAggAULFrB9+3YqVqyYI9sTQgghhBBCiPxw9epVOnToQGRkJADdu3enb9++VKpUCSsrK548ecK5c+fYu3cvBw4cyOfW5q533nmHsWPHqo8fP37M+fPnmTFjBsHBwVy4cIHu3btz5swZzM3Ns7SN+Ph4+vbty7Zt24DUIXbbtm3D3t4+R/ZBFFwFOhikrXTp0lSpUoU9e/Zkar0zZ84wYMAAYmNjcXBw4LPPPqNVq1bExsayZs0a5s+fz9WrV+nSpQsBAQESvRVCCCGEEEK8tKZMmaIGghYvXszw4cP1yrRr145JkyYREhLCunXr8riFeadIkSJUq1ZN57nWrVszYsQIatSowe3btwkMDGTTpk307ds30/XHxcXRs2dPdu/eDaS+rv/++y+2trY50n5RsBXoYNCXX35J/fr1qV+/PkWLFuX27duUK1cuU3VMnDiR2NhYLCws2LNnD40bN1aXtW7dGk9PTz7++GOuXr3KzJkzmTp1ql4dH374oUnjSbW36enpmal2Cji++Qb2zlZUa+GBmZkmv5sjhBBCCCHESyU5OZnt27cDUK9ePYOBIG3u7u6MGzcuD1r2YnF0dOTzzz9n1KhRAOzbty/TwaCYmBi6d+/O/v37AejUqRMbN27ExsYmx9srCqYCHQyaNm1attb39/fnyJEjALz55ps6gaA0H374IYsXL+bSpUvMmjWLKVOmYGlpqVPm77//Jjo62uTt9u3bV4JBmfTo1jNO774DClzxe0jLIVVwLyW9tIQQQgghhDBVSEgIsbGxAHmSAsPX15e///6bI0eO8PDhQ2xsbChXrhxdunRh4sSJuLu7663z888/89FHH2FhYUFYWBgODg46y+Pi4nBxcVEvxp85c4ZatWrp1VOlShWuXLnCgAEDWLNmTabbXr16dfV+ZpNoR0VF0bVrVw4dOgSkDsVbv349VlZWmW6HEOmR2cSyYfPmzer9ESNGGCxjZmbG0KFDAQgPDzc4bjYqKgpFUUy+yRSMmZOcnMKBlZdBSX38+E4k678P4OiG6yTGJ+dv44QQQgghhHhJaAcjLl26lGvbSUlJYfz48Xh7e7NixQru3LlDfHw8ERERnD17lm+//RZPT0/27t2rt26LFi2A1Nm3fH199ZafOHFCZ1TGwYMH9co8evSIK1euAGT5t5f2a/V8Z4CMPHv2jI4dO6qBoL59+/LPP/9IIEjkOAkGZUPaycXe3p66deumWy7thARw9OjRXG+X0BV8OYzQ4Cid55QUhbN777J62gluBz7Jp5YJIYQQQgjx8nBzc6NMmTIAnDt3jh9//JGUlJQc386nn37KH3/8AUC5cuWYO3cu/v7+HDhwgPfffx9LS0siIiLo2rUr586d01m3Tp06ap5WQ4Ge558zVkb7t1xmaAfLTJ1NLCIigvbt26u/GV9//XVWr16dqWCSEKYq0MPEsivtH7xixYpYWKT/UlapUkVvHZF3yngVosf7tVjz13/Yxul+WEU+jWP7H/9RoU4RvAd4Yu9snU+tFEIIIYQQuSElRSEsJiG/m5GnXO2sci1H5oQJE5g0aRKQGrSZO3cu3bt3p0mTJjRo0CDTOVifFxgYyMyZMwGoVq0aR44cwcXFRV3esmVL2rdvT5cuXUhISOCtt97ixIkT6nJzc3OaNWvGzp07DQZ60nrcdOvWja1bt3L48GFSUlIwMzPTK1O0aFFee+21TO9DcnIyM2bMUB+bki8oIiKCtm3bEhAQAMDQoUNZvHixTruEyEkSDMqiuLg4njxJ7VHi4eGRYVlXV1fs7e2Jjo7O9HhRUyxYsEDtpRQYGKg+l3bya9asmZq8zBTBwcEZLn/w4EHWGpqPzifG85d1NA2woHGcBebofjjeOP2YoIuhNO5VAS/vkmgkwbQQQgghxCshLCaBut/sy+9m5KlTn7elkEPuXOR8//33uXjxIosWLQLg9u3bzJ49m9mzZwOpAZSWLVsyePBgunbtikaTue/Vf/31l9rbaMGCBTqBoDQdO3Zk5MiRLFiwAH9/f06ePEn9+vXV5S1btmTnzp2cOnWKqKgoNW9QfHw8fn5+AHzyySfs27ePsLAw/vvvP528QWm/o5o3b56ptoeEhBAYGMiXX37JmTNngNRAULNmzYyue/bsWfX+66+/LoEgkevk6MqitOkUAb2kZIbY29sDqfmBcpqvry9Lly5l6dKlnD59Gkgdjpb2nKGxshkpVapUhrcGDRrk+D7kpuj4JKZtvUiyBo7bJLHYMZ67Fvq5ghLikjm0+iobZpwi9F7Ov09CCCGEEEK87MzMzFi4cCF79uyhY8eOeiMkHj16xNq1a+nevTsNGjTgxo0bmap/377UwJ2XlxcNGzZMt9zo0aP11kmTXt4gf39/YmNjcXZ2plGjRjRq1AjQHRb2+PFjdTSHsXxB06ZNQ6PRqLciRYrQpk0bjh49ip2dHR988AGrVq0yvtOgEzQ7fvw49+/fN2k9IbJKgkFZFBcXp943JZmXtXVqZD4t+35OWrJkSYYJp5csWZLj23yZBN6LICI2UX0cZq6w1j6BHbYJxGoUvfKPbj1j3bcnOb7pBokJkmBaCCGEEEKI57Vr146dO3cSGhrKjh07mDZtGt26dcPZ2VktExAQgLe3t8kjC+Lj47l27RpAhoEggNq1a6u5dM6fP6+zrG7duuoFe+1Aj/bICXNzczXYo10mbYgYZD1fEECtWrV49913Tc7306xZMwYOHAik9rZq06YNDx8+zPL2hTBGgkFZZGNjo95PSDA+BjktY72trW2utSmnBAUFZXjz9/fP7yZmSqPyhdj3QQs6ehX7/yc1cME6mYWOcZy3TNJbJyVF4fTuO6z5+gR3L4TmYWuFEEIIIYR4eTg5OdGpUye+/PJLtmzZwqNHj1i0aBGurq5AaoqJL774wqS6wsLC1PtFihTJsKylpSWFChUC4OnTpzrLLCwsaNq0KWA40JMWBEr7m5Y3SLuMu7s7Xl5eGbbhnXfeITAwkMDAQM6cOcPWrVsZNmwYZmZmHDt2jJYtWxISEpJhHWnMzMxYvnw5PXv2BODq1au0a9eO0FD5LSJyh+QMyqK0DPVg2tCv6OhowLQhZfnNWA6kl1EJF1vmvlGXA5cf89WWC9x9GgNArBnstE/kQmIy7WItcUvRjY8+exLH1t/P4Vm/KM36eWLnJFM6CiGEEEK8TFztrDj1edv8bkaecrXLv++s1tbWjBgxghIlStCxY0cANm7cyLx58zKVAyezuYae17JlS3bv3q3mDbK2tub48ePqMkjtfWRjY6OTNygtGGRKvqAiRYpQrVo19XGtWrXo2rUrrVq1Yvjw4dy+fZtRo0bx77//mtRmCwsL1q5dS48ePdi1axfnz5+nffv2+Pj46PS4EiInSDAoi2xsbChUqBChoaFGEy6HhYWpwaBSpUrlRfNEOlpVKULjCoX488B15h66SUJy6hWAu5YpLLGIp1GcBQ3j9RNMXzv5iLsXUhNMV21aQhJMCyGEEEK8JMzMNLmWTFmkr0OHDpQqVYqgoCDCwsIIDQ3F3d09w3XSehNBau6hjCQlJam9Ztzc3PSWP583yNHRkZiYGJydnalduzaQGrhq1KgRBw8e5ODBg3h4eHDhwgXAeL6gjAwbNoytW7eyYcMGtmzZgo+PD61btzZpXSsrKzZu3EiXLl04cOAAp0+fplOnTuzZs+el6FggXh4yTCwbqlatCsD169dJStIfapTm8uXL6v2sTE0ocpaNpTkftK/Mrve8aVaxsPp8sgaO2iax1DGeYHP9XEHxMUkcXHmFTb+c5un96LxsshBCCCGEEC+dEiVKqPdN6eljbW2Np6cngM508YacOXOGxMTUvKDavXPS1K9fX53E5+DBg2qPn7R8QWm08wYdPnwYRUnNKZqdfEEA3333nbqdyZMnZ2pdW1tbtmzZQuPGjYHUhNLdunXLlfyzouCSYFA2pE0RGB0dzalTp9Itp52ELG3sqsh/5d0dWP5mA35/vTZFHP//alGoucJqhwR22SYQZyDB9IPrEaz91p8TW26SlCgJpoUQQgghhHheTEwMFy9eBFLzCqXl9zGmbdvUIX0XLlzIMFfpggUL9NbRZmFhQZMmTQDUnj+g3+NHO2+Qj48PAIUKFTIYYMqMSpUq0b9/fyA1sLV3795Mre/g4MDOnTupW7cukLoPvXv3NilfrRCmkGBQNqQl9wJYvHixwTIpKSksW7YMABcXF1q1apUXTRMGXPzrJ+5tXKNG+yH1CkW3miXY92ELhjcpizr6SwOB/0swfdFQgulkhYAdt1nztT9Bl5/qLRdCCCGEEOJVExUVRcOGDdm2bZuacNmQlJQUJkyYQGRkJADdu3c3OQfQO++8o+YWeuutt3j27JlemT179rBw4UIAGjRoQP369Q3WlRboOXXqFEePHtV5Lk3Dhg2xtrYmLCyMFStWAKn5grKbswhSewSl1fPNN99ken1nZ2d2795N9erVAdi1axcDBgzIcFSKEKaSYFA2NGjQAG9vbwAWLlyoJiTTNnPmTC5dugTAxIkTTZ5aUOSs8MvnSZ6zmGeTp3Hqjd4k3Luns9zJxpKp3b3YMr4ZtUq5qM/HmMF2+0TW28cTbqb/gRcREsuW386yb/FFYiMlSi+EEEIIIV5t/v7+dOvWjdKlSzN+/HhWrlyJr68v586d49ChQ/z222/UqlWLRYsWAakBjenTp5tcf/Xq1fnwww8BOHfuHHXq1GH+/PkEBARw6NAhJk2aRNeuXUlOTsbKyoq///473bq08wY9ny8ojY2NDY0aNQIgIiICyF6+IG3VqlWje/fuQGrPI19f30zXUahQIfbu3UvlypUB2Lx5M0OHDs0wGCeEKQp0AmlfX1+uX7+uPn7y5Il6//r16yxZskSn/PDhw/XqmDVrFk2bNiU2Npb27dszefJkWrVqRWxsLGvWrGHevHlAajfBtJOayFtKSgoXJo3F7X8juuwDLnOpU3sc332HciPeQaM1ZrhaSWc2vtOENSeD+HHXZSJiU8ch37ZMYbFFPI3jLKhvIMH0lRMPuX3+CU37VKRK4+I5ciVBCCGEEEKIF4mFhQXFihXj4cOH3Lt3jz/++IM//vgj3fKenp6sXr2asmXLZmo7P/zwA9HR0fz555/cuHGDt956S6+Ms7Mz69ato1atWunW06BBA+zs7IiJSZ1J+Pl8QWlatmypk9oju/mCtE2ZMkWdTWz69Ons3r0703UULVqU/fv34+3tza1bt1i9ejW2trYsWLBAfneILCvQwaAFCxawdOlSg8uOHj2qdiVMYygYVLt2bdauXcuQIUN49uyZweRglSpVYvv27TrT0Yu8c2HLMtyuh+g8Z5WQQvzPfxCwZRNeM/7E7n+RdkidcWJQw9K09yrKDzsv88+p1NnikjRwxDaJS1bJtI+xpGSy7gdJfHQSPssuc/n4Q1oOroxrMfvc3zkhhBBCCCHyiI2NDffu3cPPz499+/bh5+fHlStXePToEXFxcdjb21OiRAlq1qxJjx496NOnD1ZWmZ/m3szMjD/++IOBAwfy999/c+TIER49eoS1tTXly5enc+fOvPfee0ZnJ7O0tKRx48bs378fSL/HT8uWLZk2bRqQOjNZjRo1Mt3m9NSvX5927dqxd+9e9uzZw8mTJ9Md1paRkiVL4uPjQ/PmzQkKCmLRokXY2toyZ86cHGurKFg0inYClQJm+PDh6QaDDMnopbpz5w6zZs1i+/btBAcHY2VlRcWKFenXrx/jx4/Hzs4uJ5r8QggODqZUqVIABAUF4eHhkc8tytiT2CesnjuRuitO42pgErBkcw3mw/pT+b3JmBn4sPK/9ZTPNwdy9VHU/z+pQM0Ec5rHWmKDfjTezEJD3Q5lqNuxLOaWMhpTCCGEECI3XLt2jaSkJCwsLNRZqIQQ4kWVlXNWbv3+LtDBIJE1L1swKM2BC9u48d1XND0VY3B5VElXPH/4BZf6jfSWJSansPjoLX7bd42YhP+fQcw+BVrHWlIl0XAnO5eidrQcXJmSlVxzZieEEEIIIYRKgkFCiJfJixQMki4LosBo5dWVgYsPcfiTNjwwEJtxuBfGvaEjOPfZBJKjdLsQWZqb8VbzCuz7oAUdvIqqz0ebwVb7RP6xjydCo5/ELfxRDJt/OcP+ZZeIi0rM8X0SQgghhBBCCCEyS3oGCaO8vLx0HicmJnLt2jXg5eoZpO30XT/8vv2A5ofDMDfwHxDtZkfpr6dTpG1ng+v7XH7EV1suEPQ0Vn3OUoEmcRbUi7fAzMDQMRsHS5r1rUilhsUk0ZsQQgghRA6QnkFCiJeJ9AwSIp/VKd2IUX8e5NR3A7hVTD8wY/80htDxH3Lq7SEkhYbqLW9dpSh73mvBhNYVsTRPXT9RA4dsk1jmGM99c/1eQnFRiexbcokts84S/sjwUDUhhBBCCCGEECK3Sc8gkWkva86g9FwNuczuH8fjvese1kn6y+PsLSn8ySQ8+r1hsEfPjZAovth8nmM3/j9opFGgVoI53rGWWBvoJWRuYUa9zmWp3b405hYSkxVCCCGEyArpGSSEeJlIzyAhXiCV3Ksw9qfdXJs9lgtlzfWW20QnEvXl95wc1I24oLt6yyu4O7ByVENmDayFu6M1AIoGzlgns8gpjiuWyXrrJCelcGLLTdZ+48/96+E5vk9CCCGEEEIIIUR6JBgkBGBuZk6/1hNosn4P+wZXIcpGv4zjmRtc6dKJa3N/QUnWDfBoNBp61CrJ/g9bMLxJWcz+1xkoygy22Cew0T6eZwYSTIc9jGHTz6c5sOIycdGSYFoIIYQQQgghRO6TYJAQWko4lmD85xt5uuArTnlZ6y23Skgh6bf5nOzehqiLF/SWO9lYMrW7F1vGN6NmKRf1+RuWKSxyiifAOokU9EdmXvS9z6qpflw9+RAZuSmEEEIIIYQQIjdJMEiI52g0GjrUG0jXlQc5OK4RTx30yzjeeMTtvn258N0UUuLj9ZZXK+nMxnea8G2vajjZWACpCaYP2CaywiGehwYSTMdGJrJ34UW2/X6OiJBYveVCCCGEEEIIIUROkGCQEOlwsXHhnQmL0az6Hd8G+hEh8xQwW7aRUx2a8/S4r/5yMw2DG5bBZ1JL+tT5/yRfjywUVjjE42OTQIKBXkJ3Lz5lzdcnOL37DsnJ+kEjIYQQQgghhBAiOyQYJIQRTSq1ZfDCQxz7vAv33fSXOzx8xqMRoznz0dskR0bqLS/sYM3M/jVZ+1YjPIukBpUUDZyySWaRUzzXLPQTTCclpnB80w3Wf3eShzcjcnyfhBBCCCGEEEIUXBIMEsIEdpZ2vDnkZ4qtX8XB1oVJMvCfY7P1EGfbNef+zn8N1tGwfCF2TPTm005VsLVMnbUs0kxhs30Cm+3iidTo9xIKvRfNhhmnOLTqCvExkmBaCCGEEEIIIUT2STBIiEzwKlmbUXN8OP/TMG6U0P/3sQuPI+L9T/EfNYDEx4/1lluam/F2iwrs/aA57asWTX1SA9esUljkFMcpqySU54eOKXD+8D1WTT3B9VOPJcG0EEIIIYQQQohskWCQEJlkaWbJ610/pdqGrfj0LEOcpX4ZR9//ON+hDbdWLjAYvPFwtWPe0HosHFYPD1dbABI04GOXmmD6sZl+rqCYZwnsnn+e7X/+x7MnkmBaCCGEEEIIIUTWSDBIiCwq61qesd/vJPjPDzlfwUJvuU1sEnHTZ+LfvxOxt28ZrKPNa0XZ+34LxreqiKW5BoCHFgrLHOM5YJNoMMH0ncBQVn99gjN77pIiCaaFEEIIIYQQQmSSBIOEyAaNRkM371G0XO/DweE1ibTRL+MUeIdr3bpw+fcfUJKS9JbbWpkzqUNldk5sTuPyhYDUBNMBNkksdoznhqEE0wkpHNt4nfU/BPDo9rMc3y8hhBBCCCGEEK8uCQYJkQPc7dx559M1xCz9gYDqtnrLLRMVlD+W4t+1Fc/OnzNYR8UiDqwa3ZBZA2tR2MEagGfmChvtE/jXLp4oAwmmnwRF8c+PARxee5WEWP1AkxBCCCGEEEII8TwJBgmRg1rW7EHPlYc4+l5LnjjpL3e6/YS7/QdybtokUuLi9JZrNBp61CrJ/g9bMKxxGcw0gAauWqWwyDGOM+kkmA48EMyqaSe4eSYkd3ZMCCGEEEIIIcQrQ6PI1ETCCC8vL53HiYmJXLt2DYCgoCA8PDzyo1kvvFO3fDnz9SQaH48wGHWNLOJAue9+xL1Z63TrCAyOYMrmQP4LjlCfK5FkRvsYS9xTDMdyy9UsjPeASji6GRizJoQQQgjxCrl27RpJSUlYWFjg6emZ380RQogMZeWcFRwcTKlSpYCc/f0tPYOEyCV1yzXjjQWHOD2tN8GFNHrLHR9H8WTUOALee5PkiAgDNUB1D2c2jW3K9J7VcLRJTVJ93yKFZY7xHLJJJNFAgulb556wetoJzu0PIiVFYr1CCCGEEEIIIXRJMEgYdeHCBZ2bj49PfjfppWFtbs0bA76l9Mb1HGpfnCQD/3H2u45xtl0LgrauN1iHuZmGNxqVwefDlvSuXRKAFA34/y/B9C0DCaYT45PxXX+Nf34IIORuZI7ukxBCCCGEENHR0cydO5fOnTtTsmRJbGxssLa2xt3dnfr16zNy5Ejmz59PUFCQ3rrDhw9Ho9Ho3czMzHBxcaFmzZqMGzeOs2fP5krbb9++bXD7Go0GGxsbSpQoQfv27Zk1axbPnhmfrKVs2bJoNBrKli1rtOwHH3ygbsvT09Pg6yNEXpBhYiLTcqub2qsuOSWZzXt/x+qn+VS8Z3hK+IhGr1Hnxz+xKlos3Xr8boby+ebzXH8clfqEAlUSzWkda4m9ot8DSaOBGq1L0aBbOaz+17tICCGEEOJVIMPE8sfx48cZOHAgd+/eNVq2aNGiPHz4UOe54cOHs3TpUqPrmpmZ8emnn/Ltt99mua2G3L59m3LlyplUtlSpUmzevJk6deqkW6Zs2bLcuXOHMmXKcPv2bYNlFEXh3XffZc6cOQBUqVKF/fv3U6JEiUy3X7y8ZJiYEAWQuZk5fTq8R52NuzjYtyJxlvplnP0ucaFDW64t/QslxXDAqFH5Qux415tPOlbBxtIMNHDZKplFjnGcs9KfUUxR4Nz+IFZPO8Gt/57k9G4JIYQQQogC5OrVq3To0EENBHXv3p1ly5bh5+fH6dOn2bNnDzNmzKB9+/ZYWhr4wvuc3bt3ExgYSGBgIOfOnWPPnj1MnDgRCwsLUlJS+O677/jzzz9zbX969Oihbj8wMJDDhw8zb948XnvtNSD1x3eXLl1M6iGUHkVRePvtt9VAkJeXFwcPHpRAkMhX0jNIZJr0DMo+RVHYc2IVEd/8RPXrCQbLRFT1oPrPf2JfPv2IcXBYDNO2XmTvxUfqcyX/l2C6cDoJpsvXdse7fyUcXK2ztxNCCCGEEPlMegblvX79+vHPP/8AsHjxYoYPH55u2ZCQENatW8e4ceN0ntfuGXTr1i2Dw6u2bt1K9+7dAXB3d+fBgweYm5vnyD5o9wwaNmwYS5Ys0SuTmJhI8+bN8fPzA2DGjBlMmjTJYH0Z9QxKSUlh1KhRLF68GICaNWuyb98+ChcunCP7Il4u0jNIiAJOo9HQodFg2q4/gO/o+jyz1S/jfDGYG917cP6Xr1ESEw3W4+Fqx/yh9VgwtB4lXVIruWeRwlLHeI7YJJJkIMH0zTMhrJrmR+DBYEkwLYQQQgghTJacnMz27dsBqFevXoaBIEgN4jwfCDJVt27d8Pb2BlKDSqdPn85SPVllaWnJN998oz7et29fputITk5m2LBhaiCobt26HDhwQAJB4oUgwSAh8pGbrRujP1xGysrfOFnLXm+5ZZKC+bzVnOjSgrCzAenW07ZqUfZ90IKxLStgaa4hRQN+/0swfcdQgum4ZA6vucqGn07xJFgSTAshhBBCCONCQkKIjY0FoGLFirm+vQYNGqj379y5o96/efMmM2fOpFu3bpQtWxZbW1tsbW0pU6YMAwYMYNeuXTmy/erVq6v3M5voOSkpicGDB7NixQoAGjVqxP79+3F1dc2RtgmRXRIMEuIF0LhqB/ouP8yJjzoQ4qy/3PluGPdff4PTX0wkJSbGYB22VuZ83LEKOyd606i8GwDh5grr7BPYbpdAjEa/F9Dj289Y910AxzZcJzFeP2gkhBBCCCFEGisrK/X+pUuXcn172jmHkpNTv6veunWLChUqMGnSJLZt28adO3eIi4sjLi6Ou3fvsm7dOjp16sQbb7xBUpJ+Ps3M0N5fU/IfpUlMTGTAgAGsXbsWgGbNmrFnzx6cnQ180Rcin0gwSIgXhJ2lHcPf/I1C65dzrJkbz6ePNlPAdv0eAtp78/DgnnTrqVjEkdWjG/HbgFoUdrACDVy0SmahYxyBhhJMpyic2XuX1V+f4M750BzeKyGEEEII8apwc3OjTJkyAJw7d44ff/yRlHQmPckJgYGB6v20ZMvJyclYWVnRrVs3Zs+ezb59+zh9+jT79u3jzz//xMvLC4AVK1Ywffr0bG1fO+BlyrTxAAkJCfTt25eNGzcC0KpVK3bt2oWjo2O22iJETpN5poV4wXiVrkeleQfZsPkH3H5dTakQ3R49jk9iCHt7Infa1qPu9NlYGOhqqtFo6Fm7JK2qFGHmniss97tDnBnsskvkgmUy7WMtcXsuwXRkaBzb5pyjYr0iNOvnib2zJJgWQgghxCsgJQVin+Z3K/KWrRuY5c51/wkTJqiJlD/99FPmzp1L9+7dadKkCQ0aNDB5ynZjzp07pw73srOzo379+gAUL16c27dvU7x4cb112rRpw9tvv83IkSNZsmQJM2fO5IMPPshyj5zvv/9evd+3b1+j5RMTE+nVqxc7duwAoF27dvz777/Y2hpIECpEPpNgkBAvIEszSwb2/oLbLV5nz3djabQrCMvnRnE57Qvg3IkWFPrsE8r0GoRGo9Grx9nWkq97VKNvXQ+mbDpP4L0IgixTWGIRT8N4CxrGWWCB7nrXAx5z98JTGveqgFezEmjM9OsVQgghhHhpxD6FGRXyuxV566MbYJ87SYrff/99Ll68yKJFi4DUmblmz57N7NmzAShatCgtW7Zk8ODBdO3a1eB31PQoisKjR4/Ytm0bn332mTo07N1338XGxgYAe3t77O31c22m0Wg0zJw5k+XLlxMdHc2+ffvo06ePyW0IDw/n0qVLfP/992zduhWAxo0bM2DAAKPr3r9/n/v37wPQokULtmzZorZbiBeNDBMTBcetw/D0Vn63IlPKFqrI6J93c/f397haSj92axeZSOzkb/B7owdx9++lW08NDxc2j2vK9B5eONpYkKyBYzZJLHWM5665fq6ghNgkDq26wsafTxN6LypH90kIIYQQQry8zMzMWLhwIXv27KFjx45YWOh+R3306BFr166le/fuNGjQgBs3bmRYX7ly5dBoNGg0GszMzChevDijR4/myZMnAHTp0oWvv/463fUTExMJDg7m0qVLnD9/nvPnz3P//n0KFSoEpPYwysjSpUvV7Ws0GlxdXWnSpAlbt27F0tKS4cOHs2vXLpNyBmkHvgIDA7l69arRdYTILxIMEgVDzFP4ZyT82RiOzobk7CWTy0sajYaurcfQeNM+fAd5EWOlX8Yl4BqXO7Xn8sJZKOmM2zY30/BG47L4fNiSXrVLAvDUXGGtQwI7bROINZBg+uHNCNZ9e5Ljm2+QlCAJpoUQQgghRKp27dqxc+dOQkND2bFjB9OmTaNbt246Q7ICAgLw9vbmwYMHmarbysqKpk2bsnTpUjUooy0xMZE//viDRo0a4eDgQKlSpahatSrVq1dXb48fPwZQg0pZ4enpyfvvv4+Tk5NJ5UuXLs1HH30EwNOnT2nXrh2XL1/O8vaFyE0SDBIFw94vIDoEkmJT789vBffP5nerMqWIQ1FGf/kPzxZP578q+t1NreNTUGbM5XjPNkReS/9Dx93Rml8H1GLV6IZUcLcHDZy3Tk0wfcFSP0iWkqJwetcdVn99gqCLBWy8vRBCCCGEyJCTkxOdOnXiyy+/ZMuWLTx69IhFixapU6g/ePCAL774It31d+/eTWBgIIGBgVy4cIE7d+4QGRmJr68vQ4cO1Rtm9vTpUxo3bsz48eM5ceIECQkJGbYvNjY2w+U9evRQt3/u3Dl27tzJxIkTsbGx4eLFi7Rs2ZIrV66Y+GrATz/9xPjx4wF4/Pgxbdu25ebNmyavL0RekZxB4tV32xfOrNB97uF/qQGhRmOh1WSwSn/c8YumVd2+PFvbnn/+/pDXlvji8txM865XH3K7Zy9ShvWhxntforEy0JUIaFKhMDsnNmf+kZv87nON2MQUdtgncj4xNcG063MJpp89iWPL7LN41i9Ks36e2DkZrlcIIYQQ4oVi65aaQ6cgsXXLt01bW1szYsQISpQoQceOHQHYuHEj8+bNw8xAUutKlSqZPFMXwMSJEzl16hQAPXv2ZOTIkdSoUYMiRYpgY2OjBo9Kly5NUFAQiqLf+12bi4sL1apVUx/XqFGDjh070q1bNzp27EhYWBiDBg3C398fc3Nzk9o4e/ZsYmJiWLRoEffu3aNNmzYcPnyYUqVKmbyfQuQ2CQaJV1+xGlB/NJxcAGh9GCgpcHwOXNoCXX+Fim3zrYmZ5WTtxMh353Oq0yFOTv2I+qcidZZbJAOLNnBi9z4q/vgrhes1NliPlYUZ41pVpHvNEkzbeoF9lx5z938JphvFWdAg3gLz5xJMXzv5iLsXQmnSuyKvNSkuCaaFEEII8WIzM8u1ZMoifR06dKBUqVIEBQURFhZGaGgo7u7u2arz2bNnrF27FoDBgwezYsWKdMuGhYVla1tt2rRh4sSJzJw5k9OnT7NkyRLefPNNk9bVaDTMnz+fuLg4Vq1axe3bt9WAULFixbLVLiFyigwTE68+Gyfo8jO8uQfcX9NfHn4XVvSBDaMhOutjivNDXc8WDFh2hNOTu/HIxcBsYvciePTGSE5++g4p0dHp1lPKzY4Fw+ozf2g9SrrYkqQBX9vUBNPBBhJMx8ckcWDFZTb9cpqnD9KvVwghhBBCFFwlSpRQ72dmVrH0XLt2jcTERIAMZ/e6fPkyUVHZnwRl8uTJar6gadOmGR2Sps3MzIylS5fSu3dvILXtbdu2JTQ0NNvtEiInSDBIGOXl5aVza926dX43KWtKNYAxh6HV52BuYIhT4DqYUw/OrgIj3UlfJNbm1gwe+hPFN63leMsipDz3OWumgMPmgwS0a0bw3q0Z1tWualH2ftCcd1pWwMJMQ6i5wmqHBHbbJhBnIMH0g+sRrP3GnxNbbpKUKAmmhRBCCCFEqpiYGC5evAik5hVKm90rO5KS/j+/ZXQGFzrnzp2b7W0BuLm5MW7cOACCgoJYunRppta3sLBg9erVdOrUCYALFy7Qvn17IiIicqR9QmSHBINEwWJhBS0+gneOQZmm+stjw2DzO7CsBzx9uRK9VS5enWF/+nBlxpvcKar/r+34NI7ICR9z/O2BJDxN/4qEnZUFn3Ssws6J3jQs5wYa+O9/CaYvGkownawQsOM2a6b7E3xZEkwLIYQQQryqoqKiaNiwIdu2bSMlnRlsAVJSUpgwYQKRkampDLp3754jPYMqVqyo1rN06VKD+YC2bt3KnDlzsr2tNO+//z52dnYA/PDDDyQnZ+4CqJWVFRs3blQvqJ8+fZqOHTvmSM8lIbJDgkHCqAsXLujcfHx88rtJ2VfYE4Ztg26zwcZZf/mtQ6nT0Pv+CsmJed++LDI3M6d310lU/3cnR7uXI8FAjjuXg+cIbNeS6+sWZ5hQz7OoI2veasQv/WtS2MGKGDPYbp/Ievt4ws30P/wjHsfy729n2bfkIrFRpnehFUIIIYQQLw9/f3+6detG6dKlGT9+PCtXrsTX15dz585x6NAhfvvtN2rVqsWiRYsAcHZ2Zvr06Tmy7UKFCtG5c2cAdu3aRfv27dm4cSOnTp1i586djBo1il69elG+fPls5ydK4+7uzujRowG4efMmq1atynQdNjY2bNmyhaZNUy9G+/n50bVrV6MznQmRmyQYJAouMzOoOwzGnQSvXvrLk+Jg31SY1wrunc7z5mVHSZfSvPnjdh7O/YQrZSz1lttFJ5H45U8cG9SZmKA76daj0WjoXceD/R+0ZEij0mg0cNsyhcWO8fhZJ5KMfjDpit9DVn11gkvHHhidvUEIIYQQQrw8LCws1ATI9+7d448//mDIkCF4e3tTq1YtWrZsyfvvv09gYCAAnp6e7N+/P1OzhRnz119/Ubp0aQD27dtHnz59qFevHp07d2bhwoWULFmSzZs3q715csKkSZOw+t8Mvd9//32GvaLSY29vz44dO6hXrx4Ahw4dolevXpnKQyRETpJgkBCORaHfEnh9DTiV1F/+KBAWtIFdkyH+5enOqdFo6OA9nOabDnB8aG2irfXLuJ25zdUunbjw108oGXR5dbaz5Jue1dk8tinVSzqTpIEjtkksc4znvrn+h2FcdCI+yy7x729nCH8Uk5O7JYQQQggh8omNjQ337t3j6NGjTJs2jU6dOlG+fHns7e0xNzfHycmJKlWqMGDAAFatWsX58+epW7dujrahVKlSnD59mo8++ohKlSphbW2Ns7MzNWvW5KuvvuLs2bNUrVo1R7fp4eHBsGHDALh06RIbNmzIUj1OTk7s3r2bGjVqALB7924GDBigkwtJiLyiUeTSvcik4OBgSpUqBaQmUvPw8MjnFuWg+Ejw+QZO/A0Ger3gXBq6/gKe7fK8adl1/Nx27nz9JTUvGA7OPK3ojteMP3B5rXqG9SSnKKw8cYcZu64QGZ8ECtRKMKd5rCXW6I8FN7PQUK9TWeq0L4O5pcSfhRBCCJFzrl27RlJSEhYWFnh6euZ3c4QQIkNZOWfl1u9v+WUmhDZrR+j0I4zaB0W89JdH3IWVfeGfkRD1OO/blw2Na3ah+5ojBLzbmqcO+svdrocQ1Lc/p7/7mJQMuquam2kY2rgs+ye1oGetEqCBs9bJLHSK47KhBNNJCv5bb7H2W3/uXwvLyV0SQgghhBBCCJEFEgwSwhCPejDmELT+AswNjK86vwHm1IczK16qaejtLO14Y+wfOK9fwskGLnrLLZLBdtlWTnRoxiO/wxnWVcTRht8G1mbVqIaUd7cn2gy22ieywT6eCI3+0LGwhzFsmnkGn+WXiIt+eZJyCyGEEEIIIcSrRoJBQqTH3BKaT4Kxx6Gst/7yuHD4dxws7QahN/K8edlRrVxDXl9ymMCp/Xnoqj+0y+VBJE+Gj8Fv0pskGZn2sknFwuyc6M1HHSpjbWHGTcsUFjvFc9I6kRQDQ+0uHX3Aqql+XDnxUBJMCyGEEEIIIUQ+kGCQEMYUqgDDtkL3OWDjor/89pHUaegP//xSTUNvaWZJ/4HTKLt5E35tSpD8XEzIDHDedozTbZtxZ9fGDOuytjBnXKuK7PugBW2qFCFRAwdtk1juEM8DAwmmYyMT2bf4IltmnSX8sSSYFkIIIYQQQoi8JMEgIUyh0UCdN2D8SajWR395cjz4TIe/W0BwQN63LxvKFa3MsDl7uf3rWG4XN9db7hgeT8x7Uzg6qg/xIRnnSSrlZseCYfX4+426lHC24bGFwkqHePbZJpBgoJdQ8OUw1kz3J2DnbZKTMj9FpxBCCCGEEEKIzJNgkBCZ4VAE+i6CQevBuZT+8scXYEFb2PlJ6sxkLwkzjRldO06g7r978etdmXgL/TJuvhc536E1l1fOzXB4l0ajoYNXMfZ92IIxLcpjbq7hzP8STF+11J++PjkxhRP/3mTddyd5cD08B/dKCCGEEEIIIYQhEgwSIisqtYexftBoLGie/zdS4MRc+KMRXNmVL83LqiJOxRnx3WbC53/F5fJWesvtYpJRps/iaP/2RN25mWFddlYWfNbpNXZM9KZBOTeizOBf+wQ22cfzzECC6af3o9n482kOrLwsCaaFEEIIIYQQIhdJMEiIrLJ2gI7fp05DX7S6/vJnwbB6AKwfDpGP8rx52dGy8UBabzrMyZENibLRX14oMJgbXbtybvZ0lGT93j7aKhV1ZO1bjZjZryaF7K24bpnCIqd4AqySDCaYvnjkPqumneBawCNJMC2EEEIIIYQQuUCCQUJkV8m68NYBaDsVLAxETi5sgj/qw6mlL9U09M7Wzgz9eAlmK3/nXHUHveVWiQpWf67iWNfmhJ4/nWFdGo2GPnU98PmwJYMblibJDA7YJbLCIZ5HhhJMP0tgz4ILbJtzjmdPYnNsn4QQQgghhBBCSDBIiJxhbgnN3od3jkG5FvrL4yJg67uwpCs8uZb37cuGul5t6bXGl7MfdiLUUX+5262nPOg/GP9p75ESH59hXc52lnzbqzob32mCVwknHlkoLHeIx8fGcILpuxeesnraCU7vvkNysiSYFkIIIYQQQoicIMEgIXJSoQow9F/o+RfYuuovv+MLfzWFQzMgKSHv25dF1ubWvD76F9w3riKgSWG95eYp4Lh6NyfaN+X+kb1G66td2pUt45sxrbsXDjYWnLJJZpFTPNct9IecJSWmcHzTDdZ/F8DDWxE5sj9CCCGEEEIIUZBJMEiInKbRQK1BMO4kVO+vvzw5Hg58A383hyD/vG9fNlQuVZtBCw5y+duh3C+kf/pweRRNxOh3OfreMJKePcuwLnMzDcOalGX/hy3oXrMEkWYKm+wT+NcuniiNfi+h0HtRbPjpFIdXXyE+NinH9kkIIYQQQgghChoJBgmRWxzcoc98GLwBXErrLw+5BAvbw/ZJEJdx4ORFYm5mTq8+n1F5yzZOdEzN//M8t13+nG7XjBtbVhutr4iTDbNfr83KUQ0p727PVasUFjrFcdoqCeX5oWMKBB66x6qpflw/9VgSTAshhBBCCCFEFkgwSIjc5tk2dRr6xuMNT0N/cj780RAu78iX5mWVR6FyDPt1Fw9+/5BbJS30ljtGJJLw8dccGd6D2EcPjNbXtGJhdr7nzaT2ldBYmrHfLpGVDvE8NtPPFRQTkcDu+efZ8ed/RD6Ny5H9EUIIIYQQQoiCQqPIpXVhhJeXl87jxMRErl1LTYIcFBSEh4dHfjTr5XT/DGx5Fx7+Z3j5a92h8wxwLJa37cqmp9FP2PbTWKpvDMQmUX95rK0Z1hPHUHXYBDQajdH67obG8NWW8xy4EoKZAnXjLWgaZ4El+utaWJvTsFs5arTywMxc4ttCCCFEQXLt2jWSkpKwsLDA09Mzv5sjhBAZyso5Kzg4mFKlSgE5+/tbfjkJkZdK1IbRB6Dd12Bhq7/80haY0wACFkPKyzN7lpt9YYZOW0fckh+4XNFGb7ltbApmP/yFb582RNy4YrS+0oXsWDS8PnOH1KWoiw0nbZJY7BjPTUMJpuOTOfrPddb/EMDjOy/PcDshhBBCCCGEyC/SM0hkWm5FJgucp7dg2/tw84Dh5aWbQLdZ4F4pb9uVTdEJ0fz7x/tUXHYEx1j95QkWGpJG9qXOu1+isdAfXqZXX3wSs/dfY6HvLZKSFSonmtMm1hJ7Rb+XkEYD1Vt50LB7eaxsjNcthBBCiJeb9AwSQrxMpGeQEALcysEbm6DX32Drpr/87jGY2xQO/gBJ8Xnfviyyt7Jn0PvzsF07n7O1nPSWWyUp2M1bz7HOzQg5e8J4fdYWfNb5Nba/602Dcm5csUpmoWMcZ630ZxRTFPjPJ5jV005w82xIjuyPEEIIIYQQQrxqJBgkRH7SaKDmQBgfADUG6i9PToCD38Ncb7jrl/fty4bqlZrRd5UvFz7tyRMn/V48bncjeDRoOMe/GEtyrIEuRM+pXMyRtWMa8XO/mtg7WrH3fwmmQwwkmI4Ki2fn3EB2/PUfUWGSYFoIIYQQQry6ypYti0ajYfjw4bm2jeHDh6PRaChbtmyubUPkLQkGCfEisC8Evf9O7SnkUkZ/+ZMrsKhD6rCyuIi8b18WWZpZ0nf495TcvJ4A76I8H7YxTwGX9Qfwb9+Uuwe3G61Po9HQt64HPh+2YFDD0jywTGGZYzyHbRJJfH4aeuDWuSesmnqCcz5BpKTIiFghhBBCiJyWlJTEhg0beOutt6hevTpFihTB0tISZ2dnKlasSK9evZgxYwa3bt3K76YWaIqisGXLFl5//XU8PT1xcHDAwsICFxcXqlWrRr9+/ZgxYwbnzp3L87a1atUKjUaDRqOhffv2Jq/XsmVLdT3tm7m5OW5ubtStW5eJEydy4cIFo3VNnTpVXf/gwYMZlvX19cXJyQmNRoOFhQUrVqwwuc0vEgkGCfEiqdA6dRr6Ju+Cxlx/ecCi1GnoL23N+7ZlQ/kSXgye58Ptn0Zzz13/tOMSEkv025M4Mv51EsKeGq3Pxc6K73pVZ8M7TahSwokTNkkscYzntoEE04nxyfiuu8aGHwMIuRuZI/sjhBBCCCFgy5YtvPbaa/Tt25f58+dz/vx5QkJCSEpK4tmzZ9y4cYPNmzfz8ccfU758ebp27cr58+fzu9kFzqNHj2jevDk9evRgzZo1XL9+nejoaJKTk4mIiODChQv8888/fPzxx9SqVYvLly/nWdvu3LnDoUOH1Mf79+/n/v372aozJSWFsLAwTp8+zezZs6lZsyY//PBDdpsKwMGDB+nYsSORkZFYWFiwatUqhgwZkiN15zUJBgnxorGyg/bT4a0DULyW/vLIB7B2CKwZDM+yd6LMS2YaM7p0/4DqW3cT0KUiSQbOPoX3neVs+xZc2bjUpDrrlHZly/imfNWtKkl25qy3T2CbXQLRGv1eQI/vRLL++5P4/nONhDj9fENCCCGEEMJ033zzDT179uT69etAai+Nn3/+mT179nDq1CmOHDnCunXrGD9+vDq0aPv27cyZMycfW13wJCQk0K5dO3x9fQGoXbs2s2fP5vDhw5w5c4ZDhw4xd+5cBg0ahLOzc563b/ny5SiKgrW1NRYWFqSkpGSpp01gYKB6O3XqFOvXr2fw4MEAJCcn89lnn7F+/fpstXXfvn107tyZ6OhoLC0tWbduHf37989WnflJptsR4kVVvCaM2g8n5sKBbyExRnf55W1w6zC0/QrqjgSzlyO2W9TFgzdmbuVgj+VET59B+aBEneWOkUmkTP6BQ5vWUe+nudgXL5VhfRbmZoxoWo4u1Yszffsltp67zy2LZJrHWVIzQfcUpyhwbl8QN04/psXrlSlbvXCO758QQgghxKtu0aJFfPHFFwAULVqUNWvW0LJlS4Nl+/Xrx2+//caaNWuYPHlyHrZSAMyfP5/AwEAARowYwYIFCzB77ndD8+bNGTNmDPHx8axevRoXF5c8a9/y5csB6Nq1K7GxsezYsYPly5fz8ccfZ6qeatWq6TyuU6cOffv2pWHDhrz77rsATJs2jX79+mWpnTt37qR3797ExcVhbW3NP//8Q9euXbNU14vi5fj1KERBZW4BTcbD2ONQoY3+8vhnsP1DWNwRHuddd86c0LL5GzTbepjTQ+oSa6W/vMjJm1zp2JGz82egpOgnidYr72TD76/XZvmbDShexJ49domsdogn1FCC6afxbP/jP3bNCyQ6/OWZqU0IIYQQIr8FBQUxbtw4AJycnPD19U03EJTG3NycwYMHc+7cObp06ZIHrRRp/v33XwAsLCz45Zdf9AJB2qytrRk+fDjFihXLk7b5+flx9epVAAYPHqwOtzp//jynT5/OkW2MGzeO0qVLA3DhwgUePnyY6Tq2bt1Kz549iYuLw9bWln///felDwSBBIOEeDm4loUhG6D3ArAz0Jsl6ATMbQYHvnuppqF3tnFh8OcrUJb/yqXKdnrLbeNTsJ65iCO9WvH0qmnjy7093dn1njcftqtEiA0sdYzH1yaRJAMJpm+cDmHVVD8CDwZLgmkhhBBCCBP88ssvxMWlztb67bffUrFiRZPXdXFxoVu3bukuf/jwIVOmTKFevXq4ublhbW1NqVKl6N+/P/v27Ut3vdu3b6vJf5csWQLA3r176datG8WKFcPa2ppy5crxzjvvEBwcbFJbDxw4wLBhwyhfvjx2dnY4OTlRvXp1Pvroowxz2mgnIgaIiIhg+vTp1K5dGxcXF502AkRHR7N27VpGjRpFrVq1cHZ2xtLSEnd3d1q0aMHPP/9MVFSUSW025O7duwAULlw4R3v8hIeH8+WXX+Ll5YW9vT0uLi40b96clStXmlzHsmXLAHB1daVLly707NkTR0dHnWXZZWZmhpeXl/o4KCgoU+tv3LiRPn36kJCQgJ2dHdu2baNDhw450rb8JsEgIV4WGg3U6AfjT0KtwfrLUxLh0I/wV1O4cyzv25cNdWt2pPOGowSOb8szW/3l7lceE9y7Hyd+/AQlMVG/wHOsLcyZ0MaTve+3wLuKO8f/l2D6joEE0wlxyRxec5WNM07xJDjrH7RCCCGEEK86RVHUYT2Ojo6MGDEix+peuXIlFStW5LvvvuPUqVOEhYWRkJBAcHAw69evp127dowaNYqkJOO5Hz/77DPat2/Ptm3bePToEQkJCdy+fZu5c+dSp04dLl26lO66cXFxvP7667Ru3Zply5Zx69YtYmNjiYyM5Pz58/z8889UqlSJrVuNT+hy7do1atWqxZdffsnZs2eJiNCfFbhLly4MHDiQhQsXcu7cOZ49e0ZSUhJPnjzh8OHDfPTRR9SoUSPLSZ2trFK74D969IinT41P1GKKK1euULt2baZPn87FixeJiYkhIiKCI0eOMGTIEMaPH2+0joSEBNauXQukDiW0srLC1taW3r17A7B69WqT3mtTpL0GAJaWliavt3btWgYMGEBiYiIODg7s2rWL1q1b50ibXgQSDBLiZWPnBj3/hKH/gms5/eWh12BxJ9g6EWLD87x5WWVjYUP/8b/jvGEZ5+q66i23TAKnxVs42rEp9wOOmFRn6UJ2LB5en7lD6mDjZs06+wR22CUQYyDB9KNbz1j/3UmOb7pOYoJ+0EgIIYQQoqA7f/48oaGhAHh7e2Nvb58j9a5bt4433niD6Ohoypcvzy+//MKuXbs4deoUGzZsoHPnzgAsXLjQaC6Z+fPn88MPP9CiRQtWrVpFQEAA+/btY+jQoQCEhIQwcuRIg+sqikLfvn1Zs2YNAN26dWP58uUcPXqU48ePM2vWLEqXLk10dDR9+/YlICAgw7b07duXe/fuMWHCBPbu3UtAQACrV6+mcuXKapmkpCSqV6/OlClT2LRpEydOnMDPz4+1a9cycOBAzMzMuHXrljpMKbPq1Kmj7tvo0aOz1csIICYmhm7duhEaGsrnn3/OwYMHCQgIYP78+Xh4eADwxx9/sHv37gzr2bZtmxqc0p6NK+3+48eP2bVrV7bamkY7+FemTBmT1lm5ciWDBw8mKSkJJycn9uzZg7e3d46050UhCaSFeFmVb5maS+jQj3B0NijPBTBOLYEru6DzT/Ba99SeRS+BKuXr47n8CNtWf4Pr7LW4R+gGbgrdiyTsjbe42aMZjb/4DXMjX0I0Gg0dqxXH29OdWfuvsdD3Fjct4mgRZ0n15xJMp6QonN59l2sBj2kxqDJlvArl+P4JIYQQIm+lKCmEx4fndzPylIu1C2aanL/u/99//6n304IM2fXkyRPeeustFEVh5MiR/P3331hY/P93tDp16tC7d2+mTJnCd999x6xZsxgzZoxOQEXbsWPHGD16NH///bc6VAugTZs2WFlZsWDBAvz8/Dhz5gy1a9fWWXfBggVs374dS0tLtmzZQseOHXWWN2rUiDfeeANvb28uXLjAe++9p87SZcj58+fZuXMn7du3V5+rW7euTpnFixfj6empt27Dhg3p378/b775Jh06dODKlSusXLmSN998M93tGTJ27FiWL19OSkoKGzduxMfHh27duuHt7U3Dhg3x8vLC3Nzc5PpCQkJISEjg+PHjOsOv6tatS8uWLalevTpxcXH8+eefGQ6nShsGVrZsWZo1a6Y+37p1a0qUKMH9+/dZtmxZtnPzbNy4Uc1L1KZNG1xd9S86G2rb0qVLSUlJwdXVld27d1O/fv1steNFJMEgIV5mlrbQdipU6wNb3oX7zyVai3oI64ZC5c7Q+WdwLpkvzcwsczNzegz+iuB2gzn01dvUOngPM62YkJkChTb74n+kKUWnfUX5tr2M1mlvbcHkzq/Ru05Jvth8nl23w7hgmUz7WEvcUnS/LEWGxrHt93N41itC036e2Dtb5/QuCiGEECKPhMeH02Jti/xuRp46NOAQbjZuOV7vkydP1Pvu7u7plktJSeHixYvpLq9cubI6XOevv/4iIiKCkiVL8ueff+oEgrRNmzaNpUuXcu/ePZYtW8a3335rsFzx4sX5/fffdQJBaSZNmsSCBQsAOHLkiE4wSFEUfvzxRwDeffddvUBQGldXV2bMmEHnzp05evQo165dMxjMARg+fLhOIMiQ9NZN07ZtW7p3787mzZvZvHlzpoNBDRo04O+//2bs2LEkJiYSHh7O8uXL1eF+9vb2NGnShH79+jFo0CCTentNnz5dJxCUpmLFivTs2ZM1a9ZkGCQLDQ1lx44dAAwaNEjnvTIzM2PQoEH8/PPPbN26lfDw8EznOkpISODmzZts2rSJb775BgA7O7t0j5nnLV68GABbW1v279+vFzR8VcgwMSFeBcWqw6h90PEHsDRwAr+yA/5oCCfmQcrLMwTKo0hFBv25l/u/TCC4iP4VC5fQeOLHT+bg232Je/rEQA36qhRzYu1bjfmpbw2inM1Z4hjPMetEkg0kmL4W8JjV005w4cg9FEkwLYQQQogCLjIyUr2fUdDg2bNnVK9ePd3bvXv31LJbtmwBUqcWt7ZO/wKchYUFjRs3BuD48ePpluvbt2+69VSuXBkHBwcAbt68qbPs4sWL3LhxQ60jI82bN1fvZ9SWwYMN5Pk0IiQkhGvXrnH+/Hn1lhZ4O3fuXKbrAxg1ahSBgYGMGDFCTdCcJjo6mr179/LWW2/h6elpdGiWRqNh0KBB6S5P6/n09OlTwsPDDZZZvXo1if/LA6o9RCxN2nNxcXGsX78+w/ZotyvtZm1tzWuvvcbkyZOJiYmhTp067Nmzh4YNG5pcF0BsbCzbt283aZ2XkQSDhHhVmJlDo3dgnB94GrgCkRAJOz+CRR3gUfpXal40Go2Gdp3GUmf7fs70fI1EA71Yix68QGD7llxYOw9FMR60MTPT0L9eKXw+bEn/hqU4apuaYDrIXD9QFh+TxMGVV9g08zSh9yXBtBBCCCEKLu1AQnR0dLbrS05O5uzZswDqsK6Mbv/88w9AhtODV6lSJcNtpg0T0g5sATr5fxo3bpxhO9ICSsbaUqNGjQzbkubo0aMMGDCAQoUKUaRIESpVqqQTPJs/fz6g2zMrsypXrsyiRYsIDQ3l2LFj/PLLLwwePFjN8wPw4MEDunbtmuHMbYULF6ZQofRTKbi5/X+PtOdf4zRLly4FUocAvvbaa3rLa9asSbVq1YDszypmZWXFm2++SdOmTU1e57vvvlOP9S+++IJff/01W214UUkwSIhXjUtpGLQO+i4CewPdd4NPwt/esH86JGY+CV1+KeRYlEE/bCRqwdfcKKN/tcchKhmzr37l0KCOPAu6ZVKdrvZWfN+7BhvHNqGohyNrHBLYaZtArIEE0w9uRLDum5P4bb5BkiSYFkIIIUQBpB0ECAkJSbeci4sLiqLo3IYNG6ZX7unTp1maMSomJibdZXZ2dhmua2aW+hM4OVn3+9zjx48z3Q5jbTElP83UqVNp1qwZ69atMzrbV2xsbKbb9zxLS0saN27M+++/z4oVKwgKCmL//v3qsK/k5GTGjh2b7gVWU1/ftLqed+nSJTXwZqhXUJo33ngDSA2U3bpl/Lt9YGCgejt8+DBz5syhQoUKJCQkMG7cOGbMmGG0jjSNGjVi27Zt6r5+8MEHzJ071+T1XxaSM0iIV5FGk5pHqHwr2PsFnFmhuzwlCY78DBc3Q7dZULaZwWpeRE0a9yN6Sye2/joBz1V+2CXoLi965i43unYh5e1B1BkzGY2Z8Zh3ndKubB3flGXH7/DL3qsssoyjVawlVRP1E0yf2nWHa6ce03JQZUq9lvNj8YUQQgiRs1ysXTg04FB+NyNPuVi75Eq9NWvWVO+fOXMm2/VpBwtGjRrFxIkTTVpPe6rwnKLdlq1bt1K2bFmT1itSpEi6y4wlZt6/fz/Tpk0DoHz58kyaNIlmzZpRunRp7O3t1fxJX375JdOnTzepPVnRunVr9u7dS7Vq1Xj69CnXrl3j7NmzuZIrR7unzwcffMAHH3yQYXlFUVi2bBlfffVVhuXSehKl8fb2ZujQoTRr1oz//vuPyZMn07JlS5MTQTdv3pzNmzfTrVs34uPjGTt2LHZ2duqsdK8CCQYJ8Sqzc4Mef0CNAbD1PXh6Q3d56HVY0gVqvwHtp4Ot8asXLwJ7awcGfrqY/7of5NLnH/HaRd3hWzbxCsxayeHtu6j60xzcq9YyWqeFuRkjm5Wjc/XifLP9Itv+e8D5xGTaxVri+lyC6WchsWyZdZZKDYvStI8ndk45/4VECCGEEDnDTGOWK8mUC6Jq1apRqFAhQkNDOXLkCDExMUZ7imREe0iRoih6P+jzknavJxcXlzxpS9rwL1dXV/z8/NJNym2sx1BOKF68OF26dFETS1+/fj3Hg0EpKSmsXLky0+stX77caDDIEEdHR5YtW0adOnVISkriww8/5PDhwyav365dO9avX0+fPn1ITExk5MiR2NjY0L9//0y35UUkw8SEKAjKNYd3joL3h2BmIAZ8ZjnMaQDnN4IJOXdeFDWqtqTr+qNc+qAr4QZyGBa5HsqDfq9z7Jv3SYmPN6nOYs42zBlUh2UjG6ApZsMSx3iOp5Ng+uqJR6ya5sfFo/dNylUkhBBCCPEy02g06tCeZ8+eqblfssrKykodnnT06NFsty87tAMfedWWCxcuANCqVasMZ2fTzmeUm0qUKKHeNzQbW3YdOHCAoKAgACZMmMDq1aszvL333nsA3LhxI8vvSc2aNdWE10eOHDGaIPt53bp1Y+XKlZibm5OcnMyQIUPYunVrltryopFgkBAFhaUttPkSxhyGkvX0l0c/hn9GwOqBEB6U9+3LIitzK3q/NYOim9byX0P9D1HLZHBdsYtjHZsSdHy/yfU2r+TOrveaM6FdJfwdU1jqGM89Qwmmo5M4sPwym385Q9jD7CdSFEIIIYR4kX3wwQfY2NgA8Nlnn5mUzyUj3bt3B+Dy5cvs3r072+3Lqjp16qjJlOfNm0dcXO7n1kzLl5RRMu4zZ85w4sSJLG8jMxcstYNO5cuXz/I205M2RMzc3JzPP/+cgQMHZnibMmWKOlQuO4mkp0yZouYySptqPjP69evHokWL0Gg0JCYm0q9fP/bu3Zvl9rwoJBgkREFT1Ave3AOdZoCVg/7yq7vgz0bgN/elmoa+fOka9FtykFvTh/HYVf/UVuhBNM9GjOfQpGEkpjOzwfNsLM2Z2NaTve83p9prhVnlkMBu2wTiDPQSun8tnDXT/Tmx9SZJiS/P6yaEEEIIkRmlS5dm9uzZAERERNCsWTN8fX0zXEdRlHSnGZ84caI6O9eIESPU3jLp2b59O//991/mG26EmZkZkydPBlKnnR86dCjxGfQsf/bsGXPmzMnWNj09PQHw9fXl+vXrestDQkLURMpZ1bt3b/7880+js78tWbKE/ftTL5yWLl06x4eIRUdHs3HjRiA1n09GuZbSFC5cmBYtWgCwbt26DN+PjFSpUoXevXsDqb2+Dhw4kOk6hg4dyl9//QVAfHw8PXv2zNSQsxeRBIOEKIjMzKHhWzDuBFTqpL88IQp2fQIL28HD83nfviwy05jRud+nVNm2k7PtypLyXO9WM6DINn9OtW/GlR1rTK63TCF7loyoz19D6vDY3ZJFTnFcstSf+SIlWSFg+23WfnOS4Cth2dwbIYQQQogX0+jRo9UcLvfv38fb25s2bdrw22+/sX//fs6cOUNAQADbtm3j66+/pnr16vz7779Aaq8Q7QTQRYsWZenSpWg0Gh48eEC9evV455132LJlC6dPn+bEiRNs2LCBTz75hAoVKtC1a1fu3r2bK/v19ttv06tXLwDWr1+Pl5cXM2bM4NChQ5w9e5bDhw8zb948Bg0aRIkSJZg6dWq2tpeWjDg6OpoWLVrw+++/c+zYMY4dO8bPP/9MzZo1uXjxIo0bN87yNoKCghg3bhzFihVj0KBBzJ07lwMHDnD27Fn8/PxYsmQJXbp0YcSIEUDq8LBff/01x4eJbdy4kaio1Dyfffr0MXm9tLLh4eFs2bIly9tPC/RB1noHAYwZM0adZj4mJoauXbvi7++f5TblN0kgLURB5uwBr69OnVVsx8epQ8W03TsF81pAk3ehxcepQ81eAkULleb133dyaN8i4r/5lVIPdQM3zmEJpHwwDZ+Nq2n8wzxsCxc1WqdGo6FT9eJ4V3Jn1r6rLDp6mwvxybSNtcTluQTT4Y9i+PfXM1RpXIwmfSpi6yAJpoUQQgjxapk6dSo1a9Zk0qRJ3Lx5Ex8fH3x8fNItr9Fo6NChAzNmzNDJTQOpvVf+/fdfhg8fztOnT5k7d266U3mbmZlhb28gWWQO0Gg0rF27lokTJzJ37lxu3LjBxx9/nG55U3q3ZKRv376MGDGCxYsXc//+fd59912d5ebm5vz666+EhYVx/PjxLG3Dw8ODU6dOERUVpebiSY+zszO///672osmJ6UN89JoNJmqv3fv3owfP56UlBSWLVtGv379srT92rVr07lzZ3bs2IGPjw9+fn40atQo0/W89957xMTEMGXKFCIjI+nYsSM+Pj7UqlUrS+3KT9IzSBjl5eWlc2vdunV+N0nkJI0GvHrBeH+oM0x/eUoS+P4CfzWBmy/XtKwt2o6k4fZD/Ne3JgkGQt/Ffa9yvkMbzq343eTx1A7WFkzpUpVtE5rhVtGZxY7xnLBOJMXA0LHLxx+y6qsTXPZ7IAmmhRBCCPHK6dWrF1euXGHdunW8+eabVK1alcKFC2NhYYGTkxPlypWje/fufP/999y4cYOdO3emO0tXt27duHXrFj///DOtW7emaNGiWFpaYmtrS7ly5ejatSu//PILt2/fplWrVrm2T5aWlvz555+cO3eOCRMmUL16dZydnTE3N8fZ2ZlatWrx5ptv8s8//3Dp0qVsb2/RokUsX74cb29vHB0dsba2pkyZMrzxxhscO3aMiRMnZqv+zZs3c/nyZWbNmkX//v3x8vJS98fe3p7SpUvTuXNnfvvtN65fv57tYWmG3Lt3Tw0UNm7cWC8YmJGiRYvStGlTAHbt2kVISEiW2zFlyhT1/vTp07Ncz+TJk/n8888BCAsLo3379jlyLOQ1jSK/UIQRaRn+0yQmJnLt2jUgtdthWqI18Yq47QtbJ6ZOO29IrSGp09DbvVxTtAYEbOXBl19S8abhZIAPa5Sg9k9zcSnraXKdKSkK/5wK5vudl7CITKJ9jBUlkg3H2EtWdqXloMq4FM369KtCCCGE0HXt2jWSkpKwsLBQ868IIcSLKivnrODgYEqVKgXk7O9vCQaJTMutg1G8QBLj4MhM8P0VUhL1l9sVhk4/QrU+qT2LXhJxSXFsn/UeZZYdwt5A/rl4Kw3xb/alwfiv0Jibm1xvWHQCP+66zFr/IGr+H3t3GR3l/fx9/L0bFwju7l5cQ3DXFioUaIHSAqUChbr8SpWWeiml0GKFoMUDxd3dXROcIPFks7v3g9zl3+QKZTeBTQKf1zk5B5jd2bnygGxm55pvghtBsR54Yfy+uLmbqdWuODVbF8fNQ4OZIiIi6aVmkIhkJZmpGaTfRkTEyMMbmr8PAzdAkbrGeMx1+OsFmPYk3HowC/weBG93b7oNG4v/7AkcrhpgiHsl2Mn+62zWdQzk8sEdDufN6efJyG7VmPNyQ+JL+PFH9jiOeRhPFLMm2ti+6AwzP9/OxRO30nMpIiIiIiIiaaZmkIjcXb6K0G8ZtP8GPLMZ4ydXwC/1YMsvWeoY+grlGtB15iZOvtWNm/7GCZ78Z25x7ann2PDxYKxOHGFZq3hOFr3SiKGdKrIqp5W5fvHcNtkMj7t5OYZ53+5mzZ9HiItOZfJKRERERETkAVIzSET+m9kMdV9MOoa+fAdj3BIDy96D31vApf2ury+N3MxudOr3GcUWzeNAo4KGuLsN8sxYzZbWDTizcanDed3dzPRvXIpVw5pSoWZ+JmaPZ8ddFkwf3nSJ4I+3cnz7ZS2YFhERERERl1EzSEQcE1AYnpkGT/0J/gWM8Yt7YFxTWPERJMS4vLy0KlKwPE/+voqwkQO4ksv4X2LuK7HE9H+D1a/3ID7ipsN5CwR480vPmvz+Ql3OFvHkT/94LrsZp4RiIy2smHCYRT/v4/a1rPN9ExERERGRrEvNIBFxnMkElTonTQnV6muM262w6Uf4tQGcWuP6+tLIZDLRqusQqi5Zyf52ZbGmuHPMDBRctpc9rYI4tGiKU7mblMvL30OCeLZtGWblsLDKJ4GEVKaEQg/fYPon29n191msVmPTSERERERE5H5RM0hEnOeTAzr9AH3/hjzljPGbZ+HPrjBvIESHu7a2dMidoyBPf7+QiLEfcr6QhyEecDsR85tfsqpPB6KuXHA4r7eHG0NaluPvoUH4VcnJhOzxnHBPZcG0xcbW+aeZ9fkOLp26na5rERERERERuRs1g0Qk7Yo3gIEboem7YDY2T9g3HX6pA/tnQRbaidOwybMEhmzkUI/axLsb44W2nuZo29bsnPSNU7t+SubxY0q/uozsVYMthUzM840n0mR8/o2L0cwdtYu1wceIj9GCaRERERERub/UDBKR9HH3gqbvwKBNULS+MR4TDnNfhKndkiaGsgg/n+x0/9+fmKf9xIkyvsZ4rA2/kX+wultTrp867HBek8lEh2oFWTWsKU2bF2dyjnh2eSZiT+XWsUPrLxD88TZO7LyiBdMiIiIiInLfqBkkIvdH3vLQdyl0/B68shvjp1bBmAaw+WewJrq+vjSq9lgr2s7fwrGXWxPlbYwXOnyVsK7d2PTt29gSHb8ufy93PuhYib9eDeRWBT+m+sdzJZUF0zERCSz//RAhv+wn4npsei5FREREREQEUDNIRO4nsxlq94PB26FiJ2PcEgPLP4Dfm8PFvS4vL6083T3p+tqP5Jo7lcM1chniXhbINX4h6zs0JGzPRqdyVyqUnTkDGzL06Sosymdjjbcl1QXT5w6GE/zJNvYsP68F0yIiIiIiki5qBonI/Ze9IDw9FZ6eBtkKGuOX9sH45kmNoYRo19eXRqVL1eLx4A2cfa8HN7KZDPH85yK52fNF1rzfH0us48fEm80mnq5TjFXDm1I6sCATs8dzKrUF0wk2Ns89yewvd3LlTES6rkVERERERB5dagaJyINTsWPSMfR1+gMpmid2a9ItY2MawMlVGVJeWphNZto99xGlFy/mYFBRQ9zdBgX+2sS21g05vnq+U7lz+XnyVfdqTHi5PodLe7LAN56oVBZMh4dFMeernayfcZyE2Kxzy52IiIiIiGQOagaJyIPlHQAdvoV+yyBvBWP81jmY+gTMfQmir7u+vjQqkL8UT45bzrVvh3A5j5shnvtaPNaX32XlK92JvRXuVO7aJXKx6LXGPPV4eWbktrDnLgumD6wNY+rHWzl/yLn8IiIiIiLyaFMzSERco1g9GLABmr0Pbp7G+P6ZMLoO7J2epY6hD+owgJpL13CoUyUSU/kftfDKQ+xr3YR9f41zKq+Hm5n+jUux5M0meNbLzTT/eK6ZjbuCYm8nsOjnfWyYeZzEBOOtZSIiIiIiIimpGSQiruPuCU3egoGboFhDYzz2BswfCH92hRunXV5eWgVky0v3UX+R8PvnnCvqZYxHWPF8/3tW9GrD7YtnncpdMMCHMT1r8eWLtVlbwsw6bwuWVKaE9q8JY+aXO7geFpnWyxARERERkUeEmkEi4np5y0GfEOj0I3gFGOOn18KYhrDxhyx1DH2thk/QZPEmjvZuRJyHMV5k53lOtm/P1nGfY3dy+qlp+Xz8PbQJ9TuUZGqOBM6ksmD61qUYZn25kz3Lz2O3ZZ3pKhERERERcS01g0QkY5jNUKsPvLIdKnUxxhNjYeX/YHxTuLDb1dWlmY+XH4+//zs+M37jZPlshrhvnJ2A76ayqmtjrhzb61Rubw833mhVjtnDg7j8WDZW+CQYpoTsVjub555k/g97iLwRl55LERERERGRh5SaQSKSsbIVgKemwDPTIXthY/zyAfi9Bfz9HsRHub6+NKpQOYh2czdz6vVORPoYj6EvfCycy916sO6rodgsFqdyl8zjx5/96/H4kxWYkcPCFTfjLqGLx28x/ZNtnNh5Jc3XICIiIiIiDyc1g0Qkc6jQHl7eCnVfwngMvQ22/pJ0DP2JFRlSXlq4u7nTcdDXFFgwiyO18xninomQb+LfrG/XgDM7VjuV22Qy8XzDEkwZ2ohdZT3Z5mUxnDhmibOy/PdDrJx4mHgdQS8iIiKZRIkSJTCZTPTp0yejSxF5ZKkZJCKZh3d2aD8KXlgB+SoZ47fPw7TuMOcFiLrm+vrSqFixKjz+51ouftyX8OzG/3bzh0UT/dxgVr79PAkxzk0/lcufjbmvNKJi22LM9E8gwmScEjq27TLTP9nGxZO30ngFIiIiIslFR0czduxY2rdvT+HChfH29sbLy4u8efNSp04d+vXrx/jx4wkNDXVpTdmyZcNkMmEymfjiiy8cfu4/z0n55enpSf78+WnSpAmff/45V69evWeupk2b3nn+vfz44493HpsvXz7279/vcM0i6aFmkIhkPkXrwEvroPmH4GY8nYuDc2B0bdgzNcscQ28ymWjxzFuUX/I3h5uXJGXLxs0OhRdsZ3urRhxePtOp3F7ubrzbriJfDarD0iImDnsYp4Cib8Yz79vdbJ1/CqvV2DASERERcdSWLVuoVKkSgwYNYunSpVy8eJH4+HgSEhK4fv06O3fuZOLEibz00kvUqVPHZXX99ddfREX93wdrf/75Z7pzWiwWrl69yvr16/nggw+oWLEiy5cvT3degFGjRjFkyBAAChQowNq1a6lWrdp9yS1yL2oGiUjm5O4JQcNh0GYo0dgYj7sFCwbDlM4Qfsrl5aVV3jxF6TZmCRE/vc2lfO6GeO7wBEyvfczyAV2ICndu30/D0nlYNDQIc8O8LPZNIC7lEfR22PX3Of76ahc3L0en5zJERETkEXX8+HHatGnD+fPnAejcuTNTpkxh69at7N69m+XLlzNq1Chat26Nh0cqx6s+QFOmTAHA398fgKNHj7J9+3anctSuXZsDBw7c+dq8eTNTpkyhfv36ANy4cYMnnniCM2fOpKvWzz//nLfeeguAwoULs27dOipVSmUyXuQBUTNIRDK3PGXg+UXQeTR45zDGz6yHXxvChu/A6twi5ozUoHUf6v29kaNPVCcxlf+Ji647zqE2Ldg542enjqEP8PXg5x41GNC7KnPyJBLqZjyC/tr5SGZ+voOD6y84fcS9iIiIPNref/99IiMjAZg4cSILFiygd+/e1KtXjxo1atCqVSuGDx/OsmXLuHDhAh9++KFL6goLC2PNmjUAfPzxx+TMmRP4vwaRo/z8/KhSpcqdrwYNGtC7d282b95M9+7dgaTb0b799ts01/rxxx/zwQcfAFCsWDHWrVtHuXLl0pxPJC3UDBKRzM9kgpq94ZUdUPkJYzwxDlaNgHFNIWyXy8tLKz/fAB7/Yjr2Sd9yrriPIZ49yorfx2NY8WxLws8ddyp31xqFmT2sMaer+LHO24I1xZSQ1WJjXfAxQsbsJyYiIV3XISIiIo8Gq9VKSEgIkDRBc68F0Hnz5mXw4MEuqAymTp2KzWbD3d2d5557jieffBKAGTNmYHHy5NbUmEwmRo4ceefvK1euTFOe9957jxEjRgBQsmRJ1q9fT+nSpdNdn4iz1AwSkazDPx88ORGenQXZixjjVw4mHUO/9B2Ij3R9fWlUrW57mi/ewol+zYj1NMaL7rnIuc5d2fDLR9isxkmfuymS05fpAxrQtGtpZmRPINxs3BV07kA4wZ9s4+yB6+m5BBEREXkEXLt2jdjYWADKlClz3/IeO3aMF198kRIlSuDl5UX+/Pl5/PHH2bp1q8M5/tkP1Lp1a/LmzUvv3r0BCA8Pv9PASq9SpUrh5+cHkKbF2MOHD+fLL78EoGzZsqxfv57ixYvfl9pEnKVmkIhkPeXawOBtUG8QhmPoscO2X+GX+nB8WUZUlyaeHl50fmsMAXMmcbJSgCHuE28nz8+zWd01kAuHdzic181s4uWmZfjttYZsKOnGHk/jcun4KAshv+xnXfAxLAmON5tERETk0eLp+X+fWh05cuS+5Jw3bx41a9bk999/59y5cyQkJHD16lXmz59PYGAgM2fe+2CNnTt3cvjwYQB69eoFQKNGjShZsiTg/K1id2MymXB3T9r56Ow+pNdff/3OrWUVKlRg3bp1FCmSyoebIi6iZpCIZE1e/tBuJPRfBfmrGOMRYRD8FMzuA5HOLWLOSKXL1aP9nE2cH9adCF/jcaSFT9wi/MnnWPXZYKwJ8Q7nrVokgIWvB1GweSHm+MUTbTLuCjq4/gIzP9/BtfNZZ6pKREREXCdXrlx3Jln27dvHV199hc2W9lNKDxw4wLPPPkv+/PkZPXo0W7duZcuWLXz88cd4e3tjtVp56aWXuHbt2n/m+afZky1bNrp06QIkNW6effZZAEJCQrhx40aa6/zHpUuXuH37NgAlSpRw6Dl2u52XX36Zn376CYAqVaqwdu1aChYsmO56RNLDeJSNSAqVK1dO9vf7cc+tyH1TpBa8tBY2/wzrvkraH/Rvh+bBqdXQ+jOo0Ttp/1Am52Z2o82Ln3KpfW+2vj+QClsvJYt7WKHQ1NVsWNWAQp9/TrmG7RzK6+Ppxqddq7C6Ql4+mrmfOtegTKJbssfcvhLD7JE7qNe5FDVaF8dszvzfLxERkf9it9mw3rqV0WW4lFuOHJjMD+Zz/1dffZXhw4cD8M477zB27Fg6d+5Mw4YNqVu37p1pHEfs3r2bWrVqsXr1arJnz37n3+vXr0+ZMmXo1asXERERTJ06laFDh6aaw2KxMGPGDAAef/xxfH1978R69erF559/TkJCAjNmzODll19OyyXf8c8tXsCdZdL38tJLL/H7778DUL16dVasWEGePHnSVYfI/WCy6ygZuYfUmkEnTpwAku6V1XijZBrhp2DxkKQTxlJTPBA6/Zh0QlkWYbfb2TBvNKavfyPPLeMtXDYTXOzWgOYf/Yqbp5fDea9HxfP27H1c23+DZrEeeBput4OCZQJo2bcS2XMbl1uLiIhkBidOnCAxMRF3d3fKli2b6mMSb9zgRMNGLq4sY5XdvAn3XLkeSG6bzcaLL77IhAkTUo3nz5+fpk2b0rNnTzp27IgplQ/iSpQowblz54CkCaNq1aoZHmO32ylSpAgXL17k8ccfZ+7cuam+3sKFC+9MAy1fvpxWrVoli9epU4edO3dSr169/9xB9E+dTZo0Ye3atXf+PTIykhMnTvDzzz8zefJk7HY7ZcuWZdu2bXdOLEupadOmrFu3Ltm/VaxYkU2bNt31OfJocOT/rJTCwsIoWrQocH9//9ZtYnJPhw4dSva1evXqjC5JJHW5S8NzC6HLGPBJ5QftuY1Jx9CvHwWJWeMELZPJRNATr1Jl6UqOtS6HLcX7KbMdiszZwtpOgVw46vhJann8vfi9Tx2efqYiM3NauORmHPG+dPI20z/ZzrFtl9N7GSIiIvKQMJvN/PHHHyxfvpy2bdve2aHzjytXrjBz5kw6d+5M3bp1OXXq1F1zVa1aNdVGECS9B6pRowYAp0+fvmuOf24RK1iwIC1atDDE/9khtG3btjsfaP+XdevWYTKZ7nxlz56dWrVqMWnSJAC6dOnC2rVrHW7q/NNkOnPmDLt373boOSKuoGaQiDxcTCao0RMG74AqqYzvWuNh9WcwrgmEOr6IOaPlzFmArj8tIG7M/7hUwHjkWKFzUVx9shcbx36MowOfJpOJnvWKM+2NQA5U8GKLlwVbiiPoE+OtrJx4mOV/HCI+RreIioiISJJWrVqxdOlSwsPDWbJkCSNGjKBTp04EBPzfQRg7d+6kcePGXLp0KdUcFSpU+M/XyPX/p5siI1PfZ3jz5k0WLVoEQI8ePTCncmtcjx49cHNLui0+vYukCxUqxJAhQyhUqJDDz/n5558BiIuLo3PnzmzcuDFdNYjcL2oGicjDyT8vdP8Des6BgGLG+NXD8EcrWPJmljqGvlazZ2iwdCPHu9cmMcX/4N4WyP3DTJY/24LbV8Mczlk6rz9zXm5E9fYlmJUtgVupHEF/YscVgj/ZzoVjN9N7CSIiIvIQyZ49O+3ateOjjz5i4cKFXLlyhQkTJtyZnLl06RIffvhhqs/9936f1PzT3LFaUz/tdMaMGSQkJE17/zMBlFK+fPlo3bo1AFOnTr3nh2a1a9fmwIEDHDhwgP3797N8+XI+/PBDAgICuHDhAm3btmXDhg3/mePfBg8ezKhRowCIiYmhQ4cO7NiRdT6QlIeXdgaJ0x7UPYsiD0x8FKz9EraOAXsqJ15kLwztv4EK7V1fWzrsXjuLiA8+Jf9143Hxt7O54fPxWzzW4Tmncm4/c4O3pu+l4qVEqlhSP2OgRuti1OtUCjcPfZ4gIiIZy5H9G1ognTGWLVtG27ZtAciZMyfXr1+/09z5Z2fQ888/f+f2q9T06dOHyZMnU7x4cc6ePWuIN2jQ4D/3AKVm7dq1NGnSxPDvd9sZ9I+DBw/SsGFDIiMjKVq0KAcPHky29Prf/r0z6J9ftz/55BP+97//AUnfj7Vr1971Fjl5eGWmnUE6TUxEHn5e/tDmc6jSDRa9BpcPJI9HXIAZPaBSF2j3NWQrkDF1Oqlm06e4tbgJa998nvIbziWLBURaYdiXLFu5hKZf/I6Xj79DOeuWzMXCNxrz8cJDLNx6mVaxHvjYky8q2rP8POcP36B1v8rkKuR3365HRETkQTCZzQ9smbLcXZs2bShatCihoaHcvHmT8PBw8ubNe9/ynzhxwulGECTdKpZaM+heqlSpwhdffMGrr75KaGgoo0aN4tNPP3X4+R999BExMTF89dVX3Lx5k1atWrFu3bp73ion8qDoY10ReXQUrgkvroFWn4B7KidkHV4Ao+vCzolgS2WCKBPKkSM/Xcf/zeUP+xDpazyto9jSfWxp35ize+5ywloqsnt78N1T1Xm1TzX+ypPIOXfjaHZ4WBQzv9jO/jVhDu8oEhERkUfLv3frpHaqWHr8e//Pr7/+yvTp0//z659bxebMmUNsbGyaXnPAgAGULFkSgO+//57r16879fyRI0fy2muvAXD16lVatGjxn8uxRR4kTQaJyKPFzQMavQ4VO8HioXB6bfJ4/O2k4+n3z0o6hj5vuYyo0mnNer5NWKMO7B3Sn9JHbyeL5b8Ux+1eA1jTrwNNhnyF+f8vUbyXjtUKUat4TobN3MvpwxE0jnPH/V9H0NsS7WyYeZxzB67T/PmK+AU4frS9iIiIPNxiYmI4fPgwkLRXKHfu3Pctt91uZ+rUqUDSxM7AgQPv+Rxvb2+WL19OREQE8+fPp0ePHk6/roeHB++88w4DBgwgOjqa77//ns8//9ypHD/88AOxsbGMHz+eixcv0rx5czZs2HDnNiARV9FkkIg8mnKVgt7z4fHfwCeV0fHzm2FsI1j7VZY5hr5IiSq0/Wsjp/s1IyFFv8fTCgXGh7CyexPCQ086nLNggA9T+9enzRNlmRlg4Voqy6XPH75B8CfbOL33WnovQURERDKxqKgo6tWrx+LFi7H9xxS1zWbj1VdfvXMKWOfOne/rZND69evv7BDq3j2V02NT0bZtW/z9k26bT8+pYn369KFw4cIA/PLLL9y+ffsez0jOZDIxduxYevbsCcC5c+do0aIFly9fTnNNImmhZpCIPLpMJnjsGXhlB1R72hi3JsDaL+C3xnB+m+vrSwN3N3c6vDUG94nfczGVI+iLHgnndJfO7Jg12uGcZrOJF4NK8fvrDdla2p2dnsaF1QnRiSwde4A1U49iiU/9xA8RERHJ+rZv306nTp0oVqwYr7zyCtOmTWPjxo3s27ePdevW8cMPP1C9enUmTJgAQEBAgFO7dRzx72ZOt27dHHqOt7c37dsnHRayYsWKNDdfPD09GT58OAC3b9/mp59+cjqH2Wxm8uTJd2o/ceIELVu2dPq2M5H0UDNIRMQvDzwxDnr9BTlSOYb+2lGY0AZChkGcc5/+ZJTKddtSP2Qdx9qUN8T8Y+z4f/QLfw/oTGyE40fFVyqUnfmvNaZEq8LM9osnymTcFXR440VmfLadK2ci0lW/iIiIZD7u7u4UKJB00MaFCxf45Zdf6NWrF40bN6Z69eo0bdqUoUOHcuBA0mEdZcuWZdWqVZQoUeK+1RAbG8ucOXMAKF++PFWqVHH4uf9MEVmtVqZNm5bmGl566SXy5MkDwI8//khUVJTTOdzc3Jg+fTodOnQA4NChQ7Ru3Zpbj9jJd5Jx1AwSEflHmZbw8lZo+CqYUv73aIcdv8Mv9eDI4gwpz1l+fjno+uN8box8jZvZjP/dF193gp3tmnBso+PX4+3hxv86VWbEgNosKmjnuIdxCijiWixzvt7JjpAz2KxZYxG3iIiI3Ju3tzcXLlxg06ZNjBgxgnbt2lGqVCn8/Pxwc3Mje/bsVKhQgaeffprg4GAOHjxIrVq17msN8+fPJyIi6UMnR6eC/tG+fXt8fJIOEUnPrWK+vr4MHToUgPDwcH799dc05fHw8GDOnDm0bNkSgD179tCuXbs0NZdEnGWy6xgYcVJYWNidBWehoaEUKVIkgysSeQAu7k06hv7SvtTjFTpC+28ge0GXlpVWVy+dYuvQPpTdaxw/tprg8jNBNHt/NG7uHg7nvBGdwLt/7ePCnnBaxHrgiXEXQP5S2WnVtzIBeVM5vU1ERCSdTpw4QWJiIu7u7pQtWzajyxER+U9p+T/rQf3+rckgEZHUFKoO/VdD68/Aw9cYP7oYfqkLO/7IEsfQ5ytYmo7B6zj3SidiU6wScrND4enrWdM5kEsn79L8SkUuP0/G9q7Nc89WZmYuCxfdjN+HK6cjmPHZdo5uuaQj6EVEREREMgk1g0RE7sbNPemWsZe3QOkWxnh8BIS8ARPbwdWjrq/PSWazmbavfE22aeM4X8w4qVP4dASXuvVg84QvHW7cmEwmnqpTlJnDGnOkkjebvC3YSP7cxHgrqyYfYdn4g8RFW+7LtYiIiIiISNqpGSQici85SyQtl35iPPjmNsZDt8LYQFjzJSTGu7w8Z5Wt2pimizZy4vEa2FLc2eUTbyfn11NY9nwbosKvOJyzeG4/Zg1sSN2OJZmZLYGbqRxBf2r3NYJHbCP0yI30XoKIiIiIiKSDmkEiIo4wmaDaU/DKTnjsWWPcZoF1I5OaQue2uL4+J3l5+dL5y2Bif/6A6zndDPHi20PZ374FB5bPdDinu5uZIS3L8eMr9VldzMz+VI6gj41IYOGPe9k4+wSJFh1BLyIiIiKSEdQMEhFxhm8uePxX6D0/aWIopevHYWJbWDQEYm+5trY0qN2yJ1UWL+d4/cKGWM7bVsyvfcyyt3thiYt1OGet4jlZODSIHEEFmO8bT2wqR9DvWxXKrC93En5Bp2WIiIiIiLiamkEiImlRuhkM2gKNhoDJOFnDrolJx9AfXgCZfHFyztyF6DxxBRffeZYo7+QxM1BswS42dAzk3IHNDuf093Lnq+7VGNavOnPzWTnjbpwCunkxmllf7GDfqlDstsz9PRIREREReZioGSQiklaevtBqBLy0FgrVMMajLsOs52BGT7h9weXlOcNkMtGiz4fkmz2NM2WzGeIFw2K42eMF1v30LjYnTk9rW6Ug84YFcaV6Nlb5JJCYYrm0zWpn4+wTLPxpL9G3Mv++JRERERGRh4GaQSIi6VWwGvRfBW2+BA8/Y/xYSNKU0Pbxmf4Y+uJla9Jq3kZO9QwkMcVPCK9EyDdmPiuebsaNi2cczpk/uzeT+9WjU/fyzMhh4Woqy6XDjt4k+JNtnNp9Nb2XICIiIiIi96BmkIjI/WB2gwYvw+CtUKaVMZ4QCUuGw4Q2cOWw6+tzgoe7Jx0/HI/995FczuthiBc7cJUTnTqya954h3OazSb6NirJpCGN2FHGg+1exiPmE2IS+XvcQVZNPkxCnHH5tIiIiIiI3B9qBomI3E85ikHP2dDtD/DLa4yHbYffgmD1Z2CJc319TqjWsAu1l6zhWPPShlj2aBu+737H3692Iz460uGc5QtkY95rgZRvU4yZfvFEprJc+uiWy0z/dDuXTt1OV/0iIiIiIpI6NYNERO43kwmqdofB26FGL2PcZoH1o2BsIzi70fX1OSFbttx0HbOY658OIMLPZIgXX3GYre0ac3L7Codzerm78V77iowcVIclheCoh3EKKCo8jrnf7GLbotNYrZn71joRERERkaxGzSARkQfFNxd0+QWeXwS5Shnj4SdhUgdY+CrE3nR9fU5o/OQQis2fy6nKOQ2xfFfjie3zGqu+fBWb1Xhq2N00LJOHhcMaY6ufmyW+CcSnWC6NHXaGnGXuqF3cuhqT3ksQEREREZH/T80gEZEHrWQQDNoMgW+A2d0Y3z0FRteFQ/My9TH0BYtWoN3sDZx5qQ3xKS7D3QaFJq9k1eOBXDlzyOGcOXw9Gf1sTV7oVYXZeRIJczM2k66ejWTGZ9s5vPEi9kz8/RERERERySrUDBIRcQUPH2j5P3hpHRSuZYxHX4XZfWD6M3A7zOXlOcrN7Eb7N37Ae8poLhT2MsSLHL9F6ONPsnXqtw7nNJlMPFGzCLPeaMypKr5s8LZgTTElZE2wsWbqUZaOPUBsVEK6r0NERERE5FGmZpCIiCsVqAIvrIC2X6V+DP3xv5OOod/2G9gcv+XK1SrUbEGjxRs43rEKKTf6+MXZCfjsd5a+0IHoW9cczlk0ly/TBzSkcZfSzMyewI1UjqA/s+86wSO2ce5QeDqvQERERETk0aVmkIiIq5ndoP5AGLwNyrU1xhOiYOlb8EdruOL4LVeu5uOTjS7fzCbquze5EWD8cVJi02n2tG/O4bVzHc7pZjYxuFkZxrzagPUl3NjraVwuHRdpYfHP+1g/8ziJCZm3YSYiIiIiklmpGSQiklFyFIUeM6D7RPDLZ4xf2Jl0DP3KEWCJdX19DqrXvh/lFy3hRO0ChljuG4nYB73P8g/6kZgQ73DOx4rmYMGQxuRrVpC5fvHEpHIE/YE1Ycz8YgfXQh0/2l5ERERERNQMEhHJWCYTVHkCXtkONZ8zxm2JsPE7+LUhnFnv+voclCdfcTr9uZqwN7oTk2KVkNkORedsYV2nQMKO7HQ4p6+nO58/XpV3X6jJgvw2Trkbp4BuXY5h9pc72bP8PHablkuLiIiIiDhCzSARkczAJyd0/hn6hEDuMsb4jdMwuRPMHwwxN1xfnwNMJhOtXvqUnDMmca6kcR9SoXNRXHuqNxvGfuzUqWAtK+Vn3rAgbtbMzgqfBCwplkvbbXY2zz3J/B/2EHkjLt3XISIiIiLysFMzSEQkMykRCAM3QdCbqR9Dv3cq/FIXDszJtMfQl6pYj+YLN3Lyqbokpvgp422BPD/MZFnPFty6GupwzrzZvJjQty7dnq7IzJwWLrsZl0tfPH6L6Z9s48SOK+m9BBERERGRh5qaQSIimY2HNzT/AAZsgCJ1jPHoa/DXCxD8FNw67/r6HODp4U2nTyaTOGYEV3Mbm1rFd1/iSId27A2Z4nBOk8lE7/rF+XNoIHvLebLVy4I9xZSQJc7K8j8OsWLiIeJjjcunRURE5P6Ijo5m7NixtG/fnsKFC+Pt7Y2Xlxd58+alTp069OvXj/HjxxMaavzwp0+fPphMJsOX2WwmR44cVK1alRdffJGtW7c6XdeIESPu5AsICCAuzvGp4ZMnTzJ9+nSGDh1Ko0aN8PX1vZNr0qRJTtcikpmZ7M7M6osAYWFhFC1aFIDQ0FCKFCmSwRWJPMRsVtg5IWmJdEIqi5I9/KD911C9Z9L+oUzo9q0rrH3zecptOJdq/Fy7ajT74g+8fPwdzpmQaOOHlcdZtPIM7aI9CLAbP9vwy+lF636VKVQ2R1pLFxGRTO7EiRMkJibi7u5O2bJlM7qcR8aWLVt45plnOH/+3h9K5c+fn8uXLyf7tz59+jB58mSHXuuVV17hp59+wuTg+5zSpUtz+vTpO3+fPn06zzzzzD2ft27dOpo2bXrX+MSJE+nTp49DNYjcTVr+z3pQv39rMkhEJDMzu0HdF5OOoS/f3hi3RMOCwfBXf4i77fr6HBCQIz9dxv/NlQ/6EOljfCNXfOl+NrdvzJk96xzO6elu5q22Ffjm5bosL2LmsIdxCij6ZjzzvtvN1vmnsCYabysTERER5x0/fpw2bdrcaQR17tyZKVOmsHXrVnbv3s3y5csZNWoUrVu3xsPD4575li1bxoEDBzhw4AB79uxh3rx5DB48GHf3pMni0aNH88033zhU28aNG+80gvz9kz5kmjLFsSnkf89ImM1mKleuTN26dR16rkhWpGaQiEhWEFAYngmGp6aAf35j/OAcGNsYwna5vjYHNe31NoXmzeR0hQBDrMClOCJ6DWT1t8Ow2Rxv3NQrlZuFwxrjGZiPxb4JxKW4bQw77Pr7HHO+2snNy9HpvQQREZFH3vvvv09kZNK08sSJE1mwYAG9e/emXr161KhRg1atWjF8+HCWLVvGhQsX+PDDD/8zX7ly5ahSpQpVqlShevXqdO3aldGjRzN37tw7j/niiy+wWCz3rO2fxk/+/Pl5//33AVi+fDlXrtx7n2DhwoUZNWoUa9eu5fbt2xw8eJBBgwbd83kiWZWaQXJPlStXTvbVvHnzjC5J5NFkMkGlLjD4LsfQ3zoHE1rDxh/AiYaKKxUpUZU2czZwum8zEtySxzytUHD8ElZ0D+J66AmHc2b39uD7p6sz6PlqzMmbyHk34xH010OjmPH5Dg6uv+DUSWYiIiLyf6xWKyEhIQDUrl37nrdN5c2bl8GDB6fptTp16kRgYCAAt27dYteu//7AKy4ujtmzZwPw9NNP07t3b8xmM1arlWnTpt3z9cqWLcvw4cNp0qTJnakikYeZmkEiIlmNT46kY+ifmgLeKaZsbImw8n8w9QmIzJynarm7e9Dh7TG4T/qOSwU8DfFih8M53aUL22eNdipv58cKMWdYEOeq+bHO24I1xZSQzWJjXfAxQsbsJyYiIV3XICIi8ii6du0asbGxAJQpU+aBv17VqlXv/Dm1RdT/tnDhQm7dugVAr169KFy4MM2aNQMcv1VM5FGiZpDc06FDh5J9rV69OqNLEhFImhIauBGK1jfGTq+BsY3g5ErX1+WgynXaUW/xWo63Lm+IZYuxk+2jX1g6sDOxkbcczlk4hw/TXmxA88fLMCMggXCzcULq3IFwgj/Zxtn919NTvoiIyCPH0/P/PsQ5cuSIS1/vXvuH/mn4lC9fnjp1kk5j7dWrFwD79u3jwIEDD6hKkaxJzSARkawsRzHoEwJBbwEpljNHX4Op3WD5B5CYOSdh/Pxz0uWn+dwc+Rq3shl/JJVYe4Kd7YI4unGxwzndzCYGNinNuNcasqmUO7s9jcul46MshIzZz7rgY1gSjLeViYiIiFGuXLkoXrw4kNRg+eqrr5za9eesfzecSpQocdfHXb16lWXLlgHQs2fPO//erVs3fHx8ABw+vUzkUaFmkIhIVufmDs3fh+cXQbaCxvjmn5N2CYWfcn1tDmrYdRClFy7k5GN5DLE81y1YXnqTFSMGYE289/LIf1QpHMCC1xtTtGVh5vjFE20y7go6uP4CMz/bztVzEemqX0REMi+7zU5sZMIj9WW3Pbj9eK+++uqdP7/zzjuULl2a119/nZkzZ3LmzJn79jo7d+5k5cqkCeeyZctSrVq1uz42ODiYxMSkD3/+mQYCyJYtG507d77zGKtVHwCJ/MM9owsQEZH7pGRjGLgp6aj540uTxy7ugd+CoMN38NjTGVPfPeQrWJoO09exYsw75PttEd7/6vu426DI9PWs3h5IlR/HU7DM3d8Q/pu3hxsfd67MmvJ5+XDGfmpfs1E2Mfnm6ttXY5nz1U7qdS5FjdbFMZtNd8kmIiJZUVy0hQlvbszoMlyq36hAfLIZ9/LdD0OHDuXw4cNMmDABgLNnz/LTTz/x008/AUkneTVt2pSePXvSsWNHTCbHf65arVbOnj3L8uXL+fDDD7HZbLi5uTFq1CjM5rvPMfxzi1jDhg0pWbJksljv3r2ZOXMmly5dYsWKFbRt29bZSxZ5KGkySETkYeKXG3pMh3Zfg1uKN4EJUTDvJZg3EOIjM6a+ezCbzbR55WuyBY8jtJiPIV7kVAQXuz3DpolfOpW3Wfl8LBjWmOg6OVjmk0BCiuXSdhtsnX+a+d/tJuJ6bLquQURE5GFmNpv5448/WL58OW3btsXdPfl8wZUrV5g5cyadO3embt26nDr135PJJUuWxGQyYTKZcHd3p0yZMrz88suEh4dTtmxZ5s6dS5cuXe76/IMHD7Jnzx4g+VTQP9q0aUPevHkB+PPPP529XJGHlppBIiIPG5MJ6g2A/qsgd1ljfN90+K1J0rRQJlWmamOaLNzAicdrYEvxgaJvvJ1cX01h6fOtiQp3/MS03P5ejHuuNs/2qMSsnBYuuRl3HFw6eZvpn27n2LbLOoJeRETkP7Rq1YqlS5cSHh7OkiVLGDFiBJ06dSIg4P9OOt25cyeNGzfm0qVLTuc3mUw8/fTTdOzY8T8f988uIA8PD5566ilD3N3dnaefTpqKnj9/PpGRmfMDMRFXUzNIRORhVbAaDFgHNYyfknHjFPzeCrb8Apm06eHl7UfnL4OJ/el9rud0M8RLbAtlX4cWHFgxw+GcJpOJZ+oWI3hYYw5W9GazlwVbiimhxHgrKyceZvkfh4iLdnxHkYiIyKMoe/bstGvXjo8++oiFCxdy5coVJkyYQM6cOQG4dOkSH3744V2fv2zZMg4cOMCBAwfYsmULEyZMoHr16tjtdj777LNkO4pSslqtBAcHA9CuXTty586d6uN69+4NQExMDHPmzEnrpYo8VEx2ffQpTgoLC6No0aIAhIaGUqRIkQyuSETu6cAcWDQEElL5NKxsa+gyBvzzurwsR90Mv8j6Yc9RbusFQ8wGhHapRYsR4/HwNt5adjcWq42fV51g7orTtIv2IIfN+PmIbw4vWvWtRJHyOdNTvoiIPCAnTpwgMTERd3d3ypZNZRqWpAXSj1pz39vPA1MG78BbtmzZnf08OXPm5Pr163f2/vTp0+fORM+ZM2cMJ4VZLBY6duzI8uXLAZg7dy6PP/74f76Go5o2bcqaNWsceuykSZPo27cvABMnTqRPnz5OvZZISo78n5XSg/r9WwukRUQeBVW7Q+Fa8NcLcGFX8tiJ5TC2ETwxDko1zZDy7iVn7kJ0nriC1ZM+I+DHYPzi/i9mBoov2MWGXYGU/v5nildt6FBODzczb7QuT5PyeRk+fS8VLiRSxZL8x2LMrXgWfL+HGq2KUa9zKdw8NFArIpLVmMymB7ZMWe6uTZs2FC1alNDQUG7evEl4ePid3T334uHhwaRJkyhfvjyRkZEMHz6cjh074uHhkexx/yyOdsa6des4f/48xYoVc/q5Ig8TvasVEXlU5CoJ/ZZBoyHGWNQVmNIVVo4Aa+b89NRkMtGi74fknT2Vs6X9DfGCYTHc7PECa396F5vNuA/obmoVz8XCIY3xD8rPQt8EYlM5gn7PivPM/monNy5Gp+saREREHiWFChW682dnThUDKFiwIK+//joAp0+f5o8//kgWj4yMZP78+QC0aNGC6dOn/+fXb7/9BoDdbtciaRHUDBIRebS4eUCrEdB7HvjlSxG0w8bvYGI7uHk2I6pzSPGytWi5YBOnejYiMcVPMa9EyD9mPsufacaNS2cdzpnN24NRTz7G630fY25eK+fcrYbHhIdFMfOL7exfE6rl0iIiIvcQExPD4cOHgaS9Qnfb5/Nfhg4dir9/0gdAI0eOJDEx8U5szpw5xMTEADBo0CCeeeaZ//x66aWXeOyxxwCdKiYCagaJiDyaSjeHQZugdAtjLGwHjG0MB+e6vi4Hebh70vHD37GP/5LLeT0M8eL7r3KiUwd2zR/vVN72VQsyd1gQFx/LxhpvC4kplkvbEu1smHmCRT/vI/p2fLquQUREJKuJioqiXr16LF68+D+ncG02G6+++uqdk7s6d+7s9GQQQK5cuRg4cCAA586dS9bE+ecWMV9fX9q1a+dQvu7duwNw7Ngxtm3b5nQ9Ig8TLZAWp2mBtMhDxGaDrb8k3R5mS+X2sJrPQduR4Onn+tocFBkRzup3nqfc6lOpxs+2qkSzkRPx9svucE6bzc6ETWeYsPg4rSPdyZvKcmlPP3da9K5IqeqZd/G2iMjDLi3LWCXtoqKiyJYtGwCFCxema9euNGjQgOLFi5MtWzZu3brFnj17mDBhAgcOHAAgICCAvXv3JlsSfa8F0v92+fJlSpYsSVxcHOXKlePIkSOEhYVRokQJ7HY73bp1c/iEsCNHjlCpUiUAXn75ZX755Zdk8Tlz5hAVFXXn7xs3brxze9oLL7xAYGDgnViBAgWcXl4tkpkWSKsZJE5TM0jkIXRhN8zpBzfPGGN5ykH3iVCgiuvrcsKGWT/g+dU4skcbf6xdze9FoVGjKFu3lVM5j16O4I3gPeQ/G0/thNTPXKjUqCCNniyLp7fOZBARcTU1g1wrLi6OkiVLcvnyZYceX7ZsWaZPn06tWrWS/bszzSCAwYMHM2bMGACCg4M5ffo0H3zwAQDTp0/nmWeecfgaKleuzOHDh8mdOzcXL17E0/P/louXKFGCc+fOOZSnSZMmrF271uHXFYHM1QzSbWIiIgKFa8KA9VD1KWPs+nEY3xy2j4dM/PlB46eGUGz+XE5XNh4Dn+9KPLF9X2Pll69isxr3Ad1NhQLZmftqIKVaF2G2XzxRqSyXPrzpEjM+287lM7fTVb+IiEhm5+3tzYULF9i0aRMjRoygXbt2lCpVCj8/P9zc3MiePTsVKlTg6aefJjg4mIMHDxoaQWnx1ltv3TlJ7Isvvrhzi5iXlxcdOnRwKle3bt0ACA8PJyQkJN21iWRVmgwSp2kySOQht3c6hAwDSyonZ5XvAF1Gg28u19flIKvNyvLvh1Fw4jK8Eo3x0HI5eOynP8hfopJTeTeeuM57M/ZS46qdchY34wNMULdjSWq1LY7ZTZ+1iIi4giaDRCQr0WSQiIhkXtV7JE0JFahmjB0LgbGBcHaT6+tykJvZjXbDfsB7ys9cKORliBc9fovQx7uzZdp3TuUNLJuHBW8EkVA3J0t9EkhIsVwaO2xfdIa53+zm9rXY9FyCiIiIiMgDpWaQiIgY5SkD/VdC/cHGWMQFmNwR1nwJ1lRGbzKJCjVbEhiykRMdqpDyvBO/WDs5Ph3Pkv7tibp1zeGcOf08GdOrFn16VWFWLgsX3YwnqVw5E8H0T7dxZPMlHUEvIiIiIpmSmkEiIpI6dy9o+wU8Oxt8cyeP2W2wbiRM7gS3wzKmPgd4+/jT+dvZRH07nJvZjT/ySm48w972zTm0bq7DOU0mE91rFWHmsCCOVfZhk7cFW4opIWuCjdVTjrBs/EHiolI5pU1EREREJAOpGSQiIv+tXGsYuAlKBhlj5zfDr43gyCLX1+WEeh1eoPziJZysVcAQy30jEfvA91n2YT8SE+Idzlksty8zBjSgfqdSzMyewE2zcUro1O5rBH+yjdDDN9JVv4iIiIjI/aRmkIiI3Fv2gtB7PrT4CEwplifH3YKZvWDxG2DJvLtycucrToc/V3FhaDdiPZPH3OxQbPYW1nYKJOzoTodzuruZea1FWUa/2oC1xc3s9zTeNhcbkcDCn/aycdYJEi2On2QmIiIiIvKgqBkkIiKOMbtB42HQ728IKGaM7/wDxreAq0ddX5uDzGYzLQd8Rs6Zkzhfws8QL3wuimtP9Wb9bx87te+netEcLBgSRK6mBZjvG09MKkfQ71sdyqwvdxJ+ISpd1yAiIiIikl5qBomIiHOK1oWBG6Dy48bY1UMwrinsnAiZeHlyyYr1aLZwAyefrIvVlDzmnQB5v5/J371acvua4/uQ/Lzc+fKJarz5Qg0W5Ldxxt04BXTzYjQzv9jB3pXnsdsy7/dHRERERB5uagaJiIjzfHJA94nQ6Sdw90keS4yFxUNgdh+IveX62hzk6elDp08nYxkzgmu53Q3xErsucrhDW/YsmexU3taVCzB3WGOu1cjOKp8EElMsl7Zb7Wyac5KFP+0l6qbjO4pERERERO4XNYNERCRtTCao9TwMWAf5qxjjh+fD2MZwfpvLS3NGjWZP8VjISk4EFjfEckRY8X5jJEuHPUNCXLTDOfNl82ZSv7p0ebICM3JYuJrKcumwozcJ/mQrJ3ddTVf9IiIiIiLOUjNIRETSJ2956L8K6rxojN0+DxPbwfpRYMu8y5MDcuSn8+9/c/WDPkT5mAzxEiH72NQ+kNN71jmc02Qy8XzDEkwZ2ohdZT3Z7mXBnmJKyBJrZdn4g6yafJiEWOPyaRERERGRB0HNIBERST8Pb+jwDTw9DbxzJI/ZrbD6M5jSBSIuZUh5jmrS620KzZ3JmfIBhliBi3FE9h7Iqu+GY7MZJ33upmz+bMx9NZAKbYsxyz+BCJPxuUe3XGb6Z9u5dOp2uuoXEREREXGEmkEiInL/VOwIgzZB8UbG2NkN8GtDOPa36+tyQuGSVWn91wbO9GlGglvymGciFBoXwvIng7gWdsLhnJ7uZt5tV5GvBtVlWWETRz2MU0BR4XHM/WYX2xaexmp1vNkkIvIoc3NL+o/aarU6dQqkiIir2e12rNakSXmzOeNbMRlfgYiIPFwCisDzi6Dpu2BK8WMm9gZMfxqWvgOJmXd5sru7B+3fGYPHxO+4lN/TEC9+KJwznbuwbfYvTuVtUDo3C4YFYWqQhxDfBOJT3DaGHXYuOctfX+/i1pWY9FyCiMgjwdMz6f9ou91OTIz+3xSRzCs+Pv5O0/qf/7sykppBIiJy/5ndoOk70CcEshc2xrf9Cr+3hOsnXV+bEyrVbUe9Jes40bqCIZYtxk72D0ezZFAXYiJuOpwzwMeDn56tyYDnqjInTyJhbsZdStfORTLjs+0c2nBBn3SLiPyH7Nmz3/nzjRs39H+miGRaERERd/7s5+eXgZUkUTNIREQenOINYeBGqNDRGLu8H34Lgj3TIBO/effzy0Hnn+Zx68vXuO1v/LFZcs1xdrZvytHNIU7l7VK9MLOGNeZUVT/We1uwppgSslpsrJ12jKVjDxAbmZCuaxAReVj5+/tjMiUt/o+KiiIsLIzo6Gg1hUQk07BarYSHhxMeHn7n3/z9/TOwoiQmu/6nFCeFhYVRtGhRAEJDQylSpEgGVyQimZ7dDjv/gL/fA2sqt4dVfRI6fAfe2Y2xTOTqxZNsH9KX0vuvG2KJZrjUowkt3v0ZN3cPh3NabXZ+W3+KaUtO0DbKg1w2Y8PJO5sHLftUonjl3OmqX0TkYRQZGcmFC8knKU0m0519QiIiGeXfe4L+kTdvXvLkyeNwjgf1+7eaQeI0NYNEJM2uHII5/eDaUWMsZwnoPgEK13J5Wc6w2Wys/OUd8o1bhJfFGA8tnZ0qP46jUJnHnMp78MJt3gjeTfFQC9UT3FN9TNWmRWj4RGncPfULjojIv6XWEBIRyWwCAgIoWLDgnYlGR6gZJJmGmkEiki4JMbDsXdg1yRgzu0OLj6DBq5AJTln4Lyf3b+DMsNcpEhpriMV4mYgd0pvAvu86lTM2wcoXS46weUMobWI88bMb3yjkyO9L6xcqk7dYtjTXLiLyMLLZbERFRREREUFCQoLh03gRkYzg5uaGr68vOXLkwNvb2+nnqxkkmYaaQSJyXxyaBwtfh/jbxljpFvD4WPDP5/q6nJAQF8Oyj/tTasEezKn8ND1TryiNv/+TbLnyO5V3zdGrfDhzH3WvQelE4xSQyWyifpdSVG9VDLPZ8U+WRERERCRreVC/f2fuj11FROThVflxGLQRitYzxk6tgl8bwslVrq/LCZ7evnQaGUzcj+8TnsPYtCm5LZT97Vuwb8UMp/I2q5CP+cOCiKgdwAqfBCwplkvbbXa2zDvFgu/3EHkjLl3XICIiIiKPHjWDREQk4+QoBn2WQOPhQIoJl+hrMPUJWP4hJGbu07Rqte5F5cXLOFm/sCGW65YV99dGsPSd3ljijbeU3U0efy/GP1+Hp56pxKycFi672QyPuXjiFsGfbOPEjivpql9EREREHi1qBomISMZyc4cWH8JzC8C/gDG++SeY0AZunHZ9bU7ImacwHSeu4PJbzxLjlTxmtkOJ+TtZ3zGQcwe2OJzTZDLxbL1iTH0jkP3lvdjqZcGeYkooMc7K8j8OsXzCIeJjE+/HpYiIiIjIQ07NIBERyRxKNYFBm6FcW2Ps4m4YGwT7Z7u+LieYTCaa9fuQvHOmca60ccFzodAYbj7bjzWj38NmM0763E2pvP7MGdyIx9qXYKZ/ArdNxuee2H6F6Z9s4+KJm+m6BhERERF5+KkZJCIimYdfbugxA9qOBDfP5LGESJjbH+a/DPFRGVOfg4qVrUmL+Rs4/WwjElP8pPWyQIHR81jWoxk3Lp11OKeHm5nhbcrz3Sv1WFHUzGEP4xRQ9M145n27hy3zT2FNdLzZJCIiIiKPFjWDREQkczGZoP4g6L8ScpcxxvdOg3FN4NI+19fmBA8PLzp89Dv2cV9yNY+HIV5i31WOd+rAzgXjncpbp0QuFrzRGK/G+Vjkm0AcxmPMdv99jtlf7eTm5eg01y8iIiIiDy81g0REJHMq+Bi8tA6q9zTGwk/C7y1h669gT+VM90ykWmBXai1Zw4lmpQ2xgCgbfm9/x5LXuhEXHeFwzuzeHnz3VHVe6VONv/JZOe9mNTwmPDSKGZ/v4OC6MOyZ/HskIiIiIq6lZpCIiGReXv7QdQw88Tt4ptjBY02Av9+B4Kch+nrG1Ocg/+y56fzrYsJHDCDC12SIl1x+mK3tgzixY4VTeTtWK8RfwxoT+pg/67wtWFNMCdksNtZNP07IL/uJicjcJ7KJiIiIiOuoGSQiIplftSdh4HooVNMYO7EMfm0EZ9a7vi4nBT49hOIL5nK6Uk5DLP+VeGL7vMaKka9isxonfe6mYIAPU/vXp9UTZZkZYOG62bgr6NzBcIJHbOXs/szdNBMRERER11AzSEREsoZcpaDfMmj4mjEWdRkmd4ZVn4I1cx+vXqBoBdrO2cC5F1uT4J485mGFIpNWsuKJQK6cO+JwTrPZxItBpRj/ekO2lnZnt6fxexAfnUjImP2sDT6GJd7xZpOIiIiIPHzUDBIRkazD3RNafwq95oJf3hRBO2z4Bia2g5vnMqQ8R7mZ3Wg77Ee8p/zMxUJehnixY7c437Ubm6d951TeSoWyM++1xhRrVZg5fvFEm4y7gg6tv8CMz7dz9ZzjO4pERERE5OGiZpCIiGQ9ZVrAoM1QurkxFrYdxjaGQ/NdXpazytdsSaOQDZxsX4WUN3f5x9rJ+el4lvRvT9Staw7n9PZw43+dKjNiQG0WFbRzwt04BRRxNZY5X+1k59Kz2GxaLi0iIiLyqFEzSEREsib/fNDzL2j1CZhT3G8VfxtmPw+LXoeEmIypz0HePtno9N1sor95k5vZjT+WS248w572LTi0dp5TeYPK5WXBsCBi6+ZgmU8CCSmWS9ttsG3BaeZ9u5uI67HpugYRERERyVrUDBIRkazLbIZGr8MLyyFnCWN81yQY3wyuHHJ1ZU6r27Ef5Rcv4VStAoZYnhsW7IPe4++P+pGYEO9wzlx+noztXZtePSszO5eFS27G5dKXT91m+qfbObbtso6gFxEREXlEqBkkIiJZX+FaMGADVH3SGLt2FMY3hx2/QyZvduTOV5z2f67i4tDuxHomj7nZofisLazpHEjY0Z0O5zSZTDxVuyjThzXmcCVvNntZsKWYEkqMt7Jy4mGW/36IuGjL/bgUEREREcnE1AwSEZGHg3d2eGI8dP0VPPySxxLjIGQYzOwFMTcypj4Hmc1mWgz4lJwzJxFaws8QL3I2iqtP9WbduI+dmuQpntuPWQMbUqdTSWZlS+BWKkfQn9x1lemfbCPsaOb+HomIiIhI+qgZJCIiDw+TCao/CwPWQYFqxvjRxUnLpc9tdn1tTipZsR5NF27g1JN1sZqSx3wSIN93M1naqwW3roU6nNPdzcyQluX48dX6rC5u5qCH8Qj6mNsJLPhhL5v+OonVYmwYiYiIiEjWZ7JrQYDcQ+XKlZP93WKxcOLECQBCQ0MpUqRIRpQlIvLfEuNhxf9g26/GmMkMTd6BoOFgdnN9bU7au2YWEe9/St4bxubNrexueH38JjXbP+9Uzqj4RD5ddJg9my/QOtYTH7vJ8Jhchf1o/UJlchfyT3PtIiIiIpJ2YWFhFC1aFLi/v39rMkhERB5O7l7QbiT0mAm+uZPH7DZY+wVM7gS3L2RMfU6o3uwpqoes5GRgcUMsR4QVrzdGsmTY0yTERjuc09/Lna+6V+ONfjWYl8/KuVSOoL9xIZpZX+xg/5pQLZcWEREReYhoMkic9qA6kyIiD0zEJZj7IpzdYIz55IQuv0CFDq6vKw3WTf0a328n4R9r/PF9qZA3xb/7gdLVmziV80pEHMNn7SXm4C2C4jxwxzglVLRSLlo8XxG/AK801y4iIiIiztFkkIiISFplLwjPLYDmH4IpxW1hsTdhxrOw5E2wxGVMfU5o0ustCs+dydlyAYZYwYtxRPUayMrvhmGzOb7vJ392byb3q0fHJ8szM4eFa6kslw49fIPgEds4vedauuoXERERkYynZpCIiDwazG5JO4L6LoWAYsb49nHwewu4dsz1tTmpUMmqtJ63kbPPN8OSorflmQiFxy1h+ZNBXLtw0uGcZrOJvo1KMmloI3aU9WSnl3E/UUJMIkt/O8DqP4+QEGeMi4iIiEjWoGaQiIg8WorVg4EboFIXY+zKQRjXFHZPgUx+F7Wbmzvt3h2Dx4TvuJzf0xAvfiicM507s3XOL07lLZc/G3NfbUTZNkWZ7R9PlMn4fTiy6RIzPtvO5TO301y/iIiIiGQcNYNEROTR45MDnpwMnX4Ed5/kMUsMLHwV5vSDuMzf7KhYrx11l6zjZKsKhli2aDsBH4wmZFAXYiJvOpzTy92N99pX5IuBdVhSGI57GJdLR16P46+vd7Ej5Aw2q46gFxEREclK1AwSEZFHk8kEtfrAS2shXyVj/NBcGBsIoTtcXZnT/Pxy0Onnedz68jVu+xt/tJdac5wd7ZtyZHOIU3kblsnDwjeCSKyfiyU+CSSQYkrIDtsXnWHuN7u5fS0mPZcgIiIiIi6kZpCIiDza8lWAF1dDnf7G2K3zMKENbPgOnFjInFEaPD6I0gsWcLpaHkMs37UEEvsPZ9mnA7EmWhzOGeDrwehna9L/uSrMyZ3IBTfjlNCVMxFM/3Q7RzZf1BH0IiIiIlmAmkEiIiIePtDhW3h6KnjnSB6zW2HVCPizK0RezojqnJK3cBnazVhH2MudiPdIHnO3QbFp61jVNZCLJ/c5nNNkMvF4jSLMGNaYk1V82ehtwZZiSsiaYGP1lKP8/dtB4qIcbzaJiIiIiOupGSQiIvKPip1g4EYo1sAYO7MOfm0EJ1a4vi4nmc1mWr32Nf7B47hQxMcQL3oygkvderBh0pdO5S2ay5fpAxoS2KU0M7MncDOVI+hP773GtE+2Enr4RprrFxEREZEHS80gERGRf8tRFJ5fDE3eAVOKH5Mx12Fad/j7PUiMz5j6nFCmamOCFm/kVJca2EzJY77xdvKMnEJIn9ZEhDs+8eRmNjG4WRnGvNaAdSXc2OdpPGI+LsLCwp/2snHWCRItxtvKRERERCRjqRkkIiKSkps7NHsXnl8E2QoZ41t/gT9aQfgp19fmJE9vXzp+FUzcj+8TnsPNEC+1NZQDHVqyb+UMp/JWK5KDBUMak7dZQeb5xhOTyhH0+1aHMuuLnVwPi0pz/SIiIiJy/6kZJCIicjclAmHQJijfwRi7tA9+C4J9zjVRMkqt1r2ovHgZJ+sVNsRy3bLi/uoIlr7bG0t8rMM5fT3d+fzxqrz7Yk0W5Ldxxt04BXTzUjSzvtzB3pXnsdu0XFpEREQkM1AzSERE5L/45oJnpkH7b8DNK3ksIQrmDYC5L0F8ZMbU54SceQrTcdIKLr/Zg5gUl2K2Q4l5O1nXMZCzB7c4lbdFxfzMGxbEjVoBrPRJIDHFcmm71c6mOSdZ8ONeom7GpfcyRERERCSd1AwSERG5F5MJ6r4IL66CPOWM8f0zk6aELu5xfW1OMplMNHvhI/LOnsr50tkM8cKhMdzq0Y/Vo9/DZjMuiL6bvNm8+KNPHbo9XZGZOS1cTWW59IVjNwn+ZBsnd11N1zWIiIiISPqoGSQiIuKoAlXhpbVQ8zlj7MZp+L0VbP4ZnGiiZJRi5WrRfP4GzvRoRGKKdwNeFig4eh5/92jGjUtnHc5pMpnoVb84U4YGsqe8J9u9LNhTTAlZYq0sG3+QVZMOkxBrXD4tIiIiIg+emkEiIiLO8PSDzj9D9wnglT15zGaB5R9A8JMQdS1j6nOCh4cX7f/3O4wbydU8HoZ4yX1XOd6pAzsWjHcqb5l8/swZHEjldsWZ5Z9AhMnYHDu69TLTP93OpZO30lq+iIiIiKSRmkEiIiJpUaUbDNwAReoYYydXwthGcGqN6+tKg6qBXagVsoaTTUsbYgFRNvzf/o6Q17sRGxPhcE5PdzNvta3AN4PrsayImSMeximgqBtxzP12N9sWnsZqzfzTVCIiIiIPCzWDRERE0ipnCei7FALfAEzJY1FX4M/HYcX/wGrJiOqc4h+Qm05jFxM+YgARviZDvNSyw2xtH8TxHSucylu3ZC4WDmuMR6O8hPgmEJ/itjHssHPJWf76ehe3rsSk5xJERERExEFqBomIiKSHmwe0/B88Nx/886cI2mHTDzChLdw86/ra0iDw6SEUn/8XZyrlNMQKXI4nrs9rLP/qVaxWx/f9ZPf24PtnajDw+WrMyZNImJvxCPpr5yKZ8dl2Dq6/gN2uI+hFREREHiQ1g0RERO6HUk1h0GYo29oYu7ATxjaGA3NcXlZaFChWkTZzNnC+f2sS3JPHPKxQdOJKVnQL4vK5I07l7fxYIeYMD+JMNT/We1uwppgSslpsrAs+xqKf9xF1Mz69lyEiIiIid6FmkIiIyP3ilwd6zIQ2X4A5xULm+Aj46wVYMBgSojOmPie4md1oM/xHvCf/zKWCXoZ48aM3Ce3ajU3B3zqVt1AOH4JfbEDzx8swMyCBG6kcQR96+AbBn2zl+I7LmhISEREReQDUDBIREbmfzGZoMBj6r4BcpYzxPVPhtyZwab/ra0uD8rVa0nDJBk62r2KI+cfayfXJ74T0b0/U7esO5zSbTQxoUppxrzdkUyl39noabzmzxFpZ8cdhlv1+iLiozL9zSURERCQrUTNIRETkQShUAwash8d6GGPhJ+D3FrDtN8gCky/ePtno9N1sIr8Zzs3sxrcOpTaeYXf75hxcP8+pvJULBTD/9cYUblmYOX7xRJmM34tTu64ybcRWzh5wvNkkIiIiIv9NzSAREZEHxSsbPD4WHh8Hnv7JY9YEWPoWzHgWYm5kTH1OqtvxBSosWsKpmgUMsbzhFhjwHks/6kdiguP7frw93Pi4c2U+GVibJYVJ9Qj6uEgLIb/sZ/WfR0iIdXxxtYiIiIikTs0gERGRB+2xp5OmhApWN8aOLYFfG8GZDS4vKy1y5S9O+6mruDikO7GeyWNudigxawuruwQSemynU3kbl83LwmFBeDbOx0LfBGJTmRI6sukSwZ9u48Lxm+m5BBEREZFHnppBIiIirpC7NLywAhq8YoxFXoTJnWD15+DEke0ZxWw202Lgp+SaMZHQ4n6GeNEzUVx7sjdrx32MzWZcEH03AT4efPdUdYb2q878/DZOuRuPoI++Ec/87/awcfYJEhOMcRERERG5NzWDREREXMXdE9p8Dj3ngG+eFEE7rP8aJnWAW6EZUp6zSlSqT9NFGzjdvS5WU/KYTwLk/24mf/duxa3rYU7lbVulAPOHBxFVJwfLfBJIwDgltG9VKDM+38HVcxHpuQQRERGRR5KaQSIiIq5WthUM2gylmhpjoVthbCM4vNDlZaWFp6cPHT6bjPWXEVzP5W6Il9x1kcPt27J76WSn8ubx9+K352rzfK8qzM6TSKibcQro9pUYZo/cyfZFp7FaHZ9AEhEREXnUqRkkIiKSEbLlh17zoOXHYE7RRIm7DbN6w+KhYInNkPKc9Vjzp3gsZCUnGxU3xHJGWPEaOpIlw58hITbG4Zwmk4lutYowe3gQodX9WeNtITHllJAddoScZc7Indy4GJ3eyxARERF5JKgZJCIiklHMZggcCv2WQQ5jE4WdE2BcM7h6xPW1pUH2nPnp9MffXHv/eaK9k983ZgZKLt7Hho6NOLl3rVN5C+fw4c8X6tPpqfLMyGnhsptxCuh6aBQzP9/O3pXnsduMt5WJiIiIyP9RM0hERCSjFakNAzdAlW7G2LUjMK5pUmPInjWaHEG936HQ3JmcKxdgiBW6EEd0r0Gs/H64U8ulzWYTzzcswbQ3AjlUyZtNXhZsKaaEbFY7m+acZN53u4m4njUmqkREREQygppBIiIimYF3AHT7AzqPBg/f5LHEuKRbxmY9B7FZ41j1QqWq0mreRs491xSLW/KYZyIU/i2EZU814VrYCafylsrrz6yBDWnUtTQzAhIINxsbSpdO3ib4k20c3ngRexZpoImIiIi4kppBIiIimYXJBDV7w0vrIH9VY/zIQhjbGM5vdX1taeDm5k7b937F449vuZLP0xAvcfA6p7t0YeucX5zK6+5mZnCzMox/vRFby3iw0ysRe4opIWuCjTVTjxLyy36ib8en6zpEREREHjZqBomIiGQ2ectB/5VQd4AxdjsUJraHdaPAZjxhKzOqWL89dZas5WTL8oZY9mg7AR+MZvHLXYiJdG7qqVKh7Mx7LZAK7Yoxyz+B2ybjlNC5g+FMG7GNEzuvpLl+ERERkYeNmkEiIiKZkYc3tP8aeswAn1zJY3YrrPkMpnSBiIsZU5+T/Pxz0mn0fG598Sq3/Y1vP0qvPs6O9k05snmxU3m93N14u20Fvn+1HqtKmNnvmWh4jCUmkeW/H2LZ7weJi7ak+RpEREREHhZqBomIiGRm5dvBoE1QPNAYO7sBfm0Ex5a6vq40avDEy5ResIAzVfMYYvmuJZDY/02W/u8FLAlxTuWtVTwXi4YGka95If7yiyfaZNwVdHLnVaaN2Mq5g+Fprl9ERETkYaBmkIiISGaXvRA8vxCavQ+mFD+6Y2/A9Gdg6dtgca6BklHyFi5D25nruDCoI/HuyWPuNigxczNrOzbi9P6NTuX19XTn065V+HhAbUIKwVEP45RQXISFxaP3sWbaURLijHERERGRR4GaQSIiIlmB2Q2avAV9l0JAUWN821j4oyVcd+50roxiNptp+foo/IN/40IRH0O8yPkYIp59kRXfDsVqda5pE1QuLwuHBeHeKC+LfBOIS2VK6PCGi0z/dDsXT9xK6yWIiIiIZFlqBomIiGQlxerDwA1QsZMxdvkA/BYEe6ZCFjlSvUy1IIIWbeT047WwmpLHvBKhyPi/WfFEYy6e2u9U3gBfD75/pgZD+j3GvPw2zrgbl21Hhccx79vdbPrrJImWrLGMW0REROR+UDNIREQkq/HJCU/9CR2/B3fv5DFLDCwYDH/1h7jbGVOfkzx9fOnw5VRsv37K1TwehnjxY7e49MQzrP19BDab8cSw/9K2SkHmDQvidp0cLPdJIAFjk2zvivPM/GIH185HpvkaRERERLISNYNERESyIpMJaveDF9dA3orG+ME5MLYxhO1yfW1pVK1pd2otWZPqEfS+8XbyfzODpT2bE37pjFN582bzYtxztenVszJzcicS5macArp1KYbZI3ewI+QMNqtzDScRERGRrEbNIBERkawsfyV4cTXU6muM3ToHE1rDxh/AyYmajOKfPTedRs8n8uth3MxufJtSas8VTnTqyJbZPzuV12Qy8WTtosx6M4hzj/mz1ttCYoopIbsNti86w5yvd3HzcnS6rkNEREQkM1MzSEREJKvz9IVOP8BTU8A7IHnMlggr/wdTn4DIKxlSXlrU7dyfiiHLOFW/iCEWEGUjx4djWPxSByJvXXUqb+EcPkztX58OT5ZjRg4LV9yMTbJr5yKZ8dl29q0KxW7LGruXRERERJyhZpCIiMjDolIXGLgRitY3xk6vgbGN4ORK19eVRjnzFqHjpBVc/6AvUT4mQ7z0+tPsa9ec3cumOpXXbDbRp1FJpg4LZH8FbzZ7WbClmBKyJdrZOPsE83/YQ0R4bLquQ0RERCSzUTNIRETkYZKjGPQJgaC3gBQNlOhrMLUbLP8AEhMypLy0aNzrLYotmMuZKrkNsdw3rXi9/jkhbzxFbEyEU3lL5/VnzssNadClFDOzJ3DDbJwSunj8FtM/2caRzRexZ5ET2kRERETuRc0gERGRh42bOzR/H55fBNkKGuObf07aJRR+yvW1pVH+YhVoO2s9F1/pSqxn8pgZKLXkANvaNebIlhCn8rq7mXmleVl+G9KQLaU92OWZaHhMYryN1VOOsmTMfmIisk4TTURERORu1AwSERF5WJVsDAM3Qbl2xtjFPfBbEOyf5fq60shsNtPilS/JPWsy50tnM8TzX0kg8YXhLP24P5aEOKdyVy4UwLzXAynXrhiz/OO5bTJOCZ09EM60EVs5tdu5PUUiIiIimY2aQSIiIg8zv9zQYzq0+xrcUozUJETB3Bdh3kCIj8qY+tKgeIW6tFiwiXPPNcPiljzmboMSMzaxtmMjzhzY5FReL3c33mlXgW9fqcfq4mYOpDIllBCdyN/jDrJ8wiHioi3puQwRERGRDKNmkIiIyMPOZIJ6A6D/Kshd1hjfNz1pSujiXpeXllbu7h60fW8M3pN/5mJhb0O8yPkYbvfoz4rv3sBmtTqVu3aJXCwYGkSe5gWZ5xdPtMm4K+jE9isEf7KN84fD03wNIiIiIhnFJc2gUqVKUapUKUaPHu2KlxMREZHUFKwGA9ZBjV7G2I1T8HtL2PILZKFFyeVqt6Tx4k2c7loLW4p92V6JUGTcUpY/EcjF0wecyuvn5c5nXavy0YDahBSC4x7GhlLs7QQW/bSPdcHHsMQ713ASERERyUguaQaFhYVx7tw5qlev7oqXExERkbvx9IMuv0C3P8Azxd4dmwWWvQfBT0HUtYypLw08fXzpMHIq1l8/5VpuD0O8+LFbXHr8adb+8Qk2m3EX0H8JKpeXhcOCMDfKQ4hvAnEYG2UH119g+qfbuHTyVlovQURERMSlXNIMKlCgAAA+Pj6ueDkRERG5l6rdYeAGKFzLGDuxHMY2gtNrXV5WelRr2p2aS9dwqkV5Q8w33k7+UdNZ2qsF4ZfOOJU3wNeD75+pwat9H2Nefitn3Y1TQJHX45j77W62zDuJ1eJcw0lERETE1VzSDKpXrx4Ahw4dcsXLiYiIiCNylYR+y6DREGMs6gpM6QorR4A16yxK9s+em46/zCfyqze4md34NqfU7suc6NSRrXOcv3W9XdWCzBvehJu1c7DCJ4GElFNCdti97Dwzv9zB9bDItF6CiIiIyAPnkmbQoEGDsNvtfP/991gsWecNpYiIyEPPzQNajYDe88AvX4qgHTZ+BxPbwc2zGVFdmtXt8iIVQ/7mVP0ihlhAlI2AD35h8UsdiLzl3DHxebN5Mf752vTsWZk5uRO54GacErp5MZpZX+xk59Kz2KyaEhIREZHMxyXNoObNm/Puu++yb98+OnbsSGhoqCteVkRERBxVujkM2gSlWxhjYTtgbGM4ONf1daVDzrxF6ThpBdfe70Okj8kQL73+NPvatWDP8mlO5TWZTDxZuygzhzfmTDV/1nlbsKaYErLb7GxbcJq/Ru3m1pWYdF2HiIiIyP1mstsf/JEhn3zyCQB//fUXBw4cwM3NjUaNGlGtWjVy5syJm5vbfz7/o48+etAlihPCwsIoWrQoAKGhoRQpYvzUVUREsiibDbb+knR7mC2Vad6az0HbkUmLqLOQK+ePsuuN/pQ8aDwK3gacbV+N5p+Nx8c3u1N5bTY7k7ec5fdFx2gZ4U4+m/FzNrO7mUbdylC1SWFMZmNTSkRERORuHtTv3y5pBpnNZkym/3vzY7fbk/39XqxWHdeamagZJCLyCLiwG+b0g5upLFvOUw66T4QCVVxfVzrYbDbWjHmfnOPm45NgjF/J70n+kV9SsUF7p3OfvBrF8Jl7yXYymrrx7pgxvs8pXD4nLZ6vSLZc3mkpX0RERB5BD+r3b5fcJgZJDaB/vlL+/V5fIiIi4mKFa8KA9VD1KWPs+nEY3xy2j4cs9HPabDbT4pUvyT1rMqGlshni+a8kkPjCMJZ+3B9LQpxTucvk82fOyw2p27kUs7IlcNNs3BV04dhNgkds4+jWS3p/IyIiIhnKJc0gm82Wri8RERHJAN7Zodt46DoWPFLcFmaNhyXDYUZPiLmRMfWlUfEKdWm+YCPnnmuKJcWd6u42KDFjE2s7NuLMgU1O5XV3M/Nqi7L8OqQhm0t7sNsz0fCYxHgrqyYdYenYA8REpDKeJCIiIuICLpsMEhERkSyqeo+kKaEC1YyxYyEwNhDOOtc4yWjuHp60fe9XvCb/xKVCxtu2ipyP4XaP/qz47g2nP5iqUjiAea8HUqZdUWb7xxNpMk4Bndl3neARWzm951qar0FEREQkrdQMEhERkXvLUwb6r4T6g42xiAswuSOs+RKsxmmYzKx87VYEhmzidNea2FKs+fFKhCLjlrL88UZcPH3Aqbxe7m68264io16px4piJg55GL8v8dGJLP3tACsnHiY+JpVl3SIiIiIPiJpBIiIi4hh3L2j7BTw7G3xzJ4/ZbbBuJEzuBLfDMqa+NPL08aXDyGkkjvmEa7k9DPHix25x8YmnWffHp05PCdUpkYuFbwSRs3lB5vvGE5PKlNCxbZeZNmIboUey1u12IiIiknW5vBl048YNvv32W9q1a0fRokXx8/PDz8+PokWL0q5dO7799ltu3NCbIRERkUyrXGsYtBlKNjHGzm+GXxvBkUWuryudHmv2JDWXrOFUi3KGmF+cnXyjglnaqwU3Lp11Kq+flzufP16V9wfUYnEhOyfcjaekxt5OYOGPe1k/4ziWBJ2iKiIiIg+WS46W/8dvv/3G8OHDiYmJATCcpPHPcfO+vr58++23vPTSS64qTZygo+VFRAQAmw02/QCrPwN7Kg2M2i9Am8/Bw8flpaXX9gXjSPz8R3JGGCeBbvub4Z2Xqd89lVvm7uF2jIWPFhzg5I6rtIjxwCuVI+iz5fWhdd9KFCgVkKbaRURE5OHxoH7/dlkzaOTIkbz//vt3GkABAQHUqFGDAgUKAHD58mX27NnD7du3kwozmfjyyy956623XFGeOEHNIBERSSZ0B/zVD26dN8byVYbuEyBfBdfXlU43r4WyaXhfSm+7kGr8VFApmnw9kWw58jmde8mBS3wx+wANb5gonuhmfIAJarUpTp2OJXFz1139IiIij6os3Qw6ePAgNWrUwGq1UrBgQUaNGsWTTz6Jh0fy+/ITExOZPXs2b775JhcvXsTd3Z09e/ZQuXLlB12iOEHNIBERMYi9BYuHwKF5xpi7D7T9Emr1AZNxEiazWz/lK7y/n0y2WONbpvCc7viNeIcarXs6nfdqZBzvztnPjf03aBLrgUcqU0K5CvvRqm9l8hTxT1PtIiIikrU9qN+/XfJR0+jRo7FareTNm5ctW7bw7LPPGhpBAO7u7vTo0YMtW7aQL18+rFYro0ePdkWJIiIikh4+OaD7ROj8c1Lz598SY5MaRbP7JDWNspig596m+Py/OFM5tyGW+2Yinq99Rsiwp4mNiXAqb75s3vzepw49nq3MnNyJXHQz3pJ240I0s77Ywe5l57DZXHZnv4iIiDzkXNIMWr16NSaTiXfffZdixYrd8/FFixbl7bffxm63s2rVKhdUKCIiIulmMkHN52DAOshfxRg/PB/GNobz21xeWnrlL16RtrPXc+GVLsR6Jo+ZgVIh+9naPogjW5c6lddkMvFUnaJMH9aYU9V82eBtwUrypo/dZmfLvFPM/WYXt67GpPNKRERERFzUDLpwIele+4YNGzr8nEaNGgFw8eLFB1KTiIiIPCB5y0P/VVA3lYMgbp+Hie1g/SiwZa1Ts8xmMy1fGUnumZMJLZXNEC9wOZ7Efm+w9OP+WBLinMpdNJcvwS82oHX3cszKYeGa2TgldOV0BNM/3c6BtWGGQzhEREREnOGSZpCbW9JixMTERIefY7UmvUE0m7U0UUREJMvx8Ib2o+CZYPDJmTxmtyadQDalC0Rcypj60qF4xbo0X7CRc72bYkmx+9ndBiVmbGJtp0DOHNzsVF6z2US/wJJMeiOQvRW82OZlwZ5iSshmsbF+xnEW/rSXqJvONZxERERE/uGSTss/t4Y5c8vXP4915LYyERERyaQqdICBm6B4I2Ps7Ab4tSEc+9v1daWTu4cnbd//Fa/JP3GpkLchXuRcNLd7vMCK74ZhsxmnfP5LmXz+zBnciDqdSzErWwI3U5kSCjtyk+AR2zi27bKmhERERMRpLmkGtWrVCrvdzjfffMOBAwfu+fiDBw8yatQoTCYTrVu3dkGFIiIi8sAEFIbnF0HT98CU4q1H7A2Y/jQsfQcS4zOmvnQoX7sVgSGbON21JrYUh4F5WaDIuCUsfyKQS2cOOpXX3c3Mqy3KMmZIQzaVdmevp3G62hJnZeXEw/w97iCxkQnpuQwRERF5xLikGTRkyBC8vLyIiooiMDCQb775hvDwcMPjwsPD+eabb2jcuDGRkZF4eXkxZMgQV5QoIiIiD5LZDZq+DX1CIHsqR6Ju+xV+bwHXjru+tnTy9PGlw8hpJP4ygmu5jaelFj96kwuPP8XaPz51ekqoSuEA5r3WmFJtizLHP55Ik3EK6PSea0wbsY0z+66l+RpERETk0WKyu2i2eMqUKfTt2/f/XthkomTJkuTLlw+TycSVK1c4c+YMdrsdu92OyWRi0qRJ9O7d2xXliRPCwsIoWrQoAKGhoRQpksqbehERkbuJuQELX4Wji40xd29o9h40eCWpgZTFRN0OZ+17/Si9KvWm1umaBWjw3SRyFSjudO7tZ27w7oy9VLiYSCWLe6qPqdCgAI2fKoenT+pxERERyVoe1O/fLmsGAYSEhDBgwIBkJ4SZTEkz1f8uo1ChQowbN4727du7qjRxgppBIiKSbnY77PwD/n4PrKncHla4NnQdk3QyWRa0bcE4rJ//SM4I4yTQbX8zvPMy9bsPdjpvdHwiny85ws4NYbSK9cTXbjI8xjenF636VKJI+ZypZBAREZGs5KFoBkHSiWLz5s1j5cqVHDx4kBs3bgCQK1cuqlSpQsuWLenatSseHsYxa8kc1AwSEZH75sohmNMPrh01xty8oOk70PA1cMt6ky43r4WyaXhfSm+7kGr8VJPSNP16Ev4BeZzOvfbYVf43az81r9gpk5j6BFW15kVo0LU07p5Zb8JKREREkmTpZtD58+cB8Pf3J1euXA/65eQBUzNIRETuq4SYpKPmt44BUnlbUqgGdBkD+Su5vLT7Yf2Ukfh8PwX/WOO1Xc/lTrYR71G9VQ+n896KSeCj+Qc5veMqzWM98MI4JZQ9nw+t+1Ymf8nsaapdREREMtaD+v3bJQukS5QoQcmSJZkxY4YrXk5ERESyEk9faPsF9PsbcpU2xi/ugd+CYP0osFpcX186BT33DsXm/8XZysYPxPLcSMTj1U8IGfY08bFRTuXN4evJT8/WZFDfx5iXz8p5N6vhMRFXY5nz9U62LTyNNdG55dUiIiLy8HJJM8jHxweAOnXquOLlHjkXLlzghx9+oHXr1hQrVgxPT08KFChAt27d2LZtW0aXJyIi4phi9WHQJmj4qvEIepslaXpofHO47Nwx7ZlB/uIVaTN7AxcHdyEuxZ3wZqBUyH42twvkyNalTufuUK0gf70ZxPXaAaz2TsCScrrKDjuXnGX2yJ2EX3Cu4SQiIiIPJ5c0gwoXLgyA1Wr8xErS7+eff2bo0KGcPn2a1q1bM2zYMAIDA1mwYAENGzZk5syZGV2iiIiIYzx8oPVn0G855ClnjF/eD+OawtqRkJjg8vLSw2w20+LVkeSaNZnQkv6GeIHL8ST2e4Oln7yIJSHOqdz5snnze586PN2zMnNyWbjkZpwCCg+LYuYXO9i9/Bw2m0tXRoqIiEgm45JmUOvWrQHYuHGjK17ukVO3bl3Wrl3LyZMn+f333/nyyy+ZM2cOa9aswc3NjUGDBhEfn8pJLSIiIplV0TowYAM0GpL6lNDaL5OmhC7tz5Dy0qN4xbo0X7iJc72bYEmx29ndBiWCN7K2cyBnDm52Kq/JZOKpOkWZPjyIk1V92ehtwZpiSshutbNl7inmfrub29di03spIiIikkW5ZIH0iRMnqFGjBv7+/uzatevOpJA8eG3atGH58uXs2LGD2rVr35ecWiAtIiIuFbYLFryc+oljZncIfAOC3gR3T9fXlk7HdiznwltvU/CScRIo3gOu9etAi9e/xmx27vM7m83OxM1nmbj4GK0i3MljMz7fzcNM46fKUimwECaTcfm0iIiIZLwsvUC6bNmyBAcHExMTQ/369QkODiYhIXOMdl+9epXFixfz0Ucf0a5dO/LkyYPJZMJkMtGnTx+ncp07d45hw4ZRoUIF/Pz8yJUrF3Xq1GHUqFHExMQ8mAu4Bw+PpMUE7u5Z70heERERAIrUggHrofEwMKUYpbElwvqvk24du7gnQ8pLj/J1WhO4ZBOnu9TElqIf42WBIr+FsKxbIJfOOLcnyWw28UJgSSa90Yg9FbzY4WXBnmJKyGqxsXbaMRaN3kf0LU0Qi4iIPEpcMhnUvHlzIKlZcubMGUwmE56enpQtW5acOXPi5uZ21+eaTCZWrVr1wGr7r0/Cnn/+eSZNmuRQnkWLFtGrVy8iIiJSjZcrV46QkBDKlCmTljLT5Pz585QrV45cuXIRGhr6n99nZ2gySEREMszFPTD/Zbh62BgzuUHgEGjyNrh7uby09Nq3eha3P/yUvOGJhli0t4no156lcZ/3nJ4SslhtjFlzirnLTtI62oMcqUwJefi40ezZCpStkz/N9YuIiMj996B+/3ZJM8hsNt9pujj6ciaTCbvdjslkeqCLp//dDCpWrBgVKlRg+fLlgOPNoD179tCoUSNiY2Px9/fn3XffpVmzZsTGxjJjxgzGjx8PJDWEdu7cSbZs2R7ItfybxWKhZcuWrF+/nilTptC7d+/7llvNIBERyVCJCbDhG9jwbdJkUEp5K0CXMUkTRVlM1O1w1r7bl9KrT6QaP12rIA2+nUiuAsWdzn0g7DZvzdhD0fMJPJaQ+sRw6Vr5aNqjPN7+HqnGRURExLWydDOoadOm6boXfc2aNfexmuT+97//UadOHerUqUP+/Pk5e/YsJUuWBBxvBgUFBbFhwwbc3d1Zv349DRo0SBYfNWoUb7311p3X+/jjjw05hg0b5tSS59dff52yZcumGrPZbPTu3Zvg4GBefPFFxo0b53BeR6gZJCIimcKlfTB/MFw5YIyZzElH1Dd9Dzy8XV9bOm2f/xvWz38iR6TxVLDb/mZ492XqdxvsdN44i5Vvlx9j1ZpztIn2xN9ufH/mnc2DFs9VpETVPGmqXURERO6fLN0MykqcbQZt376devXqATBgwADGjh1reIzNZqNKlSocOXKEHDlycPXq1Tu7fP7h7+9PdHS0w3WuWbOGpk2bpvpa/fr1Y/LkyfTq1YvJkyc7PU5+L2oGiYhIppGYABu/T9oblNqUUJ5y0OUXKFrX9bWl081roWwa1pfS2y+kGj/VpDRNv56Ef4DzTZttp8N5b+Y+Kl5MpKIl9Smhig0LEvhkWTx9tHdQREQko2TpBdLnz5/n/Pnz3LhxwxUv51Lz58+/8+e+ffum+hiz2cxzzz0HwK1bt1KddIqKisJutzv8dbdGUN++fZk8eTI9evRg0qRJ970RJCIikqm4e0LTt+GldVDwMWP8+nH4ozUsex8sWeso9Zx5i9JxykquvfccUT7GCZ7S606xp10z9q6Y7nTueqVys+CNILI1K8hC3wRiTcbPBo9svkTwp9u4cPxmmuoXERGRzMslnYISJUpQsmRJZsyY4YqXc6mNGzcC4OfnR61ad99N0KRJkzt/3rRp032v459G0JQpU3j66af5888/79vCaBERkUyvQBXovwqafwDmlPtu7LBlNIwNhPNbM6S89Ah67l2Kzv+LM5VzGWJ5biTi8eonhAx/mvjYKKfy+nu58+UTVXnnpZosKmjntLtxR2P0jXjmf7eHjXNOkGh5cDscRURExLVc0gzy8fEBoE6dOq54OZc6cuQIAGXKlPnP49srVKhgeM798s+tYVOmTOHJJ59k6tSpagSJiMijx80Dgt5MOoa+UA1jPPwkTGgLf78LCTGury8dChSvSNvZG7g4uAtxKXpdZqDU4v1sahfIkW1Lnc7drEI+FgwPwtIwN8t8EkjAOCW0b2UoMz7bztVzqZ+aKiIiIlmLS24CL1y4MKdOnXqgp4JlhLi4OK5fvw5wz/v2cubMiZ+fH9HR0YSGht7XOj755BMmT56Mv78/5cqV47PPPjM8pmvXrlSvXt2hfGFhYf8Zv3TpUlrKFBERcY38leCFlbD5J1j7JVgT/hW0w9YxcGxp0i6hEo0yrExnmc1mWrw6knMtHufYsFcoeib5JFDBy/Ek9n2Dpc/MpeU7P+Ph6fji7By+nvz0bE0WV7nIV3MO0ijcRFFr8g+Wbl+JZfbIndRpX4Ja7Uvg5qZb0UVERLIqlzSDWrduza+//srGjRupX7++K17SJSIjI+/82d/f/56P/6cZFBXl3Bj3vZw9exZI2jv0+eefp/qYEiVKONwM+mc5lYiISJbl5g6N34AKHWD+y3BhZ/L4zTMwqT3UfQla/A+87v1zPLMoXqkehRduYuXXr1EoeB0e//qszd0GJYI3snZzIGW//ZkSlRvcPVEqOlYrRN0SuXjnr/2c3HeTxnHuuPOvfUV22BFyljP7r9Oqb2VyFfK7T1clIiIiruSSj3Ref/11fHx8+Oabb7hwIfUTMbKiuLi4O3/29PS85+O9vLwAiI29vwssJ02adM+F03369LmvrykiIpIl5C0PLyyHVp+CeyqTMtvHwa8N4cx619eWDu4enrR9fyyek37gUkEvQ7zI2WhuPdOPFT8Mx2YzHk//X/Jl9+aPPnV4smdFZudK5LKb8fnXQ6OY8fl29q48j92mg2lFRESyGpc0g8qWLUtwcDAxMTHUr1+f4OBgEhIS7v3ETM7b+//eVDpyPfHx8cD/7VDKrEJDQ//za/v27RldooiIiOPMbtDoNRi4EYrWM8ZvnYPJnWDxGxAfaYxnYhXqtKHRko2c7lwDW4oDx7wsUGRsCMu6BXLpzEGn8ppMJp6uU4zpwxtzoqovm70s2FLsErJb7Wyac5J53+8m4nrWOqlNRETkUWey2+0P/OOc5s2bA3Du3DnOnDmDyWTC09OTsmXLkjNnzv9cdmwymVi1atWDLvGOs2fPUrJkSQCef/55Jk2adNfHxsXF3WnsdOjQgcWLF/9nbn9/f6Kjo6lfvz5btmy5bzW7WlhY2J1byUJDQ++5L0lERCTTsFlh22+w6hNITKWBEVAMOv8EpZu5vrZ02rdqFhEffkqeG4mGWLS3iejXe9Kk7/tO57XZ7EzYdIbJi4/TKtKd3DbjZ4lunmaCni5HxYYFMZlMqWQRERGRtHhQv3+7ZGfQ2rVrk70xsNvtxMfHc/Dg3T+lMplM2O32TP2Gwtvbm9y5cxMeHn7Ppcs3b94kOjoa0E4eERGRDGN2gwYvQ7k2sOAVOL85efz2efizK9Tqk3RrmXf2jKgyTR5r8RRRtVuw9t2+lF59IlnML86O31dTCVm1igbfTCRXgeIO5zWbTfRvXIqm5fMyfMZecp6KpXZ88reQ1gQba/48yqk912jeuwJ+AcZb10RERCTzcEkzKCgoKFM3ddKjUqVKbNiwgZMnT5KYmHjX4+WPHj16588VK1Z0VXkiIiKSmtyloU8I7BgPKz8GS4qj5ndNghMrofOPUKZlRlSYJv4Buek4ZiHb5/+G9fOfyBGZfN9PqZ2XONapPaZ3B1P/iZedyl0mXzZmD27EL2tOMnvZaVpHuRNgTz4ldP5gONM+3kaznuUpWzt/uq9HREREHgyXTQY9rAIDA9mwYQPR0dHs2rWLevVS2UUArFu37s6fGzXKOsfYioiIPLTMZqg3AMq2goWvwdkNyeMRYTC1G9ToDW0+B++AjKkzDep2HcDNhu3YNLwfpbcnP7wjR6QN3vuZxcuX0PSrSfgH5HE4r4ebmSEty9GiQn7emr6HYqEJVEtI/nbSEpvI8t8PcXrvNZr0KI+3n8d9uSYRERG5f1yyQPph1rVr1zt/njhxYqqPsdlsTJkyBYAcOXLQrFnW20MgIiLy0MpVCp5bCO2/AY9Ujkrf8yf8Uh+OL3d9bemQM18xOk5ZybV3nyPKxzihXXrtKfa0a8beldOdzl21SADzhjSmWJsizPWLJ9pkXEF5cudVpn28lXMHw9NUv4iIiDw4agalU926dWncuDEAf/zxR6qLob/99luOHDkCwOuvv46Hhz4hExERyVTMZqj7Iry8GUoGGeORFyH4SZg3CGJvur6+dAh6/l2Kzp/D2Uq5DLE8NxLxeOUTFr/5DPGxUU7l9fZw4/0OlfhicF3+LmrimIfV8Ji4SAuLR+9j7bSjJMQZF1uLiIhIxnDJaWKpCQsL4/Lly8TExFCnTp0MO25948aNnDx58s7fr1+/zptvvgkk3c7Vv3//ZI/v06ePIceePXto1KgRsbGx+Pv7895779GsWTNiY2OZMWMG48aNA6BcuXLs3LmTbNmyPbgLcgGdJiYiIg81uz1pZ9DyDyAhlQaJfwHo9AOUb+fqytLFZrOxevS75B6/EG+LMX65gBcFvxpJhXptnc4dFZ/I54sPsXfTJVrGeuBtN04i+ef2plXfShQqkyMN1YuIiDyaHtTv3y5tBkVGRvL1118zadIkLl68eOffDxw4QKVKle78fcaMGcydO5eAgADGjx//QGvq06cPkydPdvjxd/t2LVq0iF69ehEREZFqvFy5coSEhFCmTJk01ZmZqBkkIiKPhFvnk3YJnV6TerzqU9DuK/A1TtxkZucOb+PYsFcoesbY6Eo0Q9gzgbR8dzQeHs6fCLbm6FVGzNxP7Wt2Sia6pfqYGq2KUbdzSdw9Uo+LiIjI/3lQv3+77DaxEydOULNmTb744gsuXLiA3W6/a2Olfv36zJ07lwkTJrBx40ZXlZgunTp1Yv/+/QwdOpRy5crh6+tLjhw5qF27Nl999RV79ux5KBpBIiIij4wcxaD3POj8M3ilcsT8gVnwSz04stj1taVD8Ur1aL5wE+d6BWFJ0Y9xt0GJ4I2s6dSIs4eMt77fS7MK+Zg3PIi4BrlY7pNAAsb3entWnGfm5zu4dj4yrZcgIiIi6eSSyaC4uDiqVavGyZMn8fPzY/DgwQQFBdGxY0dMJpNhMgigVatWrF69mmHDhvH1118/6BLFCZoMEhGRR87tMFg0BE6uSD1epRu0GwV+uV1aVnod3b6Mi2+/TcFL8YZYvAdcf6EjzV/7CrPZ+c8PF+27yNd/HSQw3EQRaypTQGaouX+wAwABAABJREFU26EktdoWx+ymNZYiIiKpydKTQb/++uudRtCGDRsYOXIk7du3/8/ntGvXDrvdnupCZhERERGXCigCPWdDlzHglcoR8wf/gl/qwqH5Li8tPSrUbUOjJRs53bkGthRrfrwsUHjsYpZ1C+TS2UNO5+70WCH+Gh7E5VrZWedtITHllJANti86w+yvdnHzcnQ6rkJERESc5ZJm0Ny5czGZTLz++utUr17doec89thjQNLtZZKxKleunOyrefPmGV2SiIiI65lMUKMnDN4K5VJZshxzHWY/D7Oeh6hrrq8vjbx8/OnwdTCJo0dwPZe7IV7iyE0udH2S9RO/cDp3vuzeTOhbl8efrcicXIlccbMZHnP9fCQzPtvOvtWh2G0Zcq6JiIjII8clzaB/jlVv3bq1w8/JnTtpzPrWrVsPoiQRERGRtMleCHrMgMfHgXcOY/zwfBhTL2laKGMObU2Tx1o8RY2lazjVvKwh5hdnJ+9XfxLSqwU3rpxzKq/JZKJH3WIED2/MsSq+bPGyYEsxJWRLtLNx1gnm/7CHiPDYdF2HiIiI3JtLmkFRUUmnVfj7+zv8nPj4pHvXPTw8HkhN4rhDhw4l+1q9enVGlyQiIpKxTCZ47GkYvA3KdzDGY8JhTj+Y1Ruirrq+vjTyD8hDxzELifjydW5lM75NLLXzIsc6tmfr3F+dzl00ly/TBzSgafeyzAqwcMNsnBK6ePwWwZ9s48jmi3c9aERERETSzyXNoH+mfM6ePevwcw4dSro3vUCBAg+iJBEREZH0y1YAnpkG3f4An1SOmD+yKGmX0P7ZWWpKqN7jA6kQspRTdQsbYjkibQS89xOLB3Yi6vZ1p/KazSb6Ny7FhDcasaO8J7s8Ew2PscbbWD3lKEt+PUBMREKar0FERETuziXNoJo1awKwfv16h58zZcoUTCYTDRo0eFBliYiIiKSfyQRVuydNCVXsZIzH3oS5/WHGsxB52fX1pVHOfMXoOGUl1955jmhvkyFeeu1J9rRrxt5VM5zOXTZ/Nv56JZCqnUowO1sCESbjlNDZ/deZ9vFWTu3OOpNVIiIiWYVLmkHdu3fHbrczbtw4zp8/f8/H//DDD3caRz169HjQ5YmIiIikn38+eOpP6D4RfFM5Yv7YkqQpoX0zstSUUFCfdymyYA5nKxknn/LcSMTjlRGEvNmD+Ngop/J6uJkZ2qocP71en3Wl3DmQypRQQkwif487yPIJh4iLtqT5GkRERCQ5lzSDevfuTbVq1YiLi6Np06YsXbo02X3gJpMJu93Ojh076NmzJ8OGDcNkMtG4cWPatWvnihJFRERE0s9kgipPwODtUPlxYzzuNswbAMFPQ8RF19eXRgWKV6LNnA1cGNSR+BTrHM12KLVoL5vaB3J0+zKnc1crkoP5QxpTpHUR5vnFE20yNspObL9C8CfbOH84PK2XICIiIv9isrtoO9/58+cJDAwkLCwMk8mEr68vMTExAOTJk4fIyMg7S6PtdjulS5dm06ZN5MuXzxXliRPCwsIoWrQoAKGhoRQpUiSDKxIREcmkDi+AkGEQncpR814B0PYLqN4zqYmURZw9tIXjw16l6NloQyzRDGE9GtPqndG4e3g6nXvr6XDen7GPKpeslLO4pfqYKk0K0/CJMnh4pR4XERF5mDyo379dMhkEUKxYMfbu3UuPHj0wm81ER0djt9ux2+1cu3aNuLi4O9NCTz31FNu3b1cjSERERLK2Sl3g5W1Q9UljLP42LBgM07rD7TDX15ZGJSo3oPmizZzr2ZjEFO8k3W1QYtoGVndqyNnDW53OXb9UbhYMC8KnST5CfBOIw/iZ5cF1Fwj+dBuXTt1O6yWIiIg88lw2GfRv586dIyQkhJ07d3L16lWsViu5c+emRo0adOrUiXLlyrm6JHGCJoNERETS4MhiWDwUolNZiOyZDdp8BjWfz1JTQke3L+Pi229T8FK8IRbnAeH9O9L81a8wm53//HH10SuMmHmAutfslEhMZQrIBDVbF6Nux1K4ebjs800RERGXelC/f2dIM0iyNjWDRERE0ijmBvz9Luy/ywlcpZpB558gRzHX1pUO8bFRrPzoRUos3os5lXeVZyvmpPr34ylYorLTuW9GJ/Dh/ANc2HmNJrEeeGBslOUs6EfrFyqRp0i2tJQvIiKSqWX528REREREHnm+ueCJ36DHTMhW0Bg/vQbGNIAdf4DNeNx6ZuTl40+HUdOxjP4f13O5G+IljtzkQtcnWTfpC6dz5/TzZHTPWvTtU42/8lq56Gb8nty8FM2sL3ayc+lZbNas8T0TERHJaGoGiYiIiLha+bbw8pak5dEpJURByBvwZxe4edblpaVV9RbPUGPpGk41K2OI+cXZyTfyT0J6t+Dm1fNO5+78WCHmvBnEhVrZWO9twZpil5DdZmfbgtPMGbWLW1di0nwNIiIijwo1g0REREQygk9O6DoGes6BbIWM8TPrYUxD2D4+y0wJ+QfkoeOvi7j9xavcymZ8m1lqx0WOdmjH1rm/Op07f3ZvJvatS9dnKzInZyLXzMbvybWzkUz/dBv714Rht2kTgoiIyN2oGSQiIiKSkcq2gsFboeZzxpglGpYMh8md4MZp19eWRvWfeJkKIUs5XcfY5MoRaSPgvZ9YPKgTUbevO5XXZDLRo24xpg5vzJEqvmz1smBLMSVkS7SzYeZxFvy0l8gbcem6DhERkYeVmkEiIiIiGc07ADr/DL3+guypLIY8txF+bQRbf80yU0I58xWjw5+ruPZ2b6K9jYufS685yZ52zdi7aqbTuYvl9iV4YAOCupVlToCFm6lMCV04epPgT7ZxdOsldF6KiIhIcjpNTO6pcuXkp39YLBZOnDgB6DQxERGR+y4uAlZ8BLsmph4v1gC6/AK5S7u2rnS4fO4we4b2p8Thm4aYzQRnO1an5Sfj8fLxdzr38f/H3n1GRXV9DRh/Zhh6FbuIYI29d0GwF+waNRprosZEk5iYxGisKZpiYowt9t5iF3vvig3sHRDsIiJN6n0/8GdeYIYySNX9W4uVkX3vuedSwsyeffZ5Eso3ay9S6O5rakfrNrAGKF2jEO59K2JhY2Lw+EIIIURukt3EhBBCCCHeBWY20HEG9N8Ktnq2mL9/CuY2hpOzID4ux6eXGcWcKtNmw3EefNKBKOPkMbUCZbZ7c6K9Cze89hg8doWi1mwY4UKVjs5ssI4mVKX7Pqevz3NWTT7NvYvPMnsLQgghxFtFKoOEwbIrMymEEEKIFKJCYf8kOLtQf7xk/YQm1IXK5+i03oTf1VPc+nokjn7hOrEYI3jQ25VWY2ahMTa8iscn4CXfrblImYAYqsTorxJ6r0ExXHtXwNRcf1wIIYTIS6QySAghhBDiXWNqDR7TYcB2sHPSjQd6JfQSOvF3vqkScq7SiObbT+Lf15XYFM9EjePAedUxDnZqgt+10waPXcPRji2jmlK8TUm2WkYRoadK6OaZx6yafJqAGy8yewtCCCFEvifJICGEEEKIvK50U/j0FDT4RDcWF5XQY2hRK3h6I+fnlgkaYxPajp+P8ZK/eFzMVCfu6BtGcK9B7Jv5LfEGNsw2MzZifIfKTP60PrtLqrit0U2SRb6MZtsMb46uvUVMdP5IogkhhBBZKU8sE/Px8eHOnTuoVCrKlClDzZo1c3tKIg2yTEwIIYTIRf4nYetn+reaNzIB9zHQ+Aswyh/LoKIiw9g/YQjOnt6o9Twr9atsT62/FlLMqZLBY4e+juGn7de4cvIRLSKNMUV3VzPrwua0HlSZYmVsMzN9IYQQIltl1+vvbEkG3bp1CwA7OzuKFCmS6nEHDx7k008/1e5MlcjJyYm//vqLzp07Z/XURBaQZJAQQgiRy6Ij4OBPcHoOoOepXIla0HkOFK2c41PLLO8Dawkd/zOFXsTqxMLMVUR82Q+3Ad9nauwD158wZd1lGjxXcIo10j1ABXXaOFGvQ2mMNFI4L4QQIu/INz2DLl26RMWKFalUqRK7d+9O9bg9e/bQtm1bbt++jaIoyT78/Pzo3r07q1evzurpCSGEEELkfyYW0PYXGLwHCpbTjT+8CP82hSO/Q1xMzs8vE2q26E2tXYe46657P1aRCkWmLsezXwuCn943eOwWlYqy+ZumhDe0Z795NDEpE2gKnN/tz7qpZ3keGJbZWxBCCCHyjSyvDPrjjz/49ttvsbOz48mTJxgbG+scExERQfny5Xn06BEA9vb2eHh4UKJECc6dO8eBAweAhMqiO3fuYG9vn5VTFG9IKoOEEEKIPCQmEg79DKdmg6Knv06x6gk7jhWrlvNzy6TTm+agTJ2NXaju/by0VqMeN5IGXfT0T0qHoihs83nI9I1XcX2hpkSc7vuiKiMVDTuVoWarUqjVusvKhBBCiJyUbyqDvLy8UKlUeHh46E0EAaxevZpHjx6hUqmoWrUqV65cYdmyZUydOpV9+/axePFiAEJCQli1alVWT1EIIYQQ4u1hbA6tf4LBe6FQBd3440sw3x0OT4PY6ByfXmY07PYpFT13ca9uCZ2YXWg8NmP+ZvvwjoSFBBk0rkqlonNNB/77pimBta05ZhZDXIoqISVO4dTmu2z64zwvn0a80X0IIYQQeVWWJ4OuX78OQNOmTVM95r///tM+njlzJsWKFUsWHzhwIO3atUNRFPbu3ZvVUxRCCCGEePs41oNhx8BlFKhSPMWLj4XDU2FBM3jkkzvzM1CBoqXwWHmAZ9/1I9xMt0Kn3KE7XGznjveBdQaPXdTGjKWD69Pxg4psKBDLM7VuBdKTe69Y86MXV44Ekgf2WxFCCCGyVJYngwIDAwGoVEn/jg/x8fGcPHkSlUpFyZIlcXd313tcz549Abhy5UpWT1EIIYQQ4u1kbAYtJ8HH+6GwnudiT67A/GYJzadjo3J8epnRdNBYHLb8h1+lAjqxQi9iMR4xiR3ffkBUZLhB46pUKvo2cGLFaBeuVTXnjGkMSooqofiYeI6sucW2md6EBb9+o/sQQggh8pIsTwaFhSU03bOxsdEbv3r1KuHhCX+s3dzcUh2nYsWKAAQFGVb+K4QQQgjxznOoA8OOgOtoUKXYPUuJg6O/Jywde3AhV6ZnqOLOVWiz8TgPPulAVIouBGoFymzz5kT7Jtw4u8fgsZ0KWrLmk8a4dC/HBpsYXuqpEgq8HsyqyWe4eeaxVAkJIYR4K2R5MsjMzAyA0NBQvfEzZ85oH9epUyfdcV6/lndhhBBCCCEMpjGFFuNhyAEoUkU3/vQaLGwJ+yfniyohtVpNyy9/x27tYgKdLXXixR9FET3wS3b9NIzYGMN6IxmpVQxtWpb5XzfBq4IJ3ia629vHvo5j/5Jr7J5/hcjQ/NF7SQghhEhNlieDihcvDoC3t7fe+LFjx7SPGzZsmOo4wcHBAFhZWWXd5IQQQggh3jUlasHQw+D2Hag1yWNKHBz/M2Eb+sDzuTI9QzlXaUSz7Sfx6+NCbIpnssZx4LzyKAc7NcH/2hn9A6ShQlFrNox0oVJHZzZZRROq0q0CunfxGSsnncHX51lmb0EIIYTIdVmeDKpbty6KorBkyRKdWHh4ONu3bwfA2tqaunXrpjrOzZs3AWTbciGEEEKIN6UxgWZjYcghKKpni/lnN2BRS9g3AWLyflW2xtiEdhMWYLzkLx4XM9WJO/qG8aLXQPbN/Jb4eN1lX2kxNlLzVasK/PlFQw6XVnPNWLdKKDo8hp1zL3Ng2TWiI3XjQgghRF6X5cmgDz74AICLFy8yZMgQXr16BcDLly8ZOHAgL1++RKVS0aNHD4yMjFId5+jRowBUqaKnrFkIIYQQQhiueHUYegjcx4I6RfMdJR5O/A3zXCDAK3fmZ6CKDdrSeNdx7nWsQcqUj1kMlJyznT09XHnsf93gsWs42rFlVFOKti7JVosoIvRUCd049ZhVU84QeDM4k3cghBBC5A6Vkg1d8FxdXTlx4gQqlQqNRkOhQoV48uQJiqKgKAomJiZcvnyZ8uXL6z0/IiKCYsWKER4ezt9//82IESOyeorCACkTcjExMdy+fRuAgIAAqd4SQggh8qPHV2Drp6lsNa+CRp9Bs3FgYpHjU8sM731rCJ34C4Ve6FbqhJmriPyyH00HfJ+psU/dDeKHNT5UfxxHuVj9b2ZWb16SRl3KojFJ/c1OIYQQwlCBgYE4OjoCWfv6O8srgwA2btxI1apVURSFmJgYHj16RHx8PIqioFarmTNnTqqJIIBly5ZpdyVr06ZNdkxRCCGEEOLdVqwqfHwAmo8HI5MUQQVOzUqoEvI/lSvTM1TNVh9Qa9ch7rqX04lZRSoUnrocz34tCX563+CxG5UtyJbRrhi7FWaXeTTR6L6XeulgIGt+8uKJ76tMzV8IIYTISdlSGQQJ1SPz589n27Zt3L9/HxMTE2rXrs2nn35KvXr10jy3W7du2ozX5s2bs2N64g1kV2ZSCCGEELnk6XXY8ik81LfVvAoafJKwM5mJ7i5eedHpjXNg6mxsw3T7Bb20VqP+4XMadB6WqbH3X3vCT+sv0+CZQqk4PVVAKqjbzpm67Z0x0mTL+65CCCHeIdn1+jvbkkHi7SXJICGEEOItFBcLp/6BQ1MhTs9W8wVKQ+dZ4OyS83PLhBeP/Tn19SDKnH+kN363WXncpy3Byrag4WOHR/PD5ks8Ofecpq+N0aDSOca+pBWtB1emYAnZGVcIIUTm5atlYkIIIYQQIp8x0oDLKPjkGDjo2fE12BeWesDObyAqLOfnZyD7Yk54rDrIs+/6EW6mm6wpe+g2F9q743NwveFjW5owu28d+g+sxsZCsTwy0q1AehEYxrqfz3J+tx/xcYbtaCaEEEJkN0kGCSGEEEKI/1f4PfhoL7T6ETRmunGv+TC3Mdw7kvNzy4Smg8bisHk9/hUL6MQKB8Wi+Wwint/1ISoy3KBxVSoVnWs6sP4bNwJqWXPCLIa4FL2ElDiF01vu8d+v5wh6kPcTaEIIId4dkgwSQgghhBDJqY2gyefwyQlwbKgbf+kPyzuB5yiICs35+RmoeOmqtN50nAefeBBlnDymVqDs1oucaN+EG2f3GDx2MVszln5UH48PKrKxQCzP1bpVQM/vh7Hul7Oc2+lHnFQJCSGEyAOyvGfQlClTsnI4ACZMmJDlY4rMk55BQgghxDskPg7O/AsHpkBspG7c1hE6/QNlm+X83DLB78opbo8eSUk/3UqgGCN48EFTWn33DxrjlDuspc8/KJxv1npjfiuMelEaVHp6CRUsaUWrQZUp6CC9hIQQQqQv3zSQVqvVqFS6f/jeRFxcXJaOJ96MJIOEEEKId1DQXdg6Au6f1B+vPQBa/whmtjk7r0yIjY5i37QRlFx7HI2eQp2A0la89+dsnCrVN3jsuHiFRcfvsWrHbVqEaigYr1uIr1KrqOfhTO22ThgZSaG+EEKI1OW7ZFBWDatSqSQZlMdIMkgIIYR4R8XHw9mFsH8ixEToxm0coONMKN8y5+eWCTdO7+LRmO8p9lh397TXxvB8aEdafDYNtdrwhM29Z2GMWe+D2f+qhNR6dxyzpNXAyhQqaZ2p+QshhHj75btkkJmZGZ07d6Z///5UqlTpjcZ0cnLKotmJrCDJICGEEOId98IXto0Ev2P64zU/hDY/g7ldjk4rM6Iiw9g//mOcPX30NtP0rWJP7T8XUszJ8OezcfEKy076sczzJs1faSikp0oINdT3KC1VQkIIIfTKN8mgVq1acejQIeLj47XLxerUqUO/fv3o3bs3hQsXzsrLiVwgySAhhBBCEB8P5xfD3gkQo2cnLuvi0PFvqNAm5+eWCd771hA24RcKBsfqxMLMVUSO6k/T/mMyNbbf83C++88Hkxuh1E+lSqiAQ0KVUGFHqRISQgjx//JNMgjg4cOHrFq1ipUrV3L58uWEC6lUaDQa2rRpw4cffkjnzp0xNTXN6kuLHCDJICGEEEJoBfsnVAn5prLVfI0PoO1UMNfd2j2vCXv5jMPfDaLskbt643frO9Bk+hIKFHY0eOz4eIWVZ/xZvO0mzUKMUq0SqtfOmTrtnDHSSJWQEEKIfJYMSurSpUssW7aMNWvW8Pjx44SLqlTY2Njw/vvv8+GHH9K0adPsnILIYpIMEkIIIUQyigLnl8Le8RCtZ6t5q2LQ4S+o2D7Hp5YZpzfOhqlzsA3T7S4dbKPGaNznNOg8LFNjB7yIYMx/PqiuvaJBKlVCdsUtaD2oCoVLSZWQEEK86/JtMihRfHw8+/fvZ/ny5WzZsoWIiAjtMrJSpUrRr18/PvzwQypUqJAT0xFvQJJBQgghhNDrZQBs/xzuHtQfr9YT2v0KFvY5O69MePHYn1NfD6LM+Ud643eal6fZ1CVY2RY0eGxFUVjjFcCCrTdwe6mmsL4qIRXUbedM3fZSJSSEEO+yfJ8MSio8PJxNmzaxbNkyDh8+nKy/UOPGjTl2LJVmhCJPkGSQEEIIIVKlKHBxJewZC1GvdOOWRaDDn1CpY87PzUCKonBs6S9Y/L0Ky9e6T5mfFdRg++N4ajTvmanxH7yM5Pv/fIi7EkLDVKqEbItb0HpgZYo42WTqGkIIIfK3tyoZlNTDhw9ZvHgxv/zyC69fv8bMzIyICD1blYo8Q5JBQgghhEhXyAPY/gXc2ac/XqUbtP8dLAvl7Lwy4ZHvFXxGDcXpRrBOLF4Fvp1q0WrSAkzNLQ0eW1EU/jsXyNwt13ALNkq1SqhOWyfqtS+NkbFUCQkhxLsku15/5+pfk1OnTvHTTz8xY8YMoqKicnMqQgghhBAiK9k6QN//oMtcMLXVjV/dBLMbwNUtOT41QxUvXZXWm47zYGh7ojTJY2oFym69yHEPF26c3Wvw2CqVip71HFnzrRsBdW04aRpDHCneq1Xg/C5/Vv/kxVN/PdVWQgghhIFyvDLo7t27rFy5kpUrV3Lv3j0g4R0RMzMzOnXqRP/+/WnfPn80F3xXSWWQEEIIIQzy6hF4fgm3duuPV+4M7aeDVeEcnVZm+F05xe2vR1LSP1wnFmMEDz5oSqvv/kFjbGLw2IqisOnCA2ZtukrTYCOKpFIlVLt1Kep3KCNVQkII8Q7I18vEgoODWbt2LStWrODMmTNAwh87lUqFq6sr/fr14/3338fGRtZC5weSDBJCCCGEwRQFLq2HXd/C65e6cXN78PgjYfmYSrd3Tl4SE/2a/dNGUnLtcTS6G44RUNqK9/6cjVOl+pka/+mr1/yw6TJh3i9o+FqDkZ5eQjZFzWk9sApFS8vzZyGEeJvlu2RQTEwM27dvZ8WKFezatYuYmBgSL1WhQgX69etHv379KFWqVHZcXmQjSQYJIYQQItNCH8OOr+GGp/54xQ7g8SdYF83ZeWXC9dO7eDzme4o91m138NoYng/pSIsR01CrDa/gURSFbT4PmbnxKk1eqCkap79KqFarUtTvWBqNsVFmbkEIIUQel2+SQcePH2flypX8999/vHz5UpsAKliwIL1796Z///7Uq1cvKy8pslmVKlWS/TsmJobbt28DkgwSQgghRCYoClzZCDu/gcgXunHzAtDuN6j2fp6vEnodEcqB8R/jvOOS3mac/hVsqfT7Pzi9l7nnv89Co5iw+TIvLwTRKJUqIevC5rQeVJliZfT0ZhJCCJGv5ZtkkFqtRqVSoSgKpqamdOrUiX79+tG2bVs0Gk36A4g8R5JBQgghhMgWYU8TqoSub9Mff689dPgLrIvl7LwywXvvasImTqVgcKxO7LUxPBvYhhZf/oGRUeaeD++49Ii/NlyhUZCKYqlUCdVs6UiDjmXQmEiVkBBCvC3yXTLIzMyMNm3aYGdn90bjqVQqFi1alDWTE1lClokJIYQQIktd3ZyQFIoI0o2Z2ULbaVDjgzxfJRT68ilHvhtE2SP39MYDSltR9rc/KVvNNVPjB4VFMWnrVZ6dfUbjVKqErAqb0WZQFakSEkKIt0S+SwZlpbi4uCwdT7wZSQYJIYQQIsuFP09YNnZ1k/54+dbQ8W+wKZGz88qEM5vmEjdtNgVe6T6HjdbAow/caPHNDIxNzDI1/u4rj5n+3xUaPkd/lRBQo6UjDTtJlZAQQuR32fX6O1v2o1QUJUs/hBBCCCHEW86yELy/BHquAEs9W8zf3guzG8KFFQk9h/KwBt2GU3X3fu66l9OJmcSC04ojHPFozM1z+zI1ftuqxVj/bVPCXApy1CyGWHS/Hj77A1g55QyP7rzM1DWEEEK83XJka3nxdpHKICGEEEJkq4gXCVvQX/5Pf7xsC+g0E2zz/nOQ8zuXEfHTHxR6odtLKFYNAd0b0nLcbEzMLDI1/oHrT/h13WXqP4PiqVQJVW9ekoZdymIsVUJCCJHv5KvKICGEEEIIITLNwh66L4Teq8FKzxbzdw8kVAmdX5rnq4TqtB9ArV2HudemMvEpYpp4KP3faY63a8zVk9szNX6LSkX571s3XjctxJFUqoQuHQxk1eQzPLz9MlPXEEII8faRZJAQQgghhMibKnrAp6cTmkenFB0K27+AFV3g5f0cn5ohrGwL4vH3RmJnT+ZpYWOdePFHUSgffYvnd32IjHhl8Pi2Fsb80asmw4fXYldxeGiUMu0E4UGv2Tz9AkfX3SImSvpxCiHEuy7PJ4POnz+f21MQQgghhBC5xcIeus6DD9aBdXHd+L3DMKcRnF0I8bpJkLykRoue1N9znHudahGXYr8VIwXKbr3ImbYu+BxKZXlcOpq9V4T13zUlvllhDqdSJXT5UCArJ5/m4e3gTF1DCCHE2yHPJoNOnjxJu3btaNCgQW5PRQghhBBC5Lb32iZUCdX8UDcWHZawNf3yThDsl+NTM4S5hQ0ev61GtWAaj4uZ6sSLPo1BM3wCnl/2IOxVkMHj25gZM7VHDT7/rDa7S6j0VglFvIhi8/SLHFl7U6qEhBDiHZXnkkEHDhygWbNmuLq6snfvXtlNTAghhBBCJDC3gy6zoe8GsHHQjfsdgzmN4cz8PF8lVMWlM012ncS3RwNiUzwjVwNld1/lYlt3zu9alqnxXcsX5r/vmqJqWYRDZjHE6KkSunL4ASsmnebBTakSEkKId0227SamKAqbN29m//79BAQEYGxsjLOzMz169KBx48Y6xx8+fJixY8dy5swZ7fkArVu3Zvfu3dkxRZFJspuYEEIIIXLd6xDY+wNcWK4/7tQEOs8C+zI5O69MuHl2LwHfj8EhMFJv/G6z8jT9ZQE2BfQ0086Ak3ef89OaS9R8FIdDnP4dxao0LUHjbuUwMdNk6hpCCCGyR3a9/s6WZJC/vz+dO3fm8uXLeuPvv/8+q1atwsjIiKCgID7++GO2bdsGJCSBVCoVnTp1Yty4cdStWzerpyfekCSDhBBCCJFn3DmQ0Eg6JEA3pjGHlhOh/jBQ57mC+GRiol9z4LcvKL7mKCZ6Vm69sDXCaMwIGnb9JFPjR0TH8tuuG1w+FIjra2OMUekcY2ZnQpuBlSlZ0T5T1xBCCJH18k0yKDo6mjp16nD16tXUL6pS8fXXXzNy5Ejc3Nzw9/dHURSMjIzo2bMnY8eOpUqVKlk5LZGFJBkkhBBCiDzl9SvYPxHOLdYfd2wInWdDoXI5O69MuHvpGPe+/YqSfmF643eaOOEybQEFCjtmanwv3xdMWe1NtYdxlEylSqiyawmadJcqISGEyAuy6/V3lr9FsmrVKq5evYpKpcLZ2ZmFCxdy5swZLl68yOrVq6lVqxaKojB37lz69OmDn58fiqLQvXt3rl27xqpVqyQRJIQQQgghMs7MBjr8Bf23gl0p3XjAaZjXBE7+A/F5u2Fy2equNPc8ScBHrYnS3YWecif8udG+LSfW/pWp8euXtue/b9ywbFuCg+bRensJXTv2kBUTTxNw40WmriGEECLvy/LKoI4dO7Jjxw4cHR25evUqVlZWyeLx8fE0bdqUkydPAmBkZMSiRYvo379/Vk5DZCOpDBJCCCFEnhUVBvsnwdkF+uMl60HnOVC4Qo5OKzP8r3tx49vPKXU7RG/8Xr0SNPh1PoVKlM3U+Of9g5m02psqgbE4plIlVLFJcVx7lMfEXKqEhBAiN+SbyiAfHx9UKhXffPONTiIIQK1WM2XKFCBhuVi/fv0kESSEEEIIIbKGqRV4/AEDPKGAs2488CzMc4HjMyAuNqdnZxCnSvVptfUkDz/tRKSJbrzM2Yfc69CRI0t/IT4Tu6fVcSrAf6ObYuvhwEHzaKL1VAndOPGI5ZNOE3BNqoSEEOJtkuXJoKCgIACqVq2a6jHVq1fXPu7Ro0dWT0EIIYQQQrzrSrvC8JPQQE/D5biohB5Di1rB0+s5PzcDqNVqWnz+K8U2r8Ovsm5jZ+sIhSLTVrDrA3ce+xt+L2bGRnzfvjLjv2rIYWcj7hvpLqOLColm20xv9i+/TnRk3k6gCSGEyJgsTwZFRiZsiVmkSJFUjylUqJD2sSwxEkIIIYQQ2cLEEtr9CoN26d9i/uEF+LcpHJue56uESpStTpsNx3jydS/CzXR3Aivj84zAzt05MG98pqqEajrasX60K4U7OnLAIkZvldDNk49YPvEU968GZeoehBBC5B25vsemRiPrj4UQQgghRDZyagyfnICGn0HKLdXjouHAFFjYAp6kvhtuXqBWq3EfMolS2zfjW7OoTtzytUKJGRvY092FwDsXDR7fVGPE6LYVmfxVQ46V0XBfo6dK6FUM2//xYd+ya0RJlZAQQuRbuZ4MEkIIIYQQItuZWEDbX2DwHiioZ4v5R97wrxsc+Q3iYnJ8eoYo4vge7dYc4vnYgbyy1K0Scr4ezNNufdg3YzRxmah4qlbSlrVfuVKsU6lUq4RunXrM8gmn8L8iVUJCCJEfZfluYmq1GpVKxfDhw9NcKjZp0qQMHQcwYcKErJyieEOym5gQQggh8rWYSDj0C5yaBYqeJVXFqkOXOVCsWs7PzUBBj3w5/d1QyngF6o37l7eh4q9/41y5YabGv/bwFRNWe1PGLwqnWP07jpVvWAy3nuUxtTDO1DWEEEKkLrtef2dbMigrxcXplqiK3CPJICGEEEK8FQLPwZZP4flN3ZhaA66jwfVr0OjZyiuPObl+Jqrf/8UuVDe5FaWBJ/1a0OKrP9EYG34vMXHxzDt0h0O7fHEN12CScqkdYGxlTOsBlXCuVkjPCEIIITIrXyWDspJKpZJkUB4jySAhhBBCvDViXsORaXDib/1VQkWrQufZUKJmjk/NUC+fP+D490Moe8xXbzzA2ZIy0/6gXE33TI1/83Eo41d743TvNc6pVAmVq18Ut14VMLOUKiEhhMgK+SYZdOTIkawcDgA3N7csH1NkXJUqVZL9OyYmhtu3bwOSDBJCCCHEW+LBedjyGTzTsz27yghcv4Km34DGNOfnZiCvrfOJmToT+5e6b6hGG8HDni60+H4mJibmBo8dGxfP/KP32LfjLq5hGkz1VQlZamg9oDLO1aVKSAgh3lS+SQaJt48kg4QQQgjxToiNgqO/w7E/QdFTmV64UkIvIYfaOT83A4W9fMbhcUMoe0DPEjjgoYMZJX75hUoN2mVq/DtPQ/lhtQ8l70RSOpUqoTL1itCs93tSJSSEEG9AkkEiz5BlYkIIIYR4qz30hq2fwZMrujGVETT5HNzGgLFZjk/NUBf2rCRsyq8UDtLdVSxWDfe71KXl+HmYmlsaPHZcvMKiY/fYtf1OqlVCGksNrftXonSNwpmavxBCvOuy6/W3bC0vhBBCCCFEUiVqwpBDCQkftSZ5TImD43/Bv00TGlDncbXbfEid3Ue4174a8SlyNZp4KLPpHCfbNeHy0c0Gj22kVjHUrSzTv2vChcpm3NPoVlPFhseyc+5ldi64zOuwmMzehhBCiCwmySAhhBBCCCFS0phAs+8TkkL6tph/fhMWtYK94xO2qs/DLK3t8fhzPfFzf+JJEd3dxIo9jkI9bCw7RvciIuylweOXKWzF8hGNqdK7LPutY4hCd+GB7/lnLJtwinvezzJzC0IIIbKYJIOEEEIIIYRITfHqCQmhZuNAnaL3jRIPJ2fCPFe4fyZ35meAau7dabTnBPe61iEuRZWQWoEynpc427YpF/evMXhstVrFYJcyzBjjwsUq5tzVVyUUEcuueZfZMf8ykWHRmb0NIYQQWUCSQUIIIYQQQqTFyBjcvoVhR6B4Dd140G1Y3Ab2jIPoiJyfnwFMza3wmLoSo8XTeVRCt+dRkecxmIyYwvaRXQkLeW7w+E4FLVn2WSNq9inHfutYXuupEvK78Ixl409x9+LTTN2DEEKINyfJICGEEEIIITKiaBX4+AA0Hw9GKZdbKXBqFsxrAv4nc2V6hqjUqD0uu07g17sJMSk2A1MD5fbdwLutO2c9Fxk8tlqton/j0sz83oUr1fVXCcVFxrH73yt4zrtEZKhUCQkhRE6TZJAQQgghhBAZZWQMTUfDsKNQQs8W8y/uwZL2sOs7iA7P+fkZwMTUgnaTFmK+YjYPSlnoxAsGx2E1+g88h3oQEvTI4PEd7S1YPLwRdT6swAGbWF6rdKuE/L2fs2zCKe6clyohIYTISZIMEkIIIYQQwlBFKsFH+6DlZDAyTRFU4Mw8mNskX+w4Vr52c9x3nOL+gOZEa3TjZY/e42q7lpzaMMvgsVUqFX0bOvHPWFeu1bDkTipVQnsWXGHb3EtEvJIqISGEyAmSDBJCCCGEECIzjDTg8iV8chxK1tONB/vCotZw9HeI102C5CUaYxPafD8b27WLCShrrRMv8Coeux9m4zmwFS+e+Bs8voOdOQuHNaDhgPc4YBtLpJ4qoQCfhCqh2+eeZOoehBBCZJwkg4QQQgghhHgThSvA4D3Q+ifQpGjKrMTBwZ9gWUd4GZA78zOAc9VGtNh2kgdD2/PaWDde9nQgtzzac2zlbwaPrVKp6FWvFHPGNuVWLStu66kSin8dx96FV9k620eqhIQQIhtJMkgIIYQQQog3pTaCxiPhkxNQsr5u3P9EQnPpK5tyfm4GMjLS0PKr6RTeuAr/inY6cduweAr9tIQdfZrxNPCWweMXszXj3yH1cR1UkQN2cXqrhAIvB7FswilueT1GUXTjQggh3owkg4QQQgghhMgqhcrBoF3gNgZUKZ5qvw6BDYNgy6cQFZo78zNAyQq1ab3pBI8+70aEqUonXubCY/w7duHQwsnEx8cbNLZKpaJ7HUfmjXXlXh1rbhnrrxLat/gaW2f7EB4Slen7EEIIoUulSKpdGCgwMBBHR0cAAgICKFmyZC7PSAghhBAiD/I/BZuGQsh93ViB0tB9EZSsk/PzyoTH/te4MHoYpS8/1xv3rVqQmr/PpUTpagaPrSgK23wesnzdNRq+VGOh6CaeVKZqWvSpSIX6RVGpdONCCPG2yq7X31IZJIQQQgghRHZwagSfHIOqPXRjwb6wuDUcm57nm0sDFHOqTNt1R3j6bV/CzHWTMaWvBPGoS08OzPo+U1VCnWs6MG9sU+7Xt+GmniohJSqe/UuusfkfqRISQoisIMkgIYQQQgghsou5HXRfCF3/BZMUu3TFx8KBKbCsE4QE5sr0DKFWq3Eb/APOntu4V6e4TtwiCkrM2sLero25f/OcweMXtjbln0H1aDu0Kgft44jQ00vo0bUXLBt/ihunH0kvISGEeAOSDBJCCCGEECI7qVRQo3dClZC+Lej9j8PcJnB1S45PLTMKO5TDY9VBXoz/mBAr3ZcTTjdDCOrRj73TvyQuLtbg8dtXK86CcW48aGjHDWPd85XoeA4svc6mmd6Ev5QqISGEyAxJBgkhhBBCCJET7EsnNJdu+q2e5tIv4b8BsPUziArLlekZqknfr3lv5y7uNiqlEzOLAccFezjQsTH3Lp8weGx7SxNmDKhDh0+qc9A+nnA9VUKPrwezbMIprp+SKiEhhDCUJIOEEEIIIYTIKUbG0HwcDNwBto668Ysr4d+m8OBCzs8tEwoUKUWHJXsI+XkkwTZGOnHHe6GEfvAxu38eTkyM4VU8baoUY9EPTXnauADXU6kSOrjsOhtnXCQsWKqEhBAioyQZJIQQQgghRE5zagyfHIeq3XVjL+7ColZw7M980VwaoGH3T6m6ez933cvpxExiwWnFYY60b8yt8wcMHtvOwoQ/+tWm66c1OFxIf5XQk5svWTbhFNdOPJQqISGEyABJBgkhhBBCCJEbzO0StpfvMg9MrJLH4mPhwGRY3hlCHuTK9AxlY1+MDvO2EzH9O4IKaHTiDgERRPUbwc4Jg4mOijB4/BaVirJwnBtBLvZc01MlREw8h1bc4L+/LhAW/DoztyCEEO8MSQYJIYQQQgiRW1QqqPlBQnNph7q6cb9jMLcxXNua83PLpDoeA6m5+zB3W1ci5Sbzmngovf4Ux9s24dopT4PHtjU35te+tXh/RE0OF1b0Vgk9uxXCsgmnuHpcqoSEECI1kgwSQgghhBAit9mXgcG7wXU0oEoee/0S1veHbSMhOjw3ZmcwK9uCdJi5idjZk3hWyFgnXvzRa+IHf8OOMX15HRlq8Pju7xVh8bimhLgV4qreKiGFwytvsH76BUJfSJWQEEKkJMkgIYQQQggh8gIjY2gxPqG5tE1J3fiF5QnNpR9ezPm5ZVKNFr2ot+cY9zrWJD5FjstIgTJbLnC6jQs+h/4zeGxrM2N+7l2DPp/X5kgRCNNTJfT8TgjLJ5ziyrEHUiUkhBBJSDJICCGEEEKIvMS5CQw/DlW66saC7sDCVnB8BsSnXISVN5lb2uLx+xpYMI3HxUx14kWfRqMZPgHPUT0ID31h8Pgu5QuxeFxTwpsV5oq+KqFYhSOrbrLuj/NSJSSEEP8jySAhhBBCCCHyGvMC0GMJdJ4DxpbJY/ExsH8irOgMrx7mzvwyoYpLZ5rsOolf9/rEpngVogbK7rrKhTZunN+9wuCxrUw1TOlZnf5f1uFoUf1VQkF3X7F8wikuHQmUKiEhxDtPkkFCCCGEEELkRSoV1Oqb0Fy6RG3duO/RhObS17fn/NwyycTcgnY/L8N46QweljTXiRd6EYvFl7/gObwTr4KfGDx+o7IFWTKuKa9bFuGKif4qoWNrbrH29/O8CorMzC0IIcRbQZJBQgghhBBC5GUFy8JHe8H1a3SaS0cGw7oPYdvn+aa5NEDF+m1ouvMk/n2bEm2kGy976DaX27bgzNZ/DR7bwkTDxO7VGPxVXY4XVxGqp0roxb1XLJ94Gp/DAVIlJIR4J0kySAghhBBCiLzOyBhaTICBnmDjoBu/sAz+dYOH3jk+tcwyNjGj7fh/sVr9LwHOljpx+5A4bL6bgedHbQl+FmDw+PWc7Vn8fVPi2xTlsp4qIVWswvG1t1n96zlePZcqISHEu0WlSCpcpKNKlSrJ/h0TE8Pt27cBCAgIoGRJPbtdCCGEEEKI7BEZDNu/hGtbdGPq/+1I1mgkqPPP+76xMdEcnPENRZbvxTRGN/7SWk386CE06fVlpsY/7x/M9GXeVHsUh42i+3VRjFS4dC9HDfeSqNQqPSMIIUTuCAwMxNHREcja19/55y+EEEIIIYQQIqG59PtLofNs/c2l902AFV3yVXNpjbEJrb/5mwLrl3G/vI1O3C40HvuJ/+LZryXPH90zePw6TgVY/H1TVO1KcElflVCcwon1t1n161lCnkmVkBDi7SeVQcJg2ZWZFEIIIYQQBgq6Cxs/gocXdWPmBaDTLKjUIefn9Qbi4+I4OHss9gu3YR6tG39loSLqi3649PsOdSaqn3wCXvLbMm+qPohNtUqocbey1GrmKFVCQohcJ5VBQgghhBBCiOQKloWP9oHLV+hvLt0Xtn+Rr5pLq42MaPn5rxTbvA6/yvY6cZsIhcJTl7Prg2Y88b9u8Pg1HO1YPMYVkw4OXDLVXyV06r87rJx2lpBnEZm6ByGEyOskGSSEEEIIIUR+ZmQMLSfCgO1gXUI3fn4pzHeHRz45PbM3UqJsddpsOMaTr3oRbqZboVPG5ykBnbtz8N/xxMfHGzS2qcaIrz0qMfLbBpxyVBOi0j3/1f0wVkw6w/l9/ijxsphCCPF2kWSQEEIIIYQQb4PSrjD8BFTqpBt7fgsWtICT/4CBiZPcpFarcR86Ccdtm/CtWUQnbvlaofhfG9jT3YUHd7wNHr+qgy2Lv2uKRaeS+KRSJXR6411WTPXi5VOpEhJCvD0kGSSEEEIIIcTbwsIeei6HTv+AsUXyWHwM7P0BVnaD0Me5M79MKlqqIm1XH+L52AG8stStEnK+HsyTbh+w/+9viIvTTeqkxUSj5st2Ffnyu4acKWWkt0ooNCCclZNOc26vVAkJId4OkgwSQgghhBDibaJSQe3+MOwYFK+pG793COY0ghs7c3xqb0KtVuPafwzltntyr76DTtw8GhzmerKvSxP8r50xePzKJWxY9J0rNl0c8TGN04mr4uHMprss/8WLl0+kSkgIkb9JMkgIIYQQQoi3UaFyCc2lm3yBbnPpF7D2A/D8CqLzV2KjYIkyeCzfT/DkT3hprftyxun2K4J7DWTPryOJjdGzHVkajI3UjGjzHqPHNuSss4aXat0qobDAcFZOPs3ZPX7ES5WQECKfkmSQEEIIIYQQbyuNCbSaAv23gnVx3fi5RQnNpR9fzvGpvanGvb6g0q693HMprRMzjYFSS/ZzsGNj7ngfMXjsCkWtWfiNC/bdnPAx018l5LX5Hst/OkPw4/yzU5sQQiSSZJAQQgghhBBvuzJuMPwkVOygG3t+ExY0h1Oz81VzaQC7Qg54LNxJ6K+jeGFrpBN39AsnvO8n7JoyhJjo1waNrTFSM7xleb4d24jzZYz1VgmFP4xg1ZQznNklVUJCiPxFkkFCCCGEEEK8CyzsoddK6Pi3bnPpuGjYMxZWdc93zaUB6nceSvU9B7nbvIJOzCQOnFcf50j7xtzw2mPw2OWKWLFgtAtF3nfG20zPjmPxcG7rPZb9eFqqhIQQ+YYkg4QQQgghhHhXqFRQZyAMOwrFa+jG7x6EuY3h5u4cn9qbsrYrQoc5W4mcMZbn9hqduENgJDEDv2TnuP5ERxrWJ8lIrWJIs3KM/aEJF8uZEKynSijiUSSrppzh1E5fqRISQuR5kgwSQgghhBDiXVOoPHy0Hxp/rhuLCII1vWDH1xATmfNze0O12/aj9p4j3GtXlfgUfbM18VB641lOtGvMleNbDR67dCFL5n/VhBI9S+NtHodC8qSPKh4ubPNl6ZTTvHgkVUJCiLxLkkFC5EMDBw5EpVLh7Oyc21PJV4KCghg9ejSVKlXC3NwclUqFSqVixowZuT01IYQQIudpTKD1j6k3lz678H/Npa/k+NTelKW1PR5//Ufc3B95UsREJ17scRSqIWPwHN2biLCXBo2tVqsY7F6WH35ozKUKpnqrhCIfR7LqxzOc3H6P+Lj81YdJCPFukGSQEKkICQlh9uzZtG/fHmdnZywsLLC1taVChQr07duXdevWERenu7uEyJtCQkJo1KgR06dP58aNG7x+bVgTSSGEEOKtVcY99ebSz27AgmZwak6+ay4NUN29B432nMC3Sx3iUlQJqRUo6+nD2bZN8d6/xuCxnQpaMu/LJpTqU1ZvlZA6Hi7u8GPJlDMEPQx7k9sQQogsp1IURRa0CoMEBgbi6OgIQEBAACVLlszlGWW9BQsW8P333xMUFJTmcZUrV+bff//FxcUlh2aWYODAgSxbtgwnJyf8/Pxy9Nr51S+//MK4ceMA+Pbbb+nYsSN2dnYAFC9enIIFC+bi7IQQQog8QFHg/FLY/T3E6lkeVrYFdJkL1kVzfGpZ4fqpHTwa+wPFH+m+IRQP+LaqiPtPC7GyNfw5QcCLCH5Z5k2J2xHYx+u+3x6vglrtnGjsURq1kbwfL4TIuOx6/S3/JxIihdGjRzN06FCCgoLQaDR8+OGHrF+/njNnznDs2DEWLlxI8+bNAbh27RotW7Zkw4YNuTxrkZ79+/cDULduXX799VdcXFyoWrUqVatWlUSQEEIIAQnNpesOSmguXay6bvzugYTm0rcM35ErL6jUyAOX3Sfw69WY2BSvgtRA2X038G7rzlnPxQaP7WhvwZwvG1H2w3J4W+ipElLAZ6c/iyedJuiBVAkJIXKfJIOESGLOnDlMnz4dgJIlS3L27FlWrFjB+++/T/369XFxceGjjz7iwIEDrFq1ChMTE6Kiovjwww/x9vbO3cmLND148ACAChV0t5wVQgghRBKFK8DH+6HxSN1YxHNY3RN2jM6XzaVNTC1oN3kRZitm8aCUhU68YHAsVqN/x3OYByFBjwwaW6VS0aexM5MnuHC9kgVBenoJRT17zZqfvDi65Q5x0ktICJGLJBkkxP/4+/vz9ddfA2BpacmBAweoWbNmqsf36dOHxYsT3jmKioqiX79+yKrLvCsqKgoAY2PjXJ6JEEIIkQ9oTKH1T9BvM1gV042fXQDzm8GTqzk/tyxQvk4L3Hec4v6AZkTr7kJP2SP3uNquJac3zjZ47BJ25sz6vCEV+5fH2zKO+JQ7jilwefd9Fk86zfNAqRISQuQOSQYJ8T8zZszQNhWeMGFChipI+vbtS9u2bQG4cuUKnp6eOse4u7ujUqlwd3cH4Pbt24wYMYLy5ctjYWGBSqXS6ftz/fp1Bg4ciKOjI2ZmZjg6OtKnTx/Onj1r0D09fvyYcePGUbduXezt7TE1NcXR0ZGePXtql03p4+fnp91pa+nSpQBs2rSJ9u3bU6JECTQajfZ+Et26dYuRI0dStWpVrK2tMTExoUSJEtSsWZPBgwezbt06bUIms7Zv306PHj0oWbIkpqamFCxYkEaNGjFt2jTCwnSfTB0+fFh7H/7+/gAsW7ZM+7mk3xdDxcfHs2bNGrp3706pUqUwNzfH3Nxc22B8w4YNxMTE6D03OjqaOXPm0KxZMwoXLoyJiQnFihWjffv2rFy5kvg0GnSm3Enu5cuXTJgwgSpVqmBpaYmdnR1NmzZl1apVes+fMmWK9t5v376d7n22adMGlUpF8eLFU22YvmXLFt5//31KlSqFmZkZdnZ21K1bl8mTJxMcHJzhe3n06BHfffcdVapUwdraGpVKxeHDh5Odc//+fYYPH07p0qUxMzOjRIkSdOnShUOHDgEwadIk7f2lJSQkhKlTp9KkSRPt96B48eJ07NiRDRs2pJnYTRx/0qRJAJw9e5YPPvhA+3Pp4OBAv379uH79eppzSHTlyhVGjhxJtWrVKFCgAMbGxhQrVoyWLVvy22+/8ehR6u9MZ/Z3XAghMqxs84Tm0u+11409u56QEDo9L6HfUD6jMTahzfdzsFm7iIAy1jrxAq/isR03C8+BrXnxxN+gsVUqFT0bOvHjBFduVbHUWyUU/ew1a3724vAmqRISQuQCRQgDBQQEKIACKAEBAbk9nSwRHx+v2NvbK4Bibm6uvHz5MsPn7t69W/v16Nq1q07czc1NARQ3Nzdly5YtiqWlpfb4xA9fX1/t8evWrVNMTU11jgEUjUajLFy4UBkwYIACKE5OTqnOa+XKlXqvlfTjo48+UmJiYnTO9fX11R6zePFipV+/fjrnurm5aY9fv369YmJikua1AOXy5csZ/romFRkZqXTt2jXNsUuUKKFcvHgx2XmHDh1Kd05J7yOjfH19lZo1a6Y79qFDh/SeW7FixTTPc3FxUYKCgvReO+n3/saNG4qzs3Oq43z22Wc659++fVsbnzRpUpr3+fjxY8XIyEgBlC+//FIn/uLFC6V58+Zp3kuRIkWUU6dOpXsvp06dUgoVKpTm1/DAgQOKlZWV3uuoVCrl559/ViZOnKj9XGr279+vFCxYMM15t2/fXgkNDdV7fuIxEydOVGbPnq1oNBq9Y1hYWChHjhxJdR6xsbHKqFGjFJVKleZcBgwYoPf8N/kdVxRFWbJkSbJ7EUKINMXHK4rXQkX5saiiTLTR/VjRXVFCn+T2LDMtNjZG2Tt9lHKhakXl2nu6H6fqVFaOrvw9U2PHx8crG738lY+/2qfMHLZfmTXsgM7Hv2OPK0/vv8riuxJCvA2y6/W3nqJIId49V69e5cWLFwC4urpia2ub4XNbtmyJubk5kZGRHD9+PNXj7t+/z4cffoiFhQXjx4/H1dUVIyMjzp49i5WVFZBQYdC3b19iY2MxNTVl1KhRtG/fHlNTU86cOcMvv/zC8OHDqVy5cppzWr9+vXbZWpkyZRgxYgSVK1emcOHC+Pn5sWjRInbu3MmiRYuwsbHhzz//THWsGTNmcOnSJVxdXRk+fDgVKlTg5cuX2mqmJ0+eMGjQIKKjoylSpAgjRoygYcOGFCpUiMjISO7cucORI0fYsmVLhr+mKQ0YMIDNmzcDUKNGDb7++msqVarEixcvWLt2LUuXLuXhw4e0aNGCS5cu4eDgAEC9evW4fPkykFDh8vDhQzp37sxPP/2kHdvS0tKguTx58oQmTZrw8OFDAJo3b86AAQOoWLEiKpUKX19fDh48yH///adzblhYGC1atODevXsAdOnShcGDB1OiRAl8fX2ZNWsWR44c4fjx43Ts2JGjR49iZGSkdx4RERF07NiRoKAgfvjhB1q2bImVlRUXL15k8uTJBAYGMnv2bDp27EibNm2055UrV44GDRpw5swZVq9ezcSJE1O913Xr1mmrgfr27ZssFhUVRcuWLblw4QJGRkb06dOH9u3bU7p0aWJiYjh69Ch//vknT58+pX379ly8eBEnJye91wkLC6N79+68fv2acePG0apVKywsLLh8+TLFixcH4N69e3Tq1Inw8HA0Gg3Dhw+nS5cu2NjYcOXKFX7//XfGjRtHgwYNUr0fgBMnTtCuXTtiYmIoWrQoI0eOpEaNGpQoUYKHDx+ybt06Vq5cyc6dOxkwYAAbN25Mdaw9e/bg5eVFtWrV+OKLL6hWrRqRkZFs3ryZv//+m4iICPr168ft27cxMTHROX/o0KHapabFixdnxIgRNG7cGFtbW549e4aXl1eqzemz8ndcCCEyRKWCeh+Bswts+AieXE4ev7Mvobl05zlQoXXuzPENGBlpaPXVnwR06MvVb0bgdPNlsrhtWDz8uIgdO3ZQ7/f5FHEon+GxVSoV3eqVwqViEX5e7oP91VAKpdhxLCYoinW/nKVKS0eadi6LkUYWcAghslmWpZXEO+NtrAxauXKl9p7GjBlj8PkNGzbUnv/gwYNkscTKIP5XveLv75/qOHXr1lUAxdjYWG9FQWBgoFKyZEntePoqg549e6bY2toqgDJ48OBUqwLGjh2rAIparVZu3LiRLJa0MghQ+vfvr8THx+sdZ9GiRRmq/ImIiFAiIiJSjafG09NTO36LFi2UqKgonWPmz5+vPaZnz556x3FyckqzyiKjklYo/frrr6keFxoaqrx48SLZ50aPHq0994cfftA5Jz4+Xunbt6/2mDlz5ugck1hNAyi2trbKlStXdI65ffu2YmZmpgBKp06ddOIzZ87UjnH27NlU76FBgwYKoFSoUEEnlvjzY2dnp5w7d07v+X5+fkrx4sUVQOnTp0+a92JlZaV4e3unOpcuXbpoj928ebNOPDw8XKlfv36yn9uUoqOjtZVUbdu2VcLDw/VeK+nP0969e3XiSa/Rvn17vT+TP/30k/aYTZs26cS3bt2qjTdq1EgJDg5O9d7v37+f7N9Z8TuuKFIZJIR4AzGvFWX3WP0VQhNtFGXHN4oSHZnbs8y0uLg45cCsscq56vqrhM7UrKQcWjhFiYuLM3js+Ph4Zcu5AOXjr1OvEpr3/XHlqX9INtyZECI/yq7X35JyFgJ4/vy59nGxYnqaJKajaNGi2sdBQUGpHjdt2jRKlSqlN3b27FnOnTsHwLBhw2jatKnOMQ4ODtrdzlIzd+5cQkJCcHBwYM6cOWg0+gsAJ0+ejIODA/Hx8SxfvjzV8ezs7Jg1a1aqPVgeP34MQIECBahatWqq4yT21DHU7NkJjRuNjY1ZsmSJ3gqLIUOG0LJlSyCht1FaPVbexM2bN7UVTl26dOHbb79N9VgrKysKFCig/XdUVBQLFy4EoEqVKtp+M0mpVCrmzJmj3ep+1qxZac7nxx9/pEqVKjqfL1euHF26dAHQW63Wq1cvbcVRar2F7t69y5kzZwDdqqCwsDDt9+XHH3+kTp06esdwcnJi/PjxAPz333+Eh4enei/ffvstNWrU0Bt7+PAh27dvB6BHjx7ae0vKwsKC+fPnpzo+wNq1a/Hz88PMzIzly5djYaG7iwwk/DzVr18fQNszSx8zM7NUfyY///xz7eePHTumE582bZp23hs2bMDOzi7V6zg6Oib7d1b/jgshhME0ptDmZ/hwE1gV1Y17/QsLmsOTazk/tyygVqtp/tnPlNjyH75VC+nErSMViv6+mt293Hjke8WgsVUqFZ3rlGTqJFf8alrzTE8vodgXUaydeo4D/90iLlZ6CQkhsockg4QAQkNDtY8Tl2wZIuk5r1690nuMiYkJ77//fqpjJG32OmjQoFSP69q1a5ovHLdt2wZAhw4dMDU1TfU4jUZDo0aNADh16lSqx3Xs2BFra92miokSl/EEBwezdevWVI/LjNjYWI4cOQJA69atdV4UJzVkyBDtOSmbDmeVHTt2aBsLjxo1yqBzz58/z8uXL4GExsmpLf+ysbGhZ8+eAFy7di3VxJZKpaJPnz6pXi8xQfPixQvtdRMVKVKEVq1aAQlLwfQ1rF69erX2ccrrHDlyhJCQECAhOZOWxKRmTEwM58+fT/W4lAmnpA4dOqRdrtavX79Uj6tRo0aqCSX4/98NNzc3ChcunKF5p/W70apVK4oUKaI3Zm1tTfnyCUsIEpcFJgoKCuL06dNAQmKuRIkSac4lpaz6HR84cCCKoqAoit7kpBBCpKtci4Tm0hXa6caeXoX57nBmPvmxuTRA8dJVabv+CE++6UOYue6bYqUvP+dhl/c5MOv7NDd/0KeQlSnTP6lPvaGV8LaO19lxTK3AjQOBLBh/kqf++p9bCiHEm5BkkBCQLNmhb1eq9CQ9x8bGRu8x5cuXx8zMLNUxEnvbmJiYpPmC1tjYmFq1aumNxcXF4e3tDcC///6bbNcsfR+J/UgSq3v0qV69eqoxgE6dOmmTU127dqV58+b89ddfnD9/PtXdpzLq3r17REREAKTbCyZp/MoVw96ly6iLFy8CCd+Dhg0bGnRu0jllxb0UKlRIW0Gkj729vfZx0mRnosTky6NHjzh48KBOPDEZ1KBBA8qVK5cslljBBgnJwLR+xpJWi6X2c2ZlZUWZMmVSvZekX4PUqpAS1a1bN9VY4rz37NmT7u/GH3/8keacASpWrJjmXBK/Bym//t7e3tqkoqura5pjpJQdv+NCCPFGLAvBB2vAYzpoUjzPiYuCXd/A6l4Q9ix35veG1Go17h+Nx3n7Vu7V1q0et4iCErO2sLdrEwJupf6mR2o8ajrw66Sm3K9to7dKKC44mvVTz7Fv/U3iYqRKSAiRdSQZJAQJL6wTZeZF05MnT7SPU3uBnnTJkD6JDazt7e1TrRpJlHRZWsoxYmNj0zxXn8SEiz7pzbtgwYJs27YNBwcHFEXh0KFDfPXVV9qtrrt164anp6fBc4L//5oAqVZgJEq6vC/peVkpcTmhvb293qVBacnqe0ltiVMitfr///euLynXpUsX7Rgpl4pduHCBGzduAPordp4+fZrmtVOT2s9ZWpVuQLLt6dOr6Ekrnpl5R0ZGphrL6Pcg5dc/6bLUxMq6jMqO33EhhHhjKhXU+xiGHoGi1XTjt/ckNJe+vV83lk8ULlkej9WHCPphMCFWui+hnG6+5Hn3D9k7fRRxcYb9f9re0oTfh9aj0SdV8LZRdKqEVMCtgw+YP/4kT/xC3uQ2hBBCS3YTE4Lk1S+J1R8ZFRcXx6VLl4CEF6KpLflIL8GTKLXePBmdS6KPP/6YL774IkPnpZXYyMi8XV1duXPnDhs3bmTnzp0cPXqUwMBAXr16xebNm9m8eTNt2rRh06ZN6b6ATs2bfF3ymrxwL1ZWVnTu3Jk1a9awadMm5s6dq61cS6wKMjIyolevXjrnJv05u3DhAsbGxhm6ZsmSJfV+PqO/G28qcd7t2rXjt99+y5FrZrXs+B0XQogsU6QiDDkA+yfD6dnJY+FPYVV3aDAcWk4C49SrpfMylw+/IbhVL06OGUKZU/eTxcxiwHHBbg4cOEG5X/+iTLUmBo3dpnpxGkwqyLQ1lzA9/5IiKXYci38ZzX/TzlPBvQQtulfAyFje1xdCZJ4kg4QAqlatir29PS9evODo0aOEhIRkeHv5/fv3a991N3TJR1KJFThBQUHExcWl+QI5aSVSUkmXBimKkmZD56xmZmZG3759tZUkvr6+7Nixg3/++Ydbt26xZ88exo0bx19//ZXhMZPeT2r3nChpRVfS87JSYgXZixcviI6ONugFdsp7qVChQqrH5sS9QELVz5o1a3j16hWenp706NGD+Ph41q5dC6TeEydp9VvhwoVTTfJklaTVac+ePcPBwSHVY589S30ZQsGCBXn48CHR0dE5+ruRUtJKREObnefm77gQQmSIxhTa/gJlm8OW4QlJoKTOzAW/Y9B9IRSplDtzfEMFipbCY8keTm+cTfyvcynwKnkFqOO9UEI/+JjdfZrR8psZaIwz/nzBzsKEaR/V5UDDR6xbdo2qr8CI/38TSQXcPvyQuxef0XVYdYqVydjzVSGESEnSyUKQUKnRv39/IGFZyIIFCzJ87j///KN9PHDgwEzPoVq1hLLq6OhofHx8Uj0uNjZW2zMkJRMTE+3uUidOnMj0XLJC6dKlGTFiBGfPntUmC9avX2/QGGXKlNFWEiXubJUaLy8v7ePseoFcu3ZtIKEZclqNhfVJOqe8cC8Abdq00SYmEquBjhw5woMHD4DUmzon7VmVEz9nSXdMS6sJNSTvZ5RS4rzPnTtHdHR01kwuE2rVqqWtDjt69KhB5+al33EhhEhT+ZYJzaXLt9GNPbmS0Fzaa0G+bS4N0LD7Z1TZtY+7bmV1Yiax4LT8EIc9GnH7/AGDx25RpTi/T27KkwZ2PNXTSyg+JIYNv51n9+rrxMa8WY9GIcS7SZJBQvzPF198od2ZZ/Lkydy5cyfdc9auXcuOHTuAhBftHTp0yPT1E7dGB1i2bFmqx23evDlZD5WUOnXqBMCNGzfYs2dPpueTVWxsbKhXrx6QvFdKRmg0Gtzc3ADYt28fgYGBqR6buG27RqPB3d09c5NNh4eHh/ZF/IwZMww6t06dOtreOMuWLUt115HQ0FBt0qxy5coG95QxhEaj0e5ctnPnTl6+fKlNCllYWOjdwh0SflYTk3QzZ87UNkPOLu7u7tr+OytWrEj1OB8fnzQTqYm/GyEhISxZsiRrJ2kAe3t7GjduDCQkSB8+fGjQ+Xntd1wIIVJlVRj6rIP2f+g2l459DTtHw5reEG7Y84O8xLZgcTr860nYH98QVEC3qtvhfgSv+41g14TBREcZ1r/N1tyYnwfVodnI6vjYKsTp6SV09+gj5v9wkod3X77BXQgh3kWSDBLif5ydnfn999+BhN3BWrRokeYLy/Xr1zNgwAAg4d36FStWvFEvmPr162srT+bOncvx48d1jnn06BGjR49Oc5wvvvhCu9X9oEGDuHr1aprH79ixQ9vzKDP27NmT5lKXkJAQbaVL6dKlDR7/s88+AxIqpj766CNiYmJ0jlm8eDF79+4FoFu3btmWQKlQoQJdu3YFYMuWLdqfF33Cw8OTJe1MTU35+OOPgYTdsX788UedcxRFYcSIEdqk2YgRI7Jy+nolVv9ERUWxevVqNm7cCEDnzp21P0cp2dnZaed28uRJRo0aleaWuk+ePNEm6zKjZMmSeHh4ALBhwwa2bNmic0xkZCRDhw5Nc5wBAwbg6OgIwOjRo9Otyjl+/DhHjhzJ3KTT8d133wEJjZ3ff/99QkJSbwiaMgmaVb/jS5cu1e46JlvLCyGyjUoF9YfA0MNQpIpu/NZumNMI7uTf5tIA9ToMpubuw9xtXYmUfxE18eC8/hTH2zXh+qkdBo/tXqkI0yc35Xkje54Y6f69VUJi2PT7BXaulCohIUTGSTJIiCRGjhypbch6//596tatS//+/dmwYQNnz57l5MmTLF68mJYtW9KrVy+io6MxNTVl1apV1KxZ842vP2fOHDQaDTExMbRq1YqxY8dy/Phxzp49y6xZs6hTpw6PHj1Kc+v5okWLsmzZMlQqFY8ePaJu3boMHz6cbdu2ceHCBc6cOcPGjRv57rvvKFu2LB06dOD+/fupjpeeNWvW4OTkhIeHB3///TcHDhzg4sWLHD16lDlz5tCoUSPtsqNPPvnE4PE9PDx4//33Adi7dy8NGzZk1apVnD9/nv379/Pxxx9rkyz29vb8+eefmb6XjJgzZ462Sfi3335LixYtWLFiBWfPnuXcuXNs2LCBzz77jFKlSukkEydMmKDdQn3SpEn06NGDHTt2cOHCBTZu3Ejz5s1Zvnw5AI0aNUo3uZEVGjdurE3SjRs3TpvASm2JWKIpU6bQoEEDAP7++29q167N7NmzOXHiBN7e3hw6dIhZs2bRpUsXSpUqxbx5895onn/++ae2Gun999/n888/59ChQ5w/f55ly5ZRt25dvLy8tFVo+piamrJ+/XpMTU0JCwujefPmfPjhh2zYsIHz589z9uxZtm3bxsSJE6levTqurq5cvnz5jeadmo4dO/LRRx8BCQm1ypUrM3XqVI4ePYq3tzf79+9n2rRp1KpVix9++CHZuTn9Oy6EEFmiSCUYcjChgXRK4U9hZXfY/T3ERuX83LKIlW0hOszcRMysCTwrpLu5QvGHr4kbPJodY/oSFRlm0NjWZsZMGVCL1p/X4JIdequEfI8/4t9xJ6RKSAiRMYoQBgoICFAABVACAgJyezrZYu7cuYq9vb32PlP7qFSpknL06NE0x3Jzc1MAxc3NLUPXXr16tWJiYqL3ehqNRpk/f74yYMAABVCcnJxSHWfbtm0Zuge1Wq0cPHgw2bm+vr7a+JIlS9Kcb+Jc0vv45JNPlLi4uAx9DVKKjIxUunbtmub4JUqUUC5evJjqGE5OTgqgDBgwIFNzSOru3btK1apV073nQ4cO6Zzr6+urVKxYMc3zmjRpogQFBem9dka+94qiKEuWLNGO5+vrm+ax48aNS3b9QoUKKTExMel+HV69eqV069YtQ9//Zs2aZfpeEu3du1extLRM9RoTJ05Uxo8frwCKmZlZquOcOnVKcXR0zNC8ly1bpnN+0uulJb3f/djYWGXEiBGKSqVKcw6p/cy+ye+4oiT/GUnvXoQQIkvd2qsov5VVlIk2uh9zmijKk+u5PcM3Fh4arHh+3Uu5UrGicu093Y9DrtUVn0P/ZWrssNcxyuQVF5UfPt2nzBp2QOfjn2EHlO3LrioxUbFZfFdCiNyQXa+/pTJICD0++eQT7t69yz///EPbtm1xdHTEzMwMKysrypYtS+/evVmzZg2XL19+ox3E9Pnggw+4ePEi/fr1o0SJEpiYmODg4EDPnj05fvw4Q4YMydA4HTt2xNfXlz/++IPmzZtTtGhRjI2NMTc3p3Tp0nTo0IE///wTPz8/mjVrlun5/vXXX6xcuZLBgwdTt25dHBwcMDExwdzcnAoVKjBgwACOHTvG3LlztX1fDGVmZsamTZvYtm0b3bp1035dChQoQIMGDZg6dSo3b97MkuqsjChTpgze3t4sXboUDw8Pihcvrv3aVqhQgf79+7N161a9PxvOzs74+Pgwa9Ys3NzcKFiwIMbGxhQtWpS2bduyYsUKjh49mq27iKWUsgqoZ8+eaDTpbzZpbW3Nxo0bOXbsGB9//DHvvfce1tbWaDQa7O3tqVevHp999hk7d+5k3759bzzPVq1aceXKFYYNG4aTkxMmJiYULVoUDw8Pdu/ezaRJk3j16hVAmrsBNmzYkNu3bzNv3jw8PDy0P09mZmY4OjrSunVrfv75Z27cuKFtLJ8djIyM+Oeffzh37hxDhw6lQoUKWFpaYmxsTLFixWjdujV//vknf/zxh97zc+p3XAghslz5Vv9rLt1aN/bkMsx3g7ML83VzaQsrOzz+WIsyfyqPi5nqxIs+jcZo+Hg8R71PeOgLg8a2NNUw4cOatPuiJpcK6K8S8j/5mH/HnSDwdup9JoUQ7zaVouTj/8uKXBEYGKjtuxEQEJDt20oLIURGtWzZkgMHDuDi4sKxY8dyezpCCCHSoijgNR/2joc4PcvD3msPnf4By0I5P7csFB0Zwf6fhuO42QuNnhZ7zwpqsBz/LXXa9jN47IjoWP7ccJWoE88oFqf7ppsCODUqStsPKmJsotvgWgiR92XX62+pDBJCCPFWePjwobYpdMOGDXN5NkIIIdKlUkGDYTD0EBSprBu/uRPmNoa7B3N+blnIxNyC9j8vw3jJXzx0MNOJFw6KxeLLX/D8tBOhL58aNLaFiYYf+tSg09e1uFxQRayeKqH7p57w79gTBNw0rAJJCPF2k2SQEEKIfOHOnTupxiIjIxk4cKB2t7nsXN4lhBAiixWtktBcuv4w3VjYE1jRFfaMy9fNpQEqNmhL012n8OvjQrSeIp2yB29zqU1zvLbON3jsemUKMmNSUyKbFeaRnh3HVGGxbP3Lm61LrhATLTuOCSFkmZjIgCpVkm8DGhMTw+3btwFZJiaEyDnu7u6Eh4fTs2dP6tSpg729PaGhoZw7d445c+Zok0UfffTRG21lL4QQIhfd2gtbP4XwZ7qxYtWg+yIo/F7OzyuL3fE+jO+Y0ZT0C9cbv+viTJOpCyhQ2PDn2ef9XrBggQ+VguLRoNKJK5ZGdBxSDaeKOdefUAiRedm1TEySQSJdkgwSQuQF7u7uHDlyJM1junbtyqpVqzA3N8+hWQkhhMhyYU9hy6dwR8/mAxpzaPMz1B2csMwsH4uNiebgn6MpsmIfprG68ZfWapTRQ2nc6wuDx34dE8fMLdcIOfyEEqn0EnKoV4QOH1bC2FR6CQmRl0kySOQZ0kBaCJEbLly4wObNmzl48CCBgYE8e/YMRVEoUqQIDRs2ZMCAAbRv3z63pymEECIrKAqc+Rf2TUilubTH/5pLF8z5uWUx/2tnuPHt55S680pv/G59Bxr9uoCCxUsbPLbP/WD+XeDDe8/i9FYJxVsY0XFIVZwr5f+voxBvK0kGiTxDkkFCCCGEECJHPLkKGz6CZ9d1Y1bFoOs8KNss5+eVxeLiYjk063vsF3liHq0bf2WpIuqLfrh8+B1qtWFtX6Ni45i99TpBhx5TIlb/ucXqFKJjv8qYmGkyM30hRDaS3cSEEEIIIYQQ75aiVRJ2G6s/VDcW9hhWdIG9P0CsngxKPmJkpKHlF79TdNMa/CoX0InbhCsU/mU5u/s044m/nsRYGkw1RnzVvSq9v6vL1SJqYtCtBXh8/jn/jj3BvavPM30PQoj8RZJBQgghhBBCiLzL2Bza/w591oNFId34yX9gYQt4divn55bFHMrVpM2G4zwe9T7hZrrLukp7PyWgc3cOzZ9IfLzurmFpqeZox4wJTVG1Kc4Dje656og4dv1ziQ3zLxH9Wk8TIyHEW0WSQUIIIYQQQoi8r0IbGH4SyrXUjT2+BP82hXNLEvoN5WNqtZpmw6bguHUjvjWK6MQtXysU+3M9e3q48uCOj0Fjm2jUfNG1Mh9+X4/rxfRXCT258Jx535/g7hWpEhLibSbJICGymLu7OyqVCnd399yeihBCCCHE28W6KPT5D9pMBSOT5LHYSPD8EtZ9CBEvcmV6WamoUyXarjnEs7H9CbXQrRJyvvaCJ916s//vb4iLM6ySp7KDLX+Nb4px+xJ6q4SMIuPYPesS6+f5SJWQEG8pSQYJkUJ4eDjz5s2jffv2ODg4YGZmhqmpKYULF6ZevXoMHjyYBQsWEBAQkNtTzXKHDx9GpVLp/bCwsMDR0ZEOHTqwePFioqL07OyRQuK56SXGYmNj6dWrl/b4hg0b8vLly6y5qRTu3LnDmjVrGDVqFE2aNMHCwkJ73aVLl2bZdXbs2MGkSZPw8PCgUqVKFCpUCGNjYwoUKECdOnX4+uuvuXnzZppjvHr1irVr1/L111/j5uZGuXLlsLW1xcTEhCJFiuDu7s5vv/1GUFBQuvPJyvuOjY1l3rx5uLq6UrhwYczNzSlbtizDhg3j6tWrBo0lhBBCGEythkafwpCDULiibvyGJ8xtDPcO5/jUspparaZp/+8p47mdu/UddOLm0eAw15P9XZrgf93LoLGNjdR81qkSA8bV50ZxI71VQs+8g5j3/XFuX3qW6XsQQuRNspuYMNjbvJvYqVOn6N27N/fv30/32KJFi/L48WOdz7u7u3PkyBHc3Nw4fPhwNswy+xw+fJhmzTK2I0eVKlXw9PTE2dk51WNUqoR3sdL6WsTExNCrVy82b94MgIuLCzt37sTa2tqguWfEkSNH0kxMLVmyhIEDB77xdWJjYzE2Nk73OGNjY6ZMmcKYMWP0xvfv30+rVq3SHadQoUKsXLmSNm3a6I1n5X0/f/6c9u3bc/bsWb1xU1NTZs2axccff5yh8YQQQog3EhOZ0ED67EI9QRU0HgnNx4PGRE88/zmx9i/U0xdiF6pbzRNlDE/7taL5qD/QGBt2v7Fx8SzYdYv7uwMpmcqOYwWr29NtcFXZcUyIHJZdr7/lN1mI/7l16xZt2rQhNDQUgE6dOtGjRw8qVKiAiYkJz58/x8fHh3379nHo0KFcnm32Gz58OJ9++qn230+fPuXKlSv8/vvvBAYGcvXqVTp16sTFixcxMjLK1DWioqLo0aMHnp6eQEIizdPTE0tLyyy5h5SS5r7VajWVKlXC0tISLy/D3knLCFtbW9zd3WnQoAFlypShePHiWFhY8PDhQw4fPszixYsJCQnh+++/x87Ojk8++UTvOI6OjjRr1ow6derg6OhI8eLFiY+PJzAwkA0bNrBp0yaeP39Op06d8PLyokaNGtl233FxcXTt2lWbCOrWrRtDhgzB3t6eM2fO8NNPP/H06VOGDRuGg4MD7dq1M2h8IYQQwmDG5uAxPaGP0NbPICJptawCJ2eC71HovhAKlc+1aWaVJr1HEdyiByfGDKXsCb9kMdMYcFy8j4MHG1Pm1+mUq+GW4XE1RmqGd6jI7boO/DP/IqUfxmBC8qVpQZdeMG/cCXp9UYuipWyy4naEELlIKoOEwd7WyqD333+fDRs2AOlXSjx79oz169fz2Wef6cTelsqgiRMnMmnSJJ1jQkNDqV69On5+fgD8999/9OjRQ+94aVUGvX79mi5durBnzx4AWrVqxdatWzE3N8+am9Hj9u3bbN26lXr16lGnTh2srKxYunQpgwYNArKuMggSEidpJcl8fX2pU6cOwcHBFC5cmEePHukcn94YAFu2bKFr164AdO3alU2bNukck1X3vXjxYj766CMAPv30U2bPnp0sfufOHerUqcOrV68oV64c169fR6OR9xyEEELkkNDHsGU43D2oGzO2gLbToHZ/UOn238mPvLb8S+zUfygQEqcTizaCh71dafndTIxNzAwaNy5eYfHuW9zbFUDJGN0qoTgV1OtelkYtnTI9dyFExmXX62/pGSQECS+6d+zYAUDdunXTfWFcuHBhvYmgd4G1tTU//PCD9t/79+83eIyIiAg6dOigTQS1a9eObdu2ZWsiCKB8+fKMHj0aNzc3rKyssvVa6SVxSpcuTc+ePYGE5OKNGzcMHgOgS5cuvPfeewAcO3ZM7zFZdd9//PEHAPb29vz+++868XLlyvH9998DCYmhxKV/QgghRI6wLgZ9N0Lrn3WbS8dEwPbPYX2/t6K5NED9LsOotvsAd5vrVjyZxIHzqmMcbd+YG157DBrXSK1iSPv3GDK+IbdLGhOdopeQkQIXNtxl5d8XiInSTUQJIfIHSQYJQcKL8cjISCDhBW1OOH78OP369cPZ2RkzMzPs7OyoVasWP/zwA8+e6W/S98cff6BSqTA2NiYsLEwn/vr1a8zMzLSNgb29vfWOU7FiRVQqFb17987U3KtVq6Z9bGgj7bCwMNq3b8+BAweAhOV4W7ZswczMsHet3gZJ+yK9fv36jcd5kzHSc+vWLa5fvw5Az549sbCw0Htc0kSqJIOEEELkOLUaGo+Ajw9AoQq68evbYW6ThKVjbwHrAkXpMGcbETPG8txetxq3RGAkMQO/ZOe4AURHRhg0dpkiVvw51gXrzo48MdLtURRy/SVzfzjB0wehmZ6/ECL3SDJICMDE5P/fPUp8wZtd4uPjGTFiBK6urqxcuRJ/f3+ioqIICQnB29ubn3/+mfLly7Nv3z6dc93cEtZ+x8bGcvz4cZ34mTNnku3ypW+Z2pMnT7S7WKW3y1dqkn69MtIoOdGrV69o27YtR44cAaBHjx5s2LAh2Xj6JN3lLKuWceW2yMhItm7dCiT08alQQc8T1gy4efOmNulXsaKeHVWySNKft8SfQ32KFSumvZcTJ05k23yEEEKINBWvDkOPQN3BurHQh7CsE+ybCLHROT+3bFCnbT9q7znC3XZVSJm20cRD6Y1enGjXmKvHtxo0rlqt4uN2Fej+TR1u62kTZBQay9qfz+J16O3bZVeIt50kg4QgYdmLk1PCumcfHx9+/fVX4uN13wHJCmPGjNH2WildujTz5s3Dy8uLQ4cOMWrUKIyNjQkJCaFDhw74+PgkO7d27draKhB9iZ6Un0vvmLRe1KclacIsrd3EkgoJCaF169baBMEHH3zAmjVrDEom5XcxMTHcv3+ftWvX0rhxY27fvg3A4MGDDdo9LSIigtu3b/Pnn3/i5uZGbGwsAF9++WV2TBuAa9euaR+nl3RKjAcEBBAeHp5tcxJCCCHSZGIBHf6C3qvB3D5FUIETM2BRK3h+Jzdml+Usre3p8NcG4ub9yJMium+0FXscBUPGsOOb3kSEvTRo7BrOBZg82ZX7FcyJSrlsLB7OrrvN6lkXiY2WZWNC5BeSDBLif0aOHKl9PGbMGMqWLcsXX3zBunXr8PX1zZJrXL58menTpwNQtWpVLly4wLBhw6hXrx7u7u78+eefbNu2DbVaTXR0NEOHDk12vpGRES4uLoD+RE9ixU3Hjh0BOHr0qE5SK/GYokWLUqlSJYPvIS4uLlm/mNSaRycVEhJCy5YtOXPmDAD9+/dn5cqV70RzYT8/P21Vk4mJCU5OTnzwwQfaap42bdpofybSsnTpUu04lpaWVKhQga+//ponT54ACT+zffr0ybb7CAwM1D5Or2ldYoM7RVGSnSeEEELkiooeMPwklHHXjT3yhn9d4cJyeEv21anu3oMGu49xr3Nt4lL0ylYrUGa7D2fbNcX7wFqDxrU1N2baqIbYdnbkmZ5lY8FXgpn7wwmeP9RtZSCEyHskGSTE/4waNYrBg/+/lNjPz4+ZM2fSu3dvypQpQ7Fixejduzfbt28ns5vwzZ07V5ucWbhwIXZ2djrHtG3bVjsPLy8v7TbeiRKXdp0/fz5Z36CoqChOnz4NwHfffYe5uTnBwcFcunQp2fmJSaSmTZsaNPdnz55x8OBB3NzcuHjxIpCQCEpMTqXF29ubc+fOAQkVQUuWLEGtfrf/91OoUCHWrVvHjh07sLHJ/PasNWvWxMvLi6lTp2p3b8sOoaH/3w8gvSbUlpaW2sf6elsJIYQQOc6mOHy4GVr/BOoUVckxEbBtJKzv/9Y0lza3sMHj11WoF/3Oo+K6fRmLPIvB+LPJeH7ejbCQoAyPq1Kp+KhdBTp+XZvbep4OqF/FsuonL84dlTeDhMjr3u1XY0IkoVarWbRoEXv37qVt27Y6VStPnjxh3bp1dOrUifr163P37l2Dr5G481aVKlVo0KBBqscNGTJE55xEqfUN8vLyIjIyEltbWxo2bEjDhg2B5BVET58+1S7xSq9f0OTJk7WVKCqViiJFitCiRQtOnDiBhYUFX331FatXr07/piFZkuLUqVM8fPgwQ+clcnd3R1EUFEVh6dKlBp2b2xwcHLh8+TKXL1/m4sWLeHp6MmLECMLDw/nkk0/47bffMjROly5dtON4eXmxZs0aunbtire3Nx988AGenp7Zeh9Jm1On1+PJ1NRU+zixMbsQQgiR69RqaDwShqTWXHobzHMBX/27c+ZHlRt3wGX3Cfx6NiI2xSs/NVB273W827pzbscSg8atU8aeyVNc8S9vrrPbmCYezqy+xdq5PsTGyLIxIfIqSQYJkUKrVq3YtWsXQUFB7Ny5k8mTJ9OxY0dsbW21x5w7dw5XV1cePXqU4XGjoqK0PWLSSgQB1KpVS9tL58qVK8liderU0VZmJE30JD52cXHByMhIm+xJekziEjHIfL8gSKhG+fzzzzPc78fFxUW7c5mfnx8tWrTg8ePHmb5+fmJsbEzVqlWpWrUqNWvWxMPDg3/++YfTp0+jUqkYO3Zssoq01NjZ2WnHqVevHr1792bTpk0sX76ce/fu0blz52xNlCXd7S06Ou1mm0mbmJubm2fbnIQQQohMKV4jobl0nUG6sVcPYFlH2D8J4mJyfGrZwcTUgnZTFmO6/B8eOOruBlowOBbLr3/Dc1gHQoIy/tzW1sKYX79qiGUHB57rWTYW5BPE3PEnefHEsF3MhBA5Q5JBQqTCxsaGdu3aMWHCBLZt28aTJ09YvHgxBQoUAODRo0eMHz8+w+MFBwdrHxcpUiTNY42NjSlYsCAAL14kL1fWaDQ0adIE0J/oSUwCJf43ad+gxGMKFy5MlSpV0pzD8OHDk1W0bN++nQEDBqBWqzl58iTu7u48e/YszTESqdVqVqxYQZcuXYCEbcpbtWpFUFDGy5LfNtWrV+enn34CYMmSJezduzdT4/Tr14/3339fu0tdyp+XrJK0wXV6S7+SNo1Ob0mZEEIIkStMLKDjDOi1CswLpAgqcPyvhObSQYZXgudVFeq2xG3HCfz7uROtp21j2SN3udquFac3zs7wmCqViqEdKtL+q1rctdRto6B+GcOKyae5cOLBm0xdCJENJBkkRAaZmpoyaNAg1qxZo/3cpk2bMrXr2Jv2dknZNygmJoZTp04lizVo0AAzM7NkfYMSk0EZ6RdUpEiRZBUtHTp0YOnSpSxevBhIqPD5+OOPMzxnjUbDunXraNu2LZBQ8dS6dWtCQkIyPMbbpnPnztrHGzZseONxwsPD2b179xvPS5+kTaPTawodEJCwvaxKpUq32bQQQgiRqyp1gOGnoLSeiumHF2GeK1xY8dY0lzY2MaPtuLlYr1lAQGndN2wKvIrDdtwsPAe1Ifjp/QyPW69sQcZPccWvjBkxepaNnVpxk/XzfYiLzZ7deoUQhpNkkBAGatOmjXa3pODg4AxXtyRWFAHaHaBSExsbqx3X3j7lVqi6fYO8vLyIiIjA1taWWrVqAQnJq6R9g54/f87Vq1eB9PsFpWXAgAF0794dgG3btnHw4MEMn2tiYsKmTZto1qwZABcuXKBdu3bvbJPhwoULax/7+/vn+jhpqVy5svbxjRs30jw2Me7o6JismbQQQgiRJ9kUh35boNUUPc2lw2HbCPhvIEQG6zs7XypTzYUWnqcIGNKW13pW/Zc9dZ+b7dtxYvWfGR6zgKUJv45uhFm7EgSpdZM+zy4kLBsLfibLxoTICyQZJEQmlChRQvs4o1U+pqamlC9fHkC7xXpqLl68SExMwjr1qlWr6sTr1aunfZF9+PBhbcVPYr+gREn7Bh09elS7C9qb9AsC+OWXX7TXGTt2rEHnmpubs23bNho1agQkNJTu2LHjO9lo+MGD/y+ZfpPlVFk1TlqS7hqXtPdUSo8fP+bWrVsA2uWMQgghRJ6nVkOTL+Dj/VCwnG782haY6wJ+J3J8atnFyEhD66//otDGlfi/Z6cTtw2Lx37KAnb0acazB3cyNKZareKTzpVo82UN7lnoVlOpgqNZPuk0PmcM20xECJH1JBkkhIEiIiK4du0akNBXKLG3T0a0bNkSgKtXr+Ll5ZXqcQsXLtQ5JymNRkPjxo2BhERPYu+glBU/SfsGJVbwFCxYUG+CyRAVKlSgZ8+eQEJia9++fQadb2Vlxa5du6hTpw6QcA/dunVLtzHx2+a///7TPq5WrVquj5OWChUqUKlSJQDWr19PRIT+d/WSNrHu2rVrtsxFCCGEyDYlasKwo1B7gG7sVSAs9YADU96a5tIAjhXq0HrzCR6O7EqEqW68zIXH+HXoxOFFP2a4PUKDCoUZO8UFX2dTYlMuG4uD40tusGHRZeLiZNmYELlFkkFCkNAQt0GDBnh6eqb5Ry4+Pp6RI0cSGhoKQKdOnQzq/zN8+HDU6oRfu6FDh/Lq1SudY/bu3cuiRYsAqF+/PvXq1dM7VtK+QSdOnEj2uUQNGjTA1NSU4OBgVq5cCST0C3rTnkWQUBGUOE5iI2RD2NrasmfPHm3yYvfu3fTq1YvY2FidYw8fPqzd4n7gwIFvNO+sMHDgQO18kjbxTrRly5Z0d5o7evQoU6ZMARKSex988IHOMUuXLk22pbs+f/31Fzt37gSgdOnSuLq6ZvAuDDd69Gggoan5t99+qxO/e/cuU6dOBaBcuXKSDBJCCJE/mVhCp5nQa6X+5tLHpsPiNvDiXq5MLzuo1WpafPYLxTevx7dqIZ24VaRC0d9Xs6tfS4KfBWRozIJWpvz2bWM0rYvzQs+ysSdnnzFvwklePX/3qsOFyAv09JEX4t3k5eVFx44dcXBwoEuXLjRq1AgnJyesra15+fIlFy9eZPHixVy+fBlISGb8+OOPBl2jWrVqfP311/z+++/4+PhQu3ZtvvvuO2rVqkV4eDjbt29n5syZxMXFYWJiwr///pvqWEn7BsXGxibrF5TIzMyMhg0bcuTIEW2j5jfpF5RU1apV6dSpE1u3buXo0aMcP3482VKijChYsCD79u3Dzc2NmzdvsmXLFvr378/KlSu1SbOstmHDhmQ9io4fP673MUCxYsW0Da8NsWXLFnr16oWHhwctWrSgSpUq2NnZERUVxd27d9m+fTvr16/XJh4nTJjAe++9pzPOpEmT+Prrr+nevTsuLi6ULVsWKysrQkNDuXz5MqtWrdImAk1MTJg/f36yZYJZfd8DBgxg8eLFnDhxgtmzZ/P48WOGDBlCgQIF8PLy4scff+TVq1eo1WpmzpyJRiN/YoQQQuRjlTqCQx3YPAx8jyaPPTif0Fy6/e9Q4wPIgjfa8oISZapRbP0Rji75CctZa7GKTF7VU+b8I651aIfFj99Tq3XfdMdTq1V81q0yJysVYtP8y5SOTPF1Copm8aRTtBxYmap1i2XlrQgh0qMIYaCAgAAFUAAlICAgt6eTJSIjI5VixYpp7yu9j/Llyyvnzp3TO5abm5sCKG5ubnrjcXFxyqeffprm+La2tsqePXvSnHN0dLRiYWGhPcfDw0PvcRMnTkw2tre3d6pjHjp0SHvcxIkT07y+oiiKl5eX9vjWrVvrxBNjqX0tEgUGBiqlS5fWHj948GAlPj5e77wGDBiQ7rzS4uTklOHvc2rzHjBggPaYQ4cOpRlP68Pc3FyZPn36G8+1ZMmSyt69e7P9vhVFUZ49e6bUq1cv1XNNTU2VBQsWpDkXIYQQIl+Ji1OUY38pymR7RZloo/uxfqCiRATn9iyz3JOAm4rnB+7Ktfcq6nxcqVhR2TG2nxIdFZnh8Z6+ilS+/uWYMmPYfmXWsAM6HxuXXFbiYuOy8Y6EyJ+y6/W3LBMTgoQKmgcPHnDixAkmT55Mu3btKFOmDJaWlhgZGWFjY0PFihXp1asXq1ev5sqVK9p+N4ZSq9XMnj2bo0eP0rdvX0qVKoWpqSk2NjbUrFmTsWPHcvv2bVq3bp3mOMbGxtomzJB6xU/Sz9vb21O9evVMzVufevXq0apVKyBhedvZs2czNY6DgwMHDx7U7tK2ePFiRo4cmWXzzGm//fYbixcvZuDAgdStWxdHR0dMTU0xNzfHwcGB1q1bM23aNO7evctXX32V6jh79uxh+vTpdOvWjerVq1O0aFE0Gg3W1taULVuW7t27s2TJEm7evKn9PmS3QoUKcfLkSebMmYOLiwsFCxbEzMyMMmXKMGTIEM6fP8/HH3+cI3MRQgghcoRaDS5fpt5c+uommOcC/idzfGrZqUjJCnisPsTzcYMIN0te0aNWoPTGsxzu5ELAzXMZGq+wtRm/ftcEVctivNSzbOzR6afMnXSKVy/SXiIvhMgaKkVRdNu8C5GGwMBA7Yv2gIAASpYsmcszEkIIIYQQIgdEh8PuMXBhuW5MpQbXr8HtOzDSs197Pvbw3mUuf/4xpe7o9ruMMIXwLz+k6aBxGR7v6NUneC64gtNr3eV1MRoVrQdXpnLtom80ZyHeFtn1+lsqg4QQQgghhBAiI0wsodM/0HM5mNkljynxcPR3WNz2rWouDQm9hFpsPoZfHxfiUuRvLKKg8K8r8RzchtCXTzM0XtMqRfl6SmPulTQmLsVuY8axCgfnX2HLimvEx0vdghDZRZJBQgghhBBCCGGIyp1h+Elw1rOL54NzCc2lvdfAW7QIQ2NsQrsJC1Dm/sRze91NIsqevI93+xZcPrI5Q+MVtTHnt7EuxDUrSkiKZWMqVDw48Zh5k08R/lKWjQmRHSQZJIQQQgghhBCGsnWA/luh5SRQp0iORIfBlk9g40cQ+TI3Zpdtqrl3p4bnPu42KqUTK/QiFoaPZdeUIcTGRKc7lpFaxaheVWn8SVXum+kmzpQnr1kw/hQ3fZ5lydyFEP9PkkFCCCGEEEIIkRlqI3AZBR/tBfsyuvErGxOqhPxP5fzcspGNfTE6LNnDk2/6EGGaPKaJB+fVxznQzZVHvlcyNJ579WKMmtyYeyU0xKdcNhajsHfuZbavvo4iy8aEyDKSDBJCCCGEEEKIN+FQB4Ydg1of6sZC7sPS9nDwZ4iLzfm5ZSP3j8ZTaN0yAp0sdWKlbr8isFtPTqz5M0NjFbM159dxLsQ0LcwrVfJlY2rg/tFHzPvxNBGvorJi6kK88yQZJIQQQgghhBBvytQKOs+G95eCmW3ymBIPR3+DJW3hhW+uTC+7OFWsj9u2o/h2q0t8iubSVpEK9pMX4PlJR8JDX6Q7lsZIzVd9qlP/kyoEmOpWAcU/imT+Dye5feV5Vk1fiHeWJIOEEEIIIYQQIqtU6ZrQXNrJRTcWeDZh2ZjPupyfVzYyMbWg/S8riJoxjmAbI5142cN3OOvRjBtndmdovBY1ivP5pEbcK65n2Vi0wu5Zl9i5/qYsGxPiDUgySAghhBBCCCGykm1JGLANmo/X01w6FDYPhY0fw+uQ3JlfNqnd5kMq7djFvdrFdGJFn0YTPXgUe3/7nPj4eD1nJ1eigAXTfnDhdZNChKmSJ33UgO/BB8z/+TSRoek3qhZC6JJkkBBCCCGEEEJkNbURNB0Ng/dCgdK68cv/wTwXuH865+eWjQoUdqTdygM8HNmVKOPkMeM4cFy8jz09XHn24E66YxkbqfmmXw1qDalIoIluAin2QST/jjvB3etBWTV9Id4ZkgwSQgghhBBCiOxSsg58cgxq9tWNvbwPS9rBoalvVXNptVpNi89+wXrVfB46mOnEna+94G7nznht/jdD47Wu7cBnkxpzr6gRip5lYzv/9mH3xlsoiiwbEyKjJBkkRArh4eHMmzeP9u3b4+DggJmZGaamphQuXJh69eoxePBgFixYQEBAgN7zBw4ciEql0vlQq9XY2dlRo0YNPvvsM7y9vbNl/n5+fnqvr1KpMDMzo0SJErRu3Zq///6bV69epTues7MzKpUKZ2fndI/96quvtNcqX758ql+jNxUQEMDGjRsZM2YMzZs3x9bWVnvdSZMmZdl1jhw5wtSpU+natStVqlShaNGimJiYYGtrS7Vq1Rg+fDjnz59Pd5zEr2F6H+l9je/cucOaNWsYNWoUTZo0wcLCQnvu0qVLM3RPUVFRnD59mn/++Yd+/frx3nvvoVarteMIIYQQIhuYWkOXOdBjCZjqaS59ZFrCjmPBfrkyvexStrorLp7HuNu+mk7MNiwe6+9nsOPLHkRFhqU7Vkl7C6ZNcCW8oT3hepaN3d0XyPxfzhAZJsvGhMgIlSLpU2GgwMBAHB0dgYQX5SVLlszlGWWdU6dO0bt3b+7fv5/usUWLFuXx48c6nx84cCDLli1L93y1Ws2YMWP4+eefMzXX1Pj5+VG6tJ5SZD0cHR3ZsmULtWvXTvUYZ2dn/P39cXJyws/PT+8xiqLw+eefM2vWLAAqVqzIgQMHKFGihMHzT4+/v3+aSZOJEydmWUKoZMmSPHjwIM1jVCoVI0aMYMaMGajV+vPriV/D9KT1NT5y5Aju7u6pnrtkyRIGDhyY7jUGDRqUZuJI/iQIIYQQ2exlAGwaCvdP6sZMbcBjOlTvmfPzymZeW+cT/+Pf2IbpLvd6VNyMUn/9Rbma7hkaa9fZQI6tuIFDtO5zr2gzNV0/rYFzhQJvOmUh8oTsev2tSf8QId4Nt27dok2bNoSGhgLQqVMnevToQYUKFTAxMeH58+f4+Piwb98+Dh06lKEx9+zZo02IxMfH8+TJE3bs2MHs2bOJjY3ll19+wcHBgU8//TRb7qlz58789NNP2n8HBwdz48YN/vrrL65fv05AQAAeHh7cvHkTGxubTF1DURQ++eQT5s+fD0CVKlU4cOAARYsWzZJ70He9RCqVirJly1KiRAmOHj2a5deytLSkTZs2NGrUiPLly1O8eHFsbGx4/PgxXl5e/Pvvvzx58oR//vkHCwsLpk2bluZ4Kb8fKZmYmKQaS3rfarWaSpUqYWlpiZeXl0H3lHQca2trateuzc2bN/UmNoUQQgiRDewcYaAnHP8zYXmYEvf/sahXsGkI3N4HHn/oblGfj9XvPJRndZtz7ouBOF9J3uOn+KPXhH04nANDO9FsxNRU32BL1K5eSaqULsCMmeco8zQWFf9f3WzyOp7tf16kYltHWnYuJ5XPQqRCkkFC/M+4ceO0iaDUqixatWrF6NGjefbsGevXr093zAoVKuhUsbRq1YoWLVrQqVMnACZNmsSwYcMwMtLdhvNN2dnZUbVq1WSfc3V1ZeDAgTRt2pTTp0/z+PFj5s+fz+jRow0ePz4+no8//pglS5YAUKNGDfbv30+hQoWyZP76WFtb89NPP1G/fn3q1q1LgQIFOHz4MM2aNcvya129ehWNRv//Jj08PPj888+pX78+9+7dY/r06XzzzTcULFgw1fH0fT8yysHBgd9//5169epRp04drKysWLp0qcHJoHbt2uHu7k69evWoVKkSarUad3d3SQYJIYQQOUltBE2/gTLNYONHusvDLq+HgNPQfRE41s+VKWaHwg7laLP+KPv/+pqii3djkiQPZhoLJeZsY/fJMzSauZwCRUqlOVapQpZMm+DK9OU+aM6+wEL5/6SPGri1OwC/Gy/o93ltzCyMUx9IiHeU9AwSAoiLi2PHjh0A1K1bN93lNoULF+azzz7L9PU6duyIq6srAM+ePePChQuZHiszjI2Nk1Wo7N+/3+Ax4uLiGDBggDYRVKdOHQ4dOpStiSCAggULMm7cOFq1akWBAtlb/ptaIijpXIYMGQJAbGwsp09n324g5cuXZ/To0bi5uWFlZZXpcXr16sXAgQOpUqVKuu+6CSGEECKblawLnxyHGn10Yy/vw+K2cPjXt665dOuv/8Js6d88KapbFV3a+wnXO7Tjwq7l6Y5lolHz/eBaVBpQgUfGusvPov3CmTfuBPfvBmfJ3IV4m8grASFISMhERkYCUK5cuRy5Zv36//8uT9J+MolVJh07dsTZ2Rlzc3PMzc1xcnKiV69e7N69O0uuX63a/zfyM7TRc2xsLH379mXlypUANGzYkAMHDmR7ciYvsra21j5+/fp1Ls5ECCGEEPmSqTV0nQs9FutpLh0Hh3+BpR4QnH7/wfzkvXqtqb/jCHdbVNCJFXgVj+moqez4ri/RURHpjtWhoSMfj2/EvUK6L2+NI+PZ8sdFDmy/K70RhUhCkkFCkLxXy/Xr13PkmsbG/1+uGheXUCPr6+tL2bJlGT16NJ6envj7+/P69Wtev37N/fv3Wb9+Pe3ataNfv37Exr7ZO0RJ7znpXNITExNDr169WLduHQAuLi7s3bsXW9u017Qn3eUsrUbI+Ul8fHyy5YIVK1bMxdkIIYQQIl+r2h2GH4dSjXRjAadhngtc3pDz88pGFlZ2dJi9leDJnxBmnry3jxoos/UCRzu64n/9TLpjORex5JdJrrysY0tkit3GjBS4scOfRb+fI/r121NlJcSbkGSQEIC9vT1OTk4A+Pj48OuvvxIfr1tqmpUuX76sfZzYZDouLg4TExM6duzIzJkz2b9/PxcuXGD//v3MmTOHKlWqALBy5Up+/PHHN7p+0qRXRraNB4iOjqZHjx5s2rQJgGbNmrF79+5k1TFvu7i4OB48eICnpyfNmzfXNq5u2bKl9vuTmqNHj1KzZk2sra2xsLCgdOnS9OrViy1btsg7VUIIIYQAu1IwcAc0+wFUKfpJRr1K6C+0aRi8fpU788smjXt9geOWDfhX0H1z0eF+BEG9BnJ4waR0xzHVGDFuSB3Kf1iex3qWjUXdC2XO2OM88A3JimkLka9JMkiI/xk5cqT28ZgxYyhbtixffPEF69atw9fXN0uv5ePjo13uZWFhQb169QAoXrw4fn5+bNu2jZEjR9KiRQtq1apFixYtGD58OJcvX9b2M5o+fTohIZn/QzZ16lTt4x49eqR7fExMDF27dmXbtm1AQiPsHTt2YGlpmek55CeJVU0ajYaSJUvSsWNHjhw5AkDt2rVZtmxZumP4+vri4+NDWFgYkZGR+Pn5sX79erp27Yqrq2u629gLIYQQ4h2gNgK3b2DwHrBz0o1fWgv/ukLA2ZyfWzYq5lSZVpuP49/PjdgUr1LNo6Ho9HV4DmjFqxfpb3rRuUkpBo1rwD17PcvGIuLZ+Nt5Du+6J2/GiXeaJIOE+J9Ro0YxePBg7b/9/PyYOXMmvXv3pkyZMhQrVozevXuzffv2TP3hUBSFx48fs3DhQlq2bKldGvb5559jZmYGJGxlXrx48VTHUKlUTJ8+HSMjI8LDww1u/Pzy5UtOnTpFp06d2L59OwCNGjWiV69e6Z778OFDdu7cCYCbmxvbtm3D3NzcoOu/bSwsLJg7dy4nT57UVnfpY2JiQqdOnZg1axaHDx/m4sWLHDp0iF9++QVHR0cATpw4QatWrd4owSeEEEKIt4hjvYTm0tV768aC/WBxGzjyG8TH6cbzKSMjDW3HzUM9fxrPCupu5FH2TCCXPFpx6XD6y+XKFLPm58muvKhpw2t0l41d3erHkj/PERP19nz9hDCEJIOE+B+1Ws2iRYvYu3cvbdu21dlJ6smTJ6xbt45OnTpRv3597t69m+6YpUuX1laUqNVqihcvzpAhQ3j+/DmQsD35lClTUj0/JiaGwMBArl+/zpUrV7hy5QoPHz7Ubl/u4+OT5vWXLVumvb5KpaJAgQI0btyY7du3Y2xszMCBA9m9e3eGegapVP+/jvvy5cvcunUr3XOScnZ2RlEUFEXh8OHDBp2bF1y+fJnLly/j7e3Nnj17GDNmDCYmJowePZoxY8YQExOT6rleXl5s3bqVzz77DDc3N2rWrIm7uzvff/89V69epXXr1kDC0r3Jkyfn1C0JIYQQIq8zs4Fu/yZsMW9qkzymxMGhnxOaS7+8nzvzyyZVXDpTe+ch7jZx1okVDI5FPXw8uyZ+RGxMdJrjmBkbMf6Tujj3KcNTje6yscjbocwee5xH99+uZXdCZIQkg4RIoVWrVuzatYugoCB27tzJ5MmT6dixY7IGyefOncPV1ZVHjx4ZPL6JiQlNmjRh2bJl2qRMUjExMcyePZuGDRtiZWWFo6MjlStXplq1atqPp0+fAmiTSplRvnx5Ro0ahY2NTfoHA6VKleKbb74B4MWLF7Rq1YobN25k+vr5TdWqValatSo1atSgdevWTJ06lUuXLlGkSBFmzJiBh4eHttorJTs7u1THtba2Zv369djb2wMwf/58oqPTfmIjhBBCiHdMtR4JVUKODXVj90/B3LevubSVbSE6LNrF0zH9iDBN3lzaSAHndSc50MWFh3cvpTtW96al+XBcfe4VUOnEjMPjWD/1HEf3Zm1bCCHyOkkGCZEKGxsb2rVrx4QJE9i2bRtPnjxh8eLF2u3THz16xPjx49McY8+ePdqKkqtXr+Lv709oaCjHjx+nf//+yaptICHJ0qhRI0aMGMGZM2fSTQpERkamGe/cubP2+j4+PuzatYsvvvgCMzMzrl27hru7Ozdv3szAVyPBb7/9xogRIwB4+vQpLVu25N69exk+/23j6OjI7NmzAdi3bx+LFi3K1Di2trb07p1QAh4eHs65c+eybI5CCCGEeEsUcEpoLu0+Vk9z6ZCE5tKbh0NUaO7ML5u4DRxLkQ0rCShtpRMrdTeUh917c3zlb+mOU764DT9Pacrz6tZEpVg2plHg8iZfls44T0y0LBsT7wZJBgmRQaampgwaNIg1a9ZoP7dp06Y0dx2rUKGCtqKkcuXKlCpVKtmW7il98cUXnD9/HoAuXbqwbds2/Pz8iIiIID4+XrvMKrHPTHq9i+zs7LTXr169Om3btmXGjBl4enqi0WgIDg6mT58+qVa06DNz5kxtb6UHDx7QokULAgICMnz+26Z169ba3kkbNmT+HbnKlStrH0sjaSGEEELoZaQB9+9g8G79zaV9VsM8Vwh8u95Ycixfm2Zbj+HbowHxKYp7LF8rFPxpCZ5DPQgLCUpzHDNjIyZ+Wg/H3qV5pmfZWPiNEGaPPc7jgLcroSaEPpIMEumqUqVKso/mzZvn9pRyVZs2bbTJmODgYIKC0v6jk1GvXr1i3bp1APTt25fNmzfTsWNHnJycMDc3T1ZFFBwc/EbXatGiBV988QUAFy5cYOnSpRk+V6VSsWDBAvr06QMkNNpu0aIFjx+nv7PD28jIyEhbLebv75/pcVJWiQkhhBBCpMqx/v+aS+vZBCTYFxa1hqO/v1XNpY1NzGj/01JiZk3khZ2RTrzs0Xtc8GjG9ZOe6Y71vnsZPvi+Hr62epaNhcWx7peznDiQ+ed1QuQHkgwSIhOS7hyVVS/ib9++rW1CnNbuXjdu3CAsLOyNrzd27Fhtv6DJkycb1KdGrVazbNkyunXrBiTMvWXLllmWGMtPoqOjtb2brKx0y5cz6tq1a9rHae1MJoQQQggB/K+59HzotgBMrJPHlDg4+BMs6wgv364K7potelPFcw/36uo+Xyr8PIbYj79hz9QRxMXFpjnOew62/PhjU55VsSJaz7Ix7//usnzmBWJj3p6EmhBJSTJIpOvq1avJPg4ePJjbU8pVERER2hfuNjY22p293lRs7P//wQoPD0/1uHnz5mXJ9ezt7fnss88ACAgIYNmyZQadr9FoWLNmDe3atQPQ7or1rm2NvnXrVm0irVq1apkaIyQkhLVr1wIJ29XXrVs3y+YnhBBCiLdc9Z4w/DiUrK8b8z8B85rAlU05P69sZFfIgXbL9/FoVA9ep9gUVxMPpZYdYF/3pjwNSLs3prmJEZNG1qdYD2eeG+kuGwu99pJZY0/w9NGbvxErRF4jySAhgLCwMBo0aICnp2eaPYDi4+MZOXIkoaEJ64g7deqUZZVB5cqV0461bNkyvf2Atm/fzqxZs7LkegCjRo3CwsICgGnTphnUOwgSdkbbtGmTdunghQsXaNu2rd7KJT8/P+0W9+7u7m889zc1adIk7Xz0LZPbv38/d+7cSXOMa9eu8fnnn2v/3b9/f51jdu/enWaj77CwMHr27Kmtqvroo48wNTXN4F0IIYQQQgAFnGHQLnAbA6oUL/Feh8CGQbDl07equbRarab5sB+xW7OIByXNdeJON4Lx7dKV0xtmpzvWBy3L0nNMXfxs9CwbC41lzY9enD78dlVYCaHJ7QkIkVd4eXnRsWNHHBwc6NKlC40aNcLJyQlra2tevnzJxYsXWbx4MZcvXwYSdoD68ccfs+z6BQsWpH379uzYsYPdu3fTunVrhg8fjpOTE0+fPmXjxo0sXbqUMmXK8PLlS549e/bG1yxcuDBDhgzh77//5t69e6xevZp+/foZNIaZmRnbtm2jTZs2nDhxgtOnT9OhQwd27dqlbayc1Xbv3p2sR1HSLe69vb2TJXesrKzo0aOHwdc4fvw4bdu2pUWLFrRp04bq1atTsGBBYmNj8ff3Z+/evaxYsYLXr18DMHjwYL39tKZNm0bfvn3p1q0bLi4ulC1bFisrK0JCQjh58iTz5s3j/v37ALz33ntMmjQp1Tlt2LAhWaLt+PHjeh8DFCtWjLZt2+qM8fjxY3bv3q3zuUQpE2MuLi6UK1cu1TkJIYQQIo8w0kCz76FsM9g4BELuJ497rwL/k9B9EZSskztzzAalqzbGYftx9k34COft3smqHWzCFfhhFjuO7Kf5r8swt7BJdZxKjnZM+tGVX+edp8D1MEz4/8SQJh7Or73N7avP6TO0BkbGUlMh8j+Vkt52REKkEBgYqG2gHBAQQMmSJXN5Rm/u9evXlC5dOsNNkMuXL8+aNWuoU0f3D+nAgQO1S658fX1xdnbO8DwCAgJwcXHRJgf+j737jo6q+to4/p10CCShEyCEGkC6NJEO0rsgoJQACoioCNgoUhRsiBWVIr1Xkd47gkgH6T2h95JC2n3/yJv5JcxkMgkpQJ7PWrPWZM65Z/admUDunnP2eVz+/PlZtWoVTZo04cKFC/j7+1tcvJ8/f56CBQsCWG1/XGBgIIULFyYsLIwSJUpw5MgRHBz+9x9cgQIFuHDhAr6+vpw/fz7ece7fv0+9evXM26I3bNiQpUuXmndPix1XrVq12Lx5s824bKlduzZbtmyxq298cQ8fPpwRI0YAMGXKFLp27Rpvuy2Ojo7079+fr776CkdHy2KG9sZaq1YtZs2aRd68eePtE/Ne2CO+13jz5s3UqVPHrjHA+msjIiIiT7nQe7BiABxeYNnm4AS1B0L1fuBg+bfLs+zf5ZOJGDEGrweWM/2v5nYl35gxFK1Qz+YYhmEwe90Zzvx1nmyRlkmfCE8nOvarQPbc7skWt4gtKXX9rZSmCNGzWy5dusSOHTsYMWIEjRs3plChQri7u+Po6IiHhwfFixenffv2zJ49myNHjlhNBD0pHx8f9u3bx0cffYSfnx+urq54enpStmxZhg0bxoEDB+JsQZ4c8uXLh7+/PwDHjh1j0aJFSRrHw8ODNWvWUKZMGQDWrFlD+/bt49RCepb069ePOXPm0KtXL1566SXzrm6urq7kzp2b2rVrM3ToUE6cOMG3335rNREE8N133/H111/TsmVLihcvTvbs2XFycjJ/pvz9/Vm9ejWbNm2ymQgSERERsZubJ7T5A1pPsCwuHRUBG7+AaS3gXmDaxJdCKjXrjt/S5Zwrk92iLffVRwT7v8u6Hz60WRbCZDLRsUERXv24AhcyW7Y73Ytg5uf/sHv78/XaSfqjmUGSaM/jzCARERERkefS7XOwuAcE/mvZ5uYJzX+Ckq1TP64UFBUVxYafPibnpBW4WPle8lyZHFT5aRrZvAvaHOdBaDjf/LaX7CeDcMaynpBXuWx0eKs0jk6aYyEpRzODREREREREJHGyFoRuq6HWJ9aLSy/oCn/1gUfPz45ZDg4O1O/3HRmnjeVqbsuNOQoeusGpFs3Ys3yKzXEyuznzRb8qZG3pwx0ru43dPXCLsZ/t4Pb14GSLXSS1KBkkIiIiIiLyPHN0gjqDoOtK8PSxbN8/E8bXhEv7Uj+2FFS0Qj1eWrmVM/WLW7R5Pogiw4ffsuKjDoSFxJ/MMZlMdGnsR7MBL3Ixk2W7051wpo/Yxd6dl5MzdJEUp2SQiIiIiIhIeuBbFd7eDqXaWLbdPgOT6sO27yEqMvVjSyEZMnrQ7Jc/uTfyXe5njLvUywEotOwgW5tX59yRv22OU65QVgZ/UZ3LRTIQQdxKK86RsGvaceZOPERkZPz1iESeJkoGiYiIiIiIpBcZvKK3l281Dlwem+oSFQEbRsD0lnDvUpqEl1JeatuHAksWc6F4Fou2vIEh3H39TTaN+8xmcWmPDC6MHPASns3ycdfBsvTurb03GfvZ39y9qWVj8vRTMkhERERERCQ9MZmg3Ovw9jbIW9Gy/fw2+P1lOPpX6seWgnLlL079RVu56F+XiMeuhN3CIfePC1nVpT53b8afCDOZTHRtVowm/ctz0cru8k63w5gybBcHdl9J5uhFkpeSQSIiIiIiIulR1kLQfTXU/MhKcem7ML8LLH0PwoLSJLyU4OjoRMOBv+I06Tuu53C2aC+05zL/NWvIwQ3zbI5TvkhWBn5RncuF3Ih8bNmYSyTsmHyM+VMOE6VlY/KUUjJIREREREQkvXJ0hrpDoOsK68Wl902PLi59eX/qx5aCSlRtSoXlmzhTs5BFW9a7kTi9O5yVQ7oSHhYa7xheGV0Y+VFVMjbJyz0Hy6TPjX9uMHbY39y7HZKssYskByWDRERERERE0jvfl6OLS5d81bLt1mn44xXY/iPYqKnzrMnkmY1mE1Zwc0g3gtweKy5tQMGF/7CpZQ0CT8WfCDOZTLzVojgNPihHQAbLdsebYUweupPDe68md/giT0TJIBEREREREYkuLt12MrT63Xpx6fXDYEZLuP98baNeo9PH5Fk0l4uFM1u0+Zx7yLW2Hdk67SubY1T0y86nI6tzqYCr5bKxCNgy8T8WTvuPqCjLwtMiaUHJIBEREREREYlmMkG5N6DXVshbwbL93Nbo4tLHlqV+bCkoT+Ey1FuynfMdXiYy7iQhMj4yyPHVdFa82ZiHd2/EO4aXuwujPnkZt4be3H9stzETJq7tvMavw//mwd1HKXEKIomiZJCIPNUKFCgQvWtD164p9hxdu3bFZDJRoECBFHsOERERkWdKtsLQfQ3U+BB4LDsScgfmdYJlfZ+r4tJOzi40Hj6JqN+/4FYWJ4v2QjvOs69pPf7bHv8uayaTiZ6tX6DOe2W4lMFyFpDD9Uf8MWQH/x24lqyxiySWkkEi8YiIiGDRokX07NmT0qVLkzNnTpydnfH09KRIkSK0bt2a0aNHc+7cubQONd0zDIOlS5fy+uuvU7RoUTJlyoSTkxNeXl6UKlWK1157jdGjR3Pw4MFUj61OnTqYTCZMJhMNGjSw+7jatWubj4t9c3R0JGvWrFSoUIG+ffvy33//JTjW8OHDzcdv3rzZZt/t27fj4eGByWTCycmJmTNn2h1zYjx8+JCtW7fy3Xff0a5dOwoWLGiOMTmTchcuXGDixIn06NGDypUr4+vrS8aMGcmQIQM+Pj60aNGCGTNmEB4ebnOce/fuMWvWLLp160bZsmXx9PTE2dmZHDlyUKdOHcaMGcPdu3ftiikyMpJZs2bRtGlTcufOjYuLC7ly5aJ27dqMHz+eiIgIu8a5f/8+33zzDdWqVSNr1qy4urri4+ND27ZtWbVqlV1jiIiI2OToDPU+g67LwSOvZfveqTC+FlxJ/b+xUlKZ2m0pvWItZ6pYnnOOW+FE9fyU1SPfJjIy/v+zXyqRgw8/r05gfheirCwb2zjuCItnHcXQsjFJIybDMPTpk0QJDAzExyd6p4GAgADy5cuXxhElv6VLlzJgwABOnz5tV/+mTZvy9ddfU6pUqRSOLP0pUKAAFy5cwN/fn6lTp1q0X7t2jbZt27J9+3a7xjt27BjFixeP81jXrl2ZNm0avr6+nD9/PhmijnbhwgUKFixIzD+zDg4OBAQEkCdPngSPrV27Nlu2bEmwn6OjIyNHjuTTTz+Nt8/w4cMZMWIEAJs2baJ27dpW+23evJlmzZoRFBSEk5MTs2bNol27dgnGkBR16tSJNzGVnO/DkCFDGDVqVIL9SpcuzV9//UXBggUt2latWkXr1q159Mj2lO7cuXMze/Zs6tSpE2+fK1eu8Oqrr7Jr1654+1SoUIFly5bh7e0db5+dO3fSpk0brly5Em+fLl26MHnyZBwdHW3GLSIiYpeQO7DsAzi6xLLNwRnqDYWq74LD8zXfYNPEEXj+MpcMYZZtF/w8KffLZHL7vhDv8VFRBuMXH+X+hqtkMkwW7UZuN7r1r4C7h2tyhi3PkZS6/n6+flNFksHIkSNp1aqVORFUu3ZtvvvuO9auXcvevXvZtm0b8+fP59133zXPYFixYgVjx45Nw6jTp7CwMOrXr29OBJUvX56ff/6ZrVu3sn//frZs2cK4ceN444038PT0TPX4ZsyYgWEYuLq64uTkRFRUVJJm2hw+fNh827t3LwsWLKBjx45A9CyTgQMHsmDBgieKdf369TRp0oSgoCCcnZ2ZP39+iiWCAGJ/D5E1a1YaNGhApkyZbByRNA4ODpQtW5Y+ffowceJEli9fzr///svGjRuZOHEiL7/8MhD9Gr/yyisEBVlOdb916xaPHj3CwcGBhg0b8sMPP7Bx40b27dvH0qVLad++PQBXr16lWbNmHDhwwGosISEhNGnSxJwIeuWVV1i4cCF79+5l7dq19OzZEwcHB/bu3UuzZs0IDbW+le2JEydo3LgxV65cwcHBgZ49e5r/fVq4cCH16tUDYPr06bz//vtP+hKKiIhEy5AFXpsKLX8FZ/e4bVHhsO4zmNka7sf/RcWzqE6PYWSbO5XA/Bkt2nxP3iOgVVt2zvsp3uMdHEz0bluSGu+V5rKb5TwM09VQxg/+m2OH469FJJIiDJFECggIMAADMAICAtI6nGQ1adIk87nlypXL2LRpk83+ERERxsyZM438+fMbvXr1Sp0g0xlfX18DMPz9/S3axo4da36/unXrZkRGRsY7TmhoqDFlyhTjypUrFm3+/v4GYPj6+iZj5Ibh5+dnAEabNm2MJk2aGIBRqlQpu46tVauW+dzi8/PPP5v7lCxZMt5+w4YNM/ez9pleuXKl4ebmZgCGq6ursWzZMrtifBLjx483Zs+ebZw6dcr8WMx7nZzvQ3h4eIJ9+vbta359fvrpJ4v2uXPnGr169TIuXLgQ7xix34s6depY7TN69Og4n9eoqCiLPpMnTzb3GT16tNVxmjZtau4zZcoUi/aoqCija9euBmCYTCZj9+7d8cYtIiKSJDdPG8b4WoYxzMPy9nUBwzi2PK0jTHaPQoOM5Z+8YRwpVtw4auW2rHcLI+jBHZtj3LgXYnzyxTbj517rjbG9NsS5/dxrvbFk9lEjKtLy7wNJ31Lq+lszg0T+X0BAAH369AHAw8OD7du3x7ucJoajoyMdO3bk4MGDNG3aNBWilNj++iu6eJ+TkxPff/89DjamJbu6utK1a1dy586dKrHt2rWLkydPAtCxY0c6deoEwJEjR9i3b1+yPEefPn3Inz8/AP/99x9Xr15N9BjLli2jVatWhIaGkiFDBv766y+aNWuWLPHZ0rNnT15//XWKFCmSos/j5GRZ/PFxsZfYbdu2zaK9ffv2jBs3zvxaW/Pee+9RsWJFALZs2cLNmzct+sQsc3R3d+eHH37AZLKcKt6tWzeqVasGwOjRo4mMjIzTfuPGDVauXAlAtWrVrBZWN5lM/PDDD7i7u2MYBt988028cYuIiCRJtsLw5jqo3h/L4tK3Ye4bsLwfhAWnSXgpwcU1I02/nkXoj4O442H5N2fhjSfZ3aQWJ/5dG+8Y2T3c+HJQNRzq5OKhKe4sIQdMBG65wm8jdxL8wMqaNJFkpmSQyP/7/vvvzcsyRo0alaiLVC8vL5o3b26zz9WrVxk8eDAVK1aMU+y1Xbt2rF+/Pt7jzp8/by6sG3MxuW7dOpo3b07u3LlxdXWlYMGC9O7dm8DAQLvi3bRpE/7+/hQqVIiMGTPi4eFB6dKl+eijj7h8+XK8x8UuRAzRRXW/+OILypcvj5eXV5wYAYKCgpg3bx5vvfUW5cqVi1N0t1atWnz33Xc8fPjQrpituXjxIgDZs2fHy8sryeM87u7duwwdOpSSJUvi7u6Ol5cXNWvWZNasWXaPMX36dACyZMlC06ZNadWqFZkzZ47T9qQcHBwoWbKk+eeAgIBEHb948WLatGlDWFgYGTNmZPny5TRs2DBZYnuWxLwvQLxLs+wRkzyOioqyKCwfEhJiLvZdtWpVm8sWGzVqBMD169ctklN79+41L7Fr3LhxvGN4eXnx0ksvAdE1j4KDn58/xkVE5Cnh6AyvDAP/ZZDZSj3EPZNhQm24cijVQ0tJFRp1psTyVZwtl9OiLdf1MEK79mXtdx8QFRVl9XgHBxN92pei2jslueJqpXzv5VDGDd7ByaO3kjt0kTiUDBIhun7JjBkzgOgLw27duiXr+LNmzaJIkSJ8+eWX7N27lzt37hAWFkZgYCALFiygfv36vPXWW3btIjRw4EAaNGjA8uXLuXbtGmFhYZw/f55x48bx4osvcuzYsXiPDQ0N5fXXX6du3bpMnz6dc+fOERISwoMHDzhy5Ajfffcdfn5+LFu2LME4Tp06Rbly5Rg6dCgHDhzg3r17Fn2aNm1Khw4dmDRpEgcPHuT+/ftERERw8+ZNtm7dykcffUSZMmU4fvx4gs9njYuLCxBdRPr27dtJGuNxJ06coHz58nzxxRccPXqU4OBg7t27x7Zt2+jUqRPvvvtugmOEhYUxb948AF577TVcXFzIkCEDr776KgBz5syxe8eohMS8BgDOzs52Hzdv3jzat29PeHg4mTJlYvXq1dStWzfB42LvcpacxbbT0ty5c833Hy8unhixC0w/XrQ59uczV65cNseJ3b5169Y4bbdu3bLaz9Y4wcHB7Nmzx2ZfERGRJCtYA3rvgBItLNtunoA/6sHfYyGe5MizKEvO/DSevYlLfVrw6LFJyC6R4PPHGta0q8nNy2fiHaN66dy8/0U1AvM4Yzy225hrmMHqnw+wbMHxOHUWRZKTkkEiRC/dibnIqlGjBu7u7gkcYb/58+fTuXNngoKCKFSoEN9//z2rV69m7969LFq0iCZNmgAwadIkPv74Y5tjTZw4ka+//ppatWoxe/Zs9uzZw/r16+nSpQsQvYSke/fuVo81DIO2bduaL3ybN2/OjBkz2LFjBzt37uSnn34if/78BAUF0bZt2wQvHtu2bculS5d47733WLduHXv27GHOnDkUK1bM3CciIoLSpUszePBg/vzzT/755x927drFvHnz6NChAw4ODpw7d868TCmxXnzxRfO59ejR44lmGUH0RXPz5s25desWQ4YMYfPmzezZs4eJEyeaq/b/+uuvrFmzxuY4y5cvN1/8xywPi33/+vXrrF69+olijRE7+efr62vXMbNmzaJjx45ERETg4eHB2rVrqVGjRrLE86y4c+cO+/fvp3///vTu3RuITqzF3E+KmN3fnJ2dLWYWxi6ObS1xGlvs9qNHj6bIOCIiIskqY1ZoNx1a/ALOjxVajgyDtYNhVht4kPgl7U8rBwcHXnnvGzLNHMeVPG4W7QWO3OJ0ixbs/mtCvGPk9HBj5JDqRNXMSfBjy8YcMXFxw2V+H7WLkIdaNiYpINmqD0m68TwWkJ45c6b5nIYMGZJs4964ccPw9PQ0AKN79+7xFrMdNGiQARgODg7G8ePH47SdO3fOHBtg9OjRw2rh2bfeesvcZ9++fRbtEyZMMADD2dnZWLVqldU4bt++bZQsWdIAjGrVqlm0xy5E7ODgYKxZs8bm+Z88edJm+7p16wwHBwcDMP744w+rfWwVkP7nn3/MxwOGl5eX0blzZ2PChAnGwYMHjYiICJvPHyOmgDRgeHp6GkeOHLHoc+rUKXOR5RYtWtgcr2XLlgZgFChQIM57FRkZaeTJk8cAjNdee83mGPYUkF60aJG5T7169eLtF/t969atm/k1y5IlS6KLC8eO69y5c4k6NiEpUUA6ttjv8+O3jBkzGosWLUry2MuXLzeP1axZM6t9vL29DcDInj278ejRo3jHat68uXmsqlWrxmk7ceKEua158+bxjvHo0SMje/bs5r4DBw5M2omJiIgk1o1ThjGupvXi0t8UNIzjK9M6wmQXGvzAWPZBG6uFpY8WK24s7/ea8Sj4oc0xNh+4bAx5z7Kw9NheG4wx7280Th+/mUpnI08bFZAWSUGxi73myJEj3n5RUVEcOXIk3lt4eHic/r///jv37t0jb968/Pbbb/EWsx0xYgR58+YlKirKZj0Zb29vfvnlF6uFZz/88EPz/cfrjBixisi+//775pokj8uSJQujR48GYMeOHZw6dSreWLp27UqDBg3ibQcoWrSozfZXXnmFFi2ipxQvWbLEZl9rKleuzPjx483Lo+7evcuMGTPo2bMnZcuWxdPTkwYNGjBx4kSrW4Zb88UXX8SpwxOjSJEitGrVCsC8lb01t27dMhf4feONN+K8Vw4ODrzxxhtAdOHmu3fv2hVTbGFhYRw/fpyvvvqKzp07A5AxY0ZGjRpl1/FTpkwhKiqKDBkysGHDBipVqpToGJ43HTp04Pjx4+ZlfIl1+/Ztc/F5R0dHPv/8c6v9Yj7rN2/eZMyYMVb7bN++nRUrVph/fvDgQZx2Pz8/8+y7FStWxPtZHDNmTJx/1x4fR0REJMVkLxJdXLpaXyyKSwffgjkdYMUACA9Jk/BSgmuGTDT7YSH3v+7LvUyWl9iFVh5mW7PqnD0U/9+Qtcp60+fzlwnIZXm94PrIYMUPB1m5+KSWjUmyUTJIhLgXSraWiN2/f5/SpUvHe7t06VKc/kuXLgWgWbNmuLq6xjuuk5MTVatWBWDnzp3x9mvbtm284xQrVsy8hOTs2bNx2o4ePcqZM2fMY9hSs2ZN831bsXTs2NHmONbcuHGDU6dOxUmgxSTfDh48mOjxAN566y0OHz5Mt27d4hQChugC1uvWraNnz54ULVo0waVZJpPJnKyxpkKFCkD0xX98iZw5c+aYk4Kxl4jFiHksNDSUBQsW2IwndlwxN1dXV0qUKMGgQYMIDg7mxRdfZO3atVSpUsXusSC6oHHspIO9Nm/ejGEYGIZBgQIFEn18Who1ahSHDx/m8OHD7Nixg99//50XX3yRuXPn8sYbb9hMfsYnMjKSjh07cuHCBQCGDBlC+fLlrfb95JNPzJ/RwYMH069fP06dOkV4eDhXr17l119/pUmTJnGSxiEhln8ojxw5EohOTjdt2pRff/2Vq1evEh4ezqlTp+jXrx+DBw+OU0/K2jgiIiIpxskF6n8OXf6CzN6W7f/+EV1c+uqRVA8tJVVp9TaF/lrCuZJZLdryXArlfscebBw7KN7i0rm9MjBqWA3Cq2WzsmwMzq0NZNxX//AoONzq8SKJoWSQCHF3E7J3BklCIiMjOXDgAADjx4+Pc0Fv7bZw4UIAm9uDJ1TcNkuWLIDlLIDY9X+qVq1qM47YNUlsxVKmTBmbscTYsWMH7du3J1u2bOTMmRM/P784CbSJEycCWN2K217FihVj8uTJ3Lp1i7///pvvv/+ejh07muv8AFy5coVmzZrZ3Lkte/bsZMuWLd72rFn/9x97fDMtpk2bBkTXMypRooRFe9myZSlVqhTw5LuKubi48Oabb5q3IrfHl19+af68f/bZZ/zwww9PFMOzJG/evJQqVYpSpUrx8ssv8/bbb7N792569erF9u3bqVKlSqKTku+88445ydisWTM+++yzePsWLFiQefPmkSlTJgzD4Mcff8TPzw8XFxe8vb159913CQ4OZuzYseZjHk9wQnRCd8SIEUB0gvrdd9/F29sbFxcX/Pz8+PHHH8mSJYs5aRTfOCIiIimuUC3o/TcUb2bZduM4TKwDO397ropL58xblEYLtnHxzQaEx91PAtdw8B77J6s71uPO9YtWj3d0MPFB57K8+FZxrrlYzgKKuhjMr4N2cO7UnZQIX9IRJYNEIE4C4MaNG/H28/LyMs+KiLn5+/tb7Xv79u0k7RhlawvojBkzxtsG0cuQIDoRFdv169cTHUdCscQknmwZPnw41atXZ/78+Qnu9pUcMxecnZ2pWrUq/fr1Y+bMmQQEBLBhwwbzsq/IyEjeeeedeKfX2vv6xoz1uGPHjpkTb9ZmBcWIWd61Y8cOiy3IrYmZzXL48GG2bt3K2LFjKVy4MGFhYfTp08e8tM8eL730EsuXLzefa//+/Rk3bpzdxz9vHB0d+fnnn/Hx8eHOnTuJKiA9cOBAJkyILgpZo0YN5s+fb7GL2OMaN27Mvn376NKlC15eXubHTSYTderUYdu2beblZBD/79nQoUPZsGED9evXjzNbMEOGDHTq1IlDhw6RP3/+BMcRERFJcRmzQvuZ0OxHcMoQty0yDNYMhFlt4cG1NAkvJTg4ONDwo59wmfIj13K6WLQX3H+VY82asH/trHjHqFchL71HVCUgp5VlY6FRLPt+P2v+Oq1lY5Jk1guYiKQzZcuWNd/fv39/sowZO1nw1ltv0bdvX7uOi720I7nEjmXZsmV2L+/JmTNnvG0JXfRu2LDBPHuhUKFCfPjhh1SvXp38+fPj7u5uXgozdOhQvvjiC7viSYq6deuybt06SpUqxe3btzl16hQHDhyIdynPk4g906d///7079/fZn/DMJg+fTrDhg2z2S9mJlGMGjVq0KVLF6pXr86hQ4cYNGgQtWvXtrv+T82aNVmyZAnNmzfn0aNHvPPOO2TMmNG8K1164+LiQqNGjZg4cSI7d+7k0qVL5M2b1+Yx33zzDV9//TUQPQts+fLlZMiQweYxMYoWLcq0adOIioriypUrBAcHkydPHvMS1dh1gKzVr4pRt25d6taty6NHj7hy5QqGYZA3b17zvyGxl73ZGkdERCTFmUxQsRv4VoNFb8LVQ3Hbz2yA31+GVr+BX8O0iTEFFK/cEJ8Vldj0sT+FN52O05blfiRRfUeystVq6g+fgLOr5d8R3lkyMnJYdX6ecYiof26RwfhfDSZHA06vusi5Y7fo3vdFXDI4p/j5yPNFySARoi+2s2XLxq1bt9i2bRvBwcEJzhJJSOwlRYZhWFzQp6bYM5+8vLxSJZaY5V9ZsmRh165d8RbmTmjGUHLw9vamadOmzJgxA4DTp08nezIoKiqKWbPi/3YnPjNmzEgwGWRN5syZmT59Oi+++CIREREMGDCArVu32n18/fr1WbBgAW3atCE8PJzu3bvj5uZGu3btEh3L8yD25/PixYs2k0G//fYbn376KQAlSpRgzZo1eHh4JPo5HRwcrD7P3r17zfcrV66c4Diurq5WE7yJHUdERCTF5fCDt9bDxi/g71/itgXfhNntoHLP6HpDzvZ9yfK0c8+clWa/L2PHnO9x+fYPMoX8byaPgwEF/9zD5n01KPbj7+QvYfnFnpOjA/27lmNtyUB2TD9BzvC4Rbkjzwfxy6AdtH2/HL4FvVL6dOQ5omViIkQv0YhZ1nP//n1z3Zcn4eLiYv42fseOHU883pOInfhIrVj+++8/AOrUqWNzh7bY9YxSUp48ecz3re3G9qQ2bdpEQEAAAO+99x5z5syxefvggw8AOHPmTJLfk7Jly5oLXm/bti3BAtmPa968ObNmzcLR0ZHIyEg6derEsmXLkhTLsy528ffYdbMeN2PGDN59910gesbb+vXryZ49e7LGElNYPEOGDDRv3jxJYzx48IA1a9YA0XXCfHx8ki0+ERGRJ+LkCg1GQuc/IVNuy/bdE2BiXbj2X+rHloKqvd6ffIvnc7Go5RdI+S4EcbN9F7ZMGmnlyGgNKuWj5/CXCMhuOTvfLSSKJd/uY/2KM8kaszzflAwS+X/9+/fHzc0NiK4FYk8tl4TE1P44fvy4+cIsLbz44ovmYsoTJkwgNDQ0xZ8zpl6SrYLc+/fv559//knycyRmjXTspFOhQoWS/JzxiVki5ujoyJAhQ+jQoYPN2+DBg81L5Z6kkPTgwYPNtYxiFwy212uvvcbkyZMxmUyEh4fz2muvsW7duiTH8ywKCgpi1apVQHQCpkiRIlb7LV68mG7dumEYBvny5WPDhg1xkozJYe3atebkYMeOHePUFUqMr776ylyHK2bbexERkadK4brRxaWLNbFsu34UJtSBXePgOaqJ412wFPUWb+N8xxpEPHYlniEMco6exYpuDXlwx3r9pLzZ3PliRA1CKmUhlLivi5MBJ5ZdYMLo3YSFJr5uqaQ/SgaJ/L/8+fPz888/A3Dv3j2qV68ep3aHNYZhxLvFOEDfvn3Nswy6detmni0TnxUrVnDo0CGbfZLCwcGBQYMGAdHbznfp0oVHjx7F2//+/ftxdjRKiqJFiwLR9U9Onz5t0X7jxg1zIeWkevXVV/ntt98S3AFu6tSpbNiwAYh+n5N7iVhQUBCLFy8Gouv52Kq1FCN79uzUqlULgPnz59t8P2wpXrw4r776KhA962vTpk2JHqNLly78/vvvADx69IhWrVrFu+Ssdu3a5p3nzp8/n6SYk8v58+fNsdSuXdui/ebNmyxatMjmGKGhoXTv3t1cZL1t27ZWa/+sXbuW119/ncjISHLmzMn69evtrr0VW+wZSI87fPiweYZitmzZ+PLLL632Cw8Pt7n73qxZs/jmm28AqFWrlnn2mIiIyFPHPRt0mA1Nv7dSXPoRrP4EZr0GD5O2GcrTyMnZhcafTYBxX3Ijm2XVlkI7L3Kg6Ssc3rzY6vHOjg58+GZ5Snbz44azZaIs/MxDfhm0nYDz95I9dnm+qGaQSCw9evTg0qVLjBgxgsuXL1OjRg3q1q1L8+bNKV26NFmzZiUyMpKrV6+yb98+5s+fb07wODo6WhR/zpUrF9OmTaNt27ZcuXKFihUr0rVrVxo3bky+fPkIDw8nMDCQ3bt3s3DhQs6ePcuyZcvs3rY9Md5++23WrVvHn3/+yYIFC9i3bx+9evWicuXKeHp6cv/+fY4fP87mzZtZunQpbm5u5uUwSdGlSxeWLVtGUFAQtWrV4tNPP6VChQoA5u3fr169StWqVdm5c2eSniMgIIA+ffrwySef0Lx5c2rWrEmxYsXIkiULoaGhHD9+nAULFrBy5UogennYDz/8kOzLxBYvXszDhw8BaNOmjd3HtWnThg0bNnD37l2WLl3Ka6+9lqTnHzRoEAsXLgSiZwfVqVMn0WP06tWLkJAQ+vXrR3BwMM2aNWP9+vUpVmvm9OnTFsnWmNfw4cOHTJ06NU5bo0aNyJ3bylRyGx4+fEjbtm0pUqQIbdq0oXLlyuTNmxdXV1du3rzJ7t27mTRpEmfPngWit56PSaLEtmvXLlq3bk1YWBjOzs788MMPhIeHc+TIkXifO1++fFZn9TRu3JicOXPSsmVLypUrR6ZMmbh8+TIrV65k0qRJPHr0CDc3N+bMmRPv8sp79+6RP39+WrduTcOGDSlWrBgODg6cOXOGOXPmsHTpUgAKFCjAjBkzUmRZpIiISLIxmaDSm1CgOix8E64djtt+el10cemWv4Ffg7SJMQWUrtmaByuqsaV/Zwr/HXeb+ey3I4jsPZjVHVbxyqBfcXK23GCmURUfXiiUld9//Jd8t6LitLkFR7H4m72UalmAeo2Sf0a8PCcMkUQKCAgwAAMwAgIC0jqcFLF48WKjUKFC5vO0dTOZTEajRo2Mw4cPxzve0qVLjaxZsyY4loODg7Fx48Y4x547d87cPmXKFJtx+/r6GoDh7+9vtT0sLMzo3bu3YTKZEoylYMGCFscPGzbM3G6Pbt26xTu+o6Oj8eOPPyY4pq1zatmypV3vEWB4enoa06dPt/oc/v7+BmD4+vraPJ8pU6aYxzt37pz58VdeecX8Wbh06ZJdr41hGMbVq1cNBwcHAzCaNWsWp61WrVqJeq2bNGli7r9z5844bbFf402bNtkcZ9SoUea+WbJkMfbv3x9vXLFfg8SK/Vrac7MWd+zfjVq1atlsT+hWtWpV48yZM1Zjjf362XuL73e1ZMmSNo/z8fExNmzYYPO1u3HjRoLPX61aNeP8+fMJvQ0iIiJPl/BQw1g9yDCGeVi/rfzYMMJC0jrKZLdp8hfGnjLFjaPFLG+rm1Y2Lp85FO+xYRGRxjfj9xhjeq03xvbaYHGbMGa3ERYanopnI8ktpa6/tUxMxIrWrVtz4sQJ5s+fz5tvvskLL7xA9uzZcXJywsPDg4IFC9KiRQu++uorzpw5w6pVq2zu0NW8eXPOnTvHd999R926dcmVKxfOzs5kyJCBggUL0qxZM77//nvOnz+fpFkd9nJ2dua3337j4MGDvPfee5QuXRpPT08cHR3x9PSkXLlyvPnmmyxcuJBjx4498fNNnjyZGTNmUKNGDTJnzoyrqyu+vr507tyZv//+m759+z7R+EuWLOH48eP89NNPtGvXjpIlS5rPx93dnfz589OkSRN+/PFHTp8+/cTL0qy5dOkSGzduBKIL9SamhkyuXLmoVq0aAKtXr+bGjRtJjmPw4MHm+1988UWSxxk0aBBDhgwB4M6dOzRo0CBZPgtpIX/+/Gzbto3PPvuMhg0bUrx4cbJkyYKTkxNeXl6UKVOG7t27s2rVKnbs2JEitaQe99133/HOO+9QtmxZcuTIgbOzM7lz56Z27dr8/PPPHDt2jLp169ocw8vLiz/++IPXX3+dYsWK4enpiaurK/nz56dNmzYsWLCAbdu24evrm+LnIyIikqycXKHhKOi0GDLlsmz/Z9z/F5c+mvqxpaDa3YaQY/4MAgq4W7TlP32fS6+2Z8fsMVaPdXZ04OOeFSjWpSg3nSyXjYWdfMAvg3ZwOeB+ssctzzaTYTxHFbkkVQQGBpp3pgkICDAXJhYREREREUkWQTfhrz5w0spuqU5uUP8LqNwjepnZcyI8LJR1I3riu/hfHKxcpZ+pVZg6o6fj7pHV6vHnrz1k3E978LkdZdEWboLybQpR65UCyRy1pLSUuv7WzCARERERERF5urhnh9fnQpPvopM/sUWEwqqPYE4HeJj0mdVPG2cXN5qMmk7Yz59x29NyC/nCW86wp2kdju9aZfX4Arky8fnnNXlQzoOwx3YbczbgyMKzTPpxD+Fh2m1MlAwSERERERGRp5HJFD37p+dmyGWlJMPJ1dHFpU+vT/XQUlL5+m/wwvLVnKlguXlGzhthhL3Zn7XfvEdUZKRFu4uTA5++XZHCHYtw28qysdDj9/ll0A6uXnqQIrHLs0PJIBEREREREXl65SwBb22AKr0t24Kuw8w2sHogRDxK/dhSSJYc+WgyYwNX+rYh1Dlum3Mk+ExZz9q2NbgecNLq8S1q+NJxcGUCvSwv+V0fRjJ31L9s23QhJUKXZ4SSQSIiIiIiIvJ0c3aDxl9Dx0XgntOyfddvMLEeXD+e+rGlEAcHB+r2HonH7AlcypfBot332B3OtWrNP4t/t3p8Ie/MDB9Zg/ulMxP++LKxKDg07wyTf9lHZIRljSF5/ikZJCIiIiIiIs+Goq9A77+haAPLtmuHYUIt+PcPeI72SSpcugY1l23nbNMyFm0eQVF4DPqZFX3bEBpsufTL1cmRgX0q4du+EHccLV+TkP/u8tOgbVy/EpQiscvTS8kgEREREREReXZkygFvzIfGo8HRNW5bRCisGABz34jekew54ZIhI03HzOPB6AHczWx5GV9ozVH+blqT0/s3Wz2+dZ2CdBhUiUselruvud6PZNYX//D31oDkDlueYkoGiYiIiIiIyLPFZIIqPaOLS+d8wbL9xMro4tJnNqZ6aCmpcvO3KPrXUs6Vzm7R5n0llIede7P+54+JirJc+lUkrwefjazB3RcyEfHYsjGXKNg/+xTTfttPZKSWjaUHSgaJiIiIiIjIsynXC9BjI1TuZdn28BrMaA1rBj9XxaWz5ylMo3lbCOjZmDCnuG2uEZD3t2Wsfr0Od65dtDg2g4sTg9+vTJ62BbhrZdnYw0N3+GnQdm5e17Kx552SQSIiIiIiIvLscs4ATb6FNxaAew7L9p1j4Y96cMP6zlvPIgcHBxr0/x63qT9zNberRXvBg9c53qwx+1ZOs3r8a68Upu2nFbmU2cqysXsRzBjxD//sCEz2uOXpoWSQSDIrUKAAJpOJrl27pnUoIiIiIiLph1+D6OLSRepbtl09DONrwp7Jz1Vx6WIV61Nl+WbO1Ctm0eb1IArX/l+z8uM3CHsUbHmsjyefjarBneLulsvGImHPjJPMGH+AKC0bey4pGSTymKCgIMaNG0eTJk3Imzcvbm5uuLq6kiNHDipVqkT37t2ZOHEiAQGpW2AtKCiIzJkzYzKZMJlMfPnll3YfG3PM4zcXFxdy5cpFrVq1GDVqFNevX09wrNq1a5uPT8hPP/1k7pszZ04OHTpkd8yJcf36dZYvX87QoUNp3Lgx2bNnNz9vcibl9uzZw5gxY+jQoQNlypTB29sbV1dXMmfOTLFixfD392fTpk0JjrNixQqGDx9O06ZNKVGiBNmzZ8fZ2ZksWbJQoUIFBgwYwIkTJ+yO68KFCwwYMIDixYvj7u5O1qxZqVSpEqNHjyY42PI//tg2b94c7+fj8dvw4cPtjklEREQkTWTKCR0XQKNvrBSXDoHl/WBuRwi6lTbxpYCMmbxo9usS7nzxDg8yxv0b3QEouHQ/W5vV4MJ/uyyOzeDixJAPqpD7VV/uOVgmye7vv82PQ3Zw66btvynl2WMyjOcoLSqpIjAwEB8fHwACAgLIly9fGkeUfHbu3EmHDh24eNFyfe3jcuXKxdWrVy0eL1CgABcuXMDf35+pU6cmW2zTp0/H39/f/HPx4sU5duyYXcfak7gByJo1K3PmzKFBAytbdf6/2rVrs2XLFgBs/fMxevRoPv74YwBy587Nhg0beOEFK8X9koGt80vO96F69ers2LEjwX6vvfYa06dPx83NzaItIiICZ2fnBMdwdnbm888/59NPP7XZb9myZXTq1In79+9bbffz82PFihUUKVLEavvmzZupU6dOgvEADBs2TAkhEREReXZcPQKL3oQbxy3bMuWGV8dDodqpHlZKunrhGPvf706BE3ct2kJc4P677anVY5jVv5+PXbjDzF/2k+eh5biPHKFml+JUrJInBaIWW1Lq+tsp4S4i6cPJkydp2LAhDx48AKBFixa0bdsWPz8/XFxcuHnzJgcPHmTdunV2zf5IbtOnTwcgU6ZMPHz4kOPHj7N7924qV65s9xgVK1ZkypQp5p8fPHjA6dOn+e2339i1axe3b9/m1Vdf5fDhwxQsWDDJsY4aNYohQ4YAkDdvXjZu3Iifn1+Sx0uM/PnzU7x4cdauXZvsY7u6ulKrVi1efvllSpQogbe3N1mzZuXGjRscPHiQcePGce7cORYsWICDgwNz5861Oo6npye1a9emSpUqFCpUCG9vbzJmzMjly5fZvHkzkydP5t69ewwcOBAvLy/efvttq+Ps37+f9u3bExISQqZMmRg4cCB16tQhJCSEuXPnMnHiRE6ePEnTpk3Zs2cPmTNntnl+kydPplKlSvG258yZ0/4XS0RERCSt5S4VvdvY2s/g34lx2x5ehemt4OX3oO5n4OSSFhEmu9y+JWiweBvrvnmPvDM34xRrhVeGMMjw/TxWbt9OjR9m4pEtd5xjS/hmYdCoGowZuxevU0E48r+EkWsk7JpyjBOHb/J699I4ONj3ZbM8vTQzSBLteZ0Z9Nprr7Fw4UIApkyZYnN50Y0bN5g/fz59+vSxaEuJmUGBgYH4+voSFRXFd999x6hRo7hz5w59+vRh7NixCR4fk/mvVasWmzdvtmg3DIN27dqZz9/WuAnNDBo+fDgjRowAohMzGzdupHDhwnadZ1INGzaMSpUqUalSJXLlysX58+fNyazkfB8iIiJwcoo/hx4SEkLdunXZtSt6Cu7BgwcpU6aMRb/IyEgcHR3jHefcuXNUqFCBO3fukCNHDq5cuWK1f82aNdm2bRtOTk5s3bqVqlWrxmmPPTsrvlk9sWcGbdq0idq1a8cbl4iIiMgz68Rq+OsdCLayPMy7LLSZBNmLpn5cKei/Hcu4+clgct4Mt2i7lcURj1FDKVO3ndVjZ688xYXlF/GIskz6hGV1puuHFcmSNUOyxyyWUur6WzWDRIi+OF+xYgUQPXsmoTozOXLksJoISikzZ84kKioKJycnunTpwmuvvQbA3LlzCQ+3/Mc9sUwmE19//bX55/Xr1ydpnEGDBpkTQQULFmTr1q0pnggCGDFiBM2aNSNXrlwp+jy2EkEAGTJkoG/fvuaft23bZrWfrUQQRL927dpF/8d848YNjh+3nNq8e/du8/hvvvmmRSIIYMCAAZQoUQKIrt+UHJ8VERERkWdSsUbQeycUrmfZduVgdHHpvVOfq+LSJas1p8KKjZypYTnjP9udSBz6DGPVZ92ICHtk0f5Gk6I0//BFrrhbjutyO5wpQ3ey/98rKRG2pBIlg0SIvuAOCQkBiLe2SlKdOHGCHj16UKBAAVxdXcmVKxetW7c2zx6xx4wZMwBo0KABOXLkoHPnzgDcunXLnMR6UoUKFcLdPfpf+6QUx/7www/56quvAChatChbt27F19c3WWJ7lsReihUaGppi4yxZssR8v1u3blbHcHBwoEuXLgDcvXs3TZY3ioiIiDw1MueCjguh4Vfg+NiysPBgWNYX5nWC4NtpE18KyOSZnWYTV3JjkD9BbnFn+TgaUGDBLja2qsHl0wctji1VKAufjqrBzcIZiHpstzHXCNg+6SizpxzGiHp+EmjpiZJBIoCLy//+M7C3KLM9/vzzT1588UX++OMPLly4QFhYGNevX2fJkiVUr16defPmJTjGnj17OHr0KACdOnUCoFq1auZlUDG1hJ6UyWQyz3yxp8BxbH379mXMmDFAdGHrLVu22DV9MWaXqgIFCiQ63qdV7DpBxYsXT9IYISEh/PXXX0B0QsdavaXt27cD4O7uToUKFeIdq1atWub79hS/FhEREXmuOThA1XfgrQ2Q3XI7do4vh9+rwdktqR9bCqrZ5VNyL5xFQCHLGpI+Zx9wue3rbJv+jUVbJjdnhn74Elma5ePBY7uNOWDizj83+HHoDu7dSfqXoJI2lAwSIXoXrZhZLAcPHuSbb74hKioqgaNsO3z4MG+88Qa5cuVi7Nix7Nq1i507dzJ8+HDc3NyIjIykZ8+e3Lhxw+Y4McmezJkz07JlSyA6ifLGG28A0duU37795N9eXLlyhXv37gHYnZwxDIN33nmHn3/+GYBSpUqxefNmvL29nzieZ0VUVBTXrl1j48aNtG7dmpkzZwLRiaCGDRvaPU54eDgXL15k7ty5vPzyy5w6dQqA7t27Wy38HJO0LFKkiM3la7ETUgklOgcPHoyvry+urq5kyZKF8uXL069fP06ePGn3eYiIiIg8E7zLRBeXrvimZduDyzC9JawbBhFhqR5aSslXpDx1/trGuXYvEflYKSD3UIPsX05lxVtNeHjvZpw2k8lEp2bFaDygHFczWo7rcjOMPz77m4P7LHdalqeXkkEi/++9994z3//0008pXLgwffv2Zd68eZw7dy7R4+3bt4+SJUty4MAB+vTpQ5UqVXjppZcYNmwYf/zxBwD37983Jw+sCQ8PN880ad26NRkz/u9f35hZQmFhYfHuWpUYMUu8ANq2bWvXMT179uT3338HoFy5cmzatCnF6/Y8LQoUKIDJZMLR0ZHcuXNTr14989KtQoUKsXjx4gRrDJ0/f948O8rFxQVfX19ef/11Dhw4AEDDhg3NM65iCw0N5ebN6P+kE5qBlSVLFruX//39999cvHiRsLAw7t69y4EDB/jxxx8pUaIEw4cPt1owXEREROSZ5ZIRmn0PHeZAhqyPNRqw40eYVB9unk6L6FKEs7MrTT6fQsTY4dzysqxjWWj7OfY1rcuxHcst2soWzsbHo2pwo6CbxbIxtwjYOuE/5k0/omVjzwglg0T+X79+/ejevbv55/Pnz/Pzzz/ToUMHChUqRO7cuenQoQPLli2z+6J48uTJeHh4WDz+xhtvkCdPHiD+IsMAq1atMs8cikn+xChevDgVK1YEkr5U7MGDB+zbt49u3bqZdw8rWrSo3cWxY5JaJUqUYOPGjWTPnj1JcTwvnJycGDlyJAcOHDAXbk6K7NmzM2/ePFasWGH18/PgwQPz/UyZMiU4Xkwy6OHDh1bbvb296dOnD3PmzOGff/5h7969/Pnnn7z55ps4OzsTFRXFiBEjGDx4cBLPSEREROQpVrwJvLMTCtWxbLtyAMbXgH3Tn6vi0uXqtafUirWcqZTXoi3HzXAienzEmi/fITIyIk5b5gzODPu4Kh6N8/LQyrKxm39f56fhf/PgnmVRanm6KBkk8v8cHByYNGkSa9eupVGjRhazOq5du8a8efNo0aIFlStX5syZMzbHK126tNVtxSF6qmX58uUBOHv2bLxjxCR5vL29qVfPcueDmATRP//8Y15WZMuWLVvMM1FMJhMeHh5UqFDBvPV6y5Yt2bx5M1myZElwrJjzgOit0Pft22fXMbEZhoFhGJw/fz7Rx6a1tWvXcvjwYQ4ePMjGjRv54osvyJkzJ59//jl9+vSJN/ESW968eTl8+DCHDx9m//79LF++nHfffZegoCDefvttvv32W6vHxS4oHbveVXxcXV0BzEXSY6tUqRIXLlxg7NixdOjQgcqVK/Piiy/SqlUr/vjjD7Zv346npycAX3/9NQcPWhYXFBEREXnmZc4NnRZDg1Hg8Fj9zPBgWPoezO/yXBWX9sqWhybT1nJ1QHtCHvuT0ikK8k/fxLpXa3DtYtydbU0mE/4ti1P/g7Jcs7K7vPP1R0wYsoPDB6+nYPTypJQMEnlM/fr1WbVqFbdu3WLlypWMGDGC5s2bmy+IIbqoc40aNbhyJf7tFBMqHpw1a/RU1NizPGK7c+cOy5YtA+D111/HwcHy1/X11183b1P+pIWk8+TJwwcffGCesWSPX375BYhOTrRo0cJc1Dg98PPzo1SpUpQpU4Y6deowZMgQjhw5QtmyZZkxYwbVqlVLMCHk7OxMqVKlKFWqFOXKlaNp06b88ssv7Nq1C5PJxKBBg+LMVovh5uZmvh8WlvA69kePor+ZyZDB8n9rd3d3mwXDK1eubJ41ZhiG+b6IiIjIc8fBAV5+F3psgOyWG3hwbCmMqw7n4p/Z/6xxcHCgTo/hZJ07hUAfy4JAvifucqHVq+xa8ItF24t+2RkwqjrX87thPL5sLBw2/36YhbOOqtTAU0rJIJF4eHh40LhxY4YOHcrSpUu5du0akydPNs+auXLlCp999lm8x8eu72NNTHInMjLSavvcuXPNF/qPLxGLkTNnTho0aADAzJkzE/yHtmLFiuaZKIcOHWLt2rV89tlneHp6cunSJRo1amRz2drj+vTpw+jRowEIDg6madOm/Pvvv3Yf/7zJkiUL06ZNA+DQoUN8+eWXSRqnTJkyjBw5EoApU6awdu3aOO2xC0rbMwMpKCgIsG9JmTUdOnQwL1fbsuX52llDRERExIJ3Wei5BSp0s2y7fwmmNYf1IyAyPPVjSyEFXniJWsu2cbZFOR7fRidzsIHnZ7+x4t1WhATdi9PmmdGF4QOrkrFBHoJNlsvGrm27yk8jdhL0QMvGnjZKBonYydXVlW7dujFnzhzzY4sXL37iXcfiE3umz4svvhhneVfs26pVq4DoGkdbt261Oaa7u7t5Jkrp0qWpX78+n3/+Odu3bydz5sw8evSIjh07cv/+fbvj/PDDDxkxYgQQXRC7YcOGHDp0KAln/HwoUaIERYsWBWDhwoVJHidm5zhr47i5uZEtWzYAAgMDbY5z584dczLIx8cnSbE4OTmZt7e/dOlSksYQEREReaa4ZITmP0L7WZDh8RIKBmz/HiY1gFu2S0c8S1zcMtL02zmEfP8JdzwsUwWF1p9gV9NanNqzIc7jJpOJ7q+WoM77ZbnmZnEYzldD+X3w3xw9YnsXZUldSgaJJFLDhg3NF9V37tzh1q1byf4cp06dYteuXYk+LqlLxUqVKmWexRIQEGCe7WOvoUOH8sknnwDRr0n9+vU5fvx4Akc9v3LkyAHAhQsXnniM+MZ54YUXADh9+jQREREW7TFivw9PUtQ6pj6UiIiISLpSohn03gkFa1m2Xd4H42rA/pnPVXHpik26UmzpCs6WzWHRlvvqI4L932X99wMsvhSvWCI7/UZW51o+F4tlYxnCDNaPPcTiuce0bOwpoWSQSBLErquTEhfJsZM6v//+O3PmzLF5i1kqtnDhQqtFgu3Rq1cvChYsCMAPP/xg3rrcXl9//TXvv/8+ANevX6devXo2i2M/z2JmzyR1WVbsMeIbp3r16kD0ErC9e/fGO07sZV3VqlVLUiwRERGcPHkSIFE1pURERESeCx7e0HkJ1P/cSnHpIPirDyzoCiF30iK6FJEtdwEaz9lM4DvNeRR3Xx1cIiHvhJWsaVeLW5fj/r2fJZMLIwZXw7VubotlY46YuLL5Cr98sZOghwnXvZSUpWSQSCIFBwdz9OhRILquUMxyneRiGAYzZ84EomfsvP3223To0MHmrXfv3kD0Mq0lS5Yk6XmdnZ359NNPgegEww8//JDoMX788Ud69OgBwOXLl6lbty4BAQFJiudZ9e+//5pn8pQuXTrJ4yxYsMB839o4rVq1Mt+fMmWK1TGioqLMiUUvLy/q1LGyXaod5s2bx7170evDa9Wy8q2YiIiIyPPOwQGq9YW31kG2IpbtR5fA79Xh/I5UDy2lODg4UP/9b8k043eueLtatBc4cpNTLZqzZ9mkOI+bTCZ6tCtJzXdLc93yMBwvh/L7oB2cOJq4L58leSkZJEJ0Ed4qVaqwfPlymzWAoqKieO+998w7gLVo0SLZZwZt3brVvNV627Zt7TqmUaNG5tkjT7KrWNeuXcmbNy8Av/76qzkBYC+TycS4cePo2LEjEL28qV69ely9ejXe/iaTiQIFCiQ55uQydepUczzDhw+3aN+9ezf79u2zOcalS5fw9/c3/9ylSxeLPkuWLLG5Cx1EfwY+//xzILpez+uvv27Rp3LlytSoUQOASZMmsXPnTos+Y8aM4dixYwD07dvXYtewO3fusHnzZpux7N69m3fffReIfr9iEo8iIiIi6VKe8tBrK7zob9l2PxCmNYMNXzxXxaWLlK9N1RVbOdPwBYs2z4dRuH/0HSsHtCcsJDhOW5WSOflgZHWu5XGxOC5DmMGanw/y18ITWjaWRpwS7iKSPuzevZvmzZuTN29eWrVqRdWqVfH19SVz5szcvXuX/fv3M3nyZA4fPgyAp6cnX3zxRbLHETuZ06ZNG7uOcXNzo0mTJsyfP59169Zx9epVcufOnejndnFx4cMPP6Rfv37cu3ePn3/+2eaOadY4ODgwbdo0QkNDWbRoEadOneKVV15h8+bNZM+ePdEx2WP79u2cPn3a/HPsJW6nT59m6tSpcfp37do10c9x9OhRunXrxssvv0zz5s0pV66cua7PpUuX2LRpE1OmTDEn0F555RWrz7NkyRLat29P06ZNqVevHiVLlsTLy4tHjx5x5swZli1bxvz5881JyaFDh1KsWDGrMf30009Uq1aNkJAQGjRowKBBg6hTpw4hISHMnTuXCRMmAODn58eAAQMsjr937x516tShTJkytGrVigoVKuDt7Y2joyMXL15k+fLlzJgxw7yr3YcffkiFChUS/dqJiIiIPFdc3KHFz1DkFVj6HoTe/V+bEQXbvoOzm6HNRMhaKK2iTFYZMnrQ7KdF7Fr8G6ZRY/EIipvAKbjiENsOVKfQj79QsPT/ShNkyezCiM+qMWHefzzYco0Mxv++SHfEROD6S/xy/DY9+lckQ8bHluBJijIZSsNJIgUGBpoLKAcEBJAvX740jujJhYaGUrBgwXhnsDyuaNGizJkzx+qFcYECBbhw4QL+/v4WSYjYunbtyrRp0/D19TXPBAoJCSF37tzcv3+fYsWKJaoI84IFC2jXrh0A3333XZyL/5jZS7Vq1UpwJkhwcDC+vr7cvHmTbNmycf78+Tg1a2rXrm2uQ2Prn4/w8HBat27NihUrAChfvjwbN27Ey8vLIq7Yr0FSxLyW9rIW99SpU+nWLXr70GHDhlnMDordbk88v/76KxkzZkxyrBkyZGDkyJH079/fZr9ly5bRqVOneHeA8/PzY8WKFRQpYjmd+fz58+Y6UbY4Ojry2WefMXToUBWSFhEREYnt3iX4sxec32bZ5pIJmoyGsq/Dc/Q31PXAk+x9rysFjlnWSHrkDHd6t6HW25/j4BB3IdLfh66x9o8j5AizfC1CXE20fKcsRYtlTbG4n1Updf2tZWIiRM+suXTpEjt27GDEiBE0btyYQoUK4e7ujqOjIx4eHhQvXpz27dsze/Zsjhw5kiIzJJYsWWK+qLd3VlCMJk2akCFDBuDJloplzJiRfv36AXDr1i1+//33JI3j7OzMwoULeeWVVwDYv38/jRs35uHDh0mOLS21b9+eJUuW8P7771O9enXz58PFxYUcOXJQtWpVPvzwQw4ePMiUKVOsJoIAvv32WyZPnkzXrl2pWLEiPj4+uLq6kiFDBvLmzUuDBg34+uuvOXPmTIKJIIDmzZtz6NAh+vXrh5+fHxkzZsTLy4uKFSvyzTffsH//fquJIIguBr1gwQL69+9P9erVKViwIJkzZ8bZ2Zns2bNTrVo1Bg8ezOnTpxk2bJgSQSIiIiKP88wLXf6CV4aDw2MLb8IewpLesLA7hNxNi+hSRM58fjRYuJWL3eoR7hi3zTUccv+8iNWd63P3ZmCctpfL5OLdL6pxzdtyBlCGRwYrf9zPsj9PatlYKtHMIEm053FmkIiIiIiIyBO5tBcW9YDbZyzbPH3g1YngWzX140pBx3au5NrHn5LrhmWNpNuejriPHEy5+nHrX0ZFGYyfc4Tg7ddxMyy/bDR8M9Ljg4q4ZlBVG9DMIBEREREREZGnV94K0cWly3eybLsXAFObwMZREBmR+rGlkBJVm1BxxSbO1C5s0Zb1XiTO73/OqsH+hIeFmh93cDDRu2NpqvR6gZsulnNTTBeC+XngNs6etlyGJslHySARERERERGR5OCaCVr+Cq9NAzfPuG1GFGz9FqY0gtvn0ia+FJDJIxvNxi3n5tA3eZgh7kwfBwMKLNrN5hY1CDyxN05b9XLe9P78Za7mslw2ljHUYOmYfaxcetqiTZKHkkEiIiIiIiIiyalkK+j9N/hWt2wL/BfG1YCD81I9rJRU440PybtoHheLeFi05Tv/kGvtOrF1ypdxHs/plYERw6rDy9l5RNxZQs6GiXMrL/LrN//wKPT5mU31tFAySERERERERCS5eeYD/6VQ9zMrxaUfwJ89YdFbEHovbeJLAXkKlaben9s493o1Ih8rB5TxEeT4ZgYrujfi4d0b5scdHEz06VKGF3uU4JazlZLG54L4eeB2zp+7m7LBpzNKBomIiIiIiIikBAdHqPkhdF8LWQpath9eAOOqw8V/Uj+2FOLk7EKTYX8Q9fsX3MxqWQS60N8X2N+kLv9tXRLn8doV8tDr85e5lsPymIwhUSz5di+rV1gpzi1JomSQiIiIiIiISErKVwHe3gblOlq23b0YXUdo01fPVXHpMrXbUnb5Os5U9bFoy347gqi3B7L6i15ERvxvJ7JcWTIwbEQNoqpkJczKsrEzyy7w23e7CXv0/LxOaUXJIBEREREREZGU5poZWv0GbaeAq5Xi0lu+jt5x7M6FtIkvBXhkzU2zKWu5+tHrBLvGbXOKAt9ZW1nfugZXzv9nftzRwcR73cpRtnsxbltZNmacfshPA7cTcOH5WV6XFpQMesaFhobSv39/atasSZ48eXBzcyN37txUq1aNKVOmEB4envAgIiIiIiIikjpKvQq9t0P+ly3bAv6JXjZ2aEHqx5WC6rw5lOzzphHo627Rlv/UPQJbv8bfc36I83jdyvl4c/hLXM3maHFMxuAoFn29l3VrzqZYzM87k2EYVio0ybPi5s2b+Pj4ULlyZfz8/MiRIwd37txh1apVXLhwgQYNGrBq1SocHJIv7xcYGIiPT/RUv4CAAPLly5dsY4uIiIiIiKQLUZGw7XvY/BUYkZbtZdpDk+/AzXJ3rmdVWFgI64b1oMCSvThYyUScrV2EOqOnkzFzFvNjkVEGv0w+AHtu44zJ4hgHv8z0ePdFnFwsk0bPg5S6/lYy6BkXFRVFREQELi4ucR6PiIigfv36bN68meXLl9O0adNke04lg0RERERERJJJwL+w+C24c96yzcsX2vwBPpVTPayUtHfNDEKHfkPWe5ZJsOs5Xcj93bcUq9wwzuPrdgXwz8yTZImwTAgFuzvwxgcVyOuTOcViTispdf2tZWLPOAcHB4tEEICTkxOtW7cG4PTp06kdloiIiIiIiNjDpxL02gZlX7dsu3sBJjeCLd9GzyR6TlRo2JkXlq/i7Iu5LNpyXg/jUbcPWPdtX6KiosyP13/Jh27DX+JqVivLxoKimP/Vv2xcfz4lw36upOtk0PXr11m+fDlDhw6lcePGZM+eHZPJhMlkomvXroka68KFCwwYMIDixYvj7u5O1qxZqVSpEqNHjyY4ODhlTsCGqKgoVq9eDUCpUqVS/fmfZUFBQYwbN44mTZqQN29e3NzccHV1JUeOHFSqVInu3bszceJEAgICrB7ftWtX8+co9s3BwQEvLy9Kly5Njx492LVrV6JjGzFihHk8T09PQkND7T729OnTzJkzh379+lGtWjUyZsxoHmvq1KmJjuVJREVFcfToUaZOnco777xDpUqVcHV1NcezefPmZHmeR48e8eeffzJw4EBeeeUV/Pz8yJo1K87OzmTLlo2XX36ZoUOHEhgYaHOc69evM23aNN59911efvllChYsSObMmXF1dcXb25uGDRvy+++/ExQUFO8Y58+ft/q5sHUrUKBAos531apVcY4fPnx4oo4XERERkTTi5gGtx0GbSeD62LIwIxI2jYKpTaN3HntOZMnhQ+OZG7n8biseOcdtc46EfJPXsqZtTW5e/t928nmzuzP08+o8Ku9F+GO7jblEwbGFZxn/0x4iwp+fxFlKSdfLxEwmy+llMfz9/e2+QF62bBmdOnXi/v37Vtv9/PxYsWIFRYoUSUqYdgkLC+PLL7/EMAxu3brFhg0bOH78ON26dWPy5MnJ+lzP8zKxnTt30qFDBy5eTPgf2Vy5cnH16lWLx7t27cq0adPser53332Xn3/+2eZnMbbChQtz9uz/iqTNmTOHDh06JHjcli1bqF27drztU6ZMSXQC9ElMmzbN5vNt2rTJZrz2On36NEWLFk2wn7u7O7/++iv+/v5W2//44w969OiR4Di+vr4sWrSIChUqWLSdP3+eggULJhx0LA0aNGDNmjV29Q0KCqJkyZJcuPC/3SeGDRumhJCIiIjIs+bOBVjcEwKsfHns6gnNvofSbVM/rhR0+tBWLvTrS55Lll9238vkgMOQ96ncqlecx1dvv8jeOafwirSybCyzI536v4i397O/bCylrr+dkmWU50D+/PkpXrw4a9euTdRx+/fvp3379oSEhJApUyYGDhxInTp1CAkJYe7cuUycOJGTJ0/StGlT9uzZQ+bMKfNhDAsLY8SIEeafTSYTH374IV999VWKPN/z6OTJkzRs2JAHDx4A0KJFC9q2bYufnx8uLi7cvHmTgwcPsm7dOjZt2mTXmGvWrCFPnjxAdB2n8+fPs379esaPH09ERARjx44lf/78fPTRRwmOtX37dnMiKFOmTDx8+JDp06fblQyKnfN1cHCgRIkSuLu7s3v3brvOI7nFjsfZ2ZnSpUsTHh7O4cOHk/25cubMSZ06dahUqRK+vr54e3vj7OzMpUuXWLFiBbNmzSIoKIhu3bqRI0cOmjRpYjGGyWSiaNGi1K5dm/Lly5M3b168vb0JDQ3lwoULzJw5kzVr1nDhwgXq16/PkSNHzO97jLx589p1fl999RWzZ88GiDc5Zc1nn33GhQsXyJkzJ9evX7f7OBERERF5ymTxha4rYNsY2PJN3OLSj+7Bojfh9HpoMjp6u/rnQJEyNfFZvo11g7tReOWROG2eD6Pg0x9ZuXk9r3w1FZcM0TuSNaqenxf8svLH93vIdTcqzjEZH0Qy54t/qdCuCLVq50+183iWpOuZQcOGDaNSpUpUqlSJXLlyxfnm3t6ZQTVr1mTbtm04OTmxdetWqlatGqd99OjRfPzxx+bns/Yt/YABA3j06JHdcfft2zfe2Q5RUVFcvnyZZcuWMWjQIEqWLMnKlSvx8Ei+CvTP68yg1157jYULFwIJz5S5ceMG8+fPp0+fPhZtsWcGnTt3zupSn2XLltGiRQsAvLy8uH79Os7Ozhb9YuvZsycTJ04kV65cfPDBBwwcOBBHR0cuXbpErlyWa21jO3XqFH/99ReVKlWiQoUKZMqUialTp9KtWze7zje57d69m3/++YdKlSpRrlw53NzcGD58uDmhmVwzg6KiosxLpmzFUr16dcLDwylfvjz79u2z6BMREYGTk+3c+Y8//ki/fv0A6NevH99//32i442MjCR//vxcvnyZzJkzc+3aNTJkyJDgcXv37qVKlSo4OTkxduxY8ywmzQwSERERecYF7IZFb0XXDnpcloLRxaXzVUz9uFLQP39NwPjip+gk0GOueLvh+8OPFC5Xy/xYWEQkP0/cj/PBezhZ2W3MpZQn3d4uh5PTs7nbWIpdfxtidu7cOQMwAMPf3z/B/v/884+5f69evaz2iYyMNEqUKGEAhpeXlxEWFmbRx93d3TyOPbdNmzbZdT7z5883AOPjjz+2q7+9AgICzLEEBAQk69hpJSIiwsiQIYMBGBUrVnyisfz9/c2vz7lz5+LtV716dXO/nTt32hwzJCTE8PLyMgDj/fffNwIDAw0HBwcDMMaMGZOkOKdMmWJ+/ilTpiRpjOQ0bNiwRH/Gk0vDhg3Nz/3gwYMkjREeHm5kypTpiT5Dq1evNsfRrVs3u46JiIgwypcvbwDGiBEjjE2bNpnHGDZsWJLiEBEREZGnSMg9w1jUwzCGeVjehmcxjC3fGkZkRFpHmayuB54yVrSpZhwtVtzitr9kcWPDL58akZGRcY5ZvvmcMeqd9cbYXhssbt9+tNm4eiVpf+entZS6/k7XBaSf1JIlS8z3Y2ZYPM7BwYEuXboAcPfuXavLix4+fIhhGHbf7J0x0aBBA4BkK8b7PLtx4wYhISEAKVrbKbbSpUub78dXjDrG0qVLuXv3LgCdOnUib9681KlTB4Dp06enWIzpRezlm4mZpRebk5MTbm5uAIkq7B1b7PfS3iViP/zwA/v378fPz49PPvkkSc8rIiIiIk8xNw94dQK8OhFcHlsWZkTCxpEwrTnctX1N8SzJkbcIjeZvJaBHQ8Iem9DjGgHeY5ewumNd7lz/X63XprUK8MZnlbnmaZnmyHg/klmf72bb1ufnNXpSSgY9ge3btwPRxWetFYyNUavW/6aw7dixI8XjinH58mWABJcfCbi4uJjvHzt2LNWfM6H3KCZJUKxYMSpVqgREJ4UADh48mCK1dqyZOnXqc7dT1Y0bN9iwYQMA2bNnJ1u2bEkaZ8OGDdy8eROA4sWLJ/r4Bw8emBPMBQoUoGbNmgkec/78eYYNGwbA77//jqura6KfV0RERESeEWXaQe/tkK+yZduFHTCuGhxZnPpxpRAHBwcaDPgR16k/cjWXi0V7wf3XON6sCftXzzA/ViB3ZoaMqkFwqcxEPrbbmGsUHJp9ikm/7ScyQruNKRn0BGKSBkWKFLFZTyT2hWFyJxqOHj1qdev64OBg+vfvD2C1IK4tgYGBNm9XrlxJltifJlmzZsXX1xeITq588803REVZrlFNTrE/C7a2EL9+/bp5R6mOHTuaH2/Tpo25noy9u5dJtEePHnHu3DkmTpxI1apVuXPnDgAffPBBosZ58OABR48eZfjw4bRu3dr8eN++fRMd08KFC82/y507d7Zrh7nevXsTHBxMx44dqVu3bqKfU0RERESeMVkKQLdVUOtTMD12OR96DxZ2gyV94NHDNAkvJRSv1JDKKzZzpp6fRZvX/UhcPviSlZ92IvxR9EoPFydHPnq3EgXaFeK+o2WJ5NBDd/h+8A5uXA9K8difZkoGJVFoaKh5FkBCBZyyZMmCu3t0xfOElgMl1vz588mdOzdNmjThnXfe4dNPP6Vz587kz5+f1atXU6NGDXNRW3v5+PjYvFWubCUT/Rx47733zPc//fRTChcuTN++fZk3bx7nzp1L1ufas2cP69evB6Bo0aKUKVMm3r6zZ88mIiIC+N9sIIhe2hRThHr27NlERiq7bcvmzZvNs5rc3NwoVKgQPXv25MyZMwB06dLFrl3dhg8fbh7Hw8ODkiVLMmLECB48eICjoyNjx46levXqiY4v9hKxmKWltsyePZvVq1fj5eWVpGLVIiIiIvKMcnSCOgOjk0KeVnbKOjATxteAS3tTP7YU4p4pC81+/YvbI3rxIEPcL00dgIJL9rKleXUuHvvfbskt6hak3aBKXPewsmzsXgTTR/zD338HpnToTy0lg5IoZvtxiN7mOyExyaCHD5M3Q9usWTM6dOjAxYsXmTNnDmPGjGHVqlWUKVOG8ePHs3HjRrt2I5LoHaC6d+9u/vn8+fP8/PPPdOjQgUKFCpE7d246dOjAsmXL4myNbq/IyEjOnDnD77//TqNGjYiKisLR0ZHRo0fj4BD/r2JMkuDll18273YXo3PnzgBcuXKFdevWJTomiZ6VtXbtWqZNmxZn6V5i1atXjyNHjljdYS4hFy9eZMuWLUD0+5xQ3arbt2+bk7xfffUVOXPmTHzAIiIiIvJsy/9S9LKxUm0t226fhUkNorenj3p+vjSu1v4DfP5cwAU/T4u2vBeDudXeny0TPzc/VjivB4NG1eBhiUwWy8bcImHT3JOER6TsipCnlZJBSRS7QKw9F5AxtTxiihQnl4oVKzJhwgSOHDnCnTt3CA8P5+bNm2zcuJGePXsmuB22NQEBATZvu3fvTniQZ5CDgwOTJk1i7dq1NGrUyOK1u3btGvPmzaNFixZUrlzZPKPEloIFC5pnkTg5OVGkSBHeeecdbt26RdGiRVm8eDEtW7aM9/gjR46wf/9+IO6soBgNGzYkR44cAMyYMcOiPbl17drVXMj8WasZVKlSJQ4fPszhw4fZs2cPixcvpmvXrgQEBODv78+kSZPsGuedd94xj7Nr1y6mTJlCnTp12LBhA+3bt+eff/5JdGwzZ840JxjtmRX04Ycfcv36dapUqULPnj0T/XwiIiIi8pxw84zeXr71eMvi0lERsOFzmNYC7j0/M2C8C5TklcXbON+pJhGPZTTcwiDnmDms8G/AgzvXAHB1duSTvpXJ37YgDxz+lxAKw6BW1xI4O6XPtEj6POtkELNrEEBYWFiC/WN2KHoWZunky5fP5s3b2zutQ0xR9evXZ9WqVdy6dYuVK1cyYsQImjdvjqfn/7LPe/bsoUaNGkmun2QymWjfvj3NmjWz2S+mFpCzszPt2rWzaHdycqJ9+/ZA9O52sWesSVzu7u6UKlWKUqVKUaFCBVq3bs2UKVNYs2YNt2/f5q233uLzzz9PcJycOXOax6lSpQpdu3Zl48aNjBw5kkOHDlG7dm3Wrl2bqNhiEnmurq7m9zM+mzdvZsqUKTg6OjJu3Dibs8pEREREJB0wmaBsB3h7G+SrZNl+YTv8Xg3+W5LqoaUUJydnGg8Zj2nC19zIZrkZT6F/AjjY5BUOb15kfqzVK4VoO7Ai1zNFLzPL+HIOqr/4fF/b2qKriCSKvRW1PUu/goKii1PZs6RMng4eHh40btyYoUOHsnTpUq5du8bkyZPJkiULEL0067PPPrM5xpo1a8yzSHbu3MnkyZMpV64chmEwcuTIOHWKHhcZGcns2bMBaNy4cby7XMUsFQsODmbhwoVJOdV0rV69euaCzyNGjOD48eNJGmfw4MFUrlyZ0NBQevToYa7zlJDdu3ebn7NFixZ4eXnF2/fRo0f06tULgPfff59y5colKVYREREReQ5lLRhdR6jmx1aKS9+FBf7w17vPVXHpUtVbUn7lBs5U87Voy3YnAlPvIawe/hYR4dETOIr4eDLwyxpkqu9Nz86lUzvcp4qSQUnk5uZmvjgPDLQ95e7OnTvmZJCPj0+KxyYpw9XVlW7dujFnzhzzY4sXL7a565ifn595FslLL71Et27d2L17Nw0aNADgt99+488//7R67Pr167l8+TIAS5cuNS83e/xWpUoV8zGxixCL/WKW6kVFRbF4cdK344wZ5+LFi3Yvp0xM4ejFixdz8uRJnJ2deeGFF5g7d67FbePGjeb+R44cMT+e3EXQRUREROQp5OgMdQdD1xXgaeXac/8MGF8TLu1L/dhSSGbPHDSbtJrrn3Ym2DVum6MBvnN3sLFVDS6fOQSAm4sT/m1K2LV77/Ms8QVlxOyFF15g27ZtnD59moiIiHjr88SeaVCiRInUCk9SSMOGDfHx8SEgIIA7d+5w69Ytc90eezg7OzN16lSKFSvGgwcP+PDDD2nWrBnOznGnNyYlsbNlyxYuXrxI/vxWdhWQeMV+/y5cuJBs47z88ss2+4eHhzN37lwgevlZo0aNbPaPWW4aHh5Ojx49Eoxn0aJFLFoUPTV2ypQpFgXIRUREROQ55fsyvL0dlveD/x77svP2GZhUH+oOgZf7wnNSdqBW10EEVGvEsfd74XMu7uwnnzP3udymA+c+7E61Th+mUYRPl+fjXU8jMdtHBwUFsXdv/Nv2xewSBFCtWrUUj0tSXp48ecz3k5JR9vb2Ni9NOnv2rEXx4gcPHrBkyRIgehnTnDlzbN7Gjx8PgGEYqVJI+nlz6dIl8/0nWcqZ2HFWrFjBrVu3AHjjjTeSVPBdRERERMSqDF7QdjK0+h1cHvvbNCoC1g+H6S3g3iVrRz+TfIq+SJ2/tnHutSpEPXaZ5h5qkHXkJFb0bEbQ/dtpE+BTRMmgJ9CqVSvz/SlTpljtExUVZZ7h4eXlRZ06dVIjNElBwcHBHD16FIiuKxRfLZ+E9OvXz5ww+Prrr+PUmFm4cCHBwcEA9O7dmw4dOti89ezZk7JlywKps6vY82bBggXm+6VLJ23tcFRUlHkWjr3jxJ795e/vn2D/2Lu5xXfbtGmTuf+wYcPMj3ft2jVxJyQiIiIizz6TCcq9Ab22Qt4Klu3nt8HvL8PRpakfWwpxdnGjyRdTCf9lKLe8HC3aC209w94mtTm+c2UaRPf0UDLoCVSuXJkaNWoAMGnSJHbu3GnRZ8yYMRw7dgyAvn37WiwFkqfDw4cPqVKlCsuXL7dZAygqKor33nvPvGtXixYtkrzWNGvWrLz99ttA9JKi2EmcmCRBxowZady4sV3jtW3bFoATJ04kaXtze0ydOtVcq+hp2Fq+du3a5njOnz9v0T5nzhzu3btnc4z58+ebZ1Z5enrSokULiz4TJ04kMjIy3jGioqIYMGAAR44cAaBGjRoUKFDA5vPevn2bFStWANGJIxWDFhEREZEUk60wdF8DNT4EHrt+Cb0L8zvD0vchLCgtoksR5V55nVLL13CmUh6Lthw3wwl/cwBrv3qXKBt/5z/P0vWahO3bt3P69Gnzzzdv3jTfP336NFOnTo3T39o36z/99BPVqlUjJCSEBg0aMGjQIOrUqUNISAhz585lwoQJQHQh4QEDBqTIeUjy2L17N82bNydv3ry0atWKqlWr4uvrS+bMmbl79y779+9n8uTJHD58GIhOHHzxxRdP9JwDBgxg7NixhIaG8vXXX+Pv709gYKB5aWHjxo3JmDGjXWO1adPGvLvZ9OnT4xSWhujZRrF3vtu+fbvV+wC5c+dOsH7Nk3r89+vAgQPm+6tXr46T3ClSpIh5WWZijB8/np49e9KqVStq1qxJsWLF8PT0JCgoiBMnTrBw4UJWroz+RsBkMvHTTz+RNWtWi3F69uzJiBEjaNu2LS+99BK+vr5kzJiRO3fusH//fqZOncqhQ9EF6Tw8PPj1118TjG3u3LmEhUXvamDPrCARERERkSfi6Az1PoPCdWFxT7j/2EZI+6bBhb+hzR+Qp1yahJjcvLLnpcm0dWyaMIysvy7ELfx/bU5RELH3QPTsqfTISMf8/f0NwO5bfJYuXWp4eHjEe5yfn59x6tSpVDyzlBUQEGA+t4CAgLQOJ1mEhIQYuXPntvuzULRoUWPPnj1Wx4r9uTp37lyCz/3OO++Y+8+ePdsYOXKk+ec5c+Yk6jxeeOEFAzCyZctmPHr0KE6br6+v3edXq1Ytq+NPmTLF3GfYsGGJiu1xifnd8/f3tzpGrVq1bL7Wsdtt3bJkyWLMmjXriWMtUaKEsXfvXrvOv0qVKgZgODo6GleuXLHrGHts2rQp2d4jEREREXlOBd82jHldDGOYh+VtRDbD2P6jYURGpnWUyerMoe3GunrljaPFihtHixU3dlZ4wbge+PRfp6fU9Xe6nhmUXJo3b86hQ4f46aefWLFiBYGBgbi4uFCkSBFee+013n33Xbtnd0jacHNz49KlS+zatYv169eza9cuTpw4wbVr1wgNDcXd3Z08efJQtmxZWrZsSZs2bXBxcUmW5/7444+ZOHEi4eHhfPnll+bZIq6urjRt2jRRY7Vp04ajR49y69YtVqxYQevWrZMlxmfV9OnTWb58Odu3b+f48eNcu3aNGzdu4OLiQvbs2SldujSNGjXijTfeIEuWLPGOs3fvXlatWsWuXbs4d+4c165d4+7du2TMmJE8efLw4osv0rp1a1q2bGnXUtBTp06Zl/LVr1+f3LlzJ9s5i4iIiIgkKEMWeG0qHJgFKz+G8FjLw6LCYd1QOL0BWo8DD8tlVs+iQqWrkW/ZdtYO7U7B5Qdx+OwDcuQtktZhpRmTYRhGWgchz5bAwEB8fHwACAgIIF++fGkckYiIiIiIiCTJrTOw6E24vN+yLUMWaDEWSjRL/bhS0PmjuyjwwktpHYZdUur6WzODJEElS5aM83N4eHg8PUVEREREROSZkq0wvLkONn0J238gekXS/wu5A/M6QoVu0PBLcHk+Vrw8K4mglKTdxERERERERETSM0dneGUY+C+DzFaWhe2dAhNqwZWDqR+bpAgtE5NE0zIxERERERGR51TwbVjWF44ttWxz+P+k0Ut9wEFzS1JDSl1/690TERERERERkWgZs0K76dDiF3B+bFlYVDisHQIzX4UHV9MmPkkWSgaJiIiIiIiIyP+YTPBiF+i1DbzLWbaf3QS/VYXjK1M9NEkeSgaJiIiIiIiIiKXsRaKLS1frC5jitoXchrmvw/L+EBacJuFJ0ikZJCIiIiIiIiLWOblA/c+hy1+Q2duyfc8kmFAbrh5O9dAk6ZQMEhERERERERHbCtWC3n9D8WaWbTdPwMS6sPNXiIpK/dgk0ZQMEhEREREREZGEZcwK7WdCsx/BKUPctsgwWDMIZrWFB9fSJDyxn5JBIiIiIiIiImIfkwkqdoNeWyF3Gcv2Mxvg95fhxOrUj03spmSQiIiIiIiIiCRODj94az28/J5lW/BNmNMeVnwI4SGpH5skSMkgEREREREREUk8J1doMBI6L4FMuS3b/50IE+rAtf9SPTSxTckgEREREREREUm6wnWii0sXa2LZduNYdEJo1zgwjNSPTaxSMkhEREREREREnox7NugwG5p+b6W49CNY/QnMeg0eXk+b+CQOJYNERERERERE5MmZTFDpTei1BXKVtmw/vS66uPTJtakfm8ShZJCIiIiIiIiIJJ8cxaDHBqj6rmVb0A2Y/Rqs+gTCQ1M/NgHAKa0DkKdfyZIl4/wcHh6eRpGIiIiIiIjIM8HJFRqOgsJ1YUlveHgtbvs/4+DcNmjzB+R6IW1iTMc0M0hEREREREREUkaRetHFpf0aWbZd/w8m1IZ/Jqi4dCozGYZecUmcwMBAfHx8AAgICCBfvnxpHJGIiIiIiIg81QwD/v0D1g6BCCvLw4o2hJa/QqYcqR/bUyylrr81M0hEREREREREUpbJBJV7QM/NkKuUZfupNdHFpU+tT/XQ0iMlg0REREREREQkdeQsAW9tgJfesWwLug6z2sDqgSouncKUDBIRERERERGR1OPsBo2+go6LwD2nZfuu3+CPenD9eOrHlk4oGSQiIiIiIiIiqa/oK9HFpYs2sGy7dgQm1ILdE1VcOgUoGSQiIiIiIiIiaSNTDnhjPjQeDY6ucdsiQmHlhzDndQi6mTbxPaeUDBIRERERERGRtGMyQZWe0cWlc75g2X5yVXRx6dMbUj2055WSQSIiIiIiIiKS9nK9AD02QuVelm0Pr8HMV2HNYIh4lPqxPWeUDBIRERERERGRp4NzBmjyLbyxANxzWLbvHBtdXPrGidSP7TmiZJCIiIiIiIiIPF38GkQXly5S37Lt6mEYXwv+naTi0kmkZJCIiIiIiIiIPH0y5YSOC6DRN1aKS4fAiv4wtyME3Uqb+J5hSgaJiIiIiIiIyNPJZIKX3o6uJZSjuGX7iRXRxaXPbEr92J5hSgaJiIiIiIiIyNMtd6no3cYq9bBse3gVZrSCtUMgIiy1I3smKRkkIiIiIiIiIk8/5wzQ9Dt4fR5kzGbZ/vcv/19c+mTqx/aMUTJIRERERERERJ4dxRpB751QuJ5l29VDML4m7Jmi4tI2KBkkIiIiIiIiIs+WzLmg40Jo+BU4usRtiwiB5R/AvE4QfDtNwnvaOaV1APL0K1myZJyfw8PD0ygSERERERERkf/n4ABV34GCNWDhm3DzRNz248vh0l5oPR4K1UqbGJ9SmhkkIiIiIiIiIs+u3KWji0tXfNOy7cEVmN4S1g1VcelYTIahRXSSOIGBgfj4+AAQEBBAvnz50jgiEREREREREeD4SvirD4RYWR7mXQ7aTILsRVI9rKRKqetvzQwSERERERERkedD8Sbwzk4oVMey7coBGF8D9k5L98WllQwSERERERERkedH5tzQaTE0GAUOznHbwoNh2fswv0u6Li6tZJCIiIiIiIiIPF8cHODld6HHBsjuZ9l+bClMbQpRUakf21NAySAREREREREReT55l4WeW6BCN8u2mh9GJ43SofR51iIiIiIiIiKSPrhkhOY/QvtZkCFL9GPlOkKpNmkaVlpySusARERERERERERSXIlmkLcCbBoJjb5O62jSlJJBIiIiIiIiIpI+eHhDy1/TOoo0p2ViIiIiIiIiIiLpiJJBIiIiIiIiIiLpiJJBIiIiIiIiIiLpiJJBIiIiIiIiIiLpiJJBIiIiIiIiIiLpiJJBIiIiIiIiIiLpiJJBIiIiIiIiIiLpiJJBIiIiIiIiIiLpiJJBIiIiIiIiIiLpiJJBIiIiIiIiIiLpiFNaByBPv5IlS8b5OTw8PI0iEREREREREZEnpZlBIiIiIiIiIiLpiGYGSYL++++/OD8HBgbi4+OTRtGIiIiIiIiIyJPQzCARERERERERkXREySARERERERERkXREySARERERERERkXREySARERERERERkXREySARERERERERkXREySARERERERERkXREySARERERERERkXREySARERERERERkXREySARERERERERkXREySARERERERERkXREySARERERERERkXREySARERERERERkXREySARERERERERkXREySARERERERERkXREySARERERERERkXTEKa0DkGdPRESE+f6VK1fSMBIRERERERGR51fsa+7Y1+JPSskgSbQbN26Y71euXDkNIxERERERERFJH27cuEGBAgWSZSwtExMRERERERERSUdMhmEYaR2EPFtCQ0M5fPgwADly5MDJSRPMJPXVrVsXgI0bN6ZxJGKL3if7pZfX6lk+z6c99qcpvrSMJbWe+8qVK+YZ0rt378bb2ztFn08kNTxN/46IdXqP7Pe8vFYRERHm1TmlS5fGzc0tWcbVVbwkmpubG5UqVUrrMCSdc3Z2BiBfvnxpHInYovfJfunltXqWz/Npj/1pii8tY0mL5/b29n4qXneRJ/U0/Tsi1uk9st/z9Fol19Kw2LRMTEREREREREQkHVEySEREREREREQkHVEySEREREREREQkHVEBaRERERGRRAoMDMTHxweAgICA56ImhYiIpB+aGSQiIiIiIiIiko4oGSQiIiIiIiIiko4oGSQiIiIiIiIiko6oZpCIiIiIiIiISDqimUEiIiIiIiIiIumIkkEiIiIiIiIiIumIkkEiIiIiIiIiIumIkkEiIiIiIiIiIumIkkEiIiIiIiIiIumIkkEiIiIiIiIiIumIkkEiIiIiIqkoNDSU/v37U7NmTfLkyYObmxu5c+emWrVqTJkyhfDw8LQOUUREnnMmwzCMtA5CRERERCS9uHnzJj4+PlSuXBk/Pz9y5MjBnTt3WLVqFRcuXKBBgwasWrUKBwd9bysiIilDySARERERkVQUFRVFREQELi4ucR6PiIigfv36bN68meXLl9O0adM0ilBERJ53+rpBRERERCQVOTg4WCSCAJycnGjdujUAp0+fTu2wREQkHVEySERERETSjevXr7N8+XKGDh1K48aNyZ49OyaTCZPJRNeuXRM11oULFxgwYADFixfH3d2drFmzUqlSJUaPHk1wcHCiY4uKimL16tUAlCpVKtHHi4iI2MsprQMQEREREUktuXLlSpZxli1bRqdOnbh//775seDgYPbs2cOePXv4448/WLFiBUWKFIl3jLCwML788ksMw+DWrVts2LCB48eP061bN+rVq5cscYqIiFijmkEiIiIikm6YTCbz/fz581O8eHHWrl0LgL+/P1OnTk1wjP3791OtWjVCQkLIlCkTAwcOpE6dOoSEhDB37lwmTpwIgJ+fH3v27CFz5sxWx3n48GGcNpPJxIABA/jqq69wctJ3tiIiknL0v4yIiIiIpBtDhw6lUqVKVKpUiVy5cnH+/HkKFiyYqDH69u1LSEgITk5OrF27lqpVq5rb6tatS9GiRfn44485efIkY8aMYfjw4VbHyZQpE4ZhEBUVxeXLl1m2bBmDBg1i586drFy5Eg8Pjyc5VRERkXhpZpCIiIiIpFuxk0H2zAzavXs3VapUAaBXr16MGzfOok9UVBSlSpXi2LFjeHl5cf36dZydne2KZ8GCBbRr146PP/6Yb775JnEnIyIiYicVkBYRERERsdOSJUvM97t162a1j4ODA126dAHg7t27bNq0ye7xGzRoAMDmzZuTHKOIiEhClAwSEREREbHT9u3bAXB3d6dChQrx9qtVq5b5/o4dO+we//LlywB2zyQSERFJCiWDRERERETsdOzYMQCKFClis8hz8eLFLY6JcfToUatbzwcHB9O/f38AmjRpkhzhioiIWKUC0iIiIiIidggNDeXmzZsA5MuXz2bfLFmy4O7uTlBQEAEBAXHa5s+fz/fff0/16tUpUKAAHh4eXLp0iVWrVnHr1i1q1KhBv379Uuw8RERElAwSEREREbHDgwcPzPczZcqUYP+YZNDDhw/jPN6sWTMuX77M33//zc6dO3n48CGenp6UKVOGDh060L17d20tLyIiKUr/y4iIiIiI2CE0NNR838XFJcH+rq6uAISEhMR5vGLFilSsWDF5gxMREUkE1QwSEREREbGDm5ub+XykYSIAABr/SURBVH5YWFiC/R89egRAhgwZUiwmERGRpFAySERERETEDpkzZzbff3zplzVBQUGAfUvKREREUpOSQSIiIiIidnBzcyNbtmwABAYG2ux7584dczLIx8cnxWMTERFJDCWDRERERETs9MILLwBw+vRpIiIi4u13/Phx8/0SJUqkeFwiIiKJoWSQiIiIiIidqlevDkQvAdu7d2+8/bZs2WK+X61atRSPS0REJDGUDBIRERERsVOrVq3M96dMmWK1T1RUFNOnTwfAy8uLOnXqpEZoIiIidlMySERERETETpUrV6ZGjRoATJo0iZ07d1r0GTNmDMeOHQOgb9++ODs7p2qMIiIiCTEZhmGkdRAiIiIiIqlh+/btnD592vzzzZs3+eijj4Do5VxvvfVWnP5du3a1GGP//v1Uq1aNkJAQMmXKxKBBg6hTpw4hISHMnTuXCRMmAODn58eePXvi7EImIiLyNFAySERERETSja5duzJt2jS7+8f3p/KyZcvo1KkT9+/ft9ru5+fHihUrKFKkSJLiFBERSUlaJiYiIiIikkjNmzfn0KFD9OvXDz8/PzJmzIiXlxcVK1bkm2++Yf/+/UoEiYjIU0szg0RERERERERE0hHNDBIRERERERERSUeUDBIRERERERERSUeUDBIRERERERERSUeUDBIRERERERERSUeUDBIRERERERERSUeUDBIRERERERERSUeUDBIRERERERERSUeUDBIRERERERERSUeUDBIRERERERERSUeUDBIRERERERERSUeUDBIRERERERERSUeUDBIRERERERERSUeUDBIRERERERERSUeUDBIRERERERERSUeUDBIRERERERERSUeUDBIRERERERERSUeUDBIRERERERERSUeUDBIRERGReNWuXRuTyUTt2rXTOpSn2ooVK2jYsCHZs2fH0dERk8mEl5dXWoclIiJilVNaByAiIiIi8iz77bff6NOnT1qHISIiYjfNDBIRERERSaLg4GAGDRoEQPHixVm4cCH79+/n8OHD7Ny5M1Vi6Nq1KyaTiQIFCqTK84mIyLNPM4NERERERJJoz5493Lt3D4DvvvuOpk2bpnFEIiIiCdPMIBERERGRJLp06ZL5vp+fXxpGIiIiYj8lg0REREREkujRo0fm+87OzmkYiYiIiP2UDBIREXlCR44cYeTIkTRs2JB8+fLh6upKpkyZKFq0KP7+/uzatcvqccHBwWTOnBmTyUTHjh0TfJ6dO3diMpkwmUz89ttvVvtcvXqVwYMHU7FiRbJmzYqrqys+Pj60a9eO9evXxzv2+fPnzWNPnToVgMWLF9OkSRPy5MmDk5OTxW5Su3btYsiQIdSuXZvcuXPj4uKCh4cHL7zwAr179+bo0aMJnhPAxYsX6d27NwULFsTNzY08efLQqlUrNm3aBMDw4cPNsdly7949vvrqK6pVq0aOHDlwcXHB29ub5s2bs3DhQgzDsCsea6y9PuvWraN58+bkzp0bV1dXChYsSO/evQkMDIx3HHtru0ydOtX8fOfPn7doL1CgACaTia5duwKwb98+OnbsiI+PDxkyZKBIkSL079+fmzdvxjnu77//5rXXXiN//vy4ublRuHBhPvnkEx48eGD3a3HixAl69uxpfr+8vb1p165dvJ/zx6XmZ9ReN27cYMiQIZQvXx4vLy/c3NwoUKAAnTt3Zvv27VaPidllrVu3bubHChYsaI7RZDKxefPmRMURGhrKzz//TO3atcmRIwfOzs5kzZqVYsWK0bhxY77//vs4n4eY341p06YBcOHChTjPb+v3JjQ0lLFjx1KvXj3z72/OnDl55ZVXmDRpEhEREfHG+fjn799//+X111/Hx8cHNzc3fHx86NatG8ePH0/W8xURkWRkiIiISJJt2rTJABK8ffrpp1aP79SpkwEY7u7uxsOHD20+V58+fQzAcHJyMm7cuGHRPnPmTMPd3d1mHG+++aYRHh5ucey5c+fMfSZPnmx07tzZ4thatWqZ+0+ZMiXBc3Z0dDR+/fVXm+e0YcMGI1OmTFaPN5lMxqhRo4xhw4aZH4vP+vXrjWzZstmMp0mTJsaDBw9sxhOf2K/PlClTjE8//TTe58mRI4dx9OhRq+P4+/sbgOHr62vz+WK/vufOnbNo9/X1NQDD39/fmD59uuHi4mI1Fj8/P+PKlSuGYRjG6NGjDZPJZLXfiy++GO9rU6tWLfP7v3Llyng/Yw4ODsYPP/xg87xS8zNqrzVr1hgeHh42Y+rTp48RGRlp9XWxddu0aZPdcVy+fNl44YUXEhxzwIAB5mNi/27Yuj3uwIED5s9QfLdKlSoZV69etRpr7M/fpEmTDCcnJ6tjuLq6GvPnz0+28xURkeSjZJCIiMgTWLduneHu7m60a9fOGDdunLF582Zj3759xurVq40xY8bEueCaPHmyxfGrVq0yt8+aNSve5wkPDzdy5sxpAEbTpk0t2ufNm2e+0C9UqJDx/fffG6tXrzb27t1rLFq0yGjSpIn5efr162dxfOwL7TJlyhiAUaNGDWP27NnGnj17jPXr1xt//PGHuf/EiRONLFmyGF27djUmT55sbNu2zdi3b5+xfPly4/PPPzeyZ89uTuhs2LDB6jmdOXPGnBhwcnIy3nvvPWPDhg3Gv//+a0yZMsV8oVilShWbyaDt27cbzs7OBmDkypXLGDlypLFs2TJj7969xrJly8wJN8B49dVX432NbYn9+rz88svmxEPs16dLly7mPi+99JLVcZI7GVSuXDnDxcXFeOGFF4zJkycb//77r7Fx48Y459yxY0dj0aJF5rhmzZpl7Nmzx1i9enWcz8Unn3xiNZaYpEfRokUNLy8vw9PT0/jyyy+Nv//+2/j777+NUaNGxUmm/Pnnn1bHSe3PqD32799vTqQ5Ozsb/fr1MzZt2mTs3r3bGD9+vFGwYEHzc3788cdxjj179qxx+PBhY+TIkeY+a9asMQ4fPmy+JZTgja1NmzbmcTp16mQsXrzY2LVrl/Hvv/8aS5cuNYYOHWqULVs2TnLk2rVrxuHDh42WLVsagJEnT544zx9zi+3UqVOGp6enARgeHh7GwIEDjT///NPYs2ePsWbNGqNPnz7m5E6VKlWMsLAwi1hjPn9ly5Y1nJ2djTx58hi//PKL8c8//xhbtmwxPvnkE8PV1dX8uv7777/Jcr4iIpJ8lAwSERF5Ajdu3DDu3LkTb/ujR4+M+vXrmxMAERERcdoTSvLEiJ00mj17tkUMMRd33bt3tzqrwjAMY9CgQeYZHMePH4/TFvtCGzC6dOliREVFxRtPYGCgERQUFG/73bt3zRfs1atXt9qnVatWNhMIQUFBRuXKlW3OcAgLCzMKFChgAEajRo3ijWnChAnmMdauXRtv3PF5/PXp0aOH1dfnrbfeMvfZt2+fRXtyJ4NiklPWzrtt27YGRM/Qypo1q9GmTRuLz19ERITx0ksvGYCRLVs2q5+d2DNgPD09rc56OnLkiDkhlDdvXosEQlp8Ru1RqVIl82u0Zs0ai/bbt2+bk5IODg7GkSNHLPok9F7ZIyQkxJzQTCj5cevWLYvH7P1cGYZhTmaWL1/e6gxDw4j+98bBwcEAjAkTJli0x/78+fr6mmefxbZx40ZzUqlSpUpx2p70fEVE5MkpGSQiIpLCDhw4YL5w2rNnj0X7e++9Z/4G/ebNm1bHiJnpkSlTJosL/88//9x8ER4aGhpvHOHh4UbevHkNwBg0aFCcttgX2l5eXsb9+/eTcKZxLVmyxDzm4+d16dIlw9HR0QCMtm3bxjtG7NfOWjJo+vTpBmC4ubkZ169ftxlPTGLpjTfeSPS5xH59vL29432djx8/bu73008/WbQndzLIZDLFuyRt48aN5jEyZswY70X15MmTzf0OHjxo0R47GfTdd9/FG/M333xj7rdgwYI4bU/jZ/Sff/4xj/f222/H22/79u3mfu+8845Fe3Ikgy5dumQe46+//kr08fZ+rrZu3Wp+nkOHDtns265dO3Oy8XGxk0ELFy6Md4zevXub+8WeHfSk5ysiIk9OBaRFRESS0aNHj7h48SJHjx7lyJEjHDlyJE7h4oMHD1ocE1M8Ojw8nPnz51u0h4SEsGTJEgBatWpFxowZ47QvXboUgGbNmuHq6hpvbE5OTlStWhWILkYdn+bNm5M5c+Z4260JCgri/Pnz/Pfff+bzjr2z0uPnvWnTJiIjIwHo3LlzvOOWLVuWsmXLxtsec+61atUiR44cNmOsWbMmYPvc7dG2bdt4X+dixYqRKVMmAM6ePftEz2OPMmXKUKJECattsV+3+vXrkzVr1gT72YrZZDLh7+8fb3u3bt3MxYofLwT9NHxGHxc7xjfffDPeftWqVTO/xrYKXD+JbNmy4eLiAsCMGTNsFm9+EjHvQ7FixShdurTNvjG/L//++2+88WTJkoWWLVvGO0b37t3N92O/dql1viIiEj8lg0RERJ5QUFAQX331FWXLlsXd3R1fX19KlixJ6dKlKV26NOXLlzf3fXx3J4AqVapQuHBhAGbNmmXRvnTpUh4+fAhgsetYZGQkBw4cAGD8+PFWdxKKfVu4cCEQvaNTfMqUKWPXed+8eZNBgwZRrFgxMmfOTMGCBSlVqpT5vJs2bRrveR85csR8v0KFCjafp2LFivG27dmzB4A1a9YkeO7fffcdYPvc7VG8eHGb7VmyZAFI1A5dSeXn5xdvm5eXV6L72Yq5YMGCZM+ePd72HDlymHdJO3z4sPnxtPyM2hLzGXRxcaFcuXI2+1apUgWAU6dOERYW9sTP/ThXV1fat28PwMKFCylSpAgff/wxK1eu5O7du8n2PDG/LydOnEjwfXj33XeB6CT17du3rY5Xvnx5nJyc4n2+cuXKmZM+sT8TqXW+IiISPyWDREREnsD58+cpXbo0gwYN4tChQ+bZLvEJCQmx+nhMkufvv/+22Eo5JkEUs+1zbLdv307St+rBwcHxtsUkM2zZu3cvxYsX56uvvuLkyZMJbtv++HnfuXPHfD+hGT222q9fv55grAnFkliPz8x6nIND9J9XCX0WkoOtWGLiSEw/WzHnzJkzwXhy5coFECd5kFaf0YTExJg1a1abCQ2A3LlzA2AYRpzPbnIaO3YszZs3B6K3iB89ejRNmzYlW7ZsVKpUidGjR3Pv3r0neo6k/L5A/O9FQp8JJycn84y0xxNKqXG+IiISP9v/84mIiIhNnTt35ty5c5hMJrp160aHDh0oUaIEOXLkwMXFBZPJRFRUFI6OjgDxJk06duzI559/jmEYzJkzh4EDBwLRF1Br1qwBoH379hYXrbEv3t966y369u1rV9wx39ZbExNrfMLCwmjXrh23bt3C2dmZ9957j5YtW+Ln50eWLFnMy4DOnj1rnvGUULIoqWLOv3Hjxnz77bcp8hwSLWYJWGKlxWc0MZJ6XsnNw8ODpUuXsnv3bubPn8/mzZs5cOAAkZGR7Nmzhz179vDdd9+xZMkS81K6xIp5L8qWLcvMmTPtPi5v3rxWH3+S1y41zldEROKnZJCIiEgSHT9+nO3btwMwaNAgRo4cabVffEssYvPz86NixYrs2bOH2bNnm5NBCxcuNC9LeXyJGBCnDoxhGJQqVSrR55FYGzduNNeW+e2333jrrbes9rN13rFndty4cSPei82Y9vhky5aNy5cvExYWlirn/qRiZuFERUXZ7BcUFJQa4STKtWvX7O4T+3OZFp9Re8TEdevWLSIiImzODopZsmYymZJlVpItlStXpnLlykD0sr3NmzczdepUFi9ezPXr12nTpg1nzpwhQ4YMiR47W7ZsADx8+DBZ3oeEPhMRERFxZmBZk5LnKyIi8dMyMRERkST677//zPdj6l9YE1OnIyExyZ4jR45w6NAh4H9LxAoXLmyuWxKbi4sLJUuWBGDHjh32Bf6EkuO8Y2KG6CVnttgaJ6Ye0549e1Kklktyiyl6nFBdlJMnT6ZCNIlz7tw5bt26FW/7jRs3zEscYyca0uIzao+YGMPCwsw1jeKze/duAIoWLWpzxlJyy5w5M82bN2fRokW8//77AFy5csWchI5h7wydmN+Xs2fPPnHtLIADBw7YXAJ48OBB8++lPckne89XRESenJJBIiIiSRT7IsjWTI5x48bZNV6HDh3My19mzZpFYGAg27ZtA6zPCorRokULIHqmUsySspRkz3lHRUUxceLEeMeoXbu2eZbMjBkz4u138OBBqzuwxYg593v37jFlyhSbcT8NChYsCETPgDhx4oTVPmFhYSxatCg1w7KLYRhMnz493vapU6ealwM+XtsqtT+j9ogd4+TJk+Ptt3PnTo4ePWpxTGqrV6+e+f7jBdnd3NyA6N0MbYl5HwzD4KeffnrimG7fvs2yZcvibY/9uib2tbN1viIi8uSUDBIREUmiokWLmu9PnTrVap/ff/+dv/76y67xcufOTd26dQGYM2cOs2fPNl9c20oG9e3b17ydebdu3eLM3LFmxYoV5plHSWHPeQ8cOJB9+/bFO0a+fPnMu40tXLiQJUuWWPQJCQmhZ8+eNmPx9/fHx8cHgA8//JCtW7fa7L99+3a2bNlis09KqlWrlvn+mDFjrPbp378/ly5dSq2QEuWLL76wmsQ6duwYo0aNAsDb29tiu/HU/ozao3Llyuad6iZOnMiGDRss+ty7d49evXoB0Uv8evfunSKxnD17NsHP5dq1a833Y5KKMby9vYHoAtG2doRr0KCBeUnW6NGjmT9/vs3nPHz4sM1kD0R/Xq0tF9uyZQsTJkwAoncMrFSpkrntSc9XRESenGoGiYiIJFH58uUpVaoUR44cYfz48dy5c4fOnTvj7e1NYGAgM2fOZOHChVSrVs3u5TEdO3Zk3bp1BAQE8NVXXwHRW6vb2ho8V65cTJs2jbZt23LlyhUqVqxI165dady4Mfny5SM8PJzAwEB2797NwoULOXv2LMuWLUvy9twNGzYkZ86cXL9+nSFDhnD+/Hlat25N9uzZ+b/27i4kqu0P4/jz12bULCVJJUNNsJBINCybpHCUstCERFKhcIqElPBKIQzLugikRC+sEL2QIIy6EXrDBE0wMmpshMQKJXvDIKELeyPD9rk4/4bTydE5x44T7u8HBhw2a+3f0qXgw6zfHhkZcf9jPdu66+vr1dXVpU+fPmnPnj0qKytTXl6eQkJCNDg4qNOnT2toaEgbN27UgwcPpp0jICBAV65ckd1u14cPH5SZmamioiLt3r1bcXFx+vbtm968eaP+/n61t7fr0aNHamxs/CGUmU/r16/X5s2b1dfXp5aWFk1OTsrhcCg0NFTDw8Nqbm5Wd3e30tLSdPfuXZ/U6El8fLzGx8dls9l05MgR2e12SVJPT49qa2vdT35qbGz86SjVfO9Rb7W0tGjTpk2anJxUdna2ysvLlZubq+DgYLlcLtXW1rr7Y1VWVv5n/Y5evnypjIwMrV27Vnl5edqwYYO7j9arV690+fJld3CTnJz805HRtLQ0SX9+Iq+0tFTl5eVavny5+3p8fLz767a2NqWmpurdu3cqLCzUxYsXVVhYqNWrV8vf319v376Vy+XStWvXdO/ePVVUVLif+vV3SUlJGhoaUkpKiqqqqpSamqovX77o5s2bamhocPdiOnfu3C9dLwDgFzAAAMC/5nK5jGXLlhmSpn0lJiYaY2Nj7vc1NTUzzjcxMWEEBQX9MEdDQ4NXtVy9etUICwvzWMv3l5+fn9Hd3f3D2NHRUff11tbWWe/V0dFhBAYGeryH3W43BgcHZ52zs7PTCA4O9jhPTU2NcezYMUOSERgY6LGevr4+Izo6eta1SzIuXLjg1ffz335/YmNjDUmGw+GY9vrjx4+NiIgIj/VVVlYara2t7vejo6P/+B7febPvZltbenq6IclIT083rl+/bixevNjjvqqrq5uxnvnco966deuWERISMmM9hw8fNqampqYdP9vPyhu3b9/2au8mJCQYz549+2n81NSUYbPZPI77u6dPnxrr1q3z6p4nT578afxf919LS4uxaNGiacdarVbj0qVLv3y9AIC545gYAABzkJycrIGBAZWWlio2NlYWi0VhYWFKTU1VXV2d7t+/7z7C4Y3vDVS/8/f3V1FRkVdjc3NzNTo6qrq6OmVmZioyMlIWi0VBQUGKi4vTrl27VF9fr+fPnysjI+Mfr/WvduzYIafTqX379ikqKkoWi0Xh4eFKT09Xc3Ozurq6FBwcPOs827dv1+DgoA4dOqTY2FhZrVZFRkYqJydHHR0dOnHihCYmJiRJoaGhHuex2WwaHh5WU1OTcnJyFBUVJavVqsDAQEVHRysrK0unTp3SkydPVFxcPKe1z1VCQoIePnyosrIy95rDw8O1c+dO3bhxQ2fOnPFpfTPJycmR0+nUgQMH3LVHREQoPz9fd+7cUUVFxYzj53OPeisrK0sjIyM6evSokpOTFRISooCAAMXExGjv3r3q7e3V2bNn3T2u/gtbt25VT0+PqqqqlJGRofj4eC1dulQWi0WRkZHKyspSU1OTBgYGpj0y5efnp87OTlVXVyspKUlLliyZsan0mjVrNDAwoLa2NuXn5ysmJkZBQUGyWq1asWKF7Ha7qqur1d/fr+PHj89Ye0lJiXp7e1VQUOD+vVu5cqWKi4vlcrmm/fs11/UCAObuf4bx/2YEAAAAv6Ft27apq6tLW7ZscTfUBuA7q1at0osXL+RwODz2DQMA/N74ZBAAAPhtjY2NuZtC22w2H1cDAACwMBAGAQAAnxkZGfF47fPnz9q/f7++fv0qST4/3gUAALBQ8DQxAADgMyUlJfr48aMKCgqUkpKisLAwvX//Xk6nU+fPn3eHRQcPHlRiYqKPqwUAAFgYCIMAAIBPOZ1OOZ1Oj9fz8vLU2Ng4jxUBAAAsbIRBAADAZ+rr69Xe3q7u7m69fv1a4+PjMgxDERERstlscjgcys7O9nWZAAAACwpPEwMAAAAAADARGkgDAAAAAACYCGEQAAAAAACAiRAGAQAAAAAAmAhhEAAAAAAAgIkQBgEAAAAAAJgIYRAAAAAAAICJEAYBAAAAAACYCGEQAAAAAACAiRAGAQAAAAAAmAhhEAAAAAAAgIkQBgEAAAAAAJgIYRAAAAAAAICJEAYBAAAAAACYCGEQAAAAAACAiRAGAQAAAAAAmAhhEAAAAAAAgIkQBgEAAAAAAJgIYRAAAAAAAICJEAYBAAAAAACYyB9ADhYKx+pEEQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "draw_order_multiple(\n", " [\n", diff --git a/examples/underdamped_langevin_example.ipynb b/examples/underdamped_langevin_example.ipynb index 67fa4d9b..a70faff3 100644 --- a/examples/underdamped_langevin_example.ipynb +++ b/examples/underdamped_langevin_example.ipynb @@ -19,7 +19,7 @@ "and velocity, $w$ is a Brownian motion in $\\mathbb{R}^d$,\n", "$f: \\mathbb{R}^d \\rightarrow \\mathbb{R}$ is a potential function, and\n", "$\\gamma , u \\in \\mathbb{R}^{d \\times d}$ are diagonal matrices governing\n", - "the friction and the inertia of the system.\n", + "the friction and the damping of the system.\n", "\n", "## ULD for Monte Carlo and Bayesian inference\n", "\n", diff --git a/test/test_underdamped_langevin.py b/test/test_underdamped_langevin.py index 5c8f91fe..68d3fed9 100644 --- a/test/test_underdamped_langevin.py +++ b/test/test_underdamped_langevin.py @@ -16,6 +16,7 @@ ) +# ULD stands for Underdamped Langevin Diffusion def _only_uld_solvers_cls(): yield diffrax.ALIGN yield diffrax.ShOULD @@ -34,11 +35,17 @@ def get_pytree_uld(t0=0.3, t1=1.0, dtype=jnp.float32): def make_pytree(array_factory): return { "rr": ( - array_factory((2,), dtype), - array_factory((2,), dtype), + array_factory((1, 3, 2), dtype), + array_factory( + ( + 3, + 2, + ), + dtype, + ), ), "qq": ( - array_factory((2,), dtype), + array_factory((1, 2), dtype), array_factory((3,), dtype), ), } @@ -48,7 +55,7 @@ def make_pytree(array_factory): y0 = (x0, v0) g1 = { - "rr": 0.001 * jnp.ones((2,), dtype), + "rr": 0.001 * jnp.ones((3, 2), dtype), "qq": ( jnp.ones((), dtype), 10 * jnp.ones((3,), dtype), From 3aab39ce1763f3ec9ceb9f1343752216835657cb Mon Sep 17 00:00:00 2001 From: andyElking Date: Sun, 1 Sep 2024 15:42:18 +0100 Subject: [PATCH 12/15] check langevin drift term and diffusion term have same args --- diffrax/_solver/foster_langevin_srk.py | 51 +++++++++++++++++++++----- test/test_underdamped_langevin.py | 41 +++++++++++++++++++++ 2 files changed, 82 insertions(+), 10 deletions(-) diff --git a/diffrax/_solver/foster_langevin_srk.py b/diffrax/_solver/foster_langevin_srk.py index 0264b1a4..a20b50ce 100644 --- a/diffrax/_solver/foster_langevin_srk.py +++ b/diffrax/_solver/foster_langevin_srk.py @@ -44,7 +44,13 @@ def _get_args_from_terms( terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], -) -> tuple[PyTree, PyTree, Callable[[UnderdampedLangevinX], UnderdampedLangevinX]]: +) -> tuple[ + PyTree, + PyTree, + PyTree, + PyTree, + Callable[[UnderdampedLangevinX], UnderdampedLangevinX], +]: drift, diffusion = terms.terms if isinstance(drift, WrapTerm): assert isinstance(diffusion, WrapTerm) @@ -53,10 +59,12 @@ def _get_args_from_terms( assert isinstance(drift, UnderdampedLangevinDriftTerm) assert isinstance(diffusion, UnderdampedLangevinDiffusionTerm) - gamma = drift.gamma - u = drift.u + gamma_drift = drift.gamma + u_drift = drift.u f = drift.grad_f - return gamma, u, f + gamma_diffusion = diffusion.gamma + u_diffusion = diffusion.u + return gamma_drift, u_drift, gamma_diffusion, u_diffusion, f # CONCERNING COEFFICIENTS: @@ -248,23 +256,46 @@ def init( evaluation of grad_f. """ drift, diffusion = terms.terms - gamma, u, grad_f = _get_args_from_terms(terms) + ( + gamma_drift, + u_drift, + gamma_diffusion, + u_diffusion, + grad_f, + ) = _get_args_from_terms(terms) h = drift.contr(t0, t1) x0, v0 = y0 - gamma = broadcast_underdamped_langevin_arg(gamma, x0, "gamma") - u = broadcast_underdamped_langevin_arg(u, x0, "u") + gamma = broadcast_underdamped_langevin_arg(gamma_drift, x0, "gamma") + u = broadcast_underdamped_langevin_arg(u_drift, x0, "u") + + # Check that drift and diffusion have the same arguments + gamma_diffusion = broadcast_underdamped_langevin_arg( + gamma_diffusion, x0, "gamma" + ) + u_diffusion = broadcast_underdamped_langevin_arg(u_diffusion, x0, "u") + + def compare_args_fun(arg1, arg2): + arg = eqx.error_if( + arg1, + jnp.any(arg1 != arg2), + "The arguments of the drift and diffusion terms must match.", + ) + return arg + + gamma = jtu.tree_map(compare_args_fun, gamma, gamma_diffusion) + u = jtu.tree_map(compare_args_fun, u, u_diffusion) try: grad_f_shape = jax.eval_shape(grad_f, x0) except ValueError: raise UnderdampedLangevinStructureError("grad_f") - def _shape_check_fun(_x, _g, _u, _fx): + def shape_check_fun(_x, _g, _u, _fx): return _x.shape == _g.shape == _u.shape == _fx.shape - if not jtu.tree_all(jtu.tree_map(_shape_check_fun, x0, gamma, u, grad_f_shape)): + if not jtu.tree_all(jtu.tree_map(shape_check_fun, x0, gamma, u, grad_f_shape)): raise UnderdampedLangevinStructureError(None) tay_coeffs = jtu.tree_map(self._tay_coeffs_single, gamma) @@ -342,7 +373,7 @@ def step( old_coeffs: _Coeffs = st.coeffs gamma, u, rho = st.gamma, st.u, st.rho - _, _, grad_f = _get_args_from_terms(terms) + _, _, _, _, grad_f = _get_args_from_terms(terms) # If h changed, recompute coefficients # Even when using constant step sizes, h can fluctuate by small amounts, diff --git a/test/test_underdamped_langevin.py b/test/test_underdamped_langevin.py index 68d3fed9..7c318cb9 100644 --- a/test/test_underdamped_langevin.py +++ b/test/test_underdamped_langevin.py @@ -238,3 +238,44 @@ def test_reverse_solve(solver_cls): error = path_l2_dist(sol.ys, ref_sol.ys) assert error < 0.1 + + +# Here we check that if the drift and diffusion term have different arguments, +# an error is thrown. +def test_different_args(): + x0 = (jnp.ones(2), jnp.zeros(2)) + v0 = (jnp.zeros(2), jnp.zeros(2)) + y0 = (x0, v0) + g1 = (jnp.array([1, 2]), jnp.array([1, 2])) + u1 = (jnp.array([1, 2]), 1) + g2 = (jnp.array([1, 2]), jnp.array([1, 3])) + u2 = (jnp.array([1, 2]), jnp.ones((2,))) + grad_f = lambda x: x + + w_shape = ( + jax.ShapeDtypeStruct((2,), jnp.float64), + jax.ShapeDtypeStruct((2,), jnp.float64), + ) + bm = diffrax.VirtualBrownianTree( + 0, + 1, + tol=0.05, + shape=w_shape, + key=jr.key(0), + levy_area=diffrax.SpaceTimeTimeLevyArea, + ) + + drift_term = diffrax.UnderdampedLangevinDriftTerm(g1, u1, grad_f) + + # This one should fail + diffusion_term_a = diffrax.UnderdampedLangevinDiffusionTerm(g2, u1, bm) + terms_a = diffrax.MultiTerm(drift_term, diffusion_term_a) + + # This one should not fail + diffusion_term_b = diffrax.UnderdampedLangevinDiffusionTerm(g1, u2, bm) + terms_b = diffrax.MultiTerm(drift_term, diffusion_term_b) + + solver = diffrax.ShOULD(0.01) + with pytest.raises(Exception): + diffeqsolve(terms_a, solver, 0, 1, 0.1, y0, args=None) + diffeqsolve(terms_b, solver, 0, 1, 0.1, y0, args=None) From b760c654945b73bca5117e69b9ba8ac81f3df23d Mon Sep 17 00:00:00 2001 From: andyElking Date: Sun, 1 Sep 2024 16:26:55 +0100 Subject: [PATCH 13/15] added scan_trick in QUICSORT and ShOULD --- diffrax/_solver/align.py | 4 +-- diffrax/_solver/foster_langevin_srk.py | 2 +- diffrax/_solver/quicsort.py | 28 +++++++++++----- diffrax/_solver/should.py | 37 ++++++++++++++------- examples/underdamped_langevin_example.ipynb | 14 ++++---- test/test_underdamped_langevin.py | 11 +----- 6 files changed, 56 insertions(+), 40 deletions(-) diff --git a/diffrax/_solver/align.py b/diffrax/_solver/align.py index b682fcbe..dd6bf9ed 100644 --- a/diffrax/_solver/align.py +++ b/diffrax/_solver/align.py @@ -149,7 +149,7 @@ def _compute_step( levy: AbstractSpaceTimeLevyArea, x0: UnderdampedLangevinX, v0: UnderdampedLangevinX, - uld_args: UnderdampedLangevinArgs, + underdamped_langevin_args: UnderdampedLangevinArgs, coeffs: _ALIGNCoeffs, rho: UnderdampedLangevinX, prev_f: UnderdampedLangevinX, @@ -163,7 +163,7 @@ def _compute_step( w: UnderdampedLangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) hh: UnderdampedLangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) - gamma, u, f = uld_args + gamma, u, f = underdamped_langevin_args uh = (u**ω * h).ω f0 = prev_f diff --git a/diffrax/_solver/foster_langevin_srk.py b/diffrax/_solver/foster_langevin_srk.py index a20b50ce..24627fdb 100644 --- a/diffrax/_solver/foster_langevin_srk.py +++ b/diffrax/_solver/foster_langevin_srk.py @@ -326,7 +326,7 @@ def _compute_step( levy, x0: UnderdampedLangevinX, v0: UnderdampedLangevinX, - uld_args: UnderdampedLangevinArgs, + underdamped_langevin_args: UnderdampedLangevinArgs, coeffs: _Coeffs, rho: UnderdampedLangevinX, prev_f: Optional[UnderdampedLangevinX], diff --git a/diffrax/_solver/quicsort.py b/diffrax/_solver/quicsort.py index 303d2af2..2e6ca897 100644 --- a/diffrax/_solver/quicsort.py +++ b/diffrax/_solver/quicsort.py @@ -5,7 +5,7 @@ import jax import jax.numpy as jnp import jax.tree_util as jtu -from equinox.internal import ω +from equinox.internal import scan_trick, ω from jaxtyping import ArrayLike, PyTree from .._custom_types import ( @@ -193,7 +193,7 @@ def _compute_step( levy: AbstractSpaceTimeTimeLevyArea, x0: UnderdampedLangevinX, v0: UnderdampedLangevinX, - uld_args: UnderdampedLangevinArgs, + underdamped_langevin_args: UnderdampedLangevinArgs, coeffs: _QUICSORTCoeffs, rho: UnderdampedLangevinX, prev_f: Optional[UnderdampedLangevinX], @@ -204,7 +204,7 @@ def _compute_step( hh: UnderdampedLangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) kk: UnderdampedLangevinX = jtu.tree_map(jnp.asarray, levy.K, dtypes) - gamma, u, f = uld_args + gamma, u, f = underdamped_langevin_args def _extract_coeffs(coeff, index): return jtu.tree_map(lambda arr: arr[..., index], coeff) @@ -226,12 +226,24 @@ def _extract_coeffs(coeff, index): v_tilde = (v0**ω + rho**ω * (hh**ω + 6 * kk**ω)).ω x1 = (x0**ω + a_l**ω * v_tilde**ω + b_l**ω * rho_w_k**ω).ω - f1uh = (f(x1) ** ω * uh**ω).ω - x2 = ( - x0**ω + a_r**ω * v_tilde**ω + b_r**ω * rho_w_k**ω - a_third**ω * f1uh**ω - ).ω - f2uh = (f(x2) ** ω * uh**ω).ω + # Use eqinox.internal.scan_trick to compute f1, x2 and f2 in one go + # carry = x, f1, f2. We use x0 as the initial value for f1 and f2 + init = x1, x0, x0 + + def fn(carry): + x, _f, _ = carry + fx_uh = (f(x) ** ω * uh**ω).ω + return x, _f, fx_uh + + def compute_x2(carry): + _, _, f1 = carry + x = ( + x0**ω + a_r**ω * v_tilde**ω + b_r**ω * rho_w_k**ω - a_third**ω * f1**ω + ).ω + return x, f1, f1 + + x2, f1uh, f2uh = scan_trick(fn, [compute_x2], init) x_out = ( x0**ω diff --git a/diffrax/_solver/should.py b/diffrax/_solver/should.py index 9955baf6..6d8b0cb0 100644 --- a/diffrax/_solver/should.py +++ b/diffrax/_solver/should.py @@ -1,7 +1,7 @@ import equinox as eqx import jax.numpy as jnp import jax.tree_util as jtu -from equinox.internal import ω +from equinox.internal import scan_trick, ω from jaxtyping import ArrayLike, PyTree from .._custom_types import ( @@ -193,7 +193,7 @@ def _compute_step( levy: AbstractSpaceTimeTimeLevyArea, x0: UnderdampedLangevinX, v0: UnderdampedLangevinX, - uld_args: UnderdampedLangevinArgs, + underdamped_langevin_args: UnderdampedLangevinArgs, coeffs: _ShOULDCoeffs, rho: UnderdampedLangevinX, prev_f: UnderdampedLangevinX, @@ -203,7 +203,9 @@ def _compute_step( hh: UnderdampedLangevinX = jtu.tree_map(jnp.asarray, levy.H, dtypes) kk: UnderdampedLangevinX = jtu.tree_map(jnp.asarray, levy.K, dtypes) - gamma, u, f = uld_args + chh_hh_plus_ckk_kk = (coeffs.chh**ω * hh**ω + coeffs.ckk**ω * kk**ω).ω + + gamma, u, f = underdamped_langevin_args rho_w_k = (rho**ω * (w**ω - 12 * kk**ω)).ω uh = (u**ω * h).ω @@ -215,17 +217,28 @@ def _compute_step( + coeffs.a_half**ω * v1**ω + coeffs.b_half**ω * (-(uh**ω) * f0**ω + rho_w_k**ω) ).ω - f1 = f(x1) - chh_hh_plus_ckk_kk = (coeffs.chh**ω * hh**ω + coeffs.ckk**ω * kk**ω).ω + # Use equinox.internal.scan_trick to compute f1, x_out and f_out in one go + # carry = x, f1, f2. We use x0 as the initial value for f1 and f2 + init = x1, x0, x0 + + def fn(carry): + x, _f, _ = carry + fx = f(x) + return x, _f, fx + + def compute_x2(carry): + _, _, _f1 = carry + x = ( + x0**ω + + coeffs.a1**ω * v0**ω + - uh**ω * coeffs.b1**ω * (1 / 3 * f0**ω + 2 / 3 * _f1**ω) + + rho**ω * (coeffs.b1**ω * w**ω + chh_hh_plus_ckk_kk**ω) + ).ω + return x, _f1, _f1 + + x_out, f1, f_out = scan_trick(fn, [compute_x2], init) - x_out = ( - x0**ω - + coeffs.a1**ω * v0**ω - - uh**ω * coeffs.b1**ω * (1 / 3 * f0**ω + 2 / 3 * f1**ω) - + rho**ω * (coeffs.b1**ω * w**ω + chh_hh_plus_ckk_kk**ω) - ).ω - f_out = f(x_out) v_out = ( coeffs.beta1**ω * v0**ω - uh**ω diff --git a/examples/underdamped_langevin_example.ipynb b/examples/underdamped_langevin_example.ipynb index a70faff3..c0d50f6c 100644 --- a/examples/underdamped_langevin_example.ipynb +++ b/examples/underdamped_langevin_example.ipynb @@ -41,8 +41,8 @@ "id": "9deba250066ddc39", "metadata": { "ExecuteTime": { - "end_time": "2024-08-21T21:09:04.966129Z", - "start_time": "2024-08-21T21:09:01.522578Z" + "end_time": "2024-09-01T16:00:14.560735Z", + "start_time": "2024-09-01T16:00:10.980708Z" } }, "source": [ @@ -89,22 +89,22 @@ "id": "62da2ddbaaf98f47", "metadata": { "ExecuteTime": { - "end_time": "2024-08-21T21:09:08.676505Z", - "start_time": "2024-08-21T21:09:08.520037Z" + "end_time": "2024-09-01T16:00:14.739907Z", + "start_time": "2024-09-01T16:00:14.571929Z" } }, "source": [ "# Plot the trajectory against time and velocity against time in a separate plot\n", "fig, axs = plt.subplots(2, 1, figsize=(10, 10))\n", "axs[0].plot(sol.ts, xs[:, 0], label=\"x1\")\n", - "axs[0].plot(sol.ts, xs[:, 1], label=\"x4\")\n", + "axs[0].plot(sol.ts, xs[:, 1], label=\"x2\")\n", "axs[0].set_xlabel(\"Time\")\n", "axs[0].set_ylabel(\"Position\")\n", "axs[0].legend()\n", "axs[0].grid()\n", "\n", "axs[1].plot(sol.ts, vs[:, 0], label=\"v1\")\n", - "axs[1].plot(sol.ts, vs[:, 1], label=\"v3\")\n", + "axs[1].plot(sol.ts, vs[:, 1], label=\"v2\")\n", "axs[1].set_xlabel(\"Time\")\n", "axs[1].set_ylabel(\"Velocity\")\n", "axs[1].legend()\n", @@ -118,7 +118,7 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" diff --git a/test/test_underdamped_langevin.py b/test/test_underdamped_langevin.py index 7c318cb9..7090b965 100644 --- a/test/test_underdamped_langevin.py +++ b/test/test_underdamped_langevin.py @@ -34,16 +34,7 @@ def _solvers_and_orders(): def get_pytree_uld(t0=0.3, t1=1.0, dtype=jnp.float32): def make_pytree(array_factory): return { - "rr": ( - array_factory((1, 3, 2), dtype), - array_factory( - ( - 3, - 2, - ), - dtype, - ), - ), + "rr": (array_factory((1, 3, 2), dtype), array_factory((3, 2), dtype)), "qq": ( array_factory((1, 2), dtype), array_factory((3,), dtype), From dff726b774357d1e0e1bd064831f2c1cc2ff2cba Mon Sep 17 00:00:00 2001 From: andyElking Date: Sun, 1 Sep 2024 18:08:55 +0100 Subject: [PATCH 14/15] using RuntimeError for when ULD args have wrong structure --- diffrax/_solver/foster_langevin_srk.py | 12 +++++-- diffrax/_term.py | 43 ++++++-------------------- 2 files changed, 19 insertions(+), 36 deletions(-) diff --git a/diffrax/_solver/foster_langevin_srk.py b/diffrax/_solver/foster_langevin_srk.py index 24627fdb..82e6538f 100644 --- a/diffrax/_solver/foster_langevin_srk.py +++ b/diffrax/_solver/foster_langevin_srk.py @@ -26,7 +26,6 @@ UnderdampedLangevinDiffusionTerm, UnderdampedLangevinDriftTerm, UnderdampedLangevinLeaf, - UnderdampedLangevinStructureError, UnderdampedLangevinTuple, UnderdampedLangevinX, WrapTerm, @@ -290,13 +289,20 @@ def compare_args_fun(arg1, arg2): try: grad_f_shape = jax.eval_shape(grad_f, x0) except ValueError: - raise UnderdampedLangevinStructureError("grad_f") + raise RuntimeError( + "The function `grad_f` in the Underdamped Langevin term must be" + " a callable, whose input and output have the same PyTree structure" + " and shapes as the position `x`." + ) def shape_check_fun(_x, _g, _u, _fx): return _x.shape == _g.shape == _u.shape == _fx.shape if not jtu.tree_all(jtu.tree_map(shape_check_fun, x0, gamma, u, grad_f_shape)): - raise UnderdampedLangevinStructureError(None) + raise RuntimeError( + "The shapes and PyTree structures of x0, gamma, u, and grad_f(x0)" + " must match." + ) tay_coeffs = jtu.tree_map(self._tay_coeffs_single, gamma) # tay_coeffs have the same tree structure as gamma, with each leaf being a diff --git a/diffrax/_term.py b/diffrax/_term.py index 6be83043..5457df20 100644 --- a/diffrax/_term.py +++ b/diffrax/_term.py @@ -798,37 +798,6 @@ def _to_vjp(_y, _diff_args, _diff_term): UnderdampedLangevinTuple = tuple[UnderdampedLangevinX, UnderdampedLangevinX] -class UnderdampedLangevinStructureError(Exception): - """Raised when the structure of the arguments in the Underdamped Langevin - terms is incorrect.""" - - # Without this, the ValueError would be caught in _integrate._term_compatible, - # which would then give a less informative error message. - def __init__(self, problematic_arg: Optional[str]): - if problematic_arg is None: - msg = ( - "If `x` is the position of the Underdamped Langevin diffusion," - " then the PyTree structures and shapes of `grad_f(x)` and of " - "the arguments `gamma` and `u` must be the same as the structure" - " and shapes of x." - ) - elif problematic_arg == "grad_f": - msg = ( - "The function `grad_f` in the Underdamped Langevin term must be" - " a callable, whose input and output have the same PyTree structure" - " and shapes as the position `x`." - ) - else: - msg = ( - f"If `x` is the position of the Underdamped Langevin diffusion," - f" then the PyTree structure and shapes of the argument" - f" `{problematic_arg}` must be the same as the structure and" - f" shapes of x." - ) - - super().__init__(msg) - - def _broadcast_pytree(source, target_tree): # Broadcasts the source PyTree to the shape and PyTree structure of # target_tree_shape. Requires that source is a prefix tree of target_tree @@ -853,7 +822,11 @@ def broadcast_underdamped_langevin_arg( try: return _broadcast_pytree(arg, x) except ValueError: - raise UnderdampedLangevinStructureError(arg_name) + raise RuntimeError( + "The PyTree structure and shapes of the arguments `gamma` and `u`" + "in the Underdamped Langevin term must be the same as the structure" + "and shapes of the position `x`." + ) class UnderdampedLangevinDiffusionTerm( @@ -992,7 +965,11 @@ def fun(_gamma, _u, _v, _f_x): f_x = self.grad_f(x) vf_v = jtu.tree_map(fun, gamma, u, v, f_x) except ValueError: - raise UnderdampedLangevinStructureError("grad_f") + raise RuntimeError( + "The function `grad_f` in the Underdamped Langevin term must be" + " a callable, whose input and output have the same PyTree structure" + " and shapes as the position `x`." + ) vf_y = (vf_x, vf_v) return vf_y From be892ae42e9f97d98fd1dc25d2979902916a7a85 Mon Sep 17 00:00:00 2001 From: andyElking Date: Sun, 1 Sep 2024 18:25:30 +0100 Subject: [PATCH 15/15] small fixes --- diffrax/__init__.py | 1 - diffrax/_solver/foster_langevin_srk.py | 18 +++----- diffrax/_term.py | 45 ------------------- docs/api/terms.md | 7 +-- examples/underdamped_langevin_example.ipynb | 49 +++++++++++---------- test/helpers.py | 9 +++- test/test_underdamped_langevin.py | 5 ++- 7 files changed, 44 insertions(+), 90 deletions(-) diff --git a/diffrax/__init__.py b/diffrax/__init__.py index fca3f02b..1ee6ea3e 100644 --- a/diffrax/__init__.py +++ b/diffrax/__init__.py @@ -127,7 +127,6 @@ from ._term import ( AbstractTerm as AbstractTerm, ControlTerm as ControlTerm, - make_underdamped_langevin_term as make_underdamped_langevin_term, MultiTerm as MultiTerm, ODETerm as ODETerm, UnderdampedLangevinDiffusionTerm as UnderdampedLangevinDiffusionTerm, diff --git a/diffrax/_solver/foster_langevin_srk.py b/diffrax/_solver/foster_langevin_srk.py index 82e6538f..dbdf3939 100644 --- a/diffrax/_solver/foster_langevin_srk.py +++ b/diffrax/_solver/foster_langevin_srk.py @@ -412,23 +412,17 @@ def step( h, levy, x0, v0, (gamma, u, grad_f), coeffs, rho, prev_f ) - def check_shapes_dtypes(_x, _v, _f, _x0): - assert _x.dtype == _v.dtype == _f.dtype == _x0.dtype, ( - f"dtypes don't match. x0: {x0.dtype}," - f" v_out: {_v.dtype}, x_out: {_x.dtype}, f_fsal: {_f.dtype}" - ) - assert _x.shape == _v.shape == _f.shape == _x0.shape, ( - f"Shapes don't match. x0: {x0.shape}," - f" v_out: {_v.shape}, x_out: {_x.shape}, f_fsal: {_f.shape}" - ) + def check_shapes_dtypes(arg, *args): + for x in args: + assert x.shape == arg.shape + assert x.dtype == arg.dtype # Some children classes may not use f_fsal, so we allow it to be None if self._is_fsal: - _f_fsal = f_fsal + jtu.tree_map(check_shapes_dtypes, x_out, v_out, f_fsal, x0) else: assert f_fsal is None - _f_fsal = x0 - jtu.tree_map(check_shapes_dtypes, x_out, v_out, _f_fsal, x0) + jtu.tree_map(check_shapes_dtypes, x_out, v_out, x0) y1 = (x_out, v_out) diff --git a/diffrax/_term.py b/diffrax/_term.py index 5457df20..583ed592 100644 --- a/diffrax/_term.py +++ b/diffrax/_term.py @@ -980,48 +980,3 @@ def prod( self, vf: UnderdampedLangevinTuple, control: RealScalarLike ) -> UnderdampedLangevinTuple: return jtu.tree_map(lambda _vf: control * _vf, vf) - - -def make_underdamped_langevin_term( - gamma: PyTree[ArrayLike], - u: PyTree[ArrayLike], - grad_f: Callable[[UnderdampedLangevinX], UnderdampedLangevinX], - bm: AbstractBrownianPath, -) -> MultiTerm[tuple[UnderdampedLangevinDriftTerm, UnderdampedLangevinDiffusionTerm]]: - r"""Creates a term that represents the Underdamped Langevin Diffusion, given by: - - \begin{align*} - \mathrm{d} x(t) &= v(t) \, \mathrm{d}t \\ - \mathrm{d} v(t) &= - \gamma \, v(t) \, \mathrm{d}t - u \, - \nabla \! f( x(t) ) \, \mathrm{d}t + \sqrt{2 \gamma u} \, \mathrm{d} w(t), - \end{align*} - - where $x(t), v(t) \in \mathbb{R}^d$ represent the position - and velocity, $w$ is a Brownian motion in $\mathbb{R}^d$, - $f: \mathbb{R}^d \rightarrow \mathbb{R}$ is a potential function, and - $\gamma , u \in \mathbb{R}^{d \times d}$ are diagonal matrices governing - the friction and the damping of the system. - - **Arguments:** - - - `gamma`: A vector containing the diagonal entries of the friction matrix; - a scalar or a PyTree of the same shape as the position vector $x$. - - `u`: A vector containing the diagonal entries of the damping matrix; - a scalar or a PyTree of the same shape as the position vector $x$. - - `grad_f`: A callable representing the gradient of the potential function $f$. - This callable should take a PyTree of the same shape as $x$ and - return a PyTree of the same shape. - - `bm`: A Brownian path representing the Brownian motion $w$. - - **Returns:** - - `MultiTerm(UnderdampedLangevinDriftTerm(gamma, u, grad_f), - UnderdampedLangevinDiffusionTerm(gamma, u, bm))` - """ - # In practice we don't require the PyTree structure of gamma and u to be the same - # as x and v. We only require that they are prefixes of x and v, in a way that - # allows us to call _broadcast_pytree(gamma, x) and _broadcast_pytree(u, x). - - drift = UnderdampedLangevinDriftTerm(gamma, u, grad_f) - diffusion = UnderdampedLangevinDiffusionTerm(gamma, u, bm) - return MultiTerm(drift, diffusion) diff --git a/docs/api/terms.md b/docs/api/terms.md index aff1f5a3..0c72f9f6 100644 --- a/docs/api/terms.md +++ b/docs/api/terms.md @@ -115,8 +115,7 @@ the friction and the damping of the system. These terms enable the use of ULD-specific solvers which can be found [here](./solvers/sde_solvers.md#underdamped-langevin-solvers). Note that these ULD solvers will only work if given terms with structure `MultiTerm(UnderdampedLangevinDriftTerm(gamma, u, grad_f), UnderdampedLangevinDiffusionTerm(gamma, u, bm))`, -where `bm` is an [`diffrax.AbstractBrownianPath`][] and the same values of `gammma` and `u` are passed to both terms. It is recommended to -use the helper function [`diffrax.make_underdamped_langevin_term`][], which will ensure that the terms are structured correctly. +where `bm` is an [`diffrax.AbstractBrownianPath`][] and the same values of `gammma` and `u` are passed to both terms. ::: diffrax.UnderdampedLangevinDriftTerm selection: @@ -126,6 +125,4 @@ use the helper function [`diffrax.make_underdamped_langevin_term`][], which will ::: diffrax.UnderdampedLangevinDiffusionTerm selection: members: - - __init__ - -::: diffrax.make_underdamped_langevin_term \ No newline at end of file + - __init__ \ No newline at end of file diff --git a/examples/underdamped_langevin_example.ipynb b/examples/underdamped_langevin_example.ipynb index c0d50f6c..61309563 100644 --- a/examples/underdamped_langevin_example.ipynb +++ b/examples/underdamped_langevin_example.ipynb @@ -29,7 +29,7 @@ "\n", "In addition to generic SDE solvers (which can solve any SDE including ULD), Diffrax has some solvers designed specifically for ULD. These are `diffrax.ALIGN` which has a 2nd order of strong convergence, and `diffrax.QUICSORT` and `diffrax.ShOULD` which are 3rd order solvers. Note that unlike ODE solvers which can have orders of 5 or even higher, very few types of SDEs permit solvers with a strong order greater than $\\frac{1}{2}$.\n", "\n", - "These ULD-specific solvers only accept terms retuned by `diffrax.make_underdamped_langevin_term`.\n", + "These ULD-specific solvers only accept terms of the form `MultiTerm(UnderdampedLangevinDriftTerm(gamma, u, grad_f), UnderdampedLangevinDiffusionTerm(gamma, u, bm))`.\n", "\n", "## A 2D harmonic oscillator\n", "\n", @@ -38,13 +38,15 @@ }, { "cell_type": "code", + "execution_count": 3, "id": "9deba250066ddc39", "metadata": { "ExecuteTime": { - "end_time": "2024-09-01T16:00:14.560735Z", - "start_time": "2024-09-01T16:00:10.980708Z" + "end_time": "2024-09-01T17:24:08.608664Z", + "start_time": "2024-09-01T17:24:06.215228Z" } }, + "outputs": [], "source": [ "from warnings import simplefilter\n", "\n", @@ -72,27 +74,39 @@ " t0, t1, tol=0.01, shape=(2,), key=jr.key(0), levy_area=diffrax.SpaceTimeTimeLevyArea\n", ")\n", "\n", - "# Use the make_underdamped_langevin_term function to create the terms\n", - "terms = diffrax.make_underdamped_langevin_term(gamma, u, lambda x: 2 * x, bm)\n", + "drift_term = diffrax.UnderdampedLangevinDriftTerm(gamma, u, lambda x: 2 * x)\n", + "diffusion_term = diffrax.UnderdampedLangevinDiffusionTerm(gamma, u, bm)\n", + "terms = diffrax.MultiTerm(drift_term, diffusion_term)\n", "\n", "solver = diffrax.QUICSORT(100.0)\n", "sol = diffrax.diffeqsolve(\n", " terms, solver, t0, t1, dt0=dt0, y0=y0, args=None, saveat=saveat\n", ")\n", "xs, vs = sol.ys" - ], - "outputs": [], - "execution_count": 1 + ] }, { "cell_type": "code", + "execution_count": 2, "id": "62da2ddbaaf98f47", "metadata": { "ExecuteTime": { - "end_time": "2024-09-01T16:00:14.739907Z", - "start_time": "2024-09-01T16:00:14.571929Z" + "end_time": "2024-09-01T17:23:09.939787Z", + "start_time": "2024-09-01T17:23:09.786782Z" } }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot the trajectory against time and velocity against time in a separate plot\n", "fig, axs = plt.subplots(2, 1, figsize=(10, 10))\n", @@ -111,20 +125,7 @@ "axs[1].grid()\n", "\n", "plt.show()" - ], - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 2 + ] } ], "metadata": { diff --git a/test/helpers.py b/test/helpers.py index 8b3b2811..ec6cbc3e 100644 --- a/test/helpers.py +++ b/test/helpers.py @@ -12,9 +12,10 @@ AbstractBrownianPath, AbstractTerm, ControlTerm, - make_underdamped_langevin_term, MultiTerm, ODETerm, + UnderdampedLangevinDiffusionTerm, + UnderdampedLangevinDriftTerm, VirtualBrownianTree, ) from diffrax._misc import is_tuple_of_ints @@ -492,6 +493,12 @@ def get_terms(bm): return SDE(get_terms, args, y0, t0, t1, (noise_dim,)) +def make_underdamped_langevin_term(gamma, u, grad_f, bm): + drift = UnderdampedLangevinDriftTerm(gamma, u, grad_f) + diffusion = UnderdampedLangevinDiffusionTerm(gamma, u, bm) + return MultiTerm(drift, diffusion) + + def get_bqp(t0=0.3, t1=15.0, dtype=jnp.float32): grad_f_bqp = lambda x: 4 * x * (jnp.square(x) - 1) gamma, u = dtype(0.8), dtype(0.2) diff --git a/test/test_underdamped_langevin.py b/test/test_underdamped_langevin.py index 7090b965..e945cad5 100644 --- a/test/test_underdamped_langevin.py +++ b/test/test_underdamped_langevin.py @@ -4,11 +4,12 @@ import jax.random as jr import jax.tree_util as jtu import pytest -from diffrax import diffeqsolve, make_underdamped_langevin_term, SaveAt +from diffrax import diffeqsolve, SaveAt from .helpers import ( get_bqp, get_harmonic_oscillator, + make_underdamped_langevin_term, path_l2_dist, SDE, simple_batch_sde_solve, @@ -217,7 +218,7 @@ def test_reverse_solve(solver_cls): key=jr.key(0), levy_area=diffrax.SpaceTimeTimeLevyArea, ) - terms = diffrax.make_underdamped_langevin_term(gamma, u, lambda x: 2 * x, bm) + terms = make_underdamped_langevin_term(gamma, u, lambda x: 2 * x, bm) solver = solver_cls(0.01) sol = diffeqsolve(terms, solver, t0, t1, dt0=dt0, y0=y0, args=None, saveat=saveat)