From e6418b2a24b677915ccce3e53b3c335f32fc0937 Mon Sep 17 00:00:00 2001 From: cab14bacc <86755693+Cab14bacc@users.noreply.github.com> Date: Wed, 6 May 2026 16:31:43 +0300 Subject: [PATCH 01/23] feat(compute_rank_statistics): introduce param_transform and re-evaluation of rank statistics of another quantity via compute_rank_statistics --- simuk/sbc.py | 68 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 68 insertions(+) diff --git a/simuk/sbc.py b/simuk/sbc.py index 5394388..95270cb 100644 --- a/simuk/sbc.py +++ b/simuk/sbc.py @@ -305,6 +305,73 @@ def _convert_to_datatree(self): } }, ) + def compute_rank_statistics(self, param_transform=None): + """Compute the rank statistic for the reference parameters. + + This method computes the rank of each reference parameter value + relative to the newly sampled posterior draws for each simulation. + + This allows users to recompute rank statistics rapidly using a + different parameter transformation without needing to rerun the simulations. + + Parameters + ---------- + param_transform : callable, optional + A function that accepts two arguments: `(param_name, param_value)`. + This function is applied to both the posterior draws and the + reference parameter draws before computing the rank. For instance, + it can be used to take the mean over a vectorized parameter grouping. + If None, defaults to the `param_transform` passed during class + initialization. + + Returns + ------- + xarray.DataTree + An xarray.DataTree containing the computed rank statistics, matching + the output structure generated by `run_simulations`. + """ + if param_transform is None: + param_transform = self._param_transform + elif not callable(param_transform): + raise ValueError("`param_transform` should be a function or None") + + simulations = {name: [] for name in self.var_names} + + for idx, posterior in enumerate(self.posteriors): + for name in self.var_names: + if self.engine == "numpyro": + transformed_posterior = np.array( + [ + param_transform(name, posterior[name].sel(chain=0).isel(draw=i).values) + for i in range(posterior[name].sizes["draw"]) + ] + ) + simulations[name].append( + ( + transformed_posterior + < param_transform(name, self.ref_params[name][idx]) + ).sum(axis=0) + ) + else: + transformed_posterior = np.array( + [ + param_transform(name, posterior[name].isel(sample=i).values) + for i in range(posterior[name].sizes["sample"]) + ] + ) + simulations[name].append( + ( + transformed_posterior + < param_transform(name, self.ref_params[name].isel(sample=idx).values) + ).sum(axis=0) + ) + + self.simulations = { + k: np.stack(v)[None, :] + for k, v in simulations.items() + } + self._convert_to_datatree() + return self.simulations def compute_rank_statistics(self, transform=None): """Compute the rank statistic for the reference parameters. @@ -432,6 +499,7 @@ def run_simulations(self): progress.close() + @quiet_logging("numpyro") @quiet_logging("numpyro") def _run_simulations_numpyro(self): """Run all the simulations for Numpyro Model.""" From a51f926fefae333b44d697fbbe96b8af7b7f7bc1 Mon Sep 17 00:00:00 2001 From: cab14bacc <86755693+Cab14bacc@users.noreply.github.com> Date: Thu, 7 May 2026 10:54:55 +0300 Subject: [PATCH 02/23] feat(posterior sbc): Implement Posterior SBC --- simuk/sbc.py | 486 +++++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 413 insertions(+), 73 deletions(-) diff --git a/simuk/sbc.py b/simuk/sbc.py index 95270cb..3ee4733 100644 --- a/simuk/sbc.py +++ b/simuk/sbc.py @@ -1,6 +1,20 @@ -"""Simulation based calibration (Talts et. al. 2018) in PyMC.""" +"""Simulation-based calibration checking (SBC) for PyMC, Bambi, and NumPyro. + +Implements both Prior SBC (Talts et al., 2020) and Posterior SBC +(Säilynoja et al., 2025). + +References +---------- +.. [1] Talts, S., Betancourt, M., Simpson, D., Vehtari, A., & Gelman, A. (2020). + Validating Bayesian Inference Algorithms with Simulation-Based Calibration. + arXiv:1804.06788. +.. [2] Säilynoja, T., Schmitt, M., Bürkner, P.-C., & Vehtari, A. (2025). + Posterior SBC: Simulation-Based Calibration Checking Conditional on Data. + arXiv:2502.03279. +""" import logging +import traceback from copy import copy from importlib.metadata import version @@ -45,61 +59,161 @@ def wrapped(cls, *args, **kwargs): class SBC: - """Set up class for doing SBC. + r"""Simulation-based calibration checking (SBC). + + Supports two modes of operation: + + - **Prior SBC** (``method="prior"``, default): validates that the inference + algorithm across the prior. Reference draws come from the prior and replicated data + from the prior predictive (Talts et al.,` 2020 [1]_). + - **Posterior SBC** (``method="posterior"``): validates that the inference + algorithm across the posterior. Reference draws come from the original posterior + and replicated data from the posterior predictive. The model is then re-fit on the + concatenation of the original observations and the replicated data + (Säilynoja et al., 2025 [2]_). Parameters ---------- model : pymc.Model, bambi.Model or numpyro.infer.mcmc.MCMCKernel - A PyMC, Bambi model or Numpyro MCMC kernel. If a PyMC model the data needs to be defined as - mutable data. - num_simulations : int - How many simulations to run - sample_kwargs : dict[str] -> Any - Arguments passed to pymc.sample or bambi.Model.fit - seed : int (optional) + A PyMC, Bambi model or NumPyro MCMC kernel. If a PyMC model the + data needs to be defined as mutable data. + method : {"prior", "posterior"}, default "prior" + Which variant of SBC to perform. + num_simulations : int, default 1000 + How many SBC iterations to run. + sample_kwargs : dict, optional + Keyword arguments forwarded to ``pymc.sample`` (or + ``bambi.Model.fit`` / ``numpyro.infer.MCMC``). + seed : int, optional Random seed. This persists even if running the simulations is paused for whatever reason. - data_dir : dict + data_dir : dict, optional Keyword arguments passed to numpyro model, intended for use when providing an MCMC Kernel model. - simulator : callable - A custom simulator function that takes as input the model parameters and - a int parameter named `seed`, and must return a dictionary of named observations. + simulator : callable, optional + A custom data-generating function. It receives the model + parameter values as keyword arguments plus a ``seed`` integer, + and must return a ``dict`` mapping observed-variable names to + numpy arrays. + trace : arviz.InferenceData, optional + Required for ``method="posterior"``. An InferenceData object that + contains both the ``posterior`` and ``observed_data`` groups. + The number of posterior draws per chain must be at least ``num_simulations``. + augment_observed : callable, optional + *Posterior SBC only.* Signature: + ``(model, observed_data, replicated_data, simulation_idx) -> dict``. + Builds the augmented observed data that the model will be + conditioned on. ``observed_data`` is the xarray Dataset from + ``trace["observed_data"]``, and ``replicated_data`` is a + ``dict[str, np.ndarray]`` of the simulated observations from the + original posterior predictive for the current iteration. + The returned ``dict`` maps variable names to the augmented data. + + The **default** behaviour concatenates the original and replicated + observations along the first axis for each variable. Provide + this callback when simple concatenation is not valid, e.g. for + structured data. + update_data : callable, optional + *Posterior SBC only.* Signature: + ``(model, augmented_data, simulation_idx) -> None``. + Called *before* conditioning the model on the augmented data. + Use this to resize covariates, coordinate labels, or other + ``pm.Data`` containers so that the model is consistent with the + augmented dataset. transform : callable, optional A transform applied to both the reference draw and the posterior draws before computing the rank statistic. Signature: - ``(param_name, param_value) -> transformed_value``. Useful for defining scalar - test quantities (e.g. ``lambda param_name, param_value: np.mean(param_value)`` - to test the mean of a vector parameter). The return values must be comparable - with the ``<`` operator. The default is the identity (rank on the raw parameter values). + ``(param_name, param_value) -> transformed_value``. + Useful for defining scalar test quantities (e.g. + ``lambda param_name, param_value: np.mean(param_value)`` to test the mean + of a vector parameter). The return values must be comparable with the ``<`` + operator. The default is the identity (rank on the raw parameter values). keep_fits : bool, default True Whether to store posteriors to allow re-evaluation of rank statistics using a different quantity (``compute_rank_statistics``) without needing to run the simulations again. - Example - ------- + Notes + ----- + **Prior SBC** exploits the self-consistency of Bayesian updating: + if :math:`\\theta' \\sim \\pi(\\theta)` and + :math:`y' \\sim \\pi(y \\mid \\theta')`, then :math:`\\theta'` is also + a draw from :math:`\\pi(\\theta \\mid y')`. See Talts et al. (2020). + + **Posterior SBC** uses the same self-consistency after conditioning + on observed data :math:`y_{\\text{obs}}`. A draw + :math:`\\theta'_i \\sim \\pi(\\theta \\mid y_{\\text{obs}})` and a + replicated dataset :math:`y_i \\sim \\pi(y \\mid \\theta'_i)` are + combined so that :math:`\\theta'_i` is also a draw from + :math:`\\pi(\\theta \\mid y_i, y_{\\text{obs}})`. The rank of + :math:`\\theta'_i` among augmented-posterior draws should be + uniformly distributed if the inference is calibrated. + See Säilynoja et al. (2025). + + References + ---------- + .. [1] Talts, S., Betancourt, M., Simpson, D., Vehtari, A., & Gelman, A. + (2020). Validating Bayesian Inference Algorithms with Simulation-Based + Calibration. arXiv:1804.06788. + .. [2] Säilynoja, T., Schmitt, M., Bürkner, P.-C., & Vehtari, A. (2025). + Posterior SBC: Simulation-Based Calibration Checking Conditional on + Data. arXiv:2502.03279. + + Examples + -------- + **Prior SBC** (default): + + .. code-block:: python - .. code-block :: python + import pymc as pm + import simuk with pm.Model() as model: x = pm.Normal('x') y = pm.Normal('y', mu=2 * x, observed=obs) - sbc = SBC(model) + sbc = simuk.SBC(model, num_simulations=200) + sbc.run_simulations() + + **Posterior SBC** – validate inference conditional on observed data: + + .. code-block:: python + + import pymc as pm + import simuk + + with pm.Model() as model: + x = pm.Normal('x') + y = pm.Normal('y', mu=2 * x, observed=obs) + + # 1. Obtain posterior samples from the real data + trace = pm.sample() + + # 2. Run posterior SBC + sbc = simuk.SBC( + model, + method="posterior", + trace=trace, + num_simulations=200, + ) sbc.run_simulations() """ def __init__( self, model, + method="prior", num_simulations=1000, sample_kwargs=None, seed=None, data_dir=None, simulator=None, + trace=None, + augment_observed=None, + update_data=None, transform=None, keep_fits=True, + progress_bar=True, ): if hasattr(model, "basic_RVs") and isinstance(model, pm.Model): self.engine = "pymc" @@ -121,7 +235,12 @@ def __init__( raise ValueError( "model should be one of pymc.Model, bambi.Model, or numpyro.infer.mcmc.MCMCKernel" ) - self.num_simulations = num_simulations + + if method == "posterior" and self.engine != "pymc": + raise NotImplementedError("Currently, Posterior SBC is only implemented for PyMC") + + self.progress_bar = progress_bar + if sample_kwargs is None: sample_kwargs = {} if self.engine == "numpyro": @@ -132,9 +251,12 @@ def __init__( sample_kwargs.setdefault("progressbar", False) sample_kwargs.setdefault("compute_convergence_checks", False) self.sample_kwargs = sample_kwargs + + self.num_simulations = num_simulations self.seed = seed self._seeds = self._get_seeds() - self._extract_variable_names() + + self._extract_model_info() self.simulations = {name: [] for name in self.var_names} self._simulations_complete = 0 self.posteriors = [] @@ -152,9 +274,9 @@ def __init__( # Ideally, we could raise an error early for `numpyro` also, # but `factor` also produces 'observed_vars' raise ValueError( - "There are no observed variables, and PyMC will not generate prior " - "predictive samples. Either change the model or specify a simulator " - "with the `simulator` argument." + "There are no observed variables, and PyMC will not generate predictive " + "samples for both Prior and Posterior SBC. Either change the model or " + "specify a simulator with the `simulator` argument." ) if simulator is None and self.engine == "numpyro": @@ -178,8 +300,54 @@ def __init__( raise ValueError("`param_transform` should be a function or None") self._transform = transform - def _extract_variable_names(self): - """Extract observed and free variables from the model.""" + self.method = method.lower() + if method == "posterior": + if trace is None: + raise ValueError( + "When performing Posterior SBC, posterior samples from the " + "original posterior are required to generate replicate datasets" + ) + if "posterior" not in trace.groups(): + raise ValueError("`trace` should contain 'posterior' group") + if "observed_data" not in trace.groups(): + raise ValueError("`trace` should contain 'observed_data' group") + if self.num_simulations > trace["posterior"].sizes["draw"]: + raise ValueError( + "posterior samples in `trace` should have more draws per " + "chain than `num_simulations`. This is required to obtain enough " + "posterior predictive samples" + ) + self.trace = trace + + if augment_observed is not None and not callable(augment_observed): + raise ValueError("`augment_observed` should be a function or None") + self.augment_observed = augment_observed + + if update_data is not None and not callable(update_data): + raise ValueError("`update_data` should be a function or None") + self.update_data = update_data + + else: + if update_data is not None: + logging.warning( + "`update_data` is only supported for Posterior SBC. Ignoring...\n" + "Prior SBC does not augment observations, so there is no need to " + "update model data." + ) + if augment_observed is not None: + logging.warning( + "`augment_observed` is only supported for Posterior SBC. Ignoring...\n" + "Prior SBC does not augment observations, so there is no need to " + "augment observed data and replicated data" + ) + if trace is not None: + logging.warning("`trace` is only used for Posterior SBC. Ignoring...") + + def _extract_model_info(self): + """Extract observed and free variables from the model. + + Also records the baseline state for Posterior SBC. + """ if self.engine == "numpyro": self.model_params = set(inspect.signature(self.model).parameters.keys()) with trace() as tr: @@ -204,14 +372,75 @@ def _extract_variable_names(self): ] else: - self.observed_vars = [obs.name for obs in self.model.observed_RVs] + observed_var_nodes = [obs_rv for obs_rv in self.model.observed_RVs] + self.observed_vars = [obs.name for obs in observed_var_nodes] self.var_names = [v.name for v in self.model.free_RVs] + # Stores what observed values are given by pm.Data + self.observed_rvs_to_pm_data = { + var.name: ( + self.model.rvs_to_values[var].name + if hasattr(self.model.rvs_to_values[var], "get_value") + else None + ) + for var in observed_var_nodes + } + self.model_baseline_state = self._get_baseline_state(self.model) + + def _get_baseline_state(self, model): + """Extract the current mutable data and coordinates from a PyMC model.""" + baseline_data = {} + + # Extract Mutable Data + for var in model.data_vars: + if hasattr(var, "get_value"): + baseline_data[var.name] = var.get_value(borrow=False) + + # Extract Coordinates + # Convert the internal PyMC coordinate object to a standard dictionary + baseline_coords = dict(model.coords) + + return {"data": baseline_data, "coords": baseline_coords} + + def _reset_model_state(self, model, model_state): + """Reset the state of PyMC model.""" + with model: + pm.set_data(model_state["data"], coords=model_state["coords"]) def _get_seeds(self): """Set the random seed, and generate seeds for all the simulations.""" rng = np.random.default_rng(self.seed) return rng.integers(0, 2**30, size=self.num_simulations) + def _get_simulator_data(self, free_rv_samples): + """Run the user-defined simulator to obtain predictive samples. + + These samples can be generated from either prior or posterior samples. + """ + # Deal with custom simulator + pred = [] + for i in range(free_rv_samples.sizes["sample"]): + params = { + var: free_rv_samples[var].isel(sample=i).values for var in free_rv_samples.data_vars + } + params["seed"] = self._seeds[i] + try: + res = self.simulator(**params) + assert isinstance( + res, Mapping + ), f"Simulator must return a dictionary, got {type(res)}" + pred.append(res) + except Exception as e: + raise ValueError( + f"Error generating prior predictive sample with parameters {params}: {e}." + ) + pred = dict_to_dataset( + {key: np.stack([pp[key] for pp in pred]) for key in pred[0]}, + sample_dims=["sample"], + coords={**free_rv_samples.coords}, + ) + + return pred + def _get_prior_predictive_samples(self): """Generate samples to use for the simulations.""" with self.model: @@ -219,29 +448,13 @@ def _get_prior_predictive_samples(self): draws=self.num_simulations, random_seed=self._seeds[0] ) prior = extract(idata, group="prior", keep_dataset=True) + if self.simulator is None: prior_pred = extract(idata, group="prior_predictive", keep_dataset=True) return prior, prior_pred - # Deal with custom simulator - prior_pred = [] - for i in range(prior.sizes["sample"]): - params = {var: prior[var].isel(sample=i).values for var in prior.data_vars} - params["seed"] = self._seeds[i] - try: - res = self.simulator(**params) - assert isinstance(res, Mapping), ( - f"Simulator must return a dictionary, got {type(res)}" - ) - prior_pred.append(res) - except Exception as e: - raise ValueError( - f"Error generating prior predictive sample with parameters {params}: {e}." - ) - prior_pred = dict_to_dataset( - {key: np.stack([pp[key] for pp in prior_pred]) for key in prior_pred[0]}, - sample_dims=["sample"], - coords={**prior.coords}, - ) + + prior_pred = self._get_simulator_data(prior) + return prior, prior_pred def _get_prior_predictive_samples_numpyro(self): @@ -265,16 +478,81 @@ def _get_prior_predictive_samples_numpyro(self): prior_pred = {k: v for k, v in samples.items() if k in self.observed_model_vars} return prior, prior_pred - def _get_posterior_samples(self, prior_predictive_draw): - """Generate posterior samples conditioned to a prior predictive sample.""" - new_model = pm.observe(self.model, prior_predictive_draw) - with new_model: - check = pm.sample( - **self.sample_kwargs, - random_seed=self._seeds[self._simulations_complete], - ) + def _get_posterior_samples(self, replicated_data): + """Fit the model and return posterior draws for one SBC iteration. + + For **Prior SBC** the model is conditioned on the replicated data + alone. For **Posterior SBC** the original observed data and the + replicated data are combined (via ``augment_observed`` or the default + simple concatenation) and the model is conditioned on the augmented + dataset. + + Parameters + ---------- + replicated_data : dict[str, np.ndarray] + Simulated observations for the current iteration, keyed by + observed-variable name. + + Returns + ------- + xarray.Dataset + Posterior draws from the (augmented) model. + """ + if self.method == "posterior": + observed_data = self.trace["observed_data"] + + if self.augment_observed is not None: + augmented_data = self.augment_observed( + self.model, observed_data, replicated_data, self._simulations_complete + ) + else: + # Default: concatenate original and replicated observations + augmented_data = { + var_name: np.concatenate( + [observed_data[var_name].values, replicated_data[var_name]] + ) + for var_name in self.observed_vars + } + + if self.update_data is not None: + with self.model: + self.update_data(self.model, augmented_data, self._simulations_complete) + + vars_to_observations = augmented_data + else: + # Prior SBC simply uses the generated prior predictive replicated data + vars_to_observations = replicated_data + + # Set observed data that are pm.Data objects if the user hasn't modified them yet. + # We enforce an np.array_equal check against the baseline to prevent PyMC size mismatch + # ValueErrors when the user's `update_data` hook or `pm.observe` already updated it. + with self.model: + for rv, data_node in self.observed_rvs_to_pm_data.items(): + if ( + data_node is not None + and np.array_equal( + self.model.named_vars[data_node].get_value(), + self.model_baseline_state["data"][data_node], + ) + ): + pm.set_data(new_data={data_node: vars_to_observations[rv]}) + + try: + new_model = pm.observe(self.model, vars_to_observations=vars_to_observations) + with new_model: + check = pm.sample( + **self.sample_kwargs, random_seed=self._seeds[self._simulations_complete] + ) + + posterior = extract(check, group="posterior", keep_dataset=True) + except Exception: + traceback.print_exc() + raise + finally: + # Always ensure the model is reset to its un-augmented baseline state + # so the next simulation iteration isn't corrupted by the previous loop's augmented data + self._reset_model_state(self.model, self.model_baseline_state) - posterior = extract(check, group="posterior", keep_dataset=True) return posterior def _get_posterior_samples_numpyro(self, prior_predictive_draw): @@ -293,9 +571,42 @@ def _get_posterior_samples_numpyro(self, prior_predictive_draw): mcmc.run(rng_seed, **free_vars_data, **prior_predictive_args) return from_numpyro(mcmc)["posterior"] + def _get_posterior_predictive_samples(self): + with self.model: + num_draws = self.trace["posterior"].sizes["draw"] + draw_indices = np.linspace(0, num_draws - 1, self.num_simulations, dtype=int) + thinned_idata = self.trace.isel(draw=draw_indices) + posterior = extract(thinned_idata, group="posterior", keep_dataset=True) + + if self.simulator is None: + pm.sample_posterior_predictive( + thinned_idata, + extend_inferencedata=True, + random_seed=self._seeds[0], + progressbar=self.progress_bar, + ) + posterior_pred = extract( + thinned_idata, group="posterior_predictive", keep_dataset=True + ) + return posterior, posterior_pred + else: + posterior_pred = self._get_simulator_data(posterior) + + return posterior, posterior_pred + def _convert_to_datatree(self): + """Pack the rank-statistic arrays into an xarray DataTree. + + Creates a group named ``"prior_sbc"`` or ``"posterior_sbc"`` + (depending on ``self.method``) inside ``self.simulations``. + """ + if self.method == "prior": + group_name = "prior_sbc" + else: + group_name = "posterior_sbc" + self.simulations = from_dict( - {"prior_sbc": self.simulations}, + {group_name: self.simulations}, attrs={ "/": { "inferece_library": self.engine, @@ -305,6 +616,7 @@ def _convert_to_datatree(self): } }, ) + def compute_rank_statistics(self, param_transform=None): """Compute the rank statistic for the reference parameters. @@ -445,28 +757,54 @@ def _compute_single_rank(self, simulation_idx, posterior, transform): @quiet_logging("pymc", "pytensor.gof.compilelock", "bambi") def run_simulations(self): - """Run all the simulations. + """Run all SBC iterations (Prior or Posterior SBC). - This function can be stopped and restarted on the same instance, so you can - keyboard interrupt part way through, look at the plot, and then resume. If a - seed was passed initially, it will still be respected (that is, the resulting - simulations will be identical to running without pausing in the middle). - """ - prior, prior_pred = self._get_prior_predictive_samples() - self.ref_params = prior + For each iteration the method: + + 1. Draws a reference parameter vector and a replicated dataset + (from the prior / prior-predictive for Prior SBC, or from the + original posterior / posterior-predictive for Posterior SBC). + 2. Fits the model to the (possibly augmented) replicated data. + 3. Computes the rank of the reference draw among the new + (augmented) posterior draws. + The results are stored in ``self.simulations`` as an ArviZ + DataTree with group ``"prior_sbc"`` or ``"posterior_sbc"``. + + This method can be stopped and restarted on the same instance: + you can keyboard-interrupt part way through, inspect the partial + results, and then call ``run_simulations()`` again to continue. + If a seed was passed at init, reproducibility is preserved. + """ progress = tqdm( initial=self._simulations_complete, total=self.num_simulations, + disable=not self.progress_bar, ) + if self.method == "prior": + # In Prior SBC, the reference parameter draws are from the prior, + # the predictive samples are from the prior predictive + ref_params, predictive = self._get_prior_predictive_samples() + else: + # In Posterior SBC, the reference parameter draws are from the original posterior, + # the predictive samples are from the original posterior predictive + ref_params, predictive = self._get_posterior_predictive_samples() + + rng = np.random.default_rng(self.seed) + sample_indices = rng.choice( + ref_params.sizes["sample"], size=self.num_simulations, replace=False + ) + self.ref_params = ref_params.isel(sample=sample_indices) + predictive = predictive.isel(sample=sample_indices) + # if simulator is used, ignore observed_vars if self.simulator is not None: - self.observed_vars = list(prior_pred.data_vars) + self.observed_vars = list(predictive.data_vars) self.var_names = list( filter( lambda var_name: var_name not in self.observed_vars, - list(prior.data_vars), + list(ref_params.data_vars), ) ) self.simulations = {var_name: [] for var_name in self.var_names} @@ -474,12 +812,13 @@ def run_simulations(self): try: while self._simulations_complete < self.num_simulations: idx = self._simulations_complete - prior_predictive_draw = { - var_name: prior_pred[var_name].sel(chain=0, draw=idx).values + + replicated_data = { + var_name: predictive[var_name].isel(sample=idx).values for var_name in self.observed_vars } - posterior = self._get_posterior_samples(prior_predictive_draw) + posterior = self._get_posterior_samples(replicated_data) if self.keep_fits: self.posteriors.append(posterior) else: @@ -487,6 +826,8 @@ def run_simulations(self): self._simulations_complete += 1 progress.update() + except Exception as e: + logging.error(f"Stopping simulation. An error occurred during simulations:\n {e}") finally: if self._simulations_complete: if self.keep_fits: @@ -499,7 +840,6 @@ def run_simulations(self): progress.close() - @quiet_logging("numpyro") @quiet_logging("numpyro") def _run_simulations_numpyro(self): """Run all the simulations for Numpyro Model.""" From 34afaa0b5569037af0639a2796d4a5c73bd01d0f Mon Sep 17 00:00:00 2001 From: cab14bacc <86755693+Cab14bacc@users.noreply.github.com> Date: Thu, 7 May 2026 10:55:34 +0300 Subject: [PATCH 03/23] chore(tests): Add posterior sbc tests and rename prior sbc tests --- simuk/tests/test_posterior_sbc.py | 278 ++++++++++++++++++ .../tests/{test_sbc.py => test_prior_sbc.py} | 0 2 files changed, 278 insertions(+) create mode 100644 simuk/tests/test_posterior_sbc.py rename simuk/tests/{test_sbc.py => test_prior_sbc.py} (100%) diff --git a/simuk/tests/test_posterior_sbc.py b/simuk/tests/test_posterior_sbc.py new file mode 100644 index 0000000..2930edf --- /dev/null +++ b/simuk/tests/test_posterior_sbc.py @@ -0,0 +1,278 @@ +"""Tests for Posterior SBC (method='posterior').""" + +import logging + +import numpy as np +import pymc as pm +import pytest + +import simuk + +np.random.seed(42) + +# --------------------------------------------------------------------------- +# Test data +# --------------------------------------------------------------------------- + +obs_data = np.random.normal(2.0, 1.0, size=20) +x_obs = np.linspace(0, 1, 20) +y_obs_reg = 1.5 * x_obs + np.random.normal(0, 0.5, size=20) + +# --------------------------------------------------------------------------- +# PyMC models and traces +# --------------------------------------------------------------------------- + +with pm.Model() as simple_model: + mu = pm.Normal("mu", mu=0, sigma=5) + sigma = pm.HalfNormal("sigma", sigma=2) + y_data = pm.Data("y_data", obs_data) + pm.Normal("y", mu=mu, sigma=sigma, observed=y_data) + +with simple_model: + trace_simple = pm.sample( + draws=30, + tune=30, + chains=1, + random_seed=123, + progressbar=False, + compute_convergence_checks=False, + ) + +coords = {"obs_id": np.arange(len(y_obs_reg))} +with pm.Model(coords=coords) as reg_model: + x = pm.Data("x", x_obs, dims="obs_id") + y_data = pm.Data("y_data", y_obs_reg, dims="obs_id") + slope = pm.Normal("slope", mu=0, sigma=5) + sigma_reg = pm.HalfNormal("sigma", sigma=2) + pm.Normal("y", mu=slope * x, sigma=sigma_reg, observed=y_data, dims="obs_id") + +with reg_model: + trace_reg = pm.sample( + draws=30, + tune=30, + chains=1, + random_seed=123, + progressbar=False, + compute_convergence_checks=False, + ) + + +# --------------------------------------------------------------------------- +# Custom simulator and callback functions +# --------------------------------------------------------------------------- + + +def custom_simulator(mu, sigma, seed, **kwargs): + rng = np.random.default_rng(seed) + return {"y": rng.normal(mu, sigma, size=20)} + + +def custom_augment_observed(model, observed_data, replicated_data, idx): + # Custom: only keep the last 10 original obs + all replicated + return { + var: np.concatenate([observed_data[var].values[-10:], replicated_data[var]]) + for var in replicated_data + } + + +def update_data_reg(model, augmented_data, idx): + """Resize covariates and coords to match augmented data.""" + n_aug = len(augmented_data["y"]) + x_aug = np.tile(x_obs, n_aug // len(x_obs) + 1)[:n_aug] + pm.set_data( + {"x": x_aug, "y_data": augmented_data["y"]}, + coords={"obs_id": np.arange(n_aug)}, + ) + + +def custom_param_transform(param_name, param_value): + return param_value**2 + + +# --------------------------------------------------------------------------- +# Tests with observed variables +# --------------------------------------------------------------------------- + + +@pytest.mark.parametrize("model,trace", [(simple_model, trace_simple)]) +def test_posterior_sbc_with_observed_data(model, trace): + """Basic posterior SBC with a PyMC model.""" + sbc = simuk.SBC( + model, + method="posterior", + trace=trace, + num_simulations=2, + sample_kwargs={"draws": 5, "tune": 5}, + ) + sbc.run_simulations() + assert "posterior_sbc" in sbc.simulations + + +@pytest.mark.parametrize( + "model,trace,update_data", [(reg_model, trace_reg, update_data_reg)] +) +def test_posterior_sbc_with_update_data(model, trace, update_data): + """Posterior SBC with dims/coords and update_data callback.""" + sbc = simuk.SBC( + model, + method="posterior", + trace=trace, + num_simulations=2, + sample_kwargs={"draws": 5, "tune": 5}, + update_data=update_data, + ) + sbc.run_simulations() + assert "posterior_sbc" in sbc.simulations + + +# --------------------------------------------------------------------------- +# Tests with custom simulator and callbacks +# --------------------------------------------------------------------------- + + +@pytest.mark.parametrize( + "model,trace,simulator", [(simple_model, trace_simple, custom_simulator)] +) +def test_posterior_sbc_with_custom_simulator(model, trace, simulator): + """Posterior SBC using a custom simulator function.""" + sbc = simuk.SBC( + model, + method="posterior", + trace=trace, + num_simulations=2, + sample_kwargs={"draws": 5, "tune": 5}, + simulator=simulator, + ) + sbc.run_simulations() + assert "posterior_sbc" in sbc.simulations + + +@pytest.mark.parametrize( + "model,trace,augment_observed", + [(simple_model, trace_simple, custom_augment_observed)], +) +def test_posterior_sbc_with_augment_observed(model, trace, augment_observed): + """Posterior SBC with a custom augment_observed callback.""" + sbc = simuk.SBC( + model, + method="posterior", + trace=trace, + num_simulations=2, + sample_kwargs={"draws": 5, "tune": 5}, + augment_observed=augment_observed, + ) + sbc.run_simulations() + assert "posterior_sbc" in sbc.simulations + + +@pytest.mark.parametrize( + "model,trace,param_transform", + [(simple_model, trace_simple, custom_param_transform)], +) +def test_posterior_sbc_with_param_transform(model, trace, param_transform): + """Posterior SBC with a param_transform(name, value) function.""" + sbc = simuk.SBC( + model, + method="posterior", + trace=trace, + num_simulations=2, + sample_kwargs={"draws": 5, "tune": 5}, + param_transform=param_transform, + ) + sbc.run_simulations() + assert "posterior_sbc" in sbc.simulations + + +# --------------------------------------------------------------------------- +# Error-handling tests +# --------------------------------------------------------------------------- + + +def test_posterior_sbc_no_trace(): + """method='posterior' without trace should raise ValueError.""" + with pytest.raises(ValueError, match="posterior samples from the"): + simuk.SBC( + simple_model, + method="posterior", + num_simulations=5, + sample_kwargs={"draws": 5, "tune": 5}, + ) + + +def test_posterior_sbc_trace_missing_posterior(): + """trace without 'posterior' group should raise ValueError.""" + trace_missing = trace_simple.copy() + del trace_missing.posterior + with pytest.raises(ValueError, match="posterior"): + simuk.SBC( + simple_model, + method="posterior", + trace=trace_missing, + num_simulations=5, + sample_kwargs={"draws": 5, "tune": 5}, + ) + + +def test_posterior_sbc_trace_missing_observed_data(): + """trace without 'observed_data' group should raise ValueError.""" + trace_missing = trace_simple.copy() + del trace_missing.observed_data + with pytest.raises(ValueError, match="observed_data"): + simuk.SBC( + simple_model, + method="posterior", + trace=trace_missing, + num_simulations=5, + sample_kwargs={"draws": 5, "tune": 5}, + ) + + +def test_posterior_sbc_too_many_simulations(): + """num_simulations > draws should raise ValueError.""" + with pytest.raises(ValueError, match="more draws per"): + simuk.SBC( + simple_model, + method="posterior", + trace=trace_simple, + num_simulations=100, # trace_simple only has 30 draws + sample_kwargs={"draws": 5, "tune": 5}, + ) + + +def test_posterior_sbc_numpyro_not_implemented(): + """Posterior SBC is not yet implemented for NumPyro.""" + numpyro = pytest.importorskip("numpyro") + import numpyro.distributions as dist + from numpyro.infer import NUTS + + def numpyro_model(y=None): + mu = numpyro.sample("mu", dist.Normal(0, 5)) + numpyro.sample("y", dist.Normal(mu, 1), obs=y) + + with pytest.raises(NotImplementedError, match="only implemented for PyMC"): + simuk.SBC( + NUTS(numpyro_model), + method="posterior", + trace=trace_simple, + data_dir={"y": obs_data}, + num_simulations=5, + ) + + +def test_posterior_sbc_warnings_for_prior(caplog): + """Passing posterior-only args with method='prior' should emit warnings.""" + with caplog.at_level(logging.WARNING): + simuk.SBC( + simple_model, + method="prior", + num_simulations=5, + sample_kwargs={"draws": 5, "tune": 5}, + trace=trace_simple, + augment_observed=lambda *a: {}, + update_data=lambda *a: None, + ) + + messages = caplog.text + assert "update_data" in messages + assert "augment_observed" in messages + assert "trace" in messages diff --git a/simuk/tests/test_sbc.py b/simuk/tests/test_prior_sbc.py similarity index 100% rename from simuk/tests/test_sbc.py rename to simuk/tests/test_prior_sbc.py From 336df6b27409d788ca4b34f9831cdc0eadf606e4 Mon Sep 17 00:00:00 2001 From: cab14bacc <86755693+Cab14bacc@users.noreply.github.com> Date: Thu, 7 May 2026 10:56:03 +0300 Subject: [PATCH 04/23] chore(docs): add posterior sbc example --- docs/examples.rst | 19 +- docs/examples/gallery/posterior_sbc.md | 236 ++++++++++++++++++ .../examples/gallery/{sbc.md => prior_sbc.md} | 6 +- docs/examples/img/posterior_sbc.png | Bin 0 -> 54741 bytes docs/examples/img/{sbc.png => prior_sbc.png} | Bin docs/index.rst | 69 ++++- 6 files changed, 321 insertions(+), 9 deletions(-) create mode 100644 docs/examples/gallery/posterior_sbc.md rename docs/examples/gallery/{sbc.md => prior_sbc.md} (95%) create mode 100644 docs/examples/img/posterior_sbc.png rename docs/examples/img/{sbc.png => prior_sbc.png} (100%) diff --git a/docs/examples.rst b/docs/examples.rst index b813285..2405235 100644 --- a/docs/examples.rst +++ b/docs/examples.rst @@ -7,13 +7,24 @@ The gallery below presents examples that demonstrate the use of Simuk. :gutter: 2 2 3 3 .. grid-item-card:: - :link: ./examples/gallery/sbc.html + :link: ./examples/gallery/prior_sbc.html :text-align: center :shadow: none :class-card: example-gallery - .. image:: examples/img/sbc.png - :alt: SBC + .. image:: examples/img/prior_sbc.png + :alt: Prior SBC +++ - SBC + Prior SBC + + .. grid-item-card:: + :link: ./examples/gallery/posterior_sbc.html + :text-align: center + :shadow: none + :class-card: example-gallery + + .. image:: examples/img/posterior_sbc.png + :alt: Posterior SBC + +++ + Posterior SBC diff --git a/docs/examples/gallery/posterior_sbc.md b/docs/examples/gallery/posterior_sbc.md new file mode 100644 index 0000000..536b99b --- /dev/null +++ b/docs/examples/gallery/posterior_sbc.md @@ -0,0 +1,236 @@ +--- +jupytext: + text_representation: + extension: .md + format_name: myst +kernelspec: + display_name: Python 3 + language: python + name: python3 +--- + +# Posterior Simulation-Based Calibration + +**Posterior SBC** (Säilynoja et al., 2025) validates the inference algorithm +*conditional on observed data*, rather than averaging over the prior. + +```{admonition} When to use Posterior SBC +:class: tip + +Use **Prior SBC** when you want to check that your inference pipeline works +for a wide range of datasets generated under the prior. + +Use **Posterior SBC** when you already have observed data and want to verify +that the inference algorithm is trustworthy *for that specific dataset*. +Posterior SBC focuses on the region of the parameter space that matters +for the observed data, making it more sensitive to local calibration issues. +``` + +```{jupyter-execute} + +import pymc as pm +from arviz_plots import plot_ecdf_pit, style +import matplotlib.pyplot as plt +import numpy as np +import simuk + +style.use("arviz-variat") +``` + +## How Posterior SBC works + +Given a model $\pi(\theta, y) = \pi(\theta)\,\pi(y \mid \theta)$ and +observed data $y_{\text{obs}}$, Posterior SBC proceeds as follows: + +1. **Fit the model** to $y_{\text{obs}}$ to obtain posterior draws + $\theta'_i \sim \pi(\theta \mid y_{\text{obs}})$. +2. **Generate replicated data** from the posterior predictive: + $y_i \sim \pi(y \mid \theta'_i)$. +3. **Augment** the observations: $y_{\text{aug}} = (y_{\text{obs}}, y_i)$. +4. **Re-fit the model** on the augmented data to get + $\theta''_{i,1}, \ldots, \theta''_{i,S} \sim \pi(\theta \mid y_i, y_{\text{obs}})$. +5. **Compute the rank statistics** of $f(\theta'_i)$ among $f(\theta''_{i,1}), \ldots, f(\theta''_{i,S})$. Where $f$ is an optional test quantity applied to the parameters before computing ranks. + +By the self-consistency of Bayesian updating, $\theta'_i$ is also a draw +from the augmented posterior $\pi(\theta \mid y_i, y_{\text{obs}})$. +Therefore the rank statistics should be **uniformly distributed** if the inference +is calibrated. + +## Example: Linear Regression Model + +### Define the model + +```{admonition} Model requirements for Posterior SBC +:class: warning + +Posterior SBC augments the observed data (concatenating original + replicated), +which changes its size. For this to work, store observed data in ``pm.Data`` +containers, and specify size using the ``dims`` parameter instead of setting a static shape. +If your model uses ``dims`` and ``coords``, you are also responsible for resizing them to the correct size corresponding to the new augmented dataset via the ``update_data`` callback. +Similarly, if your model has covariates, store them in ``pm.Data`` so they +can be resized in the same callback. +``` + +```{jupyter-execute} + +random_seed = 42 +np.random.seed(random_seed) + +x_data = np.linspace(0, 10, 100) +y_data = np.random.normal(x_data ** 1.2, 1) + +coords = { + "obs_id": np.arange(len(x_data)) +} + +with pm.Model(coords=coords) as model: + model_x_data = pm.Data("x_data", x_data, dims="obs_id") + model_y_data = pm.Data("y_data", y_data, dims="obs_id") + + alpha = pm.Normal("alpha", mu=0, sigma=10) + beta = pm.Normal("beta", mu=0, sigma=10) + sigma = pm.HalfNormal("sigma", sigma=10) + + # pm.Deterministic forces PyMC to track this equation's output + mu = pm.Deterministic("mu", alpha + beta * model_x_data) + y = pm.Normal("y", mu=mu, sigma=sigma, observed=model_y_data) +``` + +### Fit the original posterior + +First, we need the posterior samples from the observed data. These will +serve as the reference distribution for Posterior SBC. + +```{jupyter-execute} + +with model: + idata = pm.sample(200, random_seed=random_seed, progressbar=False) +``` + +### Using `update_data` with covariates and `dims` + +When your model uses `dims`/`coords` or has covariates stored in `pm.Data`, +you must provide an `update_data` callback that resizes everything to +match the augmented observations. The callback is called **before** the model +is re-conditioned, and runs inside the model context. + +```{jupyter-execute} + +def update_data(model, augmented_data, simulation_idx): + with model: + pm.set_data( + {"x_data": np.concatenate([model["x_data"].get_value(), model["x_data"].get_value()])}, + coords={"obs_id": np.arange(len(augmented_data["y"]))}, + ) +``` + +### Custom test quantities with `param_transform` + +You can define a scalar test quantity applied to both the reference draw +and the posterior draws before computing the rank statistic. The function +receives `(param_name, param_value)` and should return a comparable value. + +```{jupyter-execute} + +def param_transform(param_name, param_value): + return np.pow(param_value, 2) +``` + +### Run Posterior SBC + +Pass `method="posterior"` and provide the `trace`. Each iteration +generates replicated data from the posterior predictive, augments it +with the original observations, and re-fits the model. + +```{jupyter-execute} +sbc = simuk.SBC( + model, + method="posterior", + trace=idata, + param_transform=param_transform, + update_data=update_data, + num_simulations=50, + seed=random_seed, + sample_kwargs={"chains": 4, "draws": 50, "tune": 50}, + progress_bar=False, +) + +sbc.run_simulations(); +``` + +### Visualize the results + +We expect the ECDF lines to fall inside the grey simultaneous confidence +band, indicating that the ranks are consistent with a uniform distribution. + +```{jupyter-execute} + +plot_ecdf_pit(sbc.simulations, + group="posterior_sbc", + visuals={"xlabel": False}, +); +``` + +## Intentionally Skewing the Augmented Posterior Using Custom augmentation with `augment_observed` + +We intentionally skew the augmented posterior by keeping only the last 25 original observations and concatenating them with the replicated data. This creates a mismatch between the reference draw (which is based on the full observed data) and the augmented posterior (which is based on a subset of the observed data), leading to skewed rank statistics. + +```{jupyter-execute} + +def augment_observed(model, observed_data, replicated_data, simulation_idx): + """Keep only the last 25 original observations + replicated.""" + data = {"y": np.concatenate([observed_data["y"].values[-25:], replicated_data["y"]])} + return data + + +def update_data(model, augmented_data, simulation_idx): + with model: + pm.set_data( + { + "x_data": np.concatenate( + [model["x_data"].get_value()[-25:], model["x_data"].get_value()] + ) + }, + coords={"obs_id": np.arange(25 + len(model["x_data"].get_value()))}, + ) + + +skewed_sbc = simuk.SBC( + model, + method="posterior", + trace=idata, + augment_observed=augment_observed, + update_data=update_data, + num_simulations=50, + sample_kwargs={"chains": 4, "draws": 50, "tune": 50}, + progress_bar=False, +) + +skewed_sbc.run_simulations() +``` + +### Visualize the skewed results + +The results indicate a clear deviation from uniformity, with the ECDF lines falling outside the confidence band. This suggests that the self-consistency property of Bayesian updating does not hold. + +```{jupyter-execute} + +plot_ecdf_pit(skewed_sbc.simulations, group="posterior_sbc", visuals={"xlabel": False}) +``` + +We shall also replot the original Posterior SBC results for comparison using `compute_rank_statistics` without need to re-run the simulations. + +```{jupyter-execute} + +sbc.compute_rank_statistics(lambda _, param_value: param_value) +plot_ecdf_pit(sbc.simulations, group="posterior_sbc", visuals={"xlabel": False}) +``` + +## References + +- Säilynoja, T., Schmitt, M., Bürkner, P.-C., & Vehtari, A. (2025). + *Posterior SBC: Simulation-Based Calibration Checking Conditional on Data*. + [arXiv:2502.03279](https://arxiv.org/abs/2502.03279) +- Talts, S., Betancourt, M., Simpson, D., Vehtari, A., & Gelman, A. (2020). + *Validating Bayesian Inference Algorithms with Simulation-Based Calibration*. + [arXiv:1804.06788](https://arxiv.org/abs/1804.06788) diff --git a/docs/examples/gallery/sbc.md b/docs/examples/gallery/prior_sbc.md similarity index 95% rename from docs/examples/gallery/sbc.md rename to docs/examples/gallery/prior_sbc.md index 12bd166..f138600 100644 --- a/docs/examples/gallery/sbc.md +++ b/docs/examples/gallery/prior_sbc.md @@ -9,7 +9,7 @@ kernelspec: name: python3 --- -# Simulation based calibration +# Prior Simulation based calibration ```{jupyter-execute} @@ -19,8 +19,8 @@ import simuk style.use("arviz-variat") ``` -## Out-of-the-box SBC -This example demonstrates how to use the `SBC` class for simulation-based calibration, supporting PyMC, Bambi and Numpyro models. By default, the generative model implied by the probabilistic model is used. +## Out-of-the-box Prior SBC +This example demonstrates how to use the `SBC` class for prior simulation-based calibration, supporting PyMC, Bambi and Numpyro models. By default, the generative model implied by the probabilistic model is used. ::::::{tab-set} diff --git a/docs/examples/img/posterior_sbc.png b/docs/examples/img/posterior_sbc.png new file mode 100644 index 0000000000000000000000000000000000000000..7d827d1e4720066518743bd5689eec6191930dad GIT binary patch literal 54741 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 literal 0 HcmV?d00001 diff --git a/docs/examples/img/sbc.png b/docs/examples/img/prior_sbc.png similarity index 100% rename from docs/examples/img/sbc.png rename to docs/examples/img/prior_sbc.png diff --git a/docs/index.rst b/docs/index.rst index 4dadc01..538a462 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -3,9 +3,9 @@ Overview Simuk is a Python library for simulation-based calibration (SBC) and the generation of synthetic data. Simulation-Based Calibration (SBC) is a method for validating Bayesian inference by checking whether the -posterior distributions align with the expected theoretical results derived from the prior. +posterior distributions align with the expected theoretical results derived from the prior (posterior). -Quickstart +Prior SBC Quickstart ---------- This quickstart guide provides a simple example to help you get started. If you're looking for more examples @@ -52,6 +52,71 @@ Plot the empirical CDF to compare the differences between the prior and posterio The lines should be nearly uniform and fall within the oval envelope. It suggests that the prior and posterior distributions are properly aligned and that there are no significant biases or issues with the model. +Posterior SBC Quickstart +------------------------ + +While Prior SBC checks the global validity of an inference algorithm across the entire prior space, +Posterior SBC evaluates validity locally, conditional on your observed data. To use it, simply pass ``method="posterior"`` and the original ``trace`` to the ``SBC`` class: +Currently, it's only implemented for PyMC. + +.. warning:: + + **Model requirements for Posterior SBC** + + Posterior SBC augments the observed data (concatenating original + replicated), + which changes its size. For this to work, store observed data in ``pm.Data`` + containers, and specify size using the ``dims`` parameter instead of setting a static shape. + If your model uses ``dims`` and ``coords``, you are also responsible for resizing them to the correct size corresponding to the new augmented dataset via the ``update_data`` callback. + Similarly, if your model has covariates, store them in ``pm.Data`` so they + can be resized in the same callback. + +.. code-block:: python + + # Define the model conforming to the Posterior SBC implementation requirements. + import numpy as np + import pymc as pm + + data = np.array([28.0, 8.0, -3.0, 7.0, -1.0, 1.0, 18.0, 12.0]) + sigma = np.array([15.0, 10.0, 16.0, 11.0, 9.0, 11.0, 10.0, 18.0]) + + with pm.Model(coords={"school": np.arange(8)}) as centered_eight: + school_idx = pm.Data("school_idx", np.arange(8)) + y_data = pm.Data("y_data", data) + sigma_data = pm.Data("sigma_data", sigma) + + mu = pm.Normal('mu', mu=0, sigma=5) + tau = pm.HalfCauchy('tau', beta=5) + theta = pm.Normal('theta', mu=mu, sigma=tau, dims="school") + y_obs = pm.Normal('y', mu=theta[school_idx], sigma=sigma_data, observed=y_data) + + # Run the model and save the trace. + with centered_eight: + idata = pm.sample(progressbar=False) + + # Define necessary callbacks to resize our covariates + def update_data(model, augmented_data, simulation_idx): + with model: + pm.set_data({ + "sigma_data": np.concatenate([sigma, sigma]), + "school_idx": np.concatenate([np.arange(8), np.arange(8)]) + }) + + # Run Posterior SBC + post_sbc = simuk.SBC( + centered_eight, + method="posterior", + trace=idata, + update_data=update_data, + num_simulations=100, + sample_kwargs={'draws': 25, 'tune': 50}, + progress_bar=False + ) + post_sbc.run_simulations() + + plot_ecdf_pit(post_sbc.simulations, group="posterior_sbc", visuals={"xlabel": False}) + +For more advanced use cases, such as custom data augmentation or re-evaluating rank statistics, check out the :doc:`Posterior SBC tutorial `. + .. toctree:: :maxdepth: 1 :hidden: From 5c07b97e2becfef257eb49d4a851680c1b4a3952 Mon Sep 17 00:00:00 2001 From: cab14bacc <86755693+Cab14bacc@users.noreply.github.com> Date: Mon, 11 May 2026 13:07:13 +0300 Subject: [PATCH 05/23] chore (docs): update phrasing --- docs/examples/gallery/posterior_sbc.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/examples/gallery/posterior_sbc.md b/docs/examples/gallery/posterior_sbc.md index 536b99b..e1c62ec 100644 --- a/docs/examples/gallery/posterior_sbc.md +++ b/docs/examples/gallery/posterior_sbc.md @@ -218,7 +218,7 @@ The results indicate a clear deviation from uniformity, with the ECDF lines fall plot_ecdf_pit(skewed_sbc.simulations, group="posterior_sbc", visuals={"xlabel": False}) ``` -We shall also replot the original Posterior SBC results for comparison using `compute_rank_statistics` without need to re-run the simulations. +We shall also replot the original Posterior SBC results using the same quantity using `compute_rank_statistics`. This allows us to compare the results without need to re-run the simulations. ```{jupyter-execute} From 98fcc38f16c8a60768bc470a43aa806a36409762 Mon Sep 17 00:00:00 2001 From: cab14bacc <86755693+Cab14bacc@users.noreply.github.com> Date: Tue, 26 May 2026 20:04:09 +0300 Subject: [PATCH 06/23] fix: manual rebase artifacts --- simuk/sbc.py | 89 ++++--------------------------- simuk/tests/test_posterior_sbc.py | 12 ++--- 2 files changed, 13 insertions(+), 88 deletions(-) diff --git a/simuk/sbc.py b/simuk/sbc.py index 3ee4733..f7be438 100644 --- a/simuk/sbc.py +++ b/simuk/sbc.py @@ -425,9 +425,9 @@ def _get_simulator_data(self, free_rv_samples): params["seed"] = self._seeds[i] try: res = self.simulator(**params) - assert isinstance( - res, Mapping - ), f"Simulator must return a dictionary, got {type(res)}" + assert isinstance(res, Mapping), ( + f"Simulator must return a dictionary, got {type(res)}" + ) pred.append(res) except Exception as e: raise ValueError( @@ -524,16 +524,13 @@ def _get_posterior_samples(self, replicated_data): vars_to_observations = replicated_data # Set observed data that are pm.Data objects if the user hasn't modified them yet. - # We enforce an np.array_equal check against the baseline to prevent PyMC size mismatch + # We enforce an np.array_equal check against the baseline to prevent PyMC size mismatch # ValueErrors when the user's `update_data` hook or `pm.observe` already updated it. with self.model: for rv, data_node in self.observed_rvs_to_pm_data.items(): - if ( - data_node is not None - and np.array_equal( - self.model.named_vars[data_node].get_value(), - self.model_baseline_state["data"][data_node], - ) + if data_node is not None and np.array_equal( + self.model.named_vars[data_node].get_value(), + self.model_baseline_state["data"][data_node], ): pm.set_data(new_data={data_node: vars_to_observations[rv]}) @@ -549,7 +546,7 @@ def _get_posterior_samples(self, replicated_data): traceback.print_exc() raise finally: - # Always ensure the model is reset to its un-augmented baseline state + # Always ensure the model is reset to its un-augmented baseline state # so the next simulation iteration isn't corrupted by the previous loop's augmented data self._reset_model_state(self.model, self.model_baseline_state) @@ -593,7 +590,7 @@ def _get_posterior_predictive_samples(self): posterior_pred = self._get_simulator_data(posterior) return posterior, posterior_pred - + def _convert_to_datatree(self): """Pack the rank-statistic arrays into an xarray DataTree. @@ -617,74 +614,6 @@ def _convert_to_datatree(self): }, ) - def compute_rank_statistics(self, param_transform=None): - """Compute the rank statistic for the reference parameters. - - This method computes the rank of each reference parameter value - relative to the newly sampled posterior draws for each simulation. - - This allows users to recompute rank statistics rapidly using a - different parameter transformation without needing to rerun the simulations. - - Parameters - ---------- - param_transform : callable, optional - A function that accepts two arguments: `(param_name, param_value)`. - This function is applied to both the posterior draws and the - reference parameter draws before computing the rank. For instance, - it can be used to take the mean over a vectorized parameter grouping. - If None, defaults to the `param_transform` passed during class - initialization. - - Returns - ------- - xarray.DataTree - An xarray.DataTree containing the computed rank statistics, matching - the output structure generated by `run_simulations`. - """ - if param_transform is None: - param_transform = self._param_transform - elif not callable(param_transform): - raise ValueError("`param_transform` should be a function or None") - - simulations = {name: [] for name in self.var_names} - - for idx, posterior in enumerate(self.posteriors): - for name in self.var_names: - if self.engine == "numpyro": - transformed_posterior = np.array( - [ - param_transform(name, posterior[name].sel(chain=0).isel(draw=i).values) - for i in range(posterior[name].sizes["draw"]) - ] - ) - simulations[name].append( - ( - transformed_posterior - < param_transform(name, self.ref_params[name][idx]) - ).sum(axis=0) - ) - else: - transformed_posterior = np.array( - [ - param_transform(name, posterior[name].isel(sample=i).values) - for i in range(posterior[name].sizes["sample"]) - ] - ) - simulations[name].append( - ( - transformed_posterior - < param_transform(name, self.ref_params[name].isel(sample=idx).values) - ).sum(axis=0) - ) - - self.simulations = { - k: np.stack(v)[None, :] - for k, v in simulations.items() - } - self._convert_to_datatree() - return self.simulations - def compute_rank_statistics(self, transform=None): """Compute the rank statistic for the reference parameters. diff --git a/simuk/tests/test_posterior_sbc.py b/simuk/tests/test_posterior_sbc.py index 2930edf..0f8ae9d 100644 --- a/simuk/tests/test_posterior_sbc.py +++ b/simuk/tests/test_posterior_sbc.py @@ -3,8 +3,10 @@ import logging import numpy as np +import numpyro.distributions as dist import pymc as pm import pytest +from numpyro.infer import NUTS import simuk @@ -108,9 +110,7 @@ def test_posterior_sbc_with_observed_data(model, trace): assert "posterior_sbc" in sbc.simulations -@pytest.mark.parametrize( - "model,trace,update_data", [(reg_model, trace_reg, update_data_reg)] -) +@pytest.mark.parametrize("model,trace,update_data", [(reg_model, trace_reg, update_data_reg)]) def test_posterior_sbc_with_update_data(model, trace, update_data): """Posterior SBC with dims/coords and update_data callback.""" sbc = simuk.SBC( @@ -130,9 +130,7 @@ def test_posterior_sbc_with_update_data(model, trace, update_data): # --------------------------------------------------------------------------- -@pytest.mark.parametrize( - "model,trace,simulator", [(simple_model, trace_simple, custom_simulator)] -) +@pytest.mark.parametrize("model,trace,simulator", [(simple_model, trace_simple, custom_simulator)]) def test_posterior_sbc_with_custom_simulator(model, trace, simulator): """Posterior SBC using a custom simulator function.""" sbc = simuk.SBC( @@ -242,8 +240,6 @@ def test_posterior_sbc_too_many_simulations(): def test_posterior_sbc_numpyro_not_implemented(): """Posterior SBC is not yet implemented for NumPyro.""" numpyro = pytest.importorskip("numpyro") - import numpyro.distributions as dist - from numpyro.infer import NUTS def numpyro_model(y=None): mu = numpyro.sample("mu", dist.Normal(0, 5)) From a90a49bd525df58734c929698637980268f37930 Mon Sep 17 00:00:00 2001 From: cab14bacc <86755693+Cab14bacc@users.noreply.github.com> Date: Tue, 26 May 2026 22:48:18 +0300 Subject: [PATCH 07/23] fix: manual rebase artifacts --- simuk/tests/test_posterior_sbc.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/simuk/tests/test_posterior_sbc.py b/simuk/tests/test_posterior_sbc.py index 0f8ae9d..4212b1c 100644 --- a/simuk/tests/test_posterior_sbc.py +++ b/simuk/tests/test_posterior_sbc.py @@ -87,7 +87,7 @@ def update_data_reg(model, augmented_data, idx): ) -def custom_param_transform(param_name, param_value): +def custom_transform(param_name, param_value): return param_value**2 @@ -164,18 +164,18 @@ def test_posterior_sbc_with_augment_observed(model, trace, augment_observed): @pytest.mark.parametrize( - "model,trace,param_transform", - [(simple_model, trace_simple, custom_param_transform)], + "model,trace,transform", + [(simple_model, trace_simple, custom_transform)], ) -def test_posterior_sbc_with_param_transform(model, trace, param_transform): - """Posterior SBC with a param_transform(name, value) function.""" +def test_posterior_sbc_with_transform(model, trace, transform): + """Posterior SBC with a transform(name, value) function.""" sbc = simuk.SBC( model, method="posterior", trace=trace, num_simulations=2, sample_kwargs={"draws": 5, "tune": 5}, - param_transform=param_transform, + transform=transform, ) sbc.run_simulations() assert "posterior_sbc" in sbc.simulations From 3189ee0a5f20a0bcd9cb024b4bb4e09bf8e6e742 Mon Sep 17 00:00:00 2001 From: cab14bacc <86755693+Cab14bacc@users.noreply.github.com> Date: Tue, 26 May 2026 23:05:28 +0300 Subject: [PATCH 08/23] fix(docstring): docstring of sbc class --- simuk/sbc.py | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/simuk/sbc.py b/simuk/sbc.py index f7be438..6acaefa 100644 --- a/simuk/sbc.py +++ b/simuk/sbc.py @@ -136,17 +136,17 @@ class SBC: Notes ----- **Prior SBC** exploits the self-consistency of Bayesian updating: - if :math:`\\theta' \\sim \\pi(\\theta)` and - :math:`y' \\sim \\pi(y \\mid \\theta')`, then :math:`\\theta'` is also - a draw from :math:`\\pi(\\theta \\mid y')`. See Talts et al. (2020). + if :math:`\theta' \sim \pi(\theta)` and + :math:`y' \sim \pi(y \mid \theta')`, then :math:`\theta'` is also + a draw from :math:`\pi(\theta \mid y')`. See Talts et al. (2020). **Posterior SBC** uses the same self-consistency after conditioning - on observed data :math:`y_{\\text{obs}}`. A draw - :math:`\\theta'_i \\sim \\pi(\\theta \\mid y_{\\text{obs}})` and a - replicated dataset :math:`y_i \\sim \\pi(y \\mid \\theta'_i)` are - combined so that :math:`\\theta'_i` is also a draw from - :math:`\\pi(\\theta \\mid y_i, y_{\\text{obs}})`. The rank of - :math:`\\theta'_i` among augmented-posterior draws should be + on observed data :math:`y_{\text{obs}}`. A draw + :math:`\theta'_i \sim \pi(\theta \mid y_{\text{obs}})` and a + replicated dataset :math:`y_i \sim \pi(y \mid \theta'_i)` are + combined so that :math:`\theta'_i` is also a draw from + :math:`\pi(\theta \mid y_i, y_{\text{obs}})`. The rank of + :math:`\theta'_i` among augmented-posterior draws should be uniformly distributed if the inference is calibrated. See Säilynoja et al. (2025). From 623189465a0f906230adebac5063f3a6ad3f4399 Mon Sep 17 00:00:00 2001 From: cab14bacc <86755693+Cab14bacc@users.noreply.github.com> Date: Tue, 26 May 2026 23:24:19 +0300 Subject: [PATCH 09/23] refactor: use print_exc instead of print for exception --- simuk/sbc.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/simuk/sbc.py b/simuk/sbc.py index 6acaefa..35bfee8 100644 --- a/simuk/sbc.py +++ b/simuk/sbc.py @@ -756,7 +756,8 @@ def run_simulations(self): self._simulations_complete += 1 progress.update() except Exception as e: - logging.error(f"Stopping simulation. An error occurred during simulations:\n {e}") + logging.error(f"Stopping simulation. An error occurred during simulations:") + traceback.print_exc() finally: if self._simulations_complete: if self.keep_fits: From ff38ddcafaf6005664fb5ced815196d99a2cbe9f Mon Sep 17 00:00:00 2001 From: cab14bacc <86755693+Cab14bacc@users.noreply.github.com> Date: Tue, 26 May 2026 23:27:17 +0300 Subject: [PATCH 10/23] chore(readme): add posterior quick start --- README.md | 67 ++++++++++++++++++++++++++++++++++++- posterior_ecdf.png | Bin 0 -> 46542 bytes ecdf.png => prior_ecdf.png | Bin 3 files changed, 66 insertions(+), 1 deletion(-) create mode 100644 posterior_ecdf.png rename ecdf.png => prior_ecdf.png (100%) diff --git a/README.md b/README.md index 0bba71a..cd3a08a 100644 --- a/README.md +++ b/README.md @@ -15,6 +15,8 @@ pip install simuk ## Quickstart +### Prior SBC + 1. Define a PyMC or Bambi model. For example, the centered eight schools model: ```python @@ -52,7 +54,70 @@ should be close to uniform and within the oval envelope. ); ``` -![Simulation based calibration plots, ecdf](ecdf.png) +![Prior Simulation based calibration plots, ecdf](prior_ecdf.png) + +### Posterior SBC + +Posterior SBC evaluates validity locally, conditional on observed data. It is +currently implemented for PyMC. This requires storing observed data in +`pm.Data` containers, using `dims` instead of static shapes, and resizing +covariates and coords in an `update_data` callback to match the augmented data. + +1. Define the model with `pm.Data` and `dims`: + + ```python + import numpy as np + import pymc as pm + + data = np.array([28.0, 8.0, -3.0, 7.0, -1.0, 1.0, 18.0, 12.0]) + sigma = np.array([15.0, 10.0, 16.0, 11.0, 9.0, 11.0, 10.0, 18.0]) + + with pm.Model(coords={"school": np.arange(8)}) as centered_eight: + school_idx = pm.Data("school_idx", np.arange(8)) + y_data = pm.Data("y_data", data) + sigma_data = pm.Data("sigma_data", sigma) + + mu = pm.Normal("mu", mu=0, sigma=5) + tau = pm.HalfCauchy("tau", beta=5) + theta = pm.Normal("theta", mu=mu, sigma=tau, dims="school") + y_obs = pm.Normal("y", mu=theta[school_idx], sigma=sigma_data, observed=y_data) + ``` + +2. Sample once to obtain the original trace: + + ```python + with centered_eight: + idata = pm.sample(progressbar=False) + ``` + +3. Define `update_data` to resize covariates and run Posterior SBC: + + ```python + import simuk + from arviz_plots import plot_ecdf_pit + + def update_data(model, augmented_data, simulation_idx): + with model: + pm.set_data({ + "sigma_data": np.concatenate([sigma, sigma]), + "school_idx": np.concatenate([np.arange(8), np.arange(8)]) + }) + + post_sbc = simuk.SBC( + centered_eight, + method="posterior", + trace=idata, + update_data=update_data, + num_simulations=50, + sample_kwargs={"draws": 25, "tune": 50}, + progress_bar=False + ) + post_sbc.run_simulations() + + plot_ecdf_pit(post_sbc.simulations, group="posterior_sbc", visuals={"xlabel": False}) + ``` + +![Posterior Simulation based calibration plots, ecdf](posterior_ecdf.png) ## References diff --git a/posterior_ecdf.png b/posterior_ecdf.png new file mode 100644 index 0000000000000000000000000000000000000000..bb7733c7992b2e1ad11bb2aeb8652454824a9d71 GIT binary patch literal 46542 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 T;S=HNNI}$;uPb3MnfU!5KfIs= literal 0 HcmV?d00001 diff --git a/ecdf.png b/prior_ecdf.png similarity index 100% rename from ecdf.png rename to prior_ecdf.png From e8db62e5ec636497f6b77d9088211daf5c7b84d6 Mon Sep 17 00:00:00 2001 From: cab14bacc <86755693+Cab14bacc@users.noreply.github.com> Date: Tue, 26 May 2026 23:29:53 +0300 Subject: [PATCH 11/23] chore: fix linting errors --- simuk/sbc.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/simuk/sbc.py b/simuk/sbc.py index 35bfee8..deea63f 100644 --- a/simuk/sbc.py +++ b/simuk/sbc.py @@ -755,8 +755,8 @@ def run_simulations(self): self._simulations_complete += 1 progress.update() - except Exception as e: - logging.error(f"Stopping simulation. An error occurred during simulations:") + except Exception: + logging.error("Stopping simulation. An error occurred during simulations:") traceback.print_exc() finally: if self._simulations_complete: From 52492ed7a6c3861e49290241f1c453c5baf58c37 Mon Sep 17 00:00:00 2001 From: cab14bacc <86755693+Cab14bacc@users.noreply.github.com> Date: Wed, 27 May 2026 12:04:31 +0300 Subject: [PATCH 12/23] build: pin pymc version to < 6 to prevent syntax mismatch --- requirements-dev.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements-dev.txt b/requirements-dev.txt index 93d7627..a28f690 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -2,7 +2,7 @@ pytest-cov>=2.6.1 pytest>=4.4.0 pre-commit>=2.19 ipytest==0.13.0 -pymc>=5.20.1 +pymc>=5.20.1,<6.0.0 bambi>=0.13.0 arviz_base>=0.5.0 ruff==0.15.13 From 5ec4df74bdfaf6625c690e9b00f460d4dc69ff36 Mon Sep 17 00:00:00 2001 From: cab14bacc <86755693+Cab14bacc@users.noreply.github.com> Date: Wed, 27 May 2026 13:10:13 +0300 Subject: [PATCH 13/23] fix: use lowered method argument --- simuk/sbc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/simuk/sbc.py b/simuk/sbc.py index deea63f..0444fba 100644 --- a/simuk/sbc.py +++ b/simuk/sbc.py @@ -301,7 +301,7 @@ def __init__( self._transform = transform self.method = method.lower() - if method == "posterior": + if self.method == "posterior": if trace is None: raise ValueError( "When performing Posterior SBC, posterior samples from the " From fa3f050d360cb3ba98827ff4ceff91fcb27c92f5 Mon Sep 17 00:00:00 2001 From: cab14bacc <86755693+Cab14bacc@users.noreply.github.com> Date: Wed, 27 May 2026 13:12:14 +0300 Subject: [PATCH 14/23] refactor: simulator error logic --- simuk/sbc.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/simuk/sbc.py b/simuk/sbc.py index 0444fba..3ff0cc2 100644 --- a/simuk/sbc.py +++ b/simuk/sbc.py @@ -425,14 +425,16 @@ def _get_simulator_data(self, free_rv_samples): params["seed"] = self._seeds[i] try: res = self.simulator(**params) - assert isinstance(res, Mapping), ( - f"Simulator must return a dictionary, got {type(res)}" - ) - pred.append(res) except Exception as e: raise ValueError( f"Error generating prior predictive sample with parameters {params}: {e}." ) + + if not isinstance(res, Mapping): + raise TypeError(f"Simulator must return a dictionary, got {type(res)}") + + pred.append(res) + pred = dict_to_dataset( {key: np.stack([pp[key] for pp in pred]) for key in pred[0]}, sample_dims=["sample"], From 7fdb9dd5883aacf6cbeb3ff0d77ac9d09ac3b3af Mon Sep 17 00:00:00 2001 From: cab14bacc <86755693+Cab14bacc@users.noreply.github.com> Date: Wed, 27 May 2026 13:12:43 +0300 Subject: [PATCH 15/23] chore: add tests for coverage --- simuk/tests/test_posterior_sbc.py | 56 +++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) diff --git a/simuk/tests/test_posterior_sbc.py b/simuk/tests/test_posterior_sbc.py index 4212b1c..63f7e56 100644 --- a/simuk/tests/test_posterior_sbc.py +++ b/simuk/tests/test_posterior_sbc.py @@ -272,3 +272,59 @@ def test_posterior_sbc_warnings_for_prior(caplog): assert "update_data" in messages assert "augment_observed" in messages assert "trace" in messages + + +def test_posterior_sbc_update_data_not_callable(): + """Passing a non-callable update_data should raise ValueError.""" + with pytest.raises(ValueError, match="`update_data` should be a function or None"): + simuk.SBC( + simple_model, + method="posterior", + num_simulations=5, + sample_kwargs={"draws": 5, "tune": 5}, + trace=trace_simple, + update_data="not a function", + ) + + +def test_posterior_sbc_augment_observed_not_callable(): + """Passing a non-callable augment_observed should raise ValueError.""" + with pytest.raises(ValueError, match="`augment_observed` should be a function or None"): + simuk.SBC( + simple_model, + method="posterior", + num_simulations=5, + sample_kwargs={"draws": 5, "tune": 5}, + trace=trace_simple, + augment_observed="not a function", + ) + + +def test_posterior_sbc_bad_simulator_args(): + """Any fault in executing the simulator should raise a general ValueError.""" + with pytest.raises(ValueError, match="Error generating prior predictive sample"): + sbc = simuk.SBC( + simple_model, + method="posterior", + num_simulations=5, + sample_kwargs={"draws": 5, "tune": 5}, + trace=trace_simple, + # bad function args + simulator=lambda: None, + ) + sbc.run_simulations() + + +def test_posterior_sbc_bad_simulator_return(): + """Simulator should return a dictionary, otherwise raise a TypeError.""" + with pytest.raises(TypeError, match="Simulator must return a dictionary"): + sbc = simuk.SBC( + simple_model, + method="posterior", + num_simulations=5, + sample_kwargs={"draws": 5, "tune": 5}, + trace=trace_simple, + simulator=lambda *args, **kwargs: None, + ) + + sbc.run_simulations() From 55e5798ff0d443afe8fe1bbfd57452b1ab2881ef Mon Sep 17 00:00:00 2001 From: Osvaldo A Martin Date: Fri, 29 May 2026 08:26:40 +0300 Subject: [PATCH 16/23] Update docs/examples/gallery/posterior_sbc.md --- docs/examples/gallery/posterior_sbc.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/examples/gallery/posterior_sbc.md b/docs/examples/gallery/posterior_sbc.md index e1c62ec..b0f26a4 100644 --- a/docs/examples/gallery/posterior_sbc.md +++ b/docs/examples/gallery/posterior_sbc.md @@ -147,7 +147,7 @@ sbc = simuk.SBC( model, method="posterior", trace=idata, - param_transform=param_transform, + transform=param_transform, update_data=update_data, num_simulations=50, seed=random_seed, From 4cfd0a750645c2b202f06ee863973fd51c636b37 Mon Sep 17 00:00:00 2001 From: Osvaldo A Martin Date: Fri, 29 May 2026 08:35:56 +0300 Subject: [PATCH 17/23] groups is a tutple --- simuk/sbc.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/simuk/sbc.py b/simuk/sbc.py index 3ff0cc2..38e9e26 100644 --- a/simuk/sbc.py +++ b/simuk/sbc.py @@ -307,9 +307,9 @@ def __init__( "When performing Posterior SBC, posterior samples from the " "original posterior are required to generate replicate datasets" ) - if "posterior" not in trace.groups(): + if "posterior" not in trace.groups: raise ValueError("`trace` should contain 'posterior' group") - if "observed_data" not in trace.groups(): + if "observed_data" not in trace.groups: raise ValueError("`trace` should contain 'observed_data' group") if self.num_simulations > trace["posterior"].sizes["draw"]: raise ValueError( From 83dd0f0d9c816789cf748c13c2bfbd8e4c030c99 Mon Sep 17 00:00:00 2001 From: Osvaldo A Martin Date: Fri, 29 May 2026 08:50:00 +0300 Subject: [PATCH 18/23] Update simuk/sbc.py --- simuk/sbc.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/simuk/sbc.py b/simuk/sbc.py index 38e9e26..9b34c14 100644 --- a/simuk/sbc.py +++ b/simuk/sbc.py @@ -307,9 +307,9 @@ def __init__( "When performing Posterior SBC, posterior samples from the " "original posterior are required to generate replicate datasets" ) - if "posterior" not in trace.groups: + if "posterior" not in trace: raise ValueError("`trace` should contain 'posterior' group") - if "observed_data" not in trace.groups: + if "observed_data" not in trace: raise ValueError("`trace` should contain 'observed_data' group") if self.num_simulations > trace["posterior"].sizes["draw"]: raise ValueError( From 654502476f216c32cd6027afa8e9b020ccf95c97 Mon Sep 17 00:00:00 2001 From: cab14bacc <86755693+Cab14bacc@users.noreply.github.com> Date: Fri, 29 May 2026 18:19:13 +0300 Subject: [PATCH 19/23] refactor: use default_rng instead of np.random --- simuk/tests/test_posterior_sbc.py | 10 +++++----- simuk/tests/test_prior_sbc.py | 6 +++--- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/simuk/tests/test_posterior_sbc.py b/simuk/tests/test_posterior_sbc.py index 63f7e56..5d2bb21 100644 --- a/simuk/tests/test_posterior_sbc.py +++ b/simuk/tests/test_posterior_sbc.py @@ -10,15 +10,15 @@ import simuk -np.random.seed(42) +default_rng = np.random.default_rng(1234) # --------------------------------------------------------------------------- # Test data # --------------------------------------------------------------------------- -obs_data = np.random.normal(2.0, 1.0, size=20) +obs_data = default_rng.normal(2.0, 1.0, size=20) x_obs = np.linspace(0, 1, 20) -y_obs_reg = 1.5 * x_obs + np.random.normal(0, 0.5, size=20) +y_obs_reg = 1.5 * x_obs + default_rng.normal(0, 0.5, size=20) # --------------------------------------------------------------------------- # PyMC models and traces @@ -200,7 +200,7 @@ def test_posterior_sbc_no_trace(): def test_posterior_sbc_trace_missing_posterior(): """trace without 'posterior' group should raise ValueError.""" trace_missing = trace_simple.copy() - del trace_missing.posterior + del trace_missing["posterior"] with pytest.raises(ValueError, match="posterior"): simuk.SBC( simple_model, @@ -214,7 +214,7 @@ def test_posterior_sbc_trace_missing_posterior(): def test_posterior_sbc_trace_missing_observed_data(): """trace without 'observed_data' group should raise ValueError.""" trace_missing = trace_simple.copy() - del trace_missing.observed_data + del trace_missing["observed_data"] with pytest.raises(ValueError, match="observed_data"): simuk.SBC( simple_model, diff --git a/simuk/tests/test_prior_sbc.py b/simuk/tests/test_prior_sbc.py index 86d945e..967ad49 100644 --- a/simuk/tests/test_prior_sbc.py +++ b/simuk/tests/test_prior_sbc.py @@ -11,7 +11,7 @@ import simuk -np.random.seed(1234) +default_rng = np.random.default_rng(1234) # Test data data = np.array([28.0, 8.0, -3.0, 7.0, -1.0, 1.0, 18.0, 12.0]) @@ -31,8 +31,8 @@ y_obs = pm.Normal("y", mu=theta, sigma=sigma) # Bambi model -x = np.random.normal(0, 1, 20) -y = 2 + np.random.normal(x, 1) +x = default_rng.normal(0, 1, 20) +y = 2 + default_rng.normal(x, 1) df = pd.DataFrame({"x": x, "y": y}) bmb_model = bmb.Model("y ~ x", df) From 4dc942f7b69733d8733047c26c9c45636b6f3656 Mon Sep 17 00:00:00 2001 From: cab14bacc <86755693+Cab14bacc@users.noreply.github.com> Date: Fri, 29 May 2026 18:22:15 +0300 Subject: [PATCH 20/23] docs: change example to ipynb, change post sbc example to match prior sbc, and other doc related changes --- README.md | 20 +- docs/conf.py | 2 +- docs/examples.rst | 7 + docs/examples/gallery/posterior_sbc.ipynb | 409 +++++++++++++++++++++ docs/examples/gallery/posterior_sbc.md | 236 ------------ docs/examples/gallery/prior_sbc.ipynb | 416 ++++++++++++++++++++++ docs/examples/gallery/prior_sbc.md | 240 ------------- docs/examples/img/posterior_sbc.png | Bin 54741 -> 105899 bytes docs/examples/img/prior_sbc.png | Bin 112794 -> 104838 bytes docs/index.rst | 9 +- posterior_ecdf.png | Bin 46542 -> 0 bytes prior_ecdf.png | Bin 110226 -> 0 bytes simuk/sbc.py | 6 +- 13 files changed, 857 insertions(+), 488 deletions(-) create mode 100644 docs/examples/gallery/posterior_sbc.ipynb delete mode 100644 docs/examples/gallery/posterior_sbc.md create mode 100644 docs/examples/gallery/prior_sbc.ipynb delete mode 100644 docs/examples/gallery/prior_sbc.md delete mode 100644 posterior_ecdf.png delete mode 100644 prior_ecdf.png diff --git a/README.md b/README.md index cd3a08a..e0b7910 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,13 @@ # Simuk Simuk is a Python library for simulation-based calibration (SBC) and the generation of synthetic data. -Simulation-Based Calibration is a method for validating Bayesian inference by checking whether the posterior distributions align with the expected theoretical results derived from the prior. -Simuk works with [PyMC](http://docs.pymc.io), [Bambi](https://bambinos.github.io/bambi/) and [NumPyro](https://num.pyro.ai/en/latest/index.html) models. +Prior Simulation-Based Calibration (Prior SBC) is a method for validating Bayesian inference by checking whether the posterior distributions align with the expected theoretical results derived from the prior. + +Posterior Simulation-Based Calibration (Posterior SBC) is a method for validating Bayesian inference by checking whether the posterior distributions conditioned on the augmented data (original + posterior predictive) align with the expected theoretical results derived from the posterior. + +For Prior SBC, Simuk works with [PyMC](http://docs.pymc.io), [Bambi](https://bambinos.github.io/bambi/) and [NumPyro](https://num.pyro.ai/en/latest/index.html) models. +For Posterior SBC, Simuk only works with [PyMC](http://docs.pymc.io) models for now. ## Installation @@ -37,7 +41,7 @@ pip install simuk ```python sbc = SBC(centered_eight, num_simulations=100, # ideally this should be higher, like 1000 - sample_kwargs={'draws': 25, 'tune': 50}) + sample_kwargs={'draws': 100, 'tune': 100}) sbc.run_simulations() ``` @@ -54,7 +58,9 @@ should be close to uniform and within the oval envelope. ); ``` -![Prior Simulation based calibration plots, ecdf](prior_ecdf.png) +![Prior Simulation based calibration plots, ecdf](docs/examples/img/prior_sbc.png) + +We see that due to the funnel neck in the eight schools model, the inference algorithm is not well-calibrated, as indicated by the red points. ### Posterior SBC @@ -109,7 +115,7 @@ covariates and coords in an `update_data` callback to match the augmented data. trace=idata, update_data=update_data, num_simulations=50, - sample_kwargs={"draws": 25, "tune": 50}, + sample_kwargs={"draws": 100, "tune": 100}, progress_bar=False ) post_sbc.run_simulations() @@ -117,7 +123,9 @@ covariates and coords in an `update_data` callback to match the augmented data. plot_ecdf_pit(post_sbc.simulations, group="posterior_sbc", visuals={"xlabel": False}) ``` -![Posterior Simulation based calibration plots, ecdf](posterior_ecdf.png) +![Posterior Simulation based calibration plots, ecdf](docs/examples/img/posterior_sbc.png) + +We see that the funnel neck in the eight schools model is avoided and the inference algorithm is well-calibrated locally for the observed data, as indicated by the absence of red points. ## References diff --git a/docs/conf.py b/docs/conf.py index c0901af..fd602ce 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -46,7 +46,7 @@ numpydoc_show_inherited_class_members = False numpydoc_class_members_toctree = False -source_suffix = ".rst" +source_suffix = {".rst": "restructuredtext", ".ipynb": "myst-nb"} master_doc = "index" language = "en" diff --git a/docs/examples.rst b/docs/examples.rst index 2405235..b59e976 100644 --- a/docs/examples.rst +++ b/docs/examples.rst @@ -28,3 +28,10 @@ The gallery below presents examples that demonstrate the use of Simuk. :alt: Posterior SBC +++ Posterior SBC + +.. toctree:: + :hidden: + :maxdepth: 1 + + examples/gallery/prior_sbc + examples/gallery/posterior_sbc \ No newline at end of file diff --git a/docs/examples/gallery/posterior_sbc.ipynb b/docs/examples/gallery/posterior_sbc.ipynb new file mode 100644 index 0000000..de77f9a --- /dev/null +++ b/docs/examples/gallery/posterior_sbc.ipynb @@ -0,0 +1,409 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Posterior Simulation-Based Calibration\n", + "\n", + "**Posterior SBC** (Säilynoja et al., 2025) validates the inference algorithm\n", + "*conditional on observed data*, rather than averaging over the prior.\n", + "\n", + "```{admonition} When to use Posterior SBC\n", + ":class: tip\n", + "\n", + "Use **Prior SBC** when you want to check that your inference pipeline works\n", + "for a wide range of datasets generated under the prior.\n", + "\n", + "Use **Posterior SBC** when you already have observed data and want to verify\n", + "that the inference algorithm is trustworthy *for that specific dataset*.\n", + "Posterior SBC focuses on the region of the parameter space that matters\n", + "for the observed data, making it more sensitive to local calibration issues.\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pymc as pm\n", + "from arviz_plots import plot_ecdf_pit, style\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import simuk\n", + "\n", + "random_seed = 42\n", + "rng = np.random.default_rng(random_seed)\n", + "style.use(\"arviz-variat\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## How Posterior SBC works\n", + "\n", + "Given a model $\\pi(\\theta, y) = \\pi(\\theta)\\,\\pi(y \\mid \\theta)$ and\n", + "observed data $y_{\\text{obs}}$, Posterior SBC proceeds as follows:\n", + "\n", + "1. **Fit the model** to $y_{\\text{obs}}$ to obtain posterior draws\n", + " $\\theta'_i \\sim \\pi(\\theta \\mid y_{\\text{obs}})$.\n", + "2. **Generate replicated data** from the posterior predictive:\n", + " $y_i \\sim \\pi(y \\mid \\theta'_i)$.\n", + "3. **Augment** the observations: $y_{\\text{aug}} = (y_{\\text{obs}}, y_i)$.\n", + "4. **Re-fit the model** on the augmented data to get\n", + " $\\theta''_{i,1}, \\ldots, \\theta''_{i,S} \\sim \\pi(\\theta \\mid y_i, y_{\\text{obs}})$.\n", + "5. **Compute the rank statistics** of $f(\\theta'_i)$ among $f(\\theta''_{i,1}), \\ldots, f(\\theta''_{i,S})$. Where $f$ is an optional test quantity applied to the parameters before computing ranks.\n", + "\n", + "By the self-consistency of Bayesian updating, $\\theta'_i$ is also a draw\n", + "from the augmented posterior $\\pi(\\theta \\mid y_i, y_{\\text{obs}})$.\n", + "Therefore the rank statistics should be **uniformly distributed** if the inference\n", + "is calibrated." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Out-of-the-box Posterior SBC\n", + "\n", + "We shall illustrate Posterior SBC using the same eight schools model as the one used in the Prior SBC example. This model is known to have a funnel-shaped posterior (Neal's Funnel) when $\\tau$ is small, which is challenging for many inference algorithms. We use Posterior SBC to focus on the parameter space relevant to the observed data (i.e. the posterior), we wish to see it avoid the funnel neck and show that locally the posterior is well-calibrated. \n", + "\n", + "### Define the model\n", + "\n", + "```{admonition} Model requirements for Posterior SBC\n", + ":class: warning\n", + "\n", + "Posterior SBC augments the observed data (concatenating original + replicated),\n", + "which changes its size. For this to work, store observed data in ``pm.Data``\n", + "containers, and specify size using the ``dims`` parameter instead of setting a static shape. \n", + "If your model uses ``dims`` and ``coords``, you are also responsible for resizing them to the correct size corresponding to the new augmented dataset via the ``update_data`` callback.\n", + "Similarly, if your model has covariates, store them in ``pm.Data`` so they\n", + "can be resized in the same callback.\n", + "```\n", + "\n", + "We define the eight schools model as before, but with the observed data stored in `pm.Data` containers and sized using `dims` to properly handle the augmented dataset. Here we also add `sigma` and `theta_idx` to the data containers so they can be resized in the `update_data` callback." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "data = np.array([28.0, 8.0, -3.0, 7.0, -1.0, 1.0, 18.0, 12.0])\n", + "sigma = np.array([15.0, 10.0, 16.0, 11.0, 9.0, 11.0, 10.0, 18.0])\n", + "\n", + "coords={\n", + " \"obs\": np.arange(8),\n", + " \"school\": np.arange(8),\n", + " }\n", + "school_idx = np.arange(8)\n", + "\n", + "with pm.Model(coords=coords) as centered_eight:\n", + " school_idx = pm.Data(\"school_idx\", school_idx, dims=\"obs_id\")\n", + " sigma = pm.Data(\"sigma\", sigma, dims=\"obs\")\n", + " data = pm.Data(\"data\", data, dims=\"obs\")\n", + " \n", + " mu = pm.Normal(name='mu', mu=0, sigma=5)\n", + " tau = pm.HalfCauchy('tau', beta=5)\n", + " theta = pm.Normal('theta', mu=mu, sigma=tau, dims=\"school\")\n", + " y_obs = pm.Normal('y', mu=theta[school_idx], sigma=sigma, observed=data, dims=\"obs\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Fit the original posterior\n", + "\n", + "First, we need the posterior samples from the observed data. These will\n", + "serve as the reference distribution for Posterior SBC." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "with centered_eight: \n", + " trace = pm.sample(1000, tune=1000, random_seed=random_seed, progressbar=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using `update_data` with covariates and `dims`\n", + "\n", + "When your model uses `dims`/`coords` or has covariates stored in `pm.Data`,\n", + "you must provide an `update_data` callback that resizes everything to\n", + "match the augmented observations. The callback is called **before** the model\n", + "is re-conditioned, and runs inside the model context." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def update_data(model, augmented_data, simulation_idx):\n", + " with model:\n", + " pm.set_data(\n", + " new_data={\n", + " \"sigma\": np.concatenate(\n", + " [model[\"sigma\"].get_value(), model[\"sigma\"].get_value()]\n", + " ),\n", + " \"school_idx\": np.concatenate(\n", + " [model[\"school_idx\"].get_value(), model[\"school_idx\"].get_value()]\n", + " ),\n", + " },\n", + " coords={\"obs\": np.arange(16)},\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Custom test quantities with `transform`\n", + "\n", + "You can define a scalar test quantity applied to both the reference draw\n", + "and the posterior draws before computing the rank statistic. The function\n", + "receives `(param_name, param_value)` and should return a comparable value." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "def transform(param_name, param_value):\n", + " return param_value**3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run Posterior SBC\n", + "\n", + "Pass `method=\"posterior\"` and provide the `trace`. In each iteration, Posterior SBC\n", + "generates replicated data from the posterior predictive, augments it\n", + "with the original observations, and re-fits the model." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "sbc = simuk.SBC(\n", + " centered_eight,\n", + " method=\"posterior\",\n", + " trace=trace,\n", + " transform=transform,\n", + " update_data=update_data,\n", + " num_simulations=50,\n", + " seed=random_seed,\n", + " sample_kwargs={\"draws\": 100, \"tune\": 100},\n", + " progress_bar=False,\n", + ")\n", + "\n", + "sbc.run_simulations();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize the results\n", + "\n", + "If the inference algorithm was well-calibrated, we expect a uniform distribution that lies within the 94% credible interval, indicated by not having any red points. In our case, we wish to see that the funnel neck in the eight schools model is avoided and the inference algorithm is well-calibrated locally for the observed data." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAC1cAAASUCAYAAAAx2hYhAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAewgAAHsIBbtB1PgABAABJREFUeJzs3QeYXGX5P+43vRMSSkJICC0ECCRBmiBFgVBEgVCkg6iAFDEiIij4E0UQASkCIioICN+ICErvvUgEUgi9mZAASSAJSUgv/+s9+c+6u9mZnZmd2Wn3fV17ZWfmzDnvzs5OnnPO5zxvmxUrVqwIAAAAAAAAAAAAAAA1rm2pBwAAAAAAAAAAAAAAUA6EqwEAAAAAAAAAAAAAhKsBAAAAAAAAAAAAAFbSuRoAAAAAAAAAAAAAQLgaAAAAAAAAAAAAAGAlnasBAAAAAAAAAAAAAISrAQAAAAAAAAAAAABW0rkaAAAAAAAAAAAAAEC4GgAAAAAAAAAAAABgJZ2rAQAAAAAAAAAAAACEqwEAAAAAAAAAAAAAVtK5GgAAAAAAAAAAAABAuBoAAAAAAAAAAAAAYCWdqwEAAAAAAAAAAAAAhKsBAAAAAAAAAAAAAFbSuRoAAAAAAAAAAAAAQLgaAAAAAAAAAAAAAGAlnasBAAAAAAAAAAAAAISrAQAAAAAAAAAAAABW0rkaAAAAAAAAAAAAACCE0N6rAAAAAAAAAJTS4MGD0z623XbbhZtvvrlVxwMAQG1SlwIQ6VwNAAAAAAAAAAAAAKBzNQAAAAAAAJCrF154IYwZMybt4yNHjgz9+/f3wjbj9ddfD4888kjax/fYY4+w2WabeR0BANSlRaUuBWiofaPbAAAAAAAAABnFYPVVV12V9vHttttOuDrLEEum13HdddcVrgYAUJcWnboUoKG2jW4DAAAAAAAAAAAAANQk4WoAAAAAAAAAAAAAAOFqAAAAAAAAAAAAAICVdK4GAAAAAAAAAAAAABCuBgAAAAAAAAAAAABYqf3//y8AAAAAAABAxXjllVfCf//73zB9+vTQpk2b0Lt377DFFluEjTfeuKDbmTlzZpg4cWLy7+zZs8PChQvDaqutFnr16hU22GCDMHjw4GT75WrJkiVh8uTJYdq0aclrNWfOnORnWLp0aejatWvo1q1b6NmzZ/K6rb/++qFtW5MfAwDkQl2qLgWqT5sVK1asKPUgAAAAAAAAgPJ1xx13hLPPPrtg67vpppvC9ttvX3c7BpTT2W677cLNN9+cfD9v3rxw/fXXh3/+859h6tSpTS7fv3//cMopp4QDDjgg76DwRx99lIzxiSeeCO+9917GZWPIeueddw7f/va3w6abbppx2RdeeCEcc8wxoVAuvPDCcOCBBza4LwbOn3nmmTB27Njw+uuvh0mTJiVB6mx06dIlbLvttmHkyJFhjz32CB07dizYWAEACkFdmp66FKBwdK4GAAAAAAAAyl4MJp9xxhlJ9+VMpkyZkgTBn3zyyXDxxRfnFBCO4e1f/epX4a677so6kDxr1qxk+bvvvjvsueee4bzzzkuCLaXyxz/+Mdx+++15PXfBggXhqaeeSr4GDhyYvBYxbA0AwP+oS9WlQPUzpxMAAAAAAABQ1u69996kM3Rzwer6HnjggfDLX/4y6+VfffXVpNt17IaYbbC6vjhh8IMPPhgOOuig8Nprr4VKFzteH3300eG+++4r9VAAAMqGurT1qUuBUhCuBgAAAAAAAMrW22+/Hc4888ywZMmSnJ972223hTFjxjS73Lvvvhu++c1vhg8++CC01NSpU8Nxxx0XJk+eHCpdDIyfddZZ4fXXXy/1UAAASk5dWjrqUqC1CVcDAAAAAAAAZWvWrFl5dZJOuemmmzI+Pnv27HD88ceHOXPm5L2NptZ50kknhQULFoRKt2jRonDFFVeUehgAACWnLi0tdSnQmtq36tYAAAAAAACAirPRRhuFI488su72hAkTwiuvvJJ2+T322CP06dMn7eOZHsvki1/8YjjmmGPC4MGDw/Lly8PTTz8drrzyyiTMnM4TTzwRFi5cGDp37tzk43/4wx+SbtPptG3bNnzta18LX/3qV8PGG28cOnXqFGbMmJFs+4Ybbki77XfeeSfcfPPN4YQTTmjwc9d/Hd97773w/PPPp932DjvsEDbccMO0j8ffS6bHhg0bFjbbbLPQv3//sM4664Ru3bolr0P8meJr8umnn4a33norPProo+Hxxx9Pu6742H//+9+w/vrrp10GAKA1qEvVpepSoDW0WRF75gMAAAAAAABk6Xe/+1246qqrMnaL3n777bN+PWNYujnHHnts+MlPfrLK/W+88UY4+OCDw5IlS9I+d/To0WGrrbZa5f7p06cnQfDYBa8pXbp0Cddee20S6m7Kxx9/HI444oi04ezVV189CS537969ycfvuOOOcPbZZ6cd94UXXhgOPPDAkIsXX3wxCXEPGDAgp+f97W9/Cz/72c/SPn7eeeeFww47LKd1AgAUm7p0JXUpQGG1LfD6AAAAAAAAAApqyJAh4ayzzmrysU033TR86Utfyvj8999/v8n7H3roobTB6mjUqFFpg9VR3759M4ajY1frZ599NrSmbbbZJudgdTRy5MiMj7/00kstGBUAQHVQl2ZPXQpUsvalHgAAAAAAAABAJt/5zndC27bp+0bFgPUTTzyR9vE5c+Y0ef8zzzyT9jkdOnQIhxxySLO/mB122CHj4zFcvddee4VSmDt3bnjqqafC2LFjk4D5Bx98kNy3YMGCsHDhwpDLJMexGyIAQK1Tl+ZHXQpUGuFqAAAAAAAAoGzFUPWuu+6acZlevXplfHzevHlN3j9u3Li0z1myZEn4whe+EFpq4sSJobVNnjw5XHHFFeHBBx9Mfo5CSBdQBwCoFerS3KlLgUolXA0AAAAAAACUrQEDBoRu3bplXKZz584ZH2+qQ/OyZcvCZ599Fort008/Da3pvvvuC2eeeWbBQtXNBdQBAGqFujQ36lKgkglXAwAAAAAAAGVr9dVXb3aZ9u1zP+05e/bssHz58lBsM2fODK3lqaeeCqeffnqTYfKWKsY6AQAqibo0e+pSoNK1LfUAAAAAAAAAANLp1KlTVlO0l6vFixe32nZ+/vOfC0EDABSJujQ76lKgGuhcDQAAAAAAANRk58EYym6N7tWt4d///neYOnVqxmV23XXXcPjhh4fNN9889O7dO3To0KHB44MHDy7yKAEAaExdqi4Fyo9wNQAAAAAAAFBz2rVrF3r27BlmzZrV5ONrrrlmePbZZ0OleOaZZzI+fsghh4Tzzz8/7eNz584twqgAAGiOurQhdSlQDsp3fiwAAAAAAACgLLVp0yZUg6FDh6Z97JNPPglvvvlmxbyOH3/8ccbHjzjiiIyPjx07tmBjAQBoLerS8nsd1aVANRCuBgAAAAAAAHLSuXPnjI/Pnj27Il7RnXbaKePjV199dd7rjsHsW265pdVex3nz5mV8fNGiRWkfW7FiRfjTn/6U9bYAAMqFurR56lKA3AlXAwAAAAAAADlZbbXVMj5+1113heXLl5f9q7rnnnuGDh06pH38wQcfDL/+9a/DkiVLslpfDEPfeeed4dhjjw377bdfeOCBB1r0Ot53331h8eLFWW27uXXdcccdTd4ff0+/+tWvwgsvvJDVdgAAyom6tGnqUoCWad/C5wMAAAAAAAA1ZoMNNsj4+COPPBL22muvMGzYsNCjR48G04xvu+22YZ999gnloG/fvuGwww4LN998c9plbrjhhvDoo4+GkSNHhq233jqsu+66SYfEzz//PHz22Wdh8uTJ4bXXXguvvPJKePnll8PSpUsL9jrGde6+++5hm222CT179gxt2/6vd9agQYPC4YcfXnd7o402yriu2267Lelufeihh4YBAwYkoeoJEyaEG2+8MYwfPz7rMQMAlBN1qboUoBiEqwEAAAAAAICcDBkyJHTs2DFjV+UYOo5fTSmXcHV08sknh4ceeihMmzYt7TLx57jiiisKvu1+/fqFPn36ZNz29OnTkw7WjX35y19uEK6Ot6+66qqM24vraWpdAACVSl1aGOpSgIb+d2kzAAAAAAAAQBa6du0a9t5776p4rXr37h3++Mc/hu7du5dk+wceeGBB1rPllluGHXfcMe/nH3zwwQUZBwBAa1KXFo66FOB/hKsBAAAAAACAnI0aNSr07NmzKl65wYMHhxtuuCH079+/1bf9rW99q2DbPe+880KvXr1yft5WW20Vzj333IKMAQCgtalLC0NdCvA/wtUAAAAAAABAztZdd91w/fXXh4EDB1bFqzd06NDwr3/9KxxyyCGhQ4cOLVpXp06dwl577RVOOumkZpddbbXVkmD3FltsEVpqvfXWC3/6059C3759s37OTjvtlDync+fOLd4+AEApqEvTU5cC5Kd9ns8DAAAAAAAAalwMBN97773h0UcfDY8//nh47bXXwvTp08Pnn38elixZEipN9+7dw/nnnx9OO+20MHr06PDII4+Et99+Oyxfvjzj89q0aZMEm7/4xS8mXzvvvHPo0aNH1tuNz7399tvDM888Ex566KHw6quvhg8//DDMmzcv59cx/k7uvPPO8Ic//CHcdtttYf78+U0ut/7664fvfOc74eCDD07GDwBQydSlK6lLAQqjzYoVK1YUaF0AAAAAAAAAVSUGnCdOnJiExufOnRvmzJkT2rdvH7p16xZWX331JBi94YYbhq5du4Zys3jx4jB27Njw3nvvhc8++yy0a9curLXWWmHIkCFh0KBBpR4eAAA5UJcCtB7hagAAAAAAAAAAAACAEEJbrwIAAAAAAAAAAAAAgHA1AAAAAAAAAAAAAEBC52oAAAAAAAAAAAAAAOFqAAAAAAAAAAAAAICVdK4GAAAAAAAAAAAAABCuBgAAAAAAAAAAAABYSedqAAAAAAAAAAAAAADhagAAAAAAAAAAAACAlXSuBgAAAAAAAAAAAAAQrgYAAAAAAAAAAAAAWEnnagAAAAAAAAAAAAAA4WoAAAAAAAAAAAAAgJXa////AgAAAAAAAFDP4sWLw2uvvRbef//9MHPmzLBo0aLQuXPnsOaaa4aNNtoobLrppqFdu3ZeMwAAAKgiwtUAAAAAAAAA9bz44ovhlltuCY8//nhYsGBB2temR48eYc899wzHHHNMErQGAAAAKl+bFStWrCj1IAAAAAAorBdeeCGMGTMm7eMjR44M/fv397IDAEA9n376afh//+//hYcffjin16VNmzbhkEMOCWeddVbo1q2b1xQAgBabMmVKmDBhQvI1fvz4ZEaVhQsXpl3+1FNPDd/73ve88gAFoHM1AAAAQBWKweqrrroq7ePbbbedcDUAANTz9ttvh+985zvh448/zvl1if2sbrvttjBu3Ljwpz/9KfTp08drCwBAzmItGWdRiYHqeOEfAKXRtkTbBQAAAAAAACibroDf/OY38wpW1/fWW2+F4447Lnz22WcFGxsAALXj2muvDY8//rhgNUCJCVcDAAAAAAAANSt2nf7xj38cPvnkk4Ks79133w3nn39+QdYFAAAAtD7hagAAAAAAAKBm3X777cnU6+m0bds2HH300eHvf/97ePLJJ8Ott94a9t9//4zrvOuuu8Lzzz9fhNECAAAAxda+6FsAAAAAAAAAKEMLFy4Ml1xyScZlYhfqgw46qO523759w9Zbbx0GDBgQrrrqqrTPu+CCC8Ldd99d0PECAFC7unbtGubPn1/qYQDUBJ2rAQAAAAAAgJr0yCOPhNmzZ6d9/Itf/GKDYHV9J510Ulh//fXTPvett94K48ePL8g4AQCoLd27d09q0RNOOCFcffXV4emnnw7nnntuqYcFUDN0rgaAFpg6dWqYOHFi+Oijj8LixYtDnz59wlZbbRXWW2+9Zp87Z86cZKrJSZMmJc9dffXVQ//+/cM222wTOnXq5PcCAEDZd/ibPHlymDZtWpg+fXqYN29eWLRoUVi6dGno1q1b8hVr3MGDByd1bps2bUo9ZAAAWMWdd96Z8VU5+OCD0z7Wvn37sP/++4crrrgi7TJ33HFHGDZsmFceAICsnHfeeckx1Y022sgxVYASEq4GgP/fCy+8EI455pi0r8fIkSPDr3/96+T7GIr+3e9+lzxnxYoVqywbp4Q888wzw/Dhw5sMZF955ZXh3nvvDUuWLFnl8Risjtv63ve+F9Zcc82Mv58pU6aE3XffPasxpxN/jkxTV950001h++23z7gOAABKL4Y2zj777KyXz1T7NlUHvvHGG+G5554L48aNS77/4IMPwvLly7PusvKlL30pHHjggWHnnXcO7dq1K0iNfuqppyZ1cyZnnXVWxsDMo48+moS/AQCoPfECweeffz7jMrGOzWSnnXbKGK5+6KGHkoAMAABkY9999/VCAZSBtqUeAABUkhikvuyyy8LRRx8d/v3vfzcZrI5eeumlcNRRR4V//etfDe5/8MEHw9e//vXwz3/+s8lgdRS7/Y0ePToccMABSWgFAADKQbxo76KLLkpq2jj7SrbB6lRoJT7vxBNPDIccckh48803izpWAADIxuuvvx6WLVuW9vG111479O7dO+M6Ntlkk4wXD86cOTOZ+RAAAACoHMLVAJCD3/zmN+Haa6/NKkgSw9Oxe3XsTBLdddddYdSoUeHzzz/PalszZswI3/rWt5KD7wAAUC1effXVZGr1OBsMAACUujbNZP311292HZ07dw59+/bNuMxrr72W89gAAACA0hGuBoAsPfHEE+H666/P+fX65S9/mUwt+ZOf/CSn7n7Rp59+mnQHBACAarJ48eJwyimnhGnTppV6KAAA1LDmZlRZY401slpPr169Mj5uhkIAAACoLMLVAJClWbNm5fVaTZ8+PXz7299OOlnn495779W9GgCAqjN79uzwxz/+sdTDAACghsXmFpn07t07q/U0t5zZCQEAAKCytC/1AACg0nTt2jWcdNJJYbfddgs9evQIEydODL/61a/C1KlT0z5n2bJldd9vvvnmyfOHDBmSBK7vv//+8Lvf/a7BMvXFZR555JHwjW98oyg/DwAA1WGjjTYKRx55ZN3tCRMmhFdeeSXt8nvssUfo06dP2sebeqxNmzZhs802C1tuuWXYdNNNw7rrrptMgR5r5DgderRgwYIwY8aMpDvfAw88EMaMGZN2G7fddlsYNWpU6N69ew4/KQAAFMbcuXMzPt6pU6es1pOqhfPdDgAAAFBehKsBIAfxIPmNN94Yhg4d2iB0EqeHPPTQQ5t9/jbbbBNuuOGG0LFjx7r7YtB64cKF4dprr037vBiKEa4GACCTYcOGJV8p8QK+TOHqY445Jmy//fZZv6jHH398uPjii8Naa63V7LLrrbde2HrrrZOw929/+9vwhz/8ocnlFi1aFMaOHRt23nnnrMcBAACFMm/evIyP1z+O25LlmtsOAAAAUF7alnoAAFBJvvnNbzYIVqcMHz682akf27VrF84///wmD7QfeOCBGZ/7/vvv5zFaAAAonC996UtZBasbGzlyZMbHX3rppRaMCgAA8hebXjR3TDcb7dtn7mc1f/78nMYFAAAAlJbO1QCQg0zdqTfYYIMwc+bMtI9vt912yTJNGThwYNIVO93B/Dlz5vg9AQBQNj799NPwxBNPJJ2x44WAU6ZMCZ9//nlYsGBBswGVxqZNm1a0cQIAQCbxmGwmS5cuzeoFXLJkScbHu3Tp4hcBAAAAFUS4GgCyNGDAgNCvX7+0jzfXuTqGqzNZbbXV0gZRYlAFAABK7bXXXguXXXZZeOaZZ8Ly5csLss7PPvusIOsBAIBcde/evUWh6ZTFixdnfLxHjx45jQsAAAAoLeFqAMhSuq7TKZ06dcr4+Prrr5/x8Q4dOqR9bMWKFc2MDgAAiuuGG24IF110UcFr03nz5hV0fQAAUKhwdbazsjS3XHPbAQAAAMqLcDUAZKm57iKZwtHZPB8AAMrV3/72t/DrX/+6KOt2ISEAAKWyxhprZHz8008/zWo9M2fOzPh4c7MeAgAAAOWlbakHAACVomPHjiV9fj6ymao92+4rAADUphgUufjii0M5Uu8CANASm266aauEq5vbDgAAAFBedK4GgCq2dOnSZpf57LPPWmUsAABUpgcffDDMnTs34zL77bdfGDlyZBg8eHDo2bNnaN/+f4ecpkyZEnbfffeijE29CwBAS2y++eYZH//vf//b7Drmz58fpk2b1qLtAAAAAOVFuBoAKljbtpknoViwYEGz63jrrbcKOCIAAKrNM888k/HxUaNGhZNOOint4/PmzStpvfv222/nvX0AAKpbDD3HmjPdjCiffPJJ0r16jTXWyHh8NdOMKr169Qr9+vUryHgBAACA1pH5DBUAUNa6du3aouko48mBiRMnFnhUAACUgzZt2hRkPR9//HHGx4844oiMj48dO7Zk9e4rr7wSZsyYkff2AQCobt27dw877rhjxmWefvrpFl2MuNdee+U1NgAAAKB0hKsBoIL16NEjY2gmdk1ZvHhx2sf//Oc/h2XLlhVpdAAAlFLnzp0zPj579uys1tNc5+lFixalfSzWojfeeGPI12qrrZbx8VdffTXj43/84x/z3jYAALVh5MiRGR//xz/+kfaxJUuWhLvuuqtF6wcAAADKj3A1AFSwdu3ahQEDBqR9fP78+eHWW29t8rHHHnss3HTTTUUcHQAApdRcMDmGQDJNX57teu644460oeszzjgjvP/++yFf66yzTujUqVPax//73/+GRx55pMnHbrnllvDggw/mvW0AAGrDHnvsEVZfffW0j48ZMyb8/e9/b/Kxq666KkyaNCntcwcNGhSGDx9ekHECAAAArad9K24LACiCoUOHhsmTJ6d9/KKLLkqmcj/ggANCr169wpQpU5IgzW233ZZVmAYAgMq0wQYbZHw8hpLjFOXDhg1bZUaUbbfdNuyzzz7J9xtttFGYMGFC2vVceeWV4aOPPgr77bdfWHfddcOCBQvCiy++GK6//vrw3nvvtehnaN++fdh8883D2LFj0y5z+umnh+9+97vJz9KtW7ckzB3DL/fee2+Ltg0AQO3M+BIvCjznnHPSLnPuueeGN954IznGutZaa4WpU6eG//u//wt33313xnX/9Kc/LcKIAQAAgGITrgaACrf33nuHe+65J+3jMUB9ww03JF8AANSOIUOGhI4dO4bFixenXSZepJfuQr1UuPrLX/5yuPPOO9OuY9myZWH06NHJV7Hq3Uzh6tgh+4orrki+AAAgHwcffHBS87700ktNPr5ixYrw17/+NfnKVrz4cIcddvALAQAgJzfeeGPa2VGaa2bx5JNPhlmzZjX5WJyt5bTTTvPbAMiScDUAVLivfOUrSYfA2C0lH7GbdbodLAAAKlfXrl2TYHKctaQlRowYETbccMO8u1DHoMrtt9+e9/Zjd8Df/e53Yd68eXk9P540mD17dt7bBwCg+sVZXH7zm9+EQw89NHzyySctXl+snzN1wgYAgEwzDo4ZMyavF+iVV15JvpoSMwXC1QDZa5vDsgBAGYpTpf/qV79qMI17tg466KBwxBFHFGVcAACU3qhRo0LPnj1btI527dqFX//616FTp045P3evvfYK3/3ud1u0/RiO/slPfpLXc7/3ve8lFyMCAEBz+vfvn8z+16dPnxa9WIMGDUrW09I6HAAAACgd4WoAqAJxeskLL7wwCVpnIy73gx/8IFxwwQV5hbIBAKgMsRvJ9ddfHwYOHNii9QwbNixcffXVYbXVVsup4/Qll1xSkHozXhQYg+K5dO2Ote6pp57a4m0DAFA7Ntlkk3DHHXeE3XffPefnxrr3kEMOCaNHjw59+/YtyvgAAACA1pFdAgsAKHsjR44MgwcPDpdeeml47rnnwvLly1dZpkuXLmG33XZLugfGEwUAAFS/LbbYItx7773h0UcfDY8//nh47bXXwvTp08Pnn38elixZkvV6dt555/DPf/4zCVnfddddaZ+7+eabh5NPPjmMGDGigD9FCCeddFLYaqutwuWXXx7Gjh3b5DIx/L333nsn9W4MlgMAQK7WXHPNcM0114QXX3wx3HzzzeGJJ54ICxcuTLt89+7dw5577hmOPfbYsOmmm3rBAQAAoAq0WbFixYpSDwIAKKyZM2cmB/+nTZuWhGZ69+6ddEvZZpttki5+AADQEvPnz0/qzQ8++CDMmTMndOjQIak3hw4dGtZbb72iv7ixzn3ppZfCjBkzkqBLDMD069cvbL311qFjx45F3z4AALVj8eLF4dVXXw3vv/9++PTTT5PbnTt3DmussUbYaKONkosL27VrV+phAgBQJY4++ugwZsyYgq83NqN47LHHCr5egGolXA0AAAAAAAAAAAAAEEJo61UAAAAAAAAAAAAAABCuBgAAAAAAAAAAAABI6FwNAAAAAAAAAAAAACBcDQAAAAAAAAAAAACwks7VAAAAAAAAAAAAAADC1QAAAAAAAAAAAAAAK+lcDQAAAAAAAAAAAAAgXA0AAAAAAAAAAAAAsJLO1QAAAAAAAAAAAAAAwtUAAAAAAAAAAAAAACvpXA0AAAAAAAAAAAAAIFwNAAAAAAAAAAAAALCSztUAAAAAAAAAAAAAACGE9l4FSmnZsmVh9uzZyferr756aNeunV8IAAAVT50LAEClU9MCAFAO1KUAAJSCztWUVAxWf/e7302+UiFrAACodOpcAAAqnZoWAIByoC4FAKAUhKsBAAAAAAAAAAAAAISrAQAAAAAAAAAAAABW0rkaqGkffvhhGD58eBg8eHC48MILSz0cysBTTz2VvB/i1913313q4QAA5E2tS2NqXQCg0qhpaUxNCwCUgrqUxtSlANWvfakHABTeihUrwiOPPJIEQ1977bUwffr00LVr19CvX7+w2267hQMPPDD5vtCWLVsW3n777fDKK6+EiRMnJv++9dZbYcmSJcnj2223Xbj55pvzWveUKVPCHXfcEcaMGRPee++9MGfOnNCuXbvQs2fPsMkmm4QvfelLYf/99w+9e/fOab2//vWvw4IFC0L37t3Dd7/73VBLJkyYUPeaTps2LXnf9O3bN/k9xffI0KFDi7r9559/Ptx5551h/PjxyfY7duwY+vTpE3baaadw8MEHh4022ijrdc2cObPuPZd6/82YMaPu8Ztuuilsv/32Wa1rl112CV/84hfDv//97/Cb3/wm+Zvp1q1bXj8jAFA9tW7K4sWLw3333Rfuvffe8M4774RPPvkkqUn79+8fRowYEUaOHJlVTbpo0aJk/Kna5b///W9S08SvuI0ePXqEgQMHJhcC7rfffmHzzTfPeaxqXbVuY2pdACgP1VLTNufRRx8NJ5988ir3xe1kS02rpm1MTQsAhVNNuYLPPvssPPfcc+GFF14Ib7zxRpg0aVKYO3ducg461rZbbrll+MpXvhL22Wef0KFDh5zHrC5VlzamLgWofm1WxGqpRi1dujSMHTs2TJ06NSkSY7gyBgvjyetCHDjMRTyx/u677yYHMuPJ9FTYM45jyJAhYf311w/V6NNPP60LtF577bVhjTXWKPWQKl4MqZ555plJMDSduEN07rnnJjtDhRJ3us4444zkvZtOPjtB8SPqyiuvDNddd13yN5tJ/Jv58Y9/HL7xjW9kte5x48aFQw89NPk+vg9/8IMfhFoQT57E0PBf//rX5PVtSps2bcLRRx+dvJfy2bnMZN68ecn7L57ASSdu83vf+1448cQTm13fYYcdlnyWZ5JLuDqKgfP480ennXZaOOWUU7J+LgBE6tzqqnVT4j5brHnjiYZ04j5NnBFl1113zbiuP//5z0lNlq140P/nP/95WH311bNaXq2r1k1HrQtAttS0xVFNNW1zxwC/+tWvJj9vvuFqNa2aNh01LUBtUZcWR7XkCj7//PPwwx/+MDzzzDN14exM1l133XDRRReFbbfdNusxq0vVpemoSwGqW012ro5F2jXXXJN0bI0dGZoK9cUrjL7//e+HwYMHF20cH3zwQbj//vuTIi8GA2PgMZ3YzTUGCI888sikg0Qu3X533333vMd4xRVXhL333jvv59O64gHr73znO8lVnSmx+/DGG2+cPBZ3jGLH5/nz54ezzz47tG3bNhxwwAEF2XZcb6YdoHz94he/CLfeemvd7U6dOiVXlcYD8PGihMmTJ4dXX321QWg3/i0dddRRza778ssvr1vnMcccE2pFfI3++c9/1t1eb731wrBhw5KgddwxjJ8b8fsYSI47oxdccEHBth13aE899dSka3VK7DweLyJZuHBhePHFF5OO03G53/72t3XLZxIvjim0uMMeL7SJr8cNN9yQvJ9y+ewFAKqr1o0+/vjj8M1vfrOu9ogXo8UD8LGWiid4Yn0T65n4fbww649//GPYYYcdslp3nCUjztoRa9zYsTpeVBhPbsT9xFiPRXHfMc7gEmvjeFFhc9S6K6l1V6XWBYDSqeaatrF4IWHjYHWu1LQrqWlXpaYFgJapplxBHOPjjz/e4L4111wzbLHFFsm/8Vjr66+/Ht58883ksdh8MdbEV111VdLJOhvq0pXUpatSlwJUt5oLV8epRWIX0nhSOp0Y5ovdE2LoORaKhx9+eMHHETvkZura2lg8CBmDzvFEepxuZKeddir4mKh8MYic2gGKHe3ie+aLX/xi3eMxmPGzn/0s3HPPPcntc845J2y11VbJdOOFEndQYvg57qzEf+PfUQzp5uM///lPg2B17HRy1llnJRcb1Dd+/PjkZ0n97PHAfZy+svFy9cWphVIB37322qtmuqbffvvtdcHquBMcO33HYHn8Plq+fHny+4pX68bv//GPfyQ7BIXaWY4XtqRe9xhqjx1w9t1337rHYzA+7pzGTo7R7373u2T78SuTeFHMoEGDkvdc6mv//fdv0ViPOOKIJFwdp4v629/+Fk444YQWrQ8AqOxaN3ZTSYVQYneTWNdsuummdY/HGYhOP/30pNaJ+5SjRo0KDz/8cFhttdWaXF8cV+yosvPOOycXm7Vr126VZWKwJV7oFWdyibVZPAFw2WWXJRfLZaLWVes2R60LAKVRbTVtOrGBwm233ZZ8/7Wvfa3u58mFmlZN2xw1LQBUbl1a6FxBFBtlxfPDBx10UIMat36NGjt1x3B1DFzH2vjBBx9MxpGJulRd2hx1KUD1WpmmqxHxoOG3v/3tVYLVsWNq7M4ci8XYMSwldsWN0y7fddddBR/LpEmTVrkvdomI3criyfV4wDFOudc48Bk7up544omrXHkHcefn7rvvrnshLrnkkgY7QFF8f1988cXJjk8UD5DHoEYhxPdtfF8+++yz4dprr026Dcf3cK4H3uuL3eXr/51eeumlTQamY9fl2EWlc+fOdX+7Dz30UMZ133jjjXXfH3LIIaEWxOByvAI3JV6NHK/KTQWro/h9vC9+VqbE90imzvrZih1v/vKXv9Td/slPftIgWB117Ngx2amNQfqU2ME6k3gS6KWXXgp33nlnciAg/j6b2mHOVfx/IfX+veWWW8KyZctavE4AoDJr3SeffDK58C91Udfvf//7VeqN3r17J3XJgAEDktuzZ88Of/rTn9Kuc4899kgu3tpss82aDFZHsb496aSTkq+UWPPEejcTta5atzlqXQBofdVY0zYl1qoxfBNnxoud7U4++eS8xqumVdM2R00LAJVZlxY6VxBr21hzxgaKP/3pT9OeJ95mm22S8HZqVsDYobt+zZmOulRd2hx1KUD1qplwdTyQFztW15+GLnYH+9e//pUEOOOVeLEoeuKJJ8JRRx3V4LnxQGDseF0ssSNr7LT73HPPJd2s48HKGCK97rrrkoIyhiHrB0rjVXSx83Wcwi9XsUNtLCqz/YpFLJXh//7v/5JudtGXvvSlZKekKTE8+6Mf/ajudpxePHYkaam11lor9OvXLxTSG2+8Uff9Pvvs0yAE3Fjfvn2THaKU//73v2mXjZ2IU+HrOO76z6tm8W/6o48+Sr6P081nOrERp/2My0Tx6t148qWlYhAoTssUrb/++uHQQw9Nu2x8j6Z+32PHjg2vvfZa2mXjDnLsgl1ocZ2pqaDi5228WhoAqM1aN15olTJy5MgwePDgJpfr2rVrst+ZEme/iPtvLVX/YsDYNaapi3VT1Lpq3WyodQGg9dVKTXv11VeH999/P/n+vPPOy+u4nZpWTZsNNS0AVGZdWuhcQey8/f3vf7/u3HYm/fv3D4cddljd7ZgPykRdqi7NhroUoHrVTLg6BiljQK9+0fTXv/51lavW4tVwcYrlo48+ukGnhRi+LqTYpXqvvfYK9957b7j55puT6UliV4imlhsxYkS4/fbbk2n6UhYsWJDXmOLPF3/2bL+6dOkSakE8kJz6Spk4cWLyXoi/p3hF5rbbbhsOPPDApKNHLKLL7eKBxx57rO52HGcmW2+9dRJujWI33vrPLSepIG6UzZWqcaqflNQOYbrPg1S3v9122y1jaLuxDz74IFx00UVJx+X4vohds+N7JHa5bxxyueCCC+reVzGgXGqPPPJI3fexM3Smv+/4WAy0p8TpPwu5/fgejZ9v6cQd6h122KGg289H/PxNKcYsBgDQGtS6Lat1Y5g5Toueba0du1SkZkSKnf5S3QFbovGMRnFM6ah11brZUusCUEnUtJVR08ZmGX/+85+T7/fbb7+w44475jVeNa2aNltqWgBam7q0PHMFufjCF75Q931z5/DVperSbKlLAapTzYSrY/fn+n72s581CGI29sMf/rBBmDkG+15//fWCjSdOmRK/Nt5446yWX3vttcP555/f4L4HH3wwLF68uGBjouH7JXaHu+2225IOyDHkO2fOnPDqq6+Gyy+/PAmdFiIkUShxjPU7mcdu6M2pv8y///3vUI7WWWeduu+z6R5ff5l00/1EcZqhlMZTHGXyl7/8JQlVX3/99eGdd95J3hcLFy5MXv94he/Xv/71ugBxDLynumMPGTKkwedJqbzwwgsle4/EMPv48eNLtv18xTGkwvdPP/10cjECAFQ6tW5u4kW6qf2u2MVvyy23zLh8x44dw/Dhwwtax7z77rsNbmfq7KLWVetmS60LQCVT05ZfTRuPm8Vp2GOX69g98Oyzzw75UtOqabOlpgWg1NSllad+A7BMDdsidam6NFvqUoDqVBPh6jfffDO89dZbdbc33HDDsOuuu2Z8TuzaWn86kOjuu+8u2JjyCVrGLg+xm3T9bhOFDHyz0k033RR+97vfJYX0euutF772ta8lnTyGDh1a9xLNmDEjnHDCCWHChAll8bLVD1vEaXRiGL85m2++ed337733XihHsat0yh133JGEmNO588476/7O48H72Jm5KfH3Wr9LS+zinY0Yqr/wwgvrOl4PHDgwHHDAAWHPPfcMvXr1Su6Lj51xxhlJd+sYJP7oo49WuUqxVGK39fi+ber3n079ZaZNmxbmzZuX9/bjVKCpndO4w5rr9kv1Ho0X4aQugvnss8+SjvYAUMnUui2rtTfZZJPQvn37Vq1jYgjmkksuqbsdQy59+vRpclm17qqvfza/I7WuWheAyqKmLc+aNjamSB07i9PHNzVTZzbUtKu+/tn8jtS0aloAWp+6tDLVzw717ds37XLq0pXUpdmRKwCoTs0fQasC9a8mS01Hl43YhfbSSy+tu/3YY4+FM888M5RS7MY7ZcqUutvTp08v6Xiq0W9+85vQqVOn8Mtf/jLsv//+DR6Lgdkf/OAHyfQwsWtxfD/861//SpZvLAaB4w5VIQ0bNmyVMaWCq9l0sauv/nLlGq4+9NBDw9///vdkBydeTHDwwQeH4447Luyxxx7JhQYxzDxp0qSka3Tq4ocePXokQej4b1Piz5oKCccQdrpgSn3PPfdcuPbaa+tuf+973wunnHJK3VWtcWrM0047LekMvWDBgmTqy86dO9ctnylc/Ytf/CIUUvyZ4lgyvUeyfZ80Xia+dvUvMshF/fdYnNa+qb+ZTNuPr/HMmTPzPinTEvGEU2onO34GxL9DAKhUat3c5VNr15+BJZ9aOwaq44VxL774YrjhhhvqLqqNXQbPOeectM9T62b/e1LrrqTWBaASqWnLr6aNzSZiw5Jo2223DQcddFAeo/zfthy/VdPmQk0LQKmoSytPDEzHfEf9BofpqEtXcqw1e+pSgOpTE+HqZ599tsHtbbbZJuuDh7HDdAzSpg5Afvjhh1kffCyGdu3aNbi9ZMmSko2lWsXX9LLLLmuy83EMVcbg7MiRI5MQbXxP3H777eHII49cZdnYKeKWW24p6NhioLupcHUMntYPrmZjzTXXrPs+/iwxwBGneywnMYB788031wWXY/flK6+8MvlqrEOHDkmn69NPPz1stNFGGTvZ1+9in42rr746rFixIvl+p512Cqeeeuoqgea487z33nsnr+UjjzySjCfaYIMN6jofN6XQ75H4mdVUuHrWrFl133fv3r1B+DtTB/9u3bolwfZU5+Z8tfQ9mlpHKcLV9d9PZgsAoNKpdVunjomzyaRkW0PFDiBxKvV01l9//XDFFVckF9ymo9ZV6+ZKrQtAJVLTll9Ne+655ybHReMx0fPOO6/BVOu5UtOqaXOlpgWgVNSllefWW2+tu3Cwbdu2q8xmX5+6VF2aK3UpQPVpG2rAO++8U/d9LJC22GKLrJ/buENp/XWVQuwAkSl8SMvFzhpNBatTYlj22GOPrbsdOyuXWgxdp2QTmm1quVSAttzE4PKNN94YrrvuuiQ4nM6QIUPCvvvum/x+Mqnf+T3TND8p8eKK2DEw5YQTTmhyubiunXfeOfk+dhmMF2JEe+65ZygH+bxHGi9bfx2tsf3Gy7Vk+y1Rv7t5/fcPAFQitW7r1DH1Z+loaZ0d92GPP/74cO+992YMVkdqXbVurtS6AFQiNW151bSx+cjzzz9fd+w0U+OLbKhp1bS5UtMCUCrq0sry9ttvN5i5Ps6aHTsNp6MuVZfmSl0KUH2qvnN17Kgwc+bMBl0ZYjfWbPXv37/B7dipeJdddgmlEEOe9bumtm/fvtmT643F7r9xHW+88Ub49NNPkxP1MbwaQ6ux+I+df7fccstQy5rqDN1Y7Fx97bXXJt/H1zK+z3r27Nlgme23377B1YzFtGjRorrvUx2Tm9O4S3X9dZTbFb9//OMfw1/+8pfkdY5ToW+99dZJZ/nYbTvuBL366qth3LhxyddNN90UrrrqqrQXHnzyySd138f3fnPGjx9f933smhz/TtKJnw0PPfRQg/v22GOPjOsv5/dI4/fJwoULS/oebcn2W6JXr15Nvn8AoBKpdVu/jsm2zj7iiCOSaSmj2PXvo48+ChMmTEiCLLEefvDBB5OOgJn2R9W6at1cqXUBqERq2vKpaWP9GWf0S8208t3vfjeP0a26zhTHb3P7PTl+6/gtAK1LXVo55syZE0455ZS6iw7XW2+9cNZZZ2V8jrrUsdZcOdYKUH2qPlw9efLkBrdjIDMXjTvbNl5fa/rrX/8aVqxYUXc7BkxXW221nNbxn//8Z5X7YgEZu+zGx6655pqw4447hrPPPjvjVXrVbPjw4c0uEw8UxwO7cTrF+DuJgfUvfvGLoVTqdxGJYeRsxGByunWUixgqid1OxowZUxc4Of3000OPHj0aLPfaa6+FM844I7z77rth7Nix4Tvf+U647bbbVgnnptaZS5eWuM6UeOFBvCAhU/fsxp83Q4cODeUgn/dI4/dJLh2vi/Eebcn2W6L+duu/fwCgEql1W7+OybbOPuecc5rcV7vlllvClVdemeyLnnjiieGCCy5ILvZsilpXrZsrtS4AlUhNWz417S9+8YukIUbq+6aOx+ZKTaumzZWaFoBSUZdWhnih4MknnxwmTZqU3O7evXtyvLVbt24Zn6cuVZfmSl0KUH3SpwSrxLx58xrcjp1n872yKJo7d24ohRjwjOHq+o499tiibOu5554L3/jGN8J9990XalG2Afz6y9Xvjl4KsZtzrt0pGi/X3M5DKVx44YV1weoDDzww/L//9/9WCVZHm2++ebjxxhuTzvRRDLvH24WQOjkQ9evXL+OyG2+8cYPOL811rS7390jjZeuvozW233i5lmy/Jepf1AIAlU6t2zp1TP3Ofi3d9vHHHx9++9vfJrdjZ+tYE3/wwQehENS6al21LgCVSE1bHjXtI488ksyukjp2G2dyLAU1rZpWTQtAqahLy9/SpUvDqFGj6poQxosGY8PBzTbbrODbUpeqS9WlANWn6jtXxymUW9Kdt3Gn1NQ0Ia0pdoj44Q9/2KBTROySvPvuu+d08PRLX/pS8rxBgwYlIfP27duHWbNmJV1/H3roofDCCy80uAovdgKOnbF32mmnvMf+8ccfZ3w8br/cdOnSJeflGr/PWlv96RE//fTTrJ5Tfxqb+LMUoqtIIU2bNi3cfvvtyfdt2rRJdnoyWWuttcIxxxwTLrvssuT2HXfckQRRMv3esjmRUP+K1ObeG/E1jH9f8W8qGjFiRCgX9S8UiRedxJMjzX0exp+9/nu7Z8+eJXuPNl5Ha6p/IinbzwcAql8l1rmRWrd16pgZM2YUpIZKiXXlDjvsEJ5//vmkNrn11lvDj3/841WWU+uqdXOl1gWobWra2jl+W+iaNh43PO+88+qOO5555pmhUNS0atpcqWkBKp+6tHbq0tYUG1WcddZZ4bHHHktux3zMFVdckfVFgepSdWmu1KUA1afqw9X1g5FRroVe4/Bh4/W1htiZLHbird8l4vzzz886VP2zn/0smTa6qa6vG2ywQfjCF74QjjrqqKRjdQxUp4roZcuWhdNPPz0JXucbatx1110zPh67/BbjqsCWiL/jOBVMNstl6tzx3//+N9x0000FHduwYcPC/vvv3+TvMeXDDz/Mal31l9twww1DuYnvx/geTP18ffr0afY58eKBlPfeey8JBjf+3cQQdi6hp/o7TfUvcEgnNa1m3DnbZpttml0+TpdZSPFv9bTTTsv4HommTp3a7O+98XupJe+T+s+NnzHZhLvrbz/+XLnOPFAo9TvT13//AFDbKrHOjdS6ucun1v7oo48KXmvvuOOOSbg6evnll5tcRq27klo3e2pdgNqmpq2d47eFrmnj8b3p06fXNcY48cQT066n8THVU089te48TXwPnnLKKQ0eV9OupKbNnpoWoPKpS2unLm1NP//5z8Pdd9+dfN+2bdtw0UUXha985StZP19dupK6NHvqUoDqU/Xh6sbigb6WLN/a0zj88Y9/TDrw1h9PDFYPGDAgq+fHMOKRRx6Z9cn6m2++ORx66KFh7ty5dVOX/PnPf046Z9eKeNA4dh/OZrmmugLX77x8yy23FHRssXN6UztBG220UYOOIvGruRBoqrtyue4ExdcvJdtwf+PlYofmxuHqddddN+uroKPYvT3bq3fffvvt5Cs1xVD8Gfr165fxOYV+j8Sfr6lwdY8ePZL3RKrjTLxgo7nfe/33SAy3Z3PRQTpxRz3utMYrhOPnaNz+8OHDK+I9Wv+9WP/9AwCVSK2bu/q19ltvvZXUefFCutauY+p3C5w9e3aTy6h11bq5UusCUInUtOVV08YAQf0QQXPqN5Jpar1qWjVtrtS0AJSKurR8XXDBBeFvf/tb3e0468rXvva1nNahLlWX5kpdClB92oYq13ja6/rTMGRj4cKFDW431f25WP71r3+FSy+9tMF9sbP0V7/61aJtMx5k/dGPftTgvttvvz3vUPmTTz6Z8evvf/97gUZeOOPGjWt2mdiVOhVoiIH3zTffPJTS+uuvH/r27Vt3e8yYMc0+p/4y9Ts+l4vOnTvXfR9D/tloHDKpH4xO2XTTTeu+f//995td58Ybb9zgxEMm9957b4Pbb775Zign9ac4euGFF5pd/j//+U/B3iOxS3W8QjqX92ght98SsQt6Sjl2IAWgNCqxzo3Uurnbaqut6jrrxYsdJ06cmHH52Jmv/utcqDom07TsKWrdldS62VPrAtQ2NW3tHL8tl5o2G2raldS02VPTAlQ+dWnt1KWt4bLLLgs33nhj3e2zzz47fOMb38h5PerSldSl2VOXAlSfqu9c3TgMnWu4uvHyrRWujjsQP/nJTxqEmo8//vjwne98p+jbPvDAA5NQdyrQGrtOxJBo/eIxW/UL83TTpZebGGo/5JBDMi5z55131n0fX5emwg0xyNpa4doY8N5tt93CrbfemtyO3c733XfftMuPHTs2CYhHsZtwfG65WWeddRoUofEqv9g9OZN///vfdd/HLs2NL65IdVCOXZxjd/YYxm5uvVtuuWXd9++++26YNGlSGDhw4CrLLVu2LHnv1PfGG280O7VQawaw99hjj3DPPfck399///3JZ0z9EHvjC0viMvWfW4jtx/de6j16wgknpF02dhVPTXtfqO3nq36ovn5AHIDaVol1bqTWzV2cCWWHHXZI9tFSdUymGTgeeuih8Pnnnyffx/2EbbfdNhTCE0880WTnwfrUumrdXKl1AWqbmrZ2jt8Wuqbt379/1q/dlClTwu677153+9FHH02en46aVk2bKzUtQOVTl9ZOXVpsv//978O1115bdzvO+PzNb34zr3WpS9WluVKXAlSfqu9c3b179wa3Z82aldPzG09nF0OZxfbiiy8mRV6cmi8lXkkXu1a3hhgEaXywtLmOvdUkdsu977770j4edx7qX+nYXBC7tRx22GHJDk30zDPPhGeffbbJ5ZYvXx4uvvjiutv77LNP6N27dyg3MZzerl275Pt4kcEVV1zRbCe/m266qe72zjvv3ORy8TWqf0XtSy+9lHG9AwYMaBCwvvLKK5tc7u677w4ffvjhKn/L5SSexEgdnJgzZ06yc5nONddckyyTmvLoy1/+cou3P3LkyLoLVGLX8EwdPeN7NAbWU511hgwZEkohXmTyzjvv1J1I2mKLLUoyDgAoFLVufo444oi67+MJh7fffrvJ5RYsWNCgXjz00EObnG49dgvM5cLfeLLjlVdeqbu95557NrmcWletmwu1LgCVSk1bHjVtsahp1bS5UNMCUErq0vISMxyXX3553e3YuPCUU07Je33qUnVpLtSlANWp6sPVjTvMfvTRRzk9P3ZPbRy0LKbXXnstfPe73026xtYPv5533nmhNcUwZaaQeTWL4fKzzjprlS7E0YQJE8K3vvWt5ABzatqcgw8+OJSDwYMHh69//et1t08//fRVpmiJIY4f//jHdYHi+LN+//vfb3a9qa940L21rL766uGAAw6ou/2Pf/wj+TuIHacbe/XVV5MrTj/99NO6HZ34e0qnfjfp+t2u06m/rtj5OU4llAr+pjpU/+pXv1rlcyIG3J977rlQLuLUn9/73vfqbv/xj38MN998c4MO+TF8H3c842Mp8WKP1LShTTn66KPr3iPxbyedNdZYo8GVweeff/4qFzLEKUcvueSSug7bqfdyqcRpruJrkgrspwL/AFCp1Lr51brxQrNtttkm+X7JkiXhxBNPXKWbTLyQNx6sjzOdpOrZOPtQU+IyI0aMCH/6058y7qPGCwgvuOCC8Itf/KLuvjiOTLOjqHVXUus2T60LQKVS05ZHTVtMatqV1LTNU9MCUErq0vLIFUS33357uPDCC+tuH3nkkeFHP/pRi9erLl1JXdo8dSlAdWqzon6qrkrF6e5S4eAYunz55ZdDly5dsnruD37wgwbhv1g07LLLLkUZ53vvvZcUefWDzDHMF7vLtva04r/97W/DH/7whwbhxniwtdBiGDaGyaM4PUsMX5ZCLPBTfvrTn9YFZddbb71kesT4+sfutePHj69bLr6H/vKXv2ScPrG1zZs3L+lgXb/rSBxfnDY8PhaDxPGKuZRf//rXSTfhbF+buENy4IEHpl02HmifPn16g/s++eST5CuKXYvja9rYddddF/r06bPK/fFg/uGHH550OU6J69h6663DOuusk5wEiF3VY7i6vrijFK9ETScGtL/0pS8l3QLXWmut8NRTT9V1/U4nvk8ff/zxBhcgxA7v8XWNz4+h4NTFEPEz4uyzz657n8T7evXqFc4888xQDuI46l88EC9CGTZsWBKyHjduXPjggw/qHou/7/o7ounC1XFnIYrvp/i+Sif+zuLvpn6ofZNNNkk6U8ffR7zCO4aIUmIY/NRTT824/TiVaFMdxWPoPSW+71Jds1PitFXNXVxQ/7WK79Ndd9014/IAUG51bqTWLUytGy+8jRdWpmqVWD/GejBeWBf34Z5//vm6izBjZ78YnI77ok15/fXXG1xIGGvLWBPFmjHue8Qp2OP+YQy71L+oL05FGWdrWXvttdOOU62r1o3UugAUgpq2+o7fFrKmzdaUKVOSGfXqH8vr379/xueoadW0kZoWgBR1afXVpYXMFcRjqPFYa6phVnxuvN2mTZuQjdhoLF5U2BR1qbo0UpcC1K7Wm8uthDbeeOO64F8sqCZOnJgcMMxG/TBtal3F8OGHHybdcesHq2MXiauuuqrVg9WpUGt96YrJanTMMcckOwpXX311mDx5cvLVWAzkXnrppWUVrI66d+8e/vznPyeB0FR4NYZl41d9cYfinHPOaXYHKFfvvvtumDp1atrHY+fs+oHX+oHbpsRwSeys/JOf/CQJMKfW8fTTTze5fPy5YufkOFVlJj169Ah77bVXuOuuu5ITCTHQu/3222d8TpxCKF5kEA/+R/HnbPyzbrbZZkl37W7duoW///3vyYUc8WREvDI3brNcwtWxY3Qczy233JIEqmMnmlQ3mpS4s3nUUUclnc4LKX6exc+1c889N9x///3JfTEgH78aLxdD1alQWibx77Wp91V9Tf0dx99XJjHsnQrUx530GMgHgEqn1s1f3759kxk+fvjDHybh6LhvGWeKaTxbTO/evZOTB5lCKDGoEoMsqQP+TdWW9cVlYwjmjDPOCD179sw4TrWuWjdS6wJQzdS05VHTFpOaVk0bqWkBKHfq0vLIFcyePbvuOGvqubfeemvWY4k5nXR5GHWpujRSlwLUrpoIV++444514eroxRdfzCpcHbs41C/oYpewfv36FeVKy+OOO67BdNCxi2vsHN25c+dQCq+88kqD25k6o1Wj2C03dh8ePXp0eOmll5KrJmMAIl4ducceeySh09VWWy2UoxgCjR21H3744XD33XcnXZ1jgDgGj+P7N05dE4MZxXgvF0MMsseO8TEgHn+e+G/sdhK7+cXfSdzRiV3+4t95DIs3FzZJOfbYY5NwdRSD0M2Fq+Pf4jXXXBOefPLJ5Hljx45NLoaIHavjyYb4/Nj1PLX966+/PummHJdNXWFbLjp27JiEm/fff/9kiqT4+Tht2rS69892222XvEeGDh1alO3HndAYVv/GN74R7rzzzuR3Gt+j8fcZO5LvtNNOyfbjldGl9MADD4Q5c+Yk38dZBeL4AKAaqHXzF+uT2267LZnd6J577klmt4m1Xtw3iN3+4r7CQQcdlNSHmQwaNCg8++yzyVesK2N3lTh7SDwRsHTp0uRivVSd+4UvfCF87Wtfa3Kml3TUumrd5qh1Aah0atrS17TFpqZV0zZHTQtAOVCXVj91qbq0OepSgOrVZkVsW1rl4onq/fbbr8HBw3jgsDlxSpHYnTjl29/+dsE7z8ZpRI4++uikS0T98f31r38t2cHLeJXgvvvum3S0jdq1a5dMB5htaLUSp/CpP0VNfL9QG+JFDc8991wSNo4ditdcc81SD4kyEqfCimGnGAaPHcuL8RkIQPUqlzo3UuvWJrUumah1AciGmpZSU9OSiZoWoHaoSyk1dSmZqEsBqlfbUANimCB2/KofHo7dZzNZuHBh0rW4vtgtrJDiNk488cQGwer+/fuHG264oWTB6hiovvjii+uC1dHw4cOFCqlK3//+95N/Y/fpm266qdTDoYz85z//SYLV0Te/+U2fgQBAxVHrko5aFwCoFGpa0lHTAgCtSV1KOupSgOpWE+Hq6NRTT21w+5e//GX47LPP0i4fO1ZPnTq17nacCm/zzTdPu/wdd9yRhLhTX7EbdSZLlixJpoh56aWX6u5be+21w1/+8pecpnvOZPz48WHcuHFZL798+fJw0UUXJR1860t13INqEy8c2GuvvZLvb7nlljBr1qxSD4kycfXVV9d9LscrkQEAKo1al3TUugBApVDTko6aFgBoTepS0lGXAlS3mglX77nnnmGrrbaqu/3BBx+Eo446Krz55psNlps7d24SvK7fxbZTp05h1KhRBR3PWWedFZ566qm62507dw7nn39+aNOmTZgyZUrWX3PmzEm7jdih+9BDDw3HHntsEv6eOXNmk8vFLtXxaqq4XOyaXd+IESPCLrvsUsCfHMpL/Fvs0qVLmDdvXvj9739f6uFQBp5++unw/PPPJ9//6Ec/Ct26dSv1kAAA8qLWpTG1LgBQadS0NKamBQBKQV1KY+pSgOrXPtSIGFq+4oorwsEHHxymT5+e3PfWW2+F/fffPwwZMiQMGDAgzJ49O0yYMCF8/vnnDZ4bQ8+DBg0q6HjuueeeBrcXLlwYTjjhhLw6cscO2Jn8+9//Tr6iddddN6y//vqhR48eoX379snP/NprrzUZvB42bFi4+OKLcx4TVJJ+/frl1OGd6rfzzjuvcuENAEAlUuvSmFoXAKg0aloaU9MCAKWgLqUxdSlA9auZcHXUp0+f8Oc//zmcdtpp4f3336/r2jxx4sTkq7HYsTpefbbffvuFajF16tTkqzmHH354OPvss5PXAAAAAAAAAAAAAABqQdtQYzbZZJNw5513huOPPz6sscYaTS7ToUOH8JWvfCX8/e9/D0cccUSoVFtvvXX45je/GTbbbLOkS3VzunfvHkaOHBn+9a9/hZ///OeC1QAAAAAAAAAAAADUlJrqXJ3SpUuXcMYZZ4RRo0aFl19+OUyZMiV88sknoVu3bqFv375hq622Cr17985pnQceeGDyla0333wzFNvAgQOT7tPRokWLwttvv510rZ4xY0aYP39+WLZsWejRo0fo2bNnGDRoUBI8b9u25vL2rfb7AACAUlDrAgBQ6dS0AACUA3UpAEDtqMlwdUrs5rzddtslX9WuU6dOYYsttki+AAAAAAAAAAAAAIBV1WabYgAAAAAAAAAAAACARoSrAQAAAAAAAAAAAACEqwEAAAAAAAAAAAAAVtK5GgAAAAAAAAAAAABAuBoAAAAAAAAAAAAAYCWdqwEAAAAAAAAAAAAAhKsBAAAAAAAAAAAAAFbSuRoAAAAAAAAAAAAAQLgaAAAAAAAAAAAAAGAlnasBAAAAAAAAAAAAAISrAQAAAAAAAAAAAABW0rkaAAAAAAAAAAAAAEC4GgAAAAAAAAAAAABgJZ2rAQAAAAAAAAAAAACEqwEAAAAAAAAAAAAAVtK5GgAAAAAAAAAAAABAuBoAAAAAAAAAAAAAYCWdqwEAAAAAAAAAAAAAhKsBAAAAAAAAAAAAAFbSuRoAAAAAAAAAAAAAQLgaAAAAAAAAAAAAAGAlnasBAAAAAAAAAAAAAISrAQAAAAAAAAAAAABW0rkaAAAAAAAAAAAAAEC4GgAAAAAAAAAAAABgJZ2rAQAAAAAAAAAAAACEqwEAAAAAAAAAAAAAVmr///8LAAAAAAAAAABQVEuXrwhzlywt6jZ6dGgf2rdtU9RtAADVS7gaAAAAAAAAAAAouvsnzwiXjHs/zFuyrKjb6d6hXThj+AZhn/XWKup2AIDq1LbUAwAAAAAAAAAAAKq/Y3VrBKujuI24rbhNAIBcCVcDAAAAAAAAAABFNXfJ0lYJVqfEbcVtAgDkSrgaAAAAAAAAAAAAACCE0N6rAAAAAAAAAAAAtLbRI4aF1Tt1KMi6Zi9aEg57eHxB1gUA1DbhagAAAAAAAAAAoNXFYHWvAoWrAQAKpW3B1gQAAAAAAAAAAAAAUMF0rgYAAAAAAAAAAKrO7EVLslquR4f2oX3bNlktu3T5ijB3ydKcxpHL+gGA0hOuBgAAAAAAAAAAqs5hD4/ParnuHdqFM4ZvEPZZb62My90/eUa4ZNz7Yd6SZTmNI9v1AwDloW2pBwAAAAAAAAAAAFAqMSwdQ9OxK3U68bF8gtXZrh8AKB/C1QAAAAAAAAAAQEXr0aF90iE6XzEAPXfJ0rSPx8fyCVZnu34AoHwIVwMAAAAAAAAAABWtfds24YzhG7QoYA0AkNQVXgYAAAAAAAAAAKDS7bPeWmFE/zWz6hA9e9GScNjD41u0vdEjhoXVO3Uo2voBgNIQrgYAAAAAAAAAAKqmg3WvNIHnQovB6tbaFgDQetq24rYAAAAAAAAAAAAAAMqWztUAAAAAAAAAAEBeli5fEeYuWdrscrMXLSn7VzjTGAsx/mzX0aND+6QDNwBQGsLVANDKBw3qs1MMAAAAAAAAVKr7J88Il4x7P8xbsixUg8MeHl826x81dGDYe721slrWeWcAKCzhagAo4UGD7h3ahTOGbxD2yXKnGAAAAAAAAKBcmk9VU7C63Fw+YVLylQ3nnQGgsNoWeH0AUHNactAgPic+N64DAAAAAAAAoFLEWX1bEqyOgeDYcblU4rbjGIo1/pauPxfOOwNAYQlXA0CJDxrE58Z1AAAAAAAAANSCVKfl9m3blGwMcdtxDPkEoLMZf0vWnw/nnQGgcEp3+RcAAAAAAAAAAFA1Ro8YFlbv1KHZ5WJX51IGq1P2WW+tMKL/mjk3w8p2/Lmu/4HJM8LlEyblNBYAoPCEqwGglQ8azF60JBz28HivOwAAAAAAAFBV4jnSXlmEq8tJDEkXc8y5rP/wQf3CIRutk1UY23lnACge4WqgYJYuX5Hz1Zy5KperV6EaDxoAAAAAAAAAUN1hbwCgecLVQEHcP3lGuGTc+2HekmVFfUW7d2gXzhi+QTJ1DgAAAAAAAAAAAEAhCVcDBelY3RrB6ihuI25rRP81dbCuQq3R/bwY4nRLrbUO3dsBAAAAAAAAaMl552Irp/Pa+eQQymn8AJSGcDXQYrEIbY1gdUrcVtymaXCqS2t1Py9Xhz08vuDd21sjrJ7rTmU5jgkAAAAAAACgls47F1u5zEqebw6hXMYPQOkIVwNQU93PK1223dtbK6yey05lawboRw0dGPbOckdXGBsAAAAAAACgumYlb0kOoRzGX000YQMqkXA1UBSjRwwLq3fqULBpa8rl6kqqo/t5scXAcQzsphMfi8vk+zM31729NcPq2e5UtnaA/vIJk5KvbLjqGAAAAAAAAKg0LT3vXO2zkrc0h1Dq8VeLcmwMV2taI9yeK03wqATC1UBRxGC1ApNalCrYMwWN42NxmWLtQLR2WD2bncpyDtC76hgAAAAAAACoNMU+7wwtVY6N4WpNa84wngtheCqBcDUAVd/9vByvrotXS8aiPpurA3VvLz5XHQMAAAAAAACVJpfzzsVWCee1M+UQKmH8laYcG8PVktaeYTwXwvBUAuFqoCLFojYbppGoXLXQ/TyGsFvrZyxkWL1QO5WFDtA/MHlGuHzCpIKtDwAAAAAAAFoj/JZrMNZ5cEp13rnS1UIOASphhvFIGJ5yJ1wNVKRsg52VPI1EPjvRucp1p9uOfeUqx53EQo/p8EH9wiEbraMbOAAAAAAAABXh/skz8uoqWsnnwYHaVo6N4QCaIlwNVLVKnUYi353oXOWy023HnkrgqmwAAAAAAAAqQWxsle854Uo9D07tMSs5ldAYrpYUeobxXAjDU2mEq4GyF7srxxBwvkHjSptGoiU70cXa6bZjX1k7odnuoBZSc9ssxZgAAAAAAACgXMVz2C05J1xp58GpTZU+K3k5hMPznfU8lzEVa2Z1OYHyI9wO2ROuBspeLPZiEd1ageNK34kuxk63HfvyU25T25TbeCp5x66YO94AAAAAAAAA5aZcu7GXOhzeklnPsx1Ta82sXmvn/cuB1wJaRrgaqAix2ItFdDZXyplGAqjkgHi5XpUNAAAAAABAcY0eMSzpKtoU58Epd7U2K3mxw+EtnfU8mzG15szqtXben9IGwDW1oxCEq4GKEYu9Siyii70TnatC7XTbsa+cndD43LiOchlPMcZUTcr1qmwAAAAAAACKK54TrtVz4lS+Sp+VvNzC4YWY9by5MbX2zOpyArRWGF5TOwpBqgnKRLwaLJuuzI250qY2lONOdDmOqVq1ZCc0VTAWMqTb0p3iYoypFAHxYqrkq7IBAAAAAACA2lTJs5JXeji83BUjJ1Du5/3LTS2F2zW1oxBq468Fytz9k2e0OKQYC9RSBb6LNUVDIWU7RmF1qmEntDXe0/mOp5hjyoUdYwAAAAAAAIrZKK01zrOX+lx9qbdPearkWcnLPRze3KznhRhTIWdWL3ZOwHn/7NViEzxN7Wipmg5XL126NIwdOzZMnTo1TJ8+PXTv3j307ds3DB8+PPTu3bskY1qxYkWYMGFCmDRpUpg2bVro0qVLMqYhQ4aEddZZp2Db+eijj8LEiROTbSxYsCD06dMnrL/++mHLLbcMbdqUNvBWiztiLbnqrVhX2rQk8F2OcikeRw0dGPYuQli9nHdAm9umneLyUG47oeU2ntYMiBdauV2VDQAAAAAAQPmfN3d+CWrrPHhrzDBeabOYl9N5/3KmCR7kribD1TFMfM0114Q77rgjfPLJJ6s83qFDh7DLLruE73//+2Hw4MGtFvS+/vrrw+jRo5Owd2Nt27YN22+/fTjllFPCtttum/d2xowZE66++urk3+XLl6/yeP/+/cNhhx0WvvWtb4V27drlvR2yF/9zb+mOWKGvtGlp4LvSXT5hUvJVS1pjpztTQFt4m1Ip5x1jAAAAAAAASqfWz5tDKRQyOyCHUDuc968cxQzDa2pHodVcuPrtt98Op512WnjvvffSLrNkyZLw6KOPhmeeeSacffbZ4fDDDy/qmD7++OMkyD1u3Li0y8Qg9PPPPx9eeOGF8N3vfjdZPleXXXZZuO6665oMVadMmTIlXHLJJcnPf8UVVyQdrak9LQ18xykc4hVPtTKNBNlx1TQAAAAAAABQS43SCnmevRLOg5c6K0Dlq/RcQTmGwzXCo9wIw1MpaqqimT59evj2t78dpk2b1uD+IUOGhAEDBoTZs2eHV155JXz++efJ/YsWLQo///nPQ7du3cJ+++1XlDHFbR1//PHhrbfeanD/oEGDwoYbbpg8PnHixGRsUQxGx67bnTp1SkLW2brqqqvCtdde2+C+Xr16JT97165dk7D5O++8U/fY2LFjw4knnhhuvfXW5HFa1+gRw5JpNirxSpu4s3TG8A2S/whLJW47jqFariIu9A5oIXa67RRD8RXrSupymO4HAAAAAACA3M6zl/t58HLICkCplWOWpxzHBFAJaiZcvWLFiqRjdf1g9SabbBIuvvjisOmmm9bdN2fOnKRj81//+te6+84555yw2WabJYHnQjv33HMbBKv79u2bdI7edttt6+5buHBhuP7668OVV16Z/BzR5ZdfHoYOHRp23HHHZrfx1FNPJeHqlDZt2oRRo0aF4447Lglpp4wZMyacccYZda/R66+/noTLf/Ob3xTs5yU7MVjdK0O4uhwD3+UW2st1GokHJs8Il0+YFGphB7SlO93ZjKmlAW7hbSjeTm7qbzh+TgIAAADUn/Y+l2l5i3ksuJzGAgCQz3nzXGVbz+R6Hrw1qcnI5z3Tmt3Y5RCg9mTb1M7/YdR0uPqhhx5KujGn9O/fPwlQ9+zZs8Fyq622WhJ4jgHkm2++ua6DdQxc1w8oF0LsSH3vvfc22PYtt9ySjK2+zp07h5NPPjnpIH3hhRcm98WQdQxh/+Mf/0jGmk5quVQoOzr77LPDscceu8qy2223XbL9kSNHhrlz5yb33XXXXUkIO4bLqW3lGPgu5DQShw/qFw7ZaJ2y2wkt1n/eLdnpzmZMLQlwu6IZiiv+Tca/zfgZ4KQjAAAAEN0/eUbOx/KKdQF3OY0FAKAcz5vnch4cyllrdmMvRg6hHMPhGuFBfk3tHFegpsPVjYPRP/vZz1YJVtf3wx/+MDz22GNh6tSpye2HH3446eRcyJBx4zH94Ac/WCVYXV8MRN93331h/PiVf/SvvvpqePTRR8Mee+yRMVT+5ptv1t0ePnx4OOaYY9IuP2DAgGQcv/jFL5LbMZQdx3n11VeHarNsxYowZ3FuwdJyvkrFlTYtV2s7ocX+efMNcJfz3xkUS2vveMftxL/NWvrMAwAAANJ3ic4nzFCMC7jLaSwAAEDxtVY39mLkEMoxHK4RHuTHcQVqNlwdw8VvvfVW3e0NN9ww7Lrrrhmf06VLl3DYYYeFSy+9tO6+u+++u2Dh6s8++yw8/fTTDbpWH3TQQRmfEztUx4D16aef3mBMmcLV99xzT4Pb8fmZOl1HBx98cLj88svDnDlzkttPPvlk0sm6R48eoVo8OuXTcPG498OsLFv/V8JVKtleaRONGjow7J3hZ8g2qA3NqbXAOlTCjjcAAABAfTHEkO/xiEJfwF1OYwEAAFpHJecKyjEcrhEetaqlTe0cV6Amw9WPP/54g9v77bdfVs/7+te/3iBcHTtZn3nmmQUZ01NPPRWWLv3ff6x77bVX6NSpU7PPi0HqGPxesGBBcvuZZ54JixcvDh07dlxl2Xh/fDyla9euGYPYKXEcI0aMCP/4xz+S20uWLEnGu++++4ZqccHL7+b1QVotV6lcPmFS8gVAbex4x4tmcrkIBwAAAAAAAIDKDIeX45ig2DS1o9BqIlz97LPPNri9zTbbZPW8ddZZJ6y77rph6tSpye33338/fPjhh6Ffv34tHtNzzz2X15hi8HnLLbcMY8aMSW7PmzcvTJgwocnnjxs3LsyfP7/udnxeUyHspsT1pcLVqdewmsLVLVEOV6m09EobAMqTnVwAAACgHIweMSys3sQx8FJcwF1OYwEAAACqo6md4wo0pybC1e+8807d923btg1bbLFF1s8dNmxYXbg6ta5ChKvffvvtBrdj8DmXMaXC1al1NRWubryNoUOH5rSNdK9hNfjJFzYKF497P8xatCRUota+0iYGuWOgGwAAAACA6hfDzOXS5aycxsJKS5evKPq058WaIh0AcrFax/ZJHZLKFcTv430AQPnS1I5Cqfqq77PPPgszZ86su73GGmuELl26ZP38/v37N7gdu1fvsssuLR5XXE9KmzZtwoABA1o0pua2ERVjG5Vq9/5rhC+v2zvMWVy5V6nkcqVN9MDkGeHyCZPyClbHILcDkwDVJf7/lg0npwAAAACqWy5h6XzPNRRT6jxGPG8CAIXUrk2b8KPhG4QLXn43uR2/j/cBAFD9qj5cPXny5Aa311lnnZye37dv34zry0cMe8+bN6/udu/evUPHjh0LPqYPPvgg4/My6dSpU+jVq1eYNWtWcnvOnDnJ9/G+ahF3eiq920UuV9ocPqhfOGSjdXLuJiFUB1Cdsr1wyMkpAAAAoFIu4C6nsVSK+yfPaLVZMosljj3+DLEhjd8rAMVo3Ba/AIDq57gCNRWurh9iTgWZc9E4TDx37tySj6nx8unG1Pj+fLaTClenxl1N4eoFCxZktdzCRauGkZcuXRpCmlBztuvNtP4ml1u4MKxYsSLko127dkmAv6kw9qJFi8Ly5cvTPnfJoqUh3eHotm3bJkH8pjS33kwyrXfx4sVh2bL8DvLGLvGdO3du8rElS5as/L3mKV1H/LjOuO5Crze+BvG1yFd8HeLrUej1xt9b/P01Ft8L8T2Rr/j+je/jxuLfRPzbKPR68/lbrq9Dhw6hffv2BV9vXGdcd7E+I1rzb9lnROt+RmT7f01zJ6farFjuM6LKPiNiZ6rmTp62bde2wWdEnPJQZ47yVy3v0Wz4f2wlte7/qHVXUuv6jKjPZ4TPiFr8jMi11lXnlp9qeS8WuqbN5r2d0rZtm9Ax3XHWZL0rx/tZEw05Fi5YGBYsb+L+Jo4xZHsBd7f2bcP3h/QPe67b9LmK5Hhlm3ZZH79tyVhSF5OP6Nerpo/fxvdTpQerU+LPMGPOvLB6p/Y1/RmRC8dv/8c5npWc4ym/zwg1bXlQl67k/5yV5ApWkivwGdGYzwifEZX8GdHSYxzNHWvN5VhOfb26dg6dOxYmn1ifXEH2qj5c/fnnnze4nS7klU7jIOb8+fNbPKbG68ila3VTP0O6MTW+v6U/e+PXMhsff/xxxsfrh7db2/XXX5/VcgvbtA+hz9AG9738+lthuy03b3L5W/7vb2HRwuw/yBe2bR/CWk2vq7477rgj79driy22CLvuumuTj913333hww8/zGu9G220Udh7772bfOzxxx8P7767cnqkXPXr1y+MHDmyyceef/75MHHixLzWGy8OOOKII5p8bOzYseE///lPXuuNfyvf/va3m3zs9ddfD0899VTI1ymnnNLk/e+//3548MEH817vt771rSYPFsa/2X/+8595r/ewww4La6yx6pXb8b07evTovNd7wAEHhHXXXbfJg03Z/i03Za+99gobb7xxk4+1ZL277LJL2HLLLZt87NZbb807EL7tttuG7bbbrsnHfEas5DOi6c+IeHqlw9pDw5L4f04eYqEfZz6Y/8l0nxFV9BnxXufe4YXV+uf8vogXasWpD2u9U0c517nV8h7Nllp3JbXu/6h1V1Lr+oyoz2eEz4ha+4zIp9atxTpXTVt5NW2++3H5iH+znVcszep4ebY+X7o8XDz2vTD5wX+Gtmn+v9rnoEOyPn7bkrGkLiZfZ/ZH4dmnnw61evw2Hu+phmB1c+/bcv3/Klv2e1dS0/6P/d6V1LTVU9OqS3Pn/5yV5Aqqpy5NkSv4H3XpSrJHK8keFfczoqXHOPbJcKz1nFv/mfexnC5tQ/jx1huHfdZbq+KOtVZybVpT4erGKf2WBplbkvovVOg523B147Hmup3Gr1U+P3u6A8Ip8erczTbbLFSan02aH8KkF5t+sOfgEHq29ogAIL14wnL7OVNa7QQs5S8G7vN9P8xatCRc8PK7Fb0TVAjVWucCANRqrVuLda6atnb24wqp44qloVNYHhY1GY9uXhz/4jbtswrAZjOWDsuXtuhi8vnVkysuiW3mTAkbLpgZ9vnqPmGdddZpsgN6POGbr6/s9pWwwQYbNPnYNTfcFO7KonENQCWqtZpWXQoAlEKPDu2Tma3yveg4dYwjndixuiXHchYsD3WzjLdvu+rsVq1heY3nCmouXdPUNGq5LJ/vlF25bKPQy5fzzw4AtI4NF84M6y+cmbG4T9n3kG+EY596o1XGRWnE90GpT8gDAEAxqHWpVq353o6B5RhcbkqMVI9oMyc80X6Nknc8djF5cew347XQeXnz4ff4HklF7Ht2aJd0pGpswfKlLQrSr9a+bZPrjbIZI0ClUtMCABRfDCyfMXyDpAN17ERdaHG2qJYey0nNMp5u37jYFtd4rqDqf/LG01MsWrQop+c3bp/etWvXFo+p8TpybdGe7Zga/+y5bqfxa5XPz/7kk09mfDy2kf/Zz34WyllLu1/kKl4RE6+MAYBCiye8sjmh1dP/Q2QxfU+tq4Y6FwCA2q5z1bQ0JR4Lj7NfZepLvUWbheHsr22bnNxr7LnnngtvvP6/C7YXtm1f1O7C2VxM3qlzp3DkkUeG2YuWhMMeHl+0sVSLGFouRGdxAFpfpda06lIAoFT2WW+tsNMa3cJ1N97c7LLFPsZRbXpVaG1aX5sVVd6OOB7IO+644+puf/nLXw5/+MMfsn7+/fffH0aNGlV3e//99w+/+c1vWjSmSZMmhT333LPu9qBBg8I999yT9fMnTJgQDjnkkLrb22yzTbjllltWWe7www8PL7/8ct3t22+/PWy55ZZZb2ffffcN77zzTt3tRx55JAwYMCAU0qeffhq++93vJt9fe+21YY01Wq8N/IIFC7Je9qGpM8MVr04pylUq9XVv3y6csdUGyQd3YzEcn++fa7t27ULHjh3ThuiXL8/v52rbtm3o1KlTq6538eLFYdmy/DqixG7snTt3bvKxJUuWhKVL8z9g3PhihpS4zrjuQq83vgbxtchXfB2a6mbf0vXG31v8/TUW3wu5XtxSX3z/xvdxY/FvItcLR7JZb66fEY116NAhtG/fvuDrjeuM626Kz4iVfEYU5m95QZt2YZ97X2pw3wNf2ybpFuQzojo+I2YvWhoOeHRig2Vu3GXTJoP1bdu1bVBHrNaxfWiX50wqtaSUdW41vEdzodZdSa37P2rdldS6PiPq8xnhM6KWPiPyrXXVuatS07bsvVjomjaX93ZK27ZtQsd0x1mT9a5osvlHc1PN5nL8tqlx/3P3LcLqndo3+f9VPCax9z0vrnJMonvblcdaW3KcNU5H23jd9+w9PFl3S9Zbycdvm3pN0v1+yu347Uez5+b8N5F6j3fp1LHk/1/lwn7vSmra/7Hfu5KatnZqWnXpqvyfs5JcQfXUpSlyBf+jLl1J9mgl2aPy+IxId4xj7R5dm1xvU/vcze23frZk6SqzjMfjIo07V5f7sdZqqU2rvj1u9+7dV+kgl4uZM2c2uN2jR48Wj6nxOnIdU+Pl042ppdtp/LM3fi0rXbrisin7b7xu2HfDfk124iik2LE63YHrdKHglkp3ELxc15vuJENLxf800v3H0RLxP6R0B2lbIv6nnMt7uNTrjTtGxVhv3JErxnqjSluvz4iVfEYU5m954aKmLwrxGVE9nxEL2676O+6zWveSTSdE4VX6e7RQ1LorqXVX8v/Y//iM8BlRn88InxHV9hmh1q0elf5eLHRNW/D3dpH2/xofm2lq3J27dA5d0mx/QZpjEsX8/yrdWGrp+G22v59yOn4bx9lY4xPQ6cLVcdrnpprcVPJnRKWs1/HbyvyMcI7nf9S0tUldupL/c1ZyHGUl/+f4jGjMZ4TPiFr4jEh3jCPdRcFNae5YTuc0x0UaU5e2jqoPVw8cOLDB7Y8++iin53/88ccNbheic3Pv3r2ToPK8efPqrrSMV3Rle0Ch8c+Qbkzrrbdexp8lk3iVR/1wdQxq9+rVK9SyGHoWOAKgVsWpc1t6oVBjS5evyPnCpVzWDwAAAFTWMYZsjz+0xlhSHIuoLvOWLAuXjHs/jOi/pmNMAAAAQO2Gq3v27JmEmVNB4U8++SRpi55ten/KlCkNbm+44YYFGdcGG2wQXnnlleT72Eo9bifbdWc7priN+j744IOsx1esnxsAqEyHPTw+q+Wa6/6Tcv/kGcmJrHhCKxfZrr9WZRtYb+2T1QAAAJUs14uDi3HhcTXtx2V7jKFcxuJYRHmKf2fxd5PrsaUoPif+3WmoAwAAQLlfQF7KY0Kzq+h4VD6qPlwdbbzxxmHMmDHJ98uXLw8TJ04M2267bVbPHT9+/CrrKoRBgwbVhaujCRMmZB1gznZMcRuZnpdJHE99G220UdbPBQBqVzbdf+KJ43yC1dmuv1blG1gHAACoNctWrAhzFmcXln5g8oxw+YRJOa2/2Bce07ociyhP8bhQ/DvzNwQAAEA1X0BeThep15qaCFfvuOOOdeHq6MUXX8wqXP3xxx+HqVOnNugE3a9fv4KMaYcddgh33HFHgzEdcMABzT5v0aJFSTg8pVu3bmHYsGFNLjt8+PDQtWvXMH/+/OR2DHMvXrw4dOzYsdntxPHUt9NOOzX7HACgOrSk80823X/iYy05cay7UGED6wAAALXk0SmfhovHvR9mFbHzTrEvPK6lYwzxuXEdpR6LYxHlKV7AEP/Omuv+HjttORkNAAAA5KJtqAG77bZbg9t33313Vs+76667Mq6nJXbdddfQvv3/Dgg+9NBDSXC6OY888khdWDraeeed04al4/31Q9HxefH5zYnjiONJ6dChQ9hll12afR4AUF2df+IJRypDSwPrhTxZDQAAUM4uePndogarG4dxa30/riXHGFIdwAs1c5XjHdUp/l7jBf6ZvlZP0wAAAAAAcr1ou5jHclq6jWLrXiHHowqlJn7SwYMHh0022SS89dZbye133303PPnkk0nAOZ2FCxeG0aNHN7jva1/7WsHG1LNnzyQY/fjjjye3P/vss/CPf/wjHHHEEWmfs2LFinDjjTc2uO/rX/96xu3EMdcPSsfn77PPPqFNm/QHI2+//fYwZ86cutvxderRo0dWPxcAUFudfwrV/Wf0iGFpT3TpLlRchT5ZDQAAQHFV2n5cLscY6osn6wr9M+p0TDHFjvS5vs+LpRh/PwAAALUsddF2PjORZXsspyXbKLbuFXY8qhBqIlwdnXrqqeG0006ru/3LX/4yDB8+PAk5N+XSSy8NU6dOrbu9xx57hM033zzt+u+4445w9tln193ebrvtws0335xxTKecckpduDq67LLLkiDzuuuu2+TyMRg9fvz/gktxPLvvvnvGbey5555JuPzNN99Mbo8bNy7cdNNN4dhjj21y+SlTpiTjSIkh7PjaAQC12/mnNcRgdWttq1ZkCqzX52QbAABQS37yhY3CxePez6t79aihA8Pe661VkguPK30/rjWPMVTSWCid+DebjWz/3u6fPKOsTn6nTnrHCwoAAAConAvI891GsfWowONRLVUz4eoYMt5qq63C2LFjk9sffPBBOOqoo8Ill1yShI9T5s6dGy6//PLw17/+te6+Tp06hVGjRhV8TFtuuWXYd999w7333pvcjt2iY+fqGOzeZptt6pZbtGhRuP7668MVV1zRIPT8ox/9KGMH6tRyZ5xxRjjhhBOSztfRhRdeGBYsWBCOO+645GdL+c9//pMsG1+D+p2xN9tss4L+3AAAFJ/AOgAAwKp2779G+PK6vcOcxaXvotyY/bjqCOPmKtv3Vj5dkWvxxGe2sr0YIpuQcvzdlFOwOopjiWOKJ+S9BwAAACrrom0XhpeHmglXx5BxDCcffPDBYfr06cl9b731Vth///3DkCFDwoABA8Ls2bPDhAkTwueff97gueeff34YNGhQUcYVO2i//fbbyViijz/+OBx55JFhk002CRtssEGYP39+mDhxYpg1a1aD533/+98PO+64Y1bb2GWXXZLu07/73e+S2zFkHbtTx07YW2yxRejSpUt47733knHUF0PV5513XsF+VgCgdmQ64ViIk5G5rMOJRAAAAOpr10bnYnLX0s7kLQnv5tsVWffi1gkpx9B7OQWrU+KY4th0agcAAIDc1Uy4OurTp0/485//HE477bTw/vvv1wWNY3g5fjUWuzqfddZZYb/99ivamLp16xauu+66pDP2uHHj6u6PYetU4Lq+tm3bhhNPPDGcdNJJOW3nlFNOCUuWLEm2tXz58uS+mTNnhqeeeqrJ5WOX7xhG79q1a84/EwBAsU445rP+Sj6RmG1XqmJ1zwIAAKB8LzymNsK7LemKrHvx/y68j8eH8g1ACykDAABA7ampcHUUO0Lfeeed4eqrrw533HFH+PTTT1dZpkOHDmGnnXYKP/jBD8LgwYOLPqZ11lkn3HLLLeH6668Po0ePDlOnTm2y8/b222+fdKDedtttc95GfH78eb70pS+Fq666KowZMyYJlje27rrrhsMOOyx8+9vfDu3atcv7ZwIAKBeVeiIx365UAABQrRcVRmamoZIU+8JjyjeMW8jwbku7IgsGr5xOOV5435rHWUaPGBZWL/I00U1dtOFzBwAAAAqj5sLVUZcuXcIZZ5yRdIt++eWXw5QpU8Inn3ySdJHu27dv0rW5d+/eOa3zwAMPTL7y1b59+3DCCSeE448/PowfPz5MmjQpTJ8+PXTu3DnpuL3lllsmIeyW2m677cJNN90UPvzww6Rb97Rp08LChQvD2muvHQYOHBiGDRuWBLEBAFrrhGN8blxHsdZfiScSW9KVCgAAKikw/cDkGeHyCZNqYmYaoHKUIoxLccX/N+KF99nOENbSkHIMVlfKcSgAAABgVTUZrq4faI5h4/hVLmKwefjw4clXMfXr1y/5AgAo5QnHVDAiU0fpWjyh2dKuVM0F1gEAoFJnYanUmWmofsW+8JjyDuPmqqXh3UxdkXUvTi/+vyHwDAAAAGTDkToAAEp2wjHbKb1zXX8tn0jMJrAOAACVPAtLpc1MQ20o9oXHlEa5hnF1RSZb8RhZoWV7PA8AAAAqmXA1AAAVccKxXE9otpZMXanqc4ILAIBKnoUFKlmxLzwGyjOkXIwAc6EUo/lA6oKQ+JkHAAAA1Uq4GgAAKoCuVAAAVLtRQweGvZsIatXyzDRUnlq/MJj8pQvoFiK4W8x11wr/D/1PvIgqdumPF5O4MAQAAIBqJVwNAEBNyPaEoY5hAADQ+rOwqMOBWlfM8K5gcG2I/5fGrtKtMYNE3Ebs0u9iEgAAAKqVcDUAADUh2xOJxZzadOnyFVlND61zFAAA1cQsLADUUkg5Pjeuo7XFLtLxmFbsKt0aAWsAAACoZsLVAADQClOb3j95hpNbAABQIOkuSHShIlDt4d3mgrvFXHetaElIOXXRfiGPKeUiNguIx7Syubg/F/H/Vx3QqVTZNrxoLWZsAQCAyuAICQAAVaelHYYKPbVpPICvaxAAABSOgBdQi+HdbIK7xVx3Lck3pFwOocm4/UId04JKV44NL4o5cyIAAFA4wtUAAFSdcpsGNZ6Ia8k4dI4CAACA6pJPeDfb4G4x111LhJQzy3a2iFzeW7l2GPa+pbn3U7kcH26NmRMBAIDCEq4GAKAq5XIisZynNtU5CgCAWteSmWlcqAjUanhXMJhiy/ZYWrZdevPpMKwDMMVseFFMhZ45EQAAKDzhagAAqlY5n0gcPWJYWD2LsenAAwBArct3ZhoXKgJAZXTpzbfDsA7AAAAAFItwNQAAlEAMVpdr8BsAACp5ZpoUFyoCQOlnkcimS29LOgzrAEwxGl4UWjnPnAgAADRNuBoAANIc8M6GwAYAALSOcp6ZBgCqWb6zSEC50fACAADIlnA1AAA0IZdOIqOGDgx7r7dWi4PaAAAAAFDps0gUoktvug7DOgBTLTIdM3Y8GQAASk+4GgAAWujyCZOSL6B1PDrl03DBy+8m3//kCxuF3fuv4aWvAEuXr8jqJHyKmQEAAABqdxYJHYapdi29AAEAACgu4WoAAGpeDPB179DOtKZQAZatWBEurjcNcfz+y+v2Du3atCn10Mjg/skzcp4+On4ux2mnY3c0AAAAAAAAgNYiXA0AQM2LXXdigC/X4F++YmAwBrqB3M1ZvDTMqjdtavw+3tdanbPKTSV0g45jzOfzNS4fnxennW7tMQOQ//87pjAHAHKtEVpaP5RD/WH2JYrZ3MPxZAAAaH0SHQAAEELSGTUG+LINKT4weUa4fMKknF+7VCdWQUGgpYHpfD6HStENOv4s+Z48jM+Lz6/V8DxAOV18k88sBAAAKYc9PL5oL0Yx150tsy9RrOYejicDAEBpCFcDAECqOG7bJusA3+GD+oVDNlonp9BKpIsNUMrgmm7QANUvn/9LmgsD5TsLAQBArbC/TaGbe6Q4ngwAAKUhXA0AAK0Qxgaqq3tnMbRWcK0cukGPHjEsrN7E9uNUzuXQcQygUuX7f0lzYaCWzEJgCnMAqD1xvzrWAMWoH1q67mrf36a8OZ4MAACVQ7gaAACAihYDuek8MHlGuHzCpIqYyrclwbVKE4PVTjYDlXYBTiV0jGvJ/yXFCAOZwhwAalOsmeJ+dT4XfTVXP7Rk3QAAAJAt4WoAAAAqWqE7HVfiVL6jhg4Me6cJg1d6N+hM4flKCjwC5ef+yTNyCuWU6uKbcpVuFoL6fD4DQO2KNVPcr85lJqls64d8111olb6/DQAAQHrC1QAAAFCmU/mWe3Atm46v2YSjM8nmRLXAI5DP51eu3Q4r8eKbTP+XtDQMZBYCAKA5sWYq1n51MddN+WuN4xEAAEBtE64GAACgYsQgcQzS1srUv6UIrmVzgjJ6YPKMcPmESaEcVGrgESpFtp8LldStOP48+fxfUi4X3+RCCBoAoPVkG+gth5o51zq/XMad6ww0AAAA+RCuBgAAoGLEE3hnDN8gr5Noo4YODHuvt1aTj9XaVL7pTvaWOjDdkvB8JQYeoZSKeSGFbvLV9/+Drn8AANnJ9thCqWvmfAPKpR53PjPQAAAA5EO4GgAAgIoST+DFDsXV1kW1NZUySB5PxMbfR6HD81Ct8ukm15xiX0hRqd3kR48YlnR5ruWLb2rpZwUAKKVS1swtCSiXutbPdwaa5o5HAAAANGbvAQAAgIoTT+CVukNxoQOPtdAVNNXhKtMJ2GzD87UWeKS6FLNrdLmoxG7yMVhdSeMFAKC0WjL7Uilr5pYElCu11s/meAQAAEB9wtUAAACQY9i5kgKPLT3Zm41RQweGvbOYEjjbDuLlEJ6HYl1IUUmfH7TOe6ZUsyu05P8HXf8AAMy+VM4z0DRmRjMAACBXwtUAAADQhGrpihwDe7E7U65T/hY6MN0asun+XU7jpfzdP3lG3tNlV6NMnwu11E2+0BffpLroxc79lfD/g65/AAC5z75U7jVzpoByOY87MgMNAABQDMLVAAAAUIYK2RU0l5O9lRxAzuZkb6lCjFRm9+FaCFZX4oUUhegcnc3FGOkUOlgS32PxvRY/p1v7Nc71/4dKey8AALSGaph9SUAZAACgIeFqAAAAal4MisXQbbmEKIvRFbQaTvZWeoiRyhLDpuXymZBLCDoXpQ7JZhOCzlU+naPLQXyvxdeiFJ/T/n8AAKDUst03aMlFkgAAALkQrgYAAKDmxWBZDDPn06W2GgOP1R6IL2WIEaq9a3S2wYdKCUGX28U3AABUl2zCwrnsDxR7Fpdc15HN2O+fPKMmZg0CAAAqi3A1AAAAhBD2WW+tpJtxLl1UKzXwWOuBeMjX6BHDkumyC6EWPj8Oe3h8qBQxQB1/J6118U0Mo1TS6wMAQHFkUxOmZreKxy3KJaScbS3b3NhjGNx+PQAAUI6EqwEAACC1k9y2jW7GVRiIF2KkUGKwWsfz6pMKfKQLu7v4BgCAUoph6RhAjvu/6WrWcg0pNzf2uD/fkjGnu0gSAACgpexpAAAAABVLIB7KQww0xGBDOYU5MnWOzrWLeGt81rTm9OwAAFRWzRyfE4PI6WrSloSUmwsot7TWb27sxbpIEgAAoCWEqwEAAACAlh1kbNsmCTbk0y0v2xB0LrIJTJebbKdWBwCg9mrmYskmoNza4x49Ylgya1A11vwAAEDlEK4GAAAAak423V2dqK1eccrs2DktEx2Ac7fPemsl030399rW5+8MAIBakm3NHPdHWnrxXTYh5Wzr8Vxq/ZaOPY652LPGAAAANEe4GgAAAKg52ZzoTXXwiieRKd8QdK7BgPsnzyirTnHVJr7+ghDNa+nU6oWa4h0AgOqtmQsdUlbrAwAAtcSRdQAAAIAmxNBjDOHG7lymGm59+YSgmwvEx7C2YDXloDWmVs9mincAAGgN6WYGMmMQAABQroSrAQAAgKrWkg6x8Tmxc3ItduLNtWt0LprrMJ1vCLq5QHz8efINsuoATKHlMrV6PrKd4h0AgMqQKYhc7iHlbGaPAgAAKCfC1QAAAEBVa40OsdUWmH5g8oxw+YRJRRtHcx2mWxKCLkYgXgdgisXU6gAAZEtAGQAAoPUIVwMAAABVL9sOsbHbV6WdsC6XwHQhO0y3ptEjhoXVmwli6wAMAABQ/NmjzBgEAACUC+FqAAAAoCYUq0NstuHmfDQX6r1/8oyK7cida4fpdCHolgbi4zqL8b4AAAAoRUC51CHlfGePMmMQAABQToSrAQAAADKI4d1SdYNOnVyOnbebCnVXarA6H0LQAABArcg3oFwuIeVsZ4+qz4xBAABAORGuBgAAAMigJV2RWyqeRI8n0+NJ6cYnxuNJ6tYIVo8aOjDs3US4O1ct7TANAABQS/IJKJdTSLlYs0cBAAC0BuFqAAAAgDIWA9TxZHohT0pnG5gul5Pyheo2nqkLOQAAQLkRUAYAACgN4WoAAACAemHiOIVya3SELobRI4aF1ZsJYZdTYLpYIWgdsgEAAAAAAMiXcDUAAABA6kBJ2zbhjOEbhEvGvZ9zwDrbbtDNicHifMPBMVhdSdMuC0EDAAAAAABQboSrAQAAAOrZZ721woj+a4a5S5Zm/bqUUzfoWtOSbuPxefH5AAAAAAAAkOLsEQAAAEAjMShdTh2gYzfrbO6rxRB0vt3G4zrj84TiAQAAAAAAqE+4GgAAAKDMHfbw+FDpihmC1m0cAAAAAACAQhGuBgAAAKBVFDMEXW7dxgEAAAAAAKhMwtUAAAAAZSSGiWO35ly6O0fxOfG55U4IGgAAAAAAgHLWttQDAAAAAKBh+PiM4RskYelsxWXjc7Lp8AwAAAAAAACkV/7tjAAAAABqzD7rrRVG9F8zzF2yNKvlY8dqwWoAAAAAAABoOeFqAAAAgDIUw9K9OnUo9TAAAAAAAACgprQt9QAAAAAAAAAAAAAAAMqBcDUAAAAAAAAAAAAAgHA1AAAAAAAAAAAAAMBKOlcDAAAAAAAAAAAAAAhXAwAAAAAAAAAAAACspHM1AAAAAAAAAAAAAIBwNQAAAAAAAAAAAADASjpXAwAAAAAAAAAAAAAIVwMAAAAAAAAAAAAArKRzNQAAAAAAAAAAAACAcDUAAAAAAAAAAAAAwEo6VwMAAAAAAAAAAAAAhBDa1+qr8NFHH4WJEyeGadOmhQULFoQ+ffqE9ddfP2y55ZahTZs2rT6eOI633norTJkyJcydOze0bds29OzZM/Tv3z8MGzYsdO3atdXHBAAAAAAAAAAAAAC1pObC1WPGjAlXX3118u/y5ctXeTyGmQ877LDwrW99K7Rr165o41i8eHF4+umnw2OPPRaef/75MHXq1LTLxnHsvPPO4Zvf/GbYYYcdctrOWWedFe688868xjho0KBwzz335PVcAAAAAAAAAAAAAKg0NRWuvuyyy8J1113XZKg6JXaOvuSSS8Kjjz4arrjiiqSjdaGNGzcuHH/88WHOnDlZLb9s2bLwxBNPJF8jR44M5557bujWrVvBxwUAAAAAAAAAAAAAtaxmwtVXXXVVuPbaaxvc16tXrzBkyJDQtWvX8N5774V33nmn7rGxY8eGE088Mdx6663J44U0a9asJoPVPXr0CJtssklYc801Q5s2bZKg9+uvv56Eq1NiF+rY5fpPf/pT6NSpU0HHBQAAAAAAAAAAAAC1rCbC1U899VQSrk6JweVRo0aF4447rkFAecyYMeGMM84I06ZNS27HYPPPf/7z8Jvf/KZoY4sB7wMOOCB89atfTYLe7dq1a/B4HEvsoP2Pf/yjwTgvvvjicM455+S8vdiRO1sdOnTIef0AAAAAAAAAAAAAUKmqPly9YsWKcMkllyT/ppx99tnh2GOPXWXZ7bbbLtxyyy1h5MiRYe7cucl9d911VxLC3myzzQo6rrXXXjucfPLJ4aCDDgodO3ZMu1yfPn3CBRdcEAYOHBh++9vf1t3/f//3f+Hoo49O7s9F//79WzRuAAAAAAAAAAAAAKhWbUOVe+ihh8Kbb75Zd3v48OHhmGOOSbv8gAEDwg9+8IO62zGUXb/rdSEMGzYsPPzww+Hwww/PGKyu78QTTwxf+MIX6m4vXbo0PPDAAwUdFwAAAAAAAAAAAADUsqoPV99zzz0NbseO1W3atMn4nIMPPjisttpqdbeffPLJuk7WhdC7d+/QuXPnnJ936KGHNrj9n//8p2BjAgAAAAAAAAAAAIBaV9Xh6sWLF4dnnnmm7nbXrl3DHnvs0ezzOnXqFEaMGFF3e8mSJeGpp54Kpbbppps2uD19+vSSjQUAAAAAAAAAAAAAqk1Vh6vHjRsX5s+fX3d7yy23DB07dszqudtss02D288++2wotXbt2jW4vXTp0pKNBQAAAAAAAAAAAACqTVWHq99+++0Gt4cOHZr1c4cNG9bg9jvvvBNKbfLkyQ1ur7HGGiUbCwAAAAAAAAAAAABUm/ahir3//vsNbg8YMCDr5/bv3z/jukrhkUceaXB7iy22yHkd559/fnj55ZfDhx9+GObNmxe6d+8eevfunaxr++23D3vvvXfo1q1bAUcNAAAAAAAAAAAAAJWhqjtXf/DBBw1u9+3bN+vndurUKfTq1avu9pw5c8KsWbNCqXz66afhgQceaHDfbrvtlvN6br755vDqq68mP8uSJUuSf999993wr3/9K/zkJz9J1nndddeF5cuXF3D0AAAAAAAAAAAAAFD+qjpcPXfu3Aa3Y4fmXDRePnZ6LpWLLroozJ8/v+72kCFDwrbbblvw7cyePTtceuml4dvf/nb47LPPCr5+AAAAAAAAAAAAAChX7UMVqx9GTnWjzkXnzp0b3P78889DKdx3331JZ+mUNm3ahLPPPjundWy88cbhy1/+chLKHjhwYOjevXtYsGBB+PDDD8MLL7wQ7rzzzgZh6ueeey5873vfC9dff31o3z7/t8nHH3+c8fFSdgMHAIB8qXMBAKh0aloAAMqBuhQAgHJU1eHqGB5uSbi6Y8eOGdfXGt5+++3w05/+tMF9Rx55ZNZdq3feeedw1FFHhS222KLJxzfddNOw2267JUHqX/7yl+Gf//xn3WMxdH3NNdeE0047Le/x77rrrhkf79ChQ9hss83yXj8AAJSCOhcAgEqnpgUAoByoSwEAqMlw9aRJk1bpIF1o6623XujWrVuzy8WOz7lovPyKFStCa/rkk0/CiSee2OD1i52nzzzzzKzXse+++2a1XOxkfdFFFyUB9L/97W91999www3h6KOPDr169cpx9AAAAAAAAAAAAABQWYoerj7rrLPCyy+/XNRtxADwjjvuuMr9Xbp0aXB74cKFOa130aJFDW537do1tJZ58+aFE044IUydOrXuvgEDBoQ//OEPOXfgzsU555wTnnnmmbrtxmD3fffdl3TLzseTTz6Z8fFZs2aFn/3sZ3mtGwAASkWdCwBApVPTAgBQDtSlAADUZLi6lBqHqxuHpZvTePlsumMXwuLFi8PJJ58cXn311br71lprrSREHv8tpo4dO4ajjjoq6WKd8txzz+Udru7bt2/Gxzt06JDXegEAoJTUuQAAVDo1LQAA5UBdCgBAOWobqliPHj1W6ZKci5kzZza43b1791Bsy5YtC6effnp44YUX6u7r2bNn+POf/5x0rm4NjbuAv/32262yXQAAAAAAAAAAAACo6s7VV155Zc4do3OVrpvzeuut1+D2xx9/nPU645jrh6tjULtXr16hmFasWBHOOeec8PDDD9fd17Vr13DdddeFwYMHh9ay7rrrZgyZAwAAAAAAAAAAAEA1Knq4Ol3wuTVssMEGDW5/8MEHWT93ypQpDW5vuOGGodguuOCCcMcdd9Td7tixY7j66qvD8OHDQ2vq1KlTg9sLFy5s1e0DAAAAAAAAAAAAQCm0DVVs0KBBDW6PHz8+6+dOmDChwe2NNtooFNMVV1wRbrrpprrb7dq1C5dddlnYcccdQ2ubNWtWg9urr756q48BAAAAAAAAAAAAAFpbVYerY8fnrl271t1+5ZVXwuLFi7N67osvvtjg9k477RSK5S9/+Uu45ppr6m63adMm6WK9xx57FG2bmcTXqb611167JOMAAAAAAAAAAAAAgNZU1eHqjh07NghFz58/PzzyyCPNPm/RokXhoYceqrvdoUOHsMsuuxRljP/4xz/Cr3/96wb3nXvuueGAAw4IpXL//fc3uL3tttuWbCwAAAAAAAAAAAAA0FqqOlwdfe1rX2tw+8YbbwwrVqzI+Jzbb789zJkzp+72rrvuGnr06FHwsT388MNJkLr+eE4//fRw5JFHhlKZMGFCuO+++xrc9+Uvf7lk4wEAAAAAAAAAAACA1lL14eo999wzDB48uO72uHHjwk033ZR2+SlTpoTLLrus7nabNm3Cqaee2ux2dtttt2Q7qa8XXngh4/LPP/98EqRetmxZ3X3HH398OPHEE0Oh/P3vfw+ff/551su/88474ZRTTgnLly+vu2/48OFhhx12KNiYAAAAAAAAAAAAAKBctQ9VLoajzzjjjHDCCSfUdYi+8MILw4IFC8Jxxx0XOnXqVLfsf/7zn2TZuXPn1t339a9/PWy22WYFHdOrr74aTj755LB48eK6+3bfffdw2GGHJeHuXPTv3z/tY7///e/DpZdeGg444IDw1a9+NQwZMiS0a9duleU+++yzMHr06HDttdeG+fPn193fsWPH8NOf/jSn8QAAAAAAAAAAAABApar6cHW0yy67JN2nf/e73yW3Y8g6dqe+8cYbwxZbbBG6dOkS3nvvvfD22283eF4MVZ933nkFH89jjz3WIMQcPfroo8lXrt58882Mj8+aNSvccMMNyVfnzp3DJptsEtZYY43QvXv3sHDhwvDhhx+GN954o0EH7SiGsC+66KIwdOjQnMcEAAAAAAAAAAAAAJWoJsLV0SmnnBKWLFkSrrvuurB8+fLkvpkzZ4annnqqyeW32mqrcMUVV4SuXbuGahHD1BMmTGh2uXXWWSdccsklYZtttmmVcQEAAAAAAAAAAABAOWgbakSbNm3CD37wg6Rb9fbbb5/cbsq6664bfvjDH4Zbbrkl9OnTJ1Syk046Key+++6hV69ezS4bX49NN900/PznPw/333+/YDUAAAAAAAAAAAAANadmOlenbLfdduGmm24KH374YZg4cWKYNm1a0tF57bXXDgMHDgzDhg1LG7zO5LHHHst62e9973vJV7EdcsghyVf08ccfh/feey989NFHYfbs2WHRokWhU6dOYbXVVktC5PHn7tmzZ9HHBAAAAAAAAAAAAADlqubC1Sn9+vVLvmpF3759ky8AAAAAAAAAAAAAoGlt09wPAAAAAAAAAAAAAFBTarZzNeVh2bJldd/PmjWrpGMBAKC8rb766qFdu3ahEqhzAQCo9DpXTQsAQDnUtOpSAABKUZcKV1NSc+bMqfv+7LPPLulYAAAob9dee+3/x959gMlVlY0DP+mdEEIJIaH3AAlKl6JA6F3Q0KQJSBEpEcUP+NMEEZAiIKKCgPChYJAWOgjSQSChtwAhARJKQhJI2ST7f87db5bdze7szOz0+f2eZ5+dO3Pnzpm7d++898x73hMGDhwYKoE4FwCASo9zxbQAAJRDTCsuBQCgFHFp57xsBQAAAAAAAAAAAACgwnWqr6+vL3UjqF3z5s0LEydOTG4vtthiRZn+curUqWGfffZJbt9yyy1h6aWXLvhrUt0cUzieKFfOT1Tb8VSu06WXS5xbLn8nqofjCccT5cr5iWo7nso1zhXTUg3K4X+c6uF4wvFEuar2mFZcSjUoh/9TqofjCccU5WxqiT/z8hmXds3LViBH3bt3D6uuumpR919dXV3yEw0YMKAsp9yksjimcDxRrpyfcDzVVpwb+b/H8US5cn7C8US5cn5qm5iWauB/HMcT5cr5CcdT5sSlVAPnfRxPlDPnKBxPrevcxv0AAAAAAAAAAAAAADVFcjUAAAAAAAAAAAAAgORqAAAAAAAAAAAAAIAGKlcDAAAAAAAAAAAAAEiuBgAAAAAAAAAAAABooHI1AAAAAAAAAAAAAIDkagAAAAAAAAAAAACABp3q6+vr/+82AAAAAAAAAAAAAEDN6lzqBgAAAAAAAAAAAAAAlAPJ1QAAAAAAAAAAAAAAkqsBAAAAAAAAAAAAABqoXA0AAAAAAAAAAAAAILkaAAAAAAAAAAAAAKCBytUAAAAAAAAAAAAAAJKrAQAAAAAAAAAAAAAaqFwNAAAAAAAAAAAAACC5GgAAAAAAAAAAAACggcrVAAAAAAAAAAAAAACSqwEAAAAAAAAAAAAAGqhcDQAAAAAAAAAAAAAguRoAAAAAAAAAAAAAoIHK1QAAAAAAAAAAAAAAkqsBAAAAAAAAAAAAABqoXA0AAAAAAAAAAAAAEELoai8AUCvWWGONNh/baKONwg033FDU9gAAQD6IcwEAqAbiWgAAyoG4FIBI5WoAAAAAAAAAAAAAAJWrAShnzzzzTHj22WfbfHzPPfcMQ4YMKWqbKtHrr78eHnzwwTYf33bbbcNaa61V1DYBANQycW5+iHMBAEpLXJsf4loAgI4Rl+aHuBSgua4tlgGgbMTE6ssvv7zNxzfaaCPJ1RleBKXbj8stt5zkagCAIhLn5oc4FwCgtMS1+SGuBQDoGHFpfohLAZrr3GIZAAAAAAAAAAAAAKAmSa4GAAAAAAAAAAAAAJBcDQAAAAAAAAAAAADQQOVqAAAAAAAAAAAAAADJ1QAAAAAAAAAAAAAADbr+328AoBUvv/xyeP/998PUqVNDp06dwhJLLBHWWWedsOqqq+Z1f33xxRfhlVdeSX5Pnz49zJkzJyy22GJhwIABYaWVVgprrLFG8vrlqq6uLkycODFMmTIl2VczZsxI3sP8+fND7969Q58+fUL//v2T/bbiiiuGzp1NngEAUEri3MyIcwEAypu4NjPiWgCAwhKXZkZcClSSTvX19fWlbgQARGPGjAmnnHJK3nbG9ddfHzbeeOPG5Zig3JaNNtoo3HDDDcntWbNmhWuuuSb861//CpMnT251/SFDhoRjjjkm7LHHHjknCn/88cdJG//973+HCRMmpF03JllvscUW4bDDDgtrrrlm2nWfeeaZ8KMf/Sjky3nnnRf22muvZvfFhPPHH388vPjii+H1118PH3zwQZJInYlevXqFDTfcMOy5555h2223Dd27d89bWwEAypE4t23iXACAyiGubZu4FgCgeMSlbROXAuSPytUA0CIxefTo0Un15XQmTZqUJII/+uij4YILLsgqQTgmb//6178Od9xxR8YJydOmTUvWv/POO8N2220XzjzzzOTCqFT+9Kc/hVtvvTWn586ePTs89thjyc8KK6yQ7IuYbA0AQOGIczMjzgUAKG/i2syIawEACktcmhlxKVDJciu1CQBV6O67704qQ7eXWN3UvffeG84+++yM13/11VeTatdxNG2midVNxQkn7rvvvvD9738/vPbaa6HSxYrXBx54YBg7dmypmwIAULXEucUnzgUAyD9xbfGJawEAFiUuLT5xKVAKkqsBIITw9ttvh5NPPjnU1dVlvT/+8Y9/hGeffbbd9d59991w8MEHhw8//LDD+3zy5MnhkEMOCRMnTgyVLiaM//KXvwyvv/56qZsCAFB1xLmlI84FAMgfcW3piGsBAL4hLi0dcSlQbJKrASCEMG3atJwqSadcf/31aR+fPn16OPzww8OMGTPytr/jNo866qgwe/bsUOnmzp0bLr300lI3AwCg6ohzS0ucCwCQH+La0hLXAgA0EJeWlrgUKKauRX01AEhjlVVWCfvvv3/j8vjx48PLL7/c5vrbbrttWGaZZdp8PN1j6WyyySbhRz/6UVhjjTXCwoULw3/+859w2WWXJcnMbfn3v/8d5syZE3r27Nnq43/84x+TatNt6dy5c9hll13CTjvtFFZdddXQo0eP8Omnnyavfe2117b52u+880644YYbwhFHHNHsfTfdjxMmTAhPPfVUm6+96aabhpVXXjnt3yXdY8OHDw9rrbVWGDJkSFh22WVDnz59kv0Q31PcJ59//nl46623wkMPPRQeeeSRNrcVH3v//ffDiiuu2OY6AACVSJwrzhXnAgDVQFwrrhXXAgDlQFwqLhWXAsXQqT7WzAeAMvT73/8+XH755WmrRW+88cYZby8mS7fnoIMOCr/61a8Wuf+NN94Ie++9d6irq2vzuTfffHNYf/31F7l/6tSpSSJ4HEXZml69eoWrrroqSepuzSeffBL222+/NpOzF1988SRxuW/fvq0+PmbMmHDKKae02e7zzjsv7LXXXiEbzz//fJLEPXTo0Kye9/e//z2cfvrpbT5+5plnhlGjRmW1TQCASiPObSDOBQCobOLaBuJaAIDSEpc2EJcC5FfnPG8PACrWsGHDwi9/+ctWH1tzzTXDd77znbTPf++991q9//77728zsTo6/vjj20ysjgYNGpQ2OTpWtX7iiSdCMW2wwQZZJ1ZHe+65Z9rH//vf/3agVQAAtEacmzlxLgBA+RLXZk5cCwBQOOLSzIlLgUrWtdQNAIBy8eMf/zh07tz2uKOYYP3vf/+7zcdnzJjR6v2PP/54m8/p1q1b2Geffdpt26abbpr28Zhcvf3224dSmDlzZnjsscfCiy++mCSYf/jhh8l9s2fPDnPmzAnZTJIRR9MCAJBf4tzciHMBAMqLuDY34loAgPwSl+ZGXApUGsnVABCncujcOWy11VZp98WAAQPSPj5r1qxW73/ppZfafE5dXV341re+1eG/wSuvvBKKbeLEieHSSy8N9913X/I+8qGtBHUAAHIjzs2eOBcAoPyIa7MnrgUAyD9xafbEpUClklwNACGEoUOHhj59+qTdFz179kz7eGsVmhcsWBC+/PLLgu/jzz//PBTT2LFjw8knn5y3pOr2EtQBAMiNODc74lwAgPIkrs2OuBYAoDDEpdkRlwKVTHI1AIQQFl988fY/NLtm/7E5ffr0sHDhwoLv4y+++CIUy2OPPRZOPPHEVpPJO6oQ2wQAqGXi3MyJcwEAype4NnPiWgCAwhGXZk5cClS6zqVuAACUgx49emQ0xU+5mjdvXtFe54wzzpAEDQBQIcS5mRHnAgCUN3FtZsS1AACFJS7NjLgUqAYqVwNAgUeuxqTsYlSvLoann346TJ48Oe06W221Vdh3333D2muvHZZYYonQrVu3Zo+vscYaBW4lAACFJs4V5wIAVANxrbgWAKAciEvFpUD5kVwNAAXUpUuX0L9//zBt2rRWH19yySXDE088UTF/g8cffzzt4/vss08455xz2nx85syZBWgVAADFJs5tTpwLAFCZxLXNiWsBAEpDXNqcuBQoB51L3QAAaEunTp2qYuest956bT722WefhTfffLNi9uMnn3yS9vH99tsv7eMvvvhi3toCAFCpxLnltx/FuQAA2RPX5oe4FgCgfOKpUpJX8A15BUA5kFwNQNnq2bNn2senT58eKsHmm2+e9vErrrgi523HxOwbb7yxaPtx1qxZaR+fO3dum4/V19eHP//5zxm/FgBAtRLntk+cCwBQ/sS17RPXAgAUnri0feJSgOxJrgagbC222GJpH7/jjjvCwoULQ7nbbrvtQrdu3dp8/L777gu/+c1vQl1dXUbbi8nQt912WzjooIPCbrvtFu69994O7cexY8eGefPmZfTa7W1rzJgxrd4f/06//vWvwzPPPJPR6wAAVDNxbuvEuQAAlUVc2zpxLQBAcYlLWycuBeiYrh18PgAUzEorrZT28QcffDBsv/32Yfjw4aFfv37NpvvZcMMNw4477lgWf51BgwaFUaNGhRtuuKHNda699trw0EMPhT333DN8+9vfDsstt1wywvarr74KX375ZZg4cWJ47bXXwssvvxxeeOGFMH/+/Lztx7jNbbbZJmywwQahf//+oXPnb8ZerbbaamHfffdtXF5llVXSbusf//hHUt36hz/8YRg6dGiSVD1+/Phw3XXXhXHjxmXcZgCAaibOFecCAFQDca24FgCgHIhLxaUAhSC5GoCyNWzYsNC9e/e0VZVj0nH8aU25JFdHRx99dLj//vvDlClT2lwnvo9LL7007689ePDgsMwyy6R97alTpyYVrFv67ne/2yy5Oi5ffvnlaV8vbqe1bQEA0ECcmx/iXACA0hLX5oe4FgCgY8Sl+SEuBWjum9KUAFBmevfuHXbYYYdQDZZYYonwpz/9KfTt27ckr7/XXnvlZTvrrrtu2GyzzXJ+/t57752XdgAAVDJxbv6IcwEASkdcmz/iWgCA3IlL80dcCvANydUAlLXjjz8+9O/fP1SDNdZYI1x77bVhyJAhRX/tQw89NG+ve+aZZ4YBAwZk/bz1118/nHbaaXlpAwBApRPn5oc4FwCgtMS1+SGuBQDoGHFpfohLAb4huRqAsrbccsuFa665JqywwgqhGqy33nrh9ttvD/vss0/o1q1bh7bVo0ePsP3224ejjjqq3XUXW2yxJLF7nXXWCR21/PLLhz//+c9h0KBBGT9n8803T57Ts2fPDr8+AEA1EOe2TZwLAFA5xLVtE9cCABSPuLRt4lKA3HTN8XkAUDQxIfjuu+8ODz30UHjkkUfCa6+9FqZOnRq++uqrUFdXV3F/ib59+4ZzzjknHHfcceHmm28ODz74YHj77bfDwoUL0z6vU6dOSWLzJptskvxsscUWoV+/fhm/bnzurbfeGh5//PFw//33h1dffTV89NFHYdasWVnvx/g3ue2228If//jH8I9//CN8/fXXra634oorhh//+Mdh7733TtoPAEDzmEqcK84FAKh04toG+m8BAEpLXNpAXAqQH53q6+vr87QtACBHMcH5lVdeSZLGZ86cGWbMmBG6du0a+vTpExZffPEkMXrllVcOvXv3Lrt9PG/evPDiiy+GCRMmhC+//DJ06dIlLLXUUmHYsGFhtdVWK3XzAAAoIXEuAADVQFwLAEA5EJcCFI/kagAAAAAAAAAAAACAEEJnewEAAAAAAAAAAAAAQHI1AAAAAAAAAAAAAEBC5WoAAAAAAAAAAAAAAMnVAAAAAAAAAAAAAAANVK4GAAAAAAAAAAAAAJBcDQAAAAAAAAAAAADQQOVqAAAAAAAAAAAAAADJ1QAAAAAAAAAAAAAADVSuBgAAAAAAAAAAAACQXA0AAAAAAAAAAAAA0EDlagAAAAAAAAAAAAAAydUAAAAAAAAAAAAAAA1UrgYAAAAAAAAAAAAACCF0tRcAoHRmzpwZPvzwwzBp0qTwxRdfhK+//jrMmTMn9O7dO/Tt2zcstdRSYdiwYWHJJZf0ZwIAoCLEePb9998PU6ZMCVOnTg1fffVVcl8U49xevXqFpZdeOqy88sphueWWC507G/sPAAAAAABA+ZBcDQBF9MYbb4Qnn3wyjBs3Lrz88sth8uTJGT1v8ODBYccddww/+MEPwoorrljwdgIAQKZiIvUTTzwRnn/++fDaa6+FiRMnhoULF2b03Jhsvdlmm4Vtttkm7LLLLqF79+52PAAAZWvs2LHhhBNOaHe966+/Pmy88cZFaRMAAACQf53q6+vrC7BdAKCJxx57LJx66qlJ9b6O6NSpU9hvv/3CSSedFPr06WMfAwBQcscdd1y47777OrydZZddNolzd91117y0CwAA8unLL78MO+20U/jss8/aXVdyNQAAuRgzZkw45ZRT8rrzzjjjjLDvvvv6gwBkybyrAFAEsUJ1RxOrozgm6sYbbwx77bVXMsU6AABUi48//jiMHj06/O53vyt1UwAAYBG/+c1vMkqsBgAAACqf5GoAqEBx6vWDDz44zJw5s9RNAQCAvPrjH/8Y7rrrLnsVAICy8dRTTyVVBAEAAIDaILkaACrUu+++Gy677LJSNwMAAPLu3HPPDfPnz7dnAQAouTlz5oTTTz+91M0AAAAAiqhrMV8MAPhGr169wiabbBK+973vhdVWWy0ss8wyYeHChUlV6nvvvTfcfvvtoa6uLu0uu+mmm8Jhhx0WBg0aZNcCAFByq666athss83CWmutldzu379/6NOnT5g9e3aYOHFiePzxx8Ott94aZsyYkXY7n3/+eXj66afD5ptvXrS2AwBAay699NIklgUAAABqh+RqACiymER94IEHhlGjRoV+/fot8vjQoUPDFltsEfbZZ59wxBFHhC+//LLNbcVqfg899FDYf//9C9xqAABo3dJLLx2OOuqosPfee4chQ4a0uZtinPud73wn/PjHP05+XnvttbS79OWXX5ZcDQBASb366qvhuuuu81cAAKDktt122yTXIFux0BsA2ZNcDQBF0rt373D00UeHgw8+OHTr1q3d9UeMGBF+85vfJIkq6TzzzDOSqwEAKJlTTz01q/UHDhwYfve734Udd9wx1NfXt7ne1KlT89A6AADITSxsEWPdBQsWNLu/S5cuYfXVVw+vv/66XQsAQNH86Ec/ChtvvLE9DlAknYv1QgBQy4YPHx7uvffecPjhh2eUWJ2y9dZbJx316Ug6AQCg0qy00kph1VVXLXUzAACgTddcc02rs60ccsghYc0117TnAAAAoIpJrgaAIlh77bVzmqIn+va3v5328WnTpuXYKgAAKO3MLukMGjSoaG0BAICmJk6cGK644opFdsoKK6wQfvrTn9pZAAAAUOUkVwNAmevXr1/ax3v06FG0tgAAQL6mWH///ffTrrPBBhvY2QAAlMRpp50W5syZs8j9Z511VujZs2dJ2gQAAAAUj+RqAChzU6ZMSft4rJYCAACV5Kabbgpffvllm4+vvvrq7c7gAgAAhXDLLbeEp59+epH799lnn7DJJpvY6QAAAFADupa6AQBA2xYsWNBqR35Tkk4AAKgU06dPD9dee224+uqr21yne/fu4ZxzzilquwAAIPrss8/CBRdcsMjOWGqppcLJJ59sJwEAUDI333xz0q86YcKEpJ+1rq4uLLbYYsnPiiuuGNZff/2w8cYbhxEjRvgrAeSB5GoAKGP3339/2srVXbt2DTvssENR2wQAAOk8+uijyU/K/Pnzw6xZs8L7778f3njjjWQAYVsWX3zx8Lvf/S4MHz7cTgYAoOjOOuusVmdYOf3005OkFQAAKJWxY8cuct/nn3+e/Lz33nvhkUceSe5ba621wqGHHhp22223ErQSoHpIrgaAMhVHm/76179Ou84ee+wRBg0aVLQ2AQBAe8aPHx9uvPHGrHZUTKrea6+9wo9//OMwcOBAOxkAgKJ76KGHwn333bfI/dtvv33Ybrvt/EUAAKgIr7/+evj5z3+eJGOfe+65YYkllih1kwAqUudSNwAAWNScOXPCMcccEz799NM2d8+SSy4ZRo8ebfcBAFDRunfvngwajMnVEqsBACiFONPKmWeeucj9sVr1aaedVpI2AQBAR8RK1gcccECrM7MA0D7J1QBQhonVxx57bHj++efbXKdbt27JdOkDBgwoatsAACDf5s2bF/7617+GXXfdNZx00knJDC4AAFBMF1xwQZgyZcoi9//iF78ISy21lD8GAAAV6d133w1HH310WLhwYambAlBxupa6AQDAN2bOnBl+8pOfpE2sjs4444yw8cYb23UAAFSN+vr6cNddd4UXX3wx3HDDDWG55ZYrdZMAAKgBsS/273//+yL3b7LJJmHvvfcuSZsAACClZ8+eYbXVVguDBw8O/fv3D3V1dcnAwJdffjnJL8gk3r3jjjuS2QMByJzkagAoE59//nn48Y9/HF577bW06/3qV7/SqQ8AQNWaPHlyOPzww8Ntt90WevToUermAABQ5bOonHbaaclAv5YJLGeffXbJ2gUAQG1bY401wnbbbRe23HLLsM4664TOnTu3Gsveeeed4be//W27swFedtllYffddw+dOnUqYKsBqovkagAoAx999FE45JBDwvvvv592vTgN5UEHHVS0dgEAQLZ++tOfJj8pc+fODbNmzQoffvhheOGFF5IO//YGFMbpKq+99tpkVhcAACiUK6+8MkyYMGGR+4877riw/PLL2/EAABTVsGHDwi233BLWW2+9dtft3r17+P73v5/MeL3ffvsl1azTFbR4/fXXw9prr53nFgNUr0WHtQAARRUTR/bdd9+0idVxJOpZZ50VDj300KK2DQAAOipWnx44cGAYMWJEEs/GitSxCmCXLl3SPu+mm26y8wEAKKg///nPrSa0HHzwwfY8AAAlqVidSWJ1U0OGDElyCdrz+OOPd6BlALVH5WoAKKGXX345mfJ82rRpba7TrVu3cP7554edd965qG0DAIBC+cEPfhAmTZoU/vjHP7a5Tqy08t5774WVVlrJHwIAgIKoq6tb5L7FF188/PrXv077vHHjxqV9/Prrrw/33Xdfs23GatgAAFAI3/3ud8Oyyy4bPv744zbXiTMLApA5ydUAUCJPP/10OProo8NXX33V5jq9e/cOl19+efjOd75T1LYBAECh7bPPPmmTq6M4u4vkagAAiumJJ55IfjriwQcfbLa83HLLSa4GAKCg1lprrbTJ1V988YW/AEAWOmezMgCQH7FzPVasTpdYPWDAgHDddddJrAYAoCots8wy7a4za9asorQFAAAAAKCS9erVK+3jc+bMKVpbAKqB5GoAKLJ//etfSZWSefPmtblOrGRy0003hfXWW6+obQMAgGL56KOP2l0nTp8OAAAAAEB6n3zySdrHBw4caBcCZEFyNQAUUaxE/ctf/jIsWLCgzXVWW2218L//+79h5ZVX9rcBAKBsxcGCr7/+es7PjzFvPqpbAwAAAABUuo5Ulv7iiy/C+PHj066z5JJL5rx9gFokuRoAiuSyyy4L5557bqivr29znfXXXz/ceOONkkgAAKiIzv499tgjHHjggWHs2LHhq6++yuh5CxcuDNdee224/vrr06631FJLhVVWWSVPrQUAAAAAKF9nn312OPXUU9utQN2aiy66KNTV1aVdZ8MNN+xA6wBqT9dSNwAAasHNN98crrjiirTrdOnSJalWfemll2a9/dNPP70DrQMAgNw9++yzyU/37t3DpptuGtZbb72w9tprh8GDB4fFFlssdOvWLXz99ddh0qRJ4aWXXgp33XVXmDBhQrvb3WGHHZIYGQAACuXNN9/M6XlxdsLbbrutzcfjQMKNN964Ay0DAKDWxNmvY4x5xx13hJ133jmMGjUqDB8+PO1zYkL17373u3DrrbemXa9Xr15hs802y3OLAaqb5GoAKIJPP/00o4ulf/7znzltX3I1AAClNm/evPDoo48mPx01YMCAcNRRR+WlXQAAAAAAlWLu3LlhzJgxyU8szhaTomPV6aFDh4aBAwcmMwNOmTIlPP/88+GWW24JH3zwQbvb3H///UOPHj2K0n6AaiG5GgAAAICyEStdn3vuuckXBQAAAAAAtSrOABh//va3v+W8jaWXXjocffTReW0XQC2QXA0AAABAWejbt2/4/e9/b4pKAAAAAIAOWmyxxcJVV10V+vTpY18CZKlztk8AAAAAgM6dO4dOnTrlZUd06dIl/OAHPwhjx46VWA0AAAAA0EHLLLNM+POf/xyGDRtmXwLkQOVqAAAAAHKqMv3EE0+E//znP+Gpp54KL7/8cnjvvffCwoULM3p+z549w3rrrRe23XbbsN1224Vll13WXwEAAAAAqEmxn3TChAlh3LhxHS5ksccee4RTTjkl9OvXL2/tA6g1nerr6+tL3QgAAAAAKt/XX38dJk6cGD7++OMwderUZHnOnDlJlevevXsnP0sssURYZZVVwpAhQ5L7AQAAAABo8OGHH4ZHHnkkPPvss+H5558P06ZNa3fXxH7WlVdeOWy//fZhn332UcgCIA8kVwMAAAAAAAAAAECZ+fTTT8MHH3wQJk2aFGbNmpUUtFiwYEFSlTr+DBo0KAwbNiyZaRCA/JFcDQAAAAAAAAAAAAAQZwWwFwAAAAAAAAAAAAAAJFcDAAAAAAAAAAAAACRUrgYAAAAAAAAAAAAAkFwNAAAAAAAAAAAAANBA5WoAAAAAAAAAAAAAAMnVAAAAAAAAAAAAAAANVK4GAAAAAAAAAAAAAJBcDQAAAAAAAAAAAADQQOVqAAAAAAAAAAAAAADJ1QAAAAAAAAAAAAAADVSuBgAAAAAAAAAAAACQXA0AAAAAAAAAAAAA0KDr//2GkliwYEGYPn16cnvxxRcPXbp08ZcAAKDiiXMBAKh0YloAAMqBuBQAgFLoXJJXhf8TE6t/8pOfJD+pJGsAAKh04lwAACqdmBYAgHIgLgUAoBQkVwMAAAAAAAAAAAAASK4Gat1HH30URowYEdZYY41w3nnnlbo5lIHHHnssOR7iz5133lnq5gAA5EysS0tiXQCg0ohpaUlMCwCUgriUlsSlANWva6kbAORffX19ePDBB5PE0Ndeey1MnTo19O7dOwwePDhsvfXWYa+99kpu59uCBQvC22+/HV5++eXwyiuvJL/feuutUFdXlzy+0UYbhRtuuCHj7cXk1lztueee4Te/+U2768V1Zs+eHfr27Rt+8pOfhFoyfvz4MGbMmPDss8+GKVOmJMfNoEGDkr9TPEbWW2+9gr7+U089FW677bYwbty45PW7d+8elllmmbD55puHvffeO6yyyioZb+uLL75oPOZSx9+nn37a+Pj1118fNt5444y2teWWW4ZNNtkkPP300+G3v/1t8j/Tp0+fnN4jAFA9se6kSZPCk08+mcROMcb9+OOPw9dff53ECTGGWX/99cMuu+ySxFKZEOsWlli3dWJdAKjtmDZl3rx5YezYseHuu+8O77zzTvjss89C//79w5AhQ8LIkSOTvtUllliiw6/z0EMPhaOPPnqR++LrZEr/rf7blsS0AJA/1RKXzp07N2l/6nvi999/P/n+OP7E1+jXr19YYYUVkqJru+22W1h77bWzbqu4VFzakrgUoPrVdHL1/Pnzw4svvhgmT56cBIkxuTImFsaAKh8dh9mIwd67776bBIwxwEsle8Z2DBs2LKy44opFbQ+VKyapnnzyyUliaMtjbNq0aeHVV18Nf/nLX8Jpp52WXAzlS7zoGj16dHLsloMll1yy3XVeeumlcN999yW3DzjggDBgwIBQC+IFZEwa/tvf/pZcMDcVz0Px5+abbw4HHnhgcix169Ytr68/a9as5PiLF8pNxWPnyy+/TJKVYhL+T3/603DkkUe2u71Ro0Yl5/J8OuaYY5L/ofjZ8Ne//jVZBgBqM9aNnfL/7//9vyRZtzUxfknFMH//+9+T5Orzzz+/oF86iHXbJtZtn1gXAGqz/zYl9v3FftwY5zYVCxXEn9jPFl8/zvK31VZbdagP8Mwzz+xQW/Xf6r9ti5gWADqumuLS+L13/P67LalE67jNa6+9Nuy4447hjDPOCIsvvnhGbRWXikvbIi4FqG41mVwdE/iuvPLKpGJrHPnWUkwkjCOMfvazn3Womlh7Pvzww3DPPfeExx9/PAni4pfAbYmV0GIC4f7775+M1Mumuto222yTcxsvvfTSsMMOO+T8fIordlj/+Mc/ThI7UmL14VVXXTV5LF4YzZgxI6mwd8opp4TOnTuHPfbYIy+vHbeb78TqeLxnKlbMjlUEU+KI0/Zccsklye8ePXqEH/3oR6FWxAvgf/3rX43Lyy+/fBg+fHiSaB0vDON5I96O1Z6/+uqrcO655+bttWMV82OPPTapWp2y+uqrJ4NI5syZE55//vnkYjmu97vf/a5x/XRiAnS+xaSoONAm7o94gR2T77M59wIA1RPrvvfee4skVsfBrzGGiYPz4mvG67lPPvkkeSzGpD/84Q/DTTfdFIYOHdrmdsW6hSHWbZ9YFwBqs/82ijHrwQcf3Nif1qlTp7Dhhhsm/YOff/550mcX++ji7Zgk8Kc//SlsuummOb1WTG6JCTsdof+2gf7bRYlpAaBjqjkujTMNxhmSY/XrWLE6Fl2McWnsw43ffUcxT2fChAlJH24setgecWkDcemixKUA1a3mkqtjAuZxxx2XBEpticl8cWq6mPQcA8V999037+044YQTFqnamk4M9mKicwzu4nQjm2++ed7bROU766yzGi+A4ijLeMxssskmjY/Hi4XTTz893HXXXcnyqaeemkxfHqfAyWcVvXXXXTess846ye/4fxSTdHMR25qp+H+dEhN1Y7JLOnFKoFSC7/bbbx8GDhwYasGtt97amFgdL4J/8YtfJInl8Xa0cOHC5O8Vqy3G2//85z+TC4J8XSzHgS2p/R6T2uNI45133rnx8TjIJF6cxlHI0e9///vk9eNPOnFQzGqrrZYcc6mf3XffvUNt3W+//ZLk6pkzZyZVKI844ogObQ8AqOxYN25n7733TmKMOPi1qVTc9Otf/zoZcBi/FIhVV+JsIPGLgdaIdfNPrJs5sS4A1GZMG2PUVALLcsstl/TVrbnmmo2Px2p+J554YtJ/F78nOf7448MDDzwQFltssaxeJxZQ+Mc//pHc3mWXXRrfTzb03+q/bY+YFgByV21xaWzXSSedFLbYYoskT6BLly6LrBOTtWNRrcsuuyzpz33zzTfDxRdfnBRrSEdcKi5tj7gUoHo1ZNPViBicHXbYYYskVsdEzFidOQaLcRRb0+lO4lQgd9xxR97b8sEHHyxyX/zSPY6giwFf7HCMU5u0TPiMFV2PPPLI8Mgjj+S9TVS2ePFz5513Ni5feOGFzS6Aonh8X3DBBcmFTxQvROLFQz7E4zYel0888US46qqrkmrD8RjOtuM9F3Ea9qb/E5kkAl933XWNt/fZZ59QC2Li8uWXX964HEcjxxHBqcTqKN6O98VzZUo8RtJV1s9UHFn817/+tXH5V7/6VbPE6qh79+7J9FM77bRT432xgnU68WL7v//9b7jtttuSjoD492x68Z2r+LmQOn5vvPHGsGDBgg5vEwCovFh3qaWWSgaExWomcbBVy8TqVAwVY5D4+ilxkFYcaNhRYt3MiHWzI9YFgNrrv3300UfDc88911io4A9/+MMifWhLLLFE0teWmoFl+vTp4c9//nNWrxO/V4nJN3FmvFjZ7uijj86pvfpv9d+2R0wLALmpxrh02223Tfpu11prrVYTq6OePXuGo446KvlJid8vx/g1HXGpuLQ94lKA6lUzydWxIy9Wtm06DV0csXb77beHMWPGJCPxYlD073//OxxwwAHNnhs7AmPF60KJFVnjFHlPPvlkUs06BoUXXXRRuPrqq5NE1ZgM2fQL/DhtSax8nZp2OhuxQm2syp3pT0yOpTL87//+bzLCMvrOd76TJDu3JiZ+/PznP29cjkkiceRnPpJOBg8eHErh7rvvbkz+jRdgcXBCOrES8f3339/Y7g022CDUgvg//fHHHye34xRI6b7YiNMrxXWiyZMnJxe5HRUvTuPUUdGKK64YfvjDH7a5bjxGU0nfcYqm1157rc1148V2rIKdb3Gb3/ve95Lb8Xybj+QoAKDyYt14vbbXXnu12Snf1MiRI5PpM1PyEUOJdTMj1s2OWBcAaq//NhYPSNlzzz3DGmus0ep6vXv3bjZLYJzRLX4nkakrrrgivPfee8ntM888M6d+O/23+m8zIaYFgNzUSlzalqaF12KF7tYKI6aIS8WlmRCXAlSvmkmujomUMUEvZciQIeFvf/vbIiPgYpXSOO3HgQce2HhfHKkWk6/zKVap3n777ZMvym+44YZkauk4+q619eIX9HF64zgdSkqcajqXNsX3F997pj+9evUKtSAG7KmflFdeeSU5FuLfKY7I3HDDDZOkijhyMgbR5TZ44OGHH25cju1M59vf/naS3BrFarxNn1uJ/vWvfzXejgMCWvtfank+SI1A3XrrrZtVbm7Phx9+GM4///yk4nI8LoYPH54cI7HKfcsLr3PPPbfxuIoJyqX24IMPNt6OlaHT/X/Hx3bcccfG5TjNUj5fPx6j8fzWlpiov+mmm+b19XMRz78phZjFAACKQaxb3Fj3W9/6VuPtSZMmdXh7Yt3MiHWzJ9YFoJKIaTsW08akkTileqb9x7HyWmqWz1glMFVZsD1vvPFG+Mtf/pLc3m233cJmm22WU3v13+q/zZSYFoBiE5dWRlyaTsvZ42Ob2iIuFZdmSlwKUJ1qJrk6Vn9u6vTTTw/9+/dvc/2TTjqpWTJzTOx7/fXX89aeOGVK/Fl11VUzWn/ppZcO55xzTrP77rvvvsZqveT/eIkjFv/xj3+E999/P6m2O2PGjPDqq6+GSy65JEk6zUfgni+xjU0rmcfqeu1pus7TTz8dKlWsgjJu3Lhmo1vb88gjjzTebjnFUTp//etfk6Tqa665JrzzzjvJcTFnzpxk/8cRvrvuumtjUkdMeE9Vxx42bFiz80mpPPPMMyU7RmIye9O/U6Uco7ENqeT7//znP8lgBACodGLdwmo6gCxVASZXYt3MiXWzJ9YFoJKJabMTC8+kvkuIFQDXXXfdtOt37949jBgxIqu+udhv9j//8z9JNcHFF188nHLKKSFX+m/132ZKTAtAqYlLyy8ubc+7777bbDnd7NziUnFppsSlANWpJpKr33zzzfDWW281Lq+88spJddt0YtXWUaNGNbvvzjvvzFubckm0jFUeYjXppiPo8pnwTYPrr78+/P73v08SIZZffvmwyy67JCMmm07v/emnn4YjjjgijB8/vix2W9MLgKWWWipJxm/P2muv3Xh7woQJoVI1reQ3YMCAdv+349+16WjYWMU7EzGp/rzzzmuseL3CCiuEPfbYI2y33XbJ60bxsdGjRyfVrWMi8ccff7zIKMVSidXW43Hb2t+/LU3XmTJlSpg1a1aHEoNSyUUx4Sjb1y/VMRoH4aQGwXz55ZdJRXsAqGRi3cJreu05aNCgDm1LrJsZsW5uxLoAVCoxbcf6j1dfffXQtWvXvPfNxcIUqb6zOH18e7MLtkX/7aL7P5O/kf5b/bcAFJ+4tDzj0nRiYveFF17YuBwTt5dZZplW1xWXLrr/M/kbiUvFpQDVpP1IpQo0HU2Wmo4uE7EK7UUXXdS4/PDDD4eTTz45lNKaa67ZbGrpqVOnlrQ91ei3v/1t6NGjRzj77LPD7rvv3uyxmDB7wgknhMmTJydVi+PxcPvttyfrtxSrGccLqnwaPnz4Im1KJa5mMrKyqabrVWpydawOfccddzQux0T4bt26pX1OfK+pJOFYQaWti6WmnnzyyXDVVVc1Lv/0pz8NxxxzTGNVwjgF0XHHHZdUy5s9e3Yy9WXPnj0b10+XXH3WWWeFfIrvKbYl3TGS6XHScp2475oOMshG02MsTrXU2v9MuteP+/iLL77I+UuZjogX9qkkqXgOiP+HAFCpxLqFFQfXNa2ekus06JFYd1Fi3fwT6wJQicS02cul/3jZZZfNuP84FpuIBUuiDTfcMHz/+9/PoZXfvJb+W/232RDTAlAq4tLyi0vbSqiORcief/75cO211zYWMIyVs0899dQ2nycuzfzvJK+ggbgUoPrURHL1E0880Wx5gw02yDhIixWmYyJtKtD76KOPMg7yCqFLly7Nluvq6krWlmoV9+nFF18cdtppp0Uei0mVMXF2zz33TJJo4zFx6623hv3333+RdeOIvBtvvDGvbYsJ3a0lV8fE06aJq5lYcsklG2/H9xIvKuK0OpUkJq7E/8mU+HfJpJJ90yr2mbjiiiuS5JZo8803D8cee+wiSR7x4nmHHXZI9uWDDz7YmOS90korNVY+bk2+j5F4zmotuXratGmNt/v27dss+TtdBf8+ffokVfJTlZtz1dFjNLWNUiRXr7LKKo23zRYAQKUT6xZWnOkkTocexevGrbfeOudtiXUXJdbNP7EuAJVITFucvrk4Q2JKe/2Cp512WtIvGvtEzzzzzMaiFLnQf6v/NltiWgBKRVxafnFp00rKqX7a1qy44orh0ksvTYobtkVcKi7NlrgUoPp0DjXgnXfeabzduXPnsM4662T83JYVSptuqxRiBYh0yYd0XKys0VpidUpMlj3ooIMal2+55ZaS7/aYdJ2SSdJsa+ulEmgrSdNp0uMowGHDhrX7nKaV3zOZpj0OroijWFOOOOKIVteL29piiy2S23Hkayrpe7vttgvlIJdjpOW6TbdRjNdvuV5HXr8jmlY3b3r8AEAlEusWzm233Rbuu+++xuUTTzyxQ4MXxbqZE+vmTqwLQCUS0xYnXmo681y6vuNYfOSpp55q7DttmlCQC/23+m+zJaYFoFTEpeUVl2Yi5gsdfvjh4e67706bWB2JS8Wl2RKXAlSfqq9cHUeuffHFF81Gv8VqrJkaMmRIs+VYqXjLLbcMpRCTPJtWTe3atWu7AV9LzzzzTLKNN954I3z++edJ8Bir7sYKYDH4j5XV1l133VDLWqsM3VKskHzVVVclt+O+jMdZ//79m62z8cYbNxvNWEhz585tvJ2qmNyelokeTbdRCeKF1/33359V1eros88+a7wdj/32jBs3rvF2rJoc/0/aEs8NTdsUbbvttmm3X87HSMvjZM6cOSU9Rjvy+h0xYMCAVo8fAKhEYt3CePnll8P/+3//r3E5Dtbcddddc96eWDc7Yt3ciXUBqERi2uL3zbXVdxz7yuKMfqnqfz/5yU9yaN2i20zRf5vd30n/rf5bAIpLXFo+cWlL++23X1i4cGFyO86w8vHHH4fx48cnydl/+tOfkiIZcfaVdLk/4lJ5BdnS1wpQfao+uXrixInNlpdddtmsnt+ysm3L7RXT3/72t1BfX9+4/O1vfzsstthiWW3jueeea/WL+1hlNz525ZVXhs022yyccsopSSXgWjRixIh214kdxbFjN05bE/8mMWF9k002CaXSdLRmnH4oE/PmzWtzG5UgXvCkRrZ26dIl4+SVePGUzWjYd999t/F2HHgQByS0pWXl7Hi+WW+99UI5yOUYaXmcZFPxuhDHaEdevyOavm7T4wcAKpFYtzCzCx111FGNHfvxOuqss87q0DbFutkR6+ZOrAtAJRLTFr9vrq2+4xj3pqZmj7c7MnNLiv5b/bfZEtMCUCri0vKJS1s69dRTF7kv5hbceOON4bLLLkvyfo488shw7rnntlnETVwqLs2WuBSg+rSdJVglZs2a1Ww5Vp7NdWRRNHPmzFAKMcEzJlc3ddBBBxXktZ588snwgx/8IIwdOzbUokwT8Juu17Q6ein07t076+oULdfr06dPqCRNp0nfYostwlJLLVWQ10l9ORANHjw47bqrrrpqsxG27VWtLvdjpOW6TbdRjNdvuV5HXr8jmg5qAYBKJ9bNr6lTp4ZDDz00fPrpp8ny0KFDw1/+8pfQr1+/Dm1XrJsdsW7uxLoAVCIxbXHipaZVAVvrO37wwQeTQYHRXnvtlczkWAr6b/XfimkBKBVxaXnEpdm89uGHHx5+97vfJcuxsnWcjTAWz8gHcam4VFwKUH2qvnJ1nNajI9V5W1ZKTVXKLaY4Eu+kk05qNiIvVkneZpttsgoUv/Od7yTPW2211ZIk865du4Zp06aF1157Ldx///3hmWeeaTYKb/To0Ull7M033zzntn/yySdpH4+vX2569eqV9Xotj7Niazo94ueff57Rc5pOYxPfSz6qihRLrLTe9HjdY489Mn5u079bJhdsTUektndsxH0Y/7/i/1Q0cuTIUC6aDhSJg07iRWh758P43pse2/379y/ZMdpyG8XU9II90/MDANWvEuPcSKybP/FvHBOrU7MbxcF+1157bVh66aU7tF2xbvbEurkT6wLUNjFt7fTf5vL6qQGErfULxn7DM888szEWO/nkk0O+6L/Vf5stMS1A5ROXFk+1xaW5iN/hb7rppuGpp55K4oibbrop/OIXv1hkPXGpuDRb4lKA6lP1ydVNEyOjbAO9lsmHLbdXDHG03Ouvv95sNN4555yTcVL16aefnkxl0lrV15VWWil861vfCgcccEBSsTomVKeC2AULFoQTTzwxSbzONalxq622Svt4rPK71lprhXIS/8Z9+/bNaL10IyTff//9cP311+e1bcOHDw+77757q3/HpskYmWi63sorrxwqye2339446i9eQGUz0KBphetMkp6aXjQ1HeDQltT0RXHwwgYbbNDu+h2dMr6l+L963HHHpT1GosmTJ7f7d295LHXkOGn63HiOySS5u+nrx/eV7cwD+dK0Mn2hKqQDUHkqMc6NxLr5EQer/fjHPw5vv/12Y6wSE6tj5eqOEuu2Taybf2JdgNompq2d/ttcXv/jjz9u8/Vj/16cxSXq1KlTMqV6W1r2qR577LGN39PEY/CYY45p9rj+2wb6bzMnpgWofOJScWmucWmuNttssyS5OnrhhRdaXUdc2kBcmjlxKUD1qfrk6pZiR19H1i/2NA5/+tOfwpgxY5q1JyZWZ/qlfUxG3H///TMOIG+44Ybwwx/+MMycObNx6pI4rXWsnF0rYnAeqw9nsl5rldJSpkyZEm688ca8ti1WTm+tc36VVVZpNnIz/rSXBJqqrlyJydVNp0nfaaedsho0sdxyy2U8CjqK1dszHT0bk2tSCTbz589PjoHBgwenfU6+j5H4/lpLro5T08djIjWyNw7YaO/v3vQYWWaZZTIadJDuC5zOnTsn0yvF82h8/REjRlTEMRr/jq0dPwBQicS6+YnJ4/SRr7zySrIcY6R4zZTJNUQmxLptE+vmn1gXgEokps1e0/7jt956K+m7jMUh8tE3FxMImiYRtKdpIZnWtqv/Vv9ttsS0AJSKuLS84tJsNK2APX369FbXEZeKS7MlLgWoPp1DlWs57XXTaRgyMWfOnGbLrVV/LpRYseyiiy5qdl+sLB2TSQslBrM///nPm91366235pxU/uijj6b9ueWWW0K5eemll9pdJ1alTgXZMeF97bXXDqW04oorhkGDBjUuP/vss+0+p+k6m2yySagU8e8T939KrMqejTXXXLPx9nvvvdfu+quuumqzC7x07r777mbLb775ZignG2+8cePtZ555pt31n3vuubwdI7FKdazck80xms/X74gJEyY03i7HCqQAlEYlxrmRWLdj4vXkUUcd1VjNJF5vXn311WGdddbJ299HrJsbsW5uxLoAtU1MWzv9t+uvv35jgYo4WDA1UDBdtemm1w7F7JvTf9tA/23mxLQAlU9cWjzi0gapgmQtE62bEpc2EJdmTlwKUH2qvnJ1y2TobJOrW65frOTqeAHxq1/9qllSc6yOFqeeLrS99torSeqOVaujWHUiJok2DR4z1bTDuK3p0stNTGrfZ5990q5z2223Nd6O+6W1gDt+uV+s5NqY4L311luHm266KVmO1c533nnnNtd/8cUXG5M2YjXh+NxK0XTfx5GpTRN2M62gHKs4x+rsMUE+jh6MVZnbsu666zbefvfdd8MHH3wQVlhhhUXWW7BgQXLsNPXGG2+E733ve2nbU8wE7G233Tbcddddye177rknOcf07NmzzYElcZ2mz83H68djL3WMHnHEEW2uG6uKp6Ziytfr56ppUn22xxsA1asS49xIrJu7urq68NOf/jQ8/fTTyXJMTrnyyivDt7/97bz9fcS6uRPr5kasC1DbxLS103/bp0+fsOmmmybfO6ReP92scvfff3/46quvktux73vDDTds9viQIUMy3neTJk0K22yzTePyQw89lDy/Lfpv9d9mS0wLUPnEpeLSXOPSXP373/9utZp2U+JScWm2xKUA1afqK1fHKZqbmjZtWlbPbzmdXUzKLLTnn38+HHfccckUKCk/+MEPkqrVxRATQVoGpe1V7K0msVru2LFj23w8dmpfd911jcvtJWIXy6hRo5KO9ujxxx8PTzzxRKvrLVy4MFxwwQWNyzvuuGNYYoklQiWIFVOaJvxmW7U6ivuoaaWV//73v2nXHzp0aLME68suu6zV9e68887w0UcfLfK/XE7ilxipzokZM2aEP/zhD22uGxOF4jqpKY+++93vdvj1498rNUAlVg1PV9EzHqMxYT1VWWfYsGGhFOIgk3feeafxgj1fVSkBoFTEurmJcclJJ53UmIwSp6q85JJLwmabbZa3v41Yt2PEutkT6wJQqcS0udlvv/0ab8fk6rfffrvV9WbPnt2sD/SHP/xhu1O155P+W/232RDTAlBK4tLyiEvjzCzZFFmMAx5ffvnlxuXtttuu1fXEpeLSbIhLAapT1SdXt6ww+/HHH2f1/Fg9tWWiZSG99tpr4Sc/+UlSNbZp8uuZZ54ZiikmU6ZLMq9mMbn8l7/85SJViKPx48eHQw89NAnkU9Pm7L333qEcrLHGGmHXXXdtXD7xxBMXmaIlXlj84he/aEwoju/1Zz/7WbvbTf3Ei5tSilVNUhXV48XMbrvtltN2mlaTTlUeTCf+zVNi5eeLL764MfE3VaH617/+9SLniZjg/uSTT4ZyEasrxmqLKX/605/CDTfc0KxCfky+j4MH4mMpcbBHatrQ1hx44IGNx0j832nLwIEDw8EHH9y4fM455ywykCEmFV144YWNFbZTx3KpxOlX4z6Jtthii9ClS5eStQUA8kGsm32sG2OlU089Ndx3332Ncehvf/vbZtX38kGs2zFi3eyJdQGoVGLa3PpvY/GEDTbYoHFWliOPPHKR6tOxOM0xxxyTzN4XLb744smMmsWm/7aB/tv2iWkBKCVxaXnEpXGdkSNHhj//+c9p84E+/fTTcO6554azzjqr8b7YjnQzUYtLG4hL2ycuBahOxSs3UCKx0misyptKDv7ss8+SxNhevXplPGVdUyuvvHIolAkTJoTDDjsszJw5s/G+mMwXK7imKhIXS8+ePZstZzPSr9KdfPLJSaJs/H355Zcn0yPGC6NYvXbcuHGN68Vj6Pzzzw89evQI5eL0009PEvTj6M7p06eHH/3oR0n741Q2s2bNShKJU8nJ0dlnn73IAISOiBc0U6dObXZf/J9LeeWVV8Luu+++yPOuvvrqsMwyy7S7/aYJ73Eay/amiGpLHH0aByzE4/rhhx8OZ5xxRtr/sZ122inccccd4ZFHHkmWr7rqqqRSdazwHvfrY489liQFpwZDbLnlluGUU05JEnGOPvro5L4BAwYkx1SpxcEAMbCP+zImiMcE55hgPXz48KS9L730Uvjwww8b199rr73CHnvskbfXj/vjhRdeSI7FOIjkhBNOSCpox8rU8e8RR3jHC9uUmAy+0UYbtZuI1FZF8ZSYEJWqmp0Sp1Ntb3DBAw880Hg712R+ACgnYt3sxUomTb8MWH755ZPBiu3NgJLq9I8D1TIh1u04se43xLoAVDMxbe4uuuiiJGaK/W+TJ09O+v1iH2csFhG/Q3nqqacaC4ukZmtZbLHFQrHpv9V/G4lpASh34tLyiUunTJmS5NXEn1hIcPXVV0++n495Hl999VWSixMTuJsWUFtppZWSomrpiEvFpZG4FKB2VX1ydbTqqqsmyYRRrEAaEzxjYJaJpsm0qW0VwkcffZRUx21aITqOkovJvTHgK7Y4ErBlUkCtiAnJMQH5iiuuCBMnTkx+WlpqqaWSgD8mLpeTvn37hr/85S/JhVyqInNMlo0/TcUk05hsuueee+b19d99993k4qctsXJ2rPLcUhyR2p7PP/88/Oc//2lc7kjb+/XrF7bffvskYTpesMWE3o033jjtc+IFW6ygHBN5o/g+W77XtdZaK0na7tOnT7jllluSJOJ40ReTceJrlkNydRQTqmN7brzxxiShOo7mTY36TenUqVM44IADkkrn+RTPZ/G8dtppp4V77rknue+tt95Kflqud+yxxyaV/NsT/19bO66aau3/OP690onJ3qmE+pj8/53vfKfdtgBAuRPrZq/lLD7vv/9+8pOJ2JGfSXK1WDd/xLoNxLoAVDMxbe5isYo4a91JJ50UXn/99eT7kjj7YcsZEGPBmvPOOy8pcFEK+m/130ZiWgDKnbi0POLSmHwdC6mlZiNu7Xv8puK6MbF79OjRSbHGdMSl4tJIXApQu2oiuXqzzTZrTK6Onn/++YySqz/55JNmQVccuTZ48OC8ty9+kX7IIYc0m6IkVnH94x//uEgF6WJ5+eWXmy0vvfTSoZbEarmx+vDNN9+cVKSL1ZhjUB6r1G277bZJ0mkpKnZkIiaB/vWvf00q7sbqyq+++mqSQBwTquPxG6euiRcLhTiWCym+l/nz5zcmkcepfTrioIMOSpKro5gI3V5ydfxfvPLKK8Ojjz6aPO/FF19MEm1ixep4URef/z//8z+NF2DXXHNNUk05rtu0ene5TJkek5tjFfFbb701OT/G0byp4ydWio7HyHrrrVeQ148XoTFZ/Qc/+EG47bbbkuT/eIzG/7Fll102bL755snrx4rrpXTvvfeGGTNmJLf333//pH0AUA3EuuVHrJs/Yt3MiHUBqHRi2tzFPrd//OMfYezYseGuu+5KZmyM/ZexvztWCoz939///veTPs9S0n+r/7Y9YloAyoG4tPRx6WqrrRaeeOKJ5Cd+hx8rVMeZmuNM3zG/IBZGi8UEYzXrb33rW2GXXXbJaFbtFHGpuLQ94lKA6tWpPpYtrXIxeNptt92aBWkxQGvP1VdfnVQnTjnssMPyXnl25syZ4cADD0xG4zVt39/+9reSdV7G6sM777xzUtE26tKlSzLtSnuj9nJNLE9Vpr3qqqvCwIEDQymsscYazY4XakMc1PDkk08mCRixQvGSSy5Z6iZRRkaNGpVcgMdk8FixvBDnQACqV7nEuZFYtzaJdUlHrAtAJsS0lJqYlnTEtAC1Q1xKqYlLSUdcClC9OocaEJMJ4ii0psnDsfpsOnPmzEmqFjcVR7DlU3yNI488slli9ZAhQ8K1115bssTqmFB9wQUXNCZWRyNGjJBUSFX62c9+lvyO1aevv/76UjeHMvLcc88lidXRwQcf7BwIAFQcsS5tEesCAJVCTEtbxLQAQDGJS2mLuBSgutVEcnV07LHHNls+++yzw5dfftnm+rFi9eTJkxuX45Qja6+9dpvrjxkzJkniTv3EatTp1NXVJVPE/Pe//228b+mllw5//etfs5qCJJ1x48aFl156KeP1Fy5cGM4///ykgm9TqYp7UG3iwIHtt98+uX3jjTeGadOmlbpJlIkrrrii8bwcRyIDAFQasS5tEesCAJVCTEtbxLQAQDGJS2mLuBSgutVMcvV2220X1l9//cblDz/8MBxwwAHhzTffbLbezJkzk8TrplVse/ToEY4//vi8tueXv/xleOyxxxqXe/bsGc4555zQqVOnMGnSpIx/ZsyY0eZrxArdP/zhD8NBBx2UJH9/8cUXra4Xq1TH0VRxvVg1u6mRI0eGLbfcMo/vHMpL/F/s1atXmDVrVvjDH/5Q6uZQBv7zn/+Ep556Krn985//PPTp06fUTQIAyIlYl5bEugBApRHT0pKYFgAoBXEpLYlLAapf11AjYtLypZdeGvbee+8wderU5L633nor7L777mHYsGFh6NChYfr06WH8+PHhq6++avbcmPS82mqr5bU9d911V7PlOXPmhCOOOCKnityxAnY6Tz/9dPITLbfccmHFFVcM/fr1C127dk3e82uvvdZq4vXw4cPDBRdckHWboJIMHjw4qwrvVL8ttthikYE3AACVSKxLS2JdAKDSiGlpSUwLAJSCuJSWxKUA1a9mkqujZZZZJvzlL38Jxx13XHjvvfcaqza/8soryU9LsWJ1HH222267hWoxefLk5Kc9++67bzjllFOSfQAAAAAAAAAAAAAAtaBzqDGrr756uO2228Lhhx8eBg4c2Oo63bp1C9/73vfCLbfcEvbbb79Qqb797W+Hgw8+OKy11lpJler29O3bN+y5557h9ttvD2eccYbEagAAAAAAAAAAAABqSk1Vrk7p1atXGD16dDj++OPDCy+8ECZNmhQ+++yz0KdPnzBo0KCw/vrrhyWWWCKrbe61117JT6befPPNUGgrrLBCUn06mjt3bnj77beTqtWffvpp+Prrr8OCBQtCv379Qv/+/cNqq62WJJ537lxz+fZF+3sAAEApiHUBAKh0YloAAMqBuBQAoHbUZHJ1SqzmvNFGGyU/1a5Hjx5hnXXWSX4AAAAAAAAAAAAAgEXVZpliAAAAAAAAAAAAAIAWJFcDAAAAAAAAAAAAAEiuBgAAAAAAAAAAAABo0PX/fgMAAAAAAADUrPkL68PMuvlZPadft66ha+dOBWsTAAAAUHySqwEAAAAAAICads/ET8OFL70XZtUtyOp5fbt1CaNHrBR2XH6pgrUNAAAAKK7ORX49AAAAAAAAgLKqWJ1LYnUUnxOfG7cBAAAAVAfJ1QAAAAAAAEDNmlk3P6fE6pT43LgNAAAAoDpIrgYAAAAAAAAAAAAACCF0tRcAAAAAAAAAvnHzyOFh8R7dWt0l0+fWhVEPjLO7AAAAoEpJrgYAAAAAAABoIiZWD2gjuRoAAACobpKrAQAAAAAAADogVrNuT79uXUPXzp3sZwAAAChzkqsBAAAAAAAAOmDUA+PaXadvty5h9IiVwo7LL2VfAwAAQBnrXOoGAAAAAAAAAFS7WXULwoUvvRfmL6wvdVMAAACANCRXAwAAAAAAAGSoX7euSRXqXBOsZ9bNt68BAACgjEmuBgAAAAAAAMhQ186dwugRK+WcYA0AAACUt66lbgAAAAAAAABAJdlx+aXCyCFLtluFevrcujDqgXFFaxcAAADQcZKrAQAAAAAAALL9orVzpzCgRzf7DQAAAKpM51I3AAAAAAAAAAAAAACgHKhcDQAAAAAAAFAk0+fW5XV7/bp1TapoAwAAAPkhuRoAAAAAAACgSEY9MC6v2+vbrUsYPWKlsOPyS+V1uwAAAFCrOpe6AQAAAAAAAADkZlbdgnDhS++F+Qvr7UIAAADIA5WrAchK7JydWTc/q+eYkhAAAAAAoPb6h/UNN+yDWFk6JkAXUtx+/NsM6NGtoK8DAAAAtUByNQAZu2fip0n1i2w7gU1JCAAAAABQ2UnQufQP6xsOyX4dPWKlnPrWAaBWFLLAV60VDyv0+621/QlA7ZJcDUDGF0m5dv6mpiQcOWRJF00AAAAAAAVUiCToXPuH9Q03iPs19o9nm4iUzvS5dWHUA+Pytj0AqMYCX7VWPKzQ77fW9meuyeTZknwOUJ4kVwOQkXjB0JGqGqYkBAAAAAAorEIlQXekf1jfcIO4Xwf06JbTPqw2Kl4CUIwCX7VWPKzQ77fW9mdHksmzVcnJ5wDVTHI1AAAAAAAAVAFJ0LUtVrMu9+qItVjxEoDSFPiqteJhhX6/tbY/O5JMXivJ5wDVTnI1ADm7eeTwsHgbFz+mJAQAAAAAqL3+YX3DpTPqgXFlnahcixUvAYDK1NFk8mpPPgeoBZKrAchZ7DgX3AMAAAAA1F4SdKX0D8eE3pioko+Kz9WiVInKtVbxEoDyK/BVa8XDCv1+a21/AlBbJFcDAAAAAABAlSqHJOhMk5f7deua12TfeyZ+WrTp3Ist7qtYgTrX9yZRGYBajF3KIS4qpkK/31rbn+mSybMl+Ryg/EmuBqBosqn+ke9OdAAAAAAAcuvD7Whl50yrFsZk4dEjVgo7Lr9UyEfF6mpNrI5i/3ncV5X+HlW8BAAqRa0lkwPUOsnVABRNNtP+5LMTHQAAAACg3MTk35l18/O6zWIlQRdKTBKOycIjhyzZ4eIbcd/mmnQc+6djAZByF/vP477K5Dgq1+qIlZKklMv/qyIyAJU9OCybbVTLOT/d+y3X/ekzGoBCKf9eAQBqUj470QEAAAAAyikJ+t6Jn4ZLxn8QqlFMhonJybkmNsfnxf1dqoTbVOGPSumXju2shOTkfMlHYle2yVv3TPw0pwrhisgAFEchBw+VYvaNUir0QKx8789cP6Oj49dbIeyQZvv5jjkyUWvJ/ADlTnI1AGXZgV4OnegAAAAAQG3rSMJGNffhpqvsHBM9YjJMOe63m0cOTyolpyNZpbaSvtpL3oqDK3I9lhWRAagdzvnF358d+YyO4kDHchvsWGvJ/ADlTnI1AIX5gCnjDnQAAAAAgPZ0NGGjHBQiCTqTys4x0SMmw2RS8TtW6Ct0lcSUmFitmEfzfd+eak82by95Kx7DisgAVP/gsI5uuxILh3X0/ZZ6f3b0M7qSSeYHKA7J1QAUTDYd6MXuRAcAAAAASKfSEzbynQSdbbJtXKdSkotqVSb98aWsjJiPGTKrMRkOoJYVcnBYrRUP68j7rcX92V4yebZqLZkfoBJJrgagsB80OtABAAAAANp0/HorhB0KkLgqCZp8KGVlxHJNyrp55PCkCnprFJEBKLxCDg4r19k3ymlflvP+TPcZHd078dNwyfgPst5uJsnk1RLnAPANydVATUzdWKiLgWJsHwAAAACA8tBewka29BW3nVxTDtuoJh2pjljKyoi5Jn0VMnkrngNUiQSo3gJftVY8rNDvt5j7s73P6H1XGxz2WWXZssnvqLVkfoBKI7kaqGr3TPy0Q9PYtDfNXa7bL2Q1kkIlh5eqIzrT1/UlBAAAAABQaJIqi0PiSP5VcnXEak9yy6WITzZ8fwKVqdDnhmJw/qEclVtcUW7tAeAbkquBqr7gzLWTMJNp7jqy/ShON5PLlDPlkhxebp3omb7nYlDNHAAAAACAcpNpdcRarIzYVqGXQldRv3fipwX7rqgcvz8BMlMJ3+Hmq+BYtc00UYjCYeVeLK2Q0r2nany/AJQXydVA1YoXGB254GxvmruObr+QipEcXonvuRqqpQMAVOsAMgPUAACgNsXrhtg/Wui+6vga8bVqneqIrStkMnmpE9XL5fsTIDPV9h1uIQuO1ULhsGpKtK/Ez9ByZxZwgMLSgwBQpQqdHF6IjuiOdqK3954rvVo6AEC1DiAzQA0AgGKq5ep/5Sj2h8brhkImDqWuTfS95q7QFZwprFJ/fwJkrpwLfJE/tVgsjfyrxFnAASqJ5Gqgptw8cnhYvI2Oo3xMc5du+8Wa3q0YCtURXYxO9Equlg4AUI0DyAxQAwCgmGq9+l+5ioke8boh29lyCjGrDtVfObIjhV7aKzxTrErsANWqkmaaKHThsHIsllbO+7PS3m8xKfQGkBufKkBNiYnPhUxcbW/7+642OOyzyrIF6SAuRnJ4MTqis+lEz8d7BgCgtAPIDFADAKBYVP8rb7HPWeEJinWs5VLoJZPCMx0pInP8eiuEHfJUUdL3J1BdMv0Ot1zkWnCs0maaKOfCYZW2Lzu6Pyvx/dbaLOAAlUhyNUCxT7xl3EFc6OTzathH5VYtHQAAAADITK1V/4NcFav6cin/p3Kplp5p4ZlCbhuoTeXyHW6mci04VonnwmIXDiuHYmnlOJtJpb7faknmB6hWeoAA2rnAyeUxqNTODgCAchhAZoAaAADlphaq4UExk3fK4X+qkIVeyrGITCbfa9VCchpQHOV4HqyG91oL3z3X0rGTLbOAAxSX5GqANCq9qnAtJodn+r50EAIAlG8nfi18SQAAQHmo9up/UOzKkZnyP1We33mlkt7j3x8AKD+SzwGKR3I1QBWr9OTwQr7ncu0gLJek92w6tucvrDc1EwAAAAAVycA+aJvkndoTK5XHiuUxsd6AEoDCq8ViaQBQKSRXAzRJJo0Jt7lOcRefG7dBZSjXDsJySYjPNPn8nomf5jQ1ZLkmtwMAlfklQSXOXpLLALVsGCwHAABQuzrynVd8TrxeNaMUQO18N0xtKJeE/XLqpwdIRxYgQOqE2LlTkuzZkUTRUgaAtZgc3tH3rIOwY8nnMSEol/+XTLcPAFSPQn9JUGmzl+Q6QC0bBssBANUg2wFpvqQH6Ph3XgBAdSqXZP5y6acHaE9lZdEBFFgM3mKyZ7YV5Mqh077Sk8NrsXOwo8nhhdZe8nl8rCNtl9wOABRbOQzw6sgAtWwYLAcAVLpcBqT5kh4g+++8YhXLckm2AqhmtVgsDcq1nx4gEz51AVqeGDt3qtipzio5ObwY77ncOggrPTkcAKAUXxJU+uwlHR2glg2D5QCASpXrgDRf0gNUz3deANWmFoulUTqVXugNoBxIrgaoMrXYUVaLCfGFkI/k85tHDg+Lt/G3KLfkdgCgMr8kMEANAKD6dWRAmi/pAQAoV7VYLI3S0I8O0HGSqwGgxCo5ObylmFhdLe8FACjfLwkqefaSbAeoZcNgOQAAAPIhXl+2R6IfQG6q6bthylu1FXoDKDbJ1QDUtEw6CCOdhAAA5fUlQTV9CVFOA9TKqS0AAJkMSPMlPUD+ZZL8lJp9KiZuAe2bv7A+40IBAPlSTf3oAMUmuRqAmpbN6Mjj11sh7JCmk7AaOzvSvad8vN9C7TPJ8AAAAADVxSAwgPIyq25BuPCl95KKmJnMQgW17J6Jnyb/L/H/BgCAyiC5GgAydMn4D5KfWlLoqXkKtf1sKmZkWimgIyR7A0B5qaUBXuUyWK6Q+0Y8BwAAkLt4vRb71HNJ+ozPif3rKmJC+n4LidUA5ddPX4x+5Wr4jgFqmeRqAGpGRzoIqc6KGcWqFGB6RAAoL+UwwKvWBssVat8Us/JTezPZFJNOdgDI7Uv6apx5DqCjYh96vF6T/AmFERP3OtJvEftUYj8AQLUpZT99uc4oUMjvGBQpgeyJwACoGcXuIKy0zo6OJp+3936LndzeXsWMYlYKMD0iANQGn/nF3TfFrvxUTjPZlGMiPwDk88vcjiZBF3qAGUC1idcW8XqtvXN0PD87x0Lxr/9VMQXIX190Oc8oUKjvGBSdg9xUTsYXABSxgzDl3omf5pRAUYmdHR1JPs/k/ZZb9YuOVgrIlukRAaA0ym2AVy0Plsv3vil2PFdOJPIDUInKtTIYAN/04ZfiWhZq0c0jh4fFM/h/M3MVUC3KqZ++3PuV892Prugc5E5yNQA1J5sOwn1XGxz2WWXZjJOxK72zI9vk82zfb67bz4SKGQBAJQzwKqRaGyxX6wzeA6CSFPLL3I58SV9pM88BANUhJlYbzADUEn3LpaPoHOROjxFQMVNBZqujU0dCrVZrKPT7Lef9mWmlgExI9gaA8lFLA7zKabBcKfZNPuO5jsxkAwDk98vcdEnQuX5JX4kzzwGUo0y+j6vUgjQAQG300+e7X7mSv2MAviG5GigpU0EC5USlAACoXuU8wCvfanmwXL7juVxnsikEnewA1KpMkqBz+ZJeoh9AfmSSDJQ6l8fzNQBQu8q1b7nW8gQUnYPMSK4GqnIqSAAAAKjmDn8AqJUvczNNgvaZDVC+4neB8TvBOBBGBWsAgNKqtWRyyJXkaqBip4LM59SRQO1NR5jJVIX5lulrqpwEQK6DFws1nR7522e1vj/z+f5rfV8CQKXzZS5A5Yl91/H7tly+34vPif0WEnkAgGJoq/9YvzKQKVmGQE3IZOpIoDanIyzH9pgiEYBs3TPxU7PClJFyi0HKiX2TXwbvAQAAxRS/Z4vft5mZFgAod5XcF13p/b6V3n5IkVwNVORUkNnygQxUElMkApBtxWpfakJtMngPgEqZQUVlMIDqsePyS4WRQ5bM6NxfyUlNAAClUun9vpXefkiRXA2UFVNBAqWYjjCKz43bKJf2mCIRgEzFLzNz/bwph8/MSlduMUg17ZtsVfO+7CiD9wAoRMJ0dO/ET8Ml4z+wgwFqTKwwOKAAxZIAAIrdF13J/cqV3u9b6e2n+lXmmQFK1FHclErIANUzHWFqRGQ+A3bTIwJQjQrxmVnpyi0GKSfFjIeqfV9GBu8BUCz3TPzUzCgAFIQp4gGAcuqLLod+5Urv96309kM6NZ1cPX/+/PDiiy+GyZMnh6lTp4a+ffuGQYMGhREjRoQllliiJG2qr68P48ePDx988EGYMmVK6NWrV9KmYcOGhWWXXTZvr/Pxxx+HV155JXmN2bNnh2WWWSasuOKKYd111w2dOlXvF5H57CiupakJckk+z4SpIIFSTUdYrAEz2bTHFIkA5NPNI4cns8Lkm0GmlRGDVMO+yVYt7EuD9wAoVl9wsQZGVWplMAByZ4p4AKCc+qLLoV+50vt9K739kE5N9lzFZOIrr7wyjBkzJnz22WeLPN6tW7ew5ZZbhp/97GdhjTXWKFqi9zXXXBNuvvnmJNm7pc6dO4eNN944HHPMMWHDDTfM+XWeffbZcMUVVyS/Fy5cuMjjQ4YMCaNGjQqHHnpo6NKlS6h2HekorpWpCVQpASpNuU1HWG7tAaA2xMRqnz/F5TPfvikGg/cAKLT4JbQZJwAotVr5HpbaKFCm4BhA8VRqP32l9/tWevuhLTWXXP3222+H4447LkyYMKHNderq6sJDDz0UHn/88XDKKaeEfffdt6Bt+uSTT5JE7pdeeqnNdWIi9FNPPRWeeeaZ8JOf/CRZP1sXX3xxuPrqq1tNqk6ZNGlSuPDCC5P3f+mllyYVratZRzuKq31qgmJVKQEAAACq+wsCAKrf8eutEHbIYKbHcqgMBkDhmSKeaqZAGQD5Vun9vpXefgi1nlw9derUcNhhh4UpU6Y0u3/YsGFh6NChYfr06eHll18OX331VXL/3LlzwxlnnBH69OkTdtttt4K0Kb7W4YcfHt56661m96+22mph5ZVXTh5/5ZVXkrZFMTE6Vt3u0aNHkmSdqcsvvzxcddVVze4bMGBA8t579+6dJJu/8847jY+9+OKL4cgjjww33XRT8ji1qRhVSpoyFSRAbtUMfCkJZOqhSZ+Hc194N7n9q2+tErYZMtDOAwAA0rp55PBkZhR9EwBkwxTxVCsFygAAakPNJFfX19cnFaubJlavvvrq4YILLghrrrlm430zZsxIKjb/7W9/a7zv1FNPDWuttVaS8Jxvp512WrPE6kGDBiWVozfccMPG++bMmROuueaacNlllyXvI7rkkkvCeuutFzbbbLN2X+Oxxx5LkqtTOnXqFI4//vhwyCGHJEnaKc8++2wYPXp04z56/fXXk+Ty3/72t6GWpOsoNjVBYROrR49YScUSgCYynQ4ndQ6N0+1QHdMENiV5nnxZUF8fLmgyK0m8/d3llghdOqkYB1Ar8j14T2wDUBtif7nqUwDkwhTxVKOOFihTcAyAYvb7ZtonXEqKzlGuaia5+v7770+qMacMGTIkSaDu379/s/UWW2yxJOE5JiDfcMMNjRWsY8J10wTlfIgVqe++++5mr33jjTcmbWuqZ8+e4eijj04qSJ933nnJfTHJOiZh//Of/0za2pbUeqmk7OiUU04JBx100CLrbrTRRsnr77nnnmHmzJnJfXfccUeShB2Ty2uFjuKOVynJhcQxgNzFTrwLX3ovjByypEEqVThNoOR58mXGvPlhWpMOlHg73idJAqB25HPwntgGAADIhCniYdHr7UwGNANAvvt9y5Wic5SrmkmubpkYffrppy+SWN3USSedFB5++OEwefLkZPmBBx5IKjnnM8m4ZZtOOOGERRKrm4oJ0WPHjg3jxjWcEF999dXw0EMPhW233TZtUvmbb77ZuDxixIjwox/9qM31hw4dmrTjrLPOSpZjUnZs5xVXXJHVe6N6ST4HKIw4yCR2quVa7SA+L1ZLkCRZfdMESp4HAIqtvfhDbANQmTKZcaASKloBAFRqgTIFxwAgd743p9hqIrk6Jhe/9dZbjcsrr7xy2GqrrdI+p1evXmHUqFHhoosuarzvzjvvzFty9Zdffhn+85//NKta/f3vfz/tc2KF6phgfeKJJzZrU7rk6rvuuqvZcnx+ukrX0d577x0uueSSMGPGjGT50UcfTSpZ9+vXr933VYtMTQBAPsSklVitINcEXKp7mkDJ8wBAOQ3eE9sA5D+pOVeZJujkOuMAAJT797CSVSkHCpQBUCn9vvG5cRulougclaQmkqsfeeSRZsu77bZbRs/bddddmyVXx0rWJ598cl7a9Nhjj4X587/pTN1+++1Djx492n1eTKSOid+zZ89Olh9//PEwb9680L1790XWjffHx1N69+6dNhE7JbZj5MiR4Z///GeyXFdXl7R35513zvj91RJTEwCQL3Ha9VgdMJMvXGOncqVP7wMAQOEYvAdQHgqd1JyaWj72KbSlIzMOAEApZdIHnslnIQBAtehIv28qbspkkHah6LemktREcvUTTzzRbHmDDTbI6HnLLrtsWG655cLkyZOT5ffeey989NFHYfDgwR1u05NPPplTm2Li87rrrhueffbZZHnWrFlh/PjxrT7/pZdeCl9//XXjcnxea0nYrYnbSyVXp/ah5OqOMTUBAJleTLRWHZDamiZQ8jwAUGmD98Q2AKVJas6k37kjMw6UuqIVALTHd7AAQK3Jpt+3HGf8UHSOSlETPWLvvPNO4+3OnTuHddZZJ+PnDh8+vDG5OrWtfCRXv/32282WY+JzNm1KJVenttVacnXL11hvvfWyeo229mE1Wax71ySBbdr/TSkVb8f72mJqAgAgX0wTSKVMrVpOnS0AlO/gPbENQH6TmrMRXyO+Vr7P9+VQ0QqA2tGR72EL9VkIAFCuKr1oW6W3n9pQ9cnVX375Zfjiiy8alwcOHBh69eqV8fOHDBnSbDlWr95yyy073K64nZROnTqFoUOHdqhN7b1GVIjXqHRdOnUKPx+xUjj3hXeT5Xg73tcWUxMAUM4kSQLZyrRCqelVS1fpMNNqswAAkK8ZB1IMsgSgmHwPCwAAlJOqT66eOHFis+Vll102q+cPGjQo7fZyEZO9Z82a1bi8xBJLhO7du+e9TR9++GHa56XTo0ePMGDAgDBt2rRkecaMGcnteF+1mD17dvJ7s4G9w10j113k/rZ8d6m+4Xs7rB9m17f++JzZcxpvf1k3Pxz02BuLPD57YesJEl27dg3durXeoT1nzpxQX9/Gi7ajS5cubR5jc+fODQsXLmz9Necu2s6m7Y+V4OOxku1225Nuu/PmzQsLFuRW7SUOZOjZs2erj9XV1YX587ObLqOptgZtxG3Gbed7u3EfxH2Rq7gf4v7I93bj3y3+/VqKx0I8JnIVj994HLcU/yfi/0a+t5vJuSCd+H8c/5/zvd1yO0e0xzmisOeI1s7RmSZJ9unaOfxs2JCw3XJLtPq4c0T+zxGt/b3Sbbe19afMmBXmpJmKuUvXLsk5orUvv9s6R8TEzfYqwXTu0rnZOSLO8pFuMBrlobVjNNPjMN30qpsP7JNz1TqfY9nFuvdP/iJc+uqk8NX83D6HmxLrNhDrfkOs20Cs2/wckU38Efs72tM01s0ltunZq+H6vWVs43q4gevh9LFuJnFuy1hXnFt+quHzqrXz33Vbrhn6tzj/tbzuampe0jfTfLuZ9juniz17h4WhZxv91Cl1c+eH1not9N9+Q/9tA/23DVz3Oke05ByR/Tkifg+7+TbrtBvLtfZZWG1xRC79t2Lawmj5d+9WXx8GdO8aps1riKXi7W4L6sLs2fPL+njKhO8MG8gr+IbvDBvIK3COaMo5onTniEz7ltvSrXu3NuPSuXPmJsWmcvketBbOEfNrNK+g6pOrmyYxpxKZs9EymXjmzJklb1PL9dtqU8v7c3mdVHJ1qt3ZJld/8sknaR9vuv1iu+aaa3J+bqxevu663yRkN/WXv13f2BEwp1PXEJZZr9njN910U+hZ33qn9YYbbhg22mijVh8bM2ZMzvtrnXXWCVtttVWrj40dOzZ89NFHrT7WXvtXWWWVsMMOO7T63EceeSS8+25DRfBsDR48OOy5556tPvbUU0+FV155JaftxuN3v/32a/WxF198MTz33HM5BwuHHXZYq4+9/vrr4bHHHgu5OuaYY1q9P1aTv++++3Le7qGHHtpqp178n/3Xv/6V83ZHjRqVzBDQUjx2b7755py3u8cee4Tllltukfvj/1pH/pe33377sOqqqxb1HBH/h3JNCC+3c0R7nCMKe45o7RydqZiod8GLE8LE+/4VWrskcY7I/zki079X6hzR2vrpvixor8Jwa+eICT2XCM8sNiTUdc7ukiBOzxRn+9hmyKLn+1pSznFuW8doTNHttvR6Wf/NU+IF83V//0foNPurnJ7vcyzzWDf+rf7egb9VS2LdBmLdb4h1G4h1m58jOhJ/tBfr5jO2cT3cwPVwaDPWFedWd0xbaX0zrZ3/7r7lH4v0D6frm7lt7F2L9M1k2u+crm/m8SeeCJ9MeCfkQv/tN/TfNtB/28B1r3NES84RhTtHtNffWg1xRC5xbaX23VZiXLpuj8XDU/2Xb7g9ZUK47tpny/p4ypTvDBvIK/iG7wwbyCtwjmjKOaJ054h89Fun023h/LDxjElh5TlfZPW8aj9HTKjhvIKqT67+6qvmX/y3VaWhLS2r3H799dcdblPLbWRTtbq199BWm1re39H33nJfZqKtDuGUOApirbXWynq7AFDrutfPTxJNMqnG1poY+M7r1LXNAT9UrlSF4ZFDlmxzZG1M3MzlAiiaNrcunPvCuxV9EZQPlRjnxsEUsUMg1789xRPPzx35G8XPh1jpFaBWYhtIEedWf0xL2+bE+LHFpCdf1XdKruGmz819Zj0AqBRNP++S5OsczZxfn3x+tjZDYLnHtZXad1uJcemKc6eHFadOL3UzAIA8irFXjMFWnPNFq0XqatHCGs8rqPpvW1uWQO9oInNHSqrnK+k50+Tqlm3N9nVa7qt8vHda7+ROmbmg4WI9KuUFOwDlLwbzsYJfTDTJNcGa8k6ejyNjO1JheGbd/GQ0aCESN6lccaR17BCIx0BbNt1007DW2mslX0iNemBcUdtHx6UqvLqWAIoZf7Q3qKPQsQ2kiHOpZXcstfaid34dwm/ver4UzQGAomvWj5XjrI/RPyZ8FcKE51udIbBYxLUAAA1iv3NHis5lS5G65ubVeF5Bzb3zTp06dWj9+vr6smtTOb/3Rx99NO3jsYz86aefHkKtd3L/n398tDCEjxo6u7O5YI+52ukSZGYtbBgN0pqv6zu1OXo7SQQHoGzFz4hYwS8mmjQVp0p/5OFHFjmnp/sMoryUc4Xh1PQ9ta6S49x4fKWrWt+vayfJa2Vot09fCz0Xtv136794//D973/fIE2g6PFHJoM6yjm2gVqOcys5pi0H8xfWN7se/zp0XqSfVf8qAFSuSpxFp1JjWnEpANCWGIcpOleZBlRobNpUp/pCZAuXkQcffDAcc8wxjcvbb799uOyyyzJ+/sMPPxyOOuqoxuWRI0eGyy+/vENteuONN8Luu+/euDxs2LAwZsyYjJ//5ptvht12261xee211w633XbbIuvtscce4fXXX29cvvPOO8Pqq6+e8evstdde4dVXX21cvv3228Oaa64Z8unzzz8PP/nJT5LbV111VRg4sHhl4DtSiTtOPdS1a9d2tzt97vywx0Ov5Pw68QvK+3bZMPmgmDNnTqsJ7vdP/iJc+uqk8NX8Nsph59m/tlknLN6j4b137ty5zYroc+fODQsX5tamdNudN29eWLAgt9FIccBAz549W32srq4uzJ/fdrJKe3r16tXq/XGbcdv53m7cB3Ff5Cruh9YGXHR0u/HvFv9+LcVjIR4TuYqV9Lt06bLI/fF/Iv5v5Hu7xTpHZCtuM267NW2dIzIR90FbMzsU6n/ZOaL454jWPpOantObco7I/zmitf1/7y4bLJLA2nK78cv6TEbhflk3Pxz02Bttbr/lOaK19ly35ZqhfysVJzt36dzsHLFY966hS46D/WpJKePcfH2OxcF5O7SoctfWeSMTPscyj3WzOWeniHW/4XOsgVi3gVg3+3NEpvFHylKL9W010aC1WDcfsY3r4Qauh7/RNNbNJs5tGeuKc6szps33dlMx7T0TP815JqnW4rpsP6/i+XT3B1/OuU849jvfMXK90Dnk1pek//Yb+m8b6L9t4LrXOaIl54jCnSPiZ+EeD74SZs0vfAXDpv2sxfqOJ9f+22qNacWli/KZ00Bc+g2fOQ3Epc4RTTlHVNc5IsZ/X86dF+bNzX273bp3WyQubW0m32y/D63m72Om13heQdWXiundu3ez5WyT+1qu33J7+ThhZXsyybRNLV+no++9T58+oZq09cGRz+1261HfoakJmk5729qXoPGD47LXJhctsTrq2atn6JXBNLxtJYx0VFtfMnRU/NBo64OjI+IHUlsfdB0RP5QLcQwXarsx6CnEdmOQVoz/5UrYbluJEh1VqP9l54jinyPmdK7L+Zyebrv5UAvniNb2f6bb7ZfB83q2MUNFW+eI1tqzzGJ9VSuuIoU69ud07pJR9b04RVc2FX18jjWPdfNxzm5KrNvA59g3yuXzMVPOEcW/Hs4k/sg11u1obON6uPxi3XI6R4hzq0u5HouxTzbXxOpc4rq2+lB+vv7KObUjNeNAn16F6UvSf9vA51UDn1ffENM6RzTlHJGfc8To9Vfq0GdyOV/3imvLS7nGpW3xmdNAXNrAZ04DcalzREvOEZV3jojfOw7s1SOE+FNgHflOrtriiDk1nldQ9cnVffv2XWQqw2x88cUXzZb79ev410stt5Ftm1qu31abOvo6Ld97y31J6acmiInXxewwiB3vMVEGgOoQR2FmItskSaB6tRy53V7Cxo7LLxUqfXr3fHNOBQCobB3pk81n/2qMtUcOWTLr2FU8CkC1yPWzMJ3WKhcCAAC1qeqzJFdYYYVmyx9//HFWz//kk0+aLQ8dOrTDbVpiiSWSROVZs2Y1TmMTq1dnOiqm5Xtoq03LL7982vfSXtXqpsnVMVF7wIABGT+f3C7sy/mCPZUgI7kOoHrUQpJkuSRVZprIXqzXLEV7qC0x2SQOMIxxcCXFjx2Z3j1TtXROBcinQsUvkgyBSu5fjduqlUpBANAan4UAAOSbvmhqJrm6f//+STJzKlH4s88+C7Nnz864NPqkSZOaLa+88sp5addKK60UXn755eR2fX198jqZbjvTNsXXaOrDDz/MuH2Fet+1qpgX9jePHB4WL8Br+bIRoHZVapJkOSZVFlO5DtiicsT4LyaA5Po/EZ8XBytUSrJHR6d3z1StnFMBKiW2MegFKFafrP5VAKhe2RbtEBcAAJQvfdHUTHJ1tOqqq4Znn302ub1w4cLwyiuvhA033DCj544bN26RbeXDaqut1phcHY0fPz7jBOZM2xRfI93z0ontaWqVVVbJ+LmUVuzEr5QEFgCKp9aSJMs1qRIqSUz8jZX1auV/oyPTu2er2s+pAJXEoBcgH/TJAkDtVi68d+Kn4ZLxH2S1TYM8AQBqj77oylMTydWbbbZZY3J19Pzzz2eUXP3JJ5+EyZMnN6sEPXjw4Ly0adNNNw1jxoxp1qY99tij3efNnTs3SQ5P6dOnTxg+fHir644YMSL07t07fP3118lyTOaeN29e6N69e7uvE9vT1Oabb97ucyj+BXuhpiEAoPrUWpJkOSdVpjrPY8J7uSTP57s9VI8dl18qqbCcSeWdGJuqmA5AOcQ22TLoBQAAaEsh+rsk1gAAlAd90aRTExkUW2+9dbjkkksal++8885w1FFHtfu8O+64Y5Ht5MtWW20VunbtGubPb0hSuP/++8Npp50WevTokfZ5Dz74YGOydLTFFlu0mSwd749J0XHbUXxefP5OO+3UbgJ36jlRt27dwpZbbpnV+yN/JKgAkC+SJMtDqipJTHgvh+T5QrSH6hKPjVqtsJzJ9O6ZkHgOkB0DAwEAgGpnkCcAQOnpiybUenL1GmusEVZfffXw1ltvJcvvvvtuePTRR5ME57bMmTMn3Hzzzc3u22WXXfLWpv79+yeJ0Y888kiy/OWXX4Z//vOfYb/99mvzOfX19eG6665rdt+uu+6a9nVim5smSsfn77jjjqFTp7aTZ2699dYwY8aMxuW4n/r165fR+wIAylstJ0mWKqmytdGvhUhkziZ5vhjtgWpgeneA0sk1tsmEQS8AAEA5VC4EAKD09EVT08nV0bHHHhuOO+64xuWzzz47jBgxIklybs1FF10UJk+e3Li87bbbhrXXXrvN7Y8ZMyaccsopjcsbbbRRuOGGG9K26ZhjjmlMro4uvvjiJJF5ueWWa3X9mBg9btw30w7F9myzzTZpX2O77bZLksvffPPNZPmll14K119/fTjooINaXX/SpElJO1JiEnbcd1TGBXt8btwGAFCbSZWS5yk3MXmtHBhEAFCZxDYAAECxr0FynSEwOn69FcIOyy/V6mMGeQIAlC990bSmZrIwY5Lx+uuvH1588cVk+cMPPwwHHHBAuPDCC5Pk45SZM2eGSy65JPztb39rvK9Hjx7h+OOPz3ub1l133bDzzjuHu+++O1mO1aJj5eqY2L3BBhs0rjd37txwzTXXhEsvvbRZ0vPPf/7ztBWoU+uNHj06HHHEEUnl6+i8884Ls2fPDoccckjy3lKee+65ZN24D5pWxl5rrbXy+r4pzAV7TKyOz1V5EoBKS5KU9AjVa9QD3wwOLaVUrBxHnlfCObVcktIBAFjUYt27JgNxp/1fzBZvx/sAgOpghkAAACCqmR6/mGQck5P33nvvMHXq1OS+t956K+y+++5h2LBhYejQoWH69Olh/Pjx4auvvmr23HPOOSesttpqBWlXrKD99ttvJ22JPvnkk7D//vuH1VdfPay00krh66+/Dq+88kqYNm1as+f97Gc/C5tttllGr7Hlllsm1ad///vfJ8sxyTpWp46VsNdZZ53Qq1evMGHChKQdTcWk6jPPPDNv75XMuGAHoNaSJMsx6RGoLnHgYhzAOHLIkmUzGLFcEs8ByG5gSy0NDJy/sD7MrJsfKokBShRDl1j4ZMRK4dwX3k2W4+14HwBQPVQuBACgmvuiM+37nV7jBaFqJrk6WmaZZcJf/vKXcNxxx4X33nuvMdE4Ji/Hn5ZiVedf/vKXYbfdditYm/r06ROuvvrqpDL2Sy+91Hh/TLZOJVw31blz53DkkUeGo446KqvXOeaYY0JdXV3yWgsXLkzu++KLL8Jjjz3W6vqxyndMRu/du3fW74mOc8EOQC0px6RHIHvxAj8OlshlytRiiO2KnQSxsiAA5DropVYGBt4z8dOcp0KHWrDNkIHJDwBAR7SVrFLrSSwAANWs1H3R+n4zV1PJ1VGsCH3bbbeFK664IowZMyZ8/vnni6zTrVu3sPnmm4cTTjghrLHGGgVv07LLLhtuvPHGcM0114Sbb745TJ48udXK2xtvvHFSgXrDDTfM+jXi8+P7+c53vhMuv/zy8OyzzyaJ5S0tt9xyYdSoUeGwww4LXbp0yfk9AQCVrdhJkpIeofLFwRHxAl8iVv7PqfG5cRsAlF4tDAyMVUt8ngMAQOGZ2QwAgGL2Rev7zU5Nfjvbq1evMHr06KRa9AsvvBAmTZoUPvvss6SK9KBBg5KqzUsssURW29xrr72Sn1x17do1HHHEEeHwww8P48aNCx988EGYOnVq6NmzZ1Jxe911102SsDtqo402Ctdff3346KOPkmrdU6ZMCXPmzAlLL710WGGFFcLw4cOTRGwAoLZJkgRyEUdOxwv8TKaRKrRY4adcvqDqyDk1NSq9WhP4ACpx0Eu1DwyM761aKlYboAQAAAAAlEq59UV3tO+3b40VhKqdd9pGQnNMNo4/5SImNo8YMSL5KaTBgwcnPwAApUiSLKekRyC/YhJwtSableKcGjsoJFYD5JeBhLXBACUAAKolsabWklgAAKpFNfVF963BglAicAAA2g4WJUkC5O8C3DkVoCIHvRgYGMLNI4eHxSts8JQBSgAAVENiTS0msQAAVJNy74vOtO+3Xw0WhJJcDQAAQE2IHRK5PAZAdTLoJXOxc93MFAAAUPyZzWoxiQUAoNqUc1+0vt+2Sa4GAACgJhR7pDcAAAAAVEpiDQAA8A3J1QAAlIVSVo1VsRYAgHKIH7OpSjd/YX1WFe8yJTYGAAAAACgP+eyv1febHcnVAACUBRVlgXwnp/Xt1iXMqluQ0/Pjc+M2AKCYsWv8/Bk9YqVkuvB07pn4abjwpfdy/pwDAAAAAKD8yaMonc4lfG0AAAAoiFj1MyanxSS1XBPbMq0cCgD5EpOlY9J0rErdlviYxGoAAAAAACgcZbgAAKi4irKFpmItVIdY9XPkkCXDzLr5WZ+jJFYDUKrYNb5O/Owa0KNbq4/Hx4oZR4uNAQAAAACqry9a3296KlcDAFBRFWULTcVaqL7zTUxOy+ZHYjUAlRK7FprYGAAAAACg+vqi9f22T+VqAAAqqqJsoalYCwBAMWPX6XPrwqgHxnVoGzePHB4Wb6PSdUeIjQEAAAAAqi+PQt9v+yRXAwBQ8oqyAABQ7so5do2J1eXaNgAAAAAAqqMvupZ0LnUDAAAAAAAAAAAAAADKgcrVAGcYQ+0AAJ0LSURBVAAAAABlZPrcupweAwAAAAAAOk5yNQAAAABAGRn1wLhSNwEAAAAAAGpW51I3AAAAAAAAAAAAAACgHEiuBgAAAAAokX7duoa+3brk/Pz43LgNAAAAAAAgPyRXAwAAAACUSNfOncLoESvllGAdnxOfG7cBAAAAAADkh5ImAAAAAAAltOPyS4WRQ5YMM+vmZ/W8WLFaYjUAAAAAAOSX5GoAAAAAgBKLSdIDenQrdTMAAAAAAKDmda75PQAAAAAAAAAAAAAAEILkagAAAAAAAAAAAAAAydUAAAAAAAAAAAAAAP+nc+oGAAAAAAAAAAAAAEAtk1wNAAAAAAAAAAAAACC5GgAAAAAAAAAAAACggcrVAAAAAAAAAAAAAACSqwEAAAAAAAAAAAAAGqhcDQAAAAAAAAAAAAAguRoAAAAAAAAAAAAAoIHK1QAAAAAAAAAAAAAAkqsBAAAAAAAAAAAAABqoXA0AAAAAAAAAAAAAILkaAAAAAAAAAAAAAKCBytUAAAAAAAAAAAAAAJKrAQAAAAAAAAAAAAAaqFwNAAAAAAAAAAAAACC5GgAAAAAAAAAAAACggcrVAAAAAAAAAAAAAACSqwEAAAAAAAAAAAAAGqhcDQAAAAAAAAAAAAAguRoAAAAAAAAAAAAAoIHK1QAAAAAAAAAAAAAAkqsBAAAAAAAAAAAAABqoXA0AAAAAAAAAAAAAILkaAAAAAAAAAAAAAKCBytUAAAAAAAAAAAAAAJKrAQAAAAAAAAAAAAAaqFwNAAAAAAAAAAAAACC5GgAAAAAAAAAAAACggcrVAAAAAAAAAAAAAACSqwEAAAAAAAAAAAAAGqhcDQAAAAAAAAAAAAAguRoAAAAAAAAAAAAAoIHK1QAAAAAAAAAAAAAAkqsBAAAAAAAAAAAAABqoXA0AAAAAAAAAAAAAILkaAAAAAAAAAAAAAKCBytUAAAAAAAAAAAAAAJKrAQAAAAAAAAAAAAAaqFwNAAAAAAAAAAAAACC5GgAAAAAAAAAAAACggcrVAAAAAAAAAAAAAACSqwEAAAAAAAAAAAAAGqhcDQAAAAAAAAAAAAAguRoAAAAAAAAAAAAAoIHK1QAAAAAAAAAAAAAAkqsBAAAAAAAAAAAAABqoXA0AAAAAAAAAAAAAEELoWqt74eOPPw6vvPJKmDJlSpg9e3ZYZpllwoorrhjWXXfd0KlTp6K3J7bjrbfeCpMmTQozZ84MnTt3Dv379w9DhgwJw4cPD7179y56mwAAAAAAAAAAAACgltRccvWzzz4brrjiiuT3woULF3k8JjOPGjUqHHrooaFLly4Fa8e8efPCf/7zn/Dwww+Hp556KkyePLnNdWM7tthii3DwwQeHTTfdNKvX+eUvfxluu+22nNq42mqrhbvuuiun5wIAAAAAAAAAAABApamp5OqLL744XH311a0mVafEytEXXnhheOihh8Kll16aVLTOt5deeikcfvjhYcaMGRmtv2DBgvDvf/87+dlzzz3DaaedFvr06ZP3dgEAAAAAAAAAAABALauZ5OrLL788XHXVVc3uGzBgQBg2bFjo3bt3mDBhQnjnnXcaH3vxxRfDkUceGW666abk8XyaNm1aq4nV/fr1C6uvvnpYcsklQ6dOnZJE79dffz1Jrk6JVahjles///nPoUePHnltFwAAAAAAAAAAAADUsppIrn7ssceS5OqUmLh8/PHHh0MOOaRZgvKzzz4bRo8eHaZMmZIsx8TmM844I/z2t78tWNtigvcee+wRdtpppyTRu0uXLs0ej22JFbT/+c9/NmvnBRdcEE499dSsXy9W5M5Ut27dst4+AAAAAAAAAAAAAFSqqk+urq+vDxdeeGHyO+WUU04JBx100CLrbrTRRuHGG28Me+65Z5g5c2Zy3x133JEkYa+11lp5bdfSSy8djj766PD9738/dO/evc31lllmmXDuueeGFVZYIfzud79rvP9///d/w4EHHpjcn40hQ4Z0qN0AAAAAAAAAAAAAUK06hyp3//33hzfffLNxecSIEeFHP/pRm+sPHTo0nHDCCY3LMSm7adXrfBg+fHh44IEHwr777ps2sbqpI488MnzrW99qXJ4/f364995789ouAAAAAAAAAAAAAKhlVZ9cfddddzVbjhWrO3XqlPY5e++9d1hsscUalx999NHGStb5sMQSS4SePXtm/bwf/vCHzZafe+65vLUJAAAAAAAAAAAAAGpdVSdXz5s3Lzz++OONy7179w7bbrttu8/r0aNHGDlyZONyXV1deOyxx0Kprbnmms2Wp06dWrK2AAAAAAAAAAAAAEC1qerk6pdeeil8/fXXjcvrrrtu6N69e0bP3WCDDZotP/HEE6HUunTp0mx5/vz5JWsLAAAAAAAAAAAAAFSbqk6ufvvtt5str7feehk/d/jw4c2W33nnnVBqEydObLY8cODAkrUFAAAAAAAAAAAAAKpN11DF3nvvvWbLQ4cOzfi5Q4YMSbutUnjwwQebLa+zzjpZb+Occ84JL7zwQvjoo4/CrFmzQt++fcMSSyyRbGvjjTcOO+ywQ+jTp08eWw0AAAAAAAAAAAAAlaGqK1d/+OGHzZYHDRqU8XN79OgRBgwY0Lg8Y8aMMG3atFAqn3/+ebj33nub3bf11ltnvZ0bbrghvPrqq8l7qaurS36/++674fbbbw+/+tWvkm1effXVYeHChXlsPQAAAAAAAAAAAACUv6pOrp45c2az5VihORst14+Vnkvl/PPPD19//XXj8rBhw8KGG26Y99eZPn16uOiii8Jhhx0Wvvzyy7xvHwAAAAAAAAAAAADKVddQxZomI6eqUWejZ8+ezZa/+uqrUApjx45NKkundOrUKZxyyilZbWPVVVcN3/3ud5Ok7BVWWCH07ds3zJ49O3z00UfhmWeeCbfddluzZOonn3wy/PSnPw3XXHNN6No198Pkk08+Sft4KauBAwBArsS5AABUOjEtAADlQFwKAEA5qurk6pg83JHk6u7du6fdXjG8/fbb4X/+53+a3bf//vtnXLV6iy22CAcccEBYZ511Wn18zTXXDFtvvXWSSH322WeHf/3rX42PxaTrK6+8Mhx33HE5t3+rrbZK+3i3bt3CWmutlfP2AQCgFMS5AABUOjEtAADlQFwKAEBNJld/8MEHi1SQzrfll18+9OnTp931YsXnbLRcv76+PhTTZ599Fo488shm+y9Wnj755JMz3sbOO++c0XqxkvX555+fJKD//e9/b7z/2muvDQceeGAYMGBAlq0HAAAAAAAAAAAAgMpS8OTqX/7yl+GFF14o6GvEBODNNttskft79erVbHnOnDlZbXfu3LnNlnv37h2KZdasWeGII44IkydPbrxv6NCh4Y9//GPWFbizceqpp4bHH3+88XVjYvfYsWOTatm5ePTRR9M+Pm3atHD66afntG0AACgVcS4AAJVOTAsAQDkQlwIAUJPJ1aXUMrm6ZbJ0e1qun0l17HyYN29eOProo8Orr77aeN9SSy2VJJHH34XUvXv3cMABByRVrFOefPLJnJOrBw0alPbxbt265bRdAAAoJXEuAACVTkwLAEA5EJcCAFCOOocq1q9fv0WqJGfjiy++aLbct2/fUGgLFiwIJ554YnjmmWca7+vfv3/4y1/+klSuLoaWVcDffvvtorwuAAAAAAAAAAAAAFR15erLLrss64rR2WqrmvPyyy/fbPmTTz7JeJuxzU2Tq2Oi9oABA0Ih1dfXh1NPPTU88MADjff17t07XH311WGNNdYo6Gs3tdxyy6VNMgcAAAAAAAAAAACAalTw5Oq2Ep+LYaWVVmq2/OGHH2b83EmTJjVbXnnllUOhnXvuuWHMmDGNy927dw9XXHFFGDFiRCimHj16NFueM2dOUV8fAAAAAAAAAAAAAEqhc6hiq622WrPlcePGZfzc8ePHN1teZZVVQiFdeuml4frrr29c7tKlS7j44ovDZpttFopt2rRpzZYXX3zxorcBAAAAAAAAAAAAAIqtqpOrY8Xn3r17Ny6//PLLYd68eRk99/nnn2+2vPnmm4dC+etf/xquvPLKxuVOnTolVay33XbbUApxPzW19NJLl6QdAAAAAAAAAAAAAFBMVZ1c3b1792ZJ0V9//XV48MEH233e3Llzw/3339+43K1bt7DlllsWpI3//Oc/w29+85tm95122mlhjz32CKVyzz33NFvecMMNS9YWAAAAAAAAAAAAACiWqk6ujnbZZZdmy9ddd12or69P+5xbb701zJgxo3F5q622Cv369ct72x544IEkkbppe0488cSw//77h1IZP358GDt2bLP7vvvd75asPQAAAAAAAAAAAABQLFWfXL3ddtuFNdZYo3H5pZdeCtdff32b60+aNClcfPHFjcudOnUKxx57bLuvs/XWWyevk/p55pln0q7/1FNPJYnUCxYsaLzv8MMPD0ceeWTIl1tuuSV89dVXGa//zjvvhGOOOSYsXLiw8b4RI0aETTfdNG9tAgAAAAAAAAAAAIBy1TVUuZgcPXr06HDEEUc0Vog+77zzwuzZs8MhhxwSevTo0bjuc889l6w7c+bMxvt23XXXsNZaa+W1Ta+++mo4+uijw7x58xrv22abbcKoUaOS5O5sDBkypM3H/vCHP4SLLroo7LHHHmGnnXYKw4YNC126dFlkvS+//DLcfPPN4aqrrgpff/114/3du3cP//M//5NVewAAAAAAAAAAAACgUlV9cnW05ZZbJtWnf//73yfLMck6Vqe+7rrrwjrrrBN69eoVJkyYEN5+++1mz4tJ1WeeeWbe2/Pwww83S2KOHnrooeQnW2+++Wbax6dNmxauvfba5Kdnz55h9dVXDwMHDgx9+/YNc+bMCR999FF44403mlXQjmIS9vnnnx/WW2+9rNsEAAAAAAAAAAAAAJWoJpKro2OOOSbU1dWFq6++OixcuDC574svvgiPPfZYq+uvv/764dJLLw29e/cO1SImU48fP77d9ZZddtlw4YUXhg022KAo7QIAAAAAAAAAAACActA51IhOnTqFE044IalWvfHGGyfLrVluueXCSSedFG688cawzDLLhEp21FFHhW222SYMGDCg3XXj/lhzzTXDGWecEe655x6J1QAAAAAAAAAAAADUnJqpXJ2y0UYbheuvvz589NFH4ZVXXglTpkxJKjovvfTSYYUVVgjDhw9vM/E6nYcffjjjdX/6058mP4W2zz77JD/RJ598EiZMmBA+/vjjMH369DB37tzQo0ePsNhiiyVJ5PF99+/fv+BtAgAAAAAAAAAAAIByVXPJ1SmDBw9OfmrFoEGDkh8AAAAAAAAAAAAAoHU1m1xNeViwYEHj7WnTppW0LQAAlLfFF188dOnSJVQCcS4AAJUe54ppAQAoh5hWXAoAQCniUsnVlNSMGTMab59yyiklbQsAAOXtqquuCgMHDgyVQJwLAEClx7liWgAAyiGmFZcCAFCKuLRzXrYCAAAAAAAAAAAAAFDhOtXX19eXuhHUrnnz5oWJEycmtxdbbLGiTH85derUsM8++yS3b7nllrD00ksX/DWpbo4pHE+UK+cnqu14Ktfp0sslzi2XvxPVw/GE44ly5fxEtR1P5RrnimmpBuXwP071cDzheKJcVXtMKy6lGpTD/ynVw/GEY4pyNrXEn3n5jEu75mUrkKPu3buHVVddtaj7r66uLvmJBgwYUJZTblJZHFM4nihXzk84nmorzo383+N4olw5P+F4olw5P7VNTEs18D+O44ly5fyE4ylz4lKqgfM+jifK2f9n7z7ApKru/oGfXXpvKiigYgODCCZiiy0qthgVo6/YNUYx0Rg1xFfzRt8U3xhbLFFjTERFTUhiMHZjjcQSS6SIGgE1IqhgASlSFtj/cy7/newuO7OzuzOzszufz/PM49y57cydM3cO7vf+boUsHfpTncrrfhkAAAAAAAAAAAAAoLQIVwMAAAAAAAAAAAAACFcDAAAAAAAAAAAAAKyjcjUAAAAAAAAAAAAAgHA1AAAAAAAAAAAAAMA6KlcDAAAAAAAAAAAAAAhXAwAAAAAAAAAAAACsU1ZZWVn5/58DAAAAAAAAAAAAAJSs8uZuAAAAAAAAAAAAAABAMRCuBgAAAAAAAAAAAAAQrgYAAAAAAAAAAAAAWEflagAAAAAAAAAAAAAA4WoAAAAAAAAAAAAAgHVUrgYAAAAAAAAAAAAAEK4GAAAAAAAAAAAAAFhH5WoAAAAAAAAAAAAAAOFqAAAAAAAAAAAAAIB1VK4GAAAAAAAAAAAAABCuBgAAAAAAAAAAAABYR+VqAAAAAAAAAAAAAADhagAAAAAAAAAAAACAdVSuBgAAAAAAAAAAAAAQrgYAAAAAAAAAAAAAWEflagAAAAAAAAAAAACAEEJbRwGAUjF48OC083baaadwxx13FLQ9AACQC8a5AAAAAAAAkDsqVwMAAAAAAAAAAAAAqFwNQDF74YUXwosvvph2/ujRo8OAAQMK2qaW6I033giPP/542vn77bdf2HbbbQvaJgCAUmacmxvGuQAAAAAAAORD27xsFQByIAarr7/++rTzd9ppJ+HqLEMnmY5j//79hasBAArIODc3jHMBAAAAAADIh/K8bBUAAAAAAAAAAAAAoIURrgYAAAAAAAAAAAAAEK4GAAAAAAAAAAAAAFhH5WoAAAAAAAAAAAAAAOFqAAAAAAAAAAAAAIB12v7//wIAdXj11VfDv//977BgwYJQVlYWevfuHbbbbruw1VZb5fR4ffrpp2HGjBnJfxctWhRWrFgRunfvHnr16hUGDRoUBg8enOy/WFVUVIQ5c+aE+fPnJ8dq8eLFyXtYvXp16Ny5c+jSpUvo0aNHctw233zzUF7u5hkAAM3JODc7xrkAAAAAAAClp6yysrKyuRsBANGkSZPChRdemLODMWHChLDzzjunpmNAOZ2ddtop3HHHHcnzpUuXhvHjx4e//OUvYd68eXUuP2DAgHDmmWeGww8/vNFB4Q8++CBp49/+9rfw9ttvZ1w2hqz32GOPcOqpp4YhQ4ZkXPaFF14IJ554YsiVSy+9NBxxxBE1XouB82eeeSZMmTIlvPHGG+Hdd99NgtTZ6NSpUxg5cmQYPXp02G+//UL79u1z1lYAgGJknJuecS4AAAAAAADFRuVqAKgVTB43blxSfTmTuXPnJkHwp59+OlxxxRUNCgjH8Pb//d//hfvuuy/rQPLChQuT5e+///6w//77hx//+MdJEKW5/OY3vwl33313o9Zdvnx5mDx5cvLYbLPNkmMRw9YAAOSPcW52jHMBAAAAAABoXKlNAGiFHnzwwaQydH3B6uoeeeSR8NOf/jTr5V977bWk2nWsXphtsLq6eMOJv/71r+HrX/96eP3110NLFyten3DCCeGhhx5q7qYAALRaxrmFZ5wLAAAAAADQcglXA0AIYdasWeH8888PFRUVDT4ef/zjH8OLL75Y73JvvfVWOPnkk8N7773X5GM+b968cMopp4Q5c+aEli4Gxi+44ILwxhtvNHdTAABaHePc5mOcCwAAAAAA0DIJVwNACGHhwoWNqiRdZcKECRnnL1q0KJx22mlh8eLFOTvecZvf+ta3wvLly0NLt3LlynDttdc2dzMAAFod49zmZZwLAAAAAADQ8rRt7gYAQJUtt9wyHHfccanp6dOnh1dffTXtAdpvv/1C3759087PNC+TXXbZJZx44olh8ODBYe3ateHvf/97uO6665Iwczp/+9vfwooVK0LHjh3rnP/rX/86qTadTnl5eTjkkEPCwQcfHLbaaqvQoUOH8NFHHyX7vvXWW9Pue/bs2eGOO+4Ip59+eo33Xf04vv322+H5559Pu+9dd901bLHFFhk/l0zzhg8fHrbddtswYMCAsPHGG4cuXbokxyG+p3hMPvnkkzBz5szwxBNPhKeeeirttuK8f//732HzzTdPuwwAQEtknGuca5wLAAAAAADQcpRVxnuUAkAR+uUvfxmuv/76jNWid95556y3F8PS9TnppJPCD37wg/Ve/9e//hWOPPLIUFFRkXbdiRMnhh122GG91xcsWJAEwWPVurp06tQp3HTTTUmouy4ffvhhOPbYY9OGs3v27JkEl7t27Vrn/EmTJoULL7wwbbsvvfTScMQRR4SGePnll5MQ98CBAxu03h/+8Idw8cUXp53/4x//OIwZM6ZB2wQAaGmMc9cxzgUAAAAAAKAYlTd3AwCgWAwdOjRccMEFdc4bMmRI+PKXv5xx/XfeeafO1x999NG0weronHPOSRusjvr165cxHB2rWj/77LOhkHbccccGB6uj0aNHZ5z/z3/+swmtAgCgLsa52TPOBQAAAAAAoK1DAADrfPOb3wzl5emvO4oB67/97W9p5y9evLjO15955pm067Rr1y4cddRR9X4Eu+66a8b5MVx9wAEHhOawZMmSMHny5DBlypQkYP7ee+8lry1fvjysWLEiNOQmGbF6IQAAuWWc2zjGuQAAAAAAAKVJuBoA4q0cysvDXnvtlfFY9OrVK+P8pUuX1vn61KlT065TUVERvvjFLzb5M5gxY0YotDlz5oRrr702/PWvf03eRy6kC6gDANA4xrkNZ5wLAAAAAABQ2oSrASCEMHDgwNClS5eMx6Jjx44Z59dVoXnNmjXhs88+y/sx/uSTT0IhPfTQQ+H888/PWai6voA6AACNY5zbMMa5AAAAAAAACFcDQAihZ8+e9R6Htm0b/rO5aNGisHbt2rwf408//TQUyuTJk8N5551XZ5i8qfKxTQCAUmacmz3jXAAAAAAAAKJyhwEAQujQoUNWt1QvVqtWrSrYfn70ox8JQQMAtBDGudkxzgUAAAAAAKCKytUAkOdKgTGUXYjq1YXwj3/8I8ybNy/jMnvttVc45phjwhe+8IXQu3fv0K5duxrzBw8enOdWAgCQb8a5xrkAAAAAAACtlXA1AORRmzZtQo8ePcLChQvrnL/BBhuEZ599tsV8Bs8880zG+UcddVS45JJL0s5fsmRJHloFAEChGefWZJwLAAAAAADQepQ3dwMAIJ2ysrJWcXC23377tPM+/vjj8Oabb7aY4/jhhx9mnH/sscdmnD9lypSctQUAoKUyzi2+42icCwAAAAAAQBXhagCKVseOHTPOX7RoUWgJdt9994zzb7jhhkZvOwaz77rrroIdx6VLl2acv3LlyrTzKisrw29/+9us9wUA0FoZ59bPOBcAAAAAAIDmIlwNQNHq3r17xvn33XdfWLt2bSh2+++/f2jXrl3a+X/961/Dz3/+81BRUZHV9mIY+p577gknnXRSOPTQQ8MjjzzSpOP40EMPhVWrVmW17/q2NWnSpDpfj5/T//3f/4UXXnghq/0AALRmxrl1M84FAAAAAACgGLRt7gYAQDqDBg3KeHAef/zxcMABB4Thw4eHbt261bgt+MiRI8NBBx1UFAe3X79+YcyYMeGOO+5Iu8ytt94annjiiTB69OjwpS99KfTv3z+paLhs2bLw2WefhTlz5oTXX389vPrqq+GVV14Jq1evztlxjNvcd999w4477hh69OgRysv/c+3V1ltvHY455pjU9JZbbplxW3/84x+T6tZHH310GDhwYBKqnj59erj99tvDtGnTsm4zAEBrZpxrnAsAAAAAAEDxEq4GoGgNHTo0tG/fPmNV5Rg6jo+6FEu4Ovr2t78dHn300TB//vy0y8T3ce211+Z835tsskno27dvxn0vWLAgqWBd2957710jXB2nr7/++oz7i9upa1sAAKxjnJsbxrkAAAAAAADkw39KUwJAkencuXM48MADQ2vQu3fv8Jvf/CZ07dq1WfZ/xBFH5GQ7w4YNC7vttluj1z/yyCNz0g4AgJbMODd3jHMBAAAAAADINeFqAIraOeecE3r06BFag8GDB4dbb701DBgwoOD7/sY3vpGz/f74xz8OvXr1avB6O+ywQ7joooty0gYAgJbOODc3jHMBAAAAAADINeFqAIpa//79w/jx48Nmm20WWoPtt98+3HvvveGoo44K7dq1a9K2OnToEA444IDwrW99q95lu3fvngS7t9tuu9BUm266afjtb38b+vXrl/U6u+++e7JOx44dm7x/AIDWwDg3PeNcAAAAAAAAmlPbZt07AGQhBoIffPDB8MQTT4SnnnoqvP7662HBggVh2bJloaKiosUdw65du4ZLLrkknH322WHixInh8ccfD7NmzQpr167NuF5ZWVkSbN5ll12Sxx577BG6deuW9X7junfffXd45plnwqOPPhpee+218P7774elS5c2+DjGz+See+4Jv/71r8Mf//jH8Pnnn9e53Oabbx6++c1vhiOPPDJpPwAANcdUxrnGuQAAAAAAABSXssrKysrmbgQAlLoYcJ4xY0YSGl+yZElYvHhxaNu2bejSpUvo2bNnEozeYostQufOnUOxWbVqVZgyZUp4++23w2effRbatGkTNtxwwzB06NCw9dZbN3fzAABoRsa5AAAAAAAAtDTC1QAAAAAAAAAAAAAAIYRyRwEAAAAAAAAAAAAAQLgaAAAAAAAAAAAAACChcjUAAAAAAAAAAAAAgHA1AAAAAAAAAAAAAMA6KlcDAAAAAAAAAAAAAAhXAwAAAAAAAAAAAACso3I1AAAAAAAAAAAAAIBwNQAAAAAAAAAAAADAOipXAwAAAAAAAAAAAAAIVwMAAAAAAAAAAAAArKNyNQAAAAAAAAAAAACAcDUAAAAAAAAAAAAAwDoqVwMAAAAAAAAAAAAAhBDaOgoAUDzWrl0bZs2aFd55550wf/78sHz58lBWVhY6duwYevToEQYMGBA233zzsMEGGzR3UwEAAAAAAAAAAFod4WoAKALPPfdc+POf/xyefvrpsGTJknqX33jjjcMOO+wQ9tprr7DPPvuE7t27F6SdAABQ3eDBg/N6QC699NJwxBFHOOgAAAAAAAAUjHA1ADSjGTNmhB//+Mdh+vTpDVrvgw8+SB4PPfRQOP/888Opp56atzYCAAAAAAAAAACUCuFqAGgmt9xyS7jqqqvCmjVrfAYAAAAAAAAAAABFQLgaAJrBz372s3D77bc79gAAAAAAAAAAAEWkvLkbAACl5rbbbhOsBgCALGy88caOEwAAAAAAAAWlcjUAFNDMmTPDVVddVe9yu+++e9h3333D9ttvH3r16hXatGkTFi1aFGbPnh2mT58ennjiiTB37tyCtBkAANI57rjjGn1wpk2bFmbMmJF2/lZbbRV22WUXBx8AAAAAAICCKqusrKws7C4BoDStWbMmHHHEEeFf//pXxsp8MXz9pS99KaswyoQJE8Lw4cPDiSeemOPWAgBAfn3ta19LLj5M5yc/+Uk4+uijfQwAAAAAAAAUlHA1ABTIo48+Gr7zne+knd+3b99w9913h4022qhB243XSZWVleWghQAAUBjPP/98OPnkk9PO79mzZ3j66adDx44dfSQAAAAAAAAUVHlhdwcApevOO+/MOP/yyy9vcLA6EqwGAKCluf322zPOHzNmjGA1AAAAAAAAzUK4GgAK4K233govvPBC2vk777xz2GWXXXwWAAC0enPmzEmqUqfTrl27cOyxxxa0TQAAAAAAAFBFuBoACnTb80xGjx7tcwAAoCRMmDAhrF27Nu38Aw88MPTt27egbQIAAAAAAIAqbVPPAIC8mTJlSsb5e+yxR/LfysrKMHPmzDB16tSwYMGCsGTJktCtW7fQq1evMGTIkDB8+PCkkh8AALRES5cuDZMmTcq4zEknnVSw9gAAAAAAAEBtwtUA0Mzh6p49e4YePXqE22+/Pdx5553JbdLT6dSpU/jqV78axo4dGzbddNM8tRYAAPLj7rvvDsuWLUs7/4tf/GIYNmyYww8AAAAAAECzKauMJTIBgLxZtWpVxoDIRhttlASsY8XqbLVp0yacc8454bTTTgtlZWU5aikAAOTP2rVrwwEHHJDxYsLrrrsuWQYAAAAAAACaS3mz7RkASsRnn32Wcf6CBQsaFKyO1qxZE6666qowbty44DopAABagieffDJjsLp///5hv/32K2ibAAAAAAAAoDbhagDIs8WLF+dt2w888EC4+uqr87Z9AADIlQkTJmScf8IJJyR3aAEAAAAAAIDmJFwNAHm2ZMmSvG7/5ptvDm+88UZe9wEAAE3x5ptvhhdeeCHt/M6dO4cjjzzSQQYAAAAAAKDZCVcDQBH54he/GG677bbwz3/+M0ybNi3cc8894Ygjjsi4TmVlZbjmmmsK1kYAAGio22+/PeP8r3/966Fbt24OLAAAAAAAAM2ubXM3AABau2xDIjFYHUMn7du3T732hS98IVx66aWhZ8+eYfz48WnX/fvf/x4WL14cunfvnpM2AwBArnz66afhgQceSDu/vLw8nHDCCQ44AAAAAAAARUHlagDIs65du2a13Lhx42oEq6s7++yzQ5cuXdKuu2bNmvD88883uo0AAJAvEydODCtXrkw7f++99w6bbbaZDwAAAAAAAICiIFwNAHmWTTXpWN06Vq5Op1OnTmGnnXbKuI133323Ue0DAIB8qaioCL///e8zLnPyySf7AAAAAAAAACgawtUAkGcxGN2/f/+My2y66aahrKws4zL1VfOLt1sHAIBi8vDDD4cFCxaknT9kyJCw8847F7RNAAAAAAAAkIlwNQAUwHbbbZdxfseOHbMKaWdSXzgbAAAKbcKECRnnn3TSSQVrCwAAAAAAAGRDuBoACmDo0KEZ5y9fvrzebSxbtizj/N69eze4XQAAkC+vvPJKePXVV9PO32CDDcIhhxziAwAAAAAAAKCoCFcDQAHstddeGef/+9//DmvXrq13mUw23njjRrUNAACao2r1McccE9q3b+/gAwAAAAAAUFSEqwGgAIYMGZKxevXnn38eXnjhhbTzly5dGl566aW088vKysKuu+7a5HYCAEAufPjhh+Gxxx5LOz+GqmO4GgAAAAAAAIqNcDUAFMiRRx6Zcf4VV1wRli9f3uB50fDhw0OfPn2a3EYAAMiFO++8M6xevTrt/EMOOcT4FQAAAAAAgKJUVllZWdncjQCAUrBq1aowevToMHv27IwVrseOHRu233770LZt2/DOO+8kwZTHH38847Z//etfh7333jsPrQYAgIZZsWJF2GuvvcKiRYvSLnPvvfcmY18AAAAAAAAoNsLVAFBAr7zySjj22GNDLq9t2m233cKtt96as+0BAEBTTJw4Mfzv//5v2vm77LJLuP322x1kAAAAAAAAilJ5czcAAErJF7/4xXDWWWflbHubb755+MUvfpGz7QEAQFPdcccdGeefdNJJDjIAAAAAAABFS7gaAAoshqvHjh3b5O1ss8024be//W3o1atXTtoFAABN9cwzz4TZs2dnvDhw7733dqABAAAAAAAoWsLVANAMzjvvvHDdddeFPn36NHjdNm3ahGOOOSb86U9/CgMHDsxL+wAAoDEmTJiQcf4JJ5wQysv97ygAAAAAAACKV1llZWVlczcCAErV559/Hv7whz+ESZMmhZkzZ2ZcdpNNNgn77bdfchv1AQMGFKyNAACQjX//+9/hwAMPDOn+V1O3bt3C008/Hbp06eKAAgAAAAAAULSEqwGgSMyfPz+8/vrrYd68eWHp0qVJRb+ePXuGXr16hW233VagGgAAAAAAAAAAIM+EqwEAAAAAAAAAAAAAQgjljgIAAAAAAAAAAAAAgHA1AAAAAAAAAAAAAEBC5WoAAAAAAAAAAAAAAOFqAAAAAAAAAAAAAIB1VK4GAAAAAAAAAAAAABCuBgAAAAAAAAAAAABYR+VqAAAAAAAAAAAAAADhagAAAAAAAAAAAACAdVSuBgAAAAAAAAAAAAAQrgYAAAAAAAAAAAAAWEflagAAAAAAAAAAAAAA4WoAAAAAAAAAAAAAgHVUrgYAAAAAAAAAAAAACCG0dRRoTmvWrAmLFi1Knvfs2TO0adPGBwIAQItnnAsAAAAAAAAALZPK1TSrGKw+44wzkkdVyBoAAFo641wAAAAAAAAAaJmEqwEAAAAAAAAAAAAAhKsBAAAAAAAAAAAAANZRuRooae+//34YMWJEGDx4cLj00kubuzkUgcmTJyf9IT7uv//+5m4OAECjGetSm7EuAAAAAAAA1K9tFssALUxlZWV4/PHHk2Do66+/HhYsWBA6d+4cNtlkk7DPPvuEI444InmeL6tWrQoPPfRQePDBB8Ps2bPDxx9/HHr06BEGDBgQRo0aFUaPHh169+7doG2+99574Q9/+EP4xz/+EebOnRuWLl2abGPTTTdNtnnYYYeFnj17NritP//5z8Py5ctD165dwxlnnBFKyfTp08OkSZPCiy++GObPn5/0m379+oWddtop6SPbb799Xvf//PPPh3vuuSdMmzYt2X/79u1D3759w+677x6OPPLIsOWWW2a9rU8//TTMmDEjvPrqq8kjPv/oo49S8ydMmBB23nnnrLa15557hl122SXpa5dffnnynenSpUuj3iMAkHutZawbx7T77rtvg/a96667httuuy3r5Y11jXVrM9YFAAAAAACA+pVVxr9Ml6jVq1eHKVOmhHnz5iV/kI/hyhgsjFVsGxr8bKqVK1eGt956K/njfAwJVoU9YzuGDh0aNt9889AaffLJJ6lA60033RT69OnT3E1q8WJI9fzzz0+CoenE8MlFF12UBE9yLfbjcePGJUGXdOLnHKtE77XXXvVub+3ateGaa64Jt9xyS/KdTWeDDTYIl1xySfjKV76SdVunTp0ajj766OR57IfnnntuKAUxEBRDw3feeWcSTqpLWVlZOOGEE5K+1K5du5zuPwbjY/+LoaR04j6/853vhLFjx9a7vTFjxiTn8kwaEq6OYuA8vv/o7LPPDmeeeWbW6wJAZJybH61prJvvcLWxrrFuOsa6AAAAAAAAkFlJVq6OweUbb7wxqdgaq4zVFeqL1Zy++93vhsGDB+etHbES78MPPxyeeeaZJBgYA4/pxGquMUB43HHHJVXRstWYP9hXd+2114YDDzyw0etTWDG0+s1vfjPMnDkz9VqsPrzVVlsl82IIZfHixeHzzz8PF154YSgvLw+HH354zvb/4YcfhpNPPjm5WKEqoDty5MikunQMGMVKxStWrEiex7Dqb37zmyQgksn3v//98MADD6SmY3XquM1evXol39+XXnopLFmyJHket3nDDTdkHbCOoe2oQ4cO4cQTTwylIoaN/vKXv6Sm4+czfPjwJGgdQzjxvBGfx0DysmXLws9+9rOc7buioiKcddZZSV+oss022yQXkcS+8fLLLycVp+Nyv/jFL1LLZ1LV33IpVu+OF9rE43HrrbeG448/vkHnXgAg91rjWLdKvEtGNm3dYostsm6vse46xrrrM9YFAAAAAACAzEouXD1r1qykCunbb7+ddpkY5nviiSeS0HP8o/wxxxyT83bECrmZqrbWVaEtBp1/97vfJbd23n333XPeJlq+n/zkJ6mwSQwhxz6zyy67pObHoOzFF1+cCiv/8Ic/DDvssEPYbLPNcrL/WMWvKmzSv3//5CKGIUOGpObHquznnXdeEjyJ37NzzjknPPbYY6F79+51bi9WVq4erD711FOT72/Hjh1rvKfLLrss/OEPfwhr1qxJtv/II48kFyRk8uqrr6YCvgcccEDJVE2/++67U8HqGDj67//+7yRYHp9XVQqPoep4TOPzP//5z0n4IlfBpNgnqo57DLXHqo5f/epXU/PjRSZVlcqjX/7yl8n+4yOTeFHM1ltvHYYNG5Z6HHbYYU1q67HHHpuEq2N4P/av008/vUnbAwCaprWNdauL7ye2PVeMdY1162OsCwAAAAAAAOmtS9OViPiH8BjOrB2sjhVTY3Xm+If5WDGsysqVK8OPfvSjcN999+W8Le++++56r8XKZ1tuuWXYY489wiGHHJLcRrp24DNWdB07dmx46qmnct4mWrYYNLn//vtT01deeWWNsEkU+/cVV1yRhEyiGPq47rrrcrL/p59+OqkiXRV0/dWvflUjbBL17t07CaEMHDgwmV60aFH47W9/W+f24vcvbqNKvMgh3gK+erC66j3FoE1VhfVYqTAGcutz++23p54fddRRoRTE4PL111+fmo6VH2P1xapgdRSfx9fiubJK7COZKutnK1ZxrH4b+x/84Ac1gtVR+/btk8/54IMPTr0WK1hnEvvUP//5z3DPPfckfSF+nrX7XmPEPlUVhrrrrruS8D4A0Dxa21g334x1jXXrY6wLAAAAAAAA6ZVMuLqysjKpeBsrQFfZZpttwr333hsmTZqUVD2Lf4D+29/+Fo4//vga68aKZ7Hidb7EiqyXX355eO6555Jq1vEP8FdddVW4+eabw7PPPpuEIatX4V29enVS+TrelrqhYoXaWJU720cMeNMy/P73v08qDUdf/vKXk5B+XWJ49vvf/35q+uGHH06q7DVVDJ9WGT16dBg8eHCdy3Xu3Dn5LlaJFYFjn67txRdfDB9//HEqwPKd73wn4/6/973vpZ7HyszxlvDpxErEjz76aPJ8ww03DDvuuGMoBfE7/cEHHyTPu3XrFr797W+nXTbeyj4uE82bNy8JFDVVDD/H8Hu0+eabh6OPPjrtsrGPVoW+p0yZEl5//fW0y8ZgU6yCnWtxm1/5yleS5/F8G+9mAAA0j9Y21s0nY11j3WwY6wIAAAAAAEB6JROujkHKGNCrMmDAgHDnnXeuV20sVim96KKLwgknnFCjgm4MX+dSrFJ9wAEHhAcffDDccccd4bDDDksqndW13KhRo8Ldd9+d3Hq6yvLlyxvVpvj+4nvP9tGpU6dQCmI4oupRZcaMGUlfiJ9TrH43cuTIcMQRRyRV6mJgodguHnjyySdT07GdmXzpS19Kwq1RrMZbfd3GiLdgj7c/z3b/sUpaVZX4WNGvqgpgddOmTatRXb52FffaNt100zBo0KBUlcJM7ymeD+L3Otpnn31qVG6uz3vvvRcuu+yypOJy7BfDhw9P+kiscl+7Iv3PfvazVL+KAeXm9vjjj6eex8rQmb7fcd5BBx2Umo63tM/l/mMfiee3dDbZZJOw66675nT/jRHPv1XycRcDACgEY93iG+vmk7GusW62jHUBAAAAAACgxMPVsfpzdRdffHHo0aNHxiq41cPMMdj3xhtv5Kw98fbU8bHVVltltfxGG20ULrnkkhqv/fWvfw2rVq3KWZuo2V+OOuqo8Mc//jH8+9//TqrtxkrIr732WrjmmmuS0GmhQxKZxDZWr2Qeq6HXp/oy//jHP5q0/3jhQlVfjNX6hg0blnH59u3bhxEjRmTcf1XV6qqgbTaqf2czvaennnoq9bz27eQzue2225JQ9fjx48Ps2bOTfrFixYrk+Mdqil/72tdSAeIYeK+qjh3D4dXb1lxeeOGFZusjMcxePTBf6P03VmxDVfj+73//e3IxAgC0dMa6zT/WzSdjXWPdbBnrAgAAAAAAQAmHq998880wc+bM1PQWW2wR9tprr4zrxKqtY8aMqfHa/fffn7M2NSZoudtuuyXVpKtXUMtl4Jt1JkyYEH75y18mtx2P1ZAPOeSQpDrd9ttvnzpEH330UTj99NPD9OnTi+KwvfXWW6nnG264YRLGr88XvvCF1PO33347Z/vfZpttQtu2bZu8/xhOrpKpwnE6s2bNqvP1+LlWrzwYq3hnI4bqL7300lTF68022ywcfvjhYf/99w+9evVKXovzxo0bl1S3jkHiDz74YL2KcM0lVluP/bau459O9WXmz58fli5d2uj9v/POO8mxr/o8G7r/pvbRxooX4VRdBPPZZ58lFe0BoCUz1i2OsW5tq1evDs8880z49a9/HX7+85+Hq6++Otx+++1JsDvelSVbxrrrH/9sPiNjXWNdAAAAAAAAqK7+vwq3AtUrd0WHHnpoVuvFKrRXXXVVavrJJ58M559/fmhOQ4YMCXPnzk1NL1iwoFnb0xpdfvnloUOHDuGnP/1pOOyww2rMi4HZc889N8ybNy+pWhz7w7333pssX1usZhzDK7k0fPjw9dpUFVxtaJXn6ss1NbjamP1vvPHGGfffu3fv1PN4vLNRfbl07ym+XhUS7tmzZ+jbt2+9233uuefCTTfdlJr+zne+E84888xU6Dve7v3ss89OKkMvX7483HLLLaFjx46p5TOFq3/yk5+EXIrvKbYl02eU7edUe5l47KpfZNAQ1T+PPn361PmdybT/eIw//fTTGv2iUGKIquoCnXgOiN9DAGipjHWLY6xbWwz3nnrqqXXOi2Onk046KZxyyilJVexMjHWz/5yMddcx1gUAAAAAAIASDVc/++yzNaZ33HHHrP8gHitMVwU24x/V33///az/oJ4Pbdq0qTHdkCpmZCce01gp7uCDD15vXgxVxuDs6NGjkxBt7BN33313OO644+oMSNx11105Pewx0F1XuDoGT6uHL7KxwQYbpJ7H9xJvdV5fWCOdxuw/VtiuEisC17bddtulnr/22mvhk08+ybjtOXPm1Ai+xGNV13uKleyrV7HPxg033JCqpL377ruHs846a71AcwwqHXjggcmxfPzxx0O7du2SeYMGDUpVPq5LrvtIPGfVFa5euHBh6nnXrl1rhL8zVfDv0qVLUiU/3eeUrab20aptNEe4esstt0w9d7cAAFo6Y93iGOs2RBwH/+IXvwiPPfZYuPHGGzPepcZY11i3oYx1AQAAAAAAYH3loQTMnj079by8vLxGaLM+tSuUVt9Wc3jvvfcyhg9pupEjR9YZrK4Sw7KxclyVP/3pT81+2GOQuEo2odm6lqsK0BZq/9UrF9e175133jkJ9laFgH75y19m3F71KvOZtlu98nu/fv3qbWe8uOLll19OTZ9++ul1Lhe3tcceeyTPP/roo+RCjGj//fcPxaAxn1HtZatvoxD7r71cU/bfFNWrm1fvPwDQEhnrFsdYt0q3bt3Cf/3XfyVj3XiB3tSpU8Orr76a3H3pyiuvDCNGjEgtG18/44wzkov50jHWNdZtKGNdAAAAAAAAKMHK1bFK2Kefflqj0lisxpqtAQMG1JiOlXH33HPP0BxiyLN61dS2bduGIUOGNGgbL7zwQrKNf/3rX0kFtBg2j1V3Y7XbGLTYZ599wrBhw0Ipq6sydG2xcvVNN92UPI/HMvazHj16rBcOrl45Lp9WrlyZel5VMbk+tSs6V99Gofdf175jdeUTTjghdZx///vfJ2HrWJW5dljlsssuC4888kjGdlX5+OOPU89j36/PtGnTUs9j1eT4PUknnhseffTRGq/tt99+GbdfzH2k9ue0YsWKZu2jTdl/U/Tq1avO/gMALZGxbnGMdaNYgXry5Mmhc+fO682Ld0uKj0MOOSS5i0rVhYbxji7jx48PZ555Zp3bNNY11m0oY10AAAAAAAAowXD1nDlzakxvvPHGDVq/dmXb2tsrpDvvvDNUVlampr/0pS+F7t27N2gbL730Up2V2GKV3Tgv3mZ6t912CxdeeGHYZpttctLulqZ6dbh0Nt988ySYG28RHj+TGFjfZZddQnOpHjaOVZ6zsWrVqrTbKPT+0+07hkbiBQFTpkxJpn/729+Gu+++O+y0005JCCCGR2K/Xbx4cTL/K1/5SlLlr0pV5evqqlf6y6by4FtvvZV6Hi88iBckpDN06ND1zjfbb799KAaN+Yxqf04NqXidjz7alP03RfX9ZqoUCQAtgbFu8Yx1YwC79sVktZWVlYWzzjorvPvuu+G+++5LXrvtttvC2LFjk4ttazPWNdZtKGNdAAAAAAAAWF/6lGArsXTp0hrTsfJsY6s4RUuWLAnNIQY8Y7i6upNOOikv+3ruueeSW1M/9NBDoRRlG8Cvvlz16ujNoXq1u2yr+9Zerq4gcj73X72CX7p9x7DJLbfcEg466KDUazHQHqtD/+EPfwhPPPFEEqyOoZOTTz65xncihqBj9eumilXJq8TqgZlstdVWNaoZ1le1upAa8xnVXrauqor53H/t5Zqy/6aoflELALR0xrrFM9ZtiHj3lipx/Dt16tSQC8a6xrrGugAAAAAAAFCClauXLVvWpOq8tSulxirPhRarnn3ve9+rUf0sVkned999GxQI+PKXv5yst/XWWych81jpbOHCheH1119PwqqxQnD1imfjxo1LKmPvvvvujW77hx9+mHF+3H+x6dSpU4OXq93PCi1W0a7yySefZLVO9VuGx/dSX9W8XO//o48+Sj3v0aNH2uViGOWaa65JwtOTJk0KL7/8cpg/f37yfejbt28YOXJkGDNmTBg+fHgyv/pt1mPoOtPnlk04pnr1v/r6RjyG8fsVv1PRqFGjQrGofqFIvOgkBn7qOx/G9169b2f6nPLdR2tvo5Cqh6OyPT8A0Pq1xHFuZKxbXGPdbA0cODD0798/zJs3L3Xx7Y477rjecsa6xroNZawLAAAAAAAAJRiurh6MjBoaIK0dPqy9vUL43//93/DGG2/UCJtecsklWYeqL7744jB69Og6q74OGjQofPGLXwzHH398UrE6BqqrAgNr1qwJ5513XhK8bmyoca+99so4P1b53XbbbUMxiZ9xNhWPq/eFuqrR/fvf/w4TJkzIadtigPiwww6r83Os8v7772e1rerLbbHFFk1qV2P2/8EHHzRo//EW9vXdxv7VV19NPR82bFidy2y44YYNCj1VD6hUv8AhnapbxceLF+oKvNT2k5/8JORS/K5Wr2xY12cUxWBOfce99mfZlH5Sfd14jskm3F19//F9NfTOA7lSvTJ99f4DQGlriePcyFi3OMe62YgXD1aFq+PdXOpirLuOsW72jHUBAAAAAACgBMPVtdVVybYhyxf6lrm/+c1valTjje2JwepYuSwbMYx43HHHZbXsbrvtFu64445w9NFHhyVLlqRuE33LLbcklbNLRQxCxOrD2SxXV1XgKrG68l133ZXTtsXK6XWFq7fccssaVfLio74QaFV15VwEPqrvf+bMmWH16tVJuLhQ+69Svfr6DjvsUOcyseJfthUno1i9PdtKhbNmzUoeUTwGsQ9ssskmGdfJdR+J76+ucHW3bt2SPlFVRTFesFHfca/+GcUq4dlcdJAplFReXh7Wrl2bnEfj/usLy+ejjzRG/Bzr6j8A0BIZ67bcsW71uyilq0BurGus21DGugAAAAAAALC+8tDK1f6jc/Vb3mZjxYoVNabrqv6cL/fee2+46qqrarwWK0sffPDBedtnDA58//vfr/Ha3Xff3ehQ+dNPP53x8ac//SkUm6lTp9a7TKxKXVUtLgbev/CFL4TmtPnmm4d+/fqlpl988cV616m+zC677NKk/ccgc1VV+Bj6mDFjRsblYwXo6se5qfuvqlodb48etWnTJhxyyCF1LjdkyJDU83feeafe7W611VY1wjSZPPjggzWm33zzzVBMdt555zqD6Om89NJLOfuMYpXqWHm9IX00l/tvirfffjv1vBgrkALQPFriODcy1m2ZY93479L4b5Aq6S6kNNZdx1g3e8a6AAAAAAAAUIKVq2uHoRsarq69fKHC1TGQ8YMf/KBGqPm0004L3/zmN/O+7yOOOCIJdceq1VW3CY4h0ep/qM9W9cBvutulF5sYaj/qqKMyLnPPPfeknsfj0qNHjzqDrIUK18aA9z777BN+97vfJdOx2vlXv/rVtMtPmTIlFc6I1YTjuk3RpUuXsOuuuyb9tmr/maoSP/roo2HZsmXJ83jsRo4cGZrqmmuuST3/yle+klRaTldBOVZxjtXZY0A+VmpLt2w0bNiw1PMY3n733XfDZptttt5ya9asSfpOdf/617+StmRSyAD2fvvtFx544IHk+cMPP5ycYzp27Jg2wBOXqb5uLvYf+15VHzn99NPTLhurij///PM53X9jVQ/VVw+IA1DaWuI4NzLWbZlj3fvvvz/1b9M49k+3TWNdY92GMtYFAAAAAACAEqxc3bVr1xrTCxcubND6MVhcXQxl5tvLL78czj777OR201X+67/+K6laXQgxCFL7j/X1VextTWK13Iceeijt/BhKvv3221PT9QWxC2XMmDFJUDp65plnwrPPPlvncmvXrg1XXHFFavqggw4KvXv3bvL+jz322NTzGDiZNWtWncstX748XHfddanpo48+ut7bqtdn/PjxyXuOYli4dvX16uIxql498J///GfGbQ8cOLBGwLp622sHXt5///31vsvFZN99900FwRYvXhx+9atfpV32xhtvTJapur383nvv3eT9jx49OnWBSqwanqmiZ+yjMbBeVS1y6NChoTnEi0xmz56dCkdtt912zdIOAMgVY93iGOvG6tbxkY05c+bUuKPRbrvtFjbYYIM6lzXWNdZtCGNdAAAAAAAAKNFwde0Ksx988EGD1o/VU2sHLfPp9ddfD2eccUZSNbZ6+PXHP/5xKKQYpswUMm/NYrj8ggsuWK8KcTR9+vTwjW98IwlNRJtvvnk48sgjQzEYPHhw+NrXvpaaPu+889a7HXa8jfl///d/pwLF8b1+97vfrXe7VY8YJEknhm933HHH5HlFRUUYO3bselWZ48UNZ555ZlL9OerZs2dSkT2d2O/+53/+JznudYnbi9+Nyy67rMb7jp9LJtWrSf/jH/8I9YmfeZVY+fnqq69OBX+rKlT/3//933rniRhwf+6550KxiLez/853vpOa/s1vfhPuuOOOGhXyY/g+XjwQ51WJF3vEddM54YQTUn0kfnfS6dOnTzj55JNT05dccsl6FzLEkNGVV16ZqrBd9Zk2lxdffDE5JtEee+wR2rRp02xtAYBcMNYtjrHuggULwqhRo8Itt9yS9t+ocQzy4IMPJgHtqouE4+dX39jIWHcdY936GesCAAAAAABA3coqq6fqWql4C+eqcHCs5PXKK6+ETp06ZbXuueeeWyP8F/9Au+eee+alnW+//XY47rjjagSZY5gvVpct9G3Ff/GLX4Rf//rXqen4B/wYIMi1Tz75JAmTRzfddFMSvmwOMUxRJYZ5q4Kym266aXLL73j8Y/XaadOmpZaLfei2227LeEvwQlu6dGlSwbp6Jb3Yvi233DKZF4PEsTpZlZ///OdJNeFsj82ll14ajjjiiIwXI8Sw+UcffZT6vsUq6DFsHPv1888/nwqmxwp+v/3tb5PvZzpxO7vvvnvyfMMNN0yqBscqfTHQMm/evDBlypQaFd7POuusGuHhdJYsWRK+/OUvJ7dWj9udPHlyqup3OrGfPvXUUzUuQIjvLR7XuH5V5cF4MUQ8R1x44YWpfhJf69WrVzj//PNDMYjtqH7xQLwIZfjw4UnIeurUqeG9995LzYufd/zcM4nh6hjMiGJ/iv0qnfjZffOb36wRat9mm22SytTx84jVNKv6TxQ/z/i5ZvLEE0/UWVE8ht6rxO9yVdXsKvvss0+9FxdUP1Y333xz2GuvvTIuDwDFNs6NjHWLb6w7d+7c5K4iUVlZWRgwYEDYeuutk0B2/LdH3Ef8t0fsR1Xi/mIbDz/88Iyft7GusW5krAsAAAAAAACNt/79iVuhrbbaKhX8i9W/ZsyYkfwRPBvVw7RV28qH999/P6mOWz1YHSujXX/99QUPVkdVldGqxD/yl4oTTzwxCSDfcMMNyS2446O2GMiNt+YupmB11LVr16T6XQyEVoVXY1g2PqqLIdMf/vCH9QarG6pfv35J1ePvfe974Y033ki+b7F6du0K2r17906CIZmC1bXFgEn1cHPtzyOGmb/61a9mta1u3bqFAw44INx3333JdmOgd+edd864zjXXXJNcZBCDvFEMd8dHddtuu21SSbtLly7hT3/6U3IhRwzYxCqIcZ/FEq6OFaNje+66664kUB2rK1ZVWKwSQz7HH398Uuk8l+L5LJ7XLrroovDwww8nr82cOTN51F4uhqqrQmmZxO9r9SB1Xer6HsfPK5MY9q7qc3379k0C+QDQ0hnrFt9YN47H4sVt1S9wqy0GuH/2s5+FnXbaqd7tGesa60bGugAAAAAAANB4JRGu3m233VLh6ujll1/OKlwdK5NVD08OGjQobLLJJjlvX6xGdsopp9S4HXSs4horR3fs2DE0h1dffbXG9EYbbRRKSayWG6sPT5w4Mfzzn/9Mbtsdq8/F6rf77bdfEjrt3r17KEYxBBoraj/22GPh/vvvD6+99loSII6B6th/423CY8W9fPTlKFbJ/uMf/5hUfH/ggQeSit8ff/xxcrxiKCQev69//etJ6KQ+scLjhAkTkqB4/N7GixDiBQgxgBIrWMeLHeL2DjzwwCRY3hAnnXRSEq6OYhC6vnB1/C7eeOON4emnn07Wi1WzY1tixer4XuL6sep5jx49kuXHjx+fVFOOy8b3X0zat2+fhJsPO+ywcPfddyfnx/nz56f6TwztxD6y/fbb52X/MfATw+r/9V//Fe65554k/B/7aPyObbzxxkm18rj/2Jea0yOPPBIWL16cPI93FYjtA4DWwFi3+ce68S4ocawex5RxLBTvPBPHlosWLUrGl/FivfhvsHh3kTh+j4/67rRSnbGusW59jHUBAAAAAAAgvbLKmFJs5d58881w6KGH1viDePxjeH1uvvnmpDpxlVNPPTXnlWfjLZtPOOGEpPJZ9fbdeeedWYVP8+Gtt95KKgBXdY02bdokt7iuCo22xtulV78deOwvlIZ4UcNzzz2XhI1jheIY2IYqY8aMSQJPMQweK5bn4xwIQOtVLOPcyFi3NBnrkomxLgAAAAAAAKSXfemrFiyGCbbZZpsa4eFYfTaTFStWJFWLqzvkkENy2q64j7Fjx9YIVg8YMCDceuutzRasjoHqK664IhWsjkaMGCFUSKv03e9+N/lvrA4YK2RDlZdeeikJVkcnn3yycyAA0OIY65KOsS4AAAAAAABkVhLh6uiss86qMf3Tn/40fPbZZ2mXjxWr582bl5qOt3f+whe+kHb5SZMmJSHuqkesRp1JRUVFcjvuf/7zn6nX4m2fb7vtttC3b9+QC9OmTUtuMZ2ttWvXhssuuyyp4FtdVcU9aG3ihQMHHHBA8vyuu+4KCxcubO4mUSRuuOGG1Hk5Vn0EAGhpjHVJx1gXAAAAAAAAMiuZcPX+++8fdthhh9T0e++9F44//vjw5ptv1lhuyZIlSfC6ehXbDh06hHPOOSen7bngggvC5MmTU9MdO3YMl1xySSgrKwtz587N+rF48eK0+4gVuo8++uhw0kknJeHvTz/9tM7lYpXqWLkqLherZlc3atSosOeee+bwnUNxid/FTp06haVLl4Zf/epXzd0cisDf//738PzzzyfPv//974cuXbo0d5MAABrFWJfajHUBAAAAAACgfm1DiYih5WuvvTYceeSRYcGCBclrM2fODIcddlgYOnRoGDhwYFi0aFGYPn16WLZsWY11Y+h56623zml7HnjggRrTK1asCKeffnqjKnLHCtiZ/OMf/0geUf/+/cPmm28eunXrFtq2bZu859dff73O4PXw4cPDFVdc0eA2QUuyySabNKjCO63fHnvssd6FNwAALZGxLrUZ6wIAAAAAAED9SiZcHfXt2zfccsst4eyzzw7vvPNOqmrzjBkzkkdtsWJ1rPR16KGHhtZi3rx5yaM+xxxzTLjwwguTYwAAAAAAAAAAAAAApaA8lJhtttkm3HPPPeG0004Lffr0qXOZdu3aha985SvhT3/6Uzj22GNDS/WlL30pnHzyyWHbbbdNqlTXp2vXrmH06NHh3nvvDT/60Y8EqwEAAAAAAAAAAAAoKWWVsXRziVq9enV45ZVXwty5c8PHH38cunTpEvr16xd22GGH0Lt379CarFy5MsyaNSupWv3RRx+Fzz//PKxZsyZ069Yt9OjRI2y99dZJ8Ly8vLB5+08++SScccYZyfObbropbeAdAABaEuNcAAAAAAAAAGiZ6i9n3IrFas477bRT8mjtOnToELbbbrvkAQAAAAAAAAAAAACsr7BligEAAAAAAAAAAAAAipRwNQAAAAAAAAAAAACAcDUAAAAAAAAAAAAAwDoqVwMAAAAAAAAAAAAACFcDAAAAAAAAAAAAAKyjcjUAAAAAAAAAAAAAgHA1AAAAAAAAAAAAAMA6KlcDAAAAAAAAAAAAAAhXAwAAAAAAAAAAAACso3I1AAAAAAAAAAAAAIBwNQAAAAAAAAAAAADAOipXAwAAAAAAAAAAAAAIVwMAAAAAAAAAAAAArKNyNQAAAAAAAAAAAACAcDUAAAAAAAAAAAAAwDoqVwMAAAAAAAAAAAAACFcDAAAAAAAAAAAAAKyjcjUAAAAAAAAAAAAAgHA1AAAAAAAAAAAAAMA6KlcDAAAAAAAAAAAAAAhXAwAAAAAAAAAAAACso3I1AAAAAAAAAAAAAIBwNQAAAAAAAAAAAADAOipXAwAAAAAAAAAAAAAIVwMAAAAAAAAAAAAArKNyNQAAAAAAAAAAAACAcDUAAAAAAAAAAAAAwDoqVwMAAAAAAAAAAAAACFcDAAAAAAAAAAAAAKyjcjUAAAAAAAAAAAAAgHA1AAAAAAAAAAAAAMA6KlcDAAAAAAAAAAAAAAhXAwAAAAAAAAAAAACso3I1AAAAAAAAAAAAAIBwNQAAAAAAAAAAAADAOm3//38BaOFWr60MSypW530/3dq1DW3Ly/K+HwAAAAAAAAAAACg04WqAVuDhOR+FK6e+E5ZWrMn7vrq2axPGjRgUDtp0w9ASA+XC4QAAAAAAAAAAAKQjXA3QwsWAcaGC1VHcT9zfqAEbNGsF68YGyospHA4AAAAAAAAAAEBxKW/uBgDQNLFyc6GC1VXi/hpaMbpYAuVV4fC4DQAAAAAAAAAAAKhOuBqAkguUN3c4HAAAAAAAAAAAgOLUtrkbAEDuTRw1PPTs0C5n21u0siKMeWxazrYHAAAAAAAAAAAAxUi4GqAVisHqXjkMV7f0QLlwOAAAAAAAAAAAANkQrgYokNVrK8OSitUNWqdbu7ahbXlZ3trUmpRioBwAAAAAAAAAAIDcEq4GKICH53wUrpz6TlhasaZB63Vt1yaMGzEoHLTphqHYxGrQ+SBQDgAAAAAAAAAAQHMRrgYoQMXqxgSro7hOXHfUgA2KroL1mMem5WW7hQqU5yscnm/C5wAAAAAAAAAAAPkjXA2QZ0sqVjcqWF0lrhu30atDu1AKChUoz1c4PN+KuZo5AAAAAAAAAABAS1fe3A0AoGVUS46h3kKpCpSTPnweK6IDAAAAAAAAAACQWypXAzSDiaOGh55pKlEvWllRdFWVYwXpWC05hnqbUoW7ucPhLbHtdSm1auYAAAAAAAAAAACFIlwN0AxisLqlBWMP2nTDMGrABnmpKJ3vQHlLD4cDAAAAAAAAAABQGMLVQFqr11Y2OEgbKwTHICutU/xsW1oovBDh8HwrxmrmAAAAAAAAAAAArZFwNVCnh+d81Kgqv13btUkqBMcgaz7C2y1RDMZSHFpyOBwAAAAAAAAAAID8E64G6gw9NyZYHcV14rqxQnCmCtaNDW+XqkwB7dYa3i7F9wwAAAAAAAAAAEDzEq4G1hOrSTcl9BzXjdtIVyG4KeHtUjXmsWmh1JTie26IbAPm3dq1zXihAwAAAAAAAAAAAP8hXA20uPB2S9e1XZsk8AqFCJ/H/jZuxKBw0KYbOuAAAAAAAAAAAAD1kO4DsjJx1PDQM00l6lhBV5Xh0KCga6ZKwjF4HZdrbAC9JYa3S/E9F0o8prFS/KgBG6hgDQAAAAAAAAAAUA9JNCArMVjdK024Ot/h7dYkBoAzBaujOD8GsGMgtqFh42zC28WoFN9zIcPncb1YMT6f32EAAAAAAAAAAIDWQLgaKInwdktz0KYbJpWGYyA21+HtYlWK77kQ4XMAAAAAAAAAAACyJ1wNRWL12soGh0rzZdHKiuZuAv8/UFtqgfNSfM/5CJ/H7/CYx6YVpF0AAAAAAAAAAACtiXA1FIGH53zU6irSZgpoC29D4wifAwAAAAAAAAAA5JdwNRRBxerWFqyOVM0FAAAAAAAAAAAAWhrhamhmSypWF32wumu7NqFbO6cLaMmyrRgfv+uxQjYAAAAAAAAAAEApkpYE6g1WjxsxKGPYMoYx43KNDYkLb0PxVJOv+s4ftOmGeW8TAAAAAAAAAABAsRGuhiI0cdTw0LNDu1AMsqliG+fHMOaVU99pcMA6m/A2UDjxOxy/y6MGbOB7CQAAAAAAAAAAlBzhaihCMVjdq0jC1dmKVW5jGHNJxeqch7eBhmlqNfm4Xvwut7TzEAAAAAAAAAAAQFMJVwM5E0PSwpjQ/JpSTR4AAAAAAAAAAKCUCVdTslavrWxwleWGUpUZaAnV5BetrAhjHptWkHYBAAAAAAAAAAAUM+FqStLDcz4qSEXXru3aJNVjY8gRoNBUkwcAAAAAAAAAAGiYkg5Xr169OkyZMiXMmzcvLFiwIHTt2jX069cvjBgxIvTu3btZ2lRZWRmmT58e3n333TB//vzQqVOnpE1Dhw4NG2+8cc7288EHH4QZM2Yk+1i+fHno27dv2HzzzcOwYcNCWVlZaO0VqwsRrI7iPuK+YvXYGHIEAAAAAAAAAAAAoHiVZLg6holvvPHGMGnSpPDxxx+vN79du3Zhzz33DN/97nfD4MGDCxb0Hj9+fJg4cWIS9q6tvLw87LzzzuHMM88MI0eObPR+XnzxxXDDDTck/127du168wcMGBDGjBkTvvGNb4Q2bdqE1mhJxeqCBKurxH3Fffbq0K5g+wQAAAAAAAAAAACg4UouXD1r1qxw9tlnh7fffjvtMhUVFeGJJ54IzzzzTLjwwgvDMccck9c2ffjhh0mQe+rUqWmXiUHo559/PrzwwgvhjDPOSJZvqKuvvjrcfPPNdYaqq8ydOzdceeWVyfu/9tprk4rWAJSeRSsrslquW7u2KvMDtDBrKivD4lWrG7SO8z0AAAAAAAAApaKkwtULFiwIp556apg/f36N14cOHRoGDhwYFi1aFF599dWwbNmy5PWVK1eGH/3oR6FLly7h0EMPzUub4r5OO+20MHPmzBqvb7311mGLLbZI5s+YMSNpWxSD0bHqdocOHZKQdbauv/76cNNNN9V4rVevXsl779y5cxI2nz17dmrelClTwtixY8Pvfve7ZH5rN3HU8NAzR5WlYyBxzGPTcrItgOaS7Xmsa7s2YdyIQeGgTTfMe5sAaLon5n4Srpj6TliY5UU0VZzvAQAAAAAAACgVJROurqysTCpWVw9Wb7PNNuGKK64IQ4YMSb22ePHipGLznXfemXrthz/8Ydh2222TwHOuXXTRRTWC1f369UsqR48cOTL12ooVK8L48ePDddddl7yP6Jprrgnbb7992G233erdx+TJk5NwdZWysrJwzjnnhFNOOSUJaVd58cUXw7hx41LH6I033kjC5Zdffnlo7WKwuleOwtUApWRpxZpw5dR3wqgBG6hgDdAC/OyVt5Jzd0M53wMAAAAAAABQKspDiXj00UeTasxVBgwYkASoqwero+7duyeB5xNOOCH1WqxgHQPXuRYrUj/44IM19n3XXXfVCFZHHTt2DN/+9rfDBRdckHothqxjCLsqbJ1OXctdeOGFSdXr6sHqaKeddkr2361bt9Rr9913XxKyBqD16taubVKRtLFi4G5JxeqctgmA4uN8DwAAAAAAAEApKJlwdfXKzdHFF18cevTokXb5733ve6F///6p6cceeyznIePabTr33HOT0Hc6J510Uhg+fHhq+rXXXgtPPPFEvaHyN998MzU9YsSIcOKJJ6ZdfuDAgUk7qsRQdu120nCLVlYkt16v6xHnATSntuVlYdyIQU0KWAPQMvzgi1u6YwsAAAAAAAAAZNA2lIAYLp45c2Zqeosttgh77bVXxnU6deoUxowZE6666qrUa/fff3/Ydtttc9Kmzz77LPz973+vUbX661//esZ1ysrKkoD1eeedV6NN++23X9p1HnjggRrTcf24nUyOPPLIcM0114TFixcn008//XRYsmRJjYrWNMyYx6Y5ZEBRO2jTDcOoARtkVYE6XhTivAbQMu07oE/Yu3/vsHiV8z0AAAAAAAAAlGzl6qeeeqrG9KGHHprVel/72tdqTD/55JM5a9PkyZPD6tX/CTQccMABoUOHDvWuF4PUMfhd5ZlnngmrVq2qc9n4epxfpXPnzhmD2FViO0aNGpWarqioSNrbWnRv37ZGtb74PL4GUOpiBet4Tqzv0bPaORSAlqdNmfM9AAAAAAAAAJR0uPrZZ5+tMb3jjjtmtd7GG28c+vfvn5p+5513wvvvv5+TNj333HONalMMPg8bNiw1vXTp0jB9+vQ6l506dWr4/PPPU9Nxvfbt22e1n9rtqX0MW3qY5PsjBoWu7dokj/g8vpYr3dq1TbbbWHHduA0AAAAAAAAAAAAACqskEpyzZ89OPS8vLw/bbbdd1usOHz48zJs3r8a2Ntlkkya3adasWTWmqwems2nTiy++WGNbdYWza+9j++23b9A+0h3D1nI79PjIV+XXcSMGhSunvhOWVqxpcLA6rhu3AdCSLFpZkbdtxwtOnBcBWtb53rkbAAAAAAAAgJaq1YerP/vss/Dpp5+mpvv06RM6deqU9foDBgyoMR2rV++5555NblfcTpWysrIwcODAJrWpvn1E+dgHdTto0w3DqAEbhCUVqxt0iIRQgJZqzGPT8rbtqgtP4rkVgJZzvj9n+83CgXk6dxs3AwAAAAAAAJAvrT5cPWfOnBrTG2+8cYPW79evX8btNUYMey9dujQ13bt379C+ffuct+m9997LuF4mHTp0CL169QoLFy5MphcvXpw8j6+RnVhltVeHdg4XQBPFuwDEuwHEi1ZUsAZoOa6Z/m7yyAcX3gAAAAAAAACQL60+XF09xFwVZG6I2mHiJUuWNHubai+frk21X2/MfqrC1VXtbk3h6uXLlzd63Xbt2oW2bdvmfLtxm3HbdVmxYkWorKxs1HbbtGmTNsC/cuXKsHbt2kZtt7y8PAniF3K7q1atCmvWrGnUdmOV+I4dO9Y5r6KiIqxe3bBK49Wlq4gftxm3nevtxmMQj0VjxeMQj0eutxs/t/j51Rb7QuwTjRX7b+zHtcXvRPxu5Hq7kXNE+u9y27WVoUvb8rBsdeO+440NWH+0eGno2aGtc0Q1zhHrOEc0fhyxem1l8v3KpLxNeY1xRPf2bUObOn5DKC65+B2L1aFjiLm+PtIcYpuumPJ22L1Pl9ChXVtjXWPdGox11zHWXce/h9fx72HniFI7R2Qzzq091jXOBQAAAACgZMLVy5YtqzGdLrCZTu0g5ueff97kNtXeRkOqVtf1HtK1qfbrTX3vtY9lNj788MOM86uHtwtt/PjxjV53zz33DMOGDatz3u9+97tGhz1HjhwZdtpppzrnTZo0qdHHa7vttgt77bVXnfMeeuih8P777zdqu1tuuWU48MAD65z31FNPhbfeeqtR291kk03C6NGj65z3/PPPhxkzZjRqu/HigGOPPbbOeVOmTAkvvfRSo7YbvyunnnpqnfPeeOONMHny5NBYZ555Zp2vv/POO+Gvf/1ro7f7jW98o85QZvzO/uUvf2n0dseMGRP69Omz3uux706cOLHR2z388MND//7913s9ftea8l0+4IADwlZbbVXnPOeIzOeIHTr2Di90HxAqygs3lIjn146Vq50jqnGOWMc5onHjiLcb+T2Od+b4/ohBYd8B65/vS0kxj3Nz9TsW7xYwbsSg5O4BxRiwjhf53Hz7HWHHoUOMdY11azDWXcdYdx3/Hl7Hv4edI0rpHGGcCwAAAABAU7X6cHXtiihNDTI3pcJKrkLP2Yara7e1ofupfawa897TBXqrxIoz2267bYO3C0Dz2mLFp2HzFZ+GVWXphxKbD9o87LPPPnXOe/LJJ8O/3/l32nVXlLcN9234hZy0FVhfrDvf2AskFq6sCD975a2SD1eXyjj3oE03DKMGbBCWVKy7w8ddd90VVq5IfzeKtzv1Di93H1DAFgIA/IdxLgAAAAAAudDqw9V13Qa1KcvXdTv15m5TS37vALRc5bFye+W6sF1dupRVJhVu083LtG7yF3Egb+KFEYWsPE/LFitYV53PO1WuCWUZzt9f+HxBGPL5gjovvhmxw4jwxS9+sc71/vznP4fPFn2WsR0uvAEA6mOcCwAAAABALrT6REWnTp1qTK9cmb7KWl1q36qyc+fOTW5T7W009HaY2bap9ntv6H5qH6vGvPenn3464/x4y86LL764wdsFAKB5xJDt90cMKvnDb5zb8ItvurX5T0i7ts5hbViZ6aKbyIU3AEAeGecCAAAAAFClrLKVlyN+7rnnwimnnJKa3nvvvcOvf/3rrNd/+OGHwznnnJOaPuyww8Lll1/epDa9++67Yf/9909Nb7311uGBBx7Iev3p06eHo446KjW94447Jrfnru2YY44Jr7zySmr67rvvDsOGDct6P1/96lfD7NmzU9OPP/54GDhwYMilTz75JJxxxhnJ85tuuin06dMnFMry5csbvW68zXvbtm1zvt24zbjtusRwfGO/rm3atAnt27dPG6Jfu7ZxSZXy8vLQoUOHgm531apVYc2aNY3abqzG3rFjxzrnVVRUhNWr6wn0ZFD7YoYqcZtx27nebjwG8Vg0VjwOdVWzb+p24+cWP7/aYl9o6MUt1cX+G/txbfE70dALR7LZbuQc0bzniEUrV4fDn5hR47Xb9xwSerRrG8rLy0L7DOeItWsa1t6u7dokVVmdI/7DOaL1nyMyfcdqK29TXmMc0b1929CmkXdSKSXNOc5tDX20LnX127/su13o07mDsa6xbg1+x1r/71hD+PfwOsa6/+Ec0brPEQ0Z59Ye6xrnAgAAAABQMpWru3btul6l5Ib49NNPa0x369atyW2qvY2Gtqn28una1NT91H7vtY9lS5cutFqs200XCm6qdMHHYt1uupB4U8U/0KX7I11TxD/+pfujYlPEP4Dmo6/la7sxZJuP7caAQEv7LjtHZHeOWFG+/kUJJ03+V14+kxiuHjdiUDho0w3TLuMcsY5zROs5R9T1HevbvWvaqsK0PC29j9alrn67orxNWFZZFpatTHcxW3no1qF9chFNMYx1V6+tDEsqVofP07a3LITymmPHbu3aNrn9fsfW8TvWus8RjeHfw+s4R6zjHNE6zhHGuQAAAAAA5EKrD1dvttlmNaY/+OCDBq3/4Ycf1pjOReXm3r17J0HlpUuXpqraxUqb2YZGa7+HdG3adNNNM76XTGJF0erh6hjU7tWrV9brA0BLsbRiTbhy6jth1IANch6+AyC/xjw2LScX0RTCw3M+Sn5v4u9OQxRL+6GuCwXyKRcXFgAAAAAAAEBjtPpwdY8ePZIwc1VQ+OOPP05uQZltpZS5c+fWmN5iiy1y0q5BgwaFV199NXkeb1sZ95PttrNtU9xHde+9917W7cvX+waAbMM0MUzW0ABaY8X9xICQqr0ArU8xXEQTg6iNCVYXS/shFxcKNJQLCwAAAAAAAGgu5aEEbLXVVqnna9euDTNmzMh63WnTpqXdVlNsvfXWNaanT5+e8zbV3kft9TKp3Z4tt9wy63UBoKlieCxW6YyhGgCofuFNUy6iaS5x300JojZ3+yEXFwo09sKCuE8AAAAAAAAopFZfuTrabbfdwosvvpiafvnll8PIkSPrXe/DDz8M8+bNq1EJepNNNslJm3bdddcwadKkGm06/PDD611v5cqVNcLhXbp0CcOHD69z2REjRoTOnTuHzz//PJmOlbJXrVoV2rdvX+9+Ynuq23333etdBwBy6aBNN0yqdOYjTLZoZUUY81j2Fx0BUDwX3hQq2Ank/kKBhnJ3EQAAAAAAAJpDSYSr99lnn3DNNdekpu+///7wrW99q9717rvvvvW2kyt77bVXaNu2bVi9el1g7NFHHw0XXXRR6NChQ8b1Hn/88VRYOtpjjz3ShqXj6zEUHbcdxfXi+gcffHC9Ae6qdaJ27dqFPffcs0HvDwByFaTr1aGdgwlAgy68aQkX0UwcNTz0TPMb1xLaDwAAAAAAANBalUS4evDgwWGbbbYJM2fOTKbfeuut8PTTTycB53RWrFgRJk6cWOO1Qw45JGdt6tGjRxKMfuqpp5Lpzz77LPz5z38Oxx57bNp1Kisrw+23317jta997WsZ9xPbXD0oHdc/6KCDQllZWdp17r777rB48eLUdDxO3bp1y+p9AQAA5FNrufAmBqtbw/uATBcKNJQLCwAAAAAAACgG5aFEnHXWWTWmf/rTnyaB5nSuuuqqMG/evNT0fvvtF77whS+kXX7SpElJiLvqccIJJ9TbpjPPPLPG9NVXX11jn7XFYPS0af+pXhbbs++++2bcx/7775+0p8rUqVPDhAkT0i4/d+7cpB1VYgi79rEDgNYohnkWZvFYvbayuZsKAFB0Fwrk4pGrkDYAAAAAAAA0RUlUrq4KGe+www5hypQpyfR7770Xjj/++HDllVfWCB8vWbIkXHPNNeHOO+9MvdahQ4dwzjnn5LxNw4YNC1/96lfDgw8+mEzHatGxcnUMdu+4446p5VauXBnGjx8frr322hqh5+9///sZK1BXLTdu3Lhw+umnJ5Wvo0svvTQsX748nHLKKcl7q/LSSy8ly8ZjUL0y9rbbbpvT9w0AxWjMY/+5gCmTru3ahHEjBoWDNt0w720CILcX0bTkfTdn+6vr1q5tUj08G/GCpCUVq4umPQAAAAAAAADZKJlwdQwZx3DykUceGRYsWJC8NnPmzHDYYYeFoUOHhoEDB4ZFixaF6dOnh2XLltVY95JLLglbb711XtoVK2jPmjUraUv04YcfhuOOOy5ss802YdCgQeHzzz8PM2bMCAsXLqyx3ne/+92w2267ZbWPPffcM6k+/ctf/jKZjiHrWJ06VsLebrvtQqdOncLbb7+dtKO6GKr+8Y9/nLP3CgCtwdKKNeHKqe+EUQM2EOYCaIUX0RSrYml/thcZPTzno+T3Mv5uFkN7aLmyvbAg38F/QX4AAAAAAIDSUTLh6qhv377hlltuCWeffXZ45513UkHjGF6Oj9piVecLLrggHHrooXlrU5cuXcLNN9+cVMaeOnVq6vUYtq4KXFdXXl4exo4dG771rW81aD9nnnlmqKioSPa1du3a5LVPP/00TJ48uc7lY5XvGEbv3Llzg98TABS7GI6JYazGBr7iejGQE29fD/mUr6qvxVIBF2idFxnFc1chgtXZtoeWLdd3F2ls8F+QHwAAAAAAoHSUVLg6ihWh77nnnnDDDTeESZMmhU8++WS9Zdq1axd23333cO6554bBgwfnvU0bb7xxuOuuu8L48ePDxIkTw7x58+qsvL3zzjsnFahHjhzZ4H3E9eP7+fKXvxyuv/768OKLLybB8tr69+8fxowZE0499dTQpk2bRr8nAChmMXwVwzeFCn5BYxSq6iu0Rk29iCbfYttiG1tq++u7yCjOK2TbXfREIYL/gvwAAAAAAAClo+TC1VGnTp3CuHHjkmrRr7zySpg7d274+OOPkyrS/fr1S6o29+7du0HbPOKII5JHY7Vt2zacfvrp4bTTTgvTpk0L7777bliwYEHo2LFjUnF72LBhSQi7qXbaaacwYcKE8P777yfVuufPnx9WrFgRNtpoo7DZZpuF4cOHJ0FsAGjtYlXDGL7JpipwrPKbbdVEyIVCVn2F1qiYL6Kpqn6bqcpyMbcfWvLdRZoa/BfkBwAAAAAAKA0lGa6uHmiOYeP4KBYx2DxixIjkkU+bbLJJ8gCAUhbDa+nCN9CcCl31tb4qutDaL6IppPhdyxSsLsb25+Iio4mjhoeeOfrNddFT6+XCAgAAAAAAAIqBBAUAAJSwbKroQkvV0i+iaentry4Gq1vLe6F13V0kU/BfkB8AAAAAAKA0CVcDAEALkMuqr42pogsArfHCAsF/AAAAAAAAahOuBgBohFjJMB8EXUlH+AtoKb+D+fqNzMTvMgAAAAAAAJArwtUAAI3Q1FvQp9O1XZswbsSgcNCmG+Zl+zSv1Wsrw5KK1fUu1xzBRIBi+B1sLL/LFCr4n+02XDBHQ8Z+TaGvAQAAAABA7glXAwAUkaUVa8KVU98JowZsENqWlzV3c8ihh+d8lHy28TMGoGXwu9zy5Dv4n+32XTBHocZ+pdLXXKQIAAAAAEAhCVcDAGRRDS6GFgoVio37iRXuenVo57NpRWEQwWqgVH8H47pxG8XSnobyu0xj+40L5kpXIcd+pdDXXKQIAAAAAEChlRd8jwAALUwMKcRqcDHIBY0Rw/JNCdfkOpgIUKjfwaqKqrkM/PldpnbQPl+/r03dflUwn9LT1LFfQ7XmvuYiRQAAAAAAmoOEBgBAFuJttmM1uHyEFhatrMj7LexpufIRTAQo1O9gDKfm4/zld5nqQfvGVAjO5ve1KdsHcsNFigAAAAAANAfhagCAbAdO5WWhV4d2jhc5MXHU8NAzi/6Ur2AiQEv/HSy29tA6g/8N2b4L5sjF2C8b+lp2XKQIAAAAAEBjCVcDAEAziOEaoUAAKP6gvSA/uWDslzsuUgQAAAAAIN+EqwEAilCsRpcNVY0BIP/8LgMUD0F1AAAAAADyTbgaAKAIjXlsWoNudR1vWQ8A5IffZYopmL96bWVYUrE6bx9KKV28l69jme3nDgAAAAAAFCfhagCAFmxpxZpw5dR3wqgBG5RMCAYAipXfZfIdzH94zkfJ2C/2tXwplYv3CnEsC0mFfQAAAAAAyB3hagCAZharA8YQS2ODHXG9WHGvV4d2OW8bAJQav8sUazA/VlkuRBi4FC4SKNSxLCQV9gEAAAAAIHfKc7gtAAAaIYZWYnXAGLAGAJqX32WaGsxvrKoL5tKJ8woVBq6vLS1dIY9lFPtF7B/FoCo8HwPmAAAAAABA3Yrj/+oDAJS4eNv1WB0wmxBLvOV3tpXpAAC/yxQ2mN/aKiLT9GB17Be5rAKuwj4AAAAAAOSXcDUAQJGIgYteHdo1dzMAAL/LtJAL5iaOGh565mD86OK93B3LuoLQuQxWR4L8AAAAAACQX8LVAAAAANACL5iLYWAX55XmsXTnGwAAAAAAyB/hagCAViBWG8yHfFTaA4DWLpvf5Xz+xq5eW5lV5eRCtQfID3e+AQAAAACA/BCuBgBoBZp6S/l0urZrE8aNGJRUxqPx4bV8hd8BaLm/y/n6jX14zkfhyqnvhKUVaxq87jnbbxYOzNAev2f5l+kYF/r4F8vnLfgPAAAAAAAUmnA1AABpxWBWDGiNGrCBapY5DK8BQD5+Y+NFP035bbpm+rvJg9Z3wVxLbouL/fJDeB4AAAAAANITrgYAaGFi9b4YMilUqDfuJ1Zn7tWhXUH21xI0NbwGQOvRlN/lXP/Gxm35baK1cbFffgjPAwAAAABAeuUZ5gEAUIRidctxIwYlQS6aR1PDa/Gzi2E8AFq+Uv5d9nuWm2B+MRz/prYl36ouRKD1hufjxYsAAAAAAFAsJDoAAFqggzbdMIwasEFeQibxFuHFUsmuNaq6tX0M4wFQWr/LzfEbO3HU8NAzQ2XsR+Z8FK6Z/m6Dt+v3LHfB/MbcDSPXx78pbaH4FfrONw3lTjkAAAAAABQb4WoAgBYqhmB6ZQhLEYoqvFY93CJYDdD6FOvvcvxtytSuY7beJBy15cYNvmDL71nzXjCXj+Ofz4v3GsrFfrklPA8AAAAAAA0jXA0AAAUIrwFAsSrWYHipKKbjX0xtIbeE5wEAAAAAIHvC1QAAZFU9MB9UvQSg1OXyNzZfv9dA6yA8DwAAAAAA2RGuBgCgXmMem5a3o3TO9puFAzfdMC9h7NVrK/Nya3vhNQBawm8stCYuRAAAAAAAAApFuBoAgGZ1zfR3k0c2urZrE8aNGJTc1rw+D8/5KFw59Z2wtGJNDloJAEBzciFCaYbnXdQIAAAAAEBzEK4GAGC96tAxxFyMoeTYphiYHjVgg4wVrGPFasFqAEr9NzbuK+4ToNgJzwMAAAAAUEzKm7sBAAAUlxhajtWhYyCrGMVA2pKK1RmXifMLGQ4XXgOg2H5jq+72kOliJCj2CxEKxVgOAAAAAACoTvkiAADWc9CmGybVoesLMTfWI3M+CtdMf7dVHHnhNQCK6Te2ejhVsJqWfiFCIe5EYizXsqr4C8IDAAAAAFAIwtUAANQ9UCwvC706tMvL0Tlm603CUVtunFWwbNHKipzcJnziqOGhZx7ej/AaAMX0GwuthQsRWq/GhucF4QEAAAAAKBThagAASiJYFoPVgmwAAC2HCxFar8aE513UCAAAAABAoQhXAwAAAABQUMLzAAAAAAAUK+FqAABanEUrK5o0HwAAAAAAAAAA6iJcDQBAizPmsWnN3QQAAAAAAAAAAFqh8uZuAAAAAAAAAAAAAABAMRCuBgCgqHVr1zZ0bdemSduI68ftAAAAAAAAAABAJsLVAAAUtbblZWHciEGNDljH9eL6cTsAAAAAAAAAAJCJ8n0AABS9gzbdMIwasEFYUrG6wevGitWC1QAAAAAAAAAAZEO4GgCAFiEGpHt1aNfczQAAAAAAAAAAoBUrb+4GAAAAAAAAAAAAAAAUA+FqAAAAAAAAAAAAAADhagAAAAAAAAAAAACAdVSuBgAAAAAAAAAAAAAQrgYAAAAAAAAAAAAAWEflagAAAAAAAAAAAAAA4WoAAAAAAAAAAAAAgHVUrgYAAAAAAAAAAAAAEK4GAAAAAAAAAAAAAFhH5WoAAAAAAAAAAAAAAOFqAAAAAAAAAAAAAIB1VK4GAAAAAAAAAAAAABCuBgAAAAAAAAAAAABYR+VqAAAAAAAAAAAAAADhagAAAAAAAAAAAACAdVSuBgAAAAAAAAAAAAAQrgYAAAAAAAAAAAAAWEflagAAAAAAAAAAAAAA4WoAAAAAAAAAAAAAgHVUrgYAAAAAAAAAAAAAEK4GAAAAAAAAAAAAAFhH5WoAAAAAAAAAAAAAAOFqAAAAAAAAAAAAAIB1VK4GAAAAAAAAAAAAABCuBgAAAAAAAAAAAABYp20oUR988EGYMWNGmD9/fli+fHno27dv2HzzzcOwYcNCWVlZwdsT2zFz5swwd+7csGTJklBeXh569OgRBgwYEIYPHx46d+5c8DYBAAAAAAAAAAAAQCkpuXD1iy++GG644Ybkv2vXrl1vfgwzjxkzJnzjG98Ibdq0yVs7Vq1aFf7+97+HJ598Mjz//PNh3rx5aZeN7dhjjz3CySefHHbdddcG7eeCCy4I99xzT6PauPXWW4cHHnigUesCAAAAAAAAAAAAQEtTUuHqq6++Otx88811hqqrxMrRV155ZXjiiSfCtddem1S0zrWpU6eG0047LSxevDir5desWRP+9re/JY/Ro0eHiy66KHTp0iXn7QIAAAAAAAAAAACAUlYy4errr78+3HTTTTVe69WrVxg6dGjo3LlzePvtt8Ps2bNT86ZMmRLGjh0bfve73yXzc2nhwoV1Bqu7desWttlmm7DBBhuEsrKyJOj9xhtvJOHqKrEKdaxy/dvf/jZ06NAhp+0CAAAAAAAAAAAAgFJWEuHqyZMnJ+HqKjG4fM4554RTTjmlRkD5xRdfDOPGjQvz589PpmOw+Uc/+lG4/PLL89a2GPA+/PDDw8EHH5wEvdu0aVNjfmxLrKD95z//uUY7r7jiivDDH/6wwfuLFbmz1a5duwZvHwAAAAAAAAAAAABaqlYfrq6srAxXXnll8t8qF154YTjppJPWW3annXYKd911Vxg9enRYsmRJ8tp9992XhLC33XbbnLZro402Ct/+9rfD17/+9dC+ffu0y/Xt2zf87Gc/C5tttln4xS9+kXr997//fTjhhBOS1xtiwIABTWo3AAAAAAAAAAAAALRW5aGVe/TRR8Obb76Zmh4xYkQ48cQT0y4/cODAcO6556amYyi7etXrXBg+fHh47LHHwjHHHJMxWF3d2LFjwxe/+MXU9OrVq8MjjzyS03YBAAAAAAAAAAAAQClr9eHqBx54oMZ0rFhdVlaWcZ0jjzwydO/ePTX99NNPpypZ50Lv3r1Dx44dG7ze0UcfXWP6pZdeylmbAAAAAAAAAAAAAKDUtepw9apVq8IzzzyTmu7cuXPYb7/96l2vQ4cOYdSoUanpioqKMHny5NDchgwZUmN6wYIFzdYWAAAAAAAAAAAAAGhtWnW4eurUqeHzzz9PTQ8bNiy0b98+q3V33HHHGtPPPvtsaG5t2rSpMb169epmawsAAAAAAAAAAAAAtDatOlw9a9asGtPbb7991usOHz68xvTs2bNDc5szZ06N6T59+jRbWwAAAAAAAAAAAACgtWkbWrF33nmnxvTAgQOzXnfAgAEZt9UcHn/88RrT2223XYO3cckll4RXXnklvP/++2Hp0qWha9euoXfv3sm2dt5553DggQeGLl265LDVAAAAAAAAAAAAANAytOrK1e+9916N6X79+mW9bocOHUKvXr1S04sXLw4LFy4MzeWTTz4JjzzySI3X9tlnnwZv54477givvfZa8l4qKiqS/7711lvh3nvvDT/4wQ+Sbd58881h7dq1OWw9AAAAAAAAAAAAABS/Vh2uXrJkSY3pWKG5IWovHys9N5fLLrssfP7556npoUOHhpEjR+Z8P4sWLQpXXXVVOPXUU8Nnn32W8+0DAAAAAAAAAAAAQLFqG1qx6mHkqmrUDdGxY8ca08uWLQvN4aGHHkoqS1cpKysLF154YYO2sdVWW4W99947CWVvttlmoWvXrmH58uXh/fffDy+88EK45557aoSpn3vuufCd73wnjB8/PrRt2/hu8uGHH2ac35zVwAEAoLGMcwEAAAAAAACgdWrV4eoYHm5KuLp9+/YZt1cIs2bNCv/zP/9T47Xjjjsu66rVe+yxRzj++OPDdtttV+f8IUOGhH322ScJUv/0pz8Nf/nLX1LzYuj6xhtvDGeffXaj27/XXntlnN+uXbuw7bbbNnr7AADQHIxzAQAAAAAAAKB1ynu4+t13312vgnSubbrppqFLly71LhcrPjdE7eUrKytDIX388cdh7NixNY5frDx9/vnnZ72Nr371q1ktFytZX3bZZUkA/Q9/+EPq9VtvvTWccMIJoVevXg1sPQAAAAAAAAAAAAC0LHkPV19wwQXhlVdeyes+YgB4t912W+/1Tp061ZhesWJFg7a7cuXKGtOdO3cOhbJ06dJw+umnh3nz5qVeGzhwYPj1r3/d4ArcDfHDH/4wPPPMM6n9xmD3Qw89lFTLboynn3464/yFCxeGiy++uFHbBgCA5mKcCwAAAAAAAACtU97D1c2pdri6dli6PrWXz6Y6di6sWrUqfPvb3w6vvfZa6rUNN9wwCZHH/+ZT+/btw/HHH59Usa7y3HPPNTpc3a9fv4zz27Vr16jtAgBAczLOBQAAAAAAAIDWqTy0Yt26dVuvSnJDfPrppzWmu3btGvJtzZo14bzzzgsvvPBC6rUePXqEW265JalcXQi1q4DPmjWrIPsFAAAAAAAAAAAAgFZdufq6665rcMXohkpXzXnTTTetMf3hhx9mvc3Y5urh6hjU7tWrV8inysrK8MMf/jA89thjqdc6d+4cbr755jB48OBQKP37988YMgcAAAAAAAAAAACA1ijv4ep0wedCGDRoUI3p9957L+t1586dW2N6iy22CPn2s5/9LEyaNCk13b59+3DDDTeEESNGhELq0KFDjekVK1YUdP8AAAAAAAAAAAAA0BzKQyu29dZb15ieNm1a1utOnz69xvSWW24Z8unaa68NEyZMSE23adMmXH311WG33XYLhbZw4cIa0z179ix4GwAAAAAAAAAAAACg0Fp1uDpWfO7cuXNq+tVXXw2rVq3Kat2XX365xvTuu+8e8uW2224LN954Y2q6rKwsqWK93377heYQj1N1G220UbO0AwAAAAAAAAAAAAAKqVWHq9u3b18jFP3555+Hxx9/vN71Vq5cGR599NHUdLt27cKee+6Zlzb++c9/Dj//+c9rvHbRRReFww8/PDSXhx9+uMb0yJEjm60tAAAAAAAAAAAAAFAorTpcHR1yyCE1pm+//fZQWVmZcZ277747LF68ODW91157hW7duuW8bY899lgSpK7envPOOy8cd9xxoblMnz49PPTQQzVe23vvvZutPQAAAAAAAAAAAABQKK0+XL3//vuHwYMHp6anTp0aJkyYkHb5uXPnhquvvjo1XVZWFs4666x697PPPvsk+6l6vPDCCxmXf/7555Mg9Zo1a1KvnXbaaWHs2LEhV/70pz+FZcuWZb387Nmzw5lnnhnWrl2bem3EiBFh1113zVmbAAAAAAAAAAAAAKBYtQ2tXAxHjxs3Lpx++umpCtGXXnppWL58eTjllFNChw4dUsu+9NJLybJLlixJvfa1r30tbLvttjlt02uvvRa+/e1vh1WrVqVe23fffcOYMWOScHdDDBgwIO28X/3qV+Gqq64Khx9+eDj44IPD0KFDQ5s2bdZb7rPPPgsTJ04MN910U/j8889Tr7dv3z78z//8T4PaAwAAAAAAAAAAAAAtVasPV0d77rlnUn36l7/8ZTIdQ9axOvXtt98etttuu9CpU6fw9ttvh1mzZtVYL4aqf/zjH+e8PU8++WSNEHP0xBNPJI+GevPNNzPOX7hwYbj11luTR8eOHcM222wT+vTpE7p27RpWrFgR3n///fCvf/2rRgXtKIawL7vssrD99ts3uE0AAAAAAAAAAAAA0BKVRLg6OvPMM0NFRUW4+eabw9q1a5PXPv300zB58uQ6l99hhx3CtddeGzp37hxaiximnj59er3LbbzxxuHKK68MO+64Y0HaBQAAAAAAAAAAAADFoDyUiLKysnDuuecm1ap33nnnZLou/fv3D9/73vfCXXfdFfr27Rtasm9961th3333Db169ap32Xg8hgwZEn70ox+Fhx9+WLAaAAAAAAAAAAAAgJJTVllZWRlK0Pvvvx9mzJgR5s+fn1R03mijjcJmm20Whg8fnjZ43ZJ9+OGH4e233w4ffPBBWLRoUVi5cmXo0KFD6N69exIij++7R48eBW/XJ598Es4444zk+U033RT69OlT8DYAAECuGecCAAAAAAAAQMvUNpSoTTbZJHmUin79+iUPAAAAAAAAAAAAAKBu5WleBwAAAAAAAAAAAAAoKSVbuZrisGbNmtTzhQsXNmtbAAAobj179gxt2rQJLYFxLgAArXGcCwAAAABQCoSraVaLFy9OPb/wwgubtS0AABS3m266KfTp0ye0BMa5AAC0xnEuAAAAAEApKG/uBgAAAAAAAAAAAAAAFIOyysrKyuZuBKVr1apVYc6cOcnz7t27F+T2lwsWLAhHHXVU8vxPf/pT2GijjfK+T1o3fQr9iWLl/ERr608t6XbpzTHOLZbPidZDf0J/olg5P9Ha+lNLGucCAAAAAJSCts3dAEpb+/btw1ZbbVXQfVZUVCSPqFevXm65iT5FUXGOQn+iWDk/Ff84N/I5oT9RrJyf0J8oVs5PAAAAAADUVr7eKwAAAAAAAAAAAAAAJUi4GgAAAAAAAAAAAABAuBoAAAAAAAAAAAAAYB2VqwEAAAAAAAAAAAAAhKsBAAAAAAAAAAAAANZRuRoAAAAAAAAAAAAAQLgaAAAAAAAAAAAAAGCdssrKysr//xwAAAAAAAAAAAAAoGSVN3cDAAAAAAAAAAAAAACKgXA1AAAAAAAAAAAAAIBwNQAAAAAAAAAAAADAOipXAwAAAAAAAAAAAAAIVwMAAAAAAAAAAAAArKNyNQAAAAAAAAAAAACAcDUAAAAAAAAAAAAAwDoqVwMAAAAAAAAAAAAAhBDaOgoU2urVq8OUKVPCvHnzwoIFC0LXrl1Dv379wogRI0Lv3r2b5QOprKwM06dPD++++26YP39+6NSpU9KmoUOHho033jhn+/nggw/CjBkzkn0sX7489O3bN2y++eZh2LBhoaysLGf7KSXF1J9WrlwZ3nrrrTB79uzw6aefJp9xbE9sR+xL8bOmuBVTfyo056fcK+X+RGkwfmoZ33ufU8tVTP3JOLflK6b+VGjGublXyv2J0mD8BAAAAACAcDUFE4OmN954Y5g0aVL4+OOP15vfrl27sOeee4bvfve7YfDgwQX7g+D48ePDxIkTkz8K1lZeXh523nnncOaZZ4aRI0c2ej8vvvhiuOGGG5L/rl27dr35AwYMCGPGjAnf+MY3Qps2bRq9n1JSLP3pvffeCw8//HB45plnkj8ur1q1Ku2yMUwfP+fjjjsu9OjRI+t9zJ07N+y7776NbuO1114bDjzwwEavXwqKpT/98pe/DNdff32j1u3cuXPSBxvK+al19qcLLrgg3HPPPTnZ1hNPPJH8TtXF+Sm/4pghXrTz6quvJheBxf+++eaboaKiIrXMpZdeGo444ohQSMZPxfm99zm1HsXSn4xzW4di6U/Gua1DMfQn49zWwTjX/ycEAAAAACh2ZZWxFAfk2axZs8LZZ58d3n777XqX7dChQ7jwwgvDMccck9c2ffjhh8kf/KZOnVrvsjFkfcYZZyTLN9TVV18dbr755jpD1bXtsMMOSRA2hnAp/v507rnnhoceeqjB62244Ybh5z//edh9992zWl54sTT6U3OETpyfWm9/ymXo5Nlnnw0bbLBBnfOcn/LjkUceCXfddVdyt4vPP/8847KFDlcbPxXv9746n1PLVSz9yTi3dSiW/hQZ57Z8xdKfjHNbNuNc/w4HAAAAAGgpVK4m7+ItYk899dQwf/78Gq8PHTo0DBw4MCxatCipxLhs2bLULad/9KMfhS5duoRDDz00L22K+zrttNPCzJkza7y+9dZbhy222CKZHwNNsW1RDEbH6kzxD4QxZJ2tGJK86aabarzWq1ev5L3HIGT8o+Ts2bNT82IwcuzYseF3v/tdMp/i7k/vvvvueq+VlZUlfWiTTTZJqlMvWbIk6UuffPJJapmPPvoo+Zxj//jKV77iY25GxdSfCs35KfdaY3+Kt3ZPF6wmf/75z38mVeWLjfFTy/je+5xarmLqT8a5LV8x9adCM87NvdbYn4xzm4dxrv9PCAAAAADQUghXk1exMHqsbFT9D3DbbLNNuOKKK8KQIUNSry1evDip2HznnXemXvvhD38Ytt122yTwnGsXXXRRjWB1v379wpVXXhlGjhyZem3FihVh/Pjx4brrrkveR3TNNdeE7bffPuy222717mPy5Mk1KtDG0O0555wTTjnllCSkXSWGp8aNG5c6Rm+88UbyR8jLL788Z++3tSjW/hTttNNO4cgjjwx77LFH6N2793rtfvzxx8NPf/rTVNtXr16dVASMVZti/2uIE088MZx00klZL9+nT58Gbb9UFHN/qhIr12bbP2KF/Ww5P7X+/nT++eeHs846q8HrnXnmmeFf//pXavrwww9v0PrOT/nVrVu35OKr2sGmQjF+Ku7vvc+pZSvW/hQZ57Y8xdyfqhjnthzF1p+Mc1sn41z/nxAAAAAAoNgIV5NXjz76aFKNucqAAQOSP7TFir7Vde/ePQnsxADyHXfckap0FP8wVz2gnAuxivCDDz5YY9/xD7uxbdV17NgxfPvb305CTJdeemnqj4oxhP3nP/85aWs6VctVhbKjeEvcugKxMawQ9z969OikynF03333JSHs+EdIirc/xe0fcMAByR+at9pqq4zLjRo1KgwfPjyMGTMmzJs3L3l9+fLlSZuq+le24vur3V9p+f2pLjFYnevP2vmpNPpTvMij9oUe9ZkzZ06NYHX79u3DwQcf3KBtOD/lThyHxHHAdtttF4YNG5Y8Bg0alPSTfJ976mL8VPzfe59Ty1Zs/ck4t2Urtv5UF+PclqPY+pNxbstnnLuO/08IAAAAAFDcsi9zCY1Q+w9oF1988Xp/gKvue9/7Xujfv39q+rHHHksqOeezTbF6cKbwYgxEx1Bslddeey088cQT9f7x8c0336xxu9lYzTOdeBvd2I7q4cfmCE4Vu2LrT7GqeXxkClZXt9FGG4VLLrmkxmt//etfw6pVq3LWJlpufyoU56f8aA396S9/+UuN6X333TfjeyB/vvWtbyW3TJ84cWJS8fGwww4LW2yxRcYLu/LN+KllfO99Ti1XsfUn49yWrdj6U6EY5+ZHa+hPxrnFwzh3Hf+fEAAAAACg+AlXkzcxXDxz5szUdAwF7bXXXhnX6dSpU1LZt7r7778/Z2367LPPwt///vcalZW+/vWvZ1wnBplqV5yur00PPPBAjem4fn2BqCOPPDJpT5Wnn346Vcma4uxP1f9gnK3ddtutRph/2bJlzf6H5lJUjP2pUJyfcq819Kd4Uc+9995b47V4RwWaR6zI2LZt8dxgxvipZXzvfU4tVzH2J+PclqsY+1OhGOfmXmvoT8a5xcU4dx3/nxAAAAAAoPgJV5M3Tz31VI3pQw89NKv1vva1r9WYfvLJJ3PWpv/X3r3AyFWVDwA/fT+2LwotIFSs2KKWUnkUobYlvDSWiq0xyEsRsIJBUaFE0QQ1YJRUYlQivhpFwGisFFBQQaOgQGqraSu0lLaAthQpbJ/0/frn3GbnvzPdmZ3Zndm9d+b3Sxp67s6de2bud89+4X797hNPPBH27t2bG7/vfe8L/fr1a3e/8847L7lB2OLvf/970W7DcXv8eYuBAwcm+7cnzuP888/Pjffs2ZPMl/TGU0e9/e1vzxuvX7++2+bSqOopniphfaqNeoinhQsXhrVr1+bGI0aMCJMnT+62+ZAu8qdsXPfOU3alMZ46Sp7b/eopniohz62NeogneS6lyJ8AAAAAAChGcTU18+STT+aNTzvttLL2O/roo/M6pb344oth3bp1VZnTU0891aE5xcLn8ePH58ZvvPFGWLp0aZuvXbx4cdi+fXtuHPfr27dvWccpnE/hd9jI0hhPHdWrV6+8cSykp2vVUzxVwvpUG/UQT/Pnzz+kIKZwraJxyZ+ycd07T9mVxnjqKHlu96uneKqEPLc26iGe5LmUIn8CAAAAAKAYxdXUzKpVq/4/0Hr2DCeeeGLZ+06YMKHoe3XGypUr88atC6YrnVPhexXbftJJJ3X7564HaYynjlqzZk3e+Igjjui2uTSqeoqnSlifaiPr8bRjx47wxz/+MW/bzJkzu3wepJf8KRvXvfOUXWmMp46S53a/eoqnSshzayPr8STPpT3yJwAAAAAAiuld9CfQCZs3bw4bNmzIjQ8//PAwYMCAsvc/9thj88axy9HUqVM7fU7i+7To0aNHGDVqVKfm1N4xoloco9GkNZ464uWXXw7Lly/PjXv37n3I49Pbs2DBguQ9nnvuudDc3Jzc5B42bFjSGWzixInhnHPOqegfDjSaLMXTXXfdFVavXh3++9//hi1btoSmpqbkXMeYOf3008O0adPCYYcdVvb7WZ8aO56Keeyxx8K2bdty43HjxoWxY8d26L2sT/VJ/pSN6955yqa0xlNHyHO7X5biSZ6bflmKp2LkubRH/gQAAAAAQDGKq6mJWAhY+EjYShx11FEl368j4k3BN954IzcePnx46Nu3b9XnVNitrXC/Uvr165cUSm7cuDEZx2LK+PdKiifrURrjqaPuvffecODAgdz41FNPDUOGDKnoPRYuXHjItu3btyePWY4/+/73vx8mTZoUbr755g4XSNazLMXTvHnz8sabNm1K/rz00kvhD3/4Q/jWt74VLrnkkvDZz342WT/aY31q7Hgq5oEHHsgbz5gxo8PvZX2qP/KnbFz3zlN2pTGeOkqe2/2yFE/y3PTLUjwVI8+lFPkTAAAAAACl9Cz5U+ig1kXMLYXMlSgsJt66dWu3z6nw9cXmVLi9s8cpnHcjSmM8dUTsQByLTlq74ooranKsp556Klx00UXhkUceqcn7Z1m9xFNLUf3cuXPDxRdfnBTXt8f6VH1Zj6dXX301PP3007lxnz59wvTp02t6TOtTtsifqv+dyHOLf5eNKI3x1BHy3HSol3iK5LndL+vxJM+lPfJcAAAAAABK0bmamti2bVveuJyOqq3179//kBurnVX4HpV0rW7rMxSbU+H2zn72wu+yEaUxniq1e/fucOONNyb/bXHGGWeEc889t+z3GDhwYHjPe96T7DdmzJjk5nbv3r2T7ubLli0Ljz76aFiwYEHu9Tt27AizZ89OOmNPnjy56p8pq7IQT/ER2meffXYYP358GD16dHIOd+3aFdavXx8WLVoU5s+fnxQLtIjnf9asWeFXv/pVGDRoUNH3tT41ZjyV8uCDD4b9+/fnxmeddVbFhTOR9al+yZ+ycd07T9mVxniqlDw3PbIQT/Lc7MhCPJUiz6U98icAAAAAAEpRXE1NxKLOahYyF75fR3S2qLDc4urCuVZ6nMLvqhqfPevSGE+V+spXvhKWL1+eGzc1NYXbbrut7KLFW265JcycOTP5e6FYfHvKKaeEyy+/POkIGwuqm5ubk5/t27cv3HDDDUnh9bBhw6r4ibIrzfF00kknhbvvvjspoG/LCSecEKZMmRKuu+668N3vfjf8+Mc/zv1s1apV4dZbbw2333570fe3PjVWPHXkUelxnamE9an+yZ+ycd07T9mVxniqlDw3PdIcT/Lc7ElzPJVDnkt75E8AAAAAAJTSs+RPoUp69OjRqdcfOHAgdXPK8mfPuqx9p7EA9v7778+bTyysHjVqVFn7xy6yl112WZuF1YUmTZoU7rnnnjB48ODcts2bN4e5c+d2cPb1L03xFLsGFyusLixsiEX0sRt6aw899FBYvXp1Jj97vcjSd7p06dK8eImPbo8xWAnrU+ORP1X/O5HnkvZ4KkWem25piid5bvalKZ7aI8+lI+S5AAAAAAC0priamhgwYEDeeNeuXRXtv3PnzrxxOUWl7Sl8j8JjVGtOhZ+90uMUflfV+OxZl8Z4quRRxHfccUfetlgUO23atJod8/jjjw833XRT3rZ58+YphK2DeCr0yU9+Mpx88sm58f79+5NzXYz1qfqyHE+F3fymT58e+vTpU9NjWp+yR/6UjeveecquNMZTueS56ZPleCokz+1+WY4neS7lkD8BAAAAAFCK4mq65AZFpTfhalFgXHhjcPfu3TWZU2dvQBa+vqmpKTS6NMZTOR5//PHwpS99Ka+oedasWeETn/hEzY/9oQ99KAwdOjQ33rBhQ1ixYkXNj5sFWY2nYq688sq88dNPP130tdan6stqPMXfgQ8//HDetpkzZ3bJsa1P2SJ/ysZ17zxlVxrjqRzy3HTKajwVI8/tXlmNJ3ku5ZI/AQAAAABQiuJqamLQoEF5440bN1a0fywEbW3w4MGdnlPhe1Q6p8LXF5tTZ49T+NkLv8tGlMZ4as+iRYvC9ddfH/bu3ZvbdtFFFyVdq7tC7D47ceLEvG3PP/98lxw77bIYT6WceeaZeeNVq1YVfa31qfqyGk9//etfw6ZNm3LjsWPHhnHjxnXJsa1P2SJ/ysZ17zxlVxrjqT3y3PTKYjyVIs/tXlmNJ3ku5ZI/AQAAAABQiuJqauK4447LG7/yyisV7f+///0vbzxq1KhOz2n48OF5Nwebm5sr6l5d+BmKzenNb35zyc/SXmen1jcg442eww47LDS6NMZTKcuWLQvXXntt3mOQ3//+94evfe1roSsdc8wxJW9uN6qsxVN7hgwZkvxpsWfPnrBly5Y2X2t9qr6sxtP8+fPzxjNmzAhdyfqUHfKnbFz3zlN2pTGeSpHnplvW4qk98tzuldV4kudSLvkTAAAAAAClKK6mJoYOHZrcpGjx+uuvhx07dpS9/9q1a/PGb33rW6syr9GjR+f+fuDAgUOOU405tT5GtGbNmqofo9GkNZ7a8sILL4Srr746bN26NbdtypQpYc6cOaFnz65dcvv379+pxzjXqyzFU7n69euXN25d2N+a9an6shhP8R9a/O1vf8uNe/XqFS688MLQlaxP2SJ/ysZ17zxlU1rjqS3y3PTLUjyVS57bfbIYT/JcKiV/AgAAAACgGMXV1Mzb3va23N/3798fnnnmmbL3XbJkSdH36owxY8bkjZcuXVr1ORUeo3C/Ugrnc/zxx5e9b71LYzwVWrduXbjqqqvyOkSfdtpp4c477wx9+vQJXa3wsc3Dhg3r8jmkVRbiqVzxH4ps2rSprHNtfaqNrMXT7373u6TDeYvJkyeHESNGhK5kfcoW+VM2rnvnKbvSGE+F5LnZkYV4Kpc8t/tlLZ7kuVRK/gQAAAAAQDGKq6mZSZMm5Y0XLVpU9qNjX3755bwuMm9605uqMqczzzyzQ3OKHX9b30RsamoKEyZMaPO173rXu8LAgQNz43//+99h9+7dZR2ncD6x4I30xlNrzc3N4corr8x7VPK4cePCD3/4w0M6tHaVGHutjRw5slvmkUZpj6dKrFixIq9QNhZW9+3bt83XWp9qI2vx9MADD+SNZ8yYEbqa9Slb5E/ZuO6dp+xKYzy1Js/NlrTHUyXkud0va/Ekz6VS8icAAAAAAIpRXE3NnHPOOXnj3/72t2Xt99BDD5V8n84466yzQu/evXPjRx99NCmcbs+f/vSnsH379tx4ypQpRYsX4/bWRdFxv7h/e+I84nxaxE7HU6dObXe/RpHGeGqxdevWcPXVV4eXXnopr+v4T37ykzBo0KDQHVavXh2ee+653LhXr17hlFNO6Za5pFGa46lSjzzySN544sSJRV9rfaqNLMXT888/H5599tnceMiQIeG8884LXcn6lD3yp2xc985TdqUxnlrIc7MnzfFUKXlu98tSPMlz6Qj5EwAAAAAAxSiupmZOOOGEMHbs2Lxiqscff7zkPjt37gy//OUv87ZNnz69anMaOnRoUhjdYvPmzeE3v/lNu48ivvvuu/O2feADHyi5T+Gc4/7xfUqZN29e2LJlS94NnsGDB5fcp5GkMZ5ajnHNNdeE5cuX57Yde+yx4ac//WkYPnx46A4x1ubMmZMXc7FjcYx/0h1PlVq7dm24995787bFtaMU61Njx9P8+fPzxtOmTSv6j4VqwfqUTfKnbFz3zlN2pTGeWo4hz82etMZTpeS56ZCleJLn0hHyJwAAAAAAilFcTU19+tOfzhvfeuutSUFzMXfccUfeo2NjN813vvOdRV9///33Jzf7Wv589KMfbXdO1113Xd7429/+dt4xC8XC6CVLluTGcT7nnntuyWO8973vTebTYvHixeHnP/95yRvHcR4tevTocch3R/riac+ePeEzn/lM+Oc//5nbNnLkyPCzn/0sHHnkkVU5ZTH2YvyUa//+/eH2228Pf/nLX/K2X3vttVWZTz1JWzzF7m4bNmwoe/6vvvpq+NSnPhW2bduW2xYftf3BD36w5H7Wp8aIp7bs27fvkG6DM2fODB1lfcou+VP9Xvfy3OxKWzzJc7MtbfEkz822tMVTW+S5dCae5E8AAAAAALRFcTU1FYv4Tj755Nx4zZo14fLLLw8rVqw45HHT8QZd6wLkfv36hc997nNVn9P48ePDBRdckBvHbtGXXnppWLRoUd7rdu3aFe66667wzW9+M6/o+aabbkr+W0r8+ezZs/Ne941vfCP84Ac/SN63tYULF4bLLrss+Q5ad8Z+xzve0anPWY/SFk9f/OIXwxNPPJEb9+/fP9x2223JeY8F8+X+ad2xvFDsDPaRj3wkXHHFFclNwmLFt7EbbIyl+LrYNbu1888/P0ydOrWKn7w+pC2efv3rXyf/cOOWW24JCxYsCLt3727zdTt27Aj33XdfUhQbH33dIsbdl7/85Xa7EFufGiOe2vLkk0+G1157LTcePXp00tW+o6xPtVXu74yNGze2+brW57oa5E/ZuO6dp+xKWzzJc7MtbfEkz822tMVTW+S52SLPPcj/JwQAAAAASLceB2JFHtRQ7K764Q9/OKxfv/7/A69HjzBu3LgwatSosGnTprB06dK87qvRnDlzwoUXXljyvWOx6c0335wbn3766eGee+5pd07xWBdffHFeYWIUH3cbi822b98ennnmmaRgqbV4UzB2ii3XnXfeGb73ve/lbRs+fHg48cQTw4ABA8ILL7wQVq5cmffzWFT9i1/8IgwcOLDs4zSSNMVT6+7kne0EFjtglzOn6JhjjglvectbwuDBg0Pv3r2Tz7xs2bI2C68nTJiQdF+P8Ua64yl21PrHP/6RG/fp0yeMGTMm6YY+aNCgpINknO+zzz6b/L3QF77whXDVVVeVfZqtT/UdT2254YYbwsMPP5w3vuaaayp6j1JziqxP1dPZ3zGlYkT+VN/XvTw3u9IUT/Lc7EtTPMlzsy9N8dQWeW62yHP9f0IAAAAAgCzo3d0ToP4deeSRYe7cueH6668PL774YrIt1vTH4uX4p1DsbBQ7pbV3A64zmpqawo9+9KOkWHrx4sW57bHYurDgOurZs2dSgFZJYXXLo0VjEWQ81v79+5NtsQC2dbfj1mI3qO985zsKqzMWT10tPmK59WOWi7nkkkuSm9TxOyB78RTXjlg0H/+UMmzYsPD1r389edx2JaxPjRVPsZPgn//857zfa7U4rvWpvsmfsnHdO0/ZlcZ46mp+jzRGPMlzsyfN8STPpRrkTwAAAAAAFOp5yBaogdgRev78+WHWrFnh8MMPb/M1sUvr2WefnTwy+NJLL635eTj66KPDfffdF2688cak02ZbYiemM844I3msbUceZRv3//znP590Dn73u9+djNsSjx/nEecTb1qSvXiqlVNPPTV8/OMfTzqaxy7V7YkdjmfOnBkefPDB8NWvflVhdYbi6WMf+1i44IILyl4DYvfy2bNnh8cee6ziwurI+lTf8VTo97//fdi5c2duHH+3xd+DnWF9akzyp2xc985TdqUxnmrF75HGiSd5bn1ISzwVkudSLfInAAAAAABa63EgtpqBLrR3797wr3/9K6xduza8/vrrSXeYo446KunaPHz48G45F/EyWLJkSfjPf/6TPOa2f//+SYHj+PHjO1181tq6deuSrk7xkbqxyG3kyJHhuOOOCxMmTChaeE324qlWdu3aFVauXJl09HvttdfC9u3bw759+8LgwYPD0KFDw5gxY5Ib3rEjLdmOp+bm5rBq1arwyiuvhI0bNybrRSyuj+f5iCOOSNamESNGVPWY1qf6jaeuYH1qTPKnbFz3zlN2pTGeasXvkcaJJ3lufUhLPHUF61Njkj8BAAAAAKC4GgAAAAAAAAAAAAAghKC9KQAAAAAAAAAAAACA4moAAAAAAAAAAAAAgIN0rgYAAAAAAAAAAAAAUFwNAAAAAAAAAAAAAHCQztUAAAAAAAAAAAAAAIqrAQAAAAAAAAAAAAAO0rkaAAAAAAAAAAAAAEBxNQAAAAAAAAAAAADAQTpXAwAAAAAAAAAAAAAorgYAAAAAAAAAAAAAOEjnagAAAAAAAAAAAAAAxdUAAAAAAAAAAAAAAAfpXA0AAAAAAAAAAAAAoLgaAAAAAAAAAAAAAOAgnasBAAAAAAAAAAAAABRXAwAAAAAAAAAAAAAcpHM1AAAAAAAAAAAAAIDiagAAAAAAAAAAAACAg3SuBgAAAAAAAAAAAABQXA0AAAAAAAAAAAAAcJDO1QAAAAAAAAAAAAAAiqsBAAAAAAAAAAAAAA7SuRoAAAAAAAAAAAAAQHE1AAAAAAAAAAAAAMBBOlcDAAAAAAAAAAAAACiuBgAAAAAAAAAAAAA4SOdqAAAAAAAAAAAAACAQwv8BGJVYzbjq43YAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_ecdf_pit(sbc.simulations,\n", + " group=\"posterior_sbc\",\n", + " visuals={\"xlabel\": False},\n", + ");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Intentionally Skewing the Augmented Posterior Using Custom augmentation with `augment_observed`\n", + "\n", + "We intentionally skew the augmented posterior by keeping only 1 of the original observations and concatenating them with the replicated data. This creates a mismatch between the reference draw (which is based on the full observed data) and the augmented posterior (which is based on a subset of the observed data), leading to skewed rank statistics." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def augment_observed(model, observed_data, replicated_data, simulation_idx):\n", + " \"\"\"Keep only the last 25 original observations + replicated.\"\"\"\n", + " data = {\"y\": np.concatenate([observed_data[\"y\"].values[-1:], replicated_data[\"y\"]])}\n", + " return data\n", + "\n", + "\n", + "def update_data(model, augmented_data, simulation_idx):\n", + " with model:\n", + " pm.set_data(\n", + " new_data={\n", + " \"sigma\": np.concatenate(\n", + " [model[\"sigma\"].get_value()[-1:], model[\"sigma\"].get_value()]\n", + " ),\n", + " \"school_idx\": np.concatenate(\n", + " [model[\"school_idx\"].get_value()[-1:], model[\"school_idx\"].get_value()]\n", + " ),\n", + " },\n", + " coords={\"obs\": np.arange(8 + 1)},\n", + " )\n", + "\n", + "skewed_sbc = simuk.SBC(\n", + " centered_eight,\n", + " method=\"posterior\",\n", + " trace=trace,\n", + " augment_observed=augment_observed,\n", + " update_data=update_data,\n", + " num_simulations=50,\n", + " sample_kwargs={\"chains\": 4, \"draws\": 50, \"tune\": 50},\n", + " progress_bar=False,\n", + ")\n", + "\n", + "skewed_sbc.run_simulations()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize the skewed results and and Replot the Original Simulations using `compute_rank_statistics`\n", + "\n", + "The results indicate a clear deviation from uniformity, with the ECDF lines falling outside the credible interval, as indicated by the red points. This suggests that the self-consistency property of Bayesian updating does not hold." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_ecdf_pit(skewed_sbc.simulations, group=\"posterior_sbc\", visuals={\"xlabel\": False})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We shall also replot the original Posterior SBC results using the same quantity using `compute_rank_statistics`. This allows us to compare the results without need to re-run the simulations." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sbc.compute_rank_statistics(lambda _, param_value: param_value)\n", + "plot_ecdf_pit(sbc.simulations, group=\"posterior_sbc\", visuals={\"xlabel\": False})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References\n", + "\n", + "- Säilynoja, T., Schmitt, M., Bürkner, P.-C., & Vehtari, A. (2025).\n", + " *Posterior SBC: Simulation-Based Calibration Checking Conditional on Data*.\n", + " [arXiv:2502.03279](https://arxiv.org/abs/2502.03279)\n", + "- Talts, S., Betancourt, M., Simpson, D., Vehtari, A., & Gelman, A. (2020).\n", + " *Validating Bayesian Inference Algorithms with Simulation-Based Calibration*.\n", + " [arXiv:1804.06788](https://arxiv.org/abs/1804.06788)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "simuk_dev", + "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.14.4" + }, + "tags": [ + "skip-execution" + ] + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/examples/gallery/posterior_sbc.md b/docs/examples/gallery/posterior_sbc.md deleted file mode 100644 index b0f26a4..0000000 --- a/docs/examples/gallery/posterior_sbc.md +++ /dev/null @@ -1,236 +0,0 @@ ---- -jupytext: - text_representation: - extension: .md - format_name: myst -kernelspec: - display_name: Python 3 - language: python - name: python3 ---- - -# Posterior Simulation-Based Calibration - -**Posterior SBC** (Säilynoja et al., 2025) validates the inference algorithm -*conditional on observed data*, rather than averaging over the prior. - -```{admonition} When to use Posterior SBC -:class: tip - -Use **Prior SBC** when you want to check that your inference pipeline works -for a wide range of datasets generated under the prior. - -Use **Posterior SBC** when you already have observed data and want to verify -that the inference algorithm is trustworthy *for that specific dataset*. -Posterior SBC focuses on the region of the parameter space that matters -for the observed data, making it more sensitive to local calibration issues. -``` - -```{jupyter-execute} - -import pymc as pm -from arviz_plots import plot_ecdf_pit, style -import matplotlib.pyplot as plt -import numpy as np -import simuk - -style.use("arviz-variat") -``` - -## How Posterior SBC works - -Given a model $\pi(\theta, y) = \pi(\theta)\,\pi(y \mid \theta)$ and -observed data $y_{\text{obs}}$, Posterior SBC proceeds as follows: - -1. **Fit the model** to $y_{\text{obs}}$ to obtain posterior draws - $\theta'_i \sim \pi(\theta \mid y_{\text{obs}})$. -2. **Generate replicated data** from the posterior predictive: - $y_i \sim \pi(y \mid \theta'_i)$. -3. **Augment** the observations: $y_{\text{aug}} = (y_{\text{obs}}, y_i)$. -4. **Re-fit the model** on the augmented data to get - $\theta''_{i,1}, \ldots, \theta''_{i,S} \sim \pi(\theta \mid y_i, y_{\text{obs}})$. -5. **Compute the rank statistics** of $f(\theta'_i)$ among $f(\theta''_{i,1}), \ldots, f(\theta''_{i,S})$. Where $f$ is an optional test quantity applied to the parameters before computing ranks. - -By the self-consistency of Bayesian updating, $\theta'_i$ is also a draw -from the augmented posterior $\pi(\theta \mid y_i, y_{\text{obs}})$. -Therefore the rank statistics should be **uniformly distributed** if the inference -is calibrated. - -## Example: Linear Regression Model - -### Define the model - -```{admonition} Model requirements for Posterior SBC -:class: warning - -Posterior SBC augments the observed data (concatenating original + replicated), -which changes its size. For this to work, store observed data in ``pm.Data`` -containers, and specify size using the ``dims`` parameter instead of setting a static shape. -If your model uses ``dims`` and ``coords``, you are also responsible for resizing them to the correct size corresponding to the new augmented dataset via the ``update_data`` callback. -Similarly, if your model has covariates, store them in ``pm.Data`` so they -can be resized in the same callback. -``` - -```{jupyter-execute} - -random_seed = 42 -np.random.seed(random_seed) - -x_data = np.linspace(0, 10, 100) -y_data = np.random.normal(x_data ** 1.2, 1) - -coords = { - "obs_id": np.arange(len(x_data)) -} - -with pm.Model(coords=coords) as model: - model_x_data = pm.Data("x_data", x_data, dims="obs_id") - model_y_data = pm.Data("y_data", y_data, dims="obs_id") - - alpha = pm.Normal("alpha", mu=0, sigma=10) - beta = pm.Normal("beta", mu=0, sigma=10) - sigma = pm.HalfNormal("sigma", sigma=10) - - # pm.Deterministic forces PyMC to track this equation's output - mu = pm.Deterministic("mu", alpha + beta * model_x_data) - y = pm.Normal("y", mu=mu, sigma=sigma, observed=model_y_data) -``` - -### Fit the original posterior - -First, we need the posterior samples from the observed data. These will -serve as the reference distribution for Posterior SBC. - -```{jupyter-execute} - -with model: - idata = pm.sample(200, random_seed=random_seed, progressbar=False) -``` - -### Using `update_data` with covariates and `dims` - -When your model uses `dims`/`coords` or has covariates stored in `pm.Data`, -you must provide an `update_data` callback that resizes everything to -match the augmented observations. The callback is called **before** the model -is re-conditioned, and runs inside the model context. - -```{jupyter-execute} - -def update_data(model, augmented_data, simulation_idx): - with model: - pm.set_data( - {"x_data": np.concatenate([model["x_data"].get_value(), model["x_data"].get_value()])}, - coords={"obs_id": np.arange(len(augmented_data["y"]))}, - ) -``` - -### Custom test quantities with `param_transform` - -You can define a scalar test quantity applied to both the reference draw -and the posterior draws before computing the rank statistic. The function -receives `(param_name, param_value)` and should return a comparable value. - -```{jupyter-execute} - -def param_transform(param_name, param_value): - return np.pow(param_value, 2) -``` - -### Run Posterior SBC - -Pass `method="posterior"` and provide the `trace`. Each iteration -generates replicated data from the posterior predictive, augments it -with the original observations, and re-fits the model. - -```{jupyter-execute} -sbc = simuk.SBC( - model, - method="posterior", - trace=idata, - transform=param_transform, - update_data=update_data, - num_simulations=50, - seed=random_seed, - sample_kwargs={"chains": 4, "draws": 50, "tune": 50}, - progress_bar=False, -) - -sbc.run_simulations(); -``` - -### Visualize the results - -We expect the ECDF lines to fall inside the grey simultaneous confidence -band, indicating that the ranks are consistent with a uniform distribution. - -```{jupyter-execute} - -plot_ecdf_pit(sbc.simulations, - group="posterior_sbc", - visuals={"xlabel": False}, -); -``` - -## Intentionally Skewing the Augmented Posterior Using Custom augmentation with `augment_observed` - -We intentionally skew the augmented posterior by keeping only the last 25 original observations and concatenating them with the replicated data. This creates a mismatch between the reference draw (which is based on the full observed data) and the augmented posterior (which is based on a subset of the observed data), leading to skewed rank statistics. - -```{jupyter-execute} - -def augment_observed(model, observed_data, replicated_data, simulation_idx): - """Keep only the last 25 original observations + replicated.""" - data = {"y": np.concatenate([observed_data["y"].values[-25:], replicated_data["y"]])} - return data - - -def update_data(model, augmented_data, simulation_idx): - with model: - pm.set_data( - { - "x_data": np.concatenate( - [model["x_data"].get_value()[-25:], model["x_data"].get_value()] - ) - }, - coords={"obs_id": np.arange(25 + len(model["x_data"].get_value()))}, - ) - - -skewed_sbc = simuk.SBC( - model, - method="posterior", - trace=idata, - augment_observed=augment_observed, - update_data=update_data, - num_simulations=50, - sample_kwargs={"chains": 4, "draws": 50, "tune": 50}, - progress_bar=False, -) - -skewed_sbc.run_simulations() -``` - -### Visualize the skewed results - -The results indicate a clear deviation from uniformity, with the ECDF lines falling outside the confidence band. This suggests that the self-consistency property of Bayesian updating does not hold. - -```{jupyter-execute} - -plot_ecdf_pit(skewed_sbc.simulations, group="posterior_sbc", visuals={"xlabel": False}) -``` - -We shall also replot the original Posterior SBC results using the same quantity using `compute_rank_statistics`. This allows us to compare the results without need to re-run the simulations. - -```{jupyter-execute} - -sbc.compute_rank_statistics(lambda _, param_value: param_value) -plot_ecdf_pit(sbc.simulations, group="posterior_sbc", visuals={"xlabel": False}) -``` - -## References - -- Säilynoja, T., Schmitt, M., Bürkner, P.-C., & Vehtari, A. (2025). - *Posterior SBC: Simulation-Based Calibration Checking Conditional on Data*. - [arXiv:2502.03279](https://arxiv.org/abs/2502.03279) -- Talts, S., Betancourt, M., Simpson, D., Vehtari, A., & Gelman, A. (2020). - *Validating Bayesian Inference Algorithms with Simulation-Based Calibration*. - [arXiv:1804.06788](https://arxiv.org/abs/1804.06788) diff --git a/docs/examples/gallery/prior_sbc.ipynb b/docs/examples/gallery/prior_sbc.ipynb new file mode 100644 index 0000000..bb5a924 --- /dev/null +++ b/docs/examples/gallery/prior_sbc.ipynb @@ -0,0 +1,416 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Prior Simulation based calibration" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from arviz_plots import plot_ecdf_pit, style\n", + "import numpy as np\n", + "import simuk\n", + "style.use(\"arviz-variat\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Out-of-the-box Prior SBC\n", + "This example demonstrates how to use the `SBC` class for prior simulation-based calibration, supporting PyMC, Bambi and Numpyro models. By default, the generative model implied by the probabilistic model is used.\n", + "\n", + "We perform Prior SBC on the centered eight school model, which is known to have a funnel-shaped posterior distribution. The inference algorithm struggles with this model when $\\tau$ is small, and thus we expect to see deviations from the uniform distribution in the rank statistics.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### PyMC\n", + "\n", + "First, define a PyMC model. In this example, we will use the centered eight schools model." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import pymc as pm\n", + "\n", + "data = np.array([28.0, 8.0, -3.0, 7.0, -1.0, 1.0, 18.0, 12.0])\n", + "sigma = np.array([15.0, 10.0, 16.0, 11.0, 9.0, 11.0, 10.0, 18.0])\n", + "\n", + "with pm.Model() as centered_eight:\n", + " mu = pm.Normal('mu', mu=0, sigma=5)\n", + " tau = pm.HalfCauchy('tau', beta=5)\n", + " theta = pm.Normal('theta', mu=mu, sigma=tau, shape=8)\n", + " y_obs = pm.Normal('y', mu=theta, sigma=sigma, observed=data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pass the model to the SBC class, set the number of simulations to 100, and run the simulations. This process may take\n", + "some time since the model runs multiple times (100 in this example)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sbc = simuk.SBC(centered_eight,\n", + " num_simulations=100,\n", + " sample_kwargs={'draws': 100, 'tune': 100})\n", + "\n", + "sbc.run_simulations();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To compare the prior and posterior distributions, we will plot the results from the simulations,\n", + "using the ArviZ function `plot_ecdf_pit`.\n", + "If the inference algorithm was well-calibrated, we expect a uniform distribution that lies within the 94% credible interval, indicated by not having any red points.\n", + "In our case, we see a clear deviation from the uniform distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_ecdf_pit(sbc.simulations,\n", + " visuals={\"xlabel\":False},\n", + ");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Bambi\n", + "\n", + "Now, we define a Bambi Model." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import bambi as bmb\n", + "import pandas as pd\n", + "\n", + "x = np.random.normal(0, 1, 200)\n", + "y = 2 + np.random.normal(x, 1)\n", + "df = pd.DataFrame({\"x\": x, \"y\": y})\n", + "bmb_model = bmb.Model(\"y ~ x\", df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pass the model to the `SBC` class, set the number of simulations to 100, and run the simulations.\n", + "This process may take some time, as the model runs multiple times" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "sbc = simuk.SBC(bmb_model,\n", + " num_simulations=100,\n", + " sample_kwargs={'draws': 25, 'tune': 50})\n", + "\n", + "sbc.run_simulations();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To compare the prior and posterior distributions, we will plot the results from the simulations.\n", + "If the inference algorithm was well-calibrated, we expect a uniform distribution that lies within the 94% credible interval, indicated by not having any red points." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_ecdf_pit(sbc.simulations)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Numpyro\n", + "\n", + "We define a Numpyro Model, we use the centered eight schools model." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpyro\n", + "import numpyro.distributions as dist\n", + "from jax import random\n", + "from numpyro.infer import NUTS\n", + "\n", + "y = np.array([28.0, 8.0, -3.0, 7.0, -1.0, 1.0, 18.0, 12.0])\n", + "sigma = np.array([15.0, 10.0, 16.0, 11.0, 9.0, 11.0, 10.0, 18.0])\n", + "\n", + "def eight_schools_cauchy_prior(J, sigma, y=None):\n", + " mu = numpyro.sample(\"mu\", dist.Normal(0, 5))\n", + " tau = numpyro.sample(\"tau\", dist.HalfCauchy(5))\n", + " with numpyro.plate(\"J\", J):\n", + " theta = numpyro.sample(\"theta\", dist.Normal(mu, tau))\n", + " numpyro.sample(\"y\", dist.Normal(theta, sigma), obs=y)\n", + "\n", + "# We use the NUTS sampler\n", + "nuts_kernel = NUTS(eight_schools_cauchy_prior)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pass the model to the `SBC` class, set the number of simulations to 100, and run the simulations. For numpyro model,\n", + "we pass in the ``data_dir`` parameter." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100/100 [01:49<00:00, 1.09s/it]\n" + ] + } + ], + "source": [ + "sbc = simuk.SBC(nuts_kernel,\n", + " sample_kwargs={\"num_warmup\": 50, \"num_samples\": 75},\n", + " num_simulations=100,\n", + " data_dir={\"J\": 8, \"sigma\": sigma, \"y\": y},\n", + ")\n", + "sbc.run_simulations()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To compare the prior and posterior distributions, we will plot the results from the simulations,\n", + "using the ArviZ function `plot_ecdf_pit`.\n", + "If the inference algorithm was well-calibrated, we expect a uniform distribution that lies within the 94% credible interval, indicated by not having any red points.\n", + "In our case, we see a clear deviation from the uniform distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_ecdf_pit(sbc.simulations,\n", + " visuals={\"xlabel\":False},\n", + ");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Custom simulator SBC" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### PyMC\n", + "\n", + "In certain scenarios, you might want to pass a custom function to the `SBC` class to generate the data. For instance, if you aim to evaluate the effect of model misspecification by generating data from a different model than the one used for model fitting.\n", + "\n", + "Next, we determine the impact of occasional large deviations (outliers) by drawing from a Laplace distribution instead of a normal distribution (which we use to fit the model)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def simulator(theta, seed, **kwargs):\n", + " rng = np.random.default_rng(seed)\n", + " # Here we use a Laplace distribution, but it could also be some mechanistic simulator\n", + " scale = sigma / np.sqrt(2)\n", + " return {\"y\": rng.laplace(theta, scale)}\n", + "\n", + "sbc = simuk.SBC(centered_eight,\n", + " num_simulations=100,\n", + " simulator=simulator,\n", + " sample_kwargs={'draws': 25, 'tune': 50})\n", + "\n", + "sbc.run_simulations();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Bambi\n", + "\n", + "In certain scenarios, you might want to pass a custom function to the `SBC` class to generate the data. For instance, if you aim to evaluate the effect of model misspecification by generating data from a different model than the one used for model fitting.\n", + "\n", + "Next, we determine the impact of occasional large deviations (outliers) by drawing from a Laplace distribution instead of a normal distribution (which we use to fit the model)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def simulator(mu, seed, sigma, **kwargs):\n", + " rng = np.random.default_rng(seed)\n", + " # Here we use a Laplace distribution, but it could also be some mechanistic simulator\n", + " scale = sigma / np.sqrt(2)\n", + " return {\"y\": rng.laplace(mu, scale)}\n", + "\n", + "sbc = simuk.SBC(bmb_model,\n", + " num_simulations=100,\n", + " simulator=simulator,\n", + " sample_kwargs={'draws': 25, 'tune': 50})\n", + "\n", + "sbc.run_simulations();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Numpyro\n", + "\n", + "In certain scenarios, you might want to pass a custom function to the `SBC` class to generate the data. For instance, if you aim to evaluate the effect of model misspecification by generating data from a different model than the one used for model fitting.\n", + "\n", + "Next, we determine the impact of occasional large deviations (outliers) by drawing from a Laplace distribution instead of a normal distribution (which we use to fit the model)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def simulator(theta, seed, **kwargs):\n", + " rng = np.random.default_rng(seed)\n", + " # Here we use a Laplace distribution, but it could also be some mechanistic simulator\n", + " scale = sigma / np.sqrt(2)\n", + " return {\"y\": rng.laplace(theta, scale)}\n", + "\n", + "sbc = simuk.SBC(nuts_kernel,\n", + " sample_kwargs={\"num_warmup\": 50, \"num_samples\": 75},\n", + " num_simulations=100,\n", + " simulator=simulator,\n", + " data_dir={\"J\": 8, \"sigma\": sigma, \"y\": y}\n", + ")\n", + "\n", + "sbc.run_simulations();" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "simuk_dev", + "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.14.4", + "tags": ["skip-execution"] + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/examples/gallery/prior_sbc.md b/docs/examples/gallery/prior_sbc.md deleted file mode 100644 index f138600..0000000 --- a/docs/examples/gallery/prior_sbc.md +++ /dev/null @@ -1,240 +0,0 @@ ---- -jupytext: - text_representation: - extension: .md - format_name: myst -kernelspec: - display_name: Python 3 - language: python - name: python3 ---- - -# Prior Simulation based calibration - -```{jupyter-execute} - -from arviz_plots import plot_ecdf_pit, style -import numpy as np -import simuk -style.use("arviz-variat") -``` - -## Out-of-the-box Prior SBC -This example demonstrates how to use the `SBC` class for prior simulation-based calibration, supporting PyMC, Bambi and Numpyro models. By default, the generative model implied by the probabilistic model is used. - - -::::::{tab-set} -:class: full-width - -:::::{tab-item} PyMC -:sync: pymc_default - -First, define a PyMC model. In this example, we will use the centered eight schools model. - -```{jupyter-execute} - -import pymc as pm - -data = np.array([28.0, 8.0, -3.0, 7.0, -1.0, 1.0, 18.0, 12.0]) -sigma = np.array([15.0, 10.0, 16.0, 11.0, 9.0, 11.0, 10.0, 18.0]) - -with pm.Model() as centered_eight: - mu = pm.Normal('mu', mu=0, sigma=5) - tau = pm.HalfCauchy('tau', beta=5) - theta = pm.Normal('theta', mu=mu, sigma=tau, shape=8) - y_obs = pm.Normal('y', mu=theta, sigma=sigma, observed=data) -``` - -Pass the model to the SBC class, set the number of simulations to 100, and run the simulations. This process may take -some time since the model runs multiple times (100 in this example). - -```{jupyter-execute} - -sbc = simuk.SBC(centered_eight, - num_simulations=100, - sample_kwargs={'draws': 25, 'tune': 50}) - -sbc.run_simulations(); -``` - -To compare the prior and posterior distributions, we will plot the results from the simulations, -using the ArviZ function `plot_ecdf_pit`. -We expect a uniform distribution, the gray envelope corresponds to the 94% credible interval. - -```{jupyter-execute} - -plot_ecdf_pit(sbc.simulations, - visuals={"xlabel":False}, -); -``` - -::::: - -:::::{tab-item} Bambi -:sync: bambi_default - -Now, we define a Bambi Model. - -```{jupyter-execute} - -import bambi as bmb -import pandas as pd - -x = np.random.normal(0, 1, 200) -y = 2 + np.random.normal(x, 1) -df = pd.DataFrame({"x": x, "y": y}) -bmb_model = bmb.Model("y ~ x", df) -``` - -Pass the model to the `SBC` class, set the number of simulations to 100, and run the simulations. -This process may take some time, as the model runs multiple times - -```{jupyter-execute} - -sbc = simuk.SBC(bmb_model, - num_simulations=100, - sample_kwargs={'draws': 25, 'tune': 50}) - -sbc.run_simulations(); -``` - -To compare the prior and posterior distributions, we will plot the results from the simulations. -We expect a uniform distribution, the gray envelope corresponds to the 94% credible interval. - -```{jupyter-execute} -plot_ecdf_pit(sbc.simulations) -``` - -::::: - -:::::{tab-item} Numpyro -:sync: numpyro_default - -We define a Numpyro Model, we use the centered eight schools model. - -```{jupyter-execute} -import numpyro -import numpyro.distributions as dist -from jax import random -from numpyro.infer import NUTS - -y = np.array([28.0, 8.0, -3.0, 7.0, -1.0, 1.0, 18.0, 12.0]) -sigma = np.array([15.0, 10.0, 16.0, 11.0, 9.0, 11.0, 10.0, 18.0]) - -def eight_schools_cauchy_prior(J, sigma, y=None): - mu = numpyro.sample("mu", dist.Normal(0, 5)) - tau = numpyro.sample("tau", dist.HalfCauchy(5)) - with numpyro.plate("J", J): - theta = numpyro.sample("theta", dist.Normal(mu, tau)) - numpyro.sample("y", dist.Normal(theta, sigma), obs=y) - -# We use the NUTS sampler -nuts_kernel = NUTS(eight_schools_cauchy_prior) -``` - -Pass the model to the `SBC` class, set the number of simulations to 100, and run the simulations. For numpyro model, -we pass in the ``data_dir`` parameter. - -```{jupyter-execute} -sbc = simuk.SBC(nuts_kernel, - sample_kwargs={"num_warmup": 50, "num_samples": 75}, - num_simulations=100, - data_dir={"J": 8, "sigma": sigma, "y": y}, -) -sbc.run_simulations() -``` - -To compare the prior and posterior distributions, we will plot the results. -We expect a uniform distribution, the gray envelope corresponds to the 94% credible interval. - -```{jupyter-execute} -plot_ecdf_pit(sbc.simulations, - visuals={"xlabel":False}, -); -``` - -::::: - -:::::: - -## Custom simulator SBC - -::::::{tab-set} -:class: full-width - -:::::{tab-item} PyMC -:sync: pymc_custom - -In certain scenarios, you might want to pass a custom function to the `SBC` class to generate the data. For instance, if you aim to evaluate the effect of model misspecification by generating data from a different model than the one used for model fitting. - -Next, we determine the impact of occasional large deviations (outliers) by drawing from a Laplace distribution instead of a normal distribution (which we use to fit the model). - -```{jupyter-execute} -def simulator(theta, seed, **kwargs): - rng = np.random.default_rng(seed) - # Here we use a Laplace distribution, but it could also be some mechanistic simulator - scale = sigma / np.sqrt(2) - return {"y": rng.laplace(theta, scale)} - -sbc = simuk.SBC(centered_eight, - num_simulations=100, - simulator=simulator, - sample_kwargs={'draws': 25, 'tune': 50}) - -sbc.run_simulations(); -``` - -::::: - -:::::{tab-item} Bambi -:sync: bambi_custom - -In certain scenarios, you might want to pass a custom function to the `SBC` class to generate the data. For instance, if you aim to evaluate the effect of model misspecification by generating data from a different model than the one used for model fitting. - -Next, we determine the impact of occasional large deviations (outliers) by drawing from a Laplace distribution instead of a normal distribution (which we use to fit the model). - -```{jupyter-execute} -def simulator(mu, seed, sigma, **kwargs): - rng = np.random.default_rng(seed) - # Here we use a Laplace distribution, but it could also be some mechanistic simulator - scale = sigma / np.sqrt(2) - return {"y": rng.laplace(mu, scale)} - -sbc = simuk.SBC(bmb_model, - num_simulations=100, - simulator=simulator, - sample_kwargs={'draws': 25, 'tune': 50}) - -sbc.run_simulations(); -``` - -::::: - - -:::::{tab-item} Numpyro -:sync: numpyro_custom - -In certain scenarios, you might want to pass a custom function to the `SBC` class to generate the data. For instance, if you aim to evaluate the effect of model misspecification by generating data from a different model than the one used for model fitting. - -Next, we determine the impact of occasional large deviations (outliers) by drawing from a Laplace distribution instead of a normal distribution (which we use to fit the model). - -```{jupyter-execute} -def simulator(theta, seed, **kwargs): - rng = np.random.default_rng(seed) - # Here we use a Laplace distribution, but it could also be some mechanistic simulator - scale = sigma / np.sqrt(2) - return {"y": rng.laplace(theta, scale)} - -sbc = simuk.SBC(nuts_kernel, - sample_kwargs={"num_warmup": 50, "num_samples": 75}, - num_simulations=100, - simulator=simulator, - data_dir={"J": 8, "sigma": sigma, "y": y} -) - -sbc.run_simulations(); -``` - -::::: - -:::::: diff --git a/docs/examples/img/posterior_sbc.png b/docs/examples/img/posterior_sbc.png index 7d827d1e4720066518743bd5689eec6191930dad..b6c67fa093adf82b5a6057526aa12e1afdced1fb 100644 GIT binary patch literal 105899 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
SwSS(cNFP5qeGm! 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 z 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 diff --git a/docs/examples/img/prior_sbc.png b/docs/examples/img/prior_sbc.png index af495fd70477d66247e3eae97d13f8ed7d70fdc2..dfb79e239e561af4c51ed10ba055912de5f9e405 100644 GIT binary patch literal 104838 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
;dXog0@G687gsC8m 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 z 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 ON_(rpPu$JF9QhBm#d$mc literal 112794 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 diff --git a/docs/index.rst b/docs/index.rst index 538a462..e5b8bc0 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -2,8 +2,13 @@ Overview ======== Simuk is a Python library for simulation-based calibration (SBC) and the generation of synthetic data. -Simulation-Based Calibration (SBC) is a method for validating Bayesian inference by checking whether the -posterior distributions align with the expected theoretical results derived from the prior (posterior). + +Prior Simulation-Based Calibration (Prior SBC) is a method for validating Bayesian inference by checking +whether the posterior distributions align with the expected theoretical results derived from the prior. + +Posterior Simulation-Based Calibration (Posterior SBC) is a method for validating Bayesian inference by +checking whether the posterior distributions conditioned on the augmented data (original + posterior predictive) +align with the expected theoretical results derived from the posterior. Prior SBC Quickstart ---------- diff --git a/posterior_ecdf.png b/posterior_ecdf.png deleted file mode 100644 index bb7733c7992b2e1ad11bb2aeb8652454824a9d71..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 46542 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 T;S=HNNI}$;uPb3MnfU!5KfIs= diff --git a/prior_ecdf.png b/prior_ecdf.png deleted file mode 100644 index 48c0deb7cdfb256390b444a3c44eb8f361fb3a7e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 110226 zcmd?RXH*nv*EU*;VH6dWBnYB_fC3^SK~ggklx!piCC5f`Zg3n$K(c_uMgeSu50gV{~K!84j*Jbh#<&e z#p`mn5QJJ2LH0cVYabjD>|r{7f)WOlx z4l8s)@Ztp_zS9;?P7fT#1q5vWbH)Wb2Xg_lv-tt=DF+^0*LFmZQ=ibEUD#%4X=E3I zD9ZhP$1VOxzh}I@v$p_ccEIyOoyn!T2F|^oalLmE~#a+TGQ) zA{5BudlIcOmfg~%uE}hCBZWPRzBcvx`^%*#T66#KUzgvti}2LjYYlPqfOv)nT{IIHWWSM7!WyhIQgIi5_^P{02?{j2(ae$ug*Ma+Nx2|-S?(`i!u_gA@pNml>;&G+dI zy~F?g_2{wxbxrpF`!4$QY2tsZ)IU~5tDaswz1XH665=(&!D<7yViHF=B*Pt3{68(w z@aG;0B{L;cr1hz+tm4f+M`Dn1h*ZHN{;zL(v8DW(73-6+z4)!gH#M(MExkQb@E79i z5{lQA#qGQ9_s3>h)k|H5Y_pz&8&+7%=3*PYALoN!+ro@h@l%csf&sD!a!>|`J-o(r zn)Uy+-8|M3;qrR}eLMQS78>V<*|x<_xqW}g6J0NO>C*8K_XcAU*=LKa>yen9on15< zrE6qk!}q18X86NHD#6Q_={|q{ob5c-DK=L{`})rL{Kfc;%TiLTD}9dYl0QFC&3%7F z^CeNrlZ2ivA#sw5iYgo1U-Iq!ecAX2pAO8u_mko~AF0%%x(`V@JVG`ZG56(&eAi(m zJgxA{b!4LSaBHJ;siNg+rZpQs{V*)*9<32aHoZvx+?{y(+T+8hSvf?an$LB4WhF2sjraP^BQsdsS8rO#t3 z!=5O$QuX79&8y)I?Od+JpZ{`K6_XQBlH(oK7FSjZ(=!mHUk;b4irZJqCiFX4WcKO% zY%bY<+{;)+MI-s1gj*T#w4+oTQsljs2!=thips!>ii#@oix)4RR<6ZW`txR$U9$hX zI#a)t^p!X38SIBou;E&yp?_h;Qih+__6i;icHdef*KBQW=(;rIsi>>h$TR9ccM(F6 z>(_B=(Ue1UH`RN7XDi?ID?|U%lBxx8b1(6BB@?MdYh!WNGuw-AFjB$dlW${tHG2xe zxiM>XbK%itoNAJDRWI=PkSw3gDf$W$QUY1K$>9Tv|Y*>jHZGIEc=hJJWY^r{en8qm*`5$=;~L^idzd>U3!kHeeUE0G=gI{5ag%O zd@h9#LnVI;tsr?Pe-{aDm$_=j8gPV)*j@}=vnC>OF}bQn0%BgXpPVA#ZAn?fZ?7Gz ztlV7g9o{S8_A#J7(T6h37E&WMV}FgZ^>IJjGl;wiL1E$iAH$uQ`X|{|KkO&fspIBz zdS@%Qw^lO-*E3?P&z=;;J`?a+s}~d#EBdiqFHk9oZhME#iUdTV+rUDirsIYKwrJ>y z*yP*SB=Bs)l>PRi`Zk>%ZXwPZyNw#vttHUlPM6>=MC>|F`Z@&O8;3tzi!ey6jYJF+ zw|)?#`duK@s|B`50-39;60>EF-GheU_QKS%?Cb{H>s?)Zhy0(4t&hLfKts;EOVCG9-M|&1H6P#KV z?Hh%=+WRV8X9rAuwu9`vUXK}jczO;$7VsK+XS?y(aP={Lp`qt={@gQjN#l;;yw7Oj zv^Lz(@ghqM`oj{1W+1nGD|NN|F<6N?!XkEbiEq+#dvm2QI|V`V!YO?x)|l?O|EaU5 zWxtL(#5;Ft^UerKN|uq9{r&yn!U?lpZ^n$x%*>+n50)Dg_BklG)x7OWa2;S`G;q7` zHKA-6(B0h~#o|azl;Xc~1VN_HV!9xbwPOBMs@l-uV2KO+_U+T?GjEI)=EWLfpA^F% zu##P>rT>q<;@oMnSRc4HrX~*d??p_E<%GR8{Wm}!{PT|9kmNhg{RSDnhq{aGhu>{1 zF1BwA4?^hZ*L#Rs+1R8{leKT?zG$N4Cu8hoBI-#zZdbX9wB#z z;&-+F2Y+c~n>EJL7lwp{xTc;_6(4>kq|vtp*)eO#c+in3We?RLy-1zcum*OWzEE9N zwWCi1GWR1k$~}_fF60K=n!7WY(&axJare;S!x=@JXnk2*TRW1UYQIy&mXS zx+h=o$`z(k*V$k^WrW)v5L7jPVc+q=_0GcMjE-{YTjB$NbL^M9&1=v|Mv=(#dQ2Se znueX_T6l#N?|3u|cA-)`S#0&@#r^G+8ef|4VmXEj1xA$kJ&GM=^*w$)`7F(5v zSBFDpSBrgCTzy1?rIx=%u}o#yd0QW%q3PNzs*zsKo{RQbi{`fkELk71gKNhn|L}&; z4}vu;v^&rYikn4`s-=I8?nW_mw>?Bw~2#O!<7hA4z;~H+`*V|XW@5h{g0%y5S0l(tHba7#*OmzQS#>?Cq zj8Ddf4Bf&D1K=HB*fv|(sxg~w znCcEqL)O9VtrcS|7TZyS!f*Tai8nP7;8AWpZHWvV931{cPs&_P4T`sRkd~&t^Ib0h z?|~aLr2<@BT$4CfwuKipRrH#A$F_gcY#&9v(b&Pkp?mYx@_WB(UcTMbC@DC*UaRTPT#f}vnnKRJAI$1Z+Q zlc8X~aJe0F5wN%DfSWO8{2C^pztr^_q^ia^(HhhzL)@x3TCt}PWG^R%iZ0~Oj-yxd zeaiEu|Mw+#e&_q&-0e?E**WF^3hE}enEYqKr%#%hn-6#D+6A#~j$g}mBsYmY_%4$U za9rWqwc#NeA2-R#n;`)M0|R++2jC8xMgH7QQhmSMaL`;!2=4OMlHs;67dN-{jOfLS zM=L4yl`NH;y_KvX-am{bzFmd4`8NHJtqGVanaT{D%BrjwTZU}A6BH<|L$of6h%nfB zPw5U*8?IjM5AlY8WU_Ow*EKRRNj}UEA!oA=u;)0MNBW%FRCn?SwtT4*U323m>M9qv z#zVH=KH}e#q;0lSC3_};R)&BRcncTeaqAQ4@=x!DgmkTJJ~HbWcwE-Y8lNF*!>4g} z6<5%(7XtvR(*ZRq`KpKYnR@WqZ@7W_h|-*CBmBo7Y9aQ(Nh0 zYj%T~uE+gxtZ{af@ec1$;_^G^s{v;+qERqRFx<4F_-qeuGwzreB4Erovvj7Uh!nuv z)1rskI(SmC^f&mFF;`JltsdN(9?UEv8g6zNq95csPJSICEv_cD)b7^)`V_s-9HY<8 z1^ZdtO6hPn5$CeFw3MG-4tT>E7$+12$cc!>ng0;5=+*h?N|sWW>37AO{_0+&SDz+7 zmw(?Y@RVC>LQ$Aa0`^eT(A&Aqb`Rp4&dkE{YzOUoR<3x?ZLL&dDz=ugYEY(=+RumR zG&FP|tWLA#D__t;11MMB*uz5{WeRS6!>1T)SY7+xh4kl|tM@(leAvEA-?h5E{SKtg zn(UfWC)M3P(Y~sztfb1=53V5&PJkATxert{RgY+-PtelR0%oSq&CNw=vsNKi-=?of z5TzVwwbRu5%7P#PGr*(_?KjY*PG5*YY1vd}Y3A56Z)OoYZb{Q8|7F20L`I{0DZ?&^ zR$Wq1O>Ah-%8Okkz9cK(efqBb&M1#b{^iI6YfY{Sa#e>#`;IaidfDs2zuwHy2>G@G zW-=<93$lB5TU~1DsV!7BLp`^l$8%t95df3H-v)rjkP|(zloqzln>IapmenHLz&QPL ziP91`Dn+8H>I0QmR zL-I>Cqan*LA;oZAau<@+0STEDH%J)^*pQsIRM)lNU^0)-CM^S`7lD5=dhp==%ra^s zsf});TIm7A=>{4gblUkkLECGXZF5S~EJcm7QMtX5^SI;KF%(Ro{Lo&{eKax<=Yztd ztj(URYIEs@7*lGvmDJQ!5-omJZfBjnc9rF$L~!SvG5uK&&9aUD*7#;mY|W$up8o;^!e%oOX0{bP$0^ z3AKi7&@&Eb#MKLe_4=J3f=~kNfM$~*rfSyZ_-RT+%Z_z=uSE{0&euj1(r)hr!Y$}Ay5zU{X%GvhK?i0!J{Tp7f> z+=eZmM$v9ok++l6l6e!HlyHKOZoj~^{ z-a#oI<$b6Q)pCuE6;;0gwLg9OtQW57KuX9vo8v9q(Y>Q3>G8~VrH;r5Um5LIMOqJq#S60h9xY#RZ6& zG9&vXWrO)}x7LWn=c}t(9vuXd-S)Db@xoXmVP*&Kpg7wN5G>2~un#3<)z4?u&vYd& zHa5Txc<>H@vzGu}*bbsfqYt-QK5n+GI}NZOL9{j0AfwBJ$Wv}}^ZwF5ZE6y>9j3Ir zkxFHo({_f-TuZ1(N6+R7$-T4d25e%OA!uSMceKjef%TS>meETDiGW8r41t=+i_N-o z-aojlEq9)x8W9oU-@6B{5-JQO)8cic*_(k9XKV0rATKC%11%)Ff4SLD`f_Kw_U#3Q zRiM_B);tI@(jLqzL5j7`^hawa4m67z5G5kehy;@D)A1=R1(icZ@{fbr@9(f(d_sb% zQ#?2dePNb5f);d>pcuj~F%uUTmkw`Gk$VS^0%rPxvStuFwe0a^N%EB)M(59+c;cjp z&C|q0eE<3?3YpCD-Y&X5T*_2P=zf%`Yxd#5SGdHRLO^PwFT{Jz*D1#BIKdS#R>}3^ zviX1Zf@cs;4Wm+oZU@xLxAkCk@TIQGttB)yboEu}++S8Qv4k@E9dMx2o%4||;^K5& zHkuM7jBA2fvw_~n)_kk*-UtxV)I3lB3qlkZ%!@uk=)QjV@By-<-CzZ2d17MXF0~GV z+)KNa)*e3G=d-=Zi`_wERzm7Kd|w1ALA1V$_NxUxa|;WL>S@UIQvto0)sHlt@vLBY@d@Zu=-Y3gEC!UU z^)@_qauu$KXum09P6`BDh;6M7TVpW*OLk;cmtG%AjZYO?9YpdEA-?Ro85h@nD+Z|{ zj%%aQ0vj7?X=z2@|Dh%Uxzk%>$(I~CL!+I2os#G|;}1#~bv<^2#8`O(#p)-eK?BHZ zZ3CQm;?$|k;>{-~u}^ofB?N1Bh&SKXFlGx>vTF(oBs9UIcnlEcZIt6B<*Hp7eO?4e z#|rBMSb~;D@~2F^=S(r$wpbbT@$uSPz=xoIA}A!(_AzQVa)VA6@RR)p%I=76UxbVx z@m)(Vn6KiN7ED}9HI0^)xZMdppedQL6!bFi?>i3{=MDwM%)tjva-#1@@F>s~eb zxv7b=>gwt{+~TBNS@xJTD&P(S8M`mJ5JP;nG}Tqp?>fk;sb?>bYUco>;>0m_Q++H%QL17NjXKP^?P2>Adxt-1gG`tE+%O+)`D!ziDp&=pe5Zr$A zP1L&^a$(7^xC6md+poUmm)j1)ESl@5`0dRo6BffODLSm+3W5%?QpH34GDuR7A zy=J@Qm%ctdFF+_-`QKmPBzlbrY4T+zLK+Vgs1UnQu}Uh4XG0L3(KR9n7QkTqf$8A7 zr$L3^n!sOZ;O2~=sA{J|LrpE8Fy8DVZt9gy>CamIO@JI2x6^)m zM62ltrMjk3bg=A4fpPE^G-2;U^BI!R(bh)mvmok|Ymv5;yrTwgP8klaD}YSqhRXWJ zpPw97Wqo}stx95Wt!aFAHftjr^&rv;0G~MVZIp;tZh~glY-|YS{0m5TcEZj$1hGir z*Da_rjn-$-EwHg%7u((d6)iOcQaut%k8Wc#s-(NEln$~&D)(O&h*Uz^7vI*_?6&m! z`g#w_;R42A7zg{)c#q4@K>^E48%71P0gxwZptO)`b|B^oB>uyPFY3)``K-V3iCxu# zkK1W5L7!?lYG*SipiS^p9fBN{mtViE!GPGd^E(P?@`_AhO~}LqO1qMWuMpkUBJo+^@hPHU$h6r z_yt998_UyyP%5ixu7E=yzJt(-AqGzZk|H0Z97`dAGyR}05OIyq5j8+K!`KyJKgL<*?U-s7v~OpU!EN_bllFj?)oCI z*(y*y3!uGf_|!_#kpeonwIm@WD7LXK9LV)9kePS57)a+eAn>7-Dp-1b9H?00(MOLS zS&Bk(wu+69e}=~Uj^+;RZE<<|3ku@iBzjn}_)z9-G21AXMpM>wZz0-RLZ#yZ5c1G^ zWDHQj7K4U+PeX&sPNxux)fWI8Mpjnmp@tg+_$|QpGozU#;{jCNuC;{0wS=Or^(kFk zANVI1dQ{F=&!{zfcuAs zhtuL=1cdp_|GxYIa4ii~F!x-UnO+A%DRW%AHdEUIG8AXn;~%k)|L37;Kn3^qYBM{( z7#oKrUcZV13yh4I!%H>XzNCoX0p@G+3^!E<`J%SRH0M@Ya{nH7P&hCm*uEE_!uZnH z5)-&Fw*x7MkZx{_Ya&I3AFN@5r}Vkc3+2}mWh8hqpTwhb7{K?G{zKm{LP)}-0otwg zHLWFvN};Di%eEVYYZ;fiodeBQXiF#^3&IQ3ok$lU-?J#OhepLTa9m}0mn!m#HT7O@AX;c7Bn5%@D~V3pc^YfSTh~ihm z{)2WvND=cw;#JA(kDk#`o*M$RmUO|3YV|p_KjbFZk*$<1E1%=LU#-h4(|&prx>)edh(VM~A6BC2=OI;x5eD&Z?;6F5{{pYXyg4G?#pQ=yz?!|T@=@9Yv z9zwfYe2vL>@4V25Nw7CVE%B#N0AWI`{x9Tx`+qmYB%E^S!!5YHEo`209TCZgAHK7g z&wr=9`&Vu^iV(zUx(<9ufGHGE=#s`ttEJruc=_@rPjnCmRV$>g<^$lM zbnrn5uu1a25A>_q3lpGXU+%{s#cf?(jIUq6=0C83EWzq)Io6o2L%NYURY#Q3fo0BL z$8m)m+J8?T#v+b3?5a(Hi+{_v*6e9SN}j=a25=rTdY%$)Un}Yfn)5>LV60fZcBEE9 zG{#pAtXL}n&d3QjUlxIX`1?Ri*-gF1oZtBbrkHwEcloBOsHve7P_5W~Hy*&M(G{aB zM{fbW74$#^cL3qaCxGOT@v12lFZ6v;=C+KMet<{h_{4a2e<_2 zG;?d=4bXBI0x=66yvb|-T_hlKcwipD_Z0*S44duZIlsnavH#bBx<|J>qf<|y&+^%*op|2Cv19dQcvMjt0KIk;-yimrg zq7oT2yF%H9g&`%atE)vT_iLHp^IJJEvRkmg&{L4!AXa@BYl(SR({wU4+OT`-;9{}$ z)ha3~Rp9Y{x_c0oOz3vh)?NqxTyp9*acigCqr-#U5bH7pkllAGUK~XQGBUXqY8M?HqzxDl27uoJ!Q zq7icoDOhI!*x}Cs2A<5OhtT^+l`L>3H^_r>ny0s2#t-`=R)t z2h1LlCZELt^aZe!+KYxAed`jCz z(1YRn@f+X(FdAY3*%#@*hMU0#5QMDI(lOJ=wB?Q@!HCFWRjO*-E4_l+ztYDRT2dil(y=3`NtcA4_>jg9fLxC^Q1t*Am4HU?o` zP*gM;ilp!E9XJ*eQu8I~WE=LNzL84>v!}V4HP&#jmsV=@mVStK9i*XW(=37A#iMMM z=3})d2V~3ZL)i37X78zAIiJ#+v#}eg=EU4~f^9*u#cdR0jC>aEr7Fb^OOBbS2gPsb78QOKqW(9;HS1-$s+%zwQg&HJ_c zdl>PEFAz?2ri@jEOg!(xtyIWk3Q4jqqHzQbVuH2g*HPgSroGD9E*Y zg(VDC?{G>93Ng;EH6_?LWyi6zU%IVT9&d&*am`hGc4YS7$b(fJbpBLyF%*@SqU}RS zUIe^AQwbYw?gCs>;6=Q|YWd)k0i{Xwda`i6XJBW5_h`@_w1LbeyrAIYQ~6!(_Ht7L z*M;!J7cqh5Lb-lhl@a^Sr=0k4j%|IrLwb+s!kJQCXCo&!?sSdQr^4{;_6Rcv<~Ap4 z?rAP~0p@PT&N~Y7WMXq6xT^qcp;fgU-i%gL23m#&zu zv&=hgoy)|&h7<&q>^i_JL{M7#)TqN1P~an6Zu2}P> zpEX9$+J0CU#gMI`bXGo_wb{RA2npQ><<4=N38`g<7ZLcWXp_AkQV83^^Cv)NYwe&} zZs4mt{>dS#x3GhktGz8zhoOfPV~!_Hiu{h3H~r6IHFW+lJsV}d%h!wWix&bkY3bE9 zyvf&Y>}8djx!Kl0RKy_lpYnGsjoR?gQdA@M$Ora$A??T|$cr+r;rP1qYsG?!nuw&= zFJn_{=x*K)BZc?*uMG#_#vY>Mj_RkWUN?PwBg*LC4w^EIs_nyB_bNkCJR zHcGUlIkh*Fj%n)&4*e8)Oo_J)An02BVgs*qY^T}W370*OeI-@zL*5R4Iy|EqCn8@Q zzs+P`mz7Q?f3EwqG-Wd65&n0wfY11Y_+oec{(5Kr{z1MmG}UwQ&OZl_nt?r~pLd+v z@uGH7Yjci}T}d09`kVJ4{eDcGf4OZ(4mj{gYP5>{wrl5ZmF=Aq7!*VWWA*X`vy;zrkb&{8x>WGK3PA4 zd#(j(>`{3nT1)0mOr0Nn!P0x|w%<~*8kuZ{Zq0Oy&5%dy-^tMf`Mej(30vA$Q3H#j zf$np)B$?y$LJ8qy*d>H|#9aI=@0xqchH}2ibVXY$`F$TJy=?gsqZjHjT1}r^ov3H= zP^em?x-%K?D5VtOjUQ6tRRai97hyOa3a22((2!@JR-Kg)|M~B`dQv)r&(%jdK&rpetrK^oX)o{p+h$Ta2 zq0v!GsRknhz8tX|G;1*~s5|ojm2u*)4^|g? z3QSv0C#1~MLp^;aB$6RvHxql2R+z+7(YaP43I0qKs&hNa{sl519T| zM%g#yn$o4VSG!N0K1?lo_S&^;(X6bBD_1tYwTQuwX`$5AY9pE^jb{^`i|BTFZ1%QU72|2QD67f z`;A%R=YJGtUh4`T_3eO&(cHX{dFy=s=0=HHys_}Sqd2Va{f$kGXyN=VvitK9_C0yf zt74%4iCDgX8VP-^6HH9UnziqO9Y1fDAG5!Rnf+GIyRZJ(&87iQO$KR%@n+P)F2;Rf zIOmOuqQy*o;T7EyFRjGDsx&;`k-S)n%Ig3xFegCd7zNXF7}3&q1`IP2XT6V5N8GtA z;b_jUeNJS5lAvRU)$Q41OX;}g$>G9{zQ#n?`|Lt%#S3(rS+9O!GAQ?%6$_U%N*?5S z?yF28V>=#ynCC;9rC^M}$jeI-TI5i5ue8|Uno3451Mh2{#8kM5>(|m;D>m^`2MH zu7wv&{On*IAvfL9D-S?(BcLPM5dG;-ElsAXJ?NB2Kd~L2-*KOK}b~8fri&M!2rUjv(%zDDplj4ZS{v( zP6A)vR9}Y0?N-!7mH}q|&1lF|;7l*#M$X zu(Afh!z%!nY&EB3GbQ`tUFb8(mY3acP3x%Ho|TXDFK5-J{G_lP^A8qqltl%J9qm%* zO_-;a_HZJz%z}oldoELbhVR98-KHv6m7w&TX6&>@1f@?}Utdp3!Y~Nnk8mOJE+Oo4 z>{)H`l+LHmMwe}uc%GUG=xCRHlS$;{54hr$TAiGGB~ybEzSt+v`)XIun_sbp3SOXl z^)x;#hX-jA>5>f^{wWhV0 z-bY>5JhW$=!Cfog*CeX*#RV^c^O!>QE(T4Xt(ob$#MwS3S|LZ_6>ZIPHN1sKvP#OX z6QUUne$M+Hsfmf};$QD~sNSu3uvFq@C)>r)2FONjv8=~V`-7f@(p9u*rjX1S{c{0$aN!-C{gl-ayW-#q1+QPQS|&Y<`cOJiB7L-rFrYq zMzuM#%Mw{C9(X;T`Y;5V1S$llzU|3=H8{jv?3aH!=zwhciNBhq6*ZS_Qq(eio2R+R z?*grKN6DR2UrCd&j|2t{0WDkiFc*G-vRj@ETRiOSZPiDVw|!s6amI`aD&ACS?LIce zPqG|U@sn|lOGuESYgQhZy&on?zR%HpQu8_chFL&WwAoOy&fI9D0~zbeU>LmHZAZ31 zCHZsj($hnuBf+)Yr4S3XH<~g$IUf@pUNN_&S;DcTh9HJnDMe`z0&5#Y|zlwKokohX7n*W z*OVu5Gj!?j=1sYDgKzyxjg(!oH=T{5YLew8GnzAF7<%tg!nI+O89A9=W`Vd=u&Dc?#h!Ca~}wi-=-uwn%jPHW@0D-{eLGulg}yB z+GLktO9ngr4>W2>Tq~r{6Y?VYL$(~&yL?$4gC*F0_2@q+6NMpWJ2c{i`VMUVY4 zrTJ?&r^*se>7y2OBAA)G+Y~${|1=8EGt;q=A5!I)f58;KXgbIBH*ary6B!-xKr0{2 zV3e>?ySJ;lf4jasO8>I9f(Mp%Iifm(;U!yQVX38yW0D}c(c0nFir0?7Zbzx9yze+4 z)c5&otcHq6=i!xJalx0`a_Jty*z;y~W5TnkUH%-S?n_iTc9yIYL&f?yY%pnZPtIzJ z8$<6MWvRX6+N(E?WON2=pNi%s`9EEqT=uq~&@Z);###z07SgrINQHax%q;p1Y80f= z674|NK+8~niL*0?A%Ms7RMg`I!e8>s)8~&H#y*a=GC#8pK{7VWr+93=wX9$D@s!Lk z8n`*910#a@0E-i16Ydf2Li9!o&!nAg1EVr*VJ5cRE7dDv%?uZ??g?5All${}TW7nY z#$48l?E?swr5+VL#IJty3K<3e$_`MQ>6FXK4;Y3d_XyVyJIG5CyD!lZakcAJxd%-w zQ>!};+F8~0HiViOw$fB5P=5A)6>*+in;s~afG0s=Y#XNiWWzYU@n1a|%uL-+IQ0ax z&s{c`w5ut$KJ1|PzOPb0>XK-vK5AymucTxS5KZd-aruv#I}$(Nnkn3+-O=>$=+f8u zcYE`i98j}9BTb&|Tv@KVXLpv%Y>e5%OX9*+d98x8X?)&1S(@QzS?2XFwgsO(KTq-C z)6#ihpx&ZV+OA6%VX{4%s7b&$z0r1~%0r12OmcHV0~Zk4$koK$iv-@UNo|qySVGPN zj+zORBX-GumH(9+M>P#HI}#ejrzW1myjHyWOa5AJCW78#gxmTqm89XNUffz`q!^4} zniUCrfO+>9@nsu$NB0im@?I$mv`OjGYr$xTFWsfS&IRs)-bW_T%d;L|Q;NRlWuO&D z+x4My>4mHAIt6DZ*nTSIEWVUXOI8*e$-kGXuY6}@X-TU&_@9OJcl4`DN3u+=V8Z2l^eKeYzW9sDUmP#={;4r_PVoN6*=NL@NYtkZ7uU-`sW zKIjsDh#J%j1bQTTHuy@?rNb%M+oj{5n;F)^2&bheZcw^CO)|CNQixK1F(`A2+ns!H- zZTT*wC&HF!U2JQDEm`%D%gg#MX?LOAT2s%XD^qU6WuB|5^&b{d84C>tyW@E|s?%OL zv_1B_UL~Gti6BjNN;Vi}usA8Lgx-Jn7m!)sAGP2w(157EEMchce5uTgYffoi%5H%B zz;KdTmZ5eDCi+X2-BJZ^i7vP6_HbS+-$Fw3q({0-xtex+ZKb{rvADbA&}0e^-i%N4 zTC7v5*IKc(!AoY3ulu7JWAMbLxH|?>lG+(Zz0TF&3%#aD-LxN-XzC1Zjw$KfJd_uI z+5Dap)xR#5E>)g#WK3vR+gS2O<}%A~xh>m$VT>nw!CCcRh4u(P(;=htN@3o)#TOMB zu$s#a#zzd5o;(JY3~seoJKo9U%Dm&;kAxW2ysvJrBiznzCW>Z7{M#a~U5ts2_8**F z%jB>e@?g-QwQ~;hmN0n3XSFzZA&A^JZnaM_utxXhZAAHO8b?OH(K~o>k!01wF7WvK zbl&@aWp7fOG3&p2^){=h#K2JuffV&=LoZM zf#`#!&V5R1Gjq7#%GVeCBgT*A!sp!p|92s^?{wsu71K5TZ67xQA*#9Q zKvio6rpw=dFuVdsO}1E;*yemZrG4(asK4H3>{{W}q9fKx_z@r7)@LgX9l^UeHJH|k zc|IcR{wCVwZI_a=Se_ME^JVQhNySY>ExHaYB;30@^#9O z^cnaVG)&Q6EeJ0+zfL$lRG^6vjrh^7>W%o&OLho#$u*8sDc-QPt z$GlfByz@UTCCiT{G>>ySB)BEyyzTZWRg)$wXb9CR4Pn}?E%p5s{oH9eJ-dHoH^jWbiU0(PzbaYyUvM@;OO zugz!Za}01WZ~J}=5Mh-LD339Qy9CvF2Y@p%S&mCKAMO$4tvI&0_B@h(MUBp%@#WES zgG+p&|3clA>CAUnZZYHL2*U?jg9fHjI5%*UgI6R%D&s}f8G#jYkKkOdRo37Td3@Pu zIk`-&y4_~ZO(?fPmOm)-#d%CtI&UDsZ`}ixPh3LfVq^sB+jz<>+n;6U8Tz zR@Do&vS(B!F!6a-d0w5=%Muweq-YoV1J1^OA4!O;rm1W!u$eryF~V6Gjqaoe5o?WphV}wi^tx% zmk#VEOhwH;>lL2UmC7!A`04iGr>(E4RqSutcRbIi#|gYtOW?#a!? z&_uN?uRZAK0V2bkBQ|mU_`Kta#mY*s_W5NFDdkGzW$!uSW!(mYS?jp2j;hj>ai6p9 z>xI_Iz8K4)%BlU+?F|8G^9%DOIYr{^q#wrDhT#X4+ps~JQN@%sO00gst0=Po>mF^H zJIdfX<|+5^U-C)&p1z{bSsf~jw4EGT=!Iv7pVyC~&yQSd+OPfGkI#nA+nlqp?qGjf zweJlcX*4-rzI;15JNz+wvP+}JISf@s&LZ>Z2C1{I%{p%E(6aWqpLl`>t$J%m`e<;N z%l&yJ0@FyETfC8V>VPax`WBF&2>wPKj~zMuP)2iIj7)DvHz`(HMDD1CTo33b08v9bP7p8^0qF*)U5 zC!$JnUR`;v7=nK@D`F`%$XG}m%ChZD)~<vH&8O5q$)2^f+w(;%MlCrKRQqyTh@Gjwgs+FizDdkd~?XK(>3J~$2@CnF=MH(&W%-?vA zXSAe0a8Bi+SC6nTEh-~A*^2pT)YmtxP*ge{FHLJEM}{QT#;)D6oZwSw^uk6$27Ieo zYL=)nykJ@0t%GX{$qixEUmi^Bh;ZZIOuSS#r|NsdrotGDmn<)^%xq4m-n|WCO6pdl zhG)WLj9AufVrim?cB3!*)G{T#C{{0RMbGrKs7Od#*@GHj58bp2pL4%PtFVq_hs@UaV_}2V;~p%n~K_ za#vzar)Jt_Hn?W$-}kvTR0v>$%F1@u@`inpGrUYq+p9^j*F=~qM@|2lBh0=yPqKdO z``Z2Qbz*Zp}e-nFbVv;Ly-%Ri%7X^;|C-hKbXK0GiF zT}~wFl;Zva1rAT@I)Vr5{((;V^{=iC(-F~KA{q20)*!&jkApfAZXv&#oOL^+OQMl% zD@+xT)Sccxy`~MNtE2YP$)yXl**~{41}bBi@GM>#8LjXmDrIl{lRT|BPsv&C zOVVeq>zU6bSzXE;Fcs0sRzbU%a&q(UJI4?EMdo>MH9wt+zQJBYSx+ z6ICCRCa0#9OAmy4T3)!l-^oBiQ(EW5Go2~3UcLNSo`||SI(dl-H_PP{^FqgXX{4hz z5ns+&Ce9a;2js#{tYJQ)&}{b6+48}C)Uo_m4aHBN78v}@?LFY`jSHnm7vqpL07-Wx zYw3(cT@FEc#jZy6QF`CATEghTz{ztth7)4SYp>p|P9_}gAH;4HrQNXkbS3Wz%Ypva z`n+ss1qCJWtMLw(+`BRb3}QETtKcpqTD#5!R#qCD!-HBM54@fWd_AQB&(T*{F2O`~ zmP^KfR(m&7#Lm(bxGMzIJSsCR2v*$Qwt>rKx!-^8+I8$^(d*8n5|ed=Pl~UR9(j;qZdRdgD&7;uf5dYx zonCxpt84VOkdON|Pe!cpyAFtHV)X+zT;hv_kbb}ZH$759l_VQ;#f{VsD&(|bj%1Ml zFLNDadcmS?m7dns3b!F#??10H-<9|5IWF%#ur%Jeds|J~E`Jw%dC9`x0R+v9FdYmJ zWiU2V!)|p?YncVw%s<8~)he|d4CF6QYgUqe>l%DBq#7n%=<1ao-Hh%PY1hq+iH@ET zFu%#E2>!9ervldlp7Y^Wfhn*Q zz$i1GtCwe{Iv2{~+;KD7pNX}^{pT_b{)SdHJd^dU*zt{TqT>>-7Q19~Rc7V-`u*a& zAH6blY`c9!%Wzubsc{G8x#AgN_T>g&2FtUOzHEaXvbInnUs-R>l~Q_ny;_;q{C+q- za0sMR!LG%*9i2{v3pAw&ayQdd<8KQYtg0wT08%W}&Hd;Zb@Ro(9$U z;TdRXdiVokSIDFXfGz*i)|tP#u3w8&$w4rpIT<{k(;957ZF zURP|T=Rnqq&$iT;-LwTWS>AW%?b#Fb?#}s}X(#CQfI`S@ak4(ssULcDC+UD)~V( zv%J75KaB{ykAl7PRrI@Z(8m=3i}t9#d<3%po{3wR)p>^wlHj3b-w%>JH}i5&a0>Y z(O|7%Ttb?0gp5yDJt4+m;z7G*Tq-~E1zoVqx%GhAfSQ-?^9w|t%*-};Hqsb}lSb!- zVcetE*F&0bHYUbyDqINF{Go&CjaazGoj$<97Knb6RkX$t1^pSVKe~?mnl{(t^;%+e zUPU4IK2KgjL7_qtj{4DGR*LIqjS3GbAijBLwI4rT2KQ~;G|&08$8JP1Ow&uiV@}NJ z9|{FV22Z|+rV{!sN}C%iFxY`yN{XSWU*el9?D2c?av+ChdIZJ*FU@D8;seVCMVwk} z#Ddpr{FvU(#6cJRSUs`2y>D!T(5axi)ajZ=k^D$)R5IaxyOBoqSS_*t1(+J2 z1I1{gg35VNLTg4@j<5%j*?Ms|8@|bA<-sokI_qq za`Z}O9jLDMI?t%VL`l{gy?~*uN4cL5v28jE`V3NC`w@|BD3YV(8xsc)MWAV<<=)@3 zjg1lbQZ!Bxc)@sEum9g$X>>rCVazWW8tJO=tpO%|Fv$ZWCs*lDaGx`aA!yKR+>UrK zpbzq4RGW=jV!VVFk2O~~#e)33KIM^o^pU?BH$JGZ6_-9&N;z?gDfp=b<7UNOp&MDt zE4z`rnj3cA?ptVL!HCA4^U?^_`y8c-@6pexB0Gtf1#g_I zzNfxvH%0xJuThJ~EX@>#kZd1Q2T9xI$coLP^15=q5O;)B!YQxfi>IA3{||fb9TnC2 zwhNE?GbXVRBT5t%#UMc`F(`x}`*Ui{9OZljfoFl|?AOU;Z#H4iDw0NLRZ)nwJ+; zZEH>3|F-$fNy*DETsb2rigZKMOPX4H{;^S_1`F;){cGP`XaX8qiCxr+y;F35sLA8h z712v!=>c?e1}}&C-APH?;_B*3%|~i-?Ui+7J^XcBN8J7Ve5cfi z^_F${$e6Ns+SuQWu58^gcHXtin(k3q(B*b5%~|@6b`K9#%}_$HDE-^M37lE3F=ie* zOK--`r5d_l>hIHd12|MwXu3gJsA%+s-D-XIP6Q#iq0-lXQBW^=CunITWq>h0qScL` zs*Dd6xBuXeE&J!<-+*Rj8Qfi{X(gNy5bFAgsr00if%U^f$}@flQgDjM8qOJ>&b`!BCHsAL{;E6%L!!qZy6wtda&5Ce^yd%Gho958wNp?Jlj~6FN z>wQ|^^*Z1D6Ymzw*AWvnwP>Y&)zjz1e)`-Ncx86P`0? zPBuYp31fbjrK&C|WuB+=^XKiD3%o2@I$0xI9Q9K5P zfgrudYu=oac)0ZTa(w`jS43ibHD}K@D~VU#rG1S)fl<1KCebwyZuL1PBrevMD7U;a z@nU!P3+^X7XB25@&c0Bh8>KurPvv>Z=Mr1KX2)Nl1qJ+dKKA(5&6_s^;wJ=ZqjtIk ztLQroZ~aA|>-?nf?yQ-E+3b(Ec5m9(6cGMrt=9ExA>19iT#A$C?b){O)#aF910^qo z>1##w*_)UT&APFn<$ia1tReTXsJ@}bAFpqNxuEY$Zw5u6fQXc|0-zY^Ljlvk;FQ(m zh2o1g0db5|?L56x0|Kcn0@)5BkFM+2xs&Igx+LwqP~0JU{mzUZ`uDt&V(VzekEYg5 zD>Z-puWyo2#UE(Nv?=$#9#eM>!16?b*8!pI0x-PdPw%%0HYF(<80=5ozvz_2*Wgzl z(qF8L@%II_@IAYmgy!RX+daIy!}8#8xRq5!*GY{}eoKman7*vZLbqf)NAARu6ElI| zxLYr`w@|s=bY~`kXnfjM2p6@m)(QQn%KL zbXr>Y*LmJNi)=&DWS_^#Hc@>8x}_7B!ZiLQD9p*G)~gZ^dM<$U@gYVB1!*Ei7tPn4 ztSzXwhrgBti>Tm`1xL%Eru^LZ5*k2J9I43ea=%rPpwla*QLU4IxclhPNI|f0S}jWF z+nypZYs|IM_W!U}*CfH!Y^=#5khvLFO|4CWdJ#8bV|#b1&N^}HM}uqMF(;Lqx#CJU zGz4*=tEG0;2R{YnAwe^I&-0qT#*m#hyHbCRFT5CLc}lXWRcp>R{qC9v#;jQmaYZQ$ zbdR(iUMrapSSDN|#xD6>pXM!K3{K%t;Xj%i~L)q z`nq=2-iwG3hr(idR}!d@Tf-Y>TM@OVNV-6pUDvj|-BQ}NE@n$JaFZpU6|}V8Ir;4~ zU+*NVb7#8*M`H%2UU?1wu9V6DVF@aLT`4bGZBoX88vYggSasJkZp`hJOdkYv}jhZh@$SKhJ%BDF-L zpo!k~LxJNvXIo@WV&@Ir%)2o~J;S-W%h~NmANL%&D35*j=JTj(tHixRF?Fv%4hw0* z^1I-KslCL5!h5)cY`~GtfRCbhY#b=DeI;;yaX)F9a>Db%3!PwQ;wN4;VVyV_xjR9{ep?F=@;LS_7Q!j)l4wH&s(Eua)>(-{ED4PY95TViX1R#n}J>b<7b)(hd;EE6_x746^p! zc}D;k7&v?Rz!_S94*PXWB?~jE4t;MZ?)9=?jkDVOQd6t>CqLhDS=LsXn)QBi;lIo# zwV@V~ZT*J+qqk2zDF{tA(RUXxI*j^5@^_1)1`&rY{h7b*mt)0O1rO`*`+4QLJ10*^ z*S!L9LZ7)gd;9F&oHxi?A3OFf_#peSJShCVz5t#Wgg`)YI!3^MgS7%V)-Eg9m-phF zury)!xpo^EWGL#zI7a_I`qo}uO?`HhVq~TMG4a-Ug)PQ+Dl6Kh-xUH;+^r$u)8CYN zT|Z*kYX5Nh_Hh73uhQyRl*jG9nX+jX=J#KK6!(s9F`e}V^noF88s;c_1J%+Ab1|um z!{(6#x{|h`r^2iBL(qQA<5t=^^Ll9W4WD~bFJQ21W5!#)k3sijWaaSh=5_qQkeNb# z)&TY9-}))%MeP>O>P`gJ6`Fu0?J^2kK$?!Y`PTvix8V>|6%t;u#0yIw!EfJH+$P zHUFblRyM5qdQrQIeObpX&SQ(anb$*C0^-?65qQOH1``#s0I=z;TepJZ=33cJJSGe? zj;8=?FTWV7QBZLK<>VZeoIAb#1Y*Ypg;u?rCaEL&Dza-*q}V3hnAx#zyZDL2Gp@QD^L{*0B7^ZW0rkaq-^=pGTF;y3MbzM9zZ!2I*f zBbMqbo$&~ocHwAUaB}w&Wv6t9zD@F_h9-j^x0fLl78=GzKc2Pv>T$W(*6#dO%g}`U z^RS&ZC{#6`pRkI-egIVN*L`0tPNh=e`gIK)L#n@!{MtLl=MCWRSofr2bF2|_bksEZ z?E@?PM2*uIc{yEP#7k+ z-FPQJBc@B>#ND)M$=^;~LDi2(&!O2^-iJ1fUKhO_rYLU7vwm4JjPYSZzGLPT<9oJ3_$FyH2 zwkI#{lE_sJzj8?Tb@TSZz2FmMej9)PvdFug!43*{eHan_F!062u=Y=oX&0^Ovv1WO zk32zH`|;zYB44tK9wIbCJaCt^x3?gnxz=lP?gk;OChp7#%4R-tOnTwh%1%+-An~ik ze^hcVPYHjo3vjF1W}D_B&(EXsfJ7(WBoQb}es1abwWGV+=Us=%Vo#J$!9BFcBi>~N zyCSdcJ=cQ}OmxZitpHX_3ig`VwZ8I-UnQ_-UQfmI>3LtbTIXWs{66tow=R9`=w+aK z8WZau$IghE{!9k%Mp!|-LdorvwBONNX;>-X@+_{JNN$*h{;J429{G;v^X2bvzQxDh zi3O&9Da=q@gV*zucB<6O!l;mRro`d z%_L6@8RdAw)m{RGWKP|;gk$t7(`^z@VvPt0C(AKU0Wzn?b{u6V+ zj$nSK@@`5X4cq3-GvLf)d0C^$K*CQ52B|oURRMIpxdDqx0|Q9VEHw7~GpkPBW{Lo2|AkiGcW$i@!nk5K6Sq$=n9cb8ng_9xqka-7a z61=M3x`6#r-&{&PJa~3$rsd_Zn~7M%-^h(BhzRQ0Kf{R$nf4qox*BppTmur?+ANB7 z;trndtv#FU%Cl<6-LauVACgy54BxB^2)YHHJCr#f2;e@RiA-EGcIqo}QwB7u{-Ee9x`T8>Y6ON8@Xf3I( zq`Vopji2VtL?>Jo2l-C)d0iaKTmIN+R+4t@T8PcaS094GsTk4OE%(dRCiiov*3;3;RKRNWtYDzpbA>(z;mKhl7{`qFuiRG&4-U%iOTJySQA06E*+w=t z2Z@ai*NHeR%j0i9Qo@u;oLIP29&6V${Q!D1WoO;pJE#Otc$Yl;pPp8QD(c3MVBli1 zbFZG^4GKd7FVcLr56Y>Kn2k13rruvKGJj#c*H$qHX98GWGj^gio_H-au!ibVoRXv~ zk8U#6rE?`<>3}cct|4EZi8!?LUx4CB;F*8RM6*b#Ezb@-VVXw09j0vpLsu5+#uGnZ z5SJ@@Ax!@q24Dx@{F+4Pd{}RnB(#X4PhFf)Ru=t=sJko|TmX*i%MNsOdC8>OM>o$b z|3LUD=>D*l!ds1Y6#vlpB=J^AR7i42Yz|6dxq-3WVNWr0LR*N{bbaE*;ek1J5fKrs zJ5^(K3kq4PoR5L{9~|wto{wi&b=vg1(S^ST>)y0o)mkg7!_QJ*<@d`~yykl@xA_K4 zJj1b}MpDDZQ~jl6;w`wL6acYMzwr$X4SkhjYo_VDS31DQ`Cq#ctUfT!0q4H@-MVyM zal>m@uY}h7Wm{%8bW5%`X@3>7$tJ>L@a|W5O5b4fZUX6{WZ(Q zkCp_`^LVUhS??aMlw0hy9}&J)6+tuy8Sr6R_{^NYmgcdXT;q5TQR!5B$RfO*6HNJN-t` zRVMsA`q!M_*WiPRLYLqUQeSDy?|JVStVgWFu7zmt*;jk$rfvKwF0w?4Wx+Soug)x= z9naC*79&%&8gdyY4!ry2;_!+;etwq+t#|BtHNR}3xi0HQ3bxm6)R3TaH~l&>2ZcJe z_V!RIK|!beHi6npjxj}O@m-Nu8r;i(N#y<(^ z%!B}Ab86>*`z^@mEISfa(87WUJO5}|LL=%W14E9&NHQYymfqoc@2 z_mp%P68mQy*n)}SJ03v(7bn0uoE8TKk7u)x&{oUpxIJyVn)E%E^9gr6Ieh1C5VTUx zFIm3amq2)6@1XkpaR+okKs^3q>50AAOxTy8F(i~6$#OHT+Hpb+59AUu8Dt;Yq;Z-L z0Y=KYn2z7f6$>e2Qdhqnk-P6(mM&sMEh)P!N1Omhn}x7XU$`qQ@!<3v*@jtdy4E{c zML<@z>EdmCE})(9t~oiEO-J${%T4u)QJm0sez8Wb5>pd%;=JLfZOw6Py&G;MyTssV zKVc~#$*jfQyRi#hnfq6^@$Sd0n!6C3ws|T^yANk<6eiu85Aq+i_xHr;Mp?>F-&YH9 zoi2#yPvlMCl8oGgQZCSDSF~b3QiM+U6%>0MTR6*NJJ+35K6t9^IOye!7)mlY(B_bT zQ74WSqZ70AXUI=kdS(>JmLUtFh8W@Nc3378l2M;$Ol)T)70dLBfA|(Jep|F?jD`%1Yyr($BKRw zdv+0A8JzPPc$Xq1Y9A7n&6#wFNi%{lr@Ns2lR)i6oT1?4|FjTd>GaI-tf=#$_n+v^ zklKlAKHX)8aVvXb3ALk0@1?6-gcXPM`|qkYA7pM;j!!sDm)d~IEC#elXZGFtFp#-Q ziOABe_%*Db6+yUIRP?Mkd`x^{C9=yIQhV22r2z$YI$FGMO(%?}t2(-bo$lf}ea5P6 z_E-{^TQ3Ifo?**p%RK`wh=dQO(m zhmo=U{oPSPEV+?Snqz2fA{R^wJ3`h5>(`eK^+Tlzb;v({dhdI`7S&cFRbotG$bDH| zU0vP?R!79Y`B|*lcS>UP-xZ>CH~#vw0$?(dr+feBqvkjL`~TqR#VBRblcWJU$m=KQ zJcR~ELeL{oJb@F@h*=+Qgr*`p!o)}!gm7poXQ4ZUD^Yp-ivSYRLr@UCh=-u6`?u>3 z4++bU48ddk@Mp#5Z6xPrKBL%3w}oU1DGtb4RSA;jxQ^wFoQSZOpN%c@n9U9wZFYJlGkIRCh&=&3939ty+~7kl#$I z(1Nip1xFf43jRrJDwGNvCwo0TjbLVmo#2^01kXD;vh;vzx5*oyn9uav&BzFjQDP-= zR7TL9#A`kLppL(>H>00XQ75+%o&r>t!?G(a!fKBR%VfO$lblQ{-!`V}>yA}^&~snn z+J&e}s*euro}p?Rzu7Vw-)52+KQvwDSIgVfEp3GYeMZZMSej6*FO`dXnM>XTlBA~U zzqFHlK*%2}-`ZYEGZ$f!o~&)j4*49&f-aS>cei)vkJp$72{ce zr+;h$h9mnN$H{1GZ>;OyVEaOaxnZm5c^L`#1KT3D)&r2fr04;#yHnzd@PPJ%B5f~~ z|L5RO67Dii^9qyks*0y18M$}38>xo; zHwmU?l2>qo`1S8eEImR z+^466Oui!58ROQKiXL60sZOplMzwy`(3sEY59vKm%E0G_hEMzZMi0cFEj-gtei%F~ zar+#BpxH1I_${UFmN(-ND16vdK7X6Yk%JqvV25M|g)_R#ozbNE%Of#g>(pldYr(-r zw)I+P`bmLA7{azAaLBrJh+jYAQ-4-IYqS8TmSKfU-*Kt@=Yy}0_1Ql<5bg)?lK)lC zB4BIw>W*DQL!-|=^T9#=)a6UHu-Kyqu-IS46>~+KT5mnyMteqsQ&^EGxwhiu6a4C> zt17G6LWa6y`oB#W?ZJ`+v=1YPOn--?EgfWD!68>0iV|D0*yIjIetA3|k6hnqzBb?X z*kWJUie-5r%#1*jb1*5v5?|-t*L%EXs-Mlbf7vU-JFA|JCGwWkmMEx@)XDr=>Yq+b z*7H56CE3fL>J?Yvj@QHM?DttJ58IqD7-0ekRx}d|@Y`q3Br%30Ze%n8t3f5SBCAIh zbbY7aVFn|HiuqZ{))~(@vcbuvJ{I_Xw)s-Y*^tQ+=#EFL3}Q0lkDVdVER;2%nN?aW z_i~AThee1ZWPh_sX;@~g7NXYHy?fRBY$4Ku~PjAC#aOSvKzYJv=BlrxvK*8CU-LpuQ77iF2Li?^nfW#T= z(S5{ws~D|Q`UIx4mQ{NLYa#0 znych~XP5Ezl+5`ErDh30A>Gx|V__8PTwPt~c&{50Ydmq!K5-tB8x>NgO)DHGyFrt& z;(*n4p2v?TJZN-Ej~kqDiA$w$Gek7#zx6(%Gl2dk&^I% zKmGLjtib7zKDYon?fTXfJzXY3ki7?*i)u^V{U!z?*vo9(s;lQo&Fsgg`;OcNU@aO|v8c%|1c=OoF$fSC3Kl+1j9vxnCU{rg3ZG3bRrIKr zpp(BZp&rH4M6>DCL1fY+&(u}E#NIqk_9b&=f_COp>?fNjp^$Mik@0`p24jY4^U+u|cfQ+z658Diza{heV z=Bs*7*P8IWwg?^Y4@gwel@4fx=ao5g^U1Pl!!UNUZJ|PIHk~LL{e@&lCod`rEuzLh zXUiy+wq9DYWXYym0wtUDJ1z1Rur#ZSXOVS)v;pVMU#^SexAdg~q0aX9b7byDt|VJTmeQ%s#K$f2Dgl=xn8!80 z&;I2BdO$f>5;;jrM-}R^-0%o5g$X?GOO!lPaq`pA)I-eI_CGgZ8~RQJ+vs;9MBCimP{4-7dMYy}ji`d>&s0o8Q z`BUUv_HC_<$qF3c5)*dxdh*AGCLvxwk-OI9Q`$sNao6WfPQX=3h6KVFa&5`RWjKpJ zxtSg2SY`Rn6lV(dJw_8e5k9;?5nPPic{yuCPoBgTOQ*HnN_qR|Y`r-xXU3_c=saFs zpV{UFXAmJFW7Qu`%Mrww1oJ8sv5UC4qU{rTVG|k!lkxzqktfum$-+d*>!JgXNcY^E zqcYwVZ+7U=Hz7|SMw4L&so$@H1D8^ad=kmYZQB@Hl&?9Zb5ZNle#eJgl*gA)KBcJ*&)(3t2t)7wB;{Vs#r1q?7%qwSJIeZ{0H39aIQRX5a{NhE9K0gW0z5;`yr<=^ZH{ z?=8u(QLOLw`^)%bCVI>Jm0s3Z+2&O%^-UIyzw(zd?0^FtBJdWGFNOhG9t)CWU(Vr_ zOK8R(gvhoDX3yq1xxp?i*J&BUrp2+^iqiLoQr&C4aJLU9x~gqtW22T>&e`Ate2%uZ z`XU*P0|2Lyt>Ln<)ZLNM&a(D@AYJU+!mbF)k8}TU4<(0?Z8*oh!abzanz@IqCvgw` zKiT zPj+Ta9m%g6NR0K6g43D6UOu0Ph^vew!L6;8^6L%icS-z9K9lFOnJs|0 zMa~L)xnwYlrBQe@%);E93`MK%`*oV@cbWMZr2SR|mG*19HTT{BaWdLOGi=-*h6ieX zYyY(Gy@OjtmOy9xU&FBm8KKf(r1p*&<)$Z2nf)Q)io-RA?Drr3nOuAFSXKHE+pA0K* zam9t4xL3JL_D1emG^r#jd-?snVN9qdV3ndW&`-u)>LMP;Z{?=>mqmQ)(dD)F!M=h1 zSpHb7h^_I-aQ~LLT=o?2oQT^U|pKkgsAwiw$&@8X!ga^Dcjx-D&HeX{6~ z`d!KC{AI#OlAa5c+@kP2mboj9874NEWGsH*Due#xRQKCe^D&7_Z}U1feFMZ}q|M_Rm7^csh$Mqge=zk5{LzDG8M%voi zZXMLuweNbAD?K)fI`cdkfbB@`#Q!P{@X-zRg^%>zs)Q;9(OXijE7Cop=aX|-4YvOo zPEUKg!v5>m%gE7;aRnvE4bsFzp+vnsQrr(k$b3p>Q5AzfUpd)V%AE@1xAM=CJ2iP| z5WFjz)NT>JDRm5nwGd)+lbE%>V4$ z<>d_>umf>>$)!Eg;W|;=o*A$_c0Os?tXpT>){0|1JO6QM$=&c(uP$jBFSk858VGw1 zl15fzI^2-Q-CH4iIQiLrkt3xrqkajc`!gIeO%efE!C_gWA)L|XXOZ$L*bbsIK&Fkh%PG9rk!>gi2ytE2=DVRwgGK9$b)D!ryr~+uLN|mUC^Vi4dT{ zQOj*C4Lei)x2Tb~)|t8@QPCb4FQ#oBaPX$v0=qRX&I(FYpXAy}bxLc>>L^dLE$g{| zl^pN)TPWIn!P@i;AS1W!uRh9u@7vKe{INcRhu38mw`$>KwFE8(1u!r>5 zmu!_7qw>P6NAEjGcuv1f1Y2!sw?HDM+x!@b7(Tno?!Wf!51hiJTLbZ*jw(d`N4s_< z+rki+hZouVanF{PUyl+9Gf@%!(kD)#rr0z137@wlap0@L^RDMN_9>JeE-9{;AFm0> z^j~@BVP})I%=d!i0ZJjGzdphNm6t%$#qM} zRF(GYnITwlc^V!2VfUxj=6h%BQV+Z%FNHlbS&J|OGisVjO;WBG=m9(fXc{E zjKv3)y|7L_c8E{KDdSs0rotHPM7z}Jn&uae2h%Y71L_{8t%elU0F}xf)fU`6ngT^-Frh81QPmX-%0>>ev92M4Z3mhiGNv zW_T-i9*%n)bS+E)LbX~q+>U(6f1O7whgV?3k(EY83NE6B+R~*~eN9Hg${Ic`9BtH}Wu*ASbu_Pbj=4#9Dmtb@{g-xxfdo_ci9 zz9KyfIEKEVP5Io>E8!eUtV2yKMz8B$%GYH(Js!{JMz6MsjYm{Mg9c5h=5`1FFiWxj z!>?8u89hcE-ohq}ufY-EO(n+^@5M8_s?F_vIoPiFG}tJyBafS$nJA z7<-60vaA$a$?S@ZA{R~eAWuyAJ;6(9I6j=&A}E7jZDx~sH#GnQ$J6~CwuX+sD&FOn zHFP9v(c{ODt&~yV**-f+Ny+b7I+O#5iLqPNL&qz31JBo-N}*=6v?7I?sSqzDaFP;e zcJ|e9(J76W;8K3K_#Y2h1Kog&t(>GQ5JYw9L4HthA>X$YXIA*!*x~&pzC!!k*@b8x z8&;KeopNlS0var;lUFN>S3XCsLA+L!7v6P0nhf6OhdovlxZHWa_cwl2hqY9Uf2sFx z87HlN|7wQZZ#mQE6#n$=+kgG~*|(CPP0KBOt+AqM=9f#q(|8q^vHiP~EBj9$eEaG* z)f2Cd+Mam*ht`WP=FE^Y`Sy!mxum0!WtR+M{9Pl51;U$qboDA??i)G;jJb#AavSfb zIrK($+%~LF8&qsH`htwUbNwdC%1O?q&V6JE?YTxAn7eZQ3=eGSwiqP;uYGpoI4^Z; ztx8k^4o+6}-@oV4_4<#KOn+Xp=ZK@mbzOyktDDnPkB$!2K0g>TA@85tkMuy=rOQkM zeUja!99_SOVD^@7+^lX&rv69YE`8b10f?bkvQu|eS!sW6Zf-!0iP9bi3>=RdF0F(}M?7_M2+zN6`eQ^ZBEY{O32bvOG18 z!IJFo;XV6{GfnT<>o4ab*-ULhvMGxCie9s+bwYxAL6!j%?st?zF*LEuGZQ(Y2421B zP<$B_pmj=7jFm`_j{fMPB=U^gd?{C@{Op90(v~g@2ov>3+@p19j5=eJfsqG%uq0DG zUfuG5(exe2M7}ibHOLc z78VwyP`%c=x-j)T$)&jCBv3Ez_B@Hc5wdlpItnyT9itBjFO6nLX-lU zdG0IN0h;LJ<2LMHgI84J6o%bGd3t^QGp^?U?As0rDXxfTK!OO=*F7>*hZQE9*AI*1 zI)96JI{XH;8e}wkJffm^!h#vRNHn7$mHUO9Bt`4e2e`-mgTwTvb)nf4J|A$#eyXB-P28dtV3#?OOX*5GaNB$>LF zyKplsOa z3$bMMvwK&&*1^|T1b)!q&Zo%b)bf3Yqyq20oB$inb&$uBcz`3FnNgA@`0>vFH^ zP}`@AF+O!38S;^@yXHI^*xc;`Yu}JIm&a@1`u2!$Ou}_+{wh4_k?=&N@f`5uzTA45bEhD`HZdMyerg!M-r zdcSrq_BpFu2+J44RiXv7w6BgExRTwf^Ai29?FMLN{I%ou_t`5nJr3Kj8O7Tzv?{MB zU_&}&q>R;1rh6tg4N)PW#x=~W?VC(!q}l}oB9Y8V>hHYVGeDg&>g&DjjxXF4)ibLK zdARfEm{8*mZOBE(X zRV2+<#(0-fx|6CK$_;Il-O~ZOqXEW&Vt>&*d-jp?t9mA>O+ys0_a>Xxwb01!obTn_ zicpI!9cJic_%*^YSjF89M!?jtK0cA+jiV_S!MsTmTdZOIRjHwm+8KjawZIO+G?L14bT`tO1HzwvFCNM9knFf^liuh4vd+f9zy4^mqK z_lC(TD=#A`NI=an+(tJh%30NAC=_n$jDC^~c=|F=%>0r&?14Wra%~Uak=QQ8c_ZXs zlQ~eVd0RIsW-OTN(PRGz_)zSz@tW4B$dUCtv|{tkL<~1RWrDlNa_S5t9~RTp`k@w3 z`UcFx`Ik7(PZwKcw-f})T54ZxN(|f3S?AX4LnhfKcJ&yp*6a=I$H4YbUN<$T;L-WG z!=A1<1+h|~UIkXpvZh+%y+{K@CB6WgB1O~OC>>7{CZch+RGSguh|v8D`}JHC0_4IgMJnp?!U zo+q16O|1lYVNc!<>8AU}AF7|Kep7vQTl3jr->c0reg!XHWCzs^+!fPlWK+S2bbYGg z{_XDqZ4rmpZy20HV4kQ9o76`)w0@r*pB~kos*>4#xwm)N2?^N%BAt6u5A-Nu<0lBuD*oE2af9KL^w)T2Z zkmCNYU%{BVdVsTNW588za@J(G*ra6MkAG0(*0gVCFFvF4{>mFU3_w9Iv+wGYWEiS1 z;q%y2xqJO~C49_iXg<<>B^eb$fOg&3t8FNcE{2s{e4owHG(@2}CJaAwIhl^N>sy;z zk2k$L{_F5)jI>-jQ9q0}#W2dQYM5wY`!-iOw9quqCHIA!A{BGcn^QW?y68_0B z5PmeE1or-58G*Z)p~r!A#C z4`}m`j|@@iis6e5UW9-=3;4;-f?amZu$1r{6$o)W3^P^(FZ`&%G0{K@P3PY1*r|@# zqz$o5LSv^Tp>aS4wGcB*$L51B{RVo`X2h%0)T8Ru^cCDo&m?oSz~<>@0cBh` zIa3p2CV$*sI)7_1Hw1}GOiFEo%7xQb)k!(zaopua86!&Xnf)_sW!a~Jf&6Kf& zCXnirM!~%V)zsY{z$H}|JemzEMH1Kswb1W~ZTVe-qEfAi0r%JA|pxT+T+gYqXhavDpv4D$mx{ICSil zL_~0LL)5+wc^L9G?yzyyxh040A7QtUaZ(&6iT%~9S2y?@TAxD$aaE`%&0fO;OqO(3 z#A=7fJQmfS?9$^j>ouTLsOav7AEz|zRg#q;*k87sAGXnVmkh4FC)I;j6rt{*1xBV873VI;3R+=ER5B2_>y?dj7bld`&A@Sk%_)OS#5j-s-L&XSIbbFkzh3Cwt`dc_g?rw!lpJa{<<3%hJME7Q4J697 zj;O$LkyF+mOQ*4)?aM7fIhY})7u~l*vJ!Ot`Z;Rl(Qe(FEDY#7AQ>Jz{9Y^2 zQl>%hli_-Y3S-*}W2cyrV7-ing}gJKBWHFji}dh!9!FDgM?Lq&NmgCA2whAFG{f=Z(q@l9e8{2swliQB@g1X$ z8rrVA-P<;ccoB3Bw2q9IS_9nowg9vJ(FzI0Nw*8|I;9 zwywd7F&G^R>`mfxqvu)h8X{>|xXfr$w zajIKP#7VgQLdS&no4C@-<#4Kxa1AC{X#3qD@?=5^0@a62@0)*2a)NvLCD@f^W_R1s z$F;?c$;JuJAk+!&irr5!1?WoxJfknXR6NYxjtQe60YwLa@-XWeH;+CaD6D9QfBakh zekm%|av#>AvgQEO<;cr+9Ue~yBCBCB*ZJw2YC>(*T2Z;1O9jl?vw+#2r!$xV57Ibs zVKSS#BWz?UOJ&?D^WoWM_2vYH4r#nj%2-DfrDdiL)tJC-?2L|Ypc!L>Enw^St2rp| zeJdXKI7lU0ieYHv`6a!Ae~lACED|eBgeiq)(lNK5RB<3w7IfRde}aenc|#!<2LXIU z$k;R{22W0n^FSL5;3owr=MyUgkz)*mwuW`~8&rcH0I<)L7r6bV4(T*Rt{W|Mdb**) zXaRwTmP30+!~Hx)o(#g3@CXZLRnfRmC~G8Vq&Of`knn~L#=Wk3AnJatVqT?!W9Mlr za6SH^is%Vcn7COHa@Ce_t8Tb*Iy7~xSF%{OE7;;B(fq|qwm9kPzW;lDc~y}xOH{Ps z`P$g?Na$mK{?@b$7#f3#HzHF%H+0)%j>tjVR}r_6mZy57tHvf>}JXX3CB*Y$7*5004;qK}lHyU#LA$i(?) z>is5qm^ags=H&=kz!aACC1yBuj|73sl%f~k2b3U}bPfelnTLBKy5ud_EuK%ip|^v zUvx4uS*tRIu(FYsaT+&PH;Okq>+Niw$kY?hvsBMM!e?-9yLqOe>PV~)EqVvPNkZaK zJQL;Mgq(cqfnJnhp9%wxjj{2F>Uo3|(Nj(fo$NHfFkEbuiX#;fXkIL#t`3zOblg*^ z_D&>$;aAd&r*zzpYCutA@?~6vslYlv-7#2JA#}VKOu?R1ED(l z!p_xKVHKR8HlJlV3JSqjB4b5oI#f872Lp0sLwV=3#}#o8mRR>k0cFl}1NK|J#h-&)lc>~nc>#ZUXUNmpnTDX zJ#vzLZ+t{#@})>ll<8#0-J#D|zpq5OiO<5mihCM?v>tu4frs_!ASggPQrD`^*FVDL1tdPy0xTo9cr{hx7xEvTT z4~N=Zn5CvSOwtywZKVkmp>I!HjiVn_xmSdbT4phu-_Nc;#twOi*4{`2M!JM*$7s0c zEX6Krj8M}6h=oJuyG~&SbmOGdOxB7Wkep&pFK9@Ch0SVv_k|PCVEg3IF4Q={Gq{ym zfsc(nWM^lWGfutGG%kAd`nD2*=Cv3VSoPl4XTTt@XNa5y3f1#G`T~1~QgI=BhQQLZ z$m2qJa~jJvV4?;Z0jwKN@4lcL0V3cQ0PEc6%$xThtpIHkyh-?cj=jA-U^_3hO1`Yb zNI%!_(JSgJ6CH!ZL(3-1$A87kf=5cCBrMmUiJGPKvdMT^d|`=>(cGe2K=+)k9vGJQ z3=Fw;?a*QUtGYgZeohl#&8C(lwRY+*R+RY+e-6529v3uXh*JOkue?3+*3bpRJ=ucCCMK~39{vyu`e z+7P<#?)m;wgm{S0k2!37J1MhaVeDDTLLLq zv)HI{FYCrkoa3FV?=(;aQkzSZbwnD!O|BE`>vL%|Se9$rA6OARHbQve(yHlDivHha zI0q5NqEuAyxI#`Rv`5Dm8VvF%;gRYc4|VG~M?&q?U8x<5%I~pOLac`W?5o+F_ z^P9<1wQp*DN*4=wybnDE;OK?1So$<=H|$&kz!_c+payTSu_DCn7R{{=+%c z)>O-##<~Hi;OET!5@pA3rvqG!`NE0)OyXp@iI=@V&trln6caR|BW&Cw+s3D2`4LLp zmfGGl2@SE{FG|H;##mXbucpl7gdRC6PmLVP_A)Ix?!*gjHX^DJ8aaNEk&&;^cC7&> zo}u2M?{Js6b(c48S6|N&u>t?j8F(=vLIas$F0m^{MM<}HouA8gdU+N1an$`L4yKq> zS?ss7`);bybHa}~^r=IPD0~(dupS-g)7e&#_jf_WM*c;C`@>&54|qlWvReTRnEeHT z8=^jWiStL1V1Nrn@-;X5oh9sdBSPe1C4^mv@izAtS6JR|W!N>mm%$PkCJ6RQ*gJ%%%Jd<`Y+1QtG-9XJ- z%5Tn^2-s7_V*UR7pIP|Fw7eFf>YETE0jgkR#IS;*gD!cAE4}%QNkoCn&?8#3;W#y2 zT9sNAc#2v5igS}|K@_G*3Z>dNW6ZXy(Zw*FF<%S4{0h7sPk9U#6(<<4ys6)D=e3t zj!#L*L_vlsM5POZ(*TWmgL@A(OlVBg_(GO@o~{@ADS;y?;=#v$aPP5)c~0zOIhw>V z>_MvZ&Ft*r+J|{~{~wHOa~9I{awB0Bvr9`$y{eTvcKLY`u-{~=F94Cxvg0cjD`6{# zbBz|=s=odww87B(7l9^+pn5n`xj5^8u?m6$1DSL#$)9b-$!xZziX&baa=5l^vw*0a~Ka2IvN{Y%P!^1GL zZ@B-nl2oIE{jWbwzcd{F>t82!8vU*4`eMFU)U?08Df)x$hQI!$s)qXRuYaEX^dI%v z|GjGV-@K{X0MbzWIiUs2p)UxjvUKYR6WCRqEQ7QX%|~>cDSh&D&R*4U=dzX;E!+Eh z&5GWAmKzl~+P}F5^KxqcG}0`Jstf`ppy(rcUhp&sZx|8cXmGSLPOS6pbSN>@y0nJa zb|+RmC8}3Sv%g^jg?ES(s&SV=56}W@ftS&$EQ4VqXC+h_O5T)De|LLa_C$iu9xXgg z)r0B8P%?`F*-GL$Q}5g{V)QAlC zNXAHxjMmM)EY?mViuV&kHhjk?-Bjy2Ka~xAc?vbTs+@GzL?7h~yK7rN=6idFKU3ZG z!f5UV9U9XJ_JU1H1?8PEj$) z0olQgC})M`}R94QKT(urvDq&3d>b5>&x zYNnDzj$TpQGt%hiXQAAwZ(HZmnlsuOCX!s|+IfHcF%TjP(WEJoWkeK^Nrf=?;afCe zf@$)B7>=!9@=G~P?dj^?5|Dx+2Sy<(L#P4oCIT*}ZMnV$$lJVk4QQZ}9ELZ*nVf*Q z#H;K+a2csUCx<`mnHAYh(@e}qJ?G1~zVyC@XjR)oOC{M75B^gkQ`2l+UmkK2pEnaT znflPr(iXGs+zZ6hxMzbcST|Ol{B*CL@j@XCLcC6ud4~WW!lT4|?(lfGji+MFYV50< zA*j)aEXx$1&uTC?nV9P3a}cGaQnLVN&{7^OJ#R1*PrAs%{J|&BB1^Q{%9yyuu77;| z1wiE)%rQqmhE8j<7G)O8`4yh9uE)f^+rAyUH6cEs$Si8iloT4K{2z9?fU3?e7ZZ2z-kCUwl?I~vm+yANAt;nT{|#0KpU z<3v-O{LE+v$IO-Qz3JuRZX>Dx4c*<8jz-`ZJDE$UXI25oQO3hOz?s9}yxxL9okkVe zS*);CJ)RiJcDsIu-!HNsL*~tDuf_oTzF!y}-G{LSn@YfLVGdHjVD9wDky0-Pqsqod z7h><#Td>C~M`#X=m%>AyPdMjKq^7e@>>nlOCZ z5}MP#vRoxuE%xLJE&{9&rMl_0YOKIJxQhqq0FK#YKZwMF*tA{yafeq3GZbLemvLq-qH z5_zf^zY-Si+?kIb5UE4)n~QqUFNH6_e=9(I^~DLFvRKbMX|Tx5HNe{wqrn?Vu$1qZ ze#4i#jVqMjhcufqs}D57v{F$#DPJ07pfY;?FoRoD;*WB< zH}F`Cgc(!-H9!coQx5I?dDxd?wy%HxWuyS4O6q8ISjVGVPcxpX99`TRTSERwr#4-3 z=6RbgrAdw%266iGc=DSl$EAdAnJu558B#U=C0c7Yl8LkA%kb*~UPa8?_q``R#tjct z8D|;&0F3J+dgNxzn8BbO{I8+|{0RaxwW@r3J$l`2sZqhp6$x{=j2pL?5PW9HqSR~n z=~?6HM6sJ=@Gtb0;;n1bD8X1jOvj^u+k6^ugEO9qaCxm$9FBc@HBg6M0?rj@S2ZOx>w1kl1F&~E^!Y56nv;>p$zR? ztV~L(EQ**1L1X}vx4#Ny6PXREVCWab!m^^whyaxh{7FxKJ^D=h96W_g-E9d-cny4mH5@KEz>&9{< zBN>UL)U17`6I69RKIOUWJFT68f*9QrlQ5H&)-aq_xcfQ zd+zKgf;H*=j08+A8xvEKE-c*Gc%Bj307dOA#e$a=70Dg_RQH{F)Q*k#2Y*C_-*}dc z!ikyUFdNz2iOsUQ@;dvL&9}w&%SlI{=ybI)nx-*wvro+1g(s#;0wzou2X55u9@PFD znEiy^S&`$9rTQoX!S_6JUC%Nr0f!IW-D31rw*BUw-+8$p)NXdYhCo@3QVO74`%>iL$n*ZnTDY zNNG4l5etm=m)h3D`#J+l*l^GVoaiU_{Y-(G;+3I2`?ed)Hm7%@us5OnM=Y}I#Od$J z;!mad#p?2>smdWA7JP>FC`2t##Io{Qa~xNU6hM6FV6=1+x}aW1P~^=`u0*d|$N))5 z?J$unsH>Hf=tuKZO>3K)lwFh%PXrC3s2v-@3?RT@y6WySlqss;(XmRO4<_h-@O=S> z;Xc9!EATDh@!!Y+*%)Gjkc2x>e-M7}~X9K{40|6u`D z3*_t1QmHfsC79!Zw04MqhqVGd za4#a%)AVx$h4E5avri@o26p~%*~oFaq7x?TVShoO4|jyr^Foi?wlK0Dbjkrk2q9A@ zzaa>qZmsp?*dPx;9@&DH=@+IWS}P2;YkQ{s{IdgEPr<~&|3$$4M*Adok&Q1pYl{qL zq4DML_VphrErCZG0*^efbTg%a(o^}&b*Ctx4-telap12o;4u-GFYRrCLz|J~4rhSq7xYSgh#%K*%t?9=se5BDyat)UC57hX|9{NUe0ky4+RE zd1pts{84tqt2M0RTg({pr|aMgjG&itNMS4e7HfAh0PW1fg6hIEj5(rjP^O1JRl8zz zZ$tkmE*7IMXC%MWh6?}lT~)a|8Djy84U4G59uLP8hij?W2dr-r=nbfEOQ+{jkPDL= zo(kKXCqgEc+5%-y^aGfOPkAl|KPF!gE%%HeHYY^Vc9B94X<6jXm9Hr(=a70e$tD;b zf4PNvQ&$XTsfxcVP(QaptYnUJI>0eN!{TB3JqQWTZ~vGDK<*mUjkgVAXnu!IEF6yy z(U^lGWL2UJyA(=B=s0b5X7C98k} z0+J+4K8k<@38ElbksKupNKhN4$vG#9DoL_r6AF^EfPlgwC&?LJt%Lpb|J{4X8{@v` z7(Hk<`<%V^+O=xcs+u+D%r{FzT2 z5cZsidhy@1lJ zN0{LEZuP<7UVNRiKz6P*MdqSNF zF<9g9jNq*J16WpY3r7ttEEFz1KNAa?9Z1O-Lpd@92*sCVJc+#@0TZSH5Z$P>B;?T%r8f=6x9Jua3Vp0DJ-YIH-hV&5RFqkj#@}2+;585xg0mC<9bjFs#=~VFfLZA~b zKupFL1*Kn4+JPOxH4AM%pF|b~aCX>!Y6%mWT?O)3Sa?9`qp^Zr5xNTGN-V@F5v}=S zXhFcN90J{1r2oKkZ~zO1lg{POU%mut98y4HE~Qp|VU;|`FcdH*5kPT@jRPXpSs2g` z;Ab_4mtaRjd_|>*>~I??r#cZ9y3$jq;d|3z?A;#2>Aw%Cp7G0`(sEy${Tq__kP~U6 z1dB(ESX4P6rT|>Bitv^FP;>z>0C9@m!2veNORS{-JLY<5;Y6+HU=bYAsALBK3!_0YZzUz*zkq3gK7@sHqTxdzvOw$>3m+;vI1pkBA7Y2? z&!uUSNmsB^?wgnp-yJfTCW!s>KR=|CZo@0(nvuoAJcLxfOjhM6xZ*Ft1gaFk+zEkn zbVEUJt`0S9onp_NP9Xyr11jZ1C7*Z_O8HRQ#~(Q71^UdSkSp*5^FtYoigZ{7fW-ue z(WRh7PXWxbZ8~u78jNK%jHMaM)Wd;0T97S!2YXZ^2XA_Q$Q&We7Z?p#iz?{rVizE@ zuMI9^g&r;jl;!BaJ!2rb?t)m%j^bV|MVBx7NTGt~8Qh-lRfY_flhkVH?;v458?Q-oe#u3|`>q7!=y6 z;CleaL1>KVg5f~5vYp_u8<2?rR6Dvu0b_`DfW-0UAKMsc?jc|UV$ym)FpU!cUeJI$ z^tARw#At)%w5<{qZ{lIW-iY3~>ZZR@ovs&n5AOKwtjMZ4RhE|Hu5sT?Ka7K_d zLHR!}v4_9z&i0pZK*m!7d}PWbSY15&YG6{XkUu!!Cu=9jVb4dH!l`R@r~(+CQ#j$Q z({R>T_{cv8{I1yv%3V4pg)zP#E07Y7{tDG+QS=>FaQg29nQRoAMV}xz2nY^Fl!oAg zylr8s~aVmLUEd8$cQ?>v9JRE$l@aAZTq1M=lk%v``;Nc2f5~j6UH-%K{e@=ejRK$03W+?TYFM+#%YzRH#*S5fucx zJ;*SV$XEb8ip+OI1WL`Q6!2c-$^s%*1{DZA3pA`V&(Jbs5XT->v-P53WAf}Mub`%m z-S+z$1>FZDW(n0!FPW@~`omX-w=Fg|E!XD*_B}hRc||Ihj-HYx^jIwAR}P>~dLvl< zO#L#1n59dsMCFB-3KwBhfd=S$A7qLQ&FZ5auA?<@4AvMxVqw^LHfcM+*VhQBb4qAt z*Ui*8s0>B z&cXL6pf!03xS`SXjsVGysqo~VA?2`SwKnB$4C_XZZzW`RYj70@K)fwh-2B0+Eb!<> z>Lhhr6J5sB&3o?otW&Oc?M=8rNwu^~*(n#uyTEjMKIXCZ&F4^q@bItB zYXi1)mxS3VZo|#ZymFz3dEr~IY6<*-QYLsaDt)zUb7nGl&mtqYH1zCnoV~@rzP8O6 ziEN=HDS)h3R<$yT5vzNOa6@Yw9n3*Dc%!+Y$uI6qQ_9bSlCOnSV;SC3WkQX#n!1lu z?h8vZ)F-F!59#a<+&B{xIKc4mQcY1l74@*AOJ^$s-K2k6qMc#YufK9{NJYa`1p5@ywy6Ts9^Mj}Y;`6Te$jyBr2Lh|&{dV}O-z;=I}l9>*J6zTZTkTL6~w z4BSLdj)u#Nn$&eix3zD+J*0-6e1e+(!9%?Crq+EaUew=ob9?NiI!OF17l-o(E|`uR zE;LyMbbfKCBH#X{uY1W}rRrpLTafGk;bsJG z*gbCB^&^wqNV!gM0)cz;J8VEe(C7K5MT@V!s$PsahcNhMSDFF*90|=XFR#jB+q7gE z2vjeS7O^AX`yj>S5qMzm8cKceo>7$eRoT-fC$VAXe3#}*s)=dvjY?Zio+wH88P$Xm zW9h+I3u?bN)H%hwpo+_6GMxE{TXHw%o4}hTzq96Rk0Uh>nHjlC85^7LZdM@6;JheWSTn`6oF8aFuV(ttWYpIm=lK3u0E5AeGPLh z3Sl0&SXfTe(Pjx2?o3#>F=*k2g(<3G)0Ng_H#uMLu~ zA0aRt!LK%H6m%XTd5%x?_7Vg>^eAlqxk6C?6kr&X3sMj+LGKFUijUSgj398{Ho%}x z2nIGuwHeD7l048mi*q7frF7-;WsX(u8lo_cT4t6BTa9?dSQ?(^X;wIC*3MD?;(o2JN$XvcJ~5y)ne%nemn{uEeX4#z!p-26kRnS8iTCx2tw( zIQ6!v?ODH~Qme~5dwDCugHk2KP2D0eP||28j1Sn;D8f8LxFz4qUekOUm_m*{fl>?r z_JHj%gyEMV=)~XxK_msuyP^74kjl{|s}`NH)OWNv^wD?C#49iBR9(m_Cr?;TmJU%t zv)PJ^o_MSg|3Id(y>rc0gN(xInQzsmE&+K4r%=tJZ&Q0VF;>s6@`mMBH}|N0!TRbwGELQG!I7+svI$Vu)3X6$ z*$qbP@xzrnABCq#tgF3QCka(=p&dWCWt~#1ziVokYOme0-;jv_o^b+ikUX41nI|?r z5U2yr*+DXe*}G#ffaPNPJdMWXf5)qHW9W<1G1zNF4Lk1U8hY zp_GyVy6I3`(c}U(rMW>q@^IflUIv0c%vY>urVg-QT4dFvP7;M0cT69CR-JQ%r~nPl zHRgEUvRLbIZG8@n{Lk5XgE73~Q^W2o2MeUZUkQ#Z-U8JN#ny{0@nvNt!2(A|nWoqM zl~wJ^@3hVhX`8b4(RE=UM- z=EqJO<=$cPHziY11mEJbtexgo2b92cHnHx2W-2=o=tq`#JL-h2K`fYYM&Yb<2-o#*efDjBoz)6uBw6)_eJnS0uD)}tbJmf7@FQ-RRPT!!3sj;E{#NE?^`MdhY zN@9Axv0d{mR?E7$L|*Y59J|%0&BurJiZ}=$NN1iqZOm!kax-nOPjcIN8hO!)I&mzT!Xulk;R6DZ!c-A)v?RVkNI zw9E|a@hiDG9Jw0sQ){Q1T8Ay7Wri_UHq4VMhdJBropW)g0klAX@Z!4y;kk2113HLrVOdY0Rlyjjq42i?%sx5iCnma0PR;eqzMpG36YqRN zr-vvsv15)leE|FiMXl$rfcx5_Lb*DU4i7XuQbL`N8ZgDhb5$g6<#C#lwQ6hU+eycJ z&1gt5Y437Q-jcXG1YFV?Z`~+innCj8KIA}VGL5E3I)nedLAa{oY5s^tQ1tVY$Pd@V z)W^%xa;`97qQqbyj2fx&D1mdJJp@&sSlsU)ehJB^o7pN=8J*X9UIdk&3ZW*^XLYv{`vvSC=2?XGUE*XJp;Aq+Q@VQyJED zq^jy=qBQaL@oJacz1)G_0JB@$WnnhQl)f@;mb+7E<|D6x(j|ZsEr)<6sI}tzJa3`4 z;frWFNrE;VMBoXVTIf4Ua8j@5g^~R6=VmN$u|c^PXBx(4;i=4*Hv3`rJp{)g{#Ofx z#qF7sDxE%tZHsDs>X~{{KW4pfi@=eN|N2A*d7DS#JYl21fhI?)UX3-sPkwWkl2aPJ zb$M#9Ly1`Uh62@owGO+zzL{p_u26P=Z7R5XX}i^nel$(Xh9!4(O4YFD#Jl?Rw+XR( z&~V5Dr5QuBmqq-ns=5%CyaOO4z#s`wM@8p#wPlA6TH~zoP4Ap0%+95^{qSyHQTxw<2FW)&!)q2Y#T8RqD9&hqbO7C)z%hspK z7Aa=GpXOR}Fa^D=Gwd@rc><%l*&WnGu(UV+=c*3yqNX2HC?SXBhm?5UZmirtpIY+d zV|Pt-uX^#qj6CW2_ySdmLF>erD{ig~*Y9ima2cwqp7VH95qZ>bxr^j0o4nfg)#{s} zEukk&qD??-!U0mdrOr>S+hs9=9rN325uriyELs{_IWl7y<5K9x0wjz-P=6aib_G-M z>Bkgk03TewFIU5=^4n7Cr0j6xjMhfY9`5IAv#=21VA5FGDWW#gI51kZ&{;w9Ie*3Z z{%(8sdX2Cr-;@(cDp+ibWa7urHUuPrE&6+u-*8PIN$EB!NRUfn(bLGXLf6(j*d-$+ z70AWSjJFYK4p#D`MNsD2rv-^I+`}Qe`?O_j!%fqFVEbsq2O+tMuXL~%I-5l3>3^zx z_@_hI!q_V3BZK`Pv|j{vzvl>C^tDQlO`R-0n$j5~@iy`5e0mr~ZIpG`r}I-?t|>Z8 zmvxG@lBS5@O|a!%pv)y6D5Q!KSoSOy>o|ca`8z+%pDY$piT(R z=m|=~_(V0KhS~Qg$jJ>eJzTR@uJ@C~g%)3OD;ep{+2>jfQ%)dRx_KtwS?GvqSW8 z1Y+iDj^JZEVaf?@m&GwF$2ZFXeD9DRf2Fn$4YYGq=->6j z)Ss%px}S3sBcxy2>-Qci1olth)Ga`o%<)&BLt;i`q-K!cfmg~4SC_~~d8On-P7(&E zmPSxBM~0hQecuULZ28xb-7OkLH)R*Pyh$hNTnF8}*jkYTn`?#I#b|4h!l?lgQ;}Qg@uAiYzN7dl;+s6tOT3bVN*=KD z2s|weJATp0+xritN30t)4wrmeIuv1Ia@@>hK)_Fnq7n0ku>mt&bsX1hS=oOM9Cmhg zB9NcSF5tXLr^DL`pt*vdbm@)Zj}h_cGA-lq9r|I?@Huur;*{Qo)?A2@!ep6_8`w8x zK5TD49n4l$-&vo^tk}^;+sw%nUgp{PTA%A8$t0>v1VTsd0kQyxrS(ra-_K)jexb8O zrz!Ogv3FhA@n1LiLVABpIo7v=fUJdSwpKzrQ|cQ+Za*bi5^r#D*SZXNAGn4(WKGkH z@*d$kzqvju>(d_S87$mKkJHqiAb>E(!4h`#YGEhr%mYl63e!gwzQ|k3(`k45GhK*h zzi2DdPTH;+f1-90SqTE;!z}@_r?rB;*nAZ0g|ec!Cf&wuHk}iWjh; zg?JIGWXXA&u*~H-m&W-7)co3)FXK_nYz+$-im%{R-?aErpXQc7kTZ`x30ywSExjli zb?utcnHc$ftZlqn-3)z;da6KL!P4eMXmPVD95+cJF{Sx{jNeO zjH;Y7NibzlOG1asMBc&qCgy8);#kD7B-A-leMNRbVld`am2WLk?n*`T^l<^8kjnRZ zyZxdoPtFByE=;_)C7>{{##DIuvt^XXxHYf4N^UO-*{E$a z-SUTi)rUTu?=fnm$BCp+y?StF^6c-Z3%a+Eh^Lc-*+){9Z*;9vHjO`HuWBs)cuM|x zXXiz0n*PNnuT3{|2++Lbkk=H@Y4}j;dRkl$${X@IrTu*taSfAmWN$H1)1Q^b2KDvW zxf%`1v<4po^Vpbxn1Q119f>Z38v?In%1ClEc++wg`n;DhAwrwwB7WKY5dxECseLSG z2WSQ5%UQ}*wYo^lNWoEQ>e~0_T^ks8)d;ZRv?FTsgS0-X$N}5JHLuzYEu-CTg@Byg zeU_PbSc9h4^?CC6Mt|KXaz_hijaFr?hxvZUo2`TuXK$y#ukuaZP~W&PIgn+dE2F3U9ZarGMSp}`9WH*o$3Kt z1lN=7?Zp?~7O(`jf@Q8Zeg7G0Fl{bi`KU5((2Fis|3$-BBS(x`;?8%Ss9xb57+ER~ z4(I!SGGjn}cfyE5(=?~AZ)V!uS^i76Nf*=b(#?orKO5>Lm+9)SA9HA2^+t}~6+|74 zP$dRFa<$y8_P5l67oS+Tm^2IE3U2t9+|=!Ca?t4SSts%yQ4pnZTf|PLKaE%}J*quK zLc_}LXs`zt8i_+ZZ2nQaUi*+a?)xJ7=*BF=yeHct-$Y`M)q8om*qS3x&vlem{isR| z;7*Q~7B;zPu&1M{FQ7APqT#{_fzx-%-JQdkI@R0<~+n z5eKedYwes)sSEkV`}&-o1d}X{Bv)BC^ZMrAcN){&O(<^j*t7(x1M}AReczn!j{lm| zBQY_AUud+%{w!K9`A(sc^&)a7Vg3D|=9Vt+Oiq|iFHp*B>c1{qQtPnRsm{}n8h)~L zhw(Tr8kl`PT9S<5t*~s*MbPXR2K2{Vo&2&-nVD+*%}JS&SbSk2&34)Gr*p>oG|Lw& zKkBp9yo+@U;w^rm(JXnGxPOZ82kBnXmwo47`s}wp)##5X>l5qjvaI95826gV6fqN4 zRPGWw=96EFN^Ud;OV#n|p2M}I(^mKO&FVC?y3&({W-=G`2rEjqK3C4QzqQam|2ysZ zVt(0g&%N#HHu#cs$kft5?EwH4vs7;u5GCq5EwpTmE(}tgI8nPE5kBhrB~a$tUKD}t zvqOp<#r-nPsrqlNv#=68)HcidM&zok2OtlS@_f*9nd75h!)$yIE zR^K_)MjA%;tYy@tneX_e8Wdrl?-LZ?jP+e}Fa;m{)oQIP+OcO#gS3CyId7gakuA;^ z7gp&^>BjO|R(n%ilaU093K#xBH+eiXSre?`xZV->{nQMaVXxh@c54M`vAT>;t1d1D zM<%MKla@78)W#1IPG$lG0`M6AzgN-p!SgT2_${3kDy^rxCQMn6c2PEBRE=CYw`}B! zMC8Durk4u`e(y7L-eNB5D+5tENt)Dfqm>bPZ2sET4z{k?Ud=p~H{L?^*dGePcE)T0`S7 z=6WL(ZxPxK+B6Dn6u8;)Y}B)&Ft!>TilSE~=D4pUPmq@7PG*EQ;~#1iN=Q02cSQ=F z8HYSS|Gii>`dPG%Z|P#N%%Nrqtdn+@=@jPxX9{MeG`-w#^T&uYpHw>7Rb-XcbUQb6Rb>U zf&k_EP?f=3Ynf14p)wsB2DPB`c8p?>anqS-gqc4QT}T*Y-qN_CB34w~%aQ5T zz#BgzBWG*nHr{)FM=w05!$`x0Ez>!lT=@RxUsvRVxTL7REC-!d99!u6`qfWngOdm| znU3ny5Qjqb3pzLf=5gceHs3RoVn(i9?kfg8Jn=H+4|LM6K1fNpU^AT#< z0Cj3!5&qr>I^|^r;$O}X+3FEsANt8nD!HZ71u$du)i^CVrW zFEQ6H5!Y{GjI0yHAf}zlHx85sru@jZ~x@+chh_BpEC- zf?c4~8ep)M8colMze2)7d!%bF@)E@(7rBnq80I3fv5a>YW=cydn(`QYed}!rP6(vE zBn*f)O?1|Ox|5&+i+j~vz^Tz%eXlRCiF!_Ny|&x?o5@FPqBJbIla4HOtfV}h-;O)E zS+aF0EW0Rb)my&9cunoDAcQ3K05N}lG{-%0WLi{zHCWha@NkN^wq6i_ps_f$W!axq zgKKZ^9^-Ugoci)9^YLdQXay9c_xR4+!XS~-j!m)g3c?lq5VM@4s_hC-XS*=PDecPk zrlBx*jY%3v68g&~EWa?$*%_CK)jNmru`8S(*qn)fM$+y-?p2KhIDus;EUC!|Y+g z;Ikv|=5hIN6IL?qM^@l4apkXj`A=f7CE9aSTG>p1`%8b#$&W4D7S*V@JE%Y)Lu=B> z@zK)T88XcmDlp|XgQEKv+^!F4{8g{>-lgZO>dsB)Ic}#JlGLF{69ToczRqYb;p^FN zD!XF`;zeYWShzS<+!<~4OTsy(tL5bRtxn3Xb$^AmaXBACR>iRGJRpRNvX}mwb#nt=QtDL z%wrayO(tHb0~-~E8Lq}cB}VLbyIx*Ef;`U)_!@Q&e^6`hNE@WrDT`e z?qqR)cXq!dm&JoENs`IV`pIg zxR&ul>ibEcL*tR^RE=|ealMZz*jn!uwvx<8K!7LrP^wQ~XZ)s3h{nBj3;r^>jhd79 zZkPHRJ@pT-QPHBdXlxy0lyV8`{t#ER!_P-vH#PSb065Q1$yfahWm^26ds>_BQtT?D zN)Wix$+OKlpDQl=<3B@)aeTh>$aiG=HUv(ep~cP6*|~J_Gq&|&qtAd%O_0V>wy&4s z^=b799sO900r~XIP>VgBqB&+$b}j8pz2}LS`lVl}BZ! zrj>ERi?eQO9o=`LP3?fRS~NC!pgCEl!S#U4g)L7X?eIah7`2-jdJZW;x4A`$cdGsi z*|7WRPHI(&8PYQa>1NTrqMcN6yS>=Y0Y zGw_v^UXQeX<~(UEuW?^5scvk-e$vR(hSh7FWr6@jHv1f z%=K#7<=>8kn9k`_*qTnYY4~%vdGtic`Y=_mdE#z&kWS|6iZ4K5SR+aF$oRZe(Vc85 zg==RvKVB2to-XDbh{KVbkrAltX`rR)jI;At^bDg~7IvTY`LJI#dFx7$p&R7K8|7d~ zvkAy@FDkfeetoS)o#oPja7yvSukD(pw}aj$mEGYWywH3rR>e5^#o3BiWQ0;<6H8M@ zp4<40WLRp^=M6_?)8t;9dMtUo?#TrF7Bo4CMLGFvaCn#<2IEI zGnq;tDWC0%o-X-`B(7*){9*X>Zb z!MEPr3DHo;-wZGIHE~@GNe$i6ig{dc*1Y*`&CPwY;(X>W%0<6w1Bir7zRv0`Ik*Bx z2ETWXggHfoa5z(VUR-wzZyeXfg^cqng;OQ8{Vz^++>v1?C%g({2X!Y5fa9c;?3}_8 z3jly*fHWu`+A8f?0}uIWBy~>tkH|+KzmXasb2dV!lDaKiSDd<~5wLuQ+DW-oewSN^ zL?hJvznYgEN|lwlO3HsJldCayTuiU3%VKfEP>T|mb4$s#O&Xwp@SzJT9UD!GaZCeR zf{Gd$^mU6Nxm9FGBGI3SG1sGab^uMwg`g9t4G53-Jc^xnO!H11psv%@5iO1!Ia-vN zGmpwwM~W09uY~ze0NM~JMJv8tEM%0DUcAwKR=eRx4%cbEeYIlFFp58`e|xx_v4TL) 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 diff --git a/simuk/sbc.py b/simuk/sbc.py index 9b34c14..cb75443 100644 --- a/simuk/sbc.py +++ b/simuk/sbc.py @@ -65,7 +65,7 @@ class SBC: - **Prior SBC** (``method="prior"``, default): validates that the inference algorithm across the prior. Reference draws come from the prior and replicated data - from the prior predictive (Talts et al.,` 2020 [1]_). + from the prior predictive (Talts et al., 2020 [1]_). - **Posterior SBC** (``method="posterior"``): validates that the inference algorithm across the posterior. Reference draws come from the original posterior and replicated data from the posterior predictive. The model is then re-fit on the @@ -138,7 +138,7 @@ class SBC: **Prior SBC** exploits the self-consistency of Bayesian updating: if :math:`\theta' \sim \pi(\theta)` and :math:`y' \sim \pi(y \mid \theta')`, then :math:`\theta'` is also - a draw from :math:`\pi(\theta \mid y')`. See Talts et al. (2020). + a draw from :math:`\pi(\theta \mid y')`. See Talts et al., 2020 [1]_. **Posterior SBC** uses the same self-consistency after conditioning on observed data :math:`y_{\text{obs}}`. A draw @@ -148,7 +148,7 @@ class SBC: :math:`\pi(\theta \mid y_i, y_{\text{obs}})`. The rank of :math:`\theta'_i` among augmented-posterior draws should be uniformly distributed if the inference is calibrated. - See Säilynoja et al. (2025). + See Säilynoja et al., 2025 [2]_. References ---------- From fc75ea69ec07ed2e841f885fe19e884d8eeb9932 Mon Sep 17 00:00:00 2001 From: cab14bacc <86755693+Cab14bacc@users.noreply.github.com> Date: Fri, 29 May 2026 18:23:02 +0300 Subject: [PATCH 21/23] fix: pin pymc>=6.0.0 to accomodate for new syntax --- requirements-dev.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements-dev.txt b/requirements-dev.txt index a28f690..2db39f4 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -2,7 +2,7 @@ pytest-cov>=2.6.1 pytest>=4.4.0 pre-commit>=2.19 ipytest==0.13.0 -pymc>=5.20.1,<6.0.0 +pymc>=6.0.0 bambi>=0.13.0 arviz_base>=0.5.0 ruff==0.15.13 From b0e280b3a519c8a892b85ce1682682d49667f6d9 Mon Sep 17 00:00:00 2001 From: cab14bacc <86755693+Cab14bacc@users.noreply.github.com> Date: Fri, 29 May 2026 18:26:22 +0300 Subject: [PATCH 22/23] fix: artifacts from renaming param_transform to transform --- simuk/sbc.py | 4 ++-- simuk/tests/test_prior_sbc.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/simuk/sbc.py b/simuk/sbc.py index cb75443..e678d38 100644 --- a/simuk/sbc.py +++ b/simuk/sbc.py @@ -297,7 +297,7 @@ def __init__( self._transform = lambda param_name, param_value: param_value if transform is not None: if not callable(transform): - raise ValueError("`param_transform` should be a function or None") + raise ValueError("`transform` should be a function or None") self._transform = transform self.method = method.lower() @@ -632,7 +632,7 @@ def compute_rank_statistics(self, transform=None): This function is applied to both the posterior draws and the reference parameter draws before computing the rank. For instance, it can be used to take the mean over a vectorized parameter grouping. - If None, defaults to the `param_transform` passed during class + If None, defaults to the `transform` passed during class initialization. Returns diff --git a/simuk/tests/test_prior_sbc.py b/simuk/tests/test_prior_sbc.py index 967ad49..092cd41 100644 --- a/simuk/tests/test_prior_sbc.py +++ b/simuk/tests/test_prior_sbc.py @@ -229,7 +229,7 @@ def test_sbc_simulator_not_callable(): def test_sbc_transform_not_callable_init(): - with pytest.raises(ValueError, match="`param_transform` should be a function or None"): + with pytest.raises(ValueError, match="`transform` should be a function or None"): simuk.SBC(centered_eight, transform="not callable") From 6e715df24682f2ae94a1feaecc8447f5253d057d Mon Sep 17 00:00:00 2001 From: Osvaldo A Martin Date: Mon, 1 Jun 2026 10:20:26 +0300 Subject: [PATCH 23/23] Upgrade bambi and arviz_base dependencies Updated bambi and arviz_base to newer versions. --- requirements-dev.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/requirements-dev.txt b/requirements-dev.txt index 2db39f4..387a6ec 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -3,8 +3,8 @@ pytest>=4.4.0 pre-commit>=2.19 ipytest==0.13.0 pymc>=6.0.0 -bambi>=0.13.0 -arviz_base>=0.5.0 +bambi>=0.18.0 +arviz_base>=1.0.0 ruff==0.15.13 numpyro>=0.17.0 numba>=0.60.0