diff --git a/sbi/inference/posteriors/base_posterior.py b/sbi/inference/posteriors/base_posterior.py index 302764a51..f45f67115 100644 --- a/sbi/inference/posteriors/base_posterior.py +++ b/sbi/inference/posteriors/base_posterior.py @@ -37,6 +37,7 @@ def __init__( Allows to perform, e.g. MCMC in unconstrained space. device: Training device, e.g., "cpu", "cuda" or "cuda:0". If None, `potential_fn.device` is used. + x_shape: Shape of the observed data. """ # Ensure device string. @@ -132,6 +133,8 @@ def set_default_x(self, x: Tensor) -> "NeuralPosterior": def _x_else_default_x(self, x: Optional[Array]) -> Tensor: if x is not None: + # New x, reset posterior sampler. + self._posterior_sampler = None return process_x( x, x_shape=self._x_shape, allow_iid_x=self.potential_fn.allow_iid_x ) diff --git a/sbi/inference/posteriors/mcmc_posterior.py b/sbi/inference/posteriors/mcmc_posterior.py index 1c9dd5889..7b2dbb531 100644 --- a/sbi/inference/posteriors/mcmc_posterior.py +++ b/sbi/inference/posteriors/mcmc_posterior.py @@ -1,12 +1,16 @@ # This file is part of sbi, a toolkit for simulation-based inference. sbi is licensed # under the Affero General Public License v3, see . from functools import partial -from typing import Any, Callable, Dict, Optional, Union +from math import ceil +from typing import Any, Callable, Dict, Optional, Tuple, Union from warnings import warn +import arviz as az import torch import torch.distributions.transforms as torch_tf +from arviz.data import InferenceData from joblib import Parallel, delayed +from numpy import ndarray from pyro.infer.mcmc import HMC, NUTS from pyro.infer.mcmc.api import MCMC from torch import Tensor @@ -17,14 +21,15 @@ from sbi.samplers.mcmc import ( IterateParameters, Slice, + SliceSamplerSerial, + SliceSamplerVectorized, proposal_init, resample_given_potential_fn, sir_init, - slice_np_parallized, ) from sbi.simulators.simutils import tqdm_joblib from sbi.types import Shape, TorchTransform -from sbi.utils import pyro_potential_wrapper, transformed_potential +from sbi.utils import pyro_potential_wrapper, tensor2numpy, transformed_potential from sbi.utils.torchutils import ensure_theta_batched @@ -102,6 +107,9 @@ def __init__( self.init_strategy = init_strategy self.init_strategy_parameters = init_strategy_parameters self.num_workers = num_workers + self._posterior_sampler = None + # Hardcode parameter name to reduce clutter kwargs. + self.param_name = "theta" if init_strategy_num_candidates is not None: warn( @@ -130,6 +138,11 @@ def mcmc_method(self, method: str) -> None: """See `set_mcmc_method`.""" self.set_mcmc_method(method) + @property + def posterior_sampler(self): + """Returns sampler created by `sample`.""" + return self._posterior_sampler + def set_mcmc_method(self, method: str) -> "NeuralPosterior": """Sets sampling method to for MCMC and returns `NeuralPosterior`. @@ -185,7 +198,7 @@ def sample( sample_with: Optional[str] = None, num_workers: Optional[int] = None, show_progress_bars: bool = True, - ) -> Tensor: + ) -> Union[Tensor, Tuple[Tensor, InferenceData]]: r"""Return samples from posterior distribution $p(\theta|x)$ with MCMC. Check the `__init__()` method for a description of all arguments as well as @@ -291,11 +304,12 @@ def sample( warmup_steps=warmup_steps, # type: ignore num_chains=num_chains, show_progress_bars=show_progress_bars, - ).detach() + ) else: raise NameError samples = self.theta_transform.inv(transformed_samples) + return samples.reshape((*sample_shape, -1)) # type: ignore def _build_mcmc_init_fn( @@ -419,6 +433,7 @@ def _slice_np_mcmc( warmup_steps: int, vectorized: bool = False, num_workers: int = 1, + init_width: Union[float, ndarray] = 0.01, show_progress_bars: bool = True, ) -> Tensor: """Custom implementation of slice sampling using Numpy. @@ -429,32 +444,47 @@ def _slice_np_mcmc( initial_params: Initial parameters for MCMC chain. thin: Thinning (subsampling) factor. warmup_steps: Initial number of samples to discard. - vectorized: Whether to use a vectorized implementation of - the Slice sampler (still experimental). - num_workers: number of CPU cores to use - seed: seed that will be used to generate sub-seeds for each worker + vectorized: Whether to use a vectorized implementation of the Slice sampler. + num_workers: Number of CPU cores to use. + init_width: Inital width of brackets. show_progress_bars: Whether to show a progressbar during sampling; can only be turned off for vectorized sampler. - Returns: Tensor of shape (num_samples, shape_of_single_theta). + Returns: + Tensor of shape (num_samples, shape_of_single_theta). + Arviz InferenceData object. """ num_chains, dim_samples = initial_params.shape - samples = slice_np_parallized( - potential_function, - initial_params, - num_samples, + if not vectorized: + SliceSamplerMultiChain = SliceSamplerSerial + else: + SliceSamplerMultiChain = SliceSamplerVectorized + + posterior_sampler = SliceSamplerMultiChain( + init_params=tensor2numpy(initial_params), + log_prob_fn=potential_function, + num_chains=num_chains, thin=thin, - warmup_steps=warmup_steps, - vectorized=vectorized, + verbose=show_progress_bars, num_workers=num_workers, - show_progress_bars=show_progress_bars, + init_width=init_width, ) + warmup_ = warmup_steps * thin + num_samples_ = ceil((num_samples * thin) / num_chains) + # Run mcmc including warmup + samples = posterior_sampler.run(warmup_ + num_samples_) + samples = samples[:, warmup_steps:, :] # discard warmup steps + samples = torch.from_numpy(samples) # chains x samples x dim + + # Save posterior sampler. + self._posterior_sampler = posterior_sampler # Save sample as potential next init (if init_strategy == 'latest_sample'). self._mcmc_init_params = samples[:, -1, :].reshape(num_chains, dim_samples) + # Collect samples from all chains. samples = samples.reshape(-1, dim_samples)[:num_samples, :] assert samples.shape[0] == num_samples @@ -470,7 +500,7 @@ def _pyro_mcmc( warmup_steps: int = 200, num_chains: Optional[int] = 1, show_progress_bars: bool = True, - ): + ) -> Tensor: r"""Return samples obtained using Pyro HMC, NUTS for slice kernels. Args: @@ -484,7 +514,9 @@ def _pyro_mcmc( num_chains: Whether to sample in parallel. If None, use all but one CPU. show_progress_bars: Whether to show a progressbar during sampling. - Returns: Tensor of shape (num_samples, shape_of_single_theta). + Returns: + Tensor of shape (num_samples, shape_of_single_theta). + Arviz InferenceData object. """ num_chains = mp.cpu_count() - 1 if num_chains is None else num_chains @@ -494,7 +526,7 @@ def _pyro_mcmc( kernel=kernels[mcmc_method](potential_fn=potential_function), num_samples=(thin * num_samples) // num_chains + num_chains, warmup_steps=warmup_steps, - initial_params={"": initial_params}, + initial_params={self.param_name: initial_params}, num_chains=num_chains, mp_context="spawn", disable_progbar=not show_progress_bars, @@ -505,10 +537,13 @@ def _pyro_mcmc( -1, initial_params.shape[1] # .shape[1] = dim of theta ) + # Save posterior sampler. + self._posterior_sampler = sampler + samples = samples[::thin][:num_samples] assert samples.shape[0] == num_samples - return samples + return samples.detach() def _prepare_potential(self, method: str) -> Callable: """Combines potential and transform and takes care of gradients and pyro. @@ -612,6 +647,60 @@ def map( force_update=force_update, ) + def get_arviz_inference_data(self) -> InferenceData: + """Returns arviz InferenceData object constructed most recent samples. + + Note: the InferenceData is constructed using the posterior samples generated in + most recent call to `.sample(...)`. + + For Pyro HMC and NUTS kernels InferenceData will contain diagnostics, for Pyro + Slice or sbi slice sampling samples, only the samples are added. + + Returns: + inference_data: Arviz InferenceData object. + """ + assert ( + self._posterior_sampler is not None + ), """No samples have been generated, call .sample() first.""" + + sampler: Union[ + MCMC, SliceSamplerSerial, SliceSamplerVectorized + ] = self._posterior_sampler + + # If Pyro sampler and samples not transformed, use arviz' from_pyro. + # Exclude 'slice' kernel as it lacks the 'divergence' diagnostics key. + if isinstance(self._posterior_sampler, (HMC, NUTS)) and isinstance( + self.theta_transform, torch_tf.IndependentTransform + ): + inference_data = az.from_pyro(sampler) + + # otherwise get samples from sampler and transform to original space. + else: + transformed_samples = sampler.get_samples(group_by_chain=True) + # Pyro samplers returns dicts, get values. + if isinstance(transformed_samples, Dict): + # popitem gets last items, [1] get the values as tensor. + transformed_samples = transformed_samples.popitem()[1] + # Our slice samplers return numpy arrays. + elif isinstance(transformed_samples, ndarray): + transformed_samples = torch.from_numpy(transformed_samples).type( + torch.float32 + ) + # For MultipleIndependent priors transforms first dim must be batch dim. + # thus, reshape back and forth to have batch dim in front. + num_chains, samples_per_chain, dim_params = transformed_samples.shape + samples = self.theta_transform.inv( # type: ignore + transformed_samples.reshape(-1, dim_params) + ).reshape( # type: ignore + num_chains, samples_per_chain, dim_params + ) + + inference_data = az.convert_to_inference_data( + {f"{self.param_name}": samples} + ) + + return inference_data + def _maybe_use_dict_entry(default: Any, key: str, dict_to_check: Dict) -> Any: """Returns `default` if `key` is not in the dict and otherwise the dict entry. diff --git a/sbi/samplers/mcmc/__init__.py b/sbi/samplers/mcmc/__init__.py index 125cc5f86..7d3abe146 100644 --- a/sbi/samplers/mcmc/__init__.py +++ b/sbi/samplers/mcmc/__init__.py @@ -7,6 +7,6 @@ from sbi.samplers.mcmc.slice import Slice from sbi.samplers.mcmc.slice_numpy import ( SliceSampler, + SliceSamplerSerial, SliceSamplerVectorized, - slice_np_parallized, ) diff --git a/sbi/samplers/mcmc/slice_numpy.py b/sbi/samplers/mcmc/slice_numpy.py index a0e90cf94..7924fa671 100644 --- a/sbi/samplers/mcmc/slice_numpy.py +++ b/sbi/samplers/mcmc/slice_numpy.py @@ -5,6 +5,7 @@ import sys from math import ceil from typing import Callable, Optional, Union +from warnings import warn import numpy as np import torch @@ -55,23 +56,34 @@ def gen(self, n_samples): class SliceSampler(MCMCSampler): def __init__( - self, x, lp_f, max_width=float("inf"), thin=None, verbose: bool = False + self, + x, + lp_f, + max_width=float("inf"), + init_width: Union[float, np.ndarray] = 0.01, + thin=None, + tuning: int = 50, + verbose: bool = False, ): """Slice sampling for multivariate continuous probability distributions. It cycles sampling from each conditional using univariate slice sampling. Args: - x: initial state + x: Initial state. lp_f: Function that returns the log prob. - max_width: maximum bracket width - thin: amount of thinning; if None, no thinning. + max_width: maximum bracket width. + init_width: Inital width of brackets. + thin: Amount of thinning; if None, no thinning. + tuning: Number of tuning steps for brackets. verbose: Whether to show progress bars (False). """ MCMCSampler.__init__(self, x, lp_f, thin, verbose=verbose) self.max_width = max_width + self.init_width = init_width self.width = None + self.tuning = tuning def gen( self, @@ -141,15 +153,14 @@ def _tune_bracket_width(self, rng): rng: Random number generator to use. """ - n_samples = 50 order = list(range(self.n_dims)) x = self.x.copy() - self.width = np.full(self.n_dims, 0.01) + self.width = np.full(self.n_dims, self.init_width) - tbar = trange(n_samples, miniters=10, disable=not self.verbose) + tbar = trange(self.tuning, miniters=10, disable=not self.verbose) tbar.set_description("Tuning bracket width...") for n in tbar: - # for n in range(int(n_samples)): + # for n in range(int(self.tuning)): rng.shuffle(order) for i in range(self.n_dims): @@ -203,31 +214,171 @@ def _sample_from_conditional(self, i: int, cxi, rng): return xi, ux - lx +class SliceSamplerSerial: + def __init__( + self, + log_prob_fn: Callable, + init_params: np.ndarray, + num_chains: int = 1, + thin: Optional[int] = None, + tuning: int = 50, + verbose: bool = True, + init_width: Union[float, np.ndarray] = 0.01, + max_width: float = float("inf"), + num_workers: int = 1, + ): + """Slice sampler in pure Numpy, running for each chain in serial. + + Parallelization across CPUs is possible by setting num_workers > 1. + + Args: + log_prob_fn: Log prob function. + init_params: Initial parameters. + num_chains: Number of MCMC chains to run in parallel + thin: amount of thinning; if None, no thinning. + tuning: Number of tuning steps for brackets. + verbose: Show/hide additional info such as progress bars. + init_width: Inital width of brackets. + max_width: Maximum width of brackets. + num_workers: Number of parallel workers to use. + """ + self._log_prob_fn = log_prob_fn + + self.x = init_params + self.num_chains = num_chains + self.thin = thin + self.tuning = tuning + self.verbose = verbose + + self.init_width = init_width + self.max_width = max_width + + self.n_dims = self.x.size + self.num_workers = num_workers + self._samples = None + + def run(self, num_samples: int) -> np.ndarray: + """Runs MCMC and returns thinned samples. + + Sampling is performed parallelized across CPUs if self.num_workers > 1. + Parallelization is seeded across workers. + + Note: Thinning is performed internally. + + Args: + num_samples: Number of samples to generate + Returns: + MCMC samples in shape (num_chains, num_samples_per_chain, num_dim) + """ + + num_chains, dim_samples = self.x.shape + + # Generate seeds for workers from current random state. + seeds = torch.randint(high=2**31, size=(num_chains,)) + + with tqdm_joblib( + tqdm( + range(num_chains), # type: ignore + disable=not self.verbose or self.num_workers == 1, + desc=f"""Running {self.num_chains} MCMC chains with + {self.num_workers} worker{"s" if self.num_workers>1 else ""}.""", + total=self.num_chains, + ) + ): + all_samples = Parallel(n_jobs=self.num_workers)( + delayed(self.run_fun)(num_samples, initial_params_batch, seed) + for initial_params_batch, seed in zip(self.x, seeds) + ) + + samples = np.stack(all_samples).astype(np.float32) + samples = samples.reshape(num_chains, -1, dim_samples) # chains, samples, dim + samples = samples[:, :: self.thin, :] # thin chains + + # save samples + self._samples = samples + + return samples + + def run_fun(self, num_samples, inits, seed) -> np.ndarray: + """Runs MCMC for a given number of samples starting at inits.""" + np.random.seed(seed) + posterior_sampler = SliceSampler( + inits, + lp_f=self._log_prob_fn, + max_width=self.max_width, + init_width=self.init_width, + thin=self.thin, + tuning=self.tuning, + # turn off pbars in parallel mode. + verbose=self.num_workers == 1 and self.verbose, + ) + return posterior_sampler.gen(num_samples) + + def get_samples( + self, num_samples: Optional[int] = None, group_by_chain: bool = True + ) -> np.ndarray: + """Returns samples from last call to self.run. + + Raises ValueError if no samples have been generated yet. + + Args: + num_samples: Number of samples to return (for each chain if grouped by + chain), if too large, all samples are returned (no error). + group_by_chain: Whether to return samples grouped by chain (chain x samples + x dim_params) or flattened (all_samples, dim_params). + + Returns: + samples + """ + if self._samples is None: + raise ValueError("No samples found from MCMC run.") + # if not grouped by chain, flatten samples into (all_samples, dim_params) + if not group_by_chain: + samples = self._samples.reshape(-1, self._samples.shape[2]) + else: + samples = self._samples + + # if not specified return all samples + if num_samples is None: + return samples + # otherwise return last num_samples (for each chain when grouped). + elif group_by_chain: + return samples[:, -num_samples:, :] + else: + return samples[-num_samples:, :] + + class SliceSamplerVectorized: def __init__( self, log_prob_fn: Callable, init_params: np.ndarray, num_chains: int = 1, + thin: Optional[int] = None, tuning: int = 50, verbose: bool = True, init_width: Union[float, np.ndarray] = 0.01, max_width: float = float("inf"), + num_workers: int = 1, ): """Slice sampler in pure Numpy, vectorized evaluations across chains. Args: log_prob_fn: Log prob function. init_params: Initial parameters. - verbose: Show/hide additional info such as progress bars. + num_chains: Number of MCMC chains to run in parallel + thin: amount of thinning; if None, no thinning. tuning: Number of tuning steps for brackets. + verbose: Show/hide additional info such as progress bars. init_width: Inital width of brackets. max_width: Maximum width of brackets. + num_workers: Number of parallel workers to use (not implemented.) """ self._log_prob_fn = log_prob_fn self.x = init_params self.num_chains = num_chains + self.thin = 1 if thin is None else thin self.tuning = tuning self.verbose = verbose @@ -236,6 +387,14 @@ def __init__( self.n_dims = self.x.size + self._samples = None + + # TODO: implement parallelization across batches of chains. + if num_workers > 1: + warn( + """Parallelization of vectorized slice sampling not implement, running + serially.""" + ) self._reset() def _reset(self): @@ -425,109 +584,41 @@ def run(self, num_samples: int) -> np.ndarray: samples = np.stack([self.state[c]["samples"] for c in range(self.num_chains)]) + samples = samples[:, :: self.thin, :] # thin chains + + self._samples = samples + return samples + def get_samples( + self, num_samples: Optional[int] = None, group_by_chain: bool = True + ) -> np.ndarray: + """Returns samples from last call to self.run. -def slice_np_parallized( - potential_function: Callable, - initial_params: torch.Tensor, - num_samples: int, - thin: int, - warmup_steps: int, - vectorized: bool, - num_workers: int = 1, - show_progress_bars: bool = False, -): - """Run slice np (vectorized) parallized over CPU cores. - - In case of the vectorized version of slice np parallization happens over batches of - chains to still exploit vectorization. - - MCMC progress bars are omitted if num_workers > 1 to reduce clutter. Instead the - progress over chains is shown. - - Args: - potential_function: potential function - initial_params: initital parameters, one for each chain - num_samples: number of MCMC samples to produce - thin: thinning factor - warmup_steps: number of warmup / burnin steps - vectorized: whether to use the vectorized version - num_workers: number of CPU cores to use - show_progress_bars: whether to show progress bars - - Returns: - Tensor: final MCMC samples of each chain (num_chains, num_samples, dim_samples) - """ - num_chains, dim_samples = initial_params.shape - - # Generate seeds for workers from current random state. - seeds = torch.randint(high=2**31, size=(num_chains,)) - - if not vectorized: - # Define run function for given input. - def run_slice_np(inits, seed): - # Seed current job. - np.random.seed(seed) - posterior_sampler = SliceSampler( - tensor2numpy(inits).reshape(-1), - lp_f=potential_function, - thin=thin, - # Show pbars of workers only for single worker - verbose=show_progress_bars and num_workers == 1, - ) - if warmup_steps > 0: - posterior_sampler.gen(int(warmup_steps)) - return posterior_sampler.gen(ceil(num_samples / num_chains)) - - # For sequential chains each batch has only a single chain. - batch_size = 1 - run_fun = run_slice_np - - else: # Sample all chains at the same time - - # Define local function to run a batch of chains vectorized. - def run_slice_np_vectorized(inits, seed): - # Seed current job. - np.random.seed(seed) - posterior_sampler = SliceSamplerVectorized( - init_params=tensor2numpy(inits), - log_prob_fn=potential_function, - num_chains=inits.shape[0], - # Show pbars of workers only for single worker - verbose=show_progress_bars and num_workers == 1, - ) - warmup_ = warmup_steps * thin - num_samples_ = ceil((num_samples * thin) / num_chains) - samples = posterior_sampler.run(warmup_ + num_samples_) - samples = samples[:, warmup_:, :] # discard warmup steps - samples = samples[:, ::thin, :] # thin chains - samples = torch.from_numpy(samples) # chains x samples x dim - return samples + Raises ValueError if no samples have been generated yet. - # For vectorized case a batch contains multiple chains to exploit vectorization. - batch_size = ceil(num_chains / num_workers) - run_fun = run_slice_np_vectorized - - # Parallize over batch of chains. - initial_params_in_batches = torch.split(initial_params, batch_size, dim=0) - num_batches = len(initial_params_in_batches) - - # Show progress bars over batches. - with tqdm_joblib( - tqdm( - range(num_batches), # type: ignore - disable=not show_progress_bars or num_workers == 1, - desc=f"""Running {num_chains} MCMC chains with {num_workers} worker{"s" if - num_workers>1 else ""} (batch_size={batch_size}).""", - total=num_chains, - ) - ): - all_samples = Parallel(n_jobs=num_workers)( - delayed(run_fun)(initial_params_batch, seed) - for initial_params_batch, seed in zip(initial_params_in_batches, seeds) - ) - all_samples = np.stack(all_samples).astype(np.float32) - samples = torch.from_numpy(all_samples) + Args: + num_samples: Number of samples to return (for each chain if grouped by + chain), if too large, all samples are returned (no error). + group_by_chain: Whether to return samples grouped by chain (chain x samples + x dim_params) or flattened (all_samples, dim_params). - return samples.reshape(num_chains, -1, dim_samples) # chains x samples x dim + Returns: + samples + """ + if self._samples is None: + raise ValueError("No samples found from MCMC run.") + # if not grouped by chain, flatten samples into (all_samples, dim_params) + if not group_by_chain: + samples = self._samples.reshape(-1, self._samples.shape[2]) + else: + samples = self._samples + + # if not specified return all samples + if num_samples is None: + return samples + # otherwise return last num_samples (for each chain when grouped). + elif group_by_chain: + return samples[:, -num_samples:, :] + else: + return samples[-num_samples:, :] diff --git a/sbi/utils/sbiutils.py b/sbi/utils/sbiutils.py index bde9d7375..0dc2dd811 100644 --- a/sbi/utils/sbiutils.py +++ b/sbi/utils/sbiutils.py @@ -6,9 +6,12 @@ from math import pi from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Type, Union +import arviz as az import pyknos.nflows.transforms as transforms import torch import torch.distributions.transforms as torch_tf +from arviz.data import InferenceData +from numpy import ndarray from pyro.distributions import Empirical from torch import Tensor from torch import nn as nn diff --git a/setup.py b/setup.py index f997f840e..6064d0cba 100644 --- a/setup.py +++ b/setup.py @@ -24,6 +24,7 @@ REQUIRES_PYTHON = ">=3.6.0" REQUIRED = [ + "arviz", "joblib>=1.0.0", "matplotlib", "numpy", diff --git a/tests/mcmc_test.py b/tests/mcmc_test.py index c9035f2d4..f68717b13 100644 --- a/tests/mcmc_test.py +++ b/tests/mcmc_test.py @@ -3,19 +3,32 @@ from __future__ import annotations -from typing import Union +from math import ceil +import arviz as az import numpy as np import pytest import torch from torch import eye, ones, zeros - +from torch.distributions import Uniform + +from sbi.inference import ( + SNLE, + MCMCPosterior, + likelihood_estimator_based_potential, + prepare_for_sbi, + simulate_for_sbi, +) from sbi.samplers.mcmc.slice_numpy import ( SliceSampler, + SliceSamplerSerial, SliceSamplerVectorized, - slice_np_parallized, ) -from sbi.simulators.linear_gaussian import true_posterior_linear_gaussian_mvn_prior +from sbi.simulators.linear_gaussian import ( + diagonal_linear_gaussian, + true_posterior_linear_gaussian_mvn_prior, +) +from sbi.utils import likelihood_nn, tensor2numpy from tests.test_utils import check_c2st @@ -43,17 +56,25 @@ def test_c2st_slice_np_on_Gaussian(num_dim: int): def lp_f(x): return target_distribution.log_prob(torch.as_tensor(x, dtype=torch.float32)) - sampler = SliceSampler(lp_f=lp_f, x=np.zeros((num_dim,)).astype(np.float32)) - _ = sampler.gen(warmup) + sampler = SliceSampler( + lp_f=lp_f, + x=np.zeros((num_dim,)).astype(np.float32), + tuning=warmup, + ) + warmup_samples = sampler.gen(warmup) + assert warmup_samples.shape == (warmup, num_dim) + samples = sampler.gen(num_samples) + assert samples.shape == (num_samples, num_dim) samples = torch.as_tensor(samples, dtype=torch.float32) - check_c2st(samples, target_samples, alg=f"slice_np") + check_c2st(samples, target_samples, alg="slice_np") @pytest.mark.parametrize("num_dim", (1, 2)) -def test_c2st_slice_np_vectorized_on_Gaussian(num_dim: int): +@pytest.mark.parametrize("slice_sampler", (SliceSamplerVectorized, SliceSamplerSerial)) +def test_c2st_slice_np_vectorized_on_Gaussian(num_dim: int, slice_sampler): """Test MCMC on Gaussian, comparing to ground truth target via c2st. Args: @@ -63,6 +84,7 @@ def test_c2st_slice_np_vectorized_on_Gaussian(num_dim: int): num_samples = 500 warmup = 500 num_chains = 5 + thin = 2 likelihood_shift = -1.0 * ones(num_dim) likelihood_cov = 0.3 * eye(num_dim) @@ -77,7 +99,7 @@ def test_c2st_slice_np_vectorized_on_Gaussian(num_dim: int): def lp_f(x): return target_distribution.log_prob(torch.as_tensor(x, dtype=torch.float32)) - sampler = SliceSamplerVectorized( + sampler = slice_sampler( log_prob_fn=lp_f, init_params=np.zeros( ( @@ -85,23 +107,32 @@ def lp_f(x): num_dim, ) ).astype(np.float32), + tuning=warmup, + thin=thin, num_chains=num_chains, ) - samples = sampler.run(warmup + int(num_samples / num_chains)) + samples = sampler.run(thin * (warmup + int(num_samples / num_chains))) + assert samples.shape == ( + num_chains, + warmup + int(num_samples / num_chains), + num_dim, + ) samples = samples[:, warmup:, :] samples = samples.reshape(-1, num_dim) samples = torch.as_tensor(samples, dtype=torch.float32) - check_c2st(samples, target_samples, alg="slice_np_vectorized") + alg = { + SliceSamplerVectorized: "slice_np_vectorized", + SliceSamplerSerial: "slice_np", + }[slice_sampler] + + check_c2st(samples, target_samples, alg=alg) @pytest.mark.parametrize("vectorized", (False, True)) @pytest.mark.parametrize("num_workers", (1, 10)) -@pytest.mark.parametrize("seed", (None, 42)) -def test_c2st_slice_np_parallelized( - vectorized: bool, num_workers: int, seed: Union[None, int] -): +def test_c2st_slice_np_parallelized(vectorized: bool, num_workers: int): """Test MCMC on Gaussian, comparing to ground truth target via c2st. Args: @@ -110,8 +141,9 @@ def test_c2st_slice_np_parallelized( """ num_dim = 2 num_samples = 500 - warmup = 500 - num_chains = 5 + warmup = 100 + num_chains = 10 + thin = 2 likelihood_shift = -1.0 * ones(num_dim) likelihood_cov = 0.3 * eye(num_dim) @@ -128,37 +160,73 @@ def lp_f(x): initial_params = torch.zeros((num_chains, num_dim)) - # Maybe test seeding. - if seed is not None: - torch.manual_seed(seed) - - samples = slice_np_parallized( - lp_f, - initial_params, - num_samples, - thin=1, - warmup_steps=warmup, - vectorized=vectorized, + if not vectorized: + SliceSamplerMultiChain = SliceSamplerSerial + else: + SliceSamplerMultiChain = SliceSamplerVectorized + + posterior_sampler = SliceSamplerMultiChain( + init_params=tensor2numpy(initial_params), + log_prob_fn=lp_f, + num_chains=num_chains, + thin=thin, + verbose=False, num_workers=num_workers, - show_progress_bars=False, ) - # Repeat to test seeding. - if seed is not None: - torch.manual_seed(seed) - samples_2 = slice_np_parallized( - lp_f, - initial_params, - num_samples, - thin=1, - warmup_steps=warmup, - vectorized=vectorized, - num_workers=num_workers, - ) - # Test seeding. - assert torch.allclose(samples, samples_2) - + warmup_ = warmup * thin + num_samples_ = ceil((num_samples * thin) / num_chains) + samples = posterior_sampler.run(warmup_ + num_samples_) # chains x samples x dim + samples = samples[:, warmup:, :] # discard warmup steps samples = torch.as_tensor(samples, dtype=torch.float32).reshape(-1, num_dim) check_c2st( samples, target_samples, alg=f"slice_np {'vectorized' if vectorized else ''}" ) + + +@pytest.mark.parametrize( + "method", + ( + "nuts", + "hmc", + "slice", + "slice_np", + "slice_np_vectorized", + ), +) +def test_getting_inference_diagnostics(method): + + num_samples = 100 + num_dim = 2 + num_chains = 2 + + # Use composed prior to test MultipleIndependent case. + prior = [ + Uniform(low=-ones(1), high=ones(1)), + Uniform(low=-ones(1), high=ones(1)), + ] + + simulator, prior = prepare_for_sbi(diagonal_linear_gaussian, prior) + density_estimator = likelihood_nn("maf", num_transforms=3) + inference = SNLE(density_estimator=density_estimator, show_progress_bars=False) + + theta, x = simulate_for_sbi(simulator, prior, 1000, simulation_batch_size=50) + likelihood_estimator = inference.append_simulations(theta, x).train( + training_batch_size=100 + ) + + x_o = zeros((1, num_dim)) + potential_fn, theta_transform = likelihood_estimator_based_potential( + prior=prior, likelihood_estimator=likelihood_estimator, x_o=x_o + ) + posterior = MCMCPosterior( + proposal=prior, + potential_fn=potential_fn, + theta_transform=theta_transform, + thin=3, + num_chains=num_chains, + ) + posterior.sample(sample_shape=(num_samples,), method=method) + idata = posterior.get_arviz_inference_data() + + az.plot_trace(idata) diff --git a/tests/posterior_sampler_test.py b/tests/posterior_sampler_test.py new file mode 100644 index 000000000..b397ee23f --- /dev/null +++ b/tests/posterior_sampler_test.py @@ -0,0 +1,80 @@ +# This file is part of sbi, a toolkit for simulation-based inference. sbi is licensed +# under the Affero General Public License v3, see . + +from __future__ import annotations + +import pytest +from pyro.infer.mcmc import MCMC +from torch import eye, zeros +from torch.distributions import MultivariateNormal + +from sbi import utils as utils +from sbi.inference import ( + SNL, + MCMCPosterior, + likelihood_estimator_based_potential, + prepare_for_sbi, + simulate_for_sbi, +) +from sbi.samplers.mcmc import SliceSamplerSerial, SliceSamplerVectorized +from sbi.simulators.linear_gaussian import diagonal_linear_gaussian + + +@pytest.mark.parametrize( + "sampling_method", + ( + "slice_np", + "slice_np_vectorized", + "slice", + "nuts", + "hmc", + ), +) +def test_api_posterior_sampler_set(sampling_method: str, set_seed): + """Runs SNL and checks that posterior_sampler is correctly set. + + Args: + mcmc_method: which mcmc method to use for sampling + set_seed: fixture for manual seeding + """ + + num_dim = 2 + num_samples = 10 + num_trials = 2 + num_simulations = 10 + x_o = zeros((num_trials, num_dim)) + # Test for multiple chains is cheap when vectorized. + num_chains = 3 if sampling_method in "slice_np_vectorized" else 1 + + prior = MultivariateNormal(loc=zeros(num_dim), covariance_matrix=eye(num_dim)) + simulator, prior = prepare_for_sbi(diagonal_linear_gaussian, prior) + inference = SNL(prior, show_progress_bars=False) + + theta, x = simulate_for_sbi( + simulator, prior, num_simulations, simulation_batch_size=10 + ) + estimator = inference.append_simulations(theta, x).train(max_num_epochs=5) + potential_fn, transform = likelihood_estimator_based_potential( + estimator, prior, x_o + ) + posterior = MCMCPosterior( + potential_fn, theta_transform=transform, method=sampling_method, proposal=prior + ) + + assert posterior.posterior_sampler is None + posterior.sample( + sample_shape=(num_samples, num_chains), + x=x_o, + mcmc_parameters={ + "thin": 3, + "num_chains": num_chains, + "init_strategy": "prior", + }, + ) + + if sampling_method in ["slice", "hmc", "nuts"]: + assert type(posterior.posterior_sampler) is MCMC + elif sampling_method == "slice_np": + assert type(posterior.posterior_sampler) is SliceSamplerSerial + else: # sampling_method == "slice_np_vectorized" + assert type(posterior.posterior_sampler) is SliceSamplerVectorized diff --git a/tutorials/14_multi-trial-data-and-mixed-data-types.ipynb b/tutorials/14_multi-trial-data-and-mixed-data-types.ipynb index 2af57ffac..efba7bcc2 100644 --- a/tutorials/14_multi-trial-data-and-mixed-data-types.ipynb +++ b/tutorials/14_multi-trial-data-and-mixed-data-types.ipynb @@ -43,7 +43,6 @@ "outputs": [], "source": [ "import torch\n", - "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "from torch import zeros, ones, eye\n", @@ -793,7 +792,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3.8.13 ('sbi')", "language": "python", "name": "python3" }, @@ -807,7 +806,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.11" + "version": "3.8.13" + }, + "vscode": { + "interpreter": { + "hash": "9ef9b53a5ce850816b9705a866e49207a37a04a71269aa157d9f9ab944ea42bf" + } } }, "nbformat": 4, diff --git a/tutorials/15_mcmc_diagnostics_with_arviz.ipynb b/tutorials/15_mcmc_diagnostics_with_arviz.ipynb new file mode 100644 index 000000000..7d85c0b63 --- /dev/null +++ b/tutorials/15_mcmc_diagnostics_with_arviz.ipynb @@ -0,0 +1,1218 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# MCMC diagnostics with [Arviz](https://python.arviz.org/)\n", + "\n", + "This tutorial shows how to evaluate the quality of MCMC samples generated via `sbi` using the `arviz` package. \n", + "\n", + "We demonstrate this case using the trial-based simulator presented in Tutorial 14: A toy simulator mimicking the drift-diffusion model of decision-making. \n", + "\n", + "Outline:\n", + "\n", + "1) Train MNLE to approximate the likelihood underlying the simulator\n", + "2) Run MCMC using `pyro` MCMC samplers via `sbi` interface\n", + "3) Use `arviz` to visualize the posterior, predictive distributions and MCMC diagnostics. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import arviz as az\n", + "import torch\n", + "\n", + "from sbi.inference import MNLE, likelihood_estimator_based_potential\n", + "from pyro.distributions import InverseGamma\n", + "from torch.distributions import Beta, Binomial, Gamma\n", + "from sbi.utils import MultipleIndependent\n", + "\n", + "from sbi.inference import MCMCPosterior\n", + "\n", + "# Seeding\n", + "torch.manual_seed(1);" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Toy simulator for mixed data\n", + "def mixed_simulator(theta):\n", + " beta, ps = theta[:, :1], theta[:, 1:]\n", + "\n", + " choices = Binomial(probs=ps).sample()\n", + " rts = InverseGamma(concentration=2 * torch.ones_like(beta), rate=beta).sample()\n", + "\n", + " return torch.cat((rts, choices), dim=1)\n", + "\n", + "\n", + "# Define independent priors for each dimension.\n", + "prior = MultipleIndependent(\n", + " [\n", + " Gamma(torch.tensor([1.0]), torch.tensor([0.5])),\n", + " Beta(torch.tensor([2.0]), torch.tensor([2.0])),\n", + " ],\n", + " validate_args=False,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train MNLE to approximate the likelihood\n", + "\n", + "For details see [tutorial 14](https://www.mackelab.org/sbi/tutorial/14_multi-trial-data-and-mixed-data-types/). \n", + "\n", + "Here, we pass `mcmc_method=\"nuts\"` in order to use the underlying [`pyro` No-U-turn sampler](https://docs.pyro.ai/en/1.8.1/mcmc.html#nuts), but it would work as well with other samplers (e.g. \"slice_np_vectorized\", \"hmc\"). \n", + "\n", + "Additionally, when calling `posterior.sample(...)` we pass `return_arviz=True` so that the [`Arviz InferenceData`](https://arviz-devs.github.io/arviz/api/generated/arviz.InferenceData.html#arviz.InferenceData) object is returned. This object gives us access to the wealth of MCMC diagnostics tool provided by `arviz`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/janbolts/qode/sbi/sbi/neural_nets/mnle.py:60: UserWarning: The mixed neural likelihood estimator assumes that x contains\n", + " continuous data in the first n-1 columns (e.g., reaction times) and\n", + " categorical data in the last column (e.g., corresponding choices). If\n", + " this is not the case for the passed `x` do not use this function.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Neural network successfully converged after 65 epochs." + ] + } + ], + "source": [ + "# Generate training data and train MNLE.\n", + "num_simulations = 10000\n", + "theta = prior.sample((num_simulations,))\n", + "x = mixed_simulator(theta)\n", + "\n", + "trainer = MNLE(prior)\n", + "likelihood_estimator = trainer.append_simulations(theta, x).train()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run Pyro NUTS MCMC and obtain `arviz InferenceData` object" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/janbolts/qode/sbi/sbi/utils/sbiutils.py:280: UserWarning: An x with a batch size of 100 was passed. It will be interpreted as a batch of independent and identically\n", + " distributed data X={x_1, ..., x_n}, i.e., data generated based on the\n", + " same underlying (unknown) parameter. The resulting posterior will be with\n", + " respect to entire batch, i.e,. p(theta | X).\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "# Simulate \"observed\" data x_o\n", + "torch.manual_seed(42)\n", + "num_trials = 100\n", + "theta_o = prior.sample((1,))\n", + "x_o = mixed_simulator(theta_o.repeat(num_trials, 1))\n", + "\n", + "# Set MCMC parameters and run Pyro NUTS.\n", + "mcmc_parameters = dict(\n", + " num_chains=4,\n", + " thin=5,\n", + " warmup_steps=50,\n", + " init_strategy=\"proposal\",\n", + " method=\"nuts\",\n", + ")\n", + "num_samples = 1000\n", + "\n", + "# get the potential function and parameter transform for constructing the posterior\n", + "potential_fn, parameter_transform = likelihood_estimator_based_potential(\n", + " likelihood_estimator, prior, x_o\n", + ")\n", + "mnle_posterior = MCMCPosterior(\n", + " potential_fn, proposal=prior, theta_transform=parameter_transform, **mcmc_parameters\n", + ")\n", + "\n", + "mnle_samples = mnle_posterior.sample(\n", + " (num_samples,), x=x_o, show_progress_bars=False\n", + ")\n", + "# get arviz InferenceData object from posterior\n", + "inference_data = mnle_posterior.get_arviz_inference_data()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generate `arviz` plots\n", + "\n", + "The resulting `InferenceData` object can be passed to most `arviz` plotting functions, and there are plenty see [here](https://arviz-devs.github.io/arviz/examples/index.html#) for an overview.\n", + "\n", + "To get a better understanding of the `InferenceData` object see [here](https://arviz-devs.github.io/arviz/schema/schema.html). \n", + "\n", + "Below and overview of common MCMC diagnostics plot, see the corresponding `arviz` documentation for interpretation of the plots. \n", + "\n", + "We will a full use-case using the SBI-MCMC-arviz workflow soon." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + "
arviz.InferenceData
\n", + "
\n", + "
    \n", + " \n", + "
  • \n", + " \n", + " \n", + "
    \n", + "
    \n", + "
      \n", + "
      \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
      <xarray.Dataset>\n",
+       "Dimensions:      (chain: 4, draw: 1254, theta_dim_0: 2)\n",
+       "Coordinates:\n",
+       "  * chain        (chain) int64 0 1 2 3\n",
+       "  * draw         (draw) int64 0 1 2 3 4 5 6 ... 1248 1249 1250 1251 1252 1253\n",
+       "  * theta_dim_0  (theta_dim_0) int64 0 1\n",
+       "Data variables:\n",
+       "    theta        (chain, draw, theta_dim_0) float32 2.125 0.8092 ... 0.8088\n",
+       "Attributes:\n",
+       "    created_at:     2022-08-10T14:02:41.300799\n",
+       "    arviz_version:  0.11.2

      \n", + "
    \n", + "
    \n", + "
    • \n", + " \n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + "Inference data with groups:\n", + "\t> posterior" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "inference_data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Diagnostic plots" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([,\n", + " ],\n", + " dtype=object)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "az.style.use(\"arviz-darkgrid\")\n", + "az.plot_rank(inference_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAADPsAAARYCAYAAADNrzcyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAADPN0lEQVR4nOzdf5xVdb0v/teMAyQN4GjqUSLGK/64ZmieGKTwhKVliiZGZqZQ5kVDOeKPTnWuHc3rozrd8piQ/biea9dSM0pvHX8UdU5ZqIBKyE3zFwUC/kwQGB35IfP9wy+DcxhghplZs/bM8/nXzFprr89n7f1en70+e89rVlVzc3NzAAAAAAAAAAAAAAAAgB5X3dMdAAAAAAAAAAAAAAAAAF4n7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsA0CvNm/evBx00EE588wze7orAAAA22TuAgAAVArzFwAAoBKYuwBQ6Wp6ugMA0Fnf//73s3bt2kyePDmDBw/u0b7Mmzcv8+fPT0NDQ0aPHt2jfQEAAMrF3AUAAKgU5i8AAEAlMHcBoDdzZx8AKt4NN9yQmTNnZs2aNT3dlcyfPz8zZ87M/Pnze7orAABAyZi7AAAAlcL8BQAAqATmLgD0ZsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASVc3Nzc093QkA2Bm33nprvvCFL2xz/Q033JAkmTRpUhoaGvJ//s//yQ9+8IPMmjUrS5cuzaBBgzJu3Lhccskl2X333dvcx0svvZTrr78+//7v/57ly5enqqoqBxxwQCZOnJiJEyemunpLbvaggw7aZl8mTJiQr371q0mSZcuW5a677srvf//7PPXUU3nxxRdTW1ubt7/97TnzzDMzbty4nXg2AACAsjJ3AQAAKoX5CwAAUAnMXQDoC2p6ugMAsLP22GOPHHHEEfnjH/+Y9evX59BDD03//v1b1g8aNChr165t+f2zn/1sbr/99tTX12f48OH5y1/+kp/+9KdZtGhRbr311laPTZInnngin/70p/Pcc8+lX79+GT58eNavX59FixbloYceypw5c/LNb34zVVVVSZIjjjgizzzzTJ555pnss88+2WeffVr2VV9f3/Lzd77znfzkJz/JwIEDs9dee+Wggw7Kc889lzlz5mTOnDm5+OKLM2XKlG561gAAgKKZuwAAAJXC/AUAAKgE5i4A9AXu7ANAxXvf+96XFStW5N///d/z1re+tdW6efPmZdKkSenXr1/q6uryrW99KyNHjkyS/OUvf8knP/nJPPvss7n88svz8Y9/vOVxr7zySj784Q/nqaeeyplnnpnp06entrY2SfLkk09m+vTpeeKJJ/JP//RP+cQnPtHyuBkzZmTmzJk5//zzM23atDb7e/fdd2e33XbLyJEjWyZ8SfLAAw9k+vTpWblyZX7xi1/kbW97W5c9RwAAQM8zdwEAACqF+QsAAFAJzF0A6M2qd7wJAFS+DRs25Itf/GLLhC1J9ttvv5x99tlJkt/97nettv/pT3+ap556Kscee2wuvfTSlglbkowYMSJf//rXU1VVleuvv77DfXnve9+bww47rNWELUne9a535YILLshrr72WO++8s8P7BQAAKp+5CwAAUCnMXwAAgEpg7gJAparp6Q4AQBGGDBmSD3zgA1stf8c73pEkWb58eavls2fPTpJ89KMfbXN/Bx98cIYOHZply5bl2Wefzd/8zd90qD8rV67Mv/3bv2XRokV58cUXs27duiRJY2NjkuTRRx/t0P4AAIDewdwFAACoFOYvAABAJTB3AaBSCfsA0CcMGzaszeV77LFHkuTll19utfzxxx9Pknzzm9/Md77znTYfu2rVqiTJc88916FJ25w5czJ9+vSsXbt2m9usXr263fsDAAB6D3MXAACgUpi/AAAAlcDcBYBKJewDQJ8wcODANpf/51uibrb5PyU8/PDDO9z3q6++2u5+rFmzJhdddFHWrl2bk08+Oaeffnr222+/1NbWprq6Ovfee28+9alPZePGje3eJwAA0HuYuwAAAJXC/AUAAKgE5i4AVCphHwBow8CBA7NmzZrMnj07w4cP77L9/u53v8vq1avzzne+M1/96le3mjQ+88wzXdYWAADQ+5m7AAAAlcL8BQAAqATmLgCURXVPdwAAymj//fdPkjzxxBMdety2/uPDZitWrEiSHH744W1u++ijj3aoPQAAoG8zdwEAACqF+QsAAFAJzF0AKAthHwAq3pve9KYkybp167psnx/4wAeSJDfccEOam5vb/bgBAwYk2fYtWjev/+tf/7rVulWrVuUnP/lJR7sKAABUCHMXAACgUpi/AAAAlcDcBYDeTNgHgIo3bNiwJMn8+fO7bJ8f+9jHMmzYsMybNy+XXHJJnn/++VbrX3755dx55535yle+0mZf/vCHP2Tjxo1b7fdd73pXkuQXv/hF7r333pblzz//fP7+7/8+r732WpcdAwAAUC7mLgAAQKUwfwEAACqBuQsAvVlNT3cAADrrQx/6UH7729/m8ssvz0033ZTddtstSfKP//iPO73PN7/5zfnud7+bKVOm5Pbbb8+dd96Z/fbbL7W1tVm9enWWLVuW1157LYcddlirx40dOzZDhgzJgw8+mHHjxmXYsGGpqanJUUcdlSlTpuTQQw/NBz/4wfzyl7/Mpz71qQwfPjwDBw7ME088kQEDBuTiiy/Ol7/85c48HQAAQEmZuwAAAJXC/AUAAKgE5i4A9GbCPgBUvJNPPjlr1qzJT37ykyxdujSPP/54kmTNmjWd2u/++++fn/3sZ7npppvy61//OosXL86yZcuy5557ZtSoUXnve9/bctvWzWpra/Ov//qvueaaa7Jo0aIsXLgwmzZtytChQ1u2+frXv96y76effjq77bZbPvjBD+b888/PCy+80Kk+AwAA5WXuAgAAVArzFwAAoBKYuwDQm1U1Nzc393QnAAAAAAAAAAAAAAAAgKS6pzsAAAAAAAAAAAAAAAAAvE7YBwAAAAAAAAAAAAAAAEpC2AcAAAAAAAAAAAAAAABKQtgHAAAAAAAAAAAAAAAASkLYBwAAAAAAAAAAAAAAAEpC2AcAAAAAAAAAAAAAAABKQtgHAAAAAAAAAAAAAAAASkLYBwAAAAAAAAAAAAAAAEpC2AcAAAAAAAAAAAAAAABKoqanOwAARbj77rtz/fXX55FHHsn69euz33775ZRTTsknPvGJVFd3ffZ18eLFufbaazNv3rysXr06e++9d4499th85jOfyeDBg7u8PQAAoPcoav6yZs2azJkzJ4sWLcpDDz2URx55JK+++mrGjBmT73//+13WDgAA0LssW7Ys9913XxYtWpRFixblySefzGuvvZYLLrggU6dO7bZ2ffcCAAB0VNHzF9+9ANCVhH0A6PW+973v5Rvf+EaSZNiwYRk4cGAeffTRXHnllbn33nvzrW99q0v/YG7u3Lk555xz8uqrr2b33XfPAQcckD//+c/53//7f+dXv/pVfvSjH+Utb3lLl7UHAAD0HkXOX+bPn58LL7ywS/YFAAD0HTfccENuuOGGQtv03QsAALAzip6/+O4FgK7U9bcyAIAS+cMf/pCrrroq1dXV+cY3vpFf//rX+fnPf57bbrstb3nLW/If//Efuf7667usvcbGxlx44YV59dVXc+aZZ+Z3v/tdbr311vzmN7/JEUcckWXLluW///f/3mXtAQAAvUfR85cBAwZk1KhROeuss3L11Vfnoosu6rJ9AwAAvVddXV2OPvro/P3f/33+1//6X/ngBz/Yre357gUAANhZRc9ffPcCQFdyZx8AerVvf/vbaW5uzqmnnprx48e3LD/44IPz+c9/Ppdcckm+973vZdKkSenXr1+n2/vRj36UlStXZv/9988XvvCF7LLLLklenzh+4xvfyLHHHpvf/va3efjhh/P2t7+90+0BAAC9R9Hzl6OOOipHHXVUy++33nprp/cJAAD0flOnTm31+5133tmt7fnuBQAA2FlFz1989wJAV3JnHwB6rcbGxtx7771JkokTJ261/rjjjkttbW1eeumlzJs3r0va/NWvfpUkmTBhQsuXTZvtu+++GTNmTJLkl7/8ZZe0BwAA9A49MX8BAACoBL57AQAAAKAvEvYBoNd65JFHsmHDhgwYMCCHHHLIVuv79euXd7zjHUmShx56qNPtbdy4MQ8//HCS5Igjjmhzm83Lu6I9AACg9yh6/gIAAFAJfPcCAAAAQF8l7ANAr7V06dIkyT777JOampo2txk2bFirbTtjxYoV2bBhQ6v9dmd7AABA71H0/AUAAKAS+O4FAAAAgL5K2AeAXmv16tVJkiFDhmxzm8GDBydJ1qxZ02Xtba/Nze29cVsAAICi5y8AAACVwHcvAAAAAPRVwj4A9Frr1q1LkvTr12+b2/Tv3z9J8uqrr3a6vfXr17f8vK02N7e3uW8AAABJ8fMXAACASuC7FwAAAAD6KmEfAHqtAQMGJEk2bNiwzW02f0n0pje9qdPtbf4yaXttbm5vc98AAACS4ucvAAAAlcB3LwAAAAD0VcI+APRaQ4YMSZKsXr16m9usWbMmSTJ48OAua297bW5u743bAgAAFD1/AQAAqAS+ewEAAACgrxL2AaDXGj58eJLkmWeeycaNG9vcZtmyZa227YyhQ4emX79+rfbbne0BAAC9R9HzFwAAgErguxcAAAAA+iphHwB6rUMOOST9+vXLunXr8sgjj2y1fsOGDfl//+//JUkOO+ywTrdXU1OTQw45JEmyYMGCNrfZvLwr2gMAAHqPoucvAAAAlcB3LwAAAAD0VcI+APRatbW1GTNmTJLkJz/5yVbrf/GLX6SxsTG77bZbGhoauqTNY489Nkly22235bXXXmu17umnn859992XJPnABz7QJe0BAAC9Q0/MXwAAACqB714AAAAA6IuEfQDo1c4999xUVVVl1qxZuf3221uWP/roo/nqV7+aJDn77LPTv3//Vo+bN29eDjrooBx00EEdau/jH/946urqsnjx4nzlK1/Jhg0bkiSrVq3KxRdfnI0bN+bv/u7vcuihh3byyAAAgN6m6PkLAABAkXz3AgAAVArfvQBQBlXNzc3NRTb4s5/9LA8++GD++Mc/5vHHH8+GDRvyla98JaecckqH9rNp06bcdNNNueWWW7J06dIMHDgwo0ePzoUXXpj6+vo2H7No0aLMmDEjCxcuzIYNGzJixIhMnjw5J554YhccGQBl9e1vfztXX311kmTYsGEZOHBgnnjiiWzatCnjxo3Ltddem1122aXVY+bNm5dJkyYlSR577LEOtXffffflnHPOybp167L77rtnn332yZ///Oc0NTVl6NChueWWW7Lnnnt2ybEBAAC9S9Hzl9GjR7f8vH79+rzyyivp169f3vzmN7cs/6d/+qeccMIJO3lEAABAb/Pggw9m6tSpLb+/8sorWb9+fXbdddcMGDCgZfn//b//N/vss0/L7757AQAAitYT8xffvQDQVWqKbvCb3/xmVqxYkbq6uuy1115ZsWLFTu3nsssuy49//OOMGDEiZ5xxRl588cXceeedueeee/KjH/0oI0aMaLX9vHnz8ulPfzr9+vXLCSeckEGDBmX27Nm55JJLsmLFipx77rldcXgAlNBnPvOZHHzwwfn+97+fhx9+OH/9619z4IEH5pRTTskZZ5yx1R/KJclf//rXJNmp/84wZsyY/PSnP823v/3tzJ07N48//nj23nvvHHvssfnMZz6TIUOGdPqYAACA3qno+ctLL7201bINGza0Wr5u3boO7xcAAOi9Nm7c2OZcoqmpKU1NTS2/v/baa63W++4FAAAoWk/MX3z3AkBXKTzsc+WVV2b48OEZOnRovve97+Ub3/hGh/cxd+7c/PjHP8673vWuXH/99enfv3+S5OSTT86nPvWpXH755fnhD3/Ysv3GjRtz6aWXpqqqKjfeeGMOOeSQJMl5552X0047LTNmzMhxxx23zTsCAVD5jj766Bx99NHt3v4Pf/hDkuSss87aqfYOOOCAXHXVVTv1WAAAoG8rcv7S0f9GBwAAMHr06J2aS/juBQAAKFpPzF989wJAV6kuusF3v/vdGTp0aKf2MWvWrCTJ9OnTW4I+yev/zWfs2LG5//7785e//KVl+dy5c/PUU09l/PjxLUGfJKmtrc3UqVOzcePG3HrrrZ3qEwC9y4IFC7LXXnvl+OOP7+muAAAAbJf5CwAAUAnMXQAAgEph/gJAGRQe9ukK8+bNy8CBA3PEEUdstW7s2LFJkvvvv79l2fz581ute6P3vOc9rbYBgFdeeSWPPfZYzjjjjFahUgAAgLIxfwEAACqBuQsAAFApzF8AKIuanu5AR73yyit54YUXcuCBB2aXXXbZan19fX2SZMmSJS3LNv88fPjwrbYfMmRI6urqsnTp0u7oLgAVaODAgXn44Yd7uhsAAAA7ZP4CAABUAnMXAACgUpi/AFAWFXdnn7Vr1yZJamtr21y/eXljY2PLss0/Dxo0aJuP2bzfbXn7YS/mlVeaO9xfAACAopm/AAAAlcDcBQAAqBTmLwAAQNEq7s4+Pemll1Zl3bqqnu4GvVxdXV1WrVrV092gD1BrFEWtURS1RlHq6up6ugvtYv5CEYy9FEWtUQR1RlHUGkUxd4EtjL0URa1RFLVGUdQaRTF/gS2MvRRFrVEEdUZR1BpFKXruUnF39tl8d5433rnnjTYvf+Odfzb/vK279zQ2Nm7zrj8AAAAAAAAAAAAAAABQlIoL+wwcODB77rlnli9fntdee22r9UuWLEmS1NfXtyzb/PPSpUu32n716tVZtWpVhg8f3h3dBQAAAAAAAAAAAAAAgHaruLBPkjQ0NOSVV17JggULtlo3Z86cJMmoUaNalm3+efO6N7rnnnta9gkAAAAAAAAAAAAAAAA9qdRhn5UrV2bx4sVZuXJlq+WnnnpqkuTqq6/O+vXrW5bfd999mTNnTkaNGpX99tuvZfmYMWMybNiw3H777fnTn/7UsryxsTHXXnttampqMmHChG4+GgAAAAAAAAAAAAAAANi+mqIbnDVrVh588MEkyeOPP96ybP78+UmSY445Jsccc0yS5MYbb8zMmTNz/vnnZ9q0aS37OPLII/PRj340s2bNyoQJE/Le9743L774Yu68887U1tbm8ssvb9VmTU1Nrrzyypx99tk5/fTTM378+NTW1mb27NlZvnx5pk+f3iocBAAAAAAAAAAAAAAAAD2h8LDPgw8+mNtuu63VsgULFmTBggVJkqFDh7aEfbbniiuuyEEHHZRbbrklP/jBDzJw4MAcffTRufDCC9sM7hx55JG56aabcs011+Suu+7Khg0bMmLEiFxwwQU56aSTuubgAAAAAAAAAAAAAAAAoBMKD/t89atfzVe/+tV2bTtt2rRWd/R5o+rq6px55pk588wz2932yJEjc91117V7ewAAAAAAAAAAAAAAAChSdU93AAAAAAAAAAAAAAAAAHidsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACURE1PNbxo0aLMmDEjCxcuzIYNGzJixIhMnjw5J554Yrsef+aZZ2b+/Pnb3eaf//mfc/LJJ7f8/r73vS8rVqxoc9uPfexjueKKK9rdfwAAAAAAAAAAAAAAAOhqPRL2mTdvXj796U+nX79+OeGEEzJo0KDMnj07l1xySVasWJFzzz13h/uYMGFCGhoatlq+cePGfPe73011dXXGjBmz1fpBgwZl8uTJWy0/9NBDd+5gAAAAAAAAAAAAAAAAoIsUHvbZuHFjLr300lRVVeXGG2/MIYcckiQ577zzctppp2XGjBk57rjjUl9fv939nHLKKW0u/+Uvf5nm5ub83d/9Xfbee++t1g8ePDjTpk3r9HEAAAAAAAAAAAAAAABAV6suusG5c+fmqaeeyvjx41uCPklSW1ubqVOnZuPGjbn11lt3ev+zZs1KkkycOLHTfQUAAAAAAAAAAAAAAIAiFX5nn/nz5ydJxo4du9W697znPa226ahnn30299xzT/bcc8+MGzeuzW3Wr1+f2267Lc8991wGDx6cI444IgcffPBOtQcAAAAAAAAAAAAAAABdqfCwz5IlS5Ikw4cP32rdkCFDUldXl6VLl+7Uvn/6059m06ZNmTBhQmpq2j60F154IZ///OdbLTvqqKPyta99LbvvvvtOtQsAAAAAAAAAAAAAAABdofCwT2NjY5Jk0KBBba6vra3Ns88+2+H9Njc359Zbb02STJw4sc1tTjnllDQ0NGTEiBHp379/Fi9enJkzZ+Z3v/tdpk6dmptvvjlVVVXbbGO33eoycOC210NXqaur6+ku0EeoNYqi1iiKWoMtzF8oirGXoqg1iqDOKIpagy3MXSiKsZeiqDWKotYoilqDLcxfKIqxl6KoNYqgziiKWqM3Kjzs013mzp2b5cuXp6Ghoc27BiXJ+eef3+r3ww47LN/97ndzxhln5MEHH8zdd9+dcePGbbONl15alXXrTNjoXnV1dVm1alVPd4M+QK1RFLVGUdQaRamUDwfMXyiCsZeiqDWKoM4oilqjKOYusIWxl6KoNYqi1iiKWqMo5i+whbGXoqg1iqDOKIpaoyhFz12qC20tr9+5J0nWrl3b5vrGxsZt3vVne2bNmpVk23f12Zbq6uqccsopSZIFCxZ0uF0AAAAAAAAAAAAAAADoKoWHferr65MkS5cu3Wrd6tWrs2rVqm3emWdbVq9enV/96lcZPHhwPvjBD3a4T5sTVk1NTR1+LAAAAAAAAAAAAAAAAHSVwsM+o0aNSpLMmTNnq3X33HNPkqShoaFD+/z5z3+e9evX58QTT8yb3vSmDvdp0aJFSZKhQ4d2+LEAAAAAAAAAAAAAAADQVQoP+4wZMybDhg3L7bffnj/96U8tyxsbG3PttdempqYmEyZMaFm+cuXKLF68OCtXrtzmPn/yk58kSSZOnLjNbZ588smsWbNmq+UPPPBArr/++vTv3z8f+MAHduaQAAAAAAAAAAAAAAAAoEvUFN5gTU2uvPLKnH322Tn99NMzfvz41NbWZvbs2Vm+fHmmT5+e/fbbr2X7G2+8MTNnzsz555+fadOmbbW/P/7xj3n00Ufz9re/PYcccsg2273rrrty3XXXZcyYMRk6dGj69++fxx9/PPfcc0+qq6vzpS99Kfvuu2+3HDMAAAAAAAAAAAAAAAC0R+FhnyQ58sgjc9NNN+Waa67JXXfdlQ0bNmTEiBG54IILctJJJ3VoX+25q0+SjB49OosXL84jjzyS+fPnZ/369dljjz1y/PHH55Of/GRGjhy508cDAAAAAAAAAAAAAAAAXaFHwj5JMnLkyFx33XU73G7atGlt3tFns8svvzyXX375DvfT0NCQhoaGjnQRAAAAAAAAAAAAAAAAClXd0x0AAAAAAAAAAAAAAAAAXifsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAA0Ec0NTVn7LhNGTtuU5qamnu6OwAAAAAAAAAAALRB2AcAAAAAAAAAAAAAAABKQtgHAAAAAAAAAAAAAAAASkLYBwAAAAAAAAAAAAAAAEpC2AcAAAAAAAAAAAAAAABKQtgHAAAAAAAAAAAAAAAASkLYBwAAAAAAAAAAAAAAAEpC2AcAAAAAAAAAAAAAAABKQtgHAAAAAAAAAAAAAAAASkLYBwAAAAAAAAAAAAAAAEpC2AcAAAAAAAAAAAAAAABKQtgHAAAAAAAAAAAAAAAASkLYBwAAAAAAAAAAAAAAAEpC2AcAAAAAAAAAAAAAAABKQtgHAAAAAAAAAAAAAAAASkLYBwAAAAAAAAAAAAAAAEpC2AcAAAAAAAAAAAAAAABKQtgHAAAAAAAAAAAAAAAASkLYBwAAAAAAAAAAAAAAAEpC2AcAAAAAAAAAAAAAAABKQtgHAAAAAAAAAAAAAAAASkLYBwAAAAAAAAAAAAAAAEpC2AcAAAAAAAAAAAAAAABKQtgHAAAAAAAAAAAAAAAASkLYBwAAAAAAAAAAAAAAAEqipqcaXrRoUWbMmJGFCxdmw4YNGTFiRCZPnpwTTzyxXY+fN29eJk2atM31t9xySw4//PAubxcAAAAAAAAAAAAAAAC6S4+EfebNm5dPf/rT6devX0444YQMGjQos2fPziWXXJIVK1bk3HPPbfe+Ghoa0tDQsNXyv/mbv+nWdgEAAAAAAAAAAAAAAKCrFR722bhxYy699NJUVVXlxhtvzCGHHJIkOe+883LaaadlxowZOe6441JfX9+u/TU0NGTatGmFtwsAAAAAAAAAAAAAAABdrbroBufOnZunnnoq48ePbwncJEltbW2mTp2ajRs35tZbb+017QIAAAAAAAAAAAAAAEB7FX5nn/nz5ydJxo4du9W697znPa22aY8lS5bkhhtuyKuvvpp999037373u7P77rt3e7sAAAAAAAAAAAAAAADQ1QoP+yxZsiRJMnz48K3WDRkyJHV1dVm6dGm793f77bfn9ttvb/n9TW96U6ZNm5azzz67W9sFAAAAAAAAAAAAAACArlZ42KexsTFJMmjQoDbX19bW5tlnn93hfnbffff8wz/8Q8aNG5d99903a9asybx58/L1r389//N//s/U1tbmtNNO69J2d9utLgMHVu2wb9BZdXV1Pd0F+gi1RlHUGkVRa7BFW/OXAQOak6zc5nrYGcZeiqLWKII6oyhqDbYwN6Eoxl6KotYoilqjKGoNtjB/oSjGXoqi1iiCOqMoao3eqPCwT1c54IADcsABB7T8vuuuu+akk07KwQcfnFNOOSUzZszIqaeemurq6i5r86WXVmXdOhM2ulddXV1WrVrV092gD1BrFEWtURS1RlEq5cOBtuYvTU3N210PHWXspShqjSKoM4qi1ihKJc9doKsZeymKWqMoao2iqDWKYv4CWxh7KYpaowjqjKKoNYpS9Nyl65Iw7VRbW5skWbt2bZvrGxsbt3n3nfY48MADc9hhh+Wvf/1rli5dWli7AAAAAAAAAAAAAAAA0FmFh33q6+uTpFUQZ7PVq1dn1apVGT58eKfa2JyYevXVVwttFwAAAAAAAAAAAAAAADqj8LDPqFGjkiRz5szZat0999yTJGloaNjp/W/cuDGPPPJIqqqqss8++xTWLgAAAAAAAAAAAAAAAHRW4WGfMWPGZNiwYbn99tvzpz/9qWV5Y2Njrr322tTU1GTChAkty1euXJnFixdn5cqVrfbzhz/8Ic3Nza2Wbdy4MV/72teyYsWKjB07NrvttttOtwsAAAAAAAAAAAAAAABFqym8wZqaXHnllTn77LNz+umnZ/z48amtrc3s2bOzfPnyTJ8+Pfvtt1/L9jfeeGNmzpyZ888/P9OmTWtZfvHFFydJ3vnOd2bvvffO2rVrc//99+cvf/lL9t1333zpS1/qVLsAAAAAAAAAAAAAAABQtMLDPkly5JFH5qabbso111yTu+66Kxs2bMiIESNywQUX5KSTTmrXPk477bT8/ve/z/z587Nq1arU1NTkbW97W84999ycddZZGTJkSLe0CwAAAAAAAAAAAAAAAN2lR8I+STJy5Mhcd911O9xu2rRpre7os9mUKVMyZcqUbmsXAAAAAAAAAAAAAAAAilbd0x0AAAAAAAAAAAAAAAAAXifsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAHdTU1Jyx4zZl7LhNaWpq7unuAAAAvYiwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAKXR1NScseM2Zey4TWlqau7p7gAAAAAAABRO2AcAAAAAAAAAAAAAAABKQtgHAAAAAAAAAAAAAAAASkLYBwAAAAAAAAAAAAAAAEpC2AcAAIA0NTVn7LhNGTtuU5qamnu6OwAAAAAAAAAAAH2WsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlERNTzW8aNGizJgxIwsXLsyGDRsyYsSITJ48OSeeeGK7Hv/AAw/k17/+debPn58VK1bklVdeydChQ/P+978/55xzTgYPHrzVY973vvdlxYoVbe7vYx/7WK644opOHRMAAAAAAAAAAAAAAAB0Ro+EfebNm5dPf/rT6devX0444YQMGjQos2fPziWXXJIVK1bk3HPP3eE+LrjggqxatSp/+7d/mw9/+MOpqqrK/Pnzc91112X27Nn50Y9+lD322GOrxw0aNCiTJ0/eavmhhx7aJccGAAAAAAAAAAAAAAAAO6vwsM/GjRtz6aWXpqqqKjfeeGMOOeSQJMl5552X0047LTNmzMhxxx2X+vr67e5n8uTJOfnkk7PXXnu1LGtubs6XvvSl3HzzzZk5c2Yuu+yyrR43ePDgTJs2rUuPCQAAAAAAAAAAAAAAALpCddENzp07N0899VTGjx/fEvRJktra2kydOjUbN27MrbfeusP9TJkypVXQJ0mqqqoyderUJMn999/ftR0HAAAAAAAAAAAAAACAblb4nX3mz5+fJBk7duxW697znve02mZn1NS8fki77LJLm+vXr1+f2267Lc8991wGDx6cI444IgcffPBOtwcAAAAAAAAAAAAAAABdpfCwz5IlS5Ikw4cP32rdkCFDUldXl6VLl+70/n/6058m2RIc+s9eeOGFfP7zn2+17KijjsrXvva17L777jvdLgAAAAAAAAAAAAAAAHRW4WGfxsbGJMmgQYPaXF9bW5tnn312p/b9pz/9Kd/61reyxx575Oyzz95q/SmnnJKGhoaMGDEi/fv3z+LFizNz5sz87ne/y9SpU3PzzTenqqpqm/vfbbe6DBy47fXQVerq6nq6C/QRao2iqDWKotZgi7bmLwMGNCdZ2eb67a2D7TH2UhS1RhHUGUVRa7BFR+cusLOMvRRFrVEUtUZR1BpsYf5CUYy9FEWtUQR1RlHUGr1R4WGf7rJs2bKcc845ee2113LVVVe1eZee888/v9Xvhx12WL773e/mjDPOyIMPPpi7774748aN22YbL720KuvWmZDRverq6rJq1aqe7gZ9gFqjKGqNoqg1ilIpHw60NX9pamre5vrtrYNtMfZSFLVGEdQZRVFrFKW3zl1gZxh7KYpaoyhqjaKoNYpi/gJbGHspilqjCOqMoqg1ilL03KW60Nby+p17kmTt2rVtrm9sbNzmXX+2ZcWKFZk8eXJWrlyZa665JkceeWS7H1tdXZ1TTjklSbJgwYIOtQsAAAAAAAAAAAAAAABdqfCwT319fZJk6dKlW61bvXp1Vq1aleHDh7d7f8uXL8+ZZ56Z559/PldffXWOPvroDvdpc8Kqqampw48FAADoC5qamjN23KaMHbep1X+pAwAAAAAAAAAAoGsVHvYZNWpUkmTOnDlbrbvnnnuSJA0NDe3a1/LlyzNp0qQ8//zz+Zd/+Zccc8wxO9WnRYsWJUmGDh26U48HAAAAAAAAAAAAAACArlB42GfMmDEZNmxYbr/99vzpT39qWd7Y2Jhrr702NTU1mTBhQsvylStXZvHixVm5cmWr/WwO+jz33HO56qqrcuyxx2633SeffDJr1qzZavkDDzyQ66+/Pv37988HPvCBTh4dAAAAAAAAAAAAAAAA7LyawhusqcmVV16Zs88+O6effnrGjx+f2trazJ49O8uXL8/06dOz3377tWx/4403ZubMmTn//PMzbdq0luWTJk3KihUrcvjhh+exxx7LY489tlVbb9z+rrvuynXXXZcxY8Zk6NCh6d+/fx5//PHcc889qa6uzpe+9KXsu+++3XvwAAAAAAAAAAAAAAAAsB2Fh32S5Mgjj8xNN92Ua665JnfddVc2bNiQESNG5IILLshJJ53Urn2sWLEiSbJw4cIsXLiwzW3eGPYZPXp0Fi9enEceeSTz58/P+vXrs8cee+T444/PJz/5yYwcObLTxwUAAAAAAAAAAAAAAACd0SNhnyQZOXJkrrvuuh1uN23atFahnc3aupPP9jQ0NKShoaFDjwEAAAAAAAAAAAAAAIAiVfd0BwAAAAAAAAAAAKA3aWpqzthxmzJ23KY0NTX3dHcAAIAKI+wDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAQKc1NTVn7LhNGTtuU5qamnu6OwAAAAAAAAAAABVL2AcAAAAAAAAAAAAAAABKQtgHAAAAAAAAAAAAAAAASkLYBwAAAAAAgIrR1NScseM2Zey4TWlqau7p7gAAAAAAAHQ5YR8AAAAAAAAAAAAAAAAoCWEfAAAAAAAAAAAAAAAAKAlhHwAAAAAAAAAAAAAAACgJYR8AAAAAAAAAAAAAAAAoCWEfAAAAAAAAAAAAAAAAKAlhHwAAAAAAAAAAAAAAACgJYR8AAAAAAAAAAAAAAAAoCWEfAAAAAAAAAAAAAAAAKAlhHwAAAAAAAAAAAAAAACgJYR8AAAC6XVNTc8aO25Sx4zalqam5p7sDAAAAAAAAAABQWsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AL1MU1Nzxo7blLHjNqWpqbmnuwMAAAAAAAAAAAAAQAcI+wAAAAAAAAAAQB/hH0gCAABA+Qn7AAAAAAAAAAAASbaEgd5+2IvCQNCNBO8AAIDtEfYBAAAAgBLxJX/fsaPXurPrAQAAAAAAAKhMwj4AAAAAUCGEOwAAAAAAdo7PVwEAqCTCPgAAAAAAAABQgfzBKgDAFq6NAADoTYR9AAAAAKCP8GU3AAAAAAAAAJSfsA8AAAAA9BLCPOXTk6+JegAAAACoXD7bAQCAvq2mpztQSV5pakqzeRPdrKamJq+88kpPd4MK1vRqkrwpyfbHLbVGUdQaRVFrFGXAgAEZOHBgT3djh9q6DtjedcKOriG6ez2VydhLUfparfX0eP3hU15f/7NbX82ub+rkwVSQ7qqznn49vf+WT18b0+g5vXXu0p718J8ZeylKT9SaMbFvMq6xIzua37veomx66/zFZzvF6w3Pqfd5iqLWKII6oyi9rdb68ne2ZVf03EXYpwMWP/lkBgwo4RU+dLN166py0T8cmiS56mt/dB6U3Lp1VUlef72MWwDQPcaNG9fTXdihtq4DtnedsKNriO5eD8AWxuvepayvp897oG/ojXOX9qwH+qa+en1jTATa4vMBKlFvnL84F4vnOQUAeoP2XNNs73Owvvo5WVGKnLtUF9YS9ALr1lXlvAvekfMueMf/P5BWxr7LrK8eNwAAAH2XuTAAANBe5g8AwLa4TgAAoGiuQYsl7ANdyAAGgPcCAABcEwJA5fI+Dr2X87tv8XoDQPfyXgsAQFtcJ3YtYR+oEAY/uopaAugdjOf0JuoZAAAoivkHAEDnbe+ayvUWAADAjpk70R7CPgAAAADQAT545Y3UA0D5GJsBAKAcXJsDALAjrhlh24R9ACAuGIHexZgGAAAAfY/PA7ZWyc9JJfedjvN6d1xnn7POPL63vl699bgAAO/zAED7uW4oF2EfSscgAVAcY25l6cnXS60AAOCasG/xegMAfY3rH3q73lzjvfnY+iKvJ0DxjL19S6W+3pXab/oWdQp0tR4L+yxatCj/7b/9t4waNSqHH354Jk6cmH/7t3/r0D42bdqUH/7whznxxBMzcuTIHHnkkbnggguyZMmSbm0XKpGLCOgc5xB0jnOIzXZUC2oFAKAyuG4DAGg/105sphagcjl/qTRqFgDKx/vzzinr81bWfpWd561jeiTsM2/evJx++ul54IEH8sEPfjAf//jHs2rVqlxyySX5zne+0+79XHbZZfkf/+N/ZNOmTTnjjDPy3ve+N//xH/+RiRMn5sknn+y2dgGoPC4QwHlA+6kVYEeME/QF6hzoTYxpUBkq+R9klLlv21Op/YaiVPK41JM687x4TgGgZ3kvLhfXo+XjOQd2Rk+OHcYtKl1N0Q1u3Lgxl156aaqqqnLjjTfmkEMOSZKcd955Oe200zJjxowcd9xxqa+v3+5+5s6dmx//+Md517veleuvvz79+/dPkpx88sn51Kc+lcsvvzw//OEPu7xdALZt3bqqXPQPhyZJrvraHzNgQHNF7Z/K0VtrobceFwCVpyffk7wfAmVjXALgjbwv9C07er3VA72BOqYSqFMqgToFAIDepTdf4/fmY+ttCr+zz9y5c/PUU09l/PjxLYGbJKmtrc3UqVOzcePG3HrrrTvcz6xZs5Ik06dPbwn6JMmYMWMyduzY3H///fnLX/7S5e2WSSWnDSu573Sc17vreU6h+zi/AACgZ7gW7128ngAA5eC6DHov5zfQndypjqKol67Xk+ev1xMAulbhYZ/58+cnScaOHbvVuve85z2tttmeefPmZeDAgTniiCO2Wrd53/fff3+Xt9tRLl4A2q+3jpm99bj6Kq8nbJ9zBIrTV8+3vnrcAABAZTF36XqeU4qi1qB7OccAKotxG4AyK3NI0XsoXaHwsM+SJUuSJMOHD99q3ZAhQ1JXV5elS5dudx+vvPJKXnjhhbz1rW/NLrvsstX6+vr6Vm11VbttcSJSFmoR+ibnPn2BSRUA0B1cB/Qu/tMoAAAAAPQNPs+jvXprrfTW4wLKbXtjj3GJrqKWtlbV3NzcXGSDZ511Vu65557Mnj27zeDNMccck2effTZ//OMft7mP5557Ln/3d3+XI444IjfffPNW6x944IF84hOfyMc+9rFcccUVXdLub3/723YeYcesW1eVi/7h0CTJVV/7YwYMaG7Xus7uu7Ntd3Z9Z3Rn37qz30Xsf2d1d611Z9+cQ12vO/vWk7XSnXqy1nqyb2Wu80o+x3pq35X8nPTkOdST7xWdUeb3/s60XeS4NG7cuE4fS3fqrvlLTynzuVjmcaAn5z4726/u3n+ZX09tl28OT8f11etwOq7MY0clt90ZZT4ubXfuPdDcpXhlvX7prWNQd/etO1Xqc9qT419PqtR+9zTPW+9S5s/BOqOSx8y+qJKf0zKfQ2U5f81filWp50NPq9RzlbaVde7Tm1/P7jzuMl+39cXvL3ekrx53Z5Xlug16Slnef4ucu9QU1hIA7TZgQHO+9c3/19PdqCies+J19jn3mnU9zykAlcD7FR2hXiqL1wsqV0+ev8YOgMpi3AagJ/l+ErqOzwKAntCd57+xhaKoNaBIhYd9amtrkyRr165tc31jY2MGDRq03X1sXt/Y2LjNfbyxra5qt9L01QsjfQMAyqIz7/199VoO2MK5Sl9Q1vdKuofXDCqX8xcqn/O4fHrrZz87alstAm0xNkDnOIcA48DO8bzRG6hj2kutQGUqPOxTX1+fJFm6dGkOPfTQVutWr16dVatW5Z3vfOd29zFw4MDsueeeWb58eV577bXssssurdYvWbKkVVtd1W7RDKxUip78QqrMX1hVqt56XPQt6hi6V6WeY5Xab7x23aE3P6e9+dgAAAAAgG3z2WDxPOewRZn/xgkqgXMEALZWeNhn1KhR+e53v5s5c+bkhBNOaLXunnvuSZI0NDTscD8NDQ254447smDBgowaNarVujlz5rS01dXtdjUXKACVz1gO5eYcBfoq4x/AFsbEcvF69C7+kAVa217NOx8AqGTexwCgZ3kvhp5Tqf+QvLOf3Rp3gLLpi+NS4WGfMWPGZNiwYbn99tszadKk/Nf/+l+TJI2Njbn22mtTU1OTCRMmtGy/cuXKrFq1KnV1ddl9991blp966qm54447cvXVV+f6669P//79kyT33Xdf5syZk1GjRmW//fbb6XYBgN6rL1700T3UEkBlMW4DQOXx/g3l4FzsXcr8xzxqDehLyjwe07eoNcpGTQKVxrjVcZ6zruc5hd6p8LBPTU1Nrrzyypx99tk5/fTTM378+NTW1mb27NlZvnx5pk+f3iqkc+ONN2bmzJk5//zzM23atJblRx55ZD760Y9m1qxZmTBhQt773vfmxRdfzJ133pna2tpcfvnlnWqX8urONyRvdtC9nGMAAAAAAAAA9DW+KweAnuW9uLL4RyRAd9je+V3Wc7/wsE/yelDnpptuyjXXXJO77rorGzZsyIgRI3LBBRfkpJNOavd+rrjiihx00EG55ZZb8oMf/CADBw7M0UcfnQsvvLDN4E5XtQsAfUVZL2Doel5rKoVapS3qArpXZ84x5yewM3rr2NFbjwugu7nrAQDdyT8bBQDAddvO8bwVz3MO29cbz5EeCfskyciRI3PdddftcLtp06a1uqPPG1VXV+fMM8/MmWee2eXt9gW9saDhjdQ49CznIABsn/dKAKg8/uAcoOsZOwF6B+M59E7ObWjNOQF0NeMKANvTY2EfgL7MRTod4T+p09upUwAAgB0zd9qa5wSAsvCeBAAAdBXzC+hezjGgkgj7AC5eAKAHeP8FqDzG7q15TgCgeN5/AagU3rPYrDfXQm8+NgDoy7zHAwBlIOwDAEBF8yEbAF2lr76n9NXjBipXbx23eutxAZXBGAQAAADQPXzuAsDOEvahW7g4oa9zDgAAlEdPXpu5Luw7vNYAvYPxvHfZ0evp9QYAAACgO/jcCQDoCsI+AHSIySjQlxjzKovXCwAAAAAAAIDu5rtpAKAIwj7t1NDQkFWrVvV0NwrT9OqWn/cfMSK7vqnn+tIdZt+5+QBH9Gg/2jJ48OCsWbOmp7tBev95oNbKQ631Lb399e5Jao2u0J7rxLq6umI60wl9bf7SGTsalzu7vrcz9rZfd9ZaX6hTtUYR1Fnv0ZkxswhqrXJ0tpZ2NL/Y3vquqFVzF9jC2EtXaM/nRmqtY8pwbVap1Fpx+nqdqrVibeu9pi/UofkLbGHs7Tt6+m8Y1RpF6M4668vXTmzNmEZRip67CPu008CBA7Nu3bqe7kZhqqqakzQnSQbuumt23bWqZzvUhwwaNCgbN27s6W6Q3n8eqLXyGDgwmfPblt96sCfdQ6211tvHlp6k1ijKwIHlH6v72vylM3Y0Lnd2fW9n7G2/ztbS9q4Z+0KdqjWKoM56j+2NmWWYg6u1yrG999Dufn/tiv2bu8AWxl6KotY6pjfMV3uKWitOGeYQPUmtlUNfqEPzF9jC2EtR1BpF6Ik6M9fsm4xpFKXouYuwD8A27LprVeb81oUeAABQ2cxtAAAAKCPzVQAAALqauSbQmwj70CZvdgDQPbzHApSLcZmyUIsAwBu5NgAAAAAAAOjbhH0AAABgJ/kjTNqrO2tFHQJA8bz/AgAAAAAA0J2EfQAAAAAAAP4TgR4AAAAAAAB6irAPAAAAbIM/8AQAAAAAAAAAAIpW3dMdAAAAAAAAAAAAAAAAAF4n7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlUVN0gy+88EKuvvrq3H333Vm9enX23XffnHjiiZkyZUr69+/frn0sWbIkv/jFL/L73/8+S5cuzUsvvZQ99tgjo0ePzjnnnJP9999/q8d8/vOfz2233dbm/vbbb7/84he/6NRxAQAAAAAAAAAAAAAAQGcVGvZ54YUXcuqpp+aZZ57JMccck/r6+jz44IOZMWNGFi5cmO9973uprt7xzYa++c1v5s4778yBBx6Y97///amtrc3jjz+en/3sZ/nlL3+Zf/3Xf8273vWuNh87adKkDB48uNWyurq6Ljk+AAAAAAAAAAAAAAAA6IxCwz5f//rX8/TTT+eyyy7L6aefniRpbm7OF77whdx222257bbb8pGPfGSH+znqqKNyzjnn5OCDD261/I477shFF12Uyy67LHfccUebj508eXLe+ta3dv5gAAAAAAAAAAAAAAAAoIvt+DY6XaSxsTF33nlnhg0blo9//OMty6uqqnLRRReluro6s2bNate+TjnllK2CPklywgknpL6+Pk8++WRWrlzZZX0HAAAAAAAAAAAAAACAIhR2Z5+FCxdm/fr1efe7352qqqpW6/baa68ceOCBeeihh7Ju3boMGDBgp9vp169fkqSmpu1Du/vuu/Pyyy+nf//+Oeigg9LQ0JBddtllp9sDAAAAAAAAAAAAAACArlJY2Gfp0qVJkvr6+jbXDx8+PI8++miWLVuWESNG7FQbixYtyhNPPJF3vOMdGTx4cJvbXHHFFa1+r6+vz1VXXZW3v/3tO9UmAAAAAAAAAAAAAAAAdJXCwj5r165NkgwaNKjN9bW1ta2225n9f+5zn0t1dXU++9nPbrV+1KhRed/73peRI0emrq4uy5cvzy233JIf/vCHOeuss/Lzn/88e++993bbqKur26m+QUepNYqi1iiKWqMoag22cD5QFLVGUdQaRVBnFEWtwRbOB4qi1iiKWqMoao2iqDXYwvlAUdQaRVFrFEGdURS1Rm/U4bDP6NGj89JLL7V7+xtuuCGjR4/uaDMdsm7dupx//vn585//nAsvvLDN9j7ykY+0+n3//ffPP/7jP2bXXXfNd77znXz/+9/P5z73ue22s2rVqi7tN7Slrq5OrVEItUZR1BpFUWsUpVI+HHA+UARjL0VRaxRBnVEUtUZRzF1gC2MvRVFrFEWtURS1RlHMX2ALYy9FUWsUQZ1RFLVGUYqeu3Q47DN+/Pi8/PLL7d7+LW95S5Itd/TZ1p17GhsbW23XXuvXr895552XuXPn5pxzzsm5557bocdPnDgx3/nOd/KHP/yhQ48DAAAAAAAAAAAAAACArtbhsM8Xv/jFnWpo+PDhSZIlS5a0uX7p0qWprq7OsGHD2r3PdevWZerUqZkzZ07OPvvsXHTRRR3u1+Z0VVNTU4cfCwAAAAAAAAAAAAAAAF2puqiGDj/88PTv3z/33ntvmpubW617/vnn8/jjj+ewww7LgAED2rW/NwZ9zjrrrHz2s5/dqX499NBDSZKhQ4fu1OMBAAAAAAAAAAAAAACgqxQW9qmtrc3xxx+fZcuW5eabb25Z3tzcnKuuuiqbNm3KRz/60VaPaWpqyuLFi/P000+3Wv7GoM+nPvWpfO5zn9tu2y+88EKeeuqprZY/99xzufLKK5Mk48eP39lDAwAAAAAAAAAAAAAAgC5RU2RjF198cebNm5crrrgi9913X+rr6/PAAw9kwYIFGTt2bCZMmNBq+0WLFmXSpElpaGjID37wg5bll112WebMmZM999wzb37zmzNjxoyt2powYULe+ta3Jkn+/Oc/Z/Lkyfnbv/3b/Jf/8l8yZMiQrFixIr/97W/zyiuvZMKECfnQhz7UvQcPAAAAAAAAAAAAAAAAO1Bo2GevvfbKj3/841x99dW5++6785vf/Cb77rtvpk2blilTpqS6un03GlqxYkWS1+/YM3PmzDa3aWhoaAn7vO1tb8vEiROzaNGi/PKXv8zLL7+c2travPOd78zEiRNz/PHHd80BAgAAAAAAAAAAAAAAQCcUGvZJXg/8fPnLX27XtqNHj85jjz221fI33uWnPfbZZ59ceeWVHXoMAAAAAAAAAAAAAAAAFK19t9IBAAAAAAAAAAAAAAAAup2wDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJRETdENvvDCC7n66qtz9913Z/Xq1dl3331z4oknZsqUKenfv3+793PQQQdtc93FF1+cKVOmdFvbAAAAAAAAAAAAAAAA0B0KDfu88MILOfXUU/PMM8/kmGOOSX19fR588MHMmDEjCxcuzPe+971UV7f/ZkNDhw7NhAkTtlp+xBFHdHvbAAAAAAAAAAAAAAAA0NUKDft8/etfz9NPP53LLrssp59+epKkubk5X/jCF3Lbbbfltttuy0c+8pF272/o0KGZNm1aj7QNAAAAAAAAAAAAAAAAXa2wW9k0NjbmzjvvzLBhw/Lxj3+8ZXlVVVUuuuiiVFdXZ9asWb2ubQAAAAAAAAAAAAAAAGivwu7ss3Dhwqxfvz7vfve7U1VV1WrdXnvtlQMPPDAPPfRQ1q1blwEDBrRrn2vWrMmsWbPy4osvZvfdd09DQ0Pq6+sLaRsAAAAAAAAAAAAAAAC6WmFhn6VLlyZJm2GcJBk+fHgeffTRLFu2LCNGjGjXPh999NFceumlLb9XVVXlxBNPzBVXXJFdd921W9sGAAAAAAAAAAAAAACArlZY2Gft2rVJkkGDBrW5vra2ttV2O3LWWWflQx/6UIYPH56qqqo88sgj+Zd/+Zf8/Oc/z2uvvZarrrqqy9uuq6trV9+gs9QaRVFrFEWtURS1Bls4HyiKWqMoao0iqDOKotZgC+cDRVFrFEWtURS1RlHUGmzhfKAoao2iqDWKoM4oilqjN+pw2Gf06NF56aWX2r39DTfckNGjR3e0mR363Oc+1+r3I488Mt///vfz4Q9/OHfccUc+85nP5IADDujSNletWtWl+4O21NXVqTUKodYoilqjKGqNolTKhwPOB4pg7KUoao0iqDOKotYoirkLbGHspShqjaKoNYqi1iiK+QtsYeylKGqNIqgziqLWKErRc5cOh33Gjx+fl19+ud3bv+Utb0my5a4627p7TmNjY6vtdsauu+6aE044Iddee20WLFjQEvYpom0AAAAAAAAAAAAAAADorA6Hfb74xS/uVEPDhw9PkixZsqTN9UuXLk11dXWGDRu2U/vfbHNaqqmpqfC2AQAAAAAAAAAAAAAAoDOqi2ro8MMPT//+/XPvvfemubm51brnn38+jz/+eA477LAMGDCgU+089NBDSZK3vvWthbcNAAAAAAAAAAAAAAAAnVFY2Ke2tjbHH398li1blptvvrlleXNzc6666qps2rQpH/3oR1s9pqmpKYsXL87TTz/davkjjzzS6s49m91111254447UldXlzFjxnSqbQAAAAAAAAAAAAAAAChaTZGNXXzxxZk3b16uuOKK3Hfffamvr88DDzyQBQsWZOzYsZkwYUKr7RctWpRJkyaloaEhP/jBD1qW33DDDfn1r3+dMWPGZJ999klzc3MeeeSRPPDAAxkwYED++Z//OW9+85s71TYAAAAAAAAAAAAAAAAUrdCwz1577ZUf//jHufrqq3P33XfnN7/5Tfbdd99MmzYtU6ZMSXV1+2409P73vz9r1qzJww8/nN///vfZuHFj9t5770ycODFnnXVW9t9//25rGwAAAAAAAAAAAAAAALpLoWGf5PXQzZe//OV2bTt69Og89thjWy0/9thjc+yxx3Zr2wAAAAAAAAAAAAAAAFA0t7MBAAAAAAAAAAAAAACAkhD2AQAAAAAAAAAAAAAAgJIQ9gEAAAAAAAAAAAAAAICSEPYBAAAAAAAAAAAAAACAkhD2AQAAAAAAAAAAAAAAgJIQ9gEAAAAAAAAAAAAAAICSEPYBAAAAAAAAAAAAAACAkhD2AQAAAAAAAAAAAAAAgJIQ9gEAAAAAAAAAAAAAAICSEPYBAAAAAAAAAAAAAACAkhD2AQAAAAAAAAAAAAAAgJIQ9gEAAAAAAAAAAAAAAICSEPYBAAAAAAAAAAAAAACAkhD2AQAAAAAAAAAAAAAAgJIQ9gEAAAAAAAAAAAAAAICSEPYBAAAAAAAAAAAAAACAkhD2AQAAAAAAAAAAAAAAgJIQ9gEAAAAAAAAAAAAAAICSEPYBAAAAAAAAAAAAAACAkhD2AQAAAAAAAAAAAAAAgJIQ9gEAAAAAAAAAAAAAAICSEPYBAAAA/j/27j3OqrreH/9rkIvSAI4mHiUEC9PjBc1ikMSkvlqpaGJoaiqVRqXyldJvp86po5nf8nQ6HhOOqV+/x76amjd8VKZGdU4apqASklpaKFdvFAiMjFxkfn/0Y4xmuAyzZ83aM8/nXzNrrf35fPbe7/3Z67P3vGYBAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJdGz6A6XLl2aK6+8Mg888EBWrFiRPffcM8cff3wmTpyY3r17b1MbU6ZMydSpU7d4zEc/+tF84xvfaP79S1/6Uu6+++5Wj917771z//33b/udAAAAAAAAAAAAAAAAgA5QaNhn6dKlOeWUU/Liiy/mqKOOytChQ/P4449nypQpmTNnTq677rr06LH1iw3V19fn/PPPb3XfHXfckZdffjmjR49udf9ZZ52V/v37b7Ktrq6u7XcGAAAAAAAAAAAAAAAAKqzQsM+3v/3tvPDCC7n44otz+umnJ0mampry5S9/OXfffXfuvvvufPSjH91qOyNHjszIkSNbbP/Tn/6Ua665JjvvvHOOOuqoVm87YcKEvO1tb2vfHQEAAAAAAAAAAAAAAIAOsPXL6FRIQ0ND7r333gwePDinnXZa8/aampp84QtfSI8ePXLHHXe0q49p06Zl/fr1+chHPpLevXu3d8gAAAAAAAAAAAAAAABQqMKu7DNnzpysXbs2733ve1NTU7PJvoEDB+ad73xnnnjiiaxZsyZ9+vTZrj7uuuuuJMnJJ5+82WMeeOCBvPbaa+ndu3f23Xff1NfXZ4cddtiu/gAAAAAAAAAAAAAAAKCSCgv7LFiwIEkydOjQVvcPGTIkv//977No0aIMGzasze0/9thjmT9/fg455JDss88+mz3u0ksv3eT3oUOH5oorrsgBBxzQ5j4BAAAAAAAAAAAAAACgkgoL+6xatSpJ0q9fv1b319bWbnJcW915551JkvHjx7e6f8SIEfnABz6Q4cOHp66uLosXL85tt92W73//+/nUpz6VH/3oR9l999232EddXd12jQ3aSq1RFLVGUdQaRVFr8CavB4qi1iiKWqMI6oyiqDV4k9cDRVFrFEWtURS1RlHUGrzJ64GiqDWKotYogjqjKGqNrqjNYZ+RI0fm1Vdf3ebjb7zxxowcObKt3bRJQ0ND7r///vTt2zfHHntsq8d89KMf3eT3d7zjHfnHf/zH7LTTTrnmmmvyve99L//wD/+wxX6WL19esTHD5tTV1ak1CqHWKIpaoyhqjaJUy4cDXg8UwdxLUdQaRVBnFEWtURRrF3iTuZeiqDWKotYoilqjKNYv8CZzL0VRaxRBnVEUtUZRil67tDnsM3bs2Lz22mvbfPxb3/rWJG9e0WdzV+5paGjY5Li2uOeee9LY2Jjx48fnLW95S5tuO378+FxzzTX5zW9+0+Z+AQAAAAAAAAAAAAAAoJLaHPb56le/ul0dDRkyJEkyf/78VvcvWLAgPXr0yODBg9vc9p133pkkOfnkk9t8243pqsbGxjbfFgAAAAAAAAAAAAAAACqpR1EdHXLIIendu3d+/etfp6mpaZN9r7zySp599tkcfPDB6dOnT5vafeaZZ/Lb3/42++yzTw455JA2j+uJJ55IkgwaNKjNtwUAAAAAAAAAAAAAAIBKKizsU1tbm2OPPTaLFi3Krbfe2ry9qakpV1xxRTZs2NDiyjyNjY2ZN29eXnjhhc22u/GqPuPHj9/sMUuXLs3ChQtbbH/55Zdz2WWXJUnGjh3bpvsDAAAAAAAAAAAAAAAAldazyM4uvPDCzJw5M5deemkefvjhDB06NI899lhmz56d0aNHZ9y4cZscP3fu3Jx11lmpr6/PTTfd1KK9tWvX5kc/+lF69eqVE044YbP9Pvfcc5kwYULe/e535+1vf3sGDBiQJUuW5Je//GVWr16dcePG5Zhjjqn4/QUAAAAAAAAAAAAAAIC2KDTsM3DgwNx+++258sor88ADD+S///u/s+eee2bSpEmZOHFievRo24WGfv7zn+fVV1/NMccck1122WWzx+21114ZP3585s6dm5/+9Kd57bXXUltbm3e9610ZP358jj322PbeNQAAAAAAAAAAAAAAAGi3QsM+yV8CP9/4xje26diRI0fmmWee2ez+Y489dpuCOnvssUcuu+yybR4jAAAAAAAAAAAAAAAAdIa2XUoHAAAAAAAAAAAAAAAA6DDCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASPYvs7NFHH81//dd/5cknn8zTTz+dhoaGjBs3Lpdffvl2tferX/0q1113XZ566qk0NTXlwAMPzMSJE3PEEUe0evzSpUtz5ZVX5oEHHsiKFSuy55575vjjj8/EiRPTu3fv9tw1AAAAAAAAAAAAAAAAaLdCr+xz11135T//8z/z29/+NgMHDmxXWz/60Y9yzjnn5A9/+EPGjRuXj370o3nuuedyzjnn5Ec/+lGL45cuXZpTTjkld911Vw455JBMmDAhu+yyS6ZMmZJzzz03GzZsaNd4AAAAAAAAAAAAAAAAoL0KvbLPxz/+8Zx99tl5+9vfnt/+9rf52Mc+tl3trFixIl//+tdTV1eXu+++O3vssUeSZOLEiTnppJPy9a9/PUceeWQGDBjQfJtvf/vbeeGFF3LxxRfn9NNPT5I0NTXly1/+cu6+++7cfffd+ehHP9r+OwkAAAAAAAAAAAAAAADbqdAr+xx00EHZZ599ssMOO7Srnfvvvz8rV67MGWec0Rz0SZKBAwfmrLPOysqVK3P//fc3b29oaMi9996bwYMH57TTTmveXlNTky984Qvp0aNH7rjjjnaNCQAAAAAAAAAAAAAAANqr0LBPpcyaNStJMnr06Bb7jjjiiE2OSZI5c+Zk7dq1ee9735uamppNjh84cGDe+c535oknnsiaNWs6cNQAAAAAAAAAAAAAAACwZVUZ9pk/f36SZMiQIS32bdy2YMGC5m0bfx46dGir7Q0ZMiQbNmzIokWLKjtQAAAAAAAAAAAAAAAAaIOenT2A7dHQ0JAk6devX4t9ffv2zQ477JBVq1Y1b9v4c2vHJ0ltbe0mx21OXV3ddo0X2kqtURS1RlHUGkVRa/AmrweKotYoilqjCOqMoqg1eJPXA0VRaxRFrVEUtUZR1Bq8yeuBoqg1iqLWKII6oyhqja6ozWGfkSNH5tVXX93m42+88caMHDmyrd0AAAAAAAAAAAAAAABAt9PmsM/YsWPz2muvbfPxb33rW9vaxVb99ZV4/jaFt3r16rzxxhubXMVn48+bu3LPlq4UBAAAAAAAAAAAAAAAAEVpc9jnq1/9akeMo02GDh2aJ598MgsWLGgR9lmwYEGSZMiQIc3bNv48f/78VttbsGBBevTokcGDB3fMgAEAAAAAAAAAAAAAAGAb9OjsAWyPESNGJElmzJjRYt+vfvWrJEl9fX3ztkMOOSS9e/fOr3/96zQ1NW1y/CuvvJJnn302Bx98cPr06dOBowYAAAAAAAAAAAAAAIAtK3XYp7GxMfPmzcsLL7ywyfZjjjkm/fr1y/e///28+OKLzdtfeeWV3Hjjjenfv38+/OEPN2+vra3Nsccem0WLFuXWW29t3t7U1JQrrrgiGzZsyMknn9zxdwgAAAAAAAAAAAAAAAC2oKbpby9104Eee+yx3HnnnUmSZcuW5YEHHshee+2Vd7/73UmSt7/97Zk4cWLz8TNnzsxZZ52V+vr63HTTTZu09cMf/jBf/OIXU1dXl+OOOy41NTW577778qc//Snf+ta38pGPfGST41955ZWccsopeemll3L00Udn6NCheeyxxzJ79uyMHj06/+f//J/06FHq7BMAAAAAAAAAAAAAAABdXM8iO1u4cGHuvvvuFtsWLlyYJKmvr98k7LMlH/nIR1JXV5frrrsu06ZNS5IccMABufzyy3PEEUe0OH7gwIG5/fbbc+WVV+aBBx7If//3f2fPPffMpEmTMnHiREEfAAAAAAAAAAAAAAAAOl2hV/YBAAAAAAAAAAAAAAAANs/lbAAAAAAAAAAAAAAAAKAkhH0AAAAAAAAAAAAAAACgJIR9AAAAAAAAAAAAAAAAoCSEfQAAAAAAAAAAAAAAAKAkhH0AAAAAAAAAAAAAAACgJIR9AAAAAAAAAAAAAAAAoCSEfQAAAAAAAAAAAAAAAKAkhH0AAAAAAAAAAAAAAACgJIR9AAAAAAAAAAAAAAAAoCSEfQAAAAAAAAAAAAAAAKAkhH0AAAAAAAAAAAAAAACgJIR9AAAAAAAAAAAAAAAAoCSEfQAAAAAAAAAAAAAAAKAkhH0AAAAAAAAAAAAAAACgJIR9AAAAAAAAAAAAAAAAoCSEfQAAAAAAAAAAAAAAAKAkhH0AAAAAAAAAAAAAAACgJIR9AOjSZs6cmX333TdnnnlmZw8FAABgs6xdAACAamH9AgAAVANrFwCqXc/OHgAAtNf3vve9rFq1KhMmTEj//v07dSwzZ87MrFmzUl9fn5EjR3bqWAAAgHKxdgEAAKqF9QsAAFANrF0A6Mpc2QeAqnfjjTdm6tSpWblyZWcPJbNmzcrUqVMza9aszh4KAABQMtYuAABAtbB+AQAAqoG1CwBdmbAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJRETVNTU1NnDwIAtse0adPy5S9/ebP7b7zxxiTJWWedlfr6+vy///f/ctNNN+WOO+7IggUL0q9fv4wZMyYXXXRRdtlll1bbePXVV3PDDTfkF7/4RRYvXpyamprss88+GT9+fMaPH58ePd7Mze67776bHcu4ceNy+eWXJ0kWLVqU++67L7/61a+ycOHC/PnPf05tbW0OOOCAnHnmmRkzZsx2PBoAAEBZWbsAAADVwvoFAACoBtYuAHQHPTt7AACwvXbdddcceuihefLJJ7N27doceOCB6d27d/P+fv36ZdWqVc2//6//9b9yzz33ZOjQoRkyZEief/753HXXXZk7d26mTZu2yW2T5A9/+EPOPvvsvPzyy+nVq1eGDBmStWvXZu7cuXniiScyY8aMfOc730lNTU2S5NBDD82LL76YF198MXvssUf22GOP5raGDh3a/PM111yTO++8M3379s3AgQOz77775uWXX86MGTMyY8aMXHjhhZk4cWIHPWoAAEDRrF0AAIBqYf0CAABUA2sXALoDV/YBoOp94AMfyJIlS/KLX/wib3vb2zbZN3PmzJx11lnp1atX6urq8h//8R8ZPnx4kuT555/PJz7xibz00ku55JJLctpppzXfbvXq1fnIRz6ShQsX5swzz8zkyZNTW1ubJPnjH/+YyZMn5w9/+EP++Z//OR//+MebbzdlypRMnTo1559/fiZNmtTqeB944IHsvPPOGT58ePOCL0kee+yxTJ48OcuWLcv999+fvfbaq2KPEQAA0PmsXQAAgGph/QIAAFQDaxcAurIeWz8EAKrfunXr8tWvfrV5wZYke++9d84555wkyYMPPrjJ8XfddVcWLlyYo48+Ol/5yleaF2xJMmzYsHz7299OTU1NbrjhhjaP5cgjj8zBBx+8yYItSd7znvfkggsuyBtvvJF77723ze0CAADVz9oFAACoFtYvAABANbB2AaBa9ezsAQBAEQYMGJAPfvCDLbYfdNBBSZLFixdvsn369OlJkpNPPrnV9vbbb78MGjQoixYtyksvvZS/+7u/a9N4li1blh//+MeZO3du/vznP2fNmjVJkoaGhiTJ73//+za1BwAAdA3WLgAAQLWwfgEAAKqBtQsA1UrYB4BuYfDgwa1u33XXXZMkr7322ibbn3322STJd77znVxzzTWt3nb58uVJkpdffrlNi7YZM2Zk8uTJWbVq1WaPWbFixTa3BwAAdB3WLgAAQLWwfgEAAKqBtQsA1UrYB4BuoW/fvq1u/9tLom608T8lPPXUU1tt+/XXX9/mcaxcuTJf+MIXsmrVqpx44ok5/fTTs/fee6e2tjY9evTIr3/963zyk5/M+vXrt7lNAACg67B2AQAAqoX1CwAAUA2sXQCoVsI+ANCKvn37ZuXKlZk+fXqGDBlSsXYffPDBrFixIu9617ty+eWXt1g0vvjiixXrCwAA6PqsXQAAgGph/QIAAFQDaxcAyqJHZw8AAMroHe94R5LkD3/4Q5tut7n/+LDRkiVLkiSHHHJIq8f+/ve/b1N/AABA92btAgAAVAvrFwAAoBpYuwBQFsI+AFS9HXfcMUmyZs2airX5wQ9+MEly4403pqmpaZtv16dPnySbv0Trxv1/+tOfWuxbvnx57rzzzrYOFQAAqBLWLgAAQLWwfgEAAKqBtQsAXZmwDwBVb/DgwUmSWbNmVazNj33sYxk8eHBmzpyZiy66KK+88som+1977bXce++9+eY3v9nqWH7zm99k/fr1Ldp9z3vekyS5//778+tf/7p5+yuvvJL/+T//Z954442K3QcAAKBcrF0AAIBqYf0CAABUA2sXALqynp09AABor2OOOSa//OUvc8kll+SWW27JzjvvnCT5x3/8x+1u8y1veUuuvfbaTJw4Mffcc0/uvffe7L333qmtrc2KFSuyaNGivPHGGzn44IM3ud3o0aMzYMCAPP744xkzZkwGDx6cnj175ogjjsjEiRNz4IEH5kMf+lB++tOf5pOf/GSGDBmSvn375g9/+EP69OmTCy+8MN/4xjfa83AAAAAlZe0CAABUC+sXAACgGli7ANCVCfsAUPVOPPHErFy5MnfeeWcWLFiQZ599NkmycuXKdrX7jne8Iz/84Q9zyy235Oc//3nmzZuXRYsWZbfddsuIESNy5JFHNl+2daPa2tr83//7f3PVVVdl7ty5mTNnTjZs2JBBgwY1H/Ptb3+7ue0XXnghO++8cz70oQ/l/PPPz9KlS9s1ZgAAoLysXQAAgGph/QIAAFQDaxcAurKapqamps4eBAAAAAAAAAAAAAAAAJD06OwBAAAAAAAAAAAAAAAAAH8h7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJdGzswcAAB2lqakpjz/+eH7xi1/k8ccfz3PPPZfXX389O++8c971rnfl4x//eA477LAO6XvevHm5+uqrM3PmzKxYsSK77757jj766Hzuc59L//79O6RPAACgenXG+mXlypWZMWNG5s6dmyeeeCJPP/10Xn/99YwaNSrf+973KtoXAADQdfz85z/Pgw8+mCeffDKvvPJKXn311ey4444ZNmxYjjnmmJx22mnp3bt3xfv13QsAANBWRa9ffPcCQCXVNDU1NXX2IACgIzz88MP5xCc+kSTp0aNH9tprr/Tt2zfz58/P6tWrkySf+9znMnny5Ir2+8gjj+Qzn/lMXn/99eyyyy7ZY4898txzz6WxsTGDBw/OD37wg7z1rW+taJ8AAEB164z1y89//vOcd955Lbb7wgkAANiS0047LbNnz07v3r0zcODA7Lzzzlm6dGlefvnlJMkBBxyQ733vexUN4PjuBQAA2B5Fr1989wJAJbmyDwBdVlNTU4YMGZJPfOITOe644zJgwIAkydq1azN16tRce+21+e53v5uDDz4473//+yvSZ0NDQz7/+c/n9ddfz5lnnpl/+Id/SK9evbJ8+fKce+65mT17dv7pn/4p1157bUX6AwAAuobOWL/06dMnI0aMyEEHHZThw4dn4cKFueKKKyrSNgAA0HWdfPLJmTx5cg499ND06tWrefucOXNywQUX5Kmnnsq///u/5+KLL65If757AQAAtlfR6xffvQBQSa7sA0CX1dDQkB133DE9e7aebf30pz+dBx98MB/4wAfy3e9+tyJ9Xn/99fnXf/3XvOMd78iPf/zj7LDDDs37XnjhhRx99NFZv359pk2blgMOOKAifQIAANWvM9Yvf2vatGn58pe/7L/LAQAA2+2+++7L5MmTM3DgwPzqV7+qSJu+ewEAADpCR6xf/pbvXgBojx6dPQAA6Ci1tbWb/UO5JDn88MOTJPPnz69Ynz/72c+SJOPGjdvky6Yk2XPPPTNq1KgkyU9/+tOK9QkAAFS/zli/AAAAVNrb3/72JMnrr79esTZ99wIAAHSEjli/AEAlCfsA0G2tWbMmSbLjjjtWpL3169fnqaeeSpIceuihrR6zcfsTTzxRkT4BAIDuodLrFwAAgI4wZ86cJMn+++9fkfZ89wIAAHSUSq9fAKDSNv/vQgGgC2tqasr999+fZPNfDrXVkiVLsm7duiTJ4MGDWz1m4/YFCxZUpE8AAKDr64j1CwAAQKW88cYbWbp0aX7xi1/k3/7t39K3b99ceOGFFWnbdy8AAEAldeT6BQAqTdgHgG7p9ttvz9NPP51evXplwoQJFWlzxYoVzT8PGDCg1WP69+/f4lgAAIAt6Yj1CwAAQHt973vfyze/+c1Nth111FG54IIL8s53vrMiffjuBQAAqIQi1i8AUGk9OnsAAFC0p556Kv/7f//vJMnkyZOz1157VaTdtWvXNv/cq1evVo/p3bt3kmTNmjUV6RMAAOjaOmr9AgAA0F677757Dj300AwfPjxvfetbkyQzZ87MT37yk7zxxhsV6cN3LwAAQCUUsX4BgEpzZR8AupVFixblM5/5TNasWZOxY8fm7LPPrljbG79MSpJ169alT58+LY7Z+KVUa/sAAAD+WkeuXwAAANrrmGOOyTHHHNP8+xNPPJF//ud/zjXXXJNXX301X/va19rdh+9eAACASihi/QIAlebKPgB0G0uXLs2nPvWpLF26NGPGjMnll1+empqairU/YMCA5p9XrFjR6jErV65scSwAAMDf6uj1CwAAQKUdfPDBue6669K7d+/cfvvtWbJkSbvb9N0LAADQETpi/QIAlSbsA0C38Oqrr+ZTn/pUFi5cmPr6+nznO99Jr169KtrHoEGDmttctGhRq8ds3D5kyJCK9g0AAHQdRaxfAAAAOsLuu++ev//7v8+GDRvy+9//vt3t+e4FAADoKJVevwBApQn7ANDlvfbaa5k4cWKeffbZHHTQQfnud7+bHXfcseL99OzZM/vvv3+SZPbs2a0es3H7wQcfXPH+AQCA6lfU+gUAAKCjrF+/PknyxhtvtLst370AAAAdqZLrFwCoNGEfALq0tWvX5txzz80TTzyRffbZJ9dff31qa2s7rL+jjz46SXL33Xe3WAS+8MILefjhh5MkH/zgBztsDAAAQHUqev0CAABQaYsXL84zzzyTJNlvv/0q0qbvXgAAgI7QEesXAKgkYR8Auqw33ngjn//85/PII49kr732yn/+539m55133qbbzpw5M/vuu2/23XffNvV52mmnpa6uLvPmzcs3v/nNrFu3LkmyfPnyXHjhhVm/fn3e97735cADD2zr3QEAALqwzli/AAAAtNWTTz6Zq666KosWLWqx78EHH8ynP/3prF+/PkceeWT22muvTfb77gUAAChSZ6xfAKCSapqampqK7PCHP/xhHn/88Tz55JN59tlns27dunzzm9/MSSed1KZ2NmzYkFtuuSW33XZbFixYkL59+2bkyJH5/Oc/n6FDh7Z6m7lz52bKlCmZM2dO1q1bl2HDhmXChAk5/vjjK3DPACibe+65JxdeeGGSZOjQodlll11aPW633XbLVVddtcm2mTNn5qyzzkqS5v/gsK0efvjhfOYzn8maNWuyyy67ZI899shzzz2XxsbGDBo0KLfddlt222237bhHAABAV9VZ65eRI0c2/7x27dqsXr06vXr1ylve8pbm7f/8z/+c4447rk3tAgAAXdNfrz9222237L777lm3bl1efPHFrFy5Mkly0EEH5brrrmuxrvHdCwAAUKTOWr/47gWASulZdIff+c53smTJktTV1WXgwIFZsmTJdrVz8cUX5/bbb8+wYcNyxhln5M9//nPuvffePPTQQ/nBD36QYcOGbXL8zJkzc/bZZ6dXr1457rjj0q9fv0yfPj0XXXRRlixZks9+9rOVuHsAlMjatWubf54/f37mz5/f6nGDBg1qse1Pf/pTkmzXf2cYNWpU7rrrrnz3u9/NI488kmeffTa77757jj766Hzuc5/LgAED2twmAADQtXXW+uXVV19tsW3dunWbbF+zZk2b2wUAALqm/fbbL//0T/+Uhx9+OH/84x/z3HPPZd26ddl5553zvve9L8ccc0xOOOGE9OzZ8k8RfPcCAAAUqbPWL757AaBSCr+yz69//esMGTIkgwYNynXXXZd/+7d/a/OVfR555JFMmDAh73nPe3LDDTekd+/eSf7y33w++clP5j3veU++//3vNx+/fv36HHPMMXnppZdy2223Zf/990+SNDQ05NRTT83zzz+fn/zkJ5u9IhAA3c9ll12Wm266Kf/yL/+SE088sbOHAwAAsFnWLwAAQDWwdgEAAKqF9QsAZdCj6A7f+973tvofSNvijjvuSJJMnjy5OeiT/OW/+YwePTqPPvponn/++ebtjzzySBYuXJixY8c2B32SpLa2Nueee27Wr1+fadOmtWtMAHQts2fPzsCBA3Psscd29lAAAAC2yPoFAACoBtYuAABAtbB+AaAMCg/7VMLMmTPTt2/fHHrooS32jR49Okny6KOPNm+bNWvWJvv+2uGHH77JMQCwevXqPPPMMznjjDM2CZUCAACUjfULAABQDaxdAACAamH9AkBZ9OzsAbTV6tWrs3Tp0rzzne/MDjvs0GL/0KFDkyTz589v3rbx5yFDhrQ4fsCAAamrq8uCBQs6YrgAVKG+ffvmqaee6uxhAAAAbJX1CwAAUA2sXQAAgGph/QJAWVTdlX1WrVqVJKmtrW11/8btDQ0Nzds2/tyvX7/N3mZju5tzwMF/zurVTW0eLwAAQNGsXwAAgGpg7QIAAFQL6xcAAKBoVXdln8706qvLs2ZNTWcPgy6urq4uy5cv7+xh0A2oNYqi1iiKWqModXV1nT2EbWL9QhHMvRRFrVEEdUZR1BpFsXaBN5l7KYpaoyhqjaKoNYpi/QJvMvdSFLVGEdQZRVFrFKXotUvVXdln49V5/vrKPX9t4/a/vvLPxp83d/WehoaGzV71BwAAAAAAAAAAAAAAAIpSdWGfvn37ZrfddsvixYvzxhtvtNg/f/78JMnQoUObt238ecGCBS2OX7FiRZYvX54hQ4Z0xHABAAAAAAAAAAAAAABgm1Vd2CdJ6uvrs3r16syePbvFvhkzZiRJRowY0bxt488b9/21hx56qLlNAAAAAAAAAAAAAAAA6EylDvssW7Ys8+bNy7JlyzbZfsoppyRJrrzyyqxdu7Z5+8MPP5wZM2ZkxIgR2XvvvZu3jxo1KoMHD84999yT3/3ud83bGxoacvXVV6dnz54ZN25cB98bAAAAAAAAAAAAAAAA2LKeRXd4xx135PHHH0+SPPvss83bZs2alSQ56qijctRRRyVJbr755kydOjXnn39+Jk2a1NzGYYcdlpNPPjl33HFHxo0blyOPPDJ//vOfc++996a2tjaXXHLJJn327Nkzl112Wc4555ycfvrpGTt2bGprazN9+vQsXrw4kydP3iQcBAAAAAAAAAAAAAAAAJ2h8LDP448/nrvvvnuTbbNnz87s2bOTJIMGDWoO+2zJpZdemn333Te33XZbbrrppvTt2zfvf//78/nPf77V4M5hhx2WW265JVdddVXuu+++rFu3LsOGDcsFF1yQE044oTJ3DgAAAAAAAAAAAAAAANqh8LDP5Zdfnssvv3ybjp00adImV/T5az169MiZZ56ZM888c5v7Hj58eK6//vptPh4AAAAAAAAAAAAAAACK1KOzBwAAAAAAAAAAAAAAAAD8hbAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlETPzup47ty5mTJlSubMmZN169Zl2LBhmTBhQo4//vhtuv2ZZ56ZWbNmbfGYf/mXf8mJJ57Y/PsHPvCBLFmypNVjP/axj+XSSy/d5vEDAAAAAAAAAAAAAABApXVK2GfmzJk5++yz06tXrxx33HHp169fpk+fnosuuihLlizJZz/72a22MW7cuNTX17fYvn79+lx77bXp0aNHRo0a1WJ/v379MmHChBbbDzzwwO27MwAAAAAAAAAAAAAAAFAhhYd91q9fn6985SupqanJzTffnP333z9Jct555+XUU0/NlClT8uEPfzhDhw7dYjsnnXRSq9t/+tOfpqmpKe973/uy++67t9jfv3//TJo0qd33AwAAAAAAAAAAAAAAACqtR9EdPvLII1m4cGHGjh3bHPRJktra2px77rlZv359pk2btt3t33HHHUmS8ePHt3usAAAAAAAAAAAAAAAAUKTCr+wza9asJMno0aNb7Dv88MM3OaatXnrppTz00EPZbbfdMmbMmFaPWbt2be6+++68/PLL6d+/fw499NDst99+29UfAAAAAAAAAAAAAAAAVFLhYZ/58+cnSYYMGdJi34ABA1JXV5cFCxZsV9t33XVXNmzYkHHjxqVnz9bv2tKlS/OlL31pk21HHHFEvvWtb2WXXXbZrn4BAAAAAAAAAAAAAACgEgoP+zQ0NCRJ+vXr1+r+2travPTSS21ut6mpKdOmTUuSjB8/vtVjTjrppNTX12fYsGHp3bt35s2bl6lTp+bBBx/Mueeem1tvvTU1NTWb7WPnnevSt+/m90Ol1NXVdfYQ6CbUGkVRaxRFrcGbrF8oirmXoqg1iqDOKIpagzdZu1AUcy9FUWsURa1RFLUGb7J+oSjmXoqi1iiCOqMoao2uqPCwT0d55JFHsnjx4tTX17d61aAkOf/88zf5/eCDD861116bM844I48//ngeeOCBjBkzZrN9vPrq8qxZY8FGx6qrq8vy5cs7exh0A2qNoqg1iqLWKEq1fDhg/UIRzL0URa1RBHVGUdQaRbF2gTeZeymKWqMoao2iqDWKYv0CbzL3UhS1RhHUGUVRaxSl6LVLj0J7y1+u3JMkq1atanV/Q0PDZq/6syV33HFHks1f1WdzevTokZNOOilJMnv27Db3CwAAAAAAAAAAAAAAAJVSeNhn6NChSZIFCxa02LdixYosX758s1fm2ZwVK1bkZz/7Wfr3758PfehDbR7TxoRVY2Njm28LAAAAAAAAAAAAAAAAlVJ42GfEiBFJkhkzZrTY99BDDyVJ6uvr29Tmj370o6xduzbHH398dtxxxzaPae7cuUmSQYMGtfm2AAAAAAAAAAAAAAAAUCmFh31GjRqVwYMH55577snvfve75u0NDQ25+uqr07Nnz4wbN655+7JlyzJv3rwsW7Zss23eeeedSZLx48dv9pg//vGPWblyZYvtjz32WG644Yb07t07H/zgB7fnLgEAAAAAAAAAAAAAAEBF9Cy8w549c9lll+Wcc87J6aefnrFjx6a2tjbTp0/P4sWLM3ny5Oy9997Nx998882ZOnVqzj///EyaNKlFe08++WR+//vf54ADDsj++++/2X7vu+++XH/99Rk1alQGDRqU3r1759lnn81DDz2UHj165Gtf+1r23HPPDrnPAAAAAAAAAAAAAAAAsC0KD/skyWGHHZZbbrklV111Ve67776sW7cuw4YNywUXXJATTjihTW1ty1V9kmTkyJGZN29enn766cyaNStr167NrrvummOPPTaf+MQnMnz48O2+PwAAAAAAAAAAAAAAAFAJnRL2SZLhw4fn+uuv3+pxkyZNavWKPhtdcsklueSSS7baTn19ferr69syRAAAAAAAAAAAAAAAAChUj84eAAAAAAAAAAAAAAAAAPAXwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAJRGY2NTRo/ZkNFjNqSxsamzhwMAAAAAAFA4YR8AAAAAAAAAAAAAAAAoCWEfAAAAAAAAAAAAAAAAKAlhHwAAAAAAAAAAAAAAACgJYR8AAAAAAAAAAAAAAAAoCWEfAAAAAAAAAAAAAAAAKAlhHwAAAAAAAAAAAAAAACgJYR8AAAAAAAAAAAAAAAAoCWEfAAAAAAAAAAAAAAAAKAlhHwAAAAAAAAAAAAAAACgJYR8AAAAAAAAAAAAAAAAoiZ6d1fHcuXMzZcqUzJkzJ+vWrcuwYcMyYcKEHH/88dt0+5kzZ+ass87a7P7bbrsthxxySMX7BQAAAAAAAAAAAAAAgI7SKWGfmTNn5uyzz06vXr1y3HHHpV+/fpk+fXouuuiiLFmyJJ/97Ge3ua36+vrU19e32P53f/d3HdovAAAAAAAAAAAAAAAAVFrhYZ/169fnK1/5SmpqanLzzTdn//33T5Kcd955OfXUUzNlypR8+MMfztChQ7epvfr6+kyaNKnwfgEAAAAAAAAAAAAAAKDSehTd4SOPPJKFCxdm7NixzYGbJKmtrc25556b9evXZ9q0aV2mXwAAAAAAAAAAAAAAANhWhV/ZZ9asWUmS0aNHt9h3+OGHb3LMtpg/f35uvPHGvP7669lzzz3z3ve+N7vsskuH97tRY2NTjj6mKUnys/tqstNONW1uAwAAAAAAAAAAAAAAAJJOCPvMnz8/STJkyJAW+wYMGJC6urosWLBgm9u75557cs899zT/vuOOO2bSpEk555xzOrRfAAAAAAAAAAAAAAAAqLTCwz4NDQ1Jkn79+rW6v7a2Ni+99NJW29lll13yxS9+MWPGjMmee+6ZlStXZubMmfn2t7+df/3Xf01tbW1OPfXUiva788516dt30yv39OnTlGTZZvfD9qirq+vsIdBNqDWKotYoilqDN1mfUBRzL0VRaxRBnVEUtQZv8t0LRTH3UhS1RlHUGkVRa/Am6xOKYu6lKGqNIqgziqLW6IoKD/tUyj777JN99tmn+feddtopJ5xwQvbbb7+cdNJJmTJlSk455ZT06NGjYn2++uryrFmz6YKtsbFpi/uhrerq6rJ8+fLOHgbdgFqjKGqNoqg1ilItHw5Yn1AEcy9FUWsUQZ1RFLVGUap57eK7FyrN3EtR1BpFUWsURa1RlGpev0ClmXspilqjCOqMoqg1ilL02qVySZhtVFtbmyRZtWpVq/sbGho2e/WdbfHOd74zBx98cP70pz9lwYIFhfULAAAAAAAAAAAAAAAA7VV42Gfo0KFJskkQZ6MVK1Zk+fLlGTJkSLv62JiYev311wvtFwAAAAAAAAAAAAAAANqj8LDPiBEjkiQzZsxose+hhx5KktTX1293++vXr8/TTz+dmpqa7LHHHoX1CwAAAAAAAAAAAAAAAO1VeNhn1KhRGTx4cO6555787ne/a97e0NCQq6++Oj179sy4ceOaty9btizz5s3LsmXLNmnnN7/5TZqamjbZtn79+nzrW9/KkiVLMnr06Oy8887b3S8AAAAAAAAAAAAAAAAUrWfhHfbsmcsuuyznnHNOTj/99IwdOza1tbWZPn16Fi9enMmTJ2fvvfduPv7mm2/O1KlTc/7552fSpEnN2y+88MIkybve9a7svvvuWbVqVR599NE8//zz2XPPPfO1r32tXf0CAAAAAAAAAAAAAABA0QoP+yTJYYcdlltuuSVXXXVV7rvvvqxbty7Dhg3LBRdckBNOOGGb2jj11FPzq1/9KrNmzcry5cvTs2fP7LXXXvnsZz+bT33qUxkwYECH9AsAAFCtGhubcvQxf7lC6s/uq8lOO9V08ogAAAAAAAAAAAD4W50S9kmS4cOH5/rrr9/qcZMmTdrkij4bTZw4MRMnTuywfgEAAAAAAAAAAAAAAKBoPTp7AAAAAAAAAAAAAAAAAMBfCPsAAAAAAAAAAAAAAABASQj7AAAAAAAAAAAAAAAAQEkI+wAAAAAAAAAAAAAAAEBJCPsAAAAAAAAAAAAAAABASQj7AAAAAAAAAAAAAAAAQEkI+wAAAAAAAAAAAAAAAEBJCPsAAAAAAAAAAAAAAABASQj7AAAAAAAAAAAAAAAAQEkI+wAAAAAAAAAAAAAAAEBJCPsAAAAAAAAAAAAAAABASQj7AAAAAAAAAAAAAAAAQEkI+wAAAAAAAAAAAAAAAEBJCPsAAAAAAAAAAAAAAABASQj7AAAAAAAAAAAAAAAAQEkI+wAAAAAAAAAAAAAAAEBJCPsAAAAAAAAAAAAAAABASQj7AAAAAAAAAAAAAAAAQEkI+wAAAAAAAAAAAAAAAEBJCPsAAAAAAAAAAAAAAABASQj7AAAAAAAAAAAAAAAAQEkI+wAAAAAAAAAAAAAAAEBJCPsAAAAAAAAAAAAAAABASQj7AAAAAAAAAAAAAAAAQEkI+wAAAAAAAAAAAAAAAEBJCPsAAAAAAAAAAAAAAABASQj7AAAAAAAAAAAAAAAAQEkI+wAAAAAAAAAAAAAAAEBJCPsAAAAAAAAAAAAAAABASQj7AAAAAAAAAAAAAAAAQEkI+wAAAAAAAAAAAAAAAEBJCPsAAAAAAAAAAAAAAABASQj7dLDGxqaMHrMho8dsSGNjU2cPBwAAAAAAAAAAAAAAgBIT9gEAAAAAAAAAAAAAAICSEPYBAAAAAAAAAAAAAACAkhD2AQAAAAAAAAAAAAAAgJIQ9gEAAAAAAAAAAAAAAICSEPYBAAAAAACgajQ2NmX0mA0ZPWZDGhubOns4AAAAAAAAFSfsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJSHsAwAAAAAAAAAAAAAAACUh7AMAAAAAAAAAAAAAAAAlIewDAAAAAAAAAAAAAAAAJdGzszqeO3dupkyZkjlz5mTdunUZNmxYJkyYkOOPP36bbv/YY4/l5z//eWbNmpUlS5Zk9erVGTRoUP7H//gf+cxnPpP+/fu3uM0HPvCBLFmypNX2Pvaxj+XSSy9t130CAAAAAAAAAAAAAACA9uiUsM/MmTNz9tlnp1evXjnuuOPSr1+/TJ8+PRdddFGWLFmSz372s1tt44ILLsjy5cvz7ne/Ox/5yEdSU1OTWbNm5frrr8/06dPzgx/8ILvuumuL2/Xr1y8TJkxosf3AAw+syH0DAACoRo2NTTn6mKYkyc/uq8lOO9V08ogAAAAAAAAAAAC6p8LDPuvXr89XvvKV1NTU5Oabb87++++fJDnvvPNy6qmnZsqUKfnwhz+coUOHbrGdCRMm5MQTT8zAgQObtzU1NeVrX/tabr311kydOjUXX3xxi9v1798/kyZNquh9AgAAAAAAAAAAAAAAgEroUXSHjzzySBYuXJixY8c2B32SpLa2Nueee27Wr1+fadOmbbWdiRMnbhL0SZKampqce+65SZJHH320sgMHAAAAAAAAAAAAAACADlb4lX1mzZqVJBk9enSLfYcffvgmx2yPnj3/cpd22GGHVvevXbs2d999d15++eX0798/hx56aPbbb7/t7g8AAAAAAAAAAAAAAAAqpfCwz/z585MkQ4YMabFvwIABqaury4IFC7a7/bvuuivJm8Ghv7V06dJ86Utf2mTbEUcckW9961vZZZddtrtfAAAAAAAAAAAAAAAAaK/Cwz4NDQ1Jkn79+rW6v7a2Ni+99NJ2tf273/0u//Ef/5Fdd90155xzTov9J510Uurr6zNs2LD07t078+bNy9SpU/Pggw/m3HPPza233pqamprNtr/zznXp23fT/X36NCVZtt37oTV1dXWdPQS6CbVGUdQaRVFr8Ka2rk+sXdhe5l6KotYogjqjKGoN3uS7F4pi7qUoao2iqDWKotbgTdYfFMXcS1HUGkVQZxRFrdEVFR726SiLFi3KZz7zmbzxxhu54oorWr1Kz/nnn7/J7wcffHCuvfbanHHGGXn88cfzwAMPZMyYMZvt49VXl2fNmk0XbI2NTe3aD3+rrq4uy5cv7+xh0A2oNYqi1iiKWqMo1fLhQFvXJ9YubA9zL0VRaxRBnVEUtUZRuuraZVv2w98y91IUtUZR1BpFUWsUpZrXL1Bp5l6KotYogjqjKGqNohS9dulRaG/5y5V7kmTVqlWt7m9oaNjsVX82Z8mSJZkwYUKWLVuWq666Kocddtg237ZHjx456aSTkiSzZ89uU78AAAAAAAAAAAAAAABQSYWHfYYOHZokWbBgQYt9K1asyPLlyzNkyJBtbm/x4sU588wz88orr+TKK6/M+9///jaPaWPCqrGxsc23BQAAAAAAAAAAAAAAgEopPOwzYsSIJMmMGTNa7HvooYeSJPX19dvU1uLFi3PWWWfllVdeyb//+7/nqKOO2q4xzZ07N0kyaNCg7bo9AAAAAAAAAAAA3UtjY1NGj9mQ0WM2pLGxqbOHAwAAdCGFh31GjRqVwYMH55577snvfve75u0NDQ25+uqr07Nnz4wbN655+7JlyzJv3rwsW7Zsk3Y2Bn1efvnlXHHFFTn66KO32O8f//jHrFy5ssX2xx57LDfccEN69+6dD37wg+28dwAAAAAAAAAAAAAAALD9ehbeYc+eueyyy3LOOefk9NNPz9ixY1NbW5vp06dn8eLFmTx5cvbee+/m42+++eZMnTo1559/fiZNmtS8/ayzzsqSJUtyyCGH5JlnnskzzzzToq+/Pv6+++7L9ddfn1GjRmXQoEHp3bt3nn322Tz00EPp0aNHvva1r2XPPffs2DsPAAAAAAAAAAAAAAAAW1B42CdJDjvssNxyyy256qqrct9992XdunUZNmxYLrjggpxwwgnb1MaSJUuSJHPmzMmcOXNaPeavwz4jR47MvHnz8vTTT2fWrFlZu3Ztdt111xx77LH5xCc+keHDh7f7fgEAAAAAAAAAAAAAAEB7dErYJ0mGDx+e66+/fqvHTZo0aZPQzkatXclnS+rr61NfX9+m2wAAAAAAAAAAAAAAAECRenT2AAAAAAAAAAAAAAAAAIC/EPYBAAAAAAAAAAAAAACAkhD2AQAAAAAAAAAAAAAAgJIQ9gEAAAAAAAAAAAAAAICSEPYBAAAAAAAAAAAAAACAkhD2AQAAAAAAAAAAAAAAgJIQ9gEAAAAAAAAAAAAAAICSEPYBAAAAAAAAAAAAAACAkhD2AQAAAAAAAAAAAAAAgJIQ9ulkjY1NGT1mQ0aP2ZDGxqbOHg4AAAAAAAAAAAAAAACdSNgHAAAAAACALsM/WgMAAAAAAKqdsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAAAAAAAAAAAAAACUhLAPAAAAAAAAAAAAAAAAlISwDwAAAAAAAAAAAAAAAJSEsA8AAABb1djYlNFjNmT0mA1pbGzq7OEAAAAAAAAAAAB0WcI+AAAAAAAAAAAAAAAAUBLCPgAAAAAAAAAAAAAAAFASwj4l1tjYlNFjNmT0mA1pbGzq7OEAAAAAAAAAAAAAAADQwYR9AAAAAAAAAAAAAAAAoCSEfQAAAAAAAAAAAAAAAKAkhH0AAAAAAADoFhobmzJ6zIaMHrMhjY1NnT0cAAAAAACAVgn7QBv4EhAAAAAAAAAAAAAAAOhIwj4AAAAAAAAAAAAAAABQEsI+AAAAAAAAAAAAUEGNjU0ZPWZDRo/ZkMbGps4eDgAAUGWEfQAAAAAAAAAAAAAAAKAkhH2qmP/+AAAAAAAAAAAAAAAA0LUI+wAAAAAAAAAAAAAAAEBJCPsAAAAAAABAksbGpowesyGjx2xIY2NTZw8HAAAAAADopoR9AAAAAAAAAADoEMK0AAAAAG0n7AMAAAAAAAAAAAAAAAAlIewDFeQ/EgFsO3MmAAAAAAAAAAAAALQk7AMAAAAAAAAAQKfwD+IAAAAAWhL2AQAAAAAAAACglISBAAAAgO6oZ2cPoJqsbmxM0998btT4epLs2CH729s2lVfEc9KzZ8+sXr261b4/ctJf2v7htNez045tbxv+2uZqjeJ19df3lua1Lb0HduXHhI5hXqMoffr0Sd++fTt7GFtl/UERzL0URa1RBHVGUdQaRemqa5f27rf26Z7MvRRFrVGUaqu1jnxvp2NVW61Rvbrq+sX8xfYw91IUtVY5/s5p89QZRVFrFKXotYuwTxvM++Mf06fPpquuNWtqkhzYIfsr0fYXvviX/Vd868kW+2lpa49Ze5+T9o6to9qma/Harz7d9fXdnvdAgM42ZsyYzh7CVhW9/gDoCG+ub9bmim+Ze4Dy87lMSx6TztUV1y7t3W/tAwAdY0vnfR353g5sXbWsy7ri+sX8BdA9+FtegO6lyLVLj8J6ArJmTU3Ou+CgnHfBQf//CR4UTx1SFLUG0L2Y9wEAAAAAALZdZ3634nsdqF5evwDQfQj7QEm09yTcSTwAAADVxloWAACAarO1tay1bvE85gAAtIfzSQDKStgHAAAAAAA6mC+MAQCgfJynUxZqEQAAgL8l7AMA7eSD1/LxnAAA0JGcbwIAm+M8AQAAKIr1BwC05P0R6EqEfQAAAACoOj6oBzqDuQcwDwB0feb6rsXzSXegzoHOZA4CAOg4wj7QTVhYAV2JOQ0AAKgW1i8AAABAe/hsge2hboCuxrwGQHfUaWGfuXPn5tOf/nRGjBiRQw45JOPHj8+Pf/zjNrWxYcOGfP/738/xxx+f4cOH57DDDssFF1yQ+fPnd2i/XYWTH4DqYL4GeJM5EQAAirel8/CufI7ele8bAEBbOTcCAOj6nPMBQLl0Sthn5syZOf300/PYY4/lQx/6UE477bQsX748F110Ua655pptbufiiy/O17/+9WzYsCFnnHFGjjzyyPzXf/1Xxo8fnz/+8Y8d1i8AtIWFcPfi+YYt8xoB6F6qed6v5rF3FI9J5ZX5MS3z2AAAoL2c7wJFK/O8U+axAdB25nUqRS0BXU01zms9i+5w/fr1+cpXvpKamprcfPPN2X///ZMk5513Xk499dRMmTIlH/7whzN06NAttvPII4/k9ttvz3ve857ccMMN6d27d5LkxBNPzCc/+clccskl+f73v1/xfoHuY82amnzhiwcmSa741pPp06epTfsBAAAAOlJnfnbRnrZ9ptK69j4u1fq4Vuu4YXv4zBkAqo/3ZwCA6uC8DSgb8xKVUPiVfR555JEsXLgwY8eObQ7cJEltbW3OPffcrF+/PtOmTdtqO3fccUeSZPLkyc1BnyQZNWpURo8enUcffTTPP/98xfsFoHsqa6J3a+Nq77i3dPuyPiZQLbyGWteex6W9c6LnBOiqzG8AAF2DdS2VolYAgG3lvIHNURt0Beq47TxmXUs1P5/VPPYt6ci/mQGqU+Fhn1mzZiVJRo8e3WLf4YcfvskxWzJz5sz07ds3hx56aIt9G9t+9NFHK94vQBk4MQMAoLtyLsy2UivF85hXXkc+pp4vALoD73fbx+MG3ZPXPrA9zB1sD3UDQDXzPkZXIFhWPQoP+8yfPz9JMmTIkBb7BgwYkLq6uixYsGCLbaxevTpLly7N2972tuywww4t9g8dOnSTvirVb3fihQjt4zUEXZfXd/XpzOdMvQBAeXmfho5V1tdYNV8Vo8xjA+hM5kcAqlU1r08AgOrVXf+GoqznVmUdFxSpWl8H1TpuqktNU1NTU5EdfupTn8pDDz2U6dOntxq8Oeqoo/LSSy/lySef3GwbL7/8ct73vvfl0EMPza233tpi/2OPPZaPf/zj+djHPpZLL720Iv3+8pe/3MZ72D2sWVOTL3zxwCTJFd96Mn36NFVsf0e2vS37u6POfMzL3HZn6syxlfX57Oy+6T46uha662uorK/f9j7fHVkvZX5M29N3VzFmzJjOHsIWlXH90pF101VfLx35uHTl+70lZb5fnTn3mvcrr6vWWnuV9X6X+THrrjwnlVfNj1lnvge257Zlee+3dmGjMtdstZ6fbG1/mdtuj65cS/ruXn2XVVnOIdh2nfmYd8fXb5nvF62zfqlenVnzXXWeKPMcVa3fQXTkOWE1P5+dqSMf885UrWMr8/loe9purzLPHR2pzHNqe25f5rY7su9qfb62tr9a7neRa5eehfUEQFXo06cp//Gd33b2MACAbqS95x9lPn/Z0tjKPG6gvMwd4HVA5VRrLVXruAGA9nMeAO3jNVQ8jzkAQNfgvK7yPKblUtbno/CwT21tbZJk1apVre5vaGhIv379ttjGxv0NDQ2bbeOv+6pUv3QNZX0xQnfg9QcAdAbnILBlXiNA2ZiXiucxB8rMHAV0J135n+LQtag1oKy68vzUle/b5nTH+wxdhddv9fGcURS11jaFh32GDh2aJFmwYEEOPPDATfatWLEiy5cvz7ve9a4tttG3b9/stttuWbx4cd54443ssMMOm+yfP3/+Jn1Vql8Aui4nEGykFqpPZz5n6gW2ndcLZaAOqRbtqVV1XjyPOQDVwPsVAAAAwPbxuUrxuurfAqkltlU114rvuiur8LDPiBEjcu2112bGjBk57rjjNtn30EMPJUnq6+u32k59fX1+8pOfZPbs2RkxYsQm+2bMmNHcV6X7BboObwqV5zEFqk2Z560yjw0ANvJ+tX3K/AWF5xQomy3NS+YsqByvp+JV62NereMGvH4BgM3rqucJXfV+Ae3TXeeGMn8/CWxe4WGfUaNGZfDgwbnnnnty1lln5e///u+TJA0NDbn66qvTs2fPjBs3rvn4ZcuWZfny5amrq8suu+zSvP2UU07JT37yk1x55ZW54YYb0rt37yTJww8/nBkzZmTEiBHZe++9t7tf6E68kZaP5wS6J699ugJ1DOXh9di1+ENngG1nXgQAwDkhRVFrLVXzY1LNY4dK83pou/Y+ZmV9zDt6XGW9352pmh8TV3MonseN7q6rvv92Jo9JuRQe9unZs2cuu+yynHPOOTn99NMzduzY1NbWZvr06Vm8eHEmT568SUjn5ptvztSpU3P++edn0qRJzdsPO+ywnHzyybnjjjsybty4HHnkkfnzn/+ce++9N7W1tbnkkkva1S/wJhM3AJ3J+xDQkco8x5R5bF2VS7K3rprH3lk8ZgC0l/cSqH5ex5XnMQVga3y+B12D1xtAZZhPAapf4WGf5C9BnVtuuSVXXXVV7rvvvqxbty7Dhg3LBRdckBNOOGGb27n00kuz77775rbbbstNN92Uvn375v3vf38+//nPtxrcqVS/AHQM/90BuievXwAAAIBy29rnN131853OvF9d9fPy7lpLAADQXTnHh67L6xsoWnecdzol7JMkw4cPz/XXX7/V4yZNmrTJFX3+Wo8ePXLmmWfmzDPPrHi/bFl3fLFQTmqxeB5zAACoPOfZAHQk7zMAravW+bFaxw3Q3ZivW+dxAaqZOQwAgCJ1WtgHAAAAoJr4Eg8AAPhr1ggAdFVlvbqd914gMRdQDHUGbA9zR9fi+aQMhH2ALssbLdDVVPO8Vs1jB7q3rc1f1Tq/Veu4ATqDORMAYNs5d6Ioag28DgC2R1nDjGVuu8zKfL/LPDYAql9X/VsWWhL2ATqVNxyKopYoC7VIpfjPdkBH6szzdHMYAFANnLPAtvN6AQAAAACAthP2ocvxpRF0XV7fsGVeIwAAlFlZz1fLOi6guplbAIpn7u1aPJ8AAAAAdHfCPkC7+bAdAAAAAGDb+UwVoHy66pW0q3nsAABFc+7EtlIrAMUx57KtumKtCPtso/r6+ixfvryzh1E1Gl9/8+d3DBuWnXbc9v3tuW1X0L9//6xcubKzh1FRXf05q1ZdsdYoJ7VWHh39/jv93o0HDWv3WLeHWmubLT1f1fB8d6a6urrOHsJWWb9QlM3NvVubR7riHGLd07G8z3cPnX2+qs4oilqjKNYuVIsizqXNvSQdW2vtPV/t7O9ON3eu3JH3a1v2s3nmNbamUq8/tUZRrF/gTebe7qEM58JqjSKoM4qi1ihK0WsXYZ9t1Ldv36xZs6azh1E1amqakjQlSfrutFN22qlmm/dv7bZ9+yYzftn8W+UH38n69euX9evXd/YwKmprzymdoyvWGuWk1sqjPe+/1TCXq7XK6ernW+3Vt2/5HxPrF4qyubm3Gt43Kq073ucieZ/vHjr7fFWdURS1RlGsXagWRZxLm3tJOvYzr41t19XVtfpHwO35/rMzP7vd2mPW3rFZS28/8xpbU6nXn1qjKNYv8CZzb/dQhnNhtUYR1BlFUWsUpei1i7AP0OF22qkmM37pw3mAztae+dhcDgBAR3O+CgDdk/dxugN13jqPCwAAAABsnrAPAAC+VAWAdvJeCgAAAAAAAABApQj7AAAAAAAAAABAF+Ef0wAAAED1E/ahQ/jgCAAAAAAAAACgfPxNBwAAAJSfsA+dwgdHAAAAAGwrnyUBANBdbe1c2LkyAAAAAHRNwj4AAAAAAAAAQJsIGgEAAABAxxH2oXR8KAwAAFDdrOsAAAAAnw8AAEDrnCsDANuiR2cPAAAAAAAAAAAAAAAAAPgLYR8AAAAAAAAAAAAAAAAoCWEfAAAAAAAAAAAAAAAAKAlhHwAAAAAAAAAAAAAAACgJYR8AAAAAAAAAAAAAAAAoCWEfAAAAAAAAAAAAAAAAKAlhHwAAAAAAAAAAAAAAACgJYR8AAAAAAAAAAAAAAAAoCWEfAAAAAAAAAAAAAAAAKAlhHwAAAAAAAAAAAAAAACgJYR8AAAAAAAAAAAAAAAAoCWEfAAAAAAAAAAAAAAAAKAlhHwAAAAAAAAAAAAAAACgJYR8AAAAAAAAAAAAA/r/27j3K67rOH/iT4XbEQXcQMUFgUsHyijemDM+2RBcRNQRstQ625kKWdjatUDfXk5m15hqGFuqWt46uonJk81pni7wnKpIXpFQGFBNMQQYIUL6/P/oxODFcZpj5zAd9PM7pxHw+7+/n/fl6Xt+vPPE8+QAAUBLKPgAAAAAAAAAAAAAAAFASyj4AAAAAAAAAAAAAAABQEso+AAAAAAAAAAAAAAAAUBLKPgAAAAAAAAAAAAAAAFASyj4AAAAAAAAAAAAAAABQEso+AAAAAAAAAAAAAAAAUBLKPgAAAAAAAAAAAAAAAFASyj4AAAAAAAAAAAAAAABQEso+AAAAAAAAAAAAAAAAUBLKPgAAAAAAAAAAAAAAAFASyj4AAAAAAAAAAAAAAABQEso+AAAAAAAAAAAAAAAAUBLKPgAAAAAAAAAAAAAAAFASyj4AAAAAAAAAAAAAAABQEso+AAAAAAAAAAAAAAAAUBLKPgAAAAAAAAAAAAAAAFASXYrecMmSJZk8eXJmzpyZZcuWpW/fvjnmmGMyYcKEdOvWbauuMX/+/Nxzzz25//77U19fn6VLl2aXXXZJXV1dJk6cmL322muj15x99tmZPn16s9f74Ac/mHvuuWeb3hcAAAAAAAAAAAAAAABsq0LLPkuWLMkJJ5yQV199NSNGjEhtbW0ef/zxTJkyJbNnz85VV12VqqotP2zosssuy1133ZXBgwfnE5/4RKqrqzNv3rzccccduffee/Ozn/0shx12WLOvHT9+fHbaaacmx2pqatrk/QEAAAAAAAAAAAAAAMC2KLTsc8kll2TRokU5//zzc9JJJyVJKpVKzjnnnEyfPj3Tp0/PmDFjtnidI488MhMnTsyHPvShJsfvvPPOnHnmmTn//PNz5513Nvvak08+OXvssce2vxkAAAAAAAAAAAAAAABoY1t+jE4baWhoyF133ZX+/fvnxBNPbDzeqVOnnHnmmamqqsq0adO26lrHH3/8RkWfJDn66KNTW1ubP/3pT3njjTfa7N4BAAAAAAAAAAAAAACgCIU92Wf27NlZs2ZNjjjiiHTq1KnJuT59+mTw4MF56qmnsnr16nTv3r3V+3Tt2jVJ0qVL829t5syZWbFiRbp165Z99tknQ4cOTefOnVu9HwAAAAAAAAAAAAAAALSVwso+9fX1SZLa2tpmzw8cODBz587NwoULs/fee7dqjzlz5uSPf/xjDjjggOy0007Nrrngggua/FxbW5tLL700++23X6v2BAAAAAAAAAAAAAAAgLZSWNln+fLlSZKePXs2e766urrJutZcf9KkSamqqso3v/nNjc4ffvjhGT58eA488MDU1NTk5Zdfzs0335xf/OIXOeWUUzJjxozstttum92jpqamVfcGLWXWKIpZoyhmjaKYNdjA54GimDWKYtYogjmjKGYNNvB5oChmjaKYNYpi1iiKWYMNfB4oilmjKGaNIpgzimLWeC9qcdmnrq4uS5cu3er1119/ferq6lq6TYusXr06p59+el588cV8/etfb3a/MWPGNPl5r732yrnnnpsddtghU6dOzbXXXptJkyZtdp8333yzTe8bmlNTU2PWKIRZoyhmjaKYNYqyvfzhgM8DRfDdS1HMGkUwZxTFrFEU2QU28N1LUcwaRTFrFMWsURT5BTbw3UtRzBpFMGcUxaxRlKKzS4vLPqNGjcqKFSu2en3v3r2TbHiiz6ae3NPQ0NBk3dZas2ZNvvrVr+aRRx7JxIkT8+Uvf7lFrx87dmymTp2aJ598skWvAwAAAAAAAAAAAAAAgLbW4rLPeeed16qNBg4cmCSZP39+s+fr6+tTVVWV/v37b/U1V69ena985St54IEHcuqpp+bMM89s8X2tb1etWrWqxa8FAAAAAAAAAAAAAACAtlRV1EZDhgxJt27d8tBDD6VSqTQ5t3jx4sybNy8HHXRQunfvvlXXe3fR55RTTsk3v/nNVt3XU089lSTp169fq14PAAAAAAAAAAAAAAAAbaWwsk91dXVGjhyZhQsX5qabbmo8XqlUcumll2bdunUZN25ck9esWrUqL7zwQhYtWtTk+LuLPv/yL/+SSZMmbXbvJUuWZMGCBRsdf+2113LhhRcmSUaNGtXatwYAAAAAAAAAAAAAAABtokuRm5111ll59NFHc8EFF+Thhx9ObW1tZs2alSeeeCLDhg3L6NGjm6yfM2dOxo8fn6FDh+aGG25oPH7++efngQceyK677podd9wxU6ZM2Wiv0aNHZ4899kiSvPjiizn55JNz6KGHZs8998zOO++cV155Jb/97W+zcuXKjB49OkcddVT7vnkAAAAAAAAAAAAAAADYgkLLPn369Mktt9ySyZMnZ+bMmfnNb36Tvn375owzzsiECRNSVbV1Dxp65ZVXkvztiT2XX355s2uGDh3aWPYZMGBAxo4dmzlz5uTee+/NihUrUl1dnYMPPjhjx47NyJEj2+YNAgAAAAAAAAAAAAAAwDYotOyT/K3wc9FFF23V2rq6ujz//PMbHX/3U362xu67754LL7ywRa8BAAAAAAAAAAAAAACAom3do3QAAAAAAAAAAAAAAACAdqfsAwAAAAAAAAAAAAAAACWh7AMAAAAAAAAAAAAAAAAloewDAAAAAAAAAAAAAAAAJaHsAwAAAAAAAAAAAAAAACWh7AMAAAAAAAAAAAAAAAAloewDAAAAAAAAAAAAAAAAJaHsAwAAAAAAAAAAAAAAACWh7AMAAAAAAAAAAAAAAAAloewDAAAAAAAAAAAAAAAAJaHsAwAAAAAAAAAAAAAAACWh7AMAAAAAAAAAAAAAAAAloewDAAAAAAAAAAAAAAAAJaHsAwAAAAAAAAAAAAAAACWh7AMAAAAAAAAAAAAAAAAloewDAAAAAAAAAAAAAAAAJaHsAwAAAAAAAAAAAAAAACWh7AMAAAAAAAAAAAAAAAAloewDAAAAAAAAAAAAAAAAJaHsAwAAAAAAAAAAAAAAACWh7AMAAAAAAAAAAAAAAAAloewDAAAAAAAAAAAAAAAAJaHsAwAAAAAAAAAAAAAAACWh7AMAAAAAAAAAAAAAAAAloewDAAAAAAAAAAAAAAAAJaHsAwAAAAAAAAAAAAAAACWh7AMAAAAAAAAAAAAAAAAloewDAAAAAAAAAAAAAAAAJaHsAwAAAAAAAAAAAAAAACWh7AMAAAAAAAAAAAAAAAAloewDAAAAAAAAAAAAAAAAJaHsAwAAAAAAAAAAAAAAACWh7AMAAAAAAAAAAAAAAAAloewDAAAAAAAAAAAAAAAAJaHsAwAAAAAAAAAAAAAAACWh7AMAAAAAAAAAAAAAAAAloewDAAAAAAAAAAAAAAAAJaHsAwAAAAAAAAAAAAAAACWh7AMAAAAAAAAAAAAAAAAloewDAAAAAAAAAAAAAAAAJaHsAwAAAAAAAAAAAAAAACWh7AMAAAAAAAAAAAAAAAAloewDAAAAAAAAAAAAAAAAJaHsAwAAAAAAAAAAAAAAACXRpegNlyxZksmTJ2fmzJlZtmxZ+vbtm2OOOSYTJkxIt27dtvo6++yzzybPnXXWWZkwYUK77Q0AAAAAAAAAAAAAAADtodCyz5IlS3LCCSfk1VdfzYgRI1JbW5vHH388U6ZMyezZs3PVVVelqmrrHzbUr1+/jB49eqPjhxxySLvvDQAAAAAAAAAAAAAAAG2t0LLPJZdckkWLFuX888/PSSedlCSpVCo555xzMn369EyfPj1jxozZ6uv169cvZ5xxRofsDQAAAAAAAAAAAAAAAG2tsEfZNDQ05K677kr//v1z4oknNh7v1KlTzjzzzFRVVWXatGnvub0BAAAAAAAAAAAAAABgaxX2ZJ/Zs2dnzZo1OeKII9KpU6cm5/r06ZPBgwfnqaeeyurVq9O9e/etuuZbb72VadOm5S9/+Ut69eqVoUOHpra2tpC9AQAAAAAAAAAAAAAAoK0VVvapr69PkmbLOEkycODAzJ07NwsXLszee++9VdecO3duvv3tbzf+3KlTpxxzzDG54IILssMOO7Tr3gAAAAAAAAAAAAAAANDWCiv7LF++PEnSs2fPZs9XV1c3Wbclp5xySo466qgMHDgwnTp1yrPPPpsf/ehHmTFjRt55551ceumlbb53TU3NVt0bbCuzRlHMGkUxaxTFrMEGPg8UxaxRFLNGEcwZRTFrsIHPA0UxaxTFrFEUs0ZRzBps4PNAUcwaRTFrFMGcURSzxntRi8s+dXV1Wbp06Vavv/7661NXV9fSbbZo0qRJTX7+yEc+kmuvvTbHHXdc7rzzzpx22mkZNGhQm+755ptvtun1oDk1NTVmjUKYNYpi1iiKWaMo28sfDvg8UATfvRTFrFEEc0ZRzBpFkV1gA9+9FMWsURSzRlHMGkWRX2AD370UxaxRBHNGUcwaRSk6u7S47DNq1KisWLFiq9f37t07yYan6mzq6TkNDQ1N1rXGDjvskKOPPjo/+clP8sQTTzSWfYrYGwAAAAAAAAAAAAAAALZVi8s+5513Xqs2GjhwYJJk/vz5zZ6vr69PVVVV+vfv36rrr7e+LbVq1arC9wYAAAAAAAAAAAAAAIBtUVXURkOGDEm3bt3y0EMPpVKpNDm3ePHizJs3LwcddFC6d+++Tfs89dRTSZI99tij8L0BAAAAAAAAAAAAAABgWxRW9qmurs7IkSOzcOHC3HTTTY3HK5VKLr300qxbty7jxo1r8ppVq1blhRdeyKJFi5ocf/bZZ5s8uWe9u+++O3feeWdqamry0Y9+dJv2BgAAAAAAAAAAAAAAgKJ1KXKzs846K48++mguuOCCPPzww6mtrc2sWbPyxBNPZNiwYRk9enST9XPmzMn48eMzdOjQ3HDDDY3Hr7/++vz617/ORz/60ey+++6pVCp59tlnM2vWrHTv3j3/+Z//mR133HGb9gYAAAAAAAAAAAAAAICiFVr26dOnT2655ZZMnjw5M2fOzG9+85v07ds3Z5xxRiZMmJCqqq170NAnPvGJvPXWW3nmmWdy//335+23385uu+2WsWPH5pRTTslee+3VbnsDAAAAAAAAAAAAAABAeym07JP8rXRz0UUXbdXaurq6PP/88xsd/+QnP5lPfvKT7bo3AAAAAAAAAAAAAAAAFM3jbAAAAAAAAAAAAAAAAKAklH0AAAAAAAAAAAAAAACgJJR9AAAAAAAAAAAAAAAAoCSUfQAAAAAAAAAAAAAAAKAklH0AAAAAAAAAAAAAAACgJJR9AAAAAAAAAAAAAAAAoCSUfQAAAAAAAAAAAAAAAKAklH0AAAAAAAAAAAAAAACgJJR9AAAAAAAAAAAAAAAAoCSUfQAAAAAAAAAAAAAAAKAklH0AAAAAAAAAAAAAAACgJJR9AAAAAAAAAAAAAAAAoCSUfQAAAAAAAAAAAAAAAKAklH0AAAAAAAAAAAAAAACgJJR9AAAAAAAAAAAAAAAAoCSUfQAAAAAAAAAAAAAAAKAklH0AAAAAAAAAAAAAAACgJJR9AAAAAAAAAAAAAAAAoCSUfQAAAAAAAAAAAAAAAKAklH0AAAAAAAAAAAAAAACgJJR9AAAAAAAAAAAAAAAAoCSUfQAAAAAAAAAAAAAAAKAklH0AAAAAAAAAAAAAAACgJJR9AAAAAAAAAAAAAAAAoCSUfQAAAAAAAAAAAAAAAKAklH0AAAAAAAAAAAAAAACgJJR9AAAAAAAAAAAAAAAAoCSUfQAAAAAAAAAAAAAAAKAklH0AAAAAAAAAAAAAAACgJJR9AAAAAAAAAAAAAAAAoCSUfQAAAAAAAAAAAAAAAKAklH0AAAAAAAAAAAAAAACgJJR9AAAAAAAAAAAAAAAAoCSUfQAAAAAAAAAAAAAAAKAklH0AAAAAAAAAAAAAAACgJJR9AAAAAAAAAAAAAAAAoCSUfQAAAAAAAAAAAAAAAKAklH0AAAAAAAAAAAAAAACgJJR9AAAAAAAAAAAAAAAAoCSUfQAAAAAAAAAAAAAAAKAklH0AAAAAAAAAAAAAAACgJJR9AAAAAAAAAAAAAAAAoCSUfQAAAAAAAAAAAAAAAKAklH0AAAAAAAAAAAAAAACgJLoUveGSJUsyefLkzJw5M8uWLUvfvn1zzDHHZMKECenWrdtWXWPKlCm5/PLLN7tmzJgxueiiixp/PvvsszN9+vRm137wgx/MPffcs/VvAgAAAAAAAAAAAAAAANpBoWWfJUuW5IQTTsirr76aESNGpLa2No8//nimTJmS2bNn56qrrkpV1ZYfNjR06NCcfvrpzZ6bNm1aXnvttQwbNqzZ8+PHj89OO+3U5FhNTU3L3wwAAAAAAAAAAAAAAAC0sULLPpdcckkWLVqU888/PyeddFKSpFKp5Jxzzsn06dMzffr0jBkzZovXqaurS11d3UbHX3/99UydOjX/8A//kBEjRjT72pNPPjl77LHHtr0RAAAAAAAAAAAAAAAAaAdbfoxOG2loaMhdd92V/v3758QTT2w83qlTp5x55pmpqqrKtGnTtmmP22+/PW+//XaOO+64dOvWbVtvGQAAAAAAAAAAAAAAAApV2JN9Zs+enTVr1uSII45Ip06dmpzr06dPBg8enKeeeiqrV69O9+7dW7XHbbfdliQZN27cJtfMnDkzK1asSLdu3bLPPvtk6NCh6dy5c6v2AwAAAAAAAAAAAAAAgLZUWNmnvr4+SVJbW9vs+YEDB2bu3LlZuHBh9t577xZff9asWZk/f36GDBmSQYMGbXLdBRdc0OTn2traXHrppdlvv/1avCcAAAAAAAAAAAAAAAC0pcLKPsuXL0+S9OzZs9nz1dXVTda11K233pokGTt2bLPnDz/88AwfPjwHHnhgampq8vLLL+fmm2/OL37xi5xyyimZMWNGdtttt83uUVNT06p7g5YyaxTFrFEUs0ZRzBps4PNAUcwaRTFrFMGcURSzBhv4PFAUs0ZRzBpFMWsUxazBBj4PFMWsURSzRhHMGUUxa7wXtbjsU1dXl6VLl271+uuvvz51dXUt3aZFGhoacs8996RHjx4ZOXJks2vGjBnT5Oe99tor5557bnbYYYdMnTo11157bSZNmrTZfd588802u2fYlJqaGrNGIcwaRTFrFMWsUZTt5Q8HfB4ogu9eimLWKII5oyhmjaLILrCB716KYtYoilmjKGaNosgvsIHvXopi1iiCOaMoZo2iFJ1dWlz2GTVqVFasWLHV63v37p1kwxN9NvXknoaGhibrWuKXv/xlVq1albFjx2bHHXds0WvHjh2bqVOn5sknn2zxvgAAAAAAAAAAAAAAANCWWlz2Oe+881q10cCBA5Mk8+fPb/Z8fX19qqqq0r9//xZf+9Zbb02SjBs3rsWvXd+uWrVqVYtfCwAAAAAAAAAAAAAAAG2pqqiNhgwZkm7duuWhhx5KpVJpcm7x4sWZN29eDjrooHTv3r1F133++efzhz/8IYMGDcqQIUNafF9PPfVUkqRfv34tfi0AAAAAAAAAAAAAAAC0pcLKPtXV1Rk5cmQWLlyYm266qfF4pVLJpZdemnXr1m30ZJ5Vq1blhRdeyKJFizZ53fVP9Rk7duwm1yxZsiQLFizY6Phrr72WCy+8MEkyatSoFr0fAAAAAAAAAAAAAAAAaGtditzsrLPOyqOPPpoLLrggDz/8cGprazNr1qw88cQTGTZsWEaPHt1k/Zw5czJ+/PgMHTo0N9xww0bXW7NmTWbMmJGuXbvm2GOP3eS+L774Yk4++eQceuih2XPPPbPzzjvnlVdeyW9/+9usXLkyo0ePzlFHHdXm7xcAAAAAAAAAAAAAAABaotCyT58+fXLLLbdk8uTJmTlzZn7zm9+kb9++OeOMMzJhwoRUVbXsQUO//vWvs3Tp0hx11FHp1avXJtcNGDAgY8eOzZw5c3LvvfdmxYoVqa6uzsEHH5yxY8dm5MiR2/rWAAAAAAAAAAAAAAAAYJsVWvZJ/lb4ueiii7ZqbV1dXZ5//vlNnh85cuRWFXV23333XHjhhVt9jwAAAAAAAAAAAAAAANARWvYoHQAAAAAAAAAAAAAAAKDdKPsAAAAAAAAAAAAAAABASSj7AAAAAAAAAAAAAAAAQEko+wAAAAAAAAAAAAAAAEBJKPsAAAAAAAAAAAAAAABASSj7AAAAAAAAAAAAAAAAQEko+wAAAAAAAAAAAAAAAEBJKPsAAAAAAAAAAAAAAABASSj7AAAAAAAAAAAAAAAAQEko+wAAAAAAAAAAAAAAAEBJKPsAAAAAAAAAAAAAAABASSj7AAAAAAAAAAAAAAAAQEko+wAAAAAAAAAAAAAAAEBJKPsAAAAAAAAAAAAAAABASSj7AAAAAAAAAAAAAAAAQEko+wAAAAAAAAAAAAAAAEBJKPsAAAAAAAAAAAAAAABASSj7AAAAAAAAAAAAAAAAQEko+wAAAAAAAAAAAAAAAEBJKPsAAAAAAAAAAAAAAABASSj7AAAAAAAAAAAAAAAAQEko+wAAAAAAAAAAAAAAAEBJKPsAAAAAAAAAAAAAAABASSj7AAAAAAAAAAAAAAAAQEko+wAAAAAAAAAAAAAAAEBJKPsAAAAAAAAAAAAAAABASSj7AAAAAAAAAAAAAAAAQEko+wAAAAAAAAAAAAAAAEBJKPsAAAAAAAAAAAAAAABASSj7AAAAAAAAAAAAAAAAQEko+wAAAAAAAAAAAAAAAEBJKPsAAAAAAAAAAAAAAABASSj7AAAAAAAAAAAAAAAAQEko+wAAAAAAAAAAAAAAAEBJKPsAAAAAAAAAAAAAAABASSj7AAAAAAAAAAAAAAAAQEko+wAAAAAAAAAAAAAAAEBJKPsAAAAAAAAAAAAAAABASSj7AAAAAAAAAAAAAAAAQEko+wAAAAAAAAAAAAAAAEBJKPsAAAAAAAAAAAAAAABASSj7AAAAAAAAAAAAAAAAQEko+wAAAAAAAAAAAAAAAEBJKPsAAAAAAAAAAAAAAABASXQpcrPHHnss//d//5enn346zz77bBoaGjJ69Oj84Ac/aNX17r///lx11VV55plnUqlUsv/++2fChAk58sgjm12/ZMmSTJ48OTNnzsyyZcvSt2/fHHPMMZkwYUK6deu2LW8NAAAAAAAAAAAAAAAAtlmhT/a57bbb8vOf/zx/+MMf0qdPn2261owZM3Lqqafmj3/8Y0aPHp0xY8bkxRdfzKmnnpoZM2ZstH7JkiU54YQTctttt2XIkCE5+eST06tXr0yZMiVf+cpXsm7dum26HwAAAAAAAAAAAAAAANhWhT7Z5/Of/3y+9KUvZc8998wf/vCHfO5zn2vVdZYtW5bvfve7qampyfTp07P77rsnSSZMmJDjjz8+3/3ud/OP//iP2XnnnRtfc8kll2TRokU5//zzc9JJJyVJKpVKzjnnnEyfPj3Tp0/PmDFjtv1NAgAAAAAAAAAAAAAAQCsV+mSfAw44IIMGDUrnzp236Tr33HNP3nrrrXzhC19oLPokSZ8+fTJ+/Pi89dZbueeeexqPNzQ05K677kr//v1z4oknNh7v1KlTzjzzzFRVVWXatGnbdE8AAAAAAAAAAAAAAACwrQot+7SV3//+90mSYcOGbXTuyCOPbLImSWbPnp01a9bkiCOOSKdOnZqs79OnTwYPHpynnnoqq1evbse7BgAAAAAAAAAAAAAAgM3bLss+8+fPT5IMHDhwo3Prj9XX1zceW//r2traZq83cODArFu3LgsXLmzbGwUAAAAAAAAAAAAAAIAW6NLRN9AaDQ0NSZKePXtudK5Hjx7p3Llzli9f3nhs/a+bW58k1dXVTdZtSk1NTavuF1rKrFEUs0ZRzBpFMWuwgc8DRTFrFMWsUQRzRlHMGmzg80BRzBpFMWsUxaxRFLMGG/g8UBSzRlHMGkUwZxTFrPFe1OKyT11dXZYuXbrV66+//vrU1dW1dBsAAAAAAAAAAAAAAAB432lx2WfUqFFZsWLFVq/v3bt3S7fYonc/iefvW3grV67MO++80+QpPut/vakn92zuSUEAAAAAAAAAAAAAAABQlBaXfc4777z2uI8Wqa2tzdNPP536+vqNyj719fVJkoEDBzYeW//r+fPnN3u9+vr6VFVVpX///u1zwwAAAAAAAAAAAAAAALAVqjr6Blrj8MMPT5I88MADG527//77kyRDhw5tPDZkyJB069YtDz30UCqVSpP1ixcvzrx583LQQQele/fu7XjXAAAAAAAAAAAAAAAAsHmlLvusWrUqL7zwQhYtWtTk+FFHHZWePXvmF7/4RV599dXG44sXL87111+fnXbaKZ/5zGcaj1dXV2fkyJFZuHBhbrrppsbjlUoll156adatW5dx48a1/xsCAAAAAAAAAAAAAACAzehU+ftH3bSjWbNm5dZbb02SvPHGG5k5c2YGDBiQQw89NEmy5557ZsKECY3rH3300YwfPz5Dhw7NDTfc0ORad9xxR771rW+lpqYmRx99dDp16pS77747r7/+ei6++OIcd9xxTdYvXrw4J5xwQv785z/nk5/8ZGprazNr1qw88cQTGTZsWK6++upUVW3cfZozZ06mTJmS2bNnZ+3atdl7771z8skn55hjjmnrfzy8h7322mu5++6787vf/S4vvvhiXn/99ey888455JBDcuqpp+aggw7a6DUNDQ2ZMmVK7rvvvixZsiS77rprPvWpT+WMM85IdXV1B7wLtldXX311LrnkkiTJzTffnCFDhmy0xryxLX71q1/lxhtvzLPPPptVq1ald+/eGTJkSL75zW9m9913b1xnzmitSqWSX/3qV7nhhhvy0ksvZfny5fnABz6Qurq6/Ou//mv69+/fZL1ZY3PuuOOOPP7443n66aczb968rF27Nt///vdz/PHHN7u+NfP0v//7v7nuuuvypz/9KV27ds2QIUPyta99LQcccEB7vjXZhTYjv9BRZBfam+xCe5NdaGvyC2ye7EJHkl9ob/IL7U1+oS3JLrBl8gsdRXahvckutDfZhba2veWXQss+t99+e84555xNnv/7Us/myj5J8rvf/S5XXXVVnnnmmSTJfvvtl4kTJ+bII49s9vqLFy/O5MmTM3PmzCxbtix9+/bNsccemwkTJqRbt24brX/00UfzpS99KV27ds3RRx+dnj175r777svLL7+cr3/96/nyl7/c0n8EvE9dcsklufrqqzNgwIAcfvjh2WWXXVJfX59f//rXqVQq+a//+q+MHDmycf3KlStz0kkn5bnnnsvHPvax7Lvvvpk7d27uv//+fPjDH86NN96YHj16dOA7Ynvxwgsv5LOf/Wy6dOmSlStXNhvazButValUcv755+fmm2/OgAEDMmzYsOy4445ZvHhxHnvssfzwhz/MYYcdlsScsW1+8IMf5Jprrsmuu+6aT3ziE6murs7cuXPz4IMPpkePHvmf//mfDB48OIlZY8uGDx+eV155JTU1NenRo0deeeWVTQa21szT1KlT86Mf/Sh9+/bNpz/96axcuTJ33nlnVq9enZ/97Gepq6trl/clu9CW5Bc6guxCe5JdKIrsQluTX2DzZBc6ivxCe5JfKIr8QluSXWDL5Bc6guxCe5JdKIrsQlvb7vJLhWatXbu2MmLEiMr+++9feeaZZxqPL1++vHL00UdX9t1338pLL73UcTfIduXee++tPPbYYxsdf+yxxyr77bdfZejQoZXVq1c3Hr/ssssqgwcPrlx88cVN1q8/ftlll7X7PbP9e/vttytjxoypjB07tvKNb3yjMnjw4MqTTz650TrzRmtdd911lcGDB1e+853vVN5+++2Nzq9du7bx1+aM1lq8eHHlQx/6UOWf/umfKsuXL29y7pprrqkMHjy4cvbZZzceM2tsyYMPPlh5+eWXK5VKpXLllVdWBg8eXLntttuaXdvSeXrppZcq++67b+VTn/pU5a233mo8Pm/evMpBBx1UGTFiRJPvxrYiu9DW5BeKJrvQ3mQXiiC70B7kF9g82YWOIL/Q3uQXiiC/0NZkF9gy+YWiyS60N9mFIsgutIftLb9UbUuz6b3skUceyYIFCzJq1Kjsu+++jcerq6vzla98JW+//XZuv/32DrxDtief+tSnGlvK73bYYYelrq4uS5cuzfPPP5/kb43nadOmpUePHvnqV7/aZP3EiROz884759Zbb02luIdysZ26+uqrM3fu3Fx00UXp3Llzs2vMG63117/+NVdccUX69++fc889t9kZ69KlSxJzxrZ55ZVXsm7duhxyyCEbPfby4x//eJLkjTfeSGLW2DpHHHFE+vXrt8V1rZmn22+/PW+//XZOO+209OzZs/H4oEGDctxxx2XBggV55JFH2u7N/H+yC21NfqFosgvtSXahKLIL7UF+gc2TXegI8gvtSX6hKPILbU12gS2TXyia7EJ7kl0oiuxCe9je8ouyzyb8/ve/T5IMGzZso3Mf+9jHmqyBbbH+NzXr/3/+/PlZvHhxDjnkkI0e7dW9e/ccdthhee2111JfX1/4vbL9mDdvXi6//PKcdtppGTRo0CbXmTda68EHH8zSpUszYsSIrFu3Lvfdd1+uuuqq3HTTTRvNizljWwwcODBdu3bNE088kYaGhibnZs6cmST5yEc+ksSs0bZaM0/r88H6vPBuRx55ZJLksccea/N7lV0okvxCW5NdaG+yC0WRXehI8gtsTHahPcgvtDf5haLIL3QU2QWaJ7/Q1mQX2pvsQlFkFzpSWfJLl5be+PvF/Pnzk/zti+Lv7bzzzqmpqfGBZ5stWrQoDz30UHbdddcMHjw4SRrnqra2ttnXrJ/J+vr6Ta7h/e3tt9/O2Wefnb322isTJkzY7FrzRms9/fTTSZLOnTvn2GOPzUsvvdR4rqqqKl/84hczadKkJOaMbVNTU5Ovf/3rufjiizNy5MgMHz48O+64Y+bNm5eHH344n/vc5/KFL3whiVmjbbVmnubPn58ePXpk11133eT69TmjLckuFEV+oa3JLhRBdqEosgsdSX6BpmQX2oP8QhHkF4oiv9BRZBfYmPxCW5NdKILsQlFkFzpSWfKLss8mrG8AvvsRSu9WXV2dP//5z0XeEu8xa9euzbe+9a2sWbMm3/jGNxofZbh8+fIk2eiRc+utP75+Hfy9qVOn5vnnn88tt9ySrl27bnateaO1/vKXvyRJrrnmmuy7776ZNm1a9tprrzz33HM577zz8vOf/zz9+/fPSSedZM7YZl/60pfSp0+f/Md//EduuummxuMHH3xwjj322MbvOrNGW2rNPDU0NKRXr16bXf/3f9NIW5BdKIL8QnuQXSiC7EKRZBc6ivwCG8gutBf5hSLILxRJfqEjyC7QlPxCe5BdKILsQpFkFzpKWfJLVYtWA21i3bp1Offcc/PYY4/lhBNOyGc/+9mOviXeI+bOnZupU6fmlFNOyX777dfRt8N7WKVSSZJ07do1V1xxRQ488MDsuOOOOeyww/LjH/84VVVVueaaazr4Lnmv+MlPfpJzzjknEydOzMyZM/Pkk0/mxhtvzDvvvJPx48fnvvvu6+hbBHhPk19oD7ILRZFdKJLsAtCxZBfai/xCUeQXiiS/AHQs+YX2ILtQFNmFIskuvN8p+2zClhp8DQ0Nm/zbG2BzKpVKvv3tb2fGjBk59thj853vfKfJ+fVztanm3pb+9hDe3yZNmpT+/fvnjDPO2Kr15o3WWv/vyf333z+77bZbk3ODBg1K//79s2DBgrz11lvmjG3y8MMP57LLLsvnP//5fPnLX84HPvCB9OjRI4ceemiuvPLKdO/ePd///veT+E6jbbVmnqqrqzebH9avaWuyC+1JfqG9yC4URXahKLILHUl+AdmF9iW/UBT5haLIL3QU2QX+Rn6hvcguFEV2oSiyCx2pLPmlS4tWv4/U1tYmSerr67P//vs3Obds2bK8+eabOfjggzvgztierVu3Lv/+7/+e22+/PaNGjcoPfvCDVFU17dwNHDgwSTJ//vxmr1FfX99kHbzb3LlzkyQHHHBAs+c/97nPJUmuuOKKjBgxwrzRanvuuWeSTf/md/3xv/71r+aMbTJz5swkSV1d3UbnevXqlX322SdPPvlk3njjDbNGm2rNPNXW1ubJJ5/MkiVLsuuuuza7fn3OaEuyC+1FfqE9yS4URXahKLILHUl+4f1OdqG9yS8URX6hKPILHUV2AfmF9iW7UBTZhaLILnSksuQXZZ9NOPzww3PllVfmgQceyNFHH93k3IMPPpgkGTp0aEfcGtupd4e1kSNH5uKLL07nzp03WldbW5s+ffrkiSeeyMqVK9OjR4/Gc6tXr86sWbPSp08f/8KhWWPHjm32+KxZszJ//vwMHz48vXr1Sr9+/ZKYN1pv/W+gX3zxxY3OrV27NgsWLEiPHj3Sq1ev7LrrruaMVlu7dm2S5I033mj2/Prj3bp1851Gm2rNPB1++OF58skn8+CDD+azn/1sk+vdf//9jWvamuxCe5BfaG+yC0WRXSiK7EJHkl94P5NdKIL8QlHkF4oiv9BRZBfe7+QX2pvsQlFkF4oiu9CRypJfqra85P3pox/9aPr3759f/vKXee655xqPNzQ05Cc/+Um6dOmS0aNHd+Adsj15d1j7zGc+kx/+8IfNhrUk6dSpU8aNG5eVK1fmiiuuaHLuyiuvzLJlyzJu3Lh06tSpiFtnO/O9732v2f+t/xtlJk6cmO9973v58Ic/nMS80XoDBgzIsGHDUl9fn2nTpjU5d9VVV+Wtt97KiBEj0qVLF3PGNjnkkEOSJNdee+1Gj7icPn166uvrs99++6W6utqs0aZaM0/HH398unTpkp/+9KdN5vWPf/xj7rjjjgwYMCAf+chH2vxeZRfamvxCEWQXiiK7UBTZhY4kv/B+JbtQFPmFosgvFEV+oaPILryfyS8UQXahKLILRZFd6EhlyS+dKpVKZdveynvXI488klNPPTVdu3bNqFGjUl1dnfvuuy8vv/xy/u3f/i2nnXZaR98i24kpU6bk8ssvT48ePTJ+/Ph06bLxQ7VGjBjR+BvplStX5qSTTspzzz2Xj33sY9lvv/0yd+7c/O53v8uHP/zh3HjjjU0agrAlZ599dqZPn56bb745Q4YMaXLOvNFaCxYsyD//8z/nL3/5Sz7+8Y9nzz33zLPPPptHHnkk/fr1y80339z4KEJzRmu98847+eIXv5jf//736dWrV4YPH56ddtopzz//fB588MF069Yt11xzTQ477LAkZo0tmzZtWh5//PEkybx58/LMM8/kkEMOafxbFkaMGJERI0Ykad08/fSnP83kyZPTt2/ffPrTn87KlStz5513ZvXq1fnv//7vdvkPTonsQtuSX+hIsgvtQXahCLIL7UF+gc2TXeho8gvtQX6hCPILbU12gS2TX+hIsgvtQXahCLIL7WF7yy/KPlswZ86c/PjHP87s2bOzdu3a7L333jn55JNz7LHHdvStsR1Z/xvmzfn+97+f448/vvHn5cuX5/LLL8+9996b119/Pb17986nP/3pnH766enZs2d73zLvMZsLbYl5o/VeffXV/PjHP87999+fpUuXpnfv3hk+fHi++tWvZpdddmmy1pzRWmvWrMl1112Xu+++Oy+++GLWrl2bXXbZJYcffngmTpyYwYMHN1lv1ticLf2+7PTTT88ZZ5zR+HNr5mnGjBm57rrr8qc//Sldu3bNkCFD8rWvfS0HHnhgm7+fd5NdaCvyCx1JdqG9yC4UQXahrckvsHmyCx1NfqG9yC8UQX6hLckusGXyCx1JdqG9yC4UQXahrW1v+UXZBwAAAAAAAAAAAAAAAEqiqqNvAAAAAAAAAAAAAAAAAPgbZR8AAAAAAAAAAAAAAAAoCWUfAAAAAAAAAAAAAAAAKAllHwAAAAAAAAAAAAAAACgJZR8AAAAAAAAAAAAAAAAoCWUfAAAAAAAAAAAAAAAAKAllHwAAAAAAAAAAAAAAACgJZR8AAAAAAAAAAAAAAAAoCWUfAAAAAAAAAAAAAAAAKAllHwAAAAAAAAAAAAAAACgJZR8AAAAAAAAAAAAAAAAoCWUfAAAAAAAAAAAAAAAAKAllHwAAAAAAAAAAAAAAACiJ/wdTvlYp723nrwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "az.plot_autocorr(inference_data);" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "az.plot_trace(inference_data, compact=False);" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABoMAAAIwCAYAAABN6RLXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeXgUVdbH8W91p7ORAGEJSISAgIIjYROIgICCILKIjIwo44yOiCKLuI4IIoIO+LqAAoIgo+iMGwyKiCIuSADZDAiiskoAwxbWJIR00t33/aNNQ0yABJJ0J/l9nseHVNWt7tNNmacOp+65ljHGICIiIiIiIiIiIiIiImWSzd8BiIiIiIiIiIiIiIiISPFRMUhERERERERERERERKQMUzFIRERERERERERERESkDFMxSEREREREREREREREpAxTMUhERERERERERERERKQMUzFIRERERERERERERESkDFMxSEREREREREREREREpAxTMUhERERERERERERERKQMUzFIRERERERERERERESkDFMxSEREypQ1a9ZwxRVXcOedd/o7FBERERERkWKl/EdERAoqyN8BiIiIFNZbb71FWloaf//736lYsaJfY1mzZg1r166ldevWtGnTxq+xiIiIiIhI2aP8R0REioJmBomISKnz9ttvM3XqVFJTU/0dCmvXrmXq1KmsXbvW36GIiIiIiEgZpPxHRESKgopBIiIiIiIiIiIiIiIiZZiKQSIiIiIiIiIiIiIiImWYZYwx/g5CRESkIObPn8/IkSPPevztt98G4G9/+xutW7dmzpw5vPPOO8ydO5fdu3cTGRlJp06dePTRR6lSpUq+r3H8+HHefPNNvv76a3777Tcsy6Jhw4bceuut3Hrrrdhsp5+juOKKK84ayy233MLEiRMB2Lt3L59//jnLly9nz549HDlyhIiICP70pz9x55130qlTpwv4NkREREREpCxT/iMiIkUpyN8BiIiIFFTVqlVp0aIFmzdvJisri6uuuorg4GDf8cjISNLS0nzbjz32GJ9++il169YlNjaWXbt28b///Y9NmzYxf/78XOcCbN++nXvuuYeDBw/icDiIjY0lKyuLTZs2sXHjRlasWMErr7yCZVkAtGjRgv3797N//34uueQSLrnkEt9r1a1b1/fzjBkzmDdvHuHh4URHR3PFFVdw8OBBVqxYwYoVK3jkkUcYNGhQMX1rIiIiIiJSGin/ERGRoqSZQSIiUupcf/31JCcn8/XXX3PppZfmOrZmzRr+9re/4XA4iIqKYtq0acTFxQGwa9cu7rrrLg4cOMDYsWO5/fbbfedlZGRw8803s2fPHu68805GjBhBREQEADt27GDEiBFs376dMWPGMGDAAN95U6ZMYerUqQwdOpRhw4blG++yZcuoXLkycXFxvkQK4Pvvv2fEiBEcPXqUxYsXU6dOnSL7jkREREREpGxQ/iMiIkVBawaJiEiZlJ2dzVNPPeVLhADq1avHwIEDAUhISMg1/n//+x979uzhhhtuYPTo0b5ECKBBgwa8+OKLWJbFm2++WehYOnbsSNOmTXMlQgBXX301Dz74IG63m88++6zQrysiIiIiIgLKf0RE5PzUJk5ERMqkSpUq0bVr1zz7mzRpAsBvv/2Wa/+SJUsA6NevX76v16hRI2JiYti7dy8HDhygZs2ahYrn6NGjLFy4kE2bNnHkyBGcTicA6enpAGzZsqVQryciIiIiIpJD+Y+IiJyPikEiIlIm1a5dO9/9VatWBeDkyZO59m/btg2AV155hRkzZuR77rFjxwA4ePBgoZKhFStWMGLEiFz9vP/oxIkTBX49ERERERGRMyn/ERGR81ExSEREyqTw8PB89/+xVUGOnCfUfvrpp/O+dmZmZoHjSE1N5eGHHyYtLY0+ffpwxx13UK9ePSIiIrDZbHz33XfcfffduFyuAr+miIiIiIjImZT/iIjI+agYJCIigjd5Sk1NZcmSJcTGxhbZ6yYkJHDixAmaN2/OxIkT8yRj+/fvL7L3EhERERERKQjlPyIi5Y/N3wGIiIgEgvr16wOwffv2Qp13tiftciQnJwPQrFmzfMeqV7aIiIiIiJQ05T8iIuWPikEiIlLqhIaGAvgWIS0KOYutvv322xhjCnxeSEgIcPbWCTnHDx8+nOfYsWPHmDdvXmFDFRERERGRckT5j4iIFAUVg0REpNTJWRx17dq1Rfaat912G7Vr12bNmjU8+uijHDp0KNfxkydP8tlnnzFhwoR8Y9mwYUO+fa+vvvpqABYvXsx3333n23/o0CGGDx+O2+0uss8gIiIiIiJlj/IfEREpClozSERESp3u3bvz7bffMnbsWN59910qV64MwJNPPnnBr1mhQgVef/11Bg0axKeffspnn33mW+j0xIkT7N27F7fbTdOmTXOd1759eypVqkRiYiKdOnWidu3aBAUFce211zJo0CCuuuoqunXrxhdffMHdd99NbGws4eHhbN++nZCQEB555BH+9a9/XczXISIiIiIiZZjyHxERKQoqBomISKnTp08fUlNTmTdvHrt372bbtm0ApKamXtTr1q9fnwULFvDuu+/y1VdfsXPnTvbu3Uv16tVp1aoVHTt29LVTyBEREcHs2bN59dVX2bRpEz/88AMej4eYmBjfmBdffNH32vv27aNy5cp069aNoUOHkpKSclExi4iIiIhI2ab8R0REioJlCtMYVEREREREREREREREREoVrRkkIiIiIiIiIiIiIiJShqkYJCIiIiIiIiIiIiIiUoapGCQiIiIiIiIiIiIiIlKGqRgkIiIiIiIiIiIiIiJShqkYJCIiIiIiIiIiIiIiUoapGCQiIiIiIiIiIiIiIlKGqRgkIiIiIiIiIiIiIiJShqkYJCIiIiIiIiIiIiIiUoapGCQiIiIiIiIiIiIiIlKGBfk7ABERkUCzbNky3nzzTX7++WeysrKoV68effv2ZcCAAdhseo5CRERERERKv71797Jq1So2bdrEpk2b2LFjB263mwcffJAHHnjA3+GJiEgRUzFIRETkDDNnzuSll14CoHbt2oSHh7NlyxaeffZZvvvuO6ZNm6aCkIiIiIiIlHpvv/02b7/9tr/DEBGREqJ/zRIREfndhg0bePnll7HZbLz00kt89dVXfPLJJ3z00UdUq1aNb775hjfffNPfYYqIiIiIiFy0qKgorrvuOoYPH86sWbPo1q2bv0MSEZFipGKQiIjI76ZPn44xhn79+tGzZ0/f/kaNGvHEE08A3plD2dnZ/gpRRERERESkSDzwwAPMmDGDIUOG0KFDB8LDw/0dkoiIFCMVg0RERID09HS+++47AG699dY8x2+88UYiIiI4fvw4a9asKenwRERERERERERELpiKQSIiIsDPP/9MdnY2ISEhXHnllXmOOxwOmjRpAsDGjRtLOjwREREREREREZELpmKQiIgIsHv3bgAuueQSgoKC8h1Tu3btXGNFRERERERERERKAxWDREREgBMnTgBQqVKls46pWLEiAKmpqSUSk4iIiIiIiIiISFFQMUhERARwOp2Atx3c2QQHBwOQmZlZIjGJiIiIiIiIiIgUBRWDREREgJCQEACys7PPOiYrKwuA0NDQEolJRERERERERESkKKgYJCIiwun2cDnt4vKT0x4up12ciIiIiIiIiIhIaaBikIiICBAbGwvA/v37cblc+Y7Zu3dvrrEiIiIiIiIiIiKlgYpBIiIiwJVXXonD4cDpdPLzzz/nOZ6dnc2PP/4IQNOmTUs6PBERERERERERkQumYpCIiAgQERHBNddcA8C8efPyHF+8eDHp6elUrlyZ1q1bl3R4IiIiIiIiIiIiF0zFIBERkd/df//9WJbF3Llz+fTTT337t2zZwsSJEwEYOHAgwcHB/gpRRERERERERESk0CxjjPF3ECIiIoFi+vTpTJ48GYDatWsTHh7O9u3b8Xg8dOrUiddeew273e7fIEVERERERC5SYmIiDzzwgG87IyODrKwswsLCCAkJ8e3/+OOPueSSS/wRooiIFKEgfwcgIiISSAYPHkyjRo146623+Omnnzh8+DCXX345ffv25a9//asKQSIiIiIiUia4XC6OHz+eZ/+pU6c4deqUb9vtdpdgVCIiUlw0M0hERERERERERERERKQM05pBIiIiIiIiIiIiIiIiZZiKQSIiIiIiIiIiIiIiImWYikEiIiIiIiIiIiIiIiJlWJC/Aygvjh075u8QpBSoVKkSJ06c8HcYUorompHC0PUihaVrRgoj0K6XqKgof4dQrin/kYIKtN8dEth0vUhh6HqRwtI1I4URaNdLQfIfzQwSCSA2m/6XlMLRNSOFoetFCkvXjBSGrhcRuRD63SGFoetFCkPXixSWrhkpjNJ4vZS+iEVERERERERERERERKTAVAwSEREREREREREREREpw1QMEhERERERERERERERKcNUDBIRERERERERERERESnDVAwSEREREREREREREREpw1QMEhERERERERERERERKcNUDBIRERERERERERERESnDVAwSEREREREREREREREpw1QMEhERERERERERERERKcNUDBIRERERERERERERESnDVAwSEREREREREREREREpw1QMEhERERERERERERERKcNUDBIRERERERERERERESnDgvwdgIiIiIiIlH7G48a+dy3WyRRMheq4Y1qCze7vsERERERERIqc221Yv8Fw5ChUrQJN48But/wd1jmpGCQiIiIiIhfFvn0JrmUTCUvd79vniaiJ87qRuBt29WNkIiIiIiIiRWtZguHVacc5eND49lWvDiOGQccOgVsQUps4ERERERG5YPbtSwhdOALOKAQBWOkHCV04Avv2Jf4JTEREREREpIgtSzCMGmM4eNCTa39KCowaY1iWYM5ypv+pGCQlrk+fPvTp08cv7z1r1izi4+NJTEz0y/uLiIiIlCkeNyFLJwB5Ex7r930h304Aj7uEAxMJHMp/RERERMoGt9swecq5iz2vTDW43YFZEFIxqBzYt28f8fHxxMfH06tXL9zu/JPxHTt2+MbddtttF/x+SjhEREREygd7ciK29AOcrRGChcGWdgB7su4LpeQo/xERERGR4rBxk3cG0LkcOuQdF4hUDCpH7HY7KSkprFmzJt/jCxcuxG7XIr8iIiIiUjDWyfNkQoUcJ1KUlP+IiIiISFE6crRox5U0FYPKkbi4OCIiIli4cGGeY9nZ2XzxxRe0bdvWD5GJiIiISGlkKlQv0nEiRUn5j4iIiIgUpapVinZcSQvydwBSckJCQujSpQuLFi3i+PHjVK5c2Xds+fLlHD9+nJ49e7J8+fI85xpj+PTTT/nkk0/YuXMnbrebevXq8ec//5levXr5xg0ePJgNGzYAMGTIEN/+mjVr8vHHH+d6zVOnTvH666/z9ddfc/z4cerUqcM999zD9ddfn+f9T5w4wZtvvsmyZcs4fPgwERERtGjRgoEDB1KvXr084w8ePMjUqVNZs2YN2dnZNGrUiEGDBhX2KxMRERGRc7CObMfAWdvEGSxMZA3cMS1LMiwRQPmP8h8RERGRouXxGCwLzDmWBIqOhqZxJRdTYagYVM707NmTjz/+mC+++CJXX+yFCxcSFRVFu3bt8pxjjOHpp59myZIl1KlTh27duhEUFMTatWt57rnn2LVrF8OHDwegR48eAGzYsIGbbrqJSy65BIDIyMhcr+l2uxk+fDipqal07NgRp9PJl19+yahRo5g8eTJt2rTxjT1x4gT33HMPv/32Gy1atOCGG25g//79fPPNN3z33Xe8+uqrNGnSxDf+8OHDDBw4kJSUFOLj47niiitISkpi+PDhtGypf4gQERERuWgeF8HfTiT4h/8C/F4Qsn7/id/3eUtEzk4jwaZWXOIfyn+U/4iIiIhcLI/H8N/3YNbscxeCAB4camG3n+1xOf9SMaicueqqq7jssstYuHChLxk6dOgQa9eu5bbbbiMoKO8lsWDBApYsWUKvXr345z//6RuTnZ3NyJEjeffdd+natSuNGjWiZ8+e7N+/nw0bNtCjR4+zJh8pKSk0btyY1157DYfDAUDXrl0ZNmwY7733Xq5kaOrUqfz222/8/e9/Z/Dgwb79PXr0YMSIEYwbN44PPvgAm83b9fC1114jJSWF++67j7vvvts3/uOPP2bixIkX+Q2KiIiIlHOZqYQuepig3SsBcLZ/CE/luoQlTITU/b5hJrIGzk4jcTfs6q9IRZT/KP8RERERuSipaYbnJhhWfufd7t4NWreCGbNsHDzo8Y2LjvYWgjp2CMxCEGjNoHKpR48e7Nixgy1btgCwaNEi3G53rnYHZ5o3bx5hYWE8+uijuZIlh8PB/fffD8CSJUsKHceIESN8iRBAq1atqFmzJj///LNvX3Z2NkuWLKFSpUq5EhuA+Ph44uPj2bt3L5s2bfKN//rrr4mKiuKOO+7INb53797UqVOn0HGKiIiIiJd1bDfh799O0O6VmKAwTvV6hezWg3Bf3pWgR77nVL85ZN70Iqf6zSHjnq9UCJKAoPxHRERERC7Etu2GewZ5C0HBDnj8UYsnn7C4oYuNLz+vzKuTLJ5+yuLVSRZz3wvsQhBoZlC51L17d6ZPn87ChQtp1KgRixYt4k9/+lO+vaczMzPZuXMn1apV4+23385z3OVyAbB79+5CxRAZGUmtWrXy7I+Ojmbz5s2+7aSkJJxOJy1atCA0NDTP+BYtWrB69Wq2b99Os2bN2L17N06nk5YtWxISEpJrrM1mo0mTJuzZs6dQsYqIiIgI2PeuJXThcKzME3giapLZZxqe6Ct9xy2bHXft1n6MUCR/yn+U/4iIiIgUhjGGTxfBpFcMWdlwSU14dpzFFZefLvbY7RYtmgd28eePVAwqh6pUqULbtm358ssvufbaa/ntt98YMGBAvmNTU1MxxpCSksLs2bPP+pqnTp0qVAwVKlTId7/dbsfjOT297uTJk76Y85OzPz09PdefUVFR5xwvIiIiIgUX9ONcQr4eh+Vx4a4ZR2bvKZiIaH+HJVIgyn9EREREpKAyMw0vTzZ8tti73fYaGP2kRcXI0lX4yY+KQeVUz549SUhI4LnnniMkJISuXfNv4ZGTtDRq1Ii33nqrBCPM/f5Hjx7N93jO/pxxERERABw7duyc40VERESkADxughNeIHj9HACyr7gJZ9fnwJF3xoJIIFP+IyIiIiLns/c3w+inDTt3gs0G995jMeB2sNlKfyEItGZQudW2bVuqVq1KSkoK11133VmfVKtQoQJ169YlKSmJtLS0Ar223W4HyPWE24WqW7cuISEh/PLLL2RmZuY5vmHDBgAuv/xyAGJjY33jnU5nrrEej4cff/zxomMSERERKRec6YQueMBXCHK2HYbzphdVCJJSSfmPiIiIiJzLsuWGgfd5C0FRUTD5JYs7B1hlphAEKgaVW0FBQbzwwgs8//zzvkVQz+Yvf/kLmZmZTJgwId92CPv27WPfvn2+7YoVKwJw6NChi47T4XBwww03cPz4cebMmZPr2Nq1a1m1ahWXXnopcXFxvvGdO3fm2LFjvPvuu7nGf/LJJ+qXLSIiIlIA1onfCHv/doJ2JWCCQjnVcxLZ8Q+AVXYSISlflP+IiIiISH5cLsO06R5GPWU4eRLimsCbs0rfekAFoTZx5diVV155/kHALbfcwubNm/nss8/YtGkTrVq1olq1ahw9epTdu3fz008/MW7cON+CqC1btsSyLGbMmMHu3buJiIigQoUK/PnPf76gOIcMGcKGDRt48803+fHHH/nTn/7E/v37+eabbwgNDWX06NHYbKfrmg888ADr1q3j9ddfZ+PGjVxxxRUkJSXx3Xff0aZNG9asWXNBcYiIiIiUB7bkRMI+GYZ16hieCtFk3jwNT82r/B2WyEVT/iMiIiIiZzp82PD0OMPGTd7t/n+B+wdZBAWVvUIQqBgkBWBZFmPGjKFt27YsWLCAlStXkpGRQVRUFLVr12bYsGG0atXKN75evXqMHj2ad999l/fff5+srCxq1qx5wclQVFQUs2fP5t///jcJCQn88MMPRERE0KFDB+655x7q16+fa3y1atWYNWsWU6dOZc2aNfzwww80atSIV199le+//17JkIiIiMhZBP30ESFfPo3lycYdfSWZN7+Giazh77BESpTyHxEREZGyb/0Gw9hxhqPHIDwcRj1h0bFD2SwC5bCMMcbfQZQHZ1vQU+RMUVFRulakUHTNSGHoepHC0jVTjnjcBK+YRPD3swFwNexG5o0TwBFW4JcItOslKirK3yGUa4F0LUhgC7TfHRLYdL1IYeh6kcLSNVM+eDyG/74Hs2YbPB6ofxk8O86i9qWFKwQF2vVSkPxHM4NERERERMqzrJOEfv44QTu/8W62GUxW26FgaXlREREREREpO1LTDP+aaFix0rvdvRs88pBFaGjZnhGUQ8UgEREREZFyykrdR+jHD2A/vBVjD8bZ9TlcjXv6OywREREREZEitW27YdQYw/79EOyAEQ9a9OrhbRFcXqgYJCIiIiJSDtn2bSD0k2HYMo7gCa9G5s1T8VzS1N9hiYiIiIiIFBljDJ8ugkmvGLKy4ZKaMP4Zi0ZXlJ8iUA4Vg0REREREypmgXxYSsmQ0ljsLd/VGZN48DVOxlr/DEhERERERKTKZmYaXJxs+W+zdbnsNjH7SomJk+SsEgYpBIiIiIiLlh/EQ/N2rBK95HQBX/c5kdn8egiv4OTAREREREZGi89tvhlFPG3buBJsN7r3HYsDtYLOVz0IQqBgkIiIiIlI+ZGcQ+vkTBO34EoCsVveS1X4EWDb/xiUiIiIiIlKEli03/Gui4eRJiIqCZ8ZYtGhefotAOVQMEhEREREp46y0A4QuGIL90M8YuwPnDeNwXdnH32GJiIiIiIgUGZfL8Posw3sfeLebXAXjx1pUq6ZCEKgYJCIiIiJSptkO/EjogiHYTqbgCatCZu8peGJa+DssERERERGRInP4iOHpZwwbN3m3b/sLDB5kERSkQlAOFYNERERERMqooK2fE7J4JJbbibtqQzL7TMdUivF3WCIiIiIiIkVm/QbD2HGGo8cgPBxGPWHRsYOKQH+kYpCIiIiISFljDI7VrxGyaioArnodybzpRQiJ8HNgcjYLFiwgMTGRzZs3s23bNrKzs5kwYQJ9+/Y96zl79+7l9ddfZ+XKlaSkpFCxYkXq16/PHXfcQffu3fOMX7hwIXPmzGHHjh04HA6aNWvG8OHDadKkSb6vn5SUxKRJk1izZg0ZGRnExsZy2223cccdd2Czaa0pERERESlZbrd35s+Ro1C1CjS5yvDBXIuZbxg8Hqh/GTw7zqL2pSoE5UfFIBERERGRsiQ7k5AlT+LY+jkAWS3vJuvaR8Bm93Ngci6vvPIKycnJREVFER0dTXJy8jnHr1y5kiFDhgBw3XXXUbt2bU6cOMHWrVtZtWpVnmLQjBkzmDRpErVq1aJ///5kZGSwaNEibr/9dmbPnk2bNm1yjd+xYwf9+/cnMzOTG2+8kRo1apCQkMD48ePZunUr48ePL9ovQERERETkHJYlGCZPMaSknN4XHAxZWQaAG7vBow9ZhIaqEHQ2KgaJiIiIiJRWHjf25ESskymYCtXxVKpN6MIHsR/8EWNz4OzyNK6r/uzvKKUAnn32WWJjY4mJiWHmzJm89NJLZx27f/9+hg8fTo0aNXjzzTepVatWruMulyvXdlJSElOmTKFu3brMmzePyMhIAO6880769evH6NGj+fzzzwkKOp0ejh07lrS0NGbOnEnHjh0BGDFiBPfeey8ffvghPXr0ID4+vqg+voiIiIjIWS1LMIwaY/Lsz8ry/tmnNzzykIVlqRB0LioGiYiIiIiUQvbtSwhZOgFb+gHfPmPZsIwHE1qZU71ewVO7tR8jlMJo27ZtgcfOmDGD9PR0pk6dmqcQBOQq6gDMnz8fl8vF4MGDfYUggIYNG3LzzTfz/vvvs3r1atq3bw/Arl27WLduHW3atPEVggAcDgcPPfQQq1atYu7cuSoGiYiIiEixc7u9M4LO5bvV8JAH7GqGcE5q9CwBJTExkfj4eGbNmlUsrz9r1izi4+NJTEz07du3bx/x8fGMGzeuWN5TREREpKjZty8hdOEIrDMKQYC3EAQ42w5TIaiMMsawePFiKleuzDXXXMPmzZt58803mT17Nt999x0ejyfPOWvXrgWgXbt2eY5de+21AKxbty7P+Jzi0Jni4uKoWLGib4xcHOU/IiIiIue2cRO5WsPl59Ah7zg5N80MEhEREREpTTxuQpZOAAxna4IQvG4WrrjbtE5QGfTbb79x/PhxmjRpwtNPP83777+f6/iVV17J9OnTqVmzpm9fUlIS4eHhVK9ePc/rxcbG+sacOf7MY2eyLIs6deqwefNmTp06RVhYWBF8KhERERGR/G3bfu5ZQTmOHC3mQMoAFYNEREREREoRe3JirtZwf2QBVtoB7MmJuDU7qMw5cuQIAD///DM7d+5kwoQJdO7cmbS0NF5//XU+/PBDhg8fzocffug7Jz09nSpVquT7ehEREb4xZ44HcrWUy++ctLS0sxaDKlWqhM2mRhTnk/Mdh4WFERUVVeSvn/P3ExkZ6Xv9kydPAhASElIs73khAiUOKR10vUhh6HqRwtI1EziOH/cw/fVTvPt+ZoHG142NJCrKUcxR5VbarhcVg8oht9uwcZO3Wlq1CjSNA7tdi2uJiIiIlAbW4W0FG3fyPL0UpFTKaQPndrt58MEH6du3L+AtvowfP56tW7eyceNGvv/+e66++mq/xXnixAm/vfcfBXL+k5aWBsCpU6c4duxYkb/+qVOnfO+T8/o5fzdOp7NY3rOwoqKiAiIOKR10vUhh6HqRwtI1Exiysw3zP4Y35xhynlcKDoasrLOfEx0Nl9VL49ixkrvHC7TrpSCFKRWDypllCd4Ft87ss1i9OowYBh07BEZClGPDhg3MnDmTLVu24HA4iI+PZ+jQoURHR/vGxMfH07x5c6ZPn57n/D59+gDw8ccfX9D7Z2VlMWbMGL799lvuvvtu7rvvvgt6HREREZEikZ2J4/vZBK95vUDDTYW8LcGk9Dtztk7nzp3zHL/uuuvYuHEjmzdv9hWDIiIifEWHP8qZBZQz2+fMnwtzTqBS/lNwyn9ERETEn4wxJKyA6TMMvyV799WvD8MesDh5EkaNOXu7uAeHWgHzsE8g07z9cmRZgmHUGJNnwa2UFO//TMsSCtZ/sST89NNPDB8+nIoVK/KXv/yFK6+8kiVLlnDvvff6WmMUp5MnTzJixAiWLVvGww8/rERIRERE/McY7Du+InxOT0JWTcXyZGPsDs5252aw8ETWxB3TskTDlJIRGxuL3e5dCyq/Nm4VK1YEvLM+ctStW5eMjAxS8ll5d/fu3b4xZ44/89iZjDHs2bOH6OhowsPDL/hzlATlPwWn/EdERET8actWw7ARhlFPeQtBVavAE49Z/HumxdUtLTp2sHhunMUfl8CMjobnxlkB95BPoNLMoFLCGENmwdoj5svtNkx69dxjJk8xtGxhLqiKGhrqXUy2qKxevZonn3yS3r17+/bNnj2bWbNmMWPGDEaNGlVk7/VHR44c4aGHHmLXrl2MGzeOG264odjeS0RERORcrCM7Cfl2AkG7VwLgiahJVsfHMZad0E9HYADrjLKQwXs/5uw0Emx2f4QsxSw4OJjmzZvz/fffs2PHjjyt4Hbs2AFATEyMb1+rVq3YsGEDK1eu9M0eybF8+XLfmBytW3vXmlqxYgWDBg3KNX7Tpk2kpqbSoUOHIvtMZ3MxOZDyn4JT/iMiIiL+cuiQYeZsw+IvvNvBwXD7bTDgdovw8Nz3Wh07WLRvR8C2/y0NVAwqBYwxPDDM8OPm4n2flBS4sSdw1udMz67JVfDalKJLiGJjY+nVq1eufQMGDGDevHksWbKExx9/HIej6BcE++2333jwwQc5duwYL774Im3atCny9xARERE5L2c6waun4djwHyyPC2N3kH31P8hqPQgc3tkYmb0mE7J0Alb6Ad9pJrIGzk4jcTfs6q/IpQTcfvvtfP/990ydOpWZM2cSHBwMwM6dO/noo4+oUKEC1157rW983759+fe//8306dPp3Lmzb0bR9u3bWbBgAXXq1CE+Pt43vl69erRq1Yo1a9awbNkyOnbsCEB2djaTJ08GoF+/fsX6GUsiB1L+o/xHRERE/CMjw/DeB4Z334ecCe3dusKggRY1os9+f2W3W7RoXkJBlkEqBklAiouLy5NYhYaGcsUVV7B69Wr27NlD/fr1i/Q9d+/ezaBBg/B4PEydOpUrr7yySF9fRERE5LyMh6CfFxC8/GVsGYcBcNW/HmfHf2Iq18k11N2wKxn1O2NPTsQ6mYKpUN3bGk4zgkqluXPnkpiYCMC2bdt8+9auXQtAly5d6NKlCwA9evRgyZIlfPHFF/Tu3Zv27duTnp7OF198gdPp5Pnnn6dSpUq+165Xrx5Dhw5l8uTJ9O7dm27dupGRkcGiRYtwuVyMHz+eoKDcqeHYsWPp378/Q4YMoXv37kRHR7N8+XK2bt1Kv379chWP5OIp/xEREZHywO02fP4FzJptyOmE2zTOuy5Qo0aa4VPcVAwqBSzL4rUpXFSbuI2bDI/+8/zjXnwemsb5v01CVFRUvvurVKkCnF60tijt3buX1NRUmjZtymWXXVbkry8iIiJyLrYDmwlZ+iz2/RsB8ETVxdnpSdz1rj3HSXbctVuXUIRSnBITE/noo49y7Vu/fj3r168HvG3fcopBlmXx8ssv85///Id58+bxwQcfEBwcTIsWLbjvvvt8bd7ONHjwYGJiYpgzZw7vvfceDoeD5s2bM3z4cOLi4vKMb9CgAXPnzmXSpEkkJCSQkZFBbGwso0ePZsCAAcXwDeR2sTmQ8p/zU/4jIiIiJSlxvWHKNMOOnd7tWrVgyP0WHa4t2vsqOTsVg0oJy7IIC7vw81tdDdWr51089UzR0dDqaisg+iweO3Ys3/1Hjx4FICIiAvB+L263O9+xJ0+epEKFCgV+z/bt21OrVi3eeOMNHnnkEV566SVCQ0MLGbmIiIhI4VgZRwheMYmgzfOxMBhHOFnxD5Dd4k6wB/s7PCkhEydOZOLEiQUeHxQUxF133cVdd91V4HN69+6da02a86lXrx6vvnqehXeK0cXkQMp/zk/5j4iIiJSEPXsM02YYVn7n3Y6oAHf93aJvHwgO9v992IUyHjf2vWtLVZcGFYPKCbvdYsQwGDXm7P2wHxwaGIkQeBemNcbkqgpnZmaydetWQkJCqFPH2yYlMjKSlHwyvH379pGWllaoZAhg4MCB2Gw2Zs6cycMPP8zLL7+shEhERESKh8eF44f3CF41BcuZBkB2495kXfsIJiLaz8GJlG7KfwpG+Y+IiIgUlxMnDG/OMXy0ANxusNvglj5w198sKlcOjHuwC2XfvgTXsomEpe737fNE1MR5XWCv32rzdwBScjp2sHhunEX16rn3R0fDc+MsOnYInP8Jd+/ezcKFC3Pt++9//8uxY8fo2rWrb/HUxo0bs3//fl9/dfAubPvKK69c8Hv/4x//YNCgQaxfv56HHnqIU6dOXfBriYiIiOTHvmcNYe/cQsi3/8JypuGOvpKM/u/i7P68CkEiRUT5T8Eo/xEREZGilJVleP9Dw20DDPPmewtB7drC229ajBhuKxOFoNCFI+CMQhCAlX6Q0IUjsG9f4p/ACkAzg8qZjh0s2reDjZvgyFGoWsW7SFegPBGXo02bNrzwwgusXLmSunXrsnXrVlavXk2NGjW4//77feP69+/PmjVreOSRR7jhhhsIDQ1l7dq1REZGUq1atQt+/3/84x/YbDZmzJjhe0Iu7GL69ImIiIgAVuo+ghNewLFtMQAmtDLO9g/huurPAd9SQKQ0Uv5TMMp/RERE5GIZY0hYDq/NMCTv8+5rUB+GPmBxdcvAuve6YB43IUsnAHlnn1sYDBYh304go37ngMzvNDOoHLLbLVo0t7ihs/fPQEuEAK666ipeffVVTpw4wQcffMBPP/3EDTfcwMyZM6latapv3DXXXMOzzz5LTEwMixcv5ptvvqF169a8+uqrBAVdXK3zrrvuYvDgwWzYsIGHHnqIjIyMi/1YIiIiUl5lZ+JYNY3wt3rg2LYYY9nIajaAk/9YjCvuLwGZKIiUFcp/Ckb5j4iIiFyoLVsMQx80jBrjLQRVrQJPPG4xe2YZKgQB9uREbOkHONsnsjDY0g5gT048ywj/sowxZ2+iLEXmbAuCipwpKipK14oUiq4ZKQxdL1JYumaKgDHYd35NyLcTsaUmA+C+tBXO60bhqX6Fn4MrWoF2vURFRfk7hHItkK4FCWyB9rtDApuuFykMXS9SWLpm8ud2m7POsj54yDDzDcMXv3dGCwmB22+DO/pbhIeXnSJQjqAtiwj97NHzjsu86UVcjXqUQESnFST/UZs4EREREZFiYB39lZCl/yJo90rAu6BoVsfHcF3eHayylxiJiIiIiEjZsizBMHmKISXl9L7q1WHwIMOevfDeB+B0evd36wqDBlrUiC67uY6pUP38gwoxrqSpGCQiIiIiUpSc6QSvfg3HhnewPC6M3UH21f8gq/UgcIT7OzoREREREZHzWpbgbfv2RykpMO6509tN42DYAxaNGpXdIhAAxmAd3oaBs7aJM1iYyBq4Y1qWZGQFpmKQiIiIiEhheNzYkxOxTqZgKlT33ujb7GA8BP38CcHLX8KWcRgA12XX4ez0BKZyHT8HLSIiIiIiUjBut3dG0LnYbTB2DHTqaGGV9c4HmamEfvkUQdu9/fC8BSHr95/4fZ/3O3B2Ghmwa8KqGCQiIiIiUkD27UsIWToBW/oB3z5PRE2ym/+VoB1fYt+/0bsvqi7OTiNx1+vgr1BFREREREQuyMZN5GoNlx+3BypVKvuFINv+TYQuehhbajLG5iDr2ofxRNYiLGEipO73jTORNbw5YMOufoz23FQMEhEREREpAPv2JYQuHMGZT38BWOkHCF7+ove5MEc4WfEPkN3iTrAH+yNMERERERGRi3LkaNGOK5WMwbF+DsHLX8LyuPBUupTMm17Cc0kcAEGtbiVt81d5O0YEMBWDRERERETOx+MmZOkETk/+Py1n2wSFkvH3TzEVLynh4ERERERERIpO1SpFO67UOXWM0C+eJOjXbwFwNexG5g3jILSib4hls+Ou3dpPAV4YFYNERERERM7DnpyYqzVcfixXJrYTe3GrGCQiIiIiIqVYcLDBssCcY9mg6GhoGldyMZUUW3IioYsexZZ+AGMPxtnpCVxx/aEMtMNTMUhERERE5Dysk+dpmF3IcSIiIiIiIoFozVrD6DHnLgQBPDjUwm4v/QUSH+PBsXYWwd9NwTJuPFF1yezxMp7oxv6OrMioGCQiIiIich5WesGKPKZC9WKOREREREREpHgs+crw3ASD2w2trobu3WD6TEg5Ix2KjvYWgjp2KDuFIOvkYUIW/5Og3d8BkN2oF84uT0NwBT9HVrRUDBIRERERORtnGiEJL+D4cS4ABvKsGeTdb2Eia3gXDRURERERESllPpxneHWqdzpQl84w6gkLh8Oi8/WGjZvgyFHvGkFN4yhTM4Lse1YR8tnj2DIOY4JCcV7/FK4/3VIm2sL9kYpBIiIiIiL5sP+6lJCvnsGWfhCA7Nj2BO1egcHC4nTPBPN7ecjZaSTY7H6JVURERERE5EIYY3h9luE/73q3b/0zDB9iYbN58xy73aJFcz8GWFw8LoJXvYZjzQwsDO6qDcjsOQlTtYG/Iys2KgaJiIiIiJzp1DFClk7AsWUhAJ7Kdci8YTye2q1xbV9CyNIJWOkHfMNNZA2cnUbibtjVXxGLiIiIiIgUmstl+L+XDJ997t2+716Lv94BVhmcFXMmK+0goZ89ij35ewCyr7oV53VPgiPMz5EVr4AsBh08eJDPP/+chIQEfv31Vw4fPkylSpVo0aIFAwcOpGnTpnnOSU9PZ8qUKSxZsoSUlBSqV69O165dGTZsGBEREfm+z8KFC5kzZw47duzA4XDQrFkzhg8fTpMmTfIdn5SUxKRJk1izZg0ZGRnExsZy2223cccdd2Cz2Yr0OxARERGREmYMQdsWE/zNs9hOHcVYNrJb3EVW26G+pMDdsCsZ9TtjT07EOpmCqVDd2xpOM4JERERERKQUycw0jHnG8N0qsNng8Uctet5UtotAAPZflxG6+AmszOMYRzjOLs/gatzT32GViICsYLzzzjtMmDCBvXv30rZtW+6++25atmzJ119/Tf/+/fnss89yjc/IyOCvf/0rb731FvXq1eOuu+6ifv36vPXWW/z1r38lIyMjz3vMmDGDRx99lCNHjtC/f3+6d+/O+vXruf3221mzZk2e8Tt27ODWW2/l66+/pn379tx5550AjB8/nqeffrp4vgi5YOPGjSM+Pp59+/b59u3bt4/4+HjGjRvnx8hEREQkEFnphwj9ZBihix7Gduoo7qoNOXX7+2R1fCzv02E2O+7arXE16oG7dmsVgkTE75T/iIiISGGkphkeetRbCAoOhn+NLweFIHc2wcteIOzj+7Eyj+OObkzGX/9XbgpBEKAzg+Li4vjvf//L1VdfnWv/999/z1133cUzzzxDly5dCA4OBuCNN97gl19+YeDAgTz22GO+8a+++irTpk3jjTfeYPjw4b79SUlJTJkyhbp16zJv3jwiIyMBuPPOO+nXrx+jR4/m888/Jyjo9NczduxY0tLSmDlzJh07dgRgxIgR3HvvvXz44Yf06NGD+Pj4YvtOyoPExESGDBnCPffcw7333uvvcERERKQ8MIagnz4iZNnzWM5UjC2I7Nb3kdVmENiD/R2diJRhyn9ERETEH1JSDA8/ZtiVBBER8Py/LJrGle1CkHUimdBFD2M/sAmArGZ/JavDYxBUvnK+gJwZ1LVr1zyFIICrr76aNm3acPz4cbZu3Qp4F7iaO3cu4eHhDBkyJNf4++67j0qVKjFv3jyMOb3I7/z583G5XAwePNhXCAJo2LAhN998M3v27GH16tW+/bt27WLdunW0adPGVwgCcDgcPPTQQwDMnTu3aD58SfC4se9dS9CWRdj3rgWP298RFbkHHniA999/n+joaH+HIiIiIgHKOpFM6Px7CV0yCsuZirvGVZwa8D9vWzgVgkTKDuU/IiIiIgDs3m24f6i3EFStGkx7tewXguzblxD+n77YD2zChFTkVK9XyLp+VLkrBEGAzgw6l5zZOjl/JiUlcejQIdq3b094eHiusSEhIVx99dV8/fXX7N69m7p16wKwdu1aANq1a5fn9a+99lref/991q1bR/v27XONz9k+U1xcHBUrVvSNCXT23xc9tp2x6LEnoibO68rWosfVqlWjWrVq/g5DREREApHx4PjhPYJXvIyVnYGxh5DVdhjZLf8OtlJ3eywi56D8R0RERMTrp58Njz9hOJEKdWrDyy9Y1KxZhgtBLifBCS8Q/MN/AXDXjCOzx8uYSjF+Dsx/SlW2u2/fPr777juqV6/O5ZdfDsDu3bsBfIWeP4qNjfWNyxmTlJREeHg41atXP+v4pKQk376cn3OOncmyLOrUqcPmzZs5deoUYWFhecYECvv2JYQuHAGYXPut9IOELhxBZq/JfkuIZs2axezZswGYPXu272c4PZNrwYIFrFu3jgMHDpCZmUmNGjXo1KkTd999d55C4Lhx4/jss8+YP38+tWrVKtHPIiIiIoHLOraL0CVPYU9OBMAd05LMruMxUfX8HJmIFDXlPyIiIiJeq9cYRj9tyMyExo3hhQkWlSuX3UKQdSzJ2xbu0C8AZLX8B1ntHyz3HSBKTTEoOzubxx9/nKysLB599FHsdu9CvWlpaQBERETke17O/pxxAOnp6VSpUuWc49PT03ONB3K1lDvbexRbMcgYcJ268PM9bkKWPgcY/vi/uYXBACFL/0VGnWsubBHkoDCwLvwXSIsWLdi/fz+fffYZzZs3p0WLFr5jkZGRfPTRRyxcuJCWLVvSokULjDFs3ryZd955hw0bNjBjxoxcazyJiIiI5OJx4Uh8i+DvpmC5szCOcJzXPoKraX+wArJzsohcTA6k/EdEREQEgCVfGp6baHC7oXUrePYZi/DwslsICtqyiJAvx3i7QIRWJvPGCbgv6+TvsAJCqbh79Hg8PPnkk6xbt46//OUv9OnTx98hFVqlSpWw2S7sHxqMMbjf6I3Zs66IozrNwvuEXMS01hd2fp3W2AcuwLrAhKhLly5ERkby2Wef0a5dO4YNG5breP/+/Rk8eDDBwbmrt1OnTmXKlCmsWrWK3r17+/aHhIQA3u89KioKgJMnT/qO5ewLRIEcmwQmXTNSGLpepLDKwjVjDvyM+6MRmH3exUKtBp0IuvkFgivX9nNkZU9ZuF4kQBhD2AcDsO/bUCwvf7H5j7tWC07d9p8LLgi1bNkSgM8++4wWLVpw77335jp+4403cvvtt+NwOHLtnz17NrNmzeKrr77ixhtvvKD3FhERkfLjg7mGKdO8s6Rv6AJP/tPC4SijhaDsU4Qs/ReOzfOA37tA3PQiJrKmnwMLHAFfDDLGMHr0aD755BN69+7NM888k+t4zmydM2fynCm/WT0RERG5ZgrlN/7MmUb5zS463zl/dOLEibMeOy9jCHO5uYDn1UqMy+Ui7dixi3o6Luf7PXXqFMeOHct1LDg4mJMnT/oKOjl69uzJlClT+Pbbb7n22mt9+51OJ+D93itUqOD7OefYH18/UERFRQVsbBKYdM1IYeh6kcIq9deMK4vgNTNwrJuF5XFhQiri7PQEriv7gLGgNH+2ABRo14sKU2VBGf2HigKIjo7Od/+tt97KrFmzWLdunYpBIiIiclbGGKbPNLz7nnf7L7fC0AcsbLZSfn/lcWNPTsQ6mYKpUB13TEuw2bGO7CD004ewH9mBwSK7zX1kXTNEa8L+QUB/Gx6Ph1GjRjF//nx69uzJxIkT88yuyW+NnzPlrCl05no/devWZcOGDaSkpORZNyi/NYhyfs45diZjDHv27CE6OjpP3+YiY1nep84uok2c/bfvCfvovvOOO3XL67gvvbrwb3CRbRLOxxjDp59+yqJFi/j1119JT0/H4/H4jh8+fLjY3ltERERKH9v+TYQsGYX9yA4AXA264Lz+KUxE/v/AKiIB5iJzIOU/IiIiUl65XIbnXzB8/oV3+/5BFgNu54I7OgUK+/YlhCydgC39gG+fJ6IGrvqdcfw0H8uViSe8Gs7uz+OObevHSANXwBaDziwE3XTTTfzf//2fb52gM9WtW5fo6GjWr19PRkZGroKM0+nk+++/Jzo6OlcxqFWrVmzYsIGVK1fmaTm3fPly35gcrVt7WwesWLGCQYMG5Rq/adMmUlNT6dChw0V/5nOyLHBceLHJHdsOT0RNrPSDWH9YQBW8nbRNZA3cse0urGd2MXvppZeYN28eNWrUoH379lSrVs3XMmH27NlkZWX5OUIREREJCNmnCP5uCo71c7CMB094VZzXj8bdsFux/sOtiBSDi8iBlP+IiIhIeZSZaRgz1vDdarDb4PHHLHp0L/15kH37EkIXjoA/3NdZ6QcJ3vguAK468Ti7/x+mQvW8LyBAgBaDziwE3Xjjjbzwwgv5FoLAW9Hs168f06ZNY9q0aTz22GO+Y6+//jonTpxgyJAhuSqfffv25d///jfTp0+nc+fOvhZy27dvZ8GCBdSpU4f4+Hjf+Hr16tGqVSvWrFnDsmXL6NixIwDZ2dlMnjwZgH79+hX111C0bHac140kdOEIDFauhChnSVVnp5EBmQgdPXqU//3vfzRo0IA33niD0NBQ37EjR44we/ZsP0YnIiIigcK2dy2hXz6F7fgeALIb9/Le34SpXZhIuaP8R0RERMqZ1FTD4yMNm3+CkBAY97RFu7alvxCEx03I0gmcvos7zeL38lBwBJl9Xoeg4Dyny2kBWQyaNm0a8+fPJzw8nLp16zJ9+vQ8Y7p06ULjxo0BGDhwIN988w1vvPEGv/zyC3/605/YsmULCQkJNG7cmIEDB+Y6t169egwdOpTJkyfTu3dvunXrRkZGBosWLcLlcjF+/HiCgnJ/NWPHjqV///4MGTKE7t27Ex0dzfLly9m6dSv9+vXLVTwKVO6GXcnsNZmQpROwzphOZyJr4Ow0EnfDrn6MDl/B78z2BwD79u3DGEOrVq1yJUIAP/zwQ0mFJyIiIoHKmU7I8hdxbPoA8LYKcHYZi/uyTv6NS0T8SvmPiIiIlBeHDhkeftyQlAQREfDCRIsmV5WBQhBgT07M1RrujyyArHTs+3/AXbt1icVVGgVkMSg5ORmAjIwMZsyYke+YmJgYXzEoPDycd955h6lTp/LFF1+wdu1aqlWrxl133cXQoUPzXctn8ODBxMTEMGfOHN577z0cDgfNmzdn+PDhxMXF5RnfoEED5s6dy6RJk0hISCAjI4PY2FhGjx7NgAEDivDTFy93w65k1O+c70Jb/laxYkUADh06lGt/zZo1Afjxxx/xeDy+daMOHTrEa6+9VrJBioiIiH+cZaFQ+64EQr4aiy1tPwDZcbfhvPYRCIn0c8AiEgiU/4iIiEhZl7Tb8PBjhkOHoHo1eOkFi8vqlY1CEIB1MqVIx5VnAVkMmjhxIhMnTizUOZGRkYwcOZKRI0cW+JzevXvTu3fvAo+vV68er776aqHiCkg2e0BWSWNjY6levTpfffUVoaGhREdHY1kWffv25brrrmPp0qXcddddtGrViqNHj7Jy5UpatmzpKx6KiIhI2ZTvQqEVovFUrkNQ8vfe7Uq1cd4wHnedNv4KU0QClfIfERERKaM2/+RtDZeaCnVqw8svWtSsUXYKQQCmgA/6aa2g8wvIYpCUT3a7nQkTJjBt2jQ+//xzMjIyAG9LwKeeeopLLrmEpUuXMnfuXGrUqEH//v3529/+Rvv27f0cuYiIiBSXsy4UevIQQScPYYDsFn8nq93wC15oXkTEH5T/iIiIyMVYtdow+mmD0wlXNob/m2BRuXLZKgTZf11GyNfjzjnGYGEia3hnf8s5WcYYc/5hcrGOHTvm7xCkFIiKitK1IoWia0YKQ9eLFJbfrxmPm/A3umClH8izUCh4y0MmvCoZg5YFRMun8s7v18sfREVF+TuEci2QrgUJbIH2u0MCm64XKQxdL1JYpemaWbzEMGGiwe2B+DYwfqxFWFjZKQRZ6YcI/nYCjm2LAfCEVsbKPA5YWGc8KGh+zxQze00u8fUgA+16KUj+YyuBOERERERECi1nodCzpTQWYMs4gj05sSTDEikWCxYsYMyYMfTt25errrqKK664gvnz5xfo3L1799K8eXOuuOIKxowZc9ZxCxcu5NZbb6VZs2a0atWKe++9lx9//PGs45OSknjwwQeJj48nLi6OXr168Z///AePx1PozyciIiIiReO9DwzP/stbCOp2A0x8rgwVgjxuHD/8l/C3euDYthhj2clqeRcZA78is9crmIgauYabyBp+KQSVVmoTJyIiIiKBxZlOUNJygja8U6DhWihUyoJXXnmF5ORkoqKiiI6OLvC6MMYYnnzyyfOOmzFjBpMmTaJWrVr079+fjIwMFi1axO23387s2bNp0yb3els7duygf//+ZGZmcuONN1KjRg0SEhIYP348W7duZfz48Rf0OUVERETkwng8humvG977wLt9219gyP0WNlvZKATZDv1CyJdPYz/ofVjJXTMOZ5exeKIbe7cbdiWjfmfsyYlYJ1MwFap7W8OpS0SBqRgkIiIiIn5npR3AvvMbgnZ+g33vWixPdoHP1UKhUhY8++yzxMbGEhMTw8yZM3nppZcKdN4777zD+vXreeyxx5gwYUK+Y5KSkpgyZQp169Zl3rx5REZ6F+G988476devH6NHj+bzzz8nKOh0ejh27FjS0tKYOXMmHTt2BGDEiBHce++9fPjhh/To0YP4+PiL/NQiIiIikh+327BxExw5ClWrwJ+uNLzwMiz+wnv8gfst7uhfNopAZJ0keNU0HOvfxjJuTHAFsto/RHZc/7yFHpsdd+3W/omzDFAxSERERERKnjHYDm/FvuNrbwHo0M+5Dnui6uG6rBNBPy/AOnUsV19o30toodCA4nYb1m8wvoS1aRzY7WUkQS0Bbdu2LfQ5u3fv5uWXX2bgwIE0btz4rOPmz5+Py+Vi8ODBvkIQQMOGDbn55pt5//33Wb16Ne3btwdg165drFu3jjZt2vgKQQAOh4OHHnqIVatWMXfuXBWDRERERIrBsgTD5CmGlDMaIAQHQ1YW2G3wxOMW3W8sG/fZ9p1LCflmPLa0/QBkX34jWZ1GYiKi/RxZ2aRikIiIiIiUDHc29uTvse/4hqBfv8GWus93yGDhqdUcV/3rcNXvjKlSz3tKrWaELhyBOctCoc5OI9UWIAAsSzC8Ou04Bw+e/juqXh1GDIOOHcpGohpoPB4PI0eOpFatWgwZMoQNGzacdezatWsBaNeuXZ5j1157Le+//z7r1q3zFYNyxudsnykuLo6KFSv6xoiIiIhI0VmWYBg1Ju+DcFlZ3j/vuJ0yUQiy0g4QsvQ5gnZ8BYCnYi2c14/BfVnH85wpF0PFIBEREREpPs50gpISvAWgpAQsZ5rvkAkKxR3bFlf963Ff1gkTXjXP6e6GXcnsNZmQpROw0g+cPjeyBs5OI7VQaAA4nbDmTlpTUmDUGMNz41QQKg5z5sxhw4YNvPvuuwQHB59zbFJSEuHh4VSvnrelYmxsrG/MmePPPHYmy7KoU6cOmzdv5tSpU4SFhV34hxARERERH7fbOyPoXL74Egb+w5TeGfgeN44f3iV45WSs7AyMZSe75V1kXfMAOML9HV2Zp2KQiIiIiBQpK22/t/Xbzm+w712Xa/0fT1gV3Jd1wtWgM+4614Dj/P+QrIVCA1dBEtZXphrat1PLuKK0a9cuJk+ezN/+9jeaN29+3vHp6elUqVIl32MRERG+MWeOB3K1lMvvnLS0tLMWgypVqoTNZjtvbCIAUVFR/g5BShFdL1IYul6ksPx5zaxdl01KSuo5xxw6BL/uiqR1K0cJRVV0TPJG3J88htm3CQCrdkuCer9AcM0rqeDn2C5Uafsdo2KQiIiIiOTlcePZtZKgA7vOX3wxBlvKFuw7vyFo59fYD/2S+6Wi6uGqfz2uBp3x1Iy7sCKOFgoNSBs3kauXeX4OHfKOa3H+moUUQE57uOjoaEaMGOHvcM7qxIkT/g5BSomoqCiOHTvm7zCklND1IoWh60UKy1/XTGamIXE9zJ137oesciTtTqNhg1L0oFXWSYJXvoLjh/9iGQ8mJBLntY/gatIPLBuU0v9PA+13TEEKUyoGiYiIiEgu9u1LCFk6AXf6AUJ/3+eJqInzujPasrmzsf+27vcC0De+BT/hzPV/rsdV/3rf+j9StrjdhtVrCpawHjlazMGUI2+//TY//PADc+bMKXCLtoiICNLS0vI9ljMLKGe2z5k/F+YcERERESm4ffsNq1bDqtWG9RtOrwlUEFXzn/AdeIzBvuMrQpY+hy39IADZV/Qgq9M/MRXyti+W4qdikIiIiIj42LcvIXThCP64/ouVfpDQhQ+S3eLvWCcPn2X9n3beAtBlnSC8tGQoUlhHjxoWfQ6fLDTsP3D+8VCKEtZSYMuWLRhj+Nvf/pbv8Q8++IAPPviAzp0789prrwFQt25dNmzYQEpKSp51g3bv3u0bkyPn55xjZzLGsGfPHqKjowkPV193ERERkYJwuQybfvQWf1athqQ/3GbVrAHx8bD0WzjXBOvoaGgaV6yhFgkrdR8hS58jaOc3AHgq1cbZ+Wncddv5ObLyTcUgEREREfHyuAlZOgHv3J7cLAwGCF4/5/Tw8Kre9X/qd8ZdJ75A6/9I6WSM4YeN8PECw7Ll4HJ590dEgNsNp06d/dzSkrCWFq1atcJuz9tqMSUlhWXLlnHZZZfRokULrrzyylznbNiwgZUrV9KnT59c5y1fvtw3Jkfr1t6WjCtWrGDQoEG5xm/atInU1FQ6dOhQVB9JREREpEw6dsyweg18t9qwbh2knzx9zG6DJk3gmniLa+KhXl2wLItWLQ2jxpx99v2DQ63AXovT48Kx4T8EfzcFKzsDYwsi++p7yGpzPzhCz3++FCsVg0REREQEAHtyIrb0s0/1yEk5sq+4iezmf73w9X+k1EhLMyxeAgs+MbmeXryyMdxys8X118HqNTBqjMGywOSTtwZ8wlrK/PnPf+bPf/5znv1r1qxh2bJltGrVinHjxuU61rdvX/79738zffp0OnfuTGRkJADbt29nwYIF1KlTh/j4eN/4evXq0apVK99rduzYEYDs7GwmT54MQL9+/YrpE4qIiIiUTh6PYdt2WLXaWwDasiX3/XHlStCmDbSNt2jVCipG5r1H7tjB4rlxMHmKybU2Z3S09766Y4fAva+27d9EyFdjsad415B1x7TE2flpPNUa+jkyyaFikIiIiIgAYJ1MOf8gwF3/ejy1mhdzNOJPW7YYPvrE8NXX4HR694WFwg03QJ/eFpc3PJ2EduwAz42DV6dZHDzo8e0vDQlrIJk7dy6JiYkAbNu2zbdv7dq1AHTp0oUuXbpc0GvXq1ePoUOHMnnyZHr37k23bt3IyMhg0aJFuFwuxo8fT1BQ7tRw7Nix9O/fnyFDhtC9e3eio6NZvnw5W7dupV+/frmKRyIiIiLlVUaGYd333uLP6tV518q8vCFcE++dAdS4EQV6SKpjB4v27WDjJu/rVa3inWkfsA9YOdMIXjEZx8b3vB0lQirh7PAorqv6gmXzd3RyBhWDRERERASgwIt4arHPsikz01v8+fgTw5atp/dfVg/63GzR7QaoUCH/BLRjB4tePSvz7bJjpSNhDUCJiYl89NFHufatX7+e9evXAxATE3PBxSCAwYMHExMTw5w5c3jvvfdwOBw0b96c4cOHExeXt49fgwYNmDt3LpMmTSIhIYGMjAxiY2MZPXo0AwYMuOA4RERERAKR221Yuy6bpN3mvPeye/Z61/35bpVh46bTLZTB+wDV1Vd7Z/9cEw/Vql3Y/bDdbtEiUJ6/87ixJydinUzBVKiOO6alt0OEMdi3LyFk6XPYfn+wMLtxb7I6Po4Jr+rnoCU/ljH5NXOQonbs2DF/hyClQFRUlK4VKRRdM1IYul7kfGyHfiHsv7diGU++xw0WJrIGGfd8pfZwZciuJMOChYbFi0/3MXc44LqO3iJQk6u8/cvPJ9B+x0RFRfk7hHItkK4FCWyB9rtDApuuFykMXS9SUMsSTJ62bNWrw4hh3lnuWVne9TNzZv/8lpz7/Esvhba/z/5pGgfBwWXngShvsWdCrnbinoiaZLW5j6BflxK0K8G7r3Iszi5P465zjb9CLXGB9jumIPmPZgaJiIiICPY9awhdOAzLeMh5UujMFMb8vuXsNFKFoDIgO9uwLME7C+iHjaf316rlbQPX/UaIqlx2klgRERERkfwsSzCMGpN3rkRKinddzMaNDElJcCrz9LGgIGjW9PfZP9dA7UvL5n2zffsSQheOAHJ/P1b6AUK+fgYLMHYH2a3uJav1IAgK8UeYUggqBomIiIiUc0G/LCTki1FYnmzcMS3JuupWQla+gnXG018msgbOTiNxN+zqx0jlYu3fb/jkU8Onn0HOQ2w2G7RrC7fcbHF1S7DZymYyKyIiIiJyJrfbOyPoXH7Z4v2zalW4pg1cc41Fq5YQHl7G75k9bkKWTuD0Y4Gn5WwbezAZA+ZhqjUs4eDkQqkYJCIiIlJeGYNj3SxCVkwCIPvyG3HeOBGCQsho3ItKqVs5eWBX7r7QElDcbnPehWXdbsPqNd5ZQKvXQE6T6GrVoFcP6NXDIjq6jCezIiIiIiJ/sHETuVrDnc1jj0DvnlaBWieXFfbkxFyt4fJjubOwnTqGu4RikounYpCIiIhIeeRxEfLNszg2fQBAVsu7yerwKFg273GbHVu9drgqX+nHIOVczt7bHDp2sDhyxDsD6JNPDQcPnh7T6mpvK7h2bSEoqPwktCIiIiIiZzpytGDjwsPLVyEIwDpZgCpZIcZJYFAxSERERKS8yc4gdNEjBP36LQaLrOueJLv5X/0dlRTC+XqbX/Unwy9bwP37Y3oVK0KP7tC7l1Vme5qLiIiIiBRG1SpFO64sMRWqF+k4CQwqBomIiIiUI9bJw4R+/AD2gz9i7CFk3vQC7oY3+DssKYSC9Dbf/JP3zyZXwc29La7rCCEhKgKJiIiIiAAYY/hh47nvqQGio72tmMuV7FME/fTxOYcYLExkDW87cSk1VAwSERERKSesY7sImz8I24nfMKGVOdXnNTy1mvs7LCmkgvY2/+ej0KunrfgDEhEREREpRVwuwwsvGxZ9dv6xDw618qzJWZZZR38ldOEI7Ee2c7pUZmGdsWXwfh/OTiO1rmwpo2KQiIiISDlg27eBsI8fwMo8jqdSbU71fR0TVc/fYckFKGhv89Cw8pO0ioiIiIgUxMmThtFPG9Z9DzYbPPygRVQUedbijI72FoI6dig/99RBvywk5KuxWNkZeMKr4bzpBXCmErJ0Alb6Ad84E1kDZ6eRuBt29WO0ciFUDBIREREp4+zbvyT0s8ew3E7cNZqQect0THhVf4clF0i9zUVERERECu/QIcNjIw07d0JYKDzztEXba7zFnvbt4NddkSTtTqNqFW9ruHIzIyg7k5Bv/4Xjx7kAuGq3wXnTC771gDLqd8aenIh1MgVTobq3NZxmBJVKKgaJiIiIlGGO9e8Q/O0ELAyuy64js8eL4Aj3d1hygdxuw7rv1dtcRERERKQwtu8wPP6EIeWw96Gp5ydYNLridLHHbrdo3cpBwwblpAD0O+vYLkIXPoT98FYMFtnxD5AVPzh3scdmx127tf+ClCKjYpCIiIhIWWQ8BCe8QHDiWwBkN+2P87pRYNPtX2mVmmp45lnDmrXnH1veepuLiIiIiJzN2nXe1nAZGVC3Lrw40aJmTd0rB21ZRMiXY35vC1cVZ/f/wx3b1t9hSTHSvwaIiIiIlDUuJyGLn8CxbTEAzvYPk91qIFhKeEqr7dsNT44x7N8PISHwz0ctQkLU21xERERE5Fw+/czwwosGtweaN4N/jbeIjCzn98ouJyHfTsCx6QPv5qWtvW3hIqL9HJgUNxWDRERERMqSU8cJ+2Qo9uREjM2Bs9u/cDXu6e+o5CJ8scTw/IuGrCyoVQueG2f52le0bwcbN8GRo5S/3uYiIiIiImdhjOGNfxvmvOPd7nYD/PMxi+Dg8n2vbB3bTeinD2FP+cXbFq7NfWRdM0QdJMoJ/S2LiIiIlBHWiWTCPhqE7eivmJBIMntNwV2njb/DkgvkchmmvmaYN9+7Hd8Gxoy2qBiZu7d5i+Z+ClBEREREJABlZxsmvmD4Yol3++93wsB/WFjlvFOCfdtiQpeMxso6iQmLIrP7C7jrtvN3WFKCVAwSERERKQNsB38i9KP7sWUcxhNRk8y+r+Opdrm/w5ILdPiIYcxYw6Yfvdt3/x3u/ruFzVa+E1gRERERkXNJSzOMGmNYvwHsNnjsEYuePcr5PbQri+BlzxO88V0A3DEtybzpJUxkDT8HJiVNxSARERGRUs7+6zJCFz2MlZ2Bu9oVZN7yum7sS7EfN3sXuD1yBCpUgKdGWbRvW84TWBERERGR8zhwwPDoE4akJAgLg2efsWjTunzfR1vH93jbwh36GYCs1oPIajtMbeHKKf2ti4iIiJRiQT/OJeSrZ7CMG1eda8js9SqERPg7LLkAxhjmfwyvTjW43VCvLvzrWYval5bvBFZERERE5Hy2bjM8/oThyFGoVg1emGDRsGH5vo+2b1tC6JJRWFnpmNDKZHZ/Hne9Dv4OS/xIxSARERGR0sgYgr+bQvCa6QBkX3kzzhvGgT3Yz4HJhXA6DS+8bFj8hXe783XeBW7Dw8t3AisiIiIicj6rVntbLJ/KhPqXwf9NtKgRXY7vo11ZBC9/keAN7wDgrtWCzB4vYSJr+jkw8TcVg0RERERKG3cWIV8+jePnjwHIajPYO9W/nC+IWlrt228Y9ZRh+w5vX/PB91vc1o9yv8CtiIiIiMj5fPyJ4eXJBo8Hrm7pbQ0XEVF+76OtE78R+unD2A96Fx/NajWQrLbDwe7wc2QSCFQMEhERESlNnOmELhxO0J5VGMuOs8vTuJr083dUcoHWrDWMHW9IS4PKlWHc0xYtmpff5FVEREREpCA8HsPrswz/fc+7fdON8PijFkFB5fde2r7jK0K/GIXlTMWEViLzxom4L+vk77AkgKgYJCIiIlJKWGkHCf3oPuyHt2Ic4WT2nKSez6WUx2P4z7swa7bBGGjcGJ57xiK6PLezEBEREREpgKwsw3MTDV9/490e+A+Lv99ZjmfWu7MIXv4Swevf9m5e0szbFq5iLT8HJoFGxSARERGRUsB2eBuh8+/Dln4AT3g1Mm+ZgafGn/wdllyAkycNz04wLF/h3e7dC0YMswgOLqfJq4iIiIhIAaWmGkaONmzcBHY7PPG4Rfdu5fc+2jqRTOiih7Ef2ARAVst/kNV+hNrCSb5UDBIREREJcPY9awhdOAzLmYYnqh6n+s7CVIrxd1hyAXYlGZ58yrB3Lzgc8PCDFr16lt/kVURERESkoJL3GR77p2HPXqhQAZ4bZ3F1y/J7L23f+Q2hi0d628KFVCLzxgm461/n77AkgKkYJCIiIhIoPG7syYlYJ1MwFarjjmlJ0NbPCPliFJYnG3dMS071ngphlf0dqVyApd8a/jXRcCoToqO9yWvjRuU3eRURERERKaiffzH880nDsWPee+kXJ1pcdlk5vZd2ZxO8YhLBiW96N2vGkdnzZUxFPTAo56ZikIiIiEgAsG9fQsjSCdjSD/j2meAIrKx0ALIvvxHnjRMhKMRfIcoFcrkMM98wvPu+d7tlCxg7xiKqcjlNXkVERERECmH5CsPY8QanEy5vCP83waJatfJ5L22l7vO2hdu/EYCsFn8n69qHwR7s58ikNFAxSERERMTP7NuXELpwBGBy7fcVgi67DmePl8CylXxwclGOHTeMHWdIXO/dvqM/DBpoERRUPpNXEREREZHCmDff8MoUgzEQ3wbGPW0RHl4O7qXz6RphT1pO6OInsDJPYEIiyez2L9wNuvg7UilFVAwSERER8SePm5ClEwBDfimNAewpv4Ax5DtAAtaWLYYnxxgOHYKwUBj5hMX1nfSXKCIiIiJyPh6PYdoMwwcferd79/Kut1keHqrKt2uEowJW9kkA3DWuIrPnJEylS/0VopRSKgaJiIiI+JF975pcN/l/ZAFW2gHsyYm4a7cuucDkonz6meHlSYasbKhd27s+0GX1yn7iKiIiIiJysZxOw/jnDN8meLfvu9fir3eAZZX9++mzdo34vRCUXa8jzl6vQpDawknhqRgkIiIiUpKc6dj3/4A9ORHbvg3Yk9cX6DTrZEoxByZFISvLMHmK4ZOF3u1r28GokRYREWU/cRURERERKQy327BxExw5ClWrQNM4SE2DkaMMm38ChwOefMLihs7l5F66IF0jDm8Fm72EA5OyQsUgERERkWKUM6snp/BjO7wVy3gK/TqmQvViiE6K0qFDhlFPG375BSwLBv7D4s4BYLOVk+RVRERERKSAliV4H6JKOeOZtypVvJ0RjhyFyEiY8KxFs6bl517anpyorhFSrFQMEhERESkqxoPtyA5syeuxJ6/Hvi8RW+q+PMM8lWrjjmmBu1YL3Jc0I+yjQVjph7D+0AoAvM+EmcgauGNalsQnkALI7wnGjZtgzDOG48e9ievYpyzatC4/iauIiIiISEEtSzCMGpM39zl61Ptn5cow7RWL2NhycD9tDLbD2wnavoSgzf8r0CnqGiEXSsUgERERKd88buzJiVgnUzAVqnuLLgWddu9yYjvwI/Z967EnJ2Lf9wOWMzXXEGPZ8EQ39hZ+YlrgqdUCExGda4zzuicJXTgCg5WrIJTTHMDZaaRaAQSI/J5gjKgAGRngMdCwATw33qLWJeUgcRURERERKSS323s/fS5Bdrj00hIKyB+MwXbwJ28BaPsSbMd3F+50dY2QC6RikIiIiJRb9u1LCFk6IddUfE9ETZzXjcTdsGveE04dw77vh98LP+uxHdyM5c7ONcQ4wnFfEoenVkvv7J9LmkJwhXPG4W7YlcxekwlZOgHrjFhMZA2cnc4Si5S4sz3BmO5dy5VmTeHF5y1CQ1UIEhERERHJz8ZN5HqwKj+Hj3jHtWheMjGVCOPBtn/j6QLQGR0kjD0Yd932uBp0JnjFK1gnU9Q1QoqFikEiIiJSLtm3LyF04Qj4w022lX6Q0IUjyOw5GU90Y+z7Er0t35LXYzu6M8/reCpUO134iWmJp/oVYCv8LZa7YVcy6ne+8FlKUqwK8gTjvn3eRW5FRERERCR/R44W7biA9nsXCvv2JQRt/xLbyUO+QyYoDHe9Drgu74qrXkffA4QmOEJdI6TYqBgkIiIi5Y/HTcjSCZy+pT7NwmCA0EUPYRlP3lOr1P+98ONd88dUqg1WEc0Esdm1EGiAKsgTjIdSyuATjFJiFixYQGJiIps3b2bbtm1kZ2czYcIE+vbtm2tcdnY233zzDUuXLmXjxo3s378fy7Jo0KABffr0oX///tjt+f8DwcKFC5kzZw47duzA4XDQrFkzhg8fTpMmTfIdn5SUxKRJk1izZg0ZGRnExsZy2223cccdd2Cz2Yr8OxAREZGyr2qVoh0XcNzZ2PeuIWj7Euw7vsZ26nRVywRH4LrsOlwNb8Bdtz04wvKerq4RUoxUDBIREZFyx56cmKs13B9ZAMaDsex4ajbxzfpx12oOYVElFqcEjiNHzj0ryDeuLDzBKH7xyiuvkJycTFRUFNHR0SQnJ+c7bs+ePQwfPpwKFSoQHx/P9ddfT1paGkuXLmXcuHEsX76c6dOnY/2hSD1jxgwmTZpErVq16N+/PxkZGSxatIjbb7+d2bNn06ZNm1zjd+zYQf/+/cnMzOTGG2+kRo0aJCQkMH78eLZu3cr48eOL7bsQERGRsskYw46d57+vjo6GpnElEFBRcTmx7/7O2wJu5ze51pE1oZVw1e/sLQDVaQtBwed9OXWNkOKiYpCIiIiUO9bJ80zx+J2z63hcf7qlmKORQPfjZsOc/xRsbKl9glH87tlnnyU2NpaYmBhmzpzJSy+9lO+4iIgInn76aW655RbCwk4/TZqRkcGdd97J0qVLWbx4Md27d/cdS0pKYsqUKdStW5d58+YRGRkJwJ133km/fv0YPXo0n3/+OUFBp9PDsWPHkpaWxsyZM+nYsSMAI0aM4N577+XDDz+kR48exMfHF8dXISIiImVQerph4guGb5edf+yDQy3s9hJeh9PjxrNrJUEHdhWs+JKdgX3XCoK2f0HQrmVYWSdPv1R4VdwNuuBq2BX3pa3AfgG9pNU1QoqBikEiIiJS7pgK1Qs2rmJMMUcigSw52TB9ZsESViiFTzBKQGnbtm2BxtWoUYM77rgjz/7w8HDuvvtuHnnkEdatW5erGDR//nxcLheDBw/2FYIAGjZsyM0338z777/P6tWrad++PQC7du1i3bp1tGnTxlcIAnA4HDz00EOsWrWKuXPnqhgkIiIiBbJ9u+GpsYbfkiEoCIYMtqhezfDK1NytmKOjvYWgjh1KthBk376EkKUTcKcfIPT3fZ6Imjiv+0NbNmc6Qb9+620Bl7Qcy5XpO+SJqIGrYVdcDW/AU6uFZvFIQFIxSERERModd0xLTHCFXE9vnclgYSJreJ8Gk3InNdXw1tuG+R+DywU2G/ToDldeCc+/cPbz/PIEo8gZcmb2/HHNoLVr1wLQrl27POdce+21vP/++6xbt85XDMoZn7N9pri4OCpWrOgbIyIiInI2xhg++RReedWQlQ01a8C4sRZXNrYAi2vbGzZu8rZarlrF+2BVSd9P27cvIXThCCB3+zor/SChC0eQ2e1fWBhvAWj3Six3tm+Mp9KluBr8XgC6JA4srakogU3FIBERESl3gjb/z1cIMvy+RtDvzO9bzk4j9TRXOZOVZfjfRzDnHUN6undfm9bwwP0W9S/zXhcVIw2Tp5iAeIJR5I/+97//AXmLOElJSYSHh1O9et5ZkbGxsb4xZ44/89iZLMuiTp06bN68mVOnTuVqVSciIiKSIyPD8OLLhiVfebfbXgOjR1pUrHj6ntlut2jR3E8BAnjchCydwOks8DQLgwFCvxiZ65gnqp53BtDlXfFUbwyWcgApPVQMEhERkXLFvuNrQr5+BoDsht2w79+IlX7Ad9xE1sDZ6Q/tAKRMM8bwzVKYMcuwf793X/36MOR+i9atcid3HTtYtG+H359gFPmjDz74gISEBOLj43O1dgNIT0+nSpX8F7SKiIjwjTlzPJCrpVx+56SlpZ21GFSpUiVsNj0dKwUTFRXl7xCkFNH1IoWh68U/duxw8dCj6fy6y43dDiOGh3PX30Kx2QLrntmzayXuM3LBP/JFG1UHW/PbsF3ZA6KvIEQFIPldafsdo2KQiIiIlBu2fRsIXfQIlvGQfdWfcd4wHowHe3Ii1smUgi0UKmXKph8NU18z/PyLd7tqVRg00OLGrmcv8Pj9CUaRP/j2228ZP348MTExvPDCOXoZlqATJ074OwQpJaKiojh27Ji/w5BSQteLFIauF//4fLHhxUkGpxOqVYNnxlg0jcvkxInM859cwoIO7PKtEXQumdcMx9Woh3fj+PHiDElKkUD7HVOQwpSKQSIiIlIuWEd2EvbRYCy3E9dlnXB2Geud0m/Zcddu7e/wpIT99pthxkzDtwne7bBQGHCHxW39ICxMT/pJ6bF8+XKGDRtG1apVmTNnDtHR0XnGREREkJaWlu/5ObOAcmb7nPlzYc4RERGR8i0z0zDpVcOiz7zbrVvBU6MsoioH5r21lZqMffuXBRprKuRttStSGqkYJCIiImWelXaQsPn3YjlP4L6kKZk9XgabboPKoxMnDG+9bZj/MbjdYLNBzx5wz10WVasGZqIqcjYJCQkMHTqUqKgo3n77bWrXrp3vuLp167JhwwZSUlLyrBu0e/du35gzx5957EzGGPbs2UN0dDTh4eFF80FERESkVNuzx/DUWMPOX7331/+4y+LOAYHZStl2YDOOxDcJ2vYFlnEDedeRzWGwMJE1vN0jRMoANXEWERGRsi0zldCPBmFL248nqi6n+kwHhxY8L2+cTsO77xtuu8Mw93/eQtA18fDWbIvHH7GpECSlTkJCAkOGDKFixYq8/fbbxMbGnnVsq1atAFi5cmWeY8uXL881BqB1a+9syRUrVuQZv2nTJlJTU31jREREpHz76mvDPfd5C0FVomDSixZ3/c0KrEKQ8WDfuZSwD/9G+Lv9cGz9DMu4cdWOx9n6PsDC/KEclLPt7DRSbcSlzNAjsSIiIlJ2uZyEfTIU++FteCpU41TfNyCsdC3wKBfHGMPX38Drswz7f18btkF9GDLYotXVAZSgihRCTiGoUqVKvP3227lm9eSnb9++/Pvf/2b69Ol07tyZyMhIALZv386CBQuoU6cO8fHxvvH16tWjVatWrFmzhmXLltGxY0cAsrOzmTx5MgD9+vUrls8mIiIipYPTaZjymuHjBd7t5s1g7FMBNts+O5OgXz4hOPEtbMd2AWBsQbiu6E52y7vwRF8JgKfGlYQsnYCVfsB3qomsgbPTSNwNu/oldJHioGKQiIiIlE3GQ8jiJ7D/tg4TXIHMW2ZiKsX4OyopQRs3GaZON/zyi3e7WjUYdI9Ft66B2bJCyre5c+eSmJgIwLZt23z71q5dC0CXLl3o0qULO3fuZMiQIWRlZdG6dWsWLVqU57ViYmLo27evb7tevXoMHTqUyZMn07t3b7p160ZGRgaLFi3C5XIxfvx4goJyp4Zjx46lf//+DBkyhO7duxMdHc3y5cvZunUr/fr1y1U8EhERkfIleZ+3Ldzvtyz8/U64++8WQUEBco+dcRTHxvdw/PAutlNHATDBEWTH/YXs5ndiImvmGu5u2JWM+p2plLqVkwd2YSpU97aG04wgKWNUDBIREZGyxxiCl07AsW0xxuYgs/dUPNGN/R2VlJA9ew0zZhoSvN2vCAuDAbdb9P8LhIYGSIIq8geJiYl89NFHufatX7+e9evXA94CT5cuXTh8+DBZWVkA+RaCwNvm7cxiEMDgwYOJiYlhzpw5vPfeezgcDpo3b87w4cOJi4vL8xoNGjRg7ty5TJo0iYSEBDIyMoiNjWX06NEMGDCgKD6yiIiIlELLlhsmTDSkn4RKFeGpURbxbQLjHts6uovgxLcI+nkBltsJgCfyErJb/I3sq26FkIizn2yzY6vXDlflK0soWpGSZxljjL+DKA+OHTvm7xCkFIiKitK1IoWia0YKozxdL461swhZ8TIAmTe9iKtRDz9HVDqVtmvm+HHDW28bPlrgXRPIZoNePbwL2AZUu4oyKtCul6gotYT0p0C6FiSwBdrvDglsul6kMHS9FK3sbO8DVx/M9W43uQrGjrGoEe3n+2xjsP22zlsE+nWpb7e7xlVkt7wL1+XdwFaw+RC6ZqQwAu16KUj+o5lBIiIiUqYE/fyxrxDk7PSECkHlgNNpmDcf3v6P4eRJ77628TD4fot6dVUEEhERERG5GAcOGp5+xvDTz97t22+D++71c1s4j4ugbV/gSHwL+8HNvt2uy64j6+q78cRcDZZyAZEzqRgkIiIiZYZ913JCljwFQFbLf5Dd4u9+jkiKittt2LgJjhyFqlWgaZw3t/vqG3h9luHgQe+4hg1gyGCLq1sq8RMRERERuVirVhvG/8uQmgoRETB6pEX7dn6813am49g8D8f6t7Gl7QfA2ENw/akPWS3+jqlSz3+xiQQ4FYNERESkTLAd2EzopyOwPC6yG/Uiq8Mj/g5JisiyBMPkKYaUlNP7KleGCuGQvM+7Xb0aDLrXotsNYLOpECQiIiIicjFcLsMb/zb8513vduNGMO5pi0su8c+9tpW2H8f6/+D48UOsrHQAPGFVyG52B9lNb4fwKn6JS6Q0UTFIRERESj3r2G5CP7oPKzsDV2xbnN2eBcvm77CkCCxLMIwak3eJy+PHvf8FB8Ndf7P4y60QGqoikIiIiIjIxTp82PD0OO/MfIBb+8ID91sEBxfx/bbHjT05EetkCqZCddwxLcFmzzXEduhnHN+/RdC2z7E8Lu9pUfXIankXrsa9wRFatDGJlGEqBomIiEipZp08TNj8QdhOHcUdfSWZvV4Fe7C/w5Ii4HZ7ZwSdS8VIGHA72O0qBImIiIiIXKx13xueedZw/DiEh8MTj1tc36no77Xt25cQsnQCtvQDvn2eiJo4rxuJu0EX7LuW40h8i6C9q33H3Ze2Iuvqu3HX66iH/0QugIpBIiIiUnplnST04/uxndiDp9KlZN4yA4Ir+DsqKSIbfsjdGi4/h4/Axk3QonnJxCQiIiIiUha53Ya33ja89TYYAw3qw/hnLGpfWjyFoNCFI4DcD35Z6QcJXfggnoga2NO9i4Iay47r8m5kt7wbT82rijwWkfJExSAREREpndxZhC58EPvBnzBhUZzqOwtTobq/o5IicOSIYdHn8MGHBRx/tHjjEREREREpK9xub/u3I0ehahVoGgcnTsAzzxoS13vH9O4FDw61CAkphtn3HjchSycAhj++uvV7cciefhDjCCc77i9kN/8rpmJM0cchUg6pGCQiIiKljzGELHmKoN0rMUFhnOozAxNV199RyUUwxrDhB/j4E8OyBHC7C35uVa0VKyIiIiJyXssSvG2Yz5x9X7kyuFyQng6hofDYwxbduhZfC2Z7cmKu1nBnk9njJdyXdSq2OETKIxWDREREpNQJXvEyjl8+wVh2MntNxnNJnL9DkguUmmpY/IW3CLRn7+n9V/0JevWEN2ZDyuGznx8d7X2aUUREREREzm5ZgmHUmLzrcR4/7v2zenV4+QWLenWLdy1O6+R5+kDnjMs6WaxxiJRHAVsMWrBgAYmJiWzevJlt27aRnZ3NhAkT6Nu3b56xU6ZMYerUqfm+TnBwMD/++GO+xxYuXMicOXPYsWMHDoeDZs2aMXz4cJo0aZLv+KSkJCZNmsSaNWvIyMggNjaW2267jTvuuAObTYuWiYiIlATH+ncIXvcGAM6u43HX6+DniKSwjDH89DMs+MTw9VLIyvLuDwuDbjfAzb0tGjbwJqERFfJPWnM8ONTCbi/ehFVEREREpDRzu70zgs6nTu3ij6Wgrb3VAlyk6AVsMeiVV14hOTmZqKgooqOjSU5OPu85t9xyCzExuXtI2u32fMfOmDGDSZMmUatWLfr3709GRgaLFi3i9ttvZ/bs2bRp0ybX+B07dtC/f38yMzO58cYbqVGjBgkJCYwfP56tW7cyfvz4C/+wIiIiUiBBWz8n+NsJADjbP4TrT7f4OSIpjIwMw5KvvEWg7TtO769fH27pbdH1BggPz13Y6djB4rlx5GlnER3tLQR17KBCkIiIiIjIuXyfmPteOj8pKbBxE7RoXryxeMKqYCw7lsm/L7TBwkTWwB3TsngDESmHArYY9OyzzxIbG0tMTAwzZ87kpZdeOu85t9xyS54iTn6SkpKYMmUKdevWZd68eURGRgJw55130q9fP0aPHs3nn39OUNDpr2fs2LGkpaUxc+ZMOnbsCMCIESO49957+fDDD+nRowfx8fEX+GlFRETkfOx71hCy+J9YGLKa3kF2q3v9HZIU0I6dho8/MSz5EjIyvPuCHXD99dCnt8WfrgTLOntRp2MHi/btyLPQrWYEiYiIiIjkdeqUYfNPsOEHww8b4aefC3bekaPFG5dt71rCPhmOZdzkzFM6847e/L7l7DQSbPk/4C8iFy5gi0Ft27YttteeP38+LpeLwYMH+wpBAA0bNuTmm2/m/fffZ/Xq1bRv3x6AXbt2sW7dOtq0aeMrBAE4HA4eeughVq1axdy5c1UMEhERKSa2lK2EfjIUy52Nq2FXsq57Es5RPBD/czoNS5fBxwu8iWiO2rW9BaDu3aBixYL/HdrtVrE/pSgiIiIiUhplZBh+3Aw/bDRs+AF+2QLu/CfenFPVKkUemk/Qzx8TsmQMlicbd804spv8heBVU7HSD/jGmMgaODuNxN2wa/EFIlKOBWwx6EJ8//33bNq0CbvdzmWXXUbbtm0JDg7OM27t2rUAtGvXLs+xa6+9lvfff59169b5ikE543O2zxQXF0fFihV9Y0RERKRoWanJhM6/FysrHXfM1WR2/z89JRbA9v5mWPCJ4bPFkJrq3We3Q4drvUWgFs3PPQtIRERERETO7eRJw6YfYcNGww8/wNat4PbkHlOjBjRrCs2bWTRtYhj+MOdsFRcd7Z19X+SMIXjVVIJXvwZA9uU34uw2ARyhuP7UB3tyItbJFEyF6t7WcMr1RIpNmSoGvfrqq7m2q1evzvPPP5+n6JOUlER4eDjVq+ddiCw2NtY35szxZx47k2VZ1KlTh82bN3Pq1CnCwsIu8lOIiIiIz6ljhM0fhO1kCu6qDTl18zQICvF3VPIHLpdh+Qr4+BND4vrT+2vUgN49LXreBFWrqgAkIiIiInIh0tJ+L/783vZt23bw/KH4c8kl0LwpNGtq0bwZXHLJmfffFiOGGUaNMZzNg0Otom/D7MoiZMkoHFs+BSCr1b1ktR8Bls173GbHXbt10b6niJxVmSgGNW7cmOeff55WrVpRrVo1Dhw4wKJFi3j99dcZPHgwH374IY0aNfKNT09Pp0qV/Oc9RkRE+MacOR7I1VIuv3PS0tJUDBIRESkq2acI+/gBbEd/xRNRk8y+MyG0or+jKjfcbsPaddkk7TZnXaPnwEHDwk8Nny463V/csuCaNnBzb4v4NlrXR0RERETE7TaFWv8yNdU7Pqft2/YdYP5Qx4mpBc2bQbNmFs2aQs0a577v7tjB4rlxMHmKyTVDKDraWwjq2KGI79tPHSPsk2HYkxMxtiCcncfgatKvaN9DRAqlTBSDunTpkms7NjaWBx54gGrVqvHUU0/x2muv5Zk1VNIqVaqEzWbzawxSOkRFRfk7BClldM1IYZSW68W4XbjfH4HZ/wOEVSb47g8Iib7C32GVG19+5WTC/2Vw8GCqb1+NGjZGPh7O9dcFs/K7bD6Ym0nC8mzfE4lVq1r8+ZZQ+v05hFq11NqhvCotv2NERERESsqyBJOnAFO9OowYhq8Ac/y4t/iT0/Zt5695iz+1a59u+9a8KVSvXvjiTccOFu3bUajC1IWwju0i7KP7sR3fgwmOILPXK7hji299eBEpmDJRDDqbPn368Mwzz7B+/fpc+yMiIkhLS8v3nJxZQDmzfc78uTDn/NGJEycKHriUW1FRURw7dszfYUgpomtGCqPUXC/GEPLV0zi2fIGxh3Cq91Q8jmgoDbGXAcsS8m8fcfCghxGPpFO5Mhw/fnp/yxbeWUDXtgOHwwk49VdVTgXa7xgVpkRERMTfznZvnZICo8YY2rT2Fol+3ZX33Lqx3uJPs6YWzZpBtSJqu2y3e9fxLC6239YR9skwrMwTeCrWIrPPDDzVGhbfG4pIgZXpYlBwcDAVKlQgMzMz1/66deuyYcMGUlJS8qwbtHv3bt+YM8efeexMxhj27NlDdHQ04eHhRfsBREREyiHH6tdw/DgXY9nI7PEinpiW/g6p3HC7vU8tnsvx4xARAT26w829LOrUURs4EREREZE/Ksi99Zq1p3+uV/eMtm9xUKVK6bvPDvr5E0KWjMbyZOOuGUfmzdMwFar5OywR+V2ZLgYlJSVx4sSJXOsFAbRq1YoNGzawcuVK+vTpk+vY8uXLfWNytG7tXchsxYoVDBo0KNf4TZs2kZqaSocOHYrhE4iIiJQvQZs+JGTVVACc1z+Fu0GX85whRWnjJnK1rzibZ8ZAm9ZqfysiIiIicjYFvbe+527oc7NFVOXSV/zxMYbgVdMIXj0NAFfDrmTeOBEcWltdJJCU+iw+PT2dLVu25Nl/4sQJRo0aBUCPHj1yHevbty9BQUFMnz49V+u37du3s2DBAurUqUN8fLxvf7169WjVqhVr1qxh2bJlvv3Z2dlMnjwZgH79tACaiIjIxbDv/IaQr58BIKvNYFxN+/s5ovLnyNGCjUtNK8WJqoiIiIhICSjovfWll5byQpAri5DF//QVgrKuvofMnpNUCBIJQAE7M2ju3LkkJiYCsG3bNt++tWu98ye7dOlCly5dOH78ODfffDNXXXUVl19+OVWrVuXgwYMkJCRw/Phx2rVrx1133ZXrtevVq8fQoUOZPHkyvXv3plu3bmRkZLBo0SJcLhfjx48nKCj3VzN27Fj69+/PkCFD6N69O9HR0SxfvpytW7fSr1+/XMUjERERKRzbvg2EfvowlvGQfdWfyWo7zN8hlTvHjhuWLj13G4scVasUczAiIiIiIqVclahycG996hhhnwzDnpyIsew4O4/BFfcXf0clImcRsMWgxMREPvroo1z71q9fz/r16wGIiYmhS5cuVK5cmQEDBvDDDz+wdOlS0tLSCAsL4/LLL6d3797069cPu92e5/UHDx5MTEwMc+bM4b333sPhcNC8eXOGDx9OXFxcnvENGjRg7ty5TJo0iYSEBDIyMoiNjWX06NEMGDCgeL4EERGRssrjxp6ciHUyBePOIvTbiVhuJ67LOuHsMhasUvxkXCnjdBrm/g/e+a/h5Mnzj4+OhqZ5b5VEREREROR3brdh8RfnH1ea762tY0mEfXQ/tuO7McERZPaajDu2nb/DEpFzsIwxBStTy0U5duyYv0OQUiAqKkrXihSKrhkpjEC5XuzblxCydAK29AO59rsrx3LqzvngCPdTZOWLx2P46mt4/Q3DwYPefQ0bQPt28Oacs5/33DiLjh1UrJO8AuV3TI6oqCh/h1CuBdK1IIEt0H53SGDT9SKF4a/rxeUyjH/O8PVSsFngOce/vJbWe2vbb98T9slQrMwTeCrWIrPPdDzVLvd3WBdNv2OkMALteilI/hOwM4NERESk7LFvX0LowhFA7ozIALbju7EnrcDdsKs/QitX1m8wTJtu2OrtxEt0dbh3oEW3G8Bms2hQ3zB5ism14G10NDw4tHQmqyIiIiIiJSEry/D0M4blKyEoCMY+ZWFZ8OoUF7U9iVQLTeFwZnV+s7dk2NCgUnlvHfTLQkKWjMJyZ+Ou0YTMPtMwFar7OywRKQAVg0RERKRkeNyELJ0AGP6Y8li/7w35dgIZ9TuDLW+LV7l4u3cbps80rFjp3Q4PhzsHWPzlVggJOf230rGDRft28OuuSJJ2p1G1ird9hd1e+pJVEREREZGSkJlpePIpw9p1EOyA58ZbXBNvYd++hO43/Atb+kHfWE9EDZyXPImbUvQgnDE4Vr9GyKqpALgadCGz+/+BI8zPgYlIQakYJCIiIiXCnpyYpzXcmSwMVtoB7MmJuGu3LsHIyr5jxwyz3zIsXAhuD9ht0Ls3/OPvFlFR+Rd47HaL1q0cNGygApCIiIiIyLlkZBj++aRhww8QGgoTn7O4uqV11s4IVvohQheO8K6zUxo6I7iyCPnyKRy/fAJAVst/kNXhEbBsfg5MRApDxSAREREpEdbJlPMPKsQ4OT+n0/DBXPjPu4aMDO++9u1g8CCL2FgVeURERERELlZamuGxJwybf/LOvH9hokXTOOs8nRFM6emMcOo4YZ8Mw578Pcay4+z8FK642/wdlYhcABWDREREpPhlZxL0y8ICDVW/6Yvn8Ri++BJmvWE49Htt7YrLYchgixbNVQQSERERESkKx48bHn7csG0bREbCyy9YNG7kvd8uC50RrGO7Cfv4fmzHkjDBFcjsORl33fb+DktELpCKQSIiIlKsrGNJhH76EPaULb7mCPmVIwwWJrIG7piWJRlemZO43jBtumHbdu92jRpw30CLLp3BZlMhSERERESkKBw5YnjoUcOvu6ByZZj0opWrxXJBOx6EfP44riu6445t782FHKHFFHHh2JLXE7ZgCFbmcTyRl5DZZwae6pf7OywRuQgqBomIiEixsW/7gtAlo7CyTuIJq0J209sIXj0Dg/dJuBw5jROcnUYGdouEALYryTB9huG71d7tChXgzgEW/f4MISEqAomIiIiIFJVDhwwPPmLYuxeqVYPJL1nU/UMb5oJ2PLClHyQ48S1IfAtjD8F9aSvcddvhjm2Hp2oDsEr+Xj5oyyJCvhiJ5c7GXeMqMm+ehomILvE4RKRoqRgkIiIiRc+dRXDCiwRveMe7GdOSzJtewkTWwFO9ESFLJ2Cd0TLBRNbA2Wlk6Vg8NcAcPWqY/aZh4SLweMBuhz694a6/W0RVVhFIRERERKQo7dtvePAhw/4D3ln4r75sEROT977bXeUyjGXHMu58X8dgYSKqk9Xhcey7v8O+eyW29IME7V5B0O4VAHgiauKObYu7bntcda6BsMrF+dHAGBxrZhDy3asAuOp3JvOm/wNHePG+r4iUCBWDREREpEhZJ5IJXfQw9gObAMhqNZCsdg+CzXvb4W7YlYz6nbEnJ2KdTMFUqO5th6AZQYWSmWl4/0P473uGU6e8+65tD4MHWdSpoyKQiIiIiEhR27PH8ODDhpTDcGkMTH7ZomaNfO69XVmEffoQlnHn2yrb1xnhulG4G3bF1agHGIPtyA7su1diT1qB/bfvsaUfwPbTfBw/zcdYNjw1rvIWhuq2x1OziS/HKhLuLEK+fBrHzx8DkNXybrKufUR5mkgZomKQiIiIFBn7r0sJ/XwklvMEJqQSmd0n4L7surwDbfaAXSQ10Lndhi+WwMzZhsOHvfsaN4KhD1g0jVMRSERERESkOOz81TDiEcOxY1C3rrc1XLWq+dx/G0PIV2OwJ3+PCY4g65qhOBLfOn9nBMvCU60hnmoNyW55F2RnYk9OxL57hbc4dGQH9gObsB/YRPDq1zAhkbhrx+Oq2x533XaYijEF+yAed94H85xphC58kKDf1mIsO87rR+Nq2v+ivi8RCTwqBomIiMjFc2cTvPIVgr+f7d2sGUdmz5cLnpAI4C30bNwER45C1SrQNA7s9tMJ5rrvDdOmG3bs9G7XrAH3D7K4/jqw2VQIEinNFixYQGJiIps3b2bbtm1kZ2czYcIE+vbtm+/49PR0pkyZwpIlS0hJSaF69ep07dqVYcOGERERke85CxcuZM6cOezYsQOHw0GzZs0YPnw4TZo0yXd8UlISkyZNYs2aNWRkZBAbG8ttt93GHXfcgc1mK7LPLiIiEui2bjM89KghNRUa1IdJL529JbNj7es4fl6Asexk9pyMu247spv/tfCdERyh3rWD6raDjv/ESjvgmzUUtHsV1v+zd+dxNpf9H8df37PODIPBzFiyJUWyE9mLqJSk3GnXneruZ0l3d4toVbd2InfLrUW6S1GSKCSMlF1pGVsMJctYwjgzZ85y/f74mmHMYoYZs3g/H48efK/zOedc39PXd841n+v6XP4DuDbNw7VpHgDhmHp2YqhOe3viXQ6l3Zwb5+JdMBrHMYmpcFRVsBw4Du/GeMqR1msMoXqdTv7DEpESS8kgEREROSXWoV1EzL4f5/ZVAKS3uIX0zv8Cp6eYe1a6LEowjB1vSE4+2hYbC8OGQK2z4D9vGJYus9vLl4Nbb7G49hrwepUEEikLXnnlFbZv305MTAxxcXFs374911ifz8fNN99MYmIiHTp0oFevXqxbt453332XZcuW8cEHHxAVlfUXQK+//jpjxoyhRo0a9O/fH5/Px6xZs7jhhht46623aNu2bZb4TZs20b9/f9LS0rjsssuIj48nISGBUaNGsX79ekaNGlUkn4OIiEhJ8/Mvhn89aEg5DI0awUvPW1SIzvk7uGv9bLxLXgHA3+1RO5EDhVIZwURXI3jBtQQvuBZ/OIRj1y84t36LK2kJjh0/4ti/Bc/+LbBmMsbpJlSj1ZFkUkfCVc/DuWkeETOHQWbhOpvl24MFhCMqkdZvEuHYc0+pnyJScikZJCIiIifNuXUJ3tkP4kjdZ88i6/EMoXN7Fne3Sp1FCYYRj5ls7cnJMOIxg2WBMeB0Qt8+MOBWi4oVlQQSKUuefvpp6tSpQ82aNXnzzTd56aWXco2dOHEiiYmJDBw4kAceeCCzfdy4cUyYMIGJEycydOjQzPakpCTGjx9P3bp1mTZtGtHR0QDccsst9OvXj5EjR/Lll1/ich0dHj7xxBMcOnSIN998ky5dugAwbNgw7rzzTj7++GN69epFu3btCvtjEBERKVFWrzE8NNyQmmav2n9+tEW5cjl/D3f8uQbvV8MBe7+dYNPri65jDifh6k0JV29KoN3/QdpBnL8vxZW0BOfWb3Ec/BPX70tx/b4UFr9EOKoKVvphju5WdJTFkfSQ00O4Sv2i67OIFDut7RcREZGCC4fwfDeeiE/uxJG6j1BsI3w3faJE0EkIhewVQXkxBrp0gvcnWdw7xKFEkEgZ1L59e2rWPHFpTWMMU6dOJSoqikGDBmV57O6776ZixYpMmzYNY47eVz799FOCwSD33HNPZiIIoEGDBlx99dVs27aNpUuXZrZv2bKFFStW0LZt28xEEIDb7ea+++4DYOrUqSd9riIiIqXB0mWGfz1kJ4LatIYXn8s9EWT99TsRMwZjhdIJ1u9Geqf7T29nIyoQatAD/6VP4rvjaw4PmI2/6yME63XBuCJx+PZiBdOyJYIyWIDj8O7Mag8iUjYpGSQiIiIFYh3eQ8SnA/Es/Q8WhkCTv5Ha/wNMTJ3i7lqp9ONaspSGy821fS1qnaUkkMiZLikpid27d9OyZctspeC8Xi+tW7dm165dbN26NbN9+fLlAHTo0CHb63XqZO8JsGLFimzxHTt2zBbftGlTKlSokBkjIiJSFiUsNjw8wpCeDu0vgmefsYiMzOW7eNpBIj+7x54kF3c+aVc8f+L9gIqSZWEq1yPQ8hbSrnmdw/+3lPQL787fUw/nY2AiIqWWkkEiIiKSb44/VhD5fl9c25ZiXJGkXfYc/kufBHdEcXet1Nq7r3DjRKRsy0jy1K1bN8fH69SpkyUO7ARSVFQUsbGxucYnJSVliT/2sWNZlkXt2rXZvXs3qampJ3MKIiIiJdrX8w2PPm4IBqFrF3jmKSv3fTpDASK+GIZj32+Ey8eT1uc1cEflHFtcXB5CddrnK9SUy/5dQUTKDu0ZJCIiIidmwrhXvIVnyVgsEyZUpT5pV47FVDmnuHtWqm373fD1/LxLxGWoUrmIOyMipcKhQ4cAKF++fI6PZ7RnxAGkpKRQuXLON5GM+JSUlCzxQJaScrm9R2RkZI4xFStWxOHQ3EPJn5iYmOLugpQiul6kIAp6vUz/LI0nnz6MMdD7Sg+jniyPy5VzIsgYQ+jzBzDbvgdPFJ5b/4e3+nmF0e1CZyp2JzinOhzcyZEdgo5jQcXqRF/QHas4VzWVALrHSEGUtutFySARERHJW+p+Ir56GNeWBAACjXrj7/54yZvxVkoYY/jpZ/jwI8O3S+z9gE4kLs7esFZEpLQ4cOBAcXdBSomYmBj2799f3N2QUkLXixREQa+XTz8zvDzW/nLe+yr4130BDh36K9d498q38a58H2M5SLviRUIRNaEEX5/OLg8TMXMYYGEdkxAyR3YSSuv8EKEDB4uncyWE7jFSECXteslPYkrJIBEREcmV488fiJj1TxyHdmCcXvyXjCR4wbVgae+aggqFDAmL7STQr4lH2zu0h0YNYeLbuT/33sEWTqc+cxE5ulrn2JU8x8ppVU/58uWzrBTKKf7YlUY5rS460XNERERKsw8/Mkx4zU6Q9LsWhg62sPIY8zg3zsOT8CIA6V0eInT2xaeln6ci1KAHaVeNxbtgNFbKzsx2Ex2Pv+twQg16FGPvROR0UDJIREREsjMG95r38CS8iBUOEq5Uh7SrxhKObVjcPSt1UlMNs7+Ej6YZ/vzTbvO4oWdPuL6fRd069iCzXl3D2PGG5GP2bI2LsxNBXTorESQitpz2+DlWxl5Bx+73U7duXdasWUNycnK2fYNy2oMo4+/H7juUwRjDtm3biIuLIypKK0RFRKR0M8YwaTJMfNtOBN1yE9w1MO9EkGPnz0R8+SAWhvRmNxJoccvp6u4pCzXoga9+N5zbV2EdTsaUiyVUsxWc4aXhRM4USgaJiIhIVv5DRMwZgWvTPAAC516G/9JR4NUM8ILYu9fwyXTD9BmQMbm+QgXo2wf69rGoXDnrALNLZ4uOHeDHtbB3n71HULOmaEWQiGRRt25d4uLiWL16NT6fL0tCxu/3s3LlSuLi4rIkg9q0acOaNWtYsmQJffr0yfJ6ixcvzozJcOGFFwLw7bffctddd2WJX7t2LQcPHqRz586FfWoiIiKnlTGGN/5reP8D+/jOOyxuuyXv797WoR1EzLgHK5hGsG4n0i8eXvqqJjichGpdWNy9EJFioB09RUREJJNj1y9EvX8trk3zMA43/otH4u/1shJBBbAlyfDs82Gu62947307EVSzBvxzmMUnH1kM/LsjWyIog9Np0bKFxaXd7D+VCBKR41mWRb9+/fD5fEyYMCHLY2+88QYHDhygX79+WWY09+3bF5fLxWuvvZal9NvGjRuZMWMGtWvXpl27dpnt9erVo02bNixbtoxFixZltgcCAcaOHQtAv379iugMRUREip4xhldePZoIGvx/J04EkX6YiOn34Di8h1DVc0nr9TI4NM9eREoP3bFEREQEjMH108d4F/wbK5ROuEIN0q4cS7hak+LuWalgjGHND3at8e+XHm1vcgH0v96iY3ut8BGRvE2dOpVVq1YBsGHDhsy25cuXA9C9e3e6d+8OwMCBA/nmm2+YOHEiiYmJNG7cmHXr1pGQkECjRo0YOHBglteuV68egwcPZuzYsfTu3ZuePXvi8/mYNWsWwWCQUaNG4XJlHRo+8cQT9O/fn0GDBnH55ZcTFxfH4sWLWb9+Pf369cuSPBIRESlNQiHDi2MMM7+wj++/z+Kaq0/wXT0cJGLWP3HuWU84qippfV7ThDkRKXWUDBIRETnTpR/G+/UTuNfZo6Hg2ReTdtloiKhYzB0r+YJBw4JFdhLoyO9usSzo3An6/82iyQVKAIlI/qxatYrp06dnaVu9ejWrV68GoGbNmpnJoKioKCZPnsyrr77KnDlzWL58OVWrVmXAgAEMHjw4x7187rnnHmrWrMmkSZP48MMPcbvdtGjRgqFDh9K0adNs8eeccw5Tp05lzJgxJCQk4PP5qFOnDiNHjuSmm24qgk9ARESk6AWDhtHPGebMA4cDHn7A4orLT/yd3bPwOVxbEjCuCNL6/AdTocZp6K2ISOGyjDGmuDtxJti/f39xd0FKgZiYGF0rUiC6ZqQgKlWswKGfv86yUahj329EfHEfjn2bMZaT9E7/JNDq9tJX9/o08/kMM2fBx9MMu3bZbV4vXHE5XH+dxVlnlY3PT/cYKYiSdr3ExMQUdxfOaCXpWpCSraTdO6Rk0/UiBVGhQiUWLtqfuR/n+Y0MT/8bFiaA0wGPjbTodsmJv7e717yPd8EzAKRe+Qqhc3sUddelmOgeIwVR0q6X/Ix/imRl0NatW9m/fz9xcXHUqKFMuYiISHFzbpxLcNGzRB7ckdlmvBUh4MMKBwiXjyet18uEa7Ysxl6WfLt3G6Z9avh8JqQcttsqVYLr+lr06Q2VKpWNJJCIFIzGPyIiIiXLogTDuAl/sWvX0TnwHg+kp4PbDU89btGp44m/uzs3L8SzcDQA/k73KxEkIqVagZJBe/bsYfny5VSrVo2WLbP/smjVqlWMGDGCrVu3Zradf/75jB49mnPPPffUeysiIiIF5tw4l4iZw4Csi4Et/wEAQrENSb32LYiqfPo7VwKEQoYf15I5Y7BZ0+z7+2zcZJjyseHr+RAK2W11atul4HpcCl6vkkAiZZHGPyIiIqXPogTDiMcMx49/0tPtP2/sT74SQY7kdUTMuh/LhAlccC2B1ncUQW9FRE4fR0GCZ8yYwf3338+WLVuyPZaUlMTAgQPZunUrxhgqVrT3Gfjll18YMGAA+/btK5wei4iISP6FQ3gXjOb4gVAGA1ipf52x+wMtSjBc198w9D7Dk6PsP6/rb1iUYDDGsHyF4b5/hbl9oGHOXDsR1LwZPPdvi8nvWlx1paVEkEgZpvGPiIhI6RIKGcaOz3tHjC/n2HF5sVJ2EzH9HqyAj2Ctdvi7Pa5S2iJS6hUoGbRixQq8Xi+XX355tsfGjx9Pamoq1atXZ+bMmSxdupRly5ZxySWXsH//fiZPnlxonRYREZH8cW5fhSNlJ7kNWyzAkbIT5/ZVp7NbJULGjMHk5Kztyckw4jE7KfTPBwwrVtqby3a7GP77usWrrzjo0N7C4dBgUKSs0/hHRESkdPlxLdm+3x9v9247LlcBHxEz/g9Hyk7Clc8m7aqx4HQXZjdFRIpFgZJBmzdvpnHjxkRFRWVpDwQCzJ8/H8uyeOihh2jQoAEAFSpU4NlnnyUyMpLFixcXXq9FREQkX6zDJxgJFTCurMjPjMFduyDCC3+7Dj76n8WTjzto1FAJIJEzicY/IiIipcvefC7MzTXOhImY/SDOXb9gImNI7fPaGVtFQUTKngIlg/bu3Uv16tWztf/888+kpaURERHBxRdfnOWxChUq0LRp0yx1tEVERKToWfu24F6Tv5npplxsEfemZMnPjEGAJx6HoYMdVK+uJJDImUjjHxERkdLF4857wleGKrlsl+pZ/BKu3+ZjnG5Se7+KqVS7EHsnIlK8XAUJTk9PJyUlJVv7jz/+CNibpXo8nmyPV6lShdTU1JPsooiIiBRI2kE8S/+D+4f/YYWDmbsF5ZTOMFiY6HhCNVudzh4Wu/zOGExNVRJI5Eym8Y+IiEjpYIzhmwXw0pgTx8bFQbOm2dtdaz/Gs/JtAPw9RxOu2bKQeykiUrwKlAyqVq0a69evJxwO43AcXVT0/fffY1kWzZs3z/F5KSkpxMTEnFJHRURE5ATCQVw/TcP73Tis1P0ABOt1IVi3I94F/z4SdHSmnDmSHvJ3HQ4O5+nubbEIhQzffgeT3z+1GYMicmbQ+EdERKTk27/f8NIYw8IE+7h6NdixEywLTA5f++8dbOF0Zp305dz6Hd75TwHgv2gwwYa9irrbIiKnXYHKxLVt25adO3fy+uuvZ7b98MMPfPvttwDZSiRk+PXXX6lWrdopdFNERETy4tz2PZHvX0vE/CexUvcTrlyf1L7/Je2a1wm2uNne9LRC1p/FJjqetKvGEmrQo3g6fRqlpho+mW646VbDiEcNm7ec+Dm5zRgUkTOHxj8iIiIl2zcLDbcMsBNBTif8fYDFh+9bPPOURVxc1l97xsXBM09ZdOmcNRFk7d1ExBfDsEyIQKOrCLT7v9N5CiIip02BVgbdcccdzJw5k/HjxzNt2jQqVarEhg0bCIVCNGvWjNatW2d7zg8//EBycjI9e/YstE6LiIiIzdq/FW/CC7h+mw+A8VYkvf0QAk3/Bk53ZlyoQQ9cra/j0M9fYx1OxpSLtUvDlfEVQXv22kmgGZ/DwYN2W3Q09LkaalSD517M/bk5zRgUkTOLxj8iIiIl0/6/DC+PNSxYaB/Xrw8jH7Zo0MD+/t6lM1x1ZSUWLtrP3n32iv9mTcn2/d7y7SVy+j+w/IcI1WyF/9Kn7SVFIiJlUIGSQfXq1WPcuHE8/PDD/Pnnn/z5558A1K9fn5deeinH50yaNAmATp06nWJXRUREJJM/Bc+y13CvnowVDmAsJ4FmN5B+0SCIrJTjUyyHk1CtC09vP4vJb5sNUz4yzJsPwaDdVrMG/K2fxRWXQWSkPcCrUMEwdrwhOfnoc+Pi7ETQ8TMGReTMo/GPiIhIybNwkeHFMYa//gKnA265GW67xcLtPq70m9OiZYs8vtMH0oiYMQjHwe2EK9Ymtfd4cGXfC1BEpKywjMmpembe/H4/q1atYt++fVSrVo2WLVtmqaF9rG+++YZwOEznzp1z3Fz1TLF///7i7oKUAjExMbpWpEB0zZyBwiFcv3yKZ8krOHx7AQjW6Yi/60OYKufk+dSyfr0YY1i+AqZ8bFix8mh7kwug//UWHdtnnwkI9j5CP64lzxmDZ6qyfs1I4Spp10th7tmj8U/BlaRrQUq2knbvkJJN18uZ7cABw8uvGOZ/Yx+fXQ8eedii4Xk5f3fP83oxYbyz/4V7/ZcYb0V8N3yIqVyviHoupYXuMVIQJe16yc/4p0ArgzJ4vV7at2+fr9hLLrnkZN5CREREjuP4fTnehc/iTE4EIBxTF3+XhwjV63JGlzJIT7dXAH308dG9gBwOuzRE/79ZND4/78/GnjF4GjoqIqWWxj8iIiLFK2Gx4cWXDfv226uBbroRBtxq4fGc3DjI8914OxHkcJHWe5wSQSJyRjipZNCJ+P1+Dh48SExMDC5XkbyFiIjIGcM68Ie9L9DGuQAYbzTp7f6PQPMbwXnmzjo/cMDw2efw6XTD3n12W2QkXNULrrvWokb1MzdBJiKnl8Y/IiIiRePgQcPYcYa5X9vHdevCiIctGjU8+e/6rl8/w7PsdQD83Z88Y0ppi4gUaKSSkpLC5s2biY6Opl697BnzpKQkRo0axbJlywiFQrjdbrp27cqIESOIj48vtE6LiIicEdIP41n2Bu7V72KFAhjLQbDp3/C3HwqRhVf+qLT5/Q/DR1MNX34Ffr/dFlsV+l1ncVUviI5WEkhECofGPyIiIsXn2yWGF16yJ345HHBjf7j9Nguv9+S/7zv+WIF37mMApF94F8EL+hZWd0VESrwCJYM+++wznnnmGR5++OFsg6Hdu3dz0003sW/fPjK2IUpPT2fu3LmsW7eOzz77jKioqMLruYiISFllwrh++QzPkjE4Du8BIFi7HeldhhOOPbeYO1c8jDGs/QmmfGT49jvI2PHw3AZ2KbhLLgaXS0kgESlcGv+IiIicfgcPGV4Zb5hjF0agTm17b6ATlX8+EWt/EpGfD8EKBwicexnpHe4thN6KiJQeBUoGLV++HKfTydVXX53tsQkTJrB3715iYmIYPXo0F154Idu2bePxxx9n7dq1fPDBBwwcOLDQOi4iIlIWObavwrtwNM5dvwAQrlgbf5cHCdW/5IzcFygYNCxKgCkfGxLXHW1v3w76X2/RojlYZ+DnIiKnh8Y/IiIip9eS7wzPv2TYu9deDdT/erhjwMmtBjLhEM7fl2MdTsa4IvAueh4r7QChak3x9xwNlqMIzkBEpOQqUDJow4YNnH/++VSqVClLezgcZvbs2ViWxf3330/Xrl0BaNiwIePGjaN79+7Mnz9fgyEREZFcWAe340l4EfeGrwAwnnKkt72HQItbwFX29gUKhQw/roW9+6BKZWjWFJzOowO8w4cNX8yGqdMMO3fZbR4PXNYTrr/Ook4dJYBEpOhp/CMiInJ6HDpkGPeq4cs59nHtWvZqoAsan9z3fufGuQQXPUvkwR1Z2sORMaRdPQHcEafaZRGRUqdAyaC9e/fSuHHjbO3r1q3j0KFDuN1uLr/88iyPxcfH06xZMzZu3HhqPRURESmLAj48y/+Le+U7WCE/Botgk+tIbz8UU65qcfeuSCxKMIwdb0hOPtoWGwvDhkDDhnYCaOYsOHzYfqxSJejbx+KaPhBTSUkgETl9NP4REREpet8vMzz/giF5j10M4fp+cOcdJ783kHPjXCJmDgNMlnYDWKn7cfy5mlCDHqfcbxGR0qZAyaDU1FTS0tKyta9ZswawZ8KVK1cu2+Px8fH88MMPJ9dDERGR0iocwrl9lV2WoFwsoZqtwOG0HzNhXIkz8Sx+Gcfh3QCEzmqDv+twwnGNirHTRWtRgmHEYyZbe3IyjHjM4LAgfOThOrXh+r9Z9LyUU9okVkTkZGn8IyIiUnRSUgzj/2OYNds+PusseOQhi6ZNTuG7fziEd8Fojk8EAViAwcK7cDS++t2Ojs1ERM4QBUoGVa1alU2bNmVrX758OZZl0axZsxyfl5qaSsWKFU+uhyIiIqWQc+NcvAtG40jZmdkWLl8N/8XDMeXi7H2Bdq612yvUxN/5QUINLi3T+wKFQvaKoLyEDbRoDjdcb9GuLTgcZffzEJGST+MfERGRorF8heHZ5w27k+0h0N+us1cDRUSc2vd/5/ZVWcZgx7MwWId24ty+ilCtC0/pvURESpsC7ZTWqlUrtm3bxqeffprZtnXrVhYuXAhA586dc3zehg0biI+PP/leioiIlCIZZQms4wYhVspOImbeS9SUG3DuXItxR+HveB++AbMIndujTCeCAH5cS5bScLm5/TaL9hdZSgSJSLHT+EdERKRwHT5seO6FMP98wE4E1awBr75iMWSQ45QTQQDWodwTQVniDudjYCIiUsYUaGXQgAED+PLLLxk5ciSffvoplStX5vvvv8fv93P22WfTqVOnbM/ZuHEjf/zxB/369Su0TouIiJRYx5QlOH4ok3FsgOD515DecRimfNzp7V8xMcawanXeq4Iy7N1XxJ0REcknjX9EREQKz4qVhtHPG3bbVbK57lq4e6BFZGThTAJzbluK+7tx+Yo15WIL5T1FREqTAiWDmjRpwpNPPsmoUaNYuXJlZnvlypV56aWXsHKY0Tx58mSAHAdKIiIiZc2JyhKAnRQKNu5zRiSC9u83zP4KZn5h+GN7/p5TpXLR9klEJL80/hEREcm/UMjw41p7cleVytCsKTidFj6fYcJrhhkz7bgaNWD4gxYtmhdOEsg68AfeRc/j2jQPyJiWl31yXsZjJjre3s9VROQMU6BkEEC/fv3o3LkzCQkJ7Nu3j/j4eLp370758uVzjG/YsCHDhw+nQ4cOp9xZERGRki6/5QbKclmCcNiwajXMmGlY/C2EQnZ7ZCQYAznsxZ4pLs4eNIqIlBQa/4iIiJzYogR7f9Bjy0LHxsKVVxi+/Ap27rLbrr0G/nFXIa0GCvjwLP8v7pVvY4XSMZaTQLP+hOIvIGLOI0eCjlYnyEgP+bsOB4fz1N9fRKSUKXAyCCA+Pj7fZQ9uvPHGk3kLERGRUim/5QbKYlmCPXsNs7+EmbMMO3YcbT+/EfS+yuKSrrBiJYx4LPdycfcOtnA6tVeQiJQsGv+IiIjkblGCyfE7fnIyvDPJ/nv1ajD8IYuWLQrhu74xuNbPxpPwYmZVhmCtdqRfPJxw1XMBSPNEEbnoWTh4dGBiouPxdx1OqEGPU++DiEgpdFLJIBEREcnOOrwH95r384wpa2UJQiHD8pXw+UzDd99BKGy3ly8HPXvAVVdanFP/6ICvS2d45imyzRqMi7MTQV06KxEkIiIiIlJahEL2iqC8REbC2/+F6OhT/67v2PUL3gX/xvnnagDCFWri7/IQoXO6wzHlW0MNeuBqfR2Hfv4a63AyplysPQbTiiAROYMVKBk0fPhwWrVqxXXXXZftsfnz51OjRg0aNWqU7bFx48axcOFCPv3005PvqYiISEl1ZGaa95unsdL+wuAAwoCFVUbLEuzebZj1JXwx27Br19H2JhfYq4Au7gIRETkP9rp0tujYgRzriYuIlCQa/4iIiOTtx7VkmeSVk9RU2LjJomWLk38fy7cXz7djcf38CRYG44okve1dBFrdDi5vzs9xOAnVuvDk31REpIwpUDJo+vTpADkOhgYNGsQ111zD6NGjsz22Y8cOEhMTT7KLIiIiJZd1OBnv/KdwbfoagFDV8/D3fAbr4Ha8C0ZjHSlbAKW/LEEwaFi63F4FtHQZhI+sAoqOhst72quA6tXNX0LH6Ty1waCIyOmg8Y+IiEje9u4r3LhsQgHcP/wPz9L/YPkPARBoeCXpne7HRFc7yRcVETkzqUyciIjIyTAG17ov8C54BivtAMbhIr3tPwhceCc4PRDfGF/9bji3ryr1ZQl27jR8MdvwxWzYs+doe/Nm9iqgLp3A69WqHhERERGRM02F6LxLxGWoUrngr+1M+hbvwtE49m0GIBR3Pv6LRxCu2bLgLyYiIkoGiYiIFJSVshvv10/g2rwAgFBsI/yX/ZtwbMOsgaW4LEEwaFjyvb0KaPkKMEfGeJUqwuWXwVW9LGrXVgJIRERERORM9Wui4ZXxJ46Li7PLQueXtX8r3kXPZY63wpGVSe84jGDjvqVycp2ISEmhZJCIiEh+GYMrcYZd/s1/EONwk97uHgJtBoLTXdy9O6FQyLB6jclzn57tfxq+mGWY/WXWUg6tWtqrgDp1AI9HSSARERERkTNVerrhnfcM//vALh1dvjykpOQef+9gK3/7g6YfxrP0Ndyr38MKBzAOF4HmN5He7v8gokLhnYCIyBlKySAREZF8sA7twvv147i2LAIgFN8Yf49/E449t5h7lj+LEgzjJvzFrl1HyzjExsKwIdD+Ili8xF4FtHLV0edUjoErLrdXAdWsqQSQiIiIiMiZbsNGwzOjDb/Zldu4tDsMG2Lxw48wdrwhOflobFycnQjq0vkEYwkTxvXr53i+fQnHYbsudbBOR/xdH8ZUqV9EZyIicuZRMkhERCQvxuD6ZTreRc9i+Q9hnG7SLxpMoPXfwVE6fowuSjCMeMwAWet5JyfDiMcMUVHg89ltlgVtWsPVV1l0aA8ul5JAIiIiIiJnumDQ8N77MGmyIRSCSpXgX/dZdO1ijxe6dIaOHeDHteRZieB4jh1r8S54BufOtQCEK9bG3/VhQmd3tQcnIiJSaErHb7FERESKgXVoB955j+NKWgxAKL4J/p7PEK7aoJh7ln+hkGHs+Lw3dfX5oHJluKoXXHmFRfXqGnSJiJR0xhjmzZvH5MmT2bJlC4cOHaJatWq0bduWO++8k1q1amWJT0lJYfz48cydO5fk5GRiY2Pp0aMHQ4YMoXz58jm+x8yZM5k0aRKbNm3C7XbTvHlzhg4dSpMmTU7HKYqISAmxebPh6WcNGzbYx107w/33WcTEZB03OJ0WLVvk7zWtlN14vh2D+9fPADDuKNLb/oNAy9vA5SnE3ouISAbLGJP3b4iO0bBhQ6xTyMonJiae9HNLu/379xd3F6QUiImJ0bUiBaJrpogYg+vnaXgXPY+VnoJxekhvP4RAqwGlZjVQhtVrDEPvO/GP+jEvQpvWjtPQIylNdI+Rgihp10tMTMwpv0ZJHv88++yzvPPOO8TGxtKtWzfKly/PunXrWLJkCVFRUUyZMoVzz7VLmfp8Pm688UYSExPp0KED559/PuvWrWPx4sU0atSIDz74gKioqCyv//rrrzNmzBhq1KhBz5498fl8zJo1C7/fz1tvvUXbtm3z7F9JuhakZCtp9w4p2XS9nF6hkOHDj+CtdwyBAERHwz+HWXS/hJP/+RhMx73mPTxLX8MK2OUJAudfTXrHf2LKxxVi73W9SMHpmpGCKGnXS37GPwX+jVYBckdZnMogSkRE5HSxDv6Jd96juLZ+B0CoejPSejxT6mpVB4OGH36E9/6Xv5/bfx3Qz2kRkZyUxPFPcnIykyZNombNmnz++edZVva8++67jB49mnfeeYfRo0cDMHHiRBITExk4cCAPPPBAZuy4ceOYMGECEydOZOjQoZntSUlJjB8/nrp16zJt2jSio6MBuOWWW+jXrx8jR47kyy+/xOUqXRMkREQk/7ZtMzzzrOGXX+3j9hfBg/+yqFolj59v4RDO7auwDidjysUSqtkKHE77MWNwblmId+GzOP7aBkCoWlP8Fz9CuHqzIj4bERGBAiaD1q1bV1T9EBERKV7G4PrpY3s1UMCHcXpJ73AvgZa3Hh3AlHAZCaAFCw2LFsNff+X/uVUqF1m3RERKrZI6/tm+fTvhcJiWLVtmK/HWtWtXRo8ezb59+wA7mTV16lSioqIYNGhQlti7776b999/n2nTpjFkyJDMBNann35KMBjknnvuyUwEATRo0ICrr76aKVOmsHTpUjp27FjEZyoiIqdbOGyY9gm8/l9DejqUKwf3Dra4/LK8Jzo4N87Fu2A0jpSdR1+rfDX8Fw8nXOUcvAufzSy/HS5XlfSO9xM8vzdYqk4gInK6aCqXiIic8awD2/HOG4lr21IAQjVa2KuBKtcr5p6dWDBo+HEtfLMgewKoYgXo1AkWfwsHDuT+GnFx9uauIiJSOtSpUwe3283q1atJSUnJkhBatGgRAO3atQPsVT67d++mY8eO2UrBeb1eWrduzfz589m6dSt169YFYPny5QB06NAh23t36tSJKVOmsGLFCiWDRETKmO3bDf9+zh5fALRpDQ8/aBEfl/dqV+fGuUTMHAZkXU1rpewkYua9YDmwTBjjcBNoeSvpbf8B3pz3qxMRkaKjZJCIiJy5TBjX2o/wJrxorwZyRZDecRiB5jeX6NVAGQmgBQsNCxOyJ4A6d4ZLulq0aA4ul8VFbQ0jHjNYFuRU7ejewRZOp8rEiYiUFjExMdx33308//zzXHHFFVxyySWUK1eODRs28P3333P99ddz8803A7B161aAzETP8erUqZMZlxGTlJREVFQUsbGxucYnJSUV7kmJiEixCYcNn30Or71uSE2DyAgY9H8WV1+Vj7Kn4RDeBaMBw/GRmccmTLBeF/xdH8bE1C30/ouISP4oGSQiImck66/f8c4diesPe/ZzqGYr0no8XWIHJ6FQ1hVAx+5RWLECdO4EF3e1aNnCTgAdq0tni2eegnETLHbtCme2x8XZiaAunZUIEhEpbe644w7i4uJ47LHH+PDDDzPbW7RoQe/evXG73QAcOnQIIFs5uQwZ7RlxACkpKVSunHP90Iz4lJSUPPtXsWJFHA6V/pH8yc+GxyIZdL0Urj93hHj08cMsXRYAoE1rF08/WZ6zzsrf5LjwliWEjikNlxvvxUOJrNfilPp6MnS9SEHpmpGCKG3Xi5JBIiJyZjFh3D98gGfxy1jBVIwrkvRO/yTQ/MYSV686MwG00LAoIWsCqEIF6JJHAuh4XTpbXHVlJRYu2s/effYeQc2aohVBIiKl1H/+8x/+85//MHjwYPr06UOFChVITEzk2Wef5dZbb2Xs2LH06NGj2Pp3IK/6pCLHiImJYf+xX3JE8qDrpfAYY5g1G8ZNMPh84PXCP+6yuPaaEA7HQfL7Mbt2biEiH3GHd24hWOn8U+pzQel6kYLSNSMFUdKul/wkppQMEhGRM4a1fysRc0fi3L4SgNBZbezVQJVqF3PPjjo2AZSQAPuOSwB17mgngFq1PHEC6HhOp0XLFkr+iIiUdt9//z2vvPIKAwYM4B//+Edme6tWrXjjjTfo1q0bo0ePpkePHkRHRwO5r+TJaM+IA3v1z7ErhXKKz22lkYiIlHx79hiee9Hwvb1lKhc0hkcetqhdq2BjBevgnzg3zc9XrCmXvfSoiIicXkoGiYhI2RIO4dy+CutwMqZcLKGarcCycK95H8+3Y7CCaRh3FP5O9xNs1r9IVwNlJHZOtBInI27BIsOiRVkTQNHRR1cAnUwCSEREyp5FixYB0LZt22yPVa5cmfPOO481a9awb9++E+7xk7GnUEYc2PsLrVmzhuTk5Gz7Bp1oDyIRESm5jDHMnQdjxhlSUsDjhoF3WFzfrwAVA4zBseMH3Kvfw7VxHpYJ2c2Qbc8gu93CRMfb4zIRESlWSgaJiEiZ4dw4F++C0TiOqVkdjqqK8Ubj3L8FgGCtdvh7jMJUPKtI+7IowTB2vCE5+WhbbCwMG2KXbAuFDGt/OlICLocEUOdOcHEXi9atlAASEZGsAgF7X4d9+/bl+HhGu8fjoW7dusTFxbF69Wp8Ph9RUVGZcX6/n5UrVxIXF5clGdSmTRvWrFnDkiVL6NOnT5bXXrx4cWaMiIiUHvv2GV542bD4W/u44XkwYrhFvbr5HGuE0nFtmIt79Xs4d/2U2Rys3Y5QtSZ4lk88khAymY+ZI+khf9fh4MjfHkQiIlJ0lAwSEZEywblxLhEzh8Exgw8Ay7cHh28PxunBf/EjBJv8DayiTa4sSjCMeMxka09OhhGPGdpeaNi0yV4xlCE6Gjp1hEuOrAByu5UAEhGRnLVs2ZL333+fd999l549e2Yp8TZ9+nS2bt1K48aNM0u59evXjwkTJjBhwgQeeOCBzNg33niDAwcOMGjQIKxjfjb27duXt99+m9dee41u3bplvv7GjRuZMWMGtWvXpl27dqfpbEVE5FR9s9Dw0suGAwfB5YIBt1rcfGM+J52l7se99mPcP3yA4/BuAIzTQ7DRVQRa3Eo49lwAwvEX4F0wGuuYiXkmOh5/1+GEGhTfHnYiInKUkkEiIlL6hUN4F4zm6Nyzoyzs9JCJqEjwguuKPBEUCtkrgvKybLn9Z/nyR1YAdbVorQSQiIjk02WXXcaUKVNYvnw5PXr04JJLLqFChQqsX7+eJUuW4PF4eOSRRzLjBw4cyDfffMPEiRNJTEykcePGrFu3joSEBBo1asTAgQOzvH69evUYPHgwY8eOpXfv3vTs2ROfz8esWbMIBoOMGjUKl0tDSRGRku6vvwxjXjHMX2Afn1PfXg3U4JwTjzscezbiXjMZ16+fY4X8AITLVSXQ7EYCTa+HqMpZ4kMNeuCr3y17yW6tCBIRKTH0DV5EREo95/ZVWUrDHc8CrMPJOLevIlTrwiLrRzhsmDsva2m43PzjLri+n6UEkIiIFJjT6eStt95i0qRJfPnll8yaNYtAIECVKlW48sorufvuuzn33HMz46Oiopg8eTKvvvoqc+bMYfny5VStWpUBAwYwePDgLKXjMtxzzz3UrFmTSZMm8eGHH+J2u2nRogVDhw6ladOmp/N0RUQkD7ntU7r4W8MLLxn27QenA265GW675QTjDxPGuWUx7jXv4dr63dH3iDufQMvbCJ53GTg9uT/f4SzS8ZaIiJwaJYNERKTUsw7tyl/c4XxkafLJGMPOnZC4HtatMySug/UbwOfL3/Pj45UIEhGRk+fxeLjzzju588478xUfHR3N8OHDGT58eL7fo3fv3vTu3ftkuygiIkUsp31Kq1aBs84y/PCjfVy3Lox82KJhwzzGHgEfrl8+w7NmMo79SQAYy0HonO6kt7yVcI2WRV5hQUREip6SQSIiUqo5ty3D/d34fMWacrEn/T5795qsiZ/18NeB7HFuNxzZ1ztPVSqfOEZERERERCQnue1Tumev/Z9lwQ394Y4BFl5vzokc6+CfuH/4APdPU7H8BwEwnvIEmvQj0PwmTMWaRXoOIiJyepXYZNCMGTNYtWoVP//8Mxs2bCAQCDB69Gj69u2bY3xKSgrjx49n7ty5JCcnExsbS48ePRgyZEjmxqnHmzlzJpMmTWLTpk243W6aN2/O0KFDadKkSY7xSUlJjBkzhmXLluHz+ahTpw7XX389N954Iw6Ho9DOXURETsz663e8CS/g2jQPyNgtKPueQRmPmeh4u2Z1Phw8ZFi/HhLXQeI6+++7c1hU5HJB/bOhUUNoeJ5Fw4ZQ6yxD/5vJs1RcXJxdvkFERERERKSg8rNPaaVKcPdAC6fzuBGSMTh2/IB79Xu4Ns7DMiEAwpVqE2hxK4HGfcBTrmg6LiIixarEJoNeeeUVtm/fTkxMDHFxcWzfvj3XWJ/Px80330xiYiIdOnSgV69erFu3jnfffZdly5bxwQcfZKuD/frrrzNmzBhq1KhB//79MzdEveGGG3jrrbdo27ZtlvhNmzbRv39/0tLSuOyyy4iPjychIYFRo0axfv16Ro0aVSSfg4iIHCf9MJ5lb+Be/S5WKICxnASaXk+o2gVEzBlB2IDDOjowChsLywJ/1+E5bl6ammrYsDFr4uePHH7kWBbUrWMnfs47z6JRQzsRlH2WncWwITnP0stw7+AcBmUiIiIiIiL58OPavCefAezfb8e1bHGkIRTAtXEu7tXv4dy5NjMuWKsdgZa3Ejq7C1ia6CwiUpaV2GTQ008/TZ06dahZsyZvvvkmL730Uq6xEydOJDExkYEDB/LAAw9kto8bN44JEyYwceJEhg4dmtmelJTE+PHjqVu3LtOmTSM6OhqAW265hX79+jFy5Ei+/PJLXK6jH88TTzzBoUOHePPNN+nSpQsAw4YN48477+Tjjz+mV69etGvXrrA/BhERyWDCdh3rJWNwHN4DQLBOe9K7PEy4agMWJRjmr4jiwQtGUy3y6B5Cu1LjeeGXh+nW+lIuqmP4bbOd+Mko97Z1G4TD2d+uZg1oeGTFT6OGcG4DiIrKXwKnS2eLZ54iW/3uuDg7EdSlsxJBIiIiIiJycvbsOTrxzEGIllVWUTUimT1psaze24ow9iS4vfuA1P24f5qKe83/cBzeDYBxegg2vJJAy1sJx55XHKcgIiLFoMQmg9q3b5+vOGMMU6dOJSoqikGDBmV57O677+b9999n2rRpDBkyBOvIZneffvopwWCQe+65JzMRBNCgQQOuvvpqpkyZwtKlS+nYsSMAW7ZsYcWKFbRt2zYzEQTgdru57777+P7775k6daqSQSIiRcSxfTXehf/GuesXwC5h4O/yEKGzLwbLyiyTkJx8KQt3XJLjYCjhKYMxEAplf/3YqlkTPw3PgwoVTi1h06WzRccO9my8vfvsPYKaNUUrgkRERERE5KQYY/h+KUx8xz6+pPq8bJPhdqbG8/zPw0k6VI92ye9T7r8zsYJpAITLVSXQ7AaCTa/HRFUpjlMQEZFiVGKTQfmVlJTE7t276dixY7ZScF6vl9atWzN//ny2bt1K3bp1AVi+fDkAHTp0yPZ6nTp1YsqUKaxYsSIzGZQRn3F8rKZNm1KhQoXMGBERKTzWwT/xLH4J9/rZgL2ZaXq7ewg0vxlcnsy4Y8skhHGycu+F2V4rGLT/rFjBTvwcu89P1SpFk6BxOq2jZRlERERERERO0tqfDK+/aVj7k33crfo8Xmh9H5C1PHV8xC5eaj0MywL+tNtCcY0ItLyN4LmXZxlHiYjImaXUJ4O2bt0KkJnoOV6dOnUy4zJikpKSiIqKIjY2Ntf4pKSkzLaMv2c8dizLsqhduzY///wzqampREZGnuSZiIhIpoAPz4q3cK98GyuYhsEi2OQ60jvcm+MMtu1/5r15aoahg6HftVbmSlEREREREZGSbPNmwxsTDUu+s489HujXN8Sg9NEQMDiOG9pkDHUMEKrfnfRWtxGu2eroAyIicsYq9cmgQ4cOAVC+fPkcH89oz4gDSElJoXLlynnGp6SkZIkHspSUy+09lAwSETkFxuBaNwvP4pdwpOwEIFSzNf6LhxOOOz9b+G+bDZ9ON3z5Vf5e/pz6SgSJiIiIiEjJt2OH4a13DXPmgjHgdMAVV8Dtt1pU968hcuouyGNoYwGBlrcQPqv1aeuziIiUbKU+GVRaVKxYEYfDUdzdkFIgJiamuLsgpUxZuWbCf6whPPtRzO8r7YZKtXD2fAxX4yuJOCaBEwgY5n+TzocfpbFyVTCz3eWEYA77AYE9CS4+zkHXLpXO+D17ysr1IqePrhkpCF0vIiIip2b/X4b3Jhs++xwCAbutaxe46w6L2rXtsYy1Ljlfr2Udzl+ciIicGUp9Mihjtc6xK3mOldOqnvLly2dZKZRT/LErjXJaXXSi5xzvwIEDuT4mkiEmJob9+/cXdzekFCkL14yVshvPty/j/nUGAMYdRfqFdxFoNQBcXvjrLwD27DV8PhM+/8KwZ4/9XKcDOneGvn0sDhwwjHw85/cwBoYMMhw8+FeRn09JVhauFzm9dM1IQZS060WJKRERKU18PsOUj+HDjwypqXZbq5bwj7ssGjU8bkJb2sF8vaYpl317BBEROXOV+mRQTnv8HCtjT6Fj9/upW7cua9asITk5Odu+QTntQZTx94zHjmWMYdu2bcTFxREVFXWypyEicuYJ+nGvehfP8jexAj4AAudfTXrHf2LKxwH2PXbtT/DpdMPCBAgdWflTpTL0vgp6X2kRG5sxMLJ45inD2PGG5GMmwMXFwb2DLbp0PrNXBImIiIiISMmTnm6YMRMmTTYZ8+A471w7CdSm9XFjmFA6nqX/wb3sTcDeFyinUY7BwkTHE6rZqii7LiIipUypTwbVrVuXuLg4Vq9ejc/ny5KQ8fv9rFy5kri4uCzJoDZt2rBmzRqWLFlCnz59srze4sWLM2MyXHjhhQB8++233HXXXVni165dy8GDB+ncuXNhn5qISNlkDM6Nc/EmvIDj4HYAQtWb4+86nHD1pgCkphrmfg2ffmb47bejT23axF4F1KUzuN3Zhz1dOlt07AA/roW9++ykUbOmnPGl4UREREREpGQJhewxz1tvG3bustvOOgvuGmjRtTM4HFnHMI7kdXi/Go4zeR0AwZqtcG5fhcHCwmTGmSPpIX/X4eBwnp6TERGRUqHUJ4Msy6Jfv35MmDCBCRMm8MADD2Q+9sYbb3DgwAEGDRqUZcPwvn378vbbb/Paa6/RrVu3zBJyGzduZMaMGdSuXZt27dplxterV482bdqwbNkyFi1aRJcuXQAIBAKMHTsWgH79+p2GsxURKd0cuxPxLhyN848VAITLVyO90/0EG/YCy+L3PwzTPzPM/hJSDtvP8Xqhx6V2EqjBOSdO6jidFi1bFOVZiIiIiIiInBxjDEu+hzf/a9i8xW6rUgX+PsCi1+Xgch035gkHca94C8/3E7DCAUxkDGndHid0bk97kt2C0VgpO4++fnQ8/q7DCTXocRrPSkRESoMSmwyaOnUqq1atAmDDhg2ZbcuXLwege/fudO/eHYCBAwfyzTffMHHiRBITE2ncuDHr1q0jISGBRo0aMXDgwCyvXa9ePQYPHszYsWPp3bs3PXv2xOfzMWvWLILBIKNGjcLlyvrRPPHEE/Tv359BgwZx+eWXExcXx+LFi1m/fj39+vXLkjwSEZGsLN9ePEtewfXTNCwMxukl0OYO0tvcQcgRyfffw6fTwyxfcfQ5NWtA32ssLr8MKkRrZY+IiIiIiJRuP641vP6m4aef7ePy5eHmGy2u6wsREdnHPNa+zUR8NRznzrUABOt3w9/9CUy5qgCEGvTAV78bzu2rsA4nY8rF2qXhtCJIRERyUGKTQatWrWL69OlZ2lavXs3q1asBqFmzZmYyKCoqismTJ/Pqq68yZ84cli9fTtWqVRkwYACDBw/OcS+fe+65h5o1azJp0iQ+/PBD3G43LVq0YOjQoTRt2jRb/DnnnMPUqVMZM2YMCQkJ+Hw+6tSpw8iRI7npppuK4BMQkRIpHNIX7Zzk9rmE0nGv+R+epf/BSk8BIHDeFaR3up+/THW+mAafzTDsODKRzbLgonb2KqAL22QvjSAiIiIiIlLa/LbZ8MZ/Dd99bx97PNDvWrjpRivniW8mjHvNZDyLx2CF/BhvNP6LRxBs1NseNB3L4SRU68KiPwkRESn1LGOMOXGYnKr9+/cXdxekFIiJidG1UoJlLMF3HLMEP1y+Gv6Li28Jfkm4ZnL+XOIJNOqNe+NcHH9tBSAU3xh/1+H8eqgln35m+Ho+pAfs+AoV4Mor4OreFjVrKAFUVErC9SKli64ZKYiSdr3ExMQUdxfOaCXpWpCSraTdO6RkK23Xy587DG+9Y5g7D4wBpwN69YLbb7WIjc153GMd+IOIOY9kltYO1umAv8fTmOhqp7PrZUJpu16k+OmakYIoaddLfsY/JXZlkIhISeLcOJeImcOArPlzK2UXETOHkXbV2DOyJnNen4t3xX8BCEdVxdduGF/t6sMnT1skJh6NPfdcuPYai+6XgNerJJCIiIiIiJR++/cbJk02fPY5BIN228Vd4c47LGrXymXcYwyun6biXfQcVsCHcUfh7/IgwSZ/y74aSERE5CQoGSQiciLhEN4FowHD8V/BLQwGC+/C0fjqdzuzSsbl+bnY6SHjKscEPueTxyvy1wH7MbcbLukK1/SxaHw+WBrYiIiIiIhIKRIKGX5cC3v3QZXK0KwpOJ0Whw8bpnxsmPIRpKbZsW1aw90DLRo2zH3cYx3ahXfeo7iSFtuvX7MVaT1HYyrVOh2nIyIiZwglg0RETsC5fVWWEmjHszBYh3bi3L7qjKrVfOLPBazgYX5ctJ6/DlxIXBz06W1xVS+IiVECSERERERESp9FCYax4w3JyUfbYqtCm9b2nkAZk+Aangf/uMuidas8xj7G4EqciXfBM1j+gxinh/SO9xFoccuZNdFQREROCyWDREROwDqcfOKgAsSVFebQ7nzFtWmYzDWXWXS4CFwuJYFERERERKR0WpRgGPFY9q23k/fA7K/sv9eqBXfdYdG1S95VECzfXrxfP4lr0zwAQvEXkHbZs5gq9Yuk7yIiIkoGiYicgHXgj3zFmXKxRdyTEsQY9vy6gdr5CG3XLY76nZQEEhERERGR0isUslcE5SU6Gt6deOL9UJ0b5+L9+kkcqfswDhfp7f6PwIV3gkO/phMRkaKjnzIiIrkxBvfKt/AsGWsfQra9cTJDAedv8wlVawruiNPUweJhHdqF9+vHqL0tAQBjct7PNGwsdqXGszncCs1tExERERGR0uzHtWQpDZeTQ4fgl18tWrbIJSDtAN4Fz+BOnAlAqOq5+C8bTTju/MLtrIiISA4cxd0BEZESKejH+9XDeBe/hAUE63TgyO5AWcIMR5NEntXvEfX+NTj+XHP6+3s6GIPr50+Ieu8qXFsSCOJm1u9XYrAIm6yfS8bxC788TJUqqnUtIiIiIiKllzGGpcvzXhWUYe++nNudWxYTNak37sSZGMtB+oV3kXrjVCWCRETktNHKIBGR41gpu4n4fAjOnWsxlhP/xY8QbH6jvZR/wWislJ2ZsSa6Gv6uw8HpwTvvcRz7k4icchOBVgNIbz+0zKwSsg7+iXfe47i2fgvAlmBT7k8YxeaUc5i/szsPXjCaapG7MuN3pcbzwi8P83PoUh5vWly9FhEREREROXnGGFashLfeMfzya/6eU6XycQ3ph/Eueh73Tx8DEI6pS1rP0YRrNC/UvoqIiJyIkkEiIsdw7PqFiBmDcKTswngrknbVGEK1LwIg1KAHvvrdcG5fhXU4GVMullDNVuCwV774bvsc78Jncf/6GZ5V7+DavJC0ns8QrpFbjYBSwBhcP32MN+EFrPTDhCwPb2waysRfbsXhctLtEpj/zaUs3HEJLausompEMnvSYlm9txVhnDzzlIXTqf2CRERERESk9DDGsGq1nQT66We7ze0GlwtSU3N/XlwcNDtmMpzj9+VEzHkEx8HtAKS3uIX0jveBO7IIey8iIpIzJYNERI5wrf8S75xHsIJphCufTerV/8HE1Mka5HASqnVhzi8QURH/ZaMJntvzyCqhLUR+dDOBlgNIbz+k1K0Ssg5sxztvJK5tSwHYHGzOfYueZuvhejQ4B0YMtzinvsUlXQ1jxztZmXz0c4mLg3sHW3TprESQiIiIiIiUHmt+MLz1juGHH+1jjxv6XA033WDx8y8w4rHcy8XdO/jIZLhAGp4lY/Csfg+AcIUa+Hv8m1DttqfjFERERHKkZJCIiAnj+e5VPMteAyBYtxNpvV4Cb/RJvVzo7K7HrRJ6G9fmBaVnlZAJ4/7xQzyLX8YK+AhaEby28V7e+fUmLKeTO263uOUmcLnsRE+XzhYdO9gbqu7dZ5dFaNYUrQgSEREREZFS48e1dhJo9ZEtYN1uuPoquPlGi6pVM8Y+8MxTMHa8ITn56HOPnQzn2PEjEV8Nx7F/CwCBC67D3+Uh8JY/3ackIiKShZJBInJmC/iI+PJhXJvmAZDe6u+kd/pnZum3k5ZlldBjpWaVkPXXNiLmjsT5xwoANgVbc9+ip/j9cB0anAOPPGzR4JzsSR6n06JlKchziYiIiIiIHOunn+0k0MpV9rHLBVddCbfcaBEXl33s06WzRceLQiQtXkX6vmQ8lWOp26kVTiuM59v/4F7xXywTJlwuFv+lowid3eU0n5GIiEjOlAwSkTOWdXA7ETMG40xeh3G68Xd/imDjPoX6HvYqoZl4F47G/euMY1YJ/btkbRhqwrjXvI/n2zFYwTSCjkheXX8fkxJvwOF08PcBFrfefHQ1kIiIiIiISGn2y692Emi5PQ8OpxOuvAJuudmiWnzu4x7nxrlELRhNs5SddsM2CG+ognF6cR76E4BAwyvxXzwCIisV8VmIiIjkn5JBInJGcmxfTcTMoTh8ewlHVSGt9/iiK+EWURH/Zc8et5fQTQRaDSC9/VBweYvmffPJ2r+FiDkjcf65GoANgQsZtmgUf/rO4pz6MOJhiwYNlAQSEREREZHSb906w1vvGr63t0bF6YArLodbb7aoXj3vcY9z41wiZg4Dsu4bZPn24gCMpxxpPZ4hdG7PIum7iIjIqVAySETOOK6fP8X79RNY4QCh2EakXf0qpkKNIn/f0NkX47ut5dFVQivfxrV5IWk9nimeVULhEO7Vk/AsGYcV8hN0RDFu3b+YvK4fDqeD22+zB0RutxJBIiIiIiJSum3YaK8EWvKdfex0QM+ecNstFjVr5GPMEw7hXTAaMBwfbWGnh4y7HKFzuhdux0VERAqJkkEicuYIh/AsfhHPqncBCDboQdplo8Eddfr6kLFKqEFPvF8/jmPf5mJZJWTt/Y2IOY/g3LkWgHWB9ty38El2pNag/pHVQOdqNZCIiIiIiJRyGzcZ3n7XsPhb+9jhgB6XwoBbLM46K/9jHuf2VTgySsPlwAKsw7txbl9FqNaFp9hrERGRwqdkkIicGfyHiJh1P66kxQCktxtE+kX/B5ajWLoTqn8xvpot8S74N+7Ez4+uEur5b8LVmxXdG4eDuFe+g+f7V7FC6QQc5RmT+CAfrO+L02lpNZCIiIiIiJQJmzfbSaCFCfaxZcGl3WDArRa1axd8vGMdTi7UOBERkdNNySARKfOs/UlEzhiEY99mjCuCtMtGEzr3suLulr1K6PLnCJ57Gd6vH7NXCU25kUCr20lvP6TQVwk59mzAO2cEzl0/A/BroDPDFjzO7rRq1D8bRgzXaiARERERESndtiQZ3plkWLAQjLGTQJdcDLffZlG3zsmNd6xDO3H/OCVfsaZc7Em9h4iISFFTMkhEyjTn1u+I+OKfWP4DhMtXI+3qVwnHNy7ubmURqn8xvhoz7b2EEj/Hs/KtI6uEnimcVUKhAO4V/8Wz9HWscIB0ZwVe/OVhPt7QG6fDYsCtdp1srQYSEREpfebNm8cHH3zAr7/+SmpqKlWrVqV58+Y88MADVK9ePTMuJSWF8ePHM3fuXJKTk4mNjaVHjx4MGTKE8uXL5/jaM2fOZNKkSWzatAm3203z5s0ZOnQoTZo0OV2nJyKSKRQyLF8RIGmroUplaNYUnM6jY5itWw3vvGeY/42dBAK4uKudBDq73kmOdUIB3GvetysrBHwcedlsewaBvZOQiY4nVLPVyb2XiIhIEVMySETKJmNw//ABnoWjsUyIUPVmpPUeX3JnaUVWOrJKKGMvod8KZZWQI3kd3jmP4NydCMDPgYu5b85jJPvjqH82PPKwxXnnKgkkIiJS2hhjePzxx/noo4+oXbs2V1xxBeXKlWP37t2sWLGC7du3ZyaDfD4fN998M4mJiXTo0IFevXqxbt063n33XZYtW8YHH3xAVFTWPRRff/11xowZQ40aNejfvz8+n49Zs2Zxww038NZbb9G2bdviOG0ROUMtSjCMHW9ITj6Y2RYbC8OGwNlnw7uTDPPmQzhsP9als50EOqf+yY91HNtX453/JM49GwAIVW9O8NweeBa9gAGszNSQnQgC8HcdDg7nSb+niIhIUVIySETKnlA63m+ewf3TxwAEzr8af/cnC73sWlEI1b8EX42WeBf+G3fizGNWCf2bcPWmBXihdDzL3sS9/A2scJB0Z0We+/kRPtnYC6fD4rZb7FrZWg0kIiJSOk2ePJmPPvqIm266iREjRuB0Zv3lYzAYzPz7xIkTSUxMZODAgTzwwAOZ7ePGjWPChAlMnDiRoUOHZrYnJSUxfvx46taty7Rp04iOjgbglltuoV+/fowcOZIvv/wSl0vDSREpeosSDCMeM9nak5NhxGMGhwXhIw936gB/H2DR4FTKX6fux5vwIu5fPgXARFTE3+lfBC/oC5aDcIWaeBeMxkrZmfkUEx2Pv+twQg16nPz7ioiIFDHLGJP9J6oUuv379xd3F6QUiImJ0bVyqlL3EznzXpx/rMBgkd75XwRa3W4Xii5lnL99Y68SOrwHYzkItP476RcNPprUCoeoeHA9h3duwZSLtcsROJw4dv1i7w20Zz0AawPdue+bkez1x3J2PXs1UMPzSt/nIadO9xgpKF0zUhAl7XqJiYkp7i4UmbS0NLp06UJ0dDRfffVVnkkZYwydO3cmJSWFJUuWZFkB5Pf76dSpExERESxatAjryPell19+mTfeeIPnnnuOPn36ZHm9xx9/nClTpvDWW2/RsWPHXN+3JF0LUrKVtHuHlCyhkOG6/obk5LzjLmoHd9x+iuMcE8b18yd4F7+ElXYAgEDjvvg7/wsij/uZEg7h3L4K63BylrGYlCy6v0hB6ZqRgihp10t+xj+ayiUiZYZjzwYiZgzCceAPjKccaVe8SOjsrsXdrZOWbZXQiom4fltAWs9/Y6XsxLtgNKGUnUQciQ+XjydUrSmu377BMiH8rhie/Wkk0zf2xOmwuPVmezWQx6NEkIiISGm2ZMkS/vrrL6655hrC4TBz584lKSmJ6Oho2rdvT506dTJjk5KS2L17Nx07dsxWCs7r9dK6dWvmz5/P1q1bqVu3LgDLly8HoEOHDtneu1OnTkyZMoUVK1bkmQwSESkMP67lhIkggBuuP7VEkCN5Hd6vn8S54wcAQlXPxd/tccI1W+byBCehWhee9PuJiIgUByWDRKRMcP62gIjZ/8IK+AhXrE1qnwmYKucUd7dOXWQl/Jc/T/Dcy47uJfRhfyD7ok4rZRfuTfMA+CFwGfd9NYL96ZWpVxdGPGzRsKGSQCIiImXBzz//DIDT6aR3795s2bIl8zGHw8GAAQN46KGHANi6dStAZqLneBmJo2OTQUlJSURFRREbm32vxYz4pKSkwjgVEZE87d1XuHHZpB/G89143GvexzIhjDuK9PZDCDS/CZzuk3xRERGRkknJIBEp3YzBvWIinm/HYGEI1mpL2pVjsi/jL+UyVwl98wzu9V/kGGNhp4gOBCrx9y+fx3I4ueVmuF2rgURERMqUvXv3AvDOO+9w/vnnM3XqVOrXr09iYiKPPvoob7/9NrVq1eLGG2/k0KFDAJQvXz7H18poz4gDSElJoXLlynnGp6Sk5NnHihUr4nA4CnZicsYqy2Ud5dRYpAGHTxhXt040MTH5T94YYzC/zCQ0+zE4ZO/9YzW+EtflT+GpWONkuyslkO4vUlC6ZqQgStv1omSQiJReQT/eeY/iTpwJQHqzG0jvOrzszuCKrESwab9ck0FgJ4Qquf/iisar6DOkrVYDiYiIlEEZ27663W4mTJhAfHw8AK1bt2bcuHH07t2bd955hxtvvLHY+njgwIFie28pXUpavX0pGVJSDBPfNnwy/cSxcXFwdr1D7N+fv7GPtX8r3m+exrX1WwDCFWvhv2QkoXqdIQzoeiwzdH+RgtI1IwVR0q4X7RkkImWWlbKbiM+H4Ny5FmM58V8ygmCzG4q7W0XOHNqdr7gH707GoUSQiIhImZSxOueCCy7ITARlaNCgAbVq1WLr1q0cPHiQ6OhoIPeVPBntGXEZr3/sSqGc4nNbaSQiciqMMcybDxP+YzJLvzW5AH76Offn3DvYwunMx9gn6LerSix/EyuUjnG6CbS5k/Q2d4I74sTPFxERKeWUDBKRki0cwrl9FdbhZEy5WEI1W+FIXkfEjEE4UnZhIiqSduUrhGq3Le6enhYbd8bSLB9xW/bEUb/IeyMiIiLF4eyzzwayJnCOldGelpZ2wj1+MvYUyogDe3+hNWvWkJycnG3foBPtQSQicrK2bjW8/Iph1Wr7uFYt+Oe9Fm1aWyxKMIwdb0hOPhofF2cngrp0PnEiyJm0BO83T+H4axsAwdoX4e/2KCamXlGcioiISImkZJCIlFjOjXPxLhiNI2VnZpuJqAjpPqxwgHDl+qT2+Q+mUu1i7OXptTnUkvjUeOIiduOwTLbHw8ZiV2o8m8OtlAwSEREpo9q2tSfBbN68OdtjgUCAbdu2ERUVReXKlYmNjSUuLo7Vq1fj8/mIiorKjPX7/axcuZK4uLgsyaA2bdqwZs0alixZQp8+fbK8/uLFizNjREQKQ1qaYdL7hg+nQDAIHg/cdovFDdeTufdpl84WHTvA5i3RJG09RJXK0KwpJ1wRZB3ahWfRs7g3fAVAuFws6V0fJnju5WCpkoKIiJxZtKOniJRIzo1ziZg5DOuYRBCAlXYAKxwgFHc+vhumnDGJIL/f8MVsw3/fdvL8z8MBO/FzrIzjF355mCpVnKe9jyIiInJ61K5dm44dO7J161amTp2a5bE333yTgwcP0r17d1wuF5Zl0a9fP3w+HxMmTMgS+8Ybb3DgwAH69euHdcwvRfv27YvL5eK1117LUi5u48aNzJgxg9q1a9OuXbuiPUkROSN8+53h5tsMk9+3E0Ht28H7kyxuu8XKTARlcDotLmzj5tJuFi1bnKA0XDiIe/Ukoib1wr3hK4zlIL3FLfgGzCZ43hVKBImIyBnJMhm7j0qRKkmbSUnJVdI2His24RBRE7tjpewkp6/oBjDlq+Eb+DU4ynbSY98+w/QZhs8+z7qP6SXV5/HgBaOpFrkrs22Hrxov/PIwP4cuZeqH+aybLWcU3WOkoHTNSEGUtOslPxuolmbbtm2jf//+7N27l65du3L22Wfz66+/snTpUmrWrMlHH32UWeLN5/Nx4403kpiYSIcOHWjcuDHr1q0jISGBRo0a8cEHH2RZMQTw2muvMXbsWGrUqEHPnj3x+XzMmjULv9/PxIkTT5gMKknXgpRsJe3eIafHjh2GV141fLvEPo6Ph2FD7NU/Vh6JmvxcL44/1+Cd/xTO5HUAhKo1xd/9ccJx5xda/6V00P1FCkrXjBRESbte8jP+UZk4ESlxnNtXZSkNdzwLsFJ24ty+ilCtC09fx06jTb8ZPp5qb54aCNht8fFw7TUWlWMMT4++lIU7LqFllVVUjUhmT1osq/e2IoyTZ55SIkhERKSsq127Np988gnjxo1j8eLFLFmyhKpVq3LTTTcxaNAgqlSpkhkbFRXF5MmTefXVV5kzZw7Lly+natWqDBgwgMGDB2dLBAHcc8891KxZk0mTJvHhhx/idrtp0aIFQ4cOpWnTpqfzVEWkDAkEDFM+hnffM/j94HTCDdfbZeEiI09xDJO6H++3Y3D/ZK+YNN6K+Dv9k2CT68BSYRwRERGtDDpNSlKWUEqukpZRLi6udbOImP2vE8alXfEiwYa9TkOPTo9w2PD9Uvh42tFNUwEanw9/62fRpRO4XPYA6VQ3UJUzk+4xUlC6ZqQgStr1UtZXBpV0JelakJKtpN07pOisWm14eaxh6zb7uEVz+Ocwi3p18zl+CYeoeHA9h3duwZSLJVSzlV0pwoRx/fIZ3sUvYqXa11Kg8TX4O/0LoioXzclIqaD7ixSUrhkpiJJ2vWhlkIiUSqZcbKHGlXQ+n+HLOTD1E8Mff9htTgd07QL9rrO4oHH2wdHJbqAqIiIiIiJyOu3Za5jwmmHe1/ZxTAwMvseix6V5l4Q7lnPjXLwLRhNK2UnEkbZw+WoEWg3AtWkezu2rAAhVOQd/t8cJn9W6CM5ERESkdFMySERKHt8+DOS4XxCAwcJEx9szwUqxXbsNn0w3fD4TUlLstvLloPdV0Pcai2rxeQ+MMjZQbXCOEkAiIiIiIlKyBIP23qf/fctw+DBYFlxzNdx5h0V0dP7HMM6Nc4mYOQx799ijrJSdeBY9iwUYdxTpFw0i0OIWcLoL9TxERETKCiWDRKREca9+D8/CI1/oAbCwjvnSb46kiPxdh9slAUqhX3619wNauAhCYbvtrJr2KqDLe0JUlJI7IiIiIiJSev3yq+GlMYYNG+3jRg3h/vssGp5XwLFOOIR3wWiOjgSPyjg2Li++W2dgKp51ir0WEREp25QMEpGSwYTxJLyIZ9U7AKQ3u4FQrQvxLnwOK2Xn0bDoePxdhxNq0KO4enpSgkFDwrfw8VTDz78cbW/Zwt4PqH07cDiUBBIRERERkdLr4EHD6/81zPwCjIHy5eEfd1pcdeXJlbR2bl+F45jxYE6soB/HwT8JKRkkIiKSJyWDRKT4Bf14v3oY94avAPB3/CeBNgPBsvCdcynO7auwDidn3SS0lDh0yDBzFnwy3bBrl93mdsOl3aDftRYNGigBJCIiIiIipVs4bO+D+trrhr8O2G2X94T/+4dFTMzJj3msw8mFGiciInImUzJIRIpX2gEiZwzGuX0lxuHG3/MZgo2uOvq4w0mo1oXF17+T9McfhmmfGmbNhtQ0u61SJbtGdp/eFlWqKAkkIiIiIiJZhUKGH9fC3n1QpTI0a3pyK2pOp02/2SXhfvrZPq5X1y4J17zZqffbOrA9X3GmXOwpv5eIiEhZp2SQiBQb6+B2Ij+9G8e+3zCe8qT1Hk+odrvi7lae8hqcGWNY8wN8PM2w5Du7LALA2fXgb9dZXNodvN6SPZATEREREZHisSjBMHa8IfmYRS6xsTBsCHTpXPLGET6f4a13DdOm2XuhRkTA3wdY/O06cLlOrb/WwT/xLhyNa9PXgL2fbE6vaLAw0fF2BQkRERHJk5JBIlIsHLsTiZh+N47DyYTLx5N2zZuEY88t7m7lKbfB2aB7DIF0i4+nGTZuOvrYRe3sJFDrVmBZJW/wJiIiIiIiJcOiBMOIx0y29uRkGPGY4ZmniichlNNkOIcDFi6Cca8akvfYcV06w9DBFvFxp9jHUDruVZPwLH0NK5iKsZwE63XGtXkBBguLo5+ROZIe8ncdXqpKiYuIiBQXJYNE5LRzJi0hYuZQrICPUJUGpPV9ExNdrbi7lae8BmdPPAUcGZR4vXZt7H7XWtSpowSQiIiIiIjkLRSyJ53l5ZVXDR07nN6ScTlNhqtcGSrHwKbf7OMaNeC+oRYXtTv1fjm3LcX7zSgc+zYDEKrZCn+3xwhXPZfgxrl4F4zGStmZGW+i4/F3HU6oQY9Tfm8REZEzgZJBInJauX75DO+8R7HCQYK12pLWezx4o4u7W3nKz+DM4YA7bodrrraoUEFJIBERERERyZ8f15Il4ZKT3bth1L8N9epCZAREREJk5JG/H/kvKvJI+zFtJ1uhILfJcPv22f85nXDrzXDzjdYpl8K2UnbjWfQc7vWzAQhHVSG98wMEG/WGI/0PNeiBr343Kh5cz+GdWzDlYu3ScFoRJCIikm9KBonI6WEM7uVv4F3yCgCBhlfi7/kMOD3F3LETy8/gLByGJhcoESQiIiIiIgWzd9/RvzsI0bLKKqpGJLMnLZbVe1sRxk54fD0fIO9JaseyLIjwGiIij0kWHZc4ioiwk0eRkRARYREZCR6P4fU3837tShVhwK3Wqa1UCgVw//A/PN+Nxwr4MJaDQLMbSG8/FCIqZI93OHHU60Cw0vkn/54iIiJnMCWDRKTohYN454/C/dPHAKS3uZP0jsPAchRvv/IpcV3+BlzHDuJERERERETyo0pl+89Lqs/jwQtGUy1yV+ZjO1Pjef7n4Xyz41K6dIYK0eBLhbQ0+z9fKqQdOU5Ng9RU8Pvt5xpzpC0tvz3Jf6Jp7z570lzLFvl+ShaO7avwzn8K554NAISqNbVLwsU3PrkXFBERkRNSMkhEilbAR8QX/8S1ZRHGcuC/eATB5jcWd6/yZetWw9uTDPO/yV98xiBOREREREQkvw4dMnSrPo8XWt/H8QmZuIjdvNj6PkZtGMOwx3vkayVOOGzs5NAxSaKM44y2YxNKqakmS+wff8DGTSfu98lMhrN8e/EkvIj7188AMBEV8Xe6n+AF15aayYIiIiKllZJBIlJkrMN7iPjsHpy7fsa4Iki74kVC53Qr7m6d0B9/GN55zzDva7v8G4DXA/703J8TFwfNmp6e/omIiIiISOkXCBhee8MwbVqI2ZeOBgyO43I9DssQNhYPXvAsIas7cOI9chwOi6goiIrKb0+yvunqNYah9514lVCBJsOFQ7jWfoR3yStY/oMABJr0w9/xPoiMKcALiYiIyMlSMkhEioS1fwuRn96N48DvmMgYUq/+D+EazYu7W3n6c4dh0mTDV19B6EgSqFMH+PsAiz93kOMGqhnuHXyK9bJFREREROSM8ecOw+NPGhLXQesqq7KUhjuewzJEBnaS+vsyQnXaF3nfmjWF2Ni8900tyGQ4x461eL95CueuXwAIxTXC3+1xwtWbFUJvRUREJL+UDBKRQuf4cw2Rn/0fVtpfhCvWIrXvm5iYusXdrVzt3GV4733DrNkQCtltF7WDOwZYNGxoJ3gaNIBnnoKx402WQVFcnJ0I6tJZiSARERERETmxRYsNo581pByG6GgYcuse+O3Ez4uYMZhgg+4E63cnVK8juPO99KdAnE6LYUMKYTJc6n68347F9dNULAzGG016h3sJNO0PjhOvcBIREZHCpWSQiBQq56b5RMy6HyvkJxTfhLRrXsNEVSnubuUoOdkw+X+GmbMgELDbLmxjrwS6oHH2gU2XzhYdO9gbpe7dZ5dFaNYUrQgSEREREZETSk83/Od1w7RP7ePG58OTj1nUTInMVzLICqbiTpyJO3EmxuklVKc9wXO6Ezy7K0QV7gamXTpbJz8ZzoRx/fwp3sUvYaX9BUCgUW/SOz+AKVe1UPspIiIi+adkkIgUGvcP/8Oz4N9YJkzw7K6k9XqpyGarnYq9ew3vf2CY8TmkH0kCtWwBd9xu0axp3okdp9OiZYvT0EkRERERESkztm83PPakYf0G+/jG/nDXQAvP7h/xzh8FgOH43Xs40m5hyseTdvnzuDYvwLXpaxwHfrf/vnkBxnIQrtHyyKqhbpiKZxVKn09mMpxjdyLe+U/h3PEDAKEqDfB3e5TwWW0KpU8iIiJy8pQMEpFTZ8J4vh2DZ8VEAAJN/oa/26PgKFm3mP1/GT740PDpZ+D3221Nm8DAv1u0bKHVPSIiIiIiUvi+WWh47gXD4cNQoQKMHG7Rvh2417yPJ+F5rHCQcLlYrMPJGCwsjpZnM0fSQ/6LhxOu1Yb0Wm1I7/wAjj0bcf72Na5NX+PcnYhz+0qc21fiXfgsodiGBM/pTuicboSrngfWyY918j0Zzn8Iz5JxuH/8AMuEMe4o0tsPIdD8JnC6T/r9RUREpPCUrN/UikjpE0zHO3cE7nVfAODvMIzAhXed0oCjsB04YJjysWHaJ5CaZred3wjuvMOidSuwSlBfRURERESkbPD7Da++Zpj+mX3c5AJ44jGL+IqH8c56FPeGrwAInHsZ/h5P49y6BO+C0VgpOzNfw0TH4+86nFCDHkdf2LIIx55LOPZcAu3+D+vgdlyb5uPcNN9OCiWvw5m8Dr5/lXDFswjW70bwnG6Ea7Qs/L16jMGVOBNPwgs4fHvs8znvctI7P4SJji/c9xIREZFTomSQiJy8tINEzByK6/dlGIcLf49RBM/vU9y9ynTokOGjqYaPp4HPZ7c1PA/u+LtFuwuVBBIRERERkaLx+x+Gx580bNhoH998o12RwLN/IxH/G4rjr60Yh5v0Lg/aq2csi1CDHvjqd8O5fZW9SqhcLKGarU6YwDEVahJoeSuBlrdC6n5cmxfayaGkb3Ec+APP6kl4Vk/CRMYQPPtie9VQ7YvAHXFK5+jYsxHvN6Nw/rECgHBMPfyXjCRUp/0pva6IiIgUDSWDROSkWId2EPHp3Tj3bsR4ypF21SuE6nQo7m4BcPiwYeonMOUjQ8phu+2c+vbgq0N7JYFERERERKTofD3f8PxLBp8PKlWEkY9YtGtr4frlM7zzn8QKphGOrk5ar5cJ12ie9ckOJ6FaF578m0fGEGx8DcHG10DAhzNpCa7f5uP6bSFW6n7cv3yK+5dPMe4oQnU7EjynO8F6nSGiYs6vFw5lT04F0/B8/x/ca97DCgcxrgjS2/6DQKvbweU5+b6LiIhIkVIySEQKzJG8gYjpd+FI2UW4XCxp17xBOK5RcXcLn8/wyXT48CPDwYN2W726cMftFp07gcOhJJCIiIiIiBQNv98w7lXDjJn2cbOm8MSjFrGV/HjnPoP752kABOt0JO2K5yEypmg75I4i1OBSQg0uxR8K4Ny+Cuem+bh+m4/j0A5cG+fi2jgX43AROquNvWKofrfM8m7OjXPxLhiN45iydeEjSSNH2gH7XOp3w991OKZizaI9FxERETllSgaJSIE4ty0l4vMhWOkphKrUJ+2aNzEVahRrn9LSDJ9+Bh98aPjLHpNQpzb8fYDFxV2VBBIRERERkaK1bZvh0ScNv/1mb596y032eMSd8jsRU4bhTE7EYJHefjCBtv8Ay3F6O+h0E6rdjlDtdqRf/AiO3b/i2jTP3mdo7yZc277Hte17+GYUofgmhGPq4DqyL+yxMpJA4agq+Hs8Tejsrqf3PEREROSkKRkkIvnmSpyJd84IrHCAUM3WpF79au7lBApJKGT4cS3s3QdVKtuz65xOO7nj9xtmfA7vf2DYt9+OP6sm3H6bRfduR+NERERERESKytx5hhdeMqSmQaVK8PhIizatLZybviZiziNY/kOEIyvjv+KFkrGfjmURjm9Menxj6DAMa38SrowVQ3/+gHPXTzh3/ZTr0w2Aw0WobqfT1mURERE5dUoGiUh2x9eFrtES96p38H77MgCB8y7H3/PZIq8HvSjBMHa8ITn5aFtsLAy6x3DggMXk/xn27LHbq1eH22+16HEpuFxKAomIiIiISNFKSzO8Mt4wc5Z93KK5nQiqGhPEs2gMnlXvABCq0ZK0Xi9nll8raUxMXQJt7iDQ5g6sw8m4V7yNZ/W7ucZbgJWyC+f2Vae2v5GIiIicVkoGiUgWOdWFNu5IrEAqAOmtbie987+KvKzBogTDiMdMtvbkZHjiKTgyH434eBhwi8XllykJJCIiIiIip0fSVsNjTxg2b7HLwg24FQbcauHy7SZi6j9x/rkaODJ+6ngfON3F3OP8MeViCVe7IF+x1uHkEweJiIhIiaFkkIhkcm6cS8TMYWQkWjJYgVQMEGzcl/QuDxZ5P0Ihe0VQXhwOuHcIXNXLwuNREkhERERERE6PL+cYXhpjSEuDyjHw2EiL1q0snNu+xzvrXzhS92E85Unr+QyhBj2Ku7sFZsrFFmqciIiIlAxKBomILRzCu2A0YMgtteLc9h2EQ+BwFmlXflxLltJwOQmHoV5dJYJEREREROT0SE01jBlnmP2lfdyqJTw2wqJKZYN76et4vhuPhSEU25C0K8diYuoUb4dPUqhmK8Llq2Gl7MIi+yQ9g4WJjidUs1Ux9E5EREROVtHWeRKRUsO5fRWOlJ25JoIswHFoJ87tq4q8L5t+y3tVUIa9+4q4IyIiIiIiIsDmLYY777ETQQ4HDPy7xcsvWFSJ+ouI6f/A+904LAyBC64ltf+HpTYRBIDDif/i4UD2qYIZx/6uw4t8kqCIiIgULq0MEhEAHNtX5yuuKOtC//yL4aOphoWL8hdfpXKRdUVERERERARjDLO/gpfHGvx+ewzy+KMWLVtYOHb8SMQX9+E4tAPj9OLv/jjBxtcUd5cLRahBD9KuGot3wWisY/eTjY7H33V4qSx/JyIicqZTMkjkTBYO4fxtPp7V7+V7xU9h14UOhQyLv4UpHxt+/uVou8cN6YHcnxcXB82aFmpXREREREREMvl8hpfGGubMtY/btLbLwsVUAvea9/Eseh4rHCBcqQ5pV71COPa8Yu1vYQs16IGvfjec21dhHU7GlIu1S8NpRZCIiEippGSQyJko/TDunz/BvWYyjgN/AGAsJzjdEEzLsVRcYdeF9vkMX8yGqZ8Yduyw29xuuLQ7XN/P4o8/YMRjuZeLu3ewhdOp/YJEREREROTUhEKGH9faZairVLYnnSVthceeMGzddrQs3M03giPowztrJO4NXwEQbNCTtB5Pg7d8MZ9FEXE4CdW6sLh7ISIiIoVAySCRM4h1YDvuH97H/dM0rPQUAExERQJN+xNofiOOHT8QMXMYBrJsFFqYdaF37TZ88qnh85mQcthuq1gB+lwNfftYVKliv1f9s+GZp2DseEPyMZXp4uLsRFCXzkoEiYiIiIjIqVmUYLKNOaLLQ2oaBINQtSo88ahF82YWjj0biJg5DMf+LRiHi/TODxBocQtYGpuIiIhIyadkkEhZZwyOHT/gWTUJ56Z5WCYMQLjy2aS3vJVgo97gjgSKti70uvWGKR8bFiyAkN0FatWyVwFd1gMiIrIPoLp0tujYgWyz9LQiSERERCSr//73v7z44osAfPTRRzRv3jxbTEpKCuPHj2fu3LkkJycTGxtLjx49GDJkCOXL57yqYebMmUyaNIlNmzbhdrtp3rw5Q4cOpUmTJkV5OiKnxaIEk2M1gkP2vDkanAMvv2gRU8nC9esMvF8/gRVMI1y+GmlXvky4RovT3GMRERGRk6dkkEhZFQrg2jgX9+r3cO5cm9kcrNOeQMvbCNXtCJYj+9MKsS50OGxY8h18NNXww49H21u2sJNAF7UDhyPvxI7TadFSYywRERGRXP3222+MGzeOqKgofD5fjjE+n4+bb76ZxMREOnToQK9evVi3bh3vvvsuy5Yt44MPPiAqKirLc15//XXGjBlDjRo16N+/Pz6fj1mzZnHDDTfw1ltv0bZt29NxeiJFIhSyVwTl5cABqBDpxzvv37h/mgpAsE4H0q54ASJjTkc3RURERAqNkkEiZU3aAdw/TcW95n84jqzuMU4PwYZXEmh5G+HYc0/8GqdYFzo11fDlHPh4quGP7Xab0wndL4Hr/2ZxbgOt7BEREREpDKFQiIceeoiGDRtSt25dPv/88xzjJk6cSGJiIgMHDuSBBx7IbB83bhwTJkxg4sSJDB06NLM9KSmJ8ePHU7duXaZNm0Z0dDQAt9xyC/369WPkyJF8+eWXuFwaUkrp9ONaMkvDOQjRssoqqkYksyctltV7WxHGifvw7zgm3Yc7JRGDRfpFgwi0/ccpl84WERERKQ765i5SRlj7k3Cvnoz718+wAvaM0HBUFQLNbiDYrD8mqkqR92HPHsMnnxlmfA4HD9pt5cvD1VfBdX0tYmOVBBIREREpTP/9739Zt24d06dP56233soxxhjD1KlTiYqKYtCgQVkeu/vuu3n//feZNm0aQ4YMwTqy98mnn35KMBjknnvuyUwEATRo0ICrr76aKVOmsHTpUjp27Fh0JydShPbus/+8pPo8HrxgNNUid2U+tjM1ntl/XEm/uh8TnXIIExlD2hUvEKrToZh6KyIiInLqlAwSKc2MwfnHCtyrJ+H8bQEWdpmDUNVzCbS8jWDDXuDyFnk3Nm4yfDTV8PV8e5NVgBo14PrrLC6/DKKilAQSERERKWwbNmzg1Vdf5Z577qFBgwa5xiUlJbF79246duyYrRSc1+uldevWzJ8/n61bt1K3bl0Ali9fDkCHDtl/+d2pUyemTJnCihUrck0GBTO+FObAsiycTmexxgJZVjUVJDYUCmFM7uXFSkKs0+nMTOwVVWw4HCYcDp9ybDAYxBhT6K8L4HA4cDgcOcaGQ3BJ9fm82Po+IOs5x0fs4u8N7OTqgQrN4NoXMdHVMgc7eb1uXn0wxhAKhUp07LH/jooqFk7+33IwGMxyrHvEycWWpnvEqcbm9f/uZP8tF1Ws7hHF+90g47rJTyzoHnGqsSXlHnEq/5aP/ZlUEu4R+aFkkEhpFErHtX427lXv4UxOzGwO1uts7wdU+yKwijYBEw4bli2HKR8bVq0+2t60iV0KrmN7e78fERERESl8wWCQhx9+mPr163PXXXflGbt161aAzETP8erUqZMZlxGTlJREVFQUsbGxucYnJSXl+p6zZ8/O9bH4+Pgs+w3NmTMn14FtlSpVsiSk5s+fj9/vzzG2UqVKdO7cOfN44cKFue6hFB0dzcUXX5x5vHjxYg4dOpRjbFRUFN27d888XrJkCX/99VeOsV6vl549e2YeL126lL179+YY63Q66dWrV+bxypUr2bVrV46xAL179878+5o1a/jzzz9zjb3iiisyf+mzdu1afv/991xje/bsiddrTyD75Zdf8vz/2r1798yEYmJiIr/99luusRdffHHmqrKNGzeyfv36HOM8Hg/t2rWjUqVKAGzevJlff/0119dt3749VatWBexr9qeffso1tm3btsTHxwOwfft21qxZA8Bvm+OYPbsJ07uMBgzHb2OaMZQ6HIxiVuV+sHh1lsdbtGhBrVq1AEhOTmbZsmW59qFJkybUq1cPgL179/Ldd9/lGnv++edzzjnnAHDgwAESEhJyjT3vvPM477zzAEhJSWHBggW5xtavX5/GjRsDkJqaytdff51rbN26dWnatCkA6enpzJkzJ9fYWrVq0aKFvcFrKBTK8999jRo1aN26debxyd4jPB4P6enpmY/pHnFUWb1HAHTu3Pmk7hGbNm3i+++/zzU2t3tETlq3bk2NGjUA2LlzJytXrsw1VvcIW3HcI45X0HvE1VdfnXmse0TZv0ec7PeIDMf+TCoJ94jbbrst18cyKBkkUlKEQ4S3LMG1cwumXCyhmq2y16JO3Y/7xym4f/wAx+E9ABhXBMHzrya95a2YymcXSldCIcOPa+3SCVUqQ7OmRxM7fr9hzjx7P6Ak+/cKOB3QtYudBDq/kRJAIiIiIkXt9ddfZ/369Xz88ce43e48YzN+OVG+fPkcH89oP/aXGCkpKVSuXDnP+JSUlFzf0+12Z5thmyEiIoKYmJjMY4/Hk+svcXKKzW3GaU6xuc3U9Xq9WWK9Xm+uvxzyeDxZYiMiIvB4PKcc63Q68x0LZImNjIw8YWzGL3GioqLyjK1UqRIRERH5ji1XrhwA5cqVyzO2YsWKVKxYMV+xFSpUyDy/8uXL5zs2OTk5z9jo6OjM2P379+NyeUj4tj7fflef1lWWZykNl5NyLh81zQ6SPedkaS9fvnzm6/p8vjz7cGxsenp6vmPD4XCeseXKlcuMdTgc+Y71eDx5xkZFRWXGpqWl5Ts2GAzmGRsZGZnt32duTnSPOPa5ukccpXtE9tiC3iPyG3vo0KF8/1vWPeL03yNOFJvXPQLI8lnoHqF7xInuERltJeEekR+WyWvtlhSa/fv3F3cXpARzbpyLd8FoHCk7M9vC5avhv3g4oQY9sPZuwrP6PVy/fo4Vsn+4hMvFEWhxE4Em/SAyJreXLrBFCYax403mZqoAsbFwx+2waxdM/wz+OmC3R0VB7yvt/YCqVVMSqDjExMTo/iL5putFCkrXjBRESbtejh3wljXr1q3juuuu4/bbb+f+++/PbH/44YeZPn06H330Ec2bN89snzlzJv/617/4xz/+wX333Zft9SZMmMC4ceN46aWXuPLKKwG44IILqFy5co6zjnfs2EHXrl3p2LFjrvsUJR/7ZfI4JaEUDKi8y6nGFlYZlpiYGA4ePFjk5V327Qvz5NOGVavt547sPYvreDDX52Y43PM5AuddkevrqgTU6S0BdfzPGt0jTi62NN0jTiW2YsWKua6qAJWJO5nYkn6PONXYqlWrZt5jdI8o+/eIU/23fOzPpJJwj8hpRf/xyszKoEsuuYTt27fn+Nj111/PU089laUtJSWF8ePHM3fuXJKTk4mNjaVHjx4MGTIk1xlzM2fOZNKkSWzatAm3203z5s0ZOnQoTZo0KfTzkTOHc+NcImYO4/g61VbKLiJm3ks4tiHO5HWZ7aH4xvZ+QOf2BOepZYOPtyjBMOKx7Dft5GR49vmjx9Xiod91FldeAeXKKQkkIiIicjo99NBD1KpViyFDhuQrPqPERm4reTLaM+LAnoWYW7mTjPjcxk2Q9RcOJ1LaYo/9pdKZHHvsLydOJdblcmVZRVZYr3usn38xPPYE7E62iIiAB/9lcfl58TA1H+9RoVqe10dB+mtZVr6vtbIcCyf/79PlcuX5XN0jSk5sUfxbPpnY/P6/Kwn9LQn/PktCLJSMf8u6RxRtbEn4N3eqsbn9TCoJ94jclJlkENiDl5xq411wwQVZjn0+HzfffDOJiYl06NCBXr16sW7dOt59912WLVvGBx98kG1j1ddff50xY8ZQo0YN+vfvj8/nY9asWdxwww289dZbWWpViuRbOIR3gV2n+viUinUkOeRMXocBQvW7kd5qAOGarYpkP6BQyF4RlBeXC0YMh4u7WLhcSgKJiIiIFId16+yJQrlNSrv++usBe8VP9+7dT7jHT8aeQhlxYO8JsGbNmsyJcznF57YHkUhJYYzhk+kwfoIhFILateDppyzOrgvWT0kYyDYOy3wuFiY63i7fLSIiIlIGlKlkUIUKFfI1O27ixIkkJiYycOBAHnjggcz2cePGMWHCBCZOnMjQoUMz25OSkhg/fjx169Zl2rRpmTPmbrnlFvr168fIkSP58ssvTzkzJ2ce5/ZVWUrD5Sbt8ucJNbqqSPvy41rIo5oHAMEgVKmsRJCIiIhIcbruuutybF+5ciVJSUlccsklVK5cmZo1awJ20iYuLo7Vq1fj8/myTHzz+/2sXLmSuLi4LMmgNm3asGbNGpYsWUKfPn2yvM/ixYszY0RKKp/P8NyLhvnf2Mddu8AjD1lEWQeI+OJxXBvnAkfrMxw7wsmYqufvOjz7Pq4iIiIipVT+1iCVIcYYpk6dSlRUFIMGDcry2N13303FihWZNm1alvqGn376KcFgkHvuuSdL6YQGDRpw9dVXs23bNpYuXXrazkHKDuvwCbIvGXFW0f5TTU01zP4qf9uH7d1XpF0RERERkRN45plncvyvRYsWgD2ueeaZZ2jUqBFgl5To168fPp+PCRMmZHmtN954gwMHDtCvX78spbr69u2Ly+Xitddey1IubuPGjcyYMYPatWvTrl2703C2IgWXtNVw1z12IsjphKGDLEY9YRG9dwVRk6/BtXEuxuHC3+l+0q4ciylfLcvzTXQ8aVeNJdSgRzGdgYiIiEjhK1NLWdLT05k+fTq7du2iQoUKtGzZkoYNG2aJSUpKYvfu3XTs2DFbKTiv10vr1q2ZP38+W7duzSx7sHz5cgA6dOiQ7T07derElClTWLFiBR07diyaE5Myy5Q78cZeBYkrqP37DZ9MN3z6GRw8mL/nVKlcJF0RERERkSI0cOBAvvnmm8wqCY0bN2bdunUkJCTQqFEjBg4cmCW+Xr16DB48mLFjx9K7d2969uyZWSo7GAwyatQoVUaQEmn+N4ZnnzekpkGVKvDU4xbNGgfxLHkV9/L/YmEIV6pD2hUvEq5ml5T3ndMd5/ZVWIeTMeVi7dJwWhEkIiIiZUyZ+vaenJzMww8/nKWtU6dOPP/881SubP8G+0T1rTNKIxybDEpKSiIqKipbrexj43Orvy2SK2Ow9m4qljrVf/xhmPKxYfZXkJ5ut9WoDgcPQS77CgMQFwfNmhZqV0RERETkNIiKimLy5Mm8+uqrzJkzh+XLl1O1alUGDBjA4MGDs02UA7jnnnuoWbMmkyZN4sMPP8TtdtOiRQuGDh1K06b6UiglSyBg+M/rhqmf2MctW8ATj1pUsbYRMeUBnLt+suMuuNYu/+Ypd/TJDiehWhcWQ69FRERETp8ykwzq27cvF154Ieeccw4ej4fffvuNV199lYSEBP7v//6PDz/8EMuyMksclC9fPsfXyWg/thRCSkpKZjIpt/iUvH6DLnK8QBre+U/i/vUz4PTVqU5cZ/jfh4ZFCZBRCbFRQ7ixv0XnTvDtEhjxWO7l4u4dbOF0ar8gERERkZLo2Wef5dlnn8318ejoaIYPH87w4cPz/Zq9e/emd+/ehdE9kSKze7fhsScNP/9iH998Iwy8HSI2fIb3m6exAj6MtwJplz5F6NyexdtZERERkWJSZpJBgwcPznLcrFkz3njjDW6++WZWrVrFokWL6Nq1a/F0DqhYsSIOxxm3RZPkwOzfSnDaQNjxE1gOHN2HQ5V6hGc/Cgd3ZMZZFavjvHwUFRr3OrX3M4ZvlwR4651UVqwMZrZ37uTm9tsiadPalVkfvs/VUK6cn9HP+9i1K5wZWy3ewcMPRnFpd+8p9UWKRkxMTHF3QUoRXS9SULpmpCB0vYjI6bZyleGJUYa//oLy5WDkIxYdWx3EO+cJ3Bu+AiB0VhvSLn8OE129eDsrIiIiUozKTDIoJw6Hg759+7Jq1SpWr15N165diY6OBnJfyZPRnhEH9uqfY1cK5RSf20qjDAcOHChw/6XscW5ZTMTsB7D8BzCRMaT1eolQ7YvsB/8+j4oH13N455asdar37z+p9woEDF9/Ax9OMWzecuT9nXBpd7jheov6Z4eAFP76K+vzWreCjz8w/LjWYu8+e4+gZk0NTqeP/ft9J33uUjRiYmLYf5LXiJx5dL1IQemakYIoadeLElMiZVs4bHj/A5j4tiEchnPqwzNPWdQyq4iY/CCOQzswDhfp7YcQaH2H9gASERGRM16ZTgbB0UFgamoqcOI9fjL2FMqIA3t/oTVr1pCcnJxt36AT7UEkAoAJ4172Op7vXsXCEIpvQtpVYzEVahyNcThx1OtAsNL5p/RWPp/h8y/g46mG3cl2W2QkXH0V9LvOIj7uxGXenE6Lli1OqRsiIiIiIiJF4uAhw9P/Nnz3vX18xeVw/5Ag0Wtew738TSwTJlyxNmlXvEC4uva3EhEREYEzIBm0du1aAGrWrAnYSZu4uDhWr16Nz+fLslGq3+9n5cqVxMXFZUkGtWnThjVr1rBkyRL69OmT5fUXL16cGSOSo7SDRHz1EK7NCwEINL0ef9dHwOUp1LfZs9cw7RPDZzMg5bDdVqUyXHetRZ/eEB2tvX5ERERERKR027DRMOIxw44d4HHDP4dZXNXhDyI++xfOnfb4P9D4GvwXjwBPuWLurYiIiEjJUSY2sdm0aRMHDx7M1r5y5UreeecdPB4PPXr0AMCyLPr164fP52PChAlZ4t944w0OHDhAv379MvdQAejbty8ul4vXXnstS7m4jRs3MmPGDGrXrk27du2K6OykNHMkryfqf/1wbV6IcXpI6/EM/u5PFGoiaNs2w3MvhOnX3y6TkHIYateChx+wmDrF4pabLCWCRERERESk1PtiluEf/2cngqpXh9dehT71Pifq/Wtw7lyL8UaT1usl/D3/rUSQiIiIyHHKxMqgL7/8kokTJ3LRRRdRs2ZNPB4PGzZsYMmSJTgcDp588klq1DhajmvgwIF88803TJw4kcTERBo3bsy6detISEigUaNGDBw4MMvr16tXj8GDBzN27Fh69+5Nz5498fl8zJo1i2AwyKhRo3C5ysRHKYXIlTgT77zHsIJphCvUIO2qcYTjGxfa6//0s+GDDw3ffgfG2G1NLoAb+1t0aA8OhxJAIiIiIiJS+vn9hpdfMcyabR+3vwge/VcKVZc+hXv9LABCNVuRdvlzmAo1i7GnIiIiIiVXmchgtG3blt9++41ff/2V5cuXk56eTpUqVbjiiisYMGAATZtmrREcFRXF5MmTefXVV5kzZw7Lly+natWqDBgwgMGDB2cpHZfhnnvuoWbNmkyaNIkPP/wQt9tNixYtGDp0aLbXlzNcKB3Pohfw/PA+AME6HUi74gWIPPVNjMNhuy72/z40/PTz0fZOHeCG/hZNmygBJCIiIiIiZcf27YaRjxs2bgKHAwb+3eK2rquJnP4QjoPbMZaT9IsGEbjwLnA4i7u7IiIiIiWWZUzGmgIpSvv37y/uLshpYKXsJuKLYTj/XANAett/kH7R4HwNSkIhw+Yt0SRtPUSVytCsKTiddnInPd0wdx58+JFh6zY73u2Gy3pA/79Z1KmjJNCZKiYmRvcXyTddL1JQumakIEra9RITc+oTceTklaRrQUq2vO4d3y4xPP1vQ8phqFQJnhwZ4qL0N3Avew3LhAlXPIu0y18gXKP5ae2zFJ+S9rNGSjZdL1JQumakIEra9ZKf8U+ZWBkkUhI4/lhJxKz7cBzeg/GUJ+3y5wjVvyRfz12UYBg73pCcfHTvq9hYuHugYc9ei6nTDHv32e3ly0Gfq+G6ay2qVlESSEREREREypZg0DDxbXtPVIALGsO/7/+TmssfzJx4F2jUG/8lj4K3fDH2VERERKT0UDJI5FQZg3vNe3gWvYBlQoSqNCCt9zhMTN18PX1RgmHEY9kX6CUnw9OjAezH4mKh33UWva+EcuWUBBIRERERkbJn3z7DE6MMq+2cD/2uhXsvnkW52U9hpadgPOXxd3ucYKMri7ejIiIiIqWMkkEipyLgwzv3Udzr7Z1MA+f1wt/jKXBn33cqJ6GQvSIoL04nPPgv6NHdwu1WEkhEREREREq/UMjw41pI8/uJ8BqaNYVffoXHnjTs2QORETDy/sP0CI7CPXem/ZwaLUi7/HnM/7d35/FRVff/x193JhshAQIkQXYXEnZIgIR9JyAgIgJSRbFK9WsFReuCldpWS7GKP1Fwq9pKraKyVXADEWQnIQFFkFUNOyGsIYQsM3N+f4wZMiSBBLLA8H4+Hjx0zj333nMzZ27mk8+9n1u9fiWPXkREROTKo2SQyEWyjqcStOAh7Ed3Ymx+5HZ/gryY0WCVPGHz/Sb3HUDn43TCNXWUCBIREREREd9wtkw2QCbgLoeddQZcLmjcCF56eBPXbnwc28l9GMtGbsffkxd/P9j0ZwwRERGRi6FvUSIXwb7rG4K+moiVm4mram2yB0/DVa9dqbZx5ozhq8XnvysoX/7zgkRERERERK5kxZXJzjzt/m/rlk5ev+1tqi5/Hcs4cVWrS/aNL+KqF1vBIxURERHxLUoGiZSGy0nAmukEJL0FgLNuLNmDX8aERJR4E2mHDfPmGxZ8BqdOlWydWjUvZrAiIiIiIiKXj4Jlsm04ia2VQu2gdI5kh7PhaDsiq6TxeO0nCVm/AYC8poPJ6fMMBIZW5rBFREREfIKSQSIldeY4QV88ht/uNQDkxtxJbvfHwe5fotW3/Gj4ZLbh2+XgdLnb6l4DGacgM7P49SIioE3rSx28iIiIiIhI5covk937mq95ouUU6lRJ8yw7kVudQFsOVfyycdir4uj3DI7mQypxtCIiIiK+RckgkRKwpW0haOFD2DIOYPyCyOn3HI5mgy+4nsNhWL4CPplj2PLj2fbYGBg53KJTR1i1miLLJOR7eJyF3a7nBYmIiIiIyJXLGMP6ZEPva75mavtHAO8YqEbASQBSTzVie4d/0qV5w0oYpYiIiIjvUjKogjgcjmKXWZaF3W6v1L4Afn5np0Np+jqdTowpPplxOfS12+1YlnVRff03z6XKt5OxnLk4qzfg9KCXcdWOBofDq6/L5cLlct/yc+oUfPYFzP+fxeF093J/f+jXB0YMt7j+OoPL5cQY6NIZnv0zTH/NIv3I2aRPRIQ7EdStq8HhcJZovAXHUBSbzYbNZrts+hpjcDqLP7bLoW/Bz1F59YWL/yw7HA6v1zpHXFzfSzlHlLTvhT4bFdX3fO+dzhGl73u5nyMutW9BOkdcHeeIS/ksF/yddDmcI0Tk8pB/gdwHHxl27XDyRb8pgMFWxPVuxkCQPZsqdepW+DhFREREfJ2SQRXkiy++KHZZZGQk8fHxnteLFi0qNrCtVasWXbp08bz+5ptvyMnJKbJvjRo16N69u+f1t99+S1ZWVpF9Q0ND6dWrl+f1ypUrOVXMA22Cg4Pp27ev5/Xq1as5ceJEkX0DAwPp37+/5/W6des4evRokX3tdjuDBg3yvE5OTiYtLa3IvgBDhpwtGbBx40YOHDhQbN+BAwd6/uizadMm9u7dW2zf/v37ExgYCI5czsx9lOr7vwFgX3Az1ta8jbykn4CfAOjbty/BwcEAbN26laT1h9iw8Vo2b6lPnsO9v+DgHGLapPLgA/Vp2NBd63r79h1s377da79jRsOhtEhOnLTTuVM0XTqHYLdb7Nr1Ez/++CPF6dy5M7Vr1wZg9+7d/PDDD8X2jY+PJzIyEoD9+/ezcePGYvu2b9+eunXdQdihQ4dITk4utm9MTAwNGjQAID09ncTExGL7tmrVimuvvRaAo0ePsmbNmmL7Nm/enBtuuAGAkydPsmLFimL7RkdHEx0dDUBmZibLli0rtu/1119PixYtADhz5gxLliwptm/jxo1p3dpdpy83N5dFixYV27dBgwbExMQA7j8Anu9zX7duXdq3b+95fbHniICAAHJzcz3LdI44q9zPEcCWLVtITU0ttu+554iffvqp2L69evUiNNR9jti5c2ehc0RB3bt3p0aNGgD8/PPPJT5H7Nq1i7Vr1xbbV+cIN186R5yrtOeIm2++2fNa5wjfP0dc6veIgr+TLodzxJgxY4pdJiLlLyfH8MVXMOtjQ/4ptlOdFK/ScOeyLKgTnEZIrRQgvth+IiIiIlJ6SgaJFMHKOEDQwgmEpP2AwWJTzQS2hPUEy1aorzGG5BT413v1+WFzM097eO0M2rf7mWbRB/DzcxEWVv+8+7TZoHGj4+Tm5tK61Q0qDSciIiIiIlecjFOGefNhzjxDfq6/ejW45+Y9jAz9N+y78Db8zhzh/PeYioiIiEhpWeZ8tSukzKSnpxe7T/7FdgAAPexJREFU7HIoBQNXaXkXlxO/AxuwTqdjqobjqBtLwMEUqnzxGNaZ47iCqpPV/x84GnUptM2cHFi6zMbsufDzL+42yzJ07gjDbzW0beO+sq2oMRRXAiUsLIzjx49XWnmXiu6rElCX/lnOnzNlvd2iXJXniDLsezmUgKpevXqxd1WAzhEX0/dyP0dcat/atWt7zjE6R/j+OeJSP8sFfyddDueI8PDwYpdJ+Sv4/USuDmmHDZ/MNixYCGey3W11I5384aYVdAv8iIC9q0q8rTMjZuJsEFdOI5Ur2bnxj8j5aL5IaWnOSGlcbvMlLCzsgn10Z1AFKfgHB1/rW/CPSldSX/vOxQQum4It85BnmQkIgdzTWBicEc3IvulVqF7f64Ny5Khh/v8Mny6AE+5nnFIlCAYNhFuH2WhQ/8J39BT8Q0ZBfn5+hX72xfUtzXYv176WZZV4rvlyX7j4z2dRc6YstluWfS+nz31l9r0cPnM2m63E793lMN7L4fN5OfSFy+OzrHNE+fa9HD5zl9q3uN9Jl8M5QkTKzy+phg9nGRYvgfz8bGzUEf7QYx7Nsj7BdvggAAYLZ+Ou2A79gJV9EovCyXKDhQmNxFmvXUUegoiIiMhVQdGTXJXsOxcTtHACnBOAWLmZADgaxJM99E3wD/Is277D8MkcwzdLIf+C5zqRcOswi8EDITRUZd1EREREROTqsOkHwwezDKs9j+4yjIzfwD0tPiby2CKsNHfQZIJqkNfyVvJa34ap0cATixksr4SQwR1P5fR8CmwlT6aLiIiISMkoGSRXH5eTwGVTOBtueDOA7fhusPvjdBpWrYHZcwzffX+2T6uWMHK4Rbeu4OenJJCIiIiIiPg+l8uwZi18MMvww2Z3W1W/0zzc8zMGR35E8KkdcMTd7qzTmry2v8ERdSP4BXq24WySQPZN0whcNgWrYJWG0Ehyej6Fs0lCRR6SiIiIyFVDySC56tj3JnmVhjuXBViZh1jxQTLTv+jAwYO/rmeHPr1gxHCLZk2VABIRERERkatDXp7h6yXw4ceG1FR3W3TYLh7p8hEdAhZgd5yGU2D8gnA0HURem9/gimxR7PacTRLIur4P9v0phJBFJsHu0nC6I0hERESk3CgZJL7PGKxjP+G3Zx32PWux715z4XWAFV8d5uBBqFYNbh4Cw262CA9XEkhERERERK4OWVmGBZ/BJ7MNh9PBz8rlpmuX8rs2H9HQtd7dyQGusMbktRlFXvOhEFS9ZBu32XE2iMMWFobzMnr4soiIiIivUjJIfJKVcQD7nnXuf3vXYTudXupt2KuH8/goi/79IChISSAREREREbk6HD9umD3XMO9/kJkJEUGH+EPMbIY1mkNV1xFwgbFsOK/vTV7b23E26AiWYiYRERGRy5mSQeIbzhzHvjfRc/eP7cQer8XGHoizXizOhp3YktWBuqsnEBF0GJtlCm3KZSzSzkTSf2w7YmMV0IiIiIiIiG9wOg3fb4Kjx6BWTWjTGuz2szHP/v2GWR8bvvgK8nJdxNVOZEzsR3SssQwbTnCBq2ptHC1HkNd6JCa0TiUejYiIiIiUhpJBcmXKy8K+L8Vd9m3POmzp27A4m9gxlh1XnZY4G3bE2aATzrptPQ8t3brAxX83P8XU9o/gMpZXQshl3IHQi1sm0q2TPh4iIiIiIuIblq8wvDrdQQNXCrWD0jmSHc5eWzseGu9HnTrwwSzDt8uhqv0kIxp8yh1RH1M3INWzvrN+B/La/AbHDX3AHlB5ByIiIiIiF0V/7ZaK53Ji35+CdTodUzW8ZA8KdeZhO7QJ+551+O1Zi+3gJixXnneXWjfgbNjJnQCq3wECQ72W/5Jq+GSO4cuvwOHox2PJL/NEyynUqZLm6ZN2JpIXt0xk6cF+DK1ZZkcsIiIiIiJSaZavMHzzxmJmtvWOfw6dieSFN55i6cF+NK3+I5NafcTghp8TYGUDYAKqktfsZhxtRuGq3aSyhi8iIiIiZUDJIKlQ9p2LCVw2BVvmIU+bK6QOOb2ewtkk4WxH48KWvv3X5/6sdSeP8rK8tuWqVhdng46/JoDiMVXDC+3PGENiEnwyx5C0/my7nx8sPdiPbw/2JrbW2SvjNhxthws7ERHukgkiIiIiIiJXMqfTkPzBYqa2fwTwLpMdEXSYl9pPYHdmIxqH7j67Tu0o911AzW6CgKoVPGIRERERKQ9KBkmFse9cTNDCCZwbgFiZaQQtnEBOr6fB7ue++2dvItaZ4179TJUwHA3iPXf/mOoNin1IaXa2YdHXMHuOIfXXmMZmg25dYeRwi+PHDZP+DC7sJB+NK7T+w+Msr9rZIiIiIiIiV6Lvv3dyf8MpgMF2ToiTXzK7cehuXNhxRg8gr+1vcNWNLTbWEhEREZErk5JBUjFcTgKXuQOQc0MKC4MBgpb9zavd+AfjrNcOZ6POOBt2xFU7CizbeXdz5Ihh7v8MCxbAyQx3W3Aw3DQIbh1mUfea/L1bTH7WMG26IT397PoREe5EUI/uCnxEREREROTKdvKkYfuSZLoXKA1XnKRG/4+WgxIu2E9ERERErkxKBkmFsO9P8SoNd6781IuzdhSOJgnu5E+dViV+MOm27YbZcwzfLAOHw912zTUwYpjFoIFQtWrh5E6P7hZdu8D3m+DoMahV010aTncEiYiIiIjIlSo317B2HXy12P3fvpHp0O7C61Wvmlv+gxMRERGRSqNkkFQI63T6hTsBeXH34Wg6qER9nU7DqjXwyWzD95vOtrdpDSNHWHTtfOHEjt1uERtTot2JiIiIiIhclowxbN4Cixa7L5A7dcrdfn3oLu6M/rhE22jQrPAzWEVERETEdygZJOXOdmQH/ikzS9TXVL1wAHL6tOHzL2HOPMOBA+42ux369oYRwy2aRuvOHhERERHxXWlpaXz55ZesWLGCn3/+mSNHjlC9enViY2MZO3Ysbdq0KbROZmYm06dPZ/HixaSnpxMeHk5CQgLjx48nJCSkyP0sXLiQmTNnsmvXLvz9/Wnbti0PPfQQrVq1Ku9DlBLav9/w1WLD4q9h/4Gz7W3rp/JEh9do5vzSU5YbU/RjgFzGIicgEhq0r6hhi4iIiEglUDJIyo2VeZiAtTPw2zwXy7jcAQgUemYQuJ8kZEIjcdYrvn7BgYOGufMMn30Bp0+726pVg5uHwK1DLWrXVhJIRERERHzf+++/z9tvv03Dhg3p3LkztWrVYvfu3SxZsoQlS5bw0ksvMXDgQE//rKwsRo8ezdatW+nSpQuDBg1i27ZtvPfeeyQmJvLhhx8SHBzstY8333yTl19+mbp16zJq1CiysrL4/PPP+c1vfsO7775LfHx8RR+2/Cojw7B0GSz62vDD5rPtVYLglh57ubPhm9Q5vADL6QLAcUM/nPXaEbD8H7gM2CzjWcdlLHeCaMBTYLNX8JGIiIiISEVSMkjKXl4W/sn/JiD5X1h5WQA4miTgqB9H4LLJGMDibABifk0P5fQsHIAYY9j0A3wyx7ByFbjc8QyNGrrvAhqQAEFBSgKJiIiIyNWjdevWfPDBB7Rv730nR3JyMnfffTd//etf6du3LwEB7udvvvPOO2zdupWxY8fy+OOPe/q/+uqrvPbaa7zzzjs89NBDnvbU1FSmT59O48aNmTNnDqGhoQDceeedjBgxgkmTJvHll1/i56dwsqLk5bmf/7Poa8OatZCX52632aB9O7il50F62t4iaPt8rDT3Q1Qd1/Ukt/N4XBHNAXBVu4bAZX+HzLSzGw6NJLvXUzibJFT0IYmIiIhIBdO3dyk7Lid+W+YTsOZVbL8+I8hZpzU5PZ7EVS8WABMSTuCyKViZhzyrmdBIcnp6ByAOh2Hpt+7nAW3bfnYXcR1g5HCLuA5gsykJJCIiIiJXn4SEov9w3759e+Lj41m1ahXbt2+nVatWGGOYPXs2wcHBPPjgg17977//fv773/8yZ84cxo8fj/VrDbF58+bhcDh44IEHPIkggCZNmnDzzTfz0UcfsW7dOrp27Vp+BykYY9jyozsB9M1SyMg4u+yG66F/gsWAzoeJ3PFP/DfPxnK6M0SORl3cSaBrvMsFOpskkHV9H+z7U7BOp2OqhrsrM+iOIBEREZGrgpJBUibsqasIWP4C9qM7AXBVr09Otz/gbNLfqzC1s0kCpxr3JnVlCrnH0gmoGU7jbu2w+7unYkaG4dOFMHe+4cgR9zoB/tA/wX0n0HXXKgEkIiIiIlKc/Lt18v+bmprK4cOH6dq1a6FScIGBgbRv355vvvmG3bt307hxYwCSkpIA6NKlS6Htd+vWjY8++oj169crGVRO9h9wPwNo0deGffvOtteqBQl93UmgJtccwz/pbfznfYTlzAHAUT+O3C4P4TpP6W1sdpwN4sr5CERERETkcqRkkFwSW/o2Ala8iN/uNQCYwOrkdvw/8trcDn4BhfovX2GYNt1GenoHT1t4ONwxykXqbvhyEeS4Yxlq1YRbhlrcPATCaigJJCIiIiJyPgcOHGDNmjWEh4cTFRUFwO7duwE8iZ5zNWrUyNMvv09qairBwcGEh4cX2z81NbVsB+/DnE7D95vg6DF3jNOmNdjt3vFNxinDsm9h0WJ3mex8QUHQoxsM6G8RGwP23BMEJP8L/88/wHKccW+/bgy5nR/C2bBjBR6ViIiIiFxplAySi2KdSiNgzav4bZmPhcHY/MmLuYPcuPuhSo0i11m+wvD0M6ZQe3o6TJt+9nVUExg5wqJ3TwgIUBJIRERERORC8vLyeOKJJ8jNzeWxxx7DbneX/jp16hQAISEhRa6X357fDyAzM5OaNWuet39mZmaZjd2XuS+GM6Snn20LD4cJ46FzJ0hMgq8WGVYXeA6QZbmfA9Q/waJ7VwgOtiA7g4DEmfhvmImVexoAZ2RLdxKocVevagwiIiIiIkVRMkhKJ/c0AevfxT/l31iObADyogaQ2/VRTI0Gxa7mdLqDoPMJDIAXnofYGMtTr1xERERERM7P5XLxxz/+kfXr1zNy5EiGDh1a2UOievXq2Gy2yh5Gpfp6SQ6T/pyJOScMSk+Hp58xBAdDVtbZ9qgmdm4aHMigGwOIjHQn80xOJq61b+Na/SZkn3R3rNMCe+8n8GuaQJCPxE1hYWGVPQS5gmi+SGlovkhpac5IaVxp80XJICkZlwO/zXMJWDMDW5b7YT7OurHkdH8cV922F1z9+014XQ1XlJxcsCwlgkRERERESsoYw6RJk1iwYAFDhgzhr3/9q9fy0NBQoPg7efLb8/uB++6fgncKFdW/uDuN8p08ebJkB+CjnE7D5OdNoURQQVlZUDMMEvr9+hygGwyQDWRz/HAW/t99SMD6d7GyT7i3Wet6cjuNx9mkH1g2OHGiAo6k/IWFhXH8+PHKHoZcITRfpDQ0X6S0NGekNC63+VKSxJSSQXJ+xmD/ZTmBK6ZiO/YTAK4aDcnp9gecN/QrcTmCvfvOf1dQvqPHLnqkIiIiIiJXFZfLxdNPP828efMYPHgwzz//fKG7cS70jJ/8Zwrl9wP384U2btxIenp6oecGXegZROJWkovhAP70NHRoX+A9c+Tgv+kj/JPe8VyE56rRiNxO43BE3wg2ezmNWERERER8nZJBUixb2hYCVryI395EAExQDXI7PUhe65FgDyjRNowxfLUYXn+zZPusVXRpchERERERKaBgImjgwIG88MILnucEFdS4cWMiIiLYsGEDWVlZBAcHe5bl5OSQnJxMRESEVzKoQ4cObNy4kdWrVxcqObdy5UpPHynaTz8b/jurZBfDnTj568V1zlx3JYbEt7BlpgHgql6f3I6/x9HsJrApdBcRERGRS6NvlFKIdeogAaum4b91AQDGHkBezJ3kxt0HQdVKvJ09ewxTXzZs2Oh+bbeD01l8/4gIaNP6UkYuIiIiIuL7CiaCBgwYwIsvvlhkIgjcZZhHjBjBa6+9xmuvvcbjjz/uWfbWW29x8uRJHnzwQa9SzcOGDeNf//oXb7zxBn369PGUkNu5cyeffvopDRs2pGPHjuV7kFeYrCzDkqWw8HPD1q3ey2w4ia2VQu2gdI5kh7PhaDtcuN+v2jXy8PthAQGJb2DLOACAK/QacuP/D0eLW8DuX9GHIiIiIiI+SskgOSsnk4D1b+OfMhPLmQNAXtPB5HaZgKler+SbyTG8/4Hhg1mQlweBgfDbMRbX1DH8+dni13t4nIXdrucFiYiIiIicz2uvvca8efMIDg6mcePGvPHGG4X69O3bl2bNmgEwduxYli5dyjvvvMPWrVtp0aIF27ZtY8WKFTRr1oyxY8d6rXvttdcybtw4pk2bxpAhQ+jfvz9ZWVl8/vnnOBwOnnvuOfz8FEoaY9i8BT77wrB0KZzJdrfb7dC1M3y3CdoFf80TLadQp0qaZ71DZyKZuvlJwsNy6Pzd69hP7gXAVTWcvLj7yWs1AvxKVolBRERERKSk9A1ewJmH3w+zCVj7GrYz7of2OOu1J6fHk7jqtCzVptYnG1562bBvv/t1p47wyMMWda+xAAs/P8O06carfnZEhDsR1KO7EkEiIiIiIheyf7/7y3ZWVhZvvll0PeZ69ep5kkHBwcG8//77zJgxg0WLFpGUlETt2rW5++67GTdunFfpuHwPPPAA9erVY+bMmcyaNQt/f39iYmJ46KGHaN366r6d//gJw6LF8NnnhtTdZ9sbNYTBgywGJEBYmMX2TxcTs+sRwLtkXGRQGi+2f9T9+NWT4KpSk7y435HXehT4B1XosYiIiIjI1cMyxpSsmLFckuPHj1fezl1O7PtTsE6nY6qG46zXzv3gUWOw/7SUwJVTsR1PdXcNu5ac7o/hvK4XWCVPzhw9apj+umHJN+7XtWu7Ezw9e+BVcgLA6TR8vwmOHnM/I6hNa3RH0K/CwsIqd67IFUdzRkpD80VKS3NGSuNymy9hYWGVPYSr2uU0F8qCy2VITnGXgVu5ChwOd3tgIPTp5U4CtWpZIPZxOQl+py9W5iGKi3QMFrldHiYvZjQEVK2Q47gcXW7nDrm8ab5IaWi+SGlpzkhpXG7zpSTxj+4M8nH2nYsJXDYFW+YhT5srpA55MXfg9/Ny7PuTATBVwsjpNA5HqxGlqkvtchkWLIQ3/2nIPA02Gwy7BX53j0XVqkWHPXa7RWzMpR2XiIiIiIhIeTuUZvjiS/j8S0Pa2UpvNI12J4D69oaQkMJxj31/ilcMVhQLg6tuzFWdCBIRERGRiqNkkA+z71xM0MIJnFuWwMo8RODKlwAw9kDy2o0ht8NYCAwt1fZ37jK8+JLhx18fkBodBY8/atG0qe7yERERERGRK1NenmH1GvddQEnrIb+WRkgIDEiAQQMtmtxw/pjHOp1+3uWl7SciIiIicqmUDPJVLieBy6bgLj7gzeLX9JBfFbLGLMBUr1+qTWdlGf71nmH2HHC6IDgYfnevxbChKvcmIiIiIiJXptTdhs8+N3y1GE6cONseG+O+C6hHNwgMLEG8Y1zYDm8t0T5N1fCLG6yIiIiISCkpGeSjLlSWwAJwnMGWcQBnKZJBq1Yb/t8rhsOH3a979nA/Gyg8XEkgERERERG5spw5Y1j2rfsuoB82n22vVQsG3giDb7SoV6/ksY7tyA4Cv3kW+/4UwH0RXlFrGyxMaKT7ea4iIiIiIhVAySAfVdZlCdIOG6a9Yli52v36mjrw6ASLTh2VBBIRERERkcuH02n4fhMcPQa1akKb1t4VDIwxbN/uTgB9/Q1kZbnb7Tbo1Ml9F1DHOPDzK0Wsk5dFwNrX8d8wE8vlwPhVwdGkH35bF/6aEDpbuju/dkNOz6fAZi+LQxYRERERuSAlg3xUScsNXKifw2GYMw/e/ZfhTDbY7TBqJPx2jEVQkBJBIiIiIiJy+Vi+wjBtuiG9wDVv4eEwYTzEtIXFS9xJoJ9+Oru8Xl13AujG/lC7duljHPtPSwlc+jdspw4C4Li+Dzm9/oipVhfHDX0IXDYFq0DVBhMaSU7Pp3A2SbjYwxQRERERKTUlg3yUs147XCF1sDLTvK5Cy1eSsgRbfjS8+JJh16+BUquW8PijFtddpySQiIiIiIhcXpavMDz9TOHYJz0dnn7G4GcHh9PdFuDvLnk9eJBF2zZgs5U+xrEyDhC47O/4/fQNAK5qdcnpNQnn9b08fZxNEsi6vg/2/SlYp9MxVcPdMZjuCBIRERGRCqZkkK+y2cnp9RRBCydgsEpVluDUKcNb7xg+XQDGQGgo/P5+i0EDLy5IEhERERERKU9Op/uOoPNxOOG66+DmwRb9+kG10IuMbZx5+G/4DwFrX8NynMHY/Mhrdze5HR8A/+DC/W12nA3iLm5fIiIiIiJlRMkgH+ZskkD2TdNKXJbAGMM3S2H6a4ajx9xt/RNg3AMWYWFKAomIiIiIyOXp+014lYYrzoTxEBtz8bGNbf8GApf8BfvRnYC7IkNOnz/jqt3korcpIiIiIlIRlAzycSUtS7Bvn+H/vWJIWu9+3aCBuyTcpQRKIiIiIiIiFSH/YrYL97vI+ObMcQJXvoT/5rkAmKAa5PR4AkfzoWApZhIRERGRy5+SQVeD85QlyM01fPgR/Od9Q26eu3b2naMt7vgNBAQoqBERERERkctfrZpl28/DuPDb8j8CV7yIlX0CgLyWw8np9ihUCSvlxkREREREKo+SQVcBp9Pw/Sb31XK1akKb1mC3W2zYaHjpZcPuPe5+7dvBHx6xaFBfSSAREREREblytGkN4eHnLxUXEeHuV1K2IzsI/OZZ7PtTAHDWakJO37/gqhd7iaMVEREREal4Sgb5uOUr3A9SLRgU1a4FDRoYNn7nfh0WBuMftOjXByyVOBARERERkSuM3W4xYTw8/Ywpts/D4yzs9hLEO3lZBKx9Hf8NM7FcDox/MLmdHiQv5k6w+5fhqEVEREREKo6SQT5s+QpTZDB05Kj7H8DNN8H991lUC1USSERERERErlw9ultMfpZCF8NFRLgTQT26Xzjmsf+0lMClf8N26iAAjuv7kNPrj5hqdctr2CIiIiIiFULJIB/ldLrvCDqfsDB4dEIJr44TERERERG5zPXobtG1C0WWyT4fK+MAgcv+jt9P3wDgqlaXnF6TcF7fqyKGLSIiIiJS7pQM8lHfbzp/vWyA48fd/WJjKmZMIiIiIiIi5c1ut0oe4zjz8N/wHwLWvoblOIOx+ZHX7rfkdvw/8A8u13GKiIiIiFQkJYN81NFjZdtPRERERETEl9j2byBwyV+wH90JgLNeO3L6/BlX7SaVPDIRERERkbKnZJCPqlWzbPuJiIiIiIj4hDPHCVwxFf8t8wAwVcLI6f44juZDwVIJbRERERHxTUoG+ag2rSE8/Pyl4iIi3P1ERERERER8hsuJfX8K1ul0TNVwnPXagc0OxoXflvkErpiKlX0CgLyWw8np9ihUCavcMYuIiIiIlDMlg3yU3W4xYTw8/Ywpts/D46wLPkhVRERERETkSmHfuZjAZVOwZR7ytLlC6pDX7m78dn2NfX8KAM7aUe6ScPViK2uoIiIiIiIVSskgH9aju8XkZ2HadON1h1BEhDsR1KO7EkEiIiIiIuIb7DsXE7RwAuB9QZyVeYiA5c9jAcY/mNxO48iLGQ12/8oYpoiIiIhIpVAyyMf16G7RtQt8vwmOHnM/I6hNa3RHkIiIiIiI+A6Xk8BlUwDDuZFO/mvjF0jWXZ9iqtev4MGJiIiIiFQ+JYOuAna7RWxMZY9CRERERESkfNj3p3iVhiuK5cjBlnEAp5JBIiIiInIVslX2AEREREREREQuhXU6/cKdStFPRERERMTXKBkkIiIiIiIiVzRTNbxM+4mIiIiI+Bolg0REREREROSK5qzXDldInSKeGORmsHCF1sFZr10Fj0xERERE5PKgZJCIiIiIiIhc2Wx2cno9BVAoIZT/OqfnU2CzV/jQREREREQuB0oGiYiIiIiIyBXP2SSB7JumYUIivdpNaCTZN03D2SShkkYmIiIiIlL5/Cp7ACIiIiIiIiJlwdkkgazr+2Dfn4J1Oh1TNdxdGk53BImIiIjIVU7JIBEREREREfEdNjvOBnGVPQoRERERkcuKysSJiIiIiIiIiIiIiIj4MCWDREREREREREREREREfJiSQSIiIiIiIiIiIiIiIj5MySAREREREREREREREREfpmRQKW3atInf/e53dOjQgbZt2zJ8+HAWLlxY2cMSEREREREpc4p/RERERER8g19lD+BKkpiYyL333ou/vz+DBg0iNDSUxYsX89hjj7F//37+7//+r7KHKCIiIiIiUiYU/4iIiIiI+A4lg0rI4XAwadIkLMvigw8+oHnz5gA8+OCDjBo1iunTpzNgwAAaN25cuQMVERERERG5RIp/RERERER8i8rEldC6devYs2cPgwcP9gRCACEhIfz+97/H4XAwb968ShyhiIiIiIhI2VD8IyIiIiLiW5QMKqGkpCQAunbtWmhZly5dvPqIiIiIiIhcyRT/iIiIiIj4FiWDSig1NRWARo0aFVpWvXp1wsLC2L17dwWPSkREREREpOwp/hERERER8S1KBpVQZmYmAKGhoUUuDwkJ4dSpUxU5JBERERERkXKh+EdERERExLf4VfYArhZhYWGVPQS5QmiuSGlpzkhpaL5IaWnOSGlovkg+zQUpDc0XKQ3NFykNzRcpLc0ZKY0rbb7ozqASCgkJASj26rfMzMxir5oTERERERG5kij+ERERERHxLUoGlVDjxo0BiqyLffLkSY4fP15kPW0REREREZErjeIfERERERHfomRQCXXo0AGAVatWFVq2evVqAOLi4ip0TCIiIiIiIuVB8Y+IiIiIiG9RMqiEOnXqRIMGDfjss8/YunWrpz0zM5PXX38dPz8/brnllkocoYiIiIiISNlQ/CMiIiIi4lssY4yp7EFcKdatW8fYsWPx9/dn8ODBhISEsHjxYvbt28eECRN44IEHKnuIIiIiIiIiZULxj4iIiIiI71AyqJQ2bdrEq6++ynfffUdeXh433HADY8aMYciQIZU9NKlAn376KSkpKWzevJkdO3aQl5fHlClTGDZsWJH9MzMzmT59OosXLyY9PZ3w8HASEhIYP3685+G851q4cCEzZ85k165d+Pv707ZtWx566CFatWpVZP/U1FRefvllEhMTycrKolGjRtx2223cfvvt2Gy6CbCypKWl8eWXX7JixQp+/vlnjhw5QvXq1YmNjWXs2LG0adOm0DqaL1e3jIwMXn31VX744Qf27dvHyZMnCQsL49prr+WOO+4gISEBy7K81tGckYLefvttpk6dCsDHH39M27ZtC/XRnLm69e7dm/379xe57LbbbuPZZ5/1atN8ubop/hFQ/COloxhISkPxj1wqxT9yIYp/zlIySOQi5J9EwsLCCA4OZv/+/cUGQ1lZWdx+++1s3bqVLl260Lx5c7Zt28bKlStp1qwZH374IcHBwV7rvPnmm7z88svUrVuX/v37k5WVxeeff05OTg7vvvsu8fHxXv137drFqFGjyM7OZsCAAURGRrJixQp27NjByJEjee6558r15yHFmzp1Km+//TYNGzakQ4cO1KpVi927d7NkyRKMMbz00ksMHDjQ01/zRXbv3s3QoUNp06YNDRs2pEaNGhw9epRly5Zx9OjRQu+R5owU9NNPPzF06FD8/PzIysoqMhjSnJHevXuTkZHBmDFjCi1r2bIlvXr18rzWfBERUPwjpaMYSEpD8Y9cCsU/UhKKfwowIlJqq1evNvv27TPGGPPWW2+ZqKgoM3fu3CL7vvLKKyYqKsq88MILRba/8sorXu2//PKLad68uUlISDAZGRme9h07dpg2bdqYvn37mry8PK917rjjDhMVFWW+/fZbT1tubq4ZM2aMiYqKMmvXrr2k45WLt2jRIrN+/fpC7evXrzctWrQwcXFxJicnx9Ou+SIOh6PQe2aMMadOnTIDBw40UVFRZseOHZ52zRnJ53A4zK233mqGDx9uHnvsMRMVFWU2btxYqJ/mjPTq1cv06tWrRH01X0TEGMU/UjqKgaQ0FP/IxVL8IyWl+Ocs3aMmchE6d+5MvXr1LtjPGMPs2bMJDg7mwQcf9Fp2//33U716debMmYMpcIPevHnzcDgcPPDAA4SGhnramzRpws0338yePXtYt26dp/2XX35h/fr1xMfH06NHD0+7v78/jzzyCACzZ8++6GOVS5OQkED79u0Ltbdv3574+HhOnDjB9u3bAc0XcbPb7fj5+RVqDwkJoWvXroD76jnQnBFvb7/9Ntu2bePvf/87dru9yD6aM1Iami8ikk/xj5SGYiApDcU/crEU/0hZuxrmi5JBIuUoNTWVw4cPExsbW+gWwsDAQNq3b09aWprniw1AUlISAF26dCm0vW7dugGwfv36Qv3zvyQV1Lp1a6pVq+bpI5eX/C+8+f/VfJHzycnJYd26dViWxQ033ABozshZO3bsYMaMGTzwwAM0adKk2H6aM5IvNzeX+fPn8+abb/Lhhx+ybdu2Qn00X0SktHTekAtRDCQlpfhHzkfxj5SW4h+3wql3ESkz+SeHxo0bF7m8UaNGnn75fVJTUwkODiY8PLzY/qmpqZ62/P/PX1aQZVk0bNiQzZs3c+bMGapUqXKRRyJl7cCBA6xZs4bw8HCioqIAzRfxlpGRwcyZM3G5XBw9epQVK1Zw8OBBxo0b53n/NWcEwOFwMHHiRK6//nruu+++8/bVnJF86enpTJw40autW7duvPDCC9SsWRPQfBGR0tN5Q85HMZCcj+IfKSnFP3IxFP+4KRkkUo5OnToFuG9vLkp+e34/gMzMTM9JqLj+mZmZXv0Br1sRi9uHfulcHvLy8njiiSfIzc3lscce89zOrPkiBWVkZDBjxgzPa39/f5544gnuueceT5vmjID7YZXbt2/nk08+wd/f/7x9NWcEYNiwYcTFxXHDDTcQEBDATz/9xIwZM1ixYgW///3vmTVrFpZlab6ISKnpvCHFUQwkF6L4R0pK8Y+UluKfs5QMEhGpQC6Xiz/+8Y+sX7+ekSNHMnTo0Moeklym6tevz/bt23E6nRw8eJAvvviCl19+mY0bNzJt2rQi62rL1Wfbtm28+eab3HPPPbRo0aKyhyNXiHHjxnm9btOmDW+99RajR48mJSWF5cuX07Nnz8oZnIiI+BzFQFISin+kJBT/yMVQ/HOWnhkkUo7ys7wFM8AFFZUNDgkJ8cowF9W/YIa6qKz0hdaRymGMYdKkSSxYsIAhQ4bw17/+1Wu55osUxW63U79+fe677z4mTJjA119/zSeffAJozgg8+eSTNGjQgPHjx5eov+aMFMdmszFs2DAANmzYAGi+iEjp6bwh51IMJKWl+EfOR/GPlJWrNf5RMkikHBVVG7Kg/FqUBetENm7cmKysLNLT04vtX7B25bm1cwsyxrBnzx4iIiIKPfhMKlb+1XBz585l8ODBPP/889hs3qdgzRe5kPwHDOY/TFBzRrZt28bPP/9Mq1atiI6O9vybP38+ALfddhvR0dEsWbIE0JyR8wsLCwPgzJkzgOaLiJSezhtSkGIguVSKf+Rcin+kLF2N8Y+SQSLlqHHjxkRERLBhwwaysrK8luXk5JCcnExERITXSaRDhw4ArF69utD2Vq5c6dUHIC4uDoBVq1YV6r9p0yYyMjI8faRyuFwunn76aebNm8fAgQN54YUXPDWyC9J8kQtJS0sD8MwfzRkZPnx4kf/yv2D27t2b4cOHU69ePUBzRs5v06ZNAJovInLRdN6QfIqBpCwo/pFzKf6RsnQ1xj9KBomUI8uyGDFiBFlZWbz22mtey9566y1OnjzJiBEjsCzL0z5s2DD8/Px44403vG4Z3LlzJ59++ikNGzakY8eOnvZrr72WDh06kJiYyPLlyz3teXl5TJs2DYARI0aU0xHKhRQMggYMGMCLL75YZBAEmi/itnXr1iJvFz5x4gQvv/wyAN27dwc0ZwQmT55c5L+YmBgA7r//fiZPnkyzZs0AzRmBXbt2kZGRUag9OTmZf//73wQEBJCQkABovohI6em8IaAYSEpH8Y+UhuIfKS3FP94sY4wpt62L+KjZs2eTkpICwI4dO9iyZQuxsbGezHDfvn3p27cvAFlZWdx+++1s3bqVLl260KJFC7Zt28aKFSto1qwZH374YaFb/9544w2mTZtG3bp16d+/P1lZWXz++efk5OTwzjvveJ1EwH1iGzVqFNnZ2dx4441ERESwcuVKtm/fzogRI/jb3/5WAT8VKcr06dOZMWMGwcHB3HXXXUU+9LJv376eLyqaLzJ58mTmzJlDfHw8devWpUqVKhw4cIBvv/2WrKws+vfvz7Rp0zwlNjRnpCgTJ05k/vz5fPzxx7Rt29ZrmebM1W369Om88847dOrUiXr16hEQEMCOHTtYvXo1NpuNv/71r17Bh+aLiIDiHykdxUBSGop/pCwo/pHiKP7xpmSQyEXI/yVTnHHjxnk9zO7UqVPMmDGDRYsWceTIEWrXrk3//v0ZN26c10PHClqwYAEzZ85k165d+Pv707ZtWx566CFat25dZP9ffvmFl19+mcTERLKysmjUqBG33XYbd9xxR6G6zFJxLjRXAKZMmeJ5aB1ovlztkpOTmTt3Lt999x2HDx8mOzub6tWr07x5c4YOHcqgQYO8rkIBzRkp7HzBEGjOXM2SkpL48MMP+fHHHzly5Ai5ubnUqlWLdu3acffddxf5fmq+iIjiHykNxUBSGop/pCwo/pHiKP7xpmSQiIiIiIiIiIiIiIiID1NaUkRERERERERERERExIcpGSQiIiIiIiIiIiIiIuLDlAwSERERERERERERERHxYUoGiYiIiIiIiIiIiIiI+DAlg0RERERERERERERERHyYkkEiIiIiIiIiIiIiIiI+TMkgERERERERERERERERH6ZkkIiIiIiIiIiIiIiIiA/zq+wBiIj4mujo6FL1r1evHkuXLi2n0ZRMdHT0ZTGO8rZv3z769OlDXFwc77//fmUPp8z95z//4eOPP2b37t3k5eVd8nFOnDiR+fPn85///If4+PgyHKmIiIiI+ArFP5cvxT+lo/hHRHydkkEiImXslltuKdSWkpLCnj17aNq0Kc2aNfNaFhYWVqrtXy2Bi5TO4sWLmTx5MtWrV6d3794EBwdz3XXXVfawRERERMTHKf6RyqD4R0Sk9JQMEhEpY88//3yhtokTJ7Jnzx769u3L+PHjK2FU4uuWLFkCwCuvvEKnTp0qeTQiIiIicrVQ/COVQfGPiEjp6ZlBIiIiPuDQoUMANGjQoJJHIiIiIiIiUr4U/4iIlJ6SQSIilez48eP84x//ICEhgVatWhEXF8e9997LqlWrvPrNmzfPU497//79REdHe/7deeednn5bt27lhRdeYNiwYXTs2JGWLVvSp08f/vKXv5CWllYmY544cSLR0dEkJiayfv167rrrLmJiYoiNjeW+++5j165d512nKNHR0fTu3bvIY54+fTp79uzh4YcfJj4+ntjYWMaOHevZj8Ph4M0336R///60atWKfv368cEHH5z3GDIzM/nb3/5Gjx49aNWqFTfeeCPvvfceLperyP6nT59mxowZ3HTTTbRp04bY2FhGjx7tuSKtoH379nnel8zMTJ5//nl69+5NixYtmDx58nnHle/gwYM888wz9OrVi5YtW9KpUyfGjRvHpk2bvPpNnz7d6+fap08fz7wo7md9rkWLFjF8+HBat25N586deeKJJ847V/Lfq9zcXGbMmMGAAQNo2bIlv//97wHIyclh9uzZPPDAA/Tp04fWrVvTvn177rjjDj7//PNC23v11VeJjo5m/vz5Xu0//PCD51iSkpK8ln311VdER0fzj3/8w9OWl5fHRx99xPDhw4mPj6dNmzb07t2b+++/v8j9ioiIiEjFU/zjpvjHm+IfxT8iUv5UJk5EpBKlpaVxxx13sHfvXurWrUvfvn05duwYa9euZdWqVTz11FPcfffdADRs2JBbbrmF+fPnExwcTP/+/T3bKVgb+Z///CeLFi2iSZMmxMbGYlkWW7duZdasWSxZsoS5c+cSGRlZJuNftmwZ//nPf2jSpAndunVj+/btLF++nO+//57PPvuM8PDwMtnPvn37GDFiBKGhocTFxZGamsrKlSvZsmULCxYs4M9//jPr1q0jJiaG+vXrk5iYyLPPPou/vz8jR44stL3c3Fzuuusu9u7dS8eOHcnLy2Pt2rVMmTKF7du3M2XKFK/+R44cYcyYMezatYvIyEg6d+5MdnY23333HQ8++CB/+MMfuO+++wrtJzs7m9GjR3PgwAE6dOhAixYtqF69+gWPd/v27YwZM4bjx49z3XXXkZCQwIEDB/j6669ZtmwZU6dO5cYbbwSgWbNm3HLLLaxcuZIjR47Qv39/goODAahdu/YF9/Xf//6X5557DrvdTocOHQgLC2PNmjUkJSXRtGnTYtdzuVw8+OCDJCcn06FDB6Kjo6lRowbgfr8mTZpE7dq1ue6662jdujVHjhxh48aNJCcn8/PPP3uVC4mLi+O1114jMTHRq+Z8wQAoMTGRuLi4QssKtj3xxBN88cUXhIWFERMTQ5UqVUhLSyM5OZmsrCwGDRp0wZ+HiIiIiJQfxT8lo/hH8Y/iHxEpF0ZERMrdk08+aaKiosyrr77q1X7//febqKgo8/jjj5vc3FxP+/r1602bNm1Ms2bNzNatW73WiYqKMr169Sp2X2vWrDFpaWlebU6n00yfPt1ERUWZiRMnFlrnQtss7niaNm1qFi5c6Gl3OBxm/PjxJioqykybNq3IddatW1fkNosaw9y5c01UVJSJiooyU6ZMMU6n0xhjjMvlMhMnTjRRUVFm4MCBZvDgwebgwYNeP4Oitrd3717P9m666SZz9OhRz7Ldu3ebrl27mqioKLNkyRKv9caOHWuioqLMCy+84PU+7dmzx/Tt27fQ+1RwP7fddps5efLkeX+eBblcLjN48GATFRVlXnrpJeNyuTzLvvzyS9O0aVMTExNj0tPTvdYbPXq0iYqKMnv37i3xvvbu3WtatmxpWrZs6fW+ZGVlmd/+9reeYzj3Pctv79evnzl06FCh7R47dsysXLnS837l27Nnj+nVq5dp2rSp1zizs7NNy5YtC71f9913n2nfvr3p1q2bGT16tNeyQYMGmaZNm5qMjAzPsURFRZlbb73VZGdne/U9c+aM2bBhQ4l/LiIiIiJyaRT/KP4pKcU/Zyn+EZHypjJxIiKVZO/evSxbtoyQkBAmTZqEv7+/Z1n79u0ZNWoUTqeTDz/8sFTb7dSpExEREV5tNpuNcePGERkZydKlS8tk/ACDBw9m8ODBntd2u537778fgOTk5DLbT8OGDXnsscew2dy/tizL8lwxuGvXLp5++mnq1Knj6d+pUyeaN2/O/v372bdvX5HbfPLJJ6lZs6bXPvJv8y/4M9+6dSsrVqwgJiaGxx57zOt9atCgAU8++SROp5M5c+YUuZ+nn36aatWqlfhYExMT2bFjB/Xr1+fhhx/GsizPsgEDBtC3b19Onz7NvHnzSrzN4sydO5fc3FyGDh1KfHy8p71KlSpMmjTJa99FefTRR4u8yjIsLIyuXbt63q98DRo04IEHHsDlcrFs2TJPe2BgIK1bt/Z6v1wuFykpKbRr1464uDi+++47cnJyADh27Bi7du2iWbNmhIaGetoAYmJiCAwM9NpvUFAQMTExJf2xiIiIiEg5UPxTcop/3BT/KP4RkbKlMnEiIpUkJSUFgB49ehT5Zfnmm2/m3//+t6dfaRw/fpylS5eyc+dOMjIyPHWgHQ4HJ06c4MSJE55b2i9Fly5dCrU1btwYgMOHD1/y9vPFxcXh5+f9Kyv/QaH+/v5et8oXXP7jjz+Snp5O/fr1vZbVqFGjyLHfdNNN/OUvf2HDhg0YY7Asi9WrVwPuWtRFBQft2rUD3PWdzxUeHk6rVq1KeJRu+UHkwIEDsdvthZbffPPNLF68mOTk5CJLM5RG/tzKL7lQ0HXXXUfz5s3ZsmVLketallWoxvm5kpOTSUpKIi0tjdzcXIwxpKenA7B7926vvnFxcZ7+9evX58cff+TUqVPEx8cTEhLCwoUL+e6774iPj2f9+vUYY7ze9+uuu47g4GDmzZtHkyZN6NevH2FhYaX6eYiIiIhI+VH8U3KKf85S/KP4R0TKjpJBIiKVJD9YqFevXpHL89tLG1R89tln/OlPfyIrK6vYPqdPny6TYKjg1Wj5qlatCrgfZllWirr6Kr8udHh4eKErsAouz83NLbSsbt26Re4nJCSEatWqkZGRQWZmJqGhoezfvx+AqVOnMnXq1GLHePz48RLv53zKa16cb1/XXHNNkcuvueaaYoOhWrVqERAQUOSyU6dOMW7cONatW1fsvk+fPu31Oi4ujtdff52kpCSGDRvmqYkdHx/vmVNJSUnEx8cXWS87JCSE5557jj/96U/86U9/4plnnuHaa68lPj6eoUOH0rZt22LHIiIiIiLlT/FPySn+OUvxj+IfESk7SgaJiFSy4m5Fz2+/0K3qBe3fv5+JEycC8Mc//pGePXsSGRlJUFAQAKNGjWLjxo0YYy5x1N5jvFT5V+5dzH7Kagz5zv3ZOJ1OwF26Iv9qvKIUdRXWubfrl8aFjqssjjv/WC9mW+c7thdffJF169bRoUMHHnroIZo0aUK1atWw2+2sWrWKe++9t9DPOSYmBn9/f0+gk5SURLVq1WjatCk2m406dep4LbPZbLRv395rG4MHD6Zz58588803rFq1ivXr1zNr1ixmzZrFvffeyxNPPFHq4xQRERGRsqX4R/FPURT/KP4RkfKnZJCISCXJr2tdXE3n/CuywsPDS7zN5cuXk5eXxz333MOYMWMKLd+7d+9FjLRs5NeaLuqKvYMHD1boWA4cOFBke2ZmJqdOnSI4OJiQkBDg7NV//fv356677ir3sZXHvDjfvlJTUzlw4ICnvEVBF/u+LFmyBLvdzhtvvOGpaZ2vuDkYFBRE69atSUlJYe/evaSkpNC+fXvPVY8dOnRg0aJFpKWlsXPnTpo1a1ZkeZGaNWsyYsQIRowYgTGGlStX8sgjj/Duu+8ybNgwbrjhhos6JhERERG5NIp/zlL8c5biH8U/IlJxCt9XKiIiFSK/1vK3335LRkZGoeWffvqpV798/v7+OByOIreZv52iyhesX7+eI0eOXNKYL0X+l/fU1NRCy/LrUleUEydOsGbNmkLtn332GeC+Siv/arHOnTsD7i/4FSH/aq8vvvjCc1VeQQsWLPDqdyny59ZXX31VaNkvv/zC1q1bL2q7GRkZVK1atVAgBPDll18Wu15+2YOZM2eSkZHh9VDX+Ph4cnNzefvttwvVyy6OZVl0796dnj17ArBjx45SHomIiIiIlBXFP2cp/jlL8Y/iHxGpOEoGiYhUkgYNGtCzZ09Onz7N5MmTvWpMb9y4kY8++gi73c7tt9/utV5ERARHjx4tMoDKv7ppwYIFXlegpaWl8ec//7l8DqSEOnToAMCsWbO86ktv2bKFV155pcLH88ILL3iNY+/evbz++usAXj/ztm3b0qlTJxITE/n73/9eqNazy+Vi1apVngefXqr4+HiioqLYt28fr776qlc5gSVLlvD1118THBzMLbfccsn7uvXWW/H39+d///uf1/izs7OZPHnyBctXFKdx48ZkZGTwxRdfeLW/9957JCYmFrtefoDzySefAHgFQ+cuOzcY+vHHH1m8eHGhWu0nT57k+++/By6uhrmIiIiIlA3FP26Kf7wp/lH8IyIVR2XiREQq0bPPPsvtt9/O//73P9avX0/btm05duwYSUlJOJ1OJk6cSNOmTb3W6d27N++//z633HILMTExBAYGcu211zJ27Fh69+5NkyZN2Lx5MwkJCcTGxpKTk0NiYiJNmzYlJiaGjRs3VsqxduzYkbi4OJKSkhg0aBCxsbEcO3aMTZs2ceedd/Kvf/2rwsbStm1b8vLy6N+/Px07diQ3N5d169Zx5swZhgwZQt++fb36T506lXvuuYeZM2fy6aef0rRpU2rWrElaWhq//PILx44d46mnniqTq9Usy2Lq1KncddddvPnmm3z99dc0a9aMAwcOsGHDBvz8/Pj73/9eJmUSGjRowGOPPcaUKVO46667iIuLIywsjOTkZGw2G7169WLZsmWl3u59993H448/ziOPPMIHH3xAnTp12LZtGz///DN333037733XpHr5dfNzsnJoXr16kRHR3uWNWrUiDp16nDo0KEi62UfOHCA8ePHExoaSsuWLalduzanTp0iOTmZzMxM+vXrp4eoioiIiFQyxT+Kf86l+Efxj4hUHN0ZJCJSiSIjI5kzZw733HMPdrudxYsXs2XLFjp16sS7777Lb3/720LrPProo4wePRqn08mXX37JnDlzWL58OQABAQF88MEH/OY3vyEgIIBly5bx008/MXr0aP7973976lZXBsuyeP311xk1ahSWZbF8+XIyMjJ4+umnefLJJyt0LAEBAcycOZNBgwaxceNGVq1aRZ06dXjyySd5/vnnC/WvXbs2n3zyCU899RSNGjXihx9+YMmSJRw6dIjmzZvzzDPPMGTIkDIbX3R0NPPnz2fkyJFkZWWxaNEifvnlF/r27cusWbO48cYby2xfd999N9OmTaNp06akpKSwdu1a4uLi+OSTT6hRo8ZFbXPIkCH885//pG3btmzdupUVK1YQERHBzJkz6d27d7HrValShVatWgF41cvOl391ZXR0NNWrV/da1qZNGyZMmECLFi345Zdf+Oqrr9i8eTPR0dH84x//YNq0aRd1LCIiIiJSdhT/KP4piuIfxT8iUjEsU/D+SxEREREREREREREREfEpujNIRERERERERERERETEhykZJCIiIiIiIiIiIiIi4sOUDBIREREREREREREREfFhSgaJiIiIiIiIiIiIiIj4MCWDREREREREREREREREfJiSQSIiIiIiIiIiIiIiIj5MySAREREREREREREREREfpmSQiIiIiIiIiIiIiIiID1MySERERERERERERERExIcpGSQiIiIiIiIiIiIiIuLDlAwSERERERERERERERHxYUoGiYiIiIiIiIiIiIiI+DAlg0RERERERERERERERHzY/wcfhlM7hnryZAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "az.plot_ess(inference_data, kind=\"evolution\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Posterior density plots" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([,\n", + " ], dtype=object)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "az.plot_posterior(inference_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Given the 100 we observed, the posterior is centered around true underlying parameters theta_o: tensor([[1.9622, 0.7550]])\n" + ] + } + ], + "source": [ + "print(\n", + " f\"Given the {num_trials} we observed, the posterior is centered around true underlying parameters theta_o: {theta_o}\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "az.plot_pair(inference_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[, None],\n", + " [,\n", + " ]], dtype=object)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "az.plot_pair(\n", + " inference_data,\n", + " var_names=[\"theta\"],\n", + " kind=\"hexbin\",\n", + " marginals=True,\n", + " figsize=(10, 10),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('sbi')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "9ef9b53a5ce850816b9705a866e49207a37a04a71269aa157d9f9ab944ea42bf" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}