From 22a685331949303e2d4e163a19baa368efe39135 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andra=C5=BE=20Jelin=C4=8Di=C4=8D?= <66168650+andyElking@users.noreply.github.com> Date: Sun, 1 Sep 2024 21:29:31 +0200 Subject: [PATCH 01/14] Langevin PR (#453) * Langevin PR * Minor fixes * removed the SORT solver (superseded by QUICSORT) * made LangevinTerm.term a static field * temporary fix for _term_compatible and LangevinTerm * Fixed LangevinTerm YAAAYYYYY * Nits * Added Langevin docs, a Langevin example and backwards in time test * Fixed Patrick's comments * langevin -> underdamped_langevin * round of small fixes * check langevin drift term and diffusion term have same args * added scan_trick in QUICSORT and ShOULD * using RuntimeError for when ULD args have wrong structure * small fixes --- diffrax/__init__.py | 6 + diffrax/_solver/__init__.py | 4 + diffrax/_solver/align.py | 188 ++++++++ diffrax/_solver/euler_heun.py | 12 +- diffrax/_solver/foster_langevin_srk.py | 448 ++++++++++++++++++++ diffrax/_solver/milstein.py | 22 +- diffrax/_solver/quicsort.py | 263 ++++++++++++ diffrax/_solver/should.py | 253 +++++++++++ diffrax/_solver/srk.py | 30 +- diffrax/_term.py | 210 ++++++++- docs/api/solvers/abstract_solvers.md | 6 +- docs/api/solvers/sde_solvers.md | 40 ++ docs/api/terms.md | 35 ++ docs/devdocs/srk_example.ipynb | 126 ++++-- docs/usage/how-to-choose-a-solver.md | 5 + examples/underdamped_langevin_example.ipynb | 152 +++++++ mkdocs.yml | 1 + test/helpers.py | 190 +++++++-- test/test_integrate.py | 2 + test/test_sde.py | 14 +- test/test_underdamped_langevin.py | 273 ++++++++++++ 21 files changed, 2175 insertions(+), 105 deletions(-) create mode 100644 diffrax/_solver/align.py create mode 100644 diffrax/_solver/foster_langevin_srk.py create mode 100644 diffrax/_solver/quicsort.py create mode 100644 diffrax/_solver/should.py create mode 100644 examples/underdamped_langevin_example.ipynb create mode 100644 test/test_underdamped_langevin.py diff --git a/diffrax/__init__.py b/diffrax/__init__.py index 67b4ca50..1ee6ea3e 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, @@ -79,6 +80,7 @@ AbstractSRK as AbstractSRK, AbstractStratonovichSolver as AbstractStratonovichSolver, AbstractWrappedSolver as AbstractWrappedSolver, + ALIGN as ALIGN, Bosh3 as Bosh3, ButcherTableau as ButcherTableau, CalculateJacobian as CalculateJacobian, @@ -100,11 +102,13 @@ LeapfrogMidpoint as LeapfrogMidpoint, Midpoint as Midpoint, MultiButcherTableau as MultiButcherTableau, + QUICSORT as QUICSORT, Ralston as Ralston, ReversibleHeun as ReversibleHeun, SEA as SEA, SemiImplicitEuler as SemiImplicitEuler, ShARK as ShARK, + ShOULD as ShOULD, Sil3 as Sil3, SlowRK as SlowRK, SPaRK as SPaRK, @@ -125,6 +129,8 @@ ControlTerm as ControlTerm, 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 da6fe6c9..0a840413 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, @@ -12,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 @@ -26,6 +28,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 ( @@ -42,6 +45,7 @@ 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 .spark import SPaRK as SPaRK diff --git a/diffrax/_solver/align.py b/diffrax/_solver/align.py new file mode 100644 index 00000000..dd6bf9ed --- /dev/null +++ b/diffrax/_solver/align.py @@ -0,0 +1,188 @@ +import equinox as eqx +import jax.numpy as jnp +import jax.tree_util as jtu +from equinox.internal import ω +from jaxtyping import ArrayLike, PyTree + +from .._custom_types import ( + AbstractSpaceTimeLevyArea, + RealScalarLike, +) +from .._local_interpolation import LocalLinearInterpolation +from .._term import ( + UnderdampedLangevinLeaf, + UnderdampedLangevinTuple, + UnderdampedLangevinX, +) +from .foster_langevin_srk import ( + AbstractCoeffs, + AbstractFosterLangevinSRK, + UnderdampedLangevinArgs, +) + + +# For an explanation of the coefficients, see foster_langevin_srk.py +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) + + 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 = UnderdampedLangevinTuple + + +class ALIGN(AbstractFosterLangevinSRK[_ALIGNCoeffs, _ErrorEstimate]): + r"""The Adaptive Langevin via Interpolated Gradients and Noise method + 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 + minimal_levy_area = AbstractSpaceTimeLevyArea + taylor_threshold: RealScalarLike = eqx.field(static=True) + _is_fsal = True + + 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 2 + + def strong_order(self, terms): + return 2.0 + + def _directly_compute_coeffs_leaf( + self, h: RealScalarLike, c: UnderdampedLangevinLeaf + ) -> _ALIGNCoeffs: + del self + # 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) + + return _ALIGNCoeffs( + beta=beta, + a1=a1, + b1=b1, + aa=aa, + chh=chh, + ) + + def _tay_coeffs_single(self, c: UnderdampedLangevinLeaf) -> _ALIGNCoeffs: + 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 + + # 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 = jnp.shape(c) + (6,) + assert ( + beta.shape == a1.shape == b1.shape == aa.shape == chh.shape == correct_shape + ) + + return _ALIGNCoeffs( + beta=beta, + a1=a1, + b1=b1, + aa=aa, + chh=chh, + ) + + def _compute_step( + self, + h: RealScalarLike, + levy: AbstractSpaceTimeLevyArea, + x0: UnderdampedLangevinX, + v0: UnderdampedLangevinX, + underdamped_langevin_args: UnderdampedLangevinArgs, + coeffs: _ALIGNCoeffs, + rho: UnderdampedLangevinX, + prev_f: UnderdampedLangevinX, + ) -> tuple[ + UnderdampedLangevinX, + UnderdampedLangevinX, + UnderdampedLangevinX, + UnderdampedLangevinTuple, + ]: + 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) + + gamma, u, f = underdamped_langevin_args + + uh = (u**ω * h).ω + f0 = prev_f + x1 = ( + x0**ω + + coeffs.a1**ω * v0**ω + - coeffs.b1**ω * uh**ω * f0**ω + + rho**ω * (coeffs.b1**ω * w**ω + coeffs.chh**ω * hh**ω) + ).ω + f1 = f(x1) + v1 = ( + coeffs.beta**ω * v0**ω + - u**ω * ((coeffs.a1**ω - coeffs.b1**ω) * f0**ω + coeffs.b1**ω * f1**ω) + + rho**ω * (coeffs.aa**ω * w**ω - gamma**ω * coeffs.chh**ω * hh**ω) + ).ω + + error_estimate = ( + jtu.tree_map(jnp.zeros_like, x0), + (-(u**ω) * coeffs.b1**ω * (f1**ω - f0**ω)).ω, + ) + + return x1, v1, f1, error_estimate 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/foster_langevin_srk.py b/diffrax/_solver/foster_langevin_srk.py new file mode 100644 index 00000000..dbdf3939 --- /dev/null +++ b/diffrax/_solver/foster_langevin_srk.py @@ -0,0 +1,448 @@ +import abc +from collections.abc import Callable +from typing import Any, Generic, Optional, TypeVar + +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 jaxtyping import PyTree + +from .._custom_types import ( + AbstractBrownianIncrement, + BoolScalarLike, + DenseInfo, + RealScalarLike, +) +from .._local_interpolation import LocalLinearInterpolation +from .._solution import RESULTS +from .._term import ( + AbstractTerm, + broadcast_underdamped_langevin_arg, + MultiTerm, + UnderdampedLangevinDiffusionTerm, + UnderdampedLangevinDriftTerm, + UnderdampedLangevinLeaf, + UnderdampedLangevinTuple, + UnderdampedLangevinX, + WrapTerm, +) +from .base import AbstractStratonovichSolver + + +_ErrorEstimate = TypeVar("_ErrorEstimate", None, UnderdampedLangevinTuple) +UnderdampedLangevinArgs = tuple[ + UnderdampedLangevinX, + UnderdampedLangevinX, + Callable[[UnderdampedLangevinX], UnderdampedLangevinX], +] + + +def _get_args_from_terms( + terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], +) -> tuple[ + PyTree, + PyTree, + 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, UnderdampedLangevinDriftTerm) + assert isinstance(diffusion, UnderdampedLangevinDiffusionTerm) + gamma_drift = drift.gamma + u_drift = drift.u + f = drift.grad_f + gamma_diffusion = diffusion.gamma + u_diffusion = diffusion.u + return gamma_drift, u_drift, gamma_diffusion, u_diffusion, f + + +# 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 AbstractCoeffs(eqx.Module): + dtype: AbstractVar[jnp.dtype] + + +_Coeffs = TypeVar("_Coeffs", bound=AbstractCoeffs) + + +class SolverState(eqx.Module, Generic[_Coeffs]): + gamma: UnderdampedLangevinX + u: UnderdampedLangevinX + h: RealScalarLike + taylor_coeffs: PyTree[_Coeffs, "UnderdampedLangevinX"] + coeffs: _Coeffs + rho: UnderdampedLangevinX + prev_f: Optional[UnderdampedLangevinX] + + +class AbstractFosterLangevinSRK( + AbstractStratonovichSolver[SolverState], + Generic[_Coeffs, _ErrorEstimate], +): + r"""Abstract class for Stochastic Runge Kutta methods specifically designed + for Underdamped Langevin Diffusion of 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. + + Solvers which inherit from this class include [`diffrax.ALIGN`][], + [`diffrax.ShOULD`][], and [`diffrax.QUICSORT`][]. + """ + + term_structure = MultiTerm[ + tuple[UnderdampedLangevinDriftTerm, UnderdampedLangevinDiffusionTerm] + ] + 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( + 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 + 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: 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 + the PyTree of gamma to compute the coefficients for the entire system. + + **Arguments:** + + - `c`: A leaf of gamma. + + **Returns:** + + The Taylor coefficients for the given leaf of gamma. + """ + raise NotImplementedError + + @staticmethod + 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: 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: 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. + 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(): + direct_out = self._directly_compute_coeffs_leaf(h, 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 + out = lax.cond( + eqxi.unvmap_all(cond), + lambda: tay_out, + select_tay_or_direct, + ) + + # 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)}" + + return out + + 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) # pyright: ignore + return coeffs_with_tree + + def init( + self, + terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], + t0: RealScalarLike, + t1: RealScalarLike, + y0: UnderdampedLangevinTuple, + args: PyTree, + ) -> SolverState: + """Precompute _SolverState which carries the Taylor coefficients and the + 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. + """ + drift, diffusion = 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_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 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 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 + # _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) + 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, + u=u, + h=h, + taylor_coeffs=tay_coeffs, + coeffs=coeffs, + rho=rho, + prev_f=prev_f, + ) + + return state_out + + @abc.abstractmethod + def _compute_step( + self, + h: RealScalarLike, + levy, + x0: UnderdampedLangevinX, + v0: UnderdampedLangevinX, + underdamped_langevin_args: UnderdampedLangevinArgs, + coeffs: _Coeffs, + rho: UnderdampedLangevinX, + prev_f: Optional[UnderdampedLangevinX], + ) -> tuple[ + UnderdampedLangevinX, + UnderdampedLangevinX, + Optional[UnderdampedLangevinX], + _ErrorEstimate, + ]: + 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( + self, + terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], + t0: RealScalarLike, + t1: RealScalarLike, + y0: UnderdampedLangevinTuple, + args: PyTree, + solver_state: SolverState, + made_jump: BoolScalarLike, + ) -> tuple[ + UnderdampedLangevinTuple, _ErrorEstimate, DenseInfo, SolverState, RESULTS + ]: + del args + st = solver_state + drift, diffusion = terms.terms + + h = drift.contr(t0, t1) + h_prev = st.h + tay: PyTree[_Coeffs] = st.taylor_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 + # 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( + eqxi.unvmap_all(cond), + lambda: old_coeffs, + lambda: self._recompute_coeffs(h, gamma, tay), + ) + + # compute the Brownian increment and space-time(-time) Levy area + levy = diffusion.contr(t0, t1, use_levy=True) + 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 + 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( + h, levy, x0, v0, (gamma, u, grad_f), coeffs, rho, prev_f + ) + + 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: + jtu.tree_map(check_shapes_dtypes, x_out, v_out, f_fsal, x0) + else: + assert f_fsal is None + jtu.tree_map(check_shapes_dtypes, x_out, v_out, x0) + + y1 = (x_out, v_out) + + dense_info = dict(y0=y0, y1=y1) + st = SolverState( + gamma=gamma, + u=u, + h=h, + taylor_coeffs=tay, + coeffs=coeffs, + rho=st.rho, + prev_f=f_fsal, + ) + return y1, error, dense_info, st, RESULTS.successful + + def func( + self, + terms: MultiTerm[tuple[AbstractTerm[Any, RealScalarLike], AbstractTerm]], + t0: RealScalarLike, + y0: UnderdampedLangevinTuple, + args: PyTree, + ): + return terms.vf(t0, y0, args) diff --git a/diffrax/_solver/milstein.py b/diffrax/_solver/milstein.py index 80d3b0f1..ce59d83b 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 new file mode 100644 index 00000000..2e6ca897 --- /dev/null +++ b/diffrax/_solver/quicsort.py @@ -0,0 +1,263 @@ +import math +from typing import Optional + +import equinox as eqx +import jax +import jax.numpy as jnp +import jax.tree_util as jtu +from equinox.internal import scan_trick, ω +from jaxtyping import ArrayLike, PyTree + +from .._custom_types import ( + AbstractSpaceTimeTimeLevyArea, + RealScalarLike, +) +from .._local_interpolation import LocalLinearInterpolation +from .._term import UnderdampedLangevinLeaf, UnderdampedLangevinX +from .foster_langevin_srk import ( + AbstractCoeffs, + AbstractFosterLangevinSRK, + UnderdampedLangevinArgs, +) + + +# 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): + 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): + 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) + + +class QUICSORT(AbstractFosterLangevinSRK[_QUICSORTCoeffs, None]): + r"""The QUadrature Inspired and Contractive Shifted ODE with Runge-Kutta Three + 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}, + 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}, + } + ``` + """ + + 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:** + + - `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: RealScalarLike, c: UnderdampedLangevinLeaf + ) -> _QUICSORTCoeffs: + del self + # compute the coefficients directly (as opposed to via Taylor expansion) + 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) + 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,) + + return _QUICSORTCoeffs( + beta_lr1=beta_lr1, + a_lr1=a_lr1, + b_lr1=b_lr1, + a_third=a_third, + a_div_h=a_div_h, + ) + + def _tay_coeffs_single(self, c: UnderdampedLangevinLeaf) -> _QUICSORTCoeffs: + del self + # c is a leaf of gamma + dtype = jnp.result_type(c) + zero = jnp.zeros_like(c) + one = jnp.ones_like(c) + c2 = jnp.square(c) + c3 = c2 * c + 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(5, -1, step=-1, dtype=dtype), axis=0) + lr1_pows = jnp.power(lr1, exponents) + assert lr1_pows.shape == (3, 6) + + 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 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 == jnp.shape(c) + (3, 6) + + # a_third = (1 - exp(-1/3 * gamma * h))/gamma + a_third = jnp.stack( + [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( + [-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 == jnp.shape(c) + (1, 6) + + return _QUICSORTCoeffs( + beta_lr1=beta_lr1, + a_lr1=a_lr1, + b_lr1=b_lr1, + a_third=a_third, + a_div_h=a_div_h, + ) + + def _compute_step( + self, + h: RealScalarLike, + levy: AbstractSpaceTimeTimeLevyArea, + x0: UnderdampedLangevinX, + v0: UnderdampedLangevinX, + underdamped_langevin_args: UnderdampedLangevinArgs, + coeffs: _QUICSORTCoeffs, + rho: 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) + kk: UnderdampedLangevinX = jtu.tree_map(jnp.asarray, levy.K, dtypes) + + gamma, u, f = underdamped_langevin_args + + 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**ω + rho**ω * (hh**ω + 6 * kk**ω)).ω + + x1 = (x0**ω + a_l**ω * v_tilde**ω + b_l**ω * rho_w_k**ω).ω + + # 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**ω + + 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**ω - rho**ω * (hh**ω - 6 * kk**ω)).ω + + # TODO: compute error estimate + return x_out, v_out, None, None diff --git a/diffrax/_solver/should.py b/diffrax/_solver/should.py new file mode 100644 index 00000000..6d8b0cb0 --- /dev/null +++ b/diffrax/_solver/should.py @@ -0,0 +1,253 @@ +import equinox as eqx +import jax.numpy as jnp +import jax.tree_util as jtu +from equinox.internal import scan_trick, ω +from jaxtyping import ArrayLike, PyTree + +from .._custom_types import ( + AbstractSpaceTimeTimeLevyArea, + RealScalarLike, +) +from .._local_interpolation import LocalLinearInterpolation +from .._term import UnderdampedLangevinLeaf, UnderdampedLangevinX +from .foster_langevin_srk import ( + AbstractCoeffs, + AbstractFosterLangevinSRK, + UnderdampedLangevinArgs, +) + + +# For an explanation of the coefficients, see foster_langevin_srk.py +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(AbstractFosterLangevinSRK[_ShOULDCoeffs, None]): + r"""The Shifted-ODE Runge-Kutta Three method + 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 + minimal_levy_area = AbstractSpaceTimeTimeLevyArea + taylor_threshold: RealScalarLike = eqx.field(static=True) + _is_fsal = True + + 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: RealScalarLike, c: UnderdampedLangevinLeaf + ) -> _ShOULDCoeffs: + 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 + + 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) + + return _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, + ) + + def _tay_coeffs_single(self, c: UnderdampedLangevinLeaf) -> _ShOULDCoeffs: + 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 + + # 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( + [-c5 / 3840, c4 / 384, -c3 / 48, c2 / 8, -c / 2, one], axis=-1 + ) + beta1 = jnp.stack([-c5 / 120, c4 / 24, -c3 / 6, c2 / 2, -c, one], axis=-1) + a_half = jnp.stack( + [c4 / 3840, -c3 / 384, c2 / 48, -c / 8, one / 2, zero], axis=-1 + ) + 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( + [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 = jnp.shape(c) + (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 + ) + + return _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, + ) + + def _compute_step( + self, + h: RealScalarLike, + levy: AbstractSpaceTimeTimeLevyArea, + x0: UnderdampedLangevinX, + v0: UnderdampedLangevinX, + underdamped_langevin_args: UnderdampedLangevinArgs, + coeffs: _ShOULDCoeffs, + rho: UnderdampedLangevinX, + prev_f: UnderdampedLangevinX, + ) -> tuple[UnderdampedLangevinX, UnderdampedLangevinX, UnderdampedLangevinX, None]: + 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) + kk: UnderdampedLangevinX = jtu.tree_map(jnp.asarray, levy.K, dtypes) + + 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).ω + + f0 = prev_f + v1 = (v0**ω + rho**ω * (hh**ω + 6 * kk**ω)).ω + x1 = ( + x0**ω + + coeffs.a_half**ω * v1**ω + + coeffs.b_half**ω * (-(uh**ω) * f0**ω + rho_w_k**ω) + ).ω + + # 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) + + v_out = ( + coeffs.beta1**ω * v0**ω + - uh**ω + * ( + coeffs.beta1**ω / 6 * f0**ω + + 2 / 3 * coeffs.beta_half**ω * f1**ω + + 1 / 6 * f_out**ω + ) + + rho**ω * (coeffs.aa**ω * w**ω - gamma**ω * chh_hh_plus_ckk_kk**ω) + ).ω + + return x_out, v_out, f_out, None diff --git a/diffrax/_solver/srk.py b/diffrax/_solver/srk.py index 99d00913..fba6120d 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, @@ -647,7 +662,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 d43f951b..2c3a78ab 100644 --- a/diffrax/_term.py +++ b/diffrax/_term.py @@ -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,198 @@ 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 + + +# 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 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): + # 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 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): + 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) + + +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 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( + AbstractTerm[ + UnderdampedLangevinX, Union[UnderdampedLangevinX, AbstractBrownianIncrement] + ] +): + r"""Represents the diffusion term in the Underdamped Langevin Diffusion (ULD). + The ULD SDE 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. + """ + + 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_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) + + vf_v = jtu.tree_map(_fun, gamma, u) + return vf_v + + def contr( + self, t0: RealScalarLike, t1: RealScalarLike, **kwargs + ) -> Union[UnderdampedLangevinX, AbstractBrownianIncrement]: + return self.control.evaluate(t0, t1, **kwargs) + + 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 + v_out = jtu.tree_map(operator.mul, vf, dw) + x_out = jtu.tree_map(jnp.zeros_like, v_out) + return x_out, v_out + + +class UnderdampedLangevinDriftTerm(AbstractTerm): + r"""Represents the drift term in the Underdamped Langevin Diffusion (ULD). + The ULD SDE 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. + """ + + 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_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_x = v + try: + f_x = self.grad_f(x) + vf_v = jtu.tree_map(fun, gamma, u, v, f_x) + except ValueError: + 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 + + def contr(self, t0: RealScalarLike, t1: RealScalarLike, **kwargs) -> RealScalarLike: + return t1 - t0 + + def prod( + self, vf: UnderdampedLangevinTuple, control: RealScalarLike + ) -> UnderdampedLangevinTuple: + return jtu.tree_map(lambda _vf: control * _vf, vf) 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 ecc9fbf9..a1a87b74 100644 --- a/docs/api/solvers/sde_solvers.md +++ b/docs/api/solvers/sde_solvers.md @@ -113,3 +113,43 @@ 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 + +\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. + +They are more precise for this diffusion than the general-purpose solvers above, but +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 + selection: + members: + - __init__ + +::: diffrax.ShOULD + selection: + members: + - __init__ + +::: diffrax.QUICSORT + selection: + members: + - __init__ \ No newline at end of file diff --git a/docs/api/terms.md b/docs/api/terms.md index 553b3fbb..0c72f9f6 100644 --- a/docs/api/terms.md +++ b/docs/api/terms.md @@ -91,3 +91,38 @@ Some example term structures include: selection: 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. + +::: diffrax.UnderdampedLangevinDriftTerm + selection: + members: + - __init__ + +::: diffrax.UnderdampedLangevinDiffusionTerm + selection: + members: + - __init__ \ No newline at end of file diff --git a/docs/devdocs/srk_example.ipynb b/docs/devdocs/srk_example.ipynb index aa2a38cf..39364def 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", @@ -37,8 +38,8 @@ "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 }, @@ -59,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", @@ -76,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", @@ -137,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", @@ -150,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", @@ -163,13 +176,22 @@ " icoeff=0.3,\n", " rtol=2 ** -(level - 1),\n", " atol=2 ** -(level + 3),\n", - " step_ts=save_ts_pid,\n", " dtmin=2**-14,\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", @@ -194,20 +216,22 @@ }, { "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": [ { "data": { - "image/png": "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", - "text/plain": "
" + "image/png": "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", + "text/plain": [ + "
" + ] }, "metadata": {}, "output_type": "display_data" @@ -236,7 +260,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 +271,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 +279,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 +300,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", @@ -299,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 }, @@ -325,20 +349,22 @@ }, { "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": [ { "data": { - "image/png": "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", - "text/plain": "
" + "image/png": "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", + "text/plain": [ + "
" + ] }, "metadata": {}, "output_type": "display_data" @@ -364,20 +390,22 @@ }, { "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": [ { "data": { - "image/png": "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", - "text/plain": "
" + "image/png": "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", + "text/plain": [ + "
" + ] }, "metadata": {}, "output_type": "display_data" @@ -402,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 }, @@ -428,20 +456,22 @@ }, { "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": [ { "data": { - "image/png": "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", - "text/plain": "
" + "image/png": "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", + "text/plain": [ + "
" + ] }, "metadata": {}, "output_type": "display_data" @@ -471,20 +501,22 @@ }, { "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": [ { "data": { - "image/png": "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", - "text/plain": "
" + "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" @@ -509,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 }, @@ -541,19 +573,19 @@ }, { "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": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABIMAAAOOCAYAAACTMtKnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAB7CAAAewgFu0HU+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==", + "image/png": "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", "text/plain": [ "
" ] diff --git a/docs/usage/how-to-choose-a-solver.md b/docs/usage/how-to-choose-a-solver.md index 669ef2e9..2dce12d1 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, please refer to the section on [Underdamped Langevin solvers](../api/solvers/sde_solvers.md#underdamped-langevin-solvers). + --- ## Controlled differential equations diff --git a/examples/underdamped_langevin_example.ipynb b/examples/underdamped_langevin_example.ipynb new file mode 100644 index 00000000..61309563 --- /dev/null +++ b/examples/underdamped_langevin_example.ipynb @@ -0,0 +1,152 @@ +{ + "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", + " \\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 $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 damping 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 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", + "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": 3, + "id": "9deba250066ddc39", + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-01T17:24:08.608664Z", + "start_time": "2024-09-01T17:24:06.215228Z" + } + }, + "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", + "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" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "62da2ddbaaf98f47", + "metadata": { + "ExecuteTime": { + "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", + "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 ac1ba4cd..b399fbd8 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -111,6 +111,7 @@ nav: - Kalman filter: 'examples/kalman_filter.ipynb' - Second-order sensitivities: 'examples/hessian.ipynb' - Nonlinear heat PDE: 'examples/nonlinear_heat_pde.ipynb' + - Underdamped Langevin diffusion: 'examples/underdamped_langevin_example.ipynb' - Basic API: - 'api/diffeqsolve.md' - Solvers: diff --git a/test/helpers.py b/test/helpers.py index 749d35a1..3eba28a4 100644 --- a/test/helpers.py +++ b/test/helpers.py @@ -14,8 +14,11 @@ ControlTerm, MultiTerm, ODETerm, + UnderdampedLangevinDiffusionTerm, + UnderdampedLangevinDriftTerm, VirtualBrownianTree, ) +from diffrax._misc import is_tuple_of_ints from jax import Array from jaxtyping import PRNGKeyArray, PyTree, Shaped @@ -116,7 +119,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 +140,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 +155,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 +182,8 @@ def _batch_sde_solve( stepsize_controller=controller, saveat=saveat, ) - return sol.ys, sol.stats["num_accepted_steps"] + steps = sol.stats["num_accepted_steps"] + return sol.ys, steps def _resulting_levy_area( @@ -220,7 +227,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 +235,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): @@ -288,7 +302,7 @@ class SDE: y0: PyTree[Array] t0: float t1: float - w_shape: tuple[int, ...] + w_shape: Union[tuple[int, ...], PyTree[jax.ShapeDtypeStruct]] def get_dtype(self): return jnp.result_type(*jtu.tree_leaves(self.y0)) @@ -296,11 +310,18 @@ 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, ): - 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 +334,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 +354,8 @@ def simple_sde_order( get_dt_and_controller, saveat, bm_tol, + levy_area, + ref_solution, ) @@ -466,3 +491,110 @@ def get_terms(bm): return MultiTerm(ODETerm(_drift), ControlTerm(_diffusion, 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) + y0_bqp = (dtype(0), dtype(0)) + w_shape_bqp = () + + def get_terms_bqp(bm): + return make_underdamped_langevin_term(gamma, u, grad_f_bqp, bm) + + 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) + 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 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) + + +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 + 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 make_underdamped_langevin_term(gamma, u, grad_log_p, bm) + + 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 + 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 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_integrate.py b/test/test_integrate.py index 11da020f..555d6ade 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_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)) diff --git a/test/test_underdamped_langevin.py b/test/test_underdamped_langevin.py new file mode 100644 index 00000000..e945cad5 --- /dev/null +++ b/test/test_underdamped_langevin.py @@ -0,0 +1,273 @@ +import diffrax +import jax +import jax.numpy as jnp +import jax.random as jr +import jax.tree_util as jtu +import pytest +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, + simple_sde_order, +) + + +# ULD stands for Underdamped Langevin Diffusion +def _only_uld_solvers_cls(): + yield diffrax.ALIGN + yield diffrax.ShOULD + yield diffrax.QUICSORT + + +def _solvers_and_orders(): + # solver, order + 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_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)), + "qq": ( + array_factory((1, 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((3, 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} + + w_shape = jtu.tree_map(lambda _x: jax.ShapeDtypeStruct(_x.shape, _x.dtype), x0) + + def get_terms(bm): + return make_underdamped_langevin_term(g1, u1, grad_f, bm) + + return SDE(get_terms, None, y0, t0, t1, w_shape) + + +# All combinations of solvers with and without Taylor expansion +_uld_solvers_taylor_non_taylor = [ + solver_cls(taylor_threshold) + for solver_cls in _only_uld_solvers_cls() + for taylor_threshold in [0.0, 100.0] +] +_uld_plus_shark = [diffrax.ShARK()] + list(_uld_solvers_taylor_non_taylor) + + +@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_uld(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 + ) + 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}" + + jtu.tree_map(check_shape, sde.y0, sol.ys) + + +sdes = ( + (get_harmonic_oscillator, "hosc"), + (get_bqp, "bqp"), +) + + +@pytest.fixture(scope="module") +def fine_uld_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_uld_strong_order( + get_sde, sde_name, solver, theoretical_order, fine_uld_solutions +): + ( + true_sols, + t0, + t1, + bmkeys, + saveat, + level_coarse, + level_fine, + levy_area, + bm_tol, + ) = fine_uld_solutions + 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 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) + + 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, + ) + + assert ( + -0.2 < order - theoretical_order < 0.25 + ), f"order={order}, theoretical_order={theoretical_order}" + + +@pytest.mark.parametrize("solver_cls", _only_uld_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 = 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) + + ref_solver = diffrax.Heun() + ref_sol = diffeqsolve( + terms, ref_solver, t0, t1, dt0=dt0, y0=y0, args=None, saveat=saveat + ) + + 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 d9d1a074fb9d38fe8ddff96fdbdc983891cd35da Mon Sep 17 00:00:00 2001 From: Patrick Kidger <33688385+patrick-kidger@users.noreply.github.com> Date: Sat, 14 Sep 2024 09:47:39 +0200 Subject: [PATCH 02/14] tidy-ups --- diffrax/_solver/align.py | 6 ++++-- diffrax/_solver/quicsort.py | 6 ++++-- diffrax/_term.py | 7 ++++--- 3 files changed, 12 insertions(+), 7 deletions(-) diff --git a/diffrax/_solver/align.py b/diffrax/_solver/align.py index dd6bf9ed..4fb5f47e 100644 --- a/diffrax/_solver/align.py +++ b/diffrax/_solver/align.py @@ -70,10 +70,10 @@ class ALIGN(AbstractFosterLangevinSRK[_ALIGNCoeffs, _ErrorEstimate]): interpolation_cls = LocalLinearInterpolation minimal_levy_area = AbstractSpaceTimeLevyArea - taylor_threshold: RealScalarLike = eqx.field(static=True) + taylor_threshold: float = eqx.field(static=True) _is_fsal = True - def __init__(self, taylor_threshold: RealScalarLike = 0.1): + def __init__(self, taylor_threshold: float = 0.1): r"""**Arguments:** - `taylor_threshold`: If the product `h*gamma` is less than this, then @@ -84,9 +84,11 @@ def __init__(self, taylor_threshold: RealScalarLike = 0.1): self.taylor_threshold = taylor_threshold def order(self, terms): + del terms return 2 def strong_order(self, terms): + del terms return 2.0 def _directly_compute_coeffs_leaf( diff --git a/diffrax/_solver/quicsort.py b/diffrax/_solver/quicsort.py index 2e6ca897..da9b53be 100644 --- a/diffrax/_solver/quicsort.py +++ b/diffrax/_solver/quicsort.py @@ -85,10 +85,10 @@ class QUICSORT(AbstractFosterLangevinSRK[_QUICSORTCoeffs, None]): interpolation_cls = LocalLinearInterpolation minimal_levy_area = AbstractSpaceTimeTimeLevyArea - taylor_threshold: RealScalarLike = eqx.field(static=True) + taylor_threshold: float = eqx.field(static=True) _is_fsal = False - def __init__(self, taylor_threshold: RealScalarLike = 0.1): + def __init__(self, taylor_threshold: float = 0.1): r"""**Arguments:** - `taylor_threshold`: If the product `h*gamma` is less than this, then @@ -99,9 +99,11 @@ def __init__(self, taylor_threshold: RealScalarLike = 0.1): self.taylor_threshold = taylor_threshold def order(self, terms): + del terms return 3 def strong_order(self, terms): + del terms return 3.0 def _directly_compute_coeffs_leaf( diff --git a/diffrax/_term.py b/diffrax/_term.py index 2c3a78ab..bacaef9d 100644 --- a/diffrax/_term.py +++ b/diffrax/_term.py @@ -3,6 +3,7 @@ import warnings from collections.abc import Callable from typing import cast, Generic, Optional, TypeVar, Union +from typing_extensions import TypeAlias import equinox as eqx import jax @@ -791,11 +792,11 @@ def _to_vjp(_y, _diff_args, _diff_term): # `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[ +UnderdampedLangevinLeaf: TypeAlias = Shaped[Array, " *underdamped_langevin"] +UnderdampedLangevinX: TypeAlias = PyTree[ Shaped[Array, "?*underdamped_langevin"], "UnderdampedLangevinX" ] -UnderdampedLangevinTuple = tuple[UnderdampedLangevinX, UnderdampedLangevinX] +UnderdampedLangevinTuple: TypeAlias = tuple[UnderdampedLangevinX, UnderdampedLangevinX] def _broadcast_pytree(source, target_tree): From 6409b783cd293825d997c57d09ad3070cb5dcacb Mon Sep 17 00:00:00 2001 From: Patrick Kidger <33688385+patrick-kidger@users.noreply.github.com> Date: Mon, 21 Oct 2024 15:25:57 +0200 Subject: [PATCH 03/14] Split SDE tests in half, to try and avoid GitHub runner issues? --- test/{test_sde.py => test_sde1.py} | 158 +---------------------------- test/test_sde2.py | 154 ++++++++++++++++++++++++++++ 2 files changed, 155 insertions(+), 157 deletions(-) rename test/{test_sde.py => test_sde1.py} (56%) create mode 100644 test/test_sde2.py diff --git a/test/test_sde.py b/test/test_sde1.py similarity index 56% rename from test/test_sde.py rename to test/test_sde1.py index cdac924f..b4504872 100644 --- a/test/test_sde.py +++ b/test/test_sde1.py @@ -1,13 +1,9 @@ from typing import Literal import diffrax -import jax import jax.numpy as jnp import jax.random as jr -import jax.tree_util as jtu -import lineax as lx import pytest -from diffrax import ControlTerm, MultiTerm, ODETerm, WeaklyDiagonalControlTerm from .helpers import ( get_mlp_sde, @@ -119,10 +115,7 @@ def get_dt_and_controller(level): # using a single reference solution. We use Euler if the solver is Ito # and Heun if the solver is Stratonovich. @pytest.mark.parametrize("solver_ctr,noise,theoretical_order", _solvers_and_orders()) -@pytest.mark.parametrize( - "dtype", - (jnp.float64,), -) +@pytest.mark.parametrize("dtype", (jnp.float64,)) def test_sde_strong_limit( solver_ctr, noise: Literal["any", "com", "add"], theoretical_order, dtype ): @@ -184,152 +177,3 @@ def test_sde_strong_limit( ) error = path_l2_dist(correct_sol, sol) assert error < 0.05 - - -def _solvers(): - yield diffrax.SPaRK - yield diffrax.GeneralShARK - yield diffrax.SlowRK - yield diffrax.ShARK - yield diffrax.SRA1 - yield diffrax.SEA - - -# Define the SDE -def dict_drift(t, y, args): - pytree, _ = args - return jtu.tree_map(lambda _, x: -0.5 * x, pytree, y) - - -def dict_diffusion(t, y, args): - pytree, additive = args - - def get_matrix(y_leaf): - if additive: - return 2.0 * jnp.ones(y_leaf.shape + (3,), dtype=jnp.float64) - else: - return 2.0 * jnp.broadcast_to( - jnp.expand_dims(y_leaf, axis=y_leaf.ndim), y_leaf.shape + (3,) - ) - - return jtu.tree_map(get_matrix, y) - - -@pytest.mark.parametrize("shape", [(), (5, 2)]) -@pytest.mark.parametrize("solver_ctr", _solvers()) -@pytest.mark.parametrize( - "dtype", - (jnp.float64, jnp.complex128), -) -def test_sde_solver_shape(shape, solver_ctr, dtype): - pytree = ({"a": 0, "b": [0, 0]}, 0, 0) - key = jr.PRNGKey(0) - y0 = jtu.tree_map(lambda _: jr.normal(key, shape, dtype=dtype), pytree) - t0, t1, dt0 = 0.0, 1.0, 0.3 - - # Some solvers only work with additive noise - additive = solver_ctr in [diffrax.ShARK, diffrax.SRA1, diffrax.SEA] - args = (pytree, additive) - solver = solver_ctr() - bmkey = jr.key(1) - struct = jax.ShapeDtypeStruct((3,), dtype) - bm_shape = jtu.tree_map(lambda _: struct, pytree) - bm = diffrax.VirtualBrownianTree( - t0, t1, 0.1, bm_shape, bmkey, diffrax.SpaceTimeLevyArea - ) - terms = MultiTerm(ODETerm(dict_drift), ControlTerm(dict_diffusion, bm)) - solution = diffrax.diffeqsolve( - terms, solver, t0, t1, dt0, y0, args, saveat=diffrax.SaveAt(t1=True) - ) - assert jtu.tree_structure(solution.ys) == jtu.tree_structure(y0) - for leaf in jtu.tree_leaves(solution.ys): - assert leaf[0].shape == shape - - -def _weakly_diagonal_noise_helper(solver, dtype): - w_shape = (3,) - args = (0.5, 1.2) - - def _diffusion(t, y, args): - a, b = args - return jnp.array([b, t, 1 / (t + 1.0)], dtype=dtype) - - def _drift(t, y, args): - a, b = args - return -a * y - - y0 = jnp.ones(w_shape, dtype) - - bm = diffrax.VirtualBrownianTree( - 0.0, 1.0, 0.05, w_shape, jr.key(0), diffrax.SpaceTimeLevyArea - ) - - terms = MultiTerm(ODETerm(_drift), WeaklyDiagonalControlTerm(_diffusion, bm)) - saveat = diffrax.SaveAt(t1=True) - solution = diffrax.diffeqsolve( - terms, solver, 0.0, 1.0, 0.1, y0, args, saveat=saveat - ) - assert solution.ys is not None - assert solution.ys.shape == (1, 3) - - -def _lineax_weakly_diagonal_noise_helper(solver, dtype): - w_shape = (3,) - args = (0.5, 1.2) - - def _diffusion(t, y, args): - a, b = args - return lx.DiagonalLinearOperator(jnp.array([b, t, 1 / (t + 1.0)], dtype=dtype)) - - def _drift(t, y, args): - a, b = args - return -a * y - - y0 = jnp.ones(w_shape, dtype) - - bm = diffrax.VirtualBrownianTree( - 0.0, 1.0, 0.05, w_shape, jr.PRNGKey(0), diffrax.SpaceTimeLevyArea - ) - - terms = MultiTerm(ODETerm(_drift), ControlTerm(_diffusion, bm)) - saveat = diffrax.SaveAt(t1=True) - solution = diffrax.diffeqsolve( - terms, solver, 0.0, 1.0, 0.1, y0, args, saveat=saveat - ) - assert solution.ys is not None - assert solution.ys.shape == (1, 3) - - -@pytest.mark.parametrize("solver_ctr", _solvers()) -@pytest.mark.parametrize( - "dtype", - (jnp.float64, jnp.complex128), -) -@pytest.mark.parametrize( - "weak_type", - ("old", "lineax"), -) -def test_weakly_diagonal_noise(solver_ctr, dtype, weak_type): - if weak_type == "old": - _weakly_diagonal_noise_helper(solver_ctr(), dtype) - elif weak_type == "lineax": - _lineax_weakly_diagonal_noise_helper(solver_ctr(), dtype) - else: - raise ValueError("Invalid weak_type") - - -@pytest.mark.parametrize( - "dtype", - (jnp.float64, jnp.complex128), -) -@pytest.mark.parametrize( - "weak_type", - ("old", "lineax"), -) -def test_halfsolver_term_compatible(dtype, weak_type): - if weak_type == "old": - _weakly_diagonal_noise_helper(diffrax.HalfSolver(diffrax.SPaRK()), dtype) - elif weak_type == "lineax": - _lineax_weakly_diagonal_noise_helper(diffrax.HalfSolver(diffrax.SPaRK()), dtype) - else: - raise ValueError("Invalid weak_type") diff --git a/test/test_sde2.py b/test/test_sde2.py new file mode 100644 index 00000000..3b4a4628 --- /dev/null +++ b/test/test_sde2.py @@ -0,0 +1,154 @@ +import diffrax +import jax +import jax.numpy as jnp +import jax.random as jr +import jax.tree_util as jtu +import lineax as lx +import pytest +from diffrax import ControlTerm, MultiTerm, ODETerm, WeaklyDiagonalControlTerm + + +def _solvers(): + yield diffrax.SPaRK + yield diffrax.GeneralShARK + yield diffrax.SlowRK + yield diffrax.ShARK + yield diffrax.SRA1 + yield diffrax.SEA + + +# Define the SDE +def dict_drift(t, y, args): + pytree, _ = args + return jtu.tree_map(lambda _, x: -0.5 * x, pytree, y) + + +def dict_diffusion(t, y, args): + pytree, additive = args + + def get_matrix(y_leaf): + if additive: + return 2.0 * jnp.ones(y_leaf.shape + (3,), dtype=jnp.float64) + else: + return 2.0 * jnp.broadcast_to( + jnp.expand_dims(y_leaf, axis=y_leaf.ndim), y_leaf.shape + (3,) + ) + + return jtu.tree_map(get_matrix, y) + + +@pytest.mark.parametrize("shape", [(), (5, 2)]) +@pytest.mark.parametrize("solver_ctr", _solvers()) +@pytest.mark.parametrize("dtype", (jnp.float64, jnp.complex128)) +def test_sde_solver_shape(shape, solver_ctr, dtype): + pytree = ({"a": 0, "b": [0, 0]}, 0, 0) + key = jr.PRNGKey(0) + y0 = jtu.tree_map(lambda _: jr.normal(key, shape, dtype=dtype), pytree) + t0, t1, dt0 = 0.0, 1.0, 0.3 + + # Some solvers only work with additive noise + additive = solver_ctr in [diffrax.ShARK, diffrax.SRA1, diffrax.SEA] + args = (pytree, additive) + solver = solver_ctr() + bmkey = jr.key(1) + struct = jax.ShapeDtypeStruct((3,), dtype) + bm_shape = jtu.tree_map(lambda _: struct, pytree) + bm = diffrax.VirtualBrownianTree( + t0, t1, 0.1, bm_shape, bmkey, diffrax.SpaceTimeLevyArea + ) + terms = MultiTerm(ODETerm(dict_drift), ControlTerm(dict_diffusion, bm)) + solution = diffrax.diffeqsolve( + terms, solver, t0, t1, dt0, y0, args, saveat=diffrax.SaveAt(t1=True) + ) + assert jtu.tree_structure(solution.ys) == jtu.tree_structure(y0) + for leaf in jtu.tree_leaves(solution.ys): + assert leaf[0].shape == shape + + +def _weakly_diagonal_noise_helper(solver, dtype): + w_shape = (3,) + args = (0.5, 1.2) + + def _diffusion(t, y, args): + a, b = args + return jnp.array([b, t, 1 / (t + 1.0)], dtype=dtype) + + def _drift(t, y, args): + a, b = args + return -a * y + + y0 = jnp.ones(w_shape, dtype) + + bm = diffrax.VirtualBrownianTree( + 0.0, 1.0, 0.05, w_shape, jr.key(0), diffrax.SpaceTimeLevyArea + ) + + terms = MultiTerm(ODETerm(_drift), WeaklyDiagonalControlTerm(_diffusion, bm)) + saveat = diffrax.SaveAt(t1=True) + solution = diffrax.diffeqsolve( + terms, solver, 0.0, 1.0, 0.1, y0, args, saveat=saveat + ) + assert solution.ys is not None + assert solution.ys.shape == (1, 3) + + +def _lineax_weakly_diagonal_noise_helper(solver, dtype): + w_shape = (3,) + args = (0.5, 1.2) + + def _diffusion(t, y, args): + a, b = args + return lx.DiagonalLinearOperator(jnp.array([b, t, 1 / (t + 1.0)], dtype=dtype)) + + def _drift(t, y, args): + a, b = args + return -a * y + + y0 = jnp.ones(w_shape, dtype) + + bm = diffrax.VirtualBrownianTree( + 0.0, 1.0, 0.05, w_shape, jr.PRNGKey(0), diffrax.SpaceTimeLevyArea + ) + + terms = MultiTerm(ODETerm(_drift), ControlTerm(_diffusion, bm)) + saveat = diffrax.SaveAt(t1=True) + solution = diffrax.diffeqsolve( + terms, solver, 0.0, 1.0, 0.1, y0, args, saveat=saveat + ) + assert solution.ys is not None + assert solution.ys.shape == (1, 3) + + +@pytest.mark.parametrize("solver_ctr", _solvers()) +@pytest.mark.parametrize( + "dtype", + (jnp.float64, jnp.complex128), +) +@pytest.mark.parametrize( + "weak_type", + ("old", "lineax"), +) +def test_weakly_diagonal_noise(solver_ctr, dtype, weak_type): + if weak_type == "old": + _weakly_diagonal_noise_helper(solver_ctr(), dtype) + elif weak_type == "lineax": + _lineax_weakly_diagonal_noise_helper(solver_ctr(), dtype) + else: + raise ValueError("Invalid weak_type") + + +@pytest.mark.parametrize( + "dtype", + (jnp.float64, jnp.complex128), +) +@pytest.mark.parametrize( + "weak_type", + ("old", "lineax"), +) +def test_halfsolver_term_compatible(dtype, weak_type): + if weak_type == "old": + _weakly_diagonal_noise_helper(diffrax.HalfSolver(diffrax.SPaRK()), dtype) + elif weak_type == "lineax": + _lineax_weakly_diagonal_noise_helper(diffrax.HalfSolver(diffrax.SPaRK()), dtype) + else: + raise ValueError("Invalid weak_type") From 2d8e87ca173445089f1c39334f26ea98a95a5acd Mon Sep 17 00:00:00 2001 From: Patrick Kidger <33688385+patrick-kidger@users.noreply.github.com> Date: Mon, 21 Oct 2024 17:51:34 +0200 Subject: [PATCH 04/14] Added effects_barrier to fix test issue with JAX 0.4.33+ --- test/test_progress_meter.py | 1 + 1 file changed, 1 insertion(+) diff --git a/test/test_progress_meter.py b/test/test_progress_meter.py index 76028169..1c87b035 100644 --- a/test/test_progress_meter.py +++ b/test/test_progress_meter.py @@ -35,6 +35,7 @@ def solve(t0): for num_lines, solve_fn in solve_fns: capfd.readouterr() solve_fn() + jax.effects_barrier() captured = capfd.readouterr() err = captured.err.strip() assert re.match("0.00%|[ ]+|", err.split("\r", 1)[0]) From 5bdd890f661fe243c0336a5316b38613b76b10a2 Mon Sep 17 00:00:00 2001 From: andyElking Date: Fri, 18 Oct 2024 16:40:55 +0100 Subject: [PATCH 05/14] small fix of docs in all three and a return type in quicsort --- diffrax/_solver/align.py | 5 +++-- diffrax/_solver/quicsort.py | 8 ++++---- diffrax/_solver/should.py | 5 +++-- 3 files changed, 10 insertions(+), 8 deletions(-) diff --git a/diffrax/_solver/align.py b/diffrax/_solver/align.py index 4fb5f47e..c6bc6105 100644 --- a/diffrax/_solver/align.py +++ b/diffrax/_solver/align.py @@ -46,8 +46,9 @@ def __init__(self, beta, a1, b1, aa, chh): class ALIGN(AbstractFosterLangevinSRK[_ALIGNCoeffs, _ErrorEstimate]): r"""The Adaptive Langevin via Interpolated Gradients and Noise method 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 + Underdamped Langevin Diffusion, and accepts terms of the form + `MultiTerm(UnderdampedLangevinDriftTerm, UnderdampedLangevinDiffusionTerm)`. + Uses two evaluations of the vector field per step, but is FSAL, so in practice it only requires one. ??? cite "Reference" diff --git a/diffrax/_solver/quicsort.py b/diffrax/_solver/quicsort.py index da9b53be..4f21bd6f 100644 --- a/diffrax/_solver/quicsort.py +++ b/diffrax/_solver/quicsort.py @@ -47,9 +47,9 @@ def __init__(self, beta_lr1, a_lr1, b_lr1, a_third, a_div_h): class QUICSORT(AbstractFosterLangevinSRK[_QUICSORTCoeffs, None]): r"""The QUadrature Inspired and Contractive Shifted ODE with Runge-Kutta Three 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. + Underdamped Langevin Diffusion, and accepts terms of the form + `MultiTerm(UnderdampedLangevinDriftTerm, UnderdampedLangevinDiffusionTerm)`. + Uses two evaluations of the vector field per step. ??? cite "Reference" @@ -199,7 +199,7 @@ def _compute_step( coeffs: _QUICSORTCoeffs, rho: UnderdampedLangevinX, prev_f: Optional[UnderdampedLangevinX], - ) -> tuple[UnderdampedLangevinX, UnderdampedLangevinX, UnderdampedLangevinX, None]: + ) -> tuple[UnderdampedLangevinX, UnderdampedLangevinX, None, None]: del prev_f dtypes = jtu.tree_map(jnp.result_type, x0) w: UnderdampedLangevinX = jtu.tree_map(jnp.asarray, levy.W, dtypes) diff --git a/diffrax/_solver/should.py b/diffrax/_solver/should.py index 6d8b0cb0..caab54d3 100644 --- a/diffrax/_solver/should.py +++ b/diffrax/_solver/should.py @@ -59,8 +59,9 @@ def __init__(self, beta_half, a_half, b_half, beta1, a1, b1, aa, chh, ckk): class ShOULD(AbstractFosterLangevinSRK[_ShOULDCoeffs, None]): r"""The Shifted-ODE Runge-Kutta Three method 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 + Underdamped Langevin Diffusion, the terms of the form + `MultiTerm(UnderdampedLangevinDriftTerm, UnderdampedLangevinDiffusionTerm)`. + Uses three evaluations of the vector field per step, but is FSAL, so in practice it only requires two. ??? cite "Reference" From aae474233807b44320acb58b6d26a543fac0170f Mon Sep 17 00:00:00 2001 From: Patrick Kidger <33688385+patrick-kidger@users.noreply.github.com> Date: Sat, 2 Nov 2024 23:48:32 +0100 Subject: [PATCH 06/14] bump doc building pipeline --- .github/workflows/build_docs.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/build_docs.yml b/.github/workflows/build_docs.yml index 8fdf2492..f098a46b 100644 --- a/.github/workflows/build_docs.yml +++ b/.github/workflows/build_docs.yml @@ -33,7 +33,7 @@ jobs: mkdocs build # twice, see https://github.com/patrick-kidger/pytkdocs_tweaks - name: Upload docs - uses: actions/upload-artifact@v2 + uses: actions/upload-artifact@v4 with: name: docs path: site # where `mkdocs build` puts the built site From ba09fba8f504a61f0ebbe1e87745653855009b22 Mon Sep 17 00:00:00 2001 From: Patrick Kidger <33688385+patrick-kidger@users.noreply.github.com> Date: Sun, 17 Nov 2024 21:59:48 +0100 Subject: [PATCH 07/14] Compatibility with JAX 0.4.36, which removes ConcreteArray --- diffrax/_integrate.py | 5 ++--- diffrax/_misc.py | 9 +++------ 2 files changed, 5 insertions(+), 9 deletions(-) diff --git a/diffrax/_integrate.py b/diffrax/_integrate.py index 938eee37..3a1c59b7 100644 --- a/diffrax/_integrate.py +++ b/diffrax/_integrate.py @@ -20,6 +20,7 @@ import jax.numpy as jnp import jax.tree_util as jtu import lineax.internal as lxi +import numpy as np import optimistix as optx from jaxtyping import Array, ArrayLike, Float, Inexact, PyTree, Real @@ -258,12 +259,10 @@ def _maybe_static(static_x: Optional[ArrayLike], x: ArrayLike) -> ArrayLike: # Some values (made_jump and result) are not used in many common use-cases. If we # detect that they're unused then we make sure they're non-Array Python values, so # that we can special case on them at trace time and get a performance boost. - if isinstance(static_x, (bool, int, float, complex)): + if isinstance(static_x, (bool, int, float, complex, np.ndarray)): return static_x elif static_x is None: return x - elif type(jax.core.get_aval(static_x)) is jax.core.ConcreteArray: - return static_x else: return x diff --git a/diffrax/_misc.py b/diffrax/_misc.py index 5a5a3b67..ac61b813 100644 --- a/diffrax/_misc.py +++ b/diffrax/_misc.py @@ -6,6 +6,7 @@ import jax.lax as lax import jax.numpy as jnp import jax.tree_util as jtu +import numpy as np import optimistix as optx from jaxtyping import Array, ArrayLike, PyTree, Shaped @@ -146,12 +147,8 @@ def static_select(pred: BoolScalarLike, a: ArrayLike, b: ArrayLike) -> ArrayLike # predicate is statically known. # This in turn allows us to perform some trace-time optimisations that XLA isn't # smart enough to do on its own. - if ( - type(pred) is not bool - and type(jax.core.get_aval(pred)) is jax.core.ConcreteArray - ): - with jax.ensure_compile_time_eval(): - pred = pred.item() + if isinstance(pred, (np.ndarray, np.generic)) and pred.shape == (): + pred = pred.item() if pred is True: return a elif pred is False: From dc689574485ff9b4e2a55eb8e9be2d4e4596e822 Mon Sep 17 00:00:00 2001 From: Daniel Weiss <32396142+dkweiss31@users.noreply.github.com> Date: Fri, 6 Dec 2024 02:05:16 -0500 Subject: [PATCH 08/14] Save fix for `t0==t1` (#494) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Langevin PR (#453) * Langevin PR * Minor fixes * removed the SORT solver (superseded by QUICSORT) * made LangevinTerm.term a static field * temporary fix for _term_compatible and LangevinTerm * Fixed LangevinTerm YAAAYYYYY * Nits * Added Langevin docs, a Langevin example and backwards in time test * Fixed Patrick's comments * langevin -> underdamped_langevin * round of small fixes * check langevin drift term and diffusion term have same args * added scan_trick in QUICSORT and ShOULD * using RuntimeError for when ULD args have wrong structure * small fixes * tidy-ups * Split SDE tests in half, to try and avoid GitHub runner issues? * Added effects_barrier to fix test issue with JAX 0.4.33+ * small fix of docs in all three and a return type in quicsort * bump doc building pipeline * Compatibility with JAX 0.4.36, which removes ConcreteArray * using a fori_loop to save states in edge case t0==t1 * added case for saving t0 data, which was also not getting updated. Added a test * using while_loop, ran into issues with reverse-mode diff using the fori_loop * bug fix for cases when t0=True * simplified logic for saving, no loop necessary * added vmap test * using a fori_loop to save states in edge case t0==t1 * added case for saving t0 data, which was also not getting updated. Added a test * using while_loop, ran into issues with reverse-mode diff using the fori_loop * bug fix for cases when t0=True * simplified logic for saving, no loop necessary * added vmap test * fix t1 out of bounds issue * fix for steps: don't want to update those values if t0==t1 since we didn't take any steps. Added test --------- Co-authored-by: Andraž Jelinčič <66168650+andyElking@users.noreply.github.com> Co-authored-by: Patrick Kidger <33688385+patrick-kidger@users.noreply.github.com> Co-authored-by: andyElking --- diffrax/_integrate.py | 47 ++++++++++++++++++++ test/test_saveat_solution.py | 85 ++++++++++++++++++++++++++++++++++++ 2 files changed, 132 insertions(+) diff --git a/diffrax/_integrate.py b/diffrax/_integrate.py index 3a1c59b7..1d3e7209 100644 --- a/diffrax/_integrate.py +++ b/diffrax/_integrate.py @@ -775,9 +775,56 @@ def _save_t1(subsaveat, save_state): save_state = _save(tfinal, yfinal, args, subsaveat.fn, save_state) return save_state + def _save_ts(subsaveat: SubSaveAt, save_state: SaveState) -> SaveState: + if subsaveat.ts is not None: + out_size = 1 if subsaveat.t0 else 0 + out_size += 1 if subsaveat.t1 and not subsaveat.steps else 0 + out_size += len(subsaveat.ts) + ys = jtu.tree_map( + lambda y: jnp.stack([y] * out_size), + subsaveat.fn(t0, yfinal, args), + ) + ts = jnp.full(out_size, t0) + if subsaveat.steps: + ysteps = jtu.tree_map( + lambda y: jnp.stack([y] * max_steps), + subsaveat.fn(t0, jnp.full_like(yfinal, jnp.inf), args), + ) + ys = jtu.tree_map( + lambda _ys, _ysteps: jnp.concatenate([_ys, _ysteps], axis=0), + ys, + ysteps, + ) + ts = jnp.concatenate((ts, jnp.full(max_steps, jnp.inf))) + save_state = SaveState( + saveat_ts_index=out_size, + ts=ts, + ys=ys, + save_index=out_size, + ) + return save_state + save_state = jtu.tree_map( _save_t1, saveat.subs, final_state.save_state, is_leaf=_is_subsaveat ) + + # if t0 == t1 then we don't enter the integration loop. In this case we have to + # manually update the saved ts and ys if we want to save at "intermediate" + # times specified by saveat.subs.ts + save_state = jax.lax.cond( + eqxi.unvmap_any(t0 == t1), + lambda __save_state: jax.lax.cond( + t0 == t1, + lambda _save_state: jtu.tree_map( + _save_ts, saveat.subs, _save_state, is_leaf=_is_subsaveat + ), + lambda _save_state: _save_state, + __save_state, + ), + lambda __save_state: __save_state, + save_state, + ) + final_state = eqx.tree_at( lambda s: s.save_state, final_state, save_state, is_leaf=_is_none ) diff --git a/test/test_saveat_solution.py b/test/test_saveat_solution.py index cc73bf99..ba536b04 100644 --- a/test/test_saveat_solution.py +++ b/test/test_saveat_solution.py @@ -147,6 +147,91 @@ def test_saveat_solution(): assert sol.result == diffrax.RESULTS.successful +@pytest.mark.parametrize("subs", [True, False]) +def test_t0_eq_t1(subs): + y0 = jnp.array([2.0]) + ts = jnp.linspace(1.0, 1.0, 3) + max_steps = 256 + if subs: + get0 = diffrax.SubSaveAt( + ts=ts, + t1=True, + ) + get1 = diffrax.SubSaveAt( + t0=True, + ts=ts, + ) + get2 = diffrax.SubSaveAt( + t0=True, + ts=ts, + steps=True, + ) + subs = (get0, get1, get2) + saveat = diffrax.SaveAt(subs=subs) + else: + saveat = diffrax.SaveAt(t0=True, t1=True, ts=ts) + term = diffrax.ODETerm(lambda t, y, args: y) + sol = diffrax.diffeqsolve( + term, + t0=ts[0], + t1=ts[-1], + y0=y0, + dt0=0.1, + solver=diffrax.Dopri5(), + saveat=saveat, + max_steps=max_steps, + ) + if subs: + compare = jnp.full((len(ts) + 1, *y0.shape), y0) + compare_2 = jnp.concatenate( + (compare, jnp.full((max_steps, *y0.shape), jnp.inf)) + ) + assert tree_allclose(sol.ys[0], compare) # pyright: ignore + assert tree_allclose(sol.ys[1], compare) # pyright: ignore + assert tree_allclose(sol.ys[2], compare_2) # pyright: ignore + else: + compare = jnp.full((len(ts) + 2, *y0.shape), y0) + assert tree_allclose(sol.ys, compare) + + +@pytest.mark.parametrize("subs", [True, False]) +def test_vmap_t0_eq_t1(subs): + ntsave = 4 + y0 = jnp.array([2.0]) + term = diffrax.ODETerm(lambda t, y, args: y) + + def _solve(tf): + ts = jnp.linspace(0.0, tf, ntsave) + get0 = diffrax.SubSaveAt( + ts=ts, + t1=True, + ) + get1 = diffrax.SubSaveAt( + t0=True, + ts=ts, + ) + subs = (get0, get1) + saveat = diffrax.SaveAt(subs=subs) + return diffrax.diffeqsolve( + term, + t0=ts[0], + t1=ts[-1], + y0=y0, + dt0=0.1, + solver=diffrax.Dopri5(), + saveat=saveat, + ) + + compare = jnp.full((ntsave + 1, *y0.shape), y0) + sol = jax.vmap(_solve)(jnp.array([0.0, 1.0])) + assert tree_allclose(sol.ys[0][0], compare) # pyright: ignore + assert tree_allclose(sol.ys[1][0], compare) # pyright: ignore + + regular_solve = _solve(1.0) + assert tree_allclose(sol.ys[0][1], regular_solve.ys[0]) # pyright: ignore + assert tree_allclose(sol.ys[1][1], regular_solve.ys[1]) # pyright: ignore + + def test_trivial_dense(): term = diffrax.ODETerm(lambda t, y, args: -0.5 * y) y0 = jnp.array([2.1]) From 57885f2201d368986273a34e670c82532a5d456b Mon Sep 17 00:00:00 2001 From: Patrick Kidger <33688385+patrick-kidger@users.noreply.github.com> Date: Fri, 6 Dec 2024 09:00:55 +0100 Subject: [PATCH 09/14] Updates to the t0==t1 case to handle `SubSaveAt(fn=...)` and nonstandard dtypes correctly. --- diffrax/_integrate.py | 36 +++++++++++--------- diffrax/_local_interpolation.py | 2 +- test/test_saveat_solution.py | 59 +++++++++++++++++++++++---------- 3 files changed, 62 insertions(+), 35 deletions(-) diff --git a/diffrax/_integrate.py b/diffrax/_integrate.py index 1d3e7209..6a31fe59 100644 --- a/diffrax/_integrate.py +++ b/diffrax/_integrate.py @@ -775,27 +775,31 @@ def _save_t1(subsaveat, save_state): save_state = _save(tfinal, yfinal, args, subsaveat.fn, save_state) return save_state - def _save_ts(subsaveat: SubSaveAt, save_state: SaveState) -> SaveState: + def _save_if_t0_equals_t1(subsaveat: SubSaveAt, save_state: SaveState) -> SaveState: if subsaveat.ts is not None: out_size = 1 if subsaveat.t0 else 0 out_size += 1 if subsaveat.t1 and not subsaveat.steps else 0 out_size += len(subsaveat.ts) - ys = jtu.tree_map( - lambda y: jnp.stack([y] * out_size), - subsaveat.fn(t0, yfinal, args), - ) + + def _make_ys(out, old_outs): + outs = jnp.stack([out] * out_size) + if subsaveat.steps: + outs = jnp.concatenate( + [ + outs, + jnp.full( + (max_steps,) + out.shape, jnp.inf, dtype=out.dtype + ), + ] + ) + assert outs.shape == old_outs.shape + return outs + ts = jnp.full(out_size, t0) if subsaveat.steps: - ysteps = jtu.tree_map( - lambda y: jnp.stack([y] * max_steps), - subsaveat.fn(t0, jnp.full_like(yfinal, jnp.inf), args), - ) - ys = jtu.tree_map( - lambda _ys, _ysteps: jnp.concatenate([_ys, _ysteps], axis=0), - ys, - ysteps, - ) - ts = jnp.concatenate((ts, jnp.full(max_steps, jnp.inf))) + ts = jnp.concatenate((ts, jnp.full(max_steps, jnp.inf, dtype=ts.dtype))) + assert ts.shape == save_state.ts.shape + ys = jtu.tree_map(_make_ys, subsaveat.fn(t0, yfinal, args), save_state.ys) save_state = SaveState( saveat_ts_index=out_size, ts=ts, @@ -816,7 +820,7 @@ def _save_ts(subsaveat: SubSaveAt, save_state: SaveState) -> SaveState: lambda __save_state: jax.lax.cond( t0 == t1, lambda _save_state: jtu.tree_map( - _save_ts, saveat.subs, _save_state, is_leaf=_is_subsaveat + _save_if_t0_equals_t1, saveat.subs, _save_state, is_leaf=_is_subsaveat ), lambda _save_state: _save_state, __save_state, diff --git a/diffrax/_local_interpolation.py b/diffrax/_local_interpolation.py index 0098a059..29a8eb9e 100644 --- a/diffrax/_local_interpolation.py +++ b/diffrax/_local_interpolation.py @@ -110,7 +110,7 @@ def __init__( ): def _calculate(_y0, _y1, _k): with jax.numpy_dtype_promotion("standard"): - _ymid = _y0 + jnp.tensordot(self.c_mid, _k, axes=1) + _ymid = _y0 + jnp.tensordot(self.c_mid, _k, axes=1).astype(_y0.dtype) _f0 = _k[0] _f1 = _k[-1] # TODO: rewrite as matrix-vector product? diff --git a/test/test_saveat_solution.py b/test/test_saveat_solution.py index ba536b04..8ddca38d 100644 --- a/test/test_saveat_solution.py +++ b/test/test_saveat_solution.py @@ -186,22 +186,29 @@ def test_t0_eq_t1(subs): compare_2 = jnp.concatenate( (compare, jnp.full((max_steps, *y0.shape), jnp.inf)) ) - assert tree_allclose(sol.ys[0], compare) # pyright: ignore - assert tree_allclose(sol.ys[1], compare) # pyright: ignore - assert tree_allclose(sol.ys[2], compare_2) # pyright: ignore + ya, yb, yc = sol.ys # pyright: ignore[reportGeneralTypeIssues] + assert tree_allclose(ya, compare) + assert tree_allclose(yb, compare) + assert tree_allclose(yc, compare_2) else: compare = jnp.full((len(ts) + 2, *y0.shape), y0) assert tree_allclose(sol.ys, compare) -@pytest.mark.parametrize("subs", [True, False]) -def test_vmap_t0_eq_t1(subs): +def test_t0_eq_t1_complicated(): + """This test case also checks: + + - vmap'ing + - non-float32 dtypes + - `SubSaveAt(fn=...)` + """ ntsave = 4 - y0 = jnp.array([2.0]) + dtype = jnp.float16 + y0 = jnp.array([2.0], dtype=dtype) term = diffrax.ODETerm(lambda t, y, args: y) def _solve(tf): - ts = jnp.linspace(0.0, tf, ntsave) + ts = jnp.linspace(0.0, tf, ntsave, dtype=dtype) get0 = diffrax.SubSaveAt( ts=ts, t1=True, @@ -210,9 +217,15 @@ def _solve(tf): t0=True, ts=ts, ) - subs = (get0, get1) + get2 = diffrax.SubSaveAt( + t0=True, + ts=ts, + steps=True, + fn=lambda t, y, args: jnp.where(jnp.isinf(y), 3.0, 4.0), + ) + subs = (get0, get1, get2) saveat = diffrax.SaveAt(subs=subs) - return diffrax.diffeqsolve( + sol = diffrax.diffeqsolve( term, t0=ts[0], t1=ts[-1], @@ -220,16 +233,26 @@ def _solve(tf): dt0=0.1, solver=diffrax.Dopri5(), saveat=saveat, + max_steps=15, ) - - compare = jnp.full((ntsave + 1, *y0.shape), y0) - sol = jax.vmap(_solve)(jnp.array([0.0, 1.0])) - assert tree_allclose(sol.ys[0][0], compare) # pyright: ignore - assert tree_allclose(sol.ys[1][0], compare) # pyright: ignore - - regular_solve = _solve(1.0) - assert tree_allclose(sol.ys[0][1], regular_solve.ys[0]) # pyright: ignore - assert tree_allclose(sol.ys[1][1], regular_solve.ys[1]) # pyright: ignore + return sol.ys + + compare = jnp.full((ntsave + 1, *y0.shape), y0, dtype=dtype) + compare_c = jnp.concatenate( + [ + jnp.full((ntsave + 1, *y0.shape), 4.0, dtype=jnp.float64), + jnp.full((15, *y0.shape), jnp.inf, dtype=jnp.float64), + ] + ) + true_ya, true_yb, true_yc = _solve(1.0) # pyright: ignore[reportGeneralTypeIssues] + true_ya = jnp.stack([compare, true_ya]) + true_yb = jnp.stack([compare, true_yb]) + true_yc = jnp.stack([compare_c, true_yc]) + + ya, yb, yc = jax.vmap(_solve)(jnp.array([0.0, 1.0])) # pyright: ignore[reportGeneralTypeIssues] + assert tree_allclose(ya, true_ya) + assert tree_allclose(yb, true_yb) + assert tree_allclose(yc, true_yc) def test_trivial_dense(): From 54778978894270bd6cd59d0d5ec9d69fe1be781a Mon Sep 17 00:00:00 2001 From: Patrick Kidger <33688385+patrick-kidger@users.noreply.github.com> Date: Fri, 6 Dec 2024 09:07:10 +0100 Subject: [PATCH 10/14] Fixes for JAX 0.4.36 which changes the name of an error. --- test/test_adjoint.py | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/test/test_adjoint.py b/test/test_adjoint.py index 3d143593..30ad7bc8 100644 --- a/test/test_adjoint.py +++ b/test/test_adjoint.py @@ -4,7 +4,7 @@ import diffrax import equinox as eqx import jax -import jax.interpreters.ad +import jax._src.interpreters.ad import jax.numpy as jnp import jax.random as jr import jax.tree_util as jtu @@ -21,6 +21,7 @@ class _VectorField(eqx.Module): diff_arg: float def __call__(self, t, y, args): + del t assert y.shape == (2,) diff_arg, nondiff_arg = args dya = diff_arg * y[0] + nondiff_arg * y[1] @@ -29,7 +30,7 @@ def __call__(self, t, y, args): @pytest.mark.slow -def test_against(getkey): +def test_against(): y0 = jnp.array([0.9, 5.4]) args = (0.1, -1) term = diffrax.ODETerm(_VectorField(nondiff_arg=1, diff_arg=-0.1)) @@ -215,6 +216,7 @@ def test_closure_errors(): @eqx.filter_value_and_grad def run(model): def f(t, y, args): + del t, args return model(y) sol = diffrax.diffeqsolve( @@ -228,7 +230,7 @@ def f(t, y, args): ) return jnp.sum(cast(Array, sol.ys)) - with pytest.raises(jax.interpreters.ad.CustomVJPException): + with pytest.raises(jax._src.interpreters.ad.CustomVJPException): run(mlp) @@ -239,6 +241,7 @@ class VectorField(eqx.Module): model: Callable def __call__(self, t, y, args): + del t, args return self.model(y) @eqx.filter_jit @@ -307,12 +310,12 @@ def make_step(model, opt_state, target_steady_state): model = eqx.apply_updates(model, updates) return model, opt_state - for step in range(100): + for _ in range(100): model, opt_state = make_step(model, opt_state, target_steady_state) assert tree_allclose(model.steady_state, target_steady_state, rtol=1e-2, atol=1e-2) -def test_backprop_ts(getkey): +def test_backprop_ts(): mlp = eqx.nn.MLP(1, 1, 8, 2, key=jr.PRNGKey(0)) @eqx.filter_jit @@ -338,14 +341,17 @@ def run(model): ) def test_sde_against(diffusion_fn, getkey): def f(t, y, args): + del t k0, _ = args return -k0 * y def g(t, y, args): + del t _, k1 = args return k1 * y def g_lx(t, y, args): + del t _, k1 = args return lx.DiagonalLinearOperator(k1 * y) From 94cec1bd3074d2483a0747edf8e3fabca73bdb95 Mon Sep 17 00:00:00 2001 From: Patrick Kidger <33688385+patrick-kidger@users.noreply.github.com> Date: Fri, 6 Dec 2024 09:08:02 +0100 Subject: [PATCH 11/14] Updated pre-commit to handle jaxtyping update --- .pre-commit-config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index dec129e5..f12e8509 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -11,4 +11,4 @@ repos: rev: v1.1.350 hooks: - id: pyright - additional_dependencies: [equinox, jax, jaxtyping, optax, optimistix, lineax, pytest, typing_extensions] + additional_dependencies: [equinox, jax, jaxtyping, optax, optimistix, lineax, pytest, typeguard==2.13.3, typing_extensions] From 3d537145f51c19a0ef68f10bc1d8c7037fddc1fd Mon Sep 17 00:00:00 2001 From: Patrick Kidger <33688385+patrick-kidger@users.noreply.github.com> Date: Fri, 6 Dec 2024 09:39:49 +0100 Subject: [PATCH 12/14] version bump --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 434d6fbe..e1c7fa69 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "diffrax" -version = "0.6.0" +version = "0.6.1" description = "GPU+autodiff-capable ODE/SDE/CDE solvers written in JAX." readme = "README.md" requires-python ="~=3.9" From 69026202b6849b2c3aedb2f5a521f673be7d38ff Mon Sep 17 00:00:00 2001 From: Patrick Kidger <33688385+patrick-kidger@users.noreply.github.com> Date: Sun, 8 Dec 2024 03:36:31 +0100 Subject: [PATCH 13/14] Fixed where a nonbatchable check was being called. --- diffrax/_solver/runge_kutta.py | 2 +- test/test_global_interpolation.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/diffrax/_solver/runge_kutta.py b/diffrax/_solver/runge_kutta.py index d1e69467..11a9f6c8 100644 --- a/diffrax/_solver/runge_kutta.py +++ b/diffrax/_solver/runge_kutta.py @@ -964,7 +964,7 @@ def eval_k_jac(): assert implicit_tableau.a_diagonal[0] == 0 # pyright: ignore assert len(set(implicit_tableau.a_diagonal[1:])) == 1 # pyright: ignore jac_stage_index = 1 - stage_index = eqxi.nonbatchable(stage_index) + stage_index = eqxi.nonbatchable(stage_index) # These `stop_gradients` are needed to work around the lack of # symbolic zeros in `custom_vjp`s. if eval_fs: diff --git a/test/test_global_interpolation.py b/test/test_global_interpolation.py index 97f1938b..9c1c236c 100644 --- a/test/test_global_interpolation.py +++ b/test/test_global_interpolation.py @@ -340,7 +340,7 @@ def _test_dense_interpolation(solver, key, t1): @pytest.mark.parametrize("solver", all_ode_solvers + all_split_solvers) -def test_dense_interpolation(solver, getkey): +def test_dense_interpolation(solver): solver = implicit_tol(solver) key = jr.PRNGKey(5678) vals, true_vals, derivs, true_derivs = _test_dense_interpolation(solver, key, 1) From 5bc5c4436a32db1ec0c30e7439f90742431355f5 Mon Sep 17 00:00:00 2001 From: Patrick Kidger <33688385+patrick-kidger@users.noreply.github.com> Date: Sun, 8 Dec 2024 03:36:51 +0100 Subject: [PATCH 14/14] Bump minimum Equinox version to one that is compatible with latest JAX --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index e1c7fa69..0dd65df1 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -23,7 +23,7 @@ classifiers = [ "Topic :: Scientific/Engineering :: Mathematics", ] urls = {repository = "https://github.com/patrick-kidger/diffrax" } -dependencies = ["jax>=0.4.28", "jaxtyping>=0.2.24", "typing_extensions>=4.5.0", "typeguard==2.13.3", "equinox>=0.11.2", "lineax>=0.0.5", "optimistix>=0.0.7"] +dependencies = ["jax>=0.4.28", "jaxtyping>=0.2.24", "typing_extensions>=4.5.0", "typeguard==2.13.3", "equinox>=0.11.10", "lineax>=0.0.5", "optimistix>=0.0.7"] [build-system] requires = ["hatchling"]