diff --git a/clpipe/cluster_theory_pred.py b/clpipe/cluster_theory_pred.py index 104b18e..e5ec75b 100644 --- a/clpipe/cluster_theory_pred.py +++ b/clpipe/cluster_theory_pred.py @@ -1,376 +1,434 @@ -from crow import ClusterShearProfile, ClusterAbundance, kernel, mass_proxy -from crow.properties import ClusterProperty -from crow.recipes.binned_grid import GridBinnedClusterRecipe -from crow.recipes.binned_exact import ExactBinnedClusterRecipe -from crow import purity_models, completeness_models +"""Cluster theory predictions from a CLPFirecrown configuration. + +This module builds the same Firecrown likelihood that ``CLPFirecrown`` +writes to its ``likelihood_file`` output (same halo mass function, +mass-richness relation, selection function and CROW recipe), evaluates it +at one point of parameter space and returns the predicted and measured +data vectors. Use it to compare a configuration with the data at the +fiducial point, at a chain best fit, or at any other set of parameters. + +The model options and their defaults come from ``CLPFirecrown`` itself, and +the parameter values follow the same rules as the CosmoSIS values file the +stage writes: the cosmology starts from the fiducial cosmology file, the +``cosmological_parameters`` block (CosmoSIS names) overrides it, and every +``firecrown_parameters`` entry takes its fixed value, or its starting value +when sampled. + +The only difference with a CosmoSIS run is the linear power spectrum. Here +CCL computes it (``boltzmann_camb``), while in the chain it comes from the +CosmoSIS CAMB module, so the predictions can differ slightly from the +chain's. +""" + +import math +import os +from dataclasses import dataclass +from typing import Any, Dict, Mapping, Optional, Tuple, Union + +import numpy as np +import pyccl as ccl import sacc import yaml -import pyccl as ccl -import numpy as np -from typing import Dict, Optional, Tuple, Any -import logging +from crow import ClusterAbundance, ClusterShearProfile, kernel, mass_proxy +from crow import completeness_models, purity_models +from crow.properties import ClusterProperty +from crow.recipes.binned_exact import ExactBinnedClusterRecipe +from crow.recipes.binned_grid import GridBinnedClusterRecipe from firecrown.likelihood import ( - ConstGaussian, - BinnedClusterShearProfile, BinnedClusterNumberCounts, - Likelihood, - NamedParameters, + BinnedClusterShearProfile, + ConstGaussian, ) +from firecrown.modeling_tools import ModelingTools +from firecrown.updatable import ParamsMap +from .clp_firecrown import CLPFirecrown, _CCL_TO_COSMOSIS_COSMO_MAP +_COSMOSIS_TO_CCL_COSMO_MAP = {v: k for k, v in _CCL_TO_COSMOSIS_COSMO_MAP.items()} -logger = logging.getLogger(__name__) +_HALO_MASS_FUNCTIONS = { + "angulo12": ccl.halos.MassFuncAngulo12, + "bocquet16": ccl.halos.MassFuncBocquet16, + "bocquet20": ccl.halos.MassFuncBocquet20, + "despali16": ccl.halos.MassFuncDespali16, + "jenkins01": ccl.halos.MassFuncJenkins01, + "press74": ccl.halos.MassFuncPress74, + "sheth99": ccl.halos.MassFuncSheth99, + "tinker08": ccl.halos.MassFuncTinker08, + "tinker10": ccl.halos.MassFuncTinker10, + "watson13": ccl.halos.MassFuncWatson13, +} -def _load_yaml_config(yml_file: str) -> Dict[str, Any]: - """Load YAML file and return the CLPFirecrown section. +@dataclass +class BinnedPrediction: + """Prediction and measurement of one cluster statistic. - Parameters + All arrays follow the order of the statistic's data vector in the SACC + file, so ``theory[i]``, ``data[i]`` and ``z_edges[i]`` refer to the same + bin. + + Attributes ---------- - yml_file - Path to YAML configuration file. + theory + Predicted data vector. + data + Measured data vector. + covariance + Block of the SACC covariance for this statistic. + z_edges + Redshift bin edges, shape (n, 2). + proxy_edges + log10(richness) bin edges, shape (n, 2). + radius + Radius bin centers, shape (n,). None for the counts statistic. + sacc_indices + Indices of the data points in the SACC file. + """ - Returns - ------- - dict - Parsed configuration dictionary (the CLPFirecrown sub-dictionary). + theory: np.ndarray + data: np.ndarray + covariance: np.ndarray + z_edges: np.ndarray + proxy_edges: np.ndarray + radius: Optional[np.ndarray] + sacc_indices: np.ndarray + + @property + def errors(self) -> np.ndarray: + """Square root of the covariance diagonal.""" + return np.sqrt(np.diag(self.covariance)) + + +@dataclass +class ClusterPredictions: + """Output of :func:`compute_cluster_predictions`. + + Attributes + ---------- + counts + Number counts (and mean log mass, if enabled). None when + ``use_cluster_counts`` is false. + shear + Stacked shear profile (DeltaSigma or reduced shear). None when + ``use_shear_profile`` is false. + chi2 + Chi-squared of the whole likelihood, using the full SACC covariance. + parameters + Parameter values used for the prediction, with CCL names for the + cosmology and Firecrown names for the cluster parameters. """ - with open(yml_file, "r") as f: - cfg = yaml.safe_load(f.read()) - # support configs that wrap settings under a top-level "CLPFirecrown" key - return cfg.get("CLPFirecrown", cfg) - - -def _select_hmf(hmf_key: str, mass_def: str): - """Return a pyccl halo mass function instance from a key.""" - hmf_dict = { - "angulo12": ccl.halos.MassFuncAngulo12, - "bocquet16": ccl.halos.MassFuncBocquet16, - "bocquet20": ccl.halos.MassFuncBocquet20, - "despali16": ccl.halos.MassFuncDespali16, - "jenkins01": ccl.halos.MassFuncJenkins01, - "press74": ccl.halos.MassFuncPress74, - "sheth99": ccl.halos.MassFuncSheth99, - "tinker08": ccl.halos.MassFuncTinker08, - "tinker10": ccl.halos.MassFuncTinker10, - "watson13": ccl.halos.MassFuncWatson13, - } - hmf_cls = hmf_dict.get(hmf_key, ccl.halos.MassFuncBocquet16) - return hmf_cls(mass_def=mass_def) + counts: Optional[BinnedPrediction] + shear: Optional[BinnedPrediction] + chi2: float + parameters: Dict[str, float] -def _build_completeness_and_purity(use_completeness, use_purity): - """Create completeness and purity objects or None according to flags.""" - completeness = completeness_models.CompletenessAguena16() if use_completeness else None - purity = purity_models.PurityAguena16() if use_purity else None - return completeness, purity +def _load_config(config: Union[str, os.PathLike, Mapping[str, Any]]) -> Dict[str, Any]: + """Return the CLPFirecrown options, filling missing ones with the stage defaults. -def _populate_firecrown_parameters(yml_config: Dict[str, Any], set_params: Dict[str, Any]) -> Dict[str, Any]: - """Resolve Firecrown parameters: use sampled values from set_params when requested, otherwise fixed values.""" - firecrown_parameters = {} - for param, value in yml_config.get("firecrown_parameters", {}).items(): - if value.get("sample", False): - if param not in set_params: - raise ValueError(f"Sampled Firecrown parameter '{param}' not provided in set_params") - firecrown_parameters[param] = set_params[param] - else: - firecrown_parameters[param] = float(value.get("values")) - return firecrown_parameters - - -def _build_mass_distribution(use_grid: bool, pivot_log_mass: float, pivot_z: float): - """Return the appropriate mass proxy object depending on whether grid evaluation is chosen.""" - if use_grid: - return mass_proxy.MurataUnbinned(pivot_log_mass=pivot_log_mass, pivot_redshift=pivot_z) - return mass_proxy.MurataBinned(pivot_log_mass=pivot_log_mass, pivot_redshift=pivot_z) - - -def _apply_mass_distribution_parameters(mass_distribution, set_params: Dict[str, Any], firecrown_parameters: Dict[str, Any]): - """Apply runtime-set attributes and firecrown parameters to the mass distribution object.""" - # set any attributes passed in set_params that exist on the object - for k, v in set_params.items(): - if hasattr(mass_distribution, k): - setattr(mass_distribution, k, v) - - # Fill mass-distribution parameter dictionary with defaults from firecrown parameters - mass_distribution.parameters["mu0"] = firecrown_parameters.get("mass_distribution_mu0", 0.0) - mass_distribution.parameters["mu1"] = firecrown_parameters.get("mass_distribution_mu1", 0.0) - mass_distribution.parameters["mu2"] = firecrown_parameters.get("mass_distribution_mu2", 0.0) - mass_distribution.parameters["sigma0"] = firecrown_parameters.get("mass_distribution_sigma0", 0.2) - mass_distribution.parameters["sigma1"] = firecrown_parameters.get("mass_distribution_sigma1", 0.0) - mass_distribution.parameters["sigma2"] = firecrown_parameters.get("mass_distribution_sigma2", 0.0) - - -def _apply_completeness_purity_parameters(completeness, purity, firecrown_parameters): - """Apply firecrown-tuned parameters to completeness and purity objects when present.""" - if completeness is not None: - completeness.parameters["a_n"] = firecrown_parameters.get("completeness_a_n", completeness.parameters["a_n"]) - completeness.parameters["b_n"] = firecrown_parameters.get("completeness_b_n", completeness.parameters["b_n"]) - completeness.parameters["a_logm_piv"] = firecrown_parameters.get("completeness_a_logm_piv", completeness.parameters["a_logm_piv"]) - completeness.parameters["b_logm_piv"] = firecrown_parameters.get("completeness_b_logm_piv", completeness.parameters["b_logm_piv"]) - if purity is not None: - purity.parameters["a_n"] = firecrown_parameters.get("purity_a_n", purity.parameters["a_n"]) - purity.parameters["b_n"] = firecrown_parameters.get("purity_b_n", purity.parameters["b_n"]) - purity.parameters["a_logm_piv"] = firecrown_parameters.get("purity_a_logm_piv", purity.parameters["a_logm_piv"]) - purity.parameters["b_logm_piv"] = firecrown_parameters.get("purity_b_logm_piv", purity.parameters["b_logm_piv"]) - - -def _make_binned_recipe(recipe_cls, cluster_theory, redshift_distribution, mass_distribution, completeness, purity, - mass_interval, true_z_interval, redshift_grid_size, mass_grid_size, proxy_grid_size): - """Construct a binned cluster recipe (GridBinnedClusterRecipe or ExactBinnedClusterRecipe).""" - return recipe_cls( + Parameters + ---------- + config + Path to a pipeline configuration file, or a dictionary. Both may hold + the options under a top-level ``CLPFirecrown`` key. + """ + if isinstance(config, Mapping): + raw = dict(config) + else: + with open(config, "r") as f: + raw = yaml.safe_load(f) + section = raw.get("CLPFirecrown", raw) + + cfg = {name: option.default for name, option in CLPFirecrown.config_options.items()} + cfg.update(section) + return cfg + + +def _config_value(spec: Mapping[str, Any]) -> float: + """Value of a parameter block entry: the starting value when sampled, else the fixed value.""" + values = spec["values"] + if spec.get("sample", False): + return float(values[1]) + return float(values) + + +def _halo_mass_function(cfg: Mapping[str, Any]): + """Return the pyccl halo mass function selected by ``hmf``.""" + hmf_key = cfg["hmf"].lower() + try: + hmf_cls = _HALO_MASS_FUNCTIONS[hmf_key] + except KeyError: + raise ValueError( + f"Unknown halo mass function '{hmf_key}'. " + f"Available options are: {', '.join(sorted(_HALO_MASS_FUNCTIONS))}" + ) from None + return hmf_cls(mass_def=cfg["mass_def"]) + + +def _cluster_recipe(cfg: Mapping[str, Any], cluster_theory, is_reduced_shear: bool = False): + """Build the CROW recipe, as ``get_cluster_recipe`` in the generated likelihood file.""" + completeness = completeness_models.CompletenessAguena16() if cfg["use_completeness"] else None + purity = purity_models.PurityAguena16LnProxy() if cfg["use_purity"] else None + + if is_reduced_shear: + cluster_theory.set_beta_parameters(cfg["beta_parameters"][0], cfg["beta_parameters"][1]) + if cfg["use_beta_interp"]: + cluster_theory.set_beta_s_interp(cfg["min_z"], cfg["max_z"]) + + common = dict( cluster_theory=cluster_theory, - redshift_distribution=redshift_distribution, - mass_distribution=mass_distribution, + redshift_distribution=kernel.SpectroscopicRedshift(), completeness=completeness, purity=purity, - mass_interval=mass_interval, - true_z_interval=true_z_interval, - redshift_grid_size=redshift_grid_size, - mass_grid_size=mass_grid_size, - proxy_grid_size=proxy_grid_size, + mass_interval=(cfg["min_mass"], cfg["max_mass"]), + true_z_interval=(cfg["min_z"], cfg["max_z"]), + ) + if cfg["use_grid"]: + return GridBinnedClusterRecipe( + mass_distribution=mass_proxy.MurataUnbinned( + pivot_log_mass=cfg["pivot_mass"], pivot_redshift=cfg["pivot_z"] + ), + redshift_grid_size=cfg["redshift_grid_size"], + mass_grid_size=cfg["mass_grid_size"], + proxy_grid_size=cfg["proxy_grid_size"], + **common, + ) + return ExactBinnedClusterRecipe( + mass_distribution=mass_proxy.MurataBinned( + pivot_log_mass=cfg["pivot_mass"], pivot_redshift=cfg["pivot_z"] + ), + **common, ) -def _build_shear_profile(cosmo_ccl, hmf, cluster_concentration, is_deltasigma, use_beta_interp, beta_parameters, set_params): - """Construct and configure a ClusterShearProfile object.""" - shear = ClusterShearProfile( - cosmo=cosmo_ccl, - halo_mass_function=hmf, - cluster_concentration=cluster_concentration, - is_delta_sigma=is_deltasigma, - use_beta_s_interp=use_beta_interp, - ) - if "cluster_theory_cluster_concentration" in set_params: - shear.cluster_concentration = set_params["cluster_theory_cluster_concentration"] - if not is_deltasigma: - shear.set_beta_parameters(*beta_parameters) - if use_beta_interp: - # The actual min/max z values will be set later when recipe is built; keep API analogous to old code - # The calling code will set the interpolation domain on the recipe if needed. - pass - return shear - - -def build_cluster_recipes_from_config(yml_file: str, sacc_file: str, set_params: Dict[str, Any], **kwargs - ) -> Tuple[np.ndarray, np.ndarray, Optional[np.ndarray], Optional[np.ndarray]]: - """ - Build cluster counts and (optionally) shear recipes from a YAML configuration and return theory/data vectors. +def build_cluster_likelihood( + config: Union[str, os.PathLike, Mapping[str, Any]], sacc_file: Union[str, os.PathLike] +) -> ConstGaussian: + """Build the Firecrown likelihood that CLPFirecrown writes to ``likelihood_file``. - This function: - - Loads configuration from `yml_file` (supports a top-level CLPFirecrown key). - - Builds a pyccl halo mass function and pyccl Cosmology (via build_ccl_cosmology_from_config). - - Constructs completeness/purity models if requested. - - Configures a mass-proxy model and fills its parameters from the `firecrown_parameters` block - or from runtime `set_params`. - - Builds either GridBinnedClusterRecipe or ExactBinnedClusterRecipe for counts and (optionally) for shear. - - Reads the SACC file and returns theory predictions and data vectors. + The likelihood has read the SACC file but has not been updated with + parameter values yet. Parameters ---------- - yml_file - Path to the YAML configuration. + config + Pipeline configuration file (or dictionary) with a ``CLPFirecrown`` + section, as used to run the stage. sacc_file - Path to the SACC file used for data vectors. - set_params - Dictionary with runtime-supplied sampled parameters (e.g. from Firecrown/Cosmosis). - **kwargs - Currently unused; accepted for forward compatibility. + SACC file with the cluster data vector and covariance + (``clusters_sacc_file_cov``). Returns ------- - tuple - (cluster_counts_theory, cluster_counts_data, cluster_shear_profile_theory, cluster_shear_data) - cluster_shear_profile_theory and cluster_shear_data can be None if shear is not requested. + firecrown.likelihood.ConstGaussian """ - # Load config and resolve parameters - yml_config = _load_yaml_config(yml_file) - logger.debug("Loaded YAML config: %s", yml_config) - - # Basic parameters (with defaults) - hmf_key = yml_config.get("hmf", "bocquet16") - mass_def = str(yml_config.get("mass_def", "200c")) - min_mass = yml_config.get("min_mass", 13.0) - max_mass = yml_config.get("max_mass", 16.0) - min_z = yml_config.get("min_z", 0.2) - max_z = yml_config.get("max_z", 0.8) - pivot_log_mass = yml_config.get("pivot_mass", 14.3) - pivot_z = yml_config.get("pivot_z", 0.6) - survey_name = yml_config.get("survey_name", "numcosmo_simulated_redshift_richness") - - use_shear_profile = yml_config.get("use_shear_profile", False) - use_completeness = yml_config.get("use_completeness", None) - use_purity = yml_config.get("use_purity", None) - use_grid = yml_config.get("use_grid", True) - is_deltasigma = yml_config.get("is_deltasigma", False) - use_beta_interp = yml_config.get("use_beta_interp", False) - redshift_grid_size = yml_config.get("redshift_grid_size", 20) - mass_grid_size = yml_config.get("mass_grid_size", 60) - proxy_grid_size = yml_config.get("proxy_grid_size", 20) - beta_parameters = yml_config.get("beta_parameters", (10.0, 5.0)) - - # Firecrown parameters (sampled or fixed) - firecrown_parameters = _populate_firecrown_parameters(yml_config, set_params) - cluster_concentration = firecrown_parameters.get("cluster_theory_cluster_concentration", None) - - # Build HMF and Cosmology - hmf = _select_hmf(hmf_key, mass_def) - cosmo_ccl = build_ccl_cosmology_from_config(yml_config, set_params) - - # completeness and purity - completeness, purity = _build_completeness_and_purity(use_completeness, use_purity) - - # redshift distribution and abundance (cluster theory) - redshift_distribution = kernel.SpectroscopicRedshift() - abundance = ClusterAbundance(halo_mass_function=hmf, cosmo=cosmo_ccl) - - # mass distribution / proxy - mass_distribution = _build_mass_distribution(use_grid, pivot_log_mass, pivot_z) - _apply_mass_distribution_parameters(mass_distribution, set_params, firecrown_parameters) - - # apply completeness/purity firecrown parameters if present - _apply_completeness_purity_parameters(completeness, purity, firecrown_parameters) - - # choose recipe class based on grid flag - recipe_cls = GridBinnedClusterRecipe if use_grid else ExactBinnedClusterRecipe - - # build counts recipe - counts_recipe = _make_binned_recipe( - recipe_cls=recipe_cls, - cluster_theory=abundance, - redshift_distribution=redshift_distribution, - mass_distribution=mass_distribution, - completeness=completeness, - purity=purity, - mass_interval=(min_mass, max_mass), - true_z_interval=(min_z, max_z), - redshift_grid_size=redshift_grid_size, - mass_grid_size=mass_grid_size, - proxy_grid_size=proxy_grid_size, - ) + cfg = _load_config(config) + if not (cfg["use_cluster_counts"] or cfg["use_shear_profile"]): + raise ValueError("Set use_cluster_counts or use_shear_profile to build a likelihood.") - # Build statistics object for counts and read SACC file + # Same flags CLPFirecrown passes to build_likelihood through the sampler + # file, where reduced shear is used whenever DeltaSigma is not. average_on = ClusterProperty.NONE - if yml_config.get("use_cluster_counts", True): + if cfg["use_cluster_counts"]: average_on |= ClusterProperty.COUNTS - if yml_config.get("use_mean_log_mass", False): + if cfg["use_mean_log_mass"]: average_on |= ClusterProperty.MASS - if yml_config.get("use_mean_deltasigma", False): + if cfg["use_mean_deltasigma"]: average_on |= ClusterProperty.DELTASIGMA - if yml_config.get("use_mean_reduced_shear", False): + else: average_on |= ClusterProperty.SHEAR - counts_statistics = BinnedClusterNumberCounts(average_on, survey_name, counts_recipe) - - sacc_obj = sacc.Sacc.load_fits(sacc_file) - counts_statistics.read(sacc_obj) - - logger.debug("Mass distribution parameters: %s", counts_statistics.cluster_recipe.mass_distribution.parameters) - cluster_counts_theory = counts_statistics.get_binned_cluster_counts() - cluster_counts_data = counts_statistics.data_vector - - # Optionally build shear recipe and statistics - cluster_shear_profile_theory = None - cluster_shear_data = None - if use_shear_profile: - shear = _build_shear_profile( - cosmo_ccl=cosmo_ccl, - hmf=hmf, - cluster_concentration=cluster_concentration, - is_deltasigma=is_deltasigma, - use_beta_interp=use_beta_interp, - beta_parameters=beta_parameters, - set_params=set_params, + # The placeholder cosmology is replaced by the ModelingTools one at + # every evaluation. + statistics = [] + if cfg["use_cluster_counts"]: + abundance = ClusterAbundance( + halo_mass_function=_halo_mass_function(cfg), + cosmo=ccl.CosmologyVanillaLCDM(), ) - - # If beta interpolation requires z range, set after knowing config's min/max - if use_beta_interp and not is_deltasigma: - # ClusterShearProfile API (in previous code) had set_beta_s_interp(min_z, max_z) - try: - shear.set_beta_s_interp(min_z, max_z) - except Exception: - # fall back silently if the method is not available or has different signature - logger.debug("set_beta_s_interp not available or failed; continuing without setting interpolation domain.") - - # build shear recipe (purity intentionally None for shear as before) - shear_recipe = _make_binned_recipe( - recipe_cls=recipe_cls, - cluster_theory=shear, - redshift_distribution=redshift_distribution, - mass_distribution=mass_distribution, - completeness=completeness, - purity=None, - mass_interval=(min_mass, max_mass), - true_z_interval=(min_z, max_z), - redshift_grid_size=redshift_grid_size, - mass_grid_size=mass_grid_size, - proxy_grid_size=proxy_grid_size, + statistics.append( + BinnedClusterNumberCounts(average_on, cfg["survey_name"], _cluster_recipe(cfg, abundance)) ) + if cfg["use_shear_profile"]: + shear_profile = ClusterShearProfile( + cosmo=ccl.CosmologyVanillaLCDM(), + halo_mass_function=_halo_mass_function(cfg), + cluster_concentration=None, + is_delta_sigma=cfg["is_deltasigma"], + use_beta_s_interp=cfg["use_beta_interp"], + two_halo_term=cfg["two_halo_term"], + boost_factor=cfg["boost_factor"], + ) + recipe = _cluster_recipe(cfg, shear_profile, is_reduced_shear=not cfg["is_deltasigma"]) + statistics.append(BinnedClusterShearProfile(average_on, cfg["survey_name"], recipe)) + + likelihood = ConstGaussian(statistics) + likelihood.read(sacc.Sacc.load_fits(str(sacc_file))) + return likelihood + + +def _resolve_parameters( + cfg: Mapping[str, Any], + fiducial_cosmology: Union[str, os.PathLike], + params: Optional[Mapping[str, float]], + cosmology_defaults: Mapping[str, float], + cluster_names, +) -> Dict[str, float]: + """Parameter values for the prediction, as a flat dict for a Firecrown ParamsMap. + + Cosmology: Firecrown defaults < fiducial cosmology file < config + ``cosmological_parameters`` < ``params``. Cluster parameters: config + ``firecrown_parameters`` < ``params``. + """ + cosmology = dict(cosmology_defaults) + with open(fiducial_cosmology, "r") as f: + fiducial = yaml.safe_load(f) + cosmology.update({name: float(fiducial[name]) for name in cosmology if name in fiducial}) + + for name, spec in cfg["cosmological_parameters"].items(): + if name == "tau": + # CAMB input only, it does not enter the cluster prediction + continue + if name not in _COSMOSIS_TO_CCL_COSMO_MAP: + raise ValueError( + f"cosmological_parameters['{name}'] has no CCL equivalent. " + f"Supported names are: {', '.join(sorted(_COSMOSIS_TO_CCL_COSMO_MAP))}" + ) + ccl_name = _COSMOSIS_TO_CCL_COSMO_MAP[name] + value = _config_value(spec) + # Same check as CLPFirecrown.generate_cosmosis_parameters_file + if not spec.get("sample", False) and not math.isclose(value, cosmology[ccl_name], rel_tol=1e-6): + raise ValueError( + f"cosmological_parameters['{name}']={spec['values']} " + f"does not match fiducial value {cosmology[ccl_name]}" + ) + cosmology[ccl_name] = value + + cluster = {name: _config_value(spec) for name, spec in cfg["firecrown_parameters"].items()} + + # Accept CosmoSIS names, optionally with their section prefix as in the + # chain outputs (e.g. cosmological_parameters--omega_c), CCL names and + # Firecrown names. + for name, value in (params or {}).items(): + short = name.split("--")[-1] + if short in _COSMOSIS_TO_CCL_COSMO_MAP: + cosmology[_COSMOSIS_TO_CCL_COSMO_MAP[short]] = float(value) + elif short in cosmology: + cosmology[short] = float(value) + elif short in cluster_names: + cluster[short] = float(value) + elif short != "tau": + raise ValueError(f"Unknown parameter '{name}'") + + missing = sorted(set(cluster_names) - set(cluster)) + if missing: + raise ValueError( + f"No value for {', '.join(missing)}. Add them to firecrown_parameters " + "in the configuration or pass them in params." + ) + return { + **{name: cosmology[name] for name in sorted(cosmology)}, + **{name: cluster[name] for name in sorted(cluster_names)}, + } - shear_statistics = BinnedClusterShearProfile(average_on, survey_name, shear_recipe) - shear_statistics.read(sacc_obj) - cluster_shear_profile_theory = shear_statistics.get_binned_cluster_property(average_on) - cluster_shear_data = shear_statistics.data_vector - - return cluster_counts_theory, cluster_counts_data, cluster_shear_profile_theory, cluster_shear_data +def _binned_prediction(likelihood: ConstGaussian, statistic) -> BinnedPrediction: + bins = statistic.bins + radius = None + if isinstance(statistic, BinnedClusterShearProfile): + radius = np.array([b.radius_center for b in bins]) + return BinnedPrediction( + theory=np.asarray(statistic.get_theory_vector(), dtype=float), + data=np.asarray(statistic.get_data_vector(), dtype=float), + covariance=likelihood.get_cov(statistic), + z_edges=np.array([b.z_edges for b in bins]), + proxy_edges=np.array([b.mass_proxy_edges for b in bins]), + radius=radius, + sacc_indices=np.asarray(statistic.sacc_indices), + ) -def build_ccl_cosmology_from_config(yml_config: Dict[str, Any], set_params: Optional[Dict[str, Any]] = None) -> ccl.Cosmology: - """ - Build a pyccl.Cosmology using config values + runtime sampled parameters. - The configuration is expected to contain a "cosmological_parameters" block where each parameter is either - marked as sampled (sample: true) in which case the value must be present in set_params, or fixed with a - numeric "values" entry. +def compute_cluster_predictions( + config: Union[str, os.PathLike, Mapping[str, Any]], + sacc_file: Union[str, os.PathLike], + fiducial_cosmology: Union[str, os.PathLike], + params: Optional[Mapping[str, float]] = None, +) -> ClusterPredictions: + """Evaluate the CLPFirecrown likelihood at one point and return predictions and data. Parameters ---------- - yml_config - Configuration dictionary (the CLPFirecrown section). - set_params - Runtime-supplied sampled parameters (may be None). + config + Pipeline configuration file (or dictionary) with a ``CLPFirecrown`` + section, as used to run the stage. + sacc_file + SACC file with the cluster data vector and covariance + (``clusters_sacc_file_cov``). + fiducial_cosmology + Fiducial cosmology YAML file (CCL names), the ``fiducial_cosmology`` + input of the stage. + params + Values replacing the configuration ones, for instance a chain best + fit. Keys can be CosmoSIS names (``omega_c``, ``sigma_8``, also with + the ``cosmological_parameters--`` prefix of the chain files), CCL + names (``Omega_c``, ``sigma8``) or Firecrown names + (``mass_distribution_mu0``, also with the + ``firecrown_number_counts--`` prefix). Returns ------- - pyccl.Cosmology + ClusterPredictions """ - if set_params is None: - set_params = {} + cfg = _load_config(config) + likelihood = build_cluster_likelihood(cfg, sacc_file) + tools = ModelingTools() + + values = _resolve_parameters( + cfg, + fiducial_cosmology, + params, + tools.required_parameters().get_default_values(), + list(likelihood.required_parameters().get_params_names()), + ) + params_map = ParamsMap(values) + likelihood.update(params_map) + tools.update(params_map) + tools.prepare() + chi2 = likelihood.compute_chisq(tools) + + counts = shear = None + for guarded in likelihood.statistics: + statistic = guarded.statistic + if isinstance(statistic, BinnedClusterShearProfile): + shear = _binned_prediction(likelihood, statistic) + else: + counts = _binned_prediction(likelihood, statistic) + return ClusterPredictions(counts=counts, shear=shear, chi2=float(chi2), parameters=values) - # Start from a complete default cosmology - cosmo_params = DEFAULT_CCL_PARAMS.copy() - # Extract config cosmological parameters - cosmological_block = yml_config.get("cosmological_parameters", {}) +def build_cluster_recipes_from_config( + yml_file: Union[str, os.PathLike], + sacc_file: Union[str, os.PathLike], + set_params: Optional[Mapping[str, float]] = None, + *, + fiducial_cosmology: Union[str, os.PathLike], +) -> Tuple[np.ndarray, np.ndarray, Optional[np.ndarray], Optional[np.ndarray]]: + """Return theory and data vectors as a tuple (older interface). - for param, spec in cosmological_block.items(): - if spec.get("sample", False): - # sampled → must come from set_params - if param not in set_params: - raise ValueError(f"Sampled cosmological parameter '{param}' not provided in set_params") - cosmo_params[param] = float(set_params[param]) - else: - # fixed → take from config - cosmo_params[param] = float(spec["values"]) - - # Filter only parameters pyccl actually accepts - valid_ccl_params = {k: v for k, v in cosmo_params.items() if k in DEFAULT_CCL_PARAMS} - - return ccl.Cosmology(**valid_ccl_params) - - -# Default CCL parameter dictionary (used as base for building cosmologies) -DEFAULT_CCL_PARAMS = dict( - Omega_c=0.2052, - Omega_b=0.0448, - h=0.71, - n_s=0.963, - sigma8=0.8, - Omega_k=0.0, - Neff=3.044, - m_nu=0.0, - w0=-1.0, - wa=0.0, - T_CMB=2.7255, -) + Same as :func:`compute_cluster_predictions` with ``params=set_params``. + + Returns + ------- + tuple + (cluster_counts_theory, cluster_counts_data, cluster_shear_profile_theory, cluster_shear_data). + The counts or shear entries are None when that statistic is not used. + """ + pred = compute_cluster_predictions(yml_file, sacc_file, fiducial_cosmology, params=set_params) + counts_theory = counts_data = shear_theory = shear_data = None + if pred.counts is not None: + counts_theory, counts_data = pred.counts.theory, pred.counts.data + if pred.shear is not None: + shear_theory, shear_data = pred.shear.theory, pred.shear.data + return counts_theory, counts_data, shear_theory, shear_data diff --git a/tests/test_cluster_theory_pred.py b/tests/test_cluster_theory_pred.py new file mode 100644 index 0000000..081978e --- /dev/null +++ b/tests/test_cluster_theory_pred.py @@ -0,0 +1,172 @@ +"""Tests for clpipe.cluster_theory_pred. + +The main checks generate the likelihood and values files with CLPFirecrown +and verify that cluster_theory_pred builds the same model and uses the same +parameter values, so the two cannot drift apart. +""" +import configparser + +import numpy as np +import pytest + +# The module imports crow and firecrown at import time, so skip the whole +# file when the science stack is not installed (fast CI job). +pytest.importorskip("pyccl") +pytest.importorskip("crow") +pytest.importorskip("firecrown") + +from firecrown.likelihood import NamedParameters, load_likelihood +from firecrown.updatable import ParamsMap + +from clpipe.cluster_theory_pred import ( + build_cluster_recipes_from_config, + compute_cluster_predictions, +) +from .test_clp_firecrown import ( + COSMOLOGICAL_PARAMETERS, + FIRECROWN_PARAMETERS, + _base_firecrown_config, + _make_stage, +) + + +def _generated_theory(tmp_path, sacc_path, fiducial_cosmology_path, cfg, parameters, monkeypatch): + """Theory vector and chi2 of the likelihood file written by CLPFirecrown.""" + stage = _make_stage(tmp_path, sacc_path, fiducial_cosmology_path, cfg) + likelihood_path = tmp_path / "likelihood_file.py" + assert stage.generate_python_file(str(likelihood_path)) + + # Same build parameters as the [firecrown_likelihood] section of the + # sampler file. The generated file opens the SACC file by basename. + build_parameters = NamedParameters( + { + "use_cluster_counts": cfg["use_cluster_counts"], + "use_mean_deltasigma": cfg["use_mean_deltasigma"], + "use_mean_reduced_shear": not cfg["use_mean_deltasigma"], + "use_mean_log_mass": cfg["use_mean_log_mass"], + } + ) + monkeypatch.chdir(sacc_path.parent) + likelihood, tools = load_likelihood(str(likelihood_path), build_parameters) + + params_map = ParamsMap(parameters) + likelihood.update(params_map) + tools.update(params_map) + tools.prepare() + chi2 = likelihood.compute_chisq(tools) + return likelihood.get_theory_vector(), chi2 + + +@pytest.mark.slow +@pytest.mark.parametrize( + "overrides", + [ + {}, + {"use_shear_profile": False}, + {"use_purity": False, "use_completeness": False}, + {"hmf": "tinker08", "mass_grid_size": 40}, + ], + ids=["counts_deltasigma", "counts_only", "no_selection", "tinker08"], +) +def test_prediction_matches_generated_likelihood( + tmp_path, mock_fiducial_cosmology, mock_cluster_sacc_dense, monkeypatch, overrides +): + cfg = _base_firecrown_config(**overrides) + pred = compute_cluster_predictions(cfg, mock_cluster_sacc_dense, mock_fiducial_cosmology) + + expected, expected_chi2 = _generated_theory( + tmp_path, mock_cluster_sacc_dense, mock_fiducial_cosmology, cfg, pred.parameters, monkeypatch + ) + theory = [pred.counts.theory] + if pred.shear is not None: + theory.append(pred.shear.theory) + np.testing.assert_allclose(np.concatenate(theory), expected, rtol=1e-12) + assert pred.chi2 == pytest.approx(expected_chi2, rel=1e-12) + assert (pred.shear is None) == (not cfg["use_shear_profile"]) + + +def test_parameters_match_values_file(tmp_path, mock_fiducial_cosmology, mock_cluster_sacc_dense): + """The values CLPFirecrown writes for CosmoSIS are the ones used here.""" + cosmological_parameters = dict(COSMOLOGICAL_PARAMETERS) + cosmological_parameters["sigma_8"] = {"sample": True, "values": [0.6, 0.83, 1.0]} + cfg = _base_firecrown_config(cosmological_parameters=cosmological_parameters) + + pred = compute_cluster_predictions(cfg, mock_cluster_sacc_dense, mock_fiducial_cosmology) + + stage = _make_stage(tmp_path, mock_cluster_sacc_dense, mock_fiducial_cosmology, cfg) + values_path = tmp_path / "priors_file.ini" + assert stage.generate_cosmosis_parameters_file(str(values_path)) + values = configparser.ConfigParser() + values.read(values_path) + + def start_value(raw): + fields = raw.split() + return float(fields[1] if len(fields) == 3 else fields[0]) + + ccl_names = {"omega_c": "Omega_c", "omega_b": "Omega_b", "h0": "h", "n_s": "n_s", + "sigma_8": "sigma8", "omega_k": "Omega_k", "w": "w0", "wa": "wa"} + for name, ccl_name in ccl_names.items(): + assert pred.parameters[ccl_name] == pytest.approx( + start_value(values["cosmological_parameters"][name]) + ), name + assert pred.parameters["sigma8"] == pytest.approx(0.83) + for name in FIRECROWN_PARAMETERS: + assert pred.parameters[name] == pytest.approx( + start_value(values["firecrown_number_counts"][name]) + ), name + + +@pytest.mark.slow +def test_params_override_config_values(mock_fiducial_cosmology, mock_cluster_sacc_dense): + cfg = _base_firecrown_config(use_shear_profile=False) + base = compute_cluster_predictions(cfg, mock_cluster_sacc_dense, mock_fiducial_cosmology) + pred = compute_cluster_predictions( + cfg, + mock_cluster_sacc_dense, + mock_fiducial_cosmology, + params={ + "cosmological_parameters--sigma_8": 0.85, + "Omega_c": 0.25, + "firecrown_number_counts--mass_distribution_mu0": 3.5, + }, + ) + assert pred.parameters["sigma8"] == 0.85 + assert pred.parameters["Omega_c"] == 0.25 + assert pred.parameters["mass_distribution_mu0"] == 3.5 + assert not np.allclose(pred.counts.theory, base.counts.theory) + + +def test_unknown_parameter_raises(mock_fiducial_cosmology, mock_cluster_sacc_dense): + with pytest.raises(ValueError, match="Unknown parameter 'not_a_parameter'"): + compute_cluster_predictions( + _base_firecrown_config(), + mock_cluster_sacc_dense, + mock_fiducial_cosmology, + params={"not_a_parameter": 1.0}, + ) + + +def test_missing_cluster_parameter_raises(mock_fiducial_cosmology, mock_cluster_sacc_dense): + firecrown_parameters = dict(FIRECROWN_PARAMETERS) + firecrown_parameters.pop("purity_a_n") + cfg = _base_firecrown_config(firecrown_parameters=firecrown_parameters) + with pytest.raises(ValueError, match="purity_a_n"): + compute_cluster_predictions(cfg, mock_cluster_sacc_dense, mock_fiducial_cosmology) + + +def test_fixed_cosmology_mismatch_raises(mock_fiducial_cosmology, mock_cluster_sacc_dense): + cosmological_parameters = dict(COSMOLOGICAL_PARAMETERS) + cosmological_parameters["omega_c"] = {"sample": False, "values": 0.30} + cfg = _base_firecrown_config(cosmological_parameters=cosmological_parameters) + with pytest.raises(ValueError, match="does not match fiducial value"): + compute_cluster_predictions(cfg, mock_cluster_sacc_dense, mock_fiducial_cosmology) + + +@pytest.mark.slow +def test_tuple_interface(mock_fiducial_cosmology, mock_cluster_sacc_dense): + cfg = _base_firecrown_config(use_shear_profile=False) + counts_theory, counts_data, shear_theory, shear_data = build_cluster_recipes_from_config( + cfg, mock_cluster_sacc_dense, fiducial_cosmology=mock_fiducial_cosmology + ) + assert len(counts_theory) == len(counts_data) == 4 + assert shear_theory is None and shear_data is None diff --git a/tutorials/theory_prediction_tutorial/fiducial_cosmology.yml b/tutorials/theory_prediction_tutorial/fiducial_cosmology.yml new file mode 100644 index 0000000..b7339ce --- /dev/null +++ b/tutorials/theory_prediction_tutorial/fiducial_cosmology.yml @@ -0,0 +1,32 @@ +Omega_c: 2.199999e-01 +Omega_b: 4.48e-02 +Omega_m: 2.647887e-01 +Omega_k: 0.000000e+00 +k_sign: 0 +w0: -1.000000e+00 +wa: 0.000000e+00 +H0: 7.100000e+01 +h: 7.100000e-01 +Neff: 3.046000e+00 +N_nu_mass: 0 +N_nu_rel: 3.046000e+00 +sum_nu_masses: 0.000000e+00 +Omega_n_mass: 0.000000e+00 +Omega_n_rel: 3.391021e-05 +A_s: nan +n_s: 9.630000e-01 +Omega_g: 4.901957e-05 +T_CMB: 2.725000e+00 +bcm_log10Mc: 1.407918e+01 +bcm_etab: 5.000000e-01 +bcm_ks: 5.500000e+01 +mu_0: 0.000000e+00 +sigma_0: 0.000000e+00 +sigma8: 8.000000e-01 +Omega_l: 7.351283e-01 +z_star: nan +has_mgrowth: 0 +nz_mgrowth: 0 +c1_mg: 1.0 +c2_mg: 1.0 +lambda_mg: 0.0 \ No newline at end of file diff --git a/tutorials/theory_prediction_tutorial/theory_prediction_tutorial.ipynb b/tutorials/theory_prediction_tutorial/theory_prediction_tutorial.ipynb new file mode 100644 index 0000000..564fd23 --- /dev/null +++ b/tutorials/theory_prediction_tutorial/theory_prediction_tutorial.ipynb @@ -0,0 +1,599 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9b64f031", + "metadata": {}, + "source": [ + "# Cluster Theory Prediction Tutorial\n", + "\n", + "## 1. Introduction\n", + "`clpipe.cluster_theory_pred` computes the cluster observables predicted by a CLPipe configuration and compares them with the measured data vector.\n", + "\n", + "It builds the same Firecrown likelihood that the `CLPFirecrown` stage writes to `likelihood_file.py` (halo mass function, mass-richness relation, completeness and purity, CROW recipe and grid sizes) and evaluates it at one point of parameter space. The predictions are therefore the ones the chain computes at that point.\n", + "\n", + "Use it to check a configuration against the data before launching a chain, to plot the model at the best fit of a chain, or to see how a modelling choice (halo mass function, selection function) changes the prediction.\n", + "\n", + "In this tutorial we use the cosmoDC2 redMaPPer baseline analysis (number counts and stacked $\\Delta\\Sigma$) in `examples/cosmodc2_redmapper/baseline/cosmodc2_redmapper_full_analysis/run_in2p3_both`.\n", + "\n", + "## 2. Requirements\n", + "- The `firecrown_clp` kernel (see `tutorials/README.md`).\n", + "- The example data, downloaded into `CLPipe/data/` with the `wget` command of the main `README.md`. We use\n", + " - `data/cosmodc2_redmapper/sacc/full_both_cov.sacc`: data vector and covariance of the baseline run (the `clusters_sacc_file_cov` file),\n", + " - `data/cosmodc2_redmapper/chains/bestfit_full_both.txt`: best fit of the counts + lensing chain, written by `examples/cosmodc2_redmapper/plot_samples.ipynb`." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "a9cca3a5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-09T07:45:36.405210Z", + "iopub.status.busy": "2026-10-09T07:45:36.405042Z", + "iopub.status.idle": "2026-10-09T07:45:38.535777Z", + "shell.execute_reply": "2026-10-09T07:45:38.534994Z" + } + }, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append(\"../../\") # not needed if CLPipe is installed with `pip install -e .`\n", + "import warnings\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.ticker as mticker\n", + "import numpy as np\n", + "import yaml\n", + "\n", + "from clpipe.cluster_theory_pred import compute_cluster_predictions\n", + "\n", + "# CROW warns when the shear profile is created without a concentration. The\n", + "# value in firecrown_parameters is set before every evaluation, as in the chain.\n", + "warnings.filterwarnings(\"ignore\", message=\"The concentration value\")\n", + "\n", + "RUN_DIR = \"../../examples/cosmodc2_redmapper/baseline/cosmodc2_redmapper_full_analysis/run_in2p3_both\"\n", + "CONFIG = f\"{RUN_DIR}/config_in2p3_both.yml\"\n", + "SACC_FILE = \"../../data/cosmodc2_redmapper/sacc/full_both_cov.sacc\"\n", + "BESTFIT_FILE = \"../../data/cosmodc2_redmapper/chains/bestfit_full_both.txt\"\n", + "FIDUCIAL_COSMOLOGY = \"fiducial_cosmology.yml\"" + ] + }, + { + "cell_type": "markdown", + "id": "bd1367d6", + "metadata": {}, + "source": [ + "## 3. Inputs\n", + "`compute_cluster_predictions` takes the same inputs as the `CLPFirecrown` stage:\n", + "\n", + "1. **Configuration file**, the one used to run the pipeline. Only its `CLPFirecrown` section is read, and options missing from it take the stage defaults.\n", + "2. **SACC file** with the data vector and its covariance (`clusters_sacc_file_cov`).\n", + "3. **Fiducial cosmology** (`fiducial_cosmology`). The file in this folder is a copy of the cosmoDC2 one used at CC-IN2P3, `/sps/lsst/groups/clusters/cl_pipeline_project/TXPipe_data/cosmodc2/fiducial_cosmology.yml`.\n", + "\n", + "The model options and parameter blocks of the baseline configuration:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "50493397", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-09T07:45:38.537947Z", + "iopub.status.busy": "2026-10-09T07:45:38.537776Z", + "iopub.status.idle": "2026-10-09T07:45:38.553181Z", + "shell.execute_reply": "2026-10-09T07:45:38.552421Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hmf despali16\n", + "mass_def 200c\n", + "min_mass 12.0\n", + "max_mass 15.5\n", + "use_completeness True\n", + "use_purity False\n", + "use_grid True\n", + "is_deltasigma True\n", + "\n", + "cosmological_parameters (CosmoSIS names, on top of the fiducial cosmology)\n", + " omega_c {'sample': True, 'values': [0.1, 0.22, 0.5]}\n", + " sigma_8 {'sample': True, 'values': [0.5, 0.8, 1.1]}\n", + "\n", + "firecrown_parameters\n", + " mass_distribution_mu0 {'sample': True, 'values': [2.0, 3.3439, 10.0]}\n", + " mass_distribution_mu1 {'sample': True, 'values': [0.5, 0.958236982, 2.0]}\n", + " mass_distribution_mu2 {'sample': True, 'values': [-2.0, -0.0192802, 2.0]}\n", + " mass_distribution_sigma0 {'sample': True, 'values': [0.1, 0.562317194, 2.0]}\n", + " mass_distribution_sigma1 {'sample': True, 'values': [-0.6, 0.04552506, 0.3]}\n", + " mass_distribution_sigma2 {'sample': True, 'values': [-0.5, -0.0445, 2.0]}\n", + " completeness_a_n {'sample': False, 'values': 1.1321}\n", + " completeness_b_n {'sample': False, 'values': 0.7751}\n", + " completeness_a_logm_piv {'sample': False, 'values': 13.31}\n", + " completeness_b_logm_piv {'sample': False, 'values': 0.2025}\n", + " cluster_theory_cluster_concentration {'sample': False, 'values': 3.8}\n" + ] + } + ], + "source": [ + "cfg = yaml.safe_load(open(CONFIG))[\"CLPFirecrown\"]\n", + "for key in [\"hmf\", \"mass_def\", \"min_mass\", \"max_mass\", \"use_completeness\", \"use_purity\", \"use_grid\", \"is_deltasigma\"]:\n", + " print(f\"{key:18s} {cfg[key]}\")\n", + "\n", + "print(\"\\ncosmological_parameters (CosmoSIS names, on top of the fiducial cosmology)\")\n", + "for name, spec in cfg[\"cosmological_parameters\"].items():\n", + " print(f\" {name:38s} {spec}\")\n", + "print(\"\\nfirecrown_parameters\")\n", + "for name, spec in cfg[\"firecrown_parameters\"].items():\n", + " print(f\" {name:38s} {spec}\")" + ] + }, + { + "cell_type": "markdown", + "id": "f920fb94", + "metadata": {}, + "source": [ + "## 4. Prediction at the starting point of the chain\n", + "Without the `params` argument, the parameter values are the ones `CLPFirecrown` writes to `priors_file.ini`:\n", + "- the cosmology comes from the fiducial file, with the `cosmological_parameters` entries on top of it,\n", + "- a fixed parameter takes its value, and a sampled parameter its starting value (the middle entry of `values`)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ca888535", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-09T07:45:38.555283Z", + "iopub.status.busy": "2026-10-09T07:45:38.555020Z", + "iopub.status.idle": "2026-10-09T07:45:40.388416Z", + "shell.execute_reply": "2026-10-09T07:45:40.387621Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "chi2 = 246.2 for 192 data points\n", + "\n", + "Neff 3.046\n", + "Omega_b 0.0448\n", + "Omega_c 0.22\n", + "Omega_k 0.0\n", + "T_CMB 2.725\n", + "h 0.71\n", + "m_nu []\n", + "n_s 0.963\n", + "sigma8 0.8\n", + "w0 -1.0\n", + "wa 0.0\n", + "cluster_theory_cluster_concentration 3.8\n", + "completeness_a_logm_piv 13.31\n", + "completeness_a_n 1.1321\n", + "completeness_b_logm_piv 0.2025\n", + "completeness_b_n 0.7751\n", + "mass_distribution_mu0 3.3439\n", + "mass_distribution_mu1 0.958236982\n", + "mass_distribution_mu2 -0.0192802\n", + "mass_distribution_sigma0 0.562317194\n", + "mass_distribution_sigma1 0.04552506\n", + "mass_distribution_sigma2 -0.0445\n" + ] + } + ], + "source": [ + "fid = compute_cluster_predictions(CONFIG, SACC_FILE, FIDUCIAL_COSMOLOGY)\n", + "\n", + "n_data = len(fid.counts.data) + len(fid.shear.data)\n", + "print(f\"chi2 = {fid.chi2:.1f} for {n_data} data points\\n\")\n", + "for name, value in fid.parameters.items():\n", + " print(f\"{name:38s} {value}\")" + ] + }, + { + "cell_type": "markdown", + "id": "4f1fe7d5", + "metadata": {}, + "source": [ + "The result has four attributes:\n", + "- `counts` and `shear`: one `BinnedPrediction` per statistic (None when the statistic is switched off in the configuration). Each holds `theory`, `data`, `covariance`, `errors`, `z_edges`, `proxy_edges` ($\\log_{10}$ richness), `radius` (shear only) and `sacc_indices`, all in the order of the SACC data vector.\n", + "- `chi2`: chi-squared of the whole likelihood with the full covariance.\n", + "- `parameters`: the values used, with CCL names for the cosmology and Firecrown names for the cluster parameters.\n", + "\n", + "The first counts bins:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "012ea324", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-09T07:45:40.390133Z", + "iopub.status.busy": "2026-10-09T07:45:40.389966Z", + "iopub.status.idle": "2026-10-09T07:45:40.394243Z", + "shell.execute_reply": "2026-10-09T07:45:40.393583Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " z bin richness bin data theory error\n", + "0.2 - 0.3 20 - 35 142 140.8 14.1\n", + "0.3 - 0.4 20 - 35 255 219.1 17.2\n", + "0.4 - 0.5 20 - 35 305 281.7 19.0\n", + "0.5 - 0.6 20 - 35 362 320.5 19.8\n", + "0.6 - 0.7 20 - 35 377 333.9 19.8\n", + "0.7 - 0.8 20 - 35 312 325.2 19.3\n" + ] + } + ], + "source": [ + "c = fid.counts\n", + "print(f\"{'z bin':>11s} {'richness bin':>14s} {'data':>7s} {'theory':>8s} {'error':>6s}\")\n", + "for i in range(6):\n", + " (z0, z1), (l0, l1) = c.z_edges[i], 10 ** c.proxy_edges[i]\n", + " print(f\"{z0:.1f} - {z1:.1f} {l0:6.0f} - {l1:5.0f} {c.data[i]:7.0f} {c.theory[i]:8.1f} {c.errors[i]:6.1f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "afe2f4e4", + "metadata": {}, + "source": [ + "## 5. Prediction at the chain best fit\n", + "The `params` argument replaces configuration values. Its keys can be\n", + "- CosmoSIS names (`omega_c`, `sigma_8`), as in the configuration,\n", + "- CCL names (`Omega_c`, `sigma8`),\n", + "- Firecrown names (`mass_distribution_mu0`).\n", + "\n", + "Names with the section prefix of the CosmoSIS chain files (`cosmological_parameters--omega_c`, `firecrown_number_counts--mass_distribution_mu0`) also work, so a row of a chain can be passed directly. The best-fit file below uses LaTeX labels, so we map them to the configuration names first." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "33c3a9b0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-09T07:45:40.395836Z", + "iopub.status.busy": "2026-10-09T07:45:40.395650Z", + "iopub.status.idle": "2026-10-09T07:45:42.163799Z", + "shell.execute_reply": "2026-10-09T07:45:42.162667Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "omega_c 0.2154\n", + "sigma_8 0.7959\n", + "mass_distribution_mu0 3.3970\n", + "mass_distribution_mu1 0.9015\n", + "mass_distribution_mu2 -0.3906\n", + "mass_distribution_sigma0 0.5233\n", + "mass_distribution_sigma1 0.0554\n", + "mass_distribution_sigma2 0.4670\n" + ] + } + ], + "source": [ + "LATEX_TO_PARAMETER = {\n", + " r\"\\Omega_c\": \"omega_c\",\n", + " r\"\\sigma_8\": \"sigma_8\",\n", + " r\"\\mu_0\": \"mass_distribution_mu0\",\n", + " r\"\\mu_m\": \"mass_distribution_mu1\",\n", + " r\"\\mu_z\": \"mass_distribution_mu2\",\n", + " r\"\\sigma_0\": \"mass_distribution_sigma0\",\n", + " r\"\\sigma_m\": \"mass_distribution_sigma1\",\n", + " r\"\\sigma_z\": \"mass_distribution_sigma2\",\n", + "}\n", + "\n", + "bestfit = {}\n", + "with open(BESTFIT_FILE) as f:\n", + " for line in f:\n", + " if line.startswith(\"#\") or not line.strip():\n", + " continue\n", + " label, best_value, _mean = line.split()\n", + " bestfit[LATEX_TO_PARAMETER[label]] = float(best_value)\n", + "\n", + "for name, value in bestfit.items():\n", + " print(f\"{name:26s} {value:.4f}\")\n", + "\n", + "best = compute_cluster_predictions(CONFIG, SACC_FILE, FIDUCIAL_COSMOLOGY, params=bestfit)" + ] + }, + { + "cell_type": "markdown", + "id": "484a7f9d", + "metadata": {}, + "source": [ + "Chi-squared of each statistic (with its own covariance block) and of the whole likelihood:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f8ea27da", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-09T07:45:42.166667Z", + "iopub.status.busy": "2026-10-09T07:45:42.166343Z", + "iopub.status.idle": "2026-10-09T07:45:42.347917Z", + "shell.execute_reply": "2026-10-09T07:45:42.347331Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " counts DeltaSigma total\n", + "data points 24 168 192\n", + "starting point 34.6 211.6 246.2\n", + "best fit 24.0 206.8 230.8\n" + ] + } + ], + "source": [ + "def block_chi2(prediction):\n", + " residual = prediction.data - prediction.theory\n", + " return residual @ np.linalg.solve(prediction.covariance, residual)\n", + "\n", + "print(f\"{'':16s} {'counts':>8s} {'DeltaSigma':>11s} {'total':>8s}\")\n", + "print(f\"{'data points':16s} {len(fid.counts.data):8d} {len(fid.shear.data):11d} {n_data:8d}\")\n", + "for label, prediction in [(\"starting point\", fid), (\"best fit\", best)]:\n", + " print(f\"{label:16s} {block_chi2(prediction.counts):8.1f} {block_chi2(prediction.shear):11.1f} {prediction.chi2:8.1f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "0d250615", + "metadata": {}, + "source": [ + "## 6. Number counts\n", + "Measured counts with their errors (square root of the covariance diagonal) and the two predictions, in each redshift bin." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "30d3be16", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-09T07:45:42.352887Z", + "iopub.status.busy": "2026-10-09T07:45:42.352549Z", + "iopub.status.idle": "2026-10-09T07:45:44.026312Z", + "shell.execute_reply": "2026-10-09T07:45:44.025542Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABQoAAAKyCAYAAACdY+POAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjIsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvgI3uAAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Qd4k1UXB/B/070nLXSw9957y94CghvEgYgDwYE4QD8FF4oDEHGLGxCQqaAgU/beo6WM0lK698j3nBsSOqEtaUbz/z3PhSRNk7dv2ty85z33HDutVqsFERERERERERER2TSNuTeAiIiIiIiIiIiIzI+BQiIiIiIiIiIiImKgkIiIiIiIiIiIiBgoJCIiIiIiIiIiIgYKiYiIiIiIiIiIiIFCIiIiIiIiIiIiUtjMhIiIiIiIiIiIiBgoJCIiIiIiIiIiIgYKiYiIiIiIiIiICIAD9wJR2SQnJ2PBggU4dOgQKlWqhAcffBBNmjS55ffFx8fjp59+wv79++Hu7o6uXbti2LBhFeZluHz5MhYuXIizZ8+iatWqeOSRR9T/NxMREYEXX3xRXbazs0PlypXRsWNHjBgxAhoNKyQQEWVlZeHrr7/Gjh071NwxatQodOnS5ZY7ZuLEiYiNjVWXvb290bBhQzz00EPw8vKqEDs1ISEBn3/+OY4cOYLAwECMHTtW/Yyl8ccff+CHH35At27dMGHChHLbViIia6HVavHLL79gw4YNsLe3x8CBAzF48OBSPcb58+fV53uZez777DNUBJmZmfjyyy+xa9cueHp6YvTo0eqY5VZmzJiB48ePF7r9+++/h6OjYzltLVHZ8QicqAwSExPRvn17/PbbbyrQJ5NG69atsXbt2pt+3/bt2xEWFqYOSFq2bKkCjI899hgGDBiAnJwcq38tzp07h+bNm2P37t3o3r07Tp48iaZNm6oDuJuRDxASLJUhH0L8/f3Vwe2gQYOQm5trsu0nIrJEMj/0798fs2fPRrt27eDn54fevXuX6MCrb9++hvdXeT9etGgR6tWrh8jISFi7uLg4tG3bFsuXL1dBPjmBJ3Pr33//XaqTW+PGjVPBwv/++69ct5eIyFrI++Kzzz6rkiBq1aqFBx54AC+99FKpAo1yUmrlypVYtmwZKsoJu169euHTTz9Vx4ESKOzRo4c6iXcr69evV3OWfj7WDwnCElkkLRGV2quvvqr19/fXJiQkGG57+OGHtdWrV9fm5OQU+32///679sUXX9Tm5uYabtu8ebNW/hQXL15cplciNjZWO3/+fO358+e15e3s2bPat99+u9iv33XXXdqmTZvm2wedO3fW9unTp9TP9ddff6n9sm7dujJvLxFRRfDtt99q7e3ttadPnzbcNmvWLK2Hh4f22rVrpXqspKQkNX899dRTZdqW5ORk7aJFi7R79uzRlreoqCjthx9+qI2Pjy/y688//7w2KChIbZPefffdp61Xr16Jn6N///7aJ598Un3PmDFjjLLdRETWbNOmTeoz+MaNGw23/fTTT1qNRqM9fvx4iR5jzpw52kaNGmknTJig3qfLKiMjQ7ts2TLthg0btOVN5povvvhCe+rUqSK/vmDBAq2jo2O+Y67p06drvb291dx6M506ddJOnDjR6NtMVF6YUUhUBosXL1aZb3mXbt1///0IDw/Hnj17iv2+nj174u2331bLa/UkG0KcOXOmxM+fkZGBpUuX4s4770SVKlXw+uuvIzs7u8j7yjK1u+++u9C45557kJqaesvnkrNfssRalrjJGUVZNl3cNklGxr333ptvufB9992nzqLJkuvS0C/jrghZL0REtzvndOjQQb0H551zJIPuVpnsBXl4eKBGjRqlem+VjMa//vpLldiQ0hBPPvkkUlJSis0sL2rOkSFfuxV5XMm679evH0JCQjBnzhyVmVLcfpF5UJZi590vJ06cUGVBbkXmtqNHj2LWrFm3vC8Rka2Q99bQ0FCVqa0n5YCcnZ3V8cetyHvwK6+8opboOjk5lWkbtm3bhieeeEId58ixRUxMTJH3k3mwuDln586dJcoSXLFiBe666y41v0nWpKwUK26/yD6R1WF55xwpgSFzJFFFwkAhUSnJhCITYIMGDfLdrr9++PDhYr+3qJpQ+iVSt6qpJAdKmzdvVkuVZSKTdH4fHx+V0n/hwgV14FcUX1/ffCnud9xxhzqwlDoZbm5uRX6PTJC///47hg8frp7rzTffVMvdJAgqtRWLcvr0aaSnpxe5X2T58LFjx1Aa8kFEPlzIEmYiIlsmQa+C761yECdBv5vNOUWRkhDyPbIk+Vbk/X7KlCnqoGjIkCHq5NK3336LqKioYusjyoFk3jlHSkjIAd+mTZtUDcHiApF//vmnCkQGBQVh0qRJak7buHGjCi7KXFdUQFG+Vpa5WEgd3eeee07VN5T9SERExc85UkdPTlbd6r1VEhdkmbIcr8ixQ2mcOnUK06dPV88jATl5j5eTRVeuXFG1AIubPwou55VjjlWrVhU75+jLQUmZIwlESlKDPgh66dKlYo/Jitovsq1yvFKSuViSN+T4Tea47777rtgkDyJLwGYmRGWoTyiBL6mrl5f+QObatWslfizJsnvqqafQuHFjlT1RFDlL9d5776m6UnJwJnWqpFmIHHy5uLjc8jmkFpUMIQXt5Xlq165dZBaKBPvef/99/Prrr4azh+vWrVOTdd4syOJ+FnE7+2X+/PnqwFCKH8tELc+dN4OGiMgWyftrwfdW/ftrSd5bpfbehx9+qB5HLv/vf//D448/XuR95cBFaiFKgXU5oST1l9566y01H5SkAUpwcLDK5BBy8kiyNKQGk5wUy5v5J2ROk/lNMtVlrhs6dCh+/vlnFcS8VXH325lzZA4fM2YMRo4ciT59+tzyZyIisiXy/irHCmWZc2bOnKmON2SeKSmpt/vNN9+oDEAJLkptRAkMSi33W5E5QD/nyHu7NKSSBAppwlK9evVCJ5j0x1RyrCFzjdQblBNhxSVP3GouluMjmRtvtV/kmK1+/frq55O5b+rUqeqYS7azJD8nkakxUEhUSvpltQWbbOibkTg4lOzPSpbqSsaeTDpbtmwp9vskeCcHaZLxIGfVJOOiJJNZQRcvXlTF72UykiXCRR3wSWBOlmJVq1YNc+fOVUHFkhbZNcZ+kSL08iFEJvgvvvgCr776qipSL4X7iYhslby/FtXYSd5fS/LeKkt4JctCSknIe7oEAqVLY1GdGuVASg5gJFAnmR2yzFgy00srKSlJHXzJAZFkw0sGZEGSpf7BBx+oBlaS2SdBxZIuU7udOUd+fplbZbkZEREZZ87Zu3evOmaRZITSHKvIcl85WSTzzbRp09RqprKs+JJjJEk4kAx2ScIoSI4vpFyTq6urChg+/PDDpcoov525WE6CBQQEGK6PHTtWbaNsjwQriSwNlx4TlZKcSZIJJjo6Ot/t+uslmdwkY2PUqFFqQpXgnD7jryitWrVSZ9gkVV0O2mRZlqT0r1mzpsQp61L/sHPnzmopl0zexWWFSIbJ6tWr1cGjbJ8c2MlZvV27dt3yOSR1X9zOfpGzbFI78fnnn1dLAg4cOKDOthER2TJ5fy343ioHK1evXi3Re6u8l0vGhWRayHKsZs2aFZtRKHOcLNuS9+GvvvpKPb4EGSXTPC0trUTbK9kkUuZCMvD//fffIoOEYsCAAeqATk6ayQGiPNejjz6qDvRu1fFeDrjkwKwsc86SJUtU8FP2h76WlWSxy7bI5YiIiBL9nEREtjLnCLntZu+tcvJFAoSSdKB/b5XjFQkCyuXiTs7I530JMEp2nZzYksQG6SQs31cSMjfJPCVLeyX5oqggoZDjLTn2kvf+d955Rx1TyXGHJFBIoLEs+0XKNUnSx63m4rxBQiElPeTYbOvWrSX6GYlMjYFCotL+0Wg0aNOmTaECufrr+uYkt1ryJMuwZPKULLpbkef7+OOPVVagnJGSAKEsA5MlXnJwJUG14kjNDJmIZLuWLVumgpzFkUwTWdr8448/qnog0nhFvr99+/aoW7cuZsyYoepbFUWyEGXCLWq/eHp6FqrpcSuSRSgfFkpS/J6IqCKTkygF31ulfqAc2JS2BpS+WdTN3ltleZQctEkdPynQLnWexo8fr97jZf6SeoL6zL2CJODWtWtXVe9J5rmbLamSJVtyX8kmlMxDKashBetlOVjVqlVVsHLfvn1Ffq9kPMr8WdScI48r82ZxpO7ua6+9lq+mlcxT8pxyuahl3kREtkLmFQne5W3qISemZE642Zwj5RykjFDe91YpIaSvXVunTp0iv0/eeyWr8MiRIyo5QeYofWahPKbUTZeVWEWRE1KyAkrmNAkS3qpkUYsWLVRWuTT0kseVE07SLEWeS06gycmt4hpoFTUX7969W92/LHOxbHtZVokRmUS59VMmqsC+//57rYODg3bPnj3qekZGhrZ9+/baXr165bvfm2++qX3xxRfz3TZ+/Hitm5ubdtOmTbe1DYmJidqvv/5ae8cdd2g1Go12//79he6zY8cOrZ+fn/aRRx7R5uTklPm5Ll68qH3vvfe0TZs21bq4uBR7v5dfflnr7++vvXTpkroeGxurDQ0N1T755JOF9sGnn35quL5+/XptREREvvusXbtW/VwLFiwo83YTEVUE27Ztk6MW7dKlS9X13Nxc7ejRo7W1a9fWZmVlGe4n75fjxo0zXD979qz2n3/+yfdY8v5cvXp17eDBg0u1Denp6drFixdrhw0bpnVyclKXCzpz5oy2Ro0a2n79+mlTUlK0ZSVzx7x587QdO3ZUP3dUVFSR91u4cKHalkOHDqnraWlp2pYtW2oHDRqU737Tp0/XvvLKKzd9znr16mnHjBlT5m0mIqoowsPDtc7OztoPPvjAcNvzzz+v9fX11cbFxRlukzlJ5qKbvd8/88wz2qCgoFJvQ3Z2tjoWuO+++7Tu7u7a999/v9B9YmJitK1atVLv+3K5rJKTk9WxXd++fbX29vbaLVu2FHk/mU9lTlq9erW6LsdWMic2bNgw33GWHOPIsY7e6dOntRs3bsz3WDKH2tnZ5dvHRJbETv4xTUiSqGJ5+umn1bKsnj17qmVaUldJlvVKKrler1691Bk4fafg3377TS3pldT35s2bF1qCJbU1ykIyDSUbouCSYtkWWQImdaLykpT8V155pUzPJT9rcdmBcrZPzvxJ6n+nTp3UWTfJTJGlBnlrgMhZO9k3UkxYyNk7aeoi+1CyCOUsn2QuSjcyKYqsr0VFRGSrJANC6rZKcynJvpPlT9L1XrIj9B555BEsXrzY0OhD7jNu3DhVj0+ywpOTk9X7sywLluy9stSBElK0XbIZJcMwL2l8Iu/n0pQkb61BySr85JNPyvRcksEi84JkpBQkH2ElA0SaochzSwa8zDUyF+vLYQjJqpdMfPnZiyNzlWTPS0F9IiJbJ++rUgpCViTJ5/ujR48amk3lzc6WeUnq3xbVnV5Ih1/5Ppm3ykpq58rxjGQe5iVlmeQ9W1ZD5T0GkhVS0lW4pHXW85LtlPmruProclwiP3f37t1VzUOZb6VsU97lzvfffz/Wr19v+Jnlf6lJGB4eruZiOW6T46lnnnlGZe/zOIcsEQOFRLdBDr4OHTqk6k5IXb+CE5LUWZLJVT+pygFPwZR1PQke5j3gu12yxFkCk0WdC5BahWVJkS8pWa4gP6sEKlu3bl3o69KgRA4w5aAs7/bKvpRJVA4qZcItSYdNIiJbIct6ZZmTLFWS4Jd0UcxLlmzJiRap+ZeX1NyTIJqUnpCDlOJqBt4uOSmUmppa6HZ5T5fgZHmRE0uyZE2WSMu8UnAulrpXMhfKCariyIGeNFUpz7mRiMiaSHBOyhvJe6rMOZKUkJcEDw8ePKjKIRXXqV7KR0iHYTmBZGzy3i7lKgqSObJgkoQxyTwrtQ5lf0hiRMETWXJSSko4FfyZ5dhI9pkEVRs2bMhmjWTRGCgkIiIiIiIiIiIiNjMhIiIiIiIiIiIiBgqJiIiIiIiIiIiIgUIiIiIiIiIiIiJioJCIiIiIiIiIiIgUje4/IiIiIiIiIiIismUMFBIREREREREREREcbH0f5Obm4tKlS/D09ISdnZ25N4eIiIxAq9UiKSkJwcHB0Ggs55wY5xwiooqHcw4REVWkecfmA4USJAwLCzP6jiUiIvOLjIxEaGgoLAXnHCKiiotzDhERVYR5x2YDhXPnzlUjOztbXT906JDKKrRlEpEu731QXs9him23hu3ha2i8/WBpv1NU+tevSZMmFvMacs4pjO9XxsM5x7z7jHMOcc6xfJxzrGtfmut5reFYlXMOmWLesdNKzqINS0xMhLe3NxISEuDl5QVbFhcXB19fX6t8DlNsuzVsD19D4+0HS/udoorx3m6p22UOfL+yrn1prue1hs8NnHPIUt/bLXW7zIHvV9a1L831vJxzyFoklvP7u+UUbiIiIiIiIiIiIiKzYaCQiIiIiIiIiIiIGCgkIiIiIiIiIiIiBgqJiIiIiIiIiIiIgUIiIiIiIiIiIiJioJCIiIiIiIiIiIgUNjMhIiIiIiIiIiIiBgqJiIiIiIiIiIgIcOBOICJrdvnyZTXySkxMhJeXl7pcpUoVNYiIiIiIiIjo5hgoJCKrtmDBArz++uvFfn369OmYMWOGSbblxIkTqFy5Mry9vU3yfERERERERETGZLOBwrlz56qRk5OjrsfFxRku2yrJwrLW5zDFtlvD9tjiazh69Gh0794daWlpGDBggLpt8eLF8Pf3V5eDgoLU37cptqdHjx4qMDlq1KhSBReDg4Ph6elZ6ucj63lP4JxTmC2+X5UXzjnm3WfGeCxL+50i6379OOcUxjnHeDjnmHefcc4hU/wd2mygcOLEiWrIDpbsH19fX8NSRVsm+8Fan8MU224N22Nrr6F8T4MGDfK9Webm5qJLly6wt7c36fZoNBq4u7uX6vt69eqFRYsWYdiwYWXYQirO7b72xsY5p2i29n5VnjjnmHefGeOxLO13ikqOc4514JxjXfvSXM9rDZ8bOOeQfTkf67DrMRFZvaVLl6Jp06aG65LRV7t2bXV7ecrOzsaZM2dUNmNRTp06hcOHD+Po0aOIj48v9PWTJ0+qoOb58+fV/SS7sCTfR0RERERERFQeGCgkIqsmwcCRI0eqQOH27duRlJSk/m/SpIm6vbyChdu2bUP16tXRtm1bhIaG4qGHHkJWVla++0yZMgV333232o6wsDCV5ShBQb2nnnoKGRkZmD17trrf+PHjS/R9REREREREROWBgUIislpSV1SCaoMGDcKyZcvQvn17eHh4qP/lutz+3HPPGb3+aGZmJu699161XPjq1auIjo5Wt8n/ea1YscKQGShfk1qEzzzzjOHr69atg6urKz766CN1v40bN5bo+4iIiIiIiIjKAwOFRGS1Nm/ejPDwcEybNk3VB8xLrr/00ks4d+6cup8x/fnnn7h8+TJmzpwJOzs7VSPivffeK3Z5cmRkJM6ePYt+/fph/fr1JXqOsn4fERERERERUVnZbDMTIrJ+EqwTjRs3LvLr+tv19zMWqUsoy43zNkCSrL+ChYUlePjWW2/BxcUFfn5+KuswOTlZNV65WfOksn4fERERERER0e1gRiERWa0qVaqo/2WZblH0t+vvZyxubm5FNjDJe9uuXbtUpuPq1asRFRWllhF//vnn6mvSwKQ4Zf0+IiIiIiIiotvFQCERWS1p8iENRWQJcMEgmlyfNWsWatSooe5nTC1atFBBvOPHj+drbpKenm64Lh2Mg4KC0LFjR8NtGzZsKPRYkjWYtwlKSb+PiIiIiIiIyNi49JiIrJbUBpSOwdIdWBqLSE1CWW4smYQSJFy5ciUWL16s7mdMrVu3VnUDR48ejXfffVfVE3z22WfzPY90Q5ZGJBLE7NWrFzZt2oQ5c+YUeqwGDRrg999/R506dVRjk5J+HxEREVFFJ+VjZEhjun379qkmcgEBAeqkrXzuklUjxl45QkRk65hRSERWbfjw4SoYePDgQZWFJzX85H8JFsrt8vXy8NNPP6F79+54+eWX8cUXX6jOxXLdx8dHfb1u3bqq87IE+iZMmKC27/vvv0ejRo3yBRTnzZuHjIwMjBs3DuPHjy/x9xERERFVdAsWLECrVq3UZzv5nCSfu+R/uS63y9eJiMi4mFFIRFZPgoGSfeft7a2u//rrr+q28gysyXNJcDCv/v3757s+YMAANQpua15NmjTBkiVLSv19RERERBVdWFgY7Ozs0K9ff7z88jTDyhFZeSErR+TrRERkXAwUElGFWJKSt5GIh4cHDhw4oC5zSQoRERGR9ZHlxm+++SYGDRqkVltoNLrFcO3bt1fXpezMW2+9hbFjx3LVBRGREXHpMRFViCUpnTt3Ntwm2XhyG5ekEBEREVmnzZs3Izw8HNOmTTMECfXkutSmPnfuHH5f84/ZtpGIqCKy2YzCuXPnqiFnqkRcXJzhsq1KTEy02ucwxbZbw/bY4msoDUWkNmBeKSkpcHd3V5elg7D8fZtqe8gyWNrrxzmnMFt8vyovnHPMu8+M8ViW9jtF1v36VZQ55/Tp0+p/WW5cFP3tzy7cj/VXamJ4Sze0quYEjZ1doftyzjEezjnm3Wecc8gUf4c2GyicOHGiGrKDpdaYr6+vaoJg62Q/WOtzmGLbrWF7bO01lO+RzsF5yQdiY2yjpf1OUclZWuMXzjlFs7X3q/LEOce8+4xzjm3jnFM+ateurf6XmoSy3LgguV3tf/dK2Hw6Q43qAU4Y3c4Xw1p5w8s1/2cBzjnGwznHvPuMcw7Zl/OxDpceExERERERkUXp0qWLalYijUtyc3PzfU2uz5w5CwGVw1C9UTvD7eFXM/HOqivoOesUpi+9jOOX082w5URE1o2BQiIiIiIiIrK4jJkOHTrgjz/+wJAhQ7B9+3YkJSWp/4cOHYqVK/9Az64d8NfUevjwvhC0relm+N60LC0W74rHiI/P4f7PwvHn0TRkZmvN+vMQEVkLm116TERERGXvNC71rvbt24erV68iICAALVq0UAd17DRORETGMmfOHLRp00b937Fjx3xLLyV4KEuS9+/djW5Nm6JP42o4fSUDv/wXh+V7E5CSoctC3BeRpsbcjckY0cYHo9r6ooqPI18kIqJiMFBIREREpeo0/vrrr8PBwQHZ2dk3PlBcvz59+nTMmDGDe5SIiG6bnHx67rnn8Oyzz6ouyBcuXEBmZqaab06dOoWLFy/il19+wbJlyzBhwgTUDg3Fy0MqY1LfSvhjXyJ+2hGngociNjkHn/8Tiy82xqJHAw/c08EP7Wu5wa6I5idERLaMgUIiIiIqMakXJQdV/fv3x7Rp01TXSSkoLzWkVq5cqb5ORERkTJKx3r1793y3xcfHY/fu3di1axfS0tJQuXJlw9dir1zE4Cb+GN2uBvaEp+HbTVfw76l0ZOcCuVpgw9FkNWpU0jU/GdqycPMTIiJbxUAhEVEZVK9eHd98802hD62mJh+SJ02ahK1bt0Kj0eDo0aOoVq0afvvtN1XXh8iYZLnxm2++iUGDBqnsDfmdE7L0S64PGzYMb731FsaOHWtxXUCJiKhi8fHxQa9evdCzZ09cu3ZNZbbrG50sWrQICQkJaNSoEdq2bYsZgyshxzEUi3fG49ed8YhJ0mXEn4vJxNsrr+CjddEY1MIb97T3Rb0qLmb+yYiIzIvNTIiIykCWvqSnl28nvXr16mHdunU3vc97772ngoOrVq3CP//8A61Wq5bhZGRklOpxiEpCln2Fh4erTEJ9kFBPrr/00ks4d+6cuh8REZEpyPwjtXL1kpOT4ebmpk5uHTx4EF988QXmzp2Lvds2YHQLDf56sTY+uDcEbQo0P/ltZzyGX29+smp/ApufEJHNYkYhEZGFkoCfLKW5mUOHDqFz586oW7eu4bbIyEhUqlSpVI9DVBLSxETIcuOi6G/X34+IiMjUvLy81GqLS5cuYefOndi7dy8SExOxfv16NQYOHIi+PXqgbxMvVb9Q6hiu2JuA1Mz8zU/8V13BSGl+0s4Xlb3Z/ISIbAczComIyigiIgL33HMPGjZsiC5dumDDhg35vp6VlaXqtrVq1QoNGjTA6NGjceLEiXz3kQLcXbt2VVl/smxzz5496nZZNpyamopHHnkEoaGhaNmyZaHnb9q0Kf78808sXLhQ3Uc/ZBmofCgu6eMQlaaovJCahEXR366/HxERkbkEBwerz1avvvoq7rzzTnVSVWrsSokWPV+HZIxrnYON02rjlSFBqBXoZPiaND9Z8E8s+rx7Gs8suoAdp1PUyg0iooqOGYVERGUkZ6s//PBDvPLKKyrgN2DAABw4cAD169dXX7/vvvsQFRWl7hMYGIiffvpJBe6OHTuGoKAg7NixQ9Vy++qrr9CmTRsVRJw6dSr++usv/P7776hVqxbeeecd9O3bt8h6b7Kc+N5771VBRtkGIctspH6ifulxSR6HqKQkIC7NSt56ayaWL79Ro1BfE+qtmbPgExgGt9BW6mCKnSSJiMjcHB0d1UndTp06IS4uTtU21Nu0aRO2bduGkJAQVcvwp8ea48gV4OcdcVh/JAk5uVBDLsuoWckJd7f3xZCW3vB04WcqIqqYGCgkIosz6tNzuHq9yHRZSMBCo7la6u8L8HTAr0/WKPH9x40bh8cff1xdfuONN1Rdtvfff1/VwpHMQAnSSaDQ399f3ef1119XQcBvv/0WL7zwgsq+krPakpUoateurTrJCuncJ0EW+V7JBCyKZG05OzvDw8PDcJ/s7Pz7rSSPQ1RSEmiWYPevv/6KIUOG4OWXXzZ0PZYg4apVKxE6bA4e+vKCysoY1VZ3MMVOkkREZAl8fX0LfWaUuU3KtMjntj/++ANNmjTBhLZt8cKAWliyO0HVLtQ3Pzkbk4mZf1zBh+uiMbi5N+7p4Iu6ldn8hIgqFgYKicjiSJDwSmLZA4U6ujoz5UlqAxbMtlq7dq26LGenJaNKlh3rl6nI/1evXjXUcZNOfc8//7yqlTNy5EjccccdqFq1arlvN9HtmDNnjsqAlf87duxouN03MBS1R34Ip1q91fUz0ZmYtVJ3MNW/qZcKGjYJc2GWIRERWQz5/CUnaaVki9QzlBq7+/btU0NWaDz55JN4rEcANhxJUlmGu86lqu9Ly9Sq7skyWlV3VVmGrUO4LJmIKgYGConI4khm3+3QZRRqyv15nZycCl3XL/mVjshy1nrLli2Fvs/d3V39Lx9Ajx8/rpYtL1++HE899RT69euHn3/+GQ4OfHsmyySZrM899xyeffZZlUUrB1VymwTKs3Pt8NfhJPy6Mw57wnUNdNKztPh9T4Ia9as4q6Lwg5p7mfvHICIiMnwukzlMTgBfuHBBBQwlUFijhm6ViaO9Hfo09kCo5jzsB9bAb7sS8ce+REPzE5nvZPi7a3BXuxyMauuDIDY/ISIrxiNRIrI4pVn+WxSpP1NwaUl5kI7DI0aMMFyX+oR16tRRlxs1aqSyB6WRSN6OxAVJrcKnn35aDflwKsFDWZ4sZ7dlKYwximYb63GICv5etWvXDhs3blS1n+S6lMAc1MJbDekk+dvOOCzfm4CkdN3B1PHLGXhjWRTeXx2NXg2c8WBXVzQI5pItIiIyPynVInV4ZQwePDhfORepI/3NN9+ooKKsFrlvXBv8d8lZdUw+G52p7hObkovP/r6KhRuvomdDT9zT3hdta7oxk56IrA4DhUREZTR37lzVRa9Zs2ZYvXo1li1bZlh6LI1D5PYxY8aoDEGpRZiQkKDqE0oQUZYZf//99yq4Io/h6uqqAoWSDVmpUiX1GFJYu2CX5LIw1uMQFXTw4EHV7VuGHFi1bt0azZs3VwdStYOc8dLgypjUNxBrDyXi1//icDAyXX2fZGGsOJCGFQfOoXGoC0a380W/pl5wcyp9JjAREZGxySqRvCtHZKWIl5cXEhMT8e+//6oh89609u2Q7VMPS/am4G9pfqLVNT+R7HoZNQOdcHc7Xwxt6Q0PNj8hIivBT+RERGX0wAMPYNiwYeqD41133aUamkgAUEgAULoSSwMR6Urs5+enlrCcO3dOnYkW3bt3x5o1a1RWYUBAgDp7PXv2bBVsEdIoYubMmaohScuWLcv8OhnrcYgKkiY5kk0oS/0jIyNVIXj5O/j6669Vxq1kY7g6aXBnKx/89EQNLH6qBka388kXEDx8IR2vLrmMHjNP4a0VUTgVpQsmEhERWYoWLVqoz1PSyE5qTevnvSVLFmP1d+/itf5uWPx4JUzoGYAAzxvdkCXbUJqfdJ91Cm8su8w5joisgp3WxtejyVkhb29vlekjB/u2zBTLNcvrOUy11NTSt4evofH2w60eQ7rjSXBPug7L+4eLi4u6XJTMzEz1XiP3L0pOTo76elHPJxmGsoRZ7iN14AqSrzk6Oqr3MT3JTJSsxLzbc6vHqWgs9b3dUrfrdiUlJWH//v3YvXu3+tvQL+F65ZVX8v1u6qVk5OC3bVFYeTgDxy7p6nrm1aKaq2p+0reJJ5wdy35Ok3NO+eKcY7z9YGmfY6hivLdb6naZg7H/xmTe27Nnj6pnKEHDKVOmID4+Xj3HwcPHcDrZF8sPZmD39eYnebWu4aaWJd/RyFPVPzT1tt8uHueYd59xziFTvL9z6TERURmX8+oVFQjJS5auFBck1GcfFvfhQT58BgYGFvu9RT2uZDGW9nGIboenp6cqBC9DmpvIwZMcROX921iyZIm6LlmtkmE7tLkbxnQPxqEL6aqW4eoDiarxidgXkabG2yvtMayVN+5q64MalYoOxBMREZlj3pOVId26dUNycrKhDqE0tfvlp0XIyspCt/r1MXpAW+y86oeV+xNVp2QhwUMZknl4VxtfNcex+QkRWRIGComIiMhoJGN10KBB+W6Ts507duxQTXWkjmetWrXQoEEDtG/fHk3DXNV4fkAQ/tiXgF93xqtGKOr70nLw7ZZrakhBeOmYfEdDTzg53DoDg4iIqLxJgFCChnmzfGQeDA8Px9GjR9WQr7/Yog1iXRth1ZFsnI3RNT+5mpSD+X9fxecbr6q57W42PyEiC+Fgy00IZMgyPH0Kr/6yrZKJzVqfwxTbbg3bw9fQePvB0n6nyLpfP1ufcySzQoKHUrdQDp7OnDmjhgQN69evr+pySpbugAZ26F/fB4cuZmH5/lT8cyIdmdd3086zqWr4umkwoIkrhjRzRYjPzT/GcM4pX5xzjLcfLO09i6z79bP1Ocec71eyBPC+++5T5V4OHDig5j3JsP9vy98A/sak/gOg9W+IpftSseVUhqH5yZ+Hk9So7u+AO1u4ol8jV7g7ayzy94vHOebdZ5xzyBR/h6xRyNodBqw1ZDys3WHefcbaHWSp7+2Wul2mJH+fe/fuVXWdYmNj1W3SDKhdu3aGepqyVF7Ep2Rj2d4E/LYzHuFXdRkYeXWs466ao3SrX3SdJ9YoLP/XkrWNOeeQ5b63W+p2mYO53q8kQHvs2DH8999/OHHiBKZOnarKb4h9x89j5aEM/HVSi9jk/IFcafo1pKW3qmXo75TKGoWcc4z6u2xpdS+p9FijkIiIiCoM+WAq3cGlg6TUdZJ6hk2bNjV8fevWraopinQHl/uM7eKPMZ39VDahBAz/OpKI7OvHU9tOpahRydMBI9r4qBHs42i+H46IiKhAHWrpkiwjNTUVbm5uhq/t3foXEo4dw4DAynBo2gl7rwXiwAXdSbHUzFz8vCNOjeZhjniwiz16NixZ8xMiottls0uPiYiIyLx1napWrapGXtI9WTony1i5ciXq1aunlia3bNgQ7WqFIDY5CL/vicdv/8XjQlyW+p6YpGx8JnWe/rmKLvU8VJZh57oeZvrJiIiICssbJJSavR4eHnB0dMTV6CggeglCNRq0qNUaF52aYMs5O6Rdb/C1PzIL+3+8qE6KSeMTGYFePClGROWHgUIiIiKyGOPGjVPBQskqjIyMVEu2ZLi4uKgsw2HDhuGRbgEY18Uf206nqCzDf44lqRpPuVpg0/FkNar4OGBgYxfc38UDlXhARUREFnaybPTo0RgyZIia86Qch8x5V07thAN2YlzdxvBqNAQ//xeHc9ebn8hJsXkbdCfF7mjkqZYlt67hZui4TERkLAwUEhERkcVwd3dHp06d1IiOjlZLk2XEx8erOlv6AyKNxg5NgnLQ+f5QXEnIwpLd8ViyKx5RCdnq65fjs/HFlmR8ve00ejTwVFmG7Wu5q+8jIiKyBK6urujQoYMaly9fVgFDmfOaN66Ljh39cF9HX6zeFYlfdyZi7yV7dUIsOxdYdyhJjdpBzri7nY+qZ+jubG/uH4eIKggGComIiMgiBQYGon///ujbty/Onj0LZ2dnw9eko+Tbb7+NGjVqqEzDhzo2w2PdA7D5ZLJalvzvyWRor3eTXH8kSY0wP0fc1dYXw1p5w9+DH4GIiMhyVKlSBUOHDsXAgQPV0mQhJ8ecE0+iUvha9Hb2Q3rlLjgQXwnxabqvn76SgTdXXMGH62IwpIU37m7vq4KHRES3Q9dWkIiIrMrTTz+tzjhbC2vbXrIs0gW5du3aCAsLM9x27tw5dQAl/y9evBivv/46fv7pB1TGBXzyQDD+fL42xnRwR4DnjQyLyGtZ+GBtNHq+fQrP/XQRO8+mGA7GiIiILIGDg4OqXZj3ujQC02Rcg9v55WiX+BW6e+5HLV9dnV6RkpGLn3bEYeicsxi7MALrDiUiK4fzGxGVDQOFRERG9uSTT6p6M+X5eN99950KkFiLsmyvsfcjVSxt2rTBK6+8ojIvgoKCkJ2drX5fvvzyS7z55pvQpkbj0S6eWP9iHcy5LwQda7sbvle6Jq85mIiHFp7H4A/P4tstsYhPvd5KmYiIyII0a9YML730Eh577DE0b94cTg4auF7bg7rR36E7VmJ4S0+4Ot4oq7HrbCom/3gRfd49jXkbYhCTeCOgSERUElx3U4Gcic5QBzotq7myqC2RGX3zzTfo1auX+jBXXo/3ySefqE6w1qIs22vs/UgVj7e3N3r06IHu3burLsmStbp3715kZWWpZcvJyclwtLdDXc84vD/SB/FZlbF4VzyW7YnHtRRdYFCKxL+7Khpz1sWgXxMvjGrng+ZVOY8SEZFlZdbXrVtXjdTUVDXXST1DHx8fjLsrFM8PysHyvQn4ZuNlRCXrcoGiE7Mxd/1VLPj7KnpJ85MOfmhVnfMbEd0aA4UVyFf/xmLZngTUqOSEEa11RW1Zg4mofJw/fx6LFi3ClStX0KBBAzz44INwc3PD1KlTkZGRgblz52LlypUqkDF79my8+uqrqki1fNALDg5WWVCSEZXX+PHjMXHiRNXtVT4A9unTB9u2bSvy8Xbt2oWGDRuievXq+b738OHDKlgiS1QeeeQRVK5c2fD4ssTyxx9/xI4dO9QSzlGjRmHevHkYPnw42rdvX+TPKY/7xBNPqEytAwcOwN/fX53RrlSpUr77rVu3To3c3Fz07NlTdfHLq7TbW9x+JCqKLEEODQ1VY9CgQervUr9sS37vf/75Z1XTUA6werRqhfGTG+HfU+n4dWe8yrwQmdlarNiXoEadIGcVMBzcwhueLiwOT0RElkM+b3bu3FkN+awkvFztMbABsP/3rxGrCcE1z9Y4m+YPrdZONT9ZeyhJDZnfpI7h4BZebH5CRMXi0uMKQIIPW/7bi9X74w3ZEe+viUaPmScxdu5hrNhxHrnSIouIjCIiIgJNmzbFiRMnUKdOHRw5ckRlNIkWLVrA3t4e9erVU8E3abKgXzYi1yWrTrKc7rjjDhW0y0uWTErjhr/++guNGjVSQY/iHq/gUl75Xgk+rl27FlWrVsXGjRvRtm1bddY5b53Ap556SgX5kpKS0LVrV3z66ac4ffp0sT+rfpuWLVuGkJAQrFmzRgU4pQOtniz/vOuuu1S3Wgn4jR07Vj1PXqXd3uJ+bqJbkd8bCcbrpaWlqd9NCRjK36z83c166w0kn1iHV3tmY/mk6niwkx+8XG98JDp1JQNvrbiCHjNP4bUll3D4Qhp3PBERWZy8Tb7S09NRu1YtBOReRN2E5eiW+QvqaY7A3SE73/z2v+VR6DHrNN5aEaVWpBERFcSMwgpgwYIFeOPNmfCo2wduwY3h4B4AB/dKcAtrhV0X7LHrQgo+2XQGd7b2xp2tfFDF50ZxXCJLpT9DWhTJystb5LngfTMzMw233eq+RX3QupX169erznTffvut4bYLFy6o/0ePHo2HH35YLZkdNmyY4esjR47M9xj169fHjBkzcO+99+a7Xb4v7+O2bNmyyMcrimTxSQaeePTRR9XSS8nyu/POO1UwcP78+fjzzz9Vxp+QJb0Ft6soEuT8/fffDcFGyaD88MMPVfMICf69++67WLp0qcrkEt26dVPPIdsgAdWybG9x+5GoLJkXUu9SMgole1UyduPi4tSSLRmSkfHisGF4pm8lVfxdsgz3R+gCg2lZWizZnaBGw2AXlWU4oJk3XwQiIrI4cpJswoQJar6TlRwy37km7EA17MQVu+pIq9wdJ6/aGZqf/Lg9To22Nd1wTwdf9GzgCQf7G7UOich2MVBYAcgSPg8PD3XgfunYKsPtbn6h8Ov2PLzq9cal+CxVo2LehqvoXMcdI9r4oHsDT1W7icgSvfzyy8V+TYJsskxVTwJuUpOsKDVr1lRLZ/VmzpyJlJSUQvd7//33S7xtEig7e/asqrsngTYJGkr2383Ic/700084duwYEhMTER0djTNnzqjtzhvIlOy9spKgWt7giCwv1gcwZQmzLN/VBwmFBOCkk96tSLagnmyrBPI2bdqkrm/duhUuLi6GIKGQ7Er5sLp58+abBgpvtr1ExhYQEIC+ffuid+/eCA8PV0FDWU4vS+KFi6MGHUIzUSn9Etz7NsSKg+n4Y1+COpgSRy+lY8bvUXhvdTR6N3DGA11dUb+KC18oIiKyuPlOPk/KnCeZ9HJSTD5zvvxkLZyN1aruyH/sjUfm9R5eO8+mqhHk5YC72vpgZFtfVPJkmIDIlvEdoALYvn07XnjhBXWgvmTJEjRu3FjV/ZKAyMplk9Dwifm45NUVsvpYqwU2n0xRw9/DHkNb+mBEa29Ur1TybCoiW9exY0f89ttv+OyzzzBt2jS1dPbZZ5/NF7zMS5b5ypJj+eA2ePBgtZxWli+vWLFCBRClELVe3sul5erqWmgJZk6O7lNgTEwM/Pz8Cn29JM8ndQnzkp9DAp1C/i/4df19pE5cWbeXqLxIlrGcQJAhwXL5vdOT+p3//vsv7O2XqwDivKGtcDajChbvTsSRi+nqPhI4XLY/Dcv2n0OzMFeVZdivqZcKNBIREVnSfCcnt2XoT0w3CAZev7MynE79jH2xPrjo2BhJuR7q/lcSs/Hp+qv47O+r6N3YC/e090XLEjQ/kTJYMuQz3L59+1RGo3wO1JeRkRPqMojIejBQaOXkDXnKlCkqSCg1xGRCEFLTS67LQdDh1e/g311j8Mf+JCzdnaCyC0Vsco5qgCKjdQ039GvoiDvbefNghyzCW2+9VezX9L/neTMK85L6efoAWMH7SmDPGGTZrAz54LV48WK1hFiW8kpAsOAHqg0bNqhAndQy1GfwyfeU1K0+oJWEZDzKh7js7GzDNkg9wNjY2Ft+b2RkZL7rEuSU7D8h/8vjynJvJycndZs0NJHvkQDq7TDGz010M3mzeYU005Fs2EuXLuHQoUNqSLbrPS1awLtDC2yKcMKqA4lIy9TV/T0QmabGOyuvqAZio9r5olYgT7wREZHlznfyWbBezVCkJe5H9YwjuGoXgvOaBojRVIUWuuYnaw4mqlG3srMKGA5s7g13Z02xZbCkHI18vpTH1tNfnz59eqHP6kRk2Xj628rJ0j5ZQiXBj4IBEbn+0ksvqRpipw/twIQ7KmHd87Xw+UNh6NtEalDcuO/uc6l4c1UCus88hTeXR+HYJV3mBJG5SM3A4kbBg/uCX5eAVUnvqx+lIcttL168qC7L4w8YMEB9GNIH3SRz79q1a4b7SxMF+aCkb9QhxabnzJlT4ucr+HhlIc1TJPD29ddfG26T+oCybbeycOFCw7ZLUPCXX35Ry4/1jyuZgdI9WU+eQ37G21lGbayfm6g0pKHO5MmT1ZBam56enup3X/7m//3jG7w2NAgbX6qDKb291MGTXmJ6LhZti8OQD89izOcRWLk/AZlypEVERGRh5LOrlJV57bXXcPfo0Whb3QmtctajW9avqJmzH255mp+cjMrA68ui0HPWKcxcEYWzRTQ/kZPG8hlTPvfJSjdZSSP/y3W5XX9ymYisBzMKrZwctAtZblwU/e36+2k0duhU10ONa8nZWLEvAUt2xeNsTKb6elJ6rqpbIaNRiIuqZTiwmRc8XPJEFYlsnGQR9ujRQ2XpSfbRli1bVO0/uU1IJq90ApYljLIsV7Ija9eurRqTSCDiv//+U0sySqrg482ePbvU2yzPJ3UYJ06cqBqTSOBSshy9vLzyLb0simRnSq1B2X7ZBmluIo1G9ME8aZIybtw4rF69WgVM//nnH3z88ceqS/LtMMbPTVQW8nctQ04CnDp1StUzlI7e8rfiYQ8Ma+4Kp0sb4digIfZdC8CfR1KQka01nHiT8fZKewxr6Y272vqiWoAu25aIiMhSyInyNm3aqCGlZKSWocx3w0c2R3hmMH7eEYf953XNvZIzcvHD9jg1WlVzwgOd7dGjgSfskIs333zzpqvb5HPw2LFjb/l5k4gsBwOFVk5f70FqEsobckFyu5A6aHmXBgo/DweM7eKPMZ39sC8iDT9tjcbfJ9KRnqU72JF6TEcuRuG9VVfQt6kXRrT2QYtqt65TQVTRSbOOgwcPqrOlUVFRmDRpklpyrPfRRx+pJieSzSuBM2n2IcFB6ZYsdVukXEC1atXUByhZ1qj3+eefFxn0L/h4Qhqp5H3Oor73jTfeUPUQ8zY+kmCmfBCUs7utWrVSwY+iagzmJZnJ1atXV40fpDuxZBHmzWC+++671T6RBieSoSjbUrC5S1m2t6ifm8iU5KBGmifJKLj8fv/+fQD2qXn1yQbNEe/ZDP+cdTCceItLycHXm6+p0b6Wm1qW3LMhm4gREZHlCQwMVME+fRZgE40Gg1t4Y8HPf2LpvlRc1tRCzvXQwZ6ITOyJuIjK3g5o5nRUrW6Thn3FrW6T2t6yCk4+KxKRdbDTlmTdWQUm3UelE2hCQoLKrLHGGoWSqdSkSZN8Z3H0dcKGDh2qlkzJWRwJSEh2jgQtihIXFwcHVy+sPpCosgz1hdvzqlnJSWUZDmnhrQKNpSXPIYEJYyuvx7W27THF81rDa2iMx7K03ylj2LVrl6qjqF+OLVl/8gFO6rHJ+2BRJEC3cuVK9OvXD9bEUt/bLXW7zMGa36/Onz+PkydPYvfu3Sr4r+fl5Q3f2h1xOrsmNp3MQFZO/o9Y0kRMTrqNbOuDEF/jZRlyzjHvPuOcQ5b63m6p22UO1jznmPMzqZwUl5Udl2IScEFTR9UyTLW78Zkx4egqXFzxvFpu7OGha4qSl9wuv3s//vgj7rnnntvaFr6GxtsPFfE4x9YklvP7O1M0KkC2gyzHk6wbSe2Wg3591+NZs2Zh1apVqn6h1BCTJYJ5g4RyZkeWBkqmkD7A6Olij9HtfNWQOoUSMJRaS7IkWUimxHuro/Hhumjc0dBTHfB0qO2uljQTkWWTM77SdEWWEEtwUDrTSWZfcUFCIiqa1C7s1auXyq6V7EJZqrV//34kJiYgce8aTH7qKUwfXhvL9ibg1//iEHntRhOxzzfGYuGmWHSu466yDLvW84CDPedQIiKyPB06dFCr1mR1h6xI2X9gOS5nB6qAYbQmDA7ulUq0uo1dj4msCwOFFcDw4cNVB1Upvi6p3Xo1atRQt8vXJXFU34xAf3ZnxYoV6napPyZZRrVq1VKX9UuLGwS74JWhlTGlfyD+OpyEJbvjVd0lkZ0DrDuUpEawjyOGt/bGna19UNk7f+MIIrIcUrha3iN27NihTh7I0uOgoKCbfk9xy6GJSNeZW062yZAM/qNHj6pMQ+n4LV8b19Uf3lf/xSHXXERo6mPvRY3qJilrOTafTFEjyMsBI9v4YHgbzqFERGR5ZD6rWbOmGpKYsm3bNhUA9AjMRlznPnhtXSjefGsmViwvvLpNElfkmLRLly5m/RmIqHQYKKwApFGJHKR89913qkujfkmhnNWRjEP5upzFcXd3z9eMQYIE8iYfHx+PjRs3qiH1KVq0aKG+JhmIwtVJgyEtvdU4F5OBpbsTsHxvvMqMEJfis/Dp+quYt+EqOtd1x8g2vuha3wOOzJAgsjiSRTxixIgS31+alBDRrckyfWn6I0NPmgbt27tHdQH3x3b0dvFFZnBnHEoMQnSyblnylcRszN1wFfP/voruDTwwqq0vOtZxhz0z9YmIyMLI6jQ5VpQmflICS441Q+d/iHvuHqVOmMlKNv3qtpkzZXXbSpW4wkYmRNaFgcIKYMGCBXj99dfz3fb0008bLk+fPh0zZszI93UJAkoDAgkYHj9+HHv37lWZENLxat26dWpZVVHp4zUqOasMw6d6V8Km40lqafKWUykqOyJXC/x7IkUNqcM0rJWPWprMbo9ERGSrwcMnn3xSzbGyPDkhIQ5OEX+gJeyQ6d0AsZ6tcCjaSc2fMv4+mqxGiK+jyjKUTP1KnvyoRkRElkcf/OvapZOqgz9v3rx8q9tc/UIx7vn31fJlIrIu/PRZAUgn0yFDhhT79ZvVhJCmBtIIRYZkHl64cEF1Ns2bESHNUOSskCxPlvtJUxQnBzv0buylhmQULtsdj6V74nE5Plt9j2QbfrkpVo02NdzUAU+vxp5G/smJiIgsW+XKlTFgwADVEOjMmTOqAcqhQ4dgl3AUD7SuguZje2Hp7ngs3hmH6CRdpv7FuCx89GcM5q6PUZ2SpW5w25purAdMREQWmbTyv//9T12WhiZ1Oo3CNb+ucAtrha252Zg5fzE+eeMpc28mEZUCA4UVgAQCjVEgVlLJ27Rpo0ZekgkhxdpPnTqFpUuXon79+irlvGHDhnByclI1Cp/oVQnjewZg++kUlWX499EkVYdJ7DqXqobXCg16N3TBvZ1dUb9K0Z2XiYiIKiKp21SnTh01pHawnICTsiH+Po6Y2KsSugRF44MfNqosw3PJ3pCFyTKP/nk4SY2q/o5qWfKwVt7wdefHNyIissykldjYa/hgQzLO29nDTmOPvQ69cSkuC8G+rGVPZC34SZNuSbqkSjdH6ZAaFRWFI0eOqOHs7IxmzZqpBglS5FbqKXWu66FGbHI2VuxNUA1QzsVkqsdJTM/Fkr2pWLL3HBqFuGBkWx8MaOoFDxdd2joREZEtkPlTagHndfbMKQRkn0NA3DmEwQNXXJrigqYOkrN0H9XOx2bh/TXRKtOwT2NdlmHL6q6GBmRERESWkrRSJeQYnvjuEmLtghGfpsXE7yKx6PFqcHfmcR+RzQQKpVi3LKUJCwtThfKpYvH398cdd9yhhixPloChjLi4OKSkpOQ7SLl48aKaKPw9HPBQV3+M7eKHvRFpKstw3aFEpGfpircfuZiOI79H4d2VV9CvqRdGtPFB86o84CEiItskReAleCi1DCWT3y11G6phB67YVcUV12a4nBWg7peVo8WqA4lq1Ap0UlmGXWpq4ZvnsWSullHeKxGIiIiK0rhhA7wxJAVvbbLDpUQtTkZl4PmfL+GTB0LZrIuoogYKpTvu999/jy+//FJdHzx4MNauXauWoS5fvlzV4TGljIwMVVdPPvRKsJLKj/7gon///mo5ct4OVrGxsfjwww/h4+Oj6hm2bNlS3bdVdTc1pg4KwuLtUVhzJBNHL6Wr70nL0uL3PQlqyAGPBAyHtOCyKiIisi1y0k0+w8gYNGgQTpw4oU7CSqOxVj6ZGP7ARPy2Kx6/705AQpquluGZ6EzMWnkFHzgA/ZtlYHRbXzQJcymyyVleRTU5IyIiMqbuHVujep0M3DMvXK0s23Q8GR+sjcbzA4K4o4kqYqDwpZdewieffKIuy4dYGeHh4VizZo368GnKQOG2bdvw4IMPqqw3qaEnNRJmzZplsue35QMaqa2UlyxLluVU8fHxKpgsIygoSNUzlCGv0Z0t3DCuZwiOXkzD4l3xWLU/EckZuYYDnndXRasJpFdDTxU0bF/LncXbiYjI5rolN2rUSI3U1FQ1rwZXclYHV4919cSTby1CBOohFoHq/hnZwLI9CWrUq+KMfh3H4q1ZHpj7yYe4dOmS4XFl1cekSZNw3333mfGnIyIiW1G9kjM+vC8Uj351Hrla4JvN11CzkrM6ziMiy6UpyzcdPHgQjRs3VpfXr1+vinJXq1ZNBezkzLcpJSQkYNOmTfjvv/9UHb2PPvoIWq1ueSuZlhzQSIaC/B5Id2Q50Lly5YrKNpXg7bFjxwz3bRjiiteGVcHGaXUw864qqs6SXnYOsPZQEh79KhL93j+Dz/6+iqiELL6cRERkc9zc3BAcHGy4npwQh3ru0Wib9Qc6Zy1BtZwjcISuFrA4cTkD//tsBV6e9gJatmyF7du3IykpSf0vmf4vvPCCukxERGQK7Wu7447Ac4brry+7jF1nU7jziSpaRqGfn59qZiG1dJYtW4Znn31W3R4TE6OyxkojLS0Nv/zyC44fP47HHnsMNWvWLHSf8+fPY8mSJeqDbqdOnVStPD1ZAqsnQSn5EMzC3ubj6OiIpk2bqiGvrXR1lHqG8hrKayuZEUKCupmZmSqgOLSljxpnozOwdHc8lu9NwLUU3bKqi3FZ+OSvGMxdH4MudT1UA5Qu9TzgaM/i7UREZHskK3DatGk4d+6cqmd44MA+1MvYhct2NXFeUx/x8MfVje9h0MBBWL58meq2LNq3b68+sw0bNgzPPfecqomYt3wIERFReZk1vgcuvvsPjqbXQE4u8MyiC/jpiRqoFuDEnU5UUQKFY8eOVcuLa9SogcjISAwcOFDdvmLFCvXBs6S+/fZbtYy5bdu2htqGBQOFW7duRZ8+fdC3b1+VtSgddiVjbc6cOfnuJ9lqErBctGhRWX4kKgeurq5o06aNGlJHUpYl6wOFf/31lwrsSgC4QYMGamlyw4YN8dyAIDzdJxAbjydh8c54bDudAkkQlVT1TSeS1QjwtMewlj4Y3tqHkwsREdkcCf7VqlVLDQn87dy5U30OOnVqFWo07ogn4i7g5Zd/MwQJ836ffO7q2LEjNm/ejO7du5vtZyAiIts6Lpz/VAfcPXs/LudWRkJaLiZ+ex4/PlEDXq48aUVUIQKFb7zxhlp6LM0sJHDn4eGhbpeMv1deeaVUS1UlM1E650qgsCgTJkzAyJEjVVBRDBgwQAUOJVgo2YP6YOLUqVPx888/IzQ0tCw/EpUzCRLq5eTkqNdOujpKsFCyDmXIfeT3qnXr1ujTuA76NPbCpbgs/L4nXmUaRiVkq++/mpSDLzbFqtG2ppuqcdE6hMvNiYjI9kgjOfk81blzZ3UyTv95Sl8ipiD97TfrikxERGRsAX6+mP9IXTzw+XkkwQfnrmZhyo8XMH9sVThwtRiR9QcK586diyeffLLQ7bIUpjQkICQkUFiU06dP49ChQ/myB3v37q2Cgb///rsKNkkDlXHjxqluu7J8WYacIZf6eEWRzDYZeomJiaXaZrp9stRJlo/LkAMVWZosIy4uTi2jkhqTderUUfet4uOAJ+4IwOM9A7DtVIpqgLLxWBKydf1PsPNsqhqeLnYY0iJTBQ3rVXHhy0REFoFzDpm6nmGVKlXUZTkBJ8uNC5Lbhf5+RFRxcM4hS1enRgjeHZmMZ35LRaadC7adTsXbK6/glaGVzb1pRHS7gcLJkyerTL/yrm1z8uRJ9X/t2rXz3S5LbfRfk27Lcib9iy++MHy9Q4cOxQYKpanG66+/Xuh2CVJJppstM0XQtOBzuLi4qNdLDmYuXryoDmDq16+vXg8hGYe//fabWpYsr/P0AYF4ursL1h5Oxx8HUxEZp3vNktK1+GF7nBoNqjhicFNX9KrvAjfnMvXrMfrPWZGet7yew5iPa4zH4kkE62Yprx/nnOLx/ap89qVkDFatWhUzZ85UNQnzLj/Ozc3FWzNnIaByVXU//VxrjOctL5xzyBpwzrF8fL+ynH3ZpGYgnmx3DHN2OiEXGvy0Iw6VPbIxoqV7uT5vSXDOIWuRWM5/D3baMrQIlky+efPmFXmmuiwuXLiAsLAw/PPPP/nq5UiAaNSoUeqDrI/PjRbqUgdRgnorV640ypk2eW7pnuzl5QVbJvvZ19fXop5DMkY3bNhguB4UFKTqGcqQpjp7wtOwZFc81h5KQKZuZbKBq5Md+jf1wojWPmhW1dWkTW5MsS/N9bzl9RzGfFxjPJa5XkMyDnlv9/b2Nvt7O+ec4vH9qvz25dKlS1XZlkGDBqmahBIUlBNxEiRctWolQofNwfxXx2BQC2+jPm954JxD1oBzjuXj+5Xl7culu+Pw6pIoddleA3w2Ngwd63iU+/PeDOccshaJ5XysU6aMwjFjxuDuu+9W9Qgl00vq4xS1pPh26Wsfyg+fN1AYHx9f5iUzUgcvb708smy9evVCcHCwWposhdolw3Dt2rVqSHOb+++/H7NGBWNCF2dsDbdTS5OPX9YFgtMytVi6O0GN2kHOKmA4uIUXfN3L9GtPRFRqnHPIHIYPH47FixerFSDSuETPyy9IBQm96vXGK0suo4qPI1rVcOOLRFRBcM4hazK8tS/OxWThq39jVSfkSYsi8fPEmqgZyGN1InMrU8Rk0qRJ6v9HH320yK+XIUmxSNINV5w4cUIFhfSPferUKfTs2dMoz0GWzdHREc2aNVMjLS1N1ayUoKHUr4yJiTFEzz1dNOgSloKhzSrjXJydyjJcuT8RKRm6Yoanr2TgnVVX8MHaaPRq5KlqGbar6QaNxnRZhkRERKYg9X+rV6+O7777Dt26dVO3ffzxx6hevQa+2uOAkxlAVo4WTy+6gB8nVEe1gPwnfImIiEzh2b6VsPdkFPZHOSIlE3j86wj8+mRN+DCxg8j6AoW3W9OmpORDrmQnSv1B6XQsVqxYgaioKIwYMcIk20CWw9XVFW3btlVDUm2jo6MNdTIlgCydsaXzttQ4HNqiBSb1ro8Nx3VLk/dFpKn7yYHRmoOJaoT6OmJ4Gx8Ma+mNIG9HM/90RERExrFgwYJC9Ziffvpp3QWNA3q8+CeuaCsjPjUHT3wbiR8mVIePW/nWnSYiIipIkjY+eag2hr57CNdyvHAxPgdPfXceXz5aA04OTOggsqpAYd5lwLdDOtxKHUIJ7ojPP/9cLSmV5aYyxGeffaYuS4dcKc4tS2lkybPU27kd0rlZhr6BCZuZWF+BWH9/f0PQWrInJGiYnZ2t6jDJkCXx9erVw6TWjWDXMwyrD6dj7eE0xKfpMl4vxGXh4z9j8OlfMWhf0xlDmrqifS1nOBghy5DNTMy7z9jMhCylsLwe5xzrn3NM8bjG2p7Ro0fnq/lckIdvEGasd8C5q9kIv5qJJ78JxwejfOFoX7r5j6+h8faDpf1OkXW/fpxzCuP7leXuS5l5PrwnCOMXxSEdLth7PgMv/3IOL/X3yVdjnq+h8faDpb1nUQVpZiIkm+v333/H2bNn8c4776jbtm7dinbt2hXbcbggWUa6atWqQrd37txZDT1ZYvrHH3+ogGKnTp2MVgPRkooPWwJrLxArAWwJGO7duxf79+9XtSz1unbtiiFDhiAzW4t/jiWpWobbT6eg4G9/JU8HDGvljeGtfVDVv+xLsdjMxLz7jM1MyFLf2y11u8zB2uccS2p2VJbt2bLnBJ76LQWZdq7q+tCW3nhrZJVSNf7ia2i8/WBpv1NUMd7bLXW7zIHvV5a/L//ZfwFP/xKPXOgy3J/rXwkPdQ0o9+e1ts8NnHPIYpuZSCCmd+/eCAkJUcE+faDwhx9+UA0nHnnkkRI9TpMmTdS4lUqVKmHcuHFl2VSyIXJwI41PZAwYMAARERGqnuGBAwcMGaiSwt7AOx53Vj6MJzo1xZbzzvh9dzyuJOpaJsckZWPhxlg12tVyUw1QpKahs6PGzD8dERGR8XRqWRcPHlqFr45XQ66dA5bvTUD1ACc81uPGQRkREZGp9GgeimevpGL2Rt2Kv9lrolGjkjO6N/Dki0BkYmWKfkyZMgVTp07FwYMH890+fvx4zJkzx1jbRlRmGo0GNWrUUJ0fX3vtNVXvUm/Xrl34+++/8cPCOcg48C1eanMe7wz3VgFBhzx/Ef+dScULv1xC91mnMOuPKJyMSucrQkREFebk2tMP9MfA4LOG2z76M0bV8CUiIjKHcX3rYljDLHVZCzs8//MlnLjMYzAiU3Moa21BaSoi8i5RqV27Nk6ePGm8rSMyAn3Dk7zdtGUZu2S/SmOcqLVrAKxB7WrV0KdHS1zU1MHvexNxPlY3SSWm5WLRtjg1moa5qI7J/Zt6wd255IXfZUm0jOJUqVJFDSIiIlPOj2883h/Rs9fhv8Ta6rZpv15EFW8HNK/mxheCiIhM7n/3NUHCt+fwz8kMpGbmYuJ3kfj5iRrXFyQTkcVmFDo6OhZZPFECLwEBXLJClq1hw4YYO3YsZsyYgVGjRqFOnToq4K2WKu/4B490D8DqKbXwzaNVMaiZJ5zzdNw6GJmO6Uuj0G3mKby25BIOnk9THZdL0oGyVatWxQ75OhERkalJ469Pnu6JOk7n1fXMHODJ7yJx4VomXwwiIjJLJ+T376+OxqEu6vrl+GxM+OosMrLL1FqBiEyVUThw4EBMnz5dBTf0GYXS1OTxxx9XDSOsAbuBFWaLnaQkSChDn2Eo2RVSEFTU8MqB24kvMS60KhI8m+K/y544c1VXMyMtU4sluxPUqBnggEFNXdG3kSu8XTU37UCZnJyMwYMHq9vefvtt1ZhHnjMoKMjQwfl22OJrWF6PxW5g1s3SXj/OOYXx/cqy9uX7Y+rh0S8jEJ0biLjUXIz/Khzz7/OHp0vx55T5GhpvP1jaexZZ9+vHOacwvl9Z3+/7m0M88fC3GYhN0eJoVI5K0nh7VP4VjcbG4xyyFomW2PVYuhBLM5MLFy4gNjYW9evXx6lTp1RjEqn9Zk1d29gN7AZ2kspPfqfzZvo5O7vAv1YbnLeri63hdkjNzP+n42hvp+ocjmzrgzq+GfD388v39aVLl2Ly5Mkqc1FPaifOnj1b1VI0Br6GxtsP7EBp3Sz1vd1St8sc+H5lefsyJj4VD311GedidNmEHWq7Y/7YMDW/lefz3gw7UJI1sNT3dkvdLnPg+5V17Uu9A+GJeHBBBLKv5zc93s0LT/ULKbfn45xD1iKxnN/fy7T0WLoQ7969GwsXLsS0adMwbNgw/PTTT9i5c6dVBQmJbkZqbkpgTzIBfXx8kJGRjktHN8PhyJfoi8V4vH0umldzNdw/K0erisA//MV53L3wKj7/5yqiE7MMQcKRI0eiadOm2L59u8pglP8luC63y9eJiIjMqZKPG+aNCYOvu64S1PbTKXhz+eUSldggIiIytmbVvfDmiCDD9c82JWL1/mvc0USWuPS4cePGOHz4MO688041ivoakbWTtPbg4GA1BgwYoDIB9+7diwMHDiA1JR4j2vjiqeBgnL6Sge//vYQ/j2YgMV13MHUpPkd1j/x0fQw61XHF8lcnY9CgQVi2bJnqyCzat2+vrkug/bnnnsPQoUMLNV4hIiIypar+TphzbzAeWhiBXGiweFcCqgU4Y1xXf74QRERkcoNbB+J0VBq+2Jqqrr/06yWE+bugSRibbhGVlzJlFB45cqTI23NycnDixInb3SYiiyPBvRo1amDEiBGqPuf48eMNXYprBzmjXtZ2tE/6Ct0996K+X4bh+3JygTV/bsLlCxEq+1YfJMz7uC+99BLOnTuHzZs3m/znIiIiKqh1TQ880jrdcP2DNVfw12HLqsFGRES2Y9LAquhSPVddztba49GFp3ElgU23iCwio3DLli1FXha5ublqKWW1atWMt3VEFkiy/qQBSkFO9nawv7YPNbAPQfBAsl9bnMmshoSUGEO2bVH0t1++fLmct5yIiKhknhnRCpGx/2HNOS9oYYcXfr6A78bXQJOwGyU3iIiITLXS6/XhVfD4d5dx8qoGSVmOeOLbSCx6vAZcncqU+0RExgoUdunSpcjL+j/ekJAQzJkzpzQPSVQh3HvvvWoJ8aFDh7Bv3z6cPn0abtf+RgDsUCXQAUsAtSRflhsXpF+qr89QJCIisgTvPtIGlz74DwdifZCZY4cJX4fj16drI9jH0dybRkRENsbJwQ5fjK+H4R+ewNVUDY5fzsS03y5h9j0h0GjKrxMykS0qVaAwLS1N/R8QEICrV6/mfyAHBzWsxdy5c9WQ5dL6Dkf6y7bKFK3uraHl/O2oW7euGpcuXUJkZKRapt+1cy3s+rMqZs6cma9GoT4Td9asWSoTVzIL5ffwdvA1NN5+sJTfKaoYrx/nnML4fmUd+3L2A3Uw5rPTuJjujbg04OEFp7FwTCDcnTV8DY24/y3tPYus+/XjnFMY5xzr/32X55Xmrh+MroTHf7iG1Ewt/jychHdXhGN8Nx+jPUd5MObjcs4hU/wd2mmN0MouOztbdUEOCwtTWYXWpLzbSlsTU7S6t4aW88beHgkGSoBQuhsPHDhQ1SrUN/15a+YsrF61EosXL8bw4cON+ry2/Boa47Es7XeKKsZ7u6Vulznw/cp69uXVxAwMee8wErJ1heM713XH3AfDkJQYzzmHcw5Z8Hu7pW6XOXDOsa59eavn/fd4MiZ+F4nc65GMl/t74N6uYUZ9DmPicQ5Z2/t7mRb0b9y4EQ8//LDh+uDBg9GhQwfUrFkTa9euNeb2EVk9ySCUIKAEA6VjcseOHdUfs/z/97Z9CBk2B6lB3c29mUREREUK8HLGV+PrwMtFt7Rry8kUzFp5BUY410xERFRqXet7YEr/Sobrs9YkYOtRXV14IjJToFC6tE6YMEFdlkxCGeHh4fjoo49UR1giKkyChfp6hE2bNkX3UZNR/ZE18KrXG2+vuoINR5K424iIyCLVD/XCxw+EwcFed/3nHXH46T/LWm5JRES2Y0xnfwxt7q4u58Iez/xwEeeuJJt7s4hsN1B48OBBQ6fW9evXqwCI1Fh78MEHcfToUWNvI5HVk47Ge/fuVc1OhAQMB7apgtpa3XVJynjhl4s4GKmrA0pERGRp2tR0xxvDbzTemvdvKtYfjjfrNhERkQ13Qh4ZhuZhugZbabnOGDvvOBJTs8y9aUS2GSj08/NTTRqE1F7r2bOnuhwTEwN/f3/jbiFRBbBgwQK0atUKnTt3NtQtnDp1KlwilqFK7ml1W3qWFhO/jUTktUwzby0REVHRhrb0wT2t9F2P7fDcTxdw5EIqdxcREZmco70d5o6tgWAvXWmMq5nuGPvxXmTn5PLVIDJ1oHDs2LHo168f2rZti4iICNWgQaxYsQJDhw69ne0hqpDGjx+PPXv25Bs7d+7ElMmT0TvgFOoH6DpuX0vJwYRvIhGfatsduImIyHK9PKIWOtfQXc7Ktccjn59BVDxPchERken5uNnj80dqwN1JVzf3RIIXXvnhGF8KotvgUJZveuONN9TSYwkS3nXXXfDw8FC3JyUl4ZVXXrmd7SGqkKpUqaJGUdq1a4eEtBzcPz8cZ2MycS4mE88suoCF48Lg5FCmWD4REVG5Lvf6+KF6GPnBYZyNd0RilgPGzDuOpVMaw92Z8xYREZlWjUrO+OiBanjsqwjkau3wxzEN2u2Ox52tffhSEJkqUCgfEEePHl3o9mnTpsFazJ07V42cnBxDy3L9ZVtusW2tz2GKbS/v7Xn7Ti88+l0MEtLtsPtcKp7/MQKvDfKGxs6uXJ+3Ir6GxngsS/udIut+/TjnFMb3K+v/fX9rqBcm/pKIa+mOuJDkiIfnHsSnY6rCXlPyeetWOOeQNeCcY/k451jXvizL89b3B57t5Y3Zf+nuN+P3y/B2zECLqk5Ge46y4nEOWdvfoZ1WK20USmft2rU3/bosS7amHezt7Y2EhAR4eXnBlkmw1NfX1yqfwxTbXt7bI4HqF2Z9jr+SOyHHTlf/6dHu/pjUN7Bcn7civobGeCxL+52iivHebqnbZQ58v7KufVnc817LcsOoj08hPUfXDvmBTn6YOijIqM/BOYcsnaW+t1vqdpkD5xzr2pe387wzV0Thh+1x6rKrfTYW3OeLVg1CjfocpcXjHLK29/cyZRQOGjQo33WJNUpzBmFvb4/s7GzjbB2RDZG/nWfHDkbcvD/wX25XwE6DhRtjEeLriLvaMmBFRESWp1agMz4ZUw2Pfx2JHK0dvt96DdX8HXFPBz9zbxoREdmgFwYGIfxqJraeSkFajgOe/P4iFj/jjpAgHk8RlVSZCslIIDDvkEyo06dPq+7H33zzTVkekogAhIaG4uWH+6Axdhn2x/+WR2HziWTuHyIiskgd63hi+p3Bhusz/7iCdfuizbpNRERkmxzs7TD73hDUCNCt0ErUeuGhuYeQnJpm7k0jshpGqzhdq1YtfP7553j77beN9ZBENkn+ll57oA1q5B5W13Nygck/XsSxS+nm3jQiIqIijWjjg4e7+avLuVrghV+jsPfUVe4tIiIyOU8Xe8wbWxXerrqauRezKuGxj7bafE8CopIyamu6gIAAhIeHG/MhiWxSo0aN8NrIGgjKPaeup2bm4olvI3E5Psvcm0ZERFSkSX0qoWd9V3U5G454/JvziIxO4t4iIiKTq+rvhI8fqAqH6xGPA4khmPrZ36psGhGVQ6BQgoEFx759+/DEE0+oAAcR3b62bVrj5f6eqOys62gUnZitgoVJ6bbdnZuIiCyTRmOHd++pigaVdSWwU3Jd8eCnR5GYkmHuTSMiIhvUuoYbZtxZxXB9TWQw5v66xazbRGQNyhQorFGjRqHRsmVLFSxcsGCB8beSyEbd0b0LfpnSAmF+uhobJ6MyMPmHi8jK4ZkwIiKyPK5OGswfVwOBnrrlXtFZXhgzZzeys3mSi4iITO/O1j54qKuuwZbWToPvjgbgbDRPYBEZPVB46tSpQuPq1as4evQomjdvXpaHJKJiBHg64bOxYfB21f25bjudgjeWXWbaPBERWaRKng74fFx1uOrOceFksh+e+HQb5y0iIjKLZ/sGokcDD3U5JROY+F0k4lOy+WoQFUO3NqSUateuDWs3d+5cNaRjs4iLi7P54qaJibolrtb4HKbYdnNuj7cD8GizWHyw3RO5dg5YujsBfi45GNvRo1yf11pfQ2M8lqX9TpF1v36ccwrj+5X1/77f7HkDnIE3h/ni+cXXkKu1w9YrAZi78gTu6xxktOe4HZxzyFJ/n4yBc05hnHMq9pxTEi/1dcP5q+k4E5ON87FZeGzhKbzSCwgLqWy05ygO5xyytr9DO20Jq3lu3LixxA/avXt3WNMO9vb2RkJCAry8vGDLJFjq6+trlc9him039/ZIUPulT/7Aqiv1DLe9PSoYg1t4l+vzWuNraIzHsrTfKaoY7+2Wul3mwPcr69qXZX3en3fE4X/Lo9Rlew2w4KGq6FDb3ajPURacc8gW3tstdbvMgXOOde3L8nreS/FZuHvuOcQm65KFatqfxbeTO8DPT7c0mXMOWYvEcn5/L3FGYY8ePUr8oOwkRGR89vb2eGviQFybvQ7bE2qp215ZfAmBXg5oV6vkB11ERESmcnd7X0RczcR3W68hJxd49ocL+O6xMNSt4sYXgYiITCrYxxGfPBCGsZ+HIzMHOJtTE5Pn/o35zw2Eq6srXw2i0tYozMrKKvEgovLh6OiIj5/uifqu59X17Fzg6e8jcfoKC/ISEZFlem7AjdpQSem5uP+To9h75Iy5N4uIiGxQs6qu+N/IYMP1XSkNMWP+CmRns2YhUakDhQ4ODiUeRFR+3Nzc8MUzHRDioFvKlZyhxYRvziMmiZMbERFZHnuNHd69OwQNgp3V9RStO55ZdAnhkZfMvWlERGSDBjX3xuM9A3RX7OywJro+Pv1uBVdGEt1O1+Po6GjMnz+/0O1yW0xMTFkekohKwdfbC19NbAJfTZy6fik+GxO/jURaZi73IxERWRw3Jw3mPhiGQC97df0aAvD4gsOIvXbN3JtGREQ2aOIdAejbxFNdzrFzwqKToVj512ZzbxaR9QYKn3nmmSILicptkyZNMsZ2EdEthFYOwK9TWqCytEQGcORiOmb8kYCc3BL1JyIiIjKpIG9HzBtTFa6Odup6ZE4YJn6yGSkpKXwliIjIpDQaO7w1MhiNQlzU9TQ7T3x7NAip6SylRlSmQOHq1avRv3//QrfLbWvWrOFeJTKRYD9XfDY2DB7Ouj/lrWcyMHPFZabNExGRRWoQ7ILZ94ZAo4sV4lB6Xbzw6RpkZmaae9OIiMjGuDpp8OmDoQjy0iVeRGV6443l0TyWIptXpkChk5MTLly4UOj2yMhIaDRlekgiKqM6lV3w4X3BsINu2fHP/yXgm82x3J9ERGSRutX3xIsDgwzXN8XVx7xfNpl1m4iIyDYFejmqYKHL9Wz3P/YnYuHGWCQmJpp704jMpkxRvYEDB2LixImIitI1UxCXL1/GE088ob5GRKbVsY4nJnS4cf39NTFYdzCBLwMREVmk+zv54d4OujI2Wjt7/HK2Ks7FZJh7s4iIyAY1DHHF26NudEL+6M8YTHn/V8TGMvmCbFOZAoXvvvuu+qOpVq0aGjdujEaNGqF69eqIi4vDe++9Z/ytJKJbmjikEQbUSjZcf+GXi9gXkco9R0REFkmyCrvUdVeXE9NzMeGbSMSlZJt7s4iIyAb1buyFx7p4GK7/l9kW7y5YjNRUHk+R7dEtxi+lwMBA7NmzB8uXL8fevXthZ2eHFi1aYNiwYXB0dIQ1mDt3rho5OTnqugQ59ZdtlSnSq8vrOSwtNdxc2zOxVyXEJMdg1xUPZOfaYfyXZ/Hl2CCE+pbpT91qX0NjPJal/U6Rdb9+nHMK45xj/b/vxnjeV/u7Y0JcBs7EZCPyWhYe+PgQnmgRgw7t2hjtOYrCOYcs9ffJGDjnFMY5x3isec65laENcxAR64J1R9ORY+eIvxJbwfuz7/DoAyPg4FD24ynOOWRtfw92Wq1Wa+s72NvbGwkJCfDy8oItk2BpUd2sreE5TLHt1rA98rzunj4YNXsfTsW7qtsqe2ixeFJd+Lo72MxraIzHsrTfKaoY7+2Wul3mwDnHuvZleT7v5fgs3D3vHK4m6U7YBueexrt3h6FFi+acc8gqWOp7u6VulzlwzrGufWmu55XncPPwxrgvz2N/RJq6zTs3Bo82isSY++8pcz8GHueQtb2/s/MIUQXj5GCHb59qikCXdHU9KtkOT35/AelZumYnRERElqSKjyPmPhhmKCR/SVMbb/x8FKdOnTL3phERkY1xdtTg4/tDEeyjWymZoKmERUd8sHLVanNvGpHJMFBIVAF5uzlg0VMNEeBhr67LGbFpv11Cbq5NJxATEZGFahzqindHh8BOFyvESU0L/O/rjfka5xEREZmCv4cD5o4JhZuTLlwSpamJL7ckck4im8FAIVEFFeLnjM8eqgpXJ91R17pDSXhj8VlzbxYREVGR7mjkief6Bxqu783tgE9/XM+uk0REZHJ1K7vgvbuDDSewTmtaYE+UrrQTUUVX4kChdDXWmzp1anltDxEZUYNgF3xwTyg0drpMwt/2ZWLh+kjuYyIiskhjOvvhrrY+6rLWzh5bszpj9mc/IiMjw9ybRkRENqZ7g/wnsF5ZchkHzqfBxts8kA0ocaBQln7oP6S988475blNRGREXet74MUBAYbrH21Iwuo9V7iPiYjI4tjZ2eHlIZXRsba7up5l54Id2h5IyzFOQy4iIqLSnsAa0dpbXc7M1uLJb8/jnY+/xNWrV7kjqcIq8aeuFi1a4N5770Xr1q3V9bfffrvY+zLjkMiy3N85EBeuZeL77UnQwg4vLY5GoLcTWtdmV18iIrIsjvZ2+OC+ENw3PxxnojNxJcUek364gM8fqqoadhEREZnyBNYrQ6vgfGwWdp1LxbXUXCxLqY+shV9j8tNPwN1dd2KLyCYzCr/99lu4urpi+fLl6vrixYuLHURkeV4YFIKe9Z3V5Ww4YMLXETh3Jdncm0VERFSIp4s95o8Ng6+b7qPqrrOpeHVxJNav34Dc3FzuMSIiMhk5STXnvhCE+ek6ISfZ+ePv+Cb44suvkJWVxVeCbDejsG7duli0aJEhqr579+7y3C4iMjKNxg7v31sdD352BocvZSM11xkPzj2O5c83gZ+nLoBIRERkKUJ8nfD2cB88/XMcMrK1WHkgBSdzLiE1dSUGDx6sPo8SERGZgo+7A+aNCcO988ORlJ6LaE01/HUhAd4//IAHH3wQGg37xFLFUabfZhbvJLJOzo4aLBhXAyHeuoOra1numPJzlKq3QUREZGkaBTth1qhgw/WT9q3xy+ZIbNy40azbRUREtqdmoDM+uDcE9tejKOfsm2LtkQz88ccf5t40IqO6rbD3li1bsHDhQnz++efqMhFZx9mwLx6tCR9XXbBw59lUTF96mScAiIjIIvVt4oVJfSsZrh+074pFq3diz549Zt0uIiKyPR3reOClQUGG64ftO2H5llPYsWOHWbeLyJjK1EJOOiCPGDEC27Ztg7+/v1r6IV1/OnbsiCVLlqBy5cpG3UgiMq6q/k6YN7YaHloYoZZzrdiXAPuMWLz5QBPuaiIisjiPdPPH+dhMLN2dgFw7B+y1742vf1kJNzc3NGjQwNybR0RENuSeDn6q2dZPO+KgtbPHfsfe8Amuau7NIjJvRuHTTz8NBwcHnDp1SgUIY2Ji1GW5Tb5GRJavWVVXvDM6GPoST78fdcDM77ebe7OIiIgKkZPSrw6tgrY13dT1TDtX7NT0wpff/YSIiAjuMSIiMqmpg4LQsY6u43GG1gnPL7mGpPQcvgpku4HCtWvXqi7ItWvXNtwml7/55husW7fOmNtHROWod2MvPD8g0HD9xyNe+GrFLu5zIiKyzK6T94eiRiUndT3Fzhd7NT3h6ORi7k0jIiIb42Bvh9n3hKDm9TnpbHQmpvx4ETt37UF0dLS5N4/I9EuPc3Jy4OxcuEuq3JadnQ1rMHfuXDXkZxFxcXGGy7YqMTHRap/DFNtuDdtTlucd3NAOZy+7YfHeVGjtNPhomxPcHXegT/t6RnuOkjDm4xrjsSztd4qs+/XjnFMY5xzbnHOM8RxvD/PC+EWxiE/T4kpuED7emIYX+l4rVRdkzjlU3r+n5sQ5pzDOOcZja3POrcwc5oXHvo9FYroWW0+l4MLxc+jotQZjxoyBh4dHmR/XmNtYHo9B5lXer6GdtgwtjAcOHAhXV1fVyMTX11fddu3aNTzyyCPIzMzEypUrYU072NvbGwkJCfDy8oItk2Cp/vW0tucwxbZbw/aU9XlzcrWYtOgC/j6WrK67aFPw6WgPdGhR32jPcSvGfFxjPJal/U5RxXhvt9TtMgfOOda1L831vMU9x97wVIz74jyycnQfY5/rH4huoQmoUqWK+oxa1sc15jaa+jHIfCz1vd1St8scOOdY17401/OW9Tl2nU3BI1+dR/b1vKNGOVvRMTgZEyZMUMlUnHPI2t7fy7T0+OOPP8ahQ4cQHByMpk2bqhESEoIjR47go48+MvpGElH5stfY4d27Q9A4RLd8K93OHZN/jcXRk+e464mIyOK0rO6GN0dWMVyfveYKZixYg6+//hpZWVlm3TYiIrItbWq647WhN+ako/YdsP9iLhYtWmTzqxbJOpUpUFirVi0cPnwY33//vep+PHLkSHVZAoXyNSKyPq5OGswdE4YQX11FgkT4YdafGci+nq1BRERkSQY198bEXgHqshZ22K/pir3nEvHjjz8iNzfX3JtHREQ2ZEQbH4zt4qcua6HBfvue2HXsEpYtW4YyLOIksr5AoXB0dFQBwunTp+O1115Tl6XrMRFZrwBPB3w2tio8XXRvDXsvavHmiihObkREZJEm9AzA4Oa6JTc5cMBe+97YeegsD8yIiMjkJvcLRLf6urqEWXbO2OPQG5u278H27dv5apBtBAqJqGKqGeiMTx4IhaO9rij8bzvjMWdVBIveEhGRxZEGJm+MqIJW1XV1CTPs3LDHoQ82bduF9evXm3vziIjIxso5vXd3MOpW1jV+TbXzxj77O5CRaR0NX4n0GCgkoiLrbOSt/fTF1jRM/eQPpKamcm8REZFFcXLQ4OP7Q1HV31FdT7Lzw377Hliz7k/s2LHD3JtHREQ2xN3ZHnMfDIO/h726fk0TjJ3pzbhCi6wKA4VEVGztp2f6VDJc/zepGd6ct0R1NiciIrIkPu4OmD8mDF6uuo+2VzVhOKZpj/DwCB6cERGRSQX7OqoTWE4OuhVafxxMw/db49RxVGxsLF8NqpiBwk8//dT4W0JEFufR7v6qMK/Q2tlj9dUm+OLn1cjOZvo8ERFZluqVnNWBmYMuiQPn7RsiM7SXWp5MRERkSs2rueF/w2+s0Hpv9RVMm7MY8+fPZ0knqpiBwsmTJ7PNN5ENkIOrV4dWRqc67oaivL9fboiF3/3KjpJERGSRpTPeyHNg9u7qaPxzLEnNWfHx8WbdNiIisi2DWnjjsR7+6nKuFlgf1xiR8Xb48ssvkZ6ebu7NIzJuoLBx48bYtWtXWb6ViKyMNDX54N4QQ1HeNDsvfH8iBD/9tpTLuYiIyOIMbemD8dcPzLRa4PmfL+L9hUvwySefIC4uztybR0RENuSpXpXQvZ7uOCoLjtjr2AdnL8bi+++/Z/IVVaxA4ZgxY3D33Xfjiy++wLZt27B79+58g4gqFg8Xe8wfG4YgLwd1PUETiJ+OByI9g/UKiYjI8jzZqxL6N/VSl9Mytfg1ohauJGRh4cKFbMxFREQmo9HY4ZUBPmgU4qKup8ID+x174+iJU1iyZAkTL6jiBAonTZqEiIgIPProo+jUqRPatGmTbxBRxVPZ21EFC92cdLWezqVXwkfruYyLiIgs88DsrZFV0Lyqq7qepnXFfqd+uBR9TS35ysrKMvcmEhGRjXBxtMMnD4Qi8HrSxTUE4oh9Z/y3cyc2bNhg7s0jMk6gUJZt3GwQUcVUr4oL3hzqA/vr7xzfb72GRVuv4fLly+beNCIionycHTXqwCzU11Fdj9P64pDTHQiPOI+lS5dyyRcREZlMkLcjPn0wVAUNxUVNHZzVNMXmzZuZ6U4VI1Do4+Nz00FEFVfbGs6YceeNQvFvr4zCCx8uxsGDB826XURERAX5eThg3tgweLroPvJGaUNxwqE9Tp8+zSVfRERkUo1CXDHzrmDD9ZP2bdCs32Nwc3PjK0HWHygU0dHRWLBgAV588UXDbVu3bkV2draxto2ILNTw1nkKxcMO+zXd8ekP63Dy5ElzbxoREVE+tQKdMee+UDhc/9R7zq4hzmsaYO/evbhy5Qr3FhERmUzfJl54qnclw/X/rUrA0g371Jy0c+dO9b9+cNUWWVWgUH5pGzRogLlz5+Ldd9813P7DDz/gm2++Meb2EZGFkgluUHNdofhcOwfssrsDc79erOqXEhERWZL2td3x6rDKhutH7Tug9YBHULnyjduIiIhMQRIu9MdRmTl2mLo0DiPvf1TFU+bMmYPJkydjxIgR+Oyzz/iCkPUECqdMmYKpU6cWWmo4fvx49YtNRBWfnZ0d/jeiCtrU1KXKZ9q5Yru2B+Yt/I5nv4iIyOKMbOOLcV1vZMO/+3cOTkalq+tcEUNERKY8jnpjeBU0qGyvrjt6VYFv37ehcXRBYGAgWrdurQKFaWlpmDdvHv766y8kJyfzBSLLDhTu2bMHjz/+uOGXXK927dpcekhkQ5wcNPjo/lDUDHRS11PsfLA1qzM++/xLxMbGmnvziIiI8nm2byX0buypLqdk5GLCN5E4eDIS77zzDk6dOsW9RUREJmu49dm4mqjio+uEnO4Sit8ja6Bt79Fo27YdfH19kZubi7Nnz2LdunXQarWG742MjFSlM/LeRiUjy7nzLu8uOLjcW0f3W1lKjo6OSExMhKen7oOW3rFjxxAQEFCWhyQiK+Xtao/PxobhnnnhiE3OQZymMramNkf/02fg76/L3CAiIrIEGo0dZt0VjAtXz+JYVBaiErIx5edoNE5MVOVznnjiCYSEhJh7M4mIyAYEeDpg7oNhuP+zcKRmauFesxte3whU9m6OHo07444QLTwyIhAXG5Mv9rJy5UqcOXMGXl5eqFOnDurWrav+l+t0c9Jn4/XXXy/269OnT8eMGTNsfjeWKaNw4MCBagfm5OQYMgol0i1ZhkOGDLH5nUpka0J8nTBvTBhcHXXvB5c1tbAjvrq5N4uIiKgQVycN3h7uY8jiuJTmhtNeA5CekYEvvviCGfFERGQy9aq44M07A5CblWa4TU5i/bQjHs8tScDz6/2wObUV1hxMRHJ6jsoidHJygoODg0rektWeP/30E9544w289957WLNmDV+9m5ByebLPtmzZYrhNLsttMuTrVMaMwtmzZ6N3794ICgpS6bDS2ESWazRp0gSzZs2yiv0qjVhkSLBTxMXFGS7bKnmjsdbnMMW2W8P2mPM1DHEHpg/2xrTf45GrBRZujIWPUxb61tdAo9GoCa0sj2vMbTT1Y5D5WNrrxzmnMM45xmOLc87tcsxNwTt3euPxH66pLI6zaYFw9eiGqkmbVPH4MWPGwN3d3WTbaGnvWWTdrx/nnIr1fmVpv1+cc4y/zxoFpOPUZ33hWacnhj72P+y/mIOs66GJpPRcrD6QqIaDBmgWokH3+v3wQI8ByIi/jPDwcJw7d04tmZXlyJJ5KLENvf/++w/BwcFq2NvbW+TvlCm5uLigRo0aSElJMdxWrVq1fHN+XJ79Z6nK+zW005ZxYbsUff7jjz+we/duFSxs2bIlhg0bppYlWxPZwd7e3khISLD5VF35g5BaCNb4HKbYdmvYHkt4DX/Ydg0z/7iiLtvbAT09d6FRQAYeeughdearrI9rzG001WOQ+Vjqe7ulbpc5WML7laU9blnZ8pxzu4+75WQynvg2Ejm5utvbOu+Ff/I+hIaGYsKECXB2djbJNlra7xRVjPd2S90uc6gI71eWgnOO8feZBK08PDzUZdW0xMEFW06m4O+jSfj3eDIS069PUgU0CnHBHY080bOBB4I9c9RyZFdXV7UMWf+8b731lros81nNmjXV1yThS5Yr5+03YWsK7vOSnhy0lfd3hzJ/o4MD7rzzTjWIiPTu6+iHi3FZ+HbLNeRogb8TmyM1diVcf/4Z9957r8ouJCIisgSd63pg2uDK+N/yKHV9d2ZLdHJNwIULZ7F27VoMHTrU3JtIREQ2xt3ZHn2beKmRlaPFnnOpKmj497EkXI7PNtzvyMV0NT7+MwZhfo7o0SBIBQ6zc7RwsLdTyV3NmzdXqz8lMCY9JWQIyTzs168f2rVrZ8aflCxVmQOFp0+fxieffGL4RWvYsCGeeuop1KpVy5jbR0RW6Ln+gbgUn4W/DichB47Y7dAHjvv/gKvr7xg+fLhNn70iIiLLcnd7X0RczcR3W6+p0hl7NT0wqo4/+vbta7jPyZMnUaVKlUKN/IiIiG5X3hJo//77L/r06WNYJuxob4f2td3VeGlwEHadiMGuC3YqcHj8cobh+yKvZal5TIaPmz261fdAz4YeGD7qXrg46Lr9SsBQhmQeJiUlqWW4ehcvXlTLlCXTUGI6kploq/ucyhgoXL58OUaOHIlWrVqhTZs26rYdO3Zg3rx5WLJkCQYPHsx9S2TjXSXfHhWMmMTz2H8+DRl27tjj0AcO21fCzc0N/fv3N/cmEhERGTw3IBCR1zLxz7FkpGQCfya0wkPZDpBDqPT0dCxcuFAVkK9UqZJauiX1jeR/S1oOSERE1mfp0qWYPHmy4fqAAQNQvXp11RdCEizykmSLOkGOaFvfFxN7VcKluCz8cywJG44mYfe5VEMZjfjUHCzfm6CGs4MdOtRxR88GnujeujO6d++OmJgYtXRV6hbqHT16FNu2bVNDnicsLEwtU5Yh23OzElIVeZ/bqjK92s899xxmzpyJ559/Pt/t0mVnypQpDBQSEVwcNfjkgVDcOz9cneFKsvPDPvs7YL9hnQoWduvWrUR7Sc5+ySiOZHjIICIiKit7jR3eGR2CMZ+H49ilDFVC46nvLuCrR6uq+j+VK1dWc5EcXMmQrAsh9YHat2+vmvwRERGVNmAlCViDBg3Czz//jMaNG+Pw4cMq1iK3L168+KaBq2BfR1X2SUZCWg42H09Wy5M3n0hBaqYuapiRrcXGY8lqyKKuZlVd0bG6Awa2CoWr6406vLVr11a1+iSDXua58+fPq7FhwwbVh+KZZ55Rc6Gt73NbUaZA4aVLl/DYY48Vul1ue/31142xXURUAfh5OGDBQ1VVsFDObMVqQnAYneH772ZVDyNvuntxFixYcNP3lenTp2PGjBlG3nIiIrI17s4aTO/njAk/pSMuzQ4HItNw/ydH0bNWDtp26gEHbYZaqhQfH686TEZGRqogYt5yGtHR0Vi1apUh4zAkJIRLmYiIqBCZTyTJSgJWy5YtM9Rxl5NPcl0axUqCltTKLcmSWG9Xewxq4a1GZnYu/jujq2somfIxSbq6htLGdn9EGvZHAPM2JaFmJSf0aOiJOxp6okm16mruEjLP6Zcpy8jMzFQZ9XqrV6/GtWvXDBmHfn5+NrnPK7IyBQobNWqEffv2qbTVvPbu3au+RkSkVy3ASWUWPvzleWRma3FRUxceLVuWKEgoxo8fjyFDhiAtLQ2dO3dWt23ZssVQN4PZhEREZCxLfliI3fN/QY37F0Hj5IZjMfZqaHOzkXrhEDrUcML/nhqOgQOd1IGTZFvk7YwsdZ+OHDmihnByckK1atUMy5XlsmRmEBGRbdu8eTPCw8Px008/FWr2KNdfeukldOzYUd2vYNzlVpwcNOhSz0ONV4dqcfhCuso0lMDhmehMw/3OxmTi7KZYfLkpFgGe9uhe31PVNWxfy0uVmJMhZTckcJg3cHbgwAHExsZi//796rq/v78haCiZiZbaQbg897nNBgp3795tuHzPPffgrrvuUkuP9b888nVZevzyyy+X17YSkZVqWd1N1Syc/ONFdf2LLcmoHZyAwS28Ve2nmwUN9UuLpVOXnnTvstQJiIiIrJf+5NTuiGzM3hgHBzddDUI7jQPcq7bFwRxg6JyzCPV1RNf6HuharwrquN446JIDpIEDB6qMQxlykkufkSEefvhhNGjQQF2WJV5y4FXRC8YTEVFh+tJKsvS1KPrbb1aCqaS145tWdVVjUt9A1bxr5Z5o7AjPxr6INJVlKK4m5WDxrng1XJ3s0Lmuh6prKHNd3nq8Evu5++671RJlmdvkhJkEDWVI3wrJPHzxxRfzZfFZSnaeqfa5TQUK9U1L8sr7C6D37LPPYtKkSbe/ZURUofRt4oUp/bMwe020uv7KkktIvnoexzb/hkceeYSdJImIyOz0J6fq1UvB+JG+cA9rhRc//A3bz2QgIvZGQPBCXBZ+3B6nhoujHTrUTlEHU93q+aBHjx5q5Obm4sqVKzh79qwKGkoWgxRL19u0aRM2btyonk8KytevX19lHnp5eZnppyciIlPRr4qS+niy9LUguT3v/Yy52uvetu6Y2NcX15Kzsel4smqGsv10CtKzdFHDtEwt/jqcpIa9BmhV3Q09G+qyDUN8nVSGvIy+ffuqpA+Z5yRoKMFDmcfyBgnfeOMNNcfpMw6lJEfBbL6Kvs8rdKAwLi6ufLeEiCq8h7r44cK1TPzyXzyyc4B3NwJtM5zwxRdf4P7772f3SCIishy5WUiJ2IHJfXxVFnt4TAY2nUjGv8eTsTs8Vc1jQg6spAaUDFGvijO6qaChB5qEVVYHHJ06dSrys7VkZkjtbxn61TsBAQHqAExqJeVd1kxERBVHly5d1MkjaaKRt16ekBNNs2bNUnOB3K8868nf2dpHjbTMXBUslOXJG48nIy5FN8lJJ+WdZ1PVeHvlFdSt7KxqGkrQsEGwi1oZ1rBhQzXU/XOuT46AquUrq8LyZtZLFr1k30vQUE6QmbK+oSXs8woXKPTx8SnfLSGiCk8Kvk8bXBlR8dnqYCsz1wH7nQegbervqlbEU089ZTXFcImIyLZUr+SsxpjO/khOz1EHVJKJsel4Eq6l6LpLihOXM9T4/J9Y+Lrbo0tdD5Vt2KmOO7xcbyy/khNkssxZsg2PHTumgoWy3Onq1atqyfKoUaMM95V6SXJAI5kaQUFBZsvGICIi45DluLNnz1adduXEkNTH03fglYDVypUrVQdeUy3bdXXSXM8a9EROrlY1PZG6hhuOJCHyWpbhfiejMtSY//dVVPZ2QI8GnrijkSda13CDo71dvu2VurwvvPCCYZmy1PGV+e3QoUNq9OvXD7169VL3zcjIULV/PT09bWafV7hmJnrS6a2oTMO8yyqIiPK96djb4b17QjD28wgcvZSO5FxXHHAZgJZJy/H5559j4sSJXIZMREQWzcPFHr0be6kRe+0aLqe6qkxDycI4cjHdcD/JyFixL0ENWb7VopqbyjbsWs8DtQKd1DLjZs2aoWrVqiqrXg6gJHCYmppq6KYsWYf//PMPEhMTDdkY+mVfEjgMDQ3lQQ0RkRUaPny4CkxNnjxZNdHQk/d3uV2+bg72Gju0quGmxnP9A1UDFMk0lHHowo05LiohGz/tiFPD00XXQEUCjV3quqt5UuaxwMBANaQppWQbXrhwwbBMuW7duobHkhNmixYtyrdMWfaDsTPrLXWfV4hAoXQ3HjNmjGENd0HygYaIqDjuzhrMGxOKe+aH43J8NmJzfHDEuTfsr67FwoULMWHChELF3fOmsf/777/o06cPD4yIiMjsNHZ2aBzqqsYTvSohJikbW07ogobbTqUgNTPXsHxr97lUNaReb4g0RKnnoQKHdfx0n51l7tMv38q7HKpDhw6qBlRERIQKJh49elQN/Qn6J5980nD/7OxsODjcVi4AERGZiASmJKvO29tbXV+9erVFHedIsK92kLMaj/UIQHRiliq1IUHD/86kIitHN38lpedi9YFENRzsgXY13VXQsEcDDwR5O6r7yM8kWYYy9JmEelLTV+jLcUgdX/39JaDYrl07oyWTWPo+twRl+hQxbtw4tG7dGl9//TWXJBNRmVTycsRnY6vi/s/C1cRyKTcYbi5dgEv/Yvv27ejZs6fhvkuXLlVnffQGDBigDowkdZxnfYiIyJJU8rxR8ykzW4u94anXlygn52uIcjEuy5CJIQ1R2tdOMWQbVr5+UCXkwKV3796Gk2YXL140NEiRIdmIerJ0a8aMGaouomQb6jMP3dzcTLwXiIiopPIGqLp27WrRAatAL0eMbuerhpTh2HoqRS1P/vdEsjqmE1LDV26X8b/lQONQF92y5gYeKuCoz5jPSxqjSIbf6dOnDRmH8fHxar6TIfEnPZkHHR0dVYfloh6rou1zqwkUHj9+XNVKKc/140RU8clEMef+UIz/+ryaUE7n1EH9un7o3r1jviCh1JEYNGgQfv75Z0MdCSlCK7czRZyIiCyVk4MEAN3VeHFQECKuZhrqGhZsiLLxWLIahoYo17MNm4S5qmVgQg5kJDAoo3v37irbMCvrRu0oWdIl18+fP6+GdFWWg6jKlSurgGGLFi3U/0RERLdLlhf3beKlhmQW7jmXqjINpYuyLEvWO3whXY2P/4xBmJ+joRZi86quqiyVnsSXZJ6SIatUpWavBA2joqLyJaitWbNGxaQkI1CWKEvGoTRIkXIeZMZAYb169RAeHo4mTZoYaTOIyFa1r+WON4ZXwbTfLqvrK8/5o+eRZN2Ek5WFKVOmqCBh3s5U0s5erksR2ueeew5Dhw7lWSAiIjKa8ip3US3ACQ929lND3xBFsjA2HiumIcpGXUOUznXcdQ1R6nrAO09DFJkX89ZvkizCadOmGTIO5f+YmBjVJEWGZF/oA4VSa/zEiRPqunRaLmtWBhERkTQy0Z8Ye2lwEI5fzjDUNZTLetIY5dst19TwcbNXJ8Ski3KHOu5wc7rRqEvmJJmzZBQk87EMmcd2796thpCTYlK+Q1afkRkChe+++y7Gjh2LV199FbVq1Sr0wUIyfoiISmpoSx+cuZSEL7fqMimm/noJ/u52WPrFLHVSQjoiF+zwKNelU5WkqEuGs2RWEBER3S5TlbsoriHKphPJKvMib0OUP/YnqqFviKKvbSgNUfJ+DpfLfn5+auiXaSUlJRmWKectHC9Bwl9//dWQxaFvjiL/y9JldlYmIqKykLmoQbCLGhN7VcLFuEz8czRZdVGWOr1Ss1fEp+Zg+d4ENZwd7FSwsGcDT3Rv4AF/j+JDVQ899JDqkCzHiZJxKEOWI0vmYcFVr1u3blUNUiQTn8uLyzlQKEWUJdXzzjvvLPLrbGZCRKU1tqM7YtPtsWxPgqrp9OR3F+B58NRNTz7ob5csCSIiottlrnIXxTVEkaChNERJySjcEOWDtfkborSt6QZnx/wn1YQcNDVt2lSNvPTdk2WJsgQTDx48qIZwcXHBo48+qorIExER3Y4QXyfc38lPDQkObj6ha4ay5eSNhl8Z2TdKcMj5L1mWrK9rWL1S4c7HTk5O6uSX/gRYSkqKqm+YN8te5rbff/9dXZbb5WSY3F+WK3t4ePBFNXagUM6ySkbhU089xWYmRGS0M0/Th1VBVHwWdpxJRVIGkB4kaeOL1UGaLDcuSN95XTIfiIiIbne5saWUuyiuIYosUw6/WnRDFFdHO7Sr7a5qG8oy5bwNUYoiJYRkSJmPyMhIw3JlydBIT09Xy5H1NmzYoDIQ5SBLhgQQ8x6MERERlYQsNx7cwluNjKxc7Dyrq2so2YZXk3RlP7RaYF9Emhqz10SjZqCTyjSUwGGTUBdortftzcvd3R3NmjXLd5s0+GrevLnKOJRA4rFjx9QQMofJCTQ5QbZ//3518kx/XFmFx5ZlCxRK6+p33nmHUVgiMnrRd2lu8sBnETh1JQOZAW3g4R+Ct956C8uXL8+3DEoKuM+aNUtlQ3Tp0oWvBBER3RYpY2GJ5S6Ka4giQcNd51IMDVHSimmIIkHDpnkaohQknSP1AUB9wDQ6OloddOlJ90l950n9/ggJCTEsV27QoAGXdBERUalIFnyXeh5qvDq0siq7IQFDCRyeib5xUuxsdCbORsfii02xCPC0Rw8JGjbwRLtaRWfS68kJr/vvv18dN8oKNAkYSiMUORkm9M3AOnfubPie6dOnY8aMGTb/SpYpUCgfBmQnSzcaIiJj8nSxx/yxYbhnXjhikgCfri9g1bJJKoNDCrTrl4FJkHDlypVqGRjrTRAR0e3Sl7Gw9HIXeRuipGTkqKXJEjSUoc/GKNgQRTI4utQtuiFKQTKnFsymGDFihCFQKFmHcXFxKgtRxq5du/D6668b7ivBVulOmbdDJRER0c1IlmDTqq5qTOobqE6K6TMNJbNQsgyFzHO/7YxXw9XJDp3reqigocxvMtcV/di6k1sypDHvhQsXVEdlmdsKZsczm/A2AoVSm3D06NHqQ4G0oS7YzERfPJmIqCyq+DiqYOGDCyKAer2BYXOw+d+3VSaHnmQxSJBQMh7+/vtvVaA2LCyMS6GIiKhsc8/14Jg1lbtwd77RECU3V4ujl9KLbIgiNaFK2hClKIGBgWro94sECvVdleUALG8G5g8//KC+7uvra2iOIv9L50p2ViYiopKeFHuoq78ascnZKpNeAodyckzqGYq0TC3+Opykhsxtraq76eoaNvRQdRGLwqXF5RgofOWVV9T/9957b5FfZzMTIrpd0iXrg3tDMPG7SHjV6w3POj3h9c8MaC//h88//xx9+vRRBxzSfV3qTwi5XrlyZQQFBakitdKlUi4TERHdipSxkHlDGpfkrVFoLeUuJBujLA1Rgn0cVcDwZg1RCpIgoIyWLVvmu13mYzmBFx8fr4KFe/bsUUNI4XhJJpAakEREpMtQlyHNYvVYL68w6YA8vLWPGmmZudh+OgUbjiap4GFcSo5hbpN6hzLeXnlFld/Q1TX0UMeVPFFlgkChTPxEROVN6lW8MrQyXv89CnYae3j0mIHL615Hy3ad1dIoqSvRu3dv1bExIiICCQkJhglXJlnpavXYY48ZHk+K10rKuZeXF188IiLKR+aV2bNnq+7G0rhEahJac7mLQg1RIlKx6VjhhiiX4m80RHFx1NVDLGlDlIJkCdekSZNU/SeZl/VLlWWeTk5ONtSDEnL5u+++U8FZyTiUVQEODmU6NCEiskoLFizIV7pBsF7ezbk6aa5nDXoiJ1eL/RFpannyhiNJiLyWVaj8xvy/r6Kyt4Phe1rXcIOj/c2z6KmMgULWHCEiUxnV1hcXrmXhy02xKlgY3P8N9J59Ac2ruqo6S53qtEPXrt1UJoUECuVgRIquSyF2KY2gl5SUhC+//NLwHiZLlWVI50YJHjo5FZ2eTkREtmP48OEqGDh58uQiy13I162RaohSy12NmzVESS/QEKVuZWd0r3/rhigFubi4qDpQMkR2draqZ6jvKinket4OlBIk7NWrlxpERLZg/PjxGDJkSLFft6RSF5ZI5qRWNdzUeK5/oGqAIsuTJdswb/mNqIRs/Lg9Tg1PF10DlTsaeqJzXXd4uFjHyT+rCBSuXbv2pl/v169fWbeHiKiQSX0q4WJsGtYeTjWklu8JT1Pj4z9j4Odujw613VUx2451GiA0NFQticpLAoWyLFm6tsuSKBkHDx5UX5PlZbKUWX9wIkvMWEKBiMg2STBQ5gNvb291ffXq1WqOsJZMwrI0RJFlXPrAYd6GKCejMtQobUOUgiQIKMHWvPz9/VXmpj7rUOZpWZ5MRGQrWC/PeGRpce0gZzUe6xGAKwlZ2Hi9ruGOMzdOiCWl52L1gUQ1HOyBdjXdMf3OysXWNLRVZQoUFqwtIgfUcmAt5EOUnDUkIjIWyRZ8fag/Frx6HzxqdUOLPmNx/tqN95lrKTlYdSBRDVEn0AHdGmShU113NK/qpjIpgoOD8dxzz6nlUNLpSjIP9SMxMdFwQCjktoULFxoyDvXZhzyAISKyDXmDgl27dq1QQcKiGqL0auSlhjREOXY5XQUNZdysIYpk9ner71nihigFybwrS+xkyLGEdKCU+oZERES3K8jbEaPb+aqRnJ6DLSdTVNBQTohJsFBI8FDq9fq6s+xFQWXaI0UFAs+cOaNqgT300EMwpRMnTuDhhx9Wl++//348/vjjJn1+IjINOQBJObdVjcXLpiEuwxFbT6Vg68lk7DiTaijSLk5FZ+NUdCy+2BQLNycN2tVyQ6c67ioDoqq/i1qSrF+WLAcnsmRZ6irlXQ4lBdlPnTqlhp6fn58KGHbv3l1lLRIREVW0E3ONQlzVeOKOSrialI3NJ3VBw4INUfSZ/fqGKJJpKMuU29R0g0sJGqIUnOOlKzIREZGxyfLifk291MjK0argoAQNZdQPdlHHi5Sf0UKntWrVUp1Ihw4dqgJ2piK1xd5++2389ttvCA8PN9nzEpF5hfo5YXQ7Gb7qDf/A+TQVNJSzRUcv3ciASM3MxT/HktUAriDMz1EtUZZsw7Y13eHurClUd1XqUgUEBKjGTfqsQ6l5eO3aNTU6deqU72TFkSNHDJmH8n3sqkVERBVBgDREaeWjhr4hyr/Xlyifi8nfEOXnHXFqSEOUdrXcVdBQ6kBV8SldQxQiIqLyIo1MpGSVjGmDgwzZhZSfUXMs5QC5LME6yeiR7B1pJiC1woojy5sLfl2WAsqShd27dyMqKqpM201E1v+GLx2sZDzTFzh74SqOxjhiy8lkbDudgtjkG/WWpBuWvruj1KVoWc1NBQ071fFA/SrOKsgnS8yknmGDBg0MxezT0tJUpqEEDeUEhd7Ro0exbds2NYSbm5vq3KhftiwnURwdeZBERETWLW9DlBcG6hqiSMBQAoc7CzRE0S9d1jdEkeXJ3UrZEIWIiKg8yXGfVynq7dqSMgUKiwoGSubN+++/j0aNGpX4cWJiYlQXUmkLLo/5zz//qCV9eWVmZmLKlCn47rvvkJqaivbt2+Ozzz4r1fMQkW3xdbfHoFBvDGrhreotnYjKUEHDrSdTsC8iFdnXTxzJQc3Os6lqfLg2BgGe9uhYW5dt2LBSLvL2Q5FOjXXr1lUjL3kvkhMYEkC8ePGiep+SLEMZ4tVXXzXUP5T7CKmXKIXdiYiIrLkhygMBfnig042GKBI03FRMQ5SF1xuiSJfJrvU80Lle6RqiEBERkWmU6Ui1YNcyPcm++fHHH0v8OPPnz0dKSgq+/fZbdOvWrcj7vPDCC1i2bBk2b96sMnSeeuop9O3bVx2Es+AxUcV3+fJlNSSjT2///v0qcFeSbmFSb6lBsIsaj3YPUAcz/51J1WUbnkpRGYZ6cmCzYl+CGpLv0DAkUQUNZamyZEFI5mJBeYOHUr/10qVLhuXK0lk5b5OUP//8E8ePH1dBQslK1DdJkSH1D7lkmYiIKlJDFAkcHr6YDq32RkOUlfsT1dA3RNHVNvQsU0MUIiIispBAYd7i/nq+vr7w9/cv1eO89tpr6n/pQFoUCSJK3cMPPvgATZs2Vbd9/PHHCAoKwq+//mryxilEZHqScfz666/nu03KDehNnz4dM2bMKNXBTM+GnmoIWTqlsg1PpWDn2RSkZeqOZuTfIxfT1fj8n1h4OGvQvrb79aYo7gjxdSr02BIA1Af+iiLLkmVI1mFERIQaevL+OXXqVMNBkgQdmXVIREQVpSGKBA3lBF1yEQ1RJKtf3xClWz0PdKjjXuTJOSIiIrLQQKG+W2h5k6whySLKm20oAclmzZph+/btKlCYnJyMfv36qSyerKwsbNmyBb/88ku+GmJ5SS1EGXqJiYkm+VmIqGzGjx+PIUOGFPv1m2UTlnTpVLUAP9zX0Q+Z2bnYGyFNUWT5VAJOR9/o8C4HNuuPJKkhalRyUkFDyTaU2oiuJeiWde+996qarFevXjVkHcqQ9y/JPMybSSEnSIQ+8Cj1DqVuotRPJOvBOYeIbF1pG6Is2xOPra/WZaCwDDjnEBGRMZS5SJY0Dtm7d6/qAFqQsboeX7lyRf1fqVKlfLcHBgYavibLD6XrcV43y2ycNWtWoewkfY3FnJwb9VRskSmCpuX1HJYW8DXX9lTE19DFxaXYcgd5/35L8lglUc8PqNfeESMbOiFT44td4Zn471wGdoVnICHt+topQB3cyFi0LQ5O9kDTUCe0q+GMdjWcUCPA4abLpyRTsGbNmmroswcly1D/c6Snp6suy0L+l2ZN+u+TwGj9+vXRtm3bMv+MtsBS3hM459jW+5W5cM4x/j6TVS168t4sNbPLc/9b2u9UeVLzbEcnPNrRDxfisrHtTAa2n83A/shMZOUALas6IS05ATcKjlg+S3n9OOcUj3OO8XDOMe8+45xDpvg7LFOgUJb9jhkzRl3OW3/L2IHCvN2OC17XH4RLdk3eZYi38tJLL2Hy5Mn5drB0KJVMRS8vL9g62Q/W+hym2HZr2B6+hsbbD/IYdcKAe7vIEiktjl5MV0uUZanywcg0tWxKZOYAuyMy1Zi7EQjycjB0UpblylK8vbRkSbW+y7J+SABRbpNgof7nkxMcixYtQmhoqMo6lP8luGrrLCXzknPOzfH9yng45xh3nzk5OeW7363qYhtrzrE16emX0cY/Gm38gfQWwOErGrg7ZuDcufgS1SG2FJxzrAPnHOval+Z6Xms4VuWcQ/blfKxTpkDhtGnT8Oabb6qAW3kWHdZ/MJCMGski1JPrbdq0KdNjOjs7q0FEVBr2Gjs0CXNV4/GeAUhMk6YoEjRMwdZTybgcf2OZ8pXEbCzdnaCGxg5oEup6PXDorr5fHutWPD090bBhQzX0J0hkybLUNQwICDDcTxq9HDp0SA0h78lSx1W/ZLlOnTqlrh9LxsM5h4iodHWI8yptHWJbxzmHiIjMFiiUZb8TJkwo985kzZs3V2dw//nnHzRu3FjdJgfKBw4cwKRJk8r1uYmIbsbL1R69G3upIXUHZRmyPmi462wqMrJ1y5RztcCByDQ15m24Ci9XDTqopigeKnhY2duxRDtao9GoEyZ5T5roA4qDBg3K12lZSkPI2LlzJ/r374877rjDsJTu7NmzKoBYVDY4ERGROeoQS01y/QohqTcupYWENWQTEhERVTRlChQ2adIER48eRevWrW/ryWXJnDQg0TcXkfovsrRO6nDJkA8JTz/9tMpelKChHNxKgFCW191111239dxERMYiJ01qBjqr8WBnP2Rk5WJPeOr1wGEKTl/J00ApLRfrDiWpIWoHOV9viuKOVtXd4Ox466YoeUnAr3v37jcePzHREDSU7MPq1asbvnb69Gl8//33hu/TZx3KkCXLkokgGYoyimMty8CIiMjy6eeUvDUh9YkCREREZEWBwrvvvlt175SlAtIBuWBmYUkDiD/++CMeffRRdVkOUPWdTV955RU1xP/+9z+VSXPfffchKSkJnTp1wl9//XXbNbjmzp2rhr6BCZuZsMivMbHIr3n3mSUU+W0QIEOKtTshOikHO89l4L9zmaopSnLGjaYoEkSU8e2Wa3B2AJqH6ZuiOKOqn32ZMrel67uMDh06qOv6JilyICYZiTExMUhISCi0ZHnUqFFYvHgx3n33XXWyRpqsFPTCCy9g6tSpsHSWUlhej3NOYSwsbzycc4y/z9jMxLRKs78tEeccy8c5x7r2pbme1xqaoFnCcQ6ZX3m/hnZaWTNX2m+6xYFrGR7SrDtYMmvkoNnWm5nIB7PyLhBbXs9him23hu3ha2i8/VBe+zI7R4vDF9JUpuHWkyk4dCFNLU8uShUfB3Su66EyDqUpiqeLcYrWShZ3wUYp8l4o9Wfla5JRuH//fuzbtw8bNmzAwoUL8y0Ds4aMQkt9b7fU7TIHvl9Z1760lc8N+qzqmy2FLfgeaMlzjjUFCj08PNTl5ORkq8sotNT3dkvdLnOoiO9X5sI5x7z7jHMOmeL9vUwZhfrsFCIiKuWbrr0dmldzU2Nir0qIT83BjtO62oayVDk68UYWnzRI+W1nvBr2GqBpmKshcNgoxAWaEjRFKYpkcEs2uAw9qW0ok42cCJKDYKkFK/dLTU3lMjAisunmGvqAoWBzDSIiIqroyhQo9PHxMf6WEBHZIB83e/Rr6qWGZGPLMmR9tuHu8FRkXm+KkpML7ItIU+OTv2LU93Wso+ukLKOSl+PtbUeB9/URI0bgxRdf5IkhIrLJ5hrFsYaMaiIiIiKTBwqJiMj4JJuvTmUXNcZ28UdaZi52n5OmKMkqeCidlfUkE3H1gUQ1RL0qzoZOyi2rucLJoXRNUQqyt7dXtQyJiGyJtZRXICIiIiovDBQSEVkoVycNutTzUENcjMtUmYYSNJTlyskZuYb7nricocZX/8bC1ckObWvqMg1lqXK1ACcz/hRERERERERkLWw2UMgOlIWxk5TxsBuYefdZRe0G5gagd10Z7sjOccORS1n4LzxDdVQ+EZUNfU+UtEwtNh1PVgO4gmAfe7Struum3KqqE9ycb51tyA6UxsU5pzDOOcbDOce8+6yizjmmxDnHuDjnFMY5x3g455h3n3HOIYvtelyRsBvYDewGZjzsBmbefWaL3cCuJWdjmzRFURmHyYhNzinyfrIiuUU1N7VEWbIN61V2LrIpCjtQlg/OOTdwzjEezjnm3We2OOcYG+ec8sE55wbOOcbDOce8+4xzDlls12MiIrIsfh4OGNTcW43cXC1ORElTlGQVONwbkYrs63HD7Fxg17lUNeasi4G/hz061tYFDTvUcYe/B6cFIiIiIiIiW8UjQiKiCkYyBBsEu6jxSLcApGTkYudZXbahNEaJvJZluK9kHv6xP1EN0TDYBZ2lIUqYPaBxAHKzzfiTEBERERERkSkxUEhEVMG5O2vQo4GnGuJ8rDRFScaWUyn470yKqmmod/RSuhqi3jPbkBKxA0v3JOH+Lm6qKzMRERERERFVXAwUEhHZmKr+TqjawQ/3dPBDZrYW+8+nYovUNjyZjOOXMwz3s3f2gFfdXliyNxkPdK1s1m0mIiIiIiKi8sdAIRGRDXNysEPbmu5qTO4XiJikbGw7lYxNRxOwatcFOLj5oUMtV3NvJhEREREREZmAzQYK586dq0ZOTo6he5D+sq0yRav78noOU2y7NWwPX0Pj7QdL+50y5aTQtQbQKtAeHz7QBS6VG+KOB1ar90hrYmmvH+ecwvh+ZTycc8y7zzjnGKfrsZ7MN5mZmbAmnHMsH+cc69qX5npeazhW5ZxDpvh7sNNqtTeKU9mg8m4rbU1M0eq+vJ7DFNtuDdvD19B4+8HSfqfMcdDm4eGhLicnJ8Pd3R3WxFLf2y11u8yB71fWtS/N9bzW8LmBc87t45xTPjjn3MD3K+PhnGPefcY5h0zx/q4x+iMSERERERERERGR1WGgkIiICslbiuHff/+1+dIMRERUfjjnEBERWQ4GComIKJ+lS5eiadOmhusDBgxA7dq11e1ERETGxDmHiIjIsjBQSERE+Q7YRo4cqQKF27dvR1JSkvq/SZMm6nYGC4mIyFg45xAREVkeBgqJiMiw9GvKlCkYNGgQli1bhvbt26uGJvK/XJfbn3vuOS5DJiKi28Y5h4iIyDIxUEhERMrmzZsRHh6OadOmQaPJPz3I9Zdeegnnzp1T9yMiIrodnHOIiIgskwNs1Ny5c9XQF0+WNuN5Cynbaotta30OU2y7NWwPX0Pj7QdL+50yhdOnT6v/GzduXOTX9bfL/Zo1awZLZmmvH+ecwvh+ZTycc8y7zzjnlA3nnPLDOacwzjnGwznHvPuMcw6Z4u/QZgOFEydOVEN2sLe3N3x9feHl5QVbJ/vBWp/DFNtuDdvD19B4+8HSfqfKmzQsEYcPH1bLjQuS2/X3s/R9Y29vD0vCOadofL8yHs455t1nnHNKj3NO+eGcUzTOOcbDOce8+4xzDtmX87EOlx4TEZHSpUsXVK9eHTNnzkRubm6+vSLXZ82ahRo1aqj7ERER3Q7OOURERJaJgUIiIjKcmZo9ezZWrlyJYcOG5et6LNfl9vfff9/isvWIiMj6cM4hIiKyTDa79JiIiAobPnw4Fi9ejMmTJ6Njx46G2yWTUG6XrxMRERkD5xwiIiLLw0AhEREVOnDr1auXqt8qVq9ejT59+jCTkIiIjI5zDhERkWXh0mMiIiok7/Lirl27MkhIRETlhnMOERGR5WCgkIiIiIiIiIiIiBgoJCIiIiIiIiIiIhuuUTh37lw1cnJy1PW4uDjDZVuVmJhotc9him23hu3ha2i8/WBpv1OmlpKSYrgs74+ZmZmwJpb2+nHOKYzvV8bDOce8+4xzzu3jnGNcnHMK45xjPJxzzLvPOOeQKf4ObTZQOHHiRDVkB0vBfl9fX3h5ecHWyX6w1ucwxbZbw/bwNTTefrC03ylTcnJyyrcf3N3dYa31riwB55yi8f3KeDjnmHefcc65PZxzjItzTtE45xgP5xzz7jPOOWRfzsc6rFFIREREREREREREDBQSERERERERERERA4VERERERERERETEQCERERERERERERExUEhEREREREREREQKm5kQERERERERERERA4VERERERERERETEQCERERERERERERExUEhERERERERERETCwVZ3w9y5c9XIyclR1+Pi4gyXbVViYqLVPocptt0atoevofH2g6X9TplaSkqK4bK8P2ZmZsKaWNrrxzmnML5fGQ/nHPPuM845t49zjnFxzimMc47xcM4x7z7jnEOm+Du02UDhxIkT1ZAd7O3tDV9fX3h5ecHWyX6w1ucwxbZbw/bwNTTefrC03ylTcnJyyrcf3N3dYU3s7e1hSTjnFI3vV8bDOce8+4xzzu3hnGNcnHOKxjnHeDjnmHefcc4h+3I+1mHXYyIiIiIiIiIiImKgkIiIiIiIiIiIiBgoJCIiIiIiIiIiIgYKiYiIiIiIiIiIiIFCIiIiIiIiIiIiUtjMhIiIiIiIiIiIiBgoJCIiIiIiIiIiIgYKiYiIiIiIiIiIiIFCIiIiIiIiIiIiYqCQiIiIiIiIiIiIFDYzISIiIiIiIiIiIgYKiYiIiIiIiIiICHDgTiAiIr3Lly+rkZaWZrht//79cHV1VZerVKmiBhEREREREVU8NhsonDt3rho5OTnqelxcnOGyrUpMTLTa5zDFtlvD9vA1NN5+sLTfKVOZM2cO3n333Xy3de7c2XD5hRdewNSpU2HpLO3145xTGN+vjIdzjnn3Geec25eSkmK4LJ/JMzMzYU0451g+zjnWtS/N9bzWcKzKOYdM8fdgp9VqteX6DFawg729vZGQkAAvLy/YMvlg5uvra5XPYYptt4bt4WtovP1gab9Tps4oLI61ZBRa6nu7pW6XOfD9yrr2pbme1xo+N3DOMU6g0MPDQ11OTk6Gu7s7rImlvrdb6naZA9+vrGtfmut5OeeQtUgs5/d3m80oJCIi6w0EEhERERERkfGx6zERERERERERERExUEhEREREREREREQMFBIREREREREREREDhURERERERERERMRAIRERERERERERESnsekxERERERCZ3+fJlNdLS0gy37d+/H66urupylSpV1CAiIiLTYddjIiIiIiIyuQULFqBVq1bo3Lmz4Ta5LLfJkK8TERGRaTGjkIiIiIiITG78+PEYMmRIsV9nNiEREZHpMVBIREREREQmx6XFRERElodLj4mIiIiIiIiIiIiBQiIiIiIiIiIiImKgkIiIiIiIiIiIiBgoJCIiIiIiIiIiIgYKiYiIiIiIiIiISGEzEyIiIiIiIiIiImKgkIiIiIiIiIiIiBgoJCIiIiIiIiIiIgAOtroX5s6dq0ZOTo66HhcXZ7hsqxITE632OUyx7dawPXwNjbcfLO13iqz79eOcUxjfr4yHc4559xnnHOKcY/k451jXvjTX81rDsSrnHDLF34PNBgonTpyoRkJCAnx8fGBvb6+GrTPFPiiv57C0189c28PX0Hj7wdJ+p6j0r51Wq7WI3cY5p2h8vzIezjnm3Wecc2wb5xzrwDnHuvaluZ7XGo5VOeeQfTkf69hsoFAvNjZW/R8WFmbuTSEionJ4j/f29raY/co5h4io4uKcQ0REFWHesflAoZ+fn9oR58+ft6iDSXNo06YNdu3aVa7psRKQjYyMhJeXl1Vtu7VsD19D4+yH8vxdJdOQbPGqVasa3uMtBeecG/h+ZTycc8y7zzjnEOccy8c5x3r2pbme11qOVTnnkCnmHZsPFGo0GrUjJEho6wEBSV81xT6Q5zD285hq2y19e/gaGnc/lMfvKpnnPd5ScM65ge9XxsM5x7z7jHMO6XHOsVycc6xvX5rreS39WJVzDpli3rGsIygyew0ta2Vp226u7bG0/WCubbfm/UBkK6z579TStp1zjnn3maX9PhBRxfo7tbRt55xj3n1mab8PVDHZaS2l0ruZSIqxZBNK6iYzh7iviX8vfF+oGCz1vd1St6si4r62frbyGtrKz1mRWepraKnbVRFxX1s/W3kNbeXnrOgSy/l1tPmMQmdnZ0yfPl39T+WL+9r62cpraCs/Z0Vmqa+hpW5XRcR9bf1s5TW0lZ+zIrPU19BSt6si4r62frbyGtrKz1nROZfz62jzGYVERERERERERETEjEIiIiIiIiIiIiJioJCIiIiIiIiIiIgYKCQiIiIi+j979wEeVbW1Afib9N5DEiB0AoQWeq8CIl1AQRHBiooVsICKXe9VsaOi19+GKBaaiCAiJRB67y2F9N57JvM/a48ZEjphkpnJfO/zHJg5meSc7EnOzt5n7bWIiIiISLH6YiZERERERERERETEiUIiIiIiIiIiIiLiRCERERERERERERFxopCIiIiIiIiIiIgU5igkIiIiIiIiIiIiThQSERERERERERERJwqJiIiIiIiIiIiIE4VERERERERERETEiUIiIiIiIiIiIiJSWMyEiIiIiIiIiIiIYMc2IKoenU6Hv/76C4cPH4a/vz9Gjx4NHx+fq37ep59+ioyMjCr7nJycMGfOnDrxVpSUlGD16tWIjIxEo0aNVLs4Oztf8+dv3rwZ+/btQ0BAgPpcd3f3Gj1fIiJLERERgR07dsDV1RWjRo1CgwYNrvlzz5w5g7///lv1XTfffDOaNWuGuqC8vBzr1q3D0aNHUa9ePYwZMwZeXl5X/Bzpn5YsWXLJjzVu3BhTp06tobMlIrIcMsb5559/YGtrq/qNli1bXvVzXn/99ct+bO7cueprWbrw8HDs3r1bjVGkLw4KCrqmz0tISMCGDRuQmpqq+poRI0Zc1xiJqDYxopCoGkpLS9Uk1n333acu+t999x1at26NQ4cOXfVz33vvPTVYKyoqMmzFxcV14n3IzMxEjx49MH/+fCQlJeE///kPOnXqpB5fTVZWFgYNGoTp06cjKioKmzZtQq9evdRjIiJrN3PmTIwcOVJdE+UmVatWrbB27dpr+twXXngBXbp0wfbt29WE4a233oqffvoJlk76zuHDh+Ohhx5CYmIi/u///g9t2rTB8ePHr/h5Wq22Sh8sW3JyMl588UV1s4qIyNr997//Rc+ePdVNGJkU69Chg7rGXs2F11bZPvjgAyxatAg2NpY/9XD//fdj3LhxiI6Oxh9//KH6YplMvZrffvsNLVq0wA8//IDY2Fi8+uqr6vnp06dr5byJrpuOiK7bRx99pHN2dtbFxMQY9o0cOVLXpUuXq35u8+bNda+99prRWr28vFwXHh6uS0lJ0dW04uJi3e+//37Zjz/yyCO6Ro0a6XJzc9XzoqIiXZs2bXRTpky56tcePXq0rkePHrqCggLDvoSEBF18fLyRzp6IyDKtWbNGJ3+yRUREGPY9/vjjusDAwCrXzEtZtGiRzs3NTXf06FHDvpKSEt3BgwerfT4HDhzQnTlzRlfTtFqtbv369bq8vLxLfvztt9/Wubu7G/oJ6Q+HDBmi69Onz3UfS9pJ2lj6UyIia3b48GGdjY2NbsmSJYZ97733ns7JyUn9bX49oqOjdRqNRvf8889X+3xOnz59Q33W9dixY8dlxx7Lli1T38vevXsN+x588EFdcHCwGiNdib+/v+7uu+82PJfXh4SE6G699VYjnj2R8XDpMVE1SAShhJrL0toKDz/8sNp37NgxhIaG1ni7njx5EosXL1Z3pmJiYgxLoC/1ul9++eWSX2P27NnXFPK+bds2dayff/5ZLfOSyMFLRWjIuTz++ONwc3NT+xwdHVXU5fPPP48vvvgCLi4ul/z6Bw4cwO+//67C8Sufz7WG8hMR1WXS50h0tkRZV3jkkUfw0UcfYf369Wq57aXIMmNZBvbAAw9U6Zfs7e1VdMj1iIuLU8t1pS+Q/kZSTDRv3vyi16WkpKjr/aXce++9qF+//lWPdfDgQXz//ff48ccf1RItidyX5daXaheJ7Kj4mhqNRkUXTpw4EWfPnr3k+V3ON998g5CQEPTt2/eaP4eIqC6Sv+e9vb0xadIkwz7pR5555hk1ppC/9a/Vt99+q/6/5557rusc0tPTsXTpUtUXSMqNTz755JL9lqQ8evvtty/5NcaPH39NYzLpL6Rvk00e79y585J9lfQ5EmXZuXPnKn2x9HmyEmrYsGGX/PoybpK+rHL/4uDgoFZh7d2796rnR2QKlh//S1TLZEJMlhh37Nixyv6wsDD1v+TXu5ZB0DvvvKMGJhLSf61kACYDw+7du6ulzrLs7LHHHlMDuMt1hNI5VQ7/LygowLvvvovPPvvsipOEp06dUkuIZaA1cOBAtdxNlg5IuPzlcj5lZ2dfsl1keZhMoF6OLKOTDrNr165qICrLs2UQKku8iYisnfQrF15bZbmTXMOv1OfIEly5Zt90001qadSCBQvUNVb6kmuRk5ODr7/+Wn2+5FOSxzIJJ8uXZRn05dJIXLjsTAZRb7zxhsrHeznSj8lgr3379mpSVAZqshRYlhT7+fld9PqKfuVyffH+/ftxraS/k2XZ1zuQJSKqi6RfkWtx5aXCEgQgS2WvZZxz4eRa//79r+nGjfQXMhE5duxYFSwgy5/lc2XcJOk3LkXGHhf2ORLY8NJLL6nghitNRMpYqHfv3ur7Wr58OR588EGcO3cO3bp1u+a+uF27dirv4pXaRSZdJS+wTHhWKCsrw549e9SYjsgcMaKQ6DpJhyR3r3x9favsryhkIneMrkQiHioiJCQxvdyhkygLKXJyqQS/cqxly5apO2oyoda0aVPceeed6m7ftSQVljtfslV8rbvuuktFZkgUyoWkyIoMIuVYko9E7nQ99dRT6o7ipaIVK6v4vqvTLtIpS7ThgAED1B08+WNC7hzKeUqUoSSoJyKyVnL9vPDaWjH4uNq1VcjNIXndkCFDsGrVKjXgkkiNS0U/SBTimjVrVD8gr5VruPQBMokneQ6vRqLyKiezl0JdMnn4559/XlTwKz8/Xw3oJIpDojHatm2LKVOmqD6ucsT+5QZ5Mgisbl98YcSL9L/Tpk275s8hIqqr5Pp5qYJXcn29nmurFP2QCD2ZtLuSLVu2qAnFX3/9VV2Lb7vtNpXPvV+/fmrcdCUyPqnc50hAhaymknGSTOJVJpNzK1asUH2O9HMNGzZU/c1XX32l8ttWpy+W8/X09Lxqu8j3JuM9yREsx5LxjfSX0j8TmSNOFBJV04Ud19U6ssrJbCuHzsvgSSIzJApCli9fSKIX77jjDnUnTxIBSydTHRJJKCH4kjR369atasLxQjJJKBGKEjkiCd2lg66NdpHBngwkJXLx/fffV/tee+01FTEzb948/O9//7vu8yAiqksudS292vW1IppCIgglwk4it4UMwiR6TiYSL7xBJTfDJI2GLE+Wwd1zzz1XrSqVcuwZM2aoG10yILpUhMbGjRtVnyYDL+kbZRlxbfXFlc9TJkVvueUWprsgIrrCtfR6r6+ycsrDwwMTJky44uskfYZEsD/66KPqptSVos+vRAqESCFF6XcuFfUu0fDS/0k0vqySkmXDtdUuMv6S/lWiNCUi3s7ODvHx8Wq71I1AIlPj0mOi6yQdngygJJrhwmg8caklUpVdmF9DBieybPhy1SvlbphUGZNBlkQfyudLKH5FpMi1kI7p5ptvVku7LjdJKCqiRuR7lEm7wYMHq7tsMol3NRXfd3XapSJaUSZEK8jdOWkbuctIRGTN5Pp54bW14vp6LddWGaRVTBKKyZMnq6h2ifS4kFz/ZemXXH9feeUVFfEgVZOvVkm4MkkbIddzqQgp1/DLLeOSKPKFCxeqY8iNLIli//DDD5GUlHTVY0hkiwy4qtsXV5Al2bI8u7o34YiI6prq9jkXBihIXyL9zeVylFeQyHLpM2TMIWMUWc0kK5uulUTCz5o1S0XnVQRgXIpESUrkogRCSJ5FGX9JWgxJr1TddpGUVDLOulK7yASlRMs//fTT6qaYpAGR/O9NmjRRN8jk/InMDScKia6T3AGSvB0S6VeZ5M+onB/pun4RbWwum0dD7qpJ5IcMZqRoiXQ0EjIvnYvk7fj8888v2ZlXkFD4QYMGqbtXMmC7UoEQGVRKJybfm0SfyDIziSgJDAxUofISNi+5Py7X+coA81LtIgPUKyUTrkgKfOEdOWmX6717SURU10jOvguvrRKdUFhYeMU+R5bySlGpS11bxaWur/IxyUO4cuVKlR9Qil5J/yPXcDkPya8rN50uR85J8kvJIE9uTMk5XI67u7uK6JA0HPL9jBgxQqWdkOVgsixalgRLlMnl+kbJ1XujfbFEvEjfJ1GURESk73OOHDlSZQJLUkXIhNe1Xlslqi83N/eabsLI9V6WCicnJ6tgCMnfLmmT5CbSyy+/rPLIXo5M1N1///1qAlD6KrkBdTkyHpk6dSrWrVun+jH5PBnbyBhGioVJ/3OlHL6X6oslV64sab5Su0jRRnmNBGBUJvl/ZZLySuM4IpMxYgVlIquxYMECnaurqy4uLs6wb+zYsbqOHTtWed3ixYt1X375peF5VFSULiUlpcprNmzYoLOxsdF9+OGH13UOBw4c0M2ePVtXv359nb29ve748eMXvebcuXO6Vq1a6QYOHKjLycnRVYdWq9WtX79eN23aNJ27u7vOz8/vsq994IEHdE2bNtUVFBSo5yUlJbp27drpbr/99iqve//993UrVqwwPJfXBwYG6p5++mnDvtzcXPW9Pfjgg9U6byKiumLlypUyWtPt3r3bsE+u//7+/rr8/HzDvtWrV+veeeedKp87ZcoUXYcOHXSlpaWGfXfccYcuODhYXd+v1ZkzZ3Qvv/yyrmXLljqNRqNbs2bNRa/Jzs7W9evXTxcaGqqLj4/XVdf27dt1jzzyiOpvnJycdGlpaZd83RtvvKHz9PTUJSUlGfYNHz5c17179yqv+/bbb3Vff/31RZ8v/aKLi4tu1qxZ1T5XIqK6RsYYcp3/5ZdfDPs+/vhjnaOjoy42NtawLzw8XPfaa6/pioqKLvoaN910k+oLqishIUH37rvvqrGV9H+ff/75Ra8pLi7WTZw4UY0Xjhw5Uu1jyec+++yzql+0s7PT7dmz55KvW7p0qRqzHTx40LBv5syZ6viV20DGODLWqXD48GH1PXzxxRdVvt7kyZOvOK4iMiWN/GO6aUoiyyRFQSSsXe6sSai8RDBIxUQpEFI52bskjk9LS1N3koRUxJKkuXJHSkLrpVKw3HGTsHwJt5clzddLIhEl/5MsSQ4ICKjyMdkn5yjh+JXzfUgOQrmjdr0kUkSWkkm0yaXI9ypRjhLBIu0jiYjlzpwkM27QoIHhdRKhKG0jkZEVpFCLLD2TJdJSfUySDUsOEbk7eGECfCIia3PfffepKD+JMJdIP1m+JAVJJLdThYroiMrpIiRCQyIspDjU0KFDVbS4RPvJ50u0eXVI5Ua5Lku0R2VyDZdzlFy3lZdhSeTgE088cd3HkSXMkpZDzlPy9F5IItylz5AcT5I6QypI7t27V/UbldN89O3bV0VzVK44KaTflTaTyJkrRT4SEVkbST0hEeQSESirkiRi77333quST12KiEh1+szMTHh5eRn2SzoHWfkk6YwkKv1GyTVaxl4VK5AqyPhGcptLv1i5+IpEy1cnv65Mi0iOdhmHSGT7pT4uRSFlfCPFryQNlBT9krHc8OHDDa+reE3lNBqyYksKrUiORBmHSX8kY0fJkXu1HI5EpsCJQqJqkgk66RwOHz6sBkRykb+wOq8saZJQfakwWXmyTSptSUUueb2E1l9YlctY5yfLhi91L6Bjx46qo6oJ8v1JhymToMHBwWpS8cIBniwrkMrGF044ymBPJghlqZlUBJOlYLLUm4iI9Pn0ZHAh+Z5kee+F+Wbl+ilLtp5//vmLrsvLly83XJdlie/VKtlXh+RdkgHjhWTA9dBDD9XIWyjLzmRyUr5v6VOlL74wV9SXX35pKK5S2U8//aSWn0llZiIiqkpuKkkwgky4Sd7aC8crMqkmQRKSx7ZyQILcsJE+R24Q1URfU0FyuEu/diEZd8hEYU2R4AZpG7kJJjkGGzVqVOXjcsNOcgA/++yzVfbLsmXJTShLjSWAQtpUgieIzBEnComIiIiIiIiIiIjFTIiIiIiIiIiIiIgThURERERERERERMSJQiIiIiIiIiIiIuJEIRERERERERERESk2+v+IiIiIiIiIiIjImnGikIiIiIiIiIiIiDhRSERERERERERERICdtTdCeXk5EhIS4O7uDo1GY+rTISIiI9DpdMjNzUX9+vVhY2M+wfPsc4iI6h72OUREVJf6HaufKJRJwuDgYKM3LBERmV5sbCwaNmwIc8E+h4io7mKfQ0REdaHfsdqJwoULF6qtrKxMPT98+LCKKrRmMiNd021QU8eojXO3hPPhe2i8djC3nym6/vevffv2ZvMess+5GK9XxsM+x7Rtxj6H2OeYP/Y5ltWWpjquJYxV2edQbfQ7Gp3ELFqxnJwceHp6Ijs7Gx4eHrBmmZmZ8Pb2tshj1Ma5W8L58D00XjuY288U1Y1ru7melynwemVZbWmq41rC3w3sc8hcr+3mel6mwOuVZbWlqY7LPocsRU4NX9/NJ3ETERERERERERERmQwnComIiIiIiIiIiIgThURERERERERERMSJQiIiIiIiIiIiIuJEIREREREREREREXGikIiIiIiIiIiIiBQWMyEiIiIiIiIiIiLYsQ2IiIjoemm1WoSHhyMxMRFBQUHo168fbG1t2ZBERERERBaME4VERER0zWRi8IcffsAHH3yA+Ph4w/4GDRrgySefxJQpU9TEIRERERERWR6rnShcuHCh2iQiQmRmZhoeWyo5/+3btyM5ORkBAQHo1avXdUV35OTk1Oj51eQxauPcLeF8+B4arx3M7WeKLPv9q0t9ziOPPIIVK1Zg1KhR+PXXX9GuXTscOXIEr7/+Op5++mls27YN//d//3fVr8PrlfGwzzFtm7HPIfY55o99jmW1pamOawljVfY5VBu/DxqdTqeDlTewp6cnsrOz4eHhAWuO7pCBq7e3d42ea00dozbO3RLOh++h8drB3H6mqG5c2831vK6VTG42bdoUYWFharLQxuZ8quPy8nKMGzcOBw8eRGRk5FVvVPF6ZTzsc0zbZuxzyFyv7eZ6XqbAPsey2tJUx7WEsSr7HKqN6zuLmdQBMhkoURydOnVSEYW5ubnqfxnIyX75OBER0Y2SnISxsbGYN29elUlCIc/nzp2Lc+fOqdcREREREZHlsdqlx3VFxXLj0aNHV4nu6NmzJ1atWqWiO3bs2KFexyTzRER0oxHsQpYbX0rF/orXERERERGRZWFEoYVjdAcREdWWijQWkpPwUir2s5gJEREREZFl4kShhWN0BxER1ZZ+/fohODgYb775pspJWJk8f/PNt9CoUSP1OiIiImPKyCtjgxIR1QJOFFo4RncQEVFtkRQWvXr1wu+//44xY8dWyYs7Zuw4rP5jNep1uwPxWZZZ0ZmIiMzToXOFGPSf05j7cwJOJhaZ+nSIiOo05iisI9Edb7zxJlauvLgCpUR3BAczuoOIiIzjgw8+QLdu3fD++x+gd+/ehv3OPg3RcNwHKGg5FCMWnMWgNm6Y2scH3Zq6QKPRsPmJiKjavtmajjItsGp/ttp6tXDFtL4+6Bviyj6GiMjIGFFYR6I7Vq++fHSHpuuTeH1VCs4kF5v6dImIqA5Ess+ZMwfnzsVgzZo1ePjhh/H+59/j6UXbUa/dMPUanQ7451ge7vnyHCZ+HIUVe7NQUlZ1qTIREdG10Ol0aOxjB13SbmQf+wP5MbsQcSoHD30Ti3EfRmHZHvYxRETGxIjCOhTdIf9fKrrDrdVQ/LwrS209m7tgSm8fDGjtBlsbRngQEVH1b1Q5ODjAxcUFcacPICgvGf8d0hdnSpvg5105SM7R55I6kViM539NxHtrUzC5pzcm9fCGrxv//CAiomvLx/7DDz+ocU58fLxhv5N3Q/gNfBpnMBQv/paID9al4M5ePpjcwwteruxjiIhuBCMK61B0R0xMDJYtW4bZs2dj+fLlOHz0JB6efjtcHM6/zTvOFuCx7+Mw4t2z+CY8HdmFzCNFRETV065dOxXVbm9vrwZza1f9gvhNn+Dx0BOYP9ID7Ro6GV6bnqfFwr/TMOS/Z/Dibwk4m1rKZicioit68skn8fTTT6NTp05VVk4N6ROGuBVPIufkekMf8/H6VNz03zN4dUUiYtJK2LJERNXE2y11LLqjIkfh1q1bkZycjJE9e2LmTW2w+mAefojIREy6vtOMyyzFO2tS8Mn6VIzp7KnuwPk6mPgbICIiixIQEIAJEyZgxIgR2L17N7Zt24b09HRsDd8Me/sIfDN/Pk6k6PDd1gz8fTQX5TqgpEyHZXuysWwP0KtFEab28Ua/EDfYMMqdiIgq0Wq1alJw9OjRWLHifC72nj17YuXKlRgraZe2voWRI4ZjW6RW9TFFpTos3alfSSW5cqf39UXnJs5sVyKi68CJwjqmTZs2SEtLw4kTJ3D69Gm1ubu7o3v37vjunu44nuaIxREZ2HoqX72+8N/OVLYujR0wvb8dlyUTEdF1cXZ2Rv/+/dG3b1/V/8jNKg8PD7W/U2OgU2MX/LPjMHal+GL5vlzkFevzFW4/k6+2Jn4OuKu3N8Z28aoSBU9ERNYrPDwcsbGx+Pnnn6sUbBTyfN68eSrtUub6F3Hv4LHI8euH3w/lo7BEZ8iVK5tEt9/WyRHjenjBzpapl4iIroYThXVMSEiI2jIyMrBr1y7s3LlThehv2LBBPX7xxRfRr1UjRKUWY8n2TKzYm42CEv2AbW9MCfZ+H4eG3va4o5c3xnf1goezram/JSIishAycAsNDVWbRIJUSEhIwJpfv4WTkxNmd+6OTLdO+G1/IeKz9K+JTivB66uS8dFfqZjY3Rt39vJGkJe9Cb8TIiIyNUlpUZHm4lIq9ufl5SEv5SxeuH8SnhwB/LIrU62kSvk3V+6RuCK1LQovwF19vDGhqxfcnDjGISK6HE4U1lE+Pj4YPnw4hg4diqNHj6qw/QYNGqjlyaKxrz36eZ3CPTPb45/TOvywPQPn0ksvuyy5RYCjib8jIiKyJBX9jcjPz4efn5+KeN8VsQUaTTjGNm0Gj86D8E+0M3ZFFqjX5RSV4/+2pOPbrekY1s4Dd/fxQYdGXDJGRGStedjFkSNH1HLjC8l+cf/996Nt27aq3/F0Bu7p6438Q0tR1KgzdqT641SyfoyTkFWKt/9Iwad/p+G27l6qwCNvShERXUyjk3rzVmjhwoVqk4iHU6dOITo6Wi2TqsvkrdZo9OH2kZGR+PHHH9VziUAM69QZ0QVeWHMC2BV1cfLfro0dMLGLC3o1c7yhask5OTk10s419XUt7Xxq47iW8B4a42uZ288UXf/716RJE2RnZ5vF+2iNfc6l+iDpeySX4dmzZ6vc2Oo25Db8ddoe648XovSCGlvt6tvjtq4uGBDiBLvr7H8s4XplDOxzTNtm7HOIfU7NkD5TipiEhYWpnISVlx+Xl5erHIUHDhzA/v37q9ycOn78uCrwKOztHeDZog8O5zfBgcSqy5dtbYDBrZwwuZsrWgXeeBQ7+5yaxXGO8drB3P6OIfPrd6x2orByA3t6eprNYLK2yCBt7dq1iIqKMuzz9vZWeT7qNQvDioPFVZYlVwj20S9LvrVL9ZYlZ2ZmquMYW019XUs7n9o4riW8h8b4Wub2M0V149purudV21JTU/HPP//g8OHDqmLy888/Dzs7O6TmluGHban4bU8uMvKrzhgGetqp6I+J3a69/7GE65UxsM8xbZuxzyFzvbab63ldj0mTJqkchSNHjlR9hSw3lkjCN954A3/88Qduv/12LF26tMrnlJaWqsnDzZs3q+KOQoIjgkK6IdYhDBtPl6NUW3UI3K2ZC6b39UH/VtUvrsU+p2ZxnGO8djC3v2PI/K7vXHpspZo3b46ZM2eq3B87duzA3r171QVDOlxb27WYPXs2Hh/WQk0WLqm0LDk2Qx+y/7EsS+7kqQZtzetxWTIREV07f39/DBs2TEWDpKSkqElC4etqg8L93+BOf39oO/TG35GOOJ2sj3JPyi7Dgj9T8OmGVIzr7IWpfXzQ2M+BzU5EVId98MEH6Natm/pfAhoqSEqld955B1OmTLnoc+QGlBRylM+TKH6ZMJT/E07ugi12YcnDT2FDpAN+2pGJrAL9TandkQVqa+rvgLv7+qhxjpM9i2sRkXXiRKGVk9wft956K0aMGIGIiAgcPHgQJSUlahAnd95kINYzIAPRBfXwy558bDv9b7XkkvPVknu3cMWdvb3VHbgbWZZMRETWRYqbNGrUyPBcqltKMa709HTg9Al09/HFiG4DsS8rCOGnCw39z487MvHTzkzV78iArkczF0NqDSIiqltjlTlz5uCpp55SVZAlyEH29evXr8py40uRfqFVq1ZqO3HihFqmnJWVhdDmDRDaHLh/gC+++us01pywRcy/QRFRqSV4ZXmSKq41uYe3Wknl68YhMxFZF171SHF0dFT5PwYNGoSCggLDgKu4uBjffvONyhFyU1gYpk3ugY3Rjli5L8ewLDniTL7abnRZMhERWbfGjRvjueeeUzeudu3ahYyMdGRE/AYfBwc83q4XYu3aY+3RIhSW6iCJUzafyFNbSKCjKnwyoqMHHBkBQkRU58ik4MCBA6v9+QEBAZg8ebLKbVihvLQQ8du+QWdbOwwOHYwDuY2wP1YfxZ6Zr8Vn/6Thqy3pGN3JE9P6chUVEVkPxlPTRVxcXAyPZc27l5eXyvUhCeiXf/8JXCN/wn+HZGLOcF81OVihYlny4P+cxmsrk3A2pZitS0RE18XX1xejR4/GCy+8gAkTJqjBnUS6n96/Gff3ADbMbYnZt9RTOQsrnEoqxgu/JWLo22ew8O9UpOWWsdWJiOjiwW+lgiiSdklyfBUVFSLp4B9oEPMF7m1xEoNa2qlCJ6KkTIffdmdhzPuRePibc9hxNl8V5yIiqssYUUhXVK9ePZWvMCYmBtu3b1dLk+Pj4xEf/6uKQnx78h3ItG+MxRGZiKi0LFlyfsgmy5Kn/LssubqJgYmIyPpIH9OrVy/07NlTFeCSKpYScSgR7/f290WDov04kuGK3Wn1cDheHwGSnqfFpxvS8OWmdIwM88DY9nbozlzdRER0CQ0bNsQzzzyDY8eOqTyGUuQx8fhWOGErpjZpi/yAgVhztAT5xfooxC0n89XWpr4jpvX1xfAOHrC35fiGiOoeThTSVcmgTEpvyzZmzBjs2bNHTRqmpaWhflAgOvi5Y0BrdxyMTMPKgyVYdSBHTRZealnyoOYAx2xERHQ9fVCLFi3UVqGwsBCbN/2jIg2bStL6Vn1wtrw1ws+WQlsOVc1SinGt2At0b1ao8hgO4A0rIiK6RIShVFKW7dy5c9iyZQsOHTqEtNgTeP7uCZgz2hW/7s7C4ogMJGbpo9WPJxTjuZ8T8P7aFFXY8bbuTLtERHULJwrpuri6umLAgAHo37+/iiz08/MzfGz/ltUoPXsWz3TqgTSX9lh1uFQtR65SLdleg7FdSnFnL29WSyYiour98WJnh3HjxmHr1q1ISEhAwpFNcMYmTGnUBplePbEpyg65RfoIkF2RBWpr5GuPu3r7YFwXL7g6MvMKERFVJcW17rrrLlVUS1ZTeXh4qP3T+/nC7tw6xAUFY09WEI4n6sc3yTlleG9tCj7/Jw3ju3pibHtbeDMigojqAE4UUrUjPCRcv0JZWRmSkpJUlMeuiE0ANmF0s+ZwbtsHEYme2H6mQL1OEtAbliW3dMWUXlyWTERE18deogi7d0e3bt3UUjGZMDxy5AhSzx0Hzh3Hi0NuQY5nJ3wTnoa4TK36nHPppXjz92R8vD4VE7t54c5ePqjvfT7PLhERkfDx8VFbBam0fGD/PgD70NzODj1C+uGUthW2R5WqwlpS4FHSMC3ZDgxtV4zpfX3RoZEzG5OILBYnCsk4P0h2dirHx8mTJ7Fjxw6V6yMq8iwQeRYN3dzwyoCbcby4KVbuzVKThUJyGsomy5JlwHZrV0+4O7FaMhERXftNq2bNmqktKytLpcWQasl9enZRhbiGtQK2HM/FbweKsT9OP2EokYZfh2fgu20ZGNLWHVP7+CCskbP6WkRERJfK2S6RhpLHMDY2FsnHNsITGzGtWRiSXLti4xmguEyHch2w7nCu2jo1dsb0fj4Y1MYdtszTTkQWhhOFZNQcH23atFGbDNh27typtpycHAS6aTFxeCCmdbfHP6fL8eOObMRlnl+W/N8/kvHR+hSM6yxRHt5oVs+R7wwREV0zmRi85ZZbMGzYMNja6m862Wg0SD++HoFRJzCpYTskuXTF9lg7VcVSchlWDOjaN3RSeQyHtmNieiIiqkr6lLCwMHTs2BHR0dFqwvDo0aNIjjwADQ7gw9un4khuffwQkYHMAn3ai/0xhdgfE68CIqR/kbQXLg5Me0FEloEThVRjA7abb74ZQ4YMUdGFFUno3Z1s0MbxDHoX/QWP9gNwMLchdkcXq49JAZQfd2SqTZYl39XbG/1CWC2ZiIiuXcUkoSgvL4ezs7O6kZUTdwQuOIIRHvVQHDwAO1O8kJGvH9AdjivC0z8lINAzRRXemtjNG14ujHAnIqLzJPK8adOmaktNTUV4eLhaTdWrc1v0s7PDrR1ssXp/FlYcLkdU2vmAiDdW6dNeTO7hrQIi/D2Y9oKIzBsnCqnGB2zt27evsu/gwYPIzclG7r5VqGdjg3ubd0aCY0dsjtKcr5b877JkST4vy5LHdeGyZCIiuj4yQThlyhSMGjVKLUuW1Bh5OSlAzi/oYWsPr9CR2JddHycT9TeskrLL8P7aVHy+IQ1jOnuqZclN/RnhTkREVfn7+2P8+PHQarWGG1T2Njqk7l2K9jm56NdqEI4WNsXec/oJw5zCcnyxKR3/F56OkR091bLkkEAnNisRmSVOFFKtu/fee3H48GE1aIuMjETi6T3QYA9GeQdA27Q/dqX6Iu7fasmSfP4/q5Px0V+pGNvZk8uSiYjounl6emL48OEqyl1uVknxE8kzNaSVHZ7v0RS7owrwbXg6Np/MV4npJZfu0p1ZauvfylVNGPZq4co8hkREdNko9ry8PDg4OKC0tASpR9YhQKPBtBbdEefQEZvPalGmhdpW7stWW+8WrpjWzwd9WrJ/ISLzwolCqv0fOjs7dOrUSW3JyckqwmPPnj3Iy0xGq3qH8PLs+xF+Mg8/RGQi4ky++hypJlaxLFk607t6+6BviCtsmByYiIiuo//p0qWL2mJiYhAUFKQm/7o3c0VZ0kE4R25Hnn8/7EnxMBTe2nIyX20tAxzVhOHIMA+2NxERXcTDwwOzZs3C6dOnVR5DWZaccnonHLATkxuGoChoIP46oUNOkT7thYxzZJP+ZVpfff/iYMc8hkRkepwoJJMKCAjA2LFjVQJ6ifLw8fFRlcEGtnFHWJAW73z+BzI8e2BXoguK/h20bTudr7bKy5KJiIiuR+PGjas8P3ToEJCfCLf8n9Hf1hll9fvjUF4wUvP0fc/p5GLMX5aI99elYGwHJ0wf6MY8U0REVIXcfAoJCVFbUlIStmzZgr179yI97hRmjh2KZ8Y1xoq9Wfhua4ahsKP0Ly/8logP/kpRY5tJ3b3g5cphOhGZDq9AZBYkTL9bt25V9u3atQvFaWfhmnYWA+2coW0wAIdyGyI5V3fRsuRb2jnhnoEuzCVFRETVcv/996u0GLIsWaINHWLXoTM00Pp3wTnbdjiVrl9elpmvxTfb87F41xmM6OCpqlm2qc88U0REVFVgYCBuv/12FRAhN6OaNGmiJhKn9PaBT85uHEhywIHcYBxJ0E8YpuVq1bjmy41pGNvFC3f38UFjPwc2KxHVOk4Uktnq378/3N3dVS7DhIQE2MWsRSdoUObTAfGOHXE8zd6wLPm3fQX4bV8klyUTEdENp8WIi4tTE4b79++HTeoejGlbiC6TJuP7bRn463AOysr1eaZW7c9WW7emLmpZ8sA2bioqnoiIqIKMZ/r06WN4XlhYiK3hW1BcXIzGNjbo3LI3IjVtERFZhvJ/8+T+tCMTS3dmYnAbN4wPc8AALx3z5BJRreFEIZktJycn9OrVCz179sS5c+fUhOGBAwegyTiIEIfjePWR5/Dr3nys2pdtyCVVeVnylH+XJbs5nU8yTEREdDUNGzbE5MmTVbXknTt3olmzZmga7Ix3JjfAfb0c8N+lB3GsoAHy9MWSVTEU2YJ97FUO3Vu7esLVkX0PERFdzNHREVOmTFF5DM+ePYvUk1vhjq2Y0rgtUt17YHOUDQpLdKq41oZjedhwDGjfsADT+/liSFt32NnyhhQR1SyNTieXIOuzcOFCtUlJ+1OnTiE6OloloLVmOTk5Nd4GN3oMuQMnS8NKSkrQt29f/dcs1OK/S3bhSEEw0gurzn0722swsr0zxnd2QSMfuzrVlqY6bk0dw5hf1xhfy1TvIRmHvH+yxCc7O9ss3kf2OXXnerVhwwZVhKsMdsj17IQoTSiS86v2L64OGozq4IyJXVwQ5FnzfQ/7HNO2GfscYp9j/sy1z0lMTFTplo4dO4bycn2Rk+59ByPJsb1aMZWWp99XIcjTFrd1ccGo9s5wcTRN4RP2OaZtM/Y5VBv9jtVOFFZuYE9PT7MZTJpSZmYmvL29Le4YEm340UcfQQcNshybIdWtG87muF70OqmSLJEeUjW5pqsl10Zbmuq4NXUMY35dY3wtU72HVLev7eZ6XqZgqdcrSYUhk4VHjx5FWVkZ5I+oXKfmSHXvjlNZLlVeK13NTW3d1bLkzo2da2zZGPsc07YZ+xwy12u7uZ6XKZh7n5OVlaVSXuzevRtPPvmk+jolZTr8vC0eP+3OR1R61QlDdycbTOzupcY2gZ76dEy1hX2OaduMfQ7VxvWdS4/J4vn6+mLQoEGqarIm4yy8i88iCF7I9OqJM0X1UazVD8y2nspXW2NfB9zZy5vLkomI6LrVr19fLUkeP368WpYcEREBTdZZeBSdRWPnQLh3vAOrD+aqAZ7kmlp/JFdtbRs4qcT0w9p7wMGOy8aIiOg8Ly8v1bcMHz5c5cwV0lcUn1mH0NRT6NuyP06UhWB3TJn6WG5ROb7ekoHvt2ZgeAcPtSyZhbWIyFg4UUgWz9XVFb1791YVxU6fPq1yGUr4vnvWWgTBAUE9pmBjlCPiMvUVxWLSS/DW6mR8+Fcqbu3iqSYNm/g7mvrbICIiC+t7Bg8ejAEDBqg+RyJBZBJx7NgGeGp4GX7emYnvt6Yiq0g/KXg0vgjP/pyABWtTcEdPb9ze3QtervwzjIiIzquYJBQStS5pl8q1WqSd2Ag/bMTUpp2Q4NwFWyKBUq1OFddafSBHbd2buWB6Px/0C3Gr8dVTRFS38S9UqjNsbGzQqlUrtUn4vuT7OHnyJGZOaIOnocHmE3n4bF0MjqXYGqol/7A9U239QlwxpZaWJRMRUd1ha2uL9u3bq60iv5SPmx2GNsnBqT+/QbpjKzWoS8jX35BKySlTN6oWbUzD6E6eally83q8WUVERBdPGj766KMqP/u+fftw5MgRpEXthwP2Y0JAY5TWH4wNkfbIKtCq1++KLFBbM38H3N3XB2M6ecLR3jR5DInIsnGikOps+P6wYcPUVmFAKxds/XUZfEptkOgUhnO6pigt13ee4afy1SbLkqf09sbYzqyWTERE13/DqkJxcTH8fLxgk3EcfsXH0UgTiHSvXjiT56PyGhaV6vDLriy1SQ5dmTCUm1U1lceQiIgsU8OGDdXNqPT0dISHh6tgiOzkGIzvk425t/XEqv3Z+DY8Q62aEpGpJXh5eRI++itVRbBP7umtbmAREV0rXjHIapSWlqJr164o37UL7nmb0BQRiLNphQTHDsgpc1KvkQ72zd/1y5LHdeayZCIiqp7Q0FC0bt0ax48fV8uSJTWGd+Zy1Ic7Uty6IlrXHIUluio5dJvXc8BdffRRIE6MAiEiogvyso8bN04FQshkoYxrHBxsMKmHN5rZRuKvg+k4WtgUB+P1eQwz8rVYuCEN/9ucjjGdPVWe3GaMYCeia8CJQrIaTk5OGDFihOpcJXRfchnanz2MJoVHkKIJRrZvH5zN1leszC/msmQiIrrxCMO2bduqLTk5Gdu2bcOePXvQyOkwvnp8GFbsy8EPEZmI/zeH7tmUEryyPAkfrktVOQzv6OWNeh61W82SiIjMm4uLCwYOHGh4LmkvNv6zAZkpKWig0aB9s244Z98R26LKoS0HisvOR7APaO2m8hh2a+rCCHYiuixOFJJV5vsICwtTW0pKCnbs2IHdu3fjoamBKLD1xZLtmVi5LwvF+ptxhmXJTfzOV0t2ddTnOSQiIroWAQEBqlKyFN7KyMiAp4s9pvX1xaRu7njsje8QY9sO8UWe6rWSb+qLTen4vy3pqpql5Jpq28CZDU1ERBeRlBXSv2zevFlFsaef3QVX7MLt9Vsiy7s3tsQ4qCAIITnbZQut74Rp/Xxwc3sP2Nsy5QURVcWJQrJq9erVw5gxY1SkYUWVsZduDUKj/K34/VA+4uzaI1+njzKMTju/LFlfLdkHjf0cTPwdEBGRJXF2dkaDBg0Mz2Oio+BZcAIdcAKN4Ysk166ILm2Acp2mSjXLLk2cVR7DwaHusL1K0a3ExES1abVa7N+/H2lpafDz80OnTp1U8ZWgoCC1ERFR3ZgobNGihdokel3yGEr0elbCaSDhNB4O6wZN4yH4flsGkrL1kRDHEorw7NIEvL82RRV0vK27F9ydGAhBRHqcKCT6N8qwMj9PJ7SxP4CmxUfVsuRztu2QptEPquSO3OKITLX1b6Wvlty7BaslExHR9WvVqhWeeeYZREREqOh2z/x1aAwXJDi0R6xtaxSU6funvdGF2Bsdjwbe9qro1oSuXnC7zKBu0aJFeOWVV1TfVlZWVqWvk+cvvfQSXn75Zb5dRER1MHp94sSJGD58uOpXJOVFn+6dEBLiq8Ysq3an4IcdOTiZrO8bZOJwwZ8p+GxDGiZ088LUPt5o4M1ACCJrx4lCoksYPXq0ymUokRiSyzAgfg1y4Y0Ym1Ak2rVEmU4/ONtyMl9tXJZMREQ3Et0uCeplYCdRIDKwc0rdicbYg3bDH8HKw2Uqf6GQfIZv/5GChX+nqeh2KX7idkGAYXBwsIowkWXO8+bNQ7t27VRu3jfffBOrV69WHyciorrLzc1NjWUGDRpkCIiQJcaOabvRPGELujbvjTO6UOyM0aqPFZSUq4jDHyIyMKydO6b180WHYKa8ILJWnCgkugxHR0f07NkTPXr0QGxsrMpluH//LjzczwMZrmEql2FCVukllyWPamsLb282LRERXV/Rrb59+6J3796qSnJUVBSGD2mMe2/SYdvpfLy34iROZp4vuiWR7T9sz0TfFo64f5CjWp4sSe1ff/11jBo1CitWrFAFVYT0Z/JcJiTfeOMNTJ8+XS1DJiKiusvevmpBrPT0dOjKy5Fxeit8sBV3NGyLVPfuCI+2VUVPynXA2sO5auvcxBnT+/piYBu3q6a8IKK6hROFRFchURmNGjVSm0QaVuSYkuTyX/95GN9uSUWGTf2qA7cIoF+rQi5LJiKi6yaTe7IkWbaKfqhDYDlapC2Ff7kH4uzbI96mBUrLbaDTAeGnixF+OgZt6juik+MxREdH48cffzRMElb+unPnzlUTkZLDqnLVTCIiqvumTZuG+Ph4bNmyBQcOHEBW3FHY4yjG+NRHacPBCI91QXqePspwX3Qh9kXHoZGvPe7u44NxXbzg7FC1X6mcF/dymBeXyPJwopDoOsgEYQW5s9bMOQ298ReySj3UsuQE2xbQwg66SsuSm/rrqyWP7cxqyUREVP1oQ4kGlGXJ7snhaI5diLVphXiHDsjXOqrXHE8oxo5jJ9RjWW58KRX7rzSoIyKiuksKat1xxx2qmKP0KZJmKS8jAX1DozH/mTH4/UA2vt2agch/U16cSy/F66uS8fH6NEzq6YWRbWyqrJyqyIt7OcyLS2R5OFFIdAMGDx6sliZLAnrpZBPTdyPOppWaNCzSuKnXRKWW4I1VyfhwXSrGsVoyERFVg4ODg4oE7NWrF86cOYOtW7fC8dhhNC06giRNE2T59kNMth3sXP3V6yUnoSw3vpDsF6x6TERk3Tw9PdVk4U033aTGMm3atIGjvQ0mdvNGZ78sLFkfiROlLbE/Th9hmF2oxRcb0/H1FmBUWAmm9fVBy0AnzJgxQ+VEfP/995GQkFBlQvLJJ5/ElClTTPhdElF1cKKQ6Aa5urqq5Vv9+/dXgzeZMDx05Bfo/Dsj07sXdkUWqNflVcondVOoO14ZHwQvF+aHIiKiayfLkFu2bKm2jIwMVdVy7969mPNYM5xM1eCbcBf8b21DvP7Gm1i18nyOQiH5C9966y00bdoU/fr1Y7MTEZHKyy75cSsL37IFWacOIxAbcUejMCQ4d8G2aKCsHCjVAsv3ZqutT0tXNCkIxwvPPKNy4/72229VCmg988wzaNasGcaPH8+WJrIgnCgkMhIZjIWEhKjt3LlzqsJY/fr1cSqpSOUx/H1/ln5Zsg74+2gucuSu3L2NVAUyIiKi6+Xj46MGZhJlKDetOrsCnZs0RvL6W/DL4v9hzNhxeH7e3EqDtrfwxx+r8eWXX7KQCRERXZZUS5axzaFDh5B17gBccAC3+jdGnn8/hJ9zQl6xJFoCtp7MwfdfPoeRIy9fQGvOnDkYO3Ys+x0iC8KJQqIa4O7uDu9/k3eEBDphcpss5O3+CbGaEETadECpxklFGv5ndTJeHBvI94CIiKqtctRgaWkpmgR5Y+TIkdi6batarlzByas+NI4eiI2NZWsTEdFlSRHHqVOnqsh1SXWxc+dO5KXGAKkxmBDUCPWH3oXvt2Xg5IFdKMqMw/PP/8ICWkR1CCcKiWqBn58fJo4ZrpYm7zq9CeHlQ6HT2OKnHZlwKknGXX3rMV8UERHdMHt7e5UTSvqbsSdP4p+Nm7EvpxGK3EPgEtwFzXw1mH5HpSz0REREV4hcHzNmDIYOHaomC8PDwxHWvjWG9fHBHb28Me+/m/D2jyygRVTXcKKQqBZUrgYmy8Pa9DuIVO9BatD29W4Nog4vw6evzuR7QUREN0wKlcgmeQgnTJiAtz/4DOuL26BQY4uoTGDRduDNhjqV75CIiOhqnJ2dVU526VckylDY2mjQzEdf6IQFtIjqlvNrVYioxkg1sHfeeUflLMzPz8eetd8i5sfpiPryFuSe2YR9tjchNqOE7wARERmVpMGYcc+d6Kb7B/Ya/YBu1f5sfLdNP9AjIiK6Vra2tioPe4WAgADVz7zxxhuqYFZl8vxNFtAiskicKCSqBVIJWap+denSRT3Ozc1V/w/pE4a4FU8i/uBfePS7OOQV6QdxRERExtKkSRO8+MTd+M/kYMO+d9ekYPuZfDYyERFVmxQrmT9/Pv744w9VsKTyOEcKaq1evRoPPj6XhUyILAwnColqmFarxezZs1VlSqn+JVXA3Nzc1P8rV67EqJGjkL75HZxOLMCzPydAW66vIkZERGQsEtE+vIMnHhzkq55LVzNrSRzOpTOanYiIqi8rKws6nQ7r1q1TBbQ8PDzU//9E7EfDcR9geUpH5DIYgsiicKKQqIZJ0t/o6GjMmzfvktXA5s2bi8KMOBTE7sWm43n4eH0q3xMiIqoRD/bzQHO3LPU4p7Acj30fh/xiRrMTEVH1Uyzt3bsX27ZtU3nZ7733Xtwx5W70fmIlPFoNRZ7OHc8uTUA5gyGILAaLmRDVsMTERPV/u3btLvnxiv3avBT1/5eb0tEiwBGjwjz53hARkZHp0N1uO5J0vZCv8cKZ5GLM+yUR79/ZADY2LG5CRETVK6AlunXrpiYKCwoKkFPmhNs/iUZ2oRabT+Th0w1peHSoP5uXyAIwopCohlV0nFIN7FIq9rfxyTXsm/9bIg7HFvK9ISIio1eufOi+u9HbLhx2umK17++jufh8YxpbmoiIbpgUO5Hlxw19HPDuHfVRcQ/qs3/S8M+x8+MdIrKCiUJJWiq5CYioqn79+qlE8m+++eYlq4G99W81sK/fmIHGmjNqf3GZTi0HS8kpZXMSEZFR+fn5Yea0W9GpfDPw799uC/9Ow4ajHMAREZHxuBacRWvdXsPz535OQGSK/iYVEdWxicLjx4/j2WefNTx/4okn1F0DSZR94MABmEJ+fj4nKsks2draYsGCBarql1QGq1wNTJ7L/nfffRcNGjTAu3e3go8uSX1eam6ZmiwsKq06uUhERHSjWrZsiQfHdUNI+Z4qAzhZikxERGQMxcXFaFR6AEHlkep5fnE5Hl8chzwWNyGqexOFs2bNwtChQ9XjU6dO4auvvlKTHXfccQeeeeYZ1KazZ89i8ODBCAwMhK+vL7755ptaPT7RtRg/fjx+/fVXHDp0qEo1MFl2LPvl4yK0dQjmj3CFs04f1XEkrkgtQ2a0LhERGZv0Q1O6uyKo/Kx6XlBSjke/i0VWAYubEBHRjevevTv69O6NdtpweCBT7YtKLVE3pljchKiOTRRGRESgV69e6rGUQR87dixGjhyJ+fPnY/fu3ajtirIvvfQScnJy8Pvvv+Oxxx7jpAqZZUETWX783XffGfZ99NFHWLp0qdpfUfBEDO3fHQ92yoIt9MuO/ziYg/9tTjfJeRMRUd12663jMKVtNpr76ZNIxWaU4umf4lGmZToZIiK6cTJX0LJpMMJK18NBU6L2bTyex9y4RHVtotDJyQlJSfrlkX/++aeK6BMlJSVwcHC47q+3Z88eLF68GMnJyZf8eFFREdavX49ly5YhLi6uysemT5+OAQMGQKPRqKWbwcHB6jGROVm0aBG6dOmiflYrPP744+oum+yXj1d2/21D8OpYP8PzD/9KxcbjzB1FRETGT49xz91T8Pm9zeHtaqv2RZzOxwfrUtjURERklH7m7rvvRn1PG3Qo/QcanM+Nu4njGyKzZFedT5LoQVkqKRMcEtFXsdx3w4YNhiXJ1+Kvv/7C3LlzVfn0EydOYOPGjQgICKjymjNnzqivKVX6ZCLwrrvuwnvvvYeHHnqoyuvS09Nxzz334Ouvv67Ot0RUo2bMmIExY8ZctTJyBRsbG4zrWR+J+fb45O80lWv+mZ/iseThJmgZ6MR3i4iIjKq+tz3ev7MB7vvqHLTlwNfhGWgd5IRRnTzZ0kREdEPc3d0xbdo0fPrpp2ip3YNTtt3U/meXJuCnmU3Q1N+RLUxk6ROFn3zyiarUGhMTo5b71qtXr8oy4OtJbvr555+rSRKJBLyUBx98UCXclshFuRshE4Gyb9iwYWjWrJl6jZxHxQRit276iw6ROZGf8QsnA6/FQ4P9cOBsBrZGlaOgRIeZ38Xi55lN4eVarV9dIiKiywoNANrpduEguqvn85clomk9B7Rt4MxWIyKiG9KoUSNMmDABiYlJ+CfHDeuP5iFPipt8H4cfH2kCNyd9VDsRWejS4127duG1115T+dYGDhxo2K/uELRsec1fZ/To0Vec2EtISFBRhpJ3UCYJxdSpU+Hp6Ymff/5ZPd+/fz9uueUWvPLKK2qyUZZEX6nwg0xOSj7DyhuRuZJl9M/e7AZP6HMUxmeW4ckf4lHK3FFEFoF9DlkSV1dXPDC0MYLLT6jnxWU6NYBLyy0z9akR0TVgn0PmTsb+Y8aMxhu3NUCLAH0UYWRqCeb9wuImROakWmFJQ4YMQWlpaY3nApSKsKJdu3aGfXZ2dmjTpg0OHz6sni9fvhwZGRm48847Da+RSsxSVfZSJBJSJhUvlJmZCa3Wuqv81cakaU0dw9wmfI15Pt4eLpg/3Alz/yxAicYFu6MK8PKvMZgz7OLlYHwPjdcO5vYzRZb5/rHPuTxer8yzLTt27IBJ5/7A/44lI8smAEnZZXj022h8NNkH9rZV/+7je2i8djCXaxZZ9vvHPufyeL0yv7Z8ZaQr7vu2AEVaW2w4loeP1sZhWi+3Gj+upY9V2edQbfw+VGuiUKq0ymRcq1atUJOys7PV/97e3lX2+/j4GD726quvqu1aSU7EWbNmVWlgiUSUY1xuctGaXNjWlnSM2jh3U53P8AFdkZKzA29v00KnscWKA4Vo39gTk3tefAy+h8ZrB3P7maJrVxGFbmrsc66M1yvzbMupU+5A6sL/w0+JbijWuOJwfCk+Cy/GS7denEKD76Hx2oF9juVin2MZeL0yr7b844/FaFechj12w2QdFf63NQ+dmnlhQGv3Gj1uXRirss8h2xoe61Rr6fELL7ygqg3v2LFDTbRJVeLKm7FIARORl5dXZX9ubq7hY9fL0dFRTQhW3ogswd2je2JC8/NVKN9YlYSdZ/NNek5EdGXsc8gSyeqNh++9AwOcd8JGp192/POuLCzdmWnqUyOiK2CfQ5ZkwIABCLJNQoh2r3ou2cOkuElMWompT43I6lVrolCqC8skYa9evVS+QJm0q7wZS+ViJZXJ84qPEVmT+fcOQBfPePW4XAc89UM8zqWzMyUiIuNXqJxz/zh01Oww7HtzVRL2RhWwqYmI6IbJqr6JEyeiWflBBJRHqX25ReV47PtY5Bdbd0owIlOr1tJjqW5cG0JDQ9WEoBQu6dOnj9q3e/duREZGYuTIkbVyDkTmFmL82eN9cPfC4ziR4YzsQi0e/S4WSx5mpTAiIjKuBg0a4L+PjsDi/bb4blsmysqBJ3+Iw9JHm6K+lz2bm4iIbkjXrl0RHx8PbXg4dth4IxdeOJtSgud/TcT7dzao8ZoIRGTEicK+ffvCGGTCLyIiQhUSEevXr0dcXBw6dOigNvHBBx9g/PjxhpLqH374IW6//Xb079/fKOdAZGlcXZzxzWMdceen0apKmHSmzyyNx8dTg019akREVAcnC2cH6nAmuQQRZ/KRka/FE9/H4bsZjU19akREVAeMGjUKCQkJKD67Htvtx6EU9lh/JBf/25yOBwb6mfr0iKxStSYKhVQ93rVrl5rsmzp1qtqXnp4OX1/fa/4acvdg7dq16vGUKVPUkmLZXFxcDBOFo0ePVsucf/jhB5w4cUIVLqk43o1YuHCh2ioqHbPqMStJGVNtVOV6Y6wHHlycjtwiHTafyMd/V57DlM41flhWAyOLYC4VKCuwz7kYqxdaVlvOHeaEqTEZyCp1xLGEIsz9KQZP9q/5SA9WoCRLwD7H/LHPMe+2lDF/6v/9H7oUbcVO3UDooMGH61LR0L0MPZs51thxL8Q+hyxFTg3/Pmh0Okkben3OnTunlv6ePn0axcXFqPgSEvkn+QvlF92SGljyLEoVZWsvbCKTpTVdSaqmjlEb526O57N861m8uLoIOo0+3ej8kZ6Y1Lc+rP09NMbXMrefKaob13ZzPS9TYJ9jWW1ZUlKC1z/6DivSukOr0S87fmSAO2YOb1ijx2WfQ5bAXK/t5npepsA+x/zbUqIK7e3t8esh4JO/09Q+Dycble6ika8D30Mjtj/HOZYvp4av79UqZvLUU0+pQiYXzmLOmTMH//nPf4x1bkR0Fbf2bY4Jbc5XBX/zzywcii1kuxERkVE5ODhg1v0T0cNhl2Hf51tyEX7yfB9ERERUXfXr14e/vz9mDPLDTaFual9OUTke/z4O+cXlbFiiWlSticLNmzfjzTffVH80Vta+fXvs3asvb05EteOlqd3Q2TdDPS4r12DmtzFIzi5l8xMRkVF5eXnhhfuGIkR3QD0v1wFP/xSPmLQStjQRERmFjY0G93YqgIdGH5R0OrkYL/6WYFjFSERmOlFYVFQEGxv9p1auRJSYmKjyCxJR7ZHfxS8f64H6jlnqeUa+Do98E4OiUt55IyIi42rcuDHmTQxBQHm0ep5bVI5Hv49FXpE+5zMREdGNkAnBXRGb0bHkL9hDH/yw7nAuluzKZ8MSmXMxk4EDB+Lzzz/HvHnzDBOF+fn5ePrppzFkyBBYAiaWvxgTxFp2UusPpwZj+ldJyNe54kRSKZ5dEo2XRntVmcw3Bib5JUvAxPLmj32OZbVlZS2aN8MDXWPxwd5M5Gm8EZlSglmLY/DWeC/YsM+pE9cssuz3j+Oci7HPsay2lHoIycn/h/Y5G7HPbpjat2hLHlrWS0L3pvriJjWB4xyyFDnmWMxEqg/3798fISEhiIiIwIQJExAeHq4+tm3bNjRv3hyWgkl+z2OSX+MxVYLYDbvPYNayQpT9ew/gyZv98cBAP6Meg4nlyRKY67XdXM/LFNjnWFZbXqi8vBwf/m8pfowPQ/6/K48fGuyHx4b6G/U47HPIEpjrtd1cz8sU2OdYVluK+Ph4fPLJJzimbYcztp3VPg9nG/z8aFME+1RNgWYs7HPIUuSYYzGT1q1b48iRI7j55ptVhWNZijxjxgwcPHjQoiYJieqazi188fYdwYbnH/6Vin+O5Zr0nIiIqG6mvZh+23C8PyUYNv8Grn/+Txr+OmJekVVERGSZGjRogNtvvx0tyvejXnmM2pdTqC9uUlDCFEtENalaE4WTJ09GvXr18OKLL2LlypX4/fff8corryAgIEB9jIhM5+YOXoaIDokXfvrHWJxKKuJbQkRERtcnxA2zb6lneD7vlwT2OUREZBSdOnXCwAED0EG7GW7IVvtOJRVj/m+JLG5CZG4ThUuXLr3kflnF/PPPP9/oORHRDZoxyBc3tXFSj4vKNJjxVRQy88vYrkREZHSTu7misY2+uElhiQ6PfReHLPY5RERkBCNGjEBoyyaY3OwcXB31Iex/HsrBN+EZbF8ic5gozMrKUlvlxxVbRkYGVq9ejaCgoJo6VyK6RlLA5D+TGiHQuUA9T8kDZn4dhZKy605JSkREdEVOTk6YO9IHHuWp6nlcZilm/RiPMi37HCIiujG2tra49957MW3CELx1WwPD/vfWpmD7GVZCJjL5RKEkLa1IXFrxuGLz9fXFuHHj8NRTT9XIiRLR9XFxtMV3M0PhYlOsnh+ML8Ory2LZjEREZHT9evfAjM45cNAVquc7zxbg3T9T2NJERHTD7O3tVSDETW3d1copUa4DZi+JR1zGvxW1iMho9KVRr9Hu3bvV/926dTM8rvzLGxwcDB8fH1iChQsXqk2r1RoqHFU8tla1UereEkrOW/L5XHhcFxvgrfHeeOrXXJTDFsv356OR9znc1tXdaMcwFmN+XWN8LXP7mSLLfv/Y51yMfU7d63NGD+mFM/F/YkVKGHQaW3y/LQONPLW4pZ2z0Y5hLOxzyFx/noyBfc7F2OfUjT6nvLwc9meXwb+8KVJtGiG7UItHv43BZ1N84WSvMcoxagL7HLK030ONThILXqfo6Gg0adKkyr7c3Fy4ubmpmX5LUtNlpS1JbZS6t4SS85Z8Ppc77uJNsXhrXZ56rIEOX94bjF4t3evse2iMr2VuP1NUN67t5npepsA+x7La8lqPW1BQgMfeXYUdhR3Vcwc7Db59sDE6BFdvspB9DlkCc722m+t5mQL7HMtqyysdV9Kdrd8Uge32Y5EP/c/1yI4e+O+k+jc8F8E+hyxFTg1f36tVzKSwsBDPPvus4fkTTzyhTq5+/fo4cOCAMc+PiIzgroHBuLW9/tddBw1m/5iAc+kM0yciIuNycXHBWw8NRlPNKfVccuM+sTgOqTmlbGoiIjJKcZO2IU3QqXQ97KDvW/44mIPvtrG4CZFJJwpnzZqFoUOHqsenTp3CV199pWb277jjDjzzzDNGOzkiMp5XJoegS0P94+zCcsz8LhZ5Rda93J6IiIyvXr16+OShLujc2Ek9T8kpwxOL41FSVs7mJiKiG2JjY4O77roLTXxt0b5ss2H/gj9TsOMsi5sQmWyiMCIiAr169VKP161bh7Fjx2LkyJGYP3/+RbkLicg82Npo8Ol9IWhWz0E9j0wpwewlsdBKJmAiIiIjatKoIT64KxiBnvp02AdjC/H6yiRUI+MNERHRRdHr06dPR7BdAppr9SsateXAnB/jkZDJCHYik0wUOjk5ISkpST3+888/MXjwYPW4pKQEDg76SQgiMj9uTrb4ZGowPJz1v/pbTxfirRUxpj4tIiKqg3zd7PDhlAaws9FHEv62JxtLtmea+rSIiKgOCAoKwuTJk9GyfB/q6eLUvsx8LR5fHIuiUkawE9X6RKFED44fPx733nsvwsPDMXr0aLV/w4YNhiXJRGSeGvs54N1JQdBA34H+uLsQv+5IMfVpERFRHdQ6yAGDvI4bnv93dTJ2RXJpGBER3biOHTti9KiRWHhfKwT72Kt9xxOK8fKyREawE9X2ROEnn3yCMWPGoKysDL///rvKRSNk0vCll166kfMholrQp5UHnhp6vlrZqytTsC9KXxWZiIjIWOzs7PD6w8PRxl5f3ESrA576IQ7xmSyoRUREN27gwIEIbdkIH09tCGcHfdXj3w/kYHEEI9iJqkufOKYaOQFee+21i/Z/+umnsBQLFy5Um1arNZRCr3hszSW2LfUYtXHulnA+13PcW8OccDgmG+tPAVrY4qGvzuL7B+qjnoedxb+Hxvha5vYzRZb9/rHPuRj7HOvqc169oxVmfheHFDRAVkE5HvkmBp/d6QNnhyvfs2afQ5aAfY75Y59jWW1ZneP6OQIP9yzHe1v0k4Xv/JGM+m4l6NzI0WjHqC6Oc8jSfg81umpklY6L0+cAuJyGDf8trWohDezp6Yns7Gx4eHjAmslkqbe3t0UeozbO3RLO53qPW1Kmw5RPTuBYsv55I48SLJ/THk72Nhb9Hhrja5nbzxTVjWu7uZ6XKbDPsay2NMZxd+47ikd/zkWBxlM9H97eHe/e0QAajcZox7hW7HPIGq7t5npepsA+x7LasjrHLS4uxptvvol9hW0QadtR7fNxtcXSR5uivpe9UY5RXexzyNKu79VaehwcHHzFjYgsg4OdBl880BK+zvpo2nM5Dpj9/Vnm9CAiIqPr0bktnuxdAludftnx2sO5+N/mdLY0ERHdMEdHR0yYMAEh5XvhV64PbMrI1+LJxXEsbkJUGxOFx48fr7IdPXoUK1asQOvWrfHZZ59V50sSkYl4u9rhfw+2gMO/VSk3nS7Dl5s4cCMiIuO7c3Q/3NY80fD8w79SsflELpuaiIhuWIcOHTDkpsHoqN0IF52+bzkaX4RXVyQxEIKopicKZUKw8hYaGoqxY8fihx9+wNdff12dL0lEJhQS6IQFUxqhYvWXDNz+OcaBGxERGZcsM37xgeF4bKi/ei4JcJ75KQGRKcVsaiIiumE333wzOrRuhk5l62GLMrVv5b5sLNnO4iZENTpReDkhISE4duyYMb8kEdWSwaHuePzfgZuY/UMMDkdns/2JiMjoZgzyxdB27upxXnE5Hvs+FjmF1l1UjoiIbpyNjQ2mTJmCZn62aF+2xbD/7T+SsSeqgE1MVJsThZI8dMGCBRZVyISIqnpgoC9u6aBPhlpSbosHv4pEag6jPIiIyPiRha/dGgAvG33Vvui0Ujy7NB7a8uuusUdERFSFs7Mzpk+fjiYOCejqFa/2lZUDs5bEISm7lK1FVBMThW5ubhdt8sv43nvv4d13363OlyQicxm4TQhCS3/9pSGnzAnTPj6MklJ9/kIiIiJjcXexx0u3OMJeV6SebzmZj4/Xp7KBiYjohgUGBuKxxx7D/2YPQu8Wrmpfep4WTyyOQzHHNkRXZIdqWLx48UX7pIx4x44d4eXlVZ0vSURmwtnBBovua4bxH5xGVpEGMXmueOzLA/j84U5qIpGIiMhYhvUNw4nYTfjioAN0GhtVTKtVkJMhup2IiOhGJgvFO5PrY9LCaMRlluJIXBFeW5mkgiM4tiEy4kThuHHjYOkWLlyoNq1Wnw8nMzPT8Nha5eTkWOwxauPcLeF8jHVcBwD/neiLmT+ko0ynwdZYZ7z10348PLypRbyHxvha5vYzRZb9/rHPuRj7HOOx9D7nrps74ET8dmxOb6aeP/9LPHwditAywJ59DlkE9jnmj32OZbWlsY9bWlqKIZ778H1mG2hhh+V7s9HMR4dbO7kY7RhXwnEOWdrvoUank3pzV5eWlnbNX9TPzw+W1MCenp7Izs6Gh4d1372WyVKJDLXEY9TGuVvC+Rj7uKv2ZWHuL4nqsQbleGuMK/q29jT799AYX8vcfqaoblzbzfW8TIF9jmW1ZU0ft6ioCJP+E44zxfpc10Gedvj50abQlOayzyGzZ67XdnM9L1Ngn2NZbWns4xYWFuKjjz7CwTR3HLQbpPbZ2QD/90BjdGniYlFjVY5zqDau79eco9Df3/+aNyKqG8Z09sI9/fSdmg42eGNdEeIyy0x9WkREVMc4OTnh80c6w1uTrp4nZpdh1pJ4lGlZ3ISIiIxT3KSpQzyaag8bips89UMcklnchKj6S4/3799/rS8lojrkqeEBOJ1UhK2nC5FbrMNzyzLx06M+cHeyNfWpERFRHRJUzxefTm+CR38pUAnnd0cV4OONwKu3+Zj61IiIyMIFBATgzjvvROHX3yBH44N0mwaqr3nyhzh8+2BjOEiIIRFd30RhWFjYtb6UiOoQWxsNFtwZjDs/i8bZlBJEp2vx+DeR+OL+ZrC342QhEREZT4eQhvjorgJM//IcSrU6/LavAB2bZGFCNxbLIyKiG9O2bVvcPHQIytZvRIRmHAo1bjgUW4Q3ViXjlfFBbF6if9lUd43/mjVrLtov++RjRFS3uDnZ4pO7g+HhrL9k7Iopw+Of7TD1aRERUR0U1tgFL44NMDx/dUUiDsQUmPSciIiobhg6dCg6tW2BTmV/wxb6Yqa/7s7CzzszTX1qRJY9UTh37lycOnXqov2y74UXXjDGeRGRmWnk64D3pzSEjUafL2pLgg/eXbrH1KdFRER10K1dPBHmkWDII/X497HMI0VERDfMxsYGd9xxB8KaeuDxAfaG/W/8noTD8SVsYaLqThQuWbIEd91110X7p0yZgh9//JENS1RH9WzuiiduOl9V6dv9TlgVfsKk50RERHVzIPf5Y70QYJuqnqfnl+Ox72NRXFpu6lMjIqI6UEDrkUcewf3DW+HuPvo8uGVa4IUVWUjJKTX16RFZ5kRhcXExCgouXgKSn5+PvLw8Y5wXEZmp8Z1ccFt3fa6oco0tXl5TgEOn4k19WkREVMe4u7lgwR314QL935ZH44vxyopE6HSshExERDdGo9Go/2ffUg9hDe0MN6We+iEeJRLKTmTFqjVROGDAALXEuLT0/Gy7PH7++efRv39/Y54fEZlhp/r8mEB0beKsnhfDGTO/jUFqRrapT42IiOqYJvV98fpYT9jq9H9zrtyXg++3MY8UEREZR0Z6Kuon/AQnnf6m1IFzhXjr92Q2L1m1ak0Uvv3226pwScuWLTF58mRMmjQJLVq0wF9//YV33nnH+GdJRGbF3laDD+5qiPpe+qrHGeXemPXdGUZ5EBGR0d3cMwT3dSk2PH9nTTK2n8lnSxMR0Q3z8/ND25bB6Fz2N2xQpvb9vCsLv+ziTSmyXtWaKGzdujUOHz6MadOmqeXGUul4+vTpOHToENq0aWP8syQis+PtaodPpzWCs70+bH9fsgu+2JRu6tMiIqI66InbumFAfX0fU64DZi+JR2wGk84TEdGN58SV4KeW9WzRrmybYf8bq5Jx8Fwhm5eskn4xfjUEBQXhlVdegaVauHCh2rRafUn0zMxMw2NrlZOTY7HHqI1zt4Tzqe330M8ReGmUJ+Yuz4JkjPror1QEuJRgQIjzDX1dY56jKb8GmY65vX/scy7GPsd4rKXPefXOUMxdloWIyGJkF2rxyNcx+PwuH7g4XP99b/Y5VFM/p+aAfc7F2OcYT13tc8aPH4+s//s/ZJcdRYxtW5RqdXj8+3P46m5f+LrpV1FVF/scsrTfB43OyjNCSwN7enoiOzsbHh7nq7laI5ks9fb2tshj1Ma5W8L5mOo9/HJTGj5Yp69Maa/RYv7gYowf0uWGv64xz9EUX4NMx1yv7eZ6XqbAPsey2tJUx73wGLlFWtzxaTSiUvXRhENC3fD+lIawsdHc0Nc15jma6muQ6Zjrtd1cz8sU2OdYVlua6ri7du3C0l9+xS6b4ciwCVL7OjV2xv/d3xgOdtfXz1TGPocs7fperaXHRESV3T/AFyM76i9QpTpbvPl3OfYePs1GIiIio3J3ssVHdzWAvUZf3OTvY3lYtDGNrUxERDdMajDccvMwhGn/gZttkdq3P6YQ//2DxU3IunCikIiMUgn51QlBaNvAST0v1LjhqSUJiE9kp0pERMbVrJ4T5gyyA/5dFPPJ32n451gum5mIiG7YTTfdhCkTR2HR/S0NUYQ/7cjEsj1ZbF2yGtc8UThq1CjD48WLF9fU+RCRhXKyt8HHUxvC312fwyMd9fDIZ/uQl5dn6lMjIqI65q6hoRgTcr5/efrHOJxJPl8ZuboSExOxb9++y27ycSIiqtsBED179kRYEzfMHxdo2P/qiiQcimVxE7IO1zxRuHbtWkOxj6lTp9bkORGRhQrwtMdHU4Ph8G++3zOlTTB74QaUlZWZ+tSIiKiOeWN6V4R6ZqrHRWXAI99EqyInN2LRokXo0qXLZTf5OBERWYcxYe7oGaCPJJTiJk8ujkNaLsc1VPddc9XjkJAQzJ8/X82ui9WrV19T9CERWZcOwc54bUJ9PPtzgnq+LbMF3v1mHZ67f6SpT42IiOoQGxsbfPVYF4z6z0Gkl7kjPqscsxafwxf3NYHtdRY3qTBjxgyMGTMGhYWF6Nu3r9q3detWODs7q8dBQfrk9kREVPfFxsbCK345vG1uQaZNIJJzyjBrSRy+ur8x7G2rX9yEqM5MFH766ad48skn8eGHH6rnEydOvOxri4r0iT+JyDqN6uSJU8nF+GpzOnQaGyyPa4Y70krQ2M/B1KdGRER1iIerI758oAXu+OwciuGIHZFFeH9dCubcElCtrycTgbLl5+cb9oWFhcHV1dWIZ01ERJagSZMmGDH8ZpT8uQERmnEo0rhib3Qh3v4jGc+POb8smchqlx4PHDgQBw4cMOQbk8nAy21ERE8M88eA1m6qIfKKgUe/i0Vu0Y0tCSMiIrpQq0Y+eHOCLyqCO77ekoHVB7JvqKEq0u2ILVu2VHlORETWY/DgwejWIQSdtBtgA31fsGR7JpbvZXETqruqVfX48OHDxj8TIqpTZNnX25Pqo0WAo3oemVqCx76JRGRUtKlPjYiI6pjhXYPx3OjzUYTzf0vE0fjqJZ1ftmwZOnToYHg+YsQItGjRQu0nIiLrK24yadIktA6wRWjZtirFTY7EsbgJ1U3Vmihs166d+j89PR3bt29HRESEekxEVJmbky0+ubshPJ311U12x5Rh9v/28XpBRERGd0dPb0zo6qkeF5fp8MjX0deddF4mAyW9jkwUyt+4ubm56v/27dur/ZwsJCKyPo6Ojpg+fTpCnOLQSHtc7Ssp0+GJxXFIz2NxE6p7qjVRKAmeJdlzQEAAevfujT59+qjHsk8+RkRUIdjHAe9PaQC7f682p8rbYO6n63itICIio0d9PD8mAA2c9Wly0vKBx76NVoO5ayHLi2fPnq2K8q1YsUIV8HNzc1P/y3PZP2fOHC5DJiKyQn5+frjrrrvQyf4AQvzK1b6k7DLMXhKvKiITwdonCp9++mn8888/+PXXX5GYmIikpCT1eMOGDepjRESV9Wjuirmjzyf8jcjvgP9+sZyDLSIiMipHe1t8PbMtXGz0ObMPxZfi9RXx1/S54eHhiI6Oxrx581RF5crk+dy5cxEVFaVeR0RE1qdVq1Z44fnn8MUDIajnoa8LuzuqAO+uSTb1qRGZfqJw6dKl+PnnnzFu3DgEBgaqaEJ5/Msvv6j9REQXmtzTG5N6eKnHOo0tVia2wtc//Q6djnfgiIjIeBr4uuDDKQ0MSed/25uLn3ZkXPXz5OZ35RQ7F6rYX/E6IiKyPi4uLvD3sMcHUxoaVkwtjsjEqn03VkSLyJzop8Gvk+Rrady48UX7ZV9OTg4swcKFC9VWUcUuMzPT6qObauO9q6ljmNvPnanOx9zfw4f7OuJUggP2x5agROOCrw77wv+Pdejfp4dRz90YX8vcfqbIst8/9tsALN8AAFaSSURBVDmWd70yxdetLvY5F2sTZI+Hemnw6Xb98zdWJSHQtRQdGzpcts1kmbE4cuSIWm58Idlf8Tr5u9GY7W9uP1Nk2e8f+5yLsc8xHvY5ena5Ceig2YN96K6ev7Q8AfWci9Eq0L5G24x9DtXG76FGV41wHslL2L9/f7z11lsqH4yQL/Pss89i27ZtarOkBvb09ER2djY8PDxgzeSPXm9vb4s8Rm2cuyWcjyW8h5n5ZZi8MBpxmaXqeYhrGn6d21v9Lhrr3I3RDub2M0V149purudlCpZwvartr1td7HMub9ZXh7DujH7Q5ukE/PZECwR52V+yzeTmsVQ3lsIlkpOw8vLj8vJytXpGJgtPnz4NW1tbo7a/uf1MUd24tpvreZkC+xzLaktTHfd6jiHFXD/44APsLu6MWNvWal+Qlx1+ntkUPm52NXbu7HOoNq7v1Vp6/O677+LTTz9FSEgI7rzzTrXJ488//xzvvPOO0U+SiOoOb1c7LJwWDBcH/eXnVL4fvtx8PjKDiIjIWN6e3h4tPAvU4+wi4PHv41BUqk9CfyGZ/FuwYAFWr16tJgUrVz2W57Jf/gauPElIRETWydfXF1OnTkWobge8yvU5ChOzyjD7x3iUsbgJWbhqTRRKRKHcTZ0yZQpKS0tRVlamHss++RgR0ZW0CHDE25Pr49+AZHy8PhWbTxaiqEiffJ6IiMgY7Gw1+OaxjmjorY8qPJZQhJeWJV42P+748eNVgb5Dhw6pv2nlLr38L5GEsl8+TkREJCRYaszIW9BJ+w8cdfqbUrsiC7DgzxQ2EFlfjkIhBUxefvll454NEVmNQW3c8cQwf3ywLlU9f/n3DOzZ8gdeeHwqnJycTH16RERUR0gk+8d3N8Sdn0WjsESH1Qdy0NC9DI+N8Lnk62UycMiQIWpJj1izZg2GDRvGSEIiIrrIgAEDEB8fj8IDG7DTbgR0sMV32zLQtoETRnXS9yNEVhFRSERkDPcP8MWoMH1OhdJyW6zN6Igvv/3Z6gsLERGRcYUEOuHN2+obni8Kz8fWk7mXfX3l5cWSl5vLjYmI6FKkZsNtt92GtkF2CNXuMOx/aXkijidwtRRZJk4UEpFJO9ZXxgehXUN9BGGhxh1LI4OxfOXvfFeIiMiohrXzwKRO+j99ddDgycXnEJNWUuU1iYmJ2LdvHw4cOGDYJ49ln2zycSIiosocHBwwffp0TOzqiVs7u6t9RaU6lRdXCjkSWRpOFBKRSTnZ2+DjqQ3h56a/HGXaBOLLnUB4+Fa+M0REZFQvTAxBWGCpelxYZoMH/3cG+cVaw8cXLVqELl26oG/fvoZ98lj2ySYfJyIiupCPjw9uv/02zL+1PjoE64MgErJKMUeKm5RfOi8uUZ3KUbhp0yYMHDjQ+GdDRFapnoc93rrVGzN/zEBJmQ5xNq3w0e874OfnizZt2pj69IiIqI6wsdFg0Yy2GPmfQ0grdkJctgZPfhuJRfe3UB+bMWMGxowZc9nPDwoKqtXzJSIiy+JgZ4P372yAce+fQm6JLXacLcCizcAL4y/OiytR6leKVJc+h/0OWcxEoSR4lmrHsmyQiMgY2gTZ47UJQXh2aYJ6fsymO95f/A8+fKEJnJ2d2chERGQUbk62+PCu+rj362QUl9sjIqoMH/wZj1kjG3JQRkREN+zs0d0ILYjALlXcxAY/7i5A5+bZGNGxanETiVJ/5ZVXLvt1XnrpJRaQJctZetykSROcOnXK+GdDRFZtVJinKnCiaGxwwG4wUvLPJ5QnIiIyhsa+DnhncgNooF8O9tXWXKw/ksPGJSKiG9atWze0r2+HNpWKm7z4WyJOJFYtbiJR7Hv37sXWredTLslj2SebfJzIYiIKX3jhBZWs8/3330doaKhK3lmZk5N+TT4R0fV6Ypg/zqQUY9PxPOSXAA/9XxSeH5APF/tLv54h+UREVB03tffFjH55+Dy8QD2f+0sCGvs5qArJRERE1SXzI9OmTUPmBx8iu9gP8TYhqrjJE9/HYenMJvBytasyjsnPzzd8blhYGFxdXdn4ZHkRhffccw927NiBXr16wdPTUy0LrLwREVX7omSjwduT6qNFgKN6fi6zHNM+OoCnZs02JJOvvDGxPBERVdejtzTCyI4e6nFhiQ6PfhuLLFaoJCIiIxQ3ufvuqWiv2wHP8lS1Ly6zFE//lAAti5tQXYwoDA8PN/6ZEBH9y9XRFp/c3RCTF0Yjq0ALp0a94N7ADX21ZSocX7aKmxJM8EtERNUl+bZfnRCEqNQSHEsoQnxWGR7632ksfrQ17GyZi5uIiKqvRYsWGDvqFhSt2oAIzViUaJwRcSYfH/6VilnD6xlep9VqDY+3bNmCYcOGwdaW6ZfIwiYK+/bta/wzISKqJNjHAe9PaYAHvjqHsnIgyrY92vecgmEuLmqSsF27dhelPSAiIrpeTvY2+HBqQ4xbcAL5ZXY4nAS8tiwar9zWlI1JREQ3pF+/foiMjETx8U3YZTMcWp0GX21OR2h9Jwzv4IFly5Zh1qxZhtePGDFC1YRYsGABxo8fz9Yny1l6LKTq8bZt2/D9998b9qWnpxvrvIiI0L2ZK+aNCTS0xBHbvqjfYRiWLFmC+fPn43//+x+vO0REdMPqe9njk2lNYINy9fzXfUX4ZXsKW5aIiG44cl0m/+bPnIhnR50f17zwawI++eonTJw4ER06dMD27duRm5ur/m/fvr3aL5OIRBYzUXju3Dl07twZN910E+6++27D/gceeAC///67Mc+PiKzcpB7emNzTWz3WaWyxy24EtjnchmPlHbD7VFqVvKhSjf3s2bNVwveJiIiuRfcW7nh6uK/h+WurUnEgJo+NR0REN8Te3h6NGjXCnb28Mbazp9pXUFyGuc8+jVGjRmHFihXo2bMn3Nzc1P/yXPbPmTOH4xqynInCp556ShUyycnJqbJffpD/85//GOvciIiU50YFoGsTfXETkaPzwFnbTthqOxbjFyZgwZ8pOBRbiDVr/sRnn32mKrJLtPPevXuRl8dBHhERXZu7BwRiZDt9WgstbDBtUTQe/OIk1h3OQVGpPtqQiIioutGFD/YEfGwyURC7F3npcZg3bx5sbKpOy8jzuXPnIioqivUhyHJyFG7evBknTpy4KD+YhMjKwJyIyJjsbTV49zZfNO81EY7+IXBr1B3OwV2gsbFFbEYp/m9Luto87AeinmMUfEtOo+jgIRw8eFB1yHIHLywsTOUIISIiupLXJzXD2eTjOJGqQZnOFtuiyrEtKh7ODhr0a+GEIaHOGNrRHw521c7gQ0REVir+XBQ6FP+F2Dx9EITkXb+Uiv2JiYm1en5Eolp/4RQVFRlmvWUQXkF+iF1cXNiyRGRUkp+jW+eOyD31N9K2fYroH6cjffFIBGRvgU2lopQ5pQ44U94KO+1GYZvr3YhyH4JUBCIq5hyio6MNr9PpdDh+/DiKi4v5ThERURUOdhr838OtcGuYE1ztz6eyKCzR4a9jhXjm1wz0mH8U936yH3/sSUSpVscWJCKia9K7d2/069oGrZ1j1fMjR45c8nUV+4OCgtiyZBkRhQMHDsTnn3+uwmQrJgrz8/Px9NNPY8iQIcY+RyKy8klCSeYreTp++ukndXdNOs4333wTqz9/GF9/vxSuIUOw/kgudpzNR9m/Y7rcEjucQGPArjHcHMqhLbNF4xN56NnCFZnpKfjqq69ga2uL5s2bo02bNmrz8/Mz9bdLRERmwNPZFq9PaoqXtDrsOpuPtYdz8PeRXOQU6Zcfl+jssDPeDjt/y4KDpgSdgyIxoWcghnVuADvbSnewiIiIKpH5kwkTJqggq4j1/nj9jTexauWKKsuPy8vL8dZbb6Fp06ZcEUUmodFJaM11kmXH/fv3R0hICCIiItQPenh4uPqYVEKWgbe5W7hwodqk6IEUQJBoIw8PD1gzyTlZ021QU8eojXO3hPOpa++h/H526dIFHTt2VEl9L+xAx40bh0OHDmHPnj1q0i+3qBzbzhbj76N52BerRcklapq4OmgQFlQGm+RdcM49CVucf5GPjw9atGiBTp06qdQK5vQzRdf/89SkSRNkZ2ebxfvIPqfuX69MiX1O7bSZRA7uji7G2sO52Ha2FMXaixfmeDlrMLCVEwa3dkLHhg6wrRz2buTzIfPBPsf8sc+xrLa0hr8bZN+cOU/jt99+xYiRo/D8vLmGgAiZJFy9ejW++eYbjB492ujnyD7H8uXU8FinWhOFIiUlBYsWLVIDdBmwSxXkRx55BAEBAbC0Bvb09DSbwaQpZWZmwtvb2yKPURvnbgnnU9few02bNmHQoEHYvn27qgB2Idkv4fsbN25Ukc6Vv5aDiwe2nMzH+iM52HIyTy0Zu5CTPRDqWwT/0rNAyj7YlJeo/ffddx8CAwPV+VQUbbL264OlMddru7melynUteuVKbHPqf02Ky4tx9ZT+fh9Xzo2n8xHySUmDV1sixHmX4hbewRgWNfGsLOzrbHzIdMy12u7uZ6XKbDPsay2tJa/GyIjI/HkrDnYsGUHCjLP5yJ09mmInre/gJn3TsLQdu7wcLY16jmyz7F8OTV8fa/W0mNRr149vPjii8Y9GyKiSiqS91Ynya+roy1u6eChNqlUue2UftJw4/E85BXrl44VlQL7kpwAtIWDQ1u0DyxHsF086jVoCmgL1WskWlomIhs2bGhYoiyPL6xORkRE1sPR3gY3tXVXW2JKBg4l2+HPg/obU8Vl+htTBVpHRCQ5ImJlMV5adQBh9WTSsB6GdWsGO7tq/wlORER1RLNmzfDs07PRa+AxfPRHNGxdvGHn6g+X4C5ItrHF/GWJeG1lEga0dsPIMA8MaOVm6lMmK1Htv1IkJ+GSJUtUQQARGhqKO++8k8VMiMhoKpL3Sgj+pSIKrzXJr1OlAV1JWTl2nCnA+qM5+OdYHrIK9EuPZZny3ngb7EUwVr8dhS6NHDCiE5CZlqs+HhcXp7b169fD3d0drVq1UpOGMlkpy56JiMg6OdlrcHN7D7XlF2vVDak1B7Kw7XQ+ysr1S48LdC6ISHZBxCotXlq1H4NbOWL6sBC0DnKsUhiQiIisi6yO6tChA+Y95QEH78Z44fN12HCyBKkF59Ne/H00V21ujjboH+KICd0d0K2ZyzWntyCqlYlCWW48cuRIlT+sffv2at93332nIgz/+OMPtQyZiOhG9evXT+VekMIll8pRWJ0kvw52Nujf2k1tL43TYU9UAf46kqM63/Q8/aShFETZGVWCnVFJsNF0RKcW3RHqlQ33/ONIiDyK3NxcdR08efKk4RooZL+bmxsHfUREVkqi2UeFeaotp1CLf47l4s+D2dh+Jh9a3b+ThnDD6pPA6pNRaOzrgL7NNAhxTcXogWFwdHQ09bdARES1SG4WVYxxSjJj0AoHkZW9C9kaP+R7dUZ0aQPkFOs/Lqui1hwuxJrD5+DvbqdWTo3q5IHQ+k4cf5DpJwofeughjB07Fh999BGcnGTZHlBUVITHH38cM2bMwO7du417lkRklSRSb8GCBarqsRQumTv34iS/v/76a7Uj+qQypVRBlu35MYE4EFNomDRMyi5TrynXAXtjirE3RjrgTugY3AudA0vgX3YW9dxtDB27TFy+9957qghKxRJlWU5gb29v1DYhIiLLIDmlxnXxUltWfhn+VpOGOdgVWaD6FhGTXoKYdPVqvLtpHzr45mFMV1/c1KMNnJ2dTfwdEBFRbQsODkZaWprKX+iV+ReCoEGmTQPke3XC2UJ/FJXpbzql5pbhu20Zamvq74ARHT0wsqMnGvs58E0j00wUHj16FGvXrjVMEgp5LFE/jRo1uvGzIiL61/jx49Vk4KxZs1RofgWJJJT98nFjkND9Lk1d1PbcqABEHE/BjhiNymsYm1GqXiOlnw6cK8KBc+oM0K6hE+I2p2FoWw+46LJRUFCgogq3bt2qNpkklOrwFROHknCWiIisj5erHSZ281Zbel4Z1h/JxdrDOSqqvaKsYC68sC3dC9vWAR5r96GdTw7GdPHBiIFd62yKC8kxfKk8wxUktcjV0osQEdUlsgy5V69eyMrKwoEDB7B//37YxMfBNyMOoZ4+aD9iOjaf0aqijbIsWUSllmDh32lqa9/QCSPDPDG8g4eKOiSqjmr95DRv3hxJSUnw8/Orsl/2SQQNEZExyWTgkCFDDBNta9aswbBhw2ps4CRLAEKDHNAn1BuzhvvjRGKxmjBcfzQXkSn6ysjiSFyR2t5fm4qQQEcMHvwUWrqlITfhuMrfKtWo5MaKbAMGDMDo0aMN0YeCBVGIiKyPr5sdJvf0VltqTin+OpKL3/dl4HC8/qaUyNH4ICLTBxF/A98fP6eWl93cwQM+TtoqN+ot3aJFi/DKK69c9uMvvfQSXn755Vo9JyIic+Dl5YWBAweqLTk5WU0Yuri4oH1rZ0zo5Y3MvBI8/f4yJNq0QEyeK/6954TDcUVqe/uPZLVqamRHDwxp6w43p7p5w4lMPFEoS4srSGTPpEmT8M4776Bbt27Q6XQqX9ecOXPw9NNP19CpEpE1qzwp2L9//1qLrpBJwzb1ndT2+LB6OJsik4a5aonyycRiw+tOJRWrDbBFM//OGNJjAAYEFKEk9RROnDiuCj5VOH36NH744Qe0bt1aRRpKYRTp+ImIyLr4e9hjSm8fjGijQZHGDesO52DtoRw1yKtwNL5Ibe/+mQIfTRpau6dhRJgP+nVre9FNe0sjKYvGjBmDwsJC9O3bV+2TiPyKZdeMJiSiuqwiqlqugRUkirDyNVC2gIAADB8+XO3LzMxU/6fER8Erew+8sAdN4IIsl7ZIcWiFhHx9rltJcRFxOl9tr65IwsA2bip/bt8QVk4mI04UXipPihQ0udC9996Le+6551q/LBGRRWlezxHNBzviocF+OJdeoiYNJdqw8qAuMrUEX2xSSacQ7NMEQ9q2R769B8rLdbCx0agiKLJMed++fWqTyUgp2lKxRDkwMJAJiYmIrEyQlz2m9/NVW1xGiVqaLJOGxxPO35TK0PkhIscPEZt18N50CK3d03FLmDd6d2lrkX1HxSA4Pz/fsC8sLAyurq4mPS8iIlNFVVfcNLlaVHXLli3x4IMPqkjDw4cPw7lgN4IKdqMZvJDt3h4pdiFIztO/trhMh3WHc9Xm4WyDAS0dMaGHA7o0cVFjE6JqTxSGh4df60uJiKxCI18H3DfAV22JWaWqCIpMGu6LKTTknJL8hl+HZ6gt0NNOhf4PDh2EB9uE4tTJE2qJsiwniIqKUpssq5bIbLlzSERE1qmhjwPuH+CntujUYqw9nKsmDU8n/ztpqNEgUxOE7flB2L61HL7hRzGsXQxmju8Kb1fmpCIisqSo6su5UlS1pDCSXOiySZqmEydOqAAEGVu454bj3Se7IE3rg9UHcrDmYBayC/WDk5zCcvx+qBC/Hzqnxia3dPRQkYatAh0t7mYT1Zxr/kui8sw2ERFdHAkytY+P2qQK2YZ/Jw13RxVAq09JqCopL47IVJuvmy1uCu2CYbcOQnPPIpw+pZ80zMjIQL169Qxfd+nSpapASkW0oY+PT402PRPLExGZlyb+EsWuj2Q/k1ysJgwl2lCS1ysaG6RrGuDHY8DPJ06jZ3NXdA4ohFfRKXQLC1XFv5gTl4jI/BirYJMUUGzfvr3aZBmzrF5q0KABGmo0CGvsgib5G7H+QAryPDoiqqgeirUaw9jk6y0Zamtez0FNGEr1ZLlZRdaNtxyJiIxMKoxVJKrPzC/DxuN5atIw4kw+yrT616TnafHzriy1eTrbYnBoUwzt2wE9mjkb7uZptVocOXJEdfhyl3D58uUq0rBi0lCWKxs7VyMTyxMRma8WAY54dKg/Zg7xw8mkfycND+Wo6HUhN6a2nc7HttOARtcUfrvOoKnDFtzUzhPdwtqqgoR2dvzzn4iorpKUcZLCoYLUk8jPzYF/eSz8s2IRDDuk2TZBjnsHRBd4QavTjzvOppTgw79S1RbW2BmjOnrg5vYe8HFjn2GNqvWux8XFqaVxkmy4IplmZXl5/y6GJyKycrIEbHxXL7XlFGqx+YR+0nDrqXyVL0RkF2qxfG+22twcbTCgtRuGtXdH7xaueOSRR1SkoWwxMTFqmbJsmzZtUgO+hx9+2Kjny8TyRETmT24otQ5yUtsTw/xVsZOKSMPErDL1Gp3GFqmaRkgta4Q9+8vgvy8Sje22YGCoB+68fbyKQDEXcmOswpYtWzBs2LBaK1pGRFTX+wv5+z4tLU0VSpHlyXYpZxCYdQZN4Ihi3y4o8OmMfdGVCqrEFKrtrdXJ6NNSKid7YlCoO1wdbUz6vZCZTxTefffdKCsrw2uvvabKdhMR0dV5ONtidCdPteUXl2PrKZk0zFWThwUl+vXJecXl+ONgjtqc7TXo18oNQ9t1wfT7B0CjLVZLCWTSUCIMmzVrVqUy/VdffaUqKEu0Yf369auVZ4SJ5YmILItc69s1dFbb7Fvq4eC5Qvx5KAd/HclFSo5+0rBcY4dkTRMklzfBviNlOKRJxvAOHqqPSYyLUdd+Jycnk5z/smXLMGvWLMPzESNGqIj5BQsWqLxbRER04/z8/DBkyBDcdNNNahxx9uxZNXHYs5sHhgxpgvjMEqzel4Wl2xKQXOhoiFLfcjJfbTIuGRzqjpFhHujd0g32tsxnWJdVa6Jwx44dKrLF39/f+GdERGQF5I6chPPLVlRajojT+WrScOPxXOQW6ScNC0t1aqAnm4OdBr1bumJYu6YYeWsHTHbUoLRUv9RMnD592lAQZe3atfD09ETr1q3VpKFURXN01Hf4RERUtycNJR+VbM+ODFDFtWTSUCLZJeWFKIOdvjjK4Vy4OGjgXXIW9ctXo1dLV3Tq0A5t27attarDMkk4ceJEjBo1Cj/99BPatWunUm68+eabav+vv/7KyUIiIiP3E4GBgWqMIDdmKiK6G3g7oKdfIk7nLEYuvJHp2g7xmmbIKrYzjEsqghm8XGxxc3t3ldMwrJEzKyfXQdWaKJS7jpIzi4ioplUU16h8zZG7X5J/w5hJgE3Jyd5G3aGTraRMh51n87H+aC7+OZaLzHx95y37Nx3PU5udTSJ6NHfF0HbuuCnUVuUOkegLGVRJtOGpU6eQnZ2NnTt3qk2Wb02dOlUNwIiIyDrY2GjQtamL2uaOCsCeqAK1NFluSmUV6PuWghIdCtAM8TbNsP9MMQJOx6D+r9vRrakTwjq0U4nxPTw8auT8ZHA6e/ZsNUm4YsUKQ8GVnj17qufjxo3DnDlzMHbsWC5DJiKqAXLdrVzsytvbG506dVI3bNzzwxGMcGRqApDt1gGx2obIL9W/VvqQpTuz1Fbfy15FGcqkoeTRJSueKHz22Wfx4IMP4pNPPlE5slhGm4hqyqWKa1Suwv7SSy/h5ZdfrjNvgEQOylIw2eaPDcSe6AI1qJMqylJNWZQZktXn49UVSejS1AXD2rljSNsuaoAlkYaRkZGG3Ibp6elVJlMPHTqE6OhodSdRqmEysT0RUd1mZ6tBzxauant+TKC6ISU5DaVvyfk3ir1M44h4TQjiEYIDMUUIjI7G2IRDeGB8H/X5khDfmH/zh4eHq77oxx9/vKgqszyfO3cuevfurV43cOBAox2XiIgurVGjRpgyZQqKi4tx7Ngxlc9Q0h755K5HY9hgwG1PIDwSagVUUak+13pCVim+3JSutpBARzVheEtHDzWBSFY2UdilSxc899xzajnbpcgfEkRExiyucTmWHk141YFdc1e1PT86AAfOFapJw/VHzyerL9cBuyML1PbGqmRVpWxoW3cMa9cM41q1UpEYMlHo6+tr+Lp79+7F0aNHVcJ4WZIcEhJiqKTs7u5uwu+YiIhqmuSV6hviprb543SIOJ2nJg3/OZ6n8ueKUo0TYjWt8ck+4MdTpzG0nQeaOyUh6ehGdOjQXkUaBgQE3NB5yGoBcblo94r9Fa8jIqLaIeMDiSyULT8/XwUZJCQkYGyPBhjbA8gv1uLVL9biSJYPzhV6ovzfysmnkorx3toUtUk0u0QaDmvnoZYqkxVMFN57773o1q0bHnjgARYzIaIaVReWFhtrCVnnJi5qe2ZkPRyJK1LLkyXv1Ln00ouqlL2zJgVtGzip5cnSQftV+lrdu3dXS7cl2lA6/8OHD6tNNG7cWFVaJiKiuk+i2Ae2cVeb5MuVIltrD+Vi0/FclY9KSG7Dn3ZkytARjrp+CPwrCkHrvkWIHwyThg0aNLjuaMOKvl2WuEk0/IVkf+XXERFR7ZOctb169aqyz1ZXCsRtQRutFs3ghFT7lshwbov4wvP5bSXdhWxvrEpCvxA3jAzzxMDWbnB2YOXkOjtRKPmvNm7cCB8fH+OfERERXZEMxtoHO6vtqZv91d07faRhLs4kFxtedzS+SG0frEtVSwEk0lAmDkNDQ1Wy+vLycsTFxRmWKMtjWe4lOQ0rcIBGRGQdJF/ukLYeaisoKceWE3mqEEr4yTwUl+knDYs1roixbYcYtMOBzDyEb4xE0D+L0cSrHHPmzL6uwln9+vVT+XWlcEnlHIVC+qe33npLpceQ1xERkflwcnLCU089pfLG79+/H47ph9Gw9DCawx1pjq2R7hyK5Hz9VFOZVpYq56nNxUH6GX3lZFkxJaunqA5NFEqnLYnyOVFIRGT6ScNWQU5qe3SoPyJTig2RhscTzk8aymSibAs3pKGJn4PKaSiThm2Cg1U+kptvvhk5OTkqwrAiyby9vb3KdyhLlIcNG8Zk8kREVkIGc8M7eKhNlphtPJaHPw/nqIhDGfSJIo0bomw7IAodcKSwAK6bstXrWwU6YuvWrWppsuQyr3zzqTLZv2DBAlWISwqXSE7CiqrHMkm4evVqVfX4cp9PRESmI5WThw8frsYQ586dUxOGMnHomrcbj91cH37Nu+qrJB/IRmpuRQGtcqzan602XzdbDG+vL4LSPtiJdS/qwkThww8/rJYff/TRR2jRosVFb6rMMBMRUe1rVs8RM2Qb5IfYjBL8LZGGR3JxMPZ81ejotBJ8sSldbQ287dWEoUQbdgh2V9Utly1bhlmzZqlJwrS0NIwYMUJFfciAbvz48XxbiYisiKujLUZ18lRbTqEWG47lqpyGO87kq+JaIkfrYkhm39jXDg6psQjQbkaAS4mKYpflyZIPV25AVSZ9ikwGSp8jhUsqByXIfvY5RETmTeaCJHWRbKNHj8bZs2dRv359uLk5I7SBM/r6ROOL37Yi07Ud4rQNUVhmY0hr8cP2TLUF+0jlZE+MCvNAU39WTrbYicLHH39c/d+hQ4dLfpzFTIiITC/YxwH39PdVW1J2qapu+deRXOyNLkBFzan4zFJ8E56htgAPOwTlbMGP/30Ao0aNwk8//WSI7pClYRL1wYEbEZH18nC2xa1dvNSWlV+mIthl0nBXZIEqriVi0ssAm044bdMJbiUZOLQvCpv3/AYfx2JVNEtyXUmkYQWZDBwyZAg8PT3V8zVr1jCKnYjIAkkEuNwUqiw3Jxv1bFLgm7ceTWGLVE1DZLu1x7mSeigr1wecxWaU4vN/0tQWWt9JLU0e0dED9TxYOdmiJgrDw8ONfyZERFRjAj3tMaW3j9rScsvwzzF9pOHOyHxo/40IScoqxvYvX8bIkaOq5IuSJPPyXJaGzZkzR1VS5lIwIiLr5uVqh9u6e6tN+hVJebHucC72VLoZlafxwWlb2brAXZuOY4ci4R6YapgoLCoqUvkIK/cp/fv3Zx9DRFRHSPoiyTUrhRNlebLdmTMIzI1BM9gj1bYZHJoPwZ7oIkO/cSyhSG3v/pmC7s1c1NJkyWsoN6rIzCcK+/bta/wzISKiWuHnbofbe3irLatAi43Hc7H+cC7+2rARRZlxeP75X6oklRfyXPJHydIwuVk0cOBAvltERGToV+7o5aO2lJxS/HU4V+U0PBBzPu1FrsYXuba+mLcBWHIyCrd08IBv8SmE/7VcLTWWlUpnzpxhixIR1THOzs7o3r272iQn+sGDB7Fv3z6EOpVjxoNNkZpTijWHcvDjljjE5jqoz5GJw51nC9T22sok9G8llZM9MKCVGxztWTnZLCcKpTLmlTRs2LC650NERLXIy+X8MrKvNba4dzHUcuNLqdifmJjI94iIiC5Jlord1cdHbQlZMmmYo6onH4krMrxGHuufe8FLMwKRUZHoN3QMAgJ2slWJiOowyYcuEYayST504e9hj1s72OPIysVoovNAqkMIku1bIbNEn6+wpEyHv4/mqs3dyUblVx/Z0RPdmrnA1oaVk81mojA4OPiKH2eOQiIiy9O0cQP1v+QklOXGF5L9IigoqNbPjYiILE99L3tM7+erNimwJfkMZTuRWGx4TZZNALIQgOM2PaFt2A6/7s3F7T2d4ezAiBEiorrswgJXknpCKie7Ze9Gk5LdyNb4Ic2xDRJtmiGvVD91lVtUjmV7stVWz8NORadLpKHkNrywyC7V8kTh8ePHqzyX3CKnT5/Gc889hyeeeKJW3w8pxf32228b1r+PGTOmVo9PRFRXyJ09qW4shUsq5yisuM6/9dZbanmYvI6IiOh6C2w9MNBPbdGpxSrKcO3hXJxJ/nfSUKOBbUAHLNyQhcm96rFxiYisLNJQqiaPHDkSUVFRKp+hLFH2KgxHM2xFuwGTcaYoSEUV5hfrE6yn5JTh260Zamvq76AKoEikYWM//fJlquWJwtatW1+0LzQ0VEUaPvzww3jooYdQm+vd5Xw2bdqEiIgIThQSEVWTJJNfsGCBqm4shUskJ2FF1WOZJFy9erWqesxCJkREdCOa+Dvi4Zv81SYThav2pOHTlQfh6NsU/UOcmX+KiMhKSaCCFLySTcYjJ0+eVFGG44eEqrmf+ePK8dmy3Vh/vBBxJfWg1emjCKNSS7Dw7zS1tW/opIqgDO/goXLo0vUzaqtJKexjx46hNvn7++PRRx9FWVkZkpKSavXYRER1zfjx49Vk4KxZs1ThkgoSSSj75eNERETG0iLAETMGemH2qJFwrNca03ZuZ+MSERHs7OzQtm1btVVwsreBbfJOhOadQws4INmmKTJc2iGh2MvwmsNxRWr77x/J6NnCFaPCPHBTqDvcnFg5udYnCouLi1UkyvUUMpFchuvWrcPnn3+OEydO4LvvvlOVcC701VdfqY/l5uaiT58+ePnll+Hr62usUyciokpkMnDIkCHw9PRUz9esWaNSOzCSkIiIjEmKY8lWWKivjlyccgI58UexL8PZkBOXeXGJiKiye++9Vy1LluXJDtEnEZx3EiFwRbJtc6Q7t0VKsYt6XbkOiDidrzZHuyQMaiOVkz3RN8QNDnbMZ2j0iUI3N7eL9hUUFMDd3R1Lliy55q/z7LPPqjdYQkpXrlypvsaFPvjgA7zwwgv49NNP0bhxY8ybNw8333wzdu7cyUErEVENqTwpKImFOUlIRETGtmjRIrzyyitV9vXt29fw+KWXXlIBAkRERJXnoySATLaMjAy1NFkmDZ0TD2F0Ux36DJ+MPw5k44+DOYjP1FdWLi7Tqby4snk42+Dm9pLP0ANdmrjAhpWTjTNRuHjx4ov2eXt7o2PHjvDyOh/yeTWvvfYaHB0dERcXh0ceeeSij0u5bHnN888/j7vvvlvt+/HHH1Wy/VWrVuHWW2+tzukTEREREZGJzZgx44r5xRlNSEREV+Lj44PBgwerTSLUVd8R4Ignbq6HOzoBc9/5BqkOrZFo0xQFZfrpr5zCcvyyK0ttPs7leKZ/CRp46Az9TlBQkNU3erUmCiUC0BhkkvBKDh06pGaIhw8fbtjXqFEjlVx/48aNaqJQlio8/fTTKjJRIhLz8vLUnUc/P7/LLpGWrUJOTo5RvhciIiL2OURE144DMuPiOIeIrNmFE3zp6elo6JIP7/wtaIFwpGkaINGmORJ0wYCtfi4qNTMXY4f0h06rjzxkJPsN5igsLy9XkYAykXehsLAwGENsbOwl3/DAwEB1bCHL4aTqceVKzPb29pf9mlK588IlDiIzMxNarRbWrDYmTWvqGOY24Wuq8+F7aLx2MLefqdqWn59f5fpYUlICS2Iu7x/7nMvj9cp42OeYts3Y5xD7HPPHPsey2tJUx7WEsSr7nGsn80aPP/44oqKicPToUVVBuV5JHNrCDim6RtiX4orsxDP44/eVqqKyCAgIUGMfc1fTvw/VmiiMiIjAnXfeiZiYmMsWKTGGiok7BweHiyIRpcpxxcek6vG1mjt3rqrmWbmBg4OD1dJpDw8PWDtpB0s9Rm2cuyWcD99D47WDuf1M1abK111pB1dXV1gSc8mpyD7nyni9Mh72OaZtM/Y51o19jmVgn2NZbWmq41rCWJV9zvWRQrhdu3ZVgQ/Hjx9X+QwjIyPxy5K31LxS/+V5HOsYY6Jw5syZqqDInDlzavSXtaKycVpamlp7XkGeV44gvB4yyXi1Jc9ERETGwD6HiIhqC/scIqIrB0JIXQ3ZsrOzVT0MMuJE4alTp7B58+Yaj8CTJcx2dnbYsWMHQkJC1D7JQyi5C++6664aPTYREREREREREdUtMs9El2eDamjRogVSUlJQ06SC8qRJk/D222+rRJSypPnVV19VOQgnT55c48cnIiIiIiIiIiKyFtWaRpUlx/fffz8+/vhjNWmo0WiqfNzJyemavs7y5ctV/qaKfIN33303XFxcVM7BiryDCxcuxJQpU1C/fn21btzNzQ0rVqwwLEuuLvm6slXkQWQxEyaINSYm+TVtmzHJ741jMRPjYp9zMSYlNx72OaZtM/Y5ZC7FTCqwz7kY+xzjYZ9j2jZjn2McHOtcmUZXjcojF04MXuhav6SsC09MTLxov5+fn9oqk4jCvLw8VXjExqZagZCX/UXz9PRU52LtxUxksrSmE8TW1DFq49wt4Xz4HhqvHcztZ8oUnafcmBFy7bW0Yibmem031/MyBV6vLKstTXVcS/i7gX0Omeu13VzPyxR4vbKstjTVcdnnWA+OdWogojA8PBzGIB2XbNdCIghvNIqQiIiIiIiIiIiIjDhR2Ldv3+p8GhERmTmJ8patsLDQsO/AgQNwdnZWj4OCgtRGREREREREdY/x1vASEZHFW7RoEbp06VLlhpA8ln2yyceJiIiIiIiobmJNaCIiMpgxYwbGjBlz2RZhNCEREREREVHdZbUThawGdjFWAzMeVgMzbZuxGlj1SdX6pk2bXjXRs7ljBUrzxz7HstrSVMetqWOwzyFz/XkyBo5zLsbrlfGwzzFtm3GcYxyselwDVY/rElYDO4+VpIyH1cBM22asQEnmem031/MyBfY5ltWWpjouK1CSJTDXa7u5npcp8HplWW1pquOyz7EerHp8ZcxRSEREREREREREVkGr1Roeb9mypcpz4kQhERERERERERFZgWXLlqFDhw6G5yNGjECLFi3UftJjRCEREREREREREdVpMhk4ceJENVG4fft25Obmqv/bt2+v9nOyUI8ThUREREREREREVGfJ8uLZs2dj1KhRWLFiBXr27Ak3Nzf1vzyX/XPmzOEyZE4UEhERERERERFRXRYeHo7o6GjMmzcPNjZVY+bk+dy5cxEVFaVeZ+3sYKUWLlyotoqklVLhyNoTWNZGqfuaOkZtnLslnA/fQ+O1g7n9TJFlv3/scy7G65XxsM8xbZuxzyH2OeaPfY5ltaWpjmsJY1X2OdV35swZ9X+7du0u+fGK/WfOnEHHjh1hzmr698FqJwpnzpypNmlgT09PVWrdw8MD1q42St3X1DFq49wt4Xz4HhqvHcztZ4quna2trVk1F/ucS+P1ynjY55i2zdjnWDf2OZaBfY5ltaWpjmsJY1X2OdUjBUvEkSNH1HLjC8n+itd5m/k4sKb7HeYoJCIiIiIiIiKiOqtfv35o0qQJ3nzzTZSXl1f5mDx/66230LRpU/U6a8eJQiIiIiIiIiIiqrMkCm/BggVYvXo1xo0bV6XqsTyX/e+++67ZRYmbgtUuPSYiIiIiIiIiIuswfvx4/Prrr5g1axZ69+5t2C+RhLJfPk6cKCQiIiIiIiIiIisgk4FDhgxRtSrEmjVrMGzYMEYSVsKlx0REREREREREZBUqLy/u378/JwkvwIlCIiIiIiIiIiIist4chQsXLlSbVqtVzzMzMw2PrVVOTo7FHqM2zt0SzofvofHawdx+psiy3z/2ORfj9cp42OeYts3Y5xD7HPPHPsey2tJUx7WEsSr7HOPIz883PJa5oJKSEliSnBr+fdDodDodrJg0sKxNz87OhoeHB6yZ/IJ4e3tb5DFq49wt4Xz4HhqvHcztZ4rqxrXdXM/LFHi9sqy2NNVxLeHvBvY5ZK7XdnM9L1Pg9cqy2tJUx2WfY10ThW5ubupxXl4eXF1dYUlyavj6zqXHRERERERERERExIlCIiIiIiIiIiIi4kQhERERERERERERcaKQiIiIiIiIiIiIOFFIRERERERERERECouZEBEREREREREREScKiYiIiIiIiIiICLCz1kZYuHCh2rRarXqemZlpeGytcnJyLPYYtXHulnA+fA+N1w7m9jNFlv3+sc+5GK9XxsM+x7Rtxj6H2OeYP/Y5ltWWpjquJYxV2ecYR35+vuGxzAWVlJTAkuTU8O+DRqfT6WDFpIE9PT2RnZ0NDw8PWDP5BfH29rbIY9TGuVvC+fA9NF47mNvPFNWNa7u5npcp8HplWW1pquNawt8N7HPIXK/t5npepsDrlWW1pamOyz7HuiYK3dzc1OO8vDy4urrCkuTU8PWdOQqJiIiIiIiIiIiIE4VERERERERERETEiUIiIiIiIiIiIiLiRCERERERERERERFxopCIiIiIiIiIiIgUFjMhIiIiIiIiIiIiThQSERERERERERERJwqJiIiIiIiIiIiIE4VEREREREREREQk7Ky1GRYuXKg2rVarnmdmZhoeW6ucnByLPUZtnLslnA/fQ+O1g7n9TJFlv3/scy7G65XxsM8xbZuxzyH2OeaPfY5ltaWpjmsJY1X2OcaRn59veCxzQSUlJbAkOTX8+2C1E4UzZ85UmzSwp6cnvL294eHhAWsn7WCpx6iNc7eE8+F7aLx2MLefKbp2tra2ZtVc7HMujdcr42GfY9o2Y59j3djnWAb2OZbVlqY6riWMVdnnVF9iYqLaCgsLDftiYmLg7OysHgcFBanN2vsdVj0mIiIiIiIiIqI6bdGiRejSpQv69u1r2CePZZ9s8nGy4ohCIiIiIiIiIiKyDjNmzMCYMWMu+3FLiCasDZwoJCIiIiIiIiKiOs1SlhabGpceExEREREREREREScKiYiIiIiIiIiIiBOFRERERERERERExIlCIiIiIiIiIiIi4kQhERERERERERERKSxmQkRERERERERERJwoJCIiIiIiIiIiIk4UEhEREREREREREScKiYiIiIiIiIiIiBOFREREREREREREpNjBSi1cuFBtWq1WPc/MzDQ8tlY5OTkWe4zaOHdLOB++h8ZrB3P7mSLLfv/Y51yM1yvjYZ9j2jZjn0Psc8wf+xzLaktTHdcSxqrsc6g2fh80Op1OBytvYE9PT2RnZ8PDwwPWTCZLvb29LfIYtXHulnA+fA+N1w7m9jNFdePabq7nZQq8XllWW5rquJbwdwP7HDLXa7u5npcp8HplWW1pquOyzyFLkVPD13cbo39FIiIiIiIiIiIisjicKCQiIiIiIiIiIiJOFBIREREREREREREnComIiIiIiIiIiIgThURERERERERERMSJQiIiIiIiIiIiIlJYzISIiIiIiIiIiIg4UUhEREREREREREScKCQiIiIiIiIiIiJOFBIREREREREREREnComIiIiIiIiIiEhhMRMiIiIiIiIiIiLiRCERERERERERERFxopCIiIiIiIiIiIg4UUhEREREREREREScKCQiIiIiIiIiIiKFxUyIiIiIiIiIiIiIE4VEREREREREREQE2FlrIyxcuFBtWq1WPc/MzDQ8tlY5OTkWe4zaOHdLOB++h8ZrB3P7mSLLfv/Y51yM1yvjYZ9j2jZjn0Psc8wf+xzLaktTHdcSxqrsc6g2fh+sdqJw5syZasvOzoaXlxdsbW3VZu1qow1q6hjm9v6Z6nz4HhqvHcztZ4qu/73T6XRm0Wzscy6N1yvjYZ9j2jZjn2Pd2OdYBvY5ltWWpjquJYxV2eeQbQ2Pdax2orBCenq6+j84ONjUp0JERDVwjff09DSbdmWfQ0RUd7HPISKiutDvWP1EoY+Pj2qIc+fOmdVg0hS6deuG3bt312h4rEzIxsbGwsPDw6LO3VLOh++hcdqhJn9WqXZItHijRo0M13hzwT7nPF6vjId9jmnbjH0Osc8xf+xzLKctTXVcSxmrss+h2uh3rH6i0MZGX/hZJgmtfUJAwldrow3kGMY+Tm2du7mfD99D47ZDTfyskmmu8eaCfc55vF4ZD/sc07YZ+xyqwD7HfLHPsby2NNVxzX2syj6HaqPfMa8RFJk8h5alMrdzN9X5mFs7mOrcLbkdiKyFJf+emtu5s88xbZuZ288DEdWt31NzO3f2OaZtM3P7eaC6SaMzl0zvJiIhxhJNKKGbjBxiWxN/X3hdqBvM9dpurudVF7GtLZ+1vIfW8n3WZeb6HprredVFbGvLZy3vobV8n3VdTg2/j1YfUejo6IiXXnpJ/U81i21t+azlPbSW77MuM9f30FzPqy5iW1s+a3kPreX7rMvM9T001/Oqi9jWls9a3kNr+T7rOscafh+tPqKQiIiIiIiIiIiIGFFIREREREREREREnCgkIiIiIiIiIiIiThQSERERERERERGRYgcrUVBQgFOnTsHf3x8NGjS45GukAPSxY8dQVlaGtm3bws7OaprH6KKjo1UlnmbNmsHNza3KxyIjI5GQkFBln4uLCzp37lzLZ0mXsnfvXhQWFl6038fHB6GhoVX2JSUlITY2Vr3Pvr6+FtGgch1ISUlBnz59oNFoLvmaEydOqDaQ64CDg0O1X0PGV1JSgpMnT8Ld3R2NGjWCjc2la3KdOXNGVQGTn1lnZ+dqv8YczpOuTvoU+b1u0qQJvLy8qnwsPj4eUVFRVfbJ+9G7d282rRk4cuQIsrKyLtrv6uqKTp06VdmXnp6u/oYIDg5GYGAgLEFMTIzqJ7t06XLZ33H5njIzM9G6dWv1fVf3NWR8Wq1WXcvt7e3RtGnTy44Nzp07p65BISEhl60+eS2vMYfzpKtLS0tTbSnXIhlbXnidOn78+EWf06NHD/X+kGnJ310yfrmQra0tevXqVWVfbm6u+r2S97hx48awBMnJyTh9+jTatWt30d9DFeLi4lQbtGjR4oZeQ8Yn81Fnz55FaWmpGl9frlDJtYzBb3icrqvjkpKSdPfcc4/O09NTFxYWpvPx8dH16tVLd/bs2SqvO3nypK5169a6evXq6YKDg3UNGjTQRUREmOy8LdXvv/+ua9Omja5ly5a60NBQnYuLi27evHlVXjNz5kz1PvTp08ew3XnnnSY7Z6pq0qRJVd6b3r176+RSIb9HFcrKynT33XefzsnJSb3Pjo6Ouvnz55t1Uy5fvlzXt29fnbe3t/p+CgsLL3rNuXPndB07dtT5+vrqmjZtqvP399f9/fff1/0aMr78/HzdrFmz1LWjffv2usDAQHWt2blzZ5XXpaamqp9Zuea3aNFC/b9s2bLrfo05nCdd3bZt23Tdu3fXNWrUSP1eyjVJrk2lpaWG17zzzjs6V1fXKte1wYMHs3nNxJNPPlnlvZHNwcFBN2jQoCqvkz5G+pqKPkfeZ61WqzNXmzZt0t1yyy2qr5A+5/jx4xe9JisrS32f7u7uupCQEPX/Dz/8cN2vIeMrLy/Xvfrqq2pcINfwxo0bq/HBmjVrqryuoKBAN3bsWPX3rowjnJ2ddQsXLrzu15jDedLVHT16VDd06FDVt3fq1Em1p7RrTk6O4TW//PKLztbW9qLrWnp6OpvYDPznP/+56L3x8PBQf9NX9vnnnxt+X+T/UaNGqb/xzNX+/ft1t99+u7oWSJ/z559/XvSa4uJiNc6T33+5XsjfTPI30vW+hmrGp59+qv6ebd68uervZSzxzTffVHmN/N3z4IMPVvl76MK5lmt5zbWo8xOFu3fv1n399deGQUNeXp4aIMhkYWVysR89erSaABEzZszQ1a9f/5KTCXR5X3zxhS46OtrwfPPmzRddrGSiUDpVsgz//POPeg/lvazwwQcf6Ly8vNQEuwgPD9fZ2dnpVq5cqTNXr7/+uvoe5A+4y00UDhw4UG3SSYpnn31WTSxmZmZe12vI+GSCdsGCBYY/0uSaPm3aNF1QUJDhui0mTpyo69y5s7rWC/njRv7YiYuLu67XmMN50tUtWbJEd+TIEcNzmYyRP+g/++wzwz5pW5lEJMsgN3I1Go3u22+/NexbsWKFzt7eXk0MixMnTqjJ9Q8//FBnrj7++GPd6tWr1U2Cy00UTp8+Xf0RL5OBQn5u5fs8c+bMdb2GjE/6+Bdf/P/27gTOpvL/A/hjCaFQdn7INi22RKXFOraUNcmSfa2QEKax72JaGEmIGCKDzNgmOyE7RYtowyRLellDnv/r8/2/nvM697pz59DM3HNnPu/Xa8rc88zcc++dc77nec73+T6D9blz56wBufDwcLnpcOrUKatdv379pGOHxATANQb+fnfv3n1bbdywn5Q4HNP2RJL4+HjpL+Ja0MB7i/MTBYcLFy7I8TJ8+HCPQTccH4sWLZLvcSzh+OnTp492q3nz5ukFCxboEydOJDhQOGzYMBnkxrUq4IYCXqe9j+ekDSUP/A3a+wEff/yx3HQ4ePCg9diUKVPk/GKuKXA+wjVBdHT0bbVxItUPFPqCkdn06dNbg4d79+6VA2rHjh1Wm99//10OCmQh0Z3De4xR7BkzZngMFNarV0/v2bNHLnTdnBFAWrdu3VruatiVK1dOd+/e3eOx0NDQoBgATmig8NixY/L46tWrrccw+IcTK242OG1DKWfr1q3yeZgBa3SUEFBxsWTvRCFYmruhTtq4YT/pzuFOLDrKBt7TMmXK6AMHDshF07Vr1/j2utjbb78txwIyoIyGDRvKdYNd586dg2IAGDesfQ0U4vUhUwNZKwauh/Lly6eHDh3quA2lHHTg8FmuWbPGGpRDxihuRNohCwfXuk7buGE/6c4hAaVNmzYe15nIUEP24TfffMOkE5fDYAzGBdD3N3r16iWZhHY4fpAY4PZ+K2asJDRQiMHOgQMHejxWqVIluaF9O20oZeDcjT7mRx99ZD2GJANc/9jh+qhBgwa31cYJ30WTUrldu3ZJnQFTv2Pfvn3yf3uNvMKFC6sCBQpY28g51NvaunWrWrlypWrVqpXU3mrevLlHm7Vr16r27dtLjSjU74qNjeVb7EKoG7VkyRLVpUsX6zHUTDh06JDUW7J7/PHHg/p4Mftuf12oyVGqVClrm5M2lLLnctSHRI0g+Oabb6ROk/3zwfby5ctbn4+TNm7YT3Lu6tWrEnPi4uLUa6+9pm7evOlxzgKcs15++WVVu3ZtlTdvXjVr1iy+xS6E42L27NmqTZs2HvX8cFz4ijmob4iYFIxQwwx/u/bXhdqZ+N6cB5y0oZSDczmUKFFC/o/aT6hH5/23WblyZevzcdLGDftJtwcxZ926dWro0KESX958802P7ajT3qhRI/lCje8xY8bwLXapmTNnqvr160vfP7GYgzqxqDsbjM6dOyd1Nf3135y0oZRz4MABucZBnUhzjYQ+hL/Px0kbp9Lcah0bN25UH330kZo+fbr1GA4KFPT1LjCLoo/YRrcHBVQHDhwoFyUoovnOO+94FExGR23w4MEqX7580qELDw+XgUQcDCiuTO4xf/58WdynXbt2HgPBOAl5F0UN9uPF7Dsu6BJ6XU7aUMpAcelhw4apfv36WQMK5jPw97fppI0b9pOcQ6xBzMG5CYuWhIWFeVzwV6hQQeKS6TR/+OGHqnPnznLhVbVqVb7VLrJmzRpZfMZ7oBfHha/jBbEIHfJgWUzLzt95wCy+46QNpQwsANK7d2+5AW7OJf4+n507dzpu44b9JOdw3kHMuXTpkiyQ17VrV/XQQw9Z25GMsnfvXmsxJiRDNG7cWG4WvvLKK3yrXQSLmO7YsUMtW7bM43EcM96LaZnjB9uwYFCwceM1MvlfiLdjx47qmWeeUTVq1LAW18HAob/Px0kbp9KntdVccaJGAO3QoYP1OAYIccfWG1Y05Wqmt69SpUpypw13wpcvX6569uypoqKirO24u4ZBQnNnfNSoUbLq8RdffHGHnywl5102HDP2Fd3MgLr3MRPsx4t5Xf/880+Cr8tJG0p+uNtZt25dFRoaqkaMGHFbf5sp+ff7X/aTnCtUqJDEHNxBRSbNu+++q8aOHWttx/tvOszQo0cPVa5cObVw4UK+zS6MOchyQnatna/rNBwvEKzHjNvOV5QwZBHVq1dPbkDYEw3c9hn+l/0k57A6LmIOsnNwE2rFihXS1zFwDrMPMj3//PPy9dlnn/FtdmHMwQzCBg0aeDzOmMNzRSChn9m0aVO5GbF48WKVLl26gMScNDNQiDs7yGTDAOHEiRM9tuHOz7Vr12Spe/vdIiwvjmmxdOeeffZZ9eSTT6pVq1Yl2AaDhblz55YsAnKP/fv3y3HjndmRI0cOmW7r/Xnh+2A+XnAeAO/XdfLkSet1OWlDyQuDb9WrV5eL8AULFsgFu5HQ52P/23TSxg37SXcGWR3okPmLOYCbVYw57nL69GkVExNzS8wxx4yv4wWx6J577lHByE3nK/JfgqVOnToqS5YsavXq1SpbtmzWNnwG6MD5+3yctHHDftKdKViwoGrdujVjThBC1tXcuXNlbMCUI0ss5oApIxOMf6sYRPJ3HnDShpIXxqQwSHjs2DG1YcMGK7kKcF5HZqC/z8dJG6fSp5UBDwwSIt0bmQbeMPUII6zIfjPWr18vqZv4OXIGi+OYO/z2kzBqOdjTX5FKa3f06FE5GMqUKcO32kVmzJihihUrJtk43vAYOnQGpifjjmowHy9PPPGEdDjt5wFkJ2EQ0LwuJ20o+Rw/flzS75FttGjRolvKRaAeKi5y7J8Pzi3INDOfj5M2bthPcgZ3W70hpthjjncbZN3s3r2bMcdl5syZozJnziy1JL3huEDdY9zENTALIZiPF8RXTH+3nwfi4+NlKqh5XU7aUPJBOQMMvmEQAYNv3oPS+B7XBfbPB30H9CHM5+OkjRv2k+485vz0009+Yw76Qps2bWLMcRnEECQJderU6ZZtOC5QrgzHib09skVxgyoY4Vq0WrVqHucBZJ2h5Ic5DzhpQ8k/SIhMZQwSoq/gDZ+DvQ+O6yLvPriTNo7oVA6rTGKlr6pVq+otW7Z4fGGVSWPw4ME6Z86csvJRVFSULly4sG7btm1A9z3Y4P18+OGHdUREhKwKiyXla9euLe8/VjeGGzduyCprEydOlDZYDbl48eKyOo/3KrQUOPgssLKX9wp5BpZpz5o1q6x8vHz5ct2sWTOdN29eHR8fr90Kf4M47keOHCmrga1bt06+x6rFxqRJk+R1RUZG6oULF+pSpUrJapt2TtpQ0jtz5owuWbKkrEK3fv16j3P5+fPnrXZz5syRFcJwjomOjtYVKlTQzzzzjMcqdU7auGE/KXFVqlSR89TKlSv10qVLdYsWLWSV2G3btlltnn76aT1ixAi9YsUKWWka73WxYsX0qVOn+Ba7CK4NvFfpM06ePCkx5sUXX5SY061bNzkPY0VRt8IKmjjucZ2DmINrS3xvj5OLFy/WGTNm1KNHj9ZLlizRjz/+uFwPXb9+/bbaUPJc0z755JM6f/78cu6wn8vt5w5cS+DzCQsL08uWLZMVcHFdcPHixdtq44b9pMQ1adJEDxo0SH/xxRc6JiZGVo3OkCGDHKcGrokHDBggbbACco0aNfR99913y8rnFFhYBTY0NNTntkuXLumQkBD57HC8hIeHy+ccFxen3bzaMY772NhYiTm4vsT3v/zyi9Vm+/btOlOmTLpv377y91m/fn1Z5djeF3LShpLv/JI9e3bpX9rP5b/++qvVBqupZ8uWTXft2lWuh5o3b67z5Mkjq93fThsn0uE/KhXDKoj22lB2S5cutWqv4W3ASnvR0dGSHYW6Uq+//votmSDkHxYvmTx5skxZReorish3795dphb7aoO7MpiejKlGfK/dA7VXBg0aJDW8fN3NACw+gwxdTLEMCQlRb731lquL+6LkgHexYpg0aZLcaTcwTRR1ZJAdi6ywPn36yFQeOydtKOkLTqNguC84n9jrAeFOKLKTsMhBlSpVVP/+/W/JsHDSxg37SYln0kRGRqrt27fL9G5kayLm2KdXmDbbtm2TBWVQRxfx3T41jwILWaBYNOuDDz5QFStW9NkGi3dMmDBBFgjC54vzrnctQzdBbWYsnOMNxzlqNRvI1EAGPzJdka0yYMCAWzJWnLShpIWi7w0bNvS57e2335ZVUo0tW7aoqVOnykIi+JvEQhdYXd3OSRs37Cf5h+wq1H9Ethmyf0qVKiV9GMQee30xLJyJjCD0L1ETt1evXh59IQosZAqiTAn6Lt71Ce3lMMaNGyczEzFegPrGyLZzK7MKt7c2bdrIdZHx9ddfy/UostMfeeQRiSeo9WznpA0lvVq1at1SBx+wqAm+DMxAioiIkD44zkH4Oy5evLjHzzhpk5hUP1BIREREREREREREiUsTNQqJiIiIiIiIiIjIPw4UEhEREREREREREQcKiYiIiIiIiIiIiAOFRERERERERERExIFCIiIiIiIiIiIi4kAhERERERERERERCS5mQkRERERERERERBwoJAqUK1euqEqVKqlvv/3WUfuxY8eqAQMGqGDz22+/qQ8//FDt3Lkz0LtCRJSmhYaGqri4OEdt58yZo9q2bauCzd9//60iIyPVunXrAr0rRERpGmIIYokTiE2IUcFGa62mTJmiYmJi1M2bNwO9O0RJhhmFRAHy77//qj179qiLFy86av/rr7+qo0ePqmDzyy+/qKioKFWlShW1d+/eQO8OEVGatX//fnXu3DlHbePj49Xhw4dVsPnjjz9UbGysdDgXL14c6N0hIkqzEEMQS5xAbEKMCjZ//fWXWrt2rWrSpImKiIgI9O4QJRkOFBIFSNasWdWuXbtU2bJlU/VnULVqVbVx40aVK1cutWnTpkDvDhFRmoUsu7p166rULCQkRK1atUpVrFhRbdiwIdC7Q0SUZs2dO1e1b99epWb33XefWrZsmWrUqBFjDqUqGQO9A0RpQevWrVXNmjXViRMn1Pr169UTTzyhhg0bprp3765mz56typQpI+0uXLig3n//fRlYy5w5s2rVqpX8rN28efPU0qVLZXrVc889p9544w2VPn16K8UfA3Nnz56V35EhQwYJ0C+++KJHivwnn3yioqOj1eXLl1W5cuXUoEGDVP78+WX7pUuX1KRJk9SWLVtUpkyZVP369VWPHj3kd8GsWbPk+fGzeB0DBw5U9957r9/XnzFjRnmeAwcOJPl7S0REnlCmIkeOHHJuRgcmX758ktndt29f9dZbb6k6depIu2vXrklpCAysIcsdHZ1XX33ViimwcuVK9emnn6pTp06pZ599VoWFhaksWbJ4PM/9998v7a5evaqaNm2qunXr5rE/iBn4HYhNGMjDPpQqVUq23bhxQ02ePFmmnWEfqlWrJvtpngP7j59Ftkn58uUl5hQoUCDRj/yxxx5jzCEiSgHou2DWE2YP4Xz9zz//SH8HZZNq1aql2rVrZ/VB0O9BTECfB9v69+8vfR5jx44daurUqVK6qEKFCtJfypkzp2zDFN/vvvtO+lSfffaZxAXzO+666y7rd6APNG3aNHX8+HFVvHhx1atXLyn3ZGAf0A9Cnwd9GcQy8xybN2+W5z958uQt8SqxmIOfI0o1NBElu/Lly+vMmTPrPn366E2bNumjR4/qCxcuaByC27dvlzaXLl3SFSpU0I8++qj+/PPP9cqVK3Xr1q11TEyMbO/WrZv8jmbNmukvv/xSz5s3T+fMmVO///771vM89thjOkuWLLp///56w4YNeuLEiTpdunR669atVpsePXrosmXL6oULF0ob/N6CBQvqv/76S7a3b99eV65cWcfGxuq4uDjdu3dv/c4778i2GTNm6Lx58+r58+frjRs36gkTJug2bdok+vqPHTums2XLJq+NiIiSF+IE4kWrVq302rVr9aFDh+Tx+++/Xy9YsED+/e+//+q6devq4sWL67lz50pc6dmzp46MjJTtY8eO1ZkyZdLVqlWTeLRs2TJdpEgRiWPez4O4sW7dOokRd999t46KirLajB8/XhctWlTPnj1b4l94eLjOnj27xAUYNmyYLlmypI6Ojtbr16/XQ4YMsZ4D+4TYMX36dL1582bZtzp16iT6+v/++29dqFAhfe+99ybxO0tERN769u0rsaB27dp61apVet++fVa/BLHE6NKli86TJ4+eNm2axAzEg7CwMNmG2JQhQwbpKyxZskSvXr1a+k9NmjSxfn7AgAHyPPXq1dNr1qzRixYt0vny5dPDhw+32uD34DkQLxBz0BfKmjWr3rZtm2xHLMqdO7f0o7AdfZyWLVvKtsOHD0s/Cv2bLVu26E8++URXqlQp0Q/8+vXrst/o1509e5Z/IJQqcKCQKAUg0CGo2XkPFL733ns6V65c1oCdcfXqVfk/BvSKFSsmwcgemGvVqmV9j4DcqFEjj59HJw+BFb799ludPn16ffz4cY82CG4RERHy75CQED1r1iyf+9CpUyfdsWNHn9v8wT5igBHB3b7/RESU9DCAV7p0aRkMtLMPFGLgL2PGjPrIkSM+z+no3GGQ7vz589a2yZMn6xIlSng8D25w2bVr1063aNFC/o0OE877poNmNG7cWPfq1Uv+jcFKDA762oeRI0fqmjVr+tzmT9euXSXmIMb+/PPPibYnIqI7h/4IkhfQt7GzDxTu379fzslINPB1TkdswnZ7TEKyBG5YmViG/gwG+S5fvmy1QZzA88CNGzd0/vz5JaHB7o033tANGza0+lNt27b1uQ+4aYabZ762+TNmzBgr5iAJgyg14NRjohSCdHx/kOqOKVcm9d2wp+Nj2hWm8RqFChVSa9as8WhvT603bTBlDMx05GbNmkn6P+D/WHDk+++/l+9RAH7o0KEytRn/xrRosw/4vnPnzjJNGdOeka5v3z9fZs6cqQ4ePChTETCN+ccff1QPP/yw358hIqL/Budn+xRiXzEH5/eSJUt6PG4/p2Mbphb7iif26VZ2aLNt2zb59/bt22UKGkpkpEuXTuINvn7//XcpX2HiCqanodQF6ieitqDZhxo1aqiRI0fKtDFMi3766aetKckJQS1cxBtMe3vqqack/hQrVszBO0ZERHcKNdezZ8/uN+agj4O+TkIxB/HGHpMQT1AiAwuGoMQFPPLII+ruu+/2GZfQl8GCVuPHj5fp0CbmYLuJHZiqjLJMBQsWVA0aNPDoyyBm4OdRyqlFixZSbiOx8kro1yBOLV++XL300ksSc6pXr36b7x6R+3CgkCgFFy/x58qVK1YQTIh9kBBMx8tpG9TiQBBGjQ9vuXPnlv9/8MEHEhgR8BBosd+o5YHHXn75ZQnIqAuCAUME03Hjxt1Sj8rASmf9+vVT06dPl6CJfUMA5UAhEVHgY46/Tl1SxRx8/+6778pAoN0999wj/0eMQExAvajmzZvLfqHOE2odYmBw586dMvCHGlTokKE9alYl9JoQm4YMGSI354oWLSoxp2HDhn5fJxERuTPmgD3uJBZzADGgSJEiHu3MYCDiDAYJ58+fr7p27Sq1CMeMGSP1eVHPEDEDtdxHjx4tqzC/8sorUsvX1403PC9iDtrgphfqsePniVIDDhQSuUTp0qWTfbUsFOM9c+aMFLb/3//+57MNAiHuouHr5s2bMgjYs2dPCZaAAUN8mYVNEGQxgGjPOjFee+01uXOHoAwoCowFTdCeiIgCG3M+//xzydbwHsRLypiDjhRiiXe2ux0y1PEFI0aMUJ06dZKBQpNJjwW2AFmCiClYoMssAmaHziFiEQYVAYXwuYgWEZE7Yg4G5dAPMckJSa1EiRLSj0HGur+Yg5tQ+ALciOrQoYP0TbCCMX7HqFGjZNsPP/wgmZIvvPCCev7552/5PbiphVlZsbGxVsz56quvkuW1EaW0hOekEFGKwh0prOQVERFhPbZ161aZupVU0BFDAOzSpYs6f/68PIYO3KJFi6zAhmnHCOKAYItVxEy6PjIRzRRlc3fOtPGG34lpBpGRkdZj6PDxThsRUeC1atVKVhzGao9YbRgOHTokqxcnlUcffVRuLPXu3Vs6iMaXX36pYmJi5N/IXMfqlva4YjI/0IH7+uuvPbaBr+nHu3fvlniDTBCTccKYQ0TkDig/hCw/JBEguxBQhgKzlJIKZmYhtoWHh3v0V3bt2iXxxAzuHT58+Ja+DG6YIS7FxcV5bEso5iBuDRo0SGZNmenJiDmIo+hbEQU7DhQSuQSyI5DdMXHiRJU3b16pqRQWFiZTp5IKAh5qGiI1v0CBAjLdK1euXGrp0qUygAi4y4d9wZ2/woULq7Vr11pTlZEdgvqGyEZEdiA6f6hB6D3d4Ny5c1JTCtOYkb1osNNGROQOiDMrVqyQL5z3UReqZcuW6oEHHkjS58GUYpSswO998MEHJebghhj+DYhxqFmFKV/4QtzAYB889NBDUt8QcQR1qXCzCwOL3nUVr1+/rjp27KgGDhwo2R/2mPPTTz9ZnVIiIgoM9EFWrVol5+Q8efJIPwLn/oRmON2padOmqZo1a0p2H/oyiHXokyCeAB7DrCn0cbAPGLj8+OOPZVo04hJKZSCzEH0hxBMzO8obZlwhu71evXoeMQfx5siRI0n6mogCIR1WNAnIMxOlIbhzhbtc9kEz3G3au3evBK5s2bJ5PI46TKjfhM6V/c4Vsj/QkTL+/PNPdfr0aelAATIS0QnDYiPGzz//LPU7vIu5o7AvfhYDhPaiwGYfjh49KkEdAdzUCDGOHz8ugRAdPF9T1s6ePSv7i2wS7wFE7I938XsiIko6x44dk6w67xpNmIaLxxAn7HC+R0aFfZAQNWhRQN50rgCZ6DiHm3O7r+dB5uCFCxekA+Z9/j9x4oTEDV/F4fF7cUmK3+VdgwqxDj+Pn/WOV3Dx4kXJHkEnzZ7hjulniL/o7CW28BYREd0Z0y9AQoGdr34JoI+Aha5w08f0MRBv8DjO4wZ+JzL0MOiHuIAYgmQHDPbZ+xx4HPUB7RCHMC0YfSkM/PnaZ8QI9I+8+zKIdYhliEe+6iri5hTiqXcfDv00lGpC/DN1eImCFQcKiYiIiIiIiIiIiFOPiYiIiIiIiIiIiAOFRERERERERERExIFCIiIiIiIiIiIi4kAhERERERERERERifT//z8iIiIiIiIiIiJKyzhQSERERERERERERBwoJCIiIiIiIiIiIg4UEhEREREREREREQcKiYiIiIiIiIiIiAOFREREREREREREJLiYCREREREREREREXGgkIiIiIiIiIiISJH6P3VwVra0k6IVAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def bin_groups(edges):\n", + " # Unique bins, in the order they appear in the data vector\n", + " unique = []\n", + " for e in map(tuple, edges):\n", + " if e not in unique:\n", + " unique.append(e)\n", + " return unique\n", + "\n", + "c_fid, c_best = fid.counts, best.counts\n", + "z_bins = bin_groups(c_fid.z_edges)\n", + "\n", + "fig, axes = plt.subplots(2, 3, figsize=(13, 7), sharex=True, sharey=True)\n", + "for ax, (z0, z1) in zip(axes.flat, z_bins):\n", + " sel = np.all(c_fid.z_edges == (z0, z1), axis=1)\n", + " richness = 0.5 * (10 ** c_fid.proxy_edges[sel, 0] + 10 ** c_fid.proxy_edges[sel, 1])\n", + " ax.errorbar(richness, c_fid.data[sel], yerr=c_fid.errors[sel], fmt=\"o\", color=\"black\",\n", + " mfc=\"white\", ms=6, capsize=3, label=\"data\")\n", + " ax.plot(richness, c_fid.theory[sel], ls=\"--\", lw=1.5, color=\"0.45\", label=\"starting point\")\n", + " ax.plot(richness, c_best.theory[sel], ls=\"-\", lw=2, color=\"#2a78d6\", label=\"best fit\")\n", + " ax.set_title(f\"${z0:.1f} < z < {z1:.1f}$\", fontsize=11)\n", + " ax.set_xscale(\"log\")\n", + " ax.set_yscale(\"log\")\n", + " ax.set_xticks([20, 35, 70, 100, 200])\n", + " ax.xaxis.set_major_formatter(mticker.ScalarFormatter())\n", + " ax.xaxis.set_minor_formatter(mticker.NullFormatter())\n", + " ax.grid(alpha=0.3, which=\"both\", lw=0.5)\n", + "for ax in axes[1]:\n", + " ax.set_xlabel(r\"richness $\\lambda$\")\n", + "for ax in axes[:, 0]:\n", + " ax.set_ylabel(\"number of clusters\")\n", + "handles, labels = axes[0, 0].get_legend_handles_labels()\n", + "axes[0, 0].legend(handles[::-1], labels[::-1], frameon=False) # data first\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "d3315001", + "metadata": {}, + "source": [ + "## 7. Stacked $\\Delta\\Sigma$ profiles\n", + "One panel per redshift bin and one colour per richness bin. Points are the data, solid lines the best fit and dashed lines the starting point." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "13e43e17", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-09T07:45:44.028508Z", + "iopub.status.busy": "2026-10-09T07:45:44.028277Z", + "iopub.status.idle": "2026-10-09T07:45:45.274802Z", + "shell.execute_reply": "2026-10-09T07:45:45.274019Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "s_fid, s_best = fid.shear, best.shear\n", + "richness_bins = bin_groups(s_fid.proxy_edges)\n", + "colors = [\"#2a78d6\", \"#eb6834\", \"#1baf7a\", \"#eda100\"]\n", + "markers = [\"o\", \"s\", \"^\", \"D\"]\n", + "\n", + "fig, axes = plt.subplots(2, 3, figsize=(14, 8), sharex=True, sharey=True)\n", + "for ax, (z0, z1) in zip(axes.flat, bin_groups(s_fid.z_edges)):\n", + " for (l0, l1), color, marker in zip(richness_bins, colors, markers):\n", + " sel = np.all(s_fid.z_edges == (z0, z1), axis=1) & np.all(s_fid.proxy_edges == (l0, l1), axis=1)\n", + " radius = s_fid.radius[sel]\n", + " ax.errorbar(radius, s_fid.data[sel], yerr=s_fid.errors[sel], fmt=marker, color=color,\n", + " mfc=\"white\", ms=5, capsize=2, lw=1,\n", + " label=rf\"${10**l0:.0f} < \\lambda < {10**l1:.0f}$\")\n", + " ax.plot(radius, s_best.theory[sel], ls=\"-\", lw=1.8, color=color)\n", + " ax.plot(radius, s_fid.theory[sel], ls=\"--\", lw=1.2, color=color, alpha=0.7)\n", + " ax.set_title(f\"${z0:.1f} < z < {z1:.1f}$\", fontsize=11)\n", + " ax.set_xscale(\"log\")\n", + " ax.set_yscale(\"log\")\n", + " ax.set_ylim(3e12, 2e14) # error bars of the noisiest bins reach zero\n", + " ax.set_xticks([1.2, 1.5, 2, 2.5, 3])\n", + " ax.xaxis.set_major_formatter(mticker.ScalarFormatter())\n", + " ax.xaxis.set_minor_formatter(mticker.NullFormatter())\n", + " ax.grid(alpha=0.3, which=\"both\", lw=0.5)\n", + "for ax in axes[1]:\n", + " ax.set_xlabel(r\"$R$ [Mpc]\")\n", + "for ax in axes[:, 0]:\n", + " ax.set_ylabel(r\"$\\Delta\\Sigma$ [M$_\\odot$ Mpc$^{-2}$]\")\n", + "axes[0, 0].legend(frameon=False, fontsize=9, loc=\"lower left\")\n", + "axes[0, 1].legend(\n", + " [plt.Line2D([], [], color=\"0.3\", lw=1.8), plt.Line2D([], [], color=\"0.3\", lw=1.2, ls=\"--\")],\n", + " [\"best fit\", \"starting point\"], frameon=False, fontsize=9, loc=\"lower left\",\n", + ")\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "d5b51988", + "metadata": {}, + "source": [ + "## 8. Changing a modelling choice\n", + "The configuration can also be given as a dictionary, so a modelling choice can be changed without editing the YAML file. Here we evaluate the best fit with other halo mass functions, as in `examples/cosmodc2_redmapper/hmf_analysis`. Only the halo mass function changes, the parameters stay at the best fit of the baseline (Despali16) chain." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "5a553f1b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-09T07:45:45.278205Z", + "iopub.status.busy": "2026-10-09T07:45:45.278046Z", + "iopub.status.idle": "2026-10-09T07:45:54.910825Z", + "shell.execute_reply": "2026-10-09T07:45:54.910071Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hmf counts chi2 DeltaSigma chi2 total chi2\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "despali16 24.0 206.8 230.8\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tinker08 25.5 207.8 233.2\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tinker10 74.6 207.7 282.2\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bocquet16 58.4 207.3 265.7\n" + ] + } + ], + "source": [ + "pipeline_config = yaml.safe_load(open(CONFIG))\n", + "\n", + "print(f\"{'hmf':10s} {'counts chi2':>12s} {'DeltaSigma chi2':>16s} {'total chi2':>11s}\")\n", + "for hmf in [\"despali16\", \"tinker08\", \"tinker10\", \"bocquet16\"]:\n", + " pipeline_config[\"CLPFirecrown\"][\"hmf\"] = hmf\n", + " prediction = compute_cluster_predictions(pipeline_config, SACC_FILE, FIDUCIAL_COSMOLOGY, params=bestfit)\n", + " print(f\"{hmf:10s} {block_chi2(prediction.counts):12.1f} {block_chi2(prediction.shear):16.1f} {prediction.chi2:11.1f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "f212eba1", + "metadata": {}, + "source": [ + "## 9. Notes\n", + "- **Parameter values.** For the cosmology the order of precedence is the Firecrown default, then the fiducial file, then `cosmological_parameters`, then `params`. For the cluster parameters it is `firecrown_parameters`, then `params`.\n", + "- **Missing parameters.** A parameter the likelihood needs and that is neither in `firecrown_parameters` nor in `params` raises an error, as it would in the chain. For example, `use_purity: true` needs the four `purity_*` parameters.\n", + "- **Fixed cosmology.** A fixed `cosmological_parameters` entry that differs from the fiducial cosmology raises the same error as `CLPFirecrown`.\n", + "- **Power spectrum.** Here CCL computes the linear matter power spectrum (with CAMB), while in the chain it comes from the CosmoSIS CAMB module. The chi-squared values can therefore differ slightly from the ones in the chain output.\n", + "- **Older interface.** `build_cluster_recipes_from_config(config, sacc_file, set_params, fiducial_cosmology=...)` returns the tuple `(counts_theory, counts_data, shear_theory, shear_data)`." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Firecrown_clp", + "language": "python", + "name": "firecrown_clp" + }, + "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.12.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}