From 8d7bbde01375e4ccb4f11b580c3c0269d89a6cd5 Mon Sep 17 00:00:00 2001 From: Daniel Weindl Date: Wed, 12 Jul 2023 07:49:08 +0200 Subject: [PATCH 01/30] Use cloudpickle for pickling dynesty sampler (#1094) Cloudpickle handles ABC-derived classes properly, whereas the latest dill version on pypi (0.3.6) does not. Cloudpickle is already installed with pypesto, so there seems to be no need to get dill on top. --- pypesto/sample/dynesty.py | 4 ++-- setup.cfg | 1 - 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/pypesto/sample/dynesty.py b/pypesto/sample/dynesty.py index 609087dc2..379944506 100644 --- a/pypesto/sample/dynesty.py +++ b/pypesto/sample/dynesty.py @@ -307,9 +307,9 @@ def get_mcmc_like_dynesty_samples(sampler) -> McmcPtResult: def setup_dynesty() -> None: """Import dynesty.""" try: - import dill # noqa: S403 + import cloudpickle # noqa: S403 import dynesty.utils - dynesty.utils.pickle_module = dill + dynesty.utils.pickle_module = cloudpickle except ImportError: raise SamplerImportError("dynesty") diff --git a/setup.cfg b/setup.cfg index 419fa296c..6194ed8bd 100644 --- a/setup.cfg +++ b/setup.cfg @@ -123,7 +123,6 @@ jax = emcee = emcee >= 3.0.2 dynesty = - dill >= 0.3.6 dynesty >= 2.0.3 mltools = umap-learn[plot] >= 0.5.3 From daf47dd40fdc9f3cfeb64e838099cfbd2530fa54 Mon Sep 17 00:00:00 2001 From: Maren Philipps <55318391+m-philipps@users.noreply.github.com> Date: Wed, 12 Jul 2023 15:58:31 +0200 Subject: [PATCH 02/30] Restrict fval magnitude in waterfall with order_by_id (#1090) * restrict waterfall with order_by_id to fvals < 1e100 * add constant for parameters/waterfall plot maximum value --- pypesto/C.py | 3 +++ pypesto/visualize/parameters.py | 4 ++-- pypesto/visualize/waterfall.py | 9 +++++++-- 3 files changed, 12 insertions(+), 4 deletions(-) diff --git a/pypesto/C.py b/pypesto/C.py index f034cfd00..61f4eb449 100644 --- a/pypesto/C.py +++ b/pypesto/C.py @@ -312,6 +312,9 @@ class InnerParameterType(str, Enum): ALL_CLUSTERED = 'all_clustered' # best + all that are in a cluster of size > 1 FIRST_CLUSTER = 'first_cluster' # all starts that belong to the first cluster +# waterfall max value +WATERFALL_MAX_VALUE = 1e100 + ############################################################################### # ENVIRONMENT VARIABLES diff --git a/pypesto/visualize/parameters.py b/pypesto/visualize/parameters.py index 150edd21c..306a6be86 100644 --- a/pypesto/visualize/parameters.py +++ b/pypesto/visualize/parameters.py @@ -10,7 +10,7 @@ from pypesto.util import delete_nan_inf -from ..C import RGBA +from ..C import RGBA, WATERFALL_MAX_VALUE from ..result import Result from .clust_color import assign_colors from .misc import ( @@ -276,7 +276,7 @@ def parameters_lowlevel( fvals=fvals, x=xs, xdim=len(ub) if ub is not None else 1, - magnitude_bound=1e100, + magnitude_bound=WATERFALL_MAX_VALUE, ) if size is None: diff --git a/pypesto/visualize/waterfall.py b/pypesto/visualize/waterfall.py index 4a22f2952..376946581 100644 --- a/pypesto/visualize/waterfall.py +++ b/pypesto/visualize/waterfall.py @@ -7,6 +7,7 @@ from pypesto.util import delete_nan_inf +from ..C import WATERFALL_MAX_VALUE from ..result import Result from .clust_color import RGBA, assign_colors from .misc import ( @@ -121,7 +122,9 @@ def waterfall( # parse input if order_by_id: start_ids = [s.id for s in results[j].optimize_result.list] - fvals_raw_is_finite = np.isfinite(fvals_raw) + fvals_raw_is_finite = np.isfinite(fvals_raw) & ( + np.absolute(fvals_raw) < WATERFALL_MAX_VALUE + ) fvals = [] for start_id in start_id_ordering: @@ -135,7 +138,9 @@ def waterfall( # also remove extremely large values. These values result in `inf` # values in the output of `scipy.cluster.hierarchy.linkage` in the # method `pypesto.util.assign_clusters`, which raises errors. - _, fvals = delete_nan_inf(fvals=fvals_raw, magnitude_bound=1e100) + _, fvals = delete_nan_inf( + fvals=fvals_raw, magnitude_bound=WATERFALL_MAX_VALUE + ) fvals.sort() # assign colors From 660862b03f86f4054f29513c7f265637491f2551 Mon Sep 17 00:00:00 2001 From: Daniel Weindl Date: Thu, 13 Jul 2023 09:47:43 +0200 Subject: [PATCH 03/30] Add startpoint_method to Problem (#1093) It's not intuitive that `x_guesses` is part of `Problem`, but `startpoint_method`s are handled separately. See also discussion in #1017. This patch * adds `startpoint_method` to `Problem` * during PEtab import, sets `Problem.startpoint_method` based on the PEtab problem * deprecates `startpoint_method` arguments where also `Problem` is passed Closes #1035 --- pypesto/optimize/ess/cess.py | 10 +++++++++- pypesto/optimize/ess/ess.py | 18 +++++++++++------- pypesto/optimize/ess/function_evaluator.py | 20 ++++++++++++++++---- pypesto/optimize/ess/sacess.py | 9 ++++++++- pypesto/optimize/optimize.py | 13 ++++++++++++- pypesto/petab/importer.py | 1 + pypesto/problem/base.py | 21 ++++++++++++++++++++- pypesto/startpoint/base.py | 13 ++++++++----- 8 files changed, 85 insertions(+), 20 deletions(-) diff --git a/pypesto/optimize/ess/cess.py b/pypesto/optimize/ess/cess.py index 1d5ef9798..225d8bf6f 100644 --- a/pypesto/optimize/ess/cess.py +++ b/pypesto/optimize/ess/cess.py @@ -4,6 +4,7 @@ import os import time from typing import Dict, List, Optional +from warnings import warn import numpy as np @@ -107,7 +108,7 @@ def _initialize(self): def minimize( self, problem: Problem, - startpoint_method: StartpointMethod, + startpoint_method: StartpointMethod = None, ) -> pypesto.Result: """Minimize the given objective using CESS. @@ -117,7 +118,14 @@ def minimize( Problem to run ESS on. startpoint_method: Method for choosing starting points. + **Deprecated. Use ``problem.startpoint_method`` instead.** """ + if startpoint_method is not None: + warn( + "Passing `startpoint_method` directly is deprecated, use `problem.startpoint_method` instead.", + DeprecationWarning, + ) + self._initialize() evaluator = FunctionEvaluator( diff --git a/pypesto/optimize/ess/ess.py b/pypesto/optimize/ess/ess.py index caa7bfb4d..130ad2a9d 100644 --- a/pypesto/optimize/ess/ess.py +++ b/pypesto/optimize/ess/ess.py @@ -28,6 +28,7 @@ import logging import time from typing import List, Optional, Tuple +from warnings import warn import numpy as np @@ -183,21 +184,24 @@ def minimize( Problem to run ESS on. startpoint_method: Method for choosing starting points. + **Deprecated. Use ``problem.startpoint_method`` instead.** refset: The initial RefSet or ``None`` to auto-generate. """ + if startpoint_method is not None: + warn( + "Passing `startpoint_method` directly is deprecated, use `problem.startpoint_method` instead.", + DeprecationWarning, + ) + self._initialize() self.starttime = time.time() - if ( - refset is None and (problem is None or startpoint_method is None) - ) or ( - refset is not None - and (problem is not None or startpoint_method is not None) + if (refset is None and problem is None) or ( + refset is not None and problem is not None ): raise ValueError( - "Either `refset` or `problem` and `startpoint_method` " - "has to be provided." + "Either `refset` or `problem` has to be provided." ) # generate initial RefSet if not provided if refset is None: diff --git a/pypesto/optimize/ess/function_evaluator.py b/pypesto/optimize/ess/function_evaluator.py index ebb7191a5..fe6412a3e 100644 --- a/pypesto/optimize/ess/function_evaluator.py +++ b/pypesto/optimize/ess/function_evaluator.py @@ -5,6 +5,7 @@ from concurrent.futures import ThreadPoolExecutor from copy import deepcopy from typing import Optional, Sequence, Tuple +from warnings import warn import numpy as np @@ -31,17 +32,28 @@ class FunctionEvaluator: def __init__( self, problem: Problem, - startpoint_method: StartpointMethod, + startpoint_method: StartpointMethod = None, ): """Construct. Parameters ---------- - problem: The problem - startpoint_method: Method for choosing feasible parameters + problem: + The problem + startpoint_method: + Method for choosing feasible parameters + **Deprecated. Use ``problem.startpoint_method`` instead.** """ + if startpoint_method is not None: + warn( + "Passing `startpoint_method` directly is deprecated, use `problem.startpoint_method` instead.", + DeprecationWarning, + ) + self.problem: Problem = problem - self.startpoint_method: StartpointMethod = startpoint_method + self.startpoint_method: StartpointMethod = ( + startpoint_method or problem.startpoint_method + ) self.n_eval: int = 0 self.n_eval_round: int = 0 diff --git a/pypesto/optimize/ess/sacess.py b/pypesto/optimize/ess/sacess.py index b477e2c5f..773f5b055 100644 --- a/pypesto/optimize/ess/sacess.py +++ b/pypesto/optimize/ess/sacess.py @@ -6,6 +6,7 @@ from multiprocessing import Manager, Process from multiprocessing.managers import SyncManager from typing import Any, Dict, List, Optional, Tuple +from warnings import warn import numpy as np @@ -96,9 +97,15 @@ def __init__( def minimize( self, problem: Problem, - startpoint_method: StartpointMethod, + startpoint_method: StartpointMethod = None, ): """Solve the given optimization problem.""" + if startpoint_method is not None: + warn( + "Passing `startpoint_method` directly is deprecated, use `problem.startpoint_method` instead.", + DeprecationWarning, + ) + start_time = time.time() logger.debug( f"Running sacess with {self.num_workers} " diff --git a/pypesto/optimize/optimize.py b/pypesto/optimize/optimize.py index 70456e6a9..eb0a74e14 100644 --- a/pypesto/optimize/optimize.py +++ b/pypesto/optimize/optimize.py @@ -1,5 +1,6 @@ import logging from typing import Callable, Iterable, Union +from warnings import warn from ..engine import Engine, SingleCoreEngine from ..history import HistoryOptions @@ -50,6 +51,7 @@ def minimize( startpoint_method: Method for how to choose start points. False means the optimizer does not require start points, e.g. for the 'PyswarmOptimizer'. + **Deprecated. Use ``problem.startpoint_method`` instead.** result: A result object to append the optimization results to. For example, one might append more runs to a previous optimization. If None, @@ -88,7 +90,16 @@ def minimize( # startpoint method if startpoint_method is None: - startpoint_method = uniform + if problem.startpoint_method is None: + startpoint_method = uniform + else: + startpoint_method = problem.startpoint_method + else: + warn( + "Passing `startpoint_method` directly is deprecated, use `problem.startpoint_method` instead.", + DeprecationWarning, + ) + # convert startpoint method to class instance startpoint_method = to_startpoint_method(startpoint_method) diff --git a/pypesto/petab/importer.py b/pypesto/petab/importer.py index 9c496318e..cdc6b19cf 100644 --- a/pypesto/petab/importer.py +++ b/pypesto/petab/importer.py @@ -740,6 +740,7 @@ def create_problem( x_names=x_ids, x_scales=x_scales, x_priors_defs=prior, + startpoint_method=self.create_startpoint_method(), **problem_kwargs, ) diff --git a/pypesto/problem/base.py b/pypesto/problem/base.py index ae3e2004a..ab802eee8 100644 --- a/pypesto/problem/base.py +++ b/pypesto/problem/base.py @@ -1,12 +1,21 @@ import copy import logging -from typing import Iterable, List, Optional, SupportsFloat, SupportsInt, Union +from typing import ( + Callable, + Iterable, + List, + Optional, + SupportsFloat, + SupportsInt, + Union, +) import numpy as np import pandas as pd from ..objective import ObjectiveBase from ..objective.priors import NegLogParameterPriors +from ..startpoint import StartpointMethod, to_startpoint_method, uniform SupportsFloatIterableOrValue = Union[Iterable[SupportsFloat], SupportsFloat] SupportsIntIterableOrValue = Union[Iterable[SupportsInt], SupportsInt] @@ -60,6 +69,9 @@ class Problem: copy_objective: Whethter to generate a deep copy of the objective function before potential modification the problem class performs on it. + startpoint_method: + Method for how to choose start points. ``False`` means the optimizer + does not require start points, e.g. for the ``PyswarmOptimizer``. Notes ----- @@ -90,6 +102,7 @@ def __init__( lb_init: Union[np.ndarray, List[float], None] = None, ub_init: Union[np.ndarray, List[float], None] = None, copy_objective: bool = True, + startpoint_method: Union[StartpointMethod, Callable, bool] = None, ): if copy_objective: objective = copy.deepcopy(objective) @@ -147,6 +160,12 @@ def __init__( self.normalize() self._check_x_guesses() + # startpoint method + if startpoint_method is None: + startpoint_method = uniform + # convert startpoint method to class instance + self.startpoint_method = to_startpoint_method(startpoint_method) + @property def lb(self) -> np.ndarray: """Return lower bounds of free parameters.""" diff --git a/pypesto/startpoint/base.py b/pypesto/startpoint/base.py index 038232915..d8ecde27f 100644 --- a/pypesto/startpoint/base.py +++ b/pypesto/startpoint/base.py @@ -1,13 +1,16 @@ """Startpoint base classes.""" +from __future__ import annotations from abc import ABC, abstractmethod -from typing import Callable, Union +from typing import TYPE_CHECKING, Callable, Union import numpy as np from ..C import FVAL, GRAD from ..objective import ObjectiveBase -from ..problem import Problem + +if TYPE_CHECKING: + import pypesto class StartpointMethod(ABC): @@ -21,7 +24,7 @@ class StartpointMethod(ABC): def __call__( self, n_starts: int, - problem: Problem, + problem: pypesto.problem.Problem, ) -> np.ndarray: """Generate startpoints. @@ -42,7 +45,7 @@ class NoStartpoints(StartpointMethod): def __call__( self, n_starts: int, - problem: Problem, + problem: pypesto.problem.Problem, ) -> np.ndarray: """Generate a (n_starts, dim) nan matrix.""" startpoints = np.full(shape=(n_starts, problem.dim), fill_value=np.nan) @@ -78,7 +81,7 @@ def __init__( def __call__( self, n_starts: int, - problem: Problem, + problem: pypesto.problem.Problem, ) -> np.ndarray: """Generate checked startpoints.""" # shape: (n_guesses, dim) From c7a88ead25385b043e0dea1a9b46a3bb4719c796 Mon Sep 17 00:00:00 2001 From: Doresic <85789271+Doresic@users.noreply.github.com> Date: Thu, 13 Jul 2023 18:29:52 +0200 Subject: [PATCH 04/30] Small initialize fix (#1095) Censoring bounds should not be reinitialized when calculators are reinitialized. --- pypesto/hierarchical/optimal_scaling/parameter.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/pypesto/hierarchical/optimal_scaling/parameter.py b/pypesto/hierarchical/optimal_scaling/parameter.py index 8cfa07915..5d2be9291 100644 --- a/pypesto/hierarchical/optimal_scaling/parameter.py +++ b/pypesto/hierarchical/optimal_scaling/parameter.py @@ -88,4 +88,5 @@ def __init__( def initialize(self): """Initialize.""" - self.value = self.dummy_value + if self.censoring_type is None: + self.value = self.dummy_value From 2609562a57d3bbcf97eb935bc65da047b4f018cd Mon Sep 17 00:00:00 2001 From: Paul Jonas Jost <70631928+PaulJonasJost@users.noreply.github.com> Date: Fri, 21 Jul 2023 12:48:03 +0200 Subject: [PATCH 05/30] Added Falco et al to bib. (#1100) --- doc/using_pypesto.bib | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/doc/using_pypesto.bib b/doc/using_pypesto.bib index 614053325..bb19094d9 100644 --- a/doc/using_pypesto.bib +++ b/doc/using_pypesto.bib @@ -1,3 +1,19 @@ +@Article{FalcoCoh2023, + author = {Falc{\'o}, Carles AND Cohen, Daniel J AND Carrillo, Jos{\'e} A AND Baker, Ruth E}, + journal = {Journal of the Royal Society Interface}, + title = {Quantifying tissue growth, shape and collision via continuum models and Bayesian inference}, + year = {2023}, + month = {07}, + number = {1}, + pages = {1-12}, + volume = {20}, + abstract = {Although tissues are usually studied in isolation, this situation rarely occursin biology, as cells, tissues and organs coexist and interact across scales todetermine both shape and function. Here, we take a quantitative approachcombining data from recent experiments, mathematical modelling andBayesian parameter inference, to describe the self-assembly of multiple epi-thelial sheets by growth and collision. We use two simple and well-studiedcontinuum models, where cells move either randomly or following popu-lation pressure gradients. After suitable calibration, both models prove tobe practically identifiable, and can reproduce the main features of singletissue expansions. However, our findings reveal that whenever tissue–tissue interactions become relevant, the random motion assumption canlead to unrealistic behaviour. Under this setting, a model accounting forpopulation pressure from different cell populations is more appropriateand shows a better agreement with experimental measurements. Finally,we discuss how tissue shape and pressure affect multi-tissue collisions.Our work thus provides a systematic approach to quantify and predictcomplex tissue configurations with applications in the design of tissuecomposites and more generally in tissue engineering.}, + timestamp = {2023-07-20}, + doi = {10.1098/rsif.2023.0184}, + publisher = {The Royal Society}, + url = {https://doi.org/10.1098/rsif.2023.0184}, +} + @Article{LakrisenkoSta2023, author = {Lakrisenko, Polina AND Stapor, Paul AND Grein, Stephan AND Paszkowski, Łukasz AND Pathirana, Dilan AND Fröhlich, Fabian AND Lines, Glenn Terje AND Weindl, Daniel AND Hasenauer, Jan}, journal = {PLOS Computational Biology}, From bfec420644c9e8374f739e4306ba74048eff9bf8 Mon Sep 17 00:00:00 2001 From: Polina Lakrisenko Date: Thu, 27 Jul 2023 16:03:24 +0200 Subject: [PATCH 06/30] fix storage (#1099) --- pypesto/store/save_to_hdf5.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pypesto/store/save_to_hdf5.py b/pypesto/store/save_to_hdf5.py index b154d2441..86e116e8d 100644 --- a/pypesto/store/save_to_hdf5.py +++ b/pypesto/store/save_to_hdf5.py @@ -138,7 +138,7 @@ def write(self, result: Result, overwrite=False): if key == 'history': continue if isinstance(start[key], np.ndarray): - write_float_array(start_grp, key, start[key]) + write_array(start_grp, key, start[key]) elif start[key] is not None: start_grp.attrs[key] = start[key] f.flush() From 234634b5f8fa7e5dae7f373103add6df1e37aa22 Mon Sep 17 00:00:00 2001 From: Doresic <85789271+Doresic@users.noreply.github.com> Date: Fri, 4 Aug 2023 11:38:48 +0200 Subject: [PATCH 07/30] Hierarchical parameter plot fix (#1106) * Fix parameter plot If, in any case (because some inner optimization failed, simulation failed, or some other reason) and there is a`optimize_result`dictionary in `result.optmize_result.list` which doesn't contain the `INNER_PARAMETERS` key and its item, the parameter plot would fail at line 381. This is a fix to make it robust to this. If any of the `optimize_result` objects has a `INNER_PARAMETER` key, then the other ones will be filled with NaN values, and plotted. * Dilan review change Co-authored-by: Dilan Pathirana <59329744+dilpath@users.noreply.github.com> * Update pypesto/visualize/parameters.py Co-authored-by: Daniel Weindl * Add comments * Add comment Testing the quality check * Fix quality check error --------- Co-authored-by: Dilan Pathirana <59329744+dilpath@users.noreply.github.com> Co-authored-by: Daniel Weindl --- pypesto/objective/priors.py | 8 ++++++-- pypesto/visualize/parameters.py | 28 ++++++++++++++++++++-------- 2 files changed, 26 insertions(+), 10 deletions(-) diff --git a/pypesto/objective/priors.py b/pypesto/objective/priors.py index d2c591027..8f340a330 100644 --- a/pypesto/objective/priors.py +++ b/pypesto/objective/priors.py @@ -272,20 +272,24 @@ def dd_log_f_log(x_log): + np.exp(x_log) * dd_log_f_ddx(np.exp(x_log)) ) - res_log = None if res is not None: def res_log(x_log): """Residual-prior for log-parameters.""" return res(np.exp(x_log)) - d_res_log = None + else: + res_log = None + if d_res_dx is not None: def d_res_log(x_log): """Residual-prior for log-parameters.""" return d_res_dx(np.exp(x_log)) * np.exp(x_log) + else: + d_res_log = None + return { 'index': index, 'density_fun': log_f_log, diff --git a/pypesto/visualize/parameters.py b/pypesto/visualize/parameters.py index 306a6be86..52509116f 100644 --- a/pypesto/visualize/parameters.py +++ b/pypesto/visualize/parameters.py @@ -10,7 +10,7 @@ from pypesto.util import delete_nan_inf -from ..C import RGBA, WATERFALL_MAX_VALUE +from ..C import INNER_PARAMETERS, RGBA, WATERFALL_MAX_VALUE from ..result import Result from .clust_color import assign_colors from .misc import ( @@ -377,15 +377,27 @@ def handle_inputs( fvals = result.optimize_result.fval xs = result.optimize_result.x # retrieve inner parameters if available - try: - inner_xs = result.optimize_result.inner_parameters - inner_xs_names = list(inner_xs[0].keys()) - inner_xs = [list(inner_xs_idx.values()) for inner_xs_idx in inner_xs] + inner_xs = [ + res.get(INNER_PARAMETERS, None) for res in result.optimize_result.list + ] + if any(inner_xs): + # search for first non-empty inner_xs to obtain inner_xs_names + for inner_xs_idx in inner_xs: + if inner_xs_idx is not None: + inner_xs_names = list(inner_xs_idx.keys()) + break + # fill inner_xs with nan if no inner_xs are available + inner_xs = [ + np.full(len(inner_xs_names), np.nan) + if inner_xs_idx is None + else list(inner_xs_idx.values()) + for inner_xs_idx in inner_xs + ] + # set bounds for inner parameters inner_lb = np.full(len(inner_xs_names), -np.inf) inner_ub = np.full(len(inner_xs_names), np.inf) - except AttributeError: + else: inner_xs = None - # parse indices which should be plotted if start_indices is not None: start_indices = process_start_indices(result, start_indices) @@ -429,7 +441,7 @@ def handle_inputs( ub = np.concatenate([ub, inner_ub]) x_labels = x_labels + inner_xs_names xs_out = [ - np.concatenate([x, inner_x]) + np.concatenate([x, inner_x]) if x is not None else None for x, inner_x in zip(xs_out, inner_xs_out) ] From 8c70d76aafd2e6675beeeabc793ccde0ac09bb8d Mon Sep 17 00:00:00 2001 From: Daniel Weindl Date: Mon, 7 Aug 2023 13:47:16 +0200 Subject: [PATCH 08/30] Fix startpoint sampling for hierarchical optimization (#1105) * Fix startpoint sampling for hierarchical optimization See #1096 * fixed pars * fixup --------- Co-authored-by: Doresic <85789271+Doresic@users.noreply.github.com> --- pypesto/petab/importer.py | 25 ++++++++++++++++++++++--- 1 file changed, 22 insertions(+), 3 deletions(-) diff --git a/pypesto/petab/importer.py b/pypesto/petab/importer.py index cdc6b19cf..fd1e812be 100644 --- a/pypesto/petab/importer.py +++ b/pypesto/petab/importer.py @@ -631,20 +631,37 @@ def create_prior(self) -> Union[NegLogParameterPriors, None]: else: return None - def create_startpoint_method(self, **kwargs) -> StartpointMethod: + def create_startpoint_method( + self, x_ids: Sequence[str] = None, **kwargs + ) -> StartpointMethod: """Create a startpoint method. Parameters ---------- + x_ids: + If provided, create a startpoint method that only samples the + parameters with the given IDs. **kwargs: Additional keyword arguments passed on to :meth:`pypesto.startpoint.FunctionStartpoints.__init__`. """ def startpoint_method(n_starts: int, **kwargs): - return petab.sample_parameter_startpoints( + startpoints = petab.sample_parameter_startpoints( self.petab_problem.parameter_df, n_starts=n_starts ) + if x_ids is None: + return startpoints + + # subset parameters according to the provided parameter IDs + from petab.C import ESTIMATE + + parameter_df = self.petab_problem.parameter_df + pars_to_estimate = list( + parameter_df.index[parameter_df[ESTIMATE] == 1] + ) + x_idxs = [pars_to_estimate.index(x_id) for x_id in x_ids] + return startpoints[:, x_idxs] return FunctionStartpoints(function=startpoint_method, **kwargs) @@ -740,7 +757,9 @@ def create_problem( x_names=x_ids, x_scales=x_scales, x_priors_defs=prior, - startpoint_method=self.create_startpoint_method(), + startpoint_method=self.create_startpoint_method( + x_ids=np.delete(x_ids, x_fixed_indices) + ), **problem_kwargs, ) From 2eb0d15f4aa636f873785a3c1e9e7afce281755f Mon Sep 17 00:00:00 2001 From: Paul Jonas Jost <70631928+PaulJonasJost@users.noreply.github.com> Date: Tue, 8 Aug 2023 10:07:00 +0200 Subject: [PATCH 09/30] PetabJL integration (#1089) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * SingleCore engine works, multicore has problems with pickling even though manual pickling works * intermediate commit * Working tests. * small changes needs verification * created base test to check for integration into python. * Added julia module file for test * Added test for objective function evaluation * Added values for evaluation * Added installation of packages to Workflow. * Readded the Julia files that for some reason were deleted. * Removed PetabJL from default pypesto.petab import * Temporariy added amici as dependency. Needs to be taken care of appropriately. * Moved Importer to objective/julia * Deactivated precompilation in test * Integrated suggestions * add comments * add sundials to ci --------- Co-authored-by: Yannik Schälte <31767307+yannikschaelte@users.noreply.github.com> --- .github/workflows/ci.yml | 7 +- .../Boehm_validation/Gradient.csv | 2 + .../Boehm_validation/Hessian.csv | 10 + .../Boehm_validation/ObjectiveValue.csv | 2 + .../Boehm_validation/Parameter.csv | 2 + .../conversion_reaction/PEtabJl_module.jl | 20 ++ pypesto/objective/julia/__init__.py | 1 + pypesto/objective/julia/petabJl.py | 215 ++++++++++++ pypesto/objective/julia/petab_jl_importer.py | 322 ++++++++++++++++++ test/julia/test_pyjulia.py | 101 +++++- 10 files changed, 675 insertions(+), 7 deletions(-) create mode 100644 doc/example/boehm_JProteomeRes2014/Boehm_validation/Gradient.csv create mode 100644 doc/example/boehm_JProteomeRes2014/Boehm_validation/Hessian.csv create mode 100644 doc/example/boehm_JProteomeRes2014/Boehm_validation/ObjectiveValue.csv create mode 100644 doc/example/boehm_JProteomeRes2014/Boehm_validation/Parameter.csv create mode 100644 doc/example/conversion_reaction/PEtabJl_module.jl create mode 100644 pypesto/objective/julia/petabJl.py create mode 100644 pypesto/objective/julia/petab_jl_importer.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 9a434d82e..4e6d48125 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -100,7 +100,7 @@ jobs: - name: Install julia uses: julia-actions/setup-julia@v1 with: - version: 1.7 + version: 1.9 - name: Cache uses: actions/cache@v3 @@ -113,8 +113,11 @@ jobs: - name: Install dependencies run: .github/workflows/install_deps.sh + - name: Install PEtabJL dependencies + run: julia -e 'using Pkg; Pkg.add("PEtab"); Pkg.add("OrdinaryDiffEq"), Pkg.add("Sundials")' + - name: Run tests - timeout-minutes: 20 + timeout-minutes: 25 run: tox -e julia - name: Coverage diff --git a/doc/example/boehm_JProteomeRes2014/Boehm_validation/Gradient.csv b/doc/example/boehm_JProteomeRes2014/Boehm_validation/Gradient.csv new file mode 100644 index 000000000..1699b6631 --- /dev/null +++ b/doc/example/boehm_JProteomeRes2014/Boehm_validation/Gradient.csv @@ -0,0 +1,2 @@ +Epo_degradation_BaF3,k_exp_hetero,k_exp_homo,k_imp_hetero,k_imp_homo,k_phos,sd_pSTAT5A_rel,sd_pSTAT5B_rel,sd_rSTAT5A_rel +-226.01431847863805,0.03263295726678998,0.05074978988074719,-273.3251522968395,-4.9353233689552945e-5,85.33308210815652,-57.82373022138993,6.47910944243548,1.5327970845176904 diff --git a/doc/example/boehm_JProteomeRes2014/Boehm_validation/Hessian.csv b/doc/example/boehm_JProteomeRes2014/Boehm_validation/Hessian.csv new file mode 100644 index 000000000..3cd15a7d3 --- /dev/null +++ b/doc/example/boehm_JProteomeRes2014/Boehm_validation/Hessian.csv @@ -0,0 +1,10 @@ +Epo_degradation_BaF3,k_exp_hetero,k_exp_homo,k_imp_hetero,k_imp_homo,k_phos,sd_pSTAT5A_rel,sd_pSTAT5B_rel,sd_rSTAT5A_rel +2348.781845248937,-0.034169780647049425,-103.24202100672939,2772.675796487632,7.194796260472683e-5,-938.3560377189202,996.659728857624,31.143959976782426,13.030712117968559 +-0.034169780647049425,0.07739858784002018,-0.15899501912479183,0.7386693785162849,-4.187803035168086e-8,-0.17134098751539498,-0.2564122376627509,0.03372069395138544,0.07241122210747836 +-103.24202100672939,-0.15899501912479183,132.944794430612,95.49012010074641,-2.508362770407691e-6,-22.250883365424308,11.34374075166351,-3.886786248018129,-7.690665859911962 +2772.675796487632,0.7386693785162849,95.49012010074641,3563.661917245381,1.092950395076315e-5,-1110.2044314822922,1202.406495619125,41.717823566223906,14.58452306207908 +7.194796260472683e-5,-4.187803035168086e-8,-2.508362770407691e-6,1.092950395076315e-5,0.00011364116982094509,-0.00016740979955329535,0.0001089554236616266,0.00011027946613432109,8.045150373694503e-6 +-938.3560377189202,-0.17134098751539498,-22.250883365424308,-1110.2044314822922,-0.00016740979955329535,965.7762449769793,-416.0316410076297,-6.62255869644657,29.6808324053416 +996.659728857624,-0.2564122376627509,11.34374075166351,1202.406495619125,0.0001089554236616266,-416.0316410076297,435.9488576495015,0.0,0.0 +31.143959976782426,0.03372069395138544,-3.886786248018129,41.717823566223906,0.00011027946613432109,-6.62255869644657,0.0,139.82333729022352,0.0 +13.030712117968559,0.07241122210747836,-7.690665859911962,14.58452306207908,8.045150373694503e-6,29.6808324053416,0.0,0.0,162.6019478340014 diff --git a/doc/example/boehm_JProteomeRes2014/Boehm_validation/ObjectiveValue.csv b/doc/example/boehm_JProteomeRes2014/Boehm_validation/ObjectiveValue.csv new file mode 100644 index 000000000..8344862a3 --- /dev/null +++ b/doc/example/boehm_JProteomeRes2014/Boehm_validation/ObjectiveValue.csv @@ -0,0 +1,2 @@ +ObjectiveValue +149.05022585636098 diff --git a/doc/example/boehm_JProteomeRes2014/Boehm_validation/Parameter.csv b/doc/example/boehm_JProteomeRes2014/Boehm_validation/Parameter.csv new file mode 100644 index 000000000..48fc5a4f2 --- /dev/null +++ b/doc/example/boehm_JProteomeRes2014/Boehm_validation/Parameter.csv @@ -0,0 +1,2 @@ +Epo_degradation_BaF3,k_exp_hetero,k_exp_homo,k_imp_hetero,k_imp_homo,k_phos,sd_pSTAT5A_rel,sd_pSTAT5B_rel,sd_rSTAT5A_rel +-1.665827601408055,-4.999704893599998,-2.2096987817000167,-1.78600654750001,4.9901140088,4.1977354885,0.5857552705999998,0.8189828191999999,0.49868440400000047 diff --git a/doc/example/conversion_reaction/PEtabJl_module.jl b/doc/example/conversion_reaction/PEtabJl_module.jl new file mode 100644 index 000000000..155ba776b --- /dev/null +++ b/doc/example/conversion_reaction/PEtabJl_module.jl @@ -0,0 +1,20 @@ +module MyPEtabJlModule + +using OrdinaryDiffEq +using Sundials +using PEtab + +pathYaml = "/Users/pauljonasjost/Documents/GitHub_Folders/pyPESTO/test/julia/../../doc/example/conversion_reaction/conversion_reaction.yaml" +petabModel = readPEtabModel(pathYaml, verbose=true) + +# A full list of options for createPEtabODEProblem can be found at https://sebapersson.github.io/PEtab.jl/dev/API_choosen/#PEtab.setupPEtabODEProblem +petabProblem = createPEtabODEProblem( + petabModel, + odeSolverOptions=ODESolverOptions(Rodas5P(), abstol=1e-08, reltol=1e-08, maxiters=Int64(1e4)), + gradientMethod=:ForwardDiff, + hessianMethod=:ForwardDiff, + sparseJacobian=nothing, + verbose=true +) + +end diff --git a/pypesto/objective/julia/__init__.py b/pypesto/objective/julia/__init__.py index 0512fc866..fbd2dcc82 100644 --- a/pypesto/objective/julia/__init__.py +++ b/pypesto/objective/julia/__init__.py @@ -3,3 +3,4 @@ =============== """ from .base import JuliaObjective, display_source_ipython +from .petabJl import PEtabJlObjective diff --git a/pypesto/objective/julia/petabJl.py b/pypesto/objective/julia/petabJl.py new file mode 100644 index 000000000..344c78f71 --- /dev/null +++ b/pypesto/objective/julia/petabJl.py @@ -0,0 +1,215 @@ +"""Interface to PEtab.jl.""" +import logging +import os + +import numpy as np + +from .base import JuliaObjective, _read_source + +logger = logging.getLogger(__name__) + +PEtabProblemJl = ["PEtab.jl::PEtabODEProblem"] + + +class PEtabJlObjective(JuliaObjective): + """ + Wrapper around an objective defined in PEtab.jl. + + Parameters + ---------- + module: + Name of the julia module containing the objective. + source_file: + Julia source file. Defaults to "{module}.jl". + petab_problem_name: + Name of the petab problem variable in the julia module. + """ + + def __init__( + self, + module: str, + source_file: str = None, + petab_problem_name: str = "petabProblem", + precompile: bool = True, + force_compile: bool = False, + ): + """Initialize objective.""" + # lazy imports + try: + from julia import Main, Pkg # noqa: F401 + + Pkg.activate(".") + except ImportError: + raise ImportError( + "Install PyJulia, e.g. via `pip install pypesto[julia]`, " + "and see the class documentation", + ) + + self.module = module + self.source_file = source_file + self._petab_problem_name = petab_problem_name + if precompile: + self.precompile_model(force_compile=force_compile) + + if self.source_file is None: + self.source_file = f"{module}.jl" + + # Include module if not already included + _read_source(module, source_file) + + petab_jl_problem = self.get(petab_problem_name) + self.petab_jl_problem = petab_jl_problem + + # get functions + fun = self.petab_jl_problem.computeCost + grad = self.petab_jl_problem.computeGradient + hess = self.petab_jl_problem.computeHessian + x_names = np.asarray(self.petab_jl_problem.θ_estNames) + + # call the super super super constructor + super(JuliaObjective, self).__init__( + fun=fun, grad=grad, hess=hess, x_names=x_names + ) + + def __getstate__(self): + """Get state for pickling.""" + # if not dumped, dump it via JLD2 + return { + 'module': self.module, + 'source_file': self.source_file, + '_petab_problem_name': self._petab_problem_name, + } + + def __setstate__(self, state): + """Set state from pickling.""" + for key, value in state.items(): + setattr(self, key, value) + # lazy imports + try: + from julia import Main # noqa: F401 + from julia import Pkg + + Pkg.activate(".") + except ImportError: + raise ImportError( + "Install PyJulia, e.g. via `pip install pypesto[julia]`, " + "and see the class documentation", + ) + # Include module if not already included + _read_source(self.module, self.source_file) + + petab_jl_problem = self.get(self._petab_problem_name) + self.petab_jl_problem = petab_jl_problem + + # get functions + fun = self.petab_jl_problem.computeCost + grad = self.petab_jl_problem.computeGradient + hess = self.petab_jl_problem.computeHessian + x_names = np.asarray(self.petab_jl_problem.θ_estNames) + + # call the super super constructor + super(JuliaObjective, self).__init__(fun, grad, hess, x_names) + + def __deepcopy__(self, memodict=None): + """Deepcopy.""" + return PEtabJlObjective( + module=self.module, + source_file=self.source_file, + petab_problem_name=self._petab_problem_name, + precompile=False, + ) + + def precompile_model(self, force_compile: bool = False): + """ + Use Julias PrecompilationTools to precompile the relevant code. + + Only needs to be done once, and speeds up Julia loading drastically. + """ + directory = os.path.dirname(self.source_file) + # check whether precompilation is necessary, if the directory exists + if ( + os.path.exists(f"{directory}/{self.module}_pre") + and not force_compile + ): + logger.info("Precompilation module already exists.") + return None + # lazy imports + try: + from julia import Main # noqa: F401 + except ImportError: + raise ImportError( + "Install PyJulia, e.g. via `pip install pypesto[julia]`, " + "and see the class documentation", + ) + # setting up a local project, where the precompilation will be done in + from julia import Pkg + + Pkg.activate(".") + # create a Project f"{self.module}_pre". + try: + Pkg.generate(f"{directory}/{self.module}_pre") + except Exception: + logger.info("Module is already generated. Skipping generate...") + # Adjust the precompilation file + write_precompilation_module( + module=self.module, + source_file_orig=self.source_file, + ) + # add a new line at the top of the original module to use the + # precompiled module + with open(self.source_file, "r") as read_f: + if read_f.readline().endswith("_pre\n"): + with open("dummy_temp_file.jl", "w+") as write_f: + write_f.write(f"using {self.module}_pre\n\n") + write_f.write(read_f.read()) + os.remove(self.source_file) + os.rename("dummy_temp_file.jl", self.source_file) + + try: + Pkg.develop(path=f"{directory}/{self.module}_pre") + except Exception: + logger.info("Module is already developed. Skipping develop...") + Pkg.activate(f"{directory}/{self.module}_pre/") + # add dependencies + Pkg.add("PrecompileTools") + Pkg.add("OrdinaryDiffEq") + Pkg.add("PEtab") + Pkg.add("Sundials") + Pkg.precompile() + + +def write_precompilation_module(module, source_file_orig): + """Write the precompilation module for the PEtabJl module.""" + # read the original source file + with open(source_file_orig) as f: + lines = np.array(f.readlines()) + # path to the yaml file + yaml_path = "\t".join(lines[["yaml" in line for line in lines]]) + # packages + packages = "\t\t".join( + lines[[line.startswith("using ") for line in lines]] + ) + # get everything in between the packages and the end line + start = int(np.argwhere([line.startswith("using ") for line in lines])[-1]) + end = int(np.argwhere([line.startswith("end") for line in lines])[0]) + petab_loading = "\t\t".join(lines[start:end]) + + content = ( + f"module {module}_pre\n\n" + f"using PrecompileTools\n\n" + f"# Reduce time for reading a PEtabModel and for " + f"building a PEtabODEProblem\n" + f"@setup_workload begin\n" + f"\t{yaml_path}" + f"\t@compile_workload begin\n" + f"\t\t{packages}" + f"\t\t{petab_loading}" + f"\tend\n" + f"end\n\n" + f"end\n" + ) + # get the directory of the source file + directory = os.path.dirname(source_file_orig) + # write file + with open(f"{directory}/{module}_pre/src/{module}_pre.jl", "w") as f: + f.write(content) diff --git a/pypesto/objective/julia/petab_jl_importer.py b/pypesto/objective/julia/petab_jl_importer.py new file mode 100644 index 000000000..3b8f2c1d2 --- /dev/null +++ b/pypesto/objective/julia/petab_jl_importer.py @@ -0,0 +1,322 @@ +"""Contains the PetabJlImporter class.""" +from __future__ import annotations + +import logging +import os.path +from typing import Iterable, List, Optional, Tuple, Union + +import numpy as np + +from pypesto.objective.julia import PEtabJlObjective +from pypesto.problem import Problem + +logger = logging.getLogger(__name__) + +PEtabProblemJl = ["PEtab.jl::PEtabODEProblem"] + + +class PetabJlImporter: + """ + Importer for PEtab models in Julia, using PEtab.jl. + + Create an `objective.JuliaObjective` or a `pypesto.Problem` from PEtab + files or from a julia module. + """ + + def __init__( + self, + module: str = None, + source_file: str = None, + petab_problem_name: str = "petabProblem", + ): + """ + Initialize importer. + + Parameters + ---------- + module: + Name of the Julia model + source_file: + Path to the Julia source file. + petab_problem: + Wrapper around the PEtab.jl problem. + """ + self.module = module + self.source_file = source_file + self._petab_problem_name = petab_problem_name + # placeholder for the petab.jl problem + self.petab_jl_problem = None + + @staticmethod + def from_yaml( + yaml_file: str, + odeSolverOptions: Optional[dict] = None, + gradientMethod: Optional[str] = None, + hessianMethod: Optional[str] = None, + sparseJacobian: Optional[bool] = None, + verbose: Optional[bool] = None, + directory: Optional[str] = None, + ) -> PetabJlImporter: + """ + Create a `PetabJlImporter` from a yaml file. + + Writes the Julia module to a file in `directory` and returns a + `PetabJlImporter` for that module. + + Parameters + ---------- + yaml_file: + The yaml file of the PEtab problem + odeSolverOptions: + Dictionary like options for the ode solver in julia + gradientMethod, hessianMethod: + Julia methods to compute gradient and hessian + sparseJacobian: + Whether to compute sparse Jacobians + verbose: + Whether to have a more informative log. + directory: + Where to write the julia file, defaults to the directory of the + yaml file. + """ + # get default values + options = _get_default_options( + odeSolverOptions=odeSolverOptions, + gradientMethod=gradientMethod, + hessianMethod=hessianMethod, + sparseJacobian=sparseJacobian, + verbose=verbose, + ) + + # write julia module + source_file, module = _write_julia_file( + yaml_file=yaml_file, options=options, directory=directory + ) + + return PetabJlImporter( + module=module, + source_file=source_file, + ) + + def create_objective( + self, precompile: Optional[bool] = True + ) -> PEtabJlObjective: + """ + Create a `pypesto.objective.PEtabJlObjective` from the PEtab.jl problem. + + The objective function will be the negative log likelihood or the + negative log posterior, depending on the PEtab.jl problem. + + Parameters + ---------- + precompile: + Whether to precompile the julia module for speed up in + multistart optimization. + + """ + # lazy imports + try: + from julia import Main # noqa: F401 + except ImportError: + raise ImportError( + "Install PyJulia, e.g. via `pip install pypesto[julia]`, " + "and see the class documentation", + ) + if self.source_file is None: + self.source_file = f"{self.module}.jl" + + if not os.path.exists(self.source_file): + raise ValueError( + "The julia file does not exist. You can create " + "it from a petab yaml file path using " + "`PetabJlImporter.from_yaml(yaml_file)`" + ) + + obj = PEtabJlObjective( + module=self.module, + source_file=self.source_file, + petab_problem_name=self._petab_problem_name, + precompile=precompile, + ) + + self.petab_jl_problem = obj.petab_jl_problem + return obj + + def create_problem( + self, + x_guesses: Optional[Iterable[float]] = None, + lb_init: Union[np.ndarray, List[float], None] = None, + ub_init: Union[np.ndarray, List[float], None] = None, + precompile: Optional[bool] = True, + ) -> Problem: + """ + Create a `pypesto.Problem` from the PEtab.jl problem. + + Parameters + ---------- + x_guesses: + Guesses for the parameter values, shape (g, dim), where g denotes the + number of guesses. These are used as start points in the optimization. + lb_init, ub_init: + The lower and upper bounds for initialization, typically for defining + search start points. + If not set, set to lb, ub. + precompile: + Whether to precompile the julia module for speed up in + multistart optimization. + """ + obj = self.create_objective(precompile=precompile) + lb = np.asarray(self.petab_jl_problem.lowerBounds) + ub = np.asarray(self.petab_jl_problem.upperBounds) + + return Problem( + objective=obj, + lb=lb, + ub=ub, + x_guesses=x_guesses, + x_names=obj.x_names, + lb_init=lb_init, + ub_init=ub_init, + ) + + +def _get_default_options( + odeSolverOptions: Union[dict, None] = None, + gradientMethod: Union[str, None] = None, + hessianMethod: Union[str, None] = None, + sparseJacobian: Union[str, None] = None, + verbose: Union[str, None] = None, +) -> dict: + """ + If values are not specified, get default values for the options. + + Additionally check that the values are valid. + + Parameters + ---------- + odeSolverOptions: + Options for the ODE solver. + gradientMethod: + Method for gradient calculation. + hessianMethod: + Method for hessian calculation. + sparseJacobian: + Whether the jacobian should be sparse. + verbose: + Whether to print verbose output. + + Returns + ------- + dict: + The options. + """ + # get default values + if odeSolverOptions is None: + odeSolverOptions = { + "solver": "Rodas5P", + "abstol": 1e-8, + "reltol": 1e-8, + "maxiters": "Int64(1e4)", + } + if not odeSolverOptions["solver"].endswith("()"): + odeSolverOptions["solver"] += "()" # add parentheses + if gradientMethod is None: + gradientMethod = "nothing" + if hessianMethod is None: + hessianMethod = "nothing" + if sparseJacobian is None: + sparseJacobian = "nothing" + if verbose is None: + verbose = "true" + + # check values for gradientMethod and hessianMethod + allowed_gradient_methods = [ + "ForwardDiff", + "ForwardEquations", + "Adjoint", + "Zygote", + ] + if gradientMethod not in allowed_gradient_methods: + logger.warning( + f"gradientMethod {gradientMethod} is not in " + f"{allowed_gradient_methods}. Defaulting to ForwardDiff." + ) + gradientMethod = "ForwardDiff" + allowed_hessian_methods = ["ForwardDiff", "BlocForwardDiff", "GaussNewton"] + if hessianMethod not in allowed_hessian_methods: + logger.warning( + f"hessianMethod {hessianMethod} is not in " + f"{allowed_hessian_methods}. Defaulting to ForwardDiff." + ) + hessianMethod = "ForwardDiff" + + # fill options + options = { + "odeSolverOptions": odeSolverOptions, + "gradientMethod": gradientMethod, + "hessianMethod": hessianMethod, + "sparseJacobian": sparseJacobian, + "verbose": verbose, + } + return options + + +def _write_julia_file( + yaml_file: str, options: dict, directory: str +) -> Tuple[str, str]: + """ + Write the Julia file. + + Parameters + ---------- + yaml_file: + The yaml file of the PEtab problem. + options: + The options. + dir: + The directory to write the file to. + + Returns + ------- + source_file: + The name/path of the file. + module: + The module name. + """ + if directory is None: + directory = os.path.dirname(yaml_file) # directory of the yaml file + source_file = os.path.join(directory, "PEtabJl_module.jl") + module = "MyPEtabJlModule" + + link_to_options = ( + "https://sebapersson.github.io/" + "PEtab.jl/dev/API_choosen/#PEtab.setupPEtabODEProblem" + ) + odeSolvOpt_str = ", ".join( + [f"{k}={v}" for k, v in options["odeSolverOptions"].items()] + ) + # delete "solver=" from string + odeSolvOpt_str = odeSolvOpt_str.replace("solver=", "") + + content = ( + f"module {module}\n\n" + f"using OrdinaryDiffEq\n" + f"using Sundials\n" + f"using PEtab\n\n" + f"pathYaml = \"{yaml_file}\"\n" + f"petabModel = readPEtabModel(pathYaml, verbose=true)\n\n" + f"# A full list of options for createPEtabODEProblem can be " + f"found at {link_to_options}\n" + f"petabProblem = createPEtabODEProblem(\n\t" + f"petabModel,\n\t" + f"odeSolverOptions=ODESolverOptions({odeSolvOpt_str}),\n\t" + f"gradientMethod=:{options['gradientMethod']},\n\t" + f"hessianMethod=:{options['hessianMethod']},\n\t" + f"sparseJacobian={options['sparseJacobian']},\n\t" + f"verbose={options['verbose']}\n)\n\nend\n" + ) + # write file + with open(source_file, "w") as f: + f.write(content) + + return source_file, module diff --git a/test/julia/test_pyjulia.py b/test/julia/test_pyjulia.py index 5405ca60a..f72b4d601 100644 --- a/test/julia/test_pyjulia.py +++ b/test/julia/test_pyjulia.py @@ -1,8 +1,11 @@ +import os + import numpy as np from pypesto import Problem, optimize from pypesto.engine import MultiProcessEngine, SingleCoreEngine from pypesto.objective.julia import JuliaObjective, display_source_ipython +from pypesto.objective.julia.petab_jl_importer import PetabJlImporter # The pyjulia wrapper appears to ignore global noqas, thus per line here @@ -13,13 +16,14 @@ def test_pyjulia_pipeline(): rng = np.random.default_rng(42) assert display_source_ipython( # noqa: S101 - "doc/example/model_julia/LR.jl" + f"{os.path.dirname(__file__)}/../../doc/example/model_julia/LR.jl" ) # define objective obj = JuliaObjective( module="LR", - source_file="doc/example/model_julia/LR.jl", + source_file=f"{os.path.dirname(__file__)}/../../" + f"doc/example/model_julia/LR.jl", fun="fun", grad="grad", ) @@ -33,13 +37,17 @@ def test_pyjulia_pipeline(): # define problem lb, ub = [-5.0] * n_p, [5.0] * n_p - problem = Problem(obj, lb=lb, ub=ub) + # create 10 random starting points within the bounds + x_guesses = rng.uniform(lb, ub, size=(10, n_p)) + problem = Problem(obj, lb=lb, ub=ub, x_guesses=x_guesses) # optimize - result = optimize.minimize(problem, engine=SingleCoreEngine()) + result = optimize.minimize(problem, engine=SingleCoreEngine(), n_starts=10) # use parallelization - result2 = optimize.minimize(problem, engine=MultiProcessEngine()) + result2 = optimize.minimize( + problem, engine=MultiProcessEngine(), n_starts=10 + ) # check results match assert np.allclose( # noqa: S101 @@ -52,3 +60,86 @@ def test_pyjulia_pipeline(): # check with analytical value p_opt = obj.get("p_opt") assert np.allclose(result.optimize_result[0].x, p_opt) # noqa: S101 + + +def test_petabJL_interface(): + """Test the interface to PEtab.jl with provided solutions from julia.""" + model_name = "boehm_JProteomeRes2014" + examples_dir = f"{os.path.dirname(__file__)}/../../doc/example" + yaml_file = f"{examples_dir}/{model_name}/{model_name}.yaml" + + importer = PetabJlImporter.from_yaml(yaml_file) + + problem = importer.create_problem(precompile=False) + + parameters = np.genfromtxt( + f'{examples_dir}/{model_name}/Boehm_validation/Parameter.csv', + delimiter=',', + skip_header=1, + ) + + # check objective function + obj_ref = np.genfromtxt( + f'{examples_dir}/{model_name}/Boehm_validation/ObjectiveValue.csv', + delimiter=',', + skip_header=1, + ) + obj = problem.objective(parameters, sensi_orders=(0,)) + + assert np.allclose(obj, obj_ref) # noqa: S101 + + # check gradient value + grad_ref = np.genfromtxt( + f'{examples_dir}/{model_name}/Boehm_validation/Gradient.csv', + delimiter=',', + skip_header=1, + ) + grad = problem.objective(parameters, sensi_orders=(1,)) + + assert np.allclose(grad, grad_ref) # noqa: S101 + + # check hessian value + hess_ref = np.genfromtxt( + f'{examples_dir}/{model_name}/Boehm_validation/Hessian.csv', + delimiter=',', + skip_header=1, + ) + hess = problem.objective(parameters, sensi_orders=(2,)) + + assert np.allclose(hess, hess_ref) # noqa: S101 + + +def test_petabJL_from_module(): + """Test that PEtab.jl is integrated properly.""" + # create objective + module = "MyPEtabJlModule" + source_file = ( + f"{os.path.dirname(__file__)}/../../doc/" + f"example/conversion_reaction/PEtabJl_module.jl" + ) + + importer = PetabJlImporter(module=module, source_file=source_file) + + problem = importer.create_problem(precompile=False) + + # optimize with single core + optimize.minimize(problem, engine=SingleCoreEngine(), n_starts=2) + # optimize with multi core + optimize.minimize( + problem, engine=MultiProcessEngine(n_procs=1), n_starts=2 + ) + + +def test_petabJL_from_yaml(): + """Test that PEtab.jl from yaml file is running smoothly.""" + yaml_file = ( + f"{os.path.dirname(__file__)}/../../doc/" + f"example/conversion_reaction/conversion_reaction.yaml" + ) + + importer = PetabJlImporter.from_yaml(yaml_file) + + problem = importer.create_problem(precompile=False) + + # optimize with single core + optimize.minimize(problem, engine=SingleCoreEngine(), n_starts=1) From cc9b702d96ec5954dc2c6d4abbf42a0d6997515f Mon Sep 17 00:00:00 2001 From: Maren Philipps <55318391+m-philipps@users.noreply.github.com> Date: Tue, 22 Aug 2023 14:18:29 +0200 Subject: [PATCH 10/30] Fix #1108 (#1109) * enable setting the y limits of a waterfall plot by using the y_limits argument * use default y limits for zoomed in starts * fix #1108 Co-authored-by: Paul Jonas Jost <70631928+PaulJonasJost@users.noreply.github.com> --- pypesto/visualize/misc.py | 4 ++-- pypesto/visualize/waterfall.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/pypesto/visualize/misc.py b/pypesto/visualize/misc.py index b1134d944..d2fbbe348 100644 --- a/pypesto/visualize/misc.py +++ b/pypesto/visualize/misc.py @@ -185,8 +185,8 @@ def process_y_limits(ax, y_limits): "log-scale. Using only upper bound." ) - # set limits - ax.set_ylim(y_limits) + # set limits + ax.set_ylim(y_limits) else: # No limits passed, but if we have a result list: check the limits diff --git a/pypesto/visualize/waterfall.py b/pypesto/visualize/waterfall.py index 376946581..f4247ec0e 100644 --- a/pypesto/visualize/waterfall.py +++ b/pypesto/visualize/waterfall.py @@ -169,7 +169,7 @@ def waterfall( ax = handle_options(ax, max_len_fvals, refs, y_limits, offset_y) if inset_axes is not None: inset_axes = handle_options( - inset_axes, n_starts_to_zoom, refs, y_limits, offset_y + inset_axes, n_starts_to_zoom, refs, None, offset_y ) if any(legends): From 09bfa4cf0af586cca3ed6a54f871286eadda76aa Mon Sep 17 00:00:00 2001 From: Daniel Weindl Date: Thu, 24 Aug 2023 08:17:45 +0200 Subject: [PATCH 11/30] SacessOptimizer: retry reading, delay deleting (#1110) * delete temporary files only after *all* were read successfully * retry reading temp file upon error to work around potential filesystem latency issues --- pypesto/optimize/ess/sacess.py | 22 ++++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/pypesto/optimize/ess/sacess.py b/pypesto/optimize/ess/sacess.py index 773f5b055..205936009 100644 --- a/pypesto/optimize/ess/sacess.py +++ b/pypesto/optimize/ess/sacess.py @@ -173,10 +173,17 @@ def _create_result(self, problem: Problem) -> pypesto.Result: tmp_result_filename = SacessWorker.get_temp_result_filename( worker_idx ) - tmp_result = read_result( - tmp_result_filename, problem=False, optimize=True - ) - os.remove(tmp_result_filename) + try: + tmp_result = read_result( + tmp_result_filename, problem=False, optimize=True + ) + except FileNotFoundError: + # wait and retry, maybe the file wasn't found due to some filesystem latency issues + time.sleep(5) + tmp_result = read_result( + tmp_result_filename, problem=False, optimize=True + ) + if result is None: result = tmp_result else: @@ -185,6 +192,13 @@ def _create_result(self, problem: Problem) -> pypesto.Result: sort=False, prefix=f"{worker_idx}-", ) + + # delete temporary files only after successful consolidation + for filename in map( + SacessWorker.get_temp_result_filename, range(self.num_workers) + ): + os.remove(filename) + result.optimize_result.sort() result.problem = problem From 787028d400c72caad890a29cb654112ba244459e Mon Sep 17 00:00:00 2001 From: Daniel Weindl Date: Thu, 24 Aug 2023 18:20:56 +0200 Subject: [PATCH 12/30] SacessOptimizer: Fix logging with multiprocessing (#1112) * SacessOptimizer: Fix logging with multiprocessing * Fix: `ValueError: setting an array element with a sequence.` --- pypesto/optimize/ess/function_evaluator.py | 3 +- pypesto/optimize/ess/sacess.py | 39 ++++++++++++++++++---- test/optimize/test_optimize.py | 1 + 3 files changed, 35 insertions(+), 8 deletions(-) diff --git a/pypesto/optimize/ess/function_evaluator.py b/pypesto/optimize/ess/function_evaluator.py index fe6412a3e..e11ac2c49 100644 --- a/pypesto/optimize/ess/function_evaluator.py +++ b/pypesto/optimize/ess/function_evaluator.py @@ -115,9 +115,8 @@ def multiple_random(self, n: int) -> Tuple[np.array, np.array]: """ fxs = np.full(shape=n, fill_value=np.nan) xs = np.full(shape=(n, self.problem.dim), fill_value=np.nan) - while not np.isfinite(fxs).all(): - retry_indices = np.argwhere(~np.isfinite(fxs)).squeeze() + retry_indices = np.argwhere(~np.isfinite(fxs)).flatten() xs[retry_indices] = self.startpoint_method( n_starts=retry_indices.size, problem=self.problem ) diff --git a/pypesto/optimize/ess/sacess.py b/pypesto/optimize/ess/sacess.py index 205936009..7b8cde97d 100644 --- a/pypesto/optimize/ess/sacess.py +++ b/pypesto/optimize/ess/sacess.py @@ -1,6 +1,8 @@ """Self-adaptive cooperative enhanced scatter search (SACESS).""" import itertools import logging +import logging.handlers +import multiprocessing import os import time from multiprocessing import Manager, Process @@ -115,6 +117,17 @@ def minimize( num_workers=self.num_workers, dim=problem.dim ) + logging_handler = logging.StreamHandler() + logging_handler.setFormatter( + logging.Formatter( + '%(asctime)s %(name)s %(levelname)-8s %(message)s' + ) + ) + logging_thread = logging.handlers.QueueListener( + multiprocessing.Queue(-1), logging_handler + ) + logging_thread.start() + # shared memory manager to handle shared state # (simulates the sacess manager process) with Manager() as shmem_manager: @@ -130,6 +143,7 @@ def minimize( ess_kwargs=ess_kwargs, worker_idx=i, max_walltime_s=self.max_walltime_s, + loglevel=self.sacess_loglevel, ess_loglevel=self.ess_loglevel, ) for i, ess_kwargs in enumerate(ess_init_args) @@ -143,7 +157,7 @@ def minimize( worker, problem, startpoint_method, - self.sacess_loglevel, + logging_thread.queue, ), ) for i, worker in enumerate(workers) @@ -154,6 +168,8 @@ def minimize( for p in worker_processes: p.join() + logging_thread.stop() + walltime = time.time() - start_time logger.info( f"sacess stopping after {walltime:3g}s with global best " @@ -362,6 +378,7 @@ class SacessWorker: _n_sent_solutions: Number of solutions sent to the Manager. _max_walltime_s: Walltime limit. _logger: A Logger instance. + _loglevel: Logging level for sacess _ess_loglevel: Logging level for ESS runs """ @@ -371,6 +388,7 @@ def __init__( ess_kwargs: Dict[str, Any], worker_idx: int, max_walltime_s: float = np.inf, + loglevel: int = logging.INFO, ess_loglevel: int = logging.WARNING, ): self._manager = manager @@ -383,16 +401,19 @@ def __init__( self._n_sent_solutions = 0 self._max_walltime_s = max_walltime_s self._start_time = None - self._logger = logging.getLogger(str(os.getpid())) - # Set the manager logger to one created within the current process - self._manager._logger = self._logger + self._loglevel = loglevel self._ess_loglevel = ess_loglevel + self._logger = None def run( self, problem: Problem, startpoint_method: StartpointMethod, ): + self._logger.setLevel(self._loglevel) + # Set the manager logger to one created within the current process + self._manager._logger = self._logger + """Start the worker.""" self._logger.debug( f"#{self._worker_idx} starting " f"({self._ess_kwargs})." @@ -502,6 +523,9 @@ def _run_ess( ) ess = ESSOptimizer(**ess_kwargs) + ess.logger = self._logger.getChild( + f"sacess-{self._worker_idx:02d}-ess" + ) ess.logger.setLevel(self._ess_loglevel) cur_ess_results = ess.minimize( @@ -592,7 +616,7 @@ def _run_worker( worker: SacessWorker, problem: Problem, startpoint_method: StartpointMethod, - sacess_loglevel: int, + log_process_queue: multiprocessing.Queue, ): """Run the given SACESS worker. @@ -601,7 +625,10 @@ def _run_worker( # different random seeds per process np.random.seed((os.getpid() * int(time.time() * 1000)) % 2**32) - worker._logger.setLevel(sacess_loglevel) + # Forward log messages to logging process + h = logging.handlers.QueueHandler(log_process_queue) + worker._logger = logging.getLogger(multiprocessing.current_process().name) + worker._logger.addHandler(h) return worker.run(problem=problem, startpoint_method=startpoint_method) diff --git a/test/optimize/test_optimize.py b/test/optimize/test_optimize.py index f051e7525..a14eae8ad 100644 --- a/test/optimize/test_optimize.py +++ b/test/optimize/test_optimize.py @@ -492,6 +492,7 @@ def test_ess(problem, local_optimizer, ess_type, request): ess = SacessOptimizer( max_walltime_s=1, sacess_loglevel=logging.DEBUG, + ess_loglevel=logging.WARNING, ess_init_args=ess_init_args, ) else: From b624087e58cf88e77ff046c40210aa4428595f7b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yannik=20Sch=C3=A4lte?= <31767307+yannikschaelte@users.noreply.github.com> Date: Fri, 25 Aug 2023 15:28:40 +0200 Subject: [PATCH 13/30] Other platform tests (#1113) * blind attempt mac * brew installs * try python 3.11 numba * try windows * fix cache * stuff * stuff * stuff * stuff * minimal test * add basic workflow test * Update .github/workflows/ci.yml Co-authored-by: Daniel Weindl * close figures --------- Co-authored-by: Daniel Weindl --- .github/workflows/ci.yml | 62 ++++++++++++- .github/workflows/install_deps.sh | 18 +++- test/base/test_workflow.py | 142 ++++++++++++++++++++++++++++++ tox.ini | 10 +++ 4 files changed, 226 insertions(+), 6 deletions(-) create mode 100644 test/base/test_workflow.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 4e6d48125..ec4710d23 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -17,8 +17,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - # update to 3.11 when numba allows (needed in umap) - python-version: ['3.9', '3.10'] + python-version: ['3.9', '3.11'] steps: - name: Check out repository @@ -48,6 +47,65 @@ jobs: token: ${{ secrets.CODECOV_TOKEN }} file: ./coverage.xml + mac: + runs-on: macos-latest + strategy: + matrix: + python-version: ['3.11'] + + steps: + - name: Check out repository + uses: actions/checkout@v3 + + - name: Prepare python ${{ matrix.python-version }} + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python-version }} + + - name: Cache + uses: actions/cache@v3 + with: + path: ~/.cache + key: ${{ runner.os }}-${{ matrix.python-version }}-ci + + - name: Install dependencies + run: .github/workflows/install_deps.sh amici + + - name: Run tests + timeout-minutes: 30 + run: tox -e base + + - name: Coverage + uses: codecov/codecov-action@v3 + with: + token: ${{ secrets.CODECOV_TOKEN }} + file: ./coverage.xml + + windows: + runs-on: windows-latest + strategy: + matrix: + python-version: ['3.11'] + + steps: + - name: Check out repository + uses: actions/checkout@v3 + + - name: Prepare python ${{ matrix.python-version }} + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python-version }} + + - name: Install dependencies + run: | + pip install --upgrade pip + pip install tox + + - name: Run tests + shell: bash + timeout-minutes: 10 + run: tox -e windows + petab: runs-on: ubuntu-latest strategy: diff --git a/.github/workflows/install_deps.sh b/.github/workflows/install_deps.sh index 09957e254..468534a9c 100755 --- a/.github/workflows/install_deps.sh +++ b/.github/workflows/install_deps.sh @@ -9,8 +9,14 @@ pip install wheel setuptools # Used to create local test environments pip install tox -# Update apt -sudo apt-get update +# Update package lists +if [ "$(uname)" == "Darwin" ]; then + # MacOS + brew update +else + # Linux + sudo apt-get update +fi # Check arguments for par in "$@"; do @@ -22,8 +28,12 @@ for par in "$@"; do amici) # for amici - sudo apt-get install \ - swig libatlas-base-dev libhdf5-serial-dev + if [ "$(uname)" == "Darwin" ]; then + brew install swig hdf5 libomp + else + sudo apt-get install \ + swig libatlas-base-dev libhdf5-serial-dev + fi ;; ipopt) diff --git a/test/base/test_workflow.py b/test/base/test_workflow.py new file mode 100644 index 000000000..5f3764734 --- /dev/null +++ b/test/base/test_workflow.py @@ -0,0 +1,142 @@ +"""Test a basic workflow, with minimum dependencies. + +These tests are not for correctness, but for basic functionality. +""" + +from functools import wraps + +import matplotlib.pyplot as plt + +import pypesto +import pypesto.optimize as optimize +import pypesto.profile as profile +import pypesto.sample as sample +import pypesto.visualize as visualize + +from ..util import CRProblem + + +def close_fig(fun): + """Close figure.""" + + @wraps(fun) + def wrapped_fun(*args, **kwargs): + ret = fun(*args, **kwargs) + plt.close('all') + return ret + + return wrapped_fun + + +def test_objective(): + """Test a simple objective function.""" + crproblem = CRProblem() + obj = crproblem.get_objective() + p = crproblem.p_true + + assert obj(p) == crproblem.get_fnllh()(p) + assert obj(p, sensi_orders=(0,)) == crproblem.get_fnllh()(p) + assert (obj(p, sensi_orders=(1,)) == crproblem.get_fsnllh()(p)).all() + assert (obj(p, sensi_orders=(2,)) == crproblem.get_fs2nllh()(p)).all() + fval, grad = obj(p, sensi_orders=(0, 1)) + assert fval == crproblem.get_fnllh()(p) + assert (grad == crproblem.get_fsnllh()(p)).all() + + +@close_fig +def test_optimize(): + """Test a simple multi-start optimization.""" + crproblem = CRProblem() + problem = pypesto.Problem( + objective=crproblem.get_objective(), + lb=crproblem.lb, + ub=crproblem.ub, + ) + optimizer = optimize.ScipyOptimizer() + n_start = 20 + result = optimize.minimize( + problem=problem, + optimizer=optimizer, + n_starts=n_start, + ) + + # check basic sanity + assert len(result.optimize_result.list) == n_start + assert len(result.optimize_result.fval) == n_start + assert len(result.optimize_result.x) == n_start + + # check that the results are sorted + fvals = result.optimize_result.fval + assert fvals == sorted(fvals) + + # check that optimization was successful + assert fvals[0] < crproblem.get_fnllh()(crproblem.p_true) + + # visualize the results + visualize.waterfall(result) + + +@close_fig +def test_profile(): + """Test a simple profile calculation.""" + crproblem = CRProblem() + problem = pypesto.Problem( + objective=crproblem.get_objective(), + lb=crproblem.lb, + ub=crproblem.ub, + ) + optimizer = optimize.ScipyOptimizer() + n_starts = 5 + result = optimize.minimize( + problem=problem, + optimizer=optimizer, + n_starts=n_starts, + ) + profile_result = profile.parameter_profile( + problem=problem, + result=result, + optimizer=optimizer, + profile_index=[0], + ) + + # check basic sanity + assert len(profile_result.profile_result.list) == 1 + + # visualize the results + visualize.profiles(profile_result) + + +@close_fig +def test_sample(): + """Test a simple sampling.""" + crproblem = CRProblem() + problem = pypesto.Problem( + objective=crproblem.get_objective(), + lb=crproblem.lb, + ub=crproblem.ub, + ) + optimizer = optimize.ScipyOptimizer() + n_start = 5 + result = optimize.minimize( + problem=problem, + optimizer=optimizer, + n_starts=n_start, + ) + sampler = sample.AdaptiveMetropolisSampler() + n_samples = 500 + sample_result = sample.sample( + problem=problem, + result=result, + sampler=sampler, + n_samples=n_samples, + ) + + # check basic sanity + assert sample_result.sample_result.trace_x.shape == ( + 1, + n_samples + 1, + len(crproblem.p_true), + ) + + # visualize the results + visualize.sampling_1d_marginals(sample_result) diff --git a/tox.ini b/tox.ini index d5b8817a9..9866525c1 100644 --- a/tox.ini +++ b/tox.ini @@ -61,6 +61,16 @@ commands = description = Test basic functionality +[testenv:windows] +extras = test +commands = + pytest \ + test/base/test_prior.py \ + test/base/test_problem.py \ + test/base/test_workflow.py +description = + Test basic functionality on Windows + [testenv:petab] extras = test,amici,petab,pyswarm deps = From 1e2712d941f9213c1abe23b041dc0250a3de4c7d Mon Sep 17 00:00:00 2001 From: Daniel Weindl Date: Thu, 31 Aug 2023 17:06:21 +0200 Subject: [PATCH 14/30] SacessOptimizer: tmpdir option (#1115) SacessOptimizer: * Add option to pass a custom directory for temporary files * Make the default temporary file paths unique, to avoid name collisions when running multiple SacessOptimizer instances from within the same working directory --- pypesto/optimize/ess/sacess.py | 60 +++++++++++++++++++++++++--------- 1 file changed, 45 insertions(+), 15 deletions(-) diff --git a/pypesto/optimize/ess/sacess.py b/pypesto/optimize/ess/sacess.py index 7b8cde97d..34b5941ec 100644 --- a/pypesto/optimize/ess/sacess.py +++ b/pypesto/optimize/ess/sacess.py @@ -7,7 +7,9 @@ import time from multiprocessing import Manager, Process from multiprocessing.managers import SyncManager -from typing import Any, Dict, List, Optional, Tuple +from pathlib import Path +from typing import Any, Dict, List, Optional, Tuple, Union +from uuid import uuid1 from warnings import warn import numpy as np @@ -49,6 +51,7 @@ def __init__( max_walltime_s: float = np.inf, sacess_loglevel: int = logging.INFO, ess_loglevel: int = logging.WARNING, + tmpdir: Union[Path, str] = None, ): """Construct. @@ -75,6 +78,11 @@ def __init__( Loglevel for ESS runs. sacess_loglevel: Loglevel for SACESS runs. + tmpdir: + Directory for temporary files. Defaults to a directory in the current + working directory named ``SacessOptimizerTemp-{random suffix}``. + When setting this option, make sure any optimizers running in parallel + have unique tmpdirs. """ if (num_workers is None and ess_init_args is None) or ( num_workers is not None and ess_init_args is not None @@ -96,6 +104,13 @@ def __init__( self.sacess_loglevel = sacess_loglevel logger.setLevel(self.sacess_loglevel) + self._tmpdir = tmpdir + if self._tmpdir is None: + while self._tmpdir is None or self._tmpdir.exists(): + self._tmpdir = Path(f"SacessOptimizerTemp-{str(uuid1())[:8]}") + self._tmpdir = Path(self._tmpdir).absolute() + self._tmpdir.mkdir(parents=True, exist_ok=True) + def minimize( self, problem: Problem, @@ -141,12 +156,15 @@ def minimize( SacessWorker( manager=sacess_manager, ess_kwargs=ess_kwargs, - worker_idx=i, + worker_idx=worker_idx, max_walltime_s=self.max_walltime_s, loglevel=self.sacess_loglevel, ess_loglevel=self.ess_loglevel, + tmp_result_file=SacessWorker.get_temp_result_filename( + worker_idx, self._tmpdir + ), ) - for i, ess_kwargs in enumerate(ess_init_args) + for worker_idx, ess_kwargs in enumerate(ess_init_args) ] # launch worker processes worker_processes = [ @@ -187,7 +205,7 @@ def _create_result(self, problem: Problem) -> pypesto.Result: result = None for worker_idx in range(self.num_workers): tmp_result_filename = SacessWorker.get_temp_result_filename( - worker_idx + worker_idx, self._tmpdir ) try: tmp_result = read_result( @@ -210,10 +228,16 @@ def _create_result(self, problem: Problem) -> pypesto.Result: ) # delete temporary files only after successful consolidation - for filename in map( - SacessWorker.get_temp_result_filename, range(self.num_workers) - ): + for worker_idx in range(self.num_workers): + filename = SacessWorker.get_temp_result_filename( + worker_idx, self._tmpdir + ) os.remove(filename) + # delete tmpdir if empty + try: + self._tmpdir.rmdir() + except OSError: + pass result.optimize_result.sort() @@ -380,6 +404,7 @@ class SacessWorker: _logger: A Logger instance. _loglevel: Logging level for sacess _ess_loglevel: Logging level for ESS runs + _tmp_result_file: Path of a temporary file to be created. """ def __init__( @@ -390,6 +415,7 @@ def __init__( max_walltime_s: float = np.inf, loglevel: int = logging.INFO, ess_loglevel: int = logging.WARNING, + tmp_result_file: str = None, ): self._manager = manager self._worker_idx = worker_idx @@ -404,6 +430,7 @@ def __init__( self._loglevel = loglevel self._ess_loglevel = ess_loglevel self._logger = None + self._tmp_result_file = tmp_result_file def run( self, @@ -458,12 +485,13 @@ def run( ess_results.optimize_result.list = ( ess_results.optimize_result.list[:50] ) - write_result( - ess_results, - self.get_temp_result_filename(self._worker_idx), - overwrite=True, - optimize=True, - ) + if self._tmp_result_file: + write_result( + ess_results, + self._tmp_result_file, + overwrite=True, + optimize=True, + ) # check if the best solution of the last local ESS is sufficiently # better than the sacess-wide best solution self.maybe_update_best(ess.x_best, ess.fx_best) @@ -608,8 +636,10 @@ def _keep_going(self): return True @staticmethod - def get_temp_result_filename(worker_idx: int) -> str: - return f"sacess-{worker_idx:02d}_tmp.h5" + def get_temp_result_filename( + worker_idx: int, tmpdir: Union[str, Path] + ) -> str: + return str(Path(tmpdir, f"sacess-{worker_idx:02d}_tmp.h5").absolute()) def _run_worker( From 30fc11b35b6ce7d65ac5e88e5f616b98aace9359 Mon Sep 17 00:00:00 2001 From: Paul Jonas Jost <70631928+PaulJonasJost@users.noreply.github.com> Date: Fri, 1 Sep 2023 10:10:22 +0200 Subject: [PATCH 15/30] Notebook on differences (#1098) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Notebook on differences * simplify some parts; add some more details and visualizations * minor edit * add workflow comparison to docs * integrated suggestions * integrated suggestions 2 * fixup * removed personal info. changed nlop objective appropriatly --------- Co-authored-by: Yannik Schälte <31767307+yannikschaelte@users.noreply.github.com> Co-authored-by: Yannik Schaelte --- doc/example.rst | 1 + doc/example/workflow_comparison.ipynb | 2275 +++++++++++++++++++++++++ 2 files changed, 2276 insertions(+) create mode 100644 doc/example/workflow_comparison.ipynb diff --git a/doc/example.rst b/doc/example.rst index 8e01b9676..f48c1d0cb 100644 --- a/doc/example.rst +++ b/doc/example.rst @@ -27,6 +27,7 @@ Getting started example/getting_started.ipynb example/custom_objective_function.ipynb + example/workflow_comparison.ipynb PEtab and AMICI --------------- diff --git a/doc/example/workflow_comparison.ipynb b/doc/example/workflow_comparison.ipynb new file mode 100644 index 000000000..9461a59c6 --- /dev/null +++ b/doc/example/workflow_comparison.ipynb @@ -0,0 +1,2275 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# pyPESTO vs no pyPESTO\n", + "\n", + "The objectives of this notebook are twofold:\n", + "\n", + "1. **General Workflow:** We walk step-by-step through a process to estimate parameters of dynamical models. By following this workflow, you will gain a clear understanding of the essential steps involved and how they contribute to the overall outcome.\n", + "\n", + "2. **Benefits of pyPESTO:** Throughout the notebook, we highlight the key advantages of using pyPESTO in each step of the workflow, compared to \"doing things manually\". By leveraging its capabilities, you can significantly increase efficiency and effectiveness when solving your parameter optimization tasks.\n", + "\n", + "This notebook is divided into several sections, each focusing on a specific aspect of the parameter estimation workflow. Here's an overview of what you find in each section:\n", + "\n", + "**Contents**\n", + "\n", + "1. **Objective Function:** We discuss the creation of an objective function that quantifies the goodness-of-fit between a model and observed data. We will demonstrate how pyPESTO simplifies this potentially cumbersome process and provides various options for objective function definition.\n", + "\n", + "2. **Optimization:** We show how to find optimal model parameters. We illustrate the general workflow and how pyPESTO allows to flexibly use different optimizers and to analyze and interpret results.\n", + "\n", + "3. **Profiling:** After a successful parameter optimization, we show how pyPESTO provides profile likelihood functionality to assess uncertainty and identifiability of selected parameters.\n", + "\n", + "4. **Sampling:** In addition to profiles, we use MCMC to sample from the Bayesian posterior distribution. We show how pyPESTO facilitates the use of different sampling methods.\n", + "\n", + "5. **Result Storage:** This section focuses on storing and organizing the results obtained from the parameter optimization workflow, which is necessary to keep results for later processing and sharing.\n", + "\n", + "By the end of this notebook, you'll have gained valuable insights into the parameter estimation workflow for dynamical models. Moreover, you'll have a clear understanding of the benefits pyPESTO brings to each step of this workflow. This tutorial will equip you with the knowledge and tools necessary to streamline your parameter estimation tasks and obtain accurate and reliable results." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# install dependencies\n", + "#!pip install pypesto[amici,petab]" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2023-07-13T09:24:44.842827Z", + "start_time": "2023-07-13T09:24:44.811471Z" + }, + "jupyter": { + "outputs_hidden": false + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# imports\n", + "import logging\n", + "import os\n", + "import random\n", + "from pprint import pprint\n", + "\n", + "import amici\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import petab\n", + "import scipy.optimize\n", + "from IPython.display import Markdown, display\n", + "\n", + "import pypesto.optimize as optimize\n", + "import pypesto.petab\n", + "import pypesto.profile as profile\n", + "import pypesto.sample as sample\n", + "import pypesto.store as store\n", + "import pypesto.visualize as visualize\n", + "import pypesto.visualize.model_fit as model_fit\n", + "\n", + "mpl.rcParams['figure.dpi'] = 100\n", + "mpl.rcParams['font.size'] = 18\n", + "\n", + "# for reproducibility\n", + "random.seed(1912)\n", + "np.random.seed(1912)\n", + "\n", + "# name of the model\n", + "model_name = \"boehm_JProteomeRes2014\"\n", + "\n", + "# output directory\n", + "model_output_dir = \"tmp/\" + model_name" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Create an objective function\n", + "\n", + "As application problem, we consider the model by [Böhm et al., JProteomRes 2014](https://pubs.acs.org/doi/abs/10.1021/pr5006923), which describes, trained on quantitative mass spectronomy data, the process of dimerization of phosphorylated STAT5A and STAT5B, important transductors of activation signals of cytokine receptors to the nucleus. The model is available via the [PEtab benchmark collection](https://github.com/Benchmarking-Initiative/Benchmark-Models-PEtab). For simulation, we use [AMICI](https://github.com/AMICI-dev/AMICI), an efficient ODE simulation and sensitivity calculation routine. [PEtab](https://github.com/PEtab-dev/PEtab) is a data format specification that standardises parameter estimation problems in systems biology.." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Without pyPESTO\n", + "\n", + "To fit an (ODE) model to data, the model needs to be implemented in a simulation program as a function mapping parameters to simulated data. Simulations must then be mapped to experimentally observed data via formulation of a single-value cost function (e.g. squared or absolute differences, corresponding to a normal or Laplace measurement noise model).\n", + "Loading the model via PEtab and AMICI already simplifies these stepss substantially compared to encoding the model and the objective function manually:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2023-07-13T09:24:47.602789Z", + "start_time": "2023-07-13T09:24:47.547768Z" + }, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-08-25 15:26:01.472 - amici.petab_import - INFO - Importing model ...\n", + "2023-08-25 15:26:01.473 - amici.petab_import - INFO - Validating PEtab problem ...\n", + "2023-08-25 15:26:01.558 - amici.petab_import - INFO - Model name is 'FullModel'.\n", + "Writing model code to '/Users/pauljonasjost/Documents/GitHub_Folders/pyPESTO/doc/example/amici_models/FullModel'.\n", + "2023-08-25 15:26:01.560 - amici.petab_import - INFO - Species: 8\n", + "2023-08-25 15:26:01.562 - amici.petab_import - INFO - Global parameters: 15\n", + "2023-08-25 15:26:01.563 - amici.petab_import - INFO - Reactions: 9\n", + "2023-08-25 15:26:01.618 - amici.petab_import - INFO - Observables: 3\n", + "2023-08-25 15:26:01.620 - amici.petab_import - INFO - Sigmas: 3\n", + "2023-08-25 15:26:01.632 - amici.petab_import - DEBUG - Adding output parameters to model: ['noiseParameter1_pSTAT5A_rel', 'noiseParameter1_pSTAT5B_rel', 'noiseParameter1_rSTAT5A_rel']\n", + "2023-08-25 15:26:01.634 - amici.petab_import - DEBUG - Adding initial assignments for dict_keys([])\n", + "2023-08-25 15:26:01.657 - amici.petab_import - DEBUG - Condition table: (1, 1)\n", + "2023-08-25 15:26:01.658 - amici.petab_import - DEBUG - Fixed parameters are ['ratio', 'specC17']\n", + "2023-08-25 15:26:01.660 - amici.petab_import - INFO - Overall fixed parameters: 2\n", + "2023-08-25 15:26:01.661 - amici.petab_import - INFO - Variable parameters: 16\n", + "2023-08-25 15:26:01.684 - amici.sbml_import - DEBUG - Finished processing SBML annotations ++ (1.34E-04s)\n", + "2023-08-25 15:26:01.717 - amici.sbml_import - DEBUG - Finished gathering local SBML symbols ++ (2.14E-02s)\n", + "2023-08-25 15:26:01.752 - amici.sbml_import - DEBUG - Finished processing SBML parameters ++ (2.24E-02s)\n", + "2023-08-25 15:26:01.765 - amici.sbml_import - DEBUG - Finished processing SBML compartments ++ (4.04E-04s)\n", + "2023-08-25 15:26:01.788 - amici.sbml_import - DEBUG - Finished processing SBML species initials +++ (6.57E-03s)\n", + "2023-08-25 15:26:01.799 - amici.sbml_import - DEBUG - Finished processing SBML rate rules +++ (7.80E-05s)\n", + "2023-08-25 15:26:01.801 - amici.sbml_import - DEBUG - Finished processing SBML species ++ (2.70E-02s)\n", + "2023-08-25 15:26:01.818 - amici.sbml_import - DEBUG - Finished processing SBML reactions ++ (5.84E-03s)\n", + "2023-08-25 15:26:01.838 - amici.sbml_import - DEBUG - Finished processing SBML rules ++ (9.97E-03s)\n", + "2023-08-25 15:26:01.849 - amici.sbml_import - DEBUG - Finished processing SBML events ++ (8.28E-05s)\n", + "2023-08-25 15:26:01.859 - amici.sbml_import - DEBUG - Finished processing SBML initial assignments++ (1.03E-04s)\n", + "2023-08-25 15:26:01.870 - amici.sbml_import - DEBUG - Finished processing SBML species references ++ (5.32E-04s)\n", + "2023-08-25 15:26:01.871 - amici.sbml_import - DEBUG - Finished importing SBML + (1.95E-01s)\n", + "2023-08-25 15:26:01.926 - amici.sbml_import - DEBUG - Finished processing SBML observables + (4.47E-02s)\n", + "2023-08-25 15:26:01.938 - amici.sbml_import - DEBUG - Finished processing SBML event observables + (2.83E-06s)\n", + "2023-08-25 15:26:02.017 - amici.de_export - DEBUG - Finished running smart_multiply ++ (2.33E-03s)\n", + "2023-08-25 15:26:02.122 - amici.de_export - DEBUG - Finished simplifying xdot +++ (8.01E-03s)\n", + "2023-08-25 15:26:02.123 - amici.de_export - DEBUG - Finished computing xdot ++ (1.85E-02s)\n", + "2023-08-25 15:26:02.147 - amici.de_export - DEBUG - Finished simplifying x0 +++ (1.72E-03s)\n", + "2023-08-25 15:26:02.149 - amici.de_export - DEBUG - Finished computing x0 ++ (1.35E-02s)\n", + "2023-08-25 15:26:02.152 - amici.de_export - DEBUG - Finished importing SbmlImporter + (1.45E-01s)\n", + "2023-08-25 15:26:02.334 - amici.de_export - DEBUG - Finished simplifying Jy ++++ (1.42E-01s)\n", + "2023-08-25 15:26:02.335 - amici.de_export - DEBUG - Finished computing Jy +++ (1.51E-01s)\n", + "2023-08-25 15:26:02.404 - amici.de_export - DEBUG - Finished simplifying y ++++ (4.67E-02s)\n", + "2023-08-25 15:26:02.405 - amici.de_export - DEBUG - Finished computing y +++ (5.86E-02s)\n", + "2023-08-25 15:26:02.425 - amici.de_export - DEBUG - Finished simplifying sigmay ++++ (1.38E-04s)\n", + "2023-08-25 15:26:02.426 - amici.de_export - DEBUG - Finished computing sigmay +++ (8.85E-03s)\n", + "2023-08-25 15:26:02.458 - amici.de_export - DEBUG - Finished writing Jy.cpp ++ (2.84E-01s)\n", + "2023-08-25 15:26:02.523 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (3.62E-02s)\n", + "2023-08-25 15:26:02.547 - amici.de_export - DEBUG - Finished simplifying dJydsigma ++++ (1.39E-02s)\n", + "2023-08-25 15:26:02.548 - amici.de_export - DEBUG - Finished computing dJydsigma +++ (7.16E-02s)\n", + "2023-08-25 15:26:02.558 - amici.de_export - DEBUG - Finished writing dJydsigma.cpp ++ (8.93E-02s)\n", + "2023-08-25 15:26:02.601 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (1.81E-02s)\n", + "2023-08-25 15:26:02.629 - amici.de_export - DEBUG - Finished simplifying dJydy ++++ (1.72E-02s)\n", + "2023-08-25 15:26:02.630 - amici.de_export - DEBUG - Finished computing dJydy +++ (5.57E-02s)\n", + "2023-08-25 15:26:02.641 - amici.de_export - DEBUG - Finished writing dJydy.cpp ++ (7.41E-02s)\n", + "2023-08-25 15:26:02.669 - amici.de_export - DEBUG - Finished simplifying Jz ++++ (9.60E-05s)\n", + "2023-08-25 15:26:02.670 - amici.de_export - DEBUG - Finished computing Jz +++ (8.37E-03s)\n", + "2023-08-25 15:26:02.682 - amici.de_export - DEBUG - Finished computing z +++ (1.74E-04s)\n", + "2023-08-25 15:26:02.701 - amici.de_export - DEBUG - Finished simplifying sigmaz ++++ (1.33E-04s)\n", + "2023-08-25 15:26:02.701 - amici.de_export - DEBUG - Finished computing sigmaz +++ (7.93E-03s)\n", + "2023-08-25 15:26:02.702 - amici.de_export - DEBUG - Finished writing Jz.cpp ++ (4.87E-02s)\n", + "2023-08-25 15:26:02.729 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (7.59E-05s)\n", + "2023-08-25 15:26:02.739 - amici.de_export - DEBUG - Finished simplifying dJzdsigma ++++ (2.09E-04s)\n", + "2023-08-25 15:26:02.740 - amici.de_export - DEBUG - Finished computing dJzdsigma +++ (1.98E-02s)\n", + "2023-08-25 15:26:02.742 - amici.de_export - DEBUG - Finished writing dJzdsigma.cpp ++ (2.80E-02s)\n", + "2023-08-25 15:26:02.769 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (6.99E-05s)\n", + "2023-08-25 15:26:02.778 - amici.de_export - DEBUG - Finished simplifying dJzdz ++++ (9.28E-05s)\n", + "2023-08-25 15:26:02.779 - amici.de_export - DEBUG - Finished computing dJzdz +++ (1.78E-02s)\n", + "2023-08-25 15:26:02.780 - amici.de_export - DEBUG - Finished writing dJzdz.cpp ++ (2.73E-02s)\n", + "2023-08-25 15:26:02.807 - amici.de_export - DEBUG - Finished simplifying Jrz ++++ (1.01E-04s)\n", + "2023-08-25 15:26:02.808 - amici.de_export - DEBUG - Finished computing Jrz +++ (7.65E-03s)\n", + "2023-08-25 15:26:02.818 - amici.de_export - DEBUG - Finished computing rz +++ (2.55E-04s)\n", + "2023-08-25 15:26:02.819 - amici.de_export - DEBUG - Finished writing Jrz.cpp ++ (2.59E-02s)\n", + "2023-08-25 15:26:02.845 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (9.20E-05s)\n", + "2023-08-25 15:26:02.856 - amici.de_export - DEBUG - Finished simplifying dJrzdsigma ++++ (9.63E-05s)\n", + "2023-08-25 15:26:02.857 - amici.de_export - DEBUG - Finished computing dJrzdsigma +++ (2.05E-02s)\n", + "2023-08-25 15:26:02.858 - amici.de_export - DEBUG - Finished writing dJrzdsigma.cpp ++ (2.91E-02s)\n", + "2023-08-25 15:26:02.886 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (6.81E-05s)\n", + "2023-08-25 15:26:02.899 - amici.de_export - DEBUG - Finished simplifying dJrzdz ++++ (1.23E-04s)\n", + "2023-08-25 15:26:02.900 - amici.de_export - DEBUG - Finished computing dJrzdz +++ (2.28E-02s)\n", + "2023-08-25 15:26:02.901 - amici.de_export - DEBUG - Finished writing dJrzdz.cpp ++ (3.12E-02s)\n", + "2023-08-25 15:26:02.928 - amici.de_export - DEBUG - Finished simplifying root ++++ (1.70E-04s)\n", + "2023-08-25 15:26:02.929 - amici.de_export - DEBUG - Finished computing root +++ (9.40E-03s)\n", + "2023-08-25 15:26:02.931 - amici.de_export - DEBUG - Finished writing root.cpp ++ (1.89E-02s)\n", + "2023-08-25 15:26:02.999 - amici.de_export - DEBUG - Finished simplifying w +++++ (3.15E-02s)\n", + "2023-08-25 15:26:03.000 - amici.de_export - DEBUG - Finished computing w ++++ (4.06E-02s)\n", + "2023-08-25 15:26:03.035 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (2.51E-02s)\n", + "2023-08-25 15:26:03.055 - amici.de_export - DEBUG - Finished simplifying dwdp ++++ (1.14E-02s)\n", + "2023-08-25 15:26:03.056 - amici.de_export - DEBUG - Finished computing dwdp +++ (1.05E-01s)\n", + "2023-08-25 15:26:03.078 - amici.de_export - DEBUG - Finished simplifying spl ++++ (1.36E-04s)\n", + "2023-08-25 15:26:03.079 - amici.de_export - DEBUG - Finished computing spl +++ (8.40E-03s)\n", + "2023-08-25 15:26:03.101 - amici.de_export - DEBUG - Finished simplifying sspl ++++ (1.03E-04s)\n", + "2023-08-25 15:26:03.103 - amici.de_export - DEBUG - Finished computing sspl +++ (1.16E-02s)\n", + "2023-08-25 15:26:03.110 - amici.de_export - DEBUG - Finished writing dwdp.cpp ++ (1.66E-01s)\n", + "2023-08-25 15:26:03.219 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (8.22E-02s)\n", + "2023-08-25 15:26:03.318 - amici.de_export - DEBUG - Finished simplifying dwdx ++++ (8.91E-02s)\n", + "2023-08-25 15:26:03.319 - amici.de_export - DEBUG - Finished computing dwdx +++ (1.91E-01s)\n", + "2023-08-25 15:26:03.359 - amici.de_export - DEBUG - Finished writing dwdx.cpp ++ (2.39E-01s)\n", + "2023-08-25 15:26:03.369 - amici.de_export - DEBUG - Finished writing create_splines.cpp ++ (3.98E-04s)\n", + "2023-08-25 15:26:03.404 - amici.de_export - DEBUG - Finished simplifying spline_values +++++ (1.11E-04s)\n", + "2023-08-25 15:26:03.405 - amici.de_export - DEBUG - Finished computing spline_values ++++ (9.25E-03s)\n", + "2023-08-25 15:26:03.417 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (1.12E-04s)\n", + "2023-08-25 15:26:03.427 - amici.de_export - DEBUG - Finished simplifying dspline_valuesdp ++++ (9.45E-05s)\n", + "2023-08-25 15:26:03.428 - amici.de_export - DEBUG - Finished computing dspline_valuesdp +++ (3.99E-02s)\n", + "2023-08-25 15:26:03.429 - amici.de_export - DEBUG - Finished writing dspline_valuesdp.cpp ++ (4.87E-02s)\n", + "2023-08-25 15:26:03.464 - amici.de_export - DEBUG - Finished simplifying spline_slopes +++++ (1.12E-04s)\n", + "2023-08-25 15:26:03.465 - amici.de_export - DEBUG - Finished computing spline_slopes ++++ (9.20E-03s)\n", + "2023-08-25 15:26:03.476 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (7.68E-05s)\n", + "2023-08-25 15:26:03.485 - amici.de_export - DEBUG - Finished simplifying dspline_slopesdp ++++ (9.28E-05s)\n", + "2023-08-25 15:26:03.486 - amici.de_export - DEBUG - Finished computing dspline_slopesdp +++ (3.93E-02s)\n", + "2023-08-25 15:26:03.487 - amici.de_export - DEBUG - Finished writing dspline_slopesdp.cpp ++ (4.71E-02s)\n", + "2023-08-25 15:26:03.523 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (7.05E-03s)\n", + "2023-08-25 15:26:03.538 - amici.de_export - DEBUG - Finished simplifying dwdw ++++ (3.78E-03s)\n", + "2023-08-25 15:26:03.539 - amici.de_export - DEBUG - Finished computing dwdw +++ (3.13E-02s)\n", + "2023-08-25 15:26:03.543 - amici.de_export - DEBUG - Finished writing dwdw.cpp ++ (4.30E-02s)\n", + "2023-08-25 15:26:03.588 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (1.64E-02s)\n", + "2023-08-25 15:26:03.599 - amici.de_export - DEBUG - Finished simplifying dxdotdw ++++ (4.12E-04s)\n", + "2023-08-25 15:26:03.600 - amici.de_export - DEBUG - Finished computing dxdotdw +++ (3.57E-02s)\n", + "2023-08-25 15:26:03.610 - amici.de_export - DEBUG - Finished writing dxdotdw.cpp ++ (5.61E-02s)\n", + "2023-08-25 15:26:03.642 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (1.69E-03s)\n", + "2023-08-25 15:26:03.656 - amici.de_export - DEBUG - Finished simplifying dxdotdx_explicit ++++ (1.36E-04s)\n", + "2023-08-25 15:26:03.657 - amici.de_export - DEBUG - Finished computing dxdotdx_explicit +++ (2.76E-02s)\n", + "2023-08-25 15:26:03.660 - amici.de_export - DEBUG - Finished writing dxdotdx_explicit.cpp ++ (3.91E-02s)\n", + "2023-08-25 15:26:03.691 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (1.63E-03s)\n", + "2023-08-25 15:26:03.702 - amici.de_export - DEBUG - Finished simplifying dxdotdp_explicit ++++ (2.59E-04s)\n", + "2023-08-25 15:26:03.703 - amici.de_export - DEBUG - Finished computing dxdotdp_explicit +++ (2.19E-02s)\n", + "2023-08-25 15:26:03.705 - amici.de_export - DEBUG - Finished writing dxdotdp_explicit.cpp ++ (3.14E-02s)\n", + "2023-08-25 15:26:03.747 - amici.de_export - DEBUG - Finished running smart_jacobian +++++ (2.99E-03s)\n", + "2023-08-25 15:26:03.834 - amici.de_export - DEBUG - Finished simplifying dydx +++++ (7.46E-02s)\n", + "2023-08-25 15:26:03.834 - amici.de_export - DEBUG - Finished computing dydx ++++ (9.83E-02s)\n", + "2023-08-25 15:26:03.853 - amici.de_export - DEBUG - Finished running smart_jacobian +++++ (2.80E-04s)\n", + "2023-08-25 15:26:03.865 - amici.de_export - DEBUG - Finished simplifying dydw +++++ (1.05E-04s)\n", + "2023-08-25 15:26:03.866 - amici.de_export - DEBUG - Finished computing dydw ++++ (2.15E-02s)\n", + "2023-08-25 15:26:03.951 - amici.de_export - DEBUG - Finished simplifying dydx ++++ (7.01E-02s)\n", + "2023-08-25 15:26:03.952 - amici.de_export - DEBUG - Finished computing dydx +++ (2.25E-01s)\n", + "2023-08-25 15:26:03.981 - amici.de_export - DEBUG - Finished writing dydx.cpp ++ (2.62E-01s)\n", + "2023-08-25 15:26:04.018 - amici.de_export - DEBUG - Finished running smart_jacobian +++++ (2.60E-04s)\n", + "2023-08-25 15:26:04.028 - amici.de_export - DEBUG - Finished simplifying dydp +++++ (9.56E-05s)\n", + "2023-08-25 15:26:04.028 - amici.de_export - DEBUG - Finished computing dydp ++++ (1.88E-02s)\n", + "2023-08-25 15:26:04.039 - amici.de_export - DEBUG - Finished simplifying dydp ++++ (9.50E-05s)\n", + "2023-08-25 15:26:04.040 - amici.de_export - DEBUG - Finished computing dydp +++ (4.04E-02s)\n", + "2023-08-25 15:26:04.042 - amici.de_export - DEBUG - Finished writing dydp.cpp ++ (5.07E-02s)\n", + "2023-08-25 15:26:04.061 - amici.de_export - DEBUG - Finished computing dzdx +++ (1.50E-04s)\n", + "2023-08-25 15:26:04.061 - amici.de_export - DEBUG - Finished writing dzdx.cpp ++ (8.54E-03s)\n", + "2023-08-25 15:26:04.079 - amici.de_export - DEBUG - Finished computing dzdp +++ (1.53E-04s)\n", + "2023-08-25 15:26:04.081 - amici.de_export - DEBUG - Finished writing dzdp.cpp ++ (9.44E-03s)\n", + "2023-08-25 15:26:04.098 - amici.de_export - DEBUG - Finished computing drzdx +++ (1.45E-04s)\n", + "2023-08-25 15:26:04.099 - amici.de_export - DEBUG - Finished writing drzdx.cpp ++ (9.13E-03s)\n", + "2023-08-25 15:26:04.117 - amici.de_export - DEBUG - Finished computing drzdp +++ (1.53E-04s)\n", + "2023-08-25 15:26:04.118 - amici.de_export - DEBUG - Finished writing drzdp.cpp ++ (8.88E-03s)\n", + "2023-08-25 15:26:04.144 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (3.40E-04s)\n", + "2023-08-25 15:26:04.154 - amici.de_export - DEBUG - Finished simplifying dsigmaydy ++++ (8.96E-05s)\n", + "2023-08-25 15:26:04.154 - amici.de_export - DEBUG - Finished computing dsigmaydy +++ (2.02E-02s)\n", + "2023-08-25 15:26:04.155 - amici.de_export - DEBUG - Finished writing dsigmaydy.cpp ++ (2.86E-02s)\n", + "2023-08-25 15:26:04.183 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (1.20E-03s)\n", + "2023-08-25 15:26:04.193 - amici.de_export - DEBUG - Finished simplifying dsigmaydp ++++ (1.58E-04s)\n", + "2023-08-25 15:26:04.194 - amici.de_export - DEBUG - Finished computing dsigmaydp +++ (1.88E-02s)\n", + "2023-08-25 15:26:04.197 - amici.de_export - DEBUG - Finished writing dsigmaydp.cpp ++ (2.99E-02s)\n", + "2023-08-25 15:26:04.208 - amici.de_export - DEBUG - Finished writing sigmay.cpp ++ (1.52E-03s)\n", + "2023-08-25 15:26:04.232 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (7.05E-05s)\n", + "2023-08-25 15:26:04.243 - amici.de_export - DEBUG - Finished simplifying dsigmazdp ++++ (1.14E-04s)\n", + "2023-08-25 15:26:04.244 - amici.de_export - DEBUG - Finished computing dsigmazdp +++ (1.93E-02s)\n", + "2023-08-25 15:26:04.244 - amici.de_export - DEBUG - Finished writing dsigmazdp.cpp ++ (2.79E-02s)\n", + "2023-08-25 15:26:04.256 - amici.de_export - DEBUG - Finished writing sigmaz.cpp ++ (5.24E-05s)\n", + "2023-08-25 15:26:04.272 - amici.de_export - DEBUG - Finished computing stau +++ (1.40E-04s)\n", + "2023-08-25 15:26:04.273 - amici.de_export - DEBUG - Finished writing stau.cpp ++ (8.13E-03s)\n", + "2023-08-25 15:26:04.292 - amici.de_export - DEBUG - Finished computing deltax +++ (1.35E-04s)\n", + "2023-08-25 15:26:04.293 - amici.de_export - DEBUG - Finished writing deltax.cpp ++ (8.38E-03s)\n", + "2023-08-25 15:26:04.313 - amici.de_export - DEBUG - Finished computing deltasx +++ (2.33E-04s)\n", + "2023-08-25 15:26:04.314 - amici.de_export - DEBUG - Finished writing deltasx.cpp ++ (1.03E-02s)\n", + "2023-08-25 15:26:04.332 - amici.de_export - DEBUG - Finished writing w.cpp ++ (9.05E-03s)\n", + "2023-08-25 15:26:04.343 - amici.de_export - DEBUG - Finished writing x0.cpp ++ (1.96E-03s)\n", + "2023-08-25 15:26:04.375 - amici.de_export - DEBUG - Finished simplifying x0_fixedParameters ++++ (2.13E-03s)\n", + "2023-08-25 15:26:04.376 - amici.de_export - DEBUG - Finished computing x0_fixedParameters +++ (1.20E-02s)\n", + "2023-08-25 15:26:04.380 - amici.de_export - DEBUG - Finished writing x0_fixedParameters.cpp ++ (2.49E-02s)\n", + "2023-08-25 15:26:04.409 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (2.16E-03s)\n", + "2023-08-25 15:26:04.420 - amici.de_export - DEBUG - Finished simplifying sx0 ++++ (9.81E-05s)\n", + "2023-08-25 15:26:04.421 - amici.de_export - DEBUG - Finished computing sx0 +++ (2.15E-02s)\n", + "2023-08-25 15:26:04.422 - amici.de_export - DEBUG - Finished writing sx0.cpp ++ (3.13E-02s)\n", + "2023-08-25 15:26:04.450 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (3.50E-04s)\n", + "2023-08-25 15:26:04.460 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (3.11E-04s)\n", + "2023-08-25 15:26:04.471 - amici.de_export - DEBUG - Finished simplifying sx0_fixedParameters ++++ (1.77E-04s)\n", + "2023-08-25 15:26:04.472 - amici.de_export - DEBUG - Finished computing sx0_fixedParameters +++ (2.92E-02s)\n", + "2023-08-25 15:26:04.475 - amici.de_export - DEBUG - Finished writing sx0_fixedParameters.cpp ++ (3.96E-02s)\n", + "2023-08-25 15:26:04.499 - amici.de_export - DEBUG - Finished writing xdot.cpp ++ (1.48E-02s)\n", + "2023-08-25 15:26:04.513 - amici.de_export - DEBUG - Finished writing y.cpp ++ (4.81E-03s)\n", + "2023-08-25 15:26:04.537 - amici.de_export - DEBUG - Finished simplifying x_rdata ++++ (1.97E-04s)\n", + "2023-08-25 15:26:04.538 - amici.de_export - DEBUG - Finished computing x_rdata +++ (8.23E-03s)\n", + "2023-08-25 15:26:04.540 - amici.de_export - DEBUG - Finished writing x_rdata.cpp ++ (1.77E-02s)\n", + "2023-08-25 15:26:04.566 - amici.de_export - DEBUG - Finished simplifying total_cl ++++ (1.07E-04s)\n", + "2023-08-25 15:26:04.566 - amici.de_export - DEBUG - Finished computing total_cl +++ (8.30E-03s)\n", + "2023-08-25 15:26:04.567 - amici.de_export - DEBUG - Finished writing total_cl.cpp ++ (1.67E-02s)\n", + "2023-08-25 15:26:04.592 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (8.56E-05s)\n", + "2023-08-25 15:26:04.601 - amici.de_export - DEBUG - Finished simplifying dtotal_cldp ++++ (9.78E-05s)\n", + "2023-08-25 15:26:04.602 - amici.de_export - DEBUG - Finished computing dtotal_cldp +++ (1.75E-02s)\n", + "2023-08-25 15:26:04.603 - amici.de_export - DEBUG - Finished writing dtotal_cldp.cpp ++ (2.57E-02s)\n", + "2023-08-25 15:26:04.630 - amici.de_export - DEBUG - Finished simplifying dtotal_cldx_rdata ++++ (1.07E-04s)\n", + "2023-08-25 15:26:04.631 - amici.de_export - DEBUG - Finished computing dtotal_cldx_rdata +++ (8.89E-03s)\n", + "2023-08-25 15:26:04.632 - amici.de_export - DEBUG - Finished writing dtotal_cldx_rdata.cpp ++ (1.72E-02s)\n", + "2023-08-25 15:26:04.662 - amici.de_export - DEBUG - Finished simplifying x_solver ++++ (1.60E-04s)\n", + "2023-08-25 15:26:04.663 - amici.de_export - DEBUG - Finished computing x_solver +++ (9.63E-03s)\n", + "2023-08-25 15:26:04.666 - amici.de_export - DEBUG - Finished writing x_solver.cpp ++ (2.06E-02s)\n", + "2023-08-25 15:26:04.692 - amici.de_export - DEBUG - Finished simplifying dx_rdatadx_solver ++++ (6.79E-04s)\n", + "2023-08-25 15:26:04.693 - amici.de_export - DEBUG - Finished computing dx_rdatadx_solver +++ (9.45E-03s)\n", + "2023-08-25 15:26:04.694 - amici.de_export - DEBUG - Finished writing dx_rdatadx_solver.cpp ++ (1.80E-02s)\n", + "2023-08-25 15:26:04.722 - amici.de_export - DEBUG - Finished simplifying dx_rdatadp ++++ (8.74E-04s)\n", + "2023-08-25 15:26:04.723 - amici.de_export - DEBUG - Finished computing dx_rdatadp +++ (1.08E-02s)\n", + "2023-08-25 15:26:04.725 - amici.de_export - DEBUG - Finished writing dx_rdatadp.cpp ++ (2.03E-02s)\n", + "2023-08-25 15:26:04.749 - amici.de_export - DEBUG - Finished running smart_jacobian ++++ (6.97E-05s)\n", + "2023-08-25 15:26:04.758 - amici.de_export - DEBUG - Finished simplifying dx_rdatadtcl ++++ (8.82E-05s)\n", + "2023-08-25 15:26:04.759 - amici.de_export - DEBUG - Finished computing dx_rdatadtcl +++ (1.66E-02s)\n", + "2023-08-25 15:26:04.760 - amici.de_export - DEBUG - Finished writing dx_rdatadtcl.cpp ++ (2.47E-02s)\n", + "2023-08-25 15:26:04.770 - amici.de_export - DEBUG - Finished writing z.cpp ++ (4.95E-05s)\n", + "2023-08-25 15:26:04.779 - amici.de_export - DEBUG - Finished writing rz.cpp ++ (5.57E-05s)\n", + "2023-08-25 15:26:04.812 - amici.de_export - DEBUG - Finished generating cpp code + (2.65E+00s)\n", + "2023-08-25 15:26:59.498 - amici.de_export - DEBUG - Finished compiling cpp code + (5.47E+01s)\n", + "2023-08-25 15:26:59.945 - amici.petab_import - INFO - Finished Importing PEtab model (5.85E+01s)\n", + "2023-08-25 15:26:59.954 - amici.petab_import - INFO - Successfully loaded model FullModel from pyPESTO/doc/example/amici_models/FullModel.\n" + ] + } + ], + "source": [ + "%%capture\n", + "# PEtab problem loading\n", + "petab_yaml = f\"./{model_name}/{model_name}.yaml\"\n", + "\n", + "petab_problem = petab.Problem.from_yaml(petab_yaml)\n", + "\n", + "# AMICI model complilation\n", + "amici_model = amici.petab_import.import_petab_problem(\n", + " petab_problem, force_compile=True\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "AMICI allows us to construct an objective function from the PEtab problem, already considering the noise distribution assumed for this model. We can also simulate the problem for a parameter with this simple setup." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2023-07-13T09:24:50.218430Z", + "start_time": "2023-07-13T09:24:48.971684Z" + }, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PEtab benchmark parameters\n", + "{'edatas': [::value_type' at 0x12c917d80\n", + " condition 'model1_data1' starting at t=0.0 with custom parameter scales, constants, parameters\n", + " 16x3 time-resolved datapoints\n", + " (48/48 measurements & 0/48 sigmas set)\n", + " 10x0 event-resolved datapoints\n", + " (0/0 measurements & 0/0 sigmas set)\n", + ">],\n", + " 'llh': -138.22199656856435,\n", + " 'rdatas': [::pointer' at 0x12c917c60> >)>],\n", + " 'sllh': None}\n", + "Individualized parameters\n", + "{'edatas': [::value_type' at 0x12c7dadf0\n", + " condition 'model1_data1' starting at t=0.0 with custom parameter scales, constants, parameters\n", + " 16x3 time-resolved datapoints\n", + " (48/48 measurements & 0/48 sigmas set)\n", + " 10x0 event-resolved datapoints\n", + " (0/0 measurements & 0/0 sigmas set)\n", + ">],\n", + " 'llh': -185.54291970899519,\n", + " 'rdatas': [::pointer' at 0x12c917060> >)>],\n", + " 'sllh': None}\n" + ] + } + ], + "source": [ + "# Simulation with PEtab nominal parameter values\n", + "print(\"PEtab benchmark parameters\")\n", + "pprint(amici.petab_objective.simulate_petab(petab_problem, amici_model))\n", + "\n", + "# Simulation with specified parameter values\n", + "parameters = np.array([-1.5, -5.0, -2.2, -1.7, 5.0, 4.2, 0.5, 0.8, 0.5])\n", + "ids = list(amici_model.getParameterIds())\n", + "ids[6:] = [\"sd_pSTAT5A_rel\", \"sd_pSTAT5B_rel\", \"sd_rSTAT5A_rel\"]\n", + "\n", + "print(\"Individualized parameters\")\n", + "pprint(\n", + " amici.petab_objective.simulate_petab(\n", + " petab_problem,\n", + " amici_model,\n", + " problem_parameters={x_id: x_i for x_id, x_i in zip(ids, parameters)},\n", + " scaled_parameters=True,\n", + " )\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that to call the objective function, we need to supply the parameters in a dictionary format. This is not really suitable for parameter estimation, as e.g. optimization packages usually work with (numpy) arrays. Therefore we need to create some kind of parameter mapping." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "185.54291970899519\n" + ] + } + ], + "source": [ + "class Objective:\n", + " \"\"\"\n", + " A very basic implementation to an objective function for AMICI, that can call the objective function just based on the parameters.\n", + " \"\"\"\n", + "\n", + " def __init__(self, petab_problem: petab.Problem, model: amici.Model):\n", + " \"\"\"Constructor for objective.\"\"\"\n", + " self.petab_problem = petab_problem\n", + " self.model = model\n", + " self.x_ids = list(self.model.getParameterIds())\n", + " # nned to change the names for the last ones\n", + " self.x_ids[6:] = [\"sd_pSTAT5A_rel\", \"sd_pSTAT5B_rel\", \"sd_rSTAT5A_rel\"]\n", + "\n", + " def x_dct(self, x: np.ndarray):\n", + " \"\"\"\n", + " Turn array of parameters to dictionary usable for objective call.\n", + " \"\"\"\n", + " return {x_id: x_i for x_id, x_i in zip(self.x_ids, x)}\n", + "\n", + " def __call__(self, x: np.ndarray):\n", + " \"\"\"Call the objective function\"\"\"\n", + " return -amici.petab_objective.simulate_petab(\n", + " petab_problem,\n", + " amici_model,\n", + " problem_parameters=self.x_dct(x),\n", + " scaled_parameters=True,\n", + " )[\"llh\"]\n", + "\n", + "\n", + "# Test it out\n", + "obj = Objective(petab_problem, amici_model)\n", + "pprint(obj(parameters))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Summary\n", + "\n", + "We have constructed a very basic functioning objective function for this specific problem. AMICI and PEtab already simplify the workflow compared to coding the objective from scratch, however there are still some shortcomings. Some things that we have not yet considered and that would require additional code are:\n", + "\n", + "* What if we have **multiple simulation conditions**? We would have to adjust the parameter mapping, to use the correct parameters and constants for each condition, and aggregate results.\n", + "* What if our system starts in a **steady state**? In this case we would have to preequilibrate, something that AMICI can do, but we would need to account for that additionally (and it would most likely also include an additional simulation condition).\n", + "* For later analysis we would like to be able to not only get the objective function but also the **residuals**, something that we can change in AMICI but we would have to account for this flexibility additionally.\n", + "* If we **fix a parameter** (i.e. keeping it constant while optimizing the remaining parameters), we would have to create a different parameter mapping (same for unfixing a parameter).\n", + "* What if we want to include **prior knowledge** of parameters?\n", + "* AMICI can also calculate **sensitivities** (`sllh` in the above output). During parameter estimation, the inference (optimization/sampling/...) algorithm typically calls the objective function many times both with and without sensitivities. Thus, we need to implement the ability to call e.g. function value, gradient and Hessian matrix (or an approximation thereof), as well as combinations of these for efficiency.\n", + "\n", + "This is most likely not the complete list but can already can get yield quite substantial coding effort. While each problem can be tackled, it is a lot of code lines, and we would need to rewrite it each time if we want to change something (or invest even more work and make the design of the objective function flexible).\n", + "\n", + "In short: **There is a need for a tool that can account for all these variables in the objective function formulation**." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### With pyPESTO\n", + "\n", + "All the above is easily addressed by using pyPESTO's objective function implementation. We support a multitude of objective functions (JAX, Aesara, AMICI, Julia, self-written). For PEtab models with AMICI, we take care of the parameter mapping, multiple simulation conditions (including preequilibration), changing between residuals and objective function, fixing parameters, and sensitivity calculation.\n", + "\n", + "While there is a lot of possibility for individualization, in its most basic form creating an objective from a petab file accounting for all of the above boils down to just a few lines in pyPESTO:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(185.5429188951038,\n", + " array([ 4.96886729e+02, 1.50715517e-01, 4.44258325e+01, 7.14778242e+02,\n", + " -5.19647592e-05, -1.66953531e+02, -1.50846999e+02, -6.86643591e+01,\n", + " -1.59022641e+01]))" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "petab_yaml = f\"./{model_name}/{model_name}.yaml\"\n", + "\n", + "petab_problem = petab.Problem.from_yaml(petab_yaml)\n", + "\n", + "# import the petab problem and generate a pypesto problem\n", + "importer = pypesto.petab.PetabImporter(petab_problem)\n", + "problem = importer.create_problem()\n", + "\n", + "# call the objective to get the objective function value and (additionally) the gradient\n", + "problem.objective(parameters, sensi_orders=(0, 1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Optimization\n", + "\n", + "After creating our objective function, we can now set up an optimization problem to find model parameters that best describe the data. For this we will need\n", + "* parameter bounds (to restrict the search area; these are usually based on domain knowledge)\n", + "* startpoints for the multistart local optimization (as dynamical system constrained optimization problems are in most cases non-convex)\n", + "* an optimizer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Without pyPESTO" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ message: STOP: TOTAL NO. of f AND g EVALUATIONS EXCEEDS LIMIT\n", + " success: False\n", + " status: 1\n", + " fun: 483.97739572289964\n", + " x: [-3.352e+00 -2.216e+00 -1.774e+00 -1.776e+00 6.234e-01\n", + " 3.661e+00 1.261e+00 6.150e-01 2.480e-01]\n", + " nit: 18\n", + " jac: [ 2.192e+02 3.002e+02 7.278e+02 -2.483e+02 3.634e+02\n", + " -3.849e+01 -3.175e+01 -1.073e+03 -4.504e+02]\n", + " nfev: 520\n", + " njev: 52\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: STOP: TOTAL NO. of f AND g EVALUATIONS EXCEEDS LIMIT\n", + " success: False\n", + " status: 1\n", + " fun: 242.1633515170673\n", + " x: [-1.690e+00 1.599e+00 4.108e+00 -2.908e+00 4.344e+00\n", + " 2.980e+00 2.152e+00 1.482e+00 1.401e+00]\n", + " nit: 19\n", + " jac: [-1.918e+01 -8.125e+00 8.223e+00 -3.257e+00 -1.422e+01\n", + " -1.719e+01 3.437e+01 -1.304e+01 3.139e+01]\n", + " nfev: 520\n", + " njev: 52\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: STOP: TOTAL NO. of f AND g EVALUATIONS EXCEEDS LIMIT\n", + " success: False\n", + " status: 1\n", + " fun: 214.20136458346468\n", + " x: [-6.979e-02 -3.372e+00 -1.727e+00 4.216e+00 -4.263e+00\n", + " 4.777e+00 1.342e+00 1.486e+00 1.120e+00]\n", + " nit: 24\n", + " jac: [ 1.194e+01 -6.911e-01 -5.608e-01 -4.737e-01 -1.027e+00\n", + " -1.151e+01 -5.561e+00 1.893e+01 -1.621e+01]\n", + " nfev: 530\n", + " njev: 53\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: CONVERGENCE: REL_REDUCTION_OF_F_<=_FACTR*EPSMCH\n", + " success: True\n", + " status: 0\n", + " fun: 249.74599720689707\n", + " x: [ 1.320e+00 -2.696e+00 -5.719e-02 2.128e+00 -9.272e-01\n", + " -1.710e+00 1.873e+00 1.759e+00 1.299e+00]\n", + " nit: 22\n", + " jac: [ 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n", + " -5.684e-06 5.684e-06 5.684e-06 0.000e+00]\n", + " nfev: 270\n", + " njev: 27\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: STOP: TOTAL NO. of f AND g EVALUATIONS EXCEEDS LIMIT\n", + " success: False\n", + " status: 1\n", + " fun: 211.80059302429987\n", + " x: [-5.000e+00 4.982e+00 -4.710e+00 -4.963e+00 -4.994e+00\n", + " 4.055e+00 1.533e+00 1.645e+00 7.582e-01]\n", + " nit: 15\n", + " jac: [ 1.543e+01 -5.858e-01 -1.036e+00 6.517e+00 -7.668e+00\n", + " -2.808e+00 1.728e-01 4.503e+00 1.388e+00]\n", + " nfev: 520\n", + " njev: 52\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: STOP: TOTAL NO. of f AND g EVALUATIONS EXCEEDS LIMIT\n", + " success: False\n", + " status: 1\n", + " fun: 223.69767170122753\n", + " x: [-2.092e+00 -1.184e+00 4.852e+00 -3.410e+00 -4.006e-01\n", + " 3.576e+00 1.544e+00 1.486e+00 1.247e+00]\n", + " nit: 35\n", + " jac: [-2.892e+00 1.587e+01 5.931e+00 -7.305e+00 -5.950e+00\n", + " 4.433e+00 1.067e+01 -2.547e+01 2.397e+01]\n", + " nfev: 530\n", + " njev: 53\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: STOP: TOTAL NO. of f AND g EVALUATIONS EXCEEDS LIMIT\n", + " success: False\n", + " status: 1\n", + " fun: 237.2482338229555\n", + " x: [-3.714e-01 4.988e+00 -5.000e+00 4.999e+00 -4.999e+00\n", + " 5.000e+00 1.853e+00 1.778e+00 1.323e+00]\n", + " nit: 24\n", + " jac: [-4.974e-04 1.434e+00 1.573e-01 -1.395e-01 -2.983e-02\n", + " 3.767e+00 3.086e+01 2.687e+01 3.920e+00]\n", + " nfev: 510\n", + " njev: 51\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: CONVERGENCE: REL_REDUCTION_OF_F_<=_FACTR*EPSMCH\n", + " success: True\n", + " status: 0\n", + " fun: 249.74599744332093\n", + " x: [ 2.623e+00 -3.868e+00 4.241e+00 6.765e-01 4.940e+00\n", + " -4.530e+00 1.873e+00 1.759e+00 1.299e+00]\n", + " nit: 26\n", + " jac: [ 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n", + " 0.000e+00 5.684e-06 -2.842e-06 -1.137e-05]\n", + " nfev: 450\n", + " njev: 45\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: CONVERGENCE: REL_REDUCTION_OF_F_<=_FACTR*EPSMCH\n", + " success: True\n", + " status: 0\n", + " fun: 249.74599618803322\n", + " x: [-5.000e+00 -1.669e+00 4.782e+00 3.631e+00 -4.844e+00\n", + " -4.694e+00 1.873e+00 1.759e+00 1.299e+00]\n", + " nit: 20\n", + " jac: [ 5.684e-06 0.000e+00 0.000e+00 5.684e-06 -2.842e-06\n", + " 0.000e+00 -2.842e-06 2.842e-06 5.684e-06]\n", + " nfev: 430\n", + " njev: 43\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: CONVERGENCE: REL_REDUCTION_OF_F_<=_FACTR*EPSMCH\n", + " success: True\n", + " status: 0\n", + " fun: 249.74599529669632\n", + " x: [-5.000e+00 -5.000e+00 5.000e+00 -5.000e+00 -5.000e+00\n", + " -5.000e+00 1.873e+00 1.759e+00 1.299e+00]\n", + " nit: 15\n", + " jac: [ 0.000e+00 0.000e+00 -0.000e+00 0.000e+00 0.000e+00\n", + " 0.000e+00 -2.842e-06 5.684e-06 2.842e-06]\n", + " nfev: 390\n", + " njev: 39\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: STOP: TOTAL NO. of f AND g EVALUATIONS EXCEEDS LIMIT\n", + " success: False\n", + " status: 1\n", + " fun: 213.3930555660625\n", + " x: [-4.976e+00 4.990e+00 4.959e+00 -4.994e+00 -5.000e+00\n", + " 4.930e+00 1.550e+00 1.674e+00 7.217e-01]\n", + " nit: 14\n", + " jac: [ 1.565e+00 7.910e-02 1.781e+00 1.024e+00 1.101e+00\n", + " 2.874e+00 3.555e-01 4.905e-01 -4.516e-01]\n", + " nfev: 510\n", + " njev: 51\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: CONVERGENCE: REL_REDUCTION_OF_F_<=_FACTR*EPSMCH\n", + " success: True\n", + " status: 0\n", + " fun: 249.7459952943729\n", + " x: [-5.000e+00 -5.000e+00 -5.000e+00 -5.000e+00 -5.000e+00\n", + " -5.000e+00 1.873e+00 1.759e+00 1.299e+00]\n", + " nit: 15\n", + " jac: [ 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n", + " -2.842e-06 -2.842e-06 -2.842e-06 -2.842e-06]\n", + " nfev: 360\n", + " njev: 36\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: STOP: TOTAL NO. of f AND g EVALUATIONS EXCEEDS LIMIT\n", + " success: False\n", + " status: 1\n", + " fun: 249.74612304678104\n", + " x: [ 5.000e+00 -5.000e+00 -5.000e+00 5.000e+00 5.000e+00\n", + " 4.999e+00 1.873e+00 1.759e+00 1.299e+00]\n", + " nit: 24\n", + " jac: [-2.842e-04 8.527e-06 -2.842e-06 0.000e+00 -8.527e-06\n", + " 3.411e-04 -3.351e-03 4.059e-03 -4.007e-04]\n", + " nfev: 510\n", + " njev: 51\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: CONVERGENCE: REL_REDUCTION_OF_F_<=_FACTR*EPSMCH\n", + " success: True\n", + " status: 0\n", + " fun: 249.74599744228198\n", + " x: [ 2.788e+00 -3.974e+00 3.981e+00 4.062e+00 -4.665e+00\n", + " -3.281e+00 1.873e+00 1.759e+00 1.299e+00]\n", + " nit: 14\n", + " jac: [ 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n", + " 0.000e+00 0.000e+00 0.000e+00 -5.684e-06]\n", + " nfev: 480\n", + " njev: 48\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: STOP: TOTAL NO. of f AND g EVALUATIONS EXCEEDS LIMIT\n", + " success: False\n", + " status: 1\n", + " fun: 249.5523160565121\n", + " x: [-2.706e+00 -3.267e+00 1.257e+00 2.064e+00 1.969e-01\n", + " 1.412e+00 1.874e+00 1.758e+00 1.297e+00]\n", + " nit: 15\n", + " jac: [-2.522e-01 -1.616e-01 6.545e-01 1.178e+00 4.326e-01\n", + " -2.745e-01 2.402e-01 -5.134e-02 4.700e-01]\n", + " nfev: 530\n", + " njev: 53\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: STOP: TOTAL NO. of f AND g EVALUATIONS EXCEEDS LIMIT\n", + " success: False\n", + " status: 1\n", + " fun: 249.74599444226348\n", + " x: [-4.686e+00 2.111e+00 2.352e+00 3.564e+00 3.211e+00\n", + " 3.715e-01 1.873e+00 1.759e+00 1.299e+00]\n", + " nit: 36\n", + " jac: [ 5.684e-06 5.684e-06 -5.684e-06 5.684e-06 5.684e-06\n", + " -8.527e-06 -9.237e-04 2.177e-03 -2.240e-03]\n", + " nfev: 520\n", + " njev: 52\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: STOP: TOTAL NO. of f AND g EVALUATIONS EXCEEDS LIMIT\n", + " success: False\n", + " status: 1\n", + " fun: 235.88920140413381\n", + " x: [-3.579e+00 3.028e+00 4.795e+00 4.039e+00 -1.795e+00\n", + " 3.737e+00 1.784e+00 1.808e+00 1.216e+00]\n", + " nit: 20\n", + " jac: [ 3.365e+00 3.241e+00 1.683e+00 2.220e+00 9.867e-01\n", + " -3.602e-01 2.902e+01 3.113e+01 -1.724e+01]\n", + " nfev: 610\n", + " njev: 61\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: STOP: TOTAL NO. of f AND g EVALUATIONS EXCEEDS LIMIT\n", + " success: False\n", + " status: 1\n", + " fun: 220.02415658728512\n", + " x: [-4.987e+00 -4.995e+00 4.993e+00 -4.992e+00 4.825e+00\n", + " 3.875e+00 1.449e+00 1.627e+00 1.031e+00]\n", + " nit: 15\n", + " jac: [ 2.576e+00 -6.263e-01 1.389e+00 2.389e-01 7.329e-01\n", + " 9.629e-01 -4.125e-01 -6.170e-01 -1.864e+00]\n", + " nfev: 510\n", + " njev: 51\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: STOP: TOTAL NO. of f AND g EVALUATIONS EXCEEDS LIMIT\n", + " success: False\n", + " status: 1\n", + " fun: 213.09054793943582\n", + " x: [-4.864e+00 -4.913e+00 3.790e+00 -4.928e+00 -4.981e+00\n", + " 4.780e+00 1.559e+00 1.668e+00 7.252e-01]\n", + " nit: 21\n", + " jac: [ 3.923e+00 1.645e+00 1.015e+01 6.265e+00 4.520e+00\n", + " 1.086e+01 2.107e+00 4.310e-01 3.321e-01]\n", + " nfev: 550\n", + " njev: 55\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: STOP: TOTAL NO. of f AND g EVALUATIONS EXCEEDS LIMIT\n", + " success: False\n", + " status: 1\n", + " fun: 233.42558246297477\n", + " x: [-4.957e+00 4.967e+00 4.933e+00 4.973e+00 -3.787e+00\n", + " 4.875e+00 1.551e+00 1.644e+00 1.318e+00]\n", + " nit: 27\n", + " jac: [-2.601e-01 -1.059e+00 6.951e-01 -9.444e-01 3.608e-01\n", + " 3.734e+00 2.608e+00 -1.406e+00 3.095e+00]\n", + " nfev: 530\n", + " njev: 53\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: CONVERGENCE: REL_REDUCTION_OF_F_<=_FACTR*EPSMCH\n", + " success: True\n", + " status: 0\n", + " fun: 249.7459534303374\n", + " x: [-6.783e-01 -5.000e+00 5.000e+00 -5.000e+00 -6.724e-01\n", + " -2.462e+00 1.873e+00 1.759e+00 1.299e+00]\n", + " nit: 13\n", + " jac: [-3.411e-05 2.785e-04 -1.421e-05 -1.222e-04 -3.979e-05\n", + " -8.527e-05 1.705e-05 2.558e-05 -7.390e-05]\n", + " nfev: 290\n", + " njev: 29\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: CONVERGENCE: REL_REDUCTION_OF_F_<=_FACTR*EPSMCH\n", + " success: True\n", + " status: 0\n", + " fun: 249.7459974433216\n", + " x: [ 2.690e+00 -1.853e+00 2.859e+00 4.703e+00 4.025e+00\n", + " -4.232e+00 1.873e+00 1.759e+00 1.299e+00]\n", + " nit: 20\n", + " jac: [ 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00\n", + " 0.000e+00 0.000e+00 5.684e-06 5.684e-06]\n", + " nfev: 250\n", + " njev: 25\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: STOP: TOTAL NO. of f AND g EVALUATIONS EXCEEDS LIMIT\n", + " success: False\n", + " status: 1\n", + " fun: 249.4079576472867\n", + " x: [-1.928e+00 -6.320e-01 2.840e+00 2.231e+00 -2.678e+00\n", + " 1.019e+00 1.870e+00 1.756e+00 1.299e+00]\n", + " nit: 10\n", + " jac: [ 1.235e+00 9.780e-01 6.752e-01 1.105e-01 2.556e+00\n", + " 1.004e-01 4.811e-01 5.480e-02 -4.183e-02]\n", + " nfev: 580\n", + " njev: 58\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: STOP: TOTAL NO. of f AND g EVALUATIONS EXCEEDS LIMIT\n", + " success: False\n", + " status: 1\n", + " fun: 200.88846803388742\n", + " x: [-8.127e-01 3.724e+00 1.937e+00 -2.592e+00 4.676e+00\n", + " 3.893e+00 1.392e+00 1.065e+00 1.110e+00]\n", + " nit: 20\n", + " jac: [ 6.924e+01 4.523e+00 5.096e+00 1.620e+01 7.100e+00\n", + " -9.445e+01 9.871e+00 -4.982e+01 3.366e+01]\n", + " nfev: 690\n", + " njev: 69\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>,\n", + " message: STOP: TOTAL NO. of f AND g EVALUATIONS EXCEEDS LIMIT\n", + " success: False\n", + " status: 1\n", + " fun: 216.78983787278423\n", + " x: [ 9.620e-02 1.241e+00 3.601e+00 1.566e+00 -4.929e+00\n", + " 5.000e+00 1.412e+00 1.423e+00 1.287e+00]\n", + " nit: 28\n", + " jac: [ 8.744e-01 -2.230e-02 -1.398e-01 -4.002e-03 -2.683e-01\n", + " -6.436e-01 4.931e+00 1.177e+01 -2.101e+00]\n", + " nfev: 510\n", + " njev: 51\n", + " hess_inv: <9x9 LbfgsInvHessProduct with dtype=float64>]\n" + ] + } + ], + "source": [ + "# bounds\n", + "ub = 5 * np.ones(len(parameters))\n", + "lb = -5 * np.ones(len(parameters))\n", + "\n", + "# number of starts\n", + "n_starts = 25\n", + "\n", + "# draw uniformly distributed parameters within these bounds\n", + "x_guesses = np.random.random((n_starts, len(lb))) * (ub - lb) + lb\n", + "\n", + "# optimize\n", + "results = []\n", + "for x0 in x_guesses:\n", + " results.append(\n", + " scipy.optimize.minimize(\n", + " obj,\n", + " x0,\n", + " bounds=zip(lb, ub),\n", + " tol=1e-12,\n", + " options={\"maxfun\": 500},\n", + " method=\"L-BFGS-B\",\n", + " )\n", + " )\n", + "pprint(results)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We might want to change the optimizer, like e.g. [NLopt](https://nlopt.readthedocs.io/en/latest/)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[array([-4.72537584, -3.8267521 , 0.17032373, 0.5309411 , 1.82691101,\n", + " -0.13738387, -2.19222726, 2.40671846, -2.17865902]),\n", + " array([-4.85782185, 0.88722054, 3.46323867, -0.42272524, 2.97501061,\n", + " -0.44685985, -1.9617645 , 4.19526924, -0.68191772]),\n", + " array([ 2.75539723, -3.45625301, -1.74304845, 4.19486719, -4.36152045,\n", + " 3.20102079, 4.1666204 , 4.5071745 , 1.64830203]),\n", + " array([-0.13272644, -1.78655792, -2.05292081, 4.94102789, 0.68000657,\n", + " -0.41145952, 4.43118647, 2.86292729, -2.27641822]),\n", + " array([ 1.5071923 , 3.23408298, 4.40175342, -4.93504248, -3.68651524,\n", + " 4.89047865, -3.50203955, -3.98810331, -0.60343463]),\n", + " array([ 3.59031468, -0.64508741, 4.57795683, -4.55808472, 1.45169025,\n", + " 0.16191615, -0.9214029 , 1.8818166 , -2.04635126]),\n", + " array([-3.69691906, -1.11149925, -2.07266599, -1.6551983 , -1.05891694,\n", + " 0.25590375, 0.87136513, -1.83339326, -2.29220816]),\n", + " array([ 2.62294851, -3.86768587, 4.24057642, 0.67648706, 4.94028248,\n", + " -4.53014752, -4.41436998, 0.48069498, 2.08662195]),\n", + " array([ 1.11811741, -1.66877199, 4.78163474, 3.63123695, -4.84414353,\n", + " -4.69389636, -4.22521978, 1.05436896, 1.66464083]),\n", + " array([ 2.10705352, -4.17386158, -4.95145244, -0.4940422 , 2.44773506,\n", + " -0.72754709, -3.38821849, 4.3015123 , -4.03270095]),\n", + " array([-1.21935294, 4.99254589, -3.5227032 , -4.57026229, -4.27577682,\n", + " 1.65134668, -2.57941689, 3.3876373 , -3.08581727]),\n", + " array([-2.69338089, 1.3336723 , 4.00935726, 4.23436455, -4.97880599,\n", + " 0.66011236, -0.92734049, -0.72506365, -1.95148656]),\n", + " array([ 4.59360518, -1.45672536, 2.53472283, 1.59953602, 4.74752881,\n", + " 2.97708352, -1.75879731, 1.52861569, -4.47452224]),\n", + " array([ 2.78765335, -3.97396464, 3.98103304, 4.06162031, -4.66533684,\n", + " -3.28137522, 3.15208208, -2.66502967, -4.85197795]),\n", + " array([-2.01253459, -2.8480651 , 3.12268386, 1.19351138, -0.60901754,\n", + " 0.29935873, 3.43245553, 4.09645236, -0.05881582]),\n", + " array([-4.51736894, 2.39365053, -0.85230688, 2.93845516, 3.92387757,\n", + " 3.35653866, 4.52675063, 1.98365382, 3.80369101]),\n", + " array([-1.17029265, 3.16644483, 4.85261058, 4.35300099, 1.26174191,\n", + " 0.82811007, 4.66370112, 3.96059639, 3.24314499]),\n", + " array([-2.59120601, 0.69656874, -3.88289712, -1.74846428, -1.58175173,\n", + " 3.39830011, 0.0917892 , -0.85030875, -3.77417568]),\n", + " array([ 2.45781935, 1.53870162, -0.24553228, 1.49870916, -3.42788561,\n", + " 4.98603203, 3.19947195, -4.22036418, 0.83316028]),\n", + " array([ 2.20258998, 4.3092804 , -2.2015135 , -1.86005028, 4.82608847,\n", + " 2.24886943, -1.09100022, -1.53563431, 0.22579574]),\n", + " array([-0.53682615, -4.81637178, 4.95364701, -4.57752447, -0.60577667,\n", + " -2.88604054, 0.85270085, 0.07054205, -1.27549967]),\n", + " array([ 2.69036786, -1.85327759, 2.85858288, 4.70288006, 4.02501682,\n", + " -4.23172439, -0.72188414, 3.55067703, 4.87046828]),\n", + " array([-1.88273814, -0.60977486, 2.87775688, 2.25140401, -2.65489216,\n", + " 1.01047951, 3.69127283, 4.44893301, 2.65440911]),\n", + " array([0.66867122, 3.97870907, 2.13991535, 0.2612146 , 4.9597103 ,\n", + " 3.23568699, 4.22366861, 0.40266923, 3.15201217]),\n", + " array([ 4.03440768, 0.83760837, 3.55179682, 1.57898613, -4.87401594,\n", + " 4.33049155, 3.79628273, 1.90990052, 1.02667127])]\n" + ] + } + ], + "source": [ + "import nlopt\n", + "\n", + "opt = nlopt.opt(\n", + " nlopt.LD_LBFGS, len(parameters)\n", + ") # only one of many possible options\n", + "\n", + "opt.set_lower_bounds(lb)\n", + "opt.set_upper_bounds(ub)\n", + "\n", + "\n", + "def nlopt_objective(x, grad):\n", + " \"\"\"We need a wrapper function of the kind f(x,grad) for nlopt.\"\"\"\n", + " r = obj(x)\n", + " return r\n", + "\n", + "\n", + "opt.set_min_objective(nlopt_objective)\n", + "\n", + "\n", + "results = []\n", + "for x0 in x_guesses:\n", + " try:\n", + " result = opt.optimize(x0)\n", + " except (\n", + " nlopt.RoundoffLimited,\n", + " nlopt.ForcedStop,\n", + " ValueError,\n", + " RuntimeError,\n", + " MemoryError,\n", + " ) as e:\n", + " result = None\n", + " results.append(result)\n", + "\n", + "pprint(results)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can already see that the NLopt library takes different arguments and has a different result output than scipy. In order to be able to compare them, we need to modify the code again. We would at the very least like the end objective function value, our starting value and some kind of exit message." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[{'exitflag': 1,\n", + " 'fun': 1150653011.8393009,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([-4.72537584, -3.8267521 , 0.17032373, 0.5309411 , 1.82691101,\n", + " -0.13738387, -2.19222726, 2.40671846, -2.17865902]),\n", + " 'x0': array([-4.72537584, -3.8267521 , 0.17032373, 0.5309411 , 1.82691101,\n", + " -0.13738387, -2.19222726, 2.40671846, -2.17865902])},\n", + " {'exitflag': 1,\n", + " 'fun': 373210706.087737,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([-4.85782185, 0.88722054, 3.46323867, -0.42272524, 2.97501061,\n", + " -0.44685985, -1.9617645 , 4.19526924, -0.68191772]),\n", + " 'x0': array([-4.85782185, 0.88722054, 3.46323867, -0.42272524, 2.97501061,\n", + " -0.44685985, -1.9617645 , 4.19526924, -0.68191772])},\n", + " {'exitflag': 1,\n", + " 'fun': 425.9896608503201,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([ 2.75539723, -3.45625301, -1.74304845, 4.19486719, -4.36152045,\n", + " 3.20102079, 4.1666204 , 4.5071745 , 1.64830203]),\n", + " 'x0': array([ 2.75539723, -3.45625301, -1.74304845, 4.19486719, -4.36152045,\n", + " 3.20102079, 4.1666204 , 4.5071745 , 1.64830203])},\n", + " {'exitflag': 1,\n", + " 'fun': 113150729.31030881,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([-0.13272644, -1.78655792, -2.05292081, 4.94102789, 0.68000657,\n", + " -0.41145952, 4.43118647, 2.86292729, -2.27641822]),\n", + " 'x0': array([-0.13272644, -1.78655792, -2.05292081, 4.94102789, 0.68000657,\n", + " -0.41145952, 4.43118647, 2.86292729, -2.27641822])},\n", + " {'exitflag': 1,\n", + " 'fun': 2170773400755.13,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([ 1.5071923 , 3.23408298, 4.40175342, -4.93504248, -3.68651524,\n", + " 4.89047865, -3.50203955, -3.98810331, -0.60343463]),\n", + " 'x0': array([ 1.5071923 , 3.23408298, 4.40175342, -4.93504248, -3.68651524,\n", + " 4.89047865, -3.50203955, -3.98810331, -0.60343463])},\n", + " {'exitflag': 1,\n", + " 'fun': 42320078.18806582,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([ 3.59031468, -0.64508741, 4.57795683, -4.55808472, 1.45169025,\n", + " 0.16191615, -0.9214029 , 1.8818166 , -2.04635126]),\n", + " 'x0': array([ 3.59031468, -0.64508741, 4.57795683, -4.55808472, 1.45169025,\n", + " 0.16191615, -0.9214029 , 1.8818166 , -2.04635126])},\n", + " {'exitflag': 1,\n", + " 'fun': 243163763.80728397,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([-3.69691906, -1.11149925, -2.07266599, -1.6551983 , -1.05891694,\n", + " 0.25590375, 0.87136513, -1.83339326, -2.29220816]),\n", + " 'x0': array([-3.69691906, -1.11149925, -2.07266599, -1.6551983 , -1.05891694,\n", + " 0.25590375, 0.87136513, -1.83339326, -2.29220816])},\n", + " {'exitflag': 1,\n", + " 'fun': 30002126964787.39,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([ 2.62294851, -3.86768587, 4.24057642, 0.67648706, 4.94028248,\n", + " -4.53014752, -4.41436998, 0.48069498, 2.08662195]),\n", + " 'x0': array([ 2.62294851, -3.86768587, 4.24057642, 0.67648706, 4.94028248,\n", + " -4.53014752, -4.41436998, 0.48069498, 2.08662195])},\n", + " {'exitflag': 1,\n", + " 'fun': 12556009991670.39,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([ 1.11811741, -1.66877199, 4.78163474, 3.63123695, -4.84414353,\n", + " -4.69389636, -4.22521978, 1.05436896, 1.66464083]),\n", + " 'x0': array([ 1.11811741, -1.66877199, 4.78163474, 3.63123695, -4.84414353,\n", + " -4.69389636, -4.22521978, 1.05436896, 1.66464083])},\n", + " {'exitflag': 1,\n", + " 'fun': 634294830118.3749,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([ 2.10705352, -4.17386158, -4.95145244, -0.4940422 , 2.44773506,\n", + " -0.72754709, -3.38821849, 4.3015123 , -4.03270095]),\n", + " 'x0': array([ 2.10705352, -4.17386158, -4.95145244, -0.4940422 , 2.44773506,\n", + " -0.72754709, -3.38821849, 4.3015123 , -4.03270095])},\n", + " {'exitflag': 1,\n", + " 'fun': 9986849980.33512,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([-1.21935294, 4.99254589, -3.5227032 , -4.57026229, -4.27577682,\n", + " 1.65134668, -2.57941689, 3.3876373 , -3.08581727]),\n", + " 'x0': array([-1.21935294, 4.99254589, -3.5227032 , -4.57026229, -4.27577682,\n", + " 1.65134668, -2.57941689, 3.3876373 , -3.08581727])},\n", + " {'exitflag': 1,\n", + " 'fun': 29198157.935426034,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([-2.69338089, 1.3336723 , 4.00935726, 4.23436455, -4.97880599,\n", + " 0.66011236, -0.92734049, -0.72506365, -1.95148656]),\n", + " 'x0': array([-2.69338089, 1.3336723 , 4.00935726, 4.23436455, -4.97880599,\n", + " 0.66011236, -0.92734049, -0.72506365, -1.95148656])},\n", + " {'exitflag': 1,\n", + " 'fun': 2817631865279.2437,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([ 4.59360518, -1.45672536, 2.53472283, 1.59953602, 4.74752881,\n", + " 2.97708352, -1.75879731, 1.52861569, -4.47452224]),\n", + " 'x0': array([ 4.59360518, -1.45672536, 2.53472283, 1.59953602, 4.74752881,\n", + " 2.97708352, -1.75879731, 1.52861569, -4.47452224])},\n", + " {'exitflag': 1,\n", + " 'fun': 16029712077044.059,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([ 2.78765335, -3.97396464, 3.98103304, 4.06162031, -4.66533684,\n", + " -3.28137522, 3.15208208, -2.66502967, -4.85197795]),\n", + " 'x0': array([ 2.78765335, -3.97396464, 3.98103304, 4.06162031, -4.66533684,\n", + " -3.28137522, 3.15208208, -2.66502967, -4.85197795])},\n", + " {'exitflag': 1,\n", + " 'fun': 4468.484751390617,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([-2.01253459, -2.8480651 , 3.12268386, 1.19351138, -0.60901754,\n", + " 0.29935873, 3.43245553, 4.09645236, -0.05881582]),\n", + " 'x0': array([-2.01253459, -2.8480651 , 3.12268386, 1.19351138, -0.60901754,\n", + " 0.29935873, 3.43245553, 4.09645236, -0.05881582])},\n", + " {'exitflag': 1,\n", + " 'fun': 426.9335166325137,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([-4.51736894, 2.39365053, -0.85230688, 2.93845516, 3.92387757,\n", + " 3.35653866, 4.52675063, 1.98365382, 3.80369101]),\n", + " 'x0': array([-4.51736894, 2.39365053, -0.85230688, 2.93845516, 3.92387757,\n", + " 3.35653866, 4.52675063, 1.98365382, 3.80369101])},\n", + " {'exitflag': 1,\n", + " 'fun': 481.3231591295339,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([-1.17029265, 3.16644483, 4.85261058, 4.35300099, 1.26174191,\n", + " 0.82811007, 4.66370112, 3.96059639, 3.24314499]),\n", + " 'x0': array([-1.17029265, 3.16644483, 4.85261058, 4.35300099, 1.26174191,\n", + " 0.82811007, 4.66370112, 3.96059639, 3.24314499])},\n", + " {'exitflag': 1,\n", + " 'fun': 36260050961.21613,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([-2.59120601, 0.69656874, -3.88289712, -1.74846428, -1.58175173,\n", + " 3.39830011, 0.0917892 , -0.85030875, -3.77417568]),\n", + " 'x0': array([-2.59120601, 0.69656874, -3.88289712, -1.74846428, -1.58175173,\n", + " 3.39830011, 0.0917892 , -0.85030875, -3.77417568])},\n", + " {'exitflag': 1,\n", + " 'fun': 7147839056555.6,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([ 2.45781935, 1.53870162, -0.24553228, 1.49870916, -3.42788561,\n", + " 4.98603203, 3.19947195, -4.22036418, 0.83316028]),\n", + " 'x0': array([ 2.45781935, 1.53870162, -0.24553228, 1.49870916, -3.42788561,\n", + " 4.98603203, 3.19947195, -4.22036418, 0.83316028])},\n", + " {'exitflag': 1,\n", + " 'fun': 37797579.29678398,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([ 2.20258998, 4.3092804 , -2.2015135 , -1.86005028, 4.82608847,\n", + " 2.24886943, -1.09100022, -1.53563431, 0.22579574]),\n", + " 'x0': array([ 2.20258998, 4.3092804 , -2.2015135 , -1.86005028, 4.82608847,\n", + " 2.24886943, -1.09100022, -1.53563431, 0.22579574])},\n", + " {'exitflag': 1,\n", + " 'fun': 1146659.4928225973,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([-0.53682615, -4.81637178, 4.95364701, -4.57752447, -0.60577667,\n", + " -2.88604054, 0.85270085, 0.07054205, -1.27549967]),\n", + " 'x0': array([-0.53682615, -4.81637178, 4.95364701, -4.57752447, -0.60577667,\n", + " -2.88604054, 0.85270085, 0.07054205, -1.27549967])},\n", + " {'exitflag': 1,\n", + " 'fun': 1236788.617249787,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([ 2.69036786, -1.85327759, 2.85858288, 4.70288006, 4.02501682,\n", + " -4.23172439, -0.72188414, 3.55067703, 4.87046828]),\n", + " 'x0': array([ 2.69036786, -1.85327759, 2.85858288, 4.70288006, 4.02501682,\n", + " -4.23172439, -0.72188414, 3.55067703, 4.87046828])},\n", + " {'exitflag': 1,\n", + " 'fun': 441.8147467190984,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([-1.88273814, -0.60977486, 2.87775688, 2.25140401, -2.65489216,\n", + " 1.01047951, 3.69127283, 4.44893301, 2.65440911]),\n", + " 'x0': array([-1.88273814, -0.60977486, 2.87775688, 2.25140401, -2.65489216,\n", + " 1.01047951, 3.69127283, 4.44893301, 2.65440911])},\n", + " {'exitflag': 1,\n", + " 'fun': 4453.420140298416,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([0.66867122, 3.97870907, 2.13991535, 0.2612146 , 4.9597103 ,\n", + " 3.23568699, 4.22366861, 0.40266923, 3.15201217]),\n", + " 'x0': array([0.66867122, 3.97870907, 2.13991535, 0.2612146 , 4.9597103 ,\n", + " 3.23568699, 4.22366861, 0.40266923, 3.15201217])},\n", + " {'exitflag': 1,\n", + " 'fun': 324.16551565091083,\n", + " 'message': 'Finished Successfully.',\n", + " 'x': array([ 4.03440768, 0.83760837, 3.55179682, 1.57898613, -4.87401594,\n", + " 4.33049155, 3.79628273, 1.90990052, 1.02667127]),\n", + " 'x0': array([ 4.03440768, 0.83760837, 3.55179682, 1.57898613, -4.87401594,\n", + " 4.33049155, 3.79628273, 1.90990052, 1.02667127])}]\n" + ] + } + ], + "source": [ + "results = []\n", + "for x0 in x_guesses:\n", + " try:\n", + " result = opt.optimize(x0)\n", + " msg = 'Finished Successfully.'\n", + " except (\n", + " nlopt.RoundoffLimited,\n", + " nlopt.ForcedStop,\n", + " ValueError,\n", + " RuntimeError,\n", + " MemoryError,\n", + " ) as e:\n", + " result = None\n", + " msg = str(e)\n", + " res_complete = {\n", + " \"x\": result,\n", + " \"x0\": x0,\n", + " \"fun\": opt.last_optimum_value(),\n", + " \"message\": msg,\n", + " \"exitflag\": opt.last_optimize_result(),\n", + " }\n", + " results.append(res_complete)\n", + "\n", + "pprint(results)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is smoothly running and does not take too much code. But again, we did not consider quite a few things regarding this problem:\n", + "\n", + "* The Optimizer internally uses **finite differences**, which is firstly inefficient and secondly inaccurate, especially for very stiff models. Constructing sensitivities and integrating them into the optimization can be quite tedious.\n", + "* There is no **tracking of the history**, we only get the end points. If we want to analyze this in more detail we need to implement this into the objective function.\n", + "* Many times, especcially for larger models, we might want to **change the optimizer** depending on the performance. For example, for some systems other optimizers might perform better, e.g. a global vs a local one. A detailed analysis on this would require some setup, and each optimizer takes arguments in a different form.\n", + "* For bigger models and more starts, **parallelization** becomes a key component to ensure efficency.\n", + "* Especially when considering multiple optimizers, the lack of a **quasi standardised result format** becomes apparent und thus one would either have to write a proper result class or individualize all downstream analysis for each optimizer." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### With pyPESTO\n", + "\n", + "Using pyPESTO, all the above is easily possible. A `pypesto.engine.MultiProcessEngine` allows to use parallelization, and `optimize.ScipyOptimizer` specifies to use a scipy based optimizer. Alternatively, e.g. try `optimize.FidesOptimizer` or `optimize.NLoptOptimizer`, all with consistent calls and output formats. The results of the single optimizer runs are filled into a unified pyPESTO result object." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Engine will use up to 8 processes (= CPU count).\n", + " 0%| | 0/25 [00:00\n", + "* message: ABNORMAL_TERMINATION_IN_LNSRCH \n", + "* number of evaluations: 141\n", + "* time taken to optimize: 6.583s\n", + "* startpoint: [-4.32816355 -4.74870318 -1.74009129 -1.26420992 3.53977881 0.54755365\n", + " 2.64804722 1.62058431 1.57747828]\n", + "* endpoint: [-1.56907929 -5. -2.2098163 -1.78589671 3.55917603 4.19771074\n", + " 0.58569077 0.81885971 0.49858833]\n", + "* final objective value: 138.2224842858494\n", + "* final gradient value: [-0.00783036 0.05534759 0.00129469 -0.00675505 -0.00121895 0.00394696\n", + " -0.00021472 0.00294705 0.00089969]\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "results_pypesto = optimize.minimize(\n", + " problem=problem,\n", + " optimizer=optimize.ScipyOptimizer(),\n", + " n_starts=n_starts,\n", + " engine=pypesto.engine.MultiProcessEngine(),\n", + ")\n", + "# a summary of the results\n", + "display(Markdown(results_pypesto.summary()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Beyond the optimization itself, pyPESTO naturally provides various analysis and visualization routines:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABLsAAAJjCAYAAADkuxODAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3gU1frA8e9sT+8hIQlJIBB6772o2LtgR69ivfZ2vRawol5FVBQbghVFEctPAaUjTUpCDzUJkEp633p+fyw7ZknbhEACnM/z5CHstDOzk52Zd9/zHkUIIZAkSZIkSZIkSZIkSZKks4CmpRsgSZIkSZIkSZIkSZIkSc1FBrskSZIkSZIkSZIkSZKks4YMdkmSJEmSJEmSJEmSJElnDRnskiRJkiRJkiRJkiRJks4aMtglSZIkSZIkSZIkSZIknTVksEuSJEmSJEmSJEmSJEk6a8hglyRJkiRJkiRJkiRJknTWkMEuSZIkSZIkSZIkSZIk6awhg12SJEmSJEmSJEmSJEnSWUMGuyRJanaVlZW89tprDBo0iMDAQDQaDYqioCgKRUVFzbqtlStXquueOnVqrfOMHj1anae1uO2229Q2paWltXRzJEmSJEk6y7TG+59zjbzfk6SWo2vpBkjS6RAXF0d6ejoAR48eJSoqqs557XY7ISEhFBcXA86L1Jw5c+pd/4wZM3jkkUcAeOihh5gxY0bzNBwoKipS19e7d2+uvPLKZlv3qVBRUcHIkSPZsmVLSzdFOm7GjBkUFRURGBjIww8/3NLNkSRJkqQzSlOCRb169SI5OblZ2/HTTz+p63z44YcJDAxs1vWfaebOnasGkOr6wlOSWiN57p4eMtglnRNGjRrFF198AcCqVau48cYb65w3OTlZDXS55m9I9XlGjx7d9IbWoqioiBdeeAGASZMmtfpg14cffqgGurp3785dd91F27Zt0Wq1APj4+LRk885JM2bMID09ndjYWBnskiRJkqQz1E8//cTnn38OOL+MlcGuueo9uAwYSGcSee6eHjLYJZ0TRo8e7XGw68TgVmpqKkeOHCEmJqbW+YUQrFmzBnB+8zdy5MhmavWZ6ffffwecx2LJkiW0bdu2hVskSZIkSZLUPBYuXOjRfAEBAae4JQ1buXJlSzdBkiSpxchgl3ROGDVqlPp7Q5laruljxoxh3bp1mM1mVq1axc0331zr/Dt37iQ/Px+Anj17Ehwc3EytPjMdOXIEgDZt2shAlyRJkiRJZ5XWnmEvSZIkOckC9dI5oX379rRr1w6AvXv3kp2dXet8DodDzdK64IILGDhwIFD/N2PVpzV3F8YzkdlsBsBoNLZwSyRJkiRJkiRJkqRzkQx2SecMT7K7tm/fTmFhoTq/q0tifdlg9dXrOnz4MDNnzuS6664jMTERX19fDAYD4eHhjB49mtdff92tPlh1aWlpKIpCfHy8+trnn3+ujuhS/aeu0V3y8vJ45ZVXGDFiBBERERgMBsLCwhgxYgRvvPEGZWVlde4XOAv7K4pCXFwcAFVVVbz77rsMHz6cNm3aoNFoGD16NHPnzlXb4hoIID09vUY7586d67b+LVu28NJLL3HhhRfSrl07TCYTXl5exMTEcOWVV/LVV19ht9vrbePpdOLxKC8v54033qB///4EBwfj4+ND9+7deeaZZygoKGi27e7Zs4eHHnqI7t27ExAQgJeXF7GxsUyYMKHe7hSu9tb3ntT2vkiSJEmSdGrY7Xa+/PJLLrvsMmJiYtzuffr27cvNN9/M559/Tnl5ubqMa0Q/V70ugPj4+BrX89tuu81tWw2Nxlj9/s11L7B582YmTZpEfHy8er9xww03sHPnzhr78c033zB27FgiIyMxmUx06tSJ//znP5SUlNR7DCorK1m4cCH3338/gwYNIiQkBL1eT0BAAN26dePee+9l27ZtdS7v2q/q9+C13d/UVQvJ4XAwf/58Jk6cSHx8PN7e3vj5+dG5c2fuvfdeduzYUW/7XWw2GzNnzmTo0KEEBQXh6+tL586deeyxx9R7r+bS3PegzXEPXtf5c+edd5KQkICPjw+KorglBrjKvzzzzDOMHTuWtm3bYjQa8fHxIT4+nuuvv55ff/21wfZPnTpV3bZr/cuWLeOaa65R/646dOjAXXfdVeM5qaqqio8++oihQ4cSFhaGt7c3PXr04LXXXlO/tG9IWVkZM2bM4Pzzz1f3ITg4mAEDBvD8889z7NixWpdr6XO3ruN2ww03EB8fj8lkqvXZcuXKlUyaNMnteTYiIoLu3btz+eWX8+abb5KRkeHRsTuthCSdIz799FMBCEDce++9tc4zY8YMAQhvb29hsVjEkiVL1GUyMjJqXSYsLEwAQlEUkZ+fr76+YsUKoSiKunxdP2FhYWLNmjU11puamtrgsq6f1NTUGsvPmTNH+Pn51btcmzZtxLp16+o8ZrGxsQIQsbGx4tChQ6Jbt2411jFq1CgxZ84cj9o5Z84cdd1Tp071aJl+/frVeexdx9k175QpU2qdZ9SoUeo8J6P68UhLSxNdunSp99hu2rSpznVNmjSp3vfP5fnnnxdarbbeYzR69Gi3c+/E9jbmfZEkSZIkyV31a+bJOHbsmBgwYIBH1+aFCxeqy1W/Z6jvZ9KkSW7ba+j+p/r925w5c8R7770ndDpdres2Go1i8eLFQgghSkpKxEUXXVRnOzp37ixyc3PrPA5xcXEe7c/TTz9d6/LV96u+n9ruCw8cOCB69+5d73IajUY899xz9b6XOTk5ok+fPnWuIzAwUPz5558e3+81pDnvQZvrHvzE82fatGm13rOuWLFCXea2227zaNsXXnihKC4urnPbU6ZMcVv/k08+Wee6goKCxNatW4UQQmRlZYn+/fvXOe+IESNERUVFve/F77//LsLDw+ttv5+fn/j5559rLNvS527147Z8+XJx//3317oe17lqt9vFnXfe6VGbH3rooXqPW0uQNbukc0b1rKu6MrVcrw8ePBi9Xs/QoUPRarXY7XZWrVrFDTfc4Db/7t271cj9ifW6qqqqEELQrVs3xowZQ5cuXQgJCaGqqoojR47w008/sWXLFo4dO8all15KcnKy+m0NQHh4OAsXLiQ3N5e7774bcNYRe/DBB2u0Ozw83O3/77zzjjrqnre3N9deey1Dhw4lJCSEvLw8Fi9ezC+//EJOTg7nnXcemzZtomvXrnUeO7PZzNVXX82uXbsYPnw411xzDW3btuXYsWPk5OQwduxYNcPorrvu4tixY4SFhfHxxx+7radv377q75WVleh0OoYMGcKwYcNISEjA39+fgoICUlNT+eqrr8jIyGDLli1ceeWVrF27Fr1eX2cbTyer1cp1113Hnj17GDRoEDfccAMRERGkp6fz+eefs3v3bnJycrjgggtITk5Wu9A21tNPP81rr70GgFar5frrr2fs2LF4eXmxY8cOPvvsM3Jycli5ciVjxoxh48aNmEwmdfmPP/6YioqKet8TcH9fJEmSJEk6NSZPnsymTZsASEhI4IYbbqBTp054eXlRUlLC3r17Wb16NRs3bnRb7sEHH+TKK6/k3XffZcWKFQB89NFHNe7/mnq/AfB///d//Pjjj4SFhXHnnXfSvXt3Kisr+fHHH/ntt98wm81MnDiR1NRUJk2axKJFixg2bBjXXXcdkZGRpKen8/7775Oenk5KSgqPPPIIX331Va3bqqysJDg4mPPPP58+ffoQFRWFXq8nIyODrVu3Mn/+fKxWK9OmTSM8PLzGSNIvv/wyeXl5PPvss+zatQuofeCAzp07u/3/4MGDDB48mLy8PACGDx/OpZdeSmxsLHa7nS1btjB37lwKCwt56aWX0Gg0tWbYWCwWLrzwQpKSkgDnfbjrmJWXl7N48WIWLFjAddddR+/evRv5TtSvOe5BT8U9+HfffcfixYsJCAhg0qRJ9OvXD61Wy7Zt29wGa6isrMRoNDJq1CgGDhxIhw4d8PHx4dixY+zbt48vv/ySgoICFi9ezK233spPP/3U4DF5//33+eGHH4iPj+f222+nU6dOFBUV8eWXX7J27VoKCwu59tpr2bFjB5dccglbt27l4osv5tJLLyUkJISUlBTeffdd8vPzWbNmDa+88govv/xyrdtasGABEydOxG63o9frufzyyxk9ejRt2rShpKSEFStWMH/+fEpLS7nqqqv4888/GTt2rLp8S5+71f3vf/9j0aJFREREcNttt9G9e3dsNht///23Wo7mvffe49NPPwUgMDCQm2++mT59+hAQEEBFRQVpaWls3LhR/VxqdVo62iZJp1N0dLQafT7xGyeHwyFCQkIEIF544QX1dVf0/6677qqxvvfff7/OaHZaWprYvn17ve355ptvhEajEYC47bbbap2neobXid/Y1WbTpk3qt3K9e/cW6enptc7366+/Cr1eLwAxaNCgWuc5MTNo+vTpDW6/+jdP9fn7779FVlZWndPNZrN46KGH1G3PnTu31vlaIrPL9fPkk08Kh8PhNo/FYhE33nijOs+ll15a67oa+qZv3bp1amagj4+PWLVqVY158vPz3b6devzxx+ttd0PviSRJkiRJNVW/9jdVTk6Oel3v37+/KCsrq3PetLQ0kZaWVuP1xmYJNSazCxADBw4UBQUFNeabPHmyW7YPIKZNm1brPkZGRgpAaLVakZmZWet2Fy1aJKxWa53tTktLE507d1YzZEpKSpq0f9XZ7XbRt29fAc4stfnz59c6X3Z2tpo9o9FoxM6dO2vM89JLL6nb7d27t8jLy6sxzw8//FAjy6k5Mrua4x60ue7BTzx/OnfuXG8mmBBCrF69WhQWFtY5vaysTFx33XXqOleuXFnrfNUzlFz7WllZ6TaP3W4X48ePdzt3NRqN+Prrr2usb+/evcLLy0uAMyuvqqqqxjyHDx8W/v7+AhDt2rWr8zlv48aNIiAgQAAiOjpaWCyWGvO01Ll74nEbPnx4vRl0rl49AQEBYu/evXXOV1xcLJKSkhrcl9NNBrukc8pNN92k/nF///33btO2b9+uTquebvvoo48KQCQmJtZY34QJE9RlqqebN8att94qAOHl5VXrh2Fjg12XXXaZenNw9OjReud97rnn1HWvXbu2xvTqF9arrrrKo/1pzsCKzWYT8fHxAhDjxo2rdZ6WCnYNGTKkxk2GS2VlpVuKfkpKSo15Grphveqqq9TpH3zwQZ1tSktLE97e3gIQvr6+td5AyGCXJEmSJDVd9YdDT39OLBGwfv36Rn15WJtTGewyGAy1BtiEEOLo0aNupTkuuuiiOrf5yiuvqPN98cUXHu1XbZYvX66u58svv6x1nsbc3y1YsECd991336133r1796qBqsmTJ7tNM5vNahc2g8Eg9u3bV+d6Hn/88VMS7DrZe1BPeHIPXv38URRFJCcnN2lbJyopKRE+Pj4CEHfccUet81QP2oSHh4uioqJa51u3bp3be1BXKRsh3IO6q1evrjH9gQceUAO5DQV2Zs+era6rtuBaS5y7QrgfNx8fnwaDk0ajUQDi8ssvb7CdrZEsUC+dU+rryuj6v9FoZPDgwerrriL1e/fuJScnx22Z1atXA87Cgq75Gmvo0KGAM613+/btTVqHS2FhIb/99hsAN9xwA1FRUfXOf/PNN6u///HHH/XO+8ADD5xU25pCq9UyaNAgAP7++2+EEKe9DXV59NFH6yz4ajKZuO+++9T/11dEvjZms5nff/8dgJCQEO64444653UVjgVnscyG3kdJkiRJkk4/b29v9XdX96XW5LLLLiM2NrbWaVFRUW6lNu6///461zN8+HD19927dze5Pa77Y6BGt86m+PLLLwHw9/dn8uTJ9c7bqVMndUT2E++r1q5dS25uLuA8Zh07dqxzPY8++igaTfM/bp/Ke1CXxt6Djxgxgl69ejVpWyfy8/OjR48egGfv/S233OLWVbK6AQMGuHXBbOq5K4Tg66+/BmDcuHENdk+dOHEiOp2zYtTJ3ps317l7IldZmvq4Prf279+P1Wr1tMmthqzZJZ1TPAl2DRgwwK3u0YgRI1AUBSEEq1atYsKECYAz+JWdnQ3UrNdV3caNG/nqq6/YsGEDhw4dorS0tM4Pi6NHj9KvX78m79/atWtxOByA8yLVUD/36u3Ys2dPnfNptVqGDBnS5HbVxeFw8NNPP7FgwQKSkpLIzMyktLRU3YfqSktLKSkpqfNidrpV73/f0HRXfQ5Pbdu2TR0NZvTo0RgMhnrnv+CCC5g9ezbgPN9c56gkSZIkSc3L0+DBifUwu3XrRtu2bcnMzGT27NkIIZg8eTIDBw48JQGRxnIFNurSpk0bUlNTAdSH6brmc3GNcF6b3NxcvvjiC/744w92795NYWEhFRUVtc579OjRetvmiTVr1gAQGRnJ4sWLG5xfq9UCzpGsKysr8fLyAtzv6caNG1fvOiIjI+natWuNkSxPVnPcgzb3PfiIESM8bL3zS9358+fz888/s23bNnJycigrK6s1oObJe1/fuavT6QgJCSE7OxsfH596axTXd+7u2rVLHeXSz8/Po1pivr6+FBUV1fuM5YnmOndP5Ml7dv755zN//nz27NnDeeedx+OPP855551X5zpbGxnsks4pCQkJREVFkZGRwc6dO8nPzyckJAT4J9g1atQot2WCg4Pp2rUru3btYuXKlWogofowutWDaC4Wi4U777xTjcZ7oqGhmhtSfZjYWbNmMWvWLI+Xre+GJCQkxC0A2ByOHj3KlVdeyZYtWzxeprUEu4KDg+sMbrokJCSov2dmZjZq/VlZWervnTp1anD+6vNUX1aSJEmSpOZ15ZVXNmk5rVbLRx99xDXXXIPFYuGzzz7js88+IzAwkCFDhjB8+HDGjx9/Ul96ngzX/XBdXAWrG5q3+nxVVVW1zvPdd99x9913U1xc7FHbTvb+uKysjPz8fMD5ZfVVV13VqOULCwvVh/vq93TV7/XqkpCQ0KzBrua4Bz0V9+AN9SZx2bFjB9dccw379+/3eLsN8fTcDQ4OrjMjrvp8UPPcrf6MtWDBAhYsWNBgu1zqe8ZqSHOeuyfy5D17/fXX+euvv8jMzGT16tWsXr0ao9FI//79GTZsGGPHjmXs2LGtZhCxE8lgl3TOGTVqFN988w1CCFavXs1VV13lNqpibd0RR44cya5du9yywar/Xluw6/7771cDXUajkYsvvpgBAwYQFRWFj4+PGnVfvnw57733HgB2u/2k9s3Tm4baWCyWOqc1d/TearUyfvx4NUU4NDSUyy+/nO7du9OmTRtMJpP6LWf1kYdO9vg0l+pdEeri4+Oj/l5WVtao9ZeWlta6nrr4+vrWuqwkSZIkSa3HpZdeyt9//83UqVP57bffsFqtFBUVsWjRIhYtWsQzzzxD9+7d+d///seFF154WtvWmOyyk8lEW716NTfeeKOaQdS3b1/OO+88OnToQEBAgFvAwfVg35L3x+B+j1z9nq6x94PN4WTvQU/VPbgnzwoFBQWcd955ajfQmJgYLr30Ujp37kxYWBgmk0kNRrlGK6wt0+xEnp6PJ3PenqpnrFO53Ya27cl7FhcXR1JSEi+99BJfffUVRUVFmM1m1q5dy9q1a3njjTcIDw/nv//9Lw8++GC9wcSWIINd0jnHFewCZ8DqqquuUgNXOp3OrUaAy8iRI5k1a5YaFAsLC1OXqa1eV1pamtqtLDo6mlWrVtG+ffta25ORkdFs+1Y96PHZZ59x++23N9u6m9O8efPUi+z555/PwoUL67wZcPWPb03qSrOvrry8XP29+vviCT8/v1rXU5fqNzLVl5UkSZIkqXXp1asXCxcupLS0lLVr17Ju3TpWr17NunXrsFqt7Ny5k4svvpgvv/ySm266qaWb2+ymTp2qBjA+/vjjOmsQeXL/46nq92EjR46sUcqkqetq7P1gczjZe9CWvAefOXOmGuiaNGkSn376qVrX6kSvvPJKs277ZFU/js8//zwvvPDCad/uyZ67TRUeHs57773H9OnT2bx5M+vWreOvv/5i+fLllJSUkJuby8MPP8yuXbv4+OOPT3v76tPyHcQl6TSrrW6X69++ffvWGpioHsxavXo1Bw4cUNOCa6vXtXz5crXf+X/+8586A13g7E/dXKqnozZHfYNTZenSpervb7/9dr3fejXn8WkuBQUFDaYkHzhwQP29oeKPJ4qMjFR/9yTNu/o8jd2WJEmSJEmnn5+fHxdeeCEvvvgiK1euJCsri0ceeQRwFsN+9NFHW01Ge3OxWCxq/aH+/fvXW2y7Oe//AgIC1Pv7k70/rn6fVf1ery6ezNMYJ3sP2pL34K5t63Q6ZsyYUWeg61Rs+2S11DNWc567J0uv1zNkyBAee+wxFi5cyLFjx/jss8/UbMxPPvmEHTt2tGgbTySDXdI5p1OnTmowYfv27RQWFqrBrrpGVGzbti0dOnQAnLW6GqrXVX3URtdydVmyZEm906un3DY0EsrIkSPV9NHWPCqfp8cnNzeX5OTk09Cixlu+fHm9011p3+Ac9KAxevXqpV44Vq5c2eDoJ9Xf69qKxrrOodY0mqUkSZIkSf8ICQlh+vTp9O/fH3DeA534hVdj7glbo/z8fGw2G3Dy98fQ+HtkgEOHDp1UAKr6fVZD94JZWVknXZy8NidzD9qS9+CubYeEhBAYGFjnfElJSWp5mdaiT58++Pv7A7Bs2TKPulfWpyXO3eZmMBi4/fbbeeCBB9TX1q5d24ItqkkGu6RzkqsIvcPh4JNPPlFHVTyxOH11rhErVq1a1WC9rur96Q8ePFjnOn/++We2b99eb1urZ5o1lAodHh6u1nj466+/Wm3Ay9PjM23atFY7zO3bb79d5zSz2cwHH3yg/r+xxSSNRiOXXHIJAHl5ecydO7fOeY8cOcK8efMA57kyfvz4GvO4zqHmTqWXJEmSJKl5xcXFqb+7AkMujbknbI08vf8rLS2t9z7LpTHHY9KkServzz//fIPrrsuwYcMIDw8H4Jdffql3P2bMmHFKsvNO5h60Je/BXdvOzc2tt8bsiy++2KzbbQ5arVbtVpyens6nn356UutriXP3VKnvM6ulyWCXdE6qHqB66623AGeEffjw4XUu44qq79y5Ux32tbZ6XeD+Lcqbb75Za7rxxo0b+de//tVgW4ODg9XRT5KTkxuM/r/88svqiBjXX399g0PUpqen8/jjj6t96E+H6sfnueeeq/XbkY8//ph33333tLWpsdauXct///vfGu+H1WrlzjvvVIfnvvTSS0lMTGz0+p944gn1W5/HHnus1m9KCgsLufbaa9WL5D333FPrSDnx8fGA8xvVw4cPN7otkiRJkiSdnCVLlvDOO+/UW3D6wIED/Pnnn4DzYfjEzBvX9Rxg69atp6ahp1BAQAAdO3YEYPPmzSxcuLDGPGVlZVx33XUcOXKkwfU15nhce+216v3nvHnzePjhh+st3l1ZWcncuXP59ttv3V7X6/U8+OCDgLNb5oQJEygoKKix/E8//cT06dMb3IemOJl70Ja8B3dtWwjBs88+W2O6EILnnnuOn376qdm33Rz++9//qhlpDz74IF988UW98+fm5vLSSy/VmtjQEuduY2VlZfH444+r51NtKioq+Pzzz9X/9+rV66S22dxkgXrpnFQ92OUK8vTs2bPelFpXUEsIQV5enrpMbcP/DhkyhH79+rFlyxbS0tLo3Lkz99xzD4mJiVRWVrJ8+XK+++47AG666aYGC0COHTuWhQsXcvDgQSZOnMjVV1/t1tZRo0apI2r07duXWbNmMXnyZAoLC7nooosYNmwYF110EfHx8ej1egoKCkhJSeGvv/5i8+bNADz88MP1tqE53X777bz66quUl5ezcOFC+vbtyy233EJ0dDQ5OTn8+OOPrFq1ioiICHr06KHe+LUWbdu2JSoqimnTprFy5UpuuOEG2rRpQ3p6Op9//jm7du0CICgoiPfff79J2xg8eDBPPfUU06ZNo7S0lFGjRnHDDTcwduxYvLy82LlzJ59++qmaEt6zZ886vwkbN24cv/zyCwBXX3019957L5GRkWowrUePHh4PGS1JkiRJ57LGPIhfcskl6heQWVlZPPzwwzz55JOMGTOGQYMG0b59e7y9vcnLy2PTpk3Mnz9f/QLr4YcfrjFa2rhx49Tfn3zySY4dO0ZiYqJa+ygqKooePXqc5B6eWg888IAaLLr22mu56aabGD58OH5+fuzcuZO5c+eSmZnJrbfe2mAwYdy4cWpQ5o477uCRRx4hNjZWHfE8ISGBhIQEwPml9oIFCxgyZAgZGRm88847zJ8/n+uuu45evXoREBBAWVkZhw8fZvPmzSxbtozy8nJeeumlGtt94okn+OGHH0hOTmbr1q107dqVyZMn061bN8rLy1m8eDELFiwgMDCQXr16uZU/OVknew/akvfg9913H5999hl2u513332X5ORkrr76aiIiIjhy5AjffPMNSUlJdO3aFS8vL7Zs2dJs224O0dHRfPvtt1x++eWYzWYmTZrE9OnTufzyy+nYsSNeXl4UFxezb98+NmzYwNq1a7Hb7YwZM6bGulrq3G0Ms9nMW2+9xVtvvcWAAQMYMWIEXbp0ITAwkOLiYvbu3cs333yjDrY2YsSIehNHWoSQpHNURESEANSfBx98sMFloqKi3JZ56KGH6px3//79IiYmxm3+6j8mk0nMnj1bzJkzR31tzpw5ta4rKSlJeHl51bmu1NTUGsv88ssvok2bNnUuU/0nJCREHDt2rMY6YmNjBSBiY2MbPDaNXeann34SJpOpzjZFRUWJv//+W0yaNKne/VyxYoU6fcqUKbVua9SoUeo8J6P6vqWlpYmuXbvW2f7w8HCxadOmOtfV0H65PPfcc0Kr1db7/o0aNUrk5eXVuY7S0lLRqVOnOpev67yTJEmSJEl4dC9V209hYaG6jrlz53q0jKIo4qGHHhJ2u73Wttxwww11Ljtp0iS3eRu6//HkHtTTdbmkpqbW2R4hhHA4HOKmm26q9xhcccUVoqKiwu0+pzY2m00MHz68zvXUdl+YmZkpxo0b59F7odVqxSeffFLrtnNyckSfPn3qXDYwMFD8+eefHt/vNaQ570Gb6x68MeePywcffCA0Gk2d2+7SpYvYv39/g+fblClT1OkrVqzw+NjVx5NnCiGEWL9+vWjfvr1H55Cvr6/Yvn17jXW01LnbmOOWlpbm8WfdmDFj6n0WaSmyG6N0zjqxPlddxemrc9XtcqmtXpdLQkICSUlJPP3003Tp0gWTyYSvry+JiYn8+9//ZsuWLR51YwTo3bs3W7Zs4c477yQxMdGtv31dLrvsMlJTU/nwww+5/PLLiYmJwcvLC4PBQFhYGEOGDOGBBx7g119/JTMzk9DQUI/a0lyuuOIKtm7dym233UZMTAx6vZ6QkBD69evHiy++yLZt2xpd2P10io2N5e+//+a1116jb9++BAYG4uXlRZcuXXj66afZs2ePWmT2ZLz44ots376dBx54gK5du+Ln54fRaCQ6OpprrrmGBQsWsHLlSkJCQupch6+vLxs2bOCZZ56hb9++BAQEuBXGlCRJkiTp1Lr11lvZuHEjr7zyCpdddhkJCQn4+Pig1WoJCAigd+/e6v3hjBkz6rxOf/nll8yaNYvRo0cTGhpa74h2rZGiKHz11Vd88803jBkzhsDAQAwGA9HR0Vx66aV89913/PTTTzWy2mqj1Wr5888/ee211xgyZAhBQUFqZkxdIiMjWbp0KStXruTuu++mW7duBAYGotVq8ff3p2vXrkycOJFZs2Zx5MgR7rzzzlrXEx4ezsaNG3nvvfcYPHgw/v7+eHt7k5iYyCOPPEJycjLnnXdek45RQ072HrQl78Hvvfde1q5dy3XXXUdERAR6vZ7w8HCGDh3K9OnT2bx5s5rR1FoNHjyYvXv38tVXXzFhwgTi4+Px9fVFp9MRHBysjjT63XffkZ2dXWu2ZUueu56KjY3lwIEDvP/++9x444306NGDgIAAtFot3t7edOzYkRtuuIFff/2V5cuX1/ss0lIUIc7AoTwkSZJaQFxcHOnp6cTGxpKWltbSzZEkSZIkSZLOAfIeVJIaT361L0mSJEmSJEmSJEmSJJ01ZLBLkiRJkiRJkiRJkiRJOmvIYJckSZIkSZIkSZIkSZJ01pDBLkmSJEmSJEmSJEmSJOmsIYNdkiRJkiRJkiRJkiRJ0llDjsYoSZIkSZIkSZIkSZIknTV0Ld2Ac43D4SAzMxM/Pz8URWnp5kiSJEmnmRCC0tJS2rZti0YjE6wlSZIaQ95LS5Iknds8vZeWwa7TLDMzk5iYmJZuhiRJktTCjhw5QnR0dEs3Q5Ik6Ywi76UlSZIkaPheWga7TjM/Pz/A+cb4+/u3cGskSZKk062kpISYmBj1eiBJkiR5Tt5LS5Iknds8vZeWwa7TzJVu7e/vLy/QkiRJ5zDZ/UaSJKnx5L20JEmSBA3fS8tiIZIkSZIkSZIkSZIkSdJZQwa7JEmSJEmSJEmSJEmSpLOGDHZJkiRJkiRJkiRJkiRJZw0Z7JIkSZIkSZIkSZIkSZLOGjLYJUmSJEmSJEmSJEmSJJ01ZLBLkiRJkiRJkiRJkiRJOmvIYJckSZIkSZIkSZIkSZJ01pDBLkmSJEmSJEmSJEmSJOmsIYNdkiRJkiRJkiRJkiRJ0llDBrskSZIkSZIkSZIkSZKks4YMdkmSJEmSJHkoLS0NRVFQFIW0tLSWbk6rNHfuXBRFIS4urkW2P3XqVBRFYfTo0S2yfUmSJEmSWp4MdkmSJEmSVC9X8MDTH0k6FZKTk5k6dSozZsxo6aacNqNHj671b0yj0eDv70/v3r15/PHHSU9PPyXbX7lypcd/9ytXrnRb9tdff+Xxxx9nzJgxdOjQAX9/fwwGA23btuWiiy5izpw52Gy2U9JuSZIkSdK1dAMkSZIkSTpztGnTpqWbIJ2jkpOTeeGFF4iNjeXhhx+uc77Q0FASExNp167d6WvcKabX6wkODlb/b7VaKSgoYNu2bWzbto0PPviABQsWcNFFF52yNgQFBWEwGOqcfuK0p59+ml27dqn/9/PzQ6vVkpWVRVZWFosXL2bmzJn8/vvv8nNFkiRJanYy2CVJkiRJkseys7NbugmSVK9///vf/Pvf/27pZjSroUOH1sicqqqq4ueff+b+++8nPz+fm2++mcOHD+Pj43NK2vDjjz82qmvotddey0MPPcSwYcOIj4/Hy8sLgMzMTD799FNeeOEFtm7dyqRJk1i8ePEpabMkSZJ07pLBLkmSJElqgBCC/Px8zGYzRqORkJAQ2V1PkqQWZTKZmDhxIlarlVtuuYWCggJWr159SrO7GmPq1Km1vt62bVuef/55qqqqmDZtGkuWLOHo0aNER0ef3gaeQkIIKisrsdls6HQ6vLy81GtGfdNOZr3nOrvdztblO1kyZxnlRcX0KtlIeHAllvh2dHpsCqu3bSM1t5jIQD8mjBtHUEAQiqJgFw72lmRSaCknyOBDon9btIqz0o883q2DEHawbAbHMdCEgaE/iqJt6WadlLNxn1ojWbNLkiRJkuqRlZXFsmXL2LBhA0lJSWzYsIFly5aRlZXV0k07I8TFxaEoCnPnzqW0tJSnn36axMREvLy8CA0N5corr2Tjxo31rsNut/PZZ58xduxYQkNDMRqNREVFcd1119XIdmkOGRkZ3H333cTExGA0GomOjub222/nwIEDHi1vsVj44IMPGDNmDKGhoRgMBiIiIrjiiitYtGhRvcuWl5czZcoUunTpgpeXF+Hh4Vx88cUsW7YMcD+e1Z1YOP/gwYPcddddxMfHYzQa3YrFFxYWMnv2bCZMmECPHj0IDg7GZDIRGxvLjTfeyIYNGxrcxw0bNnDllVcSGhqKl5cXiYmJPPPMM5SVldW7XEVFBfPmzePWW2+ld+/ehIWFYTQaadu2LVdeeWWdx0dRFG6//XYA0tPTa9SLqh5Y8aRAfVJSErfeeiuxsbGYTCaCgoIYOnQoM2bMwGw217rMiYX3t2zZwoQJE4iMjMRoNNK+fXseffRRCgsL6z0Gza13797q77Ud/+Z4v0+FwYMHq79nZGSc9u1nZWUxderUZv8sLy0t5cCBA+zdu5d9+/axd+9eDhw4QGlpab3TTma957o1P27kyqBJ/Hf8y3Sc9xEvL3qR69cuYeyvq7nw3a+Ii0uky/tzKSrU8OOGHM5/+nOe/Wgu647s4t6/P+WxLV8wdfv3PLblC+79+1P+zjsgj3crIaqWII6NQRTegih+1PnvsTGIqiUt3bQmOxv3yVOn6nO3Ls0a7CopKSE3Nxe73d6cq5UkSZKkFpGVlcWWLVuoqqpye72qqootW7bIgFcjFBYWMmDAAF577TXS0tIwGAzk5+fz888/M3ToUD777LNalysuLua8887jjjvuYMWKFRQVFeHt7U1WVhY//PADY8aM4Yknnmi2dm7dupUePXrw8ccfc/ToUbRaLcXFxcydO5d+/frx999/17t8eno6ffv25f7772flypUUFBTg7e1NTk4Ov/zyCxdffDH33ntvrcvm5uYycOBAXnzxRVJSUrDb7VitVhYtWsT555/Phx9+6NE+rFu3jt69e/PJJ5+Qm5uLXq93m/7OO+9w55138v3337Nnzx719cOHDzNv3jyGDh3Ku+++W+f6P/vsM4YNG8bPP/9Mfn4+RqORtLQ0Xn31VQYMGFBvsGf+/PnceOONfPnll2zfvh2r1YpOpyMrK4uff/6Ziy++mMcff7zGcm3atMHf3x8AjUZDmzZt3H58fX09OjYAb7/9Nv369ePLL7/k8OHDmEwmysvLWb9+PY888ggDBw5s8G/7m2++YciQIXz//fdq5kdqaipvv/02I0aMaDDo15y2bdum/p6YmFhj+sm+36fKmjVrAGcgs3379qd9+1lZWbzwwgvN+jleWlpKamoqxcXF6PV6fH190ev1FBcXs2/fPvbt21frtNTU1HqDKPWtt6Flz3ZrftzIi9e+SVWZmTvFdiawr8YDriIcDFzyf9y8bAGD4wIJ8dWzaFsRH3y3mqKSYoxaPYEGH4xaPalluby3/Vc27tkmj3cLE1VLEEUPguOE8gmOHETRg2dkcOhs3KfGOBWfu/VpcrArLS2Njz76iBtvvJH4+Hj1W7HIyEgMBgPBwcEMGzaM//73vyxZskQGwCRJkqQzihDCrbhybXbt2oUQ4jS16Mz2wgsvkJuby/z58ykvL6e4uJjdu3czatQoHA4Hd999N1u3bq2x3B133MHKlSsxGAy8++67lJSUUFhYSGZmJv/6178AePPNNz0OBNWntLSUq666isLCQtq1a8cff/xBeXk5paWlrFu3jpiYGO6+++46ly8vL+fCCy9k165djB49mpUrV1JZWUlRURFFRUVMnz4dX19fPvzwQ955550ay0+aNIndu3fj5eXF7NmzKS0tpbCwkMOHDzNhwgQeeughjh071uB+3H333XTr1o1NmzZRXl5OWVkZf/zxhzq9bdu2TJkyhc2bN1NRUUFBQQGVlZUcOnSIhx56CIBHH32UpKSkGuveunUrd999Nw6Hg9GjR7Nnzx6KioooKytj3rx5ZGdn8+KLL9bZtqCgIB5//HH++usvysrKKCoqory8nMzMTF544QX0ej1vvfUWv/zyi9ty2dnZ6jGLiYkhOzvb7ae2AFlt/u///o9HH30UIQRXXHEFhw4dUtv/xRdf4Ofnx/bt27n22mvrvHc9duwY//rXv5g0aRKHDx+mqKiI0tJSZs6ciV6vZ9euXbzxxhsetedkmM1mfvjhBx555BEALrjgAnr27FljvpN5v5tbWVkZO3fu5Mknn+Stt94C4JZbbiEsLOyUb/tUE0KQnZ2NxWJRgyOKoqDX6/Hx8VEzu06c5uvri8ViITs7u9bryYnr1el0Hi97trPb7XzwkPOLEp1wcC37ADixo6Hr//2W/I6fIugS7osC7DlYRVd7MAZFhwYFo1ZPkN6HaIsPB4sy8fH1kce7hQhhR5S8AtR2nJ2viZJXnd0BzxBn4z61do2q2eVwOPjpp5/46KOPWLZsGUKIOv/Qi4qKWL9+PRs2bOD1118nPDycf/3rX0yePNktlV6SJEk695xMrYKmLtvY5fLz82tkdJ2oqqqK/Px8QkNDPWr72SAiIqLe6RMnTqw1kFNcXMzSpUsZN26c+lqXLl1YtGgRvXr1Yv/+/Tz33HP89ttv6vSNGzeyYMECAN577z3uuusut3bMnj2b4uJiFixYwHPPPcdtt92GyWRq8r7NmjWLw4cPYzAYWLx4MV26dFGnDRkyhKVLl9K1a9c6l58+fTopKSmMGjWKP/74wy2jKiAggEceeYS4uDiuvvpqXn75Ze6//350Ouet2F9//aUW6f7444+5+eab1WVjYmL45ptvOO+881ixYkWD+xESEsLSpUvdsp06deqk/l79OLooikJ8fDwzZszAZrPx/vvv8/777/Ppp5+6zffss89is9no1KkTv//+u1p0XK/Xc/311xMUFMSFF15YZ9uuuOIKrrjiihqvR0ZG8vzzz+Pt7c0TTzzBu+++y+WXX97gvjbWk08+CcCIESNYsGABWq3zM8BgMHDLLbcQGBjI5Zdfzrp161i4cCHXXnttjXVUVFQwadIkPvnkE/U1b29v7r//fg4dOsT06dOZN29evUG/xlq3bp3b355rNEZwnh9PPvlknTWyTub9ru7qq6+uczTGl156icmTJ9c6bcOGDQwZMqTG61qtlkmTJjFz5sw6twnOoF71rqUlJSX1zl8f10iQgBpcrx5kj4yMJDIysknrrqyspKysDJPJhKIoVFVVYTab0Wq1CCGw2+0oioLNZsNqtWK1WjEYDBgMBkwmE2VlZVRWVuLt7V3vektLSxFC4OPjg1arrXfZs93ONSnkZTj/Di7jAPXdCSg4M7x6LF+C+byLCfDSUVRpI+eAnapOVVh1An+DN75CTzje5NrLybeU4WXV4HA45PE+3Syba2Y/uRHgyHLOZxx02pp1Us7GffLAqfzcbYjHmV0///wz3bp147rrruPPP//E4XDQvn17brzxRv73v/8xZ84cfv75Z/744w++/fZbPvjgA5544glGjBihpu+/9tprdOrUifvvv9+jbyYlSZKks8/J1Cpo6rKeLudwOCgvLyc3N5ejR496tD911fc5W+Xk5NT7U1xcXOtyw4YNcwt0uXh5eandEBcvXuy2/HfffQdAdHQ0d955Z63rfemllwDIy8vjzz//PKl9+/bbbwG47rrr3AJdLhEREdxzzz11Lj979mzAmSVzYtdBlyuvvBJ/f3/y8vLYsmWL+vr3338POGty3XTTTTWW02g0PPvssx7tx7///e9Gdes70SWXXAI4A3DVFRUVsWSJ82/miSeeUANd1Y0fP77WwEZjt71+/fpm7xWwfft2tRvfs88+qwa6qrvssssYOHAgAPPmzatzXXW9F65A3oEDB6ioqDjZJqusVqvb35kr0AXOQHJBQUGdf3sNqev9PlFhYWGdf/fl5eV1LmcwGNTuptWDZXfffTdTpkyp9Tyqbtq0aQQEBKg/MTExjdg7dx999BH9+vWjX79+anBu8uTJ6msfffRRk9dts9mw2+1qANtms2Gz2TCbzVRUVGCz2bBYLBQWFlJSUkJFRQUlJSUUFBRQWlpKRUUFZWVlNRIJqq/XarVisViwWq3qdK1Wi8PhwGazNbntZ6r8rH+6TLel7nOwusCcbHQaBYPO+RhcWSYIsRupsloos1ahR4MeLRbsVFqcgVar1aq+L+fy8T6tHB7GCjydr4UIey6iagmOktcQJZ5dw1v7PjXWqfzcbYhHmV2jR49mzZo1CCHo1asXN998MzfeeKPHETiHw8GyZcv46quv+Omnn5g1axZff/01X375JZdddtlJ7YAkSZJ05lBrFZyYwn28VgGB76KYxjfrsg0tV2V6gxLzYMrKyqioqFBvaC0Wi0f7ZDQaPZrvbNHUrhtjx45tcJrD4WDr1q2MGTMGgM2bNwMwZswYNJrav5/r0qULUVFRZGRksHnz5ibfV1gsFnbs2OFRW6dNm1bj9YyMDNLT0wFn18vaAikurnpO6enpDBrk/PbW9S3nyJEj6xzta9iwYeh0ugYfsoYNG1bvdIBDhw7xwQcfsGLFCg4ePEhpaSkOh8NtnhMDvlu3blXnaegYrV+/vs7pOTk5fPDBB/zxxx9qDaMTA1sVFRUUFhY2a9ak63zS6XSMGjWqzvnOP/98/v77b3X+EwUHB5OQkFDrtLZt26q/FxYWNlvmx6hRo2oMxlBSUsKmTZuYOnUqn376KUuWLGHZsmV07NixxvJNeb9PtGLFinqL/telb9++ZGc7sxkcDgeHDh1ixowZzJo1iy+++IKvv/663iy+p59+mkcffVT9f0lJSZMDXnfffTeXX345lZWVDB8+HICZM2eqAdqTyS7Q6XRotVpsNht6vR4vLy8MBoMa8KqeKazT6bDb7WpdPofDgRCCQ4cOkZWVhZ+fnxrcq75eVwDVZDKpnzF2ux2NRqMG2c4lIZFBIBxMZB8XkurRMkVWE9p9x/D98wBmfxMiMJqOShDhdm8qq2wYtRoUAV7o0Fqd1zuDwaAe33P5eJ8uwlGAMK/0bGZN6+kCLYQNbHvBkoSwJoE1CeyefXHqphXtU3M4lZ+7DfHor3T16tWMHz+eqVOnqjdljaHRaDj//PM5//zzqaio4L333uOtt94iKSnpjAl2bd26la+++oply5aRmpqK0WikS5cuPProo1x55ZUt3TxJkqRWr6FaBQIFR/HLmG1D4MTuhcKOsfxlFESNWhz1LtvQcgKU8tfIyf8AjneA0Ol0+Pj4EBkZSXFxcb2ZWyaTiZCQEA/2XoqKivJoWm5ubo3f61sWnJlfGRkZbss2VkFBgRpEqm970dHRtb6emZmp/p6Xl+fRNqtn/rgy3qsHS05kNBoJDQ1VAwd1CQ8Pr3f6woULueGGG9zObX9/f7WblCv75MRsnerHtynHCJwZWxdffDFFRUXqa76+vnh7e6MoCna7XT1+5eXlzRrscrXfNaJnXVztr+t88vPzq3PZ6g/A1bNvTgV/f3/GjRvHwIED6dGjB+np6dx9990sX77cbb6mvt+ngkajISEhgZkzZ9K+fXsee+wxbrrpJvbt21fnA4/RaGy2LxVc3WWq72vv3r3p27fvSa/by8sLX19fiouL1QCVVqtVuym6gl1BQUE4HA7sdrua/VVRUYFOp1Ozi8vLy8nOzkZRFEwmE2azmZKSEhRFQavVqtlwQgiqqqoICAhoMEPurGOx0P3nT/k/5ReMwvnZ7bq7qO3rAgEIRSFl+HkUpBdSvDMLnYDMtalkzdDiG+dP0NAwNMNCoY0f7ZUAHOVmLDod3t7eOBwOtXvqOXm8TwNhz0GUz4bK70BUNjC3ApoIMPQ/LW2rjXAUHQ9sJTsDW9btIE7M6NWArhPo+4C+F5S9CY58ar8Xbvl9OhVO5eduQzwKdq1fv75JQa7aeHt789RTT/Hvf/+btLS0Zlnn6fDGG2/w559/cvXVV3PfffdRWVnJvHnzuOqqq3juueeatS6DJEnSWamBWgUKAkXkkH3k/yi3dneb5qPfSXxQTqOXbXA5BQzafNoEHUHnPQwfHx+MRqOaWdO9e3e3rmYn6tatW51ZONK5pXpm0p49e+jcuXOT1tMc51N9WWX5+fncdtttmM1mxo4dy/PPP8/AgQPdHtyWLVvGeeedd9LtOJHNZuOGG26gqKiI3r178+qrrzJ8+HC34NHBgwfVrClZANozfn5+TJw4kTfeeIMVK1aQlZWlBo5a8v1uyH333cd///tfdXCD6tlbZyJFUYiIiHCrsaXVarHb7VRVVeHv768Gp0wmE3q9Xp0WGhpKVFQUWq1WLWRfXl6OzWZTR/usrKxECIFeryc/P19dt9FoxN/fH5vNphZTP6uVlMADDyDmzUNrtaLFGTbICowg0yuYflm7EbgHvFyfJNsuvBRtXAiFe/IwBXlTVVgBAoTZTuneQkr3FsKcfaSYtIS3D6HjkFg6D++ATqdTsyFNJhN+fn5uXValkyNsRxHln0Ll98DxLwl03cEwBCpcdQSrXw+c767i/1+P672edBuFA+yH/snasmx1/v9Eih/oe6MY+qgBLkXzT1kBofE53ttAoaX36Vzg0V9ocwW6qvPx8aFbt27Nvt5T5YEHHmDu3LluhW8feOABhg8fzrRp03j44YcJDg5uwRZKkiS1ch7WIDAZy7Bp3L/FN+nLmrSsp8uFh2pQvGpmaEVGRtKvXz927drl1gXFZDLRrVu3U5p6fbbJyMjwaFr1rKTw8HD27t3bYPcq1/SGMprqExwcrD48etrW6qoXD09PT290sCssLIy9e/e6ZYidyGw2e5w1Vpfff/+dkpISgoKC+PXXX2vtZldX5lj145uRkUH79u1rna+uY7R+/XrS09PRarX83//9X63ZYQ1lrZ0MV/vz8vIwm811Zgs1x/l0usXGxqq/p6WlqZ9NJ/N+n2omk4ng4GCysrI4cOBAi7QBGh50ozH8/PyIj48nOzubsrIyzGYzGo2GgIAAdTt1TXMFfYOCggBnl8/KykoKCwvJzc3FarVis9nU7C+NRqN2ryssLKSoqEjNJDMajeq/RqOx3gD4GSMzE3HXXbBoEYrD4QwVKAoVffvy+vjR7J5XSHFaCXdi41r2uRWrF4qGTRdczDdjriYlvRhd90jGXdsNH28vklfup2hzJsUH8rAWO6/z9io7Wbtzydqdy+rZm9AZdbRJCKXryAR6j+tGoX8hxcXFGAwGvL298fLywtvbWwa/GknYDiHKP4bKX4Dj3fP1/VB87wPDcBRFQRh6OnsFVP+yVBPhDArVUfaiWdrmKHNmalmTEZatYE0GUcvgGNp4MPRF0fcGfV/QdUBR6i6LrpjGQ+C7LbJPrUlzfu7WR/5Feqi2+hdarZarr76aDRs2sG/fPgYPHtwCLZMkSTpDeFiDoG1ULxRjottrwlyEKKxjgXqW9XS5+toWGRlJREQE+fn56gNySEjI2f/teTOrbxRB1zSNRkOfPn3U1/v378+aNWtYsWIFDoej1rpdKSkpanBlwIABTW6fwWCgZ8+eJCUlsWLFCv71r3/VOt+JXcRc4uLi1Nphv/76K+PHN+6GtW/fvvz111+sWrWqznnWrl170kWRjxw5AkBiYmKd9aSWLl1aZxs1GufIZCtWrKgz2FXXMXJtOywsrM5ukHVtG1Df/6ZmfPXv7+waYrPZWLVqFRdccEG9bTiZ8+l0qx4Q9vHxUX8/mff7VCstLVW779bXNfRUa+6HLj8/P3x9fdWMLJ1Oh5eXl3rNqG9adRqNRs02rqysxGQy4e/vj9lspqysTK25ZrfbKS0tRavVotfr1Syw6nQ6XY0AmMFgqLMWYquyZ48zyLV2Lcrxv32h0VA2ejTHXp/GvXmLKaQKhoYRvlNh/9/teTJvCB3+SqatowxxSVd6fTCdPdu2EZhbzFXt23BBv4GYKyuw2+306hjP0v57KSyuxG6xk7MjC8eeXMoO5WMpcXb9tZltZOzKJmNXNn/O+gudUUfbxDb0GNOZrsM7EtOlLRqtRga/PCSsKYjyWVC1GDW7yTAcxfdeFIP7565iGg/G85o8grdH7REC7EfA6sraSnLW3sK9riGKF+h7gr4Pir4PGHqhaBqf7HI69qm1k8GuM4TrG9iwsLOrkJwkSVKzM/QHTQTCkV1rPY16axUcXxZHDo2qc9DU5U6cS1GatXbQueivv/5i5cqVNQpcV1VV8dZbbwHOkfwCAwPVaddffz1vv/02GRkZfPrpp9x111011vv8888DzjpMJ9sVa+LEiSQlJfH999/z7LPPkpjoHnTNzc3lww8/rHP5yZMnM3XqVGbPns0dd9zhFrg7UUFBgVtG+LXXXsu7775LWloa33zzDTfeeKPb/EIIXn311Sbu2T8CAgIA2Ldvn9qdqrrk5GS++eabWpcNDAzkggsuYPHixbz55pvcdNNNNZZfunQp69atq3fbrhH82rRp4zb96NGjvPvuu3W23d/fH8Ct3ldj9OzZk65du7J7925efvllxo0bVyPj5ffff2fjxo0A3HDDDU3azulWVVXFjz/+CDgDKdXP25N5v0+GK5BTn//9739q8LYphe9bM0VR6gwu1jetNnl5eTgcDnx9fYmKilJr27lqe5WXl2O32xFCqKMEumqGueZ11QarXjNHURT0en2NAJjBYGgdX+asXYu47z7Yvl29ZxA6HSWXXUbV66+jbRvOzX/9DxsOQBDnXcq3tyWhPPQGimkcX7+ygPef+5aI3WFc0iaW2y77Z1AJIQRZWVmUlpYSYjRy71Xns3jDDpL3pdFpaBxh4ztRUmljxfZszIfyic6vovJQHmUFzuNnM9s4vD2Dw9sz+O2dZWj1WqIS29BtdCKdh3QgrkcMWr1WDX65AmDnevBLWLY5g1zmal+IGMc5g1z6nnUupyhaMDZfTzMhzGDd6QxuWY4XknfUkjWtiQJDH2fWlqEv6BJRlNpHWm6s5t4nqXZnQDj/HxUVFSxatIiXX36Zq6++mtjYWBRFQVEUpk6d6tE6SktLmTp1Kj169MDX15eAgAAGDBjAW2+95fHIWy4ZGRnMmTOHQYMG0aFDhybskSRJ0rlDUbTg94yzPkaNuFP9tQoURYvi/4zbvJ4s29TlpOYXEBDANddcww8//KA+4KakpHDJJZeQkpKCVqutUf9y4MCBXHPNNYCzdMDMmTPVou7Z2dlMnjyZ77//HoCXXnqpxoN8Y917771ER0djNpu58MILWbZsmZpFtHHjRs4777waI9hV99hjj9GjRw+qqqoYM2YMM2fOJD8/X51eVFTEokWLuPXWWxkxYoTbsiNGjOD8888HnEGzuXPnqgXFjx49yk033cSaNWtOenS/Cy64AI1GQ0FBATfddJOaFWexWJg/fz4XXHBBvVk2L730ElqtVn3v9u7dCziDG/Pnz2fChAluAcvqhg8fjo+PD0IIJkyYwL59+wBnZsqSJUsYPXp0vQ/Z3bs76/GVlJQwf/78puw+r7/+OgBr1qzh2muvJTXVOYKb1Wrl66+/VgNcQ4cOPSMGINq9ezfXX3+9+j7cf//9bt0zT/b9birXCIs//vijW6F/h8PB9u3bueuuu3jppZcAZ++JCy+8sNnbUB+tVsvFF1/MxRdf3Kq7+FVVVVFS4uw6FRYWpv59aLVa/P39iYyMpEOHDkRHRxMUFKTWAlMUBYfDodaY8vf3Jzg4mKCgILy9vdFqtQghsFgslJWVkZ+fT2ZmJmlpaezfv5+0tDSysrIoKCigrKwMq9V6+mro/fwzokMHxPDhKMcDXQ6TicI77iA/PR2f+fPRR0Vw2Zo3sAlnoCvBVMS3PTJRQhaimMYBcM0jlxLSNojstGP8+sESt0246quZTCYcDgelJcVcP34Yt10+hmBfE8IhsNod9O4cQqcR8RwbGUfmDX0YMes27pp5O/0v7IVPwD+fxXarncM7M1k0cwVv3/Qpj/Z9gdeufZ8f/vd/bFy8hbRDaRw8eJC0tDRycnIoLS096SzdM4UQAmH5G0fBbYiC644HuhQwXYwS8guaoFn1BrqapQ32HETVYhwlr+LIn4DI6YsouAFR+gaY/zwe6NKDvjd4344S+C5K2Go04SvQBE5H8bkVRd+92QJd56oW+dwVjZSSkiImT54sevfuLXr06CFuvPFGsWLFigaXi4iIEFqttrGbc7NixQrB8cE0TvyZMmVKg8unpaWJuLg4dRlvb29hNBrV//fp00cUFBR41Jby8nIxYMAAYTKZxLZt2zzeh+LiYgGI4uJij5eRJEk6WxQVFYnUlI9E1dHBwp7V8Z+fnJHCUbm4weUdlYuFPWdEo5dt6nKnwpl4HZgyZYp6rWzTpk2DP2vXrlWXjY2NFYCYPn26SExMFIAwGo0iICBAXaeiKOLjjz+uddtFRUVi1KhR6rw6nU4EBQUJRVHU1x5//PFm29dNmzaJwMBAt3sFX19fAQg/Pz/x3XffqdNSU1NrLJ+RkSEGDx7stm+BgYHC39/f7b4lISGhxrJZWVmic+fO6jx6vV5ti0ajER9//LFo166dAMS8efPclk1NTa23XdU99dRTbm0JCAgQer1eACI+Pl58/fXX6rTafPTRR27HPyAgQL2f6ty5s5g+fboARGxsbI1lZ82a5bZtX19fYTKZBCBCQ0PFL7/8Uu9+jBs3Tp3u5+cnYmNjRWxsrHj77bfVeVzn66hRo2pt//Tp093aHxgYKAwGg/r/Hj16iIyMjBrLzZkzp879cmnM++AJ17mv1+tr/J15e3u7HcuJEycKi8VSYx0n835Xv/f25H7fxXWsXD8+Pj4iNDTU7TgDYuzYsSI/P79Rx+RM/AxtCofDIY4cOSJSUlJqPR/rWqayslIcO3ZMpKWliZSUFLef1NRUcezYMVFRUSEsFosoKysTBQUFIisrS6Snp4t9+/bVWMb1s3//fpGeni6ys7NFQUGBKC8vF1artfl2+OOPhSMiQhz/PkwIELaAAJH35JOiIC9P2Gw2IYQQx8qLxKBF/xUDFv1HDFj0H3HrysnCXvSccDiqaqxy0exl4jzlWnFV8CRRUlBaY7rFYhEHDhwQKSkp4ujRoyIvL0/s3r1HfPHzn+LGKR+Jh9+cKx6bMVc88f5ccde02eLCJ2aKIQ+8I6b/sEoUlJSLzEPZ4udZi8UT500Vl/reJM5Trq315wLddWJSl/vFtMlviwUf/yySNyer70d2drYoKSlp3mPZCjgcDuGoWiXseROr3Xt1Efai/wiH9dAp3K5FOCw7hKPsc2EvfFjYc0a73/up94BDhL3gPuEo+1Q4zJtrPX+k1svT60Cjcil//fVXJkyYgMViUaP7u3bt4ttvv+XGG2/kww8/dKsTcCLRDN8IBAUF0bdvX/XnkUce8aiwps1m47LLLlOLdn7xxRfqN7Tff/89kydPJikpiZtvvpnffvut3nVZLBauvvpqtm7dyvz58+nZ89RGoyVJks4GQghycnKoMg/GFHAJbYKONrpWQVPrHMj6CM0nJ6fu0S1dasuUDgoK4u+//2batGksWLCAI0eOEBwczLBhw3j66acZMmRIresKCAhg2bJlfP7553z55Zds27aNsrIyIiIiGDp0KP/+97+btQtU//792b59Oy+++CKLFi3i2LFjhIWFcc011/Dss8822A2lbdu2/PXXX3z//ffMmzePzZs3k5eXh0ajIS4ujh49ejBu3DgmTJhQY9mIiAg2bdrEG2+8wfz580lLS0On03HxxRfz5JNPMmrUKJ544gmAOrOnPPHaa6/RrVs3Zs6cyY4dO7BarSQkJHDVVVfx5JNPkpSUVO/yd911Fz169GDatGmsXbuWiooKYmNjueaaa3j66adZsGBBncvec889tGvXjv/9739s3rwZm81GVFQUF198Mf/5z38azLL/4YcfePHFF/ntt984fPgw6enpQOO6Nj7yyCOMGjWKt99+m1WrVpGTk4OXlxd9+/Zl4sSJ3HvvvXUWr28pVqu1xt+eyWQiPj6eQYMGMWnSpDqzo072/W6KSy65hE8++YSVK1eSnJxMTk4OhYWFeHl50b59ewYMGMD111/PxRdf3OzbPlu4uihqNBqPy6UoioLJZMJkMhEaGorVaqWsrIyysjIqKysxm82YzWby8/PR6XT4+vri4+NDQEAAGo0GIQRWqxWLxYLZbHb71263U1lZ2WA9MNe/HtUDczjg1VcRb76JUlysjk9nCw+n6PHHMdx1F8H+/mpG25GKPK5bPR3H8bIEvXzy+bj/xSheV9a6+vMnjWLB2/9H2q4jfDttIZPfuMVtul6vp23bthw9epSSkhLy8vIwmUxcPmoAvbp34+Uv/8BhrSQq0ERQiJbw4EAKiiys2LyTH//azoRRvbn1llFcfs94hBCk7z7K5iXJrP3lb/b+fRBrlXNkQYddkJGSQ0ZKDss+XYuiUYhICKPT4PZ0GtSehH5x+AR4YzQa1XpfZ2q3RyEcYF6KKPsQbDuPv2oA72tRfCajaGuv19jk7TkKwZKMsG49XmtrB4jKE+bSgC7xeJfEvs4MLm1M6+iuK51SivAwApWZmUnXrl0pKSnBy8uLMWPGYDKZWLt2LTk5OSiKQvfu3fnzzz9rHb0mMjKS3Nxct6G5G8tut9dIeYuLiyM9PZ0pU6bU25Vx9uzZ3HnnnQCsW7euxk31vHnz1PoYS5cuZdy4cbWux2q1ct111/HLL78wZ84cJk2a1Kh9KCkpISAggOLiYrX2hCRJ0rmguLiY9PR0NBoNnTt3PiNv4prDuXYdcF2n58yZw2233dbSzTmj7d+/n06dOgFw+PBhYmJiWrhFknT6nQufoUII0tLSsFgsBAcHN0ttYFedr7KyMsrLy926ZLuK4buCXyc+b4njXR6rB8DMZjNWq7XO7en1erdaYK5/FUUBiwWeeALx8ccox0c6FoAlLo7iKVPwvvZafHx83IIRqSU5XL/uHcTxQNdAvxLeG/gQir5Tvfu98fetPHvpNPRGPXNS3qFNbM1jWVJSwoEDB6iqqiI4OJjExEQURaHSYmXmT3/x/apttA0wEtvGRHxMIJWFdrIKyjhSVElxlWDimD7cOK4vfl7/BMntdjsHtqayZel2Nvy6iX1bUrFb63gOVqBNfCgdB8XTcUA8HQe2xz/E94wKfglhg6pFiPIPwbbf+aLiBV7Xo/j8C0Xbpv4VeLQNB9gOgnXrP4Xk7ak1Z1T8Qd8bxdAX9H1A3wNF43vS25daD0+vAx7/xcycOZOSkhJiY2NZsWIFcXFxgDNj6q233mLKlCns3LmTMWPGsHz58hpFR5vDyfTt/PzzzwEYM2ZMrd8eX3/99TzzzDOkpqbyxRdf1Brsstvt3Hjjjfz888/MmjWr0YEuSZKkc5UrqwuchcRb8w2bJLVW06ZNA6Br164y0CVJJ6G8vFz9cj43N7feniktoaioCIvFglardRvI4mS46nz5+/vjcDiorKxUs75sNhulpaWUlpaiKApeXl74+vri6+ur1gBzBa6qczgcNTLAzGYzNpsNq9WqZpapbSgtJeLll/H57TcUm03N5DJ37UrJ66/jN24c4V5eNdq+v/AQN2/8RB1mZliAjemDXvcogDHwoj70HtON5BW7mPv8tzz1+QM15vHy8lIz0ex2O1VVVXh5eeFl0PPEhDGM6tmBp+f+xtq9RRzMqmRE7zZc1KETWw9kcKyonKUbt7NgdTI3jOvHxFG98TYZ0Gq1JA5IIHFAAjc+fTUWs5U9G/aRvHwnG37bzMHkdITj+B4JyDmUR86hPP6atwmA0NhgEvrH0nFgexIHtSewTYBb8MtVe62lCWGByp8R5R+B/bDzRcUXvG911rpqwmiF6rodZWDdVq2QfDKI0pozatuDoe/xERL7gLY9inJGlSY/J7TE567HTxt//PEHiqLw9ttvq4EucKauPvXUUwwbNoxrrrmGlJQUxowZw4oVK05JwKspKioqWLt2LQAXXXRRrfMoisKFF17IrFmz+OOPP2pMdzgcTJo0iR9++IG3336be+6555S2WZIk6WxSUlJCVVVVo7pjSNK5JiUlhTfffJNbb72VPn36qIXDU1JSeP3115k7dy4A//nPf1qwlZJ0dnANdtHa2O12dWCL0NDQUxLQcGVy+fj4EB4eTlVVlZr1ZTabqaiooKKigtzcXEwmk5r1ZTQa3bKtNBqNMyh0QoDKbrer2V8WiwVrWhpBTz6J95o1KMc7FQlFobhPH4488wy6Ll3w9vbGUVxMVVWVmgmm1WrZmfcXd275XQ10jQnx47X+T3vcBU1RFO58/Rb+PfA/LPtqDdc8fCkJfeLd5snPz1cDXlqtlszMTNq1a4de7yxIPrBzO36e8i8e/vxHtm7LZv6qw2yPKeb+8f0pKi1jy76jFJRW8se6ZH5Y6Qx6XTuyFybDP4/aBqOeXqO60WtUNya9MJHKskp2rEkhafkO/l60lcO7M9zalJdeQF56ARsWOLsZB0cF0qF/LAn940gc3IGQKOeABK6sr9Md/BKiCiq+R5R/Co4s54tKIIrP7eB9M4qmcQNfCCHAfsSZtWVJAutWsO2jxkjaihfoe4G+D4qhjzODSxPYLPsknXqn+3PX42DXgQMHUBSlzmDR8OHDWbVqFWPHjmXv3r2MHj2aFStWEBER0WyNbao9e/aoqbqukXxq45qWnZ1dY0jwJ554gq+//pohQ4YQGhrKV1995bbs0KFDad++/SlovSRJ0pmtelZXWFhYq/gmUpJao6qqKmbPns3s2bMBZ70yq9XqdnP44IMPcsstt9S1CkmSznAFBQXY7XaMRiMBAQGnfHuuTC4vLy9CQ0OxWCxq4KuyspKqqiqqqqrIz89Hr9ergS9vb+86A05ardaZfZSairjrLli3Th0PWWg0FI8eTe6LL6KLjMRosyGEULdT3RHbb/z3yDH1/xeERvNCn3saXWspsX8HxtwwjBXz1vLJf77i9SXPqdPMZrM64mX79u3Jy8vDbDaTmZlJTEyMmvHl62Xk03tu4KWl/8cvv+1nz5FiHvxsOfdc1J+bLhjI7kMZbNl/lOLyKpas28qC1UlcP7Y/Vw3rjkFf85Hby9eLgRf1YeBFfbj7f7dSkl/KtpW7SFq+g81/bCProHuNvoKMIgoyitj08zYAAsL9aN+vHQkD4uk0sD0R7cNOS/BLOMqg8ltE+WfHRzEENOEoPv9ydlnUeDZisBBVYN0JliRnvS1rEjgKas6ojXYGtvR9wNAXdJ1QFNk7QPKMx2dKRUUFAQEB9Rbs7Ny5MytXrmTMmDHs3buXsWPHtooMr8zMTPX3qKi6i+JVn5aZmekW7NqyZQsA69evZ/369TWWnTNnTq3BLte3Gi6uD1NJkqRzRfHxb2q1Wi2hoaEt3RzpLLdu3TquvvrqRi0zdOhQfvzxx1PUIs916NCBN998k6VLl7J371611mlMTAxDhgzhrrvuqrOmqNR6NeWLX08GX5LOPhaLhcLCQsCZ1dUSBbQNBgMGg4GgoCDsdrta46u8vByr1UpRURFFRUVqQKvWOl9r1iDuuw927lSDXA69nrIrr8T6v/8RGB1N4PH5XUXxq2eCWcwlHKyYyX+P/JMdNNo3llv8xnDgwAH0er2a/eWqBWYwGOotin/7yzew5ocNbP1zO5v/2Eb/C3oBkJeXhxACPz8/fH19MRgMHD58mKqqKrKzs4mMjHR7H54ddwn+4YtZ8FsKZYcFH/y2ieXb03n+xtH07NiO5L1pbNmfQVmlmcV/bWbh6iQmjOnHZUO7oa8n+OQf4seIawYz4prBznZl5JO0fCfJy3ey5c9t5GcWus1fnFtK0qJdJC3aBYBvsDfxfds5M78GdaBtpzZu9b5ONvglHMVQ8SWi/HMQxc4XNVEovneB19UoSv2Degh7drXuiFvBugc4seabHvTdq2Vt9UHR1qwFLkme8jjYFRwcrEa66wt4derUiRUrVjBmzBi3Lo0tqbT0n7693t51R5urT6u+DMDKlSubtO1p06bxwgsvNGlZSZKkM50QgtzcXODUdceQWre0tLTTuj2LxeLRiJHVFRTU8m1yC/Dz8+Oxxx7jsccea+mmSM2oseejdO5yBV5cXQxbmlarJSAggICAABwOBxUVFWrw68Q6X97e3gQsX47P88+jpKf/E+Ty8qLk1lvh5ZfxDw6uEZBSFEUNVvn5+SFsh1l+6EWePhLrmoPLQ3txW8QwZ5fI47XArFYr5eXlbuuprSi+q+ZYZHwbrrj/QhbM+I1PnvqSPuO6Y7FYKCsrQ1EUQkJCAGewzzVCY2lpKUajUZ3m2s6/e4zHqrOxfOsBjm2ClCO53PbWAu67fCjXDu9Pn87t2bT7IEkHMqiosrBozSZ+WpPEhDH9uWhQF7QejFQZGhXC+beM4vxbRiGEIPNgNknLdpK8Ygdbl+2gNL/Mbf6yggp2LE1hx9IUALz8TcT3iSGhfxwdB8QT2z0abx9vtwCYJ/dkwp6PqJgDFV+DOH68tfEovneD6TIURV9zGWEF2x73URJdXR2r04RVC2z1BX03FMXQYJskyVMeB7u6dOnC6tWr2bBhA6NGjap3XlfAa/To0ezdu5cxY8bUGKb2XPH000/z6KOPqv8vKSmRRWUlSTpnyKwu6XQbPXo0Hg40LUmnhTwfJU9UVlaqgaOwsLAWyeqqj0ajUYvWu7odugrce33+OaHvvYeu2hcHtoAAiu67D8OTTxIQEODR/oiqP1mcOp0p6b2Pv6Jwa9xI/t35QnUeVz2wE4vi2+12Z1aYxeKWtKDRaNTA10X3jWXRnOUc2pbO0q9W02VMBwD8/f3dkjm8vb0JDw8nJyeHvLw8jEYjvr7/FMPXKhoeSLyQMttP7GhzlIK/tRQftTPjxzWs3HaQFyaN57IxQxjYLY8NO/aRfDCDSrOV31Zv5Oc1W7lm9AAu6J+IRuN53bGohEiiEiK59O7zcTgcpO08QtKyHSSv2Enyyl1Ulbl3Aa0sqWL3qv3sXuUcGdHobSC2VzQJ/WPpNLA9cT1j8PX3rTP4JezZiPLZUPEdcHzdukQUn3vAdCGKUm1eR8Hx7ojHR0i07vhnmX+OGugSwdAHRX98lERtVKs7z6Wzi8fBLldNru+//77BYBc4A14rV65UA15CiBY7mV0FXqH+omjVp1Vf5mTUNnKJJEnSueDEERhlVpckSZIk1VQ9C7qhsjGtgaIoeBmNmF5/ndC330Y5XqZFAJawMI7efz+V11yDTqfDUFBAlcWCr68zsFLb86AQVkTpdH45/AevHh3o2gqTO4xlcsfz3OZV64FV65EjhMBms9UIgFksFhwOh1s9sPPvHMnPby3h06e/4pHv7sDL14uQkBAqKirUovgAgYGBmM1mioqKyMrKol27dm7vi1Gr54mul/OC/Xu0I48RdtiLjE02kg9mcv0rX/HI1SO4ZkRPrmwTxpBeefyVlMK2QxmYLTb+b+V6fv1rK1eP6c/Y3h0b/Yys0Who3zOW9j1jueaRS7Hb7OzdfFANfu38KwWbxea2jLnCwr71h9i3/hC/swK9UUe7HlF06B9Lx4HxdOgTh3+gHyZDGV78hJeYj1ZzPFlF3xPF5z4wjgEcYDuAULskJoE9rWYjlQAw9P4nsKXvgaJp+WxF6dyiCA+/btqwYQNDhw4lICCAtLQ0jwsm7tu3j7Fjx5KZmYmiKNjt9pNq8Ini4uJIT09nypQpTJ06tdZ5tmzZQv/+/QH4/fff6yyy/8EHH3D//fcDzlE5mmuo3+pKSkoICAiguLgYf3//Zl+/JElSa1FUVMThw4fRarV07txZBruOk9cBSZKkpmuOz9DKykr1eWDRokU1RhM83UpKSsjKykKj0RAfH49O14oLcFdVIR5/HGbPRjkeQBKANT6ekpdfxnT55Wqtr4qKCnWQMHAGqqoXuNdqtQh7DqLoYX7IzOfNjH5wvAPkAx3Hc0uHhhMs6lO9HpgrAFZaXMZz571BYVYx5987nPPvHOkWOKteD0yv11NQUIDFYsFgMNCuXbsa702hpYznt31PrrmYNo5gyjYZST7grBc9uEssU245nzZBftjtdrKP5bFqyy52HMrCYrVhtQs0BhPXjBnA8B7tmy0xxFxpZvf6fWrwK+XvAwhH/Y/8Wp2G6K4BdOitoWNfDQm9ITA0DK+AoXiZjHjrdqKxbwVrMoiymivQJThHRtT3BUMfZ1dHpeHumtK5ozk/dz29Dngc7AJ49dVXsVqtXHXVVfTs2dPjxhw8eJBXXnkFIQRz5szxeDlPeBLsqqiowM/PD4fDwRtvvMETTzxR63z33Xcfs2bNIiIigqysWvoVNwP5kCNJ0rlACMG+ffswm820adOmxQcqaU3kdUCSJKnpzrbPUIfDQVpaGlarldDQULf6UK1KYSGOe+9FWbAAxebMGhKAuXt3yt96C7/RozEY3OstVa/zVVZW5pb0oCgK3oZMvB3v8muJlfezu+MKdD3e+TImxA05Zbvy84e/M/O+OZj8jLy94QVMfka1HtiJHA6HOsCYt7c3ERERmEwmt3pg2ZVFPLf9O0qslXTxi6JDXjwf/LwOs9WOr5eRpyaO4eKBnVEUBYfDQXZuHkv/3sHutCysNjt2ITB6+XDlyH4M7hbf7L2hyksq2LF6jxr8OrQ9vcFlNFqFtp18aN/bQMe+Ojr1FQSHluNlKMDLWImXbwxaY6/j9bZ6o2hO/cihkuRySoJdrZEnwS6AkSNHsmbNGsaOHcuyZctqTBdCkJCQwKFDh7j11lv5/PPPT0l7z7YLtCRJUm1kVlfd5HVAkiSp6c62z9D8/Hzy8vLQ6/XExcXVO6Jgizh8GMfkyShLl6Icz9ISikLl4MFUvfMO/n36eJSJJoSgsrKS8vJySktLsZavR1g28lOZjh8rTep8/0m8jKviBp+y8jcOh4NDhw7x8uXvkJGSzTUPX8I9028DUOt+VR8Z0vV7SUkJQgiMRiM+Pj4oiqLWAzMYDOQ4yngrdTFmYWNgSAJXBQ3hhS/+ZGeac2TVsb0TeObGcQT5eavHIzM3jyXrt7E3PQub3YEQ4OPny2Uj+jKwS/wp2X+Awtxiti39P5L++I3kNWVkpjbcbVZRICIhkPZ9Y0gY0InOgzsSFhXa6IL3ktQcZLDrBLNnz+bOO+9EURTWr1/PoEGD3KbPnz+fiRMnArB06dJTNrT32XaBliRJOpHM6qqfvA5IkiQ13dn0GWqz2UhNTcXhcBAZGdm69mf7dhx33YWycaM6sqLQaik//3ys775LQIcOTQrMCUchjsInsFRs5f2jPZlf3FaddnfocIb7dcBgMODr64uPj0+ddb6aqqCggGPHjrF/Yyrv3DYbnV7LZynvEBlf+72KEAK73U5hYSGZmZnYbDa8vb3R6XRuXTQBDpqP8VneeuwIhvp34Ma2Q1i4YR+fL9uG3eEgyNeLZ286jzG9E9zWn5GTz+9rt7L/SI66zsAAfy4d0Zc+nWJpLg5bJlTOh8ofwZGtvp57VE/yWl+S//Ilea0f+dnuIywqilLrQBthscG079eOhAHxJA7qQNv4CDXwJYNf0ql01ga7CgsL3VJg+/bty5EjR3jiiSd48skn1ddNJpPbqBk2m42+ffuyY8cOoqKi+Pzzzxk3bhwOh4MFCxZw5513UlJSwkUXXcTvv/9+ytp/Nl2gJUmSalNYWMiRI0dkVlcd5HVAkiSp6ZrjM7S8vJy4uDgA0tLS8PFpmcLZ2dnZFBcX4+XlRUxMTOsYmW7lShz33YeyZ48a5HIYDJRdfTW8/TZ+bdo0uZ3Csg1R9BA4Mnn7SG++y/8n6PN8xyvobYyioqLCLbCi1WrVUSC9vb1PKvPNbreTmpqK3W4nIiKCaRPfY8sf2xh9/TCe+ebhBpd3BcoURaFt27YYDIYamWBbi9L4Kv9vBIKxfolcENCFtNwSPliSzJF8Z62r83rF89CVQwkO8MNoNKr7dDg7j19WbyEtI0c9BuEhgVw0rA89OjTu/BDCAtY9YE1CWLaCZSOIwpozaoJBPxDF0Bv0fRG6LmTszyNp2U6SV+wgecUuSgvca3RptAoOe80QQnBUAPF929GxfzyJgzsQ3bGtGrCUwS+pOT93T2mwSwjB6tWr+eOPP9i1axeZmZnqEK9+fn60bduWbt26ccEFFzBy5Mhm/eB2ZXI1ZNKkScydO9fttbS0NMaMGUNaWhrg7HftGqEDoE+fPixbtoygoKBma++J5EOOJElns+pZXREREYSHh7d0k1odeR2QJElquuYKdrm+FC8rK2uRYFdVVRWHDx9GCEG7du1avEg+8+fjeOIJlMOH/wlyeXtT+q9/oX3pJXwCApoe5BICKr5GlE4DrLx2dAQ/5f2TSTWj7ySGhicCzoCUq85XeXm5W5KDRqPB29tbzfpqbCH/Y8eOUVBQgNFoJDY2loPb0riv31MIIZi5cRqJAxLqXd41ynRxcTFarZZ27drVqFMmhGDJ0SRmH1qJEIKrQvswxDuOisoqftiwn1+3HEIICPY1cff5PegVF+5WFN9gMJBTVMb/rd3Gkaxc9b2ICg/mgsG96FZH0EvY852BLWsSWLaCdSdgrmUvFNB1Aq8JKKaxoGlb7/vqcDg4tC2dpGU7SFqxkx2rd1NV7r5erV6L3VpzEDr/MF9n5lf/OBIHdSCuWzsZ/DqHNefn7ikLdv3www889dRTasAIqJHWWP0PJi4ujjfeeINrrrmmMZup08kEuwBKS0t58803+fHHH0lNTUWj0dCpUyduuOEGHnjggRofWM1NPuRIknQ2k1ldDZPXAUmSpKY7G4JdQggyMjIoLy9XEwVahBCImTMRL76IJi9PfdkWFETZQw9hfPxxvE7y2AhHOaLkWaj6DYAXD1/G7wX/1Ij6aMBk+oTUXp/KVefLVeC+egF5RVHUnjy+vr4NPsNZrVbS0tJwOBxERUWp7/8bt83kzy9W0XNUV95cPrXBgJ7D4eDo0aNUVlaqIzTWdq+z4PBG5h9eD8CDiRcxODjBmfm1/wjTvltNZoEzUeS8nu24aURnTHr3wJ2iKBwrqWTFtkPkFRWjVRRQILZNKOcN6kZidCUae7Iza8uaBPbDtbRWA7i6WhrB+3oUn7tQtGH17mN9rBYrezcdVIvd71m/D6vF5jaP3qjDZrXXGAHSJ8iL+D7tSBgQR+LADnToHYevr68Mfp0jWn2w68UXX+SFF15Qg1t+fn507tyZqKgodcjWiooKMjIySElJUbO9FEVh6tSpPPfcc03eoTPd+++/z/vvv4/dbmffvn3yIUeSpLOOzOryjAx2SZIkNd3ZEOwqKysjIyMDRVGIi4s75V+212CzIV58Ed5+G6XM2UVNALbISMqeew6fO+5oljYJ2wFE4b/BfgjQ8czRm1iWVw44x138ZODd9Az2rCaVEAKLxaIGvlw9c1xcdb58fX0xmUw1glZ1dRnNPXyM2xIfwmq28vKv/2HQJf0abIvNZuPw4cNYrVZ8fHyIioqqsT0hBHMPrWJxVjJaNDzV7Qp6BTn3tdJs5d2f/uK7lckARIX48+S1w+gUGaR2iaxeD+xoXjYrtx+guEyLXqugKIL2YbmM6bqehIi9aDXHg03aBNAEgC0VRIHzNcUfvG9B8bkVRdP8vZeqKszsWpuiBr/2bzmE44Qgl9HbgNVsw2F3r3Fm8jMS3zuGDv1jSRyUQMe+8fgH+Mvg11mqVQe7VqxYoRZtHz9+PE8//TTDhw+vs9+0w+Fg7dq1TJs2jcWLF6MoCsuXL2fUqFFN2J2zh3zIkSTpbCWzujwjrwOSJElNd6YHu4QQpKWlYbFYCA4OJiys6Vk2jVZZiePhh1E+/xzF7OyKJgBL+/ZUvP46flde2eiugXURlb8gSp4DUQmaNjyRPoE1+VmAM9D15ZD76RQQ1eT1W61WtavjiXW+dDodPj4+ap0vm81GWlpanV1GP3nqK+b/72diu0bzUfKbaHUN379UVVVx5MgRHA4HQUFBtX7B5xAOZu5dwtq8vRg1ep7rcTUd/SLV6Rv3pPPCl3+SXViKosCt5/fn7ksGY1AO46jagsO8BcW+DY0jFUURpGSFMW/9WArK2mPSaZxBr3Abfdobad8mg2CvX9Aqzgw9oQSB9+1ofG5G0fjWaNupUlZUzvZVu9XgV9quI27TFY2CydeIpdJao+ujwVtPbI8oEgbE0XFgezoP6EhgcIAMfp0lWnWw6+qrr+ann37innvu4YMPPmhUY+677z4+/PBDrr76an744YdGLXu2kQ85kiSdjWRWl+fkdUCSJKnpzvRgV1FRETk5OWi1WuLj40/PA3x+Po577kFZuBDleA0sAZh79qTq3XfxGz682dohhBlR8ipUznO+YBjKQ/uHsLHQWYZGAb4b9jBxfs13n2C32ykvL6esrIyKiooadb5cmVJBQUHExMTUWL6sqJxbE/5NaUEZj35yDxfdMc6j7ZaWlpKZmQlAREQEAQEBNeaxOey8vvtnthcdxk9n4oWeE4jyDlanl5QX8tb83/j172MAtA8r4sWr/qRzZJ77irTtQN8Hu6YnSWlRfLfqGGXl5fgatGg0gs4ROQxP3Ep0SA5l9ksotlyAwIRer8doNKr1wFz/nq7BEAqyC0lesUsNfmWn5rpN1+g0ePt7YS43YzW7d4fUGbS06xFF+77tSBzcga5DEgkKCcTb2xuTySSDX2eYVh3satu2Lbm5uRw7dqzRBdwLCwsJDQ2lTZs26gfCuUo+5EiSdDYRQpCfn09BQQFFRUX4+PjIrK4GyOuAJElS053Jwa7qowG2adOGwMDAU7vB9HTsd9yBZvlylOOPfEJRqBw2DOv77+PXvftJjW54ImE74hxt0bYTUMDnPu7dZSKpyBno0qDw/chHiPEObbZt1miDEG4F7isqKigpKQEgMDAQPz8/tcB99a6aC97+Pz587HNC2gYxZ++7ePmYPNpeXl4e+fn5KIpCTExMrQMNVNktvLRjAQdKcwgx6nkxMZJgZRdYksC2B7Czam8cr/w6ioJyb7QaB3eOzuT28yPQm/qAvjeK9p9jJhyFiPIvSNq9mC/X9qesKo4Akw6tBjq1DaFn+yj8fb3qDGgpioLBYFCDX64AmF6vP+VBsKzUHJKX7yRp+Q6Sl++kMKfYbbrepMfb34uqsirMFRa3aVqdhqiukXToF0vHAfH0GN6FkDbBeHt74+Xl1aznstT8WnWwy2Qy4e3tTUFBQZMaFBwcTGVlJZWVlU1a/mwhH3IkSTpbZGVlsWvXLre6GQaDgR49ehAZGVnPkuc2eR2QJElquub4DK2srGTkyJEArF69+rSNhHjiaICnLLCQnIzjzjtRtmxRR/MTWi3lF16IeP99fNu1a/Zti6rliOInQZSAEogS+Cb/2rKTXSVHAWeg69eRTxDmHdis262Pw+EgLS2N4uJidDpdjTpkRqNRDXxpFC13dn2Y7LRj3PbS9dz0jGeDqwkhyMrKorS0FJ1OR7t27dDr9cenWcC6G6xJFFck8cJ+M5kWHW0N5Uxttwk/3fGC+5o2YOhLkaUX0xYaWJbszPLqGtuGFyeNp31kiHN99mOIijlQ8Q2ICudrmvZsypzEFysUKsrKCPHRo9Np6REXwYAu8YQGB6IoClarFbPZjMVicct8q06j0dQIgBmNRrRa7Sk5V4UQpO8+qga/tq3cRXlxhds8Xr5GvAO8qSitpLLEvU6bolFo2ymc9v1i6TSwPT1GdCE8KkwGv1qp5vzcbfZgV0xMDJmZmRw9erTRDzGZmZlER0cTHR3N4cO1jRRx7pAPOZIktTau7Cyz2YzRaCQkJKTBm5qsrCy2bNlS5/R+/frJgFcd5HVAkiSp6c7Uz1CLxaLWjao+GmBzEkuX4rj/fjT79qlBLofBQMXEiWimT8fLg+t7o7cpbIiyGVD+sfMFfS+UwHe4Zf0C9pU5a3RpUfht5H8I9vZr1m03xDUQgEajIS4uTn2trKyMysrKGnW+tv+Zwgf3zcXbz4u5+98jKLxmt8TaOBwOjhw5QlVlAUZdNtFhO9DYtoJ1J/BPdlKe1cSU9EEU2Pzp6OvNM50HYPIagKL9535JCMHiTXt57dvllFaaMei03H9ZD24YuAZN1feA+XiDO6P43gfG81EULUII1u1K47NF6zFXlBPuZ8Co09KjfST9O8fRNqKNmkljs9nUwJfrX4vF4lYUvzqtVusW/HL93txZ/Ha7nQNbU0k6Hvza9VcK5kr37C6/YB9n8Ku4gtKC8hrraNMhlA79YkkYEE/PkV2Iim+r1vySwa+zR7MHu26++WbmzZvHVVddxXfffefxyW2325k4cSILFy7kxhtv5Msvv/RsD85SZ+oFWpKks1Nt2Vkmk4lu3brVGawSQrBs2bIaIyFVZzKZGDdu3GmrCXEmkdcBSZKkpjtTP0MzMzMpLS2tc/S+kyG++Qbx1FMoR4+qQS67jw8Vd92F/sUXMZ2CwBoczzQqegSsfztf8L4Vxe9Jrv/rfVLLndlJOjQsGvdfAvTep6QNdbZNCNLT0zGbzbUOBFC9zld5eTkOhwOHw8H/JnzIkV2ZnHfbCO6dcRs+Pj61PvcKYQPbPrAmISxJWCt3cSSnHTa7AV+vHCKDklEUQAkEQ18UfR8w9OWIpS1Td/xCud1M76A4nuhyGTpNzfXnFpXx4he/sG5PDgB9YzN5/orlRId3QPG5F4yjaz2HhBCs3HaQ2Ys2YKsqJ9LfiJdBT68OkfTp2I424WH4+/vXOnqkK/ureiDMarVSV7hAr9fXCIAZDIZmCypZzFb2bNhH8vKdJK/YyZ4N+7Hb3LPSgiMD8fL3ory4gqLs4hrrCG0XRHtXt8cRXYhNjJHBr7NAswe7kpKSGDRoEHa7nR49evDEE08wfvx4QkNr73Odn5/P4sWLeeutt9i2bRs6nY6NGzfSu3fvJu3Q2eJMvUBLknT28SQ7KyIiArvd7vbNX35+PocOHWpw/YMHD67zGnEuk9cBSZKkpjsTP0MrKys5fPgwiqIQGxuL0Wg8+ZU6HDjeeQdefhlNtTIztuBgKh9/HNPjj6vd6U4FYfnbGehyHAPFB8X/FRSvi7lm9ZscqXC2R6doWDT29Ae6AIqLi8nOzvZoIACHw0FFRQXl5eVsWbqNt2/5BI1Ow7O/Pkib+DC8vLzw8QFfw0F0IhmsSWDdDsI9s6jSEsTRgvEITVtCQtoQ2qYPaGt2V91XksnLO3/E7LAxIqwz93W6AI3yT+BFWPcjyj9EVP7Gwq2JvL1kGJVWPV4GDY9eO4arh/doMFjqcAiWJu3j09834DBXEhVowtdkoE+HtvRIiCY8NISAgIAGAz4Oh0O9/6seCLNarbXOryiKWhS/eiCsOeqBVZZVsmNNCsnLd5C0fCcHk9NqBOLC40Lx9vOirKic/KMFnBjpCIz0p33fdmrwq333ONnt8QzU7MEugE8//ZR7770Xu92unqzh4eFERUXh7e38EKuoqCAjI4PcXOdIC0IItFotH374IXfcccfJ7NNZ4Uy8QEuSdPbxJDtLp9MRFRVV40aivLyc/Pz8BrfRp08foqKaPqz42UpeByRJkpquOT5DKyoq6Nq1KwC7d+9Wn2NOBSEEhw8fpqqqisDAQNq0aXNyK7TZsD/3HMp776EpdwZbBGBr25bKF17A5/bbT+kgMUI4oPxTRNl0wAG6jiiB76Ho2nPFyjfIqioCwKDR8ceYp/HWn556aNW5anVZrVbCwsIIDg5ueKHjhBD895JX2Lx4G33Hx3D76x3Bng0OZwDPqC/B15SLjykXo8GBYugN+j4ohr6g70VJqYPs7GwAIiMj6zxHtxak8ubuX7Hj4OK2fbg1fiTYdiHKZoH5z39mNI4io/I2Xvg2g637MwAY1i2O528+n7DAhjP27A4HizalMPv3DQirmZggE4E+Jvp0aEu3+EhCgoMJCgpq9Dljt9trBMDMZnOD9cBOzATT6XRNDoKV5JeybeUuko5nfh1JyXCbrtVpiOzQBi8/E6WF5eSmHcNhd7+n9Qv1pX3fGBKOB7869ekgg1+nSHN+7p6SYBfA+vXrefLJJ1m7dq1H8w8fPpzXX3+dIUOGNGYzZy35kCNJUmuQl5fHhg0bGpwvPDwck8nk9i1dVVUVKSkpDS4rM7tqJ68DkiRJTXemjcZYUlJCVlYWGo2G+Ph4dDpd01ZUUYH9wQfRfPklisVZx0gAlo4dMb/1Fr6XXHLKH86FoxhR/BSYlztfMF2B4v8CisabS1ZM45i5FACjRs/yMc+e0syy+hQWFpKbm4terycuLq7B4yIc5WDd4eySaN1K2vbd3DsuEodD4X8/HSGmqz9lVWFUWeMRmkhnjS1tBDpDOL6+ztEdvb291aCNayACjUZDTEwMJlPtIzuuzt3D+/uWgKjk+rAMrgj84/gUBYzjUXzvQdE7gwMOh+Cb5VuZ+fNaLDY7/t5Gnpo4lgsHJHoULLLa7fy2YQ+f/L4BbBbaBZsI9/emb0IUnWPbEBQYSFBQ0Em9Z0IItTfAiTXB6qsHVldR/MbKy8gnecUukpbvIGnZDo4dcf9i1uBlIDoxEpOPkZKCUrIO5GK3ugfnvAO9iO8dQ8KAOLoP70yXAZ3w9fOVwa9m0KpHYzxRamoqf/75Jzt37lT7oAP4+fnRtm1bunfvzvnnn098fHzT9uAsJR9yJElqDTIyMkhKSmpwvu7du9OuXTu3C7ys2XVy5HVAkiSp6c6kYFf1DKPQ0FBCQkIav5K8POyTJ6P59VeU41kzAjD36YNt5kx8hgw5LddaYd2JKHoQ7EcBA4r/c+A1AUVRGL/sFQqtziwzL62BpaOfabFAl91uJzU1FbvdTkREBAEB7kXmhRBgz1ADW1iSwZYCuAc93n4slsXzAuk2xJfpS29CMfbFIQLUAvcVFRVuARytVouPjw8+Pj54e3uTnZ1NeXk5er2edu3a1QhyCiHAso7f0r7gyyzntMkRKYyN6IviezeKLqHW/TuUlc9zcxez57CzF9V5fTvy9PVjCfLzLEvGYrXx07pdzF60EcVupV2wF1FBPvTrGEXH6DACAgIIDg6uMXLlyXDVAzsxE8xisdRZD0yn09UIgDWmHpgQgsyD2epIj8nLd1KcV+o2j0+gN+26RGH0NlCcX8LRlCysVTa3eUy+RmJ7RZPQP5buwzvTbUgX/AP8ZPCrCc6oYJfUOO+//z7vv/8+drudffv2yYccSZJalKeZXXVlZ8nRGJtOBrskSZKa7kwKduXn55OXl+dxhpGb1FTst9+OZvVqlOOPa0JRqBo5EseHH+Kd6FlGz8kSQkDld4iSlwAraKOd3Rb13QA4b+lLlNgqAfDVGVky6r8tFugC5/1Nfn4+RqOR2NhYZ5utu8C6FWFJAmsyOHJrLqiJBENvFH1fMPQhLyec2xMfw1xpYeqPTzDsyoFus7vqfLkK3Nts/wRJFEXBZDJRVlaGoih4e3sTExODRqNxHk/zckT5LGfdL+Cb3M78WtgdjSaYR7peycCQ2gNdLla7nTmLN/Hp7xuxORwE+3nz3E3nMapXB4+PU5XFxg9rtjN3ySawW2kXbCI+zJ9+HaPp0DYEPz8/goKC8PI6dd1QHQ5HnUXxa1NbPTBX18iGa5g5SNt5RA1+bV+1m4rSSrd5giICie0WjcFLT9GxYtJ3HsVc7j4apN6kI7ZnFAn94+g2vDM9hnUlKCQQk8kkg18NkMGuc4B8yJEkqTVojuyspozkKMnrgCRJ0sk4U4JdNpuN1NRUHA5HvbWbTiQ2bcJx991okpLUkRWFVkvlZZehzJyJ12mshSkcFYiS56HqF+cLxnEoAa+haAKwWq2MX/UqZTYzAP46L5ae99xpa1ttbDYbhw7uRNgyiQxJwVe/Eaw7gRODJzrQd3XW2tL3AUMfZ9fEE8x5dh7fvPoj0Z0i+WTHdHT62rugCiGoqqpSs74sx7uZ2u12iouL0Wq1BAYGEBO2H4PtIxT73uNLmsB7Inj/i49Td7IiZxd6Rct/u19F14DoBvd3z+Ecnp+7hINZzu56lw3pyuPXjcbPy/MBECrNVr5bmcznf25G2G20CzKR2DaQfh2jiY8Ixtvbm+DgYLdumqda9Xpg1bPB6qoHpihKjQCY0Wistx6Y3WZn7+aDavBr19q9WM3u50lE+3Diukaj99JTkFNE6rbDVBS7B8h0Bi3R3SLp0M+Z+dVrZHdCwoNl8KsWMth1DpAPOZIktRbNkZ0lhCA/Px+z2YzRaCQkJER2XWyAvA5IkiQ13ZkS7MrJyaGoqAiTyUS7du0avDaKxYtxPPAAmgMH1CCXw2ik6qab0L39NobTfL0QtoPObou2/YAWxe8x8L4DRVGwWq2ct/IVKu3OoE6Q3ocl4545re0DEMIGtn1g2YqwJpGTW0xxqRdehiKiQzeiHnJNsFtgC30PFKX2OlrVlZdUMCnh3xTnlfLgB5O57J4LPGqXxWJRA18lJUWUFKUh7Jl4GzLw987E16sEn6DheAfdhEbnzJ63CwfT9/wfmwsO4aM1MqXHtcT6hjW4LbPVxqxf1/Hl0i0IARFBfky59QIGdW7nUVtdyirNfLM8ia+WbsHhsNMuyET36GAGJMbQLtyZuRQcHIyvr2+L3efZbLYatcDMZrNH9cCq1wWrrR6YpcrCrnV71eDX3k0Hcdjd1xvbLZq47jHoTDoKsgo5sCWV0nz3ETk1Wg1RXSLo0C+WrkM70WdMD8LbhsngFzLYdU6QDzmSJLUmWVlZbNu2zS39XmZnnVryOiBJktR0Z0Kwy2w2k56ejhCCdu3a1dsVzP755yhPP42SlaUGuey+vlTdey/Gl19G14y1kzwlKn9DlDwLohw0YSiBM1AMAwCwWq2MXfEyZoczCybU4MfvY58+Pe1yFIE1+Xh3xCRnN0BRAYDF6kP6sWEIoRATkYeXb6fjIyX2BW3Dwca6/DRzEe8/+BmB4QF8vv89vP0869YnhBkqF2Atnkt2fgg5Rd2x2f3w9QvB4N0dFJNa58vX1xcfHx+sws6ru34ipSSDQL03L/aaSBtTQMMbA5IOZDDl8yUczSsGYOLo3jx45XC8jI3rUlpSXsWXS7fwzYokHHY7MUEm+sSFMigxhqjQAAwGA0FBQfj7+7eK4M2J9cCq/9tQPbATA2HV96e8pIIdq/eQvHwHSct3cmh7uts6NBqFjv07EN8jBo1BQ15GAfv+PkhRdonbfIpGISIhjIT+cWrwKzI24pwMfp3xwa7IyEiOHTvm9tAkuZMPOZIktSYOh4MdO3ZgNpuJiIjA29tbZmedYvI6IEmS1HTN8RlaUVHBgAHO4M2mTZvw9vasuLcnhBBkZGRQXl6uDtxVg8OB/c03UV57DU1hofqyLSQE83/+g+mRR5o0Gt3JEsKCKH0NKr5yvmAYjBLwForWmWFUYa3kghXTsDicz3oRpkB+Gf3kKWqLA+yHwJKEsCaBZavz/ydSfEHfh6yiYZRVtcPHP57oaM9rVzXEarFyZ/dHyTyQzS3PX8etUyfU325HBVR+iyj/TK0NJpQQjlXdR1FFL2x2DQEBATW65Wk0GmfRcy8909P+4EhlPm1MAbzYcyKBBs/Oz4oqC+8s/IvvV28DICYskBdvG0+v9rWcgw0oLK1g7h+b+X7VNux2O1GBJgYltGFQ52gig/3R6XQEBQUREBDQIudqQ4QQtXaFrKseGKDWAzsxEKYoCkXHitm2YhdJxzO/Mg9kuy9r0NF1aCLte7VDo9OQc/gYKRsPkHe4oMZ2wtuH0qFfO7oM6UifsT1plxB9TgS/mvNzt8WCXbm5uXX2p5XkQ44kSa1LRUUFBw4cQKfT0bVr15ZuzjlBXgckSZKarrV/hpaVlZGRkYGiKMTFxbmPamezYXv6aTQffICmwpmRJABbdDSWV1/F66abWuyBV9gzEEUPqUXT8bkHxfdBFMVZp6rEWsFFy6dhFc7nvGivYH4c9Xjzbd9R5ty2NRlh2eosJC9Kas6ojXfW2NL3dmZt6RKoqjJz+PBhFEUhNjYWo9HzmlWeWP3Del6aMB2Tj5G5+94jJDKolvaXQsVXiPI5IIqcL2oiUHwmg/d1gJGjR49SUVGhjtDo6u5YXl6u1vkCKLFX8VH+WooclcT7hjO153X46Bvudumyfnc6L3z5B7lFZWgUhUkX9OfuSwZjqKPmWH2OFZcxZ/EmFvy1A4fdTmSAiRGdIxncOYbwQN/j9cgCCQwMrDHiZGvkcDhq7QpZV7KOoig1MsAMBgOFWcUkr9hJ8oqdJC3bQX5modtyXr4meozoQoe+cWh0ChkHs0lZv5/sg8dqbCMkOpD2/WLpMqQjfcf2JL5r7DkR/DoZMtjVSrX2C7QkSeeWgoICjh49iq+vL+3bt2/p5pwT5HVAkiSp6VrzZ6gQgvT0dMxmM8HBwYSFHa+5VFaG7YEH0H79NcrxzBIBWBMTsc2Ygdf48S2aUS3MqxFFjzuDNEoASsAbKKYx6vRiawUXLX8Vm3DWMIrzCWX+iEebvj0hwH4ErK6srSSw7QVOrL1kAn3P48GtPs7REjXBNdblCiIFBAQQERHR5HbV194Hhz5Dysb9XHLX+Tz84V3/THMUIMo/d2bDiVLni9p2KD53gdeVKMo/wU673U56ejpWqxVvb2+io6NRFEXNQnLV+aqqqiLPWsasY2sod5hJ8GrDIx3GE+TvrJ3lyblSWlHFG/NX8tvGPQAkRIXy0qTxJMaEN+kYZBeUMnvxRn5euwu7w0EbfwNju0UzpEsMof4+aDQa/P39CQoKcg/wniFsNlutXSHrimtoNBq30SDz0gvYvXYf21ftJnnFLkoLytzm9w/xo9eYbnTqF4+iU0jfc5Q96/eTkZLFidGYgAg/2vdpR5ehHekzpgcJPdvj7e0tg1/VyGBXK9WaL9CSJJ17MjMzycvLIzQ0tPauFlKzk9cBSZKkpmvNn6FFRUXk5OSg1WqJj49Hc+wY9smT0f7+O8rxItoCsPTvj33WLLz69WvZIJewI8reg/JZzpbpuqMEvoui+2ckwIKKUi5Z/Rp2nI+MHX0j+Hr4g43cjtk5KqI16Z96W468mjNq2lYLbPUBXWcUpf6aU65MOo1GQ1xcHHp942pUeWrnX3t4ZOTzaLQaPt7+Fu066Z1dFSu/BXF8hD5dAorPvWC6SM2IO5HZ7MxCczgcBAYGEh4eXuMcsNlslJWVsSfvMO8cWYrZYaWbV1tuCu6PQW9Q63x5EgBZnnyAV75eSmFZJTqthrsuGcxtFwxAp21a4OTosSI+WbSR3zbswSEEoT56xveKZWiXaIL9nCM2+vn5ERwc3OwZdqebEKLOovj11QPT6XTkHMgjZd0Bdq/dx661e6kqN7vNFxYdQu+x3UkcmABawaHt6exau5cjuzJw2N3X7RviQ/u+7Ugc1IE+Y3vQuV9HfHx8zunglwx2tVKt+QItSdK559ChQ5SVlREdHU1wcHDDC0gnTV4HJEmSmq611uyy2+2kpqZit9uJKC3F+5FH0K1di3L8UUtoNJhHj0b55BOMrSCTWtjzEcWPgmW98wXvG1H8/uuWiXSsoojLVv8Px/FAV1f/KOYOvd+Ddee4B7asu4ATayXpQd/VOUqioS/oe6NoG5eVVWcm3Sky9eo3WPvTJoZc7MfUTzei7pOuG4rvvWA8D0VpOABRVlZGZmYmQgjCw8MJCqrZLdJle0Ea03b9hMVmY6BPLFf491CDYxqNBm9vb7XAfV3dCAtKKnhl3jJWJB8AoHtcBC9MGk98RNPv+9JzCvn4tw0s3pyCEBDkrePSvu0Z1iWaAB9nl0tfX1+Cg4PrHaDhTOTKxDsxAGa1WmsNgtmtdo7uyebA32mkrD/A/s2p2Czu3SajO0XSe0x3ugzpiKJVSNl8gN1r95K2/Qg2i3tsxcvfRHyfGBIHJ9B7dDe6D+mKr2/rD37Jml3nAPmQI0lSa7J7925sNhsJCQnNWqBXqpu8DkiSJDVdax2N8dixY5StXEnElCmY9uxRR1YUOh1VV1yBbtYs9Kc4GOMpYdnirM/lyAXFC8X/ZRSvy9zmOVKRx3Wr31YDXb0DY/l48N011yWszi6Ilq0Ia7KzS6Ijo+ZGNSHVAlt9QN8NRfG8DlVtSkpKyMrKUjPpTmWhdGFLJT3pPe4eehiHXeHNhQfoMTzRGeQyjGx0hl5BQQHHjh1DURSioqLqPQc35O1nRspvCAGXRfThgoAulJWVuRVbVxQFk8mEr68vvr6+NboSCiH4/e8UXv9uBWWVZox6LQ9cOZzrR/dBo2l6duHBzDw+/L/1LEtyBtL8TTquHJjA8C5R+Hk5M7u8vLwIDg7Gx8fnrB4AyeFw1NoV8sSi+JZKCwe3Hmb/xkPs25hK+s6jCId7SKZD7zh6j+lOt2GdQeNg14a97FyTwqGkw1ir3Ndn9DYQ1zuaToM60Ht0N3qN6IF/gF+rO9ZnxGiMq1evrnPaVVddRVFREStXrqwztW/kyJGN2dxZRz7kSJLUWlitVvbscdZy6N69e6v/RuhsIa8DkiRJTdcag13mhQsRDz+M8fBhNcjlMBoxT5qEYcYMtK0ks0UIARWfIUrfBOyg7YAS9B6KLsFtvrTSXCaunYHraW5gcAdmDrzDuQ5HIViSEdbjReSt2//pxqfSgK4T6PuiGPo4g1vamGZ9+HY4HKSlpWG1WgkLCztl2enCmoIo/xCqFgGCd/8TxW9fhNJ5YCTvrJvR5HsnIQTZ2dmUlJSg1Wpp165dvbWu/szazqcHlwNwe/vRjI/shdlspry8XK3zVZ3RaFS7O1av85VTWMoLX/7Jhj3pAPTvFM3UWy+gbUhAk/bDJeVILh/+up7VO5wjZvoZdVwzpBPDO0fhY9KrbQoODsbPr/UFYk4lu91ea1dIV4JQRUklBzalsW/jIfauP0jWgVy35TVaDYkDOtBnXA+6D++MUBxsX7OHXX+lsH9zGuYTukjqjTra9YwicVAHeo7sSp/RPQkKCWzxY35GBLs0Gk29B0oIUed0RVHqHOngXCEfciRJai1KS0tJTU3FaDSSmJjY0s05Z8jrgCRJUtO1pmCXbfZslGefRZOdrQa57H5+WB56COOUKWha0eh0wlGKKP4PmP90vmC6FMX/JRSN+77vL87i5vXvqYGu4SExvNUt+J9C8vbUmitX/JzdENWsrZ4oGt9Tuj+FhYXk5uai0+mc9dGa+Qs7YdnmDHKZl/3zonEshaW3cFu3WVSVm3lu/qOMvHZIk7fx/+ydZ3gc5dm2z5ntfSWtrOYqufeCcS/YppgONiX0lhcCSYAQkjeBQEjIF96EEJoJEEpI6L0FY3DFxr33Jlf1ur3PPN+PldaSbdmyLBdgzuPwYXt2yjNFM5prr/u6VVVl//79RKNRjEYjnTt3PqI77YN9y3h33xIk4Ge9pjIm+8DvbolEIt3ZMRwONzOe6PX6dKmj1ZrK1fpg4Xqe+OAbovEkNrOR+6ZP4JLR/Y5bENmwu5x/fLYkLabZTHquHtOHMX3ysDR0gzQYDGRkZOByuX6wX7Q25oEdzgnmrfSxffkuti/dxbalu6gtad7p0WA20HtEdwaf1Z/BZ/UHSbBm3gY2LNrCjuW7Cfuai886g45OffPoOaKQgeP7MmzyYLI6ZJ508es7IXZNnDixxQOzePFiksnkEd1b8+bNO5bNfe/QXnI0NDROF6qrqykvL8flctGlS5dTPZwfDNpzQON0YuLEiSxYsICHH36Y3//+96d6ON95tON54jnlYpeqkvjzn9H99a/IPl96cjwri/gDD2C7555T7qA4GJHYjPD+HJR9gAHJ+QBYfnTIODfUbuO2Fa81CF2CSa4K/l+3bw9doa4bGIc2BMkPBV1hq7Kq2otm+Wi5ubhcx+dKaoqIr0AEn4N4435LYD4PyXYHkqEPAP955D3+/ci75HfP5aWNT2Awtj0UP5lMsm/fPhKJBDabjYKCghavHyEEr+yax1fl69FJMv/b9xIGZhz6+5uiKGnHVzgcbhYxJMty2vFVH07wyOuzWVtcBsDY/t343XVTyHYdv1C5ekcJ//hsCat2lABgNem5dnw/xvbOw9gQjq/X63G73bjd7hNagvpdQghBIpFoJoCV7ixn06JtbFtazLaluwjUNO/0aLab6D2yOwMm9GHghL7IOpn132xm48KtbF9+6PyyTiK/dy49zyxkwNjenDFlCDkdD22U0N58J8SuI6FldrXMjBkzmDFjBoqisH37du0lR0ND45Szf/9+6uvrycnJIScn51QP5weDJnZpnE5o4kz7ciqP5/z585k/fz5du3blpptuOqnbPpmcKrFLxGIkf/UrdP/8J3Ik5ZwQQLxjR8p/+UtMV15JXl5em8ZzIhHh9xH+R4AYyAVIGU8hGQamnD/KfkisRsTXsLpmM3fuOFDOeK57L490XQmSBQwDU3lbhiFgHIwktxyofjKoqamhtrYWo9FI165dj/slXQgB8YWI4D8gsaphqg7MFyPZ/wdJX9Rs/kgwwo09fkZ9pY+7nrqFS3829bi2H41G2b9/P6qqHjVoXxUqz2z7ksU12zHJBh4aMI3ujpaD/YUQhMPhtOvr4Jwvo8nMrHV7eeWr1SQUFafVxG+unsy5w4/f8S+EYPm2/fzjs8Ws31UOgM1s4PqJAxjbKw+dlJIhZFnG7XaTkZHRYsj+D52meWC7Nuxl3byNbFq0nW3Lion4m5ewOrJs9BxRSN8xPek/rjcAmxdvZ8uSHexYvpv6cl+z+SUJcrt3oMeZ3eg/tjdnnjuU/C557S5+aWLXDwDtJUdDQ+N0YceOHUQiEbp06dKu34pqHBntOaBxOqGJXe3LqTyev//973nkkUeYMGEC8+fPP6nbPpmcbLFL+Hwk77wT/XvvITUIBQJI9O1L6C9/oap7d2RZplu3bqfVi7oQEYT/DxD5IDXBOB6s1yEldzTkba0BtQ6ApV4P9+yZkF72Ek+S3/YZmHJt6XshSafPfiWTSXbv3o2qquTn5+NwONq8LiFUiM1GBJ+H5MaGqQawTEey3Yak79Tisp+/8DVP/eRFXB4Hr+14Bpvr+HLfGsP2gaO61RJqkv/b/CkbvPtw6M08MvBKCqxHzywTQhCLxQgGgwSDQWKxA1lP+2sDPP/VBnZVegE4e2gPfvOjybjtx583J4Tg2017eO7TxWzdn8qjspuN3Dh5IGN75YGa0g4kScLpdJKZmXnE/DKNA8TjCbau2M7q2etZP38z25YVEz8owD4z303PkYX0GllIr5HdEapg27Jiti0rpnjlXmr21R2y3uyuWfQY3pX+Y3sz/JyhdOl5/Jl7p0LsOn3uXBoaGhoaJw0hRDrM1Gw+vm5IGhoaGhoa3yUkSUqX77f0AqeWlqL8+MfoZ83CoKpAg8g1YgS8+CL6/v2p37MHEgkyMzNPL6EruQdR/xNQigEJ5ByIL4b4NzR3ORiYFziD3+wpSE+5qvMo7ut7EacrtbW1qKqKxWJJvzgfK0IkITozlcmV3JGaKFnAchWS7RYkXctOqUam3jqJD5/8nP3bynjnL59wy5+uadNYGnE6ncTjcWpra6msrMRoNGJpobGBQdZzX+8L+cPG99kVrOL/bfqIPwy8kizTkYW/xo6NZrMZj8dDPB5Plzt2liQeuXIkHy/fyUfLi/l69Q5Wbt/Pr6+cwNln9DkuoUOSJMb278aYfl2Zv66Yf3y+hJ2lNcz470pen2/m5imDGNMzj2Qijs/nw+/3Y7fbyczM1H5HPQpGo4GBY/oxcEw/eBjisQRblqbErzVzN7J9xU7qyrws/XA1Sz9cDUBuUXYqv2tiHy6/fyqxaJzty3dRvHIPxav2UbWrhuo9tVTvqWXxe6t4kTfILHDRfXg3+o3pxfCzh1DYr+sxl5625r7b3pw+d2UNDQ0NjZNGPB5PNxTRvj3T0NDQ0PghYdHp2H7nnYjiYqRnn0XcfTeSyQSAsnkz6m23oV+6FENDAYyQZeJTpiC/+CLJ7GySySSB8nLi8ThGo5GMjPYr6xNCgfhKUKtBzgbjGUjS4V8qG+cVSjkQBjUOsZmpLolpWUuAWgGAT/Hw6L7RlMVt5Fs9jM0eyp+L/5te3w1dx/HT3sdXknciEEIQiUSIRCLU1NSg0+nweDyHfWE+0vETIg6RTxChF0FJBagj2VOON9tNSHLrOzrq9Dpue+w6Hr7sL7z/xGcUDe6KklTJysug/7jebcqgysrKIh6PEwgEKCsro1OnTiSTSZLJJHq9HovFkt5ni97I//a9lN9veI+ySD3/b+NHPDRgOqWROurjITKMNno589EdIUvNaDSmr9/GnK+b3S6GFeUy48u1lNYF+d9XZjFr+WZ+cv5wOmRlYLZYWL+7ghpfCI/LxpDuBegaQuYbz9PhxgspgeOswd2ZMLCIr1dv54X/LmVPRR1PfrKM1+wWbjlnKGN65hKLRggEAvj9fqqDMYJJGU+Gi6E9OrZ6Wz9UjCYDgyb0Y9CEftz8x1TJ7cZFW1kzZwNr5m2keM0eKoqrqSiu5ps3lyFJUjq8fsg5A5j+vxcSi8TYtqyYHct3s3vtfip2VFNX6mN56VqWf7yWV3kHm9tCdlcPPc8o5LxbJ9H3jF5Hveb1egMvPf4vakrrWPzFcsZfPAbjceTdtQatjPEko5WvaGhonA74fD727t2LxWKhR48ep3o4Pyi054DG6cTRyu5ee+01brvtNpLJJL/97W/505/+dFzb27NnD08++SRff/01e/fuRVVVOnfuzLnnnst9991H586dm83/k5/8hOeffx6Xy8XatWvp2rXrIev8xz/+wZ133olOp2Pu3LnpRkl79uyhW7duAOzevZtEIsGf/vQnZs+eTXV1NTk5OZx//vk89NBD5OfnH9d+NdL0eD788MO89NJLvPTSS2zZsgUhBP379+euu+7iuuuuO+J6Nm7cyNNPP828efMoLS1FlmUKCwu56KKLuPfee/F4POl5m+5nS7z66quH5Hgd67kA+Ne//sXNN99Mly5d2LNnD/PmzeOpp55i2bJlVFVVcf311/Ovf/0rPX9xcTGPP/44s2fPpqSkBIPBQPfu3bn00ku555572nQPPN57aOyeezA+8wwVqsoLwO1AriwTv/xy5C1b0G/alO6sKPR64tOmof/HPwjr9VRUVBAMBkkmk4TDYYxGI926dSM39+hOoNYgorMQ/j+lxSkA5Fwk5wNI5nMPzKfWIYKvQuR1EKGWV6jrAabhSIah3LR6F1sCVS3O+uOiSfy4x5T22I12JRAIpI97KBRCURTsdjs9e/Y8pISxpeOH41dIaj0i9BKoqVJBJDeS7aaU0CW37VkshODWfveyf2tps+mejlnc+eTNjLt8xDGvU1VV9u3bRyAQIBqNotPpUFUVnU6H3W4nNze32X5XR/08tP4dSsP1xJQEkiShCBW9JNPJ5uG2okmc6el+hC0efgz1Pj//+GwJHy3ZigA8DjMT+3Vi7sb91AUPZER1cNu5/8qJnNk9N32eFEVpcbxNUVSVmSu28uLnSympSeVIeVw2bj1nGE6jYPH6HYSjcQD80STBpMytF45hRI+8Y96WRgp/bYB1CzazZs4G1s7beMi1qzPoKBrShZ4jCul+Zle6DuxILBJn+4piti/fzab526nb7z1kvSabkV6jiug3phfDpgyi34jezdyuHzz/KW889CE11TWUsIuOFOLJ9nDtHy5n2h0XH/t+aJldpyfaS46GhsbpQGVlJZWVlWRmZtKxY8dTPZwfFNpzQON04khi12OPPcZvfvMbZFnm6aef5q677jqubb3xxhvceuut6ZwYk8mELMtEGsK+HQ4H77//Puecc056mUgkwvDhw9m0aROjRo3im2++afYL9MaNGxk+fDjRaJSHHnqIRx55JP1ZUxHo7bff5sc//jGBQAC73Y6iKOntZmZm8vXXXzN06NDj2j84cDwffPBBNmzYwCeffIJer8dqteL3+9PzHTzWpvzlL3/hN7/5DWpD6ZzVak23qIfU79v//e9/GTJkCJBqNjJ8+PC0GGAwGMjMbO5Qeeqpp7jqqqvS/2/LuYDmYte9997LvffeixACl8tFOBzmmmuuSYtd7777LjfccEN6Gw6HIx2wDNCpUydmzZpFnz59jukYH889NHbPPRifegqANcAwYBUwpOHzRpFLNZuJ33YbpscfRzKZCAQC7N69m3g8jtlsJhaLEYlEUFUVt9tNt27djvslW0RnpTomcvCrmZSaZrkaRCyVtaXsOfLK9EMh4wVkXSr36cZvZ7AlUNri7B2MDj6f9JvjGf4JoelxNxgMBINBhBAYjUbMZnOz497y8TsIORvJdgtYrkaSjy9na+GHy/jD9McP/aDhQnrovV+2SfCqr69n06ZNJBIJrFYrLpeLZDJJNBpNC6xNr7fPS1bx500fowgVs85ItslBQiiEkjHMOgO/6z/tmAWvRlZt38/Dr82irC5wxPnuPLsfgzunyg71ev0Rx3swCUXh8yWb+efMZVQ02Y5ZL9Mpw0y+y4Tc4NqSJThrQBc6uO1t2pZGc2rK6lg7dyNr5m5gzZwNVO+vbfa5yWqk98ge9Bndg6SS5P3HPj/qjxiA2WGicEhn+ozuQTwW57O/zwbAL+pZzhzOZDJOKeWIveO5649Z8Grtc6Bde8ReeeWV3HDDDe25Sg0NDQ2NE4CW16WhodESQgjuvvtufvOb32AymXjnnXeOW+j6+uuvueGGG1AUhV/96lfs3r2bSCRCKBRi69atXHHFFQQCAa644gr27duXXs5isfD2229jsVhYsmQJDz/8cPqzSCTC1VdfTTQaZcyYMTz00EMtbv/222+nW7duLFu2jEAgQCgUYtasWXTu3Jm6ujouu+wyAoEjv8wdCzNmzGD+/Pn861//wu/34/P52L9/PxddlMpCevTRR9mxY8chy7388sv8+te/xmq18qc//Yny8nJCoRDhcJiVK1cyadIkysvLufjiiwkGU+3kO3XqREVFBb/85S8BGD16NBUVFc3+NBW62noumlJZWcl9993HjTfeyL59+/B6vUQiEX73u98BsHr1aq677jpisRhjxoxh/fr1+P1+wuEwn376KXl5eenj0bgfJxoRi2F85hkAokCjty5KSptokJSIPvggUjCI+ZlnkEwmhBBUVFQQj8ex2+3IskwsFkOWZTIyMojH41RUVHA8/gEhlJQj6bBvkQ3TIm9D9KOjC10AajmSnMqz8iXCRxS6AKriAXyJ8DGN+URz8HGPx+NIkoTFYknnWzUe9yMfv0ZkcPwOKXsuku3W4xa6FEXhuXtebWHwqb/+ce+rx2wCEUJQU1ODwWDAaDSmhXmDwZA+Dk2vN0WofFq6CpNOj06SSYgk3kQYk2wgw2gjqiR4uXguilDbtJ/DenbirQeuw3KUcrM3F20nFosTj8dRFKXF8R4Og07HZWMH8PHvb+L+Kyamha1oUmVHdZjFu73sqYuQVAUd3Waq6+rT25Ek6Zi2pdEcT34mU64bz/2v3MUbe/7Bv7Y/zT3P/w8TrxqNO9tJLBxn3dxNvP3ox7z/5yMLXSabkcIzOmEw64kGYmz+ZgcfPPZFWuhShMImlgOgcuB6fOPhj4jHE4dd5/HSrmLXU089xauvtvBDr6GhoaFx2qCJXRoaGocjHo9z9dVX8/TTT+Nyufjyyy+ZPn36ca1TVVXuuusuVFVlxowZ/N///R9du3ZFkiQkSaJXr168++67XHzxxfj9fp544olmy/fv3z897bHHHmPevHkA3HvvvWzatAm3282bb755xLwQvV7P119/zZlnngmksmPOOeccvvzyS4xGI/v27eP5558/rv1sSn19PR999BE33nhjOmS6Y8eOvPfee+Tn56OqKu+++26zZQKBQFqwev/99/ntb3+bLo/T6XQMGzaMWbNmMWzYMEpKSnjppZeOeVzHey4aiUajXHLJJbz66qt06tQpPcaioiIAHnjgARKJBN27d+err75iwIABAMiyzEUXXcR///tf9Ho9xcXFRz3usVgMv9/f7E9bSDz1FBWqyhpgNbClYXrj/1cDFYDscCA1uZYikQjBYBCz2YwkSWn3G6Q6iiUSCWpqaqioqCAcDretwiW+snnpXUuYLwb7fUefTy1PrRP4w/r3WzWE6xc9w2ZvSavmPRk0Pe6qqpJo6ITZ1MUTDAZT56NVx09F0vdEkkztMr6NC7dSU1Lb8gwCqvfXsnHh1mNab+N+22y2tEMpEolQX19PNBrFZDId2G9gm7+M/aEabHozJl1KkAorMaJqShy06U3sC9WwzV/Wth0FtpVUEzmKGOGNJNhR6ScajeLz+dJClNlsbjbeI2E06OnR0YN6kFiVUAS7ayNsqgiiCPBHEgTCsfQXAcAxb0vjUCRJoqB7Hhf8z9k88Na9vFP+T15c9zg/eeIm+ozqedTlY6E4Nz9yDS/v/Du/fv8uzr97Evl9coiJCH5RT4B6QqS+VApQj1+k/tRUVfPNp9+ekH1qV7FLQ0NDQ+P0R1GUdBmJJnZpaGg04vf7Oe+883j33XfJy8vjm2++YeLEice93m+++YYdO3bg8Xi47bbbWpyvsTpg1qxZh3x2xx13cPnll6OqKtdddx0vvvgiL7zwAgD//Oc/D5svdfDyHTp0OGR6nz590mLe22+/3ep9OhpjxozhrLPOOmS6yWTi3HNT2Uvr169v9tkHH3yA1+tlyJAh6XkORq/X86Mf/Qg4/HE6Gu1xLhr5zW8OX/bm9XrTy91///1YrdZD5hkyZAiXX345AG+99dYRx/znP/8Zl8uV/tMorh0roriYF0iVLo5tMv2nDdOGAS80zNeUZDKJoijp8lmj0ZgWVoUQqKpKNBqlurqa/fv3s3PnToqLiykpKaGqqgqfz0ckEjmyCKZWt2ofJNNEJF3B0Wdsss6ySH2rZq+I+bhp6XOc+eVvGf/Vw/xo0VP8ZdMnrKrddUoiapoed1mW0810FEUhHA4TCAQIBALU1tYSj7Xu+LX2OLeG2vLWHdfWztdI0/02mUxYrVYkSUJVVcLhMH6/n2AwiM/nI6kkWVW3i0AySm0sQExNCVIGSY9BSl2vBllPUqjUx4+Q7XYUKo5SwtiIP5IqtTYYDMgNQfKNmWPJZLJV61i1o2XBVS9LxJMq++oiJETK/dUogrZlWxpHRpZlbG4b8VjiyMJuE8LeKLl5OXTu0gmn2UmgOkQJu1jOHFYyPz3fNtaynDksZw4l7KKmtO6E7IPWjVFDQ0PjB0aj0KXX60+rVukaGhqnjvLyciZMmMDatWvp2bMns2bNOmwYfFv49tvUN7Y+n++IQfCNmVR79+497OcvvfQSK1euZN++fdx+++0A3Hbbba1ynk2aNOmIn7355pusX7+eRCKBwXD83aFGjGg5p6fxGNTVNf/lvvE4bdmy5YiB542uhZaO05For3NhsVhazDhbvXp1uoxoypSWA8/PPvts3n333aMe99/85jf84he/SP/f7/e3SfCSioq4HbgYiHBA8HoWGNXw7zxALSlJdyuG1LNSp9ORTCbTpWVNhZfGEHG7PVU2mEgk0h30QqHmAoPBYMBkMmEymTAajZhMJgwGA5Kc3bqdaO18TebNt2RQHKxs/XJAVE1QHKykOFjJ+/uXIQFWvYl8cwZ9XR2ZmNOXkVk92tRxsLUcfNwdDgeqqhKPp0rlotEoQgh8Ph/hgBWTMgq7uQK7pRKj/vAlmSL8NhgGIOm7HPf4svJa14GztfM1cvB+WywWzGZzOu8uGo2SVBRW79vGju3fsCtZh1XVEySORW/Erjdjkg3p3LCEmkQvyWQYj71sUwjBgvW7eObjRa2a3+Oy43a7m10XiqIgy/IRf99MKirz1u7k9Tmr2bC7vMX54kmVpCow6GSsVgugNBO2WrMtjaMTqA+y8P2lzHlzIesXbD6mZRd/vJxXH3iTij0HhOWOFJJNPipKWvDqxWBcZAFgwoynoPWdUI+FdrkSVFVl1apV7N27l3A4rOV2aWhoaJzGaCWMGhoaB/Piiy8CqfvC7Nmz2+yeORxlZanymUQiQWXl0V+6WypBycjIYMaMGencq8LCQp5qCBs/GgUFLbthGj9LJpPU1dWRk5PTqnUeiSMFJDe+iDV1JMCB4xSNRtP36SPRWL5zLLTXucjKyko7Nw6mqupAx78jHffG5ihHO+6N4tDxYrj7bnJ/8xtyVZWmR24wMJRUFI0E8MUXJDp2JP7aa1gnT8ZisWC32/H5fOj1+rQIBinng6qqZGVl0a1bt7QDJxaLpcWJxr+TySSJRIJEItEspyyVOZSNMTYBo64Ekz6A0RDEoIsgSY3lXFKqq6DxjIYN54JaSYsBOrInPe9DA6dz9pxHj3p8njvjJuaUb2ZRzTZqYn6UJusWQCgZY0ewgh3BCj4pXYmEhFVnpIPZRW9nPhNz+jImuydGnfGo22oNhzvusixjNpvT14PZbMblchGJ6IlG84nGndT4e2IyBHBYKrCbKzEamgiOieWImqkI61VItruQdJ4Wtn50+o/rjadjFjWltYc/DRJkd8yi/7jex73fkiRhMplIyoLqcC2lCS81iQhGdBRIDrIkMz4RJS5DvRwn2XDdCCEIJWMU2jvQy3lsHWe3l1Tz+HsLWLl9PwCyJB1SXtiUDJuJwYV56HQH7gtCCKLRKC6XK13O3ZRgJMbHizfx1tw1lNelypP1Ohm9TiYaP9Sd5YskqQnG6eqxkZvpxOf1IoQgmUyi0+mOuC2NIxOPxln6+SrmvrmQ5V+sIdHk+A+c0Jezrh7D6398P+VUPEJu14L3lgBgtBjoObqQnqO7Muu5hYRqwyjiwDoduNMB9Y5sO+MvHnNC9uu4xa5nnnmGRx99lJqamvS0pmJXfX0948aNI5lMsmDBgnb5BUJDQ0NDo+1oYpeGhsbBXHjhhSxcuBCfz8fNN9/Mp59+etjys7bQWAI1YsQIli5delzr+uc//5n+d2lpKTt37mTgwIHHtc7ThcbjdNVVV7VrSeXhtnG85+JEOnpOFJLJROxnP8P41FOHvKs1/l9xu5G9XgxlZejPPpvYiBGI994jNze3WYaUTqdLu7pMJhO5ublpEUyWZSwWyyEv3I0RAgcLYYqiEI8niCuXIUIz0/PLkoLREMSoD2IyhDBl3ospqaYEEOcDDZ0HJQ775imioOwGfXdcBit9HAVHDKnv4yjgDE9PzvD05NekRIodgQrmVGxgWc1OdgUriKrNxQeBIKTE2B2qYneoipnla5GQsOgMeExOejnzGJfdmwm5/bC0QQCTJOmIx91sNtO1a1ccDgfJZJJg3QQC1f8mHMsklnAQSzio8ffAZAhit1Rgz7oSk7QYYgsg/AYi8hHCeguS7ZZ0mP+xoNPpuPPJm/nDFY8f/jQI+Mnfbz7mn5XD7bdXibDbX4k/HCQqJdlq8mGxWpnq6UtfYw67akpZULGZZEwlO2EmpFOokkKUqUHMegO3Fk1CJ7UuvajWH+K5zxbz8bcbEQKMeh2XjexFtsPIszPXHjrehl2/dmxPwuHQUX8+AMrr/Lw9by0fLdpAMJpykbrtFq4YP5ArJwxibXEZv3rx88bD2IwtlUHOHVpEOBRKi8uNLr/DbUujZRRFYf2Czcx9YyELP1xGyHfga4BuAzoz+drxnPWjMXTolBKFXdmuw3cfbcBoMTDknP70GltI56H5mCxGbDYb7kw3r9z7TovLXfvIZRiP0gChrRyX2HXXXXfx/PPPI4TA6XSm28E2JSMjg6FDh/LGG2/w3nvv8dOf/vS4BqyhoaGhcXxoYpeGhsbBDBs2jIcffphzzjmHOXPmcMEFF/D5559jsx1fxzIgXZLXlrK7pjz77LN8+umn6HQ6evXqxebNm7n66qtZuXLlUYW50tJSevXq1eJnkHJcZWaemFKK1tBex+lUb6NpNlpJSUk6tP5gSkpS2Twn87ibnnySGMDTT0PDO0sugCwT/9nPMD35JMqbbyLdcQdyIIB52TJE166EbryRgv/7P+q8XoLBYLobo8vlIjc394hOvkZ0Oh1Wq7XZtdroSkmJX9nEghIx/xfE4wqq0BGNu4jGXWAYhqR0g+pd6HQ6jMY+GKUnMSZexaTbi9EQRCcnQM4BDKCWIOpugMz/IOmLeG3MXdz47YzDCl59HAW8NqZ5t1VJkujpzKOnM4+f9DwHIQQ7AxXMr9zEyrpd7PRVEFZjqIhmYoRAEFbi7AvXsC9cw9cVG5A2vIdJNuAxOejuyGVMdi8m5/THbjy6+8bhcNCtWzcqKiqOeNz1ej3uDufhckok6/+PYEQQjOQQjnmIJXOJx6+grroIk+ksbKYbsEsvYFSXI4WeRUTeBNtdYL0KSTo2UW7c5SN46L1f8tw9rx6SaZSR62bURcOOaX1N97tT186sKN7E/sp9RBIxFEngk+OYs5z8pOtoBmd0RW4QsDrm5mN025m7ew2JaByjCp2x09eUzaiCvgy0d2xWmns4Yokkb81dw8tfLifUIECN7dORK0d2J9uVumatJiOvzt1Itf+AKNIhw84vr5jImd1zj3qeNu6p4PXZq5izZgeKmrpyuuZmct3koZx/Zh/MxpQ0MXlID/7yPxfy13fnU+UNtrit2tradJfO7OzsVv8s/pARQlC8bg9z31jIvLe/bZaVld0pi0k/Gsvka8fRbcCBUt9kIsmauRtZMXMNVqeFsL+549dkNXL2zeOZeMtIYokYiqJgNpvJysoiLy+PAQMGIMkSb/zhQ2jwRxkx48i2c+0jlzHtjotP2P62Wez68ssv+cc//oHD4eDf//43l1xyCXl5ec2sy41cc801vP7668yePVsTuzQ0NDROIY2WctDELg0NjeacccYZzJkzhylTpjB//nymTp3KF198kc4iaitjxqTKEyoqKli5ciVnnHHGMa9jw4YN3H///QA89NBD3HjjjQwePJgtW7Zw7733psPqW2LevHkt5nY1dnccOHBgu+R1tZUxY8bw2muvsWrVKsrLy8nLyzum5RvLCg/+4vngbcDxnYujMXTo0HR535w5c1oUu2bPTrWjHzRo0Ek97qYnnyTx0EN4OncGRSHzgQfg/vvTpXG6a66Bq69Gue8+5GeeQVIU7K++iuXdd5Efe4ychgoWvV6PxWI5LhdJqoTRgMFgSAnLmVMR4hxEbAWJeA2x4FJioVXEVT1x4wQSiQSKohCJRIhQCPwBomUgwuj1NozWIkzGJIbYHzFJGzHW3IzO8xqSvhuvjbkLXyLMH9a/T1mknnxLBg8NnI7LcHQHpyRJ9HDm0cOZx48BVajsClYxv3Izq+qK2RWswh8PIxrEr+YCWCoDrCRSR0mkjvlVm/l/mz7CKBvINNkotOcwMqsH5+UPwnWYXCmHw4HdbicSiZBMJo943CXzuehzp+COr8StVqMID8F4L0KhMKFQqMFZ14E6fodRLsYmvY/DtA6j8kek8GtgvxfMU5Fa6YKClOA1+pIz2LhwK7Xl9dhcVv5607PUV3j56rUFnH/b5FavC8AbDzO7Yj1fla/HFw9j0+uxGgwM8XTj0s5D6GI/NLdNp9Mxpkt/Rnbuy+bafdR66zHGBJl6K5IqsXfvXkwmEy6XC4fD0SzTSgjBnDU7eOrDhZTWpkoJi3LdXD++N73yM5EkCYfDgcvlomfPnlxx9ijW7CylxhfC47IxpHsBuoZ7z+HOkyoEc9fu5PXZq1hbfKAj5Jm9OnHdlGGM7tsVWT70XE4e0oOJg4qOuC232015eTkWi4Xu3btrjq4jULm3mrlvLmLOG9+wd/OBJgB2t43x00cy6dpxDBjXJ/0ciccSrP56PQs/XMqST1YQqD9QDuzMctB7RHe69O1I4Rmd6Tggl2gsSjgSxmg0pkVOp9OZPidnXTmWohGd+Wby5wgB//v8zzn3yiknzNHVSJvFrueffx5JkvjDH/7AJZdccsR5R41KxT5u2LChrZv7zjNjxgxmzJhxSrqZaGhoaDTSGJoLmtiloaFxKEOGDGHu3LlMmTKFhQsXct555zFz5szj+rb8rLPOonv37uzcuZN7772XOXPmpAO+D0ddXV0zp08kEuHqq68mGo0yduxYHnjgAXQ6HS+++CJXXnklL774Iueccw7Tpk1rcZ3PP/88d999Nx5P84yebdu28f777wOp8sFTyRVXXMGvfvUrvF4vv/jFL3jzzTdbfHlTVRW/34/b7U5PczqdQKobYksc77loDW63m3PPPZeZM2fy17/+leuuu+4Q5926dev44IMPANLdJU8m9sxMqpvkZh2CLKP7+9/hd79DmT4ded48dKEQ7p/9jMTf/kbwtdewjRlzQl6uJUmHZB6JyQxG+xjs1ZNAFCO5z0cYJ5NIJJqVQsZiXVOh+EAyHCEcBsTdiMjHSKIGfdVTmDNuxmQpwGg08v/6X4XRaDyuscuSTHdHLt0dudzGpLT4tbBqCytriykOVhFKRkk0lD4eTgCLqQnKI17KI16+rd7GE1s/xyDryTDa6GrN5kxPEVPzhuCxpF6YW1tWLUk6MKUaROgBtxXc7gwURSEUChEIBAiFQsTVIuLcT71vMwZ1AXZzMfbIQ5gsLyM7f4lkGt3q46HT6Rg0sV/6/9f8dhr/+MW/eP0P7zHlunEYzUd3jO0OVjGzbA3fVm8nKVLvi5kmO+fmDWJSbn+chqM74XSSzABPV/B0RQhBOBzG5/Olhb6qqiqqq6ux2Wy4XC721Qb52/vfsGZnyvGXYTPxo7G9GdM7H5PRiNvtxul0NhPHdJLEGT0Pn+nY9DyFo3Hemb+WN+euoaTGB6TyuKYO7821k4fSs+PRmy3oZPmI23K73dTV1SGEOKpz7YeIvzbAgveWMPfNhWxctDU93WAyMPLCoUy+djzDpw7BaEoJTrFIjJWz1rHwg6Us+WxlMwdXRo6LMZeeybjpoxgwrjf+gJ+6ujoSiQT+gB9ZlnE6nbjdbjp06HDIFxjhcBiny0lpeelxf4F2LLRZ7Fq2bBkAt9xyy1HndblcOJ1OKioq2rq57zx33XUXd911F36/H5fLdaqHo6Gh8QOl0dVlMplaDBfW0ND4YTNo0CDmzp3L5MmT+fbbbzn33HP58ssv02LKsaLX63n++ec577zzWLRoEePHj+dPf/oT48ePT/9CvGvXLr766itefvllLrnkEh588MH08vfeey+bN2/G7XbzxhtvpDNwrrjiCm699VZefvllfvzjH3PmmWe2GKyfSCQ4++yzefHFFxk+fHjKzTBnDrfddhuxWIxOnTpxxx13tGn/2gu3282TTz7JTTfdxNtvv43P5+Phhx9m+PDhaafUtm3b+OKLL3jppZd44IEHuO6669LL9+/fH4BNmzaxePFiRo8+9GX9eM9Fa3n00UeZPXs2O3fu5Nxzz+W5555jwIABqKrKl19+yY9//GOSySRFRUXpzpqnJZmZ6ObOhRUrUK+4AnnvXox79pAxYQLhiROJ//vfuDt2PGEv2ZKcgbBeD6HnEcFnkLImHzawP5X7FW+SBWYjqptGMvg+iUQdieq3CVouAzn1DiJJUrqrZNPukAaDoU370lT8urnoLBShsidYxcLqbays3UlxoJJQMoaCiqI2/eI/ta3Gcsi4mqQy6qMy6mNZ3U6e3T4LvaTDbbTS2erhjKwipuYPJt967GWvOp0Op9OJ0+lsJnyFwwNJKL2oj62lLrgao86Hvf5P2J1dMGfehWzsd/SVH8SFd5zN+3//jOr9tXz+/Ndcfs8Fh51PESora4v5omwtW/0HSkx7OHKZmj+EEVnd0ctty8eTJAmbzYbNZkNRFAKBAD6fj2g0yr6KGt7+YBGLtpQhAKNe5qJhhVw0vIgstwu3243Vam3TtVBZH+Dt+Wv5cOEGApFU92+Xzcz0cQO5cuIgsl3tJ3Q0dhVPJpPEYjEtmJ6UYLX0s1XMeXMhK2auIZlI/bxJksSgs/ox+ZpxjJs2Apsr5aKMBCMs+HQlCz9YwrL/riYaiqXXlZWfwbjLRzJu+kj6jemFLMv4/X727d9HMpkkEokQj8exWq2YzWY6dOiAw+E45LppvDdJknTSz1Gbxa66urq0FbI1ND6kNTQ0NDROHVoJo4aGRmsYMGAA8+fPZ9KkSSxZsoSzzz6bWbNmNXMSHQuTJ0/mvffe44YbbmDZsmVMmTIFg8GQznyNxQ78gn3ppZem//3hhx+mSxT/+c9/0rlz52brffrpp/n222/ZunUr1157LfPmzTtsIPQLL7yQFsTsdjuqqqa7Gbrdbj788MM2i3ntyY033kgkEuHuu+9m5syZzJw5E5PJhN1ux+/3N+vgePALxcSJE+nVqxfbtm1jzJgxZGRkpPfp8ccfZ/r06UDbz8WxMHToUP7zn/9www03sGjRIgYOHIjT6SQej6efQ506deKzzz47qd/yt5nhw5H37EE8/zzcdx9SOIxt/nyshYV477gD3R//iMPlOjFOL9stiPB/ILkVYl+D+dxD5tHpdIcJxe9IItaBWNVPicfqiSmVxE13k0jamoXlBwKB9BKyLB8igJlMJnQ63THtm06SKXLkUuTI5abCCWnxa3H1dpbX7mRnsJJwMpZ2MKEqyMhIEkiSnMoyEykJLCEUqmMBqmMBVtXv5oWds9FLOpwGC52sWQzN7MbU/MF0tXc48qAOOl4HC1/BYCbB4ADi0RXUBTZQF1AxVP4du7MbzuwfYbZ1a/UxMJqNXP/QFTzx4+d5688fct6tk7A6DpybUDLG3IqNzCpfR3UsVTqoQ2akpwdTCwbTw3FsJcyt2V+3243JYuOlz7/lzQXriTWIIMO7ZXHJsC50yfWQk9OBjIyMNjWg2LKvktfnrObrldtJNrzzd+7g5tpJQ7lwZF8spvYvV5MkCbPZTDAYJBqN/mDFLkVRWDdvE7Pf+IZvP1xOOHDAkVU0uCuTrxnHWT8ag6cgC4CQP8zcNxfyzQdLWTFzDfHogedKh84exk0bybhpI+kzsgeynPp5DIVC1NTUpDvLRqPR9HPD4XCQk5PTzAHYlFAoVQJpsVhOenOTNotdTqeT+vp6EonEUevs6+rq8Pl85OcfW8tTDQ0NDY32RRO7NDQ0Wkvfvn3Tgtfy5cuZMmUKX3/9NRkZGW1a36WXXsrOnTt57rnnmDlzJjt27MDr9WKz2ejduzfDhw/nggsu4Pzzzwdg//793HbbbQDceuutabGmKVarlbfeeouRI0eycOFCHn30UR5++OFD5hsxYgQrV67kT3/6E3PmzKG6upqCggLOP/98HnroITp27NimfToR3HHHHZx33nnMmDGDr7/+mt27d+P1enE6nRQVFTFq1CguvvjiQzLI9Ho9c+bM4fe//z1z5syhtLSU+vp6AIIHlewd67loC1dddRXDhg3j8ccfZ/bs2ZSUlGAwGBg8eDCXXXYZ99xzzykTGCORCFOnTgVg5syZrX5Jlu64A267DXH77fCvfyElk2Q8+yzJ11+n6m9/w3H11e3WxTS9TdmNsN4IoecQwWfBdHarM6UMphz0+TOw1l0PyiLQ7YGM/6CIDod0hYzH4+nOdo2/KzSi0+maiV+N/27ti2tT8ev6wvEoQmVXsJLlNTtZVrOTncEKwskYCaGkPF4SGNChk2SMckpoi6tJomoCVQiSQqEuHqQuHmSddy+v7pqPXpJx6C0UWDMZlNGFc3IH0sd99J/rpsKXquYSChUS8J1JsH4+ifgO6usqqK97CoOlL46sKTic+ZjN5qMKX+fcOJF3/vIJpTvK+eipL7j2wWmUhuv4snwtCyq3EFNTAoNDb+bs3IFMyRtAlunEhKsnEgk+WbSOF79cSU1DaVr3XDc3T+pPz/xMFEVBCEFtbS319fXpMsejubtUVbBwwy5en7OaVTsO5ECd0bMj104eyrj+hYfN42pPTCZTWuz6ISGEYMfqXamg+XcWU1den/4sp0s2ZzUEzXftl3I7B+qDfPXafBZ+sJRVX60jET/QXTW/KCctcPU8o6jZOY9Go1RXVxMOhxFCpL8Msdls6PX6Ft1cTWkUu2RZZuLEicCx3XePB0kcKcXyCEyaNIkFCxawYMECxo4dC5AOqD84l2rGjBn87Gc/45JLLuGjjz46/lF/h2ksY/T5fKfFN4gaGho/LHbs2EEkEqFLly5aSfUpQnsOaGicHPbs2UO3bt0A2L17N127dj21A9JoF9rjHhoKhdKOsmAw2LauoyUliOnTYdkyJBpyqPr0oe6f/yTrjDMOKTU8HoTqRVRPAhFEcj+DdBh31xGXVyoQddeDshd0nZAyX0fSNXcPCSHSeWBNhbBEItFi0wODwZAWwJr+fawxCUlVYVewkpW1u1heu5MdgZT4FRcHXshlZEw6PTadCaveRExJ4E9ECCsxkuLw1UM6ScauN5NnyWCAuxNTcgYwOLNrqxxaqqoS9K0jUP0BoVAtqqoHyYBkGIbeMgyHMxOHw3FE4Wv+O9/ypx89idlhZvjMC9mklqc/62z1MDV/MGOye2HStb/rqTGza/nmXbwwcxXbG8SQLIeZ/znvDC4eMzB9jSaTyXSZY1NnZ6Nzx+l0Nsv2i8QSfL50M2/MXc2+Ki8Aelnm7DN6cu2kofTtktPu+9MSwWCQ0tJSTCbTD+IeX76rMh00v3/bgcB/R6adCVeMYvK14+g7OlVy6Kvx8+3HK1j4wRLWzNmIkjyg0XTqlc/46aMYO20ERYMO/ZlIJBLU1NTg96ech4qioKoqOp0OWZZxOBx06NChRTdXI6qqUlxcjKqqZGdnk5WVcpe1+b7bQGufA212dk2fPp358+fz+9//nq+++qrFm9q6det48MEHkSTplARQamhoaGik0DoxamhoaGhotBMdOyItXQpz5iCuuw6pogLzli3kjRtH4PzzqX/uObLy8tql0+QBd9cMRPCZY3J3AUi6XMj8D6LuWlD2I+pugMz/pKY3ztMkx6tpTI2qqs3ywBqFsEQikf7T6NxoXE9TEaxRADtSKL5e1tHTmU9PZz7XdBtLUlUoDlayum43y2p2pMQvJUZUSRBR4hAPoEPGpDNQYM2kizUbVagN5Y5+/IkISaGgCBVfIowvEWarv5T39i1FRsKmN5NrcdHX2ZEpuQM4I7PwEJeaLMs4M4bgzBiCEllEqOYlAsEgoWiEhH899dER1Nf3Qa83pjtGNu0SGVUSxMfaMfdwEt3hZ8VzS7Dd0ZVhmYVMzR9CP9eJyXpTFAWfz8eukgr+PW8Di7amBBGTQce1Zw3ilqmjsB4UmK/X68nIyMDtdhOLxfD5fAQCARKJBLW1tdTW1mKxWEhIBr5YuZMPv92IL5T6fdJhMTFt3ACumjiYnIwT40w7Eo2/z8bjcRRFOellcicDX42fBe8uYc4b37B5yfb0dKPZwKiLz2DSNeMYft5gDEYDdRX1/PeFr/nmg6WsX7AZVTkgBHcb0DmdwdWl7+GvP0VRqKuro76+vlnwf+PPdVM3V2sIh8Ooqpq+J5xs2uzsSiQSDBkyhC1btjBx4kTuvfdebrnlFmpra9m6dSt79uzhs88+4+WXXyYSiTBq1CgWLVr0g++SoH2jr6GhcaqIxWJs27YNWZbp16/fD/5+fKrQngMaGicHzdn1/eS0cXYdzGOPIR5+GCkeB0A1mai99174xS/IzMw87pdwofoa3F0BJPdTSOapx74OpQxRdx0oJaDrhpT5HyRd67OumtIYit+8M2Ssxc7zjWLawS6w1oTiJ9QkOwIVrK/fy7KanewIlBNW4sTVZEO0fcrFZZINOA1m+rk609WeTXXEx65QNSXhGrzxMEmhcLgXXxkJq95ItslFX1cBZ+X0Z7SnB3rdAV+IECpEv0AJPEk4HCEYySUY64UwjAV9EZASjVSTzIrQPmbXbiakxogvqSP46y3ozHqe3Phnehd2bdPxPhKNX2Z6vV5q6r18unwnn63aRTyZEjrOH96Luy8fT7a79fl4qqoSCoXw+Xxs2VvB56t2sXhbGYqaOoL5WU6umzyUi0f1O0Q8O9ns2rWLRCJBp06d2r2M+FQRDcdY/MkK5r65kJWz1qVdWbIsMXhSfyZfO54xl52JzWmluqSWRR8uY+EHS9m4aGszJ2aPod0Ye/lIxk0bQadeBS1uT1VVvF4vdXV16Z9hg8FAMplMr8/pdNKhQ4djupdVVVVRX1+P2+3Gbre32323tc+BNotdAHv37uW8885j27ZtLd6khBAMGDCAWbNmkZube9h5fkhoLzkaGhqnCp/Px969e7FarXTv3v1UD+cHi/Yc0NA4OWhi1/eT01bsAohG4frrER98gNTwipXo0IHKv/8d29SpuFyu4+qErAaehtCzoO+BlPXZMbm7GhFKKaL2OlBLQVfYIHhlt3lMB5NMJg9xgcVisRYblcmyfIgAdrRQ/LiaZGeggg31+1hWu4PtgQoiyThxNYF6kPhl15vo7SpgaEY38ixudvgrWF23m92haryJEAk1eVgBTELCojOQbXLSy5nP+A59GJ/TB5MMhN9GBGegqj7CsSyC8RHsiZ7NjoBCWbgeFUFSUpHMBobl9+DL6z9m65IdXPSTc/n5jNva6UiT7rLo9XqJRKN8u7WMt7/dRl0w5boaXJTPL6+YQN8ux/4OrqqCxZv38PrsVSzftj89vVd+BhcM7cawwhxMJiNOpxOXy9UuDsa2UlZWRiAQIDs7m8zMY+/UebqgJBVWz9nA3DcX8u1Hy4kED+SQ9RjajcnXjmfi1WPIysugYk8VCz9YxqIPlzZzewH0HtGDcZePYNy0keQVHrmkVAhBIBCgpqYm3QClMY8vEknlu+n1enJyctrUTGT37t3E43Hy8/ORZfm7JXZBypr2t7/9jVdeeYW9e/c2+6ygoIAf//jH3Hfffe33EPmOo73kaGhonCoqKyuprKwkMzPztApj/qGhPQc0vqtcfvnlLF68+JiW+fDDDxk9evQJGtGRaavY9V3bzx8ap7XY1ciOHYjLL4eNG9N5XpGhQ6l67jky+/Q5aqBzSwjVj6g+K+Xucv0dyXJBm4YnkvtTDi+1HPTdkTL+g6TLatO6WrU9IUgmk4eE4sdisRbzwI4lFD+mJNgRqGCjdx8raovZHignosSJKUlUUiJbo/hl0Rnp7cxnUEZX+rgKyDG7WVi1hWU1O9gVrKQuHiKuJloUwMw6A1lGBz0cHkbYS7Er85nny2F3xImdLFwil57GfHrZc8m1uJGQ2LVqH09c9yI6vY5XtjxJftHxGUCi0Sg+nw+/34+qqmwvq+ffCzZTXOkDUq6rey4fx+QhPY75OovGk/x32WbemLuGPRV1qWMnS0wZ2pNrJg2he64bv99PIBBo5uKzWq24XC7sdvtxCbptoba2lpqaGhwOx3euIZ4Qgu0ri5n9+jcseHcx9Q3nECC3WwcmXzOOSdeOo3PvAkp3lrPwg5SDa/vK4vR8kiTRd3RPxk8bxdjLz6RD59aJ1+FwmOrq6nTEiV6vx263EwqF0sJXW9xcjcTjcXbv3o0kSRQVFRGNRr97YldTysrKKCsrQ1EUcnNz6dKlS3ut+nuD9pKjoaFxqtizZw9+v5/8/Hw8Hs+pHs4PFu05oPFdZeLEiSxYsOCYlpk3b166+9J3hR/Kfn5X+U6IXY188AHixz9GauiKKWQZ35VX4nv0UTy5uW3argg+iwg+nRKpsj5DktpWHimS+1IZXmol6HsiZf4bST65rhghRLM8sGMNxW+aB9ZUYIkqCbb7y9nk28+q2l1sC5QRVRLE1ARKQ5i9XtJhkvWYdUa623MYlNmVPs4Cejnz0SExu3Ij31ZvozhQQU0sQKwFAQxAAnSSQp4hxDnu/VxZ0BuD5XaCYSvBYBBFUXj2tn+x9dudjLh0CD997hYcDsdRux02RVXVdIh8o+Om2h/hncXb+XZrKQBWk4Fbp57JNZOGYjIcWzR3rT/EuwvW8d436/EGU+u3m41cNnYAV581mLzM5j9rqqoSDAbx+XyEw+H0dJ1Oh91ux+VytaprZXsQCoUoKSnBaDSmv+A43SndWc7cNxYx582FlO440LjAmeVgwpWjmXLdOPqM7Mm+raUs+mAZ33ywhF3rDhiLZFliwPi+jJs2kjGXnYknv/U/u7FYjJqamnSXXp1Oh9vtJplM4vf7EUJgMBjo0KFDm9xcjdTX11NVVYXVaqVTp07tet89JWKXxtHRXnI0NDROFVu3biUej1NYWHhcDy+N40N7DmhoaGi0nfYSuzp0SGVVVVVVndgKFFWFBx5APP44UjLVXVC1Wql88EGU66/H4/EcU9MYoQYa3F1+JNcTSJYL2zw0kdzT4PCqAn2vBsEro83ray+OFIp/OBrDsw92gjXmgUWVONv85Wzy7md1/W62+8uJKnFiapKkSLmTGsUvk85AF1s2gzK60MdZQG9XAR6Tg4gS5729S/i8ZBWlkfoW8r9SUyTAIKlkGHR0tXdllKsXHXZK/N9FzyBJEr/95Kfk9chJC0N2ux2bzXZYYSgej+P1evH7/WknVSyhMHPdfj5auo14UkGS4NLR/fnJRaPxuI7tWt5ZWsMbc1fzxfKtJBpyofIynVwzaQiXjO6H3XL0rqKJRAK/34/P52t2joxGIy6XC6fTedSufceDoijs3LkTgO7du5+2IfX1VT4WvLOYOW8uZOuyHenpJouR0ZcOZ/I14xh69kBKtpXxzftLWfjBUvZuLknPJ+tkBk/qz/hpIxl96ZlkdDi2rurJZDLdYbExeN7lcmG1Wqmurk6fO5fLRXZ29nEfx5KSEkKhULq8tD3vu5rYdZqiveRoaGicChRFYdOmTQD07dv3hP7SoXFktOeAhoaGRtv5zt5DvV64+mrErFk0ShrxTp0offJJzKNG4fF4Wp17JIIzEMGnUplbnv+22d0FIJK7EHXXg1oN+j5Ima8hye42r+9E0jQUv6kT7Eih+IfLA0ugsi1QxmZfKWvqd7PDX05UTRBTEiSail86AyZJj8NgQSAIJCMYZQN6SaanI4/JuQNR1CTfVG9lm7+MqqiPsBJLh+Y3GQkSYH20HP3iIFnj87j0/y6ghy0XuyEldOp0Omw2Gw6HA4vFQjgcxuv1NndN6fUsK67hX3PWUutPTT+jZ0fumz6BXp1a32hACMGSLXt5ffZqlm454BYa0C2P66cMZeKg7uh1bciDE4JIJILP5yMYDKZz2iRJSpc52my2E1Lm2BhS37Fjx9MqPikSjLD4k5XMeeMbVn29Pt0dUZYlhp49kEnXjGP0JcMp21mRFriaOr30Bh1Dzx7IuGmjGH3xGTizjr3jpaIo1NfXU19fnz4nDoeDjIwM/H4/Xq8XSLkmc3Jy2uX4qapKcXExqqrStWtXTKaji6bHgiZ2naZ8Zx/QGhoa32nC4TA7d+5Er9fTt2/fUz2cHzTac0BDQ0Oj7Xzn76GrV8OVV0JxKnNHAKExY6h48kmcnTuTlZV1VEeFUIMN7i4fkutvSJaLjmtIIrmzQfCqBX0/pMx/IcnH5ho5VQghUBTlkK6Q8Xi8xVB8nU7XTABTdLA7VsPWYDnr6/eyI1BBRIkTTsaIqwoCgQTIDblfBdYMhmd1Tzu/OlkzkRuaBSiKwtLa7cwrm8sm304qYzrCqh4VCXlfHPtP9iEJCP69E/aeLvKwUSA78egd5JpddDS6Mas69Hp9ukTTbrezuzbMc58vZ+v+KgA6Zru49/LxTBxU1OpSwVgiycwVW3lj9mqKy2sBkCWJSUO6c+3koQwqbL+8K0VR0mWOjWWXjcfe4XDgcrkwmUztVuZ4OoXUJxNJVn29nrlvLmTxxyuIhmPpz3oNL2LyteOZcOUoKvfWsPD9JSz8YCkVe6rT8xhMBoafN5ixl49g1EVnYHe3TXwSQuDz+aitrSXZ4Cq1WCxkZ2ejqiqVlZVpN5fb7cbj8bSbK66xtNRgMNCtW7d2L2c9YWJXbW0tL7zwAitWrEBRFAYMGMBNN91Ejx49jrjcmWeeSW1tLcXFxUec7/vOd/4BraGh8Z2krq6OkpIS7HY7hYWFp3o4P2i054CGhoZG2/ne3ENffRV+/nNoyM0ROh11N99M/f33k+nx4Ha7j+iAEcF/IIJ/B103JM8Xx+XuAhCJHYj660GtA8MApIx/IcnH7iI5XRBCkEgkDskDi8fjLeaB6fV6vESZ79/BIt8OwkqMmJokIRQMkh4JSIiU+GWQdBh1BsyygQyjjf7uTvRxFtDHVUBXewd0kowQKkQ/Jel9knXBGHO8nVj0OzPRryIkh1oJPVrQMFhwYSJbWPBgxSx0GGU9Dp2ZDJ2Tsn1JFm8upy6UwGoy8uMLRnLVhEEYW5nLVR8I894363l3wTrqAilHmNVk4JLR/blm0hAKPCdW2IzH4/j9fvx+f7MyR5PJhMvlwuFwHHfFQV1dHdXV1acspF4IwZZlO5j7xkIWvLsYb7U//Vl+91wmXzOOiVePxl8T4Jv3l7Low2VUl9Sm5zFZjJx5wVDGXT6SERcMxeqwHNdYgsEgNTU1xONxIFVS6vF4sFgs1NTU4POlgvANBgO5ublYrdY2b+9wVFVVUV9fj8vlIjf3+BoyHI4TInYtW7aMCy+8kLq6umbT9Xo9v/rVr3jkkUdavCnn5eVRVVXVos30h8L35gGtoaHxnaKsrIyamho8Hs93rlPN9w3tOaChoaHRdtrjHhqNRpk2bRoAH3zwwTFlZrUryST8/OeIF15AanAhKU4n5X/8I/ELLyQrKwun03lYV0TK3TUJhBfJ9VckyyXHPRyR2JZyeAkvGAYjZbyCJH+/Mj4bQ/EPdoJtDpaxKLCTbdHK9Lw5Bidj7IX0sxVQSYhd8Rq2hyvZE6khrirE1QQxNZkWv0w6AybZgNNgoY+roEH86kih3Y0x+i4i+A8q9oa5dVwvkgmZm14/jx2FZraGK6hOBgmrcRQhcGLEk7ThqXZi8plJV0W6FQwdIb9DNhM7D2BgZtcj7uuu8tpUHteyLcQSqXfwnAw7PzprCJeN6Y/DenKveyEE4XAYn89HKBRqVuZos9nSZY5tcQGFw2H279+PwWA4qV/qlmwvY84bC5n75kLKig9cO+5sJxOvGsOEq0aTiCVY+MEyvv14OXXl9el5LHYzIy8axrjLR3LGeYOx2I7/fEQiEaqrq9NuOr1eT1ZWFi6Xi1AoRFVVVVpwzMjIwOPxnJCy0t27dxOPx8nPz8fhSInm7XnfbXexy+v10qdPHyorUyexb9++mM1mNm7cSDweR5IkJk+ezMcff3xYZVATu1JoLzkaGhqngl27dhEMBunYseMpt3f/0NGeAxoaGhpt5zvVjbG1VFTAFVcgFi1CIqVtxHr0oPSZZ9D16oXH4zmsCCCCzyOCTzS4u/6LJB1/HqdIbEHU3dggeA1Fynjpeyd4NRJVEiys2sLMsrWUhutSji8h6GcvYKyjiK66jHT5V1NCSpw98Vr2JOsojteyP1ZHQijE1SRxNYmKwCDpMen0mGQDNr2JXs58ejuy6CpWM/uBFSx4R6XbQAP3/msYButYnO5uuN1u9oRreWb2fJZ9W0EyCk6zng4FEjmFEmbTAVFCkVTqiRHSK5isZvq6OzEltz9D3F1ZtbOMN+asZtHG3en5+3bJ4frJw5g0tDuG0yDAXVGUdHfJaDSanq7X65uVOR7L+oqLixFCUFRUdEKzaesq6pn/dipofvvKA1VrZpuJMZeeyYQrRyPrZBZ/vJzFn6xo5vKyuayMuvgMxk0byRnnDMJoNrbLmOLxODU1NQQCAQBkWSYjI4OMjFTDiaqqKvz+1DiMRiM5OTnt7uZqOpbdu3cjSRJFRUXp0sjTuhvjn//8Zx544AE8Hg+ffvopI0eOBFJljQ8++CAvvPACkiQxduxYvvjii0MGr4ldKbSXHA0NjZONEIItW7aQTCbp3r37CXu4abQO7TmgoaGh0Xa+l2JXI998A9dcA6WlAAhJInD22ZQ/9hhWjyddhtRIc3fXX5Asl7bLMERiU4Pg5QfDsAbB6zQ5Ru1ATdTPrPL1zKnYQEhJ5SlZdEYmdujLefmDybW40/MenAd2uFD8oBJjd6yG4lgNu+K1lCd8JFBS7i+RRBUCvaTDKMkY0GGoU4nctAERE1z5bIIrLtqF03khK0qv5IkPN7CjtAaALh0y+MX08XTp6uDL8rVsqtlLJBzBGpcxiObCV52IUlWZpGa7jqTvgJg1sHcHfnreOIb17NTuuUntRSwWS5c5NhUXzWYzTqcTp9PZqiypRjdRQUFBu3cdDwcifPvRcua8uZA1s9ejqikJRdbJnHHuICZcMQqz3cKy/65iyScrCNSH0ss6Mu2MuWQ446aPYsjk/hiMrWtE0RqSySR1dXV4vd50h0Wn00lWVhYGg4FgMEhlZSXJZBJJktLZXCfCzdVIfX09VVVVWK1WOnXqlJ5+WotdY8aMYenSpbz00kvcfPPNh3z+zjvvcMsttxCNRhk9ejRffvllsx3QxK4U2kuOhobGySaRSLBlyxYA+vfvf0IfcBpHR3sOaGhoaLSd77XY1cgTT8ADD0CD40U1Gqn56U+p/5//weFw4PF4MBpTjhARfAER/BvouiB5ZraLuwtAJDYg6m4CEQDDcKSMfyLJ390vy4QQbA+U80XpGlbUFqOQKqHrYHIxNX8wE3P6YtW3zkl0tFD8gBJlV7SGndEqdkaqqVQCJIRCApUECioC8ys16N6rRSoyYv6rh+jmDGr2p7KzHFYjt18wiismDDqsC0sIQYmvioX7NrCvshJfZZx4nQRJCVUIaiMJahwB6grqUe0KEhIWnZFss5PejnzG5/RmQoc+GHXt4ypqL4QQhEIh/H4/wWAwna0mSRJ2ux2Xy4XVam1RtCsvL8fv9+PxeMjKyjru8SQTSVbOWsecN75hyacriUXi6c/6jOzB+OmjcHocrJ69niWfriTsPxDE7852MuayEYyfPpKBE/qib2W+WmtRVTXdYbFRX7HZbGRnZ2MymVAU5RA3V25ubjOx/ERRWlpKMBg8pFnAaS12ZWZm4vP5CAQCLboCFi5cyIUXXkgwGGT06NHMnDkzvUM/dLFrxowZzJgxA0VR2L59u/aSo6GhcdIIBALs3r0bk8lEr169TvVwfvBoYpeGhoZG2/lBiF2QErpuuQXefhsaXteSHg9lf/kL0TFjcLvdZGZmopNjDe6ueiTXY0iWy9ttCCK+DlF/M4ggGEciZbyAJJ34l+X2JKkqLKnZzhdla9gVrEpP7+/qxNT8wQzJ7IZOap8vAYUQxGKxtAgRDodRFAVfIkwJAUoJsDdZT1UySNwXI3njZqSwSmBKD+JF2SAJbEUBsvvW0ynTQ5+MM+jj6kwfVwHZpubZbXsr63lz7mo+W7IZvSzoYDfSNdtO5442FFccvxImrMaoFmGqpTA1RFCkA6/9EhJmnQGPyUEPRx5js3sxOW8AltNEAEsmk+kyx1jsQDdDg8GQdns1Cr6NNDqK7HY7BQUFbdquEIJNi7elgubfW4K/NpD+rGPPPMZNH0VmrotN325j6eeriIYOjC0zL4Nxl49g3PSR9B/bu906Gx48Pr/fT21tbTp7y2w2k52dndZoAoEAVVVVaTdXRkYGWVlZJ+XLblVVKS4uRlVVunbt2qwU9bQWu4xGIw6Hg9ra2iPOt2TJEqZOnUogEGD06NHMmjULq9X6gxe7GtFecjQ0NE421dXVlJeX43K56NKly6kezg8e7TmgoaGh0XZ+MGJXI7t3w7RpsGYNkMrzig4cSNnTTyMKCsjIyMBt+BAp/FfQdUbyfNlu7i4AEV/bIHiFwDgaKeN5JOkUBfofA754mK8r1vN1+Xq8iVQHQoOkY1yH3pyXP4QuNk+7bi8Wi+H1egkEAun3XVmW044kWZaJx+PE43HK/LW8uXQ9i59dimnpPhSXmfDPB2IZEEZxxEgKgUESmCSBSWfBqLOTbXbR11WAyWdn7coqlm/e36iB0qtjNtdNGcbZQ3sg1FQWViAQSG1PSbIrWMm+SC17EnXsTdZTLoIkJPWQfZAAk2wgy2SnyJ7LaE8PzskbhN146gTORgGx0XTTVEuwWCy4XC7sdjs6nY5IJMK+ffvQ6/UUFhYeU9nm3i0lzH1jIXPfWkTF7gOiaEaOi7GXjSCrIJOdq3ex4su1zRxe2Z2yGD9tJGOnjaTvqJ4nTFBqDPevrq5Oi38GgwGPx4PD4UCSJJLJJFVVVencLpPJRE5OzklxczUSCoUoKSnBYDDQrVu3ZufgtBa7PB5POkDuaCrlkiVLOO+88wgGg4wZM4aZM2fSvXt3TexCe8nR0NA4+ezfv5/6+npycnLIyck51cP5waM9BzQ0NDTazg9O7Grk88/hppugwXggJAnfZZdR+Yc/oDfpyNT9L07zFmTX/0OyTmvXTYv4KkT9rSDCYByHlPEcktT68PCTyZ5gFV+UreXb6m0kReq9M9No4+zcgUzOHYDL2H6lmKqqEgwG8Xq96e53kDKJuN3uw2ZNLd68hyfeX8Cu8jqIK3jeWYMIx5n86NnI52axPVRBdbyWhBohLgQJJBKKBGUWEsUWFO+B9eV1sXDO6CIuHDyAro4OzRxqjV0nA4EAwWCwmTsqKVR2J2pZGy5hfbSMyrifqJJAcKgsIAFGWU+G0U6hvQMjPN05N3cQmWZHux3H1qKqKqFQCJ/PRzgcTpc5NoqKDoeDsrIyhBAUFhZiMBw5G6umrI55b33L3DcXsnPNgTB/i93MiAuGkt3Jw74tpaz+eh2J+IEssbzCHMZNG8m4aSPoNbz7Cc9Ci0aj1NTUEAqlcsB0Oh2ZmZm43W5kWUYIkXZzKYqCJElkZmaSmZl50qNLqqqqqK+vx+VykZub2+yz01rsaszsWrx4MSNGjDjq/IsXL2bq1KlpwWvTpk14vV5N7NJecjQ0NE4yO3bsIBKJ0KVLF1wu16kezg8e7TmgoaGh0XZ+sGIXgKrCH/4A/+//QUMJk2o2U/W//4tvWi8M6iw87gD2jm8iy+1bjibiKxD1t4GIgGkCknsGknR6lLwpQmVV7S5mlq1ls78kPb27PYfzC4YyIqs7ern9Ssri8Tg+nw+fz5d+tz1artTuijr+/sE36Q6JbpuZOy4ajbRqHy/+8t9kd8ziX9ufxmg2UhGqZ13tDlaVfsPitX4qdzhRIg3j1wl0nWKYi+KYnRJGSYdB0mPVm+huy6G3M59+7o70dBdgNprS44jFYgSDQQKBQDPhS5IkrFYrJquZtZESvqnZxjZ/GdVRP2El3qIAZpD1uA1Wuto6cEZWEVPzB5HTJNj/RJNMJvH7/fh8PuLxA06rQCCATqeja9eu6U6ETQn5Qiz8cDlz31zI2rkb04KZTq9j8KT+5HTJpmJPFevnbyKZOKBbdOyZx/jpoxg3bSRFg7uelLD/RCKR7rDYGD7vdrvJyspKi6jJZJLKykqCwSCQcnPl5uZiNp8a92Vjk4D8/HwcjuaC6Gktdt1///088cQT3H///Tz22GOtGkRTwavxBGlil/aSo6GhcfIQQrBxY+ph3qtXr2Nq46xxYtCeAxoaGhptR7uHAsEg/OhHKbdXA4mCfEr+PIlYXzdW1ySyC85r9/IlEVuGqP8xEAXTWUjuZ06p4BVKxphXuYlZZWupiqWCuHXIjPT04Lz8wfR05rXbtoQQBINBfD5f2mEDqVIyl8uFy+VCrz+0fNQbjPDif5fy3jfrUFSBXpa5+qzB3DZ1BE6bmXg0zk09f051SS0/eeImLr/nAvZXe3lr7ho+WbKJSCwlajqsUbr3qUTtksCvcxHHRlwVxNUkCaGgR8Yg6RrELx1GWU8XUxY9bDn0cRbQy12A3WxNh5c3Or6iDU0Q4IDwZbfbsdvtSJLE4prtzK/czGZ/CZVRH+FkDPUwAhikykSdBitdbB6GZXbj3PzBdG7nctGDEUIQjUbx+/3NMr4sFgsejweXy4XJaGbVrHXMeXMhSz9bSTyaSC/fa3gR+UW51JTWsWnxNlTlQHln1/6dGHf5SMZNH0nXfievm6WiKOkOi6qaGk9jh8V0Y4oW3FxZWVmnrOtmPB5n9+7dSJJEUVHRCcksa6Tdxa65c+cyZcoUcnJy2LNnT6tfmBoFr0AgoIldaA9oDQ2Nk0s0GmX79u3Isky/fv1O27bTPyS054CGhoZG29HuoU3YuBGmT4dt24BUnld4eAGlf7kCkfc/OByuZp0b2wMRW4yovx2IgWkykvupky54lYXr+bJ8LfMrNxNTU8KFXW9mSu4AzskbSJap/UrsEolE2sWVTKZK2RpFIbfbjc1mO+zvVglF4f0F63nhv0vwh1NOqgkDC7nn8vF0yWnuOPripTn8/X+ex5Zpp+vvLmLhtr3pPK7uBR6unzyUc4a4MMRmIMIfUZUwsSnsYXN8JJsjBdTFYsTVBDElSUxNkFAVdMgYJRmDrMeAjE7W0dHgppspix7WHHo68nBZ7M2yxA52fFksFhwOB3a7PS3kKYrCmvo9zK7cwEbvfioiXkJKDEUcmgEGoJdknAYrHa2ZDM7ownn5Q+juyD3svMeLqqqUl5c3lDJC9Y46Vny+jjVfbiTsO1Bmmt89l0698vFW+9m+opimckjR4K4NJYoj6dy7bSH3xzN+n89HbW1tWjOxWq1kZ2c3c2olEgmqqqrSbi6z2Uxubu4p/0Lb6/VSWVmJ1WqlU6dOJ3Rb7S52qarK7bffTjKZ5M4772T48OGtHszSpUv57W9/ixCCefPmtXq57yPaA1pDQ+Nk4vV62bdvH1arle7du5/q4WigPQc0NDQ0jgftHnoY3ngD7rwT/Cl3k9BJ1F17ATX/+xcknQ6Xy0VWVtZhnUdtQcS+bRC84mA6B8n9dyTpyPlIx71NIdjg3ccXZWtYU78nPb2TNYup+YMZm90bk659xtAYBu71egmFQmkxRK/X43K5DtsJsOmyizbu5u8ffMOeynogJVjdN30CI3p3PmT+pKLy1YqtPH3RX1Fqg4SHdyIytBNj+nXluslDObN352ZimkhsRwSfgNjc1P+xUK67ga2J8Wz217DJtx9vPExCJIkpKQEsoSaRkTA0uL4MyMiSTJ7BRTdTVsMfDw69GVVVSSaTKIqCXq9Hp9Olha/GXKzDXUfr6/fxdfk61nv3URapJ5iMtiiA6SQZh95MviWDARldOC9vEP3c7SOObFu1g09e/JKVn6+jvtyXnm7PtJFblE00EKNka3mzZXoNL2LctFGMmzaC/KITI8QdiUaXVk1NTbrDoslkwuPxNBNTGzsxVldXp91cWVlZZGZmnhZfZpeWlhIMBsnOziYzM/OEbqvdxS6N9kF7QGtoaJxMKioqqKqqIjMzk44dO57q4WigPQc0NDQ0jof2uIdGo1Guv/56AP7zn/+csnybdkVV4d57ETOeRWooxVIdDioefpjAhRciyzIZGRntFlotYt8g6n8CJMA8Fcn1t3btAtlITEnwTdUWvixbS0mkDkhlRg3J6MbU/CEMcLdfeVljDpTX602LDpBy17hcrnTXu5bYWVrDEx8sYOmWfQBk2C3cefFoLh3TH91BxzwQifHxtxt5a94aKuoCGHfW4JizHZ3FwF9XPMaAvocKY00R8RWIwOOQSHXpRMpAst+JsFxNeTTEZl8Jm3wlbPLtxx+PkBQKcTUlgMUbxK/GkkcdMhKQrXfQzZRFoclDF30GZkUmkUigqio6nQ69Xo9er8dms6WPx5FC4Lf7y/mybC3r6vdSEqklkIiQPIIAZtOZyLO46e/uzJTcAQzJ6Nqqa7W6pJZ5by1izpsL2bVub3q6yWakc6+OhANhSndUNFumcEhnzrxoCBOvGEO3Pl1OepB7I40dFhvLSfV6PR6PB6fT2exaSyQSVFZWpktoTxc3VyOqqlJcXIyqqnTp0uWw99T2vO9qYtdpivaSo6GhcTLZs2cPfr+f/Px8PJ4Tm5ug0Tq054CGhoZG2/lBB9S3AlFdgri0H9JiPxKp0sZEURGlTz1FvHt39Ho9WVlZuFyu4xaJRGw+ov4uUoLXBUiuv7ab4FUTCzCrbB1zKzcSTKaEALNsYGJOP87LH0Se5dDw8bYghCASieDz+dJB4JDqeOd0OlOZT0cRFOoDYZ7/fAkfLNyAKgQGvY5rJg3hlvPOxGFpvmxZrY+35q3l4283EoqmgtUz7BauGDeQFQ+8z75N+7nqV5dw22PXtWrsxL5GBP4GSkM3QV1HJPs9YL4QSUp16iuN1LHJmxK/tvhK8CcjKKqaKn1UkyRUJd110SDp0JMSfjJkK12NmXQzZNJJcmJRdM1KOXU6HRaLBafTmS7pbHSCtcSeYDWzytayqm43+8M1+BMREuLwMUcyEla9iRyzi36ujpyV05+RWd3R6XQEvSEWfrCUOW8sZP2CzU2C5mWyu3iIR+PUlXrT65Ikif7jenPmBUPoM6E7ZtcBZ55Op8PhcKTP9clwScViMWpqatKliLIsk5mZSUZGRjPhTQiBz+ejpqYGRVGQZZmsrCwyMjJOCzdXI6FQiJKSEvR6PYWFhYcd22kdUK/RPmgvORoaGieTrVu3Eo/HKSwsTD9gNE4t2nNAQ0NDo+1oYtfREaHXEPMeRLqjGqk0lcMkgPDkyZT85S9gs2E0GvF4POkg8jZvKzoX4f0ZKcHrYiTX/yFJbQumFkKwI1DOf0vXsKK2GIWUC6iDycV5+YOYmNMPm759nCyKoqS7+TXNqjKbzbjdbhwOx1HdPomkwtvz1/LPL5YRjKTWMXlId+6+bBwds93N5l2/q5w35qxizpqdqA2v34V5mVw3eRhTz+yNyaBn6eer+N3Fj2GyGHlt57Nk5bVO0BMiCZEPEMFnQK1KTdT3QXLcD8Yxzc6vKlRKwnUNzq/9bPaVEkxGUYVKTEkSV5MkhQIiJX4Zdfq0+OWUzRQZsuiKixxhwyL0NL1y9Ho9ZrMZp9OJxWLBZDJhMpkwGo1HDCsvj3iZVbaG5bXF7AvVUB8PkxTJQ2PwEyrG5WFM80PIKwIQPzBHh84elIRCbXl9epqskxl8Vj/GTRvFmEuHk5Fz4JzE43H8fj9+v7+Zi89kMqVda+1V9tuUZDJJbW0tPp8v3cCvpTLjeDxOZWUl4XAYAIvFQm5ubrtm8LUXVVVV1NfX43K5yM09fCnoaS12LVy4kAEDBuB2u9s8KA3tJUdDQ+PkoSgKmzZtAqBv374n5KGtcexozwENDQ2NtqOJXUdHiCiiegqoVUhvjkF68B2IpAK6hcFA/U9+QvWddwKku9ZZrda2by/6NcJ7N5AE86VIrj8fk+CVVBWW1Ozgi7LV7ApWpaf3c3Vkav4QhmZ2Qye1T5lZNBrF6/USCATSne5kWU67uFpTWiWEYP66Yp78cCH7q70A9O7UgfumT2BYzwOREYqqMm/tTl6fs5r1uw7kRI3s05nrpgxjVJ8uzfO4hOCesQ+yecl2Lr7zXH727G3HtG9CRCD0L0TonyBSjiGMo5Ac9yMZ+h92GVWo7A/Xscm7n02+/WzxlRJSYgghiKlJ4koiXXpokHWYdAYM6EACp2Sij74DnYQDtzBhw4DUIH/p9XqMRmNa6DIYDBiNxrT41fh3S4JibTTArPK1LKnawa4lxYS/qkK30I8UOlAGqTpTy8r+A9MkvUSX0V0ZefZARl04jL6D+hzlmKXy2Rq7bDZeE5Ikpcs1W2pCcCyoqkpdXR319fXpbdjtdrKzsw8Rr4QQeL1eampqUFUVWZbxeDy43e7Tys3VlN27dxOPx8nPz8fhOHyDiNNa7JJlGbPZzOWXX86tt97KWWed1ebB/ZDRXnI0NDROFuFwmJ07d6LX6+nbt++pHo5GA9pzQENDQ6PtaGJX6xChfyMCj4Kch+T6L9LtP4V//5vGNn9qVhblf/4zwfHjgdSLt8fjaXMGkIjOQnjvARSwTENy/gnpKAKVLx5mdsUGvi5fT30ilUVkkHSM7dCbqflD6GJrn/gFVVUJBAJ4vd50NhIccPE4nc4jOo+asr2kmsffW8DK7fsB8Dit3HXJWC4c2SedyxWKxvlk8UbemruG0tpU0wCDXsfU4b25dvJQehS0vF/r5m/il5N+j96g45WtT5HXLeeY91eodYjg8xB+A2hwLZnPR7Lfi6TvcsRlFaGyL1STdn5t9ZWlxa+4miSmJlGFihCgl+WU+NUQep8trHTXZ5Er2XHLFhySCdEg1jQVvhqRJKmZCNYogBmNRnZv2MecNxYy761FVJfUppcx2AwokkANJg/sr0EiOcxKYoydxJk2bHYzZ6i5IEvstATp7sxldHZPzskdiM3QspipKAqBQACfz9fsOtHr9c3KHI/pXDSUIdbW1qZLQC0WC9nZ2VgslkPmP9jNZbVaycnJOS3dXI0kEgl27dqFJEkUFRW1+LN02otdQFpNLCws5NZbb+Wmm25q0aqmcSjaS46GhsbJoq6ujpKSEux2O4WFhad6OBoNaM8BDQ0NjbajiV2tQ4gYonpyyt3l/D2S9RrYtw+mTYOVK1PzAMkBA9j/1FMk8vORJAmn04nH42mTG1xEvkD47iMleF2B5PzjYQWvvcFqvihbw7fV29J5TRkGG2fnDWRK7gBcxra7zJoSi8Xw+Xz4/X4UJbUdSZJwOBy43W7MZnOrnTK1/hDPfbqYjxdvRAgw6nVcP2UYN507HJs5JUSU1/l5e95aPlq0gWBDHpfbZuaKCYO4YvwgPK7WXWe/PvePrP56PWffOIFfvfrTNux5CpEsQQSfguinpM62HqxXIdl+iqTLatU6FKGyJ1jNZl8Jm30lbPGXElHiIARxVSGmJlCFQAJkScak02NGj0s1kaWa6WRwk210kKG34tRZMOkN6HS6wzq66sq8rPzvOlZ+tp6yHZXp6XqjDr1BTzR0oNzUZDEyfOoQRlw6jOBQIytie9gZqKAmFiCaTDBWFCALieVyORGpIWcMMMoGMo02Cu05jPR059z8wbiNh56XWCyWLnNsFKmAdJnm0QRSIQShUIjq6mri8dS1cKTS4e+im6sRr9dLZWUlVquVTp1a7qp52otdJpMJu91ObW1KXW0Mpjv//PO59dZbueCCC05ZJ4PvCtpLjoaGxsmirKyMmpoaPB4P+fn5p3o4Gg1ozwENDQ2NtqOJXa1HhP6DCPwR5Fyk7NlIUoM7ZNYsuOEGqEqVDApJInzppZQ88gg0lJZlZGSQkZHRasdTepuRzxG+XwIqWK5Gcj6CJEkoQmVV3S5mlq5ls78kPX+RPYfz84cw0tMDvdy2rK+mqKpKMBjE5/Ol3TGQEhoaXVzHIuTFEknenLuaV75ckQ6UP2dYT35+2Tjys1LX3+a9Fbw+ezVfr96OoqZerbvmZHDN5KFcMKIPFmPLHQsPx7YVO/npiN8gyxIvrv8bXfq2LCC0BpHYkurcGF+YmiDZkGy3gPVmJPnY8lxT4lcVGxvEr62+UqJqAgQkhEJMSSAa0rYkJGyygUxhwa2acKoGMgw2ss1OPCYHOfYMpCisnbWJRR+sYNvSnentSLKETq8jGT8gNJmsRgZO6svIi4cy/LwhODMcmEymQ0LxY0qcuZtWsLe+ktVqGduTtUSUeHpcTZEAg6wnw2Clq70Dw7OKOC9vMB0srtSxaxCt/H4/wWAwHYQvSRJ2ux2n03lImWMkEqGmpiZ9/el0OrKysloUruLxOBUVFUQaSo2/C26uppSWlhIMBvF4PGRltSyinvZiV25uLnv37uXDDz/klVdeYc6cOaiqmj5pubm53HTTTdxyyy0UFRW1efDfZ7SXHA0NjZNFcXExoVCIjh07kpmZeaqHo9GA9hzQ0NDQaDua2NV6Uu6uKaBWIjkeQrId1OHv0Ufhj3+EBueJMJup//Wvqf7Rj4Cjv6S3uN3IJwjfrwBByHQN34Qu5svydVTFfKn1InOmpzvn5w+mhyOvXZwr8Xg87eJq2jHQbrfjcrmwWq3Htg9CMGfNDp78cCFlDaWI/brkcN8VExhcVICiqnyzfhevz1nNmp2l6eWG9+rEdZOHMqZfN2S57fv1+2l/5duPljNu2ggeeu+XbV5PU0RsCSLwV0huTE2Qs5DsPwXLlUjSsQlyjSRVhV3BqnTZ4zZ/GTE1CQKSIuX8QqTOhaxCB8mGO2ogvqSOqjml1K6oRiQPZG7pDTqSiQPdGS0OM4Mm92Xg2X3oPbo7RvOh49TpdM2ywEwmEz6fD5/PR0ZGBh06dCCpJPm2ZjvzKzezxV9KVcRLWImjtiCA6SUdLqOVLlYPw7IKmZo3hByTk0AggN/vP6TM0el0YrVa0109gaOKxkII6uvrqa2tRVVVdDodHo+nXTqlnixUVaW4uBhVVenSpcsRM+++E2JXWVlZetq+fft4+eWXee2119i3b19qhQ0nZsKECdx2221MmzatzbXf30e0lxwNDY2TgRCCzZs3oygK3bt3P67gWY32RXsOaGhoaLSd9riHNoZSA8csgnzXEOE3EP5HQM5pcHcd9F4WDsN118FHH6UnqQUFVDz5JIEBAwAwGAx4PB4cDkerj1VZ/VvM3PsW3/jyiZIFcjZ2g5nJuf05J28QHtPhQ6yPad8aXDder5dwOJx23RgMhnTgvMFw7CLO5r2V/O39BWkRq4Pbzs8uHcvU4b2JJZJ8smQTb85dTUl1SrzT62TOO6MX104eSq9OHY57vwD2bNrP/wy8DyEEzy5/jF5ntI+RRAgBsS8RgSdA2ZuaqOuCZL8XzOcdNWftaKTEr0o2+UrY5Cthe4P4JRRBfI2X6FeVKAu9EDogaCEDB/QujE4jvab0YspV45h04WjMFlMqMyweJx6PE4vF0n8nEgkOJ2fEYjHC4TAWi4X8/PxmeWCNlWiKorCyfhdzKjay2bef8oiPUDJ6WAEMUgKY02ChkzWLYY4ujLYVYk3KJBIJIpEI0Wg03ZHS4/GQnZ3d4vUXi8WoqKhIi2Y2m42cnJw2Xa+nklAoRElJCXq9nsLCwiPeH9rzvntSxK5GhBB89dVXvPzyy3z66afE4/H04N1uN9deey233norgwYNauPufH/QXnI0NDROBolEgi1btgDQv39/rcT8NEJ7DmhoaGi0He0eemwIEW9wd1UgOX6HZLv+8DNu2QLTp8PmzanlAGXUKPb//e/E3W4glVeUnZ3d4hdoQgg2ePcxs2wta+p3I1Q/qJUUGENMzS1kXOf/xaw//tKsZDKZdu4kEon0dJvNhtvtbnP3vGpvkGc//ZbPl25GCDAb9NxwzhncePYZBCIx3pm/lg8WrscfTmVHOa0mpo0byFUTB9PBfWzlgK3h/258htn/+YYzzh3En2c+2K7rFiIBkfcQwWdBrUlN1PdPdW40jWqnbQi2rS7mo9e+Yul7KwhXBg98KEFTTUl2G3CNzqZgbEcyB3mQ9SknlN6gJ9Plpqsnnz6ZnSiwZjY7t6qqNhPBGoWwSCSCz+dDkiQyMjLSyzSG4h/sBDMYDEiShBCC9d49fFW+gQ3e/ZRH6ggmYyiiiRrXOGYh0RkHA+hAB9lOps5KltVFjisTo9GYdhVaLJb09oUQ1NXVUVtbixACnU5HdnY2TqfzOym6V1VVUV9fj8vlOqk57idV7GpKTU0N//73v3nllVfY3HCzbDxxw4YNY/ny5a3dh+8l2gNaQ0PjZBAIBNi9ezcmk4levXqd6uFoNEF7DmhoaGi0He0eeuyI8JsI/+9B7oCUPedQd1dT3n0Xbr8dvN7UsrJM9KabKPnVr9LmG5vNRnZ2drp6J6YkWFi9lS/L1rI/fKBz3tCMbpyXWUt/HkOSANttSPb72/RS3+gK8fl8zbKTdDodLpcLl8vV5oyjaDzJ67NX8epXK4jEUuLZ+Wf25meXjqU+GOH12av4auV2kmrqCHTKdnPt5KFcNLIvFtOJc+KU76rk5t53oyQVHp/3ewZN6Nfu2xBqCMKvIkIvg0h1xMQ4DsnxSyRDnzats2JPFXPfXMScN75h35bSFuczeMzox2ein5CJfoAToQNFSZIhLGSpJiyKDj0ysiQBEnFZIWGUyHF76JGZT19XRzrZPOgO40ZLJpPs2LGDeDxOVlYWQghisVi6UcHBSJLUTABr/Fuv1yNJElt8pXxVvo519XspCdVhTUp0Uh2YRSr/LSjF2Y8fk6QnX9hxyWYcegsdzC6K3Ln0yemKxWKhtrY27eay2+106NDhO+fmasqePXuIxWLk5+fjcBy/W7O1nDKxqylLly7lpZde4t133yUYDKbCCVu4wH4oaA9oDQ2Nk0F1dTXl5eW4XC66dDlym2mNk4v2HNDQ0NBoO+1xD43FYtx+++0AvPDCC9/7yJWUu+tsUMuRHA8i2W448gKqCr/+NTz5JDTkXwmHA9+f/kTVuecihECSJCSLgRXxEuZUbyKYTL3Am2QDZ+X047z8QeRZMlLLht9C+B9Ordv2P0j2+1oteCmKknZxNXa1g1QZlMvlwm63t9m9LoRg1sptPP3RIirqUzlLAwvz+MX0CXgbRK6V2w+E6Q/tUcB1k4cxbkA3dCfJMf/0XS/x2T9m0Xd0L55c+McT5v4RSi0i9ByE3wYSgATmi5Ds9yDpOx51eX9tgAXvLmbOmwvZ9O22FufL7pjFuGkjGTdtBH1H9yIhFHYGKtJljzsC5WkXlaSCJSmTJcxkCBOKqiIhIUsycVnBJ8eJGyS6uHPo7S6gj7OAQnuHdKOD/fv3Ew6Hyc3NxeVyIYRAUZRmZZCN/1bVQ51bkBJTmwpgiqLg9/tJJBJ44yG2hytZlyhjU6wSfzKS6i4qwIGRPGEjGyt6IadzwFQdWM0WRnfuz8ROA9rU9fR0IZFIsGvXLiRJoqio6KjNLNrzvntaiF2NhEIh3n77bV555RW+/fbbY17++4T2kqOhoXEy2L9/P/X19eTk5JCTk3Oqh6PRBO05oKGhodF2tID6tiHCbyP8D4Gc3eDuajlIOk1dHVx1FcyenZ6kFhWx5am/sMptpDRcjyKp1OiiCJuBcwoGMzGnHzb9oS+xIvQ6IvCH1H9sdyLZ725RuBFCEI1G8Xq9BIPBtBCh0+lwOBy43e7jFig37C7nb+8vYP2ucgByMx385MLRROMJ3py7hr1V9altyhLnDOvFtZOH0LfLySvTaqS2vJ4bu/+UWCTOo5/9LyMuGHZCtyeS+xDBv0P0vw1TDGC9Fsl+B5LcvNlRNBxj6WcrmfPmQpZ/sQZVObxglNutA+MuH8G46aPoNbzoiOJkTEmwPVCeCrz3lrAzUIGCiizArhhwJPVkCDMGSSahpkw0SVng08Xx6eIoOokezjz6uAroojixxSSyMjKP+LuwEIJEInFIHlg8Hk87CJPJJOFwOF022+godLvdmM3mtBhWGfMxs2wtq+p2sSdUTSAWwSWM5AobbkxIInXNJyWVGiL49HGsZiu93QVMyOnLWE9PDLrvhtPL6/VSWVmJxWKhc+fOR53/OxdQr3HsaC85GhoaJ4MdO3YQiUTo0qULLpfrVA9Hownac0BDQ0Oj7WhiV9tIubvOBbUUyfFbJNtNrV945UrElVci7d6dWhewfkQfPvztTyhwd6K7M4eOdg+ezFTnxpbEDBF6DRH4EwCS/WdI9p81+1xRFAKBAF6vl1gslp5uNptxu904HI7jziCtqAvwzCeLmLl8KwAWk4ErJ6RypT/+diO+UEOJmcXE5WP7c/XEIeRmnrzyrMPxz1+/zrt//YTCQV34x6q/nJQcVpHYmOrcGF+SmiDZkWw/RjFdz7r5xcx5YyELP1hKNBQ77PIFPfIYN20k46ePpPuQbm12pEWVBNv9ZWzylbDZV0JxoBIhVByqAZdixJbUY5R06OWU+BVDwa9P4tPFMaoyXZMObBYrnoIc+jgL6OnMP6wYe9hj0FA6W1lZme7yqSgKRqMRs9l82PPQmAdmMBiIRCKEQiF8SpRlkT0UJ+qIRSJYEzIG9cCyYSlBpRSigjAJScWiM+IxOejlzGd8h95MyOmLWXf8WXftTWlpKcFgEI/HQ1ZW1lHn18Su7zEzZsxgxowZKIrC9u3btZccDQ2NE4YQgo0bNyKEoFevXt/78ozvGprYpaGhodF2NLGr7YjwOwj/747J3eWLh5ldsYGvy9cz+MPZ3PT0x5ijqXJCodcTv/tuyu+8k1iD4+VonRtF6BVE4DGAVImc/U6i0Sg+nw+/3592ccmyjMPhSAd8Hy+RWIJ/fbWC/3y9imgiiSTB+AFFGA065q8rJpFMuYQKspxcM2koF4/uh818eggM/toA1xfdRdgf4YG37mHiVWNO2rZF7FtU/1/ZuWY3cz7IYN5HmXhrDl+u1rVfJ8ZePoLx00fStX/nE1JyGVXibPOXs9G7n82+/ewJVGNVdbgVI07FCEJgkHXoJB1xNYFdMRDVKawx1SJkkJHoYsumjytV9tjLmY/LeGjDBUVRqK+vp76+Pn1NOhwOPB4Per3+EBdYLBYj2VDym0wmCQaD6fgmk8mE2+3GYrGkO0L642GWlW2lpK4KbyxERImjoFBHlAopTA1hGkxgSIBZZyTLaKe7M48xnl5Mye2PzdAKd+YJQlVViouLUVWVLl26YDYffSyntdj1yCOPYLfbue+++9o8KA3tJUdDQ+PEE41G2b59O7Is069fv+9kd5fvM9pzQENDQ6PtaGJX2xEijqg5D5QSJMdvkGw3tzjv3lANM8vWsKhqayqHCHAbrJyT3Y8L/9/LmF59LZXtBYjMTMLPPEPlyJHpMi+z2YzH4znssRWhl1B8jxOM5uJL3kpUnJn+zGQy4XK5cDqdR80Aag2qKvhixRae+WgR1b5UAHthXhZWk4GNeyrS8w0qzOO6ycOYOLjopOVxHQuv//F9Xnv4HQp65PHypr+j0x//sTka5bsqmfPGQr7693zKiysPO0/hoC6MnzaKsdNG0KXP0bO92ptwMsZWfxlbfCVs9O6nzu/FoRhwqUZkVcKjmDCgo94Yp1IXoUoKEZHVlILUQEdLZkr8cnWklyMPXUShtrY2LVZZrVY8Hs9RRddEIkFlZSV1dXUkk0mEEJjN5hZzuWRZRq/XpztKRuIx9kdrKYnUU5Xws1fxsl/4CRBvNl5I/dcoG8g02Smy5zAyqwfn5Q/CeRjh7kQQCoUoKSlBr9dTWFjYqneN01rs0mgftJccDQ2NE43X62Xfvn1YrVa6d+9+qoejcRDac0Dju8rEiRNZsGABDz/8ML///e9P9XC+82jHs21oYtfxIcLvIvwPguxpcHcdeIFXhMrqut18UbqGzf4DweyF9g6cnz+UUZ4e6fBvyspg+nRYsuTAugcMwPvKK9S63WmhwGaz4fF40s6PeDyO1+vFV/01SnQpALJ5NPaMCWn3S3t9Sbe2uJTH31vA5r0pocZtM2M06KnyBlPblSQmD+3BtZOGMrAwr122eaIIByLcUHQXvpoAv/jnHUy9dfIJ2Y632seCd5fw5Stz2Llmz2Hn6TEwxrgLaxl7gY+Cnn2QHL9CMg4/IeM5VkLJGNv8pWys38+u2nJs3iRuxUhAThCRFYQQyHqZuAFqpAgVajAlbgpwqQbyklYyZCvZJgfZdjc987vSOTP3qKWjkUiEioqKdBMFp9NJhw4dkGU5HYp/cB7YwaH4jfM1CsZ6vR5VgjLVz8ZEJetjZVTEfUSUBIJDJRwJMMh6Mow2utk6MDyriPPzh5Blbv8y3Orqaurq6nC5XOTmti7L7lSIXd/d+H8NDQ0NjcPS2NK4NZZiDQ0NDQ0NjR8Qlssg9DwoJRB+E2y3EkrGmF+5iS/L1lEV8wGgQ+ZMT3fOzx9MD0feoQJUfj4sXgzz58M110B5OdKGDWSceSau6dOpefxxvNEooVCIUCiEwWBAluUDWVz6MzBaFZz6N3Ba52FwRZGsLTvNjoWyWh9PfbSIr1dtB8Cgk9HrdHgb8rhsZiOXjenP1WcNJj/ru5FranVY+NFvLuf5+17jP394j8nXjsPYTmWWkVCUJZ+s4L//nM2Gb7ZwOC9MrzO7M/HK0Yy9fAQ5na2I0MsQfgUS6xB11yJMZ6W6bBp6tsuY2opNb2JoZiFDMwuhCPZXlrGzbC+VSpC98Tpi4QiSIjAokIcZj2RA0umwYwAVomocn4iwLV5HnW87+JeTYbDRx1VAb2cBfVwFdLRmIksp8UtVVWpqavB6vQgh0Ov15OTkpEUdSIlWer2+mbhzcCh+owDW6PRKJBJp4csjjEykE5NMXbBl2rDax9bZcgABAABJREFU7WxRq1jq28WOUAVVUT8RJY6KIK4mqYz6qIz6WFq7g2e3f4le1uM2WOls8zA8s5Cp+UPIs2Yc13EOhVIuSav15DjJ2oomdmloaGh8z9DELg0NDQ0NDY3DIUkGsN2J8P+Wsrr/8FV5J+ZX7SCqptwkNp2JybkDODd/EB5TKxwhEyemXF5/+Qs89BDEYsjvvUeHTz/F/bvfsXv69Ga5RxaLBY/HQ0ZGBjbb9YigF0LPIgJ/BnRIthvavG+haJxXZ63g9dmriDdkcMmSREJRSSgquZkOrjlrCJeM6Y/D8t3LM73oJ+fwwd8/p3p/LZ+/8DWX331Bm9elJBVWz17Pp/+Yxcov15JMKM1nkKDPiB5M+tE4xlx2JtkdmweQS467EdYfIYLPQeQdiM1DxOYjLJch2X+OpMtv89jaE7fVQb41k0JzPld36UIgHmFD1W721JRR561HiiqYEim3oiKphHQCr0XBYrLiEUZqY0HqEyEW12xncU1KPLXrzfR25lNkzsYTN5KNFVmScblcZGdnt6r8VpKkdH5XU2FMCNHM/RWJRPD7/YRCIZLJJIFAgEAggEeWudzYC1PmQCwWC3q9ns3xSpb4i9keqqAq5ieUjKEiSKhJqmN+qmN+VtXt4vmds9FLOlwGC52sWQzNLGRq/mC62LNbdUwbhThJkk57V2ybxC5FUairqyM7+9ADEovFmDlzJjt37sThcDBhwgR69+593APV0NDQ0GgdmtiloaGhoaHRMlarlaqqqvS/f0gIIdgQG8oXpeNYGzAj5G9BzqDAksnU/MGM79AHk85w7Cv+1a/g5z9H3HgjvPceUiyG8cEHKXz6aUoee4y6gQORZRmz2Zx+kbdarUj2nyFQIPQPROBRQEayXXdMm1ZUlc+WbmbGx4uoDUSafaYKQf+uuVw3ZSiTBvdArzv98rhai9Fs5LrfTefvt7/AW//vQ6beOgmLvfXh/UIIti7fwcfPzGTxJysO6aQoSdB7RE/Ovn48Yy47k8zcI7t/JF0HJNfvEbYbEYG/Q+xLiHyIiHyOsF6PZL8dSXa3ZVfbjcbfhWOxGKqq4jBaODO3J0WGLLwWL8FYhNqQD18yTFUyiC4p4wnLKBEVn07FLukxWEzYDea0aBRMRFlatZ3FyhYATLKBPu6ODLR2pU9QociRg0Fum6dIkiRMJtMhzaVUVSUQCFBfX4/P5yMejxOPx4k2uCdNJhNdjHa62YaALbUeg8HAzkQNSwK72BauoDLmJ6TEUIRKUijUxoPUxoOs9e7llV3z0EsyDoOFjpZMBmV05dy8gfRyFRwyxkZXl9lsPqZcvVNx3z2msxCJRLjvvvv497//TSQSSQfW/+53v0OSJJYtW8ZVV13F/v37my137bXX8tJLL2E0nh4dLTQ0NDS+ryiKks4L0MQuDQ0NDQ2NQ5Ek6bBf2n9XUYTKNn8Z9fEQGUYbvZz56KTmok5MSbCoeiszy9ayP1wLahegksGW3UztPISBDh2SLgKHySYSQhCJREgmk+j1+sPmaiWTSXyhEL4//xlx660U/PznmLZtw1BVRddbbqHryJGE//MfagwGotEo1dXVeKuqyPvoI0wlJdCpN1yzGRH4AwIdUekSEok4erEZnVzD+0sUSuqddMp2c8WEQRgbQr9XbS/hr+/NZ3tJdbPxSBKcNag7108ZxsDCw5Rhfkc556aJvPPXTyjbWcEfrnwCo9mAxW5myvUTGDKp/2HFh/3by/jgic9Z8N5igvWhZp9JskTvM7tz3s2TGH3pcNzZx17WKem7IWU8jYivQwT+ConlEH4ZEXkPbLeD7fpmnT+FUCC+EtRqkLPBeAaS1D6B+wdfq42CTOM1l0wmCYVC6VLN3Kxs+vfqg9FoJBwOU+mtZU9NGVVhL5URH4FEFDWh4tdFCOriJElil4xYZAtJScVPFEWGzaEyNofKQIBbmCi0dqCbqwO9sjrRy5WPWWds1c8ptPDzLKecYy6XCyEEoVAIv99PIBAgkUigKArRaBSdToder0eWZeLxOJ1x0tk+GBrMY5IksSday4ZwKdujVexK1BFUow0CmEp9PER9PMQG335e37MQnSRj15vJt2Qw0NWZszJ64wil3F3/n72zjq+rvv//88h1i0uTStpCoYK1xZ3izmAw2JDhMH7IgOGd4GNs8IUhQ4cMH+6lQIeVAoVSgUrSpk3S2HU7+vvj5p4mjTRJU4PzfDxum5zzsXOu5J7Xeb9f7+Li4l7Pe0+fERlD5aXIXFam2qmOFHHq6H3wSBtWHxqQ2HXsscfy3nvvWS+OeDzOn/70JxRF4dJLL+WYY45h9erulRqeeuopdF3nqaeeGppV29jY2Nj0SD6qK+8PYGNjY7OxePzxxznrrLPQNI1rrrmGm266ab3Gq6ur4x//+Afvvfcey5cvxzAMRowYwcEHH8zvf/97RowY0aX9+eefz/33308oFGLu3LmMGjWq25j33XcfF1xwAZIk8cEHH7D33ntbc9XU1ABQW1uLqqrcdNNNvP/++7S0tFBeXs5hhx3GDTfcwLBhQ5+eY5omDz30EA899BALF+Y8cyZOnMiFF17Ir3/dd5TLSy+9xCOPPMKXX35JOBymsLCQqVOncuaZZ3Lsscf22Of000/n8ccf57TTTuOxxx7jscce44EHHmDBggWIosjkyZO54YYbrPOjaRr33Xcfjz32GIsXL0YQBPbYYw9uvPFGdtppp17XFo1Gueuuu3j55ZdZsmQJqqpSXV3NtGnTuOKKKxg9evTgT9p60tjYyAMPPMC5555LZeXmbU7eF7Nbl/DQ0g+oT7aimQayIDLcV8JZY/Zn55KxtGXjvNv4He83zSOh5b4juEQH+1bswUGumxjmWAnm5xAjZ3ktVkDwWgT3wUDueq+pqYlEIoGu60iShN/vp6KiAr/fTzqdJhKJkEgkrGtEafRo4rNmIX38MY5zzkFob4fPP8c3bhzeM84gfvvt6FddRcHDDyN0Muk2rxVQzhzG8vM+JqFmMbRWfmxyM7vWx4LVSVoTdQD8/cVZHL37BFqiSf73fW2X8+FxOjhmjwmctN+ODC8t2NCnf6MjO2SGjxtGw5Im5rw919o+48lZePxurnjsd+x13C60N4V57o5Xmfmf/9HeGOkyhiAKjJsyhsPOmcaex+5CoNDPUCA4t4eiJ0D5GDN+B2g/YCb+Cql/g/9i8BwD2RmYsZvAWFMJc+3X3GDp6bXqcDhIJBKkUimam5uRJAmn00lRURHDhw/vEmHk8/kY7fNREihg5cqVRIkSz6aI6mniqESUNFE9TVTMEhHTpBwGoiRR4Q4SdHiRsyauhIZHFZFSCo1t9fxQt5RVzjS4ZZoyERJqBgRwCFKX92medb2fISdY+f1+/H4/uq4Ti8WIxWLWNQBgRVE6nU6r2mM+BdKlKOxkFDNFLMXpz6VRtoppPk/VsSizmkYlSkLLoJkGumkQVVM4FJOVYXirtoVKfIBAS+M3yMV+dioZQ2XKSTqd7vYZEQjkUqFvmvcSr636ikx7nJY3v6H0sB15dOmHHFk1mWsnHbdez3tf9Lsa40svvcTxxx+PIAicdNJJ7LrrrsyaNYsXXngBt9vNlVdeyZ///GcuuugiLr30Uqqqqli2bBk333wzTzzxBIIgMGvWLHbfffcNdjBbAnYVLhsbmw1JW1sbq1atwu/3b9KLCJvesf8O2Gyp9FU98NZbb+Xqq69GFEXuvvtuLrzwwvWa66mnnuLMM8+0zKxdLheiKJJO51KUAoEAL7zwAgcddJDVJ51OM3XqVObPn89uu+3Gxx9/3EX0//7775k6dSqZTIYbbriBP/3pT9a+zmLXM888w9lnn008HrcuJvLzFhUV8d577/Up8PSX/Pm87rrrmDdvHq+88gqyLOP1eonFYla7tdeaR1EUTj31VJ599lkgd3GT/2zJ+yP96le/4vHHH8fh6JqW1lnsgpxQmb8bH4/HgdxNk//+978ceOCBHHXUUbz77rs4nU4cDkcXc+KPP/6YyZMnd1vf/PnzOeSQQ1i5MlfVz+1243A4rPFdLhdPPfUUv/jFLwZ03obiMzSbzfKb3/yG559/ns8++4xdd911UONsama3LuEv379IRlfxyS4cooxqaCS1LLIgsn3hKFYkW9HJvR7KXEEOHrYD+5VPwKt9iBm5qIdRc9EYQsHdJNTdqa2tRVEU3G43siyjaVqX92Hn6A2Px0NBQQF+v39N9TrDgOuvz3l6aVpumyxjdvzcOfYjf1Ha9Ks9abtkF75aXsYPjZWE3BJJ1eDzugitCbXHc1Ea8nHy/jtx3J4TCXh/upHtD175BM/f8WqfbUKlQaItsS7bBFFgqx1rOPL8g9jr+N3wBTdsGplp6pB5FTN+FxgNuY1iRVeRa83qcv8W3D1owSsej3d7raZSKdrb21FV1RK+nE4nkiTh9XqpqamxxJjexpEkiWQySTQazYm5DomMwyBGlmYlziojRkRSEEwYp4TwmDI4JGRJRjDBVDUiepqPWUEracSO94ssSJiAV3LyhwlHs3/FxD7fz27JwfUTf9FFGFubTCZjCV/5aqiA5enV0tJCNpu1/h7kvcEEQaCgoKBbFt5qJcbnqTpWptqpzLiQDYGMqVJILnU2hUpKUJktNtEmpHELDookHyOdhWwnlbO9dzhbjx3L3XXv8cqqORiKxrI7XiM8axHb3nkq/m1zKZJHV00ZsODV378D/U5afvLJJxEEgYsuuoinnnqKiy66iOeee47TTz+dTCbDzTffzMknn8xdd93FqFGjcDgcjBs3jscff5xjjjkGgCeeeGJAB2FjY2NjMzBsvy4bG5uNiWmaXHzxxVx99dW4XC6effbZ9Ra63nvvPU499VR0XefKK6+ktraWdDpNMplk0aJFnHDCCcTjcU444QRWrFhh9fN4PDzzzDN4PB4+++wzpk+fbu1Lp9OcdNJJZDIZ9thjD2644YZe5z/33HOpqanhiy++IB6Pk0wmeeeddxgxYgTt7e0ce+yxlmAzFNx77718+OGHPPbYY8RiMaLRKPX19Rx55JEA3HjjjSxevLhbv2uuuYZnn30WQRC4/vrraWtro729ndbWVq655hoA/vOf/3D99df3Ovcrr7zCc889xwMPPGBdJC1atIjJkyejaRoXXXQRl19+OXPmzOG5554jkUgQj8eZM2cOY8aMIZVKcfHFF3cbNx6Pc+SRR7Jy5Uqqqqp44403rLSbuXPnsuuuu5LNZjnllFP49ttvh+hM9h9N03j++ecBulwUbknopsFDSz8go6sUOn24JAdix3bV0AgrST5t+QHN1BkfrOb32xzBP6aczhFVO+GV5Fx0TY/kJCcjejNNTY0oioLf78fhcKDrulUhLpFIEA6HrQvlkSNHMmLECILB4BqhC3JpkTfdBG1tcOihuW2ahkBXoYtOv1c8+wlmVmHeyjKymkFzQsXnkNi2zN+tz6jyQm4641Bev+lMTjtoyk9a6FIUlRfufG2d7fJClyAKjNlhFJc+eC6vRB7n3i9v45DfHrDBhS4AQZAQPMcilL6DELgKCPUidEH+NWfGbs6JZAPENE2ampq6vFY1TSMajVrvb8MwcDgcFBcXU1BQgKIoNDU1dak8ufY4ecGss4BWVljM1DET2bViGw6t3IFTKnblBP/2HGiMoszwkiYnbrUocZrVOK1mGtkQ2MYowiM6cYgygiCgY6CbOlE1xR+/e56Lv3yUG79/kbiaJih7cu9nQcAlOSh0+sjoKg8v/QDdNHo7DbjdbsrKyhg9ejTDhg3D7/cjCAKpVIrly5cTDocRRRGHw4HX66WgoICysjJLDKuoqKCoqMg6h+XOIEeFJvEr93bs6h7J7gVj2cVXQ5kcQJZkEqKGDyfjjEJME9KmyiotwqepWu6Pf84Fq5/nsE9u55VVc3Ln1zAIz1pk/ZzntVVfkdaVAT/v/aHfYtdXX30FwCWXXNJle/4Lja7rXH311T32veqqqzBNk88++2yQy7SxsbGx6Q95scvj6b9hqY2Njc1gUBSFk046ibvvvptQKMTbb7/N8ccfv15jGobBhRdeiGEY3Hvvvdx2222MGjUKQRAQBIFx48bx3HPPcdRRRxGLxbjzzju79J84caK17dZbb2XmzJkAXHrppcyfP5+CggKefvrpPk11ZVnmvffeY+eddwZyKSMHHXQQb7/9Nk6nkxUrVnD//fev13F2JhwO89///pfTTjvN+uyurq7m+eefZ9iwYRiGwXPPPdelz6pVq7jrrruA3PfsP//5zxQUFABQWFjITTfdxGWXXQbAnXfeSWNjY49zRyIR/vWvf3HOOedYc48bN86KFqurq+Oee+7hlVde4YQTTsDhcCAIApMnT+bBBx8E4JNPPrGit/L885//pLa2FofDwdtvv81hhx1mCSDbb7897777LqNGjSKbzXLttdf2eX6y2awlxOUfg6WxsZGvv/6auXPnWtvmzp3L119/zddff93redoc+SHWQH2yFZ/sQhAEVEOjMROhXUmgmjqiIGAC54w9gOnbHc/OJWPX+AMpc/oQHgBM0pkMiehy3G43hmEQjUaJRqNWtKXb7UYURSorKykvL1/3TbZgEN58Ey6/vM9mAiAYJuZjqwm41kQkRjMapQEnIU9Xi4bj9pzEoTtvg2MARtlbKq/98x1Mo19JWRx78WG8Fn+C+7/+K4edNW1ARvZDiSC4EHy/hYLb1tHSBKMx99ocIOl0mkQigdvttioWhsNhVFVFFEWcTmeXCERBEHC73SQSCStKsfM4LpeLTCZDJBKxXu8ej4fi4mJ0XScQCFBTU8OIESMYVlLOCF8JZZKfGn8ZU3wj2ME5jDGuYnyyCw2dsJmh2PTgMUV008AlOih0+Ag4PDhFGdXUWZxooiUbRzE0mrIRGtNhMppirdcnu1iRbOWHWMM6z4coigQCAaqqqhg9ejTBYNDy0lIUhVgsRjgcRtd161xkMhkcDgelpaVWv7Fjx1JWVoYoipYHl2wKFMlexvsqOTAwju3kCg6QRvNL50S2lUopEj04OvzXTCCLjtKeILmkidTSNXZXqWWrSS5pIrmkiUx7nH8v+2jAz3t/6LfY1dzcjNPp7OZ/sNVWWwEgSRLbbrttj30nT56MLMtd7r7Z2NjY9BfdNPiqbRnvNHzLV23L+ryrsTn03VRzzmlbyodti1iUXY3DZRcEsbGx2XDEYjEOOeQQnnvuOSorK/n444/Zd99913vcjz/+mMWLF1NSUsJZZ53Va7tTTz0VgHfeeafbvvPOO4/jjjsOwzD49a9/zYMPPsgDDzwAwL/+9a9uXl899S8rK+u2fdttt7XEvGeeeabfx7Qu9thjD/bbb79u210uFwcfnEvp+e6777rse/HFF9E0DbfbzVVXXdXjuNdddx0ulwtVVXnhhRd6bDNixAhOPvnkbtvHjBnD2LG5dJm99tqLPffcs1ubffbZx6oYtvb68mLZ8ccfz8SJE7v1DQQCXHnllQC89dZbRKPRHtcHcMstt1jGzKFQiOHDh/fadl088MADTJ48ucvx/O53v2Py5MlMnjzZep1sCYSVJJppWFXfFEPr9p1BNTQeWfohty94heeWf8bstiU0Z6KYevM6x9d0N7qeS3GKxWJommZViguFQhQUFCDLMv10xFlDJ1+hvnA3tBJ0rxG2FN1AFgWcctfL11Wtvb92fmo0LO3ujd0b2+y8FS6Pa90NNxKCmepfQ6Nl3W3WIl+VMJFIEIvFUBQF0zQxTRNBEKzXaOfXqiRJGIaB1pFOmxd082OkUikMw0CSJILBID6fD1mWrT6CIFhpuz6fz5rLIcoUOLyM8ZRx6LAd2KmoBkMwcQkybhyYmGQNlZiWxie7KfcU4JNd7FK8FQ5BwinKCAjopkFcW/NecYiyZSDfX0zTRFEUNE2z1med5k7Hvva5yPfLi4bpdBpVVdE0DUmSrEf+HDsEiZ0d1Zzr24Ub/AdwX+UJPDDiJM4o3IUCwU3Lm9+w4KJHWXT5k9b8K/75HgsuepQFFz1Ky5vfsDLVPuDnvT/02704b+a2NvkcyZKSkq4hq2v1zedU2tjY2AyEmU3f87eFr9OcXXMnt8wV5PfbHsF+Fd2/QG/qvpvLnP/+4qt+zWljY2MzUBobG9lnn32YO3cuW2+9Ne+8806PZvCD4ZNPPgFyxuZ9GcHnq84uX768x/0PPfQQc+bMYcWKFZx77rkAnHXWWf2KPNt///373Pf000/z3XffoapqNy+swbDLLrv0ui9/Dtrbu14IzJmTi36YOnVqr34lhYWFTJkyhU8++cRqvzZTpkzptUpdeXk5S5YsYerUqT3ulySJkpISVq1aRTgctrYrimKJX9OmTev12A488EAgd9H19ddf9yj4AVx99dVWlBrkhNbBCl7nnnsuRx11FOl02hK87rnnHnbbbTeALcqovtDpQxZEVEPDJTnwSW5kl4RiaCiGRlZXMTFI6Vm+aq/lq/Y1Ru5eUWWkNIVR7jij3DFGueIMcyWRhTVigCxlQHASiUQQBMG66M9f7+WjZgZcDGfMmH41y1SVIItrXptOSUQzTBStq6BXPYjqgVsqw8aU97ttcWXhBlzJwDHF4nU3glx1xn6SzWaJRCK0tbWhKAqSJFlRwEAXoSv/+s3v03UdURTRNI3Vq1cTj8fJZDIYhoEgCDidTlwuV5eosHwklGEYtLa2kkgkrLTe/FwOhwOXy2XdCChw+vAIuYjYArcfBAdt2TiaqdOSiRJ05CKhJhfX8Hnrj7ik3N+UlmwMrVNKp2poyIJIodPX+znuEKlSqZT1MAwDVVUtYUqWZRwOh+Vflj8ugFQqZRWbyGazVoV3RVEQRRFJkqw0yPx5zj9cLpflcZb/u7iXbwzNSozmw3akYNetMLKqJXiNuOBA/NtWA+Ao8lPtLer38z4Q+v3pVFpayooVKwb9hz2bzRIK/Xw+jGxsbNafmU3f84e5T3fb3pyN8Ye5T3PbDif3KuZsir5b2pw2NjY2gyGfvuZ2u3n//ffXK9JmbRoacikaqqr2WOF7bTqnoHSmsLCQe++91/K9Gj16tJX2ty6qqqrWuU/TNNrb2ykv7//FZ2+sbZDcmbyQoKpdTbmbm5u7rKc3qquru7QfzNwDXV97e7t18dTX+vJr62t9QJcLx/WlsrKSyspKy2AfYIcddhiSggMbm3HBYQz3lVCbaM5Fg3T4+7gkB6ZpElaSjPKVcsk2h1GfaqM20czyZAsrUm2kdJmFSikL00Xk/ZIcgsFwV4JRrjgj3XEqZT8p3YuuKHg8ni5Cl2maZDIZQqHQwG0TLrggl8rYi1dariKkQOyEqQhNIIkCumEScss0RLNE05rVVhQETthn+0GcvS2TIy84mPsve3yd7Uqqi5m41zYbYUX9wzTaIfHQOloJOQN755S+xzJNEokEkUiEVCoXLSYIArIsk81mrc8KSZKsyMN8FFY+1TZfwVCWZZqbmy0xKx+plc1muxRfME3T8gBzOBxd/jYJgkAoFLLeE2sXbSh2+imVfNQZERKCikOUKHOHaMvGyegKbdkENf4yDqrcnldXfkVtopmQI/ee0k3DEuuSWpbR/jLGBbveBNI0zRK2ksmkFZ2VR5ZlAoEApmmSTqetmyN5371sNksqlUIURStls3PffBqzpml4PB4cDocV2SWKovVZv7ZXX/58HF+6E28lF+Es8qNn1vhyeUeX4xtbAYCIwKmj9+nzeR8s/Ra7qqurWbFiBfX19d0qfP3nP//p84MuHxI4lF+GbGxsftropsHfFr7eZ5s7FrzGREfFGg+KTn3/uqDvSjVD3XdDz/nX+a+xrViKJIjW3RndNLh9ft/97lz0BnuXj+82p42Njc1gOeKII5g1axbRaJQzzjiDV199tUv59vUh/8V5l1124fPPP1+vsf71r39ZP69atYolS5aw3XbbrdeYNjabC5IgctaY/fnL9y8SVpI9Vm87e+wBTCgYzoSCNddgmqGzMtVGXfg9atufZXkmQF02QNqQWJYJsiwTxIxIqLoXk1kU4KEyE2S4UESVs5By0Y+smrhcLioqKnqNDOwVpxMuuwz++tduu6xqjCcdgOCSKAsmaEs6ccsiSUVnYXOCzkmTv562E86BRpZtoRiGwSW79+1vl+eCf5zRpy/hxsRUvsSMXAbGanLSg0bOma3zM9kRiRW8BkHoed2qqlq+cXlBJx9pZZomgUAAXddRVRWPx2M9wuEwpmlaPlzpdJpMJoMkSQQCAev/YDCIx+MhkUhQW1tLPB63ijJkMhkURbEq1oqiiNfrxe/34/f7kSSJgoICamtrLe8wSZKsvmMKhvG/xCrC6pr3aUD2oBgaJgZJLcvbDXM5c/R+3Dj/JaJqCkwwMUnpClldxS05OHPM/ggmJFNJkskkqVSqm0CV99fyer2WPqOqqnX+Vq1alXteOq4lDMOworVkWcblcuHz+fD5fLjdbpxOJ6qqsmLFChRFsapZ6rpOKpWyboYkk8lux+1yuRhRNYK9U9vwYfPCXl8jR1ZNxiNtGPuVfn867LTTTnz66ad8+umn3cSuE088sc++eWP6CRMmDGKJNjY2P0fmttd1ScvriRYlzsxl37CNq+ud9UXZ1bQqiY3ad0PP2arG+Xj5d93mbFP77rc6E2Vuex2Ti0f32c7Gxsamv0yePJnp06dz0EEHMWPGDA4//HBef/11fL7e0yv6S0VF7k5vb+mJ/eWee+7h1VdfRZIkxo0bx4IFCzjppJOYM2fOOoW5VatWMW7cuF73Qe6Od1HRhkm76A95T7G1jeHXJr+/Jw+yDUVRUZF1wdPX+jrv25jrW5v8a25LZOeSsVw/8Rc8tPQD6pOtJLUssiAy2l/GmWP2Z+eSsd36yKLEKH8Zo/ynsE9pCWbsJgy9iRbVQ102wJLUKBZGhrHKMIibUZIOiUVaKwtizeQECoECh5exciVbtcUYlS1jlK+UMncQsb831m6/HQDzzjsROkd4iaBccAKJ/3cTZuMPlAZaMcwUny9zsGB1ktZELoJQFAR+PW0nLjlu7/U8g1sGhmFw3o5XUDsv538tOyQ0Te+qFwGegJsrHv0dex3Xe2r0xsI0DUg+gJm4G9BBqkEouAv05blKoJ0LJIgVOaHLffBaY+SikfKpddbN3g6RSxAEK5rI4/FQVFRkiUD5NNuSkhKy2SyJRMJKXXS5XJSUlFBWVmaJVfn5RFEkGAyyevVqotFol8iwsrIySkpK8Pl83cTEvGl9U1OTFTEliiKhUIhxFeMIZiu6vU8nhKoZ7i1hXnQFT9X9j4Mrt+faCcfyyLIPWRBdiW4YpFWFCb5KflmxM5VpF0uWLOnmk+d0Oi2xShRFFEUhHA7T0NCApmmW2JXvl7+pJEkSfr+fsrIyqypjPhV0bSRJ6vHY8p+fve3z+LwYgFd0EmdNZJej0IeIwJFVk7l20nEDf4H1k36LXbvssguPPPIIX3/9Nb/+9a8HNMlTTz0FMCTGpTY2Nj8PWrP9K+uuuIRufiVKbN3Gq0Pdd2PMqblFCgtyHgyCIKBH2vrVr7/n0sbGxqa/TJkyhRkzZjBt2jQ+/PBDDj30UN588038fv96jbvHHnsAuS/Oc+bMYcqUvlNaemLevHlcccUVANxwww2cdtpp7LDDDixcuJBLL710nSbkM2fO7NW3K1/dcbvtthsSv67BMmXKFJ544gnmzJlDNBrt0SokEol08fbaWDidTrbbbju++eYbZsyYwZlnntlju/fffx/IRSJs7DRCj8dDbW3Ow2pdBQs2d3YuGcvk4tH8EGsgrCQpdPoYFxzWr4huwX0wuKYhKXOoMFooUIooaS5hZ2cUt/4E/uBH1OujqRMvZGk8RV2yhdXZGBnB4PvEKr5PrLLG8khORvpKGOUrY5S/lFG+UoZ7i5HFniN1zJsvwLx0GebtHyD8I5yL7Zn1Fq7dD2GsaeJ0OolGI2w1NsIx06Ls/ocIAEftOp5rTjngZxXRddbEy6hflDvXvgIv/15yD26/m1fueYvv/7cIj9/NtN/sw477T9wsIrpMvQ0zegUo/8ttcB+NEPwjgugDxzbgmtZREbQl59HlnNIloiufZti5+mdeoMn7TkHuu7Df7ycUCuH1eq0or3g8TiQSIZ1OW1FdXq/XErJKS0utdEfDMEgkEtYjP09BQQG6ruN2uwkEApaI3xeBQAC/3086nbaqH+arGO4cCPT6Pn1j1dc8Ufsx7zR+S3s2wV+3O5n75r9FY6SVqf5RTCmsQVAFkkrSEvryaYSCIKAoiuWxlRe28qb0ea8tt9ttRW05nU7cbjdut9ta37ro69iAXve9sOJz6lNtlHiCFDm8yP/+fwiCwNHb780l44/YYBFdefr9KXHyySf3WK1lXei6zjbbbMP06dM56qijBtzfxsbm50mJq3ePkM5sWzWaUcWjumxrazOg4YON2ndjzDluWA3Di9ekImztUaDvm/pA/8+ljY2NzUDYcccd+eCDD5g2bRqzZs3ikEMO4a233urT42ld7LfffowdO5YlS5Zw6aWXMmPGjB4LJOVpb2/vEmGVTqc56aSTyGQy7Lnnnlx77bVIksSDDz7IL3/5Sx588EEOOuggfvGLX/Q65v3338/FF19MSUlJl+0//PCDVdVwXVkNG5pf/OIX/P73vyeTyXDbbbdx8803d2tz8803k81mcTgcfR7vhuCkk07im2++4YUXXuCaa67pVpExkUhwe0d0z2GHHbbRfX1FURyyogqbA5IgMj5Uve6GPSAIErh2IZ1Os6plFYah4/GVM6zicsTo9xTq89lOuhWh+gkEqZKMrrIi2UJdsoW6RAu1yWbqk22kdYVFsQYWxRq6rKvaW5QTwHyljPKXMsJbjE95ETN+OwgZuKoGHkxBKovw+H9h90MsESOTySC7x+EOViBLd6HpBtuMKP/ZCF2apvHbbS+hsaMKY6DIzxNL78EXykXRnnDZUZxw2eZ1fW0qszvSFpsBN0JwOniO6yKo5F9za5M3nI/FYhiGYXll5aO48mKTw+GwqrPmhS/DMIjH41Ylxc7G9J3TFPMG8/F4nHg8TjKZxDDWFD2QZdlKT8wLaANBEIReo4d7e58eUrE9Qd3Bq8u+IN7Yyn9a3qXGEUAzkuhZlWQiiSiKVrph5yIR+UfeWD9fVNDj8eB0Oq3j8Hq9lrH8YOnr2HratyLZykv1swEY5S2lPt3GiFEjEQWRE2v22OBCFwxA7BoskiRx7bX9yy+2sbGxybND0SjKXME+UxnL3SF2KBq1WfTd0ua0sbGxGQq23357PvjgAw444AA++eQTDj74YN5+++1eKwSuC1mWuf/++znkkEP43//+x957781NN93E3nvvbUVSLVu2jHfffZeHH36Yo48+muuuu87qf+mll7JgwQIKCgp46qmnrIujE044gTPPPJOHH36Ys88+m5133rlXL1lVVTnwwAN58MEHmTp1KqZpMmPGDM466yyy2SzDhw/nvPPOG9TxDRVVVVVcfPHF/O1vf+PWW2/F4XBw6aWXUlBQQCQS4W9/+xt/7fBEuuyyyzZ6lcHzzz+f+++/n9raWg499FAefPBBDj74YERRZN68eZx33nnU1tbicrm48cYbN+rabLqTSqVYtWoVhmHg9XqpqqpCFEXMoicw238D+grM9l9D0RO4pWFsHcw98uimwapUO8uTLdQmWjr+byapZ1mebGV5spWPAEwNjNWUyW2Mco1jpL+UmuLfst3E83HMngMzZlhj5t/v+eIHTllC0w1WR34e0eqapnHa2N/RvCIXxV9QGuTxJffgDQywIMBGwjR1SN6Pmfg/wABpDELB3QiOrdbRLxeJFY1GLcN5XdctAUqWZUvs8nq9FBQU4PP5rCiudDpt+YPrnVJivV4vwWCQQCBgGannBa58lcI8DofDErj6G+m0PuTXnUgkLHHOp2kc6BrLV7HlrFYjrMi20WamSQomu/i2tkS6fBqnrutWlJvL5bJSOvN+XV6v19q+KdBNgwcXv49uGkwurGFhhwjuk92kdWUdvYeOn4csbmNjs8UhCSKXjjuMq797ptc2l21zeI9h+pIg8vttj+ixSuGG6rulzWljY2MzVEyaNIkPP/yQ/fffn88++4wDDzyQd955h4KCgkGNd8ABB/D8889z6qmn8sUXXzBt2jQcDgfBYNDyBMlzzDHHWD+/9NJLVoriv/71r27paXfffTeffPIJixYt4pRTTmHmzJk9pqU88MADliDm9/sxDMO6CCsoKOCll14atJg3lNx8883U19fz3HPP8ec//5kbb7yRUChENBq1LuR+9atf8Ze//GWjry0QCPDqq69yyCGHsHLlSg477DDL7DgWy92gcblcPPnkk2y//cavpqcoinUz/qabbuozevCnTmehy+fzMWzYMCtyRJCqoOjJDsGr3hK8BKlrlU1JEBnhK2GEr4S9yrYFchf0rdk4dR3C1/LobGpji2kzZZpVH836SGanQ9D6P47aqYJTZoNRW8t/ln7MqGA5w6QgJqYldrmcMqmsSnssyU8dRVE5dfSFtDWEASiqLOSxH+/G43Nv4pX1jKm3YkZ/D0rOpxvPcQiBGxDE3v0R1zacz0dxQS5KKC92yrJMKBQiGAxa71NVVYnFYsRiMRSlkw9UR8RXIBDA6XSiaRqxWIxEItEl2ivfNp+a53a7N6gopGmaJWzl16JpWhfBTZIkSlxBdisbxxORL2k2EsTUDNvoEi6Xq0taYv685L3EOhvSbypxa23ebpjL4kQTXsnJ/hUT+Spci9uQmHv/K2R0FeXejRNtbItdNjY2my0TxDLOL9yDZ2Pf0K6nrO3l7hCXbXM4+1VM7LXvfhUTuW2Hk/nbwte7RD5tyL5b2pw2NjY2Q8X48eMtwWv27NlMmzaN9957j8LCwkGNd8wxx7BkyRL++c9/8tZbb7F48WIikQg+n49tttmGqVOncvjhh3PYYYcBUF9fz1lnnQXAmWeeyfHHH99tTK/Xy3/+8x923XVXZs2axY033sj06dO7tdtll12YM2cON910EzNmzKClpYWqqioOO+wwbrjhBqqrB5cuNtQ4nU6effZZfvnLX/Lwww8zZ84cwuEwxcXFTJkyhbPPPptjjz12k61v4sSJzJ8/n3/84x+8/PLLLFmyhGw2y5gxYzjwwAO5/PLLGTNmzCZZm6qq3HHHHQD88Y9//NmKXclkkoaGhh6FrjyCNKyT4LUi93/hvxHkvt8HgiBQ6g5S4tSYLP4DXO9AGSSEHVkuX8bytJxLhUy2MPPI3Tn5/tcRDYPl/32KV3fdFtkU2C5bTNDpwanXInRctbbGU33Ou6WjZBROGXUBkeYoAKXDi3lk4V24va5NvLKeMbOfYUYvz/lvCR6E4HQET8+G4z0ZzhuGYYlceYN1yH1e54WrfFRTXuDqLFyJotglTTEvLK1evdry7MrjcrmsCK4NEfWkaZrln5WP3EqlUmQymS7CFuTeH/l0w3yqoSzLmKbJNWWVvLzsc5qVMEJaYFmkkWpvsWWun4/cyleG3NxYnYny7PJPAfh1zV6sSLYCMM5Xwb+fehcA7R/qRlmLYK5t52+zQYnFYtZdt83hrqCNzeaKoij88MMPmKZJ9Yjh1OphWrNxSlwBdiga1e9oJd00mNtet1H7bmlz2mxc7L8DNjabH3V1ddTU1ABQW1v7k/Jz+qkxFJ+hyWTSKqaQSCSGpJLolkZnocvv91NZWdnnhbOpN3UIXstBrEIoemKdgpeZmYEZuw6MNkBG8F8EvrMRhK7xFlldRS4uRYpGWXbYPjxy83msSLSydTqAYAosckVY/LaOEgZ3Mex+XEmHB1iHF5ivFL9j84x6GgiZVIZTRl5ArC2XqllRU8bD8/+O0735ibGmqWMm7oXkvYAJ8lYIBXchyN0rgOYN5yORCIqiWFFc+UqH+SguSZIIBoMUFBTgdDotcSwWixGPx7sIRnkxzO/3WwJXIpEgnU53mdvtduP3+61or/U/7lwaYV7UUhQFRVHIZDJkMhnLQ6tzSmX+2LxeLz6fj0AggM/nw+VyoSgKqVSqmyimGTrPLv+MiJlGcMocPnoqB4zYYbMoQNAXpmly0/z/Mi+ygvHBam6Y9Av+PO9FFsRWckrlrhw9djcA5jUtZWL54CvF9/fvwEaJ7Bo9OncggiCwdOnSjTGljY3NFk5jYyOmaeLz+SgMFVAkDC46QBJEJhcP7sN0sH23tDltbGxsbGxsfj4kEgkaGhowTbNfQheAIFVA0ROY7aeCXrcmpVHu7n1nGgnM+M2QzhV0QN4KIfRXBMf4Hsd2SQ6YOhXef5/Rcxdz4/YnoZsG835cSGsqSo1Xpdm3gJZwBl2B+lQb9ak2ZrUsssYocQUs4WuUv4waXynFrsBmk9a1LpKxFL+uOZ9EOBe5Vr1VJQ/O+xsO56ar+tobpt6ci+ZSPs9t8ByPELweQejqJ7a24bxhGFZaqizLlnDj8XisKC5RFFFVlba2tj7TFE3TJJFIUF9fTyaTsdoIgmBVUPT7/YOumpsXtToLWvmf835Znasf5o9LkqQuJvGBQKBLtci8uBUOh0mn091EMVmWrcgt0j4WhhvxSA4eXjWLsJjllyN226xf0x82L2BeZAVOUebcraaRNTR+jDcCMGGQRTTWh40idtXV1QFs1k+MjY3N5kMymSQazYVvDxs2zP7ssLGxsbGxsbEZAjoLXYFAgMrKyn5/z+oqeNV2ErzW+OOZ2S8wo1eBsQoQwHcmgv9iBGEdaXgnnQTvvw+NjaAoSE4nJb4QHmSmVlTwXXmCd1f+SFD08ofxB3Yywm+hORulNRunNRtnTvsya0i/7GaUr5SRvlJq/Ln/q7xFm13keyKS4JRRF5CK5aKSRk6o5v6v/4rs2Pwch8zsJx1pi20geBGCf0LwHL1m/1qG850N1SGXfp03Uw8Gg4RCIdxuN4ZhkEgkuhjVw5o0xbwQlkwmWbVqVRcRLG9en09RlAdQrTMfZba2oJUXtTqTF7fyflv56of51EK3243P57PEKlmWURSFdDpNU1MT6XTaStnMk4/46qliYoW/kMKkj60CFSxJrOal+tm0ZeOcM3Yasrj5RXhFlCRPLPsYgBNG7EqFp4Bvw8vRTJ0SV4Byd8FGX9NGeQftvffe9sWqjY1NvzBNk4aGXMWOoqIiPJ7Ns+qMjY2NjY2Njc2WRDwetyLnByp05RGk8g7B6zedBK8nQSrDjN8JqcdyDaVqhNBtCM6p/Rv4lFPgrLPANOE//4HTTutSkbE4mDM7zyoaOxWNZqeiNdHsSS3L8mQLdYmWDh+wZlYm20loGb6P1vN9tN5q6xAkhvuKqfGVMcqfiwQb4SvFLW2aCKpIa4zfjL6ATCJXeGPMDqO4d/atSPLmJWaYpoaZuAeS95FLWxyHUPAPBDnnu9eT4Xw+ZTEvCEHON6ugoMASr/JCUE9pisFgEFmWSSaTrF692oqegpzA5fP5LIFrXel9AxG1OvfJ/5+vENm5+qEkSZY5vM/nw+FwoOs6qVSK1tZWUqlUlzUDA6qYWOkpRBAEqrxFHFAxiYeWfMBHzQsJK0ku3eZwvPLm5eP2yNKZJPUso/1lHF61EwDzIisAmFQwYpPoQRtF7Prwww83xjQ2NjY/ASKRCOl0GlEUKS8v39TLsbGxsbEZBMcddxyffvrpgPq89NJL7L777htoRRuGn8tx2mz5xGIxmpqaME2TYDBIRUXFoC8+BamsU4TXMsy2X4LoBz13YYvnRITAHxBEf/8HdbuhogKamuCZZ7qJXaWhnK+aonYXJnyyi/GhasZ3SpNSDY2VqXbqEs3UJVupSzZTl2ghY6gsSzSzLNEMqzuOh5ywUOMrY6S/lJqOaLCQs/dqgkNBuDnCb2ouJJvORSmNmzqGuz69abPzZTL11ZiRy0D9MrfBcyJC8FrAZWVj5A3nNU1DVVXLgF0URURRxO/3U1BQgNvtRtM0IpEI0Wi0ixjkdDoJBAI4HA4ymQytra1dIqFEUbQELp/P1+N5yq+hp/TDtU3i8+TXmn+9dY7gyu8XRdFKkcyLW/mItLzpfiqV6lItON833ycf/dVfU/mKjkiohnSYC7Y+mEKnj78vepPvIiv447znuWr8MRS5BvAe24DMbl3CF21LkBA5b+yBVvRkZ7FrU7D5xUba2Nj8bNF1ncbGXF53WVnZoPPsbWxsbGw2Le3t7axevXpAfTqnpWxsRo0axWBqNm1px2nz86Sz0BUKhSgvL1/vKAtBKsMsfBTajgGzHfR2EIoQCm5FcO07uEH32ANefBFmzwaw0tE0TaOsMJD7We9ZsFgbhyhT4y+jxl9mbTNMg+ZMjNpEcy4FMtnC8kQLYTVJQzpMQzrMJ60/WO2LnD5G+TpM8P05L7AyV3BIIlRaG9o5bezvUDI5sWfiHtvwt4/+tNlV1zOzszAjl4MZBsGHEPwLhvNQopEYkUijFb2VF5Py0U6QE68KCgoIBnPnLB6PWxFPeSRJwufz4XQ6URSFSCTSJdIqvz8vcOXPT37OniK11iVqdX4IgoCqqqTTaVKpVLe+TqfTErc8Hg+CIJDJZEgmk7S0tJDJZLr97ciLWx6PB4/HM2jxstJTAEBTOgLAjkU1TJ90PLcteIXlyVau+/YZrp5wLMN9xYMaf6hIaBkeXvoBAEdXT2GkvxSAqJKiLtkCwITQcFA3fl1EW+zaSNx7773ce++9vYZJ2tjYQEtLC5qm4XQ6KSkp2dTLsbGxsbEZJD+XqP6fy3H+1PB4PHz//ffWzz9lotEoq1evHlKhC8DUlkLkipwIYiGCtB4RHKeemhO72tshEsHRkfqmqiqVRbmKa4ZpWlX8BoooiFR4CqjwFLBb6dbW9oiSsiK/6pI5L7DGdJh2JUm7UsvX4VqrrVdyMnItI/wqb9GAPJRWL2/mjHEXoyq5yKEd9p/I7e/dsFnZ/uTSFu+C5AO5DfI2KJ47icYCxGLLMAzDqkoIOVFIkiQEQegSxZXJZGhpaemSppiPdnI4HBiGQTKZJBaLWXNLkmSlJ3q9Xiv9MBKJDFjUcrlcXcStfJphKpUiFot1SzPsXDUx77uVyWRIpVJW9klvglj+MVSReRUdYldcy5BQM/gdbsYEyvnL9idy6/yXaUiHmf7dc1w+/sguUY0bmydrZxFRUwzzFHLsiJ2t7fM70odHeEsocHoxZINf/uePRNUU7o30uWuLXRuJCy+8kAsvvNAqk2ljY9MVRVFoacmp//2pCmRjY2NjY2NjMxhEUWTChAmbehkbnM5CV0FBAWVlZestqJimAaknMON3AFkQguC/HNJPgLY4l9pY9Ljl5TQgjjgCRBEMAx5+GMfFFwO5yK7q0tI1x5XIUBAYuovlAqeXHZyj2KFwlLUtrSnUp1qpTeQ8wOqSLaxItpHSFRbGVrEwtspqKwsSw71FHUb4ZYz0lTLSV9Kjp9KqpY2cOf5S9I50zJ0P3ZEbX7968xK69CbMyKWgfoVpCsTN3xJLnUC6TcU0w5bPlSiKuN1uBEGwKiWGQiEMw7CiCTuLSbIsW1kb2WyWdDrdZZ/b7e4SbdXW1kZjY2OvopYoit0itVwuVxeT93yaYSwWI5VKdancmB+js4eW0+lEVVVSqRTNzc3rrJiYN5XfELglJ0VOH+1KksZMmK0clQCUu0P8ebtfcvuCV/kx3shN3/+XC7c+iN1Lx22QdfTFvMgKZq6ejwCct9WBOEW5yz5Yk8IoiiJFo6tASWy067yNInYpisIzzzwDwKmnnroxprSxsdnCyBum+v1+gsHgpl6OjY2NjY2Njc0WSyQSsVJsCwsLKS0tXX+hS1+FGb0alM9zG5x7IYRuQpAqMD0HYbafBtoPHYLXvwcueIkijBgBdXXw0ktIl12GKIoYhkHAs0ZQWNkaHVKxqyc8spOtg8PYOjjM2qYZOqvS4Q4fsJwh/vJkC0k9S21HWuSHzQus9hXugi6VIJ0NGpfvdD26lhNP9jh2Z6a/cPnmJXRlP8SMXImqZoimJxLTz0QXxqLrGStl0eFwWMbqPp+PUCiEx+MhkUjQ2NjYJU0xb+QuCAKapqFpmlWdURAEZFlGkiR0XSeRSPS4prVFrXy0VmdRy1q/aZLNZkmlUiSTSTKZTDexrLOHlsfjsaK9wuEwqVSqx4qJawtiG+s5q3AX0q4kaUpH2CpQaW0PODxcN/E47vnxbWa3LeWuH96iPZvg8KqdNtraMrrKg4tnAHBg5XaM6/ReMU2T7yyxa/hGWU9PbBSxKx6Pc/rppyOKoi122djYdCNfahgYVGUgGxsbGxsbG5v+oigKN998MwDXXHMNTqdzE69oaAmHwzQ3NwNDI3SZpgnp/2LG/wJmEgQPQuAq8JxkjSuIRVD0eCfB6zcdgtfYgU12wAHw8MPw7bdWxFA2m+0QR3LFGhvaokysqRj08QwWWZQY6SthpK+EfTq2maZJSzbWpRJkbaKFdiVBUyZCUybCF22LUZcmiJ/5LXToLjVHbM1B9x9FYzpChSeEKGzajAbTVDHifycdfolIchRJZSKm82BU3YuqJhFFEZfLhSiKyLJMKBQiGAyiaRqxWKxLBJZhGIiiiK7raJqGYRiWyJV/TjunPeb7dRa1Oqcf9iRqdSYfiZVMJkmlUt0isRwOR5dILIBUKkUikaC5ubmbj+JAKiZuaCo9BSyIraQhHe62zyU5uGSbw3li2ce81TiXJ+pm0ZqN85vRe1sG8RuS55Z/RnM2SrHTz8kj9+yyb3UmSms2jiSIbNuRYqkoCl/+61XSuoJyxy82+PpgI6cxDsb408bG5qeNaZqWKX1RUdFP3jvDxsbGxsbGZtOiqip/+tOfALjiiit+UmJXZ6GrqKiIkpKS9RO69DbM2HWQzUVw4NgJIXQbgjyyW9s1gtfpoC3qELyeGJjgdfbZObErmYTly5FlmWw2i6ZpyJKIqhmsDscHfTxDjSAIlLlDlLlD7Fyy5jhjatqK/Pp69gL+d+YnltDlPKSU6JWl3PXDWwC4RAcjfSU5E3xfKaN8ZQz3FXdJCduQaMpKog23EI2mUbSpGNL2KOyIkRFwOMDny1XCzEdxOZ1O4vE4K1eutFIa89ULDcOwHnlkWcbpdOLxeJBl2RK11vbTWpeolUfXddLptCVurS1WdY7Eypva53232tvbh7Ri4oYm79u1Oh3tcb8kiJw2eh9K3EGeqM2JXm1KnN9tfQguacMV+loSb+Kthm8AOHvsAXjkrp+h+RTGcYFhuKU1VVW/eug1ALRbunqlbShszy4bG5tNSjgcJp1OI4oiFRUb/y6djY2NjY2Njc1Pgfb2dsv/tLi4mOLi4vUTujLvYkav7zChdyD4LwbfmQhC7wbcXQWvhZjtv4bCfyM4tu61Txd22QUcDlBVePBBHP/v/wG5C2WnLKNqCs3R5KCPaWMRdHjYrnAE8g9p/u+Xr1lC156/3YPd/7J/zgg/0cKKVCtZQ+XHeCM/xhut/hIiVd6iNZUgfaWM9Jfil91DtsZMJkOk5WNirW+j6yKaUYkq7A5CJW63G0mSkCSJYDCIz+cjlUrR2NhIMpnsInBBTjDqLBDlPbjyJvOdI7ZkWR7Q69I0TasCYt53q3MQTWexKl/ZMZ/K2NTU1GPFRJfL1SWVcahM5YeaSk8hAI2Z7pFdeQRB4IiqnShy+rj3x3eZ3baUG79/iSvHH0XAMfRBBJqhc//i9zAw2at0G3YsqunWJi92TdyEKYwwALHr448/HvQk+fQkGxsbm87ouk5TUxMA5eXlVolpGxsbGxsbGxub/tPW1kZraysAJSUlFBcXD3os04hhxm6EzMu5DfI4hNBfERzb9Ku/IBZ2ErwWYIZPhcLHERz9NNDeaitYsABefx3H738P5MQut1MmmVFoi23+YhfAtx/P54r9/kheZzn24sO44O9ndGmjmwaN6XCnNMgW6hLNxLUMK1KtrEi18nHLQqt9mSuYqwbpX1MRstjp77d4ZBgGiUSCcLiVdHQmhvIdWTWAbpbh8E7G4yrCMAwkScLlcmEYhuXDZRgGpmlaaYJ5P658aqPH4yEYDBIKhaxKhoMRW03TRFEUq2piTybx+QqIPp8Pt9uNpmmkUina2tr6rJiYj/jaUq45KjsiuxrTkXVWId29dBwFTh93LHiNH+ON3PDdc1w14RjK3UNbHO/llV9Sn2ojKHs4dfQ+3fbrpsH3kVwlxrw5/aai38/yvvvua/vo2NjYDCktLS1omobT6VyvL2U2NjY2NjY2Nj9HTNOkra2NtrY2YAiEruwnORN6owkQwXc2gv8iBGFgqZ6CWABFj2G2/xa079dUaeyPYHbYYTmxa9Eiq9Kdqqr43E7aYikiicw6Btj0fPX+d1x18F+gQ+g68Q9Hc9Ytv+7WThJEqr3FVHuL2ZPcuTFNk3YlQV2ihdpkM8s7zPCbszHr8WX7UmuMgOzuUgmyxl9Kpaewi2+TqqpEo1Gi0Siq0o6amEk6o2GY1UiOSnBsRVYR0I00siyjKArhcBhd1zEMwxKbHA4HPp8Ph8OBLMv4/X5CoRCBQGC9oqPyYlX+0bmKI+RSE/PilsfjwTRNUqkU0WiUpqamTVYxcUNT7g4hAGldIaqmKXB6+2w/PlTNn7f/JbfMf5mGdJjrvn2Gq8Yfw5hA+ZCsZ2WqjZfqZwNw+ph9CfYQOVaXyBVt8ErOIZt3sAxY0rR9t2xsbIYCRVGsUPthw4ZtNrnxNjY2NjY2NjZbAmsLXaWlpRQVFQ1yrDRm/A5IPZHbII1ACN2O4Nxp0OvLCV6PYrafsZbgtW3fHc87D+64AxQFx/z5UFiIqqr4PS4Aosn0oNe0Mfj8jTlcf+Rt1u+/ueF4Tv3jif3uLwgCxa4Axa4Ak4tHW9uTWpblyRZqE80d/7ewKtVOXMvwfbSe76P1VluXKDPcU8xoZzHlupegKuNBRk2vRs02AEEkUUd0jEIQS3A5cibsiqKQyWS6GMe7XC48Hg8OhwNJkvD5fPj9fnw+36AFLsMwSKfTlriVyXQVMNc2iRdF0Wrf2tq6WVVM3JA4RJlSV5DmbIzGdHidYhdAtbeYv2x3IrcueJnlyVb+NO8FLtnmMHbqId1wIOimwf2L30M3DSYX1bB7Sc+pyfkUxvGh6o1ilN8X/Ra7ioqKCIfDPPTQQxxwwAEDmqS9vZ3JkycPeHE2NjY/LfJfyrLZLJFIJFdKOhAgEAhs6qXZ2NjY2NjY2GwxmKZJa2sr7e3tAJSVlVFYWDi4sZRvMaNXgl6b2+A5GSFwJYK47gvrdSGIoVyEV/gMUOflqjUWPYbgGN97pzFjwOuFVArno4/CZZehaRoFvpxfVSKd7b3vJuZ/L3/Bn467w/r9zJtP5qSrjh2SsX2yi/GhasZ3VLcDUAyN+mQbtfHVLI01UZtoZlWyDW/GhHiCVWaa1aaI15SRMEBI4xRVArKDkGcMFYFheEUHiqJgGAaCICAIArIsWwbysix3EbgGc4PaNE3LRyufmrh2qmFnk3in02mZyjc2NvZaMTEvcLnd7p+EuNUTFZ4CmrMxmtJhtg1V9atPkcvPHyedwN8XvcF3kRXcseA1zhy7HwdUTBr0Ot5t/JbF8SY8kpMzx+zf6/nOi12bOoURBiB27bTTTsyYMYPGxkZGjuxefaMv/H7/gBdmY2Pz06KxsZH58+d3uXMjSRLjx4//yf5xsrGxsbGxsbEZakzTpKWlhXA4Z1o9WKHLNBXMxD8heT9ggFiGELoFwbXXkK5XEINQ+Chm+LegftdJ8JrQe6eJE2H2bIQZMxAvvxzDMCgO5MSuVGbjVHIbKDOf+R83n3yX9ft5d57GLy45Ykjn0HUdRVGsRzabRVAUhqsuKvUqpgjFZB1ZEkKWpJYhqymkTIV2s404KlkhS5us0SbKGMnv8McXMkwIMgw/hbKXIk+QUn+QAk8Av99vGcwPRuBSVZVUKmUZy6+dauhwOLpUQFQUhXQ6TWtra7dIr825YuKGpsJTwHeRFTRmIgPq55Vd/GH80Ty45H0+al7Ig0tm0JZNcMKIXQd87dWcifKfuk8AOGXUnhS7eg5UyOoqP8QagC1M7Jo8eTLvv/8+X3311YZcj42NzU+QxsbGHj87dF1n3rx5OJ1OKisrN8HKbGxsbGxsbH5uuN1uZs+ebf28JWGaJs3NzUQiESBX4KegoGDg46iLMaNXgLYgt8F9JELwhlwk1gagq+D1bc68vuhRBMfEnjscc0xO7KqrwyFJZA2D0kAu0iyjaj332YS88/hM7jjjn9bv/+/eszjy/IMHPV5nUSubzVo/r+1llTdzz2QyVmQWgF92UewL4nE2IWkf4XetwHQlWJQ5gbpoGYlsCkVXyBgagiAQFTK0ammiqUZiGQXTITEyVcqo1Boj/CpPIbLYe9qiruuk02lL3OopGquzj5amaaTTaSKRyBZdMXFDU+nuqMiY7r0iY2/IosT5Wx1EsSvAS/WzebH+C1qzcc4Ze0Cfz2VnTNPkX0tmkDU0tg1WcUBFL+9Z4IdYI6qpU+T0M8zTVYB3u90c9+g1xNQ0ro30uTugyC6Ar7/+eoMtxsbG5qeHaZrMnz+/zzbz58+noqLCjvCysbGxsbGx2eBIksTUqVM39TIGTGehSxAEysvLCYUGJk6Zpg6pxzDjfwcUEAoQQn9CcB+6YRbdCUEMdAheZ4L6TSfBq4fUqrPPhmuuAV3H9/nnZCdPpjiY8+xSNjOx6/UH3+Wu8/5l/X75I+dz8On796tvXtTqLGhls9lunlSdkWUZSZJQVZVsNosoirhcLhRFQRAE/H4/kiTgMD4i5HgZn6uZWHYHVoXPx6t4GA84/BW4XC4cHhdph8FqkixX2skkW0inMuiGxoLYShbEVq6ZV5AY7i2mxl+aqwjpK6Vc9KNnVct3q7NgtXY0liAIlhjW2traLY2xc6TXllQxcUNT0VGRsSkdHVR/QRA4ceTulLgCPLxkJh81LyCsJLhsmyPwyOsuPPFx80K+i6zAKcqcM3YaYh8+XGtSGId3u66TJImy8TXISmKjCZf9fgXtvffeTJ8+HUEQ1ln2cm2Kioqora0d1AJtbGy2bNra2rqFIq9NJpOhra2NkpKSjbQqGxsbGxsbG5stB9M0Wb16NdFoFEEQqKioIBgMDmwMrR4z+gdQ5+Q2uPZFCN6IIJVtgBX3jCD6ofBhzPBZoH6dM68vegTBsV3XhiUlEApBNIr/+edpnzyZog7PLm0tkWRT8tLdb3LfJY9av1/95P9j/5O7p4Hqut5N0FIUpU9Ry+Fw4HQ6cTqdOWHK4UDTNOLxOMlkEk3TUFUVVVVxOp0dIpeEy5HAZ/wfglFPMlvGyvDRpLTtkCQHXq8Lv99PQUEBfr8fl8vV7bpeM3RWpdqpTbZ0McRPaQoN8Vbi0SjLjOX4DQeSKeCX3RQ4vRQ4fRR5gwwrKKE0WIQsy5ZPVyQS6bFiosfjsSosOp0Dq/j5cyEfIbU6E8EwjT7Fpr44oGIShU4f/1j0Jt9FVvDHec9z1YSjKXT2bjkVUVI8vuwjAI4fsSvDvH2nS29Ofl0wALGrvLyc6dOnD2oSQRAG7PNlY2Pz0yCb7Z+JaH/b2djY2NjY2NisD4qicNddOW+liy++eLO/yDZNk6amJmKx2KCELtM0If08ZvwWMJMg+BACV4PnhE0SVZ8TvB7qKngVPoLg3L5rwylTYMYMXJ9/DkChPyd2mWaumt+m9mx69vaXeeiqp6zfb3jh9+x21BQrha+zuNUfUStvCJ9/5KNfdF0nFouxevVqstksqqpaFRPzqX6SJOUqKGa+wMjOoFXxY5rbk9R3R3TUUFoYoLCwkEAggMvl6vO4ZFFipL+Ukf5SNE2zfLeaY+20pWJE1CQRJUVESRE3MtSbURaqbaQ1DXdSwr/aQangpUT2U+D0WUJYwOnB5/X95CombmhK3UEkRLKGRruSpKQXv6z+sFPRaKZPOoFbF7xMXbKF6759lmsmHEuVt+cqro8unUlSz1LjK+OIqr4rs8bUNHXJZgAmFgzvtl9RFOY+8Q4pPYsy/heDPoaBYMcG2tjYbFDW9Qd1oO1sbGxsbGxsbNYHVVW58sorAbjgggs2a7FrbaGrsrJyQFWsTb0ZM3YdZD/MbXBMQQjdhiB3vxjdmKwRvM4BdU6uWmPho10FrxNPhBkzEFavBkUh5F5THbIlmqS8cNNU8zZNk3//6Tme/PML1raLHz2Tyu1KWLp0aa/9HA5HN0Grs6i1NplMhkgkQjweR9M0MpkMqqpa1RHz/XLG7nGczMEtLUbHi04ZzsCh1JTUEAgE+v0aNwyDdDptVU3snJ3hRma4v4StPcPxer24XC6imST1kdWsjrUTTSUIq0kSegYNnUY9whK1lURaJSGqGJLISH8po/yljMrm/h/uLcYh2pJEX0iCSLknREM6TFM6sl5iF8CYQDk3bn8St3z/XxozEa7/9lmuGH9Ut0qPs9uW8HnbYiREzttqGtI6IsrmR+oxgeHe4h6jxVRV5fN7cu8Zbfo/1usY+ov9yrKxsdmgFBcX43Q6u5lUdsbtdlNcXLwRV2VjY2NjY2Njs3ljmiaNjY3E4/HBCV2ZtzCj08GMAA6EwGXgPR1B2DyMvnOC1786BK8vMcOnd0R47Zhr8JvfwDnnIJgmgbfeIv2LNdEgK1ujG1zsMk2zx/TD5299lbfv/6jjIOB3D53OVrvWoOs6giAgy7IlanUWt/oTiWYYBolEgkgkQiqVskQuwzBwuVwEg0F0XUdVVRKJBJqmIQpx/I5PcIjteJzt+Ap2I1B2Nk7nuk3ATdO0Ug1TqRTpdLqbl1bedytfzCGTyRCPx2ltbcU0TQpwUuCtQPDlIs0cbhftZFilR1iebKUu2UIk1YZiqPwQb+CHeIM1toRIlbfI8gGr8Zcx0leKT7Zvgnemwl1AQzpMYzrcY9TUQCl3h/jz9ify1wWv8mO8kRu/f4nfbX0wu5VuDUBSy/LIkpkAHFk9mVH+dac6b24pjLABxK4777yTRCLBDTfcMNRD29jYbIHEYjGCwSCtra29tpkwYYIdxmxjY2NjY2Nj08HaQtewYcPw+3v31unS14hixv4MmddyG+TxCKG/Iji22oArHhyC6MsJXpFzQfkiV62x8GEE507gdkN5OaxeTfD114kffTSyKKAZJo1tMRiiwzFNE03TLEGrcwri2j5TL972FjMf+yS3dgH+8NxFbL/P+C6RWoNJr1RVlUgkQjQatYzns9kssizjdrsxTRNVVYlGo2iaZn1vdssrKPG9ScBdj8+j4ii+GcG19zrnyqcmplKpbseYN4r3eDyIokg2myWdThMOh/tdMXEY0Llmn24aNKTC1CWbqUu2UJfIeYEl9SwrUq2sSLUCC632Za4Qo/wljPKVWUJYkdP/s71eqPAUQBga05EhGzPo8HDdxOO458e3md22lH/88CbtSoLDq3biqdpZhNUkwzyF/GLELv0ab16kHsiZ028uDLnY9de//pXm5mZb7LKxsSGdTlNfX4/X66WmpobGxsau4dBuNxMmTKCysnITrtLGxsbGxsbGZvPBMAwaGxtJJBKIokhlZWX/ha7sLMzo1WA0AxL4zkPwn48gbL6pmoLohYIHMCPngfJ5rlpj4UMIzsmw++7w3//imTcPAL9LJpJWaY4kBjzP2qJW54ittQUfa22CYKUfPnn9i2uELlHg77P+woTdxg36uE3TtMzbE4mEJXJpmobT6cTj8aAoCvF4HMMwLKFHFEX8fjeVwdcIOZ5BEjVwTEUo+BuCVNFtHl3XrSqIeT+xzoiiaIlVsiyjqirpdJrm5uYhq5goCSLDfcUM9xWzF9tax9+Wja9lhN9KSzZGczZKczbK7LY1aaFB2ZNLgfSVMspfxihfKRWegnWm1/0UqMxXZMyEh3Rcl+Tgkm0O5/FlH/FO47f8u/Zjvo/U83V7LQhwzthpOPuRZro6k3u+JES2DVYP6RrXBzuN0cbGZoOgqip1dXUYhoHf76empobx48fT1tZGNpvF5XJRXFz8s71DY2NjY2NjY2OzNoZh0NDQQDKZRBRFhg0bhs/nW2c/00hhxm+H9NO5DVINQuj27qbvmymC6IXCBzDD53YSvP6FcOqp8N//IkYiiIkEAY+TSFqlJZLsday8qNVT9cO1xRtr/k6i1toVEEVR5G9n3cd7j34MgCgK3DP7VrbaafSgjlXXdaLRKNFolEwmg6IoZDIZRFFEkiREUSSVSmGaJoIgIAiCJUgVFxdTVpRCTv0etB8AAXwXIPh/hyDI1vFnMhlL3MpkMl0isgRBwO12WxUQ8z5d7e3tvVZMzItbDodjyL67C4JAiTtIiTvI1OIx1vaEmsmJX8kW6hK5SLCGVJiYlua7yAq+60iXA3CJMiO8JTkRrEMAG+4txiU5hmSNmwsV7lwVxKGM7MojCSJnjN6XUleQf9d+zJsN3+AQJU4YsWs3H6/e+L7jOdkqWIFH3nyEdVvssrGxGXIMw2D58uWoqorL5WLkyJHWH8aSkpJNvDobGxsbGxsbm82PtYWuqqoqvF7vOvuZyteY0StB7xABvL9BCFyOIHg28IqHFkHwdAhe54HyGWb4bDjkAQRRRDAMgi+8QMi/NfXt0BZPWql9PaUf9iVqdU457Cxu9Sbi3Prru5jx9P8AECWR+765ndETRw74+DobzucFLlVVEUURQRDIZrOWwCWKIqIo4na7KSoqorS0FI/HA5nXMGM3gJkCsQgh9Ddw7o6qqiSTYct3a23Ryul0WqbyeZ+ueDyOqqpd2uVFtU1ZMdHvcDOhYDgTOqXDZXWVlan2XBpkooW6jmiwrKGxONHE4kTTmmNAYJin0BK/8tFgAceW9X7ozLCOyK7VmSi6aQx5NJsgCBxZPZm54TreafwW0zBZnmglrqb7dd7WpDBuPn5dYItdNjY2Q4xpmtTX15NKpZAkiVGjRvVaZcbGxsbGxsbGxiYndK1atYpUKtVvocs0FczE3ZB8CDBArEAI3Yrg2n3jLHoDsEbwOh+UTzCj50B1GcKKJvzvvIP/V+MBWN0aZsmSJf0StdaugDgQ8ebPJ/yNWS9+DoAkSzw472+MGNe/aBdYYzgfDodJp9Nks1kymYxlZq9pmpWiKEkSsizjdDopKCigpKQEv9+PKIqYZhozdi2kO6rZSbuTdvyRdNhNKlXbTbSSJMkylRcEAUVRrJTJtc9T58itfPvNDZfkYEygnDGBcmubbho0pSOWB1jeDyymplmZbmdlup3/tSyy2hc7/ZYBfl4AK3UFN8vjXZsilx+nKKMYGq3ZOOXu0JDPsTTexILoSkpcAVyizNLkam747jmumnBMn/MZpmFFdtlil42NzU+a5uZmotEogiAwcuRIXC67moqNjY2NjY3N5oPb7WbmzJnWz5saXddpaGiwbhRWVVXlonj6wFQXYUav6EhlA9zHIASvQxCDG2HFG4Y1kVoaWfNmsvF7yabrKdrhS0IrmnAvWoTPmYtoiaWylki0tqCVTz9cXxHj+qNu5fPXvwJAdkg8NP/vVI3tn8+soihWqmLe4D2dTiMIAqZpWiKdKIrWmv1+P8XFxYRCoS5eWKa2BL39MtKpFlLZcaQ4DoXdgGzHY41olTeV1zSNdDpNIpHolsK4tqn8YAz1NwckIVfJscpbxB6lOe800zQJK8kuEWB1yRZWZ6K0KQna2hPMaV9mjeGTXIxaqxJklacQWdy8btSLgki5O0R9qo3GdHjIxS7N0Ll/8fsYmOxfMZFjq3fmlvn/pSEd5vpvn+UP44/uIjR2ZnmylbiWwS06GOPvuQ3kPmuP/OflxLU0ro30uTvkYtfaFRpsbGx+PkQiEVavXg1AVVVVv81UbWxsbGxsbGw2FpIkse+++27qZQA5oWvVqlWk0+l+CV2mqUPyYczEXYAKQiFC6C8I7oM23qLXk7yotbanlqqqa0VqnYxpvEH46AShVxciptNUK3EAFANqamqG1EOqM384+C98/d53ADhcMo8suouKkWXrPK5kMkk0GiWRSFim8KqqWmvMpym6XC5cLhdut5vCwkIKCgpwuVxd2mWzWZLht0m2/5dMthqDbRHcB4KUS+/Li1aSJGEYBplMhvb29h4rJno8Hnw+X5eKiT9FBEGgyOWnyOVnp6I1nmpJLctyywg/9399qo2knmV+dCXzoyuttg5BYrivmBpfWYcIVsoIXwluadN6UVV6CqhPtdGUjkDh0I79yso5rEi1EpQ9nFazDyGnl79sfyK3zn+FFalW/jTvBS7d5jB2LKrp1ndeR1TX+FB1nyKhJElUTR5Hu5LYaK/BIRe75syZ02s1Cxsbm58uyWSS+vpcvnZpaSlFRUWbeEU2NjY2NjY2Npsvawtd1dXVfUaamdpyzOgfQP06t8F1AELwLwjS5umHappmj35aiqL0GiCRj3RaE6F1Jo7KZZiygKCZ7PHpuzxesRcZJVexcEPw+31v4LuPFwLgdDt4bPH/UVpV3Gv7vOF8JBIhmUySTCZJp9PW8UDuXDidTtxuN263m2AwSCgUwufzWW1UVSWVSnUYy0fRUjNBXQgEQarG4T8Ur68Uh8NhiWHRaHTIKib+lPHJLsaHqhkfWlMpUDW0Dh+wli4+YGldYVmimWWJZqutAFR6CrtUghzlKyXkXLen3lCRN6lvSA9tRcZVqXZeqp8NwGmj97GOqdgV4E/bncCdi95gXmQFf13wGmeN3Z/9KyZ26T9vM01hhA0gdlVXbz6lJm1sbDYOiqKwfPlyTNMkGAxSUdG97LGNjY2NjY2NzeaAqqo8+OCDAJxzzjk4HBu/cpuu66xcuZJMJrNOocs0TUg/gxm/Fcw0CD6EwPXgOXaz8BvqLGp1FrT6I2qt7afVU6SW6b8Lc/QzCD9GGD33c6RD9yKjahvkWC7a7RoWfbEYAJfXxeOL76a4sucbuHnD+fb2dkvgyhvO5+nsneX1egkGgwSDQWRZRtf1TuJWCkVRcp2MdszM24g043ZFcAUPQHAfgaYZJJPJboEl+Tk2RMXEnzIOUabGX0aNvww6su8M06AlE+tSCbIu0UJYTdKQDtOQDvNp64/WGIUOH6P8pbkoMH8pNb5SSt1BxCE2kAeo8ORSF5uGsCKjbhrcv/g9NFNnp8IaKx00j1d2cdX4o3lg8ft83LKQB5a8T1s2zvEjds15wRkai2INwLrFLlVV+f75mST1LOqE44fsGPrClnltbGzWC13XqaurQ9M03G43w4cPt//A2tjY2NjY2Gy2KIrC7373OwBOP/30jS52DUjo0pswo9eCMiu3wbkrQugWBKn/JulDhWEYvaYfDkTUcrlcyLLc7++LguCEw0+DH+8itKoZt0Miqw2t2GUYBhdOvYol39QC4PG7eWLZvYRKgt3axWIxWltbiUajlkglCIL1yItPHo8Hl8tlCVxOp5NsNkskEiGVSpHJZLqdN7e0AJf5NIIng04JafEc0ulhkI5abURR7JKW2Dn90Wb9EAWRck8B5Z4Cdi3ZytoeUVIdKZDNLO/wAWtMhwmrScLhJN+E66y2HsmZM8HvMMKv8ZVS7S1ebx+wSk8usqtxCMWu9xq/48d4Ix7JyZlj9+/xdSSLEhdsfRAlrgAvrZzNC/Vf0JqNc/bYA/gx1ohiaBQ6fFR7+87qURSF/93xNADqH24fsmPoC1vssrGxGRCmadLW1kY2m8XlchGPx8lkMsiybFdetLGxsbGxsbHpA03TWLlyJdlsFlmWqa6u7rGYj2makHkDM/ZHMGOACyHwe/CeirABokY6YxhGl+is/ohakiT1WP1wIKJWXwjnXQB/vwtJ1dk23MBXvjLM7CwE117rPbZhGJy7/eXUzc/ZcXhDXp5Yeg/BooDVJpvN0tLSQmtrK8lkEkVRLIP8vMDldrvx+Xw4nU58Ph+BQACn00k6naatrY10Ot0tKiuf2igICkbyaTLJH4moFSANz/mwmZ4tpmLiT5kCp5cC50i2LxxpbcvoCiuSrZYHWG2ymfpkG2ldYVFsFYtiq6y2kiAy3FtseYDlxTCv3P9CXpWeAgBaszE0Q19v8awlE+Ppuk8AOHnUHpS4Ar22FQSBE0ftTpHLzyNLZ/Jh8wLCStISuCYVjNgsX5NDInaJokhlZSWrVq15QisrK2lpaUEbYtXdxsZm09HY2Mj8+fPJZDLWNkmSKCoqYtKkSRvMO8HGxsbGxsbGZkun30KXEc6JXJm3chvkiQgFtyPIY4d0PWuLWvmIrf6IWmunHw6VqNUrW2+N4XYjZjIc/f2nzNnlGJTWC3CW3IPg2mfQwxqGwZnjL2Hlj40ABAp9PLHsXnwhH4Zh0NbWRktLC7FYjGw2i67rGIaBKIrWucgLUG63G7/fjyRJZLNZWltbUVW1y3ySJFkVEAVBIJvNEovUYmbeBiMMBBBcu+AO7IHX69viKyb+lHFLTrYODmPr4DBrm2borEqHrSiwug4hLKlnrcqQH62xAqPMFaLGvyYKbJSvjEKnr8f3UoHDh1t0kDFUVmeiVK0jkqovTNPkX0tmkDVUtglWMa1iUr/6HVi5HcUuP/9Y9CbfRpbzacsPuGUnEwuGD3otG5Ihi+zq6QPRrsxoY/PTobGxka+++qrbdl3XaWlpIRqN4vVuPJNGGxsbGxsbG5stBU3TqK+vR1EUHA4H1dXVPd4kNDMzMWPXgdECSAj+C8B3HoIw+FTLzqJWXtDKZrNomjYgUcvlciFJ0iaL4NC22Qbn3LnsWPcD7CLQFHUyXLoACu9FcO078PE0jTO2uZimZTn1IVQa5PHF/4eOxpIlS2hra0NRFHRdR9M0K4IrbwDvdru7nBdVVWlra+syhyAIuN1uSwxUVZVkMrnmvKsLMLMf4XTE8Pp0vCXn4QvtbGdKbKHIosRIXwkjfSXsXbYtkNNEWrIxy/8rL4S1KQmas1Gas1G+aFtijRF0eDoM8Ms6BLBSKjwFSIJIpaeA2mQLTenIeolds1oW8W1kOQ5B4pyxBwzIY2ynotHcMOl4bp7/X1am2pC1TJ9RYZsSO43RxsZmnZimyfz58/tsM3/+fCoqKjbLEFYbGxsbGxsbm02FqqqsXLmyT6HLNBI5A/r0c7kN0phcNJejfxEXkBO11jaIz6cf9oYkSd0ELafTuUlFrd7QDjsM59y5lEdawTBYldif4UWvYIYvhIJ7ENz79X8sTePU0b+jZWVOnCooD3HTB1fy49IfSKfTaJqGpmkYhtFF+MsLV7IsI0kShmFYlRfz5NtC7qZwNpvt1kaWDDzCy3gd7+ApbMPh2Rmh4O8Iol3N/KeGIAiUuUOUuUPsXLwmOjOmpnP+Xx2VIOsSzTSkw8TUNN9FVvBdR5VDAJfoYKSvhNZsnKSW4dvwciYVjsApDlzOiSgpHl/2EQDHj9h1UKLZ2EAFJ47YjZvnvwzA3xa+zpXjj2Kb0Mb3EuwLW+yysbFZJ21tbV1SF3sik8nQ1tZGScnmWf7axsbGxsbGxmZjo6oq9fX1qKqKw+Fg+PDh3QzxTeVLzOgfQF8JCOA9DSFwGYLQs2m9ruu9ph/2hizLvXpqbSkYZ56JefPNSKbBzg2LacqeB64sZN/GjPwOCv4Pwb3/OsdRFJXf1FxAe2MEgFB5gEuePYPmtmY0TUPX9S4+XA6HA0mSkCQJURStlMK8/5Ysy5ZJvGmaZLNZ4vF4lzk7V0z0OFYiJ3+PYNSSi967FHxnbXAvNpvNi6DDw6SCEV2qGGZ1lfpU2xoj/EQLK1KtZA2VH+ONRJUUcS3NMys+5f2meQzzFnakQJZ1RIOV4nf0/LmR57FlH5LQMozylXJE1U6DXv/KVDtl7iAOUSapZ7nx+5f43bhDuhj7b2q2nE83GxubTUY2mx3SdjY2NjY2m559992Xjz76iOnTp/PHP/5xg81z+umn8/jjj3Paaafx2GOPbbB5Nhfy0TAzZ85k33333bSLsdmkKIrCypUrUVUVp9NJdXV1F6HLNLOY8X9A6hHABLEKIXQrgmsXoKuo1Tlia6CiVj7NbkvHUVWF4fcjJRIcvWg2K6KnIRT8DTMqQOYtzMhFUHAXgntaj/11Xae9tZ1zJ15JvC0BQEFFkPMfPwXVUDG0nBfX2uJWPvotLwyKoojL5UIURUzTtFITO5OvmJgXuCxvtvSzmLEbAQXEilw0l3PyBjtnNlsWLsnB2EAFYwMV1jbdNGhKR6hNNPNB0/d81LwAAdAxqE+1UZ9qY1bLIqt9qSvISF8JNf6ynCG+r5RiVwBBEPiybSmftf6IhMi5W01bL5P7eZEViILIRVsfwv9aFjGnfRn/WPQGv6nZm8PXQ0QbSmyxy8bGZp309wtSTyarNjY2NjY2NhuHxx57jLq6Ovbdd19baOsDl8vF66+/bv28IVin0KUuwIxeAdpidMOBIp2A6jgXJSqhKCstT63eyEcT9ZR++FNFlmUyEybg++ILdmpcxlfRZM7LLPQ3TATIvIkZ+X8dgteBQC5dMZFIkEgkiLRGuHa/20hFc9kKRdUhzn7oJAQ5F5GVj9oSRdGqkuh0OhEEocu51TStW1pivmJiXuDyeDxd0kBNI5HzYsu8mdvg2hchdBuCWLgRzpzNlowkiFR5i6jyFlHmDjE/tpIip58btz+xw/+rhbpkM3WJVpqzUVqyMVqyMea0L7PG8Mtuqj1FfBdZgWbqHFK5AyN9pYNeU0smRmMmgoTIdoUj2blkLI8t+5B3G7/j37Uf05qN85uavbp4gblcLg7920XEtTTOjXTNaItdNjY2fZJIJGhra0OSpG7lkjvjdrspLi7eiCuzsbGxsdkSqKysZNy4cVRWVm7qpfzkeeyxx/joo5wXiy129Y4syxx++OEbbHxFUaivr0fTNJxOJ8OHD0eWZXRdJ5NJoUSfJRt/A0UNoeiHocuHgFwDxLqN5XA4ekw//CmLWr0hSRLJww7D98UXlCajRMO58yUIMoTu6BC83kBp/QNJWSehjCeTyWAYBpHWCDcedg/ZRC4LoWRkIWfcfzyClBO68imLa5vOC4JgGfx3NvMXBAGXy7UmNbGPiommugAzcjHoywEZIfB78J5hpy3aDJhKTwEA7UoCv+xmp6LR7FQ02tqf1LKWAX5eCFuVaiehZfis9UeSehZZkPiweQGfty1muLe4SyXIEb4S3NK6i2F83+EnNiZQjk/OCVe/Hb0fJa4gT9f9jzcbvqE9m+DCcQdbvmKyLDNyz+1oVxIbLX3aFrtsbGx6xDRNWlpaaGpqAqC8vJyGhoZe20+YMGGzMzK1sbGxsdn03HLLLdxyyy2behk2NhuFbDbLihUryGazVvpbY2MjiqKgKS2Y2fdBXw1UgzwmV0VQ8NiiVj9Jn3AC5vTpiMDYz2bC744DQFUN4vrVxCNVZJLLgbfQZJ2sVkG8PcFfj30AJZVL/ywdXcTp9/4Ch9OBw+HoFo2VT01cO13U6XRa4pbX613nc2OaJqSfxozdDKggDutIW9xxA5wZm58DAYcHn+QiqWdpykQZ6evqleyTXYwPVTM+VG1tUwyNj1bP564f3kYQBLYJVBFRk2QMlaWJ1SxNrIbVubYiAhWeAmp8ZYz051IgR/pKCTm9XeaZF6kHYGLBcGubIAgcXT2FYqeffy5+l8/bFhP5PskV2x61Th+xDYUtdtnY2HRD13VWrlxJNBoFoLCwkKqqKiorK5k/f34Xs3q3282ECRPsO/Y2NjY2NjY2WwSKovDoo49iGAYnn3wywWBwwDfsTNNE0zRisRjpdBrDMFBVldbWVnQ1jCRpBAMe4vGOcdV5mNlPcchxnB4NV/BYnP59fhbphwPFNE2rIqIsy11EKN3lIuUP4EvEOe6Np/nqbB3x7NORPTnBMJ3cn5mPv0jd3CYcnlcZu+sEXrn9U/RsLjuhcusizvjnifj8foLBIG537iJcVdVu3rOyLHcRt9YuLLBmvTooc8BoAbEUnFPATGFGr4Xs27lGrv1zfmxiwQY7bzY/DyrdBcyPrWRG43fsWro144LDkHqIEtRNgx9iDTSnozxT9xleycmB1VM4e+wBGKbB6ky0SyXI2mQLUTVFQzpMQzrMJ60/WGMVOf2M8pUywleCgMBHzQvQDYMJnUS1PHuWbUOh08cdC19jUayB6797lqsnHIMbmc9fepe0rvCMv5pLJx2FR3J26z+UCGbneMxBIooiFRUVXaI+KisraW5u7jPt6edILBYjFAoRjUYJBoObejk2Nt3IZrPU1dWRzWYRBIFhw4ZRVFRkfQk0TZO2tjay2Swul4vi4mI7osvGZgAM5d+BvLfIokWLGDt27Lo72Nh0Yl0G9Y8//jhnnXUWmqZxzTXXcNNNNw1qnr4M6juv4brrruP//u//+Pe//83ixYvxer3svvvu/OlPf2L77bcHIJVKceedd/LMM89QW1uL2+1m2rRp3HzzzYwZM6bb3I899hhnnHEGI0eOpK6ujvfee48777yTOXPmkEgkGD16NL/61a+4/PLLrYve9aWzQf3kyZO57bbbeOGFF1i+fDler5fddtuN66+/nl122aXPcd544w0eeeQRPv/8c1pbW/F6vUyaNIlf/epXnHnmmTiday4S8sfZF7W1tYwaNarLtk8++YT77ruPWbNmsXr1alwuF+PGjeMXv/gFF154IX6/v9s4nZ/PRx99lIcffpjHHnuMhQsX0t7ezqOPPsrpp59utf/www+59957+fTTT2ltbSUQCLD99tvz61//mlNPPXXAIs/6fobG43GWLVvGDjvsAMArr7zCtttuS0VFBYFAoFt70zTRdb2LQbyiKMRiMWKxGIqiYBgGAIaexCE24HaEKfQvxe2M4XRKuJwyTmE+TjmJ6N4FIXQLgmTfJOyJeDxOU1MTiUQCXdeRJAm/308gEKChoQFp+p/Z7vVX6PzN0xBEFh55FE+5duLLF7+DXq5ua7ZzcsUjDkQ5iOE4BEPs+pnRuWJiXtxa13dcM/MOZuwmMJrWbBQ7bD2MNnJpi1eA93T7+7LNejO7dQl/nvcCbUoCpyjjlZwM95Vw1pj92blkbJd2Dy39gPpkK0kti2rqeCQnf5x0AnuXb9vr+BEl2ZEC2WqlQjZmIgCkNYWwkkQ1NIyON1mhw8deZduyZ9k21PhKqfIWWab3y5Ot3Dr/ZdqVBLFsitZ4mDnH3gHApIfPxTusmCOrJnPtpOMGfB76+3fAjuyysdmC0Q2Db5asojWapCTkY8exVUi9+AX0p28iHqe+vh7DMHA4HIwYMQKfz9elnyAIlJSU9DKqjY3NxsTTcSfbFrpshppbb72Vq6++GlEUueeee7jwwgs36HyqqnLIIYcwY8YMnE4nDoeDlpYWXnnlFWbMmMHMmTOpqanhwAMP5JtvvsHtdiMIAu3t7Tz33HN8+OGHfPnll4wYMaLXOf75z3/yu9/9DtM0KSgoQNM0FixYwPXXX89LL73EjBkzKCwcOrPoxsZGdtppJ5YsWYLb7UYURdrb23njjTd47733eO211zjooIO69Uun05x66qm88MIL1rZgMEg0GmXWrFnMmjWLf//737z55pvWej0eD+Xl5bS3t6OqKj6fr5tQ1VlUMgyDSy+9lLvvvtva5vf7SSaTfPnll3z55Zc8+uijvPPOO4wcObLH4zNNkxNOOIEXX3wRURQJhULdPIsuu+wy/v73vwO57w+hUIhIJMIHH3zABx98wJNPPsnLL7/co8i0IYjH49TW1hKLrfHGikQiRKNR0uk0w4cPx+l0dquAuPbNe0VRiEQi6LqO0+lEFEUyqVYwWhHELGMq36bQv2qt2R0IgWvBe7Lt1dQL+edHURTcbjcejwdN02hubmbZsmVU//N+xr/+Srd+gmkw/tWX2Z4FfCls1+v4+5/iQTc96KoJ6luI3kPxBrbrUjFxIIKUmXknZ4i/trpmtHUsrAih8AEE5/b9HtPGpjdmty7hL9+/SExNIwBOQcIlOahNNPOX71/k+om/YOeSsVa7jK7iEmU0U0cg95n914Wv4pYcXYSxzhQ4fexYVMOORTXWtrSm8Maqr3lgyfuAiSiIGB1jRtUUbzR8zey2JXhkJ7IgMdxbxCh/GaN8pZxesw83zn+JNjVhCWQAajiJMayIV1bNARiU4NUf7E/ajcS9997L+PHjmTp16qZeis1PhBnfLObwax/mnL+/wDWPvMU5f3+Bw699mBnfLB5U30OvfpAXZ36JYRj4fD7Gjh3bTeiysbHZvKiuru6zBL2NzUAxTZOLL76Yq6++GpfLxbPPPrvBhS7ICVFz587l+eefJ5FIEI/HmT17NqNHjyaRSHDxxRdz9tlnEw6Heeedd0gmkyQSCd5//31KS0tpbm7mmmuu6XX8lpYWLrnkEo4//nhWrFhBOBwmFotx33334XK5+OabbzjzzDOH9JguvPBCnE4nH3zwgbXe2bNnM27cOBRF4ZxzzrEigjpzzjnn8MILLzB69GieeuopotEo0WiUVCrFK6+8wujRo/n888/57W9/a/U58cQTaWpqYvfddwfg8ssvp6mpqctj+PA13irTp0/n7rvvpqysjHvvvZe2tjbi8TjpdJqZM2ey44478sMPP3Dcccf1uEaAl156iVdeeYU77riDcDhMe3s70WiUgw8+GIB77rnHErrOOeccGhoaCIfDRKNR/v73vyPLMh988AFnn332kJ3zvjBNk6amJhRF6fL9RlVVdF0nHA6zaNEi6uvraW5uJhKJkE6n0XXdqsbn9/utaHeXy0V5eTmhUAjTNHCIK/C7m3A547THx2Gaa4kmYgF4f2ULXb3Q+fnx+/0IgkAqlSIej5NMJlGTSbZ9/VUA1paj8r8fz4/IZs+vV4AX/xbHJbdTHFjK8JIvGV10O1VVlRQVFVkCev/Xq+ciunoLIwMQHOCY2O8xbWx6QzcNHlr6ARldJejIpfXqmLgkB4VOHxld5eGlH6AYmtUu5PCQ0HKZOj7ZTak7aLXT+3ifrI1Tknm36Tsgl0Lplhw4BIlCp58SVwBZkFAMDa/oRDN1apMtzFw9n0eXfchfF7zK6ky0z/FfW/UVaV1Zr/PTG/an7UbiwgsvZMGCBXz55Zebeik2PwFmfLOYKx98neZIosv2lkiCKx98vU/Bq7e+rbE097wzjx9bMowePbpXXwIbG5vNh8MPP5xMJmNVX7OxWR8UReGkk07i7rvvJhQK8fbbb3P88cdvlLkjkQgvv/wyxx9/vJU6NHXqVP71r38B8Omnn/L222/z3nvvcdBBB1kpvAcccAC33norkBNfehN/U6kUu+++O88884wl+ng8Hs477zzuvfdeAP773/8O6fc0WZaZOXMm++23H6IoWsf0/PPPA7B8+XI+++yzLn1mzZrFk08+SVlZGR9++KHlJwU5j8yjjjqKjz76CJ/Px8svv8zcuXMHvK66ujpuueUWPB4P7777LhdccAFFRUVArvJfPrW0urqar7/+mldffbXHcRKJBHfeeSe///3vrTX6/X4qKytJp9NMnz4dgF/96lc88MADVFRUAODz+bjkkku48847AXj22Wf56quvel1vNpu1Ugbzj8GQTqepra1l2bJlLFy40Nq+YMECFixYwOLFi2lsbETTNCRJIhQKUVlZyahRoxg7diw1NTVUVVXh8/lQVRWv14soiiSTSUw9BigIAgjoRJLVpLIFXRdgtGAqswe19p8D6XSaRCKB2+3GNE2i0SiZTAZN0zAMg+FvvIFoGN2ErjwCIAFH0vt34EizQfuPCygOLsHjakc0G3JeW4NBmdM1dbEnjNWDH9/GphNftC5mSbwJzdSJqCkAS7DKiVkulidaeHzpR/wYayRrqDRmIqimhohIgdNrtVuRbOWHWO9FxzqjGhrvNMxlcawRxdBoyETIGioI4JVd+Bxuil1+BODy8Udy95Qz+P02R3Dc8J0Z6yunORtDaU+QXNJEaulqa9zUstUklzSRXNJEpj3Ov5dtmO+xtthlY7OFoRsGf33uwx7vI+W33fH8h+gdd2JN07Qemq732jfPwzO+xVh/Kz8bG5uNwNVXX01paSnnn38+jY2Nm3o5NlswsViMQw45hOeee47Kyko+/vhj9t133402/5577smee+7Zbfs+++QMvAGOP/74HlN285FE6XSaxYt7v9C97rrruqXZAZxxxhlUV+dMdp955plBrb8nzjnnHMrKyrptnzRpEjU1uRSR7777rsu+hx9+GIBTTjmlSyRWZ6qrq9lvv/0AeOeddwa8rsceewxd1znkkEMsL7S1CQQCHHPMMX3OUVhYyLnnntvjvvfee4/29naAHv3gAC644AKruM3TTz/d63pvueUWQqGQ9ejtvKwLTdN44YUXOPHEE/n1r39tbb/zzjv57W9/y9lnn80rr7yCYRjouk40GqW5uZmmpiaam5tpb28nkUhY0V6ynHODcblciIIGgKq7yaoBEukKljfvTWP79kST1aiaJzdZ+HyMyMWYqRcw9XUIJT8zNE2zzqsoitb7Pv8d1tfUv/N1DvO4xfyY3cxVPUZ5XXXiGI7eaiK/P3Y0M14sINtyLWbiXkx1PgOysjZahradjU0ndNNgYXQVT9f9jyu+fpJb5r9MSsuS1VVMTCRE/LIbzdBJqBniaoaolub5FZ+R0RU0I5d67RAkil1+xI6IUocoo5kGYSXZ47yqobEouooXV3zBX+a9yJmf3899i98jrSuohoaJidgxt0OQuoz5TXstD/z4HrcteIV7fnib91fPI2OotLz5DQsuepRFlz9pzbPin++x4KJHWXDRo7S8+Q0rU+0b5Dzanl02NlsY3yxZ1S0qqzMmsDqc4IV3ZrFtVVfvkYWrwn32paPvN0tWMWXrwX2ZtLGx2XgsXLiQm266iUsvvZTx48fzm9/8hj322IOysrI+TZ/33nvvjbhKm82dxsZG9tlnH+bOncvWW2/NO++8083IfEOz884797hdkiRKSkpYtWpVr1YQ5eXl1s/hcLjHNrIss9dee/W4TxRF9t13X5588knmzBm6KIy+DOiHDRtGbW2tJQjl+eSTT4Cc6NWXAJSvlrx8+fIBrys/x7vvvmtFW/VEIpHoc46pU6d2McnvTP48Dh8+nK233rrHNpIksf/++/PUU0/1ed6vvvpqLrvsMuv3WCw2KMFLlmWOP/54pk2bhqZpnHLKKUBOBN1uu+1QFIVQKGT5h+XTG3Vd71KFWlXVXFqdqlpVFL1eFyiNGIaDjBpENzRME+LpCuLp3Dl2yCm8rja8rq/xOt9HklRMeStw7ong2gucUxEE14CP66eCLMtIkoSmaTgcDvx+Pz6fj1QqRTqdJtXHa7XLOMAUmplCMxoCi80C3qKG/1FNXHACApmkxPdfBPj+iwC3X2Ti9s5g7MTXOfBXGvv+cjKewgPAuTuC2Iedh1javwPrbzubnz0RJcW34Tq+CdfxXXg5SX1NdVBZkJBFCY/owCHJaIZBQssQUXOiVV6o9Ts8ZAwVr+TCL7u7eTmrhoYsiBQ6fdbvS+KrWRBdyYLoSn6M5yK4OhOUPUTFFB7Jic+RE7lM0ySpZYhrGbK6ioHJ3T++3e2YBKD0sB0p2HUrjKxqCV4jLjgQ/7a5m0yOIj/V3qKhOYlrMSRi16mnnkpBQUGXbb/85S8HHWZsY2PTO63RnpX4tYmmsv3atj5z2NjYbFr23XffLh4j9957r5WS1RuCIKBpWp9tbH5ePPjgg0AuTe79998fdOTM+tCXQXk+gqa3Nvn9QK9pjCUlJVakSE9UVVUB0NzcvM619pf+HNPa681XNu9vul4qlRrwuvJzJJNJksl1/73vbY6eotby5M9j/rz2Rj6irq/z7nK5+nzu+ovH46GmpoZoNNolwm/bbbdl0qRJJBIJQqEQo0aNQhAETNPsUn0xb1YP4HQ6yWQyGIbR8RnsxVRGgplFM9z4XM0U+OowcKBpHlTdi6qXETV+TTRRj6AvxyUtwetqxet6BbfzcUTBgencOSd8ufYEaczPqnqfx+PB7/cTjUaRZRlBEBAEAYfDgSRJrDj8cCY++hiC2XMqowkYwMdUMYVmAqjImGxLmG0Jcylfs0oIsGBMDa+2DOOHmL8jJUIgk5L4fraf72fD3y9dgtv7I2Mm/p39TyjkgFP2x1tyIIK8VvEL5xQQK/pIZRRy+51ThvI02fyE0E2DZYnVfNNexzfhWpYlun4OBmQ3kwpGUuUtJKOrPFH7MVElhaSLXYzrnKKMYZqM9JXw4C7n8P/mPEZtohlxrc8P0zRJqBkqPQXMj9Tz4ooveha3HB7GB6sZH6pmQkE1Fe4Czv3iXyyON5DqqOxo9JIn5BQkSt1BJhaM4IiqyUwqGM7+7/8ZZ5EfPbPGl8s7uhzf2JyALSJw6uh91udU9sqQiF1rl5EGuOuuu4ZiaBsbm07ouo6o90+w2n781ozfqrrLtrQjCO/PX2ffkpBtTG9js6UwoLSLQbS3+elzxBFHMGvWLKLRKGeccQavvvoqXq93Uy/rZ0m+6t99993Heeedt0Hn+MMf/mD5nQ2GvqJHN0cEQaCioiIXJZRKcckll/CPf/wDQRBIJBK4XC4qKiosgSlvQr+20GaaJuFwmNraWrLZLLIs54QxaQRapglJUnDKKZLZNZFIJoBzTxAq0IVSDHEHNEEjozTQnlmBqNfhdqzE66rH6/o/XI6bEaRKTFc+6ms3BDG0Ec/Wxqfz85NIJJAkyRIaBUFA8niYd/gRbPf6q5h0NanP/1V7ga15qKMa4ygzwrEsYQ8aCKEgANVGnOrF33EQ36EVe2icujtvRUbwzo8asXA6vxIyKYn5s33Mn63wf1e8hcvzBmMmmex97CimnXo0wYo9EAQHpvdkSNzZ09Hk/g1egyBsWe8Tmw1LQs3wbWQ537TX8m14OTEt3WX/aH8ZWwUqcYkOmrNR5kWW82nrDwC4xJyfpYmJR3TilV0ICKR1Bbfs4HdbH4JbcnLWmP35y/cvElaSeCUnJpDWFVJaFhOTqJrmhfovrDmDDg8TQsPZNljFhIJqqjxFNKTb+W/9lzxR+zGrUu1doszWRhZE9izdhgu2PohR/u43QY6smswrq+YgOmSqf7svKx/5EEGWuuz3SD1HCa8vdhqjjc0WQP6LVVNTE2VuKPS5CCd7/tARgLJCP1PGjegWujpl3AjKCvy0RBI96vH5vjuO7ftOrI2NzeZBb1XSbGwGwuTJk5k+fToHHXQQM2bM4PDDD+f111//SVXkbW1tRVGUXtPuVq1aBfQdrbQxqKioYPny5YNKTxzIHD/88MMGnSN/HleuXNlnu/z+jXXeA4EANTU1NDU1ceihh5JMJikuLiYUClFRUdFnNF4eQRAoKirC4XDQ1NREIpHAMAyczio8hQIFzudwiI0oqg9F85PVKzEd+4I8BsilzRqGgapCRq3EMMqBqSSMFFJ2NRKrcApL8blX43V9htf1Og45i+nYHsG1Jzj3Asekn6SI4vf7KS8vZ8WKFcRiMQzDQBRFiouLKSsro+lP0/lKg53eeR2hkx+XKYgsOPIovnPtBC9+BybUCQX8nSn83TQZ54ly+dQfGf59M1J7LiVVbksz/O0ZnAOc5fWSPmw/Fo3ajpcXGcz7uoFkZI34lU1LLJgNC2av5P6r78Hl+T9GT3Cy28FhDjxBpqjMAXQSLcSKnNDlPnijnTubzRPTNKlLtvBNey3fhOtYEm/qEhXlk1yMD1VT4gqQNVQWx5t4p/HbLmN4JScTC4azXcFIDNPkxfovqE+2ktFVZEFktL+MM8fsz84lY1EMDb/DzT5l43mv6TuaszFM08xFSQoSBU4f5Z4QE0LDGR+qYkJoOBWuEPOiK3ht1Vc8uPh9mrNRFEPrdq0okIvCQhCQBRGP5KSm09y9ce2k44Bc1cXiAyZhZDWcpUFEBI6smmzt3xAMWuxasWIFkiStMzw5T0NDA5qmMWLEiHU3trH5GWGaJm1tbWSzWVwuF8XFxV3C1pPJJA0NDaTTuT+ibreLS47dg+lPfoBA14LH+V6Xn7BvN6ELQBJFrvjlvlz54OsD7mtjY2Nj89NlypQpzJgxg2nTpvHhhx9y6KGH8uabb+L3+zf10oYETdOYNWsWBxxwQLd9pmlaFU2nTNm0KUd77LEHy5cv5/XXX+eWW24ZcP98el5fEZx77LEHH330Ee+//z6ZTAa32z3o9fZG/jyuXLmSH3/8sUffLl3XmTlzJkCvfmwbgkAggN/vp6qqil133RVZlvF4PANOGcyPk06n0TStY5wdgEM6KvW1gFiK6ZiMYWClQXZOi9R1HdM00XUdTXOiqj5S6nBMcyrtmTiS0I5EEy65Ab+7iaD3Jfye+5EkL6ZrdwTnnuDaC0Hqn5/V5oppmqRSKdra2kin0wQCAXw+Hz6fj8LCQgKBAIIgUFlZSeu/H+Kqx15j388/wL+6Cfe22zDs2supKS1lusPB6r+u5rX73mXxl7V4/G52PnoHxu06GtHTQswTw700jPmf2Tifew65JWceL6ZS+N54g8m8wU6ShLrLLkT23oev/SN598NVLJldSzqe920TyKYFFs7RWDgnwCM3jcfphlHj3exyyDAOOm0a5WMP+EmKkTb9I6ll+T6ygm/CdcxtryOsdk0XH+4pZpS/FIco0ZyJMTdch2rq1n4BGOuvYFLhCHYoHMUYfzmyuOb1NK1yEj/EGggrSfyyG1EQWBRdxVsNc1kcb7TGKnD48EhO3JKDrQOV7FG6DRMLhlPiCvDR6oW82zCXuxa9RVhJoJvdExMlQaTA4WPrYCUHVU5iWvkkZEm25i50+hgXHIYkrPu68dpJx3HZ+CP497KPWDlhD6q9RZw6ep8NFtGVZ9Bi16hRo6isrLTuhK2LPfbYg/r6etsnxMamE42NjcyfP7+L8anb7WbChAkUFxfT1NREJBIBcl9gy8vLKS4uZhtRxOv18tfnPuxiOF9W6OfyE/blgB236nXOA3bcitvPOWJQfW1sbGxsfrrsuOOOfPDBB0ybNo1Zs2ZxyCGH8NZbb/Ur2mVL4KabbmK//fbrVpHx8ccfp76+HoATTzxxUyzN4pxzzuHpp5/m+++/57777uP888/vtW0ymcThcHSJVgsGgwDWd4ee+O1vf8vtt99Oa2sr06dP57bbbuu1bV6YGajoeeCBB1JcXExbWxt//OMfezTbf+CBByz/sF/96lcDGn990XWdN954A4Bjjz120N5YgiD0kPIrgWtNcQIBEMWcT9va0ZKapnURwBRFIZPJkMlkUFUfqlpMRqsho2SJZmKsDEeRaMflaMfnasHv/g9+7524PaVI7l0R3Xmj+6EXMDcEa4tckPu+W1BQQGFhYRc/PlgTVdemwow9DsTj9XLjeSd0aTN85HAuuPVMVFUlkUgQj8dJp9OklQrSSgVCqYD3qv3x/fnPuH/8EePpp3E9+yxyh2+coOs4P/2Usk8/5RDgwK23JvWbA2na4QDmxDx8/uq3LJ1TSzaVv6YVUDLw49dZfvy6lidu/hcO10OM3LaYqYfsykG/PYjqsZUb+lTabEJM02RVup2v22v5pr2OH2IN6KyJPHSJDsYFKgk5vWR0lSXxJma1LOoyRpHTzw6FI9muYCSTCkbgd/T8HlYMjSXxJuZH6lkQXdVF3MpT4PDm0hJDVYwPVeOTnLzZMJeX6r/gjoWvEVfT3Ty3BMAhSpS6gkwqGMHhVTuxc/EYq4pjZ8aHqrtt6w8OU6RoboQiRI49dj9kacMnGa7XDLZPiI3N4GlsbOSrr77qtj2TyfDVV19RWlqKx5MrVV1UVER5eTkOh8Nqd8COW7Hv9mP4ZskqWqNJSkL/n73zDI+jPNv2OW27dtW7LffeC2BjcMemmA6hg5OQRviAhJA38CaUQMJLCIEkEJJAKIHQIXQbd2yMDbbl3m1JVrX69joz34+11pIl2bIsWy5zHsce0u6U55mZ3Xlmrrnv67Yzul9eh6KyjmVZAwODkxNN01i7di0lJSUEAgFuueWW7u6SwSnIyJEjWbx4MdOnT+err75i1qxZzJs3LyGinKrYbDZWrFjBDTfcwJNPPkl+fj6hUIhXX32Vu+66C4DLLrus3aqQJ4rJkyczd+5cXnrpJe644w527tzJnXfeSZ8+fYB4dFBhYSHvv/8+//rXv1i/fn3C5B1g2LBhfPjhh3z22Wfcd999bWZg9O3bl1//+tc8+OCDPPHEE1RWVnLfffcxbNgwIC7AbN68mY8++ogXXniB//znP0yaNOmotsNqtfLQQw9x55138sYbb+B0Onn44YfJysoiEAjwwgsvcO+99wJxgXHs2LGd3WWdIhwOc+211wLxqpOHiionClmWkWW5lWCmqmpC/GrysGqqSqiqMYKqj4DfQ43XjaB7kaUgZsWL3fIKNvOfMdsKMNuGY3Kcg2zu30rg7W7aE7lcLhepqamHPR6SJOGPqCRbJGym9udTFIWUlBRSUlKIRqN4vV68Xi+hUChRnEFITcV23304Hn4YZcsW9LfewvzeeyiVlQfb27mTpJ07SQL6paVxxYwZeB6DolwnWzansG6Bzp7CMmLhg+JGNKyze30tu9d/whuPf4JiEskfmMWYmWOZddtUeg8zMp1OdUJqlK3u0gPm8sXUhFsWFMm2JJNnS0VCpDrsZqN7X4vpZlFmsCufkckFjEwpINea0qboHj4gjm05UC1xl7eK2BHErUgsyicVhbyydxllgXqCagS9DXHLIpnItaYwLrUPl/c4iz6OzONaFKM7zrsn7MweCoW6bSAxMDjZ0HWdLVsObxRfX19P//79ycvLS4hehyKJIuMGdK5q1rEsa2BgcHLxl7/8hUcffZTa2trEZ83FroaGBs477zxisRjLli0jKyurO7ppcIowfPhwli5dyrRp0/j666+ZOXMm8+fPb1V5+1QiIyODX/ziF9x555289dZbpKSk4PP5EtUQR44cyYsvvtjNvYzz/PPPI0kSL7zwAk8//TRPP/00DocDRVFwu90tvPoOvTG59dZb+eMf/8ju3bvp2bMnGRkZiTTFFStWJISxX//618RiMR599FH+/e9/8+9//xur1YrNZqOxsTFhYt9WGx3lpz/9KXv37uVPf/oTf//73/nHP/5BcnIyXq83kekxdepU/vnPf3Zq/aczkiRhtVqxWq24XAeN6TVNIxAI4PF48Hq9+P1+IpEAsVgj0YgbX8iNKARRpCCyvANFWo+iyJgseZhtAzDZhmG2pGIymVAU5YRXezwWkas5gUgMMGEzdSxVUFEUUlNTSU1NJRKJ4PV68fl8LYWvzEzs//M/2B95BGnDBnj7bSz//W8L4Uuoq8Py1ltY3oIMRWDMeedy1SUX0vD4ZRR7YNvKnayfv57iTftpXuAuGtEo2lRJ0aZPeO+pT5AVkdx+OYyeNpwLbptC/zF9zqjKm6cqVcFGChvi0Vtb3WUtIqoUQaKXIxOnbMGvhiny1VAVamyxfIE9nZHJvRiR0pNBzlwUsfX3PazGfbu2HkbcSlHsDHHlMyQ5n0FJuVQGG/isopC/7VpAdchNtA2/LREBu2yhwJ7O+ZmDuChvLJmWU/shVkc4IepTRUUFNTU13W76aWBwslBXV9cidbEtVFUlOTm5XaHLwMDAAOCOO+7g+eefR9d1nE4nPp+vVSR1SkoKY8aM4fXXX+edd97hpz/9aTf11uBUYciQIQnB65tvvmHGjBksWLCAlJSU7u5ap7njjjsYMGAATz31FN9++y2iKDJo0CBuuOEG7r333pNmvDWZTPzzn//ku9/9Lv/4xz9Yvnw5FRUVhMNhMjMzGTRoEOeffz5XX311q8it/v37s2TJEn7/+9+zevVq6urqEsJScysRQRB45JFHuPbaa/nb3/7GkiVLKC0txe12k5KSwoABAzj33HO54oormDBhQqe35amnnmLOnDk8++yzfPXVV9TV1ZGUlMSoUaO4+eabueWWW065qo7diSiKOByORFqprutEIpFEup7X6yUWqUeN1RCKNhII+RHFCIrfg9L4JbL8BaKcAVJPRKUAkyUfs9mKyWTCZDJhNpuPiwim6zrBYJC6ujoCgUBiW45W5GoiGIkLvlbl6L87JpOJtLQ00tLSEsKX1+slHA7j8/nw+XyIeXnYHniA2KOPIq5bh/Duu1g/+qil8BXVURavwLV4BS6g5/DhnHXBBVzx4AU09OlL8eYKdqzcxKYl2yjd1kgzP31iUY1928rZt62cD5+dhySLZPfOYuSUocy8ZTJDJw40xK+TgIgWY7u7nMKGYgrri6g8RLxKMznIsrpAF6gOudnlrWwx3alYGZlcwIiUAkYk9yTZ1LroS5O4tcUdT0vc3Z64lZzPEFc+fe2ZbHOXs3D/ZuZXbjiC35aN/kk5zMwZzvTs4dhkM2cagt7B3MIvv/ySpUuXJt4/9NBDOByORAhyW+i6TmNjI5999hm7d+/m0ksv5YMPPjjmTp/KeDweXC4Xbrf7lE8JMOg85eXlFBYWHnG+0aNHd7gIhIGBwalBV44D8+bN46KLLiIpKYlXX32Vyy67jJycHKqrq1tEZjSf99JLL+W///3vMbVrYHCq8PLLLzN37lwKCgooLi7u7u4YdAFdcQ71+/0Jwcjn8502lUd1XU9EK8XTHr3EIuWokQrUaC2qGkQQNCQhhiSGkWUdQc5HkHqC3BMEB4IgJMSvQ0WwzqRDNkVydYXI1cS5/+8ZzumVzIiCDG658sIuEYbC4XBC+IpEIonPRVHEbrdjtVjgywcRP1iMbX4pyn5vYh6dg4WeAPTsbKIXXIB/2jQaxo7FH9PZs3Y3O1ZuZNOyPezf26xyYxuIkkhmz3SGnz+EGTeex6hpw066VNTTlZoDhvGFDUVsbiwl3CxET0Qgz5aKXbbgj4aoCNajNpOZZEFikDOXESkFjEzuSU97eivPq7AaZae3skXklqq3rKydarIz2JXPUFc+WeZkChuKWF69nSL/frzREPohSYnCgbYzLE6GuXpwcd5oxqX1bTNyrDvpyvNuR8eBDu+BJUuW8PDDD7eqEvfwww8fcVld17FYLPzqV7/qaHMGBqc1ZnPHlPWOzmdgYHBm8vzzzyciNC677LLDztsUnbFp06YT0TUDAwMDgxOMIAiJ9EeIZwkEgwUEAgECgQDhUB3E9qHH9qHGKlFVFUnfg6huR4ipaHommtSbcKwn4XAuzW8VBUFIFEQwm80txLC2hJhDRS5BEBIiV3MP2s4QjmnoOphkgWg02qJIQ2cxm82JqujNI74S/zfuROipYv/lEKK/fx5xvRfxvfewf/opyv79ifXogFBVhenVVzG9+irJFgva1Kn0mTGDs350Eb5fuvA1+Ni5qpAdX29j21fl1JW3LOCmqRpVRdVUFVWz4JWlCKJARn4aQycOZNoNkxh/4WgjIrKLiGkqO72VFNYXUdhQTGmgrsX0JNlChtmJhs7+YGOr6bnWlET01hBXPhap5Xc7rEbZ4alkm+dw4pYjnpboysMqKnxbt5dvanfz/r7VBNVoG35bAhZRjvttpfXlktzR9Hd1rCrimUaHxa5evXoxefLkxPtly5ahKMphQ5tFUcTpdDJs2DBuvfVW+vXrd2y9NTA4DdB1HU3TkCSpVeRFcywWC2lpaSewZwYGBqcaq1evBuLV1Y6Ey+XC6XRSVVV1vLtlYGBgYHASIElSi7THaDSPYLD/AZ8qH2qkAl3dh6buA3U/kliDWdyLLASRAE0aQkQfSkTrg6anJEzzfb6D1bwFQUCW5YQIpmkaPp+PSCSCKIpdKnLBgetoHSKqhkWRCIVCXSJ2NSEIQgvhKx7x1YCn6iWiuoQ3Ng2fNxOxfzb23/6W2O9/D6tWIb//PvbPP0c5UNURQBcEhFAI6fPPsX/+OXZAHzuWyKxZFEyZwlmXTCEai9FQUcGOlWvZsWoP21bW4ms4ZJs1nep9tVTvq2XJm1/Fq1LmJDP4nAFM+c5EJl42HsV07Pv2TKE+7GNDQ9xYflPjPgLqwUg+QRdItyRhk0x4YkEawn68sYPWM3bJzLDknoxM6cmI5AIyDvG9CqlRdnoq2eYuY4u7jN2+tsWtoa58+idlE9NUvq3fw5KqzbxVspKoprYSt0QEbLKZAlsGkzIHcmHOKHJsbRvaG7Skw2LXrbfeyq233pp4L4oiqampLFmy5Lh0zMDgdCQcDlNaWkogECAlJaWFmfShDB061DiJGRgYHJb6+npcLhdJSUkdml8UxRbm1gYGBgYGZw6KoqAoCk6n84DfV08CgRHxyC9/PVp0HwF1H0T2ge7DJFdhM28m2VSHyWxHlSYSYRwRfTDRmEI4HEZVVaLRKMFgkEAgkCj6AGC320lOTkYQBPx+f0IQO5aopGgs/qA4HNMwKzLBYPC4WcMIgoDFYsEc+5DU9PcJx3riM92Dz0+iwiOANGQItnHjiDz+OOIB4csxbx5yTU1iXbokgaoirF2Lee1azL/7Hal5eWgXXURgxgzyv3M5E67R0LQoVbu2sGPlJnauKmXHt37CgZb90nWduooGVry/mhXvrwYBUjJdDDqrH+ddPYHzr5mA2dJ1AuCpjqpr7PFWHaicWESRv9lx0XXMkkKayUFM16gLe1tUVpQEkb5JWYxMKWBEcgF9k7JaRFDFxa0Kth4Qt/b49rcrbvWyZ9IY8bG2fi+fVRTSGPG367flUqz0d+QyPWcYk7MGk2JyHJd9c7rT6UTOl1566aQx8jQwONnRdZ26ujoqKyvRdR1RFBkwYAA9e/Zk69atLczqLRYLQ4cOJScnpxt7bGBgcCrgdDppaGggGo0e8Yl5fX09breb3NzcE9Q7g9OJK6+8kpUrVx7VMu+//z4TJ048Tj06vmRnZx/1MkbU5KmDyWTipZdeSvx/JtI8giklJQVdzyUY7EsgEMDv9xMOVhKNldAY2kejvxxBiGFW9mAzf4PD3IDFno+YfC5BdTz76zMIhWJIktQi3VEURUKhUKuiTE2RYM09wUwmU2L5w1Hr9gMQUXVsJjlR1fF4ocf2ofueRRDAmn4nNmsfMg54ozVVdWwhfA0bhu2sswg//jjCypWY/vtfHPPnIzd7wK0rCug6Qnk50j//SdI//0mSzYY+YwbhWbNIO/98CoaNZ8ptEdRILaWbNrD96x3s+qaa3YVR1Ngh+0iHhv1uvv54LV9/vJYnbv0rrgwn/cf0ZtKVZzP1+knYHGfWfbs7EmBjYwmF9cVsaCzB1yw6S9M1UhQ7JknBHQ0QUWMtzOczzc4DvlsFDE3ugb2ZsXtIjbDFU3lQ3PLuR6W1uDXM1YNMs4vqcAOF9SX8t/RbfLG2/bYUQSLNnMTw5B7Mzh3FmNQ+Ldo8XeiO826HDeoNugbDoP70pUnQCofDidBnQRCIRCKUlZUlQr4dDgf5+fmJH3l7yxkYGJyedOU4MG3aNJYtW8ayZcuYNGkSQLsG9c8++yx33nknl1122RlfLMbg6JkyZQrLli07qmWWLFnClClTjk+HjjOdGYeNS+oTg3EtfWKI+30FD4hfbiLBYvTYPlD3gVaPKKhYzQ3YzHWYTUFU+oLpXGzJF6BYClBVNZH2GA6HE/83j/w6FEmSWglgJpMJWZYTv8nC3WV874/vMDDTzk8vGEpaWhqDBg06LvtA13X0hu9BZAWYJiCkvNzq3NBUFMDj8eDz+VpUPZUkCZvNBqqK+NVXmD/6iKQvvkCuO+j7pJvNIMsIfv/BlQoCnHUWsYsuwj99Ot6ePQmGQmhqkIh/L3vWbGLn6mJ2feuleItGS3v8tklKddB3VC/OvWw8M26ejCP59CjK0ISmaxT5aihsKGJ9fTG7fVUJUUnXdUQEkk12oloMTyzYwjjeLCoMS85nRHIBI1MKyLYkJ45zSI2w01PJlgOG8m2JW2kmB0Oc+dgVMxWBBra4yygP1hM+4LfVUtwSMIsyOdZkxqb15cKckQx05WE6yczkT3Y6Og50idi1ceNG5s+fT0lJCcFgkBdffDExLRqNUlNTgyAIRqQKxgB9ulJZWcmWLVtaRWgVFBQQDofRNA1RFMnOzjbELAODM5yuHAeee+45fvrTnzJt2jS++OILRFFsU+zasGEDU6ZMwePx8MYbb3Dttdce62YYGBgYdAvGtXT3EI1GCQQCNDY2Ul9XghYpQRErUaT9CESQpQhWUx02Sx02qxPFfjaCeRKYxiMIB6OKNE1rVwRr77ZUFMWEALZyezmPvvUlvdOs/PyiEdjtdkaOHHlctlkPfoLu/hlgQkj/BEHudfj5dZ1gMJiI+GoufMmyjMVigVgMYflybJ98gmPBAuT6+oPL22xgtyM0S38EoKAA/ZJLCF9wAZ7RowmoKuFwCNT9+Bt2smvVdnZ9u5+d34aoLOrYPYbdZaPPiALOvmQss26bQnKGq6O75aTBHwuzsaGEwoa4ubwnGo/y03WdmK6RJFtQRAlPNIiA0EIT7OPITIhbA5JykMV4am1IjbDDU8kWdylb3WXs9Va3ErfSzUkMTMpFFARK/XXs8FZQE/IQ07VWflsSAhbZRIEtnXMzBjItaxi9kjINM/lj5ISIXW63m+9+97uJEua6riMIQosL7EAgQEFBAQ0NDWzYsIGhQ4d2trnTAmOAPv2orKxk7dq17U5PT08nPT2dHj16GNUVDQwMunQciEajjB49mm3btjFlyhTuuecevvvd71JXV8f27dspLi7m448/5sUXXyQYDDJhwgRWrFhhCO4GBganLF1xDo3FYsyfPx+AWbNmIctGVMWRCAaD1NXV4ff7E8WWTCYTiiwRCZWiRUvQDxjdg45J9mMz12Eze7Am9UG2TgTTeSD3b3MM0jSNaDTaQgBrejW/XZ2/voiXl24jP9nMXTMGoigKffv2xWKxJAQxRVGOeZzTNTd67WzQ6hAcdyM4fnJ0y+s6gUAAn8+H1+ttcX8sSRIWiwU9GkVcvhz7p5/i+OIL5MbGg8snJSGkpkJlJUQOGqiTlASzZhG78EL8kyfjs1gIBAJoqgdiJdRX7GDXqiJ2r/WwfXWUhuqOiSrWJAu9hvbk7ItGc8FtU8jITz+q7T0R6LrOvkBdonLiLk9lQojS9HiFTodiJqzGiGoqUrMqoSmKnREpPRmZ0othrh64TDag4+JWb3smUU2lNFBDka+GxmgATW8ZtyUAoiCSJFsZkJTNtOxhnJM+gBxrsnHdRdeed4+72BWNRpk8eTKrV6/GZrMxdepUFi5cmDAqbM59993Hk08+yYMPPsiDDz7YmeZOGwyx6/RC13UWLVrUyougOSaTiRkzZrRZltnAwODMo6vHgZKSEmbPns2OHTvavZjSdZ3hw4czf/78TnkRGRgYGJwsdMU51O/3JyoU+nw+7PbTK6WrKwmFQtTV1SXsOARBwOl0kpqa2sKS42DKYx1h/x60WAnE4kb3gqBjVjzYzLXYrAKWpBFI5klgnoggphy2/biR/kHh61/z1/DG8q1kO838/IKBCIJAZmZmC99KQRBaeII1F8E6ej2uuf8Xgm+D1Bch/UMEofMeQ03CV1PEV/N7ZVmWURQFPRJBXrEC+2efkfTFF0hu98Hlk5MRcnOhqgqaRYIhijBxIvollxCaORNffj7+QIBwOABqGVq0mP17drH72xp2r/Gx/Vsdv6dj22+2mSkYnMe42aOYNXcquX2659ohGIuwyb2P9fXx6on1kfj3UNd1IloMq2RCEkT8sVA8FfDAdZAiSAx25TEyuYDhKQX0tMUza4KxCDu8FWxpLGObu4y9vtbiVqbZSbbFRUCNUBaopyxQj78dvy1ZkOIeXcn5zMwewajU3qSaDTP5tujK8+5xF7uef/55fvKTn9C3b1+WLVtGbm5uuz4hq1evZsKECUydOpVFixZ1prnTBkPsOr2ora1l1apVR5zvnHPOIT395HtCYmBgcOI5HuNAIBDgj3/8I//6178oKSlpMS0vL4/bb7+dn//858YNnYGBwSmPIXadGDoicrVHk9+X3+8n4NtHJFiEHisBtRxQm/l91WOzZ2Kyj0O0TAJlJIJw+GiPx15fwHsrNpPltPDwVWOJRqMJL9wmQay9qsPNzfObe4I1mek3oUfWoNffEF8m9XUE0/ij2HOHR9d1/H4/Xq8Xv9/fSviSZTkufH35JY7PPydp4cKWwldaGkKfPtDQALt3t1x5375w6aXxqK/Ro/FHIvj9frRYLaglqOEiSreUsGedh53fhti1TiAS7pj4ZbIo5A/MY+zMEcyeO5Weg/O7ZH8ciq7rVAQbKGwoprC+iG2e8kR1w5imouoaVslEWIsiIraI3uphS0ukJg5y5mKWFIKxCNs95Wx1l7PVXUqRr6Z15JbJQYopCX8sRFmwjv1BNxEt1krcEhFQRJlsi4sxqX2Ynj2slYG9QfucUmLX5MmTWbFiBR9++CGXXHIJ0L4pbiQSwWazkZWVRXl5eWeaO20wxK7Ti/LycgoLC4843+jRo8nLyzsBPTIwMDjZOd7jQEVFBRUVFaiqSnZ2NgUFBV3ehoGBgUF3YYhdx5e2RK6kpCTS0tI6XUGtye/L73cT8O4iFi4BtQS0eJSSLEWwmuuwmYPYkvpjsp8D5vMQpNbXzr/8x8csKNxNptPC7687h2AwSJ8+fRJRy7quE4vF2vQFO/QetTlNIpjJJKIE/weTsA1T0gUoKY91aps7gqZpLSK+mot0kiQhSRJaKIR5xQqSPv8cx8KFSAeqPgLomZkIQ4ZAMAiFhS3THZOTYfbseNTX1Kn4TSb8fj+hoBvUfeixYqKBIoo3NrJ3XTzlce9mGU07JEJcANpQCxSzTG7fbEZPH86s26bSb3TvTu+HsBpli7vsgLl8CdXhuLin6TphNYosSohAVNcwiweLFSTJFkYkFzA8pScjknuSZk4iEAuzw1NxWHErzeTAJpnxxIJUBhqoj/hQD/htNd9UCRGzpNDTnsbE9AGcnzWEvo4szNLhq18btM0pJXalpqbi8XgIBAKJE197YhdAWlpa/Ad2mHSvMwFD7Dq9MCK7DAwMjhZjHDAwMDDoPIbYdXw4HiJXWzSlJQYCAfzeCgK+nWjRfaCWgh4GOOj3ZbNidQ5Htk4C01kIgpWfPPMuq7aXkp1s4/9umIjX6yUnJ4fevQ8vtui6jqqqbXqCNTeSJ7IGPbIKBCuC7UYUU1KbKZGSJHXZPoG48NU84utQ4UsURbRQCMvy5XHha/HilsJXTg7C2LGgafDtt9Dc5F6S4LzzYM4cYhdeSCAvD7/fj9/vQ41UoKvFECsm4K6mZIObXWv8bFutU7a7tagjCEKbhQQkRSKndxYjpw5l1q1TGHR2295sTewPuRPeW1vdZfFIKl0nqqlEtRhmSSGsxTCLcsI8XkJkgDOHEclx761ejgzCapTtngq2ucvY4i6jyFeNdog655JtmEQZd9TP/pAbbyzUpt+WJEjYZRP9HDlMyR7CuNS+9HJkGGbyXcQpJXZZLBasVisNDQ2Jzw4ndjmdTjRNS5xAz1SMm5zTC6/Xy4oVKw77pMhisTB9+nTDmNDAwADo2nFg2rRppKWl8c4773Ro/uuvv57q6uoz3lLAwMDg1MUQu7qWUChEfX093gPCyfESudqjye/L7/cR8O4iFNiLHisFtQrQEQQdi+LGavZgc+Tx45cHsaVUpSDDyeM3TqKuro6UlBQGDRrU6WvtpkiwcLCEcO3/EomaicrXERMGtruMLMvtimDHes3fnvCl63pi/XoohHXFCpLmzYtHfPn9ieX1/HyESZPAZIK1a2HLlpYNDBoEc+bEo75GjyZwIN0xGKiFWHFc/FJL8dQEKC5sYOe3IbaskqitbJliKojx7dS1NsQvWSSrIIPh5w1h+k3nMXTyILZ7KuPRWw3FVATjGoKqaYS0KCLxADIRAbN0sMBAtiU5biyfXMAQVz46sONAWuIWdynFvpoW4pau6dgVMxIijVE/dWEfQTWCDoeIWwKKKOJS7AxL7sGUrCGMSC4g15pi3LMdJ04psSs/P5/Kykrcbnei0+2JXUVFRfTt25d+/fqxc+fOzjR32mCIXacPDQ0NlJWV4ff7qa2tbXe+sWPHkpOTcwJ7ZmBgcDLTleOAKIpkZ2dTUVHRofl79+7Nvn37DivQGxgYGJzMGGJX1xAOh6mrq+s2kas9En5fvloC3q2Eg/sOGN3H+3nfu/mUNZoYkBXlkaus1Lp7k+TKYeDA4cfUb13X0Ru+C5GvwDQRIeUlNE1rEQHWFBUWjUbbXY8kSS3Er6b/ZVnulIiiqmoL4avp1l3XdURRjAtfwSC2r77C+fnnOBYtQgwEDq6goABmzgSnEzZsgGXLoHkkW1oaXHQRzJmDOmMGfkk6UEXSjRopQY8Vg1qCrrpprPCxZ20jO76JsXm1BV9jy+2RZBFdB01twzNNBCHDjDw8CWFGCrHRNkyKgqprWCQTiiCBAFbJxDBXD0amFDAipQCHbDmiuGWW4sb0jRE/jRE/UU1tx29LItPiYkxqb87PGMyQ5HzSzElHfUwMOkd3iF2drvd49tln89///pdPP/2U73znO4ed9y9/+QsA5513XmebMzA4adB1nZqaGqqqqoC4yNuzZ0+2bt3aIk3XYrEwdOhQQ+gyMDA4adA0zXhiaWBgYHAG05bI5XA4SEtLw2zufqNtSZJwOBzxm+LsXkSj0QNG90UEvDsJxeIPd0ySSGOjl3CoCkHdQU3x66Rn9MJknwjKqCMa3bci9Elc6MKE4HwYQRCQJAmr1YrVam0xa3MRrHlaZDQaTYh1wWCwxTKiKLYpgimKcthxWZIknE4nTqezTeFL13V0kwn/tGn4p02DYBDHV1/FUx2XLEEsKYEXXoivrFcvuOMOyMqCrVvh00+hrg7+/W/497+RFAXn5Mk4L70U/ZJLCPc5H79/bNyKKFBBau8iUnoWM+7SStCi1BQ1sGuNj22rRbZ+ayYSOkTkMgmgATEdNND3h4nuD8PCWhAgnG5CGZpE1sX9OO+ysYzJ6EOONYU9viq2uMtYvH1zK3FL1TRkQURDxx0J4I0FEymJTXMJgCiImEWFPFsqE9P7c076AAY6c3EolqP7Xhic0nQ6suvTTz9lzpw59OvXj6VLl7ZbjfHvf/87P/nJTwBYuXIlZ599dtf0/BTFiOw6tdF1nfLycuoPlP3NyMggOzs7kb9eV1dHOBzGbDaTlpZm3FQaGBi0orsiu1RVxeFwYDKZcDer7GRgYGBwKtEV59BoNMo//vEPAH7wgx+gKKe/4fTJLnJ1BF3XmXHf8zT4Qkzo5+K7k0x4vSqCECTJWonNXI9J8WMz+7E5CrA5xyBZJyHIh68cqGuN6LUXglaH4LgHwfHjTvVP0zSi0WibvmDt3XI3F8EOfR3uPkJVVXw+H16vl0AgkFh/i4dawSBJTamOS5YgNhfgeveGq6+GAQNg+3b45BPYsaNlI8OGwZw5cOmlqGPHEgiF4lFf3lpi4SL0WDHhaClVEZHSgEThxgD713nxFQZRd4Th0AAviwiqDtE29oUAcqoZYZAdZWoapilpiCaJqBZDQEDVNTzRQDwlUaeVuCULEhbJRN+kLM7PGMTo1N70S8o2zORPIrryvHvc0xgBrrnmGt577z2ys7O54YYbeOGFF/B6vfztb3+jpKSETz75hM2bN6PrOrfffjt///vfO9vUaYMhdp26qKrKvn37EhcJubm5hum8gYHBUXMs44DH46GxsTHxvlevXmRkZLBmzZp2L6R1XaexsZGXXnqJP//5z4wfP57Vq1cfyyYYGBgYdBvGtfTR0SRy+Xy+xDjRlK54qohczTnvnr/iD0WZM74fd1xyNqWlpUTCXmyWRixyCXqsDPR4pkWT35fNqmBzDsTqPAvBdDaCaGuxTs39AATfAakvQvqHCELXpnHqut6uCNbciL45giC06QmmKAqi2NIwXVXVREXH5sKXqqoJ4UsIBklavjwufC1diti8aFzfvnDttXD22bBrV1z4WrECmlseZGbCxRejXnIxe88ZQWGwmt21ZXh9XmyagK5FiWkxmmoa+oNe6rfU4FnvIVwYJlYcoQUiiHYZLaJBuO19oLskYv3NRM91EJuchG4RDywqIIsSSbKVoa48JmUOYXhyPr0cmYaZ/BnCCRG7QqEQt99+O6+//nqbynPTqr/73e/y/PPPI8udzpo8bTAG6FOTaDRKcXExwWAQQRAoKCgwjp+BgUGnOJZx4OGHH+aRRx5JvNd1/agjSJ955hl++tOfHtUyBgYGBicLxrV0xzjdRK4mzrnzz0RiKjdNHsbcWeMoLy8nFAqRmppKQUHBAaP7bQS8O4mEyhJG9wCiGMNq8mBzZGJ3DsdknxD3Amu4CQAh9XUE0/gTti1NIlhbvmCHE8EURWkzJVIURWKxWCLiKxgMJo59LBZLZKJIoRDOA1Ud7cuWIYbDBxvo3z8ufM2aBSUl8Mkn6J9/juDxJGaJmGQ2je7HqnMG8uU5/ahPSyZdsJIh2EjRFUyahkuOkCXXkyb70aUIRTUhCr+Jsm+NSqQwjLb/EN8zBTSbiBDWIaRz6JWNDghJEq4haYy/dAxX3Dab/tm5RhbNGcoJEbuaWLFiBS+88AIrV66koqICVVXJzs7m3HPP5Qc/+AHnn3/+sTZx2mAM0Cc3baUihsNhioqKiEajyLJMr169sNlsR16ZgYGBQRscq9j18MMPJ963VwK8LfLy8vjRj37EAw88cFRtGhgYGJxMdMW1tKqqLF++HIh7CkuS1JVd7FYikUgiXfF0ErmaGH/H06iazk8vHsc1k0dRXl6e+E7069evxbGMRqP4fTUEPBsI+IqIhcsSRvcAshTGZm7AZq7Bau+NKeOPCGJqd2xWC3RdT1SIPNQX7HAFZppEsCYBTBRFIk2VFg+kMOq6nliHruvIzYWvL79sIXx5+xawZvpY5p/dB6vby+ivNjNu5VZyKxtatFvUP4/N548iMPsCks+ZhIJEZWMdle4aQgEvgh4FPYqma0QQ8epBqiq91BW6ia73IW0MIHpbinu6TUS0yUghnZiv7YIA9mQbfUYUMPHSccy4ZQrJ6ca99clMV553T6jYZdBxDLHr5KWyspItW7a0MJk3m824XC4sFgtms5nevXt3a4UaAwODU59jGQfcbncijVHXdfr06UNGRgbffPNNu8uIoojT6cTlch1Ltw0MDAxOCoxqjG3TnsiVmpqKxXL6mHKP/fGf0IFff2cSs84aSmlpKR6PB6fTSY8ePdp9IK3rOqFQiIBvDwHPZoL+fWjRcpobS5kUPzarA5tzADbnWUiW0QjCyeP51CRUHSqARSIRYs0rLB6CLMvIspxYNhaLJTKumpaLqDE8nhqUxQvJWrCYgm/Wo0QPrrO4Zzorpoxg9ZSRKLKJ8Su3MmnVTvI37ERoJifUpzlZd+5Q1k4cyrrRfXCLKnZdwa7KODUTVl2GZobzEUHFrQfwFNUhb3Vj3qxTt85HNNBS4ErOcmGxmfG7A/ga/G0+6LMlWek1rAdnXzyWWXOnkJbT/cKlwUG6oxqjIXadYAyx6+SksrKStWvXtjs9Ly+P4cOHG6m4BgYGx0xXjgNTpkwhPT2dd999t4t6Z2BgYHByY4hdLWlL5Goynj+dRC6Im6+Pu+MZAJ7+/gWcM7w/RUVF+Hw+HA4HmZmZpKSkdGhdaqSYYOVNBMJOAupEwuEYulqXmC4IOhZTCJs9B5tzGFbnRESlx3HZrq5AVdU2PcGi0dZRUU3zNkT81IY91Mb8NEYDKLqApkMMFdXvYfA3mxi+fC391m5GbiZ8NQ7ozZ7Z57Pk/MHsMEUZtWorY7/awohvtmMLHvTmCpllvhnVm+Xn9GPFWf2oS3Vg02UyBDtZgp1+io2epiDpciWpsgdF1LAobhShjtId6Wz9Nov1y1W2f1OOpraM/MrunYliVvDWe3HXetG11pKGxW6m5+B8xs8exYXfm0ZWQWYX7nGDo+W0ErtqampYsWIFoigyefJkkpOTj0czpxyG2HXyoes6ixYtahHRdSgWi4Xp06cbeeEGBgbHjDEOGBgYGHQeQ+yKcyaJXE00eANMvy9e8Oz1n13OwL4F7Nq1i0AggMViISUlhezs7COuR9d19Ia5EFkJpnMRUv6Fpmn4faUE3IUEfHuJhKoSRvdwwO/LImNL6oXdORqT/WxE6eT/3jRFc0UiEbyhAJsb9rHJW8pWfyUNMT+CBkmajFMzk4QJCREFCZsgYxJlnIoVWzhC3srV5C1aRo9vNyDHDqZS7u2VyeLzh7DgvEFUZDoZvWkf563eyaTVu8mp9rToS9nQvvhnz8R65dXknj0ZURAJhUL4fF78np2Eg3shVgxaLQCSGMFmqUOI6ezdXMDGr1NYv6yeok1lLdYrySI9BucjiSKNNW4a9rtbiWMAZquJ/AG5jJ01kgu/O438Abldv8MN2uWUErvWrFnDc889x9ChQ/n5z3/eYtqbb77J9773vYR4YLfbeeWVV7jiiis609RphXGTc/JRW1vLqlWrjjjfOeecY1RfNDAwOGaO5zhQU1NDSUkJgUDA8Ms0MDA4LTnTxa5IJEJ9fT0ej+eMEbma2L6vmht+/zoAnz14PdnZ2ezevZtgMIgkSdjtdgoKCo64Hj34Ebr7XsCMkP4pgtyz1TyRSIiAdzMB9yb8vjLUaA3N0+9kKYbNnozNMQBb8lkoliEn5UPxymADhfXFFDYUsaWxjKAWIaxGCalRIloMkyBjFmVMgoRdV+grppCh21A0kaAWIahGsCCDrhPWVWK+RgauXs/w5WsZULgNuZmotKt3XPhaPmU4kd69uKhWYtI3u+i5+GtMa9a17FiPHjBnTvw1dSqYzUSjUQKBAD5vGQHPdtRoCcRKgXhUmcXkwWZuJBrKZfvaAtavkClcvJf9JTUtVm2xm+k9PH5M6ysbqa2oR4229jpTzDJ5/XMYPX04s+dOpc+IXl267w1ackqJXT/72c945plnePLJJ7nnnnsSn1dUVNC/f/+ECV4TZrOZzZs307dv3840d9pgiF0nH+Xl5RQWFh5xvtGjR5OXl3cCemRgYHA6czzGgY8++oiHHnqIDRs2AHHj+ub+HQ0NDVx//fUAvPXWW4Z/l4GBwSnLmSp2tSdypaamYrVau7l3J4blm/Zy13MfAjD/kZvIyMigqKiIYDCIpmmYzWb69et3WNFJ1xrRa2eDVo/guAfB8eMjthv3+6on4P6WgHcHQX8lmupvMY/JBDZ7LnbnMKyuCchK9zwgj2gxtrnLKawvorChmPJgfULcCqlRREHAIilYJAWzqJBqcpBlcSGLEg0RP+WB+nglSFXFFpVwqSYsuoyu65gQsQkKAhBGA5+bYV9vYNhXaxlQuB2pmfCljRyJcO21CNdeC/36QVUVfPopfPQRLFgAzbUCuz1e/XHOHLj4YsjIQNd1gsEgfn8jfs8WQv4iUEtAi0eLSWIUm7kOq82Cp34gm1dlsX6Zh/VLtuCu9bbYJ8kZTvqO6oUa06gpq6O6pIZopLXHmaxI5PTNZtSUoVxw2xQGjj/8d8ng6OgOsavTBkRffvklAJdeemmLz//xj38QDAYZMWIE7733HhaLhZtuuokvv/ySP//5zzzzzDOdbdLA4LjQ0co0p0MFGwMDg9OPxx9/nAceeOCwVRlTUlKwWq189NFHvPvuu3zve987gT00MDAwMOgsbYlcdrudtLS0M0bkaqLOGwBAFISECCHLMpIkoWkamqYRjUYPW0xK9z4BWj3I/cDesbFQEASs1jSs1tmkZc9GVVVC/l0E3Ovw+/YSDtYRicSIRCpobKhAEOZjsdixOXphd43GkjQGUTx+Ba5qQh4KG4oorC9mc+M+PLFQQuCK6SomUcYqmXAqViySQpYlGbMk44uGqA55qA97CajxKK6wFiWmaQdj2AQdq6CQqVvJxI4KyIhkyA4y0jIwXTqUyiu+iycQJG35ctKXLMH17beIGzbAhg3wwANEhg8nevnlaFddhXLjjZhUFXHp0rjw9cknUFEB778ffwkCnHMOwqWXYpszB9uQIWRk5BKLxfD7/fg9ewh4txOLlOANmvAGdWA/QyftZvyMAFZHb/bvO4/1K2wULtnDpmVbaazxsHbBxsT+yu6dSb/RfYhFIlQWVVO5Zz+RUJRYVKV0ezml28v5+PkvkGSRrIJMRkwewoybz2fE+Sdn9J5B+3Q6sisvL4/9+/cTCoVamHaPHz+edevW8eGHH3LJJZcAsHHjRkaNGsXQoUPZtGlT1/T8FMWI7Dq5CIfD7Nu3j927dx+2lK/h2WVgYNBVdOU4sGrVKs4991xkWeaJJ57g5ptvZujQoVRXV7c6p7333ntcc801XHvttbz55pvH1K6BgYFBd3GmRHZFo1Hq6uoMkasZ/5r3DX/98CsUSeSzh28iLS2NiooKvF4vqqoiSRK5ubkkJSW1ubwe+Ra9/kYAhNT/IJjGdUm/YrEgAfca/N5NBL2lRCK+FtNFUcRqz8Ce1B+bczxmW+9juqeIaSo7PBUUNhSzrm4vxYFaQmo8PTGsxeLRW6IJi6SgiBJppiRssomgGqUx4kPVdQKxMAE1TERTUfWmiCw9IXIJgCiImESZJNnCsOSejEnpRX9rFlnYCPmDRKPRRJXLcDiMpmmIoojc2Ejy0qWkL1mCc80ahGbXI8Fhw/BdeCGhOXMQ+/TBpChYt23DsmAB0mefIRyabdO7dzzi69JL4bzzwGRKtOn3VeN3byIUKEKP7Ut4rIliDJupAZsjFbNlGHu29qZwmYf1izezbdUu1FjL66M+IwroP7YPoUCY8p2VlO6oIBwIt9rvoiSS0SONYZMGM+2GSYy7YCSiKHb6OJ5pnFJpjBaLBYfDQW1tbeKzYDCI0+lEURQaGxtbqOoWiwVFUfB6vW2t7ozBELtODnRdp6GhgYqKCjRNIxQKUV1d3e78Y8eOJScn5wT20MDA4HSlK8eB66+/nrfffptf//rXPPTQQwDk5OS0KXbV1taSmZlJ//792bFjxzG1a2BgYNBddMU5NBKJJLJN7rrrrsNGAp1ootEo9fX1uN1uQ+Q6hD++u4zXF63DapL5+MEbSU1Npbq6moaGhsQ8aWlpbXrs6noEvfZSUPeC9VpE16PHrZ+RUAUB92r83u0EfPtbjceyYsPmyMWeNBSrczwm85GtBerDPtY3xL231jeU0Bjxx6O3tCiarmMSZSySgkmUsUkmkhQrUU3FGwsS0zQCsRBBLUpUjRGP2xI4VNySBQmzJJOs2BmT1psRyQUMcubRx5GJLEot+qPrOuFwGK/Xi9frJRqNomlaogKkIAjIsozS2Ihz0SKSFyzA/s03CNrBVMfg8OF4Z8/GO3s2sQNWMZbaWpxffolt8WJMy5cjhJuJTk4nzJ4dF78uughSU4G4Cb/P5yXg2YLfu5NYuAS0g5U1TYofu0XF5hwAwhi2rkmhcPEOChdtYu/GkhbbJckSg87ux8Bx/Qh4gxRv2UfJ1jKC3taFzARRID0vlSHnDGTq9edyzpyxSJLUaj6DOF153j3uYpfD4UhUdmjiyy+/ZMqUKUyaNCmR5thEeno6fr+/lZfXmYYhdnU/sViM8vJy3G43EL+A6NGjB3V1dWzZsqVFVUaLxcLQoUMNocvAwKDL6MpxoGfPnpSXl7N///7ExX17YheQeNp9pj94MjAwOHU5Xa+lDZHryPzm5Xl8snobTquJD359AykpKdTX11NTU4MkSaiqisPhaNNjV/c9h+57GsQ0hPR5COKJ8a7UNJVwYCMB9zoC3j0EAx40vXlUl4jJkobdUYDNNRKrYxiyLKPqGru9VRTWF7Guvoid3sqEuBXRYoiIWA+IW5Ig4TJZ0XQdfyyUiNwKa1GimtpM0jposS8ioIgSJlEhy+LirNS+DEnJZ5Azj3xbKqLQ8Yilpkgrr9eLz+cjGo0mqkBGo1FEUcRsNmPxeHAuXIhr/nxMq1a1EL5CI0fiaRK+Dtx3CYEA9pUrsS9ZgmPpUuS6gwKWLkkwcSLCpZfGxa+BAxN9CYfD+L378Ls3EvQXo8fKaTK5FwUVq9mD3ZGD3TUKv380G1c0ULhoE+sWbaKqqGXwg8VuZvj5Qxg4vj8Bt4+da/dStGkffneg1X4QBEjJTmHQ2f2Ycu1EJl15NopJ6fB+NOg4x13sGjZsGNu2bWPVqlWMHz8egHvvvZc//elP3Hffffz+979PzKuqKhaLhdzcXEpKStpb5RnB6TpAHw9UVWXz8u3UVTaQlpPCsPMGdVgtb29Zn89HaWlp4olDVlYWGRkZiVBiXdepq6sjHA5jNptJS0szUhcNDAy6lK4cBywWCxaLhcbGxsRnhxO70tPT8Xq9hMOtw/MNDAwMTgVOt2tpQ+TqOPc89yHLNu0lPcnK2/dfR3JyMh6Ph8rKSmRZJhaLoSgKffr0abGcHitGr70EiCC4nkKwXtI9GwCoMQ8h7yr87o0E/KWEwyr6AfHLp8GumI3dup2tERGPJhDWNMJaFI149JZJVBABh2xBEARCsQgxtANpjDFiesuxv+lGX0JEkSQsokIvRwbjUvsyyJXHIGcuGWZnl93vNBe+vF4vsViMWCxGOBwmFoshSVJc+GpsxLVoEa4FC1BWrkRoJknExo8nOGcOvtmzCaalEY1GQdOwbNqEY/FiHEuWYN65s0W7sb59ic2ejX7JJShTpiCZzQiCgKqq+P0NBNwb8Hl3EguVgn7wgZ8iB7DbTNicg7C7JrC/Ip/1i7dRuGgj6xdvprHG06IdV3oSo6YNY/A5A/A2+NiyYgd7NhTjrW+ZutpEcqaLgeP6Mumqs5ly3blYrIYHdFdw3MWue+65h2eeeYZx48bxl7/8hcrKSm655Rb8fj/Lly9n4sSJiXnXr1/PmDFjmDBhAl999VVnmjttON0G6I7QGdFq+furee7ul6gtO6jgp+en8ZOn53LelWd3YtlUrn/wCnqNzwXiZvM9evTAZrMdw5YZGBgYHD1dOQ6kpaXh9XoTZdehfbHL5/ORnJxMRkYGlZWVx9SugYGBQXfRFedQVVVZt24dAGPGjOmW1KO2RC6bzUZaWppxfdoO3//j26zbXU5eqoPX7rsWl8uF3++nrKwMRVHiogjQr1+/xDHVdR294TaIfA2mSQgpL540D7JVTWV3QyHfVK1kTX0Vu4IqYV0goguoxFMLTQhIoogiKZglK+EDHlvhAxFeqq7RtDXNUxIlQcIkStgkM4OcuYxM7cVgZx4Dnbm4TCfm+9VUUbF5xFdz4UtRFEwmE5aGBlKWLME5bx7yqlUthC/OPRft6qsJX3IJkYyMRGaZumcP5gULcCxejO3bbxEOHHsA1eUiMHky4QsuQJ05EyU9HZPJhMlkQlVVAt6dBDxxsVGPVSX2nCBoWM0h7Ek9sLtGI9smsm9b4EDU10Y2LttKyN/yYWFWQQajpw9n6LkD8dZ5WbdoM7vW7mlVEbIJZ5qD/mP6MPHys5hx03nYks6c33pXnnePu9hVXl7O8OHDE6lgEP9CT5s2jYULF7aY97HHHuM3v/kN99xzD08++WRnmjttONPErs6IVsvfX80j1zwJh34zD5zJf/POvZ1e9tYnr2bKNeeSk5Nj5FQbGBh0C105DkycOJHVq1ezZs0aRo8eDbQvdr322mvccsstzJo1i88///yY2jUwMDDoLk51g3pD5Oo81z/2GjvKauiX7eKFe67G6XQSDocpLi5GkiREUSQajbZ4oK0HP0R3/wIwI6R/iiD37NZt8MVCbGwoobC+iFV1u6gN+wirceFK13VkASQ0QEXWdWK6gAbEEIgBTdJW3HGLA/8LKKKISVRwKlaGuwoYlpLPYGce/ZNysMrd70nXXPhqiviKRqOEw2FUVT0ofNXXk9pM+EogCDBpElx7LVx1FeTkJDzCIrW18MUXyJ9/jnnRIqRmHm66LBMYNw7ftGn4p05FLShICF+KoqDGvESDWwgFdhMLlydM7gEUKYTN7sTuHIQt+Vx0oT87vt1D4cJNFC7exLZVO4lFW15r9RrWgzHTRzBs0iA89T5WfbyWHWt207C/sfX9KeBIttN3ZC8mXDaOmbdOwZni6Opdf9JwShnUA2zYsIGf//znfP311yQnJ3PJJZfwxBNP4HIdzIHWdZ3+/fuzd+9ePv74Yy6++OLONndacCaJXZ0RrVRV5abed7QQxw5dNiM/jX/vfbaVWNWRZdNyU3m9+DlD6DIwMOg2unIcePzxx7n//vu5+uqrefvtt4G2xa6ysjLOOeccKisr+fvf/873v//9Y2rXwMDAoLs4VcWuWCyWELm0A15Fhsh1dFz2m5corWlkREE6f7njcpKSklBVld27dwPx9E+/309mZiYpKSnoWgN6zWzQGxAcP0Nw/OiE91nXdfb5aylsKGZV7U62ussJqhFCahQNDUEHSZQQBQERAQ0dTddRNZWorrbhtgUiIAMmQcAlyQxzpDMsbTgjMvrTz5mNIsonfDuPBl3XCQQCLSK+mgtfJpMJs9mMta6O1CVLcHz+OfLq1QdXIAhw/vlwzTVx4Ss7++A0VUX76iu0jz5C+PhjpEPSHcP9+uGbOhXf1KmERo6EA/eEgiAgiqBHK4lFi4iFKxGpQRKjB6brWMwa9qRe2F1jMSdNIBwU2bx8G+sOiF971he3aEuURAad3Z/R04Yx/PwhNFa7WfH+arat3kl9RSNtyTA2p5Xew3pyziVjuWDuVFKzkrtkn58MnHJiV0dQVZWysjIA8vLykOWT+8d3vDlTxK6OCk/PbXgcURTQNA1N09i8fDuPXfXMEdd/35s/YdCEfi0+2/71bp647rkjLvvk4ocYOWVoh7bDwMDAoKvpynHA5/MxePBgKioquPHGG7nvvvuYOXMm1dXVhEIhiouL+fjjj/m///s/ampqGDhwIBs3bkRRDMNUAwODU5NTTew6nMhltVpPmpS6U4FZ//MPatx+zhmQwxO3X4LD4UDXdXbt2oWu64nvhcvlIjs7G819PwTfBbk/QtoHCMKJiXAKxiJscu9jTe0evq7dRXXYTViNxsUrXUcSRERBTIgdOjqqrqHqWlvBP0iCGK+2KApkKTqDTQF6CF7yBYVMUUcUAEQEORurLR+bcwi2pEFYrbaT/vul6zp+vx+fz5cQvsLhMJFIBE3TMJvNmEwmbHV1pC1Zgv2zz5C++ebgCgQBJk+OR3xdeSVkZbVsYPdu+Phj+Phj9C+/RGj2IFBNTSU4dSreKVPwTpiA7jgYVaXrOtFII7FwJWqsBl2tQxJDSGIEWYpgkkPYHak4nIOxJU9CNvfEXeth/ZItFC7cSOHiTVTs2d+iK2arieHnD2b0tOGMmDKE+spGlr75FVtW7qCmrA5da330LQ4LBUPyOevC0cz+7jQye7SuNHqqcNKKXSkpKeTk5LB169bEZ6+++ipWq5Vrrrmm0508EzlTxK4NS7dw77SHjjjfj/95M/3G90q8X/f5Zl7/1QdHXO7G31/BmAuHtfiso8v+6vW7mHb9pCPOZ2BgYHA86OpxYP369cyaNYuampp2L2p1XSc3N5dFixYx8EDFIgMDA4NTkVNF7GpL5LJarYlIrpNdhDgZmfLz5/AEwswY0ZMHb5mdOG579+4lGo2SlpZGXV0dFouFnjn70etvAkBIfQPBNPa49UvXdSqCDayrL2JFzXa2uMsIxMJEtBiaHj/2kiA289cSUNHQ2rgNFwBZkDBJMlbJRF9HJsOSezLImccgVx6ZB8zkdc2HGvwav3stAd8uAkGIxppFCApWRCUfm6MXNucI7I4cTCbTSf290zStVcRXOBxOFNVpEr7stbVx4evTTxHXrDm4AlGEKVMOCl8ZGS0baGiAefPi4tfnn0Oz4j66yYR6/vmEZ87EP20awQP+YE2/XVUNEw2VEwnXEo14QI8iitGE+GW1QJIrh+TUkVid4xBFhf0lNQm/r8JFm2msdrfojjMtiZFThzJ62nBGTh1KTWkdi177kk0rtlFdUoumahyK2Waix8A8xs0ayezvTiOvX06X7PsTQXeIXR0Ks3K73a2qgdx2223k5OQYYpdBm9RVNhx5JiDsjeBwOBBFEUEQyOvdsR9srwE9yW4esgr0GuBpZ+6WpOWkdGg+AwMDg1OBUaNGsWHDBh544AHeeOMNQqFQi+kmk4kbbriB3/3ud63OmwYGBgYGXYshch0/IrF4VE6SRWmxH2VZJhqNIooiAOFwEK3xN3Fhyfqd4yJ0hdUoW9xlrKrdydc1u6gKNRLWosS0A6mHiaituIAV0VX0NuK24n5bEmZRwS6bGZSUy9CUHgxy5jLQmUdyO2byguhAts/EZZ+JU9dBLSHqW4Hfu5GAr5xAKAk1sgtf/S589QtAzEA252NP6o/NOQS73XXSZVyJoojD4cDhcKBpGn6/PyF8NRnTe71efBYLDZddhvnaa3HU1pK2eDHWTz5BXLsWFi+Ov+64A6ZOjQtfV1wB6emQkgLXXx9/RaPw1Vfw0Ufw8ccIu3cjL1yIvHAhdoARI9DnzEG96CLCw4cTicWIRLIS4ls4WEUkVEk00kAgHCIQ1qlzh2DfahRpJVablSRnPuMvHcHk6yegKAql2ysSfl8bl23FU+dl+burWP5u3Jsss2c6o6cN57aHr2PUtKFU7qlmwb+XsWHZFqqKqlGjKuFAhN2FRewuLOLNx/+LYlHI75/DmBkjmPXdqfQe2r2edCcbHYrsMpvN2O126uvrE5+Jokh2djYVFRXHtYOnG0ZkV0sOTSlMpD+W17Vp4tchz65OLGtgYGBwojie40A4HGbt2rVUVFSgqirZ2dmMHz/e8IMxMDA4bThZI7tisRgNDQ00NjYaItdx4qyfPkNM1bhtyhBuv/T8RDBGeXk5Pp+PzMxMamtr0UKrKUj+IyazFSH9cwTRdYQ1d4z9ITdr6vawrHorWxvL8KthwmoUHQ5EcMVt44UD3lttISJgkmQsooJTtjIspSeDD0Rt9U/Kxiabj7mfuh5BD68l5FtFwLONQMBHKJKMph+4/xEUkPIxW3tgSxqCPakAq9V60t4fHSp8NaU5RiIRRFFMeHy56upIWbwY60cfIRyo+gfEfbmmT48LX5dfDmlpLRvQddixIx7x9dFHsHIlaM2iqrKz4eKL4dJLYcYMdKsVVVWJRCKEw2H8/lr87h34fVWEQgF0vXlEloAsmzGZUrA68rA5emI2m5FEiX2bK9j85XY2LN3C1pU7WpvdD+3BqGnDGD19OCMnD6F8dxVfvLKUwkXxFMlYJNZqX8kmmdy+WYyaOowLbpvKwHF9j/0AdBEnbRpjQUEBZWVlbN++nf79+wOG2NVZzhSx61iEp4SxPbRc9miqMXZiWQMDA4MTwZkyDhgYGBgcD042scsQuU4cY3/yJ3Qd/t9Fo7hu5gQsFgsA+/fvp7GxkbS0NPzeEoL1/yYndS3O7F8iWC/pdHtRLcbWxnKW12xjVe0uKkONhGKRAyby7clZLZEP+G1ZJRNp5iSGJfdgkDOPwa48+jgyT4iZvK7WoIW+IuhdQ8C7h0BIIRx1ousHvpuiC0HugdXeC1vSUOyONCwWy0n53dU0DZ/Ph9frxe/3EwqFCIfDRKNRJEnCbDZjNptJrqsjZeFCzB99hFBYeHAFsgwzZsTN7S+/HFJTWzdSWxtPc/z443jao9d7cJrFEhfO5syBSy6BvLwWi0ajYTz16/A0bMHnrSUU1oipJjQ9fpxFQUYxJ6GYsjBZ8xBFU/xeWIWiwlK2f72bzct3ULRhXwsDe1ESGTi+L6OnDWfMjBEMnjCAit2VzH9pKWsXbKB8VyWRULTVpkiyRHbvDEacP4QLbp3C0HMHddtxPWnFrrlz5/LKK6+QmprKtGnTcDgcvPzyy1itVr7zne90uFOCIPDiiy92eP7TkTPpJmfJ21/xu+ufjr/phGj13N0vtTC4z+iRxo//NPeIYtWxLGtgYGBwvDmTxgGD04MpU6awbNkyHnzwQR566KHj1s5tt93GK6+8wq233srLL7983No5WWi64ViyZAlTpkzp3s6cQnTFOTQSifC73/0OgPvvvx+T6eiNy1VVpb6+voXIZbFYSEtLw263n5RCwanOmB//CYAHrz6b2ZPGYjbHo6Dq6uqora3F5XKh+/6E2x0gNcVORu/fH/VxqA17WV27iyX7t7DVXYYvGiKqq6h6a/+kQ2ny2zJLClZJIc+SypADKYmDnXnk29OQBPGot7sr0XUNYttQAyvwezYQ8O8nEE5u5vclgpSDpPTAmtQPm6M/DocDRVFOuu+0qqqJiC+v15tIMYzFYsiyjMlkwmKxkFJbS/KCBZg+/BBhw4aDK5BlmDkzHvF12WXxNMdDiURg2bKEyT3FxS2njx0bF74uvRRGjYob5jcjGi7F37gSr3s7Po+HSMyMqpkOvMwIkhOTKQ3FkousJCf2sa8hwJ41xexaXcT2r3dTtbemxXrNVhNDJw06IH4Np++oXlQVVTP/pSWsmb+BfdvLCAcirTZHlEQye6YzfNJgpt04iTEzRiTSf483XXHebaJLxa7S0lImTpxIeXl5pzojCAK6riMIQotS6GciZ9JNTlVVFQvfWMZHf1hAQ9VBQ76OCk+qqrJ5+XbqKhtIy0lh2HmDOhxeeyzLGhgYGBxPjuc4EAwGaWxsJBpt/XSvOT17Gp4OBh3HELuOD4bY1Tm6+1raELm6h0AowqR7ngXg6blTOGfU0MTNstvtpqqqCrtpGzb1r1S7h+HImEt+z5FHXG9MU9nuKWdh5Wa+rd9NeaCekBptNw2xOQICiiBhkRVskpkCWzpDkvMZ5MpjsDOPLIvrpP8+6JoPIquI+L4m4NtKIBAjEE5D1Q5UbRasIPVEsfTAljQYuyMbm8120vl9qaqaiPhqLnypqpoQvqxWK2m1tTi/+ALlgw8QNm06uAJFgQsuOCh8udpIfdV12Lz5oPC1enXCmw2A/Px4tNecOTBtWjwKrBmaFiTk/Rq/uxC/p5hwREfTRFRNQdVM6EIKkpKFpPRAkLMQm0X91Vc0smPVHnau2suOVXvx1HhbrNuRYmfUlKGMmTGC0dOHk9c/h9qyOua/vITVnxVSsqWUoK+lpyuAIApk5KcyeMJApl0/ibMvHnNK3DN3qUF9jx492LJlC2+88QabNm0iEAgkIruuvfbaLuu0wemDpmnU19czYvpgLrr1Ako3Vhy18CRJUgs/r6PhWJY1MDAwOJXw+Xw88cQTvPnmm+zZs+eI8wuCQCzW2ufBwKC7ycnJYeDAgeTknDrVpQzOHFRVpaGhgYaGBkPk6gb2Nxy8uU+zt0yxkyQJ9CAx3zzMTi+C6SwisaR219UY8bO8ejtLqjazxV2KJxpE7YC4JQoCJiGekmhXzPRPyolXSXTmMtiVR7Kp66t6Hm8E0QGWGZgtMzCnQ3KsBD20nJDvWwK+YgIhO6GIj6hvB27fQtxiOsg9MVt7YXcOxGZzYrPZTlh0UHtIkoTL5cLlciWEL4/Hg9frJRQKEQqFCAQCuBUF85VXYrvpJtKqq3HOn4/8/vuwZQt8+mn8ZTLBrFlx4evSS6FJTBEEGD48/rr/fti/Pz7/xx/DF19AWRk8/3z8ZbPFxbM5c+J+X1lZiKIVm2saNtc00nWdWGgHAfdK/J7tBAINxFQf6KUQWYMesSCY8jBZ+iBbBuIYkE9O7ywmXjUOTdOo2l3NjlV72bFqD7u+KcLX4GfFB9+w4oNvAEjNTWHklCGMmTGcB9+7l/TcVBqrG5n30lJWf7qWvRtLCHiC6JpO9b46qvetZNlbKxEEgdScZAafPYDJ35nIuVechaKcXMLm0dChyK62MDy7Okd3P406UTQ0NFBaWoqiKAwa1H25wQYGBgYnG105DlRXV3P++eeza9cujmY417Qjp2MYGDRxoiK7zjSMyK7O0RXnUE3T2LZtGwCDBw8+7I16k8jV2NiYyFAxRK4Tz+rt+/jxM+8B8MbdF9G3b99EdFEoFKJ457+QtUIKcqvZ2/A4INKvXz8kSULVNbY1ljO/aj2ranZRHqwn1oG0REkQMYsyVtmMU7YxyHVQ3BrgzMXeBWbyJzO6HoFIIWpoOUHvBgL+BoKRNMLRpLjf1wGje1HqgcXRD3tST2w220nl9xWLxRLCl8fjSZjb67qOLMuYzWaSkpJIraoi6fPPkd57Dw6cGwAwm2H27LjwNWcOJLUjooZCsGRJorojzTPiBAHOOisunM2ZA8OGtUp31NQGwt6v8LvX4feWEYqYDnqqISDKmdgcPbA5R2Cyxj3Um7YlGAiye10R21buZueqPexdt6+V2X1Ov0yGThrIyKlDGTl5KCmZyYT9ERa9tpyvP1rD7vVxwawVAqRkuhg4vh+TrjqHqd+ZiMnSufTDoznvHokuTWP0eDyJUqBNTJ06lbS0NN59991Od/JUwufz8eSTT7JmzRrWrFnD/v37OxVmf6aIXbt37yYQCJCVlUVWVlZ3d8fAwMDgpKErx4Hbb7+dF198EZvNxs9//nNmzZpFVlbWEdMLCgoKjqldgzMLQ+w6PhhiV+foaoP6iooKXC4XVqu1xQ26IXKdXLy1vJD/+89SAM4Z4eLnV84kKGymMVJLkh5AqNgNSPQZeAVVtWl4/F5KJC/L3LtY59tHSD98ej/EzeQtogmbYiZVsTPYFa+SOMiZR9+kLEwnwEz+ZEZXayHyFbHAVwS82wiEJALhdKKxeFVMRCdIBUhKT2xJ/bHZU7Hb7Yf1+9J1FSJrQKtBF9IJqkNR1bgQdehv8liJxWKJNEe3250QiwAURcFkMuFyOkmtrMTx+eeI77wTr9LYhNmMftFFhC+9FO/kyeh2O3a7vXUhCl2HtWvh2Wfhyy9h796WHSkoOOjzNXlyPJKsxT6JoYbW43evJODZid8bxLSmHqk2gJpuIzBmACZ7T+zOAdhcY7DbUxAEgWg0SiQSwdvoY/NX29m0bCtbV+xk35aKFg9EBVGgx5BcBk3sy7DzBjHonP44nHbUsMrK/65l9cfr2F1YhKe2ZapkE9YkCz0G5jFr7hRm3jIFq93S5ny6rhMMBhMeaqFQhLS0uC/aa4+/wzX3XIbJpHTw6LWkS8UuURTJyclp4dn18MMPk5SUxM9+9rNOdfBUo7i4mN69e5OTk8OYMWP49NNPDbGrHQKBALt370YQBAYPHnzS5XQbGBgYdCddOQ7k5ORQXV3NW2+9xdVXX91FPTQwaMmRxK5XXnmF73//+8RiMe6//34ee+yxTrVzOM+u5n343//9X/7yl7/w6quvsmvXLmw2GxMnTuThhx9m5Mi4R08gEOCpp57izTffpKioCIvFwowZM/jd735H376tS7G//PLLzJ07l4KCAoqLi1mwYAFPPfUUa9aswefz0adPH66//nruvffeRAW4Y6W52DV27Fj+7//+j3fffZeSkhJsNhsTJkzg17/+NWef3b7HaSgU4vnnn+ftt99m27ZtBINBsrKymDx5Mj/72c8YNWpUm8v16tWLkpISXnrpJa699lqeeOIJ3nrrLUpKSkhOTmb69Ok88sgj9O7dG4Da2lr+8Ic/8MEHH1BaWorL5eKSSy7hscceO+xDzT179vDkk0+ycOFCysrKUBSFfv36cfnll3P33Xd36hzYFefQqqqqRLrs+++/T69evXA4HGRnx/2IDJHr5OKCvzxD7VaVRJWrA/ToI5A53E+mbmeInoFDFPFIFmLhGKDjJYKXCLVCkB1iPbVCMLGsACiijFlUcMhmMsxOhiT3YLArl0HOPHra07vdTP5kJm50vx09tJyIfzUBfxnBsKuZ35cIUjaC1BPZ0gubozd2u6OF35cemo/ueQy0KnzBTKoahuMLF6BJw5GU3MRvMqm9aKpjIBqN4vP5cLvduN1uIpFIwu9UURTMZjMpycmkVlRg++QThLffhl27EsurJhN1Z51F7bRp6BdfTM/Bgw/28/334a674mmNTSQnQ9++8XTJUDPvrKSkeMrknDlw0UWQnt6yo++/j37XTxHKKg/2PdPO/nvPxzetLyAhKnlY7QXYXaOwJxVgMpkS5yktOI/6oj/y9SIra5ZlsvPbCLWlwRZNKGaZPqN7MnBiXwae05ceQ3IxW8ygwbrPNrPmsw1sW72LgLvlck04Uuz0G9WbiZeNZ+Yt5+NIduD1eqmqqsLn86GqKvP+upQl/17JYu0DACYyG4fs5Kp7LuEHT9x8FEcuTpeLXYemLLYlgJ3OhMNhamtrycvLIxQKYbVaDbGrHUpLS2loaCA5OdkwQTYwMDA4hK4cB2w2G7qu4/P5TglDUYNTk8OJXY8//ji/+tWvEEWRP//5z9xxxx2dbqcjYtf999/P6tWrWbRoESaTCUVR8PvjqRcOh4MlS5bQu3dvZs6cSWFhYSKdJhiMX6RnZmby7bfftro+aS523Xffffz0pz9F13WSk5Px+XwJn7vRo0ezaNEiUtqq2nWUNN2M/Oc//+E3v/kNu3fvxmKxIIoigUAAAJPJxMcff8wFF1zQavny8nJmz57N5s2bgfgNms1mw+2OFwUSRZGnn36aO++8s9WyTWLX008/zYsvvsimTZta7aucnBxWrlyJpmnMmDGDoqIibDYbsVgsEQ3Rv39/1qxZ0+a57O233+aWW24hHA4DkJSURCQSSbzv0aMH8+fPZ/DgwUe13471HOr1etmyZQsTJkwA4LXXXmPkyJEEg0F0Xcdutyduxs1mM2lpaTgcDkPk6ibaE7oA0h0KFwxPRU6NISOiIKEgYkNBR6cKP7WEcAkmAsRYL1UTMOkkyWbybGkMcuYx2JnLIFce2ZZk4xgfA3Gj+9Vo4eWEfYUEAiEC4TSCkRR0XTxgdN8DQe6J2doXm7kUa/RRrKZ6AuE0iqvPIxJ1YDE1IIkRVGUWoWgWJpOJ3r17HxfBq4km4auhoSGR6tgkdCuKgtVqxWqxEFi1Csfnn5O1bBm2ZhqIajbjmTQJyy23YJVluOmmlsb1cDBt8fXXwW6Ppzp+8glUVR2cRxRh4sS48DVnDmzdCtdc02pdTdmNjc9Mpf68PkRVa7N1pKFY8rE7B2Eze7BG7iUYTm2xfz01QbZ/o7Lt22T2rNmPt9bXYv1Wp4X+43szcEJfBk7oS+Xu/bx495t0wNYOAJvTSlbfdAae24eJV41j2b9XsehfX6HqMZbwXwDGMYVkIS7sXXPvpUcteHWpQb3JZEpcSDSnk3ZfpyRms5m8vLzu7sZJTywWo7GxEYD0Q5VpAwMDA4MupUePHlRUVBhCl8EJR9d17r77bv785z9jNpt57bXXTkh04XPPPYckSbzzzjtcdtllyLLMmjVruO6669i7dy933XUXWVlZNDQ0MH/+fGbMmAHEo6euv/56qquruf/++3nttdfaXH9NTQ133303V199NX/84x/p0aMHwWCQV155hbvvvpvCwkK+973v8f7773fZNt1xxx3k5OSwePFiJk+ejCAIrFmzhptvvpkdO3bwgx/8gL1797bwN1FVlauuuorNmzfjcrl49tlnueaaazCZTIn98Mknn3DXXXfRr18/Lrzwwjbbfuihh0hOTuaLL75g+vTp6LrO4sWLufHGG6msrOSXv/wlxcXFuFwuvv76a8455xyi0SgffPABc+fOZdeuXTzxxBM8+uijLda7bt06brrpJqLRKOeeey5/+9vfGD58OJqm8emnn/LDH/6Q0tJS5syZw/r161tYpRxPdF2nqqqqVcXaWCxGNBpN3ORmZ2eTnp5uiFzdTE3Q067QJQCDsxyoIQFFF4gIGi4s6Oi4CePCTApWGqQoUVGgQEplUFIPevbuxSBXHqnmE/OdO1OIG91PR7JMx+YCa2wfaZHlqMGvCPq2EAjZCEb2EwrtJBRaSAgRGANoeIM5RGMOkqxlyFJcDJfVFTgct+Dz+amqqjquv0VFUUhJSSElJYVIJNJK+Gqq9hlNS0O4+WaKv/c9kouLyViyhLTFi7FWVJCyaBEsWoQuCAhtaSS6Hhe8fvlLKCqKpzBqGqxZc7C644YNsGJF/PXLX4IktRbNAEEHBIHkP+zG9f2/Egl+hd+zkYC/jkBYIxqoozGwgUYApuENZhON2XHaypClCKnZIhMvFZlwqYBP+zHBuij1uz2sX7yJ9Uu24HcH2LhoGxsXbTtwbIXDCl2KRcaRbKdxvwdd1wl4ghQVllJUWMq8vy474v5/70+fcNuj13U6pfFwdCg2Mz8/H5/Px9dff93lHTA4vaivr0fX9bgCbrUeeQEDAwMDg05z+eWXEwgE+Pbbb7u7KwZnEJFIhOuuu44///nPuFwu5s2bd8LSaBsbG/nvf//L1VdfnfCBGT9+PP/85z8BWLlyJfPmzWPBggVccMEFiKKIKIpMnz6dxx9/HIinrR0qdjQRCASYOHEib775Jj169ADAarXyox/9iGeffRaADz74oEt/c7Iss2TJEqZOnYooiolteueddwAoKSlpdQ3+7rvvsnr1aiAeQXXjjTdiOuD70qdPHz744APOPvtsdF3nvvvua7ftcDjMggULmDlzJqIoIkkSM2fOTOyrt99+m5KSEhYuXMg555wDxG8Mr732Wn7+858D8Oabb7Za7wMPPEA0GqVfv3588cUXDB8+HIhHm82ZM4dPP/0UWZbZs2cPzz///GH3TzgcTphLN706y969e/n2228pKipKfLZu3ToKCwvZsWMHjY2NCIJAZmYmSUlJhtDVzfzkrTdoS+gCcFllMhwm3KEY4UYR04GoLh0wCxKKIJMqWTnP1Y+Lc0czPnsAA02ZjHL0MISuE4Ag90Sw3Yic9hyOnvPI7P0bevYaQZ/8KnJSN+Cy70ORg0RjNvyhDFRNwhPMp97Xm0A4FXQfglaJxWLB5/MlIk6PNyaTidTUVPr27cvQoUPp168fKSkp6LqOrutomkYoHKY6L4+dc+ey9s03KfznPym57joiqaltC11N6DqUlsLy5fH3ohg3rv/tb2H9eigpift8zZoFsgyqeth1CaWliKursaTeTlqvv5A/+Dn6DZxNbq6LZPt+THKAaMx6YP/KuAM9aPAVEFPjqfgCPqxmD0lZNi747mQeev8+3qv5F39Z9Tu++9gNjJo2DEmR0LXDBzhFQzFu/r+reGbzw/zw+ZsYPnMgyTnOuEgGhPUgHr0B7wH5DcBLIx69AY/eQDDm5+Pn5nfk8Bw1HYrsuuiii/jrX//K1KlTGTFiROLpS319PdOmTetwY4IgsGjRos71lPgFyLJly1i7di3r1q1j7dq17Nu3D6DDpqler5c//vGPvPfeexQVFSFJEgMGDOC6667jzjvvTFwoGBw9uq5TV1cHxKO6jAsEAwMDg+PLfffdxzvvvMOPfvQjFi1aRHJycnd3yeA0x+PxcPnll7NkyRJycnKYN28eI0aMOGHtT5o0iUmTJrX6fPLkyZjNZsLhMFdffTX9+vVrNc+sWbMACAaD7Nq1iyFDhrTZxv/+7/+2WSVq7ty5PPTQQ5SVlfHmm28yfvz4Y9yaOD/4wQ/IzMxs9fnw4cPp3bs3RUVFbNy4kXPPPTcx7a233gJgwoQJbaY4yrLMgw8+yEUXXcTmzZvZtGlTQnBqzlVXXXXYfdXUv7S0tDbn+e1vf8uePXvw+/3Y7XYgLkjOnx+/cfnFL36BzWZrtezo0aO58sorefvtt3njjTe49957W83TxO9//3sefvjhdqcfDS+88EJCyGviqaeeSvw/d+5cbr75Zvbu3YvT6cRkMmE2mxN/ZVk2rm9PIHUNgXanmWQRWRSIxDR8XnC6JEQRJASsgowZCVEXkMMaPs0Tr8qoqrjdbsxmsxERfQIRBBOYzkIwnYXiUJE9j5AUfANdhwZfb7yhbBQxREyzoukiwUgKUdVGkhJAUiTC4XAilfxEYjKZSE9Px2Qy0djYSCAQSAheuq4f7NOgQTT27Utk0CD6d6SIS2Vl25/37Ak/+Un89a9/wfe+d1TrEsRkJPscnPY5OJyvg/dh6r298QZzkKUwMdWCpstEYnZkKe4bJokhwlEtsS2SLDHorP4MOqs/1//qCr54ZQl/mPvcEbth0i3k5eVhn20ne0gasiyjqipvPvAxny77iCK2tZh/B+sT//dmMBV79h95WztBh8Suhx9+mOXLl7NhwwbWrFmT+DwSibB06dION3asg8M333zDRRdd1OnlS0pKmDJlCsXFxUDc6yQcDicqLL7++utd5sNwJuL1eolGo0iShMvl6u7uGBgYGJz2pKWlsXDhQm644QaGDBnCD3/4Q8aNG3dEb4vzzz//BPXQ4HSisrKSyZMns379egYMGMD8+fPp1avXCe3DWWed1ebnkiSRnp5OeXl5uyJUcyP1hoaGNueRZZnzzjuvzWmiKDJlyhRee+21FtfDx8rhDOhzc3MpKiqivr6+xedN7TelabbF1KlTEzf4a9asaVPsam9/Nt9XHdmfjY2NCbFr3bp1CauTw/Vv5syZvP3222zcuJFoNIqitJ3C8qtf/apFQSyPx5OIujtavv/97zN8+HBisRi33norAPfffz/Dhw9HVVWcTmciui4UChFqbiRN/HvWJHw1vUwmkyGcHCfSUmw00rbgFYlpxDQdkyziD2ns2q2RZNFJtsskOyBmDiMjEQjFMEdkFFFCFiWqqqrweDxYLBbsB6rpNfnVGRw/9Ng+9OB7EPwAtLhPlSCAxdSIRfFgkv3IUhWRmB1/KJOYasbtlTFbg4ii2K0Fz2RZRlEUJElCURQ0TSMSiRCLxVBVNeFhqB6mWEcLDhTHOCx9+hz1unRdh+ha9MAbEPoMOLB/TW5Msp9ILIlgxEXznERVsxx2/2YVtH4Q0xbZPTNxOp3IskxdXR2yLOPz+SgYmUf+sj5kkIuGyhqWAjCQUbiIP0QxYyG3bwf33VHSoW9NSkoKa9euZcGCBWzatIlAIMBDDz2Ew+FIhDCfKFJSUhgzZkzidc8991DV3NitHWKxGHPmzKG4uJicnBxeffVVZsyYgaZpvPPOO9x+++0UFhZy00038emnn56ALTn9qK2tBSA1NbXNJ6IGBgYGBl2PLMv06tWLb775hkceeeSI8wuC0C1PSA1Off7xj38A8cp0Cxcu7LTgcCwcTshtulhvb57mF/PtpTGmp6djNpvbbaPJv7W6uvqIfe0oHdmmQ/vb1P7h/GQtFgvp6ens37+/3f52ZF8d7f5s3tbh+pefnw/Er9Hr6+vbrerYJCp1BX369EHTNGpra7n00kv56KOPGDFiBKNGjUoU+3C5XPTs2TPh4RUOh4lEIkQiEVRVJRgMtkqpUhSlhQhmMpkwmUzG9fAx8tx3rmfW6hdoK5XRHYxR44uQ6zRT7YuLDd5QDG8oRmkd5LjMBGMqQWLkZZhIMZlQRaipD5LkNuO02HFZHYljZ7PZEuKXUUm+a9C1AITnoQfeh+g3zaY4QYiBHsBqasRhqcYTyMduqYqLXvZSfKGeRHHgdrtxuVzdmn1ltVpxuVz4/X6i0SgmkwlZltF1HVVVicVicdF7yhT0/HyE8vI2vbYQBMjPh3YeqLTgvPPi83ZgXbrmg9CHcZErtrPZTEqL/QvxtEjhgNil4yAUceFyOdq1Hxp23iDS89OoLa9r27dLgIz8NIadNyixrxwOB1VVVYiiyLnXjuOLZ5dj1qxoukY2PaliH05ScArxACNREpnzk1ltrPzY6fAvWRRFZs2alQhrbhK7HnzwwePSsbY477zzWj3Z+p//+Z8OLfvKK6+wadMmAN57771EBRZRFPnOd76DpmnccMMNfPbZZyxatIjp06d3bedPc0KhED5fvJJDW6HuBgYGBgZdT3FxMZMmTaLyQBh7RwrHnEnFZQy6lksuuYTly5fjdruZO3cuH330UZspagYGJyuCIJCdnU0wGOSaa67ho48+QpZlotEooVAIs9lMdnZ2QrRqbpzfFM3RVFGySQSLRqOJV/OCXoIgJESv5iJYk9ecwZHJsDpJHyK1aVKvA9v2++iZaaJfnkaFP0q0QUGJKjhMEp5gjFUljdT6okiiQLpDIS9DISNTwp4qYA0qODxmUiQbdsVCitVBksWeqL5nt9ux2WxYrVbjeB0F8eiiQvTguxD6HPSm34QApkkI1qvAMh3CS9Eb/x+CANkpmwhFk/GHsjGbGpHFMNak/sT8YiKqat++feTk5HSLJ7QgCOTk5OD1emlsbCQcDqMoCrFYDE3TgHjUZ2pGBsIzz8DVV8fFqEOvt3Qdnn46bjx/JCQJ2lvXge+j/uS96L5HIPTRwf0sWMFyCYLtBlDLoPH/kZ2ymVA0GU8gF10X0BGIqhbCTMJstZCdnd3ud1ySJH7y9FweuebJNnZM/M+P/zQ3Ed0qCAJJSUmJQiCpqalMvvkclr7yNaIg0lPvTxX7EJpZx191zyXHxZwejkLsOpRbbrnlhHuDHEuI8CuvvALEQ7qbhK7mXHfddTzwwAMUFRXx6quvGmLXUdLk1dXkb2BgYGBgcPz5zW9+Q0VFBRkZGTz++OPMmjWLrKwsI6XG4LgwduxYHnzwQS644AIWLVrExRdfzCeffJJIXzsdqK2tJRKJtHstU36g3HxbHlsnkszMTEpLSykrK2t3nlAolLg+O5H9bd5WWVkZffv2bXO+pr7LskxqauoJ6RvEI9V69+6N1+vlBz/4AQ6Hg2g0isvlIjs7u91INlEUsVgsWCyWFp83pTE1CWBNIpiqqon3Xq+3xXqa+4A1/W9EE7XNF3fexQV/eaZNwcuaGWN7ZhGZup18l5W+uckkm/IIhiMs3l6GLumIIqiazn5PhP2eCOwBu0kiO1khJzNMSoYPs0PA6ldwSVackgWH2UaqPQmH2ZaI+mqK/Gov3fZMR1erIfjfeKqierAABFLPuMBlvQJByj74uWUWJP8Z3fMYDmsVvTKXU9UwHF+4gDDDkbRcMjIcpKSk4PF4iEajlJaWkp6eTkpKygkXIJOSkhgwYAAlJSXU19cTDserRjalN5rNZtxuN8mXXYb07rtw111w6PlZFOFoIqKvvBLaWJfusKD/ZQyc/1doCjKV+sQFLuvlCKIz/pkyFJL/jEN8jF6Zy9lVMRNvMJtQNAPB1BuXa8Bhz3lNnHfl2fzmnXt57LqnUGNa4vOM/DR+/Ke5nHflwVT8WCyGz+cjOTkZTdNQVRVfw8GHAGYs9GYwZiyIkshV91zCD564ueP75Cjp9Fn15Zdf7sJuHF8CgQBfffUVQLullwVBYPbs2fztb3/jiy++OJHdO+VRVTXhfWFEdRkYGBicOBYtWoQgCPznP/8xHtIYnBDGjRvHokWLmDFjBkuXLuXCCy/ks88+axEBcyoTi8VYvnx5m78nXddZtixeRn3cuHEnumstGDduHKWlpSxatIjf/va3bc6zdOnSRMpyV5npd4QxY8YgiiKaprFo0aJ2xa6FCxcCMHLkyBMuINjtdnJzc7n77rvJycnBZDJ1OoJHkqRWVcibzKubhK/mfzVNazMVUpblFiJY018jFRLmf9dBdfUf+OnCi3F7sshISebRSy/Gr22kMVJLsimdnrZzQYvvR4vFwvixIWKxGLIsU1Tt4f8+/YIde+uIBnT8EZU91Sp7qkPIokCqXSEnTSErI4It1Y0SFrF7TbgkCw7FgtNiJ83uwmayJLy+mqK+zuTjo+sRCC+JC1zh5TSlycWjiy6Mi1zKuHZ/V4JlFphnQGQNSa4aHDnpBNWhqKqOLMuJ32RKSgr79+/H6/VSU1NDIBAgOzv7hAvESUlJDB06lEAgkIjiVBSF/fv343a7aWxsxGQykXfFFQiXXRavulhZCdnZ8Ne/wvvvw3XXQWEhOJ0da/TKK+Gyy9CXvov+7l8Qn/8KrGGYvh9QwDITwXpDvABAG/u5aR8nudaQpddg9lpIThtIamraUZ3zBp/THzWmIQhwzz9+RG7fbIadN6jVw9Xq6uqE/2GPHj2oqahh3afx7LoxM4fT6+w89pfUMnTkYC776YXHLaKriS77hni9XtatW5fI08/MzGTMmDFHVApPBNu2bUuEGA4bNqzd+ZqmVVVVUV9f3+op01//+lcaGxsTFw4bN27k0UcfBeJmv2eq4W9DQwOaprUK9zYwMDAwOL40NjZitVqPqjKygcGxMnr0aBYvXsyMGTNYvnw5s2fP5vPPPz8prvm6gscee4ypU6e2uol95ZVXKC0tBeA73/lOd3QtwXXXXccHH3zA119/zRdffNGqImMsFkt4+A0bNuyw179dTXJyMrNmzeLzzz/nD3/4AzfddFOrdNcNGzbw3nvvAXD99defsL41EQwG6XPAANrn83V5Oq4gCCiK0krE03W9VSpkOBwmGo0Si8WIxWKtUiEVRWkVCXYmpULqgTfQvf9HhhXevr4fguPHzaa27wnX/JgO7WXj1TtuASASi/H56q38c9nXVFUGiMU0qr0Rqr0RKAaHWSIjSSEnQyU1PYzJ2YgpKONoUEiSLdjNVpJtDjLsyVgUc4uorzMlu0WP7jhgNv8h6M2KfShjEKxXg2U2gtixe0JBkMAcjwwSgLbihCVJIicnB7vdTnV1NX6/n+LiYrKzs0/4vacgCAlvtyaaKg96PB7q6+uxWq3xAJApUw4uOGoUrFkDe/fCj34Er7+eSEdsD11XIbwMPfAfGLoc+mvo70gI1SqsmAbX/BZBOnLUbmIfm8pQLH6SkpxHfc7bsGQLAP3G9OHC77X9cNXn8+H1ehEEgaysLERR5M8/fBFN1RElkbv++QPyCnIS8x5voQu6QOzatGkTDzzwAJ9//nlCUGpCFEUuvvhifvvb37ZZAeZEUVFRkfj/cEaZzadVVFS0EruefPJJSkpKEu8LCwspLCwE4MEHH2xT7GoaxJrweDxHvwEnMbquJ0Lk09LSzpiB18DAwOBkoKCggJKSEuPca3DCGTlyJIsXL2b69Ol89dVXzJo1i3nz5uHs6NPqkxSbzcaKFSu44YYbePLJJ8nPzycUCvHqq69y1113AXDZZZe1W8XwRHHVVVdx9tlns3r1aq699lqee+45rrnmGhRFoaioiLvvvpuvv/4agCeeeOKE9+/RRx9l4cKF7N69m1mzZvHcc88xfPhwNE1j3rx53H777cRiMfr27csPf/jDE96/7kIQhIRg1Vwc1jStRfRX0/+xWCwhjjVHFMU2/cBkWT6txgM9+F90z0PxN/YfgP1Hx7xOkyxz2bkjuOzcEQDUNPp4ZfG3fLp2C+6GKL6wii+sUlQbj/pKsSlkJytkZ6jYUoMo1gYsfoWkWjNWxYzDYiXF5iTD6sRqOej1ZbPZTquoL11zQ+gT9MB7ENt8cIKYGU+ds16JIHewgmAnEAQBl8uF1WqlsrKSUChEeXk5KSkppKend+u+TkpKIjs7O5HCV1VVlYgATJCSAm+8AeefH/87cybMndvm+nS1FoLvoAfeAu2gjoHjfLh5NDz9DsJr5XDd0aWnN3m2duYcsX5J/JiPntr2gxNVVRNBTykpKVgsFsp2V/LNvLhWcsGtU3ClnfgHYsckdr3//vvcdNNNhMPhNg1vVVXl448/5osvvuD111/niiuuOJbmOk3zPPnDqZjNpzVfponi4uKjbvv3v/89Dz/88FEvd6rg9/sJh8OIokhKSkp3d8fAwMDgjOLaa6/lt7/9LYsXLzaiuwxOOMOHD2fp0qVMmzaNr7/+mpkzZzJ//vwT7unalWRkZPCLX/yCO++8k7feeouUlBR8Pl+i2uDIkSN58cUXu7mX8UiH9957j1mzZrFlyxZuvPFG5s6di81mo7GxEYgLIn/605/atfA4nowZM4Z///vf3HLLLaxYsYIRI0bgdDqJRCKEQiEAevTowccff2xkBRA/VoemQgKtUiGb/tc0jVAolNiXTTR5Bx0qgp2KPo56aD66+38AHWw3ITh+flyEvIxkB/deOZV7r5wKwJodpbyxdB0rdxQTDmrU+CLU+CJsKotHfaU7FHJSdVLTVEzJPuSQgN1Tg000YVHMOK020u0u0qwu7M0qPJ6K0Xi6rkJk1QGz+QVAk+iqgHkagu2quOm8cOLSCU0mEz169KC2tpaGhgYaGhoIBoOJdOTuIjU1lXA4TCwWw+v1Ul5eTu/evVtGd06cCI88Ag88AD/9KUyYAIPiVQzjxv7fxqO4QguAAxVuhWSwXY1gvQ5B7gk/3glPvwOffw6lpUflAdak13RGGGwSu0a2I3bV1tYmKlU22Rr9/oanQQfFrHDns98jGmu7CvLxpNPfzKKiIm688UbC4TC9evXivvvuY+bMmYkywmVlZSxYsIA//OEPiXm3bNlC7969u6zzpwK/+tWv+NnPfpZ47/F4uqVU9/GiKaorJSXllBxIDQwMDE5lfvnLX/L+++9z++23s3DhwjNujDXofoYMGZIQvL755htmzJjBggULTukHYHfccQcDBgzgqaee4ttvv0UURQYNGsQNN9zAvffe2y3VwNoiLy+PNWvW8Le//Y23336bbdu2EQgE6NGjB1OmTOFnP/sZo0aN6rb+fec732Hs2LE8+eSTLFy4kLKyMhRFYdSoUVxxxRXcfffdp3wk4PFGlmVkWW4RIaLrOtFotM1USFVVCQQCBAKBFutpKxXSZDKdtOKLHl6G3vgzQAPrVQhJ/3vC+jpuYA/GDYzfq4UiMT5etYUPV21iR2lNIuqruC6Eskcgxa6Q4VTISQNbcgQlyYsSFElqrEGWZKwmC8k2B5m2ZNLtroTwZbVaT+r7Jj22Dz34AQTfB63y4AR5YDxN0ToHQTxxRSUORRRFMjMzsdlsVFVVEQqFKCkpITMzE6fT2S3f66ZKr5FIhOrqahobG6moqKBnz54t+/PLX8KiRbB4MVx3HfrKBaDPQw++AbHdB+dTRiPYro97nwnmg58PGACTJ8OyZfCvf8GDD3a4j52N7KoqrqaqqBpJlhg2aVCr6YFAIPGQpSl9cfNX29m5Zi8A1/3yckxmU7eIXYLeyRrkP/nJT3j++eeZMGEC8+fPb/epjN/v54ILLmDVqlX8+Mc/5q9//esxdfhQevXqRUlJCQ8++CAPPfRQm/N8/PHHXHrppUDcI2DEiBFtzvfhhx9y+eWXA/H0zOPhb+DxeHC5XLjd7lN+gI9EImzfvh2AAQMGtKpOY2BgYGDQmq4cB1599VUaGxt56KGHiEQiXHXVVZx11llH9E665ZZbjqldA4PTjZdffpm5c+dSUFDQqUh+gxNHV5xD/X5/4t7F5/OdFhVFNU1r5QcWiUQSUYmHIghCm6mQ3R2BpIdXozd8HwiD5SIE1x/jnkMnAaU1jby9bAOL1u+gqt4Pze6ik8wSaXYTWSkKaSky5hQN2QRmJKyiCVGWSDLHUx6z7SmkJyUnxK+TQXjU9SCE5se9uCKrD04QnHFxy3o1yEO6vZ+HEovFqKqqSnjdJSUldWtV6mg0SlFREXV1dSiKQo8ePcjKymo5U0UF+shhCLUN6N9NQ3/sgHAo2MByKYLtegRlcPuNvP463HRTPKqrqAg6uK3FxcWEw2F69OhxVJ5d815awh+/9xxDJgzgma8eazFN0zRKSkqIRCKJirYAN/e9g6qiauwuG+/XvYQoil163u3oONDpyK6FCxciCALPP//8YcOP7XY7zz//PCNHjuy2Koe5ubmJ/8vLy9sVu5rKSR+6jEHb1NfXA+BwOAyhy8DAwKAbuO222xIXnrqu89prr/Haa68ddhlBEAyxy8DAwOA0QxRFLBZLq2tyVVXbTIVs+jwcDrewbxFFsYX41fT/iRAP9Mh69MYfAuF4mpzrDyeN0AXQIyOZn189mZ9fPRlN0/hqawn/XbGJb3ftwxuI4g0HKa4PokgCqTaFdIeJ7FQBqyuE2aXTGPFR62ukSChHMsnxKo9WJ7lJaaQ7UxJ+XydKqImnzm04kKb4KehNxREEMJ0br6ZomdEysugkQ5Zl8vLyaGhooLa2Fq/XSygUIicnp1uicBVFIT8/n0gkgsfjobKyEqvVitPpRNfDEPoM3fwGPG1FuKkB4V916FN6IVx5d9z7rCPG/lddBXfeGU9j/OIL6GCqepO/+tEKlhuWHkhhnDK01bT6+noikQiyLJORkQHAkjdXUFUU9+/64R9u7lY/tU6LXWVlZSQlJXXIeH748OE4nU7Kyso629wxMXjw4EQJ5M2bN7frXbB5c/xAZmdntzKnN2iJpmkJsaspL9fAwMDA4MTSKjzewMDAwMCgGZIkJQzTm9B1/bB+YMFgkGAw2GI9siy3mQrZVTeyenRrPKJLD4BpAkLyMwjC8a/W1llEUeS8Yb05b1jcPsAXCPPBV5v4Yu0OdpTXst8bYb83wtZKSLLIpB1IeUxLVjG7Yij2EJ5QgFp3AzuqSzCZzPGUR2sy+ckZpB6I/DKbzV0+zutqDYQ+RA+8C+regxOkHnGBy3o5gnTqBH4IgkBqamrCvD4ajVJaWkpaWhqpqakn/DrJZrORn59PUVERgUCAfSVb6Je7AlPsHdAb4zNNT0a/Ixvh2XUIdxchTJ0C9g76F1oscMst8Mwz8I9/dFjs6kwao67rrF8c10hGTWup+4RCoYQekJmZiSRJaJrGX+6M+1qm5aYyu53KjSeKTotdiqK0GxZ7KE1ldg8tv3uisNlsnHvuuSxfvpx58+bxi1/8otU8uq4zf/58gFblmw1a43a7icViKIpyyqdjGhgYGJyqGOlWBgYGBkePLMv85Cc/Sfx/piEIAoqitLo3a7pnO1QEi0ajxGIxYrFYIl2s+XoOFcGONhVSj+1Gb/gu6B5QxiAk/+2kjiZqC4fNzM0zx3HzzHEA7Kmo462lhazcUkxlvRdPKEZRXRCTFK/wmOYwkeVSsDljWJI1FDVKIBigSqhlQ+UerBYLadYksu2p9EzNJjnJic1m6/T3VdejEF4aT1MMLwPU+ATBCuZZCLarQRmHIJy6FSStVisFBQVUV1fj8Xiora0lEAiQnZ19wnUIl8tBdnoVpftK8dT72BfbQ58sL6Kci2C7DqxXIzzlhFUTEdauhRtuiPt4dfT43n57XOz6+GOorIScnCMu0hmxq3x3FbXl9SgmmaETB7RY1/79+9F1naSkpIR9xtt/+AhvnQ+An7/woxZtdcd5t9Ot9OvXj/Xr1zN//nxmzZp12Hnnz59PKBRi8ODD5J4eZ2699VaWL1/OkiVLWL16NWeffXaL6e+88w5798aVbSO948g0GdOnpaUZUQUGBgYGBgYGAFx55ZWsXLnyqJZ5//33mThx4nHq0fGlyZ/kaKiqqjoOPTE4GsxmM88++2x3d+OkQxCEhGDVHFVVW/mBhcPhFp83RxTFhPh1aCrkofcNemwfev1toNWDPBQh5Z8IYsf9hE5W+uamcf8NM4B4Rsyiwt18/PUWNuytSER9bWse9ZWkkOIUMDtjWJwQ9ccIBQKU1O9nVfk2XFYH6TYXuUlp9ErLwelIwmKxHPE+TI/ujAtcoQ/j+7gJZfSBNMWLOpY6d4ogSRLZ2dnY7Xb2799PIBCgpKSE7OzsE1L5VVerIfgOeuAtMuX9hJLOoaphOPX+8djCV5KbPQ1BPCDBSMCbb8Lo0bB8OTz6KLTjQd6KoUPj1R1XroSXXoL77z9y3zohdjVFdQ2eMACz9eB5oaGhgVAohCRJZGZmAhAJRfj3I+8AUDA0n/GzR7dYV3ecdzstdl122WUUFhZy++FZzdgAAQAASURBVO23M3/+/HaFrK1bt/KDH/wAQRAS5u/HQkNDA6qqJt435Z4GAgFqa2sTn1sslhZf6FtvvZVnnnmGTZs2cdVVV/HKK68wffp0NE3jvffe4/bbbwfgwgsvZPr07g23O9lpqvLSFDJqYGBgYGBgYABx/479+/cf1TKH3ih3B7fddhu33XbbUS93tNtqYHAqIkkSVqu1hQeSruvt+oFpmkYoFCIUCrVaTwsBTGnE5J+LoFWD3B8h9UUE8fAFVk5FRFFk5tgBzBwbj4xp8AV4d9lGFhXuoqiqnqK6YCLqK9VuIs0WT3m0OTQsyTomK3i9Xrw+L7tqS1lRuplks4MMu4seKVn0Ss0hyeFIRMvomgdCn8a9uKKbmnUkI56iaL0SQe7bHbvihCAIAk6nE4vFQmVlJaFQiPLycpKTk8nIyOhyDyld1yGyGj3wHwgvBGLxfogp5PccTkQ5n7qGGJW1CvZkb8tqxf36wd/+BjffDL/9LUydGq+22BFuvz0udr3wAvzP/8BhtkvX9YTYdTTb3+TXNWrKwcJ9kUgkEfiSkZGR+N79/d5XiQTj4/n//Pv/dbiN40mnqzF6PB6GDh1KeXk5JpOJa665hunTp5OXlwfEPb0WLVrEu+++SyQSIT8/ny1bthyxQtSRaKq+eCRuvfVWXn755RafFRcXM3Xq1ETah81mS5yMAUaPHs2iRYuOa7ns06EaY2lpKQ0NDaSkpNCjR4/u7o6BgYHBKcXpMA4YGBgYdBddcQ7VdT3xkDw9Pd3IUuhCdF0nGo22mQrZ/LZTEhrIt/8Kk1ROVMulXv8zijm3RUTYmXJcNhdX8e6XG1i1rYTqxniaqAA4rTJpB1IeU5IkTHawpYAsgSSIRFFRxbi9ULrFSaY9Si/7VnqY5mMzVyMIOiCDeWq8mqL5PAThzErbbfqtN3lLmc1mcnJyWkUvdmrdmgeCH6AH3mjpfaaMRbDdAJZZCIKJcDjMjh078Pl8WK1WBg0a1No8/7bb4JVXIC8PNmyAjnhiBwKQmwtuNyxYADNmtN9XXWfnzp1APEOvI0UQdF3n2pzbaax289SyRxh+3mB0XaesrIxAIIDdbicvLw9BEHDXebk2+/toqsbw8wfz1NJH2lxfV513j3s1RqfTybx585gzZw7FxcX85z//4T//+U+r+XRdp3fv3nz00UfHLHQdK7169WLjxo08+eSTvP/++xQVFaEoCkOHDuX666/nzjvvxGQydWsfT3ZisRiNjY2AYUxvYGBgcDKxcuVKVqxYQVlZ2f9n777jo6rSBo7/zp0+k2TSG4RepCkCNhRBwAqrKBbslbWX9VV3Xcvqrq676667q6LuKmtvIPYuHUGRXqR3SO/J9HLP+8dNJoyEFhKSwPl+PtFk7p1zz2TCnbnPPM9z8Hq97O2zLCEEkydPPsyzUxRFaTt8Pl+s9Mbj8eByuVp5RkcOIQRWq3WPaypd12PBr3CwjMToY1hEPmE9g12ePxGRNvCU7zHOL0shzWbzERcE698lm/5djJLoUCTCN4vW8/mPa1mzvYgt5X62lPuxmTVSnRbSXBbSEiw4nDr2JIEjEbRohPJgBflVIZZpSdjNF5Bhj5LtzqBn1lA6JnRvtd7ZrU0IQUZGBk6nk6KiIoLBIDt27CAjIwO3292kvyUZXm1kcfk/B+qyF4UL7BcgnJcjLL3j9rfZbHTp0oUNGzbg9/vZunUrvXv3jg84Pf88/PADbNgAN9wAH38M+5ub0wlXXgkvvGA0qt9PsKvegT7m7Wt2UVVSjc1hpfeJPQAjyOTz+dA0jczMzNhY/7jxBfSojhDwuzfubHS81jjvNjmzq57H42HSpElMmTKFlStXxkoMTSYTxx57LBMmTODWW289LDWybdmkSZOYNGkS0WiUDRs2tLtP9KWUlJeXU1paSm2tkX7Zs2fP1p6WoihKu9PcmV0bN27kiiuuYOnSpXG3Syn37I1Sd9vu7QAURVHak+Y4h3q93ti1iQp2HV5S9yArr4PwStAykO43CEZz4jLBQqHQXl+nTCbTXvuBHYmKK2uZOncFs5dvYntJFVFdIgC3w0yay0qqy4LbacLmAocbbHaBAELohEQUadJw25yku9x0TMnkmIzOZCalNHspX3sQiUQoKiqKLbKQmJhIVlbWAWY5+cH/JdL/TnxpqLl3XRbXr/bb+6y0tJQtW7YQjUbJzs6ma9eu8e/Tli2Dk0+GUAieew7uuGP/D2r5cqPnl8UC+fmQkdHobtFolE2bNgHQq1evAwp4ffz8V0y6638MOvNY/vrNI0QiEbZt20Y0GiUjIyPWzih/UyHX9b4LJJx+8ck8MuX/Gh2vOc+7B/o6cMjBrt2Fw+FYimBqaupRG0Hel/ZYvlJYWMjPP/8cV3dvtVoZMGAAOQew8oOiKIrSoDlfB8rLyxk4cCD5+flkZWUxfPhwpkyZgsPhYPz48RQVFbFw4UJqa2tJT09nzJgxALz66qvN8VAURVEOOxXsar+k9CMrboLwIhDJiNS3EJZejewniUQicX3A6v+/t0tXs9kcC3ztHgw7UoI6UkoIr2TR6o/5cEE5S7ZlU+61AyIu6yvVZcFuF9gTwekGs0mgC0lARggKHYvJTLIjgYzEZDqn5tA3swvJzqMnKUVKSWVlJWVlZUgpsVgsZGdn43Q2viiCjGw1yhT9H4GsrrvVAvZzEc7LjdVDDzBTSkrJjh07KCgoQAhB165dycrKit/p3/+Ge+4BqxUWLoSBA/c/8IknwqJF8PTTcN99je4SDofZsmULQgh69drz31xjHhv/NPM/+okbnryCyx+8kIKCAmpra7Hb7XTq1Cn2uO885fesW7gRk1ljStErJKU2Xs3XGsGuZi3atVgsez5hSrtWWFjIkiVL9rg9FAqxZMkSBg8erAJeiqIoreRf//oX+fn5nHTSScyYMQOn08mUKVNwu9288cYbgPHm4o9//CNPP/00DoeDF154oZVnrSiKohxtpAwhK++oC3QlIFL/12igC4wyK4vFgsViiasOklLGBb527wcWiUSIRCKxrJ3dx/llFpjFYmk3pZAyWgaBT4wVFSObGJILQy4GTB0JmMbx+Yrj+GZJIWt3llJYE0QT4LabjUb3LguJDhNWu8DpNpPsAiEFvloP62qrWFW0lZnrF+N2JpCVnEb3tI70zeiEw3Lo/azaqvoF1pxOJ4WFhYRCIXbt2kVqaippaWkIIZAyDMGZRqli6IeGO5s6IhwTwHkxQjv4RdqEEOTl5eH3+6moqGD79u04nc74Vk933QXTp8Pnn8OECbBkCewvKDRxohHsevll+L//a7T88WBXYtR1nZWzfwZg4Mj+xgIJtbUIIcjKyoqN8/P8daxbuBGA8287Z6+BrtZydHWoUw6KlJKff/55n/v8/PPPZGdnt5sXDEVRlCPJF198gRCCP//5z3v9VNLlcvHXv/6VUCjEs88+yxlnnMEll1xymGeqKIqiHK2kDCOr7oHQPBAORMrLCEv//d7vl4QQsYDV7qLRaKNBsPrbf7niq6ZpccGv+u9NJlObuKYxgi1zjABXcA71q/uBHexnGc3mrSfiFBqXngGXnmFs3Vlaxfuzl/P9qi1sLathc5kPu1kj1WVkfaU4LdisYHNquFKsWK2CqC6pqq6mqLqc5Ts38qXZSnJiEh2SM+mdkUevlA5YTEdeyKA+O6m0tJTq6mrKy8vxeYrIcs/CEn4f9JK6PTWwjTCyuKzDEOLQMgU1TaN79+4EAgF8Ph8bN26kf//+DT3uhIBXX4XjjoP16+HOO+F//9v3oBMmwG9+Y/T7mju30dUcDzbYtWXFdmorvTgTHXQf2Jmdu3YCRvWe3W6PjfnXa58HwOa0cuNTVxzQ2IfTAf3lLlq0iBNOOKFZD+z3+9m2bRt9+vRp1nGV5lNeXr7HksG/FAgEKC8vJz09/TDNSlEURam3efNmhBAMGzYs7vZfvrEH+N3vfsezzz7Lf//7XxXsUhRFUQ4LKaPI6t9BcDpgRSS/iLAObtZjmEwmHA5H3Ap3Ukqi0WijpZC6rhMIBPa4zjGZTI2WQh6ufmAysgnp+wACn4De0Kwfy0CE4yKwj0Foe8+cyctI5r5LRnDfJSPQdZ35a7bz0bxVLN+cT0GBx8j6ctSVO5ZaSLCZsNjAkWghNcli9PoKRSktL2dXeTFLt63FbDaTnpxKl5Rs+mR2pmtiJtohBnzaCpPJRFZWJg7zeooLl+DzbGNHZYjMZEGiKw0clyCclyFMHZr1uBaLhR49erBmzRoCgQCbNm3imGOOaSi5TU+Ht9+GkSONwNfo0XDFPgJJiYnG9pdfNr72Eew60LLe5bNWAzDg9D5UVFYQiUSwWq2xPl0Ac6YsoHBLMQBXP3oJNkfbywg8oGDXSSedxNixY3nssccYNGjQIR3Q7/czadIk/v73v3Pbbbfx6KOPHtJ4SssJBoPNup+iKIrSvMLhMCkpKZjNDS/nTqeT2traPfbNysrC7XazcuXKwzlFRVEU5SglpUTW/AECnwFmRPKzCNvQw3JsIQRmsxmz2RzXG0hKSTgc3iMIFg6HiUaj+Hw+fD5f3Fj1pZC/DII1RxaY1Gsh8IWRxRVe0bBBS69b3W88wtzjoMfVNI1h/bsyrH9XADy+INPmr2L6kvVsKihnU6mR9ZXmspDmspLsNGMxC2wOEy63iWSnjWhUEohGKCguYmdJIT9uWolmMZOdkkH39Fz6pXWmgzO1TWTDHSypV4H/Q6TvPRKj27ClOCmqPJZAtA9FvrH4HceT6cpBtFDPt4SEBLp168bGjRupqqpi586ddO7cuWGHESPg4YfhT3+CW26Bk06C7t33PuDEiUag64MP4NlnITW+zPJgM7vqg119T+1FdbXRqywrKysWLItGojx3h7Gyd2JqAhff+6sDGvdwO6Bg16mnnsrnn3/OF198wQknnMBVV13FZZddRsZeuv3/kpSSmTNn8vbbb/Phhx9SW1uLy+Vi4IE0XFNazS9ThA91P0VRFKV55ebmUlhYGHdbVlYW27ZtY8uWLXTr1i12ezgcpqamJi4wpiiKcjQym81ce+21se+V5ielRNb+GfxTAA3hfhphH9na00IIgdVqxWq1xvVK0nU9rgSy/vtIJEI4HCYcDuPxePYY55dBMLPZvN+AgpQ6hBYaAa7AN0B94oDZKJlzjAfb6QjRfIu9JThtXHvmEK49cwgAm/JLmTJnBQt+3saqwloEkFyf9VVpwWk1YbaAw2UhNdmCZoFgJIo/EmGbfyfbi3Yx27QYm9NBrjuDnhkdGZDamXRb2+rZtLv6Jv/S/y74vyD2excurEkX0ilzAuXVKVRWVlJd7SEQ2EFOTk6LXeump6fj9XrJz8+noKAAl8sVXy316KMwaxZ8/71Rqjh/vtG4vjFDhhjN7JcvhzffhLvvjtus67rxUA8g2BWNRFk1dy0Auf0yAUhOTo5rlzHtX19QU258sHrbv67DZN5/9mNrnHcPeDXGadOm8dvf/jbWxb++k/+JJ57IcccdF1t+0mazUVlZSUVFBVu2bOGnn35i8eLFeL1epJSYTCZuvPFG/vjHP5KZmdnSj6/NaU+rMUopmTFjxj5LGe12O6NGjWqXEX1FUZTW0JyvA6NGjWL27Nls376djh07AjBhwgSmTp3KH/7wh7js6Zdffpmbb76Zrl27snnz5kM6rqIoSmtpT++lj2Z67b/AayyIIpKeQjjHt+6EmmhvpZDRaLTR/U0mU1z2V30wzGQyIaP5RjaR/yOI7mq4k7mHEeCyX4AwHf7WMLquM2PZJj5dsJqVWwup9YdwWLS61R2tpDjMmEwCqw2cSQJXIkQ0nQBRfESIoKNpgqjZyFjKS8mmT1oe/ZLzcFsb7yd6OEndB4HPjVUVI7v1ozb3MXpx2X+F0Bqy/7xeL0VFRUQiETRNIz09neTk5Ba53pVSsnbtWqqqqjCZTAwYMCC+B+vOnUb/rspKY6XFp5/e+2AvvAC33w59+8Lq1XGN6j0eD/n5+djt9vgMskasXbiRu075Pa5kJ0/N/x02m43OnTvHynn9Hj+XZN9E0Bciq3M6b2554bDHApp9Ncbx48dzwQUX8MEHH/DSSy8xd+5c1q1bx/r163nzzTf3er/6WFpGRgbXX3997I220vYJIejXr1+jqzHW69evnwp0KYqitJJhw4Yxe/ZsZs+ezVVXXQXA1VdfzZQpU3jiiScoLi5m4MCBrFixgpdffhkhBOPGjWvdSSuKoihHNOn5T0OgK/HRdhvoAiN45XQ64wIQUkoikcheg2B+vx+/3w+AIEiC5QfcthnYtRUIYVwbSxIQ9jEI58VgObZVr6c0TePMwb04c7CxOmalx8cHc1YyY9lG1hZVENV1UpwWUp0W0mqsOCwaJrPA7rCQkmzB7ICgHsUfiuCrqGVdZS1rtm7gPYsgNclN17RcBqR24pikDjjNh68iyOiB9h74PwJZ397BCvbzEM4rwHJco793l8tF586dKSoqwuv1UlJSgs/nIzs7u9n7t9UnEK1cuZJAIMD69esZMGBAQ+ZTXp7RoP7CC+Hvf4dRo+Cccxof7MorjYDYmjXwww8wtKFk+GDKGFfUlTD2OKELmqaRmZkZ97gnP/QuQZ/RG/beV25t07GAA87s+qWNGzfyzTffMHfuXBYuXEhhYSGRSCS2PSkpib59+3L66aczYsQIRo0ahcXSfKmY7VV7/DSqsLCQVatWxTU8ttvt9OvXj5ycnFacmaIoSvvTnK8DP//8M2PHjmXEiBG8+uqrsduvuOIK3nvvvbg3IFJK+vTpw4IFC3C73Yd0XEVRlNbSHOdQKWWsL5PT6WzTF2vtjfS+iaz9EwAi4X5EwsRWntHhI6U0Al+BAJHgCiyRT3GIGWjCG9vHFzmOmtBoPOGTQTga7QdmsVja1N/k6m1FTJ2znIXrdlBS5cVp0UhzWUl1WUh2WNA0sFgFDhckJINulviJ4CdCROggJH6ho1s0slPS6JXagf4pnemZmI3N1LzxAWMly+lI3zsQWtiwwdTJyOJyXITQUg5wLElVVRWlpaVIKbFYLGRnZ+919etD4fP5WLVqFdFolNTUVHr37h3/N3D77UbmVkYGrFgBe7sGv/56eO01uO46o7l9nZqaGgoLC3G5XLFKgL357Vl/Yun0lVz80Bh+detZ5ObmxrZVFFVyeadb0CM63Y/vwktL9pFp9gvNed490NeBJge7GlNVVUUgECAtLU0FtvaiPQa7AAoKCti1axdOp5Ps7GzS0tLa1ElYURSlvTgcrwNSSl555RXef/99du7cidvt5pxzzuH//u//VKBLUZR2rTnOoV6vl4SEBMAo79m9gbnSdNI3DVnzoPGD63a0xLv3fYcjjIyWQ+AToxdXZGPD7VouUcsF+OXZBMJpsUywvZVCapq2135grS0UifDNovV8/uMa1mwvJhAKk+w0mtynuSzYzRqaBla7wJUksCfqBIWOjwhBIkgBEaHj0SKYLGby0rPpk9KR/sl5dE/MxtTElR5ltBDpex/8U0EvrbtVA9sZRhaX9VREE8cOBAIUFhYSCoUQQpCamtoi18JlZWVs2LABgLy8PPLy8nafhNGkfuVKY3XGb76BxprnL1gAp54KDgcUFEByMgDV1dUUFRWRkJBAhw57X10yHAozLuVaQv4wD39+N6eedXLc391j4//O/I+MIOJLy56m+3FdDvjxNed5t9nLGA9Ect0vU9nTpEmTmDRp0l5Pam2druvY7XYyMjLiG+cpiqIobY4QgokTJzJx4tHzibqiKIrSeqT/C2TNQ8YPzusQCXe17oQOEykjEJyL9H8AwdlAfaWTDexnIxwXIawnYxIaVsAdu5+M6wdWXwYZCoXQdZ1AILBH32Sz2dxoEExroRUDG2M1m/nVKf341Sn9ACiurGXKnBXMWbGJn7ZXYatf4dFpwe21oBWB2WLC7jSRkWRHOHR8MoJdDxOJSqp2lTA9P59PTPOx2Wx0T+9I/5Q8+rvzyHOloe0jQGU0+p9vZHEFZwFGE3a0DHBcinBeijAdehVSfZ+rkpISqqurKS8vx+fzkZOT06wJPunp6Xg8nliSSUJCAikpKfWTgPfeMxrRT58Of/sb/O53ew5yyilGz641a+Cdd+C224ADL2Nc9f1aQv4wCakuBp46IC7QtX3tLuZ/bAS6Bp117EEFulpLs2Z2KfvXXjO7tm/fTnV1Nbm5uSrYpSiKcgia83Xgj3/8IwDXX399/CeAiqIoRyiV2dX2yMBMZNUdQAQclyGS/njEV4DIyCak/0Pwfwx6WcMGy7EIx8VGXyjt4P8+pZSEw+E9+oGFw2H2dtneWCmk1Wptlefgp/U7+GjeKhZv2EmVN0CKwxzL+rKZNYQwSh6dCQJHsk7EpOMlTIAo1GV91RDEb9Zx2Z30zehM/+Q8+ifnkW03msRLvdJo9O97F6I7Gg5uPdkoVbSNbtaVLHdXU1NDSUkJ0WgUk8lEZmZms17T67rO2rVrqa6uxmw2M2DAABwOR8MOkyfDTTeByWSs0njyyXsO8u9/wz33GI3tly0DIaisrKSkpISkpKS9tiGSUvLC/ZP5+JlvOGHsQJ785Pdxf0N3Df09a3/ciBDw+qbnyemadVCPrd1ndilHrvp+bG0hfVZRFEUxPP7445hMJh588MHWnoqiKIpyFJLB+ciqu4AI2M9HJD12xAa6pO6BwBdGmWJ4ecMGLRXs4xCO8QhLz0M6hhACq9WK1WolMTExdruu67HA1+5BsEgkQjgcJhwO4/F44sb5ZfCrvhSyJZ+fE3t34sTenQDwh0J8tmANXy9ax9JdpZiQdSs8WkgOWKgqB81kwm43kZoE5gQdv4hiw0Q0LCEMGz2bWSzWEDJJUhyC49xl9LMtoZ+zmDRLEEQiOC5EOCcgzD1a7HHVS0pKwuFwUFhYiN/vp7CwEJ/PR2ZmZrNk2GmaFmtYHwwGYw3rYw3ib7gBvvsO3n8fLr/cCGb9srru6qvht781enstXgwnnICuG1lv+3ruq6ur+fl7o4zypHMGx+27fNZq1v5olOaOuur0gw50tRYVuVAOSH35ZXOvQKEoiqI0XXp6OtFoVPXJVBRFUQ47GVqCrLoNCIHtTIT7LwhxZF0rGKVyi4wyxcA3QH1poQlsIxCO8WAb3mKZRPU0TcNut2O32+Nuj0QijQbB9lYKaTKZGi2FbIlrPIfVyqUjBnLpiIEA7Cyt4v3Zy5m3agtrCqtwO8zGCo8uCz6vBggsFgsOlxW7W4Itil2acGEBXRKNSJbUZjFTDCdq8tAlOYX+KcfT39SNfo4OJO5zNs3HYrGQl5dHeXk5FRUVVFdX4/f7ycnJ2eP5aer4vXv35ueff8bn87Fp0yZ69eplBJ+EgP/8B376CbZuhV//2gh87R7ESk2Fiy+Gt9+Gl1+GE07YbxljOBymYFchW5cZmXKDRx8b26brOs/8+iXAKEm9+e/XHPJjPFxUsEs5ICrYpSiK0vYcd9xxzJw5k/LyctLS0lp7OoqiKMpRQoZXIysngvSDdRgi+Z8IceRcWspoAfg/MrK4orsaNpi6I5wXG1lspozWm2Ads9mM2WyOWyGwvhTyl0GwUChENBrF7/fj9/vjxrFYLHsEwaxWa7P2A8vLSOa+S0Zw3yUj0HWd71dv5eP5P7N8cz6RSJg0p4VUlxV3yExNFQhNw2a1k5QA9mSdgBbBikaacICejr8szKyyFXyiLUZYTfRJyaOf2yh57JPUAYfZ2mxz/yUhBOnp6Tidzljz+h07dpCRkUFycvIhZ88lJCTQrVs3Nm7cSHl5Ofn5+Q2rKLrd8O67cNppMHUqnHkm/LJH68SJRrDr3XfhH//YZ7BLSklJSQmblmwlEo6S3iGVDj0bSh1nvvs9hZuLAbjw7jEkZ7SfhY6OnDOS0qJUGaOiKErbc/PNNzN9+nSeeeYZnnzyydaejqIoinIUkOENyIobQHrAcgIi5XmEaLnAwuEiZRAC3xkBrtACoK5HlnCBfazRi8tybJsv09y9FLK+RxIYGTq79wOrD4LVl0GGw2G8Xm+j4+weBLNYLIf8O9A0jdOP7c7px3YHwOMLMu37ZXy3eCkLd1STYLUZje5dFgIBDcoEZrMVu92GNVHHlBDFI0w4sJArQQ9IygtL+LhoO2+IMAlWBwPSjH5fA5I70SMxG6vW/NexTqeTLl26UFRUhMfjoaSkBJ/PR1ZW1iFfN2dkZFBbW0tRURE7d+7E5XI1NKw/6SR48kmjXPHuu40VGPv2bbjz6adDr16wYQO89x7yggsAGg1e1tbW4vF42LhwKwDHndEv9vyGgmFevOc1AOwuG1c/evEhPabDTUUulP3SdT0WDVaZXYqiKG3H+PHjuffee/nLX/5COBzmgQceUIuIKIqi7IfJZOLiiy+Ofa8cOBnZhqy8HmSVEfhJ+Q9COPZ7v7ZKSgmRn40yRf/nIGsaNlpPNsoU7We168dYT9O0WNBqd9FotNFSyN1Xi6ytrY0bp7FSyKYGd2Q0H2f0Pa4e+AFXH1sOwKbidKYsPYsfN2ZQ64/WlTtaSYqYER4QwoTVYsHlBLtbJ2KLYkEjRRhlhIFAhK35O1hasAGvFiXN7ub4tM70r8v86pqQiWkfKz0eDJPJRG5uLlVVVZSVleHxeAgEAmRnZx/y4hddunTB5/NRU1PDpk2b6N+/f0PD+vvugxkz4Ntv4bLLjNLG+m1CGNld998PL7+MPP/8upvjg5TRaJTS0lIAtiwxShgHnjEgtv3Df35OTbnx3F/z2KU4Epr+76A1zrtqNcbDrD2uxhgKhVi3bh1CCPr379/mP81QFEVpy5rzdWDkyJEALF68GK/Xi6Zp9OjRg8zMzL2+kRBCMGPGjEM6rqIoSmtpj++ljxQymo8svwL0QjD3RqS+idCSW3taTSL1CvB/amRxRdY3bNByjYbnjosQ5qN3lWMpZaP9wEKhUKzZ+S+ZzeZGm+I3lk0kZRRC84wVFYOziWXRaZnguBThvBRhygYgEtGZtWITnyxYzdrtRVhEQ6N7q8kY26QJ7HaByaljc0t8pjB+IiBACkk1QSpEgEoCRDTIc6RyXHoX+rs70S85j07OtGa5xg0GgxQWFhIMBhFCkJKSQnp6+iGNHQqFWLVqFcFgEJfLRf/+/Rve4xUVGasulpTArbfCCy803LG0FDp0gHCYsu++ozwvj4yMDFJTU2O7FBYWUlNTg4zAPcf/gWgkyptbJpHdJZPaSg8TOt5MyB/CnZ7Eu7tewmJtGz1i1WqMSrPZvV+XCnQpiqK0HbNnz477ORqNsn79etavX9/4Hdj3SjyKoiiK0hgZLUFWXGcEukxdESmvtrtAl5QRCM4zAlzBWUC4bovVyN5yjAfrKYhmyvhpz4QwmsVbLJa47KT6fmCNlUJGIhEikcgepZBx/cCsPuzyc0yhD+J7oVmHIpyXg23kHs3+zWaNMwf34szBvQCo9PiYOmcFM5dtorSyGrfdTKrLQpJuRviAMoHVYsdpB0tiFC1Bx4xGcl3WV0hGqfAEmONdxacsxmI209mRxvHp3eifnEd/dx6ZdneT3i/ZbDY6depEaWkpVVVVVFRU4PP5yMnJwWptWqmv1WqlZ8+erF27Fq/Xy+bNm+nZs6cxv+xsePNNOPtsePFFGDUKxo837piRAePGwdSpON56Cx58MO4xeb1eampqEEJQuqmSaCRKdtdMsrtkAvD6o+8T8ocAuOWf17aZQNfBUMEuZb9Uc3pFUZS26Q9/+ENrT0FRFEU5wkm9wihdjG4HU0dE6usIU/spmZeRLUaAy/8J6CUNG8z965rNj0Fo7afpdmvavY9XYmLD+oe6rseVQNb/38gOC6JFl+GKfoUjPB9NGL2gozKRAOcQtV6C2doDm8mG+QDCEykJTn495hR+PeYUAFZtKeSDeStYsn4n0UiIVJeFNKeVUFhArUAIMw6bDatNx5ESJWANY8VEtnAhhaQmHKIy4uHT2p94l/m4LDa6OzNjwa9+7jxSbQn7mVUDTdPIysrC6XRSXFxMIBBgx44dZGZmNjkbNSkpiU6dOrFt2zbKy8txOp0NDevPOgseeAD+9je46SYYMgQ6dza2/frXRrDrww8R99wTC3bpuk5xsdF0Pjk5mTnzFwIwcEQ/AIq3l/LZS98CkNMti5GXn9akebe2Zgl26brOkiVL2L59Oz6fj2uuaT/LUSr7p4JdiqIobZMKdimKohw8r9cba9zt8XgOua/OkUzqtciKGyGyEbRMRMprsfKytkzqHgh8ZQS5wksbNogUcFyAcIxHWHq33gSPMJqm4XA4GvpJYTwHUe/H4H8XTd8Yuz0Q7UVV8Fw84WFI6vuH5QPG9ebuJZD13+/rOnRAtxwGdDNWDwxFInz103q+XLiGjUVlOC2CVKfF6M0WAG+1wGyy47RpaM4o1uQwZk3DLWx0wU1YRKkIBSgIl/Fz9S50IXGZ7RyTkMPxGd0Y4O5EX3dHEiz2/f5OEhMTsdvtFBYW4vf7KSwsxOfzkZGR0aTr6uzsbLxeLyUlJeTn5+N0OhtKEp94AmbPNvp2XXml8b3ZDCNHQteuaFu3kvjVV4jbbgOgrKyMcDiMxWIhPT2d5bN/BmDgSKNf1wv3vIoeNcpV73j+xmZZlbM1zruHHOx67rnneOKJJygrK4vdtnuwq7KykmHDhhGJRJgzZw5ZWVmHekjlMFMrMSqKoiiKoijK0UXqPmTlRIj8DFqqkdFl7tTa09orKSWEFyF90yD4NUh/3RYT2E43yhRtI46IlSPbMhleb/TiCnyCJutLGu3gGItwXoHD3A9zOExSI/3AotEoPp8Pn88XN2ZcKWTdl8Vi2SMIYzWbuWBoPy4YWpehVFnLlDkr+H7lJrw+H8kOC6lOC5GoDj6gzIzDasdmBas7SsQVwoKJLGEEYmpFiIqQn3WVu/ipcgtmTSPJ4mBgSlej5DE5j2OScrGbGv+bslgs5OXlUV5eTkVFBdXV1fj9fnJycrDb9x8w250Qgq5du+L3+6mtrWXr1q3YbDYjaGSxwLvvwvHHw/z58Pjj8Kc/gaYZjep//3uSp04lfPvt+P1+qqqqAMjKysJX42fT0i2AsRLjxqVbWPDJIgB6DenGCWcPPKh5tiWHFL24/fbbeemll5BSkpSUhMfj4Zf97lNSUhg0aBBvv/02U6dO5Y477jikCbdXkyZNYtKkSbEsqfZEZXYpiqIoiqIoytFDyiCy6lYjK0okIVL+hzB3b+1pNUpGC8H/EdL/IUR3NGwwdUU4LjYyuUyZrTfBo4CUIQh8jfS9E59JZ+qKcF5hNP3XGkr46ksh6zN9wKgWqw96/bIfWP3XL/uB1Y+zexaYxWKJletlpSRy57jTuHOcUYb30/odfDhvJeu3F6LJKGmuuj5UIcADmmbFYXGiOSX2lAgWs0aisNJZuokInYpogEo9wPdFa5lZvBqz0Ei1JjA4rRv96lZ67JmYjUUzx80zPT0dp9NJUVERoVCIHTt2kJ6eTkpKykH1BjOZTPTo0YM1a9YQDAbZsmULxxxzDBaLBbp1g//+FyZMgCefhDPOMDK7rrsO+cgjOJYtQ1+3juLMzFj8xuVyseDTRei6JK93Lmk5KTx+0dOx4935/E3tutdrk1dj/PrrrznvvPNITEzkjTfe4IILLiAnJ4eSkpI9Ajr1+55//vl8/PHHzTHvdqs9riBTWFhIaWkp6enp5ObmtvZ0FEVR2rX2+DqgKIrSVjTHOVSVMe6blGFk1R1GE3fhMprRWwe29rTiSBmEwHQjwBX6nthqfsIF9vOMIJdlYLu+UG8PZGQn0v8e+D4AWVl3qxnsZyIcl4P1pEN+DqLRaFwArD4ItrckEk3TGi2F/GWVkj8U4rMFa/h28TrKKqtJtGqkuiyYtYb5WkwaNpsZW6KOdAeoJoSs2+wRISoJUCECVBMEAWZhItuexKC07vRP7kR/d0e6JGRiqlv0IBqNUlxcTG1tLQAul4vs7OyDrqCqqKhg06ZNRCIRMjIy6N69e0OW2003weTJkJMDK1ZARga+s8/G+e231N54IwX334/ZbKZLly6YTCZeuOdVPnr2S8befCYn/2oID499CoATzj2eP3/x+4Oa174053m3xVdjfOmllxBC8Mc//pELLrhgn/ueckpd87hVq5p6OKUVqcwuRVGUtm3FihVMmjSJ77//nl27dsV98vlLQohYebqiKIqi7E7KKLL6vrrVCm2I5JfaTKBLSgmRNUj/B+D/HGR1w0bLiQjneLCdjdCcrTfJo4CUUQjOMbK4QvOIBRq1bITzMnBc0qyZdCaTac9+YFISiUQabYqv6zp+vx+/3x83jtls3iMIdvHpx3LpiIEAbC+uZMqc5SzfsJ1QMEiK00KiDcK+EB4fUGLGarLhdFpwpEZxWb0kYCVPJBEVOpXSCHyV+Gr4xL+YT3ctxqqZ6WBPZXB6NwYkd6KfO48O2dk4nU5KS0vxer1s376d7Ozsgwr+pKSkkJOTQ35+PuXl5djtdjp27GgEFv/9b6OUcd06uP56+OwzaiZMwPnttzg++ABx111k5OTEru1X1PXrOvb0vjx/52TjAAJu++d1TX7O2oomB7sWLjQ69t9www373dftdpOUlERRUVFTD6e0ovpgl+rZpSiK0vY8//zz3HvvvUSj0T1aCSiKoijKgZJSR9Y8BIGvAAsi5XmE7aTWnhZSrwD/Z0az+ci6hg1ajlEe57ioTfcSO1LIaBn4pyJ9U0DPb9hgPc0oVbSNQIjDc70ohMBisRjle7vPUco9SiGDwSDhcJhIJEIkEtmjFNJisRi9r6xWbjl3CLZxp2IymZj/8zY+XbCanUWlWDVJqtMCMkqoJkpVDWjChtnsJMVtxZQWwi69pAsj0OoTYSoIUCH9bPWWsMVXwgc7fsSmWejszOSE9G70dmWTHrCQEIFdu3aRmppKenr6AWXCCSHo0KEDfr+fsrIyioqKcDgcpKeng8sF778PJ54IX3wB//43vjFjCGZnYysqIn3uXBIHGI3oq0qr2bJyOwDlRZUUbTVWKz3r6uF07NX+K7qa/NdYUVGB2+2OW3J0XzRNQ9f1ph5OaUX1GQAqs0tRFKVtWbhwIXfffTcAt912G2PGjOG8884jNTWVKVOmUFRUxPTp03nnnXdISkri2WefJScnp5VnrSiKorQ1Ukpk7RPg/xAwIZKfQdiGt+J8IhD6vq7Z/EwgXLfFCvbRRpmi9RSEUNcnLclo+r8Y6XsbAt8Rex5EMjjGI5wTEObOrTnFOEKIWNbW7nEKXdfjsr/qv49EIrHg2O40TaOz28r/XXAiNpuNUFTy1aKN/LhmCzUeL0k2Ewk2E6FwhOKyCJSBEHYcdiuZ6Tb8CTUk6FY6ykSiQqdKBqkUASqiAdZ78lnvyUcgcJisdLOk0sOeQXdfBn1rOtA7rxtW6/4XUdA0jS5duhAMBqmtrWXnzp3Y7XajVPDYY+GZZ+D22+GBB9BzcigeM4ZOkyeTPHUqoq6P+so5awDo1LcD7zwxDQCTxcT1f76iuZ6SVtXkYFdSUhKVlZWxJSv3pX7lAdXvqX1SZYyKoiht07PPPouUknvuuYdnnnkmdrvVamXkyJEAXHHFFdx1112cffbZPPLIIyxdunRvwymKohwVTCYT5513Xuz7o52UEun5O/jeAgTC/ReE/ezWmUtkq5HB5f8Y9JKGDeb+CMdFxop+WnKrzO1oIvVa8H9s9OOKbGzYYBmIcF4O9nMR4uBWE2xNmqbtUQoJ7FEKWf+9rusEAgECgUBs36HdUxjWywh+7arw8u2yTWzJL4VohBSnBZMGPn+QbTuDAEjhJD3JSXaOlUKtgupIACkk/vqsLxGgKhJkdbSQ1YFCBOAottB9Wxon5PRiUGYP+iXn4TLb9vq4rFYrXbp0YePGjfj9frZv306PHj2w2Wxw660wfTp89BEd7ruPtX/5C3mvvoo2dy5s2AC9erF8llHC6ExwsKPSyNa76K7zSM9NbeZnoHXOu00Odg0YMIA5c+awcOFCTjvttH3u++677yKlZMiQIU09nNKK6jO7VBmjoihK2zJ//nyEELHsrnq/LGccOHAgzz33HBMmTODpp5/mj3/84+GcpqIoSptit9v54osvWnsabYf3JfC+DIBIehzh2Hc/5uYmdY+xkp//g/iV/EQyOMYZZYqWYw7rnI5WMrwG6XsXAp+B9Bk3CgfYf4VwXoGw9G3dCTYzs9mM2WyO65clpSQcDjdaChmNRvH5fKTaBRNO6Qn0JKLrLNlcwuJNBVTWenFZNFxWE0JKyqu9lFd7ieoCszmBLplukrIkW8NleKNBokJSLYNUiAAVBPARZlW4iFU7inhtxzwSzXaOc3fi+PTuDEjOo1dSLnZTfKJRYmIiHTp0YMeOHdTU1LBjxw66deuGyWRCvvwy0YULcezaRae330aefTbiq6/g5Zfh6adZPms1ABuXbQXA7rJxxUPjW+R33Rrn3SZHLy6++GJmz57NY489xrffftvQ/f8XVqxYwcMPP4wQgssvv7zJE1Vah5RSZXYpiqK0UcXFxdhsNjp3bigh0DQt7pPIehdeeCEWi4UPP/xQBbsUpZmMGDGCOXPm8Ic//IHHHnustaezV126dGH79u28+uqrXHfdda09HaUNkd7XkJ5/AiASf4dwTjg8x60vj/NPg8DXDYEVNLANM8oUbWcgxP7LuZRDY6xs+ZXRcD68vGGDuYexoqJjHEI7sNZFRwIhBFarFavVGls9EIxSyF/2AwuFQhAOc1LPbE7qmQ1AtS/AzFU72VRQRjQSwe0wY9IEUo+ytagCWQhhXSPRlcLATmkEE3xs8ZcS0MMERCTW6L6SANURP3PL1zO3fD1moeG2ODkpvSf9k/Po786jR2I2Zs1EZmYmfr+foqIiKioqsNls5OXlUWuxUPnXv9Lp2mtJ/+oronfeaTyY11+n/I772LnOyOaKho3r/asfvYSE5CNnddomB7smTpzICy+8wKxZszjzzDP5zW9+EwuKbNy4kW3btvHZZ58xefJk/H4/p5xyCpdcckmzTVw5PKSUsQwBFexSFEVpW5xO5x6NTBMTE6mpqSEYDBpp7HUsFgtOp5Pt27cf7mkqiqIobZD0vY+s/TMAIuEuhGv/C48d8jGjReD/COn/EKK7vR6ZutaVKY5DmLJafB4KyMgOI4vLPw1kVd2tFrCfiXBeCZYhB9Qs/WihaRp2ux27Pb58MxqNxpVCOhxBLh7qisVGNuRXMH/dTkorPVhM4LKasJoEwUCQJRsKCEUlEgs5qamc0DOLLXoRO/0VBGWYahmiUvgpJ4BXhikPefiyYBlfFizDLDTSbYmcnN6L/sl5HOPOxR1IpqqyktLSUiwWC16vl8iQIRTdfDM5L76INnkyZGZCSQkFz/wn7nG4M5IYd+e5h+33eTg0OdhlsVj44osvOOecc5g1axazZ8+ObTvmmIY0UyklAwYMYNq0aeofSztUX8IohNhr9p6iKIrSOjp06MC6deuIRCKxUvPu3buzbNkyFi1aFNdmoKCggOrqapxOtSS7oihHN6/XS2ZmJgAlJSVxJUxHC+n/DFnzqPGD6yZw3d5yx5IhCM5A+j6A0HygbtEy4TJ6PznGg2WQulY8DKSMQHC2kcUV+r5hg5aLcF4GjksQpvTWm2A7ZDKZcDqdce+vpJSxfmAZGRkM6WM0kvf5Any/biert5XgCwRIsBmBL4CK6lq+XlSLNxzFZrHTKzeH7rkO1vgLKdO9+AhTsVvWVwSdokA1H+9axCe7FmEWJnraMhipdSU1aKNqs4e0BDdut5uaO+7AvWQJzp9+gqQkAJI+eBfoH5vzTU9didXecpmUrXHePaQmTJ07d2bJkiX84x//4H//+98enxZ36NCBiRMn8n//939H5YvIkWD3Ekb1AqQoitK29OnTh59//plVq1Zx/PHHA0ZZ1dKlS/njH//Ip59+it1uJxQKcddddwFGz01FUZSjnc/n2/9ORygZ+A5Z/QAgwXkFIuH+FnmfL8Nr6prNf7Zb5hBgOcEIcNnPRmjqGvFwkNES8E9F+t4HvajuVgHWYQjnFWAbrla2bEZCCCwWyx4L+Ukp6d69aywTbGdxOd8u3sD2kgrQdRwWjQSrCdDZWljO2p06wYiO2+5kUKdk0lKtrI2UUR71UKn7Y72+agkRJsqaQBEe6WOgnkmKtFFTs5VEPZ2eJBN+6gn6XXo5osh4/jsXrCObLhSJBHK6ZXLmNS2/+urhPu8ecsdxp9PJI488wiOPPEJBQQEFBQVEo1Gys7Pjeogo7ZPq16UoitJ2nXXWWUydOpXPPvssFuy6/fbbmTRpEjNmzKBjx4707t2bDRs2UFFRgRCCO+qWm1YURVGOfFJGIbQY9FLQMpAyAFX3AFGwX4hIfPSgAl2/HA/rkLggidQrwf+ZEeSKrG24o5YFjouMZvNmdY3YXPb1fEgpIbQQ6X8XAt8BRsUOIgWcFyMclyHMnVpv8kchIQQ2my3WZiI9PZ3j+/UmGo0SCoX4YfVmZi/bQHlVDVYT2M0adrMG6CzfXkHteuM5zE1J4sKevYg4oqz2FVAa8VAqfVSKAIXSQ5K00p90krw2ilaU4rNXsiFRY8VdV3HlH/4dm889LGGnTKLv0HPxVlVidjoJmSV/WjWNAn8lufZkLu9yCkEpSbG66J2Ui0m0n2qvZl1eLzc3l9zc3OYcUmll9cEutRKjoihK2zN+/Hh27doV99rbtWtX3nnnHa6//noqKir44YcfAKPXxP3338+VV17ZWtNVlKPO66+/zk033UQkEuH3v/89Tz75ZJPG2b0R/u9//3ueeeYZ3nnnHTZv3ozVamXIkCHce++9nHvu/vuthEIh/v3vf/PWW2+xadMmzGYzgwcP5oEHHuCcc87Z6/2i0Sivv/46b731FitXrqS2tpb09HSGDh3K7bffzogRI/Z63/fff5/XXnuNpUuXUlFRgcvlIiMjgz59+nD22Wdz44037tEH53ApKiqie/furXLsliYD3yBrntwtk2c39nMR7icRB3Hh2uh4WjYy8UGE5qprNj8dCNdttIB9tJHFZT1VZQ41s70+Hwn3ImS10Y8ruqVhm2WQkcVlP0c1/m9jTCYTDoeDkSf0Z+QJRmmhx+/n8+9XsnT9NgIBPxZN4HYY1+TeQIjPlm7DE4pgN5vokZnGiMw8SoWfYrz4SwUui5MUp5ncVBcmAduXFPL2X4tx0oML2QTAYEoZTCm8+Tzy7Rf4dPwwnrxhaGxemz3FzCtbj4Ygxeoiz5XOTd1HcmJ6j0N6vIfrvKsiGMo+1ffsUpldiqIobYuu6xQUFHD22WeTmpoat+3CCy9k+PDhfPnll+zcuRO3281ZZ51Fjx6H9uZEUZQD95e//IUHH3wQTdN4/vnnuf32Q++JFAqFGD16NPPmzcNsNpOQkEBVVRXTp09n+vTp+10V0uPxcPrpp7Nw4UIsFgs2m42amppY/91XXnmFG27Ys0l5dXU148aNi/XoNZlMJCYmUlhYyAcffMAHH3zAfffdx9NPP73HfW+44QZeffXV2M8JCQmEw2E2bdrEpk2b+OyzzxgzZgxdunQ51F9PkxypwS4Z+AZZdRcgG9/BdhZCHPil4F7H04ug+u74W819jQCXYyxCSznImSsHYp/PR80DDbcKF9jPRzgvR1iOQWk/EhwOJpx5EhPOPAkpJVvyS/nyh5VszS8CPYrdomG3GEHLgio/awprcVhMdE2145Lg1SNkJlgxaQJPuZfakloS0l1Edhp/NXvkc+o650+dQ7UM8PyNI+M3IakO+YjIEv60ehqP9B9/SAGvw3XebXIO2o4dO5r0pbQvqoxRURSlbQmHw/z2t78lNTWVAQMGcOqpp9KnTx8yMjJ48sknYyvopqamctVVV/Hggw9y2223qUCXohwmUkruvvtuHnzwQWw2G++//36zBLoAXnjhBX766SdeeuklamtrqaysZMeOHVx88cUAPP7443z66ad7vf+jjz7Krl27+Pjjj/F6vdTW1rJu3TpOPvnk2Lyrq6v3uN+NN97I7NmzsVqtPPvss9TU1FBZWUlBQUEsOPb3v/+dl156Ke5+33//Pa+++iqapvHXv/6V8vJyamtr8Xq9lJWV8c0333Dttdditaosk+YkZdTI+NlboAsBtX8zSuCaZby6MR1XIdI+Rkv/GOG6WgW6WsiBPR9mSHwUkTEPzf24CnS1c0IIunfM5M5LRvPMPVfx5K2X0r9LJiaTRlRKNCFIdVronekkzWXFatbIcdsRAnRdsun77dgT7fQ8IYeL6rK69jhG3f+v/PAnzKHIHtsj6CQIK4FomMmbZxKVegs+4ubR5Myurl27HvR9hBCxTKGjzaRJk5g0aVIseNReqGCXoihK2zJu3Di+/vrrWFCrXnl5OY8++igbN27ktddea53JKcpRLhQKcfXVVzNlyhTcbjcff/zxPsv7DlZ1dTWTJ0+Oy77Ky8vj/fff54wzzmDu3Ln8/ve/5/zzz2/0/j6fjwULFsStnN67d28+/fRTOnXqhMfj4fPPP48rd164cCHTpk0D4LnnnuPXv/51bFt2djaTJ0+murqaadOm8cgjj3DdddfFShIXLFgAwOjRo3nggQfi5pKWlsZZZ53FWWedtc/HHAwGCQaDsZ9ramr2uf++FBYWUlhYiN/vj922fPlyHA4HADk5OeTk5DR5/DYjtLjx0sUYCXqhsZ/tpGYYzxhT2M9GWPoezEyVpjig5yOCMPdEaAmHZUrK4SWlZGDXbI7JSaampgZ/OMKmEg92i4lAVCfBZsJh0RACaku8hPxhPOVeRpWtZl9X9QIw6ZKLv1jKexeeuMf28oiXVFsCO7xlrK8poK+7437n2prn3SZndkkpD/pL19t+9K+l3H777axZs4ZFixa19lQOiurZpSiK0nZMnTqVr776CiklPXr04MEHH2TSpEncf//95ObmIqXkzTffZM6cOa09VUU56tTU1HDOOecwZcoUcnJymDt3brMGusAIbF1//fV73K5pGg8//DBAbIXWxlx88cVxga56GRkZnHLKKQCsXLkybtv7778PQMeOHbnpppsaHfdPf/oTAGVlZXz33Xex25OTkwEoLS1t8ge+Tz31FG63O/aVl5fXpHEA/vOf/zB48GBOO+202G133HEHgwcPZvDgwfznP/9p8thtil56QLvJmkeQ3snIyLbmGS/wCVKvOqB9lUNwgM/HAe+ntDvhcBi/308oFELXdWwmjd5ZiZhNgqgusZk1NCHQhMBbaayAaKuo4PgV8w5o/I6FlY3eHpFRLJqZiNSpDHkPaKzWPO82OYKxdevWfW6vrq5m4cKF/POf/6S0tJQ333yTPn36NPVwSitRPbsURVHajrfeegswVmH85JNPYqv5ADz00EOMHDmSZcuW8fbbbzN8eMsvIa0oiqGwsJDhw4ezfPlyevXqxTfffNMiPahGjBix15Xzhg0bhtlsJhKJsHjxYgYMGLDHPiedtPcsnvqFLioqKuJuX7x4MQBnnHEGmtb45+R9+vShQ4cO5Ofns3jxYn71q18BMGrUKOx2O8uWLWPYsGHceOONjBw58qAqRB588EHuvffe2M81NTVNDnjdfPPNsay3pUuXMnHiRF5++WUGDRoEcGRkdYGxKt+BiG5D1v4Vav+KNPcA22iEbRRYBsQ3rj/Q8fwfIP2fIG2nIexjwTYSobkOfv7Kvh3o83Gg+yntSjAYpKSkhFAoRDgcxhOIsKaollA4So9MF2lOC1azRtAbZNP87SRv3MDNi7+gY0X+nn269mJXTuMlyGZhIqxHMAuNFOuB/dtuzfNuk4NdnTvvf8nYY489lquvvppRo0Zx4403smzZsqYeTmklqoxRURSl7Vi6dClCCP75z3/GBboAkpKS+Otf/8qZZ56pXm8V5TD773//C4Ddbmf69OmHlH20Lx06dNjrNrvdTlpaGsXFxZSUlDS6T2Ji4l7vX5/FHw6H426vH2tfxwYj8ys/Pz/u2N27d+eVV17hlltu4YcffoitDpuRkcEZZ5zBFVdcwfnnn7/XAB6AzWbb43zXVI2VywwaNCh20XXEsA4BLRv0Yhrv6ySMQIjrZgjOhNBCiGyCyCak9yXQMpG20Qj7aLCeeADjASIRtFyIrofgLGRwFggH0jayLvA1TK0A2FwO6PlINvZTjhhSSiorKykrK8Pr9VJa7WX1rio8wQg2s0Z2khWHRUOLRNkwcys9l8znlhUzSfZVxYJcEQSmur+Zxs66EtA1wQdjGj8nppldeCJBuiVk0jspt9F9fqk1z7tNLmM8UHa7nWeffZbCwsImL7estB5VxqgoitJ2lJWVYbfb95opPWTIkNh+iqIcPmPHjsXtdhMIBLj++uvx+XytPaU248orr2T79u289NJLXHbZZeTl5VFaWsqUKVMYN24cw4cPP6Q+XMqehDAhkh6q/+mXW43/Jj2C5roaLfVVROaPCPczYD/XWL1PLwH/O8jKG5AlJyOr7zO27XU8gXD/GS3jM0T6l+C6HUydQPoh8AWy6lZkyVD06oeQwR8OuDG+0rh9P791ZBX43j5cU1JaWCgUYufOnRQUFLBq43Y+WrCWHzeXEYxE6ZBsp0e6E1ckyvxnv6fD317g3pcf4pIfPiSlLtAVdDiZN3g0V3W4jin0AvYMk9b//PZFJxKx7nntb0bDI0PYTRZu7D4Sk2jxUNIhOywzHDx4MC6Xi88+++xwHE5pRqqMUVEUpe0IBoO43e69bq/ftnszZ0VRWt7gwYOZPn06KSkpzJgxgzFjxuD1Hlg/k4ORn5+/123BYJDy8nIAMjMzm+2Y9WPt2rVrn/vVb2/s2Kmpqdx8882899577Nixg02bNvG73/0OIQTz5s3jsccea7b5Hgiv18uZZ56Jw+HY5zm1PRP2sxHJz4KWFb9By0YkP4uwn92wr5aEcIxFS/43InMhIuUVcEwwsr+kBwJfgO9VjEtHyz7HE+YeaIl3I9K/Q6R9AM7rQMsEWQP+qcjKa5Glw9FrnkSGVuyx2IpyYPb1/GI9HQBZ+wR67TPqd9yOSSmpqqpi8+bNzF+xjndnLWfB+gIC4QiZiVa6pztI02DZk1/SbeJveWbuM5y6dCb2YAAJVKdlsOCue/jinXdZ9quLqanw84o4lin0Yo9u6prGp5cM5/kbR+4xDw2B2+qkW0Imj/Qfz4npB7/Cd2ucdw9Luo6u60SjUQoLCw/H4ZRmIqVUZYyKoiiKoigHYMiQIcyYMYPRo0cze/Zszj33XL788ksSEppvNbQ5c+YgpWy07G/evHmxDynrszybw5AhQ5g3bx6zZs1C1/VG+3atW7cuFog74YQT9jtm9+7deeqpp9i5cydvv/12XFP7w6W+N1l2dvZhP/bhIuxng2103ep9pUbwyjoEIfb+vl4IK9hOR9hOR8rHILwKGfwOAtMhugXYLSvL1A3s54O5+x5/l0IIsByLsByLTPwthBYhA59D4Bsjc8z3OtL3Opg6Ie1jEI5fIcwHfwF9NNvb8wsaeF9Eev4F3peQejkkPY4QqlKnPQmHw+zatYt5yzewblcpwXAUISDZaSEzwUKiZmLjE1MZv/Y7rqY8lsUkgapj+vLX289khaUD0quRWrqVzMEmct49gao1Vcz8sRdLQxqXmHYyMM+J3rULgRtu4Eynk+FmyZ9WTaPAX0muPZnLu5xCUEpSrC56J+UeUkbX4T7vHpa/+FmzZhEIBMjKytr/zkqboet67JMAFexSFEVRFEXZt+OPP56ZM2cyevRo5s2bxznnnMNXX321z15ZB2PHjh28/vrrXHfddXG367rOn//8ZwD69u3baHP6ppowYQL//Oc/yc/P55VXXuHXv/71Hvs8+uijAKSnpzN69OjY7cFgcJ/9tuqXnt9b43vl0AlhAtveFybY9301sB6HsB4HifchI1sgMAMZnA7h5Ubwy/svpPdfYOqCtI9G2EaD5bi4gJoxh5MRtpORSY9C8Hsj8BWcAdEdRmDG+yLS3Nvo72UfgzB3bJ5fwBFur89vwm2gpSJrHjMy6vRKSP4nQjRP/zul5UgpKS4u5tO5S9lSVE44YuRgOa0mcpJspNnMVD30CiM2z+FyvHH9uIqGDePuO05kZ1J9BmZl7L8WexZX9RjF6WP7YjNZ9jhufUc9J/CPwde05EM8bFo02BUOh/noo4+49957EUIwcuSeKXFK21Wf1SWEUG9CFEVR2oji4uJ9fgAhhNjnPkKIWPaHoijN77jjjmPmzJmMGjWK+fPnc/bZZ/P111+TlJR0yGO73W5uvfVWwuEwV199NXa7nZ07d3Lfffcxa9YsAJ544olDPs7uTjzxRMaPH8+0adO48847CYVC3HDDDTidToqKinjkkUeYOnUqAH/605+w2+2x+95xxx1UV1dz2WWXMWzYsFiJo8fj4a233uKNN94AYMyYMc06Z6VlCHM3SOiGSJiIjJZCcKYR+AougOg28L6C9L4CWprRmN42GmxD4wIsQljBPhJhH4nUfcYYgc8hOA8i65Ge9eD5B9IyCGEfA/ZzEab01nvQ7ZhwTgAtBVl1LwSnIytuhJQXEVrzBN+V5mU0oK/mvW/ns62onKgukYBZE+Sl2MmxadgeeIbhOxeTRMNCIj5hYcO4sfzmhmPw/iK6Y0JwqrMbF3U4gZO69DvqEliaHOzq1q3bPrcHAgFKSkqQUiKlxO1284c//KGph1Nawe4ljPtaJUdRFEU5fFTvDUVp+wYMGMDs2bMZOXIkP/zwA2eeeSbffPMNycnJhzTubbfdxrx58/j1r3/N7bffTkJCApWVlbHtDz/8MBdeeOEhzn5PkydPpqysjDlz5nDnnXfym9/8hsTERKqqqmLnpPvuu49bbrkl7n7hcJipU6fGgmEJCQmYzWaqqqpi+5x22mk89NBDKO2LMGWA8zKE8zKk7oHQ98jAdAjOAr3cyCbyTwXhRFqHGSs72kYgtIZePUJzgmMswjEWqVdB4Fsj8BVaCOGlyPBSqH0SaR1al/F1pgrUHCRhPxtSJiOrboXwT8iKKyHlFYSp+fr6KYdGSklpeQXvffsDO4sr0KVEl6BLna5pTrqbImTc/ziDStZhreu0JYFyzcUPv57Any/IJvqLDlw2zFzkPp4RyT3onNWBlJSUo/J6vsnBrm3bth3wvqeddhrPPfccvXr1aurhlFag+nUpiqK0LepDI0VpP/r27RsLeP3000+MHj2a7777jpSUlCaPabVamTFjBv/4xz9455132LJlC263myFDhnDvvfdy3nnnNeMjaOB2u5kxYwavv/46b775JitWrMDj8ZCdnc3QoUO54447GDFixB73e+SRRxg8eDCzZs1i7dq1FBUV4fF4yMzM5LjjjuPyyy/nmmuuUe812zmhJYD9HIT9HKQMQ+gnZHCG0edLL4LgN8jgN4AJaT3ByPiyj0aYcncbIxmclyKclyKjxRD4ygh8hVcagbTQ91DzKNI2AuEYawTOhH2vc1IaCNvJkPo2svImiKxDVlwOKa8izJ1ae2pHNV3X2VVYwgczf6KgzPjgIKpL/OEox2QlMKC2lM6/eZTu1bvi+nFtMafxyf9dxfsjnHUrKDYEulLNLiamnEJfVw4Ws4WcnBxcLtfhf3BthJBN/Ij49ddf3+d2s9lMSkoKxx13HB06dGjS5I5ENTU1uN1uqqurmyWdvSVVVVWxY8cOXC4X3bt3b+3pKIqiHBHa0+uAoihtw4gRI5gzZw5/+MMfDvvKhW1Nc5xDvV5vbOEAj8dzVF8MtiQpJUR+RgZmQHA6RNbH72DuW5fxNRrMvRvNPJGR7RD4Aun/DKKbGzYIF9hGIxy/AuspCLFnDyIlnozsQFZeD9GdoKUhUiYjLH1be1pHnWg0yobtu/h0zlJKKmsACEclNYEw/XOTGLZlFV3+9SKZvopYP64ogiXWPF57+DIWn7BnvlKPhGwe6f4rTLVhpJTY7XZyc3OxWNrOv4vmPO8e6OtAkzO7rr322qbeVWknVGaXoiiKoiiKcqTRNC22YqXqS9tyjBUZ+yMs/SHxbmRkh9E7KjADwksgsgbpWQOeZ8HUEWkbbQS/LINiKwcKc2ej2brrViMrKfA5+L8EPR8CnyADn4BIQdrPNTK+LIOMxvrKHoS5E6S+h6y8sS7D60pIftHI/FJaXCQSYfn6LXzzw0oqarwABCI6Fd4Qgzsmcd73s+n0pykkhP2x+/gx8a29N5MfHkvR4D2vyYdn9OHxAZdQVVZBbU0tEiMTNzMzs82d21rjvKvWH1X2SgW7FEVRFEVRlCONw+Fg0aJFrT2No44wdwLzDQjXDUi9AgKzkcHvIPg9RHeB7zWk7zUQyUjbGXVZX6chhKMucNYHYemDTPg/CC9HBj6DwFegV4D/HaT/HdBykI4xRo8vc5+jsk/RvghTRl1JY10Pr8obIfkZo7eX0iJCoRALVqxnzpI11PgCAHhDUco8QYZnO7jgu2nkzJyJRTeuvSVQhp2pzuOY9ruh1J4QX65rEhrXdh3GzT3PIhQKUZBfQCgUQghBZmbmIfeGbCmtcd5VwS5lr+pX6zKb1Z+JoiiKoiiKoijNQ2ip4LwI4bzIWJUxNL+uz9dMkFUQ+AgZ+AiwI22n1vX5OgOhpRqZW9ZBCOsgZOJDEPrRKHMMfgd6YcOqkKZu4BgL9rEIc5dWfsRth9ASIXVy3SqN3yGr7oKkx43VG5VmEwgEmP7TKhau3oQvEAKgOhCh3BNmnDvEeZ//j7QVK9HqOm9JYDNuXnYN4Yf7BxA4yRE3nl0z82i/ixnd4VgAamtrKSoqQtd1LBajP5fDEX+fo90BRTF27NjRbAfs1Ek1wmsvVGaXoiiKoihK87joootYsGDBQd3nww8/ZOjQoS00I0VpG4TmNFZatJ+JTIoYKzEGpht9vqK7IDjDCITVaEjLYIR9lNGvy9zJKHe0nYawnYaUf4TgbKT/CwjOhOgWpOdZ8DyLNPc3yhzt5yFM2a39kFudEDZIfhZZ8wfwT0HWPGqsoum6TWXDHQIpJT6fj8+/X8aKjdsJhozkkXJfmEpfhInhfIZPeYOEHTt268cFi8lmUsIJbLqnM5FT41ccdVscTBp8I72Sc2PHKCsro6KiAgCn00lOTo5KUGnEAf1Gunbt2iwHE0LEsoWUtk8FuxRFURRFUZpHRUUFxcXFB3WfUMjIBpg9e3YLzOjo5fP56NvXaMy9Zs0anE5nK89IqSeEGawnIqwnIuWDRlP7+j5fkZ8hvAgZXgS1f0Gae4NtlFHuaO5nBHDsZyPsZyN1j5G15P8cQgsgshpZuxpq/4q0noiwjzH21Zq+Omp7J4QJkv6E1NLB+wLS82/QyyDxEdX37CBJKamuruWj2YtYt72QSDSKBEpqQ3iDEX63awkDP5uGraoqdp8AJr6mM5Odx1N+dzaR0+MbrefaU/jfibeQ6mwIfkUiEQoLC/H5fACkpqaSnp7eLgKUrXHePaDVGJuzgZiu6/vf6Qg0adIkJk2aZKy+sGFDu1iFa/PmzXi9Xjp37ozb7W7t6SiKohwR1GqMiqIoTadWYzx6yWgBBKYbWV6hnzByYupoOWAfaZQ7Wk+MW53R6A/2lRH4Ci/ZbUQz2IYZ/b1sIxHa0ft3IL1vIGufMH6wn4dw/w0hrK07qXZASklpRQXTZvzEloJSdF2iSyisCWIOhfjDsq/oNms6proPLiRQiY13OYaP7T3x3plFZGT8eax/Uh7Pn3AdTkt8SaLf76ewsJBwOIymaWRnZ5OYGJ8F1pa1xmqMBxTs2r59e5Mn8kudO3dutrHao/Z0kbN+/XqCwSDdunWL/WEqiqIoh6Y9vQ4oiqK0NSrYpQBIvQqCc4xyx9A8kL6GjSIJbCOMckfrMITWcB0jowXg/8JY1TGydrf7OMB2BsL+KyMAdhQGeqT/c2T1b4EwWE9FJD8X97tTGui6zq6iEj6cuYhdpZVIKYnokoLqILneGn4/dyqZy5Yg6hJ9JLCNJF7iWJY6cvHdnE747IZkEgEMz+zLkwMuw2KxxB3LyBqrpqSkBCklVquV3NxcbDbbYXzEh641gl0HVMZ4tAeojlaqjFFRFEVRFEVRlLZGaMnguADhuAApgxBcgAxON3p16eUQ+BQZ+BSwIG1DEbZRRsmjKRcSJiISJiIjm4z+XoHPIbodAl8iA1+CSELazzICX9YTjXK/o4BwjAUtGVl1h7FgQMU1kPqKsZiAAhjXx5u25fPJvCUUV9QAEIrq7KoMcErpdp6Y+QEJWzbH+nHpwFIyeZbjKbQn4bspg/CYhiCXCY1LOp3MvX3HNno8XdcpKSmhuroagMTERLKystT1+QFSXcyURkkpVbBLURRFURRFUZQ2zejVdQbCfgZSRiG8wgh8BaZDdJuRARacA/wBaRlYt7LjKIS5ByLxbmTCXRBZZZQ5Br4EvQT8HyD9H4CWibSfa5Q6Wo5tF72RDoWwnQYpryMrJxp9zsovh5TJCHPH1p5aq4pEIqxcv4Wvf1xJebUXgEBYZ2eljys2LeHCOZ9hLSuLBbmCaEynE//hWPw2G/7rUwld0BA0tGpmbu0xmiu7nb7XY4bDYQoKCggEAgghSE9PJyUl5Yj/G2xOKtilNErXdeorXFWwS1EURVEURVGUtk4IE1gHIayDkAn3Q3RzXZ+v6RBeCeFlyPAy8DyNNHUD+2gj+GU5Fi3pWGTibyG0GBn4DALfGIEv3+tI3+tgykPaxyLsYxGWnq39UFuMsB4Hae8iK26E6FZkxQRI+R/C0qu1p3bYhUIhfli5ntlL1lDjDQDgCUYpKa/l/5Z+xyk/zsTk98f2r8LKFHoxlV5gNRG4Jo3g+IZFEFwmG48OuJgzsvvt87her5fCwkKi0Sgmk4mcnBxVbt0EzRbsKikpYdeuXXi9XvbVBuz00/cevVTajvqsLiFEsy5QoCiKoiiKoiiK0tKEEGDuAQk9EAm3IKPFEJxZ1+frR4huAe9/kd7/gpaBtI2q6/N1CprtJGTSoxCcbwS+gjMguhO8LyK9LyLNvY1sL/uYIzLrSZi7Q9p7yMobIbIRWXEFpPwHYR3c2lM7LAKBADMXrebHVRvxBozm8lX+CNH8In7/wyf0XBnfj2snifyXASwUuWARBK9II3BZQ5ArxeLi6eOv4tjUfbeHklJSWVlJWVkZUkrsdju5ubl79PFSDswhB7uef/55nn32WTZv3rzffYUQRCKRQz2kchjsXsKoUiUVRVEURVGUI4UQgr59+8a+V44OwpQFzssRzsuRei0E59b1+ZoDein430P63wPhQtpOR9jOBNvpaPYzkLqvLlD2BQTnQmQ90rMePP9AWo6vC3ydizClt/bDbDbClA2pbyMrbzYy4iqug+RnEfYzWntqLUJKidfr5av5y1m2cTvBkBG3KPOGyVy/jqcWfELG1k1x/bhWksFzDGSHcINZELksFe+VDeWKHRwpvHDCTeQ4U/Y84C9Eo1GKi4upra0FwO12k5mZecQknrTGefeAVmPcmwkTJjB16tR9ZnL9kl4XAT1atZdVuGpra9m6dSt2u51evY6+lFVFUZSW0l5eBxRFUdoidQ5VmpuUIQj9ZGR8BacbpYsxZrCehLCPrmtwn22sBBn41ljRMbQQI7cHQAPrKUZje/uZCC3x8D+YFiClH1l1lxEUxIRwP4lwXNTa02o2xmqHtXwydzFrtxUQjkSREoo9QU76aT43/PQVrrLSWJArjMYs8pjEcfiEFUyC6PhUPNemQF0Q55jEXJ478QbcFucBzSEYDFJQUEAoFEIIQWZmJsnJyS3zgI8AB/o60ORg13vvvccVV1yB2+1m8uTJnHvuubhcLrKzs9m1axdFRUV89913PPnkk1RVVfH+++9zxhlHZhT4YLSXF+iqqip27NiBy+Wie/furT0dRVGUI0Z7eR1QFEVpi9Q5VGlJUuoQXoUMzjACX5FN8TuY+yPsZ4JtFJh7GoGxwFdG4Cu8crcdrWAbbqxwaDsDIeyH9XE0NynDyOqHIPAxACLxAYTrptad1CGSUlJaXs6HsxazOb8UXdfRpaS4wsulsz5jzPJ5WPy+2P41WJlGT96jN7rQwARckEb1jUaQSwAnp/Xi7wOvPKiyw9raWoqKitB1HYvFQk5ODg6Ho/kf8BGkxYNd55xzDt999x3//ve/ueOOOwDQNI3s7GwKCgpi+3k8HoYPH86mTZtYsmQJPXr0aMrhjhjt5QW6vLyc/Px8kpKS6NKlS2tPR1EU5YjRXl4HFEVR2iJ1DlUOJxnZBsEZyMB3EF5GQxYXYOoEttFG1pfleIjugsAXRuBr9yCZcBn7OcaCdShCtM/+S1LqyNqnwTfZuMF5IyLxfoRoX2V2uq6zq7CYj+YsYWdxBVJKIrrEu6uIid99wAnrl6PVtfSRQIFI4BXZj+9FnjGABtrYVConpoJJYEIwpsNgHh5wcNluUkrKysqoqKgAwOl0kpOTg9ms1hDcnxYPdmVlZVFWVkZ5eXksxU7TNDIzMykqKorb94cffuDUU0/lxhtv5OWXX27K4Y4Y7eUFuri4mOLiYlJTU+nY8chruqgoitJa2svrgKIoSlvUHOdQn8/HCSecAMCiRYtwOg+s1Eg5usloGQRn1fX5mg+EGjZqqWAbibCNRlpPQUS3G43t/V+Cnt+wn0gxens5xoBlcLsLFAFI7yvI2r8ZP9jHGWWN7SCAF41G2bR9F5/OW0ZRRTVICEV1bD+v49YZH9Bt15ZYqaIE1pjSeTZ6HFtEXb8tDUxnp1FxawqYBRZh4sbuZ3BDj5EHPZdIJEJhYSE+n5E5lpqaSnp6+hHdQ7A5z7sH+jrQ5LBhVVUViYmJcbWkFosFr9e7x76nnHIKTqeT6dOnN/VwymG2e4N6RVEURVEURTlSSClZs2ZN7HtFORDClA7OSxDOS5C6F0Lf1/X5mg16Bfg/QPo/AOFAWk9D2Ecj06YhotuMbK/Al3X7vYP0vwNaDtIxxmhub+7TbgIdwnUTiFRkjVHWKGUVJP8bIdpm6V04HGblhq188+NKyquNWIUvHKX79/O4bv7npFWWxYJcUZOJ77WOPBseQI1uBwEIMI9OpfLONHQz2DULD/a9gHM7DmrSfPx+P4WFhYTD4VhlXGLikdHfbV9a47zb5GBXWloafr8/7rbk5GTKysqoqqpqtKHaLzO+lLZLBbsURVEURVEURVH2JDQX2M9G2M9GyjCEFht9vgLTQS+A4HfI4HeACWkdYmR8pbyP0HfWBb6+Bb0QvK8gva+AqSs4fgX2sQhzl9Z+ePslnBeBloysuhuCs5EV10PKSwgtubWnFhMKhVi4aj2zFq+l2mvELbzeICO+/IgLVszFsVs/roDdwceyO68Ge6HrWizIZRmeStU96USskkTNxlPHTuDE7N5Nmo/RCL+akpISpJRYrVZyc3Ox2WzN8XCVRjQ52NWhQweWLl2Kx+MhISEBgD59+jBv3jxmzZrFhRdeGNt36dKl+Hw+UlL2v+Sm0jaoYJeiKIqiKIqiKMq+CWEB2ykI2ynIxIcgsrZhZcfIOggtRIYWAk8izceAbTSk/A+ixRD4AoKzILoV6XkWPM8izf2NMkf7GIQpu7Uf3l4J+0hIfQ1ZeTOElyIrroSUya0+Z7/fz+zFP/PD6o14/UapaaisgvEfvc2wjcsx7daPqzoljcnh3nztzTXuXBfksp2aQtW9GVTbJWkmJ08dczHHdezV5Ow7XdcpKSmhuroagMTERLKystS1dgtrcrBr0KBBLF26lEWLFsVWWRwzZgxz587lvvvuo2PHjgwcOJAVK1Zw/fXXI4Tg1FNPbbaJKy0rEokAqAZ5iqIoiqIoiqIoB0AIAZa+CEtfSLwLGdkJwZlGn6/QIiP4FVkH3udB6wD2UZD8rFHeGPgSQgsgshpZuxpq/4a0nGA0trefjdDaXuKIsA6G1HeQlTdAZCOyfAKkTkaYux/WeUgp8Xq9fL1gOcs27CAQCgNg37iJKz5/h76/6MdV0KkLz1Qfw8qqhLhx7CenUHt/JtUOnQ7mJJ7s/Cu65XXDbm/6aprhcJiCggICgQBCCNLT00lJSWk3ZavtWZMb1H/66aeMGzeOW265hRdeeAEwVl7s06cP+fn5cU+elBKLxcLcuXM56aSTmmfm7VR7aUy8fv16gsEg3bp1i2XuKYqiKIeuvbwOKIqitEXNcQ71er2x97cejweXy9WcU1SURkm9wij5C8yA4Dwg0LBRJINtOFhPAr0Wgt9CeMlu9zaD7TSjv5dtlFFG2YbIyC5k5Y0Q3QoiGZHyMsJ6XMsfV0qqq2v4dN4S1mwtIByJIiV0+nE+l07/mJyq0liQSzeZWNd3AH8p6EFhRfw4jiEp+B7IoiYhSi9zOr/NOpOcnBxSU1PRtKYvIuD1eiksLCQajWIymcjJyTlqzzfNed5t8Qb15513HrNmzYrrop+QkMDMmTO57rrr+OGHH2K3d+rUiUmTJh31ga72RJUxKoqiKIqiKIqiNA+hpYLjIoTjIqT0Q3CBkfEVmAmyEgKfGF/YwHYqJNwP0gfBmRBZawTKgrMBO9I+si7wdTpCWFv5kYEwd4S0d5EVNxmZaZXXQvLzCNtpLXI8Xdcpq6jko9mL2byrhKiuo0cinPzlJ5y3cCaJgYZF84JOB0tOHsozq7KpXh2MG8cxMJng73IoToww2JLFrVnDSUhIIDs7G4ej6Q33pZRUVFRQXl6OlBK73U5ubi4WS9tftfJI0uRgl9lsZvjw4Xvc3rNnT+bPn8+uXbvYuXMnbrebPn3az+oSivGPUwW7FEVRFEVRlCOREILOnTvHvleUw00IB9hHIeyjkElRo+dVfZ+vqFH6SHAmRpf0QeC8CWQAQvMguh0CXyIDX4JIQtrPMgJf1pMQovWu3YSWCqlvIKvugNACo5eX+69GGWYziUajFBSV8vGcxWwvrkBKianWy9hpb3DamiVYokYrHgnUZqQyc9S5vD7bjGeWF2gIdDn7u4k+2IHS5AijbF0ZlzSAhIQEUlNTSU9PP6Rsrmg0SlFRER6PBwC3201mZuYhjXkkaI3zbpPLGJWmaQ/lK9FolJ9//hmA/v37H/X/MBVFUZpTe3gdUBRFaavUOVQ5kkkpIbIRgtON4FdkdfwOph5gORYIQ2gh6CUN27QMsJ9nBL4sx7ZaIFfKELL6AaMHGQKR+BDCdc0hjRmJRNi8M5/P5i6jsKIaJCTn72Tc1Nfpt3MzGkZIQwJFPbrw1ZgL+OyDajwFnrhxnH2S4MFOVKRHuNh1LCeaO+JyuWLZXLtXrTVFMBikoKCAUCiEEIKsrCzcbvchjansqcXLGN9++20uuuiiQ0rvU9qm+qwuIYQKdCmKoiiKoiiKohwGRoP7XmDphUi4DRkthMAMZHCGEdyKbjK+AEQmWEcBEQgvB70UfK8jfa+DKQ9pH4uwj0VYeh7mx2AF9zNILRV8byFrn0DqFYiEuw86ABcOh1m9cRtf/7iSsiojcNVtxRIu+Px9OlSUNPTj0jQ2nXAcn425kAUvb6Xm2fy4cZy9kjA9kEdNB8GNqafQTXdjMplwuVykpqaSkZFxyNe9tbW1FBUVoes6FouFnJwcFStpZU3O7NI0jcTERMaPH8/VV18dW5FR2bf28GmU3+9n48aNWCwW+vTp09rTURRFOaK0h9cBRVGUtkqdQ5WjldRrIDjH6PMVnAvSu9tWF1j6AlGjv5f0N2wy9zayvexjjN5ah2u+UoL3BaTn38YNjssQSY8dUKllMBhk0eqNzFqyhiqPH3SdU6Z/wZlzv8btb3jcIbuN5ecM5+vh57Dyn6up3lkTN46zWyK2BzoT6Gbj7swRpEZtBINBnE4nLpeL7OzsQ24YL6WkrKyMigqj6339uGZzk/OKlP040NeBJge7XC4Xfr8/Fp3t2LEjV111FVdffTXHHHNM02Z9FGgPL9C1tbVs3boVu91Or169Wns6iqIoR5T28DqgKIrSVjXHOdTv93P66acDMHfuXJV9obQ7UoYg9ENdn68ZoJftttVslDsKILIJiDRsshyPsI8xyh1N6Ydnrr73kDWPATrYzkQkP4MQtkb39fv9zF2yhgWrNuLxB7EGfJzz4TucvPxHbLv14/KmpTDvil/xQ58hrH16BVXbquPGcXZOwHlfV0S/JH7f6VyEP4LH40HTtLhsrkPtTx2JRCgsLMTn8wHEen6pXoB7as7zbosHu7xeL9OmTeONN95g9uzZ6Loee1IHDRrEtddey+WXX05aWlrTHsERZtKkSUyaNIloNMqGDRva9EVOVVUVO3bswOVy0b1799aejqIoyhFFBbsURVGarjnOoV6vl4SEBAA8Hs8hZ3YoSmuSUofwSmTwOwhMh+jW+B1MHQHNaHxP/aW/BtZT6jK+zkJoiS07x8A3yKp7gTBYTkSkvBg7ppQSn8/H1z8sZ+n67QSCYVJLizh/ymv027oeTTb04yrt2olvb7mcLald+PkvS6nYUhl3HEdHF4n/142UIdk81PsiPJWVeDweAoFAXDZX/b//Q+H3+yksLCQcDqNpGtnZ2SQmtuzvsT1rzvNuiwe7dldQUMBbb73FW2+9xerVRhM9IQRms5lzzz2Xq666ivPPPx+rtfWXRW1t7eEip7y8nPz8fNxud2zFBEVRFKV5tIfXAUVRlLZKBbsUZd9kZHNdn6/pRi+v3YlUEOb4xvZYwTbcWDXRdgZC2FtmXsEfkVW3GuWX5j6Q/DK1XhufzlvKz1vyCUei9Fy3ijEfv0vH0oKGflxCsH3wAL684xp8MpWlf/6Rsk0VcWPbc5yk3dudTsN68OCACykvL6empia2ImJCQgLJyclkZWUdcjaXlJLq6mpKSkqQUmK1WsnNzcVmazxbTTG022DX7lasWMEbb7zBu+++S1FRkXEQIUhOTubSSy/lxRdfbM7DtTvt4SKnuLiY4uJiUlNT6djx8NV1K4qiHA3aw+uAoihKW6WCXYpy4GS0BIIzjXLH0A9AuGGjcAJmkLv1uRIusI02Al/WoQhhad75hNcQrbiJsmonny49h01FmUQjUYbO+45RMz7H7a2NBbnCVis/nzWM6TdNwOVzMf+P31O8viRuPHumg4zf9GTQ2cdz27Hn4fF4KCkpwePx4Pf7cTgcuFwusrKymuU9l67rlJSUUF1tlE0mJiY2SwDtaHBEBLvq6brO9OnTefPNN/n444/xer0IIWIr/R2t2sNFTkFBAWVlZWRkZJCTk9Pa01EURTmitIfXAUVRlLZKBbsUpWmk7oHQvLo+X7NB1u621Vz3FWi4SaSA/VyEYwxYBiPEoa1WGI1GKSgu5ePZP7C9uBpTMMjYT97nxMXfY4s0BOG8yUn8dNmvWHnxGFKr7Ux/dAYFa4vjxrKl2ci95xjOuGAoE/qdQTQapaSkhKqqqlg2l8vlimVzNUez+HA4TEFBAYFAACEE6enppKSkqP5cB6g1gl0ttkSApmkMHDiQ1atXs3TpUtauXdtSh1KaWX1AUkWoFUVRFEVRFEVR2j+hJRjBK/u5dQ3uFxmljoHpoBfT0MheYGR8VYL/HaT/HdBykPbzEI5fgbnPQQV4IpEIW3bk8/n3y8kvryKlrJTrpr1Bnw2rMe3Wj6uiUwdmT7yc6uHDSK60sPQ3X1Lwc1HcWNZkG53uOoaLrjibUT0Go2kaHo+HoqIivF4vPp8Pu91OQkICmZmZJCUlNUswyuv1UlhYSDQaxWQykZOTo4Lk7UCzB7sCgQAfffQRb775JtOnTycajVKfPDZw4MDmPpzSAuqDXWq5VEVRFEVRFEVRlCOLEFawnYqwnYpMfBQiq5GBGRCcDpENxJU7ooFeCL7JSN9kMHUFx1iwj0WYu+71GKFQiDWbtvP1jysprfLQbdNa7vnobToW7Yrrx7XzuN7Mvv1iXH37kVSTzcd3TKNo1S+CXElWutzeh+tuHMegzn0wmUxEo1EKCwuprKzE6/Wi6zpJSUm43W6ysrKwWA69BFNKSUVFBeXl5Ugpsdvt5ObmNsvYSstrtmjGrFmzePPNN5k2bRoejycW4MrNzeWKK67gmmuuoX///s11OKUFRSJGVF9ldimKoiiKoihHovT09NaegqK0CUIIsAxAWAZA4j3IyA4ITjfKHcNLAT3+DtGtSM9z4HkOae5vlDnaxyBM2QAEg0EW/7yRWUvWUFnt5ZQfZ3Pzt5+SXFsVC3JFLBbWjRzKottvJCe9gq4la/nvLZ9RvDoUdyhLgoUet/bj5psvoVde11iQyev1UlRUhMfjiWVzuVwuMjMzcbvdzZLNFY1GY8cASE5OJiMjA007tHLOo9nhPu8eUrBr7dq1vPnmm7z99tvs2rULMKKfTqeTCy+8kGuuuYbRo0erOtZ2RpUxKoqiKIqiKEcql8tFaWlpa09DUdokYe4E5hsQrhuQegUEZhnljsHvgWD8zpHVyNrVUPs3fPpwvt8wgh/WCvzVHs778gNOWjgHe6jhPr6kRJZdPIbt11xB15QcjimP8uxtr1O2ojxuWLPTzDETB/Dr2y+mW17n2EqHuq5TWlpKRUUFHo8HXddJTEyMZXNZrdZm+R0Eg0EKCgoIhUJomhYLoilN1xrn3SYHu4YMGcKyZcsAI8ClaRojRozgmmuuYfz48aqGtR1TwS5FURRFURRFUZSjm9BSwTke4RyP1H0Q+r6u3HEWyCqkBG8wg+mrh7J0W28sJcWM//BN+q5ZgUkaGWESqOyYw083XUXo7LPp4s6mR6mfp6+bTNXysrjjme1m+t/QiZtuyqFjz4lxMQWfzxfLtPJ6vdhsNtxuNxkZGSQnJzdbgk1tbS1FRUXouo7FYiE3Nxe73d4sYyuHV5ODXUuXLgWgb9++XH311Vx55ZV07Nix2SamtA4pperZpSiKoihHkMcee4zHH3+c4cOHM3v27NaejqIA0KVLF7Zv386rr77Kdddd19rTURRlP4TmBPtZCPtZ6HqY6rIf+WLBWn7eYSF34yZ+/dET5OVvj5UqSgG7+vdk2V1XknDssXRO6kVliYfHrnyW2uUVcWObbCYGXj+Q62/uRE7SC7jsJYjwdqT8K1KaKS8vp7y8HI/HQyQSITExkcTERHJycpotm0tKSWlpKZWVlYCRiZSTk6MSQNqxJkcz7rrrLq6++moGDx7cnPNRWpmu67F+a+oftqIoiqIoLWHNmjW89NJLzJkzh23btuH3+0lPTycrK4u+ffsybNgwRo4cSa9evQAYMWIEc+bMadKxrr32Wl577bW421588UVuu+02AIYOHcr8+fPjts+ePZszzjijSccD2Lp1K126dDngcV5++WVuuumm/e63du1a+vbtC4DD4aCoqGify64rjfP7/Zx77rkAfPXVVzgcjlaekaK0D7quU1Zewadzl7JhVzHH//AT93/zESlVFQ39uMwmNg0fzPo7fkVOdg29LGWUlnzJb2/+CP8Kf9x4mlVjyLXHc8Xt59OxcwfjfBZIRFb/FgJf4A8EKfbdjccbwuPxYLVaY72zUlNTmy2bKxKJUFhYiM/nAyA1NZX09HTVjqkZtcZ5t8nBrn/961/NOA2lrajP6hJCqOZ7iqIoiqI0u6effprf//73sQVxwGj8W1VVRWFhIcuXL+edd96Jy0RLTU0lKytrj7FCoVDsU/iUlJRGP+FvrM/K5MmTY98vWLCA9evX07t379htVqu10eMBVFRUEA6HsVgspKamNrpPYx8Y7m08AKfTuddte5u33+/n3Xff5eabbz6g+yoNdF2PBU91Xd/P3oqiRKNR8otK+GzeUrbvLOacrz7gygWzcAQDsX38iS7WXDSWkuuvooPbR2+2kF9QxeOPBAkt88WNp5k1hlzenUvvOIOO3QaRkpLScO3p+BVSuCnf+Qxl1Wa8oW+JiIEkJCSTlJREdnZ2rIdXc/D7/RQWFhIOh9E0jezsbBITE5ttfMXQGuddVaemxKl/46lKGBVFURRFaW4ffvghDzzwAACnn346Dz/8MMOGDYv1Q8nPz2fevHlMmzaN6urquPs1ZvfMqQ8//JARI0bsdw4rVqxgyZIlpKSkcN555/H2228zefJk/va3v8X2GTp0KEVFRY3evz7LbOjQoQdVFrq38Q5UOBzmzTffBODOO+/kueeeY/LkySrYpShKi4lEImzZmc/n3y+nest2Lpr2Jrf8vBST3tCPqyonkzW/vp7oeeeTnpBMN5OJjYX5vHD/N4SX1MSNJ0yCEy7J5qKbdPI6riAl4WNMUTd4xiEdFyIsvQgGgxQVd6bGdzce70ospmrcju9Iz7qC9IxOzZZtJaWkurqakpISpJRYrVY6dOjQbGWRSutTEQ0ljmpOryiKoihKS/nHP/4BQP/+/ZkxY8YeH6516NCBCRMmMGHCBPx+f2NDHLL67KjLLruMCRMm8Pbbb/PGG2/w5z//uU1/2PfZZ59RUlJCnz59eOqpp3j11VdZtGgRq1evpn///q09PUVR2hEpJTW1tXy5cA2FJeUMnP05vaI1mHr2IOGWuwnpks07C5m5dB22lasY/9FbdNqxpaEfF7AhIZtp/c4h59JR9D+tN1ablRU7t/L6wx8S/WWQSxMMGX8s427rR17HjaTaPyIUlpTXdgcJLvuHOKyvUuUfSJnvHLzB7oTCdlzJg0nQPiDb/T12ZkHkf2DpiR71Q+3fILoNTF0g8QE0U+NlcVJK/H4/kUgEs9mMw+FASklJSUnsQ5XExESysrLUNfARpu2+oiutQgW7FEVRFKV1vf/++7z22mssXbqUiooKXC4XGRkZ9OnTh7PPPpsbb7xxj5WhvvrqK5555hkWLVpEJBKhe/fuXHnllfzmN79p1rntnkklpWTx4sX85S9/Yf78+VRWVtKxY0cuvPBCHnroIZKTk/e4//LlywE477zz9htYaol+HsFgkLfffhswenmddNJJdOnShW3btvHFF19wwQUXNPsxm0t9kO6aa67B5XIxfvx4Xn/9dSZPnsw///nPZjvOL5/jZcuW8fe//505c+ZQXFzMqaeeGpfRFgqFeOWVV5g6dSqrVq2ipqaG1NRUTjrpJG655ZZYj5a2qqioiO7du7f2NBTlsKmtrWXajB/ZVVTK6A/f5bLpX6DV9WwG0B/+E8vPOJftWR2Z+PWHpFaUNfTjEhpzZS4vMJBqrx1+8sBPn2C2m0nqkEDF5qq4YwkBgy8YwNg7RtP1mC6kp6cTDAbZuP1cyst2EQ75QPoxa15sFg9WSy2hSBlmUwHJDi+pyZ1Iy56IVrsBIpuQFVcgzT0gvKThIOH5EHgb3ToKLfXFPR5r/QqO0WgUk8mEw+GIZYcJIUhPTyclJUX15zqMDtd5VzVlUuKoMkZFURRFaT033HADEyZM4Ouvv6akpAS73U44HGbTpk189tln3HHHHXuUwz322GOcd955TJ8+nerqaiwWC2vWrOG3v/0to0ePJhQKtchcP/nkE0499VSmTZuGz+dDSsnmzZv5+9//zsCBA9m2bdte77tr164WmdP+fPTRR1RUVNCrVy9OPvlkhBBcc801QHw/rLYmPz+fb775Bk3TuOqqqwAjWAfw1ltvtdhzPG3aNE466STeeecdamtr93h/uH37dgYNGsTtt9/O7NmzqaiowOl0UlxczKeffsp5553Hrbfe2iJzay6HWl6qKO1JbW0tn8xcQHFJGadPfYuTvvscsVugC0DoktNmfMlV7/yXtLpAV9Dp5JtepzJGjuMpcTLVIv4Dl0ggEh/oEjDwvD489OVd3Pqv6xh0yvHk5uYSDAbZsGEDxcUlRKJWrPYMTNYOBKN5VPp6UFbbB4vJT2rCZjqlf0eG7R9olReC7gUtC2R1fKBrd6EZ6BUN55va2lq2bt0ae11MSEhACEFxcTElJSVEIhE6duzYrI3ulQNzuM67KtilxFGZXYqiKIrSOr7//nteffVVNE3jr3/9K+Xl5dTW1uL1eikrK+Obb77h2muvjesn8umnn/L4448DcMkll7Bjxw4qKyupqalh0qRJ/Pjjj7z44ot7O+Qhufbaaxk6dChr1qyhuroar9fL+++/T0pKCtu3b+fSSy+Nva+od+KJJwIwZcoU3nnnncPeHLw+oHX11VfHbqsPdn311Vct+gZ86NChuN1u7HY7eXl5jB8/nk8++SS2Cva+vPbaa0SjUc444ww6duwIGL3DOnfuTFlZGZ988kmLzPm6667jzDPPZO3atVRXV+P3+3n55ZcB8Hq9nHPOOfz888+MGDGC2bNn4/f7qaqqoqqqimeeeYaEhAReeukl/v3vf7fI/BRFOXBSSvILCsgvqaCsysdps74G4JdhHlH3JQFvejpL7/0NU9/8H3/flIMu9h8+6D28KxP/N4FLHh3L4FOPJy8vL1Y6WFRURG1tLUIIbDYb0WiUSCSCLgVCWEEkozlG0qnriTicqQ2z0wtBL97/gwzNQI/6Y8cKhUIkJCRgsVgIBAL4fD7MZjNSylhJo3LkUsEuJY4KdimKoihK61iwYAEAo0eP5oEHHohb6S8tLY2zzjqL1157jdzc3NjtDz74IADDhw/nvffeIy8vDzBKAG+77TaeffZZqqqqWmS+WVlZfPnll/Tp0wcwssIvvfRSpkyZAsCiRYv2aCz/2GOPYTabiUQiXHnllXTo0IHLLruMp59+mlmzZuH1eltkrgDbtm1jxowZCCHigl3du3fn1FNPJRKJ8Prrr7fY8X/44Qc0TUMIwa5du/jwww8ZN24cY8aMwePx7PV+Ukr+97//AQ3ZXGCU39RnedVvb259+/bl008/5Zhjjond1rNnTwCeeeYZ1q1bx/Dhw/n2228ZPnx4bIU0t9vNb37zG9544w0AnnjiibjVNw9GMBikpqYm7qupCgsLWbp0KcuXL48FjZcvX87SpUtZunQphYWFTR5bUdo6v9/Pms07qfZHOG3BDDQp9wh07U4A2y+6kK1njGDdV5uN6NcBOO68PnTpk4fFYomd8+qPX1VVhZQSk8lEMBgkHA7HygvNZjNms5mobiVsuRot42tE5mJIfAjMvQ78gdb+Db/fj8fjwW63I4TA4/Hg8xkrQjocDlJSUvD5fC3WG1Jp0JrnXRXsUuLUB7tUGaOiKIqiHF71Pa5KS0v3yIhqzMqVK1mzZg0ADz/8cMOy7buZOHEiHTp0aNZ51rv//vsb/VR89OjRDB06FID33nsvbtvw4cP5+uuv6d27N2CUMkyZMoUHHniAkSNHkpKSwpgxY5g7d26zz/fVV19FSsnw4cPp3Llz3Lb6IFJzB42Sk5O57777WLhwIV6vl8rKSnw+H8uXL+eyyy4DjIyyyy+/fK9jzJ49my1btpCQkMBFF10Ut60+K+3bb79l586dzTp3MJ7jvX0AWp8ld++992KxWBrdZ9y4cSQlJVFWVsaSJXspPdqPp556CrfbHfuqD+g2xX/+8x8GDx7MaaedFiv9vOOOOxg8eDCDBw/mP//5T5PHVpS2LhKJ4A+GCEV0MspLDug+jsJCwkSpKqw94OMEqoJYrVZ0XY8LckciEaLRaCybtf7/JpMJi8WCw+FA07RYtheA0BLRXNeipX8OllMObALRbbFjmc1mwuEwwWAQgISEBFwuF2azeY/5KS2jNc+7KtilxKn/B68yuxRFURTl8Bo1ahR2u51ly5YxbNgwJk+ezNatW/e6/+LFiwHjA6phw4Y1uo+maYwYMaIlpsvIkSP3u61+jrsbNWoUa9asYfbs2Tz44IOMHDkylsUWDof58ssvGT58OI8++mizzVXXdV577TWgIUC0u0svvRS73c6GDRuYN29esx134MCBPP3005x44ok4nU7AyMg67rjjeO+997jzzjsB+Pzzz5k5c2ajY9QH4C666CJcLlfctl69enHKKafEPb7mdOqppzZ6e35+Ptu3bwfgxhtvJDs7u9GvnJycWNZa/f4H68EHH6S6ujr2dShBvZtvvpklS5awZMmSWDnmyy+/HLvt5ptvbvLYitLWmc1mHDYrVrNGSWrmAd3H3yEXs9Bw5rj2v3OdxPQEpJRomhaXQGE2mzGZTHv0xxJCoGlaXPCr0cQLU7cDm4CpS+xYkUgklr1lt9tj2afRaHSP+SktozXPu80W7JJSUlZWxo4dO5prSKUVqDJGRVEURWkd3bt355VXXiEhIYEffviBm266iW7dupGZmclll122R3+nkhLjk/n09PTYG/jG1Pd4am77yhir31Y/x1/SNI3hw4fz5z//mRkzZlBeXs7atWt59NFHYwGdP/3pT3z++efNMtfp06ezY8cOnE4nF1988R7b3W4348aNA1quJLAxf/7zn2Mra3788cd7bK+urmbatGlA40E6aMhKe+211w6o/9fByMxs/IK4oKAg9n1ZWRnFxcV7/arvy1ZfQnSwbDYbSUlJcV9NlZOTw6BBg2JfQNzPOTk5TR5bUdo6h8NB3+55uB1m5p86Cl2IvVYmSkDXNArPH0eC2Ubnc7vs2dyrEQnpTnoM6UIkEiEhISEu+9fhcJCcnIwQIi57WUoZy7ISQuB2uxvvpZX4wIE90MQHcDgcJCQk4PF4CIVCCCFiY0opCQQCe8xPaRmted495GDX0qVLueiii3C73WRlZdGtW3zEtbKykptvvplbbrlF1cS2AyrYpSiKoiit58orr2T79u289NJLXHbZZeTl5VFaWsqUKVMYN24cw4cPP6SeRW3ZMcccw+OPP86nn34a++T/lVdeaZax60vufD4fSUlJCCH2+KovuZw6dSq1tQdesnMoEhIS6N+/PwBbtmzZY/s777wTe/88evToRud9yy23xO4/a9asZp3f3t4P7n6hunbtWqSU+/267rrrmnVuhyIQCHDXXXcBxMqbFOVIJ4SgQ24uHTJTSU92svisMcCerbjqf946/iJ0sxlNaFgcVjpf2HW/xzjr9mGYLWbsdjvZ2dlxWVxCCLKzs0lMTERKSTQaRdd1dF0nHA6j6zpJSUnk5OQ0ujqiZnKAddS+J2AdhWZyIIQgKysLXdcJhUKxDK5wOIzH48Fms+0xP6VltcZ595CCXW+++SannHIKH3/8MR6PJ/ZitruUlBQ2b97Myy+/3GIrxSjNR/XsUhRFUZTWlZqays0338x7773Hjh072LRpE7/73e8QQjBv3jwee+wxoCHrpqysLNYHozH5+fktMs99jVu/bW+ZQfsycuRIevToAcD69eubNrndlJeXN5o1tTder3ePXmOtpT5I11L7N1V2dnbs+6aWJ7amaDTK/Pnzgab9jSpKe5WYmMgFI4eSlZnO/EuvYtXY85G/CPhITWPLJRez87bbMZlMmEwm+rs70u2WAXBeaqPjWhwWLvrD2Qw+91jS0tLo0qULiYmJjR6/V69eZGVlxVZFjEajseBUz549G71fPS31xb0HvKyjjO11TCYTiYmJOBwOTCYTPp+PcDiM2+3e6/yUltMa590mB7vWrFnDxIkTCYfD3HXXXSxevJj09PRG97322muRUvLVV181eaJKy5NSqp5diqIoitLGdO/enaeeeoorrrgCgO+++w6AIUOGAEa/zb31mdJ1ndmzZ7fIvPaVRVS/rX6OByshIQFgn+WZB+qtt94iFAqRmZlJdXU1tbW1e/26++67gcNXyujxeFi9ejUAXbvGZ02sWLEi1tR90aJF+5z3Bx98AMCHH37YYqtv7q5Lly6xUtXPPvusxY/XknYP3CnK0SAxMZFrLxjN5WPPYN3Nd/LAX/6L32QsMpE/oBcbli/D+/Aj9O/fn/79+5ORkUFmZiYPjrqKaP/4sr+uJ+Rxw3OX8rcff88V91xC//796dGjxz4DSYmJifTr149+/fqRnp5OYmIiHTp0oF+/fgcUgNo9oIVIB/uVkLEi7vb6FktWq5Vu3bpxzDHH0LNnT3r37r3f+Skt73Cdd5sc7HrmmWcIhULcfvvt/Otf/2LQoEF7DZCMGmVEX5u6CotyeNT3VAAV7FIURVGUw21/af31vUXqV1089thj6dOnDwBPPvlk3Ot4vf/973/s2rWrmWdq+Pvf/04gENjj9lmzZsU+va1fcbDet99+u9++UitWrGDFihUAsf4eh6I+2+miiy4iKSmJhISEvX5NmDABgB9//DG20uWh2N9jffjhh2O/wwsuuKDReffp04chQ4bsc95jx47F7XYTCAR45513DnneB2LixImxeS5btmyf+1ZUVByOKSmKcoD+n737DpOiyh4+/q3OkyMMOYoSBFQEFWTJBiRLEkHQVRHFV38G1DWAgjnvLqKiCCpKZo2IioyigBIVBCRIZgjD5ND5vn80XUwzgQk90wNzPs/TDz1Vt+qe6m6qq07foGkatRISaN+iIQaLlZRoX4stj1EjMi4eq9WK2WwmOjpa/9FB0zTUX4Fj793xxigu692OOnXrEBMTQ3h4eKm6BmqaRlxcHJGRkfpg8uUSNhRD7GRfF8cCcnNzsdvtGAwG4uPjCQ8PJzo6utTxifNDuZNdK1euRNM0HnnkkbOWrVevHmFhYZUyJbIIHn8XRoPBUOT05UIIIYSoPBMnTmT48OEsXrw4YGD3nJwc3n77bT788EMAbrjhBn3ds88+C/iuy0aNGqUntux2O2+//TYTJ04kNja2UuJNSUnhhhtu0Lsaut1uFi1apA8Af9lllzFkyJCAbUaNGkXLli2ZOnUq69atC+h+efToUV5//XV69+6N1+vFZDLpLa3Ka926dWzZsgXwzbh4NldccQWNGjUCgtMlsHXr1rz++uts375dT0YqpdiyZQujR4/mzTffBOD666+nd+/e+nYOh4O5c+cCMGzYsLPWY7VaGTBgQNDiLo0HH3yQtm3bYrfb6dGjB//97385efKkvj4jI4Nly5Zxyy23FDtbqBAidPyzHkbYLKTE+npoRR45HjC+lcViAXz3iR6PB/ad/lEmvkEsYVG+CTbK0wrXYrFgNBr13kX+HkZlYmpcaJFSSj8XxcbGyvA8NVi5MxpHjhwhIiKi1DP8hIeHywD11Zx0YRRCCCFCx+VysXDhQoYOHUpSUhJRUVHExcURFRXFhAkTcDqdXH311Tz++OP6NoMHD9b/nj9/Pg0bNiQ+Pl7fplOnTkyYMKFS4p0zZw6rVq2iZcuWxMbGEhkZybBhw0hLS6NRo0YsWrSo0E2G2Wxm586dPPXUU3Tq1ImwsDDi4+Ox2WzUrVuXBx54gNTUVKKiovj0009p3759hWL0J36SkpL4xz/+cdbymqbpybqPP/4Yl8tVofp37NjBAw88QOvWrbHZbCQmJhIREUG7du30ZFbfvn2ZP39+wHZLly7VW0OVJtlVsNzGjRv1lnGVKTIykm+++YYrr7ySzMxM7r33XmrVqkVcXBwxMTHExcXRt29fPvrooxLHlBNChI7VaiU+OpyDSb57+ojMHOz47gndbjcGg0E/jzudTgzHTv9frt8ySX/un1W2LDRNw2azYTAY8Hg8pU52eT2Zp/8wXVBofU5OTkCrLlFzlTvZZbVacTqdpZri2OFwkJGRUWm/LJ4Lpk+fTuvWrenYsWOoQymWzMQohBBChM6TTz7Jv//9bwYPHkzLli0xmUzk5ORQu3Zt+vTpw6xZs0hOTiYiIiJgu2nTpvHll1/Ss2dPoqOjcTgctGrVihdeeIEVK1bov8wH28CBA1m9ejU33ngjNpsNpRRNmzblwQcfZPPmzYXGoALYuXMnCxcu5O677+bKK68kISGB7OxslFIkJSXRvXt3nn32WXbt2qUnncorPz+fTz/9FPB1YSzt9Y2/Bdjx48crPB7Vu+++y6233kq7du2Ij48nKysLTdNo3rw5N910E19//TVfffVVofFjCnZh9M/WeDbXXnstMTExAdtXtnr16vHzzz/z6aefMmDAAOrWrUteXh5Op5MmTZrQv39/3njjDX766acqiUcIUTZWq5V68dHsa+JLGlkcLk44fTP++pNP/u8Ql8uFlnF6JtZ6FyXprcPMZnO56vcnu9xud8AsryXy7D793NgiYFXBVl1xcXFyX1vDaao02aoiXHbZZfz+++9s27aNiy66CIC6dety/PjxQh/Uzz//XJ8uO9hTIp9rsrKyiImJITMzk+jo6FCHEyAjI4MDBw4QGRlJs2bNQh2OEEKcl6rz94AQZ5OcnEyPHj2As49HJURlCMY5NDc3V58EIScnp1ACWYiaIisri11/7+ODJT/yn6n/Dw1I/vIj6l7QEYvFQtOmTTl69CiZmZkkJCQwMmkC2qlT/z//O4JLe7UlMjJSn7CiPPXv3LkTr9fLhRdeWKrGMd7c+ZD9JACGOjsD1mVnZ3PkyBGMRiNNmzaVZFc1Eszzbmm/B8rdsqtv374opXjjjTdKLJedna1Pl+0fS0BUT9KNUQghhBBCnO8iIiJQSqGUkkSXqNGsViuRYVbMMdF4NF9qwLhmNeC7N1RK6S27Du06oie6ABq0qguUrwujX8GWXaXuNu7ZX+RiadVVvYXivFvuZNf9999PTEwM7777Lk8++WShaY7z8/NZsmQJnTp1YseOHdSpU4c777yzovGKSiTdGIUQQgghhBCiZrBYLBgMBqLCLORafEkr2x9/omkaXq8Xj8ejJ7u2rtqhbxdVJ5KoeF8rnYoku8xmsz4mWKnH9/aknHoSOKtidnY2DocDo9FYo4dPEqeVO9mVmJjIwoULsdlsPPfccyQlJZGamgr4+u/HxMQwbNgw/vrrLyIjI1m0aJH8clLNSbJLCCGEEEIIIWoGTdOwWCzERYWRFuUb8y/27wMYjL40gcvl0sfj2rNpn75dUotENM2XbKpIskvTNMLCwoAyJLu8J049OX3PKq26RFEqNA9n7969Wbt2Lffff3/AWFxHjx7Vn3fv3p3//Oc/tGnTpiJViSrg78Yo07MKIYQQ56/Vq1czZMiQMm3TuXNnlixZUkkRiWCT97hkdrudMWPGAPDRRx9V6GZdiHOd1WqlTlwUx+Jr0zQ1hfhj6RxSTmwYcbvdREREoGkaB3al6NvUuygJs9mMxWKpcGLJn+xyOByl28CbcerJ6UHxs7KycDqd0qqrGgvFebfCWY22bduyYsUK9u/fzy+//MKRI0fweDzUqVOHLl26cMEFhacDFdWTtOwSQgghzn9Op5Njx46VaZu0tDTA9yOmDExf/VXkPa4JPB4PixYtAmD27NmhDUaIELNarTSpE09KvYaw83eisnJJd+dRV4vC7XZjMBgwmUykH8nQt2ncqh4GgyEoCYvw8HCgDMkule37V/N1ryzYqis+Pl7uZaupUJx3g9aEp3HjxjRu3DhYuxMhIMkuIYQQ4vwnCavzn7zHQojSslqtxEeFs6HZhZAMZqebE85s6lqj9EHjLRYLuWl5+jYNW9cDKtaF0c8/1JHL5QroNlksdSoOzdciLDMzE5fLhclkklZdIkC5x+z65ZdfghmHqAYk2SWEEEIIIYQQNYfVagXgxMVtUPiGfXf/sRE4PcyN0WjE6/QCYIm2EBnvS1AFI9lVsCtkbm7u2TdQTt+/WhRer1dvlRofH4/BUO70hjgPlfvT0LVrV1q0aMEzzzzD33//HcyYRIjImF1CCCGEEEIIUXMYjUbMZjORcbG4Db6kU8S6DQB6y67je0/q5eMu9A0Ar2maniirCP8g+VDaQep9MWGIJSsrS2/VFRMTU+FYxPmlQqnPPXv28PTTT9OiRQuuvvpqZs6cSWZmZrBiE1VIKSUtu4QQQgghhBCihrFarSTFRZJn9XUNjN+xG5fXoye7/vp1j1424cJ4zGYzVqs1aC2p/IPU5+XlnaUkgO+eFUOitOoSJSr3J2L37t1MnjyZ5s2bo5Ri9erV3HXXXdSpU4fhw4fzxRdf6MkTUf15vV79uSS7hBBCCCGEEKJmsFqtNKodT3p0LAB19h8ly5WHx+PB6/Wy9/cDetnYC+IwmUxBnU3P30KsdC27fOMR2l3x+hhf0qpLFKXcya5mzZoxefJkdu7cqSe64uLicDgcLFq0iEGDBlGvXj3uv/9+1q9fH8yYRSXwd2E0GAySFRdCCCGEEEKIGsJqtVInLpLUxCQA4o5mkOn2JZ7cbjcHtx/Ry8Y1j0XTtKAmu/wtu1wul35fejbZeXGAtOoSxQvKp+LKK6/krbfeIiUlhaVLlzJ48GAsFgsnTpzgP//5D1dccQVt2rThxRdfDEZ1ohJIF0YhhBBCCFEThIeHk5OTQ05ODuHh4aEOR4iQs1qtaJpGapOmAETl5JHu8XUpdLlcpOw9BoDBbCAszhb0ZJd/kHqv14vdbi+2nNdzuuVXvru+tOo6h4TivBvUFKjZbGbgwIEsXryYlJQUZsyYQefOnVFKsX37dv71r38FszoRRP5klwxOL4QQQgghzmeaphEREUFERASapoU6HCFCzmw2YzAYSG19se9vj4cTdt9Y3G63m9wM3yyJkbUi8OLrDeQfVD4YTCYTJpPprMkuPLv0pw5PYxISEuT/8DkiFOfdSstsxMbG8s9//pNatWpht9vZsGFDZVUlgqDgtLJCCCGEEEIIIWoG/8yKrksvRQEaYP19M/Rpj91ux+P2je+c2CIeTpUNZsLCn+yy2+0lJ7vcvmSXUmCxJBAdHR20GMT5p1KSXWvWrOGjjz5iwYIFpKen68tr1apVGdWJIJBujEIIIYQQoiZwOByMHz8egHfeeUcfHFuImsxqtVK/fm3cBiNmr4fav28jr6eT1I179TINr6iP0RDcLoxQuGWXUqrIZJpy7cO/VFp1nVtCcd4NWrLr77//5uOPP+bjjz9mzx7f1KRKKaxWK/379+eWW27h+uuvD1Z1Isgk2SWEEEIIIWoCt9vNnDlzAJg+fboku4TAl+xqUCuGvLBwYnKzSfrzIJnOPHb8tEMvU7tlImbNWCnJLqPRiFIKt9uNy+Uqspukw74fX80aUVFRQY1BVK5QnHcrlOzKyMhgwYIFfPjhh6xZswbwJbgAunTpwi233MLw4cNl0LhzgIzZJYQQQgghhBA1k9VqxWgwkBUbT0xuNrUOHGOHK4/tq3f6CmgQkRCG0kxBT3YZDIZCrbvOTHZ5PB68rqO+DIZmkFZd4qzKndkYOnQoX331FU6nU09wNW/enDFjxjBmzBiaNm0atCBF5ZMxu4QQQgghhBCiZvInlzLr1afh4f0kpmeS6cojZfdxAEw2E14NrEaTfv8fTGcmu84cjys9PZ1wfIPma5iDXr84/5Q72bVkyRIA4uLiGD58OGPGjKFz585BC0xULenGKIQQQgghhBA1k9FoxGKxkNbiQli3mih7PpmuPHLSfDMxhiWG4cJDrMWK2+0Oeje0kmZk9Hg8ZGRkEBnmiwUteDNBivNXuZNdAwYMYMyYMfTv3z+o046K0JBujEIIIYQQQghRc1mtVjydOsEnszF5PaRlp+Fy+HoAxTaLxYmHaFs4TqeTiIiIoNZtNBoxmUw4nU4cDkfAIPXp6el4PB6MhlNJMC0sqHWL81O5Mxv/+9//ghiGCDVp2SWEEEIIIYQQNZfVaiWmW2cUoAFhP2/T19W9oi5OPMRaI3G5XEGv22QyYTAYAPB6vTgcDmw2G263m/T0dAAM2ql6tcig1y/OP4ZQByCqBxmzSwghhBBCCCFqLqvViiXMhtvoaxNT+6vN+rr6Hetix4PFYsHpdAa9bpPJhKZp+v2ovytjeno6Xq8Xm82Ghu+eFS026PWL84/0WRMopaRllxBCCCGEqBHCw8M5fvy4/lwI4eMfh8seEYk5K4PG+w4CtX3NvKwa2TgxGAyV1rIL0Ft32e123G43GRkZACQkJECO754VY0LQ6xeVKxTn3VIlu/wJkJYtW/Lnn38GLCsLTdP0FkSi+vAnukCSXUIIIYQQ4vymaRq1atUKdRhCVDsmkwmj0UheYiJRWRk0yPN1HzRZjHiBE/gGiHe5XAFjagWrbjid7HI4HKSlpeH1egkLCyMiIgKV4/UVNtQNWr2iaoTivFuqboxKKf1R1LKyPET14092GQwG/eQihBBCCCGEEKLm0DQNq9WKvUlTABK9eQCExYWhUJzQ7BgMBpRSQW/ddeZEaXl5eQGtugISa8aGQa1bnJ9K1bJr5cqVQGBzM/8yce6TmRiFEEIIIURN4XA4eOCBBwB47bXX9K5bQgh8Y3Jd2h5++I5IfAmtuMYxuPCSY3BhsViw2+04nU4sFkvQ6vXfi/rH7crNzcVisRAdHU14eDheT4FxwkzNglavqBqhOO+WKrvRrVu3Ui0T5yYZnF4IIYQQQtQUbrebt956C4CXXnpJkl1CFGCz2ci/ohMARhQW5SapTS08eMnT3JjNZux2e9Bbdmmahslkwu12o2kadruvFVliYiKapqE8e08XNl8U1LpF5QvFeVf6rAkZnF4IIYQQQgghBBaLBUfr1ih849JfTCpJF9ciHw+aQdNbc1XWjIzgawUEvvtTvXeZ+y+9nMEoY+6Jsyt3sqtnz54MGzas1OVvuukmevXqVd7qRCWSZJcQQgghhBBCCKvVimY24zb6Ek+tOUlcs1hyNScWgwmz2QxUTrLLaDTi8XjIz88HCOwm6dkf9PrE+a3cgzQlJydTp06dUpdfu3YtBw4cKG91ohJJsksIIYQQQgghhMFgwGw2k28Nx5yXRXMti30GA3m4sBrNegIq2N0YwdeyKz8/H03T9KSax+Px3ad6Dp8qFbwZIMX5rcq6MXq93qBOTSqCxz9mlwxQL4QQQgghhBA1m9lsJiMsGoD6Wg5eL+QrD+FGS0Cyy+v1Br1uh8OBUoqYmBgA7Ha7b4Xn+KkSMhKTKJ0q+aR4PB6OHz9OREREVVQnykhadgkhhBBCCCGEAMg4mk1qdCIACdhxOBQuPMSYwzEYDPp9Y7Bbd+Xk5AC+7otRUVFAgWSXSj9VShpoiNIp9SclKyuLjIyMgGUej4eDBw+ilCpyG6UUGRkZfPDBBzgcDtq1a1ehYEXlkGSXEEIIIYQQQgiAQ9uO4I6vx2V7NxOhnGTlubFGmIixROhdDD0eD06nM2iz6jmdTj2xFRYWhs1mIysrq0CyK8v3r2YpZg9CBCp1suv111/nmWeeCViWmppKkyZNSrW9pmmMGTOmTMGJquFPdkk3RiGEEEIIcb4LCwtj7969+nMhRKCdG/5Gq90EAINS5KRmY61lpG5YHOBreWW324Pasis1NRVN8832qGkaNpsN8LXsUkqBN9dXULMFrU5RdUJx3i1TdqNgCy5N04pt0XWm+vXrc9dddzFx4sSyRSeqhH/MLmnZJYQQQgghzncGg6HUP9gLURPtWLOL6AYJKHzDwcdt+ZPsVhfRODwBOD1LYrBmZHQ4HOTk5GAwGAgLC8Pj8ehJL7fbjdvtxqgcvsJaZFDqFFUrFOfdUie77r//fsaNGwf4kl7NmjWjVq1a/Pbbb8VuYzAYiI6O1geXE9WTdGMUQgghhBBCCOHxeNi35SAXRDfGbTRh9ripu3sXex0X0jw8CUCfKTFYLbtOnjyJUoro6Ghyc3NRSuH1erFardjtdux2OxGcqkuT3IIonVInu2JiYgKSVv/4xz9ITEykcePGlRLY+Wb69OlMnz5dTyxVF0op6cYohBBCCCFqDKfTyeOPPw7As88+q7dSEULA4V1HcTnc5Kbnk2cNJyYvi3opBzlx3Esdiy8fEMyWXXa7nezsbDRNIzExEYfDgcvlwu12Y7PZCiS7fL2RMCRUuE5R9UJx3i33bIzJycksWrQomLGc1+655x62bdvGunXrQh1KgILJN2nZJYQQQpx/pkyZgqZpdO/ePdShCKHr3r07mqYxZcqUKq/b5XLxyiuv8MorrwR9NjkhznU7ftsFQF5GPllRvjG66macIC3VS7o9Gzjdssvtdle4McfJkycBiIyMxGq16g0wPB5PwLhd4PVtYKhTofpEaITivFvuZBf4Zmj0Tw9akpycHLKysipSlagk/pOTwWBA07QQRyOEEEKImmDbtm38v//3/2jfvj0xMTFYLBbq1avHpZdeys0338zbb7/Nzp079fL+xEh5Hv5hOAqaMWOGvr5Lly6F1icnJ5e7Pk3T2LdvX5n289577xX5Oo0bN67YbSIjI2nTpg0TJkxg69atQXlfhBDir/W7AchLzye9Vl0AEnKzyM5UHMnxJaaMRqOelKpI4sJut5OTk6O36oLTvY38LbvAN6aXUqfuVU31y12fqFnK3W9tyZIlDBs2jBEjRvDJJ5+UWHb06NF88cUXLF26lAEDBpS3SlEJ/IPTSxdGIYQQQlSFl19+mX/961/6NQhAbGwsGRkZpKSksHnzZj755BO6detGcnIyAPHx8SQlJRXal9PpJD09HYC4uLgiu0UUNXbs+++/rz9fvXo1f/31FxdddJG+zGKxFFkfQFpaGi6XC7PZTHx8fJFlimotX9z+AMLDw4tdB74fJWvVqqX/7fF4OHnyJNu2bWPbtm3MnDmTd955h3/+858l7kcIIc5m18a/AcjPcpDWpRlsXUuE04E9T3EiL0MvZzabcbvdOJ1OPSlVVqmpqQBERUXp52//+dPtdmOxWDAYDL563OFYzblgal6BoxM1SbkzHAsXLgQo1ZfqHXfcweeff86CBQsk2VXNyOD0QgghhKgqS5YsYdKkSYBv/NcnnniCrl276jdKhw8fZtWqVSxevJjMzMyA7YqSnJxMjx499DKl6ar5+++/s2HDBuLi4ujbty9z587l/fff56WXXtLLdO7cmaNHjxa5fffu3fnxxx/p3LmznowrjeL2VxoNGzbUW4v5uVwuVqxYwT333MPff//N3XffTa9evWSWQSFEuXm9XvZtOQiA8irS27WHLz/BqLyE5eZxLOv0edlisZCfn1/ull35+fnk5uaiaRoJCafH4SrYskvTNGw2G7nZR3C4YnzJLvNFxe1SiADl7sa4adMmDAZDkU2/z9SzZ08MBgMbN24sb3WikkiySwghhBBV5dVXXwXg4osvZsWKFfTp0yegRUD9+vUZOXIkCxcu5LPPPquUGPytukaMGMEdd9wBwIcffhjQ0uxcYDabue6665gzZw7ga+W2bNmyEEclhDhXud0evpj5LfnZdn2Zp01zFKABL66ci23ax0ybt5TfU/djMBlxuVxkZmaSl5eHUuqsdSilyMvLIysriyNHjugzMBZslWs0+vabnZ1NXl4eFosFl+M4adlNyHPEoTLfwevJr4RXQJxvyp3sOnz4MLGxsaVqshgWFkZsbCyHDx8ub3WikkiySwghhKhe5s+fz/XXX09SUhJms5nY2FhatGjBgAEDmD59+qmBegMtW7aMPn36EBsbS2RkJO3bt+ell14K+iCwBcegAli/fj1Dhw6lbt262Gw2LrjgAh5++GEyMjKK3H7z5s0A9O3b96xDKISFhQUzdMA37svcuXMBGDt2LP/4xz9o0qQJx44d46uvvgp6fVXhkksu0Z+XZizds9m3b1/A2GN79uzhzjvvpGnTplit1kItx7xeL3PnzqVv374kJSVhsVioVasW11xzDZ9++mmpboBDqSIt7oQ4X3w3N5lBcbfw3wmnu3jHNYih/sv/0f++av92xi9fymOjbmRT71t5eM5SDh47wqFDh/jrr7/YvXs32dnZxdaRnZ3N7t27+euvv9i+fTuHDh0iPT09INGVnZ3N4cOHOXnyJCkpKWzdupWd25dzIvU4h1KvYOfh69iz7zg5B/rgTZtQOS+GqHRVdd4td7JL0zTy8vJKXT4/P7/CMzWI4PO/JzJmlxBCCBF6t912GyNHjuSbb77h+PHj2Gw2XC4Xu3fv5osvvmDixImFLhKnTJlC3759+f7778nMzMRsNrNt2zYeeeQRevfuHZSp4Yvy2Wef0aVLFxYvXqz/qr9nzx5eeeUVLrnkkkLd7go6dOhQpcR0NkuXLiUtLY0LL7yQK6+8Ek3TuOWWW4DAcbzOJb///rv+vOC4Y8GwevVqLrnkEmbOnMnx48f1Gdj80tLS6NGjB6NHj2bZsmUcP36c8PBwUlNT+e677xg1ahSDBg2qtM9gMEiyS9R0381N5qUx03Hknv5/Gtcghv9L2M2Vm38sVN6gFGN/X0mPj+axaMN+8pRvDMPMzEz27t1bZMIrOzubvXv36t9RmqZhNBrxeDwcOnSI7OxsvUxubi5Go9GXb8jehd1uxOUOA7yYTXlk5TVg3/Gu5GRukYTXOaraJ7saNmyI3W5ny5YtZy37+++/k5+fT/36MnNCdeNvsi8tu4QQQojQ+vnnn/nggw8wGAy8+OKLnDx5kuzsbHJzc0lNTWX58uWMHTs24Ffwzz//nKeffhqAYcOGceDAAdLT08nKymL69OmsXbuWGTNmVEq8Y8eOpXPnzmzbto3MzExyc3OZP38+cXFx7N+/n+HDhxf6obNTp04ALFiwgE8++QSv11spsRXHn9AaM2aMvsyf7Fq2bFmlXoB37tyZmJgYbDYbDRs25MYbb+Szzz4rd8snl8vFt99+q8822bp1a/r27RvEiGH8+PG0adOGdevWkZubS05ODt9++y3g+8F0yJAh/PTTT1xyySV88cUX5ObmkpGRQU5ODnPmzKF27dp8/vnnPPLII0GNq6LCwsJYsGABAFarNcTRCBE6breHdx/6KHChBi061eOK33/y/3nmagDG/JHM1l0ZHMpJw2A0EhkZidPp5OjRowHnNaUUR48exel0EhkZeapeNwaDgfj4eJxOJykpKXqZqKgoNE3D4bCjvPnYLCcADZcnEg1FhO0oTlckxzIuRjl+kC6N54hQnHfLnezq3r07SikmT5581rJTpkxB0zR9AFFRfUg3RiGEEKJ6WL16NQC9e/dm0qRJATP9JSQkcM011zB79mzq1aunL3/ssccA6NatG/PmzaNhw4aA76Ly7rvv5t///nexXQorKikpia+//ppWrVoBvlbiw4cP1y9m161bV2hg+SlTpmAymXC73dx8883Ur1+fESNG8PLLL7Ny5Upyc3MrJVbwdc9bsWIFmqYFJLuaN29Oly5dcLvd+vhXlWHNmjUYDAY0TePQoUMsWbKEQYMGccMNN5y1++HBgwepU6eO/qhVqxZWq5Vrr72WzMxMxo8fz6pVq4LeUj8hIYHvv/+eyy+/XF924YUXAvDJJ5/w448/0rJlS5KTk+nXr58+q2RERAS33HILX3/9NZqm8dZbb3H8+PFyxeBwOMjKygp4lFdKSgobN25k8+bN+gQImzdvZuPGjWzcuJGUlJRy71uIc9GG7zeTcSzw/1RUrQh6ndiCQalCiS4/DTAqxdA/f+H3PVmk5mfpg8nn5OSQn386AZWfn09OTg42mw1N0/R1NpsNo9GIzWYjMzOTjIwMbDYbBoMBr9eLx52D0eDAYACj0YnbY8bhikLTwGrJIDs/iXxnLGS/VHSQoloI5Xm33Mmue++9F4PBwGeffcbo0aM5duxYoTLHjh1j1KhRfPbZZxgMBv7f//t/FQpWBJ90YxRCCCGqh9jYWABOnDhRqqEf/vjjD7Zt2wbAE088gcFQ+LLujjvuqLSW9Q8//HCR42r17t2bzp07AzBv3ryAdd26deObb77Ru9sdPXqUBQsWMGnSJHr27ElcXBw33HADP/30U9Dj/eCDD1BK0a1bNxo3bhywbuzYsQDMmjUrqHXGxsby0EMP8euvv5Kbm0t6ejp5eXls3ryZESNGAL4WZTfddFOJ+/F6vRw7dkx/pKam6i0nsrOzyczM5MSJE0GNHWDixIl6S4wz+VvJTZgwgZiYmCLLdOjQgTZt2uB0Olm5cmW5Ynj++eeJiYnRH/6Ebnm88847dOjQgQ4dOuiTE9xxxx36snfeeafc+xbiXJR6JK3QMkuYmbick6XavmFWKpl5HhzKNz6k0WjE6/UGTPjhdrvxeDyYTCY8Ho8+lqT/+8PfndFfxul0njq/eTAYXHi9ZlAaoGEw+PZrMjjwKjNujw08+8r/AohKF8rzbrmTXS1btuTZZ59FKcWnn35K48aN6dKlC6NGjWLUqFF06dKFRo0aMX/+fACmTZtG69atgxa4CA7pxiiEEEJUD7169cJms7Fp0ya6du3K+++/z969e4stv379esD3g1XXrl2LLGMwGOjevXtlhEvPnj3Pus4fY0G9evVi27ZtJCcn89hjj9GzZ0+9FZvL5eLrr7+mW7duPPXUU0GL1ev1Mnv2bOB0t8WChg8fjs1mY+fOnaxatSpo9V5yySW8/PLLdOrUSW/1pGka7du3Z968edx7770AfPnll/zwww/F7qdx48YopQIeOTk5rF69mmuvvZZ58+Zx5ZVXsmbNmqDFDhQ767rH42Ht2rWAr7VewVZnZz7++usvAPbv31+uGB577DEyMzP1x8GDB8t3MPi6ZW7YsIG1a9fSv39/AGbMmMGGDRvYsGED48ePL/e+hTgXJdaLL7TMme8iPTKhVNsfjE4kKtxAmMnXLc3j8WAwGAIaUphMJoxGI263W59gxWKx6D/QeDwejEajXsbpdKJpGiYjKK8RlycMpQwYDU5MRt/2bq8Vg+by/W1sUpGXQFSyUJ53K9Sc55FHHiE6OppHH32U7Oxs1qxZo3/x+X9tio6O5qWXXuLOO++seLQi6KQboxBCCFE9NG/enPfee4+77rqLNWvW6ImLWrVq0aNHD0aNGsWAAQP0mRD93cISExNLHP+iQYMGlRJvSS3G/OuK67pmMBjo1q0b3bp105ft2LGDTz/9lFdffZXc3FymTp1Kp06d6NevX4Vj/f777zlw4ADh4eEMHTq00PqYmBgGDRrEvHnzmDVrVrHJw2B77rnnmDlzJna7nf/9738lJhDPFBERwVVXXcXixYu56qqrWLduHbfccgt//fVXka38yqN27dpFLk9LS8PhcACQnp5eqn2VZWKrgqxWa9DGd6lbty5169YlNzeXL774AoC2bdty2WWXBWX/QpxrOvS+hNik6ICujNkncllxdVu6a5+hFdOVUQFeTWNRmy7cekE0ibYolFLY7XZiYmICWv2GhYURGRlJRkaG3qrLZrP59lNgG03TyMzMxOl0YjAYsNqScORn4/Ua8SojUbYTmI12lAKHM5aYiIOEWTIgalIlvkKiokJ53q3wN+GECRPYv38/7777LuPGjePaa6/luuuu49Zbb2XmzJkcOHBAEl3VmHRjFEIIIaqPm2++mf379/P2228zYsQIGjZsyIkTJ1iwYAGDBg2iW7duFRqzqDpr2bIlTz/9NJ9//rme0HvvvfeCsm9/l7u8vDyio6PRNK3Qw9/lcuHChUXOJlYZIiMjufjiiwH4+++/y7UPo9HIrbfeCsDu3bv57bffghZfcT+GFuxmu2zZskKtzop6TJkyJWhxCSGCw2QycucrYwIXKtj12xF+bf+PIrfxDz3/UbvuXNwilmYxtXG73OTk5GC1WqlTp45+Dgdfa9Y6deoA6Elyo9GIy+XSt6lbt66+nb9MZFQUHhWJ2xOG0WgnwnYcl8dGrr0OFnMOSbFb0aw9MRgLd6cXAoKQ7ALfeAS33347s2bN4uuvv+arr77i/fff55///CfR0dHBqEJUAqWUtOwSQgghqpn4+HjGjx/PvHnzOHDgALt37+bRRx9F0zRWrVqlJw38rW5SU1NxOp3F7u/w4cOVEmdJ+/WvK65lUEl69uzJBRdcAKB3gauIkydP8r///a/U5XNzcwuNNVbdFRyDrKSur8GSkJCg/1Ba3u6J1YX/JlyImqrPzd2Z9NE9WGxmfVn6oUxeP3kBB+MKt+D1ahpz2vfgpzE3MbRDY6IMVlwuFzExMTRp0oSoqKhC20RGRhIZGakPSp+Xl1dom6ioKGJjY/Uy+fn5mMwJWC1ZRNmO4fJE4HKHExNxkCa1VxEZ0xZDfOXMNiwqV1Wdd6U5Tw1W8Fc5SXYJIYQQ1VPz5s15/vnnOXjwIHPnzuW7774D0GfIc7vdrFq1il69ehXa1uv1kpycXClxrVy5kmbNmhW7rmCMZeUfFD0Y3dc+/vhjnE4ntWvXZteuXSV28XviiSd48803mTVrlj6QbmXKyclh69atADRt2rTc+zl06JD+PCIiosJxnY3ZbKZTp06sXr2aL7744pwe60qSXUL4El7xteN49Npp+rK2vVsSt3kDpB8mJzqC5As7sMMcx1dXdCWqn5eJiW2oZ4ymVq1aREVFERYWFtCiq6Dc3FwMBgOJiYnUrVsXr9eLyWQK2Mbj8eD1eomLi6N27dqkpKQQGXaSuhHzsFmycBt6YzJkEBZeFy36dWnRdQ6rqvNuUFp2paamsnDhQl555RWeeeaZYOxSVIGCrbqKOzEJIYQQomr4u24Uxz8Gij9Z065dO1q1agXAs88+i9frLbTNrFmzAhIhwfTKK6/ogw0XtHLlSn755RcAfcZBv2+//VYf17U4v//+O7///jtAUMb08HdhHDJkCNHR0XoLg6IeI0eOBGDt2rX6TJcVcbZjfeKJJ/TXcODAgeWu49NPP9X/7tChQ7n2U1b+YUq+/vprvv766xLLpqUVnvFNCFG92PMCv4P63tODiAO+CSH+bt+SN68fzCftu2GNCCfcYuZobjpms5n4+HjCw8NLvJ/0j+0XGxtLZGQk0dHRhbbJycnB6/Vis9n0ZFi4cS1xkQcIt2YS2/BZIutPxxg3WRJdolQqlOxyu908+OCDNGzYkJEjR/LII4/w9NNPB5RJT08nLi4Om83Gvn37KlKdCDKZiVEIIYSoPiZOnMjw4cNZvHhxwMDuOTk5vP3223z44YcA3HDDDfq6Z599FvAlmEaNGqUntux2O2+//TYTJ04kNja2UuJNSUnhhhtu0Lsaut1uFi1apA8Af9lllzFkyJCAbUaNGkXLli2ZOnUq69atC+h+efToUV5//XV69+6t3+jcd999FYpx3bp1bNmyBfDNuHg2V1xxBY0aNQJOJ8kqonXr1rz++uts375dT0YqpdiyZQujR4/mzTffBOD666+nd+/eZd7/3r17ufPOO/XWeyNGjChx4oBgGj16NL1790YpxeDBg5k2bRpHjhzR1+fm5rJy5UruueeeYlsACiGqj9ys05NIaBqYDAa0U4nqAx3aYrD6kvcup8KqjBzLz0AzaGcd+9nhcJCXl4emaSV+H/nHSgwPDycjIwOAhIg1aJoCY8MKHJmoqSqU7Bo2bBhvvPEGTqeTNm3aFPlBj4uLY9SoUTidThYsWFCR6kSQyXhdQgghRPXhcrlYuHAhQ4cOJSkpiaioKOLi4oiKimLChAk4nU6uvvpqHn/8cX2bwYMH63/Pnz+fhg0bEh8fr2/TqVMnJkyYUCnxzpkzh1WrVtGyZUv91/phw4aRlpZGo0aNWLRoUaFrQ7PZzM6dO3nqqafo1KkTYWFhxMfHY7PZqFu3Lg888ACpqalERUXx6aef0r59+wrF6E9YJSUl8Y9/FD3YckGapunJuo8//lifOay8duzYwQMPPEDr1q2x2WwkJiYSERFBu3btmDt3LgB9+/Zl/vz5Je7n4MGD1KlTJ+ARHR1Ns2bN9EH8u3fvzsyZMysUb1kYjUYWL15Mv379cDqdPPnkk9SvX5+YmBj9c9uzZ0/eeustcnNzqywuIUT55BVIdhlMBsK3b0dTCgWc7NUTo82X7HI4vcRqNpxeDxle+1l7CPkTV5GRkZjN5iLLuN1ufcZWt9uNx+PBYvEQFeZrWUZY4Vl0hTibcie75s2bx2effUbt2rVZv349f/zxB/Hx8UWWHTZsGHB6/AZRPUiySwghhKg+nnzySf79738zePBgWrZsiclkIicnh9q1a9OnTx9mzZpFcnJyoTGZpk2bxpdffknPnj2Jjo7G4XDQqlUrXnjhBVasWIHFYqmUeAcOHMjq1au58cYbsdlsKKVo2rQpDz74IJs3by5yDKqdO3eycOFC7r77bq688koSEhLIzs5GKUVSUhLdu3fn2WefZdeuXXrSqbzy8/P17n1Dhgwp9fWOvwXY8ePH9WnSy+vdd9/l1ltvpV27dsTHx5OVlYWmaTRv3pybbrpJn9ipqAGdC/J6vRw7dizg4XQ6adCgAQMHDmT+/Pn88MMPZ91PsEVHR/PFF1/w9ddfM2LECBo1aqS34qhfvz7XXHMNzz//fFAmGggmm83Gb7/9xm+//YbNZgt1OEJUC3lZ+fpzo9lIzKkWo8pi4cJGrdDCTyW7XG7aRPhakO53nCxxnx6PR59BuKRWXTk5OSilMJvN5OTkAJBoW4yeRwu7vRxHJKqTUJx3NXW2wQSKce211/L9998zZ84cRo8eDUDdunU5fvx4wMDn4JvmOSoqigYNGpzzM7ZUVFZWFjExMWRmZoZ8psrU1FSOHDlCbGys3mRfCCFE5apO3wNClFVycjI9evQAzj4elRCVQc6hQlSOmY99zIIXPwMgIi6cuU3/JGLDBpyNG7N3+XIeWvMZh3/1tcx65b6rWXNwOyrKwhNXjix2n2lpaZw4cQKr1Urjxo2LbQV28OBB8vLyMBgMeL1ewsPDqWcejsZJ0CIwJG0K/gGLc1ZpvwfK3bJr0ybfB+7GG288a9nw8HBiYmICxp8QoSdjdgkhhBBCCCGEKNiN0WIzYd27FwDHqYlQjBGnG7REu8PRgH2Ok5x0ZBe5P6WU3oUxLi6u2ESXy+UiPz8ft9ut358mJib6El0A5o4VOSxRg5U72ZWZmUlMTIw+M9DZeL1emfGvmpFujEIIIYQQoqZxOp28/PLLvPzyywGTJAhRk+Vnn+7GaI2wYjw1g2J+584AmCNP3zOmpGYTb4nEbvCwOX1fkfvLzc3F5XJhNBpL7GLt78Lo8XgwGAxERUVh5cfTBSLvL/9BiWojFOfdcie74uLiyMzMLHLK6TOlpKSQlZVFUlJSeasTlcCf7DrbDBpCCCGEEEKcL1wuF5MmTWLSpEkVnoRAiPNFboFkVwtDhj44fc611wIQazvdyOVIWg51ImJx4S022eVv1RUTE4PBUHzaISsrC5fLhVIKTdNITEyEXP9kGwYMltYVOSxRTYTivFvuLMdll13G8uXLWblyJddff32JZWfNmgXAVVddVd7qRCWQboxCCCFEzbN69WqGDBlSpm06d+7MkiVLKikiEWwHDx6kY8eydf1p2LAh69atq6SIhBDVXX726UYsnfJPjbNtteKNjwePhxZR9dhkPIDXA8cy8uhwcTOwwx/pB3B7PZgMp+8pHQ4Hubm5aJpW4sD0TqeT/Px88vPziYyMJCYmBovFgtd9alILY4PKOFRRQ5Q72XXzzTfzzTff8OSTT9K1a1ciIyOLLPfNN98wdepUNE1j7Nix5Q5UBJ90YxRCCCFqHqfTybFjx8q0TVpaGgDdu3eXgenPAR6Pp8zvscxKKETNVrAbY4u8IwBo9evry/rWv4TFp5Jd+zMyqBcVT0x6OJmuPHZkHeHi2IZ6WX+rrsjISMxmc7F1Zmdn6618TCYTCQkJeD1pwKlubmFl+2FGiILKnewaNWoU7777LqtWreLKK6/krrvu0vtefvfdd+zbt0+fitjr9dK/f3+uPdUEUlQPkuwSQgghah5JWJ3/mjRpIu+xEKJM8nNOt+xKyj01OPwll+jLmkbXwWzWcDkVRzNzsFltXBLXhB+Pb2NT+l492eXxeMjKygIosVUX+Low5uXlERYWRlxcHCaTCW/G66cLhN0elGMTNVO5k12apvG///2PwYMH89NPP3Hffffp66677jr9uVKK3r17M3fu3IpFKoLO341RxuwSQgghhBBCiJqrYDfGcHuO70nv3voyg8GA2QLkQq7dhcVi4bL4pvx4fBsb0/Yypuk/AN9Edl6vF6vVWuJkdg6Hg6ysLDweDzabjbi4uFMrvj9VIgKD0RLMQxQ1TLkHqAffIPU//PADc+bMoWvXrlgsFpRSKKUwGo1cddVVzJ49m2+++abYbo4iNJRSeL1eQFp2CSGEEEIIIURNZs/1JbuaqAwMpwan58Yb9VaimqZhs/nSBw6HL5nVNrYRRgwcyU/nmD0TpZTehTEuLg5N04qtLzMzk/z8fCwWC7Vq1Tp9T6p83eYxX1YZhylqkAo36TEYDIwZM4YxY8bg9XpJS0vD4/GQkJAgLYaqMX8XRpBklxBCCCGEEELUVEopvWVXVw77FlosULs2ZGYCvvv+6HATx/Dg9vh6B5k1jYui67Et6xCb0/bRJbo5LpcLo9FIVFRUifUdP34cr9dLeHg4MTExAHjzvwNOdcGOur+yDlfUEEHNRhkMBt9UoaLaKzgTY0kZdyGEEEIIIc4nNpuNlStX6s+FqOlcDhcet6/XT1tSAfDUqVMoWVAnOoJdOPB60O8hL4lvwrasQ2xK30sbbwIAMTExGAzFdyLLzc0lOzsbTdOoV6/e6bK5b58qYcBgaRu04xOhF4rzboW6MYpzlwxOL4QQQgghaiKj0Uj37t3p3r27XAsLAeQVmImxMb7B5d2tWweU0TSNNrVrAaAUrD72FwCXxTUFYEv6AdKzs9A07awD06ekpKCUCmjV5avUt0+M9YveUJyzQnHeLVXLrgMHDgBgNpupW7duwLKyslqt0sWxGvAnu+R9EEIIIYQQQoiaKy/rdLIrBicArm7dOLP9TbOEOP35gj2/0jnpIhqEx5NojeJobjp/O07QsXYLzGZzsXU5nU7S0nzjctWtW1dvIeb1ZMCpugkbUuFjEqJUmY6mTX3Z2pYtW/Lnn38GLCtXpSYTHTp0YNKkSQwaNKjc+xHlJy27hBBCCCFETeRyuXj33XcBuPPOO0u8MReiJvC37GqkMjHiG5zeNXAggD5APUCM7XT6YNvBo4CvxVf7mMYcyTrJDvsx+sR2LLGulJQUPB4PFouFhISE0yuyXzv9POyOCh6RqG5Ccd4tVTdG/wyLBT/oBZeV9eFyuVi7di033ngjS5YsqbSDE8UrOGaXEEIIIYQQNYXT6WTixIlMnDgRp9MZ6nCECLkzB6dXZjPGevUCyvjv5f3DPWdlnv6/08KSCCh2OU+UOB6Tw+Hg5MmTANSuXTvwXtTx/akn4RiMloodkKh2QnHeLVXLrr179wIEZN/8y8rK7XZz+PBh3nzzTZYuXcorr7zCkCHSTLGqScsuIYQQQgghhBB5WXkAtDs1OL27Vq1CA8zrjSUMGm6Pwp3jW66Uoq47HJNmJFPZSbFnUD88vsh6UlNTcTgchVt1AShfEgzzZUE6KlHTlSrZ1bhx41ItK63mzZvToUMHYmJi+OOPP8q9H1F+MmaXEEIIIYQQQoi8Uy27/IPTOy66qFCyy+FwoGkaFpMBt8eDyvc1msjNzUXzKJrZEtnnyWBT2t4ik135+fmkpaWhlCIqKorw8HB9nTd/BXCqF1nU/1XCEYqaKGSzMUZERNC0aVOsVmuoQqjRpBujEEIIIYQQQgh/y65YHL6/r7qq0H2iy+VC0zQirad6e9kNrD7+FxkZGQBcFt8MNNiUvq/Q/pVSpKam4nQ6sVqtxMbG6gPTA5A749QTAwZL22AemqjBgprs8ng8nDhxghMnTugth0qya9cuvc+uqFrSjVEIIYQQQgghRG5WHg1VFsZTratyrrlGb9nlH7fbP85STLivsYpyGFh64Fdfyy5No3P9VgBszzpMntsRuP/cXHJzc3G5XISFhREdHR0YgHuH719j4DhhQlREhZNdubm5vPrqq3Ts2JHw8HDq1KlDnTp1CA8Pp2PHjrz66qvk5OQEI1YRRJLsEkIIIYQQQgiRm5XH1acGp3drBtx16hTbsisu4lTPLJfGtkzfNpGRkTSMqkW9sDg8ysvWjIP6dv5WXS6XC4vFgs1mCxjE3uvJAE4NWG4bXGnHKGqeCiW7Nm/ezMUXX8ykSZPYsGEDLpcrYMbFDRs2MGnSJNq2bcumTZuCFbMIAhmzSwghhBBCCCFEbmYe7TgBQE64r9WVwWDQW3WBr2WXpmkkRof5Frg1Mtynuj/GxgJwSVwTADaln57MLjs7G4fDobfqioqKCuzCmP366efh44N8ZKImK3emIyUlhd69e5OWlobFYmHo0KH07NmT+vXrA3D48GFWrlzJokWL2L9/P3369OGPP/6gXj1pmlgdyJhdQgghhBCiJrJarXz55Zf6cyFquvzsfJqcGpz+ZO0GGAwGNE3Tk10ejwdN0zAYDCTFRvg28mi4lQer1UpYmC8BdmlcE74+solNafv0RjCpqakopTAajRgMBqKiogIrd3536kk4BqOlKg5XhEAozrvlTnY988wzpKWl0bhxY5YtW0bLli0Llbntttt44oknuO666zhw4ABTp05lxowZRexNVCWlFF6vF5BklxBCCCGEqFlMJhM33HBDqMMQotrIy7YTd2pw+tRW7ah1xj2ix+PBZDJhNpupExvpW6h88ycWHGy+VUx9rAYz6a5c9ueeIMZlxuVy4fV6sVqtWCyWwokO76kxvM2XVuYhihALxXm33N0Yv/76azRNY+bMmUUmuvwuuugiZs6ciVKKr776qrzViSAqOHmAJLuEEEIIIYQQouaypRzUB6dP79VbH5zez3//aLFYaJBwKtmFhtcO2xzH9HJmg4m2sQ0BWH/yb30yOrPZjKZphbowevNXwKl6ifq/SjgyUZOVO9l17NgxwsLC6N2791nL9u7dm/DwcE6cOFHe6kQQFezCGNBfWgghhBBCiPOcy+Vi9uzZzJ49G5fLFepwhAi5i/b5xtd2oxHRrkWJya7Y8AJdDbNNfH54fUDZS+ObAvDbsZ14PB7MZrPeq6jQLIy5b596YsBgaRekoxHVUSjOu+VOdtWqVatMrYIMBgO1atUqb3UiiGQmRiGEEEIIUVM5nU5uvfVWbr31VpxOZ6jDESLkmqXvA+AkNqJrRen3iQXH7AJfsksphcHfXiLXyPaswwH7uiSuCSjF7pyj5Hqc+syLNpsNi+WMMbncO3z/GusG/ZhE9RKK8265k129evUiJyeHDRs2nLXs+vXrycnJoVevXuWtTgSRzMQohBBCCCGEEAKgvt3X3XAvMZhMpmJbdlmtVux2O2ajb73KMZLmzAkom2iNIskUjVKKAypD71V05sD0Xk8GnBonDNug4B6QEFQg2fXEE08QERHBHXfcoffFLUpaWhp33nkn0dHRPP744+WtTgSRzMQohBBCCCGEEAIgxpsPwO9abX3WRT+Px6PPpmg0GnE4HFjNp+4j7UacXnfAvpxOJ82N8QDs8aRht9uBwskust88/Tx8QpCPSIhSzsZ44MCBQsssFgvvvfce48ePp1WrVkyYMIEePXpQv359AA4fPszKlSt5++23cblczJw5s3CzRRES0o1RCCGEEEIIIQR79mA6NUj8WnMjuhkMAfeJ/ntHs9lMXl4eSikirGay8l0ou8E/vLwuNTWVi2xJ/JS7my1ZB+lruZCI8AjMZnNgQee3p56EYzBKnkAEX6mSXU2bNj1rmWnTpjFt2rRi148cORJN0/RWRSJ0JNklhBBCCCGEEMIzfwFGfIPTnwyLLbJlF/gau2RlZQEQHW4hJSMPHL5yv57YxRW1WmC328nOzqaJNZ4oazhZjjwOOjPomFSncMXeVN+/5ksq8/BEDVaqboxKqaA8/LMwiNDyJxxlzC4hhBBCCCGEqLm8P/wAQBo2rOG+1lcFB6j3J7u8Xi9utxtN00iICvdt7PKNVL/04G+Ar1UXQEx0DG1jGqG8XnY6jhcer8u+EvxtwqLuq7RjEzVbqbIde/furew4RBWSll1CCCGEEEIIIbRt2wDYRzS2SN/MiUW17LLb7Wiahs1mIyHKVw63L9m1I/sIubm55ObmomkaiYmJtMxL4me2scuVWriRRc6MU08MGCyXVt7BiRqtVMmuxo0bV3YcogpJsksIIYQQQtRUVquVBQsW6M+FqMmMJ44DsJla2KJ8/x/8yS5/yy6v14vT6cRoNGKz2agdfapll9eX7DrpyNZbdcXGxmI2m2lMNABHXBmkO3OIs0SertS9/VTldSv78EQ1EYrzbrlnY6yJPB4PL774IhdccAFWq5XmzZszbdq0c24cMkl2CSGEEEKImspkMjFs2DCGDRsmw3qImm3/frRT97I/04DwmDDg9H2iy+XSE14Gg4GIiAgMBgN1404luxQoBU6vG7vdjtFoJCEhAYfDgdmt0cASh8FgYHP6fr1KrycTcPj+sA2oskMVoRWK826Fk11er5e9e/eyfv161q9fz969e8/bsbnuvfdeHn30Ua6++mqmT59Ojx49ePLJJxk/fnyoQysTf7JLvtyFEEIIIYQQooZatAjwDU6fokUSeSqJ5W/Z5XQ69WSXpmnEx8cD0CDe30pLQ9k1fUbGuLg4jEYj2dnZALSLaQSaxqa0fafrzHnz9PPweyrryIQoXTfGoixbtozp06ezatUqcnJyAtZFRkbStWtX7rnnHq6//voKB1kdbNmyhbfffpu7776b6dOnA3D77bcTExPDa6+9xoQJE7j88stDHGXp+FuiScsuIYQQQghR07jdbpYuXQrA4MGD5QdgUXOdGpw+HV+3ssj4COD0faLT6dQTXVarlfDwcDRNIybCdnof2UYIc7PDcZT+cS1QSunJrk61WvB91g62ZOzH7fVgMhjBsfzUhmEYjJaqOU4RcqE475a5ZVdqairXXHMN/fr1Y9myZWRnZxeadTE7O5tly5bRr18/+vTpw/Hjxysj9io1b948lFLcf//9Acv9f8+bN6/qgyoHr9ert7yTZJcQQgghhKhpHA4Hw4cPZ/jw4TgcjlCHI0TobNkCwD5iAIip7Rtny9+yy+Fw4HK5MBgMxMbGommavs5o8I3XRY7vnvLn/H0YDAYcDgdOpxODwUCb2o2JNoeR53GyMzvFV97rG9sL8yVVcICiugjFebdMya60tDS6dOnCihUrUEoRGRnJjTfeyNSpU5kxYwYzZsxg6tSpDBkyhMjISJRS/PDDD1x99dWcPHmyso6hSqxfv56EhARatGgRsLxhw4bUq1eP9evXhyiysvF3YQRJdgkhhBA12ZQpU9A0je7du4c6FFEDzZ49G03TaNKkSahDEaLmOnoUgD9IBCCubgwGgwFN8yWycnJyUEphNBqJifElxPzrrOZTLXPyfPeUu/KPAeituiIiIjAZTVwa1wSATWl78dqTwd/pMer+SjwwIcqY7BozZgy7du3CbDbzzDPPcOTIERYuXMjjjz/O+PHjGT9+PI8//jiLFi3iyJEjPP3005jNZvbs2cOYMWMqHGxeXh7Lli1j2rRpDBkyhMaNG6NpGpqmMWXKlFLtIzs7mylTptC2bVsiIyOJiYmhY8eOvPrqqzidzmK3O3LkCPXr1y9yXf369Tl8+HB5DqnKFRyc3n+iEkIIIYSoSi6Xi1mzZtG3b1/q16+P1WolJiaGCy+8kB49evDYY4+xbNky7HY7AMnJyfo1X3ke+/btC6jf4/FQv359ff13331XKMbu3buXu75x48aVaT8NGjQo9Ws3YsQIfbvHH3+8XK+/EEJw4AC4XAD8iO8cFF8vVm8QoZQiKysLAJvNprfo8t9DhlnNvv3k+5JeJ505AV0Yo6KiALjEn+xK3wc5M05VrmGwXFpphyYElGHMruTkZJYtW4bZbOZ///sf1113XYnlIyIiePLJJ7n88ssZOHAgy5cvZ+XKlfTo0aPcwf7222/07du33Nvv37+f7t276xc84eHhOBwOfXD9uXPnsmLFCuLi4gptm5eXR0JCQpH7tdls5OfnlzuuqiSD0wshhBAilA4ePEjfvn3ZunWrvsxisWA0GtmzZw+7du0iOTmZF154gZUrV9K9e3csFgtJSUlF7i8tLQ2Xy4XZbNYHTz7Tma3Zly1bxpEjR/S/Z82aRZ8+fQLKxMfHF1mn0+kkPT0d8A3GbLEUHnPG3wKioIiICCIjIwstB6hdu3aRy8908uRJ/ve//+l/z5kzh2eeeUZa6wshym7JEgC8moEUfImpxAZxelIrNzcXl8uFpmlERETom/nXR1iMnARMDjNeTs/I6HK5MBqN+jbt4hpjxMDBvJOcyN9DLTNgqFtlhylqrlK37Pr0008BmDhx4lkTXQVdf/31TJw4EaWUvo+KiIuLo1evXjz88MN8+umn1KlTp1Tbud1u+vfvz759+6hbty7fffcdubm55OXlMW/ePKKioti0aROjR48ucnt/YqwodrudsLCwch9TVSrYsksIIYQQoip5PB4GDhzI1q1bCQ8PZ+rUqRw4cAC73U5aWhp5eXn89ttvTJkyhebNm+vbde7cmaNHjxb56Ny581nLNGzYMCCO999/H4B77rkHTdNYunQpaWlpAWWWLFlS5L6WnLpBLKnMm2++yZkeeuihYuPbuHFjqV6/jz/+GKfTSd++fWnevDmHDx9m+fLlZ99QCCHOtGIFANmW04ksW8TpFlz+YYhMJlPAvaOmaXg8HiIsvsYTZrevhZcCvSVYZGSkvp9Ik40W0XVBedicE32qooGVd1xCnFLqZNeqVavQNI3x48eXuZIJEybo+6iIrl27kpaWxvfff89LL73EyJEjsVqtpdp2zpw5bDk1AN/ixYvp3bs34MtMjxgxgnfeeQeAr7/+mhWn/uMXVK9evWK7Kh4+fLjYLo6VwuOB5GT49FPfvwXG4SrNdrHLlhGxbl3ptxNCCCGECIIffviBTZs2Ab6E0xNPPEHDhg1PjwFjtdKxY0cmT57Mrl27uOqqq4Iew7Fjx/jyyy8xGo3861//olu3bjgcDubOnRv0uoLNn6S75ZZb9CFC/MuEEKJUnE544w3ffSRwUIvWV33zzkoy0zNJS0vj2LFj+uD0DoeD3NxccnJyyMnJIT09nQjrqRkbcxWePWF4vTDu9/d49ch3eKyBaYZLYuqj3IdZkdGA1Vl12Oa8Bo/yVtURixqq1MmuI0eOYLVaufDCC8tcSYsWLbDZbKSkpJR524Iq0hppzpw5APTo0aPIC6eRI0fStGlTAD788MNC6zt06MDJkyfZtWtXwPKDBw9y5MgROnToUO7YymTJEmjSBHr0gFGjfP82aaI3Qz3bdtEDB9Lo0UepO2pU6bYTQgghRLUwf/58rr/+epKSkjCbzcTGxtKiRQsGDBjA9OnT9fGtClq2bBl9+vQhNjaWyMhI2rdvz0svvYTr1DgtwVJwTC2ATZs2cfPNN9OgQQPMZrM+CP7mzZv1bQYOLPmXff9U98H24Ycf4na76d27N/Xq1WPs2LGArytjdbZu3Tq2bNlCTEwMAwcO5JZbbkHTNL744gtOnDgR1Lr844xNmTIFl8vFq6++yuWXX67PxpZ86ibZb+vWrdx55520aNGC8PBwIiMjadeuHY8//jipqalBjS3Yjp4aoFuIGmHSJAgPh//7P8jJAaC1/TC3qz8A+Oa/P/LAZc/w0p3/4fjx4+Tk5JCdnc3hw4dZu3Yta9as4cCBA8xbvZP1e33/t11uL2prJN4vEjn+h2Kz4wiDf32DMav+DYA3bQLGnMmkOE2syqzHlP0deWjze0xY/Qi/pe4OzesgQqqqzrulTnY5nc4KXXBYrdYSB4CvTHl5efzyyy+Ar1tlUTRN07tnfvvtt4XW+wcDfeONNwKW+/8eOXJk8AIuzpIlMHQoHDoUuPzwYd/y4hJX5d1OCCGEENXCbbfdxsiRI/nmm284fvw4NpsNl8vF7t27+eKLL5g4cWKhi8cpU6bQt29fvv/+ezIzMzGbzWzbto1HHnmE3r17V9p12eLFi7niiiv45JNPyM7OLnac0ENnXpdUEX9S65ZbbgFg6NChREREsHnz5lJ3JwwFfwuu4cOHY7PZaNq0KV27dsXlcvHRRx9VSp12u53u3bvz0EMP8fvvvwfM0ub30ksv0b59e2bOnMnu3bvRNA2Xy8WWLVt47rnnaNeund6ar7qwWCxMnjwZ4JyfMV6IUps0CV5+uVDvHg0Yzk494YWCv387yJEdxwHwer243W7y8/NxuVzsS83lr+O5RVah9oTj2RoOwF+5Rxmd/Ai/ndzCzKOtcSsDGopwgxubwc3feV6m/jFTEl41RCjOu6VOdtWqVYusrCwyMzPLXElmZiaZmZkkJiaWedtg2L59O16vr5nkxRdfXGw5/7qjR48WGrehffv23Hnnnbz11luMGzeO999/n9tvv53XXnuNsWPH0rFjx8o7APCdlO67D5QqvM6/7P77C3dN9HhQ992HKut2QgghhKgWfv75Zz744AMMBgMvvvgiJ0+eJDs7m9zcXFJTU1m+fDljx44NGCj9888/5+mnnwZg2LBhHDhwgPT0dLKyspg+fTpr165lxowZxVVZIePGjaNPnz5s376dzMxM8vPzmTlzJgCdOnXSy911111VPpv1L7/8wo4dO4iKimLw4MGAb2yZIUOGAJXbJXDu3Lk0adIEq9VKbGwsl19+OY8//njAQPnFycvL08e+9SfpgEpvlTZ9+nT++OMPPvjgA7KyskhLS+PEiRO0a9cO8L1ejzzyCOHh4Tz77LOkpKToY+KuX7+enj17kpKSwoABA8g51YqkOjCbzQwYMACQSZtEDeF0wmuvFbnKn74eyk5MygsaNL+yETkn8/B6Tnc11DQNr9dLVr6LVrUj0YrZk9oTzqlbb3baDbxzsBX5XhORBieaBg5lxGrwEm+yk+9x8/7u76VLYw0QivNuqZNd/i+1pUuXlrkS/0Ce7du3L/O2wVDwIqKksbUKrivqwuO///0vzz33HKtWreLuu+9mxYoVPP300/oFXFEcDgdZWVkBj3JZtapwy6yClIKDB/n71NhkW7Zs4Y8//mDP7Nlohw4VcTIK3I4KjqcmhBBCiMqxevVqAHr37s2kSZMCZhxMSEjgmmuuYfbs2dSrV09f/thjjwHQrVs35s2bpw/QHhYWxt13382///1vMjIyKiXe1q1b8/nnn9OyZUt9WYsWLfR4/LMe/vDDDzRu3JjOnTvzf//3f3z88ceFhosINn8ya9iwYQGTC/kTSJ988kmR3UGDYffu3Rw5coSIiAiysrLYsGEDzz33HK1atTrr9fWiRYvIysqiefPmXH311fpy/3H8+eef/Prrr0GPOScnh08++YRx48bpr1dCQgLx8fFkZ2fz0EMP6fH961//0ieOMhqNdOjQgeXLl9OhQwcOHTrEe++9V64YgnYtDaSkpLBx40b9AQT8XdEhV4Sott56q8TGDRpgBPqzm6haEcQ3iCbnRC4n9pxuAKJpGocy7GTa3dSKshATVlTCQgM01N4w/e8dzjgijU7CjL767V4jKNA0iDQ62Z97gL+yzp70F+emUJ53S53s6tevH0opnnrqqUKtnkpy8uRJJk+ejKZp9OvXr1xBVlR2drb+PDw8vNhyBdcV3MbPZDLx2GOPsWfPHhwOB3v37uWpp57CbDYXu8/nn3+emJgY/XHmbEClVsoPgenECZRSeksuc2nHSZAvdyGEEKJaio2NBeDEiRP6rMol+eOPP9i2bRsATzzxhD4jVkF33HFHpU2u8/DDD5c4zurSpUu5++67MZvNeDwe1qxZwxtvvMGYMWO48MILadKkCU8//XSFkhpFycnJYcGCBUBg6yiAnj170qBBAzIyMgJmWwyG7t2788EHH3D48GEcDgdpaWmkp6fzwQcfULt2bbKyshgxYgRr164tdh/+JJ1/UHq/gi3UKqNVWps2bejfv3+R6xYvXkxGRgaXXnop1157bZFlTCYTN910E0C5Z40M2rU08M4779ChQwc6dOjAHXfcAfj+L/iX+SesEuK8s2dPqYrVIxdLmBmjxYTL4cae69DXKaXIc3pweryYDBoWUwmphNzT67xomDUvNoMHDXArA55TaQiz5sWjPKQ7i+4WKc59oTzvljrZNW7cOOrXr8/hw4fp1asXu3efvW/trl276NWrF4cOHaJevXqMGzeuIrGekx577DG9G2dmZiYHDx4s347q1i1dscsuo2XLlrRq1YpWrVpR//LLg7p/IYQQQlStXr16YbPZ2LRpE127duX9999n7969xZZfv3494Es0dO3atcgyBoNBHzQ+2Lp06VLi+oiICKZPn86hQ4d49913GTNmDK1atdITZPv372fKlClccskl7CnlDVppzJ8/n9zcXJo0acI//vGPgHUGg6HSZjecMmUK48aNo169evp4VzExMYwbN47Vq1cTGxuLy+Vi0qRJRW6/e/dufVb0M5NdcLor47x588jLywtq7CW9l/7xcLdv306dOnWKfTzzzDOA730tj6BdSwPjx49nw4YNbNiwQe+ZMXPmTH1ZeWadF+Kc0Lx5qYodIQJnvguP043ZasISfrp7vKZphFtMWIwG3F6F011C18OI0+sMKFzKgKYpEs351LPkYtR8613KgFEzEmeJKN9xiWovlOfdUie7rFYrs2bNwmg08scff9CuXTtuv/12vv76a1JSUnA6nTidTlJSUvjqq6+47bbbaN++PX/88Qcmk4n333+/UmbUKY2oqCj9eUkXAQXXFdymIqxWK9HR0QGPcunaFRo08LX3LIqmQcOGmHv2xGKxYDabMZvNGLt3L9V2FHMxLIQQQojQat68Oe+99x6RkZGsWbOG22+/nWbNmlG7dm1GjBjBZ599FjA25/HjvkGFExMTS7z2atCgQaXEW7t27VKXu+OOO/jwww/Ztm0bGRkZfPbZZ3o3vb179wZ1AiB/Emv06NGFBlmH00mjlStXlphMDKbmzZtzzz33AL6x2YoatHfWrFkopejSpQvNmjUrtL53797Ur1+f7OxsFi5cGNT4Snov/UN+2O12jh07VuzD30KvvIm4oF1LA3Xr1uWyyy7TH0DA33Xlx19xvrr7biihxa0CPMAXXED2iVzSDmURWSuCuhfV0s+XSikaxNmICTNxIttJZr67mD0ptKb5+t8tLenkeCwoBVaDB4OmTu0PcjwWGkc04qLoekXsS5wPQnneLXWyC6BPnz589NFHhIWFYbfb+eCDD+jfvz8NGjQgLCyMsLAwGjRowIABA5gzZw52u52wsDDmzJnDNddcU1nHcFYFx7AoaSDUgusKblMtGI3w5pu+52deoPn/fuONwiex8m4nhBBCiGrj5ptvZv/+/bz99tuMGDGChg0bcuLECRYsWMCgQYPo1q1b0Lv9lVdJXRhLEhkZyYABA/jxxx/p0aMH4Gultnnz5grHtH37dtasWQPAtGnT0DSt0MM/xphSig8++KDCdZbWVVddpdd7ZpLN4/EwZ84cwJcMKypuo9GoX8MGu1VaSe+lv0vtiBEj9CE0Snrs27cvqLEJIcrAYoEHHihylf+nkkVciFszgII9aw8QlRCOwWDQZ2FVSmHQNGLDLWw/nkPh6c98S7Tmefh7z19o8zK+4XbCDG7S3DYcXgNeBQ6vgTS3jTCjiX9e0BujVqa0hBClUuZP1YgRI1i/fj2DBw/WP/RFPTRNY/Dgwaxbt07vqx8qrVq10ser2Lp1a7Hl/Ovq1KkTMPhrtTFkCCxaBGeOsdGggW/5qZmEgradEEIIIaqN+Ph4xo8fz7x58zhw4AC7d+/m0UcfRdM0Vq1axZQpU4DTrXFSU1NxOp3F7q+qZ0IsLYPBwO23367//ddff1V4n2VNAs2ePVufyTuUli1bVqrZGv1WrVpV6YP8+/kHoy9v98RQq1u3LpMnT5bWXKLmeOklePjhQo0cvMACLuQ9zTchHRo0v6IRjdrWx2QyYTKZ9IYtZrOZprWiaFMvpsgJ0LTmeRgv9rXivCiiDh93f5FOCW15vNEGmtmysHtNZLht2L0mmocbeLLdHXRKvKByj1tUG1V93i3XnI8tW7Zk8eLFHD16lOTkZP7880+92XVCQgKtW7emR48e+pdgqIWHh9OlSxdWrVrFN998w8MPP1yojFJKHzgzlK3QzmrIEBg40Dd7YkqKb6ytrl3P3jKrvNsJIYQQolpq3rw5zz//PAcPHmTu3Ll89913AFx+arxOt9vNqlWr6NWrV6FtvV4vycnJVRlumURGRurPKzoMhsvl4qOPPgLgtdde0wfILUpmZiZNmjTh4MGDfPfdd8UOvB5M/oHpNU2jSZMmAev8SbrBgwfz4Ycflrifbt26sXHjRmbNmsXzzz9fKbEW1KVLF+bMmcOGDRtISUk555JGdevW1RPEQtQYL70E06b5ZmfcswdPkyZsvKgrOz76kUsycmnRqRn97+pDWEQYHo8Ho9GIx+PRk15KKfLy8rjkEnjKauWrdbs5nJpJQlwYW6K2k+KC+mENmHzJMGJPjcNliJ9Bp5h8OiS+yF9ZR8jw1iE2Ziyt4ppKi64apqrPu+VKdvnVqVMnqGMpVKaxY8eyatUqVq5cya+//soVV1wRsH7hwoX8/fffQOEZeqodoxHKM6hsebcTQgghRMg4HI4SEz5hYb4p3v2t2Nu1a0erVq3Yvn07zz77LD169Cg0I+OsWbM4dOhQ5QVdjK1btxIXF3fWmSALJnYuvfTSCtX5xRdfcPz4cQwGAyNHjgxIpJ0pMjKSXr16sXz5ct5///0KJ7v8vR2Ks3fvXqZPnw5A586dSUxM1NcdO3aML7/8EvD1rCgpboBhw4axceNG5syZw7Rp08rdnbS0hg0bxqRJk8jIyOCBBx7gk08+KfZYvV4vWVlZ+syiQogQsljg/vsBMAIdgY79OpV684LnotG9OxRYc1Wx2xiMYRjipnBxXNlCFaIizrlUanp6OqmpqfrD38Q8Ly8vYHlOTk7AdmPHjqVt27YopbjxxhtZsWIF4PvyXbhwof4r3/XXX1/kL6BCCCGEEKEwceJEhg8fzuLFi/XB5wFycnJ4++239cTQDTfcoK979tlnAd9g66NGjdITW3a7nbfffpuJEyeGJPGQnJxMs2bNGDFiBAsXLiQlJUVfZ7fb+fnnnxkwYACLFy8GYOjQoTRu3LhCdfpbR1199dWlan00fPhwAD777LMiB4wvixdeeIGxY8eybNkyMjIy9OVZWVl8+OGHdO7cmfT0dMxmMy+++GLAth9++CFut5uwsDD69etX6rhTUlL4+uuvKxR3acTGxvLGG28Avpkgb7jhBn799Vf92tzr9bJ9+3ZeffVV2rRpoyfuhBBCiKpQoZZdoXDppZcWOTbAyy+/zMsvv6z/PXbsWGbPnq3/bTKZ+Pzzz+nRowf79u2jd+/ehIeH4/V6sdvt+r7nzp1b6ccghBBCCFFaLpeLhQsX6jPtRUZGYjKZApInV199NY8//rj+9+DBg3n88cd59tlnmT9/PvPnzycuLo7s7Gzcbjddu3bl6quvrpLubgWZzWacTicLFixgwYIFANhsNsLCwkhPTw8oe8011zBr1qwK1Xf48GF9mIphw4aVaptBgwZx11134XQ6+fjjj7nvvvvKXb/D4eDDDz/UE5JRUVGYzWYyMjL0pFBMTAyzZs2iS5cuAdv6j71v375EREScta5mzZpx2WWX6V0Z+/fvX+64S2vs2LHk5+dz3333sWzZMpYtW4bVaiUyMpKsrCxcLpdetqQWbkIIIUSwnXMtuyqiSZMm/PHHHzz11FNcfPHFaJqG2WymQ4cOvPLKK6xdu5a4OGlbKYQQQojq48knn+Tf//43gwcPpmXLlphMJnJycqhduzZ9+vRh1qxZJCcnF0qITJs2jS+//JKePXsSHR2Nw+GgVatWvPDCC6xYsQKLxVLlxzJ+/Hh+//13XnzxRQYOHMgFF1yA0WgkMzOTqKgoWrduzS233MLXX3/N8uXLiYqKqlB9s2fPxuPxYDAYGDp0aKm2iY+P11v5V3R2w2HDhvHUU0/Rp08fmjZtiqZpZGVlERcXx9VXX80zzzzDX3/9xZAzJgv65Zdf2LFjB3C6xVZp+Mt++eWXHDt2rEKxl9Zdd93FX3/9xUMPPUT79u2xWq1kZGQQGRnJ5Zdfzr333st3330X8gmrhBBC1CyaUqrwrKEi6KZPn8706dPxeDzs3LmTzMxMoqOjQx2WEEKIKpaVlUVMTIx8DwghRDnIOVQIIWq20n4P1KiWXaF0zz33sG3bNtatWxfqUIQQQgghhBBCCCHOW5LsEkIIIYQQQgghhBDnDUl2CSGEEEIIIYQQQojzxjk3G6MQQgghhAi+1atXFxoo/Ww6d+7MkiVLKikiURFDhgxh9erVZdpmyZIldO7cuZIiEkIIIaqOJLuEEEIIIQROp7PMM/ilpaVVUjSiotLS0sr8fjqdzkqKRgghhKhakuwSQgghhBB0794dmaT7/JGcnBzqEIQQQoiQkTG7hBBCCCGEEEIIIcR5Q5JdQgghhBBCCCGEEOK8IckuIYQQQgghhBBCCHHekGSXEEIIIYQQQgghhDhvSLKrikyfPp3WrVvTsWPHUIcihBBCCCGEEEIIcd7SlEy7U6UyMzOJjY3l4MGDREdHhzocIYQQVSwrK4uGDRuSkZFBTExMqMMRQohzilxLCyFEzVbaa2lTFcYkgOzsbAAaNmwY4kiEEEKEUnZ2tiS7hBCijORaWgghBJz9WlpadlUxr9fLkSNHiIqKQtO0cu/Hn808V37VOpfiPZdiBYm3sp1L8Z5LsULNjVcpRXZ2NvXq1cNgkNEEhBCiLIJ1LV2dnGvfh1VFXpeiyetSNHldinY+vi6lvZaWll1VzGAw0KBBg6DtLzo6+pz60J5L8Z5LsYLEW9nOpXjPpVihZsYrLbqEEKJ8gn0tXZ2ca9+HVUVel6LJ61I0eV2Kdr69LqW5lpaflIUQQgghhBBCCCHEeUOSXUIIIYQQQgghhBDivCHJrnOU1Wpl8uTJWK3WUIdSKudSvOdSrCDxVrZzKd5zKVaQeIUQQgiQ75fiyOtSNHldiiavS9Fq8usiA9QLIYQQQgghhBBCiPOGtOwSQgghhBBCCCGEEOcNSXYJIYQQQgghhBBCiPOGJLuEEEIIIYQQQgghxHlDkl1CCCGEEEIIIYQQ4rwhya5zSHZ2NlOmTKFt27ZERkYSExNDx44defXVV3E6naEOT7dx40aefvppBgwYQMuWLUlISMBsNpOQkECXLl149tlnSUtLC3WYRcrKyuLFF1+kc+fO1KpVC6vVSoMGDejRowdTpkwhIyMj1CHqVq1axYgRI2jQoAFWq5XatWvTp08fPv300yqNIy8vj2XLljFt2jSGDBlC48aN0TQNTdOYMmVKidsePnyYt956i2HDhnHBBRcQFhZGWFgYTZs25aabbuKHH36oVvFOmTJFL1vSY/fu3SGP1W/RokX079+fevXqYbFYiIiI4KKLLuKOO+5g8+bNQYnT7+TJk3zwwQeMHj2a1q1bExERof8fGjRoEEuXLi1222Aca1XGW5wXXngh4LMghBBCBFNN/56pjO/uc8W5ci9YVWryZ6Gsaux5Q4lzwr59+1STJk0UoAAVHh6urFar/vell16q0tLSQh2mUkqpe+65R48LUDabTUVFRQUsS0xMVKtXrw51qAF++OEHlZSUpMdosVhUbGxsQNybNm0KdZhKKaUeeeSRgLhiY2OV2WzW/x48eLByuVxVEsvKlSsDYin4mDx5crHbHThwQGmaFlA+PDxchYWFBSy77bbblNvtDnm8Sik1efJkBSiz2aySkpKKfezduzfksdrtdtW/f/+AbSIjI5XFYtH/NhgM6rXXXgtKrEopZTKZCv3fj4iICFh2/fXXq9zc3KAeayjiLcqOHTuUzWYL2F4IIYQIFvmeCf5397niXLoXrCo19bNQVjX5vCEtu84Bbreb/v37s2/fPurWrct3331Hbm4ueXl5zJs3j6ioKDZt2sTo0aNDHSoAnTp14uWXX2bNmjWkp6eTn59PVlYW2dnZzJkzh1q1apGamsqgQYPIzMwMdbgA/PLLL9xwww0cO3aMIUOGsG7dOux2O+np6eTm5vLbb7/x+OOPExMTE+pQeeedd3jxxRcBGDlyJAcPHiQ9PZ3s7Gxmz55NREQES5cuZdKkSVUWU1xcHL169eLhhx/m008/pU6dOmfdxuPxoJSiV69ezJkzh8OHD5Obm0tOTg5//vknAwcOBGDWrFlBb9lTnngL6ty5M0ePHi320aRJk5DH+txzz/HFF18AcPfdd3Po0CGys7PJz89n/fr1XH311Xi9Xh588EE2bNgQlFjdbjedOnXirbfeYs+ePeTn55OTk8PevXv55z//CcCyZcsYP358UI81VPEW5PV6ue2227Db7Vx11VWVGrcQQoiaR75nfIL53X2uONfuBatKTfwslFWNP2+EOtsmzu69997Ts7BFtYb65JNP9PXff/99CCIsm+XLl+vxfvzxx6EOR+Xm5qpmzZopQN17772hDqdELpdLb3122WWXKY/HU6jMjBkzFKBMJpPas2dPpcdUVKurxo0bn7VFTkZGhtqwYUOx671er7ruuuv0Fkn5+fnBCLfc8Sp1umVXt27dghLL2VQkVv+vf8XFmpGRoSIjIxWgHn300SBE62sdWZLx48fr//cPHDgQsK4ix1peFYn3TG+88YYC1M0336x/TuQrVgghRLDI94xPML+7zxXn271gsNTEz0JZ1fTzhrTsOgfMmTMHgB49ehSZkR05ciRNmzYF4MMPP6zS2Mrjyiuv1J8fOnQohJH4fPTRR/z999/UqVOHl156KdThlGjDhg0cO3YMgAcffBCDofB/4TvuuIPY2Fjcbjcff/xxpcdkNBrLtV1MTAyXXXZZses1TeO2224DICcnh+3bt5ernjOVN95QqEisKSkpAFx++eVFro+JieHCCy8EfK9vMPTo0aPE9f5f2QDWr18fsC4U70tF4i1o7969PP744yQkJPD6668HLT4hhBAC5HumoGB9d59Lzrd7wWCpiZ+FspDzhgxQX+3l5eXxyy+/AHD99dcXWUbTNK677joAvv322yqLrbxWrVqlP2/evHkII/HxfykMGzYMm80W4mhKtn//fv1569atiyxjNBr1JMa58HkoScH3w+PxhDCSc0+zZs0Aiu2imJmZyc6dO4HiE2LBdq69n6WN94477iA3N5fXXnuNWrVqVUVoQgghahD5nim9c+1a42zOx3vBqnK+fRbKSs4bkuyq9rZv347X6wXg4osvLracf93Ro0er5UyHDoeDffv28d///pcxY8YAcMEFF9C/f/+Qx+XP9Hfo0IEDBw5w55130rBhQywWC0lJSfTv35+vvvoqpHEWpaSTtn/d1q1bqyqcSpGcnAyAxWLRE3jVwZ9//snFF19MeHg4kZGR+uyGmzZtCnVougkTJgC+1/Cee+7h8OHDACil2LhxI/369SMnJ4errrqqysZ48L+fAG3btq2SOiuiNPHOnDmTFStW0Lt3b2655ZYqikwIIURNId8zZXOuXWuczflyLxgK59tnoSzkvOEjya5q7siRI/rz+vXrF1uu4LqC24SazWZD0zRsNhtNmzbl3nvvJT09nS5durBixQqsVmtI49u3b58+Ve/ff//NxRdfzMyZMzl+/DgREREcP36cL7/8kn79+nHHHXeglAppvAUHPi8ukeV0Otm1axfga72Tm5tbFaEF3d69e3n77bcBGDFiBNHR0SGO6LTU1FS2b99OWFgYDoeDnTt38t5779GhQweeeOKJUIcHwD333MOkSZMwGAy89dZbNGjQgKioKGw2Gx06dGD37t08+uijrFixokq6EGZkZPD8888D0LVrVy666KJKr7MiShPv4cOHefjhhwkLC+Odd96p6hCFEEKc5+R7pmzOtWuN0jjX7wVD5Xz8LJSWnDdOk2RXNZedna0/Dw8PL7ZcwXUFtwm1OnXqkJSUREREhL6sR48evPHGGzRq1CiEkfmkp6frz6dNm4bZbGbhwoXk5OSQnp7O/v37GTZsGADvvfdeyPs7X3bZZSQlJQHw4osv4na7C5X5z3/+Q1ZWlv53wefnivz8fIYNG0ZeXh6JiYm88MILoQ4JgBYtWvDSSy/x119/YbfbOXnyJLm5uSxfvpwOHTqglOLZZ5/l1VdfDXWoGAwGnn/+eWbNmkVkZCTgG5vLn9y12+1Vlgz1er2MGTOGlJQUbDYb//3vfyu9zooobbzjx48nMzOTKVOm6N1GhRBCiGCR75nSO9euNUrrXL8XDIXz9bNQWnLeOE2SXaJS7du3j6NHj5KTk8OxY8d45ZVX2Lx5M506deKpp54KdXh6s2D/8/fff5+hQ4diNpsBaNSoEfPmzaN9+/YAPPfcc0UmmKqKyWTSX7ft27fTr18/Nm7ciNPp5OjRo7z88ss89thjevxAkYPYV2dut5tRo0axYcMGzGYzc+fOpV69eqEOC4Cbb76Zhx9+mAsvvFB/jS0WC9dccw0///wzHTt2BGDKlClkZmaGMlRSU1Pp1asX48aN46qrruLnn38mIyODlJQUlixZQq1atZgxYwZXXHGF3sWxstx33318+eWXAEyfPp127dpVan0VVZp4P/74Y7766isuueQSHnjggaoOUQghRDUze/ZsNE0r9+Obb74J2N/58j0T7NelOOfatYaoPDX5s3C+nDeC5dy6C66BoqKi9Od5eXnFliu4ruA21Unt2rV58MEH+eabb9A0jalTp+onolAp+Fq1aNGCQYMGFSpjMBh46KGHADh58mSxA35XlbvvvluPx9+iyGq1UrduXSZNmkSTJk2YNGmSXj4uLi5UoZaZx+Ph5ptv5n//+x8mk4lPPvmEa665JtRhlYrNZuO5554DfC2oVqxYEdJ4xo4dS3JyMt26dWP58uV06dKFmJgY6tSpw+DBg/n5559JTEzk77//5tFHH620OB566CH9F7XXX39dn2GzuipNvMeOHeP+++/HaDQyc+ZMTCZTVYcphBDiPCbfM2Vzrl1rlMX5dC9YFc7nz8LZyHmjMHkFqrmCLVoOHz5cbGa6YMuM6tIKpjidOnXi6quv5qeffuLdd9+lX79+IYulYP/2li1bFluu4MyH+/fv54orrqjUuM7m5ZdfZtCgQbz33nusW7eOrKws6taty4ABA7j//vt56aWXAGjcuDEWiyWksZaWx+Nh9OjRLFiwAKPRyMcff8zQoUNDHVaZFJwO+u+//w5ZHNu3b+frr78G4MEHH0TTtEJlateuzS233MJrr73GkiVL+PDDD4ssVxGTJk3Su3S+8sor3H///UHdf7CVNt5HH32UkydPMmHCBFq2bElOTk7Aen9XUUBfZ7FYzpn/i0IIIcrupptuqtA1bUxMjP78fPqeCebrUpRz7VqjrM7He8HKcr5/Fs7mfDpvBIsku6q5Vq1aYTAY8Hq9bN26tdgpZ/2DldepU4f4+PiqDLFc/Emm3bt3hzSO+Ph46tevf9ZuXAUHpg92QqC8unTpQpcuXYpc559hsnPnzlUZUrn5W3TNnz9fT3SNGDEi1GGds7Zt26Y/b968ebHlWrRoAfh+DTx+/Lg+HlwwPPzww7zyyisAvPTSSzz44INB23dlKEu8e/fuBWDGjBnMmDGjxP36f1297777eOONN4ITrBBCiGrHarUGbeKl8+l7Jpivy5nOtWuN8jhf7wWDrSZ8Fs7mfDpvBIt0Y6zmwsPD9YRGcX3WlVIsX74c4Jzp8uVv9VIdmtn6X7Pt27cXW6Zg8qBp06aVHlNFHDt2jO+//x7gnJhq1uPxMGrUqIBE18iRI0MdVrmsXbtWfx7Kz0nBcdr2799fbLljx47pz/2D2AfDQw89FHDB8fDDDwdt35XhXItXCCGEqOlqynf3+XovGEw15bMgykGJau+9995TgNI0Ta1du7bQ+vnz5ytAAer7778PQYSnud1u5fV6Syzz/fffK03TFKAmTZpURZEV76efftJfv6VLlxZa7/F4VLt27RSg6tevrzweT9UHWUput1sNGjRIAapTp05nfS8qS+PGjRWgJk+eXGI5t9utRowYoQBlMpnUvHnzqibAM5Qm3rO9lna7XV1xxRUKUBERESo9PT24QZ5Smlj37dunf6b79+9fZJmcnBzVrFkzBah27doFLb4HH3xQr/uVV16p0L5K+zmqiGDG6zd58mR9n0IIIUSw1fTvmcr47q7OzqV7wapW0z4LFVETzxs150jPYS6XS7Vt21ZPtvhPYh6PRy1YsEBFR0crQF1//fUhjlSpvXv3qvbt26u3335b7dmzJyBBcODAAfX888+riIgIBaj4+HiVkpISwmhPGzp0qAJUQkKCWrRokXK5XEoppfbv36+GDx+unxhmz54d4kiV2rNnj/rXv/6lNmzYoPLz85VSvs/Czz//rHr27KkAFRsbq7Zt21ZlMaWlpakTJ07oj4YNGypAPfzwwwHLs7Oz9W3cbrcaOXKknuhasGBBtY43OTlZ9erVS3344Yfq4MGD+nKn06m+//571bFjR/1z8uKLL4Y0VqWU6t+/vx7P6NGj1e7du5XX61VOp1P98ssv6vLLL9fXz5kzJyixPvzww/o+X3vttSo71lDFW5yaeDEhhBCi6tTk75nK+u6uzs6le8GqVBM/CxVRE88bNedIz3F79+5VTZo00T+g4eHhymaz6X9feumlKi0tLdRhqr179+oxAcpisajExEQ9weV/NG3aVG3cuDHU4epycnLUP/7xDz0+q9Wq4uLiAmKuzNYlZbFp06aAuOLi4pTZbNb/btSokdqwYUOVxuRvgXO2x9ixY/VtfvzxR3252WxWSUlJJT6C2eqrPPGuXLkyYF1YWJhKTEwMeO0NBoP617/+FbQ4yxurUkqdOHFCdejQIaBMeHi4MplMAcsefvjhoMS5f//+gNfhbO/nyy+/HLRjDVW8xamJFxNCCCGqTk39nqnM7+7q7ly5F6wqNfmzUF418bwhA9SfI5o0acIff/zBK6+8wpIlS9i7dy9ms5k2bdpw0003ce+991aLmRTq1avHwoULSU5O5tdff+XIkSOkpqZiNBpp1KgR7du3Z+DAgYwaNYqwsLBQh6uLiIhg5cqVzJo1i48++oitW7eSnZ1N/fr16dq1K/fee2+1Gey9SZMmPPXUUyQnJ7N7925SU1OJjo6mZcuWDBkyhLvuuovw8PBQh3lWXq9Xf+5yuQLGjypKfn5+ZYdUorZt2/LKK6+wZs0atmzZQmpqKhkZGYSHh9O6dWu6du3KnXfeSdu2bUMap19iYiJr165lzpw5LFy4kM2bN5OWlobJZKJRo0Z07tyZ8ePHc/XVVwelvoLvp9frPev7eeYMMVXtXItXCCGEqOlq8nf3uXIvWFVq8mdBlJ6mVIFp5oQQQgghhBBCCCGEOIfJbIxCCCGEEEIIIYQQ4rwhyS4hhBBCCCGEEEIIcd6QZJcQQgghhBBCCCGEOG9IsksIIYQQQgghhBBCnDck2SWEEEIIIYQQQgghzhuS7BJCCCGEEEIIIYQQ5w1JdgkhhBBCCCGEEEKI84Yku4QQQgghhBBCCCHEeUOSXUIIIYQQQgghhBDivCHJLiGEEEIIIYQQQghx3pBkl6gx9u3bh6ZpaJrGvn37Qh1OpRg3bhyapjFu3LhQh1IpmjRpgqZpzJ49u8rrnjJlCpqm0b179yqvWwghhBBCCFGYXKOL4kiyS1Qqu93OO++8Q79+/WjUqBFhYWHExMTQqlUr7rzzTlauXBnqEEU1MHv2bKZMmUJycnKoQxFCCCGEEAX4kwlnPmw2Gw0aNGDAgAEsWLAApVSoQz2vZGRkMGXKFKZMmUJGRkaowxHinGMKdQDi/PXdd99x2223cejQIX1ZdHQ0DoeDHTt2sGPHDmbOnMn111/PRx99REJCQgijFaE0e/ZsfvzxR4ASf5Vp3rw5NpuNmJiYKorstMTERC666CIaNWpU5XULIYQQQlQHSUlJ+vPMzEwOHz7M4cOH+eKLL5g9ezZLly7FarWGMMLzR0ZGBk8//TTg670RGxsb2oCEOMdIyy5RKebPn0/fvn05dOgQ9evX57333iMtLY3MzEzsdjvbt2/n/vvvx2QysWzZMq688kqOHz8e6rBFNbdixQp27NjB4MGDq7zuiRMnsmPHDj788MMqr1sIIYQQojo4evSo/sjNzWXr1q306dMHgGXLlvHEE0+EOEIhhPCRZJcIuu3bt3Pbbbfhdrtp27YtmzZt4p///CdxcXF6mZYtW/L666/z2WefYbFY2L17N6NGjQph1EIIIYQQQojSMhgMtGnThs8//5wLLrgAgHfeeQe32x3iyIQQQpJdohI88cQT5OXlYbVaWbhwIbVq1Sq2bN++ffVfgFasWMFXX30VsP7MQeX37NnDnXfeSdOmTbFarTRp0iSg/OHDhxk/fjwNGzbEarXSoEEDbr31Vnbv3l2q2J1OJ2+99RY9evQgMTERi8VCnTp1GDhwIMuWLSt2O3+MycnJHD9+nAceeIALL7yQ8PBwNE0rVP6rr77ixhtvpH79+litVuLi4vjHP/7BjBkzcDqdJcY4d+5cunTpQlRUFDExMVxxxRW8++67QRsnYcmSJfTr14+kpCQsFgtJSUn069ePpUuXFrtNwYHxlVK8/fbbdOrUiejoaKKjo7n66qv55JNPCm03e/ZsNE3TuzA+/fTThcaDKDiZQEkD1Bd8D06ePMkDDzxA8+bNCQsLo3HjxkycOJETJ07o5ffv38+ECRNo2rQpNpuNRo0a8eCDD5KdnV3kMRY3+KX/GErzKGpMsqr6zBXnzPfuvffe4+qrryYhISHgtfYf55n/5woqaRKIM7ffsGEDw4cPp27dulitVpo1a8YDDzxAenp6qWMXQgghROjZbDaGDRsGQHZ2Njt27AAgPT2d999/n+HDh9O2bVvi4+Ox2Ww0btyYUaNGsXbt2mL3eeZ11+LFi7nmmmuoXbs2BoOBKVOm6GW3bt3KlClT6Nmzp37tFx0dzaWXXsoTTzxBampqsfUUvLbMy8tjypQptGrVivDwcOrVq8eYMWPYu3evXj41NZVHHnmECy+8kLCwMOrUqcPtt9/OsWPHSnyNsrOzeeGFF7jqqquIj4/HarXSsGFDRo4cyZo1awqV7969O02bNtX/btq0acA1ZVHDfoTqmtLlcpGYmIimafz73/8useysWbPQNI3o6Gjy8vL05UePHuU///kPAwcOpFWrVsTExBAWFsYFF1zA7bffzp9//nnWOIrSvXt3NE0L+LycqTQD3O/bt4/777+fNm3aEBkZSXh4OC1btuS+++7jwIED5YpNVAElRBAdOXJEGQwGBahx48aVapvs7GwVFRWlAHX99dcHrNu7d68CFKDmzp2rIiMjFaDCw8NVRESEaty4sV52w4YNKi4uTi8fFhaml4+Ojlbz58/X1+3du7dQHPv27VNt2rTRy2iapmJiYvS/AXXXXXcVeQz+9TNnzlRJSUkKUDabTT8uv7y8PDV06NCAfUZHRytN0/S/r7zySpWWllaoDq/Xq2699daA+OLi4vTXe+TIkWrs2LEKUGPHji3Va1+Qw+FQI0aM0PdvMBgC9g+om266STmdzkLbFqzXvw//9gWP7dZbb1Ver1ffbt68eSopKUmZzWYFqIiICJWUlBTwOHDggF6+cePGClAffPBBse/BnDlzVIMGDfT9WSwWfV2rVq1Uenq6+u2331RCQoL++ptMJr1Mly5dlNvtLrT/yZMnK0B169YtYLn/GIp7xMbG6vteuXJlwLZV8Zk7G/97d8stt6gbb7yx0Hvvf60/+OADBQT8nztTwf+vZ/4fK7j93Llz9fc8JiYm4DPWpk0blZ2dXer4hRBCCFG5/NdAJV1fTJ8+XS/zyy+/FNrOaDSquLg4ZbVaA6573nzzzRLr7Natm3rggQcCrn2NRqOaPHmyXtZ/fei/FoqPjw+4/qxfv77asWNHkfX4t33jjTdU27Zt9X2EhYXp29etW1ft3btX7dmzRzVt2lS/Fyl4jdmiRQuVmZlZZB2bNm3Sr039r4X/es1/XM8991zANoMHD1aJiYl6mcTExIDry8GDBweUD/U15T333KMAdfnll5dYrnv37kXeJ/qvRwFlMplUfHx8wPW51WpVixYtKnKfxV2jK6VUt27dFBDweSnL9kop9fHHHwd8bq1Wa8DnIyoqSi1fvrzE4xahIckuEVSffPKJ/h//iy++KPV2/pvsyMhI5XK59OUFb54jIyPVFVdcodatW6ev/+uvv5RSSmVlZalGjRopQDVq1Eh9++23elJl9erVqk2bNgFJhzNvxHNyclTLli0VoLp3766Sk5OV3W5XSimVkZGhXnvtNT1x9sYbbxSKv2CMF110kVqxYoXyeDwBMSql1OjRoxWgmjVrpubOnat/Kebn56vPPvtMNWvWTAFq0KBBhep488039XomTpyoTpw4occ3ZcoUpWmafozlSXY9+OCD+pfjk08+qdLT05VSSqWlpal//etfet2PPPJIoW39X1AxMTFK0zQ1depU/diOHz+uJk6cqG9f1EVNab6IlCpdsis2NlZdcsklau3atUoppZxOp/r0009VeHi4/to1btxY9ezZU23dulUp5Xv9//Of/yij0ah/2Z/pbF+ERXE4HPqxNWrUSH/PlKq6z9zZ+N+7yMhIZTKZ1CuvvKK/d9nZ2erIkSNKqeAlu8LDw5XValW33367nsjMzc1V//3vf/UE2JNPPlnq+IUQQghRuUqT7Hr44Yf1Mtu3b1dKKfXOO++oyZMnq/Xr1yuHw6GU8v14+/fff6v77rtPaZqmjEaj2rhxY7F1+q+FHnnkEXX8+HGllFJ2u13t27dPL3vLLbeo2bNnq/379+vLHA6H+v7771WnTp0UoC677LIi4/ZfW8bGxqomTZqob7/9Vnk8HuV2u9W3336ratWqpQA1fPhw1alTJ3XJJZeoNWvWKKV815jz58/XrzEff/zxQvs/cuSIql27tgLUkCFD1Pr16/Ufjo8dO6aefPJJPamzdOnSgG1Luq4qqDpcU/7666+F3v8z7d+/X09C/vDDDwHrpk6dql5++WW1ZcsW/V7Q4/GorVu3qptvvlmB70fsw4cPF9pvZSa7vv32W2UwGJTJZFKTJk1Se/fuVV6vV3m9XrVjxw41bNgwBb4fzwt+/kT1IMkuEVSPP/64fqI7dOhQqbebOnWqvt3u3bv15QVP8o0bNy62xceLL76oAGWxWNS2bdsKrU9JSQlo9XXmF8Yzzzyjn+SKarmklFJLlizRf1kpmJBT6vSXRHR0tDp48GCR2//0008KULVr1w5orVTQwYMHVUREhALUpk2b9OX5+fkqPj5eAWrMmDFFbvvoo4/qcZQ12XXo0CH9i/axxx4rsoz/VzWz2awnQPwK/hpTXKLCn+iLj49X+fn5AeuCmexKSkpSqamphdY/+eSTepk2bdroFwEFjRkzRgGqV69ehdaVJ9nlf12ioqLUH3/8EbCuKj5zZYkRUP/+97+LLResZFdJn0//Z+yCCy4ox5EIIYQQojKcLdmVmZmp6tWrp1/n+RMlZ+NvDfTPf/6zxDofeOCBcseenZ2tt1ZatWpVofX+a8uwsDC1a9euQuvff//9Ul9jNm/evNC62267TQFq1KhRxcb42muvKUC1b98+YHlpk13V5ZryoosuKvFe4rnnntN/AC7Y06M0brjhBgWoqVOnFlpXWckuj8ejWrRooQD1zjvvFLv9gAEDFKDuu+++Uh6NqCoyZpcIqpMnT+rPExISSr1dYmJikfsoaOLEiURGRha5bt68eQAMGzaMVq1aFVpfp04d7rrrrmLrf//99wF44IFVeBDMAAAQy0lEQVQHMJvNRZYZNGgQ0dHRpKamsmHDhiLLjBkzhgYNGpRYx80330zDhg2LLNOgQQN69OgBwPLly/Xl3377LWlpaQA89dRTRW776KOPYrPZilx3NosXL8btdmOz2Xj00UeLLPPEE09gtVpxuVwsWrSoyDJhYWE89NBDRa7zx52WlsZ3331XrjhL44477ijys3fttdfqzx944IEip8X2l/njjz8qHMe0adOYM2cORqORefPm0bZt24D1VfGZK4u4uDjGjx9f4f2URnEzNQ0cOBCA3bt3B4zjIIQQQojqJyMjgxUrVtCzZ0+OHDkCwH333YfBULpbzBtuuAGAn3/+udgyBoOBRx55pNwxRkZG0q1bt7PWc+ONN+qD7BdU8PrxzjvvLPEac8+ePeTm5urL7Xa7PmZtScdwyy23APD777+fdeyvolSXa8oxY8YAvvGFVRFjCX/00UeA716oLOPLQuk+K8H2008/sWvXLhITE7n99tuLLed//wreu4nqwRTqAIQorS5duhS53Ol0smXLFgB69uxZ7PY9e/bk+eefL7T88OHD7N+/H4B//vOfGI3GYveRk5MD+AY3v+KKK0odI8Avv/wC+L6Qihqs3S8zM1Ovw2/9+vUANGzYsMgvYoCYmBg6dOig11MW/v137NiR6OjoIsvExcVx+eWX88svv+jlz3T55ZcXu32LFi1o0KABhw4dYv369fTv37/McZZGp06dilyelJSkP+/YsWOJZSo6SPq8efP05N7rr79O3759A9ZX1WeuLDp27IjFYgnKvkoSHx9f7Ge4Xr16+vP09HTCw8MrPR4hhBBClF5JSYrRo0fz+OOPByz7+++/eeutt1i5ciV79uwhOzsbr9cbUObQoUPF7vOCCy6gdu3aZ43ryy+/5KOPPmLdunUcO3asyB/NSqonGNeP4EsARkREAL7JeOx2OwDXXHPNWY8BfNd7Bfd3NtXpmnLMmDE8+eSTHDhwgB9//DFgwPcNGzawfft24HRy6Ey///4777zzDj///DP79u0jJyenUNKspPcw2Pz3VJmZmQHXqGfyTy5W8N5NVA+S7BJBVfDXjpMnT1K/fv1SbVdwlpTiWoQV90WXlpamT3FcUn3F/VLh/yXqzDhKUlyrk5K+jP31ZGVlkZWVVaY6jh8/DpR8fFD8MZ5NWffvL3+ms21fv359Dh06VOz2wRAVFVXkcpPJVOoyFZkye/Xq1frMhvfccw/33ntvoTJV9Zkri2Dt52yKe+0h8D1yuVxVEY4QQgghyqBgIsZqtZKYmMill17KzTffrPdO8Fu6dCk33XQTDodDXxYdHY3NZkPTNJxOJ+np6QGtoc50tusTr9fL6NGj+fTTT/VlJpOJuLg4/Ue8zMxM7HZ7ifUE4/oRAq9fCl7vlbbFVllbtlena8pGjRrRrVs3kpOT+eijjwKSXf5WXR07dqRly5aFtv3vf//LfffdpydCNU0jJiZG74mRn59PVlZWie9hsPlfW5fLVar3Lz8/v7JDEmUk3RhFULVu3Vp/vnHjxlJvt2nTJsDX1Lhx48ZFlinpl4qK8Hg8+vPt27ejfGPZlfgYN25cmWP01zNjxoxS1TF79uxgHqaoAn///TeDBg3C4XBw7bXX8uabbxZZrqo+c2VRWf+/hBBCCHH+OHr0qP7Yv38/GzZs4L333iuU6Dp58iTjxo3D4XDQs2dPkpOTycvLIzMzk2PHjnH06FEWLlx41vrOdn3y/vvv8+mnn2I0GnnqqafYtWsXDoeDtLQ0Pc6hQ4cCFNm1rjIVvN7Lz88v1fVewQRRWeuoDteU/lZbixYt0pM/brdbT0b6uzoWtH37du6//368Xi/Dhg3jt99+w263k56err+Hr732GlC176H/tb3iiitK9bpW9edLnJ0ku0RQ9ejRQ++nv3jx4lJtk5OTo4/h1LVr14BfR0ojPj5ePzkfPny42HLFratTp47+vDKbn/rrKU8d/l9aSjq+0qw/2/7P1jTYv764X35KG19VtSKqShkZGfTr148TJ07Qpk0bFixYUOxFQ1V95oLJ///S3xy/KP4uuEIIIYSo2b7++muysrKIi4vjiy++oFu3boSFhQWUOXr0aIXr8Y/be/vtt/P0009zwQUXFBozLBj1lEdVXO9Vt2vKoUOHEhYWRlZWFp999hngG3v4+PHjmM1mbrrppkLbLFq0CI/HQ6tWrZg3b16RQ2uU9z2syPVrRe7dRPUgyS4RVHXr1tUHmZ43bx5//fXXWbd5/fXXyc7OBuDuu+8uc50Wi4V27doBsHLlymLL/fDDD0Uub9Kkid797osvvihz/aXl7wf/5Zdflnnbyy+/HICDBw+yZ8+eIstkZWUVO+Bkafe/fv36Yk/4GRkZAWN7FWX9+vX6eABn2r17t54s89fn578oOVd/EXG5XNx4441s376d2rVr8+WXXxY7dhlU3WcumOLi4gBfF9aC3REK+vXXX6syJCGEEEJUUwcPHgTgoosuKnYMzu+//z5o9Vx66aVFrs/JyQnZ9UnBpE15rvcKJu2Ku0aubteUUVFRDBo0CDjdddH/7/XXXx8wKZmf/z1s3759sZMblPez4r9+9ddRlOI+H/57t6NHjxY7XrGo3iTZJYJu6tSphIWF4XA4GDZsWIn9x5ctW8a0adMAX6sw/0wbZTVixAgAFi5cWGSC7fjx47z99tvFbn/HHXcAvqbQ/i6VxfHPilhWd955JwBbt25lxowZJZbNzc3VBzsE6NOnj36ynjp1apHbvPTSS+XuK37jjTdiMpmw2+28+OKLRZZ57rnncDgcmM1mbrzxxiLL5Ofn88orrxS5zv8+x8fH06dPn4B1/sRQRkZGueIPtQkTJvDDDz9gtVr53//+R5MmTc66TVV85oKpffv2gO9ia+nSpYXW5+fn8/rrr1d1WEIIIYSohmJiYgDYuXNnka1qNm/eXOKETWWt5/fffy9y/dSpU/Uf1ataREQEo0aNAuDFF1/kwIEDJZY/83qv4A+nJV0jV7drSn9Xxm+//ZZdu3bpLbyKG5je/x5u2bKlyKTesmXLSE5OLlcs/uvX5cuXFzne1w8//MCaNWuK3LZHjx76pEr/93//F3BvVpTqcL0uAkmySwRdmzZteO+99zAajWzZsoVLL72UWbNmBZykd+7cyQMPPMCAAQNwOp00a9aMTz75pMzT0PpNmDCBBg0a4HA4uO6661ixYoV+svz111/p3bt3oZlfCnrwwQdp27YtdrudHj168N///peTJ0/q6zMyMli2bBm33HILXbt2LVeM3bp149ZbbwXgnnvu4f/+7//4+++/9fUOh4O1a9cyadIkGjduHDCIe1hYGE8++SQAc+bM4f7779fjy8rKYurUqTz33HPExsaWK7b69etz3333AfDCCy8w+f+3d28hTb5xHMC/7uA0Z24ecxYzWlLQwcrGBpFe2NAoUSgPRU1o4IUXHSACSSWMjLwxgjH1Ym1iopReRQTGIFSIKEOoi5BEMuigJZ0s23z+F+FLb9OVlv797//9wHuzPb/n/bH3Gfz27Hnfp7ZWul4TExOorq5GQ0MDgO/bGqemps7aT1xcHOrq6lBfXy8VFmNjYzh+/Dg8Hg8AoLq6GlFRUbK4TZs2Afi+5H2ht2L+WxoaGqQtn91uN6xW62/FLcWY+5tWr16NXbt2Afg+Bnp6eqRnGTx48AC5ubmLuvEAERER/XfYbDYoFAq8ffsWhw8fluq7qakpdHZ2wmazhdy05nfl5eUBAFpaWtDc3CxNSLx8+RInT57EpUuX5tz8ailcuHABBoMBY2NjsFqtaG1tlU2+vXnzBjdu3EBRUVHQLX46nU5ateV2u+fcQGm51ZR79uzBqlWr4Pf7cejQIUxOTkKv12Pfvn2ztp+5ho8fP0ZlZaU0afTp0yc0NTXhwIEDC76GxcXFUCgUGB8fR1lZmXSXyeTkJDweD4qKihAfHz9rrEqlgsvlgkqlQm9vL3bv3o07d+7INiF49uwZXC4Xdu7cCafTuaAcaREJokVy69YtYTAYBADpiIuLE1FRUbLXbDabeP369ax9DA8PS+2Gh4dDnu/+/ftCp9NJ7VesWCG0Wq0AIGJjY0VHR0fIvl68eCEsFovUJiIiQuh0OrFy5UpZviaTKSh25j2fzxcyx69fvwqHwyHrT6vVCr1eLxQKhez10dFRWWwgEBBHjhyR3lcoFEKv1wulUikAiNLSUmG32wUAYbfbQ+YxV27FxcVB/f+YV1lZmZiamgqK/fG8JSUlAoBQKpVCr9eLiIgIKf7o0aMiEAgExT99+lQaFwqFQqSkpAij0SiMRqN4/vy51M5oNAoAwu12B/Xxq2vwO2PJ5/NJbX5WW1srAIjs7GzZ69nZ2bK8Qx19fX2y2KUYc78ynzEzMDAgyy0qKkrExMQIACIlJUXcvHlzzs/Y7XYLAMJoNM7Z/3y+70RERLQ0Zmqg+f50PHPmTNDvALVaLQCItWvXira2tnnXXT979+6d2LBhg6x+1el0Uv1ZUVERstYJVVvO+NMa88mTJyIjI0OWY3x8vFRDzRy5ublBsXV1ddL7Go1GrFmzRhiNRlFSUiJrtxxqyh+dOnVKdt6KioqQ7UtLS2XtdTqd9Btnx44d4sqVK3PWkb8aKzU1NUHjUKVSCQCisLBQnD17NmR8d3e3iI2NleLVarVISEgQGo1G1u/58+fn+SnRYuPKLlo0eXl5GBoagtPpxN69e5GWloYvX75ArVYjIyMDx44dQ09PD27fvo2kpKQ/Pl9WVhYGBwfhcDiQlpYGv9+PuLg42O12PHz4EGazOWS8wWBAb28v2tvbUVBQgNTUVHz+/BlTU1NIT0/H/v370djYiLt37y44x8jISLS0tKC/vx/l5eVYt24dAoEAPn78iOTkZOTk5KCmpgaDg4PSPzkzFAoFvF4vvF4vLBYLoqOj4ff7sX37drhcrj9eCh4ZGYmOjg5cv34d+fn5SEhIwIcPH5CQkID8/Hx0dXXh2rVrUKvVIftpb2+H0+nEtm3b4Pf7ERMTA6vVCq/XC4/HM+u9+OvXr4fP50NBQQGSkpIwPj6OkZERjIyMzPkv1nIzPT2NV69ehTx+Xv68FGPub8rMzMS9e/dQWlqK5ORkTE9PIzExEZWVlXj06JFsN1YiIiL6f7t48SK8Xi/MZjOio6Px7ds3mEwmVFVVYWBgAAaD4Y/PodPp0N/fjxMnTiA9PR1KpRIqlQo5OTlob28P+RiTpbJx40YMDg6iqakJNpsNiYmJeP/+PYQQMJlMOHjwIJqbm9HZ2RkUW1VVhcuXLyMrKwtqtRqjo6MYGRkJemD7cqspf75lca5bGGe0tbWhsbERW7ZsgUajQSAQwObNm1FfX4++vj5otdoF53Lu3Dm0trbCYrEgJiYGgUAAmZmZcLlc6Orq+uUulIWFhRgaGkJtbS3MZjO0Wi0mJiag0WiwdetWOBwOdHd34/Tp0wvOkRZHhBD/0SdCE9GyUV5eDo/HA7vdjqtXr/7b6RAREREREdH/GFd2ERERERERERFR2OBkFxERERERERERhQ1OdhERERERERERUdjgZBcREREREREREYUNPqCeiIiIiIiIiIjCBld2ERERERERERFR2OBkFxERERERERERhQ1OdhERERERERERUdjgZBcREREREREREYUNTnYREREREREREVHY4GQXERERERERERGFDU52ERERERERERFR2OBkFxERERERERERhY1/AD5IXfecj0ifAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "_, axes = plt.subplots(ncols=2, figsize=(12, 6), constrained_layout=True)\n", + "visualize.waterfall(results_pypesto, ax=axes[0])\n", + "visualize.parameters(results_pypesto, ax=axes[1]);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Profiling\n", + "\n", + "Profile likelihood analysis allows to systematically asess parameter uncertainty and identifiability, tracing a maximum profile in the likelihood landscape starting from the optimal parameter value.\n", + "\n", + "### Without pyPESTO\n", + "\n", + "When it comes to profiling, we have the main apparatus already prepared with a working optimizer and our objective function. We still need a wrapper around the objective function as well as the geneal setup for the profiling, which includes selecting startpoints and cutoffs. For the sake of computation time, we will limit the maximum number of steps the scipy optimizer takes to 50." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'x': array([ 4.03440768, 0.83760837, 3.55179682, 1.57898613, -4.87401594,\n", + " 4.33049155, 3.79628273, 1.90990052, 1.02667127]),\n", + " 'x0': array([ 4.03440768, 0.83760837, 3.55179682, 1.57898613, -4.87401594,\n", + " 4.33049155, 3.79628273, 1.90990052, 1.02667127]),\n", + " 'fun': 324.16551565091083,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([ 2.75539723, -3.45625301, -1.74304845, 4.19486719, -4.36152045,\n", + " 3.20102079, 4.1666204 , 4.5071745 , 1.64830203]),\n", + " 'x0': array([ 2.75539723, -3.45625301, -1.74304845, 4.19486719, -4.36152045,\n", + " 3.20102079, 4.1666204 , 4.5071745 , 1.64830203]),\n", + " 'fun': 425.9896608503201,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([-4.51736894, 2.39365053, -0.85230688, 2.93845516, 3.92387757,\n", + " 3.35653866, 4.52675063, 1.98365382, 3.80369101]),\n", + " 'x0': array([-4.51736894, 2.39365053, -0.85230688, 2.93845516, 3.92387757,\n", + " 3.35653866, 4.52675063, 1.98365382, 3.80369101]),\n", + " 'fun': 426.9335166325137,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([-1.88273814, -0.60977486, 2.87775688, 2.25140401, -2.65489216,\n", + " 1.01047951, 3.69127283, 4.44893301, 2.65440911]),\n", + " 'x0': array([-1.88273814, -0.60977486, 2.87775688, 2.25140401, -2.65489216,\n", + " 1.01047951, 3.69127283, 4.44893301, 2.65440911]),\n", + " 'fun': 441.8147467190984,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([-1.17029265, 3.16644483, 4.85261058, 4.35300099, 1.26174191,\n", + " 0.82811007, 4.66370112, 3.96059639, 3.24314499]),\n", + " 'x0': array([-1.17029265, 3.16644483, 4.85261058, 4.35300099, 1.26174191,\n", + " 0.82811007, 4.66370112, 3.96059639, 3.24314499]),\n", + " 'fun': 481.3231591295339,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([0.66867122, 3.97870907, 2.13991535, 0.2612146 , 4.9597103 ,\n", + " 3.23568699, 4.22366861, 0.40266923, 3.15201217]),\n", + " 'x0': array([0.66867122, 3.97870907, 2.13991535, 0.2612146 , 4.9597103 ,\n", + " 3.23568699, 4.22366861, 0.40266923, 3.15201217]),\n", + " 'fun': 4453.420140298416,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([-2.01253459, -2.8480651 , 3.12268386, 1.19351138, -0.60901754,\n", + " 0.29935873, 3.43245553, 4.09645236, -0.05881582]),\n", + " 'x0': array([-2.01253459, -2.8480651 , 3.12268386, 1.19351138, -0.60901754,\n", + " 0.29935873, 3.43245553, 4.09645236, -0.05881582]),\n", + " 'fun': 4468.484751390617,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([-0.53682615, -4.81637178, 4.95364701, -4.57752447, -0.60577667,\n", + " -2.88604054, 0.85270085, 0.07054205, -1.27549967]),\n", + " 'x0': array([-0.53682615, -4.81637178, 4.95364701, -4.57752447, -0.60577667,\n", + " -2.88604054, 0.85270085, 0.07054205, -1.27549967]),\n", + " 'fun': 1146659.4928225973,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([ 2.69036786, -1.85327759, 2.85858288, 4.70288006, 4.02501682,\n", + " -4.23172439, -0.72188414, 3.55067703, 4.87046828]),\n", + " 'x0': array([ 2.69036786, -1.85327759, 2.85858288, 4.70288006, 4.02501682,\n", + " -4.23172439, -0.72188414, 3.55067703, 4.87046828]),\n", + " 'fun': 1236788.617249787,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([-2.69338089, 1.3336723 , 4.00935726, 4.23436455, -4.97880599,\n", + " 0.66011236, -0.92734049, -0.72506365, -1.95148656]),\n", + " 'x0': array([-2.69338089, 1.3336723 , 4.00935726, 4.23436455, -4.97880599,\n", + " 0.66011236, -0.92734049, -0.72506365, -1.95148656]),\n", + " 'fun': 29198157.935426034,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([ 2.20258998, 4.3092804 , -2.2015135 , -1.86005028, 4.82608847,\n", + " 2.24886943, -1.09100022, -1.53563431, 0.22579574]),\n", + " 'x0': array([ 2.20258998, 4.3092804 , -2.2015135 , -1.86005028, 4.82608847,\n", + " 2.24886943, -1.09100022, -1.53563431, 0.22579574]),\n", + " 'fun': 37797579.29678398,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([ 3.59031468, -0.64508741, 4.57795683, -4.55808472, 1.45169025,\n", + " 0.16191615, -0.9214029 , 1.8818166 , -2.04635126]),\n", + " 'x0': array([ 3.59031468, -0.64508741, 4.57795683, -4.55808472, 1.45169025,\n", + " 0.16191615, -0.9214029 , 1.8818166 , -2.04635126]),\n", + " 'fun': 42320078.18806582,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([-0.13272644, -1.78655792, -2.05292081, 4.94102789, 0.68000657,\n", + " -0.41145952, 4.43118647, 2.86292729, -2.27641822]),\n", + " 'x0': array([-0.13272644, -1.78655792, -2.05292081, 4.94102789, 0.68000657,\n", + " -0.41145952, 4.43118647, 2.86292729, -2.27641822]),\n", + " 'fun': 113150729.31030881,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([-3.69691906, -1.11149925, -2.07266599, -1.6551983 , -1.05891694,\n", + " 0.25590375, 0.87136513, -1.83339326, -2.29220816]),\n", + " 'x0': array([-3.69691906, -1.11149925, -2.07266599, -1.6551983 , -1.05891694,\n", + " 0.25590375, 0.87136513, -1.83339326, -2.29220816]),\n", + " 'fun': 243163763.80728397,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([-4.85782185, 0.88722054, 3.46323867, -0.42272524, 2.97501061,\n", + " -0.44685985, -1.9617645 , 4.19526924, -0.68191772]),\n", + " 'x0': array([-4.85782185, 0.88722054, 3.46323867, -0.42272524, 2.97501061,\n", + " -0.44685985, -1.9617645 , 4.19526924, -0.68191772]),\n", + " 'fun': 373210706.087737,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([-4.72537584, -3.8267521 , 0.17032373, 0.5309411 , 1.82691101,\n", + " -0.13738387, -2.19222726, 2.40671846, -2.17865902]),\n", + " 'x0': array([-4.72537584, -3.8267521 , 0.17032373, 0.5309411 , 1.82691101,\n", + " -0.13738387, -2.19222726, 2.40671846, -2.17865902]),\n", + " 'fun': 1150653011.8393009,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([-1.21935294, 4.99254589, -3.5227032 , -4.57026229, -4.27577682,\n", + " 1.65134668, -2.57941689, 3.3876373 , -3.08581727]),\n", + " 'x0': array([-1.21935294, 4.99254589, -3.5227032 , -4.57026229, -4.27577682,\n", + " 1.65134668, -2.57941689, 3.3876373 , -3.08581727]),\n", + " 'fun': 9986849980.33512,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([-2.59120601, 0.69656874, -3.88289712, -1.74846428, -1.58175173,\n", + " 3.39830011, 0.0917892 , -0.85030875, -3.77417568]),\n", + " 'x0': array([-2.59120601, 0.69656874, -3.88289712, -1.74846428, -1.58175173,\n", + " 3.39830011, 0.0917892 , -0.85030875, -3.77417568]),\n", + " 'fun': 36260050961.21613,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([ 2.10705352, -4.17386158, -4.95145244, -0.4940422 , 2.44773506,\n", + " -0.72754709, -3.38821849, 4.3015123 , -4.03270095]),\n", + " 'x0': array([ 2.10705352, -4.17386158, -4.95145244, -0.4940422 , 2.44773506,\n", + " -0.72754709, -3.38821849, 4.3015123 , -4.03270095]),\n", + " 'fun': 634294830118.3749,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([ 1.5071923 , 3.23408298, 4.40175342, -4.93504248, -3.68651524,\n", + " 4.89047865, -3.50203955, -3.98810331, -0.60343463]),\n", + " 'x0': array([ 1.5071923 , 3.23408298, 4.40175342, -4.93504248, -3.68651524,\n", + " 4.89047865, -3.50203955, -3.98810331, -0.60343463]),\n", + " 'fun': 2170773400755.13,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([ 4.59360518, -1.45672536, 2.53472283, 1.59953602, 4.74752881,\n", + " 2.97708352, -1.75879731, 1.52861569, -4.47452224]),\n", + " 'x0': array([ 4.59360518, -1.45672536, 2.53472283, 1.59953602, 4.74752881,\n", + " 2.97708352, -1.75879731, 1.52861569, -4.47452224]),\n", + " 'fun': 2817631865279.2437,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([ 2.45781935, 1.53870162, -0.24553228, 1.49870916, -3.42788561,\n", + " 4.98603203, 3.19947195, -4.22036418, 0.83316028]),\n", + " 'x0': array([ 2.45781935, 1.53870162, -0.24553228, 1.49870916, -3.42788561,\n", + " 4.98603203, 3.19947195, -4.22036418, 0.83316028]),\n", + " 'fun': 7147839056555.6,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([ 1.11811741, -1.66877199, 4.78163474, 3.63123695, -4.84414353,\n", + " -4.69389636, -4.22521978, 1.05436896, 1.66464083]),\n", + " 'x0': array([ 1.11811741, -1.66877199, 4.78163474, 3.63123695, -4.84414353,\n", + " -4.69389636, -4.22521978, 1.05436896, 1.66464083]),\n", + " 'fun': 12556009991670.39,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([ 2.78765335, -3.97396464, 3.98103304, 4.06162031, -4.66533684,\n", + " -3.28137522, 3.15208208, -2.66502967, -4.85197795]),\n", + " 'x0': array([ 2.78765335, -3.97396464, 3.98103304, 4.06162031, -4.66533684,\n", + " -3.28137522, 3.15208208, -2.66502967, -4.85197795]),\n", + " 'fun': 16029712077044.059,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1},\n", + " {'x': array([ 2.62294851, -3.86768587, 4.24057642, 0.67648706, 4.94028248,\n", + " -4.53014752, -4.41436998, 0.48069498, 2.08662195]),\n", + " 'x0': array([ 2.62294851, -3.86768587, 4.24057642, 0.67648706, 4.94028248,\n", + " -4.53014752, -4.41436998, 0.48069498, 2.08662195]),\n", + " 'fun': 30002126964787.39,\n", + " 'message': 'Finished Successfully.',\n", + " 'exitflag': 1}]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# sort the results\n", + "results_sorted = sorted(results, key=lambda a: a[\"fun\"])\n", + "results_sorted" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-5. , -2.2098163 , -1.78589671, 3.55917603, 4.19771074,\n", + " 0.58569077, 0.81885971, 0.49858833])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results_pypesto.optimize_result[0][\"x\"][problem.x_free_indices][1:]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "direction: -1\n", + "direction: 1\n" + ] + } + ], + "source": [ + "# we optimimize the first parameter\n", + "# x_start = results_sorted[0][\"x\"][1:]\n", + "# x_fixed = results_sorted[0][\"x\"][0]\n", + "\n", + "x_start = results_pypesto.optimize_result[0][\"x\"][problem.x_free_indices][1:]\n", + "x_fixed = results_pypesto.optimize_result[0][\"x\"][problem.x_free_indices][0]\n", + "fval_min = results_pypesto.optimize_result[0][\"fval\"]\n", + "\n", + "# determine stepsize, ratios\n", + "stepsize = 0.05\n", + "ratio_min = 0.145\n", + "x_profile = [results_pypesto.optimize_result[0][\"x\"][problem.x_free_indices]]\n", + "fval_profile = [results_pypesto.optimize_result[0][\"fval\"]]\n", + "\n", + "# set up for nlopt optimizer\n", + "opt = nlopt.opt(\n", + " nlopt.LD_LBFGS, len(parameters) - 1\n", + ") # only one of many possible options\n", + "\n", + "opt.set_lower_bounds(lb[:-1])\n", + "opt.set_upper_bounds(ub[:-1])\n", + "\n", + "\n", + "for direction, bound in zip([-1, 1], (-5, 3)): # profile in both directions\n", + " print(f\"direction: {direction}\")\n", + " x0_curr = x_fixed\n", + " x_rest = x_start\n", + " run = True\n", + " while direction * (x0_curr - bound) < 0 and run:\n", + " x0_curr += stepsize * direction\n", + "\n", + " # define objective for fixed parameter\n", + " def fix_obj(x: np.ndarray):\n", + " x = np.insert(x, 0, x0_curr)\n", + " return obj(x)\n", + "\n", + " # define nlopt objective\n", + " def nlopt_objective(x, grad):\n", + " \"\"\"We need a wrapper function of the kind f(x,grad) for nlopt.\"\"\"\n", + " r = fix_obj(x)\n", + " return r\n", + "\n", + " opt.set_min_objective(nlopt_objective)\n", + " result = opt.optimize(x_rest)\n", + "\n", + " # update profiles\n", + " if direction == 1:\n", + " x_profile.append(np.insert(result, 0, x0_curr))\n", + " fval_profile.append(opt.last_optimum_value())\n", + " if np.exp(fval_min - fval_profile[-1]) <= ratio_min:\n", + " run = False\n", + " if direction == -1:\n", + " x_profile.insert(0, np.insert(result, 0, x0_curr))\n", + " fval_profile.insert(0, opt.last_optimum_value())\n", + " if np.exp(fval_min - fval_profile[0]) <= ratio_min:\n", + " run = False\n", + " x_rest = result" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(\n", + " [x[0] for x in x_profile], np.exp(np.min(fval_profile) - fval_profile)\n", + ");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is a very basic implementation that still lacks a few things:\n", + "* If we want to profile all parameters, we will want to **parallelize** this to save time.\n", + "* We chose a very unflexible stepsize, in general we would want to be able to automatically **adjust the stepsize** during each profile calculation.\n", + "* As this approach requires (multiple) optimizations under the hood, the things discussed in the last step also apply here mostly." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### With pyPESTO\n", + "\n", + "pyPESTO takes care of those things and integrates the profiling directly into the Result object" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Engine will use up to 8 processes (= CPU count).\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:13<00:00, 13.82s/it]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result_pypesto = profile.parameter_profile(\n", + " problem=problem,\n", + " result=results_pypesto,\n", + " optimizer=optimize.ScipyOptimizer(),\n", + " engine=pypesto.engine.MultiProcessEngine(),\n", + " profile_index=[0],\n", + ")\n", + "\n", + "visualize.profiles(result_pypesto);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Sampling\n", + "\n", + "pyPESTO also supports Bayesian sampling methods. These are used to retrieve posterior distributions and measure uncertainty globally.\n", + "\n", + "### Without pyPESTO\n", + "\n", + "While there are many available sampling methods, setting them up for a more complex objective function can be time intensive, and comparing different ones even more so." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "State([[-1.24027462 1.78932702 -3.93716867 -1.83911125 -1.99677746 4.14486841\n", + " 1.47913514 2.0021859 1.35932731]\n", + " [-1.47022978 1.7611698 4.98482712 0.85855303 -4.1989386 -4.3008923\n", + " 1.8615283 1.95714177 1.35676185]\n", + " [-0.41107448 -0.14952555 -1.77644606 4.16117419 -4.81759753 4.76263479\n", + " 1.60195281 1.74819962 1.4403907 ]\n", + " [-1.43602926 2.50778511 -2.30100058 -2.81499186 -4.86002175 3.36625301\n", + " 1.68878632 1.88056349 1.14940453]\n", + " [-1.22391434 1.81872122 -4.926788 -1.83840725 -1.59900807 4.96243857\n", + " 1.52924675 2.06366179 1.22987441]\n", + " [ 3.17131352 2.57330524 -1.1846534 -1.70751361 -2.87054037 0.42192922\n", + " 1.73901292 1.86776607 1.410648 ]\n", + " [-1.48461283 2.07931539 -3.32203888 -2.5926305 -2.01782331 4.26739815\n", + " 2.0839329 1.8225061 1.03565239]\n", + " [-1.93277149 -0.53931518 -1.76408703 4.33144966 4.79263617 -0.9410984\n", + " 1.80687188 1.61994219 1.35782666]\n", + " [ 0.10231878 3.61432235 -3.84512502 -4.9434848 -1.90631217 4.65431699\n", + " 2.07729333 1.65028872 1.19654252]\n", + " [ 4.50592151 -2.55538837 -1.16047637 4.24362302 4.53497182 1.87264848\n", + " 1.88624933 1.70845149 1.22235004]\n", + " [ 4.72615409 3.13268638 -1.56100893 -4.8662477 2.02282208 -3.87082935\n", + " 1.71348793 1.81644395 1.27623322]\n", + " [ 2.78834613 0.85239735 -0.21509618 2.03024593 -3.91778162 4.8823026\n", + " 1.7798872 1.89429546 1.29492976]\n", + " [-0.32634656 3.31840234 -1.24790645 -4.29790084 -4.71308262 3.9882119\n", + " 1.67219851 1.8025746 1.33922103]\n", + " [-0.08441014 1.99504729 -4.3086613 -2.44371181 -1.08546383 4.95857931\n", + " 1.58357273 2.03714516 1.29240578]\n", + " [-0.10478905 2.40772042 -4.44534855 -3.06426882 -0.89430395 4.15788078\n", + " 1.71021755 2.11709698 1.23181781]\n", + " [ 0.61026717 3.16617924 -3.2045833 -3.67833471 -2.67609702 4.98107667\n", + " 1.64134768 2.04945557 1.06515929]\n", + " [ 4.80721281 -0.14817726 -3.47387807 0.65699343 2.30248275 2.93320564\n", + " 1.94145041 1.85902189 1.20024436]\n", + " [-0.30164889 0.26109268 -1.84307512 3.18671824 -3.29807383 4.68070785\n", + " 1.74777087 1.80071269 1.29463877]], log_prob=[-225.64207758 -252.53559047 -229.04464792 -225.0066885 -226.23100939\n", + " -253.38487017 -229.64580756 -252.46891095 -229.74162106 -250.5537262\n", + " -252.83686794 -251.71454896 -226.72542441 -228.79079296 -237.22532707\n", + " -227.92871341 -251.80959409 -232.78825374], blobs=None, random_state=('MT19937', array([2206932849, 687533236, 392309260, 3170464034, 53645069,\n", + " 3010884295, 1924462243, 1739011224, 1215225621, 290578729,\n", + " 3346691071, 1848570829, 23027121, 456591643, 3025351839,\n", + " 44139322, 3859461820, 3384285855, 1545011441, 2880274270,\n", + " 1612523433, 348209045, 2395282107, 139706992, 2541325984,\n", + " 361020130, 1683022293, 3472867620, 989676495, 1333052438,\n", + " 261248819, 846013908, 363225567, 1078525269, 3382521778,\n", + " 1987817078, 1431689355, 919377321, 640858636, 1080089014,\n", + " 3234408472, 2099893506, 3873028967, 1835169171, 806641627,\n", + " 3825290061, 2135782189, 2804364627, 1288904372, 532697971,\n", + " 1285750807, 3181725207, 1937910098, 3735350617, 877929555,\n", + " 794118818, 531193134, 2968996371, 2235534554, 1078546710,\n", + " 1699481864, 16632259, 2038009533, 4124018018, 1654549904,\n", + " 1839175806, 281104275, 3001893995, 3549514596, 572512883,\n", + " 775895305, 2476554611, 1078562900, 477044261, 3332147477,\n", + " 1790764712, 1220166955, 1835496428, 2754893033, 1269592747,\n", + " 1030059335, 2361857228, 3976443209, 3069245420, 2891322212,\n", + " 777908704, 1732733343, 3104821860, 846811797, 2485970223,\n", + " 717890732, 3822556252, 4038352219, 1021866056, 782933989,\n", + " 3607286638, 2876106162, 1844124260, 1289090079, 771261560,\n", + " 1552270256, 1354994831, 3061800544, 2727263367, 3030113580,\n", + " 2186079388, 539503901, 877058179, 3425099351, 2714112648,\n", + " 584347502, 448943255, 481046113, 2494146037, 1959281397,\n", + " 2997223436, 580854431, 901139350, 4073689258, 2403752855,\n", + " 1273639913, 17097930, 1189258404, 1129946182, 3861197036,\n", + " 1187616964, 3950619282, 2894123197, 3052892285, 1794601679,\n", + " 3107229605, 1154736540, 1445112066, 1281647315, 3823808737,\n", + " 2464923304, 3066806796, 911645021, 3321406851, 2506397230,\n", + " 3224207588, 34403862, 4121992940, 125096971, 3733411609,\n", + " 2433840407, 1211748718, 692955217, 3920121066, 3170374543,\n", + " 963071047, 2240583049, 2557131029, 2215007747, 1682863338,\n", + " 1829007553, 188935160, 4233449025, 1142368962, 4126532027,\n", + " 1540531607, 3427751919, 1553010111, 2479983119, 3408252102,\n", + " 2263816213, 331359825, 3633921403, 3759892034, 292106085,\n", + " 1864810289, 1140673266, 2800793353, 2838103537, 396634619,\n", + " 2380262092, 558090601, 3954852938, 2356468210, 854842063,\n", + " 3987873003, 1413040425, 1717097406, 2845933124, 200449670,\n", + " 697004378, 2330358332, 913572043, 727824675, 2521505152,\n", + " 3756628260, 1304545993, 237809106, 2921467337, 3517022909,\n", + " 2809328755, 1400146847, 2513699124, 366244197, 2865045532,\n", + " 185705230, 2728436123, 1264754284, 377298617, 2139695975,\n", + " 2167647175, 223358529, 3465282111, 1175303169, 3186216422,\n", + " 3649327174, 41779725, 1271572271, 1509599366, 3834341205,\n", + " 776192713, 2664384316, 2403609316, 3263681045, 3055346811,\n", + " 119641578, 1236369036, 1658776216, 2518401352, 4226029546,\n", + " 3148558757, 2569699277, 2866355296, 2156478906, 1404501902,\n", + " 2259574338, 2099399259, 1361291934, 3002098967, 1676689722,\n", + " 802343793, 2988447027, 4257587183, 1160559483, 4259810484,\n", + " 26038768, 3634335801, 3081765329, 2625613137, 3151957490,\n", + " 925383249, 525896746, 2564842755, 2264351719, 1664592786,\n", + " 4270323838, 3033360425, 754685161, 2610981497, 4055010380,\n", + " 939595199, 551357476, 3155657354, 1972748719, 197478011,\n", + " 2898800626, 1689855652, 953799410, 585253348, 375694973,\n", + " 1377335697, 2538595639, 2825497566, 1340999129, 831526576,\n", + " 3017026296, 1486493792, 3366584623, 57393291, 2269395590,\n", + " 851853425, 1288518763, 249497874, 326769358, 1621412413,\n", + " 478423386, 4228785772, 3199093009, 2834245505, 3430966499,\n", + " 3276897556, 17435474, 3402869961, 2647167094, 1896074115,\n", + " 3830180145, 1079813803, 1492462393, 1934793483, 2199874291,\n", + " 3105650711, 2135627634, 2313133474, 1975487203, 1890372153,\n", + " 4112771771, 1009532521, 4071594554, 3150015758, 4198705016,\n", + " 3926942927, 1307590463, 2199556149, 1191234777, 3507715113,\n", + " 2175050552, 3877421719, 1129190928, 2107289827, 3479211066,\n", + " 2448609618, 804432187, 1598435854, 3338802337, 1787761744,\n", + " 1428721688, 3471720360, 2655347578, 3314264648, 3027267759,\n", + " 2007712732, 3733317522, 4012993888, 3517787824, 551121758,\n", + " 2049597321, 3456036022, 3415694232, 3759659216, 2509150560,\n", + " 2767078802, 171594234, 3992175113, 283686696, 4132055111,\n", + " 1994172934, 3077263724, 2389273218, 1682293509, 1448618303,\n", + " 3795182571, 3684132545, 1622325522, 3459644093, 2428584405,\n", + " 415654718, 421558721, 1903663875, 3716389580, 3419812698,\n", + " 3617346627, 1591072231, 2762520964, 116836745, 3639259734,\n", + " 1005442451, 1461831630, 867361387, 1942784541, 1142795005,\n", + " 1525588494, 1321625262, 162610824, 4008904733, 1776666739,\n", + " 873008342, 3840442180, 2973938450, 4265481404, 4283339674,\n", + " 2273252972, 71877482, 1390256942, 3544503825, 425620956,\n", + " 3851338020, 2957518941, 445243979, 1074579722, 2688962277,\n", + " 4273255105, 1546547539, 4024051829, 3945648095, 229231550,\n", + " 595803490, 3758182796, 2169358100, 3500261562, 4192015134,\n", + " 2183314072, 1545238201, 3103643224, 3841556466, 3855483966,\n", + " 1662567278, 3143839091, 808076356, 480190800, 2688847279,\n", + " 3994938844, 925302366, 2500422343, 610881158, 1984695872,\n", + " 3101566415, 3452810700, 4264390600, 1896509376, 2705432340,\n", + " 737630594, 843491200, 3532758010, 1025149261, 1657901107,\n", + " 3198420133, 3883637990, 2870068863, 2458990462, 3855620477,\n", + " 4085561001, 2402086898, 3598591303, 3550267891, 3130649350,\n", + " 811095721, 3994393403, 4237031623, 4083059107, 3051463399,\n", + " 3574114492, 3489500082, 1078191029, 1011531782, 3665502319,\n", + " 2506534754, 3377378812, 4091943684, 3385579500, 873609207,\n", + " 2952279524, 1124109539, 2561046657, 1209401355, 652418891,\n", + " 146960807, 2284822124, 70957741, 218064618, 353348997,\n", + " 193324864, 346234800, 2222422197, 907424622, 3028157175,\n", + " 3359071299, 326033693, 1308837373, 3853624073, 941872757,\n", + " 1348026446, 401040482, 1878332630, 2032502345, 3465082472,\n", + " 620100896, 3561419166, 494354990, 238926942, 3590224542,\n", + " 3575718072, 2671530629, 2301328592, 3229986077, 292475316,\n", + " 1970818708, 3723688063, 3273180879, 1219909701, 3669876766,\n", + " 3726886119, 4035180072, 3342544030, 4229704504, 2954320999,\n", + " 3660720816, 3963744058, 4088207964, 787636590, 1028989741,\n", + " 3551773942, 3067705925, 1879440107, 2690101453, 1476966661,\n", + " 1164988387, 567866675, 4223115538, 2801780003, 784163621,\n", + " 3001146061, 47857172, 3826349248, 591270366, 1038637042,\n", + " 2849851035, 2179802647, 2327748806, 803249147, 1437242643,\n", + " 2668896084, 887003105, 131613121, 1216052268, 1414385990,\n", + " 2639415044, 2951259651, 744354232, 2078830196, 2862706838,\n", + " 3251688536, 3902545329, 3578883028, 843511480, 2008248639,\n", + " 3610132004, 622281062, 3765494681, 593697613, 1024899973,\n", + " 2150321665, 3572264842, 3718275156, 3339033624, 789397804,\n", + " 455982697, 195867210, 832452258, 1590638004, 2841209280,\n", + " 1250620031, 4231398546, 2538639652, 1651308686, 4233459872,\n", + " 3251288337, 1530737085, 2508960905, 819142661, 2454195021,\n", + " 1499019860, 316344890, 1411618432, 1346866985, 2082162230,\n", + " 1861144179, 3200584504, 1713787377, 180706102, 1331333666,\n", + " 1253441295, 685235807, 1697835523, 3989857807, 2558228675,\n", + " 828902009, 1580370495, 2751730402, 2538134001, 1555804373,\n", + " 231859026, 818685043, 1092546692, 3623429586, 3779756715,\n", + " 4050788987, 796440633, 1710608815, 2296686361, 3037349092,\n", + " 1169055388, 3595308497, 268610246, 3144126922, 305091101,\n", + " 3004394692, 4235572670, 141994113, 1728717716, 1992324897,\n", + " 3387776119, 519323380, 4203830862, 2836686724, 1390785037,\n", + " 4054831231, 3030165607, 916606003, 3053193754, 4131727760,\n", + " 1575646449, 878167720, 38027722, 1743581095, 2239841900,\n", + " 3572764997, 55813195, 3787178673, 3949825982, 2088303512,\n", + " 3672572846, 2002937565, 1152259001, 2024262702, 3512380730,\n", + " 1978640799, 689801872, 1484426853, 2228701662], dtype=uint32), 379, 0, 0.0))" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import emcee\n", + "\n", + "n_samples = 500\n", + "\n", + "\n", + "# set up the sampler\n", + "# rewrite nll to llh\n", + "def log_prob(x):\n", + " \"\"\"Log-probability density function.\"\"\"\n", + " # check if parameter lies within bounds\n", + " if any(x < lb) or any(x > ub):\n", + " return -np.inf\n", + " # invert sign\n", + " return -1.0 * obj(x)\n", + "\n", + "\n", + "# def a function to get multiple startpoints for walkers\n", + "def get_epsilon_ball_initial_state(\n", + " center: np.ndarray,\n", + " lb: np.ndarray,\n", + " ub: np.ndarray,\n", + " nwalkers: int = 20,\n", + " epsilon: float = 1e-3,\n", + "):\n", + " \"\"\"Get walker initial positions as samples from an epsilon ball.\n", + "\n", + " The ball is scaled in each direction according to the magnitude of the\n", + " center in that direction.\n", + "\n", + " It is assumed that, because vectors are generated near a good point,\n", + " all generated vectors are evaluable, so evaluability is not checked.\n", + "\n", + " Points that are generated outside the problem bounds will get shifted\n", + " to lie on the edge of the problem bounds.\n", + "\n", + " Parameters\n", + " ----------\n", + " center:\n", + " The center of the epsilon ball. The dimension should match the full\n", + " dimension of the pyPESTO problem. This will be returned as the\n", + " first position.\n", + " lb, ub:\n", + " Upper and lower bounds of the objective.\n", + " nwalkers:\n", + " Number of emcee walkers.\n", + " epsilon:\n", + " The relative radius of the ball. e.g., if `epsilon=0.5`\n", + " and the center of the first dimension is at 100, then the upper\n", + " and lower bounds of the epsilon ball in the first dimension will\n", + " be 150 and 50, respectively.\n", + " \"\"\"\n", + " # Epsilon ball\n", + " lb = center * (1 - epsilon)\n", + " ub = center * (1 + epsilon)\n", + "\n", + " # Sample initial positions\n", + " dim = lb.size\n", + " lb = lb.reshape((1, -1))\n", + " ub = ub.reshape((1, -1))\n", + "\n", + " # create uniform points in [0, 1]\n", + " xs = np.random.random((nwalkers - 1, dim))\n", + "\n", + " # re-scale\n", + " xs = xs * (ub - lb) + lb\n", + "\n", + " initial_state_after_first = xs\n", + "\n", + " # Include `center` in initial positions\n", + " initial_state = np.row_stack(\n", + " (\n", + " center,\n", + " initial_state_after_first,\n", + " )\n", + " )\n", + "\n", + " return initial_state\n", + "\n", + "\n", + "sampler = emcee.EnsembleSampler(\n", + " nwalkers=18, ndim=len(ub), log_prob_fn=log_prob\n", + ")\n", + "sampler.run_mcmc(\n", + " initial_state=get_epsilon_ball_initial_state(\n", + " results_sorted[0][\"x\"], lb, ub, 18\n", + " ),\n", + " nsteps=n_samples,\n", + " skip_initial_state_check=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "trace_x = np.array([sampler.get_chain(flat=True)])\n", + "trace_neglogpost = np.array([-sampler.get_log_prob(flat=True)])" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(\n", + " trace_neglogpost.reshape(\n", + " 9000,\n", + " ),\n", + " \"o\",\n", + " alpha=0.05,\n", + ")\n", + "plt.ylim([240, 300]);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### With pyPESTO\n", + "\n", + "pyPESTO supports a number of samplers and unifies their usage, making a change of sampler comparatively easy. Instead of the below `sample.AdaptiveMetropolisSampler`, try e.g. also a `sample.EmceeSampler` (like above) or a `sample.AdaptiveParallelTemperingSampler`. It also unifies the result object to a certain extent to allow visualizations across samplers." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:03<00:00, 311.04it/s]\n", + "Elapsed time: 3.9380469999998695\n" + ] + } + ], + "source": [ + "# Sampling\n", + "sampler = sample.AdaptiveMetropolisSampler()\n", + "result_pypesto = sample.sample(\n", + " problem=problem,\n", + " sampler=sampler,\n", + " n_samples=1000,\n", + " result=result_pypesto,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot objective function trace\n", + "visualize.sampling_fval_traces(result_pypesto);" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize.sampling_1d_marginals(result_pypesto);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Storage\n", + "\n", + "As the analysis itself is time consuming, it is neccesary to save the results for later usage. In this case it becomes even more apparent why one needs a **unified result object**, as otherwise saving will have to be adjusted each time one changes optimizer/sampler/profile startopint or other commonly changed things, or use an unsafe format such as pickling.\n", + "\n", + "pyPESTO offers a unified result object and a very easy to use saving/loading-scheme:" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "import tempfile\n", + "\n", + "# create temporary file\n", + "fn = tempfile.mktemp(\".h5\")\n", + "\n", + "# write result with write_result function.\n", + "# Choose which parts of the result object to save with\n", + "# corresponding booleans.\n", + "store.write_result(\n", + " result=result_pypesto,\n", + " filename=fn,\n", + " problem=True,\n", + " optimize=True,\n", + " sample=True,\n", + " profile=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: You are loading a problem.\n", + "This problem is not to be used without a separately created objective.\n" + ] + } + ], + "source": [ + "# Read result\n", + "result2 = store.read_result(fn, problem=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot profiles\n", + "visualize.sampling_1d_marginals(result2);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This concludes our brief rundown of a typical pyPESTO workflow and manual alternatives. In addition to what was shown here, pyPESTO provides a lot more functionality, including but not limited to visualization routines, diagnostics, model selection and hierarchical optimization. For further information, see the other example notebooks and the API documentation." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 46992b73750decbb548c4587bf5b6ce521672d7a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yannik=20Sch=C3=A4lte?= <31767307+yannikschaelte@users.noreply.github.com> Date: Mon, 2 Oct 2023 15:35:11 +0200 Subject: [PATCH 16/30] Documentation fixes (#1120) * document hierarchical optimization sources; add aesara+jax to objective docs * document origin of the mh + pt samplers * fix typo * fix typo * Update pypesto/sample/parallel_tempering.py Typo * streamline doc deps * update setup req versions * try cyipopt fix * test * tesT * test * fix test_visualize::test_optimization_scatter_with_x_None * test * fixup --------- Co-authored-by: Paul Jonas Jost <70631928+PaulJonasJost@users.noreply.github.com> --- .github/workflows/ci.yml | 4 +- .readthedocs.yml | 1 - doc/api.rst | 2 + pypesto/hierarchical/__init__.py | 27 ++++++++- pypesto/sample/adaptive_metropolis.py | 58 +++++++++++++++++-- pypesto/sample/adaptive_parallel_tempering.py | 19 +++++- pypesto/sample/metropolis.py | 25 +++++++- pypesto/sample/parallel_tempering.py | 21 ++++++- pypesto/visualize/parameters.py | 4 +- pyproject.toml | 4 +- setup.cfg | 6 +- tox.ini | 8 +-- 12 files changed, 157 insertions(+), 22 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ec4710d23..f3fb62908 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -188,8 +188,8 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - # update to 3.11 when nlopt allows - python-version: ['3.9', '3.10'] + # ipopt does not work on 3.9 (https://github.com/mechmotum/cyipopt/issues/225) + python-version: ['3.11'] steps: - name: Check out repository diff --git a/.readthedocs.yml b/.readthedocs.yml index 4a2a4d3c1..b75a9c82b 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -17,7 +17,6 @@ python: path: . extra_requirements: - doc - - amici build: os: "ubuntu-20.04" diff --git a/doc/api.rst b/doc/api.rst index f23a6a0cb..470318cd0 100644 --- a/doc/api.rst +++ b/doc/api.rst @@ -12,6 +12,8 @@ API reference pypesto.history pypesto.logging pypesto.objective + pypesto.objective.aesara + pypesto.objective.jax pypesto.objective.julia pypesto.optimize pypesto.petab diff --git a/pypesto/hierarchical/__init__.py b/pypesto/hierarchical/__init__.py index fc326f25e..74caae7d8 100644 --- a/pypesto/hierarchical/__init__.py +++ b/pypesto/hierarchical/__init__.py @@ -2,7 +2,32 @@ Hierarchical ============ -Hierarchical optimization sub-package. +Contains an implementation of the hierarchical optimization approach, which +decomposes the parameter estimation problem into an outer and an inner problem. +In the outer problem, only dynamic parameters are optimized. +In the inner problem, conditional on the outer solution, static parameters are +optimized. +Static parameters can be parameters affecting directly the model observables, +such as scaling factors, offsets, and noise parameters. + +Hierarchical optimization has the advantage that the outer problem is typically +less complex than the full problem, and thus can be solved more efficiently. +Further, the inner problem can often be solved analytically, which is more +efficient. +Thus, hierarchical optimization can be used to speed up parameter estimation, +finding optimal values more efficiently and reliably. + +The implementation in this package is based on: + +* Loos et al. 2018 (https://doi.org/10.1093/bioinformatics/bty514), + who give an analytic solution for the inner problem for scaling factors and + noise standard deviations, for Gaussian and Laplace noise, using forward + sensitivity analysis (FSA). +* Schmiester et al. 2020 (https://doi.org/10.1093/bioinformatics/btz581), + who give an analytic solution for the inner problem for scaling factors, + offsets and noise standard deviations, for Gaussian and Laplace noise, + using adjoint sensitivity analysis (ASA). ASA allows to calculate gradients + substantially more efficiently in high dimension. """ from .calculator import HierarchicalAmiciCalculator diff --git a/pypesto/sample/adaptive_metropolis.py b/pypesto/sample/adaptive_metropolis.py index cbe9b1825..6b29bd804 100644 --- a/pypesto/sample/adaptive_metropolis.py +++ b/pypesto/sample/adaptive_metropolis.py @@ -8,7 +8,54 @@ class AdaptiveMetropolisSampler(MetropolisSampler): - """Metropolis-Hastings sampler with adaptive proposal covariance.""" + """Metropolis-Hastings sampler with adaptive proposal covariance. + + A core problem of the standard Metropolis-Hastings sampler is + its fixed proposal distribution, which must be manually tuned. + This sampler adapts the proposal distribution during the sampling + process based on previous samples. + It adapts the correlation structure and the scaling factor of the + proposal distribution. + For both parts, there exist a variety of methods, see + + * Ballnus et al. 2017. + Comprehensive benchmarking of Markov chain Monte Carlo methods for + dynamical systems + (https://doi.org/10.1186/s12918-017-0433-1) + * Andrieu et al. 2008. + A tutorial on adaptive MCMC + (https://doi.org/10.1007/s11222-008-9110-y) + + for a review. + + Here, we approximate the covariance matrix via a weighted average of + current and earlier samples, + with a decay factor determining the relative contribution of the + current sample and earlier ones to the weighted average of mean and + covariance. + The scaling factor we aim to converge to a fixed target acceptance rate + of 0.234, as suggested by theoretical results. + The implementation is based on: + + * Lacki et al. 2015. + State-dependent swap strategies and automatic reduction of number of + temperatures in adaptive parallel tempering algorithm + (https://doi.org/10.1007/s11222-015-9579-0) + * Miasojedow et al. 2013. + An adaptive parallel tempering algorithm + (https://doi.org/10.1080/10618600.2013.778779) + + In turn, these are based on adaptive MCMC as discussed in: + + * Haario et al. 2001. + An adaptive Metropolis algorithm + (https://doi.org/10.2307/3318737) + + For reference matlab implementations see: + + * https://github.com/ICB-DCM/PESTO/blob/master/private/performPT.m + * https://github.com/ICB-DCM/PESTO/blob/master/private/updateStatistics.m + """ def __init__(self, options: Dict = None): super().__init__(options) @@ -79,7 +126,7 @@ def _update_proposal( decay_constant=decay_constant, ) - # compute covariance scaling factor + # compute covariance scaling factor based on the target acceptance rate self._cov_scale *= np.exp( (np.exp(log_p_acc) - target_acceptance_rate) / np.power(n_sample_cur + 1, decay_constant) @@ -100,8 +147,11 @@ def update_history_statistics( n_cur_sample: int, decay_constant: float, ) -> Tuple[np.ndarray, np.ndarray]: - """ - Update sampling statistics. + """Update sampling mean and covariance matrix via weighted average. + + Update sampling mean and covariance matrix based on the previous + estimate and the most recent sample via a weighted average, + with gradually decaying update rate. Parameters ---------- diff --git a/pypesto/sample/adaptive_parallel_tempering.py b/pypesto/sample/adaptive_parallel_tempering.py index 788f752b4..2475db3e3 100644 --- a/pypesto/sample/adaptive_parallel_tempering.py +++ b/pypesto/sample/adaptive_parallel_tempering.py @@ -7,7 +7,24 @@ class AdaptiveParallelTemperingSampler(ParallelTemperingSampler): - """Parallel tempering sampler with adaptive temperature adaptation.""" + """Parallel tempering sampler with adaptive temperature adaptation. + + Compared to the base class, this sampler adapts the temperatures + during the sampling process. + This both simplifies the setup as it avoids manual tuning, + and improves the performance as the temperatures are adapted to the + current state of the chains. + + This implementation is based on: + + * Vousden et al. 2016. + Dynamic temperature selection for parallel tempering in Markov chain + Monte Carlo simulations + (https://doi.org/10.1093/mnras/stv2422), + + via a matlab reference implementation + (https://github.com/ICB-DCM/PESTO/blob/master/private/performPT.m). + """ @classmethod def default_options(cls) -> Dict: diff --git a/pypesto/sample/metropolis.py b/pypesto/sample/metropolis.py index 88a8ca41c..09495f534 100644 --- a/pypesto/sample/metropolis.py +++ b/pypesto/sample/metropolis.py @@ -11,7 +11,30 @@ class MetropolisSampler(InternalSampler): - """Simple Metropolis-Hastings sampler with fixed proposal variance.""" + """Simple Metropolis-Hastings sampler with fixed proposal variance. + + The Metropolis-Hastings sampler is a Markov chain Monte Carlo (MCMC) + method generating a sequence of samples from a probability + distribution. + + This class implements a simple Metropolis algorithm with fixed + symmetric Gaussian proposal distribution. + + For the underlying original publication, see: + + * Metropolis et al. 1953. + Equation of State Calculations by Fast Computing Machines + (https://doi.org/10.1063/1.1699114) + * Hastings 1970. + Monte Carlo sampling methods using Markov chains and their + applications + (https://doi.org/10.1093/biomet/57.1.97) + + For reference matlab implementations see: + + * https://en.wikipedia.org/wiki/Metropolis%E2%80%93Hastings_algorithm + * https://github.com/ICB-DCM/PESTO/blob/master/private/performPT.m + """ def __init__(self, options: Dict = None): super().__init__(options) diff --git a/pypesto/sample/parallel_tempering.py b/pypesto/sample/parallel_tempering.py index e82ab9e34..44a9f4453 100644 --- a/pypesto/sample/parallel_tempering.py +++ b/pypesto/sample/parallel_tempering.py @@ -10,7 +10,26 @@ class ParallelTemperingSampler(Sampler): - """Simple parallel tempering sampler.""" + """Simple parallel tempering sampler. + + Parallel tempering is a Markov chain Monte Carlo (MCMC) method that + uses multiple chains with different temperatures to sample from a + probability distribution. + The chains are coupled by swapping samples between them. + This allows to sample from distributions with multiple modes more + efficiently, as high-temperature chains can jump between modes, while + low-temperature chains can sample the modes more precisely. + + This implementation is based on: + + * Vousden et al. 2016. + Dynamic temperature selection for parallel tempering in Markov chain + Monte Carlo simulations + (https://doi.org/10.1093/mnras/stv2422), + + via a matlab-based reference implementation + (https://github.com/ICB-DCM/PESTO/blob/master/private/performPT.m). + """ def __init__( self, diff --git a/pypesto/visualize/parameters.py b/pypesto/visualize/parameters.py index 52509116f..d175c25b6 100644 --- a/pypesto/visualize/parameters.py +++ b/pypesto/visualize/parameters.py @@ -561,7 +561,7 @@ def optimization_scatter( parameter_indices = process_parameter_indices( parameter_indices=parameter_indices, result=result ) - # remove all start indices, that encounter an inf value at the start + # remove all start indices that encounter an inf value at the start # resulting in optimize_result[start]["x"] being None start_indices_finite = start_indices[ [ @@ -570,7 +570,7 @@ def optimization_scatter( ] ] # compare start_indices with start_indices_finite and log a warning - if not np.all(start_indices == start_indices_finite): + if len(start_indices) != len(start_indices_finite): logger.warning( 'Some start indices were removed due to inf values at the start.' ) diff --git a/pyproject.toml b/pyproject.toml index ed59d2789..06bda6a3f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,8 +4,8 @@ [build-system] requires = [ - "setuptools >= 52.0.0", - "wheel >= 0.36.2", + "setuptools >= 68.2.0", + "wheel >= 0.41.2", ] build-backend = "setuptools.build_meta" diff --git a/setup.cfg b/setup.cfg index 6194ed8bd..573406d37 100644 --- a/setup.cfg +++ b/setup.cfg @@ -96,7 +96,7 @@ amici = petab = petab >= 0.2.0 ipopt = - ipopt + cyipopt >= 1.3.0 dlib = dlib >= 19.19.0 nlopt = @@ -143,6 +143,10 @@ doc = ipykernel >= 6.15.1 %(select)s %(fides)s + %(amici)s + %(petab)s + %(aesara)s + %(jax)s example = notebook >= 6.1.4 select = diff --git a/tox.ini b/tox.ini index 9866525c1..9477f90f0 100644 --- a/tox.ini +++ b/tox.ini @@ -95,10 +95,8 @@ description = Test Julia interface [testenv:optimize] -extras = test,dlib,pyswarm,cmaes,nlopt,fides,mpi,pyswarms,petab +extras = test,dlib,ipopt,pyswarm,cmaes,nlopt,fides,mpi,pyswarms,petab commands = - # workaround as ipopt has incomplete build - pip install git+https://github.com/mechmotum/cyipopt.git@master pytest --cov=pypesto --cov-report=xml --cov-append \ test/optimize -s description = @@ -127,8 +125,6 @@ description = allowlist_externals = bash extras = example,amici,petab,pyswarm,pymc3,cmaes,nlopt,fides commands = - # workaround as ipopt has incomplete build - pip install git+https://github.com/mechmotum/cyipopt.git@master bash test/run_notebook.sh 1 description = Run notebooks 1 @@ -171,7 +167,7 @@ description = [testenv:doc] extras = - doc,amici,petab + doc,amici,petab,aesara,jax commands = sphinx-build -W -b html doc/ doc/_build/html description = From 7458d04086eeefec5b6df8266c412eeb279a2921 Mon Sep 17 00:00:00 2001 From: Yannik Schaelte Date: Mon, 2 Oct 2023 15:40:11 +0200 Subject: [PATCH 17/30] update changelog+version --- CHANGELOG.rst | 36 ++++++++++++++++++++++++++++++++---- pypesto/version.py | 2 +- 2 files changed, 33 insertions(+), 5 deletions(-) diff --git a/CHANGELOG.rst b/CHANGELOG.rst index b51746437..516e6465c 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -6,8 +6,38 @@ Release notes .......... +0.3.2 (2023-10-02) +------------------ + +* Visualize: + * Restrict fval magnitude in waterfall with order_by_id (#1090) + * Hierarchical parameter plot fix (#1106) + * Fix y-limits on waterfall (#1109) +* Sampling: + * Use cloudpickle for pickling dynesty sampler (#1094) +* Optimize + * Small fix on hierarchical initialise (#1095) + * Fix startpoint sampling for hierarchical optimization #1105) + * SacessOptimizer: retry reading, delay deleting (#1110) + * SacessOptimizer: Fix logging with multiprocessing (#1112) + * SacessOptimizer: tmpdir option (#1115) +* Storage: + * fix storage (#1099) +* Examples + * Notebook on differences (#1098) +* Problem + * Add startpoint_method to Problem (#1093) +* General + * Added new entry to bib (#1100) + * PetabJL integration (#1089) + * Other platform tests (#1113) + * Dokumentation fixes (#1120) + * Updated CODEOWNER (#1122) + + 0.3.1 (2023-06-22) -------------------- +------------------ + * Visualize: * Parameter plot w/ hier. pars, noise estimation for splines (#1061) * Sampling: @@ -34,7 +64,7 @@ Release notes 0.3.0 (2023-05-02) -------------------- +------------------ New functionalities compared to 0.2.0: @@ -61,8 +91,6 @@ Not supported functionalities and versions compared to 0.2.0: * **Changed parameter indexing from boolean to int in profiling routines** - - 0.2 series .......... diff --git a/pypesto/version.py b/pypesto/version.py index 260c070a8..f9aa3e110 100644 --- a/pypesto/version.py +++ b/pypesto/version.py @@ -1 +1 @@ -__version__ = "0.3.1" +__version__ = "0.3.2" From 6333356e9f522a13628db9f1bcbeeab4f3588840 Mon Sep 17 00:00:00 2001 From: Paul Jonas Jost <70631928+PaulJonasJost@users.noreply.github.com> Date: Mon, 2 Oct 2023 15:51:34 +0200 Subject: [PATCH 18/30] Changed Codeowners and contact to accomodate changes in personell (#1123) --- .github/CODEOWNERS | 38 +++++++++++++++++++------------------- doc/contact.rst | 2 +- 2 files changed, 20 insertions(+), 20 deletions(-) diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index 3a08e687b..511438234 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -4,43 +4,43 @@ * @ICB-DCM/pypesto-maintainers /doc/example/hdf5_storage.ipynb @PaulJonasJost -/doc/example/hierarchical.ipynb @dilpath @dweindl @yannikschaelte -/doc/example/julia.ipynb @yannikschaelte +/doc/example/hierarchical.ipynb @dilpath @dweindl +/doc/example/julia.ipynb @PaulJonasJost /doc/example/model_selection.ipynb @dilpath /doc/example/petab_import.ipynb @dweindl @FFroehlich -/doc/example/sampler_study.ipynb @dilpath @yannikschaelte -/doc/example/sampling_diagnostics.ipynb @dilpath @yannikschaelte +/doc/example/sampler_study.ipynb @dilpath +/doc/example/sampling_diagnostics.ipynb @dilpath /doc/example/store.ipynb @PaulJonasJost /doc/example/synthetic_data.ipynb @dilpath /docker/ @dweindl -/pypesto/engine/ @yannikschaelte +/pypesto/engine/ @PaulJonasJost /pypesto/engine/mpi_pool.py @PaulJonasJost /pypesto/ensemble/ @dilpath -/pypesto/hierarchical/ @dilpath @dweindl @yannikschaelte +/pypesto/hierarchical/ @dilpath @dweindl /pypesto/hierarchical/optimal_scaling_approach/ @doresic /pypesto/history/ @PaulJonasJost -/pypesto/objective/ @yannikschaelte -/pypesto/objective/amici/ @yannikschaelte @dweindl @FFroehlich +/pypesto/objective/ @PaulJonasJost +/pypesto/objective/amici/ @PaulJonasJost @dweindl @FFroehlich /pypesto/objective/jax/ @FFroehlich /pypesto/objective/aesara/ @FFroehlich -/pypesto/optimize/ @yannikschaelte +/pypesto/optimize/ @PaulJonasJost /pypesto/petab/ @dweindl @FFroehlich /pypesto/predict/ @PaulJonasJost @dilpath -/pypesto/problem/ @yannikschaelte +/pypesto/problem/ @PaulJonasJost /pypesto/profile/ @PaulJonasJost -/pypesto/result/ @yannikschaelte -/pypesto/sample/ @dilpath @yannikschaelte +/pypesto/result/ @PaulJonasJost +/pypesto/sample/ @dilpath /pypesto/select/ @dilpath -/pypesto/startpoint/ @yannikschaelte +/pypesto/startpoint/ @PaulJonasJost /pypesto/store/ @PaulJonasJost /pypesto/visualize/ @plakrisenko @stephanmg -/test/base/ @yannikschaelte -/test/doc/ @yannikschaelte -/test/hierarchical/ @dilpath @dweindl @yannikschaelte -/test/julia/ @yannikschaelte -/test/optimize/ @yannikschaelte +/test/base/ @PaulJonasJost +/test/doc/ @PaulJonasJost +/test/hierarchical/ @dilpath @dweindl +/test/julia/ @PaulJonasJost +/test/optimize/ @PaulJonasJost /test/petab/ @dweindl @FFroehlich /test/profile/ @PaulJonasJost -/test/sample/ @dilpath @yannikschaelte +/test/sample/ @dilpath /test/select/ @dilpath /test/visualize/ @plakrisenko @stephanmg diff --git a/doc/contact.rst b/doc/contact.rst index 4cc55b6e1..e5d4e5685 100644 --- a/doc/contact.rst +++ b/doc/contact.rst @@ -5,4 +5,4 @@ Contact Discovered an error? Need help? Not sure if something works as intended? Please contact us! -- Yannik Schälte: `yannik.schaelte@gmail.com `_ +- Paul Jonas Jost: `paul.jost@uni-bonn.de `_ From 5dc85e48a09c8bc548594097813a142cbde6fd16 Mon Sep 17 00:00:00 2001 From: Paul Jonas Jost <70631928+PaulJonasJost@users.noreply.github.com> Date: Mon, 2 Oct 2023 15:56:39 +0200 Subject: [PATCH 19/30] Updated version and Changelog (#1122) * Updated version and Changelog * Updated Changelog * Update CHANGELOG.rst --- CHANGELOG.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 516e6465c..c69ec6607 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -7,7 +7,7 @@ Release notes 0.3.2 (2023-10-02) ------------------- +------------------- * Visualize: * Restrict fval magnitude in waterfall with order_by_id (#1090) @@ -17,7 +17,7 @@ Release notes * Use cloudpickle for pickling dynesty sampler (#1094) * Optimize * Small fix on hierarchical initialise (#1095) - * Fix startpoint sampling for hierarchical optimization #1105) + * Fix startpoint sampling for hierarchical optimization (#1105) * SacessOptimizer: retry reading, delay deleting (#1110) * SacessOptimizer: Fix logging with multiprocessing (#1112) * SacessOptimizer: tmpdir option (#1115) @@ -32,7 +32,7 @@ Release notes * PetabJL integration (#1089) * Other platform tests (#1113) * Dokumentation fixes (#1120) - * Updated CODEOWNER (#1122) + * Updated CODEOWNER (#1123) 0.3.1 (2023-06-22) From 3deb5481f8da35d8a33bf651697dfc63ba15c29d Mon Sep 17 00:00:00 2001 From: Paul Jonas Jost <70631928+PaulJonasJost@users.noreply.github.com> Date: Mon, 9 Oct 2023 10:55:34 -0400 Subject: [PATCH 20/30] Temporarily set the version of petab installed to 1.4.2 (#1128) * Temporarily set the version of petab installed to 1.4.2 (last working version) * Slightly Altered syntax --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f3fb62908..a016b6e5d 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -172,7 +172,7 @@ jobs: run: .github/workflows/install_deps.sh - name: Install PEtabJL dependencies - run: julia -e 'using Pkg; Pkg.add("PEtab"); Pkg.add("OrdinaryDiffEq"), Pkg.add("Sundials")' + run: julia -e 'using Pkg; Pkg.add(name="PEtab", version="1.4.2"); Pkg.add("OrdinaryDiffEq"), Pkg.add("Sundials")' - name: Run tests timeout-minutes: 25 From 8fe602aefa964fe110ef59338178a5255e8aabf7 Mon Sep 17 00:00:00 2001 From: Paul Jonas Jost <70631928+PaulJonasJost@users.noreply.github.com> Date: Mon, 9 Oct 2023 11:33:31 -0400 Subject: [PATCH 21/30] =?UTF-8?q?Added=20a=20bit=20more=20information=20to?= =?UTF-8?q?=20petab=20importer=20and=20objective=20function=E2=80=A6=20(#1?= =?UTF-8?q?126)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Added a bit more information to petab importer and objective function created from petab. Line with "noqa" to keep url. Closes #1047 * Moved noqa somewhere else * Apply suggestions from code review Co-authored-by: Daniel Weindl --------- Co-authored-by: Daniel Weindl --- pypesto/petab/importer.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/pypesto/petab/importer.py b/pypesto/petab/importer.py index fd1e812be..5c536128b 100644 --- a/pypesto/petab/importer.py +++ b/pypesto/petab/importer.py @@ -61,11 +61,15 @@ class PetabImporter(AmiciObjectBuilder): """ - Importer for Petab files. + Importer for PEtab files. Create an `amici.Model`, an `objective.AmiciObjective` or a - `pypesto.Problem` from Petab files. - """ + `pypesto.Problem` from PEtab files. The created objective function is a + negative log-likelihood function and can thus be negative. The actual + form of the likelihood depends on the noise model specified in the provided PEtab problem. + For more information, see + [the PEtab documentation](https://petab.readthedocs.io/en/latest/documentation_data_format.html#noise-distributions) + """ # noqa MODEL_BASE_DIR = "amici_models" From 2f0f50dc758eb9638318de4f483914b696d0436b Mon Sep 17 00:00:00 2001 From: Vincent Wieland <90847066+vwiela@users.noreply.github.com> Date: Mon, 9 Oct 2023 18:28:54 +0200 Subject: [PATCH 22/30] Update ensemble.py (#1124) * Update ensemble.py Add an option for computing cutoff values for pointwise confidence regions. Needed for ensemble simulations. * Update ensemble.py Fix string literal. * Style changes ensemble.py Change style of string representation. * Fix string name & black * Update C.py Add simultaneous and pointwise strings for the choice of confidence regions. * Update strings ensemble.py Changed strings to constants stored in C.py. * Fix typo C.py Fix typo. * Style and quality ensemble.py Use black for consistent code style. --------- Co-authored-by: Doresic Co-authored-by: Paul Jonas Jost <70631928+PaulJonasJost@users.noreply.github.com> --- pypesto/C.py | 3 +++ pypesto/ensemble/ensemble.py | 27 +++++++++++++++++++++++---- 2 files changed, 26 insertions(+), 4 deletions(-) diff --git a/pypesto/C.py b/pypesto/C.py index 61f4eb449..c5b65452a 100644 --- a/pypesto/C.py +++ b/pypesto/C.py @@ -35,6 +35,9 @@ ENSEMBLE_TYPE = 'ensemble_type' PREDICTIONS = 'predictions' +SIMULTANEOUS = 'simultaneous' +POINTWISE = 'pointwise' + LOWER_BOUND = 'lower_bound' UPPER_BOUND = 'upper_bound' PREEQUILIBRATION_CONDITION_ID = 'preequilibrationConditionId' diff --git a/pypesto/ensemble/ensemble.py b/pypesto/ensemble/ensemble.py index 178c1c2b1..d2ab53df9 100644 --- a/pypesto/ensemble/ensemble.py +++ b/pypesto/ensemble/ensemble.py @@ -29,12 +29,14 @@ OUTPUT, OUTPUT_SENSI, PERCENTILE, + POINTWISE, PREDICTION_ARRAYS, PREDICTION_ID, PREDICTION_RESULTS, PREDICTION_SUMMARY, PREDICTIONS, PREDICTOR, + SIMULTANEOUS, STANDARD_DEVIATION, SUMMARY, TIMEPOINTS, @@ -1204,7 +1206,11 @@ def get_percentile_label(percentile: Union[float, int, str]) -> str: return f'{PERCENTILE} {percentile}' -def calculate_cutoff(result: Result, percentile: float = 0.95): +def calculate_cutoff( + result: Result, + percentile: float = 0.95, + cr_option: str = SIMULTANEOUS, +): """ Calculate the cutoff of the ensemble. @@ -1220,6 +1226,10 @@ def calculate_cutoff(result: Result, percentile: float = 0.95): The percentile of the chi^2 distribution. Between 0 and 100. Higher values will result in a more lax cutoff. If the value is greater than 100, the cutoff will be returned as np.inf. + cr_option: + The type of confidence region, which determines the degree of freedom of + the chi^2 distribution for the cutoff value. It can take 'simultaneous' or + 'pointwise'. Returns ------- @@ -1230,10 +1240,19 @@ def calculate_cutoff(result: Result, percentile: float = 0.95): f"percentile={percentile} is too large. Choose " f"0<=percentile<=100." ) + if cr_option not in [SIMULTANEOUS, POINTWISE]: + raise ValueError( + "Confidence region must be either simultaneous or pointwise." + ) + # optimal point as base: fval_opt = result.optimize_result[0].fval - # degrees of freedom is equal to the number of parameters - df = result.problem.dim - range = chi2.ppf(q=percentile / 100, df=df) + if cr_option == SIMULTANEOUS: + # degrees of freedom is equal to the number of parameters + df = result.problem.dim + elif cr_option == POINTWISE: + # degrees of freedom is equal to 1 + df = 1 + range = chi2.ppf(q=percentile / 100, df=df) return fval_opt + range From 9b0d7fd06a13676c09559715ae66ab05613a28cc Mon Sep 17 00:00:00 2001 From: Polina Lakrisenko Date: Tue, 10 Oct 2023 09:31:23 +0200 Subject: [PATCH 23/30] Get optimization result by id (#1116) * add possibility to get an optimization result with specified id --- pypesto/result/optimize.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/pypesto/result/optimize.py b/pypesto/result/optimize.py index 6f38a4fba..c77a57460 100644 --- a/pypesto/result/optimize.py +++ b/pypesto/result/optimize.py @@ -406,3 +406,11 @@ def get_for_key(self, key) -> list: "releases." ) return [res[key] for res in self.list] + + def get_by_id(self, ores_id: str): + """Get OptimizationResult with the specified id.""" + for res in self.list: + if res.id == ores_id: + return res + else: + raise ValueError(f"no optimization result with id={ores_id}") From 33da1189d2a954260fbc46eb269b90fb376c3fa2 Mon Sep 17 00:00:00 2001 From: Polina Lakrisenko Date: Tue, 10 Oct 2023 16:07:26 +0200 Subject: [PATCH 24/30] {id} in history storage filename (#1118) * allow {id} in history filename together with multiprocessing * Black rework --------- Co-authored-by: Paul Jonas Jost <70631928+PaulJonasJost@users.noreply.github.com> Co-authored-by: PaulJonasJost --- pypesto/optimize/util.py | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/pypesto/optimize/util.py b/pypesto/optimize/util.py index a620ae37d..4e2e86383 100644 --- a/pypesto/optimize/util.py +++ b/pypesto/optimize/util.py @@ -61,9 +61,16 @@ def preprocess_hdf5_history( return False # create directory with same name as original file stem - template_path = ( - path.parent / path.stem / (path.stem + "_{id}" + path.suffix) - ) + if "{id}" in path.stem: + template_path = ( + path.parent + / path.stem.replace("{id}", "") + / (path.stem + path.suffix) + ) + else: + template_path = ( + path.parent / path.stem / (path.stem + "_{id}" + path.suffix) + ) template_path.parent.mkdir(parents=True, exist_ok=True) # set history file to template path history_options.storage_file = str(template_path) @@ -92,6 +99,8 @@ def postprocess_hdf5_history( History options used in the optimization. """ # create hdf5 file that gathers the others within history group + if "{id}" in storage_file: + storage_file = storage_file.replace("{id}", "") with h5py.File(storage_file, mode='w') as f: # create file and group f.require_group("history") From 0529fe5273d432e6e1d18604e96deba5b3ff7eaf Mon Sep 17 00:00:00 2001 From: Paul Jonas Jost <70631928+PaulJonasJost@users.noreply.github.com> Date: Tue, 10 Oct 2023 11:07:26 -0400 Subject: [PATCH 25/30] Added How to Cite (#1125) * Added How to Cite to readme. * Added how_to_cite to read_the_docs * added how_to_cite to index.rst --- README.md | 27 ++++++++++++++++++++++++--- doc/how_to_cite.rst | 28 ++++++++++++++++++++++++++++ doc/index.rst | 1 + doc/references.rst | 4 ++-- 4 files changed, 55 insertions(+), 5 deletions(-) create mode 100644 doc/how_to_cite.rst diff --git a/README.md b/README.md index 58ef9ca52..e6f00ba30 100644 --- a/README.md +++ b/README.md @@ -59,8 +59,29 @@ We are happy about any contributions. For more information on how to contribute to pyPESTO check out +## Publications + +**Citeable DOI for the latest pyPESTO release:** +[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.2553546.svg)](https://doi.org/10.5281/zenodo.2553546) + +There is a list of [publications using pyPESTO](https://pypesto.readthedocs.io/en/latest/references.html). +If you used pyPESTO in your work, we are happy to include +your project, please let us know via a GitHub issue. + +When using pyPESTO in your project, please cite +* Schälte, Y., Fröhlich, F., Jost, P. J., Vanhoefer, J., Pathirana, D., Stapor, P., + Lakrisenko, P., Wang, D., Raimúndez, E., Merkt, S., Schmiester, L., Städter, P., + Grein, S., Dudkin, E., Doresic, D., Weindl, D., & Hasenauer, J. (2023). pyPESTO: A + modular and scalable tool for parameter estimation for dynamic models [(arXiv:2305.01821)](https://doi.org/10.48550/arXiv.2305.01821). + +When presenting work that employs pyPESTO, feel free to use one of the icons in +[doc/logo/](https://github.com/ICB-DCM/pyPESTO/tree/main/doc/logo): + +

+ AMICI Logo +

+ ## References -[**PESTO**](https://github.com/ICB-DCM/PESTO/): -Parameter estimation toolbox for MATLAB. Development is discontinued, but PESTO -comes with additional features waiting to be ported to pyPESTO. +pyPESTO supersedes [**PESTO**](https://github.com/ICB-DCM/PESTO/) a parameter estimation +toolbox for MATLAB, whose development is discontinued. diff --git a/doc/how_to_cite.rst b/doc/how_to_cite.rst new file mode 100644 index 000000000..53054abd8 --- /dev/null +++ b/doc/how_to_cite.rst @@ -0,0 +1,28 @@ +How to cite pyPESTO +=================== + +**Citeable DOI for the latest pyPESTO release:** + +.. image:: https://zenodo.org/badge/DOI/10.5281/zenodo.2553546.svg + :target: https://doi.org/10.5281/zenodo.2553546 + :alt: pyPESTO release DOI + + +There is a list of `publications using pyPESTO `_. +If you used pyPESTO in your work, we are happy to include +your project, please let us know via a GitHub issue. + +When using pyPESTO in your project, please cite + +- Schälte, Y., Fröhlich, F., Jost, P. J., Vanhoefer, J., Pathirana, D., Stapor, P., + Lakrisenko, P., Wang, D., Raimúndez, E., Merkt, S., Schmiester, L., Städter, P., + Grein, S., Dudkin, E., Doresic, D., Weindl, D., & Hasenauer, J. (2023). pyPESTO: A + modular and scalable tool for parameter estimation for dynamic models `arXiv:2305.01821 `_. + +When presenting work that employs pyPESTO, feel free to use one of the icons in +`doc/logo/ `_: + +.. image:: https://raw.githubusercontent.com/ICB-DCM/pyPESTO/master/doc/logo/logo.png + :target: https://raw.githubusercontent.com/ICB-DCM/pyPESTO/master/doc/logo/logo.png + :height: 75 + :alt: pyPESTO LOGO diff --git a/doc/index.rst b/doc/index.rst index 062f4c034..5035172d0 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -45,6 +45,7 @@ pyPESTO - Parameter EStimation TOolbox for python references contact license + how_to_cite logo diff --git a/doc/references.rst b/doc/references.rst index 79742222b..c8cb861c0 100644 --- a/doc/references.rst +++ b/doc/references.rst @@ -1,7 +1,7 @@ -Publications using pypesto +Publications using pyPESTO ========================== -pypesto was used in the following publications: +pyPESTO was used in the following publications: .. bibliography:: using_pypesto.bib :list: enumerated From 4c25569a6ff566d3e3d7af58c422f68b5ab55fd7 Mon Sep 17 00:00:00 2001 From: Polina Lakrisenko Date: Wed, 11 Oct 2023 14:34:06 +0200 Subject: [PATCH 26/30] fix ensembles from optimization endpoints (#1130) Co-authored-by: Paul Jonas Jost <70631928+PaulJonasJost@users.noreply.github.com> --- pypesto/ensemble/ensemble.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pypesto/ensemble/ensemble.py b/pypesto/ensemble/ensemble.py index d2ab53df9..d3bd07687 100644 --- a/pypesto/ensemble/ensemble.py +++ b/pypesto/ensemble/ensemble.py @@ -670,7 +670,7 @@ def from_optimization_endpoints( # did not reach maximum size and the next value is still # lower than the cutoff value if start['fval'] <= abs_cutoff and len(x_vectors) < max_size: - x_vectors.append(start['x']) + x_vectors.append(start['x'][result.problem.x_free_indices]) # the vector tag will be a -1 to indicate it is the last step vector_tags.append((int(start['id']), -1)) From a52ae70e91957695793ff87a5d278f3e4d4016d0 Mon Sep 17 00:00:00 2001 From: Paul Jonas Jost <70631928+PaulJonasJost@users.noreply.github.com> Date: Fri, 13 Oct 2023 08:35:43 -0400 Subject: [PATCH 27/30] Added option to show/not show the hessian in the summary. (#1134) --- pypesto/result/optimize.py | 12 +++++++++--- pypesto/result/result.py | 6 ++++-- 2 files changed, 13 insertions(+), 5 deletions(-) diff --git a/pypesto/result/optimize.py b/pypesto/result/optimize.py index c77a57460..30d08454d 100644 --- a/pypesto/result/optimize.py +++ b/pypesto/result/optimize.py @@ -126,7 +126,7 @@ def __getattr__(self, key): __setattr__ = dict.__setitem__ __delattr__ = dict.__delitem__ - def summary(self, full: bool = False) -> str: + def summary(self, full: bool = False, show_hess: bool = True) -> str: """ Get summary of the object. @@ -134,6 +134,8 @@ def summary(self, full: bool = False) -> str: ---------- full: If True, print full vectors including fixed parameters. + show_hess: + If True, display the Hessian of the result. Returns ------- @@ -164,7 +166,7 @@ def summary(self, full: bool = False) -> str: f"* final gradient value: " f"{self.grad if full else self.grad[self.free_indices]}\n" ) - if self.hess is not None: + if self.hess is not None and show_hess: hess = self.hess if not full: hess = self.hess[np.ix_(self.free_indices, self.free_indices)] @@ -239,6 +241,7 @@ def summary( disp_best: bool = True, disp_worst: bool = False, full: bool = False, + show_hess: bool = True, ) -> str: """ Get summary of the object. @@ -251,6 +254,8 @@ def summary( Whether to display a detailed summary of the worst run. full: If True, print full vectors including fixed parameters. + show_hess: + If True, display the Hessian of the OptimizerResult. """ if len(self) == 0: return "## Optimization Result \n\n*empty*\n" @@ -295,7 +300,8 @@ def summary( ) if disp_best: summary += ( - f"\nA summary of the best run:\n\n{self[0].summary(full)}" + f"\nA summary of the best run:\n\n" + f"{self[0].summary(full, show_hess=show_hess)}" ) if disp_worst: summary += ( diff --git a/pypesto/result/result.py b/pypesto/result/result.py index a2ba81dac..e85bbcde4 100644 --- a/pypesto/result/result.py +++ b/pypesto/result/result.py @@ -36,7 +36,7 @@ def __init__( self.profile_result = profile_result or ProfileResult() self.sample_result = sample_result or SampleResult() - def summary(self, full: bool = False) -> str: + def summary(self, full: bool = False, show_hess: bool = True) -> str: """ Get summary of the object. @@ -44,5 +44,7 @@ def summary(self, full: bool = False) -> str: ---------- full: If True, print full vectors including fixed parameters. + show_hess: + If True, display the Hessian of the OptimizeResult. """ - return self.optimize_result.summary(full=full) + return self.optimize_result.summary(full=full, show_hess=show_hess) From 520b718c80cb30b91b0e6fe5c98069a43497ad6c Mon Sep 17 00:00:00 2001 From: Paul Jonas Jost <70631928+PaulJonasJost@users.noreply.github.com> Date: Thu, 19 Oct 2023 04:09:04 -0400 Subject: [PATCH 28/30] New petabjl syntax (#1131) * Altered syntax * Adhere to new petabl.jl 2.0 version syntax * Changed pyPESTO syntax accordingly. * Removed version from PEtab.jl * bound syntax * Update doc/example/conversion_reaction/PEtabJl_module.jl --- .github/workflows/ci.yml | 2 +- .../conversion_reaction/PEtabJl_module.jl | 14 +-- pypesto/objective/julia/petabJl.py | 16 +-- pypesto/objective/julia/petab_jl_importer.py | 100 +++++++++--------- 4 files changed, 66 insertions(+), 66 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index a016b6e5d..f3fb62908 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -172,7 +172,7 @@ jobs: run: .github/workflows/install_deps.sh - name: Install PEtabJL dependencies - run: julia -e 'using Pkg; Pkg.add(name="PEtab", version="1.4.2"); Pkg.add("OrdinaryDiffEq"), Pkg.add("Sundials")' + run: julia -e 'using Pkg; Pkg.add("PEtab"); Pkg.add("OrdinaryDiffEq"), Pkg.add("Sundials")' - name: Run tests timeout-minutes: 25 diff --git a/doc/example/conversion_reaction/PEtabJl_module.jl b/doc/example/conversion_reaction/PEtabJl_module.jl index 155ba776b..f1bac1935 100644 --- a/doc/example/conversion_reaction/PEtabJl_module.jl +++ b/doc/example/conversion_reaction/PEtabJl_module.jl @@ -5,15 +5,15 @@ using Sundials using PEtab pathYaml = "/Users/pauljonasjost/Documents/GitHub_Folders/pyPESTO/test/julia/../../doc/example/conversion_reaction/conversion_reaction.yaml" -petabModel = readPEtabModel(pathYaml, verbose=true) +petabModel = PEtabModel(pathYaml, verbose=true) -# A full list of options for createPEtabODEProblem can be found at https://sebapersson.github.io/PEtab.jl/dev/API_choosen/#PEtab.setupPEtabODEProblem -petabProblem = createPEtabODEProblem( +# A full list of options for PEtabODEProblem can be found at https://sebapersson.github.io/PEtab.jl/stable/API_choosen/ +petabProblem = PEtabODEProblem( petabModel, - odeSolverOptions=ODESolverOptions(Rodas5P(), abstol=1e-08, reltol=1e-08, maxiters=Int64(1e4)), - gradientMethod=:ForwardDiff, - hessianMethod=:ForwardDiff, - sparseJacobian=nothing, + ode_solver=ODESolver(Rodas5P(), abstol=1e-08, reltol=1e-08, maxiters=Int64(1e4)), + gradient_method=:ForwardDiff, + hessian_method=:ForwardDiff, + sparse_jacobian=nothing, verbose=true ) diff --git a/pypesto/objective/julia/petabJl.py b/pypesto/objective/julia/petabJl.py index 344c78f71..bceca4a60 100644 --- a/pypesto/objective/julia/petabJl.py +++ b/pypesto/objective/julia/petabJl.py @@ -61,10 +61,10 @@ def __init__( self.petab_jl_problem = petab_jl_problem # get functions - fun = self.petab_jl_problem.computeCost - grad = self.petab_jl_problem.computeGradient - hess = self.petab_jl_problem.computeHessian - x_names = np.asarray(self.petab_jl_problem.θ_estNames) + fun = self.petab_jl_problem.compute_cost + grad = self.petab_jl_problem.compute_gradient + hess = self.petab_jl_problem.compute_hessian + x_names = np.asarray(self.petab_jl_problem.θ_names) # call the super super super constructor super(JuliaObjective, self).__init__( @@ -102,10 +102,10 @@ def __setstate__(self, state): self.petab_jl_problem = petab_jl_problem # get functions - fun = self.petab_jl_problem.computeCost - grad = self.petab_jl_problem.computeGradient - hess = self.petab_jl_problem.computeHessian - x_names = np.asarray(self.petab_jl_problem.θ_estNames) + fun = self.petab_jl_problem.compute_cost + grad = self.petab_jl_problem.compute_gradient + hess = self.petab_jl_problem.compute_hessian + x_names = np.asarray(self.petab_jl_problem.θ_names) # call the super super constructor super(JuliaObjective, self).__init__(fun, grad, hess, x_names) diff --git a/pypesto/objective/julia/petab_jl_importer.py b/pypesto/objective/julia/petab_jl_importer.py index 3b8f2c1d2..06aa8bdf1 100644 --- a/pypesto/objective/julia/petab_jl_importer.py +++ b/pypesto/objective/julia/petab_jl_importer.py @@ -50,10 +50,10 @@ def __init__( @staticmethod def from_yaml( yaml_file: str, - odeSolverOptions: Optional[dict] = None, - gradientMethod: Optional[str] = None, - hessianMethod: Optional[str] = None, - sparseJacobian: Optional[bool] = None, + ode_solver_options: Optional[dict] = None, + gradient_method: Optional[str] = None, + hessian_method: Optional[str] = None, + sparse_jacobian: Optional[bool] = None, verbose: Optional[bool] = None, directory: Optional[str] = None, ) -> PetabJlImporter: @@ -67,11 +67,11 @@ def from_yaml( ---------- yaml_file: The yaml file of the PEtab problem - odeSolverOptions: + ode_solver_options: Dictionary like options for the ode solver in julia - gradientMethod, hessianMethod: + gradient_method, hessian_method: Julia methods to compute gradient and hessian - sparseJacobian: + sparse_jacobian: Whether to compute sparse Jacobians verbose: Whether to have a more informative log. @@ -81,10 +81,10 @@ def from_yaml( """ # get default values options = _get_default_options( - odeSolverOptions=odeSolverOptions, - gradientMethod=gradientMethod, - hessianMethod=hessianMethod, - sparseJacobian=sparseJacobian, + ode_solver_options=ode_solver_options, + gradient_method=gradient_method, + hessian_method=hessian_method, + sparse_jacobian=sparse_jacobian, verbose=verbose, ) @@ -166,8 +166,8 @@ def create_problem( multistart optimization. """ obj = self.create_objective(precompile=precompile) - lb = np.asarray(self.petab_jl_problem.lowerBounds) - ub = np.asarray(self.petab_jl_problem.upperBounds) + lb = np.asarray(self.petab_jl_problem.lower_bounds) + ub = np.asarray(self.petab_jl_problem.upper_bounds) return Problem( objective=obj, @@ -181,10 +181,10 @@ def create_problem( def _get_default_options( - odeSolverOptions: Union[dict, None] = None, - gradientMethod: Union[str, None] = None, - hessianMethod: Union[str, None] = None, - sparseJacobian: Union[str, None] = None, + ode_solver_options: Union[dict, None] = None, + gradient_method: Union[str, None] = None, + hessian_method: Union[str, None] = None, + sparse_jacobian: Union[str, None] = None, verbose: Union[str, None] = None, ) -> dict: """ @@ -194,13 +194,13 @@ def _get_default_options( Parameters ---------- - odeSolverOptions: + ode_solver_options: Options for the ODE solver. - gradientMethod: + gradient_method: Method for gradient calculation. - hessianMethod: + hessian_method: Method for hessian calculation. - sparseJacobian: + sparse_jacobian: Whether the jacobian should be sparse. verbose: Whether to print verbose output. @@ -211,51 +211,51 @@ def _get_default_options( The options. """ # get default values - if odeSolverOptions is None: - odeSolverOptions = { + if ode_solver_options is None: + ode_solver_options = { "solver": "Rodas5P", "abstol": 1e-8, "reltol": 1e-8, "maxiters": "Int64(1e4)", } - if not odeSolverOptions["solver"].endswith("()"): - odeSolverOptions["solver"] += "()" # add parentheses - if gradientMethod is None: - gradientMethod = "nothing" - if hessianMethod is None: - hessianMethod = "nothing" - if sparseJacobian is None: - sparseJacobian = "nothing" + if not ode_solver_options["solver"].endswith("()"): + ode_solver_options["solver"] += "()" # add parentheses + if gradient_method is None: + gradient_method = "nothing" + if hessian_method is None: + hessian_method = "nothing" + if sparse_jacobian is None: + sparse_jacobian = "nothing" if verbose is None: verbose = "true" - # check values for gradientMethod and hessianMethod + # check values for gradient_method and hessian_method allowed_gradient_methods = [ "ForwardDiff", "ForwardEquations", "Adjoint", "Zygote", ] - if gradientMethod not in allowed_gradient_methods: + if gradient_method not in allowed_gradient_methods: logger.warning( - f"gradientMethod {gradientMethod} is not in " + f"gradient_method {gradient_method} is not in " f"{allowed_gradient_methods}. Defaulting to ForwardDiff." ) - gradientMethod = "ForwardDiff" + gradient_method = "ForwardDiff" allowed_hessian_methods = ["ForwardDiff", "BlocForwardDiff", "GaussNewton"] - if hessianMethod not in allowed_hessian_methods: + if hessian_method not in allowed_hessian_methods: logger.warning( - f"hessianMethod {hessianMethod} is not in " + f"hessian_method {hessian_method} is not in " f"{allowed_hessian_methods}. Defaulting to ForwardDiff." ) - hessianMethod = "ForwardDiff" + hessian_method = "ForwardDiff" # fill options options = { - "odeSolverOptions": odeSolverOptions, - "gradientMethod": gradientMethod, - "hessianMethod": hessianMethod, - "sparseJacobian": sparseJacobian, + "ode_solver_options": ode_solver_options, + "gradient_method": gradient_method, + "hessian_method": hessian_method, + "sparse_jacobian": sparse_jacobian, "verbose": verbose, } return options @@ -293,7 +293,7 @@ def _write_julia_file( "PEtab.jl/dev/API_choosen/#PEtab.setupPEtabODEProblem" ) odeSolvOpt_str = ", ".join( - [f"{k}={v}" for k, v in options["odeSolverOptions"].items()] + [f"{k}={v}" for k, v in options["ode_solver_options"].items()] ) # delete "solver=" from string odeSolvOpt_str = odeSolvOpt_str.replace("solver=", "") @@ -304,15 +304,15 @@ def _write_julia_file( f"using Sundials\n" f"using PEtab\n\n" f"pathYaml = \"{yaml_file}\"\n" - f"petabModel = readPEtabModel(pathYaml, verbose=true)\n\n" - f"# A full list of options for createPEtabODEProblem can be " + f"petabModel = PEtabModel(pathYaml, verbose=true)\n\n" + f"# A full list of options for PEtabODEProblem can be " f"found at {link_to_options}\n" - f"petabProblem = createPEtabODEProblem(\n\t" + f"petabProblem = PEtabODEProblem(\n\t" f"petabModel,\n\t" - f"odeSolverOptions=ODESolverOptions({odeSolvOpt_str}),\n\t" - f"gradientMethod=:{options['gradientMethod']},\n\t" - f"hessianMethod=:{options['hessianMethod']},\n\t" - f"sparseJacobian={options['sparseJacobian']},\n\t" + f"ode_solver=ODESolver({odeSolvOpt_str}),\n\t" + f"gradient_method=:{options['gradient_method']},\n\t" + f"hessian_method=:{options['hessian_method']},\n\t" + f"sparse_jacobian={options['sparse_jacobian']},\n\t" f"verbose={options['verbose']}\n)\n\nend\n" ) # write file From c1f259463cf4913f48bb3b0347982e654efa7db2 Mon Sep 17 00:00:00 2001 From: Paul Jonas Jost <70631928+PaulJonasJost@users.noreply.github.com> Date: Thu, 19 Oct 2023 08:23:31 -0400 Subject: [PATCH 29/30] Prepare release 0.3.3 (#1133) * Update Changelog * Added suggestions --- CHANGELOG.rst | 17 +++++++++++++++++ pypesto/version.py | 2 +- 2 files changed, 18 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.rst b/CHANGELOG.rst index c69ec6607..05b8d4936 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -6,6 +6,23 @@ Release notes .......... +0.3.2 (2023-10-02) +------------------- + +* Visualize: + * Get optimization result by id (#1116) +* Storage: + * allow "{id}" in history storage filename (#1118) +* Objective: + * adjusted PEtab.jl syntax to new release (#1128, #1131) + * Documentation on PEtab importer updated (#1126) +* Ensembles + * Additional option for cutoff calculation (#1124) + * Ensembles from optimization endpoints now only takes free parameters (#1130) +* General + * Added How to Cite (#1125) + + 0.3.2 (2023-10-02) ------------------- diff --git a/pypesto/version.py b/pypesto/version.py index f9aa3e110..e19434e2e 100644 --- a/pypesto/version.py +++ b/pypesto/version.py @@ -1 +1 @@ -__version__ = "0.3.2" +__version__ = "0.3.3" From f6cf0d9eef2ae342a73d0d9a13f978e5dc105d06 Mon Sep 17 00:00:00 2001 From: Paul Jonas Jost <70631928+PaulJonasJost@users.noreply.github.com> Date: Thu, 19 Oct 2023 11:36:37 -0400 Subject: [PATCH 30/30] Speed up base test (#1127) * Replaced zengh with Boehm (smaller model should be faster) * Added info on the times for each test * Updated changelog to include it in latest release. * Corrected date of Changelog --- CHANGELOG.rst | 4 +++- test/base/test_engine.py | 16 +++++++++++----- tox.ini | 8 ++++---- 3 files changed, 18 insertions(+), 10 deletions(-) diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 05b8d4936..e65d84e6d 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -6,7 +6,7 @@ Release notes .......... -0.3.2 (2023-10-02) +0.3.3 (2023-10-19) ------------------- * Visualize: @@ -21,6 +21,8 @@ Release notes * Ensembles from optimization endpoints now only takes free parameters (#1130) * General * Added How to Cite (#1125) + * Additional summary option (#1134) + * Speed up base tests (#1127) 0.3.2 (2023-10-02) diff --git a/test/base/test_engine.py b/test/base/test_engine.py index c3e5979e5..d4d045c20 100644 --- a/test/base/test_engine.py +++ b/test/base/test_engine.py @@ -36,12 +36,12 @@ def _test_basic(engine): optimizer = pypesto.optimize.ScipyOptimizer(options={'maxiter': 10}) result = pypesto.optimize.minimize( problem=problem, - n_starts=5, + n_starts=2, engine=engine, optimizer=optimizer, progress_bar=False, ) - assert len(result.optimize_result) == 5 + assert len(result.optimize_result) == 2 def test_petab(): @@ -59,7 +59,9 @@ def test_petab(): def _test_petab(engine): petab_importer = pypesto.petab.PetabImporter.from_yaml( os.path.join( - models.MODELS_DIR, "Zheng_PNAS2012", "Zheng_PNAS2012.yaml" + models.MODELS_DIR, + "Boehm_JProteomeRes2014", + "Boehm_JProteomeRes2014.yaml", ) ) objective = petab_importer.create_objective() @@ -79,7 +81,9 @@ def test_deepcopy_objective(): """Test copying objectives (needed for MultiProcessEngine).""" petab_importer = pypesto.petab.PetabImporter.from_yaml( os.path.join( - models.MODELS_DIR, "Zheng_PNAS2012", "Zheng_PNAS2012.yaml" + models.MODELS_DIR, + "Boehm_JProteomeRes2014", + "Boehm_JProteomeRes2014.yaml", ) ) objective = petab_importer.create_objective() @@ -114,7 +118,9 @@ def test_pickle_objective(): """Test serializing objectives (needed for MultiThreadEngine).""" petab_importer = pypesto.petab.PetabImporter.from_yaml( os.path.join( - models.MODELS_DIR, "Zheng_PNAS2012", "Zheng_PNAS2012.yaml" + models.MODELS_DIR, + "Boehm_JProteomeRes2014", + "Boehm_JProteomeRes2014.yaml", ) ) objective = petab_importer.create_objective() diff --git a/tox.ini b/tox.ini index 9477f90f0..89af0a9c1 100644 --- a/tox.ini +++ b/tox.ini @@ -53,10 +53,10 @@ deps = git+https://github.com/Benchmarking-Initiative/Benchmark-Models-PEtab.git@master\#subdirectory=src/python commands = pytest --cov=pypesto --cov-report=xml --cov-append \ - test/base \ - test/profile \ - test/sample \ - test/visualize \ + test/base --durations=0 \ + test/profile --durations=0 \ + test/sample --durations=0 \ + test/visualize --durations=0 \ -s description = Test basic functionality