From dc49e118aa32845b9ea5feac108be3feb9854ba2 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 16 Mar 2023 12:04:16 +0100 Subject: [PATCH 01/65] =?UTF-8?q?Bump=20version:=200.6.0=20=E2=86=92=200.6?= =?UTF-8?q?.1.dev0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .bumpversion.cfg | 2 +- setup.py | 2 +- src/pydvl/__init__.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.bumpversion.cfg b/.bumpversion.cfg index 4c69a15d0..50e75f70a 100644 --- a/.bumpversion.cfg +++ b/.bumpversion.cfg @@ -1,5 +1,5 @@ [bumpversion] -current_version = 0.6.0 +current_version = 0.6.1.dev0 commit = False tag = False allow_dirty = False diff --git a/setup.py b/setup.py index 83267abb0..4a3cc8522 100644 --- a/setup.py +++ b/setup.py @@ -12,7 +12,7 @@ package_data={"pydvl": ["py.typed"]}, packages=find_packages(where="src"), include_package_data=True, - version="0.6.0", + version="0.6.1.dev0", description="The Python Data Valuation Library", install_requires=[ line diff --git a/src/pydvl/__init__.py b/src/pydvl/__init__.py index 906d362f7..c13c0c481 100644 --- a/src/pydvl/__init__.py +++ b/src/pydvl/__init__.py @@ -1 +1 @@ -__version__ = "0.6.0" +__version__ = "0.6.1.dev0" From a790a8411d4c6aab13af4ebd66c8cb90c8124511 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 15 Mar 2023 20:47:41 +0100 Subject: [PATCH 02/65] Use Queue instead of passing coordinator to workers in TMCS --- src/pydvl/utils/parallel/actor.py | 67 +++++++++------- src/pydvl/value/shapley/actor.py | 109 ++++++++++++++++----------- src/pydvl/value/shapley/truncated.py | 27 ++----- 3 files changed, 112 insertions(+), 91 deletions(-) diff --git a/src/pydvl/utils/parallel/actor.py b/src/pydvl/utils/parallel/actor.py index 05340609b..bd6bc219b 100644 --- a/src/pydvl/utils/parallel/actor.py +++ b/src/pydvl/utils/parallel/actor.py @@ -1,8 +1,7 @@ import abc import inspect import logging -from time import sleep -from typing import Generic, List, Optional, Type, TypeVar, cast +from typing import Any, Generic, List, Optional, Protocol, Type, TypeVar, cast from ..config import ParallelConfig from ..status import Status @@ -13,6 +12,24 @@ logger = logging.getLogger(__name__) +Result = TypeVar("Result") # Avoids circular import with ValuationResult + + +class QueueType(Protocol): + def put( + self, item: Any, block: bool = True, timeout: Optional[float] = None + ) -> None: + ... + + def get(self, block: bool = True, timeout: Optional[float] = None) -> Any: + ... + + def empty(self) -> bool: + ... + + def shutdown(self, force: bool = False, grace_period_s: int = 5) -> None: + ... + class RayActorWrapper: """Wrapper to call methods of remote Ray actors as if they were local. @@ -67,29 +84,21 @@ def wrapper( setattr(self, name, remote_caller(name)) -Result = TypeVar("Result") # Avoids circular import with ValuationResult - - class Coordinator(Generic[Result], abc.ABC): """The coordinator has two main tasks: aggregating the results of the workers and terminating the process once a certain accuracy or total number of iterations is reached. + + :param queue: Used by workers to report their results to the coordinator. """ _status: Status - def __init__(self): - self.worker_results: List[Result] = [] + def __init__(self, queue: QueueType): + self.queue = queue + self.result: Result self._status = Status.Pending - def add_results(self, results: Result): - """Used by workers to report their results. Stores the results directly - into :attr:`worker_results` - - :param results: results of worker's calculations - """ - self.worker_results.append(results) - # this should be a @property, but with it ray.get messes up def is_done(self) -> bool: """Used by workers to check whether to terminate their process. @@ -99,38 +108,38 @@ def is_done(self) -> bool: return bool(self._status) @abc.abstractmethod - def accumulate(self) -> Result: - """Aggregates the results of the different workers.""" + def check_convergence(self) -> bool: + """Evaluates the convergence criteria on the aggregated results.""" raise NotImplementedError() @abc.abstractmethod - def check_convergence(self) -> bool: - """Evaluates the convergence criteria on the aggregated results.""" + def run(self, *args, **kwargs): + """Runs the coordinator.""" raise NotImplementedError() class Worker(abc.ABC): - """A worker, it should work.""" + """Abstract worker class for use with TMCS. + + :param queue: Used by workers to report their results to the coordinator. + :param worker_id: id used for reporting through maybe_progress. + :param update_period: interval in seconds between different updates + to and from the coordinator. + """ def __init__( self, - coordinator: Coordinator, + queue: QueueType, worker_id: int, *, update_period: int = 30, ): - """A worker - - :param coordinator: worker results will be pushed to this coordinator - :param worker_id: id used for reporting through maybe_progress - :param update_period: interval in seconds between different updates - to and from the coordinator - """ super().__init__() + self.queue = queue self.worker_id = worker_id - self.coordinator = coordinator self.update_period = update_period + @abc.abstractmethod def run(self, *args, **kwargs): """Runs the worker.""" raise NotImplementedError() diff --git a/src/pydvl/value/shapley/actor.py b/src/pydvl/value/shapley/actor.py index b79d4edc6..b466533ac 100644 --- a/src/pydvl/value/shapley/actor.py +++ b/src/pydvl/value/shapley/actor.py @@ -6,16 +6,15 @@ """ import logging -import operator -from functools import reduce from time import time from typing import cast import numpy as np +from ray.util.queue import Empty, Queue from pydvl.utils.config import ParallelConfig from pydvl.utils.parallel import init_parallel_backend -from pydvl.utils.parallel.actor import Coordinator, RayActorWrapper, Worker +from pydvl.utils.parallel.actor import Coordinator, QueueType, RayActorWrapper, Worker from pydvl.utils.utility import Utility from pydvl.value.result import ValuationResult from pydvl.value.shapley.truncated import TruncationPolicy @@ -27,6 +26,16 @@ logger = logging.getLogger(__name__) +def get_shapley_queue( + maxsize: int, config: ParallelConfig = ParallelConfig() +) -> QueueType: + if config.backend == "ray": + queue = Queue(maxsize=maxsize) + else: + raise NotImplementedError(f"Unexpected parallel type {config.backend}") + return queue + + def get_shapley_coordinator( *args, config: ParallelConfig = ParallelConfig(), **kwargs ) -> "ShapleyCoordinator": @@ -35,8 +44,6 @@ def get_shapley_coordinator( ShapleyCoordinator, RayActorWrapper(ShapleyCoordinator, config, *args, **kwargs), ) - elif config.backend == "sequential": - coordinator = ShapleyCoordinator(*args, **kwargs) else: raise NotImplementedError(f"Unexpected parallel type {config.backend}") return coordinator @@ -51,8 +58,6 @@ def get_shapley_worker( worker = cast( ShapleyWorker, RayActorWrapper(ShapleyWorker, config, u_id, *args, **kwargs) ) - elif config.backend == "sequential": - worker = ShapleyWorker(u_id, *args, **kwargs) else: raise NotImplementedError(f"Unexpected parallel type {config.backend}") return worker @@ -60,33 +65,25 @@ def get_shapley_worker( class ShapleyCoordinator(Coordinator): """The coordinator has two main tasks: aggregating the results of the - workers and terminating processes once a certain stopping criterion is + workers and shutting down the queue once a certain stopping criterion is satisfied. + + :param queue: Used by workers to report their results to the coordinator. + :param done: Stopping criterion. + :param update_period: Interval in seconds in-between convergence checks. """ - def __init__(self, done: StoppingCriterion): - super().__init__() + def __init__( + self, queue: QueueType, done: StoppingCriterion, *, update_period: int = 10 + ): + super().__init__(queue=queue) + self.update_period = update_period + self.result = ValuationResult.empty() self.results_done = done self.results_done.modify_result = True - def accumulate(self) -> ValuationResult: - """Accumulates all results received from the workers. - - :return: Values and standard errors in a - :class:`~pydvl.value.result.ValuationResult`. If no worker has - reported yet, returns ``None``. - """ - if len(self.worker_results) == 0: - return ValuationResult.empty() # type: ignore - - # FIXME: inefficient, possibly unstable - totals: ValuationResult = reduce(operator.add, self.worker_results) - # Avoid recomputing - self.worker_results = [totals] - return totals - def check_convergence(self) -> bool: - """Evaluates the convergence criterion on the accumulated results. + """Evaluates the convergence criterion on the aggregated results. If the convergence criterion is satisfied, calls to :meth:`~Coordinator.is_done` return ``True``. @@ -95,15 +92,45 @@ def check_convergence(self) -> bool: """ if self.is_done(): return True - if len(self.worker_results) > 0: - self._status = self.results_done(self.accumulate()) + self._status = self.results_done(self.result) return self.is_done() + def run(self, *args, **kwargs) -> ValuationResult: + """Runs the coordinator.""" + start_time = time() + while True: + while (time() - start_time) < self.update_period: + try: + worker_result: ValuationResult = self.queue.get( + block=True, timeout=30 + ) + self.result += worker_result + except Empty: + break + start_time = time() + self._status = self.results_done(self.result) + if self.check_convergence(): + break + self.queue.shutdown() + return self.result # type: ignore + class ShapleyWorker(Worker): - """A worker. + """A worker calculates Shapley values using the permutation definition, + aggregates the results and puts them in the queue every + `update_period` seconds until it is closed by the coordinator. + + To implement early stopping, workers can be signaled by the + :class:`~pydvl.value.shapley.actor.ShapleyCoordinator` before they are + done with their work package. - It should work. + + :param u: Utility object with model, data, and scoring function + :param queue: Used by workers to report their results to the coordinator. + :param truncation: callable that decides whether to stop computing + marginals for a given permutation. + :param worker_id: id used for reporting through maybe_progress + :param update_period: interval in seconds in-between updates to the queue. """ algorithm: str = "truncated_montecarlo_shapley" @@ -111,7 +138,7 @@ class ShapleyWorker(Worker): def __init__( self, u: Utility, - coordinator: ShapleyCoordinator, + queue: QueueType, *, truncation: TruncationPolicy, worker_id: int, @@ -132,9 +159,7 @@ def __init__( :param truncation: callable that decides whether to stop computing marginals for a given permutation. """ - super().__init__( - coordinator=coordinator, update_period=update_period, worker_id=worker_id - ) + super().__init__(queue=queue, update_period=update_period, worker_id=worker_id) self.u = u self.truncation = truncation @@ -154,18 +179,13 @@ def run(self, *args, **kwargs): This calls :meth:`_compute_marginals` repeatedly calculating Shapley values on different permutations of the indices. After :attr:`update_period` - seconds have passed, it reports the results to the - :class:`~pydvl.value.shapley.actor.ShapleyCoordinator`. Before starting - the next iteration, it checks the coordinator's - :meth:`~pydvl.utils.parallel.actor.Coordinator.is_done` flag, - terminating if it's ``True``. + seconds have passed, it puts the results in the queue. + The loop is terminated if the queue is closed by the coordinator. """ while True: acc = ValuationResult.empty() start_time = time() while (time() - start_time) < self.update_period: - if self.coordinator.is_done(): - return results = self._compute_marginals() nans = np.isnan(results.values).sum() if nans > 0: @@ -175,4 +195,7 @@ def run(self, *args, **kwargs): ) continue acc += results - self.coordinator.add_results(acc) + try: + self.queue.put(acc, block=True, timeout=30) + except Exception: + break diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 26649d931..999687600 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -208,7 +208,7 @@ def truncated_montecarlo_shapley( """ # Avoid circular imports - from .actor import get_shapley_coordinator, get_shapley_worker + from .actor import get_shapley_coordinator, get_shapley_queue, get_shapley_worker if config.backend == "sequential": raise NotImplementedError( @@ -216,12 +216,14 @@ def truncated_montecarlo_shapley( "the Sequential parallel backend." ) - coordinator = get_shapley_coordinator(config=config, done=done) # type: ignore + queue = get_shapley_queue(maxsize=100, config=config) + + coordinator = get_shapley_coordinator(config=config, update_period=coordinator_update_period, queue=queue, done=done) # type: ignore workers = [ get_shapley_worker( # type: ignore u, - coordinator=coordinator, + queue=queue, truncation=truncation, worker_id=worker_id, update_period=worker_update_period, @@ -232,19 +234,6 @@ def truncated_montecarlo_shapley( for worker in workers: worker.run(block=False) - while not coordinator.check_convergence(): - sleep(coordinator_update_period) - - return coordinator.accumulate() - - # Something like this would be nicer, but it doesn't seem to be possible - # to start the workers from the coordinator. - # coordinator.add_workers( - # n_workers=n_jobs, - # u=u_id, - # update_period=worker_update_period, - # config=config, - # truncation=truncation, - # ) - # - # return coordinator.run(delay=coordinator_update_period) + result = coordinator.run(block=True) + + return result From 215246a89c79bcb1918da833d187da6134f80f0f Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 15 Mar 2023 21:10:54 +0100 Subject: [PATCH 03/65] Instantiate all shapley workers inside get_shapley_workers --- src/pydvl/value/shapley/actor.py | 23 +++++++++------ src/pydvl/value/shapley/truncated.py | 43 ++++++++++++++++------------ 2 files changed, 39 insertions(+), 27 deletions(-) diff --git a/src/pydvl/value/shapley/actor.py b/src/pydvl/value/shapley/actor.py index b466533ac..219dd233d 100644 --- a/src/pydvl/value/shapley/actor.py +++ b/src/pydvl/value/shapley/actor.py @@ -7,7 +7,7 @@ import logging from time import time -from typing import cast +from typing import Sequence, cast import numpy as np from ray.util.queue import Empty, Queue @@ -20,7 +20,7 @@ from pydvl.value.shapley.truncated import TruncationPolicy from pydvl.value.stopping import MaxChecks, StoppingCriterion -__all__ = ["get_shapley_coordinator", "get_shapley_worker"] +__all__ = ["get_shapley_queue", "get_shapley_coordinator", "get_shapley_workers"] logger = logging.getLogger(__name__) @@ -49,18 +49,23 @@ def get_shapley_coordinator( return coordinator -def get_shapley_worker( - u: Utility, *args, config: ParallelConfig = ParallelConfig(), **kwargs -) -> "ShapleyWorker": +def get_shapley_workers( + u: Utility, *args, n_jobs: int, config: ParallelConfig = ParallelConfig(), **kwargs +) -> Sequence["ShapleyWorker"]: parallel_backend = init_parallel_backend(config) u_id = parallel_backend.put(u) if config.backend == "ray": - worker = cast( - ShapleyWorker, RayActorWrapper(ShapleyWorker, config, u_id, *args, **kwargs) - ) + workers = [] + for worker_id in range(parallel_backend.effective_n_jobs(n_jobs)): + workers.append( + cast( + ShapleyWorker, + RayActorWrapper(ShapleyWorker, config, u_id, *args, **kwargs), + ) + ) else: raise NotImplementedError(f"Unexpected parallel type {config.backend}") - return worker + return workers class ShapleyCoordinator(Coordinator): diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 999687600..0189da55f 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -1,10 +1,9 @@ import abc import logging -from time import sleep import numpy as np -from pydvl.utils import ParallelConfig, Utility, effective_n_jobs, running_moments +from pydvl.utils import ParallelConfig, Utility, running_moments from pydvl.value import ValuationResult from pydvl.value.stopping import StoppingCriterion @@ -166,6 +165,8 @@ def truncated_montecarlo_shapley( config: ParallelConfig = ParallelConfig(), coordinator_update_period: int = 10, worker_update_period: int = 5, + queue_timeout: int = 30, + max_queue_size: int = 100, ) -> ValuationResult: """Monte Carlo approximation to the Shapley value of data points. @@ -204,11 +205,14 @@ def truncated_montecarlo_shapley( accumulated results from the workers for convergence. :param worker_update_period: interval in seconds between different updates to and from the coordinator + :param queue_timeout: Interval of time after which an operation + on the queue will timeout. + :param max_queue_size: Size of the queue. :return: Object with the data values. """ # Avoid circular imports - from .actor import get_shapley_coordinator, get_shapley_queue, get_shapley_worker + from .actor import get_shapley_coordinator, get_shapley_queue, get_shapley_workers if config.backend == "sequential": raise NotImplementedError( @@ -216,21 +220,24 @@ def truncated_montecarlo_shapley( "the Sequential parallel backend." ) - queue = get_shapley_queue(maxsize=100, config=config) - - coordinator = get_shapley_coordinator(config=config, update_period=coordinator_update_period, queue=queue, done=done) # type: ignore - - workers = [ - get_shapley_worker( # type: ignore - u, - queue=queue, - truncation=truncation, - worker_id=worker_id, - update_period=worker_update_period, - config=config, - ) - for worker_id in range(effective_n_jobs(n_jobs, config=config)) - ] + queue = get_shapley_queue(maxsize=max_queue_size, config=config) + + coordinator = get_shapley_coordinator( + update_period=coordinator_update_period, + queue_timeout=queue_timeout, + queue=queue, + done=done, + config=config, + ) # type: ignore + + workers = get_shapley_workers( + u, + queue=queue, + truncation=truncation, + update_period=worker_update_period, + config=config, + n_jobs=n_jobs, + ) for worker in workers: worker.run(block=False) From ca25ed43cf552267604259578a3f9b3cd7aa342b Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 15 Mar 2023 23:04:40 +0100 Subject: [PATCH 04/65] Add queue timeout parameter --- src/pydvl/utils/parallel/actor.py | 15 +++++-- src/pydvl/value/shapley/actor.py | 63 +++++++++++++--------------- src/pydvl/value/shapley/truncated.py | 18 ++++---- 3 files changed, 51 insertions(+), 45 deletions(-) diff --git a/src/pydvl/utils/parallel/actor.py b/src/pydvl/utils/parallel/actor.py index bd6bc219b..6170deebd 100644 --- a/src/pydvl/utils/parallel/actor.py +++ b/src/pydvl/utils/parallel/actor.py @@ -90,12 +90,15 @@ class Coordinator(Generic[Result], abc.ABC): number of iterations is reached. :param queue: Used by workers to report their results to the coordinator. + :param queue_timeout: Interval of time after which an operation + on the queue will time out. """ _status: Status - def __init__(self, queue: QueueType): + def __init__(self, queue: QueueType, queue_timeout: int = 30): self.queue = queue + self.queue_timeout = queue_timeout self.result: Result self._status = Status.Pending @@ -110,12 +113,12 @@ def is_done(self) -> bool: @abc.abstractmethod def check_convergence(self) -> bool: """Evaluates the convergence criteria on the aggregated results.""" - raise NotImplementedError() + ... @abc.abstractmethod def run(self, *args, **kwargs): """Runs the coordinator.""" - raise NotImplementedError() + ... class Worker(abc.ABC): @@ -125,6 +128,8 @@ class Worker(abc.ABC): :param worker_id: id used for reporting through maybe_progress. :param update_period: interval in seconds between different updates to and from the coordinator. + :param queue_timeout: Interval of time after which an operation + on the queue will time out. """ def __init__( @@ -133,13 +138,15 @@ def __init__( worker_id: int, *, update_period: int = 30, + queue_timeout: int = 30, ): super().__init__() self.queue = queue self.worker_id = worker_id self.update_period = update_period + self.queue_timeout = queue_timeout @abc.abstractmethod def run(self, *args, **kwargs): """Runs the worker.""" - raise NotImplementedError() + ... diff --git a/src/pydvl/value/shapley/actor.py b/src/pydvl/value/shapley/actor.py index 219dd233d..09218f6c8 100644 --- a/src/pydvl/value/shapley/actor.py +++ b/src/pydvl/value/shapley/actor.py @@ -13,8 +13,8 @@ from ray.util.queue import Empty, Queue from pydvl.utils.config import ParallelConfig -from pydvl.utils.parallel import init_parallel_backend from pydvl.utils.parallel.actor import Coordinator, QueueType, RayActorWrapper, Worker +from pydvl.utils.parallel.backend import RayParallelBackend, init_parallel_backend from pydvl.utils.utility import Utility from pydvl.value.result import ValuationResult from pydvl.value.shapley.truncated import TruncationPolicy @@ -40,10 +40,9 @@ def get_shapley_coordinator( *args, config: ParallelConfig = ParallelConfig(), **kwargs ) -> "ShapleyCoordinator": if config.backend == "ray": - coordinator = cast( - ShapleyCoordinator, - RayActorWrapper(ShapleyCoordinator, config, *args, **kwargs), - ) + parallel_backend = cast(RayParallelBackend, init_parallel_backend(config)) + remote_cls = parallel_backend.wrap(ShapleyCoordinator) + coordinator = remote_cls(*args, **kwargs) else: raise NotImplementedError(f"Unexpected parallel type {config.backend}") return coordinator @@ -57,12 +56,10 @@ def get_shapley_workers( if config.backend == "ray": workers = [] for worker_id in range(parallel_backend.effective_n_jobs(n_jobs)): - workers.append( - cast( - ShapleyWorker, - RayActorWrapper(ShapleyWorker, config, u_id, *args, **kwargs), - ) - ) + parallel_backend = cast(RayParallelBackend, init_parallel_backend(config)) + remote_cls = parallel_backend.wrap(ShapleyWorker) + worker = remote_cls(u_id, *args, worker_id=worker_id, **kwargs) + workers.append(worker) else: raise NotImplementedError(f"Unexpected parallel type {config.backend}") return workers @@ -76,16 +73,23 @@ class ShapleyCoordinator(Coordinator): :param queue: Used by workers to report their results to the coordinator. :param done: Stopping criterion. :param update_period: Interval in seconds in-between convergence checks. + :param queue_timeout: Interval of time after which an operation + on the queue will time out. """ def __init__( - self, queue: QueueType, done: StoppingCriterion, *, update_period: int = 10 + self, + queue: QueueType, + done: StoppingCriterion, + *, + update_period: int = 10, + queue_timeout: int = 30, ): - super().__init__(queue=queue) - self.update_period = update_period - self.result = ValuationResult.empty() + super().__init__(queue=queue, queue_timeout=queue_timeout) self.results_done = done self.results_done.modify_result = True + self.update_period = update_period + self.result = ValuationResult.empty() def check_convergence(self) -> bool: """Evaluates the convergence criterion on the aggregated results. @@ -107,7 +111,7 @@ def run(self, *args, **kwargs) -> ValuationResult: while (time() - start_time) < self.update_period: try: worker_result: ValuationResult = self.queue.get( - block=True, timeout=30 + block=True, timeout=self.queue_timeout ) self.result += worker_result except Empty: @@ -136,6 +140,8 @@ class ShapleyWorker(Worker): marginals for a given permutation. :param worker_id: id used for reporting through maybe_progress :param update_period: interval in seconds in-between updates to the queue. + :param queue_timeout: Interval of time after which an operation + on the queue will time out. """ algorithm: str = "truncated_montecarlo_shapley" @@ -148,23 +154,14 @@ def __init__( truncation: TruncationPolicy, worker_id: int, update_period: int = 30, + queue_timeout: int = 30, ): - """A worker calculates Shapley values using the permutation definition - and reports the results to the coordinator. - - To implement early stopping, workers can be signaled by the - :class:`~pydvl.value.shapley.actor.ShapleyCoordinator` before they are - done with their work package - - :param u: Utility object with model, data, and scoring function - :param coordinator: worker results will be pushed to this coordinator - :param worker_id: id used for reporting through maybe_progress - :param update_period: interval in seconds between different updates to - and from the coordinator - :param truncation: callable that decides whether to stop computing - marginals for a given permutation. - """ - super().__init__(queue=queue, update_period=update_period, worker_id=worker_id) + super().__init__( + queue=queue, + queue_timeout=queue_timeout, + update_period=update_period, + worker_id=worker_id, + ) self.u = u self.truncation = truncation @@ -201,6 +198,6 @@ def run(self, *args, **kwargs): continue acc += results try: - self.queue.put(acc, block=True, timeout=30) + self.queue.put(acc, block=True, timeout=self.queue_timeout) except Exception: break diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 0189da55f..57b011ffd 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -3,7 +3,7 @@ import numpy as np -from pydvl.utils import ParallelConfig, Utility, running_moments +from pydvl.utils import ParallelConfig, Utility, init_parallel_backend, running_moments from pydvl.value import ValuationResult from pydvl.value.stopping import StoppingCriterion @@ -163,9 +163,9 @@ def truncated_montecarlo_shapley( truncation: TruncationPolicy, n_jobs: int = 1, config: ParallelConfig = ParallelConfig(), - coordinator_update_period: int = 10, - worker_update_period: int = 5, - queue_timeout: int = 30, + coordinator_update_period: int = 30, + worker_update_period: int = 10, + queue_timeout: int = 5, max_queue_size: int = 100, ) -> ValuationResult: """Monte Carlo approximation to the Shapley value of data points. @@ -206,7 +206,7 @@ def truncated_montecarlo_shapley( :param worker_update_period: interval in seconds between different updates to and from the coordinator :param queue_timeout: Interval of time after which an operation - on the queue will timeout. + on the queue will time out. :param max_queue_size: Size of the queue. :return: Object with the data values. @@ -220,6 +220,8 @@ def truncated_montecarlo_shapley( "the Sequential parallel backend." ) + parallel_backend = init_parallel_backend(config) + queue = get_shapley_queue(maxsize=max_queue_size, config=config) coordinator = get_shapley_coordinator( @@ -228,7 +230,7 @@ def truncated_montecarlo_shapley( queue=queue, done=done, config=config, - ) # type: ignore + ) workers = get_shapley_workers( u, @@ -239,8 +241,8 @@ def truncated_montecarlo_shapley( n_jobs=n_jobs, ) for worker in workers: - worker.run(block=False) + worker.run.remote() - result = coordinator.run(block=True) + result = parallel_backend.get(coordinator.run.remote(), timeout=300) return result From 41990988ff2ef5392ad5c87b65dbf6c707668cce Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 16 Mar 2023 22:01:30 +0100 Subject: [PATCH 05/65] Create separate test module for tmcs --- tests/value/shapley/test_montecarlo.py | 33 +---- tests/value/shapley/test_truncated.py | 163 +++++++++++++++++++++++++ 2 files changed, 164 insertions(+), 32 deletions(-) create mode 100644 tests/value/shapley/test_truncated.py diff --git a/tests/value/shapley/test_montecarlo.py b/tests/value/shapley/test_montecarlo.py index e91f4bb9a..0f92cde29 100644 --- a/tests/value/shapley/test_montecarlo.py +++ b/tests/value/shapley/test_montecarlo.py @@ -10,8 +10,7 @@ from pydvl.value import compute_shapley_values from pydvl.value.shapley import ShapleyMode from pydvl.value.shapley.naive import combinatorial_exact_shapley -from pydvl.value.shapley.truncated import NoTruncation -from pydvl.value.stopping import HistoryDeviation, MaxChecks, MaxUpdates +from pydvl.value.stopping import MaxChecks, MaxUpdates from .. import check_rank_correlation, check_total_value, check_values @@ -31,18 +30,6 @@ 1e-4, {"done": MaxUpdates(2**10)}, ), - ( - 12, - ShapleyMode.TruncatedMontecarlo, - 0.1, - 1e-5, - dict( - coordinator_update_period=1, - worker_update_period=0.5, - done=MaxUpdates(500), - truncation=NoTruncation(), - ), - ), (12, ShapleyMode.Owen, 0.1, 1e-4, dict(n_samples=4, max_q=200)), (12, ShapleyMode.OwenAntithetic, 0.1, 1e-4, dict(n_samples=4, max_q=200)), ( @@ -111,15 +98,6 @@ def test_hoeffding_bound_montecarlo( [ # FIXME: Hoeffding says 400 should be enough (ShapleyMode.PermutationMontecarlo, dict(done=MaxUpdates(600))), - ( - ShapleyMode.TruncatedMontecarlo, - dict( - coordinator_update_period=0.2, - worker_update_period=0.1, - done=MaxUpdates(500), - truncation=NoTruncation(), - ), - ), (ShapleyMode.CombinatorialMontecarlo, dict(done=MaxUpdates(2**11))), (ShapleyMode.Owen, dict(n_samples=2, max_q=300)), (ShapleyMode.OwenAntithetic, dict(n_samples=2, max_q=300)), @@ -174,15 +152,6 @@ def test_linear_montecarlo_shapley( "fun, kwargs", [ (ShapleyMode.PermutationMontecarlo, {"done": MaxUpdates(500)}), - ( - ShapleyMode.TruncatedMontecarlo, - dict( - coordinator_update_period=0.2, - worker_update_period=0.1, - done=HistoryDeviation(n_steps=10, rtol=0.1) | MaxUpdates(500), - truncation=NoTruncation(), - ), - ), (ShapleyMode.Owen, dict(n_samples=4, max_q=400)), (ShapleyMode.OwenAntithetic, dict(n_samples=4, max_q=400)), ( diff --git a/tests/value/shapley/test_truncated.py b/tests/value/shapley/test_truncated.py new file mode 100644 index 000000000..5345531fa --- /dev/null +++ b/tests/value/shapley/test_truncated.py @@ -0,0 +1,163 @@ +import logging + +import numpy as np +import pytest +from sklearn.linear_model import LinearRegression + +from pydvl.utils import MemcachedConfig, Status, Utility +from pydvl.utils.score import Scorer, squashed_r2 +from pydvl.value import compute_shapley_values +from pydvl.value.shapley import ShapleyMode +from pydvl.value.shapley.truncated import NoTruncation +from pydvl.value.stopping import HistoryDeviation, MaxUpdates + +from .. import check_total_value, check_values + +log = logging.getLogger(__name__) + + +# noinspection PyTestParametrized +@pytest.mark.parametrize( + "num_samples, fun, rtol, atol, kwargs", + [ + ( + 12, + ShapleyMode.TruncatedMontecarlo, + 0.1, + 1e-5, + dict( + coordinator_update_period=1, + worker_update_period=0.5, + done=MaxUpdates(500), + truncation=NoTruncation(), + ), + ), + ], +) +def test_tmcs_analytic_montecarlo_shapley( + num_samples, + analytic_shapley, + parallel_config, + n_jobs, + fun: ShapleyMode, + rtol: float, + atol: float, + kwargs: dict, +): + u, exact_values = analytic_shapley + + values = compute_shapley_values( + u, mode=fun, n_jobs=n_jobs, config=parallel_config, progress=False, **kwargs + ) + + check_values(values, exact_values, rtol=rtol, atol=atol) + + +@pytest.mark.parametrize( + "a, b, num_points", [(2, 0, 21)] # training set will have 0.3 * 21 = 6 samples +) +@pytest.mark.parametrize("scorer, rtol", [(squashed_r2, 0.25)]) +@pytest.mark.parametrize( + "fun, kwargs", + [ + ( + ShapleyMode.TruncatedMontecarlo, + dict( + coordinator_update_period=0.2, + worker_update_period=0.1, + done=MaxUpdates(500), + truncation=NoTruncation(), + ), + ), + ], +) +def test_tmcs_linear_montecarlo_shapley( + linear_shapley, + n_jobs, + memcache_client_config, + scorer: Scorer, + rtol: float, + fun: ShapleyMode, + kwargs: dict, +): + """Tests values for all methods using a linear dataset. + + For permutation and truncated montecarlo, the rtol for each scorer is chosen + so that the number of samples selected is just above the (ε,δ) bound for ε = + rtol, δ=0.001 and the range corresponding to each score. This means that + roughly once every 1000/num_methods runs the test will fail. + + FIXME: + - For permutation, we must increase the number of samples above that what + is done for truncated, this is probably due to the averaging done by the + latter to reduce variance + - We don't have a bound for Owen. + NOTE: + - The variance in the combinatorial method is huge, so we need lots of + samples + + """ + u, exact_values = linear_shapley + check_total_value(u, exact_values, rtol=rtol) + + values = compute_shapley_values( + u, mode=fun, progress=False, n_jobs=n_jobs, **kwargs + ) + + check_values(values, exact_values, rtol=rtol) + check_total_value(u, values, rtol=rtol) # FIXME, could be more than rtol + + +@pytest.mark.parametrize( + "a, b, num_points", [(2, 0, 21)] # training set will have 0.3 * 21 ~= 6 samples +) +@pytest.mark.parametrize("scorer, total_atol", [(squashed_r2, 0.2)]) +@pytest.mark.parametrize( + "fun, kwargs", + [ + ( + ShapleyMode.TruncatedMontecarlo, + dict( + coordinator_update_period=0.2, + worker_update_period=0.1, + done=HistoryDeviation(n_steps=10, rtol=0.1) | MaxUpdates(500), + truncation=NoTruncation(), + ), + ), + ], +) +def test_tmcs_linear_montecarlo_with_outlier( + linear_dataset, + n_jobs, + memcache_client_config, + scorer: Scorer, + total_atol: float, + fun, + kwargs: dict, +): + """Tests whether valuation methods are able to detect an obvious outlier. + + A point is selected at random from a linear dataset and the dependent + variable is set to 10 standard deviations. + + Note that this implies that the whole dataset will have very low utility: + e.g. for R^2 it will be very negative. The larger the range of the utility, + the more samples are required for the Monte Carlo approximations to converge, + as indicated by the Hoeffding bound. + """ + outlier_idx = np.random.randint(len(linear_dataset.y_train)) + linear_dataset.y_train[outlier_idx] = np.std(linear_dataset.y_train) * 10 + linear_utility = Utility( + LinearRegression(), + data=linear_dataset, + scorer=scorer, + cache_options=MemcachedConfig(client_config=memcache_client_config), + ) + values = compute_shapley_values( + linear_utility, mode=fun, progress=False, n_jobs=n_jobs, **kwargs + ) + values.sort() + + assert values.status == Status.Converged + check_total_value(linear_utility, values, atol=total_atol) + assert values[0].index == outlier_idx From cccd7a5ac5a88b950e6bb8df43f481be8f96a28a Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 17 Mar 2023 19:15:03 +0100 Subject: [PATCH 06/65] Delete actors code, Add new abstraction based on the concurrent futures interface --- src/pydvl/utils/parallel/actor.py | 152 -------------------------- src/pydvl/utils/parallel/backend.py | 1 - src/pydvl/utils/parallel/futures.py | 55 ++++++++++ src/pydvl/utils/utility.py | 3 +- src/pydvl/value/shapley/truncated.py | 121 ++++++++++++-------- tests/value/shapley/test_truncated.py | 9 +- 6 files changed, 135 insertions(+), 206 deletions(-) delete mode 100644 src/pydvl/utils/parallel/actor.py create mode 100644 src/pydvl/utils/parallel/futures.py diff --git a/src/pydvl/utils/parallel/actor.py b/src/pydvl/utils/parallel/actor.py deleted file mode 100644 index 6170deebd..000000000 --- a/src/pydvl/utils/parallel/actor.py +++ /dev/null @@ -1,152 +0,0 @@ -import abc -import inspect -import logging -from typing import Any, Generic, List, Optional, Protocol, Type, TypeVar, cast - -from ..config import ParallelConfig -from ..status import Status -from .backend import RayParallelBackend, init_parallel_backend - -__all__ = ["RayActorWrapper", "Coordinator", "Worker"] - - -logger = logging.getLogger(__name__) - -Result = TypeVar("Result") # Avoids circular import with ValuationResult - - -class QueueType(Protocol): - def put( - self, item: Any, block: bool = True, timeout: Optional[float] = None - ) -> None: - ... - - def get(self, block: bool = True, timeout: Optional[float] = None) -> Any: - ... - - def empty(self) -> bool: - ... - - def shutdown(self, force: bool = False, grace_period_s: int = 5) -> None: - ... - - -class RayActorWrapper: - """Wrapper to call methods of remote Ray actors as if they were local. - - Taken almost verbatim from: - https://github.com/JaneliaSciComp/ray-janelia/blob/main/remote_as_local_wrapper.py - - :Example: - - >>> from pydvl.utils.parallel.backend import RayParallelBackend, init_parallel_backend - >>> from pydvl.utils.config import ParallelConfig - >>> from pydvl.utils.parallel.actor import RayActorWrapper - >>> class Actor: - ... def __init__(self, x): - ... self.x = x - ... - ... def get(self): - ... return self.x - ... - >>> config = ParallelConfig(backend="ray") - >>> wrapped_actor = RayActorWrapper(Actor, config, 5) - >>> wrapped_actor.get() - 5 - """ - - def __init__(self, actor_class: Type, config: ParallelConfig, *args, **kwargs): - parallel_backend = cast(RayParallelBackend, init_parallel_backend(config)) - remote_cls = parallel_backend.wrap(actor_class) - self.actor_handle = remote_cls(*args, **kwargs) - - def remote_caller(method_name: str): - # Wrapper for remote class' methods to mimic local calls - def wrapper( - *args, block: bool = True, timeout: Optional[float] = None, **kwargs - ): - obj_ref = getattr(self.actor_handle, method_name).remote( - *args, **kwargs - ) - if block: - return parallel_backend.get( - obj_ref, timeout=timeout - ) # Block until called method returns. - else: - return obj_ref # Don't block and return a future. - - return wrapper - - for member in inspect.getmembers(actor_class): - name = member[0] - if not name.startswith("__"): - # Wrap public methods for remote-as-local calls. - setattr(self, name, remote_caller(name)) - - -class Coordinator(Generic[Result], abc.ABC): - """The coordinator has two main tasks: aggregating the results of the - workers and terminating the process once a certain accuracy or total - number of iterations is reached. - - :param queue: Used by workers to report their results to the coordinator. - :param queue_timeout: Interval of time after which an operation - on the queue will time out. - """ - - _status: Status - - def __init__(self, queue: QueueType, queue_timeout: int = 30): - self.queue = queue - self.queue_timeout = queue_timeout - self.result: Result - self._status = Status.Pending - - # this should be a @property, but with it ray.get messes up - def is_done(self) -> bool: - """Used by workers to check whether to terminate their process. - - :return: ``True`` if workers must terminate, ``False`` otherwise. - """ - return bool(self._status) - - @abc.abstractmethod - def check_convergence(self) -> bool: - """Evaluates the convergence criteria on the aggregated results.""" - ... - - @abc.abstractmethod - def run(self, *args, **kwargs): - """Runs the coordinator.""" - ... - - -class Worker(abc.ABC): - """Abstract worker class for use with TMCS. - - :param queue: Used by workers to report their results to the coordinator. - :param worker_id: id used for reporting through maybe_progress. - :param update_period: interval in seconds between different updates - to and from the coordinator. - :param queue_timeout: Interval of time after which an operation - on the queue will time out. - """ - - def __init__( - self, - queue: QueueType, - worker_id: int, - *, - update_period: int = 30, - queue_timeout: int = 30, - ): - super().__init__() - self.queue = queue - self.worker_id = worker_id - self.update_period = update_period - self.queue_timeout = queue_timeout - - @abc.abstractmethod - def run(self, *args, **kwargs): - """Runs the worker.""" - ... diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index a973b91ed..b7e146d35 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -16,7 +16,6 @@ import ray from ray import ObjectRef -from ray.remote_function import RemoteFunction from ..config import ParallelConfig diff --git a/src/pydvl/utils/parallel/futures.py b/src/pydvl/utils/parallel/futures.py new file mode 100644 index 000000000..02c939baa --- /dev/null +++ b/src/pydvl/utils/parallel/futures.py @@ -0,0 +1,55 @@ +from concurrent.futures import Executor, Future +from contextlib import contextmanager, nullcontext +from dataclasses import asdict +from typing import Callable, Generator +from weakref import WeakSet + +import ray + +from ..config import ParallelConfig +from .backend import effective_n_jobs + +__all__ = ["init_executor", "RayExecutor"] + + +@contextmanager +def init_executor( + max_workers: int, config: ParallelConfig +) -> Generator[Executor, None, None]: + if config.backend == "ray": + max_workers = effective_n_jobs(max_workers, config=config) + executor = RayExecutor(max_workers, config) + else: + raise NotImplementedError(f"Unexpected parallel type {config.backend}") + yield executor + + +class RayExecutor(Executor): + def __init__(self, max_workers: int, config: ParallelConfig): + if config.backend != "ray": + raise ValueError( + f"Parallel backend must be set to 'ray' and not {config.backend}" + ) + self.max_workers = max_workers + self.futures: "WeakSet[Future]" = WeakSet() + config_dict = asdict(config) + config_dict.pop("backend") + config_dict["num_cpus"] = config_dict.pop("n_local_workers") + self.config = config_dict + if not ray.is_initialized(): + ray.init(**self.config) + + def submit(self, fn: Callable, /, *args, **kwargs) -> Future: + remote_fn = ray.remote(fn) + ref = remote_fn.remote(*args, **kwargs) + future = ref.future() + self.futures.add(future) + return future + + def shutdown(self, wait: bool = True, *, cancel_futures: bool = False) -> None: + if cancel_futures: + for future in self.futures: + future.cancel() + if wait: + for future in self.futures: + future.result() diff --git a/src/pydvl/utils/utility.py b/src/pydvl/utils/utility.py index 33b361429..5763edeea 100644 --- a/src/pydvl/utils/utility.py +++ b/src/pydvl/utils/utility.py @@ -294,10 +294,9 @@ def _convert_indices_to_boolean_vector(self, x: Iterable[int]) -> NDArray[np.boo def __call__(self, indices: Iterable[int]) -> float: indices_boolean_vector = self._convert_indices_to_boolean_vector(indices) frozen_indices = frozenset(indices) - if self._current_iteration < self.training_budget: + if len(self._utility_samples) < self.training_budget: utility = self.utility(frozen_indices) self._utility_samples[frozen_indices] = (indices_boolean_vector, utility) - self._current_iteration += 1 else: if not self._is_model_fit: X, y = zip(*self._utility_samples.values()) diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 57b011ffd..7ae013c10 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -1,11 +1,14 @@ import abc import logging +from concurrent.futures import FIRST_COMPLETED, as_completed, wait import numpy as np -from pydvl.utils import ParallelConfig, Utility, init_parallel_backend, running_moments +from pydvl.utils import ParallelConfig, Utility, running_moments +from pydvl.utils.parallel.backend import init_parallel_backend +from pydvl.utils.parallel.futures import init_executor from pydvl.value import ValuationResult -from pydvl.value.stopping import StoppingCriterion +from pydvl.value.stopping import MaxChecks, StoppingCriterion __all__ = [ "TruncationPolicy", @@ -156,17 +159,38 @@ def reset(self): self.variance = self.mean = 0 +def _permutation_montecarlo_one_step( + u: Utility, + truncation: TruncationPolicy, + algorithm: str, +) -> ValuationResult: + # Avoid circular imports + from .montecarlo import _permutation_montecarlo_shapley + + result = _permutation_montecarlo_shapley( + u, + done=MaxChecks(1), + truncation=truncation, + algorithm_name=algorithm, + ) + nans = np.isnan(result.values).sum() + if nans > 0: + logger.warning( + f"{nans} NaN values in current permutation, ignoring. " + "Consider setting a default value for the Scorer" + ) + result = ValuationResult.empty(algorithm="truncated_montecarlo_shapley") + return result + + def truncated_montecarlo_shapley( u: Utility, *, done: StoppingCriterion, truncation: TruncationPolicy, - n_jobs: int = 1, config: ParallelConfig = ParallelConfig(), - coordinator_update_period: int = 30, - worker_update_period: int = 10, - queue_timeout: int = 5, - max_queue_size: int = 100, + n_jobs: int = 1, + n_concurrent_computations: int = 50, ) -> ValuationResult: """Monte Carlo approximation to the Shapley value of data points. @@ -201,48 +225,55 @@ def truncated_montecarlo_shapley( set to :func:`available_cpus`. :param config: Object configuring parallel computation, with cluster address, number of cpus, etc. - :param coordinator_update_period: in seconds. How often to check the - accumulated results from the workers for convergence. - :param worker_update_period: interval in seconds between different - updates to and from the coordinator - :param queue_timeout: Interval of time after which an operation - on the queue will time out. - :param max_queue_size: Size of the queue. + :param n_concurrent_computations: Number of permutation monte carlo iterations + to run concurrently. :return: Object with the data values. """ - # Avoid circular imports - from .actor import get_shapley_coordinator, get_shapley_queue, get_shapley_workers - - if config.backend == "sequential": + if config.backend != "ray": raise NotImplementedError( - "Truncated MonteCarlo Shapley does not work with " - "the Sequential parallel backend." + "Truncated MonteCarlo Shapley only works with " "the Ray parallel backend." ) - parallel_backend = init_parallel_backend(config) - - queue = get_shapley_queue(maxsize=max_queue_size, config=config) + done.modify_result = True + algorithm = "truncated_montecarlo_shapley" - coordinator = get_shapley_coordinator( - update_period=coordinator_update_period, - queue_timeout=queue_timeout, - queue=queue, - done=done, - config=config, - ) - - workers = get_shapley_workers( - u, - queue=queue, - truncation=truncation, - update_period=worker_update_period, - config=config, - n_jobs=n_jobs, - ) - for worker in workers: - worker.run.remote() - - result = parallel_backend.get(coordinator.run.remote(), timeout=300) - - return result + parallel_backend = init_parallel_backend(config) + u = parallel_backend.put(u) + + accumulated_result = ValuationResult.empty(algorithm=algorithm) + + with init_executor(max_workers=n_jobs, config=config) as executor: + futures = set() + # Initial batch of computations + for _ in range(n_concurrent_computations): + future = executor.submit( + _permutation_montecarlo_one_step, + u, + truncation, + algorithm, + ) + futures.add(future) + while futures: + # Wait for the next futures to complete. + completed_futures, futures = wait( + futures, timeout=60, return_when=FIRST_COMPLETED + ) + for future in completed_futures: + accumulated_result += future.result() + if done(accumulated_result): + break + if done(accumulated_result): + break + # Submit more computations + # The goal is to always have `n_concurrent_computations` + # computations running + for _ in range(n_concurrent_computations - len(futures)): + future = executor.submit( + _permutation_montecarlo_one_step, + u, + truncation, + algorithm, + ) + futures.add(future) + return accumulated_result diff --git a/tests/value/shapley/test_truncated.py b/tests/value/shapley/test_truncated.py index 5345531fa..90d53d9ea 100644 --- a/tests/value/shapley/test_truncated.py +++ b/tests/value/shapley/test_truncated.py @@ -26,10 +26,9 @@ 0.1, 1e-5, dict( - coordinator_update_period=1, - worker_update_period=0.5, done=MaxUpdates(500), truncation=NoTruncation(), + n_concurrent_computations=10, ), ), ], @@ -63,10 +62,9 @@ def test_tmcs_analytic_montecarlo_shapley( ( ShapleyMode.TruncatedMontecarlo, dict( - coordinator_update_period=0.2, - worker_update_period=0.1, done=MaxUpdates(500), truncation=NoTruncation(), + n_concurrent_computations=10, ), ), ], @@ -118,10 +116,9 @@ def test_tmcs_linear_montecarlo_shapley( ( ShapleyMode.TruncatedMontecarlo, dict( - coordinator_update_period=0.2, - worker_update_period=0.1, done=HistoryDeviation(n_steps=10, rtol=0.1) | MaxUpdates(500), truncation=NoTruncation(), + n_concurrent_computations=10, ), ), ], From dac64cb8efeab7a75c8977d121a535e182031527 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Sat, 18 Mar 2023 00:27:25 +0100 Subject: [PATCH 07/65] Fix type hint --- src/pydvl/utils/parallel/futures.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/pydvl/utils/parallel/futures.py b/src/pydvl/utils/parallel/futures.py index 02c939baa..3c7e5dd20 100644 --- a/src/pydvl/utils/parallel/futures.py +++ b/src/pydvl/utils/parallel/futures.py @@ -1,7 +1,7 @@ from concurrent.futures import Executor, Future -from contextlib import contextmanager, nullcontext +from contextlib import contextmanager from dataclasses import asdict -from typing import Callable, Generator +from typing import Callable, Generator, TypeVar from weakref import WeakSet import ray @@ -11,6 +11,8 @@ __all__ = ["init_executor", "RayExecutor"] +T = TypeVar("T") + @contextmanager def init_executor( @@ -39,10 +41,10 @@ def __init__(self, max_workers: int, config: ParallelConfig): if not ray.is_initialized(): ray.init(**self.config) - def submit(self, fn: Callable, /, *args, **kwargs) -> Future: + def submit(self, fn: Callable[..., T], *args, **kwargs) -> Future[T]: remote_fn = ray.remote(fn) ref = remote_fn.remote(*args, **kwargs) - future = ref.future() + future: Future[T] = ref.future() self.futures.add(future) return future From 374b4d17d96f1c28f999b523998a51ccffc9da6f Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Sat, 18 Mar 2023 17:32:36 +0100 Subject: [PATCH 08/65] Fix type hints --- src/pydvl/utils/parallel/__init__.py | 1 - src/pydvl/utils/parallel/futures.py | 4 ++-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/src/pydvl/utils/parallel/__init__.py b/src/pydvl/utils/parallel/__init__.py index 30af6839c..d0a1a0f42 100644 --- a/src/pydvl/utils/parallel/__init__.py +++ b/src/pydvl/utils/parallel/__init__.py @@ -1,3 +1,2 @@ -from .actor import * from .backend import * from .map_reduce import * diff --git a/src/pydvl/utils/parallel/futures.py b/src/pydvl/utils/parallel/futures.py index 3c7e5dd20..c1309e6c7 100644 --- a/src/pydvl/utils/parallel/futures.py +++ b/src/pydvl/utils/parallel/futures.py @@ -41,10 +41,10 @@ def __init__(self, max_workers: int, config: ParallelConfig): if not ray.is_initialized(): ray.init(**self.config) - def submit(self, fn: Callable[..., T], *args, **kwargs) -> Future[T]: + def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": remote_fn = ray.remote(fn) ref = remote_fn.remote(*args, **kwargs) - future: Future[T] = ref.future() + future: "Future[T]" = ref.future() self.futures.add(future) return future From 5d134452e99f0c87596f146ce189429e448eecac Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Sat, 18 Mar 2023 17:33:00 +0100 Subject: [PATCH 09/65] Update data utility learning notebook --- notebooks/shapley_utility_learning.ipynb | 237 ++++++++++++++--------- 1 file changed, 145 insertions(+), 92 deletions(-) diff --git a/notebooks/shapley_utility_learning.ipynb b/notebooks/shapley_utility_learning.ipynb index fd0b156c9..8bb50229c 100644 --- a/notebooks/shapley_utility_learning.ipynb +++ b/notebooks/shapley_utility_learning.ipynb @@ -88,6 +88,8 @@ "\n", "import os\n", "import random\n", + "import time\n", + "from warnings import simplefilter\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -109,23 +111,20 @@ "\n", "random_state = 24\n", "\n", + "train_size = 15\n", + "training_budget_values = np.linspace(100, 4000, 10, dtype=np.int_)\n", + "n_runs = 10\n", + "\n", "is_CI = os.environ.get(\"CI\")\n", - "enable_cache = not is_CI\n", "\n", "if is_CI:\n", " train_size = 5\n", " training_budget_values = np.arange(2, 10, 2)\n", " n_runs = 1\n", - "else:\n", - " train_size = 15\n", - " training_budget_values = np.arange(100, 8000, 250)\n", - " n_runs = 10\n", "\n", "random.seed(random_state)\n", "np.random.seed(random_state)\n", "\n", - "from warnings import simplefilter\n", - "\n", "\n", "class LinearSVC(_LinearSVC):\n", " def fit(self, X, y, sample_weight=None):\n", @@ -147,6 +146,7 @@ "metadata": {}, "outputs": [], "source": [ + "%autoreload\n", "from pydvl.utils import DataUtilityLearning, top_k_value_accuracy\n", "from pydvl.reporting.plots import shaded_mean_std\n", "from pydvl.value import *" @@ -213,7 +213,7 @@ "metadata": {}, "outputs": [], "source": [ - "utility = Utility(model=model, data=dataset, enable_cache=enable_cache)" + "computation_times = {}" ] }, { @@ -222,16 +222,28 @@ "metadata": {}, "outputs": [], "source": [ - "df = (\n", - " compute_shapley_values(\n", - " u=utility,\n", - " mode=ShapleyMode.CombinatorialExact,\n", - " n_jobs=-1,\n", - " progress=False, # Does not display correctly in a notebook\n", - " )\n", - " .to_dataframe(column=\"exact\")\n", - " .drop(columns=[\"exact_stderr\"])\n", - ")" + "utility = Utility(model=model, data=dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "start_time = time.monotonic()\n", + "\n", + "result = compute_shapley_values(\n", + " u=utility,\n", + " mode=ShapleyMode.CombinatorialExact,\n", + " n_jobs=-1,\n", + " progress=False, # Does not display correctly in a notebook\n", + ")\n", + "\n", + "computation_time = time.monotonic() - start_time\n", + "computation_times[\"exact\"] = computation_time\n", + "\n", + "df = result.to_dataframe(column=\"exact\").drop(columns=[\"exact_stderr\"])" ] }, { @@ -251,15 +263,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Doing 10 runs for each of 32 different training budgets.\n" + "Doing 10 runs for each of 10 different training budgets.\n" ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d26df42558fb466db10b05024bd871d3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/100 [00:00" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -390,29 +436,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "shaded_mean_std(\n", + " accuracies.transpose(),\n", + " abscissa=training_budget_values,\n", + " mean_color=\"dodgerblue\",\n", + " shade_color=\"lightblue\",\n", + " xlabel=\"$m_\\\\operatorname{train}$\",\n", + " ylabel=f\"Average Top-{top_k} Accuracy\",\n", + ");" + ] + }, + { + "cell_type": "code", + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ - "shaded_mean_std(\n", - " accuracies.transpose(),\n", - " abscissa=training_budget_values,\n", - " mean_color=\"dodgerblue\",\n", - " shade_color=\"lightblue\",\n", - " xlabel=\"$m_\\\\operatorname{train}$\",\n", - " ylabel=f\"Average Top-{top_k} Accuracy\",\n", - ");" + "plt.show()" ] }, { @@ -424,7 +481,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": { "nbsphinx": "hidden" }, @@ -453,17 +510,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -482,7 +541,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -509,7 +568,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -530,18 +589,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Finally, we recompute the values of all samples using the exact method and the best training budget previously obtained and then plot the resulting scores.\n", - "\n", - "
\n", - "\n", - "Notice the argument `enable_cache=False` when constructing `utility`: because we have changed some samples in the training set, the utility must be evaluated again on all possible subsets of samples.\n", - "\n", - "
" + "Finally, we recompute the values of all samples using the exact method and the best training budget previously obtained and then plot the resulting scores." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -550,29 +603,27 @@ "utility = Utility(\n", " model=LinearSVC(),\n", " data=corrupted_dataset,\n", - " enable_cache=False,\n", ")\n", "\n", - "df_corrupted = compute_shapley_values(\n", + "result = compute_shapley_values(\n", " u=utility,\n", " mode=ShapleyMode.CombinatorialExact,\n", " n_jobs=-1,\n", " progress=False,\n", - ").to_dataframe(column=\"exact\")\n", + ")\n", + "df_corrupted = result.to_dataframe(column=\"exact\").drop(columns=[\"exact_stderr\"])\n", "\n", "dul_utility = DataUtilityLearning(\n", " u=utility, training_budget=best_training_budget, model=MLPRegressor(**mlp_kwargs)\n", ")\n", "\n", - "dul_df = compute_shapley_values(\n", + "result = compute_shapley_values(\n", " u=dul_utility,\n", - " mode=ShapleyMode.TruncatedMontecarlo,\n", - " done=MaxUpdates(2 * len(dataset)),\n", - " truncation=RelativeTruncation(utility, rtol=0.01),\n", + " mode=ShapleyMode.PermutationMontecarlo,\n", + " done=MaxUpdates(300),\n", " n_jobs=-1,\n", - " worker_update_period=2,\n", - " coordinator_update_period=4,\n", - ").to_dataframe(column=\"estimated\")\n", + ")\n", + "dul_df = result.to_dataframe(column=\"estimated\").drop(columns=[\"estimated_stderr\"])\n", "df_corrupted = pd.concat([df_corrupted, dul_df], axis=1)" ] }, @@ -587,14 +638,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": { "nbsphinx": "hidden" }, "outputs": [], "source": [ "fig, ax = plt.subplots()\n", - "df_corrupted.plot(\n", + "df_corrupted.sort_values(by=\"exact\", ascending=False, axis=0).plot(\n", " y=[\"exact\", \"estimated\"], kind=\"bar\", ax=ax, color=[\"dodgerblue\", \"indianred\"]\n", ")\n", "ax.set_xlabel(\"Index\")\n", @@ -604,17 +655,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABT0AAANTCAYAAABsI7kcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/av/WaAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB8RElEQVR4nOz9ebhXZb0//j8302YQSBIHRkVB0kIBZzMUU0lDPWh1TC2kU3kckdKPlAOppWmYmFrnpKgHzDANlBwzFU0DVETCDBwQUekAikzKvH9/9GX/2geQzZs3sF0+Hte1r4t93/d6rdda7j+6nt1rrYqqqqqqAAAAAAAURL2t3QAAAAAAQDkJPQEAAACAQhF6AgAAAACFIvQEAAAAAApF6AkAAAAAFIrQEwAAAAAoFKEnAAAAAFAoDbZ2A58kq1evzjvvvJPmzZunoqJia7cDAAAAAB8rVVVVWbRoUdq0aZN69da/n1PouQW98847ad++/dZuAwAAAAA+1mbNmpV27dqtd17ouQU1b948yT//o7Ro0WIrdwMAAAAAHy8LFy5M+/btq3O29RF6bkFrHmlv0aKF0BMAAAAASrShV0f6kBEAAAAAUChCTwAAAACgUISeAAAAAEChCD0BAAAAgEIRegIAAAAAhSL0BAAAAAAKRegJAAAAABRKg63dABu2YsWKrFq1amu3ARulfv36adiw4dZuAwAAAPgEEnrWYQsXLsy8efOybNmyrd0KlKSysjLbbbddWrRosbVbAQAAAD5BhJ511MKFC/P2229nm222yXbbbZeGDRumoqJia7cFtVJVVZUVK1ZkwYIFefvtt5NE8AkAAABsMULPOmrevHnZZptt0q5dO2EnH0tNmjRJ8+bN89Zbb2XevHlCTwAAAGCL8SGjOmjFihVZtmxZWrZsKfDkY62ioiItW7bMsmXLsmLFiq3dDgAAAPAJIfSsg9Z8tMhHYCiCNX/HPsYFAAAAbClCzzrMLk+KwN8xAAAAsKUJPQEAAACAQhF6AgAAAACFIvQEAAAAAAqlwdZugNJ1HLa1O9iwmeeWr1Zt3g35zW9+M7fddlv5TgoAAADAx47Qk4+db37zm+ud+/znP78FO9l4t912W0477bRceumlGTJkyNZuBwAAAKCQhJ587NjJCQAAAMBH8U5PAAAAAKBQhJ4U1v/7f/8vFRUV+epXv7rW3Lx589KmTZvUr18/f/7zn6vHZ8+enauvvjq9evVK27Zt06hRo+y4447p169fnn322fWea8mSJfnpT3+affbZJy1atEizZs3StWvXnHnmmZk+fXqS5NBDD81pp52WJPnRj36UioqK6h+7VwEAAADKx+PtFNbll1+eP/7xj/nd736X22+/vca7QL/97W9n9uzZ+eEPf1jjPaD33ntv/t//+3/Zfffd061bt7Ro0SKvvPJKRo8enT/84Q/5wx/+kCOPPLLGeWbPnp0jjjgiL730UrbddtsceuihqayszOuvv55f/epX6dy5c7p06ZI+ffpk5cqVefrpp7PXXntl7733rq6x2267bfb7AQAAAPBJIfSksBo1apQ77rgjPXv2zNlnn50vfOEL2WWXXfLrX/86Y8aMyb777rvWx4QOPvjgTJ06NXvuuWeN8YcffjjHHntszjjjjLzyyis1viR/6qmn5qWXXspXv/rV3HLLLdlmm22q5954440sXLgwSXLhhRdmxx13zNNPP53jjz/eh4wAAAAANhOPt/Ox86+Phf/fnzFjxtRY+5nPfCY/+9nPsmjRopx88sl5+eWXc95556Vp06YZOXJkGjSomft/7nOfWyvwTJKjjjoqX/nKV/Laa69l6tSp1eMTJ07Mn/70p2y//fa5+eabawSeSbLzzjunW7du5bt4AAAAADbITk8+dv71MfX/q0OHDmuNnXHGGXnggQdy//3354ADDsiSJUvyX//1X+nSpcs6ayxbtiwPPfRQJk6cmLlz52b58uVJkr/+9a9JkldeeSWf+9znkiSPPvpokuSkk05K8+bNN+m6AAAAACgPoScfO6V89OeWW27JzjvvnIULF+ZLX/pSvvOd76xz3V//+tcce+yxeeONN9Zba9GiRdX/njVrVpJk11133eieAAAAANg8PN7OJ8J9992XpUuXJkmmTZuWxYsXr7WmqqoqX/3qV/PGG2/k9NNPz+TJk7Nw4cKsXr06VVVVGTx4cPU6AAAAAOouoSeF98orr1S/x7Nfv355/fXXc84556y17u9//3v+/ve/Z5999skvf/nL7LXXXmnevHn1R4tef/31tY5p3759kuS1117bvBcBAAAAQK0JPSm0lStX5pRTTsmSJUty7bXXZuTIkenatWtuvfXW3HPPPTXWzp8/P0nSrl27terMnz8/f/zjH9ca/+IXv5gkufPOO9e5e/T/atSoUXVfAAAAAGweQk8K7bLLLsvEiRPTt2/ffPe7302TJk0ycuTINGzYMN/5znfyzjvvVK/dbbfdUq9evTz22GN55ZVXqseXLl2a008/Pe+9995a9ffbb78cdthhmTNnTr7zne9kyZIlNebfeOON6g8gJUmbNm2S/PMRewAAAAA2Dx8y4mOnf//+653r0KFDLrvssiTJX/7yl/zkJz/JDjvskFtuuaV6Tc+ePTNkyJD88Ic/TP/+/fPwww+noqIi22+/fb71rW/l17/+dfbaa6/07t07TZo0yVNPPZVVq1alf//+6/yI0ogRI3L44YfnzjvvzMMPP5zPf/7zqayszGuvvZbJkydn6NCh1V97P+CAA7L99tvn7rvvzqGHHppOnTqlXr16GTBgQA466KCy3icAAACATyqh58fYzHO3dgdbx+23377eub322iuXXXZZFi9enFNOOSWrVq3K8OHD07p16xrrLrzwwjz44IP54x//mOuuuy7nnXdekuSXv/xlunbtmltuuSV/+tOf0rJly3zxi1/Mj3/849x6663rPGfbtm3z7LPP5rrrrsvdd9+dP/7xj6lfv37atWuXM844I1/+8per1zZu3Dj3339/fvCDH2TixIl58sknU1VVlc9//vNCTwAAAGCjdBxW3npFypoqqnyKeotZuHBhWrZsmQULFqRFixbrXbd06dLMmDEju+yySxo3brwFO4Ty8/cMAAAAm8cnMfSsbb7mnZ4AAAAAQKEIPQEAAACAQhF6AgAAAACFIvQEAAAAAApF6AkAAAAAFIrQEwAAAAAoFKEnAAAAAFAoQk8AAAAAoFCEngAAAABAoQg9AQAAAIBCEXoCAAAAAIUi9AQAAAAACkXoCQAAAAAUitCTj42KiooN/vTv33+znX/nnXdORUXFZqv/cTJkyJBUVFTktttu29qtAAAAAKylwdZugNJNOvXUrd3CBvUYMaLsNb/5zW+ud+7zn/98STXfeOON7LLLLunVq1eeeOKJEjvbOj7OvQMAAABsDkJPPna21u7CP/3pT1mxYsVWOTcAAAAAtSf0hFraddddt3YLAAAAANSCd3pSaDNnzsx//ud/pkuXLmnatGlatWqVPffcM9/97nczbdq0JP98P+Uuu+ySJBk3btx63xG6rnd6vvHGG6moqMihhx6aJUuWZNCgQWnfvn2aNGmSHj16ZOzYsdVrf/e732X//fdPs2bNssMOO+Scc87Jhx9+uFbPkydPzgUXXJCePXumdevWqaysTKdOnXLGGWfknXfeqbG2tr0nyXvvvZfBgwdnjz32SJMmTdKyZcv07t07f/jDH9Z7/+67774ceOCBadq0aT796U/nhBNOyPTp0zd84wEAAAC2Ijs9KaxZs2alR48eee+999K5c+ccffTRWbVqVWbOnJlf//rXOfDAA7P77rtn7733zgknnJB77rknO+ywQ/r06VNdo7bvCF2+fHkOP/zwzJgxI1/4whcyb968PPnkk/m3f/u3PPTQQ/nrX/+aCy64IL169cpRRx2VJ598Mr/4xS/y7rvv5o477qhR66qrrso999yTbt26VZ9/8uTJ+eUvf5kxY8bkueeeS5s2bZKk1r1Pnz49X/ziFzNr1qzsvPPOOeqoo7Jo0aKMHz8+ffv2zTXXXJPvf//7Nfr41a9+lf/8z/9MRUVFDjnkkOy0004ZP3589ttvv/Tt23fj/mMAAAAAbEFCTwrr5ptvznvvvZezzjorv/jFL2rMvfnmm9Xv5zz++OOz995755577knXrl1LemfoX/7yl/Tu3Tuvv/56mjVrluSf7x497bTT8p//+Z95991385e//CX77LNPkuSdd95J9+7d85vf/CaXX355OnXqVF3ru9/9boYNG5Yddtihemz16tW54oorcumll+aiiy7K8OHDa937qlWrcuKJJ2bWrFm5+uqr873vfS/16v1zk/err76aI488MhdeeGH69OmTz372s0n+uUP2vPPOS8OGDTN27NgcddRRSZIVK1bktNNOy8iRIzf6HgEAAABsKR5v52PnXx/h/r8/Y8aMqV43d+7cJMkXv/jFtWp06NChrO/orFevXn75y19WB55J8o1vfCPbbbddXn311Zx55pnVgWeStGnTJieffHKS5Mknn6xR67DDDqsReK6pf8kll6Rt27a57777Nqq3sWPH5q9//WtOOOGEnH/++dWBZ5LstttuGTp0aFatWpVf//rX1ePDhw/P0qVLc9JJJ1UHnknSsGHDDBs2LE2bNt2oHgAAAAC2JDs9+dj55je/ud65Dh06VP+7Z8+eSZIf/OAHqV+/fr74xS+mcePGm6WnnXfeOV26dKkxVq9evXTs2DHz5s3LkUceudYxa3Z3zp49e625d999N/fdd1+mTp2a999/P6tWrUryz52W7777bt577720atWqVr098sgjSZJ+/fqtc/6QQw5JkkycOLF67KmnnkqS/Pu///ta6z/96U/nyCOPrBEwAwAAANQlQk8+dmr7+Hn//v3zyCOP5K677krfvn3TuHHj7LvvvunTp08GDBiQHXfcsWw9tW3bdp3j22yzzXrn18wtW7asxvidd96Z73znO1m8ePF6z7do0aJah55vvPFGkuTkk0+u3l26LvPmzav+95oPJnXs2HGda3feeedanRsAAABgaxB6Ulj169fPqFGjcuGFF+bee+/NY489lgkTJuSpp57KVVddlYceeigHHXRQWc71r4+MlzK/xsyZM6u/un7dddflmGOOSdu2bdOkSZMkyUEHHZS//OUvqaqqqnVvq1evTpL06dNnrcfm/9V2221X65oAAAAAdZnQk8Lr3r17unfvniFDhmThwoUZMmRIfv7zn2fgwIE1HumuCx544IEsX7483//+93PuueeuNf/6669vdM127dolSf7jP/4jJ5xwQq2O2WmnnTJt2rTMnDkze+yxx1rzM2fO3Og+AAAAALYUHzLiE6VFixa58sorU1FRkalTp1aPN2rUKEmycuXKrdVakmT+/PlJ/v9B5b968skn87//+79rjW+o9yOOOCJJMnr06Fr3seY9n3fddddac++99171e0IBAAAA6iKhJ4U1YsSIGsHmGg8++GCqqqrSvn376rHtttsuDRs2zGuvvVb90aCtYc3HkEaOHJklS5ZUj7/99ts5/fTT13nMhno/4YQTsscee+SOO+7I5ZdfvtY7RKuqqvL000/n6aefrh477bTTUllZmTvuuCOPPvpo9fiKFSty3nnn1egNAAAAoK7xeDsfO2veebkuHTp0yGWXXZYkueeee/KNb3wju+66az73uc+lSZMmmTFjRiZMmJB69erliiuuqD6uUaNG6dOnT8aOHZu99torPXr0SKNGjXLwwQfntNNO29yXVO3YY4/Nnnvumeeeey677bZbDj744CxdujSPP/549t577xx00EF55plnahyzod4bNGiQMWPG5Kijjsoll1ySG264Id26dcv222+fefPmZfLkyZkzZ05+/vOf5+CDD06S7LLLLhk6dGjOOuusHHXUUfnCF76QHXfcMePHj8/8+fNz8skn54477thi9wUAAABgYwg9P8Z6jBixtVvYKm6//fb1zu21117VoeegQYPSrl27PP3003nqqaeyZMmStGnTJl/72tfyve99L/vss0+NY2+++eZ8//vfzx//+Mf85je/yapVq7Jy5cotGno2atQoTz31VH74wx/mwQcfzB/+8Ie0bds2Z599di655JIcffTR6zxuQ7137tw5L7zwQm644Yb8/ve/z/jx47Ny5crsuOOO6d69e4499th89atfrVHzzDPPTNu2bXPVVVdlwoQJady4cb7whS/kqquuym9/+9vNfi8AAAAASlVRtTGfgWaTLFy4MC1btsyCBQvSokWL9a5bunRpZsyYkV122SWNGzfegh1C+fl7BgAAgM2j47Dy1pu59jeV65za5mve6QkAAAAAFIrQEwAAAAAoFKEnAAAAAFAoQk8AAAAAoFCEngAAAABAoQg9AQAAAIBCEXoCAAAAAIUi9KzDqqqqtnYLsMn8HQMAAABbmtCzDqpfv36SZMWKFVu5E9h0a/6O1/xdAwAAAGxuQs86qGHDhqmsrMyCBQvskuNjraqqKgsWLEhlZWUaNmy4tdsBAAAAPiEabO0GWLftttsub7/9dt566620bNkyDRs2TEVFxdZuC2qlqqoqK1asyIIFC7J48eK0bdt2a7cEAAAAfIIIPeuoFi1aJEnmzZuXt99+eyt3A6WprKxM27Ztq/+eAQAAALYEoWcd1qJFi7Ro0SIrVqzIqlWrtnY7sFHq16/vkXYAAABgqxB6fgw0bNhQeAQAAAAAtVSnP2T04Ycf5pJLLkmXLl3SuHHjtGnTJgMGDNjox73HjRuXH/3oRznmmGPSunXrVFRUZOedd97gcatWrcrPf/7zfO5zn0uTJk3SunXrfPWrX83LL79c4hUBAAAAAJtbRVUd/Tz40qVLc9hhh2X8+PHZaaedcsghh+SNN97IxIkT07p164wfPz6dOnWqVa299947L774Yo2xjh075o033ljvMatXr86JJ56Y0aNH51Of+lQOP/zwzJs3L08++WSaNGmSxx9/PPvtt99GXdPChQvTsmXLLFiwwDsOAQAAANgkHYeVt97Mc8tbb3Oobb5WZ3d6XnHFFRk/fnwOPPDATJ8+PaNGjcqECRMydOjQzJ07NwMGDKh1rSOPPDJXXHFFHn744bz00ku1Omb48OEZPXp0OnfunL///e+5++6788QTT+R3v/tdPvjgg5x88slZuXJlqZcHAAAAAGwmdXKn5/Lly7P99ttnwYIFmTRpUrp3715jfq+99sqUKVPy3HPPpWfPnhtV+x//+Ed22mmnDe703GOPPfLyyy9n9OjROf7442vMHXfccbnvvvty991354QTTqj1ue30BAAAAKBc7PT8mO30fPrpp7NgwYLsuuuuawWeSXLiiScmScaOHbtZzj9jxoy8/PLLadKkSY455pgtfn4AAAAAoHR1MvRc8/7NHj16rHN+zfiUKVM26/k/+9nPrvOr6Zv7/AAAAABA6Rps7QbW5c0330yStGvXbp3za8ZnzpxZp8+/bNmyLFu2rPr3hQsXlqlDAAAAAGB96uROz8WLFydJmjZtus75Zs2aJUkWLVpUp89/5ZVXpmXLltU/7du3L2+jAAAAAMBa6mToWRSDBw/OggULqn9mzZq1tVsCAAAAgMKrk4+3b7PNNkmSDz74YJ3zS5YsSZI0b968Tp+/srIylZWV5W0OAAAAAPhIdXKnZ4cOHZIkb7311jrn14x37NixkOcHAAAAAEpXJ0PPvfbaK0kyadKkdc6vGe/WrdtmPf/UqVOzYsWKLX5+AAAAAKB0dTL0PPjgg9OyZcu89tprmTx58lrzd999d5Kkb9++m+X8u+yySz7zmc/kww8/zP3337/Fzw8AAAAAlK5Ohp6NGjXKWWedlSQ588wzq9+hmSTXXnttpkyZkl69eqVnz57V4zfccEO6du2awYMHl6WHQYMGJUkuuOCCzJkzp3r897//fe67777stttuOe6448pyLgAAAACgfOrkh4yS5KKLLsqjjz6aZ555Jp07d84hhxySmTNnZsKECWndunWGDx9eY/28efMybdq0zJ49e61aN998c26++eYkqX5cffbs2TnggAOq19x0003p0aNH9e8DBgzIAw88kNGjR6dr1645/PDDM2/evIwbNy5NmjTJyJEj06BBnb19AAAAAPCJVSd3eiZJ48aN8/jjj+fiiy9O06ZNM2bMmMycOTP9+/fPpEmT0qlTp1rXeuuttzJhwoRMmDCh+n2cy5cvrx6bMGFCFi5cWOOYevXq5Xe/+12GDh2aNm3a5A9/+EP++te/5oQTTshzzz2X/fffv6zXCwAAAACUR0VVVVXV1m7ik2LhwoVp2bJlFixYkBYtWmztdgAAAAD4GOs4rLz1Zp5b3nqbQ23ztTq70xMAAAAAoBRCTwAAAACgUISeAAAAAEChCD0BAAAAgEIRegIAAAAAhSL0BAAAAAAKRegJAAAAABSK0BMAAAAAKBShJwAAAABQKEJPAAAAAKBQhJ4AAAAAQKEIPQEAAACAQhF6AgAAAACF0mBrNwAAAADAJ0fHYeWvOfPc8tfk481OTwAAAACgUISeAAAAAEChCD0BAAAAgEIRegIAAAAAhSL0BAAAAAAKRegJAAAAABSK0BMAAAAAKBShJwAAAABQKEJPAAAAAKBQhJ4AAAAAQKEIPQEAAACAQhF6AgAAAACFIvQEAAAAAApF6AkAAAAAFIrQEwAAAAAoFKEnAAAAAFAoQk8AAAAAoFCEngAAAABAoQg9AQAAAIBCEXoCAAAAAIUi9AQAAAAACkXoCQAAAAAUitATAAAAACgUoScAAAAAUChCTwAAAACgUISeAAAAAEChCD0BAAAAgEIRegIAAAAAhSL0BAAAAAAKRegJAAAAABSK0BMAAAAAKBShJwAAAABQKEJPAAAAAKBQhJ4AAAAAQKEIPQEAAACAQhF6AgAAAACFIvQEAAAAAApF6AkAAAAAFIrQEwAAAAAoFKEnAAAAAFAoQk8AAAAAoFCEngAAAABAoQg9AQAAAIBCEXoCAAAAAIUi9AQAAAAACkXoCQAAAAAUitATAAAAACgUoScAAAAAUChCTwAAAACgUISeAAAAAEChCD0BAAAAgEIRegIAAAAAhSL0BAAAAAAKRegJAAAAABSK0BMAAAAAKBShJwAAAABQKEJPAAAAAKBQhJ4AAAAAQKEIPQEAAACAQhF6AgAAAACFIvQEAAAAAApF6AkAAAAAFIrQEwAAAAAoFKEnAAAAAFAoDbZ2AwAAAACwKSadempZ6/UYMaKs9djy7PQEAAAAAApF6AkAAAAAFIrQEwAAAAAoFKEnAAAAAFAoQk8AAAAAoFCEngAAAABAoQg9AQAAAIBCEXoCAAAAAIUi9AQAAAAACkXoCQAAAAAUitATAAAAACgUoScAAAAAUChCTwAAAACgUISeAAAAAEChCD0BAAAAgEIRegIAAAAAhSL0BAAAAAAKRegJAAAAABSK0BMAAAAAKBShJwAAAABQKHU69Pzwww9zySWXpEuXLmncuHHatGmTAQMG5O23397oWvPnz8+5556bjh07prKyMh07dszAgQPz/vvvr/eY6dOn57TTTkvHjh3TqFGjNG/ePPvuu29+/vOfZ/ny5ZtwZQAAAADA5lJnQ8+lS5emd+/eufzyy7N48eIcd9xxad++fW699dZ07949r7/+eq1rzZs3L/vtt1+uv/76NGjQIMcff3yaN2+eYcOGZf/9989777231jHPPPNMunfvnttuuy3NmjXL8ccfn4MOOigvvfRSBg0alCOPPDIrV64s5yUDAAAAAGVQZ0PPK664IuPHj8+BBx6Y6dOnZ9SoUZkwYUKGDh2auXPnZsCAAbWuNXDgwLz66qvp169fpk2bllGjRmXq1Kk5++yzM3369AwaNGitY84666x88MEHufLKK/O3v/0td911Vx5++OG8+uqr6dSpU8aNG5cRI0aU85IBAAAAgDKok6Hn8uXLc8MNNyRJbrzxxmyzzTbVc4MGDUq3bt0ybty4PP/88xusNXv27Nx5551p1KhRbrrppjRo0KB67pprrknr1q0zcuTIzJkzp3p88eLFeeGFF9K0adNccMEFNeq1adMmZ511VpLk2Wef3aTrBAAAAADKr06Gnk8//XQWLFiQXXfdNd27d19r/sQTT0ySjB07doO1HnrooaxevTqHHHJIdthhhxpzlZWV6du3b1atWpUHHnigerxhw4apV2/Dt+bTn/70BtcAAAAAAFtWnQw9X3zxxSRJjx491jm/ZnzKlCmbpVZlZWW+8IUv5IMPPsjVV19dY/0777yTG2+8MQ0bNsypp566wfMDAAAAAFtWnQw933zzzSRJu3bt1jm/ZnzmzJmbrdavfvWrtG/fPoMHD84ee+yRr371q+nTp0922223VFVV5f7770+XLl0+8tzLli3LwoULa/wAAAAAAJtXgw0v2fIWL16cJGnatOk655s1a5YkWbRo0Wartfvuu+fPf/5z/u3f/i2TJk3Kyy+/nCSpqKjIYYcdlj333HOD577yyivzox/9aIPrAAAAAIDyqZOhZ13w2GOP5YQTTkj79u3z2GOPZZ999sm7776bW265JT/5yU/ypz/9KRMnTkzr1q3XW2Pw4ME1vgy/cOHCtG/ffku0DwAAAAAbZdJmeJVjjxEjyl6zNupk6Lnma+0ffPDBOueXLFmSJGnevPlmqfXee+/lK1/5SlasWJEHH3wwbdu2rV5z+eWXZ8GCBfnFL36Rn/3sZ/npT3+63nNXVlamsrJygz0CAAAAAOVTJ9/p2aFDhyTJW2+9tc75NeMdO3bcLLXuv//+vPfeeznggAOqA89/9ZWvfCVJ8uSTT27w/AAAAADAllUnQ8+99torSTJp0qR1zq8Z79at22aptSYIbdmy5TqPWTM+f/78DZ4fAAAAANiy6mToefDBB6dly5Z57bXXMnny5LXm77777iRJ3759N1irT58+qVevXp566qnMmTOnxtyyZcsyduzY1K9fP0cffXT1+I477pgkeeGFF7Jq1aq1aj777LNJkp133rm2lwQAAAAAbCF1MvRs1KhRzjrrrCTJmWeeWf3ezSS59tprM2XKlPTq1Ss9e/asHr/hhhvStWvXDB48uEatnXbaKSeddFKWL1+eM844IytXrqyeu+CCCzJ37tyccsop2X777avH+/Tpk8rKysyYMSMXX3xxVq9eXT03bdq0XHLJJUmSE088sbwXDgAAAABssjr5IaMkueiii/Loo4/mmWeeSefOnXPIIYdk5syZmTBhQlq3bp3hw4fXWD9v3rxMmzYts2fPXqvWddddl/Hjx+eee+5J165ds88+++Sll17K1KlT07lz51x77bU11u+000752c9+lnPOOSdXXnllRo0ale7du+fdd9/NX/7ylyxbtixHH310+vfvvzlvAQAAAABQgjq50zNJGjdunMcffzwXX3xxmjZtmjFjxmTmzJnp379/Jk2alE6dOtW61nbbbZeJEyfm7LPPzvLlyzN69OgsWLAg55xzTiZOnJhWrVqtdcxZZ52Vxx57LMcff3w++OCD3HvvvZk0aVK6d++eG2+8Mffdd18aNKizmTEAAAAAfGJVVFVVVW3tJj4pFi5cmJYtW2bBggVp0aLF1m4HAAAAYIvrOKz8NUc/d2pZ6/UYMaKs9TaXct/Lct/HpPz3srb5Wp3d6QkAAAAAUAqhJwAAAABQKEJPAAAAAKBQhJ4AAAAAQKEIPQEAAACAQhF6AgAAAACFIvQEAAAAAApF6AkAAAAAFIrQEwAAAAAoFKEnAAAAAFAoQk8AAAAAoFCEngAAAABAoQg9AQAAAIBCEXoCAAAAAIUi9AQAAAAACkXoCQAAAAAUitATAAAAACiUBlu7AQAAAIC6ruOw8teceW75awL/ZKcnAAAAAFAoQk8AAAAAoFCEngAAAABAoQg9AQAAAIBCEXoCAAAAAIUi9AQAAAAACkXoCQAAAAAUitATAAAAACgUoScAAAAAUChCTwAAAACgUISeAAAAAEChCD0BAAAAgEIRegIAAAAAhSL0BAAAAAAKRegJAAAAABSK0BMAAAAAKBShJwAAAABQKEJPAAAAAKBQhJ4AAAAAQKEIPQEAAACAQhF6AgAAAACFIvQEAAAAAApF6AkAAAAAFIrQEwAAAAAoFKEnAAAAAFAoQk8AAAAAoFCEngAAAABAoTTY2g0AAADAljDp1FPLWq/HiBFlrQdA+djpCQAAAAAUitATAAAAACgUoScAAAAAUChCTwAAAACgUISeAAAAAEChCD0BAAAAgEIRegIAAAAAhSL0BAAAAAAKRegJAAAAABSK0BMAAAAAKBShJwAAAABQKEJPAAAAAKBQhJ4AAAAAQKEIPQEAAACAQhF6AgAAAACFIvQEAAAAAApF6AkAAAAAFEqDrd0AAAAAsPl0HFbeejPPLW89gM3BTk8AAAAAoFCEngAAAABAoQg9AQAAAIBCEXoCAAAAAIUi9AQAAAAACkXoCQAAAAAUitATAAAAACgUoScAAAAAUCgNylHklVdeybx58/LpT386Xbp0KUdJAAAAAICSlLzTc9myZfnBD36Q7bbbLl27ds3nP//5XHXVVdXzI0eOTI8ePTJ58uRy9AkAAAAAUCslhZ4ffvhhDj300Pz0pz9No0aNcvTRR6eqqqrGmt69e+fFF1/MXXfdVZZGAQAAAABqo6TQ8+qrr86ECRMyYMCAvP766xk7duxaa9q0aZM99tgjjz766CY3CQAAAABQWyWFnqNGjUqHDh3yy1/+Mo0bN17vut133z2zZs0quTkAAAAAgI1VUug5Y8aM7LPPPmnQ4KO/g9SoUaPMnz+/pMYAAAAAAEpRUujZpEmTWoWZM2bMyLbbblvKKQAAAAAASlJS6Ln33nvnueeey9y5c9e7ZsaMGXnhhRey7777ltwcAAAAAMDGKin0/Pa3v51FixblpJNOyrx589aaf//99zNgwICsWLEi3/nOdza5SQAAAACA2vrol3Kux0knnZSxY8fmt7/9bTp16pSDDjooSfL000/nuOOOy7hx47Jw4cJ84xvfyJe//OWyNgwAAAAA8FFK2umZJHfccUd++tOfpnHjxnnkkUeSJK+88krGjh2bioqK/PjHP86tt95atkYBAAAAAGqjpJ2eSVJRUZHzzz8/gwYNyqRJk/LGG29k9erVadeuXfbdd980atSonH0CAAAAANRKyaHnGvXr18++++7rg0UAAAAAQJ1Q8uPtAAAAAAB1UUk7PQcMGFDrtRUVFbnllltKOQ0AAAAAwEYrKfS87bbbNrimoqIiVVVVQk8AAAAAYIsqKfR8/PHH1zm+evXqzJo1K4888kh++9vf5rzzzkvfvn03qUEAAAAAgI1RUujZq1evj5z/xje+kWOOOSbf/OY3c+yxx5bUGAAAAABAKTbbh4xOOumk7LnnnhkyZMjmOgUAAAAAwFpK2ulZW507d85DDz20OU8BAADUQZNOPbXsNXuMGFH2mgBAMW22nZ6rV6/OlClTUq/eZjsFAAAAAMBayp5IfvDBB5k8eXJOOumkvPLKKxt8/ycAAAAAQDmV9Hh7/fr1N7imqqoqrVu3zjXXXFPKKQAAAAAASlJS6Nm+fftUVFSsc65Ro0bZaaed0qtXr5x55pnZfvvtN6lBAAAAAICNUVLo+cYbb5S5DQAAAACA8vCVIQAAAACgUEra6QkAAACbU8dh5a85uvwlAaijahV6/s///M8mneQb3/hGScd9+OGHufLKK/Pb3/42b775Zlq1apU+ffrk8ssvT9u2bTeq1vz58zNkyJCMGTMm//jHP7Ljjjvm3/7t3zJkyJB86lOfWu9xixcvztChQ3PPPffk9ddfT/369dO+ffv06tUrP/3pT7PNNtuUdG0AAEDxbI6gbua55a8JAEVXq9Czf//+6/1w0UepqqpKRUVFSaHn0qVL07t374wfPz477bRTjjvuuLzxxhu59dZb84c//CHjx49Pp06dalVr3rx5OfDAA/Pqq6+mU6dOOf744/PSSy9l2LBhefDBB/OXv/wlrVq1Wuu4GTNm5PDDD8+MGTPSqVOnfOlLX8qyZcsybdq03HTTTRk8eLDQEwCAQih3WGdHHQCwNdUq9LzkkktKCj03xRVXXJHx48fnwAMPzCOPPFIdLl577bX53ve+lwEDBuSJJ56oVa2BAwfm1VdfTb9+/TJq1Kg0aPDPyz7nnHPyi1/8IoMGDcptt91W45hly5blS1/6Ut5888386le/yne/+90a81OnTl1nUAoAAAAAbF21Cj2HDBmymduoafny5bnhhhuSJDfeeGON3ZSDBg3K7bffnnHjxuX5559Pz549P7LW7Nmzc+edd6ZRo0a56aabqgPPJLnmmmvy29/+NiNHjszVV1+d7bffvnpu2LBhmTZtWs4///y1As8k+exnP7uplwkAAAAAbAZ18uvtTz/9dBYsWJBdd9013bt3X2v+xBNPTJKMHTt2g7UeeuihrF69Ooccckh22GGHGnOVlZXp27dvVq1alQceeKDG3K9//eskydlnn13qZQAAAAAAW0Gd/Hr7iy++mCTp0aPHOufXjE+ZMqUstYYPH16j1qxZs/Lqq6+mXbt2ad++fZ5++uncd999WbBgQXbZZZeccMIJ2W233TbqmgAAAACALWOTQs8333wzY8eOzSuvvJJFixalqqpqrTUVFRW55ZZbNrpukrRr126d82vGZ86cuVlq/e1vf0uStGnTJmeeeWZuuummGsdcdNFFueqqq/K9733vI8+9bNmyLFu2rPr3hQsXbrBfAAAAAGDTlBx6XnbZZbn88suzevXq6rE1oeeajx6t+Xr7xoaeixcvTpI0bdp0nfPNmjVLkixatGiz1Jo/f36SZNKkSXnuuecyZMiQfOtb30qDBg3yP//zP/nhD3+Y73//++natWuOOeaY9Z77yiuvzI9+9KMN9ggAAAAAlE9J7/QcNWpUhgwZkvbt2+e///u/c8QRRyRJHn744fzyl79Mr169UlVVlUGDBuWxxx4ra8Nbwpogd+XKlfnud7+bSy+9NO3atcuOO+6YCy64IOedd16S5Cc/+clH1hk8eHAWLFhQ/TNr1qzN3jsAAAAAfNKVFHredNNNadSoUR5//PF861vfyk477ZQkOeKII/Ld7343jz32WIYOHZphw4alfv36G11/zdfaP/jgg3XOL1myJEnSvHnzzVLrX78Wf9ppp611zJqxCRMmZOnSpes9d2VlZVq0aFHjBwAAAADYvEoKPadMmZKDDjooHTt2TFLzcfY1zjvvvOy+++654oorNrp+hw4dkiRvvfXWOufXjK85f7lr/eu/d95557WOWTO2atWqvPfeexvsAQAAAADYckp6p+eyZcuy4447Vv/euHHjJMn777+fbbfdtnp8r732ykMPPbTR9ffaa68k/3yn5rqsGe/WrdtmqdW1a9c0btw4S5cuzfz589O6desax/xr0Pmvu0IBANiyOg4rf82Z55a/JgAAW1ZJOz132mmnzJkzp/r3tm3bJkleeumlGuveeuutrFq1aqPrH3zwwWnZsmVee+21TJ48ea35u+++O0nSt2/fDdbq06dP6tWrl6eeeqpGz8k/w9uxY8emfv36Ofroo6vHKysrc9RRRyVJnnjiibVqjhs3LknSqVMnj6wDAAAAQB1TUuj5uc99LtOmTav+/dBDD01VVVUuvfTS6ndk3nXXXXnqqaey5557bnT9Ro0a5ayzzkqSnHnmmdU1k+Taa6/NlClT0qtXr/Ts2bN6/IYbbkjXrl0zePDgGrV22mmnnHTSSVm+fHnOOOOMrFy5snruggsuyNy5c3PKKadk++23r3HcBRdckCS5/PLLM3369OrxGTNm5OKLL06SnH766Rt9bQAAAADA5lXS4+19+/bNfffdl8ceeyy9e/fOwQcfnMMOOyyPP/54tt1227Ro0SLz589PRUVFdUC4sS666KI8+uijeeaZZ9K5c+cccsghmTlzZiZMmJDWrVtn+PDhNdbPmzcv06ZNy+zZs9eqdd1112X8+PG555570rVr1+yzzz556aWXMnXq1HTu3DnXXnvtWsccdNBBueSSS3LZZZele/fuOfjgg1O/fv08/fTTWbRoUb70pS9l0KBBJV0bAAAAALD5lLTT85RTTsnLL7+cvffeu3ps9OjR+c53vpNWrVpl0aJF2WOPPTJixIj06dOnpMYaN26cxx9/PBdffHGaNm2aMWPGZObMmenfv38mTZqUTp061brWdtttl4kTJ+bss8/O8uXLM3r06CxYsCDnnHNOJk6cmFatWq3zuB/96Ee555570rNnz4wfPz7jxo3Lrrvump///Oe57777SvoyPQAAAACweZW007OysjK77757jbEWLVrkV7/6VX71q1+VpbEkadKkSS677LJcdtllG1w7ZMiQDBkyZL3zrVq1yvXXX5/rr79+o3ro169f+vXrt1HHAAAAAABbT0k7PVevXl3uPgAAAAAAyqKk0LNt27Y577zz8uyzz5a7HwAAAACATVJS6Pnuu+9m2LBhOeCAA7L77rvn8ssvz2uvvVbu3gAAAAAANlpJoec//vGP3HTTTTnooIPy6quv5tJLL02XLl1y4IEH5sYbb8zcuXPL3ScAAAAAQK2UFHq2atUqp59+ep566qnMmDEjP/7xj/OZz3wmEyZMyDnnnJO2bdvmmGOOyW9+85t88MEH5e4ZAAAAAGC9Sgo9/1WHDh0yePDgTJ06NZMnT873vve97LDDDnnwwQdz6qmnZscddyxHnwAAAAAAtdKgnMW6deuWq6++OkOGDMn3v//9/OpXv8qSJUvKeQoAAIBPlEmnnlr2mj1GjCh7TQCoS8oWelZVVeXRRx/NHXfckTFjxmTRokVJknbt2pXrFAAAAACF4f/UgM1nk0PPiRMn5je/+U1GjRqVOXPmpKqqKi1btsyAAQNy8sknp1evXuXoEwAAAACgVkoKPadPn5477rgjd955Z1577bVUVVWlsrIyxx9/fE4++eR8+ctfTqNGjcrdKwAAAADABpUUenbt2jUVFRVJki984Qs5+eSTc+KJJ+ZTn/pUOXsDACikjsPKX3PmueWvCQAAH1clhZ6f/exnc8opp+TrX/+6d3YCAAAAAHVKSaHnlClTyt0HAAAAAEBZ1NvaDQAAAAAAlJPQEwAAAAAoFKEnAAAAAFAoQk8AAAAAoFCEngAAAABAoQg9AQAAAIBCEXoCAAAAAIVSUui566675qqrrso//vGPcvcDAAAAALBJSgo933jjjfzwhz9Mhw4d0q9fvzz00EOpqqoqd28AAAAAAButpNBz5syZueSSS7LTTjtlzJgxOeaYY7Lzzjvnsssuy1tvvVXuHgEAAAAAaq2k0LNdu3a59NJL88Ybb+SBBx7I8ccfn3/84x8ZMmRIdtlll/Tt2zf33XdfVq9eXe5+AQAAAAA+UoNNObiioiJ9+vRJnz59MmfOnNx22225+eabc//99+eBBx7IjjvumAEDBuRb3/pWdt555zK1DAAAAGwtk049tew1e4wYUfaawCdb2b7evv322+eCCy7Iyy+/nPPOOy9VVVWZPXt2fvzjH2e33XbLcccdl8mTJ5frdAAAAAAA61S20HPNez533nnnXHfddUmSgw46KBdddFF22223jB07Nvvtt19Gjx5drlMCAAAAAKxlk0LPlStX5p577kmfPn2y66675oorrsiiRYvyn//5n5kyZUr+/Oc/57LLLsvf//73jBo1KvXr188ll1xSrt4BAAAAANZS0js9X3nlldx88825/fbbM3fu3FRVVaVHjx45/fTT8/Wvfz1NmzZd65ivfOUrueuuu3LfffdtctMAAAAAAOtTUui5++67p6KiIk2aNMlpp52W008/Pfvss88Gj2vZsmVWrFhRyikBAAAAAGqlpMfb99hjjwwbNizvvPNObr755loFnkly8803Z/Xq1aWcEgAAAACgVkra6Tl16tRy9wEAAAAAUBYlhZ7/1yuvvJJ58+bl05/+dLp06VKOkgAAAAAAJSn56+3Lli3LD37wg2y33Xbp2rVrPv/5z+eqq66qnh85cmR69OiRyZMnl6NPAAAAAIBaKSn0/PDDD3PooYfmpz/9aRo1apSjjz46VVVVNdb07t07L774Yu66666yNAoAAAAAUBslhZ5XX311JkyYkAEDBuT111/P2LFj11rTpk2b7LHHHnn00Uc3uUkAAAAAgNoqKfQcNWpUOnTokF/+8pdp3LjxetftvvvumTVrVsnNAQAAAABsrJJCzxkzZmSfffZJgwYf/R2kRo0aZf78+SU1BgAAAABQipJCzyZNmtQqzJwxY0a23XbbUk4BAAAAAFCSkkLPvffeO88991zmzp273jUzZszICy+8kH333bfk5gAAAAAANtZHP5++Ht/+9rfzxBNP5KSTTspvf/vbbLfddjXm33///QwYMCArVqzId77znbI0CgB1yaRTTy1rvR4jRpS1HgAAwCdZSaHnSSedlLFjx+a3v/1tOnXqlIMOOihJ8vTTT+e4447LuHHjsnDhwnzjG9/Il7/85bI2DAAAAADwUUp6vD1J7rjjjvz0pz9N48aN88gjjyRJXnnllYwdOzYVFRX58Y9/nFtvvbVsjQIAAAAA1EZJOz2TpKKiIueff34GDRqUSZMm5Y033sjq1avTrl277LvvvmnUqFE5+wQAAAAAqJWSQ8816tevn3333dcHiwAAAACAOqHkx9sBAAAAAOqiWu30vOyyy0o+QUVFRS6++OKSjwcAAAAA2Bi1Cj2HDBmSioqKVFVVbfQJhJ4AAAAAwJZUq9DTV9gBAAAAgI+LWoWe3/zmNzd3HwAAAAAAZeFDRgAAAABAodRqp+dHefvtt/PnP/8577zzTpKkTZs2Ofjgg9OuXbtNbg4AAAAAYGOVHHq+8847Oeuss3Lfffet9YGjioqK9O3bN7/4xS+EnwAAAADAFlVS6PnOO+/kwAMPzKxZs9K0adMceeSR2XnnnZMkM2fOzCOPPJJ77703zz//fMaPH582bdqUs2cAAAAAgPUqKfT8wQ9+kFmzZuXkk0/OsGHD0qpVqxrz8+fPz8CBAzNixIj88Ic/9PV3AIDNbNKpp5a9Zo8RI8peEwAAtoSSPmT04IMPZpdddsltt922VuCZJNtuu22GDx+eXXbZJffff/8mNwkAAAAAUFslhZ6LFy/OAQcckPr16693Tf369bP//vtnyZIlJTcHAAAAALCxSgo9P/OZz1R/rf2jzJ49O127di3lFAAAAAAAJSkp9Bw4cGCefPLJPPzww+td88gjj+TJJ5/MueeeW3JzAAAAAAAbq6QPGX3hC1/IGWeckWOPPTZf+9rX8rWvfS0dO3ZM8s+vt991110ZNWpUzjzzzBx66KF58803axzfoUOHTe8cAAAAAGAdSgo9d95551RUVKSqqip33HFH7rjjjrXWVFVV5cYbb8yNN95YY7yioiIrV64srVsAAAAAgA0oeadnRUVFuXsBAAAAANhkJYWeTzzxRJnbAAAAAAAoj5I+ZAQAAAAAUFcJPQEAAACAQinp8fY1Pvjggzz++ON55ZVXsmjRolRVVa21pqKiIhdffPGmnAYAAAAAoNZKDj1vu+22nHfeeVm4cGH1WFVVVY0PHK35XegJAAAAAGwpJT3e/uijj+Zb3/pWKioq8oMf/CAHHnhgkuS//uu/cv7552e33XZLVVVVzjrrrAwfPrysDQMAAAAAfJSSQs+hQ4emoqIijz/+eC6//PJ07tw5SfLtb387V111VV566aUMHDgww4cPT8+ePcvaMAAAAADARykp9Hz22WdzwAEHZK+99lrnfIMGDfKzn/0s22+/fS699NJNahAAAAAAYGOUFHouXrw4HTp0qP69srIySbJo0aL/f+F69bL//vvnqaee2sQWAQAAAABqr6TQc8cdd8x7771X/ftOO+2UJJk+fXqNde+9914+/PDDTWgPAAAAAGDjlBR6du3aNa+88kr17wcddFCqqqpy9dVXp6qqKknyzDPP5LHHHsvuu+9enk4BAAAAAGqhpNDzmGOOyYwZMzJx4sQkyeGHH55u3brl7rvvTtu2bdOzZ88cdthhWb16dQYOHFjOfgEAAAAAPlJJoec3vvGNPPjgg9lhhx3+WaRevdx///054ogjMmfOnLzwwgtp2rRprrjiipxyyillbRgAAAAA4KM0KOWgli1b5qijjqox1rZt2zz00EP54IMPsmDBgmy//fapX79+WZoEAAAAAKitkkLPj9K0adM0bdq03GUBgDqg47Dy1pt5bnnrAQAAJCU+3g4AAAAAUFeVvNNzzpw5uemmm/Lkk09m9uzZWbZs2TrXVVRU5LXXXiu5QQAAAACAjVFS6Pnyyy+nV69eeffdd1NVVVXungAAAAAASlbS4+3nn39+5s2bl379+uW5557LwoULs3r16vX+AAAAAABsKSXt9Hzqqaey++6756677kpFRUW5ewIAAAAAKFlJOz2rqqqy9957CzwBAAAAgDqnpNBzn332ycyZM8vdCwAAAADAJisp9BwyZEieffbZjB07ttz9AAAAAABsklq90/PJJ59ca+zcc89Nv3798vWvfz1HHHFE2rVrl3r11p2hfuELX9i0LgEAAAAAaqlWoeehhx66zvd3VlVVZcSIERk5cuRHHr9q1arSugMAAAAA2Ei1Cj2/8Y1v+GgRAFB2k049tew1e4wYUfaaAADAx0utQs/bbrttM7cBAAAAAFAeJX3ICAAAAACgrqrVTs/a+OCDD/LMM89k3rx5adu2bQ488MA0aFC28gAAAAAAtVKrVPK1117LPffck8985jPp27fvWvN33313vvvd7+b999+vHmvbtm1GjBiRXr16la1ZAAAAAIANqdXj7b/97W8zePDgLFmyZK25559/Pl//+tczf/78NGnSJD169Mi2226bt956K3379s2sWbPK3jQAAAAAwPrUKvR88skn06RJkxx33HFrzV122WVZuXJl9txzz7z22mt59tlnM2fOnPzHf/xHFi9enF/84hdlbxoAAAAAYH1qFXq++uqr2WeffdKkSZMa4x9++GEeeuihVFRU5Oqrr84OO+zwz6L16uW6667Ltttumz/+8Y/l7xoAAAAAYD1q9U7POXPm5MADD1xr/LnnnsuKFSvSvHnzHHHEETXmmjZtmn322ScTJkwoT6cAUKKOw8pfc3T5SwIAAFAmtdrpuXLlyhofKVrj+eefT5L07NlznV9qb926dT788MNN6xAAAAAAYCPUKvRs3759Jk+enFWrVtUY/9Of/pSKiooccMAB6zxu/vz5ad269aZ3CQAAAABQS7UKPXv37p3Zs2fnRz/6UfXY008/nYceeihJcuyxx67zuBdeeCHt2rUrubkPP/wwl1xySbp06ZLGjRunTZs2GTBgQN5+++2NrjV//vyce+656dixYyorK9OxY8cMHDhwnTtY12X58uXZY489UlFRsc5drQAAAABA3VCr0PP73/9+GjdunB//+Mfp0KFDevbsmcMOOyyrVq3KQQcdtM6dnn/5y1/yj3/8Y53vAq2NpUuXpnfv3rn88suzePHiHHfccWnfvn1uvfXWdO/ePa+//nqta82bNy/77bdfrr/++jRo0CDHH398mjdvnmHDhmX//ffPe++9t8EaP/nJT/L3v/+9pGsBAAAAALacWoWeu+22W0aPHp3tttsub731Vl544YWsXLkye+yxR+644451HnPdddclSY466qiSGrviiisyfvz4HHjggZk+fXpGjRqVCRMmZOjQoZk7d24GDBhQ61oDBw7Mq6++mn79+mXatGkZNWpUpk6dmrPPPjvTp0/PoEGDPvL4l19+OVdeeWW+/e1vl3QtAAAAAMCWU6vQM0mOPPLIzJw5M4888kjuuOOOPPnkk5kyZUo6dOiwzvWnnHJKRo8end69e290U8uXL88NN9yQJLnxxhuzzTbbVM8NGjQo3bp1y7hx46o/pPRRZs+enTvvvDONGjXKTTfdVOPR9GuuuSatW7fOyJEjM2fOnHUeX1VVle985zv51Kc+lauuumqjrwUAAAAA2LJqHXomSePGjfPFL34xJ510Uj7/+c+nXr31H963b98cd9xxadSo0UY39fTTT2fBggXZdddd071797XmTzzxxCTJ2LFjN1jroYceyurVq3PIIYdkhx12qDFXWVmZvn37ZtWqVXnggQfWefx//dd/5c9//nOGDh2abbfddqOvBQAAAADYsjYq9NxSXnzxxSRJjx491jm/ZnzKlCmbtdbs2bNz4YUX5vDDD88pp5yy4cYBAAAAgK2uToaeb775ZpKs98vva8Znzpy5WWudddZZWbp0aW666aYNNw0AAAAA1AkNNrxky1u8eHGSpGnTpuucb9asWZJk0aJFm63Wvffem9///ve59NJL06VLl9o1/n8sW7Ysy5Ytq/594cKFJdUBAAAAAGqvTu703NoWLVqUs846K126dMngwYNLrnPllVemZcuW1T/t27cvY5cAAAAAwLrUydBzzdfaP/jgg3XOL1myJEnSvHnzzVLrBz/4Qd56663cdNNNqaysrH3j/8fgwYOzYMGC6p9Zs2aVXAsAAAAAqJ06+Xh7hw4dkiRvvfXWOufXjHfs2HGz1Bo7dmwaN26cyy+/PJdffvlax6xatSqHHnpokuS6667L3nvvvc7alZWVmxSaAgAAAAAbr06GnnvttVeSZNKkSeucXzPerVu3zVZr6dKlGTdu3Hrrrpl7//33N9gDAAAAALDl1MnH2w8++OC0bNkyr732WiZPnrzW/N13350k6du37wZr9enTJ/Xq1ctTTz2VOXPm1JhbtmxZxo4dm/r16+foo4+uHn/jjTdSVVW1zp8kqV+/fvXva3Z8AgAAAAB1wyaFnn/+859z/vnn5/jjj8/hhx+e3r17r/Vz+OGHb3TdRo0a5ayzzkqSnHnmmdXv3UySa6+9NlOmTEmvXr3Ss2fP6vEbbrghXbt2XevDQzvttFNOOumkLF++PGeccUZWrlxZPXfBBRdk7ty5OeWUU7L99ttvdJ8AAAAAQN1T0uPtVVVV+da3vpXbb7+9evdjRUVF9b//9feKioqSGrvooovy6KOP5plnnknnzp1zyCGHZObMmZkwYUJat26d4cOH11g/b968TJs2LbNnz16r1nXXXZfx48fnnnvuSdeuXbPPPvvkpZdeytSpU9O5c+dce+21JfUIAAAAANQ9Je30/NWvfpXbbrstPXv2zB//+Mf069cvSTJt2rQ8+OCD6d+/f+rVq5fzzz8/r7/+ekmNNW7cOI8//nguvvjiNG3aNGPGjMnMmTPTv3//TJo0KZ06dap1re222y4TJ07M2WefneXLl2f06NFZsGBBzjnnnEycODGtWrUqqUcAAAAAoO4paafnbbfdlmbNmuXBBx/Mpz/96YwcOTJJ0rlz53Tu3DlHHXVUjj766Hzta1/LQQcdVKuvrK9LkyZNctlll+Wyyy7b4NohQ4ZkyJAh651v1apVrr/++lx//fUl9bLGv+5mBQAAAADqnpJ2er788ss56KCD8ulPfzpJqh9hX7VqVfWaE088MT179szPfvazMrQJAAAAAFA7JYWeq1evrg48k6Rp06ZJkvnz59dY17lz5/z1r3/dhPYAAAAAADZOSaFn27Zt884771T/vubx9RdeeKHGuunTp6dBg5KeoAcAAAAAKElJoWePHj3yt7/9rfpx9iOPPDJVVVW54IIL8ve//z2LFi3KNddck+effz7du3cva8MAAAAAAB+lpNDz2GOPzbx583L//fcnSfbaa6/8+7//e1588cXsueee+dSnPpULL7wwDRo0yI9//OOyNgwAAAAA8FFKevb8pJNOSr9+/Wo8un777benW7duGTNmTObPn58uXbrkggsuyH777Ve2ZgEAAAAANqTkF25WVlbW+L1hw4a58MILc+GFF25yUwAAAAAApSrp8fb/+Z//yTPPPLPBdePHj8///M//lHIKAAAAAICSlBR69u/fPzfffPMG191yyy057bTTSjkFAAAAAEBJSgo9a2v16tWpqKjYnKcAAAAAAKhhs4aer7/+elq0aLE5TwEAAAAAUEOtP2R02WWX1fh98uTJa42tsXLlykybNi1PPvlkjjjiiE3rEAAAAABgI9Q69BwyZEgqKipSVVWVioqKTJ48OZMnT/7IY7bffvv85Cc/2dQeAQAAAABqrdah56233pokqaqqyoABA/L5z38+3/rWt9a5tlGjRmnTpk0OOOCAVFZWlqdTAAAAAIBaqHXo+c1vfrP637fffnu+9KUv1RgDAAAAAKgLah16/qvHH3+83H0AAAAAAJTFZv16OwAAAADAllbSTs/kn+/2vOOOO3LvvffmlVdeyaJFi1JVVbXWuoqKirz22mub1CQAAAAAQG2VFHouX748xxxzTB577LF1Bp1Jqr/0DgAAAACwJZX0ePvQoUPzpz/9KV/+8pfzyiuv5NRTT01FRUWWLVuWl19+OUOGDEmzZs1y/vnnZ/Xq1eXuGQAAAABgvUra6Tlq1Ki0atUqv/nNb9KsWbPUq/fP7LRhw4bZfffdc8kll+Swww7LYYcdlt133z0DBgwoa9MAAAAAAOtT0k7PV199Nfvtt1+aNWv2zyL/X+i5atWq6jWHHHJIDj744Nx0001laBMAAAAAoHZKCj3r16+fli1bVv++JvycO3dujXVt27bNtGnTNqE9AAAAAICNU1Lo2bZt27z11lvVv++2225JkvHjx9dYN2XKlGyzzTab0B4AAAAAwMYp6Z2eBxxwQEaPHp1ly5alsrIyRx99dM4777wMHDgwjRs3Ttu2bfPf//3fefnll9O3b99y9wzwidBxWPlrzjy3/DUBAACgrilpp+cJJ5yQxo0b55FHHknyz52eAwcOzJtvvpljjjkme++9d2688cY0bdo0V199dVkbBgAAAAD4KCXt9DzmmGMye/bsGmNDhw7NvvvumzFjxmT+/Pnp0qVLzjnnnHTu3LksjQIAAAAA1EZJoef6/Pu//3v+/d//vZwlAQAAAAA2SllDTwDqtkmnnlr2mj1GjCh7TQAAANgUJYWezzzzTB5//PG8/PLLmT9/fioqKtKqVavsscceOeyww7L//vuXu08AAAAAgFrZqNBzypQpGTBgQF544YUkSVVVVY35ioqKJMl+++2XW265JXvssUeZ2gQAAAAAqJ1ah57PPvtsevfunSVLlqRZs2b50pe+lL333jvbbbddqqqqMm/evLzwwgt5+OGHM2HChBx44IF54okn0r17983ZPwAAAABADbUKPVetWpWTTz45S5Ysybe+9a0MHTo0LVq0WOfahQsXZtCgQRk+fHi+/vWv529/+1v1DlAAAAAAgM2tXm0W3XvvvXn11Vfzta99Lb/+9a/XG3gmSYsWLXLzzTfnK1/5SqZPn56xY8eWrVkAAAAAgA2pVeg5duzY1KtXLz/5yU9qXfjKK69MkowZM6akxgAAAAAASlGr0PP555/P7rvvnl122aXWhTt16pSuXbvm+eefL7k5AAAAAICNVavQc/bs2enSpctGF+/SpUveeeedjT4OAAAAAKBUtQo9FyxYkJYtW2508RYtWmThwoUbfRwAAAAAQKlqFXquXLky9erVamnN4vXqZeXKlRt9HAAAAABAqTY+yQQAAAAAqMMa1Hbh7bffnttvv31z9gIAAAAAsMlqHXpWVVWVdIKKioqSjgMAAAAAKEWtQs/Vq1dv7j4AAAAAAMrCOz0BAAAAgEIRegIAAAAAhSL0BAAAAAAKRegJAAAAABSK0BMAAAAAKBShJwAAAABQKEJPAAAAAKBQhJ4AAAAAQKEIPQEAAACAQhF6AgAAAACF0mBrNwAUT8dh5a0389zy1gMAAACKzU5PAAAAAKBQhJ4AAAAAQKEIPQEAAACAQvFOT/j/lPs9lIl3UQIAAABsDXZ6AgAAAACFIvQEAAAAAApF6AkAAAAAFIrQEwAAAAAoFKEnAAAAAFAoQk8AAAAAoFCEngAAAABAoTTY2g0AAEBdMunUU8tar8eIEWWtBwDAhtnpCQAAAAAUitATAAAAACgUoScAAAAAUChCTwAAAACgUISeAAAAAEChCD0BAAAAgEIRegIAAAAAhSL0BAAAAAAKRegJAAAAABSK0BMAAAAAKBShJwAAAABQKEJPAAAAAKBQhJ4AAAAAQKE02NoNAGzIpFNPLXvNHiNGlL0mAAAAUDfY6QkAAAAAFIrQEwAAAAAoFKEnAAAAAFAoQk8AAAAAoFCEngAAAABAoQg9AQAAAIBCEXoCAAAAAIUi9AQAAAAACkXoCQAAAAAUitATAAAAACgUoScAAAAAUChCTwAAAACgUISeAAAAAEChCD0BAAAAgEIRegIAAAAAhSL0BAAAAAAKRegJAAAAABSK0BMAAAAAKBShJwAAAABQKHU69Pzwww9zySWXpEuXLmncuHHatGmTAQMG5O23397oWvPnz8+5556bjh07prKyMh07dszAgQPz/vvvr7V2xYoVeeSRR3LWWWfls5/9bJo2bZomTZrkM5/5TL7//e9n7ty5Zbg6AAAAAGBzqLOh59KlS9O7d+9cfvnlWbx4cY477ri0b98+t956a7p3757XX3+91rXmzZuX/fbbL9dff30aNGiQ448/Ps2bN8+wYcOy//7757333quxfty4cTnqqKNy4403ZsmSJfnSl76UI444IvPmzcvQoUPTrVu3TJs2rdyXDAAAAACUQZ0NPa+44oqMHz8+Bx54YKZPn55Ro0ZlwoQJGTp0aObOnZsBAwbUutbAgQPz6quvpl+/fpk2bVpGjRqVqVOn5uyzz8706dMzaNCgGuvr1auXr371q5kwYUJmzJiRe+65J/fdd19effXVHHXUUfnHP/6R0047rdyXDAAAAACUQZ0MPZcvX54bbrghSXLjjTdmm222qZ4bNGhQunXrlnHjxuX555/fYK3Zs2fnzjvvTKNGjXLTTTelQYMG1XPXXHNNWrdunZEjR2bOnDnV4717986oUaOy33771ajVsmXLDB8+PEnyl7/8JTNnztyk6wQAAAAAyq9Ohp5PP/10FixYkF133TXdu3dfa/7EE09MkowdO3aDtR566KGsXr06hxxySHbYYYcac5WVlenbt29WrVqVBx54oFa9tWnTJq1bt06SvPPOO7U6BgAAAADYcupk6Pniiy8mSXr06LHO+TXjU6ZM2aK1kuT999/P/PnzkyQ77rhjrY4BAAAAALacBhtesuW9+eabSZJ27dqtc37NeG0eLy9nreSfj9uvXLkyn/vc57LLLrt85Nply5Zl2bJl1b8vXLiwVucAAAAAAEpXJ3d6Ll68OEnStGnTdc43a9YsSbJo0aItWuuFF17IFVdckST56U9/usH1V155ZVq2bFn90759+w0eAwAAAABsmjoZetZF//u//5t+/fpl6dKlGThwYL70pS9t8JjBgwdnwYIF1T+zZs3aAp0CAAAAwCdbnXy8fc3X2j/44IN1zi9ZsiRJ0rx58y1Sa9GiRTn66KPzxhtv5Ctf+UqGDh26wfMm//xQUmVlZa3WAgAAAADlUSd3enbo0CFJ8tZbb61zfs14x44dN3utpUuX5thjj82kSZNy5JFHZuTIkalXr07eNgAAAAAgdTT03GuvvZIkkyZNWuf8mvFu3bpt1lorV67M1772tTzxxBM56KCD8vvf/z6NGjXa8AUAAAAAAFtNnQw9Dz744LRs2TKvvfZaJk+evNb83XffnSTp27fvBmv16dMn9erVy1NPPZU5c+bUmFu2bFnGjh2b+vXr5+ijj64xV1VVldNOOy333Xdf9t5779x///3VHz0CAAAAAOquOhl6NmrUKGeddVaS5Mwzz6x+72aSXHvttZkyZUp69eqVnj17Vo/fcMMN6dq1awYPHlyj1k477ZSTTjopy5cvzxlnnJGVK1dWz11wwQWZO3duTjnllGy//fY1jhs4cGBGjhyZrl275pFHHsmnPvWpzXClAAAAAEC51ckPGSXJRRddlEcffTTPPPNMOnfunEMOOSQzZ87MhAkT0rp16wwfPrzG+nnz5mXatGmZPXv2WrWuu+66jB8/Pvfcc0+6du2affbZJy+99FKmTp2azp0759prr62x/t57783111+fJGnfvn3OP//8dfZ44YUXpmvXrmW6YgAAAACgHOps6Nm4ceM8/vjjufLKK/Ob3/wmY8aMSatWrdK/f/9cfvnladeuXa1rbbfddpk4cWKGDBmSMWPGZPTo0dlhhx1yzjnn5Ec/+tFauzjnz59f/e8//vGP663bv39/oScAAAAA1DF1NvRMkiZNmuSyyy7LZZddtsG1Q4YMyZAhQ9Y736pVq1x//fXVOzg/Sv/+/dO/f/+N6BQAAAAAqCvq5Ds9AQAAAABKJfQEAAAAAApF6AkAAAAAFIrQEwAAAAAoFKEnAAAAAFAoQk8AAAAAoFCEngAAAABAoQg9AQAAAIBCEXoCAAAAAIUi9AQAAAAACkXoCQAAAAAUitATAAAAACgUoScAAAAAUChCTwAAAACgUISeAAAAAEChCD0BAAAAgEIRegIAAAAAhSL0BAAAAAAKRegJAAAAABSK0BMAAAAAKBShJwAAAABQKEJPAAAAAKBQhJ4AAAAAQKEIPQEAAACAQhF6AgAAAACFIvQEAAAAAApF6AkAAAAAFIrQEwAAAAAoFKEnAAAAAFAoQk8AAAAAoFCEngAAAABAoQg9AQAAAIBCEXoCAAAAAIUi9AQAAAAACkXoCQAAAAAUitATAAAAACgUoScAAAAAUChCTwAAAACgUISeAAAAAEChCD0BAAAAgEIRegIAAAAAhSL0BAAAAAAKRegJAAAAABSK0BMAAAAAKBShJwAAAABQKEJPAAAAAKBQhJ4AAAAAQKEIPQEAAACAQhF6AgAAAACFIvQEAAAAAApF6AkAAAAAFIrQEwAAAAAoFKEnAAAAAFAoQk8AAAAAoFCEngAAAABAoQg9AQAAAIBCEXoCAAAAAIUi9AQAAAAACkXoCQAAAAAUitATAAAAACgUoScAAAAAUChCTwAAAACgUISeAAAAAEChCD0BAAAAgEJpsLUbgCKbdOqpZa3XY8SIstYDAAAAKCI7PQEAAACAQhF6AgAAAACFIvQEAAAAAApF6AkAAAAAFIrQEwAAAAAoFKEnAAAAAFAoQk8AAAAAoFCEngAAAABAoQg9AQAAAIBCEXoCAAAAAIUi9AQAAAAACkXoCQAAAAAUitATAAAAACgUoScAAAAAUChCTwAAAACgUISeAAAAAEChCD0BAAAAgEIRegIAAAAAhSL0BAAAAAAKRegJAAAAABSK0BMAAAAAKBShJwAAAABQKA22dgNsmo7Dyl9z5rnlrwkAAAAAW4qdngAAAABAoQg9AQAAAIBCEXoCAAAAAIUi9AQAAAAACkXoCQAAAAAUitATAAAAACgUoScAAAAAUChCTwAAAACgUISeAAAAAEChCD0BAAAAgEIRegIAAAAAhVKnQ88PP/wwl1xySbp06ZLGjRunTZs2GTBgQN5+++2NrjV//vyce+656dixYyorK9OxY8cMHDgw77///nqPWbVqVX7+85/nc5/7XJo0aZLWrVvnq1/9al5++eVNuCoAAAAAYHOqs6Hn0qVL07t371x++eVZvHhxjjvuuLRv3z633nprunfvntdff73WtebNm5f99tsv119/fRo0aJDjjz8+zZs3z7Bhw7L//vvnvffeW+uY1atX5ytf+UoGDRqUt956K8ccc0z23HPP3H333dlnn30yceLEcl4uAAAAAFAmdTb0vOKKKzJ+/PgceOCBmT59ekaNGpUJEyZk6NChmTt3bgYMGFDrWgMHDsyrr76afv36Zdq0aRk1alSmTp2as88+O9OnT8+gQYPWOmb48OEZPXp0OnfunL///e+5++6788QTT+R3v/tdPvjgg5x88slZuXJlOS8ZAAAAACiDOhl6Ll++PDfccEOS5MYbb8w222xTPTdo0KB069Yt48aNy/PPP7/BWrNnz86dd96ZRo0a5aabbkqDBg2q56655pq0bt06I0eOzJw5c2ocd+211yZJrr766uywww7V4yeccEKOPfbYvPrqq7n33ns36ToBAAAAgPKrk6Hn008/nQULFmTXXXdN9+7d15o/8cQTkyRjx47dYK2HHnooq1evziGHHFIjvEySysrK9O3bN6tWrcoDDzxQPT5jxoy8/PLLadKkSY455phNOj8AAAAAsGXVydDzxRdfTJL06NFjnfNrxqdMmbJZaq055rOf/WwaNmy4SecHAAAAALasBhtesuW9+eabSZJ27dqtc37N+MyZMzdLrXKdf9myZVm2bFn17wsXLtxgvwAAAADApqmToefixYuTJE2bNl3nfLNmzZIkixYt2iy1ynX+K6+8Mj/60Y822OOmmHlu+WtOOvXUstfsMWJE2WuW2+a4l0ndv+7Nofz30n0sH/eyfNzL8nAfy8e9LB/3sjzcx/JxL8vHvSwP97F83MvycS/Lozj3sU4+3l4UgwcPzoIFC6p/Zs2atbVbAgAAAIDCq5M7Pdd8rf2DDz5Y5/ySJUuSJM2bN98stcp1/srKylRWVm6wRwAAAACgfOrkTs8OHTokSd566611zq8Z79ix42apVc7zAwAAAABbVp0MPffaa68kyaRJk9Y5v2a8W7dum6XWmmOmTp2aFStWbNL5AQAAAIAtq06GngcffHBatmyZ1157LZMnT15r/u67706S9O3bd4O1+vTpk3r16uWpp57KnDlzaswtW7YsY8eOTf369XP00UdXj++yyy75zGc+kw8//DD333//Jp0fAAAAANiy6mTo2ahRo5x11llJkjPPPLP6HZpJcu2112bKlCnp1atXevbsWT1+ww03pGvXrhk8eHCNWjvttFNOOumkLF++PGeccUZWrlxZPXfBBRdk7ty5OeWUU7L99tvXOG7QoEHVa/41LP3973+f++67L7vttluOO+648l00AAAAAFAWdfJDRkly0UUX5dFHH80zzzyTzp0755BDDsnMmTMzYcKEtG7dOsOHD6+xft68eZk2bVpmz569Vq3rrrsu48ePzz333JOuXbtmn332yUsvvZSpU6emc+fOufbaa9c6ZsCAAXnggQcyevTodO3aNYcffnjmzZuXcePGpUmTJhk5cmQaNKiztw8AAAAAPrHq5E7PJGncuHEef/zxXHzxxWnatGnGjBmTmTNnpn///pk0aVI6depU61rbbbddJk6cmLPPPjvLly/P6NGjs2DBgpxzzjmZOHFiWrVqtdYx9erVy+9+97sMHTo0bdq0yR/+8If89a9/zQknnJDnnnsu+++/fzkvFwAAAAAok4qqqqqqrd3EJ8XChQvTsmXLLFiwIC1atNja7azXpFNPLXvNHiNGlL0mAAAAAJ8stc3X6uxOTwAAAACAUgg9AQAAAIBCEXoCAAAAAIUi9AQAAAAACkXoCQAAAAAUitATAAAAACgUoScAAAAAUChCTwAAAACgUISeAAAAAEChCD0BAAAAgEIRegIAAAAAhSL0BAAAAAAKRegJAAAAABSK0BMAAAAAKBShJwAAAABQKEJPAAAAAKBQhJ4AAAAAQKEIPQEAAACAQhF6AgAAAACFIvQEAAAAAApF6AkAAAAAFIrQEwAAAAAoFKEnAAAAAFAoQk8AAAAAoFCEngAAAABAoQg9AQAAAIBCEXoCAAAAAIUi9AQAAAAACkXoCQAAAAAUitATAAAAACgUoScAAAAAUChCTwAAAACgUISeAAAAAEChCD0BAAAAgEIRegIAAAAAhSL0BAAAAAAKRegJAAAAABSK0BMAAAAAKBShJwAAAABQKEJPAAAAAKBQhJ4AAAAAQKEIPQEAAACAQhF6AgAAAACFIvQEAAAAAApF6AkAAAAAFIrQEwAAAAAoFKEnAAAAAFAoQk8AAAAAoFCEngAAAABAoQg9AQAAAIBCEXoCAAAAAIUi9AQAAAAACkXoCQAAAAAUitATAAAAACgUoScAAAAAUChCTwAAAACgUISeAAAAAEChCD0BAAAAgEJpsLUboO7pMWLE1m4BAAAAAEpmpycAAAAAUChCTwAAAACgUISeAAAAAEChCD0BAAAAgEIRegIAAAAAhSL0BAAAAAAKRegJAAAAABSK0BMAAAAAKBShJwAAAABQKEJPAAAAAKBQhJ4AAAAAQKEIPQEAAACAQhF6AgAAAACFIvQEAAAAAApF6AkAAAAAFIrQEwAAAAAoFKEnAAAAAFAoQk8AAAAAoFCEngAAAABAoQg9AQAAAIBCEXoCAAAAAIUi9AQAAAAACkXoCQAAAAAUitATAAAAACgUoScAAAAAUChCTwAAAACgUISeAAAAAEChCD0BAAAAgEIRegIAAAAAhSL0BAAAAAAKRegJAAAAABSK0BMAAAAAKBShJwAAAABQKA22dgOfJFVVVUmShQsXbuVOAAAAAODjZ02utiZnWx+h5xa0aNGiJEn79u23cicAAAAA8PG1aNGitGzZcr3zFVUbikUpm9WrV+edd95J8+bNU1FRsbXbWaeFCxemffv2mTVrVlq0aLG12/lYcy/Lw30sH/eyfNzL8nAfy8e9LB/3sjzcx/JxL8vHvSwP97F83MvycS/L4+NyH6uqqrJo0aK0adMm9eqt/82ddnpuQfXq1Uu7du22dhu10qJFizr9B/5x4l6Wh/tYPu5l+biX5eE+lo97WT7uZXm4j+XjXpaPe1ke7mP5uJfl416Wx8fhPn7UDs81fMgIAAAAACgUoScAAAAAUChCT2qorKzMpZdemsrKyq3dyseee1ke7mP5uJfl416Wh/tYPu5l+biX5eE+lo97WT7uZXm4j+XjXpaPe1keRbuPPmQEAAAAABSKnZ4AAAAAQKEIPQEAAACAQhF6AgAAAACFIvQEAAAAAApF6AkAAAAAFIrQEwAAAAAoFKEnAAAAUGtz5szJm2++ubXbAPhIFVVVVVVbuwm2nCuuuCKHHHJIevXqtbVbgRpWr16dv/3tb2nUqFE6d+6cioqK6rnnn38+Y8eOzdy5c7Prrrvma1/7Wtq2bbsVu/34mTJlSq655pqMGzcuc+bMyTbbbJMePXrk9NNPT79+/bZ2e3XWypUr8+6776ZVq1Zp2LDhR6597733snjx4nTo0GELdffx8sILL2Ts2LGZMmVKZs6cmUWLFiVJmjdvno4dO6Zbt27p27dvunfvvpU7BTbGuHHj8uyzz+bTn/50/u3f/i2f+tSnkiQrVqzI8OHD8+STT2b+/PnZeeedc+KJJ6Z3795bt+GPoWXLlmXChAmZPXt2mjVrlh49eqRNmzZbuy0+4Q477LA89dRTWbly5dZu5WPhr3/9a+699968+OKL1f87qF69etl2222z55575tBDD02/fv1SWVm5tVuFYqniE6WioqKqXr16VR07dqz64Q9/WPXyyy9v7ZYK7+GHH666/fbbt3Ybddr9999ftdNOO1XVq1evql69elVdu3ateuGFF6qqqqqqfvKTn1TVr1+/ql69etV/v82aNau6++67t27TddD5559f1bBhw6pnn322xvidd95ZVVlZWX0P//WnXr16VaeffvpW6rjumjt3btXJJ59c1aRJk6p69epVVVZWVh1//PFVU6ZMWe8x/fv3r6pfv/4W7PLjYcb/r707D4rizN8A/vQgl4jK6QEK4oVRvPBARAQUxGhiYowHHlHWHGoSL7SsisbEuHHdeLtGTaKCB5pEd+MV3ajxQNCgsqKAoqx4oLASRQ0wKDLf3x8W4w9nEDTAMMPzqeoq6+1+nWe6pq8vb3enp0tgYKB2+372N/js7zEoKEjS09MNHZuIymHUqFHabVulUomjo6MkJibK/fv3pUuXLjrbvEqlkgkTJhg6drXz73//W5KSkvTOW7Fihdjb25dYzyqVSt58803Jzs6u4qRETwUEBIhKpTJ0jGrv5s2bEhoaqnMepG//6OzsLJs2bTJ0ZJPz888/83q8nHJzcyUzM1MyMzMlNzfX0HEqBEd61jAq1dMnGhSPpOvcuTNGjx6N4cOHw9nZ2VDRTFZgYCCOHTuGoqIiQ0eplpKSkuDt7Y3CwkI0b94c5ubmSE1NhYuLC6Kjo+Hv7w9vb28MGzYMjo6OOHLkCDZv3gxLS0ucP38eHh4ehv4K1Ya3tzdycnJw5coVbVtmZiZatGgBtVqNt99+G+PGjYO7uzvu3r2LI0eOYMmSJcjJyUFUVBRGjRplwPTVR15eHrp27YrU1FQ8e4i0sLDAokWL8OGHH+r0GzduHDZu3Mht/f+5desWOnfujNu3b6N9+/YYMmQIOnfuDFdXV9jY2AB4sr4zMjKQkJCAH3/8EefPn0eDBg1w5swZjmTSIzk5GYcPH4aFhQWCg4PRrFkzAE9GJa9cuRI7d+7UjooPDw/HG2+8YdjAJmT+/PlIT0/HunXrDB2lWoiMjER4eDjs7e21x4/NmzejSZMmCA4OxqJFizBw4EAMHToU9erVQ3x8PJYtW4b8/Hxs3boVQ4cONfA3qD5UKhXGjRun89uaP38+5s6dCxFBly5d0LJlS+Tk5CAmJgZ5eXnw8vJCfHw8R4bpUVRUhLi4ONy6dQsNGzaEr6/vc+/YiIuLQ1paGsaMGVOFKaunVq1alWu5mzdvoqCgAM2bN9e2KYqC1NTUyopmdO7cuYNOnTohIyMD7u7u6NmzJxwcHJCeno4DBw6gqKgIn332GZydnREbG4sdO3YgNzcXn376KebOnWvo+CajR48eiI+P5zm6Hg8ePMC6deu0d2Pl5OSUmG9nZ4f27dvj9ddfR3h4OOrWrWugpH+CYWuuVNUURZExY8bIvn37JCwsTOrUqaP9y5K5ubkMGDBAtm3bJmq12tBRq72bN2+Wa+rRo4eoVCq5detWiXZ6YsyYMaIoiqxevVrbtnHjRlEURZo1ayYhISFSWFhYos+KFStEURSZMmVKVcet1uzt7WXAgAEl2pYtWyaKosjMmTP19vnPf/4jVlZW4ufnVxURjcK8efNEURTp3LmznDhxQvLz8yUpKUnGjx+v/Sv9jBkzdPqNHTuWIx6eER4eLoqiyNKlS8vdZ/HixaIoivzlL3+pvGBG6pNPPtGOfC8egbxp0ybRaDTy+uuv6x05GxERYejYJsPHx4fb+P/Tq1cvsbCwkIsXL2rbUlJSxNzcXKysrPTeRXDixAkxMzOTvn37VmXUak9RFBk3blyJtuvXr4uFhYXY2NjIL7/8UmLe7du3pWfPnqJSqWTZsmVVGdUoxMbGiru7e4mRsQ0aNJBvvvmm1D48hj+lbxRieSeuw5I+/PBD7Xn4s9czGRkZ4uXlJY0aNZKcnBwREcnMzJRu3bqJSqWSY8eOGSCxaeLxW7+dO3dq7yQo3obt7OzE1dVVXF1dxc7OrsS27eDgILt27TJ07BfGomcN8+xJVV5enmzcuFFCQkKkVq1a2h903bp1Zdy4cXLo0CEDpq3eitfVy0y8BfYpNzc38fT01Glv166dqFQqOX78uM68wsJCady4sXh5eVVFRKNhbW0tI0aMKNE2ceJEUalUcv369VL7BQUFia2tbWXHMxodOnSQevXqSVZWls68vXv3ip2dnahUKhk/frxoNBrtPF4w6WrcuLH4+Pi8cD8fHx9p3LhxJSQyXnv27BFFUcTW1lbGjx8vEyZMEHt7e7G2tpbvvvtOFEWRjz/+WE6dOiXp6emyYcMGcXZ25oVTBeJFU0n169eXPn366LQHBQWJSqWStLQ0vf38/PzEwcGhsuMZFX1Fz+I/8C5YsEBvn/T0dLG2thZfX9+qiGg00tPTpW7duqIoitSvX1+6desmDRo00J63v/XWW1JQUKDTj8fwp5ycnMTMzEw++OADSUtLk6tXr+qdiveJz7bTU+7u7nqvc4rFxcWJoiiyatUqbduNGzfEyspKBg8eXBURawQev3XFxcVJrVq1xNLSUiZPniwxMTGSl5ens1xeXp7ExMTIxx9/LFZWVmJubi4nT540QOKXV8vQI03JsGrXro3Ro0dj9OjRyMrKQnR0NDZv3oyzZ88iMjISUVFRcHFxwciRIzFy5Ei0a9fO0JGrFUVR0KRJk+cuk5WVhUePHvHlJqXIysrCwIEDddrbtGmDlJQUeHl56cyrVasWvLy8EBcXVxURjUbTpk2RlJRUos3KygrAk229NNbW1jq3cddkaWlp8Pf3R4MGDXTmvfrqq4iLi0NoaCjWr1+P+/fvIzo6GrVq8XCqz927d+Hv7//C/dzc3HD27NmKD2TEvv76ayiKgkOHDqFr164AgAkTJqBTp06YPHkyJk2ahOXLl2uXHzt2LFxcXNCvXz+sXbsWvXr1MlT0aufYsWMv1e/BgwcVnMS45eXlwcnJSae9+FFJpT2eonHjxoiPj6/UbKbg0qVLUBQFQ4YM0Tvf3d0d3t7eSE5OruJk1dvChQvxxx9/YNy4cVi1ahWsrKwgIoiOjsbUqVPxr3/9C/369cOuXbuM8zbNKnDx4kVMmzYNa9euRWxsLNasWQNfX1+d5YrPMd3c3Ko6otHIzMzEa6+9Vur89u3bA0CJ83dXV1f4+fnxOkcPMzOzl+onIiVekktPHp+iUqlw9OhRdO/evdTlateuDT8/P/j5+WH48OHo3bs3vvjiC+zZs6cK0/45qrIXoZqiYcOGmDZtGhISEpCSkoJZs2ahadOmyMjIwMKFC9GxY0dDR6xWgoKCoNFo4OnpiV9//RXp6el6Jx8fHwDQaacnik+YnlX8vL/STkgdHR3x6NGjSstljAYOHIjk5GTs3btX29a3b1+ICLZv3663T1ZWFuLi4tCmTZuqilntFRUVPfdCyNPTE7GxsfD09MSOHTswaNAgFBQUVGFC49G0aVPExMQgPz+/3H3y8/MRExNT5h+UaprTp0+je/fu2oInAHh5ecHX1xdqtRoTJkzQ6RMcHAxPT0+cOHGiKqNWewEBAQgMDHzh6cKFC4aOXq04OTkhLS1Np/3y5csAgJSUFL39UlJSUK9evUrNZgo0Gg0APHdf6Obmhry8vKqKZBQOHDgAV1dXrFmzRnuOqSgKRo4ciTNnzqBz5844duwYgoKC8Pvvvxs4bfVkb2+PyMhIHDhwAPn5+fD398d7772n86w/Kpu9vX2p+0Lg6X7S2tq6RLuzszPXtx7y5E5lWFhYvNDEgqeukydPok+fPs8teD6rR48eCA4ONrrzShY9SS9PT098+eWXSE9Px9GjRzF+/HieoD7j4MGDWL9+PU6dOoV27dphwYIFePz4saFjGR1nZ2fcvHlTp71t27YICgoqtd+dO3fg6OhYmdGMzqxZs2BnZ4fhw4dj7dq1ePjwIfr3749BgwZh6tSpWLx4Me7cuQMAKCwsxMGDBxEaGor79+/j/fffN3D66sPNzU1nxOyzXFxccPz4cXTp0gX79+9HaGgoR4HpMWzYMNy6dQv9+vXDuXPnylz+3Llz6NevH7KyshAWFlYFCY1HTk4O3N3dddqL7yJo0aKF3n6tWrVCZmZmZUYzOsUXP8HBwQgJCSn3xPOgknr27ImEhAR8//332ratW7ciISEBzZo1w8yZM3X+4LFmzRokJyfD29u7quNWe7m5ubh+/bp2cnBwAIDnbr/37t2DnZ1dVUU0ChkZGejWrZvelxY1adIER48eRWhoKBISEuDv76/3HJSe6NOnD5KSkhAREYHIyEh4enpi06ZNho5lVAIDA3Hx4kXMmzdPZ97du3cxadIkKIqiM5I2MzNTuw+gp1xcXKAoCq5duwa1Wl3uqVu3boaOXu08evSo1MFHz2NhYWF8A48MeW89VT19zwwqr4cPH1ZwGtOQnZ0tYWFhoiiKtG3bVmJiYkrMDwgI4DNEnmPw4MFSu3btF/p9aTQacXJykl69elViMuN0+vRpcXR0FJVKJba2tuLv7y9DhgwRc3Nz7TNl69Spo30Zyp/ZJ5iq8PBwUalUkpqaWuayubm5EhQUVOIZv/SUWq0WHx8f7fpp2bKlDBs2TKZPny5z5syROXPmyPTp02XYsGHSsmVL7W+yR48eep+5VpM5OjrKwIEDddrLeg5dWFiY2NjYVGY0o9OmTZvnPnOyNHwmWEmnTp2SWrVqiUqlkjZt2mjXq729vZw7d06srKykSZMm8u6770pERIT2fEilUslPP/1k6PjVyvOeE79lyxa9fYqKiqRRo0bSpUuXKk5bvdna2sobb7zx3GUKCwtlxIgR2pdmpqWl8ZmeZUhMTJSuXbuKSqWSoKAgSU1N5TVOOVy4cEFsbGy0+8n3339fZs2aJSNGjNA+e9bLy0uKioq0fQoKCqRevXrSv39/AyavngYPHiwqlUr27t37Qv14/NbVtWtXsbGxkf/+97/l7nP58mWxsbGRrl27VmKyiseiZw3DAkfl2bdvn/ZNkeHh4XL37l0RYdGzLIsXLxZHR0eJi4srd5/9+/eLoigye/bsSkxmvLKzs2XChAnak6nSpo4dO0p0dLSh41Y7P/30kyiKovfNw/o8fPhQ3nzzTb61tBQFBQXyySefSP369XXe8Prs22Hr168vs2fPZsFTDy8vL2nfvr1O++7du2X+/Pml9vP395dmzZpVZjSjU1zc2LZt2wv140WTru3bt4uzs7N2G27RooXExsaKiEh0dLRYWFjovAl65syZBk5d/fTu3VsCAgL0TnPnztXbp/hYNWnSpKoNW815e3uX60V4Go1GJk6cKIqiSOPGjcXX15fbdxk0Go0sW7ZMbG1txcrKSvvWZ3q+Q4cOaV+m9ez+0NvbW65du1Zi+aSkJBk7dqzs3LnTQImrr7/97W+iKEqp+8XSdO/enb/VZ2zYsEEURREnJydZsWKF3Lx5s9Rlb926JcuXLxcnJydRqVQSFRVVhUn/PEWEb6+oSY4ePYqGDRuidevWho5ikvLz8zFnzhysWLEC9vb2WLhwISIjIxETE4OioiJDxzMZcXFxuHz5Mnr37q33dk96oqCgAKdPn0ZKSgpycnKg0WhQp04duLm5oVOnTnxmYinUajWio6Nhbm6OMWPGlKuPRqPBP/7xD+Tk5GDu3LmVnNA4FRYWIjY2FomJibh+/Tpyc3MBAHXq1EHTpk3RoUMH9OzZU+8tiQS888472LJlC7Kzs8t9O6tarYaTkxMCAwOxe/fuSk5oPFavXo1JkyZpH/tRXj4+Pjh16hSP588oKirCxYsXYWlpCQ8PD6hUT5+elZaWhm3btiEjIwMNGzbEoEGD0KlTJwOmNR0nTpzApUuX0L17d3h6eho6TrUxc+ZMLF68GL/++it69+5d5vKzZ8/Gl19+qX3sBbfvsl2/fh2TJk3C3r17oSgK11k5qNVq/POf/8SZM2e0L4Hz9/dHSEiIoaMZlYSEBHzxxRfw9fXFjBkzyt3v559/RnZ2Nt55551KTGd8pkyZghUrVmj3f05OTnB1ddW+ADc/Px8ZGRnIzs4G8OSZqlOmTMGSJUsMlvllsOhJVAkSEhIwfvx4JCYmatt4QkBERC9r9+7d2LhxI2bPno0OHTqUq893332H9957D1999RWmT59eyQmNR0ZGBnbs2AEPD4/nvlX3WVlZWXj48CHfVExUjR0/flxbTNq/f3+5+ixduhQREREAeL5ORDXLwYMHsWTJEhw+fBgPHz7Uu4ylpSWCgoIwbdo09OnTp4oT/nksehJVEo1Gg6VLl2LPnj0AgMOHDxs4ERER1SS///478vLy4OzsrPNmWCIiUyQiuHLlChRFgYeHR7n7JSYm4t69e+UaHUpEZGoKCgqQmpqq926s1q1bv9RLj6oLFj2JiIiIiIiIiIjIpKjKXoSIKtK+ffuwceNGQ8cgIqIagMecisN1SWS6uH0TEZXNGPeVHOlJVMV69OiB+Ph4PjOIiIgqHY85FYfrksh0cfsmIiqbMe4rOdKTiIiIiIiIiIiITAqLnkRERERERERERGRSahk6AJGxMjMze6l+IgJFUSo4DRERmTIecyoO1yWR6eL2TURUtpq0r2TRk+glFT8O19LS8oX6PXr0qDLiEBGRCeMxp+JwXRKZLm7fRERlq0n7St7eTvSSXFxcoCgKrl27BrVaXe6pW7duho5ORERGhsecisN1SWS6uH0TEZWtJu0rWfQkeknFG/zp06cNnISIiEwdjzkVh+uSyHRx+yYiKltN2ley6En0krp16wYRQXx8/Av1Kx5KTkREVF485lQcrksi08Xtm4iobDVpX8lnehK9pODgYJw8eRI2NjYv1O/TTz9FdnZ2JaUiIiJTxGNOxeG6JDJd3L6JiMpWk/aVihhjqZaIiIiIiIiIiIioFLy9nYiIiIiIiIiIiEwKi55ERERERERERERkUlj0JCIiIiIiIiIiIpPCoicRERERERERERGZFBY9iYiIiKjaUxQFiqJU+udERkZCURR89tlnlf5ZRERERFR5WPQkIiIiIiIiIiIik8KiJxEREREREREREZkUFj2JiIiIiIiIiIjIpLDoSURERERG6erVq1AUBQEBAVCr1Zg1axbc3NxgaWmJFi1aYOHChRARvX1jY2PRt29f2Nraon79+ujXrx9+++23537e48ePsXr1avTo0QN169aFtbU1OnbsiGXLluHx48fa5YqKitCzZ08oioKvv/5a5/+JiYmBmZkZGjdujDt37vy5lUBEREREerHoSURERERG7dGjRwgJCcG3336LLl26IDAwEDdv3sSsWbMwZ84cneX37NmDgIAAHDp0CK+88gr69++PGzduwN/fHydOnND7GWq1GiEhIZg4cSIuXboEHx8fBAcHIzMzE1OnTsVbb70FjUYDADAzM8OmTZtga2uLiIgIXLx4Ufv/3L9/H6NHj4aIICoqCg4ODpWzUoiIiIhqOBY9iYiIiMionThxAmZmZkhPT8eOHTuwf/9+7WjKpUuXIjc3V7vsH3/8gfDwcDx+/Bjr16/Hb7/9hq1btyI5ORlTp07FN998o/czIiIicPjwYQwbNgxXrlzBL7/8gl27diEtLQ2vvvoqdu3aVaKvh4cHVq5cCbVajbCwMDx69AgAMHHiRFy7dg2TJ09GcHBw5a4YIiIiohpMkdLu+SEiIiIiqiYURQGAErerX716Fc2aNYNKpUJKSgpat25dos9rr72GPXv24PDhwwgICAAAbNiwAeHh4fD398fRo0dLLF9YWAgPDw9kZGRg7ty5+OyzzwAAt2/fhqurKxo2bIjU1FRYW1uX6JeVlQU3Nzd4enoiMTGxxLyhQ4fixx9/xIwZM9ChQweMGjUK7dq1w+nTp2FpaVkRq4aIiIiI9OBITyIiIiIyam5ubjoFTwBo1aoVACAzM1PbFhMTAwAYPny4zvLm5uYYMmSITvuRI0dQWFiI0NBQnYInADRs2BAtW7bE+fPnoVarS8xbu3YtXF1dsXjxYnzwwQewtLTEli1bWPAkIiIiqmQsehIRERGRUXN1ddXbbmtrCwB4+PChtu3WrVsAnhRK9XF3d9dpu3r1KgDg22+/haIoeqfk5GSICO7evVuir52dHVatWgWNRoPc3FzMmzcP7du3f9GvSEREREQvqJahAxARERER/RkqVeX+Hb/4BUUdO3ZEhw4dnrusvhGc33//vfbfZ86cqdhwRERERKQXi55EREREVGM0atQIAHDt2jW98/W1F48k9fPzw8qVK1/o87Zu3Yro6Gi0bdsWFhYW+OGHHzBgwACMGTPmBZMTERER0Yvg7e1EREREVGP06tULAPDDDz/ozHv8+DF27Nih0x4YGAgzMzPs2bMHhYWF5f6sGzduYOLEibC0tER0dDQ2b94MKysrfPTRR0hPT3/5L0FEREREZWLRk4iIiIhqjLfffhsODg44cuQIoqKitO0igrlz5+L69es6fVxcXBAeHo6rV69ixIgR+N///qezTFpaWomCqUajwZgxY3Dv3j389a9/Rfv27fHKK69g4cKFePDgAUaPHo2ioqLK+ZJERERExKInEREREdUctra2WLduHczMzDB27Fj4+PggLCwM7dq1w1dffYV3331Xb7/ly5cjODgYO3bsQPPmzeHn54ewsDAMGjQILVu2RMuWLbFp0ybt8osWLcKRI0fQp08fTJs2Tdv+0UcfISQkBLGxsViwYEGlf18iIiKimopFTyIiIiKqUQYNGoTDhw8jMDAQSUlJ2Lt3Lxo1aoSjR4/C19dXbx9ra2vs27cPUVFR6N69Oy5cuIDt27fj9OnTcHJywueff46///3vAICzZ89izpw5sLOzQ1RUFBRF0f4/iqIgMjISDg4O+PzzzxEfH18l35mIiIioplFERAwdgoiIiIiIiIiIiKiicKQnERERERERERERmRQWPYmIiIiIiIiIiMiksOhJREREREREREREJoVFTyIiIiIiIiIiIjIpLHoSERERERERERGRSWHRk4iIiIiIiIiIiEwKi55ERERERERERERkUlj0JCIiIiIiIiIiIpPCoicRERERERERERGZFBY9iYiIiIiIiIiIyKSw6ElEREREREREREQmhUVPIiIiIiIiIiIiMin/BxFAx23FxikPAAAAAElFTkSuQmCC\n", + "image/png": "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", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -648,7 +701,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.6" + "version": "3.8.13" } }, "nbformat": 4, From 6d0a13b5d13210e8ce77535fd56bfbdac42a7663 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Sat, 18 Mar 2023 17:39:50 +0100 Subject: [PATCH 10/65] Update shapley basic spotify notebook --- notebooks/shapley_basic_spotify.ipynb | 160 ++++++++++++----------- notebooks/shapley_utility_learning.ipynb | 1 + 2 files changed, 88 insertions(+), 73 deletions(-) diff --git a/notebooks/shapley_basic_spotify.ipynb b/notebooks/shapley_basic_spotify.ipynb index e7893eef4..bfd36a8c9 100644 --- a/notebooks/shapley_basic_spotify.ipynb +++ b/notebooks/shapley_basic_spotify.ipynb @@ -68,6 +68,7 @@ "from sklearn.ensemble import GradientBoostingRegressor\n", "from sklearn.metrics import mean_absolute_error\n", "\n", + "plt.ioff() # Prevent jupyter from automatically plotting\n", "plt.rcParams[\"figure.figsize\"] = (20, 6)\n", "plt.rcParams[\"font.size\"] = 12\n", "plt.rcParams[\"xtick.labelsize\"] = 12\n", @@ -75,10 +76,8 @@ "plt.rcParams[\"axes.facecolor\"] = (1, 1, 1, 0)\n", "plt.rcParams[\"figure.facecolor\"] = (1, 1, 1, 0)\n", "\n", - "random_state = 24\n", - "\n", "is_CI = os.environ.get(\"CI\")\n", - "enable_cache = not is_CI\n", + "random_state = 24\n", "random.seed(random_state)" ] }, @@ -95,6 +94,7 @@ "metadata": {}, "outputs": [], "source": [ + "%autoreload\n", "from pydvl.reporting.plots import plot_shapley\n", "from pydvl.utils.dataset import GroupedDataset, load_spotify_dataset\n", "from pydvl.value import *" @@ -397,7 +397,6 @@ " model=GradientBoostingRegressor(n_estimators=3),\n", " data=grouped_dataset,\n", " scorer=Scorer(\"neg_mean_absolute_error\", default=0.0),\n", - " enable_cache=enable_cache,\n", ")\n", "values = compute_shapley_values(\n", " utility,\n", @@ -406,8 +405,6 @@ " # or if the number of updates exceeds 1000\n", " done=AbsoluteStandardError(threshold=0.2, fraction=0.9) | MaxUpdates(1000),\n", " n_jobs=-1,\n", - " worker_update_period=0.5,\n", - " coordinator_update_period=1,\n", ")\n", "values.sort(key=\"value\")\n", "df = values.to_dataframe(column=\"data_value\", use_names=True)" @@ -454,41 +451,41 @@ " \n", " \n", " \n", - " Years & Years\n", - " -1.371126\n", - " 0.031585\n", + " Ava Max\n", + " -2.030388\n", + " 0.068219\n", " \n", " \n", - " Maroon 5\n", - " -1.369077\n", - " 0.043815\n", + " blackbear\n", + " -1.322559\n", + " 0.071610\n", " \n", " \n", - " Adele\n", - " -1.336247\n", - " 0.326559\n", + " Fedde Le Grand\n", + " -1.275141\n", + " 0.132753\n", " \n", " \n", - " 5 Seconds of Summer\n", - " -1.306585\n", - " 0.065579\n", + " Maroon 5\n", + " -1.191885\n", + " 0.070732\n", " \n", " \n", " Ariana Grande\n", - " -1.198273\n", - " 0.083772\n", + " -1.169887\n", + " 0.032827\n", " \n", " \n", "\n", "" ], "text/plain": [ - " data_value data_value_stderr\n", - "Years & Years -1.371126 0.031585\n", - "Maroon 5 -1.369077 0.043815\n", - "Adele -1.336247 0.326559\n", - "5 Seconds of Summer -1.306585 0.065579\n", - "Ariana Grande -1.198273 0.083772" + " data_value data_value_stderr\n", + "Ava Max -2.030388 0.068219\n", + "blackbear -1.322559 0.071610\n", + "Fedde Le Grand -1.275141 0.132753\n", + "Maroon 5 -1.191885 0.070732\n", + "Ariana Grande -1.169887 0.032827" ] }, "execution_count": 11, @@ -517,11 +514,29 @@ { "cell_type": "code", "execution_count": 12, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "low_dvl = df.iloc[:30]\n", + "plot_shapley(\n", + " low_dvl,\n", + " level=0.05,\n", + " title=\"Artists with low values\",\n", + " xlabel=\"Artist\",\n", + " ylabel=\"Shapley value\",\n", + ");" + ] + }, + { + "cell_type": "code", + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABmQAAALBCAYAAABGGc5jAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeXhkVZn48e/bbK3sAkrTgMENcEPFnUFB3DDiwg/3Ddd2h3EN44yAGxkdFFBHcRnRcR1bFJyIiiDatDuOKAruUVoaUFRAsFE65/fHOWVuqpN0Uqmbqlv5fp6nntRdqvLeW7du3Xves0RKCUmSJEmSJEmSJNVnWa8DkCRJkiRJkiRJGnQmZCRJkiRJkiRJkmpmQkaSJEmSJEmSJKlmJmQkSZIkSZIkSZJqZkJGkiRJkiRJkiSpZiZkJEmSJEmSJEmSamZCRpIkSZIkSZIkqWYmZCRJkiRJkiRJkmpmQkaSJEmSJEmSJKlmJmQkSZKkJSgiDomIFBEn9DqWukTE0WUbj57n61JEXNClGMYjYrwb79VEETFU9ucZvY5FkiRJ6jUTMpIkSVIfiYjXlQLsFBH7LuB9ai0I7zTZ0Q+WepJEkiRJUm9s2esAJEmSJGUREcDzgAQE8HzgVTX9u+8A+wN/qOn9+8FngW8B63sdiCRJkiTZQkaSJEnqHw8HhoAPA1cCz4qIrev4RymlG1NKl6WUBjYhk1K6tmzjtb2ORZIkSZJMyEiSJEn94/nl7/uBjwG7Ao+fbsWIOKF0GXZIRDw1Ir4dEX8p3XGdAPy6rPqsShdo/+hibKYxZCLidhHxvoj4RUT8NSL+GBE/ioj3RsQuZZ0LgA+Vl3yo7f2HyjrbR8S/RcQlEXFdRFwfEb+MiE9FxIGb2xER8Ynyfndsm//hMv+8tvnbR8TfI+LrlXlTulVrbTNwW+C2bXGfMU0Mu5Z9sT4iboqIH0fEszcX+1xExDYRMVL27Y1lH62JiCe2rbddRPwtIta2zb9FRGwosT+jbdmLyvznbCaGkbLeMTMs3yMibo6I77XNe31ErI2IK0tsV0TExyPizvPY/gvKZzHdshm7w4uIPSPiXRHxq/KZXBMRZ0fEfaZZd0HHoCRJktRtdlkmSZIk9YGIuA3wGOBnKaVvRMR1wCuBFwCfmuWlrwQeBnwe+CqwI3ABsBNwDHAx8LnK+j+YJYYVwHeBHYAvAJ8BlgP7AM8A3gVcA5wB/Bl4LHBW23v+uXS99kXggcA3gQ8ANwN7AocCa4CLZtkmgPOAJwOHAT+vzD+s/H1gRCxPKW0o0w8m399MSdS0GQdOBI4t06dUlv1g6qrsBKwF/gasBrYBngD8V0RMpJQ+vJn4Z1RaPX2pxHwZ8G7glsBRwKci4h4ppX8BSCn9JSK+A9wvIrZPKV1f3uagEhPkffLflX/R2kez7QvKa94MPBM4dZrlTwe2IH/eLQ8CRsjH2meAvwB3LLE/JiIOSildvJn/25GIuBfwZeBW5P13Jjlp+Tjgwoh4fErpC2XdbhyDkiRJUleZkJEkSZL6w7OBrSiF3ymlSyLiIuDQiLhDSukXM7zuIcADUkr/V50ZedD6Y4AfpJROmGMMR5ELu49NKU0poI+IbYGJEtsZubybxwKfSymd0bbu3cgF4Z9LKT2+bdkyctJoc84vfw8D3lteuy+wEjiXnIQ6iMmkw2Ftr9tESmkcOKHV8mIz++UA4IPAqpTSxvL/TwF+CLyW3K1cp15JTsacAzwmpXRzef8TyWP7HBcR/5tS+kZZ/3zytj4IGCvzDgM2Al9jcttb+/dQ4Fcppd/MFkRK6XcR8RXg4RFx15TSJW2rPIuckPpEZd75wG0qiaHW/z2AnMAaBQ7f/C6Yn4jYEvgfYDvg0JTS1yrL9iAnEj8YEUMppZuAu7LwY1CSJEnqKrsskyRJknqs1OZ/Hjnh8ZHKojOAYLIrs+m8rz0Z0wV/bZ+RUrohpbTJ/A7eZyKl9KfNvTCl9Ctyi5ZDy/6BycTD68nJiMMqLzkMuAH41jxjnMmNwCtayZgS00/ISYf9I2K7Bbz3c4BU3v/myvtfDbyxTD6vsn570qn1/CJyK5E9I+JOZf49yEm1zbWOaWkllp5VnRkR9wbuDIyllK6pxtiejCnzLyYnaw6NiK3m+L/nYxi4PfDOajKm/O8rgLcCuzN1H8ECjkFJkiSp20zISJIkSb33EHJh87kppd9V5n+c3ELh6FkKub/TxTjOJndB9e6I+ExEvCAi7lJJiMzVT8hdgD2ljDXymoh4YOmqaz7OB3YhJxkg76f1KaVvkZMRhwFExG7kFhEXppT+Ps//MZOfp5Sum2b+5eXvzp28aURsD9wBuCKldNk0q7Ra+NyzMu+b5MRCa3t3BO5FTrpUWxJB3kfV99mczwLXAk+LiC0q81sJmjOm2YbhiPh8GVvn761xeIAjyN2o7TrH/z0fDyh/bxt5/KQpD+C+Zfn+5W+3jkFJkiSpa0zISJIkSb33gvL3jOrMlNIfyWPD3JrcPdh0ruxWEKWLq/uSW108FDgduAT4TUS8fB7vs5GcGDgF2Bv4d3LLkj9ExDvn0brkHy1DKl1xnVdZdmBJTjyE3JJorq1C5uLPM8xvtWjZYoblm9PqKmv9DMtb83dqzUgp/Q24ELhbST4dUv7/eSmlS8trWgmZw8itb+aUkCmtnv4HWAE8HP4xxs1TgN+Tu1X7h4g4BvhfchdqXyd/xm8gj83TGjtmG7pvl/L3CcDx0zyeWpZvB109BiVJkqSuMSEjSZIk9VApYH9cmfxEq7VBpdXB/yvLXjDtG+TC965JKV2aUnoSuQD83uQB3JcBp0bEc+fxPn9KKf1zSmkv8qDvzyMPYP9S4D1zfJtWUuGhbNoV1/nkpMShzGH8mD5ybfm7+wzLV7St13I+Oel0WHlsICcYWssOjYhtgIOBH5fuz+aqvduyYfLn//Fqi6MyjssJ5CTgXVJKT0opvTqldHwZj+eqefzPicp7tttpmnmt/fHYlFLM8jix9YIuHYOSJElS10x38StJkiRp8TwL2JrcBdcPZljnMcBDI2KflNKv5/i+rbFPOmrJUcY2uQi4KCK+QW4N8TjyQPfzev+U0i+AX0TEx4Grmbm1T/vrroyIn5CTDI8ss1sJmbXATeTkxEOAPwFzHUtnI3mfL7qU0vUR8UvgdhFxx5TSz9tWObT8/X7b/Oo4Mg8AvpFS2lBZ9jTgRcC2zLOlUEppbUT8HHhsaXHUSsx8uG3VXcnJkjNTSlNa+JQWJ/eax79tjeGyF9B+TN97mvVbYwMdTO5ab146PQYlSZKkbrKFjCRJktRbzy9/X5xSet50D3LXYcHUgd4350/k1jN7z/UFEdHqAqzdbcrfGyvzWgO9b/L+EbFPRNxumvfZmdyd1SYDrc/ifOCWwDHkcV0uh390tfVN4Ink8XcuSClNzPE9rwF2i4hbzCOObvov8uf5tuq4LRGxK/BvlXWqvk9uJfJY4C5MTbq0WgYd1zY9Hx8GlgMvBh4F/DCl1J7gupp8DBxY7fKrjG90KvMbO6Y19tHzqzMj4jByd2ntzgJ+CbwkIh413RtGxAMi4pbleTePQUmSJKkrbCEjSZIk9UhEHALcCfhRSuk7s6z6QeB1wLMj4vjSemVWKaW/RMS3gYMj4mPAz8gtQ85OKf1whpc9A1gVEReSC7//RE52HEFujXJKZd1vkgvnj42IXZgcy+adwAHAmRHxXeBS4ApgN3IyYSvyeB5zdR65i6lbk8e2aV92SOX5fN7zPsAXI+Lr5G27OKX0+Xm8x0L8B3A4eX9cHBFfICednkDezremlC6sviCltDEiLmCyZcd5lWW/Ka1ubk/+jL/WQUz/zeRYMFuxaesYUkoTEXEauRu7H0XEWeSWRoeSu5P7KpMtfDbnQ8CrgeMi4gDgJ+TvwuHAZ5nsqq/1v/8eEUcCXwLGSqutH5CPwb3In+ftyF2+3Uh3j0FJkiSpK0zISJIkSb3Tah3wgdlWSimNR8RXgIeRkyOfneP7PwN4B7m7r6eQW2WsA2ZKyHyC3HrggcCBwC2A3wGfBE5OKV1SielPEfH/yAOqH03uKgvgo8D3gFHgweV/70weIP4i4LSU0pSB4jfjAvJ4I8vYtOXHecAby/P5tAp5E7nrrSPIg9NvQU5ALEpCJqX0t4h4GPAK8mD0LwNuBi4Gjk0pfWKGl55HTihcR97H7ctuD1yUUmoff2YuMf02Ir5K7hLtZuBjM6z6b+TP8nnAKnKrnXOBfyUnc+b6/66OiAcDbwMeRD5Wvkc+xvehLSFTXvPDkrx5BfBo4NnkY2M9ubu644E/lNW7eQxKkiRJXREpdXUMUEmSJEmSJEmSJLVxDBlJkiRJkiRJkqSamZCRJEmSJEmSJEmqmQkZSZIkSZIkSZKkmpmQkSRJkiRJkiRJqpkJGUmSJEmSJEmSpJqZkJEkSZIkSZIkSarZlr0OoGkiIoA9gOt7HYskSZIkSZIkSeoL2wNXpJTSTCuYkJm/PYB1vQ5CkiRJkiRJkiT1lT2B38200ITM/LVaxuyJrWQkSZIkSZIkSVrqtic35Jg1Z2BCpnPXp5Su63UQkiRJkiRJkiSpd/JIJ5u3rOY4JEmSJEmSJEmSljwTMpIkSZIkSZIkSTUzISNJkiRJkiRJklQzEzKSJEmSJEmSJEk1MyEjSZIkSZIkSZJUMxMykiRJkiRJkiRJNTMhI0mSJEmSJEmSVDMTMpIkSZIkSZIkSTUzISNJkiRJkiRJklQzEzKSJEmSJEmSJEk1MyEjSZIkSZIkSZJUMxMykiRJkiRJkiRJNTMhI0mSJEmSJEmSVDMTMpIkSZIkSZIkSTUzISNJkiRJkiRJklQzEzKSJEmSJEmSJEk1MyEjSZIkSZIkSZJUsy17HYAkSZIkSVKTDY2MrQBWLOAt1o+PDq/vVjySJKk/mZCRJEmSJElamFXA8Qt4/YnACd0JRZIk9SsTMpIkSZIkSQtzOnD2NPOXA2vL84OADTO83tYxkiQtAZFS6nUMjRIROwDXAjumlK7rdTySJEmSJKk/DY2MbQv8pUxuNz46fEMv45EkSfWYa95g2eKFJEmSJEmSJEmStDSZkJEkSZIkSZIkSaqZCRlJkiRJkiRJkqSamZCRJEmSJEmSJEmqmQkZSZIkSZIkSZKkmpmQkSRJkiRJkiRJqlnjEzIR8ZKIGI+IDRHx7Yi472bWf0JEXFbW/1FEPGqxYpUkSZIkSZIkSUvTlr0OYCEi4knA24EXAt8GjgW+FBH7ppSunmb9BwKfAI4D/hd4KvC5iLhXSumSRQtckiRJkiRJkrpsaGRsBbBiAW+xfnx0eH234pE0VaMTMsArgPenlD4EEBEvBIaB5wCj06x/DPDFlNLbyvS/RcTDgJeSkzqSJEmSJEmS1FSrgOMX8PoTgRO6E4qkdo1NyETE1sCBwEmteSmliYj4CvCAGV72AHKLmqovAY+b5f9sA2xTmbV9J/FKkiRJkiRJUs1OB86eZv5yYG15fhCwYYbX2zpGqlFjEzLArsAWwFVt868C9pvhNbvPsP7us/yf41hYVlmSJEmSJEmSale6G9skqTI0MrZtZfLi8dHhGxYvKkkty3odQAOcBOxYeezZ23AkSZIkSZIkSVLTNLmFzB+AjcBt2ubfBrhyhtdcOc/1SSndBNzUmo6IeQcqSZIkSZIkSZKWtsa2kEkp/Q24CDisNS8ilpXpb87wsm9W1y8eNsv6kiRJkiRJkiRJC9bkFjIAbwc+HBHfA74DHAtsC3wIICI+AvwupXRcWf9U4GsR8UpgDHgycG/gBYsctyRJkiRJkiRJWkIanZBJKX0qInYD3gDsDvwAeGRK6aqyyt7ARGX9b0TEU4E3AW8Bfg48LqV0yaIGLkmSJEmSJEmSlpRGJ2QAUkrvAt41w7JDppn3aeDTNYclSZIkSZIkSZL0D40dQ0aSJEmSJEmSJKkpTMhIkiRJkiRJkiTVzISMJEmSJEmSJElSzUzISJIkSZIkSZIk1cyEjCRJkiRJkiRJUs227HUAkiRJkiRJkppvaGRsBbBiAW+xfnx0eH234pGkfmNCRpIkSZIkSVI3rAKOX8DrTwRO6E4oktR/TMhIkiRJkiRJ6obTgbOnmb8cWFueHwRsmOH1to6RNNBMyEiSJEmSJElasNLd2CZJlaGRsW0rkxePjw7fsHhRSVL/WNbrACRJkiRJkiRJkgadCRlJkiRJkiRJkqSamZCRJEmSJEmSJEmqmQkZSZIkSZIkSZKkmpmQkSRJkiRJkiRJqpkJGUmSJEmSJEmSpJqZkJEkSZIkSZIkSaqZCRlJkiRJkiRJkqSamZCRJEmSJEmSJEmqmQkZSZIkSZIkSZKkmpmQkSRJkiRJkiRJqpkJGUmSJEmSJEmSpJqZkJEkSZIkSZIkSaqZCRlJkiRJkiRJkqSamZCRJEmSJEmSJEmqmQkZSZIkSZIkSZKkmpmQkSRJkiRJkiRJqpkJGUmSJEmSJEmSpJqZkJEkSZIkSZIkSaqZCRlJkiRJkiRJkqSamZCRJEmSJEmSJEmqmQkZSZIkSZIkSZKkmpmQkSRJkiRJkiRJqpkJGUmSJEmSJEmSpJqZkJEkSZIkSZIkSaqZCRlJkiRJkiRJkqSamZCRJEmSJEmSJEmq2Za9DkCSJEmSJEmSJPXe0MjYCmDFAt5i/fjo8PpuxTNoTMhIkiRJkiRJkiSAVcDxC3j9icAJ3Qll8JiQkSRJkiRJkiRJAKcDZ08zfzmwtjw/CNgww+ttHTMLEzKSJEmSJEmSJInS3dgmSZWhkbFtK5MXj48O37B4UQ2OZb0OQJIkSZIkSZIkadDZQkaSJEmSJEmN5iDUkqQmMCEjSZIkSZKkpnMQaklS3zMhI0mSJEmSpKZzEGpJUt8zISNJkiRJkqRGcxBqSVITLOt1AJIkSZIkSZIkSYPOhIwkSZIkSZIkSVLNTMhIkiRJkiRJkiTVzDFkJEmSJEmSJEnqgqGRsRXAigW8xfoyLpYGkAkZSZIkSZIkSZK6YxVw/AJefyJwQndCUb8xISNJkiRJkiRJUnecDpw9zfzlwNry/CBgwwyvt3XMADMhI0mSJEmSJElSF5TuxjZJqgyNjG1bmbx4fHT4hsWLSv1iWa8DkCRJkiRJkiRJGnQmZCRJkiRJkiRJkmpml2WSJEmSJEmSpJ4bGhlbAaxYwFusL12GSX3JhIwkSZIkSZIkqR+sAo5fwOtPBE7oTihS95mQkSRJkiRJkiT1g9OBs6eZvxxYW54fBGyY4fW2jlFfMyEjSZIkSZIkSeq50t3YJkmVoZGxbSuTF4+PDt+weFFJ3bOs1wFIkiRJkiRJkiQNOhMykiRJkiRJkiRJNTMhI0mSJEmSJEmSVDMTMpIkSZIkSZIkSTUzISNJkiRJkiRJklQzEzKSJEmSJEmSJEk1MyEjSZIkSZIkSZJUMxMykiRJkiRJkiRJNTMhI0mSJEmSJEmSVLMtex2AJEmSJEmSemtoZGwFsGIBb7F+fHR4fbfikSRpEJmQkSRJkiRJ0irg+AW8/kTghO6EIknSYDIhI0mSJEmSpNOBs6eZvxxYW54fBGyY4fW2jlHj2VJMUt1MyEiSJEmSJC1xpRB5k4LkoZGxbSuTF4+PDt+weFFJi86WYtLMquPRHzw0Mnbu+Ojwxp5F01AmZCRJkiRJkiTJlmLStIZGxo4ETqvMOgdYNzQydsz46PCZPQqrkUzISJIkSZIkSVrybCmmmjWyhUlJxqyeZtFKYPXQyNhRJmXmbtnmV5EkSZIkSZIkSZ0oSY1LK7POAcbL/L41NDK2BXBqmYy2xa3pU8p6mgMTMpIkSZIkSZIk1aDSwmSPtkWtFib9nJQ5GNiTTZMxLQHsVdbTHJiQkSRJkiRJkiSpywaghcmKLq+35JmQkSRJkiRJkiSp+5rewmSTMZUWuN6SZ0JGkiRJkiRJkqTua3oLkzXAOiDNsDwBl5f1NAcmZCRJkiRJkiRJ6r5GtzAZHx3eCBxTJtuTMq3pY8t6mgMTMpIkSZIkSZIkdV/jW5iMjw6fCRwFXNG2aB1wVFmuOTIhI0mSJEmSJElSlw1KC5OSdNm/MutwYB+TMfNnQkaSJEmSJEmSpBoMUAuTicrzNf2eROpXJmQkSZIkSZIkSaqJLUzU0tiETETcKiI+FhHXRcSfI+KDEbHdZl5zQUSktsd7FytmSZIkSZIkSdKSZAsTsWWvA1iAjwErgIcBWwEfAt4HPHUzr3s/8PrK9I21RCdJkiRJkiRJklQ0MiETEfsDjwTuk1L6Xpn3MuALEfGqlFJ7f3xVN6aUrlyMOCVJkiRJkiRJkqC5XZY9APhzKxlTfIXc7Ot+m3nt0yLiDxFxSUScFBG3nG3liNgmInZoPYDtFxa6JEmSJEmSJGkequXYBw+NjG3Rs0ikBWhkCxlgd+Dq6oyU0s0R8ceybCYfB34DXAHcHfh3YF/gyFlecxxw/IKilSRJkiRJkmYxNDK2gtw9f6fWj48Or+9WPFK/GBoZOxI4rTLrHGDd0MjYMeOjw2f2KCypI32VkImIUeC1m1lt/07fP6X0vsrkjyJiPXBeRNw+pfTLGV52EvD2yvT2wLpOY5AkSZIkSZKmsYqFVQo+ETihO6FI/aEkY1ZPs2glsHpoZOwokzJqkr5KyAAnA2dsZp1fAVcCt67OjIgtgVuVZXP17fL3DsC0CZmU0k3ATZX/M4+3lyRJkiRJkubkdODsaeYvB9aW5wcBG2Z4va1jNJv2Lr/OHR8d3tizaOagdEt2aplsL5QNIAGnDI2MndXv2yK19FVCJqX0e+D3m1svIr4J7BQRB6aULiqzH0I+sXx75ldu4h7lrz9YkiRJi8xuOSRJkiaV65pNrm2GRsa2rUxePD46fMPiRaVB0OAuvw4G9pxleQB7lfUuWIyApIXqq4TMXKWULo2ILwLvj4gXAlsB7wI+mVK6AiAiVgLnAc9MKX0nIm4PPBX4AnANeQyZdwBfTyn9sBfbIUmStMTZLYckSZJUo4Z3+TXXylsLqeQlLaplm1+lbz0NuIycdPkCcCHwgsryrYB9gVuW6b8BDwW+XF53MvAZ4IhFileSJElTnQ4cOM3joMo6B82wzoHl9ZIkSVLd2rv72qJnkczDHLr8gtzlV79uz1xbw9tqXo3RyBYyACmlP5JbvMy0fJzKiSaldDnw4PojkyRJ0lzYLYckSZL6XYO7+4Lmd/m1BlhHbs0z3cDeqSxfs5hBSQvR5BYykiRJkiRJklSLSndfe7QtanX3deTiRzUvje7ya3x0eCNwTJlMbYtb08eW9aRGMCEjSZIkSZIkqU6N6/JrALr7ggHo8qu0QjoKuKJt0Tqgn8e/kaZlQkaSJEmSJElSLUorkksrs84BxhvQuqTV3dd0XWXB1O6++lWry6/21iUtCbicPu/yqyRd9q/MOhzYx2SMmsiEjCRJkiRJkqSua3iXX43u7gsGrsuvicrzNQ2JWdqECRlJkiRJkiRJXTUAXX41vrsvsMsvqd+YkJEkSZIkSZLUbU3v8msguvsCu/yS+smWvQ5AkiSpF4ZGxlawsO4F1o+PDvd1bThJkiQNhGqF6oOHRsbObUh3TY3u8mt8dHjj0MjYMeQu1xJTE0tN6+4L7PJL6gsmZCRJjWNBurpkFXD8Al5/InBCd0KRJElSTZqazAD+MQbLaZVZ5wDrhkbGjmlA64bGd/k1Pjp85tDI2FHkz2BlZdE6cjKm3z8DSX3GhIwkqYksSFc3nA6cPc385cDa8vwgYMMMr+/bG0dJkiQ1PpnRin/1NItWAquHRsb6ffyPVpdfK5m+27JUlvd1l18lKXMucF2ZdTjQqMSepP5hQkaS1EQWpGvBSiupTY6FoZGxbSuTF4+PDt+weFFJkiSpG5qezCgD3Z9aJtuTGUFOZpwyNDJ2Vr8mBgasyy+7+5LUFSZkJEmNY0G6JEmStGga1+XXICQzyAPd7znL8gD2KutdsBgBdcIuv7QUzdLN+vLK8wOGRsZmrERqN+uDa9nmV5EkSZIkSdJSU1qZXFqZdQ4wXub3s1YyY7pusmBqMqNfzXXMzIWMrbkoStJl/8qsw4F9TMZogK0CLprmsbayztoZ1rmovF4DyhYykiRJkiRJmqLhXX4NQjJjrrXjm1KL3i6/tJTM1M36XDXle60OmJCRJEmSJHVslm455spuOaQ+MwBdfg1CMmMNuVuvlUzf0ieV5WsWMyhJmzdTN+sSmJCRJEmSJC3MKuD4Bbz+ROCE7oQiqUuaPn5J45MZ46PDG4dGxo4ht1JKTN2OVP4e26cJMUnSDBxDRpIkSZK0EKcDB07zOKiyzkEzrHNgeb2k/tLoLr9KkuKYMpnaFjcmmVG6hDsKuKJt0Tqgn7uMkyTNwBYykiRJkqSOzdQtx9DI2LaVyYvHR4dvWLyoJC1Q47v8Gh8dPnNoZOwo4DRyS5mWdeRkTCOSGWU7zgWuK7MOB87t92SSJGl6tpCRJEmSJElSVavLr/bWJS0JuJw+7vIL/tHCZP/KrMOBfZqSjKmYqDxfYzJGkprLFjKSJEmSJEn6hwEbv8RkhiTNw9DI2Aqm75JyeeX5AUMjYxtmeIv1pQW1pmELGUmSJEmSJE3h+CWStGStAi6a5rG2ss7aGda5qLxeM7CFjCRJkiRJkjbh+CWStCSdDpy9gNfbOmYWJmQkSZIkSZI0E7v8kqQlpHQ3ZlKlJiZkJEmSJDXWLH1cz5V9XEt9wO+yJElaCkzISJIkSWqyVcDxC3j9icAJ3QlF0gL4XZYkSQPPhIwkSZKkJpupj+vlTA48ehCwYYbXW6Ne6g9+lyVJ0sAzISNJkiSpsWbq43poZGzbyuTF46PDNyxeVJLmy++yJElaCkzISJIkSUuUYzZIktQ/ZvldXl55fsDQyNiMLcX8XZak/mZCRpIkSVq6HLNBkuq1rPL84KGRsXPHR4c39iwa9bu5/C6vnWWZv8uS1OdMyEiSJElLl2M2SAPA1m79aWhk7EjgtMqsc4B1QyNjx4yPDp/Zo7DU32b6XZ4rv8eS1OdMyEiSJElLlGM2SAPD1m59piRjVk+zaCWwemhk7CiTMmo30++yJGlwmJCRJEmSJKnZbO3WR4ZGxrYATi2T0bY4gAScMjQydpbdl0n9xXF8JNXNhIwkSZIkSQ024K3dmjgGy8HAnrMsD2Cvst4FixGQpDlzHB9JtTIhI0mSJEmS+k6Dx2CZ63g+Cxn3R1I9HMenx2ylpEFnQkaSJEmSJPWVho/BMteCQAsMpT7jOD59wVZKGmgmZCRJkiRJUt8YgDFY1gDryMmj9vghx7+urCdJmspWShpoJmQkSZIkqUdm6ZZjruyWQ4Oo0WOwjI8ObxwaGTuG3MInMTUpk8rfY/s0mSRJPWUrJQ06EzKSJEmS1Dtz6ZZjNnbLsUADnhRbVnl+8NDI2LkNSQI0fgyW8dHhM4dGxo4ij4GzsrJoHTkZ06/drUmSpBqZkJEkSZKk3pmpW47lTPaPfhAw48C1dQS1xAxkUqyMwXJaZdY5wLqhkbFjGpAMGIgxWEpS5lzgujLrcKApSTFJklQDEzKSJEmS1CMzdcsxNDK2bWXy4vHR4RsWL6olZ+CSYiUZs3qaRSuB1UMjY0f1eVJmkMZgmag8X2MyRpKkpa0rCZmI2BH4S0rJCwtJkiRJUmMMWlJsaGRsC+DUMtmezAhyMuOUoZGxs/o1OeAYLJIkaVB1nJCJiHsDbwIeBGwNPBw4PyJ2BT4IvCOldEE3gpQkSZL6zYCPOyGpuQ4G9pxleQB7lfUuWIyAOuEYLJIkaRB1lJCJiAcC5wO/Az4KPK+1LKX0h9JiZhV9fHEnSZIkLdBAjjshqfHmmiheSEJ5UTgGiyRJGjSdtpB5C3ApcH9geyoJmeKrwLMWEJckSZLU7wZu3AlJA2Gu55amnIMcg0WSJA2MThMy9wGOSyndFBHbTbP8d8DunYclSZIk9bdBG3dC0sBYQ+7WayWbjiEDeQyWdWU9SZIkLaJlHb7u75t57UrgLx2+tyRJkiRJ6kBpQXJMmUxti1vTx9rSRJIkafF1mpD5FnDUdAsiYlvg2cDXOg1KkiRJkqQeq94vHzw0MrZFzyKZpzLg/VHAFW2L1gFHleWSJElaZJ0mZI4H7h0RY+RB9QAOiIjnARcBuwFv7EJ8kiRJkiQtqqGRsSPJ46a2nAOMl/mNUJIu+1dmHQ7sYzJGkiSpdzpKyKSUvg08CrgD8JEy+2TgfcAWwKNSSj/sSoSSJEmSJC2SknRZDezRtmglsLpJSRlgovJ8jd2USZIk9daWnb4wpXQ+sG9E3AO4Izm580vgopRSez+1kiRJkiT1tdIt2allMtoWB3kMllOGRsbOMrnRXUMjYyuAFdMsWl55fsDQyNiGGd5i/fjo8PruRyZJktQ9HSdkWlJKPwB+sOBIJEmLYpab3bnyZleSJA2qg4E9Z1kewF5lvQsWI6AlZBW5e/TZrJ1l2YnACV2LRpIkqQYdJWQi4kFzWS+l9PVO3l+SVKu53OzOxptdSZI0qOZaaWUhlVs0vdOBsxfweisMSZKkvtdpC5kLyE21N2eLDt9fklSfmW52lzNZ6/AgYMbuIOoISpIkqQ/M9TrH66EuKy2w3a+SJGmgdZqQOXSaeVsAQ8ALyOPJjHT43pKkGs10szs0MrZtZfLi8dHhGxYvKkmSpL6wBlgHrGTTMWQgV0xcV9brG46/IkmS1AwdJWRSSl+baVlEnEG+OD0EOL+jqCRJkjQrx4OS1ADLKs8PHhoZO3d8dHhjz6KZg/HR4Y1DI2PHAKvJyZdqUqbVS8Sxfbgdjr8iSZLUAJ22kJlRSmkiIj4JHAe8vtvvL0mSJMDxoKRB17hkRtXQyNiRwGmVWecA64ZGxo4ZHx0+s0dhzcn46PCZQyNjR5HjX1lZtI6cjOnH+B1/RZIkqQG6npApbgXsVNN7S5IkyfGgpIHV5GQG/CP+1dMsWgmsHhoZO6rft6MkZc4FriuzDgf6Ninm+CvqBru+kySpfh0lZCJi7xkW7QQ8CHg1fdanriRJ0iBxPChpMDU9mTE0MrYFcGqZbB+DJcjdfp0yNDJ2Vr8mNyomKs/XNCBeaaHs+k6SpJp12kJmnMn+c9sF8C3yD7kkSZIkaQ4GJJlxMLDnLMsD2Kusd8FiBCRpzuz6TpKkmnWakHkOmyZkEvAn4JcppZ8sKCpJkiRJWpgmjsEyCMmM6bo7Wsh6khaJXd9JklS/jhIyKaUzuhyHJEmSJHVFg8dgGYRkxlwLcy30lSRJ0pKzbPOrSJIkSVIzVMZg2aNtUWsMliMXP6o5G4RkxhpgHTN3cZ2Ay3HMUUmSJC1Bc2ohExHnd/DeKaV0WAevkyRJkqR5G4AxWFrJjJVsGj/k+NfRx8mM8dHhjUMjY8eQk2KJqdvRStIc26f7X5IkSarVXLssW8bMNZxmMt0NhCRJkiTVpdFjsAxKMmN8dPjMoZGxo8jdxq2sLFpHjr+vuo0bGhlbwfTdwC2vPD9gaGRswwxvsb6MvSFJkiTNak4JmZTSITXHIUmSJEkL1fgxWJqWzJhJ2Y5zgevKrMOBc/s0mbQKOH4z66ydZdmJwAldi0aSJEkDa64tZCRJkiSp3w3CGCxNS2bMZqLyfE0fx386cPYCXt/Xx5MkSZL6x4ITMhGxPbAjuVuzKVJKv13o+0uSJEnSHDV+DJaKpiQzGq90N2ZSRZIkSbXrOCETES8CXgHcbpbVtuj0/SVJUv+apb/9ubK/fUldNyhjsEiSJEkaTB0lZCLihcC7gS8B/wW8GXgHsAE4GriK3OexJEkaTHPpb3829rcvqRaDMgaLJEmSpMHTaQuZlwFfSikdHhG7kBMyYyml8yPircD3gF26FaQkSeo7M/W3v5zJgY8PIlfWmI6tYyTVZoDGYJEkSZI0QDpNyNye3EIG4O/l79YAKaVrI+IDwIuBkxcWniRJ6kcz9bc/NDK2bWXy4vHR4RsWLypJmsIxWCRJkiT1lWUdvu5aSjInpXQdcCOwV2X59cDuCwtNkiRJkiRJkiRpMHSakLkEOKAy/S3gRRGxMiL2Ivcr/7OFBidJkiRJkiRJkjQIOu2y7KPACyNim5TSTeRBfb8C/LYs/zvw/7oQnyRJkiRJkiRJUuN1lJBJKX0I+FBlem1E3AU4AtgIfDmlZAsZSZIkSZIkSZIkOm8hs4mU0q+AU7v1fpIkSZIkSZIkSYOio4RMRHwH+ATw6ZTSuu6GJEmSJEmSJM3d0MjYCmDFNIuWV54fMDQytmGGt1g/Pjq8vvuRSZI0aVmHr9sInAyMR8SFEfHSiNi9i3FJkiRJ6p3qfcLBQyNjW/QsEkmS5mYVcNE0j7WVddbOsM5F5fWSJNWq0zFkHhARewNPAp4InAa8IyLWAJ8Ezkwp/aF7YUqSJElaDEMjY0eSr+9bzgHWDY2MHTM+Onxmj8KSJGlzTgfOXsDrbR0jSapdx2PIpJR+C7wNeFtE3I7J5Mx7gXdFxPkppUd2J0xJkiRJdSvJmNXTLFoJrB4aGTvKpIwkqR+V7sZMqkiS+lqnXZZNkVL6VUrpJOBe5CaefwUe1o33liRJklS/0i3ZqWUy2ha3pk+x+zJJkiRJ6kxXEjIRcf+IeDvwW3ILGYCPd+O9JUmSJC2Kg4E92TQZ0xLAXmU9SZIkSdI8dZyQiYgDI+KtETFOHhTtBeXvUcCtU0rP6E6IkiRJUqNUr7EPblCLkhVdXk+SJEmSVNHRGDIR8UtgCPgbeZDP1wKfTynd2L3QJEmSpGYpY7CcVpl1DrBuaGTsmAaMvTLXfvftn7+LhkbGVjB9kmt55fkBQyNjG2Z4i/Vl3ARJkiRJfa7TFjI/AZ5FbglzZErpU4udjImI10XENyLixoj48xxfExHxhohYHxF/jYivRMQdaw5VkiRJS0BJxqwG9mhbtBJYXZb3szXAOiDNsDwBl5f11D2rgIumeaytrLN2hnUuKq+XJEmS1AAdJWRSSkeklD6aUrq+2wHNw9bAp4H3zOM1rwFeDrwQuB9wA/CliFg+66skSZK0mBrX5VeJ8dQy2T4GS2v6lH7elvHR4Y3AMWWyPSnTmj62rKfuOR04cAGP0xc/ZEmSJEmd6KjLsn6QUjoeICKOnsv6ERHAscCbUkpnlXnPBK4CHgd8so44JUmSNHcN7vLrYGDPWZYHsFdZ74LFCKgT46PDZw6NjB1F/gxWVhatIydj+vkzaKTS3ZhdjkmSJElLQKddljXRPsDuwFdaM1JK1wLfBh4w04siYpuI2KH1ALavPVJJkqQlqOFdfs11oPu5rtczJemyf2XW4cA+JmMkSZIkaWGWUkJm9/L3qrb5V1WWTec44NrKY133Q5MkSVraBqDLr7m2cGhKS4iJyvM1dlMmSZIkSQvXV12WRcQo8NrNrLZ/SumyxYinOAl4e2V6e0zKqIeGRsZWsLDatetL1xiSJPWTpnf5tYZ8jbiSTRNKkMdgWVfWkyRJkiQtQX2VkAFOBs7YzDq/6vC9ryx/b8PUmom3AX4w04tSSjcBN7Wm81A0Uk+tAo5fwOtPBE7oTiiSJHVNo7v8Gh8d3jg0MnYMucu1xNSkTCp/j7WliSRJkiQtXR0lZCLiHOC/gc+mlP7arWBSSr8Hft+t92vza3JS5jBKAqaMCXM/4D01/U+pDqcDZ08zfzmwtjw/CNgww+ttHSNJ6keN7/JrfHT4zKGRsaOA08gtZVrWkZMxjsEiSZIkSUtYpy1kbgd8FPhLRHyWnJw5L6WUZn9Z90TE3sCtgL2BLSLiHmXRL1JKfynrXAYcl1L6bEopRcQpwL9GxM/JCZo3AlcAn1usuKWFKt2NbVIYNTQytm1l8uLx0eEbFi8qSZIWbCC6/CpJmXOB68qsw4FzbRkjSZIkSeooIZNS2jci7gM8HXhi+XtlRHwc+FhK6QfdC3FGbwCeVZn+v/L3UCb7Fd8X2LGyzluBbYH3ATsBFwKPTCnN1JJAkqSucywo1WxZ5fnBQyNjjUgGDFiXXxOV52saErMkSZIkqWbLNr/K9FJK300pHUOuxfgo4Hzy2BYXRcQlEfGaiJhtYNYFSSkdnVKKaR4XVNaJlNIZlemUUnp9Smn3lNLylNJDU0o/qytGSZJmsAq4aAGPVYsf8pLSntDYomeRzNPQyNiRwKWVWecA42V+3ytdeh1FbsFctQ44yi6/JEmSJElN1nFCpiWlNJFS+lJK6Rnk7sNWA3cGRoHxiPhKRAwv9P9IkjRATgcOnOZxUGWdg2ZY58DyetWgyQmNEuNqYI+2RSuB1U3YBvhHUmb/yqzDgX1MxkiSJEmSmq7TMWSmiIh/IndbdhR5XJdLgI8AfweeA5wdEW9OKb2+G/9PkqQmcyyo/lRJaLRrJTT6toVGacVzaplsH38lyF1+nTI0MnZWQ7rPsssvSZIkSdLA6TghExF3JidhnkJuGXM18GHgv9vGkDk1It4HvAQwISMtcY6dIQ28Ro5fMgAJjYOB2bqKDWCvst4FixGQJEmSJEmaqqOETET8ALgbcBNwFvBi4EsppYkZXvJV4Hmd/C9JA2cVcPwCXn8icEJ3QpHUTaWFyWmVWecA64ZGxo7p15YlFU1PaMw10b2QhLgkSZIkSVqATlvI/Bl4AfDplNJ1c1j/LGCfDv+XpMFyOnD2NPOXA2vL84OADTO83tYxUh9qcndfRdMTGnM9N3oOlSRJUm1m6RVjeeX5AUMjYzPe89srhqRB1lFCJqV0yDzXvxH4TSf/S9JgcewMaVZ299U7TU9orAHWkRNg7Z8B5M9gXVlPkiRJqstcesVYO8sye8WQNNA6HkMGICLuDxwK3Br4z5TSzyPilsB+wM9SSn/pQoySJA08u/vquUYnNMZHhzcOjYwdQ26llJi6Dan8PbaPE2KSGsza0JKkipl6xZgrfw8kDbROx5DZGvgk8Fgma75+Hvg5MAF8GXgH8ObuhClJ0uCyu6/eG4SExvjo8JlDI2NHkRN7KyuL1pFj7+djSFKzWRtakgTM3CuGJCnrtIXMG4FHAy8Cvgr8tLUgpbQhIj5NTtaYkJEkaRZ299U/BiGhUbbhXKA1xt/hQCO6vpM6ZeuMvmBtaEmS+oTXRlJ/6zQh8xTgPSml90XELtMsvxR4QudhSZLUkSaOwWJ3X31kQBIaE5XnaxoWu9QJW2f0mLWhJUnqK14bSX2s04TMrYEfzbJ8I3DLDt9bktQbTUxm/EODx2Cxu6/+Y0JDahZbZ0iSJE3y2kjqY50mZC4H9ptl+UHALzp8b0nqa7M0/52rvmv+2+BkBtD4MVjs7kuSFsDWGZIkSZO8NpL627LNrzKtjwOrIuIBlXkJICKeDzwR+MgCY5OkfrUKuGgBj1WLH/LMKsmMPdoWtZIZRy5+VHM3hzFYII/BssXiRTUvre6+0gzLE7kiRCO6+wL2r8w6HNjHZIwkSZIkSVLnCZk3A98Avg58lVxY9I6I+C25WdwXgXd0JUJJ6j+nAwdO8zioss5BM6xzYHl9XxiAZAZMjsEy3dglMHUMlr5TusM6pky2J2Xs7kuSJEmSJGlAdNRlWUrpbxHxSOBpwFHAFsA2wA+BfwX+O6U0U01fSWq0mZr/Do2MbVuZvHh8dPiGxYuqY4MwoPwgjMFid1+SJEmSJEkDrtMxZCgJl4+WhySpmRqfzGCwxmA5F7iuzDocONcWJpIkSZIkSYOh0y7LJEmDYRCSGQMzBgt29yVJkiRJkjSw5tRCJiLO7+C9U0rpsA5eJ0laPK1kxkqmH4MlleV9m8wYHx3eODQydgywmhxvdTuaOAaLJEmSJEmSBtBcW8gsIxdwzedh6xtJ6nODMqB8GWPlKOCKtkXrgKMcg0WSJEmSJEm9NqcWMimlQ2qOQ5LUI4MyoLxjsEiSJEmSJKmf2YpFkrqnek49eGhkbIueRTJPJemyf2XW4cA+TUnGVDgGiyRJkiRJkvrSnFrIzCQiHg08Chgqs8aBL6SU/ndhYUlSswyNjB1JbmHScg6wbmhk7JgGJTVMZiySoZGxFcCKaRYtrzw/YGhkbMMMb7F+fHR4ffcjkyRJkiRJUl06SshExE7AZ4EHARuBVqHQQ4FVEbEGeFxK6c9diFGS+lpJxqyeZtFKYPXQyJhjmKjdKuD4zayzdpZlJwIndC0aSZIkSZIk1a7TFjKnAgcDrwXek1K6ASAitgVeDJxU1nlWN4KUpH5VuiU7tUxG2+IAEnDK0MjYWbY4UcXpwNkLeL2tYyRJkiRJkhqm04TM44D/TCn9R3VmScy8LSL2Bp65wNgkLS3t4680ZTD2g4E9Z1kewF5lvQsWIyD1v9LdmEkVSZIkSZKkJWTZ5leZ1t+Bn86y/LKyjiRtVuny69LKrHOA8TK/3003DshC1pMkSZIkSZI0gDptIfMZ4AkR8d6U0pQa7BGxJfBE4NMLDU7qtlkG0p4rB9LusgEYf2Wux4PHjSRJkiRJkrSEdZqQ+SjwLuAbEfE+4Bdl/h2BFwBbAx+LiHtVX5RS+n6ngUpdMpeBtGfjQNpdNCDjr6wB1pETSO3bAHkb1pX1JEmSJEmSJC1RnSZkvlZ5fh9ygSNMLYysrtMqWN2iw/8ndctMA2kvB9aW5wcBG2Z4va0cuqvx46+Mjw5vHBoZO4bcyicx9TzYOjce28cJJUmSJEmSJEmLoNOEzLO7GoW0SGYaSHtoZGzbyuTF46PDNyxeVEvaQIy/Mj46fObQyNhRwGnkljIt68jJmH7uck2SJEmSJEnSIugoIZNS+nC3A5G0JA3M+CslKXMucF2ZdThwri1jJEmSJEmSJAEs63UAkpa01vgraYblCbic5oy/MlF5vsZkjCRJkiRJkqSWTrssIyKWA/8PuBewI5smd1JK6bkLiE3SgHP8FUmSJEmSJElLRUcJmYi4LfBVYAj4Mzkh80dgJ2AL4A/AX7oRoKTB5vgrkiRJkiRJkpaCTrssexs5CXN/4E7kWu1PArYDXgv8FXhENwKUNPhK0mX/yqzDgX1MxkiSJEmSJEkaFJ0mZB4C/GdK6TtMjpkQKaWbUkpvA84DTulCfJKWDsdfkSRJkiRJkjSwOh1D5pbAeHl+HXmshx0ry78J/EfnYUlS/xoaGVsBrJhm0fLK8wOGRsY2zPAW68dHh9d3PzJJ0mLy90CSJEmSNB+dJmR+C+wJkFK6OSJ+R+6+rNW90J2BmW48JanpVgHHb2adtbMsOxE4oWvRSJJ6xd8DSZIkSdKcdZqQOR94LPkmEuAM4LiI2JncDdozgI8sODpJ6k+nA2cv4PXWhpakweDvgSRJkiRpzjpNyIwC94mIbVJKNwFvAfYAjgI2Ah8HXtGdECXNUXVMqIOHRsbOdRyWepTuZSxEk6QlbhB+D+x2TZIkSZIWT0cJmZTSb8ndlrWmNwDPKw9Ji2xoZOxI4LTKrHOAdUMjY8eMjw6fOcPLJKljFuJKA8Nu1yRJkiRpkXTaQkZSnyjJmNXTLFoJrB4aGTvKpIykGliIKw0Gu12TJEmSpEXScUKmjBfzFOB2wM5AtK2SUkrPXUBskjZjaGRsC+DUMtn+HQwgAacMjYydZfdlkrrMQlxpAAxCt2uSJEmS1BQdJWQi4hHkGvnbAtcBf5pmtbSAuCTNzcHAnrMsD2Cvst4FixGQpKXBQlxJkiRJkqT56bSFzMnAlcCRKaUfdTEeSfMz3fgNC1lPktQQjuMjSZIkSVKzdJqQuQPwapMxUs/NtSDNAjdJGjyO4yNJkiRJUoN0mpD5ObB9NwOR1JE1wDpgJZuOIQO568B1ZT1J0mBxHB9JkiRJkhqk04TMvwLvjoiPp5TGuxiPpHkYHx3eODQydgx5TKfE1KRMaxynY8dHhzcuenCSpFo5jo8kSZIkSc0yp4RMRJw2zezfA5dGxLnA5UB7gW9KKR2zwPikxbKs8vzgoZGxc5uSxBgfHT5zaGTsKOA0ckuZlnXkZMyZvYlMkiRJkiRJktQy1xYyL51l2aNnmJ8AEzLqe0MjY0eSkxkt5wDrhkbGjmlKMqMkZc4FriuzDgcak1SSJEmSJEmSpEG3bPOrQEppWQePLeoOXlqokoxZDezRtmglsLosb4qJyvM1JmMkSZIkSZIkqX/MKSEjDaKhkbEtgFPLZLQtbk2fUtaTJEmSJEmSJKljc+2ybFYRsR/wBGAF8FPgQyml62Z/ldRzBwN7zrI8gL3KehcsRkCSJEmSJEmSpME054RMRLwUeDnwwJTSHyrzjwA+DWxdWf1lEXH/6npSH1rR5fUkSZIkSZIkSZrWfFrIPAb4ZVsyZkvgA8BG4NnA94Bh4M3A64B/7l6oUtet7/J6moOhkbEVTJ/kWl55fsDQyNiGGd5i/fjosJ+JJEmSJEmSpEaZT0LmzsD72+YdCuwGvCWl9OEy78cRcQDwKEzIqL+tAdYBK9l0DBmAVJavWcygloBVwPGbWWftLMtOBE7oWjSSJEmSJEmStAjmk5DZBbi8bd5h5ELrz7bNXwscuYC4pNqNjw5vHBoZOwZYTT6Oq0mZVP4eOz46vHHRgxtspwNnL+D1to6RJEmSJEmS1DjzSchcBezeNu9g4Ebg4rb5fysPqa+Njw6fOTQydhRwGrmlTMs6cjLmzN5ENrhKd2MmVSRJkiRJkiQtKcvmse73gGdFxPYAEXEX4L7Al1JKN7etux+5QFvqeyXpsn9l1uHAPiZjJEmSJEmSJEndMp8WMicC3wV+HhE/Bg4kd+t00jTrPh44f+HhSYtmovJ8jd2USZIkSZIkSZK6ac4tZFJKPwIeAlwE7AF8C3hUSumi6noRcQi5G7NPdy1KSZIkSZIkSZKkBptPCxlSSt8AhjezzgXA3RYQkyRJkiRJkiRJ0kCZzxgykiRJkiRJkiRJ6oAJGUmSJEmSJEmSpJqZkJEkSZIkSZIkSaqZCRlJkiRJkiRJkqSamZCRJEmSJEmSJEmqmQkZSZIkSZIkSZKkmpmQkSRJkiRJkiRJqpkJGUmSJEmSJEmSpJqZkJEkSZIkSZIkSaqZCRlJkiRJkiRJkqSamZCRJEmSJEmSJEmqmQkZSZIkSZIkSZKkmm3Z6wAkSYtraGRsBbBimkXLK88PGBoZ2zDDW6wfHx1e3/3IJEmSJEmSpMFlQkaSlp5VwPGbWWftLMtOBE7oWjSSJEmSJEnSEmBCRpKWntOBsxfwelvHSJIkSZIkSfNkQkaSlpjS3ZhJFUmSJEmSJGkRLet1AJIkSZIkSZIkSYPOFjJaUhzMXJIkSZIkSZLUCyZktNQ4mLkkSZIkSZIkadGZkNFS42DmkiRJkiRJkqRFZ0JGS4qDmUuSJEmSJEmSeqGxCZmIeB0wDNwD+FtKaac5vOYM4Flts7+UUnpkt+OTJEmSJElLg+OVSpKkuWhsQgbYGvg08E3gufN43ReBZ1emb+pmUJIkSZIkaclxvFJJkrRZjU3IpJSOB4iIo+f50ptSSld2PyJJkiRJkrREOV6pJEnarMYmZBbgkIi4GvgTcD7wrymla2ZaOSK2AbapzNq+5vgkSZKWBLt3kSQNCscrlSRJc7HUEjJfBM4Efg3cHngLcE5EPCCltHGG1xzH5psdS5Ikaf7s3kWSJEmStGT0VUImIkaB125mtf1TSpd18v4ppU9WJn8UET8EfgkcApw3w8tOAt5emd4eWNfJ/5ckSdIUdu8iSZIkSVoy+iohA5wMnLGZdX7VrX+WUvpVRPwBuAMzJGRSSjcBN7WmI6Jb/16SJGlJs3sXSZIkSdJS0lcJmZTS74HfL9b/i4g9gV2wIECSJEmSJEmSJNVoWa8D6FRE7B0R9wD2BraIiHuUx3aVdS6LiMeX59tFxNsi4v4RMRQRhwFnAb8AvtSLbZAkSZIkSZIkSUtDX7WQmac3AM+qTP9f+XsocEF5vi+wY3m+Ebh7ec1OwBXAl4F/K92SSY0wNDK2AlgxzaLllecHDI2MbZjhLdaXLmIkSZIkSZIkSYuksQmZlNLRwNGbWScqz/8KPKLeqKRFsQo4fjPrrJ1l2YnACV2LRpIkSZIkSZK0WY1NyEhL2OnA2Qt4va1jJAlbHEqSJEmSpMVlQkZqmFL4ZwGgJC2cLQ4lSZIkSdKiMSEjSZKWKlscSpIkSZKkRWNCRpIkLUm2OJQkSZIkSYtpWa8DkCRJkiRJkiRJGnQmZCRJkiRJkiRJkmpmQkaSJEmSJEmSJKlmJmQkSZIkSZIkSZJqZkJGkiRJkiRJkiSpZiZkJEmSJEmSJEmSamZCRpIkSZIkSZIkqWYmZCRJkiRJkiRJkmpmQkaSJEmSJEmSJKlmJmQkSZIkSZIkSZJqZkJGkiRJkiRJkiSpZiZkJEmSJEmSJEmSamZCRpIkSZIkSZIkqWYmZCRJkiRJkiRJkmpmQkaSJEmSJEmSJKlmJmQkSZIkSZIkSZJqFimlXsfQKBGxA3AtsGNK6bpexyNJS9HQyNgKYMU0i5YDa8vzg4ANM7zF+vHR4fV1xCZJkiRJkqSlZa55gy0XLyRJkrpmFXD8ZtZZO8uyE4ETuhaNJEmSJEmStBkmZCRJTXQ6cPYCXm/rGEmSJEmSJC0quyybJ7sskyRJkiRJkiRJLXPNGyxbvJAkSZIkSZIkSZKWJhMykiRJkiRJkiRJNTMhI0mSJEmSJEmSVDMTMpIkSZIkSZIkSTUzISNJkiRJkiRJklQzEzKSJEmSJEmSJEk1MyEjSZIkSZIkSZJUMxMykiRJkiRJkiRJNTMhI0mSJEmSJEmSVDMTMpIkSZIkSZIkSTUzISNJkiRJkiRJklQzEzKSJEmSJEmSJEk1MyEjSZIkSZIkSZJUMxMykiRJkiRJkiRJNTMhI0mSJEmSJEmSVDMTMpIkSZIkSZIkSTUzISNJkiRJkiRJklQzEzKSJEmSJEmSJEk1MyEjSZIkSZIkSZJUMxMykiRJkiRJkiRJNTMhI0mSJEmSJEmSVDMTMpIkSZIkSZIkSTUzISNJkiRJkiRJklQzEzKSJEmSJEmSJEk1MyEjSZIkSZIkSZJUMxMykiRJkiRJkiRJNTMhI0mSJEmSJEmSVDMTMpIkSZIkSZIkSTUzISNJkiRJkiRJklQzEzKSJEmSJEmSJEk1MyEjSZIkSZIkSZJUMxMykiRJkiRJkiRJNTMhI0mSJEmSJEmSVDMTMpIkSZIkSZIkSTUzISNJkiRJkiRJklQzEzKSJEmSJEmSJEk1MyEjSZIkSZIkSZJUMxMykiRJkiRJkiRJNTMhI0mSJEmSJEmSVDMTMpIkSZIkSZIkSTUzISNJkiRJkiRJklQzEzKSJEmSJEmSJEk127LXAag5hkbGVgArFvAW68dHh9d3Kx5JkiRJkiRJkprChIzmYxVw/AJefyJwQndCkSRJkiRJkiSpOUzIaD5OB86eZv5yYG15fhCwYYbX2zpGkiRJkiRJkrQkRUqp1zE0SkTsAFwL7JhSuq7X8fSDoZGxbYG/lMntxkeHb+hlPJIkSZIkSZIkLZa55g2WLV5IkiRJkiRJkiRJS5MJGUmSJEmSJEmSpJqZkJEkSZIkSZIkSaqZCRlJkiRJkiRJkqSamZCRJEmSJEmSJEmqmQkZSZIkSZIkSZKkmpmQkSRJkiRJkiRJqpkJGUmSJEmSJEmSpJqZkJEkSZIkSZIkSaqZCRlJkiRJkiRJkqSamZCRJEmSJEmSJEmqmQkZSZIkSZIkSZKkmpmQkSRJkiRJkiRJqlkjEzIRMRQRH4yIX0fEXyPilxFxYkRsvZnXLY+Id0fENRHxl4j4TETcZrHiliRJkiRJkiRJS1MjEzLAfuTYVwF3Af4ZeCHwls287h3AEcATgAcDewBn1hemJEmSJEmSJEkSbNnrADqRUvoi8MXKrF9FxL7Ai4BXTfeaiNgReC7w1JTS+WXes4FLI+L+KaVv1Ry2JEmSJEmSJElaopraQmY6OwJ/nGX5gcBWwFdaM1JKlwG/BR4w04siYpuI2KH1ALbvUrySJEmSJEmSJGmJGIiETETcAXgZcPosq+0O/C2l9Oe2+VeVZTM5Dri28ljXeaQDq3ocHTw0MrZFzyKRJEmSJEmSJKkP9VVCJiJGIyJt5rFf22tWkrsv+3RK6f01hHUSufVN67FnDf+jsYZGxo4ELq3MOgcYL/MlSZIkSZIkSRIQKaVex/APEbEbsMtmVvtVSulvZf09gAuAbwFHp5QmZnnvhwDnATtXW8lExG+AU1JK75hjjDuQW8rsmFK6bi6vGVQl6bK6TEZlUeugOmp8dPjMxY1KkiRJkiRJkqTFM9e8QV8lZOajtIz5KnAR8PSU0sbNrL8j8HvgKSmlz5R5+wKXAQ9IKX1rjv/XhAxQuiUbB1YyNRnTksjdu+0zPjo862cjSZIkSZIkSVJTzTVv0Fddls1VScZcAPwWeBWwW0TsHhG7V9eJiMsi4r4AKaVrgQ8Cb4+IQyPiQOBDwDfnmozRFAeTu2+bLhlDmb9XWU+SJEmSJEmSpCVty14H0KGHAXcoj3Vty1oJgq2AfYFbVpb9MzABfAbYBvgS8OJaIx1cK7q8niRJkiRJkiRJA6uRCZmU0hnAGZtZZ5y21hsppQ3AS8pDC7O+y+tJkiRJkiRJkjSwGtllmfrCGnLrpJkGIUrA5WU9SZIkSZIkSZKWNBMy6sj46PBG4Jgy2Z6UaU0fW9aTJEmSJEmSJGlJMyGjjo2PDp8JHAVc0bZoHXBUWS5JkiRJkiRJ0pIXKc3U45SmExE7ANcCO6aUrut1PP1gaGRse6C1Lw4HzrVljCRJkiRJkiRpKZhr3sAWMuqGicrzNSZjJEmSJEmSJEmayoSMJEmSJEmSJElSzUzISJIkSZIkSZIk1cyEjCRJkiRJkiRJUs1MyEiSJEmSJEmSJNXMhIwkSZIkSZIkSVLNTMhIkiRJkiRJkiTVzISMJEmSJEmSJElSzUzISJIkSZIkSZIk1cyEjCRJkiRJkiRJUs1MyEiSJEmSJEmSJNXMhIwkSZIkSZIkSVLNTMhIkiRJkiRJkiTVzISMJEmSJEmSJElSzUzISJIkSZIkSZIk1cyEjCRJkiRJkiRJUs1MyEiSJEmSJEmSJNXMhIwkSZIkSZIkSVLNTMhIkiRJkiRJkiTVLFJKvY6hUSJiB+BaYMeU0nW9jmcxDY2MrQBWTLNoObC2PD8I2DDDW6wfHx1eX0dskiRJkiRJkiT1wlzzBlsuXkgaAKuA4zezztpZlp0InNC1aCRJkiRJkiRJaggTMpqP04GzF/B6W8dIkiRJkiRJkpYkuyybp6XcZZkkSZIkSZIkSZpqrnmDZYsXkiRJkiRJkiRJ0tJkQkaSJEmSJEmSJKlmJmQkSZIkSZIkSZJqZkJGkiRJkiRJkiSpZiZkJEmSJEmSJEmSamZCRpIkSZIkSZIkqWYmZCRJkiRJkiRJkmpmQkaSJEmSJEmSJKlmJmQkSZIkSZIkSZJqZkJGkiRJkiRJkiSpZiZkJEmSJEmSJEmSamZCRpIkSZIkSZIkqWYmZCRJkiRJkiRJkmpmQkaSJEmSJEmSJKlmJmQkSZIkSZIkSZJqZkJGkiRJkiRJkiSpZiZkJEmSJEmSJEmSarZlrwNosO0jotcxSJIkSZIkSZKk3tp+LiuZkJm/1o5d19MoJEmSJEmSJElSP9keuG6mhZFSWsRYmi9ys5g9gOt7HUuf2Z6cpNqT5u4bt6H3mh4/NH8bmh4/NH8bmh4/uA39oOnxQ/O3oenxg9vQD5oePzR/G5oeP7gN/aDp8UPzt6Hp8YPb0A+aHj80fxuaHj80fxuaHn/dtgeuSLMkXWwhM09lZ/6u13H0m0r3bdenlGbMAPYzt6H3mh4/NH8bmh4/NH8bmh4/uA39oOnxQ/O3oenxg9vQD5oePzR/G5oeP7gN/aDp8UPzt6Hp8YPb0A+aHj80fxuaHj80fxuaHv8i2Ow+WbYYUUiSJEmSJEmSJC1lJmQkSZIkSZIkSZJqZkJG3XITcGL521RuQ+81PX5o/jY0PX5o/jY0PX5wG/pB0+OH5m9D0+MHt6EfND1+aP42ND1+cBv6QdPjh+ZvQ9PjB7ehHzQ9fmj+NjQ9fmj+NjQ9/p6LWcaXkSRJkiRJkiRJUhfYQkaSJEmSJEmSJKlmJmQkSZIkSZIkSZJqZkJGkiRJkiRJkiSpZiZkJEmSJEmStKgiYllERK/jkCRpMZmQkTQnEbFvROzd6zikfuNNpObD40WSJC11EbFNRNwvpTSRUkoRYdmUpvCYkDTIPMGppwatYGrQtqfNGHBBRDwpInbsdTARsVNEbNXrOLR4ImLL8vdB5TjcpoexVL/rR0fE7XsVi/pb62YyIu4CkFJKvY2oewb8N08LtFSOj6WynVK/iIideh2DuuLlwDcj4hMRceuU0gRARGzR47g60qTkQUTs1esYZtMqa2gdE6pfk47fOlTKGbbtdSx18Fq1Py3pL50WX/VEEBHbDkLBVHWbBmF7plMujF8KXAp8HPhoRPxTRNyih2F9FXj4Uv9xWUoXTymlm8vTM4CDgZ17F00WEf8KvAHYvdexNMFS+75GxLKU0kRE7AZ8LSL+eRASyRGxX0Ts0cTfvFZBz6DecPVSJfm4TUTs1cTjoxOt7YyI+0XE3Xsdj5ql8r1ZUr+PnYqIJwDXRMSqVgHaUjQg1//nAScBDwJ+FxFvAEgpbYT+/0604ouIvSJii6YkDyLipcCbex1Hu8q58PbAmyPi4xGxQ4/DWkqeX67vB+HcMmet73FK6eaI2A54W0Ts3+OwFqTyXdo2Ig6A/iunbD+/V86nfX3e77Yl9WVT/4iI44GP9TqObqjciL8iIoZ6HE4tUkobU0pfBJ4BPBfYE/gS8G8RcefFrslULtj3A66b6cdlkC8mImLPiLhbROzWlIv/bimFXRuBL6SUruxRDFHpWuGO5NZjP1qE/3vbiDgoIg6NiN1LIX+j9NvFYN0q388XAlcCa1NKf+9hSB2r1Bx7IPA+4J0RsbzMa8xFdEppY0TcEvhQRDw5Im7V65hamv67VTne3wWM9jKWxVL5XjwaeA/wukrSrzHfi6rKjfzWEbFd+b1Zvkj/s1H7qhta35ul9vu4AOuBzwOnkFtXPKy34Syett+ILSNi5/L93LpnQS1ASun75MTAM4GPAK+IiMsj4oiyPEWfji9TEjApIm4HfBA4JyK2L8v6Lt42RwH79luclWuItwOPAL6ZUrqufb1+ixsgIlZED3tuWKiIeAz5GuaDwJMjYklUNCyV5B4UEQeWWf8JHA40unyl8l16A/CZiHhhdXk/3G9UylBvW86dUZ2/VPT8g9DSUvmC7Qk8JCLuBP35wzoXlRvIhwH/DjyiH05wdUkp/ZGcSFsF/AIYAT4DvGSxfrhLIfRxwFuAH5R5yyPiwIh4TEQ8K3Lrq1az98Z/HpXCnX0j4j/J+/5rwKUR8Z5Brz1U+Z7dEtgV+AtwTZnXi9qRrfPVfYEtga1TStfVFUtE3CMiTgF+TP7czwMuAv4zIo6OiF3q+L/dUDl2nxQRz+11PIup7Xj4EfCblNJ3yrLG/eZVWqj9J3ATcGpKaUNZlqp/G+B25AKJ1wMnRO4GsWcFWq1jpekJ9rbj+oiIuPM08wdGSc63vhenAePASa3a3WWVrSo3nY3YD2038t8Bzgc+FxHPquP/lf2SImLLBp1DOtKW7DooIv4rIt4bEcdHxP16GNe0NVX7UUrpQvJ9yLOBvwFfioiPRsQdextZ/Sr3Ni8Cvg78Fvgy8IGIeHgvY+tEOYfemFI6j3wO/RSwEjgrIr4WEQdUxpfpq27MKuf59wA7AB9IKV1flvX7eex/gbuTy2P6QuXc+BJyi6mTU0rvLPO2rKy3Vb+NN1RieRlw6Gzr9Pl59Wygldz+b3Klq4cOehkDsC/wVnLvLycBTwP+PaX0U2hmOVLl3vvhwPOBDwEfrSyP0ntDT47HSnwHR8QZ5N+ydcCnI+J5scS6JG3cAaaBMUou0Dkapl64RINqyVVuWh9OPpl8oZcnuDpVLoRfA7wXuBo4F/gDuSbL5yLicVH/+DLvBn4K/E9K6fqSUf8w8F3gc+QfnSsj4rXQ/AIumHLR/xHgUcB/AK8kdyG3ipwYGFiVz/DfyTcRQ+SWKa3mxYt6k1a+43cmH//3JieJ/lFg3c2Lt4jYFfgA8ERK7UHgjcAFwDD5u/jWKM2R++HcU42hcuyeCNytLF8SXYxUjodzgNcBKyLiNuVCuN9v1qeo/C6/iFxY8h8ppa+XebtHxJsi4ssR8eqouSZ9pyo3ACuAvcgFzXuTu+P8EPCqVgJhEWO5Y0S8EvhERFwQES8u8TVS5bh+d/n7xOr8KHoRW01aLWBGgG2AU1JKPyjz7kSuafqDiHhXROzShO995dh8Gfl673fkCgC7Af8REWsi4qFd+h+3Lon675J/094XEU9eyHs3yFvIrTweSS58/GdgLHILxH+o+/vSev9SwLlNRNw1Im7XjwXgMCXeq1JKnwSeR74HeSrwrYh4/SLch/RETLbGewG5VcnfgVcDPweeDtyvX39/Z9E6FxxCvrd5KHAyuReGOwL/FxEfjIjtK92Y9bz8qnJNdATwQHJrrc+UeTtExMsj4iPlN70fW7N/lfybdRD0x71DubfaCjiGfL/zP5VlN0fEjhHxevL3/JPAiyPittD7+Mt96tbk7+EUJRFzi1ZicfGjm7uSGH0QuVX/A4HV5N5Q7hkNbYU3m8it3C4B/g34K/ke+4/AFq1EVKtcr3WM9fpYm4vKvfco8AXgYymlv0TELSPin4BzI2I18P8WO7bIXXlvjNw13EeB+5DLdt4MPI7cG892ix1XT6WUfPhYlAcQbX9PA24E7tTr2Drcni3L372ApwBn9jqmGrd1Wfl7T3J3UccBy8u8PYAjyTfUfwNOJycItqkhjvuSm5C+HtixzPsE8CfyxfB9gZeQb3InyBdzO/R6/3Vp3z8duA54bGXZz8gFibuW6f2A2/c65hr3xXPJic+byrH2krblWyxiLLsDZ5Zjb4KcDDygsjxa57oF/p//AS4BHtU2fxvgAPLF8kSJZdtef0ZtMS6rPH8PuesBurFfmvIo58evAFeUz+lNreO0afuBXInns+Qb+dY55wHAWWXbLim/D58CturX7QO+CPyQPJjwweQagV8p23BhOc/sVed+LH+3L/vsT8D3yQXSE2X/7VhZvy/340zbVZk+ldxN3yb7sinbNMft3qqcf88DblnmHQ6sIV/jngtcX46xWzZh28ktP39Mvk7fqczbn5xY/j9yC9WPLvR6o/xu/qkc+58tz68B7tfrfVDTfm199+9NLkw/Ebh1mff9cozctkxvtxjHSiWmp5JbQv2xnMe/DjwL2K7X+22amFu/oTuSu0f8OfA9cldmfwN+TS7UWdbLOGva9i3LefU9wMoy79nlu3Of1mdKrvXdmO0HflLOAQe0PuPy+/ze8rt4HfDiXsc5TdwfJd//3q5M70tOxE+QW0xOkFvO9DzWSszLyvnlSuB9M63To9gOI18vP7VMt8qM7kJO0k2UY/2Kcg59Z6/3ZyX2R5Z9evsyfS9yRcK1wMXkcor9K+sv2j1rh9uzC7nlyIZyjn05uXV531/DzHH7dmubfkw5vq4HbiB3zfwQSnlXWWdLclnYw/t9P5Tj72rgpZV5ryJXshkHLiuf7eMXOa7Wd/o95bh6UJleUfb7cZTyjPbPaFAfPQ/Ax9J7ADuRb2CfXH64XltObEeSM/LHkptKPqXXsc5hW5aXk9nN5eR2YJnf1yfpBWzvyeUzu1vb/GXAgeQEwUR5vKyG///c8t6/IdeKe1y5IHtm2w/mEHng9wngIb3eb13a9vcA36QUbpFbyPwFuHdlnQ+SuxNa3osYF2k/7EruKu9n5MKuL1Y/43IsLtr3j1yD6EvlOLyYXFvx1tV4FvDedweuJTc33qbM26ptne3ICcqJcsxvtZD/2YX9cSLw0PbtJ9eUvxLYvdfHUA/2yT7AC8iJjAlywe09Kssb83tRjrHflue3JhfaXgo8nlw78BRyodhOvY61Le7WDcBDyIWNz5xmnSeRb16uJre6fEQd59LKd+IM8s3Io8v0fcmFia8FblHmbdnrfTfXfVuZ3ovcmuKfy/acBDy6TL8OeFs5b2/yGTTxQU6+fxD4PbkA4+7krhe+A9y/rPNWcgHSrr2OdzPb0jo2lwHvBF44zToPJBeC/4JcMPYv8/wfrcL0J5JrpD6n8n9/Ru4Wt5WkuDUlyTVID/I9zjeAO5bpQ8pvw5GU33hyy70n1BxH67O4J/l68qvkGsKta+2xfjxmK+fz1eSui59Wpu8APKGcX1rxD1RyDziCfL/5qDJ9G3Ky4o1MVpR7dNkHK3od7xy36X7lt+JVZbpamWcncsuZ1r3lFf10TiAnrX9Tnm9NTi6Pl+/RtuVz+QuwRx/Eurxt+tPka7gZK3OR7zEeQ0n2LUKM9yif8+GVefckV2zYQK7UdBfy7+wnyrpP6/W+rXz+J5ELlu9I7k7w2nKu/155fi1wfK9jncO2ROX5ncmVJybI3WYfRcMLysvv6wTw9DK9jNz6/6nld+QU8r3Cb4HjmUwU7wF8G3h3r7dhDtu4T/lt+JcyfQy5wsuZwK3IFUt/A5zWg9h2Jiey30Gp9FG+z5cwWc61Tdn/R/V6X9a+P3odgI/BfzB5o/UU8s3WL8nZ2d9VLrB+U/5uKCeLq4H79jr2OWzbbsAJ5JuYm8kFs/tVljemoG2O2/uy8jndvUxv3faj/SRyIcQpwL1q+P/bkgsDPlv29wS5KeZuZfkWlXW3J1/g/0ev91uXtv2twK8q2/ZncvPOVkH9nuSC3v+iz2vdzHO7p/0OkVuHvIdc8HU1uSbLHXoY53PIBdPXk28cnkxb8qSD93w+cDlw0GbW27V8D64Bhnq4D+5azuGt2pv7VJbdk1z49shpXreM3GT5gF4fbzXvn3uRk2et37t3A7v0Oq7NxNwqsNsZuAW5oOcP5TP+I7mG1RGV9V9JLqi9S69jn2F7XkiugfWQMh1MLfx5Rfnd+FvZxmfUFMdK8o3G6yitOMktYy5m8mZkB3KN9Xv0er9tZlta13jHld+l35GT5dVrvD+TCyKuIdde/zmwZ69j7+I+OIRcCHcj+Sb+G5Raf5Xj6hdUasf26wO4PbmLst8Bx5V5W1Z/z8iJ/8eRrzk6SqyRC3i+0DoOyEnrm8hd6LQK3N9a13ewh/t3S3J3PF+pzPsh+bp2pzK9U5n3H+Qx6uqO6bxyrrlzmT60nAOfyGSCqK/O6eU4vZ48zlF7RZU7kZNeE+TKMp+ljwrxF7jd/1S+J61axR8q59Pq9da/kH+b79zreOe4TXuTrx1fX5m3BVN/m38MvB94Xq/jbYv9iPJduYxcxnE18KzK8heTr+MXJaGxmVjPJ1caa7VwfjqVe/oy7zbkbuP+hckWcxPAXRcpxr3K8byG3EX37cktTCbIlVW2qaz7oPL9fslixDbH+Pcuf88mFzi3rjVvTW6N/eGyLZ+l0hK63x5MUxmI3E32xeV4/xC5NdMteh1rh9v39HJcPbhM33Gade7OZHL/u+TKRJ8ilz/ts1ixLmAbl5F7rZkgl71OkBPIrYogK8kJ5I+wuBVZW9d33yd38wu5NeQEueykdU9xn3Lef+lixdazz6rXAfhYOg9y5nN1ORm8gZydfim55shnyo/u3cg3Io2o1VO2a0vyBfLJ5BqSN5D7oqxeNAxEYqZc/NxcLiiqiZhWUuBJ5O4sai0YJ3dT8ATyQJZTEhCVE/1KcsHPu2lWs/2V08VLrqH0R/KN8vvLj+tQZfkjyDXHntvrbejSfqgeX7uSu854Krm/020ryx5B7jLpynIueXSd8ZALcHehknitrLMdOUl2BblWyn/TQQ33yv96evm+3bVMz/he5Rw0QY8Lr8gtJc4qx+rPyTdQrVqbPyUPlAg5OfEUciuBX5fYj+hV3N0+TsrzW5Bvbu9ambecXHh7ejler2KeNcx7tF2fIXdXsCe5deL7yTdkt68cr0Pkm8xv9TreWbbjgeQC81aNsSAX/LS2YT/yDdhdybXIJoAnt3+2XYijVTPt+WX6kPK/nsjkzcgjyQU8tZzTFhj/fajUkCRfB32c3D3HieRk8pPJ3QZdTu6+bGdywduWDEgrzspxs3U5951YHjtX1tmXXOB9Xq/jneM2HU2+lv1DOUYf2PY5b1mZ3nmO7znlGq1851ZTkhLkrtyuIlfmabUO24vcjdFJDFAlk7JtJwM/Ls9fQE7kPaCy/H7kgq/jFiGWIfJv879Rkj/kgpLPtz5fJgvMH9vDfTalG1hyTeU/ASelyWOzepxtR04sjpH7z+/5596l/XBH8jXmK8p35GZyi6bWfdje5bfrgl7HurnPs/xdVj67s8vnOcymrS5XkgtPn9rruCsxtSqr3ILcZdxny3n+n5js0vw25C7XLuuDePcmt264iVxx8nHkim1/BD5JbnlyEZOVKDYCPyJ3yfb0xTwuyBV7WsnUVmXdd1TWaV0jHUxukf2qXu/fVuzl737k389/pe2+rXxn31W2q2+u7SrH8wryoPank5MPTyjnnNbyrcn3Ar8nJ2Zq6953Eba5lZjckZxIHaOSnKys91hyYqCV2Hhlr2Ofw7ZV78teQ75fey1Tk9yPIleSelaZXpSysvIdD3KlnB+R74e+SR5HptU6emvyEARXUSp4t/8uDNKj5wH4WDoPprmhKl+4c4G1vY5vodtDTiQ9hjzmw83Ar4An9jrOGrb7LeVH+Bzg4ZX5u5QLunUsQnc15Iv42zHZV2t7//UPLifyY3q9z+axTY8gJ/ReBtymbdmu5CbPfyoXBf/MZMHFPcoP2y96vQ1d3Beti79VTHaFt6F8pv9Hpds8cm3dF5NrVM2pgKjDWHYkFzj+gnxD/GNyAerWbevvR04WvnqB/3e4bPeM78PkjcndyLXQj+7l51Web0NuifAdcq34b5ELK0fJtcivZOoN33tZxBu+mvdDNZl2PjkxdzW5dtXDKuvditzs/wLg172OezPbdFD5rI6uzGs/396SnIy8gUqXdf30IN8AbE9uyXoD8KRp1nk4+bf7weQCv18AX64hlp3Iicj3l+nvkwukdinTW5P7eh6nz1pVkJMxE+RWcLOOFVeO82+Su3hoFRg2poLEDNtUvaFdTqkRO8O6u5X9dD01tBqucRvvT06W31jO4SdT6W6SDrrGpJL4LNNvBS4pz08it8ip9q//sPJd7Ksa8Qvcr61riYeW71Crq7sTmBx/aFfydfafmSwwqu07U841v2Gyu6jnk6+1DqqsM0zuSmTR72nI1/q7t00HucX8ReUcvW91e8rfW5J/d1/OgCSAK9v4evJ92NXAt9uWvZxc6H549Zjrp0fle3B38nXhbciFg9eRr/dfQqXGOrlQ+M9M85u9yHHPq0CQfC93HfCcXu/zEs/e5C6+v0u+pvssk/eUN5Jbdr6NXFnqTsD2PYz17uSKHG8mJ7la58dWi73l5KTkjUzTuqHH+3mPcry2Wpgua/8elvP+f/U61hJL9Xf5vBL7L8j32hPkbkR3bXvNSnp0v7nAbb1VeVS3eQj4ALkCyFXk652dpnntAyljvPX7Y7r425YfRi5/vbiHMd6nHGcXU+m5oCx7ELmV8JllemCTMSmZkPGxSA8q4zqQL6SrNexaNybPaK3b63hn247K81uVH90dmdoaZi9ybaULmWzm2FeDbS9wH+xBbnXy5/LDdR65xdOF5Ju4N/b68yEnaj4CXNXr/TXP+O9Mron+V3Ih1mOrF8Tkwp0PlwvQ75NvZE4hd32zjkqCrMmPyue4V/mR/gR5fIVdyN2CfQ+4U1mnOnZQLd+zyrnr4+TaJKvJNZ9a3/GvUumepov/d1vyBfHvgcNmiqs8fzQ50dGLApPtyQUEd2JqYmYvcsHSL8q54hryzelryMnHgemyqGxvq5DhweTWL2vJidM3lePki7R1UVb22T7led+MF9J2bD2YfKO+f2sZm9ZgPZlcqHdqr2Ofw/bciZwsa30m9yUXVDyc3IXS+sq6q8mJ15U1xPRqcoHaR8t57p8qy+5Nvhn5VK/33XT7spwLTyzTewD3bFuneo338LKvh3sdexe2vfXbFOW7/R1yTdiLy/f8wOq65Jv8XwL/1uvY57h97bV5jyTftP+ZXFjxMuZxjU5u0Xt+9VzPZIH5/ckFx2vIlZieydRanR+hjFfV5MdM+4tc6NyqnHAc+fru9uRruj8B/1rWq7VAnZwo+xz5WuPeTBZItfp134GcMPstPehis3yv1pArMLSPgfHocmx+oxyr1evBe5ErfLyi18dADftkT3I3vVeRrw/fSm6NeBY5sfmJXsc4x+04j9w6q9WFTqtl2AT5Ov/T5dj8C/D9XsdbifvhZf9/h1zz/AWUe5LKOq8gt974nz6It1pGsRX5XvPfyN2sTZDvN2cca4lFLAwtv5vVspaZzp+HlWPng73ev9PEtgP5Hv2XTK08uGVl+TfJCbHau6ScQ7yte5c3kK9nji7TdySXR5xMD5NzXd7W7wBfIV9/bF2ZH+Sk8EfL9/ZnwIt7He88tqt1bO1HHrfq0vL9/gC5S/UdKuvellyZ4dLW956a7z8rx1j1WnAZedzwG8t56FPkyrWvKfv/F5Sxt+jDigVd3T+9DsDH0ngweWFfvVjegtxMeVty7cnvtNbrxwdTC3TeUE4WN5WT2nG0jXlD7vLkJHowWFY3t5dcqHo38oXyrpXljyJfLF9CrkH5M/pgoDpyguwj5aLiyb2Op4P4tyXXRryQXIPpw+QCw20rn8dzyDXrbyLffP0PcEivY69hX3yAXCjZ6rJrb3IT9hcw2Q3WY8kFxrUkcpksgLt/uTB9aWXZueWCodWU+Z10uV9ZciHDjeTCkofNsM4K8s3h5T36nI4s2/++1j5j6g3V/ct3cpzcKuAkSrPksrxvEhFd2h/fJReM7FemH1s+w8OZvCiddVygXj8qx/0zyTco40yOdfKPChZleityrdxn00c3be3nhLaY712+r1eVY/eacr69glILt3yvzi7fva4fo+RE5mfL//9d2df3IFdSubDE1lfdt053niUXnP20fP4rK/NbXVNtRb7G+zZ9PmbSHLa/9f399/L5fJWcWGv1M/5kpialn0IeY2BB44nVvE0x3fPKvB3IhYv/R04UXMgcu5ckt3D9C/la5d+nWf5kcqHBRnJFnwPL/voC+bqycddws+yLUeDgyvRu5bz5jXLs3ES+xrgGePtsn8kC46i2+G11BfIIcnL4d+W4vn9l/SeVZW/u0X47vpyXf01uTVsdm2kZuSXhBnLXS58mF+i8iFwgei01tJpexG1v/Q4vL9/D6jgx25MHaT6/fC83kFuUvZbJlpZ9V4jF5L3lrcrn9VqmFoxuXc4bF5fP/LfkhNMm3QQvctytAs8nlO/JFeR7r9aYgC9mauuNY8t5s+uVOeYZ953Iv1d3advP25FroZ9CrhDyc/K91U69PkZKfDPe05GTMReWY6TnY0NVjo2tmOxy6Rnk37Uvk+/pqwXiB5MrUb6p17FXYtqefB33Via7qnw7ucvZfcv0FuRKo3fqVZwL3MatyUMlXEq+Ljm5fD+qCcudyZWqv1x+Uy5khnvvfnkw9Rruu+UzO7N8tyfI5at3qqxzx3J+evAix7kz+Xf5TUwdb/sOTHY9fyO5gs7HWvH14+9Y1/dNrwPwMZgPJi/4b0/O1F5RThJvp1IoVVn/iHLSuOdix9rBNv1LOUmfQy4YP6ecQNaUC7LbV16zDX18Iz6Hbb1X+dxaBVbfIWeuqyf/O5Av7HbsddwlniNLzMf3OpYFbsfu5L7oJ8g3JG+gbcD2ss4ug/hjRb6h+TTw6cq8r5BbHVT7GP0BuaZX3bU7PkiuzddqJdCq9f1YcpdOrZuyCRbQjJt80/0k4DGVec8pF1gT5DGTHkS+iFxOrun24XJOekqPPqttyj64bZl+KfkGZPu29Z5Ivsi9nlxz9ZX0cYvIDvfFncuxcAyTXav8lNyiYMeyzh3KcdvvSZktmNqn+EcotZXK8vZWMn15HiInCt5NTn68qDJ/G3Iy95nkG5dXM7WFw/8j175e0ICSbL7A+4XkgrRWN34TwNeBI3u97zazXa3Cp2Emk9KfIV/P7dC27rPL8qFex73Qz5Fcu/CvTO1m6r3kSimtgout2l/Xjw8mC3y3Lsf76eV78hRyQrJagHcHcnc2fwVeN8f3X16+Y+8rr7saeGZl+S3J/dV/jtx6sjVuwCX00UDNXThmdi2/AxPlWNmlss4B5NYfryW3uroHi9C9H/n66p2V6SeRC5onyIU5JzHZpdqFPd6Pe5Gvfa4hF8K+kcqA9eQCps+Sk0mtcSe+TYMTepXv5i3I13iXlcc5VArSyC0U9yUXuK+ozO/b806J7+nkMU1aXeUFm5YN7E5/FLhXf8OvIBcW3rlMv5BcuPvA6udWns/apecixd4aj+UH5ITLXm0x3prc3fo5Zb2vkbuL7HnLjRm25+5lf6+h0sVRr46Ltn35HnI3a63uxF9CTnb9nnz9/ErydeZl5PuEvqiMVrZjN/I1TKubtf3I3SK+nMlrvfuSC837ZiynDrd1n/L7dg25stnzyV2wVSvT3IHcE8ZF5IT3Z/vh+zzDNrV+K0bKNj22suzKckzuVKY3qRS1WL8V5XfqYiYrM72YSvf85Irsd6fLFVub8Oh5AD4G+1F+MH9PrkXy4fIjegm58ONelfVWULq/6McHkzdVu5BrXP07kzWQXl/m/ZRcmLKaXPB4m17F28Xt/n75gT6WXOh9LrnlyUXAE9rW7YsLi8rx1POL+A7ibiXCtikXdhcxWUtsA7k1xgvIN/d9WfjZ5f3x38D3yvPHl+/X4ZWLj3uWY/T4muPYgVyg/tHKvO+VC7Tty/TTyAnL91IpKJjn/2kNJP5X8kV76xyzTdn+/yUnf/9aLrJ+Q77Yv5w+6RKHXMvqkvJZva9cXC1vW/7PZf9NUEk8DcKDfHP7J8q4B+Tau9cytaD/WeW82oguBskJi1bXOmeRW0dO6QKj1zFOE3PrXPpUcs3z35O7XLq5fG+eu5nXt2rur+lCLK3rh8eTC7xXl/P43Zm80b0l+bphFbm2el8VhlT256PIhQybjMlAvnG/npzEOoXcMq71ulttbp835UFOtv4cuE+Zvkc53z2n8nmeSE4+902LsRm2pfVbejL5Rv7Kcm6+mVzz/onk695qodMDK8f0jDfyTC3EbI2Z1Sr0u4iprTD2LMfLcHns1ut90+X9fAi5FdX1TLaGOWGRY2jV4m59dh8DzmtbZ0X57l5JTp5dTS6U6kmNaNrGXiC31P8JOXH0dXJheHV8mVZr/ntMd45q0qPy3fwA+d75c+Tue1tden2etm5faUgFF3Lyr5V8/RGlFXxZFvThNUWJ7Snk6+2HlukdyPfE/8Fkcv5R5TvUF4W35F4XHk6u0DZBHkPv0Wzafe4Q+brk+2W9Y2uOq+OWQ+Rrp5630iC3dHkNsD85sT5R9uEtKuvciXwv26r5P0G+Bjyk1/G3bcstyBWDPlCmzybf064s08vI16fjVFp6NvVBbs10HyYrSpxTvhc7tq3X6uHhbb2OeTPbsw05mfpB4FZl3lvLb3l1bL5zgMf3ONZnMzlez6fI90abnPPp80oFXd0nvQ7Ax+A9mLwBfyG5xtuTKssuJzfTvLlchL0GuEOvY57Htr2SXNj4gDK9N/nG6nnlx+rj5Bvz65ime4YmPcg3NL8FHleZtze5Cfa3yDXyPwfcYxFjmvVmo+knb6begF1GKcAij4nzCHKB/ES5UHoobbWQB+0BHE2+YXsKuQb2f1UuNLYrx+J1LEJXBuSbrMeV5/cl34Q9q3K+exG59c7QAv7HN8t7PL0yr1oQtoJci/lfycnRM4F3kGud9M0NLLlwrdV/9tXkVoV7M3VciTtRakYO0oN8UfyV8tnsR07GnMhkjeedyTfrP6Ny09aPD6bW8t+SXGg7QU5unAzcu9cxzmEbLiN3ubYPOVl2RPlsNpK7CprS/U35uzU56fAmOkyuVt6zdX54IPm6589MVt74CTlh1/OChTluy9blvPd74JOUQaPb1llOTkpPkJMWr1zoPuz1g027vns6+fqn1YXf18hdiO7W+szLd/xCKl0z9tuDqS2hbybXGL0NuaDiAiZbbH2GXPA07+sNNm1Ftw+5BeUPy/v/DzMkX9pf27QHkwmQF5Tv+hfIrYVeRS5MnyDfEz2u+pnQ5co2wO0qz/+R4Cifw+/JXZdtxdQE2s7kmvQ970a6sh8PJHdf9puyP1tdvP0PMxToNP1Bvpa6ksq1Uvm+Hk++l94IjPY6zg62K8iVmFoVc75AW6vq9vNuj2JsP389kVzh5i5l+l3k++Q7Vtb5D3I5wVCv93Nb7LuSyyp+Sk4OvI+cvNy2ss7W5MTCW6h58HJywf63mOd1ZL/8LjCZoJgg35/+lvyb37pH3ZKpyeS9yfeO+9FHFVjbtunF5BZg7ya3jnlUZdm+5EoaF/Q6zgVuY+v35GnkSjPfIyeifksub/gYuUvjW1Zes1U//74w2RvD14GPl3l3KL+Rr2CyotB+VFpB9SDO9i4T30JOylxFqcTV633Zs8+w1wH4GMwH+aZiLfCflJYi5KZ0fyQXLj+NXOPnF+UH+b69jHeO27Qludb6hZSxVMhZ8x9TbnjI/ZpeSi7waVxTeabekN2W3EVTqxZotTD1HuSuK1rdlCz6QOKD+iAXuv+BXOC5dduylcBpZZ//qRxnt+p1zDXvjw+VC8MJ4NGV+avIN6Tvr/n/T9fF0P7kRNCzy/Qu5MLbn9BhrUzyYMl/rm7jbDGU+dXvZF/VjCQXzN6FXDi7gVwA95Syr/rihqrGbX9eOV7XkS/yq33lPqP8Dr6yTDeqpVv5/W7Vcr+Y3HKy38Y5adUA34lcWP6MtuV7kFv9fK+cWz7GNIUPdDFhRi5w+l/yDfmtyAn1r5b9eAG5kH+Pbv2/mvbr40q8fyO32vw5uSuEu06z7n6V7buUBiZl2o/rynH10LJdTyB3WXkzuQZy66b3LuTr2jN6vQ1z3M5PkQtaWt2t/RO5oPfZTHZ38zty666hDv9HtWJBlO9B62b8bzS8i9lZtntLcsWE9zK1a449yJU4rij798u0tRLo0v/fmlwp4Ju0dQlN7l7z70x2tTSlAJpcyNM3LfXI1xDnkQvudyZfS5xMvpf8Pfna+IG9jrOG7f4kba1pyRU/DiVX3rq+fI6P6kV8C9y2ncnXENeTK++cRE689bTAmqmVUaqF6oeSr2fvR+7i6e/kxObWZfle5AThV3q9b0s8W7ZPk7uSfwv5fmN92f/7MrWwtNbWPeSW8i8nt8a5uZwf+/r6Z5ZtuX/5fdxAviZ+NlPHi/lHsps+LdSvxHdbJq/bri7bshe594bPkO97+74i1izb2ap0tZKclHx32b5tyja+uvwmX00eG/oO/fQbOIft+x8mexX5ePl+3ba17eQeA65o/VZQ8714ZX9Xzy1btJ1f70S+F9tA7lXphH79ntS6r3odgI/BfJQf/O8BJ5XpIBcgv4XJvjXPJBdW/ZA+rylc2a77U/p1J99Q/Qx4fWX5g8kZ6p7XKlvgdp5IvsH5PaVpdplfPakG+cbog3VsL5O1+LYnF3qcRu7n8440sDuyeWz3LuXi7oOtfc7UwowdyWPknAd8vtfxLsL+2J9c6HcF+ebnO0zW8PpCHcfCTBcplWNyZ/IAx1eSb8Y+VOIZ6fD/bUVuMfh+Jvt5nS4R1Pr/fVUA3hZjexJxGya7a9lIblV3GH3SnUNdxww5KXNZuch8N7lV03+Tk63nb+5Y69E2tI6vW5O7F3oduSbuvtOs+0hygfwEfdLCg0qBYtmGl5C753himTelkIVcCDFSjstj6/pMyIUgH6ZtANcS79OBX5Jren+M3CVj3xwT02zLa8iFDh8k37jfVKZfwzStQcpx9LVex93Bdu5YfmtOZJpW3OTKOD8nXyNVxznbqXxn/jbd96bfHuTr2HPJFWxaN8/fJicPdyR3Y3IW+Vr9JipdDc/hvauF+1uWx8rKvO3JYxV8hMkk39PbX9vkB7k1ww2UawM2bYnyeHLB6FVl/55IFwsjyAVP7yv79mbyNUarBneQawa/rkxvQa61etdy7jwfeHmv92GJ7Qjy9d8mFd3ICdBLyImZteX715c10Oe4rdUuLn9CrtjxlDJvG6YmCHYht9pYC/xTr2NfwDbfofz+TZCvhV9CD68ryNdqL2LqvVfr/Pi/5N/sH5bfiOr3+Znke4Gejv9GpaXdTOdScuLrg+W8821yRdmhxTr3lt+Du5DHR72c3GXmS2jI/X3b5345+b70T+U89AnyNXL1+NkHeDN9WgGZqdfHra6W/1Z+vybK9jV+XLeyfW8mJ13aKylsQ65w0+qi+VdUevnp90f5Tq9jsuXhEZVldyWXG327B3GdQu7lpdp9+T9akJFbJF1Nvp5+52LH1w+PngfgYzAetNUKJ/eH/gIma9w9n1wT476VdU4j175r1I0Xk7UgdyK3EPlImQ5yN23X0IAb8Vm2L8jj4vyYfAM3TmXgPDbNbtdSe4DJm5L/LnFcWy4cf1d+TO9OQwbOned2b03uSudXVAY2Y+qYDV8t352BqEVQ+VHegdy1z9OBh1WWb0e+OX0LuSbpx8k3D7WO0wQ8iHyD9SoqfbCWZQeRE0IbyoXEfy7g/9yFfEE/p4RO2T9vruu71+Fntx+5cPtz5MKBY5k6APzOJe6fle/xTr2OvVvbXp7vRi5UuBeTBV4PJNdg/UPl3DVCqWVOH7WOYerN5ZfLcX19OS5vLr/X207zup6PgzPdfiz7eYLJgea3K/OXMfUm+ZZUbsrq+h0hF+78ywzHzo7k39wJ4O293p8zxN8qjNq77M/zyYW9jyG3gLmeXLD/FBpcGFrZ3v3J10BXkbsgfB6wc2X5PcmtpVuDJb+R3J3kF8r3/K293oY5budO5AoFTyrTDy6f5RFMXoP9Ozmh2GrtPqfvSOX1j2GyAtb3yb/f1VaDty7HzXeBX/d6n3R5/64g1yo+o21+9dr1J+QWtv9V1u1qoVc55z2CXOD9F3ILzdZA6u9gslbqF8jX+xNM1vbeuZuxLGAbnkQuHBxuHVtM7X7t8eSCw6soFQGb/iBXiLiifGYXMrWF1dZM/c1udZfY1/dB5Nahh5ITsZskd4GHlONxAjilRzEeQO4W79flvPXQtuWHlHPVBPla97HkSqhvIhdaf7kP9vNryfeJ7yrnlTeTuw5+EbmSxOPI16qPJvc2cB35HvszLGBslw5j3Z5cufOSsk+/yTQ9BfTzg/w7umN5vI98zfw7cvd1dy3f1+PI9wE968aUyd/kanelx5fP/fMlxta4qDuTW4y8lnz9c6t+P7/MYz+8qvzG3bVMb9O2/CXk678LgMf2Ot55fK63KJ/Z1eTE8EfJicGjyeVKV1HKYanh/pNprv3LOb3VPesbmWaYA3Ky8lxyF52tLuX6qteP2j/DXgfgo/kPcnOzN5C7saq2oLgFkzfxR5Nrgd2/TO9BrnXXqBr+bFqQ8wVyjYjXk2ueraMy8HeTH+Ui4l3kBNM15SLj9pXlW9V1wqz8uDyAXCvutSWeA0pMfyPfxL6Qmvu57dG+P4hcQ+OnlJpxlWV3Jtd+eHOv46xhuz9SLpL+Xn7Av0+5AS/LWz/UtSWimLxQPaycs1oD8E6Qaz1VvwMryc2db99+QTfP/7myvP9zqzFMs17rfNpKmPa6j+1WPDuRC2WvIde0O7dsz6epJF7INWJuBxza62OtW9tenr+jnPtb46t8i9wFXWv/bEUu4N2x13HPsj2t4/7N5ATSy8v0cPlOTpALhvquhhz5JvJhTG0hcydylxhfZXIA5GohcK3JsMr+vC/5hvcr5AKP9q5nqomZO9CA1sLkxPm3yzloL/Kgwf9Ovtm7mlyJovGDvpZtXUVOIl9FLtB+TNt3/zXkwrs/luPs1+RkdGOSUkzt+vKo8hkeWqa3J9duPGc+v3FM/lYfRr5G/jG5cGp12U+fom1MGvK1zT4L2ZZ+erTO9+W7MUEuKLl12zp7khPgzySP33NB2f9daQXLpq2rjyYnUyfINfzHyNfTl5Xv9MnkApTd6aPCN3JrxmvKd7DaHVDrfL9/2Xd70+CCnLbPaxm5sP9j5GvQ64BXtK3f80o5c9im1rngYeQExgQ56fsrcguN27et3xrD7YAexnzH8l34Gblr9XczdWDsO5PvB64m36/cVL5HH6TH96TkQvaJyuMH5TfqhhLrxsqy1rXdn8rf3/bguHgJubC4dU3xaybHSr1br4/fGWKf9dxIrrDROs9eWrbtWvpgvCcmKxXflsmWmT9lMhl/JfCCTra7KQ/yddwEcGJ125gc6/NIcjlLX16PMDUZvwX53rra+uTwcvxdXb7vN5ffxye2v77LcX2a3Np6+7b5tyFf87XORy+i0v1t+W34DfCIXu/bnn2mvQ7AR/MfTNZquJBcQL7JBTF5QNDryTfqzwbeU34EHtnr+GfZrlZh2j7lguED5KTEMyvr7FxOMn8nF2J9hj4udNvM9k6pOVGZ/why8uyP5Gba/8IiNSkm3zx+jcqgpGX+PcjJsAlyQcETGaAB7snjb7yMXMh7NbnbneeXeWvJF9F79zrOLm1rtV/+v5MLbY4gd91xcfmM/5epN0O133CXi7ELyvH/aHILgavLvn8zHY4VM8P/uhX55vQLm9tG8kXju8rF1q598tl9hHzj2uqX9n7km9NXM9lFZeO7KCNf9LZfaL6mHBOfB54DvJN8A3Zj+d72fX/Llc9xN3ItphOYbOXzDnLN9heSu+lrFeT1tEuOSuwHlZi+Ot12kRMib2ayy8MpNwt1nEuYvHa4bfnd/Hv57awOdL9PW5x9X4hIufErz+9Jrsm6urL8zuTxDq4l39y/nYa24mRqkmK7cs69glxwfTJTW3tvT25NeTtgl17Hvpntah2by2nrgrb8PbgcpyeQC+VfRC6gOaH6+nn8vx8Bn2WyJuqTyIndR1Ri2WQMoqY++P/snXWYHVXSxn8VISQhggZ3ZyE4LG7Lh7vD4u7uLLK4u7u7Lros7u7u7k6AyNT3x1vNPdOZhMjc230nXc9znknLZOqcPlL6Vs0RuwaS1WaKdfFc7AMXICd3H+So35+k/gdCFhhCOxoiGbo2zDTIif0SMvJ/Tg7uqkzrNvjvioziLajOSN6ZtwqSz5Yumt/R6Wf8HI8E3hLpmZshebQF6dwr5H+vjC037z5GEF9rxz6TZcJ8FvtNu8nU7cjzYkjHfxPpI3uQ1O1E9bY2iLZgGb4Fcsi8gALKnkEyzyTR+kWfFo41szGSWw9HWcUjDEk5mjxme/+csf8dSmTjxb09kdz5GwpombDocW1rjgSvayDdfPI23lsL2cYeB04vkN/54zv3Te7dGPNk+bieBtW4vDfW5blI9im9bDqKY3IBOmvPoXWw1lgoqOYDGpwtNhK8p5mhNyI72ZUk9sl4vnjstYvl9rV236dQoNbFyNb7TuyJeSjvhajpkXci+WfH2KfeL3pcC/2mRTNQteZuKDL6AaSAvxeL7ME46FOhxeJQHRAH7JfACUXzP5x+ZZvdZEih/A0ZHN+IPl5Ca6PONOSK4jVro20c+LGQovgEcjy9AyxW57GfPTbqx5JnnXKHympIUG6hxHU1htPXTCjthBT0frSGJZgXGbjejznYEofZFkXzXoex2AtFik6RzQNk9DucmjH1GBrg8ERR348AmyX3eqGokyuRs+FDYJN2+FsW7ZT4vlsOY45kCsB0yNBzRdHfLPiZHClOB1BLdb8OCfqTx3WfOBfmKZrf0ezrGUhJmT3mpyEDw0m0hjOaPr7nQCQsN0W0PFIeXyXgAuP8GwRsG9fzxbf+lAZGUo4A3zMTGRkoongHEuUYZXD8H1IWfg/+24wAbGe+rkKKxkpIVlodyREtKItsA0oK3UftHJ4i5vNQAQ+xH/6EAjbGT+5n9YVKK+ON4Bhke+9myOn8dcyd7Bzeh1wEZROt9UuRgXQoyEEEDTog9q8/aC2DjbAijwyUnwGbxF7ZGcmOl2bzCTkr7qKJYX6H0ff/IsPWNNlcinNiEIpU/wRlfAwhahDF+OyBDBrt5sinJjvkjSMLozPto+DrNEpWv4Ghg/vOQNG+7wC7xJm1F9IDXi2a33bq8wbUnKI9k/vTIgPWazEG95HLLilbS/bQA2KeLZ48+wZB3P6Pkuk2hC6P9PqTkY0jyyq5D/hn0TyOQB92iHXyHTJ+rpxfT0U3FJz7MUNDQo+NZLkBMeYDgLWK5jd4S7OfP0n4G4ICd6du43cKhfuiFtx4Pspa7YWgSg9m6CDcWZEON5AOkuk8jDGZA8muv8aeelqcJxehjLGLiuZxGHxne+pkyC70KXL4fR176n0kyCJt/W4deRsPyf+3xXy7n0BGyr23WYz59zHPXiWgIWkSGbrdx65oBqrW/A1Fe72PjA9ro9TMP2JT+ztJwXdkvFsnBMtSRMMMo0+ZAnNbHGSrxvVqSHHZKhHYmjozIxEuFkDKzouxOe5JDoopDoAjUeTAtPXkCSnyLXFYrp/jI3XK9CSH8dssLTlYd0YRlB/GwXoYrR2ac0f7Ox0g02AYY7A0cEMbz7ujdNaLkMD7dbqn1JGvi4BVUh7j3xMjA1OmRO7UTn9vuhBQWmKNpRH0WVR6XxTZOgiYtQTfzpAT8SPCkUQNL3at5NsujwwmTYULnetrN6TMZM75XZEj4G5aF2xO58rOMRbbF83/CPZxIRRYkTlFz4g5OV1cd4o9ak/aUDoL5r1TzMdnY8yvRLJJCm8zCapjdHe8s3c9+Ej4OZQEEiF5Z/c4135D+O7LFz1+w+hLX2RoeB5FZV+FIkE3QVHbnZHR5GFkKMzXEixNjaRR6HsagfhL7MmzoSjAtVB2wWBqcFNNIweiTL8NqUWo30DrDNTxUZ2EA1FGy6Sj8j2RYecXaufogUgB75+8szNy3i1Q9Li0w7hma38iFFV/WDbeyTvToMyxaxBiwFrUIsNnQYELD9WJv6kY2ikzFtJrrqdmdG7TmNPocYx/90Iy19TB61jImHMfMuS0xM9HO8Icij73i732G5JaisnzBVDGdguwdtH8jkB/eiIH5amE455a5u1EyC7wCDXj9voF85vt/TPEN7gGyQ3zBN9vomysy4GFih7fv+jLeCij8xsUCHsRsHDy3GhgNhxDO1gPRrJQVgMpXxtpWyTT3Vi29Y2CsZ5Edq/lUPDgp7GP7k8D9NSR4LU3ygTJMtIOQ8HUp8XzP7Of47pn9OOionlvrzkXZ8l45CAFkS73JAqQyGxOV1Cy4IQ2+nVs8J3VhPlb7LEfxnq/lJyjs4G8TYEysl5AdpvzyGWQxd6zJAo8nqrRPJatFc5A1TpGQxkxPwFnIq/zoUjx+iIO3FkZWlkvPLX3L/o0W2xqO1CD3bkTCf4Tx/WEKMJjqqL5HcU+ZgdVT6QUf4LgJa6Ig+kpVMytH62x7qeoM1+dkYH+YmT0eB1Yj1zaMiWL9hnFsZ8vxvoxZAB9KL7D2wzD2F/2tTOS/c/qiuwV33k52jD8xFrbklwGSR34mRkZch+KtdBvGO/PGoLcKGXFIeVuRlobHxZDEW0t8fd3R8pqZpQ4K+ZGYZHn+bmHBNz3gQvi+vkYt0zx7hbf9gOStPBmbMg5uBiC0GtBxtgngeNy72XO+gmREnxWW2NXxpacdT2RIeLu5NmMyIi7QQn4nAE4mjaUJmA3pFR9hyAQF8ydX7Mgx0LW13qk7x+JZIXs23emdVDBOMDZMY9Kke3WRh/2oaagXoyMoK/GWh4Se9Sj8e8vqCmGmQO59PN9BMbgEWQknyyu0/362BifDJZrjqL5HYl+GTp3d0Fwer/FehrpIu4Mw6AX+9/rqJBrP+Sc+Rc1nPbxkMzzEh0guzz61DPW9cMEzFs2b3Jzp2vu92ZHMLxf0061M6gZlhdDxuPPkBH8BARl0jf3rbZDxcoLy1aitTF2H+QI/h0FQVxLZFig4LDpUbDWwhQM31qHcegd++13BLR37gwbiyaJXkcO3v8B58X1uCgLbG/i/EYG4peA3YrmN+H7ahSQMmvufn9kC8jqg5xNG3BVBfC7L6oJNVsbz+ZATo1fkEPpcBpYHwPJa23pdavGOB6RW/vZGbEFkrGnL3p8c3xPg879FMK+J5I1z0Hn6RtEzY6CeU0dLX+jFojxc/DYP3me1ZcZB9l//keJg6dHoO8p2s21yGH2WqyFlZP3xkPwg7MjPae0sis1W8X2wMVtPF8aBdl8gwLsjiMQHRo975Cd5F9IP/gO2QJK7egq7LsWzUDVmruRQEgh4+TrhLEGYWtejqK5X0T1QOpqyG/nvs0Zm8hKcb06Mjwsl/R5S6QozF8Un6P7/eLnmbFx/19cz4AiY9+NPv8H1fgYaWV9NPmbCGVUPR/z6CqkXJYm8qQd+nglgraYIa4nQJEF98QB9ihtwIo0e0vm3uEoMuW7EBKfjLnWsLTVRGibCTkXBiX8nMUwlIFRFXCQYf/XmNfrEg7eeNaTGrRJZgzNssV+R/jpDcV3p7WiNEmsy8mSb7gnMiRdjRS+hZL350dGlSuLnnPtOB7jIqzl56jBWGxKDn4K1VN7Dbi2aJ6H05dhOrVj7g9Ehq8eyGgykBIUWkXR9i2EbNHG83EQRnQLUjp3JzE0MgwYn3biLcsS+zzO0LTeSBda1+6YgxLKRchgvxhyaH2GnDDrIWPUzEgOOgHVVnkZGQ9LFcHaDmPQFxkvHs6NS+Zw6oogGb6J/a9N532ZWsp/XHejFvn9CwoIWH9kzhgEOXYCuWLrSD84KtbCa8gQmJ5166Mo3HbJMi1Di3WRnQmDUfR06ojt2taeE3vG07RTNiW1s7k7kmneQYbCYxCCwSsIEqs/rYsBDwVZ3ODxy2SxfZBceGfMk6wg8D50YEgTkoyF+DbPoaz5KbPxYWiIodIZD/M8IQdTFqSzdpwpS8V1l/iul1AS4y+SH+4Cnkru/Zm9Ed/pzlhb39MGLE+D+e2KDM4/Bk9HkKAsJO+tigztv6KzbRcSWLw68TYxsi+cQ053D76vCX5OBeZMnvVFwb1vkavdWNAY5+twXU/NZpI628dD8HAZbFPhTkaGDghYAwV9ZjL0RiRw4AiN4yPgpKJ5b6f+3xnr9GKkp74Q58uN5AIgaJJAX5Spfn+cCZ1oLWd0Qjrqq8AtdeThz9rTSI5cBGXipsEDPVDQxAXIhvEasHr+/xjTW+EMVK3jtDhYz0VKSOaU6QGsgCIMByLBctKieR3B/kyFFO1d4vpd5GDKsK+7o+yfN5qlT8Po5+RIWTsw6dvlsZHPgZS2ljjMbqQNIa8BPE6KoJq+iEP0cKSsNKViRk3p7Iyceme08c50CHf52Rj7m+ggcGXJIf435PC7FEV7HB6H9UCU4trQjArkBHsJ1UtaHzkqv0fK4260U8FmhI/8z9gPByFFaila1yGZNNbehUhh2ZcCarAk36oTMsh/iqK/HkA1nnrFPp8ZTD5HkCLzIuPU43Gv9MbKkR0XpJTtjjCwf0DG64VRzZzuSJn8A1gifqc0EE60Vi47xfeaBjkEM4PQnMjYPhAZa38BTima9+BtImAbpJB8jyL5hqprhiLesojA/yJnd92jqRFM33/j774b8yStszIWTZBJggIEVkaRty0xzkMVlKYJa7iNYP9PjXm/eO6+Jc/3pwC5aCT6MJSBgZxjABm/NqfmTHgTmHEE/u9xkZEjqyO5URvvHBfnxjcIomw9VJfhExJnV0dpCF7rxBjHj1AmwIy5d9pc8+21F1BzyJyGDLSZ8XvCmM8Z5N7j8d1nKMG4ZWuqT+zpx1GDMtoTyRFzJPN3dkp0po5On4f17eMc+QFlIzadDBVn9J9wVPFzYRIoV6QH3A/cUzS/Od5PQbLuXLnvlGVvnIF04qWK5jWbP0iveDD24xdooyZPvLcHtbq/i9SZp8mRY/HsuNeDcDDG9fQoO7AF2R3Ojz3pJmTAPaLosc316YDgNcsqzfbavKN0KpThU5oAUobOzNwXyfe/xzfYC2U0PIXqH3Yvmud26PPsSPbYNLm3ADqj30F2peMpOewsNX1hISQ/XYXsYdsm73SmdcDXRIS+095nJbXzugdytv4e6+I52q4bMzEKbL8X2T3+RwmC+8rSCmegas3XkKF4cWQwHCpNF3lBnwD+HtedYlPYDbi5aP5Hop9jISPjR8jR9C0JJAUSKt8Bziya19Hs5+Kxga4d1zMiI/kmyTg8FpvnbXXiIXNQ9ESRGdshY/T8RNQGEuxmR+nhv8UhOlnR4zea/X4UGT5uSudd7p0FkMPiuEbx1cD+b40M+9PHdQ9kBD4mBKivQkCcuI48ZEJFP2RA3SF5Nh6wLEr/HYwiWFejnYTU2EP3QIapH5BQ2D/9/2lwNkwbPGbKxpHISPJEzMcPkGFn12wcUW2tLOoqaw8SNbg6YkPOtf7Uon++jDPjSQR3tFs6z8rSkj13HWQM+SG+16MxJ8eL50sgpe1UZEgtHFqI1saRmZAC+VzsGafRRoAEqtXwcfRxKEiP9uQpd38rFOH5I4q4Xbtsc2FE+oMwobeghgl9DQrYaMqgiBHtP4r4+wUZKObPPZsIwbuWypA4nL4chYxd6frJG2jORIEJdzGCBgrklFkOZVIPiT1/geT5ZOis/x+1uh8/oXO+cEdAHcd9EWRIzwqBb8CwIVDb3bGAsllfR4EBWbDVpXFvcmoOuB+RjD9le/MwivN0beREWjqup0Vn617UjPobxDxtOidFrs+ZfLUJyhLZGMmiUyXvrBJnyNlEFi5NEMWNnEktwGa5+xMiB/+3sVe8geCT+hfNc47PfwT/tyCY0zTDoDuSiW/J76FFtziXDkLOjR9RzbyhnEaxL+/RQL7Gjp/nIfl4Q1pnZWyIUAO+iXH/Cji16PFsox//h2rxfBjnWKozWm6eNIOsNwGqZ5YGYxxFHfXuBvQpH2xyOzBf7p1OCJ78CqSz/QkPWbaWnI1dkb3gJ2R//CO+2Z20rgP4Z8BXHXnKzq6zkXP37DjHnovzOwvs65v2A53n28T+v03RY1uWVjgDVWu+hoySLch7fh/ydu5CQJKhaJK348CdJPm9Vil1ZW25w7RvCIyDUYr/PAiG5v+Q4eoz6pzuW6c+pmmGfVCkT1ZY9CQUFZ0WFX8IRTa2+wafOzgvRYJ5JhgMQYaBfyTvjIOyrg4uehxHs9/zoMjpT5CyuW3ueRrl0JWSCf2j0e8symMylB30SBvv9EYZI1ciA877tFN2ynD4WiKEto3iOp2XkyJF+dGYl6OsxDC0obMLqld1BnI0vo3qW0xL67Tfhgv2yT4xfazFI+PbdI19/g1yUD3xfCEkmDUllOMwxiI9FyaM9ZtC/4yNnHe3UMsoXIOa46M0BpSEp+mRI+Z+lMGxDopcupvEqUEJo5BzYz9PrM2sKPXHKKOyLczy9erAS7pOjiAxMsT9cZGz9WvksLsAWLLoMRyZvmVjHnvVwUj2+RHVB2nqwIgRGIPlY18ehGD8VkaK/PmxL25aNI8j0IexUWDRIGTo2jx51pmacn0WMphl8uAIr/04J9dH2TCDURTnFLnnU6Czdqqix6SdxjV/nvfJ30e60fvofL805lPdz4PYF58gDOIomG4IkrsyOey/SMa+oaixy88FJPsNJAxoKFL+hXSfQQFbL1Oy2hKjOA49kBHrd2Roa0EZTI+hCPyd4/l3wI5F8zuSfbsYwVFtH+dH9s3njf3zIZRlUnitjWHwv018k7dRPdn5UE2c7SmJwwBFnq+DZLi/JffnQA72j5HscT4FOMDJZQIje9H7wddFwPK59xdA2SWlRR6hphNmWdBPkWTRUkDNjhHgeaLYW9ekjXp3SKe7P/pzQdH8jmZfs7m2NbLdfQ0sHPda2VOQfJ4Fh05dNO9/0a99kCMmg8pbFAXLfYGcM6fQgBotyfjOE/PlT/sgki/eQHaMZ5Et+BJaQ5mPxQhkYI9JrXAGqtZcjRo2+nex4I6PA/+jEFgGIyfNI/HeIZQEE/Yv+tVWqngWiTU9Uiy/RsrsL9G3+4n6Ms3UaK0oHgpMl3t+ZHzLLM1xpthQ/1UnfjLj4N7IwHMkcnotjQTMt5CTZvth9aNZGzJOHBrrpwUpJmlkaWc6iCOmjb6/H9/1MxSJ1pbxtB+Cvzq4zrxsGuM/AOH+thVh3xlFye1PHSKHQkBZglrq/sMovbcwTPdE6LoHGXamzT0/AhnfjkMFri9GGQq7IOiE7dP/p1kbNWNlr+hzFhn3FXKkzZ682y/6/j2wT9G8/0V/borvmsHA9I8zbjNqsByzFMHjCPQhOzd2R4a5uxE++mFI/vgeKQOrDm8M2pmn7WLtvoUwuTvlns9ODdrvP0WP4Wj0sydSBC9ERuZXkYGq8OypduxjCi/XJfp7LlJ8s4CRr4FziuZ1JPrUDzmJM/i552mtJPdDMBjXjeT/m0VCLoYibV9Lxuh75BwtvR4wCuOZytKrIqjfl5GDY0dkEM32qb7U4H/rNmeondldkMxyIDXn2hHxbaZP3r+NgGVu8NhlZ9B8yKjZP3k2C3Jc747grFqQwTnTyaaL/f6OoudAe30zZCScEunY6yLj+fUoYOsDWmce70jiRC1jS+bhLEhX/og2aoxR50Cr0exDNkeXQ3aNwXHe/R7/foLiM9iXR7CDaVb6SSRGWRRAejOKSH8PZTwXAqNF1ENFWRlnoDP0deR4nLutOVTmhoqW7xF9aEHZFoVmGub4y4zki1LL1vwB6S+X0UaGIXJC1g3GroF9t5hjnyJnxUO0DhDpSuugx1LuRTke10KIHSmKRhcUJHRd7E+fAntlY1Bn3p6JszgN4F4gxvszpGO+msy7zerJTzO3whmoWnM1FMmzJ4rceTd+LhUb3/QoRf8khCd4CbBW0TyPZP/+gbzN96JIwe0J4yvyBG+ODD5rkCvg3CyNmqC8f2yY/8g93zE2zwOQknl9bPJ1EzJQ+vd7qEBwWkejK4KwujV46hDF7clFz6BosUuQseezWEMdEpM/+jsWMljeHd/18Vh7QxVuJFeMsE78TI6UlMyQdBIyBAylbDEaWWIIvmhV5GxcCmXBzImilyePd6ZFsGhvIAXqTHL1Cxr0jbJ9IoNt2CG5lwn5h8azb1HUTgbNlDmtHy96rrXTWGSK+aWxRi9FTovLqRmLUqF5bFpDjpRCsUQGwX7x70lQ1PFR1JwvDyPDQ+aMnxBFt7Z7Vkk79acHCg45mdYG9CkRjNmv8X1uIDE815Gf8ZDxJsuSeoCAbs29tzYF1IOqQ38niL3qUeScLK2BcAT6khouMsP6Q7G2e8Wz3sAMwErIiT8zJc6QRg7kiZEBu09yfwrkPHyBGtzFrigYYAiwWrz3l98z2RvHQ1Az1wILogjnNWMsB6GI/xWbeY600ffM2bJHnIGfI2fw8zGuzwLr5n5nRuoEO0VrmfI8hjZw7o3OrxnjOgu2OqHAMczG6tzcmP4LGXV+AO5LxxzpLoOIiOdmbfyFXEDtXF4QZd9uHOP1ITn4nbK13FycHBUO/5halHo+WKEwGYnWTtOVkPPiMuQkyGDzugNLoiDUo5DTrGiIv25I7n4OwYnuTE2H2S/3blcCkQBlnz1Gg5xJyRmxNXIuLp08mxcFCHyP5IhdKGlmDDpLN0A2kg3T+YOM0CfEGdBCG7XUCuA3XYNvx96xPoKFz2TUIcBhRfNa53FYEQUetMT824sErYcmCSRCtoAbEfRrd2QbaeVQijX+EvBavecVsoO2AKvnnl8b+9Aiyb2tkRPwORIbX9WScSuagao1Z0MK3gnIiP4jioxOo4R70RoGoRQGqWH0JRPGVoi+/Ixg2X5EUTDPImzTps9UyB3QJ6N04aEiZRC29/ex2b5P1ImoI19TIkfE8XGdxzWfEzmFzi56DNtj7Nu6jntrIifF9yiqYN+i+a7jeHSK774ztaLoJ6Co0oYLSEi5mRPhoP4eAsU2SJkc7f0LOXKzCLZvUDZOVhjyRxTV8i6Kuns6BJfs/V0K/E67xXh8GOORGevHjXl6CXLGd4s9fwpkqJyHkipWI9n/TPicCxmIUrzoW5EzcapkTEpZBJNaavnayb3XgCPj3+shI9dSSZ+XQOn+mzea3+F9i+R64VhHWSZWV1pDy/0z1tqnyMHZEGMwgmPcNNbwEJRZMUUj/nZB32V6YKai+RgN/lO56CMki9wZa3tQ7Mkrt3UutcfZ0I79yOTtCZDM+nCcLd8jQ9EpwFzJ+/Mg40QGQ/wucPQo/u2jUVZD3gkwCYKuyM6y/9IBCrkme+T4yPF7JpHNGvdWQ0bon4H1G8zTHsjxslLu+YbxDc4CtkU1fwbQYJgWajrXjnGmvoQcuilM5sRIFvsCObtOR0Eh98f6bFpdoI3xmBtlp42fu99W1vg4sR+9RshiZW25s3ixOIMfpiYvlQoKFQXa/BBz7u04u79DMu4MyXulcCojp+v7tM5ynBTpU/eigJXOue8wMSpmvmUB/F6HMkgyHSLlax3kMPgMBULMW/T4Bl9ZoMa6KEgjy/ochM7UOZN3e6N6TzdSAjgmavLATjGuyybPPkHZC9dTO/s3LILPen+7+PfYKAjlaeQYeAxYs2geR6Ivk8Q5+XOc2dskz7rk1tKsBJoFdawjQ83J9SiBRIBQAFqQ4y+vr+0fz/5WL56auRXOQNWaqyEjaqq8LozqPHwTG/xxJBA79dwMRrMfqyBlNO3Li0hByQq3dkHKalZwe9Oi+W6P7xc/l0PKzrXpd6Km0PWhFgk6VQP46hnCzV25+ynO54NxAJTS4DkSfV0eGUbujgNqBlqnl4+DnBQfArcVzW8DxmNsVJfgtBA03kGK+jT5A71B/PRGWSEZNvB/Yx2McjozclY8G//feygibD0ESbYrqslwVqzJO5Gh/2UUYf8aBSqA8X2WCp6GIGPA4sjI/A6tM0FaOeCL+H51HId9UAbQnHG9THzP1agZmE5GAn/pIoBiX3kUOXr7xfl2LTI8zBPz8hxq0ds9UWHYLygRBENufk2DjKFn5Z5n0Da9g//jiUwV6mQEQoaPLrnrWRBMUFbXZi9KnFExpjdkpP4QWCKu+yFHzKMoOOeqWCulht9CRpafkAJ/NjIovoQio78H9k/e7YYiwydBGPPZHj5SZw4K4vmOyOwlVy8SQVq+E+ux8OjhdhzrnZHsOlQGHnJUPoV0iOnqzEceivhaapldluP3s9iTXqPBNUmSvbtLzNHDUQTzQHKR2jE3t0YQcF+izNtXEHJB0+6j1PStZZEeMCT6difKdEhhdf4sEk4NGnBn5GgdKvuywD5lMtCsKBihX+wraS3M5dF5fTdtZMMXzPdayDm4F1GrCMm516OApLupZZYVLtcivbEF2CK5l2VU3YcKs7cqLj+ye3o7j+/0yGl9Tlx3Sp/Hv7ugLO53yjA/kr2qOzrbbkMQixPEv7+Na8uNde8S8J6N+1goG+Z8amgvhyEH+LQoKPI+atnkOxTFcx3GYCg5DWXuHh1z7KtY17MWzesI9qc/0kNfim91IQl8Og22t8b8ORI5874DrkbQfTck8+9PmzGy6/xAk9TPbPj3LZqBqjVnyx/sKHrgvlhsL5MrUF6mFofrxyFkHYoi4KdAWIhbxzupAjMZMkJ+SRuF0JqthSA3ECllT5JAr1FgxBJSMlqQASFfq2IqFNHQlA4KagrYxkh5/w5Fin2PDKJ7hGCUOqBmoA61Sgrqf3Y490HwCwuRM2CgrLrFkVN0UOwjdS0WHcLqXEiJbBUBh4xTm1GLitp/FP9GaoDYJvaeD5DBpC1M7fT9HpQknRoZtzehFvXfEvtnl9x7hSur7dTffHTPpsCPyfWrSFnvE9c9kVPtHkoGZ5nMqdXju20Y1/MgAfrj2JPSFPM14v5pJeB/UWQY75O73xm4ABlSNsuPOzA1iqhetQ5jmf0chwR+jKFxqSdAQStZsebdix7PEelfG/dLFc3cjv1NDSkbIziIPrl3JkLR+R+g4KNTKYHRpa1+UHOi7px7PmXs3/fGPLyLyEigHQx1CI6zhQSiC52jmXN0EyRj9y96rNp53DeOfi8Y13lHVAbrUdd6k8n3XxM5OW7M3W9lMESy1ngFjFfGzxnIUTUP0skejvWVGQ1T5/a4SEebmuYPyMr63y3O1+dRYNZ66Az+DMmGq+T3oeT/WJ+SRhpTg6D7Pdb7f5CcuCyCyFs9+n01JYJlRnCND1FzxqTrZQ8k856Yf1Ygv3fGOO+Uuz8WCio4Jq47554X4ZSZLHh6A7g6uW/U5KhUZiqkvs1w+D849qYsWHcc5EDdjwimjH13gwJ5zMZxbFrXFxkv5soVcd0NyTCHJLzvEOt2C5pYf6NmZ5gW2ZNuRFlZyyP45XSOLYhgCX+n/PCP6V40Fso2PI1aLaB9kr435PvR2kb6d5T59iWy3VxJrvYtOsPPQRnoHVKXGO0xLZqBqjV3y21wfRFG8cux4T9Txo0uDqSlUbrvbyiSZH3kKd8gea8TrXHFC4UOaod+d4rWF0UrvhB9ehlYKv9eA/nKBImpUQptCzKK7ICMCDPG4TMQWKzocRyN/nWNdXEVMHPcOz76OxgZutchiVLtaA0VtP4t+vwFiqRI06g7IQPmFsBFdeIhW9NLIKNUC0oDfgxFDuWL/k0X62WuUfx73ZEDajdqhoWLQ5D6JOb2XLnfySIhSyUcIwVqcmRAeC3G7TCi/k1HaPG9h4q+RQL87yiKfg8UUTYvNUF4HuSkyWAXS/Xtkn7cgpzAWc2iDagVKv8fynI9HwnXT1ICqE5qkEonxjin+M+zxVz8JfbTRYjIXFSH4M9aA+35TagZ1g4J3i6mdf2zsZK5sRrCbl+2xPMiVbB6o4jh1VA2bSkzndu5/wcjmfC+YTzvRC3Kt2743KPZhz4o6vMoao7iPPzrbDFXW4BDRvHvDCWfIEPQo7Fv7EDrmk5dUVbDC5TICNtOY750jOXxufuZI+rvKJK67hBBSF5uQQ7qd0kCyCiBEYSaLDx98Lk7EcWMAh5aSOqVIXkj20PHib2/b9H9GM0xyM6NDPJ70bjugrJe7o2z7DMkdy5Gaz17bGQIPrXovgyjfzMip8u2SNZ4OvakwaiA+7fxnX+hYMi1mF+GZPTbgKfbmntxfR0KpuvWaD7b4LkzkoW+iLG9lNDhETzV9yRQWkU35Ih7lloWxlm0hif802nc1tlSgvE+EemH2V51OXIuTZm8dxNCDehRFJ/x83Qkxy+XPOtG6LVInvuSGsRUF+S8uJUCHPTt3f/490Oxl75ELYDwaoT00Cv3ewsWzfso9nc8FOxxc6ypV2hwrc/8WkX2q/8hR9ErtIb3XgbZfraN68LlkbK1whmoWvM3hk7XnCkOhW8pYQRPwucEITjeH8JiC8qEmaGNd6dBxtNziuZ7FPs6FH49wno8EwnJX4WQNE3yvJANE6WM/4AcMJnx/htGEdu86JYISnsjQ+gicd0LGeWPjHn4NVKkb6XJi5Xm+p8J2/+M/p2MIMCuRNES36BaRjMnv9OVOhiCc0LbByGwbYOMj6/H93gCwWSkRt9R5gX4d/TxNgIKJ+4vFsLLrwgucW+i4Ho8L63AghTCuZHhfkDM600ZRkRns7TY579DTokeuWedkSL2ZfT5QmoQEVOhqPlfCaWGEimW6Rkda69V0dfYi06NNfBZnAeHUZJUfqR8HBbj/j4y5E1PzVg3Hoq++h0ZI95D8sdA4JJsDNqBj33IpdsjR90xMS/+AA5o4/c2R3JGaWsqJWO5CbWswCyT9nFKgIlex76PH3twJgf+aShu491ulBCSMHhbM77Xqm08S8++rshY+ku2xvmLCMvh7WfJ3rIicgQMQsEWW8U63Q/Jz9cXPUZ1GvfTqTll01qaXRFMx8DsfnvsQ8Phozsq6psFmnwIrJI8b1VPooBxymThu5GcNW3yrCsKjnsqv/bQ+bVS7OtNLxsj3fNZBJ3TJ+5dFP3vgQI9PkX6zzfkjOvxHQsPlBjBvk6K6pYsDRyIZKu3gBMK4mdY+9sJcX4v09b7CHr0YxI9peiGbC1Xo8Cod1Bw188ktUeLWu/UAt8mSO6th2SLIUge2ojWqBCl1Hni238T/54/9tZ/Jn2cCQXcFFrXKuHtB6TbnkGSvR3vzB3v7BbXs6AstkeLHufR7HsmvxyEZP9N4noapNcPQPrBqahObSGOs5HoTyZTzQLsgnTtzeMbpxlQUyN7xSvx3Ru+hmjtuO6DAhZfpBZgsAGSB0sZyFSWVjgDVes4jaHry5RGcMnxmYeimQIV+3ooDqpr49BK63qsiZSqjYvmf0S/RfycDTla/ow8y2/YSIm+DRki30EOkbrBAiQH5zRIWb0CpdTuQRg6UCbB7ijC+WAEKdUUCsgw+twNRc/cSK3w6+nIuDh1XB+ElLAf6EA4rskYnIqw7CdM7i0dY/JNjMVB1DECMlkX/0IGojQz7BsEu/guMszdAqwxmn9vSxTFdhytsbRTB/Zm1LJN7kXZek0x11G05grUcNCfo0mjrJDRpw/K7Lw47vWkdY2ccVGWVwsyKpwe++VzKHpyl3ivNIolST2V+NkNwUK+Ts5BgHDfJ6YE+N3D6MuM6HzOCkmuR61mRWdgzthnbkcOs3WIbKfR/SYo86YFKRoHkzgokENrOeSwG4QMoRugTJNlY10/PTp/v87jmu2L/ZDyehPKIJwSRYK+QC2rszRzux37b0hW2im+7+/IuDVt0byNZD+Wijk6W/pdh/Gts3dHuJ5LrLGrgD2R3Lh43E8NBOOgGnm/xlpoSdZrqYuQj8a4Z4bRAXEunAtsiGTbz6k5hdvdOIoyVleN/Wch5JTpi+Tn92Lsb83tV4VlvKGsuxYUBPNn9nj8PCyeLZubq5Mj2ezFor91O43BjNGfzCg6JZI5t83WUpwlNzB0fbTSBHoEP2nd0YWQE3YulGk8zLOCBmeKJnwaqpe1BUkAEQqs+BHJcgvlfqcfykJ5swTjvTuwa+7e8iiDYzByKh2c61vd50wyVl1oDTf4KsqOTOuxHBr74jcoMG+Josc1eFuVNoItUJ2Y75GN4jESWGIkT2+CzrtCETyQDPNp8PJy8PwSCiTK7A6dkA4zJPryFnL8dgRHd2/k1D6GyNBFWYafInnnHGq10w6nZLCzST8yG9nMwevv8Z1aELTcQQztpJ+PWn3Thp/vDB2YPyOSAz+IfbUlWx9F8NcMrXAGqtbx2vCEsLI1YJb42R05YY5E0cHfouiCgxEMysvAf4rmdwT7lApG/0MGlS1oXfyrOwnGYwgV26FI2D+Q8tzutSuoKVgTIMPHQGQY/zg27E8YRv0hGizA16HvuwH/Tvr/OYoczaLsV4nxr2vx1wL6nc3HnYAb4t+toqKQU+KhmA+PU0eHBDIYPYTS0LNshlOQEXVcVLvnlbj+EVh+FP9OZ5T1dDqR+ZITWDrneDoERTf/irBtm0ZoiXHbDTizaF7aqT+ZgegmpLSsTmtH4uoowvXbmCNPAGslz0uxV6H6Kg8hI8NzSFn5kJqR9H5g7tzvlIL3v+jXsshxlhVaX4IEd5w6wYogg9PdKHjhPmRAS+fFpKimxH+RwvsNMkqXqgDzcPp3FlIA+8f1REge2JGaoXB5mhTmYQT63wtYADn1MkjJnWkSJ3Pw3gIcQA5yp413u6MMmZ1jPZ0D/OMv/v+94v8fhDLCvkByzPXIgLwZgpXqhYyY28V8WYAmh5qK/qey9ZSoDkuf5PmWcV58E+P0Ezr/e8Xz9qjVk/EwWXyPAcl+/kecS1siw9t0yLH4TTw7joJrsKDCxEeQZAMnz6aLMbsiudcFRQC35M+qZmlIPloO6WFTx71VCQclcnC+QzhS494FwEHJden0amqGw+lQlP3A2FOGIB1yRXKZd/nrBvKa/f1tkE78MjmIH+D/UKDKYBSRviaS9S5HRtFNCh7vsQg0i7jO16vaFgWU/RjfY80CeNwQZfuPjZxHAxFcUR4CbvoY1x8QUsIpFBiIRq0u0y0Ioj6fpXdqss/uQq3+2iZIZipFfVtgSSR/HopQC15BZ8S9KCOpCzo7jgEeRDrOOkXz3U59XwzpOf+M6/Fj3e4R/Z4COQjfBt4tmt8R6M/DCPJxzbheL5mDT8ReNk2RPLbBcz4wf3Fkh8z2rNLrl4WNXdEMVK05GzlvaDO1RDDbAHgi96w38qRfjiLWW2LzXpnE8FLmRk3gPRVFyK3dRt9PQ1F889LakDV5/N42dR77a5Dgu3Zcz4CimbNChecjg0FTzrHoU5bOPB+1iL8Mg3Y25ITKIuQ6o3TUV2iyqNzh9D8tXjpNCIf3UlNCu9A6a2Qi5PzcrM58TRyCaFagczzkBNmTWjT9WSiyaJRhFZCh6yMiingY7+RhZCZBxUX3LPr7jUJ/jSZyIg2jD11zP7dDxqxfUFbJkgxdv6QXifJWFoETRam+EmvuSuS4OBdBBh4Y/Xkn9ttzyRVhLFNra0yRcWI7ZBD+HsG/zMUwoKZG429n5+mi1LJEtojz6wsUGb8araNCp0EQO4eiaLYFih7DEejn2Agn/9pk774DQQhlhbY7IUfYgc281vPzCWUUpHJQH2RAvQkZ5x5F8kmp+4zk17eQ43Xy5H5bmTJ/R8awTMH/hr9wZCID5VvI4TMbMmDuh5yUDyLDz3exHu9HcuZRJDBezdqSfWACak6OAXE2XE3Ua0HBFQsgqJEUkqvdZNlYh5fGWF+EHKYbIci0P6g52+dC5/IqsbZbULRwu+6R7TzOpyOD/oJxPXvM5yuL5m1kv1H8zJz4LUk7kNbBORuiKPUl43pmZHC7uOh+jGBfH0Syxi6ooPbh0c+Vc/0sRDZKvsUSSF64mtYBidnzLuicPxM547Pv9QFweNHjHDxeD7yajietHR3jAyfF/vQ5ku0akrmBdPZdYszeiDl9GknGNTnYRISS8BpwXMHjOj41uNYBwffMJPU8kbz5KjLyv0QtkPR/lASONubwfnEObBLjfRCSVb9BwX5zJ++XztE7En3N5n+2fmdEDrWp4vrfyH43U/I7D6LzsqwoAFmflkEBneskzx5HWZPrxP70NbJVrlO275jf96nZvkrFZ5la4QxUrTkaMn7MgJSwNNOiqRYXrQ2geyOHxVAbMzLarhfCTwuwXdG8j0z/kEHot+hjFtmaOQiWoxbl+AEyRM9Ig4wNwdvXCDYqH+EzUwgMLeSw+pu1IcPdeSTFbJHz4QfkgJocOQefA+4umt927Hc2F49FikFW0PF+WteLGatRcy/5m3MQDlbkCPuYJOobQWecyCgqkCGAHIcM3pkxc1jY1QZMiOBN+hf93arW5vc5IebuR8iY0j/3TunOQYYRbUjrKO9FkPPxJ5Ttszclc4JTU7ZmQk7OsXLPJ0QGiD+QEWA72inLMDdW36GI9IyfnsgJ9DmKSj2FJsiCScc1/61jD3o6/r1izPlVkj73RxH4hxbN/2j2PTOuLxZnc2ZcOTdd2yiSdGNkpPmZEhuyE55XjLP2PVoX9v0zchE5DfZH0cs7I6PYZCP4/2dZMnvk7vdChs7PUWDFtSiLpoUkKKhZWzJ2NyFjyMkoy+G8rI9t7E3tupcm6/Co2HOGCtxAsvzVwdPrwLxxvx+S9Tcpeiz/oo9LBO9HorP36Njb+xbN2yj250XkUNobGUqzIIgDk3cWQUbgR5Hc+Cg6k6etxzxqp35l62HZ4HXd5NmTCAY7g0malhJkNyGn0c3A9MMbV5TRNA3SlddF2XDtjhgxin3YJubPtLn7+QyUuRAcdAsNRPdAjo2FqWUJPoYCmfI1GfP8Fj7HkfNiCuTA+AY5r3ejlg0zNoLF3Q3Blp2L5IPxi+Y9P4ax138CbBDXs6FA2F+Q3edIosYzJQkiG82+Z/vRnxDFSA55JdmHpgEeAA4rmt8R6M+BcXb0j+u1kby2eFxvQc2mcmkjx7it+Tac3ymdblzWVjgDVStvo2bA74+ia1uQgvU8UubSqODSLjpUJHHyNu4vGBtam4WLY0OfNQ62psiOSXg/HEVyzNvGszeRV30p5HAahATopRvxHVEB7B+IwoPI2JUKZr2R8ePcosexHfo6Vwg/q7TxbG0EUZUVEn6Hjpcds2T07RoUlXI9NfiMk2iNPd9QY1fC4wrxDdaN6xmR0+j20fz/TyMKQY7Au71iTWwW100vIDdbQ8URN0fwKHOmcyT+PRWqTdIS++UWbZ0rZWoMDRfSKf0Z/x4XWIOa8l7K+lUoa3IAMoiu0MbzOZCxpQU4uZ3+ZjZep8VePU86rvHvTNH9DmWP7FfmfRw5wOdJrjsn82QLFP25CpLzrqCW0dgTwU7+RBNnPNAaZudLZNi+jJph/VYSA0uM15y0IUuVscVZciitIbOy7I0e8XN/5IA6eiT+3zSYaX8Efbhhcm9+JEvuTs0o0osmclL+Vd9RtsNvJFm8CB7mvuwsQFmu7Z5tmPAwHTLMHECtIHwXcg5WBB/3CzJA9Sx6DEeyr/cgaKY1kbx4YNE8jST/qePsS5JC8ci4/3HMmbRO6VKoVlfmmNk87pdWtw7+do09dPa4zs6QRZJ3zkVZEEPB1DWAv2zdrBVzabW/ejf+nXeuFiqTJ+fWPLG3bz6M97rm9oE1gfkazOsEKHDjOhQk8zs6X+egNVz1wshoXphDA0GnbURre1Z25l8cZ9rTSEbOw5gVNieG9beTvWdSlBn/JUmGNnIyPkiDHXV16P+sCIrsWMKx1MY7+1GrVzYHcnYPpOSyXJzla5JAgCPd4ipqdZZni3NyMmryVl2dmsleuggwQ9Hj1NFa4QxUrfwNKebvo6iBrRGERQvyPG+Ue7d0hkQUqXcvwrLuk9wfJwS0neI6c0ClQlldsOgb0OdTkeMl79FeEhl+547rvtSKu57RAL46xbi/hTJCUliNLDW4GzJ4Xk9JopJGto9ZfxBc2ZOZQERrQ143JFxvjQphTl8073UYi+NRFtCUcd0dGftuQEL6F8DWBfM4A4pEeQ0ZIJ9Ajtr+o/n/bhbr6v/i2oa1PyLF5DVg06K/2ZjUkrW6LoqSzyAqnqENp0xc/wMpmQOR4262RvJcx7GYGti4aD6Gw9+0KFr6DRT9fy5haM69tyY1aLFRVlCoKR/Tx5zYndZwdasQ0AhxnRXW/RY57raihLAIKFK7BQVlDFVkHSl9WTH25ZP7myA58LKi+9BO43BH7PXzx/VisaY3z+QOkqzWZmsIRu+DZE97BBliPkIBEVeQc9SOxP/dD0XAf00tYvNuJNPNENelNiSP4pjugyBQ+sf1qghea7nkLDkdGdbbte5Q8q3uiXk7bXo/eS+VMbPMzqZwiiV9XD34/hr4oGi+RrEP/ag5KDPdMttX7kAOzR7p78S/Z6G10bqMOnXK73pIXs769kWsgaxv46H6VP+jQMcgqtH4HjXZYJjjGt/uIkqI0oD053cICD+GYaNA+sbsFFPguxPKRuiHMpuPQraWL5CRfFIU+HY98G3B43lz7DWrtvGsF4LlfCD2+RsQHGWPRvI4rO8bP3eItlGstYly6/MyctmycX9PQjdtlkbNKbkmylpuQcGU39NGFi5yrN1ALej1J9opWKud+pPJDIuTy1COdT5Z/HtKZKM4KXm+ApLHF2rw2M+DHPDvUAsIycsgpTuzmqEVzkDVytmSjWJrZGBYOXn2AcIyfIFaROEiRfA5Iv0ADkbRq9+iqPw/D1RU+O42Wisxk6M07DOA84vuwyj2+yIEHdGZHHQNgmNL8e77IWiDg+s8l8ZC0FwToeKDLcj4szCtFZC5Y7M/tehxHM1+H4cyfX6gNQ5ohzNU5PqdKZ8ToaiiobC/UQTVNshI1BLCVbsXm2UEDU3IyP4/5Ch8kGFEn43k354ORXk+Q2uItk4kzplYFzvFHjVj0d9vTGnJ+PdB0AR3ILiU1ZDydQK1QpC909+Jf+8Re2yhRZLbaxzK3Ggd8fl35Ez4IPaN/alDhCVDG0CnSZ71pQark4+k3TH2kVJG4iGFKoNaG0hSODqez45g7L5E2QD3IWXw1/h376L70A5jMB0yiO5NTRZ8EDlYMyjLSZCTfNGi+R3JvuUdyNsjXPUnkDPmOlTfqHdb74/E3+kW/+/LKEp1MIJvKXWdndEc202An5Prd2Iv6hXXvZHx+e72XCfJXvSP2Hd2GJF9G9VAaKHJatIhGMo3SQJamq2h6PQ2M06RvpUVOc4MXYVDNv1Ff1akdQBCp2jTIjn3zGifI2N8NmcXRxlB+xfM/6HAjyPx/gdtfbuCeL+E1llWZwFf597phoLL1kAOkHuQTtGQrKRkHk+JHNS9k2fjoICHK1EwwHvUarEsW/DYzoDgZrvF9WYkQVYxxydCATbvIJ3+KORoKqomUgoX2IJsWx8iee4BJKcdgRzbOyO55gqSgORma0mfuyF97T9IX/s/JG9nDsr+SHbrF9cTxjjthzJcSxXki3SJgTG3NiSpZZh77wkU3Dsr0oEuAz4qgN9nkK68SO6+Edk7VRvFsS2agaqVtyFj/l0oEjWrg7BvHPIzIIiCd5B3ugVYv2ieh9OXKVDK7BAk6O+BHBP7x0a3CRImn0de9BYS/M1ma0gJbyEpKE7AGrTx7uLI8FAX4TM5SE+PgzSDzzg6eHwTOAalla6F0vW/a9bNnZpDYheU6jwQ+JHW8B5GGxlZHaUhJ8OvSOB+mXA05OcgEmpPop0gKWjt5Bg3f394vxP/Hr+tNTIa/OxJzeG0AW1ECCKowLdoEA5s1f4c98xRfFWM/1zJs1NQoMHtyNjwC3A2uWwYakpo0xshy74PMXRgwboIFiOrS7VVe/WBtg2g6b51NsrUSZ00aVDHBPU6T9upf92jb5ciQ/rHwFrJ8/FjvzoFZf3cEuM7QnVGyt5QJOlnwBZxvT6KZl8q+farI7lopaL5HcU+pkE3Y6OM3XaBBU32zoVQtGQWXJMZtUq9l4xGv+dCBrk9UKDXj8iBmY3HAnGWHFGPcUC1C35HxrdtGIYjOuFnuji7NmtPPho01guTcxY3S0O682lIj/kM6Z4Lx7MNkKO7IZHN7dSfOeOcuC32yp655wdSqxlyITUH5UIoA+GzEvRho+BvrbgepsyG4I1eA3YuAd/LIbvFp8gWMzWCDMpq/m0R5/hLKPgvyxp4B/hXg3hMdag7UKbkUOcmMo6vQg21pGh0hHxkf4YWcm/srxMkz7rGfnokshF9TR2gKUeS/11jjxmMnHQboUCyC5DT6x0kp7YgO8RKbfW7GRo1Xes8lBmSwrDtjex4D8Z5NwDJrGtSfkd37/hu98R3uhs5L7vk3ts0vvM3Mf++IwJ9h7eXtROPmTyxTvzdlZJnMyBov/dir1+86DFt1lY4A1Urb0OZE48Bl8S1xSF0JLVC8QeH4HIyTQDvhYT8DD/zTgSplAkwL6Not92RYtVUdWNy/ZwMRfh8SC7CjNbFXfvEGHzDMDzzo8lHaiC/Cjle0siZxZLvkbVHSYxDZW60FkSHmv/IEfhvZPD6FaVoz5s879yMwtEIjMvEKIroUWqp3pMlz/PCRnsbLk6MubTdiP4dFDW8Rvy7PZ0yBwQvv8QaWC/W3fTx71eR0Nz0kefN0hIBc+74NlvT2oB5Tty/K/bHu5CQ/wk1+MGujeZ7TGnUlK/etHaUGa2zKcdHEYEfxPoaqlbXaPKRGkC3RY6M2WNP2yK/T5ArVFvGRmvHUm/k2LqfGqxV/+T52PGz9LLdSI7BOMhodAOScz9Ein6WNdITRVR/QBT0bcYW8zHb6+oiZyBj7Qsoi2rWev6tAsavB61lPEMG5x+QznAutQyrmWIO/UidMN2RY20pFCwwBCEVrDis9YnqFL5DG3AuzdDae/wK4H9OZBj8BWXFHIl06KOTd5qij0jXfwfpMueTwHnFujgAObV/RVHUt8VaeL29z+VR5H8m5Ey9l0TXze+PSD9eH+nESxTNd/C0CjJ2focgEy+M8/oHJJ98E2f3CUinaGimPTV5bV+UWbtp7vlQWToo06HoDJMpUBBoCkW7HbIFfQFcjWApU92gO7IjFR5wE+fB0sjBNQQFkC1FzT43H4Kp3wxlbje8hlM79TNbozPFvN8O2U6y+8fE/RtQsMTZsc9+RhNkWMb+OS3KZnoTZZGdlV/HKPPw5OjvMgXweVLs59PH9d9RDb1fUAbW56iURaGOymZthTNQtXK1/AEZG2CGCb0mihb+v+T5/iEcNFvRyI2o4Wt/FP0YCk+9GVts7oaMSS3I2Ls9MHUb725BRNrUcz4BiyLP/8lx3Y3WhqH5kNC5aLPNpeD/7yid9HJk7GnlaEEOvstCyPsMGXknLprvenzr5HrsEAZPQ4rDDyhj5E8FiDoYtZFCtUHMtxZkLFq2LT6T+TkDUiJ/qNPYLBCCS+Z0/AkJ0C2oSPkSRX+/MbGhDLb3gZmSe5Mjo8Kh1CI9p6LmWLu6aL5HoZ9NaSBF0JvvoEjAtN5YZ2rOgsPjOx5Qh7+fN4A+gpT1+xlOjYgyjzc148lM1GrJzYAU2Qwm6EJaG62azvmY6+dQ2bZIqf8FGbW/AeZJni2L5MKmgk1t9LyjBr+5WZzvl9HEgQWJPDAzijI+hwRuNJ51peaw/xhFpx+HDKWfUsu6qlvUKnKkboKcikNQoMecOdmmFzLQvk8dgq2qNtzvk5f/10DZnINRpPq/SPQcmscpM0nM/a9RINERJHXcQk46Czk9HkG1TIeq81Yg/zvFun2RYesEcwIPAw8VzW+O97FQluoTyOkxCAW8/Z1hwOY28jyIPemrmBPjx72JULDTa8hQW5pMvTi7Lke62Ka5Z+NQg3V9H2UKL1g0z8PpS984D16M8+AaRrMGahkbtRqN6dodHzl+j6EWCNEHOdq+j3nXLpnBdepTq6BeFCR4HHK+fgHsxXAcHA1e43vGvjMPtdICLwCrx/M1kIO4f9Hj2oytcAaqVs5Ga4zpDFppiViMWZrcVMgj/UjR/A6nH+lmNwOtsW37oIiOn5GR/KjYaEqFMTma/V8LRX/+gQzU+yOMzaWQofwr4I4687AoNWiy62gdbdK0UD/UDD4rIqi712O8eyTv9Mn9zjrIMP91tELxc+s0LoukAkQITGugSMGWGKeVG8DHNEgBezH+7o2Eczn3/bogY2QLdYanQRAOxyDM/SNRYb7SGm87ckNZhA/EmXYngYmLjFsvosKjeSfjQ0gh7lP270aTGHn+og/rIkfp1yjithXsH1Kq90RGoFEqUD6CfGQG0Mdjn3gImLPo8RlB3rNx6UkSBBDn8ZHUHFudEQztCUiR/RXYtWj+R7PvE1Jzei+SlzeQM+835Ew4MObbrkjRfI0mlQUpIEsrxm0gygJuur0nWSczoqztrxFUYZrR3Sv595Ko7twnyBFzFw2U55AjbApk3P8MGaUOp1YIeBFk1Nmn6LEdUxutYSw7IfSFj2J/vbHe8mY79uPPTLu4XjDm+/fIebELrTPgSwk3jXSRk6kFRZ2HggE7x1kxL6q/8Tk5eNoCeO2BECTOSGUNFDB0BNKjPkPZEfMnzwvRqREE6tfAanHdGcHAD4j99KEY93ULHtcsIPAoFJS7d/qM1vaJGZHD/Ufk/N6bRIcsU4s1OjnKZPss5vcRwBRF89ZO/RsHweG1oODXLYBxUbbeGwjKL5+xfgMKlJiQkutrOb57A8sgx9og5PRYi4IDK1B9qOfjGwxAzq6lkucbICfSkkXx2MytcAaqVr6GHC9DFVNE0TGPo6iw85AyMpASG5WpGV13jk1tjzbemQEZ4QYj/OftmmnzHka/U+F5NhTh8TOtocF+Q8rc1HXmpQe1ApctqEDh3G19p2ZsIdRdR0DrJHNuClQ3Zxmgb/J+bxT18AIdL0tmmfjGZ8U+MnbybJpYW0/HOw+TOK/akYc8xMg8yPD4RexXx9A6+vvvIbTdW/T4Va1xLebGzHE2vI0ie25GEWbrJO9l63kcBAnwNCWLAo89fiVgkrR/8fOgVGhuthbfad/YZzO4lBXi2TwoEveuBvExFcqU+hQZ8Q8nydwpc0MK7DUogOCgOP8XZ2hj2zjIUXw1tQzidt+nG9TnvRK543ckt85Ia0Pp8iiiO5WNLqLcEbGZUakTchyvjgrC/r1gvi4C7i56fEazD/fHnrJ8XKewuyfHOuqbvD8NyppJDXmNjFrtjGrbnI+MJG/FmXYt8GHR41m1oRwzkyJIne+RM+80knoIZW4MbfDcCGWMfoWMn+vQWuYvZcAdChDLal9lQWJfxL+fBzYqAY/HUgtEWTo//siRdDHKlvks9qbCaryhujtDkBOge/D2BXBkPJ8peG33TOaR4DHby6emZv/oG/fGip/dYz9dmsiOREGlDyIb0WVFz42/6GP+PHgb1R/pUzRv7dS/VZAjYDAKqBtIAk1OLYC8C5JH3qBJIbSQzXVDaoFgN9M6k7shdjNa21RmR/WVDiJx9iFnzRXAq0WPW7O2whmoWvkaSpu7H6UGZjUVsoNsReSlfgelYO9WNL/D6UemtE6NjCfnAtOmz3LvL40KU+1eNO91Go++SJncAmHk/q0BfzPdyGemBtv0PMI0nbytd8veaB1l8ykRXZ97dn309QskXPendfZMKaPI2mFszggh6SMUdTxH7vmcKAr7vDrzkc69HgiG5jKULfYpUiZ7otT0FhoY+dRMc72jtzjv5qEG79IS83bc3HtzIwPK0XFdiijwON+eRpGd0+aeTYQUkseyddgoIX40+tPm2kDRf+fH2v0UOWi+R4EGszWqbzSpwoscD98iQ8QfyGDbL3meh9nph+rm7Fo076PR56UQtM5TyHn2ITIeDgUDgZyaSxH42GVu1OTxfyV71o+xFm6mIIdxzKFeRfzt0eQ7k9nWjvWxVnIvM/AcGOP8faz9ZWhtaC/0TEfwiiugTPiBwWvhtTuqVpsftDaoL4QCPFooeTAQtaCURdp41g1F5X8SZ/LpwKJF8zy8fiTXGyO7wPXIobRjGfYvBAH5FXD48OZQ3FsNZSt9hTLili+I58xh/XvIRYMRVPp48TyDhT6uBON7fPDyt9z9cVDmWuao+wpB9PWJ5/vQBDVJgtf0PBiCMnyGCbPbTA3p83uhTLaW+EYL0LoWUP+Qjc4smt9R6F8qh3dCQUR7U6uVWZcSA8PiIa6HmS0ec+14JIOuGvdKrWeWsWVCfUUVAWBm5u5uZvOhTa4TSjF9M3mnF1LWPwd+d/chxXA7YmRmlyEj8Hru/mruWdbfLu4+2Mw6l70/o0JZP8vwt81sDSS4TY6cexciheSnIvgbVTKz8VDkwn+Ag939l2z+mNkycX9v5IjaDEV3nwBc1Wx9HREys07u3hL/nhKlq6+AjMXnA/e4+4fxvAcwxN3/aABff84/M+uHUus3Rxk8b6LIrTPdfcd681JRecnM+qJsqU2QQe5FlFl1M1IA/o3W8fhxVvw534skM7sTOduPcvdb23i+EsqQfMPdV0zuF3YmtEW5dToJNePob8Cj7v5+PJsPQUuNjxT//7j7nY3+HmaW1ZfZBRlnX0SFNr9rFA+jQmb2ETp7v0Yy3k3u/nzuna7IMFXqvowImdkqCCv+HpQJvSaK5H4FRfP+x91/K47DkaNExlgCGVuuQPvUJMiY9BLwT3f/rDAmm5TM7D5kVNje3T/P9hQzmwwFax2NsuQ2Rk7hi4Dz3f2jwpjOUcilGyNn635F81NRa8qfU2a2Jcpk+m+Z9U8zGxfV2voCRaTfmns+DXAIsBwyAK/p7o83ms+2qA0dtIu7D07/nZM/CtWXUcbLzUiv/Kot2SbXh14oan195JD5qs48tilrmdkUKFO7G5I374r73VEA3GnA4u7+ZD35Gx7F+J6DYODmT+73R5Dua6NsmHuQjvgP4CR336Px3I4+xbrdFAUcbl8wO+1KMd/2Q3P/XWRnuAFlYu2H6ihP6O6/FsZkO1Gsof7IybkRQvo4EGip515lZssiO87kKLjvJHf/NvfO3misr3L33evFS4enoj1CVStvQzixX6BMmCyzJO81LXWkNzLaPAZc08azzCHZnRLgMzZgLBryrZJx7YwitGek7Yykg5BBrQU4qexzqQ3++8f62LGNZ48jZ1MvFD2wCBLwWoDpiua9jmPShdbQHcsgp8cgBFu3OlHwscF85fetGRGe9yvxDZuyVkDV2r8hSJGNUK2YrPbQDigyabt4pxRQHAi24hfkKEqhdfKRoPOijLXdkcJ5PrB10fzneEzhRTM4kUHRXkEKVo/8+8l1IecHwrHejRJH4iVj2wkZI45BAQNZtuoOwDTJ+4vE+TVX0byPRp/TKMNNkaNiSwQZugHCIc9gIOYvy5oeif49gGpfTR3XSyBD6HLUsjo2B2YtmtdmaMjg8CpwWhvPjkIR1X3jeq4Y/xZKiJeOIumbaj6PaS1/fpW9obp5WyOo8haEojFzG+/9A7iyaH5HoD+WyEyl0T2BrVDw3j9G4N3OJFnR1DFLl9HICI8+vVWWeYGyuAYAU8V130Qe+hcy4mey3X1Ixm5aRIuOfh4gW2UGO/sQCp77mQZkkhTQ1wljD36ZpJ5mO/+NVH78EiEMPYWyg79EemTPeKdz6AtLE9mFo7NXjMmtcAaqVr5G6zT8FVEq8i1EvYtm29iRYe2BjPf8ZoGiSp6nxJjhI9jPfL8avilSM/xMipwsX6M0y5eBTdp4fwJkVNi+6PEbhb7OHALABnHdNXk2CUPDB+2FIFOmLJr3dhyDDNZjAlobwLrmrq9BKezfkEvDrxNfw4I9SnnqHELEfEWPY9WKb23MjZlQ7ZK3Yp2/UTSPbfC8AMog2bSNZ+MiI+2+CIe8BUFWDY5/9y+a/4TXbB+ZKfpzFbAyMD2CiXgBKcXnE7jFZRL6KbnCm51NyBkzR3J/hTibW5BBYg2kXN0IfFY036P7TZJ/j40yNn8H1o5706EM1veR8n4qiVOqzC3O2yeAY5N7b6Ggh0wpngw5GDYsmt9maCgw6xeixgGt4aXmQU6YP/UHBDn1AwXX7alaeRuJ0b+jtDij90aw5S2xr3Yrmq8cj9kanQNYspm+AQpU/ITQE4ejy3RCTrLbEfpHI3jrHLLZnsg2tHjcH7uNdzNn19IxV/5LAcF4w+jHPCELv4CcM1mNjovaePfMkBFKD2U6pjcUaPNafMsOVT8tJ88eihCK2j3YhtaB6t+hDOxp4t6ZMbZDQrZcpS3+qjZqrRMVjdFkZp3jZ7+AQAAJkRndibC3VwYOA/BIky07mVk2v58F5jez5d19sAuCYKx4pztSXCdEEARNRZF+C4DX4KK6p9eNJK+l25+Posz/E//+GbjIzJ43s0WT979x9+Xd/cxG89oO9AsSnFcHcPdBZtYpUsk/d/f3shdjvo2LHFRNsX5GhGIt9UcYxuuY2URxf5C7u5l1i1fPQpkyTyPDUb358uHdD0iCIe7+P3d/ut78VFR+SudMzI03EdTXJmj+rg+CiiiGwzbpc+BXYDszW8HM1jezg83sUVSo9m6U1j4eiiAbF2GOT+7uLxbE81CUnFX7oeyYw9z9Nnd/x92PQfLHTShia43c7xROLirdvm5mC5rZJHE2rYwiVWfJZCN3v8PdZ0cRbwshLP3/oHpbGxfF96hQ1icz6wNDreffXXAd5wJHmtlS7v4uWtfrAReg+gGrN5zxUaOfkJNpCvgTMqIfcIK7/xzvzB7vVHreiFFW3HsNMxs3ZJvOAO7+rLs/n+gPXZCD5mtUr6WiMZhSPczMxjKzbmbWI84Fz+ZRs5KJxgIIuehE4J+oXuTWwGdmtnmR/MXP3mY2eSIb3IZgRccuirdRoG4oY+NrGK4u04J00LmRfNcI2h3BxR6FoMavMbPPgcvN7FIz28jMFjezmWLed0GZqLshJIlvh/1fN47c/VlUU8/QPJ4eOZl2hZqMH3BffZD9ounsQ2MaufuVKFvmEGR/Kh0lNtfxQj5f1swmzPbXYVFiu+iD1vyn7v5aHVndA+1BZ7j7+2bWG+kERyM9bFrgZjO7z8zmHtY+VdGIU5kMCxUVQIkB/RpgsThcH4ufD6MIgiuRAniKmQ0E/uVNgC2eCGUnImPD5WZ2EnCOu38dz1ZEh/B/3P3jxnM5epRs0suj6IA5gTfN7EXgWk9q/9SbErztFYDFgR3c/eJ4tiryqPcAHjSzS4D93P2LRvHX3uTun5jZjcDOZrYzcLa7DwRa2sDYnRkZQh/2DoLtnvSxG4rYvQi4yczOA55x91+8ViPmd5SGv5rXoW5Mgqu/KormOHl471fCQ0UjQq7aEo+b2SuZobNMhnd3/ygw6I8BrkNRTV8huKlrkfPz1XhvXhQx+mIZ9yAz64mU31/d/fW41wVhJH8M/NPMxgf2NbMLE8NzRW1Q1JLYHNjSzA5DzphzUL22LHjDwmZ4spmdjwwuvVBG8b1F8T6yFP1oMbOJgdvN7E0kvw5BUKHfozPoQKTMHm1ma7lqfzxpZm8Dt7r7fQV1oU0ys0kRlG6rIAZ3H2hmNwNbm9k/UBbcKUjGwswmQE617ijbqXQ1o8pG7v6Hmd2OIGs2AU4OmaITiv4cksg8kyDd4fMw7lU0ZlMnYIiZrYeMVhMAn8R8usRrtT5KWyMmT4lMPWHoywMzQ3X053EzewNFUR8EnG9mBwOzuPuARvKa7GsbACua2cUIznVc4E5vohphKPOxBzIonxf7jw9j754boQ40yuH3Hsp2uQRBfU4ePCyBglrPRU6iTmb2AYJ5/Aa4opG2iBEhd3/KzOZCfRicycQx7zMZf27kuDmqyebQGEuu+ryHFc1HWxTyw5BwvtyCoHK7osC6i83sBqSvDdNG4u4/hjxflzrE4UgdG2WQP4cCaQGODz5Pd/fPTHX1tgBmQxlnz9WDnzGKvARpOlVrfKOW0pv9XAEVpz0R4bV/hCL5fwbeRoreIKTYTl40/6PQ35URLNkvKAL3ChQJ+m3c7140j6PQpwzncTVUB+MD4DwU5deChOSGp5IjQ+D11OoObYCiCBdHgtvnwV8LsFHR4ziafZ0TORp+Q2mksyTPMvi2yWJd/QpMUDTP7dDn2QjYoOReV1SH4MtYU0eiCNJsDLaN++2WYksbKbII5/Ti+HdpIYSqVo5GiWCvRqMPXYFZkbPlclSkPf9OZ1RH411gnqJ5Hk5fTkeKxhy0hgwaK34eGWddBR8xYvNipTiLs3o8h+TmROf8PkoCvdlsDWVRZZAKHwCPxr+fR46ZfVAB2BaEDT9Z0Tz/RX8uCl5XauPZeMjgNQTJtXNl8h5y0HwH7JV966L70gwNOYSzGhnn0Lo+Qwbl0QNFfA8CFqvGd8xu1HToqYA/Yt+5D+k53yLH8KrJ+9YsckecIe/EPjRx7n56Pj+NdM+dCuZ3KZTJMDDaNcAk6dgXPaYj0IeJkc3lbZIabsjp9+fcQbUCtwd+BGZrIH97xf64R+5+L+DqmPfHI2izL+PdtYse15HoXza+CyMb0UtF81S1ob5R6dfx8PhG0F9folo3K8f1b0g/2wVlnxTWR6QXHAQcF9cTo2yZPQl4QpRZ/gIlgr5u9lY4A1UrZ0NwB3MhGIfzgRtCwLm2aN6Gw3MqIHYPgaVfcm88ZDS/D3gDOZ3+TYKp3owtFICrgb/F9YbI+L9oCHCd03Gow99PiyOOhxTaK5Pnb6H05h5xvR3ypp9LyQ0iI9j/WZEjoAV4MATWOWMOzo4iIT4Hdiua19HoYyakLo3wdl8Gerfx3kQIi39gzMvLQqj9HriuTnMvXfdHoAiTwsesauVqzSrEj2Qfl4u9f6Hc/SmRYf6FonkcBt/Z/rJq7KPXZWdW8qxHrO9PiaKrVWtzLKciCTABZkROriwQ4nGSulnUAjtmAmYvmv/R6HdXZBT8HngRBYZshaJcDwp5403gM+TUuxuYumi+h9MfQ/V8jiOw98nVQwg5I4OE/Shkr/eRke6a9P8quj9lb4kMuyAyMGcQZgehjJh+yDBxSsg251VjW7WsISP0o8DccT1jrN33kHP0KprMeIWgnG6IPeUDwsGbe2dSVEh71aL5TXj6INbv9/ENFiTnNEX2gWnz98vQECzYr8ihtwvKksy/83/IjnFFg3hKz539UT3UDZN78yMndVrwuxdNVmML2UsWQ8bx54BFi+ZpTGy5+ZbJqGl966ZwarfRr14IPvrAXH9mjr22JfbTtUic4AXxmtWe7I/0rq3ieiyUHfM8HcCGV5ZWOANVa/AHH3ZRtp7D+Z2uCJaoJ02QSYJSxh9EqbIPIDiXWZPnE6FIuF5F89oOfV0lNsqV4nocZHA4PRGKFgXOBvrW4e/3Tv6dGc7+DiwV/14aKSNrJ4fqnshIXzcnUQPHP+vzJMDBtM7+GRA/PwV2LprX0ehjZqjoDLwUa2rp9FkbvzMTgjr8EDlvLgfGa0eeDgUWSa6zTJxlkfFx2vb6W1XrGC2Zxysjo9rNCNJpeiIDo9kbMuLeh6Jad0LZeQvEmf87sHzR/CX/XhpYoI13to01/H4I/TMhQ+iOCI7tlHivKRWyOo/vPMgYvzu1rKLJUMbE8nFGfRTn0iXZnoyUxHNQVnRTG5iRYeiekDteRgatXsnzWWPuNSyqeDT7k33HueO7PUDicAWmRvWtzkEK8mUoa3rceF46g2MZG60DOzohrPRfY8z/QHL14Lg+FuiT/72qjXmNmg6wLYInyz9fOGThL2PvPR3p1E2xzyK9f0NUj+Ub5KxcI3m+QpzL65SA107IWHgpcEDIPS3IcbEnMFPy7hLIMDpXUfwOpx+GAhez/eeRmF/Txvm2BcqgeYU66PUjwF+/mA9fU7Mh3Y0cGDPEddOeO0hmvoHQc6tWyDfI9tVVkP3gLlTPemmSLO5mO38RFNhNwK4Z/7TWi5ajFuB7TMG8Zg6ZyZBecReyna6Dgp7+U/R4dqSWGSgqGkPIzPZCDoohSGH1aI8iA/I9qFD5F+7+hpl19wQ7s6w41FFIfXAUrr0SGaT+g5wD8yLjzjWofsz38TvDw2ZtCoraMdcC/3D3J8zseCQ8L+nub8Q7/0YOkVW9HXFczWzC+NtXA5d6GxirZjYfco5t5O43mlk/FHG4sLvP1V68lIGiWNt4aKznQAbQt4C7XQWEm5KS2kAnoL5t4+535p71QgWGB6IaEJ/H84nROPzk7VSE28ymRqmyvZDxaW93/yqezRDPtnT3q3K/1wVFFOPuz7QHLxU1ByV46AuhKPI/ENTgLEixPQspmB9k50FZz7phUcavma2IzvhZUBp8D2QwOdfd/1UC/nohY8mewO3ALu7+QfJeL6SEbYvO7z+QctIZRY6t6K3rOVQUZGZZJtS97r6/mfUF/sjJcEsjuIENkDJ4YvzcCUVAn9VwxtuB8vUZzGxDBFE2IyosfDHKGhkQz0u9vvP8mdlEyNGyJXK8XYbqOX6U+72mqVNRNLU1B1Kdx8wmR+tkCuQUfg64392fGNbvVzRmkpltjAI8/oEcd2N5UgvAzNYB9gPedfe1iuFy1MnMpkFR22uizP/XkK1gMWQvmK1A9oaiRDdZHDlQ5wPuR2gNX6HasbO5+9QF8pjJRH/+RI6MrObQ1MAJKIioC9Klxo5fvxY4zd0fLYB1zKxb8DAtcCcKAtkcoWOUps7iqFK1txdHib42J3JOfI+y3uZEAa53Ape7++PJ75ReHzCzZVAg4JdID93B3QfFsz/nm5l1BXYGnnT3R+o9F5Px7gv0RcHST+be2QA4CdWKAunNy7j7x5XM2T5UOWTGMDKzNYGjqBVlmwwpd0ugg34+oigb2gCfRkbW89395YYzPJJkZm+hKMFD3P11M/sn6uurKBL6MeSUubZANtuNzKw/iojeFEX7/IDSiU93FSmdBAmj07j7Iu38t69FAvqbaHwvyAz1yTsToMiZKRCU1WzxO9u5+/ntyU+ZqKMJc+FIexxhSZ/gSdFOM5sfOA3tHV+hPeNC4LZ6CebhiFwbzSUHjnb3o+LZc0iQ2S4cgtMjbOklkfKwsbtfXg++Kio3mdl96Dw7CO1bM6H9clWE9X4a8KCriG3TUuz7myIH8WC0Hj/IhP+CeMqMDmcieeNGdz8w986MHgXMzWx6lMa/CJJN7gOecvcvKgVg+JSM9YMo0OYYBFf3QzzvgyLxNkR742BU/Hj9glhuN0rnRhRP3Qc598ZGSvAF7n53gSyOMkVQwYzAGqh+QA8k352UOBE6lOxRT0rWyZLISTkXqsvzJPBfrxV67tIRjIwVtR8lQYCLI6fdRCh6+1/ufnK80xkZ2AfG9bgA7v59Gc+w1KgZzv1+yEbwYBLIODfq55Io8Ox24Ex3f7EYrkeMzGxzFGE/MToTh6DgjkcK5GlclL35kZn1SPWq3HvzIjloLJQ980hRjpjgJ3N2LYQCA6ZBAa+bht2hOoMqGm0ys9uR3LaPuz9jZjMC/0LZ3h+hLKarmiXg1czmAA5BTvueyOlyQxbAGu80dO0ka7k3CuaaGyEifQEcBlzt7oPMrCey8UyH9qAH3P2dZnCENQtVDpkxkMxsb5SOv5e7n5Dc74UwuBdHRe8nQ8r6hMC67n5dAewOk9qIIFwT9WsXd78jhOEP0KZ9NPLuroNglJ5BWRsDG854O5OZXY4Mih8gIXPuRKjeCEFZbNOeRugY2yvQeH6MoncGo3op57v7S/FeJ5TSvjPazH9CG/w+7cVL2Sgf9VQ0P+1BoRD8B9gznUdmthqKsJ4CpbP+ghwlLyBl58s68tQLzftNkHL4HorSmhZFIhpSkgcjPOCHgcfc/eJ68VRR+ShZj+Mjx8Rj7n5M7p0VUcH4mVD9kguRwNlU6zciLK0tAbnI/SgR+hdBjpV9UMbOr2bWNQT+TdG4nwCc6u4fl4H3ZqWYC3ugPbEbqqFyDfCGu/8e70yK9u7fgY/d/buC2G13yjlmpkZwbWugoJUbgMvc/fnCGBwNirNvDuR03QjJtPu5+01F8tVMlESFLoDkVpAjZl7C6InWy22JQb10RvSKGk+JTNEd6V1dEaTdVMjQ9hCwu7s/F+93BSgyIOKvKBehfSySqydEAU8/o/PjgCSiu3P2q0U6K3N8z4Gg2Ieg4LDLU97Cob0DigJ/2N3vazzHNTKze4BlEIrEZyj6/y6UFfy0uw8suzM4shguRnvm+u7+WiWvVTSqlOgKY6Ngk+9RgHVq61sGOWZmRbaGG5A+Ufqz2czGQzCWewMLAbcCZ6Bgs58K4Cc7yy5DQVpXI2fMwggC/jlgf3e/t9G8jXHkJcBNq1pjGoxwUbY9aJKibLTGfd4WbSSzxfUeqCjeXHE9FcLAfQQJy4Xz3x7fE5gBuAMJza+jlPK50WH2LvC/Ov39sVFtmluRkHsHEiRfRIdNv+TdKVBk5+R0kHoNY1JDWSYtwG7JvdWQMvpJ/DvDut863t23TrxYbt1Pgwy8L8ff/QlhG++GnIFTFz1+VWtsS8+67BrYDDkVt23rPRR9uGPMoROL7sNo9j/DXy4VTj0yVN0FTJHjMzNsfYAM5h/GmTJu0Tw3e0NGtZNRZtjrKLNi2rLNjTr1vVPurFgcwfK2UHL862RtTI6MjPMgqKAUP30iBO93R/TpuqL5brYGPIuyyxeO65WoFQT/BtX8WKhIHqtWzob06Dep1cycHzg+ZOLBKMCx3Won1rkvWR3GveIMvhJFcu+DdLzBCPp76fT9olvC947IqdGCnDGfIbijtYvmcRh8Tx7yzluo1s3tqNbNoJB/vgJuRMgS2yIH/KxF853rQ6dEtv4BZcv0LpqvqjV/A/4d+sIRyb2xcu9sFef0mUXzO5J96xSy266x1n8KGb0/MHYB/EyCIMhS+85kqDbh47GnXg1MV/TYdeRWOANVK+jDN3FRNmTYXx/olrs/GbBF/LtrbCSXAuPEvZlQlPzMRfdhFPo8XOMJcsqcgmrntITw/CtwJoIra29+MmPBoiGkXxljvgbCFv4ZKbn/JDEgNHNr6xvQZAXlRqPvY6EolO9CQdgFGSuGACvk3p0FOUIPrud3CEWgS3J/nhBqXo65fzzQPe1D0eNYtWIagmZqifYyMHvueeqY6ZcJxWVa38meOxYwQdH8jAL//UP52JecwwhlcX6JsihXRI6zP1AB835F8dyRGjLo/CfWwL3IiT5R0Xw1qO+dc9c7oDp7hfM2PH5RBOh7yd71OoLdmS/3/tQoAGH1uC7NvlXGluw7yyPj+erJs5eRYbE/ypj5HdXY/HdHkWWrNlpzp3Py7zUQzEu35J6hSOMrUMb4V5ks3JYOUaaGsnu+RGgS4yf3J0WO/E+Bl8pyJidyRL+Q+S9HunCPkB0GI130FmDO9BuVgPduKGj0C2C9rD8IpnVzVGOvJfanAbEPfYF0/NI5PZBxeWCsh+r8qdooNxRk0oKckx8TwRLxzEh0eVRkfpyieR5GPzI5oxfSbf6Jgmp6Rz8s1vvJwI+x925bAJ9dkA1vjdz9TrGf7kXNtrhV0ePaUVsnKhojyQUltBaqqXJ6pCgvjTaG9+Odsqb/nYgMOCcEBAoA7v4pEshAEbe/AxO6+y9xb2ZkLJ6igbyOMgXkSD4lu8016+5vu/su6JsuHT8XBnZ09/frxaO7P4yyEBYALnH3G1GU2BnA39C3utBUSLgpKRnzLmY2jZmtaGZLAfgYgp3pguw4AdUK2gopbB8Am7jgAS15fRJkTP25Tuxk32MF4OyoJ4O7P4sUnAOQs3kn4AMz2z3pQ0UdnMxsv4CvJJmXdyIovbtQHasjzGzpgP4h3V/d/UsPSKcyre+El/2Ao8xswfw7uXVYNhqCsjXedkESpIVsfwaOdPen3f125EA7DTn8yyqHNBW5+0vuvhIyIk6CZKVzTIXLOzR5Dbqsc1yf4e73F8vVsCmRvU9HhsbdkJHiSxSVf6GZ7W4qtI27f4DqBt4U16XZt8pI2X6Pgrv+QE4vzGwThJGe1cTYFekRMyAjaGkhpypqDCV7ycVIFh4f6QadAtLO3f0u5MDYHtU6WD1+19v+X0tDs6GAj7fd/dsEau0zdz8TGeb+hmASC6dknzsIZZqc4O5vA+MiOKATEOzgysB9ZnaRmU1Yhu/g7n+4IONPBS42s52RofkNd78Q+Bw5lP6N9OtNkZPpPC8A2uivyFU36QpUE6c6fyoaZXL3W9GcfxAFWp9tZtua2SSxvw40s84Bd/wjkpFKRdlZYGYzoMDwxxCizAsoMGqR6MsbKEhtRZRt2dC+mNk6KLh2cYSEgpl1yaDjYj89DQXBX4CC9iuqBxXtEapaMY1aZMlCCNaqBaXNdov7hUeQDIf36dDG8C2K1jkYmKmN905EG82xCG/yJeDZovkfyb52RUXA5sndz0PypLAcY9OAiAFqUZydUUTPl8BhyfNZYk59hw6ZpYoez9Hs7yHICfE7igR6BVilaL4aPAadEIzBQkDf5H6X+NkHFZD+iTpEcSVzbnIUOXMbke1A68jFcYEtUL2KFmCzoseuavVvyMD2M4py7pV71hWYEhnZPkYQCyeiSOhSZ08l62ut2E9PYxjR2pQ3s3Wu2Df3iutOuef5LIZDkPA/fdG8l7GNjowWMsJBwEtF96MO49JpeGNTZtk2x+eECLJjvdz9FahFK96NCoo3BSxS2RqKWj0kuX4SGRX7xvWMyCg0ZbIHV9HfY3hDDu2nEVzO78BOybPOtNbHpgemjH93aSSfo9CvaZCD8oTc/a7x05AOdEbRvCa8jY8cFScBPeLeTahObHZ9Ccou/JlcRn+BfGc2mD6oBsvb1GAT+6LA2OtI9Kyyt5j7vYrmo2rN2xgaZnZ95JxsiXW9araum6GhEgmvoTrKcyDkjhYUYJPaLDoVsXaQc/0ZZLN5l9bZSHmdLNtPm0KGbrZWZciMoeQRweDuj6GaIy8heITpiuTrryi8tu+6+xaI728RfNJZZrZ1FG7O6AIkNG+EcHB/RI6DZqLNkTPpPDPb1cymBEVapdHQ3joiZUXgIjPr356MmNlEZraema1uZhMDLWbW3d2HuCJ69gV2N7Mjzaynu7/u7usDGwN3ecEFFEeFsohaM1sZZV48giKMN0MQeDeb2T1R9L5DU0R8tLj7f939MXf/IZuDXis6uRZKyz3c6xDF5bXI4VMRFMQh7v5y9sxEndz9e3e/AOFK7+zuF7U3LxWVj9z9LTQH93P3n81sATP7t5mN7+6D3P0j4Czg/1DU0jYIim9bMyvt2ZesrxORUnKCuw+K+T6Tme1iZntExFhZM0reR46yzSJKtQVqGYjZ+o17kyB55Cd3f6cohstMnmlGZvua2SLDyp7NKM24RYrWv1E2a1NSKv+YWVcz62VmPeKM8qTodCvKxq3s5O5fIyiJXgBm1j2yyu5w9+lRtPoCKNNpneI4bWp6FhlyMbMJkaEEd/8hnk+LdKKZsz3Yq+jvMZ7c/XNU9P7fKGv8FDO7ysymCn2oxVRAHnd/J+SO9BwvDeXOjY+RfLFd6HpZBnGWGTYNCmQZp6FMDp8GoAy3Ae4+wMxmQZBxZyTvfIKCM9d09zsK4HEoSmwwPyJj7YfArWb2dxQ0ND7KevwBFLVeDKcjTjH364WMUNEYQCG/tSTXV7n7JMCRyIlxCXC0mS1eFI9/RYmsvTxywhzk7qe6+0vAksDNwOOh88xiZvNGvxu+dtz9clT390TkcH/IzE41s3F96MzyAfGzKWTopqOiPUJVK7bRhEXZGDqydmsU/fIVKjy1Cq1rSyyB6ks0He5+8L8KtYjIu4D1gD65b5hF20yHIvq+rgMfj1DDMf8N1ei5DDgaWAxYBHn/HwWWLXrc2rnvz6HU92nieqMYg5OQID0wxmGKonlth76OPwq/0x055D4Cbqozf9OjbKxDGbrIX4bZOjYV3vsY35BTfgDwX+CfuWfjxL51U+xrxxXN71/0ZW2EIb5ccm8zVLx2SPThKUpceBFBuLTEXjontKrdk0XhdkZO79+AdbN7RfNexoYi939AGagnMAL14pAR/xFgg6L5H82+Z9mSGwL3IOP6HeQwuJtp7iR9Ghcp8gcA/06eG63rVfQGLgQmzZ4X3YdmbsC1Ic+tF+1uBN9UOG9VK0ejdfR2Z2rQWN+ErHEIufqmZW20rrGY6ZDzxRr4NvoyX8j3Y8X1YGDRonlvoy9ZBtuaIRMtmvURwTzeTAEFs0d0PiHn70NI1/wdOIxEz69a1Tp6Q/arjVCNv+XaeD5ZnNEtwJVF8zsC/dkT2e5mjeutY22nWShno4D4CQvmtSdCPzk/9ImvgR2KHsMxqRXOQNXK02iiomx5/mIzORgZrD5ABe4XLoK3OvZxH2SkGhCb5hI55aAryhZqAdZqZ14mR2mXLcCLcWCehVKqX0fFK58N/loQ7ENWuKzUc2kE+r549H3j5N6HqI7ReCgDKCu6+zMld2iOQH+/Q9jYqbF0uN8QOUkeRQ6qaevM3zQIKmKHYfEW6+DqooWcqjW+MTR03d4It/cj5AhYPHneCZgAZXVNld0rug/D6Ne6sb/+X1xvE/vQ/1C23s6oCOaqRfM6nD50As6NvfIBZPScKvfOSgg66OGi+S17Q4WBFw555+eY4zsA4+bHPX72QEXhW8gVhm+mlvRnJiSzvgHcGrLJ5wiCIS3UXno5JOnTeMD9iUzRgqK9Z07e7cLQwQil7l/RjZqzqyeCT/wbqpmRGqWXiD11ADI8vwssk4150X2oWjkbgp1aKeSLQQh+aoui+WqDz2yPmRk4MOb3lcBsufcmD/l5MNKp30ABjz8BZxXdj2H0LVvf8wXfJ8b1Cqi+zCVF8zgCfVgGOZP+IJFTq1a1jtqoOVJXo2Zj+gY5BR4kB9cf7y5JG2UKytBobTfZBDlgskDRrxC6R/e4ngC4CAVady+A14mRI3iq5F4/pJfdmchAixU9rmNCyyZJRRUBYGYXoWi7/yual7YoKzQVxQanApZChohXok0GHIFwJt9F3vQbXYWpmpLMrItHqruZ9QVORk6AT9Fmfp27v2xmsyFn2jfuvmg789AdwZusgIz1X6Foqcfd/UMzmx2YHSm7CyCIsuvbk4eiyMyWRA6w9d39KTPbBmXD/MPdn4l3HkdGlIfd/c7iuB09MrPdUFTuau7+yEj+blcUGfhLO/JjnjukAlrkWRRVspHXUvqzvaE7gvlbHFjJ3b9rL34qag6KObAZcK67Dw4Yix0RVFkLcDvCQX8n3u/kJYeiieKQd6LssM9RFsklwDHu/oaZzYz6dbq7n1Qcp21Tsj7HQs6jXZHx+XHk1H8bGVNWJ6DN3P31gEosKwxbKcjMxgX+DmyLIEufQo6Xe939j+S9f6BgidvdfbMieG1PMrNLUVTldu7+kplNi+bP2tTqfxzsgoooNWVnnZldjgxz5yM4pL1QPb5XETzZpdmZFhCFVaH5kSAzuxYZz8dGzpfbgNvc/b/JO1sgp8wL7v56IYxWVBpK1mZ/pAPNgbIMXwBezGReM5scrd2dUd2YCQpieShK+mAoE2N6JEdMjIL5lvKA/01+Z1EU1T1pvHs18D93/62hzLfmKetHJ8T7FMDzQEvIeuMg+J21kXOsO3Iqzec1KMLSkpkti4IdXwJ2c/cPmkE+raiikaXcWv4UOWQOQefyiUjHAcmsO7v794Uw+hdkZkuhTNqP4zqD050a6TcXI6f9KsAi7v5+vLc46tsp7n5cvdd5pkuZ2fQocGsbpA//irLMD3T3D+PdGRD0476oRtqN9eKroqCiPUJVK1ejpEXZqEX2ZD+PQkJWFkE4AHmZl43nywAPIw/vZUXz3w79N1rDsM0FPBZ9fxIZt06P69nryMf4yOBze/ytx4CV23jvzyKQRY9dO/V76fjZCRlFHgYminuTIwWnqdM7o2+XIQEiK0K6MTqQhxu9QR1gYRDMwK7AOG3weVLMv93JQawhCIm3gNOKHtOqNabFuTUTkRmAoj4/B2bIvbcMcCPCSn8y5vY4jeZ3RPsUP5dCkCjdgU1RFkBW+6B3vNMFQXX8ACxfNO8j0LeeCC7uBKSItcRZ/XHcmzHe6xDnRwPHdXJUd+45BGN3FTB3PJsI1U36nSaGQqF1BtzWwKltvDMXcBzwJpITz6HEGQ7ZPI918RiwE0kGDIL6ewfVQbwj1nq1NkZ8fDO9YeeY/6cDy8Y58S1yCB+drZWqVS1ryTk8OwoaGICM5UNQ4MBhwLy535mLyDopy76TrIGT4pxdE2VYLh1ywxqxJrZCMJBTJ7/b8Ojtv/gWE0Y/vqAGr3MmofuiyPNdUTT6/rQRZV8Q/3+5Z8c3OTBkolJmI1Wtau3RErnnAFQHKoMZ7IJQMM5HkF4tCIXl4KJ5bqMP8wd/1yLbWK/kWVcUQD0wW89E6QRgQaSLfpofjwbw/AjKxDsP1UG7JWTLP4DdU34IXaxqDfguRTNQtar9VQPGi5/Z5r1wbG6XACujyNAjYzP5Gdgl+d19CIiXjtBI6sXE9fqxsWaOqTMbxEfe8JPVBOhQdTtoGw7rVJRSm83H1RHM1zpF89sO/T045tFaKPpsUNxrKPYyMj7fF7xMG/dSh2QXFK2XZTusgwy8a6JouS+AnkWPZ9UaNl/mCiHzemADZNzfkVo6fNfk3c7AFih6fjCwQtH8/0XfnkDR8dPFdS+gbyq8o6zEh4HHiuZ3JPtmobQsggxeUxXNU7O32BtnQ1mCn4ai9W8UEfc7sG/RPLZTP2+Mvf7GuO5EayeGIQPjrcBFRfM7gn2aH8HAZnCcPZJn4yFn5edxLu9XNL/N1GI+XB3yW5/k/nwhQ3yPYFd3oQPUAqxa+7Y4hx9HWdeEzJnpXc+HvDFDkTwOh/dMV5k2+N2bCERBtWHuQs6mQdRgp18KOakrJXH+Jv24GfgEGWvXQ4EHLQgZI9UTyuJISmERR2gsUbBZC7B50fxXrWr1aghG97ZYy5mt7zRUemASBH1/LbUA7K2L5rmNPuwX8sP3KLNnwdw+tBeyTf6CkFRuC7n8LWDFeKeujntqDvl/Bh9rJM96x955b5wB29aTl6oN4xsVzUDVqja8BmwZm/BuyYZyCspImCb37iQoenAIgjIqnP86jkvn3PW/4zBomBGa1oafz+KAORyYrOjxacc+DiVII5zxH1H07X+Qc+bJonltp/72AG6INfRhKD1zFcTLeNSiu2dE0TJ/Iwqmoii5PeM7pHj7DxBKc9XGjIYy9/ZCNTR+i7m7RO6dfJZhP2CbonkfRn+yvWaSEJJ3YhiGEWAeBFH1LtC/aN6rVo6Gsi0WAS4I2aAF+LBovtqpb/Mj6L5PUDBEWi+mM60dsH0aKReNRp9WjW/0JXBscr9rrj/9EXRh/7guhbG0rI3W9YYuJqLOUSR6Gty0Dqo9NABlzlQ1ecbwlpzDy8W6XDN59gxyBKwEvB/70HUou6TdM8bbqR//CVlhwux+yEE/ISfHmgjK7EgUrPI2da4JORJ9yNbxoiiwYLPk2X0hJ00W15OQOLML5rsfQlVYIbePtxXsl32nvvH+edU+VLWO3EJOvQ64IK7HR/aVPbM1jIIknqNk9TFpHRTXI9ZrC0Iw2Av4W/J8OuR0egYFfpxBHdFshsPzOcgRNEVcp3vSrMgR/zbhHKta41onKqqo3PQmErSOBV6Neh4PAd95DYexc2Ajfo7Srd8GtklwHDsceWDqm1mXuD4ImMTdf20gD4Pd/VUUtbkOOlR3Bp43szUbxUd7UjaeZja3mR0LXGVml5lZf48TC0Xib4fgCmZBMF//LIThdqRYL78hmLITETbzRMBWZjZ1o9eTu3/n7s/F5TwoI+tOYBczm8Tdv0bO2aVQqvDOKCJ6ZXf/TyN5rahYcvdv3f044HhkaJsYuNDMtjWzfvGOuzDGuwaG7gB3PwdU36Qw5tsg9z+x3hdFRpNf3X1Qcj+lCZECs6+7v9hoXisqJ7n7r646YPugekp3o4jnpqR03rv7U2jPvxVlxlxrZueY2bTuPsTdB8U67+LuPzZSLhoN+goFFLUAe5rZKWY2fqz7QWbWLTDGX3T35d39xbZqrFXUmlx1q2ZERpBZkYMLd//DazWtcPdrUWTrqajGUkvZzoWKGkvJ2poXRWi/DWBmG6KMzjND1jwUZZqsCSzjJat5FnLDIsjI/xMyDmb9OxgFle3n7je4+zvuvj+wbry3ZUFstyKv1VZYEjnAngYwszVQdvyxKHsQBCN3r5n1aTSfbdD/oazt84AjzGxuqPUnd65l821NBFN5ule1YyrqwBRy6too6Bq01/4GvOnuA+J8drS2HyqIzTYp08fMbGx3H+DuWwGbIMSGfwEnmtk/zWxid3/X3bdF58PC7r6DR82uBttWvkH1t7+NPgwKG2ond38N2fOmQ46xihpI5pUsX1HJycx6IgFlF7TRfY0iZNYEns2EmKRA2IWoVsAS7v5eQWy3G2Wb9bAU73huRQtuZjYBisjdF2F93l0kPyNLqXHDzN5AUVYfowjbyRAc0oHu/la8MzYSFAaXTQEbXTKzGxEs3ctonQ1AmPyXuvu3DeIhK0DX091/NbPZ0B6wCcJ8PxIZTprB2FZRA8jMVkSGkveAjZDR9lHgGOAhd/85Cu/eDNzt7gcUxetfURSWPi8unwP+6cMoMP1XZ0QRNCxjcVWgtvEU82PiCFppSsrmjZmtD/zH3X+O+8siuKCFUS2E84GTvcDC06NDZrYBsC0KQngLGeUuSJ53c/c/iuKv2Sib+2jPny9uHweck+kH4Xjp7O6DCmGyolKQmfUA+rr7Z8m9Tih7bQl33yXuPYdgRHdy9x9CNj0RBWb95O6/l+2cM7OZUVT2PAjR4EpUR+9O5HS50t0HmlnXMNJNjepZ3YAKapdCtjCzbYEj3H38uH4PBclt7+6/hBPmJJSZsl52ThRJZjYTqlu1NJo3FyKozayAtqFMmCFm9jeUUdPb3actiueKKmokJfa7OYAXgCPd/UAzWxAF2g1w92ULZbINSuTSrgiKrAuyTw5AAXXjI0j/q4BH3P2n9PfqzNM6wCvhaMmeLQ38F8nJh7n7J7nf3QKdZSu7e6kcYB2dquifikpP4UG/FBnXDka46FOgQmBTwp8bkJvZuMhI3hlFNDU1Zf0anjAcjwsX/N39G3e/GVil2ZwxUDNmmtkuCFNzQwQPsgrCXJ4PZf8caWa93f33iLLsMM6YJFLjBGAbFF29DsLOPg6428xWC2dUXSkZ15fMbFPkhNkVRfl9jQScK81soVCkKxoDKYtijiil29396Ih23gYZGnojY9xpYezcD5gbuCh+r6yZlLegjIbHEL+HmNkiZtY9eyGis7r81RlRBCX76cxm1i8c9pThrBrTKKZH0zpj4M9Mh0mAc4FzIusBd78H1TzbF50L+wL3mdlmhTE7GuTuV6IgiKNQ1P2JZna3KTucyhkz4pQZedz9c3dfABlEX0dwIueY2YZm1tfdW8II3bVYjisqmC4E7gijOPDneXU3cDSAmU2BbCffu/sP8drUwMyohszvye+Vhtz9DXdfGslEv6N98joEdXq/uw+MVzO+J0DQxd+XTLZ4BehpZluZ2SHAuCg7ZkA8nxVlzDxTEmdMZ3d/093/geqN9kD61blmtp6Z9Yk9akjoMWsAcyCkgooq6lCUZp2aWW8zmyHujRW3X0aO433M7CMEszgLCsYsMx2JIPzPdveVUG2raVAw4LrIIbuXmS0YckndzoeQlSdCdbYfNLM9zGzCePwE2ve3BA4LnTJzbs+K7CtfVs6YxlOVIVNRU1EYz/qjArXrIcHyGFQ34jdkRN8MOMndjy2IzVGiXIZGf4RNPBWqi3AZ8ElHMv6XidJoBTPbDmFGb+zuP8a9bijy/p8IOusr4Hh3P6sglhtKZjYVsDiKRJ4XFdk72d2fqPPfXQdhnm7v7lcl98dDjrJ9gUkRNvwZ7v5mPfmpqFyURAL1RDAVXVEWWxaF1BVhoq+N4CwnQ6nap7j74VkWVkHs/yUF/1OhbJ+dgIHAmWj9vevugwtkr01KMtuWQOf0P1DU2DOooOXZ7v5lcRxW1KxkZuMA+6N5dQOKUP81eT4ZsHU8f8ndlyqE0ZEgE0zqoghq0YBX3f2jeDYHgkddDu1dJ7j7fkXx2iyUk6W7ey5bysx2R3UXO6PAjstQBmXp9tOKGkdmtj0qpr6Eu39iZtMCX7j7gOQdQ1m3YyGjVl+0Rud392kaz/WIUSrrxJ6zB5Ip+iKH07lZIF3IU/ujsZgkcTwVTsH7FQiquDeK9N7Nld0zIwqeWwvxXViWpJn1QoE006HMzds8MvDMbC8Ec2do/7nc3e8zs/mBG4En3H2tQhivqKI6US6bZF9kw5sCBU//B7jG3Z+M7Ly1kM3lR+Amd7+/ILb/kmKtP4qc2+u5+x8RKDc4nq+CZIxOaC9YyesMLx3O3SWRTXRt5Mg+wt2vj+f/Qvv7YFTz5hdk2+kDrO/ud6Z9qKj+VDlkKmpKig19aYQ7+Q/gZ7Sx3I7SAs8tkL1RomzzM7OtUfbPJGiDnwwZtJZ39weT90uVEt/MlKTL7ogEhFncfZUsej5R7vuigsJ7AjO7+5RF8dyelAhKvRCO+sxIeHjZ3e+Ld8YCZgBWRtEqvZHS81OdeDHkXN0KFfP7KqdUGjJWb4rwWvd396Pbk5eKyk3JXDkbCZ/nuvsJbbw3Nqq1MheK+Hw47jdFDYYQrmdF5906KIrsZOB/7v5pgay1ouR7dEdwS9+gM/kNlNnwErChu79bIJsVNRnl12lkv5yBssc29gRiKJ4vAHxT1nmWyHpzosjK5eLRH2itXAucmjmbTLBs+wFHu/vdzbJvFU1hYD8d2N3dT849GwdBG22B9qkLgIMqA8SYTRaQgGa2EKpRdUT8fC/RAzZA2TS/oyCQ34At3f3mshuxcjL05Ah1Ym2kQ9+MYFI7I1ibU939sIJYHYoSPa0vKpC9DtKR70PIGesjveRfnsA8FsBnZxSdvjaaH7+geXSyR4Zj9OEkBMH8KXA1yrRaHZjc3Zse4aOiilJK9INT0dp9GjlilkXzfgPgumR/GivJ3CslhR3CgP8hZ8Z8CKXHY6/KAtRuQNlxP7r7eg3kbxLkvN4RWADVKTwM6WKzIRvLqugMexG42N1vbxR/FdWocshU1NRkZr2RELYB2myeAJZsNmU1ETR7I+HsZiRUvm9ml6OaOCt4rch5Re1MZjYpiiLoi6IYNvYoDp+PpDfBFlgWydrMlAhJfZBS8H+EQIEMRI8Ce7v7C/F+DyKSwt1va0c+MsElWwu7IyP0HO4+f/Je3jjXFaU0v1I5KMccSubtXMgwuz9wnrv/Es8XQtmUj3gUT8z9fimNmrEO/44gOAa4+zPJs74omn4PBMtxmLsfUgCbbVKydk9GQv5G7v5oOMS+RLCHJ7uw3qcFPvUKgqmiYZC1zlxtFYBiZushbPFXgQPc/ZmyG0PzZGYvIGX+JpQ9tiSCK5sa1XY4xAP/u+zZfGUkM1sO1eNZAfgQ1cK4M/fO35AD7DZ336fxXFZURjJlhZ+DjFlPAacBD3hkd4ahayckI9+XBXk0A2VGxGRvXQQFNS2MHBxdgF7uPkVxXNYo5J7xUbS8ufvXcX9VFLw4NXIivYDQMf5TCKNBZnYciv6/GO0txyK5bUbk+JooCxYwoWGcjewXoPqr/240zxVVVE9KdIMZUEDZIcCJkdl2EQp0XdXd3wkbQ1PBwZvZ8SjjZH13vybudfVaVtw5SN85LK7rKs+l+q0JEm56YDVgexSceBZwmrt/GAF0XZG+OTj/+xU1iNy9alVr+oYi5U8Dri6al9Hsx0FIIJ43ridCnus9ge5xbyuEgW1F89uRGjqQlgNOAT4Hvgd2SZ4bKvxaOK/t3O9O8fNy4H1k2J4S1Ww6H6UTf44iuTo1gB8DxkHRMy3RTgImzb9X9NhVrfiGlN7nUcYaSHHfE0UltqDMyV3jWd3n7yj2oUv8XB1Be7UgQ8/LCKKsf/JuZ5Q9uTMwbdG8t9GXXsCDyJg1Tty7AkX+T5m89yqwSdH8Vq28LTmbjgJ+RVHG/wQWiPvrIAjCm4HJ4l6pz4WMPxRI9CuquZc+nyLWTguCRaUjyh0NHO9JUBbtozGmdwPTDef9Up4RVSumoejtZ4BBwJXIQdN3GO+Weu9pg9/OueuNQ+ZoQUWdi+KrUyITLQ48HDx9ijJP1stki3hnFqA70LUEYzp98LoH0Dvh73WUDfl2yKaPARskv7cB8GjR/FetavVsqA7sW9RsXAvEetkoWfNHojIEfYrmdyT61Re4F+mbR6V7K4Jeewy4tmAeu8d4nxF70McI7aRX8k5TnWEdqVUZMhV1GAovcBcveYrj8ChwHdcF5nJFDlyPompWcPdP4p0rEX7x5t7OcFEVgan42VJIOVkeZc3s7e53xfMOBxVnwl5+DuEan+y1qI4uqMjkcegAX8zdv23nv70aEsYO91oWTmZ0XgYJDLMhDNazUCbM7/FeFcUxBlPA6J0FzOPuc8a9c1B9of8iWJFtkFFlxvaeu+1BSabP2Khe2Oso8v9L5BCdDvgAYY2f47Xo0FJEzMe56+7uSRTcQ8DH7r5hZCo9gvbTq1xZcP3Rer7cm6zWW0WNpTgL7kMRxoORcXRsBBd0IoLXPCzub+V1xuZuLzIVpN4aWNDdP4pMzyFei1o/DUUzzpOdixWNOOXhTkwFa1dFYzoZcu4d4gkEaiVLVNQWxdrcCmWRdEXwm9cAb2SyaJnpr+Z2DsasB7Cau1/ZMAZrfEzmOQhWkLmaHAAAPmZJREFUM3sX1c67Ahk9N0bBKvcgA+fdybuFy0Rmdg+CTVvfhXBhSId/DQVbPobOr/lQ0e/jgH2rvaeijkhtZDZviBwCk7sy5Z8AfkLr5dvYa48D5gHWyPSdMlGi52yBAlXXdvcvzezvKBhwdVRn+BYUQLcICnKdx91fL3qfMrNxEQrDtijw9ikkC2U1xArfR8dE6lQ0AxVV1F7k7i3N4owJI0Nb9DOKsOlhZgsjY/gRKEsBM5sZmBzhUFbOmDqQu3/tSjndOVoLcIeZ3WBms3U0Z0zQxMAQ4CN3H2RmneNQHuzu1yKHySyoiGl709LAEsAlZnaomU3s7kPCAXk1clCeiIr83QjsYmbTBX+VEjMGU+z3LwBzmNklAe+4CYIu29jdH0CG2l+BSQtjdPiUzeHDECTHvi4owOeQwn4HMkQfBlxnZtuGklO4wGxmk8S5m1+HbwILm9mU6Py6B7g3nDFjoSitSYCH4v+pZNGK2qSY5+uirJHbo52AAiXOQ+fCZwhG86SC2PxLakPm+xidu7MCuPugcMx2i+cPojO5X+O47DgUAU0WBh5c0G/HIyPETwjqaJCZrRHPK1miojYp1uaZKNL5MhQkdDNyDpSe/mpuJ86Yzu4+oCBnzMTA/8zsgIA1wswWRRnz27r74e6+JzAHcBsKujnJzI4ws9nTfhRFZrYMCiK7DEEkZmO/Owqq2czdN0XzZkeUNbwbgmuqqKIOQ2Y2NcguF9eZjP8pyqJfK5wzcyMdIbNnzYLgmF8vozMGWu2nUyFnyzpx/3FkM9oBeBzV210dOWK3CGdM4bqbu3/v7neg4JStgG7A7Sao6cL30TGVKiW4oooaTBExs5eZ9c+UxYSuQ8aF4xFUzR0I23pwRFAvioxZ5zeS545ImYBgZhOa2UpmtrOZLWqqbYAL4/cM5IQ4EmXNPBHfoaPR5yiSY+mILB0SxtNsfr6F5uVE7f2H3X0nJBR8gQrsXm9m24Ry+Lu7vwX8G9W2eQIJb5cBm5pqLlU0BlHsnyndhPbKRRDk4G7IYJvVGBsXwY2Ust5TRFqNi/Dbb0JQXqA9/lOkvC+J5v5U6GxYpgBWW5GZ7QC8ZGZrZfcSReUopGA9hL7L8V4rUrsQUliecPcn4vc6opO7olGk/BqPuXMViixeHHjO3bd293HRXDsLuAud16Wh1NEY56lF1imogOovwAGmmnRZ5GVWU6kF1ZHqQkXDpRjXTJ5b1cweMbN5XDTIzLqEPDHIVbB2J+BZ5Cj+uEjeKyqG2pAj/pIiWGtXYEEkr5ZKF0jWQG8zW97MNjGzFSPr5S+pKENcfItxo/0bON/MNkZIEL8BGTpEN3f/wt23R5HdHyDd4XozW7AI3nM0O8rm2RvY2sy6h7NoS6S3PAlyFrtqWe2N9vfJC+K3ooranUwoI7eb2TFmNhvUZPwIkrsQOBg4HbjB3R+Mc3pCBOU6G1ovpSZ3/xcKAjrJzPY01Yz51N3PQoGBMwDzu/uK7n5V9mtF8ZtRdvZF0OulSMc8DdjZzE4fTsB4RXWkyiFTUUWNpxWRgf8SYLOIIgb+3CBPATZDwt3rwMwhaO8E7APcEp74ikaRQjlvMbNJUdbFzeibPAicamZbmNnkodA/g4w+m6LU1NJDFIwCfYoMWpsD65vZOKDIwHg+CVI02rUAd3bwu/tNKJLkKKTk7gtcY2ZLxfNfkTKzDbA2wkI9G0XPVTSGUEQXuZmNZ2YrwZ975v7APxAs2Vnu/mP8yjJIGb7c3X8ssaDZBTkwhrj7T3EmrIfOgk7u/h3KBPoCFX29pzBOa+TAD0AGoTZt8uwDBDswEBmWDzWz/UzFbi9Ca3yH+L2yfpOKCqLMsWdmi5nZLHHvIXQGOwqMyKISrwGOQfAWNxTDcdsUMsbsZvaymS0e8sTgcLw8g87bWYGHzWxToJ+ZdTOzBdD6+CocCBW1QWY2dRhpPcbakDFnGuA2MzvNzCZ0ZfoOSbKPeqIagVu7+9OjYpyvqLkp5IgZzGzfMAQOlxJnRy93f8ndF3T3U+Ne4fMn9pQWM+uF6urdjs7ay4AN23i/NOdurN/X3b0fijCfE8HC7YJk/AHx3h9m1jX6+pS7r4Aggj5DsDtF01nACsjZfgaCzb0SBabc7LWC2dnYj4X61r3xrFZUUftT7IW9UbDJpsA5ZraTKQMuoxNRLaU+wJxmdrKZbQ7cgBwZR7n7h43lfOQoWcMnItvJTihLGwB3/8ndf43A3tQJUrhDJuUhZKNXgANRP5ZBGUwVNZq8BIVsqla1Ma2hjftOZKy6B6Vf90ueL4Vw01tQ0drMsHUNMH7R/Dd7o1ZY9zaUNr4zKiS/R4zzzwgua2WGUcCzozVgPKRADEJRE0uhCI/ZUebWr8CEdfi7WSG/LkiZ+QThr7YgResMYNb0fYTHukDRY1a1YhqC78r2wzmS+52IYooIyuhV4MnkeWkLFgLTEsUVUabYh8B8cd0l+nxGmfoATBA/e8c+egkwZ/J8BgQr9UqcY9+hzJ+Fs+9VdB+qVs6GHPQtyBF5B4ItmxTV/zgk5KN/AmMXzetf9GNzBEX4B8rymTx5Ng5yvGZFqz9BhooBwPvAkvFel6L7UbaGsgU/i7nwt9yzZZFR+lPgPWCX5FkfVAvkFaB70f2oWnENGaFakDF/zb+aD3EO74eKN49bNP853jrFzwtjDzkA1S65HRlHJ4j9Zvq2fq9g3i133Q1Fz7dEezgv7wNjDev3i24hD22CYItakENmztx36gkcjYJaehXFa9WqVq+GoM5fQkFbN6JgyrGT59ugoOMvkY3rVZTxVqr13Ea/8vvVlAhi+vP8PtVMDdUQ/hwFNhbOz5jWMqNkRRVVVACZ2eooRXtCVLTwJgTH8auZ9URYmiugiOMXgYe9BmlR0SiQ1YpoL4QMPbsCl7i7m9kdQA/gURR59QH6Jne4InQ7JEXG0BAT7uuWyIg0IRKSuqNxONbdz67D384K5F2NooVvQ86w6ZFwNg/wDVI0L3T379ubh4qaiwKeYl1gJRTNcxnwb4+6WmbWB8GWdQFOc/dnrQkKFVoUojazZVG00tbufr6ZzYUiRt9393UK5rG3J/XLIvJrGuBUVGD9N7RnnuXun8c70xNBBa6Mpooq+ksys00Qvv5cCKr1G+BpNJemQcasw9z9/qJ4HBEys8WR82hNVBT8GHf/d/L8bygqfDEEX/MEcJe7lyHqu3QUe874KLN5IVQn7DzgHo/I2jgDVkMOr/mRQ/hCoD+qzXiMu//LckWHKxpzyMwmQxCIOyIYsltRpvwz3roQdSajzgdcDgxw97mK4LktyvH3JKoNcLG7/24qNH0x6ttGyCnzNto3by6IZaAV32OjwK9lgVvd/eV4Ph2CaF0VGW7PB25M1nhnZBwdXEgHhkOxR02Jxnx75IA5AzjT3T811Yj9D3CCux9eHKcVVdR+lK3p5HoshOyyNVGPF7g2k9lMsOhzIujQX93954YzPQJkZl08SgfEvtpKnwxotptRAMhW7v5RM8kWsQdfA/Rx9yUKZmeMpMohU1FFBVDiFJgNCZuZQPYREjqvA94to6DZUcjMDkUZMJu5+4tmthyKJlvO3f9rZgegiIFOwEXuvkWB7DaMAq5sKlTToj8q0H2fK621vf9WppDNjiKh9wBO9VohQEMOohORo+wBJMyd0968VNRcFBAiyyM4jqVQFPqx7n5BPO+ColhLVxgyVVpCIemb8mlm0yCoi0mBd4ApkAFyHnf/oPEc18jMnkQRb7t4pOMnz9ZGTtRZUYT/pcAFeaUkr7RVVFFKqSIb63wSZEjcFBlOJ0DQVCCov4ncfWABrA6Xcut8HGBpFGE/Pwpy+Je7Xx7PM5mwq9egQqu18hdkZksiQ+fMwC0oS+8hF8xjtpeuGG1h5My7wd23iefV+I7BFPvL9Mh5tx2qk3gOCuR4P3mvN8rG2hWY2d3fyox0jeZ5WGRmzyCn9TaJ02JOFL39FkJjmAQ5oSZAGRoHp/tNEWRmhwPbAo+genOPpAZPM1sRBXxMg7L4LwLu9Bo0bWkpnEZzIAjKDVAW5Omott4C7j5VgexVVFG70DCcq7dkdgMzmwrZU1ZGmas3IV3+1eT/KNV+2haZ2bNI13waZfbcGY/eRHBftyDHxpZl70ueQhftlclOFTWWKodMRRU1mJJshAURhMX7KJ2zM1IY1wSeR0W2Hnb39wpjtgNQKFzdXXVIsnudkXFnGXdfP+49gWo0bOXuX5vZPKgOwqHAO+7+acOZH0PIzFYBrgXWd/eb8pFvZrYqioD9A3i86CyBioqjNubGuGjP3BwZa/8LnOjudxfH5bApMbyOjRT0zZCz5XvgTOA2Vx2ZOVFk2TQIvuyqEkS09gZ2R0UgJ0JZSCemhhEThv3WqG8TIcXlDHf/X+M5rqhZqC3DeBaNmLs3LoLCmxhB+z3o7ic2jtORp5yD6Xkk6wH8DRkh98yyYWJ/82aJrCyKYpxaEofXjii7wVFGwHUIrnJQPJ8EOe/GA75wFREufdZkRY0hM+uODOf/RHBT36PaVFe6+/dmtjwKkrjK3bcvy9xJDKFrIRl6PXe/Nnl+PXI4be7uz8W9lVB9unGBv7v7mwXwnenBW6KAxMuB/VPHehtR6HshfWwwgo07wN1fbzDro0Qh7y2F6uIsibK3V3P3WwtlrKKK2pGG4VxN5Z8lgINRsOcLyHlxvbt/WwjDI0FmNjNyyvdFZ0U3tId+gJAB/od00HmBk4CD3H1AM2XKVFQcVQ6ZiioqiMzscYQVvoO7v5Ep4iiy4FhUU+BqBOH0P3f/pTBmm5jM7Ghk8Py3u3+U3J8cGCfGfjo0zte6+yHxfEWULr+mu7/WeM6LpUYKEWY2EzLcXgPslBnhsmhhE+TR3Qj7/T4PKKSKOj4liruhOltfxP2uyCCXRVH2R7CPk6E6AVu6+4VF8T0sSvpzNrAOilx9EUEyzYEiyO5MFJjJyuQMNkFpzoqcMpuhbJmDkOEqhXmZHkWFroAM0A+is+73of7TiioKMrN/oKy32RAU1WMIvqt0mW4jQrFvZQW3t0SBNouhTI0Nok2K4LT2b9Z+NpoSx/ZYmRHXzLqhbNrtEHTIecjBPcbJbxWNGoXD9+/IqLgiqgNyDjqX/w9l4/1RNiNbGEJ3Q/ViDnH3s6wGYbYuygpLz+e1kby9nLvfUxDPnVEQ3DVIP/uyrXFNswZNUIRnAuujmpalN+SmZGbjIdmpn7vvVzQ/FVU0ujSKztUtECx8L1Q7Zl93f77BrI80mVm32P/7Af1QpuEyKNBjQaR7dovrndz9vMKYraipqHLIVFRRAygf/Rnpmw8B/3X3LfPvAsuhaKeecXuKMhnlmoVC4L8QRb3N5O5vm1lfd/8h914XlJX0ERKW+6JIprWBaTqCETERmnp5yXBazawHgiFYExlTrvHWdSrmRVGve5Q186Gi+pKZ7Y+yYI5B+OiZgv6nYyaipLdHzrsD06y4osnMFvOoQxXZL08D+7n78XHvTrTvbOju75lZnzJBcgT0z+eJs3R8BL20Harl8xDqz+O531scFU9+xd13ayzXFTUDWQ2fewkk9wxGdVT+DgxB0ZZXIEdllhk3lpcMpixxEswFfOzu3yTPeiInwdXA3plRFynz/0QG397AHF4HeNCOTPmsogjwOAtYAtUDPA/J2lUgR0UjRBGwtSyqL/M3lNGwo7ufWUZoHTObGFgUyUj/h4I8+iKn9oau2nQGWihmtjFaI+u5+20N5jXL6tkZGWU3dvcH/uJ3ugBTeiBGmNlE7v5V/bltf4rv0Llsc6iiikaVRsK52iWR4XqhjJN1kdxTaqistrK423hnBiTHbYUCizZ39+tG5HcrGrOpcshUVFGDqI0IgRdQNNOiIZy2EvIj1fxp4CkvedHaspOZTeHuH5vZLAi/9xTgEa/hjHcC/o3w3V9AisyEyHByViFMtyMlhqIuCGN9CLBrXgAqUmgwwSFdjZTgG4ELUKG/bigzZmmkkP1QBH8VNYaSuboOMuK/Fvd3QhkZE6A1era735H73R1Ruvj2ZUoVN7P5gYeRY/0rMzsW1b9Zz91fDafF/Shj5uYwTh+NIrC2K9ohHAEEjwPnokjbl5NnUyIojp0RDMHFKEL349z/kUWWleKbVFQ+MrNXETzfoe7+pJmti2BdfwQGxb+vcvcnCmRzuGSqh/YiOmfPRXvYz2Z2DCrwvHRk5ab1ZXojo8Rc7r59UbyXmZJzYQMUsHQryjJ6wVVAt7u7/5b7nTVQlvPkaH/d3RPM+ooqGh6FvDwjysaY0d3XLZilvyRTtv+KaK+ZA3gK2MLd307e6QMchermTF7EeRxOiWOB1YFF3P2LYekf8e64wMnAZe7+34YyW1FFFbVJo+FcncKjRpeZjVdGZ0wSxNoT1cWZMx5dkQW1Ju+ksGyG6vDeieTZ5StnTEV/RZ2KZqCiijoymdnUZrYDgNegdcaKx9cBCyE8TcII1zneGRfoig6tyhkzmpQYBycE5gIuA440swXNrIe7t7j7AcAqCDv6WeSwaHpnTJDFz2NQ1PEnbQlAjRAasii9Nv72T6gmwL8Rj3egYqTPxvU+lTOm41MY3SZCBs0HzWx3M+vt7qchA8JVwEzA6WZ2dkSjZ4aIRYDZ3X1A9n8V0omhaSDazzOIil+Anolx8BQEmXhvnAM9UO2YnigytzCK9foLiu7/F3CBmW0VjhhcMJBXoCj/g5Gj6SUz2ycUmYwGxvtl+SYVlYCy88DMVkfwFWe6+5Px+HCU3bAEyl7dCjjRzA4Opb6M9A2qrbQ8Kly7kwmGbVfgSHd/I305DBo/uaAtdo17namoFcW5MBaCfNsInQ+nAa+a2VPA+WZ2jJktbWZLhQP4RnefFmU7z4OMIxVVNELk7oMjIOQ4tPeUfm26+7so6Gw3BN83A/BKrI0e8doCKJPmsKLO49A1xgb6esDQDkv/iPuDkH7Wr2FMVlRRRcOlcMYYMAWS8d+AYev5cb83cGjIRZTRGQM1mx2S525HDuHjgE/NbE8TisGQePdPZ4yLPgAuRUFqf2s07xU1H1UZMhVVVEcysyOBfRF+/pFpZI8JS/ZkpFw+ABzl7v81s77I8HgSihQ9uaFMdzCyGhzKpO7+WaTJ7owKZv8EnAHcArzlJYZDGVVKIkunRVitB6Psgp9COPoHyioYANyaQQLUkZ8somaN+NuTovF/AHgfBQpMjZyV8wBvoyyxp+vJV0XloTAcLIlSvtcGXgcO9yhWa2YLAjshR93YqA7LpKh47arufls+I7FoMrPzkUFhbmA+lNq/CFp7x6Msk6cj2moelGlyh7vvUwzHQ5OZLYWMPTOjNXsxKqr+QzwfBykgmwLrof11S3e/swB2K2oiMhVs3goVOn7NakXal3L3Z0xwZrcAvwMXeonx900wirMjR8AG6Ez7GO1NL7bxfpU1NgJkgkk8CZgFGZz/QI7r5YApkbF2NjTWPVB2wKso0/z2yJosHdxURRWNKpmy+ydCEdm/Ab+GUybLvFsY7UHroHpvxyPZajp3L9RQaGaboUz45d397syIO4wsmYWRc/5Yd7+4oYxWVFFFwyUzOw1Y390nGIF3e6Ezekd3v7zuzI0CJZkvGyHY+1NRxvPkSA7tiewVBwDX5XXNsONdB8zi7pM3kveKmpMqh0xFFdWRzGxGYK1oUxOFybP0cRPe5E7AGsig+B7gKNrgBXdfsAC2OySZ2YcoEv0sd//NzKYGDkWR3c/FswfyUDsdhczsCFSjZV13fzEEhp0QhutABA12LipEN6hOPGRCzjIo4uRX4BNUJPxt5By72d0/qcffr6i5yMwmQY6KHVFU5+3IMfNkPF8RwXPMgubwNe5+YUHsDpcio+QZ4GaUKXM/gg6cCkH17erCeZ8YGXJ3BabyEuCkhwL1S2YoSYzljpwy1yKnaVbXZyJU4PJAFGhwUxF8V9Q8ZGZ/R3Beh4dh7nm0XnZzQX79DTkDNwC+aAYHRmSILQ5sg2rE3IXkjKfc/fsieWtWMsEn3owc8atnGUfhDJ4BOWH+g4wli6CM6E/dfeoi+K2oonqRmc2M5PeVkAPyB2TovBtlGn4Q702KIH83AxZDDuIlPGraFUWR1fw4yn7cKFnLnZBskUXgj4X20EOBBd39rYJYrqiiitqgjupcNbOXEErHQe7+iZltjTIPD0V2vfmQPHJyfj81s/WAr9z9vsZyXVEzUuWQqaiiBlBEdK+PIvnGQYbnkzwwr81sWZQRMANyzFwH3J1FOlU0emRmqyBnwzbufkvu2aIIT3kBZDA53TtQ4fgkI2VvhPG6sLu/bWZnUDMSbQvsDxwGzOPuz9eZp8eBr5Ay+Q5yyByAFMsHERTJYxmUQUVjFmVzNv7dCWW+rIYKyPcDzgeOc9WFyjLgugKDY66XIuI8SdvvggqVn4agQuZDRpGr0Ny/BdVE+Bg5nxYCTnH3IxrNc0ZJZt0KaF3uj5wyWRZhN6SYbIcCCc4FbnP31+O5Af2qNVzRiFCs83Eic3NiZFR/2d03i+crA+egKMwHC2R1pChbB2j/2iv+fSkyXrzqBdeHaiZKZJkpkYz8JQog+TCeX4IMzit5wEGaWX/gB3f/sMqOqajZKTmXl0ZGwb8hyNBvgPGQw3pcJEscDZyXnNkzoqzjgUXKFimZ2Z6olsyrSA+7xd1/zb2zNHAW8IS7b9x4LiuqqKLhUUd0rppqe56GdM3L4t5XCPL+IBR0dgMKZu0CjOfuvxTEbkVNTpVDpqKK6kipAhiK4cnA/EB3JICe6O4XxfNSQew0OyWKSycUybA/sKK7f5of6zCa/BNFbRzh7ocVw/Xok5mtBnyHlJeBufs3ouLihqJHD0aOwV/C8HoRKsrX7g6pxJgyEYqqv8dzcHxhdDsCOSavB85vJuNbRfUjM+uOitT+E9gEFfo+BhV5/SHeabMobFnIzCZEtZFedPctw/C8G3KI9orXPkHRVicWxGYrMrNPgZeQkvVtPvItjDxnIRiUR9Eeeq+7f1YQyxV1ADKzmxHs1/7AWMiROZG7z1YkX6NKIYdMi2DZtkVn9EXAJZlDoaIRJxPk6UXAXe6+rpnNCzwJ7I2Cav4o+3lQUUUjQ4kM3RmdyZ8jfeX+5J2eCI55L6AzkvGPT7JXu4Dq4zSa/2GRmR2AakcOQLX0bkEFsSdEkK4Hob7M76o1WVFFFZWMOoJzNeS0rGbdfMDlwIYu2NxdEbrB/7n7C/H+Y8A9wE2BPFLZ8SoaJaocMhVVVEdKore3QwaFFhQZOR/yrk+JlMiD3f3x+J1qQ29HMrPDURTZdMDfswiGtpR1U5G2Hwtgs10ootZfRH09ARlH3/dawbl1kcFiMHA2cGUYLnqhqJV9gLm8TpBhwd/GCDrtKne/JO6nGRHdkMHqJKRsHlQPXipqTjKzcVHtmG0RXNlTwCGZE7Es+6eZrYlwhvuhWgcTo0ixHVCW5B7AqWFg6QH8H8o0+cLdvyyGa5HVoAX3RgrIqmk6vplNFo7tTsnesjLCWZ4YZbntkUWpV1RRSsn86gXMhOrCALyTZYyYYC0vAsZHDpn3gM3d/ZEieG4vigjRuZEjdm3gH+7+v2K5ak4ys5WQPH0tyiocBGzgda6DV1FFRVASZHYqym7fyt3vTRw1aQDgHCiSewpgTXe/vyyZw22RmS0AHI6g1QB+QfKTIQfNKe7+QDHcVVRRRSNCzeZcTfbO8YEJ3P3N3P0ZXIginRGyzdzACu7+jZlNTi0o5ITielFRR6DKIVNRRXUmMxsb+BSllR+ZQbiY2ezAlgiiZggynh/ngftb0ehTGD+uR5A7IOHgwNRQ2NGiKE11iTYGdkZRuMchjNPPE6fHuJ5g2Icx9XTgVnffqY68bYHmOcALKOr+teR56piZGPimTJF8FZWHQhheFu2fc6Co6F0LZSrIzBYBHkKOz59RRuRPyPD8OTAjSnF/DmVJ3pb8bqFGk0QR6YmKAJ8OHJY4stdHhp6Z3f2dNrINDwR2B6as0vcrylPOaHgLgnHtCnyAFPhbUwdFnBk/oayy0sJbjCyZWR+gvxdcx6EZKdmjuiMDz77xaFl3v7dA1iqqqC6UzPnpUL3FPVGdmN9zcnMa4f134D6Ujb5qYcyPBJnZQsCqyBEzGHgEuLMj6WgVVdSRqRmdq2Z2KarlfCQKlBtKdzGzI1FA6xTu/rmpbs5pyI5xc0ezJVXUWKocMhVVVGcys6UQTM0O7n6BmY3lraGk9kZK5R8IE3uOMkR4dyQyYYH+C8Hq3I9SZh9w92/ieYc6SMMRNSeCR9kcFUM/C3jE3X/OvbtGPPsIWCiDNqgTX32AZYKvZVHdjFOAZ1K+ijZKV1ReyhkfugAzA1sAuwBnArsUvX+aahxMgvbzgSgz5gegbwjy0wHbowj5niiC7Gh3f6UYjmuUZC9ciOoxrJbxFcaeN4DHgO3dfUDye6mhfSx3H2hVzYaKgMgAm9Td30nuHYgM6eei82lLdCZ8iZT2a73OtczKQh1N/mg0mdnByEB9IsqWrMayog5JZvY/YHIEv/zOCLx/OXJ6T9fM2f8VVVRRc1EzOVcDxWYjYDZU1/Zkd788986MKGhoMhRkPRnwqLv/X4PZragDUuWQqaiiOpOZzQK8jLJj/pXcz4xW4yMj17XAjRV8xajT8Az54aTYHDlmegNXInzQp939t8ZxWV9KDKp9kUH1XyjN9g80x05BxZIHmQqhrwEsAFzt7k81gL+uCNZoHRRJ3wPBjlwKvJE6KyuqaEQosjmuQzUaFvSoKVMmSuBGUpivxRGE2SIImmltd7+1SD4BzGw2dGbtg2pMZY6WAxHU0hLu/nLcyyJ3ewDTAJ+WcfwrKo7M7Bqk6B4D3O7u35nZjUjxTbOvFgAOQXCurwLXIGzuukBo1psqR0t9KdlTp0D1GRdDgU/XFstZRRW1P8U8vx9BXZ+BzuaPhvFuBpd9BgqCmhP4vVn2o2rvrKiiihpJZtYP2A7ZJiYDHgCOdfdH43kXFNS7JLKp3I3sJp/nkQIqqmhkqXLIVFRRnSkM0Neg9M1NgbtzkcXTIBzKI9z9v4Uw2cQ0ItkUuejtiVBk7g6ogPYNKEW1KY0+wyIzuxoVRb4fQQ+ND6wFdENOmcvc/X0zM6BLPTJj8kqVmXVz9z+S61nRd9gMfYtTkcHu/fbmpaKOTWZ2KLA1sHjZoY3ye5aZbQJsiLDefx72bzaGzGw3VIPqFeTQ/Q/aP95DKf3HhkM3c8YY2lsORE6lUo9/RY0lUzHUQ4Gx0Xl7MdrzP3f33U11wwYljsoNUMbDLEjh3awIvkeEEqdAd1S77TOkW32bvFMZF+tMAXGa1ZL5vyqwqaKORrHHzItqMG4BfI+c3Fd6awji7FweB+213VFh6h8aznRFFVU0RlPZ5Z/QXyyRP2cB7gUmQHvsDUjn+TCed60nkkhFYyZVDpmKKqojJYLxEkhZHIwi+e4CXo1Mhj2Ao4BlvMITHyUyFVy7HHgWeB34xd0fNLOxPYoEt/E7cwDHo+ix8VOFplkpMQ6tAtwIbOzuV8aznsAMCNppE+BRBBdzR2o8akdeUmipZYDVkYHtbSTgPBOR0t1Rhs5uqFDp4WkmWUUV/RWZ6nRdA/Rx9yUKZmeEKY2qGt5e1Wgys6mAhVF9ngXReh0HFQhe3t0/jvey820qVCNtbHeftyC2KyoxRYbqCcgB/1m0Z919u/SdLEMyAlkOB55y9xsKYPkvKVPMzWwy4BJgCZSJ+gDaj+7P1kpF9acI8HgQOYUfKJidiiqqC5nZuMDfgW2BFYGn0F55by7gaV5U7+1Gdz+gCF4rqqiiipqBEnnu/1AQ2mFon10Q+AYheZyc7rEVVdReVDlkKqqoQRR1A04Flgc+RBv8uMBUSGBet0D2mprMbC8UKTYEFbL3aI8CA4B7gI+BL939jTRTw8xm7GgR3WZ2Ioq4X8rdX805R6ZFUXOLxOuHuPthdeAhg07bGWUkdQaeRzU/pkBQabcmfE2IsK7/6+5ftDc/FXVsCgNuL3f/rmheRoYiOouyRZCZ6sVMD6yGaj5Nh6LGtnX39xJnTDdgGxRoMIu7v1ml71c0LAoc7tNRIATA0cC57v5BPO8EdC5rBGJAzA5y95+Se3cA/YHrgXeR02kGVCPtIlSv7sd4t9TRos1OZjauu39fjXNFHZ3MbHJUd2tHtP9ciyK5n48ArP2BnVAR6qp+TEUVVTTG0/Bkg5A/30HBNFuEXrkVyuieEXgJOMdz9WUqqmh0qXLIVFRRO1JihJ4QWBzhpncDHnb3O2NzXxJB60yBnDK3AtdU6eSjTma2JsoyugS4GRW9nBtFrI4NzAf8AnQCPgCeRsW2z/eohdCRyMy2Bs5G9TSeCiHDkmj85RC80Kkoqq5djdiJsbYvgiK7HNUK+MzMzkRG3hXc/YXKcFJRReWlyGCbC8GkbAn8ABxLwKREpuGtwD3uvnXljKkoJTP7G/CTu3+UywhbBjlmZgT+i4IE7kgcF6WEhTCzx4EnEeTnswGV9RCKprwygb3YFjmbOqO+XY2yfUrXp4oqqqg5yVTXYCZ0Pm8L9ERy/XMoovtEdz+8OA4rqqiiispFZjYD2jMvcPevk/tZncylUK3dTJ6bEgWebQO85+7zN57rijoyVQ6ZiipqJ0rgovoAtwPzIyfAL8hBcCawewLJ0Qf42f+i/klFI0ZJlsxe7n5Ccr8XcB5ykF2BirUtBUwIrOvu1xXAbl3JzKZHRqJPgH+6+5txP3MYro+yVtZ19zfqyMeeqEjeeu7+dEC7vAscAJzh7r9HvYqpgD0qQ25FFZWTzGw8lLqfwaQ8AZyEoM22BCZw9z9sBGp6VdSxKZGFlkFQOj2Bhd39p7zDzsz2Bg4BDLgKuBQFsJTuLIgAg6tQds8bCPLzaeAcYB93vyuXfdsVOBGtmd+ALTqivFFRRRUVS5ERMxeqU7oW0Bv41N2nKJKviiqqqKKyUTheDgOeQQFmN6GaMfk6mZ2BlgTJYxHgR3d/uQo+q6g9qVPRDFRUUQekM4CJgW3cfTxgj7j/PjI6ZNGfP1aGq9GnBPLnOJT1sbOZbZi8MguKhDgOONjd10dQPAt3VOOIu7+DhIoZgBvNbHcz6xXOmDmQQbV3eztjzKxH/MzOloFAV1TXB+A0ZMi6OqmXMRswB9C3PXmpqKKK2o/c/Tt3vwPYHqXwdweuRDWp9g9nTJfqTBuzKTIeW0KRPQk5InYJZ4zlFVh3PxaYBNVc2RS4Djg4fr9U5O4/uPvywP+hQJtTkFLfGRgr3vnDzDplGT7uvhMwK4pYf6kg1iuqqKL/b+/Oo+2qqwOOf3cGEkAIEAWkBVEokzJasWiroAK6kKjMCCJgKbOoYJGWVjGCWiaBFjEOQcWFAgJCEdEyCUFBKBZBqRRFGYQwBRAyZ/eP3+/q4ZEQXt6977zh+1nrrbx3fufcux8k77579m/vPYJl5rOZeSNlo9X+wFWUNjuSpOebDuxLmet8AWWjzbmU+3Tf6FQyZ+bC2u1jTP36xk5XFZMx6iYrZKQuqnNibgFOpPRF/2NEnE9JCuycmffXypjjgDMz86EWwx1xImIN4CuUndy7Zeb1EXEVf66GuWek7WpYSj/Uw4CPAWsBTwN3UZIfKwIHZea3uvD8nd3QbwbekZknNNb2o/ySszEwGbgR2BO4tO4+2ZDSWu3BzNx3oLFI6r3aJmUD4P3AX6Xzz1Q1Xg9Oo+zUPjgzr+yzthKlZetC4Lmsg+8jYgvKm+Pzsgdzzbqp/hv4EGVOw9rAw5RE5XWZ+WzjHDJzQeM6K8gk9UzdpLZmZv6h7VgkaSha2pzMFkPTKGRCRloGS7oJHhGvB74HHJqZl0fE2yg/4PcALq43I/ajvInfNzNvHdTAR4E6ZPoC4DXAlZSExIGU/u4LXuza4ayW0r6GUvl4T2bOqMfXotw4eh2lXdv9wPmZeVmXn//HwMLM3K5xbCJwPfAUsA5lWN57M3NBXTuAssv4LZn5027GI6m3ImJlgMW1otLoVTdG/ISyC/HUzHyusbY1ZXbMXwMzKS2/pgOXDcfX5zov8DDKzvQnKG3MLqH0H++0uRiS83AkSZJGq6XNyWwxNI0i49oOQBqOGm+0d6T0O+/ccHgSmES58Q2lZcdlwNU1GTOBMk8Gypt3dVHdfTo3Ij4PfBM4htIK5Ts1CTCiBsjXFkELImJPyk2uyZQ2YY/U4cMn1vLaqRGxcqNtTNf+GzQe76fAQRGxRmY+Uv9fzImIUygzfFamtG3ZMSJupQzO2xO4wGSMNPxk5tONz03GqGNtYAXgt32SMe+lzFRZG/hPStuv3SkVnDOARwY90n5oVPisQOk3PiczZwInRMR3ganAJ4GdgWkR8YPM/L3JGEmSpKElM2cDN0XE3cDVlJl/ZwL7RsRUyv27uW3GqJHPGTJSP3V6m0fEEZQh8n/RWH4QuBY4IiI+TSmB/Fwjy/46YG/gFksiu6/TCiQzb6LsdriD0r99vTbj6pXGjuJTKTuNtwHeDXyfsgP5hxFxcp0f07l52tXe/I3kznWUZORWnaW6fiGwOSUxthdlRsAfKMmyHwJHdDMeSVKrZgGr1w8AImIXSjXkcpRWZrtl5vuBQym7Ew8c/DD7p9FqbCplftIbGmt3Zub7gCmUzW5nAedGxHYveCBJkiQNCYuZkzmBUu38vYhYrdXgNOLZskzqh041QO0N/iRwHnBsc6dwRKxLaVu2KfBzSruyR4FXU2bLvAnYKDOH9G7Q4az2Bk3KcMvTgcuBw5v/n0aKiNgI+DZwdGZeXY+NA94F7ANsCzwOnJWZ5/QwjlUp7dBOycxPNY7/qWd+RGwG7EBJXN7ZGY4nSRoZImI5ypDU7YBvAb8BjgdWoczS+37j3I0ps8XObM4fG2o6Lfki4j2UuWhfBf6l7q7se+4Eypv6fwO2q8O2JUmSNIQ15mTuB2yVmTu0HJJGOFuWSf0TlBv9Z1ASMtP6JGO2ycyfRMShlB2fe1IqF56ltOW4AzjKZExvNXayTo+ISZQbI8tHxB4jYaBuo3XKqpTqnwSeqWsTM3MOcHlEzKBUCu0OnB0RszLz2114/he0PcvMJyPiZmCHiJjaaWFU4xyXmQsy8w7gjjrUeeJA45AkDS2ZOS8iTqVUyHyI8rP+NuALmfn9Pq8fr6S02RzSmyUaLfmmAtcAp2Xm7OaGg8a5c4HTI+Lc+ro4olqlSpIkjUS1+8gvI+IzlPt+f2oR325kGqlMyEgvUX1TvSgi1qO02TgG+GVj/RPASRGxbmbeFBH3ARdTWjitS5mfcVlmPjDowY9imfmFiNgcWGskJGPgeQmnzwMfBJ4CNqS0wpsTEeOBRZn5BPDliLgB2L4byZj6/J0ZSp+g7G6+JTPnAVfUmNYH/rdxyaSIWAd4B/CW+ud7gau6EY8kaeiovwO9BXg7ZVbM3Zk5qy6PBRbUzRI7AitSKk6GtIjYklLlc2tmPgR/fi1ubJJYh/L6d32nVa3JGEmSpOEjM//Y+NxkjHrGhIz0EjXeVE8D7qEkV+YCRMQqwNHAScDMev5DwEOUeR5q199ThgyPND+iDEjeFvh6RPwFcHrj7+VymTkvM+8G7u7mE9cbT58AxgPnRMSZwE3AXODdEbEWJfmyI7AZf/7v/3vgvMw0GSNJI1T9nem/Ol93KkUab2x3Az4AfGYothPttClrHHqQMidtpbo+ofNa29gkcQjl9e5uyu9/kiRJkvQCzpCR+iEi1gauBdYB/gM4IzPvi4gvUXaCbp+Zv63ndubNvKClhdQtEbECpUrmIMrO3Dso7VQurusBjO327o7aJ/+vKTOSDqDMqTkdOJbShqbjTuBW4Pr6+e+BWZk5v5vxSJKGvvqadRSl0vjWzNyl5ZCeJyLWBOZ2KlzqsTHAyyi//02kzIaZWdcmZObciHg5pT3qJsA2VsZIkiRJWhITMlI/RMTylJvQu1J6oz9OGV57NHBwZk6v59kzXD2xpL9bEfEayg2uXYBVgR8CJ2fmbT2OZ1VgG+BwSlJyOeAW4AuUJMysvoOP/fchSaNTRKwPnEt5nTirs4llqIiIS4EtgCl17llzbWfgG8DvgJMy84LG2iGUTQmHZeb0xVTYSJIkSRJgQkZaJo2b0IcAbwMmAPsBF9pnUr3QTGLUv39TgOcoA5FnZOZjde3vKH8vtwXWAHbNzO8NQnxrU2bDvJ/yb+I84DTgF1aISZI6ImIcMLHZo7tttZp0PPBZStuxd9fKl806iZmIWBE4AvhoPffXwAxKAmdzSsXPu1oIX5IkSdIwYkJGGoA6R+PtwMHAG4DvACcDP7cCQN3U2W0bEYcBRwIb1qU5wC+A6Zl5TuP8vSnJkT36Vqj0MMbxwEaUKp2DKcOazwK+mJkPDkYMkiQNRERMysynakXMucDXgHMy8966vjUlMbMZZePDPOAc4JuZ+YDVMZIkSZJejAkZaYDqTegNKG3MDqb0GfcmtLqmkYzZELgd+AHwbeBeYE/gPcCalJtGn8vMR+p149uY1VJ3EW8J7E+ZMTMXOCQzvzvYsUiS9FL0nfkXEW8FjqfMZ3uM0qJ2WqeyJyLWo7SuHdepUpUkSZKkpTEhI3XJYm5CzwEO9Sa0uiUivgVsSql6ubtx/LWUYcI7AB/KzG8MhR26dcjx3wKfAD6ZmVe1GY8kSf1R26vtDxwAvAq4E/hqZl7YPMd2tZIkSZJeKhMyUpd5E1q9EBErARcAy2fmtvXYeGBBZmbtf/9jYC3gdYPVpuyliIjVM3Nm23FIktTUZz7basAsYMXMfKbPeWsCh1Facr4MuB44KzNvHdyIJUmSJA13Y9oOQBppMvOxzLwUmGIyRt1Sbw49DLw2ItarrVXm12TMcvWG0m3ARODlrQbbh8kYSdJQ00nGRMTkiDgOuKN+fD4ito+IMRExtr7ePpyZ/wrsB1wDvAm4JCI+3uK3IEmSJGkYMiEj9Yg3odUD1wCTKdVXL4M/9byfFxErUGa1LKS0y5MkSUt3OvCPlOqYWcDfA6dRqk0XZuaiWpFKZv53Zh4IfBx4gNLCjFqlKkmSJElLZcsySRqC+rRRGZ+Z8+vn/wT8K3A38CngdspQ4b2BqcAFmfnhVoKWJGkYqJsZFkXETsBllI0OX6JUme4AfKMef18u4c1SREzIzLmDFbMkSZKkkcGEjCQNQY2bRVOALYGrM/PGiJgM7A4cDGwGPFkvWQH4KbB9Zi5sJWhJkoaRiLgX+Bnwkcx8uB5bBbiEUon6BeBVlMrT8cBdlA4Dj2fmjObmCUmSJEl6Kca1HYAk6fkiYmxmLoyIzYAvUhItXwbIzMcjYhowA9gU2JZyc+hq4AaTMZIkLVljdszHgFcDhzaSMWMzc1ZEPAq8FfiPetlYysYHgACmATNMxkiSJEnqLytkJGmIiogbgPnA0Zl5e0SMAbLvDaBmSzNJkvTiImIs8G1gV+A/KS1A76wz2TYH/puyEeIUyuvwM5RNEPOBvwIuysxnO9WsLXwLkiRJkoYpEzKSNARFxNbADynzYs7OzAWNtU4FzUrA+Mx8oq04JUkabiIiKAmW7YEjgVdQql4+D5xHqYjZPTMfe7HHsEJGkiRJUn/ZskyShqaJlBtC92fmguaNn0ZbsgOAlSPi1Myc3VagkiQNJ/X19I6IuAe4EfgAcBCwPzAJ2LWZjGm0OWu+FpuMkSRJktRvY9oOQJK0WDOBRcDf1a8jIsbUXb2docNvBP4G8KaQJEn9lJmzM/Nm4F+APYArgDnAcRHxzoiYWM8zCSNJkiSpK0zISNLQ9HvgOuDwiHhPZi6qH52bQVtRBg7PyMw5bQUpSdJwl5lPZub3geOBwyldBK4ApkfE5p3NEJIkSZI0UM6QkaQhpDkgOCLWBs4H3gRcCpxI2bm7JXAMsEpmrttOpJIkjTwRMQ7YANiN0sZsNeBM4PhGy1BJkiRJWiYmZCSpZYsbDNzoV78xcBSwKzCZ0sZsDPBj4ITMvHbQA5YkaYSLiBWBzYGjgV9n5nEthyRJkiRpBDAhI0lDRETsDOxOuQF0F3AT8F3gScqsmDUou3bvAm7MzJkthSpJ0qgQEasBT9ZNEn+qYpUkSZKkZWFCRpJaFBHjMnNBROwLnAzMA66ltClbHzgqM89qM0ZJkiRJkiRJAzem7QAkabSqbckWRMQY4BTgKuAdmbk/cDrwDPCziBgTEWMjYqXOda0FLUmSJEmSJGmZmJCRpJY05sbsTamM+WZm3lPbo5wEnA38T22PsjPw2YhYvu+8GUmSJEmSJElDnwkZSWrfPGAS8FD9+nOUuTFfzszZ9dibgbdS5shIkiRJkiRJGmbGtR2AJI1GfQYDPwpMAF4eEWsBBwKHAw/Uc9cB1gP+kJn3tRCuJEmSJEmSpAEKO99I0uCJiEnAs5m5oM/xS4AtgDnArMzcprF2IKV92e6ZefkghitJkiRJkiSpS2xZJkk9FhFj6p8bAycAp0XEys014GTgEWDDcjj2iohNIuIU4J+Aq03GSJIkSZIkScOXFTKSNEgi4gfARsAJmTl9MevrUZIvOwGT6+H5wLnAiZn54CCFKkmSJEmSJKnLTMhIUg91ZsVExHHAR4BjM/PcujY2MxfWz1fIzOfq568FNgAS+F1m3t5K8JIkSZIkSZK6xoSMJPVYbU92F3Ae8LnMfKqxtjpwBPBu4P+AS4GLMnNeC6FKkiRJkiRJ6pFxbQcgSaPAtpSZXTf1ScZsCpwFvAWYBawLvBfYHDh2kGOUJEmSJEmS1ENjln6KJGmAZgGvBP7YORARb6QkY7YGTgL+BtgFuB74eETsPPhhSpIkSZIkSeoVK2Qkqfceqx8fjQiAR4CzgS2BDwNfzsy5wK8jYjngbcAq7YQqSZIkSZIkqRdMyEhSj2XmLyPiDGAqsBMQwLOUeTL/DhARYzJzETAWeAqY2Fa8kiRJkiRJkrrPhIwkDYLMPDEirgD+AZgNXAzcDhAR4zNzfkSsAGxF+dl8RWvBSpIkSZIkSeq6yMy2Y5CkES1qn7KsP3AjYmxmLoyIyMYP4Yh4J/Al4OLM/Gg70UqSJEmSJEnqBRMykjRIGm3JFrc2Bfg4sDyw9ZLOkyRJkiRJkjQ8jWk7AEkaLV4kGfNa4EJgEXCUyRhJkiRJkiRp5LFCRpKGgIjYFHguM+9tOxZJkiRJkiRJ3WdCRpK6KCImZeZT/bzmebNkJEmSJEmSJI08tiyTpAGKiLH1zyOBcyJilcWcE0u63mSMJEmSJEmSNPKZkJGkAajVLQsjYhzwWeBZyiyY5+kkXSLCn7uSJEmSJEnSKDSu7QAkaZgLIIEzgCeAczLzaSjty4DXA6sDv8nMWzJzUa2oWWRljCRJkiRJkjR6mJCRpGVUq2MWRcRrgEOBjwF31bX9gY8AmzXO/y/g8My8Z/CjlSRJkiRJktQmW+dI0jJqVLh8BXgQ+Elmzq4JmmnAbGCP+nEqsClwW0Ts1Ea8kiRJkiRJktoTdsyRpGUXEa8ArgS2Ai4CTqAkX1YBPtCphomICcAUSvLmOuB9mfmCWTOSJEmSJEmSRiYTMpI0ABExBlgb2A04BliVUn24N3BxZmZEjM3MhfX8TwPHA3+ZmQ+1FLYkSZIkSZKkQWbLMkkagMxclJm/A84A3gF8EfgVMKvT0iwzF9bEDcAc4AngFW3EK0mSJEmSJKkdVshIUhdFxMrABpl5a+NY1EqZlYHPAu8CXpeZz7UVpyRJkiRJkqTBZYWMJHVRZj7dTMbUY53M9w6UVmbTTMZIkiRJkiRJo4sVMpI0CCJiT+CfgdmZ+ca245EkSZIkSZI0uKyQkaQeq63K9gTuBw5vORxJkiRJkiRJLbBCRpIGQUSMB9bMzPvbjkWSJEmSJEnS4DMhI0mSJEmSJEmS1GO2LJMkSZIkSZIkSeoxEzKSJEmSJEmSJEk9ZkJGkiRJkiRJkiSpx0zISJIkSZIkSZIk9ZgJGUmSJEmSJEmSpB4zISNJkiRJkiRJktRjJmQkSZIkSZIkSZJ6zISMJEmSJHVBRJwbEfe1HYckSZKkocmEjCRJkqRRJyIOi4iMiJv7ed1aEfGpiNiiS3FsUh9v3W48niRJkqShy4SMJEmSpNFoH+A+YOuIWL8f160FfBLYYjFrBwEb9jOOTerjrdvP6yRJkiQNMyZkJEmSJI0qEfFq4E3Ax4BHKcmZpV0zLiKWe7FzMnN+Zs7tTpSSJEmSRhoTMpIkSZJGm32AJ4ErgIvok5CJiHVrO7NjIuIjEXEvMBc4DPhZPW16PScjYv963QtmyETEXhFxW0Q8ExFPR8QvIuKourY/cGE99drG423bg+9ZkiRJUsvGtR2AJEmSJA2yfYCLM3NeRJwPHBoRb8jMn/U57wBgIjCNkpC5BFgJ+HQ9dkM976bFPUlEbA+cD1wNHFsPbwy8GTgD+DFwJvBh4CTgV/WcXyFJkiRpxDEhI0mSJGnUiIjXAxsBR9ZDNwIPUJI0fRMyfwmsn5mPNq6/kpKQ+UlmnreUp9sJeBrYMTMX9l3MzN9ExA2UhMyPMvO6/n9HkiRJkoYLW5ZJkiRJGk32AR4BrgXIzAS+A+wVEWP7nPvdZjJmGcwCVgS2H8BjSJIkSRohTMhIkiRJGhVqwmUvSjLm1RGxfkSsD9wMrAG8vc8lvx3gU54N/Bq4MiIeiIivRcQ7B/iYkiRJkoYpEzKSJEmSRou3Aa+kJGXuaXxcUNf36XP+7IE8WWbOBLYApgCXAdtRkjNfH8jjSpIkSRqenCEjSZIkabTYB5gJHL6YtV2A90XEIUt5jOzPE2bmPOBy4PKIGEOpmjk4IqZm5v/19/EkSZIkDV8mZCRJkiSNeBGxPCXpcmFmXrSY9YeAvSnVLDe/yEM9W/9c5SU85+TMfLzzdWYuiog76pcT+vt4kiRJkoY3EzKSJEmSRoMpwEqU1mGL81PgUUoVzYslZO4FZgGHRMQzlITKzZm5uHkzX4mI1YBrgAeAVwFHAj8HflXP+TmwEDg2IiYBc4FrarszSZIkSSOIM2QkSZIkjQb7AHOAHy1uMTMXAVcA7wQmL+lBMnM+8EFKEuUc4HzgrUs4/bz6nIdRWpV9EPgO8K76fGTmw8AhwOrAV+vjbdK/b02SJEnScBCZtiyWJEmSJEmSJEnqJStkJEmSJEmSJEmSesyEjCRJkiRJkiRJUo+ZkJEkSZIkSZIkSeoxEzKSJEmSJEmSJEk9ZkJGkiRJkiRJkiSpx0zISJIkSZIkSZIk9ZgJGUmSJEmSJEmSpB4zISNJkiRJkiRJktRjJmQkSZIkSZIkSZJ6zISMJEmSJEmSJElSj5mQkSRJkiRJkiRJ6jETMpIkSZIkSZIkST32/zmYCrbLRTuTAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -533,14 +548,6 @@ } ], "source": [ - "low_dvl = df.iloc[:30]\n", - "plot_shapley(\n", - " low_dvl,\n", - " level=0.05,\n", - " title=\"Artists with low values\",\n", - " xlabel=\"Artist\",\n", - " ylabel=\"Shapley value\",\n", - ")\n", "plt.show()" ] }, @@ -555,7 +562,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -574,14 +581,14 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Improvement: 13.910043%\n" + "Improvement: 13.951589%\n" ] } ], @@ -630,12 +637,30 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "high_dvl = df.iloc[-30:]\n", + "ax = plot_shapley(\n", + " high_dvl,\n", + " title=\"Artists with high values\",\n", + " xlabel=\"Artist\",\n", + " ylabel=\"Shapley value\",\n", + ")\n", + "ax.get_xticklabels()[high_dvl.index.get_loc(\"Rihanna\")].set_color(\"red\");" + ] + }, + { + "cell_type": "code", + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -647,14 +672,6 @@ } ], "source": [ - "high_dvl = df.iloc[-30:]\n", - "ax = plot_shapley(\n", - " high_dvl,\n", - " title=\"Artists with high values\",\n", - " xlabel=\"Artist\",\n", - " ylabel=\"Shapley value\",\n", - ")\n", - "ax.get_xticklabels()[high_dvl.index.get_loc(\"Rihanna\")].set_color(\"red\")\n", "plt.show()" ] }, @@ -665,20 +682,9 @@ "Let us take all the songs by Rihanna, set their score to 0 and re-calculate the Shapley values." ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "
\n", - "\n", - "Notice that we use a new name for the `Dataset`, in order to trigger usage of a different cache. Reusing the old one would be a mistake because modifying even just one label changes all the Shapley values, which means that we cannot reuse any utility computations.\n", - "\n", - "
" - ] - }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -695,15 +701,12 @@ " model=GradientBoostingRegressor(n_estimators=3),\n", " data=grouped_anomalous_dataset,\n", " scorer=Scorer(\"neg_mean_absolute_error\", default=0.0),\n", - " enable_cache=True,\n", ")\n", "values = compute_shapley_values(\n", " anomalous_utility,\n", " mode=ShapleyMode.TruncatedMontecarlo,\n", " done=AbsoluteStandardError(threshold=0.2, fraction=0.9) | MaxUpdates(1000),\n", " n_jobs=-1,\n", - " worker_update_period=0.5,\n", - " coordinator_update_period=1,\n", ")\n", "values.sort(key=\"value\")\n", "df = values.to_dataframe(column=\"data_value\", use_names=True)" @@ -718,12 +721,30 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 19, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "low_dvl = df.iloc[:30]\n", + "ax = plot_shapley(\n", + " low_dvl,\n", + " title=\"Artists with low data valuation scores\",\n", + " xlabel=\"Artist\",\n", + " ylabel=\"Shapley Value\",\n", + ")\n", + "ax.get_xticklabels()[low_dvl.index.get_loc(\"Rihanna\")].set_color(\"red\");" + ] + }, + { + "cell_type": "code", + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABmQAAALBCAYAAABGGc5jAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd5wkZZ348c93WWCVLAaWBRwERfROVMzImQOO6TjMCSNmMJyOP/UAE+OdAfAM6HmiZ3ZFwRtREUSXNeOJCTzTKCuLYiIKHLvP74/naae2t2emZ6aru6vn83696jXdVdXd36quqa56vk+IlBKSJEmSJEmSJEmqz4pBByBJkiRJkiRJkjTqTMhIkiRJkiRJkiTVzISMJEmSJEmSJElSzUzISJIkSZIkSZIk1cyEjCRJkiRJkiRJUs1MyEiSJEmSJEmSJNXMhIwkSZIkSZIkSVLNTMhIkiRJkiRJkiTVzISMJEmSJEmSJElSzUzISJIkaWRExH0jIkXEcYOOpS4RcWTZxiMX+LoUEef2KIbpiJjuxXv1W0SMlX1x6qBjGRaLPab6ocnHmiRJktTOhIwkSZJqFxGvLgW+KSIOWML71FqYPswF0/Ox4Lq/lkPyrx8i4tyISIOOQ5IkSeqHlYMOQJIkSaMtIgJ4FpCAAJ4NvLymj/s2cCDwh5refxh8BvgmsHHQgUh98IBBByBJkiT1ii1kJEmSVLcHA2PAB4FLgadFxHZ1fFBK6ZqU0kUppZFNyKSULi/bePmgY5HqllL6RUrpF4OOQ5IkSeoFEzKSJEmq27PL3/cBHwFuCvxjpxUj4rjSDdR9I+KJEfGtiLiqdMd1HPCrsurTKl2g/a2Lsdm6kYqIW0XEeyPi5xHx14j4U0T8MCLeExG7l3XOBT5QXvKBtvcfK+vsFBGvjYgfRcQVEXFlRPwiIj4REQfPtyMi4mPl/W7dNv+DZf7ZbfN3ioj/i4ivVeZt0a1aa5uBWwK3bIv71A4x3LTsi40RcV1E/Dginj5f7N2IiO0jYqLs22vKPloXEY9tW2/HiLg+Ita3zb9RRFxbYn9K27LnlfnP6DKWnSLibRGxobznRRHxUma5B4qI20TEZER8NyIuK/vm12Vf7dW27qnAV8rTY9v2+X3LOrtExD9HxDklhuvL+54REffsZhvK+3yhvO9Bsyx/XFn+lsq8gyPipIi4oBzr10bEzyLirRGx2wI+e9ZxhyLi1Or/RmX+kRHx6Yj4ZflfuyIi1kfEk9vWGyvH7X0qn5XaPzNm6Yqv22Ot+lkl5rGI+HhE/KHsl+9GxMO73Sfl/Q6NiM+V7/W6iLg0Ir4ZEcd2WPfGEfHK8jlXRj6fXRgRJ0fELdrWXR0R7yzb3DpeTosO55aonAci4qGRu367PCrdv0XEyoh4fontirKf/iciXhgRW/0fRMQjI+LsmDk3XBIRX42I5y9k/0iSJGl2dlkmSZKk2pQCx0cC/5tS+npEXAG8DHgO8Ik5Xvoy4EHA58gF37sA5wK7AkcDFwCfraz//TliWA18B9gZ+DzwaWAVsC/wFODfgT8CpwJ/AR4FnN72nn+JiAC+ANwL+AbwH8ANwF7A/YB1wPlzbBPA2cDjyd0w/awyv9Ut070iYlVK6dry/D7ka/YtEjVtpoHjgWPK8xMry76/5arsCqwHrgfWAtsDjwH+MyI2p5Q+OE/8s4rc6umLJeaLgHcCNwaOAD4REXdMKf0/gJTSVRHxbeDuEbFTSunK8jaHlJgg75P/qnxEax/NtS9asWxf1rsr+Vj5CHnbX1vi6+Rw4Lnk4+3r5H10e3J3e4+IiLuklH5b1v1s+fs04KvkY7Nluvw9EHgj8DVgCvgzsA/5/+GwiHhESukL820LuWXZQ4Cnkv8v2j2t/D21Mu/Z5KTnV4Evk5NQBwMvLZ9998o+77V3Az8mb/dGYHfgYcB/RcQBKaXXlvX+Qj5ujyQnE4+vvMf0XB+wkGOtzS3J3Rr+knxs3QR4HHB6RDwwpfSVDq9p/+yHkr/PK4AzgN+W9zkQeH51O0ry6yvAQcBPgf8kH1f7AU8HTgN+V9bdFzgP2BM4B/gYsDf5/3M8Iv4ppfTfHUI6AngocCbwnrKNRMS25PPnQ8pnfxS4lnyuegdwd/L5rxXrc4BTyK0YP0fu9vHmwB1KrO+ab99IkiSpCyklJycnJycnJycnp1omYII8dsyrKvO+C2wG9u+w/nFl/auBO3VYPlaWnzrL5923LD+uMu9FZd7RHdbfAbhR5fmRZd0jO6z792XZZzosWwHs1sX+uFV5j09V5h1Q5n2p/H1AZdnby7xD54uRXIg9PcdnpzL9B7BNZf7tyImlnyzge93qs4BXlff/PLCyMv/mZf0E3Ksy/3Vl3nhl3gkllrOBi9v27x+BX3QZ3/8r7/1pYEVl/r7AnzodQ8AaYPsO7/VgYBPw7vmOtbbluwA37TB/L+AS4MIut2UVOXlxaXW/lmV7lP11ftv8W1a/48r8Z5aYX9k2f7ZjKgHnzhLXqWX5WNv8/Tqsu135Tv8PWNO27Fwg1XysjVWO/2Pb3ushrffq8vv4dFn/oA7Lbtr2/KNl3XdXj8OybEdgl8rzL5Z1X9223r3Kd/xHYMcO39lm4KEdYjmuLH8HW/6/bwO8vyx7VGX++cB1wM3n2y4nJycnJycnJ6fFT3ZZJkmSpFqUFiXPIhcYfqiy6FQgmOnKrJP3ppT+p8ch/bV9Rkrp6pTSVvMX8T6bU0p/nu+FKaVfkguM71f2D8y0/PgXcsF/dRDzB5CTU99cYIyzuQZ4aUppUyWmn5BbzRwYETsu4b2fQS7kfWlK6YbK+/8eeH15+qzK+q2WLu3bez655cBeEXGbMv+O5FYI87aOKZ5OPu5ekVLaXInlV8DJnV6QUvptSum6DvO/RG7x8ZAuP7v1ustTh7GMUkobyK2TbhsR+3TxPtcCnwRu0SGGJ5ML2D/Y9ppfV7/jiv8kt+xY0LYsROow3ktK6XpyK5aVbPl9L9ZCj7WWXwNvaIvti8BvgLstMIZO54G/fd8RcXNy65uNwMurx2FZ96pUxoGK3CXeg0sc/9q23tfJrWVuQm7F1e701NbSqnRH9iJyEu8lbf/vm8gtrRLwpLb3uoGcNJt1uyRJkrQ0JmQkSZJUl/uTu+Y5K8109QS51vj1wJGlW51Ovt3DOM4ArgLeWca2eE5E3L6SEOnWT8hdgD2hjInxioi4V+k+aSHOIXfjdMfy/P7AxpTSN8nJiAcARMTNgL8DzkspbVVIukg/Syld0WH+xeVv1+OLVEXETsD+wCUppYs6rHJO+XunyrxvkAu1W9u7C3BnctKltX6r8P7+be/TTSy/7ZQcYMvuxaqvi4h4ckR8uYzdcUNrTBNy66g18312h/c8JCI+GREXlzE5Wu/3orJKt+95avn7tLb5TyMXoH+07XO3LeOEnBd5DJlN5XM3k7vuW/C2dCsi9injoFxUxixpbfOnyypL+uxFHmst358lUXUx3R/7Hyl/vxV5DKrHRdsYQ8VdyffbX0spXT3Pe7ZiXTfL//pc29TpXHkbcgLnSuA1kcfm+ttE7t7wr+Ru1lo+Qu727ScR8faIeHQ5B0mSJKmHHENGkiRJdXlO+XtqdWZK6U8R8Tngn8jjtazt8NpLexVESunXEXE3chc+D2WmlvnFEfGWlFLHFhMd3mdTRNyf3JLlCODNZdGVEfFBcrdsV3XxVmeTa/g/ICIuII/p8PnKsleU5MT9yS2Jum0V0o2/zDK/1cpgm0W+7y7l78ZZlrfm79qakVK6PiLOAx5YCn7vVT7/7JTShRGxkZyQeXf5m+giIVOJ5XezLJ/t2HobuaB6I7n7qN8y0wriSMrYHN2KiH8kH9vXAmcBvyC3dtpM7u7sPsyMlzOnlMdf+l/gkRGxW0rpzxFxZ3LC7rMdWjB8gjyGzC/J4yFdSu6OirKNXX3uQkXErcgJgt3IYyp9Cbic3PJrjJxAWupnL/hYq/jLLK+5gS4rK6aUTouIh5NbmTwDOAogIs4nnwPOavv83271JltbyjZ1Op53L39vDRw7x+f+rUVcSultEfEH8jg4LyYfJykivgr8c0rpu3O8jyRJkrpkQkaSJEk9VwrYH12efiwiPjbLqs+hc0Im9TKelNKFwOMiYiV5gO0HklspnBQRV6eU3t/l+/wZeAnwkojYn1yofhTwQnJh6VNmf/XftJIKDyyPq11xnUMeH+N+zLQO6SYJMWiXl797zLJ8ddt6LecADyJv673IyYv1lWWHRcT2wKHAj0uXVN3GcotZlm8VY+le6sXAj8hjj1zZtvwJXXxuu9eTW4LdpRx/1fc7hXzsLMSHyN1tPY48eHurtcwW3ZVFxF3IyZgvA4dVu/QqXVm9YgGfmZj9nnHXDvNeSk4GPD2ldGpbXE9g6xY+i7HYY61nUkpTwFRE7ADcHXg48DzgvyPiTqUbwL+U1btpEbSUbep0rmyt95mUUqduzjpKKX0I+FBE7Er+f/xHctLpixFx25TSZd2+lyRJkjqzyzJJkiTV4WnkgbzPJw8g3Wm6jNw6Yt8FvG+ru6FFteRIKd2QUjo/pfRmoFXI/ujFvH9K6eclkXMfcpdoj+oyhkvJ3Z8dSm6xAzMJmfXklgwPILeQ+TPQ7Vg6m7qJuw4lgfELYE1E3LrDKvcrf7/XNr86jsz9ga+XMVNay25CLujegS5bCpVYfl5i2a/DKvftMO9W5HujL3VIxuxVlreb71jZH/hJh2TMCuDes27A7D5Ebl3ztNLV3xOAPwBTHT4X4IxqMqa4G3CjBXzmn4G922dGxDbMdLnX6bM/3WHZbAmoTZX3nNcSjrWeK2NQnZNSeinwJvI577Cy+Nvk7+sfSuJmLq3/8XuXpHG7hW7TReSE0D3m6BZyVimlv6SUPp9Seja5heNNgH9Y6PtIkiRpayZkJEmSVIdnl7/PTyk9q9MEnELukqvT4Nuz+TO5Rvi8g6G3RMTBpQuwdq0WFNdU5v2x/N3q/SNi39IlU7vdyN0wbTXI9xzOIY/XcDR5XJeLAVJKfyWPrfJY8vg757YPBj6HPwI3i4iFFLj30n+Sv89/qxauR8RNgddW1qn6Hrk2/6OA27Nl0qXVMuhVbc+78QHyvc6bSwKkFcu+5JYw7abL33u3xb4j8D46txKZ9VipvOetI2LPyvsFueu823WzEVXlGDkHuAf5uLkZ8NEOY45Ml7/3rc4srYDeucCP/TawT0Q8uG3+a+jchdtsn/0QZv8/n28/drKYY60nIuIfZkmabHE+Ka1JPk5u3fKW6nFY3mfH1nkppbSB3K3dGLmrsOp6dweeSD73faabGEsi7h3ls0/udE6IiNURcbvK8/uV47PdzavbJUmSpKWxyzJJkiT1VETclzyo9A9TSp0GnG55P/Bq4OkRcWyH2vxbSSldFRHfAg6NiI8A/0uuYX9GSukHs7zsKcBRZbySX5ALNvcDHkFujXJiZd1vkAsej4mI3ZkZn+Ed5K7OTouI7wAXApeQC8UfBWzLzJgy3Tib3M3ZzYHTOiy7b+XxQt7zrsAXIuJr5G27IKX0uQW8x1K8hdw64FHABRHxeXLS6THk7fzXlNJ51ReUcXnOZaZ10dmVZb+OiF+Qv6tNwFcXEMtbyS2f/gn4XkR8kdzF1mOBrwGPbIvj0oj4OPB44PsR8SXyuB4PInej9n22bhHyU/L4II+PiP8Dfk1OFv5XSunXwNvJXYv9T0R8Gvg/4BByMuZz5ONvoT5I7uruTZXn7b5Dbml1eER8HTiPnCw4rMR8yQI+7y3AQ4DTI+ITwJ/IXVntC5zL1q2N3gU8HfhURKwtn/V35JZgnyR3t9bubPIxclo5Zv4K/Dql9F/zxLWgY62HTia3zllPTkBdDxxMbuH1a3ISpuWF5O1/LnDfchxeT95/DyEfh+eWdZ9L/t7+rSTAvktunfQYckubp7e33prH68nnrOcCj4iIc8jH683JY8scQj7//qSs/xngqoj4ZtmuILfiuyu5peOXF/DZkiRJmoUtZCRJktRrrdYx/zHXSimlaXIh32oWVjj9FHI3TQ8lD1j9euDOc6z/MXK3OzcnF8gfU9b/OHl8j29UYvozuRD/J+SB3F9fpt3IBaST5AHAH0oe1PswcmHlw1JKb1vANpxLLmSFrVt+dGol0o03kBMA+5FblbyevC19kVK6npzAeHWZ9SJy13U/A56YUnrlLC9tbe8V5H3cadn5KaWuxwRJKV1HTly8nZw0O5rcZdYbyGMAdfJMcqLjRsALyAXm/01OQGz12SmlTeQxNs4jF5ofT97n+5blp5CTExvJ++FJwMXkMUcW253WaeT9tC3wo5TSVu9T4nok8G5gT3KLoHuT/x8fQk4MdSWldDY5sfVjcrLqaeTC+ruRkw/t6/+A3L3W14FxcndzOwOHk4/NTv4DOIGcAHsFeR8+c564Fnus9cKbyOet25Nb/TyXnPB6E3DXcg5pxfln8vHzGvJ+fw55n9ye3ILnJ5V1fwnchbyfDgBeTj6/fAE4JKV0+kKCLC2nHg08lZyIezj5nPVQcjnAa4GPVF4yQU7m3Rl4PvnY3RZ4JXC/Di2xJEmStAiRUk/HS5UkSZIkSZIkSVIbW8hIkiRJkiRJkiTVzISMJEmSJEmSJElSzUzISJIkSZIkSZIk1cyEjCRJkiRJkiRJUs1MyEiSJEmSJEmSJNXMhIwkSZIkSZIkSVLNVg46gKaJiAD2BK4cdCySJEmSJEmSJGko7ARcklJKs61gQmbh9gQ2DDoISZIkSZIkSZI0VPYCfjvbQhMyC9dqGbMXtpKRJEmSJEmSJGm524nckGPOnIEJmcW7MqV0xaCDkCRJkiRJkiRJg5NHOpnfiprjkCRJkiRJkiRJWvZMyEiSJEmSJEmSJNXMhIwkSZIkSZIkSVLNTMhIkiRJkiRJkiTVzISMJEmSJEmSJElSzRqfkImIF0TEdERcGxHfioi7zbP+YyLiorL+DyPiYf2KVZIkSZIkSZIkLU+NTshExOOAtwHHA3cGLgC+GBE3n2X9ewEfA94P3An4LPDZiPi7vgQsSZIkSZIkSZKWpUgpDTqGRYuIbwHfSSm9sDxfAVwMvCOlNNlh/U8AO6SUHl6Z903g+yml53b5mTsDlwO7pJSu6MFmSJIkSZIkSZKkhuo2b9DYFjIRsR1wMPDl1ryU0uby/J6zvOye1fWLL86xPhGxfUTs3JqAnZYUuCRJkiRJkiRJWnYam5ABbgpsA/yubf7vgD1mec0eC1wf4FXkzFZr2rDgSCVJkiRJkiRJ0rLW5IRMv5wA7FKZ9hpsOJIkSZIkSZIkqWlWDjqAJfgDsAm4Rdv8WwCXzvKaSxe4Piml64DrWs8jYsGBSpIkSZIkSZKk5a2xLWRSStcD5wMPaM2LiBXl+Tdmedk3qusXD5pjfUmSJEmSJEmSpCVrcgsZgLcBH4yI7wLfBo4BdgA+ABARHwJ+m1J6VVn/JOCrEfEyYAp4PHAX4Dl9jluSJEmSJEmSJC0jjU7IpJQ+ERE3A14H7AF8H3hoSul3ZZV9gM2V9b8eEU8E3gC8CfgZ8OiU0o/6GrgkSZIkSZIkSVpWIqU06BgaJSJ2Bi4HdkkpXTHoeCRJkiRJkiRJ0uB0mzdo7BgykiRJkiRJkiRJTdHoLsskSZIkSZIkSRoWYxNTq4HVS3iLjdOT4xt7FY+GiwkZSZIkSZIkSZJ64yjg2CW8/njguN6EomFjQkaSJEmSJEmSpN44BTijw/xVwPry+BDg2lleb+uYERYppUHH0CjdDs4jSZIkSZIkSRLA2MTUDsBV5emO05PjVw8yHvVWt3mDFf0LSZIkSZIkSZIkaXmyyzJJkiRJkjRQDoAsSZKWAxMykiRJkiRp0BwAWZIkjTwTMpIkSZIkadAcAFmSJI08EzKSJEmSJGmgSndjWyVVygDILRc4ALIkSWqyFYMOQJIkSZIkSZIkadSZkJEkSZIkSZIkSaqZCRlJkiRJkiRJkqSamZCRJEmSJEmSJEmqmQkZSZIkSZIkSZKkmpmQkSRJkiRJkiRJqpkJGUmSJEmSJEmSpJqZkJEkSZIkSZIkSaqZCRlJkiRJkiRJkqSamZCRJEmSJEmSJEmqmQkZSZIkSZIkSZKkmpmQkSRJkiRJkiRJqpkJGUmSJEmSJEmSpJqZkJEkSZIkSZIkSaqZCRlJkiRJkiRJkqSamZCRJEmSJEmSJEmqmQkZSZIkSZIkSZKkmpmQkSRJkiRJkiRJqpkJGUmSJEmSJEmSpJqZkJEkSZIkSZIkSaqZCRlJkiRJkiRJkqSamZCRJEmSJEmSJEmqmQkZSZIkSZIkSZKkmpmQkSRJkiRJkiRJqpkJGUmSJEmSJEmSpJqZkJEkSZIkSZIkSaqZCRlJkiRJkiRJkqSamZCRJEmSJEmSJEmqmQkZSZIkSZIkSZKkmpmQkSRJkiRJkiRJqpkJGUmSJEmSJEmSpJqZkJEkSZIkSZIkSaqZCRlJkiRJkiRJkqSamZCRJEmSJEmSJEmqmQkZSZIkSZIkSZKkmpmQkSRJkiRJkiRJqpkJGUmSJEmSJEmSpJqZkJEkSZIkSZIkSaqZCRlJkiRJkiRJkqSamZCRJEmSJEmSJEmqmQkZSZIkSZIkSZKkmpmQkSRJkiRJkiRJqpkJGUmSJEmSJEmSpJqZkJEkSZIkSZIkSaqZCRlJkiRJkiRJkqSamZCRJEmSJEmSJEmqmQkZSZIkSZIkSZKkmpmQkSRJkiRJkiRJqpkJGUmSJEmSJEmSpJqZkJEkSZIkSZIkSarZykEHIEmSJEmSJEmSBm9sYmo1sHoJb7FxenJ8Y6/iGTUmZCRJkiRJkiRJEsBRwLFLeP3xwHG9CWX0mJCRJEmSJEmSJEkApwBndJi/ClhfHh8CXDvL620dMwcTMpIkSZIkSZIkidLd2FZJlbGJqR0qTy+Ynhy/un9RjY4Vgw5AkiRJkiRJkiRp1NlCRpIkSZIkaZlzEGdJkupnQkaSJEmSJEkO4qxlz8SkpLqZkJEkSZIkSZKDOEsmJiXVzISMJEmSJEnSMucgzhJgYlJSzUzISJIkSZIkSVr2TExKqtuKQQcgSZIkSZIkSZI06hrbQiYibgK8A3gEsBn4NHB0SumqOV5zLnCfttmnpJSeW1eckiRJ0rBy4FpJkiRJ6p/GJmSAj5BvHh8EbAt8AHgv8MR5Xvc+4F8qz6+pJTpJkiRp+DlwrSRJkiT1SSMTMhFxIPBQ4K4ppe+WeS8CPh8RL08pXTLHy69JKV26gM/aHti+MmunxcQsSZIkDSEHrpUkSZKkPmlkQga4J/CXVjKm+DK567K7A5+Z47VPiognA5cCnwNen1Kaq5XMq1harUFJkiRpKDlwrST1hl1ASpKkbjQ1IbMH8PvqjJTSDRHxp7JsNh8Ffg1cAtwBeDNwAHD4HK85AXhb5flOwIZFxCxJkiRJkkaTXUBKkqR5DVVCJiImgVfOs9qBi33/lNJ7K09/GBEbgbMjYr+U0i9mec11wHWVGBf78ZIkSZIkaTTZBaQkSZrXUCVkgLcCp86zzi/J3Y3dvDozIlYCNynLuvWt8nd/oGNCRpIkSZIkaS52ASlJkrqxYtABVKWULkspXTTPdD3wDWDXiDi48vL7k7fnWx3fvLM7lr/WRJEkSZIkSZIkqbNqLuHQsYmpbQYWSYMNVUKmWymlC4EvAO+LiLtFxCHAvwMfTyldAhARayLiooi4W3m+X0S8NiIOjoixiHgk8CHgaymlHwxqWyRJkiRJkiRJGlZjE1OHAxdWZp0JTJf5WoBGJmSKJwEXAWcDnwfOA55TWb4tcABw4/L8euCBwJfK694KfBp4RJ/ilSRJkiRJkiQtT41sYVKSLmuBPdsWrQHWmpRZmGEbQ6ZrKaU/AU+cY/k0EJXnFwP3qT8ySZIkSZIkSeq/sYmp1cDqJbzFxjIu1kA0Pf7ZlKTFyZVZZwIbxiamjp6eHD9tQGHNqySNTipPo21xAAk4cWxi6vTpyfFNfQ2uoRqbkJEkSZIkSZJGxagWRKvvjgKOXcLrjweO600oi9L0+LdSaWHSrtXC5IghTsocCuw1x/IA9i7rnduPgJrOhIwkSZIkSZI0eCNXEK2BOAU4o8P8VcD68vgQ4NpZXj/opF7T49/CCLQw6TZJvJRk8rJiQkaSJEmSJEkavJEqiNZglFZSWx0LYxNTO1SeXjA9OX51/6LqXtPj76DpLUy6Pa94/umSCRlJkiRJkiRpwEawIFpS81uYrAM2kLtXa2/hA7mFz4aynrqwYtABSJIkSZIkSZI0ghrdwqR0o3Z0eZraFreeHzOk3a0NJRMykiRJkiRJkiT1XquFSXsyoyUBFzPELUymJ8dPA44ALmlbtAE4oixXl0zISJIkSZIkSZLUY6PSwqQkXQ6szDoM2NdkzMKZkJEkSZIkSZIkqQYj1MJkc+XxumFPIg0rEzKSJEmSJEmSJNXEFiZqMSEjSZIkSZIkSVK9bGEiEzKSJEmSJEmSJEl1MyEjSZIkSZIkSZJUs5WDDkCSJEmSJElairGJqdXA6iW8xcbpyfGNvYpHkqROTMhIkiRJkiSp6Y4Cjl3C648HjutNKJIkdWZCRpIkSZIkSU13CnBGh/mrgPXl8SHAtbO83tYx0nCrDr1x6NjE1FnTk+ObBhaNtEgmZCRJkiRJktRopbuxrZIqYxNTO1SeXjA9OX51/6KShkpjExpjE1OHAydXZp0JbBibmDp6enL8tAGFJS3KivlXkSRJkiRJkiQ1UUloXFiZdSYwXeYPtRLjWmDPtkVrgLVN2AapyoSMJEmSJEmSJI2gJic0xiamtgFOKk+jbXHr+YllPakRTMhIkiRJkiRJ0ogZgYTGocBebB17SwB7l/WkRjAhI0mSJEmSJEmzax9/ZVgTGO2antBY3eP1pIFbOegAJEmSJGmxxiamVrO0m/CNZSBoSZKkrTR8QPmmJzS6vUbzWk6NYUJGkiRJUpMdBRy7hNcfDxzXm1AkSdIoqYy/0q41/soRQ56UaXpCYx2wgby/O7XySWX5un4GJS2FCRlJkiRJTXYKcEaH+auA9eXxIcC1s7x+WAsgJEnSAHUx/koij79y+vTk+Ka+Bte9Ric0pifHN41NTB1NToolttyGVP4eM8T7v5HmaIG+qvL4oLGJqVmvr22BPjsTMpIkSZIaq9zsbXXDNzYxtUPl6QXTk+NX9y8qSZI0Alrjr8ymOv7Kuf0IaKFGIaExPTl+2tjE1BHkbuPWVBZtIMc+zC2UmqqbFujr51hmC/Q5mJCRJEmSJEmSpC01ffwVYDQSGmUbzgKuKLMOA84a5kRSw83WAr1bto6ZgwkZSZIkSdKyNUe3HN2yWw5JKkbsnNr08Vf+ZkQSGpsrj9c1LPZGma0FunrDhIwkSZIkaTnrpluOudgthyTNGKVzaqPHX+nAhIY0BEzISJIkSZKWs9m65VjFTP/ohwCzDlxbR1ALMWI10iU1W+PPqS2jMP6KpOFjQkaSJEmStGzN1i3H2MTUDpWnF0xPjl/dv6gWbJRqpEtqsBE5p/7NKIy/Imm4mJCRJEmSJKnZRqZGuiQNmxEZf0XSkDAhI0mSJElSg41ajXRJI2lF5fGhYxNTTUtoOP6KpJ5YMf8qkiRJkiRJkrRwYxNThwMXVmadCUyX+ZK0rJiQkSRJkiRJktRzJemyFtizbdEaYK1JGUnLjQkZSZIkSZIkST01NjG1DXBSeRpti1vPTyzrSdKyYEJGkiRJkiRJUq8dCuzF1smYlgD2LutJ0rJgQkaSJEmSJEkaXtXyu0Mb1KJkdY/Xk6TGWznoACRJkiRJkiRtrYyxcnJl1pnAhrGJqaOnJ8dPG1BY3drY4/W0DIxNTK2mc5JuVeXxQWMTU9fO8hYbpyfHPaY0tEzISJIkSZIkSUOmJGPWdli0Blg7NjF1xJAnZdYBG8jxduq2LJXl6/oZlIbeUcCx86yzfo5lxwPH9SwaqcdMyEiSJEmSJElDpHRLdlJ52p7MCHIy48SxianTpyfHN/U1uC5NT45vGpuYOpqcVEpsuR2p/D1mWOPXwJwCnLGE19s6RkPNhIwkSZIkSZI0XA4F9ppjeQB7l/XO7UdAizE9OX7a2MTUEeRu19ZUFm0gJ2OGuYVPIzW9y6/y2SZVNLJWzL+KJEmSJEmS1EjVsq9DS8uTJuh2oPtu1xuYknQ5sDLrMGBfkzG1OQo4v8NU7eZr/SzrnF9eL6kmtpCRJEmSJEnSyCljsJxcmXUmsGFsYuroBiQDum0h0JSWBJsrj9fZTVmt7PJLGmImZCRJkiRJkjRSSjJmbYdFa4C1YxNTRwx5UmYduVuvNWw9hgzkMVg2lPWkv7HLL2m4mZCRJEmSJEnSbNq7/Dpr2Fs3lG7JTipP25MZQU5mnDg2MXX6sG7L9OT4prGJqaPJSaXEltuRyt9jhi3+po9fIkl1cwwZSZIkSZIkbaW0MrmwMutMYLrMH2aHAnvRuWUJZf7eZb2hVVrwHAFc0rZoAzCsLXwcv0SS5mBCRpIkSZIkqR5NHVC+2uXXnm2LWl1+DXNSptuB7rtdb2BK0uXAyqzDgH2HNBkDefySg5cwndL/kCWpf+yyTJIkSVqEObrk6JZdckjSCGvygPIj0OVXt7+vTfkd3lx5vG5I9zng+CWSNB8TMpIkSdLiHAUcu4TXHw8c15tQJEnDZAQGlG91+TWbapdf5/YjoAVaR+7Waw2duy1LZfm6fgYlSZJdlkmSJEmLM1uXHIdU1jlklnXskkOSRlQXrUsgty4Z5u7LGt3lV2lBcnR5mtoWt54fM8wtTSRJo8kWMpIkacHsqkmavUuOsYmpHSpPL5ieHL+6f1FJkoZA01uXwAh0+TU9OX7a2MTUEeRu49ZUFm0gJ2OGuYWSJGlEmZCRJEmLYVdNktQDJrilkdTo1iXFSHT5VZIyZwFXlFmHAWfZMkaSNCgmZCRJ0mKcApzRYf4qYH15fAhw7Syvt/BQkjIT3NLoGYXWJZvGJqaOJo+Dk9gyKdO0Lr82Vx6va0jMkqQRZUJGkiQtmF01SVLPmOCWRs8otS6xyy9JknrIhIwkSZIkDYgJbmn0jFLrErv8kiSpt1YMOgBJkiRJkqRZVMstDh2bmNpmYJEsQGk9cgRwSduiDcARDWtdYpdfkiT1iAkZSZIkSZJGUyOTGS1jE1OHAxdWZp0JTJf5Q68kXQ6szDoM2LdhyRhJktRDJmQkSZIkSRoxTU9mlDjXAnu2LVoDrG3KdmDrEkmSVGFCRpIkSZKkEdL0ZEZpyXNSeRpti1vPT2xaix9JkqSVgw5AkiRJktRcYxNTq4HVS3iLjdOT4xt7Fc9y10UyI5GTGacPcWuNQ4G95lgewN5lvXP7EZAkSVIvmJCRJEmSJC3FUcCxS3j98cBxvQlFjEYyo9sE31ISgZIkSX1nQkaSJEmStBSnAGd0mL8KWF8eHwJcO8vrbR3TW6OQzOj2mPDYkSRJjWJCRpIWyG45JEmSZpTrmq2ubcYmpnaoPL1genL86v5FtayNQjJjHbCBPOZNe7drkLtd21DWkyRJagwTMpK0cHbLIUmSpGHV+GTG9OT4prGJqaOBteR4q9uRyt9jhngMHEkNNUcFzFWVxweNTUzN2urTCpiS5mJCRpIWzm45JKkHbHEoSb03KsmM6cnx08Ympo4ATiYnl1o2kOM/bTCRSRpx3VTAXD/HMitgSpqTCRlJWiC75ZCknrHFoSTVYFSSGWU7zgKuKLMOA84a9mSSpEabrQJmt6wsJGlOJmQkSZIaaERal9jiUJJqMkLJjM2Vx+saGL+kBpmtAqYk9YoJGUmSpGZqfOsSWxxKUu1MZkiSJA0REzKSJEnNZOsSSarXisrjQ8cmpprYukSSJElDxISMJElSA9m6RJLqMzYxdTh5/JWWM4ENYxNTRzdl/BVJkiQNnxXzryJJkiRJ0vJQkjFrgT3bFq0B1pblkiRJ0oI1NiETEa+OiK9HxDUR8ZcuXxMR8bqI2BgRf42IL0fErWsOVZIkSZLUAGMTU9sAJ5Wn0ba49fzEsp4kSZK0II1NyADbAZ8C3r2A17wCeDHwXODuwNXAFyNiVe/DkyRJkqRFax+/pIkJgCZuw6HAXmydjGkJYO+yniRJkrQgjU3IpJSOTSm9HfhhN+tHRADHAG9IKZ2eUvoB8FRyM/RH1xWnJEmSJC1E6RLrwsqsM4HpJnWV1eBtWN3j9SRJkqS/WVJCJiK2j4h7RsSjIuKmvQqqJvsCewBfbs1IKV0OfAu452wvKtu4c2sCdqo9UkmSJEnL0iiMX9LwbdjY4/UkSZKkv1l0QiYiXky+CD0POA24Q5l/04j4Q0Q8ozch9swe5e/v2ub/rrKsk1cBl1emDb0PTZIkSdJyNwrjl4zANqwj3/OlWZYn4OKyniRJkrQgi0rIRMTTgROBLwDPpHKhnVL6A3AO8PhFvO9kRKR5ptsuJuYlOAHYpTLt1efPlyRJkrQ8jML4JY3ehunJ8U3A0eVpe1Km9fyYsp4kSZK0ICsX+bqXAaenlJ4YEbt3WH4+8OJFvO9bgVPnWeeXi3hfgEvL31uwZfPyWwDfn+1FKaXrgOtaz/NQNJIkSZLUc6Mwfknjt2F6cvy0sYmpI4CTyd2stWwgJ2NOG0xkkuYyNjG1ms7nllWVxweNTUxdO8tbbJyeHLc7QklSrRabkNmffHE6mz8BnRI1c0opXQZctsiY5vMrclLmAZQETBkT5u7Au2v6TEmSJEnq1iiMXzIK29BKypwFXFFmHQacZcsYaagdBRw7zzrr51h2PHBcz6JZBJNKkjT6FpuQ+Qtw0zmW346ZFim1iIh9gJsA+wDbRMQdy6Kfp5SuKutcBLwqpfSZlFKKiBOB10TEz8gJmtcDlwCfrTNWSZIkSepCa/ySNXTu8iuV5cM8fskobEPL5srjdSZjpKF3CnDGEl4/DImMxieVJElzW2xC5vPAcyLiXe0LIuL2wLOB/1xKYF14HfC0yvP/KX/vB5xbHh9AHvel5V+BHYD3ArsC5wEPTSnNVrNAkiRJUjNVx8s8dGxiauhbN0xPjm8am5g6GlhLTlxUExqNGL9kFLZBUjOVliHDkFRZilFIKkmS5rDYhMxrgG8BPwI+R76wflpEPAP4J/IPwOt6EuEsUkpHAkfOs060PU/Av5RJkiRJqkPjEgEdNHobxiamDmfLLpbPBDaMTUwdPezjf4zC+CWjsA2SNAgjklSSJM1hxfyrbC2ldAlwMPAF4HHkWk9PAR4BfAy4R0rpD70KUpIkSctKezJgm4FFskAlEXBhZdaZwHSZ3whN34YS51pgz7ZFa4C1TdiOkrA4sDLrMGDfJiUyRmEbJEmSpF5bVEIGIKX0+5TSs1JKNwFuQR50bLeU0jNSSr/vWYSSJElaNpqcDBiFREDTt6Ek704qT9vHL2k9P7EhSb5RGL9kFLZBkiRJ6plFJ2SqUkqXpZR+l1LaPP/akiRJ0taanAwYhUTAKGwDcCiwF50Hk6fM37usJ0mSJEl9tagxZCKimzFYUkrp9Yt5f0mSJC1aI8f+6CIZkMjJgNOHdHtaiYDZVBMB5/YjoEUYhW1Y3eP1JEmSJKlnFpWQAY6bY1li5qbZhIwkSVKfNHkgc5qfDBiFRMAobEO3AyE7YLIkSZJqMTYxtZrO18yrKo8PGpuYunaWt9g4PTnu9eqIWlSXZSmlFe0TObmzH/B24LvAzXsYpyRJkubQ5O6+iqYnA0YhETAK27AO2ECuHNZJAi4u60mSJEl1OAo4v8O0vrLO+lnWOb+8XiOqJ2PIAKSUNqeUfpVSejnwM+AdvXpvSZIkzW5Exv5oejJgFBIBjd+G0p3d0eVp+3a0nh8zpN3eSZIkaTScAhy8hOmU/oesfllsl2Xz+Rrw5preW5IkSVtqendfMJMMWEPnAdlTWT6UyYDpyfFNYxNTR5NbKbW68G1pRCJgFLYBYHpy/LSxiakjyN33raks2kCOf9i775MkSVKDle7GhrUimQasZy1k2twF2FzTe0uSJGlLTe/uayRaNpSC/iOAS9oWbQCOaEIiYBS2Af62HQdWZh0G7NuU+CVJkiSNpkUlZCLiqbNML46ItcAzyTXrJEmSVL+md/cFjEYyYBQSAaOwDUW1gti6YU7mSZIkSVoeFttl2alzLPsDMAm8bpHvLUmSVLuxianVLK3FyMbSFH0YNLq7r6rS3dRZwBVl1mHAWQ0rTB+FRMAobIP6ZI7z6arK44PGJqauneUthul82kh+B5IkSc2w2ITMvh3mJeDPKaUrlxCPJKlmI1YILS3FUcCxS3j98cBxvQllaUZl7I8KkwFSs3RzPl0/x7KhOZ82mN+BJElSAywqIZNS+nWvA5Ek9c3IFEJLS3QKcEaH+auYKbQ6BJi1NnEdQS2WA5lLGqDZzqfdGqrzaUP5HUiSJDXAYlvISJKaa6QKoaXFKi29tjqexyamdqo83Rn4VlNaaIxId1+SGma286n6x+9AkiSpGbpKyETEZma6u+hWSimZ8JGkITNHIfQOlacXTE+OX92/qKThMDYxdTi5hUnLmcCGsYmpoxvUwsTuviRJkiRJGkLdJkxex8ITMpIkqQPH8RlOJRmztsOiNcDasYmpIxqUlJEkSZIkSUOmq4RMSum4muOQJGk5cRyfITM2MbUNcFJ5Gm2Lg1wx5cSxianTbXEiSZIkSZIWwy7FJEnqP8fxGT6HAnvNsTyAvct65/YjIEmSJEmSNFqWlJCJiL2AOwG7ACval6eUPrSU95ckaRQ5js9Q6rYLuaV0NSdJW5mjG8tVlccHjU1MzZqktxtLSZIkqRkWlZCJiFXAB4F/IidiEjPde1THmjEhI0mSmqDbwkwLPSX1WjfdWK6fY5ndWEqSJEkNsdgWMm8CDgdeDXyD3HXH08iFFMcAewJPXXp4kiRJfbEO2ACsYesxZCBXONlQ1pOkXpqtG8tumSiWJEmSGmKxCZkjgA+klN4cEbuXeb9NKZ0DfDkizgFeADyvF0FKkiTVaXpyfNPYxNTRwFq2bPkLM61/j5meHN/U9+AkjbTZurGUJEmSNHq2GvelSzcHvl0e/7X8rfZ7/2lyCxpJkqRGmJ4cP41c6eSStkUbgCPKckmSJEmSpEVZbELmd8DuACmla4A/AwdUlu/MloNQSpKk5aF6bXHo2MTUNgOLZBFK0uXAyqzDgH1NxkiSJEmSpKVabJdl3wLuDby5PP8c8M8RsZFcEPMS4JtLD0+SJDXF2MTU4cDJlVlnAhvGJqaOHsaExtjE1GpgdYdF1UolVwAHjU1MdXqLjaWrIUmSJEmSpHktNiFzMvCYiNg+pXQd8FrgnsB/leW/AF7cg/gkjZg5CkC7ZQGoPI6GUEnGrO2waA2wdmxiahi7/DoKOHaeddbPsex44LieRSNJkhqry4oeB41NTF07y1t4fSpJ0jLQdUImItaSEy6fTymdB5zXWpZSujgiDgT+HtgEXJRSuqHXwUoaCd0UgM7FAlCBx9FQKd2SnVSeRtviABJw4tjE1OnTk+Ob+hrc3E4BzljC6y00kSRJLVb0kCRJ81pIC5lx4B+ByyPiU8BHUkpfay1MKW0GLuhxfJJGz2wFoKuYuUE5BJi15lgdQalxPI6Gy6HAXnMsD2Dvst65/QioG6UWqsfCAFmbWJI0QqzoIUmS5rWQhMzNgH8Cngg8A3hWRPwW+Cjw0ZTSD2qIT9KIma0AdGxiaofK0wumJ8ev7l9UahqPo6HTbfdxS+lmTqPJ2sSSpJFgRQ9JktSNrhMyKaWrgA8CH4yImwGPJydnXgH8c0T8BPgw8LGU0m/qCFaSJA2lbgsfLKTooRFpXWJtYkmShsSIXFtIkjTUFtJC5m9SSpcB7wDeERFjwJPICZoTgDdGxNeBD6eU3turQCVJ0tBaB2wA1rD1GDKQx5DZUNZT7zS+dYm1iSVJGiqNv7aQJGnYLSohU5VSmgbeSE7E3IH8A/woct/9JmQkSRpx05Pjm8Ympo4G1pKTL9WkTCp/j5meHN/U9+BGm61LJElSL3ltIUlSzZackAGIiNXAE8hdmN25zP5uL95bkiQNv+nJ8dPGJqaOAE4mt5Rp2UBOxpw2mMhGl61LJElSL3ltIUlS/VYs9oURsWtEPCsizgF+A7wF2AV4HXCblNLdexSjJElqgJJ0ObAy6zBgX5MxkiRJkiRJC2whExGrgEeSW8I8BNgeuAx4N3nMmG/3PEJJktQkmyuP19lNmSRJkiRJUtZ1QiYiPkQeG2ZH4Brg08BHgC+llCxskSRJkiRJkiRJmsVCWsg8ATiLnIT5TErpmnpCkiRJkiSpP8YmplYDqzssWlV5fNDYxNS1s7zFxjL2hiRJkjSnhSRk9kwpXVZbJJIkSZIk9d9RwLHzrLN+jmXHA8f1LBpJkiSNrK4TMiZjJEmSJEkj6BTgjCW83tYxkiRJ6spCWshIkiRJkjRSSndjJlUkSZJUuxWDDkCSJEmSJEmSJGnUmZCRJEmSJEmSJEmqmV2WSQ0zNjG1Gli9hLfYWLplkCRJSzDHb/KqyuODxiamrp3lLfxNliRJkqRlZFEJmYg4E/gv4DMppb/2NiRJ8zgKOHYJrz8eOK43oUjqsWrL1UPHJqbOmp4c3zSwaCTNp5vf5PVzLPM3WZIkSZKWkcW2kLkV8GHgqoj4DDk5c3ZKKfUsMkmzOQU4o8P8VcwU+hwCzFobt46gJC3N2MTU4cDJlVlnAhvGJqaOnp4cP21AYUma22y/yd3yN1mSJEmSlpFFJWRSSgdExF2BJwOPLX8vjYiPAh9JKX2/dyFKqipdm2xVgDM2MbVD5ekF05PjV/cvKmloNLKFSUnGrO2waA2wdmxi6giTMtLwme03WZIkSZKkTlbMv0pnKaXvpJSOJhcWPQw4h9xtw/kR8aOIeEVE7NWjOCVJmlNJalxYmXUmMF3mD62xialtgJPK02hb3Hp+YllPkiRJkiRJDbXohExLSmlzSumLKaWnAPuQa/jeDpgEpiPiyxExvtTPkSRpNpUWJnu2LWq1MBnmpMyhwF5snYxpCWDvsp4kSZIkSZIaaskJGYCIuHdEvAf4OfAY4EfAK4CXATcDzoiI1/XisyRJtWnv7qsRLTJGoIXJ6h6vJ0mSJEmSpCG06IRMRNwuIt4UEb8Cvgo8CvggcOeU0h1SSm9JKZ2UUjoIeD/wgt6ELEnqtaZ291U0vYVJt+NPOE6FJEmSJElSgy0qIRMR3wd+CBwDfBN4OLAmpfSylNL3O7zkK8BuiwtRklSnhnf3Bc1vYbIO2ACkWZYn4OKyniRJkiRJkhpqsS1k/gI8B9gjpfSElNKZKaXNc6x/OrDvIj9LklSTEejuCxrewmR6cnwTcHR52p6UaT0/pqwnSZIkSZKkhlpUQialdN+U0vtTSld0uf41KaVfL+azJEm1anp3XzACLUymJ8dPA44ALmlbtAE4oiyXJEmSJElSgy16DBmAiLhHRLwqIt4eEbcu824cEXeOiB17E6IkqUZN7+5rZFqYlKTLgZVZhwH7moyRJEmSJEkaDYsdQ2a7iDgNWA+8EXgxuQY1wGbgS8wUjkmShleju/tqGaEWJtXuP9cNexJJkiRJkiRJ3VtsC5nXAw8HngccQKWrm5TStcCngEctOTpJapbqOfXQIR93paXx3X212MJEkiRJkiRJw2yxCZknAO9OKb0X+FOH5RcCt1p0VJLUMGMTU4eTz30tZwLTZf7QGpXuvipsYSJJkiRJkqShtNiEzM2BH86xfBNw40W+tyQ1Skm6rAX2bFu0BljbgKTMqHT3JUmSJEmSJA2txSZkLgZuO8fyQ4CfL/K9JakxSrdkJ5Wn0ba49fzEYe++zO6+JEmSJEmSpHotNiHzUeCoiLhnZV4CiIhnA48FPrTE2CSpCQ4F9mLrZExLAHuX9Yad3X1JkiRJkiRJNVlsQuaNwNeBrwFfISdj3h4RvwFOAb4AvL0nEUpaLqrno0OHvUVJxeoerydJkiRJkiRpBC0qIZNSuh54KPB04JfARcD2wA+AI4FHpJSsWS2pK2WMlQsrs84Epod97JViY4/XkyRJkiRJkjSCFttChpR9OKX06JTS7VNKB6aUHp5S+lBKKfUySEmjqyRd1gJ7ti1aA6xtQFJmHbCB0m1jB4k87ta6vkUkSZIkSZIkaegsOiEjSUtVuiU7qTxtH4Ol9fzEYe6+rIyzcnR52p6UaT0/xvFYJEmSJEmSpOVtZTcrRcQ5i3jvlFJ6wCJeJ2n5OBTYa47lAexd1ju3HwEtxvTk+GljE1NHACeTW/a0bCAnY04bTGSSJEmSJEmShkVXCRlyS5qFdkPWXttdktp1O9B9t+sNTEnKnAVcUWYdBpxlyxhJkuo1NjG1ms7XCqsqjw8am5i6dpa32Dg9Oe5Yb5IkSZJq11VCJqV035rjkLQ8dVv40ZRCks2Vx+tMxkiS1BdHAcfOs876OZYdDxzXs2gkSZIkaRbdtpCRpDqsI3frtYbOrepSWb6un0FJkqRGOQU4Ywmvb0rFD0mSJEkNt6SETEQ8HHgYMFZmTQOfTyn999LCkrQcTE+ObxqbmDoaWEtOvlSTMq1uEo+xpYkkSZpN6W7MpIokSZKkobdiMS+KiF0j4ivA6cCzgNuX6VnA6RFxbkTs2rMoJY2sMuD9EcAlbYs2AEeU5ZIkSZIkSZLUaItKyAAnAYcCrwR2SyndMqV0S2A3YAK4d1mnNhHx6oj4ekRcExF/6fI1p0ZEapu+UGeckuZXki4HVmYdBuxrMkaSJEmSJEnSqFhsQubRwLtSSm9JKV3dmplSujql9G/Au8s6ddoO+FT5rIX4ArC6Mj2hx3FJg1L9fz50bGJqm4FFsjibK4/X2U2ZJEmSJEmSpFGy2DFk/g/46RzLLyrr1CaldCxARBy5wJdel1K6tPcRSYMzNjF1OHByZdaZwIaxiamjbWWiUTQ2MdVKqrdbVXl80NjE1LWzvMXGMuaAJEmSJEmS1BeLbSHzaeAxEbFVDfyIWAk8ltx6ZRjdNyJ+HxE/jYh3R8Tuc60cEdtHxM6tCdipT3FKXSnJmLXAnm2L1gBry3Jp1BwFnN9hWl9ZZ/0s65xfXi9JkiRJkiT1zWJbyHwY+Hfg6xHxXuDnZf6tgeeQuxP7SETcufqilNL3Fhtoj3wBOA34FbAf8CbgzIi4Z0pptu6RXgUc26f4VLM5atV3a6hq1ZduyVrjNUXb4gAScOLYxNTpdgGmEXMKcMYSXj80/8eSJEmSJElaHhabkPlq5fFdyYW+sGWBcHWdVsHwnGNaRMQk8Mp5PvvAlNJFXca5hZTSxytPfxgRPwB+AdwXOHuWl50AvK3yfCdgw2I+X0PhKJaWYDseOK43ofTEocBecywPYO+y3rn9CEjqh5IYNakiSZIkSZKkxlhsQubpPY1ixluBU+dZ55e9+rCU0i8j4g/A/sySkEkpXQdc13oe0d4IQQ0zW636Vcx0dXQIMOu4E3UEtQTdtvZZSqsgSZIkSZIkSdISLSohk1L6YK8DKe97GXBZHe/dSUTsBezO8BWyqyaz1aofm5jaofL0gunJ8av7F9WSdHvseoxLkiRJkiRJ0gCtGHQAixUR+0TEHYF9gG0i4o5l2rGyzkUR8Y/l8Y4R8W8RcY+IGIuIBwCnk8e/+eIgtkHqgXXkLvTSLMsTcHFZT5IkSZIkSZI0IIvtsoyIWAX8E3BnYBe2Tu6klNIzlxDbfF4HPK3y/H/K3/sxM1bGASU2gE3AHcprdgUuAb4EvLZ0SyY1zvTk+KaxiamjgbXk5Eu1T71WkuaY6cnxTX0PTpIkSZIkSZL0N4tKyETELYGvAGPAX8hJjz+REx3bAH8ArupFgLNJKR0JHDnPOlF5/FfgIXXGJA3C9OT4aWMTU0cAJwNrKos2kJMxpw0mMkmzGZuYWk3nsZ1WVR4fNDYxNet4VqULRkmSJEmSJDXEYrss+zdyEuYewG3ItfIfB+wIvBIw+SH1UUm6HFiZdRiwr8kYaWgdBZzfYVpfWWf9LOucX14vSZIkSZKkBllsl2X3B96VUvp2RNykzIvS9de/RcSBwInAeA9ilNSdzZXH6+ymTBpqpwBnLOH1to6RJEmSJElqmMUmZG4MTJfHV5DHqtilsvwbwFsWH5YkSaOrdDdmUkWSJEmSJGkZWWyXZb8B9gJIKd0A/JbcfVnL7YDZ+r2XJEmSJEmSJElaVhbbQuYc4FHA8eX5qcCrImI3cpLnKcCHlhydJEmSJEmSJEnSCFhsQmYSuGtEbF/GjXkTsCdwBLAJ+Cjw0t6EKEmShs3YxNRqYHWHRasqjw8am5iarcXsxtJ1myRJkiRJ0rKwqIRMSuk35G7LWs+vBZ5VJkmSNPqOAo6dZ531cyw7HjiuZ9FIkiRJkiQNucW2kJEkScvbKcAZS3i9rWMkSZIkSdKysuiETBkv5gnArYDdgGhbJaWUnrmE2CRJ0pAq3Y2ZVJEkSZIkSerSohIyEfEQYC2wA3AF8OcOq6UlxCVJkiRJkiRJkjQyFttC5q3ApcDhKaUf9jAeSZIkSZIkSZKkkbNika/bHzjZZIwkSZIkSZIkSdL8FttC5mfATr0MRJLUH2MTU6uB1R0Wrao8PmhsYuraWd5iYxk/RJIkSZIkSVKXFttC5jXA8yNirIexSINU/V84dGxiapuBRSLV7yjg/A7T+so662dZ5/zyekmSJEmSJEkL0FULmYg4ucPsy4ALI+Is4GJgU9vylFI6eonxSbUbm5g6HKge42cCG8Ympo6enhw/bUBhSXU6BThjCa+3dYwkSZIkSZK0QN12WfbCOZY9fJb5CTAho6FWkjFrOyxaA6wdm5g6wqSMRk3pbsykiiRJkiRJktRHXXVZllJasYjJLp801Eq3ZCeVp9G2uPX8RLsvkyRJkiRJkiQt1WLHkJFGwaHAXmydjGkJYO+yniRJkiRJkiRJi9Ztl2VziojbAo8BVgM/BT6QUrqiF+8t1Wh1j9eTJElqlLGJqdV0vtZZVXl80NjE1LWzvMXG0hWmJEmSJGkeXSdkIuKFwIuBe6WU/lCZ/wjgU8B2ldVfFBH3qK4nDaFuCw8sZJAkSaPqKODYedZZP8ey44HjehaNJEmSJI2whbSQeSTwi7ZkzErgP4BNwNOB7wLjwBuBVwMv6V2oUs+tAzYAa+jcbVkqy9f1MyhJkqQ+OgU4Ywmvt+KKJEmSJHVpIQmZ2wHva5t3P+BmwJtSSh8s834cEQcBD8OEjIbY9OT4prGJqaOBteTkSzUpk8rfY6Ynxzf1PThJkqQ+KN2NmVSRJEmSpD5YSEJmd+DitnkPIBdcf6Zt/nrg8CXEJfXF9OT4aWMTU0cAJ5NbyrRsICdjThtMZKPLvuolSZIkSZIkLUcLScj8Dtijbd6hwDXABW3zry+TNPRKUuYs4Ioy6zDgLFvG1Ma+6iVJkiRJkiQtOwtJyHwXeFpEvCOldGVE3B64G3B6SumGtnVvS25hIDXF5srjdSZjamVf9ZIkSZIkSZKWnYUkZI4HvgP8LCJ+DBxM7q7shA7r/iNwztLDkzRq7KtekiRJkiRJ0nK0otsVU0o/BO4PnA/sCXwTeFhK6fzqehFxX3I3Zp/qWZSSJEmSJEmSJEkNtpAWMqSUvg6Mz7POucDfLyEmSXMYm5haDazusGhV5fFBYxNT187yFhtLKxVJkiRJkiRJUp8sKCEjaSgcBRw7zzrr51h2PHBcz6KRJEmSJEmSJM3LhIzUPKcAZyzh9baOkSRJkiRJkqQ+MyEjNUzpbsykiiRJkiRJkiQ1iAkZSZIkSZI0UI6VKUmSlgMTMpIkSZIkadAcK1OSJI08EzKSJEmSJGnQHCtTkiSNPBMykiRJkiRpoBwrU5IkLQcrBh2AJEmSJEmSJEnSqDMhI0mSJEmSJEmSVDMTMpIkSZIkSZIkSTUzISNJkiRJkiRJklQzEzKSJEmSJEmSJEk1MyEjSZIkSZIkSZJUs5WDDkDqp7GJqdXA6g6LVlUeHzQ2MXXtLG+xcXpyfGPvI5MkSZIkSZIkjTITMlpujgKOnWed9XMsOx44rmfRSJIkSZIkSZKWBRMyWm5OAc5YwuttHSNJkiRJkiRJWjATMlpWSndjJlUkSZIkSZIkSX21YtABSJIkSZIkSZIkjToTMpIkSZIkSZIkSTUzISNJkiRJkiRJklQzEzKSJEmSJEmSJEk1MyEjSZIkSZIkSZJUMxMykiRJkiRJkiRJNTMhI0mSJEmSJEmSVDMTMpIkSZIkSZIkSTUzISNJkiRJkiRJklQzEzKSJEmSJEmSJEk1MyEjSZIkSZIkSZJUMxMykiRJkiRJkiRJNYuU0qBjaJSI2Bm4HNglpXTFoOOR1H9jE1OrgdUdFq0C1pfHhwDXzvIWG6cnxzfWEZskSZIkSZKk/uo2b7CyfyFJ0sg4Cjh2nnXWz7HseOC4nkUjSZIkSZIkaeiZkJGkhTsFOGMJr7d1jCRJkiRJkrTM2GXZAtllmSRJkiRJkiRJauk2b7CifyFJkiRJkiRJkiQtTyZkJEmSJEmSJEmSamZCRpIkSZIkSZIkqWYmZCRJkiRJkiRJkmpmQkaSJEmSJEmSJKlmJmQkSZIkSZIkSZJqZkJGkiRJkiRJkiSpZiZkJEmSJEmSJEmSamZCRpIkSZIkSZIkqWYmZCRJkiRJkiRJkmrWyIRMRIxFxPsj4lcR8deI+EVEHB8R283zulUR8c6I+GNEXBURn46IW/QrbkmSJEmSJEmStDw1MiED3JYc+1HA7YGXAM8F3jTP694OPAJ4DHAfYE/gtPrClCRJkiRJkiRJgkgpDTqGnoiIfwael1K61SzLdwEuA56YUlpb5t0WuBC4Z0rpm7O8bntg+8qsnYANwC4ppSt6uAmSJEmSJEmSJKlhImJn4HLmyRs0tYVMJ7sAf5pj+cHAtsCXWzNSShcBvwHuOcfrXkXeka1pw5IjlSRJkiRJkiRJy8pIJGQiYn/gRcApc6y2B3B9SukvbfN/V5bN5gRysqc17bX4SCVJkiRJkiRJ0nI0VAmZiJiMiDTPdNu216wBvgB8KqX0vl7HlFK6LqV0RWsCruz1Z0iSJEmSJEmSpNG2ctABtHkrcOo86/yy9SAi9gS+AnwdeM48r7sU2C4idm1rJXOLskySJEmSJEmSJKkWQ5WQSSldBlzWzbqlZcxXgPOBp6eUNs/zkvOB/wMeAHy6vMcBwD7ANxYbsyRJkiRJkiRJ0nyGqsuybpVkzLnAb4CXAzeLiD0iYo/qOhFxUUTcDSCldDnwfuBtEXG/iDgY+ADwjZTSN/u+EZIkSZIkSZIkadkYqhYyC/AgYP8ybWhbFuXvtsABwI0ry14CbCa3kNke+CLw/FojlSRJkiRJkiRJy16klAYdQ6NExM7A5cAuKaUrBh2PJEmSJEmSJEkanG7zBo3sskySJEmSJEmSJKlJTMhIkiRJkiRJkiTVzISMJEmSJEmSJElSzUzISJIkSZIkSZIk1cyEjCRJkiRJkiRJUs1MyEiSJEmSJEmSJNXMhIwkSZIkSZIkSVLNTMhIkiRJkiRJkiTVzISMJEmSJEmSJElSzUzISJIkSZIkSZIk1cyEjCRJkiRJkiRJUs1MyEiSJEmSJEmSJNXMhIwkSZIkSZIkSVLNTMhIkiRJkiRJkiTVzISMJEmSJEmSJElSzUzISJIkSZIkSZIk1cyEjCRJkiRJkiRJUs1MyEiSJEmSJEmSJNXMhIwkSZIkSZIkSVLNTMhIkiRJkiRJkiTVzISMJEmSJEmSJElSzUzISJIkSZIkSZIk1cyEjCRJkiRJkiRJUs1MyEiSJEmSJEmSJNXMhIwkSZIkSZIkSVLNTMhIkiRJkiRJkiTVzISMJEmSJEmSJElSzUzISJIkSZIkSZIk1cyEjCRJkiRJkiRJUs1MyEiSJEmSJEmSJNXMhIwkSZIkSZIkSVLNTMhIkiRJkiRJkiTVzISMJEmSJEmSJElSzUzISJIkSZIkSZIk1cyEjCRJkiRJkiRJUs1MyEiSJEmSJEmSJNXMhIwkSZIkSZIkSVLNTMhIkiRJkiRJkiTVzISMJEmSJEmSJElSzUzISJIkSZIkSZIk1cyEjCRJkiRJkiRJUs1MyEiSJEmSJEmSJNXMhIwkSZIkSZIkSVLNTMhIkiRJkiRJkiTVzISMJEmSJEmSJElSzUzISJIkSZIkSZIk1cyEjCRJkiRJkiRJUs1WDjoANcfYxNRqYPUS3mLj9OT4xl7FI0mSJEmSJElSU5iQ0UIcBRy7hNcfDxzXm1AkSZIkSZIkSWoOEzJaiFOAMzrMXwWsL48PAa6d5fW2jpEkSZIkSZIkLUuRUhp0DI0SETsDlwO7pJSuGHQ8w2BsYmoH4KrydMfpyfGrBxmPJEmSJEmSJEn90m3eYEX/QpIkSZIkSZIkSVqeTMhIkiRJkiRJkiTVzISMJEmSJEmSJElSzUzISJIkSZIkSZIk1cyEjCRJkiRJkiRJUs1MyEiSJEmSJEmSJNXMhIwkSZIkSZIkSVLNTMhIkiRJkiRJkiTVzISMJEmSJEmSJElSzUzISJIkSZIkSZIk1cyEjCRJkiRJkiRJUs1MyEiSJEmSJEmSJNXMhIwkSZIkSZIkSVLNTMhIkiRJkiRJkiTVzISMJEmSJEmSJElSzUzISJIkSZIkSZIk1cyEjHqhehwdOjYxtc3AIpEkSZIkSZIkaQiZkNGSjE1MHQ5cWJl1JjBd5kuSJEmSJEmSJEzIaAlK0mUtsGfbojXAWpMykiRJkiRJkiRljUzIRMRYRLw/In4VEX+NiF9ExPERsd08rzs3IlLb9J5+xT1KSrdkJ5Wn0ba49fxEuy+TJEmSJEmSJAlWDjqARbotOZl0FPBz4O+A9wE7AC+f57XvA/6l8vyaOgJcBg4F9ppjeQB7l/XO7UdAkiRJkiRJkiQNq0YmZFJKXwC+UJn1y4g4AHge8ydkrkkpXVpbcMvH6h6vJ0mSJEmSJEnSyGpkl2Wz2AX4UxfrPSki/hARP4qIEyLixnOtHBHbR8TOrQnYqSfRNt/GHq8nSZIkSZIkSdLIamQLmXYRsT/wIuZvHfNR4NfAJcAdgDcDBwBzDT7/KuDYHoQ5atYBG4A1bD2GDEAqy9f1MyhJkiRJkiRJkoZRpJQGHcPfRMQk8Mp5VjswpXRR5TVrgK8C56aUnrXAz7s/cDawf0rpF7Ossz2wfWXWTuREwy4ppSsW8nmjZmxi6nBgbXlaTcq0DqojpifHT+tvVJIkSZIkSZIk9U/pXety5skbDFtC5mbA7vOs9suU0vVl/T3JA8Z/EzgypbR5gZ+3A3AV8NCU0he7fE1XO3a5KEmZk8ktZVouBo4xGSNJkiRJkiRJGnWNTMgsRGkZ8xXgfODJKaVNi3iPQ4DzgINSSj/o8jUmZNqMTUztBLT2xWHAWdOT4wv+PiRJkiRJkiRJappu8wYr+hdS75RkzLnAb8jjxtwsIvaIiD2q60TERRFxt/J8v4h4bUQcHBFjEfFI4EPA17pNxmhW1ZZJ60zGSJIkSZIkSZK0pZWDDmCRHgTsX6YNbctaY5lsCxwA3Lg8vx54IHAMsAO5W61PA2+oOVZJkiRJkiRJkrTMNTIhk1I6FTh1nnWmqQw0n1K6GLhPnXFJkiRJkiRJkiR10sguyyRJkiRJkiRJkprEhIwkSZIkSZIkSVLNTMhIkiRJkiRJkiTVzISMJEmSJEmSJElSzUzISJIkSZIkSZIk1cyEjCRJkiRJkiRJUs1MyEiSJEmSJEmSJNXMhIwkSZIkSZIkSVLNTMhIkiRJkiRJkiTVzISMJEmSJEmSJElSzUzISJIkSZIkSZIk1cyEjCRJkiRJkiRJUs1MyEiSJEmSJEmSJNXMhIwkSZIkSZIkSVLNIqU06BgaJSJ2Bi4HdkkpXTHoePppbGJqNbC6w6JVwPry+BDg2lneYuP05PjGOmKTJEmSJEmSJGkQus0brOxfSBoBRwHHzrPO+jmWHQ8c17NoJEmSJEmSJElqCBMyWohTgDOW8Hpbx0iSJEmSJEmSliW7LFug5dxlmSRJkiRJkiRJ2lK3eYMV/QtJkiRJkiRJkiRpeTIhI0mSJEmSJEmSVDMTMpIkSZIkSZIkSTUzISNJkiRJkiRJklQzEzKSJEmSJEmSJEk1MyEjSZIkSZIkSZJUMxMykiRJkiRJkiRJNTMhI0mSJEmSJEmSVDMTMpIkSZIkSZIkSTUzISNJkiRJkiRJklQzEzKSJEmSJEmSJEk1MyEjSZIkSZIkSZJUMxMykiRJkiRJkiRJNTMhI0mSJEmSJEmSVDMTMpIkSZIkSZIkSTUzISNJkiRJkiRJklQzEzKSJEmSJEmSJEk1WznoABpsp4gYdAySJEmSJEmSJGmwdupmJRMyC9fasRsGGoUkSZIkSZIkSRomOwFXzLYwUkp9jKX5IjeL2RO4ctCxDJmdyEmqvWjuvnEbBq/p8UPzt6Hp8UPzt6Hp8YPbMAyaHj80fxuaHj+4DcOg6fFD87eh6fGD2zAMmh4/NH8bmh4/uA3DoOnxQ/O3oenxQ/O3oenx120n4JI0R9LFFjILVHbmbwcdx7CpdN92ZUpp1gzgMHMbBq/p8UPzt6Hp8UPzt6Hp8YPbMAyaHj80fxuaHj+4DcOg6fFD87eh6fGD2zAMmh4/NH8bmh4/uA3DoOnxQ/O3oenxQ/O3oenx98G8+2RFP6KQJEmSJEmSJElazkzISJIkSZIkSZIk1cyEjHrlOuD48rep3IbBa3r80PxtaHr80PxtaHr84DYMg6bHD83fhqbHD27DMGh6/ND8bWh6/OA2DIOmxw/N34amxw9uwzBoevzQ/G1oevzQ/G1oevwDF3OMLyNJkiRJkiRJkqQesIWMJEmSJEmSJElSzUzISJIkSZIkSZIk1cyEjCRJkiRJkiRJUs1MyEiSJGleEbEiImLQcUiSJEmS1FQmZCRJUqOZJKhXRGwfEXdPKW1OKaWI8PpRW1iOx4TnHUlSVUQcEBH7DDoOSdLwW3Y3T5KWNwtQtFTDegwNa1x1adveIyNivwHGsmtEbDuoz++DFwPfiIiPRcTNU0qbASJimwHHNa+I2HvQMYyyiNgFoHVMjLJW0ikibg+QUkoDiGHXfn+mVLeIWFn+/kNEPC4ith90TMNsuV3vNcwUcG45jncZdDDtPHaGU+UcuMOgY+mF5VhJZ1Aq16a3GnQsWjj/USQtCxFx24jYcxAFKBotrWMoIu4eEXcYVBzVm6qI2GG5HtsR8RrgdcAeAwzjK8CDR/hG92zgBOAfgN9GxOsAUkqbYHhv8CPihcAbBx1HHSo3YH3f95XP3g94Y0R8NCJ27ncc/RQRK1JKmyPiZsBXI+Il/U7CRsRjgD9GxFGtwhsN1rCe+5ompXRDeXgqcCiwW52f18TCwuqxNmrXe63KHU0vjC7b8ULgQuCjwIcj4t4RcaMBxtT6vd4+IvYetWOnW8P6P9/6v04p3RAROwL/FhEHDjisBWttR0TsHRHbLIdKOsOgcm26BvhgRBzehMpymjGUJyZpGA2y8GOxImL1cq5lVqltci/gvcA7ImJVmRfVvwOKrxHn4Ii4ZUQcEhH3i4g9SoHUslQ5ph4OvBt4deVGciDHVEQcC3ykn585aBERla6zbk2ukfjDAcXyOuC2wBWz3eg25X99Niml75ETG08FPgS8NCIujohHlOUphnN8mSOAA4YwriVr3ewOonClcqP9NuAhwDdSSle0rzdK+72yzc8FLgXWp5T+r89hbAQ+B5xIbrH2oD5/fmNUrtm3i4gdy7XLql5/znIt3KxDqeCyCfh8SunSGt6/+ju8MiJ2K8fFdr3+rDpUKgO9NCLGBhxOT6WUNkXEjYEPRMTjI+Img45pMVJKm1JKXwCeAjwT2Av4IvDaiLjdIApKK79d/w5M9vvzByki9oqIv4+Imw1jgqBU6viHiDi4zHoXcBgwdLHOpSRgUmmh8X7gzIjYqSwbmevAYVQ5ro8Ddgd+1qosp2ZodAGB1C/lxyRFxMqm3HyVG48XAfeba51R/qGs1Lh7F3AdcFJK6dqyLFX/9lOrUH8YLw6rIuKOEXEi8GPgq+Ra8ucD74qIIyNi90HG128lCdA6pk4GpoETKhc+ERHbVm6aa/3fqhy7ewH3j4jb9ONzh0RrG+8GrAS2Syld0e9a4yU5+SrgTcD3y7xVEXFwRDwyIp4WufVSq4uvRl53lWP/mpTS2eRj/xPAGuD0iPhqRBxUGV9mmGpm/TdwB/L/SGO1FS4fEhH/GRHviYhjI+LuA4rlBeQWU29NKb2jzFtZWW/bURlvqO288kPg1ymlb5dlfTvfppTOA44Cng5cD3wxIj4cEbfuVwxNUbm+eh3wbeAc4LMR8bSlvG+lAsbjIuKZS4tSlfPJjYGbAlcBfyzzevp7Xvkdfh7wNeA3wJeA/4iIB/fys3qtsp8eBLwZeMgonFvb3IpcieJfgOMid1/XiGRZu5TSn8gVpY4Cfg5MAJ8GXhARfW3N3fYb9YiIuF2H+SOhcn4+ICLeRd73XwUujIh3x/C15D0A+FdyS6oTgCcBb04p/RSac89QuQ9+N7Az8B8ppSvLskaUmzVR2/3Wd4B1KaWBVE7spP0cM4rnnF5oxD+5RlTEXkSsZIDNeGdT+UG/ebnh+g5wLvDeiHj8IGPrVrnx2A54cvuykoi5UasArf/R1a9y8/I8csHhW1JKXyvz9oiIN0TElyLin+uoNdkWS+t4unVEvAz4WEScGxHPj4jVdX72YkXETYH/AB5LqREPvJ78fzAOvAf414g4qKy/HH5kWy1gJoDtgRNTSt8v825DrhX0/Yj494jYvY//W5PkhOORsOXFbzSwZV83SvPs2wFnAXchF+T8LQnbx5uYdwI/BT6ZUrqy1Aj7IPk347PAB4BLI+KVrbj7FFevtc5h9wXeAjwQeCu55uetgf+JiPdHxE6VbsyG4RrzK+T/1UNgJP4P3kRuIfFQcjLkJcBU5Fagf1Pndpb/vW2Bo8m/DZ+sLLshInaJiH8BvhkRHweeHxG3rDuuOlXOK2cCrwZWR8QtSqKyL+f51r5LKf0upfRx4FnkFkpPJO/rf4khHK9gECrXXC8CXgH8llyZ5GbAWyJiXUQ8cAHvV+0qqlXwdDzw92W53cctUuU38c3kBPoY+TeldT7pSYI/Zlo3P4fc2vP/gH8Gfka+T7p73fcCS1HZTw8mJ5M+X87FjTyntlT+V1cDe5OTp/uQu/36APDyVgKhKSrH7CvI90q/J1+r/oF8zv5sRDy6X+frym/UO8vfx1bnR9GPWOpWOT9/CHgY+Xr1ZeQu5I4iV+IaCpFblfwIeC3wV/J99p+AbVqJo9b/eOv7GcbvqXKf+QjgXuQWvJ8u83aOiBdHxIdKmcey7WGjDpX7rf8Cnkf57SzlfAOrHFe5Xk2Ru0r8u4i41RBW2hsOKSUnp/5MsLL8vWeCDya4IsGvErwnwSMT7DLwGNsmcoHan8mF0J8pj/8I3H3QsXUZ/0PJXWvsV57fmXzTsx64gPyjeWBl/W0GHXOPt39F+d6+Aty0zLsncDq5OfCPyN0jfALYFog6Yih/dyqf92fge+WY2lw+e5fK+j2PYZFxf7LE+7C2+dsDBwFrS/ynATsMOt4+7pdtyzafDdy4zDsMWAdcQ77puhL4MnDjur7P1vtW/p5cPv82g95Hffwu9ijfxZ/LsfhZ4KDqPqrz/4l8Y7eZXJtzlzLvYyWeE8vyF5AL0DeX/6mdB73flrjNPynn1IPK823I/f2/p2zjFcDzBx1niW0FsGP5DXzvbOsMOs5utqP8vQu5EPF44OZl3vfKueaW5fmO/fgNAR4AXAI8sTxvnYduT07SbS7/B5eUmN8x6P3Yg23es+zrS8r2vYFyzdSv3+3K5+1C7n7mZ8B3yV2ZXQ/8itxVztAf133YVyvJrXtPBnYt8w4kJ9T+h3wt/2HK9XGX77mi8vjd5K76+vb9j/JE7t7pa+TKJdcDL2hbvuT7k3JMXFq+uzVl3tPLuequre+YXGt9aP6HKPfP5ITFE4DTBh1TDdv4BeAHwIvLNcWDyvl2M3BeOT72HnScXWxH6/f6TuT7y1cBq8q8PYHDyRV2rgdOIV8nbl93PJXnJ5X/ga32ZdPPY5V9/2TyteijKsv+l5zga5UF3HYh5/4aYr1Z2/NHlmP9SuBqcjfr928dO2WdleW4evAwflfl9/Q7wK3K8wPIFRU3k3uU2ExuOTPwWDvEPnT7cwGxHwT8DthQfsseX1m2YhC/ZZX/xSeSWyf/qZwPvwY8Ddhx0PttmKaBB+C0TKbqiQ4uSvDLBO9M8IYE1yX4SYK3l2TNykHGyswN72PJNRaeUTmx/C+5CXKrMOTmlELZYZzILWROAFaTs+a/AS4Hvk6+ib+8TMcOOtYa98GpwG8q39ePyTVl/rHsnxPJhRm71vT5Kypx/Ax4eHl+t3JB/krgRmXeQI/9Ssx3KMfFs1s3CsC2bevsSC6I3ly2bdtB/OgPYN9EucC8jNxX6x3KRdC3gXuUdf6VXGh30z7Es2vZ948n32S9slysH04e6+AY4L+AJwx639W4D+5FLgT+P3Ki+Z9b5+iyvJbjklxAsBn4Nbm2+qNLDE9ly5uosfI/shm4/6D31xK29+7lnPXy9v1ajsO3lG3cXI7/gfw2Vvd9ef6pct6fNXFczmePpBTKDeNU/o+/Dty6PL9v2deHt87P5FrFj+lDLHcsn31YZd6dyAnpa8nJituX8+PHyrpPGvQ+7MF27ws8h1zJYzM5MX/HyvJab+qZSXytJXeR+KTyfH/gMeRCzc3kMbUaUXGohn3UuuZaAbwDeG6Hde5FTmj9nFyA8f/meL/jgQd2eP/Hkn9z9xj0No/KRG7pOkG+17qmHM/3ryxfsZT/MeAR5ILBh5XntyAX3L6emULzh5fPXT3o/dEW+6pybr2hbMPBZX6TCxJb57P7kwvrntphnceRW5j8ntz6+CHtv/HDOJFbEF8K/H3b/BXAweUYb10vvaiufVt5vje5heBLyNdxJ5Rj/SXkJPW/leN+q++gaRMlWU5JOpFbyFwF3KWyzvvJ3Zn3/VgiX6dtBp5cOSbWkAuv9yeXS2wil9kcy0wFqD2BbwHvHPQ+nmW7TiZ35wq5fOXccq56KbBDOc9eBexZcxxbnRNnO0/SVrbR1KmcU95NLrvZTO7hZN/K8r5VuGamHPVO5fv+SjkGWvfMU/ShfKRJ08ADcFomU6vgBt6Y4LcJHlJZ9ucEP06wOcEPErw8we0HHTO5tvXngb3K8+eQa24dUrmI/FfgKYOOdZ7t2Kf8PYNcc+H+5fnNyTWQPlhOkJ9hCFspLWJ7Wz8EuwE3KhecfygXxn8CLgIeUVn/ZeSb8tqOuXKh9Zty0btzmfcJcuFx64JxZ3ItgjsOwT58NnAxcMg86920/I/8ERgbdNx93D/3LReZ15SL5q8D/1BZ/tJyTB1Yw2e3CoOeQL6h+wW5O5bfMnNz9+vy99ry3fweuNug91sfvpdnkJOtV5ILhh9f58U2+QbjXuXceUPZ55+n1HyrXgCTW8hdT+46ceD7apHbu085pv6lMm8btkzM/Bh4H/CsAcZ5Djkp16oJ+eTy3dyhss4tyN2u/T9mam9tBv5u0Pt5lm1aSe6C48uVeT8ox96u5fmuZd5byGMq1RnP3uQKBuvI3YLsR255u5mcFN6+su4/kBOVL6gzpj5/H3cmV0honWvfCezep8/er5zjXtd+fgNuQ07cbS77/DMMcaWhmvfR+eV38VVl3srq/iJXZHg0OanWsRAS+Ltyzmu1qqgWcNyJXGnroR1etwK4K5UWm04d9+9shWQHlf29gXz98l5g/x583r3J93H/UJ5/oJzHqt/r/yPfJ9xu0PunLfabkQdt/gr5euOLwG3n25dNmMiVh65m5v402PK64qXk66fry//iUN93l5hfROW6g1xAHZXljyNX5DoRuHMNn9+6V3gV8JdyLryGLe8V/kIuwP0juXXlzyhlHk2eyGUzvyyPdyrb+UZmKhjuVc77/8kAegYhX5OuB+5Tnt+6wzp3YKaCxXfICbNPlP/9ffsV6wK36xHlf/Qi8v3p74GnVZY/n1y20JeKT8CjqLQEY+vWYkHuevdYGpogaD9+ydfjnyPf0/yMfD0+kAR2+R87p/VbSh7T+npyZZZWJbKBl/cOwzTwAJyW0QS7Jvh+gjcn2K3Me1fK3ZbtnOBRCS5P8MeSmOnbxTBbFpwFuZBpLaXwg9z10O/KhVOrNcPe5O5bThjED3qX29VKHN2WnJR4DW2tMMp2/Hv50X/4oGPu4bZ/mtz0fS9y7fX3kW++9qvslzFygcU3a45lD3LBzbPL8/uW/f1YZi6aH1ouYAb2HVT2y5PLRd/fleezttwh3+BupgE3SD3cP9uRW1gdX6bdKuscUC5Czq45lo+Vc9TJ5IK5F5bpqnLs70fu335XhqymZw/2f5BbJ922wzo7km+8LiHXfP2vuY7fHsW1C7l2+pdou8GrxLyGfMP7ThrUkqwS/wpygeYZ5Brl42xdA3MN+SbziQOMdx/yAK7XkQs7Hk0u3PsT8HFyy43zmSmQ2EQepP3DlNqKwzqRa9z+uDx+Drlw5Z6V5XcnJ/lf1Y/jglyZoVXw30oAv72yTuu37VByK9SXD3ofLnQbK49vRE7i/V1l3iryb/kp5bz7O+ZoabHEfV2NZc/yP3hCeb6y7ZyzYznGp4CPDHo/Dui7O5LcivUP5Guve1WWraz+JlD5/Z7lvf6R3M3tVgUc5PHD3lwe35lcUeLUcq7fTKXyj9MW+7R6PN+U3IXJE4F/otKSkdwa4nRyIfxVLPH6mNxTwCXkAv69yde5z2SmoHYfcjeo5w56H80S/0ryNfdby/F9NXn8iWoCvHGJGXLFlk2t8ycz9+HVe9gvkBOkp5X/rccP8/aSKyLcQK70WD3eW8fa48hdJy450Vh577tS6QqrHC8fJXdVfjy5st3jyd1aXkzuvmy3ctyvpAEtj9q2dw0drqfJrZ3/RC4Afh+54tpYZflDynngmQOMvVVhaBdy4mKKSqWhynqPIld02ly242WD3u8dYmxVhL0RuQvIz5Dvg+/NTHeLtyB3bXxRn2K6JzNdWT+OUnZXlrWuTdeU8+hm2lqyDfPUdj6JMq2uzFtFTnJ/i5xwXU9JjPXrfEkuX/tp+X3arsz7HjlZtFt53qrk96hB79NBTwMPwGkZTXBggq8neGl5vkeC/0twdGqdKOGMBOsSnNPv+KoXf+X5vwI/Ko9PINcqqY638iDglwywJvACtm1Pcg2RVk3BFWydVb8M+M9Bx9qj7T2EfHF/ZGVee82IG5MLbq+m0h1FTfHsSr5Bf195/j1ywebu5fl2wMvJrS563qpiEfGOlwuUf55jndYFzd+XY+vIfsQ2gH1RraW3itLibJZ1b0au1XklNdR4a/usrZLA5Tg6C1g/6P1W1/aSb17eTG6BdAn5RuWxtLUIIN/Af2muY7jXxwlwK2bG62o/39yHXGB79KD35SL2+R2ASfIN1cPIia7/JY+Pc+vK+o8p54LHDTjufcjdxn2n/A58hplxhq4ht2j7N3Lh6W2AnQa9r7v8Hh5YtqHVZeJxzIxjdVPgTWX/t270a0/8lWPjpPJbeu9KPK3ab6vIhZ/X0KEW6DBPbFlB4Zxy3P++HFcPqqx3E+AIcvccv+rh56+g0h1WeR7klnnnl3PgAZXlrZveG5cYX0zDCth6/P3dg5wcuYZcKPHWtv05ZzerbJnk2p5cwPHt8l7fJCdqJsnXbZeyZYL3PQx5gnfA303rnHYUM103XUv+jfwfKoVj5Xt6Prk13pzJsy4/+1/ItXR/D3yrbdmLycn8w9qPgWHYX5Xnu5ILnT9JLvT/JfDYQce5yG0LciuGL5Lvx7a6fiB3w/tL8nXUnuXc96VBx97Ftr2pHGtnAg+uzN+dXDlkAz3qLpucjNlMvgeZc0ya8pv1DXKBbStB1JiKQiXeh5Tj5UXALdqW3ZTcLXvruu8lzFSmvSO5kP7nA4j5JmWqljWNkbuX+kk5/7210zFBTlrectD7vRLPggr2y/d0BfCMPsW3gnyN/AtyDyXvA+7bYb0DGZJxLxexjf9YjuVLyEmXD1C6Ti/L15C7ifs9NVc87hDbduTKMK0urp9N/o0/pLLOOHms4kb+dvV0fw06AKdlNMEuCV6QWn37w0SCn6dqATR8KMFR/YqJXHviHCpNdJm5qb0H+cJ8XbngfSpbtqz4EGVskmGfyN1hfa/8MFVvdFZWln+DXHBVa1cnNW5j9QLnPuRCtwNby9ovHspFz6+Bk/oU3z+XH8UPl4vIe1eW3YXc1cwnBr0fSzw7kG+KLwMeMM++fji5MGLkflCZSToF+YL+2+QatxeQb6YOrq5bLqp/Aby27rjYsrVItbZvq9D2KdVtaPpU2d6PkrtXWEtu8Xde2d6vUOk2bhimyvFzq/J78btBx7TI7TibXNOpNXZJqyXGZvJN76fINwVXAd8bYJzVWsLbArcj1866qMT6DeYYV6P9N2IYjp0O81/ATOHvq8hJ4P3IrXf/DLymrFdrQSJtA4XOEe8DyrHz/kHv0wVuX6vA+D7luF5ffgPeUPb9F2jrooyc3Nu3PF5yq7zyWevIyZ72cZEeTk6+fZ08hlB1zKo7k5MCLx30fhzQd9feCvxwckWFv5ALvV403+8iuYD4X8p3Wk3M7E0uZP05ufDsj+RCpleQCwgb391PH76f1u/i3uRr4Y+Rx1Tcndzl6HeB25R1qsf1rGOALfDz9yJ3gfY78jXuv5JbDJxOrnj3sUHvo+p+Ko9vQk5E7NL2O7c3uYVP6zroO73aT33axuq9xG3I9+Ot8+vdyJUrHkzuCnZjZd215Mo4awa9DfNs357kVtF/Kcfb2eQW7eeRCydf38t9Sb4+Pr7y2XdqW6d6r/Dgsq/HB72fFrm9tyP3BvBX8rXdo6hUriFfG32QnJD/Hjl5fiK5cH4DlQRZH2P+NvBlcvnSdpX5Qa7s9GFya+L/pSFJgnIcvbds2wfIrbdv07bOS8t2fbJPMVXPK2vIyZg/kAv/j6dSkaVpEzPldg8hX3+0euo5s/w/n0Iu06vug0MoXYPRp0oG5ErunyWXJd2FmWTjjmX5ziXu39Cn7n6HeRp4AE7LbKreBMFzE/wltQZZg/1Sbh3zwX7FQ66ddRU58fLmDssfTy7M2VQuqg4m95H5eXItuccPfJ923q7WCXtbSgKMfMOxiVxrfJwylklZdmi5QHnDoGNfwja3bvKeWi5qppkZr2WLgUDLfnkxuWltX2pHk2/wP1N+MH9b4rwjuQD9vPJjNTRdS5ELMa4pP6YPmmWd1eVC7OJBx1vTPmgVyr25fD9fISfWWv36Pp4tC2ueUM4PtQ4SWLmgqRZWbEPucmAHcq23b7fWa/pU+d++B/nm64WVZWeRC8daTfrfwRD1r0wuQPkQ+WZgKH8vZom7lQC7CTnh8kq2vIHcrvx+XkBu/fcbcsHWVt3I9Sne25T/09u3xbkjueuQE8mFfz8j3zDuOuh93OV2TQKHVp7frPx2fb0c79eV/4k/Am9r//76EN9cLQweUH7bLqCh45iQCzhPbx3X5EKfa4DDKr8Pc461toTPPpZc8/FX5BYX1XHKVpBb1V5L7prlU+RWBM8jFz5dTg9aEzRloq0Ljw7LdyYXCv0POXF5HnN0J0a+/tkMvLeyv6sF5Pco5/Xp8v2cQKuyWepNQm7UJ3IFlh8w0zXuPuTuD5/DTJdwjyInRRdcsYSZ64ZV5fuvjhOzE3nsgHPK8XAtuQXGK5lpuT6w1jFtx/PryAW015Fbxr2KtjEByV15nQCcPOjvtdvvZZZtvQv5Gu535f/vj+T71ksoLWfI9x1nlP/lofg/Y+Z6aW9yrwF3pzImBbmw/VPkAuHLy/d5bF37tMz7LrkyxNOpJK6Y6Q5uW/K9wrdoaIEo+X5nvJzPN5ETMHejJCXL9/EMcuvV68j33p+kQ0uJPsS6Hblb6QvJ5U5vJV+3VhOsu5ETrF8i/66fxyz33wPe760ypseUfXpJ2a+tMfWez5atpI8h//72LYHK1l253rscB5vJFV2ezxCVuSxi+y4kJ6Zb47McTr4XeAAzv323p3/3AtVeLO5cHj+EXBH5t+WcXm2987iy7I2D3pfDMA08AKdlPMHDE2xK8LEExyT4TIK/pj4Oqlt+KO5DLlT+azk5PLWy/MbAk8hZ3iuY6S/9RwzhALVsPRDiu8ndibSa6r6AXCh1Gflm8mXkAuaLyg/pUFzcLmH7t2HL8QE+BOxZ3T/t69fxHcz2eWXec8k3fq3uLTYDXwMOH/C+27n8QD6yMu8Z5H6GN5PHxvgH8gXkKnLtpA+SLxqfMOjvvq7vEbhlOTccx0x3PO8h31AdUJ5v2/66HsfSutDZj9z8+BJyQeHbqBQMVtZ/RPnO7tTrWAb8nbyfXMOw1fKtVcPvUeQaQK2bgc0MSRd65Ivk79DDm+8+x/9k8pgsrWbn0eF424MBF7gzM57J98kFenu3/RbenNzFS6sW2VfJ3Y4OXYvQyrnnpuQClc3lnLN7ZZ2DyC0nXkluuXFHhqjrEXJXZleRb3zvP+h4FrkNtyvnlKOZ6S7sp+RayLuUdfYvx1xdSZm9y2/vH8mJrddTGV+RPCbGZ8g3u62xfL5Fg5K/PdhHrcKH7chjkJxS9skTyIW31QTt/uTuCv8KvHqO99y+/Kbcsjx/Ibngb6e29R5LLjy7ktwq6WXD8P837BP5GvJTwKcq875MbonWqkS2Xfnfei0LvDepHBM3Il+nXlSmMykDaZfle5LH/bs9W/bBP9DWksxc8/0/8jX2meTr8TPJCeFWgeJ+lddsT82VgXq8jU8nV3T8DPC8tu24D7nS2onke9Rqa/R/Irc4eWG/Y57nu7oz+VqvlUj6NrnlXPWecH9yJZFdaoynVRA+zkxFpU+T7wt2blv36WX52KD34xK3eQ9yy4fN5MpBr2vfprLO7gw40QrsS06e/pGc0H82uRVHNXmwP7kHgPPJCePPME83dP3chsrjS4CPMJMUeC75uu9e5Xn1GrzW+Cvn/LG2fbltW8xvKzFeQkO76SdXov4tpeyF/Fs5Tb5W3KnMO4g83tZYn2P7FPCOyvPHlVg3l3hOYKbb5fMGvS+HZRp4AE4jOrVOwrAiwb0SvDLBIxPcPlULQOD5Cf6cYHOC/019HPS17QTd6gO8VVhzPltmcvci14gbL9PN+hXnArfp0HIBeGA5GW8mF05VBzO7DXmg62vIXbFtJmfZ7zvo+Hu4H57KTLcup5NrJ23RnU3dxxW5b89Tyr59DrmAqnWhfGPyjfxR5BoEAy0UZGagzL+Sb35aNQS3L9vx3+V4+WvZr78mJ/YupubuuQY9kQvjfgbctTy/IzmR9ozK93k8uVCm1tZW5Jvwy8g1kT5YLip/RL5pvXNlvdWUbgtGZSInDD8KfLgy77vkG5XWBeiTyDfB76FSaDnoqXwfjWshUC6kW5UQfsiWA5pHnefRRcS6AzlB9+US8xfJ3Tq1dys1Vs7H3yvrHTPo2OfYpvuSW+NdyUxrmOP6HMOiazSW37zb9CqWAez/m5MLQ55Vnr+cXLu5Wjj4NHJyvqfdn9A2zh+5xvVPyDe2XyMXfFTHQ2nVyr4jy2zcGGYKYt5KLuS6tPw23EBuAfFYckFctXDoXlS6/Zzn/Xcqv7ObyJW37sCWrVN3IidFv1v+Tx/Zy+0b1Yl8H/Ld8vgfy/49rPJ93qmcp49dwjHxH+TrpM+Su0ZrdbX5Odq6l2NIEmmV43L3cr55MzPX5P9S5v207K+15fi+xaDiXeC2tZIXTyy/Z5eV89oN5PuKOQdZZ6bXinWD3pYOsX2v/BYcQ04inkVuGX0+8Ji2dXtS+bGyPx9GrnC51bmf3KL2SnIS60RyWUbrdTeZb58P61TZhu3JlU/PZ6bF9rXklvPPIVdsGYqxoCqxb0se86dV4eZM8vXqLm3rtVpi/tugY+6wDU8glwE8sDzfuRzvb2Gm8uLDyjHXl2QSuSzjYnI5xq3blq1qW+eT7f+XTZnIyd+rKa18yRVG/8CWQxK8lNyF+l1qjqXVWqr1u/UR4Oy2dVaX4+BScsX335MTjo29P+j5fhx0AE4jOrV+/GAywXUl4bIpwU8THJuqA17DtgkemGC31OdaSWzdYmJfck24H5QfyU8yS/Kl/bWDnsg38EeVuH9MriVyHnCTsry9+eY+5Ka9t+3VxeGgJ7ZsqbCSfIO+mXzR/9Y+/DC1LhDvRb7B+AszN04/IRfoDN0PELn/3fVUBqFly8KL1eRaaa8h32ScBrydXLNwaAple7Qv2rtTeDK5hmKr+7uvkps936z1nZcLjfOodFlSwzH1XHIrvcdVll1M7mrwBnKB+SuA/Qe9D2v8bh4GPLo8vlu5AH1aZR89rxzHY4M4VjosH6rfiEVsX5CTXK2Cxs/TVkt8vn0wgJhvCjyrnHevIReg3p1Kv/rk2mQHkceCuOWgY26Lv3Vz85zym/F5cm3hl5MLETeX//tHV16zDTUVOJBr3X1zob+dTT/2yzZsT07wnUa+TrqcnHxvtUTarZz7/5dKpZcajoWDyd2X/bocE61u6j5JLsgeqd/gBe6jau30G8i1L29BLvA6l5mWyJ8mV1jaeZGfsxcz/eD/ntxyYR+2HJPhNvSxUlnTJ+BIcrL/CeR7lv9k5n5lx7K/r2CR3WCW7+zS6ndSjpNjyddNm4DJQe+HOeJ/GTkReM/yfJ/yv/8s8v3eR8s2XEGHLreHeSInVT5Mvue+Obn1xmlle75OW/eM5e925KTDGxiiCjcltjuS77kfXZm3TzmGv0m+h/gscMcaPns78rXwZcDHgcM6rLOKXFFpM7mC2cuGbR8uYrurSdeLKIkl8piNDyFXJNxM7t7ugYs99/c45tZv+pPIlfi+S+4x4zflXPgRcrd9N668ZlsG/BtP53F4H0uusNIam+Tfy3bcurLOW8o5bKxPMY6R74Vb44o+ibb7cnKFii+1z2/SVH7bfk5OPN2YnJx5DTPXpjcjVwj+H+q7N7hV5fHfKhCRy1AvI3dd1t46aTdyq++R6E69p/tz0AE4jeDU+ueD/RPckOCkBPdIcHCCz5bkzPcSPC9V/qEHObFl4XOQC/veRO4G4noa1N0MuUbFb8k1RC4gN0mujhfztxPkoH/k+7Q/bsVMy6cLyDWXau03lFyI9t/lOLpJuRj8SonhXHIh/551xrCAWF9EThw9vMOyjoVqbFkIMVQFskvYD6vbnrf+Rx5YvrfHkLvGuoFcE7/VOub25BuuU2uMbRtyouFdlJqQwAT5Ju9W5aLzqnKB9k3a+hdv+tTpOCS3ArwCeHp5vjv5Rv0nLLMa4n3Y/7uV8+aV5MLIE8iFxEORyG+Pg5yM36/8hv+FXIj6WnICudp90VB0AdFpe0rM76FS85ncvc7zyF0tbCbfVG7RaqnHcexErl37vXLee8+w/G718bt4VtnXG8iFDbetLHtKOQe/rDyv68b3B+SuGsfL/+Lu5AomV5FvfE+mdBGyXCfgE+TWMK1uRO9NLtx9OjPdGf6WXEgxtsjPWFV+799Dvr7+ATmZsHuv//eWy0QeBPr68v08vDL/qPI/974lvv/HaWu9Rk603o9ckHsluSD0YYPeF20xriQXtp1HGYuEXFP+x5T7ZvJYAReSExlD30UhM9fUu5IrNj2lbfme5N4NvluOiY/QocIENSS/l7I95fEtyzm61ZK+eo90R3I3ia3uwx7b4zgeXd73enLrkJ+Ruyrfqvt3csWC1r3ohTQ/KbOanIx6K/+fvbMOk6Nowviv4yGOhQABEtzdPbi7u7u7fLi7u7u7u7u7OyRAcBJC5Or7461h+yZ7Se6yuzN7mXqefu52Zu62Wqa79K0U0gSCATvH+/qbvycTZ8hrm4ivoQiur6/vR3P4+/4DkrEPQbBlmUPq0jjQNQ7qXdbPwYWRA2AEMsZ38Pt9UdDIYxnwvC4lJ9e1KPMycVbshnTHebIe2+aundS1E31tf+R7S5y1u7n3caf0vFWInw4oQOlFUtDoCOp3BCXYukbOPOS8yXxd561lzkDRWnGDNQyet3R0Eyxp8I47Zu402NhqVFg9bqkNop23uPBdN4Qxf00k6Gye/tu8tFR/vkURwr8hpf1GYGUaO576AcdTx8ZbSh75yRHk3GEo+m3mMs+ujATVBqqYpeLr6GrguPT8+CH5OYpuvd6FhMzWEnLOvQtcihe5LsdPNM51WwBvLOPQA0FdHU2ZDBPfAz5Fxq8Y87ynr7fh5dZcBfmbHimpJ0Zr6TdkcE7qQ92BBNB3yInCOp59bsoZmKzFXij6ZxBSAq5ESs7BVeIn+d5uyDF3DsJ+npE6hCNr4RjM4PtWg+8bu1VzLx2XOYnmpan1Mj/CK/4X1dbYDEXR5e4Mj3hO4AgO9s/pKLN1kKPpR+/X0VQpuMLPs9kRJvu3CBJqt9a85tNrAzllPkLGh/NRJOK1yBD0RFN/VyFe1kDK7WgGV5+X95CM97yfRblwktZ4vqZEmbunUjJ6vYyCYnqgOiJ3+/n4L3GG/rj9/7ShryMlOMFRKPJ9OXLq4M1zQ4EVZyND5AgkhyXZjQ80d5+hZPRfBwVnfEcJZ78jjQ2Kk6Ao7+eBJbIeizJ9WQSvLelr/BPgiOj+0gi+MNfRxkQGOaSr7YYgRTf0a40Mvihw4mB/t/ZOz23emp+/P3tbProeB38E5FC/vBrzhbLj3/b//6Tvc2/79dEyAZC+/HTWY1eBfk+CHO2XJ2NOYztHD1TX53Hg3qz5dZ6OR06XtCG7IwoATODWvyBCRMiQ32tRIFA8rsk5ex+yabzje3csp27p+3hV6uMi52L/1LV0cNbh/i4M9L3yeSQv3VoNnmowF4cAy/rvXZA8+gNeUwvppucjWadq7zdyKl6C7KIjkQ0pyW4NvnYP889tUcbrHL73PwHsmfVY5q1lzkDRWllLNkOYzmA3U12YJGOmo8VeXtjB4Fd3zFTNmNlUiwTENSkZM99AaeBxFOTkKAruVeDLzMd43PrW0wWRHr5pjnSh5TTfFDv4xv5vOWGtHlrq4H8EGUv+Qkajkchg2qXM31UU670J3nYBDo0+x0pgD4QD3QCckfEYzu7jNU5GbORQOp5WFt2AjALvIwPnY8gA1yu6Py+KVEyKhh+LINwe8PfqlArz0yn1eSIEYZRE/+7gAuZC0TPnoEjgXCqt4zEWSyHBfn9g1tS9xX0OhiEF54Iq8pGcF9f6/vKH75/f+zvxX42o+Pl6bCirb1kUkDCa8RIYgOoZNQBnZcjnQcj4cB6CuzkeQQntggwOayPnxuoo4vpPn7fbGY/aKDXoVx/n9arU9Xh9fYAywq7wZ3erMk/dkEHpPZ/3FymTVVmvLXVGT4acj/NRUjIXQxH1g6P3/mA824LqZcdshBz+q/nnQGN4iHWQ8+5H3GE/oTUk716JG6+Qofov5MxK9u2TUaBMkmHa5P4cje0sPsd3IUPO3kQZYigoYHNkKP8XD2opWpPj2d3fo82BFaL7XX0dn4Bk+RuQ47zFdVFQcNYPyPj2HI0zDTvQWH9I4Gdzd2ZTysTuiWTUaxJeEYztL2SgPzdn3lPXDvbzIyk039Wvt6GxwXciIoN1HucmmocjfG5GIojPAfEY0PjcrqjuRMkwPo2P5xPIWLomyoD5CzmrN6EVOuv9XX4BGYD7RdfjmrFPIt0oF4ggSJcZhmcwkXLkI6P1+whNY62MeZ0bQaV+iexky6fuL4NsYw1+Rq6FAgiPQ471R6rEVxvf37duYp+JM9QmRhDrzyG95Vwi/T7vjRLM3To+zi9E7/2UqH7dc0gGaUBZ26dSyqSslmzaBkEDXo/O2V9xeFAf72dRbZsHfF9soITcUzfjX7N5zpqBorXSBh8a/Gnwo6UPlFgggbaWQUG5aINbDkWav4+cFbf5pnEzKbxRlIbXr9a8jmN/xlaUdF4X1JI05ZeRYSq3+Mnj0OdEyTseGUn29M+r+abf4IdEVQ1VKV4WQlGqj/n4pqESYqPPDGScyYAE9wZK2LtlD+7o8E8Uj1YBU1amnzsh48qPLmSsSWMl8UAknP7q4/YlMtJUTNFBOPTHIJiDOMKuczQPW6OImEX885QoAjgXEWAVGIPkfVrO+5kUNG9A2X7TR89OhVLjp6dKEcqUjHqLoijeg5Bje27kDBiODOQ7k7OaJM3oY3ImroAUqwakzH+Boi6nTz2f4LnPnRG/81Ey7CSO0q+RcXoEiq5N7iXnwW/+85usx3sM/erhP092Xg9gdAzsqZHhcktUL+Mp5JCseAZjtC52Q4rgy34GfEkJn33OSn9vjcc83uPPRFH1Se25lxCsZ7L3tkcO/B414m1mZHS9nsbQs8meNKvP/zS00nN5HMcpNsCs7+9DEknaDdX6eXBsZ0Q0zz2RrPyLr/lHfU3cSuR4QRlk/ZPvKtoYx/Ya34tH+Fi+gTsa4zmkhYbT1HvcBhkHr0eyw5/Avqnncx1YxOgOigf8DDsCRSR/B1yXNZ9j4P8QJE/EGTIzIRjMJ30N3EvjAMhcFV9vRl/nQLLgL94uobGc2r7a+zNyeCbnc18UQX8y0md+QsFES2Y9VlXo9+Ioq+RjPBsuujcbQhc4Pms+I57W9LV/dHQtUILUWtd5zoW9CaEAnI50489QBsas0f3ZkF72k+/t/yKd6HKqpA8hOe1nHCKwiWcCjW0uPVt6tmQ49nHgwCCk54wilXWEsv5nQIF0M9aAr3QW2taUbIzvAPf7GvjI96TTUSDfFOTUuZ51y5yBorXSBisZPGzKfvnUYDOLjQrQxnIgDCPYlTspRSpshIz4K1FSzEbDYc1bi4Tdefww3wOYusxz6yNP+ovAeVnzXYH+ToYyPI6iFMl6Jsp22hlBGiUHRLXSZpN1Mi0y1I9AKbxx8cQ4cieQE8MJihz5Angg3Z9yY44UjidwTOvW0mhszOnq/fzBhYnTaZyJ0g1lbfQHJqkCL0kE+nO+hkcztKHixH8hBWsb4EIkBK+c9VhWeCxeQ8bGlVCWwzlI6B+GHLE1rRXjQufTjJ4mPw8yljQgo9+G5KCAaDP6lYa7fAXVTFqSUibMD77P5qI+D3LIvIUcdq+hiLA+3nr7O7o4Un63BLZFUXsH00zIohr0JXFAroucYTMjJfcNP08uR4EGPZBh51Ciugcoe24UFXaMUDrb5vHvOxqPbPNr+6Oz9h8UiDBZ1mPZjL61IwWVixzuw5CRcFsUSfkhgt14GFigxjwGn+/z/R08Mb2v+Pr+CVgu6zGt4bgk67ITKVgg/7mkj9dRyACwCzJmHBX/fVNj7j+vQQao5B1bGBkYDqAEE1pAlI19ruJafCNQ4Nsavpe87fN0H40NfM2Wj6PvmZgILhhlMW2D5IgGJF+tmv67rFu0pvsh5/dlyKi/ZaovN/s4DkYZET2y5r2J/izu4/1kublCwWvHU4KqOzXej1uyBmrcv2S9tU1dXwkFR/2K9MBDqTK8J8rCSZyZ8yL9/rbo/myoltIfKFL9DOrMMD2W/ndCNo/v/Cx8GKEI7IHkqWHANFnzmeL5ciSzXUxjh2QHFOT3FTnI4qaxbrCU7z8f+969H1FNHlS3bVNvi1Rrb/U9sgHJnx3TfJZ5PtlbQ7V4quL4J7rBscjRu5KP/7Xx/azWRmp99ENO+HdQAMRAUlCgrWnfqfh4Zs1A0VphawxRtoXB1wb/GFxhMMBiGKls62cs4sLgVr6xtEXe/2twpdcFmYfIaUq48xhnZySRnUP9sL+MMgVMkdJSVwdTE31fH0UDreCfp0LC/c7+eUFkMPqeKkdFowiR15DhuCdKL/3E5+NRF1J6Zj1mEb/B29nO4/ap+/8JMf5zehdur8+a9yqNR9LfbXwP+NnXTQNy7B1EKmKJCkMA+Lp5CilOX/h3P42MbrHgG5ABdCgyhv4InJ71GFZ4LPoip9Q20bVuqO7SDcg49jWwVZX5SPbXORFG7wvxmkkJpGsjYbmBOqq3FK39w3y/XDq6NxhB9jwevQs1z2odA++7oXP7V+QMW4OcG3PG0JdHUXZlv2h9neln2hB0vv+CzvZb/Zm2SDH+iyo5DJDD91tGhwzshKLQh1KSO9bPehzHsU/nI4PnnD6GATkiz6QxXOUM6IwcjiA7agL7kl7Dzu9IX+t7IdnnAN9v3s96PDOaw2t8XY4GQ4vgr4b6vP2b2rfHllE+te+Dh+FGYpQZ8xYe6ISco08D82c9DvXQfK0+AvT1z22R8fg4Skb5kxlPBwOSsxNnXJfoen9kHP/A36MnSGV9Zjg2iYwxFQoS/AfpDh95X66msbOiH3LaZx7UOJZ+zYJnZPg5sRtRoCDK4FgJuAoZzb8Hdsya72b2sVx9lg4oSOIlJD99BixV4bXS18+m0QJ/kIz8J3IMTRJdT+qo1qWuQElObeP7b28aQxEugBxPX/o7lDt5NeJ1Lp+fIb4nnYvO9CtRFtyVWfMY8drBf86MMk3/oJR9/gSwRY35uRs51qfyz2M7zyeuNk9V6mfyrk+GZJij/PM+vq9Ml3q+HzVELKBkG0rXXFycUh2bEb62W23NyYqNZ9YMFG0CaDCJwUnulPne4EiD+SxjowlytvwNrOmfD/eDcO7omT1dgFk483Ece39eQamBG7jgdZwLuH8gRSTXhR9b2OfFkOE6UfLOd+Fmev/cBhlt908fXhX6/lhAPJooBTl6Zl8Xuv5BeP+rZD1uKf6m9zFrQEaMOJsnibrqiSIfRgCzZc1zFcYgxuP/28dhdgQBsD6K+BhJCSaoatkPKBL+S+Tg28Df6X9dUF80fo+R4WhDZGzIReZChcfiymh/jlOkp0CO9MRJsEe11wcyGjX4u7wJjTGqY6dMF1I4y/XQnO9HURbSJH7tTBeqJ/e19hwlp/8mWfKb4n1ilMk2GDknrwQWj+eHnEZmRWfI5Cj68Bj/HGft9UNRrTejrLj1KWWqzIoMw89Umqfo85G+7pNaC+kaDDsDryOHRT3ISh1RsEpi+NwbGQ8fxuupkYKYQbJgA7BrtdeC/97N97npfLw7oGCBJ5CTocF/Pl8PY16FsWqH6owkGXy30zjLYhKEb384ynyf0q+PMaLU94revu9t79cG+HesH72vqyBnWKupo1SleUrGazng9jL3OyNYqyuRo/lnxkNX8bm70c+CFcrcXxidcQ3ABlmPj/OUGLbuRZHna/nntZHMvQMlo2jdZN4m8+/v1Os+5jcgGTeGX+yD6go97M8cmDXfY+hPoissjPTNt1FQ4P6kYHORg+0ElO3Qv4I89ETO5jeRYfpGlA2yFcqiaoscYM8i3T9dk7JeYeGSvWRPlD38NcoGOobGAWvzeVuUjLMYI567ITl12tT9vZGO9wsl/eJ6cmLAjtb7jL6n3uzv6vxIP/gYZSVdByxWA36WowSnfEh6bZd5vh0K3BjIGODN8txQoNnHuHyDbJd/4g4av9bT96NXMuBvWkZ3ynTw8+s2Sg681WrNWz21zBkoWitoyeEOPQ2WMtjIyr14MJvBbQajDL4xmKkW/NGEIQZ5nT9EqYC9kSH2CEopkBP7BvcO+Y9E6ociq+L09i4oC+hiZHj4CNgwa16r0PcEPqKLCwsPR/dmcqF00yrzcAIyjFzon9vSWDDvClzkh1KmGSYuSM1EY+PPUiiKqwF4BjmRpqZkFLoQGWLrMrKqGWPzHDJuJpE38Rid4uOTwBzOVUU+1nSB6wIUSXU0chYPQsbR2dKCaFogqsdGSXmZBSntz/hYly3u6+Owd7X3Z3+fl0ORnCP93NiYFEQTdZqZ4bxPghxcl/rnXkjpORBXDpHi+w6wT4Z8HozwiWcvc28u5BT4Gykwx5ETHO6x9KmLnw/P0ljJShc6bp/6uzkRVN7PVCAyDind5QqkruV73/E0dsQkstJ2yKgwQ9Zj2Yy+dvZz7z7v2yPeh1NTzyWG0MmQsy854yu636bG9SBkaBuGHEa34FlryMg3A3IKL04rgw9t7pihYIS9EDzQP8BJNLNgbHoukez/JXC5f37Tz6HEUd0RZXx8RQQ3U7RGY5ic5UmNnQP83Fy5iT1mMmB7UpnaLfzu7shx+SsO40rjWgIdyFktDRQANBhlkSQ6zYNIr5giGqMLyXGdOj9DTqKMQRlFdg/xeTkN6afxvMyKHAtJ/3Ml00ZrugsK1PzO94Xr/Qx5xddw71S/+laYj4MoGe+v8rX+vu9Ho5Dc/Lz/PgiHXKYUYJercW3m2C9IqbD5+d7X73w+ygZmZdVfGme+3YICZD9AMuoa0XMTI7ivOZFunrv5QZlHH5AKyER1NB+kVJ/4IsrA5VeQj8+QnHYnclZ/yBiyspHt5R7nr+5qHSK97E7kbI33lOuBD/33gM7VEcC28dqrEk/Jul4KOeJ+QAEspwNL07jG3mQIMvZVcow0lIeWOQNFa0UNrjcYYjDC4G+Dt6xc9BisbTUsRIggx04nVRAVGTtO9I36A2TAmSJ6ZhPk2a1q9PV49CuN3XgbsJJ/jo04EyMYl3u9r5kZ0yrU7zHhf1+IokZnQEUwj/HPVTuIKUVPDkRGgbjeSDsaY5zPRYWF82by2hkJ8W+iqNF4vXehBI+TCPtJVsAwf1dyGWVeobHpiQyiz0bXAlGhWVSIdDAygJZ1EownD/9BYCFHw4e4MxHVbLjO5+dtVM8ks7VUhb4nQt7MyBg2AinuDf5elzX2UkPlBWUxbOjvzwgUmbgUdZp9mB47ZMhKjI4b+Ps/wD+3Q4aAq8koG8vfwVv8XP4SOQhGgyNADoRXfA97Fhlsu9Sa32b0a2VKEBAjfexjh377cuvcz55XqUDWBnK8f4ECOLqm7rVHwQ5DUHT5PNG9nshh/Ampmiz10JDjcQsUcZvMwdak4EVRLa8PgFuqxEey/x2EomUfRDLozc7TQdQILi3vjehc9s8dKUXs/o2MNpswBnmFxvJzH9/bp6Jk+NsfnfM3+f9cLHp+IeQwuyHrschri8bxOF/PyVn+MqonU/G1TJQJiQyFb6AI+mn8WlsYreZHLoyfSL4bhOvMKFt7lJ8NiUy4ve+zC2XF5zj043Cf57eBrcvc74rqZzSgIMF9iQx1NAGDk4cWrekL/KxM9O0ZUcbK5z5n9/kab5ZjeBx5CEjmPA3JZ1+h4KC5USDTysjecR4KHnuCVpRBiTKsHsMLlwOTonpvj/ge8zxlICwz5vlBFFB3lZ8nb/meeAepQBpyGNTl7+xDRNkXRFnSviYfRDL5b8AiVeJjXxSouCQ6q7dCjrkG569J+ND0ONdL87HtSykoLhnzxZCusAiC73sIeLMG/CR7YGef78+QznAyQvJ4D8GFzk2kJ1IG2rFoqbHNmoGi1Xkr1YvZwB0xJxksY3CQwbMGDQaPWTobpkbCFlK2r6JUk2HzMs+ciiIXBqNU2I0RTuZ3RMbZvDaEc91AKTow2TDTise0KJK17o2HyHC9AHJEdaGkhM3jQuhwpET/DZxdA95WQXA/DUgo35fG2L0dyEF0EsL83wIpqSOQcXMAjTHzp/QD9QpkDDp4TIJOa2rI2Pg3UQ2NeM78/qHUAJMWGUEvcaErccpMBKyKsniG+zxOmfW4Vbjfj6AsjB2RUe0CJOT/gCIsJ8kBj1OidPlBSLE6zgXQujSYAjsRwVH5z6Qo767+eQ7kkHwkY16D72FP+7n+FmUwwv25/SjVYlqi1rw2s1/TIViyBhRtdiApuamps2N8zxQfq6mRAfMivzYRUSFcFOTwgPP3PoL82hZF7w0Djs96DMez//383P4W+B0ZvBZHym5n5HT6F1jG/6ZiEYjR+dLD97pTo/dxfxTsMZd/bo/Xvcl63Go8R6MZqkg5KpFzcFtKjrWP0+9QarzboKCd75H8/BSqE9bN13/iDBuI4OIWQAbPF/1axYMyWkOLxncOZKC+BtgVnZMfINnlUsYzuyg19+Uc1qv4u/xM3ucK6WeDgb388+coACepZ9oZZUd/RI5lPuTY3AnJCr+hrNvR6qf4HpbADT7q723us/3QOfkZcjwlc3Odn4lzId2pwft+B1XSFZAjYg2ULdzg47xqdD95B+umluEY+poEK7RFTsnzyzwzPbKFvO5jfycZw5U5X3P6e711dG1hJOt9hnSI08g5FCGqo/cPqvtVLkv6fF/vA6r0/Ukw6Wm4DQud37MjnfxLSvVK+kR/V5dBpOnzjKimr78HE/lZeieCDG7AHa9UUQ+N+DjXxzwJ2JsM2U4SePcXfU+fMeuxrJeWOQNFayUNzjG40+LDH2Zxx8zn7pg5xzI4IJFTZmUUtTIKGXIWju5PhYx/j1PC5v4TeXxzv5mgoohXIjzVP4HdonuBxtkyuYs6akY/E6FsQyTs/+5z9TwyvE3s95dBToRzkHOt4nBGTY0jwnr+BBkKH0KRzrkbc2RQ3g85HX93IWduHCrAn6lLQWZ85hOljf+NousXSt2bHKUJV9QgjRSJpX1ORkv1RtGELwGL+uc2zss+wF1Zj12Fx783Us7jPWxiYEVUI2AkyghYO16rVeAn2Wu6IBzqXZCivRBedNj31jlRiv4/SLGaKuuxbEFfV/F9dJvU9cmQsv+Ln5kfIQizubPm2fmbHPgfMoT8gfDnR1MG0fm+X9b8NqNfSyADYlIwdVOahuyruFEej2pDBtOXUZ2OHtH9zVCG2GDn8SfgnKzHrVJ993PwcuRk+hE5x15GcJb7+HNVgStD8sKXwHL+ub/zcQAlR+mmyGmdawNzFeYmGaMTkTMwNgqlofwu8DF6iPJFrxOjwgnIePcSchp8hc7/vZPvRDLdp5ScPA2+H66V9ZjkvSG96ik8uxUZkeZButVg3zsOIMrUbub/T+ZxK5RBtiWSIaaNnlkTyeQX4Vlv5DMKvQNyAH6DAnF+IYLFRc7hz4ALsuZ1DH2I38mZEQT4Gz7X51LGkYTqMn3r79VoMKR5a0hWfwOvP4QgpkYBW0Xz+AKyJ9xbzTH2z31RoOVbzsfNyDFUl8FBY+n788jJfmd0rUPqmYV9Lz+1VnyNaY5QkMD9pOqXID1uNaRTfkMEr5jHhup8NQB3I2jB2K7U2c/Su6mS3cD39vcpBabEY9wJyc3nIxvYjyi4OnOH3HiunXYo87esUxU56H/1/fXmZF3VgMc+CL3jaEpO6Wv82tSUgmL+8L1wmmrz1Bpa5gwUrY5bqXZMP4NNDa7xz22iZ9oZLGZwtsG/Br9ZFQ1pY2rI4LkJioYbibJg+qbu90UG/WkzH9/m921LSlkarxBF+SOPeu4cA83oX2IgnQE5EJ5E0awboqiIh4mEfaqLnxkiXo4nMlb59V7IwfGzCwaXA8vmYAzTgnw7FF1yPjIof4rwm/vTGKu0btdNC8dpFR+LEQgqaw0XnC9DCs/WFf6+V/2dfQ0ZYB9DEEtb+340r/PzMo0jf9rUo8A5lrFYBikvm/vnWDhN9rjnfbyqYmRPfec1yAmRGOJGISPfCtEzXVHW0pFZj9949PkqFH22q+8LyR63gK/7Z1D0W2Y1yBCk1oa+788RXZ8LGWC/9T33MnIeSFFmL+5RZu1tjYzz//g6XIUqKlukMjh9D/rSx/VKYJXU8wujqO7cRmuPoa+xMWEypPTGEFidkBP4bkrRzutSkkPGax6iMZ42dX0ACgpa0D/fiQxtU0XPHIWygOumXk8F560TMlaPQMb8baN7bSkZ6C9EDsVeyb0yYz+D7+cnIKjG9uis/YgUJKnfXwwZ/nMLF5WHFu0jU6Fo9ufKPNPd1/oNvt6/pIWZr8jJ8wZyXP7p7+s7yBB0EqUC4L8Cu2c9PmX4j/einsjZNxJBv8yPoBJXQnLPD+QYejOef/99fuc7Ker8LcosLldDaOOseR9Dn5I9oy3KYjw/2lvO9P24X/T8M77uqhmpnjbczo4MtD/4eB9LHQYIjaG/86Osse/8Xd85dT+GBm9PhgGF0XrZ0d/jn4HFy/GG7AWJ43q6rMd5LP3ayffYT1GtqwVRjZNdqUFgDqnaTGXuT4yC9e5B2cyf4xnN9dIoyZgb+Jr41c/IO5AzuEv07BS+voZSCkiuhUNmfhTEso1/nh7JUttTOv8fRbry7VmPab20zBkoWp036GXKfhlq8IolQrUcMe2i53oYbGQeVVLLRgnOaingWpTmlxjYfnMBMRNM/Cr0dTaU+fCh9+96WoF3mpKifacfBEmUxNxIOd+GUursrDXiaRcf40+AzdMHIYqeTyAv7st6DMfQjw7IEJ7A0TyL8KsnGMxPGsPLtUMYtZegrIdkr/gZuLjC35vUH/oVGYJOQ8blb1zoHYmcNM/5c0e1lr2qzFhs7X0ciupdlYumbIuisw6lhVG148BHIhAfiBTbE5BRZDnkDPgEOWl2Tf1d3TkuKSmOsyIn9zeUwRsnY5g45Ix4kcZR6mcSFQ5GRqu7UGTxFyhLMnfwnDQ2pKyF4E7eRcrL7sjBlKzBnpQgUCq694yFxxX956TI+PQzkilOAuZrqj/10CjJEt1QQEWSWfyT93XO6NneCB7vN+CgCn//gkhpnTu6NysK4tgXwT01ICdkkh0zPQo+eSDrccxw/noj51gC1fMmjeu79Ea1vW5t4u+TPe8RJEv2T90/HgVtnQqcgpzV5yIH5RaUIBzrat1nME9f+jn5A4quLmeE741k9yPH43sCMnJOg+SpjZBT/jZkvP2KxhlOuxM57zIam3Lwask7PgMKFvwZ6TZ/O99PUq4ma85adHbti861h9E5dwySY39DsFJrNfH3ucpeovF5fTQwfer+Cb6+JvXPM6PgqSMy4LUL0l2uQIEc7yNjecVRIjKai74+B9/4O3EHjdFO2pITZAffl873s+Rf5KSLA4Db0zhQIHMo5rH0J5FbVkY66UhfY8P895eqNfZj2xPS+ykKFNoR6QGrZT12zehnsnf29X3yZYQCsDsKmPsdBZvMiQe2o8ChZf33qjuAkX2kLYJsTJzSxyO76gzR8/fi8JtFG8cxzpqBotV5g6kMzjN41R0z91lsSIMOlm3NjOQQmRil9d2CimBNC6xHqUj2OygKPlfC4Fj6NgWCr9gd2Cy63hZFr56OcK4bKFM7px4aMkb19t/7oGjREyk5X5514SARhifzg6vq0Va+plamFEX7FA4rlXpuAzKuwYJgN9ZCRuUBKAtmHhRxOrU/0x9Fl3yEjJoXkKql0loapSiOJSkZRJ9Bxq9ufq87Kta5OnIWzEKFoxNRdOf+KJrzc/85AAnzM6A07DNR0byrgfWzHrsqzsnUyIieOMzPREbJ0YT8agqe/v87I2H+PBrXV2rv7809zmOuioe2oJ+xsWFqVIj3W0rRfGknc83PclSw+zMU5bwdijxN1sghqWfb41HZKKrshXLrJ+MxT5Su/XyfHej8vul9eh3YKPU3M1FluB1KstKOyIi5XHRvAWQA/w1FPO9FHWbGpPp5DXK4X4OMwtdRcoDEhpJONIZAqsg7EM33Jal1cQQy4PwOPBGvG+SIHpG8nxNCQ46zKZAzqkd0vS8KinnLx/FBYG8UWDIKWDue73juKMGv7BZdS2SCo/3eL77vJBC0iWH8xazHJO8NBflsjozxDciZvgIuW6WebdOSPW1s7yElHWERZLTa0t+5r0nBB2U4TisgaOXHkKFtVzzQBEUhb4scGesm+389NCTX/oocS3Gw0zS+vw3xdXE7kTM1jy3aHw7FnYup+7t7Xw5DOtZtyFCdWSAkCqRYG53VP7Xk/cpTI4XwgeSRq9H5/QPSFXJZKwfZle71NfIVgmjsGN3PlbOMxsFAq6Mgp2tRME4CpdoZWBYFEJ6InOCZB/6m1kgboqy1emookPc13G6EAo//9XWUBJztQY1k8NS4XsroQVkH+rs4k39OnNKnZz2W9dQyZ6BoraTBAIMrDP72dmTqfqbQOn6Y/FhmI+njG1sSPfUoUYRk3holpXEjZEROsnxGIMPOPNGz3RF+8h2UKWya94YUkgairCpkiDvBf9/Y+z0gEpqXQSmc29aQz6mQwf4NZAi4hCgSJuuGFLpkfQ9GGQgNSGn4A0XwfI4iXF71fiTP75U1/1UYj1i4+AYJ9A8io8EIH4c1ygnKVMkgjYxNp7ug9QeKyo0jtbvRGJKlVUbnIuP7PAjvfZi/7zshZ0HN+owMBz8Ap/nndI2Cefz9uSjrMatAX2OD5VLIIfssboQm4+LhSAH4ksZR8FMix9FjyPjTNtWPKVDR1O2zHt9UX5JzahJklLoAz0T0a2sjp9hfwCYZ8XgryqxNghzicd0QGTV/QA7sBbIe0xaO/7xIwY1rVd3jZ8C0/rkXFYbXpWTs2N2//x1kMIvhVqfw/W8QUr7PQ46DJ33c637PGcsYJWfcpKhe0bN+Jv6GZNyzgXmj5+dHRq4E+vNz4KSxfMc+fr587edLstZ7+fdcjQIiOvre0hcFZMxPnTois5hHP0f39L36dyTjzEUFjZDAfCjTZpLU9XIZOV2RfPcBGRWQj/aAVX1d/+Vr9w8Uaf66r/tcBRKMpU/pCPXFkZ6RZJO1T50jWyBd5Hskb+TSYUBjXeEsBN05WtYtqon0m+8/X+I1qLJuvofNnDUfFVpT5bLK1kNO399QNtDBWfMd8ZaGQN3F3/M/UaDQelnzOBb+r/E9exDKABuFnKxXE0EC5/HdLbdW6qWh4KuPUE20JAvmYRS01RfBpib2me+pASwhJbl5P18Pq6fub+b8XAjsjOp1DyXnEHx5a5kzULQ6bumNGLqaask8ZDDS4HPLAKKsXHOB6Vc8ioKUgwhBE3zmm00us0miTbGz9+VeBHsxKSXP+YIouj4WfkcraloPDSlPz7ug1RulSt7iwsH8yHh9MaXI4S4ovXMQVY7WQEp6u9TnWVHqZoKVfAAZ4z0jg8LrztMXKMp5YwRJtjfCHL4QGYAeREapd1G2zwd5FLYqODY7I4PMMv65N3LEPI8U4xt9nVUNIgwZLWKlb3GEqz4YwW2cSgQdRyss1NnEuHRH0aNJTaxHUbRWTdL6fS8ZCDyUuh5jPz/t+24mNdFa2K/EGDQbciL3RpFwMf72KshZ8DBlIpprzO+MPv/bRdeSyOcnUIHXRhHw9bBnISPlQMpEByMjyiv+/k9fI37iGm0X4PBolIzjccZIO5S5+lnW62M8+nsQynyYxz8v7+ts7WgszkIGlF4V+s4Y8uFP4DgUPTscOCb1bEeUqfQQCiT6GwWa7ErOa0hUcI5u83F6B8knV/vvw5EB7tDUePVEAVaTR+u27F6ADGQDkLwzChnpl0bBNJ/ROCOqURAEdWzsyWgeO6H6FuciI81nyCHZryVjSSkobUU/o0b5+/EgyqCMYYFCNH8JdPWeyPkxWjZ7FcdgTSRLxrLe28hwtVDSL6QzfIcMoVtnPXct6GfyjvRDMsSFqfsJLFt3pKedlswDGQd+NNGfGKbpIuCW1BpM+tuDUjb9tFnz3ZoakkfP9nf9UB/nGKq2q7/TXwP3Zs1vxNdoeiNCZjnJ98CfvE+zZc1rxF8i+6yPAkYOwA3+fj7ehgIZHqaUDVGch5WdgwWQ3Lm2f14Y2SPWjp55wGWVQ2vATxqy8RZKKCLxvT1RwFADsh3lrl5b3lvmDBStzlqs4EBPS1IC42gemMZgP4M3TDBmL1nGdQ8QZFMDERQIMoYmAuJWKEVw7szHeOx9ORKlviaCfFekkBySCCoocmTTrHkdjz4mgu46Pm+b+ef5EZb9t8gptUT0N+v69XOrwEfysysR/Bij48BOigzqSXHRfXMwhu1QFOi3vm5uoXydiPj5ichZKnWFxiQ23m4JPE4Eg+LXJ0cRyV8hx8g5VNmpCaNBQ22EDM6/IwfZztX8/oznpAOKWJ+NVOSVz8U2lLIBqy6ARt+/p3/nRYxeZ2BaFOWWGwWwmX170/s2zM+9+5CwvSJKN1/H94ubyBAKAhnZGoA9yqyZr4GT/XPb1P1cO2V872kAFvHP6QCRdf1+zWoGoEzPr1F03k3R9RCdDfFZl7v6PGPoWzradmvgj+jz+8jY0MM/d0GBCo9QIaggSsa985HRdX4UXPOsnzUJVFEc6NELRUVORx05fiswRklgzZ6p+9MgWf0xfz8ewjNWWvLOI8PwVpSymxt8H2yXeq4wOo15HBNDXg8EEbYYKWczyvJd2s+aEehMb1Z0b7Q+Ovr59CYy0m6M9IEfkHy7Jim5Lvofm/g8z1GjsensvA7ztTW1v9OvATum15fvwy8hR+xcWc/tWPq2JApi6pG63ha4HBl1t0nvob6fPUkTdWTy1JADYLivrZfjvlBDJ1JTe1AteahhXxOH15YocOVXPyd/QwGZ+/lZEAdIzUiV6kqOI8/JHtgf6Q53oGzjVRCUeiw7LYJgwIaRE/jEVF8eQBnQiTMm1pv387PyjPS9olVk7CdCAQuJbfIs5Lzv55+7ILn0f4wl8KRC/CTfsR4KIrojdb1R8Dc64yfOehzrsWXOQNHqqCUCAQSD4w0+Mhhi8LrBrgazW6zIwLwGlxicUks+y21OKErreRdyd6Mxrm17FHn4FjnFIY14DQiK5QXcyYWwzz8iygoB7kQe9Imy4LPCfb7bhbCk1smmlIqtP46yCC7zuX2ZKqT6R4fPUf69V9G4tkSHSCBbG6WXrki29ZM6I8V4H0qGnauQs+g7FLE4b+pvkijCVm2AQE7NS4kw+tPzTSla/IMa8hUL7T0RNuu7yDH0GjkU3lvYz0ThWgYZ1RoQdMcLCGIvXfxyepTFOG8NeEuMz9P5PprsM7shJXAmf3eGA0tlPZYt7ONMyOmys++vr6KIvZGomPAv3u+/yQDaxc+5tn7WDXLergEG+P09kHI+T9Zj2cL+Lefje1rqeqKELepzUDPINeSIe50Svv+FNIbS+k8Bo06UcN83RssoQQaRYb7+9/M+L0DpDJ8fOWkSyMLxOg+jPWUGH9t9KclvW/u1jePnI166Oj89sx7PGs1ZD3/fT6TkIEtDRs6OZJkG4KjxnRtkJD8URXb+5WfQ1FmPRb01hH3/j8/LIFQjZMXofhsUtLQdcGUL/n+yByXwrkv653Yo6+UxP7N+QPLCUjBaPahDgHNqOCYdfb+/1MfmY+QUepgoaM7HJq5tmHvIYEowgWf4HhXXxpjd36e/USbMEng2Lqoj818trPHdX6vUtzbeevpaesv7+i4uh8TPVZGP2FnXHWUvrI2ydlpdxjyls7I90ntuBGbxa6f5HIxETvQNiTIis+bZf3/G96J3KDn6b0IZmd1Sf7dI1uMd98FbZ5T5/2rqXryP3oocZVUtRUDjYKCx1QybAmU6T15NnjKYl0P8PUgCT+b3ffWwGvIwjb93/yJI2Lmie63OIZzZXGfNQNHqqCUvHpxk8IvBAwa7GTxsMNzgEYONLVZkoI3V4IUd04FMSYhfzTeTEUhR2AEpyIcgA/VtmY/xuPX1eGCw/76Qb5RbUBLmZ0YOgbrFGqcx1MDqpAo4o2i7c1C2zA9IgT+GCqb/IliTZVPXFkHwdz/64TTaoYgKcT5JxljjwLF+kN+Lw3L59aWQgXkIirw4EOgd3W/VByyq1fC2C/WNjGNlnu1IhSBrmsFfGnJwZlRH4BdqFNVZ7f5Fv3+FFJedkKL5IXIYvoQge2IFPxNMdZS2/ztywCTGpsGMpU5BPTVUk2UKZDg6HDm5PyEHRRl9/d+EDKWfIWfYX0R44WM6//Pa/J1OnPtxvaj2KEJueHKdKhmsIplh0ujaxsjoNMrPsc1pHIlaF+cDgs351dfyRKl7bVEgy48IRukKSlB40yLZYgge6Te+64uSUeFh39v6R/faIyPtK+lzyM+C1ZHxefGsx7RG87YekunWamoco3G7Gxl8Z0vmNf1cM763LapHcpmviU+Rs6xH1mOS50ZJTt8CycRn+Zq9AdXoG4xqb8ySmrsWnefIofM6gv7p4deu9HdoIuRY/R6d1YNJOe19nmsuSzjf6/iemsieLxFlBUfP9kM66cVZz+9Y+jQx0ruGotop+yKdum10/2Lk/P7N97Ff0Nl2tT+TR2fMaDVAgTlRgNbPSN+8kKhoOFU6F6Ox3IpSpniSsfMidVgfdiz9Tc7KA30PXsI/d0O6wQn+Hv3s+809WZ+N0Rz9z9f3Vv65n/M81N+Bc1ANrVwEyjb17iGH97/A8k3MzfEo62+WKvHVjTFkO1E+6PpYfzcOynpcKzknlOxf9/pe+6av/S5jmsMK89QZ2J5S8OTXwJrR/bbl5qRozRznrBkoWp205GWDvqasmKMsgayA8w0GG7xvMMzgMoMVLFHyayRw+aZwI7A/cr4s7dc7R890RXikQ5BjJimO9TwZFXkcQ3/WoowxGNWJ+Q1Fdr5ABKuBDMhbef/qNXr7P5zhqE8XIWPtlKlneyNDYkWx7FE0VwMy3B8ZC70uLKyMDDoj/HDaFEUvrYii9F6tJD8t4H97FKF4Ko3rQ8SG/m0oRYQ+hqL26qaQ6HiMTUDRe3v4/A5DRt7+WfOW4jNdX6Yqwm8W/fKfRyCjQxxtOBhBtX2OjBZ3A+tWmZ9EmeqHDOHXI6is/ZL9F2WY7es8H4ng1ermXaGkSPVAWXM7IJi46RmDIYGMjCU+1nunrq3i591IpCweSWQspc4UAkqOpqHI+XUJKo55PYo+TAxWFetXtA7a0Rga632UJRzXqTva+RiMjKvLZD1mzemnr/XXgKv8Whca1wbphSL6G3z8z0PO1ze833v5cxUxtKGo5gbkeP4vCth/HuP3VoznHGVuPAG8nfWY1nDuBvhYzB6PReqZNqlnK1b3EWVRrEqpPskbFBAc4zJu56A6P5NF15ZD0D2DkcH+f4xnphfK7nwC2Mc/T+Nnws6UiiBfh4Lu0jVMan5GpM9QlKm+C4qkb0AQa/PRuC7GesjovmXW89qMObmFki69MaV6rW2BeXx93I+c3xtSMihm7uCP9pPZkaPlv4zFNH/ItnAvcvZ/5mdGVeAkI756I8P+nSirfBqEivEWpeyRzMexgv3uiOShO/CMB3Q+f4kXCve95HsULLVbDnjujpzCJ+MILCiz6ns/py6mVF/jODKs7UuUdYLqrm1HY1l6EZTl8wYOPRn9TW+Urf5xFfm72cfyfmTP2xEhFkxGGWcWkmdXQnU9l8x6LbRkLsbyzBYoYKcBOfTXTvpdRb6mRjbIlZHO2BllC+6LHOsNyBka28ZaXcZeTddC1gwUrc4aHG3wlsEC/nkWg1EGWxtMYcqSaTD4y2rsqXbBqAEZyX9EBumBCBv8OmSAnh8Z1HsjoXgVVDSrZ+Zj27gvCc7x3Sh9PR05eQ4lZ9JelNIZt/IDv15rG1yOFJU3vH2MHB5JX58E5kv9TbWihxdDSvmvSAHcmcbK5pQI4/ZRpLgP9rVX04KhZfhuiyIozsMzX2jsiGlUBwDBsP2AnHjXTiiHqu8DC/u7lMC47UnOjC+0IkUr6lNXf8/PoBSFfra/670QHvR7/vkPYJUq8ZEovJMi59xwXwff+n7zHU3U76nWvlOt9YOcL/d5H//2Pet5ZGBoFFme/lxjfjvgEaj+OV1fZWfksPvD+7Ne1mM8lv7ETpBpEMZyj+j+9sjRNNjX3J++dyeFMytuRESOnwOR8XlfXxPLMzo0xQxIdvodRbufTR05Ir0PidPjTh/ndWh8jq+DIu5/8TX1ErB+ev4qwMfcKLK0d5l70/u8Xx9da4cMEQ2kZJ7W3PxMbgAOS6/HMs929r1sTxQMczGwQoX46IXgXi/Iekzy3KL9bQ/gdv+9UUYd0r2e8X3mxebsIT4PKyOj4XR+bS08gA4Z7D7DHXh+7XLgfzEPWY+T8zGr/+yMnDAn+Fn3C6otdSSCZXoXuC9rflvQvxWRE3wkCo5chqjWGFWGOGohz/H5/DhydGxHFKHv8zV59Lkjsh+8iIJDnqeKNTeRk+gDvMYtgun6FwUQJU7IVcgRBFYF+rwPcKz/Pimy5RxCKZN1TR//6bPm1flZCtkstvDPk6Bgv/18bfVFgS+fAp9nzGuy5nfy9f4uEWSq31sJBcGORFmj6yFZ6Trv11ZV4m0+dP6/hRz831CyAb3r58hZKHt1bRRok6yJXNsuKOmbk+BnWTwfY/nb7ij4uCp9jNbEVMiWOpSS3e1fJCNvjwJFp0dBrIP93qlMADUOq74+smagaHXUoIPBMQb3WSk75m6DVywpzghrGrxtcK3ByrXkzw+MT5AiN7sfKIcgo/rTvsH8irJLnvQN5UQiuJC8NN+wt/IDaKjzOgtRjQ8kEL7vh+M7lIyIj5MxXFYL+zwvMsI+hiJyb0RRMmchGJ2LkOLV4NcrjhVKyRC5JKXIo+1cMBmEIprXpnF0cT+UVno0itpZOONx3NOFmKXH8Ewa+qMPKuS3f9broArjkY5Q7EljJbEHUvjvRMLn8yiCr2bCHSmYstbeXLB8mlJhyImRQ3B/SpGTF/q+VjXYrEgIvdnf8Q3884y+BpKi8pchpbxu58jH+z3kwO+PovQaUFHe2GGbuaMJBVG8n5qj2FEwCXAmUggG+nmQu4zQ6DyZlJICMxQZkW/CsZiRg3JhYFYaw1lVwxnT2ddAA1LG/3HeusV8p9bEcsggdGrWY9qMfrZP/dzFx/9vJEssy+g1D7oRBb/U8l1ATrhRuFENQeR8DNyQ9VjWeN66Izn+YyL443LvAqq19Dslw8FgKmj09XM510aeDOcpMS51RDLw1kh2Txwl7WicnT05cjZs04z/nQRFNUTt8NTetJnvYcv651mQU/WqrMcoWUP+c1PgpdS97ih6/jqUqd6ADLZrEDmN89rK7Y8ooGIXdC7/hqDl5qUJWOCsG6Uz+hwU+b1Bmbk7F8kYC9BYd5ja/26nKvLXCdXsuCV6Lx5AEfNT+Oc2yBF2eL3uV5TgUxeklCma1FmbHdk3kqy4tgga/D0yQjaI1kYyJzOhANpp/fOx/i7PHP3N08iJVlFEj2bynfC7jL+jN9HY2Zjcb4fsIBegwLRk//0KOK6K/HX1d204ktHao2CWpRGU2lXOR+LI/svX/t1U0Sla4T4+jc6oDRlDlj+NM5lWRjbNataraoOyn35FMKC7I8jiq5DjJQmKntd5WtP3pgaUCZbLPb5eWuYMFK3OGqxosKH/3s/ga4P9ovuru4OmSfzHajZKWTL7pa5384NnIFIKbkFZNA1EAliemgsdfZGRf7BvePtQyobphFLB90GwZZegjI1Jsua9hf0tGzVH4wimJZCh9k8/jA+s1AGV+p5ffS0lwkkXpFgMRNHZZ5NhFsyY+oCiFT6jJKw3hRMbUArw9XjkVWtslBSupVBh1cR5eUncbxQZsiVygv5VTeECKa0zIkVjijSvE0JDWMqT+e/b+pwsEt0/BmXQVNUoioxJPyM4snQ2xswoa6yBVD2pemjRnrai75kbRfdeRtAbCSREf3ISiY8i9xpIKduMnsExL4K1aCCHEcXR+N+JlNqzUHT3pc7zBqSUyEqdZ2PhaxJgcUpZOS8g5TddayU93nXrkIz6c7r3+RtkwJo79UwmezAykDSgqPng8sa/5Cx7u0ZjsRpy0H9BFNhFBOOJDDeHIsPNnshpOFXWvE8oLZqHU5BcPISSwSauF9OBFhqJUdbqx0jOP4RSQNbh0TNLICf380j2fd7Puv7Jmsl6jPz3A309j2aMRQEqG6NAhAZgl6zndxz6luhGM/v7lz7HJkNBE/8ix/8u5CSbIT0/SAb8x+coyThJHAQrU0Le+AoFDc3U0jU9LuOaXrNIR3vVf1/N+VkzmoO5UQT70VmPaQX6/yGSj/pE1yZHjvcHkRNsU5SN8nDW/KbW0X8wfMjO9B4l+bof8BRwTNb8Oj/vAXcBMyTrronnejnvKwMboSzvqjs+kGPgfVIBrsje9RfKyNwcyQDv4NlUeW7ROjkGnZdDULDfMjQOMki//0sguL4Lq8RXso+ciOxbowXm+p53k+89H+IoSQhtaH+qlDE1IbXMGShaHbZEyITJDb4yj3I26GSwl8H3FkW21aLRWPA9FKU4bhZdW8gFqn2jQ7MbOTOqI4iQzWkcpdkBOV6u8j68CqxLmQKwWfNfgf6noXPaxD/9917e/8QQVxH82Oi7zkUQXvPHPPnvs6No+l9RVMYh5K/2yLnA4HF8thsSdLdpLWuoifU0PXLAfo4M7IlB9B4iB2b0ri1QBV4SBW9ulP3V4Dy96XtWpzTfrb1F79yqKDtpI/88EzLs3F8DHqb1d+DgZJ5S73x3pABckvV4jUcf9/a1nxSJ3w5lVi4RPXMJyoIYDVKphnwm7+v8/n5s28Rz7VNnwnrAglmPc4rH5AxbDBl7tonuPYpgMKf2z32oQsbnWPhLimPfigxmw3xfnIvGkEOLI+NC3QR6ILzxbRHk1zx+LV4v0yJ88gbkmNyOGsusTfD9CIr8XA85yw7PmqeMxqEbyjiOIfySbLKJ/OehyIl/Utb8TmgtOreX9Tm6GUXT3kYJxuRMGtfvHKcAFxobh34kKiyNjIHf+t4Z11wZgCBuEsfMtn695nIUMFG5vQTVZRgCzNbE37VFten2pw6yYyK+L/NxvxNYtcz9uZDhtwE4K2t+m+jDccj4O5rcjxyC1/kauw3p4C8jB3DF1hfSPeZPrYdEHkrktTWRvnA9pUy0Lsg4/Sc5RPto5hjMi5xea5a5twHSy0f6WvqM7LJjZkNQZKcAczTxzCGUasbNhZzFw8utsRryncik6/s+vfbYnk3WZlP3qsBjsv/Pi4Ij36bk1JoMBSZfO67nSV4bQua4ytfIt8hJM0d0v0303Jn+3BidZ+O5Jqb39XkYnrWDdOFGDmIEP/o3ci52yXocW1PLnIGi1XGDbgYvGgwy2NfgEoOfrEpe3HFtyGN7L4p6XtqvPYwiKmb0z7k0eFISXNcqc68bSll8CkFb3I5gTkYrcjYhNGR0qUjRy+hQmsHHf18aw5msSeOCwEmB6V+QYWcHMkxDTvVlG+/DSknfmhKgkLHtA2DrrPmu8pg8gFKEF/LPS7nwsW0ibBJFZFWZlzcpFbjdkVKxvvdIFSeupuCbp4ayhd72tXi9z9UQqpy55cJmVwSR8waNIXISqKOOSAG/jTpJiU+vHRR9OyRa64OQkTMxbk6M6i88ngch2+fkMxyuiSZgiHxvm5Mcw3QAByHoirn981p+fq9MSek6DxkUa1a/ytd+PyQvzYwMoIN9bRyCaqTN5Ov+l6zHcVz64z83QhGTCcTGa5RxyvjnFZAzajhyAM9eS54jPhL5Yx3n+Wfgq6zHNOuG4GG/iubyOQT38Q0y+l9PKninaDWdn9NQ1Po0/rkzkpVvRwbkQcCOzfh/ceHoJIAuCWRJzq4HUMDdRPHf+O+z0tiZnEUNtFsQdNsqNIaj6er76x7+OelXzH/uaqyMQ3/7o2y+j1AG0CW48zT13HqUYKBz9a4i2LGP0+sFORx/xzOHEdzxAN+Lzq8wDwf6/70Od7ak7t/o70QDUU1FBG3+JXBt1uPYwn4n53Z7BFf2Mp4VQePAqI4oUGdHpG/PUGM+E+fYeshR0ICcQ79RBmUFOdhup+RA+pOcOCRR3dgvovexyX3S9+IryQAhADngP0A2r2nQefMLgir9D9FkbH3IUyMFg4ocTy/4GnkVZRJOFd1fM147VNh2GY3jI0jv7h9fj56L38UkyzxXAe313jJnoGg5bonQBPMY7GzwP4OFLDYaQB+DWw1GGvxucJPlQKj0w/tuPzhP8UNxS3JsuHG+Z0RwWEmRsm1oXKyyDUrf3QEZrP5ChpSZ6+VAqsAYVbyfZQ6lftG9npSgRNKRIrsjY26mkS8pnqZHUbav0Rg6og2Rc8YFxj1Qts9MWfNd5fH4Gik8iRL/NDLAJZBZfVzwW7JKPCRKx44uUK4R3fsKFad8i1LWzhLV4COj8R8n5RsZRx/39+lpmsiOqOBcdEDQB5OjQvENSOldnMZGnfl8rz0n67Ech76tRmPHcRtv/X1PuMDbQGSMT/aCpVGU1qEZ8n41jaOhLwR+Tj3T0c/Idf3ce8T3r8yyesahX1sBf0WfP0NGl27+uTtyhj0MdK8yL4lRYRrkEOoe3euKHNU3IGP3F5Rq1K2Y9TiOpV/JOu6BIigfQDAQayPn1+mUCut2j//Gf9/P34lMC5OiCNCPiQIqJsSWPjOAXZE8/xJyxtyK6vZ1L/d80ao6N4kBbHLfh0ercYSy73ZCDrSkGPM4v1u+B5XNfkdwKRf678l+lov597P2SD+TfkGRzf8FzQH3oWDB2Lg1NYIUPR+4LOs+NLe/0e+L+rn2lc/3odRJViUyOA9EWSntU/caFdJGBuoPgSMrzMP8lGCxhwP/S92fE8lEP6KM2ydQENMQ/72qskMN5uBUZM/4nQQW3ypvgG4hb4l80dHli/tcvlgJ6StJ4NDcSJfs7Z8n83f7EJQpnYuALpR9+kcznv+q3F5cZR4TPW1jlBl1D5JFDyeq41SvjdEzTzbxfjYgWWdVFBB1M3L6JeduNbJjVkjOW8bBvobqtDXQCmsOZ7omsmagaDltiQACMxv8aDDK4A93vNxtsIbFadUwlcGs1kQdkFq2aCNfDMG0JIa2xMmRS8dFmi9KkTiPIeVm0uhee2RoPgF5z3+mxpAnWbdKzWMTh1J8UF6Eor9iJ02sUE1aa2FlHPq0PyVFeFPKRL2jlPtPgGuy5rfKYzGxCzrb+edNUKTZABpHJn8ArF5FPtoCD6EIwqS+z8FIeZ8RwSp+5sJXA7BJ1mPXwn7GDr9e6etj+hv/fZJKCp1j4O88pFwlUDgn+bh/DJyM0vrXRxAov8Z9yWNDUHsjkcFnk/Q7jxSZpGbIFZQcAouhzMwfMuR9ZWQ4/97fj+kQbnJSJ2w7hCn9DqUi3iP9fTki67EfS9/mRYaG/ZCx7g9kXEnklIV9Hz4+Xp9V4CN+xx5AGWGj7XfIiLAmpUjvcY5wz3CMk7G80cdy3uje2UiZvx85Jf9GZ/rsqf+RGHczDdpBDuH/ZclDXhqNDaGdkNxb11AlraH52T4EGcjexQN6cIiT6LmZkVNinKH3kJx0rp+5PyAYxcX93qbIGL1Y1mMwlj70db5HuTyxHzLsH4qciluhwIg3kf7WgGqMbZo17y3oa9qBsRGCwkzqCe1QrTOtgn3Y1fldOrrWaC1H15dGukLFdT6UYbaCyzojUZDM+tH9SfwdOBtF1d/t41u3tbMoGZr3QhkCw5GMFEPOBzLMhIhkg0tRNtLC0b0D/Z1+2mWLoT4v65VbP3loCBa/IVlbY5J5ENzaB8CeGfK7he+T35GqKVPvjZTDEUGXjfR34HGfpx3HNk/jycM+fpZ/jWyNZR3plOTs6X2tb1MNfibUljkDRctRgzkN5rPYiw8PG7xqsJ7BjAbbGnxiMNTgYoOFLQcQJ001ZKR6C0WSzObXciUcUjIQ9kUGwBgqaxek8AxCBbXWorGS2hkp8LlyCNRjSx1KO/vYzomUqu3SwhWpgsd5awgLtMEPzhtRpEkPBMu2MYp+/og6j6wah3HoioyPt6Potq9dsE6ia7ugiKGvgCmryEdvpERdHa2fn5FTNSkkeqQLv2eRg0zD8ezvGZQpUDum/RdFPa/rv1dcmaGxs+hG5HiJswSWQopVQ9SeJ1KK89x8/XyGFPnLiGAGfL0dhpyRQ1AG3b1I8P+QMrjdNeZ9TeQY+hVBfF3h4/+778uDUcT16b5/5TKrD9UQiJ0fwfvyO1K0LqEUMT2z70V/UKptVxUlnpJR4WAUZbt16v5oWUYoIjRX8lIZHhMlcT5fLzvSWEa62K8/hCAvHkJGk/+Ue3IQSFSuT0X77/1J5jjXa3FCaci5cKKfjQl8cgyz0i71fLPnDeludyP59UMkJ/1MVDMo7+8J0s0SeeJB33+SYIJ3UUbJvsgpn/u6MdEZ0p3GTu9A46ziSRDM0Fc+f5nKFuPQr6mc169JZSbiyAL+ew+fw8FUOEqfxo7M7six9SQlqMa5o/ud/Gdd6Qg0lotG4x3ZQI5F8usQBJe6QHS/ba3PgOjsmdnnYhfnI7l+sl+/HTleL/J96of0WspL8778hQJuukbXG52zvvY38fW+TAZ8ton4OAoFKx5Wbj3Ve6OxzDoFgmNtAD6twXd3QgGq96Dz/EWEttAUVPQGSM8cDaqvaOMxD1kzULQcNfjUYKDBrgbTGPQ2eMRg79RzXQwON/jT4FuDQywj7O0xtUSQQrBfv6NCYLk0Pjuv16EogK1T97pSSmX+EkXHLJI1z1UejyyiYNKH0nNIaXqSMWD751koQIreo5SMy3963xpQEc5lsuaxQv1MFMWZKZPJ4EL03y5oDKZx8cwVEQxKxSGp0mvD+UvqWK2HIrZXiu4fioy3uXVyj2O/26BIvod9rb1FBHtEymDtP2dEToLfq8hX8l1LOm9n+eeONFaIF0QOgiXrbS4QZMLFSCl8HzieCNMdFTS/ECljzyH89NEw3zPivQOK+HwJOQ1GIKPfojQBeZP1/hutqVmAy33sZ0k9056SY+BbFAF7KnI8fU8pe6+q2RnI0POTr4lJ/NrkyInxAapjVZdRbyi69ktg5uja1MiwczSljLBpKQUr3JQ130UbbR5zK09NyK2MLNMJ1dg4F+lXv6PM7P+MerTA0UnK6Ipg0V5HTozhwBHxmUzOnTLO4+aUaiF9g+S80eqE1EtDEF+fAXvTuO5eW0rOguN8Tz4sCx6b0ZfgbR+fn49Qxsx0ZZ7dDs/arQIfsQ6T1KyZERn5ExjLK2hsQM9VIEEz+rooqhVzHbJvpN/5hZG9ZhBybJyGowpkyHNSMzbWYyZBwTQnUwqo6YECa39zeSqXGZ0IrrwBBSs3pZvNAzwLPJMDftv7+h9J2iZZZ62pM4tUkC9y6M/hv1c9cxvpB1uhANZRKGhxntSa6IaC4r6kFUDH5allzkDRctKgvcFKBvcYNBg8bbCqwX2WOAggWCyUw3QGV/jzJ2fehzE0FxyHo4iL3AjwlJSXE11gPzC+R2Ov+UzIkPOHb5gH4sbd1tDyMi/RofSiCyzP4EWB67UhWKKTUT2lExA+aasyfCConcTRtERagEEK4j/IcHA4ikDbGymWH1BFfF8a490nqffLIIPzhv55WhRl9VzWY1nBfvdzwf9tn5s74j2LCCYIKZ4NVBE2zr9rSUrQZLem9thc1xgbS7/+iyT3z4ugbIDfkFK1F42jmDOHYEPZJEsh/Px5outTI6fBh0ghvwVYKG/zRMkZMxOKhP4ZQV7GWVfdot+XRTAE3yFHzEPUsD4LgkP5GVjbP7dF0DlDnf9n/N3YKOuxbWa/pkIR2SNQJPoSfv1G33umTJ933teXkAGlVZ2FraGR4+zjCbm5bDV59HkS5DS52/eOD4lq5FVi/pEutC9yZvzmckRV5YQW8hwbrmakcZ22Hig78S8/005EdUNyUVeimf3cCAXP/IyybBvBIvt87Y8CP/6Lts+a73Ho1/ooS+ZfFLBzKKoLMgA5Hn8CHqjkWkEZ+lNE1z9GOlri2GqL4IxP97U/hDo0SFOS9VdDUH0f+nhPFD3TI/U3G6KAwp+9ZVLLDjmNHvD97WXkmOuFstA/QhC7aQSN21HAzWR5lC983z6LUqDmpSgQra3zvACqTTSQKgZcj8u+QMlO1gMhxTQAA7Iew2b0MXnX21LG0Vvm+bbjMi7V4hVlqh3h59QfyHYyld9fAqEYHJT1uLa2ljkDRctRgzYGExtsbvC+wXCDf9wp0yf1bOyYWcrqoH4Jiup5OGs+In6STXo6ZCg+Aujp1zr4z84Ig345POoWGRSfRpEC12bdjxb2fXZkpO4TXUvG439ZH7Z+KE2LImm/R0b844iiwYqWrwYcQCkTaJgLmDPRWLFfBWUGxJBUV1LFjDPkeBmtSDPKZHgRRcxfigy1w8l5Ae1x7HMasml+pGQO8j6eTONIv0VdeXmsBrxNRKlocAMqJj9f6pm6NQamBXkUnfsuMibcjpTcTtH9zJwbyEGcGHWWS/OPFMSrULbMD0iBzB1eOsqifA5YxT/H0HhnIQW+Z/R8PxTxFzsDq660IzzwUcjZ1dnHdhBwgt+f2cc611HNZfoVUIbSnr6PDEPwd6MoUyAYGVjuRxHcucyabu2NxnAkU6I6bpsBi2bNW9GanLPl/cy80OWa+BzphzKRX/VnniUyto7Hd8by25QIEug35NQ+lxzVFIj2lz1RVvB+ZZ6ZETmKR6J6V7vUYu+vQl8DcjB9RQkidVW/N7+fhw9lzec49iWWOWZHKBR/0VhPSHT06Sr83duhwt2rId33H1SnJh1g0xUF0iUG6W8q8X5lMNZfoUCoef1z8s70RXUdl6exrNQd6XZvkX2WzJoo62UkCgAZTgTJTCnYrh3SKz8i57Yx5ExPai0nDvVB/vubwOZV/v5k/o9hHAJfkf3r8azHrZl9TGSds/EaklnzNC7zgmyPl6GArU/8XLsF+Dpr/lpjy5yBouWgwcbm9VX8czCY1uAgE4xZg8HpBrNbnCKbzpjJefMNplvWfJTh6zQUbTRH6npXFAmWHJQ/IdiTHn7/IHKKUTqW/k6HlLYngP6pe5O7EPMCpWLbmRlHyxxKnwJbk4rkqZdGHb2vLejbAATR9Apynn3t78wBaaEYKV0DgBlqwFdHZLD9hVJ9lMRguxqKvPoMwXLsk/U4VrjvsWNmIgQPdy2KQPweOQu6IEjGBqqc8ZfiZxZKcH5vArvTGH6jrt6VSLFZosy9jqi+zHdIIT4PWDJjfrfx9/O49BwxulNpbZRN8hOKzlolB+OdKFkbICPK+tG1RDE/3NfXb36GLE9jA2Ot8dATB9EwP89GIniWif1+Aht4atbj28L+dUTGwARSocHnoFfqufn8XTgpnsui1XSukjPwiGiu/kCG0LsoHGW5bCibcTgyCB9OCu4SQZycDlxaybVCY+P0Ysih2kANgjjGkcdk758OBXBdgus35fYXFGT3BbBv1ryP6xw0cX1qP9u+9/aVn3d/4ZH11GGAC9ATOUu2Q3U05qjS96yCdIN/kFx8C1E9N0aH8+qNapzunfUYNaOPMRLI90QyanTvNn+fB6FAnblpnD2TeUa38zER0ikHOr8XI4i1uPbv3H6mXZA1v2PoR7qY/Ja+Z92GArd2p4r2MhQcNJ3/vrSP5RZNyWIogLFu5TQUAPUUsvdNkjU/zeC7E3IEP+znfgM5rwlWry1zBoqWcYMZTFkwr1kUleD3uhjMa3Cpwb8G7xnsYDmMUK3X5orGJcArqetzo6iZBmTMPYRSPYbTs+Z7PPv8IMoMKLupo8yZz4H702OVIc/xoTQKQcY1WVemaJnN05oo/fo2VKPlBmR0fAsZTsvWoagiP4nRaUFfM28R1Tjwe92AGZBjou4U1+aMg//eGzlinqAUkdUAnFdrXvzzusi41ADc55/r0hiIYBRGIaV3tP0VRTFfTSnjJJNodD/3BqJI68n9WjmjVZxB0g3BoLxOjqIOfR3fiWd7UjIwTIUMLEejTJSkfswxwDQ14KspxbYvisreG1g5ut4Z1e8ZRo6izlvY957I0HWT7/+v+3nQ1tfRWcj4nzjO6lbRr8dGyXm8jL8jV/gZuCTKmHscmDJrPovWaM5ih8g0flYmED47ANNG9yeiCgXH0+8psD2wgkVrKuuGAk7epQzMDyV5MNl3csHzWPoTy259UJT0DkiG6xfdWxAZG69ETrskW7Tu9lYy0DUpyaA/uowwb5ln2lOneicwMYJjOx3Pjo/OgeVd7tgTQaj+gyLydyKnsrjLURcgefsTBCE/PQqkPR4FvOSu/mR6bVMGsjn1zlf8XfAxOh05bQ9EQbi3kUbiifhCWVUNRDJrPbRoz58G2b728891tS/6+7s3cGLWvLTWljkDRcu4QVtTJsxO/nkGiyAe/Fp3U32Zx03ZMg+Z6svUjZc3zw1FKw9NFBpkTEiUnSOAyfx6L2T8+ZucRIu0oK8LOv/bRAdVh7RigvBLv0G40RugCKwdc8B/L1T8MbeRLxNiSwmQWwPvIGW9O8K3ftnfp7sQHnPNYZpQTY9ByDjYP813uc+tqZXp60z+fr/n41IVLPVon2mLMvBmKicMI7iIob5OzqzHuUAYyzsig2bizJ+lzHMrADdkyOcOyDmxwjg825Yok5IcZSei6OD3gXPL3DsRZZv09M/zogi5BmDZKvHTYiXP5+STLNdFFcZjSmQ4fIlSDavdXAbZxZ/JRT2iCbH5+/AgpUjZZZCBa2VKxqFtiTP4i5blfLWjsQFveWRkHYGCX9ahBnohOXVkoLoMLwA3l7mXyCGdUTZlXRREpjEMWwJtNMLbeyhYcKL08+l+11urBd/R2LZBmRYnU9L93/SzKnZ6LYEy6kdz1uS9oSDTQcDuZe696P3qhoIflwAe8XGYPmvex9KvRSjBYD8DHIs7GrLmrRl9CNH+VIt13w4hVFzj+8hw4PiYn9TznZEDZzipjMx6aMju9TGqVXtW1vyM5zop5OVqjW/WDBQtZw2uMfjL4HKLiuia6sv0NtjeVF+mweCQzPltBQ1BbPyCoufPo1RM/soyz16AUmGrDrVUpb4ujKJfti5zrxdSyA9GNQUafFxG+u9zZ82/81kcSjlrNHbIdPL3ZBiwgV+bHkXifOnC8jmxolNl3mKIotUQVM7dOB5ya11LTQn2qblqi6A7Fqzm2CPD7Jko+vorFMG6VZnnJ0UGwl2zHr/x7PfMvt4/873zAqoQsTwe/P3P34NpxrJW2iAn0/3AxlnzXYa/zsi4f1jCb3RvfuSEaUcpa2YxBGdTtcwkf6duRNlEqwFL+/VOZZ5NlPDlfK08SisItCmzx8zscsUn/j58lDWPE3rzvfYl4JTo2ifIsN/NP0+FHJ6bZc3vhNiifWvS1DvVPvX5ZiSnDyYFQTke3x2oQ2O+r+mn/Pf/9v7o/ibI2F61uoVVmP+Zkd52I7AGymY7COmsf6OAub7x3+S9lZmXmvONQ8AjZ8xc0fVVkYwaZ20vgQIKfsh67FrY11m8P5vGffff+zA6fPkBCHa66tnEFerfpsjg3kCOamxE7/BcwLJ52lNRltGvSC9rQE640fZFZBuajigLs54akvuT2moNKFh00qz5Klq+WhsKmrAphHb+M/iVixCG6QDgKkI4nhCmwqwBsx+RR3stZNx6JAOOWx2Z2esIXiMgDM0ZkDFlb4DgcxRC6IWMU38hSJp6pIHAEGCXEMKqIYRNQghHhhCeR9BFDyNc6olR1EkvVD9gajN7OyOeG5GJRmbNx4RMIYQ2/rMHaE6Se2Y2zMx2RVCAJ4QQBpjZ5wgeaWPgcoSPu04V+GrrP3uHEJZJLkePPIjq26yBYAlorWspnpNy10MIwcxGmdnjZvZqlXgY5b9ehiLl7/Pf/wKuDCG8GUJYMnp+sJmtYmYXVIOfalIQdQAws4+BM9B5cj7KmvkhhLBthizG1BFlgv4MY1wrDcjgMx86E/JGCeTeuiGEXmbWkOwBZva6mb1pZiP9ejvkoPkZRfpVi/YFNkIZOlcAN4cQBgLXhRCuCSFsHkJYOoQws5mZ8/Uyyvzc3cx+qSJvNaHUeTDK34ezga3QObAJlGSrgjKhP1HwRF+AEMKBCM7ydDP7y5+Z058pdNUMyPetuVH9rg1DCJP79RG+d3T0Ry9EEcCvIqfaOFMo6Z6EEDqEEDqGECZyOduS/TTvlMikKAN6oRDCKtHe38Gf6YycjJNRBzqcn7+gLJjPgWPM7F4z+8zMTkZy7J0oi23d1N/kjuK1lvDpc1JTvkMIi4QQ+pjZiBDCGig7ddZkDZnZA2Y2JzrLF0NwTvehGoxb1orPCtPfKAhnHdAeEkJoE0JoZ2YDzeyL5EF/X3ohWaku9CMzuwFlyxyFdI1MKFnjIYTuIYSpo3V9L7LrdcqKtzL0B8oo2hIFkPUHngshXBxCSOSCLsBhyNk1KCtGx4fM7AVkN90enZPnAseFEOYPIeRpPgrKkIKV14MLas0UQiCZ+BD6IIiA9sBAks07hLUQfudcCDrqGuAKzIb7/Q7//V5QRciFsamBkWb2g19rmxgVQwjLIRzNE83s1Ow4HT8KIayNUrOnRhHGP6F05beRMve+mX0TQlgACaELmtm3GbFbUM7IDfkWQpgCRc5/DDyL9rFHUEHRYcjo+wCCxFvfzL7xv58YmMfMnqgij08BSyEH5Av+81kUUfgjqpN0NoosPcLMfq0WL7WiZK8KOjv6mdlZGfPTxo0hq6J9czczu8rvvYoUkw6okPnVKOOzrgT+aMwnM7Of/Vo7KDn63JG/N8pKAUGFzWpmQzNgGedpdeAeBJV6qZ99Vs4xE0JYEDkWLjGzc2vM6lgphHAUghbdN1nz3p/gc5Osw74oErarmS1VRX7WQ86YqxFE49TIobUMWvMJbGgblC32Gopsv97MPqwWX3mhEEK3yOBfUJUphDAlWvOjGer93dkROcpuRhniJ5jZsBDCpMChKIhiRjMbkpz9teN+wqVo31oIBelNjozvlwKvmdnf0bOJIXItM/u3md+TnGEbI8PcpMhwez9wdXSO/acL5ZlCCNMjA/o0KHDx4uhsXh/Vr7rPzHbOjMlmkBtEr0M1nRb2a+2Ahsip8QAKNpipHvbWEMIqKKNhHqQ/vA3c4o77an/3xMBJyDh7DHLG3AMcngRDxPtcCKErcsx0Q5lX91ebx2pRCOEsBH23N3CRuQ0p2Wui5+ZC9d+eNbOdMmC17imEsDPKkL4KyXy7ovorL2TJV1Pke8rCKJhoS+SIOxvp8bsBZ5vZUZkxWAFyR+M0SObZGTmkzkPnxVf1cL4VVEWyHKTpFK2GLUlXFATZMQbfG/xj8JTB7ub1SvyZzn7tZYNvDe4yWCPzPkxAjVK66eLIOfFO1jxVoE/tgdmQs+864M4yz7RFtUA+B+bPmuei5a8h40ADcsR8BTzvv7+JHDMHIadyA6q9NFUVeWmT+rkqsBfKUngPObVHosyMTxEMywjkPJo667Ecj36Plv4OvAJc5b9nDseGjEm3UarbsynKUFgaGakHUkol3zxrflvQv/YIbupKHAYvuh5DaL2KjGl75IDnKfw9+JQIDx05CUL0HnVAiuQflCmSnIeGslaTmj0X07jeTRL0NBHKQBkBLOXXqlYHAcF9NOAFRKPr3ZChYyAqwHwjchA34PCO9dqoE6icCa35vtQArF7m3sTIITgKOQnnxaEVEcTcr8AB/jmXdUNaWwNmx+GnomvtkVHsRwQjfILPVQIJurNfb1atn2ifnxb4F8lxT/j+9AsKYlkrev6/syHPDWWOvOlr+nPgeqS//eLXO2fNYzP7cx7KaJsrJVN08J8noOj13EJpU6pJtbbz+pXLQx/6/vQ/agDr6u/S6kgmTerxHBXdb+stXUejfbV5q0Hf50EBQf8AR6PAoP/67T+nQnrTEHII65Sel7w2lA3zPdJ1hqOAhz557wfKjFoDBdEN83Vwd9Z8tXSNoACDuWhcZ6sNyqa61c+9t8khJHPRatsyZ6BoNW6JMAUnGPxm8JKpbsxXptoxe/j9ttHf9Dc4zeADd96sknk/JpDmgtlSLtS/ASyZNU8V7t/KfuAulro+jQusb2XNY9Hy11ypuRQ5NN5GRvcdUCT4/xBc2cfAD658PYwXDs6I3zmRAWN3BJl1uwvJt2Q9lhXoWyMjCXA8ynLLkp/EED4xMpbfEN3/BGVcTOSfd/G99RKq6LSrYn9n8PX0pRsZDijzzJSo4OhaWfMb8bSR7/2/IOflaEWOgZWAj1D2RuY8l1tr/nMRShjRH/oe1AdBME2BIv2+Ai6N/65a/PjvhyIM9s2iawshA9C+QBe/1o0q1rSpdj+Llt/me/ESwKl4bSJSOPbISJfASH7j+/WXyAl7c/y/su5Pa22UHCPLoRqW7wLdyzw3Oaq/N9z3s2uRo+E34Nbx+P7TUEDNfP55Jl8zXyCn3I3kpIZkesz8984oeKB3dG1iZHR+ws+wbxA8T90UpY7WxVp+tt2a9DG6NxGS+b4nDujMafN1exMwh3/ezOWQJX2/ahvPYwW/d1oiR5yv8T8pBQS9SFRLkZIDaWZgzqzHrYLjMBsK2moAnkbBI/P4OzQnqq85ENgnQx7j8ymZh7gWaO6dwhGvX/lY/+Z76iKkght87+qfvp4x35MDszq/k2fNTzP4ThyLk/j+/y1yuvyO5JwlKdWOmhhB+H0J7JU170XLeO1kzUDRathK2TEzGIxyp0x3g/YG8xp8ZPCzNc6SaR/9Po/BaZn3YwJrKI3zdmC5rHmpQt+CKyyfAXug6JiFXQEbRuH8K9oYGjIwPoKU9neRYbdbdH82ZGSoSnQ9TRfQ7jKGv2mP0rC7UGeRkql+HA0sEY+F/1zRFc3+GfDUPfo9MRgsCgzw35fztbJBpGjtj4xKFVfCa9jvLsiwcC+Cn3oVWDe6vyqChtwwa14jngJyhg1xhfE5FGnd39/r7VAGzXtAz6z5baIPsVGuDYIiSfrzL3IIj/TPpwA90n9XRd56+3r4OdqXHkbOxxn9c24U8OauHf+5BnJ23YXqGMyAR20XLT+NUiT9fP4uPEUUhIMK9m6CMszeRIb+tYFefr8u12k9tOhdagu843OzXHyvzN/MDNyAHL7vokz3iVvw3ckZvTOCJ0vfX9y/50fk0DgPyU+5cc4heJ2n/dx9CsExzxbdnxxlUXbLisdxXQP++3LAwmWe2RnJdV/62TwzCjbY3WWLs+M5zWMD1kSOo9X9c1c/o8+jFKCwJKql27OC3zs/cjDvG+2FU6EswFWAI319NyCo0Yn9mW6+J47M05ofj3FI3vc+3uc4O32o//we2DMnfK7pe9tDqPbnckQ2sZyv9TbI0XINqsFyo4/vR0jnmTl6dhlUs3ferPhtLY3SeXor0jVv9TPhckoZpvvHzxPZXFvDe160lrWihsyEREntmBAeAboDmxIVUiOE4xFM1PV+ZXIUtfY7MoyMwOzGWrJckKg1YmdHtUBWQwfWrCiVeSIk4F9iZkdkyWNB+aQ0nngIYTMEUTYTKlB9FYquHer3q/L+hBAOQGt3FBK+zNvzSMF4BOGhDzKzj0IInc3sn+jv6/K9DiFMh+rhdEPGswPN7Ce/N6Pf295S54XjBM8DYGavVZinyVCm1E3ANfE4R88siIwnm5vZHSGE3iibYXEzm7eS/GRBIYR+wPrAeija8AO0/pZCa3D2DHhK9vn/fiIDa1IbYDrgdGRcb4cc8Umhy1uAc83s+Vrz3RSVe2fj9zqEMDWCxeuLDFZvAE+a2UtN/X0Vee2IxrA/8CAyCG2LMsbqolhumqKaE4uhbIp/8bpISE69EDmivkrGuV732Xqn9Lh7Ufi1Uf2E+dHZcYR5fbfoubqoF9IaKKoVczoKVNjJzB5M3euG9rPhwBAzG+j3p0D79Z82HkXRQwhbon1pBWR87mBRLZoQwoZ4YXkzW7+l31Mp8kLkI70g+w0ooOw+FPyxAHJa3Izqx/zmf9NknbQsKTqXuyHD7f6ofs9eZvZV9Fw3ZKDeGfXzX2TgbYuyb1ezqGZajbsxTuS1Y24BVjCzl0IIp6FAlmXN7CN/5lj0HqxlFaopE0JIEB8eM7NDQwg9gX9TusByqF7WpsiYfob/3ANlPV9YCV7yQiGEtihDYAME6TQMZa8/bGafZ8mXr+N5UCbPbyjLZB7kLHoQuM7MXoz+JrdrHhrt40ujwKAFgScRUsBPqKbP7GY2XWZMtgKKxnlJ5ODaw8wu8XvdkX1ib/SOnwIcVsg5BSVUOGQmFCo5Y1ZAUZJ7ABf4tXaYjSSEo5Fx6jdkXGxAUZYBGd5ew2yhjHpQUCumEEIf5AycGClkVyCDyogs+Soo3xQbbrxg3kFIYeyEjHWXm9nDVfz+dAHtqZChaRnKF9B+FRk1LjOzd6vFVy3IldsNkAPAgJPM7ES/9wbwspnt4k6QGRCm8bLIOLylmV1XYX5ucV4+RjV6Lk8MS9Ezk6Lzry+CXpnd/2YXM7uskvxUi2LlzxX93mjdPR0Zf+ZD0XzLImX3fuACM3s7A357oejgb0IIEyVO0jLPLYDgjTogmeO5PDliEooMWMsiA8q8qA7Gy8CjZvaDP9cuS6dHpBwuhgzf/ZCRcGsz+7fenRQhhCfQXvo/9M7PjGDa1kK1J85F78TPmTFZ0GjkTvmZgHVRfaiJkHHizMipWddrs97IAxNeRPV+To/36BDCQuhdWhAZ715F8vm9Ld3fIofG0sg4NTk6r44ws7P8mbbIcZ8U/u4FYGa/5cVhF0L4BGV0HWVmH4YQtkCy4PtI5nkBOWVuyZDNMVJ0nl2A5NY7zOzw1DMzmdkn/vsMwCzorO6EEA5eMbNBeZmXpiiEMDfid2tkMP0dnRnn+ZnYB+1F/cxsiSp8fzLWT6OArZMRLPfvfr8HgvHeDMnLI4EHzWyTSvOSJ8rjfh9CuB+t74PM7LUQwkzAESij6RuEWnJjls6jllIIYVuU8TMFWoejkEP1uUwZayUUZEvdASG8vB2v7xBCfwSPPTuwiJl9nSGrBeWICofMhEYh7IMMiD+iQny3YzYYCbtfAPcgnNtvkTAwJYJD6QIMxI0NBRVUCfJo6VAuuiSPQlpB+aSUY2Y6lA6/LlK4bgeuNbM3q/TdByKoogPM7PToejdU52ZplHU4FVKyJgM2MrNbq8FPLcn7uBawFTL+f4Gi8PujiNaAjC0jUR2sZ4EXzOyqCvPRFo3xhujsauffeTdyfr3jz7VB8F17IgPTn8BNZnZQJfmpFqUE+1PQuE+GHGJ/IUH/sMSR7eMC2mMzcQ4EZeQujzKTfkBRhg+hCNtXzWx41s6LcaUoenJhtLZAjpgFcCcScnrcGxkSMzdSebTnVYjHTczsg3o8XyOD1iTIKPyCmZ2cemY1JNvOjOAirgCeqre+tnbys2MuZBzdHMFfHWJmd2bJ14RI7gy/D0GpXBddXxtF6vdFe/bfKAjjLWTA+7EF35W8w51RkEp7dC5Mi/TMZ4B9zewNf749QNbBWWWyvdZDct9eZvaAn7VfIXnzJOBMJI98jRz2mydnQl4octovgRwVByFkgiEhhPZmNiKEsDXaQ08HzjGzb6O/r8cz5Doks36FDNHzRQEumyOIsJ0qHTAUfX8A9kNyckcks90MfGRmw/yZKdE7Nwz41sx+rQYveaBoP8h8LUXvQyfkmPsNOVvj93555JiZDe2Dt6N3JnNHZEo/mAvBaI9CjvTrYhnbAyN2A3oCz5rZE7XnuHVQmbNhRwR7OJOZfeZng0X7zADkEF7BzB7PhOmC8keWA9y0otWwQSeDAQb3mOrIvGSwtMElBp8ZTBs928Z/hkY/i1a0CjdKmK3FGitaixrKQolrOiyNIMMagPuq8H3jWkB7P+q4gHZTfU+NdT+kzL/r4/0nql2xD3KATFcDnjohIfgepGg8gIz+bwMH0rjgbl8UpT01dVRzglKdngOQs/EGBPNykPd7JIJLWS5+PkN+p0aGj08QhvX9CMN6hL8vPwF3oGylnZGBdrYseR7Hfr2OFKrF/fPqlAqnDkaY9ItlyWPEaxt/X7fxNXMtZQp257WlZYKoL/cBO5d7DmVZ7e5zckbWfZhQWyTXTY2MQ/MjKMUYh39yBIX0gM9Xi4vDF63F8zSDj/0+0bW1fe/+zn9Pal/s6M8ePJ7feSjKbEvquy0EnObfNxIFszS7Lk2VxymWeXYGBuH1CZGc9wtehwE5mAYjJ/2+WfM+ln49gxxufeN+okLrX3n73c/s3fDaTvXUkvMBmNH3mr+ADxG863zIAP858HiN+JkMOAtleX6IsgX7p8+7omWyVo71d+L46FqH1DM7IHnvgqz5jXhK9IPdkZO7AcnYPyD4tQ2y5rE1NZRROE2Z6/Mg+P17gKmi60nd0jWQjlzMR9H+a5kzULSMGnQ32MrgDXfMNBgcbb5hRM8VwkHRWtQiob4DMGnW/BRtwmikjNCuQC5b5e9stQW0m+hvotwGojMDGdzOQo6ZIW5g6Rzdr4rzI9prlkQOiRtQ5O26qI7KX8iAvgWRMbAeG4oi/hFF4E4SXZ/SlfrvUXHm3lnxGPHUERmqBgEbJ3OFIE+2RXj1DcgINxRFhA5CmPy5chpEa34V53ed6N67yNExN8qYGYbqSB2bp/WG8KuHIzz73BakHUsfNqNUCPhdYM5y8+S/9wY6Jesua94npEbJODQbypxM5uxDBJeyYOr56ZADf51ivmo+Vx1QpPevyDm+F3ImjAJWTT07K3I8HNnSNeG/r+v7UMfoWkCQTdejbJyfku8hI10UBW5sEvPp16cCtvPf2yPIt2uArn5tZpQRPEvW8zuW/s2NHC0HkwqMQ9kiP6Js4tWQE/xf4ClyIF+MoU9jXCvIKXO2yxkNyAE4BLgAwZXVkte5fFwbkIy6NjB51mNYjTmohz0dBQc0oKChb/Ggm6RPRDoM0CN537Nu0bvb29fydb7OJ/L3dSTSg+4G5hnTPBVtnMZ7BiRLPwD0SN1rC5zqe+WDftYlcmg/FLD1a3StmIOiFQ6ZCbpBMJja4FCDDwz+MjjGYOrMeStaq2kIPupShJeZvlccREWrSqPGDhBkfL4bGQlPcQF4S9JO7lbQKBnbVgMuQ1i5/91zpeYmF0h/pMoRojSOXJ0VRTre4J+7IgiRQchhdi2eQVKPDUUS/wbs6p/bp+5v6grlflnzGvF0KHJS7JkoIX59M1dqdkKR8xv7ujkoa57H0Je9fH3N7Z+3Qs6kRf3zoiia+Cfg7Kz5LcP/lahwbua8jAOvhwDr+e+JkXBiFNWcZFTcg+pPdEv9be6NPxNCQ1BI7/p7szoyDiXOtH2JDKDpvaxoNZ2nxZAD4R+fnwRmq5GcjmBXfxifMx3BJz6ICkt3QU762FnTw2Wn11CNjSzH5T4UzXwesETqXkf/2d378mB0by3k1Foh67kdS//m8PMrvc8GFFCzV2peTkOOulwF2cV8R9fGeAagSPZlkRNknizPDOfhfeSIvJM6tcNQcgy0R8bn1fAsuHppyAH5WHRO7Qz0ie63Tc4qcmbD8H3qTUqZelMhGftkpKs1IGfAlcBkWfNbr83XwDkI0g5Uj2eZ1P3jfa/8A3gJuBxlhf6OYBGhFdoHitayljkDRctBg7YG8xlcZjDU4FODrS3l9S1a0ca1UUrNXN8P/3NpQtmmFWUOFK22zRX5JgXiWgnLkRKyGDLWNiCIpo615KNGfU2cMVOjCLJ78Sh1GhtVegHbIYNcA7BNjfhqi7IvfgSOie7P6nPyK4ogqyslMepHP+ToOj11/T8FEUGMnJ8DXpP3ogcywn1KCearJ8pmuhXomTWvzejTgokS5p9fRhHdPf3zTKhezjTROZgb54C/H92y5mMc+JwJRXS+m+YXGXumQRk/37qCewaK9q4bCMLW3hAszzN4dlx0fVVK0ekPIydyruCpJsTm8tQKLsf0jK4n+1gPZNj7kxZmMAJ9gFdRUMEwYI/oXlsaB1fMgEPCkJHhCpgeGdJ+QZmnRwIzl3nuDOSAOQXVmHgHeD3rOR2H/s2LDLYHJGsgdT+dcX4UyvyeIWvey/SlvfM3f+p6GvYyXmOdqGCWQ/q7mvm3nYD/Ae9kPZYVGIejkBw6zNfXe8CaWfM1Fp7TsNebAAP9nLoTOVknyprPMfA/CQp4ODPh0/l+Lfp8NcpS/YtU9mPRWjTmiSP4NhSocAQOY+nXZ0C6z5v+PjwJbJg130XLX0sWUkEFgQqZDUCRbMsj7P3lacUF5QqqLoUQvgEeBY41s6+8oOFMCJagHSoSmWmxzoLyT6lihe2R4jLKzIb6tcwLZyfUWgpoj41CCHcgnPQdzez16HpAQmpSwHA25Pw4r8LfPzk6r/5FcCE/ouyLf/z+NsgRfA7Cgh7i11dHzqH1KslPNSkpNuq/t0NwBGsix9P9ZvZX9Gx/VJflbTPbKgt+y1EIoTvia14UKb8SipBfw8ye9mfaWVR4NI8UQmiDHAR/hBAmQxkaX5jZZn5/ZRSJuK2ZPZIhq3VPIYSVkKPxvhDCwmjdnGVmv/j9jshgujNy/g5E7/v9ZvZ5RmwXFFEI4QXgSjO71Au5D4vO8v2QAbI7yvi7KENWJ2gqJ0OVKVa8HYJhPMvMThmP75oN6QCbofPgZlST5mu/n4tzIHXuLoOcMXOjYt43AbdHe9HsKHtkbuS4egPY3czerjnjzaAQQk/gcVQvZmkz+9mvx31PCq/3QVBfk5vZMhmx3CSFEHYCLkTzcw1wh5l94/fKyuAhhPVQZu5xlZyrEMLBqH7QC8k4NvHcf0XtkdF8SAihk5kNqxQvtaJkDwkhrIFkvZsRfHAvpBO1RZknh5rZa5kx2kwKIRyHsnX/Quvq9kRmzRP5+Xo+MNDMDgshzIr2oV2Bm81saAjheGApZJMp5NMWUrI/Ru/vALRG5kfO+FvR/jPQn58S6ahtzWy4X2t1doGCWk6FQ6ag0SmEXsDWwIyY7ZoxNwXVKYUQNkAG0a3N7CG/tg1K4+yNDNavIaN1YTwpqEmKBP3NEETQJEi4uSc24mTtmHFjraH980yUPbKbmf2ZFU/VoBDCDKhGxkXI2TE8upcIqInTrCoO1xDCcyiS92NUf+AtFHX9PSU4o7URhNTR9ap8hBA6R06mRAlYEEVkdUV77P0oAnEUggc7HNVNejYjthtRxHd/pJh3RbUlTkGZPn9kyd/4UAjhFmBh4CC/tA3Q38xmzI6r1kchhMtRxOrzwDVmdm10rysqzLwPimI93cwOyITRCZyis7oX0BcVsO1kZv/z+wkO/7/+uTuqO3a4mf1QGCmqSyGESRInQjP+pjMK1NsVZX2s08Lvjo38bdG+uR6S6SZC58GJydrIA8U8++cd0T4zCcr+vQF4IHEguePmL+BrMxtcc4ZbQCGEXRHU0a3AiSiY478AKDMb4fO1FsoG3drMbs5a3i5HIYQ1UbZSf+ARHB4vkTFcRsflkemBK4DZzGyyCvIwDTLKtkcy8nlm9uVY/mZh4HRUJP6GSvGSBYUQ3kDZ0Aeb2ZchhM0RbPlFqJ5GHzRH55vZt9lxWiJfC4siZ+rnic0iuj8V0unWB24ys01rz+W4UeLQdmfjucBGZvas7+P7INjjjevR6Zd3chvXAZSylW5BdooRfj93e2ZBOaExpc8UbQJuqi9TYBsWrcUN2AjhUa/kn3dCxSMfRwUv90SF89bKmtei5bdRgj2aGaW+f4Si0t9GEdGv0bjAdiAHEEG0ggLaY+hbPwQ5sls8R6ln9kJRpBXHKUZwaR8gp8vbwG4oMvJWlI7/N/A6JTz861EUdi7Wxlj6lqz3WZBj5XNk9Jk99dzUPr4jUX2cj1Ddkj+BC7Puxxj6tzxK7f8XReRmztMYeE1g8LqgSO45gNmBztEzy/i5NtTn4nNgeb9XyFAVGH//vRdwIHK8foOib5eO7rcBJgW2AKZNrmXdhwmpRXvXxAiaoyFq5xMVOEcZ0h3K/X3RqjpHvwI70LxaG0kAxpnI2VxJfnqgzLebkT7wKbBd1uOU4jEN49UFZcsMQjA0ZxMV/6635nvnJf6ePoUyRqZNPbM6gud8Nmt+x3GODnL5byjKWF2GxnBU7ZGM2gCsX2FeOgKL+7r4y8+r3YBe5XhGzsjjnJcFsx7L8ez70kg23zK69jVwsZ8LW0Znwl+0EPqwQrwmUIxrU9InBiNI46dJQd/5s8tSBrIwT42S3LogkknP8M+rAp8AV2fNY2tu0fv8A/AFcoqNVkO5aEWLW5EhU1BBBVWFQggzosKdPyLD+boIv/RkM/sohDALiuw+z8zOzI7TguqBQgjXIHiaXczsHY+2XwfYgFLdhiPN7J0M2WxEIYQrgSnNbKWseWkplYtYdqim11EU4OZm9rtfTzIhOiMs3aWB1a3CsJf+/xdCCsYOyBFxFPCimX0dQpgTFYnvgqJwHzKz2yrJQzUoBV/xDDKEDUQFI9sj6Ld3U3+zJLAjMKU/exPwuHlWTR4phLAicqC9A+xjgrNsFImcJ/IsmNURVOLXKPPtXjN7NHpmO2T8ecvMPsyE0VZI/q5vA1xiivqcFdgdQd41IBnifDP7zJ/P7Tpq7RTtX9chx+tlqFD1AaiG1/sIbvGa5ExIIvCz4nlCohDCPsBhwNpm9lwz/7Y9qon3dzP/LlkTc6Pzei4E5fQWysT425+bGq2ZPVHdmEmb8z3VoEieaY/gWQcgI/J73qZCGf9rIUf8LQim5tOMWG42RX3sgMZ+b2Q4fxEFt3yKDLvroHpe25jZh3mN9I7h7hyO7SzkBPgeFTK/1czedYi524DBZrZklXjphbIudkbF7V9BhtrHLMoCCyGsgIKG7jezbarBS60ohLAs2vc3MbNXHEbuJGAFc5iyEMKLyGH/rJk9mBGfyb7UBq2ND5AO8TXK3lnXH70e2NPMfsuCzzFRqg9ToIzUN4EGl5W6or5sgJzdnZETecFEZyuo+RTrxCGELmi/bGepLLgQwkxoTa2MHPe3AjeYQ3MWVFAjytojVLSiFa11NEpRGQNQ6nVnBN30NjLenolHw6DoyPVQMd5Vsua9aPlsNI6Q3hHVHEo/My9wKoKuGoQisXIRmU6dFNAeA/+HIgW9a+p6G3+fG1AdkElS9xdDkVjnVpm/SZCie7/z8gKqSZJ+7r+C91mP6Vj6k0RMnomKla+Hoi2X871yXWBF5ITaDJgu+tvOWfBcpg9jHWPv0+E+Z7nM5onmYk9UmPY8H/sbUIHnD5GhYb6seW1NzffMmfFoYh/vgcCMqeeWRzj136LI7YPT+1TRajpvSYBfF9+H9yDKgEFwV58BfyBIyfXyvh+3puZn9rXI0D6NX9vS35sxnh2kCrs34zsTnWBOZNgfipzwo5Bx/xhggdTfzItng2Ylx0V7f/LzRCRbJpH9Q4GHgBX9/vLAsyga/dqs53o8+t0F1Zc4HRmpG7xP3/q1mfy5XL+3KBO6XfR5Xt+TGvys2NvP8wZgzhrwMzWq9/eGr/0bE7kBmBzVJRkG9Mh67CrU3+X8ZxvkgH8W1R1KxuIZPLs+yzXiPw9DWQxL+ud2KPv/MgSx1oAy7o/MelxT/Cd762RIXxiEMnt+Bi5I1jXKGt4b1dY7lDJZP0Vr9tgn58KmyLH4M/AlcrhMV+b5FVEQwq/ICTxr1n0oWv5a5gwUrWhFa10NeAlFQk7vn7sBPWMhHkWtP4sKHmbOc9Hy3ZDh7U0UfZgI+rGxJ7jQcw8qIJw5z/XekEP1CVdI+vu1WMlth7Ixkij1DZEyv57P1SCgS414TSu8NwPz4I6YemiRgtjfx/RA3MAMdEAGoE9RpFsCxfYOKmbenoyNJDSG8RonXpAzrwHYNuvxb2pOfI2fQ2QsQRHD97vi/jyCPumbNb+toSHj2XOuuG6KDIK7U4IXaR8929bX/9P+3KpZ8z+hN5S5eCslOMuJonsTI8PuQN/HDsma3wmpIZitBlQHYQqfgyNRjZ9qfu9LyBG0un/ekJJz401/v2esJg/N4HVi/5mcx4s7n1ejekiLAicgyM2/gL2ivz0Ih2iu5+bnXntgCeRMmzZrnlrYjzY0hinbBMEIJWvvghry0g7BnR6BnF1/AMciKLNhqN5K5mM2vuNd5to5CAYseZ/WQYbpDXPA70Qo2/mi6L0/F2Uz9EEwx7dQcsbumDXPEe/JeN4FfOd92Bg5+xpQ1l6sr+UiYKveGyVH2HzIUfcacDSlAMUGlJU0WhADCkppAC7Luh9Fy1/LnIGiFa1o9d8i4aAP8BiKjixrJATmR6nbnwNzZ8170fLdkIHnRxc6f6VxvZi2NDbQ9aBGToAJoSEDWhLJNxOKGpsDQZeAorP2R9lJcb2Ap3DjSw15jRXeH1zhPQ6YKutxHEf+kz30Pt8fJ0uuA71RbZi7kMNrBmQUGomcNBXF9W8B771RJOSqqfexnIKe9LOnP39puecy7k9ct+oqPIsHZfbEBp4NXSEbijI5ctWPemwo6+0AhLv/D4IQWSa9hlLGht7ATlnzPqE3ZARq8PP6lOh6+9S+MDeCs507mc+seZ8QGjJA3o6CFr52mWreKn1Xss+v7Othvejea8hwuDqKLP4VOfE2o4XZOBXieXtfv/tEZ8DZKKK/X+rZPijTaxSCbc18fovW5Ly2TX0+FgVT1FxXQFlISwCXOw8NwNdZj1GF+jZaUA6q3fMH0hHuQ86Zl7PmNZqLW4HL/fMkzuv+eCABCrZ5gxzVuo32piWRM2+b6N4TyAYzlX/uQxQUUbSKzcFTPs5z++eVkJP+0UgGGu1cQLX03sOzVItWtKS1oaCCCipoPMnsv7oHSyJjyRAzGxFdj2kyJPQcbGZv15rXgvJP8Zoxs1cQLNU9KOLtlhDCxSGE/mY2ysxGhBDaO3b0H2Y2JCu+WxuZ2a9m9oZ/nB9loTwI7BVC6GNmPyODxQA0R3uiTKU1zOy+GvM60szeRxHYGyJFa0/gzRDCerXkpSXke+USyEnxJ6qXhJkZimIejCLKbzezz8zsUGAjf277jNhOaCWUzXApcHwIYT4A81oeqffZ/Nf1UMTYeZazmh8mTP2ZUPbLbMigjJn9ayW8fczsFmARFAV6v98r5OrxIDP7xcxOBU5DDrApgCtCCDuHEHr7M2bCSG8fQpgBGGpmF4NqImTGfEE/ISN1A7B/COHsEMIkLguOCCF09JoVb5vZKmb2drkaZQVVnnwP/gfBlJ2B6g1MDuwQQpiujJw+XhTN6QIowvxT52MzlHVxgcsIR6MM0PWA5S3buiQfIyPbKcD7Xg/jGeBX8/oAIYS2Xj9lIIIO/RTYqdLjV1DlKFlTIYR2/vl/QJ8sdAUzG2Kq33QQqo32MMryrDtKxjOEMF8I4RTgxhDCtSGEuaP3/zlgFwRROCuCTdwiE4ZT5HOxAXLAgvaqf4CPzWyoy3mGMjqfyYjN0SiSl5dFDu1XAUII6yKUglMQzyBYyMdCCD1qzWdrpRDCoqh+2LXIuQKCtbwfQasfh+xc14QQvg4hdAshtPGaPp2QfeybDFgvKMcUCjm4oIIKqgR5UeNL/eMbwBbWRHHjRHkpFPGCylFUaHQT4D4z+8uvr4jgLRZHNTUuA86yHBcwr2dKCreGELqY2RAvhLoXsBWqoXECMkTnzgkWQpgURSIejPCfH86YpbFSCGEWFEE1P8ryuQFhnj+InC43mNnwpBB2CGE6hI1+Oyo8mtl+GkKYGeGyL4cgK69AEINf+/2AIvtGhRDmQBk13c2sf1Y8N0XO6xQoI2lBv3wqcLGZfeHPtEGRt0VB8ipQCGE1ZLj9AtgcOXyfB04GnjGzv7wQ+F3Aw2Z2WFa8FtSYQgibokLW86NaYueZ2eXR/Y4WFbUuqLYUQrgDwXy+ixwhQ9H+do2Z/dLC/zkR0NPMfoiutUFZU8uY2V5+7Q10PuxhZr+7THEGMtL+aWbDEvmv5T1sOXmR5vWQnDMvqg8wzK+9npyxUUHtK1ANmWWSsyHP1JQDNMsxrySNTbf0+yEPfU3kDHfu1RWlCpt/hDIxvkUoBVMhyNHDzewTf6YTcm6MzNjpOhpF7/JcwFvACWZ2eAhhERQYMtTMVsyUyTIUQtgZON7MJvHPXyAH2K5m9rc7Yc5EGcQbJ3p0Qc2nRBf239dEmfPrmNnTIYS1EbTxymb2lD/zBvAB8IGZnRCtsSWBv8zsrQy6UVCOqYgkK6iggipFd6NInxcQvuZRIYQlQgidkweCqJ1HuBbOmILKkjtj+gCXABd7tDpm9gjCPz8YKcoHA0+EELbJjNlWTJHi9E4IYWvkhNkbZXH8jGBHbgghLOYGmdyQmQ02s7uANevBGQNgZh+Z2XLI+TIMre9bEbzjk2Y23B9NjAmTIsiU3zJ2xrQ1s4/NbAWEET4RylS6JISwcQihh2/5o3ydrAvMhaK1c0WJ4mRmA81sYeRg+hDBaF0cQtgshNDTzBrcKdY+W45bDyXZLSGETmZ2v5mdZMpC2gm9E92RA+ZcN/ofgmSNK/3viij1HJCZ3YAM2Cei7IczQggPe8YBhTMmG4rej9PRO3UQyiZ9ETlkHg4hrO3G0+bSFcAD7mwH/ovkfhg4yb+/L7I7/GZmv/tj0wGzoBoyw6K/y4Q8av4a5AA+EtX76IuKf08D/zkvLITQCxmZ26IsoNxTZESfJYTQ2wNXMh3zSlEyL2OShfx2LvqayBlZ89ESitbRXuhc3gxBUa6J6h8uiLLTTwghdDezYaYM48ycMSHKng0hdA8hzOjXOvjld1FA1EEhhG8QxNqsyDmbR3oP6BJC2CGEcBTQC2XHDPX7s6GMmdcKZ8z4Ubxuzewe4DAze9ovbYqylD4GCCFMAQxHgXQn+TNt/G+fLZwxBZWjIkOmoIIKqhi5cWpaFNG6BzqULkCF8T43s5EZsldQHZGn9x6Kil7ejiIqh0T3p0LpwbsB75jZgEwYbeUUQtgQuBhFXd0YXZ8YKV8HA1OiiKHzzezjLPhsDZSKwmoH7If20Z7IsHVJ4lzySN5DgX0R/MbvGfDbDRnEp0cZa/eaZ4yEEA5AcDQBOe6uM7MnQggLAXcAL5nZ+rXmuSlKRXx2tlTWXQhhX4Q93xb151qUqVGcaRWgKCuyC4LZaI8ibP/0++1R7aQNEFTQVMAvwNlmdlz87hRUW/K9akkEMReA980hOTzqeBdUS2Qq4HQzOyQrXgsanUII0wJLo+zjBZC8fpaZvdSM/7ErOouWMbPvQgj9gUFmNjR6JqAstw7IwdoTrY2FzKxfhbpTMXJ+50Yy5sYoSOJkVD/gH2SE3gY408xOyYjNcaJQynZeBvVnBVR37zXgSeAiM/sxOw6bR6nzem5Uj2haVHvsWuC74jyoDsXZVCGEZG/f0sz+8GsdUXbrFgjm+CfgNDO7MCOWY/miPdJZNkaO1kHI8XKzmb0clHW+PuL/D+BOM3syI7bHSH7uXo8go7sjxIh9TFn0MyHH2PpIPyhQJJpB0Xo5EJ2Jp5rZq2Wea4eceMuY2cx+bSmEAHCEmV1VQ7YLqmMqHDIFFVRQxcmjoGdD2KwbosiTs4DHzez7DFkrKOeUhlTw7JfzUebVlhZBYvj9hYHBZvZ5bTltvRQJowEZHHZARS1/SjkNAlKCtwaOAA41s5Oa+r8FjRulxnhqFKm7AfAXyhC4FDkGHgXOMbNjsuARuNr5ag/8DRyPDHn/+jM9EWTCVijS+CYUEb0OMLWZ5S6q2A2L5wH7mtlZqXtdUX+2QzV9Lgf+Vzhlxp+iPecihI1+iZmdXua5Tgife14Uaf+sXy9qkdSQPNN5ZAhhHgRdubLf+hf4CBn1z0mCKILgRg8BTjKzh4v5qh1F71Y3VPNqFhSx+66ZPeHPdABmBNZAEeHdkSHvz2Z8T0cz+zeEsBiq+Xe8//wiMp5virJphqFz4x9gezO7K1lTlel15ciNuMshfWYFdA6PRDUDnjOzSzJkb6wUzX9nBCE4GPH+EcpCfwfYrJ5k6Gj/2RFlL/VBmcRTIUfTKlEEe6uBZMsDJXt3CGF35NSY1czWTDLwone9J7AQsD8wi5lNkyHPyTtwDrJJvIocMSsieXRT4NZI7u5gpYz03FE0Bz2Bi1CfPgeeQLL2JmgPP8IiuNCCxp1CCNMAXwFDEPzYw8ClZvat30/W1BZIF7oHwfVvCHQ1s+my4Lug+qTCIVNQQQWNFwXhlC6K0mSHmtlr0b2eKHJyP5Q6e4yZHZUBmwXlnFJRV42Uol55CgAAQUBJREFUpxDCxgjL932UKvxaXpX3eqYoijIR9vdFjtW5zGyh6Lm006w9Su1/r1B6K0Ou3IbonVgCOb0WR4pXO6CbmfXNiL9TUZThVcj4egra62dCBqvJEwOPR7BeBCzsf36kmR1ba57HhUIIK6P6F6sCX6PaPA+mnpkD9fleMzuo9ly2LooU23mR4/1QpPj+7fcXQ5Hqz5nZu2X+vjDuZ0QhhLdQVsydKNJ+WQRXNh2C7DjKzD7wZ4ssphpT9G71QA7xlRDMliHn2fPAgeYwKh5MtQDQw8zubeF3TouyagcArwDnAk8lGRhBcLR7+Pc/kThV804hhO7I0LkpOsteApbN+94TyXNnoZo+m5vZ8+7c/hHB1Z1lqjvRH/jecgwrGPWnOzI+34UMz1+GEK5DNX1WNbM3suSzNVMIYUoEmdUTZUdvaWb3+b1G+3wQVGGwjAqZR+tlRhQcehRwhmeSXImcRmuZ2We+/2UKrTYmcpvKJCh7J5jZz359LeSYnA4Fa72FMvfuy4TRVkAhhAVRTZ42qJbhpMgGcRVwY5J1FEKYDDnr10ZBDU8Dx5nZU4WdoqBxpcIhU1BBBTWbouikdZAQMB8wAkVfPYuKH7/tz7YFJkeR1PdZHRS+LKj2FBkOTgT2RBlVHwGfmFLJNwQuROtrNzP7vjDEVYfcGdAFGdjm98tno7TtuGhvMf5VpjLK7ZaonsnsSIlskdFsPHmaAe31ByDD+Z8hhFkRFNmdaK/vgyJvzzPVlEiio3czs8VrzXNzyA2GK6HMsEVRJtKuTUUQF9G3laEQwlXI8bKJmX0UQpgEZegdheoSNQD7m9lZxZhnR5GBaxMEk7KJCVc9ud8XOBy9P2eY2f6FMyYbiuSq65Az/1IEpzInigxfHTlnDgaureQ75VlRJ6B3+la0Vt6wMvCa9SRLuMNpf2AyM9s4a37GhTw76j4kU+/nzpfrkXy3opUgBt8HTjGzq7PjdtwohPA/lJ29kQdpTY6CKP6H4HP/CSHsgJwGp9XL+qoHirLGVkEZAZ2Q8/1svx+ANnna80MIewO7Apv6elkY1c/aErjJbRonAIsh2fqP7LgVBdW4aeO8LQ0ch/bxgcBjKOjhvih4ZVaU1THSHD64oJaTB2gdhJzvQxDEZlfgEeAyK0FIt0WQuiOBX83st2w4LqheqXDIFFRQQc2iSMHrhPB6P0TZCz8ihWt6JBDciBwzSQRHoZAXNEZyoeYJFGk/EuFbd0LwFmcgqI1j/PoOidOvoPGjEMLaqO7TcVGkbFtkVF8eQZjMjrC5L0SZMMP8uboxpOSZxjaOoTGM2UTA2omjo9YUQngEwSFs4lGpAWXGfICyd15A7+2CQD8UgXtw3tdJGqYihDAbiijeFUGhHI+MDv9B9uW9T/VCQZBJFwLzm9k8fu1iVKfqUQRztBOCGJnJzH7JiNWCnIIKCe8ILGJm37iRblSU1Xcuenfmt6KQbWYUVE/gDVTT6ywr1flqB6yL9ue/gaUq/V75mtgBZXe2RxBZNwMfJTJEPZIbSttZTmGNnD9zx2niQH0G+NbMNvOsw+eQMfpGU2b03EjGu85yXhMHIIRwBLARMK9nO9yG5JBVzew7f+YGVLNoW2sG/F5B40aeHTAAraNVUNbMgWb2kN/PLHAi/d0hhM0Q/PXU7pB8CfgTybG/+F51KnJSrpvYLrKgEMJUloJ3DyF8juryXo+cjFuiLMNHgFsS54A/W9hbKkCuax2B5JzNkG5zEsqS/AO4G7jCzN7MjMmCWgW1yZqBggoqqO4oMUAdgw6kgz1K+w1kfHsAGdOPAW4NIezsglEhHBQ0RvI1shGCu7jf2+lIyL8UFSj8AUFqnJkRm62RlgOWAa4OIRwdQpjCzEa5UnsTmpMz0PjfAewVQpjehf7CIF0BGts4Rk6AtmY2NENnzPLISXctikZNeN8XOeK3MbOtkbK4O4rI3QfBQuSa3KgTXDHHBLV0GoIw+xNlg44IIazr94u1XyFyw+ZbwFwhhKs9on8rlIG1pZk9hRzxQ4ApM2N0AiZ30sf0LTAFgrXEzEZ4sE5Hv/80MAroXTsuCypDU6B5+MbMRoQQ2vo5MtLMbkHBGLMC21f6i31NXIAycq5FwR13ofOhbsnMGnLsjOnj/KXPp4+BxYNqIxyPDLmPuTOmA4Jh6wM84/8nFzaiMvtOQn+hqPSJQgiLI+fi8ahQOyGEWYCpgT8KZ0x1yMx+NrObEarBniiL9YEQwu0hhNmzcMaEEKZz3v6DwPZb3wPdgPXdOTMfWi/J2pgVQat/mLEzZgrg8RDCYUEwa4QQlkTQoDub2XFmtj8wF3AvClo5M4RwfAhhTijpCwW1nNyRPdTMDkY2iStR0MIuKLv0M2Bb4KoQwgGeWV9QQS2iXBy2BRVUUP2QR1r1QmmzdyJMTVB2zPdI0VoWpXhOiwxay2fAakF1QB5d/x+ZCn3fiCLsl0YQFzuaWS/gRBRF/RCKdCqoAmRme6Ao1kGoYPltIYSd3GgzzMw+AY5FME4vISXmWmDrIBzvgsaREuUwhNA9hLBKCGGrEMJqHok1VsqBojUnitI7ENgxhNDZlcDt0bp4GWRgN9VeORDVu5k6I37LkjtekrlYK4TwXAhhfhONCCG08/U/wszuRzUPXkdGrG+z5L21UHrvR/LEBcASqEj8Psghn9Rv6IWgUTPBop8QKTbKuuE2eGYFwNsos+KwIJiyxIiR1J9oQLUF21FQljQQ1RVYzrMAR/lctvf7n6BAl8nH5Z+VeW/HSm643RtYBMkZnZr7PwoaO4UQdgPeCSGsn1yLHDMnIuPzM2iPPc3lbRBM027AS2b2kv9d5pCQvtYOCCHMHa3XhG5F6/Y0dG48gOq6jQxCcFgSOZkuqyXPrZEiWWmyEMLqIYQ9QwhLBtUcwgTnej6SA09AWTMv+TzUks/JgPtDCCeHEGZ33hr851Mo0/ZI4DzgdjN72uW9yVB9qNmRHJsJ+Xrv5e1Y4LIgmOIOwD9AkvnV0cwGmdmuwGooGGoHpLstkgXvrY3c1pXILheijMIzQwgzmNkTZjYA6QVt0N56WfR8QQU1iwqHTEEFFdQSaocE+1Gm+gHToALPZyO8019RtOsgVMD5kcw4LSjXlCiLIYSlgvBvMbNnEDa0IaF+Q79+M3AySie/PRuOWxcl0YdmdieK+jkRGUsOBm4OIQzw+0OQsX0nVCOkMyrU3mzjzIRKbqxsCMJzvwplgF2JnFublXm+qcjQLOlCVPD+baSAPwrcgIw8d5kXsIx474CMsp1rz+roFEKYzpVZ87kISAnvB9wbQjg3hDCZR4+PiqL9uwC/ATua2astMUoWVKKgrFkLIUwcQlgdwDPyDgVWQLBkF1oJx315ZOy5zsz+yOm70erI35E5QwjvhhCW9vdmpO9lr6EI0dmAZ0MIWwO9Qwgdg/D5dwN+codmQdnR9yiIZVtgkxBCV1D2it/vg5zs41TI3d/bGUMIB7shc4wUGXO7mdk7ZraImZ3j14p9tLJkqMh6AhXdP7r3FYJkGo6cpUeHEA4JIZyK5JBO6J3Nk+yxGjLwXw1s47om8N95cTaqMzYngs+exdfbHqj2w91m9mLNuW5F5IEpDSGEKVGG/F1oTp4GzgkhbBdCmNrPhteQDrE1sIHVEJbQ95LuKEhga+DiEMIeQRknCZ0BfAr0AOYJIZwVQtgWuB1l5J5oZl/Xiuc0+Rh+aGa9UcbRPAjmcS+kaw315/4NIbT3c/gVM1sV1bX6AXglG+7rl5L9zoPj1k30XqAjgKnG1jYIkvmhEMJSfv0KFGRwAXCny0aFbb2gZlNRQ6agggpqEbmg/7OZ/RVC2A7hbK7vxqp2/nkSYPcyqfMFFfQfhRDWQQLxO0igvBp4FgmgO6A08iuBW2sp4E8oFEJo54JkO1Sj4RJkSJ8UOVXvREVSP0ieR7BBfczs5YzYrjsKpfpbV6DozatQlOeZKBtsOlQvaQoz+yz9d7XnuGnyjIV1EJzXwih6bE8zeyvqZxdUYHdnoK+Z/ZUdx/8VY34Rre/bzOy96N6KCBd6BWSYPNtKBWp7IIV4Q2BBM/un1ry3VgohHIMKwN8KHG9m7/j1NkhHGeXR3kcDf5vZwn6/qN9TI3KD1ZnIYHsHcICVajR0RYXhd0NZ0z+gSN6pUF3Bbc3syeSMyYL/giCEMDGq3bIMykC+CmX6dUKy+qrAdDaOUD0hhMMp1fM7GXhgTPuiywwHIHjUDawoelw1CiFMamaD/Yx+BQXSnGml+oAzoszVRZEzLqD3+kozez5v8kYIYQFKGdqPoeyGl83sR78/AJ0hy6CgiW4oaPBWYFcr6o2NFyVnbQjhXmBGZHxOarqdimBE70e1TZ41s9+z4jWhEMLmaI33QbrkjSh7Kql9uROwNzAxykb5FDgLFWrPTK5IyzUeEHQ6qsUG8Dywf6x3haj2YSEXtZxCCHMgG8QvyGndAXgS6QOPI+j0mZDj7ms0D6NBIRZzUFBLqHDIFFRQQS2mRBBwY9ZDKHr4shDCvMjo9aWZbZgtlwXVA4UQtkJ1JuZFBt7BwKtIMOqHov6OMbMns+KxtVKkcN2Eop3vRbVjZkAOsfnRfFyBChgWxpRmUjTGCyIDya7AVWY2LISwKDKQ3YPw/LsiBfEYM7srI5bHSh6ROA3ieVeURXI+cIGZfR+E634fcLqZHZcdp//xOgmK7lwMGRIvBR5JIiLd8bI2yvZcCClmVwBzI3z6k83siLwZrOqZguA1NkJG/W4oW+zYRNH1OTkdGdjONbPXQ1GwtuYUQlga2AJYDxVnP9nMjo3uz4GieZdC8IQvAQ+ZWRGtmzEl70tQbYXtUabMZEi26owyJ04xs4ua8T+nQkEEu6MI4XtQ1Pxr1riQdnzuXQcMNbN5K9Kxgv6jEEL32Djo510/4BxgFuQkvRO40MwG+jMz4NkyiYM1z+SBW8eitXs96s8bZjbEgz+WQo7Fr1AG77NWgk8sqAUUBdcshiDh9gau9nf6AWAi3EmAxv1O5Jx9JgNe086MDihLake8tg1wS6JDBkHgzYMc00OyDBiK9slOKNtrReAeM3vX70+PoPnWQplglwF3RLJrW2TTLYIeWkghhL1Q4MkoZL/6Gum+3VAA3c9ov5zJ/2RtM7unkEcLqgQVDpmCCiporBQLOi7E9Iwj6UII/RBszZSo0FlfZPya38y+qj3HBdULxcZNj4rugwzSWyNFf1IEKQSCyZvcclpMtR4pUgTmRDCD+wHnRHMSkBHnDKR8PYWUmouz4bi+KYTwGnJu7RQpU/MAbyAs/0fQO7A0WvsnIdjHEWX/YQ7IlcG5UJT8pgjn+jyEU7+wmU2bIXujUQhhWeQ4mgW4G2XkPWOC2kzOs9W8LY6UsNvNbCe/X0TAVZB8318FwfYNAP5ABuLL/X47oNe4Ru8XVDlKyX5dUYbDIchh+RVwhJld5/cT4137eL8q3pf8kM/htGhfmxsVen8izhZsxv9qg4I21gZ2QTVoLkaO0y+j57oDRyFj7ixm9kmRMVVZCiG8jAyGe5nqecT3NkCBNbMBXwLXAJengwry+p5G+8rsyCCdBHd8gwzTtwKfF+upehRCOBpYA9jGzN4OIayMsmJWNrNHQwiHoSzWNijTarsa8lbOmXF3sqd5ZnTC//fIaXSLmb0f/Y9c7EchhONQRvlzqMbTc7HBP4SwGnKy9kNwwVcCD1oJ2rWgFpIHLCyOoMkGAJcjWO5PEHLBSsg5MxsKSrnMIiSDggoaHyocMgUVVNAYKRKGOyFj2zbI2fIbSl2+11RHZh4UjdIPRRbcmOfo7oKyo3KKXwihk6XgyEIIvVCK/BSo2PzTZnZG7TidcCiEsCZwC7CJmd2ZjrgKIayFMgr+BV4sMt/GnSKFcX00xhub2S3R/duQYWtbM3vDr62O8NF7AYua2ccZsN4s8jNiAIL3WhZlNaxtZvdkypiTr+mGyMC8O4rqNkrwcS8nxuQQQh/kBJ4YGGQq/lpEw1WIyuwxvVAGxrbIGf8ocIaZPZwdlwXBaIETb6Ii8QBzIOPR/kk2jM+rFVlkEwaFEDojh/wWCM7lNwRjdoOZ/RZCWAUFbN1oZrsWe2hlyR1e+wJbIqfY6Wjf/CN6phvKFNjUn3kVwdA+XnuOx52i7K5FEOzUlwherS0ynq4HvAmcizJivsiM2VZA7mTtbKoZmVxriwLkljezTfzaSwjOeAcz+zmEMD+CLzsa+MzMvs+A93LOjPjcWgY4Ejmi30IQjrdZxpB20RrfHjkbrwMOjQMP03tmCOEANNYjEYzfYWb2YY1Zb3Xka31GYE1Uh6oXcvqeFmcR5sWBV1DrocIhU1BBBY2RImHhIoSh/wlKB18YKWFroAiNROiZKgthrKD6oxDCCigqenYEIfQCgjkpIqFrTCGEmZGSfjOwh5Wwltu7IXoG4GGEN/9EAntR0LiTK4z7oKKjR5nZhaEEYbYRysKI4V42QPOxspk9kgXPLaGgegVbAr3N7JCs+UkoCi6IMbc7ouyvXYAvkNPxXvN6SQVVjiJZIqC1Mcivt0eOsiQKdG4ESTMVKr67val4akEZkM9X8Hdne2T8XApljm3qbUoE73docX7nn0IVYBfdobooMoquhup1XYx0hJVQdvO/1fjuCZ2CILtmQ+fuNihb5n/IKRbLFDOgTNZVkVPjaWC3dDBU3iiE8CIqaL6bmX2UOH1RNsQpQH8Es3sv8LiZ/Z0Zs3VMIYSTUMDlsaZC5sn1qYGuPvbTo3G+xcyO8vurIUit9WopO7XQmbEdgljrBrwPHGxmb9aK53Lk63kQkvePNbMfy+2TcfZpEJzrBcAmwGRZO5ZaE0VBBlt6+x0FGdxYjHNB1aA2WTNQUEEF5ZNCCEsBuLAzD8pQOMHMFnHoloHIkPihK+o9/PnCGVNQk+TwM0m00vVIofoWwV6cCJwbQlgjec6f7VBzRic8+hZ4ECnzW3jUJRH0TE+EQz64cMa0mM5DkYZvAOd7pPktwO0IYqEhOPnzndGYd8yC2ZaSCfrrbGQQyg0lyq2p7llbV3j/NbPdgFkRBMqJwMUhhC09Q6agClFkFDkEeC6EsENiYHA5o70bT95GUBED0Tq6OSueJzTyCGlCCPOGECYFpbr43tQFOB7hq7/j83QIkg1vADYAfgyqJ1NQDckNekkmxFipGg4RM/vNzB5A9cR2QBCnlwPrA4e4M6Zd4YypHIUQ+nl2+RAzexVBw20AvIugyZ4IqlEHgJl9Zmb7oGyZL4E/8+aMieSf5PO0yOH7pZl9BDpLfB09jJAZDGVW3omc+AU1k3wP6YP2845+rSeAmX2XjD1CwBgFLBhCmMQdNCshHaGmGUouN7RFctttwKku37WJn4GS7mmCQl0IyRWzo/5kQtFa3w3J+reZ2Y9Qfo/24Lh2IYT+ZvaHmW0GTFE4CSpLZvaPmb0MHI6C5d5Esuh9IYRVPZCroIIqRkWGTEEFFTQahRAWAp4F+prZTyGEUxDG+8Zm9n5QgdcnUcbMXWY20iNregO75E3ALyh/FEJ4HwnCR5vZyyGEjRAkwR/ACP/9RjN7KUM2JyhyJ8xNyEl2BzKmfIuUsyNQ/YBpzOz3rHhsDeQK7GrA5igK6xVgOzP7NHqmB1Iy1wamLoxYzacoI2ZTYGVUeHo48JaZfRNC6Gxm/6T+Zl0U6Tk1OuP2tQhrvKBxp2j8NwTeSyJnQwh7IMfvpAg65CI35MZ/uzuwALCrmQ0touprR0H1xN5GtZUuQXP3VwjhZLRnLeeR0nF9me7IcDGvme2aFe8TIkXvWTs0Z6OAvd0xHj9XsxohzstMKHp7JjPbqBbfOyGROypeRO/o7eYFwP3eNAg+dE8E0XQVysr9NvU/OuYxa6lMVsNbKLN4STOzkIIMCoJ9fRV4xbxoe0EtoxBCXzP7NoQwKwoiOht4zko19toAxyJn/FvIETMZcKCZXVhDPhMo4D1RxsuWZvbUWP6mHbJrfOmfJ07vk7Umd8qcAqwDLGFmg5raq/3ZXsBZwLVm9mhNmZ1AyTPEVgR2R068J4FNs147BbUeKjJkCiqooHI0HBUtS+Bm/ga6RIaps1HK8mPujJkI1Y7pguoGFFTQaJREA4UQ1kHp4hd4FAoo3fxSYBkUqb4DcEYI4cg4W6ag8ad0BGJCZvYnio47FkGPPICyOV73zwcVzpjxJ1PR3fMQfNkZCLP4vRDCyb6XgiAhtwWOyZOhpJ7IjZQdEMTS5shYeS7wfgjhFeAyH/PlQggD3Dh1h5n1R3Vw5ifD6Ml6Jx//ydG4Px1C2DeE0N3MzkWOxhuBmYHzQggXhRDmhf8clksAc5rZ0OR/ZdKJCZMGozoUq6CI8z2C4EX3RlnSH8UPu/HoTzO71J/5L2OjoJpQcp6fjM7p78oZimrljPHvGukO2FORLFesiQqSy3B/o4yEI4DLPeNwGgAT3NT1qK7PkehdfieEcJBnuiU03J/PfH8NIUwXQtjN+UmyGpLs+FuBxVBfcL0zyQrrhfTVvoUzZvwpctpNBswLXAucEEJYJIQwkZk1mNlhqM7Gb0g/2LuWzhjn0/w96IvW8UfQtH7j17sDR/t5Rrl9stbk+3InoKc5jGtTe7VfH4HGvnfNmJzAyVQ/5hqkR5wJtMnD2imo9VCRIVNQQQWVpRDCZejQnw9YEKX3LoGiVk9D0Vevesrw/CgC6wEzOygbjguqFwoqSLgDKvj9QSgV1x5gZq8FwZndDQwDrrAc1aFoDRRFlq0LrIDgIO4GnkIwFm2A6ZACPD/wKYo8fDUThuucPKJwcmBaBEswxJ0ySWT54qgOw4YI+/00YFlgejMr4H/Gg0IIkyAFalbkAPsXBQ+sDEyDlNrZUSbYRChb6X0UbXu/Z2cUBTxbSO5gXBbVCtsA+BA4zsxu8fuLoOKpiyKjxCdoP5oBWMvM7k1HSxdUfQqq6zMnckxuis6Eb9GcvF3m+VxF2E8oFGXH9Ef71pEo4+xPN0CugGT2ocA9VhQ9b3UUQhiAAjxmQXLcVcDTSfBMCKErypLZGtgY+BPV5XowA3abpBDCCcDBqK7NCXH0f1BdurOQQfQp4EQzezQIUmttdMYfbWZn1ZTpVkaJrBNCmNLMfgiCQNwTwcL9CZyP1tgniUwUopp8GfF8LrCJmU06Ds92Q+fY7mZ2XdWZG0cKIWyDEAlWMbOHE6dSE1kyi6PgxVPM7KqaMlpQsp8GzxoudIOCKkKFQ6agggoqSx5p9RpwF8qUeRJBIUyLYI32NmG1ToGU9r2Bac3sp0wYLqhuKAjTejkzO84FzzfRWtvHhZw5kIK5KTCoMPRUjkKpCObywP3AEOA7VBD2U6Rw3eURQQWNJ4UQZkG47qsjg//vSCF8GGWIfeXPTYkg4bZBBbPbAMuY2TM1Z7qVkUO73IUM/uskEf6uWM2InDD3IWfkEigq9Hszmy4LflsjBdXjGYAgHxZGe89xSYZkUFHg1ZDjbDhws5ldkRG7BTl5NP3SwE6oOPtDKEP6FTP7LUveCipRCOF4YD1gIzN72w3Ve6CzZziCHb0E2MNKdeEKqmNy4/LfidE2Cmwy5JS5Bb2nSRHwyYFFUF2EE83sziz4bopCCDOhekPro4Cgh4EjzKFcQwgzojW9LnLaf4H62hfBkC6SAdutkkIIX6N9/kIz+yeEMB1wNMq4esPvPWUpCLwsqDU4Mzwr+EWEDrF5JKO2QWs8yQjqgM7io4FFzOyTjFguqKCCKkiFQ6agggr6j6JU33bASATvsi3KkGmDIEZmQxEy9+CRJiiS/mwzO77WPBdUf+RCZleP4pwCGUPfNbNt/P4awMUo6unpDFlttRRCeBH4CRlsPkPv9WHIcfA0evdfSFLoCxp3iqKWl0OK0xwIPmQwMDFyNPZC++dJwKVRtOFMKJtgeLGfjj9F2WDTINiTH5FR8mu/fzVygK1uDskZQpgb+N3Mvi4i4MaPkvH339ugzJe1gV1QdtJlqBDvt1F0bntgpM9bkXmRMblc2BvN2wH++zXICPa+FTUDM6NofzsQ1VFY3Mw+DSGcT8mBtjNwKHAMML+ZvZkdxwWND0WyxapIVjsUOWUS+aEjgkHdBTksLgHuNbMP/X4AeudZrvOsyU1QFmtXFCR0pnm9txDCikjnnBE5Zm4FHk6yjgsaPwohrInWzU5mdnfq3pKotuHCaG85z8werj2XjXhqFc6MEML+qJbM+2iM7zazIalnlgMuBF4ysy1rz2VBBRVUDSocMgUVVFCTFEKYDNWReNvMtnfj+T5Iwevmj30HnGVmZ2TEZkF1TiGEuxA8yqFAB+QEnNzMZs+Sr9ZGkfFmchRB+Uga4sGdYccjZfc24LLCKTbuFI1xW+AdYCBwvEXY5h51fhAybrZFMDOnRZGs7UA46bXmvzWTQ/RdCTxkZhuFEBYAXgYORIaFf2MHQkHVoRBCZ2AuFG27FfAHqn9xbQSzU8xDzsgNXP0R3OjOwK/ofbo6cXAWVF0KIayNxv2lGCbIr98BPItqyiyBzpUzzexvN+BfiQpfZ2pALWj8KYTwPZIvNjezX9JZAR7YcSGCi3weZQU8ZmY/ZMTyWCkOfvCgiLOAhYDOyEh9hpld6fcLGMsKUuToa4MylA4FVjOz79Nj7WttC7SmjjezY7LhukStxZkRQjgM1fAciur03g08iOr5LAD8D+kMC5lqfhZUUEGtgAqHTEEFFQRACGE9oAuKfvwXmAJFl+yGopT2A85xY+NEwEooAmuQmf2YDdcF5Z0iiKxuqIBzEk37WRJZ6/BZVwKTIIfMF8C2ZvZcFjy3ZvIIyi0RvMmNZna1X48j2Tsig9uZSOH6X1b81htFiu05KEJ5BzN7LHLUxEaHuVDB1L7Aemb2ZJERUF0KIayOIvtvQVG2I4BNraitUHMKKsa8KNprVkPQcUclBuPC6JZP8kjj+VBwzgbACmb2eLZctX7yc/ltYHrgdGQQ/TI5L0IIGyHn8kjgIuAGdzJ3Q5HhBwHzWgFHWpcUydIHIhjptSyCNA0hTOUG9DbRmlgDOAfpc08D+yWZoHmjKENyFxSU1YDO6gUR1No0KIDiSDN70f+mOCMqSCGE41BG9/TAomb2t18fLUAihNDDzP7IgM2y1FqcGSGEhYHjEIQxwN/INhNQn842s6ey4a6gggqqBhUOmYIKKogQwhLAM0iR+wtFJP2JjOcDgZkQjNkbKErp3uhvCwNiQWUpZXy+G0EQtAe+QgLzPbEhJ4SwHVp3b+ctnby1kI/xpf7xLRRh+UF0P3bMTAEMLjI1xo0ip8v0qB7P/qhOzLAy0E2442ZR4AmUrbRWZsy3cormpjNSzA/2Wyua2WMZsjbBUwhhamBFBH86F8pW2jtTpgoaK4UQegBzW1HnqmYUVEdjS1Ro+1fgVFQfa2B0vvSyqL6PG+XPQ/LWHjVnuqDxpuj86gL8jObzmMhgvgkK7pjFzD4rk9VwOLAvME3yN3mkEEIn4HsE8XpCAq0WQpgT2B6dEaOQDHuqeQ2+gsaf3NF+G4LCAxn/D48deHnPXG1NzowQwmLAWoj3kcBzwIN5Hv+CCiqoZVQ4ZAoqqCCC8PX7IHz94Sgz5negp5kNdAPjrigasguKOjnJzN7LhuOC8kqePTWlmX0WXTscGUAvQcWct0cGuB+RkHyLFbjmNSE3oi2PYGdWRLWgzgZeM7O/oucKR2sLKYTwODA1gnz4bByevw45K6fPU8Rha6YQwpHIYXYGysoohOEaU8pJ2Q6YBdgO2Au4ANiriH6uD8q7oa41kRtO50Fn+LZIproQeC4+w/3Zdf3eN8Bi5rCYBdUXRdkxV6CaZ2sn+pcHeHwEvADsamZDo7+Lg6I6mNnwkOO6aCGEAQgmezczuzzhObp/IAqo+BfpD3MVZ0RlKYSwNHAEgrt7Eu0fT5nZYL+f+72+cGYUVFBB9USFQ6agggoqSzGmbJT+vjSCMFsCwUttYGb3ZMlnQfmiEMLNwOyoJsD9ZvZrCOEOVDg+juhbGBWUXwTh/t4M3FnAaVSfgopmTwFsiKImJ0LQENcAH8UKcEHNoxBCX6TETkOpGO03TTybQHScj5xk8wDDCqWxehSda30RRv1SyPhzS7acFQT/1Ve6FdUqWcS8pkxB2VA9GN8mJIoM8z3R3nUEgo/7F8Ewng28a2Yj/JxfFxXgvsnMXsmI7YIqQCGE2YF3EfTcmZGj5XAEH7iMmb3r15KMmomAfsD39bCXhhBmRX08wcyOiK4nzqRJkPPpFuCOAiqx5TSmoCt3+m6L9pfuwA3AdcCrZvZP7bgsqDiDCyqo9VObrBkoqKCC8kmJoGalQn+Y2dNmtiHCL34aGR4LKuj/7d15mFxllYDx93QSEsCQCLKIIigIgsjiggujILLIKCiyiwq4QAAB2QZRRgUUFwRERsSoAyoDsooooIgCQtgRB2VEFkVZFGQJaxaSnPnj+wovbViadPXtrn5/z9NPd997q/p0Kl1V957vnNN0BWUmxneA/4qIjSkXC8ZmGS47vp4IXJWZm1ISfItQBjIe1lrUPSqiDHttfD8+M5/IzDsy80hgI8rJ1u6UdgW7RMTLWwi1V9wH7ExZ4f9R4LKI2KPOy3hSPcmaExEvoMztuhUY74lXdzVe1+6gPPf8ATg5ysBXtSzLIN5rgEnAUi2HMyp03t9FxMIRsXpELF4vfDaHhMcz3YeGRqMa4HjK8OorgUMoLZw2An4BHBQRL6/VMKcBB5qM6Qkb188fBN4dEWMjYmnK+dhRlERFMxkTlNlcJzNynktvpVRt7x0RW9SEEo1FQotRFnCdbTJm4DrP9fDP90LzOWZsZs7OzOMpi4SmAjtS5nweUluMjgi98LrlOYHU+6yQkfScNfsSR8SErEPZpaa6uupIygXPu+vHdZm5W/OYzklWXcn5eeDqzDyzhZB7Ur+WQBsCWwCrUuabnElpU/ZAnavxRsoqy82AzzdXJ2rgYv4Dyz8PXJiZsxrHvZ7S+/2szPx0G7GOZhGxGmVxwdYjpbd4L6szBE4FJmXm+i2H0/MiYlytpngJ8D1gfcoCiospj8NFNXmpljWq+zYHzgI+lJkn132LAq+ktPvbEZhGuZB6Xmbe31bMGjwRsTywLmWOypso7+FeQFkAtWnn77SRkFmeMotlQma+vqWwn7NG3OtTEolzKFWsPwNurJVh+1ESkRums6uel4gYQ6l2uY6yIOXRzLzkmc7pI2IN4KuUSu4lsjGjSpK0YEzISBqQzooTV23o2UTEypThoxvWTV8CpmYdxFlXa42xr3l3NNqb7EWZ4TMGuJ4yq2E5SjuTcxpJmyUps0x+kXWYqhZMPHVg+ZqUCw1fyczr60W0TwF7Asul82NaEXUItq0hhoeaoJ+YmQ+0HUsvqtUvT2Tmw41t51Gen84AbqMspnglZbX6CZQZAg/VY/07aVFEHAXsAGyQmTf2W3jxCuBESlthKPOxDm0nUg22+p55JeC9lBlCKwIXAlMy80+NpMZ4YFdKQmPVzPxjc0HdcBdlbunXgU2Bv1Aqj18ILE9ZvLJti+GNaBFxAKWl9FzgAcrM2KQkcR8HLgDuAO7JzJtqVf2setuVM/PmdiKXpN5kQkaSNCgiYnXg4cz8a79qqg0piZmVKS01TqSs3Oxc4BlnUmZwNU7MJwN3UlbEHZqZd0fEcZQT+n/PzN96ga27ogwsXwXYklIxsyjlYsNvKLN7jsrMz7cXoaTRIiKuAK4CfpCZ10XEMsCvgUOBk/OfMwOnUBZRjKG8Zv+QUsXqa3WLImIXSsuyN2Xm1fUifTTeb70TOJjyGnOhic3eU6ua16a8p/goMJ3S9vfkurhgDUoy9YLM3GU4JmMaC4aWBNajzJ4cD1yamefXxPzbgV0oC4juo/xOp46EeTjDVURsSaky+h5wNvBSyhyq9YEJwBuARyljDW6ntBCdDXwn64wiSdLgMSEjSXreGm00NqS0ZFoUWDczH+5/EhgR/wF8DgjgFMoQ+UuH24liL4mI/YHdgO0y85ramuY24NPANzJzZkTsQ1l5uJ+PRffUipi1gZ2ArSj90O/KzOXajEvS6FAT9KdQqlZvorS1ugb4FmXWyM/6rYgeR5lPMQWYAXwkM09vI3YVEbESJYF2J/DBzPxj3d65wL09pSJ228y8qcVQ1WURsTilfVmnNeqVwNGU1mYfBV6UmbPiGQa4t6Fx3jAJOBdYh5IEeJSSIDgO2LfR1ngS8Mhw+h1GskaVzAFZZkl2tk+kzKNaj9Lu7iXABsCSlOcTn/slaZD1PfshkiT9q1pZMa/2JD6acsFm75qMif4X9zPzK8CLKb3pdwJOBz5bb69B0BmC2hjeORsYR+kVDXAs5ULcDxv9ol8NrAFMHrpIR5/MfCwzL6NcLNsJ+Dmwc6tBSRo1MnN6Zm4KbEK5+HkMpTJmDLBQPWZWRPR1Klczc09gNUpF3w0tha4qM28FDqe0lDsrIvaNiIk1GbMG5cL8YiZjel9mPpCZ5wG7U1qYLQycTJkl9Kn6tzx2GCcyvgEsA+yamYsD+9Xtf6Ys3OpU0D80jH+HEaPRcvwIShXdXhGxQ+OQVSlVV0cAn83M7Skt8tY1GSNJ3WGFjCTpeWmscjuKsuJ/18w8v9++iZR2A3OBxxuDR9eizNM4yR7nC6bxb70uZdjpIY19H6K0m1kVWAK4DNgWODvLMOdVKO1P7srMDwx99KNTPTFeJjP/1nYskkaf2krxI5Q5VssBf6dc1L04Mx9rHENmzmncblittu9lz9RONCJ2B/YFlgUeBm6kLKxYFPhYZv7PkAWq1tW/1ZWB9wOvHO5zVuqcmKuBL1BmSz4aEadQ3qtulpl31MqYg4CvZ+bdLYbbcyJiaeA7lAqrrTLzkoj4Of+shrllOLa6k6ReY0JGkvS81Tf1V1AG/x6ZmY839q1DmR3zeuBeSmuUEyiD5OfM5+60ACLi18DczHx7Y9sE4BLgIeBlwK3AezNzTt23M2WV9Nsy88oWwpYktaTOcNidUrn3AKWN2Y+A3zWGxTvnrUUR8W/AKyidLW7JzGl1+7KUpNrqlPZCdwCnZOY5bcWqdkXEYgDzaxvcUjzzTSpGxOuAHwO7ZeZPImID4EJgG+CsusjoQ5SE8Qcy89ohDXwUiIjxlIVxrwDOpyR4P0yZReQ5miQNgbFtByBJGtGWAxYB/twvGfNeSu/55YCfUtqjbE1ZzTkNuGfII+1RjRPeK4GPRcTSmXlPXck8MyK+SukLvRil7cwmEXEtsA+lWuY0kzGS1Nsa1ZSLAC8CZmbmvcAhEXEmcBjwWWAzYGpE/Cwz/2oyZujVVlNzImJbysKWJSgtSO+JiCuAL9Qh24dFxGKNVrGutBzFMvPhxtetVzc0krqbUGZGds4THgQmURKJUNoenwP8sj5HjafMk4GSKNYgqq8FsyLiy8APgP0p7aRPrc87PpdI0hBwhowkaUFMB5aqHwBExPsoVRcLUVqZbZWZ76cMl1+bsgJLg6Rx0nQx5QT3tZ1ddf/pwJqUk63tKLN7/kY5AbsA+PgQhitJakGj1dhhlFkTb2js+31mbgFsTlmwdyxwYkS8/V/uSF3XWKF+JKW6+M3Au4HzKFXHF0TEEXV+TOcivPP4NGx05kNGxMcpQ+Rf0th9F3AR8PGIOBRYEfhSZj5Y968ObA9cnZl/GrqoR4fOa0FmXk6ZG3MDZVbYim3GJUmjjQkZSdKC+CulvcnBEXFsROxDqcZ4KbBLZv44M2fXY6dRVsUt1E6oPe8K4HHgjfCUlYl9mfmXOqBzLeAzwA7A2pm5a2ZObydcSdJQaFwcfQ9lUcSVwK/6H5eZP6W8hnwSeCtgdUxLIuJVwH2UdrBXZeaFwJ6U6tZLgA8CV0bEFHjqrB+pTbXCYm6dbfNFyvvTJyvjM3MWsBdlvuTBwM3AfRExqc6YPJRyHnHAUMc+mkREH/C/lEV0ywMH1Yo7q2MkaQjYskyS9Lxl5uyIOJJSIfMRYAJwHfC1zDyvX9n7iyktNx6e/73puZpfO4HMfDAirgI2jojDOu0qavuHsZk5JzNvAG6IiImUx0qS1OMa7YsOoyRijsrMGZ02Zv2OnQUcHREn1tcV29cMkUZbuRdSVqsn8EjdNyEzZwI/iYhplJXtWwPHRcT0zPxha4FLTxWU/7vHUBZiTW22U4uIN2fmFRGxGyVBvC2lEuwxSmvjG4C9M9P2xl3UeO4/ISImAV8BFo6Ibfq/LkiSBp8JGUnSAsnMyyPibcA7KLNibmpUXYwB5tQ3+psAiwLfbSXQHtKofvkkcBmlrcNs4FxKa4iVgD82bjIpIl4GbAi8rX5+L/DzIQxbktSSiFgbmAxcm5l3wz8vyDUSAS+jvH5c0mkfZDJm6DQugn4Z2BF4CFiF8ho/MyLGAfMy8wHg2xFxKbCRyRgNFzWBOy8iVqS0Kt4f+L/G/k8Ch0fECvX84XbgLEq73RUosw7Pycw7hzz4USwzvxYRawLLmoyRpKFhQkaStMDqBZsLO993VtQ2WmhsRWmv8fnmKjk9f/XC2SeBccDxEfF14HJgFvDuiFiWknzZBFgDWKTe9K/ASZlpMkaSelREjOk32PsuypyxiXX/+FoN00wETKG8XtwE3D2E4eqpfgEsB6wPfC8iXgIc3Xm8ImKhzJydmTdRHitpWGgkcKcCt1CSK53/t5OB/YDDgXvr8XdTnmvOG/Jg1d9H+ee5giSpy8JFT5KkbomIRYC9Kavkrs3M97UcUs+IiPGU4b7bADsD9wNHAwdS2sN1/B64ltJz/veUhMz0zHQ2gCT1mIhYBpjVGJDdmRXwAsog7QnA2zPz3rpvfGbOiogXUVrWrAa82cqYdtX3TzsCH6NULd1AaTV3Vt0fwBhnx2i4iYjlKM81LwO+ARyTmbdHxLco1fQbZeaf67GRmTm/9omSJPUyEzKSpK6JiJWAE4GrgWM7J2AaPLXX/JuBPSgnugtR/r2/RknCTM/MGf1u40wASepBEXE2sBaweZ0b1ty3GfB94C/A4Zl5WmPfFEpSf/fMPGE+FTbqoqd7XY6IV1AWtbwPeCFwAXBEZl43xCFKz0lELExZMLQlZb7k/cAplOqYXTPzhHqc70UlSaOWCRlJUldFxFhgQmY+2nYsvayuSNwQeD+wAXAScBTwO1cdSlJvqxUT44AvUtqOvbtWvqzRScxExKLAx4F96rE3A9MoCZw1KZWsm7YQ/qjVvChdF1hsDjwOzAamZeZ9dd9bKS3l1geWBrbMzB+3ErT0HDQWDE2hvC8dD3wION3KLknSaGdCRpKkHlEH/r6KspJ2V2BR4Fjgm5l5V5uxSZKGRkRMysyHakXMicB/A8dn5m11/zqUxMwalIv7s4HjgR9k5p1Wxwydzr91ROwO7AmsUnfNBH4HnJCZxzeO356y8GKb/tWv0nBUZx6+g/K+9A3AqcARwG+tkJEkjVYmZCRJ6jF1FfTawE6UGTOzgCmZeWabcUmSuqf/HIaIWA84mDKD5D5K26CpnYrViFiR0k5obKcSQ0OnkYxZBbge+BnwQ+A2YFvgPcAylITalzLznnq7cc6B00hSFwytTGljtitlppULhiRJo5YJGUmSelQd0vxvwCeBz2bmz1sOSZI0hGrb0J2AnYHlgd8D383M05vH2EKoPRHxP8BrKFUvNzW2vxr4CrAx8JHM/L7VSxrJ5rNgaCawmwuGJEmjjQkZSZJ6XEQslZn3th2HJGlw9ZtBsjgwHVg0Mx/pd9wywO6UlpYvAC4Bjs3Ma4c2YjVFxETgNGDhzFy/bhsHzMnMrLOBfg0sC6xumzL1AhcMSZJGu762A5AkSd1lMkaSek8nGRMRS0TEQcAN9ePLEbFRRPRFxJjayuzvmfkZylDtXwFvAX4UEQe0+CuMejVx9nfg1RGxYn2snqiP60I12XYdMAF4UavBSoMkM+/LzLOBzU3GSJJGIxMykiRJkjRyHQ38B6U6ZjrwUeAoSkXF3MycV6suyMzfZOaHgQOAOyktzKiVGGrHr4AlKNUCL4An5wHNjohFKHPg5lLaO0k9wwVDkqTRypZlkiRJkjSC1Av28yLiXcA5lIv536JUUmwMfL9u3yKf5oQvIsZn5qyhiln/0mJuXGY+Ub/+FPAZ4Cbgc8D1wP3A9sBhwGmZuVcrQUuSJGlQmZCRJEmSpBEoIm4DrgE+kZl/r9smAz+iVFt8DVieUl0xDriR0iXh/syc1kwQqPsaibTNKcPNf5mZl0XEEsDWwK7AGsCD9SaLAFcCG2Xm3FaCliRJ0qAa23YAkiRJkqTnpjE7Zl/g5cBujWTMmMycHhH/ANYDvlFvNoZycR8ggKnANJMxQ6c+NnMjYg3gm5REy7cBMvP+iJgKTANeA6xPSZz9ErjUZIwkSVLvsEJGkiRJkkaQiBgD/BDYEvgppc3V7+vckTWB31Au9n8VeAJ4hHKh/wnglcAZmflYp2KjhV9h1IqISymPw36ZeX1E9AHZPznWbGkmSZKk3mFCRpIkSZJGkIgISoJlI2BPYElK1cuXgZMoFTFbZ+Z9z3QfVsgMrYhYB7iAMi/muMyc09jXqaCZCIzLzAfailOSJEndY8sySZIkSRpBaiLlhoi4BbgM+CDwMWAnYBKwZTMZ02hz9mQSxmRMKyZQkmV3ZOacfo9Hpy3ZzsBiEXFkZs5oK1BJkiR1R1/bAUiSJEmSBi4zZ2TmVcB/AtsA5wIzgYMi4p0RMaEeZxJmeLgXmAe8tX4fEdFXK56IiMnAG4E3AT5WkiRJPciEjCRJkiSNYJn5YGaeBxwM7EHphHAucEJErNm54K/W/RW4GNgjIt6TmfPqRyf58lpgPWBaZs5sK0hJkiR1jzNkJEmSJKlHRMRYYGVgK0obs8WBrwMHN9piaQhFRF9mzqtfLwecArwFOBv4AqWqaW1gf2ByZq7QTqSSJEnqNhMykiRJktRjImJRYE1gP+DmzDyo5ZBGleZ8mP7bImJVYG9gS2AJShuzPuDXwCGZedGQByxJkqQhYUJGkiRJknpURCwOPFgTAU9WamhoRMRmwNaU5NiNwOXAmcCDlFkxS1Mqmm4ELsvMe1sKVZIkSUPAhIwkSZIkSYMkIsZm5pyI+ABwBDAbuIjSpmwlYO/MPLbNGCVJktSOvrYDkCRJkiSpF9S2ZHMiog/4KvBzYMPM3Ak4GngEuCYi+iJiTERM7NyutaAlSZI0ZEzISJIkSZI0CBpzY7anVMb8IDNvqa3jDgeOA/63to7bDPhiRCzcf96MJEmSepMJGUmSJEmSBtdsYBJwd/3+S5S5Md/OzBl127rAepQ5MpIkSRoFxrYdgCRJkiRJI11E9NXKF4B/AOOBF0XEssCHgT2AO+uxLwNWBP6Wmbe3EK4kSZJaEFZGS5IkSZL0/ETEJOCxzJzTb/uPgLWAmcD0zHxzY9+HKe3Lts7MnwxhuJIkSWqRLcskSZIkSRqAiOirn1cFDgGOiojFmvuAI4B7gFXK5tguIlaLiK8CnwJ+aTJGkiRpdLFCRpIkSZKk5yEifga8CjgkM0+Yz/4VKcmXdwFL1M1PACcCX8jMu4YoVEmSJA0DJmQkSZIkSXqOOrNiIuIg4BPAgZl5Yt03JjPn1q8XyczH69evBlYGEvhLZl7fSvCSJElqlQkZSZIkSZIGoLYnuxE4CfhSZj7U2LcU8HHg3cCtwNnAGZk5u4VQJUmSNIyMbTsASZIkSZJGmPUpM1kv75eMeQ1wLPA2YDqwAvBeYE3gwCGOUZIkScNM37MfIkmSJEmSGqYDLwYe7WyIiDdSkjHrAIcDbwLeB1wCHBARmw19mJIkSRpOrJCRJEmSJGlg7qsf+0QEwD3AccDawF7AtzNzFnBzRCwEbABMbidUSZIkDRcmZCRJkiRJGoDM/L+IOAY4DHgXEMBjlHky/wUQEX2ZOQ8YAzwETGgrXkmSJA0PJmQkSZIkSRqgzPxCRJwL7ALMAM4CrgeIiHGZ+URELAK8lnLufW5rwUqSJGlYiMxsOwZJkiRJkkaMqH3Ksp5QR8SYzJwbEZGNk+yIeCfwLeCszNynnWglSZI0XJiQkSRJkiTpeWi0JZvfvs2BA4CFgXWe7jhJkiSNHn1tByBJkiRJ0kj0DMmYVwOnA/OAvU3GSJIkCayQkSRJkiRp0EXEa4DHM/O2tmORJEnS8GBCRpIkSZKkpxERkzLzoQHe5imzZCRJkiSwZZkkSZIkSU8REWPq5z2B4yNi8nyOiae7vckYSZIkzY8JGUmSJEmSqlrdMjcixgJfBB6jzIJ5ik7SJSI8r5YkSdJzMrbtACRJkiRJGkYCSOAY4AHg+Mx8GEr7MuB1wFLAnzLz6sycVytq5lkZI0mSpGdiQkaSJEmSJJ6sjpkXEa8AdgP2BW6s+3YCPgGs0Tj+QmCPzLxl6KOVJEnSSGNptSRJkiRJPGX2y3eAu4ArMnNGTdBMBWYA29SPI4HXANdFxLvaiFeSJEkjS1hRLUmSJElSERFLAucDrwXOAA6hJF8mAx/sVMNExHhgc0ry5mJgi8z8l1kzkiRJUocJGUmSJEmSqojoA5YDtgL2B15I6S6xPXBWZmZEjMnMufX4Q4GDgZdm5t0thS1JkqQRwJZlkiRJkiRVmTkvM/8CHANsCHwT+AMwvdPSLDPn1sQNwEzgAWDJNuKVJEnSyGGFjCRJkiRJTyMiFgNWzsxrG9uiVsosBnwR2BRYPTMfbytOSZIkDX9WyEiSJEmS9DQy8+FmMqZu66xs3JjSymyqyRhJkiQ9GytkJEmSJEkaoIjYFvg0MCMz39h2PJIkSRr+rJCRJEmSJGkAaquybYE7gD1aDkeSJEkjhBUykiRJkiQNUESMA5bJzDvajkWSJEkjgwkZSZIkSZIkSZKkLrNlmSRJkiRJkiRJUpeZkJEkSZIkSZIkSeoyEzKSJEmSJEmSJEldZkJGkiRJkiRJkiSpy0zISJIkSZIkSZIkdZkJGUmSJEmSJEmSpC4zISNJkiRJkiRJktRlJmQkSZIkaRBExIkRcXvbcUiSJEkankzISJIkSRp1ImL3iMiIuGqAt1s2Ij4XEWsNUhyr1ftbYTDuT5IkSdLwZUJGkiRJ0mi0A3A7sE5ErDSA2y0LfBZYaz77PgasMsA4Vqv3t8IAbydJkiRphDEhI0mSJGlUiYiXA28B9gX+QUnOPNttxkbEQs90TGY+kZmzBidKSZIkSb3GhIwkSZKk0WYH4EHgXOAM+iVkImKF2s5s/4j4RETcBswCdgeuqYedUI/JiNip3u5fZshExHYRcV1EPBIRD0fE7yJi77pvJ+D0euhFjftbvwu/syRJkqSWjW07AEmSJEkaYjsAZ2Xm7Ig4BdgtIt6Qmdf0O25nYAIwlZKQ+REwETi0bru0Hnf5/H5IRGwEnAL8Ejiwbl4VWBc4Bvg18HVgL+Bw4A/1mD8gSZIkqeeYkJEkSZI0akTE64BXAXvWTZcBd1KSNP0TMi8FVsrMfzRufz4lIXNFZp70LD/uXcDDwCaZObf/zsz8U0RcSknI/CIzLx74byRJkiRppLBlmSRJkqTRZAfgHuAigMxM4FRgu4gY0+/YM5vJmOdhOrAosNEC3IckSZKkHmFCRpIkSdKoUBMu21GSMS+PiJUiYiXgKmBp4B39bvLnBfyRxwE3A+dHxJ0R8d8R8c4FvE9JkiRJI5QJGUmSJEmjxQbAiylJmVsaH6fV/Tv0O37GgvywzLwXWAvYHDgHeDslOfO9BblfSZIkSSOTM2QkSZIkjRY7APcCe8xn3/uALSJiyrPcRw7kB2bmbOAnwE8ioo9SNbNrRByWmbcO9P4kSZIkjVwmZCRJkiT1vIhYmJJ0OT0zz5jP/ruB7SnVLFc9w109Vj9Pfg4/c4nMvL/zfWbOi4gb6rfjB3p/kiRJkkY2EzKSJEmSRoPNgYmU1mHzcyXwD0oVzTMlZG4DpgNTIuIRSkLlqsyc37yZ70TE4sCvgDuB5YE9gd8Cf6jH/BaYCxwYEZOAWcCvarszSZIkST3EGTKSJEmSRoMdgJnAL+a3MzPnAecC7wSWeLo7ycwngB0pSZTjgVOA9Z7m8JPqz9yd0qpsR+BUYNP688jMvwNTgKWA79b7W21gv5okSZKkkSAybVksSZIkSZIkSZLUTVbISJIkSZIkSZIkdZkJGUmSJEmSJEmSpC4zISNJkiRJkiRJktRlJmQkSZIkSZIkSZK6zISMJEmSJEmSJElSl5mQkSRJkiRJkiRJ6jITMpIkSZIkSZIkSV1mQkaSJEmSJEmSJKnLTMhIkiRJkiRJkiR1mQkZSZIkSZIkSZKkLjMhI0mSJEmSJEmS1GUmZCRJkiRJkiRJkrrs/wHZKW4Y+ucnmwAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -735,14 +756,6 @@ } ], "source": [ - "low_dvl = df.iloc[:30]\n", - "ax = plot_shapley(\n", - " low_dvl,\n", - " title=\"Artists with low data valuation scores\",\n", - " xlabel=\"Artist\",\n", - " ylabel=\"Shapley Value\",\n", - ")\n", - "ax.get_xticklabels()[low_dvl.index.get_loc(\"Rihanna\")].set_color(\"red\")\n", "plt.show()" ] }, @@ -759,6 +772,7 @@ } ], "metadata": { + "celltoolbar": "Edit Metadata", "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", diff --git a/notebooks/shapley_utility_learning.ipynb b/notebooks/shapley_utility_learning.ipynb index 8bb50229c..8e930730e 100644 --- a/notebooks/shapley_utility_learning.ipynb +++ b/notebooks/shapley_utility_learning.ipynb @@ -686,6 +686,7 @@ } ], "metadata": { + "celltoolbar": "Edit Metadata", "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", From 7ac86215cb891590fec7d034268f6665a93be10f Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Sat, 18 Mar 2023 17:42:51 +0100 Subject: [PATCH 11/65] Remove shapley actor module --- src/pydvl/value/shapley/actor.py | 203 ------------------------------- 1 file changed, 203 deletions(-) delete mode 100644 src/pydvl/value/shapley/actor.py diff --git a/src/pydvl/value/shapley/actor.py b/src/pydvl/value/shapley/actor.py deleted file mode 100644 index 09218f6c8..000000000 --- a/src/pydvl/value/shapley/actor.py +++ /dev/null @@ -1,203 +0,0 @@ -""" -Methods and classes to distribute jobs computing Shapley values in a cluster. - -You probably aren't interested in any of this unless you are developing new -methods for pyDVL that use parallelization. -""" - -import logging -from time import time -from typing import Sequence, cast - -import numpy as np -from ray.util.queue import Empty, Queue - -from pydvl.utils.config import ParallelConfig -from pydvl.utils.parallel.actor import Coordinator, QueueType, RayActorWrapper, Worker -from pydvl.utils.parallel.backend import RayParallelBackend, init_parallel_backend -from pydvl.utils.utility import Utility -from pydvl.value.result import ValuationResult -from pydvl.value.shapley.truncated import TruncationPolicy -from pydvl.value.stopping import MaxChecks, StoppingCriterion - -__all__ = ["get_shapley_queue", "get_shapley_coordinator", "get_shapley_workers"] - - -logger = logging.getLogger(__name__) - - -def get_shapley_queue( - maxsize: int, config: ParallelConfig = ParallelConfig() -) -> QueueType: - if config.backend == "ray": - queue = Queue(maxsize=maxsize) - else: - raise NotImplementedError(f"Unexpected parallel type {config.backend}") - return queue - - -def get_shapley_coordinator( - *args, config: ParallelConfig = ParallelConfig(), **kwargs -) -> "ShapleyCoordinator": - if config.backend == "ray": - parallel_backend = cast(RayParallelBackend, init_parallel_backend(config)) - remote_cls = parallel_backend.wrap(ShapleyCoordinator) - coordinator = remote_cls(*args, **kwargs) - else: - raise NotImplementedError(f"Unexpected parallel type {config.backend}") - return coordinator - - -def get_shapley_workers( - u: Utility, *args, n_jobs: int, config: ParallelConfig = ParallelConfig(), **kwargs -) -> Sequence["ShapleyWorker"]: - parallel_backend = init_parallel_backend(config) - u_id = parallel_backend.put(u) - if config.backend == "ray": - workers = [] - for worker_id in range(parallel_backend.effective_n_jobs(n_jobs)): - parallel_backend = cast(RayParallelBackend, init_parallel_backend(config)) - remote_cls = parallel_backend.wrap(ShapleyWorker) - worker = remote_cls(u_id, *args, worker_id=worker_id, **kwargs) - workers.append(worker) - else: - raise NotImplementedError(f"Unexpected parallel type {config.backend}") - return workers - - -class ShapleyCoordinator(Coordinator): - """The coordinator has two main tasks: aggregating the results of the - workers and shutting down the queue once a certain stopping criterion is - satisfied. - - :param queue: Used by workers to report their results to the coordinator. - :param done: Stopping criterion. - :param update_period: Interval in seconds in-between convergence checks. - :param queue_timeout: Interval of time after which an operation - on the queue will time out. - """ - - def __init__( - self, - queue: QueueType, - done: StoppingCriterion, - *, - update_period: int = 10, - queue_timeout: int = 30, - ): - super().__init__(queue=queue, queue_timeout=queue_timeout) - self.results_done = done - self.results_done.modify_result = True - self.update_period = update_period - self.result = ValuationResult.empty() - - def check_convergence(self) -> bool: - """Evaluates the convergence criterion on the aggregated results. - - If the convergence criterion is satisfied, calls to - :meth:`~Coordinator.is_done` return ``True``. - - :return: ``True`` if converged and ``False`` otherwise. - """ - if self.is_done(): - return True - self._status = self.results_done(self.result) - return self.is_done() - - def run(self, *args, **kwargs) -> ValuationResult: - """Runs the coordinator.""" - start_time = time() - while True: - while (time() - start_time) < self.update_period: - try: - worker_result: ValuationResult = self.queue.get( - block=True, timeout=self.queue_timeout - ) - self.result += worker_result - except Empty: - break - start_time = time() - self._status = self.results_done(self.result) - if self.check_convergence(): - break - self.queue.shutdown() - return self.result # type: ignore - - -class ShapleyWorker(Worker): - """A worker calculates Shapley values using the permutation definition, - aggregates the results and puts them in the queue every - `update_period` seconds until it is closed by the coordinator. - - To implement early stopping, workers can be signaled by the - :class:`~pydvl.value.shapley.actor.ShapleyCoordinator` before they are - done with their work package. - - - :param u: Utility object with model, data, and scoring function - :param queue: Used by workers to report their results to the coordinator. - :param truncation: callable that decides whether to stop computing - marginals for a given permutation. - :param worker_id: id used for reporting through maybe_progress - :param update_period: interval in seconds in-between updates to the queue. - :param queue_timeout: Interval of time after which an operation - on the queue will time out. - """ - - algorithm: str = "truncated_montecarlo_shapley" - - def __init__( - self, - u: Utility, - queue: QueueType, - *, - truncation: TruncationPolicy, - worker_id: int, - update_period: int = 30, - queue_timeout: int = 30, - ): - super().__init__( - queue=queue, - queue_timeout=queue_timeout, - update_period=update_period, - worker_id=worker_id, - ) - self.u = u - self.truncation = truncation - - def _compute_marginals(self) -> ValuationResult: - # Avoid circular imports - from .montecarlo import _permutation_montecarlo_shapley - - return _permutation_montecarlo_shapley( - self.u, - done=MaxChecks(1), - truncation=self.truncation, - algorithm_name=self.algorithm, - ) - - def run(self, *args, **kwargs): - """Computes marginal utilities in a loop until signalled to stop. - - This calls :meth:`_compute_marginals` repeatedly calculating Shapley - values on different permutations of the indices. After :attr:`update_period` - seconds have passed, it puts the results in the queue. - The loop is terminated if the queue is closed by the coordinator. - """ - while True: - acc = ValuationResult.empty() - start_time = time() - while (time() - start_time) < self.update_period: - results = self._compute_marginals() - nans = np.isnan(results.values).sum() - if nans > 0: - logger.warning( - f"{nans} NaN values in current permutation, ignoring. " - "Consider setting a default value for the Scorer" - ) - continue - acc += results - try: - self.queue.put(acc, block=True, timeout=self.queue_timeout) - except Exception: - break From fb2c91dc3f885786797b290016c9c02721ce393b Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Sat, 18 Mar 2023 17:49:54 +0100 Subject: [PATCH 12/65] Update changelog --- CHANGELOG.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index cff8d31d3..428938560 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog +## Unreleased + +- Create new `RayExecutor` class based on the concurrent.futures API, + use the new class to fix an issue with + Truncated Monte Carlo Shapley (TMCS) starting + too many processes and dying + [PR #329](https://github.com/appliedAI-Initiative/pyDVL/pull/329) + ## 0.6.0 - 🆕 New algorithms, cleanup and bug fixes 🏗 - Fixes in `ValuationResult`: bugs around data names, semantics of From 1038a57d66385e214aa85456069afbcd508cdf26 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Sat, 18 Mar 2023 18:08:55 +0100 Subject: [PATCH 13/65] Add docstring for init_executor --- src/pydvl/utils/parallel/futures.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/pydvl/utils/parallel/futures.py b/src/pydvl/utils/parallel/futures.py index c1309e6c7..80ba76968 100644 --- a/src/pydvl/utils/parallel/futures.py +++ b/src/pydvl/utils/parallel/futures.py @@ -18,6 +18,20 @@ def init_executor( max_workers: int, config: ParallelConfig ) -> Generator[Executor, None, None]: + """Initializes a futures executor based on the passed parallel configuration object. + + :param max_workers: Maximum number of concurrent tasks. + :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. + + :Example: + + >>> from pydvl.utils.parallel.futures import init_executor + >>> from pydvl.utils.config import ParallelConfig + >>> config = ParallelConfig(backend="ray") + >>> with init_executor(max_workers=4, config=config) as executor: + ... pass + + """ if config.backend == "ray": max_workers = effective_n_jobs(max_workers, config=config) executor = RayExecutor(max_workers, config) From e50911a6f5287caf58e354e0b2bd31e269f62533 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Sat, 18 Mar 2023 18:09:21 +0100 Subject: [PATCH 14/65] Use zeros method of ValuationResult instead of deprecated empty method --- src/pydvl/value/shapley/truncated.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 7ae013c10..ba77d9d06 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -241,7 +241,7 @@ def truncated_montecarlo_shapley( parallel_backend = init_parallel_backend(config) u = parallel_backend.put(u) - accumulated_result = ValuationResult.empty(algorithm=algorithm) + accumulated_result = ValuationResult.zeros(algorithm=algorithm) with init_executor(max_workers=n_jobs, config=config) as executor: futures = set() From 25410ff1c3b9ca93284646a96f765e5c942cdaee Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Sat, 18 Mar 2023 19:56:17 +0100 Subject: [PATCH 15/65] Add docstring for submit method It is almost the same as the one from the base Executor class but it escapes the start characters because sphinx complains about starting emphasis character without matching ending character --- src/pydvl/utils/parallel/__init__.py | 1 + src/pydvl/utils/parallel/futures.py | 10 ++++++++++ 2 files changed, 11 insertions(+) diff --git a/src/pydvl/utils/parallel/__init__.py b/src/pydvl/utils/parallel/__init__.py index d0a1a0f42..be9f612f2 100644 --- a/src/pydvl/utils/parallel/__init__.py +++ b/src/pydvl/utils/parallel/__init__.py @@ -1,2 +1,3 @@ from .backend import * +from .futures import * from .map_reduce import * diff --git a/src/pydvl/utils/parallel/futures.py b/src/pydvl/utils/parallel/futures.py index 80ba76968..b7579d0e7 100644 --- a/src/pydvl/utils/parallel/futures.py +++ b/src/pydvl/utils/parallel/futures.py @@ -56,6 +56,16 @@ def __init__(self, max_workers: int, config: ParallelConfig): ray.init(**self.config) def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": + r"""Submits a callable to be executed with the given arguments. + + Schedules the callable to be executed as fn(\*args, \**kwargs) + and returns a Future instance representing the execution of the callable. + + :param fn: Callable. + :param args: Positional arguments that will be passed to `fn`. + :param kwargs: Keyword arguments that will be passed to `fn`. + :return: A Future representing the given call. + """ remote_fn = ray.remote(fn) ref = remote_fn.remote(*args, **kwargs) future: "Future[T]" = ref.future() From 59aa9b54b86662086a0d7bd0b1998f704d3e85da Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Sun, 19 Mar 2023 14:50:10 +0100 Subject: [PATCH 16/65] Use deprecation warning for coordinator_update_period and worker_update_period, rename n_concurrent_computations to max_workers --- src/pydvl/value/shapley/truncated.py | 35 ++++++++++++++++++++-------- 1 file changed, 25 insertions(+), 10 deletions(-) diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index ba77d9d06..7859d0494 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -1,11 +1,13 @@ import abc import logging -from concurrent.futures import FIRST_COMPLETED, as_completed, wait +from concurrent.futures import FIRST_COMPLETED, wait +from typing import Optional import numpy as np +from deprecate import deprecated from pydvl.utils import ParallelConfig, Utility, running_moments -from pydvl.utils.parallel.backend import init_parallel_backend +from pydvl.utils.parallel.backend import effective_n_jobs, init_parallel_backend from pydvl.utils.parallel.futures import init_executor from pydvl.value import ValuationResult from pydvl.value.stopping import MaxChecks, StoppingCriterion @@ -183,14 +185,22 @@ def _permutation_montecarlo_one_step( return result +@deprecated( + target=True, + deprecated_in="0.7.0", + remove_in="0.8.0", + args_mapping=dict(coordinator_update_period=None, worker_update_period=None), +) def truncated_montecarlo_shapley( u: Utility, *, done: StoppingCriterion, truncation: TruncationPolicy, config: ParallelConfig = ParallelConfig(), + max_workers: Optional[int] = None, n_jobs: int = 1, - n_concurrent_computations: int = 50, + coordinator_update_period: int = 10, + worker_update_period: int = 5, ) -> ValuationResult: """Monte Carlo approximation to the Shapley value of data points. @@ -221,12 +231,16 @@ def truncated_montecarlo_shapley( sampling permutations. :param truncation: callable that decides whether to stop computing marginals for a given permutation. - :param n_jobs: number of jobs processing permutations. If None, it will be - set to :func:`available_cpus`. :param config: Object configuring parallel computation, with cluster address, number of cpus, etc. - :param n_concurrent_computations: Number of permutation monte carlo iterations + :param max_workers: Number of workers processing permutations. + If None, it will be set to the specific executor's maximum. + :param n_jobs: Number of permutation monte carlo jobs to run concurrently. + :param coordinator_update_period: in seconds. How often to check the + accumulated results from the workers for convergence. + :param worker_update_period: interval in seconds between different + updates to and from the coordinator :return: Object with the data values. """ @@ -235,7 +249,8 @@ def truncated_montecarlo_shapley( "Truncated MonteCarlo Shapley only works with " "the Ray parallel backend." ) - done.modify_result = True + n_jobs = effective_n_jobs(n_jobs, config) + algorithm = "truncated_montecarlo_shapley" parallel_backend = init_parallel_backend(config) @@ -243,10 +258,10 @@ def truncated_montecarlo_shapley( accumulated_result = ValuationResult.zeros(algorithm=algorithm) - with init_executor(max_workers=n_jobs, config=config) as executor: + with init_executor(max_workers=max_workers, config=config) as executor: futures = set() # Initial batch of computations - for _ in range(n_concurrent_computations): + for _ in range(n_jobs): future = executor.submit( _permutation_montecarlo_one_step, u, @@ -268,7 +283,7 @@ def truncated_montecarlo_shapley( # Submit more computations # The goal is to always have `n_concurrent_computations` # computations running - for _ in range(n_concurrent_computations - len(futures)): + for _ in range(n_jobs - len(futures)): future = executor.submit( _permutation_montecarlo_one_step, u, From e3b8357d22b563821bd5a9baebba3c3d20f2d74e Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Tue, 21 Mar 2023 13:20:22 +0100 Subject: [PATCH 17/65] Add alias, document and cite ApproShapley --- CHANGELOG.md | 9 ++- README.md | 53 ++++++++------- docs/30-data-valuation.rst | 25 ++++--- docs/pydvl.bib | 106 ++++++++++++++++++++++++------ src/pydvl/value/shapley/common.py | 2 +- src/pydvl/value/shapley/types.py | 1 + 6 files changed, 140 insertions(+), 56 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index cff8d31d3..2b5474459 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,10 @@ # Changelog +## Unreleased + +- Added alias `ApproShapley` from Castro et al. 2009 for permutation Shapley + + ## 0.6.0 - 🆕 New algorithms, cleanup and bug fixes 🏗 - Fixes in `ValuationResult`: bugs around data names, semantics of @@ -8,8 +13,8 @@ - **New method**: Implements generalised semi-values for data valuation, including Data Banzhaf and Beta Shapley, with configurable sampling strategies [PR #319](https://github.com/appliedAI-Initiative/pyDVL/pull/319) -- Adds kwargs parameter to `from_array` and `from_sklearn` - Dataset and GroupedDataset class methods +- Adds kwargs parameter to `from_array` and `from_sklearn` Dataset and + GroupedDataset class methods [PR #316](https://github.com/appliedAI-Initiative/pyDVL/pull/316) - PEP-561 conformance: added `py.typed` [PR #307](https://github.com/appliedAI-Initiative/pyDVL/pull/307) diff --git a/README.md b/README.md index bd3740b04..2201e8c9e 100644 --- a/README.md +++ b/README.md @@ -32,42 +32,47 @@ Data Valuation is the task of estimating the intrinsic value of a data point wrt. the training set, the model and a scoring function. We currently implement methods from the following papers: -- Ghorbani, Amirata, and James Zou. - [Data Shapley: Equitable Valuation of Data for Machine Learning](http://proceedings.mlr.press/v97/ghorbani19c.html). - In International Conference on Machine Learning, 2242–51. PMLR, 2019. +- Castro, Javier, Daniel Gómez, and Juan Tejada. [Polynomial Calculation of the + Shapley Value Based on Sampling](https://doi.org/10.1016/j.cor.2008.04.004). + Computers & Operations Research, Selected papers presented at the Tenth + International Symposium on Locational Decisions (ISOLDE X), 36, no. 5 (May 1, + 2009): 1726–30. +- Ghorbani, Amirata, and James Zou. [Data Shapley: Equitable Valuation of Data + for Machine Learning](http://proceedings.mlr.press/v97/ghorbani19c.html). In + International Conference on Machine Learning, 2242–51. PMLR, 2019. - Wang, Tianhao, Yu Yang, and Ruoxi Jia. - [Improving Cooperative Game Theory-Based Data Valuation via Data Utility Learning](https://doi.org/10.48550/arXiv.2107.06336). - arXiv, 2022. -- Jia, Ruoxi, David Dao, Boxin Wang, Frances Ann Hubis, Nezihe Merve Gurel, Bo Li, - Ce Zhang, Costas Spanos, and Dawn Song. - [Efficient Task-Specific Data Valuation for Nearest Neighbor Algorithms](https://doi.org/10.14778/3342263.3342637). + [Improving Cooperative Game Theory-Based Data Valuation via Data Utility + Learning](https://doi.org/10.48550/arXiv.2107.06336). arXiv, 2022. +- Jia, Ruoxi, David Dao, Boxin Wang, Frances Ann Hubis, Nezihe Merve Gurel, Bo + Li, Ce Zhang, Costas Spanos, and Dawn Song. [Efficient Task-Specific Data + Valuation for Nearest Neighbor Algorithms](https://doi.org/10.14778/3342263.3342637). Proceedings of the VLDB Endowment 12, no. 11 (1 July 2019): 1610–23. -- Okhrati, Ramin, and Aldo Lipani. - [A Multilinear Sampling Algorithm to Estimate Shapley Values](https://doi.org/10.1109/ICPR48806.2021.9412511). - In 25th International Conference on Pattern Recognition (ICPR 2020), 7992–99. - IEEE, 2021. -- Yan, T., & Procaccia, A. D. - [If You Like Shapley Then You’ll Love the Core](). - Proceedings of the AAAI Conference on Artificial Intelligence, 35(6) (2021): 5751-5759. +- Okhrati, Ramin, and Aldo Lipani. [A Multilinear Sampling Algorithm to Estimate + Shapley Values](https://doi.org/10.1109/ICPR48806.2021.9412511). In 25th + International Conference on Pattern Recognition (ICPR 2020), 7992–99. IEEE, + 2021. +- Yan, T., & Procaccia, A. D. [If You Like Shapley Then You’ll Love the + Core](https://ojs.aaai.org/index.php/AAAI/article/view/16721). Proceedings of + the AAAI Conference on Artificial Intelligence, 35(6) (2021): 5751-5759. - Jia, Ruoxi, David Dao, Boxin Wang, Frances Ann Hubis, Nick Hynes, Nezihe Merve - Gürel, Bo Li, Ce Zhang, Dawn Song, and Costas J. Spanos. - [Towards Efficient Data Valuation Based on the Shapley Value](http://proceedings.mlr.press/v89/jia19a.html). + Gürel, Bo Li, Ce Zhang, Dawn Song, and Costas J. Spanos. [Towards Efficient + Data Valuation Based on the Shapley Value](http://proceedings.mlr.press/v89/jia19a.html). In 22nd International Conference on Artificial Intelligence and Statistics, 1167–76. PMLR, 2019. -- Wang, Jiachen T., and Ruoxi Jia. - [Data Banzhaf: A Robust Data Valuation Framework for Machine Learning](https://doi.org/10.48550/arXiv.2205.15466). +- Wang, Jiachen T., and Ruoxi Jia. [Data Banzhaf: A Robust Data Valuation + Framework for Machine Learning](https://doi.org/10.48550/arXiv.2205.15466). arXiv, October 22, 2022. -- Kwon, Yongchan, and James Zou. - [Beta Shapley: A Unified and Noise-Reduced Data Valuation Framework for Machine Learning](http://arxiv.org/abs/2110.14049). +- Kwon, Yongchan, and James Zou. [Beta Shapley: A Unified and Noise-Reduced Data + Valuation Framework for Machine Learning](http://arxiv.org/abs/2110.14049). In Proceedings of the 25th International Conference on Artificial Intelligence and Statistics (AISTATS) 2022, Vol. 151. Valencia, Spain: PMLR, 2022. Influence Functions compute the effect that single points have on an estimator / model. We implement methods from the following papers: -- Koh, Pang Wei, and Percy Liang. - [Understanding Black-Box Predictions via Influence Functions](http://proceedings.mlr.press/v70/koh17a.html). - In Proceedings of the 34th International Conference on Machine Learning, +- Koh, Pang Wei, and Percy Liang. [Understanding Black-Box Predictions via + Influence Functions](http://proceedings.mlr.press/v70/koh17a.html). In + Proceedings of the 34th International Conference on Machine Learning, 70:1885–94. Sydney, Australia: PMLR, 2017. # Installation diff --git a/docs/30-data-valuation.rst b/docs/30-data-valuation.rst index 57ad08356..b2ca10224 100644 --- a/docs/30-data-valuation.rst +++ b/docs/30-data-valuation.rst @@ -314,9 +314,8 @@ values in pyDVL. First construct the dataset and utility, then call u=utility, mode="owen", n_iterations=4, max_q=200 ) -There are more details on Owen -sampling, and its variant *Antithetic Owen Sampling* in the documentation for the -function doing the work behind the scenes: +There are more details on Owen sampling, and its variant *Antithetic Owen +Sampling* in the documentation for the function doing the work behind the scenes: :func:`~pydvl.value.shapley.montecarlo.owen_sampling_shapley`. Note that in this case we do not pass a @@ -327,8 +326,9 @@ integration. Permutation Shapley ^^^^^^^^^^^^^^^^^^^ -An equivalent way of computing Shapley values appears often in the literature. -It uses permutations over indices instead of subsets: +An equivalent way of computing Shapley values (``ApproShapley``) appeared in +:footcite:t:`castro_polynomial_2009` and is the basis for the method most often +used in practice. It uses permutations over indices instead of subsets: $$ v_u(x_i) = \frac{1}{n!} \sum_{\sigma \in \Pi(n)} @@ -336,11 +336,16 @@ v_u(x_i) = \frac{1}{n!} \sum_{\sigma \in \Pi(n)} ,$$ where $\sigma_{:i}$ denotes the set of indices in permutation sigma before the -position where $i$ appears. To approximate this sum (with $\mathcal{O}(n!)$ terms!) -one uses Monte Carlo sampling of permutations, something which has surprisingly -low sample complexity. By adding early stopping, the result is the so-called -**Truncated Monte Carlo Shapley** (:footcite:t:`ghorbani_data_2019`), which is -efficient enough to be useful in some applications. +position where $i$ appears. To approximate this sum (which has $\mathcal{O}(n!)$ +terms!) one uses Monte Carlo sampling of permutations, something which has +surprisingly low sample complexity. One notable difference wrt. the +combinatorial approach above is that the approximations always fulfill the +efficiency axiom of Shapley, namely $\sum_{i=1}^n \hat{v}_i = u(D)$ (see +:footcite:t:`castro_polynomial_2009`, Proposition 3.2). + +By adding early stopping, the result is the so-called **Truncated Monte Carlo +Shapley** (:footcite:t:`ghorbani_data_2019`), which is efficient enough to be +useful in applications. .. code-block:: python diff --git a/docs/pydvl.bib b/docs/pydvl.bib index 2a35ee51b..69af8af14 100644 --- a/docs/pydvl.bib +++ b/docs/pydvl.bib @@ -1,3 +1,21 @@ +@article{castro_polynomial_2009, + title = {Polynomial Calculation of the {{Shapley}} Value Based on Sampling}, + author = {Castro, Javier and G{\'o}mez, Daniel and Tejada, Juan}, + year = {2009}, + month = may, + journal = {Computers \& Operations Research}, + series = {Selected Papers Presented at the {{Tenth International Symposium}} on {{Locational Decisions}} ({{ISOLDE X}})}, + volume = {36}, + number = {5}, + pages = {1726--1730}, + issn = {0305-0548}, + doi = {10.1016/j.cor.2008.04.004}, + url = {http://www.sciencedirect.com/science/article/pii/S0305054808000804}, + urldate = {2020-11-21}, + abstract = {In this paper we develop a polynomial method based on sampling theory that can be used to estimate the Shapley value (or any semivalue) for cooperative games. Besides analyzing the complexity problem, we examine some desirable statistical properties of the proposed approach and provide some computational results.}, + langid = {english} +} + @inproceedings{ghorbani_data_2019, title = {Data {{Shapley}}: {{Equitable Valuation}} of {{Data}} for {{Machine Learning}}}, shorttitle = {Data {{Shapley}}}, @@ -6,15 +24,15 @@ @inproceedings{ghorbani_data_2019 year = {2019}, month = may, eprint = {1904.02868}, - eprinttype = {arxiv}, pages = {2242--2251}, publisher = {{PMLR}}, issn = {2640-3498}, url = {http://proceedings.mlr.press/v97/ghorbani19c.html}, urldate = {2020-11-01}, abstract = {As data becomes the fuel driving technological and economic growth, a fundamental challenge is how to quantify the value of data in algorithmic predictions and decisions. For example, in healthcare and consumer markets, it has been suggested that individuals should be compensated for the data that they generate, but it is not clear what is an equitable valuation for individual data. In this work, we develop a principled framework to address data valuation in the context of supervised machine learning. Given a learning algorithm trained on n data points to produce a predictor, we propose data Shapley as a metric to quantify the value of each training datum to the predictor performance. Data Shapley uniquely satisfies several natural properties of equitable data valuation. We develop Monte Carlo and gradient-based methods to efficiently estimate data Shapley values in practical settings where complex learning algorithms, including neural networks, are trained on large datasets. In addition to being equitable, extensive experiments across biomedical, image and synthetic data demonstrate that data Shapley has several other benefits: 1) it is more powerful than the popular leave-one-out or leverage score in providing insight on what data is more valuable for a given learning task; 2) low Shapley value data effectively capture outliers and corruptions; 3) high Shapley value data inform what type of new data to acquire to improve the predictor.}, - archiveprefix = {arXiv}, - langid = {english} + archiveprefix = {arxiv}, + langid = {english}, + keywords = {notion} } @inproceedings{jia_efficient_2019, @@ -29,7 +47,8 @@ @inproceedings{jia_efficient_2019 url = {http://proceedings.mlr.press/v89/jia19a.html}, urldate = {2021-02-12}, abstract = {``How much is my data worth?'' is an increasingly common question posed by organizations and individuals alike. An answer to this question could allow, for instance, fairly distributing profits...}, - langid = {english} + langid = {english}, + keywords = {notion} } @article{jia_efficient_2019a, @@ -47,7 +66,25 @@ @article{jia_efficient_2019a url = {https://doi.org/10.14778/3342263.3342637}, urldate = {2021-02-12}, abstract = {Given a data set D containing millions of data points and a data consumer who is willing to pay for \$X to train a machine learning (ML) model over D, how should we distribute this \$X to each data point to reflect its "value"? In this paper, we define the "relative value of data" via the Shapley value, as it uniquely possesses properties with appealing real-world interpretations, such as fairness, rationality and decentralizability. For general, bounded utility functions, the Shapley value is known to be challenging to compute: to get Shapley values for all N data points, it requires O(2N) model evaluations for exact computation and O(N log N) for ({$\epsilon$}, {$\delta$})-approximation. In this paper, we focus on one popular family of ML models relying on K-nearest neighbors (KNN). The most surprising result is that for unweighted KNN classifiers and regressors, the Shapley value of all N data points can be computed, exactly, in O(N log N) time - an exponential improvement on computational complexity! Moreover, for ({$\epsilon$}, {$\delta$})-approximation, we are able to develop an algorithm based on Locality Sensitive Hashing (LSH) with only sublinear complexity O(Nh({$\epsilon$}, K) log N) when {$\epsilon$} is not too small and K is not too large. We empirically evaluate our algorithms on up to 10 million data points and even our exact algorithm is up to three orders of magnitude faster than the baseline approximation algorithm. The LSH-based approximation algorithm can accelerate the value calculation process even further. We then extend our algorithm to other scenarios such as (1) weighed KNN classifiers, (2) different data points are clustered by different data curators, and (3) there are data analysts providing computation who also requires proper valuation. Some of these extensions, although also being improved exponentially, are less practical for exact computation (e.g., O(NK) complexity for weigthed KNN). We thus propose an Monte Carlo approximation algorithm, which is O(N(log N)2/(log K)2) times more efficient than the baseline approximation algorithm.}, - langid = {english} + langid = {english}, + keywords = {notion} +} + +@inproceedings{koh_understanding_2017, + title = {Understanding {{Black-box Predictions}} via {{Influence Functions}}}, + booktitle = {Proceedings of the 34th {{International Conference}} on {{Machine Learning}}}, + author = {Koh, Pang Wei and Liang, Percy}, + year = {2017}, + month = jul, + eprint = {1703.04730}, + pages = {1885--1894}, + publisher = {{PMLR}}, + url = {https://proceedings.mlr.press/v70/koh17a.html}, + urldate = {2022-05-09}, + abstract = {How can we explain the predictions of a black-box model? In this paper, we use influence functions \textemdash{} a classic technique from robust statistics \textemdash{} to trace a model's prediction through the learning algorithm and back to its training data, thereby identifying training points most responsible for a given prediction. To scale up influence functions to modern machine learning settings, we develop a simple, efficient implementation that requires only oracle access to gradients and Hessian-vector products. We show that even on non-convex and non-differentiable models where the theory breaks down, approximations to influence functions can still provide valuable information. On linear models and convolutional neural networks, we demonstrate that influence functions are useful for multiple purposes: understanding model behavior, debugging models, detecting dataset errors, and even creating visually-indistinguishable training-set attacks.}, + archiveprefix = {arxiv}, + langid = {english}, + keywords = {notion} } @inproceedings{kwon_beta_2022, @@ -59,14 +96,14 @@ @inproceedings{kwon_beta_2022 month = jan, volume = {151}, eprint = {2110.14049}, - eprinttype = {arxiv}, publisher = {{PMLR}}, address = {{Valencia, Spain}}, url = {http://arxiv.org/abs/2110.14049}, urldate = {2022-04-06}, abstract = {Data Shapley has recently been proposed as a principled framework to quantify the contribution of individual datum in machine learning. It can effectively identify helpful or harmful data points for a learning algorithm. In this paper, we propose Beta Shapley, which is a substantial generalization of Data Shapley. Beta Shapley arises naturally by relaxing the efficiency axiom of the Shapley value, which is not critical for machine learning settings. Beta Shapley unifies several popular data valuation methods and includes data Shapley as a special case. Moreover, we prove that Beta Shapley has several desirable statistical properties and propose efficient algorithms to estimate it. We demonstrate that Beta Shapley outperforms state-of-the-art data valuation methods on several downstream ML tasks such as: 1) detecting mislabeled training data; 2) learning with subsamples; and 3) identifying points whose addition or removal have the largest positive or negative impact on the model.}, - archiveprefix = {arXiv}, - langid = {english} + archiveprefix = {arxiv}, + langid = {english}, + keywords = {notion} } @inproceedings{okhrati_multilinear_2021, @@ -76,15 +113,46 @@ @inproceedings{okhrati_multilinear_2021 year = {2021}, month = jan, eprint = {2010.12082}, - eprinttype = {arxiv}, pages = {7992--7999}, publisher = {{IEEE}}, issn = {1051-4651}, doi = {10.1109/ICPR48806.2021.9412511}, url = {https://ieeexplore.ieee.org/abstract/document/9412511}, abstract = {Shapley values are great analytical tools in game theory to measure the importance of a player in a game. Due to their axiomatic and desirable properties such as efficiency, they have become popular for feature importance analysis in data science and machine learning. However, the time complexity to compute Shapley values based on the original formula is exponential, and as the number of features increases, this becomes infeasible. Castro et al. [1] developed a sampling algorithm, to estimate Shapley values. In this work, we propose a new sampling method based on a multilinear extension technique as applied in game theory. The aim is to provide a more efficient (sampling) method for estimating Shapley values. Our method is applicable to any machine learning model, in particular for either multiclass classifications or regression problems. We apply the method to estimate Shapley values for multilayer perceptrons (MLPs) and through experimentation on two datasets, we demonstrate that our method provides more accurate estimations of the Shapley values by reducing the variance of the sampling statistics.}, - archiveprefix = {arXiv}, - langid = {english} + archiveprefix = {arxiv}, + langid = {english}, + keywords = {notion} +} + +@misc{schioppa_scaling_2021, + title = {Scaling {{Up Influence Functions}}}, + author = {Schioppa, Andrea and Zablotskaia, Polina and Vilar, David and Sokolov, Artem}, + year = {2021}, + month = dec, + number = {arXiv:2112.03052}, + eprint = {arXiv:2112.03052}, + publisher = {{arXiv}}, + doi = {10.48550/arXiv.2112.03052}, + url = {http://arxiv.org/abs/2112.03052}, + urldate = {2023-03-10}, + abstract = {We address efficient calculation of influence functions for tracking predictions back to the training data. We propose and analyze a new approach to speeding up the inverse Hessian calculation based on Arnoldi iteration. With this improvement, we achieve, to the best of our knowledge, the first successful implementation of influence functions that scales to full-size (language and vision) Transformer models with several hundreds of millions of parameters. We evaluate our approach on image classification and sequence-to-sequence tasks with tens to a hundred of millions of training examples. Our code will be available at https://github.com/google-research/jax-influence.}, + archiveprefix = {arxiv}, + keywords = {notion} +} + +@inproceedings{schoch_csshapley_2022, + title = {{{CS-Shapley}}: {{Class-wise Shapley Values}} for {{Data Valuation}} in {{Classification}}}, + shorttitle = {{{CS-Shapley}}}, + booktitle = {Proc. of the Thirty-Sixth {{Conference}} on {{Neural Information Processing Systems}} ({{NeurIPS}})}, + author = {Schoch, Stephanie and Xu, Haifeng and Ji, Yangfeng}, + year = {2022}, + month = oct, + address = {{New Orleans, Louisiana, USA}}, + url = {https://openreview.net/forum?id=KTOcrOR5mQ9}, + urldate = {2022-11-23}, + abstract = {Data valuation, or the valuation of individual datum contributions, has seen growing interest in machine learning due to its demonstrable efficacy for tasks such as noisy label detection. In particular, due to the desirable axiomatic properties, several Shapley value approximations have been proposed. In these methods, the value function is usually defined as the predictive accuracy over the entire development set. However, this limits the ability to differentiate between training instances that are helpful or harmful to their own classes. Intuitively, instances that harm their own classes may be noisy or mislabeled and should receive a lower valuation than helpful instances. In this work, we propose CS-Shapley, a Shapley value with a new value function that discriminates between training instances' in-class and out-of-class contributions. Our theoretical analysis shows the proposed value function is (essentially) the unique function that satisfies two desirable properties for evaluating data values in classification. Further, our experiments on two benchmark evaluation tasks (data removal and noisy label detection) and four classifiers demonstrate the effectiveness of CS-Shapley over existing methods. Lastly, we evaluate the ``transferability'' of data values estimated from one classifier to others, and our results suggest Shapley-based data valuation is transferable for application across different models.}, + langid = {english}, + keywords = {notion} } @misc{wang_data_2022, @@ -94,15 +162,14 @@ @misc{wang_data_2022 year = {2022}, month = oct, number = {arXiv:2205.15466}, - eprint = {2205.15466}, - eprinttype = {arxiv}, - primaryclass = {cs, stat}, + eprint = {arXiv:2205.15466}, publisher = {{arXiv}}, doi = {10.48550/arXiv.2205.15466}, url = {http://arxiv.org/abs/2205.15466}, urldate = {2022-10-28}, abstract = {This paper studies the robustness of data valuation to noisy model performance scores. Particularly, we find that the inherent randomness of the widely used stochastic gradient descent can cause existing data value notions (e.g., the Shapley value and the Leave-one-out error) to produce inconsistent data value rankings across different runs. To address this challenge, we first pose a formal framework within which one can measure the robustness of a data value notion. We show that the Banzhaf value, a value notion originated from cooperative game theory literature, achieves the maximal robustness among all semivalues -- a class of value notions that satisfy crucial properties entailed by ML applications. We propose an algorithm to efficiently estimate the Banzhaf value based on the Maximum Sample Reuse (MSR) principle. We derive the lower bound sample complexity for Banzhaf value estimation, and we show that our MSR algorithm's sample complexity is close to the lower bound. Our evaluation demonstrates that the Banzhaf value outperforms the existing semivalue-based data value notions on several downstream ML tasks such as learning with weighted samples and noisy label detection. Overall, our study suggests that when the underlying ML algorithm is stochastic, the Banzhaf value is a promising alternative to the semivalue-based data value schemes given its computational advantage and ability to robustly differentiate data quality.}, - archiveprefix = {arXiv} + archiveprefix = {arxiv}, + keywords = {notion} } @inproceedings{wang_improving_2022, @@ -112,14 +179,14 @@ @inproceedings{wang_improving_2022 year = {2022}, month = apr, eprint = {2107.06336v2}, - eprinttype = {arxiv}, publisher = {{arXiv}}, doi = {10.48550/arXiv.2107.06336}, url = {http://arxiv.org/abs/2107.06336v2}, urldate = {2022-05-19}, abstract = {The Shapley value (SV) and Least core (LC) are classic methods in cooperative game theory for cost/profit sharing problems. Both methods have recently been proposed as a principled solution for data valuation tasks, i.e., quantifying the contribution of individual datum in machine learning. However, both SV and LC suffer computational challenges due to the need for retraining models on combinatorially many data subsets. In this work, we propose to boost the efficiency in computing Shapley value or Least core by learning to estimate the performance of a learning algorithm on unseen data combinations. Theoretically, we derive bounds relating the error in the predicted learning performance to the approximation error in SV and LC. Empirically, we show that the proposed method can significantly improve the accuracy of SV and LC estimation.}, - archiveprefix = {arXiv}, - langid = {english} + archiveprefix = {arxiv}, + langid = {english}, + keywords = {notion} } @inproceedings{yan_if_2021, @@ -137,5 +204,6 @@ @inproceedings{yan_if_2021 urldate = {2021-04-23}, abstract = {The prevalent approach to problems of credit assignment in machine learning \textemdash{} such as feature and data valuation\textemdash{} is to model the problem at hand as a cooperative game and apply the Shapley value. But cooperative game theory offers a rich menu of alternative solution concepts, which famously includes the core and its variants. Our goal is to challenge the machine learning community's current consensus around the Shapley value, and make a case for the core as a viable alternative. To that end, we prove that arbitrarily good approximations to the least core \textemdash{} a core relaxation that is always feasible \textemdash{} can be computed efficiently (but prove an impossibility for a more refined solution concept, the nucleolus). We also perform experiments that corroborate these theoretical results and shed light on settings where the least core may be preferable to the Shapley value.}, copyright = {Copyright (c) 2021, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved.}, - langid = {english} + langid = {english}, + keywords = {notion} } diff --git a/src/pydvl/value/shapley/common.py b/src/pydvl/value/shapley/common.py index 023671600..9be775df0 100644 --- a/src/pydvl/value/shapley/common.py +++ b/src/pydvl/value/shapley/common.py @@ -107,7 +107,7 @@ def compute_shapley_values( return combinatorial_montecarlo_shapley( u, done=done, n_jobs=n_jobs, progress=progress ) - elif mode == ShapleyMode.PermutationMontecarlo: + elif mode in (ShapleyMode.PermutationMontecarlo, ShapleyMode.ApproShapley): truncation = kwargs.pop("truncation", NoTruncation()) return permutation_montecarlo_shapley( u, diff --git a/src/pydvl/value/shapley/types.py b/src/pydvl/value/shapley/types.py index 7bacca63c..3b0d80d3d 100644 --- a/src/pydvl/value/shapley/types.py +++ b/src/pydvl/value/shapley/types.py @@ -8,6 +8,7 @@ class ShapleyMode(str, Enum): Make algorithms register themselves here. """ + ApproShapley = "appro_shapley" # Alias for PermutationMontecarlo CombinatorialExact = "combinatorial_exact" CombinatorialMontecarlo = "combinatorial_montecarlo" GroupTesting = "group_testing" From 751f327808d5d7f9fe5354fd57a1e0674c81b279 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 21 Mar 2023 19:47:01 +0100 Subject: [PATCH 18/65] Rename n_local_workers to n_workers --- src/pydvl/utils/config.py | 5 +++-- src/pydvl/utils/parallel/backend.py | 8 ++------ 2 files changed, 5 insertions(+), 8 deletions(-) diff --git a/src/pydvl/utils/config.py b/src/pydvl/utils/config.py index e969c101a..855f7bb29 100644 --- a/src/pydvl/utils/config.py +++ b/src/pydvl/utils/config.py @@ -15,13 +15,14 @@ class ParallelConfig: :param backend: Type of backend to use. For now only 'ray' is supported. :param address: Address of existing remote or local cluster to use. - :param n_local_workers: Number of workers (CPUs) to use when using a local ray cluster. + :param n_workers: Number of workers (CPUs) to use. + This has no effect when using an existing ray cluster. :param logging_level: Logging level for the parallel backend's worker. """ backend: Literal["sequential", "ray"] = "ray" address: Optional[Union[str, Tuple[str, int]]] = None - n_local_workers: Optional[int] = None + n_workers: Optional[int] = None logging_level: int = logging.WARNING diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index b7e146d35..c24e98568 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -99,11 +99,7 @@ class SequentialParallelBackend(BaseParallelBackend, backend_name="sequential"): """ def __init__(self, config: ParallelConfig): - config_dict = asdict(config) - config_dict.pop("backend") - config_dict.pop("address") - config_dict["num_cpus"] = config_dict.pop("n_local_workers") - self.config = config_dict + self.config = {} def get(self, v: Any, *args, **kwargs): return v @@ -135,7 +131,7 @@ class RayParallelBackend(BaseParallelBackend, backend_name="ray"): def __init__(self, config: ParallelConfig): config_dict = asdict(config) config_dict.pop("backend") - config_dict["num_cpus"] = config_dict.pop("n_local_workers") + config_dict["num_cpus"] = config_dict.pop("n_workers") self.config = config_dict if not ray.is_initialized(): ray.init(**self.config) From 86248f1b1215733661eab5a2d448e8908947be0f Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 21 Mar 2023 19:49:18 +0100 Subject: [PATCH 19/65] Lots of changes - Make RayExecutor respect max_workers - Use a local thread and queues to manage work items and submit futures - Make init_executor take max_workers as n_workers from parallel config --- src/pydvl/utils/parallel/futures.py | 306 +++++++++++++++++++++++++-- src/pydvl/value/shapley/truncated.py | 5 +- 2 files changed, 284 insertions(+), 27 deletions(-) diff --git a/src/pydvl/utils/parallel/futures.py b/src/pydvl/utils/parallel/futures.py index b7579d0e7..addb12759 100644 --- a/src/pydvl/utils/parallel/futures.py +++ b/src/pydvl/utils/parallel/futures.py @@ -1,22 +1,29 @@ -from concurrent.futures import Executor, Future +import logging +import queue +import sys +import threading +import time +import types +from concurrent.futures import BrokenExecutor, Executor, Future from contextlib import contextmanager from dataclasses import asdict -from typing import Callable, Generator, TypeVar -from weakref import WeakSet +from typing import Any, Callable, Generator, Optional, TypeVar +from weakref import ref import ray from ..config import ParallelConfig -from .backend import effective_n_jobs __all__ = ["init_executor", "RayExecutor"] T = TypeVar("T") +logger = logging.getLogger(__name__) + @contextmanager def init_executor( - max_workers: int, config: ParallelConfig + config: ParallelConfig = ParallelConfig(), ) -> Generator[Executor, None, None]: """Initializes a futures executor based on the passed parallel configuration object. @@ -28,33 +35,80 @@ def init_executor( >>> from pydvl.utils.parallel.futures import init_executor >>> from pydvl.utils.config import ParallelConfig >>> config = ParallelConfig(backend="ray") - >>> with init_executor(max_workers=4, config=config) as executor: + >>> with init_executor(config=config) as executor: ... pass """ if config.backend == "ray": - max_workers = effective_n_jobs(max_workers, config=config) - executor = RayExecutor(max_workers, config) + max_workers = config.n_workers + with RayExecutor(max_workers, config=config) as executor: + yield executor else: raise NotImplementedError(f"Unexpected parallel type {config.backend}") - yield executor class RayExecutor(Executor): - def __init__(self, max_workers: int, config: ParallelConfig): + """Asynchronous executor using Ray that implements the concurrent.futures API. + + :param max_workers: Maximum number of concurrent tasks. + :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. + + Example: + >>> from pydvl.utils.parallel.futures import RayExecutor + >>> with RayExecutor() as executor: + ... future = executor.submit(lambda x: x + 1, 1) + ... result = future.result() + ... + >>> print(result) + 2 + + >>> from pydvl.utils.parallel.futures import RayExecutor + >>> with RayExecutor() as executor: + ... results = list(executor.map(lambda x: x + 1, range(5))) + ... + >>> print(results) + [1, 2, 3, 4, 5] + """ + + def __init__( + self, + max_workers: Optional[int] = None, + *, + config: ParallelConfig = ParallelConfig(), + ): if config.backend != "ray": raise ValueError( f"Parallel backend must be set to 'ray' and not {config.backend}" ) - self.max_workers = max_workers - self.futures: "WeakSet[Future]" = WeakSet() + if max_workers is not None: + if max_workers <= 0: + raise ValueError("max_workers must be greater than 0") + max_workers = max_workers + config_dict = asdict(config) config_dict.pop("backend") - config_dict["num_cpus"] = config_dict.pop("n_local_workers") + config_dict.pop("n_workers") + if "address" not in config_dict: + config_dict["num_cpus"] = max_workers self.config = config_dict if not ray.is_initialized(): ray.init(**self.config) + self._max_workers = max_workers + if self._max_workers is None: + self._max_workers = int(ray._private.state.cluster_resources()["CPU"]) + + self._broken = False + self._shutdown = False + self._cancel_pending_futures = False + self._shutdown_lock = threading.Lock() + self._queue_lock = threading.Lock() + self._work_queue = queue.Queue(maxsize=self._max_workers) + self._pending_queue = queue.SimpleQueue() + + # Work Item Manager Thread + self._work_item_manager_thread: Optional[_WorkItemManagerThread] = None + def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": r"""Submits a callable to be executed with the given arguments. @@ -66,16 +120,222 @@ def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": :param kwargs: Keyword arguments that will be passed to `fn`. :return: A Future representing the given call. """ - remote_fn = ray.remote(fn) - ref = remote_fn.remote(*args, **kwargs) - future: "Future[T]" = ref.future() - self.futures.add(future) - return future + with self._shutdown_lock: + logger.debug("executor acquired shutdown lock") + if self._broken: + raise BrokenExecutor(self._broken) + if self._shutdown: + raise RuntimeError("cannot schedule new futures after shutdown") + + logging.debug("Creating future and putting work item in work queue") + future = Future() + w = _WorkItem(future, fn, args, kwargs) + self._put_work_item_in_queue(w) + # We delay starting the thread until the first call to submit + self._start_work_item_manager_thread() + return future def shutdown(self, wait: bool = True, *, cancel_futures: bool = False) -> None: - if cancel_futures: - for future in self.futures: - future.cancel() + logger.debug("executor shutting down") + with self._shutdown_lock: + logger.debug("executor acquired shutdown lock") + self._shutdown = True + self._cancel_pending_futures = cancel_futures + if wait: - for future in self.futures: - future.result() + logger.debug("executor waiting for futures to finish") + # Putting None in the queue to signal + # to work item manager thread that we are shutting down + self._put_work_item_in_queue(None) + logger.debug("executor waiting for work item manager thread to terminate") + self._work_item_manager_thread.join() + # To reduce the risk of opening too many files, remove references to + # objects that use file descriptors. + self._work_item_manager_thread = None + self._work_queue = None + self._pending_queue = None + + def _put_work_item_in_queue(self, work_item: Optional["_WorkItem"]) -> None: + with self._queue_lock: + logger.debug("executor acquired queue lock") + try: + self._work_queue.put_nowait(work_item) + except queue.Full: + self._pending_queue.put_nowait(work_item) + + def _start_work_item_manager_thread(self) -> None: + if self._work_item_manager_thread is None: + self._work_item_manager_thread = _WorkItemManagerThread(self) + self._work_item_manager_thread.start() + + +class _WorkItem: + """Inspired by code from: concurrent.futures.thread""" + + def __init__(self, future: Future, fn: Callable, args: Any, kwargs: Any): + self.future = future + self.fn = fn + self.args = args + self.kwargs = kwargs + + def run(self) -> None: + if not self.future.set_running_or_notify_cancel(): + return + + remote_fn = ray.remote(self.fn) + # TODO: we assign 1 CPU to each task which could be wasteful. + ref = remote_fn.options(name=self.fn.__name__, num_cpus=1).remote( + *self.args, **self.kwargs + ) + + # Almost verbatim copy of `future()` method of ClientObjectRef + def set_future(data: Any) -> None: + """Schedules a callback to set the exception or result + in the Future.""" + + if isinstance(data, Exception): + self.future.set_exception(data) + else: + self.future.set_result(data) + + ref._on_completed(set_future) + # Prevent this object ref from being released. + self.future.object_ref = ref + + if sys.version_info >= (3, 9): + __class_getitem__ = classmethod(types.GenericAlias) + + +class _WorkItemManagerThread(threading.Thread): + """Manages submitting the work items and throttling. + + It runs in a local thread. + + :param executor: An instance of RayExecutor that owns + this thread. A weakref will be owned by the manager as well as + references to internal objects used to introspect the state of + the executor. + """ + + def __init__(self, executor: RayExecutor): + self.executor_reference = ref(executor) + self.shutdown_lock: threading.Lock = executor._shutdown_lock + self.queue_lock: threading.Lock = executor._queue_lock + self.work_queue: Optional["queue.Queue[_WorkItem]"] = executor._work_queue + self.pending_queue: Optional[ + "queue.SimpleQueue[_WorkItem]" + ] = executor._pending_queue + super().__init__() + + def run(self) -> None: + logger.debug("starting work item manager thread main loop") + while True: + time.sleep(0.1) + try: + self.add_pending_item_to_work_queue() + self.submit_work_item() + finally: + if self.is_shutting_down(): + self.flag_executor_shutting_down() + + # Since no new work items can be added, + # it is safe to shut down this thread + # if there are no more work items. + if self.work_queue.empty() and self.pending_queue.empty(): + break + logger.debug("exiting work item manager thread main loop") + + def add_pending_item_to_work_queue(self) -> None: + # Fills work_queue with _WorkItems from pending_queue. + # This function never blocks. + while True: + with self.queue_lock: + logger.debug("work item manager thread acquired queue lock") + # If the work queue is not full, + # Move a work item from the pending queue, if not empty, + # to the work queue + if self.work_queue.full(): + return + try: + work_item = self.pending_queue.get_nowait() + except queue.Empty: + logger.debug("pending queue is empty") + return + else: + if work_item is None: + self.work_queue.put_nowait(work_item) + return + logger.debug("moving work item from pending queue to work queue") + self.work_queue.put(work_item) + del work_item + + def submit_work_item(self) -> None: + with self.queue_lock: + logger.debug("work item manager thread acquired queue lock") + # Try to get a work item + # If it is None, we break from the loop. + # Otherwise, we submit the future. + try: + logger.debug("getting work item from work queue") + work_item = self.work_queue.get_nowait() + if work_item is None: + return + except queue.Empty: + logger.debug("work queue is empty") + return + logger.debug("Submitting work item") + work_item.run() + # Delete references to object + del work_item + + def is_shutting_down(self) -> bool: + # Check whether we should start shutting down the executor. + executor = self.executor_reference() + # No more work items can be added if: + # - The executor that owns this worker has been collected OR + # - The executor that owns this worker has been shutdown. + with self.shutdown_lock: + logger.debug("work item manager thread acquired shutdown lock") + if executor is None or executor._shutdown: + # Flag the executor as shutting down as early as possible if it + # is not gc-ed yet. + if executor is not None: + executor._shutdown = True + return True + return False + + def flag_executor_shutting_down(self): + # Flag the executor as shutting down and cancel remaining tasks if + # requested as early as possible if it is not gc-ed yet. + executor = self.executor_reference() + with self.shutdown_lock: + logger.debug("work item manager thread acquired shutdown lock") + if executor is not None: + executor._shutdown = True + # Cancel pending work items if requested. + if executor._cancel_pending_futures: + logger.debug("forcefully cancelling futures") + # Drain all work items from the queues, + # and then cancel their associated futures. + # We empty the pending queue first. + while True: + with self.queue_lock: + try: + work_item = self.pending_queue.get_nowait() + except queue.Empty: + break + if work_item is not None: + work_item.future.cancel() + del work_item + while True: + with self.queue_lock: + try: + work_item = self.work_queue.get_nowait() + except queue.Empty: + break + if work_item is not None: + work_item.future.cancel() + del work_item + # Make sure we do this only once to not waste time looping + # on running processes over and over. + executor._cancel_pending_futures = False diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 7859d0494..8f2c8555e 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -197,7 +197,6 @@ def truncated_montecarlo_shapley( done: StoppingCriterion, truncation: TruncationPolicy, config: ParallelConfig = ParallelConfig(), - max_workers: Optional[int] = None, n_jobs: int = 1, coordinator_update_period: int = 10, worker_update_period: int = 5, @@ -233,8 +232,6 @@ def truncated_montecarlo_shapley( marginals for a given permutation. :param config: Object configuring parallel computation, with cluster address, number of cpus, etc. - :param max_workers: Number of workers processing permutations. - If None, it will be set to the specific executor's maximum. :param n_jobs: Number of permutation monte carlo jobs to run concurrently. :param coordinator_update_period: in seconds. How often to check the @@ -258,7 +255,7 @@ def truncated_montecarlo_shapley( accumulated_result = ValuationResult.zeros(algorithm=algorithm) - with init_executor(max_workers=max_workers, config=config) as executor: + with init_executor(config=config) as executor: futures = set() # Initial batch of computations for _ in range(n_jobs): From a0e5702b80c6a496f165646e4dd15cf95e75b74d Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 21 Mar 2023 19:49:41 +0100 Subject: [PATCH 20/65] Add tests for RayExecutor --- tests/utils/conftest.py | 8 ++++-- tests/utils/test_parallel.py | 56 ++++++++++++++++++++++++++++++++++++ 2 files changed, 61 insertions(+), 3 deletions(-) diff --git a/tests/utils/conftest.py b/tests/utils/conftest.py index 890882e95..ebf322fdd 100644 --- a/tests/utils/conftest.py +++ b/tests/utils/conftest.py @@ -5,12 +5,12 @@ from pydvl.utils.config import ParallelConfig -@pytest.fixture(scope="module", params=["sequential", "ray-local", "ray-external"]) +@pytest.fixture(scope="function", params=["sequential", "ray-local", "ray-external"]) def parallel_config(request, num_workers): if request.param == "sequential": yield ParallelConfig(backend=request.param) elif request.param == "ray-local": - yield ParallelConfig(backend="ray") + yield ParallelConfig(backend="ray", n_workers=num_workers) ray.shutdown() elif request.param == "ray-external": # Starts a head-node for the cluster. @@ -20,6 +20,8 @@ def parallel_config(request, num_workers): "num_cpus": num_workers, }, ) - yield ParallelConfig(backend="ray", address=cluster.address) + yield ParallelConfig( + backend="ray", address=cluster.address, n_workers=num_workers + ) ray.shutdown() cluster.shutdown() diff --git a/tests/utils/test_parallel.py b/tests/utils/test_parallel.py index 8dbb4d37c..9783c4ec6 100644 --- a/tests/utils/test_parallel.py +++ b/tests/utils/test_parallel.py @@ -8,6 +8,7 @@ from pydvl.utils.parallel import MapReduceJob, init_parallel_backend from pydvl.utils.parallel.backend import available_cpus, effective_n_jobs +from pydvl.utils.parallel.futures import init_executor from pydvl.utils.parallel.map_reduce import _get_value @@ -223,3 +224,58 @@ def get_pid(): wrapped_func = parallel_backend.wrap(get_pid, num_cpus=1) pids = parallel_backend.get([wrapped_func() for _ in range(num_workers)]) assert len(set(pids)) == num_workers + + +def test_futures_executor_submit(parallel_config): + if parallel_config.backend != "ray": + with pytest.raises(NotImplementedError): + with init_executor(config=parallel_config): + ... + pytest.xfail("Currently this only works with Ray") + + with init_executor(config=parallel_config) as executor: + future = executor.submit(lambda x: x + 1, 1) + result = future.result() + assert result == 2 + + +def test_futures_executor_map(parallel_config, num_workers): + if parallel_config.backend != "ray": + with pytest.raises(NotImplementedError): + with init_executor(config=parallel_config): + ... + pytest.xfail("Currently this only works with Ray") + + def func(_): + time.sleep(1) + return time.monotonic() + + start_time = time.monotonic() + with init_executor(config=parallel_config) as executor: + assert executor._max_workers == num_workers + list(executor.map(func, range(3))) + end_time = time.monotonic() + total_time = end_time - start_time + # We expect the time difference to be > 3 / num_workers, but has to be at least 1 + assert total_time > max(1.0, 3 / num_workers) + + +@pytest.mark.parametrize("n_workers", [1, 2, 4]) +def test_futures_executor_map_with_max_workers(n_workers, parallel_config): + if parallel_config.backend != "ray" or parallel_config.address is not None: + pytest.skip() + + parallel_config.n_workers = n_workers + + def func(_): + time.sleep(1) + return time.monotonic() + + start_time = time.monotonic() + with init_executor(config=parallel_config) as executor: + assert executor._max_workers == n_workers + list(executor.map(func, range(3))) + end_time = time.monotonic() + total_time = end_time - start_time + # We expect the time difference to be > 3 / n_workers, but has to be at least 1 + assert total_time > max(1.0, 3 / n_workers) From 9fd5a0ec3985b7301fee6678615720616f726958 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 21 Mar 2023 19:49:57 +0100 Subject: [PATCH 21/65] Rerun shapley basic spotify notebook --- notebooks/shapley_basic_spotify.ipynb | 50 +++++++++++++-------------- 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/notebooks/shapley_basic_spotify.ipynb b/notebooks/shapley_basic_spotify.ipynb index bfd36a8c9..ae1c73aca 100644 --- a/notebooks/shapley_basic_spotify.ipynb +++ b/notebooks/shapley_basic_spotify.ipynb @@ -451,41 +451,41 @@ " \n", " \n", " \n", - " Ava Max\n", - " -2.030388\n", - " 0.068219\n", + " Kendrick Lamar\n", + " -1.279149\n", + " 0.091670\n", " \n", " \n", - " blackbear\n", - " -1.322559\n", - " 0.071610\n", + " BLACKPINK\n", + " -1.277363\n", + " 0.177476\n", " \n", " \n", - " Fedde Le Grand\n", - " -1.275141\n", - " 0.132753\n", + " Adele\n", + " -1.241698\n", + " 0.183732\n", " \n", " \n", - " Maroon 5\n", - " -1.191885\n", - " 0.070732\n", + " 5 Seconds of Summer\n", + " -1.228002\n", + " 0.103377\n", " \n", " \n", - " Ariana Grande\n", - " -1.169887\n", - " 0.032827\n", + " Flume\n", + " -1.197065\n", + " 0.102345\n", " \n", " \n", "\n", "" ], "text/plain": [ - " data_value data_value_stderr\n", - "Ava Max -2.030388 0.068219\n", - "blackbear -1.322559 0.071610\n", - "Fedde Le Grand -1.275141 0.132753\n", - "Maroon 5 -1.191885 0.070732\n", - "Ariana Grande -1.169887 0.032827" + " data_value data_value_stderr\n", + "Kendrick Lamar -1.279149 0.091670\n", + "BLACKPINK -1.277363 0.177476\n", + "Adele -1.241698 0.183732\n", + "5 Seconds of Summer -1.228002 0.103377\n", + "Flume -1.197065 0.102345" ] }, "execution_count": 11, @@ -536,7 +536,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABmUAAALBCAYAAACp26VdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd7xcZZ348c83CRAFBLshgIMNscGKnY0LYsNrZaOuHV019rC6rsPPXZNYlmthBdTV6Lr2HoPgDqgIoiEWFBUb2K8SCYoFaQYkeX5/PM94Tya3zp077X7er9d53Tlt7vdMOXPO831KpJSQJEmSJEmSJEnS/FrU6wAkSZIkSZIkSZIWApMykiRJkiRJkiRJXWBSRpIkSZIkSZIkqQtMykiSJEmSJEmSJHWBSRlJkiRJkiRJkqQuMCkjSZIkSZIkSZLUBSZlJEmSJEmSJEmSusCkjCRJkiRJkiRJUheYlJEkSZIkSZIkSeoCkzKSJEnSAhURR0ZEioi1vY5lvkTEceUYj5vlfikizutQDGMRMdaJ5xpEEVErr+f7ex2LJEmS1GsmZSRJkqQ+ExGvLoXYKSIOnsPzzGtheLsJj36w0BMlkiRJknpjSa8DkCRJkjQuIgJ4LpCAAJ4H/Os8/bsLgEOA38/T8/eD04CvA1t7HYgkSZIk2VJGkiRJ6i8PB2rAB4DLgWdFxO7z8Y9SStellC5JKQ1tUial9OdyjH/udSySJEmSZFJGkiRJ6i/PK3/fA3wEuBXwhIk2jIi1pfuwIyPiqRHxjYi4pnTNtRb4Zdn0WZXu0P7W3dhkY8pExB0i4t0R8bOI+EtE/DEivh8R74qIW5ZtzgPeV3Z5X8vz18o2e0fEf0TEDyLiqoi4OiJ+HhGfiIjDp3shIuJj5fnu3LL8A2X5OS3L946Iv0bEVyrLdupirXnMwO2B27fE/f4JYrhVeS22RsT1EfHDiHj2dLHPRETsERH18tpeV16jTRHxpJbt9oqIGyJic8vym0TEthL7M1rWvbAsf840MdTLdqsnWb9fRNwYEd9qWfaaiNgcEZeX2C6LiI9GxN1mcfznlfdionWTdo0XEftHxNsj4hflPflDRJwREfedYNs5fQYlSZKkTrP7MkmSJKlPRMRtgccCP0kpfTUirgJeATwf+MQUu74CeBjwWeBLwD7AecC+wGrgIuAzle2/O0UMy4BvAjcDzgQ+DSwFDgKeAbwd+APwfuBK4HHA6S3PeWXphu1zwIOArwH/A9wI7A8cBWwCLpzimADOAf4JOBr4aWX50eXvgyJiaUppW5n/B/I9zk7JmhZjwDrg+DJ/cmXdd3felH2BzcANwAZgD+CJwP9GxI6U0gemiX9SpfXT50vMlwDvAG4KrAQ+ERGHpZT+H0BK6ZqIuAC4f0TsnVK6ujzNESUmyK/Jhyr/ovkaTfVaUPZ5A/BM4JQJ1j8dWEx+v5seDNTJn7VPA9cAdy6xPzYijkgpXTTN/21LRNwb+AJwC/Lrt5GcuHw8cH5EPCGldGbZthOfQUmSJKmjTMpIkiRJ/ePZwG6UAvCU0g8i4kLgqIi4U0rpZ5Ps9xDggSml71QXRh7IfjXw3ZTS2hnGsJJc4H18SmmnQvqI2BPYUWJ7fy7z5nHAZ1JK72/Z9p7kwvDPpJSe0LJuETlxNJ1zy9+jgXeVfQ8GlgNnkxNRRzCeeDi6Zb9dpJTGgLXNFhjTvC6HAu8FVqWUtpf/fzLwPeBV5C7m2vUKckLmLOCxKaUby/OvI4/1c0JE/F9K6atl+3PJx/pgoFGWHQ1sB77M+LE3X9+jgF+klH41VRAppd9ExBeBh0fEPVJKP2jZ5FnkpNTHKsvOBW5bSQ41/++h5CTWKHDM9C/B7ETEEuCTwF7AUSmlL1fW7UdOJr43ImoppeuBezD3z6AkSZLUUXZfJkmSJPWBUqv/ueSkxwcrq94PBOPdmk3k3a0JmQ74S+uClNK1KaVdlrfxPDtSSn+abseU0i/ILVuOKq8PjCcfXkNOSBxd2eVo4Frg67OMcTLXAS9vJmRKTD8iJx4OiYi95vDczwFSef4bK8//O+B1Zfa5le1bE0/NxxeSW4vsHxF3KcsPIyfWpmsl09RMLj2rujAi7gPcDWiklP5QjbE1IVOWX0RO2BwVEbvN8H/PxghwR+Bt1YRM+d+XAW8CbsfOrxHM4TMoSZIkdZpJGUmSJKk/PIRc4Hx2Suk3leUfJbdUOG6Kgu4LOhjHGeTuqN4REZ+OiOdHxN0rSZGZ+hG5O7CnlLFH/i0iHlS67ZqNc4FbkhMNkF+nrSmlr5MTEkcDRMStyS0jzk8p/XWW/2MyP00pXTXB8kvL35u386QRsTdwJ+CylNIlE2zSbOnzd5VlXyMnF5rHuw9wb3LipdqiCPJrVH2e6ZwG/Bl4WkQsrixvJmneP8ExjETEZ8tYO39tjssDPIbcpdqtZvi/Z+OB5e/tI4+ntNME3K+sP6T87dRnUJIkSeoYkzKSJElSf3h++fv+6sKU0h/JY8XchtxV2EQu71QQpbur+5FbXzwUWA/8APhVRLxsFs+znZwcOBk4EHgjuYXJ7yPibbNoZfK3FiKVbrnOqaw7vCQoHkJuUTTT1iEzceUky5stWxZPsn46zW6ztk6yvrl83+aClNINwPnAPUsC6sjy/89JKV1c9mkmZY4mt8KZUVKmtH76JLAMeDj8bcybpwBXkLtY+5uIWA38H7k7ta+Q3+PXksfqaY4lswedd8vy94nAmgmmp5b1e0FHP4OSJElSx5iUkSRJknqsFLI/vsx+rNnqoNL64B/LuudP+AS5AL5jUkoXp5SeTC4Evw95UPdFwCkR8c+zeJ4/pZT+JaV0AHkg+OeSB7V/CfDOGT5NM7HwUHbtlutccmLiKGYwnkwf+XP5e7tJ1i9r2a7pXHLi6egybSMnGZrrjoqIPYAVwA9LV2gz1dqF2Qj5/f9oteVRGddlLTkRePeU0pNTSq9MKa0p4/P8dhb/c0flOVvtO8Gy5uvxuJRSTDGta+7Qoc+gJEmS1DETXfxKkiRJ6q5nAbuTu+P67iTbPBZ4aEQclFL65QyftzkWSlstOspYJxcCF0bEV8mtIh4PvHe2z59S+hnws4j4KPA7Jm/107rf5RHxI3Ki4ZFlcTMpsxm4npygeAjwJ2CmY+tsJ7/mXZdSujoifg7cISLunFL6acsmR5W/325ZXh1X5oHAV1NK2yrrnga8ENiTWbYYSiltjoifAo8rLY+ayZkPtGx6K3LCZGNKaaeWPqXlyb1n8W+bY7ocALR+pu8zwfbNsYJWkLvZm5V2P4OSJElSJ9lSRpIkSeq955W/L0opPXeiidyNWLDz4O/T+RO5Fc2BM90hIprdgbW6bfl7XWVZc/D3XZ4/Ig6KiDtM8Dw3J3dttcvg61M4F7gpsJo8zsul8Ldut74GPIk8Hs95KaUdM3zOPwC3joibzCKOTvpf8vv55uo4LhFxK+A/KttUfZvcWuRxwN3ZOfHSbCF0Qsv8bHwAWAq8CHgU8L2UUmuS63fkz8Dh1e6/ynhHpzC7sWSaYyE9r7owIo4md53W6nTg58CLI+JREz1hRDwwIm5aHnfyMyhJkiR1hC1lJEmSpB6KiCOBuwDfTyldMMWm7wVeDTw7ItaUVixTSildExHfAFZExEeAn5BbiJyRUvreJLs9A1gVEeeTC8D/RE54PIbcKuXkyrZfIxfQHx8Rt2R8bJu3AYcCGyPim8DFwGXArckJhd3I43vM1Dnk7qZuQx7rpnXdkZXHs3nO+wKfi4ivkI/topTSZ2fxHHPxFuAY8utxUUScSU48PZF8nG9KKZ1f3SGltD0izmO8hcc5lXW/Kq1v7kh+j7/cRkwfYnxsmN3YtZUMKaUdEXEquUu770fE6eQWR0eRu5b7EuMtfabzPuCVwAkRcSjwI/J34RjgNMa77Wv+779GxLHA54FGab31XfJn8ADy+3kHcvdv19HZz6AkSZLUESZlJEmSpN5qthL4n6k2SimNRcQXgYeREySnzfD5nwG8ldz111PIrTO2AJMlZT5GbkXwIOBw4CbAb4CPAyellH5QielPEfGP5EHWjyN3mwXwYeBbwCjwD+V/35w8aPyFwKkppZ0Gj5/GeeTxRxaxawuQc4DXlcezaR3yenI3XI8hD1i/mJyE6EpSJqV0Q0Q8DHg5eYD6lwI3AhcBx6eUPjbJrueQkwpXkV/j1nV3BC5MKbWORzOTmH4dEV8id492I/CRSTb9D/J7+VxgFbn1ztnAv5MTOjP9f7+LiH8A3gw8mPxZ+Rb5M34QLUmZss/3SgLn5cCjgWeTPxtbyV3XrQF+Xzbv5GdQkiRJ6ohIqaNjgkqSJEmSJEmSJGkCjikjSZIkSZIkSZLUBSZlJEmSJEmSJEmSusCkjCRJkiRJkiRJUheYlJEkSZIkSZIkSeoCkzKSJEmSJEmSJEldYFJGkiRJkiRJkiSpC5b0OoBBExEB7Adc3etYJEmSJEmSJElSX9gbuCyllKbayKTM7O0HbOl1EJIkSZIkSZIkqa/sD/xmqg1Mysxes4XM/thaRpIkSZIkSZKkhW5vcmOOaXMGJmXad3VK6apeByFJkiRJkiRJknonj3oyM4vmMQ5JkiRJkiRJkiQVJmUkSZIkSZIkSZK6wKSMJEmSJEmSJElSF5iUkSRJkiRJkiRJ6gKTMpIkSZIkSZIkSV1gUkaSJEmSJEmSJKkLTMpIkiRJkiRJkiR1gUkZSZIkSZIkSZKkLjApI0mSJEmSJEmS1AUmZSRJkiRJkiRJkrrApIwkSZIkSZIkSVIXmJSRJEmSJEmSJEnqApMykiRJkiRJkiRJXWBSRpIkSZIkSZIkqQtMykiSJEmSJEmSJHWBSRlJkiRJkiRJkqQuMCkjSZIkSZIkSZLUBUt6HYAkSZIkSZKkwVerN5YBy+bwFFvHRke2dioeSepHJmUkSZIkSZIkdcIqYM0c9l8HrO1MKJLUn0zKSJIkSZIkSeqE9cAZEyxfCmwuj48Atk2yv61kJA29SCn1OoaBEhE3A/4M7JNSuqrX8UiSJEmSJEn9rFZv7AlcU2b3GhsdubaX8UhSp80mb7CoOyFJkiRJkiRJkiQtbHZfJkmSFiQHIZUkSZIkSd1mUkaSJC1UDkIqSZIkSZK6yqSMJElaqByEVJIkSZIkdZVJGUmStCCVrsd2SayUQUibLnIQUkmSJEmS1CmLeh2AJEmSJEmSJEnSQmBSRpIkSZIkSZIkqQtMykiSJEmSJEmSJHWBSRlJkiRJkiRJkqQuMCkjSZIkSZIkSZLUBSZlJEmSJEmSJEmSusCkjCRJkiRJkiRJUheYlJEkSZIkSZIkSeoCkzKSJEmSJEmSJEldYFJGkiRJkiRJkiSpC0zKSJIkSZIkSZIkdYFJGUmSJEmSJEmSpC4wKSNJkiRJkiRJktQFJmUkSZIkSZIkSZK6YEmvA5AkSZIkqZdq9cYyYNkcnmLr2OjI1k7FI0mSpOFlUkaSJEmStNCtAtbMYf91wNrOhCJJkqRhZlJGkiRJkrTQrQfOmGD5UmBzeXwEsG2S/W0lI0mSpBkZ2KRMRNwCeBvwGGAH8GlgdUrpmhnsG8CZwCOBJ6SUPjOPoUqSJEmS+ljpemyXxEqt3tizMnvR2OjItd2LSpIkScNoUa8DmIOPAHcHHgY8Gngw8O4Z7ns8kOYnLEmSJEmSJEmSpF0NZEuZiDiE3Mrlvimlb5VlLwXOjIh/TSldNsW+hwGvAO6DTcwlSZIkSZIkSVKXDGpLmQcCVzYTMsUXyd2Y3X+ynSLipsBHgRenlC6fyT+KiD0i4mbNCdh7DnFLkiRJkiRJkqQFalCTMrcDflddkFK6EfhjWTeZtwJfTSmdPov/dQLw58q0ZXahSpIkSZIkSZIk9VlSJiJGIyJNM921zed+LPAQ8ngys3EisE9l2r+d/y9JkiRJkiRJkha2fhtT5iTg/dNs8wvgcuA21YURsQS4RVk3kYcAdwSujIjq8k9HxKaU0pET7ZRSuh64vvJ/pglPkiRJkiRJkiRpV32VlEkpXQFcMd12EfE1YN+IODyldGFZ/BByy59vTLLbKPA/Lcu+D/wL8Nn2IpYkSZIkSZIkSZqZvkrKzFRK6eKI+Bzwnoh4AbAb8Hbg4ymlywAiYjlwDvDMlNIFKaXLaWlFU1q9/Dql9MuuHoAkSZIkSZIkSVpw+mpMmVl6GnAJOfFyJnA+8PzK+t2Ag4Gbdj80SZIkSZIkSZKknQ1kSxmAlNIfgadOsX4MmHIAmJSSA8RIkiRJkiRJkqSuGOSWMpIkSZIkSZIkSQPDpIwkSZIkSZIkSVIXmJSRJEmSJEmSJEnqApMykiRJkiRJkiRJXWBSRpIkSZIkSZIkqQtMykiSJEmSJEmSJHWBSRlJkiRJkiRJkqQuMCkjSZIkSZIkSZLUBSZlJEmSJEmSJEmSusCkjCRJkiRJkiRJUheYlJEkSZIkSZIkSeoCkzKSJEmSJEmSJEldsKTXAUiSJEmSJEmSNAxq9cYyYNkcnmLr2OjI1k7Fo/5jUkaSJEmSJEmSpM5YBayZw/7rgLWdCUX9yKSMJEmSJEmSJEmdsR44Y4LlS4HN5fERwLZJ9reVzJAzKSNJkiRJkiRJUgeUrsd2SazU6o09K7MXjY2OXNu9qNRPFvU6AEmSJEmSJEmSpIXApIwkSZIkSZIkSVIX2H2ZJEmSJEnSHNTqjWXAsjk8xdbS3Y0kLWieT7UQmJSRJEmSJEmam1XAmjnsvw5Y25lQJGmgeT7V0DMpI0mSJEmSNDfrgTMmWL4U2FweHwFsm2R/a3VLUub5VEPPpIwkSZIkSdIclK5ydikIrNUbe1ZmLxobHbm2e1FJ0uDxfKqFYFGvA5AkSZIkSZIkSVoIbCkjSZIkSZIkSZIAqNUby4Blc3iKraXVkyZgUkaSJEmSJEmSJDWtAtbMYf91wNrOhDJ8TMpIkiRJkiRJ0hCwhYM6ZD1wxgTLlwKby+MjgG2T7O9naAomZSRJkiRJkiRpONjCQXNWEnO7JFZq9caeldmLxkZHru1eVMPDpIwkSZIkSZIkDQdbOEh9zqSMJEmSJEmSJA0BWzhI/W9RrwOQJEmSJEmSJElaCEzKSJIkSZIkSZIkdYFJGUmSJEmSJEmSpC5wTBlJkiRJkiSpx2r1xjJg2RyeYmsZT0SS1MdMykiSJEmSJEm9twpYM4f91wFrOxOKJGm+mJSRJEmSJEmSem89cMYEy5cCm8vjI4Btk+xvKxlJGgAmZSRJkiRJkqQeK12P7ZJYqdUbe1ZmLxobHbm2e1FJkjptUa8DkCRJkiRJkiRJWghsKSNJkiRJkrTAOci8JEndYVJGkiRJkiRJDjIvSVIXmJSRJEmSJEmSg8xLktQFJmUkSZIkSZIWOAeZlySpOxb1OgBJkiRJkiRJkqSFwKSMJEmSJEmSJEmaTjWfsKJWbyzuWSQDzO7LJEmSJEmSJC14tXpjGbBsDk+xtXQFKA2dWr1xLHBqZdFZwJZavbF6bHRkY4/CGkgmZSRJkiRJUk9ZECqpT6wC1sxh/3XA2s6EIvWPkpDZMMGq5cCGWr2x0sTMzJmUkSRJkiRJvWZBqKR+sB44Y4LlS4HN5fERwLZJ9jc5rKFTuig7pcxGy+oAEnByrd44fWx0ZHtXgxtQJmUkSZIkSVKvWRAqqedKi7tdzie1emPPyuxFY6Mj13YvKqnnVgD7T7E+gAPKdud1I6BBZ1JGkiRJkiT1lAWhkiT1rZl2LzqXbkgXlEW9DkCSJEmSJEmSJPWlmbZGtdXqDJmUkSRJkiRJkiRJE9kEbCGPHTORBFxattMMmJSRJEmSJEmSJEm7GBsd2Q6sLrOtiZnm/PFlO82ASRlJkiRJkiRJkjShsdGRjcBK4LKWVVuAlWW9ZsikjCRJkiRJkiRJmlRJvBxSWXQMcJAJmdkb2KRMRNwiIj4SEVdFxJUR8d6I2GsG+z0wIs6NiGvLvl+JiJt0I2ZJkiRJkiRJkgbUjsrjTXZZ1p6BTcoAHwHuDjwMeDTwYODdU+0QEQ8EPgd8AbgfcF/g7ez8YZIkSZIkSZIkSeq4Jb0OoB0RcQjwSOC+KaVvlWUvBc6MiH9NKbX2bdf0VuDUlNJoZdmP5zdaSZIkSZIkSZKkwW0p80DgymZCpvgiucXL/SfaISJuU9b9LiK+GhG/jYgvR8TfT/WPImKPiLhZcwL27tAxSJIkSZIkSZIWhmpZ/IpavbG4Z5GopwY1KXM74HfVBSmlG4E/lnUTuUP5uxZ4D7mlzbeBcyLizlP8rxOAP1emLW1HLUmSJEmSJElaUGr1xrHAxZVFZwFjZbkWmL5KykTEaESkaaa7tvn0zWNdn1J6X0rpOymlfyF3X/acKfY7EdinMu3f5v+XJEmSJEmSJC0gJfGyAdivZdVyYIOJmYWnr5IywEnAIdNMvwAuB25T3TEilgC3KOsmsrX8/VHL8ouBAycLKKV0fUrpquYEXD2bA5IkSZIkSZIkLTyli7JTymy0rG7On2xXZgvLkl4HUJVSugK4YrrtIuJrwL4RcXhK6cKy+CHkJNM3JtltDLgMOLhl+V3IzcUkSZIkSZIkSeqUFUzd81IAB5TtzutGQOq9fmspMyMppYuBzwHviYj7RcQRwNuBj6eULgOIiOURcUlE3K/sk4A3Ay+LiJURcaeIeB1wV+C9vTkSSZIkSZIkSdKQWtbh7TQE+qqlzCw9jZyIOQfYAXwaeFll/W7kVjE3bS5IKZ0cEUuBt5K7OrsIeFhK6efdClqSJEmSJEmStCBsnX6TWW2nITCwSZmU0h+Bp06xfoxd++kjpTQKjM5fZJIkSZIkSZIksQnYAixngrJqIJX1m7oZlHprYJMykiRJkqTeq9Uby5hblxtbx0ZHrB0qSZKGztjoyPZavbEa2EBOwFQTM6n8PX5sdGR714NTz5iUkSRJkiTNxSpgzRz2Xwes7UwokiRJ/WVsdGRjrd5YCZxKbjHTtIWckNnYm8jUKyZlJEmSJElzsR44Y4LlS4HN5fERwLZJ9reVjCRJGmolMXM2cFVZdAxwti1kFiaTMpIkSZKktpWux3ZJrNTqjT0rsxeNjY5c272oFha7kJMkaSDsqDzeZEJm4TIpI0mSJEnSYLMLOUmSpAFhUkaSJEmSpMFmF3KSpGG3qPJ4Ra3esOsvDSyTMpIkSVKb7DJIUj+wCzlJ0jCr1RvHAqdWFp0FbKnVG6vHRkc29iisoTbFfc7SyuNDa/XGpBU+vM+ZnEkZSZIkqX12GSRJkiTNk5KQ2TDBquXAhlq9sdLEzLyYyX3O5inWeZ8zBZMykiRJUvvsMkiSJEmaB7V6YzFwSpmNltUBJODkWr1xul2Zddxk9zkz5X3OFEzKSJIkSW2yyyBJkiRp3qwA9p9ifQAHlO3O60ZAC8Vk9znqjEXTbyJJkiRJkiRJUlfNdOzGuYzxKHWdSRlJkiRJkiRJUr+ZaUsNW3RooJiUkSRJkiRJkqThVi0HXlHGa+l3m4At5LFjJpKAS8t20sAwKSNJkiRJkiRJQ6pWbxwLXFxZdBYwVpb3rbHRke3A6jLbmphpzh9ftpMGhkkZSZIkSZIkSRpCJfGyAdivZdVyYMMAJGY2AiuBy1pWbQFWlvXSQDEpI0mSJEmSJElDpnRRdkqZjZbVzfmT+70rs5J4OaSy6BjgIBMyGlQmZSRJkiRJkiRp+KwA9mfXhExTAAeU7frdjsrjTXZZpkFmUkaSJEmSJEmShs+yDm8nqQNMykiSJEmSJEnS5KplqCv6vbuviq0d3k5SB5iUkSRJkiRJkqQJ1OqNY4GLK4vOAsbK8n63CdgCpEnWJ+DSsp2kLjEpI0mSJEmSJGk+DWRLk5J42QDs17JqObCh3xMzZdyV1WW2NTHTnD/e8Vmk7jIpI0mSJEmSJGleDGpLk5I4OqXMRsvq5vzJ/Z5gGhsd2QisBC5rWbUFWFnWS+qiJb0OQJIkSZIkSZqLWr2xjLkNVr51bHTEcTU6rNLSpFWzpUk/JwVWAPtPsT6AA8p253UjoHaNjY5srNUbZwNXlUXHAGfbQkbqDVvKSJIkSZIkadCtAi6cw7Sq+yHP2KB2/TXoLU1mmuSbSzKwm3ZUHm8yISP1ji1lJEmSJEmSNOjWA2dMsHwpsLk8PgLYNsn+fdlKprQ0ObWy6CxgS63eWN3HLUyaBr2lyUw/E3352ZHUv0zKSJIkSZIkaaCVrsd2KRyv1Rt7VmYvGhsdubZ7Uc3NgHf9BYPf0mQTedyV5eza0gcglfWbuhmUpMFn92WSJEmSJElSHxmCrr9gwFualO69VpfZ1LK6OX+83YBJmi2TMpIkSZIkSVJ/aXb9NVELDdi5669+1Wxp0prQaErApfRxS5PSEmklcFnLqi1Av7dUktSnTMpIkiRJkiRJ/WXQu/4ampYmJfFySGXRMcBBJmQktcukjCRJkiRJktRfBrrrr6Yhammyo/J4U78nkiT1N5MykiRJkiRJUn8Z+K6/mmxpIkk7MykjSZIkSZIk9ZFh6fqrwpYmklSYlJEkSZIkSZL6zBB1/SVJqjApI0mSJEmSJPUhu/6SpOGzpNcBSJIkSVK7avXGMmDZHJ5i69joSM8GSR70+CVpAFQrJK+o1RtnD2DXWXb9JUlDxKSMJEmSpEG2Clgzh/3XAWs7E0pbBj1+SepbtXrjWODUyqKzgC21emO1LU0kSb1iUkaSJGkAWbte+pv1wBkTLF8KbC6PjwC2TbJ/r78Hgx6/JPWlkpDZMMGq5cCGWr3hmCySpJ4wKSNJkjSYrF0vASW5uEtiolZv7FmZvWhsdOTa7kU1c4Mev6QFYeC6/6rVG4uBU8pstKwOIAEn1+qN0/v9WCRJw2fR9JtIkiSpD60HDp9gOqKyzRGTbHN42V+SJM2v1oTG4p5F0obS2uTiyqKzgLGyvJ+tAPZn14RMUwAHlO0kSeoqW8pIkiQNIGvXS5LU3wZ9PJMB7/5rpl28zqUrWEmS2mJLGUmSJEmSpA6qJDT2a1nVTGj0dUuTGXT/Bbn7r35t+TPT8bYcl0uS1HUmZSRJkiRJkjpkCBIaMPjdf20CtpDHjplIAi4t20mS1FV2XyZJkqSeqNUby5hbtyFbSzdukiT1k2ZCYzLVhMZ53QioDQPd/dfY6Mj2Wr2xmtxaKbFzcqmZqDl+bHRke9eDkyQteCZlJEmS1CurgDVz2H8dsLYzoUiS1DEDndAoBr77r7HRkY21emMleVyf5ZVVW8gJmX4dD0eSNORMykiSJKlX1gNnTLB8KbC5PD4C2DbJ/n1bECRJ6phqt+sravXG2QPQumHgExqMd/+1nIm7MEtlfV93/1USM2cDV5VFxwCD8BmSNMCm6BFgaeXxobV6Y9L7HHsEGG4mZSRJktQT5UZjl5uNWr2xZ2X2orHRkWu7F5UkDZVBTGj8Ta3eOJbcyqHpLGBLrd5Y3eetHAY+oTFk3X/tqDzeNCAxSxpsM+kRYPMU6+wRYMgtmn4TSZIkSZI0SEpC4+LKorOAsbK875U4NwD7taxaDmzo5+Mohf6ry2zrQPMDk9Aoia+VwGUtq7YAK/s8MSZJvbQeOHwO0/ruh6xusqWMJEmSJElDpJLQaNVMaPR1gXqt3lgMnFJmW1uaBDmxcXKt3ji9XxMbwzKeid1/SdLsTdYjgNRkSxlJkiRJkobEDBIakBMai7sX1aytAPZn4q6/KMsPKNv1rZJ4OaSy6BjgoEFJyFTY/ZckSR1kUkaSJEmSpOExDAmNiQZHnst2vWRCQ5Ik7cSkjCRJkiRJw2MYEhoz7fLFrmEkSdLAMSkjSZIkSdLEqvfMK/q8y6+mYUhobCKPvZImWZ+AS8t2kiRJA2VJrwOQJEmDp1ZvLGNuNWy3lsEPJUnqS7V641jyIO1NZwFbavXG6j4fE6SZ0FjOxF2YpbK+bxMaY6Mj22v1xmpgAzne6nE0EzXH2xWYJEkaRB1pKRMR+0REV2sMRcQtIuIjEXFVRFwZEe+NiL2m2ed2EfGhiLg8Iq6NiG9HxD92K2ZJkobIKuDCOUyruh+yJEkzUxIyG4D9WlYtBzaU9X2pJCpWl9nWliYDk9Aoia+VwGUtq7YAK/s8MSZJkjSptlvKRMR9gNcDDwZ2Bx4OnBsRtwLeC7w1pXReJ4KcxEfINXQfBuwGvA94N/DUKfb5ILAv8Fjg92XbT0bEfVJK35nHWCVJGjbrgTMmWL4U2FweHwFsm2R/W8lIkvpS6aLslDLb2tIkyImNk2v1xun9mtgYGx3ZWKs3VpJb+iyvrNpCTsgMREKjHMfZwFVl0THA2f36uqu3pmjJvbTy+NBavTHp9aktuSVJ3dBWUiYiHgScC/wG+DDw3Oa6lNLvI2Ifcg3Y8zoQ40T//xDgkcB9U0rfKsteCpwZEf+aUmqtSdP0IOCFKaULyvzrI+JfgMOBCZMyEbEHsEdl0d6dOAZJkgZZuWHd5aa1Vm/sWZm9aGx05NruRSVJUkesAPafYn0AB5TtzutGQO0YooTGjsrjTQMYv7pnFbBmmm02T7FuHbC2Y9FIkjSJdlvK/CdwMfAAcpLiuS3rvwQ8aw5xTeeBwJXNhEzxRfLF2v2B0ybZ76vAkyOiAVwJPIlcY+K8Kf7XCUz/oy5JkiRJGg4zHTNtLmOrdYsJDS0kk7XknilbyUiSuqLdpMx9gRNSStdPMo7Lb4DbtR/WtG4H/K66IKV0Y0T8cZr/+yTgE8AfgBuB64AnpJR+NsU+JwL/VZnfm9zkW5IkSZI0fGZaMGsBrtRHJmvJLUlSv1nU5n5/nWbf5cA1s33SiBiNiDTNdNc2YwZ4HXlMmYcC9yEnWz4ZEfecbIeU0vUppauaE3D1HP6/JEmSJKm/bSJXxEuTrE/ApWU7SZIkaVbaTcp8HVg50YqI2BN4NvDlNp73JOCQaaZfAJcDt2n5v0uAW5R1E8V1R+AlwHNSSueklC5KKa0DvgW8uI1YJUmSJElDpnTxtbrMtiZmmvPH2xWYJEmS2tFuUmYNcJ8yNssxZdmhEfFc4ELg1uRWKbOSUroipXTJNNMNwNeAfSPi8MruDynH841Jnv6m5e+OluXbaf91kCRJkiQNmbHRkY3kioiXtazaAqws6yVJkqRZaysZkVL6BvAo4E7AB8vik4B3A4uBR6WUvteRCCf+/xcDnwPeExH3i4gjgLcDH08pXQYQEcsj4pKIuF/Z7RLgZ8D6ss8dI+IVwMOAz8xXrJIkSZKkwVMSL4dUFh0DHGRCRpIkSXOxpN0dU0rnAgdHxGHAnckJnp8DF6aUJut7t5OeRk7EnENu/fJp4GWV9bsBB1NayKSU/hoRjwJGgc8Ce5GTNM9KKZ3ZhXglSZIkSYOl2tPCJrsskyRJ0ly1nZRpSil9F/junCOZ/f/9I/DUKdaPAdGy7KfAP85vZJIkSZIkdu6ZYUWt3jjbpIYkSZIWuraSMhHx4Jlsl1L6SjvPL0mSJEkaXLV641jg1Mqis4AttXpjtd1/SZL6Va3eWAYsm2DV0srjQ2v1xrZJnmLr2OjI1s5HtnD4HmghaLelzHnATLooW9zm80uSJEmaZ1Pc9M6UN73aRUnIbJhg1XJgQ63eWGliRpLUp1YBa6bZZvMU69YBazsWzcLke6Ch125S5qgJli0GasDzyc3U620+tyRJkqTumMlN71S86dVOavXGYuCUMhstq4Ncue/kWr1xul2ZSZL60HrgjDnsb2WVufM90NBrKymTUvryZOsi4v3AJuBI4Ny2opIkSZLUDZPd9C5lvAbiEcCk3UPMR1AaaCuA/adYH8ABZbvzuhGQJEkzVVoAe33TQ74HWgjabSkzqZTSjoj4OHAC8JpOP78kSZKkzpjsprdWb+xZmb1obHTk2u5FpWJR5fGKWr1x9oC0LJlpd3hz6TZPkiRJGliLpt+kLbcA9p2n55YkSZKkoVXGZLm4sugsYKws73czrdlqDVhJkiQtSG21lImIAydZtS/wYOCV5C7MJEnSBBxcW5I0kZJ42TDBquXAhlq9sXJsdGRjl8OajU3AFnK8rWPKQB5TZgveL0qSNC+muNdcWnl8aK3emLR7Wu81pfnVbvdlY+SL6YkE8HXyoKGSJHXckCQ0HFxbkrSTWr2xGDilzLYmNIJ8D3Zyrd44vV+7MhsbHdleqzdWkxNLiZ2Po3kPeXy/xi9J0hCYyb3m5inWea8pzbN2kzLPYdekTAL+BPw8pfSjOUUlSdLUhiGh4eDakqRWK4D9p1gfwAFlu/O6EVA7xkZHNtbqjZXAqeQWM01byAmZfm7pI0nSoJvsXnOmvNeU5llbSZmU0vs7HIckSbMx8AkNB9eWJE1gpq1A59JatCtKYuZs4Kqy6BjgbFvISJI0vya715TUP9ptKSNJUs+Y0JAkDamZFqAMSkHLjsrjTSZkJEmSpBkmZSLi3DaeO6WUjm5jP0mSJElaiDaRu/hazq5jykDuMnpL2U6SJEnSAFo0i+1iltNMn1uSJEmSFrzSkmR1mZ1oDE/IY7LY4kSSJEkaUDNqKZNSOnKe45AkSZKkTqpWEltRqzcGYjyTMhbLSuBUcouZpi3khMzG3kQmSZIkqRNszSJJkiRpqNTqjWOBiyuLzgLGyvK+VxIvh1QWHQMcZEJGkiRJGnxzTspExN4RsX9EHNg6dSJASZIkSZqpknjZAOzXsmo5sGFQEjPAjsrjTYPQykeSJEnS9NpOykTECyPip8CVwK+AX04wSZIkSVJX1OqNxcApZTZaVjfnTy7bSZIkSVLXtZWUiYgXAO8Afgb8O/kG52RgFLgcuAj4586EKEmSJKnLWsdjGZQkxgpgf3ZNyDQFcEDZTpIkSZK6bkmb+70U+HxK6ZiIuCXwBqCRUjo3It4EfAu4ZaeClDSuVm8sA5bN4Sm2jo2ObO1UPJIkaUIDOcg8/K37r1Mri84CttTqjdUDMKbJTK+R5nItJUmSJElta7f7sjsCny2P/1r+7g6QUvoz8D/Ai+YWmqRJrAIunMO0qvshS5K0cAzyIPNDMB7LTCueWEFFkiRJUk+0m5T5M6WVTUrpKuA6cjcATVcDt5tbaJImsR44fILpiMo2R0yyzeFlf0mSNA8GOakxJOOxbAK2AGmS9Qm4tGwnSZIkSV3XbvdlPwAOrcx/HXhhRJxJTvSsAn4yx9gkTaB0PbZL7c5avbFnZfaisdGRa7sXlSRJmkFSI5GTGqf3aVdmzfFYJlMdj+W8bgQ0W2OjI9tr9cZqcmIssfP70EzUHN+nr78kSZKkBaDdljIfBu4REXuU+TXAIcCvgTHgYODf5xydJEmSFiIHme+NoRiPpYx7sxK4rGXVFmDlAIyLI0mSJGmItdVSJqX0PuB9lfnNEXF34DHAduALKSVbykiSJGlWHGS+p4ZmPJax0ZGNtXrjbOCqsugY4GxbyEiS+lmt3ljGxNcJSyuPD63VG9smeYqtpXcNSVIfa7f7sl2klH7BeHcNkiRJ0qxUxmNp1RyPpd9bOQx6UqM5HstyJm7tk8r6QRmPZUfl8SYTMpKkAbCK3BvNVDZPsW4dsLZj0UiS5kVbSZmIuAD4GPCplNKWzoYkSZKkhWYIxmOBAU9qOB6LJEk9tx44Yw7792vFD0lSRbstZbYDJwFvjoivAx8HNqSULu9YZJIkSVpIHGS+D5Ruv1aSu5BbXlm1hRx7P7dUkiRpoJWux0ysSNKQWzT9JrtKKT0QqAEnAHuQb9oujYhzI+L5EXGrzoUoSZKkBWDQx2MBhmOQ+RLjIZVFxwAHDULskiRJktTv2krKAKSUfp1SenNK6b7AnYDXADcH3gVcFhGf61CMkiRJmrnq9d2K0i3YIBj08Vj+ZkiSGo7HIkmSJEnzoN3uy3aSUvoFcGJEjALPBd4CPKwTzy1J6qxavbGMudU031qa1UvqM7V641hyC+ams4AttXpj9QAkBAZ6PJYJmNSQJEmSJO2i7ZYyVRHxgIj4L+DX5JYyAB/txHNLkjpuFXDhHKZV3Q9Z0nRKQmYDsF/LquXAhrK+b5Wkxeoym1pWD8R4LJIkSZIkTaftljIRcTjwZOBJ5EFX/wL8H/AJ4MyU0vUdiVCS1GnrgTMmWL4U2FweHwFsm2R/W8lIfaZ0UXZKmW1tZRLkpMbJtXrj9H5OajjIvCS1Z4qW0Esrjw+t1RuTXt/ZElqSJKk72krKRMTPgRpwA7lbjFcBn00pXde50CRJ86HccO9y012rN/aszF40NjpybfeikjRHK4D9p1gf5Eo0K4DzuhFQu0pi5mzgqrLoGODsfk4mSVIfWAWsmWabzVOsWwes7Vg0kiRJmlS7LWV+RL7gOz2ldHUH45HmlWNpSJKG1Ex/2+byG9hNjsciSbMzWUvomfIeR5IkqUvaSsqklB7T6UCkLplJDbKpWINMktSPZlqYZqGbJA2hyVpCS5Ikqf+0PaaMNKAcS0OSNIw2kcddWc6uY8pAHlNmS9lOkiRJkiT1iEkZLSiOpSFJGkZjoyPba/XGamADOQFTTcyk8vd4uwGTJEmSJKm3FvU6AEmSJM3d2OjIRmAlcFnLqi3AyrJekiRJkiT1kEkZSZKkIVESL4dUFh0DHGRCRpIkSZKk/mBSRpIkabjsqDzeZJdlkiRJkiT1j7bGlImIs4APAaellP7S2ZAkSZIkdUOt3lgGLJtg1dLK40Nr9ca2SZ5iaxmzT5IkSZI0A20lZYA7AB8GromI08gJmnNSSmnq3SRJkiT1kVXAmmm22TzFunXA2o5FI0mSJElDrq2kTErp4Ii4L/B04Enl7+UR8VHgIyml73YuREmSpK6qdu+6olZvnG0XYBpi64Ez5rC/rWQkSZIkaRbabSlDSumbwDcj4l+Ah5ETM6uAl0fExcAHgY+mlLZ0JFJJkqR5Vqs3jgVOrSw6C9hSqzdWj42ObOxRWNK8KV2PmViRJEmSpC5ZNP0mU0sp7UgpfT6l9AzgQGADcDdgFBiLiC9GxMhc/48kSdJ8KgmZDcB+LauWAxvKekmSJEmSpLa13VKmKiL+ntxSZiVwC+AH5JYyfwWeA5wREW9IKb2mE/9PkiSpk2r1xmLglDIbLasDSMDJtXrjdLsykyRJw6hWbywDlk2wamnl8aG1emPbJE+xtbTAlCRJU2g7KRMRdyMnYp5CbiHzO+ADwIdaxpQ5JSLeDbwYMCkjSZL60Qpg/ynWB3BA2e68bgQkaWGwEFRSH1kFrJlmm81TrFsHrO1YNJIkDam2kjIR8V3gnsD1wOnAi4DPp5R2TLLLl4DntvO/JEmSumCiAtG5bCdJM2UhqKR+sR44Yw77myCWJGkG2m0pcyXwfOBTKaWrZrD96cBBbf4vSZKk+TbTQgQLGyR1moWgkvpCaXXnOUWSpHnWVlImpXTkLLe/DvhVO/9LkiSpCzYBW4Dl7DqmDOQxZbaU7SSpYywElSRJkhaWRXPZOSIeEBEnRMRbI+LOZdlNI+LeEbFXZ0KUJEmaX2OjI9uB1WU2taxuzh9ftpMkSZIkSWpLu2PK7A58HHgcuTZpAj4L/BTYAXwBeCvwhs6EKUmSNL/GRkc21uqNlcCp5BYzTVvICZmNvYlMkqThV6s3ljHx2G1LK48PrdUb2yZ5iq2l5ZkkSVJfa7elzOuARwMvBA6m0s1HSmkb8ClywkaSJGlglMTLIZVFxwAHmZCRJGnerQIunGDaXNlm8yTbXFj2lyRJ6ntttZQBngK8M6X07oi45QTrLwae2H5Y04uIVwMjwGHADSmlfWewTwDrgOcB+5Iv6F6YUvrpvAUqSZIGzY7K4012WSZJUlesB86Yw/62kpEkSQOh3aTMbYDvT7F+O3DTNp97pnYnt8j5GvDPM9zn34CXAc8Cfklu8fP5iLhbaeEjSdOaomuFmbJrBUmSJKmiXB97jSxJkoZeu0mZS4G7TrH+COBnbT73jKSU1gBExHEz2b60kjkeeH1K6fSy7JnAb4HHk8fImWi/PYA9Kov2bjdmSUNjFbBmDvuvA9Z2JhRJkiRJkiRJg6LdpMxHgZdHxKeBn5RlCSAingc8CajPPbyOOgi4HfDF5oKU0p8j4hvAA5kkKQOcwNwKXyUNn8m6VljKeJ/XRwCTDkI6H0FJkiRJkiRJ6m/tJmXeADwA+Ap5/JgEvDUibgHsD5wJvLUjEXbO7crf37Ys/21l3UROBP6rMr83sKWDcUkaMJN1rVCrN/aszF40NjpybfeikvrGosrjFbV642zHZJEkSZIkScoWTb/JrlJKNwCPBJ4N/AK4hNzF1/eA44DHpJRmXQATEaMRkaaZpuo2reNSStenlK5qTsDV3fz/kiQNilq9cSy5skbTWcBYWS5JkiRJkrTgtdtShpRSAj5cpk45CXj/NNv8os3nvrz8vS0713C/LfDdNp9TkiTxt4TMhglWLQc21OqNlWOjIxu7HJYkSZIkSVJfaaulzHxJKV2RUrpkmumGNp/+l+TEzNHNBRFxM+D+wNc6EL4kSQtSrd5YDJxSZqNldXP+5LKdJEmSJEnSgjWjljIRcW4bz51SSkdPv1l7IuJA4BbAgcDiiDisrPpZSumass0lwAkppdNSSikiTgb+PSJ+Sk7SvA64DPjMfMUpSdICsII8ptxkAjigbHdeNwKSJEmSJEnqRzPtvmwRkGb53K01ZTvttcCzKvPfKX+PYrzA52Bgn8o2bwL2BN4N7AucDzwypbRtPgOVJGnILevwdpIkSZIkSUNpRkmZlNKR8xzHrKWUjgOOm2abaJlPwGvKJKkHavXGMuZWMLt1bHRk6/SbSeqimX4n/e5KkiRJkqQFbaYtZSSpU1YBa+aw/zpgbWdCkdQhm4AtwHImbimbyvpN3QxK0sIwRYWPpZXHh9bqjclax1vhQ5IkSVLXzCkpExGPBh4F1MqiMeDMlNL/zS0sSUNsPXDGBMuXApvL4yOASQtO5iMoqY8sqjxeUas3zh4bHdnes2hmYGx0ZHut3lgNbCAnYKqJmWb3p8f3+3FIGlgzqfCxeYp1VviQNGcmiCVJ0ky1lZSJiH2B04AHA9sZLyR9KLAqIjYBj08pXdmBGCUNkXKjscvNRq3e2LMye9HY6Mi13YtK6g+1euNY4NTKorOALbV6Y/XY6MjGHoU1I2OjIxtr9cZKcvzLK6u2kBMyfR2/pIE2WYWPmbIQVFInmCCWJEkz0m5LmVOAFcCrgHemlK4FiIg9gRcBJ5ZtntWJICVJGnYlIbNhglXLgQ21emNlvyc2SmLmbOCqsugYoO9b+kgabJNV+JCkLjNBLEmSZqTdpMzjgf9OKb2lurAkZ94cEQcCz5xjbJIkLQi1emMxuTID7DomS5C7ADu5Vm+cPgAJjh2Vx5sGIF5JkqQ5M0EsSZJmatH0m0zor8CPp1h/SdlGkiRNbwWwP7smZJoCOKBsJ0mSJEmSpAHVblLm08ATI2Jx64qIWAI8CfjUXAKTJGkBmWhQ2LlsJ0mSJEmSpD7UbvdlHwbeDnw1It4N/KwsvzPwfGB34CMRce/qTimlb7cbqCRJQ2ymXV3YJYYkqe/U6o1lTFxxYGnl8aG1emPbJE+xtXT9JEmSJA29dpMyX648vi+5r3vYuduV6jbN/vB3aVkjSZLYBGwBljNxF2aprN/UzaAkSZqhVcCaabbZPMW6dcDajkUjSZIk9bF2kzLP7mgUkiQtYGOjI9tr9cZqYAM5AVNNzDQrPhw/NjqyvevBSZI0vfXAGXPY31YykiRJWjDaSsqklD7Q6UAkSVrIxkZHNtbqjZXAqeQWM01byAmZjb2JTJo/dnkkDYfyPfS7KEmSJM1Auy1lJElSh5XEzNnAVWXRMcDZtpDRELPLI0mSJEnSgtJ2UiYilgL/CNwb2AdY1LJJSin98xxikyRpIdpRebzJhIyGnF0eSZIkSZIWlLaSMhFxe+BLQA24kpyU+SOwL7AY+D1wTScClCRJ0nCyyyNJkiRJ0kLT2rplpt5MTsQ8ALgLeUDiJwN7Aa8C/gI8ohMBSpIkSZIkSZIkDYN2kzIPAf47pXQB492sRErp+pTSm4FzgJM7EJ8kSZIkSZIkSdJQaDcpc1NgrDy+CkjkljNNXwP+vv2wJEmSJEmSJEmShku7SZlfA/sDpJRuBH5D7sqs6W7AtrmFJknSrFV/11bU6o3FPYtEkiRJkiRJatFuUuZc4HGV+fcD/xIR74mI9wIvBj47x9gkSZqxWr1xLHBxZdFZwFhZLkmSJEmSJPVcu0mZUeANEbFHmf9P4APASnKy5qPAy+ceniRJ0yuJlw3Afi2rlgMbTMxIkiRJkiSpH7SVlEkp/Tql9OmU0vVlfltK6bkppZunlG6VUjoupXRVZ0OVJGlXpYuyU8pstKxuzp9sV2aSJEmSJEnqtXZbykiS1C9WkMc5a03INAVwQNlOkiRJkiRJ6pkl7e4YETcHngLcAbg5uxaGpZTSP88hNkmSZmJZh7eTJEmSJLWhVm8sY+J7r6WVx4fW6o1tkzzF1rHRka2dj0yS+kdbSZmIeAS57/49gauAP02wWZpDXOpDU/ywzpQ/rJLmw0zPK55/JEmSJGl+rQLWTLPN5inWrQPWdiwaSepD7baUOQm4HDg2pfT9Dsaj/jaTH9ap+MMqaT5sArYAy5m4C7NU1m/qZlCSJEmStACtB86Yw/5WppM09NpNytwJeKUJmQVnsh/WpYzXcjgCmLQJ6nwEJWlhGxsd2V6rN1aTW3Amdk7MNFttHj82OrK968FJkiRJ0gJSekix/EeSptBuUuanwN6dDET9b7If1lq9sWdl9qKx0ZFruxeVJMHY6MjGWr2xEjiV3GKmaQs5IbOxN5FJkiRJkiRJ4xa1ud+/Ay+KiFoHY5EkqW0l8XJIZdExwEEmZCRJkiRJktQvZtRSJiJOnWDxFcDFEXE2cCnQ2i1MSimtnmN8kiTNxo7K4012WaZhVqs3lgHLJli1tPL40Fq9MWm3oqUVrCRJkiRJ6pKZdl/2kinWPXqS5QkwKSNJkjQ/VgFrptlm8xTr1gFrOxaNJEmSJEma1oySMimldrs5kyRJ0vxYD5wxh/1tJSNJkiRJUpfNtKWMJEmS+kjpeszEiiRJkiRJA6QjSZmIuCvwRHK/5j8G3pdSuqoTzy1JkiRJkiRJkjQMZpyUiYiXAC8DHpRS+n1l+WOATwG7VzZ/aUQ8oLqdJEmSJEmSJEnSQjabsWIeC/y8JSGzBPgfYDvwbOCeQB24PfDqDsYpSZIkSZIkSZI00GaTlLkb8PWWZUcBtwbemlL6QErphymlNwGfBB7VoRglSZIkSZIkSZIG3mySMrcELm1ZdjSQgNNalm8GDpxDXJIkSZIkSZIkSUNlxmPKAL8FbteybAVwHXBRy/IbyiRJkiQNrVq9sQxYNsGqpZXHh9bqjW2TPMXWsdGRrZ2PTJIkSZLUj2aTlPkW8KyIeFtK6eqIuDtwP+D0lNKNLdveFdjSqSAlSZKkPrUKWDPNNpunWLcOWNuxaCRJkiRJfW02SZl1wDeBn0bED4HDyV2XnTjBtk8Azp17eJIkSVJfWw+cMYf9bSUjSZIkSQvIjJMyKaXvR8RDgFcDdwC+DrwlpXRhdbuIOJLcpdmnOhemJEmS1H9K12MmViRJkiRJM7JoNhunlL6aUhpJKR2SUnpkSumLE2xzXkrpnimlL3QuTElSF1R/E1bU6o3FPYtEkiRJkiRJGkKzSspIkoZTrd44Fri4sugsYKwslyRJkiRJktQBJmUkaYEriZcNwH4tq5YDG0zMSJIkSZIkSZ1hUkaSFrDSRdkpZTZaVjfnT7YrM0mSJEmSJGnuTMpI0sK2AtifXRMyTQEcULaTJEmSJEmSNAcmZSRpYVvW4e0kSZIkSZIkTcKkjCQtbFs7vJ0kSZIkSZKkSZiUkaSFbROwBUiTrE/ApWU7SZIkSZIkSXNgUkaSFrCx0ZHtwOoy25qYac4fX7aTJEmSJEmSNAcmZSSpc6rn1BW1emNxzyKZhbHRkY3ASuCyllVbgJVlvSRJkiRJkqQ5MikjSR1QqzeOBS6uLDoLGCvL+15JvBxSWXQMcJAJGUmSJEmSJKlzBjYpExGvjoivRsR1EXHlDLbfLSLeGBHfj4hrI+KyiPhgROzXhXAlDbGSeNkAtJ5PlgMbBiUxA+yoPN5kl2WSJEmSJElSZw1sUgbYHfgU8M4Zbn9T4N7A68rfY4GDgTPmJTpJC0LpouyUMhstq5vzJw9KV2aSJEmSJEmS5s+SXgfQrpTSGoCIOG6G2/8ZeFh1WUS8BLggIg5MKf2640FKWghWAPtPsT6AA8p253UjIEmSJEmSJEn9aWCTMh2yD5CAKyfbICL2APaoLNp7nmOSNFiWdXg7SZIkSZIkSUNqkLsvm5OIWAq8EfhYSumqKTY9AfhzZdrShfAkDY6tHd5OkiRJkiRJ0pDqq6RMRIxGRJpmumsH/s9uwCfJ3Qq9cJrNTyS3qGlOU3VTJGnh2URO1qZJ1ifg0rKdJEmSJEmSpAWsr5IywEnAIdNMv5jLP6gkZG4PPGyaVjKklK5PKV3VnICr5/L/JQ2XsdGR7cDqMtuamGnOH1+2kyRJkiRJkrSA9dWYMimlK4Ar5uv5KwmZOwNHpZT+MF//S9LCMTY6srFWb6wETgWWV1ZtISdkNvYmMkmSJM1Erd5YxsRjAC6tPD60Vm9sm+Qpto6NjthdrSRJkqbVby1lZiwiDoyIw4ADgcURcViZ9qpsc0lEPKE83g3YANwHeFrZ53Zl2r0HhyBpZ9Xz0YpavbG4Z5G0oSReDqksOgY4yISMJEnSQFgFXDjBtLmyzeZJtrmw7C9JkiRNq69ayszSa4FnVea/U/4eBZxXHh9MHgcGcu31x5bH3215ruo+krqsVm8cS25l0nQWsKVWb6wesKTGjsrjTXZZJkmSNDDWA2fMYX9byUiSJGlGBjYpk1I6Djhumm2i8ngMiMm3ltQLJSGzYYJVy4ENtXpj5YAlZiRJkjRgStdjJlYkSZI07wa2+zJJg690UXZKmW1NmjbnTx60rswkSZIkSZIkaSImZaThMYhjsqwA9mfyVmwBHFC2kyRJkiRJkqSBZlJGGgKlC7CLK4vOAsbK8n62rMPbSZIkSZIkSVLfMikjDbjKmCz7taxqjsnSz4mZmfbbbf/ekiRJkiRJkgaeSRlpgA3BmCybgC1AmmR9Ai4t20mSJEmSJEnSQFvS6wAkzUlzTJbJVMdkOa8bAc3G2OjI9lq9sZrc0iexc2Kpmag5fmx0ZHvXg5PmWa3eWMbEXfMtrTw+tFZvbJvkKbaOjY7YikySJEmSJGmAmJSRBtvAj8kyNjqysVZvrAROJXe51rSFnJDZ2JvIpHm3ClgzzTabp1i3DljbsWhmyaSSJEmSJEnS7JmUkQbbUIzJUhIzZwNXlUXHAGfbQkZDbj1wxhz27/X3eqCTSpIkSZIkSb1gUkYabM0xWZaz65gykLsA28JgjMmyo/J4kwkZDbvSSqTXiZW5GPSkkiRJkiRJUteZlJEGmGOySOqVIUgqSZIkSZIkdd2iXgcgaW7KmCsrgctaVm0BVjomiyRJkiRJkiT1B5My0hAoiZdDKouOAQ4yISNJkiRJkiRJ/cOkjDQ8HJNFkiRJkiRJkvqYSRl1QvVztKJWbyzuWSTtG4ZjkCRJkiRJkiT1MZMympNavXEscHFl0VnAWFk+EIbhGCRJkiRJkiRJ/c+kjNpWkhYbgP1aVi0HNgxCUmMYjkGSJEmSJEmSNBhMyqgtpXuvU8pstKxuzp/cz92ADcMxSJIkSZIkSZIGh0kZtWsFsD+7JjOaAjigbNevhuEYJEmSJEmSJEkDwqSM2rWsw9v1wjAcgyRJkiRJkiRpQJiUUbu2dni7XhiGY5AkSZIkSZIkDQiTMmrXJmALkCZZn4BLy3b9ahiOQZIkSZIkSZI0IEzKqC1joyPbgdVltjWp0Zw/vmzXl4bhGCRJkiRJkiRJg8OkjNo2NjqyEVgJXNayaguwsqzva8NwDJIkSZIkSZKkwWBSRnNSkhaHVBYdAxw0SMmMYTgGSZIkSZIkSVL/MymjTthRebxpQLv7GoZjkCRJkiRJkiT1MZMykiRJkiRJkiRJXWBSRpIkSZIkSZIkqQtMykiSJEmSJEmSJHWBSRlJkiRJkiRJkqQuMCkjSZIkSZIkSZLUBSZlJEmSJEmSJEmSusCkjCRJkiRJkiRJUheYlJEkSZIkSZIkSeoCkzKSJEmSJEmSJEldYFJGkiRJkiRJkiSpC5b0OgBJkmarVm8sA5ZNsGpp5fGhtXpj2yRPsXVsdGRr5yOTJEmSJEmSJmdSRpI0iFYBa6bZZvMU69YBazsWjSRJkiRJkjQDJmUkSYNoPXDGHPa3lYwkSZIkSZK6zqSMJGnglK7HTKxIkiRJkiRpoCzqdQCSJEmSJEmSJEkLgUkZSZIkSZIkSZKkLjApI0mSJEmSJEmS1AUmZSRJkiRJkiRJkrrApIwkSZIkSZIkSVIXmJSRJEmSJEmSJEnqApMykiRJkiRJkiRJXWBSRpIkSZIkSZIkqQtMykiSJEmSJEmSJHWBSRlJkiRJkiRJkqQuMCkjSZIkSZIkSZLUBSZlJEmSJEmSJEmSusCkjCRJkiRJkiRJUheYlJEkSZIkSZIkSeqCgU3KRMSrI+KrEXFdRFzZxv7viogUEcd3PjpJkiRJkiRJkqSdDWxSBtgd+BTwztnuGBFPAB4AXNbpoCRJkiRJkiRJkiaypNcBtCultAYgIo6bzX4RsRx4G/AIoNH5yCQNu1q9sQxYNsGqpZXHh9bqjW2TPMXWsdGRrZ2PTJIkSZIkSVI/G9ikTDsiYhHwIeDNKaUfRsRM9tkD2KOyaO95Ck/S4FgFrJlmm81TrFsHrO1YNJIkSZIkSZIGwoJKygCvAm4ETp3FPicwfeGrpIVlPXDGHPa3lYwkSZIkSZK0APVVUiYiRsmJk6kcklK6pI3nPhxYDdw7pZRmseuJwH9V5vcGtsz2/0saHqXrMRMrkiRJkiRJkmalr5IywEnA+6fZ5hdtPvcK4DbAryvdli0GToqI41NKtYl2SildD1zfnJ9Jl2eSJEmSJEmSJEmt+iopk1K6Arhinp7+Q8AXW5Z9vix/3zz9T0mSJEmSJEmSJKDPkjKzEREHArcADgQWR8RhZdXPUkrXlG0uAU5IKZ2WUvoD8IeW5/grcHlK6cfdi1ySeqtWbywDlk2wamnl8aG1emPbJE+xtXThJkmSJEmSJGkWBjYpA7wWeFZl/jvl71HAeeXxwcA+XYxJkgbBKmDNNNtsnmLdOmBtx6KRJEmSJEmSFoiBTcqklI4DjptmmykHgJlsHBlJGnLrgTPmsL+tZCRJkiRJkqQ2DGxSRpLUntL1mIkVSZIkSZIkqcsW9ToASZIkSZIkSZKkhcCWMpK6ykHmJUmSJEmSJC1UJmUkdZuDzEuSJEmSJElakEzKSOo2B5mXJEmSJEmStCCZlJHUVQ4yL0mSJEmSJGmhWtTrACRJkiRJkiRJkhYCkzKSJEmSJEmSJEldYFJGkiRJkiRJkiSpC0zKSJIkSZIkSZIkdYFJGUmSJEmSJEmSpC5Y0usANDhq9cYyYNkEq5ZWHh9aqze2TfIUW8dGR7Z2PjJJkiRJkiRJkvqfSRnNxipgzTTbbJ5i3TpgbceikSRJkiRJkiRpgJiU0WysB86Yw/62kpEkSZIkSZIkLVgmZTRjpesxEyuSJEmSJEmSJLVhUa8DkCRJkiRJkiRJWghMykiSJEmSJEmSJHWBSRlJkiRJkiRJkqQuMCkjSZIkSZIkSZLUBSZlJEmSJEmSJEmSusCkjCRJkiRJkiRJUheYlJEkSZIkSZIkSeoCkzKSJEmSJEmSJEldYFJGkiRJkiRJkiSpC0zKSJIkSZIkSZIkdYFJGUmSJEmSJEmSpC4wKSNJkiRJkiRJktQFJmUkSZIkSZIkSZK6wKSMJEmSJEmSJElSF5iUkSRJkiRJkiRJ6gKTMpIkSZIkSZIkSV1gUkaSJEmSJEmSJKkLTMpIkiRJkiRJkiR1gUkZSZIkSZIkSZKkLjApI0mSJEmSJEmS1AUmZSRJkiRJkiRJkrrApIwkSZIkSZIkSVIXmJSRJEmSJEmSJEnqApMykiRJkiRJkiRJXWBSRpIkSZIkSZIkqQtMykiSJEmSJEmSJHWBSRlJkiRJkiRJkqQuMCkjSZIkSZIkSZLUBSZlJEmSJEmSJEmSusCkjCRJkiRJkiRJUheYlJEkSZIkSZIkSeoCkzKSJEmSJEmSJEldYFJGkiRJkiRJkiSpC0zKSJIkSZIkSZIkdYFJGUmSJEmSJEmSpC4wKSNJkiRJkiRJktQFJmUkSZIkSZIkSZK6wKSMJEmSJEmSJElSFwxsUiYiXh0RX42I6yLiylnsd0hEnBERf46IayPimxFx4DyGKkmSJEmSJEmSNLhJGWB34FPAO2e6Q0TcETgfuAQ4ErgX8Dpg2zzEJ0mSJEmSJEmS9DdLeh1Au1JKawAi4rhZ7PYG4MyU0r9Vlv28k3FJkiRJkiRJkiRNZGCTMrMVEYuAEeBNEfF54O+AXwInppQ+M8V+ewB7VBbtPZ9xStOp1RvLgGUTrFpaeXxord6YrAXY1rHRka2dj0ySJEmSJEmSNJUFk5QBbgPsBdSBfwdeBTwS2BgRR6WUvjzJficAa7oTojQjq5j+M7l5inXrgLUdi0aSJEmSJEmSNCN9lZSJiFFysmQqh6SULmnj6Zvj55yeUnprefzdiHgQ8AJgsqTMicB/Veb3Bra08f+lTlkPnDGH/W0lI0mSJEmSJEk90FdJGeAk4P3TbPOLNp/798CNwI9all8M/P1kO6WUrgeub85HRJv/XuqM0vWYiRVJkiRJkiRJGjB9lZRJKV0BXDFPz31DRHwTOLhl1V2AX83H/5QkSZIkSZIkSWrqq6TMbETEgcAtgAOBxRFxWFn1s5TSNWWbS4ATUkqnlXVvBj4REV8BvkQeU+YxwJFdDF2SJEmSJEmSJC1AA5uUAV4LPKsy/53y9yjgvPL4YGCf5gYppdMi4gXACcCpwI+Bf0wpnT/v0UqSpL5SqzeWAcsmWLW08vjQWr2xbZKn2Fq6lJQkSZIkSZqRgU3KpJSOA46bZptdBoBJKf0v8L/zE5UkSRogq4A102yzeYp164C1HYtGkiRJkiQNvYFNykjtsFa0JKliPXDGHPb390CSJEmSJM2KSRktNNaKliQBUJLsJlYkSZIkSVLXmJTRQmOtaEmSJEmSJElST0RKqdcxDJSIuBnwZ2CflNJVvY5HkiRJkiRJkiT1zmzyBou6E5IkSZIkSZIkSdLCZlJGkiRJkiRJkiSpC0zKSJIkSZIkSZIkdYFJGUmSJEmSJEmSpC4wKSNJkiRJkiRJktQFJmUkSZIkSZIkSZK6wKSMJEmSJEmSJElSF5iUkSRJkiRJkiRJ6gKTMpIkSZIkSZIkSV1gUkaSJEmSJEmSJKkLTMpIkiRJkiRJkiR1gUkZSZIkSZIkSZKkLjApI0mSJEmSJEmS1AUmZSRJkiRJkiRJkrrApIwkSZIkSZIkSVIXmJSRJEmSJEmSJEnqApMykiRJkiRJkiRJXbCk1wEMsL0jotcxSJIkSZIkSZKk3tp7phualJm95ou7padRSJIkSZIkSZKkfrI3cNVUG0RKqUuxDIfIzWP2A67udSx9Zm9yomp/Bve18Rh6b9Djh8E/hkGPHzyGfjDo8cPgH8Ogxw8eQz8Y9Phh8I9h0OMHj6EfDHr8MPjHMOjxw+Afw6DHDx5DPxj0+GHwj2HQ4wePYdjtDVyWpkm62FJmlsoL+ptex9FvKl25XZ1SmjIT2K88ht4b9Phh8I9h0OMHj6EfDHr8MPjHMOjxg8fQDwY9fhj8Yxj0+MFj6AeDHj8M/jEMevww+Mcw6PGDx9APBj1+GPxjGPT4wWNYAGb0eiya7ygkSZIkSZIkSZJkUkaSJEmSJEmSJKkrTMqoU64H1pW/g8pj6L1Bjx8G/xgGPX7wGPrBoMcPg38Mgx4/eAz9YNDjh8E/hkGPHzyGfjDo8cPgH8Ogxw+DfwyDHj94DP1g0OOHwT+GQY8fPAYBMc2YM5IkSZIkSZIkSeoAW8pIkiRJkiRJkiR1gUkZSZIkSZIkSZKkLjApI0mSJEmSJEmS1AUmZSRJkiRJktRVEbEoIqLXcUiS1G0mZTSQvHCTNFcR4W/ggIqIgyPiwF7HocHldYQkSb0TEXtExP1TSjtSSsnrcknSQuMPnwZGSwHKcRFxx54FM4mIOKDXMWh+RMSS8vfBEfHkiNij1zGpPRGxD0BKaUevY1HbGsB55bu4T6+DWYgGLanRLOyJiLsDpJRSbyPqjAF8H5q/pXv2OpZBFBH79jqGXqp8j+/Q61hmY9C+p1KXvAz4WkR8LCJu07wuj4jF3fjnEbF42BNBEbFvROzW6zg6YRjPo8N4TMNg2M8L6i9+2DRwIuLfgdcCt+t1LFUR8RLgDb2OQ/MjpXRjefh+YAVw895Fo9mqFOTcEXhDRHw0Im7W47BmzYv3v92svwS4GPgo8OGI+PuIuElvI5vcMF7cN5MaEXH/iLhXr+OZSkQsSintiIhbA1+OiH8Z9EKKiLhrROw3KMml5rkrpXRjROwFvDkiDulxWG1rFhp2M7kUEU8E/hARq5rJrYWk8j1eDnwgIo7tVuHtbFWuOfaIiAMG5XvarsrxLvhrFM3KOcCJwIOB30TEawFSStuhK5+nNcDxEXH7ef4/vfQl4OGD+N2sxhwRew7LebR6XMNyTDPRz/dCzfckIg6IiMVW3FQ39e0XQ6qKiKg0a74zuZb093scVquVwMH9etHjDdPclYLH7cCZKaXLO/B8A3MOjojbR8QREXFURNyuFG4OjMrF1X8BjwC+llK6qnW7fv9+LKSL98mklLanlD4HPAP4Z2B/4PPAf0TE3fqlkK7l+70kIm5evju79yyoDqm0dng08E7g1ZVC6qj+7QeV7/8LgMuBzSmlv/YwpLZUXvcHAe8G3hYRS8uyvnvdm0oC7MERcXhZ9N/AMcDA3vSmlLZHxE2B90XEP0XELbrwb7cCnwVOJtcuf1gX/mffqHyP1wK3BH7aLLztN5VY3w6M9jKWbmgeb7evUSJiWdhyfVKVe7/dI2Kvcg2ytNdxNaWUvk2u0PhM4IPAyyPi0oh4TFmfYp7Gm4ncyvqfgLcAp0bE47t0Hu+akuS6K3DVZN/NQbgXjYg1wEd6HUenVCo1vTwiaj0OZ15FxP4Rcc+IuHW/JjpKEiZFboH7XuCsiNi7rOu7a2oNn74/CUtF84R4P2AJsHtK6ao+qyn4f8C9yAWEfaX8oKSIWGKh7uxUbmhuCtwKuAb4Q1nW1uevuV+/XpxURcRhEXEy8EPgy+RabRcC/x0Rx0XELXsZ30xU3sMXk2vjnZRSeltZtqSy3W791qd1paD7yRHxz72Op5+klP5IvklbBfwMqAOfBl4cET1vSVnphuOFwFeAXwNfAP4nIh7ey9jmolSSaLYcPBUYA06sFI5G87vUnOlBmH/Tcp7+PvCrlNIFZd1A3WxVXvf/Bq4HTkkpbSvrUvVvnzkYeBO5VduJwNOAN6aUfgyDUSg0iTuQK+S8BlgbuXvTeUu6ppTOJ5/vng3cAHw+Ij4cEXeer//ZL1qS7d8ENqWU+q1y1t+0nFseExF3m2D5QGop6D8iIv43It4VEWsi4v5djuOlwFFTbTMMr3m7KvcZrwUuAM4FPhMRz+pdVOPK9cR1KaVzyNcTnwCWA6dHxJcj4tDKeDMdrXCTUvozcE/yZ+gB5KTQ6yO3vO6bxFW7SuW5E4D/BL5bli2NiMMj4rER8azIrU+a16p99ztcuZ7ZH3hIRNwFBvs8Wjl/Pgx4I/CIfnzt21W5bz04Iv6bfH/2ZeDiiHhn9GEvFZX7l3cCNwP+J6V0dVnXs2vq1s/5IH/uNbWhOQFouJXuCu4GnA3ch1w4/rcCij75MfsSsAdwBPT2xFn5QbxNKcj9JnAe8O6I+KdexTWIKjc0byQn3mrk1lrNblimvUmovB93johXAB+LiPMi4kURsWx+Ip+7iLgV8D/Akyg12IDXkT9LI8C7gDdFxKFl+768WCjnj92A1eTj+GRl3Y0RsU9EvAb4ekR8HHhRlK4MenFM1f9ZuVBcR755bDsZOEwq37t/I38Of0f+ffg9uTXUZyLXeuzJeDMx3qLh+eRaoH8FXgn8FHg6cP8Bvulvtsiok3/zTk4pfbcsuwu5ltl3I+LtEXHLXicJKtcJZwGvBpZFxG1LYVA/JjAmVLmRfyG50OotKaWvlGW3i4jXR8QXIuKV/fTZilwD8QfAfwB/If+O/BFY3Lw5L+foaJ77+vW3BHb6PV8GHEAu6DyQ3KXi+4B/bRbAd/j/Nrt/+21K6ePAc8nnuqeSf7te06vzXTdUujP6EPBCynVYKXTvi9aRVZVzyzvK3ydVl1c/7wPsP8kttx5JrvDyL0Ajcku+v5mv4yzX57uTf1N3Uj4XN2kW6M/H/+93lXPVS8nXSr8hV6q6NfCWiNgUEQ/tYYgAzRiPJLdYeShwErn1852B70TEeyNi78o5oGP3/Cml61NK7wAOJXdP/VzgQ+QWO3fv1P/pkXcAPwY+mVK6OnLN/w+QywQ+Q/69ujwiXgV9X1FwlFwR5TjYuaA8BqwnkMrr/HByha0zm9dAPQyrYyr3rR8EHkX+Xr+C3OX0KnIF675R+fw8BngQuSXyp8uym0XEyyLig6XMpiu9hFSu91LkLlDvERF3mI/ktPpESsnJaSAm8hgyG4E/kbu8+AxwaGV9ANGj2BYBe5G7RXn3ZNv0IK7PlNfrPOC08vgPwP17/X4O2kTuJukr5IvCG4AXt6xfPNX7DuwN/KC8B98u78kOcq2wfSrb9+QzPEnsnywxP6pl+R7kG5gN5Rg2Anv2Ot5pjuVo4DLgqdXXGbg7+eZvR3lvLiMXoL+tD2JeVHn8TnKXa331Genl6wL8Hbk7wROApWXZfsCx5JvOG4D15BuAPXoQ55Lym/BOYHlZ9uzyObtv81jIrQi6/vswx2PbrXzvzwFuWpYdA2wCriMnyK4GvgjctNef2fK5+GL5fu8AXt88Z/c6tlkex6LyW/4l4FZl2QOB08tx/aB8Jz5R3qNev+63bpl/bInzauBachdsD2l+f8s2S8p3++G9jn+aY/sc8D3yQNUrgIeVz9gO4HzyNcMBHf6fzc/sPuRusX4KfIvcrdkNwC/J3ToO1PlkFsd/KPBbYEs5j/5TZd2ifjnu1jiAU8pvwS6fh37+jE91bOQKcn8lVxi5TVn27fIduH2Z32u+j4+cELocuGOZvze5EtVm4CJyAdshle0nvFYf1qmcT39IboWyb1l2CLmCwnfI94Qfbr5+PYzzR+W37dDm+1TOq+8q59SrgBd1+H827wMWV5Ydzvg9wTfI12wdPY936fW8XzmG11DuMYGPlfPmyWX9i8lJ1R3k+72b9TruSd6f5t9TydeXd+l1bHM4piXl7wHAU4CNvY6pw8fX/H14evnOPq6y7ifkRGDz2vWuvT7vtMT+YfK94x3K/MHkSmY7yD0C7CC3oOnm6/hUcuvGP5Kv7b8CPAvYq9ev1zwc80BdC3X8+HsdgJPTbCdyFvvz5WbgInLt49tU1nftpoxKQUKZ/1S5+J20gJp8k/JYSqHcPMTUvGl/ErlW6nMqJ/efkLv7ad5A3YZSoOY0o9f2VuQukn5SLgw/Bzyksn5R649K5bV/P7kA5dFl/n7kQpRXATcpy5b0+hgrcd8L+DPwPEqBNrBbyzZ7kS/4d5Tj262b379ZHs9hJc5jKsv+jlx4vI1cSHv3ctwfK9s+rQdxrgMeOsHn50nkgofb9fq17JeJXJvycuCeLcsXkW+sf1Lexx3AS3sQ32PKhfyjyvxtyTcpr2M8ifToch5Z1uvXc5bHFuSblSvIYzvci1xQegHwgLLNm8hJkFv1Ot4Sz0HA88kJjR3khNJh1WPqdYwzPI73A78uj29Dvua4GHgCudb4yeRC+n17HOdLyuv89DK/iNzC56nAnUqc28nd+q1hvDBuP3Jh2Dt6/VpPcEzNwqGHlNifOcE2Tya33PsduVbyI2i5VuzA/99A7o7maWX+TsATy7lkB3ncxaGsfFPO7e8kX5/sILfmPaiyvmeF7q3nEHLB263JLUhuIA9o/ugy/2rgzeU92+Vz1O8TuTXBV4E7l/kjy/txLOVasZwDnjjPcexeXtdl5JYVvy6fja+SE5Z/LtOaXr9mXX5/mteOi4C3AS+YYJsHkZO7PyMX1v+/HsV6//L9+Ndq7OXxvuSa9s1rucuY430rsHfzszPFNo8pn5+/ls/6Y+mTa5kZHuM/l9frV+TWP48vx/JMdq4EUSNfU+ygcj/bT1P5DOxGHv/ncvJ988PLueYFwPHlPXpKr2Od4fEsJd933ki+Rzi8LB+Ia9AZHuM7ga9REprkljLXAPepbPNecle8Hbk+6kDMp5K7N27+rpxX3p+XA3uS792uAfab5zia5Xh/V/7fl0oMze90o9/PRRN9lif7fNNStrRQp54H4OTU7kRONlxMrnF5dvmx7uoXm5y9fiXjWf+nlxPmvSrb3JbcHPv/MZ7t3gHcY55j+wxwJrB/mX8+uZXHEYzf2L8JeEav38t+nab4ATm0XHBsIRe8vBu40xTPs5x8o/hqSk0kck3miyoXLDcrn4/Den3cJZ7nAZcCR0yz3a3K5+wPQK3XcU8R5wHkpNgmcnPqO5JrUu4gX+DvUdn2weSblxd3OcZ7kC/Um60rqgVNf0dOsj5ygv0WAfel0nJwIUzkfsD/dr4tF9FRWf9kcpLgZODePYjv78s598Fl/n3lM1h9X/8fcAlwt16/nm0c35HkG5bryAXUX20ea1n/cnJhzyG9inGSuO9NTib/qnx+3gHcstdxTRFv8wbt5sBNyIW6vy/niT+Wz89jKtu/orzud+9x3E8v59h/KPN3nmCbezGeSPgmuZD6E+TCioO6FWsbx/YCckufh5T5YOeCxJeTCxlvKO9Tx66zym/X1eQxIlorStyFXDi1o/yGncaQVLyhJdlSfsc/W74DPy2/4z0t3GG8IPwE4Epyd1HXlb/NQuUryUmCP5BbNv2Ucp0+KBO59cUHgS9Wln2vfN72LfP7lmVvYYrC7w7Fc2D5e0Y5jzS/l7cht2D7QHntT6PSMn3Yp3KuuLB8/k6ovHe7VbbZjVxgfw49Sg6Su3/cBrymsmxxyzn1h8B7gOfO8X81k/6fBT5afm9Gy+f0eeSE6cPL+eUIxluhjjVfw0GYyIXIDyqf+RvLMZxJab3Kzq2D9i6/VW/pddwlnuZ59CnkylU/L5/h6nm0ef22rZxLfwfcr9exz/D4bg2sJRe230iuaHzXyvqBT86Qy5d+Ufl8XUnuyrlZyXP/cs75X/qk9SI5EXsD+Zr6J+Uz9azK+heRy0XmpVL1BPGcQy4XuluZP6rE9yTGKz709Dp/BsfwOCotDdm1FXGQu5ZfQ58nmub9tep1AE5Ok01Umq2Sa+LedYJt9ion+cvINZA/RJdaG5SLyC+TC90uIF/UHkq+Qfw4ueb9hZULiO3kQYY/TKk52sFYqhdXQb6Y3UC5YSJ3H/NbcuFks1XGAeTm4if2yw9iv0zsXLB7K3JT0acC/0ilFRS5Buzp5EKXayitYCZ4vtuVC8jnlfkjy2fiSYxffD6yXARM+BzdPnZygdqNlOThVN8rcuHzDvo4wVe+F69gvLCqeTH/1so2zfdiBbmm+b/2IM4nlM/ULgVN5L6h31ge35t8w/J+csHODioFswthIifPbiQXuFS/s82L/ieTu+eYNGE6z/Hdufw2vbycb28k13RqxncguQuw83r9Ws7yuJrniN3L53VdmW5e2eZg8g3FOb2MsTy+CblyxD0qy5aW8/D6cu7+LT2qJTyLY/o0uaus/ck1X99DTvTdsfKe1MiFMF/vdbwlnmaFlX3IN7gNKpVWKts9jlzotoNcAPOKXsc+zXE9iHxN9/+anzfydVfzfbgrOdl0j/Id30HpaotZFrjQ0jUvuVDxT8CJZX4JO18D7kW+9mwAH+n1azXH17l63FGmZZVlS8kJsm+QEx2bKYUos32d5xDjfal001fej4+Su9BaRy7o/Sdyt3KXkrsyu3k5/y+hT2oJt3HcJwE/LI+fT04+PbCy/v7kikfzWpDd8p37PfDvtFyvkn9/316+hz29xu7ye3QcuTXr78n3IA+qrFtSfZ2o/H53Kbbm+7aoxHJGOa+NtH53yRXbNlO6H57j/222hN9Brth5DrlQ/4pyTr+Gne8T/lB5vLLX72kbx7sPuRXlF2gpAK+8B8vJ9xHvoI96Oyjv1QZyC4bXklvevaS8R58mX/vck5wAHrTW5kvI984nlc/eteRx96oVBPs+OVM+O7t8Zsgty/5ITiS8h3xdV6usfwT5/uif++AYmhWfbkLurvC0cl74e8a7m7stuSvFS7oUU418z/8flEoN5O5BP9s8VzOezH5cr1/DSY7hgYwPN/FkSvljWdcsb1lePv87aOn1YqFNPQ/AyWmiiZ37zX4judbnZeSb9ifRUuuKfDH+BeCVXY7zQHJT4G+Wi7nTGB/z5jpyzeE3kwtP70JpMj1frxk738C+CfhBeXwiuYZJtV/lhwG/YI61joZxqnz+VjHeBdI2csHdd6o/HORaZi8it8CY8KamXDD+EnhPmf82+QbklmV+d+BfyTWx+qJWOfnGaMdU36nKj+o9ybVgjut13DM4rnuRC0XeUC64muNhNGudLCUXol/HBDW75/szVx7vQS5ouoBc0PR1cuH3aPmMXM7Oid530eFE76BM5IGGbwDOAh5eWX5LcmJ8Cz3sxoncIuMGcoH0N1rWvYyc1D+m9TPQbxM711hdSqmZPMm2tya39LqaHrRQKjFUk8vnkitt/I78W/2wyna3AFaSuyn4Za9f5ymO54jyfT9uovekzN+0nNeupdIFYg9ivUWZqtcjNXI3Uz8i/46eNNH3kpzsuH2vX+/pPlvkmp+fL6/1kyfY5uHk66t/ICdRfgZ8YZb/ZxGV7irLfJBrQF9YnvPgyvrmjftNy+f8ZQxogf8Er8UTyDf2l5ELZ99H6SaxrF9O7lrkd3QxIUlOyOwo57spxy0r34mvkRNIzcR83xSAzuKYm9fHDy3H3uzGci3j11O3Iv82X8l4YnZej7V8z65kvEXIInZtXXUF8L+9fg27/H49gFx55zry9eRJLeeVrnc7XPkM3Yt8XXtbcsuUq8j3XC+mcv1NTipcOdG5dpb/dxG5dfJ3ydfSF5BbngY5mb28/AbdjXxd8FDy/cBxwMt7/V7O8bjvwPi4S63XDv9A/l1e3etYJ/qctCzbndw7yuZex9eJYyKXDzyWPKbPjeTrhif1Os4ZHssjyNdALwVu27LuVuTu/5plYv/CeKXgw8i/5z/rYeyzrRzz0nJ+ek6X4tudnEhvdun4PHI51BGVbUbI40j25eelnHfWkhNyvyYn546cYLtD6PB4YYM49TwAJ6eJJsYLVD5KrqWygVz76fxycv8SlW5SehBftSbDbuUC7j/ITR53kG+8Ju3Pe7Y/BlM8z1HkAqf9K8uaN+YPIBf4bSo/9M9k59q0H6T0S++002vaTDQcUC42PkYe/+WW5FpV36IMMsjO/fJOOdA9uZu735FbSl0L/H1l3X3I3Tx8otfHXz0ecgLqCuDoCdZXC9weTU4U9OWFQfN9ZeeC5QlvQoGjybVT3tvF2PYmF97fhZ2TMweQCzZ+Rr5h+kO5KPw38sXwQHV5Mk+v3X7k2n1XltfoHHKNuvPLBezrehzf/uTuDX9bvktvIteYPp2cKP9Yr1/DGRxD85wY5BurC8g1by8iJ74Or25LLnz/OfAfPYq3WeDzD+QalZtL3K8vv8+fo6W7svLdO6g87ouxvVrOsf9AruRxSOW9aK1NfBL5Ju6UHsd9AXmw7wdQqUBTYn5U+Q3cSi58G6gbsZb35C7k66/mZ+p+5Io6Dyd3E7O1su0GcqWi5bP4X68nX7+tZNfxCx9dznlfJferX70WuTc5WT+whYjlOJo1VB9RfvuaLbvPKq/5enK3r9X35AhKdx50IcldPtMfBdaV+f2Av5voOMrjh5fYR3r9+s7yOCe7Xnox45VETiAn5O9IbpX/J+Dfu/he3Ixc4enn7Fxxakll/dfIlefmtTu1fphaf8fKeeLsct74EbmQsadJQfL12o8ZH5eo2bpqB/le61PkwttrgG934P/tV/7enXzd+IvyOX03A9iF7Bxfi+Z13R3I5QG/7XVMrfHBTj2mVM+jzYTwM6rH0q8TO9973qL8TuzDzmVJB5Bb0jfLub7JNOUKvZ7IZV+fJnet/TVyi+e9K+tvTe7J4Lpybh4tvw2/JleYe3ivYq/E+PDy/b+AXNnj+ZQynso2Lydfs36yi3EtLue+75DLiJqVmfYq629Gvh76NX3Y/TI7X5ctJydkfk9OIq2jUqHIqbxOvQ7Ayal1qlwoPKCc6F9SWXc2uYCy2c3F2+hyv+PkG/E3lou6aoHDXuTudE4mF7r/tJzc953HWFaVi9XrKd0ataz/J3KiaHu5AD2c3GfmmeQaU//U6/e7XydyweL3GO++60ByE/bnM96d1OPIhWXTXhCSC95PK5/b35CTZIeRLy7PLz+4fdX8mnwTd125KHjYJNssKxc0l/Y63hke06TvFTkhcz75prBr/fCX13kH8O5mjOx8Ef8A8k3TGLnF1YnAbSrr+6IQeZ5fo+bN2QHklln3p9L/LLmw91Plgu/P5ALfNd3+XJFbkdyMnceN2ZvcZ+655AKAbeTCgFcx3lqun1vJNJMcbyznqS+Rk8zNsUD+iZ2TiU8pvzM9HbyRfFN7OqXr03K+vg44pnJMU46Z1eP4m5+pZ5ITGWOMj0n2twKLMr8buWXEs5nHFrkziHl3cvciF5OvTU4iXzNVCx9uTi58+AK5e4vzJ/t96Yep9Tej5XW/D/k69LeMd3Wzndyi48llm2XklrHfmc25mtzH9mXlnP8udh6vaRG5de228hp+itxi94Xkwo8/0+XuiObx9b+YnNRq9qt+LPne4OjKd+TudLmrl9bPRVn2LXIh87OpJOAY795uN3JLmW/QhwUpMzjmUWBFZf7W5bzz1fL5v768N38A/qt6/PMQSzPZshvleohc4WF7ObeMNM+XZd0KckHg63v9Os7j+xMTPa4suxm5gPE75GuR8+lyt7eMX8vdopy3XsXO99K7k+9tLyrnvl+TK7Ps0oX5LP/vC8ktDKvX1keTC5X/QP59Xdfymdm9GvOwTeTEwAfJhaV9VR7AeOFztcLBYnK3X3uWc+gFze36dWr5Tr6WfG9yffksnkDLODjkLk9PBE7tdewzPL49y7n2/HLu/QC5gsqeZf0B5DGgzyvH/Rtyq6Ajexhz87fjiSWey0pMzXGKXsTOvWccX86bM65U00ZM1R6C7l0eP4Jcmfc35GvMauvgJ5d1b+j1Z2Cq15md7w3/vnwOdpArHL2IPiv36unr1esAnJwmm8hN4s9hvGZos4bZ48i14Zonzx10sdskxsel+C65gP6Alou825CbojZr832Z3FVYx2tmlR+LfyAXiv+lnKCfWVl/U+Bp5Gz7VYz3k/sDujyI+SBN5XX9FPCpyrIvkmtcN2/+di+fgf9g5xo8090UvYBcINvsfmoH8BXg2D447puVH/rHVpY9h9wP+g5yf8QPJheyLSXXkvkAuVDoKb2Of47Hfi9yIeImyiCxXfzfe5Rz2u3L/EvIF7l7t2z3JHJhw9XkmtCvoM9riHXo9WlerN6bXNDeLPy8gNxqqPqduxM5Qb5PF+NrFgzepHwfLinTWZRBzsv6/chjrdydncdF6NsbfsYLUG5ffmPWMt5FzbvIN5gHl/ndWvfrYdx3I18jrGa826cfk2u171P5rHyX/k7MLGbnsek+SKntO9HrTB8k98prfRC5YKFZ2PU8cm256g3ancgtoC8kFxCexjRdQPX4uJ5NrtxyGvDCyvI9yNdhzyRXynklO7ce+0dy7fSXtPE/DyD/7v6BXEj5Oio1usnjVp1GvmFvjnvwDfqsgG0Or/kKcoHEU8r87uXz9L+U30fyWI4bqfRX34M4mwU4I4xXGvs0OTl9s5Ztn13W9yzeWR5b8zfgVuUcuqOc+29Z2eZQcouuV5FbJR7GPHXRVs4v1Xuud5K7pG12jfNicsW4K8r58hXlO3kJ+TdhKCuxMH4dsns556wv54ankBPD1cTHnchda/8FeHWP4n06+f642T1PsGvXTrejQxWkyNcCO6iMe1SWLyZ3T3Y+OZl9IZX76GGeyAnub9LFCkxTxNK8zr9j+Z27rMT2X1Qq0lS2f0x5P/+u27G2eVz/j3yvfBb5vvosciWhZuH0HSv77EGPKzW1cZy3Iyc1d5ATqa9t/Y0r29yy9b3scpzV+8XLgI8wXuHjBeRygAeV+ervTFeuTcllT2+rzD+ZfA20g3ydcyLjXYae3+v3vSX25m9QjZ2v9Xdred3/q7zOl7HAuhOd8vXrdQBOThNN5MLhjwIfriz7VrnAbN6IPY1cKPcuutjsmFwr4OHkQvod5H7FH82u3aHUyEmbb5ftju9wHNUTXLNf/GYi6EJ2zqjvT65tP1KmW3cylmGcgA8B3yqPn0BOoBxT+dH5u/LerpnofSn7rCfX8Hw+udC/eeN+U3IB+ypyTYied6XA+IDEfyHfwDZr8O9RjuX/yBeQfyF3V/Er8o3vpfSom6JJjqPtmizlPbpLp2JpM4a9yUnT7eRk673YuabY3uRCj2+V7/pjexVrD16bb5OTAMeTk6Fnk2v4XQg8sWXbrhW8VM4J/1MuND9D7vaw2Q3HZ2npao4BS6aRCzR+Cty3zB9WPqPPqZzX1pGThj1rqVGJ9zbkgv7nlvl/JRe4VAvLn1U+Tz3vQmEGx/NMxrsJOp3cMmynblR7HeMEMe9GHnOjWZB7FvlaaZ+W7ZotAd/c65gnOIZmgcpTybU8ryB3/XNj+Q2ccpBaxlsrb5rl/91pPAxyy8AfkW/Ov0IuPKiOC9FsPXgYQzKOTDmue5frjMeU+bXlnF/tnurl5C6r7tPlz8SjyAmAXV5vcuuRq8nJuJPLZ7y53y2m+9z04wQcSW4deTXjrWLW9iCOFeTKGIeQk0E7yNfY1UGE70K+hr+ufFd3kK/Fj+z16ziPr0vzOuQkchL3cvJ14o3kVrpPIheIVgsaH0Sli6guxvpkxisJfp/SI0Ezjvn4PWM8qfgV8jgei9i5Qt1tyNeVF5fv7Rn0cGy2Lr4Xy+hizwAziGdT+Z39JLmS0zXke6KTqYxRWOJe1+t4pzmW5nfrluTrzzcyfm/9mrLsx+Rr6Q3lO3rbXsXbxvE1f9P2ICfHL2S8hds2cs82zy/fvZ5XGGqJ/Snk8ouHlvmbka8t3sJ4xbNHlc/dvCVkGG+10/ysfAQ4p2WbZSWOy8mVr39HrtDU0/KKSY7nHuV1fSUt4/Iy3stMc5tP0nLvvpCnngfg5DTZVE6Gjy+P71dOls+q/Ai8kNxyodaj+G4FPLf8oF5HLkC9P5U+QMk1lg4ljwtx+3mIobWW7EHkWvbfI1/wfpJJEjCt+zrt8vocR75heAq55uP/Arco6/YiFwRcRaVJfeWz+SDyjdCVlQuuH5ELBvvuR7TE/LXyfXp6ZVn15m0Zufbdv5MLwzcCbyXX/O+bAkFyLdqvM8sCmn76PpCTqM0+bH9HrmF1IDvfQN6FUsNwIUzkwsZfN38TyrIDy+v0dXINtM8Ah/XwPbu8+p6QCxTXkLtM2Q6M9vp1nMXxtHbZ9PTyGje7z/oyuRn6rcv8YvJNw/lUutbrYfx7kCtObATuSr75Xcd47e2bl3h/QqUwr98mdm59tIRc4LaDXGhx0mzPc12KuXmT+TRyku5b5Nahvy6/qR8hd/t108o+u/XT78gEx3QJuQu5g8iFd48pn63t5K6bduparPzdnVxo/3raqDhUeR0PL+eRX5GvI5pdRH2SXGGib1+3Drzu+5MLdl5JrsxyLfkapPk9vjW58st36GKhT3lvf1++hx8Hjplgm6XkSmM7yAntV7TzOejx69/8DD6/fPbOJLcK+1dyZYMd5MKVx1f2WTxf7wW5IH1V+b8/LOeU8xm/Nm/tLuVA8v3jXRnSFjLN17z8vTf53uNE4LblvHoe4y3zP01Oat2sx/FG+X1oVi46k5bW4XSw4grjBZ4vKufPkZZYqvc69yIXMF8DfL3X7+0cjnnK14/+uudpfn5fQL6vfnJl3aXka+gbyQm8fwPu1OuYZ3l8ryAnlh5Y5g8sn8PnlnPaR8v38yom6Iq+Xyd2rpB2CaWyAXmcokeQK3PuoCQ4e3XeYeIxGJ9ErrjVHIPu7eX35M6Vbd5S3rfaPMR0h+rrWPkOvIR8XbEPu7YwuTm59XRfdtlXXuda+Z42x/9+Gi33hOUc+4XW5Qt96nkATk6t00QXCuQaUVcBzy7ztyTf6P6ILtYKZNeBE5eQm9r+J7kAfiu5ps3B7NxUfF6bPbZcUAb5JuQ/yV1a3EAfNE0exIk86NsN5cfl0ZXlq8pF4nsm2e/McjFyP3KtyIeWH6cd5Bukp1PpgqbXE3nAzyurx1j9PE2yTzVB0Be1/smtSF5GblFxI7lApG9e51key1JyN1fvItc4+h45QXjLyd6TYZtaLkZvT+7OstlSo/r5O4zcFUez25gn9Sjej9PS6oKcHDiKfNNyNblQ+lG9fm2nOIZlLfPNwozmwKpPJHcheiO5xWizlczdycmx9/f6GCqxP7fEvIV8s1VNoD+DnGR6RZnvq1p80xzXHRhvFXtRueboi36ZGb9JX06urPIO8k3kHuTaca8kd1nwO3J/6neiD1qKTnIszc/+vuQk5DNa1u9HbsH0LfJ1wkeYoPINc0z6lXP/OeRCy5uX34CTyIWGVwCnUrrbGPRpomsJcgHzDnKhzw/ZueXo08n3BqvKfFe+x8DjS0w3kGsF/5TchdY9Jtj2roxf/13MACZmyPc276JSi7t8/l9Yvs87yIUsO7V4mMeYHkBuNbatnAOfzc5jgfytMIshTlpO8Lp8gtwqptml6N+TC3ufzXjX278hJzJrfRDvzcvv19XlN+FEchJ6XhJo5IThV8o5u1kbvvk5aa2I8gT6sNLDsE7lvdkM/HfzPAPUyddpdyAX7l5DTtJ/nZaxWPp1KufPV5KTx7cqyz5YfsvuUOaPLr8NGxmwrkfJFTZ/X65Jdm9Zt7xcn+wgJ0A2UhLoXYyvWrGpmrA/qvx+3J9cueOv5IRIcxypA8gVX744DzHtTq4o9jVaut8jd738V8a7UNspoURO4PTlNXPLcRzLeEWsD5F7mmlWpnkx+brtsF7H2U9TzwNwckppyoLfZub45uSacJeXk+b7yDf89S7Ft7gSy2SxHk7u5/F6cp/eTyNnjOflxqTlJL2kTNWBRfcmj2XzQcZvHJ8+1TE47fIaH0K+0b6s/LBcwHjLqDOZoMl3eR8+QMtgouWH9enkbjb+Qi7AOabX7wX55vX7wHuA/8/eWUZJUiVt+IlRBhjB3R0+fHGHxd3d3d1ZXBd3d3cWd3eXxR0Wdx9mho7vxxtJ3c6pHu2uzOrJOOee7srM6o5780roG/3amh/J/C+F8W8I/emGDMSHowir70IAKE16/lD4zwu1PanBhvyFskGWosS1FzpgTA5DxsdvSOAkaO34NmS0vJAGRRFBK6jCN5DxP6t90JPWCsA4KDLrCWDhose0jf70jT3uMOpEIsZZ8m68h7TeVj8UyT+AMAYV2Id8NNxWyJjbHzkIDkIKwrfAg219r0D+s312fARJemCM7WDjCiwX76OFkmVgAkchI1te4eyJHHwZFNsHJFGxZWgkSnC8hx0RTO06ca2Vko+CcPaL/Xm39pxTKCNnIHUMNXHO/RcZqp6IedIpsgGQw26J+H2MWLufE7V5kGP4TKT0P1IQj/sgh8CFyOnyZ3zehzoRoLGeC+F1JPuZQcjtF5/z0burx3v5KsbgMDrIEZL7v58iefyHWANXx56YBqlNFXtRUxhwR3JsJkZZ7MdTc44/gwLE+qKad/+JNfMnCRRU0Q0556+MM+G12HM75EyjVotkgzbulyLIbDj7lMkNvWNvPA3VcZuO5tF9pkHOsmPis8XaPppavaibYv6+SokznOv0bX6ibmys03eAg5P7iyFnYSkzIIbSt3GQo/fC+Nwjtwf3RbWBHgBuK4C/y1HwQMpTtj/ejmwyryLdJz1fNkG2nnav94ucVechu9wgZH/Jsj0NycUHxueuCJ3l/2JffBDYpej3HrzNSJLxE9fywesHxXnzRczxJ+K8vr5RfDZLK5yBqlUtbaiI+CYoNX6m3L2FkCG8P1L2z2ogX/sipesMBGN1FIIU2h4pWqshxWUllEXxM/KC38hI1LgYCk+Z0WCVRFB5EaXBphHB46MI++eAD4t+x2Vr1ITZPgh2bCNg6eT+mEjpPBpFAl6FHG5t4r7GvDgg/z/i974IS7YFOKkE/Z8FKbfD5OCM8TmKkkdqIOVkRWS0akERKYNlAhXdkvk3IzLs3RJCy260Lug9Voz9OyHg9Cua9waNj8V6eR0Jrx8BS6bjR2sjacPnJTKcfx6C5uO0jibuQWtBP4P7KoUTINePmWKcv0LQX1sBYyX354z+tQAvo2Ksa6Jz+TPg3wXxne6v4yEDz1zUlJwFUabSt7F2Pou1NmX++wWPfzpP7kWyzi+xPw9ChpYx6nyvdDVxkAzXn4icJ+dERsrl6yhzdNWi+W1rHsQ8aaFWuH3MuN6F1kr+6CQOqPZa36j2wgACbif2wxTqYnVkMP+KMGY1a6MGlbV6jPeT1IwnE6Naao/HGm5BEdTHU4s2blSWTMbT5DEnHkRGllVQtPMvyDi+Pp3ASYYioX8mlwVJ63P3DYRecFE8u2MD+OqH5Om+yMA1KPb2E5ABqwdy7v3JKACTEuNxMeHkRobeX5ATItMXj0NBY1kmQkPlEIQcsAQKGBzMKQQsiWqKtACntMP/Wx5l9K4b63FrlCX7a+wv89EJApyS93t5rIOfqMk6R5HUNC3ivbfB82i5z6MjmMQsy2trZMidN3nmNJTxVTj/I9DfLKu8H5J9LsveBYJt+46Cg5pGsF89Yi19AEyVXE9rHj4U762hWYuofMDHyPlxE7kaUSjg8bnYb55ADs1p4ix7G7i3A3nrgiDeroz96HsC/hpBwz+GaujdifTeFmqZoWN1FF/Dyf/nCOq/nuycolmMHX16PPp1ehn6ULZWOANVqxo15XIpFG2VFZBsQZFP0yTPToJSCqdplCCFjDstSXuZWpHzgSg6MrvXn1qaZgvwSQfxlCmvS8X/eh0pIjfE/72WHHYnSomcqiP46QwNRYH3j3faghxcKe5wNuaDCRXJHJ4XRavej4TiPJRRajyclhJE+sSaaqGGBVvXsEHNEJEZyEsZTZa8px2RoPhM8PshNWzbWYvksc6Y9kPGnO+C3/uC1+tJnC8oC2hqIoJ4VGrIyHJGjNF3yAiTng3dGzknyUVdIWH+yji7fgb2yD1faidmjtdtkfPvq+jTKrn+7hNn4PcxTz9ETsSGGyBzfJ2MspWymitPI2jGbJ11R46nvkWPcRt9yc6Ro5ADaZf4vCI12eJXGmDwbIe+rBL8HpZcM2rwBWugqNjSyCTIgLs0rTNlpkeQmA9Ff26jTh25DuRphtjvrqQ1PFPG30zIsTV5Wc/kYexn6pD8EsnZf5GLUkXZ59Miw+50jeSxDb77UJMxJkNZPcfF3vk1MpIuUjSfI9G/vvHzuJj/ezM4PvykyIm8Capj8nD0vV2zqhmKIRYFDTxIDSbuGSSHN00tt3YYo9QQtla8hyzjrDeqo3YXDXREUJPJl0aGzxbkLPoAZZlNk3s+q8U1+0j+392o6eZ/xRn6e/z8NObGR0iemaaj9/IOHN/sLFgA6a/7Inl5diQzD0BO0+3ogNq2I8jz9AjNYA5aZ7z3oiavbYZsQvPH54lRplfDsy3aob/5AI47ke3mYJQl8T/giqL5HIn+LYTO7bcJtIDk3sxI1juqIN6mQ9Bq7yDouzNJgr6Dv6tjrxyIdLgBsTdN0YD50DfmenZ2vQrcETy8FefYichhPSElcUgifesbAlK8jWeM1navfoxCcKLDPaZFM1C1qmUtNu2Hked4JRQR8XUIUEfRwNoxOb7mQgrij8Hj8ShybCKkgCwaB9IqSCnZAnnZ96OD08NRmvfN1KJR10VGm2UTwWYwjOuq/T1+ab2EgcixtTKCX3glDsjbcwd4Hnc4G+cpkJFyIEqHTYu7ptEjlv8bBY/B2Eg5urOtPuZ4PyOEh3GL5r0Of9m7mCPew2FENEZc2wtllP2BnGfjlWT+XYYExhXi83whkO1NLW2/6aP5RnBsuuauL4sUs+9jnR1Ag+EZEt7GJoEpRNlMm1MrrPtfkvoxlESYHkK/UoPOmLHWP0eKwYm0jljsHWff1MA4jeaTpCBwXNsHyQq3oTP4dGSY+x1BT5UaGz6ZU+Mhg9Gh1DJ9To59azsE45opbu0Oq9DOfboQGcPOpbUjowcymH1EB2USjwCvC8W4PlTv3aCAi6OoQZkeTwcVpc793+7IiNCC6i3kg21WQXLyUkWP4Uj2NXNIHoGcUMsiA8/l6f2yNJShmRmb50SZuDck92dGNcYyw+9JNIkxInkXayAj+gzRnxdj7l+IHMV9Y34eQFIrDUW7/0U7B78ke+QcwdvOwKR1nlsLReQ+BZxR9Hh24HvK5N3RyEG5xs9FYt84FBnztkeG00PT73cwj3m4uWdRXbpFqGXEfB48tquOjyDF14z5Ox9yXM+CZJfpYs+/Iebq00h/bhMBoewNGXYfYXA4oTmQE6AFOeTWyZ8jBfCaIRg8juSawYIKYo78ghzbmwNnI4P5ckWP9VD6lq3LqZBz8QIURLZJ8sxYKHh2IArAuZGSBgsNY59Hi/34f0geuQdlOu0cZ0h/YPIC+Er3n0VjzN9G9p09SerboPpbG0Sbnw7W1xi8VsxUKDDoVRTY9wU5qGtKIkMEry3IppIFWrU5XsmasI4e12ZuhTNQtaq5OyjC7HFg8+Rab5R6fBUyUH4MbFogjzsiL/v3IdisnBciGszP/EiY3TQ2uq7B32WZwIUUqbtpwpTYBo/l3ijSb7L43BUp2kdSM8IcNyShCUVaPI8civ0QBMc7cXDdFwd9v6L7muPZop0afG6Vu//3QRo/pwkB68qieR9Kv85GCmAeAnE0lNHwe/T3d2CtgnmdFBlcDySMfChD5mXC4ICMH48Acxc9tgWMTz1s/h7I8PM0UmjeAxYtgLcNqBk9xkiuT40MVW8gKIkHyUWDlrUla37zOEu+QRAYLcghsC+57AYanCGDjNTnAbPGXm3I2HMyreHWpo29bQCCLig9lBAyKL5OQGiiTMaBwHbxeZ7YLz6jgzJx27EvsyEH6m+xFk6P/l2MokQvLprHHL8zElkNcU7sSGL0RVkQywKXICPDZ8A2HcRL3kB1Zuwl7wG7xjjujQwMrxc9diPZ18wJMB4yuh0an3eP/X3K3PNTMZJR9CPI32Sxpwxm0ES6ys8x38dJrmd1n04sepxHoN/3oazvqeJzl9hjB8aa/h9yoP1F4MPHfrwnMqa2myOc1tnoWTbk7/G/L8jPkXh2bEYBAxA6pz+lDowlgl3+Pc7AP4Enk3sdPjbU5IkD49xaLLn3LYLrfYCafLFlg8eub+ylz8Wefj8lr5uZ4z9bF7OiWlvp++1Ca6PvanFetBTZR6QfP4wc1h8EP4+gAIPUSG4oeO53FEj3Vdn30eR9TIKCZv9AdoC3op+X0jqYYyrkNGyKTPpkPXeJtTMBreGa/4GCET6MvheyrnM894ifM6BMwZ+oZdA9CGxcEF+W/kyuL0StXt5AJDeXqi4UknP+SwRVDe0sSdd11YYwTkUzULWqZQ0p6qvE72lq34TI8ZAJbjsXyOPYKGL42xAQLgYWSu4bDfJkI4fLr8mYHYQMHbMnz+yCFML5in6/ZWyJgLEUcGOd+71Qyv3FSPn7hqQQX05AOYwEqiV5Zg+kwP6B8LaXL7rfdXicBhnNWpASl2b2ZNGg/VAUx0Bg5qJ5rvcek8+HxJhn9TvydT22A15AhtrC1kbsFxOE8LVVXFsy3sNayfxaHilTpauJ0wFjkik184Vg+goyUu9FDrYSKT5Ho0jkqQvgdQLkjP2WpA5Vcn8+lPHZAqxd9NgOx9ivHmfL0SiytE/Mx1eRYTiDqml4tCUqFH8BNWV3N2RMv4fWhahTGWKXeAc7FD3Gw9C/BZGhIgsQODP25mnicxcUoLIXdQyRBfGc7VO9kYw0Re7+bgiC4bt4D78hOK5SKZrJ+FqcDy0oKGhFWkOHTYTqe90Tz+zTnuOYjOWECK6rR7TNkRFhQPzfAShIolPIdyjY6W0imALJuD8TTpq41i/WxLMN5q0fMg6+hIwRV6Mo4E1R1HNX5Mh7DDnk8/USSpXpM7Q5iGpRXgscHp/TLMqpUObPtSiKfS1qGckzIQProx3E37Oxl6yNHF5HIufoTzHuTVcoeyTHoxuqcZllndxI68z+cVDdhINQJsjEcb1h8xE5s+9DstA4ce1kJPeOjwKTHqfmbFu/nf9/ZvzMdJnB0ApiTz8IuL/odzoC/euKggezs3V9WsvJqe4zBrm6GgXxvCIy3F8da/kZ5DS8GMGwpXr2pCi7Z+r8vlq2lsy125Dusmp8Xg3pzltTcxIUmq00gv3LzoddUObkxygj8XBaO9TmirYABaI8UNNppkN62rVIdps79qC3UWbPFcCCBfE4BYM7ZnrEnLmBmhNpxSL4q8PvUtQgKPcf2pqMM+oylPnTJtRZ1SqnTNUKbMnmPmMc0I8iKK666cNIQduNBkUUIPixO4BZ6tybDRl0f41N/Ug6CBudNpw8KKrwTQT3MEHwcjC1VMKxkfL6aqPGrFlaMveyGh17x1guR/2CZeOhotdbtfH3jkbGkbPjc1daC8VjAufEQVZ4lkkIJNPT2gi0KIrCbYm1uAcShjPj0NlIaSpNpFIIWvXe16rRj6NorZBka2NLpARMWwDPeeFrbKScXBifX4p9MFNee8b8/IgEAqgztmRdjoGcyf+Lsbgy3uezsQ4noDVO7WQF8twHGUq/J2AVcrz1oMlqCiADySPUoqDSfeLf8S4y6MzZCuCvV+xXtwcv98Z6Pj73XKb8joeCKLL9udTR09QgC8dASuQ9yb3pkQFug6L5DH7SyNDrkIH0DSQfrZw8NzaCh5g1+lCKdxBnyLHUcRChTI3fYm2fgLKT07U9EzLMZ+9rhPuUO6f2RYb//sjxeB0RYR7jPC0yvC1ECWFER7D/48R+smlujK8E3szGCMloA4Et0vnXAP72pWb0vCT2/NfRufwXkpmeiN+/JKAeSQzBRY/xcPR1DCSvPkZrh1iX3FnQPfe9WRFM0jd0QCYTcga9RmsYoDFiXZ6LHPVvAesUPYYNfl+G9JhdEaTrH7GnlaKQcqztB4Dz4/NYyKC3T7bvIqPuq8Du7fD/joix2CX2ygna2N8t97NHvefK3pC+uVTsS4OQLrseOXhmCkT2aIPvVZDT/SxkUzkMBZZ+iQLrZmZw53bp91EUyPQtyrTNZIO74nyYMD6Ph3TqKYrmdzj6leln88RZ+CSyMT2KdLV3aSNouuj3hrJ33iAXUIrqLt1FrQ7ZOdSBxGxnXjKZeVHkDPocOahPBBajdR3Z8RDs5HOUBPEG2YmeQfLawBi3NhFHkP3r1hjjUtTzLWsrnIGqjZot2ZRmQAbJgdSKBp9NG8bSRm3sKNL2OuSh/hAZdwdLv0PG32eRovZYCIJjtDMvd8dm3arIK1KQjokxewM5hyZMnlk/+C8ss6isLREujkTRu9ncewbVlxlmmBtqmQ1fIIUorbvQjdZYz7NRoAE5eOgV8/UlFDmXzpkxqMFTZAaILAKrf8y3smCaTogiys8lFx0Z6/fa4P80YI7kXj8k/L9Dri5FB/KaGtwmQtGBkyTzcC9kyLgGOVcXTJ6fFxnorip6zBswTtl4nBXvdtn4PB2KUn4fGb1uj3VamNGBJCsSCfYvooixyeNaVwavh9MMCmW/OMsey/U1My52R0XPv405WxgGOzLubBxjn8ERbEYOJhLhlb8BXFf0+LbRjzaNJUgeGoCMS6Mj49UASqbcIMX2B2QYugbBL36HnDOzD2t/C+D7oJg3rwCb1bk/Jqqh0YIMvnuQKMe0AUExAnxkMvG+MW53IRnu2vjf+9IE8Hsj0X9D8GCZkTYb1wWRoXF+BJdyN/BSAbwtihxznyNHzHqx78+IHEUnohpcryGHTdNmL0V/sv10EIpkT4OMuteb70gWfo52zEiktew0FYoczuSC1EE0NoKUvi34Hmnjftkbybkcn3tSiwD/FRnP1qcAmT0/P1DwShZotHasoyXjc7fY3y5lJDMhUHR5C5IVn0Hy4qtINjsX1ZtbFZ2lnQpSB+kV6yDdbiDKQlmUkmWPkcCqoUDbN4kgE1T/5org/xUkzxWqM49A/+ZAjqWV4vPqMQ+XS/q9FdJB5y2Kz5Ho31UI5m+6+DxurKt7kS3lCepAKRbI75hIbng2udYjeReG5K0PkQw7fwfykum4veL/vRf70nEoU+y/CA579nQvpA6Md0FjuQdypC6CbBibIudcS4xxmxDrNBBytllb4QxUbdRusYm/iuoDrI+McT+EwLY7DS4gnOPNkMHnEeTceJk6uJjx3J7UsFEXbkcexkJGjgx7daM6zxyPolO/RZFB6yHczP+RGNaqVntf8fP/QlC6DNgBOWjeQAav8xmOrAQEL3UfNWVgD1rjivegJBGTqK7KxkhJGYicj0vSuhbDxCEYXISMQvsN6bAt4h2iLJ4XgXPi2ugkhQSRETMrbvk6gjzaAkV39AeOavB864IMqp+hSMaHEQZ07+A9M759gWBq/oGE+KfiWtMWIB3O8ZoUCaoHUauNdUW8w9liXrbEOXETDVKsaW0cqmeQWh74EUWNNfW7Qo7MX0nw39N+x/0DGjX2Q3svyFi3B8LV/xEZTxdCRtxeyAn7J7B4fKcUUEK5OdUl1vxUyDmeOfzmQIbeAfFOfgVOLZr3XD9mRfLHZsm1+RDE0XvIQHECJYTrQIasbZGj8QcU0T1YfaroYwYRdF+cJe2SpZKsq77Bw/HUoDf3iv1/tvjcPXgpxRxur74nn9OCsF3jbHwDndvbxfjPF880upbVuMjwf0fw8QBR3D73HpumJsUQ+jplrN8WFMW7DzD9kN7d0K6PJD8HBi9ZFkg2T/KBD1OgTOhSGaLbcRwGc2iTc5KhwIotqDnW3s6/uwbyu22yl2WZqwuRwIkiXewh4N52+H+To9qez6BMjIVQdu+5SIf/Mv73j0hWuwXpN3/DBTd7Q/rb/tHX75BuO3uj98th5LU7qg84iJpjZnRgBWR7GYB0oImL5nU4+jQFkod2jc/vIx0m02d6oUygt5qlX9SCRroih9KZdZ6ZJvbpF5AcczMFQpfleDs1zo45c3tlhp5xJtInl+xgPrJz63TklMkc0+Mh2T6DiH4q9vDpih67hPcsoPeE7HxFesssSB/8kFoNnImS75UikLcZWuEMVG3Ua9QUlwmQcrtjcm9sYBmEizsIRV2tRqSAFsTv+MC/kFHwJ4QjPtjGjbzGe3bA/x8LGWdvR06ER0ii8OL/boMUxAxr/GfkeS/Nhl62FmP2MJGVFYLgHDFu3yKc0b1JMkmS77aljG6Nol9+QlEDa7f1bNENCe57Iufdj3HQzp6utWY4TIloEuRIewbha/dN7m+IIse+jbXxNXBaA/nLhLCjkaD6NHIEfhRC2G7ZnIr58y41ZTorgLlq0ePcwPFaDDnb1o7P08e+t2l87oEicx4AbivgPW6Kojo3iTNsiuSZVWL9n0Nka9BEij61s3nhmJvPUoPhye6NjyCFRtqA0s68jxb714XI6foVMiY+g+DYdk/7UYZGTdFdBxmlfow1/0TszWPH/cWR4eg0FHRROBwpgxsB7yCHF40UthVjvnxCAvFXhpbrwwwI/vXFOCtOp47BBBnvPo33NBi07cjwgeSFD4Gl4vPUMZf3pmbQ3AAFMzW74zcd+24owr+uMwMZsL6P93JtNreK4DU+T4YM/y/H2XQtChgondGzHfq+MDJeZ0WRN2hr7tGBjkJgWVRv4mOk36R6Y6saIWXa4ztgHLK94hgUaJSuozyc3FmxV9xNMfXflo95s3nu+nhxXnyH5Nu3EJzZ7O00Nushff3Y5F4GI3Vk7CWnoOj4l4LHweqBlrVRkxvGQDU7tkfBSvMSuk+siVmRLPoHctBMUiDP0yDZfmLqwEMhue1pYIH43AXJmrsDtxQ95sPZ1x5xJnyCHE7fkcD8Ikfhe8BZRfM6An17Ajl5b077m3tmPqTjHt8ovoaB76Vjnf8Hwc6m50UvpJ//J7+HdhAvE6HssMOoOeoui2uTUnOo/4R03ck7mqdh5HuT2FezAKH07BkNyQpnovP5KxQkXgqnXLO0whmo2qjbkKHhDiL7I7fAJ44N4InYnNrd2TEEviZERpI9gP9Lrs+GhNxPEWzLBTTQ6RFjsj6KtB8UQuVkufuTxbhOUfT7LWOjlq0yCYr2eLzOM31Q5shVyMn1Ia2zXjLBf1oEa9c39/2xkIPjmziYLgSWKLrvKe/peKAohzOR4P4uwsifmta47qVTcsllHiHowA9jfV4MLJ97fj4UwdSwyKTcXPkrBL8+KDpsTqSMtoKAivsLIuN/06W2j+Q4dUXR4mdSKxx8MsoUmCp5/tEQ+BodKT06Mtr2R4JnC4psehJF72bFL78Hdip6XEeyr8vHfjAQQWitjAzsF8Rc3qwgvlJlajxkzE0hXEZDgR3/oZZRtQY1Q0YpnGQJP9MiZ8xDSOZYJ8b8nnSvomSZEcma3QZBLnwDLBTXupMot+hMzIIgpiya91w/0rkzN5I5s8Kqn6KI43p1y9Zrh7GbInd9SSRzzBOfb0aG/0mSZw6N/bDh9dDaedyz+b92zIvvo+83IePdGMmzE8Yc+52ao7Lh65jBHUmzIIfR5zFnjqBAw2d79Cs+963T382QfPUHMiAt3+h3QE0vzLLSnyXJ5kTyQ+lk1Q4Yh9GQsXcgCjLaIjcGWQDJ2ShYKZOlGn6GIKSH3xAaQbdk7/sHkiUejTXfrnWAUBZ6C8r2ygK3JkSG8iuo6Q+TU5JaDcPYr3RNXoacWVkA11/IAbd08syYKOvkkIL5fi54fB45d+9HOttmyG4xJ5I3n6F1lH0XmsSwS2vZtB9yOA6Ks2vumGvLIhnjc9oZ6r4B/ZsbZf38D+lA2+Xup1DtrWTAMjSUtfdzzLMdUW2ccWJvaliwZozj04SzGjks/0I2qWxfui/W8o1Fj1uO91b1XOvcHxsF0t+K0AneJxAKqjYM41s0A1UbNVscxC1IybqN+hGJXZFH+wDqZCt0EF/Lo7TBNFL9ZJLif3Go3oKiHz5AEawdlipPDcZkUeByBOWQ8fYDMhqMFA7vqNaQcvlLCEZL1ztk4vDZvC1hFkUntaDI+I3IKagoSimDpLq96D4PZTx6IGdeBvf1GMLBLQWO6TDwv0z8HBcZ9L9BUSfHAnPlnm2Y0k5NAb03hLCpc/ePQk7W4xHEwiUoQntXBDG3Q6N5LuDdpUrmYcA0uftHIyF63Pg8A1LcDi6CV6RsTI4MqOsiw8INSFH5iNaZTjuRGEnK3mjtfO6GcIPPowb50RJr69yC+MuMTb1j7WRR01/Hup81eXaCWEM/APsWPbZD6MvNsTdk0WezI2Pb5tSgFWYqmt82+mAx7p8hBexRWgeKdKe1c78wONoh9CFzDuyBnB33oJoDh6MMqx8QHMeqQ3qPI/De50GK9+zJvZlQIMceCNKnBTnpsiyZaYK/O4set3Ya88lifJ9B2eg7IQPuj8igPCu1CPdliOAWSpSRgqLVF0FQr3+gSNIdKEE22zDyn56/qyKD9WvIILQTCkbL3lc/avChhZwBwcfMKJPwzeDlSkoSTdzAMZgABRtkUHov0boW4QSopsj1Rc6r2NMeQs6QweostdeZQDi4c/P5ACSTbRKfT0TZdgtQsiCH4ehnthb3QY7go5E8ulScG+8g3XaH3PcK0yGo1V39HgWinYACXD9B8vIg5Kh5PJ47lCaxadQb1+S8nhYFz36DZLpfo38PEfVmmq3FmX1YvLsW5FBNkVu6UjJnTPCVyV3LxVwbFOd1//j96Y7kO9kPu8UYHUTNWX4UsutNmzx/GwF/V4bGUOTc/DpAAbDbIBvpikXz3yytcAaqNmo2lKK3HzUHw8lICR1sU6RBChgqkvgeinTeEkU9Z/ztn3u2O5FpgaL7nuyIDT05SMYOYfI6VPB0CmBNagXxXkVRzE1h/Ct47vVATpR74t0+hRwzgxV9R1E6dcc03sly1CKyHyZSr3PPrU0J6rEgaKxVkfC+JMqGmQNF3U0az0yNohzeQk7Hs8jVlShLS9bGNkjxWiq59w+krP6AopJ2pcHYvYkQlqVN75gKZvHzsLj3Xew9GfRdJrw/VfQ4N3CcDiCcpLn7WcTjgTF/b0DCdMOMMAxFoaVmPJ8fGQ83QUaSj8lBOpWpJfNwEWrGuEeRIbh33OsDTAeshIIpZqSgCL9kzV+GHEWXIefFFdQM2KkTYDRaw8sV7txEBocJ4veJUCbEMckcegwpjZkTcjxkqB7hzIwG9GlFagW2P0JwW2lh8FIbqFEGXAZpkzomJ0eQZr9F324kMXyO5P98Kf7mefE5M7YdjBxcPwIPJs93jT1yIJGR1OwNBa08T8hHyCH5Z8ylLOhpZ5oAdx8FhKyG5I2vaRJZPJl3e8aYf4H0mmx+vgCsm/vO9DQInhNlN2yA5IANU75R9vOJwXMLdWpudpaGAhEmRI7Zvsn1yVCA2MsxBneh4ul3oujr1RrxnurwmzpHJkVF2z+llk2ZD2Ib4bMZyfutHNxxvR+SF39COsDvyNk++sj+z4LnQq/YG8+gdS3Q7kinuzXmQimKraPzdS9kJ3k/fi6JgjqmRbBHJ6O6P5cCaxXN8wj0cWkEL3s/CijYgQgmRpkRW8TcWyPbO5upkctCjDV3KZLDP4/3V3gtNVoHEKyEAqgvRwGaGSxsL2AJ5Bw8BgXXdZg+mRu38xk8UHSfGMfp43MWeHhi0eM5kn3tQoJwUbVhGL+iGajaqNuQE2QOhHnaHzlAtg0BruHCUmyWH9I62mjiECTvD8GiVdQzEpJPArbqYN6ORRGU+c18IqS0ZlHM95FEC1etzfHsggwuu1ArDn0iigocLgMSgkLbDDnz/kKR5ZN1BN8j0d/DkznyLVJOsqKpP6FI5/dRtMhz0Zfs+V2L5n8ofbseRUpmRsx0fa6DjAufI2PzPwrgb/fY3z6O/S3jcyzkNLoUKSY9Y3+ZDBm+56YJjFEjOTapAHcKgp0bLOsQ1Xn6Iebjh0QdngL4nQtFoI6Tu14v027MWE9v0E4FwTtw7D+JNXIXclIPDN5XrrcfFnQ+Z867OZHhNq0pcGvwPUV8HosC69ANoQ9zxxxeO7n2BnB0/L5ejP2SSX8XR/AXWzSa32HoTx42bvs4P35Ghpc1i+ZxSHMp+bxQnIlZZmL33DmyMTo3P0MBCyNk4KRmMNgp5vCryICfwtRNiGTirEjzGcih/1Cs0XOKHr92egfTx1juSy0b5h7kEJgMwXdmMshnNAksGDrLmwIOKdljxkGOx7OI7Oi4thoypv8CrN9AvrJggXVRoECGCjAQOWDmSJ7tg2q53URBxew7aAyyAIRxUV3Ex5Cs/kOMwanAnMnzcyNneAYT9T5JTZUi+xC/Lxrr/TFq53S7ZKtQ01cyB3cKk9YDBTNmDsamnyNId/0cOCE+52sJzYF0u1KdFciheCJyKP2EkAHS7ObetIbfK7XTjNp5vkL055dYfz+h7IsXYu2WLnNkGPuXl5PqZQWtGef2DyhLdL+i+Q6+LkN2nS9RNtZfKPDmUpKyAzTAWZ3sRXsGPyvl7m8Y+9PZwHaofvTvlAzqd2TmTtWGcdyKZqBqVQuhemlqOMH3IQ93w6AuUCRwC7Blci2LXH0QFTZrVUiyEZt58v+OiwNlopS35P6/UaT9l3TiaLEOGNfREC746XEIvocMJlMN6VAJwbFb7vNMKA01w6LfmxJgxiJj/wvB1wcog2Q9BE+2G8JEPxsZgu5CBs7XUObPG42c58PRp7Qew1kElAY1YT6Nlu+GotPfo042VIPm2JIxrn8hY/diyHn3Hq0j+VspI51dsKF1Svk5wHXZO8uNQ19q2RpTNJC/jI9lkOLxF8piugtlU6ZQTZb0J4Oc3AUpaINl0JWlISXgYwL3FzmdVkYR34MQBMrclAROAhlx3yEMc8A/Y29bLdkXTkHK8VhF8dkG72PGuL4e49wNGYzejTH+AEWL9ovnx0CwTl9SQnieenMCZfEeG3vb17FuZi6a1zb4z/aXqZBR+uzc/QyGpE+8gxOoFSIeLoNi8r+6IafVkSjDaABweO7ZnigD9G4UjPMrcsztQAlkinYa+3/EGl0tPs8X+81qyTN3onPygKL57cwtzqkvqJMFhmSsZxE85zQN4CVbJ72QznMbgvobl1oG1TzkdDAKKGTfoHdzQ+wXryIZ6dL4fQAyhB6QPNsTRYhPhIqkZ/JIIwyP2dk7MwpSmyB4SetMLB/77D20kyzOkB3c2VyaD52xH9PEhs6kX2PEer07dz2t4/ZIrJfCg1NQEGQaBLQQqtn6bewrx5NAZVMieMo6fVkFyWppf15BhvR5M/6R/v8/5BjYrGi+R7LPyyMn8D0oW3c6WkP6jxlnyMfAbQXyme1Ba8WesDcRzIF07htQgOQ91LJSOlTHzs2Tw5C837vOvV2Qo7UF2V2auiZp1UZwvhTNQNVGrYaiVuYMwa2VtzqEyM2pRUY1TBFDRrYWYOc6/H4MHBefu+buN8RgjaCnWkhgBGLMMqPBpggGYvai33HZWnJQ90XwQguSUz5RhM5iIVgNjDk4CTnjeAgfcyffy2PmjxvCZlYEfI+C+54agrZFzqKPQjCoh++cPj86JYadiffzMYq+uybtQ9KP9N10WN2nYeS3T6zTLKOqJYS0brnnOrUjps64TIcMDJ+jlO1+yb3CcL+pGTR6xrp5CSkk6yFj0eexjlYhgRPJ/Y314z3/X9HjXK9v8fsmwAP5PsR5vGPsF98iaIaGG77y6wEZfH5KPr+OlK2+8XkM5GS+lxLBRCR70uoxJzaMz3Oj2gifxrxaOPnOGnH99KL5D36ys3RqpETehDIVl0cwa+l+Oz+CjehPSSD8EEzfynXmelfgQqTIb56fN8CUKFNl1ZH439l+ciYy1syNDM+PxRrLoE7SYI+xUNbIlJTAuNbO72J0ZFDNZNhTkHFrqvg8Rqzhf9FA43KOx7pnMQWeSx3Uz01iT5o/PueDvtaI+w2rg4CChT6iZugcEzkn96cGP7UmsEHR49cBfc/me+aQ3yV3f3IkS94f7+VuwhnR6DVSh/eXgqf+SCe9Hcm5yyBYntXjTLuGkYQ7Yhgc3MmzM6NAgTeoo/s0W0Pnbwty1OVrVU6BMlULM5C3wXMesm5dFPT6I9K5tyuCr+Hgv1fM3f4xpyeN8/l5YJt4JjW0T4KC8L4iagY2S6MWkLYJcgB+j2SVH5CDc8/Yh1JH4HQ0qP7zUHi/EyFjZA6ZVN/ZE+nfJ9Wbkx3AS7aXrxn71E25660CC5Adauyix7BqxbTCGaha52/J5r54CI8tKM3zSQSrlC8MOw3K/JizAbwZUshPQsLv1yjtccm4v3McQnM0cLwGOyRQtP0TcbjvSGvc8+4ogvJlSoDpWdaG8Mv/iPn3JcKHXya53wU5VbYELq73TqgVOb2E1li+PagZrFZDEBzLULCBHQmRCyIIrczAcwlSZP6HMoTmzH0ni/IvtXMAKXgvUMP7P5vWUXJ/Cz0dLXgNB8+GBPkDkHL4S+yBkxbNWwFj0SVav9jvX473+Fq2/xb5/pL5k8EtLBKfu6Hsl/uRkejz4H9RGKyeyf7AaUWP9RD6eAiC7XywjftdqGWjvdFg3qahTlYAMvb3Rxk+e8b6/0ey/86NHDUZtEfp9jFUh+xdarW8NogzqQU5yI4HLkDn/TOUAP6C1saGR2MNvErNyXwNygjsnfve/EXznvCSQfucFPMkrXszS+zJv6KMmIVjb+qB6rz8XctleOcUNYfctPH/9yCyjJCTsYWkZlCcE9l8HjN47Vf0+HXwu9kfOX8z4/Lc8T4OLICXdK73QZG3q6GMztJGcY9Ef5eKOXhC7nrmMFsAZah0KExzOv6xRp9M1skVKABn8uS5m1Em1eiN4KvB76Qv0kePoRZwkIepmgXJ8y3AoUXzHDxNjxwv28U591z0YxAqeP5d8PsrIwnrSs3BPRd1HNzJc11jTm0S59ZdNKmunJwlU8b8z2SGHZGRfHqk1w0AFi2a3zb6kMrJ/VBNjddi/3+ekgRx1OG7Z+yV5yNbwtso8OoeEucwkpvTeo2lhwFvY451j3dyNTBjXDsh+jMIyX7rkGTlFclztF4oQ+y53L10zl2PHE09G8Tb5DFmfyJYydmSe6UO8KB1kOvQaqtOiJALxu9ovjprK5yBqnXuRmvl5iOkxG+LlJw3kXH4aQTVkCrIDTdCICPvNchQ+l4INr+QYGR21MEzpL9LzTi4YmzoA5FDYWuk5O+PBNMbin7fZWvJ2G0cB+IpCALpKlRH4VtUx2LG5Dvdo+0LLJH7e/MjKLmv4u8NZjBABf0eogT1QIAjoo+3EfBEcX1RJMj/hqJT9yGKT8f9UgoK1ATdcZNr6yGB/q8Y941oHb1Tur4gJXEuZHj9HRloN6ONjIvO1qhTcwmYFRn/v0FK/NkkRQKLeI/ISfsCgmPqG9cuRsrY6MgZ8BlS0L4l57yP91y4Qb2Nvo0Ta38QOUNxnWd70kAoMAQn9T1yToyeu9cVGei+irVzETWo0SlQRs9vRLQZ5XLIZufRSjHm+yf3ewfvbyJH39fIYVsK6C9qToJ/IcPapsm7+jneRf/ow2z591aGBowdY/o7qk21B5Khuib3z41+/ICcsd8hA9el2XsckXcfP+9B8u7Uyb3usZ88m19/MWdWCj4WKnr82vld5DPgsjVxW7yjl+IsGGNEx30keMvmw6bUMvezbM6n6AR1Ker0+QxqAUdpnYfuKKNpQHa9Ee8CQQF/G7/PG7xtTE0GnAEFP5WqbkY79n/NmG+r1rmX6tXdkfPj1+ysSOZv4QEJqC7rhMiYfRA6099hJItYU3Nw707Ncbc5OQd3nfG6Cfiq6HFpx/HdG2WaDKAWdPgtBdcTGga+8/CDM8Qe9B0lyyyvw/u4yPH4EDX5+WkS9Jfk2amQfebcovkenncTP/dBuunC8bk3kvWOjv5/g+wgtxYhn7S1v6FAuj+Bf7bRr6NQxtOMHclf8n97AVtRC0r/GFglud+qVnUZWrzrNrOe6vGL7E0twL5F89+srXAGqta5GzUjxMFxMKUR0N+i1NX342D7D7BGg/nbg1zRaATF8WTw9CeKJu6b71MH8NIVRSTshRwwi8X1XskzYyJsz9+QcyYrhPoEJSwmXZaGDEWXAuMl15YKAf1bZKD5FzUs/4VjXF+J9z998r3eKGLyingHH6NI5z4oO+Z+kiiNAvu8FYq+Pp7WuM6pILw5tYyN+1HUT2mMyIkQ1Y3WsC6vo+ywFH/8MBT98i1yui1eNP/D0L/RUJHIrF7Ji3TC1OXkHJgFOVv+VpwZHBJyRWSY+x45x/emIOgeFHX4ILB7fJ48zoXtqBWnvgI5yfP1KEolZNfpm8X72Dn2uf4oEGHqEvDVF0VMXhLXxqB17aWxUOZjCzLwnBHz5MXYA3atN7cK7NPftUniZ08EO/ImOec9wuKfkALqXw1DP/ogB8JxRLYuyhL7DGXJnEsNE/tISlrnIdZ1Vvz5CeTYz+r1dUWFkk9D9dcuQtGgmXNghOYUyrRoQQFJf0eixs/D494y8TnbLyeN/eeVosesHcZ8qAZiZHR/NsbiIWr1ZhqWnZKM/QTIAHUzyvKfHGVqvEwtargU+0s79TsLSvs99tTzUAHiK2NPzZyS7XquAatSx+GP6sb8gLIhnySBo4z9c1OkB5UyG6AdxmXJWAeztDXuyVzNnm14PdFkL+uLsvK3RhDl0wxpfQzLfjCU/5s5uNPAnSE5uLsix+83NBHkHTUH21TIOXolyvTZM1s3SB7aA9lZDkFQbaXR44bSv3y9mYYYykeQ13wgwWTA9ihzuAXJFHPRut7KmshhtknR/A9nX3vGGXATkfmA5OwPibpMyGbyGXIK7tjo94B0hYkQuknf5P78KCPuRQKqPvnOBAgN5+0O5nHSONuWi32xF8oK2wMF2bQgZ1ZqWypNFi7Sr95GMvBeKHB+SgRTPFjAFbLRLItqWS1SNP/N2gpnoGqdvyFHwqMoHT2LXj0VGbPHQjiU/43PPwHLN4ivHkREdnzO4yhvhxxGPyFc3DU7mJ+9Y6MeiKKAv0TK0A3I8Lc5gnToHQfL9siBNB+dHNpiJMY0O4h3Bm6M31tlUcS4PhqC01PUDCULIsH/e2QY2Y7WTp2JUTr8fcig/m28u8ILe0e/vkFC1ARxLXXGtKq1gmDZPkdK7uVlEg6Cxw1R1M5oIdQMQGmy+bTkaWOt/IgyoU6lCZST2Ad3B84qmpcO6FvqWHsAGba2JInCQQJrWuizZ+xvTyHH+BM0oL5RvIflgr8p49qqhMMbCafvEYaSuHYh8K/kc1MZ6uI8mQ8ZoTNYw10ogXMw2YtvRoa51XN78Oook+m72HefBtbKz72C+3BhnC8vRnsbyTpZQMVDwFy57xTOdxt9WTT6sHF8Hgc58/aM9T0Zcpi/C7xfNL/D0J9lkPNvEAqIWZyk9hjtCG8BzI4iNCeoc2+aWHtXJte6IUW4JT8/yt6oGYvHISmsPSzzGjn+JqRgGQQFD7xB1GlEEC1/IsNo5pBfnhLB8w1jv9LzeHKEYd83ub9V7LXfxtz7GcmRWXHidnPKUKu59h8E85M3pJ+W7JO7UoO22zTeTalqZrTze5ov+n0gOTm3zrO9UKbMLrGnnQss3QAeM4fBNEhHHhB8/IVkthXJZe3kP4/g/12Vth3chzFkB/fzRb/b4ehnxvu4KHBmAJLPPo0+/o826rCMzPgW1Ndmk5tnip+9kCPmaGRP+g7B6h2CoL5eA24vmt8R7OPuwBHx+7jIHrU/tcz0VZCONk2D+crW/LZIn3yNwbPjlkVBT4MQIsWaSF+4Asmsm3YQT5MgW97vydn1J9JTtkJOyGlQANy3ce94SlQzMOZzCwpAuRTZUjKd5TWkz5yC0D1WQ0Fz2Zwole2o2VrhDFSt8zekYD1CrbDW2Mj4uxe16MOzEbTZSKU0jwBvNwCvx+/1ioOPA5wcm+cXKHKgQyKz4tB4Bwnhs8Shsj9yDDwSm/z3KHrsodjUjyGBGqja32OZFumeKg6P+6kZV7vROntk/BCgtojPi1CLhtwyDvcvUSTharTO2pgKRWAdhiJHCi8iiZSzT4hsqzaeyUMgTIQK5O1VNP85PnshhbwFCWB/xNzvnTzTKv0XZUG9ARxfNP/D0U/rjAINNSX8NBQhtHba5/h5euyt/6C1UXTS+N62HchftldkTtiWpB2Um1cbxvxbIj7PiBwBlxQ9zsMyv3Kf++XGui9ySN2MFJknUIZAw+ckNQNL9nN7dAb/ijJMlmDweiC9SYx6+f4WNOZzooCT+1H23tUxz0+JuXUOcvK1xPVSYTEn6zNbI9MjA+oU8fkI5ICZIfnOI8hwXcZMn8HmBArO2R7Jdz8gqMI5aQPKrwN5OwMZM7Ni67MiB95VRY/bSPTpkdgf12EI2ea0jnxdDsm+hWUaouCP61Hkczb370QR+BNmfUAOvYOK2CNHsF/ZWTwuNaPQ77GvXkNg3aNAnfmAmWgNtdfeWTLjUIOI+z14mjHZ9y3W5uvIkPYqNYP0A5QAIrgD31UfpA++TVJzsN47QDV/fqQmt3xLg+olxP9/JM65XYGpUZZkC7AyreWndjmTGTkH99xFv9vh6Ge2L16LdNC14/N0safeFX26AOlJzZCdXWoeh/F9bAA8nbvXB2WsXYGQJ1qQbLQySSBRmRs1aMh5qDk1M2jAWWLvzVADuiKo9v/SwOx6aufx4khmu4bWAX3Z/W7IjnMWcl5me+NHwJEdxRvKwvkewVzvhODUL0HOlywIa85YC6sgOaMFZRw1VOYcQj/GRPrIAKRrdY89dzEEDXdJ8Jw5IX9BstB/aEDwZGduhTNQtVGjIYzx8eL3LWJznz+5fzjKpGmoIQV52lvyhwqDR+DPidI4W+jAqAdq2TJ75q73jsPnC+Q8uA5l07SQGDmrVnt/8fPfMWZZMfiHaF0/pkciiKQRhN/Hu8gO+DGQseYLlD11KgVnwwyp7yjy4j1qBoS2sFcNpaNeSUSElrEh5X0hatGbT4awkK83kV+3TasAdIaWrKmpkDNjH2pRxtm6W45ahuBHyFk/PQ02dKFIxLeDx/2pGcsPSp5ZGBmPnog19gQyAExd9vlGzSC3KCpUmhm4zkvXPor02gQZyn6hPIqCIYWgBTmcD8rvWZQs2pI2svRyZ83CKCjlZ6Tg7FPGeZTw/DeMF5JF/ksN3mIq4GHg8KL5rcN/dpbPgIIWeuTuj4cCcP5Ezv/taWAEKDIytKCIW0Pyxp80YRZ0MlcOR7LXb8hwuDitjbR558zCCB7l7EbxmvFRh5crCRhaFPHfgowo2TyaHUW/Hlb0eI/Ae7kZGapOQVkH50f/1q6zLjp0L4p9ZDIU0PQtMk7tTi0rZjQEJ7g7gjA7L86ncYoezwa8rxVj7XwALJe+k+RdjgkcgAxou6CApEkaOJeWibNr3eTeMwiCNjsXpqaB2X50Igd3nKnfIGiyPJrHDAjZoIVc/dMyNKRfT4cM+mlmfKnktGHsSxrEuE+sycECT1AQ8noo4LcF2L5o3kegr2/GmTBRcm185Pi9CwXLbYCypu8piMf/ArcA08bnuucUQj+YCumZ66Ls0HZ1HFCTCY5B9qHBAluRTntNzIk3gX/E9QmQzrtp0e+9Ds+XoYCI+XLXd0e64c7I6XQA0iePKJrnZm+FM1C1UaclG9cKKBJ33fg8PTKW39FAXjID1dyxSW7RxnPdaa1ErgnM0wH8pAf+AShVcMPk2rzIaLkHNaNIb0rqGCiyJfNsiXi316KIhRuopYueTOtaPaMl3zsdQXnNnc6V+H2W+Hvfo8iA/Sm4BkMbY3A6USR1GJ7tHcLW5vm5WKZGrej69cho1h8JjrPRGpJuIWQs7PRKe7M0FDn5eiaI5u69jaLLlow1OhAp9UvRwcpbTpj+iqQwJBLeP0WQFylG9JIorTtzzmTZdaVVNGkNM/IVUhwup2aMuzVdL0iZnqPe+2oAr1OiwI1tgDnS9xS/T4FwjltinmxJEklctsbg8C1d0p/x+1jAGtQCPxqGzz0EvmdGsGT/po3Cu3H+ZTAysyFH5YAi5s1w9OuCWLs3AyvUuT8bUvZbgFMazNu9KPpwTSSrHNTI/99BfepLLbLyU+So+b/kfpfkuZPjuSEaWtqRtx4kkfPIQZCt1y2RjLEK8BJy0mSZ1mMgg8TPNEmmerL/LIgCJDZP7t2HzrlJ4/NEdGDWHoKZ3YjWmY3ZmXMJkgGeiz0xD2lWSvm0g8apNzU4rgxGLstmGj1+HhDrqpDC7sBuSJ6YNT5n62bh5JnzUOb6YJktHcTT4nQeB/cUSD/bLz53o7VO2gcZSM8rmteMv/g5O8oMbkEy50sxV9M1X1qZOfgbnTqyJapZ8hswcxvf64rkp71okiyZhPc5UXDcKnXurY1sI4Pivb5HY7NksjNsLSQfrTa0Z+P3fKBBu50hCU/TINn3QCIrONZqq4APBJf/KwpeGqPo991GnzKZbE4UnPcKNQf7eChw4vL82Vy1dhj7ohmo2qjXUOTEKyGkXYngDX6jgEh9FGX0HhFBQxsp3yHYzUoDoreR5/w2FB2zWFy7B0UlTBefSy3MlKEhw/xdwOTxuRdSsG9ESsOXwDbZ+42f04awsQet4XFWoXWh6eVRtsZ3yEC4NSWCa4mDvwVYNutfW4IIcmK8AWxWNN9D6VMXFPEyAYoQOyYEsy+RcXBi5OC9AfiuaH6r1urdnYacL3kIrSWQwjlXfO5HrWjtmR3MU1r4MXN4ZwplVpj9TuQgHz39Tvw+E62dgaU3FkV/ngbmjc+LIkVii6TPExXAV6YErIsirjKogeep45iJz0sj5+wAFNQxSyN57qBxmJICC8JSM0iviZSxFqSA/0CdjFxkSL2RmpL+Mw12ZIxAH6dGRrq3ULTreYShM/fcmtQgTDvaOZDtRavHOH4DfFT0WI1sn2gN8zonkplakMF9e5KIfiRj/T1/aICMiyKeW1BQwLh17l8dZ0MLSa1LBLn1IXB50eM8An3eF8HqzB6fV0VZBcsl+/AZKPCgQ+qKUXN6rlrnXm8EX/dw8HUjglIbrLjwqNIQZPJHybn4OIIM+wQ5G64k5/TvYH5SOWg9pL9n8sOXMX8ymWlsVOPmARpohKQTOLiRzjMmgrF7kdYwdhnEX08UnHIDJYIOQk6YD1EG3DYI+rEFZThs1NZ8KlNDiCT3I32/b3J9zJhTO8fnVmgb2Xspmv/hmWfZnELQZc8Q2RG0dgD2RIHM2yCbx7QF8Xsokt0y+azN+YP0u4vpoEyyZN+9F+lWU9fjKTeOWcZ/6YOqUXDiG3EeT47sat8hyMy/M/6H9h6qNozjXTQDVetcbVgFQmRQeSCEjUdoI1Olg3i8lNYR0WcD3+Se6YmcR2sg4++9KDuiUZE+PRE+42soUnUQStlvCuzqolpyOIwf726wdHWUcbEtUmyywmUZpFJ2sE6VPN+PWtRVPuJip5jDpYoORlEbXyOjZgrX1oXEQYOMajvH3J6+aL7r9CMzEk6OjAZ9kntjIqPyVUgx/YAa9vgyRfNetVbv8WIE/deVHKQTuaLOIUS/CRzSIN6uoo3shODj7Pg9m4ulg5Yaxn5OgxxM+1AzmDyCHBoZtOhESABfpIF8ZXtRXxSBdSeKdF0NGeVOpFZEvk/6nfh9z5hbpSmUOaJjUAYeQvb4DBVuXhwZSN+hFrgye8yTCeLzeAjCZn8UhV8aw1CdPqYRiwsgY/xHSAY4gIKzK2Ms3yYJqGj2xuCRouujaNuswPsKKJjiWuT8y2S4RhiX56YGSzsA+Ffu/qxIP/gKZZc8iALKfovf+3Q0jx3Q502BX5LP78U66B2f+yAj+j0d1T+kW51KrTjw5iRO9Zgz4yPD33soE+AYFIxT+F7ZwHeVD0TYIdbM08ghcz2qZ9mn3vPtzMuKtA5M6xJtaqRrnBXtCxQ8lZ0ni6FMngMaNGZN7eCmZiDvgSCixge2i75cjYLo0mCguWKNnFYi3rdBhtuVk3sfoaLwL1PLzl64CD6HtS/AIUg3/g5lcf7tHEby0W20NrZPimShM4ELiu7DCPT5+NhrfwTWSa6XKggYZQ/+NBzPf0QHZJ8ne83SMad3HJbzCdVNa6Fk9Xvr8Jmt5/WQzHYrsq8cRFKPtGrtOOZFM1C15m60Nu6Olb8+pO/E7+N0pCBZ538vhww9n6EIySkRjnWG5b4lwlF8lVrhxEEh9BzcIB7TwtPvJ8JYpsCMMkrJCI5fD6Q090fGlunjejdaGwdmCEHroPicHqzpc+egqNrUUZMKYuN2xIHfDuOwFzWn0wbUiVJDEFHvAJcVzW8d3tJ94k4UKbZSnefGQ1G2WVTTNkXzXrXB3tEOMRcXS661Wo/J9cWQY6DD1xRyEp2OFK/PEZzXQnFvA2SIW7Do8Wunvo4dfdwyPq+PosCXpLUh441666wD+crOu6tjL5ozuXcqUgTuQIafX2M/niX3NzKHWVMHLRR5tidjeD6KcJ0vubcPMgQ+Eu/gd2QcXLPeGi5zY3Cn8LoIFjOrObd1we9hIXLOgc7QyBl2EIzZIOAnFKDVQi1zuWHrGGVQL43k/kHIgLxWcn+cOAtORZk+/4k50uF1Ozqov3Miw9ueyOj4E3I+ZfvwfLEPHxWf23Ut5P8etczY+1Gw1LjJve4omOBolEX1DR0Iq1bWRuugldFiXBoGHYNg5QYhI/T65HQJZKTL6j1eRM3BtyDKivq8gDFrSgc3NVnsDGSnyODqjo2+vA0chyCc1kIQut+T2F8K5r8rcDeyr2Q1TfcLHqdDUOzvIQd8C7B+0TwPpT+TIZnorxj7PVEg2QFIJtoUOSNfij2qBdXr2qBo3oejj1kgxK4oi3VAnAsphL5RkowIBH3ZQpzTDEFeQHC0bwC7dCA/uyN708dxhtUN7knO2GmQHL15R/HUAX3cOOb3/8jVmKlaO45z0QxUrXM04CTqFDUb0uaNInzWiN8b6ZhZJQTF71Ea/0XB+4+xsX6LsihORB7iwjIIkDD8MorOm3loY1o1JwSmY0JYzeAPUpiMbrnnMyE4PVi3Q8r6rPE3tszPUXJF5cvYEL5pSwgAV8d87otg2tZDmSVvUcKIT2pGwv1QpOpmufuDZa2hKO9qfZSsoeLxH8XaWjZ3Ly1a2xelR39LAyNxYp/9T6yTN5ER6BsSnPZGnlEd1McxkWPzRpSN9DFSNrMo2zFQBNpHRJHlBvCUKSlzxT61Da0NUOfG9btjXtyNHAJ/KwbkjOxVG6n3MEOM9/bIuJJdPy6u34iMEufE+vg8v57L1JIzpA+tnX1G62jjcRA8w0exBwyGp17E++iMLbe+J0TQSy3Au0WOc8yRdZFjLoOImj25P1r8bBpYmuB3dFoHuBjSeX5EhvbzqEV/zxBnwk/Uale2y1xMzvjJkDE5hQfeHgUPfYmKIa+amye9kLOydMFPDXyPluzHDZdxkQPvPeS0vIAEDih4OxAFefyGMvRvi3n0ZlH7KU3m4KZ1kOvVce6m6ACLosCIlqQ9QeJELroh2fJJ4NJkbnyDZOoMkeIQZCg/pVn205hL2djfheTRLGj3NZRtuAdyape2jkzuLBhs7GN/PiLW+W8IFu8fyf2uRew/OR5nQIEF95Poifn9EemW6yN9cvEO5Gc0FFxwK7IXPYUyC9sqh7B27KWDQQKXrSVj2gXBxv0AHFhvPlWtHca7aAaq1vwtFusGKN29BTkRlknuW/53FDHxPPBjQTz3QNFuTyOD78AQbhagDRiURm8+1KCmNkcK1OWU0HhehpZ/N3FILoGi4H+Mtld6aDN4xGz+YH08hK2HGAK2dtkPpRAS76MmxP8c/WtBxY4XL5rHIfDeB0XIH0VEn6B0/m2QUP9fmijaZFRssdYMOT1bkBNwB2DKOs9uSWQtNoi3VgoGgjx8ASlaA4CDSaJCKbmxlJoRegbqRE4i49evSGn4ltZFrpdBkCgNh8FA0XkfAjMk1yZFSuFh1CJvp6DmaL6m6PEezj6W+pwIHrM6aan8Ng4yrh1HzVDbFxlWf4g9uNQFPxF84nuoKHWKy9+VmrH9yJiHBxbBY2dsbe2X5AJakMHr/+L3RmbJpPtlVtdsOuR4zKLsL6K14afUTmBqOtaMwIXIsT1j7pnu1Bzen6IsoeNRkNpn1LIp2/VdIJ3mCiSDbpa7NyY1KLkPUWbS/EWPZ9HvsUwNwVaei4zsryO5fLbk/hQI7u9+pD+dRp16XQ3mudQyW713DiyC7CmnxOeetHYgz4OCSxehBMXC83M19tOs/u2aSIdbNrl/QOyrhfM+An3diFp9p0+iL4PVIyt7Q7auZ2I/HpPBdaH5kM3pSxR8cwKR+VSGhmDXW1DAclv2xjmAx4BHG8RTH5Q59SKysVwdPKQ89UYB3x/SZBBgITdchPTj3YrmpzO2whmoWudpCEd259gkW4CbsoM57v8NMYKUnhYaBJOCosUWRVifcyTXJw3B8s04eK4jiiBnvBY9rsHHbshIeEMzCZkFjNPCJPAGyKC0BoqCb4n3vPJQ/kZ2sD4V33k0nTPN2hCUwHGoRtHRCMu9dIpfjuelkQK4WnzuilLFf0dRS4/GO1q3aF6rNkzvcy2UofEnUjoPQDUqlkQO1K+BOwvgKzUQdkERb58go/NNjTqn2qkv41FzuC6cP8OQ8fkP5Kg+CEWH74aM1m/Q4JogKIvqYRQYcReBM44UmleAifP7VKz7p5FzoLR7WDOd1UgxvzPmzjPIQToWiop+C0G95rNFb0SG3PFK/h7WRUFA36AI7lZwnrHm90IGxYYVzO5sLRm7rtRxutd5vmsjxznhbwwSAxNywBxNzUHXFcHsnBhnwG80gREi6d/0IR99g+B402j73snvSyDouP8hZ8zddEA9PmrBUMcgg+Y+6T1aZ8VMj5xEPyHj1j4keuSo1ihBNj5Jlk58nj/myg/I6LkrrdEISgGl1YwNOVoymLLrc2ujFPaIIfCe1jfKoK4WR7LdOvF5ipAbHi+a36H0JTWkT0frOkl9EYLDL8hudAyqT1baenrBd2aDWxHBrb2JdLLRk2f65r6zDgrq/CZaKeq1ItvOKdQCTc9HzsquSB79B6r79gU5uOOOnjco2+jgmBs/IZ1rkri/MELp2bfoMUx4HqoMlpzhfVE2awuwZNG8d7ZWOANVa/6WO7wsDqejkYd9ADIEp5FmCyBF/v4G8vhvagr5UnEtH3lyCcqa+Tw2+1JhRqNoz3uK5qOsDfhnHBRnhyA4WnJvKhQl/lw881gqiNT5W0YtKvszZMA8kiTKtmoNeaezoYiToxCExSWxrxwd92eINVtFN5e45fbaWVAU7C+0hmH4IwTZKQvkM3XOTIxgmn5ARqvTaQIsXWDvZEz7h7Iyfa5vy6No1nT8L6aAyOTYa2cEdgm5oD+CF/2LOsVGkfPgjtjLS5M5GvN6JWCitG/x8180iQKDInD/i6LhHkYy3PbJ/czY0i3mzFs0QZ2HmGf7IaNwBsGzQtybG0V23100n83cqCnupxK1SormqQ0+twSuRcapf8XZsxiDG5/HRMErmRHiE4YgN5aloezux4Hl43MKi3RK9L9f8vxUKAo2NQC3i5M1+d9TJmd8v4yf+NkL1bpZisjqQcbpR2IfurzoMe3Ad5XCw0yM6rptCCxQNG9t8Zp83gihCXyNDO3r0FrvKrUToYwNBZBeRU0uu5TI4kueKdxRV4fvxalTvwdlVz0VZ+75yAk8gJIY94fQn0ze3AWhv+xZ55npUPDQIFSHa/v22jc7uG8fIYffnLm+ToZqGf0zdz70QXrFy5QoWyZ4W4Na7eUs8PbL+P0lYKOi5k+caRegINJ3Yi5dB3xc9LjleY2fhzMMAchxNj9QNN+dsRXOQNU6T6O1c2Z0BIdyOYqK/iwEuDGoFaxrSPQTgv/6Gjgyz28dIXM1FAH0NfJmL1/0uCa8dSWJcqta3TE6MwS+T1AU+Gy5+3Og6Mfzh2PM04P1XWAzctEkzdSaQWhMeM2MCP1j/Ach6Kux434Gg3h80bxWbbjfbT9kHNoS4f7+X9E8BV95w9yCyAnQQgMDCUaC/yURtMizyJH8cZxne5MzniNHwpLAtCXguycyjmep/S2xh4+Ve24u5CQ7Nj4XntGADI7Poci8qXP3xkeOiyepFe0tnVElx/PoMV++iPdwLoKzSOtAzB7v6ayi+W2jD3XPOZQdfQGSST9DBoofkJN4lmZ4P2VuyMD+MII7qVvwtuiGnNLfISfBn8hQMkFyPw/lMgGqM7hb0bwPoU+ZcX/t6NdaybXMkXpQrOcfYg38k9bO+g6TDWM+PJ8/55Hj6yZqRrWvY7/pG/f3pcR1q9phXDKn1cHJufdT7Ee3UILAA2pGu4Xr3OuJaoT8L/bSM4BFiua5GVtuz5mRGuz0S8BOtIbeLJUeF/PgodhXs1rB2dxeEWXhvofggXcvmt+h9CXbN6dEAZnnEXIddeRN5Ez+ANijaN6HoU/HhNyzcJ17N8R8+xIFMs9O6yya0mTAkZPRgE3iPd2AHMQ7UQJ7GYLFXwEhQwyI8S20ZmHC22xEECQKSmkBNq43x+OZidq6V7X2admGWVFF7UZmZh4Ty8wmQBBEW6BIirdRdPtZ7r5TI3hBmS+3AIe4+9dm1sXdW3LPdXP3QfF7b2BbZChc3t2/7mg+Kxo5St+pmU2OIK5WQIayC4B73f3juD868Je7/zkcfz+rN7MrUmRfAf7p7t+3a0dGYaq3LuP6ZCgCvSfwlrvfHdd7IUfv6cBi7v5MI/mtaMQpPSPKSvn5aGZboQin+8ysq7v/VSB7QyQzWwVhRd+LIvnWRFGs/0VZZ7e7+x/Fcdg2mVk/lE27KTIsvoIyb29BzoIjUKDFOO4+qK19o5FkZnchJ+Mx7n5rnfsroeyBt9x9xeR6qddB7L37I3nofXSW3oiyE/dHdaLGc/ffCmMyRzn5cyJqRuo/gCfc/cO4Nw+CNRsHOfxvd/e7yjCfmpGycQ/561zkwD6xzONpZp8gJ903iOeb3f2l3DPdkXGnKWQ9M3sQGfV3cPcvsvE3s0mQ4fBYlAW+CTLOXQxc4O6fdCBPhsZ3DnefN7k+O4IwXRtlxdyL9MSlgZPdfc+O4qkMlMkRZrY4Mtpdic66iZCj6lVgY3f/vDAmg8xsLFSH7kuUOXlr7v5UqBD0cijLdU13f6rRfDY75WUCM1sDBaZNihwbF6G99ediOByckr1/HrTOuyBI6beTZ3oj5/YXQP8yy88ZmdnlKJBzPXd/PXcv63O3kENLrRMAmNnYKGvpdmQP+zXZg/4Z1/dBDsHNUXbTicDVZZlvddZHarvL3kUqA5ZCxo6x3wQFf+xfAn7GRPU6t0E61RZIP9zZ3b+o83w3arrkCpkdpqJ2pqK9QlXrnI3BMeCnRzj9/0VCXUOwN4Gt0cGy9DA825UkypUmzoYYFRuCU0nhF/6JnIADUTr46oxk5CbC2N+dkkYHN1tjJKIuYm2/A1xVdD+qNkLvr1SRfkPgs2mi5tMxRRl9rwJbIfiBDVCtkBbk4JiXEsOLICiXjVDtmKxG3Y7ArwScVhn4R9CnvyIlNoUJykfy/QNlcO6BjJAXANsUzf8w9nF+anB3jyIl7heS2hBlabSGHclgLQZG+y9yJo2efz753BT7UhlbrIW3UW2qU4rmZyjzowsyIB6HjFFZRPqOwFTJ8wsjY+icRfM+DH2bFGVJnl7n3jEoU6VffJ4TZTS1AEs0gLczkPNzivjcLxn3g5FzN5OxH4w9tTSR2R08Ng+jempTxufFkWNjOWpZTlsAMxfIY19kwHsg3tlDBNRc7rmlqWTy4RnXtA7X+MhWUi8b41+xflqAk8t6ToWs8CXKiMmyS/L2oFLynuNxHJTdfO0Q3lkvFDjUFAXbUebLl8BOde49Fedcb5TdsTBykrcA0xTN+1D6Zck7Ke3cCj4L11mCl24o0PgyJBsPAI5Kec093ws56AaQQ6CpWvu1KlOmonahtrzROY91VyRs/uzuzzWIr3+hKM8F3f2TIfDZBR1GVyH84msawV9FI05JBOC4wHfJPOsODEo+X4u8+z8C57j7QSP5fw0p9oNGqgMVAX/vC1cgIf5N4Fd3f8TMRnP3/rlns+ikpZBB5UMUxfRdwxmvaIhUJ9OkzBHTBlDvbGgmyp23owEnIWPOxu5+vZlNg/bC7YFxUZT0yR7ZA2WgOjLDtMihvkX8/o67z1ggi63IzOZDRrXt3f2S3L2xkCI8P7AQgvH4ARm4uiBD7yuN5HdkyMw2QBBIMwKfuvsUBbPUihKZYAaEf34LkuneRPN+fTSHrgEOc/dPy7wvNRuZ2YIoI2zuuLQNcIu7f1scV63JzLq7+0AzOxc4091fjesrIAfNLNQi0r9GTtT53X3iongeVors4W9Qxt5RuQzyuZGB7TWgJdbJgqivy3sHZzXE/78XBck9jubIfMCl7r557tmzEMTc0u7+XkfyVTSF/nI78Ki77xPX3kEOtG3d/ZfIcroX1VK8sjhuIfbWVdHanhrV3dvdhwN5oCJRkqUwMYIL3Qj4DQU8nODul+aeHxdBwt/m7mc1nOEhUJopYmYrIv3sBTSHv0wzGpqFzOxplNWzeGQKtOR0mvVRZsn27v50UXwOK5nZjChgYiN3vyo7C+PeREAvd/8geX5vBAO2iHdgJuVQeM5kutmQo+zhZtfTykSRDf8KCgIYBwVfHZyfz6HL9EVq8scNZ3QUoS5FM1BR56C2NsnEuGLu/pe7P9Aoh0xQTxSR9U3KT57ioP0V4dWP3SjmKhpxioN6dlQDaB0zGz+uDwzDfc949GwUvfkcyqwY2f/rzSZclpz2QDAyxyBDyLVm9gVwhZldZmYbmdliZjZDvNduKOJ/dxTxUzlkSkKZcwP+3lMzQ9Hfn4uklD8z62FmPc1s9FjTHk6ApqEIJsDM+kLr883d+7v7Dghn+WgzW9Ld30f74XrAhUjhWr3hjA+Bcn34ywWBcSqCMzsbGdazdPoy0BfIkLK9ma1gZuub2SFm9gRyBtyDHBljI4VnLFS7btJmcsgAuPtVyMF0KDIglYqSPWZ/lCVzuLvf5u7vuftxwMrAzcjBt0buOxWNJLn7k8hguxWSuU4HjjSzucNJXBiZ2fxmNlE4ZFZGmbYzZXuou9/p7rMieWRBhE1/O6qNuUlRfA8nZYWO1zCzsUJG7grg7i+4+0vuPiiud0PZMt+g6NcOJXd/ATlaDOHWTwvsBewGtf08Mf78guDVOjv9jCLTJwMws30QzNOJ7v5LPDNrPFOIzcZEPQDiPD4JvcMzkXPmczPbogjempm8Bnd1ATpPb4/ffwEuNrOXzGyR5Plv3X35oh0y2Z5iZhOYoPdA6zqju1A9w5VR8XCaSWfOzgTkVJrXzJZP9s0e8UwvYBJgPJpnn/oV1X5aHWQrMbMu4TD7IueQ6YFk1W9QLdeGUKajmVkfM5s0kc9uQ5kdhcoRnZB+QpnvmyAH49TA42Z2bjhsMLMxgAORQ+/LohgdFajKlKlohCiJ8FgVpfqfUjRP9ciE5X4ritY4Pw5br+ecMeGhXgSc5+6nN5jVioaDkuiJeVGR1vGRseV84Hl3/zV5NjMirVpFc5WPzGxN5JC5FEU2T4qco4sjASyDB+qCCok+j7Ctr3T3NxvOcEVDJTNbHsFlzYGMc68A13mCMV0QX9m5tR4SQsdFSsodKGJ3UPpcgawOlbKMEjObEPH/NvAYini6F2Vk9EeBCXciSK21sog3E8bxHO7+YBH8jwiZWe/EUFUaMrPVUJT9pCjN/2s05q+gQIDXXZm6/0CGl3nc/dOC2O3UFArkFcDE7j5fXGsV5WpmdyKD9PRlnE/NTmHQmRwZbLdDiv8ZyNHxUaP31tjrjkXOosORQ+ZW4KAsqCPbT+P3MZFzpjeKzL2jkfyODJnZoQgObI9MLwu9x+Lsy2TnyVA0+5juvmgD+euC9slBHrVSclH2SwHXo2yf4xvFV0dTZEOM6e6DBYbFO9sGBR5ci9bK0e7eP7IjDkCBFNO5+2/pXO1AfjNZaTx3/yaudYOagT0caLshaC1QFtRM7v57R/LWGShZhyug+b6jR6atmT2HdJ8ewHRIN9rf3UtlEDWzh4FFUWDKk/HzMZSl+hWqBXoqmtMHe5PU5crIlFl+AzrLTgbOTdbCWqjWz+3uvl1hTA4nmdkpCNp1N4QcMiCu55ENZkMZxY+5+7YF8Lkdyiy/BNkAdgCWi8CPijqAYn+fDwXJboKccaciHXJH4FR3P7QwBkcF8hJgqFWtORp1sBqBZ4FL4vdSYCXm+JsQeDfanMn1Liiyo0t87oE2/Z+AWYrmu2ptvs9ZgMly17qjA+Mr4DtUKHNOatjh28X1wvCYqzbU97o3ivLcM3e9NxIMvwBOQIXmvopn1y6a76q1elcZ9vlqKJrmI+QkfTPe17+AngXyl+31UwB/Bn8Pxtz6DimTqybP/30+lLkhZ3QLcsZ8BDwRv7+EnDP7IgjPlujvJEXz3Na7adYWZ9DMwGzIIXBznWe6ojo/7wNzF83zUPpTWlzuYeT/DBSBPls6t4hahiEjfAlMWzSvzdzSeYIc3LPRul5PF5RZdX3sua8guNFG89kdGQhvoFZj6NDkftdoeRz17kWP8Qj0tS+1uh/n0rpOZhaIOTrKNB4ILJqNQYE8Z2fzQshp/WrR49gBfbw43slKde6NjYKN/kIBSHNmshKwH/A9sHej31Osm/eC9wlz19N99Tkk6+1c9Dg3W0NBhTdQq7+yAcpcWwwFpn0R86YFwU4VyWuX3M8VgF1R5tR/Uc28QSjT511U32ogChCatOixHsE+r4xk6V9Ddrsy9qjv4nqvonkczv7MgZynf6BC7zMl9zKbySTxTn8Dxi2IzyVRBtKAaNcCEyX3m1pGLXNDGVIrI7mtf8yD/xTN16jQqkyZioaLIrXQvBZxeBSwmrvPUixnbZOZrYsyYPqjKLkLPcmkiGeWRR7hF9x9w8ZzWVFblEQULYVSoscEFnL3n3PPjY9gYrYDPkdG1rGQone/u6/dWM4rGhrlolMPQMbjAzxwsyMT6glkWD7XFSXYG/g/72AM9IpGjMzsI1Sc/Uh3/6+ZbYggtJZDWPJdkKD/VUH8nQAsgAwIL5rZ9Chyek0EdXkPcKw3AbSUqX7WWajY6CcoW+Y+BLuwIoJEWQw5N7sgo+i27v5REfxC6zXfGcnMlgNuRPUQnkyuT44U3WndfY6C2PubcntvN3cflItYb7paK4mssCpyVt6IIC6/Su6NjqAYNkOZYt8UyHLTUhJJPw6KvN0CZSz/gYyMlwJPuyBSxkb70EnAKe5+aoN4nAL42t3/iM/TI+P3bwgi6hlgFw9I5WQdzIAceK81gs/2oiR7cn4EHTc3OhOuQrBILSjYYH8EM3efu29d9J4ccEgLIeP/T8Cu7v5YUfy0N4XevBAa82Pd/TszW4KkPoKZzYHgRNdFRux3EZTM2MDd7r5u9rca9a7MbFqUAToXmjdnei57KTKArkFwa/9pBF/NTBk8U6zTsZHh8yt33yDuv4Pk5J3c/Xcz2x7Jp8+jOmilhcoys1lRAfGFkPE/M+7e4u7rFMjaEMla197qhZyjY2U6SrynXYFFgImRU/tS4HqPmmTNRGY2M8pA+Qeyk9yO9Ia3EazkkcC8wL/d/eSC2AT+1icnR+fCBUime86TbNvIzJ0U+NhLjnDQTBQ2tXFQoMcH7v51wSx1eqqcMhUNE5nZYUiAfzw+ZwrZMkgBm8MTPMoyUQhB26FI+14ozfYKFEU8LsLr3Q9F8i3s7j8Ww2lFeUqUzK4oKuV74Ah3f6At5SQU6kOQYPgzMkTu4k2WOj2qkZlNgISu+RHM0iNmdg/C7F3X3d9tBlipUZnMbBVU92Nbd789YGDeAW4C9g2n2iLAhsB+jdxrE6PsdsAC7r5p7v5CKONuKXQW3IqiiQeV3YkQzssjkZL1GVpHF3lAM4USNhHwpbu/XhijtNrTVwb+iTKXbgUeBT7xgFNoVgp54wGkSJ6K5v6kCC5idWB1d7+rMAaDkvWwCrAOkoWeBx5CRacHps8VyOpglHMoLQX86u7P5J7ZDvg3img9Ehm6fkIOzIOBq9191zL2rxkoWcfXoz3zAeADNI9WQsa5Y9z9hOx55Iz/Jv1+B/I3N8oMPAw4w90HmAqmb4xkwnmBLdHavBwVK/8+gj5OiHvdy773p5QzLnZBGWE7I71nIFoL4yMH/QnAUe7+UxnWgJnNhzDtz3L3B4rkpaPIzHrEPJwL7bWPoiCkJ+P+lChgZHE0P/+LjJCPuPsPRci/JjjI1RB82gLAh2hd3xT3V0AG3p3c/bpG8tZsZGZ9smDC5PxdAGVbPGg16L5tUbbtIDPbC82HLQsMZOqKbCYvoMz3X0M/G8Pdf2vjO93RPpNBh/7RMIZHkMxsE7Tvz4LW3jMI1viNuD8+0g1avElhT5N5NxE1eNEJ4nZ/BJv3BXCcu59WEJvZ+dUN6TJvA/+HHNbvxLXbPOCwTXWNDkLZhC8VwW9FFbUHVU6ZioZKISi+jKJtLwf2yTymZjZd3NvK3a/Ofa8bipbA3Z9vAJ+Zkvj3T5SOmeHfTgmciCI3ulE7gEApxKe7+xMdzWdFw06JAHEisDYy9t6Vu9cbRYQPAH5z9y/i/oToHf9ctMJZ0bCRmfVEa3FqVCxyDxSBe5U3UaHIUZVMtWSuQ1kCT5uyUjYElnD3t+KZI9BaXtULqDETitcWwNIIaqGHJ7WmzGwdolC4u6/VaP6Gh/JGGlNW0r7A9EihvAS41gPjvQwR0RHMsSAy4v5J4NCjyOCzUUHPjxKje9Nk1iSyx4oowngmlDkwOqozc567H1wkj9DqPcyBIGh/QNB3cyCn3l3AFZ5kI5bBcBt8ZGPcG2W87IVqKu3qSQZY3F8FGR0WIIwpCKbqUWBFT2psNLgbTU2J7LUIcD/KOjwv7vVB+89uCIrn38CBBRiTJ0cBY/e7+wFm1g/4MzUOhhF0veCzC8rk6YIcGXu7+9mN5HlEqN7+aGa9vJYdNCnq32QIzvlF4CF3f7qt7xdFZeKlPSnfrzDuroZqHM2N9OqDPeq9Jc+VJgjJzKZCDu01USDjG6ge36Io2KO0aBllIDMbD8nG1wCX1XNSmOraPoJgym6KQLV/IWSIORvKcGu+9kbyzF8oMNKjPQH8jgJc/4fmwVvp/hPfL+26tlp25Mooo/A9lDmyAApy+hBBZ53r7j/Ed9qsTdxMFM62sZE+Nhuyl7wD3OPu7xfJW0qJvLEYkifmQcFDFyG5ejdUdmDKwpisqKJ2oMopU9EwURjb1kZCmaMU7GPi3ovAM+6+fQgV0yI8yCWQcXUTd7+iATyOBfR2FdQd3dsoNmgqtrswqiNjwOOVM6a8FILpUwja4MT0vZoixE9Hh/TXCNv4IhRFURnxm4gSwWtBpKROhYThzdz9zzIL9hWJzGx2FJ28GTLW/YiK1J4R73AiJFRP5e4LN4inTOlaDBmnxkeR3Qd7rRByV+TAz4pejgVQVHTq8JK1hp3qgRwz26GggwcQZOc9BbLYiszsQeRE/xeKgpsBzZNVEZzC6Sg6uGmhpWKub4aU3kHoXPrIIwOlDGRmd6A5sq+7P2+CdzoYWB7B4d2IMkrKpKBnTpmzUATxTe5+UO6Z6T0KapsgeGZEMt9oaH961t2/bIa1XWYyZdBvDSzv7q+kZ7SZTY1gK2cB5nf3jwviMZsvjyAD4nHAyx5ZmmbWF0Frboj0lkHAXe6+fhH8Di8l/VsCOZjmRFkYzyB0g8/juW6VTFweiqDF6YE1UD3T0ZFsdHLiUGuozGutM60mRxH0kxCZOnF9LiQ/LYEMuXeg7KbSw70WSWZ2HbKfvI1qrVzouYxZMxsXwedOBpyG9s61gO3d/YLGctyKrzWBYxBk1y1oTsyNzt/RkP79K3Jof4T08AHABd4kEJAm2LiXUK2xN81sY9Tf15FN60nkmOmU2WDNpF+b2RYo+3lCdKb/hYJsHi+UsYoqGkmqnDIVDTNF5OGqwKZIIPsARbJPjSKLDRm8BqGCaI8BT7r7JQ3i714Eh/IIqinyGXA3ipB8zpU2XikmTUbhRLsd2Ct17pnZaiiycTL0nn9FjsOX0QFdSKp3RSNPEcF9CdpT1nf3N5pJaByVycyuQOfER0hYnitR9DdCxYe3bZCjPjNY9Qp+uqOzYQpgDBQxv4e7vxjPdwcok+F8eCjnnJkSwTiugZxjNwKXe0Hp/cm7GAc5KJ509+Nyz6yIIHdmQDAeF5Hg7jcDmbWuu5e/V3RfEuf3aMgI+AMyRKSR3P9EzpmZ0Xl6I8ryKdSBkfC+MHKu7Bt8/WZm3V31SzZD8+ZE4DR3/zT5fuHj38xUJ+J/G+AcYHp3fy+c257s90si5/zSXiAkVazJPZG+0hM5i64F3nL3/vHMxEiW7A986k0Ad2u1jLf5gKyexzMowtsQZN+1KEhpQPqdQhiuaDAKvXo25MDfCPgY2N/db24wH6lD9d9Izx8PBWH+gtbMgV6DteyafbXSqYdMMVZXIpjQTxFSxyC0Zi/wqEsSGRgroBpd8yD47Wvcfd8i+E7JzPYBjkUZhCcm13sD56OaYVcih82S1GCnry+A3SFSnXNsTdS3Xd39znhfHyG551jgZPTuPkYO7428yWF2U0pk86Iz6dM9aDZUF/MvFHB7RbrPhFN7R1QH9DF3f7DxHFdUUftS5ZSpaKiUNzKY0pjXQQLkLMgY/icyprwNvOENLiRsStF/HEVnvAD0AaaJ9jnCVH4cpdi+gaIeBnlghVZUXopI13eAPT2KzoVD5hQk3O4E3BlOt8xIcIC7H1sMxxWNDIVi4khJPRnBGe3ogcVcUTkpEeynQ7U0FkH77UEIAmA9BH3xkbsv1WDeDkBGhu1d2N3zojNsPRRtdTHKFii9IW5oFOuH5LxeDME8/RPtkys1kJe88mtoXa8J3O7u5+Sfi0yfbVCk6Cnuvkej+G1PShwIpXQEmGAEF0MK7YFxrUdqbDCzrZHj5mp336EYTgcnM3sURUhu7e6fJmPdC2Heg5T1nxD/V2WR3hUNP5kw2z/wweGV5kBZzPehvfWzuJ5CwlyJ6iEUbpwzQQgdiDIT3kcZeXcDH5ZxjQ4rmdkLyLl6iLs/YWYroTpdPyGj1jVoDTxZIJujLCX706TA7MCXSFd9K3FyjI/qKW6HMrdudPe1G8hj5uDbG62RO5FcNBeqz7kCcihs5arpWTn3hoMiCOIUVCj+HmRwXgp4C+2Rl3qtsPxkyGbxO/B1kQ6AnGx2AKp3c4C7XxnX5kUwZvsB50SARG/g/zyBPy0b5bLCtgMOBZZy99fNbE+Uuf1Pd3/JzKZAdqW3UGbuSUXx3Zkp2YN2QuM/IfAtcmD+Dzi+DHJERRV1GLl71ao2xEbNeWdAt+T63EjIeA34DRWO7JXc79FAHnuiSLgvgfXiWhcEW7EFwh1vQRv77yga7kuEH9qn6DGu2hDfbQ8UsfI9MtTtig7qv4AVcs/OhIqZHlI031Vrl3e/G1JebwC6FM1P1f5+LzaU+5lj5r3YdwfFGXEWgi5rBI9dk9/XiDnUM+0DMn5ciQILvs72jaH1rxla2v/4vCOwRME8bRjzoSXkhlnbmlcIOmW0+L0Uaz/jI86kcYvmZyT6sUq8g4HI0LZQ+g5S2Q3oC4xZNM8JP7OjiNX9kveRyajnAl+hKOMVUYbtn8DDwARF896MDUG3DEBG2r65e12B42OM74p9NluzUwFnhNyWXSvFvooyE26PNXA/qu8xftF8DWcfsjm/PNJrVk/uvYYgYGdHmTP9keH0CKB70byPSi07h1HW4QfJ+fcmguCZJ/f8lMDu2fts5NmHsoe/QsFQ4yTXJ0aOzM+AV6u9dLjHNTunFkEBSlehrO01UJDoL7EPbVzm9Rky2W3AN8Bice0eVKdquvjctQjehpH/6YH1SfSAuD4JChwg3stTwGWZ3IMytx8DZiy6D8PZ38HO20buJ8PJa7ZGJkC64hVIjxw95LdBsU7+A8wxpD5WrWrN2rpQUUVDp2yerACcY6ovg7u/gBwhB6KDemfgIzPbI+43LLrD3f90pdSeBlxiZrsgw8Jb7n4R8AXa1I8A5kPRug8D53sVgV9qinl0IsJ23RopDB8Bm7pSjS15fCJkIPil0XxW1P7kqvlxJaoVVRVjLpCydZaLnKsrQ7j7u+6+K8LDXip+LgTs5O4fNoJfr8F4XYL2jXGAbmbWJSKy3N3vRsaGHVANjdXju00bNZ1R0v+u8flMd3+oUf/fzPYPWAiSPfouBDF5N8qyPcrMlorIStJ55e5feUALlWXtJ3zsDxxjZvPnn8mdR6Ukd78VyUGPIIPEOWa2nZlNFOtigJl1DUiwn5CSXBb6C0GjvOtJJlKM+y/A0e7+nLvfgZyApyNjWBXVPWL0Ico+ftbdfzKzCSNzJttj9kMBWcugyPqHzexCtMY3QlBM/SN7phT7qru/6soYXAPJjFcA50YmQ1NQMpbTI5n3AwAz2xQhBGR1PnZDTpnpUABaU0JzNit5LZvkDLSP7o6c4l+haPCLzGyPQKDAhTJxhgd8WYPPvllQwMG77v6d1eBcP3f3s4C9gf9D67qi4SR3fwzZUeZDmTE3AfMCZ6JxPQnNh4Zmkg8ruTJ51kJII2cEzN1SKDj3w3imzOfsSShw40QTBCoArgzPDE65F9ovx3P3X+PajCjgc7IG8jrClOhl3cxsKjNb0QQlWhpZOk8JX/9CyCgnuvu7wFjAgsgGdC2wMvCgmV1sZuOVRaaoqKL2oAq+rKIhUpJOOCmKHngZpa6+Zq3x68dCCs6GqPjblu5+cQP5zNLD+6II7YVQgfAnzKwfKuD2PIK7+LFRfFXUfhSCxlJIsXnDa4VaM6iMvkjJ2R6YtHK2dQ4Ko/Lo7l452gqmUNIPRBj1LyTX8zBVKTTAaCjD8tfB/mDH8zsRgnGZFilbe7v76XEvX/9gWmCAu39iTVZ7LIP8a0tBaTSElqlg/AvIeb5gunZjDk2E5IU9gd6oBsilwJuNDOYYHkrOmbUQvv6VqB7RYEbOMkO71IG3Wx8ZKyZAUYiXoALhvxfF45DIzOZE0f8Huvvx6V4T91uNvZkdioyg67j7ew1nuJNQ4vy6ARlJzkEQS6/H/WkRVOXsyJDyIXC2N6Aw8sjsb3E+7Q2s7e6ztS9nHU9mNg+qoXhofH4GZaju6O4/xl58PorC/zz2sFZrpqKOpYDNuxE5yq5Jrq+AAgmnRhCAlwJ3e0EwquEYegs5hfZMrmf1ugyt6zvcfccieGxWSmwpXRGU7jGocPzBcX8mVMdtWYT8sbKXrE5GYmdZEGXiTYUM5Zu5+5+NljOHl8xsGmQjWA1lfd2Iava8nXvuJGATJJf+ihxRA9197oYyPJIUss9mCAasC3J2HBBBOaUjU73JG5G97kB3/93MbkbOsEXj86XIkTkpqll0Z3EcV1RR+1LllKlomMjMbkLFkbfJG+NoXW9mZmBJdz+jGE7BzPoANwFzAishIWcPJOQ8Es80ldFtVKd6Rq46huAtUSbUKe7+70bzWFFFnZ3MbFvgbOScvwzhK38S9+oqZJEtsR5wZETuNpTiTFoOBQzMiZTI/dz947jfNGdBLkupOzAa8FdmQC+TM8DMlkVQHLebClGvhPbm7+J+TxTRvR2wJcpmPQ0ZfN4viO2hkpl9ggxoR7j7RyEDTY/mWDdUXL7potHN7EiUAfQLWts3ZvJSmSiCbB5ATtbF3P2buJ46gjMHwkQoSGd8d1+8IJabmixXGykibvdH8MWvAtejc+CLeH5ilAXQ1WvF5RtirDOz/VDtyCeH5HTIZVeN7qqDMJpHZl4zUThZe7uymMZDQQgfuPuGcX854AJgC3e/t0BWR2kysyeBi939fFPtq/7JWb4nihDvA+zgUWutQXyl+2Y3lDGwCoL9viMXUDE10q1fcfdNG8VjM5KpRtCSKIvtKbQnjubuf8T9zVEW52nAUe7+W1xfCdjc3dcshPFhJFM9sUsQ3On67v5GmZ0yuXm+OHAICiB4GdXcujGRTWdB2Z+zI/jWF1GWf8P1l+GlxPm3Mlqr1yK4vLHQ++qKoPIOcPfnC2O0DsW+eCbwhbsfGI7KFxGSwbXhlDkKWBTJ39V5VlGnosopU9FQKSLgnkCRcUd560KwmXKTGYcKNUYkCuTU6AAaE2H5/hulQ/5UJH8VDZnMbJxMMBqO7/RCdWZ2AF5w99U7hLmKKqoIM1sFRdZPDdyL9tm7sr01jcSPyLSLgJndfbwG85kqYV0RZMSaKEpxdHQmHOPufzaSr5GhROHaEPVjHKTs35oacsrknAEwwRmtj+SIy9z98uTemKiY8O7Aquic3rsQRodCZrY2MqRs5oK+y4wrR6FME0MZueuX0bEU63EBZGh4P+tDcn8SBA+6Foog3aDxXA6dzGwHBAd0PYo4fiV1VkZUd1c0n65E7+vasq2LZqaY93ujPehh4Dq0D2WFyxs61mY2OXISdUe6yhk+FKjMcBafiDIYrup4LjuezOw6dNbtG5c2B6Z29+mK42rUo+SsHgtFeq+MjPL/ivtZ7a4/43MfBAN1kLt/3ggDt5n1SpwEme48D6q/NyY66+4A/ovgHw9A2XBLuKC4KmqDzOxxlFH4NqoT9DLKYPsM1edqQRkbCwCHNZOBOWR8R1kYJyP4+h295OgUNnhW7TZI7hwHeBA5L+7MgrTCefML8LG7f9twhkeCzOxF4F0UgPahmW2EMibPoQbbeRJwprt/Whyng5PVstLXRHvQuu7+WNh6dkeZMus1YxBFRRUNkbwEhW2qVu6GUlR/QIcu1CkUhozi1yAczsJ5Dp7+CXyOIlUWK5qfqg3TO/se1X9ICz4PsTAdgiZ6AgmHUxfdh6pVrTO2/DpERp8/gN9RJO7i6TPIOLYrUj7XKpr/4Kkvyti4FhU5f5co8Fn2Rq0Q5gyo8PZbKCr6FZRl8jytiz3b0PbODua3a/L7WMA+yDDxSYz/YmnfgHERxM4U9eZbGRqwbsz5ZePztqjo/APxXnaJebVq0bwmPHeLn6uhosItwLcIBvQRYO4631kCmKFo3ofQpy4IQq4FOQTWy+ZN8sxKCObssaL57awNObePDDn7A2RAmb8gXnoi2OJTkSHtE2BHYKz83Mnx3kKu2HpZG7Wi8WOgrM//Q3VAeiXPLB570u+ojub7wD/jXrei+zAqtGSOjQ08FHMsa2eSFAxH2ZU96n2/A/maETlX3keG6Flyz02K9PlBwJdI1vga+BlBEhY+xmVuMX7ZWftK7ENnoyCCNxEk1gshS7SgwIE+FCyzjWBfd0Py6A3NwHuex9hLD4l5/lGcHwsVzedI9nGxmH+bJNc+RvV0xkbQbNl+9AuqNVY43wmv2Tk3T+xBJ8XnFRAE26VF81i1qnVEqzJlKmpF9aJzIiX+BRSFtpHXanlkkTW9EBbqYsBKXhAebj0ys2WQMPQqsLsLbqTCUy4hmdnuqF7Fau7++HB+tzvQ0wuoW1FRRaMSpXBfASV0ChLyP0OFnq931RybBSlq37r7Ig3iLcvcnB0J8LMhOJuXUTT9r/HcpMhpvwswubuP2wj+2oPM7DIE+7W9u78aWaGrA2sjGK1HgEPc/dUC2QT+zmLcHDjPFfk2E7ATghRtQVG4Z3rU+ij72Wxm0wF3oeykL1DE4aXAce7+lpnNiPp0hrufXBynomQ9dEHr8w3gUKSgn4T4BxmFdnH3HwphdDgokTt7oPW7GzI0PIUMXu8iZX514DUEBfNmlSUz/JTqA2Y2Bhrnbp7LQDHVLTkUQfh9hIyPV3lARDaSIjNhAQSLuCLwLHK+3O9JVqSZLY3m/R3uvnmj+RwZimyYlRB85ccoUv02d78veWZL5Jh52d3fLITRUZSSffcKJGdcALyOMstmit+vQFmj38d3unsHIk3kIPseRcFsX6B6E90R7Phrue8sAmwDTBzPXgM84JFdU1F9CrlnXiSDbo0cWocCT7n7x2Y2KzArcgjMh+oI3VAQuyNNZnYxMLG7L1s0L21RIjd0R1D8SyKHxH+jTYIynldFzsrrECznuwWxPMJkZkugPWd9d3/WBDt9LLC0B2SZmT2FHMaPuftdBfGZyqcToozCl4CW0BfGRHLq2ijYqRdyns3jVW3oijojFe0Vqlp5GkpN3g0YM3e9C8pCaEG1WcbJ3V8Qea9PbzC/NgzP9EQRQS1UET6lbTHHLkeGlcnj2ibAfiRRgG18t2tH81e1qlWt1lBEX7fk85zAk7HPPhPnyBnxedYG8ZRFV82KDLO/I2f8X8g4ezjwj9x35iSiRClxFDGts062QXVL8s/MCRyP4DK+RFFxDe0TwquegYhOR1G4XwDT5Z77J8K7/jTmy355uaMMLZlTSyKYo14IsuMVFKhyMhFliCKe1wR+BJYvmvfgKQu8OhBlMiyS8PoDUtzPiXX6K3LmFc73cPRvDIQvfiJyOrWgyMpP49r06ThUbbjHN4us3wAZcL5Bhb6vB6as8/wyyAn+PXLIz1Qg75OiuhgvxhlwNTBX3Bsf1U3qD/QtepyH813sEnyfEeN9FfAdckgem/WxaoW9p2zPHQPJRDuTZMIgmOX3gJ8QjNWajdifkvlzcuyPayL9eKk4s9aI+bQ1qr83ZfLdIepgVWtzzMdBjuE74mx6EtW2zT/XPZ07zdaQ3Ne7aD7a4K1L7ucxSD7OMkV+B+4Glon7/wQeCzni8qL5H4l+L5X1GzmAH0O19bKz8VEC/aaoORM/x4s96UuUvf0NcBahN6IM+t1Q7aUDqJPZXbWqdZZWOANVK0dDxoYH45CaOq6lRrduKEomi25dBynDayLP9pfAGI3iNfl9mIQY5ExqQcUuCx/vqtV9R4fEO1oLRU0MjGujFc1b1apWtcFbCPwpZNn6CMomU3jOKoCnp5Fzd6X4vE7Cz0soU2O6RvPVTn27KfpwUzL+qcHHwrByKyoq3Gj+5kRG2RuQIXdQjHcGodU9ebYrsCXK7BkErFD0+A5lTr0OTBOfewP9UvkDRbw+hoqMF85zwtfoKJL+HGDsuHY6ymiYCMGmXEfNULFN0TyPQB8NRXsvjJyyUxTNU7M3akaTuZDD7nngMGoBWi0oinWwoBhkeG4BLii4D90QvNfByGn3E3AEghPqj/D2Cx/r4eiPIT3sNBJnEsoMuwM5Wp9AsKGTFc3vqNxQpsT11GC/R0/ujY2cxl8gPWf/jp438XPqWJf7EEEQQA9klH43eMkgtV6N87k7TeosKEtjcAfxtcAcqTxUtQ4Z90zeyeb/QjG3L0U1nhYAjkYQ978Auybf3ZeAqW2mRv3yAqchyNpsHFZHgRPrFMhnxsstwP9CPl0PBU+0oIyl1AZZOYar1ulb4QxUrTwtBMUskmx6FEX5fwgWCuTR3gtF4qYYuQ8TBrAG8DgB8vqvQGsDT72DKNv0+8Xz59d7rmrlaMh4dGMIrR/HQT1n0XxVrWpVG3IjZ5hDhq8faJyjPtvrl0PQUmsm954PQX8lFOX9PTKWbJjnu8wNGXm+in3xe1rXj+maOw/7NmrsczyOgyBaPkHGnY+BxfPvKqdsTQBsW/T4DmFOTQTcjyKe6xqogLkRTNL7wOxF857jbYyY7xcm7+inkOVGj2u7IoPRqkXzW7VytZDv78/mNYIe/BO4L+T/rxCscf57ZyJYmMlL0IcxkMPuwjiXWlDx5sLHdxj5T+uJXUJk/aNMhzQoYp04735HGTSVvlPM+1o1WRv/Tq53z53TsyM4zNnjc4c4P5Kz7PY4p8bLrsf5+zMyjq6JYM2ORoES71LV6Wyvd5A6iD+PM/hIYJKieeuMDdgq1uDuyf55KsoQmSr37EQoa+2vemdZMzXqBC2jOmM/Idvd7chB80yBPGbvYxEUHLF5cu/BkDcmSd7N6I3msWpVK6J1oaKKgtz9e3d/MT7OjSI77gJ2NbOJ3P0bdKgtiVJyd0FRuSu7++0NYnNZFIF7PnCUmc0VvLeAMCqT/nj8uiaK3DvDS4xXPypTvLc/EGTZSQhbdHxgazObMn2vFVVUUbnIo1aDmXWLz/8CJnL33xr0/7O9/h8o4v/d4GdDFDl/VpxRh6HI0DVR8eNS15jInWfPonP3VpQhc52ZnWtmU7v7X+4+0My6R82fnxo19im5+3fufjxwAjIYTghcZGbbmdkE8Yy78KK7m9m0wO/ufi4I97vRPLdF7n/j7y+CjFe/ufvA5HpK4yGldz93f6XRvA6J3P03d18bGSdAa+QP4G13/z1qsziK2n60IDYrKiGZ2QIIa/9y5GABwb/cgWAUj0Rz/zIz+9jMeptZl8CCHw2tmU8KYL0VxRp4HEU/bw7cg7IAmoJctRCmR1kwMyPjPu7+p9fqK+Hu1wHzo8joO+JeafbUUYi+RkbeFmAvMzvVzMaJ82OgmfWMGhevuPvy7v5KvXqu7UVxZi2MghN/RjXpMrnpEGSk3d/db3T399z9AGDdeG6rjuBpVCN3H+Tur6MMqXVQoMQuwEtmtmahzHVOehsZ9/8NvB51Vh4FvveoiWZmXaPW3BcItu9dYNtmsjdkOpeZzWVm/wauNrPLzWz2ZD95HNgewTjPhM7zjQthmJq9DlgCBco9B2BmayAEnn8jeRQEO32/mfVtNJ8VVdRosg6SASpqQsoKoZrZGO7+WxRq3hXYFOEVH40E/YYbe3J8zoDwlJdCkCIXITiXj+O+IU/8X2b2fyizpo+7T10UzxUNO5nZTSjd+zVkPP0d1Uq4zN2/K5K3iioa1SlTWNoyIMR960gHuJmNDvRz98+Ta11QhOri7r5rXHsRnRE7u/uPcaadhBSSn929f5mLyyfFSdcHbnf3X+L6MggWbCGEB38BcIqXpACvma2InGEfABshZ9ITwHHAo+7+i5lNiqJz73H3A4vidUgUxbLPj48vAht7G0Wzh7YuiqakqOpswMvA0e5+kJnNj5xov7v7MoUyWYfaMlaWed02M2V6QPy+CsrMWN3dHzGz1RB81nLu/nA88yLwBvCGux+dzLNFgF/c/eUCutEmxTqdMAxxTUEZz2i/nCcuHw+c6+4fxDNdUOZnhxWLr2j4yMw2ALZDQY7voMDAC5P7Pd39zwbxMiPKXpsbZWpcheq53YUcL1e5+wAz6x6OoylRDZQbgV3Keq41K5nZuCh7bz9Uy+2eglnqdGRmYyAbwq4IWvcblJmxJvBCNqeTM+siVFNm8WxfLTOlspGZvYWySj5FmfKTIBjhg9z9nXhmNBSAM6gMAWlmth1wlLuPE58/QA6kHdz913DEnIyy+dbL9J+KKuqsVEXQVPQ3JZv0q2a2GXLE7Iaia75BEDBXmdmCYRRrOIXC+La7L41wMUdHkSfnmdl6ZtY3InH/Ch7XAGZDGRgVlZiS6JQTgW1RVOM6qD7E8cA9ZrZaCBYVVVRRgykMoT4kBT1ud7Sx9CLgznC6Z/+3BUVAHxu8ToZknB/c/cd4bEpgRlRTpn/yvVJSOGQmAs4Dzo1oadz9XlR7az90Nu8HPGhmmxfFaxaRbWajufsd7n5sRG5vi4w+fZBR8fQwVu2P6lVcHN8rY3Tif1BE/ZOI10PNbGEz65U9YKJuQ1sXjaI0Mt7M+pjZdHGtR1x+DRnn9jWzTxCcxUzIcFE6SowOM5rZBGHMKvW6bWZKjTXufitwoLs/Epc2QFGtbwOY2YTAAGTYPTae6RLffaxsDhn4+3xqKodMxrO7z4eC0d5EMJHnmtmGZtbP3VvCmN69WI4rysjdr0IG4GPQ/nuSmd0TUfs0yiET/+std18KncX9kcxwPYLcfMjdB8Sj2b46LoJz+qEM51pnI3f/1t1vAVapHDIdQ64MyctQUNAhqK7YZMCBwORQ02nMbCzksOiKsu1LT4lstCuSrzdEkIiroLpR86BMrKPNrI+793dlVxbukAn6LzCGmW1tZocCY6Esmd/j/swoc+b5yiFT0ahAVaZMRa3IzNYBzkWe6quT62OjjX4/YGIUPXemu7/dIL56I6PINCgy+LYsIszM9kawNIYcR1e4+4NmNi8qjPy0u6/VCD4ran8ysymAxVBk+D9QUeJT3P3pQhmrqKJOTLkorNlRTZYpUL2Qy4H/FSXcm9kOwB4oou1/ZjY18KW7/548Yyg7owcyRPRDKfzzuvtUjed6xMgEBXQAKk59I8r6+S25PwmCEtoReNXdlyyAxyyjZwwEN9AdRej9HPe7I6z6tRFMxCTAd8Cp7n5kGp1fNgrep0AZPzsjI/RZ6Bx6390HFcheK0reQ3ckq62HjBBfIufLte7+TERBr4WymX4Cbnb3hwpiuy5ZLXN7cTS3l0a4/M8DDwHnuPtXxXHYOSiZM/sg+ep4d3+uznPdkDNvcXefIa4tijLRD3b3SxrIdqen3Pnby3NZkGa2B6rd1hXpPZejLMTS7EejGsUaWQRBdxrwugd8X2Qobo/q3k0CnOju+zeQtzQDrhuwJzrP+qFglvMy50Cc4wcgGWuiJKilooqakkIfmB3JEushx+RxqGbaH8ihsTlwsrv/uyA2h5nSTGEzy/aVTdz9p7jWE8l3G6NSBF8DJ7j72QWxPBjFPnQlKonQB2X87+7K2JseOZbWQntQKVAAKqqoI6lyylSUKmWGDqWtUcHXr3OCnCHjxGaoWN0B7n5sW3+3HfnrClyKDDrdgV+Bo5Bh/s94ph9Kc9wURUNcg6KiVwcmdfemiHwYFSmZf70RHvaMKNryNXd/MJ7pAUwHrIwievugg/rngtiuqKJOTRH9P8jMtkGRZROhqMpJkHF0+SSCuuFwQhn0h5ktiOqsHBU/P0iMWRugrJr+6Oz4A9jK3W/J+tcofoeXUqNcfN4cGUWfRMrX57nn5wO+dff3G8tpqz38HIQTfZ67n1jnudFQDYo5UQTuY3G9w/D024si83ZmVJtlHZRxcgrwgLt/ViBrf1PyHk5DPD6HnDHLIFloA+D6RKbrkURIl4aSfvRCsD/fojomb6GssVeBDYuY652RzGxy4CPgNwRFdg9wvrt/Gvez97ExksVvRXB+6wBjuvuURfA9KlAEIJwB7OHup+TujYn0ni3RGrkQ+FeZz7XORomcNAeC+F4ubv2J9qvrgNOyQAoT9Oj+wLHufk+jz76cTj8pyiBYG/gFZbKejxx99wXfhzeKt4oq6miKgJWlkBy3NJr3g5B88bi7n1cge8NM2b5hZjuhwJuZ3H2VLOM80YH6AfMCewEzuvvkRfGcUsJ/P+AcJEu8DzyIbHjrIzvPwZ5APlZUUWemyikzClMSiZhtjnsgo8Ns7j5v8lzeONQdwV38txFGODM7HkU2XIIE3H+jaKTp0YE6fqacR0T3OcB88fVD3P2IjuaxohGjRNnvixxpy6IUYkdKzRPAPh4wGGEY+wfQ191vK4briirq3JScCX2QgHwLEo4/NLMrEO7yCu7+YpF8wt+ZdOeiaKtngdOBh7MoehP8185oP3kwcwSUlXIRcK0cXWa2Hqr/8TqCFXq+aOdSsofPiRxGByCD7q9xf0EUofi4u79W5/ulc8jEebQAglH43d2fT+71Q/LHngha4XB3P7QANltRsmanQw6jQ4GTIurwYqSYr+ru78U5WiYYi1aU9OUUVCdqI3d/Ipx6XyE401NcuONTA595A6GAOhuZ2TwIy70LqgM1LtpjLgGuzqJUzWw8ZMxaDQXJPAIc6e4PF70PdVYys+VQXZIVgI9RfY+7cs/8H9KNbnP3fRvPZUVm9jLKjrkZZfItgaDLpkTwfoe6+xvxbKGZoWG4tUTOWBgFWi6EDKPdgN7uPllRPFZUUUdS6Dbro0CV+YCngSXKJosOicxsYgQB1g8hyGzi7rfHvVZ7jAnO2bLMvaIo5OdxUIa2ufs3cX1VFPw3JXIKv4yylm4vhNGKKiqAKqdMRZmANgYSJOeOy6ciGIO0kHLDjSdmNi2KlNwbGXp+NrOZECzZzSjCZyIUOXmGC8M3i5De0d0XaiS/FQ0fJQa9K5BCcD6Cw5gVRfauhBw0+wGXNzISv6KKRnUys3+hzMh1wwEwPjIM/QvBV/5hZlsjpeCEIhWaiEA9GjkArkep8C96HeiNMjoCMkr2xGOAXVA2xlvAOy7oqXWAs4HH0Bn3WRn6Y2aXoLFf393fMrNxUObtoaj2WwuwttdnkAAAPpxJREFUl7uf0uisqmGhJOJ5daQczgUMRPLHY6io9ivxbFdgfCR/3O4lKgprZrsBOwAbxJqdD9Vl2wS4Jvp4NLAgctL8VBy3bZMpc/Z2NPf3DAfMlUhGXcZrsECvA/9290uL47b5KYz/+yLj1G8IamlM4F7gAq9BG3VFUISDgO/d/YdiOB51KAILlkUoBgugLIYd2soUK+P+2hkpcR6vj+SN9V11mLL7kwEHofd2krvvVbRDJqU6httNkK49CzobqsC3ijo1RVDXXsB47r5e0fwMDyVZP8ujTJPRkPP31LhvQJeCHcBdgodBZrYYcCSy9XwB3I8c1rcnQVwzoazdQR4lCiqqaFShyikzCpKZrYbw0Y9MMhC6IufGPxE81CwIo/hslBHTP55rdKr1vSiFcf2I0jaUIfMGiuh5Eh1E8wBToQjK/Yo2UFU07GTCDn0R1QU6xWu1groBa6B3+iuwqLt/VxijFVU0ipGZHQysC8wZEfc3oP13BXf/XzxzFarbsoUXDCcYSsrWKOqzO4I6uhZ4KzvDmoHiPH4QZWQMQnU0RkMwbCchiMfD4/rWmbOgKDLBS54NzO3uc8S1c1EduvsQhNy2CEZr+rLt44kjbDRUM+lNlJH0FTK2TYMUxauRcyaL7ivcwFYnm2pDBHM3aTgyngZ+RjLUd7FGjkfOjTWyvhRNobx7GDkzY+ejwKfuvmFkXD2OnEtXu7K8Z0dy6hXeBDjwZabInjoY1afaEMnWx6JI4p+A/wAXuftLhTE5ipHl4AXNbGaUObYDghE9Chnh/oaYrnSfxpOpSPU2wPzu/knssX8lmSino3c2d6ZzN5i/Ic4Law1pNjqwWhbgWFFFnZ1C9ujmJYRyHRaKDNYlkWy0PMqe2cfd7477DXfSm9kknoP1NbP3UU3GK1Eg3yYIweBe4Los8COeLVy2rqiiRlOXohmoqBBaClgcuNTMDjOzCd39rzCyXYOMcCehAls3Abua2TSxSTbSIfNP5CS6HEVnZziZeyADyebuvhna2HdCEZW7I5iOipqHJgT+Aj5x94Fm1jXm2iB3vw45EGdCxborqqiidqZwAtSjX1BU9OhmthBykh6FCodjZjMCkwI/Fe2QAXD3ge5+Fsq0uxwFGNyCzoimoVBG1kWwbHdEOxEpW+ejs/lzBOV4ckFs/k2hzL4MzGZml0bm46You3UTd38YOZB+AyYujNG2KZNrDkcG6P0iSvhFFOxxJ3KOHQ5cb2bbhaJbZATilACJ4S+T5z8DegNrhYNmLrRms/U5E4Jde7NEDpmJ3L2ljnz5NrCQqebJUUh5vz8cMj0Q7MhEwKPxdyqdZgQojLa/u/t+aM+5GAXBbI8ylt9DxYIvMbO9I3Ojog6mCISwMPLjgr86AcGZ/Ywy+gaa2Rpxv3LINIDqyEufIj1mZvhbDmkxFdsGwfz9BUzQOC5rNLR5kThkusY+UDlkKhplKGSPpnTIALj7N+5+Lcqs3wVlpd9pZjea2SwFOGQmBB4wswNNcLqY2SII3nE7dz/S3fcCZgNuQ8FbJ5vZUWY2a/SpcshUNMpRpcCMguTuO6No4i9RgcgbzGzbEMj6u/s7wBEoXf5ppAxfDmxmwuFsFM2KvOr7ANuYWa/YsLcKnp6J/gxwYSzvg7BwJ20gjxWNPH2BMESXisjAv8Lo0j3uv4MMkOMXxmFFFXVSiuzDvc1s9mTNZXQ9WnsnAGch4/RtkYo+GsrkmA9lE3Qkf8NFoaTsBsyPzrnR2puv9qZ8P939S5SZMRqwGIJi28bdxwKOQZkpd6OsiIZTnfdyM5ojC6Nix7sjR1KG3z0WggMrFNO6HkVWxlgIVuFmVE8DNK8/Q069JZA8NAVaD/8sgFXg78jIO8zsODObBWrOmXCAXYQKOJ8B3Ojuj0TAw3gIR30WJEMVTma2I/Cqma2VXUuMiMcg4/OjaF6dEOsCBL+2I/C0uz8d36sgm0aAYv53i49no4ykk81sWnd/0N2XRHW5uqB3ckHyfEXtQOF86RK/r2pmj5vZ3C4aaGbdQkcb6O53oPfxAnJUflok76MCpQ7f0E8sWQOvoGz+A02QZZmjM6tz1YLqk3XomknmTx8zW97MNjWzFSP7ZahUGUIrqqi8lKzv8cxsJTPbxcwWMdXVwwVneSaykR2NsmeeDl2tUTwakvXHQnbEC0ywiD2AP4AMYaGnu3/p7jsAK6JA662RPXL+RvFbUUVlosopM4pRFuHj7jejCLhjkNFnP+BaM1sy7v+GnB7bItz0XsA5yNPdKDobFbd8BR009wFXIQX9Fo+ioknUUg8k+PZqII8VjTx9hoyLWwDrm9mYoGizuD8Rcs5VhXwrqqj9aUUkwF8KbB5R6QBE9uSpqDbIrAjWacZQDnZGNQj+4+5PdRRzYTCczsz2C6PyEClRXHq7+6vuPr+7nxbXGnl+DRdlhmgzW9SEq4y7P4pq+jhSrtaJ69cCxyH4qRsbzWtkibiZjW1mKwVP/wMOAJZGEGVne61eyT+RoniFu/80hMysIqkbcgD85apdNzmwHpr/Xdz9e5QN9CVwiLvfWwSTMYf7ICPgZsC5ZrZzRCdmdBLwLtAXmMPMTjGzLYAbUQbTMe7+cWM5b5McFanNIOGmTu59hKDWBiDD5mFmtr+ZHY+yOUZDjpkhZftVlFA2TmGsXSOT+YGeAK5aPZsjeOC7zWzRuH4RcnKfBdwcjvlKhxxJMrMpw0DlkV1hyGk6FXCbmZ1uZuNF5vhfSfbFGMAPwDbu/lyZz7bOQPFuZjWz18xssXhfg8L58jzSX2YGHjOzzYAJzKynqabXjsDX4UzrEAo+Wky1uC5B2bUXo4DKDes8X+2XFVXUJBQO+RYzmxgh2NyC9LZHgNPMbEszmzT2peeRbW8zYG1vIHRz/P833X0ClLUzB4KR3hXZD3+P5/40s+6xbz3r7iug2j6fA882it+KKioTVTVlRkGyWkHbbgjj/Tzk0BgXGRxuRkWc38ieR5AjE7n7MwXw2wc5kLZDUdmPA7u4+8tWw4IfAxWf3g6YzN1/aTSfFY04mdnYqPbD4ig6/BIU/TcawjlfAZjSSwK3UlFFnYnM7B/UsiPvRxH2z7j7V3F/SVSwdnFkCOqNjNjXo4LDHVojxMwOolZD5TjgTnf/YwjPd0MFa5dCSklTFKM2FZm/EXgVKSeXoiLzhqLIFkWGlusbqWi1RWZ2OJoX1wNHufurcb0Lki//igyIw4Bf3X2+uF/K2gfhEPjG3X8xsy3R2bNWGD27xedxgJ3KwL+ZbYQyhCdC8+RqlMmW1QDcFtgNGBtFLr4LnIIKtxfOf0ZmNq67fxuy3rMoIOhkr9U8nA71cwHUV0OGiYvd/QmrCpsPF5nZ/6E95jvk8OoBPIQCXx5AMInTIwfex8BeXgeesqzruFnIVGT6KaSD3eDu/03uLYPq+SyN3supXivg3BcZudYB5hnSWVhR+1E4tk9GeslNwN5eq603JrAScsAshM7vP1Dtn69Qzb2HMv27A3jLdOGLUAbzJehcPhll2k6JatJN6O7v5b/X3vxUVFFF7UfZWWtmtwHToeCIrFbj8Qga+A5Ur+Uxd/+xSD6Tzz1RxvwOcekJJE88kzzzd+20SqaoaFSmyikzClKyuV+DIntuQ7VkpkWGn7mBb9GGf1EZDFoRBTY5qi+yA4oSOxM4y90/M9U7uB040d2PLI7TioaXIgLkLxNG/lYo4mw8ZCzohaJl/+3u5xTGZEUVjQIUToEj0Pq7EjnoX3T338LxvShykH6EMhgf8xpER0fyNQkyLOyEorVvRVFiz3vrIufZ2TYPcAXwu7vP2dH8tSeZ2aaoLtqcKAjhW+A5tB9OhbIKDnf3h4riMSMTzMC6yBjVG0XlHpEZcMN4eCJy4J3u7i9YyQt4ZgpiGEXvRpHoF5jZnMh4+qG7r1Mgf3mltwfKWNuGwBJHRVMfivvdUbTip8BvZQlYMbM+qaE/ZLypgNOAGZFB82bgbHf/Ip6ZlsiayYyhFQ0/mdmuyFj7F5rTHyO5vzcy6H6Dxnn6+Mpq7n5r2dduM1HM93FQxPOCKODgfODeLIst9s/VUMbevMiJdhEwO6rvdpy7H1wZ1htHZrYYsDGwJtAdvYMjkvv/h/bbRRGU9tPA3e7eYdHfObnnGaQjX+Lu/c1sAeSguRXpz2Mi5/zh7n5LR/FUUUUVtQ8lDtcFkXy3G3BprPk7gdEJZwfSzW5GgWuPNpDHbA8aDaEqLAPc6u6vxf1pEOzvqghx4QLgpuSs64ps0u3usK6oomahyikzilGycc6KoDj2BE7zWrFYQ4bxk9BG/zBS8M8thuPWFBv3bCgaaQOET3kGwhufz92nKJC9ikaSItpsChRpNjsq9PtgGkFYUUUVtS8lQv8sSGjOHNufIOH5euD9IgXmyL6YFhmptkc1ps5Fxv4Pk+f6AIcixWVGd3+no6JT25NSw1r0dSJkQNkMOaLGRbA2IJit8b0ExUmD1+URRMqSwE/IiX5h3O8GjFW2LMfUuRGOi34pj2Y2FYJLnRgVOp8MGVHndvePiuI3p/T+JzsbI+r+MGBlBAl6M5LdXk/+RmnWgZk9g4z/u7qw0NN7a6MAoZmBD4HLgAvzhucqqnLEKAJgFkIwZUsCFyJ44ndQNP2yyEEzMzI8X5BG11fUvmRmS6AgsxmB/6AMyUddkInZXrRitIWQw+xGd9827lfroIMpd16MibJw90fOso+Ag939irifyVPdvQbD3OHvycyeR0Ec2ybGzjmAF9HavhfJFYsheeJYBMU5sO4frKiiikpDZpbJd5u7+ytmthzKjlnO3e8zswORDNgFZRFvWQCPRyLEmsdRDcDH02AOM1sRBd5MhUoSXAzc5TWo44oqGmWpcsqMomRmqwDXAeu7+815L7WZrYqitv4EnioyMrQehWFiSZTCvwSKxF3N3W8tlLGKKqqooiaiJFNtfgR/9CGC5uiKDEBrAi8Bp6PMmA8KYxYws17IMb8xgtf5AUGaXeXuP5jZ8siYfrW771Dm6O56RhozG81z0GSmIvTTARMCWwKPuPtJjeN0cKojM4yF5soWyIl0H3CSu99THJf1KTGajYaCOzZHDpcfECzEba66MnOgLJSpUDbB1UVHF7eh9KYOvcWBQ1BQw8sIFvQG72CIweGhcJzuAWyCnKsnornyU/JMb5T9s0E88xyC1X2g8Rx3Por1Ox2wCqoPNhZywJ+QZiGVyZHX2SjeQUti7N8JZYA6NfipZzKjuZlNhBzyYwNfuvvAMp9vnZFye+1LSE4C+D+0J++VZcXE+/WOzGJKnPVrIZ1+PXe/Lrl/Awpm2cLdX4xrK6FaaWMBC7j72x3FX0UVVTR8FIFOvVy1nbNrXVGA1j/dff249jQqObC1u39jZnMjKLPDgPfc/bMG8ZvpkFuhgL4rgAPSoLH8OWVmewefgxBk9oHu/mYj+K2oorJS5ZQZRcnMZkBK7rXAzl7DIO8egv60wD0IQ/3BDD6ibGSqRbIJMIG77180PxW1D1VwDBVV1Fgys6dQEcYd3f2tzKCAIvL/DUyNYC5vAx5w918LY5a/nQALIAP1igib/1wUSbYsyiT5sxn2EjNbGmWazIJgbJ5EkCelyS5JFC9D5+2Xcb07MixmkXCzI+i7SVCh+a1cRcJLQ0lfzkF1Gd5BcHzzIYffyih6LzO+TdIoBXco/A6P0rslgrPoDbwO7OfuLzWY9TbJBIc4M5LfNkdZM/9CztUUknBalBm9AjKAPoL2qMJrKnUGSpzcm0T7ETm5ry6TI68zUuIcTjH1eyKkgu2BD1Bw3G0eNT4rKo7i7LN4Z1uhQJVFUebSBtEmRhBzBzTy/A5n/e7Ar8Ch7n621eDM1kWZVem+ujbS/5dz93sbxWdFFVU0ZDKzY1GQ0BHu/klyfVJgzNDPpkG62HXufmjcXxFBhK3Z6PMi9MUv0Z5yhLt/VU/3SrMHTfCcZwHrA+NV8kZFozp1KZqBigqjT4G7kDK8cUQukqQx90OY3t+W1SEDEOn9pyJlvqKSUhzYWfTrUKnsRtSKKmpmCuNC+nkKZEz40N3fAnD3v2Id3oOyBRxlQdyMjO2Fkrv/4O53Ivz0rRHc5oXAWsD+4ZDpVta9xATrlWU2XImcX58ieLZjgNPNbOXsuXi2R8MZDUoM/vsDj5vZ1pmCFQ6D7uEYeAVBIX2BzuZri+I5T2a2KKgvkQWzJXC0u88fUEBfICPWm2F46xvPF+aQif//V5yhxwA3AMe76t50SZ+B2rxywcfNi8Z/FpTpUziZ2VSRDfabuz+HoAbXBl5DMGUPmuogAODu77n77ihr5kPg58oh037k7n+4iu4ehIy3L6F1e7uZrRBOgoo6gLKzKdZy1zBi/enuOwIzIfjQY4BzzWyTyJSpqAGU7a1mNqeZjQtKeYlzYQzgKFSP6dU48/ZH58lVaD/7ylRfplF0BoqkfxE4M7J4rgNuRDCXLRYUz/dCOn61viuqqCQUct5EaC/pGdf6Abj7/zL9DMlzfwHzmNk44aRZFtnuGoZmkOwnO6L95AZ3/yr4HUz3iqDvbmY2tbv/5O4bAhNWDpmKKqoyZUZpCkfMNcgYdBMyaH2KDoKDEWbu5O7+Y1E8VtT8lEQDdkNY2X8Bu4VDLX2uwsWuqKIGUZ3I+pdRlOUiAYfRCrYmYDCeA571EhSZTyn2lulRxNX07r5uwSwNM5nZ60jBOszdnzGzdRGM3E/AwPj9and/usF8Zfv2OsB/s8g7M9sZBXOMi+CxzgnnWPrdnYB/ADu4++9lyFYys3mBx4DJ3P1rM/s3qoWznru/birg/BDKnLnF3QdFxOIEwPZFOQKyc9HMdkGZL5u4+8ND+U431M8P4/PY+fO2CArn71PImHmjRxHYuDc5gqTdBUGvXYIivj/N/Y2ezZIB14wU0bjLADshZ95DwAZlmD/NTsmeugGwHCq+PgB42d0/MbNe7v5H7jtroOjnSdG72MOTOlEVdRyZaq++gvSW89A5+IuZHQdsBCwVUetpvZk+yLk5p7vvUADP06DM4Y1QBtyzwJbu/m7yTF/k7FsNmLTaRyuqqFxkZpO5+6dmNhNyuJ4KPO61OmNdgCOQM/hl5IwZD9jH3c9uMK+G0BRWBxZ29y/bsufEs2MBpwCXu/t9jeS1oorKTFWmzChA+ajojNz9Z+SNPwLBwNyJomxeiM/7Vg6ZitqBsvl3HJpX/6un4FcOmYoq6lgysynNbEdoFVmfZV9cDyyI6lEQRuksw20sVPB5srI5ZEC8htPgeJQ183d2XhkpO5PNbHUEL3VWRKuD4KnOBxZHkdJbAyeZ2SFp1kxHUxgPx0cGqUfMbA8z6+PupyNjztXADMAZZnaOmc0ZfZoGWBiY1d1/z/5Wo/geAg1AcziDOf0VGCMxcJ6K4CDuj7k/OqolMwaqWVcIhUPGgMlQH96CtuW6uN4HOMwEi0e987bRFHz9iqI4DwYujGyryQFcMB1XolpRhyCH2atmtm9Epmc0IJ4vw5zqdOSqJ3MZMuqeDHQpw/zpDBR7ag8Ee7UR2ltPB143s2eBC8zsODNbysyWDAfkTe4+NaqfOTclyXgbRehbVO9qeZQhvHPsqbuhDMu30ofDEPmzu58fzzRcDnH395ERd3cEgzcd8N+YV6PHY/OhrOfDq320oorKR0kwynjAnMDlwNFmNr+Zje7uLe5+IKoJ9wOy2+3WaIdM8OrAaEA/D1jjtuw5cX0g4nuChjFZUUVNQFWmzChASaTlGsDSCKbmP8DDCA6iCzAlMsjNDbyLoqGfK4ThijoNJZGBUyNc+0NQZPXPYaRZGkVU/w7c6gUXEa+oos5MZnY0sB+qy3B0GqVkqs91CjIWPQwc4+73Rer8ashAd5i7n9JQpjsxmYpdbg2s5u5vWK3Q85Lu/rwJ2uw/QH/gIm9w3bQw4iyB6t2sDbwJHOlRSNjM5kdFwhdAStk7SL6YFljV3W/LZ2QVSWZ2AVIG5wLmQdBeC6Mz6ASUqfGcCy5sbpStcae771sMxzUys9OB9d193GF4tjfKet7J3a/ocOaGk8xsSWQ4nBHN70uAR7IgIDMbE2XLbAash4qbb+XudxXA7ihL8R4ssgNaZU5WNGJkZuOgs3QmZDj/Ezl/lwMmR4aqWdD6HR1lOryOslTviMzD6l00iEw102ZFTrENkL78KTrfXqnzfEMz+CJifnxgCgQf9Fs4ZrKsnYWC73VQ3a4T0Jk+jbs3El6toooqGgbK9nczm9jdPw95bhcEI/0zcCaSm97JzgFL6pIVxPPmCG1neXe/JwsaaiNbZiEUePZvd7+koYxWVFGJqXLKdHKyWoHYfwJ3AL8B/0MFVt9Fm/stER1XUUUdQmZ2FLAmsK67vxKG3p0RnvwABJl3HrCz1+oaVVRRRe1IZjY9qrmyFnLE3wMcnEFbmNl0aF2ugYzrH6BaMpMhiJX5C2C705KpdsZS7n5kKDEvAc8Du4ch9P+Q8XoD4MuiolpNtQyWRJBG8yFZ4sgsu8dUYHRFZGgcAFzr7hcVweuQKLIyngduQRkzDyE4zSkQlOturvoOEyIj3G7AFO7+dSEMJ9QZlN4wLvyaQP1kTkhHjpnrUEBQVgh2fGB+VO/kGHe/uQi+K6qoPckE43cLcmSvnmVchBNsOuSIuR0FzS2MIqU/c/cpi+C3IohsvcWAbYGVgbtRduWz7v5DQTzNiHSolZAD70fkMLoHZd9+FM9NjODINwcWRY6lxd390YYzXVFFFQ0TmdnHaI85293/MLMpgcNQNvGLce9hz0G8FkGRIf8Uyu7fKDnTuiD5Lsv67oH20MOA+d39nYJYrqii0lHllBlFyMyeAr5GAtx7yClzIBLmHkEp9E9mqYcVVdQelGRp7YPw8Bdy93fN7Exqis12wAHA4cDc7v5ScRxXVFHnp8hwWB9F546JnPMne+DZm9kyKHNyOuScuR64J4vArKh9KBSWMSNzcEJkiHvN3TeP+ysD56IMiUcK4C/Fyu+CMmBWA7ZHEd0XoKLznybRfd2BQbHvF173I4H56gYMQrLOFihTpguCYZsZRR7eSmSYoPl/qrsf1Wie61GzKr1JtuwKSN48ADlmsgjPnghmZ3vkBD4PuM3d34z7BkxQyaYVdQZKZOLJ0bn6FQpG+jjuX4oM5yt5QCua2ezAj+7+cZUlUxxlexE6A/eO3y9DzvLXvQF1x5L9dCm0x/8fgn38FhgbBXCMhc6xY4Hzk712epT1OqAs51pFFVU0OJnZKkgW2tbd/5O7twiqCTUfsqGc4e73NJ7L1mRme6HaMq8j/v7j7r/lnlkKOBt42t03aTyXFVVUXqqcMp2YEuF/fBSFeG8eeiaMPkch49sNwAVFGH8q6hxkZqsB36MDd0Du+k2o0LKh6L9DkCH41zDYXIyKGBcuXFRUUWek1KAThp5TgHmBXkiQPsndL477pYGdGlXIzG5BUCkHAD2Q82B8d5+lSL5SMrNeqIDwxsCmwE+oXtjlCfxU3SKfZSAzGw/Vz3vF3bcKZ9juKDigdzz2P+AUdz+pIDbrUjMrvWb2GfAqcih9l8/0CYPh2Qha5wmU6XO/u39eEMsVVdShZIKUvhi4293XNbN/AM8A+yBD259l3ktHVQpH+NQIenQ7pPNcDFyaOdc66P9mOn1XtJd+ARzlSZ2/yOjZFzmNuiI964Qk+7AbqA5fR/FZUUUVDT8lDtcuCM3gAGBFd/8sr4+F/LQxkpOOcvfDi+G6NZnZgahO9e+oRuN/gLtQbZx/AP9C+9K8rrrWFVVUUVDllOnkFFGImyDoqKvd/dK4nkbA9kSC5cloc/9XUfxW1LwU8+gVYBpUHPN84MMsUtrM1kXK5iDgHOCqUDp7o8jefYE5Kyi9iirqGEqyGbZHBv8WFOU5D4IJmhwZhQ5x96fiO5Vzph0ogRLtDcyA6sQAvJdF2AbM6MXAOMgp8wGwhbs/XgTPQyIzGwvVktkOQZc9CxyaOdXLMG/MbE1gDBTR/CcwIcoq2RFliO0JnBaGrtGBZdGYf+nuXxXD9ZCpmZTeZM7vg+DiVk0hc8xskjA4dEnkhJWB09C7egTYM8sYqKiizkZmthI6g69D2XkDgQ28qq9YeoqsxLmQU39tYGl3f6AD/19mtD0NIQ1s7e73J86aNOhmNlQcfDJgTXd/qAyZqxVVVNGQycyORBlw0wALuPuvcX0wB72Z9XX3nwpgs00ys/mAIxFkIsCvSA43JK+e6u4PF8NdRRWVlyqnTCcnM9sSGccBXkZRim8k91PnzITAt1UETUUjSqaaFJugonTfA8cj7Owvknk2licYzGGEOQO41d13bjjTFVU0CpGZjQZ8hiAvjs5ggcxsVmArBN30Fzo3jvfAJa9oxClnLPkPgo3rDnyEDOu3psacOLd/RtkcpcZcNrNJgWXQvJkNRXjvVihTgJktDDyKggB+QdlgPyNn2BfA9AjS7EWUIXZb8t1SG6+aQelNDIVjoALTZwCHJwaG9ZHRcEZ3f69OJOhBwB7A5Nl3Kqqos1CyPnohR+p+cWsZd7+/QNYqGk4ys77A7N6BNVqS+TINqge7F6ob0z+nx3cBCOfNAsCDCCVj1Y7iraKKKmofCkfvDQjqFSTPHZQGpjRL9qSZLQisiuTSQcDjwF3NwHtFFRVBlVOmk1MIi/9EadbLIMz0U4Hn3f2X5LlSGyEqah4KoWIONOe2QEWhzwYeT+dcPLtG3PsEWDBLsa+oooo6hsxsSQTftKO7X2hmPXJQg/sgI9GfCO9+tqIzHpqRIvNiYnd/L7l2EDK+nYf2xa3QufwVUr6u8yapqZUzBHUDZgS2BHYFzgJ2LXLemGo2TITGdgDKkPkR6OfuX4RxawcU4TwGyjY51t3/WwzHw09lVnqTLJmLUI2M1bKxDcPhW8CTwA7u/nvyvdSB2cPdB1hVR6OiTk5mdggytJ+EMg4LX8MVDT91tMHUzB4AJkWwRu8Nw/NXoCCQacoWUV9RRRXVJzNbDDgYwbk+hOwkD7v7t3G/KRwzFVVU0bBT5ZQZBchUeHdCYB0UeTg6Spe/DHgrNchVVNHIUGKI6YcMMQej9P4/ETzDqaiQ9cCYl2ugYnXXuPuzBbFdUUWjDJnZTMBrKEvm4OR6ZgAdBxlMrwNu6kg4js5MZnYtMAuqt3KHu39vZjcB79E6Y2A+4FAEH/c6cC1wczPCOEZWxPUIb39+jxozZaEUszuBy1oMwZktjGDj1nb3W4vks7OQmc2C9pp9Uf24zNlyEIL8WdzdX4trWST46MBUwGdlmz8VVdTelOxJk6Eab4uigInriuWsopTKYASNOfIQgpk9E+2pn7TxbAZVeyYKzJwD6F90HyqqqKIaDSkgOgJct0B2lD7AVcAVwHPu/kfjuBw5KsPeWVFFzUBdimagovYlMxVPTT73dPeB7v6pu58ILI029h1QiuQ2ZjZVAaxW1AkpiYw+BxUifho4DEEhLQ3cB+xvZlNFVsx1wL6VQ6aiihpG76GMyV3NbPUwgpI45/sg58AtlUNmpOgphOd+AXCGmS2DnNPd3P1XM+sZCtkz7r48cgyMjgq5H1EY1yNBrqLzzwF9gfELZmcwypRfrxVTxd0fcfd1UM2TR5DRq6koL/eViJaJnxsDK5lZNzObAI31Scj5mzpkDNUnuooSzp+KKmpvSvakT9EZ8CZwlZktNcQvVtTulJ0JZtbLzP7PzMaOIBWSrNAi99pvgc1RJupWwONmtqOpvtvfFPvpIDMbE9VTew/oWRlGK6qoeMr2Gajt/3We6ebuA9z9/9u783jN5/Lx46/rzIwZxMiWlCgiytai5FuWSH5FZE8LbQYh27eUX4VI2ZJf0lRfKt9kl0JEiLFLX+WbSClLkWWss5iZ6/fH+33Xp+OQMefcnzn3/Xo+Hucxcz7Lfa5h5nPfn8/1vq7rREpCdTLwYcrMyYNr2+BRweuO9PxYKdNDBrUT2RjYCliV0n/2LErLsodrD+M3U1Yqbg58qbliWnohGiv+tgDOBj6UmT+s+xYGXk1pbfNhYArlQ8YFmflQWzFL/aTx8HMDSkJ0FmV17s+AW2uV236UhOrGI9kjvR/UlW5HUx623Ve/bsrM3ZrHdBJitXrwS8D1mXlWCyHPkyjzik4DJmbmBi2H87w0Z5lExITMnN52TL0iIpYH1qPMG3oL5XPoiyjJys3qg+jmdWl5yqyrCZn5xpbClloTEatRksPbpsOQuyYixtUK/pcB3wM2oCyiuJzynnZZ53rVtpqEWReYREliX0/53HBJZs5oHPdGytyuszPzc23EKumZImIMperlJkoi/onMvOK5PoNGxBrAUZTKtyWyMZtX0uhnUqaHNFpH7UXpWz8GuJnS6305Squo8xqJm6UovWZ/nnXYszSvIuIYYCdgo8y8dVCy8FXAyZRWMVB6Zx/STqRS/6ozNb4ObAb8mbIK88XA8pSb+O1bDK+nRMTKlEHnG9dNRwCTM/Ouun8AGJM9MFOrJpYWycyH247l+eqsfnZF3/Crf7dXArakzJlbEbgEmJSZf2wkZMYDu1KSxKtm5u+bCTOpX0TEizPzEdu+jKxaBfN0Zj7W2HYBsCalk8SdlAUVr6ZUF59EmevwaD221f8/dbX8OylJ7zUpC22+mpk314VwnwX2BJZL58lI842IOIDS2ng28DBl5mFSFqw+BVwM3A3cn5m31a43M+q5K2fm7e1ELmmkmJTpEY0b28WAeygZ+EMy876IOIFyQ/x/MvPXbX+QVG+LiE9Q2pe9JTOvrw9lorEa+V3AQZQHwpeMpod30mjSSNQvBaxPmXEyHrgyMy+sD9A3BD5BSdw/SHn4cJrzHF64iHgd8Fhm/mVQJcbGlOTMypRWjidTqgU7D3nG9UJiRhqsVmivDWxNab0zldKq74f1AfQalGvPxZn5CRMykkZSRFwDXAf8IDNviohlgF8Ch1CuS525Y5MoCynGUN6zf0SpZm39vToixgKrUK6rk4CFKfdWv6LMjj0mM7/UXoSSBouIrSkdCb4HnAu8nDJ/dwNgAvAm4AnKmIm7KG2BZwLfyTqHT1JvMSnTYyJif2A3YIfMvKGWYt8JfA74RmZOj4h9KKuh9/OmV8MtIlai3NjcA3wwM39ft3ceEO9IqeTaPjNvazFUqWc12glOBM4H1qF8yH+CcgNwArBvo3XWRODxZ+txrOfW+O+9MaWVyMLAepn52OAHzBHxn8AXgQBOBb5PSZT5fqyeFhGLU1qZdVrvXAscS2lz9jFgycycEc8xAFeS5kVdwHgqpXr1Nko75RuAb1HmXP5s0Or0cZQ5WJOAacBHM/OMNmIfSq2MWRvYGdiGMhvw3sxcrs24JA2tUS1zQJaZz53ti1Dm8K5Paef6MmAjYCnKc5P55rojafgM/PtDND+LOqS5MThsJjCO0qMS4HjKB84fNfpUvhZYA1ise5GqX2TmH4DDKSX/Z0fEvhGxSE3IrEF5ELOoCRmpK74BLAPsmpmLA/vV7X+iJAU6FRqP+hD0hanVp3Nqn+hjKQ9t9q4JmRicbMnMrwIvpfSq3xk4A/hCPV/qWZn5cGZeAOxOaWe2IPBDyry5z9aEzFivRZJGSmZOzczNgE0pC1WOo1TIjAEWqMfMiIiBTgVrZu4JrEapQrmlpdCHlJlPZuZVlAVvOwMXAbu0GpSkZ2i0yz2S0jVkr4jYqXHIqpTKtyOBL2TmjpQWsOuZkJF6l5Uyo1BjRe56lGHMBzf2fYhSXr0qsARwFbA9cG4dYrgKpbXUvZn5ge5Hr17yXK3wImJ3YF9gWeAx4FZKMnBh4OOZ+d9dC1TqQ3VuzPXAYZQZJk9ExKmU94fNM/PuWiFzIPD1zLyvxXBHrcZ78jGUVaq7ZuaFg/YtQmkRNxt4Kv855HwtSi/4U5yvpX5SW++sDLwfeLVzrCR1W70OfZQyg2U54G+UhPHlmflk4xgyc1bjvPmymq8+9F0mM//adiySnl1EvAT4DqV6eJvMvCIiLuKfVTF32MpV6g8mZUaxiPglMDszN2xsmwBcATwKvAL4A7BlZs6q+3ahrAh6e2Ze20LY6kER8R/AqyjVd3dk5pS6fVnKzc7rKCW4dwOnZuZ5bcUq9ZpnS45GxBuAHwO7ZeZPImIjypDt7YCza7LgQ5SHER/IzBu7GngPqTdX11CGAR+dmU819q1DmSXzRuABSpuUk4Dzmg95pH4UEYsCDNXqT5K6oc7e251SbfIwpaXZOcBvOp+vnPsmaThFxHjKwqxXARdSFrN+hDLXyvsDqU+MbTsAzb3GA7hrgY9HxEsy8/66amd6RBxF6Ue5KKXMetOIuBHYh1I1c7oJGc2r2mJkVkRsT3nguASlfd79dYDmYXUg3aERsWijlY+ZYGkYNR4YbEqZTdJJCDwCTKQkRKG01joPuLQmZMZT5stAeQihF245YCHgT4MSMltSetEvB/yU0iplW0oF4RTg/q5HKs1HMvOxxu9NyEgaUY0K1oWAJYHpmfkAcHBEnAUcCnwB2ByYHBE/y8y/mJCRNFzqdWhGRHwF+AGwP6Wt8Wn1+YrPTKQ+4UyZUahxgb6c8sDt9Z1ddf8ZwJqUC/sOlH71f6Vc7C8GPtnFcNWjGis4jqas/F4XeA9wAWVF+MURcWSdJ9N56OLMBGkYdeaQRMQnKUMjX9bYfS9wGfDJiDgEWBE4IjMfqftfB+wIXJ+Zf+xe1D1pKrB0/QIgIt5HqUxdgNLWbJvMfD+wG2Uo70e6H6YkSf2r0XbsUMpMqzc19v02M7cCtqAsXj0eODkiNnzGC0nSC9S5DmXm1ZQ5MrdQ5lat2GZckrrPpMzodg3wFPBm+JfV0gOZ+ec6HGwt4PPATsDamblrZk5tJ1z1moh4DfAgpV3PdZl5CbAnpSrrCuCDwLURMQn+tR+zpHnTGSJf+51/mfKe8I/Ki8ycAexFmWNyEHA78GBETKyzTA6hVMoc0O3Ye9BfKK1ODoqI4yNiH0rF6suBT2TmjzNzZj12CqWKaYF2QpUkqf80FrK8l7Iw4lrgF4OPy8yfUu6vPwO8DbBKRtKwi4gB4H8oi7iWBw6sHUaskpH6hO3LRomhShgz85GIuA54Z0Qc2mn7UEuyx2bmrMy8BbilDhme0ELo6jGNsv8XU1ZzJPB43TchM6cDP4mIKZSVH9sCJ0TE1Mz8UWuBS70nKP/+jqM85J/cbAUUEetm5jURsRvl4cP2lKq2Jynts24B9s5MW2jNo8ycGRFHUyplPkp5v70J+FpmXjDoPfyllFaPjw39apIkabg1WiQeSknGHJOZ0zr3NoOOnQEcGxEn13tu2wlJGlaN685JETER+CqwYERsN/iaJKk3mZQZJRpVMJ8BrqK0m5kJnE9pWbMS8PvGKRMj4hXAxsDb669bAhd1MWz1oMYHhK8AHwYeBVah/J2cHhHjgDmZ+TDw7Yi4EtjEhIw0fOrDgTkRsSKlHdb+wP829n8GODwiVsjMqyPiLuBsSrvLFSjzxs7LzHu6HnyPqv+d3w68gzI75rZGZeoYYFa94doUWBj4biuBSpLUpyJibWAx4MbMvA/+eW/TWHj2Csq99RWdlq8mZCSNpMz8WkSsCSxrQkbqHyZlRpH6AfEzwDjgxIj4OnA1MAN4T0QsS0nAbAqsQRk6DKWtyimZaUJGw+nnlOHVGwDfi4iXAcfWlWVExAKZOTMzbwNuay9Mqfc0Hg5MBu6gJFg6//YWA/YDDgceqMffB9xHmfmkEVL/v1zS+b6zsrbRunEbSlvHLzWrmiRJ0vCLiDGNChko8/YmAovU/eM7n58aD0InUe6lb6N8dpKkbvgY/3yGJ6kPhIs+Ro+IGE8ZoL4dsAvwEHAs8GlKO5SO3wI3UmZ6/JaSlJmamfbD1bCKiIUo1TIfp6wou4XSCuDsuj+AMc6SkYZfRCwHXAa8AvgGcFxm3hUR36JUa2ySmX+qx0Zm5lAtOjTy6rVyb0pV042Z+b6WQ5IkqWdFxDLAjE6lS902ALyI8tlpArBhZj5Q943PzBkRsSSlhdBqwLpWyEiSpJFiUmYUqrM81gX2oDx4WwC4HvgaJREzNTOnDTrHPriaZ8/29ygiXkV52Pg+4MXAxcCRmXlTl0OU+kZELEhJ1G9NmWPyEHAqpUpm18w8qR7n9b9lEbEScDLlvfr4TrJMkiQNv4g4F1gL2KLOWG3u2xz4PvBn4PDMPL2xbxJl0ePumXnSEJU2kiRJw8KkzChWV0lvDLwf2Ag4BTgG+I0roTWcmg91a1JwC+ApyrDqKZn5YN33NkrJ/wbAS4CtM/PHrQQt9YlGon4S5b1gPPAh4Ayr1OYfETEWmJCZT7QdiyRJvahW6Y8DvkxpQfaeWgGzRic5ExELA58E9qnH3g5MoSRx1qRUtG7WQviSJKmPmJQZ5epQ9ddQKhR2pQwPPh74Zmbe22Zs6h2dVWIRsTuwJ7BK3TUd+A1wUmae2Dh+R0qycLvBVVuSRkadO/YOynvBm4DTgCOBX1spI0mS+klETMzMR2tlzMnAfwEnZuaddf86lOTMGpTFZDOBE4EfZOY9VslIkqSRZFKmR9QVP2sDO1NmzswAJmXmWW3GpdGvkZBZBbgZ+BnwI+BOYHvgvcAylBudIzLz/nreOOcYSd1VE/UrU1qa7UrpnW6iXpIk9YXB8/MiYn3gIMr8ywcprV4ndypXI2JFSgvYsZ3qf0mSpJFmUqbH1OGE/wF8BvhCZl7UckjqERHx38DqlOqX2xrbX0sZiPlO4KOZ+X1XlkntGiJRPx3YzUS9JEnqN7WF6M7ALsDywG+B72bmGc1jbPsqSZK6xaRMj4qIpTPzgbbjUG+IiEWA04EFM3ODum0cMCszs/Zv/iWwLPA6W5ZJ8wcT9ZIkqdcNmn+5ODAVWDgzHx903DLA7pTW3y8CrgCOz8wbuxuxJEnqdwNtB6CRYUJGw6ne0PwNeG1ErFjbAjxdEzIL1Jugm4AJwJKtBivpHzLzwcw8F9jChIwkSeo1nYRMRCwREQcCt9Svr0TEJhExEBFj6v3L3zLz88CHgF8AbwXOiYgDWvwjSJKkPmRSRtLz9QtgCcqK+xfBP3o2z4yIhShzjGZT2iRJmo+YqJckST3uWOA/KVUyU4GPAcdQqvhnZ+acWulPZv4qMz8CHADcQ2lnRq3+lyRJGnG2L5P0DINaAIzLzKfr7z8LfB64DfgicDNlMOaOwKHA6Zm5VytBS5IkSeobdYHYnIh4N3AeZfHYtyjV++8Evl+3b5XP8uAjIsZn5oxuxSxJkgQmZSQNoXGDswVlWPilmXlVRCwBbAvsCqwBPFJPWQi4FtgkM2e3ErQkSZKkvhMRdwI3AJ/KzL/VbYsB51Aq/L8GLE+p6B8H3ErpGvJQZk5pLkiTJEnqhrFtByBp/hIRYzJzdkSsAXyTkmz5NkBmPhQRk4EpwOrABpQbmkuBK03ISJIkSRppjVky+wKvBHZrJGTGZObUiPg7sD7wjXraGMpiMoAAJgNTTMhIkqRus1JG0pAi4krgaWC/zLw5IgaAHHzT0mxvJkmSJEndEBFjgB8BWwM/pbRX/m2debkm8CvK4rKjKPc1j1MWlj0NvBo4MzOf7HQJaOGPIEmS+pRJGUnPEBHrABdT5seckJmzGvs6lTSLAOMy8+G24pQkSZLUnyIiKEmWTYA9gaUo1S9fAU6hVMZsm5kPPtdrWCkjSZK6zfZlkoYygXITc3dmzmrerDRalO0CLBoRR2fmtLYClSRJktR/6v3JLRFxB3AV8EHg48DOwERg62ZCptHyrHlvY0JGkiR13UDbAUiaLz0AzAHeVr+PiBioq9E6gzPfDLwF8EZGkiRJUisyc1pmXgf8X2A74HxgOnBgRLwrIibU40zESJKk+YJJGUlD+QtwObBHRLw3M+fUr84NzOspQzOnZOb0toKUJEmSJIDMfCQzLwAOAvagdAY5HzgpItbsLDCTJElqmzNlJP1Dc8hlRCwHnAq8FTgXOIyy4mxtYH9gscxcoZ1IJUmSJGloETEWWBnYhtLSbHHg68BBjXbMkiRJrTApI/W5oYZbNvotrwrsDWwNLEFpaTYA/BI4ODMv63rAkiRJkvQ8RMTCwJrAfsDtmXlgyyFJkiSZlJFURMTmwLaUm5ZbgauBs4BHKLNjXkJZbXYrcFVmPtBSqJIkSZL0vEXE4sAjdeHZP7oDSJIktcGkjNTHImJsZs6KiA8ARwIzgcsoLctWAvbOzOPbjFGSJEmSJEmSesVA2wFIakdtUTYrIgaAo4CLgI0zc2fgWOBx4IaIGIiIMRGxSOe81oKWJEmSJEmSpFHMpIzUpxpzZHakVMj8IDPvqKX9hwMnAP9TS/s3B74cEQsOnj8jSZIkSZIkSXp+TMpImglMBO6r3x9BmSPz7cycVretB6xPmSsjSZIkSZIkSXoBxrYdgKTuGzTc8u/AeGDJiFgW+AiwB3BPPfYVwIrAXzPzrhbClSRJkiRJkqSeEHYikvpHREwEnszMWYO2nwOsBUwHpmbmuo19H6G0Mts2M3/SxXAlSZIkSZIkqafYvkzqcRExUH9dFTgYOCYiFm3uA44E7gdWKZtjh4hYLSKOAj4LXGpCRpIkSZIkSZLmjZUyUp+IiJ8BrwEOzsyThti/IiUB825gibr5aeBk4LDMvLdLoUqSJEmSJElSTzIpI/WwzuyYiDgQ+BTw6cw8ue4bk5mz6+8Xysyn6u9fC6wMJPDnzLy5leAlSZIkSZIkqceYlJF6XG1VditwCnBEZj7a2Lc08EngPcAfgHOBMzNzZguhSpIkSZIkSVJPG9t2AJJG3AaU+VFXD0rIrA4cD7wdmAqsAGwJrAl8ussxSpIkSZIkSVLPG/j3h0ga5aYCLwWe6GyIiDdTEjLrAIcDbwHeB1wBHBARm3c/TEmSJEmSJEnqbVbKSL3vwfq1T0QA3A+cAKwN7AV8OzNnALdHxALARsBi7YQqSZIkSZIkSb3LpIzU4zLzfyPiOOBQ4N1AAE9S5sv8P4CIGMjMOcAY4FFgQlvxSpIkSZIkSVKvMikj9YHMPCwizgc+AUwDzgZuBoiIcZn5dEQsBLyecl04v7VgJUmSJEmSJKlHRWa2HYOkERS1Z1nWf+wRMSYzZ0dEZOMCEBHvAr4FnJ2Z+7QTrSRJkiRJkiT1LpMyUp9otCgbat8WwAHAgsA6z3acJEmSJEmSJOmFG2g7AEnd8RwJmdcCZwBzgL1NyEiSJEmSJEnSyLBSRhIRsTrwVGbe2XYskiRJkiRJktSrTMpIPSQiJmbmo3N5zr/MlpEkSZIkSZIkjQzbl0mjXESMqb/uCZwYEYsNcUw82/kmZCRJkiRJkiSpO0zKSKNYrXKZHRFjgS8DT1Jmw/yLTuIlIvw3L0mSJEmSJEktGdt2AJLmSQAJHAc8DJyYmY9BaWUGvAFYGvhjZl6fmXNqZc0cK2QkSZIkSZIkqbtMykijVK2SmRMRrwJ2A/YFbq37dgY+BazROP4SYI/MvKP70UqSJEmSJEmSbGUkjVKNSpfvAPcC12TmtJqkmQxMA7arX0cDqwM3RcS724hXkiRJkiRJkvpd2MFIGr0iYingQuD1wJnAwZQEzGLABztVMRExHtiCksC5HNgqM58xe0aSJEmSJEmSNHJMykijWEQMAMsB2wD7Ay+mVMDtCJydmRkRYzJzdj3+EOAg4OWZeV9LYUuSJEmSJElSX7J9mTSKZeaczPwzcBywMfBN4HfA1E57s8ycXZM3ANOBh4Gl2ohXkiRJkiRJkvqZlTJSD4mIRYGVM/PGxraoFTOLAl8GNgNel5lPtRWnJEmSJEmSJPUjK2WkHpKZjzUTMnVbJ/P6Tkpbs8kmZCRJkiRJkiSp+6yUkfpARGwPfA6YlplvbjseSZIkSZIkSepHVspIPa62LdseuBvYo+VwJEmSJEmSJKlvWSkj9YGIGAcsk5l3tx2LJEmSJEmSJPUrkzKSJEmSJEmSJEldYPsySZIkSZIkSZKkLjApI0mSJEmSJEmS1AUmZSRJkiRJkiRJkrrApIwkSZIkSZIkSVIXmJSRJEmSJEmSJEnqApMykiRJkiRJkiRJXWBSRpIkSZIkSZIkqQtMykiSJEnSMIiIkyPirrbjkCRJkjT/MikjSZIkqe9ExO4RkRFx3Vyet2xEfDEi1hqmOFarr7fCcLyeJEmSpPmbSRlJkiRJ/Wgn4C5gnYhYaS7OWxb4ArDWEPs+Dqwyl3GsVl9vhbk8T5IkSdIoZFJGkiRJUl+JiFcCbwX2Bf5OSdD8u3PGRsQCz3VMZj6dmTOGJ0pJkiRJvcikjCRJkqR+sxPwCHA+cCaDkjIRsUJtbbZ/RHwqIu4EZgC7AzfUw06qx2RE7FzPe8ZMmYjYISJuiojHI+KxiPhNROxd9+0MnFEPvazxehuMwJ9ZkiRJ0nxgbNsBSJIkSVKX7QScnZkzI+JUYLeIeFNm3jDouF2ACcBkSlLmHGAR4JC67cp63NVD/ZCI2AQ4FbgU+HTdvCqwHnAc8Evg68BewOHA7+oxv0OSJElSTzIpI0mSJKlvRMQbgNcAe9ZNVwH3UBI1g5MyLwdWysy/N86/kJKUuSYzT/k3P+7dwGPAppk5e/DOzPxjRFxJScr8PDMvn/s/kSRJkqTRxPZlkiRJkvrJTsD9wGUAmZnAacAOETFm0LFnNRMyL8BUYGFgk3l4DUmSJEk9xKSMJEmSpL5Qky47UBIyr4yIlSJiJeA64CXAOwad8qd5/JEnALcDF0bEPRHxXxHxrnl8TUmSJEmjmEkZSZIkSf1iI+CllMTMHY2v0+v+nQYdP21eflhmPgCsBWwBnAdsSEnQfG9eXleSJEnS6OVMGUmSJEn9YifgAWCPIfa9D9gqIib9m9fIufmBmTkT+Anwk4gYoFTP7BoRh2bmH+b29SRJkiSNbiZlJEmSJPW8iFiQkng5IzPPHGL/fcCOlKqW657jpZ6svy72PH7mEpn5UOf7zJwTEbfUb8fP7etJkiRJGv1MykiSJEnqB1sAi1DaiA3lWuDvlGqa50rK3AlMBSZFxOOUpMp1mTnU/JnvRMTiwC+Ae4DlgT2BXwO/q8f8GpgNfDoiJgIzgF/U1meSJEmSeowzZSRJkiT1g52A6cDPh9qZmXOA84F3AUs824tk5tPAhymJlBOBU4H1n+XwU+rP3J3StuzDwGnAZvXnkZl/AyYBSwPfra+32tz90SRJkiSNFpFpC2NJkiRJkiRJkqSRZqWMJEmSJEmSJElSF5iUkSRJkiRJkiRJ6gKTMpIkSZIkSZIkSV1gUkaSJEmSJEmSJKkLTMpIkiRJkiRJkiR1gUkZSZIkSZIkSZKkLjApI0mSJEmSJEmS1AUmZSRJkiRJkiRJkrrApIwkSZIkSZIkSVIXmJSRJEmSJEmSJEnqApMykiRJkiRJkiRJXWBSRpIkSZIkSZIkqQv+P30Ofdktrw+OAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -588,7 +588,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Improvement: 13.951589%\n" + "Improvement: 13.940685%\n" ] } ], @@ -660,7 +660,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -744,7 +744,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From 5eebc56f41d92a88885f832535558160402921a1 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 21 Mar 2023 19:56:24 +0100 Subject: [PATCH 22/65] Refactor futures module into futures packages --- src/pydvl/utils/parallel/futures/__init__.py | 34 +++++++++++++++++++ .../parallel/{futures.py => futures/ray.py} | 33 ++---------------- src/pydvl/value/shapley/truncated.py | 1 - tests/utils/test_parallel.py | 2 +- 4 files changed, 38 insertions(+), 32 deletions(-) create mode 100644 src/pydvl/utils/parallel/futures/__init__.py rename src/pydvl/utils/parallel/{futures.py => futures/ray.py} (91%) diff --git a/src/pydvl/utils/parallel/futures/__init__.py b/src/pydvl/utils/parallel/futures/__init__.py new file mode 100644 index 000000000..b27a12a67 --- /dev/null +++ b/src/pydvl/utils/parallel/futures/__init__.py @@ -0,0 +1,34 @@ +from concurrent.futures import Executor +from contextlib import contextmanager +from typing import Generator + +from pydvl.utils.config import ParallelConfig +from pydvl.utils.parallel.futures.ray import RayExecutor + +__all__ = ["init_executor", "RayExecutor"] + + +@contextmanager +def init_executor( + config: ParallelConfig = ParallelConfig(), +) -> Generator[Executor, None, None]: + """Initializes a futures executor based on the passed parallel configuration object. + + :param max_workers: Maximum number of concurrent tasks. + :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. + + :Example: + + >>> from pydvl.utils.parallel.futures import init_executor + >>> from pydvl.utils.config import ParallelConfig + >>> config = ParallelConfig(backend="ray") + >>> with init_executor(config=config) as executor: + ... pass + + """ + if config.backend == "ray": + max_workers = config.n_workers + with RayExecutor(max_workers, config=config) as executor: + yield executor + else: + raise NotImplementedError(f"Unexpected parallel type {config.backend}") diff --git a/src/pydvl/utils/parallel/futures.py b/src/pydvl/utils/parallel/futures/ray.py similarity index 91% rename from src/pydvl/utils/parallel/futures.py rename to src/pydvl/utils/parallel/futures/ray.py index addb12759..df648c63a 100644 --- a/src/pydvl/utils/parallel/futures.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -5,48 +5,21 @@ import time import types from concurrent.futures import BrokenExecutor, Executor, Future -from contextlib import contextmanager from dataclasses import asdict -from typing import Any, Callable, Generator, Optional, TypeVar +from typing import Any, Callable, Optional, TypeVar from weakref import ref import ray -from ..config import ParallelConfig +from pydvl.utils import ParallelConfig -__all__ = ["init_executor", "RayExecutor"] +__all__ = ["RayExecutor"] T = TypeVar("T") logger = logging.getLogger(__name__) -@contextmanager -def init_executor( - config: ParallelConfig = ParallelConfig(), -) -> Generator[Executor, None, None]: - """Initializes a futures executor based on the passed parallel configuration object. - - :param max_workers: Maximum number of concurrent tasks. - :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. - - :Example: - - >>> from pydvl.utils.parallel.futures import init_executor - >>> from pydvl.utils.config import ParallelConfig - >>> config = ParallelConfig(backend="ray") - >>> with init_executor(config=config) as executor: - ... pass - - """ - if config.backend == "ray": - max_workers = config.n_workers - with RayExecutor(max_workers, config=config) as executor: - yield executor - else: - raise NotImplementedError(f"Unexpected parallel type {config.backend}") - - class RayExecutor(Executor): """Asynchronous executor using Ray that implements the concurrent.futures API. diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 8f2c8555e..7a606575a 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -1,7 +1,6 @@ import abc import logging from concurrent.futures import FIRST_COMPLETED, wait -from typing import Optional import numpy as np from deprecate import deprecated diff --git a/tests/utils/test_parallel.py b/tests/utils/test_parallel.py index 9783c4ec6..a32ffafed 100644 --- a/tests/utils/test_parallel.py +++ b/tests/utils/test_parallel.py @@ -260,7 +260,7 @@ def func(_): assert total_time > max(1.0, 3 / num_workers) -@pytest.mark.parametrize("n_workers", [1, 2, 4]) +@pytest.mark.parametrize("n_workers", [1, 4]) def test_futures_executor_map_with_max_workers(n_workers, parallel_config): if parallel_config.backend != "ray" or parallel_config.address is not None: pytest.skip() From 9c00425693a3fdc3c9a5a60e210480936faa6880 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 21 Mar 2023 20:05:26 +0100 Subject: [PATCH 23/65] Use ThreadPoolExecutor with max_workers=1 for sequential parallel backend --- src/pydvl/utils/parallel/futures/__init__.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/pydvl/utils/parallel/futures/__init__.py b/src/pydvl/utils/parallel/futures/__init__.py index b27a12a67..739a46bd5 100644 --- a/src/pydvl/utils/parallel/futures/__init__.py +++ b/src/pydvl/utils/parallel/futures/__init__.py @@ -1,4 +1,4 @@ -from concurrent.futures import Executor +from concurrent.futures import Executor, ThreadPoolExecutor from contextlib import contextmanager from typing import Generator @@ -30,5 +30,9 @@ def init_executor( max_workers = config.n_workers with RayExecutor(max_workers, config=config) as executor: yield executor + elif config.backend == "sequential": + max_workers = 1 + with ThreadPoolExecutor(max_workers) as executor: + yield executor else: raise NotImplementedError(f"Unexpected parallel type {config.backend}") From 933ba65b3259fa2cd279359538f08cb1bfcf8b29 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 21 Mar 2023 20:05:56 +0100 Subject: [PATCH 24/65] Add calls to sleep inside work item manager thread loops --- src/pydvl/utils/parallel/futures/ray.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index df648c63a..611a23016 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -203,7 +203,8 @@ def __init__(self, executor: RayExecutor): def run(self) -> None: logger.debug("starting work item manager thread main loop") while True: - time.sleep(0.1) + # This is used to avoid using too much CPU + time.sleep(0.01) try: self.add_pending_item_to_work_queue() self.submit_work_item() @@ -222,6 +223,8 @@ def add_pending_item_to_work_queue(self) -> None: # Fills work_queue with _WorkItems from pending_queue. # This function never blocks. while True: + # This is used to avoid using too much CPU + time.sleep(0.01) with self.queue_lock: logger.debug("work item manager thread acquired queue lock") # If the work queue is not full, From a873edc874ebbc8c8b8ecfcaa6fb874b3f6fbe09 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 21 Mar 2023 20:06:06 +0100 Subject: [PATCH 25/65] Update tests --- tests/utils/test_parallel.py | 40 ++++++++---------------------------- 1 file changed, 8 insertions(+), 32 deletions(-) diff --git a/tests/utils/test_parallel.py b/tests/utils/test_parallel.py index a32ffafed..cae284f71 100644 --- a/tests/utils/test_parallel.py +++ b/tests/utils/test_parallel.py @@ -227,24 +227,21 @@ def get_pid(): def test_futures_executor_submit(parallel_config): - if parallel_config.backend != "ray": - with pytest.raises(NotImplementedError): - with init_executor(config=parallel_config): - ... - pytest.xfail("Currently this only works with Ray") - with init_executor(config=parallel_config) as executor: future = executor.submit(lambda x: x + 1, 1) result = future.result() assert result == 2 -def test_futures_executor_map(parallel_config, num_workers): +def test_futures_executor_map(parallel_config): + with init_executor(config=parallel_config) as executor: + results = list(executor.map(lambda x: x + 1, range(3))) + assert results == [1, 2, 3] + + +def test_futures_executor_map_with_max_workers(parallel_config, num_workers): if parallel_config.backend != "ray": - with pytest.raises(NotImplementedError): - with init_executor(config=parallel_config): - ... - pytest.xfail("Currently this only works with Ray") + pytest.skip("Currently this test only works with Ray") def func(_): time.sleep(1) @@ -258,24 +255,3 @@ def func(_): total_time = end_time - start_time # We expect the time difference to be > 3 / num_workers, but has to be at least 1 assert total_time > max(1.0, 3 / num_workers) - - -@pytest.mark.parametrize("n_workers", [1, 4]) -def test_futures_executor_map_with_max_workers(n_workers, parallel_config): - if parallel_config.backend != "ray" or parallel_config.address is not None: - pytest.skip() - - parallel_config.n_workers = n_workers - - def func(_): - time.sleep(1) - return time.monotonic() - - start_time = time.monotonic() - with init_executor(config=parallel_config) as executor: - assert executor._max_workers == n_workers - list(executor.map(func, range(3))) - end_time = time.monotonic() - total_time = end_time - start_time - # We expect the time difference to be > 3 / n_workers, but has to be at least 1 - assert total_time > max(1.0, 3 / n_workers) From 57c34de09d2780a2677079ed7a27d4977f79437e Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 21 Mar 2023 20:44:43 +0100 Subject: [PATCH 26/65] Allow using TMCS with sequential, update tests --- src/pydvl/value/shapley/truncated.py | 5 ----- tests/value/conftest.py | 2 -- tests/value/shapley/test_truncated.py | 3 --- 3 files changed, 10 deletions(-) diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 7a606575a..44d0d52b9 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -240,11 +240,6 @@ def truncated_montecarlo_shapley( :return: Object with the data values. """ - if config.backend != "ray": - raise NotImplementedError( - "Truncated MonteCarlo Shapley only works with " "the Ray parallel backend." - ) - n_jobs = effective_n_jobs(n_jobs, config) algorithm = "truncated_montecarlo_shapley" diff --git a/tests/value/conftest.py b/tests/value/conftest.py index 13ef6477f..2073415a2 100644 --- a/tests/value/conftest.py +++ b/tests/value/conftest.py @@ -126,8 +126,6 @@ def linear_shapley(linear_dataset, scorer, n_jobs): @pytest.fixture(scope="module", params=["sequential", "ray-local", "ray-external"]) def parallel_config(request): if request.param == "sequential": - # FIXME: instead test TMC separately - pytest.skip("Skipping 'sequential' because it doesn't work with TMC") yield ParallelConfig(backend=request.param) elif request.param == "ray-local": yield ParallelConfig(backend="ray") diff --git a/tests/value/shapley/test_truncated.py b/tests/value/shapley/test_truncated.py index 90d53d9ea..4727c087d 100644 --- a/tests/value/shapley/test_truncated.py +++ b/tests/value/shapley/test_truncated.py @@ -28,7 +28,6 @@ dict( done=MaxUpdates(500), truncation=NoTruncation(), - n_concurrent_computations=10, ), ), ], @@ -64,7 +63,6 @@ def test_tmcs_analytic_montecarlo_shapley( dict( done=MaxUpdates(500), truncation=NoTruncation(), - n_concurrent_computations=10, ), ), ], @@ -118,7 +116,6 @@ def test_tmcs_linear_montecarlo_shapley( dict( done=HistoryDeviation(n_steps=10, rtol=0.1) | MaxUpdates(500), truncation=NoTruncation(), - n_concurrent_computations=10, ), ), ], From c119a2b39917aa08dbc53c643963bb37892b1e30 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 21 Mar 2023 21:47:15 +0100 Subject: [PATCH 27/65] Add check to parallel config when using external ray cluster --- src/pydvl/utils/config.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/src/pydvl/utils/config.py b/src/pydvl/utils/config.py index 855f7bb29..c610249da 100644 --- a/src/pydvl/utils/config.py +++ b/src/pydvl/utils/config.py @@ -13,10 +13,13 @@ class ParallelConfig: """Configuration for parallel computation backend. - :param backend: Type of backend to use. For now only 'ray' is supported. + :param backend: Type of backend to use. + Defaults to 'ray' :param address: Address of existing remote or local cluster to use. + Defaults to None. :param n_workers: Number of workers (CPUs) to use. This has no effect when using an existing ray cluster. + Defaults to None. :param logging_level: Logging level for the parallel backend's worker. """ @@ -25,6 +28,10 @@ class ParallelConfig: n_workers: Optional[int] = None logging_level: int = logging.WARNING + def __post_init__(self) -> None: + if self.address is not None and self.n_workers is not None: + raise ValueError("When `address` is set, `n_workers` should be None.") + @dataclass class MemcachedClientConfig: From d8d5ae487c00fa3fac6f8229deeffaf45e9cd2e8 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 21 Mar 2023 21:47:26 +0100 Subject: [PATCH 28/65] Update tests --- tests/utils/conftest.py | 6 ++---- tests/utils/test_parallel.py | 2 +- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/tests/utils/conftest.py b/tests/utils/conftest.py index ebf322fdd..29968af6a 100644 --- a/tests/utils/conftest.py +++ b/tests/utils/conftest.py @@ -5,7 +5,7 @@ from pydvl.utils.config import ParallelConfig -@pytest.fixture(scope="function", params=["sequential", "ray-local", "ray-external"]) +@pytest.fixture(scope="module", params=["sequential", "ray-local", "ray-external"]) def parallel_config(request, num_workers): if request.param == "sequential": yield ParallelConfig(backend=request.param) @@ -20,8 +20,6 @@ def parallel_config(request, num_workers): "num_cpus": num_workers, }, ) - yield ParallelConfig( - backend="ray", address=cluster.address, n_workers=num_workers - ) + yield ParallelConfig(backend="ray", address=cluster.address) ray.shutdown() cluster.shutdown() diff --git a/tests/utils/test_parallel.py b/tests/utils/test_parallel.py index cae284f71..2d0037abd 100644 --- a/tests/utils/test_parallel.py +++ b/tests/utils/test_parallel.py @@ -22,7 +22,7 @@ def test_effective_n_jobs(parallel_config, num_workers): assert parallel_backend.effective_n_jobs(1) == 1 assert parallel_backend.effective_n_jobs(4) == 4 if parallel_config.address is None: - assert parallel_backend.effective_n_jobs(-1) == available_cpus() + assert parallel_backend.effective_n_jobs(-1) == num_workers else: assert parallel_backend.effective_n_jobs(-1) == num_workers From 898f04b44cf76cfcc88358684e80d7c328ef0eb5 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 21 Mar 2023 21:56:24 +0100 Subject: [PATCH 29/65] Check if work item manager thread exists before calling join --- src/pydvl/utils/parallel/futures/ray.py | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index 611a23016..715a0e77f 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -117,11 +117,14 @@ def shutdown(self, wait: bool = True, *, cancel_futures: bool = False) -> None: if wait: logger.debug("executor waiting for futures to finish") - # Putting None in the queue to signal - # to work item manager thread that we are shutting down - self._put_work_item_in_queue(None) - logger.debug("executor waiting for work item manager thread to terminate") - self._work_item_manager_thread.join() + if self._work_item_manager_thread is not None: + # Putting None in the queue to signal + # to work item manager thread that we are shutting down + self._put_work_item_in_queue(None) + logger.debug( + "executor waiting for work item manager thread to terminate" + ) + self._work_item_manager_thread.join() # To reduce the risk of opening too many files, remove references to # objects that use file descriptors. self._work_item_manager_thread = None From 73c6aa18dcdd1fb8745feb84905a7d26e0d523eb Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 21 Mar 2023 22:01:21 +0100 Subject: [PATCH 30/65] Fix type hints --- src/pydvl/utils/parallel/futures/ray.py | 24 ++++++++++++++---------- src/pydvl/value/shapley/common.py | 2 +- 2 files changed, 15 insertions(+), 11 deletions(-) diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index 715a0e77f..902bb5cd4 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -76,8 +76,12 @@ def __init__( self._cancel_pending_futures = False self._shutdown_lock = threading.Lock() self._queue_lock = threading.Lock() - self._work_queue = queue.Queue(maxsize=self._max_workers) - self._pending_queue = queue.SimpleQueue() + self._work_queue: "queue.Queue[Optional[_WorkItem]]" = queue.Queue( + maxsize=self._max_workers + ) + self._pending_queue: "queue.SimpleQueue[Optional[_WorkItem]]" = ( + queue.SimpleQueue() + ) # Work Item Manager Thread self._work_item_manager_thread: Optional[_WorkItemManagerThread] = None @@ -101,7 +105,7 @@ def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": raise RuntimeError("cannot schedule new futures after shutdown") logging.debug("Creating future and putting work item in work queue") - future = Future() + future: "Future[T]" = Future() w = _WorkItem(future, fn, args, kwargs) self._put_work_item_in_queue(w) # We delay starting the thread until the first call to submit @@ -128,8 +132,8 @@ def shutdown(self, wait: bool = True, *, cancel_futures: bool = False) -> None: # To reduce the risk of opening too many files, remove references to # objects that use file descriptors. self._work_item_manager_thread = None - self._work_queue = None - self._pending_queue = None + del self._work_queue + del self._pending_queue def _put_work_item_in_queue(self, work_item: Optional["_WorkItem"]) -> None: with self._queue_lock: @@ -176,7 +180,7 @@ def set_future(data: Any) -> None: ref._on_completed(set_future) # Prevent this object ref from being released. - self.future.object_ref = ref + self.future.object_ref = ref # type: ignore if sys.version_info >= (3, 9): __class_getitem__ = classmethod(types.GenericAlias) @@ -197,10 +201,10 @@ def __init__(self, executor: RayExecutor): self.executor_reference = ref(executor) self.shutdown_lock: threading.Lock = executor._shutdown_lock self.queue_lock: threading.Lock = executor._queue_lock - self.work_queue: Optional["queue.Queue[_WorkItem]"] = executor._work_queue - self.pending_queue: Optional[ - "queue.SimpleQueue[_WorkItem]" - ] = executor._pending_queue + self.work_queue: "queue.Queue[Optional[_WorkItem]]" = executor._work_queue + self.pending_queue: "queue.SimpleQueue[Optional[_WorkItem]]" = ( + executor._pending_queue + ) super().__init__() def run(self) -> None: diff --git a/src/pydvl/value/shapley/common.py b/src/pydvl/value/shapley/common.py index 023671600..20214d202 100644 --- a/src/pydvl/value/shapley/common.py +++ b/src/pydvl/value/shapley/common.py @@ -100,7 +100,7 @@ def compute_shapley_values( if mode == ShapleyMode.TruncatedMontecarlo: truncation = kwargs.pop("truncation", NoTruncation()) - return truncated_montecarlo_shapley( + return truncated_montecarlo_shapley( # type: ignore u=u, done=done, n_jobs=n_jobs, truncation=truncation, **kwargs ) elif mode == ShapleyMode.CombinatorialMontecarlo: From fc74d147647d537ee4ec76fa79919b6c8baaca75 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 28 Mar 2023 12:19:09 +0200 Subject: [PATCH 31/65] Track submitted futures in a weakset, call ray.cancel to cancel the tasks --- src/pydvl/utils/parallel/futures/ray.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index 902bb5cd4..043b7a01b 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -7,7 +7,7 @@ from concurrent.futures import BrokenExecutor, Executor, Future from dataclasses import asdict from typing import Any, Callable, Optional, TypeVar -from weakref import ref +from weakref import WeakSet, ref import ray @@ -205,6 +205,7 @@ def __init__(self, executor: RayExecutor): self.pending_queue: "queue.SimpleQueue[Optional[_WorkItem]]" = ( executor._pending_queue ) + self.submitted_futures: "WeakSet[Future]" = WeakSet() super().__init__() def run(self) -> None: @@ -268,6 +269,7 @@ def submit_work_item(self) -> None: return logger.debug("Submitting work item") work_item.run() + self.submitted_futures.add(work_item.future) # Delete references to object del work_item @@ -297,10 +299,16 @@ def flag_executor_shutting_down(self): executor._shutdown = True # Cancel pending work items if requested. if executor._cancel_pending_futures: - logger.debug("forcefully cancelling futures") + logger.debug("forcefully cancelling running futures") + # We cancel all the submitted futures + # and their corresponding object references + for future in self.submitted_futures: + future.cancel() + ray.cancel(future.object_ref) # Drain all work items from the queues, # and then cancel their associated futures. # We empty the pending queue first. + logger.debug("cancelling pending work items") while True: with self.queue_lock: try: From 13771d026ac9918cf85f1e40e72b76598e42b569 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 28 Mar 2023 13:43:08 +0200 Subject: [PATCH 32/65] Override the base Executor class' __exit__ method --- src/pydvl/utils/parallel/futures/ray.py | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index 043b7a01b..92122d09a 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -148,6 +148,16 @@ def _start_work_item_manager_thread(self) -> None: self._work_item_manager_thread = _WorkItemManagerThread(self) self._work_item_manager_thread.start() + def __exit__(self, exc_type, exc_val, exc_tb): + """Exit the runtime context related to the RayExecutor object. + + This explicitly sets cancel_futures to True + in the call to the shutdown() method which is different + from the base Executor class' __exit__ method. + """ + self.shutdown(cancel_futures=True) + return False + class _WorkItem: """Inspired by code from: concurrent.futures.thread""" @@ -300,10 +310,9 @@ def flag_executor_shutting_down(self): # Cancel pending work items if requested. if executor._cancel_pending_futures: logger.debug("forcefully cancelling running futures") - # We cancel all the submitted futures - # and their corresponding object references + # We cancel the future's object references + # We cannot cancel a running future object. for future in self.submitted_futures: - future.cancel() ray.cancel(future.object_ref) # Drain all work items from the queues, # and then cancel their associated futures. From f0ed3f0527ba489b8e2751a9f0f101f74ede0792 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 28 Mar 2023 13:59:34 +0200 Subject: [PATCH 33/65] Recommend using init_executor instead of instantiating executor directly --- src/pydvl/utils/parallel/backend.py | 15 ++++++++++----- src/pydvl/utils/parallel/futures/ray.py | 3 +++ 2 files changed, 13 insertions(+), 5 deletions(-) diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index c24e98568..9b70cbbe8 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -92,8 +92,10 @@ def __repr__(self) -> str: class SequentialParallelBackend(BaseParallelBackend, backend_name="sequential"): - """Class used to run jobs sequentially and locally. It shouldn't - be initialized directly. You should instead call `init_parallel_backend`. + """Class used to run jobs sequentially and locally. + + It shouldn't be initialized directly. You should instead call + :function:`~pydvl.utils.parallel.backend.init_parallel_backend`. :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with number of cpus """ @@ -121,8 +123,10 @@ def _effective_n_jobs(self, n_jobs: int) -> int: class RayParallelBackend(BaseParallelBackend, backend_name="ray"): - """Class used to wrap ray to make it transparent to algorithms. It shouldn't - be initialized directly. You should instead call `init_parallel_backend`. + """Class used to wrap ray to make it transparent to algorithms. + + It shouldn't be initialized directly. You should instead call + :function:`~pydvl.utils.parallel.backend.init_parallel_backend`. :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. @@ -196,7 +200,8 @@ def init_parallel_backend( ) -> BaseParallelBackend: """Initializes the parallel backend and returns an instance of it. - :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. + :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` + with cluster address, number of cpus, etc. :Example: diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index 92122d09a..fbb6bcf37 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -23,6 +23,9 @@ class RayExecutor(Executor): """Asynchronous executor using Ray that implements the concurrent.futures API. + It shouldn't be initialized directly. You should instead call + :function:`~pydvl.utils.parallel.futures.init_executor`. + :param max_workers: Maximum number of concurrent tasks. :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. From 0bbc10a608bb83b9047a9ae217177b3481399639 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 28 Mar 2023 14:58:02 +0200 Subject: [PATCH 34/65] Fix docstrings --- src/pydvl/utils/parallel/backend.py | 4 ++-- src/pydvl/utils/parallel/futures/__init__.py | 17 +++++++++++++++- src/pydvl/utils/parallel/futures/ray.py | 21 +++----------------- 3 files changed, 21 insertions(+), 21 deletions(-) diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index 9b70cbbe8..326b56bb0 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -95,7 +95,7 @@ class SequentialParallelBackend(BaseParallelBackend, backend_name="sequential"): """Class used to run jobs sequentially and locally. It shouldn't be initialized directly. You should instead call - :function:`~pydvl.utils.parallel.backend.init_parallel_backend`. + :func:`~pydvl.utils.parallel.backend.init_parallel_backend`. :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with number of cpus """ @@ -126,7 +126,7 @@ class RayParallelBackend(BaseParallelBackend, backend_name="ray"): """Class used to wrap ray to make it transparent to algorithms. It shouldn't be initialized directly. You should instead call - :function:`~pydvl.utils.parallel.backend.init_parallel_backend`. + :func:`~pydvl.utils.parallel.backend.init_parallel_backend`. :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. diff --git a/src/pydvl/utils/parallel/futures/__init__.py b/src/pydvl/utils/parallel/futures/__init__.py index 739a46bd5..432f6112b 100644 --- a/src/pydvl/utils/parallel/futures/__init__.py +++ b/src/pydvl/utils/parallel/futures/__init__.py @@ -5,7 +5,7 @@ from pydvl.utils.config import ParallelConfig from pydvl.utils.parallel.futures.ray import RayExecutor -__all__ = ["init_executor", "RayExecutor"] +__all__ = ["init_executor"] @contextmanager @@ -25,6 +25,21 @@ def init_executor( >>> with init_executor(config=config) as executor: ... pass + >>> from pydvl.utils.parallel.futures import init_executor + >>> with init_executor() as executor: + ... future = executor.submit(lambda x: x + 1, 1) + ... result = future.result() + ... + >>> print(result) + 2 + + >>> from pydvl.utils.parallel.futures import init_executor + >>> with init_executor() as executor: + ... results = list(executor.map(lambda x: x + 1, range(5))) + ... + >>> print(results) + [1, 2, 3, 4, 5] + """ if config.backend == "ray": max_workers = config.n_workers diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index fbb6bcf37..a3ad4aacd 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -24,26 +24,11 @@ class RayExecutor(Executor): """Asynchronous executor using Ray that implements the concurrent.futures API. It shouldn't be initialized directly. You should instead call - :function:`~pydvl.utils.parallel.futures.init_executor`. + :func:`~pydvl.utils.parallel.futures.init_executor`. :param max_workers: Maximum number of concurrent tasks. - :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. - - Example: - >>> from pydvl.utils.parallel.futures import RayExecutor - >>> with RayExecutor() as executor: - ... future = executor.submit(lambda x: x + 1, 1) - ... result = future.result() - ... - >>> print(result) - 2 - - >>> from pydvl.utils.parallel.futures import RayExecutor - >>> with RayExecutor() as executor: - ... results = list(executor.map(lambda x: x + 1, range(5))) - ... - >>> print(results) - [1, 2, 3, 4, 5] + :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` + with cluster address, number of cpus, etc. """ def __init__( From 2769bbacf4fdc62995a7e8798938c3a67a7f0fe2 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Wed, 29 Mar 2023 13:08:02 +0200 Subject: [PATCH 35/65] Change get to pop in compute_semivalues. --- src/pydvl/value/semivalues.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 2fac0df56..6dfb94116 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -232,8 +232,8 @@ def compute_semivalues( if mode == SemiValueMode.Shapley: coefficient = shapley_coefficient elif mode == SemiValueMode.BetaShapley: - alpha = kwargs.get("alpha", 1) - beta = kwargs.get("beta", 1) + alpha = kwargs.pop("alpha", 1) + beta = kwargs.pop("beta", 1) coefficient = beta_coefficient(alpha, beta) elif mode == SemiValueMode.Banzhaf: coefficient = banzhaf_coefficient From a04c977f2099d05d16d55357b09fe636054e68bb Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 31 Mar 2023 10:58:56 +0200 Subject: [PATCH 36/65] Fix publish CI workflow --- .github/workflows/publish.yaml | 36 ++++++++++++++++++++++++++-------- 1 file changed, 28 insertions(+), 8 deletions(-) diff --git a/.github/workflows/publish.yaml b/.github/workflows/publish.yaml index 5053608d6..c0203716e 100644 --- a/.github/workflows/publish.yaml +++ b/.github/workflows/publish.yaml @@ -10,6 +10,10 @@ on: description: Why did you trigger the pipeline? required: False default: Check if it runs again due to external changes + tag: + description: Tag for which a package should be published + type: string + required: false env: PY_COLORS: 1 @@ -23,19 +27,35 @@ jobs: - uses: actions/checkout@v3 with: fetch-depth: 0 - - name: Fail if manually triggered workflow is not on 'master' branch - if: github.event_name == 'workflow_dispatch' && github.ref_name != 'master' - run: exit -1 + - name: Fail if manually triggered workflow does not have 'tag' input + if: github.event_name == 'workflow_dispatch' && inputs.tag == '' + run: | + echo "Input 'tag' should not be empty" + exit -1 + - name: Extract branch name from input + id: get_branch_name_input + if: github.event_name == 'workflow_dispatch' + run: | + export BRANCH_NAME=$(git log -1 --format='%D' ${{ inputs.tag }} | sed -e 's/.*origin\/\(.*\).*/\1/') + echo "branch_name=${BRANCH_NAME}" >> $GITHUB_OUTPUT - name: Extract branch name from tag - id: get_branch_name + id: get_branch_name_tag if: github.ref_type == 'tag' run: | - export BRANCH_NAME=$(git log -1 --format='%D' $GITHUB_REF | sed -e 's/.*origin\/\(.*\),.*/\1/') - echo ::set-output name=branch_name::${BRANCH_NAME} + export BRANCH_NAME=$(git log -1 --format='%D' $GITHUB_REF | sed -e 's/.*origin\/\(.*\).*/\1/') + echo "branch_name=${BRANCH_NAME}" >> $GITHUB_OUTPUT shell: bash - name: Fail if tag is not on 'master' branch - if: github.ref_type == 'tag' && steps.get_branch_name.outputs.branch_name != 'master' - run: exit -1 + if: ${{ steps.get_branch_name_tag.outputs.branch_name != 'master' && steps.get_branch_name_input.outputs.branch_name != 'master' }} + run: | + echo "Tag is on branch ${{ steps.get_branch_name.outputs.branch_name }}" + echo "Should be on Master branch instead" + exit -1 + - name: Fail if running locally + if: ${{ !github.event.act }} # skip during local actions testing + run: | + echo "Running action locally. Failing" + exit -1 - name: Set up Python 3.8 uses: actions/setup-python@v4 with: From a8d149b94967e7a429683f753b0a04400cbf3a07 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 31 Mar 2023 10:59:34 +0200 Subject: [PATCH 37/65] Make naming consistent in publish CI workflow --- .github/workflows/publish.yaml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/publish.yaml b/.github/workflows/publish.yaml index c0203716e..2ea899fa3 100644 --- a/.github/workflows/publish.yaml +++ b/.github/workflows/publish.yaml @@ -1,4 +1,4 @@ -name: Upload Python Package to PyPI +name: Publish Python Package to PyPI on: push: @@ -19,10 +19,10 @@ env: PY_COLORS: 1 jobs: - deploy: + publish: runs-on: ubuntu-latest concurrency: - group: deploy + group: publish steps: - uses: actions/checkout@v3 with: From 17c31059a8ebeb5dc8fc694328935f020e503914 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 31 Mar 2023 11:01:15 +0200 Subject: [PATCH 38/65] Add instructions for running github actions locally --- CONTRIBUTING.md | 109 ++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 102 insertions(+), 7 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 8e22923ab..d9b072073 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -261,6 +261,101 @@ sizeable amount of time, so care must be taken not to overdo it: 2. We try not to trigger CI pipelines when unnecessary (see [Skipping CI runs](#skipping-ci-runs)). +### Running Github Actions locally + +To run Github Actions locally we use [act](https://github.com/nektos/act). +It uses the workflows defined in `.github/workflows` and determines +the set of actions that need to be run. It uses the Docker API +to either pull or build the necessary images, as defined +in our workflow files and finally determines the execution path +based on the dependencies that were defined. + +Once it has the execution path, it then uses the Docker API +to run containers for each action based on the images prepared earlier. +The [environment variables](https://docs.github.com/en/actions/learn-github-actions/variables#default-environment-variables) +and [filesystem](https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners#file-systems) are all configured to match +what GitHub provides. + +You can install it manually using: + +```shell +curl -s https://raw.githubusercontent.com/nektos/act/master/install.sh | sudo bash -s -- -d -b ~/bin +``` + +And then simply add it to your PATH variable: `PATH=~/bin:$PATH` + +Refer to its official +[readme](https://github.com/nektos/act#installation-through-package-managers) +for more installation options. + +#### Cheatsheat + +```shell +# List all actions for all events: +act -l + +# List the actions for a specific event: +act workflow_dispatch -l + +# List the actions for a specific job: +act -j lint -l + +# Run the default (`push`) event: +act + +# Run a specific event: +act pull_request + +# Run a specific job: +act -j lint + +# Collect artifacts to the /tmp/artifacts folder: +act --artifact-server-path /tmp/artifacts + +# Run a job in a specific workflow (useful if you have duplicate job names) +act -j lint -W .github/workflows/tox.yml + +# Run in dry-run mode: +act -n + +# Enable verbose-logging (can be used with any of the above commands) +act -v +``` + +#### Example + +To run the `deploy` job (the toughest one to test) with tag 'v0.6.0' +you would simply use: + +```shell +act push -j deploy --eventpath events.json +``` + +With `events.json` containing: + +```json +{ + "ref": "refs/tags/v0.6.0" +} +``` + +To instead run it as it were manually triggered (i.e. `workflow_dispatch`) +you would instead use: + +```shell +act workflow_dispatch -j deploy --eventpath events.json +``` + +With `events.json` containing: + +```json +{ + "inputs": { + "tag": "v0.6.0" + } +} +``` + ### Skipping CI runs One sometimes would like to skip CI for certain commits (e.g. updating the @@ -348,10 +443,10 @@ create a new release manually by following these steps: 8. Pour yourself a cup of coffee, you earned it! :coffee: :sparkles: 9. A package will be automatically created and published from CI to PyPI. -### CI and requirements for releases +### CI and requirements for publishing -In order to release new versions of the package from the development branch, the -CI pipeline requires the following secret variables set up: +In order to publish new versions of the package from the development branch, +the CI pipeline requires the following secret variables set up: ``` TEST_PYPI_USERNAME @@ -367,13 +462,13 @@ The last 2 are used in the [publish.yaml](.github/workflows/publish.yaml) CI workflow to publish packages to [PyPI](https://pypi.org/) from `develop` after a GitHub release. -#### Release to TestPyPI +#### Publish to TestPyPI -We use [bump2version](https://pypi.org/project/bump2version/) to bump the build -part of the version number, create a tag and push it from CI. +We use [bump2version](https://pypi.org/project/bump2version/) to bump +the build part of the version number publish a package to TestPyPI from CI. To do that, we use 2 different tox environments: - **bump-dev-version**: Uses bump2version to bump the dev version, - without committing the new version or creating a corresponding git tag. + without committing the new version or creating a corresponding git tag. - **publish-test-package**: Builds and publishes a package to TestPyPI From 2ea227fb7750a94f5d2506155aa65b198ee9cd00 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 31 Mar 2023 12:08:09 +0200 Subject: [PATCH 39/65] Use 'publish' instead of 'deploy' --- CONTRIBUTING.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index d9b072073..d9e84f249 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -324,11 +324,11 @@ act -v #### Example -To run the `deploy` job (the toughest one to test) with tag 'v0.6.0' +To run the `publish` job (the toughest one to test) with tag 'v0.6.0' you would simply use: ```shell -act push -j deploy --eventpath events.json +act push -j publish --eventpath events.json ``` With `events.json` containing: @@ -343,7 +343,7 @@ To instead run it as it were manually triggered (i.e. `workflow_dispatch`) you would instead use: ```shell -act workflow_dispatch -j deploy --eventpath events.json +act workflow_dispatch -j publish --eventpath events.json ``` With `events.json` containing: From 7713a374d948a7576510deaa2848c458045ddb46 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 31 Mar 2023 12:09:33 +0200 Subject: [PATCH 40/65] Update changelog --- CHANGELOG.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index cff8d31d3..6942505b2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,10 @@ # Changelog +## Unreleased + +- Fix release job not triggering on CI when a new tag is pushed + [PR #331](https://github.com/appliedAI-Initiative/pyDVL/pull/331) + ## 0.6.0 - 🆕 New algorithms, cleanup and bug fixes 🏗 - Fixes in `ValuationResult`: bugs around data names, semantics of From 98e0033f6512f888f53707d5915039fa12ce317c Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 31 Mar 2023 13:21:17 +0200 Subject: [PATCH 41/65] Apply suggestions from code review Co-authored-by: Miguel de Benito Delgado --- CONTRIBUTING.md | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index d9e84f249..6bd181636 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -273,8 +273,8 @@ based on the dependencies that were defined. Once it has the execution path, it then uses the Docker API to run containers for each action based on the images prepared earlier. The [environment variables](https://docs.github.com/en/actions/learn-github-actions/variables#default-environment-variables) -and [filesystem](https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners#file-systems) are all configured to match -what GitHub provides. +and [filesystem](https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners#file-systems) +are all configured to match what GitHub provides. You can install it manually using: @@ -339,7 +339,8 @@ With `events.json` containing: } ``` -To instead run it as it were manually triggered (i.e. `workflow_dispatch`) +To instead run it as if it had been manually triggered (i.e. `workflow_dispatch`) + you would instead use: ```shell @@ -465,7 +466,7 @@ a GitHub release. #### Publish to TestPyPI We use [bump2version](https://pypi.org/project/bump2version/) to bump -the build part of the version number publish a package to TestPyPI from CI. +the build part of the version number and publish a package to TestPyPI from CI. To do that, we use 2 different tox environments: From 03f52135d844724cad1db7d2f42f78318db43738 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 31 Mar 2023 13:28:36 +0200 Subject: [PATCH 42/65] Update CHANGELOG.md Co-authored-by: Anes Benmerzoug --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2b5474459..12ec3a0e5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,7 @@ ## Unreleased - Added alias `ApproShapley` from Castro et al. 2009 for permutation Shapley + [PR #332](https://github.com/appliedAI-Initiative/pyDVL/pull/332) ## 0.6.0 - 🆕 New algorithms, cleanup and bug fixes 🏗 From c7448dddccad3bfa5d496c10255e99f6f8cc5f23 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 3 Apr 2023 12:32:48 +0200 Subject: [PATCH 43/65] Add n_cpus_per_job field to ParallelConfig --- src/pydvl/utils/config.py | 3 +++ src/pydvl/utils/parallel/backend.py | 15 +++++++++++---- src/pydvl/utils/parallel/futures/ray.py | 23 ++++++++++++++++------- 3 files changed, 30 insertions(+), 11 deletions(-) diff --git a/src/pydvl/utils/config.py b/src/pydvl/utils/config.py index c610249da..614525b00 100644 --- a/src/pydvl/utils/config.py +++ b/src/pydvl/utils/config.py @@ -20,12 +20,15 @@ class ParallelConfig: :param n_workers: Number of workers (CPUs) to use. This has no effect when using an existing ray cluster. Defaults to None. + :param n_cpus_per_job: Number of CPUs to use per job. + Defaults to 1.0. :param logging_level: Logging level for the parallel backend's worker. """ backend: Literal["sequential", "ray"] = "ray" address: Optional[Union[str, Tuple[str, int]]] = None n_workers: Optional[int] = None + n_cpus_per_job: float = 1.0 logging_level: int = logging.WARNING def __post_init__(self) -> None: diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index 326b56bb0..c2e6d6686 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -135,7 +135,10 @@ class RayParallelBackend(BaseParallelBackend, backend_name="ray"): def __init__(self, config: ParallelConfig): config_dict = asdict(config) config_dict.pop("backend") - config_dict["num_cpus"] = config_dict.pop("n_workers") + n_workers = config_dict.pop("n_workers") + if config_dict.get("address", None) is None: + config_dict["num_cpus"] = n_workers + self.n_cpus_per_job = config_dict.pop("n_cpus_per_job") self.config = config_dict if not ray.is_initialized(): ray.init(**self.config) @@ -168,9 +171,13 @@ def wrap(self, fun: Callable, **kwargs) -> Callable: :return: The `.remote` method of the ray `RemoteFunction`. """ - if len(kwargs) > 1: - return ray.remote(**kwargs)(fun).remote # type: ignore - return ray.remote(fun).remote # type: ignore + remote_fn = ray.remote(fun) + if len(kwargs) == 0: + kwargs["num_cpus"] = self.n_cpus_per_job + else: + if "num_cpus" not in kwargs: + kwargs["num_cpus"] = self.n_cpus_per_job + return remote_fn.remote # type: ignore def wait( self, diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index a3ad4aacd..9fa81915d 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -49,7 +49,8 @@ def __init__( config_dict = asdict(config) config_dict.pop("backend") config_dict.pop("n_workers") - if "address" not in config_dict: + self.n_cpus_per_job = config_dict.pop("n_cpus_per_job") + if config_dict.get("address", None) is None: config_dict["num_cpus"] = max_workers self.config = config_dict if not ray.is_initialized(): @@ -94,7 +95,7 @@ def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": logging.debug("Creating future and putting work item in work queue") future: "Future[T]" = Future() - w = _WorkItem(future, fn, args, kwargs) + w = _WorkItem(future, fn, args, kwargs, n_cpus_per_job=self.n_cpus_per_job) self._put_work_item_in_queue(w) # We delay starting the thread until the first call to submit self._start_work_item_manager_thread() @@ -150,21 +151,29 @@ def __exit__(self, exc_type, exc_val, exc_tb): class _WorkItem: """Inspired by code from: concurrent.futures.thread""" - def __init__(self, future: Future, fn: Callable, args: Any, kwargs: Any): + def __init__( + self, + future: Future, + fn: Callable, + args: Any, + kwargs: Any, + *, + n_cpus_per_job: float, + ): self.future = future self.fn = fn self.args = args self.kwargs = kwargs + self.n_cpus_per_job = n_cpus_per_job def run(self) -> None: if not self.future.set_running_or_notify_cancel(): return remote_fn = ray.remote(self.fn) - # TODO: we assign 1 CPU to each task which could be wasteful. - ref = remote_fn.options(name=self.fn.__name__, num_cpus=1).remote( - *self.args, **self.kwargs - ) + ref = remote_fn.options( + name=self.fn.__name__, num_cpus=self.n_cpus_per_job + ).remote(*self.args, **self.kwargs) # Almost verbatim copy of `future()` method of ClientObjectRef def set_future(data: Any) -> None: From 27c6cff485f1b95ba1acae5803a0f51ca1285a54 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 3 Apr 2023 12:35:20 +0200 Subject: [PATCH 44/65] Add cancel_futures_on_exit parameter to RayExecutor --- src/pydvl/utils/parallel/futures/ray.py | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index 9fa81915d..650b46789 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -29,6 +29,10 @@ class RayExecutor(Executor): :param max_workers: Maximum number of concurrent tasks. :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. + :param cancel_futures_on_exit: If True, all futures will be cancelled + when exiting the context created by using this class instance + as a context manager. It will be ignored when calling `shutdown()` + directly. """ def __init__( @@ -36,6 +40,7 @@ def __init__( max_workers: Optional[int] = None, *, config: ParallelConfig = ParallelConfig(), + cancel_futures_on_exit: bool = True, ): if config.backend != "ray": raise ValueError( @@ -46,6 +51,8 @@ def __init__( raise ValueError("max_workers must be greater than 0") max_workers = max_workers + self.cancel_futures_on_exit = cancel_futures_on_exit + config_dict = asdict(config) config_dict.pop("backend") config_dict.pop("n_workers") @@ -140,11 +147,11 @@ def _start_work_item_manager_thread(self) -> None: def __exit__(self, exc_type, exc_val, exc_tb): """Exit the runtime context related to the RayExecutor object. - This explicitly sets cancel_futures to True - in the call to the shutdown() method which is different - from the base Executor class' __exit__ method. + This explicitly sets cancel_futures to be equal to cancel_futures_on_exit + attribute set at instantiation time in the call to the `shutdown()` method + which is different from the base Executor class' __exit__ method. """ - self.shutdown(cancel_futures=True) + self.shutdown(cancel_futures=self.cancel_futures_on_exit) return False From ee46ecf1306012a7c94ba3962cd13c1313315697 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 3 Apr 2023 12:38:46 +0200 Subject: [PATCH 45/65] Apply suggestions from code review Co-authored-by: Miguel de Benito Delgado --- src/pydvl/utils/parallel/futures/ray.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index 650b46789..7c3364d40 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -92,6 +92,8 @@ def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": :param args: Positional arguments that will be passed to `fn`. :param kwargs: Keyword arguments that will be passed to `fn`. :return: A Future representing the given call. + :raises BrokenExecutor: If ... + :raises RuntimeError: If a task is submitted after the executor has been shut down. """ with self._shutdown_lock: logger.debug("executor acquired shutdown lock") From f1a9a65cacc4886a81e7b2e7359e4cc6a8e564df Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 3 Apr 2023 12:42:04 +0200 Subject: [PATCH 46/65] Remove private broken flag from RayExecutor It was not used --- src/pydvl/utils/parallel/futures/ray.py | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index 7c3364d40..fbc38ee5e 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -4,7 +4,7 @@ import threading import time import types -from concurrent.futures import BrokenExecutor, Executor, Future +from concurrent.futures import Executor, Future from dataclasses import asdict from typing import Any, Callable, Optional, TypeVar from weakref import WeakSet, ref @@ -67,7 +67,6 @@ def __init__( if self._max_workers is None: self._max_workers = int(ray._private.state.cluster_resources()["CPU"]) - self._broken = False self._shutdown = False self._cancel_pending_futures = False self._shutdown_lock = threading.Lock() @@ -92,13 +91,10 @@ def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": :param args: Positional arguments that will be passed to `fn`. :param kwargs: Keyword arguments that will be passed to `fn`. :return: A Future representing the given call. - :raises BrokenExecutor: If ... :raises RuntimeError: If a task is submitted after the executor has been shut down. """ with self._shutdown_lock: logger.debug("executor acquired shutdown lock") - if self._broken: - raise BrokenExecutor(self._broken) if self._shutdown: raise RuntimeError("cannot schedule new futures after shutdown") From 7210663080d61d4d1dfabd4309f9367d718495fe Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 3 Apr 2023 12:44:17 +0200 Subject: [PATCH 47/65] Update changelog --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 42d8134a6..fa7ca2a06 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,7 +5,7 @@ - Create new `RayExecutor` class based on the concurrent.futures API, use the new class to fix an issue with Truncated Monte Carlo Shapley (TMCS) starting - too many processes and dying + too many processes and dying, plus other small changes [PR #329](https://github.com/appliedAI-Initiative/pyDVL/pull/329) - Fix release job not triggering on CI when a new tag is pushed [PR #331](https://github.com/appliedAI-Initiative/pyDVL/pull/331) From e2a9a56de83ccdd5fec99508106b77aebe8f32f5 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 3 Apr 2023 16:41:27 +0200 Subject: [PATCH 48/65] Properly split data_groups in from_arrays and from_sklearn methods of GroupedDataset --- src/pydvl/utils/dataset.py | 30 ++++++++++++++++++++++++------ 1 file changed, 24 insertions(+), 6 deletions(-) diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index 6125e6716..d3c6eadf7 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -479,10 +479,20 @@ def from_sklearn( raise ValueError( "data_groups must be provided when constructing a GroupedDataset" ) - dataset = Dataset.from_sklearn( - data, train_size, random_state, stratify_by_target, **kwargs + + x_train, x_test, y_train, y_test, data_groups_train, _ = train_test_split( + data.data, + data.target, + data_groups, + train_size=train_size, + random_state=random_state, + stratify=data.target if stratify_by_target else None, + ) + + dataset = Dataset( + x_train=x_train, y_train=y_train, x_test=x_test, y_test=y_test, **kwargs ) - return cls.from_dataset(dataset, data_groups) # type: ignore + return cls.from_dataset(dataset, data_groups_train) # type: ignore @classmethod def from_arrays( @@ -527,10 +537,18 @@ def from_arrays( raise ValueError( "data_groups must be provided when constructing a GroupedDataset" ) - dataset = Dataset.from_arrays( - X, y, train_size, random_state, stratify_by_target, **kwargs + x_train, x_test, y_train, y_test, data_groups_train, _ = train_test_split( + X, + y, + data_groups, + train_size=train_size, + random_state=random_state, + stratify=y if stratify_by_target else None, + ) + dataset = Dataset( + x_train=x_train, y_train=y_train, x_test=x_test, y_test=y_test, **kwargs ) - return cls.from_dataset(dataset, data_groups) + return cls.from_dataset(dataset, data_groups_train) @classmethod def from_dataset( From b9ecf3b933cc83c5587c41babc5c94df7595dba2 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 3 Apr 2023 16:41:40 +0200 Subject: [PATCH 49/65] Update tests --- tests/utils/test_dataset.py | 33 ++++++++++++++++++++++----------- 1 file changed, 22 insertions(+), 11 deletions(-) diff --git a/tests/utils/test_dataset.py b/tests/utils/test_dataset.py index 7f08ba534..e157a2a21 100644 --- a/tests/utils/test_dataset.py +++ b/tests/utils/test_dataset.py @@ -39,16 +39,23 @@ def test_creating_dataset_from_x_y_arrays(train_size, kwargs): def test_creating_grouped_dataset_from_sklearn(train_size): data = load_wine() - data_groups = np.random.randint( - low=0, high=3, size=int(train_size * len(data.data)) - ).flatten() + data_groups = np.random.randint(low=0, high=3, size=len(data.data)).flatten() n_groups = len(np.unique(data_groups)) dataset = GroupedDataset.from_sklearn( data, data_groups=data_groups, train_size=train_size ) assert len(dataset) == n_groups + + +def test_creating_grouped_dataset_from_sklearn_failure(train_size): with pytest.raises(ValueError): - GroupedDataset.from_sklearn(data, data_groups=data_groups[len(data) // 2 :]) + data = load_wine() + # The length of data groups should be equal to that of data + data_groups_length = np.random.randint(low=0, high=len(data.data) - 1) + data_groups = np.random.randint( + low=0, high=3, size=data_groups_length + ).flatten() + GroupedDataset.from_sklearn(data, data_groups=data_groups) def test_creating_grouped_dataset_subsclassfrom_sklearn(train_size): @@ -57,9 +64,7 @@ def test_creating_grouped_dataset_subsclassfrom_sklearn(train_size): class TestGroupedDataset(GroupedDataset): ... - data_groups = np.random.randint( - low=0, high=3, size=int(train_size * len(data.data)) - ).flatten() + data_groups = np.random.randint(low=0, high=3, size=len(data.data)).flatten() n_groups = len(np.unique(data_groups)) dataset = TestGroupedDataset.from_sklearn( data, data_groups=data_groups, train_size=train_size @@ -71,9 +76,7 @@ class TestGroupedDataset(GroupedDataset): @pytest.mark.parametrize("kwargs", ({}, {"description": "Test Dataset"})) def test_creating_grouped_dataset_from_x_y_arrays(train_size, kwargs): X, y = make_classification() - data_groups = np.random.randint( - low=0, high=3, size=int(train_size * len(X)) - ).flatten() + data_groups = np.random.randint(low=0, high=3, size=len(X)).flatten() n_groups = len(np.unique(data_groups)) dataset = GroupedDataset.from_arrays( X, y, data_groups=data_groups, train_size=train_size, **kwargs @@ -82,8 +85,16 @@ def test_creating_grouped_dataset_from_x_y_arrays(train_size, kwargs): for k, v in kwargs.items(): assert getattr(dataset, k) == v + +def test_creating_grouped_dataset_from_x_y_arrays_failure(train_size): with pytest.raises(ValueError): - GroupedDataset.from_arrays(X, y, data_groups=data_groups[len(X) // 2 :]) + X, y = make_classification() + # The length of data groups should be equal to that of X and y + data_groups_length = np.random.randint(low=0, high=len(X) - 1) + data_groups = np.random.randint( + low=0, high=3, size=data_groups_length + ).flatten() + GroupedDataset.from_arrays(X, y, data_groups=data_groups) def test_grouped_dataset_results(): From 0802d7542ff6639d31ca0fdaa9cd0c76d85aa86e Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 3 Apr 2023 16:44:42 +0200 Subject: [PATCH 50/65] Update changelog --- CHANGELOG.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index d3449f9d2..e3b16e5d2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,9 @@ ## Unreleased +- Fix creation of GroupedDataset objects using the `from_arrays` + and `from_sklearn` class methods + [PR #324](https://github.com/appliedAI-Initiative/pyDVL/pull/334) - Fix release job not triggering on CI when a new tag is pushed [PR #331](https://github.com/appliedAI-Initiative/pyDVL/pull/331) - Added alias `ApproShapley` from Castro et al. 2009 for permutation Shapley From 0575b7a9e5f793f745b7967313b2bb5deee8727e Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 3 Apr 2023 18:29:01 +0200 Subject: [PATCH 51/65] Fix test_grouped_dataset_results --- tests/utils/test_dataset.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/tests/utils/test_dataset.py b/tests/utils/test_dataset.py index e157a2a21..c522b587f 100644 --- a/tests/utils/test_dataset.py +++ b/tests/utils/test_dataset.py @@ -101,9 +101,7 @@ def test_grouped_dataset_results(): """Test that data names are preserved in valuation results""" X, y = make_classification() train_size = 0.5 - data_groups = np.random.randint( - low=0, high=3, size=int(train_size * len(X)), dtype=np.int_ - ).flatten() + data_groups = np.random.randint(low=0, high=3, size=len(X)).flatten() dataset = GroupedDataset.from_arrays( X, y, data_groups=data_groups, train_size=train_size ) From 63db9c2403d22c06b1768d45a6e0063460136243 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 5 Apr 2023 14:20:39 +0200 Subject: [PATCH 52/65] Update src/pydvl/utils/config.py Co-authored-by: Miguel de Benito Delgado --- src/pydvl/utils/config.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/pydvl/utils/config.py b/src/pydvl/utils/config.py index 614525b00..208a445a0 100644 --- a/src/pydvl/utils/config.py +++ b/src/pydvl/utils/config.py @@ -16,12 +16,9 @@ class ParallelConfig: :param backend: Type of backend to use. Defaults to 'ray' :param address: Address of existing remote or local cluster to use. - Defaults to None. :param n_workers: Number of workers (CPUs) to use. This has no effect when using an existing ray cluster. - Defaults to None. :param n_cpus_per_job: Number of CPUs to use per job. - Defaults to 1.0. :param logging_level: Logging level for the parallel backend's worker. """ From d713c74067fea2d81e851afd915ba057008b58f5 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 5 Apr 2023 14:31:27 +0200 Subject: [PATCH 53/65] Apply suggestions from code review Co-authored-by: Miguel de Benito Delgado --- src/pydvl/utils/parallel/futures/ray.py | 15 +++++++++------ src/pydvl/value/shapley/truncated.py | 2 +- 2 files changed, 10 insertions(+), 7 deletions(-) diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index fbc38ee5e..91ab66554 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -1,4 +1,5 @@ import logging +import math import queue import sys import threading @@ -26,12 +27,14 @@ class RayExecutor(Executor): It shouldn't be initialized directly. You should instead call :func:`~pydvl.utils.parallel.futures.init_executor`. - :param max_workers: Maximum number of concurrent tasks. + :param max_workers: Maximum number of concurrent tasks. Each task can + request itself any number of vCPUs. You must ensure that the product of + both does not exceed available cluster resources. :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. - :param cancel_futures_on_exit: If True, all futures will be cancelled - when exiting the context created by using this class instance - as a context manager. It will be ignored when calling `shutdown()` + :param cancel_futures_on_exit: If ``True``, all futures will be cancelled + when exiting the context created by using this class instance as a + context manager. It will be ignored when calling :meth:`shutdown` directly. """ @@ -88,8 +91,8 @@ def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": and returns a Future instance representing the execution of the callable. :param fn: Callable. - :param args: Positional arguments that will be passed to `fn`. - :param kwargs: Keyword arguments that will be passed to `fn`. + :param args: Positional arguments that will be passed to ``fn``. + :param kwargs: Keyword arguments that will be passed to ``fn``. :return: A Future representing the given call. :raises RuntimeError: If a task is submitted after the executor has been shut down. """ diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 44d0d52b9..7d8bba94a 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -272,7 +272,7 @@ def truncated_montecarlo_shapley( if done(accumulated_result): break # Submit more computations - # The goal is to always have `n_concurrent_computations` + # The goal is to always have `n_jobs` # computations running for _ in range(n_jobs - len(futures)): future = executor.submit( From 64dcde6902bb492384c65b7fc7ee019b40a1edf3 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 6 Apr 2023 12:09:35 +0200 Subject: [PATCH 54/65] Revert changes to wrap() Co-authored-by: Miguel de Benito Delgado --- src/pydvl/utils/parallel/backend.py | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index c2e6d6686..1ebeab9c6 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -171,13 +171,9 @@ def wrap(self, fun: Callable, **kwargs) -> Callable: :return: The `.remote` method of the ray `RemoteFunction`. """ - remote_fn = ray.remote(fun) - if len(kwargs) == 0: - kwargs["num_cpus"] = self.n_cpus_per_job - else: - if "num_cpus" not in kwargs: - kwargs["num_cpus"] = self.n_cpus_per_job - return remote_fn.remote # type: ignore + if len(kwargs) > 1: + return ray.remote(**kwargs)(fun).remote # type: ignore + return ray.remote(fun).remote # type: ignore def wait( self, From f3d40e769045b375e7af4028c8d8655a9a07d65d Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 6 Apr 2023 13:42:02 +0200 Subject: [PATCH 55/65] Remove n_cpus_per_job from ParallelConfig, rename n_workers to n_cpus_local --- src/pydvl/utils/config.py | 10 ++++------ src/pydvl/utils/parallel/backend.py | 5 ++--- src/pydvl/utils/parallel/futures/__init__.py | 2 +- src/pydvl/utils/parallel/futures/ray.py | 19 ++++++++++++------- 4 files changed, 19 insertions(+), 17 deletions(-) diff --git a/src/pydvl/utils/config.py b/src/pydvl/utils/config.py index 208a445a0..89ddd023f 100644 --- a/src/pydvl/utils/config.py +++ b/src/pydvl/utils/config.py @@ -16,21 +16,19 @@ class ParallelConfig: :param backend: Type of backend to use. Defaults to 'ray' :param address: Address of existing remote or local cluster to use. - :param n_workers: Number of workers (CPUs) to use. + :param n_cpus_local: Number of CPUs to use when creating a local ray cluster. This has no effect when using an existing ray cluster. - :param n_cpus_per_job: Number of CPUs to use per job. :param logging_level: Logging level for the parallel backend's worker. """ backend: Literal["sequential", "ray"] = "ray" address: Optional[Union[str, Tuple[str, int]]] = None - n_workers: Optional[int] = None - n_cpus_per_job: float = 1.0 + n_cpus_local: Optional[int] = None logging_level: int = logging.WARNING def __post_init__(self) -> None: - if self.address is not None and self.n_workers is not None: - raise ValueError("When `address` is set, `n_workers` should be None.") + if self.address is not None and self.n_cpus_local is not None: + raise ValueError("When `address` is set, `n_cpus_local` should be None.") @dataclass diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index 1ebeab9c6..d5683035e 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -135,10 +135,9 @@ class RayParallelBackend(BaseParallelBackend, backend_name="ray"): def __init__(self, config: ParallelConfig): config_dict = asdict(config) config_dict.pop("backend") - n_workers = config_dict.pop("n_workers") + n_cpus_local = config_dict.pop("n_cpus_local") if config_dict.get("address", None) is None: - config_dict["num_cpus"] = n_workers - self.n_cpus_per_job = config_dict.pop("n_cpus_per_job") + config_dict["num_cpus"] = n_cpus_local self.config = config_dict if not ray.is_initialized(): ray.init(**self.config) diff --git a/src/pydvl/utils/parallel/futures/__init__.py b/src/pydvl/utils/parallel/futures/__init__.py index 432f6112b..41f3be2f5 100644 --- a/src/pydvl/utils/parallel/futures/__init__.py +++ b/src/pydvl/utils/parallel/futures/__init__.py @@ -42,7 +42,7 @@ def init_executor( """ if config.backend == "ray": - max_workers = config.n_workers + max_workers = config.n_cpus_local with RayExecutor(max_workers, config=config) as executor: yield executor elif config.backend == "sequential": diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index 91ab66554..4029c41ae 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -28,8 +28,11 @@ class RayExecutor(Executor): :func:`~pydvl.utils.parallel.futures.init_executor`. :param max_workers: Maximum number of concurrent tasks. Each task can - request itself any number of vCPUs. You must ensure that the product of - both does not exceed available cluster resources. + request itself any number of vCPUs. You must ensure the product + of this value and the n_cpus_per_job parameter passed to submit() + does not exceed available cluster resources. + If set to None, it will default to the total number of vCPUs + in the ray cluster. :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. :param cancel_futures_on_exit: If ``True``, all futures will be cancelled @@ -58,10 +61,9 @@ def __init__( config_dict = asdict(config) config_dict.pop("backend") - config_dict.pop("n_workers") - self.n_cpus_per_job = config_dict.pop("n_cpus_per_job") + n_cpus_local = config_dict.pop("n_cpus_local") if config_dict.get("address", None) is None: - config_dict["num_cpus"] = max_workers + config_dict["num_cpus"] = n_cpus_local self.config = config_dict if not ray.is_initialized(): ray.init(**self.config) @@ -84,7 +86,9 @@ def __init__( # Work Item Manager Thread self._work_item_manager_thread: Optional[_WorkItemManagerThread] = None - def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": + def submit( + self, fn: Callable[..., T], *args, n_cpus_per_job: float = 1.0, **kwargs + ) -> "Future[T]": r"""Submits a callable to be executed with the given arguments. Schedules the callable to be executed as fn(\*args, \**kwargs) @@ -92,6 +96,7 @@ def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": :param fn: Callable. :param args: Positional arguments that will be passed to ``fn``. + :param n_cpus_per_job: Number or fraction of vCPUs to request for each task. :param kwargs: Keyword arguments that will be passed to ``fn``. :return: A Future representing the given call. :raises RuntimeError: If a task is submitted after the executor has been shut down. @@ -103,7 +108,7 @@ def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": logging.debug("Creating future and putting work item in work queue") future: "Future[T]" = Future() - w = _WorkItem(future, fn, args, kwargs, n_cpus_per_job=self.n_cpus_per_job) + w = _WorkItem(future, fn, args, kwargs, n_cpus_per_job=n_cpus_per_job) self._put_work_item_in_queue(w) # We delay starting the thread until the first call to submit self._start_work_item_manager_thread() From 2e229a59f96f0193afe1bb49b6545fdeb5b25497 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 6 Apr 2023 13:44:10 +0200 Subject: [PATCH 56/65] Change check for kwargs length inside parallel backend wrap method --- src/pydvl/utils/parallel/backend.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index d5683035e..f9840d77d 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -170,7 +170,7 @@ def wrap(self, fun: Callable, **kwargs) -> Callable: :return: The `.remote` method of the ray `RemoteFunction`. """ - if len(kwargs) > 1: + if len(kwargs) > 0: return ray.remote(**kwargs)(fun).remote # type: ignore return ray.remote(fun).remote # type: ignore From da3b111669ffd6ac75d471238261cfbf6812a1a2 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 6 Apr 2023 13:44:22 +0200 Subject: [PATCH 57/65] Update fixture --- tests/utils/conftest.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/utils/conftest.py b/tests/utils/conftest.py index 29968af6a..df56a9583 100644 --- a/tests/utils/conftest.py +++ b/tests/utils/conftest.py @@ -10,7 +10,7 @@ def parallel_config(request, num_workers): if request.param == "sequential": yield ParallelConfig(backend=request.param) elif request.param == "ray-local": - yield ParallelConfig(backend="ray", n_workers=num_workers) + yield ParallelConfig(backend="ray", n_cpus_local=num_workers) ray.shutdown() elif request.param == "ray-external": # Starts a head-node for the cluster. From 14bb2bfe86fe5e6e73906689d9b3a4ee6960102f Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 6 Apr 2023 13:48:59 +0200 Subject: [PATCH 58/65] Use n_jobs as max_workers in TMCS --- src/pydvl/utils/parallel/futures/__init__.py | 6 +++--- src/pydvl/value/shapley/truncated.py | 17 ++++++++++------- 2 files changed, 13 insertions(+), 10 deletions(-) diff --git a/src/pydvl/utils/parallel/futures/__init__.py b/src/pydvl/utils/parallel/futures/__init__.py index 41f3be2f5..aeb49470c 100644 --- a/src/pydvl/utils/parallel/futures/__init__.py +++ b/src/pydvl/utils/parallel/futures/__init__.py @@ -1,6 +1,6 @@ from concurrent.futures import Executor, ThreadPoolExecutor from contextlib import contextmanager -from typing import Generator +from typing import Generator, Optional from pydvl.utils.config import ParallelConfig from pydvl.utils.parallel.futures.ray import RayExecutor @@ -10,6 +10,7 @@ @contextmanager def init_executor( + max_workers: Optional[int] = None, config: ParallelConfig = ParallelConfig(), ) -> Generator[Executor, None, None]: """Initializes a futures executor based on the passed parallel configuration object. @@ -22,7 +23,7 @@ def init_executor( >>> from pydvl.utils.parallel.futures import init_executor >>> from pydvl.utils.config import ParallelConfig >>> config = ParallelConfig(backend="ray") - >>> with init_executor(config=config) as executor: + >>> with init_executor(max_workers=3, config=config) as executor: ... pass >>> from pydvl.utils.parallel.futures import init_executor @@ -42,7 +43,6 @@ def init_executor( """ if config.backend == "ray": - max_workers = config.n_cpus_local with RayExecutor(max_workers, config=config) as executor: yield executor elif config.backend == "sequential": diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 7d8bba94a..23b871699 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -186,8 +186,8 @@ def _permutation_montecarlo_one_step( @deprecated( target=True, - deprecated_in="0.7.0", - remove_in="0.8.0", + deprecated_in="0.6.1", + remove_in="0.7.0", args_mapping=dict(coordinator_update_period=None, worker_update_period=None), ) def truncated_montecarlo_shapley( @@ -240,19 +240,22 @@ def truncated_montecarlo_shapley( :return: Object with the data values. """ - n_jobs = effective_n_jobs(n_jobs, config) - algorithm = "truncated_montecarlo_shapley" parallel_backend = init_parallel_backend(config) u = parallel_backend.put(u) + # This represents the number of jobs that are running + n_jobs = effective_n_jobs(n_jobs, config) + # This determines the total number of submitted jobs + # including the ones that are running + n_submitted_jobs = 2 * n_jobs accumulated_result = ValuationResult.zeros(algorithm=algorithm) - with init_executor(config=config) as executor: + with init_executor(max_workers=n_jobs, config=config) as executor: futures = set() # Initial batch of computations - for _ in range(n_jobs): + for _ in range(n_submitted_jobs): future = executor.submit( _permutation_montecarlo_one_step, u, @@ -274,7 +277,7 @@ def truncated_montecarlo_shapley( # Submit more computations # The goal is to always have `n_jobs` # computations running - for _ in range(n_jobs - len(futures)): + for _ in range(n_submitted_jobs - len(futures)): future = executor.submit( _permutation_montecarlo_one_step, u, From fbbb0a35790c5ac775f7fdde9f93a233070d1bd2 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 6 Apr 2023 14:22:00 +0200 Subject: [PATCH 59/65] Pass options to the ray remote function as part of the submit method's kwargs This is done because mypy complains if we don't have the same signature as the base Executor class --- src/pydvl/utils/parallel/futures/__init__.py | 7 ++++--- src/pydvl/utils/parallel/futures/ray.py | 22 +++++++++++++------- 2 files changed, 18 insertions(+), 11 deletions(-) diff --git a/src/pydvl/utils/parallel/futures/__init__.py b/src/pydvl/utils/parallel/futures/__init__.py index aeb49470c..93b94fc27 100644 --- a/src/pydvl/utils/parallel/futures/__init__.py +++ b/src/pydvl/utils/parallel/futures/__init__.py @@ -12,11 +12,13 @@ def init_executor( max_workers: Optional[int] = None, config: ParallelConfig = ParallelConfig(), + **kwargs, ) -> Generator[Executor, None, None]: """Initializes a futures executor based on the passed parallel configuration object. :param max_workers: Maximum number of concurrent tasks. :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. + :param kwargs: Other optional parameter that will be passed to the executor. :Example: @@ -43,11 +45,10 @@ def init_executor( """ if config.backend == "ray": - with RayExecutor(max_workers, config=config) as executor: + with RayExecutor(max_workers, config=config, **kwargs) as executor: yield executor elif config.backend == "sequential": - max_workers = 1 - with ThreadPoolExecutor(max_workers) as executor: + with ThreadPoolExecutor(1) as executor: yield executor else: raise NotImplementedError(f"Unexpected parallel type {config.backend}") diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index 4029c41ae..62ad8d26b 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -86,9 +86,7 @@ def __init__( # Work Item Manager Thread self._work_item_manager_thread: Optional[_WorkItemManagerThread] = None - def submit( - self, fn: Callable[..., T], *args, n_cpus_per_job: float = 1.0, **kwargs - ) -> "Future[T]": + def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": r"""Submits a callable to be executed with the given arguments. Schedules the callable to be executed as fn(\*args, \**kwargs) @@ -96,8 +94,9 @@ def submit( :param fn: Callable. :param args: Positional arguments that will be passed to ``fn``. - :param n_cpus_per_job: Number or fraction of vCPUs to request for each task. :param kwargs: Keyword arguments that will be passed to ``fn``. + It can also optionally contain options for the ray remote function + as a dictionary as the keyword argument `remote_function_options`. :return: A Future representing the given call. :raises RuntimeError: If a task is submitted after the executor has been shut down. """ @@ -108,7 +107,14 @@ def submit( logging.debug("Creating future and putting work item in work queue") future: "Future[T]" = Future() - w = _WorkItem(future, fn, args, kwargs, n_cpus_per_job=n_cpus_per_job) + remote_function_options = kwargs.pop("remote_function_options", None) + w = _WorkItem( + future, + fn, + args, + kwargs, + remote_function_options=remote_function_options, + ) self._put_work_item_in_queue(w) # We delay starting the thread until the first call to submit self._start_work_item_manager_thread() @@ -171,13 +177,13 @@ def __init__( args: Any, kwargs: Any, *, - n_cpus_per_job: float, + remote_function_options: Optional[dict] = None, ): self.future = future self.fn = fn self.args = args self.kwargs = kwargs - self.n_cpus_per_job = n_cpus_per_job + self.remote_function_options = remote_function_options or {"num_cpus": 1.0} def run(self) -> None: if not self.future.set_running_or_notify_cancel(): @@ -185,7 +191,7 @@ def run(self) -> None: remote_fn = ray.remote(self.fn) ref = remote_fn.options( - name=self.fn.__name__, num_cpus=self.n_cpus_per_job + name=self.fn.__name__, **self.remote_function_options ).remote(*self.args, **self.kwargs) # Almost verbatim copy of `future()` method of ClientObjectRef From 3d2b38608cf9121ae46268c3477d68499f721886 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Tue, 11 Apr 2023 11:22:47 +0200 Subject: [PATCH 60/65] Add test case for dispatch function compute_semivalues. --- tests/value/test_semivalues.py | 29 ++++++++++++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index 42f7c71b4..082659999 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -1,9 +1,10 @@ import math -from typing import Type +from typing import Dict, Type import numpy as np import pytest +from pydvl.utils import Utility from pydvl.value.sampler import ( AntitheticSampler, DeterministicCombinatorialSampler, @@ -13,10 +14,12 @@ UniformSampler, ) from pydvl.value.semivalues import ( + SemiValueMode, SVCoefficient, _semivalues, banzhaf_coefficient, beta_coefficient, + compute_semivalues, semivalues, shapley_coefficient, ) @@ -113,3 +116,27 @@ def test_coefficients(n: int, coefficient: SVCoefficient): """ s = [math.comb(n - 1, j - 1) * coefficient(n, j - 1) for j in range(1, n + 1)] assert np.isclose(1, np.sum(s)) + + +@pytest.mark.parametrize("num_samples", [5]) +@pytest.mark.parametrize( + "semi_value_mode,semi_value_mode_kwargs", + [ + (SemiValueMode.Shapley, dict()), + (SemiValueMode.BetaShapley, {"alpha": 1, "beta": 16}), + (SemiValueMode.Banzhaf, dict()), + ], + ids=["shapley", "beta-shapley", "banzhaf"], +) +def test_dispatch_compute_semi_values( + dummy_utility: Utility, + semi_value_mode: SemiValueMode, + semi_value_mode_kwargs: Dict[str, int], +): + values = compute_semivalues( + u=dummy_utility, + mode=semi_value_mode, + done=MaxUpdates(10), + **semi_value_mode_kwargs, + progress=True, + ) From 157eb87efc6ad7226799c003234300782d99080f Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Tue, 11 Apr 2023 11:40:42 +0200 Subject: [PATCH 61/65] Update change log. --- CHANGELOG.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 812b3335b..38b3b9f7a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,7 +13,9 @@ [PR #331](https://github.com/appliedAI-Initiative/pyDVL/pull/331) - Added alias `ApproShapley` from Castro et al. 2009 for permutation Shapley [PR #332](https://github.com/appliedAI-Initiative/pyDVL/pull/332) - +- Change get to pop i pydvl.value.semivalues.compute_semivalues method. Added + test case to test the dispatch method with the possible inputs. + [PR #333](https://github.com/appliedAI-Initiative/pyDVL/pull/333) ## 0.6.0 - 🆕 New algorithms, cleanup and bug fixes 🏗 From 85cdad40a9ad35467c0082d3569b0e2ec45de5e9 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Tue, 11 Apr 2023 19:30:58 +0200 Subject: [PATCH 62/65] Update CHANGELOG.md Co-authored-by: Anes Benmerzoug --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 38b3b9f7a..67afb8305 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,7 +13,7 @@ [PR #331](https://github.com/appliedAI-Initiative/pyDVL/pull/331) - Added alias `ApproShapley` from Castro et al. 2009 for permutation Shapley [PR #332](https://github.com/appliedAI-Initiative/pyDVL/pull/332) -- Change get to pop i pydvl.value.semivalues.compute_semivalues method. Added +- Change `get` to `pop` in pydvl.value.semivalues.compute_semivalues method. Added test case to test the dispatch method with the possible inputs. [PR #333](https://github.com/appliedAI-Initiative/pyDVL/pull/333) From 7281cf3bcbd1177d58170222114aeba5898fe8be Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Tue, 11 Apr 2023 19:31:10 +0200 Subject: [PATCH 63/65] Update tests/value/test_semivalues.py Co-authored-by: Anes Benmerzoug --- tests/value/test_semivalues.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index 082659999..17063c6c7 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -136,7 +136,7 @@ def test_dispatch_compute_semi_values( values = compute_semivalues( u=dummy_utility, mode=semi_value_mode, - done=MaxUpdates(10), + done=MaxUpdates(1), **semi_value_mode_kwargs, progress=True, ) From 19a6287fcfa354e8a9849bd7738301c0af5cecbe Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 13 Apr 2023 14:12:34 +0200 Subject: [PATCH 64/65] Update Changelog for release --- CHANGELOG.md | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 67afb8305..a6bf217e1 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,7 +1,9 @@ # Changelog -## Unreleased +## 0.6.1 - 🏗 Bug fixes and small improvement +- Fix parsing keyword arguments of `compute_semivalues` dispatch function + [PR #333](https://github.com/appliedAI-Initiative/pyDVL/pull/333) - Create new `RayExecutor` class based on the concurrent.futures API, use the new class to fix an issue with Truncated Monte Carlo Shapley (TMCS) starting too many processes and dying, plus other small changes @@ -13,9 +15,6 @@ [PR #331](https://github.com/appliedAI-Initiative/pyDVL/pull/331) - Added alias `ApproShapley` from Castro et al. 2009 for permutation Shapley [PR #332](https://github.com/appliedAI-Initiative/pyDVL/pull/332) -- Change `get` to `pop` in pydvl.value.semivalues.compute_semivalues method. Added - test case to test the dispatch method with the possible inputs. - [PR #333](https://github.com/appliedAI-Initiative/pyDVL/pull/333) ## 0.6.0 - 🆕 New algorithms, cleanup and bug fixes 🏗 From ce29e0c4eba4dee536a77cadbcc69178f65480d2 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 13 Apr 2023 14:12:34 +0200 Subject: [PATCH 65/65] =?UTF-8?q?Bump=20version:=200.6.1.dev0=20=E2=86=92?= =?UTF-8?q?=200.6.1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .bumpversion.cfg | 2 +- setup.py | 2 +- src/pydvl/__init__.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.bumpversion.cfg b/.bumpversion.cfg index 50e75f70a..4a9b23366 100644 --- a/.bumpversion.cfg +++ b/.bumpversion.cfg @@ -1,5 +1,5 @@ [bumpversion] -current_version = 0.6.1.dev0 +current_version = 0.6.1 commit = False tag = False allow_dirty = False diff --git a/setup.py b/setup.py index 4a3cc8522..002249cea 100644 --- a/setup.py +++ b/setup.py @@ -12,7 +12,7 @@ package_data={"pydvl": ["py.typed"]}, packages=find_packages(where="src"), include_package_data=True, - version="0.6.1.dev0", + version="0.6.1", description="The Python Data Valuation Library", install_requires=[ line diff --git a/src/pydvl/__init__.py b/src/pydvl/__init__.py index c13c0c481..43c4ab005 100644 --- a/src/pydvl/__init__.py +++ b/src/pydvl/__init__.py @@ -1 +1 @@ -__version__ = "0.6.1.dev0" +__version__ = "0.6.1"