diff --git a/causalpy/__init__.py b/causalpy/__init__.py index 135ae8e8..ddfa7abe 100644 --- a/causalpy/__init__.py +++ b/causalpy/__init__.py @@ -3,7 +3,9 @@ import causalpy.pymc_experiments import causalpy.pymc_models import causalpy.skl_experiments +import causalpy.skl_meta_learners import causalpy.skl_models +import causalpy.summary from causalpy.version import __version__ from .data import load_data diff --git a/causalpy/pymc_meta_learners.py b/causalpy/pymc_meta_learners.py new file mode 100644 index 00000000..8fc4b6ff --- /dev/null +++ b/causalpy/pymc_meta_learners.py @@ -0,0 +1,427 @@ +"PyMC based meta-learners." +from typing import Any, Dict, Optional + +import arviz as az +import numpy as np +import pandas as pd +from sklearn.model_selection import train_test_split +from xarray.core.dataarray import DataArray + +from causalpy.pymc_models import LogisticRegression, ModelBuilder +from causalpy.skl_meta_learners import ( + DRLearner, + MetaLearner, + SLearner, + TLearner, + XLearner, +) +from causalpy.summary import Summary +from causalpy.utils import _fit + + +class BayesianMetaLearner(MetaLearner): + "Base class for PyMC based meta-learners." + + def fit( + self, + X: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + coords: Dict[str, Any] = None, + ): + """ + Fits base-learners. + + Parameters + ---------- + X : pandas.DataFrame of shape (n_samples, n_featues). + Training data. + y : pandas.Series of shape (n_samples, ). + Target vector. + treated : pandas.Series of shape (n_samples, ). + coords : Dict[str, Any]. + Dictionary containing the keys coeffs and obs_indx. + """ + raise NotImplementedError() + + def ate_hdi(self, X) -> np.array: + """ + Estimates high density interval of average treatement effect on X. + + Parameters + ---------- + X : pandas.DataFrame of shape (n_samples, n_featues). + Feature matrix. + """ + cate = self.predict_cate(X) + hdi = az.hdi(cate.mean(dim="obs_ind")).mu.values + return hdi + + def cate_hdi(self, X) -> np.array: + """ + Estimates high density interval of conditional average treatement effect on X. + + Parameters + ---------- + X : pandas.DataFrame of shape (n_samples, n_featues). + Feature matrix. + """ + cate = self.predict_cate(X) + hdi = az.hdi(cate).mu.values + return hdi + + def summary(self) -> Summary: + "Returns summary." + hdi = self.ate_hdi(self.X) + ate = self.ate() + + s = Summary() + + s.add_title(["Conditional Average Treatment Effect Estimator Summary"]) + s.add_row("Number of observations", [self.index.shape[0]], 2) + s.add_row("Number of treated observations", [self.treated.sum()], 2) + s.add_row("Average treatement effect (ATE)", [ate], 2) + s.add_row("HDI for ATE", [tuple(hdi)], 1) + # Can bias be estimated in this setting? + # s.add_row("Estimated bias", [bias], 2) + s.add_title(["Base learners"]) + s.add_header(["", "Model", "R^2"], 1) + + for name, model in self.models.items(): + s.add_row(name, model, 1) + + return s + + def predict_cate(self, X: pd.DataFrame) -> DataArray: + """ + Predicts distribution of treatement effect. + + Parameters + ---------- + X : pandas.DataFrame of shape (n_samples, n_featues). + Feature matrix. + """ + raise NotImplementedError() + + +class BayesianSLearner(SLearner, BayesianMetaLearner): + """ + Implements PyMC version of S-learner described in [1]. S-learner estimates + conditional average treatment effect with the use of a single model. + + [1] Künzel, Sören R., Jasjeet S. Sekhon, Peter J. Bickel, and Bin Yu. Metalearners + for estimating heterogeneous treatment effects using machine learning. + Proceedings of the national academy of sciences 116, no. 10 (2019): 4156-4165. + + Parameters + ---------- + X : pandas.DataFrame of shape (n_samples, n_featues). + Training data. + y : pandas.Series of shape (n_samples, ). + Target vector. + treated : pandas.Series of shape (n_samples, ). + Treatement assignment indicator consisting of zeros and ones. + model : causalpy.pymc_models.ModelBuilder. + Base learner. + """ + + def predict_cate(self, X: pd.DataFrame) -> DataArray: + X_untreated = X.assign(treatment=0) + X_treated = X.assign(treatment=1) + m = self.models["model"] + + pred_treated = m.predict(X_treated)["posterior_predictive"].mu + pred_untreated = m.predict(X_untreated)["posterior_predictive"].mu + + return pred_treated - pred_untreated + + +class BayesianTLearner(TLearner, BayesianMetaLearner): + """ + Implements of T-learner described in [1]. T-learner fits two separate models to + estimate conditional average treatment effect. + + [1] Künzel, Sören R., Jasjeet S. Sekhon, Peter J. Bickel, and Bin Yu. Metalearners + for estimating heterogeneous treatment effects using machine learning. + Proceedings of the national academy of sciences 116, no. 10 (2019): 4156-4165. + Parameters + ---------- + X : pandas.DataFrame of shape (n_samples, n_featues). + Training data. + y : pandas.Series of shape (n_samples, ). + Target vector. + treated : pandas.Series of shape (n_samples, ). + Treatement assignment indicator consisting of zeros and ones. + model : causalpy.pymc_models.ModelBuilder. + If specified, it will be used both as treated and untreated model. Either + model or both of treated_model and untreated_model have to be specified. + treated_model: causalpy.pymc_models.ModelBuilder. + Model used for predicting target vector for treated values. + untreated_model: causalpy.pymc_models.ModelBuilder. + Model used for predicting target vector for untreated values. + """ + + def predict_cate(self, X: pd.DataFrame) -> DataArray: + treated_model = self.models["treated"] + untreated_model = self.models["untreated"] + + pred_treated = treated_model.predict(X)["posterior_predictive"].mu + pred_untreated = untreated_model.predict(X)["posterior_predictive"].mu + + return pred_treated - pred_untreated + + +class BayesianXLearner(XLearner, BayesianMetaLearner): + """ + Implements of PyMC version of X-learner introduced in [1]. X-learner estimates + conditional average treatment effect with the use of five separate models. + + [1] Künzel, Sören R., Jasjeet S. Sekhon, Peter J. Bickel, and Bin Yu. Metalearners + for estimating heterogeneous treatment effects using machine learning. + Proceedings of the national academy of sciences 116, no. 10 (2019): 4156-4165. + + Parameters + ---------- + X : pandas.DataFrame of shape (n_samples, n_featues). + Training data. + y : pandas.Series of shape (n_samples, ). + Target vector. + treated : pandas.Series of shape (n_samples, ). + Treatement assignment indicator consisting of zeros and ones. + model : causalpy.pymc_models.ModelBuilder. + If specified, it will be used in all of the subregressions, except for the + propensity_score_model. Either model or all of treated_model, + untreated_model, treated_cate_estimator and untreated_cate_estimator have + to be specified. + treated_model : causalpy.pymc_models.ModelBuilder. + Model used for predicting target vector for treated values. + untreated_model : causalpy.pymc_models.ModelBuilder. + Model used for predicting target vector for untreated values. + untreated_cate_estimator : causalpy.pymc_models.ModelBuilder. + Model used for CATE estimation on untreated data. + treated_cate_estimator : causalpy.pymc_models.ModelBuilder. + Model used for CATE estimation on treated data. + propensity_score_model : causalpy.pymc_models.ModelBuilder, + default = causalpy.pymc_models.LogisticRegression(). + Model used for propensity score estimation. Output values should be in the + interval [0, 1]. + """ + + def __init__( + self, + X: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + model: Optional[ModelBuilder] = None, + treated_model: Optional[ModelBuilder] = None, + untreated_model: Optional[ModelBuilder] = None, + treated_cate_estimator: Optional[ModelBuilder] = None, + untreated_cate_estimator: Optional[ModelBuilder] = None, + propensity_score_model: Optional[ModelBuilder] = None, + ): + super().__init__( + X, + y, + treated, + model, + treated_model, + untreated_model, + treated_cate_estimator, + untreated_cate_estimator, + propensity_score_model, + ) + + def fit( + self, + X: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + coords: Dict[str, Any] = None, + ): + treated_model = self.models["treated"] + untreated_model = self.models["untreated"] + treated_cate_estimator = self.models["treated_cate"] + untreated_cate_estimator = self.models["untreated_cate"] + propensity_score_model = self.models["propensity"] + + # Split data to treated and untreated subsets + X_t, y_t = X[treated == 1], y[treated == 1] + X_u, y_u = X[treated == 0], y[treated == 0] + + # Estimate response function + _fit(treated_model, X_t, y_t, coords) + _fit(untreated_model, X_u, y_u, coords) + + pred_u_t = az.extract( + untreated_model.predict(X_t), group="posterior_predictive", var_names="mu" + ).mean(axis=1) + pred_t_u = az.extract( + treated_model.predict(X_u), group="posterior_predictive", var_names="mu" + ).mean(axis=1) + + tau_t = y_t - pred_u_t + tau_u = -y_u + pred_t_u + + # Estimate CATE separately on treated and untreated subsets + _fit(treated_cate_estimator, X_t, tau_t, coords) + _fit(untreated_cate_estimator, X_u, tau_u, coords) + + # Fit propensity score model + _fit(propensity_score_model, X, treated, coords) + return self + + def predict_cate(self, X: pd.DataFrame) -> DataArray: + treated_model = self.models["treated_cate"] + untreated_model = self.models["untreated_cate"] + + cate_estimate_treated = treated_model.predict(X)["posterior_predictive"].mu + cate_estimate_untreated = untreated_model.predict(X)["posterior_predictive"].mu + g = self.models["propensity"].predict(X)["posterior_predictive"].mu + + return (1 - g) * cate_estimate_untreated + g * cate_estimate_treated + + +class BayesianDRLearner(DRLearner, BayesianMetaLearner): + """ + Implements of DR-learner also known as doubly robust learner as described in [1]. + + [1] Curth, Alicia, Mihaela van der Schaar. + Nonparametric estimation of heterogeneous treatment effects: From theory to + learning algorithms. International Conference on Artificial Intelligence and + Statistics, pp. 1810-1818 (2021). + + Parameters + ---------- + X : pandas.DataFrame of shape (n_samples, n_featues). + Training data. + y : pandas.Series of shape (n_samples, ). + Target vector. + treated : pandas.Series of shape (n_samples, ). + Treatement assignment indicator consisting of zeros and ones. + model : causalpy.pymc_models.ModelBuilder. + If specified, it will be used in all of the subregressions, except for + the propensity_score_model. Either model or all of treated_model, + untreated_model, treated_cate_estimator and untreated_cate_estimator + have to be specified. + treated_model : causalpy.pymc_models.ModelBuilder. + Model used for predicting target vector for treated values. + untreated_model : causalpy.pymc_models.ModelBuilder. + Model used for predicting target vector for untreated values. + pseudo_outcome_model : causalpy.pymc_models.ModelBuilder. + Model used for pseudo-outcome estimation. + propensity_score_model : causalpy.pymc_models.ModelBuilder, + default = causalpy.pymc_models.LogisticRegression(). + Model used for propensity score estimation. + cross_fitting : bool, default=False. + If True, performs a cross fitting step. + """ + + def __init__( + self, + X: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + model: Optional[ModelBuilder] = None, + treated_model: Optional[ModelBuilder] = None, + untreated_model: Optional[ModelBuilder] = None, + pseudo_outcome_model: Optional[ModelBuilder] = None, + propensity_score_model: Optional[ModelBuilder] = LogisticRegression(), + cross_fitting: bool = False, + ): + super().__init__( + X, + y, + treated, + model, + treated_model, + untreated_model, + pseudo_outcome_model, + propensity_score_model, + cross_fitting, + ) + + def fit( + self, + X: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + coords: Dict[str, Any] = None, + ): + # Split data to two independent samples of equal size + (X0, X1, y0, y1, treated0, treated1) = train_test_split( + X, y, treated, stratify=treated, test_size=0.5 + ) + + treated_model = self.models["treated"] + untreated_model = self.models["untreated"] + propensity_score_model = self.models["propensity"] + pseudo_outcome_model = self.models["pseudo_outcome"] + + # Second iteration is the cross-fitting step. + second_iteration = False + for _ in range(2): + # Split data to treated and untreated subsets + X_t, y_t = X0[treated0 == 1], y0[treated0 == 1] + X_u, y_u = X0[treated0 == 0], y0[treated0 == 0] + + # Estimate response functions + _fit(treated_model, X_t, y_t, coords) + _fit(untreated_model, X_u, y_u, coords) + + # Fit propensity score model + _fit(propensity_score_model, X0, treated0, coords) + + g = az.extract( + propensity_score_model.predict(X1), + group="posterior_predictive", + var_names="mu", + ).mean(axis=1) + mu_0 = az.extract( + untreated_model.predict(X1), + group="posterior_predictive", + var_names="mu", + ).mean(axis=1) + mu_1 = az.extract( + treated_model.predict(X1), group="posterior_predictive", var_names="mu" + ).mean(axis=1) + mu_w = np.where(treated1 == 0, mu_0, mu_1) + + pseudo_outcome = (treated1 - g) / (g * (1 - g)) * (y1 - mu_w) + mu_1 - mu_0 + + # Fit pseudo-outcome model + _fit(pseudo_outcome_model, X1, pseudo_outcome, coords) + + if self.cross_fitting and not second_iteration: + # Swap data and estimators + (X0, X1) = (X1, X0) + (y0, y1) = (y1, y0) + (treated0, treated1) = (treated1, treated0) + + treated_model = self.cross_fitted_models["treated"] + untreated_model = self.cross_fitted_models["untreated"] + propensity_score_model = self.cross_fitted_models["propensity"] + pseudo_outcome_model = self.cross_fitted_models["pseudo_outcome"] + + second_iteration = True + else: + return self + + return self + + def predict_cate(self, X: pd.DataFrame) -> DataArray: + pred = az.extract( + self.models["pseudo_outcome"].predict(X), + group="posterior_predictive", + var_names="mu", + ) + + if self.cross_fitting: + pred2 = az.extract( + self.cross_fitted_models["pseudo_outcome"].predict(X), + group="posterior_predictive", + var_names="mu", + ) + + pred = (pred + pred2) / 2 + + return pred diff --git a/causalpy/pymc_models.py b/causalpy/pymc_models.py index 7b6efbf0..ffd847e7 100644 --- a/causalpy/pymc_models.py +++ b/causalpy/pymc_models.py @@ -4,7 +4,9 @@ import numpy as np import pandas as pd import pymc as pm +import pymc_bart as pmb from arviz import r2_score +from pymc.distributions.distribution import DistributionMeta class ModelBuilder(pm.Model): @@ -113,3 +115,120 @@ def build_model(self, X, y, coords): sigma = pm.HalfNormal("sigma", 1) mu = pm.Deterministic("mu", pm.math.dot(X, beta), dims="obs_ind") pm.Normal("y_hat", mu, sigma, observed=y, dims="obs_ind") + + +class BARTRegressor(ModelBuilder): + """ + Class for building BART based regressors for meta-learners. + + Parameters + ---------- + m : int. + Number of trees to fit. + sigma : float. + Prior standard deviation. + sample_kwargs : dict. + Keyword arguments for sampler. + """ + + def __init__( + self, + m: int = 20, + sigma: float = 1.0, + sample_kwargs: Optional[dict[str, Any]] = None, + ): + self.m = m + self.sigma = sigma + super().__init__(sample_kwargs) + + def build_model(self, X, y, coords=None): + with self: + self.add_coords(coords) + X_ = pm.MutableData("X", X, dims=["obs_ind", "coeffs"]) + mu = pmb.BART("mu", X_, y, m=self.m, dims="obs_ind") + pm.Normal("y_hat", mu=mu, sigma=self.sigma, observed=y, dims="obs_ind") + + +class BARTClassifier(ModelBuilder): + """ + Class for building BART based models for meta-learners. + + Parameters + ---------- + m : int. + Number of trees to fit. + sample_kwargs : dict. + Keyword arguments for sampler. + """ + + def __init__( + self, + m: int = 20, + sample_kwargs: Optional[dict[str, Any]] = None, + ): + self.m = m + super().__init__(sample_kwargs) + + def build_model(self, X, y, coords=None): + with self: + self.add_coords(coords) + X_ = pm.MutableData("X", X, dims=["obs_ind", "coeffs"]) + mu_ = pmb.BART("mu_", X_, y, m=self.m, dims="obs_ind") + mu = pm.Deterministic("mu", pm.math.sigmoid(mu_), dims="obs_ind") + pm.Bernoulli("y_hat", mu, observed=y, dims="obs_ind") + + +class LogisticRegression(ModelBuilder): + """ + Custom PyMC model for logistic regression. + + Parameters + ---------- + coeff_distribution : PyMC distribution. + Prior distribution of coefficient vector. + distribution_kwargs : dict. + Keyword arguments for prior distribution. + sample_kwargs : dict. + Keyword arguments for sampler. + + Examples + -------- + >>> import numpy as np + >>> import pymc as pm + >>> from causalpy.pymc_models import LogisticRegression + >>> + >>> X = np.random.rand(10, 10) + >>> y = np.random.rand(10) + >>> m = LogisticRegression( + >>> coeff_distribution=pm.Cauchy, + >>> coeff_distribution_kwargs={"alpha": 0, "beta": 1} + >>> ) + >>> + >>> m.fit(X, y) + """ + + def __init__( + self, + sample_kwargs: Optional[dict[str, Any]] = None, + coeff_distribution: DistributionMeta = pm.Normal, + coeff_distribution_kwargs: Optional[dict[str, Any]] = None, + ): + self.coeff_distribution = coeff_distribution + if coeff_distribution_kwargs is None: + self.coeff_distribution_kwargs = {"mu": 0, "sigma": 50} + else: + self.coeff_distribution_kwargs = coeff_distribution_kwargs + + super().__init__(sample_kwargs) + + def build_model(self, X, y, coords) -> None: + with self: + self.add_coords(coords) + X_ = pm.MutableData("X", X, dims=["obs_ind", "coeffs"]) + beta = self.coeff_distribution( + "beta", dims="coeffs", **self.coeff_distribution_kwargs + ) + mu = pm.Deterministic( + "mu", pm.math.sigmoid(pm.math.dot(X_, beta)), dims="obs_ind" + ) + pm.Bernoulli("y_hat", mu, observed=y, dims="obs_ind") diff --git a/causalpy/skl_meta_learners.py b/causalpy/skl_meta_learners.py new file mode 100644 index 00000000..f1283162 --- /dev/null +++ b/causalpy/skl_meta_learners.py @@ -0,0 +1,865 @@ +"Scikit-learn based meta-learners." +from copy import deepcopy +from typing import Any, Dict, Tuple + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +from sklearn.base import ClassifierMixin, RegressorMixin +from sklearn.linear_model import LogisticRegression +from sklearn.model_selection import train_test_split +from sklearn.utils import check_consistent_length + +from causalpy.summary import Summary +from causalpy.utils import _fit, _is_variable_dummy_coded + + +class MetaLearner: + "Base class for meta-learners." + + def __init__(self, X: pd.DataFrame, y: pd.Series, treated: pd.Series) -> None: + # Check whether input is appropriate + check_consistent_length(X, y, treated) + if not _is_variable_dummy_coded(treated): + raise ValueError("Treatment variable is not dummy coded.") + + # Check whether input data share the same index + if not ((X.index == y.index) & (y.index == treated.index)).all(): + raise ValueError("Indices of input data do not coincide.") + + self.cate = None + self.treated = treated + self.X = X + self.y = y + self.models = {} + self.labels = X.columns + self.index = X.index + + def predict_cate(self, X: pd.DataFrame) -> pd.Series: + """ + Predict out-of-sample conditional average treatment effect on given input X. + For in-sample treatement effect self.cate should be used. + + Parameters + ---------- + X : pandas.DataFrame of shape (n_samples, n_featues). + """ + raise NotImplementedError() + + def predict_ate(self, X: pd.DataFrame) -> np.float64: + """ + Predict out-of-sample average treatment effect on given input X. For in-sample + treatement effect self.ate() should be used. + + Parameters + ---------- + X : pandas.DataFrame of shape (n_samples, n_featues). + """ + return self.predict_cate(X).mean() + + def ate(self) -> np.float64: + "Returns in-sample average treatement effect." + return self.cate.mean() + + def fit( + self, + X: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + coords: Dict[str, Any] = None, + ): + """ + Fits model. + + Parameters + ---------- + X : pandas.DataFrame of shape (n_samples, n_featues). + Training data. + y : pandas.Series of shape (n_samples, ). + Target vector. + treated : pandas.Series of shape (n_samples, ). + Treatement assignment indicator consisting of zeros and ones. + coords : Dict[str, Any]. + Dictionary containing the keys coeffs and obs_indx. + """ + raise NotImplementedError() + + +class SkMetaLearner(MetaLearner): + "Base class for sklearn based meta-learners." + + def fit( + self, + X: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + coords: Dict[str, Any] = None, + ): + raise NotImplementedError() + + def bootstrap( + self, + X_ins: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + X: pd.DataFrame = None, + n_iter: int = 1000, + ) -> np.array: + """ + Runs bootstrap n_iter times on a sample of size n_samples. + Fits on (X_ins, y, treated), then predicts on X. + + Parameters + ---------- + X_ins : pandas.DataFrame of shape (n_samples, n_featues). + Training data. + y : pandas.Series of shape (n_samples, ). + Target vector. + treated : pandas.Series of shape (n_samples, ). + Treatement assignment indicator consisting of zeros and ones. + X : pandas.DataFrame of shape (_, n_features). + Data to predict on. + n_iter : int, default = 1000. + Number of bootstrap iterations to perform. + """ + if X is None: + X = X_ins + + # Bootstraping overwrites these attributes + models, cate = self.models, self.cate + + # Calculate number of treated and untreated data points + n1 = self.treated.sum() + n0 = self.treated.count() - n1 + + # Prescribed treatement variable of samples + t_bs = pd.Series(n0 * [0] + n1 * [1], name="treatement") + + results = [] + + for _ in range(n_iter): + # Take sample with replacement from our data in a way that we have + # the same number of treated and untreated data points as in the whole + # data set. + X0_bs = X_ins[treated == 0].sample(n=n0, replace=True) + y0_bs = y.loc[X0_bs.index] + + X1_bs = X_ins[treated == 1].sample(n=n1, replace=True) + y1_bs = y.loc[X1_bs.index] + + X_bs = pd.concat([X0_bs, X1_bs], axis=0).reset_index(drop=True) + y_bs = pd.concat([y0_bs, y1_bs], axis=0).reset_index(drop=True) + + self.fit(X_bs.reset_index(drop=True), y_bs, t_bs) + results.append(self.predict_cate(X)) + + self.models = models + self.cate = cate + return np.array(results) + + def ate_confidence_interval( + self, + X_ins: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + X: pd.DataFrame = None, + q: float = 0.05, + n_iter: int = 1000, + ) -> tuple: + """Estimates confidence intervals for ATE on X using bootstraping. + + Parameters + ---------- + X_ins : pandas.DataFrame of shape (n_samples, n_featues). + Training data. + y : pandas.Series of shape (n_samples, ). + Target vector. + treated : pandas.Series of shape (n_samples, ). + Treatement assignment indicator consisting of zeros and ones. + X : pandas.DataFrame of shape (_, n_features). + Data to predict on. + q : float, default=.05. + Quantile to compute. Should be between in the interval [0, 1]. + n_iter : int, default = 1000. + Number of bootstrap iterations to perform. + """ + cates = self.bootstrap(X_ins, y, treated, X, n_iter) + ates = cates.mean(axis=0) + return np.quantile(ates, q=q / 2), np.quantile(cates, q=1 - q / 2) + + def cate_confidence_interval( + self, + X_ins: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + X: pd.DataFrame = None, + q: float = 0.05, + n_iter: int = 1000, + ) -> np.array: + """Estimates confidence intervals for CATE on X using bootstraping. + + Parameters + ---------- + X_ins : pandas.DataFrame of shape (n_samples, n_featues). + Training data. + y : pandas.Series of shape (n_samples, ). + Target vector. + treated : pandas.Series of shape (n_samples, ). + Treatement assignment indicator consisting of zeros and ones. + X : pandas.DataFrame of shape (_, n_features). + Data to predict on. + q : float, default=.05. + Quantile to compute. Should be between in the interval [0, 1]. + n_iter : int, default = 1000. + Number of bootstrap iterations to perform.""" + cates = self.bootstrap(X_ins, y, treated, X, n_iter) + conf_ints = np.append( + np.quantile(cates, q / 2, axis=0).reshape(-1, 1), + np.quantile(cates, 1 - q / 2, axis=0).reshape(-1, 1), + axis=1, + ) + return conf_ints + + def bias( + self, + X_ins: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + X: pd.DataFrame = None, + n_iter: int = 1000, + ) -> np.float64: + """Calculates bootstrap estimate of bias of CATE estimator. + + Parameters + ---------- + X_ins : pandas.DataFrame of shape (n_samples, n_featues). + Training data. + y : pandas.Series of shape (n_samples, ). + Target vector. + treated : pandas.Series of shape (n_samples, ). + Treatement assignment indicator consisting of zeros and ones. + X : pandas.DataFrame of shape (_, n_features). + Data to predict on. + q : float, default=.05. + Quantile to compute. Should be between in the interval [0, 1]. + n_iter : int, default = 1000. + Number of bootstrap iterations to perform.""" + if X is None: + X = X_ins + + pred = self.predict_cate(X=X) + bs_pred = self.bootstrap(X_ins, y, treated, X, n_iter).mean(axis=0) + + return (bs_pred - pred).mean() + + def score( + self, + X: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + ) -> Dict[str, np.float64]: + """ + Returns a dictionary of R^2 scores of base-learners, mean accuracy in case of + propensity score estimator. + + Parameters + ---------- + X : pandas.DataFrame of shape (_, n_features). + Data to predict on. + y : pandas.Series of shape (n_samples, ). + Target vector. + treated : pandas.Series of shape (n_samples, ). + Treatement assignment indicator consisting of zeros and ones. + """ + raise NotImplementedError() + + def average_uplift_by_quantile( + self, + X: pd.DataFrame, + nbins: int = 20, + ) -> pd.DataFrame: + """ + Returns average uplift in quantile groups. + + Parameters + ---------- + X : pandas.DataFrame of shape (_, n_features). + Data to predict on. + nbins : int. + Number of bins. + """ + preds = self.predict_cate(X) + nunique = preds.unique().shape[0] + + uplift = ( + pd.DataFrame( + { + "Mean uplift by quantile": preds, + "quantile": pd.qcut(preds, q=min(nunique, nbins)), + } + ) + .groupby("quantile") + .mean() + .sort_values("quantile", ascending=False) + ) + + return uplift + + def summary(self, n_iter: int = 100) -> Summary: + """ + Returns. + + Parameters + ---------- + n_iter : int, default=1000. + Number of bootstrap iterations to perform. + """ + # Bootstrapping confidence intervals for ATE + bootstrapped_cates = self.bootstrap( + self.X, self.y, self.treated, self.X, n_iter + ) + bootstrapped_ates = bootstrapped_cates.mean(axis=1) + conf_ints = ( + np.quantile(bootstrapped_ates, q=0.025), + np.quantile(bootstrapped_ates, q=0.975), + ) + conf_ints = map(lambda x: round(x, 2), conf_ints) + + # Calculate bias + cates = self.predict_cate(self.X) + ate = round(cates.mean(), 2) + + bias = (bootstrapped_cates.mean(axis=0) - cates).mean() + bias = round(bias, 2) + + score = self.score(self.X, self.y, self.treated) + models = { + k: [type(v).__name__, round(score[k], 2)] for k, v in self.models.items() + } + + s = Summary() + s.add_title(["Conditional Average Treatment Effect Estimator Summary"]) + s.add_row("Number of observations", [self.index.shape[0]], 2) + s.add_row("Number of treated observations", [self.treated.sum()], 2) + s.add_row("Average treatement effect (ATE)", [ate], 2) + s.add_row("95% Confidence interval for ATE", [tuple(conf_ints)], 1) + s.add_row("Estimated bias", [bias], 2) + s.add_title(["Base learners"]) + s.add_header(["", "Model", "R^2"], 1) + + for name, x in models.items(): + s.add_row(name, x, 1) + + return s + + def plot( + self, + nbins: int = 20, + figsize: tuple[int] = (20, 20), + fontsize: int = 40, + ) -> Tuple[plt.Figure, plt.Axes]: + """ + Plots average uplift per decile and cummulative uplift curve. + + Parameters + ---------- + nbins : int, default=20. + Number of bins. + figsize: tuple[int], default=(20, 20). + Size of figure. + fontsize: int, default=40. + Size of font to use. + """ + fig, ax = plt.subplots(2, 1, figsize=figsize) + + uplift = self.average_uplift_by_quantile(self.X, nbins=nbins).sort_values( + by="Mean uplift by quantile", ascending=False + ) + + # nbins might change here if nbins is too big + nbins = uplift.shape[0] + + uplift.plot.bar(ax=ax[0]) + ax[0].set_title("Uplift by quantile", fontsize=fontsize) + + ( + uplift.cumsum() + .reset_index(drop=True) + .set_index(np.linspace(0, 100, nbins)) + .plot(ax=ax[1], xlabel="Percentage of population", ylabel="Uplift") + ) + ax[1].set_title("Cumulative uplift", fontsize=fontsize) + + return fig, ax + + +class SLearner(SkMetaLearner): + """ + Implements of S-learner described in [1]. S-learner estimates conditional average + treatment effect with the use of a single model. + + [1] Künzel, Sören R., Jasjeet S. Sekhon, Peter J. Bickel, and Bin Yu. Metalearners + for estimating heterogeneous treatment effects using machine learning. + Proceedings of the national academy of sciences 116, no. 10 (2019): 4156-4165. + + Parameters + ---------- + X : pandas.DataFrame of shape (n_samples, n_featues). + Training data. + y : pandas.Series of shape (n_samples, ). + Target vector. + treated : pandas.Series of shape (n_samples, ). + Treatement assignment indicator consisting of zeros and ones. + model : sklearn.base.RegressorMixin. + Base learner. + """ + + def __init__( + self, X: pd.DataFrame, y: pd.Series, treated: pd.Series, model: RegressorMixin + ) -> None: + super().__init__(X=X, y=y, treated=treated) + self.models["model"] = model + + COORDS = {"coeffs": list(self.labels) + ["treated"], "obs_indx": self.index} + + self.fit(X, y, treated, coords=COORDS) + self.cate = self.predict_cate(X) + + def fit( + self, + X: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + coords: Dict[str, Any] = None, + ): + X_t = X.assign(treatment=treated) + _fit(model=self.models["model"], X=X_t, y=y, coords=coords) + return self + + def predict_cate(self, X: pd.DataFrame) -> pd.Series: + X_control = X.assign(treatment=0) + X_treated = X.assign(treatment=1) + m = self.models["model"] + return pd.Series(m.predict(X_treated) - m.predict(X_control), index=self.index) + + def score( + self, + X: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + ) -> Dict[str, np.float64]: + return {"model": self.models["model"].score(X.assign(treatment=treated), y)} + + +class TLearner(SkMetaLearner): + """ + Implements of T-learner described in [1]. T-learner fits two separate models to + estimate conditional average treatment effect. + + [1] Künzel, Sören R., Jasjeet S. Sekhon, Peter J. Bickel, and Bin Yu. Metalearners + for estimating heterogeneous treatment effects using machine learning. + Proceedings of the national academy of sciences 116, no. 10 (2019): 4156-4165. + + Parameters + ---------- + X : pandas.DataFrame of shape (n_samples, n_featues). + Training data. + y : pandas.Series of shape (n_samples, ). + Target vector. + treated : pandas.Series of shape (n_samples, ). + Treatement assignment indicator consisting of zeros and ones. + model : sklearn.base.RegressorMixin. + If specified, it will be used both as treated and untreated model. Either + model or both of treated_model and untreated_model have to be specified. + treated_model: sklearn.base.RegressorMixin. + Model used for predicting target vector for treated values. + untreated_model: sklearn.base.RegressorMixin. + Model used for predicting target vector for untreated values. + """ + + def __init__( + self, + X: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + model: RegressorMixin = None, + treated_model: RegressorMixin = None, + untreated_model: RegressorMixin = None, + ) -> None: + super().__init__(X=X, y=y, treated=treated) + + if model is None and (untreated_model is None or treated_model is None): + raise ValueError( + "Either model or both of treated_model and untreated_model \ + have to be specified." + ) + elif not (model is None or untreated_model is None or treated_model is None): + raise ValueError( + "Either model or both of treated_model and untreated_model \ + have to be specified." + ) + + if model is not None: + untreated_model = deepcopy(model) + treated_model = deepcopy(model) + + self.models = {"treated": treated_model, "untreated": untreated_model} + + COORDS = {"coeffs": self.labels, "obs_indx": self.index} + + self.fit(X, y, treated, coords=COORDS) + self.cate = self.predict_cate(X) + + def fit( + self, + X: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + coords: Dict[str, Any] = None, + ): + X_t, y_t = X[treated == 1], y[treated == 1] + X_u, y_u = X[treated == 0], y[treated == 0] + _fit(model=self.models["treated"], X=X_t, y=y_t, coords=coords) + _fit(model=self.models["untreated"], X=X_u, y=y_u, coords=coords) + return self + + def predict_cate(self, X: pd.DataFrame) -> pd.Series: + treated_model = self.models["treated"] + untreated_model = self.models["untreated"] + return pd.Series( + treated_model.predict(X) - untreated_model.predict(X), index=self.index + ) + + def score( + self, + X: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + ) -> Dict[str, np.float64]: + X_t, y_t = X[treated == 1], y[treated == 1] + X_u, y_u = X[treated == 0], y[treated == 0] + return { + "treated": self.models["treated"].score(X_t, y_t), + "untreated": self.models["untreated"].score(X_u, y_u), + } + + +class XLearner(SkMetaLearner): + """ + Implements of X-learner introduced in [1]. X-learner estimates conditional average + treatment effect with the use of five separate models. + + [1] Künzel, Sören R., Jasjeet S. Sekhon, Peter J. Bickel, and Bin Yu. Metalearners + for estimating heterogeneous treatment effects using machine learning. + Proceedings of the national academy of sciences 116, no. 10 (2019): 4156-4165. + + Parameters + ---------- + X : pandas.DataFrame of shape (n_samples, n_featues). + Training data. + y : pandas.Series of shape (n_samples, ). + Target vector. + treated : pandas.Series of shape (n_samples, ). + Treatement assignment indicator consisting of zeros and ones. + model : sklearn.base.RegressorMixin. + If specified, it will be used in all of the subregressions, except for the + propensity_score_model. Either model or all of treated_model, + untreated_model, treated_cate_estimator and untreated_cate_estimator have + to be specified. + treated_model : sklearn.base.RegressorMixin. + Model used for predicting target vector for treated values. + untreated_model : sklearn.base.RegressorMixin. + Model used for predicting target vector for untreated values. + untreated_cate_estimator : sklearn.base.RegressorMixin + Model used for CATE estimation on untreated data. + treated_cate_estimator : sklearn.base.RegressorMixin + Model used for CATE estimation on treated data. + propensity_score_model : sklearn.base.ClassifierMixin, + default = sklearn.linear_model.LogisticRegression(). + Model used for propensity score estimation. + """ + + def __init__( + self, + X: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + model: RegressorMixin = None, + treated_model: RegressorMixin = None, + untreated_model: RegressorMixin = None, + treated_cate_estimator: RegressorMixin = None, + untreated_cate_estimator: RegressorMixin = None, + propensity_score_model: ClassifierMixin = LogisticRegression(penalty=None), + ): + super().__init__(X=X, y=y, treated=treated) + + if model is None and (untreated_model is None or treated_model is None): + raise ValueError( + "Either model or each of treated_model, untreated_model, \ + treated_cate_estimator, untreated_cate_estimator has to be specified." + ) + elif not (model is None or untreated_model is None or treated_model is None): + raise ValueError( + "Either model or each of treated_model, untreated_model, \ + treated_cate_estimator, untreated_cate_estimator has to be specified." + ) + + if model is not None: + treated_model = deepcopy(model) + untreated_model = deepcopy(model) + treated_cate_estimator = deepcopy(model) + untreated_cate_estimator = deepcopy(model) + + self.models = { + "treated": treated_model, + "untreated": untreated_model, + "treated_cate": treated_cate_estimator, + "untreated_cate": untreated_cate_estimator, + "propensity": propensity_score_model, + } + + COORDS = {"coeffs": self.labels, "obs_indx": self.index} + + self.fit(X, y, treated, coords=COORDS) + + # Compute cate + self.cate = self.predict_cate(X) + + def fit( + self, + X: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + coords: Dict[str, Any] = None, + ): + treated_model = self.models["treated"] + untreated_model = self.models["untreated"] + treated_cate_estimator = self.models["treated_cate"] + untreated_cate_estimator = self.models["untreated_cate"] + propensity_score_model = self.models["propensity"] + + # Split data to treated and untreated subsets + X_t, y_t = X[treated == 1], y[treated == 1] + X_u, y_u = X[treated == 0], y[treated == 0] + + # Estimate response function + _fit(treated_model, X_t, y_t, coords) + _fit(untreated_model, X_u, y_u, coords) + + tau_t = y_t - untreated_model.predict(X_t) + tau_u = treated_model.predict(X_u) - y_u + + # Estimate CATE separately on treated and untreated subsets + _fit(treated_cate_estimator, X_t, tau_t, coords) + _fit(untreated_cate_estimator, X_u, tau_u, coords) + + # Fit propensity score model + _fit(propensity_score_model, X, treated, coords) + return self + + def predict_cate(self, X: pd.DataFrame) -> pd.Series: + cate_estimate_treated = self.models["treated_cate"].predict(X) + cate_estimate_untreated = self.models["untreated_cate"].predict(X) + g = self.models["propensity"].predict_proba(X)[:, 1] + + cate = g * cate_estimate_untreated + (1 - g) * cate_estimate_treated + return pd.Series(cate, index=self.index) + + def score( + self, + X: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + ) -> Dict[str, np.float64]: + X_t, y_t = X[treated == 1], y[treated == 1] + X_u, y_u = X[treated == 0], y[treated == 0] + + tau_t = y_t - self.models["untreated"].predict(X_t) + tau_u = self.models["treated"].predict(X_u) - y_u + + return { + "treated": self.models["treated"].score(X_t, y_t), + "untreated": self.models["untreated"].score(X_u, y_u), + "propensity": self.models["propensity"].score(X, treated), + "treated_cate": self.models["treated_cate"].score(X_t, tau_t), + "untreated_cate": self.models["untreated_cate"].score(X_u, tau_u), + } + + +class DRLearner(SkMetaLearner): + """ + Implements of DR-learner also known as doubly robust learner as described in [1]. + + [1] Curth, Alicia, Mihaela van der Schaar. + Nonparametric estimation of heterogeneous treatment effects: From theory to + learning algorithms. International Conference on Artificial Intelligence and + Statistics, pp. 1810-1818 (2021). + + Parameters + ---------- + X : pandas.DataFrame of shape (n_samples, n_featues). + Training data. + y : pandas.Series of shape (n_samples, ). + Target vector. + treated : pandas.Series of shape (n_samples, ). + Treatement assignment indicator consisting of zeros and ones. + model : sklearn.base.RegressorMixin. + If specified, it will be used in all of the subregressions, except for + the propensity_score_model. Either model or all of treated_model, + untreated_model, treated_cate_estimator and untreated_cate_estimator + have to be specified. + treated_model : sklearn.base.RegressorMixin. + Model used for predicting target vector for treated values. + untreated_model : sklearn.base.RegressorMixin. + Model used for predicting target vector for untreated values. + pseudo_outcome_model : sklearn.base.RegressorMixin + Model used for pseudo-outcome estimation. + propensity_score_model : sklearn.base.ClassifierMixin, + default = sklearn.linear_model.LogisticRegression(). + Model used for propensity score estimation. + cross_fitting : bool, default=False. + If True, performs a cross fitting step. + """ + + def __init__( + self, + X: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + model: RegressorMixin = None, + treated_model: RegressorMixin = None, + untreated_model: RegressorMixin = None, + pseudo_outcome_model: RegressorMixin = None, + propensity_score_model: ClassifierMixin = LogisticRegression(penalty=None), + cross_fitting: bool = False, + ): + super().__init__(X=X, y=y, treated=treated) + + self.cross_fitting = cross_fitting + + if model is None and (untreated_model is None or treated_model is None): + raise ValueError( + "Either model or each of treated_model, untreated_model, \ + treated_cate_estimator, untreated_cate_estimator has to be specified." + ) + elif not (model is None or untreated_model is None or treated_model is None): + raise ValueError( + "Either model or each of treated_model, untreated_model, \ + treated_cate_estimator, untreated_cate_estimator has to be specified." + ) + + if model is not None: + treated_model = deepcopy(model) + untreated_model = deepcopy(model) + pseudo_outcome_model = deepcopy(model) + + # Estimate response function + self.models = { + "treated": treated_model, + "untreated": untreated_model, + "propensity": propensity_score_model, + "pseudo_outcome": pseudo_outcome_model, + } + + cross_fitted_models = {} + if self.cross_fitting: + cross_fitted_models = { + key: deepcopy(value) for key, value in self.models.items() + } + + self.cross_fitted_models = cross_fitted_models + + COORDS = {"coeffs": self.labels, "obs_indx": self.index} + self.fit(X, y, treated, coords=COORDS) + + # Estimate CATE + self.cate = self.predict_cate(X) + + def fit( + self, + X: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + coords: Dict[str, Any] = None, + ): + # Split data to two independent samples of equal size + (X0, X1, y0, y1, treated0, treated1) = train_test_split( + X, y, treated, stratify=treated, test_size=0.5 + ) + + treated_model = self.models["treated"] + untreated_model = self.models["untreated"] + propensity_score_model = self.models["propensity"] + pseudo_outcome_model = self.models["pseudo_outcome"] + + # Second iteration is the cross-fitting step. + second_iteration = False + for _ in range(2): + # Split data to treated and untreated subsets + X_t, y_t = X0[treated0 == 1], y0[treated0 == 1] + X_u, y_u = X0[treated0 == 0], y0[treated0 == 0] + + # Estimate response functions + _fit(treated_model, X_t, y_t, coords) + _fit(untreated_model, X_u, y_u, coords) + + # Fit propensity score model + _fit(propensity_score_model, X, treated, coords) + + g = propensity_score_model.predict_proba(X1)[:, 1] + mu_0 = untreated_model.predict(X1) + mu_1 = treated_model.predict(X1) + mu_w = np.where(treated1 == 0, mu_0, mu_1) + + pseudo_outcome = (treated1 - g) / (g * (1 - g)) * (y1 - mu_w) + mu_1 - mu_0 + + # Fit pseudo-outcome model + _fit(pseudo_outcome_model, X1, pseudo_outcome, coords) + + if self.cross_fitting and not second_iteration: + # Swap data and estimators + (X0, X1) = (X1, X0) + (y0, y1) = (y1, y0) + (treated0, treated1) = (treated1, treated0) + + treated_model = self.cross_fitted_models["treated"] + untreated_model = self.cross_fitted_models["untreated"] + propensity_score_model = self.cross_fitted_models["propensity"] + pseudo_outcome_model = self.cross_fitted_models["pseudo_outcome"] + second_iteration = True + else: + return self + + return self + + def predict_cate(self, X: pd.DataFrame) -> pd.Series: + pred = self.models["pseudo_outcome"].predict(X) + + if self.cross_fitting: + pred2 = self.cross_fitted_models["pseudo_outcome"].predict(X) + pred = (pred + pred2) / 2 + + return pd.Series(pred, index=self.index) + + def score( + self, + X: pd.DataFrame, + y: pd.Series, + treated: pd.Series, + ) -> Dict[str, np.float64]: + X_t, y_t = X[treated == 1], y[treated == 1] + X_u, y_u = X[treated == 0], y[treated == 0] + + g = self.models["propensity"].predict_proba(X)[:, 1] + mu_0 = self.models["untreated"].predict(X) + mu_1 = self.models["treated"].predict(X) + mu_w = np.where(treated == 0, mu_0, mu_1) + + pseudo_outcome = (treated - g) / (g * (1 - g)) * (y - mu_w) + mu_1 - mu_0 + + return { + "treated": self.models["treated"].score(X_t, y_t), + "untreated": self.models["untreated"].score(X_u, y_u), + "propensity": self.models["propensity"].score(X, treated), + "pseudo_outcome": self.models["pseudo_outcome"].score(X, pseudo_outcome), + } diff --git a/causalpy/summary.py b/causalpy/summary.py new file mode 100644 index 00000000..1a3eac2b --- /dev/null +++ b/causalpy/summary.py @@ -0,0 +1,245 @@ +"Summary objects." + +from dataclasses import dataclass +from typing import Optional + + +def html_header(columns: list[str], colspan: int = 1) -> str: + """ + Returns HTML code for table header. + + Parameters + ---------- + columns : list[str]. + List containing column names. + colspan : int. + Column span. + """ + string = ( + f' ' + + (f' '.join(columns)) + + "" + ) + return '' + string + "" + + +def html_rows(index: str, values: list, colspan: int = 1) -> str: + """ + Returns HTML code for table rows. + + Parameters + ---------- + items : dict. + The keys of items is the index-set of the rows to be added. The values are + lists containing the values to be added. + colspan : int. + Column span. + """ + string = "" + string += f' {index} ' + + if not isinstance(values, list): + values = [values] + + values = map(str, values) + string += ( + f'' + + (' '.join(values)) + + "" + ) + + string = f" {string} " + + return string + + +def str_header(columns: list[str], length: int) -> str: + """ + Returns table header string. + + Parameters + ---------- + columns : list[str]. + List containing column names. + length : int. + Length of box containing header. + """ + # If first column is empty, it's box should not be displayed + first_col_empty = columns[0] == "" + + if first_col_empty: + columns = columns[1:] + + n_cols = len(columns) + + top = f"{length * '═'}╦" + bot = f"{length * '═'}╩" + + spaces = first_col_empty * (length + 1) * " " + + return f"""\ + {spaces}╔{(n_cols - 1) * top}{length * "═"}╗ + {spaces}║{"║".join(map(lambda x: x.center(length), columns))}║ + ┏{length * '━'}╚{(n_cols - 1) * bot}{length * "═"}╝\ + """ + + +def str_row(index: str, values: str, length: int, row_type: str = "inner") -> str: + """ + Returns string table row. + + Parameters + ---------- + index : str. + Index of the row. + values : int. + Values of the row. + length : int. + Length of boxes. + row_type : str. + One of "inner", "first", "last". + """ + n_cols = len(values) + values = map(str, values) + + s = "" + + if row_type == "first": + s += f""" ┏{length * '━'}┱""" + s += f"{(n_cols - 1) * (length * '─' + '┬')}" + s += f"{(length * '─' + '┐')}" + s += "\n" + + s += f"""\ + ┃{index.center(length)}┃{"│".join(map(lambda x: x.center(length), values))}│ + """ + if row_type == "last": + s += f"┗{length * '━'}┹{(n_cols - 1) * (length * '─' + '┴')}{length * '─'}┘" + else: + s += f"┣{length * '━'}╋{(n_cols - 1) * (length * '─' + '┼')}{length * '─'}┤" + + return s + + +def str_title(title: str): + """ + Returns title in a box. + + Parameters + ---------- + title : str. + String to return in a box. + """ + length = len(title) + return f"""\ + ╔{(length + 2) * '═'}╗ + ║ {title} ║ + ╚{(length + 2) * '═'}╝ + """ + + +@dataclass +class Record: + """ + Class representing either a header or a row of a table. + + Parameters + ---------- + record_type : str. + Either 'header', 'title' or 'row'. + values : list. + List of values in record. + colspan : int. + Column span. + """ + + record_type: str + values: list + colspan: int + index: Optional[str] = None + + def to_html(self): + "Returns HTML code for record." + if self.record_type in ["header", "title"]: + return html_header(self.values, self.colspan) + else: + return html_rows(self.index, self.values, self.colspan) + + +class Summary: + """ + Base summary class. + """ + + def __init__(self): + self.records = [] + + def add_header(self, col_names, colspan) -> None: + "Adds a header." + self.records.append(Record("header", col_names, colspan)) + + def add_row(self, index: str, values: list, colspan: int) -> None: + "Adds a row." + self.records.append(Record("row", values, colspan, index=index)) + + def add_title(self, title) -> None: + "Adds title." + self.records.append(Record("title", title, 1)) + + def get_longest_length(self) -> int: + """ + Returns the lenght of the longest item currently in the table. + """ + non_titles = [r for r in self.records if not r.record_type == "title"] + + def length_of_items(L): + return [len(str(x)) for x in L] + + vals = [length_of_items(r.values) for r in non_titles] + longest_value_length = max([max(x) for x in vals]) + indx = [len(str(x.index)) for x in self.records] + longest_index_length = max(indx) + return max(longest_index_length, longest_value_length) + + def to_string(self) -> str: + """ + Return string summary table in string form. + """ + type_of_next_row = "first" + length = self.get_longest_length() + s = "" + + for i, x in enumerate(self.records): + if i == len(self.records) - 1: + type_of_next_row = "last" + elif self.records[i + 1].record_type == "title": + type_of_next_row = "last" + + if x.record_type == "header": + s += str_header(x.values, length) + type_of_next_row = "inner" + elif x.record_type == "title": + s += str_title(x.values[0]) + type_of_next_row = "first" + else: + s += str_row(x.index, x.values, length, type_of_next_row) + type_of_next_row = "inner" + s += "\n" + return s + + def to_html(self) -> str: + """ + Returns HTML code for summary table. + """ + s = "" + + for x in self.records: + s += x.to_html() + + return "" + s + "
" + + def _repr_html_(self) -> str: + return self.to_html() + + def __repr__(self) -> str: + return self.to_string() diff --git a/causalpy/utils.py b/causalpy/utils.py index 50e79694..92df3574 100644 --- a/causalpy/utils.py +++ b/causalpy/utils.py @@ -1,5 +1,18 @@ import pandas as pd +from causalpy.pymc_models import ModelBuilder + + +def _fit(model, X, y, coords): + """ + Fits model to X, y, where model is either a sklearn model or a ModelBuilder + instance. In the later case it passes coords, in the first case coords is ignored. + """ + if isinstance(model, ModelBuilder): + model.fit(X, y, coords) + else: + model.fit(X, y) + def _is_variable_dummy_coded(series: pd.Series) -> bool: """Check if a data in the provided Series is dummy coded. It should be 0 or 1 diff --git a/docs/notebooks/meta_learners_synthetic_data.ipynb b/docs/notebooks/meta_learners_synthetic_data.ipynb new file mode 100644 index 00000000..6b719cd1 --- /dev/null +++ b/docs/notebooks/meta_learners_synthetic_data.ipynb @@ -0,0 +1,819 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "fafe7c80-fc2d-47d4-b260-c5a1082d6fbb", + "metadata": {}, + "source": [ + "# Comparing meta-learners with different ensembles of trees as base learners" + ] + }, + { + "cell_type": "markdown", + "id": "3ccc6766-7606-4b6b-8c76-b4b5b732c988", + "metadata": {}, + "source": [ + "## Introduction\n", + "\n", + "When estimating causal effect of a certain treatment, generally we cannot assume that all of the treated units will respond to the treatement in the same way, that is the causal effect is might be *heterogeneous*. For example, the effectiveness of a certain medication might depend on the patient's age, gender, medical history, etc.. Estimating the treatement effect conditional to a set of covariates can provide valuable insights into our data. In this notebook we give a brief introduction to *meta-learners*, a class of models for estimating heterogeneous causal effect by leveraging machine learning methods.\n", + "\n", + "For a deeper dive on meta-learners we suggest reading [[1]](https://arxiv.org/abs/1706.03461) or for a lighter overview in video format, check out [Causal Effects via Regression by Shawhin Talebi](https://youtu.be/O72uByJlnMw). We also highly recommend reading Causal Inference for The Brave and True by Matheus Facure Alves [[3]](https://matheusfacure.github.io/python-causality-handbook/landing-page.html) for an easily digestible, yet comprehensive guide on several estimators discussed in this notebook.\n", + "\n", + "We will denote by $Y$ a $d$-dimensional outcome vector, by $X \\in \\mathbb{R}^{d \\times n}$ a feature matrix containing potential confounders, by $W \\in \\{0, 1\\}^d$ the treatment assignment indicator and by $Y(0) \\in \\mathbb{R}^d$ and $Y(1) \\in \\mathbb{R}^d$ the potential outcome of corresponding units when assigned to the control and the treatement group respectively. Note that\n", + "$$ Y = W Y(1) + (1 - W) Y(0).$$\n", + "\n", + "Our task is to estimate the *conditional average treatement effect (CATE)*, defined as \n", + "$$\\tau(x) = \\mathbb{E}\\left[Y(1) - Y(0) \\mid X=x\\right].$$\n", + "\n", + "Since only one of the potential outcomes materializes, CATE is never directly observed, this is often refered to as *the fundamental problem of causal inference*. Meta-learners estimate CATE by decomposing the treatement effect estimation to several subregressions. For instance the one may estimate $Y(0)$ and $Y(1)$ in two separate regressions and estimate CATE as the difference of the two functions (this is the approach of the T-learner discussed later). The estimators used for these subregressions are called *base learners*. Some of the most popular base learners are tree based ensembles, in particular Random Forest and Bayesian Additive Regression Trees (BART) due to their flexibility, however any machine learning algorithm suitable for regression problems (like generalized linear regressions, gaussian processes, etc.) can be used." + ] + }, + { + "cell_type": "markdown", + "id": "c06012dc-2adc-40df-bdec-6de7d884396e", + "metadata": {}, + "source": [ + "## Assumptions\n", + "As always, in order to be able to derive meaningful results, we need to impose some untestable assumptions. \n", + "1. __(Consistency)__: If the $i$th unit is assigned to the treated group, in other words $W_i=1$, then $Y_i(1)$ is observed and $Y_i(0)$ is observed otherwise.\n", + "2. __(Unconfoundedness)__: The treatement assignment $W_i$ is independent from $Y_i(0)$ and $Y_i(1)$ conditional on $X_i$, that is\n", + "$$Y_i(0), Y_i(1) \\perp\\!\\!\\!\\perp W_i\\mid X_i.$$\n", + "3. __(Overlap)__: $0 < \\mathbb{P}(W_i = 1 \\mid X_i=x) < 1$, i.e. treatement assignment is non-deterministic.\n", + "\n", + "Given these assumptions, $\\tau(x)$ can be written as the difference of the expected values observed random variables, namely\n", + "$$\\tau(x) = \\mathbb{E}[Y(1) \\mid X=x, W=1] - \\mathbb{E}[Y(0) \\mid X=x, W=0].$$" + ] + }, + { + "cell_type": "markdown", + "id": "ed73c7c9-7df5-4912-80f4-c5e69c916c22", + "metadata": {}, + "source": [ + "## Data generation\n", + "\n", + "In this notebook we will deal with synthetic data, so that we can quantify exactly the mean squared error of our CATE estimations. We generate the data in a way that the treatment assignment $W$ is *not* independent from $X$." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c543b717-acb7-4c7f-aa77-975833dbf699", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING (pytensor.tensor.blas): Using NumPy C-API based implementation for BLAS functions.\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "from sklearn.dummy import DummyClassifier\n", + "from sklearn.ensemble import (\n", + " AdaBoostRegressor,\n", + " HistGradientBoostingClassifier,\n", + " HistGradientBoostingRegressor,\n", + " RandomForestRegressor,\n", + ")\n", + "from sklearn.metrics import mean_squared_error\n", + "from sklearn.svm import SVR\n", + "from xgboost import XGBClassifier, XGBRegressor\n", + "\n", + "from causalpy.skl_meta_learners import DRLearner, SLearner, TLearner, XLearner\n", + "\n", + "np.random.seed(42)\n", + "\n", + "\n", + "def sigmoid(x):\n", + " return np.exp(x) / (1 + np.exp(x))\n", + "\n", + "\n", + "def sinc(x):\n", + " return np.where(x == 0, 1, np.sin(x) / x)\n", + "\n", + "\n", + "def create_synthetic_data(*shape):\n", + " X = np.random.rand(*shape)\n", + "\n", + " α = np.random.rand(shape[1])\n", + " β = np.random.rand(shape[1])\n", + " γ = np.random.rand(shape[1])\n", + "\n", + " treatment = np.random.binomial(n=1, p=sigmoid(X @ γ) / 2, size=shape[0])\n", + " treatment_effect = (X @ β) ** 3\n", + "\n", + " noise = np.random.rand(shape[0])\n", + "\n", + " y = np.cosh(X @ α) + treatment_effect * treatment + noise\n", + "\n", + " X = pd.DataFrame(X, columns=[f\"feature_{i}\" for i in range(shape[1])])\n", + " y = pd.Series(y, name=\"target\")\n", + " treated = pd.Series(treatment, name=\"treatment\")\n", + " return X, y, treated, treatment_effect\n", + "\n", + "\n", + "X, y, treated, treatment_effect = create_synthetic_data(5_000, 5)" + ] + }, + { + "cell_type": "markdown", + "id": "19940b36-b376-4e2c-9899-91a5162319c8", + "metadata": {}, + "source": [ + "## Model evaluation\n", + "The `summary` method of a scikit-learn based meta-learner contains\n", + "* Number of observations,\n", + "* number of treated observations,\n", + "* average treatement effect (ATE),\n", + "* 95% Confidence interval for ATE,\n", + "* estimated bias,\n", + "* in-sample $R^2$. \n", + "\n", + "Confidence intervals and bias are calculated when summary is called via bootstrapping. This means that the runtime of each learner in these examples will be exaggerated.\n", + "\n", + "Furthermore, with the `plot` method we will be able to get a sense of how much uplift one can expect if we treat certain percentages of the population." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8dc5e4d6-c632-4ca2-85e6-2d9a7aae892f", + "metadata": {}, + "outputs": [], + "source": [ + "def summarize_learner(learner):\n", + " print(f\"Actual average treatement effect: {treatment_effect.mean()}\")\n", + " print(f\"MSE: {mean_squared_error(treatment_effect, learner.cate)}\")\n", + " learner.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "9cf837e1-d93c-4fc5-bc52-96296db82e51", + "metadata": { + "tags": [] + }, + "source": [ + "## S-learner\n", + "\n", + "The simplest meta-learner is the *S-learner*, which predicts the potential outcome vectors by treating the treatement assignment indicator as a feature and estimates\n", + "\n", + "$$\\mu(x, w) := \\mathbb{E}[Y \\mid X=x, W=w]$$\n", + "\n", + "with an appropriate base learner. The \"S\" in S-learner stands for \"single\", as it uses a single model to estimate CATE. We will denote this estimation with $\\hat{\\mu}(x, w)$. Then the S-learner approximates CATE as \n", + "\n", + "$$\\hat{\\tau_S}(x) = \\hat{\\mu}(x, 1) - \\hat{\\mu}(x, 0).$$\n", + "\n", + "In the following example we will choose `HistGradientBoostingRegressor` as base learner." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "454322d0-6dbc-4771-bb7a-344afa30e793", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Actual average treatement effect: 0.11803778255762709\n", + "MSE: 0.005983053828482953\n", + "CPU times: total: 7min 9s\n", + "Wall time: 1min 17s\n" + ] + }, + { + "data": { + "text/html": [ + "
Conditional Average Treatment Effect Estimator Summary
Number of observations 5000
Number of treated observations 1822
Average treatement effect (ATE) 0.12
95% Confidence interval for ATE (0.1, 0.13)
Estimated bias -0.01
Base learners
Model R^2
model HistGradientBoostingRegressor 0.85
" + ], + "text/plain": [ + " ╔════════════════════════════════════════════════════════╗\n", + " ║ Conditional Average Treatment Effect Estimator Summary ║\n", + " ╚════════════════════════════════════════════════════════╝\n", + " \n", + " ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┱───────────────────────────────┐\n", + " ┃ Number of observations ┃ 5000 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃ Number of treated observations┃ 1822 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃Average treatement effect (ATE)┃ 0.12 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃95% Confidence interval for ATE┃ (0.1, 0.13) │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃ Estimated bias ┃ -0.01 │\n", + " ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┹───────────────────────────────┘\n", + " ╔═══════════════╗\n", + " ║ Base learners ║\n", + " ╚═══════════════╝\n", + " \n", + " ╔═══════════════════════════════╦═══════════════════════════════╗\n", + " ║ Model ║ R^2 ║\n", + " ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╚═══════════════════════════════╩═══════════════════════════════╝ \n", + " ┃ model ┃ HistGradientBoostingRegressor │ 0.85 │\n", + " ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┹───────────────────────────────┴───────────────────────────────┘" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%time\n", + "# Utility for printing some statistics.\n", + "slearner = SLearner(X=X, y=y, treated=treated, model=HistGradientBoostingRegressor())\n", + "\n", + "summarize_learner(slearner)\n", + "slearner.summary(n_iter=100)" + ] + }, + { + "cell_type": "markdown", + "id": "c3d35f7f-6526-4b7d-ac36-2365fc08cb5d", + "metadata": {}, + "source": [ + "## T-learner" + ] + }, + { + "cell_type": "markdown", + "id": "54a8971c-5eef-4423-893e-9277e8a40ac1", + "metadata": {}, + "source": [ + "The *T-learner* is a closely related meta-learner. Here, instead of including the treatment assignment indicator as a feature, we estimate the potential outcomes in two different regressions. Namely, we estimate\n", + "$$\\mu_{\\operatorname{treated}}(x) := \\mathbb{E}[Y(1) \\mid X=x], \\quad \\text{and} \\quad \\mu_{\\operatorname{untreated}}(x) := \\mathbb{E}[Y(0) \\mid X=x]$$\n", + "separately and define estimate the cate as\n", + "$$\\hat{\\tau}_T(x) = \\hat{\\mu}_{\\operatorname{treated}}(x) - \\hat{\\mu}_{\\operatorname{untreated}}(x),$$\n", + "where $\\hat{\\mu}_{\\operatorname{treated}}$ and $\\hat{\\mu}_{\\operatorname{untreated}}$ are the estimated functions. \n", + "\n", + "If we choose our base-learners to be a forest based ensemble, in the case of the S-learner, during the fitting process splits on the treatement assignment indicator can happen *anywhere* in the trees. In the fitting process of the T-learner however, we essentially force a split at the first level. This difference means that the S-learner is more flexible, but especially when using regularization, it is prone to disregard the effect of the treatment. On the other hand the T-learner uses two separate models that do not share information between each other, which may lead to overfitting if one of the treatement groups is small." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2a24a76e-398a-4629-9d49-7fadecb2a2c7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Actual average treatement effect: 0.11803778255762709\n", + "MSE: 0.03202522692931663\n", + "CPU times: total: 14min 44s\n", + "Wall time: 3min 56s\n" + ] + }, + { + "data": { + "text/html": [ + "
Conditional Average Treatment Effect Estimator Summary
Number of observations 5000
Number of treated observations 1822
Average treatement effect (ATE) 0.14
95% Confidence interval for ATE (0.12, 0.15)
Estimated bias -0.01
Base learners
Model R^2
treated HistGradientBoostingRegressor 0.89
untreated HistGradientBoostingRegressor 0.85
" + ], + "text/plain": [ + " ╔════════════════════════════════════════════════════════╗\n", + " ║ Conditional Average Treatment Effect Estimator Summary ║\n", + " ╚════════════════════════════════════════════════════════╝\n", + " \n", + " ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┱───────────────────────────────┐\n", + " ┃ Number of observations ┃ 5000 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃ Number of treated observations┃ 1822 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃Average treatement effect (ATE)┃ 0.14 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃95% Confidence interval for ATE┃ (0.12, 0.15) │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃ Estimated bias ┃ -0.01 │\n", + " ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┹───────────────────────────────┘\n", + " ╔═══════════════╗\n", + " ║ Base learners ║\n", + " ╚═══════════════╝\n", + " \n", + " ╔═══════════════════════════════╦═══════════════════════════════╗\n", + " ║ Model ║ R^2 ║\n", + " ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╚═══════════════════════════════╩═══════════════════════════════╝ \n", + " ┃ treated ┃ HistGradientBoostingRegressor │ 0.89 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┼───────────────────────────────┤\n", + " ┃ untreated ┃ HistGradientBoostingRegressor │ 0.85 │\n", + " ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┹───────────────────────────────┴───────────────────────────────┘" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%time\n", + "tlearner = TLearner(X=X, y=y, treated=treated, model=HistGradientBoostingRegressor())\n", + "\n", + "summarize_learner(tlearner)\n", + "tlearner.summary(n_iter=100)" + ] + }, + { + "cell_type": "markdown", + "id": "7bef7acd-3d29-4b2a-b364-a915a30f4f46", + "metadata": {}, + "source": [ + "# X-learner\n", + "The X-learner was first introduced in [[1]](https://arxiv.org/abs/1706.03461) by\n", + "Similarly, to the T-learner, the X-learner first estimates $\\mu_{\\operatorname{treated}}$ and $\\mu_{\\operatorname{untreated}}$. Next, it computes \n", + "\n", + "$$D(1) := Y(1) - \\hat{\\mu}_{\\operatorname{untreated}}(X(1)), \\quad \\text{and} \\quad D(0) = \\hat{\\mu}_{\\operatorname{treated}}(X(0)) - Y(0).$$\n", + "\n", + "Note that if $\\hat{\\mu}_{\\operatorname{untreated}} = \\mu_{\\operatorname{untreated}}$ and $\\hat{\\mu}_{\\operatorname{treated}} = \\mu_{\\operatorname{treated}}$, then $\\tau(x) = \\mathbb{E}[D(1) | X=x] = \\mathbb{E}[D(0) | X=x]$, so CATE may be estimated by regressing on $D(0)$ or $D(1)$. Let us denote the estimations obtained this way by $\\tau_0$ and $\\tau_1$, respectively. \n", + "\n", + "Finally, the X-learner computes a weighted average of the two CATE estimates, that is \n", + "$$\\hat{\\tau}_X(x) = g(x)\\hat{\\tau}_0 + (1 - g(x))\\hat{\\tau_1}(x),$$\n", + "for some weight function $g: \\mathbb{R}^d \\rightarrow [0, 1]$.\n", + "\n", + "In CausalPy, we obtain $g$ as an estimation of the so-called *propensity score*, that is the conditional probability of a unit receiving treatment given $X$. By default, we use logistic regression to obtain this estimation. However, in case one of the treatement groups is small, it makes sense to set $g \\equiv 0$ or $g \\equiv 1$." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "250bd516-b1ad-452f-b26c-e0eafc3747f8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Actual average treatement effect: 0.11803778255762709\n", + "MSE: 0.01568992784762661\n", + "CPU times: total: 26min 27s\n", + "Wall time: 5min 9s\n" + ] + }, + { + "data": { + "text/html": [ + "
Conditional Average Treatment Effect Estimator Summary
Number of observations 5000
Number of treated observations 1822
Average treatement effect (ATE) 0.14
95% Confidence interval for ATE (0.12, 0.15)
Estimated bias -0.0
Base learners
Model R^2
treated HistGradientBoostingRegressor 0.89
untreated HistGradientBoostingRegressor 0.85
treated_cate HistGradientBoostingRegressor 0.49
untreated_cate HistGradientBoostingRegressor 0.44
propensity LogisticRegression 0.64
" + ], + "text/plain": [ + " ╔════════════════════════════════════════════════════════╗\n", + " ║ Conditional Average Treatment Effect Estimator Summary ║\n", + " ╚════════════════════════════════════════════════════════╝\n", + " \n", + " ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┱───────────────────────────────┐\n", + " ┃ Number of observations ┃ 5000 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃ Number of treated observations┃ 1822 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃Average treatement effect (ATE)┃ 0.14 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃95% Confidence interval for ATE┃ (0.12, 0.15) │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃ Estimated bias ┃ -0.0 │\n", + " ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┹───────────────────────────────┘\n", + " ╔═══════════════╗\n", + " ║ Base learners ║\n", + " ╚═══════════════╝\n", + " \n", + " ╔═══════════════════════════════╦═══════════════════════════════╗\n", + " ║ Model ║ R^2 ║\n", + " ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╚═══════════════════════════════╩═══════════════════════════════╝ \n", + " ┃ treated ┃ HistGradientBoostingRegressor │ 0.89 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┼───────────────────────────────┤\n", + " ┃ untreated ┃ HistGradientBoostingRegressor │ 0.85 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┼───────────────────────────────┤\n", + " ┃ treated_cate ┃ HistGradientBoostingRegressor │ 0.49 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┼───────────────────────────────┤\n", + " ┃ untreated_cate ┃ HistGradientBoostingRegressor │ 0.44 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┼───────────────────────────────┤\n", + " ┃ propensity ┃ LogisticRegression │ 0.64 │\n", + " ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┹───────────────────────────────┴───────────────────────────────┘" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAB9sAAAfbCAYAAAAIH89NAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzde4CXY/4//tfUNKVpqmmLUimig8ixhMLmENWSHGLt2jZFsT67zuyyawntKZ+lxWLXx1p2HRKVkFMSkkO0ZEMUis6NakrT4feHX/M13lPNPYfuqR6Pv8x13/d1v97XNTOq531dd9aGDRs2BAAAAAAAAABQZjXSLgAAAAAAAAAAtjXCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBC2WkXAAAAwJb16NEj5s6dW6LtueeeixYtWmzx2kcffTSuuuqqEm0nn3xyDB8+vNz1LFy4MMaNGxfTpk2LmTNnxrJly2LFihWxdu3aEuddddVVMWDAgHLfZ2v5/PPP4+ijjy7R1rx583j++edTqgioLO3atctomzlzZpmuvfXWW2PkyJEl2n72s5/FhRdeWCm1AQAA2zZhOwAAAGX29ddfx+9///t48MEHo6ioKO1yAAAAAFIjbAcAALa60lYRR0TcdNNN0a9fv0q7z5VXXhmjR48u0Wa1cvmtWrUqfvSjH8W7776bdikAAAAAqRO2AwAAUCa//e1vKxS0z5kzJ+bMmVOirVWrVtGqVauKlgZsByZNmpTRdsQRR6RQCQAAQNkI2wEAANiiTz75JB577LGM9hYtWkS/fv1i7733jvr160fNmjVLHG/evHnxf48ZM8a7j4FNGjx4cEZbWd+tDgAAkAZhOwAAAFv0yCOPxIYNG0q0derUKe69996oW7duSlUBAAAApEfYDgAAsJ3r169f9OvXr0J9vPnmmxltv/jFLwTtQLVndTwAAFBVaqRdAAAAANXfjBkzSnxds2bNOPjgg1OqBgAAACB9wnYAAAA2q7CwML7++usSbQ0bNozatWunVBEAAABA+oTtAAAAbNby5csz2urUqZNCJQAAAADVh7AdAACAzSoqKkq7BAAAAIBqJzvtAgAAALZ1GzZsiJkzZ8YHH3wQixcvjlWrVkXdunWjefPm0alTp9hll13SLpFKNmvWrJg5c2YsWLAgCgsLo06dOtG0adPo2LFjtGrVKu3ytgmrV6+Ot99+Oz755JMoKCiIGjVqRIMGDaJ169axzz77RG5ubtolpmLBggXx8ccfx9y5c2PFihVRWFgYO+20UzRo0CDy8/OjQ4cOqf1O+eyzz2LGjBnxxRdfxKpVq6J+/fqRn58f7dq1izZt2qRS07Zu1apVMWPGjPjss89iyZIlsXr16qhfv35873vfi6ZNm8a+++4b2dn++Q4AAKorf1oHAAAoxWuvvRZnn312ibYuXbrEfffdV/z1okWL4p577onHH388Fi5cuMm+9t133/jxj38cJ554YmRlZVVZzZvy6KOPxlVXXVWi7eSTT47hw4eXen6PHj1i7ty5m+1z7ty50a5du82e89xzz8XRRx+92XNGjhwZI0eO3Ow5ERHNmzeP559/fovnVaXly5fH/fffHw899NBmx2ePPfaIM888M84444zIyckpU9+zZs2KXr16lWjLysqKZ599Nlq0aFGhuiMinn322bjgggtKtNWvXz9eeumlrf5KgP/+979x1113xTPPPBNff/11qefk5ORE9+7d45xzzomDDjqouD3p9/K3XXnllTF69OgSbTfddFP069evHJ+ibL8jyuKzzz6LiRMnxtSpU+P111+PpUuXbvGali1bRrdu3WLAgAHRunXrRPf7trJ8hq+//joefvjh+Ne//hUfffTRJvvaddddo1+/fjFw4MAyPyhR2px815Z+z2y0ubksrY+ZM2eWqd+q8PXXX8eYMWNizJgx8dZbb8XatWs3eW5eXl4cdthh0b9//zj88MO3YpUAAEBZ2EYeAACgHMaOHRsnnHBC3H333ZsN2iMi/vOf/8Tll18e/fv3j08//XQrVUhlevnll6NXr15x8803b/FBhI8//jhuuOGG6NOnT0yfPr1M/bdp0yYOOeSQEm0bNmyIhx9+uNw1f9uDDz6Y0XbSSSdt1aC9qKgofve738XJJ58c48aN22TQHhGxZs2aeO655+KHP/xhXHXVVbF69eqtVufWMmHChDj99NPjmGOOiWHDhsWECRPKFLRHfBPQ/+tf/4oTTjghLrvsslixYkWV1Dh9+vQ48cQT4/rrr99s0B4RMW/evBg5cmQcd9xx8cYbb1RJPdu6DRs2xKhRo6JHjx5x9dVXx9SpUzcbtEd885DP008/HQMHDozBgwfHxx9/vJWqBQAAykLYDgAAkNDf//73uPTSS+Orr75KdN0777wTp512WpkDWKqHJ554Is4999xYsGBBouvmzJkTZ511VjzzzDNlOv/MM8/MaBs1atQWw7gtmTdvXkyePDmjvX///hXqN4nCwsI499xz4+9//3usX78+0bWPPvpoDBgwIAoLC6uounRMmDAh3nnnnQr1sX79+hgzZkycdtpp8cknn1RSZd+YMGFC/OhHP4rZs2cnum7RokVxzjnnxCuvvFKp9WzrVqxYERdccEH88pe/jEWLFpWrj0mTJkX//v09zAAAANWIsB0AACCBCRMmxO9///uM9kaNGkXHjh2jS5cu0bp166hVq1ap1y9btiwGDRoUs2bNqupSqQTTpk2LK664IiPwbtCgQXTo0CG6dOkSbdq0idq1a5d6/Zo1a+Kiiy6KV199dYv3OuaYY6JJkyYl2hYuXBgvvPBC+T9ARDz88MMZAfeBBx4Ye+21V4X6Lat169bFRRddtNnwdeedd4799tsvDj744GjZsmXUqFHynyumTZsWl112WVWXWm3ssssu0b59+zj44IOja9eu0bFjx2jUqNEmz//444/jnHPOSfwA0Ka8+uqrcfHFF2fsPtCkSZPo2LFjdO3aNTp06LDJnRFWr14dl112WSxbtqxS6tnWFRQUxE9+8pN47rnnNnlOw4YNo0OHDtG1a9fYd999o3HjxqWe99VXX8XAgQM9zAAAANWEd7YDAACU0dKlS+Oaa66JDRs2FLf16dMnfvzjH8f+++9f4tyCgoJ46qmn4tZbb83YZr6goCAuvfTSeOSRR6JmzZpbo/RERo4cGWvWrCn+euHChfGzn/2sxDlNmjTZ4rvWd9555xLblz/88MPxyCOPlDjn1FNPjdNOO22LNZX13eeVac2aNXHllVdGUVFRcdsRRxwRAwcOjEMOOaREIFxYWBgvvPBC3HrrrRkrjIuKiuKyyy6L8ePHR/369Td5v1q1asWpp54at99+e4n2Bx98MI499thyfYZ169bFqFGjMtq35qr2e++9NyZOnJjRXqNGjfjhD38Y/fv3j7Zt25Y4Nn/+/BgzZkzcfvvtsXLlyoj45r3zlRUmVydZWVnRsWPH6NGjRxxyyCHRrl27yMvLK/XcL774Ip5++um4//77M15JMXfu3Lj66qvjlltuqVA9ixcvjosvvrj4+36nnXaKs88+O0466aRo06ZNiXNXr14dzz33XPzpT3/KeL3CokWL4k9/+lNcf/31m7zX+eefH2eccUbx16V9X5b2CoTS7LbbbmU6b2vbsGFDXH755fHuu+9mHMvLy4sf/vCH0bt372jbtm1kZWWVOP7f//437r///hg1alSsW7euuP3rr7+OSy+9NMaOHRvf+973qvwzAAAAmyZsBwAAKKMPP/yw+L9zcnJixIgRmwxBGzRoEP3794+ePXvGJZdckrGN94wZM+Lvf/97DB48uEprLo+99967xNeff/55xjk5OTkZDxiU5tvnvPTSSxnHmzZtWqZ+0rBw4cLiByVq1KgR11577SZD6rp160bv3r3jmGOOid/+9rcZAffChQtj+PDhceONN272nv37948777yzRLD28ssvx9y5c6N58+aJP8PEiRNj/vz5JdoaNGgQJ5xwQuK+yuOzzz4rNfxt0KBB3H777XHQQQeVet0uu+wSgwcPjt69e8fQoUPjv//9b0RETJ06tUrr3Zpyc3Pjxz/+cfzkJz+Jli1blumaZs2axYABA+LMM8+MP/3pT3HvvfeWOP7000/H9OnTo1OnTuWu69u7brRv3z7uuOOOaNasWann1qlTJ3r37h2HHXZYDBgwoHieNhozZkxcfvnlm3x4YLfddttiSF5dfz+U1d///vdSHzbp3r17/OEPf4j8/PxNXtu+ffu4/vrr4+STT46hQ4eW2Clg8eLF8atf/SruuOOOKqgaAAAoK9vIAwAAJJSVlRV//OMfy7TauGHDhjFy5MhSA6O//OUvtlneRlx99dVlWg1eu3btGDZsWBx//PEZx0aNGpURRn5Xs2bN4sgjjyzRtn79+nj44YeTFfz/e+ihhzLaTjrppE1ue1/Z/vSnP8WqVatKtNWuXTvuuOOOTQbt37brrrvG3XffHS1atKiqElNz7bXXxtVXX13moP3bateuHb/85S/j7LPPzjj23QC+vNq0aRP333//JoP2b8vPz48RI0ZkvD5j9erVMX78+EqpZ1v02Wefxc0335zRfsIJJ8Rdd9212aD92w488MC49957M35uX3jhhVJXzAMAAFuPsB0AACChk08+OXr27Fnm83faaacYPnx4RhC1atWqeOyxxyq5Oipbt27d4qyzzirz+TVq1Ijrr7++1Hds//vf/97i9WeeeWZG23e3kS6LL774otTdBLbWFvKLFi2KZ599NqP93HPPjQMPPLDM/TRp0iSGDRtWmaVVC9/dMrw8LrnkkmjatGmJtqeffrrEayDKIzs7O26++eaoV69ema9p06ZNqQ+ZvPXWWxWqZVt27733lngNRUTEXnvtFb/73e8Sz3/79u3j4osvLvUeAABAeoTtAAAACeTk5MQll1yS+Lrdd9+9xLuJNypt5THVy1VXXZX4mvr162e85z4iYuzYsVFYWLjZa7t3756xtfaCBQvihRdeSFTDI488khHQH3TQQbHnnnsm6qe8Hn300YygsUmTJjFo0KDEfR166KHx/e9/v7JK227UqVMnI+AuKiqK9957r0L99uzZM9q1a5f4utJeT1DRWrZVy5Yty3idRETE5ZdfXu6dJc4888yMd7Q/+eSTW/ydAgAAVB1hOwAAQALf//73o3HjxuW69tRTT81omzVrVnz22WcVLYsqsv/++5c7nP7BD34QOTk5JdpWrFgR06ZN2+x1WVlZpa4+T/Jgxrp160oN+rbWqvaIKPU91T/4wQ+iTp065eqvtJ8fIvbdd9+MtnfeeadCfZZ3rPfZZ5+MttmzZ1eolm3VCy+8kBGCt27dOo444ohy91m7du2MXVWKiooqPN8AAED5CdsBAAASKG2b5LJq37597LHHHhnt06dPr0hJVKGKzHf9+vXj8MMPz2gvSzDWr1+/jKD+pZdeinnz5pXp3pMmTYovvviiRFvDhg0r9HmSWLduXcyYMSOjvbSVz2V15JFHRm5ubkXK2i59d6VzRMSnn35a7v6ys7Nj//33L9e1u+yyS8aq7aKiovj666/LXc+26vXXX89oO+644yrc78EHH5zRtqUHeAAAgKqTnXYBAAAA25LSVpEmvf7jjz8u0TZ9+vTo3bt3hfqlalR0vvfZZ5+M7d/L8nBFo0aN4vjjj48xY8YUt61fvz4efvjh+PnPf77F6x988MGMtpNOOqnc21cn9eGHH8aqVatKtNWqVSvat29f7j43Xv/mm29WtLxqa9q0afHGG2/EBx98EB999FEsW7YsVq5cGStXroy1a9eWuZ+vvvqq3DU0a9Ys6tatW+7r69WrlxGuL1++fKt971UXb7zxRkZbaSv/k2revHlG28yZMyvcLwAAUD7CdgAAgDKqV69etGzZskJ9tG/fPh5//PESbbaRr74qEg5v6vqyrk4/88wzS4TtERGjRo2Kn/3sZ1GzZs1NXvfll1/GpEmTMtq35hbypa2s3n333TNW6yfVoUOH7S5sLywsjL///e/x6KOPxty5cyulz+XLl5f72gYNGlTo3qW9JmBHW9m+Zs2amDNnTkb7qlWr4u23365Q36X9/igoKKhQnwAAQPkJ2wEAAMqovO9q31IfFQnGqDo5OTlRr169CvXRqFGjjLayrjo+8MADo127diVWrc6fPz8mTpwYRx999Cave+SRR2LdunUl2g4++OBo06ZNGauuuNI+Y5MmTSrcb2X8DFYnL774YvzmN7/J2PK/or77rvAkKrKqfVM2bNhQ6X1WZ0uXLi21/YorrqiS+wnbAQAgPd7ZDgAAVBuVHchUdn+V8b7o0sJbQUn1VNGgPSIiLy8voy3JfJ955pkZbQ899NAmz1+/fn088sgjGe1bc1V7ROkPkFTGeFZGH9XF+PHj4/zzz6/0oJ30be3f6R7YAgCA9FjZDgAAbHWb2kp69erVlXqf774zenP3LovStkeujD4q+3NTOWrVqlXhPkr7fisqKirz9SeeeGL84Q9/iJUrVxa3vfTSS/HFF19Es2bNMs6fNGlSRnjbsGHDOP744xNUXXGlfU9Xxju7K+NnsDqYMWNGXHrppRk7EEREZGVlxe677x4HHHBA7LbbbtG0adPIz8+PnJycqF27dtSoUXLdxHvvvRfXXXfd1iqdMijr7hWVZf369Vv1fgAAwP8jbAcAALa6+vXrl9r+7UCxMpTWX0XeR1yRrZk3Kq2m7Wm17vakMr4fV6xYkdFW2mr3TcnNzY2TTjopHnjggeK2devWxSOPPBIXXnhhxvkPPvhgRlvfvn0r/K70pErbBaKqfn62Rdddd12pQfupp54agwYNit13373MfVXGuFK5srP9cxsAAOwo/OkfAADY6urUqRM5OTmxZs2aEu2lBZMVUVp/mwr6y9tfZfRRkZqoOoWFhbF+/fqMlcRJlLa9c9L5PvPMM0uE7RERo0aNivPPPz9q1qxZ3DZ//vx48cUXM64//fTTE92vMpT2Gavq5ycta9euLdd17777bkybNi2j/dprry31tQFb4jUU1c+mHqAaP358tGnTZitXAwAAVCXvbAcAAFJR2grzTz75pFLvUVp/FVnZ/uWXXybaArw0n3/+eUZbRWqi6qxfvz4+/fTTCvUxe/bsjLaGDRsm6qNt27Zx0EEHlWj74osvYtKkSSXaHnnkkYzV0p07d04l3Cvte7q07/2kKtLHtx9M2Ki01eVltWzZsnJd9/zzz2e0devWrVxBe0TE0qVLy3UdVadp06altpsrAADY/gjbAQCAVLRr1y6j7YMPPqi0/ufPn1/qis+2bduWu8+ioqKYNWtWRcqK//73vxlte+21V4X6pOq8//77lX59+/btE/dTWhD77S3j169fH6NGjco4p3///onvVRlK+56eO3duhVemV2Q+StvaviLb0s+fP79c17333nsZbSeddFK565gxY0a5r6Vq1KtXr9TAfd68eSlUAwAAVCVhOwAAkIoDDjggo+3TTz+NhQsXVkr/b775ZqntBx54YJX0Wxbr1q2Lt99+O6N93333rUBF246srKy0S0js1VdfrdD1U6ZMyWjr1KlT4n569uwZjRo1KtE2adKk4sD3pZdeirlz55Y43rBhw+jZs2fie1WGFi1axPe+970SbRs2bIg33nij3H0uW7asQg+75OXlZbQtWrSo3P299dZb5bqutHtWZPeBiowpVWf//ffPaHvttde2fiEAAECVErYDAACp+O622BHfrM598sknK6X/cePGZbTVqlWrwsH22LFjy33tK6+8khG0ZWVllSt83Rbl5ORktJX3vddby1NPPRVr1qwp17XTp08vdRv50h402ZKcnJw45ZRTSrStW7cuHn744Ygoucp9o5NPPrnUMd9aSvu+rsjPz5NPPlmh1zjsvPPOGW0zZ84sV18rV64s9UGKsihtdX/dunXL1debb75Z6a/fSFNp368VfXVHWr7//e9ntL344ovl/n0CAABUT8J2AAAgFQcddFA0adIko/3BBx+scLjy2WefZbzPOiKiR48eUbt27Qr1PW3atHj33XfLde0///nPjLbDDjss8vPzK1TTtqK0bbwLCwtTqKTsCgoKigPtpO6+++6Mtn333Tf22GOPcvXXv3//qFGj5F/jH3nkkfjyyy/jxRdfzDj/9NNPL9d9KssJJ5yQ0fbss8/Gl19+mbivdevWxQMPPFChevbee++MtjfffDNWr16duK9HHnkkli9fXq466tWrl9G2YMGCcvX1t7/9rVzXVVel/Y5YtWpVCpVU3DHHHJPxEMXChQtLfTAGAADYdgnbAQCAVOTk5MRZZ52V0f7RRx/FPffcU6G+r7322lID+wEDBlSo342GDRsWGzZsSHTNpEmTYuLEiRntaQeiW1P9+vUz2r679Xl19Oc//znxduOTJ0+Op59+OqO9Iu9Qb9myZXTr1q1E2xdffBGXXnppxg4BXbp0KXeoX1mOP/74aNiwYYm21atXx+9///vEff373/+ODz74oEL1tGvXLmrVqlWibeXKlTF+/PhE/Xz22Wdx6623lruO0lbYl/Zw0JaMHTs2nnvuuXLXUR01aNAgo21b+B1Rmnr16pX6+/2WW26p0OsQAACA6kXYDgAApOaMM84odfvkP//5z/Hoo48m7m/9+vVxzTXXxOTJkzOOHXDAARV+X/tG06ZNi9/97ndlPn/27Nlx5ZVXZrQ3b948jj766EqpaVuw5557ZrRNnz498YMLW1tBQUGce+65pW7/XZr//ve/cdFFF2W0N23aNPr06VOhWn74wx9mtL3++usZbRUJ9StL7dq1Sw0bn3jiibjvvvvK3M8bb7xRroD+u3JycqJHjx4Z7SNGjIglS5aUqY8FCxbE+eefX+5V7RERBx98cEbbv/71r/jiiy/K3MfUqVPjN7/5TblrqK5Ke3f9tGnTUqikcgwdOjTjgZOvvvoqBg8eXCmB++zZs+Oxxx6rcD8AAED5CdsBAIDU5Ofnx3XXXZfRvnbt2vjlL38Zv/zlL8u8qvGtt96KH//4x/HQQw9lHMvNzY2bbrqpwvVmZWUV//c999wT11577Ra3QZ86dWoMGDAgFi9enHHsN7/5TcZK2+3ZnnvumfFO5oULF8a///3vlCravNq1axdv2/7ee+9F//79Y/r06Zu95rHHHouzzz47vvrqq4xj1157bey0004VqunII4+M5s2bb/ac/Pz8OO644yp0n8oydOjQUuu94YYbYuTIkRkr8r9r/PjxMWTIkOKt3r+7jX5S333vfcQ334M/+clPYvbs2Zu99tlnn43TTz+9eIV9eeeyR48eJX6XRHyzwn7QoEHx6aefbvbajdvpDx48OFauXBkRETVr1ixXHdVRx44dM9r+8Y9/VOjhhjQ1bNgwbrjhhoz2uXPnximnnBL/93//l3ib/JUrV8ZTTz0VQ4YMieOPPz7Gjh1bWeUCAADlkJ12AQAAwI7tBz/4Qbz55pvxr3/9q0T7hg0bYtSoUTFmzJjYb7/9omvXrtG6deto0KBB1K1bN5YvXx7Lli2LGTNmxJQpUza7xfSwYcNi9913r3CtBxxwQKxatSref//9iPhmNeqLL74Yp5xySvTo0SOaNWsWubm5sWDBgpgxY0aMHTs2nnnmmVJXbvfp0yeOPPLICte0LalVq1YcffTR8eSTT5Zov/baa+PFF1+MI444Ilq2bBm5ubkZoWpOTk6p79yuSo0bN46jjz46/vGPf0TEN684OP3006Nz585x9NFHR8uWLaN+/fqxaNGi+Oijj2L8+PHx8ccfl9rXD37wg/j+979f4Zpq1KgRp59+etx8882bPOfkk0/OeKghLXXr1o3f/va3MWjQoBLtGzZsiFtvvTWefPLJOOWUU6J79+7RtGnTyM7OjgULFsS0adNi9OjRMWXKlOJratasGWeccUbcf//95a7niCOOiC5dusTUqVNLtH/wwQfRp0+f6NmzZxx++OHRtGnTqFGjRixZsiTef//9mDhxYonfMTvttFNcdtllpT4stCW777579OrVK5544okS7R999FGcdNJJccopp8Sxxx4bbdu2jby8vPjqq6/iyy+/jMmTJ8eYMWPiww8/LL4mKysrzj333Lj99tsT11EdHX/88XHLLbeUaPvkk0+id+/ecdJJJ0XHjh0jPz8/ateunXHtbrvtFo0aNdpapZbZMcccEz//+c/jz3/+c4n2VatWxU033RS33XZb9OrVKw4++ODo0KFD5OfnR/369WPNmjWxYsWKKCgoiFmzZsXMmTPjP//5T7z22muxZs2alD4NAADwXcJ2AAAgdVdffXXUqlWrONT8tqKionjjjTfijTfeSNxvnTp14rrrrotevXpVRpmRnZ0df/rTn6J///7FKy3nzZsXt956a6J3OO+9997lCum2Bz/+8Y/jqaeeyngA4YUXXogXXnhhk9c1b948nn/++aouL8Nll10W7777brz11lsR8U1IPHXq1IywdnMOPPDAGDZsWKXVdOqpp8bIkSOjqKio1OOlbd2epu7du8f//M//ZISoEd8EzL/73e/K9FqGX/ziF9G4ceMK1ZKVlRU33HBD9O3bt3hl+EZFRUUxbty4GDdu3Gb7yM7OjptvvrnUV2CU1eWXXx5Tp06NhQsXlmgvLCyM++67r8zb7P/iF7+IAw44YLsJ29u0aROHH354vPzyyyXa58+fH3feeedmr73pppuiX79+VVleuZ1//vlRo0aNUh+SKSgoiH/9618ZD5wBAADbBtvIAwAAqcvOzo5f/epX8Yc//CHq169fKX22bt06/vWvf8VJJ51UKf1t1KZNm7jjjjvKXecBBxwQ99xzT+Tm5lZqXduKgw46KAYPHpx2GWWWk5MTd955Z3Tp0qVc1/fo0SP+9re/RZ06dSqtpsaNG8exxx5b6rEuXbpUyi4Ole2CCy6In//85xnbp5fVoEGD4txzz62UWnbbbbe45557Mt6lXRb16tWL2267rcK7FDRt2jRuu+22ctUQ8c1DAxdeeGEMGTKkQnVURzfeeGO1XKFeUUOGDIm//vWvFX5g5Lt2pFeRAABAdSRsBwAAqo0TTzwxXnjhhbj00kujSZMm5eqjQ4cOMWLEiBg/fnyVbTt+8MEHx8MPPxwHHXRQma/JycmJ8847L+67775yB2zbi0suuSSuu+66bWYc8vLy4p577olLLrkk8vLyynRN48aN4/rrr4/bb7+9QiugN+XMM88stf2MM86o9HtVlvPPPz/uvPPOaNGiRZmvyc/Pjz/+8Y9x2WWXVWot++23Xzz00EPRo0ePMl/To0ePGDNmTKW9/qFTp04xatSoOPDAAxNd17Jly7jzzjvjZz/7WaXUUd00bdo0Ro8eHd26dUu7lEp31FFHxdNPPx1Dhgyp0O+/WrVqxRFHHBE333xzxvb0AADA1pW1obSXBwIAAKRs3bp1MWPGjHjzzTfjzTffjLlz58ayZcuioKAgVq9eHfXq1YsGDRpEw4YNY4899oiDDjooOnfuHK1bt66U+7/22mtx9tlnl2jr0qVLxvbOL7/8cowePTpeffXVWLRoUYljWVlZ0aZNmzjmmGPijDPOiGbNmlVKbVvbokWL4oorrijR1rhx4zJt/b05a9asieeeey6mTp0a//3vf2Pu3LmxcuXKWLVqVaxbt67EuWltI/9dK1asiKeeeiomT54cM2fOjPnz58fq1aujdu3ascsuu0THjh3j+9//fhx33HFV+t70Z555JiNsbdSoUbz44ovV5n3tm7JmzZp44oknYsyYMfHmm2/G119/XeJ47dq1Y7/99ouePXtGv379Sjys8Oijj8ZVV11V4vyTTz45hg8fXu563nvvvXjuuefi1VdfjS+//DKWLFkS69atiwYNGsQee+wRBx98cPTu3Tv23HPPct9jS15++eUYNWpUvPbaaxm/RyIivve970Xnzp3j+OOPj2OPPTays//fWwHnz58fzzzzTInzd9lll03ufrAt+eSTT+Kpp56KGTNmxIcffhgFBQWxcuXKjO+ZiOq9jXxpVq9eHRMnToyJEyfG22+/HXPmzIn169eXeu7OO+8ce+yxR+y9997RtWvX6Ny5c5U8xAMAACQnbAcAAChFWcP2b1uyZEksWrQoVq9eHXXr1o1dd91VIEKVGDx4cEyaNKlE28CBAzMeiqju1q1bF/PmzYuvvvoqatSoEXl5ebHrrrtGjRqlb8RXFWF7dbN48eJYtmxZFBYWxk477RRNmjSJBg0apF0WVayoqCjmz58fK1asiDVr1sROO+0Uubm50bBhQ/8fAQCAaix7y6cAAABQFo0aNdou3zVM9TJ37tyYPHlyibasrKzo379/ShWVX82aNaNly5Zpl1GtfO9734vvfe97aZfBVlarVq1Er1gAAACqB+9sBwAAgG3IQw89lLHddNeuXSvtFQoAAABA2QjbAQAAYBuxYsWK+Pe//53R/qMf/SiFagAAAGDHJmwHAACAbcTdd98dy5YtK9HWvHnz+P73v59OQQAAALADE7YDAADANuCVV16Ju+++O6N9yJAhUbNmzRQqAgAAgB1bdtoFAAAAAP/Pp59+GkuWLImIiK+//jrmzp0bkyZNiqeeeio2bNhQ4txWrVpFv3790igTAAAAdnjCdgAAAKhGbrvtthg9evQWz8vKyorrrrsusrP91R4AAADSYBt5AAAA2AYNHTo0unbtmnYZAAAAsMOq1o+/T58+PW699daYNm1arF27Ntq2bRsDBgyIXr16len6Rx99NK666qpNHv/HP/4RhxxySGWVCwAAAFWuVq1aceGFF8Z5552XdikAAACwQ6u2YfuUKVNi0KBBkZOTE717947c3NyYMGFCXHTRRfHll1/GwIEDy9zX0UcfHR06dMhob968+RavXbp0aaK6q5sGDRpEQUFB2mXssIx/+sxBuox/+sxBuox/+sxBurb18V++fHlGW1FR0Tb1d4RtfQ62deUd/6+//rrE1zVr1ozc3Nxo2bJlHHzwwXHSSSfFrrvuuk19L1aWlStXZrR9/fXXmxwLPwPpMv7pMwfpMv7pMwfpMv7pMwfpMv7pMwfp2h7GPz8/f4vnVMuwfe3atXHNNddEVlZW3H///cVB+QUXXBCnnnpqjBgxInr27FmmsDwi4phjjol+/fpVZcnVVo0a3hSQJuOfPnOQLuOfPnOQLuOfPnOQrm19/A866KCYMmVK2mVUyLY+B9u68o7/r3/96/j1r39dydVsH/r06RN9+vQp8/l+BtJl/NNnDtJl/NNnDtJl/NNnDtJl/NNnDtK1o4x/tfyUU6ZMiU8//TT69OlTYkV6Xl5eDBkyJIqKimL06NEpVggAAAAAAADAjqxarmyfOnVqRER069Yt49jGttdff73M/c2YMSOWLVsWa9eujRYtWsShhx5apmX/AAAAAAAAAFCaahm2z549OyIiWrVqlXGsSZMmUbdu3ZgzZ06Z+7vvvvtKfF2nTp244IIL4txzz61QnQAAAAAAAADsmLI2bNiwIe0ivmvgwIHx8ssvx4QJE0oN3Lt37x6FhYXx5ptvbrafqVOnxgcffBDdunWLpk2bRkFBQbz66qsxYsSImD9/flx99dXx4x//eLN9rF+/fod5pwAAAAAAAAAAZVMtV7ZXli5dukSXLl2Kv65Tp0707ds3OnbsGKecckqMHDkyzjzzzMjO3vQwFBQUbI1Sq0x+fn4sXbo07TJ2WMY/feYgXcY/feYgXcY/feYgXcY/feYgXcY/feYgXcY/feYgXcY/feYgXcY/feYgXcY/feYgXdvD+JflteTVcsl2vXr1IiJi+fLlpR5fsWJF5OXllbv/vfbaKw466KBYtmxZzJo1q9z9AAAAAAAAALBjqpZhe+vWrSMiSn0v+8KFC6OwsLDU7eWT2PgkwqpVqyrUDwAAAAAAAAA7nmoZtnfu3DkiIiZPnpxxbGPbxnPKY926dfHuu+9GRMSuu+5a7n4AAAAAAAAA2DFVy7D90EMPjZYtW8a4cePi/fffL25fvnx53HHHHVGrVq3o27dvcfuCBQti1qxZGdvObwzUv23dunXxxz/+MebMmROHHHJI7LzzzlX2OQAAAAAAAADYPmWnXUBpsrOzY9iwYTFo0KA466yzonfv3pGbmxsTJkyIuXPnxhVXXBEtWrQoPn/EiBExevTouOmmm6Jfv37F7aecckq0a9cu2rVrF7vssksUFBTE1KlTY/bs2dG0adO44YYb0vh4AAAAAAAAAGzjqmXYHhHRtWvXeOCBB+KWW26J8ePHx9q1a6Nt27Zx6aWXRq9evcrUx8CBA+Ptt9+OV155JQoKCqJWrVqx2267xdChQ+OnP/1pNGjQoIo/BQAAAAAAAADbo2obtkdEdOrUKe6+++4tnjd8+PAYPnx4RvsVV1xRFWUBAAAAAAAAsIOrlu9sBwAAAAAAAIDqTNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhLLTLgAAAAAAAIAdT7ej1qddwiZNnmi9anUybty4GDZsWFx99dXRp0+f4va+fftGRMRjjz1W4vzFixfH8OHD45VXXolFixbF+vXr45lnnom8vLxy3b9r165xwAEHxO23317ej0Apks5rdSRsBwAAAAAAgEr0+eefx9FHHx0REY0aNYoxY8ZEdnZmLPfJJ5/EmWeeGRERTZs23SbCxW3B9ddfH6+99loce+yx0bJly4iIyMnJ2aZC3O3BvHnzol+/ftGrV6/49a9/nXY5VULYDgAAAAAAAFWgZs2asWTJknjllVfiiCOOyDg+duzYqFHDKvryGjlyZEZbUVFRTJ06NQ477LC47rrrUqiKsjrqqKNin332icaNG6ddSrn56QUAAAAAAIAq0KlTp6hXr16MGzcu49jatWvjqaeeis6dO5e66p0ta9GiRbRo0aJE2+LFi2P9+vWx8847p1QVZVWvXr1o3bp11KtXL+1Syk3YDgAAAAAAAFWgdu3aceyxx8bLL78cS5YsKXFsY9u331X9XRs2bIixY8fG4MGDo0ePHnHkkUfGgAEDYuzYsRnnLly4MO66664455xz4oQTToju3btH37594/e//33GvSMirrvuuujatWvMmzcvHnzwwejfv3/xNXfffXesX7++TJ/xzTffjK5du8Zdd92VcWzevHnRtWvXjBXmffv2jb59+8by5ctj+PDh0atXrzjiiCPi7LPPjgkTJpTpvt/uZ6OhQ4cWfz169Ojo2rVr8f27du0aX375ZXz55ZfF7Zuqe1MWLFgQ11xzTfTs2TOOPPLIGDx4cEydOrXEOb/5zW+ia9eu8d5775Xax5133hldu3Yt8+d8++23Y+jQoXHUUUfFcccdF7/61a9i/vz5MXTo0OjatWuJc789p9911113RdeuXePNN98sbisqKoqHHnoofv7zn8eJJ54Y3bt3jxNOOCGuuOKKmDlzZkYf48aNi65du8a4cePitddei8GDB8eRRx4Zxx13XFx33XVRUFBQfO6jjz4a/fr1i4iI8ePHlxjzjTV8u7+ySPLzsLV4TAYAAAAAAACqSJ8+fWL06NHx5JNPxllnnVXcPnbs2Khfv34ceeSRcf3112dct2HDhvjNb34TEyZMiJYtW0bPnj0jOzs7pk6dGjfccEN88skn8T//8z/F57/99tvxwAMPxMEHHxwdO3aM7Ozs+OCDD+LRRx+N1157Le69995SVxDfeuutMW3atDj88MPjkEMOiUmTJsXdd98dRUVFMXTo0KoZlPhmZf+FF14Yq1atihNOOCFWrVoVzz33XPz617+OZcuWxemnn564z969e0fbtm3jwQcfjPbt28fhhx8eERFt27aNZs2axYMPPhgREf379y++5sADDyxT38uXL49zzz03GjZsGCeeeGIsW7Ysnn322bjooovixhtvjCOPPDIiIk4++eR4+umnY8yYMdGxY8cSfaxbty7GjRsXDRo0iKOOOmqL93z99dfjoosuiho1asQxxxwTjRs3jjfeeCPOPffcyMvLK1Pdm/PVV1/F//7v/8Z+++0Xhx12WOTl5cW8efPipZdeiilTpsTtt98ee++9d8Z1L730UrzyyivRrVu32HfffePtt9+O8ePHx+effx533nlnRER06NAh+vfvHw8++GDstddeJV6j0KxZs8S1Jv152FqE7QAAAAAAAFBFOnbsGG3atIknnniiOGxfvHhxvPrqq9GvX7/Iyckp9brHH388JkyYEH369Ikrr7yyeKv5oqKiuOqqq+KBBx6I4447Ltq3bx8REQcddFA88cQTUbdu3RL9jB8/Pq677rp4+OGH46c//WnGfWbOnBn//Oc/i9+bPXDgwDjttNPi4YcfjkGDBkWtWrUqbSy+bdGiRdGyZcu46667iu8xYMCAOPvss2PkyJFx1FFHJd4Kvk+fPsUr9Tt06BCDBw8uPnbkkUfGE088ERFRor2sPvroozjuuOPit7/9bWRlZUVExOmnnx4DBw6M4cOHxyGHHBJ16tSJ/fffP3bfffd45pln4he/+EXstNNOxX1MmTIlFixYEGecccYm532j9evXx/Dhw2PdunUxcuTI2H///SOiZOhcUXl5efHYY49ljPPHH38cgwYNittvvz1uvfXWjOsmT54ct912W+y3334R8c1DBBdeeGG89dZb8e6778Y+++yTEbaXZ8y/LenPw9ZiG3kAAAAAAACoQn369ImPP/443n333YiIeOKJJ2LdunXxgx/8YJPXPPLII7HTTjvFpZdeWuKd7rVq1YohQ4ZERJQIXBs1apQRtEdEnHDCCZGbmxuvv/56qfcZOHBgcdAeEdGwYcPo3r17FBYWxpw5c5J90ISGDBlSIszfeeed4/TTT481a9bEM888U6X3TqpmzZoxdOjQ4qA9ImKvvfaK448/PpYuXRqvvPJKcXvfvn2jsLAw4zOMGTMmIiJOOumkLd7vnXfeiblz58bhhx9eHLRHRGRlZcXQoUOjZs2aFfxEETk5OaU+0LDHHnvEgQceGG+//XasXbs243jPnj2Lg/aIb8amV69eERExY8aMCtdVmqQ/D1uLle0AAAAAAABQhY4//vj4y1/+EuPGjYt99tknnnjiiWjbtm20bdu21PNXr14ds2bNisaNG8d9992XcXxjAPrdMPyFF16Ixx57LGbOnBnLly+PdevWFR9btGhRqfdq165dRtvGAHbFihVl+4DlULNmzdh3330z2jcGyx988EGV3bs8dtlll1K3P99///1j7Nix8cEHH0SPHj0iIqJXr15x2223xeOPPx4nnnhiRHyzm8HkyZNj3333jd13332L9/vwww+L+/+uZs2axc477xxffPFFBT7RNz744IP45z//Ge+8804sXrw4I1xftmxZiYcxIrb+90x5fx62BmE7AAAAAAAAVKH8/Pzo1q1bPPPMM9GjR4+YM2dOXHLJJZs8/6uvvooNGzbEwoUL429/+9smz1u1alXxf99///1x6623Rn5+fnTp0iV23nnnqF27dkREPPjgg7FmzZpS+8jNzc1o27hq+tthfWVr2LBh1KiRuQl3o0aNIqJqg/7y2FjXptq/XW9eXl4cffTRMX78+Jg1a1bxawTWrVtXplXt3+4vPz9/k/etaNg+ffr0+NnPfhYREV26dIkePXoU744wadKk+PDDD0v9vtna3zPl+XnYWoTtAAAAAAAAUMVOPPHEmDhxYlx//fVRu3bt6Nmz5ybP3Rhmtm/fPv7v//5vi32vXbs27rnnnmjcuHH84x//KBEMb9iwIf75z39WuP5N2RiYlxayrly5cpPXLVu2LNavX58RuC9ZsiQiIurVq1eJVVbcxro21f7devv16xfjx4+Pxx9/PC6++OIYO3Zs5ObmxjHHHFOm+23sb+nSpWWuJ+lc/N///V+sWbMm7rjjjowV9O+9917x6vq0Jf152Jq8sx0AAAAAAACq2CGHHBJNmjSJhQsXxhFHHBH169ff5Lm5ubnRunXrmD17dixfvnyLfRcUFMSKFStin332yViB/f7778fXX39d4fo3JS8vLyIiFi5cmHFs5syZm7xu3bp18Z///Cej/e23346I2OQW+xVRs2bNWL9+fbmunT9/fqkryTdV7z777BN77rlnPPXUU/Haa6/FZ599Fj179ow6deqU6X577bVXif6/7YsvvogFCxZktCedi7lz50b9+vUzgvbVq1dvdu7KauNq9/KO+UZJfx62JmE7AAAAAAAAVLGaNWvG73//+/jd734XQ4cO3eL5p59+eqxevTpuuummUrfHnjdvXsybNy8ivtlqvHbt2jFz5sxYvXp18TlfffVV/OlPf6q8D1GKVq1aRd26deOll16KgoKC4vbFixdvcRXyHXfcEUVFRcVfL1iwIB566KHIycmJY489ttJrrV+/fhQUFJTr4YN169bF7bffHhs2bChu+/DDD+Opp56K/Pz8OOywwzKu6du3b3z11VcxbNiwiIgybyEfEbHffvvFrrvuGi+//HKJwH3Dhg1x++23l7p6fe+9946IiCeeeKJE+/PPPx/Tpk3LOL9p06axfPny+Pjjj0t8zltuuWWTK+qTyMvLi6ysrJg/f36F+0ry87A12UYeAAAAAAAAtoIOHTpEhw4dynTuySefHO+++26MHz8+pk+fHp07d47GjRvHkiVLYs6cOfHee+/FddddF7vuumvUqFEjTjnllHjggQfiRz/6UXTr1i1WrlwZU6ZMiaZNm0aTJk2q7DPVqlUrTjvttLj33nvjJz/5SRxxxBFRWFgYkydPjgMOOCA+//zzUq9r3LhxrFq1qrjeVatWxXPPPRcFBQVx8cUXx84771zptR500EHx/vvvx0UXXRT7779/ZGdnxwEHHBAHHHDAFq/dc889Y/r06fHTn/40OnfuHMuWLYtnn3021q1bF1deeWWpK9ZPOOGE+Mtf/hILFy6M9u3bR7t27cpca40aNeLKK6+Miy++OP7nf/4njjnmmGjcuHG88cYbsXjx4thzzz3jo48+KnFN9+7do0WLFvHEE0/E/Pnzo127djF79ux444034rDDDotXXnmlxPmnnXZavPbaa3HeeefF0UcfHTk5OfHWW2/FwoUL48ADD4y33nqrzPWWpm7dutGhQ4d4++2349prr42WLVtGVlZWnHDCCdGsWbNEfSX5ediahO0AAAAAAABsdZMn2oB5c7KysuLXv/51HHbYYfH444/Hyy+/HIWFhZGfnx8tW7aMCy+8MDp37lx8/vnnnx/169ePJ554Ih599NFo1KhRHHvssTFo0KD44Q9/WKW1nnfeeVGrVq0YO3ZsjB49Opo1axY//elPo3v37vHCCy+Uek12dnbccsstcdttt8WTTz4ZK1asiFatWsUll1wSxx13XJXUOXDgwFi+fHm8/PLL8c4778S6devinHPOKVPYnpeXFyNGjIhbbrklHn/88fj666+jbdu2MWjQoDjkkENKvSY3NzeOPPLIeOqppxKtat+oS5cuMXLkyPjrX/8azz33XNSuXTs6d+4cN954Y/z2t7/NOL9OnTpxyy23xJ///Od4/fXX47333ouOHTvGHXfcEZMnT84I27t16xY33nhj3HvvvfHUU09FnTp14qCDDorf/e538be//S1xvaW59tpr43//93/j5ZdfjhUrVsSGDRtiv/32Sxy2J/152FqyNnx7rwMyVMYWCWnKz8/f5j/Dtsz4p88cpMv4p88cpMv4p88cpMv4p88cpMv4p88cpMv4p88cpMv4p88cpMv4p88cpMv4b17fvn0jIuKxxx6rsntUlzk466yzYt68eTFu3LjIzc2ttH6HDh0a06ZNiylTplRan5Wpuox/ReTn52/xHI8MAQAAAAAAAFSyV155JWbNmhU9e/as1KCd6sM28gAAAAAAAACVZNSoUbFgwYIYM2ZM1K5dO84+++y0S6KKCNtT1u2o9VV8h8VV2rv3qQAAAAAAAMD/c99998XChQtjt912i1/96lex6667pl0SVUTYDgAAAAAAAGw1Vfmu9upga3y+22+/vcrvwZZZlgwAAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJFStw/bp06fH4MGD4+CDD479998/Tj/99Bg/fny5+ysoKIju3btHu3bt4pxzzqnESgEAAAAAAADYkWSnXcCmTJkyJQYNGhQ5OTnRu3fvyM3NjQkTJsRFF10UX375ZQwcODBxn9ddd12sWLGiCqoFAAAAAAAAYEdSLVe2r127Nq655prIysqK+++/P66//vq48sor4/HHH4/WrVvHiBEjYu7cuYn6fPrpp2PcuHFx6aWXVlHVAAAAAAAAAOwoqmXYPmXKlPj000+jT58+0aFDh+L2vLy8GDJkSBQVFcXo0aPL3N+SJUvi2muvjZNOOimOPPLIqigZAAAAAAAAgB1ItQzbp06dGhER3bp1yzi2se31118vc3+/+c1vombNmvGrX/2qcgoEAAAAAAAAYIdWLd/ZPnv27IiIaNWqVcaxJk2aRN26dWPOnDll6uvxxx+PCRMmxF/+8pdo0KBBLF++PFEtDRo0iBo1qvKZhMVV2HfVy8/PT7uEas8Ypc8cpMv4p88cpMv4p88cpMv4p88cpMv4p88cpMv4p88cpMv4p88cpMv4p88cpMv4p88cpGtHGP9qGbavWLEiIr7ZNr409erVK1NoPn/+/LjhhhuiT58+ccwxx5SrloKCgnJdt6NYunRp2iVUa/n5+cYoZeYgXcY/feYgXcY/feYgXcY/feYgXcY/feYgXcY/feYgXcY/feYgXcY/feYgXcY/feYgXdvD+JflYYFquY18Zbn66qsjOzvb9vEAAAAAAAAAVKpqubK9Xr16ERGbXL2+YsWKaNCgwWb7GD16dEyaNCn+/Oc/R6NGjSq9RgAAAAAAAAB2XNUybG/dunVERMyZMyf22WefEscWLlwYhYWF0alTp832MWPGjIiI+PnPf17q8cmTJ0e7du2iffv28fjjj1e8aAAAAAAAAAB2GNUybO/cuXP89a9/jcmTJ0fv3r1LHJs8eXLxOZtzwAEHRGFhYUZ7YWFhjB8/Ppo2bRrdunWLZs2aVV7hAAAAAAAAAOwQqmXYfuihh0bLli1j3LhxcfbZZ0eHDh0i4ptt5e+4446oVatW9O3bt/j8BQsWxPLly2PnnXeOvLy8iIjo1atX9OrVK6Pvzz//PMaPHx977rln3HDDDVvl8wAAAAAAAACwfamRdgGlyc7OjmHDhsWGDRvirLPOimuuuSaGDx8eJ510UsyePTsuvvjiaNGiRfH5I0aMiF69esUzzzyTYtUAAAAAAAAA7Ciq5cr2iIiuXbvGAw88ELfcckuMHz8+1q5dG23bto1LL7201BXrAAAAAAAAALC1VNuwPSKiU6dOcffdd2/xvOHDh8fw4cPL1GeLFi1i5syZFS0NAAAAAAAAgB1YtdxGHgAAAAAAAACqM2E7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISy0y4A0tTtqPVVfIfFVdr75ImelwEAAAAAAIA0SOoAAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJJSddgHAjq3bUeur+A6Lq7T3yRM9swQAAAAAALAjkhIBAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgoey0C9ic6dOnx6233hrTpk2LtWvXRtu2bWPAgAHRq1evMl3/4osvxmOPPRbvv/9+LFq0KIqKiqJZs2Zx4IEHxuDBg2P33Xev4k8AAAAAAAAAwPao2obtU6ZMiUGDBkVOTk707t07cnNzY8KECXHRRRfFl19+GQMHDtxiH5MmTYp33nknOnXqFDvvvHNkZ2fHxx9/HI899liMHTs27rzzzjj00EO3wqcBAAAAAAAAYHtSLcP2tWvXxjXXXBNZWVlx//33R4cOHSIi4oILLohTTz01RowYET179ozmzZtvtp/LL788rrnmmoz2V199NQYMGBB//OMfY9SoUVXyGQAAAAAAAADYflXLd7ZPmTIlPv300+jTp09x0B4RkZeXF0OGDImioqIYPXr0FvupXbt2qe2HHnpoNGjQID799NNKqxkAAAAAAACAHUe1DNunTp0aERHdunXLOLax7fXXXy93/9OmTYuCgoLYa6+9yt0HAAAAAAAAADuuarmN/OzZsyMiolWrVhnHmjRpEnXr1o05c+aUub/JkyfHtGnTYs2aNTFnzpx44YUXIj8/P6666qrKKhkAAAAAAACAHUi1DNtXrFgREd9sG1+aevXqxfLly8vc38svvxx///vfi79u1apVjBgxIvbZZ58tXtugQYOoUaMqNwBYXIV9V738/Py0S6gg458+c7C9M0bpMwfpMv7pMwfpMv7pMwfpMv7pMwfpMv7pMwfpMv7pMwfpMv7pMwfpMv7pMwfp2hHGv1qG7ZXtiiuuiCuuuCJWrlwZs2bNir/85S9x5plnxo033hg/+MEPNnttQUHBVqpy27R06dK0S9ihGf/0mYPNy8/PN0YpMwfpMv7pMwfpMv7pMwfpMv7pMwfpMv7pMwfpMv7pMwfpMv7pMwfpMv7pMwfp2h7GvywPC1TLd7bXq1cvImKTq9dXrFixyVXvm5ObmxudOnWKv/zlL7HHHnvEr3/961iyZEmFagUAAAAAAABgx1Mtw/bWrVtHRJT6XvaFCxdGYWFhqe9zL6vs7Ow45JBDorCwMP7zn/+Uux8AAAAAAAAAdkzVMmzv3LlzRERMnjw549jGto3nlNeCBQsiIqJWrVoV6gcAAAAAAACAHU+1DNsPPfTQaNmyZYwbNy7ef//94vbly5fHHXfcEbVq1Yq+ffsWty9YsCBmzZqVse38platv/TSS/Hss89G/fr1Y//996+KjwAAAAAAAADAdiw77QJKk52dHcOGDYtBgwbFWWedFb17947c3NyYMGFCzJ07N6644opo0aJF8fkjRoyI0aNHx0033RT9+vUrbj/11FOjbdu20bZt22jatGmsWrUqZs6cGW+88UbUqlUrbrzxxqhbt24aHxEAAAAAAACAbVi1DNsjIrp27RoPPPBA3HLLLTF+/PhYu3ZttG3bNi699NLo1atXmfq4+OKL47XXXovXX389lixZEjVq1IhmzZpF//794yc/+Um0adOmij8FAAAAAAAAANujahu2R0R06tQp7r777i2eN3z48Bg+fHhG+3nnnRfnnXdeVZQGAAAAAAAAwA6sWr6zHQAAAAAAAACqM2E7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABIKDvtAgBIT7ej1lfxHRZXae+TJ3pmDAAAAAAASIeUAgAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJBQdtoFAMCOrNtR66v4DourtPfJEz23BwAAAADAjsm/kAMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACWWnXQAAQFq6HbW+iu+wuEp7nzzRc5MAAAAAAGnxL7QAAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAklJ12AZszffr0uPXWW2PatGmxdu3aaNu2bQwYMCB69eq1xWs3bNgQkyZNiueffz7eeuutmDdvXqxduzZatWoVvXr1ip/+9KdRu3btrfApAAAAAAAAANjeVNuwfcqUKTFo0KDIycmJ3r17R25ubkyYMCEuuuii+PLLL2PgwIGbvX7NmjVx7rnnRk5OTnTp0iW6desWa9asicmTJ8fNN98czz77bNx3332x0047baVPBAAAAAAAAMD2olqG7WvXro1rrrkmsrKy4v77748OHTpERMQFF1wQp556aowYMSJ69uwZzZs332QfNWrUiF/84hfxwx/+MBo0aFDcXlRUFBdeeGG88MILcf/998egQYOq/PMAAAAAAAAAsH2plu9snzJlSnz66afRp0+f4qA9IiIvLy+GDBkSRUVFMXr06M32UatWrRg6dGiJoH1j+3nnnRcREa+//nrlFw8AAAAAAADAdq9ahu1Tp06NiIhu3bplHNvYVpGgPDv7mwX9NWvWLHcfAAAAAAAAAOy4qmXYPnv27IiIaNWqVcaxJk2aRN26dWPOnDnl7n/UqFEREXH44YeXuw8AAAAAAAAAdlzV8p3tK1asiIhvto0vTb169WL58uXl6vvFF1+MBx98MNq0aROnnXbaFs9v0KBB1KhRlc8kLK7Cvqtefn5+2iVUkPFPnzlIl/FPnzlIl/HfERindBn/9JmDdBn/9JmDdBn/9JmDdBn/9JmDdBn/9JmDdBn/9JmDdO0I418tw/aqMn369LjooosiLy8v/vznP0dOTs4WrykoKNgKlW27li5dmnYJOzTjnz5zkC7jnz5zkC7jv2X5+fnGKUXGP33mIF3GP33mIF3GP33mIF3GP33mIF3GP33mIF3GP33mIF3bw/iX5WGBarmNfL169SIiNrl6fcWKFZtc9b4p//nPf+Kcc86JGjVqxN133x177bVXhesEAAAAAAAAYMdULcP21q1bR0SU+l72hQsXRmFhYanvc9+U//znPzFw4MBYv359/O1vf4tOnTpVVqkAAAAAAAAA7ICq5TbynTt3jr/+9a8xefLk6N27d4ljkydPLj6nLDYG7evWrYu//e1vsd9++1V6vQAAlE+3o9ZX8R0WV2nvkydWy2dXAQAAAICtoFr+6+Chhx4aLVu2jHHjxsX7779f3L58+fK44447olatWtG3b9/i9gULFsSsWbMytp1/9913Y+DAgbF27dq466674oADDthaHwEAAAAAAACA7Vi1XNmenZ0dw4YNi0GDBsVZZ50VvXv3jtzc3JgwYULMnTs3rrjiimjRokXx+SNGjIjRo0fHTTfdFP369YuIiGXLlsXAgQPjq6++iu7du8crr7wSr7zySon75OXlxYABA7bmRwMAAAAAAABgO1Atw/aIiK5du8YDDzwQt9xyS4wfPz7Wrl0bbdu2jUsvvTR69eq1xetXrFgRBQUFERHx0ksvxUsvvZRxTvPmzYXtAAAAAAAAACRWbcP2iIhOnTrF3XffvcXzhg8fHsOHDy/R1qJFi5g5c2ZVlQYAAAAAAADADqxavrMdAAAAAAAAAKozYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAklJ12AQAAQDq6HbW+iu+wuEp7nzzRs8MAAAAApMe/TgEAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISy0y4AAABgR9XtqPVVfIfFVdr75Ime3wYAAAB2XP5lBAAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACWWnXQAAAACkodtR66v4DourtPfJEz0/DwAAAGnyN3MAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhLLTLgAAAADYMXU7an0V32FxlfY+eaI1DAAAADsyfysEAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAllp13A5kyfPj1uvfXWmDZtWqxduzbatm0bAwYMiF69epXp+k8//TQef/zxeO+99+K9996LBQsWRPPmzeP555+v4soBAAAAAAAA2J5V27B9ypQpMWjQoMjJyYnevXtHbm5uTJgwIS666KL48ssvY+DAgVvs44033oiRI0dGzZo1o02bNrFo0aKtUDkAAAAAAAAA27tqGbavXbs2rrnmmsjKyor7778/OnToEBERF1xwQZx66qkxYsSI6NmzZzRv3nyz/XTu3DkefPDBaN++fdSpUyf23XffrVE+AAAAAAAAANu5avnO9ilTpsSnn34affr0KQ7aIyLy8vJiyJAhUVRUFKNHj95iPy1btoz9998/6tSpU5XlAgAAAAAAALCDqZYr26dOnRoREd26dcs4trHt9ddf36o1AQAAAGxPuh21vorvsLhKe588sVquIQEAAHYg1fJvJbNnz46IiFatWmUca9KkSdStWzfmzJmzlasCAAAAAAAAgG9Uy5XtK1asiIhvto0vTb169WL58uVbpZYGDRpEjRpV+UxC1T7lXdXy8/PTLqGCjH/6zEG6jH/6zEG6jH/6zEG6jH/6zEG6jH/6zEG6jP+OwDily/inzxyky/inzxyky/inzxyka0cY/2oZtlcnBQUFaZdQrS1dujTtEnZoxj995iBdxj995iBdxj995iBdxj995iBdxj995iBdxn/L8vPzjVOKjH/6zEG6jH/6zEG6jH/6zEG6tofxL8vDAtVyG/l69epFRGxy9fqKFSs2ueodAAAAAAAAAKpatQzbW7duHRFR6nvZFy5cGIWFhaW+zx0AAAAAAAAAtoZqGbZ37tw5IiImT56ccWxj28ZzAAAAAAAAAGBrq5Zh+6GHHhotW7aMcePGxfvvv1/cvnz58rjjjjuiVq1a0bdv3+L2BQsWxKxZsza57TwAAAAAAAAAVKbstAsoTXZ2dgwbNiwGDRoUZ511VvTu3Ttyc3NjwoQJMXfu3LjiiiuiRYsWxeePGDEiRo8eHTfddFP069evuH3JkiXx+9//vvjrtWvXxtKlS+PKK68sbrv88sujUaNGW+eDAQAAAAAAALBdqJZhe0RE165d44EHHohbbrklxo8fH2vXro22bdvGpZdeGr169SpTH4WFhTF69OjNtv3sZz8TtgMAAAAAAACQSLUN2yMiOnXqFHffffcWzxs+fHgMHz48o71FixYxc+bMqigNAAAAAAAAgB1YtXxnOwAAAAAAAABUZ8J2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABIKDvtAgAAAABgR9TtqPVVfIfFVdr75InW8QAAsGPzJ2IAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJBQdtoFAAAAAABsbd2OWl/Fd1hcxf1HTJ5oLRUAQJr8aQwAAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACSUnXYBAAAAAADseLodtb6K77C4SnufPNFaNgDY0fnTAAAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAP8fe/cen3P9/3H8ec1Gm42GEcYmlWkoizk051OhcthGOSanmPgR8o0UOueUKadCUdhkVAg5tCHD5CwlmzmtYQ47mdn1+8Nt17d9N4dL2z5c1+N+u3X7fve53taz99vnc13X5/V5v98AAACAlSi2AwAAAAAAAAAAAABgJYrtAAAAAAAAAAAAAABYiWI7AAAAAAAAAAAAAABWotgOAAAAAAAAAAAAAICVKLYDAAAAAAAAAAAAAGAliu0AAAAAAAAAAAAAAFiJYjsAAAAAAAAAAAAAAFai2A4AAAAAAAAAAAAAgJUotgMAAAAAAAAAAAAAYCWK7QAAAAAAAAAAAAAAWIliOwAAAAAAAAAAAAAAVqLYDgAAAAAAAAAAAACAlSi2AwAAAAAAAAAAAABgJUejAwAAAAAAAAAAgMIV0DSrgP8N5wv490tRm5lPCAAwFu9EAAAAAAAAAAAAAABYiWI7AAAAAAAAAAAAAABWotgOAAAAAAAAAAAAAICVKLYDAAAAAAAAAAAAAGAliu0AAAAAAAAAAAAAAFiJYjsAAAAAAAAAAAAAAFai2A4AAAAAAAAAAAAAgJUotgMAAAAAAAAAAAAAYCWK7QAAAAAAAAAAAAAAWIliOwAAAAAAAAAAAAAAVqLYDgAAAAAAAAAAAACAlSi2AwAAAAAAAAAAAABgJYrtAAAAAAAAAAAAAABYiWI7AAAAAAAAAAAAAABWotgOAAAAAAAAAAAAAICVKLYDAAAAAAAAAAAAAGAliu0AAAAAAAAAAAAAAFiJYjsAAAAAAAAAAAAAAFZyNDrArezbt08zZszQnj17lJmZqccee0y9e/dW27Zt7/h3ZGRkaM6cOVq1apXOnDmjkiVLqlmzZho2bJhKly5dgOkBAAAAAAAAAAAAALbqni22//rrr+rbt6+KFi2qdu3aqXjx4lq3bp3+7//+T2fPnlWfPn1u+zuysrL06quvKioqSk8++aRat26tuLg4hYWFafv27Vq2bJlKlSpVCP81AAAAAAAAAAAAAABbck8W2zMzMzVu3DiZTCYtXrxY1atXlyQNHjxYgYGBmjJlitq0aaOKFSve8vesWLFCUVFRat++vT755BOZTCZJ0rfffqu3335b06ZN04QJEwr8vwcAAAAAAAAAAAAAYFvuyT3bf/31V504cULt27e3FNolyc3NTQMHDtS1a9e0YsWK2/6esLAwSdLw4cMthXZJ6tq1qypVqqTvv/9e6enp+f8fAAAAAAAAAAAAAACwafdksT06OlqSFBAQkOu17GM7d+685e+4evWq9u7dqypVquSaAW8ymdSwYUOlpqbqwIED+ZQaAAAAAAAAAAAAAGAv7slie2xsrCTJy8sr12seHh5ycXFRXFzcLX/HiRMnlJWVJW9v7zxfzz6e/e8CAAAAAAAAAAAAAOBO3ZN7ticnJ0u6sWx8XlxdXXXlypVb/o7s111dXW/6O/7577qZkiVLysGh4J5JOLi3wH417gD9bzzGwFj0v/EYA2PR/8ZjDIxF/xuPMTAW/W88xsBY9L/xGANj0f/GYwyMRf8bz/eJ8wX8byjY339wb+kC/f0F7X7vf4kxuD3OgVu53/tfujfG4J4stt9LLl26ZHSEf8Xd3V1JSUlGx7Bb9L/xGANj0f/GYwyMRf8bjzEwFv1vPMbAWPS/8RgDY9H/xmMMjEX/G48xMBb9b/sYX+MxBsai/41X0GPg7u5+2zb35DLy2bPObzZ7PTk5+aaz3rNlv36zmevZx2828x0AAAAAAAAAAAAAgJu5J4vt2fup57Uve2JiolJTU/Pcz/2fKlWqJAcHh5vuyZ59/GZ7ugMAAAAAAAAAAAAAcDP35DLydevW1ezZsxUVFaV27drleC0qKsrS5lYeeOAB1apVS7/99ptOnTqlihUrWl4zm83atm2bXFxcVKNGjfz/DwAAAAAAAAAAALiFqM0FOx+SpfwBoODdkzPbGzRooEqVKumHH37Q4cOHLcevXLmiWbNmycnJSR06dLAc//vvv3Xs2LFcy84HBwdLkqZMmSKz2Ww5vmTJEsXHx+u5557TAw88ULD/MQAAAAAAAAAAAAAAm3NPzmx3dHTUpEmT1LdvX3Xr1k3t2rVT8eLFtW7dOp06dUqjR4+Wp6enpf2UKVO0YsUKvf/+++rUqZPleMeOHbV69Wr98MMPOnnypOrWrasTJ05o3bp18vT01LBhwwz4rwMAAAAAAAAAAAAA3O/uyZntklS/fn1988038vPz0+rVq/Xtt9+qdOnSmjp1qvr06XNHv8PBwUGff/65hgwZogsXLmjBggWKiYlRYGCgli5dqlKlShXwfwUAAAAAAAAAAAAAwBbdkzPbs9WqVUvz5s27bbsPPvhAH3zwQZ6vFS1aVCEhIQoJCcnveAAAAAAAAAAAAAAAO3XPzmwHAAAAAAAAAAAAAOBeRbEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKzkaHQAAAAAAAAAAAAAoDBFbS7Y+aju7u5KSkoq0H8HAOMxsx0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALCSo9EBAAAAAAAAAAAAANiXqM0FOyfY3d1dSUlJBfrvAJjZDgAAAAAAAAAAAACAlSi2AwAAAAAAAAAAAABgJYrtAAAAAAAAAAAAAABYiWI7AAAAAAAAAAAAAABWotgOAAAAAAAAAAAAAICVKLYDAAAAAAAAAAAAAGAliu0AAAAAAAAAAAAAAFiJYjsAAAAAAAAAAAAAAFai2A4AAAAAAAAAAAAAgJUotgMAAAAAAAAAAAAAYCWK7QAAAAAAAAAAAAAAWIliOwAAAAAAAAAAAAAAVqLYDgAAAAAAAAAAAACAlSi2AwAAAAAAAAAAAABgJYrtAAAAAAAAAAAAAABYiWI7AAAAAAAAAAAAAABWotgOAAAAAAAAAAAAAICVKLYDAAAAAAAAAAAAAGAliu0AAAAAAAAAAAAAAFiJYjsAAAAAAAAAAAAAAFai2A4AAAAAAAAAAAAAgJUcjQ6Ql+TkZM2YMUPr1q1TYmKiypYtqzZt2igkJETFixe/49/z9ddf69ChQzpw4ICOHTum69ev66uvvlK9evUKMD0AAAAAAAAAAAAAwNbdc8X21NRUde/eXYcPH1ZAQIDatWunw4cP68svv9TOnTu1ePFiFStW7I5+16RJkyRJHh4eKlWqlBITEwsyOgAAAAAAAAAAAADATtxzy8jPmzdPhw8fVr9+/fTFF1/o9ddf1xdffKF+/fpp//79WrBgwR3/rtmzZysqKkpRUVFq3rx5wYUGAAAAAAAAAAAAANiVe6rYbjabFRYWJhcXFw0aNCjHa4MGDZKLi4vCwsLu+Pc1bdpUHh4e+R0TAAAAAAAAAAAAAGDn7qlie2xsrP7++2/5+fnJxcUlx2suLi7y8/NTfHy8zpw5Y1BCAAAAAAAAAAAAAADusWJ7XFycJMnb2zvP17OPx8bGFk4gAAAAAAAAAAAAAADy4Gh0gH+6cuWKJMnV1TXP17OPJycnF1qmkiVLysHhnnomwWru7u5GR7Br9L/xGANj0f/GYwyMRf8bjzEwFv1vPMbAWPS/8RgDY9H/xmMMjEX/G48xMBb9bzzGwFj0v/EYg1s5b3SAf+1eGN8CKbZ/8MEHysjIuOP2PXv2vOlsdqNdunTJ6Aj/iru7u5KSkoyOYbfof+MxBsai/43HGBiL/jceY2As+t94jIGx6H/jMQbGov+NxxgYi/43HmNgLPrfeIyBseh/4zEGtq+gx/dOivkFUmxfunSpUlNT77h9mzZt5O3tLTc3N0k3n7meffxmM98BAAAAAAAAAAAAACgMBVJs37Nnz139OS8vL0k335M9+/i9OgseAAAAAAAAAAAAAGAf7qnNyL29vVW2bFnFxMTkmhmfmpqqmJgYeXp6qnz58gYlBAAAAAAAAAAAAADgHiu2m0wmBQUFKTU1VZ999lmO1z777DOlpqYqODg4x/G0tDQdO3ZMp0+fLsyoAAAAAAAAAAAAAAA7ViDLyP8bffv21c8//6y5c+fq8OHDevzxx3Xo0CFFRUWpZs2a6tWrV472+/btU8+ePeXv76+vv/46x2tz5szRX3/9Jem/S9vPmTNHK1askCS1bNlSLVu2LIT/KgAAAAAAAAAAAACALbnniu0uLi5atGiRZsyYoXXr1mnHjh3y8PBQnz59NHjwYD3wwAN3/LsiIyMVHR2d41hUVJTl/1esWJFiOwAAAAAAAAAAAADAavdcsV2S3Nzc9J///Ef/+c9/btu2Xr16+v333/N87X9nugMAAAAAAAAAAAAAkB/uqT3bAQAAAAAAAAAAAAC4H1BsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACs5Gh0AAAAAAAAAAAAAABA4YnaXLBzst3d3ZWUlFSg/457ATPbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK5nMZrPZ6BAAAAAAAAAAAAAAANxPmNkOAAAAAAAAAAAAAICVKLYDAAAAAAAAAAAAAGAliu0AAAAAAAAAAAAAAFiJYjsAAAAAAAAAAAAAAFai2A4AAAAAAAAAAAAAgJUotgMAAAAAAAAAAAAAYCVHowMA96PTp0//699RokQJubq65kMaAPaI6xAAAACMsnPnzn/9OypWrKgKFSrkQxr7xPcBY3EOAAAAe8Zn0ZxMZrPZbHQIWK969er/+ncMHjxYISEh+ZDG/vj4+MhkMv2r30H//ztjxoz517+jZcuWatGiRT6ksT89e/b817+jU6dO6tChw78PY6e4DhkrP64dvXr1ypdzyV4xBsbis6jxGANj0f/GYwyMxWdR4zEGxqL/jcd9IWNxX8h4fCc2Fv1vvNDQ0H/9O+rVq6e6devmQxr7w2ehnJjZfp8ym82qUKGCKlaseFd/Pj+ewLV31apVu6sbPGazWREREfkfyM6sWLHiX/15k8mkihUr8qXqLkVHR/+rP28ymeTv759PaewX1yHjnDp1Sm5ubnJzc7urP3/mzBldvnw5n1PZF8bAWHwWNR5jYCz633iMgfHq1q17V5/pzWazZs6cWQCJ7A/fB4zFOWAs7gsZi/tCxuM7sbHof+OFhobKZDLpbucTZxeKKbbfPT6L/hfF9vtYp06d7vqpDx8fn3xOY39atmx51/1vaxcSo9zt039ms1ktW7YsgET2JSQkhGuQwbgOGatXr16cAwZjDIzFZ1HjMQbGov+NxxgYy9/f/677n0Jj/uD7gLE4B4zHfSFjcV/IeHwnNhb9b7wOHTqoY8eOVv85s9msXr16FUAi+8Jn0f+i2A7chTJlyqh48eKG/Xnc4ObmdtczWYD7HdchAAAAGOWJJ57QQw89ZNifB98HjMY5cG/gvhAA2LeKFSuySoZB+CyaE3u236cyMjJUpEgRFSlSxJA/DxhtyZIlqlGjhmrUqGHIn7d3kZGR8vLyUuXKlQ3584DR/vrrL7m7u8vd3d2QPw/GwGh8FjUeY2As+t94jAEA2DfuCxmL+0LG4zuxseh/402ePFkNGzZUgwYNDPnzwD9RbAcAAAAAAAAAAAAAwEoORgcAAAAAAAAAAFvz888/68iRI0bHAAAAQAFiZrsdSU5O1uXLl1WhQgWjo9i8w4cPKyYmRqmpqapYsaIaN24sV1dXo2PZpZCQEDVs2FAvvfSS0VFsWnp6un777TfFxsbq8uXLcnBwUOnSpVWjRg09+uijRsezaefPn9fSpUt14cIFNWzYUM2bN5ckHThwQFOnTtWhQ4dUtGhR1a9fX0OGDJGnp6fBie3X8ePHde7cOdWtW9foKDZj1apVatCggTw8PIyOgn84evSovv76ax04cEDp6emqWLGi2rZtq44dO8pkMhkdzy4wBoXj888/V0BAgGrWrGl0FLvFGNxfwsLCFBMTo/fff9/oKDYjNTVVV65cUbly5XIcj4yM1Pz583O9D/Tr108PPPCAQWntk4+Pj4KDgzVhwgSjo9ikhISEXH//cW/p2LGjWrVqpUGDBhkdxeadPHlSO3bsyPPeXMOGDVW0aFGjI9oc7kkANxw7dkxxcXF69NFHValSJUlSVlaWli1bpujoaDk6Oqpp06Zq27atwUkLDsX2+9zx48f14YcfWv7CBgQE6LXXXpO3t3eutqGhoZo5c6YOHz5c+EFtUGhoqOrVq5ejaJKWlqbRo0dr/fr1kiSz2SyTyaSSJUvqgw8+UNOmTQ1Ka798fHwUFBSkiRMnGh3FJl26dElTp07VypUrlZ6enmebRx55RCNGjODvfwE4d+6cOnXqpMTERMv15rXXXlOrVq0UFBSktLQ0lSxZUikpKcrMzFSZMmW0fPlybkYYZMyYMYqIiOB9OB/5+PjI0dFRTZo0UWBgoJo0aSIHBxZuKiwTJkzQmjVrtHXrVku/r169WqNHj9a1a9dytDWZTGrSpIk+++wzxigfMQbG8vHxkclkUrVq1RQYGKjnn39eJUqUMDqWXWEM7i98Fsp/Y8aMUWRkpKKioizHFixYoA8//FBms1lFixZV8eLFlZSUJJPJJF9fX3399ddydnY2MLXt2Ldv323bBAcHq0WLFhowYIDlWK1atQoyll3x8fHRo48+ankPYO/jew/35QpefHy8JkyYkOO9IFv2vaIHH3xQISEh6tatmwEJbRf3JIzn6+urRo0aKTAwUM2aNVORIkWMjmR33nrrLYWFhUm6cd9h8ODBGjx4sIYMGWKpk2W/9uyzz2rKlClGRS1QFNvvYwkJCerYsaMuXLigBx54QI6OjkpOTpazs7MmTpyo9u3b52hPsT1/+fj4KCQkRCEhIZZjo0aN0qpVq1SlShW98MILcnd312+//aaVK1fKyclJERERqlKlioGpbcvbb7992zZLlixR1apVLQ9FmEwmjR8/voCT2YdLly6pa9euOn78uB588EFVqFBBp0+f1sWLF1WtWjXVrVtXv//+u2JiYpSVlaVhw4bluMGAf+/jjz/WF198oR49eqhZs2bauHGjwsPD1bBhQx07dkzTp0+Xj4+PMjIyNGPGDM2dO1cvvfSS3nrrLaOj2yVuMOe/7CJL9g0EDw8PdezYUYGBgZYnaVFwnnvuOVWpUkWffvqpJOnixYtq3ry5HBwcNGLECDVv3lwlSpTQH3/8oRkzZigqKkojR45Unz59DE5uOxgDY/n4+MjZ2VlpaWkymUwqWrSo5YG3evXqGR3PLjAG9xc+C+W/Nm3aqEaNGpo8ebKkG/eJWrZsKXd3d02aNEmNGjWSyWTShQsXNGXKFIWHh2vgwIEaNmyYscFtRPZnUWtxDuQfHx8fSTfu9Tg5OalFixYKCgpSw4YNDU5mH/r163fbNpGRkSpfvrweeeQRSTfGas6cOQUdzW6cPXtWgYGBOnfunKpXry5PT0+dPHlShw8flo+Pj55//nkdPXpUmzZt0uXLlxUcHKx33nnH6Ng2g3sSxvvne3Hp0qXVoUMHBQYG5jkZFflv/fr1GjJkiKpWrapGjRpp+/btOnr0qEaNGqUpU6Zo2LBhevrpp5WQkKCpU6fq999/19SpU/XMM88YHT3fORodAHdv1qxZunDhgl5//XX16dNHJpNJa9as0bvvvqtRo0YpLS1NQUFBRse0G/Hx8fr+++/15JNPasGCBZal2bp06aJmzZrptdde0/z581k6LB8tWbLE8oHmZkwmk44dO6Zjx45ZfqbYnj9CQ0N1/Phxy0377LFYsGCBPvroI7322msaO3asTp06pVGjRmnatGny8/NjCe18tHnzZj311FN68803JUkNGzbUwYMHtWnTJs2ZM8dy46Fo0aIaMWKEduzYocjISCMjA/luwIABevzxxxUWFqatW7dq9uzZmjNnjvz9/RUUFKTWrVuzXF4BOXXqlBo1amT5+ZdfflFqaqo++eSTHA991qpVS5999pk6deqkFStWUOjNR4yB8V555RU1a9ZMYWFh+vHHH/XDDz/oxx9/lKenpwIDA9WxY0eVLVvW6Jg2jTEwTkREhFXt4+LiCiaIHUtISFDr1q0tP0dFRSkzM1MTJ05U48aNLcdLlSqlSZMm6ejRo1qzZg3F9nzk7Oysli1b5jmTzmw2KyIiQl5eXvLz8zMgnX3IXtXk+++/15o1a7R27VqVL19enTt3VufOnfXQQw8ZHdFmRUZG3tF9uTNnzujMmTOWn5F/pk+frvPnz2v69Olq06aN5fi6des0bNgwy2qrKSkp+s9//qNly5apUaNGatmypYGpbQv3JIzXpEkTSTeuSfPmzdMXX3yhOnXqqHPnznr22WdVrFgxgxParsWLF6tMmTIKCwuTi4uLrl69qmeeeUZTpkzRkCFD9Morr0i68VDEE088oWbNmikiIoJiO+4tkZGRqlu3rvr27Ws51rZtW9WuXVv9+/fX+PHjdf36dXXt2tXAlPZjx44dkqRhw4bl2gOtdevWeuqpp/Trr78aEc1mOTs7y2QyadiwYZai4j+ZzWb16tVLTZs25aZyAfj555/19NNPW940pRtfml5++WVFRUVp1qxZatGihSpWrKhZs2apTZs2mj9/PsX2fHTmzBnLB8pstWvX1m+//ZbnzRw/Pz8tXry4sOLZvOrVqxsdAZIcHR3VunVrtW7dWgkJCQoPD9d3332nHTt2KDo6WhMnTtRzzz2nwMDAPN8rkH/Onj0rk8mU57YhTk5OatCggZYsWVL4wewIY2AMX19f+fr6asyYMVqzZo2WL1+uXbt2adq0aZoxY0aOZQ1ZVrJgMAbGeOONN6wqmmTP+kL+cXJyUkZGhuXn8+fPS9JNv3M99dRTWrRoUaFkswfDhw9XaGioTpw4oXfffVdVq1bN1SYiIkL+/v4soV2AKleurJCQEI0aNUo//fSTwsPDFR0drdDQUH322Wd6+umnFRQUpGbNmsnRkVvh+cnDw0MpKSl6/fXXc92bkG5c91u2bKl27dpp+PDhBiS0fVFRUWrRokWOQrt04150ixYttGDBAnXu3FnFixfXxx9/rP3792vx4sUU2/MR9ySMV6NGDYWEhOjvv//Wd999p+XLl2vnzp3atWuX3n33XbVv316BgYHy9fU1OqrNOX78uJo1ayYXFxdJUrFixdS4cWMtW7Ys18rbDz74oJo2baqdO3caEbXA8QnjPpaQkJDrjVSSypcvr6+//lq9evXSO++8o6ysLL300ksGJLQv2V9qb3bRfvzxx7Vs2bLCjGTzVq1apTfeeEMfffSRBg4cqIEDB+b5xcnDw0P+/v4GJLRtiYmJevbZZ/N8zcfHJ8dNHDc3NzVv3lwbN24srHh2oVixYjlurkmy/Jyenq7ixYvneC09PZ29i/KR2WyWs7PzHc+USExMVEpKSgGnsm/lypWz7A21fft2hYeHa8OGDVq0aJEWL14sX19fBQUFqUuXLkZHtQlVqlTRb7/9Zvm5VKlSkm5sM+Lq6pqr/eXLl9kjNp8xBveWYsWKqUOHDurQoYNOnDih8PBwRUREaNOmTdq8ebNKly6tTp06cbO5ADEGhcvJyUlly5a94/fVtWvXsnx2Pnv00UctD/5LsnwuPXv2rB5++OFc7c+ePZvn+wPuTv/+/dW0aVO98cYb6tSpk0JCQtS3b18eKjFI0aJF9dxzz+m5557TyZMnLe8Bv/zyiyIjI1WqVCm98MILCgwMzPP8gPV+/PFHvfPOO5o4caL279+vN998M89rjIuLiypWrGhAQtuXlJQkLy+vPF+rXLmytmzZYvm5aNGiatKkiVavXl1Y8ewO9ySMVbZsWUuNIDo6WmFhYVq/fr2+/fZbLVmyRD4+PgoMDNTzzz8vNzc3o+PahAsXLljuQ2QrXbq0pBt1yv9VoUIFXbx4sTCiFToe6b6Pubm55SqyZHvwwQe1cOFCPfbYY5o4cSIzGQtB9ofJm32pKlKkCLMo8lmlSpW0aNEiDR8+XHPnzlVgYCA3bwpRyZIlFR8fn+dr8fHxuVZ4KF26tK5cuVIY0eyGl5eXIiMjdf36dUlSZmamIiMj5ejomOvBhoyMDEVGRrJnVD6qWLGiHnroIa1Zs+aO/mnVqpXRke1KgwYNNHnyZEVGRurNN9/UY489pgMHDujtt982OprNaN++vfbs2WO5WdOiRQsVL15coaGhudoePXpUP/30k5544onCjmnTGIN7V+XKlTV8+HBt3rxZn332mZo1a6aLFy9q7ty5RkezG4xBwXvssceUlpam/v3739E/1apVMzqyzenUqZOOHDmiL774QtKN94EyZcroww8/1NWrV3O03bZtm9avX8+D6Pnsscce07Jly9S3b19Nnz5dXbp0sWxjB+N4enpq2LBh2rRpk2bPnq2WLVvq0qVL+vLLL3PNtMPdK1GihCZPnqxp06Zpy5YtevbZZ7Vp0yajY9kVDw8P/f7773m+9vvvv+cqKLq6uiotLa0wotk97kkYy9/fXx9//LGioqI0btw4Va9eXYcPH8611Q7+nRIlSujSpUs5jmVvL5JXnezq1au5aga2gpnt97FKlSpp3759N309u+Deq1cvTZo0iac2C8DPP/+sU6dOSZL+/vtvSTeKjHktLXz27Fm5u7sXaj57YDKZ1KdPHzVp0kRvvPGGgoKC1LdvXw0ePFhOTk5Gx7Np9erV09q1a7V58+Ycy9Vu2bJFGzZsyPXB5e+//+YcyGeBgYEaO3asunXrpvr162v79u06ceKExowZow8++EAZGRny9/fXhQsXNHv2bJ0+fVr9+/c3OrbN8PX11YYNG5SammpZLgn3nhIlSqhHjx7q0aOHDhw4oOXLlxsdyWZ0795dq1ev1uuvv67IyEi1adNGISEh+vjjj/X777+rWbNmcnNz07Fjx/T9998rMzNTr776qtGxbQpjcO9zcHBQ8+bN1bx5c50/f14rVqwwOpLdYQwKjq+vrw4dOqQzZ87kOXMFBa9z587asGGDPvnkE23evFnPPPOMXnzxRc2cOVOtWrVSw4YNLe8D27dv1wMPPKDXXnvN6Ng2x9HRUUOGDFHz5s01evRodezYUYMGDVK/fv2Mjmb3TCaTmjRpoiZNmujChQuKiIjg+0ABaNOmjerWravx48dr0KBBat++vcaOHauSJUsaHc3mNWrUSGFhYVq8eLG6detmOb548WJt3bo114qUZ86cUZkyZQo7pl3jnoSxXF1d1a1bN3Xr1k1HjhxRWFiYfvjhB6Nj2YyKFSvmmozXrVu3m+7Jfvr0aXl4eBRGtEJHsf0+1qBBA82ePVvx8fE3namYXXDv3bu3jhw5wlJW+ezw4cO5ZlJv2LAhz2L7b7/9pscee6ywotmdqlWraunSpZo1a5Y+++wz/fzzz3r33XeNjmXTBg0apI0bN+rVV19VzZo15enpqZMnT2r//v1ydHTUoEGDcrT/9ddf2Rsnn3Xs2FFbtmzR+vXrLcsI9+rVSz179tQff/yhiRMnWq77ZrNZVatW5YZPPvL19dW6det06NAh1alT57btzWazzGZzISTDzdSoUUM1atQwOobNcHJy0hdffKExY8ZoxYoVioiIkHTj7/o/PyOZzWa5u7tr4sSJql27toGJbQ9jcH8pXbq0+vbta3QMu8YY5K86deooKipKsbGxd1Rs9/PzK4RU9sVkMunTTz/VJ598om+++Ua7du2SdOO6//fff2vlypWWz59Vq1bV+++/n+e+4sgfvr6++u677zR9+nR9+umnWrduHffh7iGlSpVSnz591KdPH6Oj2KRSpUppxowZWrlypd577z21a9dOb731ltGxbN7gwYO1YcMGTZo0SZ9//rkqVqyoU6dO6fz583JxcdGQIUMsba9fv65t27apXr16Bia2b9yTMJaPj4/GjRun0aNHGx3FZtSoUUOrVq3KMZO9VKlSuZaWl26syBoTE5Nj0p4tMZm563vfOnLkiMaPH6/nn38+x5Nrebl06ZJCQkJ06tQp9kzOJ9kz2v+Xs7NzrovJ4cOH9d5771n2hkLBOnLkiEaPHq0///xTWVlZCgwM1MSJE42OZZN+++03jRs3Tn/88YflWKVKlTR+/HgFBARYjqWmpmrDhg167LHH5OPjY0RUm7Zv3z6dPHlSjzzyiOWhHrPZrPDwcEVGRiojI0N+fn566aWX2KMxH124cEF//vmnqlatatmPCIWrR48e6ty5szp06GB0FLu3d+9e/fjjjzp06JDOnz+vrKwsubm5qUqVKqpfv77atGnD9aeAMQaFb8yYMWrZsqVatGhhdBS7xRgA/5WQkKC1a9da3gfMZrNcXV0t7wP+/v5sbVeI9uzZozfeeENxcXEKCgrinkQB8fHxUUhIiEJCQoyOgn9ISEjQ2LFjFRkZKUmcAwUsPj5ekyZN0tatW5WZmakiRYqoTp06GjNmTI57cFevXtWBAwdUoUIFVqTJJ9yTMB7vA8Y6f/68zpw5o+rVq6tIkSK3bHvkyBEtXLhQL7zwgurXr19ICQsPxXYANunatWuaPXu2Dh8+rKefflovvfSS0ZFsWnx8vBITE+Xu7q4qVaoYHQcAAAAAAENdv35dqampKlq0qIoVK2Z0HKDQrVixQocPH9aTTz6ptm3bGh3H5mVkZCgpKUklS5a02T2Rgf916tQplShRQm5ubkZHgZ2j2A4AAAAAAAAAAAAAgJXYs91GZGRkaP/+/YqLi9OVK1ckSW5ubvLy8lLNmjVVtGhRgxPavvj4eMXGxurKlSsymUwqXbq0Hn/8cZbrBGCYlJQUpaeny93dnSUjDXL16lU5ODjIycnJ6Ch2ISEhwfJeLN34LOTt7a1y5coZnMy2Xbt2TampqSpZsmSO43v27NGhQ4dUtGhR+fv7y8vLy6CE9ikmJkYHDhxQenq6PD091ahRI572N0BISIgaNmzIKkuApOPHj+vcuXOqW7eu0VGAfLFq1So1aNBAHh4eRkfBLfz888+qWLEiW9rBLp09e1a///67ihYtqlq1aql48eJGR7IbCQkJOnDggK5evaqKFSuqZs2a3JuDTTt79qyio6PzrFHWrVvX5revoNh+n0tKStK0adP0/fffKy0tTdKNfXolyWQySbqxh/jzzz+voUOHyt3d3bCstujatWtasGCBlixZotOnT+d63cHBQY0aNdKwYcP4UF+AtmzZohMnTujRRx+17PeRkpKiWbNmKTo6Wo6OjmrSpIl69+7NgycFIDExUXv27LHsCfW/xZZs0dHRio6OZg+dfHT69GmVKFEi10M9mzZt0rRp03T06FFJN94H2rZtq5EjR950fHB3zp8/ry+//FInTpzQY489pt69e8vNzU1Hjx7VuHHjtH//fplMJjVo0EBvvfWWKleubHRkm5ORkaEFCxYoPDxc8fHxebbx9PRUcHCwevXqxftAPps5c6bmzZun9PR0Va9eXdOmTZOnp6dGjBihtWvXWtqZTCa9/PLLGjlypIFpbc/atWu1fft2jR8/3nLjJiEhQUOHDtXevXsl3fhuYDKZ5Orqqrffflvt2rUzMrLd2bBhA9/BCsFPP/2knTt3qkiRIgoICFCjRo3ybLdixQqtWLFCX331VSEnhCTNmTNHEREROnz4sNFRbMrVq1e1ePFiy3ffgIAAde7cOc+HPRcuXKivvvpKP//8swFJbc+oUaMs9xsCAwPVpEkTCin3oMGDBys4OFgTJkwwOorN4r6QsSIiIjRz5kxduHBBDRs21Ntvv63SpUvrk08+0YIFC3T9+nVJ0gMPPKDXX39d3bp1Mzix7YiOjtaePXvUr18/y/U/OTlZb731ltauXat/Lirt6emp9957j4cOC8ixY8cUFxenRx99VJUqVZIkZWVladmyZZbPSE2bNmVLiwJw4sQJTZgwQVu3bpUk/e9i6tl1yoCAAI0dO9ZmJ2KwjPx97MKFC+ratatOnDihSpUqqWHDhvL29rYUXZKTkxUbG6tt27YpPj5elStX1pIlS1SqVCmDk9uGq1evqk+fPoqJiZHZbFbJkiV16dIlSVLVqlVVqVIl/fHHHzp16pQcHR317rvv6oUXXjA4tW3JzMzUwIEDtXXrVsuN5M6dO2vChAnq3r27YmJiLG1NJpPq1KmjhQsX8uU3H3355ZeaOnWqMjMzJUnFihXTwIEDNWDAAMsbabbQ0FDNnDmTm2v5qHr16goJCdHgwYMtxyIiIvSf//xHZrNZlStXlru7u/744w+lpKTIx8dHy5Yto9iYTy5duqSOHTvqzJkzlg+Svr6+mjt3rjp27KikpCRVrVpViYmJOnfunB566CGtWrVKJUqUMDi57UhNTVXv3r21b98+ubi4yM/PT97e3pan9VNSUhQbG6uYmBilpaWpVq1amj9/vlxcXAxObhs2btyoQYMGqXjx4nrsscd09OhReXl5qVOnTpo0aZJatmypevXq6fz581q6dKkuXryoTz75hGJvPurZs6cyMzP1zTffSLrxpbZz5846dOiQnnjiCTVr1kxubm76888/FRERoYyMDC1cuFB16tQxOLltePvtt2/bZsmSJapatarlpprJZNL48eMLOJn9yMrK0uDBg7V58+YcD503aNBAH330kcqUKZOjPZ9HjTVmzBiK7fksIyND3bt31/79+3OcA4888oimTZumqlWr5mjPOZC/fHx8ZDKZLPcjPDw81LFjRwUGBlpu9KNg7du377ZtgoOD1aJFCw0YMMByrFatWgUZy65wX8hYu3btUvfu3S3XoMTERNWvX18dOnTQ6NGj5evrq7p16+rChQv66aeflJGRoblz5yogIMDo6DahX79+On/+vL777jvLsVdeeUVbt25VhQoV9PTTT1u+j0VGRqpYsWJaunSpqlWrZmBq2/PWW28pLCxM0o3PQYMHD9bgwYM1ZMgQrV+/3tLOZDLp2Wef1ZQpU4yKanPi4+MVFBSkixcvyt/fXwEBAXnWKCMjI7Vz5065u7tr2bJlNvk5iZnt97Fp06YpPj5eb7/9trp27XrLtt9++60mTJigadOm8SRnPpk9e7Z2796tbt26adiwYXJzc1NycrKmTZumZcuWaeLEifLz89Pu3bs1duxYvfnmm6pWrRoz3PPRqlWrFBUVJX9/f7Vq1Uq//PKLli9frpIlS+rPP//UtGnTFBAQoISEBL3//vvaunWrli9frqCgIKOj24SoqCh99NFHcnNz07PPPisnJyf99NNPmj59uvbs2aMZM2ZQ1C1gZrM5x9OCqampeu+99+Tm5qZp06apQYMGkqS0tDSNHTtWq1ev1uLFi/Xyyy8bFdmmfP311zp9+rReffVVPfPMM9q8ebOmTp2qUaNGyc3NTUuXLtVDDz0kSZoxY4Zmzpypr776iqf481FoaKj27dunfv36adCgQXJ2ds6zXVpammUG9syZM5ldnU8WLVqkEiVKaOXKlSpfvrxOnz6tDh06aObMmXr55Zc1evRoS9suXbqoXbt2Wrp0KcX2fHTs2DG1bt3a8vOvv/6qQ4cO5Tl7q3v37goKCtLs2bMptueTJUuWWIosN2MymXTs2DEdO3bM8jPF9vyzdOlSbdq0STVq1NDLL78sR0dHhYeHKzIyUl27dtXChQtVsWJFo2MCBWb+/Pnat2+fmjVrpgEDBljOgWXLlqlbt2764osv5Ovra3RMmzZgwAA9/vjjCgsL09atWzV79mzNmTNH/v7+CgoKUuvWrfleXICCg4NzFXT/l8lk0saNG7Vx40bLMYq9+YP7Qsb78ssv5ezsrG+++UbVq1fXwYMH1a1bN504cULt27fXxx9/bDlHXn75ZQUHB+urr76i2J5Pjhw5ombNmll+3rNnj7Zu3aoWLVpo6tSpOf7+R0dHq0+fPpo5c6Y+/fRTI+LapPXr12vZsmWqWrWqGjVqpO3btys0NFQuLi7avHmzRo4cqaeffloJCQmaOnWq1qxZo9atW+uZZ54xOrpNmDZtmlJSUjRnzhw1btz4pu369++vLVu2KCQkRNOmTdPkyZMLMWXhoNh+H9u0aZNatWp120K7JL344ovavn27Nm3aVAjJ7MOPP/6oJ598UuPGjbMcc3V11dixY3XgwAFNmzZNX331lZ566iktWLBAbdu21dy5c23yQmKUsLAwVaxYUQsWLJCDg4O6d++udu3aaf78+Xrrrbcsb5qurq4KDQ1V06ZN9eOPP1JszycLFy6Us7OzwsLC5O3tLUn6v//7P40fP14//vijBg4cqM8//1zFihUzNqgd2bZtmy5fvqxx48ZZCu3SjWXk33vvPe3evVtr166l2J5P1q9fryeffFJDhw6VJFWrVk1RUVHaunWrPv/8c0uhXZKGDBmi1atXa9OmTRTb89HatWsVEBCgESNG3LKds7OzXn/9dR0+fFhr1qyh2J5P/vzzT7Vq1cqy71aFChXUsmVLrVixItfShOXLl1erVq34LJrPLl++nGO1jMOHD8tkMmngwIG52latWlVt2rTRhg0bCjOiTXN2dpbJZLrpllFms1m9evVS06ZN1adPHwMS2r4VK1aoXLlyWrRokR544AFJUps2bbR06VJNnDhRPXr00MKFC21y5sS9oHr16kZHsHurV6+Wt7e3QkNDVaRIEUlSjRo11KxZM/3f//2f+vTpo3nz5qlmzZoGJ7Vdjo6Oat26tVq3bq2EhASFh4fru+++044dOxQdHa2JEyfqueeeU2BgIJMvCoizs7NatmxpOQf+yWw2KyIiQl5eXvLz8zMgnW3jvpDxjhw5opYtW1rek319fdWiRQutXr1a8+bNy/EwSvXq1dWiRQv9+uuvRsW1ORcvXsyxZdTevXtlMpn0+uuv53rQxN/fX61bt9a2bdsKO6ZNW7x4scqUKaOwsDC5uLjo6tWreuaZZzRlyhQNGTJEr7zyiqQbq9Fkr/4WERFBsT2fbNu2TW3btr1loT1bkyZN9OyzzyoyMrIQkhU+1lK+j126dMnyQeZOeHl5WZY5x793+vRp1a5dO8/Xateurf3791t+LleunFq0aKHo6OjCimcX4uPj1bhxY8uy8NlLRprN5hxPFUo39iVq3Lixfv/9dyOi2qT9+/erdevWOa5Drq6umjx5svr166dt27ZpwIABunr1qnEh7UxcXJxMJlOuv//SjaXcGjRoYJlZh3/v9OnTuZYfrFGjhiTpySefzNW+Tp06iouLK4xodiMxMVGPP/74Hbf39fVVYmJiASayL5cuXVLp0qVzHMtestnDwyNXew8PD6WmphZKNnvh4eGhkydPWn7O/kzk5uaWZ3tXV1dlZGQUSjZ7sGrVKlWvXl0fffSRoqOj5efnJ39/f8s/9erVk3RjnP55HPnnzz//VLNmzSyF9mxdunTRjBkzdO7cOfXs2VPx8fEGJbRtZrNZDzzwgLy9ve/on+xtXpB/4uLiFBAQkKvI2KRJEy1YsEBZWVl65ZVX7mipbfx75cqV0+DBg/Xzzz9r/vz5atu2rdLT07Vo0SLL8vJLly41OqZNGT58uDIzM3XixAn17dtX77//fo5/PvjgA0k3ilz/PI78wX0h450/f97y8HO27FV98lrdx9PTU8nJyYWSzR64u7vr77//tvx8/fp1SVLZsmXzbF+2bFm+E+ez48ePq1mzZpbtAosVK6bGjRsrMzNT7du3z9H2wQcfVNOmTXXgwAEjotqk1NTUm/59z4stnwMU2+9j5cuXt6p4u3Pnzlxvvrh7xYsX17lz5/J87dy5c7n2BS9fvrwuXrxYCMnsx//O5pJuvGlKN77k/q9y5crpypUrhRHNLqSkpOSYuftPI0aM0MCBA/Xrr7+qf//+Sk9PL+R09ikrK0uScu1Pmq1MmTKMRT7KzMzM9YR+9k3k7GvRP7m7u9P/+czDw8OqJSAPHjyYZxEYd+ehhx5SbGxsjmPZPx8/fjxX+7/++ivX+zb+nYYNG2rjxo1KSEiQdOOhHrPZrJ9//jlX24yMDEVFRaly5cqFHdNmVapUSYsWLdLw4cM1d+5cBQYGsixtITObzTd9uKRZs2aaMWOGzp8/r+7du+e6XuHfq1ixoh566CGtWbPmjv5p1aqV0ZFtjqOj401njNaqVUtffvmlzGazXnnlFe3Zs6eQ09m3Bg0aaPLkyYqMjNSbb76pxx57TAcOHNDbb79tdDSb0r9/f4WHhysjI0OdOnXS3Llzb7m9C/IX94WMV6ZMGZ05cybHseyfT506lav96dOnefgtH9WtW1ebNm2yPMBQs2ZNmc3mPGs2ZrOZ+kwBuHDhgkqVKpXjWPakgLz6ukKFCtRo8lHlypW1efNmZWZm3rbttWvXtGXLFpu9J0Gx/T723HPP6bffftPIkSNzvan+05kzZ/T6669r7969ev755wsxoW2rXbu21q1bl+uG2uHDh/XTTz9ZZjdmO3/+vEqWLFmYEW1eyZIllZSUlOv4zb5YJScn84EyH5UrV85ycz8vw4YN08CBA7Vjxw7169dPKSkphZjOfpw6dUo7d+7Uzp07LbMVbzZz99y5c1yH8pG7u3uuh67Kli1705nW9H/+a9WqlaKiojR16tRb3rxJT0/XlClTtG3bthz7W+Pf8fPz08aNG7Vp0yZlZmbq559/1saNG1WjRg198sknOWawbN26VZs3b861GgT+nezl4nv37q3o6GjVqFFDwcHBmjhxor7++mudPHlSly9fVkxMjAYOHKjY2FgFBgYanNq2mEwm9enTR999952cnJwUFBSkadOm6dq1a0ZHswvly5fP8+GebE2aNNGnn36qpKQk9ejR45ZtYT1fX1/FxcXZ7OyU+0GFChV09OjRm75es2ZNffnll5Kkvn37MsPdACVKlFCPHj20cuVKhYeH39FWkLDOY489pmXLlqlv376aPn26unTpwopuhYT7Qsbz9fXVhg0bLCt5HjlyROvXr1flypX1+eef52j7+++/a/369WwDk4/69eunK1euqF+/foqPj5e/v7+aNm2qcePGaePGjZaZ7gkJCRozZowOHTqUa7Y1/p0SJUrkWs3ZZDLJbDbn2EYh29WrV3OtioW7FxwcrD/++EN9+vTR7t2786zLmM1m7dq1S3369NGff/6pLl26GJC04LFn+32sf//+2rNnj77//nv98MMPqlKliry8vCxP9l+5ckVxcXE6fvy4zGazAgIC1L9/f4NT246BAwcqMjJSwcHBatWqlSpWrKiTJ09qw4YNyszMVN++fXO03717t6pVq2ZQWtvk5eWV64bZwIEDLXux/K9Tp05ZtawJbu3RRx/V9u3bb9lm2LBhkqRZs2Yxk6KAREREKCIiQpIsHySjo6PVsWPHXG2PHTuW5zJiuDuPPvporgeugoODFRwcnGf7uLg49ozNZ0OGDNGOHTs0e/ZsLVq0SH5+fnl+FoqJiVFKSop8fHwUEhJicGrbMXDgQK1Zs0aDBg2yfJktU6aM5SZnmzZtVKtWLSUlJSkmJsayfzXyj6enp0JDQzV06FD16tVLDz74oDw9PZWenq733ntP7733nqWt2WxWmzZt1KNHDwMT266qVatq6dKlmjVrlj777DP9/PPPevfdd42OZfNq1qypDRs2KD09/aY3zZo2bapPP/1Ur732mlavXl3ICW2br6+v1q1bp0OHDqlOnTq3bW82m5lxms9q166tiIgIXbly5aarPGQX3F955RWb3SPzflGjRo1cEzOQPxwdHTVkyBA1b95co0ePVseOHTVo0CD169fP6Gg2jftCxhswYIA2bNigjh07ysPDQ4mJiXJxcdH06dPVvXt3BQUFqU6dOkpKStJPP/2kzMxMmy10GcHHx0fvvvuuxo4dqzZt2ujxxx/XQw89pKSkJA0ePFhFihTRAw88oJSUFJnNZtWuXZv6TD6rWLFiri2junXrdtM92U+fPs2Kh/moe/fu+v333xUeHq7u3bvL2dlZnp6eOe7LnTx5UmlpaTKbzQoKClL37t0NTl0wKLbfx4oWLap58+bpu+++U1hYmPbt26e//vorRxsHBwc98cQTCg4OVseOHfN8mgd354knntCUKVM0fvz4HDdtXF1dNX78eDVq1MhyLDk5Wc8///xN93jH3fH19dXSpUuVmZkpR8cblzMnJyc5OTnlapuenq7du3erXbt2hR3TZjVt2lSbNm3S5s2b1bRp05u2GzZsmEwmkz7//HOuQfnsZkXDvG60xcbGav/+/erWrVtBx7IbTz/9tJYvX66MjAwVLVr0lm0TEhK0d+9evfzyy4WUzj64urrq22+/1dy5cxUeHq7IyMg8byKXLVtWvXv3Vt++feXs7GxAUtvk5eWlhQsXKjQ0VCdPntSjjz6qYcOGqUKFCpo5c6b+7//+T+vWrZN0Y6xGjRqlBg0aGJza9jz99NP6/vvv9fnnn+unn37S/v37c7xepEgR1a5dWy+++CKfgwqYg4ODBg0aZLnR/+KLL/LZp4A1b95cK1eu1IoVK/Tiiy/etF3Tpk01Y8YMhYSE3NESh7gzQUFBql27tqpUqXJH7T/44APL/snIH82bN9fSpUv1zTffaMCAATdtl11w79OnD1ur5aO6devK09PT6Bj4B19fX3333XeaPn26Pv30U61bt4734gLEfSHj+fr66tNPP9WUKVN08uRJVa9eXWPGjJGPj48++eQTjRw50vL9oEiRIurfv7+effZZg1Pblg4dOuiRRx7R1KlTtW3bthz7gWdmZio5OVkVKlRQ165d1bt379veP4J1atSooVWrVuWYyV6qVKlcS8tLN8YjJibmltcrWMdkMmnSpElq3769wsLCFB0dnWvVJQ8PDzVr1kzBwcGqV6+eQUkLnsnMY8U2IyMjQydOnLB8cXJzc1OlSpVuun8X8sfVq1cVExOjc+fOyd3dXX5+fnJxcTE6ll3IyMhQSkqK3N3db9v22LFjWrNmjZo1ayZfX99CSGf7Ll68qLVr16pKlSp39Eb53Xff6fTp08wqNUhKSoouXryokiVLytXV1eg4dicxMVHHjx/Xww8/rDJlyhgdx2bFxsYqLi4ux2chLy8veXt7GxvMTmVmZuqvv/7StWvX9Oijj3JToZDEx8frwoULysrKkpubmypXrkzfG+DatWuaPXu2Dh8+rKefflovvfSS0ZFsUmZmpk6cOKHixYurXLlyt23/119/6dy5c/L39y+EdEDhyMjIkIODg+UB9Fu5dOmSkpOTWe0KdmHPnj164403FBcXp6CgIE2cONHoSDaH+0L3vosXL2rPnj26du2annjiiTv6vIS7d+XKFR08eDDH97EqVarY7B7V94Lz58/rzJkzql69uooUKXLLtkeOHNHChQv1wgsvqH79+oWU0P6kpaXluC9nL5NeKLYDAAAAAAAAAGzK9evXlZqaqqJFizIZCQAAFBiK7QAAAAAAAIANuHr1qq5cuSIHBweVLFnytrO8kH8SEhIUGxubYzaXt7c3M0kBAABsHHu238dat26tRo0aKTAwUNWrVzc6jt3asmWLTpw4oUcffdSy/EhKSopmzZql6OhoOTo6qkmTJuzJUsCSk5NzLY39559/ateuXXJ0dFTDhg1VoUIFg9IBBevatWs6evSoihQpomrVqt10D7QjR47oyJEj6tChQ+EGtAMXL16Uo6PjLZfoP336tE6dOqW6desWYjL7wDlwfwgLC1NMTIzef/99o6PYLcbAWPS/8RgDY3344Ydav369NmzYYHQUm7N3714tWbJEv/76q86ePWs5XqRIEfn4+Khdu3bq0qULW94VgIyMDC1YsEDh4eGKj4/Ps42np6eCg4PVq1cv7gsVoqysLB07dkxpaWmqUKEC23kVoOTkZJ06dUqVKlXKcZ2JjIy03Btt3LixateubWBK23X+/HktXbpUFy5cUMOGDdW8eXNJ0oEDBzR16lQdOnRIRYsWVf369TVkyBB5enoanNh+bdiwQUeOHGErhUKUkpKi9PR0ubu7y8HBweg4ds+Wvw8ws/0+5uPjY7mZXL16dQUFBem5555jL95CkpmZqYEDB2rr1q0ym80ymUzq3LmzJkyYoO7duysmJsbS1mQyqU6dOlq4cCEX9Xy2atUqffTRRzp//rzKly+vd955R40aNdL8+fP1ySefKCsrS5Lk6OioN954Q926dTM4sX3666+/1K5dO5lMJh06dMjoODZlzZo1evvtt3X58mVJUtmyZfX666/rueeey9U2NDRUM2fO1OHDhws7ps3atWuX3nnnHf3555+SpFq1amnkyJGqU6dOrrb0f8HgHLh/jBkzRhEREfS/gRgDY9H/xmMMjEX/F4yPPvpI8+fP1//e3nNzc7MsoS3dKPjOnDlT1apVMyKmTUpNTVXv3r21b98+ubi4yM/PT97e3ipevLikGzf4Y2NjFRMTo7S0NNWqVUvz58/noYd8tHPnTlWsWDHX5IrFixdrxowZunTpkuVY/fr1NXHiRAqN+Wz27NkKDQ1VZmamHnjgAY0bN06dOnXSu+++q0WLFlmuTSaTSa+88opef/11gxPblnPnzqlTp05KTEy03J9+7bXX1KpVKwUFBSktLU0lS5ZUSkqKMjMzVaZMGS1fvpwVNwzCZ6H8d/r0aZUoUSJXTWzTpk2aNm2ajh49KklydnZW27ZtNXLkSJUsWdKIqJBtnwPMbL/P1a5dW1euXNGhQ4c0YcIEffTRR2rTpo06d+7MzLkCtmrVKkVFRcnf31+tWrXSL7/8ouXLl6tkyZL6888/NW3aNAUEBCghIUHvv/++tm7dquXLlysoKMjo6DbjwIEDGj16tIoWLarq1avr+PHjeu211zRz5kx9/PHHatSokZ5++mklJCRo6dKlevfdd1WzZk3VqlXL6Oh2yWw257oBhH9n3759GjFihBwcHNSwYUM5OTlp27ZtGjVqlKUIjILz119/qW/fvkpPT5e3t7ecnJy0d+9e9erVS0OHDlX//v2NjmjzOAcAAIA9W7Fihb788kvVrFlTAwcOlKenp06ePKnZs2fr3Llz+uabb3T9+nWtWrVKc+bMUZ8+ffT999+rVKlSRke3CaGhodq3b5/69eunQYMGydnZOc92aWlpmjlzpubNm6eZM2dq5MiRhZzUdvXs2VODBw/OMUt07ty5mjJliooWLaoGDRrI3d1dBw4c0Pbt29WzZ0+tXLlSbm5uBqa2Hdu3b9fUqVNVunRp+fn56bffftNbb70lJycnLVq0SC+++KLlvtycOXP0xRdfqGHDhmrYsKHR0W3G/Pnz9ffff6tHjx5q1qyZNm7cqNmzZ2v//v0qW7aspk+fLh8fH2VkZGjGjBmaO3euZs+erbfeesvo6EC+aNGihUJCQjR48GDLsYiICP3nP/+R2WxW5cqV5e7urj/++EPh4eE6cOCAli1bxkozyHcU2+9zDRs2VEhIiPbt26ewsDCtXr1aERERWrlypby8vBQYGKiOHTuqdOnSRke1OWFhYapYsaIWLFggBwcHde/eXe3atdP8+fP11ltv6ZlnnpEkubq6KjQ0VE2bNtWPP/5IsT0fffHFFypWrJjCw8P1yCOP6MSJE+rYsaNGjRqlF154IcfykO3bt1fnzp31zTffUGw3wMMPP6wjR44YHcPmzJs3Tw4ODlq4cKGeeuopSTee6Bw1apSWLVumq1ev6v3337/pktr4d2bPnq309HRNmTJFbdu2lXSj+Dt69GhNnTpVqampGjZsmLEhbRzngLEiIiKsah8XF1cwQewYY2As+t94jIGxxowZY1X73bt3F1AS+7V48WJVqlRJX3/9tR544AFJUrVq1dSwYUM9//zz+vjjjzV58mS9+uqrqlu3rnr27Kk5c+bojTfeMDi5bVi7dq0CAgI0YsSIW7ZzdnbW66+/rsOHD2vNmjUU2/PR/z7Qf/HiRc2cOVPlypXTvHnz9Mgjj0i6saT8xx9/rPnz52vBggUaMmSIEXFtzsKFC+Xm5qaIiAh5eHgoKSlJbdu21dtvv60+ffrk+LvepEkTPfPMM1q6dCnF9ny0efNmPfXUU3rzzTcl3agVHDx4UJs2bdKcOXPk4+MjSSpatKhGjBihHTt2KDIy0sjINmXnzp1WtU9MTCygJPbrfyd3paam6r333pObm5umTZumBg0aSLrx4NvYsWO1evVqLV68WC+//LJRkW0K3wf+i2K7jahVq5Zq1aql//znP1qzZo3Cw8MVExOjyZMna9q0aWratKmCgoLUuHFjbjjnk/j4eLVq1cqyLLzJZFKDBg10/PhxNWvWLEfbBx54QI0bN+bDTD47ePCgmjVrZvnyVLlyZTVv3lw//PBDrjfM6tWrq2HDhtq1a5cRUYECERMToxYtWliKjJJUoUIFLViwQKNHj1ZERISuX7+ujz76iGt/AdixY4eaNGliKbRLN96Pw8LCNGjQIM2ePVtZWVkaPny4gSltG+eAsd544w2r+jV7WUPkH8bAWPS/8RgDY61YsUImk8mq1avo//x17Ngxde7c2VJoz+bs7KwmTZro+++/txyrU6eOGjdurE2bNlFszyeJiYlq3779Hbf39fVVdHR0ASbCtm3blJ6eruHDh1vuFUmSg4ODRo4cqU2bNmnjxo0U2/PJ0aNH1aJFC3l4eEiS3N3d1bx5c3333XcKDg7O0bZixYpq3Lix9u7da0RUm3XmzBk1adIkx7HatWvrt99+k5+fX672fn5+Wrx4cWHFs3k9evTgs+g9Ztu2bbp8+bLGjRtnKbRLNz4bvffee9q9e7fWrl1LsT2f8H3gvyi22xhnZ2d16tRJnTp10vHjxxUWFqZVq1Zpw4YN+vnnn1WuXDlt3rzZ6Jg24fLlyypRokSOYw8++KAk5bnvTbly5XTlypXCiGY3zp49a1lBIFv2Pl3e3t652lepUsXqJw6Be9nFixfz/Lvu6OioTz75RE5OToqIiLA8xY/8de7cuTz3BXd1ddXcuXP16quvau7cucrKymJfugLCOWAsJycnlS1bVl26dLmj9mvXrrXJfbmMxBgYi/43HmNgLFdXV5UrV07vvffeHbX/7LPP9MsvvxRwKvtz7dq1mx5PT0/Pceyxxx7Ttm3bCiOWXfDw8LDqmnLw4EFLURIF49SpUzKZTKpfv36u1xwcHOTv768ffvjBgGS2KTExMdc90LJly0q6UVz/X5UrV+Z9IJ8VK1ZMGRkZOY5l/5yenq7ixYvneC09PV1FihQptHy2rkiRIipVqpSaN29+R+137NjBSksFLC4uTiaTKddkSOnG+dKgQQOtX7/egGS2ie8D/0Wx3YZVqVJFo0aN0ogRI7Rp0yaFh4czszoflSxZUklJSbmO3+wpnuTk5FwfcPDvODs7Ky0tLccxJycnScpz3xUnJyfLSgTIX2fPnlV0dLTi4uIsD5W4ubnJy8tLdevWVfny5Q1OaJs8PDx04cKFPF8zmUx6//33ZTabtXLlSss+Rcg/7u7uSk5OzvO1YsWKadasWRo4cKC++OILZWVlycXFpZAT2j7OAWM99thjOnPmjPr3739H7Y8fP06RK58xBsai/43HGBjr8ccf1/79+1WrVq07mqHCPuH5r1q1atq4caNef/31HHtQX7lyRRs3blSVKlVytE9OTs41Cx53r1WrVvrqq680depUvfrqqzft2/T0dH322Wfatm2bevXqVcgp7Yuj441b3dmTYf5XyZIlb/qACqzn6uqa6ztxdiE3eyz+KSsry3LfDvnDy8tLkZGRun79uooUKaLMzExFRkbK0dFRGzduzLGdaUZGhiIjI1WpUiUDE9uWqlWr6uLFi3rnnXfuqP2YMWMothewrKwsSVKZMmXyfL1MmTK5HkbE3eP7wH9RbLcDRYoUUcuWLdWyZUv9/fffRsexGV5eXjp+/HiOYwMHDtQrr7ySZ/tTp05Znu5E/ihbtqwSEhJyHGvcuLHc3d3zbH/mzJmbvoa7c+LECU2YMEFbt26VlPthk+w32YCAAI0dO1ZeXl6FntGWPfzww7dchtBkMumDDz6QJK1cuZIHfvKZl5fXLfcaKlq0qD7//HO9+uqrmj9//k0/6OPucQ4Yy9fXV4cOHdKZM2d4qMogjIGx6H/jMQbG8vX11c6dO/XXX3+patWqRsexS926ddPIkSMVFBSk3r17q2LFijp58qQWLlyoc+fOacCAATna//7773muCoS7M2TIEO3YsUOzZ8/WokWL5OfnJy8vL8uDD1euXFFcXJxiYmKUkpIiHx8fhYSEGJza9hw5ckQRERGSpNOnT0u6MSEgrwdtExISVLJkycKMZ9MeeughnTp1Ksex9u3bq0aNGnm2P3PmDN+L81lgYKDGjh2rbt26qX79+tq+fbtOnDihMWPG6IMPPlBGRob8/f114cIFzZ49W6dPn77jhxRxe76+voqIiND58+dVunRpo+PYrVOnTllWs81e2SExMTHPFTbOnTvH+0A+4vvAf1FstzMUe/OPr6+vli5dqszMTMvTmk5OTnk+oZmenq7du3erXbt2hR3Tpj3++OPavn17jmO1atVSrVq18mx/8OBB+fj4FEY0uxAfH6/g4GBdvHhR/v7+CggIkLe3t1xdXSXdmDURGxuryMhIRUZGqmvXrlq2bBlP0OajRo0a6YMPPtCuXbtUp06dPNtkFxtNJpMiIiJsdl8cIwQEBGj69Ok6cuTITa8txYoVsxTct23bRv/nM84BY9WpU0dRUVGKjY29oyJXXnsG4t9hDIxF/xuPMTBWixYtdPHixTueHRQYGCh/f/8CTmVfnnvuOR08eFALFizIMavObDbrhRdeUPfu3S3Hsme1W7PHOG7N1dVV3377rebOnWtZTTKvFSXLli2r3r17q2/fvnJ2djYgqW3L3jpT+u8EgMjISHXr1i1X299//51JAPnI19dXGzZsyHHM29v7pg/17N27l/fifNaxY0dt2bJF69ev12+//SZJ6tWrl3r27Kk//vhDEydOtHwHNpvNqlq1qvr162dgYtvy+OOPa8WKFTpw4ICaNGly2/ZVqlS56b0L3L2IiAjLQ1dms1kmk0nR0dHq2LFjrrbHjh3LswiPu8P3gf8yma3ZuR73lOjoaFWsWJGLg0EyMjKUkpJyRzOljx07pjVr1qhZs2by9fUthHT2Yd++fdq1a5e6d++e57Lx/3TgwAG99tprevXVV3MsoYS7N2LECK1bt04zZ85U48aNb9l2y5YtCgkJUevWrTV58uRCSmj7EhIStGjRIj3xxBNq2bLlLduazWaFhobq9OnTev/99wspoW2Li4vT9OnT1bhxY3Xo0OGWbTMyMvTWW2/p1KlT+vrrrwsnoB3gHAAAALjxfffnn3/WuXPn5O7ursaNG3Mz3wCxsbF5bq3GagIFZ8WKFXke9/T0VN26dXMcO3jwoDp37qw+ffpo1KhRhRHP5h0/flxHjx5V8+bNb7s8/MGDB/XBBx+oR48eat26dSEltB/79u3TyZMn9cgjj+ixxx6TdOM7cPaDQBkZGfLz89NLL71kmSQD2ILQ0NA8j/v4+OS6TxQbG6tnn31W3bp109ixYwsjHuwIxXYAwF1p0KCBGjdurA8//PCO2o8aNUqRkZG5ViMAAAAAAAAAAKCgpKSk6OLFiypZsiQPnSDfsYw8AOCupKamWrU1RdmyZZWamlqAiQAAAAAAAAAAyKl48eIqXry40TFgoyi2AwDuSuXKlbV582YNHTpUjo63fju5du2atmzZosqVKxdSOgAAAAD3iuvXryshIUGSVKFCBYPT2J7U1FStX79eO3fuzHMZc39/f7Vs2VIuLi4GJ7Vf6enp2r9/vyTlWt4c+cdsNuvUqVNKTk6WJLm6uqpChQpycHAwOJnty8jI0P79+/O8BtWsWfO22z/i3zt79qyio6PzHIO6deuqfPnyBie0bfT/vSMrK0spKSmSbhTYeQ+4N9j69wGWkbcTf/31l9q1ayeTyaRDhw4ZHcfuxMfHq3fv3jKZTNqwYYPRcexSUlKSFi9eLJPJpMGDBxsdxyZ8/fXXevfdd+Xv76+hQ4fKz89PJpMpRxuz2azdu3dr+vTp2rVrl9588011797doMT2jeuQsc6cOaPRo0fLZDJp4cKFRsexS5wDxqL/jccYGIv+Nx5jYKy//vpLbdu2lYODA/ck8tm6dev09ttvKykpSTe7xWcymVSqVCmNHz+evZINwjlQsFavXq1ly5YpJiZG165dy/Gak5OTnnrqKQUFBalt27YGJbRdSUlJmjZtmr7//nulpaVJkuValH2PyNnZWc8//7yGDh0qd3d3w7LaqhMnTmjChAnaunWrJOV6L8geh4CAAI0dO1ZeXl6FntGW0f/3hr1792rZsmXauXOnTp06paysLEk3+t/T01P+/v4KDAzUk08+aWxQO2brn4WY2W5HzGbzTb94oWBdu3ZNp06dylWIROFJSkpSaGgoxfZ81L17d/3+++8KDw9X9+7d5ezsLE9PT7m5uUmSrly5opMnTyotLU1ms1lBQUEU2g3EdchYaWlpio6Opv8NxDlgLPrfeIyBseh/4zEGxnJycrLJGSxG2759u4YOHaoHH3xQgwcPVqNGjeTl5WXZhzQ5OVlxcXGKjIzUokWLNGzYMH355ZeqX7++wcntj7OzMzPaC0BmZqaGDh2qjRs3ymw2q0qVKnmeA9u3b9evv/6qH3/8UdOnT7/t6ny4MxcuXFDXrl114sQJVapUSQ0bNpS3t3eO/o+NjdW2bdu0ZMkSy/+WKlXK4OS2Iz4+XsHBwbp48aL8/f0VEBCQ5xhERkYqMjJSXbt21bJly1SpUiWDk9sG+v/eMGnSJC1evFhms1nOzs56+OGHc4zByZMnFR4eruXLl6t79+568803DU5sn2z9+wAz24FCkJmZaVkio2LFigansU9JSUlatGiRTCaTQkJCjI5jU3799VeFhYUpOjpaiYmJOV7z8PCQv7+/goODVa9ePYMSQuI6ZLT09HTt27dPkuTv729wGvvEOWAs+t94jIGx6H/jMQawRT179tSxY8f03XffqVy5crdse/bsWXXq1EmPPvooKy3BZsyaNUvTpk1Tu3btNGLEiJvexD99+rQmT56s1atXa9iwYRowYEAhJ7VNb731lsLCwjR+/Hh17dr1lm2//fZbTZgwQUFBQZowYUIhJbR9I0aM0Lp16zRz5kw1btz4lm23bNmikJAQtW7dWpMnTy6khLaN/jfet99+q3feeUd16tTR0KFD9dRTT+VaNj4rK0u7du3S9OnTFRMTc0fXLMBaFNsBAPkmLS0tx75Ezs7OBicCAAAAANv01FNPqWPHjho7duwdtZ80aZJWrFih3bt3F3AyoHA888wzevDBB7VkyZI7at+lSxddunRJa9euLeBk9qFRo0aqXbu2Pv300ztq/9prr2nPnj2KjIws4GT2o0GDBmrcuLE+/PDDO2o/atQoRUZGavv27QWczD7Q/8Z74YUXlJWVpRUrVtx21ZJr166pU6dOcnBw0MqVKwspIeyFw+2bAABwZ5ydnVW2bFmVLVuWQjsAAAAAFKC7mT/DnBvYktOnT1u1cpi/v79Onz5dgInsy6VLl+Tt7X3H7b28vHTp0qWCC2SHUlNTVbZs2TtuX7ZsWaWmphZgIvtC/xsvNjZWTZs2vaPtQZycnNSkSRPFxsYWfDDYHTaosRFnz55VdHS04uLicswq9fLyUt26dVW+fHmDE9q2jIwM7d+/P8/+r1mzpooWLWpwQvuRlZWllJQUSVLx4sVzLRsD2CquQ8ZLSEhQbGxsjv739va+7ZKeyB+cA8ai/43HGBiL/jceY2CsXbt2aefOnTe9J1GnTh2DE9qmxx9/XGvWrFH//v1ve7M/ISFBq1evlq+vbyGlsx+pqalav379Tc8Bf39/tWzZUi4uLgYntT0lSpRQXFzcHbePi4tTiRIlCjCRfSlfvryio6PvuP3OnTu5R53PKleurM2bN2vo0KF3NKt3y5Ytqly5ciGls330v/GcnZ1zbWt6K4mJiUwQKyD2/n2AYvt97sSJE5owYYK2bt0qKfcTyiaTSZIUEBCgsWPHysvLq9Az2rKkpCRNmzZN33//vdLS0iT9dwyy+97Z2VnPP/+8hg4dKnd3d8Oy2rK9e/dq2bJl2rlzp06dOqWsrCxJN8bA09NT/v7+CgwM1JNPPmlsUKAAcB0yVkZGhhYsWKDw8HDFx8fn2cbT01PBwcHq1asXN/oLAOeAseh/4zEGxqL/jccYGGvPnj0aN26cjh07dtMZ0yaTSY888ogmTpzId7J8NmDAAPXr108dOnRQjx499PTTT8vLy0tubm6SpCtXriguLk5RUVFatGiRkpKS2Ks6n61bt05vv/22kpKS8jwHdu7cqeXLl6tUqVIaP368WrdubUBK29W4cWNFRERo2bJlCg4OvmXbJUuWaMOGDerUqVMhpbN9zz33nEJDQzVy5EgNHz78poX0M2fOaPLkydq7d69CQkIKOaVtCw4O1rvvvqs+ffpo6NCh8vPzs3z+yWY2m7V7925Nnz5df/75p958802D0toe+t949erV0+rVq9W+fXsFBATcsu0vv/yi1atXq0WLFoWUzj7wfeAG9my/j8XHxysoKEgXL16Uv7+/AgIC5O3tLVdXV0lScnKyYmNjFRkZqZ07d8rd3V3Lli1TpUqVDE5uGy5cuKCuXbvqxIkTqlSpkho2bJhn/2/btk3x8fGqXLmylixZolKlShmc3LZMmjRJixcvltlslrOzszw9PXOMwcmTJ5WWliaTyaTu3bvzgQY2heuQsVJTU9W7d2/t27dPLi4u8vPzk7e3t4oXLy5JSklJUWxsrGJiYpSWlqZatWpp/vz5zGjJR5wDxqL/jccYGIv+Nx5jYKxDhw6pa9eukqR27dqpUaNG8vLyytH/cXFxioyM1I8//iiTyaSlS5fKx8fHyNg2Z+XKlXr33Xd1+fLlXDf4s5nNZrm5uWncuHF6/vnnCzmh7dq+fbv69OmjBx98UN26dbvlObBo0SJdvnxZX375perXr29wctuRmJiooKAgJSQk3NH7wEMPPaSwsDCVKVPG4OS2ISMjQ6+++qq2bt0qk8mkKlWq5PnAz/Hjx2U2mxUQEKDPP/9cTk5OBie3HWazWePGjVN4eLhMJpPl3ug/xyD73qjZbFZQUJAmTpxocGrbQf8bLzY2VoGBgUpJSVH9+vVv+j6wdetW7dixQ25ublq2bJlVW2Dg5vg+8A9m3LeGDx9urlGjhnnLli23bbt582ZzjRo1zMOHDy+EZPZh3LhxZh8fH/O3335727bffPON2cfHxzxu3LhCSGY/vvnmG3O1atXM3bp1M0dHR5uvX7+eq83169fNO3bsML/00kt3PF7A/YLrkLE+/PBDc7Vq1cyffPKJOTU19abtUlNTzR9//LG5WrVq5o8++qgQE9o+zgFj0f/GYwyMRf8bjzEw1oABA8xPPfWU+fDhw7dte+jQIbOfn595wIABhZDM/ly6dMm8ZMkS8/Dhw82dO3c2t27d2ty6dWtz586dzcOHDzcvWbLEfOnSJaNj2pwePXqYGzZsaD579uxt2545c8bcoEEDc8+ePQshmX1JTEw0jxo1ylyzZk1ztWrVzNWqVTP7+PiYfXx8LD/XqFHDPHr0aPPff/9tdFybk5WVZQ4PDzd36dLFXL16dUufZ/9TvXp1c5cuXczLly83Z2VlGR3XZm3fvt08fPhwc0BAQK4xCAgIMA8fPtz866+/Gh3TZtH/xvrjjz/M3bp1y/Ue8L/vBd27dzf/8ccfRse1KXwf+C9mtt/HGjRooMaNG+vDDz+8o/ajRo1SZGSktm/fXsDJ7EOjRo1Uu3Ztffrpp3fU/rXXXtOePXsUGRlZwMnsxwsvvKCsrCytWLHijvbF6dSpkxwcHLRy5cpCSggULK5DxmrevLkefvhhzZs3747av/LKKzp+/Lg2btxYwMnsB+eAseh/4zEGxqL/jccYGMvf31/PPPOMJkyYcEftx40bp59++smq/X2Be9lTTz2ljh07auzYsXfUftKkSVqxYoV2795dwMnsU0pKin777TfFxsYqOTlZkuTq6ipvb2898cQTlll2KDgZGRk6ceJEjr16K1WqpGLFihmczL6kpaXlGAP2py5c9L9xYmNjFR0dnef7QN26dVWlShWDE9oevg/8F3u238dSU1NVtmzZO25ftmxZpaamFmAi+3Lp0iWrlhvx8vLS5s2bCyyPPYqNjVXPnj1vW2iXJCcnJzVp0kRff/11ISQDCgfXIWMlJiaqffv2d9ze19fXJj9MGolzwFj0v/EYA2PR/8ZjDIx17do1y/Y5d8LV1VXXrl0rwERA4bqb+UvMeSo4xYsX19NPP62nn37a6Ch2q2jRonrkkUeMjmH3nJ2dKfAaiP43jre3N8vDFzK+D/yXg9EBcPcqV66szZs3KzMz87Ztr127pi1btqhy5cqFkMw+lC9f3qqiyc6dO1W+fPkCTGR/nJ2dlZiYeMftExMT+bADm8J1yFgeHh46fPjwHbc/ePCgPDw8CjCR/eEcMBb9bzzGwFj0v/EYA2M98sgjWrdunVJSUm7bNjk5WT/99BNFGNiUxx9/XGvWrNHff/9927YJCQlavXq1fH19CyEZAHuVkJCgHTt2aMOGDdqwYYN27NihhIQEo2MBsFF8H/gviu33seDgYP3xxx/q06ePdu/enefTsWazWbt27VKfPn30559/qkuXLgYktU3PPfecfvvtN40cOVJnzpy5abszZ87o9ddf1969e/X8888XYkLbV69ePa1evVpRUVG3bfvLL79o9erVql+/fiEkw/8KDQ3VrFmzFBcXZ3QUm8J1yFitWrVSVFSUpk6dqvT09Ju2S09P15QpU7Rt2za1bt26EBPaPs4BY9H/xmMMjEX/G48xMFaPHj106tQpBQUFadWqVTp//nyuNufPn9fKlSsVFBSkM2fOqFevXgYkhXTjPOjZsydjkI8GDBig8+fPq0OHDvr888+1b98+Xbp0SVlZWcrKytKlS5e0b98+ffbZZ+rYsaOSkpI0YMAAo2PbrevXr+v06dM6ffq00VHsUnJysiIiIhQREWF0FJuTkZGhOXPmqHXr1mratKl69+6tIUOGaMiQIerdu7eaNm2qVq1aae7cucrIyDA6rt1KSkpSaGioZs6caXQUIN/wfeC/2LP9PmY2mzVu3DiFh4fLZDLJ2dlZnp6ecnNzkyRduXJFJ0+eVFpamsxms4KCgjRx4kSDU9uOjIwMvfrqq9q6datMJpOqVKkiLy+vHP0fFxen48ePy2w2KyAgQJ9//rmcnJwMTm47YmNjFRgYqJSUFNWvX18NGzaUt7e3ZR+u5ORkxcbGauvWrdqxY4fc3Ny0bNkylpMxgI+Pj0wmkxwcHNSmTRv1799fPj4+Rse673EdMlZycrK6d++uI0eOqHjx4vLz88uz/2NiYpSSkiIfHx8tWrSIvQLzEeeAseh/4zEGxqL/jccYGO/zzz/XzJkzdf36dUmSi4tLjv7P3squSJEiCgkJ0cCBAw3Lau/++usvtW3bViaTyarVmXBrK1eu1LvvvqvLly/LZDLl2cZsNsvNzU3jxo3jgR8DZZ8DDg4OOnTokNFx7A7XoIKRmpqq3r17a9++fXJxcZGfn5+8vb0tyzqnpKQoNjZWMTExSktLU61atTR//ny5uLgYnNz+cA4Y76+//lK7du1kMpl4H8hHfB+4gWK7Dfj1118VFham6OjoXEtqe3h4yN/fX8HBwapXr55BCW2X2WzWd999p7CwMO3bt09ZWVk5XndwcFCtWrUUHBysjh073vSLF+7en3/+qbffflu7du2SpFx9nH2Jq1u3rsaPH2+zy5Tc60JDQ5WVlaU//vhDu3fvVlJSEh8s8wnXIWOlpaVp7ty5Cg8Pv+nykWXLllVQUJD69u3LVhYFgHPAWPS/8RgDY9H/xmMMjBcXF6fly5crOjpacXFxunLliiTJzc1NXl5e8vf3V6dOnXjo2WDp6enat2+fJMnf39/gNLbl8uXLWrNmzS3PgWeffVYlSpQwOKl9i4+Pt8ym27hxo8Fp7E9iYqImT54sk8mk999/3+g4NuOjjz7Sl19+qX79+mnQoEE3veeQlpammTNnat68eXrllVc0cuTIQk6KpKQkLVq0SCaTSSEhIUbHsUvZDzxI0pEjRwxOY1v4PkCx3eakpaXl+IvMTf3Ck5GRoRMnTuTo/0qVKqlYsWIGJ7MPsbGxio6OVmxsrJKTkyVJrq6u8vb2Vt26dVWlShWDE+Kfjh07pqpVqxodw+ZwHTJWbGxsnh8obfmD5L2Gc8BY9L/xGANj0f/GYwwAAIA9ad68uR5++GHNmzfvjtq/8sorOn78OA+cAEA+o9gOAAAAAAAAAABwH6lZs6ZefvllDR8+/I7aT5kyRfPnz9f+/fsLOBkA2BdHowMAAAAAAAAA+HcSEhIUGxubY3UHb29vlStXzuBkAICC4OHhYdU2jQcPHpSHh0cBJkJWVpZSUlIkScWLF5eDg4PBiQBjrFixQitWrNBXX31ldJRCQbEdAHDXzp8/r6VLl+rChQtq2LChmjdvLkk6cOCApk6dqkOHDqlo0aKqX7++hgwZIk9PT4MTAwAAAIDtyMjI0IIFCxQeHq74+Pg823h6eio4OFi9evVS0aJFCzkhUDh27dqlnTt35rm1V926dVWnTh2DE9quM2fOaMWKFTftf39/f73wwguqUKGCwUltT6tWrfTVV19p6tSpevXVV/XAAw/k2S49PV2fffaZtm3bpl69ehVyStu3d+9eLVu2TDt37tSpU6eUlZUlSTKZTPL09JS/v78CAwP15JNPGhvUxp09e/ame4bXrVtX5cuXNzihfTl16pR27txpdIxCwzLyAIC7cu7cOXXq1EmJiYkym80ymUx67bXX1KpVKwUFBSktLU0lS5ZUSkqKMjMzVaZMGS1fvpxZFQAAAACQD1JTU9W7d2/t27dPLi4u8vPzk7e3t4oXLy5JSklJUWxsrGJiYpSWlqZatWpp/vz5cnFxMTg5kH/27NmjcePG6dixY7rZbW6TyaRHHnlEEydOpNiVzxYsWKApU6YoIyNDkuTi4iJXV1dJUnJyslJTUyVJRYsW1fDhw9W7d2+jotqk5ORkde/eXUeOHFHx4sXl5+cnLy8vubm5SZKuXLmiuLg4xcTEKCUlRT4+Plq0aJFljPDvTZo0SYsXL5bZbJazs7M8PT1znAMnT55UWlqaTCaTunfvrjfffNPgxLbnxIkTmjBhgrZu3SpJud4LTCaTJCkgIEBjx46Vl5dXoWe0R6GhoZo5c6ZVq2/cz5jZDgC4K/Pnz9fff/+tHj16qFmzZtq4caNmz56t/fv3q2zZspo+fbp8fHyUkZGhGTNmaO7cuZo9e7beeusto6MDAAAAwH0vNDRU+/btU79+/TRo0CA5Ozvn2S4tLU0zZ87UvHnzNHPmTI0cObKQkwIF49ChQ5ZZuh06dFCjRo3k5eWVo9AVFxenyMhI/fjjj+rVq5eWLl0qHx8fI2PbjDVr1uiDDz6Qt7e3Bg4cqICAAJUpUyZHm3PnzikyMlKzZs3Shx9+qIceekjPPPOMQYltj6urq7799lvNnTtX4eHhioyMVGRkZK52ZcuWVe/evdW3b9+bvlfAet9++60WLVqkOnXqaOjQoXrqqadyLRuflZWlXbt2afr06Vq0aJGqVq2qrl27GpTY9sTHxys4OFgXL16Uv7+/AgIC5O3tneN9IDY21nJudO3aVcuWLVOlSpUMTg5bw8x2AMBdadeunR588EEtXrzYcuzFF1/Ub7/9pjlz5qhRo0Y52gcHByspKUnr168v7KgAAAAAYHOaN2+uhx9+WPPmzbuj9q+88oqOHz+ujRs3FnAyoHAMHDhQu3bt0qJFi25bQD98+LC6d++uunXratasWYWU0LZ16dJF586d08qVK287U/rKlSt64YUX5OHhoaVLlxZSQvsTGxub5xLa3t7exgazUS+88IKysrK0YsUKOTreel7rtWvX1KlTJzk4OGjlypWFlND2jRgxQuvWrdPMmTPVuHHjW7bdsmWLQkJC1Lp1a02ePLmQEtove5vZ7nD7JgAA5HbmzBk98cQTOY7Vrl1bkuTn55ervZ+fn86ePVso2QAAAADA1iUmJurxxx+/4/a+vr5KTEwswERA4YqJiVHbtm3vaKZ69erV1bZtW8XExBRCMvtw9OhRtW7d+o6WJHdzc1ObNm109OjRQkhmv7y9vdWkSRO1b99e7du3V5MmTSi0F6DY2Fg1bdr0toV2SXJyclKTJk0UGxtb8MHsyLZt29S2bdvbFtolqUmTJnr22We1bdu2QkiGli1b6r333jM6RqFhGXkAwF0pVqyYZU+ubNk/p6enW/YJzJaenq4iRYoUWj4AAAAAsGUeHh5WzRY6ePCgPDw8CjARULiuXbuW697Drbi6uuratWsFmMi+ODo6KiUl5Y7bp6Sk3FFRErhfODs7W/UQW2JiIsv457PU1FSVLVv2jtuXLVtWqampBZgI2Xx8fOxq2xZmttuJ0NBQzZo1S3FxcUZHsUsRERH6/vvvLUv4ALbAy8tLkZGRun79uiQpMzNTkZGRcnR0zLUsYUZGhiIjI9kPx0Bch4y1c+dOxcTEKCsry+godotzwFj0v/EYA2PR/8ZjDIw1ZswYjRs3Tr/++qvRUWxKq1atFBUVpalTpyo9Pf2m7dLT0zVlyhRt27ZNrVu3LsSEyNazZ0/16dNHy5cvV2ZmptFxbMYjjzyidevW3VHBNzk5WT/99JMeeeSRQkhmH5588kmtXr1av//++23bHjlyRD/++KNlRUQUvvT0dO3cuVM7d+40OorNqFevnlavXq2oqKjbtv3ll1+0evVq1a9fvxCS2Y/KlStr8+bNd/Teeu3aNW3ZskWVK1cuhGSwN+zZbid8fHxkMpnk4OCgNm3aqH///nb1VInRsvu/ePHievHFF9W7d2+VLl3a6Fh2pXr16ipSpIjatWun/v37q2rVqkZHuu+Fh4dr7NixevLJJ1W/fn1t375d+/bt05gxYzR9+nQNHz5c/v7+unDhgmbPnq3t27erf//++r//+z+jo9slrkPGyu7/ihUrqm/fvurUqZOKFi1qdCy7wjlgLPrfeIyBseh/4zEGxsq+/2AymVSrVi0NGDBAzZs3NzjV/S85OVndu3fXkSNHVLx4cfn5+cnLy0tubm6SbuyRHBcXp5iYGKWkpMjHx0eLFi26oyWfkb/+eQ489NBD6tOnj3r06GFwqvvfqlWrNGrUKD388MMaOHCgnn766VzX9vPnzysqKkqzZs1SbGysPv74Y7Vv396gxLZl3759eumll1SkSBE999xzatiwoby9vXNcg2JjY7V161b98MMPysrK0jfffKOaNWsanNw+/fXXX2rbtq0cHBx06NAho+PYhNjYWAUGBiolJUX169e3nAPZ77PJycmWc2DHjh1yc3PTsmXLWNo/H3399dd699135e/vr6FDh8rPz08mkylHG7PZrN27d2v69OnatWuX3nzzTXXv3t2gxLBVFNvtRGhoqLKysvTHH39o9+7dSkpKsmqpMfw7b7zxhsxms/744w8dOXJETk5O2rt3r9Gx7Mo/Hy5xcHBQixYtNGPGDAMT3f+uX7+uYcOGaf369ZZjvXr1ssxaCQsLs3y4MZvNqlq1qpYuXcqNHYNwHTJWjx49LP1/6dIllSlT5o6efEb+4RwwFv1vPMbAWPS/8RgDY61YscJyTyI6OlpHjx7VgQMHjI5lE9LS0jR37lyFh4fr77//zrNN2bJlFRQUpL59+7J8rUGio6Mt50D2qld8H8gfn3/+uWbOnGlZdc/FxSVHsTd7ueAiRYooJCREAwcONCyrLfr11181btw4xcfH5ypwZTObzapUqZImTZqkevXqFXJCZDtz5oxGjRol6UaBEvnjzz//1Ntvv61du3ZJUp6FXkmqW7euxo8fz+oa+cxsNmvcuHEKDw+XyWSSs7OzPD09c7wPnDx5UmlpaTKbzQoKCtLEiRMNTg1bRLHdTh07doyZvQZJTk5WTEyMGv8/e3ceV2P6/w/8dVqlhaIGSTWWIrKWQWXfIhRlN5ZhLDX52A3GDGObYWzZhpmxzaBINGqQbZIlJI2RsbQqIpQ2LTq/P/z0nTMnFKdz6ZzX8/H4PD7jOtd99+q6OqfTed/3dbm4iI6idqRSKW7duoVLly7hypUrWL16tehIKiEmJgb37t1DgwYN0KhRIwAvx3r//v0IDw9HQUEBWrVqhWHDhrHQ/oHg65BYt27dwpUrVzB06FDRUdQWnwNicfzF4xyIxfEXj3MgXk5OTrn2WaaySUhIQGJiYsl2CYaGhrC0tOQddKTyEhMTceDAAURGRpb6HHB0dISHhwefCxXkxYsXuHDhAiIjI5GQkIDs7GwAgIGBAaysrODg4IB27dpBU1NTcFKiipOQkPDG54C1tbXghKrtwoULCAgIQGRkJB49eiTzmKmpKRwdHeHl5cULfqjCsNhORERERERERERERERERJVaXl6ezEVXXNWHlIHFdqIKlJ2dDR0dHe7LS0RERERERGolOzsbz58/h4mJCTQ0NETHISIiIlKa7OxsPHv2DHXq1BEdhYiUQEt0AKoYsbGxiIqKQm5uLszNzeHi4sLlmwVwcHCAp6cnFi1aJDqKWkhOTkZCQgKysrIgkUhQo0YNNGnShD/7guTk5OD58+cwNjbmh2sfiKioKCQlJWHAgAGio6iEw4cPo127djA1NRUdhf7j1q1b2LVrF65fv47nz5/D3Nwcrq6ucHd3f+0+gqQ4HH/l2bRpE5ycnNCsWTPRUdQSx7/y4XshxUpLS0NKSgpatGgh835/7969+OWXX5CUlAQA0NPTQ48ePTBz5kzUqFFDVFwihevRowecnZ0xaNAgNG7cWHQcIlJjubm5OH78OC5duvTarRS6deuGqlWrCk6qPrZv344NGzYgNjZWdBS1FRYWhhMnTmDZsmWio5Aa4J3tlZifnx/atm0LBweHkra8vDzMnj0bx48fB/By32SJRIJq1aph+fLl6NSpk6C06snW1haenp5YvHix6Cgqq7CwENu3b8fevXuRmpoq97iGhgacnZ0xdepU2NraCkioulJTU2FkZCR3McOpU6ewZs0a3Lp1C8DLD9dcXV0xc+ZMVKtWTURU+v/mzp2LoKAgvtFXEFtbW2hpaaFjx44YNGgQOnbsyAtLlGzRokUIDQ1FREREydiHhIRg9uzZKCwslOkrkUjQsWNHbNy4kfOkIBx/8WxtbSGRSGBjY4NBgwahX79+MDIyEh1LbXD8Kx++F1Ks6dOn4+rVqzh58mRJ23fffYdffvkFEokEFhYWMDQ0RFJSEp49e4a6devC398fJiYmAlMTKc6r3wMA0LhxY3h6esLNzY0X/BORUh07dgxff/01nj59iteVeiQSCUxMTLBw4UL06NFDyQnVk5+fH4vtgnEOPix+fn7Q0tJC7969YWlpKTqOwrHYXonZ2trC29sb3t7eJW2zZs3C4cOHYW1tjf79+8PY2BjR0dE4dOgQtLW1ERQUBGtra4GpVUfz5s3f2qegoACamprQ1NQE8PKNTXR0dAUnUx/5+fkYO3YsoqKiIJVKUa1aNWRmZgIA6tevDwsLC9y+fRspKSnQ0tLCkiVL0L9/f8GpVUfjxo3h7e2NKVOmlLQFBQXhyy+/hFQqRb169WBsbIzbt28jJycHtra28Pf357YKAvEDZsV69eHaqwvbTE1N4e7ujkGDBsHCwkJ0PLXg5uYGa2trrFu3DgCQkZGBLl26QENDA9OnT0eXLl1gZGSE27dvY/369Th79ixmzpyJsWPHCk6uGjj+4tna2kJPTw95eXmQSCTQ0dFB9+7d4enpibZt24qOp/I4/pUP3wspVteuXeHg4IDly5cDAJKSktCrVy9YW1tjzZo1aNiwIQCgqKgIW7Zswfr16zFixAjMnz9fZGwihbG1tUWrVq2QlZWF27dvQyKRoEqVKujZsycGDhwoc3MMEVFFOH/+PMaOHYvq1atj+PDhcHZ2hqWlZclFP9nZ2UhMTER4eDh2796NZ8+e4eeff8Ynn3wiOLnqY6FXPM7Bh+XV56gaGhro2bMnJkyYoFI3R3IZeRWSnJyM4OBgtGjRAtu3b0eVKlUAAIMHD0bnzp3xxRdf4JdffuGS5gqSn5+PKlWqvPGq/NTUVOjo6KB69erKC6ZGtmzZgitXrmD48OGYOnUqDA0NkZ2djTVr1sDf3x+LFy9Gq1atcOXKFcyfPx/z5s2DjY2NSr2IiySVSmWumM3NzcXSpUthaGiINWvWoF27dgBerrgxf/58hISE4Ndff8WYMWNERVY5pa3m8CY5OTkVlER9ff7552jSpAkCAgIQERGBLVu24Mcff4SjoyM8PT3Ro0cPXmBSgVJSUuDs7Fzy7z///BO5ublYuXIl+vbtW9Jub2+PjRs3wsPDAwcPHmSxV0E4/h+GcePGoXPnzggICMCRI0fw+++/48iRI6hbty4GDRoEd3d3mJmZiY6psjj+YvG9kFiPHj2S+fk+d+4cpFIpFi1aVFJoBwAtLS1MmTIFly5dwsmTJ1lsJ5XSvn17eHt7IyYmBgEBAQgJCUFQUBAOHToES0vLkt8F3EKBiCrCpk2bYGJigsDAQHz00Udyj1evXh3Vq1dH8+bNMWjQIHh4eGDTpk0sthOR0nl7e6O4uBi3b9/GhQsXEBoaqlIXQrDYrkIuXrwIAJg6dWpJof2VHj16oHXr1rhw4YKIaCrJ2dkZERER6N27N3x9fUstptja2qJPnz5cRr6CHDlyBC1atMCCBQtK2gwMDDB//nxcv34da9aswc6dO9G6dWts374drq6u2Lp1K1atWiUwteo6d+4cnj17hgULFpQU2oGXy8gvXboUV65cwR9//MFiuwJ16dKF+x8LpqWlhR49eqBHjx5IS0vD/v37ERgYiIsXLyIyMhKLFy+Gm5sbBg0axAt9lODBgweQSCSlbpujra2Ndu3aYe/evcoPpiY4/uLY2dnBzs4Oc+fORWhoKA4cOIDLly9jzZo1WL9+fcl+sp07d+Yy/hWA4y8O3wuJpaenJ3MBw7NnzwAATZo0KbV/48aNceXKFaVkI1I2e3t72Nvb48svv0RoaCj279+PqKgorFq1CmvWrEGnTp3g6ekJFxcXvm4RkcL8/fffcHd3L7XQ/l+1atWCq6srDh48qIRk9N+blIjU3b9X6AaAu3fvCkpSMVhsVyGPHz8G8PLDntI0adIE/v7+yoyk0rZu3Qp/f3+sWLECp06dwtKlS9GiRQvRsdRKamoqunTpUupjLVu2lPlA/6OPPkLXrl1x/vx5ZcVTO4mJiZBIJOjcubPcY7q6umjXrh2OHz8uIJnqkkgkqFatGpo2bVqm/rdu3cKjR48qOJX6+uijjzBlyhRMmTIF58+fx/79+xEWFobdu3fj119/hZ2dHTw9PTF48GDRUVWGtbW1zPYsr1abyczMLHWvzGfPnkFPT09Z8VQex//Do6uriwEDBmDAgAFISkrC/v37ERQUhFOnTuH06dOoUaMGPDw8MG3aNNFRVRLHX/n4XkisJk2a4OzZsyVb6lhZWQEA4uLiSv1cIj4+nqu+kcrT09ODh4cHPDw8EB8fj4CAABw+fBhhYWE4ceIEPvroI5w+fVp0TCJSEe9SzGUBWDl8fHzg4+MjOoZac3R0FB2B3qB+/fqiIygUL6tXIa8+1HzdFbKampq8k0LBvLy8cOjQIdSsWRPDhw/HihUrkJ+fLzqW2tDX10d6enqpj6Wnp8v9vNeuXRsZGRlKSKaeiouLAQA1a9Ys9fGaNWvi+fPnyoyk8qysrKCvr49t27aV6X8dOnQQHVlttGvXDqtWrUJ4eDjmzZuHRo0a4fr16/j6669FR1Mpffv2xdWrVxESEgLg5d6x+vr68PPzk+t769YtHD16FM2bN1d2TJXF8f+w1atXD9OmTcPp06exceNGdO7cGRkZGdi6davoaGqB468cfC8k1rBhw5CYmIglS5aguLgYnTp1gqWlJRYtWiT3d1pAQADOnDkjs/0IKdelS5cQFRVV8ncbVTxra2vMmjULZ86cgZ+fHzp27MgLfohIoZo0aYLQ0FA8fPjwrX3T0tIQEhLy2hv1iFSNo6Oj3N3URBWFd7ZXcidOnEBKSgoAlPxSTU5ORuPGjeX6PnjwAMbGxkrNpw7q1q2LnTt3YufOnVi9ejVOnjyJJUuWoE2bNqKjqbyWLVvi2LFjGDt2rMzPfGxsLI4ePYqWLVvK9H/8+DGqVaum7JgqLSUlBZcuXQIAFBQUAHi5d6O5ublc3/T0dI6/gjVp0gQhISF49uwZjIyMRMehUhgZGWHkyJEYOXIkrl+/jgMHDoiOpFJGjBiBkJAQzJgxA+Hh4ejZsye8vb3x/fff459//kHnzp1haGiIu3fvIjg4GEVFRZg0aZLo2CqD4185aGhooEuXLujSpQseP37MZSOVjONfsfheSKzu3bvDy8sLu3fvRnh4OLp06YKuXbti+/bt6N69O5o2bVryeyApKQk1atSAr6+v6Nhqa+TIkZBIJDA3N8dnn30GDw+PUrfDI8XT1NREt27d0K1btzIVxKhizJ07F1paWujTpw/3qxaga9euJeM/atQornSiIJ9//jnGjx+PAQMGYOTIkejQoQMsLS1haGgIAMjKykJiYiLOnj2L3bt34+nTp/j8888FpyYiVXP37l0kJiaiYcOGsLCwAPDyxjx/f39ERkZCS0sLnTp1gqurq+CkFYfF9kouNjYWsbGxMm1hYWGlFtujo6PRqFEjZUVTO6NGjYKLiwvmzJmDUaNGYdiwYaIjqbyJEyciPDwcXl5e6N69O8zNzXHv3j2EhYWhqKgIn332mUz/K1euwMbGRlBa1RQUFISgoCAAKFk+MjIyEu7u7nJ97969W2oRnt6dnZ0djhw5gr///hvt2rV7a//q1aujdu3aSkhGpWnatGmZl7mlstHW1sZPP/2EuXPn4uDBgzKvR/9+jySVSmFsbIzFixfLXYhF747jX/nUqFFD7v0RKQ/HX/H4Xki8RYsWoX79+ti4cSN++eUXSCQSSKVS5OXllVyUCwAdOnTA119/XaY9ZaliODg4QCqV4vbt2/j666/h5+eHs2fPio6ldszMzERHUFuvLnjbv38/7O3t8fnnn792a0JSvFc3i736fTF48GDMmTNHcKrKz9nZGStWrMCSJUuwdu1arFu3rtR+UqkUhoaGWLFiBZycnJSckohU2VdffYWAgAAAL1fdfrXFpq+vr8yWssHBwQgLC8MPP/wgKmqFkki5SUel9epNyn/p6emV7Jn5SmxsLJYuXYr+/ftj0KBByointqRSKbZu3Qo/Pz8UFBTA09MTixcvFh1LZR07dgwLFy7E06dPS9oMDAwwZ84cmZ/17Oxs7Nq1Cy1btuQVzApS2jLBAGBra4tu3brJtCUkJKB3794YPnw45s+fr4x4auH58+d4/PgxjI2NUbVqVdFx1M7IkSMxcOBADBgwQHQUAnDt2jUcOXIEN27cwOPHj1FcXAxDQ0NYW1vjk08+Qc+ePUvdR5wUg+Mvxty5c9GtWzd07dpVdBS1xPEXj++FPhz5+fk4e/Ys/v77bzx+/BhSqRQGBgYlvwde3eFCH4Zbt27hypUrGDp0qOgolVpkZCTMzc15UXklcfDgQRQXF+P27duIjIzErVu3cP36ddGx1EZKSkrJ+F+6dAlXrlyBv7+/6Fgq49mzZwgNDUVkZCQSExORlZUFADA0NISlpSUcHR3Ru3dvrgRERAp1/Phx+Pj4oH79+nB2dsb58+dx69YtzJo1Cz/88AOmTp2KDh06IC0tDatXr8Y///yD1atXo1evXqKjKxyL7UQVJCEhAXfu3EHdunVha2srOo5Ky8/PR1RUFNLT02FsbIxWrVrxw7YPTE5ODjIyMlCtWjUWW4iIiIiIiIhIqJycHOjr64uOQUREVGmNHj0ad+7cwbFjx1C1alXk5+ejV69eSE9Ph4+PDyZMmFDSNyMjA507d0bbtm2xefNmgakrBpeRJ6ogVlZWsLKyEh1DLejq6pZp2UgSR19fn3/EEhERERERkVrJzs6Gjo4OdHR0REeh/+BnFERERO8nPj4enTt3LrnxUVdXFy4uLvD390ffvn1l+lavXh2dOnWS2WpKlbDYrkKSk5ORkJCArKwsSCQS1KhRA02aNOFdpIK8ePECiYmJ0NbW5pJ5RCQEX4eUKy0treT3MPByuTYrKyvuTaoEhYWFyM3NRbVq1WTar169ihs3bkBHRweOjo6wtLQUlFD9REVF4fr163j+/Dnq1q0LZ2dnGBoaio6llry9vdG+fXsMGzZMdBQiIhLA0dERAwYMwJdffik6ilpycHCAp6cnFi1aJDqK2jpx4gTMzc256qQSFBYWIjk5WeazaW6zQESkup48eSK3pXWNGjUAALVr15brX6dOHWRkZCgjmtKx2F7JFRYWYvv27di7dy9SU1PlHtfQ0ICzszOmTp3KN5UV4O7du1i/fj2SkpLQqFEj+Pj4wNzcHBcvXsTs2bORlpYG4OVd7itWrIC9vb3gxKqpsLAQt27dgqamJmxsbCCRSErtd/PmTdy8eZP7KysYx18svg6JVVBQgO3bt2P//v1ITk4utU/dunXh5eWFTz/9lHe0VIANGzZg27ZteP78ORo3bow1a9agbt26mD59Ov7444+SfhKJBGPGjMHMmTMFplUtf/zxB86fP4+FCxdCQ0MDwMuLTnx9fXHt2jUAgFQqhUQigYGBAb7++mv06dNHZGS1FBYWBmNjY9ExVNrRo0dx6dIlaGpqwsnJCc7OzqX2O3jwIA4ePIidO3cqOSG9MnfuXBw6dAg3btwQHUVlPHnyBBs2bEBkZCS0tLTg5OSEcePGoXr16nJ9/fz8sHHjRo6/kj179gx5eXmiY6gtqVQK7uAp1pQpU+Dl5cULHipQSEgI9uzZg6tXr+LFixcyj1WvXh19+vTB+PHjeSE6EZGKMTIyQmZmpkybRCIp+Szov/Lz81GlShVlxVMq7tleieXn52Ps2LGIioqCVCpFtWrVSn6w69evDwsLC9y+fRspKSnQ0tLCkiVL0L9/f8GpVUdaWhrc3Nzw7NmzkrZ69erhp59+goeHB3R1ddGiRQs8fPgQMTExMDIyQnBwMN9YKlhoaCi+/vrrknkwMzPDjBkz4ObmJtfXz88PGzZsQGxsrLJjqiyOv1h8HRIrNzcXo0ePRkxMDKpWrYpWrVrBysqqZDnCnJwcJCQkICoqCnl5ebC3t8cvv/xSsrQSvb+TJ09i8uTJ0NfXR6NGjXDr1i1YWlrCw8MD3377Lbp164a2bdvi8ePH2LdvHzIyMrBy5UoWfBVk1KhRKCoqwm+//Qbg5YfJAwcOxI0bN9C8eXN07twZhoaGuHPnDoKCglBQUIAdO3agTZs2gpOrjq+//vqtffbu3Yv69evDwcEBwMs/fBcuXFjBydRDcXExpkyZgtOnT5cUUiQSCdq1a4fvvvsONWvWlOnP90LizZ07F0FBQZwDBcnKysLAgQORnJwsU0ysWbMmVq9eXfK68wqfA4rn6ur61j5xcXEwMjIqeU2SSCQ4cuRIRUdTC82bN39rn4KCAmhqakJTUxPAy/GPjo6u4GTqIyYm5q19vLy80LVrV3z++eclbbwIXTGKi4sxbdo0HD16VO6ikjp16kBfXx+JiYkoKCiAkZER1q5dy20gSW117doVWlpa6NOnD0aNGlXqhYlUsYKCgqCpqYlOnTpx5T0F8fLygqGhIX766aeStidPnuDx48do2LChXP/JkycjPj4eoaGhyoypFLyzvRLbsmULrly5guHDh2Pq1KkwNDREdnY21qxZA39/fyxevBitWrXClStXMH/+fMybNw82Nja8w11Bfv75Z2RlZWHJkiXo2bMnTp8+jdmzZ2PatGmoX78+tm3bVrKE//79+zF//nxs374ds2fPFpxcdcTExGD69OnQ0NBA+/btoa2tjXPnzmHWrFm4fPkyvvnmG9ERVRrHXzy+Donl5+eHmJgYjB8/HpMnT4aenl6p/fLy8kruvt6wYQPvrFag3bt3w8jICIcOHULt2rWRmpqKAQMGYMOGDRgzZozMz/rgwYPRp08f7Nu3j8V2Bbl79y569OhR8u8LFy7gxo0bpd45NGLECHh6emLLli0stivQ3r17S64afx2JRIK7d+/i7t27Jf9msV0x9u3bh1OnTqFp06YYM2YMtLS0sH//foSHh2PIkCHYsWMHl04llbZlyxYkJSVh6NChmDx5cslzYOPGjfjss8+wbt06dOzYUXRMlRYXF1em3wPPnj2TuUCXFOPV3Vn/XT7131JTU6Gjo8OiSgXx8vJ67ep6r0gkEpw8eRInT54saeNFP4qxc+dO/PHHH+jatSt8fHxQt25d3Lt3D35+foiMjMTWrVthYWGBP/74AytWrMDkyZNx+PBhbnNHaiklJQUAsHHjRvzyyy8YPHgw5syZIziVepkzZw4kEgn09fUxdOhQjB49umTJc3o3TZs2xeHDh2XuZDcxMSn1vVFRURGioqLQqVMnJadUDhbbK7EjR46gRYsWWLBgQUmbgYEB5s+fj+vXr2PNmjXYuXMnWrduje3bt8PV1RVbt27FqlWrBKZWHREREfjkk08wcOBAAEDfvn1x+PBhhIeHY8eOHSUFLgAYNGgQfvvtN5w9e5ZFLgXatm0bNDQ0sGPHDrRu3RrAyz9kZ82aBX9/f+Tn52PZsmVv/cOL3g3HXzy+Don1xx9/wMnJCdOnT39jPz09PcyYMQOxsbEIDQ1lsV2B7ty5g+7du5fsA1WnTh1069YNBw8exPDhw2X61q5dG927d8epU6dERFVJz549g5GRUcm/Y2NjIZFIMHHiRLm+9evXR8+ePREWFqbMiCpPT08PEonktVtGSaVSfPrpp+jUqRPGjh0rIKFqO3jwID766CPs3r27ZCm8nj17Yt++fVi8eDFGjhyJHTt28APlCjRq1Khy9Y+Li6ugJOrpxIkTaNKkicwFPOPHj4eTkxMmTJgAHx8frF27Fp07dxaYUrXZ2NggOTkZM2bMwLBhw0rtY2trC09PTyxevFjJ6VSfs7MzIiIi0Lt3b/j6+pa6ZZStrS369OnD8a9Aenp66NatW8nqAf8mlUoRFBQES0tLtGrVSkA61XbgwAE0atQI69evL9lWytbWFmvXroW7uzu+//57bN68Gf369YOdnR3c3d3x448/8vlAaunEiRMoLi7G7du3cenSJVy5ckV0JLUzYMAASKVS3L59Gz/99BN27txZsgUevZspU6bAw8MDxcXFpf4e/rc7d+6gc+fOKrv6NovtlVhqaiq6dOlS6mMtW7bE3r17S/790UcfoWvXrjh//ryy4qm8lJQUuf0YGzZsiPDwcDRp0kSuf7NmzRAcHKyseGohKioKXbt2LSn0Ai8LLa/u3A0KCsKLFy/w3XffseBbATj+4vF1SKxHjx6hb9++Ze5vZ2eHyMjICkykfjIzM+WuQn61RKqpqalcf1NTU+Tm5iolmzowNTXFvXv3Sv796gO21y3HZmBggIKCAqVkUxeHDx/GnDlz8N1332HixImYOHEitLTk/8QzNTWFo6OjgISq7c6dO+jXr5/cnnODBw+GmZkZfH19MWrUKOzcuZMF9woSGRn51rt6/4vvSxUnJSVF7uI2AGjcuDF+++03jBo1Cl988QXWrFmDrl27Ckio+vbv3w8/Pz8sWbIER48exZIlS1C3bl3RsdTG1q1b4e/vjxUrVuDUqVNYunQpWrRoITqWWpk2bRr8/PyQlJSEJUuWoH79+nJ9goKC4OjoyAJvBXi1usmrvwNe0dTURLt27XDgwIGStvr166Nz586IiIhQdkyiD8KrFa8sLCxeW9OhirV8+fKS/87OzkZUVJTANKqhRo0aZV4dwNbWFsuWLavgROJovL0Lfaj09fWRnp5e6mPp6elyb3Rq166NjIwMJSRTDxKJRO6DmldLCP/7btJXqlWrhsLCQqVkUxcZGRmwsrKSa9fS0sLKlSsxYMAABAcHY8aMGSguLlZ+QBXH8RePr0NimZqalmv5wb///rvUAjC9u1q1aiEhIUGm7dW/4+Pj5fq/2rOUFKN9+/Y4efIk0tLSAABt2rSBVCrFiRMn5PoWFBTg7NmzqFevnrJjqjQLCwvs3r0b06ZNw9atWzFo0CAui6pEUqn0tReXdO7cGevXr8fjx48xYsQIudcqUgxjY2M0bNgQZ8+eLdP/evfuLTqyStHT03vthQ4WFhbYuXMnatasialTp3Jlkwqira2N//3vf9izZw8ePnwINzc37N69W3QsteLl5YVDhw6hZs2aGD58OFasWIH8/HzRsdTGhAkTsH//fhQUFMDDwwNbt24t1wVY9H50dHReu0VFVlYWXrx4IdNmZWWFR48eKSMaEdEbGRgYwMXFRXQMUiEstldiLVu2xLFjx+Q+UIuNjcXRo0fRtGlTmfbHjx+jWrVqyoyo0mrUqCH3BrF+/fro3r17qf3T0tK4R5eCmZqa4smTJ6U+JpFIsGzZMvTv3x9HjhzBjBkzUFRUpOSEqo3jLx5fh8Tq3r07zp49i9WrV+P58+ev7ff8+XP88MMPOHfunMz+1vT+WrVqhZMnT+LUqVMoKirCiRMncPLkSTRt2hQrV66U+aAzIiICp0+fhr29vcDEquXVcvGjR49GZGQkmjZtCi8vLyxevBi7du3CvXv38OzZM0RFRWHixIlISEjAoEGDBKdWPRKJBGPHjkVgYCC0tbXh6emJNWvW8OIqJahdu3apF/a80rFjR6xbtw5Pnz7FyJEj39iX3k2TJk2QkJAAY2Nj1KxZ863/++8qBPR+zM3NcePGjdc+/t+C+9mzZ5WYTr3Y29vj0KFD8PLywtKlSzFixAgkJSWJjqU26tati507d2L27NnYu3cv+vXrh8uXL4uOpTYaNWoEf39/fPbZZ1i7di0GDx6Mu3fvio6lFuzs7HD8+HE8ePBApv3Bgwc4fvw4GjVqJNOekZEBfX19ZUakfxk1ahTGjh2LAwcO8DM6IlKIK1eucAXD/4/LyFdiEydORHh4OLy8vNC9e3eYm5vj3r17CAsLQ1FRET777DOZ/leuXIGNjY2gtKrHxsYGf//9t0xb7969X3u3RFxcXKl3AdO7+/jjj9+4JLNEIilZHubQoUN8Q69gHH/x+Doklo+PDy5evIgtW7Zg9+7daNWqFSwtLUvucszKykJiYiKioqKQk5MDW1tbeHt7C06tWiZOnIjQ0FBMnjy5ZBnhmjVrlnzI1rNnT9jb2+Pp06eIiooq2b+aFKNu3brw8/ODr68vPv30U1SvXh1169bF8+fPsXTpUixdurSkr1QqRc+ePTFy5EiBiVVb/fr1sW/fPmzevBkbN27EiRMnsGTJEtGxVFqzZs0QFhaG58+fv7aI26lTJ6xbtw5ffPEFQkJClJxQ9dnZ2eHcuXO4desWGjdu/Nb+vNtRsRwdHbF7926kp6eXbOPyX68K7qNGjUJ0dDSX8a9AOjo6mDt3Lrp164a5c+eiX79+8PX1FR1LrYwaNQouLi6YM2cORo0ahWHDhomOpDa0tLTg4+ODLl26YPbs2XB3d8fkyZMxfvx40dFU2tixYzFhwgT0798fXl5eJZ9N79+/H9nZ2RgxYoRM/7/++gsNGjQQlJZefYZ3/vx5+Pn5YezYsfz77D3Z2dnB2dkZgwYNQufOnd+6ZzVVnOzsbKSkpMDCwgJVq1YtaQ8PD0dkZCS0tLTg4uKCli1bCkypeoYPH45q1aqhf//+GDhwoFrXH3lneyXWvHlz/PDDDzAwMEBISAi2bt2K0NBQ6OrqYvHixTL7+GZnZ6Nfv358k6lAPXv2RL169cp05U58fDyuX7+Otm3bKiGZ+nB2dkZiYuIbrxh/VfAdMGAAcnJylJhO9XH8xePrkFgGBgbYs2cPJk+eDH19fYSHh2P37t3YtGkTNm3ahN27dyM8PBz6+vqYMmUK9uzZU+ry/vTuLC0tsWPHDjg5OcHS0hLdu3fHjh07UKdOHWzYsAGampo4duwYLl26BD09PXzzzTdo166d6NgqpUOHDggODoanpyeKi4vx119/4cWLF5BKpZBKpdDQ0EDr1q2xatUqrF27Vm6bI1IsDQ0NTJ48Gfv374eGhgaGDh3KwlYF6tKlC3JycnDw4ME39uvUqRPWr18PLS1e665orq6umDJlCnR0dMrUf8KECdixY0cFp1If3bt3R/Xq1REUFPTGfq8K7nXq1FFOMDXn4OCA4OBg9O/fHytWrBAdR+1YWVlhz549mDp1Kvz9/UXHUTt2dnYIDAzEyJEjsW7dOnh6evK9UAVycXHBl19+iby8PGzduhXffPMNtm3bhqysLEyaNAlubm4lfbOzs2FnZydXgCfl2blzJ7Zv344vv/wSzZo1w5YtW0RHqvRevHiBM2fOwMfHBx07dsTKlSu5fZQAW7ZsQbt27TBgwAB06NABgYGBAIAlS5ZgwoQJ2Lp1KzZt2oRhw4Zh5cqVgtOqnszMTOzcuRMDBgyAl5cXAgIC1LIOIJHy0u5KLz8/H1FRUUhPT4exsTFatWolc/UOiZeTk4OMjAyYmJiU7KdM7y8tLQ27d+9G8+bN0a1btzf2lUql8PPzQ2pqKpYtW6akhKqN41+58HWo4iUkJCAxMRFZWVkAAENDQ1haWnI1AYGKiooQFxeHwsJCNGzYsMzFGHp3ycnJePLkCYqLi2FoaIh69epx3AUpLCzEli1bEBsbiw4dOvDuugpQVFSEpKQk6Ovr46OPPnpr/7i4OKSnp8PR0VEJ6YiIgIsXL+LmzZto1KgRLzgUICEhAXfu3EHdunVha2srOo7auXr1KubMmYPExER4enpi8eLFoiOprIcPH+LPP/8s+Wy6Q4cOqFu3ruhYRBXO1tYWnTp1AvDyDuoXL15AIpGgTZs2GDhwIHr37g1dXV2xIVXc+fPnMWbMGNSoUQOtWrVCdHQ0nj59imXLlmHWrFkYOnQoOnTogLS0NPz4449IS0vDTz/9hPbt24uOrhJsbW0xYsQImJubIyAgAHFxcZBIJKhSpQp69+6NQYMGoVWrVqJjKgWL7URERERERERERESkUl68eIHc3Fzo6Oiw4EVECvdqu0Bvb288fPgQgYGBOHDgAJKTkyGRSGBgYIC+ffti0KBBsLOzEx1XJU2cOBFXrlxBSEgITE1N8fTpU7i6uqKgoABDhgzBzJkzS/qmpKSgV69e6NKlC9auXSswter493MAeHmhW0BAAP744w/k5uZCIpGgfv36GDRoEPr16wcTExPBiSsO13EkIiIiIiIiIqL3UlhYiLi4OFy7dg0xMTFISUkRHYmI1JympiYMDQ1ZaCeiCmdmZoaJEyfi+PHj2LlzJ/r27YvCwkLs2bMHgwYNgru7O3799deS1RBJMW7duoWuXbvC1NQUAGBsbIwuXbogNzcXXl5eMn3Nzc3h4uKCa9euiYiqFlq2bImlS5fi7NmzWLx4MZo3b447d+5gxYoV6NixI3x9fXH27FnRMSsEN41TAWfOnEFSUhIaNmyITz75BMDL5YI3b96MyMhIaGlpoWPHjhg9ejSX8awAHH8iEq2wsBC3bt2CpqYmbGxsXrsn3c2bN3Hz5k0MGDBAuQFVHMe/8ggICEBUVBS3sxCE4y8e50Asjr94nIOKERISgj179uDq1at48eKFzGPVq1dHnz59MH78+DJtt0DlY2dnB2dnZwwaNAidO3eGpqam6EgE4O+//8aGDRsQFRWFvLw8mJubw83NDePGjePnQqRyHj9+jH379uHJkydo3749unTpAgC4fv06Vq9ejRs3bkBHRweffPIJfHx8uLy8gvXo0aPk90Djxo1Fx6H/z9HREY6OjsjOzsahQ4dw4MAB3LhxA4sXL8bKlStx9epV0RFVxqNHj+TeY5qZmQF4WVz/r3r16uHPP/9USjZ1VrVqVXh6esLT0xN3795FQEAADh8+jKNHj+LYsWOIjY0VHVHheGd7JVZUPBWIgQABAABJREFUVITPPvsMEydOxJIlSzBmzBjMnz8fxcXFGD9+PLZu3Ypr167hypUrWL16NcaNG4fi4mLRsVUGx79ySU5ORteuXd+6tzhVDI5/xQkNDYWTk1PJVbKdOnVCcHBwqX3DwsIwd+5cJSdUbRz/yiUqKgpBQUGiY6gtjr94nAOxOP7icQ4Uq7i4GFOnTsX06dNx6dIlFBUVQSqVQiqVonbt2mjQoAFycnKwe/duuLm54fz586Ijq5wXL17gzJkz8PHxQceOHbFy5UokJCSIjqU2GjdujA0bNsi0nT17FkOHDsXJkyeRl5cHQ0NDxMXFYd26dZg4cSK4m6fiPXnyBIsXL4abmxvc3d2xatUqZGRklNrXz88PTZo0UW5AFZaeng53d3esX78eu3fvxpQpU7Bp0ybcuXMHI0eOREREBIqLi/H48WMcOnQIQ4YMQVpamujYKiUpKQm//fYbPDw84OHhgT179iA7O1t0LPr/DAwMMHz4cAQGBiIoKAjDhw/nRVcKZmBgIPcz/+riQy0t+XuNi4uLoa2trZRs9FL9+vUxZ84c/Pnnn1i7di2cnZ1FR6oQLLZXYocPH8bZs2fh4OCAefPmwcnJCQcOHMCqVatw584drFmzBpcvX8aRI0fQoUMHXL58GQcOHBAdW2Vw/CuXwsJCpKSkcClDQTj+FSMmJgbTp09HTk4O2rdvj44dO+Lp06eYNWsWFi5cKDqeyuP4ExERkTrbuXMn/vjjD3Tp0gVBQUG4fPkygoKC0K1bN2RnZ5f8Tfzdd99BW1sbkydPRnJysujYKqdjx44l70O3bduG3r17Y+TIkQgKCkJ+fr7oeCrt1cUlrxQWFmLu3LnQ1NTEkiVLcPXqVZw9exYnT56Eg4MDzp8/j/379wtMrHqysrIwZMgQ/Pbbb7h9+zZiY2OxdetW9O3bF5cuXSr1GF7woDi//PILHj58iBEjRuDnn3/G8OHDsWXLFvzwww8wMzNDUFAQLl68iKioKIwfPx7p6enYsmWL6Ngqp2XLlmjQoAFu3LiBRYsWwdnZGXPmzHntc4DEsLW1xYIFCxAeHi46ikqpVauW3OfNffv2xaZNm0rtf//+fdSsWVMZ0eg/tLS00LNnT/z444+io1QILiNfiQUEBMDc3Bzbt2+HhoYGRowYgT59+uCXX37BV199hV69egF4eXWPn58fOnXqhCNHjsDT01NwctXA8a9c6tWrhxMnToiOobY4/hVj27Zt0NDQwI4dO9C6dWsAQGpqKmbNmgV/f3/k5+dj2bJlr13WnN4Px1+88t6dmJiYWDFB1BTHXzzOgVgcf/E4B2IdOHAAjRo1wvr166Gh8fJeDltbW6xduxbu7u74/vvvsXnzZvTr1w92dnZwd3fHjz/+iMWLFwtOrlqaNm0Kb29vPHz4EIGBgThw4AAuXbqEy5cvY8mSJejbty8GDRoEOzs70VFV3vnz5/Ho0SP4+vpi4MCBJe116tSBn58fevTogcOHD/NzIQXasmULkpKSMHToUEyePBlaWlrYv38/Nm7ciM8++wzr1q1Dx44dRcdUWadPn0br1q0xb948AED79u3x999/49SpU/jxxx9ha2sLANDR0cH06dNx8eJFFhorQPv27eHt7Y2YmBgEBAQgJCQEQUFBOHToECwtLUtW4qtRo4boqATwznYFs7OzQ1hYmEyblZUVrKysSu1/7do1tGrVSgnJ1EOdOnVgZGQkOsYHgcX2Siw5ORndu3cv+aNWIpGgXbt2iI+PR+fOnWX6VqlSBS4uLnxDo0Ac/8pFS0ur1H1aSDk4/hUjKioKXbt2LSn0Ai/f5Gzfvh2zZ89GUFAQXrx4ge+++44F3wrA8Rdvzpw55RpbqVTKuVAgjr94nAOxOP7icQ7EelXgevU38Suamppo166dzMpu9evXR+fOnREREaHsmGrDzMwMEydOxMSJExEZGYmAgAAcP34ce/bswd69e2Fra4tBgwahX79+MDQ0FB1XJcXFxUEikaBv375yjxkZGcHZ2Zn7xCrYiRMn0KRJE5mVxcaPHw8nJydMmDABPj4+WLt2rdzndKQY9+/fl7uYoWXLloiOji61mNWqVSv8+uuvyoqnduzt7WFvb48vv/wSoaGh2L9/P6KiorBq1SqsWbMGnTp1gqenJ1xcXPh+SEFOnDjBQqNg48aNg7OzMwoLC9+6PPzff/+NevXqoXfv3kpKp/pOnjwpOsIHg8X2SuzZs2dyL+bVq1cHAHz00Udy/T/66CNkZWUpI5pa4PgTkWgZGRmlXqmppaWFlStXQltbG0FBQSguLsb333+v/IAqjuMvnra2NszMzDB48OAy9f/jjz8QGxtbwanUB8dfPM6BWBx/8TgHYuno6ODZs2elPpaVlYUXL17ItFlZWfEDOSVxdHSEo6MjsrOzcejQIRw4cAA3btzA4sWLsXLlSly9elV0RJVUUFAAoPTPhACgdu3ayMnJUWYklZeSkoLhw4fLtTdu3Bi//fYbRo0ahS+++AJr1qxB165dBSRUbbq6uiU/96+8+vfz58+hr68v89jz589L9lKmiqOnp1eyh3t8fDwCAgJw+PBhhIWF4cSJE/joo49w+vRp0TFVAm8sEs/a2hrW1tZl6mtnZ4ddu3ZVcCJSVyy2V2LVqlXD06dP5dpft/dQdna23Jscencc/w9LQUEB/vrrLyQmJpZc1GBoaAhLS0s0a9aMS/RUMI6/GKampnjy5Empj0kkEixbtgxSqRSHDh2CVCpFvXr1lJxQtXH8xWvUqBHu37+PCRMmlKl/fHw8iywKxPEXj3MgFsdfPM6BWHZ2djh+/Di++OIL1KpVq6T9wYMHOH78OBo1aiTTPyMjg38TK5mBgQGGDx+O4cOH4+bNmwgICMDvv/8uOpZKyc7ORmpqKgCU/Hw/ffq01IL7kydPuKqAgunp6b32czgLCwvs3LkTo0aNwtSpU7F69Wolp1N9lpaWCA8Px4sXL6CpqYmioiKEh4dDS0sLJ0+elNkyoaCgAOHh4bCwsBCYWP1YW1tj1qxZmD59Ok6dOoX9+/dz5VUiogrAYnslZmlpifj4eJm2iRMnYty4caX2T0lJgZmZmTKiqQWO/4fh6dOnWLNmDYKDg5GXlwfg/y54eLUkkp6eHvr16wdfX18YGxsLy6qKOP5iffzxx4iMjHzt4xKJBMuXLwcAHDp0iB9uKhjHXzw7OzvcuHED9+/fR+3atUXHUTscf/E4B2Jx/MXjHIg1duxYTJgwAf3794eXlxfMzc1x79497N+/H9nZ2RgxYoRM/7/++gsNGjQQlJZsbW2xYMECzJ49W3QUlbJjxw7s2LFDpi06Oho9e/aU65uYmChzYQq9P3Nzc9y4ceO1j/+34N60aVMlplN9gwYNwvz58zF8+HB88sknOH/+PJKSkjB37lwsX74cBQUFcHR0xJMnT7BlyxakpqaW+QI5UixNTU1069YN3bp1w8OHD0XHUTl3795FYmIiGjZsWHJBSXFxMfz9/REZGQktLS106tQJrq6ugpOqNt4MJkZ+fj4OHDiApKQkNGrUCP3794empibS0tKwYsWKkudAx44dMXXqVJWtD7DYXonZ2dlh3759KCoqgpbWy6nU1tYudW+K58+f48qVK+jTp4+yY6osjr94T548wZAhQ5CUlAQLCwu0b98eVlZWMDAwAPDyCvOEhAScO3cOe/fuLfl/ExMTwclVA8dfPGdnZyxfvhyXL19GmzZtSu3zquArkUgQFBTEfbkUiOMvXps2bXD27FkkJCSUqchS2r6B9O44/uJxDsTi+IvHORDLxcUFX375JVauXImtW7dCIpFAKpVCU1MTkyZNgpubW0nf7Oxs2NnZoUOHDgITEwB+0KxA7u7upbaXtlR8Wloarl69Cg8Pj4qOpVYcHR2xe/dupKeno2bNmqX2+XfBPTo6mn+TKZC7uzvOnDmD48ePIzo6GgDw6aefYtSoUbh9+zYWL15cMt5SqRT169fH+PHjBSYmALwZTMG++uorBAQEAHj5GdCUKVMwZcoU+Pr64vjx4yX9goODERYWhh9++EFUVJXFm8HEef78OYYOHYqbN29CKpVCIpEgNDQU69atw7hx43Dnzh1Uq1YNT548wb59+xAVFYX9+/dDV1dXdHSFk0hft9YOffAKCgqQk5NTpheHu3fvIjQ0FJ07d4adnZ0S0qk+jr94r97MLFy4EEOGDHlj3z179mDRokXw9PTEokWLlJRQtXH8xUtLS8Pu3bvRvHlzdOvW7Y19pVIp/Pz8kJqaimXLlikpoWrj+BMREREBDx8+xJ9//on09HQYGxujQ4cOqFu3ruhYaiElJQVGRkZcmrwSSE9PR1xcHOrVq8e72xXoypUr8PX1xejRo/HZZ5+9sW9ycjI+/fRT3L9/n1uKKFhMTAzu3buHBg0alGwhIpVKS5YsLygoQKtWrTBs2LCSGzRIMSIjI2Fubs69wwU5fvw4fHx8UL9+fTg7O+P8+fO4desWZs2ahR9++AFTp05Fhw4dkJaWhtWrV+Off/7B6tWr0atXL9HRVUZ5bgZLTk5GvXr1eDOYAm3fvh3Lly9Hv3790KtXL5w+fRoBAQHo168fLl68iPXr16NZs2bIzc3FkiVLEBgYiFmzZmHMmDGioysci+1EVGk5OzujZcuWWLduXZn6f/HFF7h69Sr3JlIQjj8RERERERERERGpo9GjR+POnTs4duwYqlativz8fPTq1Qvp6enw8fGR2TYhIyMDnTt3Rtu2bbF582aBqVULbwYTa+DAgSgoKEBwcLBM240bN7By5UqZlZ6LiorQrVs31K5dG3v27BERt0JpiA5ARPSuMjMzYWVlVeb+lpaWyMzMrLhAaobjT0REREREREREROooPj4enTt3RtWqVQEAurq6cHFxQVFREfr27SvTt3r16ujUqROuX78uIqrKOnXqFLp37/7WQjsADB06FN27d8epU6eUkEw9pKSkoG3btjJtrVu3BgB88sknMu1aWlpo164d4uLilJZPmbhnOxFVWrVr10ZkZGSZ+1+6dKlMezlS2XD8iYiIiIjo/v37OHjwIC5duoTExERkZWUBAAwNDWFpaQlHR0f0798fderUEZxUdXEOxOL4f9jy8/OhoaEBbW1t0VFU1v379/H06VM0aNAAOjo6AF4uI3/kyBHcuHEDOjo6aNu2Ldq1ayc4qfq4desWdu3ahevXr+P58+cwNzeHq6sr3N3dS/awpvf35MkTueXIa9SoAQClfgZap04dZGRkKCOa2niXm8FOnz5dYXnUTV5eHvT19WXajIyMAPzfc+HfTE1NkZOTo5RsysY729VEcnIyunbt+tY9ZalicPwrhpubG6KjozFz5kzcv3//tf3u37+PGTNm4Nq1a+jXr58SE6o2jn/lwtchsTj+4nEOxOL4i8c5EIvjLx7noGJs374dPXv2xLp163D+/HlkZGRAT08Penp6yMjIwPnz57F27Vr06tUL27dvFx1XJXEOxOL4i/f48WN8//338PHxwfr160sudrh16xYGDx6Mli1bokWLFvjss8+QlJQkOK1qKS4uxpdffokuXbpg4MCB6NatG2JiYpCfn49hw4Zh5syZ+Pnnn7F582aMHTsWU6dOBXe0VaxFixahXbt2KC4uLmkLCQnBwIEDERAQgNjYWMTHx+Ps2bOYN28eJk2aJNOX3o+RkZHcKp4SiQRSqbTUixry8/NRpUoVZcVTC7wZTCxjY2M8fvxYpk1XVxfVqlUrtX9GRgYMDQ2VEU3peGe7migsLERKSgqvXBOE418xJkyYgKtXryI4OBi///47rK2tYWlpWfKCnZWVhcTERMTHx0MqlcLJyUlmrxx6Pxz/yoWvQ2Jx/MXjHIjF8RePcyAWx188zoHihYaGYvny5bCyssLEiRPh5OSEmjVryvRJT09HeHg4Nm/ejBUrVqBWrVro1auXoMSqh3MgFsdfvMzMTHh6euL+/fuQSqU4fvw4Tp8+ja1bt2L8+PF4+vQpbGxs8OjRI5w9exajRo3C4cOHS+66o/cTHByMwMBA1KlTB61atUJUVBRmzJiB/v37IyYmBqNGjULbtm3x+PFj/Pzzzzh69Cj27NmDYcOGiY6uMi5dugQHBwdoaLy8pzIjIwPz58+Hrq5uyYUQRkZGuH37NtavX48zZ85g+/btGDt2rODkqsHc3BzJyckybcOHD3/t63xqaipMTU2VEU1tuLm5wc/PDzNnzsS0adNeW0i/f/8+Vq1ahWvXrsHb21vJKVWXtbU1bt++LdM2fvx4jB8/vtT+ycnJKnuxg0TKy8nUQlFREdLS0gC8/CVAysXxrzhSqRSBgYEICAhATEyM3NWZGhoasLe3h5eXF5dKqgAc/8qDr0NicfzF4xyIxfEXj3MgFsdfPM6B4g0ePBjp6ek4dOgQDAwM3tg3KysL/fv3h6mpKfbt26ekhKqPcyAWx188Pz8/+Pn5YdKkSejVqxdOnz6N1atXw8nJCQ8ePMC2bdtQq1YtAMD69euxYcMGeHt7s9CiIMOGDUNycjJCQ0NhYGCAZ8+ewdXVFTk5OZg8ebJMseXZs2fo1asX6tatC39/f4GpVUurVq0wZMgQzJo1CwBw+PBhzJo1CytXrpTbM7ywsBAeHh4AXl4oQe9v0aJFOHz4MC5duvTWzzyLiorg5OSETp06Yfny5UpKqPoKCgowadIkREREQCKRlOlmsE2bNnFrEQVZu3YtfvvtN4SHh5dsI/I6mZmZcHZ2xuDBgzFv3jwlJVQe3tmuJrS0tPiBgkAc/4ojkUgwcOBADBw4EAUFBUhKSpLZH83CwgK6urqCU6oujn/lwdchsTj+4nEOxOL4i8c5EIvjLx7nQPFu3bqFIUOGvLXICLz826Bnz57Yu3evEpKpD86BWBx/8Y4fP44WLVrA19cXAGBjY4OzZ88iIiICmzZtKim0A4CPjw9CQkJw6tQpFtsVJDExET169Ch5DhgZGaFr167w9/eX20bQyMgIXbp0QWhoqIioauPBgweQSCTo1KmT3GPa2tpo164dX4cUaMqUKfDw8EBxcTE0NTXf2PfOnTvo3Lkz+vfvr6R06kFHRwfbtm2TuRksLi5Opo+GhgaaN2/Om8EqgK+vb8nv4Ld59uwZvvnmG7Rq1aqCU4nBYjsRqQwdHR00aNBAdAy1xfEnIiIiIlIfWlpayMnJKXP/nJwcaGnxYyhF4hyIxfEXLzU1Fe7u7jJtTZs2xeXLl9GiRQu5/m3atGGxV4Fyc3PlLjZ5dTdpaUv1GxkZIT8/XynZ1IW1tTWio6NL/m1iYgLg5R2kpV0I9OzZM+jp6SkrnsqrUaMGatSoUaa+tra2WLZsWQUnUk+8GaxysLCwgIWFhegYFYbv8FREQUEB/vrrLyQmJsq8kFhaWqJZs2ZvXcKB3g/Hn4hE4+uQWBx/8TgHYnH8xeMciMXxF49zoHwtWrRASEgIhg8fDhsbmzf2vXnzJo4cOYLWrVsrKZ164ByIxfEXr6ioSK6Aoq+vDwCoXr26XH9jY2M8f/5cGdHUQp06dfDPP//ItL36982bN9GyZUuZx2JjY0uKwaQYffv2xXfffYeQkBC4urqia9euWL58Ofz8/OQKu7du3cLRo0fh4OAgKC1RxePNYCQKi+2V3NOnT7FmzRoEBwcjLy8PwMs9lAGULIehp6eHfv36wdfXF8bGxsKyqiKOvzjjxo2Dr68v7O3ty31sbm4udu/eDX19fQwfPrwC0qk+jv+Hg69DYnH8xeMciMXxF49zIBbHXzzOgTg+Pj4YNmwYvLy84Obmhvbt28PKykpmj8yEhARERETg999/R3FxMXx8fASnVi2cA7E4/uIZGxsjPT1dps3MzAxNmjQptX96ejqqVaumjGhqoV27dvjtt9+we/duuLi44MyZM4iIiICzszOWLl2KLVu2lBTXAwICcP78efTu3VtwatUyYsQIhISEYMaMGQgPD0fPnj3h7e2N77//Hv/88w86d+4MQ0ND3L17F8HBwSgqKsKkSZNEx1YbOTk5eP78OYyNjaGhoSE6DhFVIIn01V+hVOk8efIEQ4YMQVJSEiwsLEre1L9aIiY7OxsJCQk4d+4ckpOTUa9ePezdu5dXECoIx18sDw8PxMbGok2bNhgwYAB69OhR8gft60RHR+Pw4cM4cuQI8vPzsXz5cvTq1UtJiVULx//DwNchsTj+4nEOxOL4i8c5EIvjLx7nQLwLFy5gwYIFSE5Ofu3+l1KpFBYWFvj222/Rtm1bJSdUfZwDsTj+Yn3++edIS0tDUFBQmfoPHz4cL1684J7VCvLw4UP069cPmZmZJW1WVlbYu3cvhgwZggcPHuDjjz/G06dPcf/+fWhqamLv3r1o2rSpwNSq59mzZ5g7dy5OnDhR8joklUplXpOkUimMjY2xePFidOvWTVRUlZOamgojIyO5JftPnTqFNWvW4NatWwBeXvjp6uqKmTNn8oIfwX788UecPXsWO3fuFB1F7cTFxaFPnz6QSCS4ceOG6DgKx2J7JfbVV18hICAACxcuxJAhQ97Yd8+ePVi0aBE8PT2xaNEiJSVUbRx/8Q4ePAg/Pz+kpKRAQ0MD1tbWsLOzQ40aNUr2gcrMzER8fDyuX7+OnJwcaGpqwtXVFVOnTkWdOnVEfwuVGsdfPL4OicXxF49zIBbHXzzOgVgcf/E4Bx+GFy9e4MKFC4iMjERCQgKys7MBAAYGBrCysoKDgwPatWsHTU1NwUlVF+dALI6/ODt37sSBAwcQEBDw1u1C0tLS0LVrV4wZMwbTp09XUkLVl5ycjJ9++gn37t1Dw4YN8dlnn6FGjRpISkrC7NmzcfXqVQAv9xafO3cuXFxcBCdWXdeuXcORI0dw48YNPH78GMXFxTA0NIS1tTU++eQT9OzZs9R93OndNW7cGN7e3pgyZUpJW1BQEL788ktIpVLUq1cPxsbGuH37NnJycmBrawt/f39ubyTQ3LlzERQUhNjYWNFR1E5cXBxcXV0BvNxqRNWw2F6JOTs7o2XLlli3bl2Z+n/xxRe4evUqwsPDKziZeuD4fxikUinOnDmDwMBAXLx4UeZq2lc0NDRgY2ODbt26wdPTE2ZmZgKSqiaOv1h8HRKL4y8e50Asjr94nAOxOP7icQ6IiKisHj16hPj4eHz88ceoWbOm6DhqIycnB4WFhahevbroKEQKZ2trC29vb3h7ewN4uXVmp06dIJFIsGbNGrRr1w4AkJeXh/nz5yMkJASzZs3CmDFjRMZWayy2U0Xhnu2VWGZmJqysrMrc39LSEqdPn66wPOqG4/9hkEgk6NSpEzp16gQAuHv3Lh48eICMjAzo6urCxMQEDRs2fOsS5/RuOP5i8XVILI6/eJwDsTj+4nEOxOL4i8c5ICKisjI1NYWpqanoGGpHX19fdAQipTl37hyePXuGBQsWlBTagZfLyC9duhRXrlzBH3/8wWK7Avn5+ZWrP4vsVFFYbK/EateujcjIyDL3v3TpEmrXrl2BidQLx//DVL9+fdSvX190DLXF8Vcuvg6JxfEXj3MgFsdfPM6BWBx/8TgHREREHw6pVIqUlBSZrRTq1KkDDQ0NwcmIlCMxMRESiQSdO3eWe0xXVxft2rXD8ePHBSRTXX5+fpBIJCjPAt4SiaQCE5G64m+6SszNzQ3R0dGYOXMm7t+//9p+9+/fx4wZM3Dt2jX069dPiQlVG8efiETj65BYHH/xOAdicfzF4xyIxfEXj3NQeSQnJ6Nr167o1q2b6Chqi3MgFse/Yt2/fx8bN27EmDFj0KVLFzg4OMDBwQFdunTBmDFjsGnTJqSmpoqOqbJCQkIwevRoNG/eHN27d4e7uzvc3d3RvXt3tGjRAmPGjEFISIjomISXS2g3adJEdAyVVVxcDACv3aqiZs2aeP78uTIjqTw9PT3Uq1cPP/zwQ5n+5+DgIDqyynrw4AEOHz6M9evXY+nSpVi6dCnWr1+Pw4cPv/FvNVXBPdsrsYKCAkyaNAkRERGQSCSwtraGpaVlyXLNWVlZSExMRHx8PKRSKZycnLBp0yZoa2sLTq4aOP5EJBpfh8Ti+IvHORCL4y8e50Asjr94nIPKIy4uDq6urpBIJFy+UxDOgVgc/4qzfft2/PDDDygoKAAAVK1aFQYGBgCA7Oxs5ObmAgB0dHQwbdo0jB49WlRUlVNUVARfX1+cPHkSUqm05Pfwv8f/1e9hiUSCLl26YO3atdDS4mK7onC/asWytbWFu7s7PDw8AACRkZHw8/NDWFgYzM3N5frPnTsXf/75JyIiIpQdVWUNHToUd+7cwaVLl8rUn88BxUtKSsKiRYtKfq7/W3J+tZKAk5MT5s+fD0tLS6VnVAYW2ys5qVSKwMBABAQEICYmpuTqqVc0NDRgb28PLy8vuLu7c4kMBeP4E5FofB0Si+MvHudALI6/eJwDsTj+4nEOKoeioiKkpaUBQKkfPlPF4xyIxfGvGKGhofjf//4HKysrTJw4EU5OTnJ3lKanpyM8PBybN29GUlISVq9ejV69eglKrFo2b96MNWvWoE+fPpg+fTrq1KlTar/U1FSsWrUKISEhmDp1Kj7//HMlJ6VXWGhULFtbW5n3llKpFBKJBEuXLoW7u7tcfy8vLwCAv7+/0jKqum+//Ra//vorjh49inr16r21P58DipWcnAxPT09kZGTA0dERTk5OsLKykrnoKiEhAeHh4bh06RKMjY3h7+8PCwsLwckVj8V2FVJQUICkpCRkZWUBAAwNDWFhYQFdXV3BydQDx5+IROPrkFgcf/E4B2Jx/MXjHIjF8RePc0BEpF4GDx6M9PR0HDp0qOSD/dfJyspC//79YWpqin379ikpoWrr1asXqlevjr1795ap/+DBg5GZmYk//vijgpOpj1GjRpWrf1xcHB4/fsxCo4L4+fmV2m5rayu3bUhCQgJ69+6N4cOHY/78+cqIpxZOnTqFn3/+GVOnTkXr1q3f2j8sLAw3b96Et7e3EtKpvunTp+PYsWPYsGEDXFxc3tj3zJkz8Pb2Ro8ePbBq1SolJVQeFtuJiIiIiIiIiIiIqFJp2bIlhgwZgtmzZ5ep/4oVK7B3715cvXq1gpOpB3t7e4wePRrTpk0rU/9Vq1Zhx44diImJqeBk6uPVndXlKfFwOwsxcnJykJGRgWrVqr314iCiyqJdu3ZwcXHBihUrytR/1qxZCA8Px/nz5ys4mfJxgxQiIiIiIiIiInpnBQUF+Ouvv5CYmCizsoClpSWaNWsGHR0dwQlVH+dALI6/GFpaWsjJySlz/5ycHO4XrkBGRkZITEwsc//ExEQYGRlVYCL1Y2xsDFNTU/z8889l6r9kyRKuLCCIvr4+9PX1RccgUqjc3FyYmZmVub+ZmRlyc3MrMJE4fHdRSY0bNw6+vr6wt7cv97G5ubnYvXs39PX1MXz48ApIp/o4/kQkGl+HxOL4i8c5EIvjLx7nQCyOv3icgw/D06dPsWbNGgQHByMvLw8ASu6ue7WHqZ6eHvr16wdfX18YGxsLy6qqOAdicfzFatGiBUJCQjB8+HDY2Ni8se/Nmzdx5MiRMi0zTGXj4uKCoKAg+Pv7l+xF/Tp79+5FWFgYPDw8lJROPTRp0qRkH2RNTc239q9SpYoSUqm34uLikouA9PX1oaGhITgRUcWpV68eTp8+DV9f37dezFZYWIgzZ86gXr16SkqnXCy2V1JPnz7F4MGD0aZNGwwYMAA9evSAoaHhG4+Jjo7G4cOHceTIEeTn52P58uVKSqt6OP5EJBpfh8Ti+IvHORCL4y8e50Asjr94nAPxnjx5giFDhiApKQkWFhZo3749rKysSpZGzc7ORkJCAs6dO4e9e/eW/L+JiYng5KqDcyAWx188Hx8fDBs2DF5eXnBzcyuZg1e/D7KyspCQkICIiAj8/vvvKC4uho+Pj+DUquN///sfzp07h4ULF2Lbtm1vfA4kJyejVq1amDp1qtjQKsbOzg7nzp3DrVu30Lhx47f2547CFePatWvw9/fHpUuXkJKSguLiYgAvL7qqW7cuHB0dMWjQILRo0UJsUCIF8/LywpIlSzB27Fj4+vqiVatWJRcbviKVSnHlyhWsXbsWd+7cwbx58wSlrVjcs70SO3jwIPz8/JCSkgINDQ1YW1vDzs4ONWrUgJGREfLz85GZmYn4+Hhcv34dOTk50NTUhKurK6ZOnYo6deqI/hYqNY4/EYnG1yGxOP7icQ7E4viLxzkQi+MvHudArK+++goBAQFYuHAhhgwZ8sa+e/bswaJFi+Dp6YlFixYpKaHq4xyIxfH/MFy4cAELFixAcnKy3Af8r0ilUlhYWODbb79F27ZtlZxQtaWnp+P7779HaGgoCgoKAPzfqg6vyg7a2tro06cPpk+fDlNTU2FZVdHNmzcRFhaG3r17o379+m/tHxcXh/T0dDg6OiohnXr49ttv8euvv0IqlUJPTw9169aVueDk3r17yMvLg0QiwYgRI1S20FgZxMXFoU+fPpBIJLhx44boOCpBKpViwYIF2L9/PyQSSclz4N8Xvb16DkilUnh6emLx4sWCU1cMFtsrOalUijNnziAwMBAXL15EZmamXB8NDQ3Y2NigW7du8PT0LNceCvRmHH8iEo2vQ2Jx/MXjHIjF8RePcyAWx188zoE4zs7OaNmyJdatW1em/l988QWuXr2K8PDwCk6mPjgHYnH8PxwvXrzAhQsXEBkZiYSEBGRnZwMADAwMYGVlBQcHB7Rr165My2zTu8nJyUF0dHSp49+8efOS4iORKtmzZw+++eYbtGnTBr6+vmjdurXcsvHFxcW4fPky1q5di6ioqDJdoEUVIy4uDq6urgBeXqhCinPhwgUEBAQgMjISjx49knnM1NQUjo6O8PLyUukL3lhsVzF3797FgwcPkJGRAV1dXZiYmKBhw4ZvXU6PFIPjT0Si8XVILI6/eJwDsTj+4nEOxOL4i8c5UB57e3uMHj0a06ZNK1P/VatWYceOHYiJiangZOqDcyAWx5+ISL31798fxcXFOHjwYJn2q/bw8ICGhgYOHTqkpIREypeXl4esrCwAgKGhIfT09AQnUg7u2a5i6tevX6YlY6hicPyJSDS+DonF8RePcyAWx188zoFYHH/xOAfKU7t2bURGRpa5/6VLl1C7du0KTKR+OAdicfyJ6ENUXFyMnJwcAIC+vr7cndakOAkJCRg1atRbC+3Ay+0UOnbsiF27dikhGZE4enp6alNg/ze+0hIRERERERERUbm4ubkhOjoaM2fOxP3791/b7/79+5gxYwauXbuGfv36KTGh6uMciMXxJ3rp/v372LhxI8aMGYMuXbrAwcEBDg4O6NKlC8aMGYNNmzYhNTVVdEyVdu3aNcybNw89evRAs2bN4OjoCEdHRzRt2hQ9evTA/PnzER0dLTqmytHT05NbMvtNHj16pJZFSFJPYWFhmDt3rugYSsNl5ImIiIiIiIiIqFwKCgowadIkREREQCKRwNraGpaWliVL9mdlZSExMRHx8fGQSqVwcnLCpk2boK2tLTi56uAciMXxr1ySk5MxevRoSCQShIWFiY6jMrZv344ffvgBBQUFAICqVauW7M+enZ2N3NxcAICOjg6mTZuG0aNHi4qqsr799lv8+uuvkEql0NPTQ926dWXm4N69e8jLy4NEIsGIESMwb948wYlVh6+vL06dOoWNGzfCycnpjX3//PNPTJkyBV27dsWaNWuUE1DNPHjwAJGRkUhMTJRZxtzS0hIODg5cXUbJ/Pz8sGHDBsTGxoqOohQsthMRERERERERUblJpVIEBgYiICAAMTExKC4ulnlcQ0MD9vb28PLygru7OyQSiaCkqotzIBbHv/KIi4uDq6srJBKJ2nzwX9FCQ0Pxv//9D1ZWVpg4cSKcnJxQs2ZNmT7p6ekIDw/H5s2bkZSUhNWrV6NXr16CEquePXv24JtvvkGbNm3g6+uL1q1byy0bX1xcjMuXL2Pt2rWIiorCwoULMWTIEEGJVUtCQgIGDRqEnJwcfPLJJ2jfvj2srKxkLnZISEhAREQELl68CENDQ/j7+8PKykpscBWTlJSERYsWISIiAsDL383/9up3r5OTE+bPnw9LS0ulZ1RHLLYTERERERERERGVQ0FBAZKSkmTuJLKwsICurq7gZOqDcyAWx//DVlRUhLS0NACAubm54DSqYfDgwUhPT8ehQ4dKiouvk5WVhf79+8PU1BT79u1TUkLV179/fxQXF+PgwYNv3Te8sLAQHh4e0NDQwKFDh5SUUPXduXMHX3/9NS5fvgwAchdVvSq/OTg4YOHChWjQoIHSM6qy5ORkeHp6IiMjA46OjnBycir1gofw8HBcunQJxsbG8Pf3h4WFheDkqk/diu1vfgUmIiIiIiIiIiJ6Cx0dHX6ALBjnQCyO/4dNS0uLRXYFu3XrFoYMGfLWQjvw8uKTnj17Yu/evUpIpj4SEhIwatSotxbaAUBbWxsdO3bErl27lJBMfTRo0AC7d+9GQkICIiMjkZCQgOzsbACAgYEBrKys4ODgAGtra8FJVdOaNWuQk5ODH3/8ES4uLq/tN2HCBJw5cwbe3t5Ys2YNVq1apcSUpA5YbCciIiIiIiIiIiIiojLT0tJCTk5Omfvn5OSUqShMZaenp4dHjx6Vuf+jR4+gp6dXgYnUl5WVFZeHF+DcuXNwdXV9Y6H9lY4dO6J3794IDw9XQjJydHQUHUGpNN7ehYiIiIiIiIiI6KVx48YhJibmnY7Nzc3Fjz/+iF9//VXBqdQL50Asjv+Hp6CgAFeuXEFgYCB27NiBHTt2IDAwEFeuXEFBQYHoeCqpRYsWCAkJwT///PPWvjdv3sSRI0fQsmVLJSRTH23btkVISAjOnj371r5//vknQkJC8MknnyghGZFy5ObmwszMrMz9zczMkJubW4GJ6BVHR0d4e3uLjqE0vJSMiIiIiIiIiIjK7OnTpxg8eDDatGmDAQMGoEePHjA0NHzjMdHR0Th8+DCOHDmC/Px8LF++XElpVRPnQCyO/4fj6dOnWLNmDYKDg5GXlwfg//ZIfrV3sp6eHvr16wdfX18YGxsLy6pqfHx8MGzYMHh5ecHNzQ3t27eHlZVVyXMhKysLCQkJiIiIwO+//47i4mL4+PgITq1a/ve//yEiIgLjx4/HJ598UjIH/92vOiIiAhcvXoShoSGmTp0qNjSRAtWrVw+nT5+Gr6/vW1fOKCwsxJkzZ1CvXj0lpSN1IpG+evdBRERERERERERUBgcPHoSfnx9SUlKgoaEBa2tr2NnZoUaNGjAyMkJ+fj4yMzMRHx+P69evIycnB5qamnB1dcXUqVNRp04d0d9Cpcc5EIvjL96TJ08wZMgQJCUlwcLC4rWFxnPnziE5ORn16tXD3r17YWJiIji56rhw4QIWLFiA5OTkkosb/ksqlcLCwgLffvst2rZtq+SEqu/OnTv4+uuvcfnyZQCQm4dX5R8HBwcsXLgQDRo0UHpGAuLi4tCnTx9IJBLcuHFDdByVsWvXLixZsgSOjo7w9fVFq1atSn0OXLlyBWvXrsXly5cxb948jBgxQlBi1TFu3Dj4+vrC3t6+3Mfm5uZi9+7d0NfXx/DhwysgnfKx2E5EREREREREROUmlUpx5swZBAYG4uLFi8jMzJTro6GhARsbG3Tr1g2enp7lWuqT3o5zIBbHX6yvvvoKAQEBWLhwIYYMGfLGvnv27MGiRYvg6emJRYsWKSmhenjx4gUuXLiAyMhIJCQkIDs7GwBgYGAAKysrODg4oF27dtDU1BScVLUlJCS8cQ6sra0FJ1RvcXFxcHV1BfByWwVSDKlUigULFmD//v2QSCTQ09ND3bp1ZVbYuHfvHvLy8iCVSuHp6YnFixcLTq0aPDw8EBsb+96r/PTq1UtJiSsWi+1ERERERERERPTe7t69iwcPHiAjIwO6urowMTFBw4YN3/rBGykO50Asjr9yOTs7o2XLlli3bl2Z+n/xxRe4evUqwsPDKzgZEREp04ULFxAQEIDIyEg8evRI5jFTU1M4OjrCy8uLq2soGFf5+T8sthMRERERERERERFRpWJvb4/Ro0dj2rRpZeq/atUq7NixAzExMRWcjIiIRMnLy0NWVhYAwNDQEHp6eoITqTau8vOSlugARERERERERERERETlUbt2bURGRpa5/6VLl1C7du0KTERERKLp6emxwK5EEokEnTp1QqdOnQCo7yo/LLYTERERERERERERUaXi5uYGPz8/zJw5E9OmTXttIf3+/ftYtWoVrl27Bm9vbyWnJABITk7G6NGjIZFIEBYWJjqOWoqLi0OfPn0gkUhw48YN0XFUzoMHDxAZGYnExESZu6otLS3h4ODAC30ECAsLw4kTJ7Bs2TLRUdRK/fr1Ub9+fdExlI7FdiIiIiIiIiIiIiKqVCZMmICrV68iODgYv//+O6ytrWFpaVly91xWVhYSExMRHx8PqVQKJycnTJgwQXBq9VRYWIiUlBRIJBLRUdSaVCoFdxVWrKSkJCxatAgREREAIDe+r37mnZycMH/+fFhaWio9o7q6efMmgoKCWGwnpeCe7URERERERERERERU6UilUgQGBiIgIAAxMTEoLi6WeVxDQwP29vbw8vKCu7s7i72CFBUVIS0tDQBgbm4uOA2RYiQnJ8PT0xMZGRlwdHSEk5MTrKysYGBgAADIzs5GQkICwsPDcenSJRgbG8Pf3x8WFhaCk6sHPz8/bNiwAbGxsaKjkBpgsZ2IiIiIiIiIiIiIKrWCggIkJSXJLOFsYWEBXV1dwcmISBVNnz4dx44dw4YNG+Di4vLGvmfOnIG3tzd69OiBVatWKSmhemOxnZSJy8gTERERERERERERUaWmo6ODBg0aiI5BRGri3LlzcHV1fWuhHQA6duyI3r17Izw8XAnJiEjZWGwnIiIiIiIiIiIiIqJ3UlBQgL/++guJiYkyKwtYWlqiWbNm0NHREZxQ9T148ACRkZGlzoGDgwNq164tOKHqyc3NhZmZWZn7m5mZITc3twIT0b85OjqKjkBqhMvIExEREREREREREVGlMW7cOPj6+sLe3r7cx+bm5mL37t3Q19fH8OHDKyCd+nj69CnWrFmD4OBg5OXlAQBelRskEgkAQE9PD/369YOvry+MjY2FZVVVSUlJWLRoESIiIgD83/i/8moenJycMH/+fFhaWio9o6pyc3MDABw8eBBaWm++r7WwsBAeHh4AgODg4ArPRkTKxWI7EREREREREREREVUaHh4eiI2NRZs2bTBgwAD06NEDhoaGbzwmOjoahw8fxpEjR5Cfn4/ly5ejV69eSkqsep48eYIhQ4YgKSkJFhYWaN++PaysrGBgYAAAyM7ORkJCAs6dO4fk5GTUq1cPe/fuhYmJieDkqiM5ORmenp7IyMiAo6MjnJycSp2D8PBwXLp0CcbGxvD394eFhYXg5Kph165dWLJkCRwdHeHr64tWrVqVXNzwilQqxZUrV7B27VpcvnwZ8+bNw4gRIwQlJqKKwmI7EREREREREREREVUqBw8ehJ+fH1JSUqChoQFra2vY2dmhRo0aMDIyQn5+PjIzMxEfH4/r168jJycHmpqacHV1xdSpU1GnTh3R30Kl9tVXXyEgIAALFy7EkCFD3th3z549WLRoETw9PbFo0SIlJVR906dPx7Fjx7Bhw4a37ht+5swZeHt7o0ePHli1apWSEqo2qVSKBQsWYP/+/ZBIJNDT00PdunVLLvzJysrCvXv3kJeXB6lUCk9PTyxevFhwatXBFU7oQ8JiOxERERERERERERFVOlKpFGfOnEFgYCAuXryIzMxMuT4aGhqwsbFBt27d4OnpWa49lun1nJ2d0bJlS6xbt65M/b/44gtcvXoV4eHhFZxMfbRr1w4uLi5YsWJFmfrPmjUL4eHhOH/+fAUnUy8XLlxAQEAAIiMj8ejRI5nHTE1N4ejoCC8vL7Rt21ZQQtXEFU7oQ/LmjSSIiIiIiIiIiIiIiD5AEokEnTp1QqdOnQAAd+/exYMHD5CRkQFdXV2YmJigYcOGby3AUPllZmbCysqqzP0tLS1x+vTpCsujjnJzc8t18YiZmRlyc3MrMJF6+uSTT/DJJ58AAPLy8pCVlQUAMDQ0hJ6enshoKi0wMLBkhZN58+ZhwYIFXOGEhOGd7UREREREREREREREVGY9e/aEsbEx9u7dW6b+Q4YMwdOnT3H06NEKTqY+3NzcALzcUkFL6833VRYWFsLDwwMAEBwcXOHZiJSFK5zQh4B3thMRERERERERERERUZm5ubnBz88PM2fOxLRp01C7du1S+92/fx+rVq3CtWvX4O3treSUqs3LywtLlizB2LFj4evri1atWkEikcj0kUqluHLlCtauXYs7d+5g3rx5gtKql7CwMJw4cQLLli0THUXlcYUT+hDwznYiIiIiIiIiIiIiIiqzgoICTJo0CREREZBIJLC2toalpWVJQSsrKwuJiYmIj4+HVCqFk5MTNm3aBG1tbcHJVYdUKsWCBQuwf/9+SCQS6OnpoW7dujJzcO/ePeTl5UEqlcLT0xOLFy8WnFo9+Pn5YcOGDYiNjRUdhYiUgMV2IiIiIiIiIiIiIiIqF6lUisDAQAQEBCAmJgbFxcUyj2toaMDe3h5eXl5wd3eXu+uaFOPChQsICAhAZGQkHj16JPOYqakpHB0d4eXlhbZt2wpKqH5YbCdSLyy2ExERERERERERERHROysoKEBSUhKysrIAAIaGhrCwsICurq7gZOolLy9PZg709PQEJ1JPLLYTqRfu2U5ERERERERERERERO9MR0cHDRo0EB1D7enp6bHATkSkZCy2ExERERERERERERERqYiwsDCcOHECy5YtEx1FLTk6OoqOQERKpCE6ABERERERERERERERVQ7jxo1DTEzMOx2bm5uLH3/8Eb/++quCU9G/3bx5E0FBQaJjqC1HR0d4e3uLjkFESsI724mIiIiIiIiIiIiIqEyePn2KwYMHo02bNhgwYAB69OgBQ0PDNx4THR2Nw4cP48iRI8jPz8fy5cuVlJaIiKhiSaRSqVR0CCIiIiIiIiIiIiIiqhwOHjwIPz8/pKSkQENDA9bW1rCzs0ONGjVgZGSE/Px8ZGZmIj4+HtevX0dOTg40NTXh6uqKqVOnok6dOqK/BZXm5+eHDRs2IDY2VnQUlTRu3Dj4+vrC3t6+3Mfm5uZi9+7d0NfXx/DhwysgHREpG+9sJyIiIiIiIiIiIiKiMnN3d8eAAQNw5swZBAYG4uLFizh8+LBcPw0NDdjY2KBbt27w9PSEmZmZgLREisXVHYjo33hnOxERERERERERERERvZe7d+/iwYMHyMjIgK6uLkxMTNCwYcO3FiFJ8SIjIxEZGcl9wysQV3cgoldYbCciIiIiIiIiIiIiIiIqB6lUKrO6Q2Zmplwfru5ApPpYbCciIiIiIiIiIiIiIiJ6D1zdgUg9sdhORERERERERERERERUSYwbNw6+vr6wt7cv97G5ubnYvXs39PX1MXz48ApIR0SkXrREByAiIiIiIiIiIiIiIqKyefr0KQYPHow2bdpgwIAB6NGjx1vvno6Ojsbhw4dx5MgR5OfnY/ny5UpKS0Sk2nhnOxERERERERERERERUSVy8OBB+Pn5ISUlBRoaGrC2toadnR1q1KgBIyMj5OfnIzMzE/Hx8bh+/TpycnKgqakJV1dXTJ06FXXq1BH9LRARqQQW24mIiIiIiIiIiIiIiCoZqVSKM2fOIDAwEBcvXkRmZqZcHw0NDdjY2KBbt27w9PSEmZmZgKRERKqLxXYiIiIiIiIiIiIiIqJK7u7du3jw4AEyMjKgq6sLExMTNGzY8K1LzBMR0btjsZ2IiIiIiIiIiIiIiIiIiKicNEQHICIiIiIiIiIiIiIiIiIiqmxYbCciIiIiIiIiIiIiIiIiIionFtuJiIiIiIiIiIiIiIiIiIjKicV2IiIiIiIiIiIiIiIiIiKicmKxnYiIiIiIiIiIiIiIiIiIqJxYbCciIiIiIiKiCjVnzhzY2Njg4sWLMu0jR46EjY0N7t27JygZERERERER0btjsZ2IiIiIiIiI3kuXLl1gY2MjOgYRERERERGRUrHYTkREREREREQVatq0aQgJCYG9vb3oKEREREREREQKoyU6ABERERERERGpNjMzM5iZmYmOQURERERERKRQvLOdiIiIiIiISJATJ05g8ODBaN68Odq2bQsfHx/Ex8dj/fr1sLGxQWBgYElfGxsbdOnSpdTzBAYGwsbGBuvXr5dpT0xMxPr16zF48GB06NABTZs2hYuLC2bNmoX4+PhSz/Xq67x48QI//vgjevbsiaZNm6Jjx474/vvvUVBQUNL34sWLsLGxQUpKSsmxr/7376yv27P9TTIyMrBq1Sq4urrC3t4erVu3xqhRo3Dq1Kkyn4OIiIiIiIioIvHOdiIiIiIiIiIB9uzZg6+//hoSiQRt2rSBqakprl27Bk9PT3Tu3FkhXyMgIADbtm1Dw4YN0axZM+jo6ODOnTs4dOgQTpw4gV9//RW2tralHjt9+nScOXMGbdu2hbW1NS5fvoxt27YhLS0NK1euBADUrFkT7u7uOHr0KHJzc+Hu7l5yvLGx8Tvnjo+Px5gxY3D//n2Ym5vDyckJOTk5uHbtGiZOnIhZs2Zh3Lhx73x+IiIiIiIiIkVgsZ2IiIiIiIhIyVJSUrBs2TJoa2tj06ZNcHZ2BgAUFhZi7ty5OHz4sEK+Trdu3TB48GBYWFjItB84cABffvklli5dip07d5aar0qVKjh27BhMTU0BAMnJyfDw8EBwcDC++OIL1KtXD/Xr18fy5csRGRmJ3NxcLF++/L0zv3jxAl988QXu37+PmTNnYuzYsdDQeLkwX2JiIsaOHYtVq1bB2dkZjRo1eu+vR0RERERERPSuuIw8ERERERERkZIdOHAA+fn56NOnT0mhHQC0tbUxb9486OnpKeTrtGjRQq7QDgADBw5Eq1atEBkZiaysrFKPnT9/fkmhHQAsLCzQr18/AMDly5cVkq80p06dwq1bt9CzZ0989tlnJYV2ALC0tMScOXPw4sUL+Pv7V1gGIiIiIiIiorLgne1ERERERERESvaqWO3q6ir3mLGxMTp06ICwsDCFfK2cnBycOnUKsbGxyMzMRFFREQDg0aNHkEqlSEpKgp2dncwx2traaNu2rdy5rKysSo6tKGfPngUAdO/evdTHW7duDQD466+/KiwDERERERERUVmw2E5ERERERESkZA8fPgQAmJubl/r469rL6/z585g2bRqePHny2j45OTlybTVr1oSmpqZcu76+PgCgoKBAIflKk5KSAgCYMWMGZsyY8dp+T58+rbAMRERERERERGXBYjsRERERERFRJVdcXCzXlpOTg6lTpyIzMxNTpkxBnz59UKdOHVSpUgUSiQTTp0/H77//DqlUKnfsv5duV7ZX34uzszNq1qz52n7GxsbKikRERERERERUKhbbiYiIiIiIiJTM1NQU8fHxSElJQYMGDeQeT01NlWvT1tYu9S50AHjw4IFc2+XLl5GRkYGePXviiy++kHs8OTn5HZJXvFq1agEAPD090bNnT8FpiIiIiIiIiF5P3KXqRERERERERGqqTZs2AIA//vhD7rGMjAxERETItZuamiIjI6PU5dPPnTsn1/bs2TMA/1e8/rfExETcuHGj3LlfR1tbGwBK9oN/Hx06dAAAHD9+/L3PRURERERERFSRWGwnIiIiIiIiUjIPDw/o6OggODhYplBeWFiIZcuWITc3V+4YBwcHAMCmTZtk2rdu3YorV67I9beysgLwsmj97z3bnz17hnnz5qGwsFAR3woAwMzMDAAQHx//3ufq0aMHGjRogODgYGzYsEFuf3ipVIorV66U+j0TERERERERKROXkSciIiIiIiJSMgsLC8yZMweLFi3CuHHj0KZNG5iamiI6OhrPnj2Dm5sbgoODZY4ZP348jh49ih07diAyMhL16tXDP//8gwcPHmDYsGH47bffZPo3a9YMHTp0QEREBHr27AlHR0cAQGRkJIyNjdG1a1ecOHFCId9Ply5dEBkZidGjR6Nt27bQ09ODsbExZsyYUe5zaWlpYcOGDRg3bhzWrVuHX3/9FTY2NjAxMUFGRgZiY2Px+PFjzJ07F61bt1ZIfiIiIiIiIqJ3wTvbiYiIiIiIiAQYPnw4NmzYgGbNmiEmJgZnz56Fra0t9u3bB0tLS7n+DRs2xI4dO+Do6IiEhARERESgXr162LdvH5o1a1bq19i4cSMmTpwIExMT/Pnnn/j777/h6uqKffv2wcjISGHfy8iRIzFp0iRUrVoVx44dw/79+xESEvLO57OyskJQUBCmTp2KWrVqITo6GsePH0d8fDwaN26Mr776Cv369VNYfiIiIiIiIqJ3IZFKpVLRIYiIiIiIiIjo/6xfvx5+fn5YtmwZPDw8RMchIiIiIiIiolLwznYiIiIiIiIiIiIiIiIiIqJyYrGdiIiIiIiIiIiIiIiIiIionFhsJyIiIiIiIiIiIiIiIiIiKifu2U5ERERERERERERERERERFROvLOdiIiIiIiIiIiIiIiIiIionFhsJyIiIiIiIiIiIiIiIiIiKicW24mIiIiIiIiIiIiIiIiIiMqJxXYiIiIiIiIiIiIiIiIiIqJyYrGdiIiIiIiIiIiIiIiIiIionFhsJyIiIiIiIiIiIiIiIiIiKicW24mIiIiIiIiIiIiIiIiIiMqJxXYiIiIiIiIiIiIiIiIiIqJyYrGdiIiIiIiIiIiIiIiIiIionFhsJyIiIiIiIiIiIiIiIiIiKicW24mIiIiIiIiIiIiIiIiIiMqJxXYiIiIiIiIiIiIiIiIiIqJyYrGdiIiIiIiIiIiIiIiIiIionFhsJyIiIiIiIiIiIiIiIiIiKicW24mIiIiIiIiIiIiIiIiIiMqJxXYiIiIiIiIiIiIiIiIiIqJyYrGdiIiIiIiIiIiIiIiIiIionFhsJyIiIiIiIiIiIiIiIiIiKicW24mIiIiIiIiIiIiIiIiIiMpJS3QAIiIiIiIiItFGjhyJyMhImbadO3eibdu2ghJ9OAIDAzF37lyZNnd3dyxfvlxQIqLS2djYyLX9888/ZTp2/fr18PPzk2nz9vaGj4/PO+dJTk7GkSNHEB0djTt37uDZs2fIyspCcXGxTL8NGzagW7du7/x1iIiIiIhIHBbbiYiIiIioUklOTkZSUhJSU1ORk5ODvLw8aGtrw8jICEZGRqhZsyZsbW1hYGAgOioREamhzMxMfPPNNwgNDZUrrBMRERERkWphsZ2IiIiIiD5omZmZOHHiBI4fP46oqChkZGS89RiJRAJra2vY29uje/fucHFxgY6OTsWHJSIitfbo0SMMGTIE9+7dEx2FiIiIiIiUgMV2IiIiIiL6IKWmpmLr1q04ePAg8vLyynWsVCpFXFwc4uLiEBQUhOrVq6N3794YN24cLCwsKigxkVhpaWlyS2Z/9NFHpS6tTUQVY9q0ae9VaP/nn3+QlpYm02ZjY4OPPvrofaMREREREVEFYLGdiIiIiIg+KEVFRfjxxx+xZcsWPH/+XCHnzMjIwJ49e7B//34MHToUkyZNgomJiULOTfShiIiI4N7qRAKdO3cOkZGRcu2NGjXCgAED0LBhQxgYGEBDQ0PmcWtr65L//uWXX3Dw4EGZx5ctWwYPD4+KCU1ERERERO+FxXYiIiIiIvpgPHz4EP/73/9w+fLlt/Y1MTFB7dq1oa+vD01NTeTm5uLhw4dIS0t77R65hYWF2LlzJ27duoUdO3YoOj4REakxf39/ubauXbti3bp10NLiR3BERERERKqI7/SJiIiIiOiDkJycjNGjR792+d0qVaqgZ8+e6NGjB1q1avXaO9Pz8vIQHR2NiIgIhISEICUlRa7P64rxRCTPw8ODd9WSyvPx8YGPj897nePKlStybbNmzWKhnYiIiIhIhfHdPhERERERCff48WN8+umnpRbGNTU1MWLECEycOLFMS7/r6emhXbt2aNeuHaZPn46TJ09i8+bNiImJqYjoRERESE9Px8OHD2XazMzMYGVlJSYQEREREREpBYvtREREREQkVFFRESZPnlxqod3U1BTr169Hy5Yt3+ncEokEXbt2RZcuXXDo0CEsW7YMGRkZ75mYiIhI1tOnT+XaatWqJSAJEREREREpk4boAEREREREpN42bdqE6OhoufZatWphz54971xo/zeJRIIBAwbg0KFDaN269Xufj4iI6N+ysrLk2qpUqSIgCRERERERKROL7UREREREJExSUhK2bNki166pqYn169fDwsJCoV+vVq1a2L59O/r06aPQ8xIRkXorLCwUHYGIiIiIiATgMvJERERERCTM2rVrSy1QjB8/Hvb29hXyNXV0dDBkyJAKOfeHIDExEbGxsXjw4AHy8vKgp6eH2rVro3nz5uVe0riwsBA3b97E7du38fTpU7x48QImJiYwNzdH69atoaOjU0HfhWooLi7GvXv3EBcXh4cPHyI7Oxv5+fkwNDREtWrVULNmTTRr1gwGBgaio6q9vLw83LhxA8nJyXjy5AmeP38OIyMj1KhRA7Vq1UKzZs2gpcWPUN5HUVERbty4gbt37+LJkyfIz8+HgYEBLCws0Lx5c5iYmIiOSEREREREVG4SqVQqFR2CiIiIiIjUT1paGjp37owXL17ItJubm+Po0aPQ1tYWlAxYv349/Pz8ZNq8vb3h4+PzTue7d+8eunbtKtNmbm6OkydPKuTYvLw87NmzB/v27UNCQsJrz9WmTRtMmTIF7du3f+PXTElJwdatWxEaGvraPe719fXRs2dPTJs2Daampm/9Pv4rMDAQc+fOlWlzd3fH8uXLy32uV2xsbOTa/vnnnzIdO3LkSERGRsq07dy5E23bti1XhpiYGISHhyMyMhLR0dF4/vz5G/traGjA1tYW3bt3x/Dhw1GtWrVyfb3Svud39bqxKu9c/fnnnxg/frxMW9WqVREREYGqVau+d869e/di4cKFMm1169ZFWFgYJBJJmc+Tn5+Pw4cP4/Dhw4iKikJRUdFr+xoaGqJ9+/YYPHgwOnTo8M7ZFUFRP6uvvM9zsSzHJicnY9u2bQgNDUVmZmap59HQ0ICDgwPGjBmDzp07v8N38dL7vAaU93VfUc+9nTt3YtSoUQo5l6OjI3bt2qWQcxERERERUdnwsmwiIiIiIhJi//79coV2ABg8eLDQQntlExUVhZkzZ+LevXtv7Xv58mWMGTMGQ4cOxYIFC6CpqSnzuFQqxS+//IIffvjhrUsi5+TkIDAwEMeOHcN3330nd0GAutm0aRMOHDiA5OTkch1XXFyMGzdu4MaNG9i2bRvGjx+PiRMnlqto/KHp0KEDTE1N8ejRo5K23NxcHDt2DAMGDHjv8wcFBcm1DRgwoMxjJpVKERgYiB9++AHp6ellOiYrKwtHjx7F0aNH4eLigrlz5+Ljjz8uT2y19Msvv2D16tXIz89/Y7/i4mJcvHgRFy9ehIuLC5YvX44aNWooKSUREREREdG7457tREREREQkxPHjx+XatLW1MWjQIAFpKqeTJ0/i008/LVOh/d/27NkjdzfqixcvMGfOHKxYsaJcew9nZ2fD19cXp0+fLlcGVbNnz55yF9r/KycnB2vWrMHkyZORnZ2toGTKp6mpiX79+sm1l1YkL6/4+HhcvXpVpk0ikZS5iJ+dnY0pU6bgyy+/LHOh/b/+/PNPDB48GJcvX36n49XFt99+i+XLl7+10P5ff/75Jzw9PZGYmFhByYiIiIiIiBSHxXYiIiIiIlK6hw8fIjY2Vq7d0dGRdzOWUUxMDKZOnYqCggKZ9lf7szs6OuLjjz9+7d2+hw4dwt69e0v+vXjxYrliqLa2NurXrw9HR0e0bNnytcvFFxYWYvbs2Xjy5Mn7fVMqSFNTExYWFrCzs0Pbtm3h4OAAW1vbNy6nfvLkScyePVuJKRXPw8NDru3ixYu4f//+e523tIJ9mzZtYGFh8dZjMzMz8emnn+LEiROv7VO9enU0btwYn3zyCZo1a4aaNWuW2u/Zs2cYO3Yszp07V+bs6mT79u2lLmduZmYGe3v7kjnT0Cj9Y6mUlBSMGTPmnS+IICIiIiIiUhYuI09EREREREoXExNTanuzZs2UnKRyys/Px/Tp00vuGNXT08Po0aPh4eGBevXqyfR99OgRfvnlF+zYsUNuT+rVq1ejb9++CAsLw549e0ra69evjylTpqBjx44wMDAoaZdKpbh27RpWrFiBqKgomXNlZGTghx9+wLfffqvob7dS0dHRgaOjI7p06YIWLVqgYcOG0NHRketXXFyMW7duITg4GHv37pW7kz0sLAy7d+/GiBEj3vj19u3bV/Lfp0+fxqZNm2Qe79ixIyZPnvwe39G7adCgAZo2bYrr16+XtBUXF+PQoUOYOHHiO51TKpXi8OHDcu1luatdKpVi1qxZMnleMTQ0xLBhw9CnTx80atRI7gKVmzdv4tdff8WBAwdktr7Iz8/HjBkzEBwczIuE/iU+Ph5Hjhwp+beGhgaGDh2KwYMHy+1z/vDhQwQHB2Pjxo1yz4GUlBQsWLBA7mf6Q/Hv5x4A/P3331i0aJFMW5MmTbBw4cI3nqdBgwYy59q4cSPOnDkj02fSpEno1KnTWzP9+/WaiIiIiIiUg8V2IiIiIiJSuhs3bpTazmJ72fz7bk9ra2ts27YNdevWLbWvqakpZs2ahaZNm2LatGmQSqUlj2VkZGDbtm0yhfaRI0di7ty5cvu5Ay+X627RogV27doFb29vnDp1Subx4OBgzJkzRy0LPnXq1MGoUaMwePBgGBoavrW/hoYGbG1tYWtri08//RQzZ87EhQsXZPqsX78egwYNQpUqVV57nhYtWpT8d1xcnNzjJiYmMn2UycPDQ664ffDgwXcutl+4cAGpqakybXp6eujVq9dbj/35559L3erA2dkZ33//PYyNjV97rK2tLRYvXgx3d3dMmjQJGRkZJY89fvwY8+bNw+bNm8v8fai66Ojokv+uVq0aNm3ahNatW5fa18zMDOPGjYOrqyumTJmCv//+W+bxkydPIiQkBK6urhUZ+Z3893lV2nL5BgYGZXr+/buPiYmJ3OP16tUT9jwmIiIiIqI34zLyRERERESkdK/b27pJkyZKTlK51apVC7/99ttrC+3/5urqWuo+2ps2bSopHg4bNgzz588vtdD+b1paWli6dCmMjIxk2p8/f47Q0NCyfwMqZM+ePfjss8/KVGj/LzMzM2zZskWumJaRkVHqndyVRZ8+faCtrS3TlpCQIFOMLY/SlpDv3r37Wy/uSE5OxurVq+Xae/fuja1bt76x0P5vrVq1wo4dO6CrqyvTfurUqVLvmFd3urq62Lx582sL7f9Wu3ZtbN26VW5lDgBYsWKF3KocREREREREHwoW24mIiIiISOkePHhQantZi1700vLly0u9C/J1xowZ89rHPv74Y8yZM6fM5zIxMUH//v3l2i9fvlzmc6iS/y49Xl5VqlTBN998I9ceHBz8XucVqXr16ujSpYtc+8GDB8t9rtzcXBw7dkyuvbS94f9rx44dKCwslGlr2LAhVqxYUe55s7W1xbRp00r9GiRrwoQJaNWqVZn716hRo9RtKB48eFDqqgREREREREQfAhbbiYiIiIhI6Z49eybXpq2tDT09PQFpKqdWrVqhXbt25TqmcePGqF27dqmPffbZZ3J37L5N165d5dpet0UAvZ2tra3c6g5//fWXzD7hlU1p+6mHhoaioKCgXOc5duwYcnNzZdpq166Ntm3bvvG4jIwMHDhwQK591qxZ5f55f2Xo0KFye7SHhobK5VNnpqam+Oyzz8p9XNu2bUu9QOO/+6MTERERERF9KFhsJyIiIiIipXv+/Llcmzru8/0+Bg4c+E7H2djYyLXp6Oigb9++CjlXfHz8O+Wil5o1aybz77y8PPzzzz+C0rw/FxcXucJ0ZmYmTp48Wa7zlHY3fP/+/aGh8eaPNU6dOiVXBLeysoKLi0u5vv6/6erqomfPnjJthYWFuHbt2jufU9W4ubmhSpUq73TsoEGD5NrOnz9f7gs0iIiIiIiIlIHFdiIiIiIiUrrS7tTV0dERkKTyatOmzTsdV6dOHbk2Ozu7d7rL18TERG41gsLCQuTn579TNkKp2wIkJSUJSKIYWlpacHNzk2svbf/110lNTcXFixfl2t3d3d967KVLl+TaevToUeav/TqlPf+uXr363udVFb17937nY11cXOQuviosLOSqGURERERE9EHSEh2AiIiIiIjUT2mF3aysLAFJKictLS1YWVm907H6+vpybfXr13/nLPr6+sjLy5Npy8rKeuclulVFQUEBIiIi8Ndff+Gff/5BQkICsrKykJ2djdzcXEil0jKfq7I/N9zd3bF9+3aZtvDwcDx+/FjurvfSHDp0SG68WrZsWabnwOXLl+XamjZt+tbj3sbc3FyurTKvQKBI2trasLW1fe/j/zt3MTExaNGixXumIyIiIiIiUiwW24mIiIiISOlK25s9NzcXL168gKampoBElYuRkdE7H1taEbxatWoKPZ8639mempqKTZs24Y8//sCzZ88Uck5FnUcUW1tbNG7cGLGxsSVtRUVFCA4OxujRo996fGl3wZflrvaCggIkJibKtefl5SE6Ovqtx79JamqqXFtmZuZ7nVNVWFtbv/dKJaUV25OTk9/rnERERERERBWBxXYiIiIiIlK6mjVrltqelZWF6tWrKzdMJVTaxQof0vnKc9e2Ktm6dSs2bNggd6f/+1L0+URwd3eXKbYDL/dhf1ux/erVq0hISJBp09XVhaur61u/5tOnT0ttnz179luPfRcstr9kamr63uco7XdEZV/hgYiIiIiIVBP3bCciIiIiIqWrXbt2qe337t1TchIixfj222+xcuXKCimMq8LFC25ubtDW1pZpu3nzJm7evPnG4w4ePCjX1q1bNxgaGr71ayq7+M1i8Ev/3W9dUefgxQxERERERPQh4p3tRERERESkdA0aNCi1PSYmRiH7KRMp065du7Br165SH9PW1kbjxo3RvHlzmJub46OPPoK+vj50dXWhq6sLiUQi0z8gIAD79+9XRmylMjExgYuLC06cOCHTfvDgQcydO7fUYwoKChAaGirXXpYl5AHlL79fXFys1K/3oSpta4nyqlKlilzb8+fP3/u8REREREREisZiOxERERERKd3rCup//fWXkpMQvZ/Hjx9j7dq1cu1VqlTB5MmTMXjw4HJtjXDq1CkFpvuwuLu7yxXbf//9d8ycORNaWvIfT5w4cUKuYG5mZob27duX6euVdk6qeLm5ue99jpycHLm2sqxmQEREREREpGz8y5OIiIiIiJSuSZMmMDQ0lFt2+dKlS5BKpXJ3+1Z2RUVFoiOovMLCQiFf99ChQ3I/x3p6evj1119hZ2dX7vMp+25sZerUqROMjY1l9lJPT0/H2bNn0alTJ7n+QUFBcm39+/eHpqZmmb7e65YzDwkJQf369ct0DnWg6Nen7OzsCjkHi+1ERERERPQh4p7tRERERESkdNra2nBycpJrT05Oxvnz5wUkklVaMe99ClIZGRnvkUY1qcoYnzx5Uq5t8uTJ71RoByBTiFY12tra6Nu3r1x7afuyvyrC/1dZl5AHgFq1apXaXtnHuLTnzosXL975fIp+7ty7d69CzlGtWrX3Pi8REREREZGisdhORERERERC9O/fv9T2vXv3KjmJPH19fbm291kaOS0t7X3iqCRVGeO///5bru11P9tlcePGjfeJ88ErrVh+8uRJZGZmyrQFBwfLXXxhb29frjvSDQwMSi24p6amlvkcH6IP/bmTkpLy3ne337x5U66tYcOG73VOIiIiIiKiisBiOxERERERCeHi4oI6derItZ84cUJ4wbG05YrT09Pf+XxRUVHvE0clqcIY5+bmyhU59fX18dFHH73T+R49eoTExMR3zlMZtl+ws7NDo0aNZNoKCgoQEhIi01ba3e4DBgwo99dr0aKFXNvFixfLfZ4PSWnPnUePHr3z+RT93JFKpbh8+fI7H5+ZmYk7d+7Itdvb279PrEqjMjyPiYiIiIjo/7DYTkREREREQmhqamLy5Mly7UVFRZg9ezYKCgoq7Gu/bRlpMzMzubZ//vnnnb6WVCrF6dOn3+lYVVbaGN++fRvFxcXvdL7SlnOvaP/dqx0Aqlat+s7n279///vEgY6OjlybqL3s36S0ovm/92ePjY2Ve77p6OigT58+5f5anTt3lms7c+ZMhb6+VDRFvj6lpKS887FvEhwc/M7HhoaGyv3cGhoa4uOPP37fWJWCtra2XNv7bLFBREREREQVi8V2IiIiIiISxsPDAzY2NnLtt27dwnfffVchX/PUqVOYO3fuG/s0adJEri0uLg73798v99c7ceIEEhISyn2cqrOyspJbDjs3N/ed7rK9efMmzp8/r6hoZVbaHcYZGRnvVMjNzc3Fnj173itPacuL5+Xlvdc5K0K/fv3k9h2Pjo5GfHw8gNLvau/cuTOqV69e7q/VrVs3uQsgHj16hH379pX7XB+K0l6fzp07907n2rFjx3vt9/46YWFhePDgQbmPKy4uxm+//SbX3rt3b7W541vR2wQQEREREVHFYrGdiIiIiIiE0dTUxHfffVfqnXy7du3CypUrIZVKFfK1CgoK8N1332HSpEnIycl5Y18TExOYm5vLtEml0nLfeZyZmYklS5aUO6s6kEgksLOzk2sv7xgXFBTgyy+/VFSscqlatSoMDAxk2goLC9+p8L9s2bL33jvbyMhIri0lJeW9zlkRTE1N4eTkJNceFBSEoqIi/P7773KPlbbXe1kYGBjAy8tLrn3dunW4e/fuO51TtKZNm8q1JSYmlnt5/GvXruHXX39VVCwZz58/f6cLpvbt21fqnfalzaGqqlatmlzbh/g8JiIiIiKil1hsJyIiIiIioWxtbfHVV1+V+tjWrVsxceLE9y5CnjlzBm5ubvjpp5/KXLzv2bOnXNtPP/1Ucvft22RnZ8PHxwepqanlyqpOShvjoKAgXLp0qUzHFxYWYu7cufj7778VHa3M2rRpI9e2fv36ci3f/vPPP8Pf3/+9szRo0ECu7e7du8jOzn7vcytaacXzw4cP48yZM3j8+LFMe82aNeHs7PzOX2vSpElyd8U/e/YM48ePV0jBPSEhQWYZ/IpWt27dUi9U+fbbb8u8ksHdu3fh6+tbocuTHzlyBLt27Spz/6tXr2LFihVy7S1btkSzZs0UGe2DVtrzODo6WvlBiIiIiIioTFhsJyIiIiIi4by8vErdvx0ATp8+jV69emHFihVITk4u8zmzs7MRGBgIDw8PTJgwodxLuQ8aNEiuLS8vD6NHj8Zff/31xmMjIyMxdOjQkjtN9fT0yvW11YWbmxt0dXVl2qRSKSZNmoTw8PA3HhsbG4tPP/205C5oUWPcrVs3uba//voL06dPf+sKCllZWVi0aJFMgfG/y6uXh5GRESwsLGTaCgsLsWXLlnc+Z0Xp2rWr3B28qampWLp0qVxfNzc3aGlpvfPXql69eqkrTKSkpGDgwIHYvn17uZfbz8nJwR9//IGJ/4+9+46vqjz8OP49mWQQCIQRAsgMIBA2hI3sJSIIDgQBcWC1Vmtttf3ZVltr66oVREFRQUAMG2SjEobsrWwEhAAJECAkIes+vz9OJgmQQMZN8nm/XnmZ+9xz7z0hycn1fu7znKefVt++fe/oHOW3I6fj06FDh/TUU08pMjLyhrdLSUnRnDlz9PDDD6efFiO/f3cyL/f+z3/+UxMmTLhl1F+xYoWeeuqpbN8HNzc3/e1vf8vX/XN2OZ0mYM+ePQoPDy+CvQEAAABwK7f/f6sAAAAAkI+ef/55eXl56b333ss2+zwuLk5Tp07V1KlT1ahRI7Vq1Up169ZVtWrV5OPjIxcXF8XHxysyMlK//PKLdu3apV27dt3WubPT1K1bV4MHD842Y/Xs2bMaPny47rnnHnXt2lVBQUHy8PDQxYsXdeTIEa1du1Z79uxJ397FxUV//vOf9Ze//OW296WkKleunMaNG6eJEydmGY+JidG4ceMUGhqqHj166K677pKPj4+io6N1/PhxrVu3Tlu2bMnyc/J///d/RbKc/H333adJkyZlW+Z5xYoV2r17t0aMGKFOnTqpZs2a8vT01MWLF3Xy5El99913WrhwYZZZ3BUqVFDv3r319ddf3/b+9OnTR59++mmWscmTJ2vXrl3q2bOnatWqJV9f3xyjfvPmzW/7cfPKw8ND/fv3z3ae+lOnTmXb9naXkM+sZ8+eev755/XBBx9kGY+Pj9e//vUvffTRR+rfv79at26tRo0ayd/fX35+fkpMTNTVq1d1+fJlHT16VAcPHtTevXu1efPmOzq+3KmhQ4dq2rRp2Vba2Lx5s/r06aMBAwaoXbt2qlSpkowxunDhgnbv3q3vv/8+y5uWAgIC9Nhjj+ndd9/Nt33r0aOH9u7dq3PnzskYow8//FDLli3T0KFD1alTJ1WtWlUeHh6KjIzUjh07tHDhwhuec37cuHFq2LBhvu1bcVCtWjWFhIRk+Tsi2Ss09O3bV6GhoQoKCpKXl1e289j7+vrmODMeAAAAQMEhtgMAAABwGk8++aQaNGigP/3pT7p48WKO2+zfv1/79++/7cfw9fVVv379crXtq6++qh9//DHbMvYOh0Nr1qzRmjVrbnkfr732mtq3b39b+1oaPP3001qzZo0OHDiQ7bpNmzZp06ZNt7yPJ554QkOHDi2S2O7h4aG///3veuqpp5SSkpLlurNnz+rdd9/NVcj08PDQ+++/n+sl9G/koYce0vTp05WQkJBlfMuWLdqyZctNb5vTubIL0v33358ttl/v7rvvVoMGDfLl8Z555hm5uLjo/fffz3bd5cuXNWvWrFvuj7Pw9PTUm2++qZEjR2abNR4XF6ewsDCFhYXd9D68vb01adIkHTlyJF/3rWzZsnrnnXc0duzY9NMpHDlyRP/+979zXCb+Rjp37qznnnsuX/etuBg1apReeumlLGPJyclasmRJ+moeOWnbtm2elu4HAAAAcOdYRh4AAACAU+natauWLVumRx55RO7u7vl2vx4eHho1apRWrVqlRx55JFe3KVeunKZPn66goKA8P567u7vefPNNPfzww3m+bWni4eGhzz//PMelk2/Fsiw9//zz2aJUYevcubP++te/3vYS8D4+PpowYYJCQ0PveF9q1KhRJG86uB3NmjVTnTp1brpNfsxqz+zpp5/WJ598ooCAgHy93/w8VuVWy5Yt9eGHH2Y7FUNuVKpUSV9++aVCQkIKYM/s6Pvee+/Jw8Pjtm7fo0cPTZw48Y5OH1Cc3XvvvRowYEBR7wYAAACAXCC2AwAAAHA65cuX11//+letXr1aTz75pKpVq3bb9xUSEqLXXntN4eHh+vOf/6wKFSrk6fZ33XWXZs+erSFDhsjFJXf/C9W6dWvNnTtXQ4cOvZ1dLnUqVKig6dOna8yYMbmOlg0aNND06dP1zDPPFPDe5c6DDz6ozz77TIGBgXm6Xdu2bTVnzhx17do13/bloYce0sSJE1WlSpV8u8+CcrOY7u7uroEDB+b7Y3br1k0rVqzQ008/rfLly9/2/bi7u6tLly56//33sy1PX1i6d++uWbNmqXXr1rna3tXVVUOGDNHixYsLLLSn6d27t2bMmKHg4OBc38bX11evvPKKJk6ceFtvIihJ3n77bT3//PPy9vYu6l0BAAAAcBOWuf5kiAAAAADghH766Sdt375de/fu1a+//qqIiAjFxMQoISFB7u7u8vPzU7ly5RQQEKC7775bTZs2VbNmze4o1F/v2LFjWr16tTZs2KBTp07p4sWLSkpKkq+vr2rVqqUWLVqoX79+BR6xSrIzZ85o1apVWrdunY4fP66LFy/q2rVr8vHxUfXq1dWsWTP17t3baZfmT0xM1KJFi7Rs2TLt2LFDcXFxWa63LEs1atRQhw4ddN9996lly5ZZrt+zZ0+2czWHhITc1s9USkqK1q9frw0bNmj//v06deqUrl69qri4uGxLj0uFv4y8JEVFRd3wHPVVq1bVsGHDCvTxr127ph9++EE//PCDdu3apRMnTsjhcOS4beXKlVWnTh3dfffdCg0NVZs2bZwqhG7dulXff/+9tmzZosjISEVHR0uS/P39Va9ePYWGhmrAgAG3tVLHjcybN0+vvPJKlrH7779fb731Vvplh8OhVatWafHixdqyZYsuX76cZXsXFxc1atRIffv21QMPPJDnN0Q5iwMHDujtt9/OMtagQQO9/PLLd3S/sbGxWrFihXbs2KEDBw7o7NmziouLU3x8fLafVZaRBwAAAAofsR0AAAAAgAKQnJysCxcuKDo6WikpKfL29lZgYKDKlClT1LuGG0hKStK5c+d09epVJSYmysvLSz4+PipfvrxThXVnkZvYfr2oqChdvHhRiYmJ8vHxUVBQUKmfxQ4AAACg+CqdJ78CAAAAAKCAubm5qUqVKsViOXfY3N3dVb169aLejRKtUqVKqlSpUlHvBgAAAADkC87ZDgAAAAAAAAAAAABAHhHbAQAAAAAAAAAAAADII2I7AAAAAAAAAAAAAAB5RGwHAAAAAAAAAAAAACCPiO0AAAAAAAAAAAAAAOQRsR0AAAAAAAAAAAAAgDwitgMAAAAAAAAAAAAAkEfEdgAAAAAAAAAAAAAA8sitqHfA2UVHRxf1LpRY5cqV0+XLl4t6NwCgVOHYCwCFj2MvgJIqNjY221hCQoJTvJbCsRcACh/HXgAofBx7C5a/v/8ttyG2o8i4uLCwAgAUNo69AFD4OPYCKKkGDhyogQMHFvVu5IhjLwAUPo69AFD4OPYWPb4DAAAAAAAAAAAAAADkEbEdAAAAAAAAAAAAAIA8IrYDAAAAAAAAAAAAAJBHxHYAAAAAAAAAAAAAAPKI2A4AAAAAAAAAAAAAQB4R2wEAAAAAAAAAAAAAyCNiOwAAAAAAAAAAAAAAeURsBwAAAAAAAAAAAAAgj4jtAAAAAAAAAAAAAADkEbEdAAAAAAAAAAAAAIA8IrYDAAAAAAAAAAAAAJBHxHYAAAAAAAAAAAAAAPKI2A4AAAAAAAAAAAAAQB4R2wEAAAAAAAAAAAAAyCNiOwAAAAAAAAAAAAAAeURsBwAAAAAAAAAAAAAgj4jtgBNZsmSJQkNDtWTJkizjgwcP1uDBg7Ntf+HCBb3++usaNGiQOnTooNDQUMXExNz244eGhmr8+PG3fXvkLK/fVwAAAAAAAAAAADg/t6LeARRvERERGjJkiCSpQoUKWrRokdzcsv9Y/fLLL3r44YclSVWrVtWCBQsKczdLrDfeeEObN29Wr169VKNGDUmSh4dHesDl37lwpP0e9O/fX6+99lpR7w4AAAAAAAAAAAAKAbEd+cLV1VUXL17Uxo0b1aVLl2zXL168WC4uLKRwuyZMmJBtLCkpSVu2bFGbNm30+uuvF8FeIbe6deumJk2aKCAgoKh3BQAAAAAAAAAAAPmE+ol8ERISIl9f32zLZEtScnKyli9frjZt2uQ46x23Vr16dVWvXj3L2IULF+RwOAi4xYCvr69q1aolX1/fot4VAAAAAAAAAAAA5BNiO/KFp6enevXqpQ0bNujixYtZrksbGzhw4A1vb4zR4sWL9cQTT6h79+7q2rWrRo8ercWLF2fbNioqSlOmTNHjjz+ufv36qXPnzho8eLD+85//ZHtsSXr99dcVGhqqiIgIzZ49Ww8++GD6bT799FM5HI5cfY3bt29XaGiopkyZku26iIgIhYaGZpthnnZO7piYGL311lvq37+/unTpolGjRmnlypW5etzM95Nm/Pjx6ZeXLl2q0NDQ9McPDQ3V2bNndfbs2fTxG+33jURGRur//u//1KdPH3Xt2lVPPPGEtmzZkmWbv/71rwoNDdVPP/2U431MnjxZoaGhuf46d+3apfHjx6tbt27q3bu3/vznP+vcuXMaP368QkNDs2yb+Xt6vSlTpig0NFTbt29PH0tKStI333yj559/XoMGDVLnzp3Vr18//fGPf9TBgwez3Ufmc6xv3rxZTzzxhLp27arevXvr9ddf1+XLl7Nsm3Yqhczfi8z7cKNztt9IXn4fAAAAAAAAAAAAUDSYZox8M3DgQM2fP1/Lli3TiBEj0scXL14sPz8/de3aVW+88Ua22xlj9Ne//lUrV65UjRo11KdPH7m5uWnLli365z//qV9++UW//e1v07fftWuXZs6cqdatW6tx48Zyc3PToUOHNG/ePG3evFlffvlljjOIP/zwQ+3cuVMdO3ZUu3btFB4erk8//VRJSUkaP358wfyjyJ7Z/9xzzyk+Pl79+vVTfHy81qxZo9dee02XLl3S8OHD83yfAwYMUHBwsGbPnq369eunL90fHByswMBAzZ49W5L04IMPpt+mZcuWubrvmJgYPfnkkypfvrwGDRqkS5cuafXq1XrhhRf05ptvqmvXrpKk+++/XytWrNCiRYvUuHHjLPeRkpKiJUuWqFy5curWrdstH3Pr1q164YUX5OLiop49eyogIEDbtm3Tk08+qbJly+Zqv2/mypUr+u9//6tmzZqpQ4cOKlu2rCIiIrRu3Tpt2rRJkyZN0t13353tduvWrdPGjRvVqVMnNW3aVLt27dLSpUt16tQpTZ48WZL9b/7ggw9m+15IUmBgYJ73Na+/DwAAAAAAAAAAACgaThnbExIS9N5772nfvn06ceKELl++LD8/P9WoUUPDhg3ToEGD5O7unqv7cjgcmjFjhr755hudOHFC3t7e6tChg1544QXVqFGjgL8SO5xdu1bgD3PbypSRLMvKl/tq3Lix6tatq2+//TY9tl+4cEE//vijhgwZIg8Pjxxvt3DhQq1cuVIDBw7Un/70p/Sl5pOSkvTKK69o5syZ6t27txo2bChJatWqlb799lt5e3tnuZ+lS5fq9ddfV1hYmMaMGZPtcQ4ePKivvvoqfdn1sWPHatiwYQoLC9O4ceNy/TOVV+fPn1eNGjU0ZcqU9McYPXq0Ro0apQkTJqhbt26qXLlynu5z4MCB6TP169evryeeeCL9uq5du+rbb7+VpCzjuXXkyBH17t1bf//739N/NoYPH66xY8fqrbfeUrt27VSmTBk1b95ctWvX1qpVq/S73/1OXl5e6fexadMmRUZG6qGHHrrh9z2Nw+HQW2+9pZSUFE2YMEHNmzeXlDU636myZctqwYIF2f6djx07pnHjxmnSpEn68MMPs91u/fr1+uijj9SsWTNJ9psInnvuOe3YsUP79u1TkyZNFBwcLF9f3xy/F7cjr78PAAAAAAAAAAAAKBpOGdtjY2M1a9YshYSEqFu3bqpQoYIuX76sdevW6dVXX9XSpUs1ZcoUubjcehX81157TWFhYapfv75GjhypyMhILVu2TBs2bNDs2bNVq1atAvs6jDF65jmjvfsK7CHuWNMm0kcf5l9wHzhwoD744IP0EPntt98qJSVF99577w1vM2fOHHl5eemll17Kck53d3d3Pf3001q/fr1WrlyZHhcrVKiQ4/3069dP7777rrZu3ZpjbB87dmyW85uXL19enTt31tKlS3XixAnVq1fvdr/sW3r66aezxPzKlStr+PDhmjx5slatWpVlJYCi5urqqvHjx2f5mahfv7769u2rxYsXa+PGjerevbske3n7999/X6tWrdKgQYPSt1+0aJEk6b777rvl4+3evVunT59Wp06d0kO7ZP9Mjh8/XmvWrFFKSsodfU0eHh45vqGhTp06atmypTZv3qzk5OQsP3+S1KdPn/TQLtn/Nv3799eOHTv0888/q0mTJne0XznJ6+8DAAAAAAAAAAAAioZTxvby5ctr27Zt2WbEJicna8yYMVq/fr3Cw8NvuTz1pk2bFBYWpjZt2mjq1Knp9zdw4EA9+eSTeuONN/TZZ58V1JdRKvXt21cTJ07UkiVL0mN7cHCwgoODc9z+2rVrOnr0qAICAjR9+vRs1ycnJ0uSTpw4kWX8+++/14IFC3Tw4EHFxMRkibHnz5/P8bEaNGiQbSwtwF69ejV3X+BtcHV1VdOmTbONp4XlQ4cOFdhj344qVarkuPx58+bNtXjxYh06dCg9tvfv318fffSRFi5cmB7bL1y4oPXr16tp06aqXbv2LR/v8OHD6fd/vcDAQFWuXFlnzpy5g6/IdujQIX311VfavXu3Lly4kP6zlebSpUtZ3owhFf7PzO3+PgAAAAAAAAAAAKDwOWVsd3FxyXHpaTc3N/Xq1UtbtmzJVWwKCwuTJD3//PNZ7q9r165q27at1q9fr4iICFWrVi3/dj4Ty7L00YcqNcvIS5K/v786deqkVatWqXv37jpx4oR+//vf33D7K1euyBijqKiom77xIT4+Pv3zGTNm6MMPP5S/v7/atm2rypUry9PTU5I0e/ZsJSYm5ngfPj4+2cZcXV0l6Y5nTt9M+fLlc1yFIW2GfkGG/ttxo5UDctrfsmXLqkePHlq6dKmOHj2afhqBlJSUXM1qz3x//v7+N3zcO43te/bs0bPPPitJatu2rbp3755+GoLw8HAdPnw4x5+bwv6ZuZ3fBwAAAAAAAAAAABQNp4ztN+JwOLRu3TpJuuFM6cw2b94sb29vtWzZMtt1nTt31pYtW7RlyxYNHjw4v3c1nWVZynQq61Jh0KBB+uGHH/TGG2/I09NTffr0ueG2aTGzYcOG+uKLL25538nJyfr8888VEBCgadOmZQnDxhh99dVXd7z/N5IWzHOKrLGxsTe83aVLl+RwOLIF94sXL0qSfH1983Ev71zaft1o/Pr9HTJkiJYuXaqFCxfqxRdf1OLFi+Xj46OePXvm6vHS7i86OjrX+5PX78UXX3yhxMREffzxx9lm0P/000/ps+uLWl5/HwAAAAAAAAAAAFB0nDq2JyYm6pNPPpExRpcuXdKPP/6oY8eOaciQIWrfvv1NbxsXF6eoqCgFBwenz0TN7K677pLEcswFoV27dqpUqZKioqLUq1cv+fn53XBbHx8f1apVS8ePH1dMTIzKli170/u+fPmyrl69qtatW2ebgb1//34lJCTky9eQk7R9i4qKynbdwYMHb3i7lJQU7d27N8u5vyVp165dknL3xpG8cnV1VVJS0m3d9ty5czpz5ky2peRvtL9NmjRRvXr1tHz5cnXs2FG//vqrhgwZojJlyuTq8erXr59+/48++miW686cOaPIyMhst8n8vahRo0aW63L6Xpw+fVp+fn7ZQvu1a9du+r3LrbRjjMPhuKP7yevvAwAAAAAAAAAAAIqOU8f2pKQkTZgwIf2yZVkaO3bsTZclTxMTEyPpxrOG08bTtruRcuXK5bgEOGxps4jd3NyyLAM+adIknTt3Tg0bNsy2PLirq2v6mL+/v0aPHq2//e1veuedd/TWW2+lL++d5tdff5VlWapevbrKlSunMmXK6PDhwypTpoy8UpcNuHz5sj744INs9y8pfYn5cuXKZduXtNuXLVv2hsuYp2nWrJl8fHy0YcMGWZal8uXLS7LPET9t2rT0x8p8P2kR9tNPP9XUqVPTT2dw9uxZhYWFycPDQ8OGDUu/TdrMZh8fnxzvJ/NY2r/99Y+Ztt3hw4fl7e2d/vXnVkpKij777DO988476acYOHDggJYvX64KFSpowIAB2UL6I488otdff13//Oc/JUkjR4685b9nmm7duql69erasGGDjh49qtatW0uyVyr4xz/+kT57PfP9tWnTRrNmzdLq1avVo0eP9PHly5dr586dkrJ+T2vUqKGTJ0/q/Pnz6XE/JSVFH3zwQfqM+sw/Hzf6PqTdr2T/7KRd5+HhIcuydPHixRy/7rx8X/Py+wDcrtz+fgIA8g/HXgAofBx7AaDwcewFgMLHsbdoOXVs9/Hx0cGDB+VwOBQZGanvvvtO77//vnbt2qUpU6YUyvLbly9fLvDHKM7S/n2Sk5OzLANevXr19Bh4/fLgKSkpio6Olr+/v6Kjo9WnTx9t2bJFS5cu1fbt29WmTRsFBATo4sWLOnHihH766Se9/vrr6tWrlyR72fKZM2dq4MCB6tSpk2JjY7Vp0yZVrVpVlSpVSr//NGmz3S9fvpztHNxp576OiYm54TLmmT3wwAP68ssvdd9996lLly6Ki4vT+vXr1aJFC508eVIJCQlZ7iclJUUBAQGKiYlJ39/4+HitWbNGly9f1osvvigPD4/026QF9NjY2Gz3c/2/Zdq//fWPKUnNmzfXvn37NHr0aDVv3lxubm5q0aKFWrRoccuvsV69etq2bZsGDx6sNm3a6NKlS1q9erVSUlL0xz/+UfHx8dnOGd61a1d5eXkpMjJSDRs2VGBgYK7+PdO8/PLLevHFFzVmzBj17NlTAQEB2rZtmy5cuKB69erpyJEjWe6vZcuWql69uubNm6eTJ0+qQYMGOn78uLZt26YOHTpo48aNWb6ngwcP1vr16/Xwww+rR48e8vDw0I4dOxQVFaWWLVtqx44dWX4+bvR9kDLeoBMfH5/lukaNGmnr1q16/vnnVaNGDVmWpX79+ikwMDBP39e8/j4AeZV27AUAFB6OvQBQ+Dj2AkDh49gLAIWPY2/Bys0bGYrFlG0XFxdVrVo1ffbsjh07NGnSpJveJm326dWrV3O8Pm2cZZqLnmVZeu211/SPf/xDtWvX1oYNGzRr1ixt2bJFHh4eeu6559SmTZv07Z955hk9/fTTsixL8+bN09atW9WrVy998MEHOZ4yID899dRTGjdunIwxmj9/vvbs2aMxY8boueeeu+Ft3Nzc9L///U8tWrTQsmXLtGTJElWuXFmvv/66hg8fXiD7OXbsWN133306efKkvvzyS02ePFnbtm3L1W3Lli2ryZMnq3r16lq4cKFWrlypevXq6f3331fXrl1zvI2Pj0/6dffdd1+e97dt27aaMGGCGjdurDVr1mjBggUKDAzUJ598kuPvaJkyZfS///1PXbt21c8//6x58+YpISFBH3/8sRo1apRt+06dOunNN99UtWrVtHz5cq1cuVJ33XWXpk6dqqpVq+Z5f3Pyt7/9Te3bt9eGDRv06aefavLkyYqIiMjz/eT19wEAAAAAAAAAAABFwzLGmKLeibyIiYlR69atFRISorCwsJtumzbredu2bdki7OTJk/Xuu+/q3//+twYPHnzD++DdIAWnNLzbJu1na8GCBUW6H4VhxIgRioiI0JIlS7KtIHAnxo8fr507d2rTpk35dp9AaVYajr0A4Gw49gJA4ePYCwCFj2MvABQ+jr0Fq8TMbM8sMjJSkj1b+Fbatm2ruLg47dixI9t169atkyRmiAL5YOPGjTp69Kj69OmTr6EdAAAAAAAAAAAAcFZOec72I0eOKCgoSF5eXlnG4+Pj9a9//UuSsixnffHixfRzgFeoUCF9fPjw4fr222/1wQcfaOrUqfLw8JAkrV27Vlu2bFGnTp0UFBRUCF8RUDLNnTtXkZGRWrRokTw9PTVq1Kii3iUAAAAAAACgVDPGKC5OiomRrsSk/veKFHM17XOT/nlsrH0bFxfJxZJcXFM/d5FcXSQr9b8uLqnXWRmfu7pIlpXxubd3rBITHam3t+z7cE3dJvXz6x8n7b5z8ziumfYt84dr6naWlfF55v3P/DhZbpfTvrlYRfvNAwAUO04Z25ctW6bPP/9crVq1UlBQkHx9fXXu3DmFh4fr0qVLat26tUaPHp2+/YwZMzRhwgQ9++yzWc6dHRoaqmHDhiksLExDhgxR165dFRUVpaVLl6p8+fL6y1/+UgRfHVByTJ8+XVFRUapZs6b+/Oc/q1q1akW9SwAAAAAAAECJkJBg7EieKZpnfG6yxvTU/15N/W+Koyj2+Fqmz4vV2WszMdlCvnVd1M/8RoAc35Rwi6jv6ytVCpACAixVCpAqVUr9CJDKlCH2A0Bx45SxvVu3boqMjNTOnTu1a9cuxcXFydfXVw0aNNCAAQM0dOjQXC0jL0mvv/66goOD9c0332jatGny9vZWr1699MILL6hmzZoF/JWgtCvp52ovjK9v0qRJBf4YAAAAAAAAQEFITjY5zCzPPss8LarHXJViUj9PTLqzx/Zwl8r6SWXLSn5ls/63bFlLfmUlH1/JkuRw2IHe4ZAcKZLDZHye4pCMkVJSUsccksNh0j9PSd3Ow6OM4uKv2bdPHTeO6+4788cN71tZ7ttc9zgOR+r+3exxbvA1OHLxJoS0xy542d+Q4Otr0gN8QIAd4CsFWFmCfLlyzMAHAGdiGWOK61vMCkV0dHRR70KJ5e/vz78vABQyjr0AUPg49gJA4ePYCyA/paQYxcZeP7M86yzz7GP2R3z8nT22q0tqHPeTyvpKfqnxPONzK+t4pqDu6Vm4QbY4HHuNMTeM+o6U1PDvuEXIz3y7lIyIf6s3DKSkbhNzRYqMMjp/XopK/TgfJcVfu/X+S5KbmxRQ8bogX8nKEukDKhb+9x9A0SgOx97izN/f/5bbOOXMdgAAAAAAAAAA8osxRvHxqSE8h1nmV66Y9JnlmWeZX7lin9f8Tqes+fpmj+HXzzLPdr2f5OUlWRbRNL9YliVXV3s59yLekyyXjLHf0BF1Xjp/XoqMkqKipPPnTZYgH31JSk6Wzp6zPzLdQ7ZHKOdnFFBJGUvVpy5bnz4WYP+M8fMFAHeG2A4AAAAAAAAAKBYSEky22eM3Oo/59Z+npNzZY3uVyTrLPC2I2zPLretmnGd87uMjuboSNHFjlmXJ19d+U0btWlmuybJdcrLR+Qt2iE8L8FGpQf78+YzxxETp8hX74+jRtFtnD/IeHlJAgFHl65atzxzkK1aU3N35+QWAGyG2AwAAAAAAAACKhMNhh8KICOl0hB0Mc5plnhbNExPv7PHc3ZVlFnnZLDPKretmnGf9nOCIoubmZqlqFalqlcyj2WfJX7mSdYl6+3OTEeSj7BCfmGj/7kVEZLmHLPdnWZJ/eZMlwAeknUc+wI70lSvZbyphljyA0ojYDgAAAAAAAAAoMAkJRhFnMoJ6RIRJ/a905oyUmJS3+3NxyZhZntMs87JlrUwzzrPOMvf0JAiiZLMsS+XKSeXKSfXqZrkmy3YJCfYs+cwz4tOXrU9bxv6CvWz9xWj749ChtFtnnyXvVUYKqGQyBfmMc8mnBXl/f/sNAwBQkhDbAQAAAAAAAAC3zRijy5dTQ/oZ6fTprEE96vzNb+/qas/UDQqSqlS2A3raLPOcznHu7S25uBDsgDvh6WkpqJoUVC3zaNbfK4fD/t2Oui7IR0ZljfRXr0rx16Rff7U/MmSN8i4uUoUKJiPGpwb5tBifNu7tze83gOKD2A4AAAAAAAAAuKnkZDuwnT6dFtWNIk5nBPbY2Jvf3ttb6WGvWpBULTA19AXZkY3ZroDzcXGx5O9vz0gPrp82mv13NT4+41zy588rNcZnzJI/f166cEFKcdifn8/yBpzss+R9fLIG+YBKUuVMs+QrBdj7xJtuADgDYjsAAAAAAAAAQHFx9nLvpyNSZ6efMfbS76els+eklJSb375SgFQtLahXsxQUJFULtC+XK8fy7UBJ5eVlqUZ1qUb1zKNZf99TUoyiL9nnkI/MYdn686nnmI+Ls9+8ExsrHT+R+R6yRnlXV6lixYxl6ytVypgln3nM05PjDoCCRWwHAAAAAAAAgFLAGKMLF7OeOz3t89MRUnT0zW/v4S4FBqbF9NSgnvZ5IFELwI25uloKqCgFVJQaNkwbzX7MiI3NHuCjzhudj8pYzv5itP3mn8hI+yND9lnyFSsYNWkiNWtqKSTEPo89K2kAyE/EdgAAAAAAAAAoIZKSjM6czRrU086dHnFGunbt5rf388sc06WgahnndQ4IYNlmAAXLx8eSj49U667Mo1mPO8nJ9huHcgrykZnGEhKkCxelteHS2nA7xHt5SU0aGzULsRTSVGp8N28UAnBniO0AAAAAAAAAUIzExJj02egR1wX1yCjJ4bjxbV1c7HOkBwWlzUi3l3sPSp2dXrYs0QmAc3Nzs1SlslSlcubRrMcuY4xirkrHj0u790h79hrt3StdjZW2bpO2bjOp9yU1bGAUEmLPfm/aVPLjOAggD4jtAAAAAAAAAOBEHA57GeXTp1NnqJ8xijidGtfPSFeu3Pz2ZcpkxPNqQfbs9GqBdmCvWkVydyckASjZLMuSX1kppKn9IVlKSTE69ou0Z4+0e6/R7j3ShQvSvp/sj5mzjCxLqlM7I743C7HPBQ8AN0JsBwAAAAAAAIBClpBgFHEmNaCfliLOpM5WPy2dOSslJd389hX8U2enB6Yu9x6UGtSrSRUq2KEJAJDB1dVS/XpS/XrS0CGWjDGKiLBnvqfF91OnpKPH7I/5C+zZ74GBRs0yxfcaNTjGAshAbAcAAAAAAACAfGaM0aXLmc+dLp0+nRHYz5+/+e1dXaXAqjmcOz3IHvf2JvQAwJ2wrNTTaARJ/fvZx9QLF4z27LXj+5490pGj0pkz9sfyFXZ89/eXQpoaNWtqKSREqlfXXtoeQOlEbAcAAAAAAACA25CcbHQuMnNQzzh3+ukIKS7u5rf38Uld7r1a2n9Tg3o1qVIl4g0AFLaKFS3d0026p5t9/I2NNdr3k7R7jx3hf/5Zio6W1oZLa8Pt+O7lJTVpbNQsxFJIU6nx3ZKnJ8dvoLQgtgMAAAAAAADADcTFZQ3omYP62XNSSsrNb1+5UtbZ6WlhPaia5OfHUsQA4Mx8fCy1ayu1a2sfqxMTjQ4ctJee37PXaO9e6WqstHWbtHWbHd/d3KSGDTLO+960qeRXlmM9UFIR2wEAAAAAAABA0vkLdkQ5eNDo4CHp4CHpwoWb38bDPTWmB0rVgjKWe69WzV7undmNAFByeHjYs9dDmkqSpZQUo2O/SHsynff9wgVp30/2x8xZRpYl1amdEd+bhUiVKvG3ASgpiO0AAAAAAAAASp0LaWH9kHTwkP35jcJ6OT87pFcLTJ2VHpQa1AOlgADJxYVoAgClkaurpfr1pPr1pKFDLBljFBFhz3xPi++nTklHj9kf8xfYs98DA42aZYrvNWqw0glQXBHbAQAAAAAAAJRoFy/aM9XtuG6H9fPns2/n4iLdVVNq2EBq0MBSg2Cpdi3J15cAAgC4NcuyFBQkBQVJ/fvZfzsuXLDP9757r9GePdKRo9KZM/bH8hV2fPf3l0KaGjVraikkRKpXV3Jz428PUBwQ2wEAAAAAAACUGNHRRgcOSQdTl4M/cFCKukFYr5kW1oPtsF6/nuTlRdwAAOSfihUt3dNNuqeb/fclNtZo776M+L5/vxQdLa0Nl9aG2/Hdy0tq0tioWYi9bH3juzktCeCsiO0AAAAAAAAAiqXoS0YHD2bMWD94UIqMyr6dZdkz1htcF9a9vQkXAIDC5eNjKbSdFNrO/huUmGi/MWz3HmnPXqO9e6WrsdLWbdLWbXZ8d3OTGjbIOO9706aSX1n+hgHOgNgOAAAAAAAAwOldupR1KfiDh6Rz57JvZ1lSzRqZZqw3IKwDAJyXh4c9ez2kqSRZSkkxOvaLtCfTed8vXJD2/WR/zJxlZFlSndoZ8b1ZiFSpEn/ngKJAbAcAAAAAAADgVC5fvi6sH5TO3iCs16ie9RzrwfUJ6wCA4svV1VL9evYbxYYOsWSMUUSEPfM9Lb6fOiUdPWZ/zF9gz34PDDRqlim+16hhn0MeQMEitgMAAAAAAAAoMleuZArrB+3Pz5zNedsaNbKeYz24vr0cLwAAJZVlWQoKkoKCpP797L95Fy4Y7dmbcd73I0elM2fsj+Ur7Pju7y+FNDVq1tRSSIhUr67k5sbfTCC/EdsBAAAAAAAAFIorMdedY/2QHQZyUr169rDu60skAACgYkVL93ST7ulm/12MjTXauy8jvu/fL0VHS2vDpbXhdnz38pKaNDZqFmIvW9/4bsnTk7+rwJ0itgMAAAAAAADId1dijA4dUuqsdTusR0TkvG31IKlBalhv2ICwDgBAXvj4WAptJ4W2s/92JiYa7T8g7dkr7dlrtHevdDVW2rpN2rrNju9ublLDBhnnfW/aVPIry99eIK+I7QAAAAAAAADuSEyM0aHDmcL6Qen0DcJ6UDU7rDfMdI71sry4DwBAvvHwsM/b3ixEkiylpBgd+0Xak+m87xcuSPt+sj9mzjKyLKlO7Yz43ixEqlSJv8/ArRDbAQAAAAAAAOTa1at2WM98jvVTp3Petlo1qUFwprAezKw5AAAKm6urpfr1pPr1pKFDLBljFBEh7c4U30+dko4esz/mL7BnvwcGGjvap8b3GjXsc8gDyEBsBwAAAAAAAJCj2Fg7pmdeCv7UqZy3DQzMGtYbBEt+frwgDwCAs7EsS0FBUlCQ1L+f/bf6wgWjPXszzvt+5Kh05oz9sXyFHd/9/aWQpkbNmloKCZHq1ZXc3Phbj9KN2A4AAAAAAABAsbHXLQV/SPr115y3Daxqx/QGDTLOsV6uHC+2AwBQXFWsaOmebtI93ey/57GxRnv3ZcT3/ful6Ghpbbi0NtyO715eUpPGRs1CLIU0lRrfLXl68nwApQuxHQAAAAAAAChl4uKyn2P911OSMdm3rVol6znWGwQT1gEAKOl8fCyFtpNC29l/8xMTjfYfkPbslfbsNdq7V7oaK23dJm3dZj+BcHeXevU0GjPKUmAgzxVQOhDbAQAAAAAAgBIsLs7o8BHp4MGMGesnf805rFepkn0p+PLlebEcAIDSzsPDPm97sxBJspSSYnTsF2lPpvO+X7ggLV0mrVxlNLC/0ahHLVWuzPMIlGzEdgAAAAAAAKCEiI/PmLF+8JA9Y/3EyZzDeuXK14X1BpI/YR0AAOSCq6ul+vWk+vWkoUMsGWP008/SZ58bbd0mLVgkLV1mdN8go0cfsVSxIs8xUDIR2wEAAAAAAIBiKD4+dcZ6alg/cFA6eVJyOLJvW7lSxjnWGzSQGgZL/v686A0AAPKHZVlq0lh6/x1Lu3YbTfnMnu0eNldatMRo6BCjEQ9ZnIoGJQ6xHQAAAAAAAHByxthLte7aZS8FfyB1xnpOYb1SQPZzrFeowAvbAACgcDRvZmnCB9K27dKUz4x+3i/NnCUtWGg0/AGjB4dZKluW5yYoGYjtAAAAAAAAgBM6e9Zo2w5p23aj7Tuk6Ojs2wQEZD/HOsu0AgCAomZZltq0llq3kn7cJH061T7VzRfTpDnzjB5+UBo2VPL25nkLijdiOwAAAAAAAOAELl822rEzI66fOp31+jJlpJCmUpPGGedYDyCsAwAAJ2ZZljq0l0LbSevW29H9l+P2jPdvwqQRj0hDBktlyvCcBsUTsR0AAAAAAAAoAteuGe3ZK23bYbRtu3T4sGRMxvWuLtLdd9szwlq3snR3I8ndnReiAQBA8ePiYqlrF6lTR+m7H6SpXxj9+qv00cdGX8+WRj4qDRooeXryXAfFC7EdAAAAAAAAKATJyUYHD9nnL92+w2jvPikpKes2dWpLrVracb15M8nHhxecAQBAyeHqaqlXD+mertLKVdLnXxqdOSt98KHRrK+lUSOlAf14gyGKD2I7AAAAAAAAUACMMTpxUtq+3V4afucu6Wps1m0qV06dud7SUsuWLAsPAABKBzc3S/37Sb16St8uk6ZNN4qMkt55z2jGTGnMY1LvXvZ2gDMjtgMAAAAAAAD5JCrKaNsOe+b6tu3S+fNZry9bVmrZwp653rqVVD3IPpcpAABAaeTubmnwIKlfH2nREmn6V/ZM9zf/bTR9pjR2tNTjHnsZesAZWcZkPhMUrhcdHV3Uu1Bi+fv78+8LAIWMYy8AFD6OvQBQ+Arz2Hv1qj1jfdt2o+07pOMnsl7v4S6FhEitWlpq00qqX99ePhUAShqe9wLID9euGc1bIM2YaXT5ij1Wu5Y0bqylLp15k+L1OPYWLH9//1tuw8x2AAAAAAAAIJcSE432/WTH9W3bpQMHJYcj43oXF6lBsL00fKuWlpo2kTw9eVEYAAAgN8qUsfTIQ9LgQVLYXGnWbKNfjkt/fs0ouL70+BipQ3uiO5wHsR0AAAAAAAC4AYfD6PARadt2e2n43XukhISs29SokXre9VaWWjSX/Mry4i8AAMCd8Pa29NhIachgaXaY0eww6dBh6Y+vGt3dSHricfv5F9EdRY3YDgAAAAAAAKQyxuj0aWnbDnv2+o6d0pUrWbepWCFj5nqrVlKVyrzICwAAUBDKlrU0bqylB4YYzZxtNHee9PN+6YWXjJo3k8aNlZo347kYig6xHQAAAAAAAKXaxYtG23emnnd9u3T2XNbrvb2lFs3tmeutWtrnDWUWFQAAQOEpX97SM09ZevABo69mGi1cJO3aLT37vFHrVkbjxlpq0pjnZyh8xHYAAAAAAACUKnFx9nLwaeddP3os6/VublKTxnZcb91KathAcnPjxVsAAICiVrGipeefs/Twg0bTvjJastQ+3c+27UYdQo0eH2upQTDP21B4iO0AAAAAAAAo0ZKTjX76WdqeujT8Tz9LKSlZt6lfL2Np+GYhkpcXL9ICAAA4q8qVLb30oqURDxt9Md1o+XJp4yZp4yajrl2MHh9tqU4dns+h4BHbAQAAAAAAUKIYY3T0mEmf5bRrtxQfn3WbwEA7rrduZallC8m/PC/GAgAAFDeBgZZeednSo48Yff6F0ao10tpwKXydUY/uRmNHW6pZg+d5KDiWMcYU9U44s+jo6KLehRLL39+ff18AKGQcewGg8HHsBYDCcfas0bbUmes7d1q6cDHrS17ly0ktW2acdz2oGi+6AkB+4nkvAGdw7BejqV8Y/bDWvuziIvXtLY1+zFK1wJL3/I9jb8Hy9/e/5TbMbAcAAAAAAECxc/my0Y6ddlzfvkM6dTrztUZlykjNQlLPu95SqltXcnEpeS+wAgAAIEOd2pb+8XdLhw8bffq50YaN0tLl0opVRgP6Gz020lKVyjwnRP4htgMAAAAAAMDpXbtmtGevtG2HvTz84cNS5vUaXV2kRo3speG7dfVTzRox8vDghVQAAIDSqH59S/9+09LP+40+nWq0Zau0aLG0bLnRffcaPTrCUkBFnivizhHbAQAAAAAA4HSSk40OHpK2bZe27zDau09KSsq6Te1aUqvU8663aCb5+NgvmPr7uys6mhdPAQAASru7G1l6721Lu/cYTfnMaNduac48afG3RkMGGz3ysCX/8jxvxO0jtgMAAAAAAKDIGWN04qS0fXvqedd3SVdjs25TuZI9c71VS0utWonZSAAAAMiVZiGWPvyvtH2H9OlUo30/SbNmSwsWGQ0bavTQg5b8yvLcEnlHbAcAAAAAAECRiIoy2rbDnrm+bbt0/nzW6319pZYtMs67XqOGZFm8CAoAAIC8sywr9Y2b0qbN0pSpRocOSdO+kubNN3roQWnY0IzVkoDcILYDAAAAAACgUFy9as9Y37bdaPsO6fiJrNd7uEtNm6bG9VZScH3J1ZUXOwEAAJB/LMtS+1AptJ20br090/3YL/Z/v5kjjXhYGjJY8vLieShujdgOAAAAAACAApGYaC/RuW27PXP9wEHJ4ci43rKkBsEZS8OHNJU8PXlREwAAAAXPsix16Sx16ih9/4P02edGJ3+VJn1i9PU30shHpPsG8fwUN0dsBwAAAAAAQL5wOIwOH5G2bbeXht+9R0pIyLpN9ep2XG/TylKL5pKfHy9eAgAAoOi4uFjq0V3q2kVatUb6/EujiAjpfxONZs2WRo2UBvaX3N153orsiO0AAAAAAAC4LcYYnT4tbdthz17fsVO6ciXrNhX8pVat7KXhW7WUqlbhRUoAAAA4Hzc3S/36SL16SEuXS19MM4qMlN5932jGTGn0Y1Lf3vZ2QBpiOwAAAAAAAHLN4TD6eb8Uvs4ofJ106nTW6728pBbNU8+73lKqXdteohMAAAAoDtzcLA0aaIf1xUukaV8ZnT0nvfUfo69mSmMfk3p0l1xdeY4LYjsAAAAAAABuITnZXhJ+bbhR+Hrp/PmM69zcpMZ3p8b1VlKjhsz2AQAAQPHn4WFp6BBpQH9p/kJpxkyjU6ek1/9pNG2G9Phoe+l5Fxee+5ZmxHYAAAAAAABkk5BgtHW7FB5utH5j1uXhvbykDqFSly6W2reTvL15gREAAAAlU5kylh5+ULrvXmnufGnm10bHj0v/9zejenWlcY9LHduzmlNpRWwHAAAAAACAJCk21ujHTdLadUabNknx1zKuK+cndeokde1sn3vd05MXEwEAAFB6eHtbGjlCuv8+aXaY0eww6chR6U+vGjVqJI0bI7VtQ3QvbYjtAAAAAAAApVj0JaMNG+zAvm27lJSUcV2lAHtpzC6dLYU0ZXl4AAAAwNfX0uNjLD0wxGjWbKM586T9+6Xfv2wU0lQaN1Zq2YLnzaUFsR0AAAAAAKCUORdptG69fQ723XskhyPjuurVpW6pgb1hA85BCQAAAOSkXDlLTz9pafgDRjNmGc1fIO3ZK/32BaNWLY2eeNxSk8Y8ly7piO0AAAAAAAClwMmTRmvXSeHrjPYfyHpdcH07rnfpLNWuxdKXAAAAQG5VqGDpud9Yemi40bQZRouXSNt3SNt3GLUPNXp8jKWGDXh+XVIR2wEAAAAAAEogY4wOH7Fnr69dJx0/nnGdZUlNGktdu9iBvVogL/4BAAAAd6JSJUu//52lEQ8ZfTndaOky6cdN0o+bjDp3Mho31lLdOjzvLmmI7QAAAAAAACVESorRvp/s2evh66QzZzOuc3WVWrW0Z7B37ihVrMgLfQAAAEB+q1rV0h//YGnEw0afTzNauUpat15av8GoezejsaMt3XUXz8VLCmI7AAAAAABAMZaUZLRjpx3Y162XLkZnXOfpKbVrK3XtbKl9e8mvLC/qAQAAAIWhenVL//eqpZEjjKZ+YfTd99Ka76Xv1xr17mU0ZpSloCCenxd3xHYAAAAAAIBi5to1o81bpfBwow0bpauxGdf5+kgdO0hdulhq10YqU4YX8AAAAICiUusuS6//NTW6f260boO0fIW0arVR/35Gj420VLUKz9mLK2I7AAAAAABAMRATY7TxR2ntOqPNW6SEhIzr/P2lLp3sJeJbtpDc3XmxDgAAAHAm9etZ+tc/Le0/YPTpVPs5/eIl0vIVRvcOMBr1qKWAAJ7HFzfEdgAAAAAAACd14YI98yV8ndH2HVJKSsZ1gVWlLp3twN6kseTqygtzAAAAgLNr1NDSu/+xtGevHd137JTmLZCWLDW6f7DRow9b8vfnuX1xQWwHAAAAAABwIhFnjMLX2YF97z7JmIzratWSunaWunaxVL+eZFm8CAcAAAAURyFNLf3vfUs7dhpN+cx+7j/7G2nRIqMHhho9/KAlPz+e7zs7YjsAAAAAAEARMsbo+Alpbbgd2A8dznp9o4b27PWunaWaNXmxDQAAAChJWraw9NGH0uYt0qdTjQ4clKbPkOYtMHpwmDT8AcnXl/8PcFbEdgAAAAAAgEJmjP0i2tpwo7XrpF9/zbjOxUVqFmLPXu/cSapSmRfWAAAAgJLMsiyFtpPatZXWb5A+/dzo6FFp6hdGYXOlRx6Sht4veXvz/wbOhtgOAAAAAABQCJKTjfbstWevh6+TIqMyrnN3l9q0smewd+wo+ZfnRTQAAACgtLEs+w23HTtI36+Vpn5udOKk9MkUo9lh0sgR0uBBkqcn/7/gLIjtAAAAAAAABSQx0WjbdmntOqMNG6RLlzOu8yojtW8vdelkqX2o5OPDC2YAAAAAJBcXSz3ukbp1kVavsWe4n46QPpxoNGu2Hd3vHVDUewmJ2A4AAAAAAJCv4uKMftxsz2D/cZMUF5dxnZ+f1KmD1KWLpTatmJECAAAA4MZcXS316S316C4tXyF9Ps3o3Dnp/Q+MZn4t/d+riWrerKj3snQjtgMAAAAAANyhy5eNNmy0Z7Bv3SolJmVcFxAgdelkn4O9WYjk5kZgBwAAAJB7bm6WBg6QeveSliyVpn1lR/d/vBmrObOLeu9KN2I7AAAAAADAbYiKMgpfb89g37VLSnFkXFc9SOrSxV4i/u5G9jKQAAAAAHAnPDwsDRksDegnrf5OqlfXV9LVot6tUo3YDgAAAAAAkEunThmtXSetDTf6eX/W6+rVtWevd+ks1aktWRaBHQAAAED+8/S0NKCf5O/vrujoot6b0o3YDgAAAAAAcAPGGB05as9eD18nHT2W9fqmTaTOnSx17SwFBRHXAQAAAKA0IbYDAAAAAABk4nDYs9bXhtuz2CMiMq5zdZFatLBnsHfuKAUEENgBAAAAoLQitgMAAAAAgFIvOdlo5y5p7TqjdeulCxcyrvPwkNq1kbp0sdSxveTnR2AHAAAAABDbAQAAAABAKZWQYLRlqx3YN2yUYmIyrvPxkTq0l7p2ttSureTlRWAHAAAAAGRFbAcAAAAAAKXG1atGGzfZ52DftFm6di3juvLlpc6dpC6dLbVqIXl4ENgBAAAAADdGbAcAAAAAACVadLTR+g32DPZt26Xk5IzrqlSRunSyz8HetInk6kpgBwAAAADkDrEdAAAAAACUOGfPGYWvs2ew79krORwZ19W6S+rc2V4ivkGwZFkEdgAAAABA3hHbAQAAAABAiXD2nNGq1dIPa40OHsp6XYNge/Z6l85SrbuI6wAAAACAO0dsBwAAAAAAxda1a0Zrw6VlK4y275CMscctS2oWYp9/vUsnqWpVAjsAAAAAIH8R2wEAAAAAQLFijL00/LLlRt/9IMXFZVzXornUs4elzh2lChUI7AAAAACAgkNsBwAAAAAAxcLZs0bLV9qR/XRExnhgoNS/r6U+vaVqgQR2AAAAAEDhILYDAAAAAACnFR9vtHadHdi378gY9/KS7ulmR/aQppKLC5EdAAAAAFC4iO0AAAAAAMCpOBz2MvFLlxt9/4MUH59xXauWUr++lrp2lry8COwAAAAAgKJDbAcAAAAAAE4h4ozR8hXSshVGZ85kjAdVswN7395S1aoEdgAAAACAcyC2AwAAAACAIhMXZ/TDWjuw79yVMe7tLXXvZkf2kKaSZRHZAQAAAADOhdgOAAAAAAAKlcNhtGu3fR72H9ZK8dfsccuyl4nv39dSl85SmTIEdgAAAACA8yK2AwAAAACAQnH6tNHylfZS8WfOZoxXr24H9j69pSqVCewAAAAAgOKB2A4AAAAAAApMXJzRdz9Iy1fYs9nT+PhI3e+xI3uTxiwTDwAAAAAofojtAAAAAAAgXzkc9vnXly43WhsuXcu0THyb1vZ52Lt0kjw9CewAAAAAgOKL2A4AAAAAAPLFqVNGy1YYLV8pnTuXMV6zhh3Y+/SSKrNMPAAAAACghCC2AwAAAACA2xYba/Td99KyFUZ79maM+/pIPbrbkb3x3SwTDwAAAAAoeYjtAAAAAAAgT1JSjHbslJYtN1q7TkpIsMddXOxl4vv3tdSpI8vEAwAAAABKNmI7AAAAAADIlZO/2svEr1ghRUZljNe6K2OZ+IAAAjsAAAAAoHQgtgMAAAAAgBu6etVozffS8hVGe/dljPv6Sj172LPYGzVkmXgAAAAAQOlDbAcAAAAAAFmkpBht3yEtXW4Uvk5KTLTHXVykdm3tWewd27NMPAAAAACgdCO2AwAAAAAASdKJE6nLxK+Uos5njNeqZc9g791LCqhIYAcAAAAAQCK2AwAAAABQql2JMfruO2nZCqOffs4Y9/OTena3I3uDBiwTDwAAAADA9YjtAAAAAACUMikpRlu3ScuWG61bLyUm2eOuLlK7dnZg79Be8vAgsAMAAAAAcCPEdgAAAAAASolfjmcsE3/hQsZ4ndpS/36WevWQKrJMPAAAAAAAuUJsBwAAAACgBLtyxWh16jLx+/dnjJfzk3r1lPr1tRRcn2XiAQAAAADIK2I7AAAAAAAlTHKyvUz80uVG6zdISWnLxLtK7UPtwN4hVHJ3J7ADAAAAAHC7iO0AAAAAAJQQx47Zy8SvXCVduJgxXreuNKCvpV49JX9/AjsAAAAAAPmB2A4AAAAAQDF2+bLR6jX2MvEHDmaMly9nLxPfv6+l+vUJ7AAAAAAA5DdiOwAAAAAAxUxystGmLdLy5UbrN0rJyfa4q6vUob0d2EPbsUw8AAAAAAAFidgOAAAAAEAxcfSY0dLl9jLx0dEZ48H17fOw9+wh+ZcnsAMAAAAAUBiI7QAAAAAAOLFLl4xWpS4Tf+hQxri/v9S7l9Svj6V6dQnsAAAAAAAUNmI7AAAAAABOJjnZaNNmaelyo40/ZiwT7+Ymdexgz2IPbSu5uRHZAQAAAAAoKsR2AAAAAACcxOEjRsuWG61cLV26lDHeINg+D3vPHlK5cgR2AAAAAACcAbEdAAAAAIAiFB1ttGq1vUz84SMZ4xXSlonva6luHQI7AAAAAADOhtgOAAAAAEAhS0oy+nGTtGy50cZNUkqKPe7ubi8T37+vpbZtWCYeAAAAAABnRmwHAAAAAKAQGGPPXF+63Gj1aunS5YzrGjW0Z7D37C75+RHYAQAAAAAoDojtAAAAAAAUoIsX7XOwL1thdPRoxnjFilKfXlLfPpbq1CawAwAAAABQ3BDbAQAAAADIZ8YY7dkrzZlnFB4upTjscXd3qXMnexZ7m1YsEw8AAAAAQHFGbAcAAAAAIJ8kJhqt+U4Km2d06FDG+N2N7POwd+8u+ZUlsAMAAAAAUBIQ2wEAAAAAuEPnLxgtXGS0YJEUHW2PeXjYy8QPHWKpXl0COwAAAAAAJQ2xHQAAAACA2/TzfqM5c42++0FKTrbHKleS7h9s6d4BUvnyRHYAAAAAAEoqYjsAAAAAAHmQnGz0w1opbK7RTz9njDdtIg17wFKXTpyLHQAAAACA0oDYDgAAAABALkRfMlq0WJq/0Oj8eXvM3V3q0V16YIilhg0I7AAAAAAAlCbEdgAAAAAAbuLwYaOweUarV0uJSfZYBX9p8H2WBg+SKlQgsgMAAAAAUBoR2wEAAAAAuE5ystGGjfZS8bt2Z4w3bCANG2qp+z2SuzuRHQAAAACA0swpY/u5c+e0bNkyhYeH69ixYzp//rzKlSunli1baty4cWrWrFmu7mfz5s0aNWrUDa//17/+pSFDhuTXbgMAAAAAirkrMUZLvpXmzjc6d84ec3WRunW1z8fe+G7JsojsAAAAAADASWP79OnTNWXKFNWsWVMdO3ZUhQoVdOLECa1evVqrV6/Wu+++q/79++f6/tq2bau2bdtmG2/UqFF+7jYAAAAAoJj65bjRnLlGK1ZJ167ZY+X8pEGDpPsHWapcmcAOAAAAAACycsrYHhISounTp2cL5Nu2bdPo0aP1t7/9TT179pSHh0eu7q9t27Z67rnnCmJXAQAAAADFlMNh9OMme6n4bdszxuvWtZeK79VD8vQksgMAAAAAgJw5ZWzv3bt3juOtW7dWu3bttH79eh08eFBNmzYt5D0DAAAAABR3sbFG3y6T5s4zOh1hj7m4SJ062pG9eTOWigcAAAAAALfmlLH9Ztzc3LL8NzeOHz+uL774QgkJCapSpYrat2+vKlWqFNQuAgAAAACc0K+njObOs0N7fLw95usr3TtAGjLYUmAggR0AAAAAAOResYrtERER2rhxoypVqqTg4OBc327JkiVasmRJ+mU3Nzc9+uijevnll+Xq6loQuwoAAAAAcALGGG3dJs2Za/TjZskYe7zWXdIDQyz16S15eRHZAQAAAABA3lnGpL3U4NySkpI0ZswYbd26Vf/+9781ePDgW97m8OHD+v7773XPPfcoKChI8fHx2rlzp959910dO3ZMY8aM0Z/+9Keb3ofD4ZCLi0s+fRUAAAAAgMIQF2e0aEmCZsy6pmPHUtLHu3Z216Mjyqh9qDtLxQMAAAAAgDtSLGK7w+HQH/7wBy1ZskTDhw/XG2+8cUf3FxUVpUGDBunKlSsKDw9XxYoVb7htdHT0HT0Wbszf359/XwAoZBx7AaDwcewtXGfOGM1bYLT4W+nqVXvM21vq308aer+lGtUJ7EBpwLEXAAofx14AKHwcewuWv7//Lbdx+mXkHQ6HXn31VS1ZskSDBg3S3//+9zu+z0qVKqlHjx4KCwvT7t271b1793zYUwAAAABAUTDGaOcuac48o/UbJIfDHq8eJA0dYql/X8nHh8gOAAAAAADyl1PHdofDoVdeeUULFizQwIED9dZbb+Xbku5p70SIj4/Pl/sDAAAAABSuhASjVaulsHlGR49mjLdpLQ0baim0neTiQmQHAAAAAAAFw2lje+bQ3r9/f/3nP/+Rq6trvt3/7t27JUlBQUH5dp8AAAAAgIIXGWk0f5HRokXS5Sv2WJkyUt/e9kz22rUI7AAAAAAAoOA5ZWxPWzp+wYIF6tu3r95+++2bhvaLFy8qOjpa/v7+qlChQvr4vn371KRJk2zbf/nll9q8ebNq1aqlpk2bFsjXAAAAAADIP8YY/fSzFDbH6Ie1UkrqUvFVq0hD7rc0cIDkV5bIDgAAAAAACo9TxvaJEydq/vz58vb2Vq1atTRp0qRs2/Ts2VONGjWSJM2YMUMTJkzQs88+q+eeey59m9/+9rdyc3NTkyZNVKVKFcXHx2v37t36+eef5efnd8uIDwAAAAAoWomJRt//IIXNNTpwMGO8eTN7qfiOHSQ3NyI7AAAAAAAofE4Z20+fPi1JiouL08cff5zjNkFBQemx/UYeeughrV+/Xlu3btWlS5fk4uKiatWq6bHHHtPYsWNVtWrVfN93AAAAAMCdu3jRaMEiacFCo4vR9piHu9Srl/TA/Zbq1yewAwAAAACAomUZY0xR74Qzi46OLupdKLH8/f359wWAQsaxFwAKH8fevDlw0ChsrtF330tJSfZYQIB0/32WBt0r+ZcnsgO4NY69AFD4OPYCQOHj2Fuw/P39b7mNU85sBwAAAACUHsnJRmvXSXPmGu3dlzHepLH0wBBL3bqyVDwAAAAAAHA+xHYAAAAAQJG4dMlo8bfS/AVGkVH2mJub1OMe6YGhlho1JLADAAAAAADnRWwHAAAAABSqI0eN5sw1WrlaSky0x/z9pcGDpPsGWQqoSGQHAAAAAADOj9gOAAAAAChwKSlGGzZKYXONdu7KGA8OloYNtdTjHsnDg8gOAAAAAACKD2I7AAAAAKDAxMQYLVkqzZtvdOasPebqInXpYkf2pk0kyyKyAwAAAACA4ofYDgAAAADIdydOGIXNM1q+Qrp2zR7z85MGDZTuH2ypSmUCOwAAAAAAKN6I7QAAAACAfOFwGG3eYi8Vv2Vrxnid2vYs9t69JE9PIjsAAAAAACgZiO0AAAAAgDsSF2e0dLk0Z57RqVP2mGVJnTpIwx6w1KI5S8UDAAAAAICSh9gOAAAAALgtp08bzZln9O0yKS7OHvP1kQYMkIYMthRUjcAOAAAAAABKLmI7AAAAACDXjDHatt2exb7xR8kYe7xmDemBoZb69pa8vYnsAAAAAACg5CO2AwAAAABu6do1oxWrpDlzjX45njEe2s4+H3ub1pKLC5EdAAAAAACUHsR2AAAAAMANnT1rNG+h0eIlUkyMPeZVRurfTxp6v6WaNQnsAAAAAACgdCK2AwAAAACyMMZoz14pbI5R+HrJ4bDHq1WTHrjfUv9+kq8vkR0AAAAAAJRuxHYAAAAAgCQpIcFozXf2+dgPHc4Yb9VSGvaApfbtJFdXIjsAAAAAAIBEbAcAAACAUu/8eaP5C40WLpYuXbLHPD2lPr3tmex16hDYAQAAAAAArkdsBwAAAIBS6qefjcLmGn3/g5SSYo9Vrmyfi31gf6lcOSI7AAAAAADAjRDbAQAAAKAUSUoy+n6tFDbXaP/+jPFmIdIDQyx17iS5uRHZAQAAAAAAboXYDgAAAAClQEKC0ZKl0oyZRpFR9pi7u9SrhzR0iKUGwQR2AAAAAACAvCC2AwAAAEAJdu2a0aLF0oyvjS5csMcqVpDuH2zpvnslf38iOwAAAAAAwO0gtgMAAABACRQXZ7RgkTRrtlF0tD1WubI0coSl/n0lT08iOwAAAAAAwJ0gtgMAAABACRIXZzR3vjT7G6NLl+2xwKrSyEct9esjubsT2QEAAAAAAPIDsR0AAAAASoCYmNTIHmYUE2OPVQ+SRj1qqXcvyc2NyA4AAAAAAJCfiO0AAAAAUIxduWIUNtcobI50NdYeq1lDemykpR7diewAAAAAAAAFhdgOAAAAAMXQpUtGs8Ps2exxcfZY7Vp2ZL+nm+TqSmQHAAAAAAAoSMR2AAAAAChGLl40+vobo/kLpPhr9ljdutKYUZa6dJZcXIjsAAAAAAAAhYHYDgAAAADFwPnzRjO/Nlq4WEpIsMeCg+3I3rEDkR0AAAAAAKCwEdsBAAAAwIlFRhrNmGW0eImUmGSP3d1IGvOYpdB2kmUR2QEAAAAAAIoCsR0AAAAAnNDZs0ZfzTT6dpmUlBrZmzaxI3ub1kR2AAAAAACAokZsBwAAAAAncvq00fQZRstWSCkp9liL5nZkb9GcyA4AAAAAAOAsiO0AAAAA4ARO/mo0/SujlaukFIc91rqVNHqUpebNCOwAAAAAAADOhtgOAAAAAEXol+NG074yWvOd5EiN7KHt7MjepDGRHQAAAAAAwFkR2wEAAACgCBw9ZvTldKPvf5CMscc6drAje6OGRHYAAAAAAABnR2wHAAAAgEJ06LDRF9OMwtdljHXpbEf24PpEdgAAAAAAgOKC2A4AAAAAhWD/ATuyb9hoX7Ys6Z5u0mMjLdWtQ2QHAAAAAAAobojtAAAAAFCAdu1O0ocTHdq02b7s4iL16C6NetRS7VpEdgAAAAAAgOKK2A4AAAAABWD3HqPPvzTatv2KJMnVRerVSxo1wlLNmkR2AAAAAACA4o7YDgAAAAD5xBijnbukz7+0/ytJbm5S397SyBGWgoKI7AAAAAAAACUFsR0AAAAA7pAxRlu32ZF97z57zM1NGtBP+s348vL2vlK0OwgAAAAAAIB8R2wHAAAAgNtkjNGmzXZk/3m/PebhLg0cII14xFKVypb8/V0VHV20+wkAAAAAAID8R2wHAAAAgDwyxmjDRjuyHzxkj3l4SIMHSY88ZCkggOXiAQAAAAAASjpiOwAAAADkksNhFL5O+mKa0ZGj9liZMtL990kPDbdUsSKRHQAAAAAAoLQgtgMAAADALaSkGP2w1o7svxy3x7y8pAeGSMOHWfIvT2QHAAAAAAAobYjtAAAAAHADyclGa76Tpn1ldOKkPebjIw0bKg1/wJKfH5EdAAAAAACgtCK2AwAAAMB1kpONVq6yI/up0/ZY2bLSg8MsDb1fKluWyA4AAAAAAFDaEdsBAAAAIFVSktHyFdK0GUZnzthj5fykhx60NGSw5ONDZAcAAAAAAICN2A4AAACg1EtMNPp2mfTVTKNz5+wxf3/p4QctDR4keXsT2QEAAAAAAJAVsR0AAABAqZWQYLT4W2nGTKOo8/ZYxQrSiIctDbpXKlOGyA4AAAAAAICcEdsBAAAAlDrx8UYLF0uzvja6cNEeq1zJjuwDB0ienkR2AAAAAAAA3ByxHQAAAECpERdnNH+hNGu20aVL9liVKtLIEZb695U8PIjsAAAAAAAAyB1iOwAAAIASLzbWaO58afY3Rpev2GPVqkmjRljq01tydyeyAwAAAAAAIG+I7QAAAABKrCsxRnPmSt/MMbp61R6rXl16bKSlXj0kNzciOwAAAAAAAG4PsR0AAABAiXP5stE3c4zmzJNiY+2xWndJo0Za6nGP5OpKZAcAAAAAAMCdIbYDAAAAKDGiLxl9Pdto3gIpPt4eq1NbemyUpW5diOwAAAAAAADIP8R2AAAAAMXehQtGs2YbLVgkXbtmj9WvJ41+zFLnjpKLC5EdAAAAAAAA+YvYDgAAAKDYiooymvG10aLFUmKiPdawgR3ZO7aXLIvIDgAAAAAAgIJBbAcAAABQ7Jw9ZzRjltGSb6WkJHus8d12ZA9tS2QHAAAAAABAwSO2AwAAACg2Is4YfTXTaOkyKTnZHgtpKo15zFLrVkR2AAAAAAAAFB5iOwAAAACnd+qU0bQZRitWSCkOe6xlC2n0KEstmhPZAQAAAAAAUPiI7QAAAACc1smTRl9+ZbRqteRIjext20iPjbTULITADgAAAAAAgKJDbAcAAADgdI79YvTldKPvvpeMscfah9qRvUljIjsAAAAAAACKHrEdAAAAgNM4fMSO7D+szRjr3NGO7A0bEtkBAAAAAADgPIjtAAAAAIrcgYNGX04zWrchY6xbFzuy169PZAcAAAAAAIDzIbYDAAAAKDJHjxl9Mtlo4yb7smVJ3bvZkb1OHSI7AAAAAAAAnBexHQAAAEChO3/eaMpUo2XLJYdDcnGRevWQRj5qqdZdRHYAAAAAAAA4P2I7AAAAgEITF2c0a7bRrNnStWv22D3dpCcet1SzBpEdAAAAAAAAxQexHQAAAECBS042+naZ9NlUo4vR9ljTJtJvxltq0pjIDgAAAAAAgOKH2A4AAACgwBhjtGmzNPFjo+PH7bGgatL4pyx17SJZFqEdAAAAAAAAxROxHQAAAECBOHTYaOIko+077Mt+ftKYxywNHiS5uxPZAQAAAAAAULwR2wEAAADkq3ORRlM+M1qxUjJGcneXhg2VRo6wVLYskR0AAAAAAAAlA7EdAAAAQL6IjTX6aqbR7DApMdEe69VTevJxS4GBRHYAAAAAAACULMR2AAAAAHckOdlo0RJp6hdGly7ZY82bSb8Zb6lRQyI7AAAAAAAASiZiOwAAAIDbYozR+g3SR58Y/fqrPVazhvTM05Y6dpAsi9AOAAAAAACAkovYDgAAACDP9h8wmjjJaNdu+3L58tLY0ZYGDZTc3IjsAAAAAAAAKPmI7QAAAABy7cwZo08+NVq9xr7s4SE9OFx69GFLPj5EdgAAAAAAAJQexHYAAAAAt3Qlxmj6V0Zz5klJSZJlSX16S088bqlKZSI7AAAAAAAASh9iOwAAAIAbSkoymr9Q+mKa0ZUr9lirltJvxlsKrk9kBwAAAAAAQOlFbAcAAACQjTFGP6yVPp5sdDrCHqtVS/rN05ZC20mWRWgHAAAAAABA6UZsBwAAAJDFvp+MJnxktO8n+3LFCtLjYy317yu5uRHZAQAAAAAAAInYDgAAACDV6dNGkybbM9olqUwZ6eEHpYcftOTtTWQHAAAAAAAAMiO2AwAAAKXc5ctGX043mrdASk6WXFyk/n2lcWMtBQQQ2QEAAAAAAICcENsBAACAUiohwWjufGnadKOrsfZYu7bSM09bqluHyA4AAAAAAADcDLEdAAAAKGUcDqM130uTpxidOWuP1a0rPTveUpvWRHYAAAAAAAAgN4jtAAAAQCmya7fRxElG+w/YlwMCpCcft9Snt+TqSmgHAAAAAAAAcovYDgAAAJQCJ08aTZpstG69fdnLSxrxsKWHhktlyhDZAQAAAAAAgLwitgMAAAAlWPQlo8+/MFq4SEpxSK4u0r0DpbGjLVWoQGQHAAAAAAAAbhexHQAAACiBEhKMvpkjTZ9hFBdnj3XsII1/ylKtu4jsAAAAAAAAwJ0itgMAAAAliMNhtHK1NPlTo8hIeyw4WHp2vKWWLYjsAAAAAAAAQH4htgMAAAAlxPYdRhMnGR06bF+uUkV68nFLvXpKLi6EdgAAAAAAACA/EdsBAACAYu6X40aTPjbauMm+7OMjjRxhadhQydOTyA4AAAAAAAAUBGI7AAAAUExduGD02RdGS76VHA7J1VW6/z7psVGW/MsT2QEAAAAAAICCRGwHAAAAipn4eKPZYdKMmUbx1+yxrl2kp56wVLMGkR0AAAAAAAAoDMR2AAAAoJhISTFatkL6dKrR+fP2WKNG0rPjLTULIbIDAAAAAAAAhYnYDgAAABQDW7YaTZxkdPSYfTkwUHr6CUvd75Esi9AOAAAAAAAAFDZiOwAAAODEjhw1+uhjoy1b7cu+vtLoUZaGDJY8PIjsAAAAAAAAQFEhtgMAAABOKCrK6NPPjZYuk4yR3NykoUOkxx615OdHZAcAAAAAAACKGrEdAAAAcCJxcUYzvzaaNVtKSLDHut8jPfWEpaBqRHYAAAAAAADAWRDbAQAAACeQnGy0ZKk09XOji9H2WNMm0m/GW2rSmMgOAAAAAAAAOBtiOwAAAFCEjDH6cZP00cdGx0/YY9WDpPFPWerSWbIsQjsAAAAAAADgjIjtAAAAQBE5eMho4iSjHTvty+X8pDGjLd13r+TuTmQHAAAAAAAAnBmxHQAAAChkZ88ZTfnMaMVK+7KHuzTsAenRRyyVLUtkBwAAAAAAAIoDYjsAAABQSK5eNfpqptE3YVJikj3Wu6f05DhLVasS2QEAAAAAAIDihNgOAAAAFLDkZKOFi6XPvzC6dNkea95Mena8pYYNiewAAAAAAABAcURsBwAAAAqIMUbr1kuTJhv9+qs9dldNafzTljq2lyyL0A4AAAAAAAAUV8R2AAAAoAD8vN9o4iSj3Xvsy/7+0uOjLQ0cILm5EdkBAAAAAACA4o7YDgAAAOSjiDNGn0wxWvOdfdnTU3pouDTiYUve3kR2AAAAAAAAoKQgtgMAAAD54EqM0bTpRnPnS0lJkmVJ/fpI48ZaqlyZyA4AAAAAAACUNMR2AAAA4A4kJRnNXyB9Ps0oJsYea91K+s14S/XrEdkBAAAAAACAkorYDgAAANwGY4y+Xyt9MtnodIQ9Vqe29MzTltq1lSyL0A4AAAAAAACUZMR2AAAAII/27jOaOMlo30/25YoVpCcet9Svr+TqSmQHAAAAAAAASgNiOwAAAJBLp04ZfTzZ6Idw+7JXGenhhyw9NFzy9iayAwAAAAAAAKUJsR0AAAC4hcuXjb6YZjR/oZScLLm4SAP6S4+PsRRQkcgOAAAAAAAAlEbEdgAAAOAGEhKM5s6Xpk03uhprj4W2k555ylKdOkR2AAAAAAAAoDQjtgMAAADXcTiMVn8nTZ5idPacPVavrvSb8ZbatCayAwAAAAAAACC2AwAAAFns3Wf0wYdGBw7alysFSE+Os9S7l+TqSmgHAAAAAAAAYCO2AwAAAJKuXDGaNNlo8RL7speXNHKEpeEPSGXKENkBAAAAAAAAZEVsBwAAQKlmjNGKVdKEj4wuXbLHBvSXnhpnqUIFIjsAAAAAAACAnBHbAQAAUGqdOGH0zvtGO3fZl2vXkl560VKzECI7AAAAAAAAgJsjtgMAAKDUSUgwmvaV0YxZUnKy5OkpjXnM0oPDJHd3QjsAAAAAAACAWyO2AwAAoFTZstXo3feNTkfYlzuESi88bykwkMgOAAAAAAAAIPeI7QAAACgVzl8w+nCC0Zrv7cuVAqTf/dZSl86SZRHaAQAAAAAAAOQNsR0AAAAlWkqK0YJF0uRPjWJjJRcXadhQ6fExlry9iewAAAAAAAAAbg+xHQAAACXWwUNG77xntP+AfblRQ+kPv7cUXJ/IDgAAAAAAAODOENsBAABQ4sTGGn061WjufMnhkHx9pKeetDRooOTqSmgHAAAAAAAAcOeI7QAAACgxjDH6Ya30wQSj8+ftsZ49pOeesVSxIpEdAAAAAAAAQP4htgMAAKBEiDhj9P4HRj9usi8HVZN+/4Kltm2I7AAAAAAAAADyH7EdAAAAxVpSktHX30hfTDNKSJDc3KRHH5FGjrDk6UloBwAAAAAAAFAwiO0AAAAotnbvMXr7PaPjx+3LLVtIv/+dpbvuIrIDAAAAAAAAKFjEdgAAABQ7ly4ZffSJ0dJl9uXy5e3zsvfuJVkWoR0AAAAAAABAwSO2AwAAoNgwxmjpcumjSUaXr9hjg+6Vnn7Ckp8fkR0AAAAAAABA4SG2AwAAoFg49ovRu+8b7d5jX65bR3rpRUtNmxDZAQAAAAAAABQ+p4zt586d07JlyxQeHq5jx47p/PnzKleunFq2bKlx48apWbNmub4vh8OhGTNm6JtvvtGJEyfk7e2tDh066IUXXlCNGjUK8KsAAABAfrh2zejL6UYzv5ZSUqQyZaSxoy0Nf0BycyO0AwAAAAAAACgaThnbp0+frilTpqhmzZrq2LGjKlSooBMnTmj16tVavXq13n33XfXv3z9X9/Xaa68pLCxM9evX18iRIxUZGally5Zpw4YNmj17tmrVqlWwXwwAAABu24+bjd77r9GZM/blTh2l3/3WUtUqRHYAAAAAAAAARcsyxpii3onrrVy5UuXLl1fbtm2zjG/btk2jR4+Wt7e31q9fLw8Pj5vez6ZNm/TYY4+pTZs2mjp1avr2a9eu1ZNPPqlOnTrps88+u+l9REdH39kXgxvy9/fn3xcAChnHXhQXUVFGH0ww+mGtfblyZemF31rq3InIjuKHYy8AFD6OvQBQ+Dj2AkDh49hbsPz9/W+5jVPObO/du3eO461bt1a7du20fv16HTx4UE2bNr3p/YSFhUmSnn/++SxhvmvXrmrbtq3Wr1+viIgIVatWLf92HgAAALctJcVo3gJpymdGcXGSq4s0fJg05jFL3t6EdgAAAAAAAADOw6WodyCv3Nzcsvz3ZjZv3ixvb2+1bNky23WdO3eWJG3ZsiV/dxAAAAC35cABoyfGG33woR3aG98tfTrZ0m/GuxDaAQAAAAAAADgdp5zZfiMRERHauHGjKlWqpODg4JtuGxcXp6ioKAUHB8vV1TXb9XfddZck6cSJEwWyrwAAAMidq1eNpnxmz2g3RvL1lcY/ZeneAZKLC5EdAAAAAAAAgHMqNrE9KSlJL7/8shITE/XSSy/lGNAzi4mJkST5+vrmeH3aeNp2N1KuXDm5uBS7BQCKjdyc6wAAkL849sJZGGO0fEWi3no7VufP22P3DvDQS7/3UUBFnn+hZOHYCwCFj2MvABQ+jr0AUPg49hatYhHbHQ6H/vSnP2nr1q0aPny4Bg8eXGiPffny5UJ7rNLG399f0dHRRb0bAFCqcOyFszh92ujd/xpt2WpfrlFDeukFS61aJku6LH5MUZJw7AWAwsexFwAKH8deACh8HHsLVm7eyOD0sd3hcOjVV1/VkiVLNGjQIP3973/P1e3Kli0rSbp69WqO16eNp20HAACAgpeYaDTza2naV0aJiZKHuzTyUUsjHpY8PFgyHgAAAAAAAEDx4dSx3eFw6JVXXtGCBQs0cOBAvfXWW7le0t3b21uVKlXSqVOnlJKSkm3Z+bRztaedux0AAAAFa8dOo3ffNzpx0r7cupX0+xcs1ahOZAcAAAAAAABQ/DhtbM8c2vv376///Oc/tzxP+/Xatm2rb7/9Vjt27FCbNm2yXLdu3TpJyjYOAACA/BV9yWjiJKPlK+zLFfyl55611LO7ZFmEdgAAAAAAAADFU+6miReytKXjFyxYoL59++rtt9++aWi/ePGijh49qosXL2YZHz58uCTpgw8+UGJiYvr42rVrtWXLFnXq1ElBQUEF80UAAACUcg6H0eIlRo+MtEO7ZUmD75NmTLPUq4dFaAcAAAAAAABQrDnlzPaJEydq/vz58vb2Vq1atTRp0qRs2/Ts2VONGjWSJM2YMUMTJkzQs88+q+eeey59m9DQUA0bNkxhYWEaMmSIunbtqqioKC1dulTly5fXX/7yl0L7mgAAAEqTo8eM3nnPaO8++3L9etJLL1pqfDeBHQAAAAAAAEDJ4JSx/fTp05KkuLg4ffzxxzluExQUlB7bb+b1119XcHCwvvnmG02bNk3e3t7q1auXXnjhBdWsWTNf9xsAAKC0i483+nya0exvpJQUyauMNO5xS0Pvl9zcCO0AAAAAAAAASg7LGGOKeiecWXR0dFHvQonl7+/Pvy8AFDKOvShI6zcavf+B0blz9uWuXaTfPmupSmUiO0o3jr0AUPg49gJA4ePYCwCFj2NvwfL397/lNk45sx0AAADFx7lIow8+NApfZ1+uWkV64XlLHTsQ2QEAAAAAAACUXMR2AAAA3JbkZKM586TPphrFX5NcXaWHhkujR1ny8iK0AwAAAAAAACjZiO0AAADIs59+Nnr7XaMjR+3LTZtIL71oqW4dIjsAAAAAAACA0oHYDgAAgFy7EmM0eYrRwsWSMZKfn/TMU5b695NcXAjtAAAAAAAAAEoPYjsAAABuyRijVWukDycaRUfbY/36SM+Mt+RfnsgOAAAAAAAAoPQhtgMAAOCmTv5q9O77Rtt32Jfvqin9/gVLLVsQ2QEAAAAAAACUXsR2AAAA5CghwWjGLGn6DKOkJMnDQ3pspKVHHpLc3QntAAAAAAAAAEo3YjsAAACy2brN6N3/Gp06ZV9u20b6/e8sBQUR2QEAAAAAAABAIrYDAAAgk4sXjT78yGjVavtyxYrSb5+11L2bZFmEdgAAAAAAAABIQ2wHAACAHA6jRYuljycbXY2VLEsaer80bqwlX18iOwAAAAAAAABcj9gOAABQyh0+YvT2u0Y/77cvBwdLL79oqWFDIjsAAAAAAAAA3AixHQAAoJSKizP67AujOXOkFIfk7S098bilIYMlV1dCOwAAAAAAAADcDLEdAACglDHGaN166b//M4qMssfu6Sb99jeWKlUisgMAAAAAAABAbhDbAQAASpGzZ43e/5/Rho325cBA6cXnLbUPJbIDAAAAAAAAQF4Q2wEAAEqB5GSj2WHS518aXbsmublJDz8kPfaopTJlCO0AAAAAAAAAkFfEdgAAgBJuz16jd94zOvaLfblZiPTSi5Zq1yKyAwAAAAAAAMDtIrYDAACUUFeuGE36xGjxt/blcn7Sb8Zb6tdXsixCOwAAAAAAAADcCWI7AABACWOM0fKV0sSPjC5dtscG9JeeecpSuXJEdgAAAAAAAADID8R2AACAEuTECaN33jfaucu+XKuW9IcXLTULIbIDAAAAAAAAQH4itgMAAJQACQlG074ymjFLSk6WPD2l0aMsPTRccncntAMAAAAAAABAfiO2AwAAFHObtxi9+1+jiAj7cvtQ6YXnLVULJLIDAAAAAAAAQEEhtgMAABRT5y8YfTjBaM339uWAAOl3z1nq2kWyLEI7AAAAAAAAABQkYjsAAEAxk5JitGCRNPlTo9hYycVFemCING6sJW9vIjsAAAAAAAAAFAZiOwAAQDFy8JDRO+8Z7T9gX27UUPrD7y0F1yeyAwAAAAAAAEBhIrYDAAAUA7GxRp9ONZo7X3I4JB8f6aknLN13r+TqSmgHAAAAAAAAgMJGbAcAAHBya8ON3v+f0fnz9uUe3aXnfmMpoCKRHQAAAAAAAACKCrEdAADASV2JMfrvB0YrV9uXg6pJv3/BUts2RHYAAAAAAAAAKGrEdgAAACe0dZvRm28ZRZ2XXFykEQ9Lo0dZ8vQktAMAAAAAAACAMyC2AwAAOJH4eKNJnxjNW2Bfrl5d+ssrlpo0JrIDAAAAAAAAgDMhtgMAADiJn342euNNo1On7MtDBkvjn7Lk5UVoBwAAAAAAAABnQ2wHAAAoYklJRl9MM5o+Q3I4pEoB0it/5NzsAAAAAAAAAODMiO0AAABF6NgvRv/4l9GhQ/blXj2lF5635FeW0A4AAAAAAAAAzozYDgAAUAQcDqNv5kiTpxglJkl+ftLvX7DU4x4iOwAAAAAAAAAUB8R2AACAQnbmjNE/3zLatdu+3D5U+uMfLAVUJLQDAAAAAAAAQHFBbAcAACgkxhh9u0z63wSjuDjJq4z03LOW7h0gWRahHQAAAAAAAACKE2I7AABAIbh40eg/7xqt32BfbtpE+ssrloKCiOwAAAAAAAAAUBwR2wEAAArY2nVGb79jdOmy5OYmjRtr6eEHJVdXQjsAAAAAAAAAFFfEdgAAgAJy9arRBx8aLVthX65bV/q/Vy3Vq0tkBwAAAAAAAIDijtgOAABQALbvMPrnW0aRkZKLi/TIQ9LY0ZY8PAjtAAAAAAAAAFASENsBAADyUUKC0ceTjcLm2perVbPPzR7SlMgOAAAAAAAAACUJsR0AACCfHDhg9MabRidO2pfvu1f6zXhL3t6EdgAAAAAAAAAoaYjtAAAAdyg52WjaV9KX04xSHFLFitKfXrbUvh2RHQAAAAAAAABKKmI7AADAHThxwp7NfuCgfbn7PdLvf2epXDlCOwAAAAAAAACUZMR2AACA2+BwGM2ZJ3082SgxUfL1lV56wVLPHkR2AAAAAAAAACgNiO0AAAB5dPac0b/+bbR9h325bRvplZctVapEaAcAAAAAAACA0oLYDgAAkEvGGK1YJb3/gVFsrOTpKf1mvKX775Msi9AOAAAAAAAAAKUJsR0AACAXoi8ZvfOe0dpw+3Lju6W/vGqpRnUiOwAAAAAAAACURsR2AACAW1i/wejf7xhFR0uurtLjYyw98pDk5kZoBwAAAAAAAIDSyuVObtyoUSO9+uqrt9zuL3/5i+6+++47eSgAAIBCFxtr9K//OPSnP9uhvXYtacrHlkY9ahHaAQAAAAAAAKCUu6OZ7cYYGWNyvS0AAEBxsXOX0ZtvGZ05K1mW9NBwadxYS56eRHYAAAAAAAAAQCEtIx8TEyMPD4/CeCgAAIA7kpBgNOUzo9lhkjFSYFXpz69Yat6MyA4AAAAAAAAAyJDn2B4REZHlclxcXLaxNCkpKTp27Jg2bNigmjVr3t4eAgAAFJKDh4zeeNPo+HH78r0DpOd+Y8nbm9AOAAAAAAAAAMgqz7G9e/fusqyMF5xXrlyplStX3vQ2xhgNGzYs73sHAABQCJKTjb6aKX3+pVFKilTBX/rjHyx17EBkBwAAAAAAAADkLM+xvU2bNumfb926VRUrVlTt2rVz3NbDw0OVK1dW9+7d1atXr9vfSwAAgAJy8lejf7xp9PN++3LXLtJLL1ryL09oBwAAAAAAAADcWJ5ie0REhD788EOVL19ektSwYUN17txZ//rXvwpi3wAAAAqMMUbzFkgffWyUkCD5+kgvPG+pdy9lWcUHAAAAAAAAAICcuORl4x49eug///lP+uX7779fwcHB+b5TAAAABSky0ujFPxi9/4Ed2lu1lP6/vTsP12s8+L/9XZlkktiIKYJSQYsYY25LVTx0UIpWayyqNdQQkhBjRvOs6KRVivQpWq2WaovUEEQNFfQRggQJIoYkMuzr/WO/ya9pguwMe8p5HoejudZa972ue2e7pPnstdYvfl6lz26V0A4AAAAAwEKp15XtpZSUUuaOb7311nz9619f4pMCAFgaSim5+57koktK3n8/adcu+cFRVfbeK2nVSmQHAAAAAGDh1Su2L7/88nnttdeW1lwAAJaaKVNKLri45G9/rxtvtGEycECVtdcW2QEAAAAAqL96xfZNNtkkDz30UAYMGJDu3bsnSZ599tlcccUVn/jaqqpy9NFHL9osAQAWwwMPlpx7fslbbyetWyeHHFTlwG8nbdoI7QAAAAAALJqq/Od94T/Bv/71rxx11FGZNGlS/U9UVRkzZky9X9fYJk+e3NhTaLFqamp8fQEa2LK29k6dWnLFj0p+9/u68Tpr113NvuGGIjvQcJa1tRegKbD2AjQ8ay9Aw7P2Ll01NTWfeEy9rmz/7Gc/mz/96U956qmn8vrrr6d///7Zcsst841vfGORJwkAsDQ8+VTJ4GElEybUjfffNzny8CrLLSe0AwAAAACw+OoV25OkU6dO2XbbbZMk/fv3z1prrZWvf/3rS3xiAACLYsaMkp/+vOTGm5JSklVXTU7rX2WLzUV2AAAAAACWnHrH9v90zz33pGPHjktqLgAAi+Xf/1cyeGjJC2Prxnvsnhx3TJXOnYV2AAAAAACWrMWK7d27d19S8wAAWGSzZ9ddyf7Tn5fMmpWssEJyyklVPreTyA4AAAAAwNJRr9h+2223JUl23XXXdO7cee54Ye211171Oh4A4JOMH1/3bPannq4b77RDckrfKjU1QjsAAAAAAEtPvWJ7//79U1VVevXqlc6dO88df5JSSqqqEtsBgCWmlJLbf59ceVXJtOlJx47J8cdW+Z/ds1B/PgEAAAAAgMVRr9h+9NFHp6qq1NTUzDMGAGhIb75ZMuy8kodH1Y033yw5rX+V1Vbz5xIAAAAAABpGvWL7scce+7FjAICl7Z6/lVx4ccm77ybt2iZHHVnlG/skrVoJ7QAAAAAANJx6xXYAgMby7rslF11a8pd76sY9eyann1rlU+uI7AAAAAAANDyxHQBo8kY9UjL03JI330xat0oOOjA5+MAqbdoI7QAAAAAANI56xfYrrrhikU9UVVWOPvroRX49ALDsmTat5KprSm69rW7co0fd1eyf2UhkBwAAAACgcdU7tldVlVJKvU8ktgMA9fH0v0oGDy15dXzd+Bt71z2fvX17oR0AAAAAgMZXr9g+bNiwpTUPAIAkycyZJT/7RckNNya1tckq3ZIB/apsvZXIDgAAAABA01Gv2P71r399ac0DACBjx5YMGlry7/+rG/f5UnL8cVWWX15oBwAAAACgaalXbAcAWBpmzy65eUTy45+WzJyZdO2S9D2xys5fENkBAAAAAGiallhsf+ONN/LYY49l4sSJSZJVVlklW2yxRVZbbbUldQoAoAWa8FrJkGElTzxZN95+u6Rf3yorrSS0AwAAAADQdC12bH/jjTcyaNCg/PWvf00pZZ59VVVl5513zumnny66AwDzKKXkD39MLr2iZNq0pEOH5IfHVNlzj7o/QwAAAAAAQFO2WLH9jTfeyDe/+c289tpr6dChQ3bYYYd07949STJhwoSMHDky99xzT/71r3/l5ptvzqqrrrpEJg0ANG9vvVVy7gUlDzxYN+61aXJq/yrd1xDZAQAAAABoHhYrtl988cV57bXX8pWvfCWnnXZaVlhhhXn2T5kyJUOHDs3tt9+eSy65JMOGDVuc0wEALcDf7y05/8KSKe8mbdsmR3y3yv77Jq1bC+0AAAAAADQfixXb77vvvqy55poZPnx4WrduPd/+rl27ZujQoXnsscfy97//fXFOBQA0c++9V3LJ5SV/vqtuvP6nk9NPrbLuuiI7AAAAAADNT6vFefHUqVPTq1evBYb2OVq3bp1evXpl2rRpi3MqAKAZe+TRkoMPqwvtrVolB30nufZHQjsAAAAAAM3XYl3Zvu6662bixImfeNzEiROz7rrrLs6pAIBmaPr0kquvLfnNb+vGa3ZPBp5aZePPiuwAAAAAADRvi3Vl+8EHH5xHH300999//0ceM3LkyDz66KM56KCDFudUAEAz88yYksOO+H+hfa+vJT//idAOAAAAAEDLsFhXtm+99dY54IAD8v3vfz977LFH9thjj6yxxhpJkgkTJuTOO+/MH//4x3z7299O7969M2HChHleP+dYAKDlmDWr5BfXl/zy+mR2bbLyysmAU6ps01tkBwAAAACg5ahKKWVRX7zhhhumqqqUUlJVC/4L9I/aV1VVnnnmmUU9dYOZPHlyY0+hxaqpqfH1BWhgS3vtfWlcyaAhJc89Xzfe9YvJiT+s0qWL0A4su/y5F6DhWXsBGp61F6DhWXuXrpqamk88ZrGvbAcAqK0t+c3/JldfWzJjZrL88knfE6p8cReRHQAAAACAlmmxYvv111+/pOYBADRTr79eMmR4yeP/rBtvu03S/+QqK68stAMAAAAA0HItVmwHAJZdpZTc+afkkstLpk5N2rdPjvlBla99JR/5eBkAAAAAAGgp6hXbr7jiik88pqqqdOzYMauuumq23HLLrLrqqos8OQCgaZo8ueS8C0vuH1k33mTj5LT+VdZcU2QHAAAAAGDZUO/YXp8r1Vq1apXddtstZ5xxxkI9QB4AaPpGPVJyzpCSd95J2rRJDj+syrf2T1q3FtoBAAAAAFh21Cu277XXXp8Y20spmTZtWl555ZU8++yz+dOf/pSxY8fm5ptvTvv27RdrsgBA45k9u+QX1yc//0VJKcl66yYDT62y/qdFdgAAAAAAlj31iu3Dhw+v15u/9tprOfXUU/PQQw/lxhtvzGGHHVav1wMATcM779RdzT7qkbrx176SHHdMleWWE9oBAAAAAFg2tVqab7766qvnsssuS+fOnfPnP/95aZ4KAFhKnv5XyWFH1IX25Zaru5r95JNaCe0AAAAAACzT6nVl+6JYfvnls+WWW+axxx5b2qcCAJagUkp+89vkiqtKZs9OevRIhpxdZd11RXYAAAAAAFjqsT1JOnfunGnTpjXEqQCAJWDq1JLh55f89W91452/kPQ/uUqnTkI7AAAAAAAkDRTbX3311dTU1DTEqQCAxTR2bMnAM0tefiVp3To55gdVvrF3UlVCOwAAAAAAzLHUY/uTTz6ZJ598MrvsssvSPhUAsJj+dFfJ+ReWfPhhskq35Jyzqmz8WZEdAAAAAAD+21KJ7R9++GFeeeWV/P3vf8+Pf/zjlFLyzW9+c2mcCgBYAj78sOSyK0pu/33duPfWyRmnVVlhBaEdAAAAAAAWpF6xfaONNqr3CUopOeKII7LjjjvW+7UAwNI34bW628Y//3xSVckhByWHHFSldWuhHQAAAAAAPkq9YnspZaGPbd++fbbYYoscdNBB+cIXvlDfeQEADWDkAyWDh5a8/37StUtyxsAq2/QW2QEAAAAA4JPUK7bfc889n3hMVVVp3759VlhhhbRq1WqRJwYALD2zZpX85Gclv7qxbvzZz9Q9n33VVYR2AAAAAABYGPWK7d27d19a8wAAGshbb5WcNajk8X/WjffdJ/nBUVXathXaAQAAAABgYdUrtgMAzdujj83MiX1L3no76dAh6X9KlS/uLLIDAAAAAEB9ie0AsAwopeTGm5Jrf/JuZs9OPrVOMuScKmutJbQDAAAAAMCiENsBoIV7772SIcNLRv6jbtznS0nfE6t06CC0AwAAAADAohLbAaAFe/7fJQPPLJkwIWnbNjm1f6fsusvUVJXQDgAAAAAAi0NsB4AWqJSSO/6QXHxpyYyZyeqrJYPOrrLdtu0zefK0xp4eAAAAAAA0e2I7ALQw06eXXHhxyZ1/rhtvv10y8NQqXZZ3NTsAAAAAACwpYjsAtCAvv1Jy+pklL4xNWrVKjvhulW9/K2nVSmgHAAAAAIAlSWwHgBbib38vGXZeydSpyYo1yVlnVNlic5EdAAAAAACWBrEdAJq5WbNKfnRNyc0j6sab9aoL7SuvJLQDAAAAAMDSIrYDQDM2cWLJmeeUPPV03fiAbyVHfrdKmzZCOwAAAAAALE1iOwA0U488WnL2oJJ3piSdOyWnDaiy044iOwAAAAAANASxHQCamdrakl9cn/zsupJSkvU/nQw+u0r37kI7AAAAAAA0FLEdAJqRd94pOWdIyahH6sZf+XJy/LFVlltOaAcAAAAAgIYktgNAM/GvZ0pOP6tk4sRkueWSvidU+Z/dRXYAAAAAAGgMYjsANHGllPz21uTyq0pmzUrWXLPutvGfXk9oBwAAAACAxiK2A0ATNnVqybkXlNzz17rxFz6XDOhXpVMnoR0AAAAAABqT2A4ATdTYF0tOP7Nk3MtJ69bJ0UdV2fcbSVUJ7QAAAAAA0NjEdgBogu66u+S8C0umT0+6rZycc1aVTTYW2QEAAAAAoKkQ2wGgCZkxo+SyK0tuu71uvNWWyZkDq9TUCO0AAAAAANCUiO0A0ES89lrJ6WeVPPtc3fiQg5JDD67SurXQDgAAAAAATY3YDgBNwAMPlgwaWvLee0mXLsnpp1XZbhuRHQAAAAAAmiqxHQAa0axZJT+9ruT6X9WNN9ooGXRWldVWFdoBAAAAAKApE9sBoJG8/XbJWYNKRj9eN97n68nR36/Srp3QDgAAAAAATZ3YDgCN4IknS844u+Stt5IO7ZN+J1fZ9YsiOwAAAAAANBdiOwA0oFJKfn1zcs21JbNrk3XWTgafU2WdtYV2AAAAAABoTsR2AGgg771XMvTckvtH1o2/tGty8olVOnYU2gEAAAAAoLkR2wGgAfz73yUDzywZPyFp2zY57pgqe301qSqhHQAAAAAAmiOxHQCWsjv+UHLRJSUzZiarrZoMOrvKRhuK7AAAAAAA0JyJ7QCwlEyfXnLRpSV/vLNuvP22ycBTq3TpIrQDAAAAAEBz12Rj++23357HHnssTz/9dJ5//vnMnDkzw4YNy957773Q7/Hwww/noIMO+sj99X0/AFhYr7xad9v4F15IWrVKDj+syncOSFq1EtoBAAAAAKAlaLKx/dJLL8348eNTU1OTVVZZJePHj1/k9+rdu3d69+493/aNNtpocaYIAAt0730lQ88t+eCDpKYmOev0KltuIbIDAAAAAEBL0mRj++DBg7P22mune/fuufbaa3PhhRcu8nv17t07xx577BKcHQDMb9askh9dW3LzLXXjTTdJzj6jSrduQjsAAAAAALQ0TTa2b7/99o09BQBYaJMmlZxxdslTT9eNv7V/8r0jqrRpI7QDAAAAAEBL1GRj+5L00ksv5brrrsuHH36YVVddNdttt11WXXXVxp4WAC3Eo4+VnD24ZPLkpFOn5NT+VT6/k8gOAAAAAAAt2TIR2++4447ccccdc8dt2rTJd77znZxyyilp3br1x762a9euadWq1dKe4jKrpqamsacAsMhqa0t+/NNpueKqaamtTTbYoHUuvmD5rL3Wx/+3pbFZewEanrUXoOFZewEanrUXoOFZextXi47tK664Yk466aTsvPPO6d69e6ZNm5bHH388F154Ya677rpUVZX+/ft/7HtMmTKlgWa77KmpqcnkyZMbexoAi2TKlJJBQ0seerhuvOceyYk/rM1yy72bpry0WXsBGp61F6DhWXsBGp61F6DhWXuXroX5QYYWHdvXX3/9rL/++nPHHTt2zK677ppevXrlq1/9aq6//vocccQRWWmllRpxlgA0N8+MKTn9rJI33kjatUtOPL7Kl/dw23gAAAAAAFiWLJP3R+/WrVu++MUvZtasWXniiScaezoANBOllPz2tpIfHFsX2tfsnlxzldAOAAAAAADLohZ9ZfvHmXPZ/7Rp0xp5JgA0B1Onlpx/Ucndf6kbf26n5NR+VTp3FtoBAAAAAGBZtMzG9jlXtHfv3r2RZwJAU/fSuJKBZ5S8NC5p3So56ntVvrlfUlVCOwAAAAAALKtaxG3k33777bzwwgt5++2359n+9NNPL/D4X/ziF3n44YezzjrrZJNNNmmIKQLQTN19T8kR36sL7SutlFx2SZVv7V8J7QAAAAAAsIxrsle2jxgxIo899liS5Pnnn5+7bdSoUUmSLbfcMvvuu2+S5IYbbsgVV1yRY445Jscee+zc9zjuuOPSpk2bbLzxxll11VUzbdq0PPHEE3nmmWfSpUuXnH/++WndunUDfzIAmoMZM0ouv6rk1tvqxltukZw5sMqKK4rsAAAAAABAE47tjz32WG699dZ5to0ePTqjR4+eO54T2z/KN7/5zYwcOTKPPPJI3nnnnbRq1SprrLFGDj744Bx22GFZbbXVlsrcAWjeXn+95PSzSsY8Wzc++MDksEOqtG4ttAMAAAAAAHWqUkpp7Ek0ZZMnT27sKbRYNTU1vr5Ak/PgwyWDhpS8+26y/PLJGadV2W7blhPZrb0ADc/aC9DwrL0ADc/aC9DwrL1LV01NzSce02SvbAeAhjR7dsnPriv5xfV14w03SAadVWX11VtOaAcAAAAAAJYcsR2AZd7kySVnDSp57P9/UsnX90qO/UGVdu2EdgAAAAAAYMHEdgCWaU8+VXLG2SVvvpm0b5+c0rfKbruK7AAAAAAAwMcT2wFYJpVScvOI5EdXl8yuTdZeKxl8TpVPrSO0AwAAAAAAn0xsB2CZ8/77JcPOK7n3vrrxF3dJ+vWt0rGj0A4AAAAAACwcsR2AZcq//6/k9DNLXh2ftGmTHHt0lb33SqpKaAcAAAAAABae2A7AMuOPd5ZccHHJjBnJqqsmg86q8pmNRHYAAAAAAKD+xHYAWrwPPyy5+NKSO/5YN952m+T0U6t07Sq0AwAAAAAAi0ZsB6BFGz++ZOCZJf/+v6Sqku8eWuWg7yStWgntAAAAAADAohPbAWix7ru/ZOjwkvc/SFbompx5epWttxLZAQAAAACAxSe2A9DizJpVcs2PS359c914k42Ts8+ossoqQjsAAAAAALBkiO0AtChvvlly5jklTzxZN95/v+T7R1Zp00ZoBwAAAAAAlhyxHYAWY/TjdaF98uSkY8fk1H5VvvB5kR0AAAAAAFjyxHYAmr3a2pJf3Zj85GcltbXJeusmg8+p0mNNoR0AAAAAAFg6xHYAmrVp00oGDS257/668f/0SU46oUr79kI7AAAAAACw9IjtADRbb75V0m9AyXPPJ23bJif+sMqX90yqSmgHAAAAAACWLrEdgGbphbElJ/cvmTgx6dolGTakyqabiOwAAAAAAEDDaNXYEwCA+nro4ZLvH1MX2nv0SK65SmgHAAAAAAAalivbAWhWbru95OJLS2bXJpv1SoYOqtKli9AOAAAAAAA0LLEdgGZh9uySH11TctMtdePd+yT9+lZp21ZoBwAAAAAAGp7YDkCTN21ayTlDSu4fWTc+/LAqBx+YVJXQDgAAAAAANA6xHYAm7c23SvoNKHnu+aRt2+TU/lW+9EWRHQAAAAAAaFxiOwBN1gtjS07uXzJxYtK1SzJsSJVNNxHaAQAAAACAxteqsScAAAvy0MMl3z+mLrT36JFcc5XQDgAAAAAANB2ubAegybnt9pKLLy2ZXZts1isZOqhKly5COwAAAAAA0HSI7QA0GbNnl/zompKbbqkb794n6de3Stu2QjsAAAAAANC0iO0ANAnTppWcM6Tk/pF148MPq3LwgUlVCe0AAAAAAEDTI7YD0OjefKuk/6klzz6XtG2bnNq/ype+KLIDAAAAAABNl9gOQKN6YWzJyf1LJk5MunZJhg2psukmQjsAAAAAANC0tWrsCQCw7Hp4VMn3j6kL7T16JNdcJbQDAAAAAADNgyvbAWgUt91ecvGlJbNrk816JUMHVenSRWgHAAAAAACaB7EdgAY1e3bJj64puemWuvHufZJ+fau0bSu0AwAAAAAAzYfYDkCDmTat5JwhJfePrBsffliVgw9MqkpoBwAAAAAAmhexHYAG8eZbJf1PLXn2uaRt2+TU/lW+9EWRHQAAAAAAaJ7EdgCWuhfGlpzcv2TixKRrl2To4Cq9NhXaAQAAAACA5qtVY08AgJbt4VEl3z+mLrT36JFcc5XQDgAAAAAANH+ubAdgqbnt9pKLLy2ZXZts1isZOqhKly5COwAAAAAA0PyJ7QAscbW1JVddXXLTLXXj3fsk/fpWadtWaAcAAAAAAFoGsR2AJWr69JJzhpTcd3/d+PDDqhx8YFJVQjsAAAAAANByiO0ALDFvvlXS/9SSZ59L2rZNTu1f5UtfFNkBAAAAAICWR2wHYIl4YWzJyf1LJk5MunZJhg6u0mtToR0AAAAAAGiZWjX2BABo/h4eVfL9Y+pCe48eyTVXCe0AAAAAAEDL5sp2ABbLbb8rufiSktm1yWa9kqGDqnTpIrQDAAAAAAAtm9gOwCKprS256uqSm26pG/fZLenXt0q7dkI7AAAAAADQ8ontANTb9Okl5wwpue/+uvHhh1U5+MCkqoR2AAAAAABg2SC2A1Avb71V0u/UkmefS9q2TQb0q7LbriI7AAAAAACwbBHbAVhoY8eWnDyg5I03kq5dkqGDq/TaVGgHAAAAAACWPa0aewIANA8Pjyo56pi60N6jR3LNVUI7AAAAAACw7HJlOwCf6LbflVx8Scns2mSzXsnQQVW6dBHaAQAAAACAZZfYDsBHqq0tuerqkptuqRv32S3p17dKu3ZCOwAAAAAAsGwT2wFYoOnTS84ZUnLf/XXjww+rcvCBSVUJ7QAAAAAAAGI7APN5662S/qeVjHk2ads2GdCvym67iuwAAAAAAABziO0AzGPs2JKTB5S88UbStUsydHCVXpsK7QAAAAAAAP+pVWNPAICm4+FRJUcdUxfa11wzueYqoR0AAAAAAGBBXNkOQJLktt+VXHxJyezaZLNeyZBzqnTtKrQDAAAAAAAsiNgOsIyrrS350TUlv765btxnt6Rf3yrt2gntAAAAAAAAH0VsB1iGTZ9ecs6QkvvurxsffliVgw9MqkpoBwAAAAAA+DhiO8Ay6q23SvqfVjLm2aRt22RAvyq77SqyAwAAAAAALAyxHWAZNHZsyckDSt54I+naJRk6uEqvTYV2AAAAAACAhdWqsScAQMMa9UjJ94+tC+1rrplcc5XQDgAAAAAAUF+ubAdYhtz2u5KLLymZXZts1isZck6Vrl2FdgAAAAAAgPoS2wGWAbW1JT+6puTXN9eN++yW9OtbpV07oR0AAAAAAGBRiO0ALdz06SXnDCm57/668XcPrXLIQUlVCe0AAAAAAACLSmwHaMHeequk/2klY55N2rZNBvSrstuuIjsAAAAAAMDiEtsBWqixY0tOHlDyxhtJ1y7J0MFVem0qtAMAAAAAACwJrRp7AgAseaMeKfn+sXWhfc01k2uuEtoBAAAAAACWJFe2A7Qwt/++5KKLS2bXJpv1SoacU6VrV6EdAAAAAABgSRLbAVqI2tqSH11T8uub68Z9dkv69a3Srp3QDgAAAAAAsKSJ7QAtwPTpJecMKbnv/rrxdw+tcshBSVUJ7QAAAAAAAEuD2A7QzL31Vkn/00rGPJu0bZsMOKXKbl8S2QEAAAAAAJYmsR2gGRs7tuTkASVvvJF07ZIMHVyl16ZCOwAAAAAAwNLWqrEnAMCiGfVIyfePrQvta66ZXHOV0A4AAAAAANBQXNkO0Azd/vuSiy4umV2bbNYrGXJOla5dhXYAAAAAAICGIrYDNCO1tSU/uqbk1zfXjft8Kel3cpV27YR2AAAAAACAhiS2AzQT06eXDBpacu99dePvHlrlkIOSqhLaAQAAAAAAGprYDtAMvPVWSf/TSsY8m7Rtmww4pcpuXxLZAQAAAAAAGovYDtDEjR1bcvKAkjfeSLp2SYYOrtJrU6EdAAAAAACgMbVq7AkA8NFGPVLy/WPrQvuaayZXXyW0AwAAAAAANAWubAdoom7/fclFF5fMrk0265UMOadK165COwAAAAAAQFMgtgM0MbW1JVdfW3LjTXXjPl9K+p1cpV07oR0AAAAAAKCpENsBmpDp00sGDS2597668XcPrXLIQUlVCe0AAAAAAABNidgO0ES89VZJ/9NKxjybtG2bDDilym5fEtkBAAAAAACaIrEdoAkYO7bk5AElb7yRdO2SDB1cpdemQjsAAAAAAEBT1aqxJwCwrHvk0ZLvH1sX2tdcM7n6KqEdAAAAAACgqXNlO0Ajuv33JRddXDK7NtmsVzLknCpduwrtAAAAAAAATZ3YDtAIamtLrr625Mab6sZ9vpT0O7lKu3ZCOwAAAAAAQHMgtgM0sOnTSwYNLbn3vrrxdw+tcshBSVUJ7QAAAAAAAM2F2A7QgN56q6T/aSVjnk3atk0GnFJlty+J7AAAAAAAAM2N2A7QQMa+WHJK/5LX30i6dEmGDa7Sa1OhHQAAAAAAoDlq1dgTAFgWPPJoyfePqQvta66ZXHOV0A4AAAAAANCcubIdYCn73R0lF15UMrs22axXMuScKl27Cu0AAAAAAADNmdgOsJTU1pZcfW3JjTfVjft8Kel3cpV27YR2AAAAAACA5k5sB1gKpk8vGTS05N776saHHVLl0IOTqhLaAQAAAAAAWgKxHWAJe/e9kr6nlDwzJmnbNhlwSpXdviSyAwAAAAAAtCRiO8AS9M47JSf0Lfn3/yVduiTDBlfptanQDgAAAAAA0NKI7QBLyOTJJT88sWTsi0lNTXLphVXWXVdoBwAAAAAAaInEdoAl4M23So4/seSlcclKKyWXXVRl7bWFdgAAAAAAgJZKbAdYTBMnlhx3YsmrryardEsuvbhKjzWFdgAAAAAAgJZMbAdYDK+/XhfaJ0xIVls1ueySKmusLrQDAAAAAAC0dK0aewIAzdX4CSVH/7AutK+xRnLFZUI7AAAAAADAskJsB1gEr7xacsxxJW+8kfTokVx5aZXVVhXaAQAAAAAAlhViO0A9vTSu5Jgflkx6M1lnneTyS6p06ya0AwAAAAAALEvEdoB6GDu25NjjS956K1lv3eTyi6usvJLQDgAAAAAAsKwR2wEW0r//XRfaJ09Oeq6fXHZxlZoaoR0AAAAAAGBZJLYDLIRnny057sSSKe8mG22YXHJRla5dhXYAAAAAAIBlldgO8Ame/lfJD08qee+9ZOPPJhdfUKXL8kI7AAAAAADAskxsB/gYTzxZckLfkg8+SDbrlVx0fpXOnYV2AAAAAACAZZ3YDvARRj9ectIpJdOmJVtukZw/vErHjkI7AAAAAAAAYjvAAo16pKRvv5Lp05PeWyfnDavSoYPQDgAAAAAAQB2xHeC/PPhQSf9TS2bMSLbfNhk2uMpyywntAAAAAAAA/D9iO8B/uH9kyYCBJTNmJp/bKRkySGgHAAAAAABgfm0aewIATcXf/l5y1qCS2bOTnb+QnDmwSps2QjsAAAAAAADzE9sBktx9T8ngISWza5Pddk1O7S+0AwAAAAAA8NHEdmCZd+efSoadV1Jbm+yxe9Lv5CqtWwvtAAAAAAAAfDSxHVim/f6OkvMuLCkl+epXkr4nVGnVSmgHAAAAAADg44ntwDLrt7eVXHRJSZLs8/Xk+OOqVJXQDgAAAAAAwCcT24Fl0i0jSi67si60779vcswPhHYAAAAAAAAWntgOLHNuvKnkqqvrQvt3Dki+d4TQDgAAAAAAQP2I7cAy5bpflvzkZ3Wh/dCDk8MOEdoBAAAAAACoP7EdWCaUUvLTn5dc98u68eGHVTnkIJEdAAAAAACARSO2Ay1eKSXX/LjkVzfWjX9wVJUDvim0AwAAAAAAsOjEdqBFK6XkiqtKbh5RNz7umCr7fUNoBwAAAAAAYPGI7UCLVVtbcsllJb+9rW580glVvv41oR0AAAAAAIDFJ7YDLVJtbckFF5f87vdJVSX9+lb58p5COwAAAAAAAEuG2A60OLNnl5x7fskf/5S0apUM6Fflf/oI7QAAAAAAACw5YjvQosyaVTJkeMndf0lat0oGnlblS18U2gEAAAAAAFiyxHagxZg1q+TswSV/+3vSunVy1ulVdv6C0A4AAAAAAMCSJ7YDLcLMmSVnnF1y/8ikTZtk0FlVdtpRaAcAAAAAAGDpENuBZu/DD0tOP7PkgYeSdm2TIYOqbLet0A4AAAAAAMDSI7YDzdqHH5YMGFgy6pGkXbvk3KFVtt5KaAcAAAAAAGDparKx/fbbb89jjz2Wp59+Os8//3xmzpyZYcOGZe+9967X+9TW1uaGG27ILbfcknHjxqVjx47Zfvvtc8IJJ6RHjx5LafZAQ5g2raT/aSWPjU7at0/OG1Zli82FdgAAAAAAAJa+JhvbL7300owfPz41NTVZZZVVMn78+EV6nzPOOCMjRozI+uuvnwMPPDATJ07MnXfemX/84x+5+eabs8466yzZiQMNYurUkpP7lzzxZNKhQ3LBuVV6bSq0AwAAAAAA0DBaNfYEPsrgwYPz17/+NQ899FC++c1vLtJ7PPTQQxkxYkS23nrr/Pa3v83JJ5+c888/P1deeWXeeeedDBo0aAnPGmgI779fcuLJdaG9U6fk4guEdgAAAAAAABpWk72yffvtt1/s9xgxYkSS5Ic//GHatWs3d/vnP//59O7dOyNHjsyECROyxhprLPa5gIbx7nslJ51cMubZZPnlk4vPr7LhhkI7AAAAAAAADavJXtm+JDz88MPp2LFjtthii/n27bTTTkmSUaNGNfS0gEX0zjslx59YF9q7dkkuu0hoBwAAAAAAoHG02Ng+derUTJo0KWuuuWZat2493/611147STJu3LiGnhqwCCZPLvnhiSXP/zupqUkuv6TK+usL7QAAAAAAADSOJnsb+cX13nvvJUk6d+68wP1zts857qN07do1rVq12J9JaHQ1NTWNPQWagUmTavPDk97N2LGz061blZ9e2yXrrdtily9Y6qy9AA3P2gvQ8Ky9AA3P2gvQ8Ky9jUut+gRTpkxp7Cm0WDU1NZk8eXJjT4MmbtKkkuNOLHnllWSVbsmlFycr1rwX3zqwaKy9AA3P2gvQ8Ky9AA3P2gvQ8Ky9S9fC/CBDi43tyy+/fJLk/fffX+D+OdvnHAc0Pa+/XhfaJ0xIVl01ueziKt3XcOt4AAAAAAAAGl+LvT96x44d061bt7z66quZPXv2fPvnPKt9zrPbgaZlwmslx/ywLrSvsUZy5aVCOwAAAAAAAE1Hi43tSdK7d+9MnTo1o0ePnm/f/fffnyTZeuutG3pawCd45dWSY44ref2NZM01kysuqbLaakI7AAAAAAAATUeLiO1vv/12Xnjhhbz99tvzbN9vv/2SJJdeemlmzJgxd/u9996bUaNGZccdd0z37t0bdK7Axxs3ru6K9omTknXWTq64tMoqqwjtAAAAAAAANC1N9pntI0aMyGOPPZYkef755+duGzVqVJJkyy23zL777pskueGGG3LFFVfkmGOOybHHHjv3Pbbddtvsu+++GTFiRPbee+98/vOfz6RJk/LHP/4xK6ywQgYOHNjAnwr4OGPHlvzwpJLJk5P11k0uubBKTY3QDgAAAAAAQNPTZGP7Y489lltvvXWebaNHj57nlvBzYvvHOeecc9KzZ8/ccsst+eUvf5mOHTvmS1/6Uk444YSstdZaS3zewKL59/+VnHBSyTtTkvU/nVx8QZUVVhDaAQAAAAAAaJqqUkpp7Ek0ZZMnT27sKbRYNTU1vr4kSZ59ruSEviXvvZdsuEFy0flVunQR2mFpsPYCNDxrL0DDs/YCNDxrL0DDs/YuXTU1NZ94TIt4ZjvQfD39r5LjT6wL7Rt/tu7W8UI7AAAAAAAATZ3YDjSaJ54sOfHkkvc/SDbdpO6K9s6dhXYAAAAAAACaPrEdaBSjHy/pe0rJ1KnJFpsnF55XpWNHoR0AAAAAAIDmQWwHGtwjj5ac3L9k2vSk99bJecOqdOggtAMAAAAAANB8iO1Ag3rw4ZJ+A0o+/DDZfttk2OAq7dsL7QAAAAAAADQvYjvQYEb+o+TUgSUzZiY77ZgMGVRlueWEdgAAAAAAAJqfNo09AWDZ8Pd7S848p2T27GTnLyRnDqzSpo3QDgAAAAAAQPMktgNL3V/uKRk0pGR2bfKlXZPT+gvtAAAAAAAANG9iO7BU/emukqHDS2prk//pk/Q/pUrr1kI7AAAAAAAAzZvYDiw1d/yx5NzzS0pJvrJncvJJVVq1EtoBAAAAAABo/sR2YKm47faSCy4uSZKv75WccJzQDgAAAAAAQMshtgNL3Ij/Lbn08rrQvt83kmOPrlJVQjsAAAAAAAAth9gOLFE33lRy1dV1of3b30qOOlJoBwAAAAAAoOUR24El5pe/Krn2J3Wh/ZCDku8eKrQDAAAAAADQMontwGIrpeRn15X8/Bd148MPq3LIQSI7AAAAAAAALZfYDiyWUuquZr/+hrrx979X5dvfEtoBAAAAAABo2cR2YJGVUnLlj0puuqVufNzRVfbbV2gHAAAAAACg5RPbgUVSSsmll5f85rd14xN+WGWfrwvtAAAAAAAALBvEdqDeamtLLry45PbfJ1WVnHxSla9+WWgHAAAAAABg2SG2A/Uye3bJuReU/PHOutB+ar8q/7O70A4AAAAAAMCyRWwHFtqsWSXDzi35891J61bJaadW2W1XoR0AAAAAAIBlj9gOLJRZs0oGDSm5529J69bJmadX2eULQjsAAAAAAADLJrEd+EQzZ5aceU7Jffcnbdok55xZ5XM7Ce0AAAAAAAAsu8R24GPNmFEy8MySBx5M2rVNBp9TZfvthHYAAAAAAACWbWI78JE+/LDk1NNLHh6VtGuXDB9SpffWQjsAAAAAAACI7cACTZtW0v+0ksdGJ+3bJ+cOrbLlFkI7AAAAAAAAJGI7sABTp5acMqDkn08kHTokF5xbpdemQjsAAAAAAADMIbYD8/jgg5K+/Uqeejrp1Cm58LwqG39WaAcAAAAAAID/JLYDc737XslJp5SMGZN07pxcfEGVjTYU2gEAAAAAAOC/ie1AkmTKlJITTi55/vmka5fk4gur9FxfaAcAAAAAAIAFEduBTJ5ccnzfkhdeSFZYIbn0oirrrSu0AwAAAAAAwEcR22EZ99ZbJT88qeSll5KVVkwuuajKp9YR2gEAAAAAAODjiO2wDJs0qeS4E0teeSXptnJy6cVV1uohtAMAAAAAAMAnadXYEwAax+tvlBzzw7rQvuqqyRWXCu0AAAAAAACwsFzZDsugCa+V/PCEktdeT1ZfPbn84iqrrSa0AwAAAAAAwMJyZTssY159te6K9tdeT9ZcM7nyUqEdAAAAAAAA6ktsh2XIuHElxxxfMnFisvZadbeOX2UVoR0AAAAAAADqS2yHZcTYF0uOPb7kzTeTdT+VXH5JlZVXEtoBAAAAAABgUXhmOywDXnyp5LjjS96Zkqz/6eTiC6qssILQDgAAAAAAAIvKle3Qwr35ZslJp9SF9g16JpdeJLQDAAAAAADA4hLboQX74IOSvv3qntG+Vo+6K9q7dBHaAQAAAAAAYHGJ7dBCzZpVMvDMkv97IVmxJrngPKEdAAAAAAAAlhSxHVqgUkrOu6DkkUeTDu2T84ZVWWN1oR0AAAAAAACWFLEdWqCfXVfyxz8lrVsl55xVZcMNhXYAAAAAAABYksR2aGHu+EPJz39R9+uTTqyy3bZCOwAAAAAAACxpYju0IA89XHL+hSVJctB3kq9+WWgHAAAAAACApUFshxbiuedLTj+rZHZtsnuf5IjvCu0AAAAAAACwtIjt0AK89lrJKf1Lpk1Lttoy6de3SlWJ7QAAAAAAALC0iO3QzL37XsnJ/UveejtZb91k8NlV2rYV2gEAAAAAAGBpEtuhGfvww5JTB5a8NC5ZpVty/vAqnTsL7QAAAAAAALC0ie3QTNXWlgwZXvLPJ5JOnZLzz62yyipCOwAAAAAAADQEsR2aqR9dU/LXvyVt2iRDB1VZb12hHQAAAAAAABqK2A7N0P/+tuTXN9f9+tR+VbbcQmgHAAAAAACAhiS2QzNz7/0ll1xekiTfO6LKbl8S2gEAAAAAAKChie3QjDz9r5KzB5WUknztK8l3DmjsGQEAAAAAAMCySWyHZuKVV0v6DSiZMSPZfrvkhB9WqSpXtQMAAAAAAEBjENuhGZg8uaTvKSVT3k023CA5+4wqbdoI7QAAAAAAANBYxHZo4qZNKznl1JLxE5LVV0/OG1alQwehHQAAAAAAABqT2A5N2OzZJWcPLhkzJunSJbnw3Corrii0AwAAAAAAQGMT26GJKqXk4stKRv4jadcuOXdolbXWEtoBAAAAAACgKRDboYm64dfJbbcnVZWcObDKJhsL7QAAAAAAANBUiO3QBN31l5Krry1JkmOPrvL5zwntAAAAAAAA0JSI7dDEjH68ZOjwutC+/77Jft8Q2gEAAAAAAKCpEduhCRk7tuTUgSWzZiU7fyE5+vtCOwAAAAAAADRFYjs0EW++WdK3f8n7HySbbpIMHFClVSuxHQAAAAAAAJoisR2agA8+KOnbr2TixGStHsnwIVWWW05oBwAAAAAAgKZKbIdGNmtWycAzS/7vhWTFmuSC86p06SK0AwAAAAAAQFMmtkMjKqXk3PNLHnk06dA+OW94lTVWF9oBAAAAAACgqRPboRH97LqSO/+ctG6VnHNWlQ03ENoBAAAAAACgORDboZHc8YeSn/+i7tcnnVhlu22FdgAAAAAAAGguxHZoBA8+XHL+hSVJcvCByVe/LLQDAAAAAABAcyK2QwN77vmSM84smV2b7N4nOfwwoR0AAAAAAACaG7EdGtBrr5Wc0r9k2vRkqy2Tfn2rVJXYDgAAAAAAAM2N2A4N5N13S/r2K3nr7WS99ZLBZ1dp21ZoBwAAAAAAgOZIbIcG8OGHJQMGlox7OVmlW3LB8CqdOwvtAAAAAAAA0FyJ7bCU1daWDBle8sSTSadOyfnnVunWTWgHAAAAAACA5kxsh6XsR9eU/PVvSZs2ydBBVdZbV2gHAAAAAACA5k5sh6XoN78t+fXNdb8+tV+VLbcQ2gEAAAAAAKAlENthKbn3/pJLLy9Jku8dUWW3LwntAAAAAAAA0FKI7bAUPP2vkrMHlZSS7PXV5DsHNPaMAAAAAAAAgCVJbIcl7OVXSvoNKJkxI9l+u+T446pUlavaAQAAAAAAoCUR22EJmjy5pG+/kinvJhttmJx9RpU2bYR2AAAAAAAAaGnEdlhCpk0rOWVAyYQJyeqrJ+cOrdKhg9AOAAAAAAAALZHYDkvArFklZw0qGfNs0rVLcuF5VVZcUWgHAAAAAACAlkpsh8VUSskll5f844GkXbtk+NAqa/UQ2gEAAAAAAKAlE9thMd3w6+S225OqSs4cWGWTjYV2AAAAAAAAaOnEdlgMd/2l5OprS5LkuGOqfP5zQjsAAAAAAAAsC8R2WESjHy8ZOrwutO+/X7LvPkI7AAAAAAAALCvEdlgEY8eWnDqwZNasZOcvJEcfJbQDAAAAAADAskRsh3qaNKmkb/+S9z9INt0kGTigSqtWYjsAAAAAAAAsS8R2qIcPPqgL7RMnJmuvlQwfUmW55YR2AAAAAAAAWNaI7bCQZs0qGXhmyQsvJCvWJBecW6VLF6EdAAAAAAAAlkViOyyEUkrOPb/kkUeTDu2T84ZXWX11oR0AAAAAAACWVWI7LISf/rzkzj8nrVsl55xVZcMNhHYAAAAAAABYlont8Al+f0fJdb+s+3XfE6tst63QDgAAAAAAAMs6sR0+xoMPl1xwUUmSHHxg8pUvC+0AAAAAAACA2A4f6dnnSs44s2R2bbJ7n+Tww4R2AAAAAAAAoI7YDgvw2mslp/QvmTY92WrLpF/fKlUltgMAAAAAAAB1xHb4L+++W9K3X8nbk5P11kuGnFOlbVuhHQAAAAAAAPh/xHb4Dx9+WDJgYMm4l5NVuiUXDK/SqZPQDgAAAAAAAMxLbIf/X21tyZDhJU88mXTulFxwbpVu3YR2AAAAAAAAYH5iO/z/rrq65K9/S9q0SYYOrrLuukI7AAAAAAAAsGBiOyQZ8b8lN91S9+tT+1XZYnOhHQAAAAAAAPhoYjvLvHvvK7nsipIk+d4RVXb7ktAOAAAAAAAAfDyxnWXaU0+XnD24pJRkr68l3zmgsWcEAAAAAAAANAdiO8usl18p6X9qyYwZyfbbJccfW6WqXNUOAAAAAAAAfDKxnWXS5MklffuVTHk32WjD5OwzqrRpI7QDAAAAAAAAC0dsZ5kzbVrJKQNKJkxI1lgjOW9YlQ4dhHYAAAAAAABg4YntLFNmzSo585ySMc8mXbskF5xbpaZGaAcAAAAAAADqR2xnmVFKySWXlTzwYNKuXTJ8aJW1egjtAAAAAAAAQP2J7SwzfnVjctvvkqpKzhxYZZONhXYAAAAAAABg0YjtLBPu+oSUKpUAACroSURBVEvJNT8uSZLjjqny+c8J7QAAAAAAAMCiE9tp8UY/XjJ0eF1o33+/ZN99hHYAAAAAAABg8YjttGhjx5YMGFgya1ayy87J0UcJ7QAAAAAAAMDiE9tpsSZNKunbr+SDD5Jemyan9a/SqpXYDgAAAAAAACw+sZ0W6YMPSvr2L5k4KVl7rWTY4CrLLSe0AwAAAAAAAEuG2E6LM3NmyWlnlLzwQrJiTXLBuVW6dBHaAQAAAAAAgCVHbKdFKaXk3AtKHn0s6dA+OW94ldVXF9oBAAAAAACAJUtsp0X56c9L/vTnpHWr5Jyzq2y4gdAOAAAAAAAALHliOy3G7+4oue6Xdb/ue2KV7bYR2gEAAAAAAIClQ2ynRXjw4ZILLypJkkMOSr7yZaEdAAAAAAAAWHrEdpq9Z58rOePMktm1yf/0Sb57qNAOAAAAAAAALF1iO83aa6+VnNK/ZNr0ZKstk1P6VqkqsR0AAAAAAABYusR2mq133y056ZSStycn662XDDmnStu2QjsAAAAAAACw9IntNEsffljS/7SSl19JVumWXDC8SqdOQjsAAAAAAADQMMR2mp3a2pLBw0qefCrp3Cm54Nwq3boJ7QAAAAAAAEDDEdtpdq68uuRvf0/atEmGDq6y7rpCOwAAAAAAANCwxHaalRH/W3LzLXW/PrV/lS02F9oBAAAAAACAhie202zce1/JZVeUJMn3jqiy265COwAAAAAAANA4xHaahaeeLjl7cEkpyV5fS75zQGPPCAAAAAAAAFiWtWnsCXycJ598Mpdffnkef/zxzJo1Kz179swhhxySPfbYY6Fe/9vf/jYDBgz4yP2//OUvs8022yyp6bKUvPxKSf9TS2bMSHbYPjn+2CpV5ap2AAAAAAAAoPE02dj+0EMP5fDDD0+7du2y5557plOnTrnrrrtywgkn5PXXX89hhx220O/1xS9+MRtttNF827t3774kp8xS8PbbJSedUjLl3WSjDZOzTq/Spo3QDgAAAAAAADSuJhnbZ82aldNPPz1VVeWGG26YG8qPPvrofOMb38hFF12UPn36LHQs33XXXbP33nsvzSmzFEybVnLKgJLXXkvWWCM5b1iVDh2EdgAAAAAAAKDxNclntj/00EN5+eWX8+Uvf3meK9KXX375HHXUUZk5c2ZuvfXWRpwhS9usWSVnnlPy7HNJ1y7JBedWqakR2gEAAAAAAICmoUle2T5q1KgkyY477jjfvjnbHnnkkYV+v2eeeSbvvPNOZs2alTXXXDPbbbddampqlsxkWeJKKbnkspIHHkzatUvOHVZlrR5COwAAAAAAANB0NMnY/tJLLyVJ1l577fn2devWLR07dsy4ceMW+v2uv/76ecbt27fP0UcfnSOPPHKx5snS8asbk9t+l1RVcubpVTb+rNAOAAAAAAAANC1NMra///77SepuG78gnTt3znvvvfeJ77Pmmmvm9NNPz4477pjVVlstU6ZMyYMPPpiLLrooF154YTp06JADDzzwY9+ja9euadWqSd5tv0X47zsM3PGHD3PNj+t+//uf3DF7fbVDY0wLoEVzdxeAhmftBWh41l6AhmftBWh41t7G1SRj+5LSu3fv9O7de+64ffv22WuvvfLZz342++yzT6644op861vfSps2H/1lmDJlSkNMdZlUU1OTyZMnzx0/NrrktDNKkuSb+yV77jE9kydPb6zpAbRI/732ArD0WXsBGp61F6DhWXsBGp61d+lamB9kaJKXbHfu3DlJPvLq9ffff/8jr3pfGOuvv3623HLLvPPOO3nhhRcW+X1Ycl4YW3Lq6SWzZiW77Jz84Ci3jgcAAAAAAACariYZ29dZZ50kWeBz2SdNmpSpU6cu8Hnu9THnJxGmTZu2WO/D4ps4seTkfiUffJD02jQ5rX+VVq3EdgAAAAAAAKDpapKxfeutt06SjBw5cr59c7bNOWZRzJ49O08//XSSZI011ljk92HxffBByckDSiZOStZeKxk2uMpyywntAAAAAAAAQNPWJGP7dtttlx49euSOO+7ImDFj5m5/7733cvXVV6dt27bZa6+95m6fOHFiXnjhhfluOz8nqP+n2bNn54ILLsi4ceOyzTbbZJVVVllqn4OPN2Nm3TPaX3ghWWnF5IJzq3TpIrQDAAAAAAAATV+bxp7AgrRp0yaDBw/O4Ycfnm9/+9vZc88906lTp9x1110ZP358+vXrlzXXXHPu8RdddFFuvfXWDBs2LHvvvffc7fvss0822GCDbLDBBll11VUzZcqUjBo1Ki+99FJWW221DBkypDE+HklKKTnz7A/y6GNJh/bJecOrrL660A4AAAAAAAA0D00ytifJtttumxtvvDGXXXZZ/vjHP2bWrFnp2bNn+vbtmz322GOh3uOwww7LP//5zzzwwAOZMmVK2rZtm7XWWivf//73c+ihh6Zr165L+VPwUW75TfK733+Y1q2Sc86uskFPoR0AAAAAAABoPqpSSmnsSTRlkydPbuwptEhDh9fmzj8np5xU5StfFtoBGkpNTY3/tgE0MGsvQMOz9gI0PGsvQMOz9i5dNTU1n3hMk72ynZbtlL5VTjyha9ov925jTwUAAAAAAACg3lo19gRYNrVpU2X11Vo39jQAAAAAAAAAFonYDgAAAAAAAAD1JLYDAAAAAAAAQD2J7QAAAAAAAABQT2I7AAAAAAAAANST2A4AAAAAAAAA9SS2AwAAAAAAAEA9ie0AAAAAAAAAUE9iOwAAAAAAAADUk9gOAAAAAAAAAPUktgMAAAAAAABAPYntAAAAAAAAAFBPYjsAAAAAAAAA1JPYDgAAAAAAAAD1JLYDAAAAAAAAQD2J7QAAAAAAAABQT2I7AAAAAAAAANST2A4AAAAAAAAA9SS2AwAAAAAAAEA9ie0AAAAAAAAAUE9iOwAAAAAAAADUk9gOAAAAAAAAAPUktgMAAAAAAABAPYntAAAAAAAAAFBPYjsAAAAAAAAA1JPYDgAAAAAAAAD1JLYDAAAAAAAAQD2J7QAAAAAAAABQT2I7AAAAAAAAANST2A4AAAAAAAAA9SS2AwAAAAAAAEA9ie0AAAAAAAAAUE9iOwAAAAAAAADUk9gOAAAAAAAAAPUktgMAAAAAAABAPVWllNLYkwAAAAAAAACA5sSV7QAAAAAAAABQT2I7AAAAAAAAANST2A4AAAAAAAAA9SS2AwAAAAAAAEA9ie0AAAAAAAAAUE9tGnsCLFuefPLJXH755Xn88ccza9as9OzZM4ccckj22GOPxp4aQLP1xhtv5M4778x9992XsWPH5s0330zXrl2zxRZb5PDDD0+vXr3me83777+fyy+/PHfddVcmTZqUVVZZJX369MkxxxyTTp06NcKnAGgZrr322lx44YVJkptvvjmbbbbZPPutvwBLxt13350bb7wxzzzzTKZOnZpu3bpls802y8knn5zVV1997nHWXYDFV0rJ3Xffneuvvz4vvvhi3nvvvay22mrZZpttcsQRR6RHjx7zHG/tBVh4t99+ex577LE8/fTTef755zNz5swMGzYse++99wKPr+8aW1tbmxtuuCG33HJLxo0bl44dO2b77bfPCSecMN/6zaKpSimlsSfBsuGhhx7K4Ycfnnbt2mXPPfdMp06dctddd2X8+PHp169fDjvssMaeIkCzdMEFF+THP/5x1lprrfTu3Tsrrrhixo0bl7/85S8ppeTCCy+c54eapk6dmgMOOCBjxozJjjvumI022ihjxozJyJEjs8kmm+SGG27Icsst14ifCKB5ev7557PPPvukTZs2mTp16nyx3foLsPhKKTnzzDNz8803Z6211sqOO+6YTp06ZeLEiXnkkUdy/vnnZ6uttkpi3QVYUoYPH56f//zn6datW774xS+mc+fOefbZZ/OPf/wjHTt2zE033ZSePXsmsfYC1Ncuu+yS8ePHp6amJh07dsz48eM/MrYvyho7cODAjBgxIuuvv34+//nPZ+LEibnzzjvTqVOn3HzzzVlnnXUa6JO2XK5sp0HMmjUrp59+eqqqyg033JCNNtooSXL00UfnG9/4Ri666KL06dMn3bt3b+SZAjQ/m266aa6//vr07t17nu2PPvpoDjnkkJx11lnZdddd065duyTJT37yk4wZMyZHHHFE+vbtO/f4OdH+uuuuy/e+970G/QwAzd3MmTPTv3//bLTRRll77bXzu9/9br5jrL8Ai++Xv/xlbr755hxwwAEZOHBgWrduPc/+WbNmzf21dRdg8U2aNCm/+MUv0r1799x+++1Zfvnl5+677rrrMmzYsPz85z/PsGHDklh7Aepr8ODBWXvttdO9e/d57pa3IPVdYx966KGMGDEiW2+9dX72s5/N/fvhL3/5yznyyCMzaNCg/PSnP116H24Z4ZntNIiHHnooL7/8cr785S/PDe1Jsvzyy+eoo47KzJkzc+uttzbiDAGar912222+0J4kW221VbbZZptMmTIlzz33XJK6K4FGjBiRjh075gc/+ME8x//gBz9Ix44dM2LEiAaZN0BLcvXVV+ff//53hg4dOl/4Say/AEvC9OnTc+WVV6ZHjx457bTTFrjetmlTd12JdRdgyRg/fnxqa2uz+eabzxPak+QLX/hCkmTy5MlJrL0Ai2L77bdfqAtRF2WNnTP+4Q9/ODe0J8nnP//59O7dOyNHjsyECROWwKdYtontNIhRo0YlSXbcccf59s3Z9sgjjzTonACWBXP+snHO/7700kuZOHFitthii3Ts2HGeYzt27Jgtttgir7zySl577bUGnytAc/Wvf/0rV199dY455ph8+tOfXuAx1l+AxTdy5MhMmTIlu+66a2pra3PXXXfl2muvza9//euMGzdunmOtuwBLxtprr522bdvm8ccfz/vvvz/Pvr///e9Jkm233TaJtRdgaVqUNfbhhx+eu++/7bTTTkn+X79j0bmNPA3ipZdeSlL3h7P/1q1bt3Ts2HG+/2MMwOKZMGFCHnjggXTr1m3us9PmrLUf9SyeddZZJyNHjsxLL72U1VdfvaGmCtBszZgxI/369cuGG26Yww8//COPs/4CLL5//etfSZJWrVrlK1/5yty/a5iz7ZBDDkm/fv2SWHcBlpSampr07ds3w4cPz+677z7PM9sffvjhHHDAAfnOd76TxNoLsDTVd42dOnVqJk2alJ49ey7wjlBzep02t/jEdhrEnJ96/O9bDc3RuXPnvPfeew05JYAWbebMmTnllFMyY8aM9O3bd+4fqOastZ07d17g6+Zs/++fVgdgwS699NK89NJL+e1vf7vA//M6h/UXYPG99dZbSeqeEfyZz3wmI0aMyHrrrZcxY8bk9NNPz89+9rP06NEjBxxwgHUXYAk65JBDssoqq2TgwIG56aab5m7fcsst8+Uvf3nu3fSsvQBLT33X2IU9XptbfG4jDwAtTG1tbfr3759HHnkk++23X/baa6/GnhJAi/T444/nZz/7Wb7//e/PvYMIAEtPKSVJ0rZt21x55ZXZdNNN06lTp2y11Va59NJL06pVq/z85z9v5FkCtDxXXHFFTjnllBx11FG59957M3r06Nxwww358MMPc9BBB+Wee+5p7CkCQKMR22kQn/QTMu+///5HXvUOwMKrra3NqaeemjvuuCNf/epXc/bZZ8+zf85a+1E/RT5n+0f9xCMAdWbNmpX+/ftngw02yJFHHvmJx1t/ARbfnDVy4403zqqrrjrPvp49e6ZHjx55+eWX8+6771p3AZaQBx54IJdffnm+/e1v58gjj8xqq6029wedrr766rRp0ybnnntuEn/mBVia6rvGLuzx2tzicxt5GsScZ0iMGzcuG2+88Tz7Jk2alKlTp2bTTTdthJkBtBy1tbUZMGBAbrvttnz5y1/O8OHD06rVvD9XN+dZPP/5fMv/NGf7Rz37B4A6U6dOnbtm/vefb+fYf//9kyRXXnll1ltvvSTWX4DFse666yb56L8QnLN9+vTp/twLsITcd999SZJtttlmvn3dunXLuuuum2eeeSYffPCBtRdgKarvGtuxY8d069Ytr776ambPnj3fo+/mPKt9zvuy6MR2GsTWW2+da665JiNHjsyee+45z76RI0fOPQaARfOfoX2PPfbIeeedt8BnB6+zzjpZZZVVMnr06EydOjUdO3acu2/q1KkZPXp01lxzzay++uoNOX2AZqddu3b5xje+scB9jz76aF566aXssssuWXHFFdO9e3frL8ASMCf0jB07dr59M2fOzMsvv5yOHTtmxRVXTLdu3ay7AEvAzJkzkyRvv/32Ave//fbbadWqVdq2bevPvABL0aKssb17984f/vCHjB49er4Gd//99yfR5pYEt5GnQWy33Xbp0aNH7rjjjowZM2bu9vfeey9XX3112rZt65nCAItozq3jb7vttuy+++45//zzFxjak6Sqquy7776ZOnVqrrrqqnn2XXXVVZk6dWr222+/hpg2QLPWvn37DBkyZIH/bL755kmS733vexkyZEg22mgj6y/AErDWWmtlxx13zLhx4zJixIh59l177bV59913s+uuu6ZNmzbWXYAlZIsttkiSXHfddfM9IvTXv/51Xn/99Wy22WZp166dtRdgKVqUNXbO+NJLL82MGTPmbr/33nszatSo7LjjjunevfvSn3wLV5VSSmNPgmXDQw89lMMPPzzt2rXLnnvumU6dOuWuu+7K+PHj069fvxx22GGNPUWAZunyyy/PFVdckY4dO+aggw5Kmzbz37hm1113zUYbbZSk7icdv/Wtb+XZZ5/NjjvumM985jN55plnMnLkyGyyySb51a9+lfbt2zf0xwBoMfr3759bb701N998czbbbLO5262/AIvv5Zdfzje/+c289dZb+cIXvjD39sUPPfRQunfvnptvvjndunVLYt0FWBJmz56dgw8+OI888khWWmml7LLLLll++eXnrr3t27fP9ddfP/cRodZegPoZMWJEHnvssSTJ888/n3/961/ZYost5t7efcstt8y+++6bZNHW2IEDB2bEiBFZf/318/nPfz6TJk3KH//4x3Tq1Ck33XRTPvWpTzXsB26BxHYa1JNPPpnLLrssjz/+eGbNmpWePXvm0EMPzR577NHYUwNotuZEnY8zbNiw7L333nPH7733Xi6//PLcddddefPNN9OtW7fsvvvuOfroo9O5c+elPWWAFu2jYnti/QVYEl577bVcdtlluf/++/POO+9k5ZVXzi677JKjjz46K6200jzHWncBFt+MGTNy3XXX5c4778yLL76YmTNnZqWVVso222yTo446Kuutt948x1t7ARbeJ/3d7te//vUMHz587ri+a2xtbW1+9atf5ZZbbsm4cePSsWPHbL/99jnhhBOy1lprLZXPtKwR2wEAAAAAAACgnjyzHQAAAAAAAADqSWwHAAAAAAAAgHoS2wEAAAAAAACgnsR2AAAAAAAAAKgnsR0AAAAAAAAA6klsBwAAAAAAAIB6EtsBAAAAAAAAoJ7EdgAAAAAAAACoJ7EdAAAAAAAAAOpJbAcAAGCBNthgg3n+2XDDDbPVVlvlgAMOyIgRI1JKaewp0sjefvvtnHLKKdlxxx2z0UYbZYMNNshvf/vbxp5Wg9tggw2yyy67LPXzPPzww9lggw3Sv3//pX4uAAAAPlmbxp4AAAAATdvXv/71JMns2bPzyiuvZPTo0Xnsscfy4IMP5qKLLmrk2TW8XXbZJePHj89zzz3X2FNpdKeeemr+9re/ZYMNNsi2226bNm3aZK211mrsaTVbl19+ea644ooMGzYse++9d2NPBwAAgE8gtgMAAPCxhg8fPs/4H//4R4488sj84Q9/yFe+8pXsvPPOjTQzGtOMGTNy3333pXv37rntttvSqpWb5y1tm266af74xz9m+eWXb+ypAAAAELeRBwAAoJ522GGHfPWrX02S/OUvf2nk2dBY3nzzzcyePTvdu3cX2htIhw4dst5662WVVVZp7KkAAAAQsR0AAIBF8JnPfCZJ8vrrr8+z/Yknnshxxx2XHXfcMRtvvHE+97nP5bTTTsuECRPme4/LL7987jO+n3zyyXzve9/LNttskw022CBjxoyZ5z1POOGE7LTTTtl4442z44475uCDD84tt9wy33tOmzYt11xzTfbaa69svvnm2XzzzbPffvvl1ltvXeDnmPOs7dmzZ+faa69Nnz59svHGG+fzn/98zj///MyYMWPusXOelz1+/Pi5r53zz38+r3vcuHG5/PLLs//++2eHHXaY+3U45ZRT8uKLL37k13TUqFE56KCDsvnmm2frrbfOEUcckaeeeiq//e1vs8EGG+Tyyy+f7zWzZs3KjTfemP333z9bbLFFNt1003zta1/Lddddl1mzZn3kuT7Kvffem0MPPTRbb711Ntlkk/Tp0ycXXHBB3n333XmO22WXXebe0WDUqFEL/Dp8lP/8fX/iiSfy3e9+N1tttVW22GKLHHroofnnP/+52PNb1PN83Nc6SQ488MBssMEGefXVVz/xc5ZScscdd+SEE05Inz59stlmm2XzzTfPN77xjdxwww2pra2d5/hddtklV1xxRZJkwIAB83x/Pfzww0k+/pnts2bNyvXXX5+999577vf+N77xjdx4442ZPXv2x36Wv/zlL9lvv/2y2WabpXfv3jnxxBPn+3cbAACA+bmNPAAAAPX2wQcfJEnatm07d9sNN9yQwYMHJ0k22WSTbLnllnnxxRfzm9/8Jn/961/zq1/9Kuutt9587/XII4/kjDPOyDrrrJMddtghEydOTFVVSZJf/OIXGT58eGpra/PZz342W2+9dSZPnpznnnsu5513Xvbbb7+57/PWW2/l0EMPzXPPPZdu3bpl6623Tikljz/+ePr375+nn346p59++gI/z0knnZR7770322yzTT71qU/l0UcfzU9+8pO88cYbueCCC5IkK6+8cr7+9a/nz3/+c6ZOnTr3WfZJUlNTM/fXI0aMyE9+8pOsv/762WSTTdKuXbv83//9X26//fbcc889ueGGG7LhhhvOc/677rorxx9/fGbPnp3NNtss3bt3z/PPP58DDjjgI5/dPX369Bx55JF5+OGHs8IKK2SzzTZLu3bt8uSTT2bYsGF5+OGHc+WVVy70VefXXHNNLrroorRp0yZbb711ampqMnr06Pz4xz/O3XffnRtuuCErr7xykqRPnz4ZP358/vznP2fllVfOTjvtNN/X4ZM8/vjjOeOMM7L22mvnc5/7XMaNG5cHHnggjzzySK6++ursuOOOizy/xTnPkjJjxoycdNJJWWGFFfLpT386n/nMZ/LOO+/k8ccfzznnnJOnnnpqnkc09OnTJw888ECeffbZbLHFFll77bXn7lvQ5/pPs2fPzg9+8IPce++96dy5c7bffvuUUvLQQw/l7LPPzgMPPJDLLrtsgd8LN954Y6677rpsueWW+dznPpcnn3wyf/jDH/Kvf/0rt99+e9q3b7/kvigAAAAtTQEAAIAF6NmzZ+nZs+d822tra8v+++9fevbsWS666KJSSimPP/542WijjcpOO+1UnnrqqXmOv+WWW0rPnj3LvvvuO8/2yy67bO45rr322vnOM2rUqLLBBhuUzTffvDzwwAPz7Js5c2b5+9//Ps+2I444ovTs2bMMHjy4fPjhh3O3T5o0qey9996lZ8+e5d57713gZ/yf//mfMnHixLnbX3755bLVVluVnj17lnHjxs3zmp133nmBX5c5Hn/88fLyyy/Pt/03v/lN6dmzZznwwAPn2f7ee++V3r17l549e5bf/e538+y75JJL5s7xsssum2ffWWedVXr27FmOP/748u67787zfnO+FjfeeONHzvM/PfHEE2XDDTcsm222WfnnP/85d/uHH35YjjvuuNKzZ89y7LHHzvOaV155pfTs2bN85zvfWahzzPGfv+8XXXRRqa2tnbvvhhtuKD179iw77LBDmTZt2mLNb1HO87//+78L/FrP8Z3vfKf07NmzvPLKK/Ns79mzZ9l5553n2TZz5sxy9913lxkzZsyz/a233pr7/Thq1KgFzvl///d/F3j+hx56qPTs2bP069dvnu0//elPS8+ePcuee+5ZJk2aNHf7G2+8Ufr06VN69uxZrr/++gV+ll69epXRo0fP3T516tS5/36PGDFigfMAAACgjtvIAwAAsFBmz56dl156Kaeeemoef/zxtGvXLvvss0+S5Nprr83s2bNz9tlnZ+ONN57ndfvuu2922WWXPPHEE3nmmWfme9+ePXvm8MMPn2/7tddem1JKjjrqqGy33Xbz7GvTpk0+//nPzx2PGTMm9957bzbZZJMMGDAg7dq1m7tv5ZVXzqBBg5Ikv/71rxf42QYOHJhu3brNHffo0WPuc+kfffTRj/26/LfNNtssPXr0mG/7Pvvsky222CKjRo3Ke++9N3f7nXfemXfeeSfbbbddvvKVr8zzmqOPPjrdu3ef773eeuutjBgxIquvvnqGDRuW5Zdffu6+zp07Z8iQIWnbtu1Hft7/Nue25gceeGB69eo1d3u7du1yxhlnpH379rn77rvz2muvLdT7LYzu3bvn2GOPnXsXgyQ54IAD0qtXr0yaNCl//vOfl8j86nOeJalNmzbZdddd57n7Q5KsuOKKOemkk5Ik99xzzxI51/XXX58k6d+//zxXwa+yyio55ZRTkiS//OUvF/jagw8+OJtvvvnccYcOHXLooYcmqf/3PgAAwLLGbeQBAAD4WBtssMF82zp16pRzzz03a621Vmpra/Pggw+mQ4cOH3lL7q222ip//etf8+STT8593vscO++88zwhNKl7/vSoUaOSJPvvv/8nznHkyJFJkl133XWBt8r+zGc+k44dO+app56ab1/btm2zzTbbzLd9nXXWSZJMmjTpE8//3z744IP87W9/y5gxYzJlypS5z0+fNGlSSil5+eWX89nPfjZJMnr06CTJ7rvvPt/7tGnTJrvttlt+/vOfz7P94YcfzsyZM7PTTjst8Dbf3bp1yzrrrJPnn38+06dP/8Rbgc+Jqv8d+5NkpZVWyg477JB77rkno0ePzp577rkQX4FPtttuu6VNm/n/WmLPPffME088kcceeyxf+9rXFnt+9TnP0jBmzJiMHDkyEyZMyPTp01NKmfsYhpdeemmx33/ChAmZMGFCVlxxxQX++7fzzjunS5cuGTduXCZNmjTPD5UkWeBrFud7HwAAYFkitgMAAPCx5jybvKqqdO7cOT179sxuu+2Wrl27JkkmT56cqVOnJsl8V7X/t8mTJ8+3bfXVV59v2zvvvJPp06dnhRVWmHuejzN+/PgkycUXX5yLL774I4+bMWPGfNtWXnnltG7der7tnTp1+sjXfJwHH3wwJ554Yt5+++2PPGZObE2SiRMnJlnw1+Gjts/5vLfccktuueWWj53PlClTPjG2z5nDgq6i/8/tb7zxxse+T32sscYaH3uuOXNa3PnV5zxL0owZMzJgwIDccccdH3nMf34fLKo58/+oz1lVVdZYY428++67eeONN+aL7autttp8r1nU730AAIBljdgOAADAxxo+fPjH7q+trU2SdOzYMX369PnYY9dff/35ti233HKLPrn/msOWW26ZtdZaq16vXdCV8Ivqgw8+yPHHH58pU6bk6KOPzp577pk11lgj7du3T1VVOemkk3LHHXeklLJY55nz+o022igbbrjhxx7737cxXxT/feeBpqah5jfn+2xhXHfddbnjjjvSs2fPnHzyyfnsZz+bLl26pG3btnnxxRcXeCeDpeXjvj5N/fcWAACgKRPbAQAAWCw1NTVZbrnl0qpVqwwbNmyJxLuampq0b98+77zzTt5999106dLlY4+fc3XurrvumsMOO2yxz7+oHn300bzzzjvp06dPjjvuuPn2v/LKK/NtW2WVVZLkI5+H/vrrr8+3bdVVV01S98MFp59++uJMee4cXn311UyYMCGf/vSn59s/50r6OeddEiZMmPCx2+d8XRZ3fvU5z5wfTJhzp4b/Vp9n1t99991Jkosuumi+HzJZ0PfBopoz/4/6nP+5b0n+/gEAAJAsuR/fBwAAYJnUpk2b9O7dO++//34efPDBJfKerVu3Tu/evZMkN9988ycev8MOOyT5f4FzaZoTZOc8h/0/vfvuu0kWfGvucePG5Zlnnplv+xZbbJEkueuuu+bbN3v27AVu33bbbdO6dev87W9/y8yZM+v3ARZgq622SpIF3vL87bffzsiRI1NV1dy5Lgl33XVXZs+ePd/2P/7xj0kyz7kWZ371Oc+cW6y/+OKL8x3/4osv1iu2f9z3wp133rnA18z53lrQfD/KGmuskTXWWCNvv/32Av/9+/vf/54pU6Zk7bXXnu8W8gAAACwesR0AAIDFdtRRR6VVq1YZMGBAHn744fn2f/DBB/nNb36T6dOnL/R7HnHEEamqKldffXUeeuihefbNmjUr995779xxr169ssMOO2T06NE5++yz8/7778/3fs8++2zuu+++enyqBZtzJfGCguw666yTpC76/+cz2999992cdtppCwzju+++e1ZYYYX84x//yB/+8Id59v3oRz/Kq6++Ot9rVl111eyzzz4ZP358TjrppLz55pvzHTNu3Lj8+c9/XqjP9O1vfzutWrXK9ddfn6eeemru9hkzZmTQoEGZPn16dtttt498rvyiGD9+fK644op5tt188815/PHHs/LKK8/zSILFmV99zrPJJpukQ4cOuf/++/P000/P3f72229n4MCB9bqN/JzvhV//+tfzbP/Tn/6U22+/fYGvmfO9NXbs2IU+T5J85zvfSZIMGzZsnu+7SZMm5bzzzkuSHHTQQfV6TwAAAD6Z28gDAACw2LbaaqucccYZGTRoUA466KD07Nkz66yzTtq0aZPx48dnzJgxmTFjRnbbbbe0b99+od6zd+/eOfnkk3P++efn4IMPzsYbb5x11lknkydPzrPPPpsZM2bk0UcfnXv8+eefn8MPPzw33nhj7rjjjmy44YZZZZVV8v777+e5557La6+9loMOOiif+9znFuuz7rLLLhk1alQOOeSQbLPNNunQoUNqamrSt2/fbLLJJtlhhx3yj3/8I3369Jl7df6oUaNSU1OTL37xi7nnnnvmeb/ll18+gwYNyvHHH58TTzwx119/fbp3757nn38+L774Yvbff//cfPPN8z17/bTTTsv48ePz5z//Offff3823HDDrLHGGpk6dWpeeOGFjBs3Ll/84hfnickfZdNNN80Pf/jDXHzxxfnmN7+Z3r17p6amJqNHj85rr72WddZZJ2ecccZifd3+23777Zcf//jHufvuu7PBBhtk3Lhxeeqpp9K2bdsMGzYsHTp0WCLzq895OnXqlMMOOyxXXnllDjjggGy99dapqipPPvlk1l133Wy++eZ5/PHHF+rzHX744bn//vtz4YUX5k9/+lM+9alP5aWXXsrTTz+dww47LD/72c/me80OO+yQ5ZZbLr/4xS/y73//O6usskqqqsp3v/vdrLvuuh95rkMOOSQPPfRQ7rvvvuy2227ZdtttU0rJgw8+mA8++CC77rprDjjggIWaNwAAAAtPbAcAAGCJ+Na3vpXNNtssv/jFLzJq1Kj87W9/S4cOHbLqqqvmK1/5Snbbbbcsv/zy9XrP7373u+nVq1euu+66jB49Os8991xWWGGF9OzZM3vuuec8x6600kq56aabcsstt+QPf/hDxowZM/fq5R49euTAAw+c7zWL4sADD8yUKVPyhz/8IXfddVdmzpyZ7t27p2/fvkmSq666Kj/60Y/ypz/9Kffdd19WWmml7LHHHjn++ONz7rnnLvA9d9ttt/z85z/PFVdckaeffjr//ve/s9lmm2XIkCH5xz/+kSRZYYUV5nlN+/bt8+Mf/zi///3vc+utt+bZZ5/NU089lZqamnTv3j1f/epX6/V5jzrqqGy44Ya57rrr8tRTT2X69OlZY401cvjhh+fII49M165dF+0L9hE233zz7L333rn00kvzt7/9LaWUbLfddjnuuOMWeDv4RZ1ffc9z7LHHplOnTrn55pvz8MMPZ6WVVso+++yT4447LkceeeRCf76tt946N954Yy6++OKMGTMmL730Unr27JnLL788n/nMZxYY21ddddVcddVVufLKK/PYY4/NfXb8V7/61Y+N7a1bt86PfvSj3Hjjjbn11lszcuTIJMl6662XvffeO9/85jfTqpWbGwIAACxpVSmlNPYkAAAAgAX77ne/m5EjR+aWW25Jr169Gns6i+3yyy/PFVdckWHDhmXvvfdu9ucBAABg2eXHmgEAAKCRvfHGG/M9d722tjbXXXddRo4cmXXWWSebbrppI80OAAAAWBC3kQcAAIBG9uijj+bkk0/ORhttlO7du2fGjBl5/vnnM378+HTo0CFDhgxJVVWNPU0AAADgP7iyHQAAABrZZz/72Xzta1/Le++9l5EjR2bkyJGpra3N1772tfzmN7/JVltt1dhTBAAAAP6LZ7YDAAAAAAAAQD25sh0AAAAAAAAA6klsBwAAAAAAAIB6EtsBAAAAAAAAoJ7EdgAAAAAAAACoJ7EdAAAAAAAAAOpJbAcAAAAAAACAehLbAQAAAAAAAKCexHYAAAAAAAAAqKf/Dzyb6ghBe6flAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%time\n", + "# Using logistic regression based propensity score\n", + "xlearner = XLearner(X=X, y=y, treated=treated, model=HistGradientBoostingRegressor())\n", + "\n", + "summarize_learner(xlearner)\n", + "xlearner.summary(n_iter=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "aaab018b-c95e-4c29-9163-410e39cd34de", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Actual average treatement effect: 0.11803778255762709\n", + "MSE: 0.02027915744890722\n", + "CPU times: total: 25min 55s\n", + "Wall time: 4min 27s\n" + ] + }, + { + "data": { + "text/html": [ + "
Conditional Average Treatment Effect Estimator Summary
Number of observations 5000
Number of treated observations 1822
Average treatement effect (ATE) 0.13
95% Confidence interval for ATE (0.12, 0.15)
Estimated bias 0.0
Base learners
Model R^2
treated HistGradientBoostingRegressor 0.88
untreated HistGradientBoostingRegressor 0.85
treated_cate HistGradientBoostingRegressor 0.48
untreated_cate HistGradientBoostingRegressor 0.44
propensity DummyClassifier 0.64
" + ], + "text/plain": [ + " ╔════════════════════════════════════════════════════════╗\n", + " ║ Conditional Average Treatment Effect Estimator Summary ║\n", + " ╚════════════════════════════════════════════════════════╝\n", + " \n", + " ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┱───────────────────────────────┐\n", + " ┃ Number of observations ┃ 5000 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃ Number of treated observations┃ 1822 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃Average treatement effect (ATE)┃ 0.13 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃95% Confidence interval for ATE┃ (0.12, 0.15) │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃ Estimated bias ┃ 0.0 │\n", + " ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┹───────────────────────────────┘\n", + " ╔═══════════════╗\n", + " ║ Base learners ║\n", + " ╚═══════════════╝\n", + " \n", + " ╔═══════════════════════════════╦═══════════════════════════════╗\n", + " ║ Model ║ R^2 ║\n", + " ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╚═══════════════════════════════╩═══════════════════════════════╝ \n", + " ┃ treated ┃ HistGradientBoostingRegressor │ 0.88 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┼───────────────────────────────┤\n", + " ┃ untreated ┃ HistGradientBoostingRegressor │ 0.85 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┼───────────────────────────────┤\n", + " ┃ treated_cate ┃ HistGradientBoostingRegressor │ 0.48 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┼───────────────────────────────┤\n", + " ┃ untreated_cate ┃ HistGradientBoostingRegressor │ 0.44 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┼───────────────────────────────┤\n", + " ┃ propensity ┃ DummyClassifier │ 0.64 │\n", + " ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┹───────────────────────────────┴───────────────────────────────┘" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAB9sAAAfbCAYAAAAIH89NAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzde4CXY/4//lc1Tek8bVEqRXQQOaSEHDaHqFbJIdaubVMU67OLnHbZtYR2PyufVYsP7fpYy25IVEJOSUgO0ZINUVE61+jcdPj94dd8jfdUc8+he6rH4y9z3fd93a/3dc2M6nlf111hy5YtWwIAAAAAAAAAKLKKaRcAAAAAAAAAALsaYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgoay0CwAAAGDHOnfuHPPmzSvQ9tJLL0Xjxo13eO2TTz4ZN9xwQ4G2s846K4YMGVLsehYvXhzjxo2LadOmxcyZM2PFihWxatWq2LhxY4HzbrjhhujTp0+x77OzfPXVV3HyyScXaGvUqFG8/PLLKVUElJaWLVtmtM2cObNI1w4bNiyGDx9eoO0Xv/hFXHHFFaVSGwAAsGsTtgMAAFBk69evjz/+8Y8xcuTIyMvLS7scAAAAgNQI2wEAgJ2usFXEERF33HFH9OrVq9Tuc/3118fo0aMLtFmtXHxr166Nn/zkJ/Hhhx+mXQoAAABA6oTtAAAAFMnvf//7EgXtc+bMiTlz5hRoa9q0aTRt2rSkpQG7gUmTJmW0nXDCCSlUAgAAUDTCdgAAAHboiy++iKeeeiqjvXHjxtGrV684+OCDo1atWlGpUqUCxxs1apT/32PGjPHuY2Cb+vfvn9FW1HerAwAApEHYDgAAwA498cQTsWXLlgJtbdu2jYceeiiqVauWUlUAAAAA6RG2AwAA7OZ69eoVvXr1KlEf7777bkbbr371K0E7UO5ZHQ8AAJSVimkXAAAAQPk3Y8aMAl9XqlQpjjrqqJSqAQAAAEifsB0AAIDtWrNmTaxfv75AW506daJKlSopVQQAAACQPmE7AAAA27Vy5cqMtqpVq6ZQCQAAAED5IWwHAABgu/Ly8tIuAQAAAKDcyUq7AAAAgF3dli1bYubMmfHJJ5/E0qVLY+3atVGtWrVo1KhRtG3bNvbZZ5+0S6SUzZo1K2bOnBmLFi2KNWvWRNWqVaNBgwbRpk2baNq0adrl7RLWrVsX77//fnzxxReRm5sbFStWjNq1a0ezZs3ikEMOierVq6ddYioWLVoUn3/+ecybNy9WrVoVa9asib322itq164dOTk50bp169R+p3z55ZcxY8aM+Prrr2Pt2rVRq1atyMnJiZYtW0bz5s1TqWlXt3bt2pgxY0Z8+eWXsWzZsli3bl3UqlUrfvCDH0SDBg3i0EMPjaws/3wHAADllT+tAwAAFOKtt96Kiy66qEBbhw4d4uGHH87/esmSJfHggw/G008/HYsXL95mX4ceemj89Kc/jTPPPDMqVKhQZjVvy5NPPhk33HBDgbazzjorhgwZUuj5nTt3jnnz5m23z3nz5kXLli23e85LL70UJ5988nbPGT58eAwfPny750RENGrUKF5++eUdnleWVq5cGY888kg89thj2x2fAw44IC644II4//zzIzs7u0h9z5o1K7p27VqgrUKFCvHiiy9G48aNS1R3RMSLL74Yl19+eYG2WrVqxWuvvbbTXwnwn//8Jx544IF44YUXYv369YWek52dHccff3xcfPHF0a5du/z2pN/L33X99dfH6NGjC7Tdcccd0atXr2J8iqL9jiiKL7/8MiZOnBhTp06Nt99+O5YvX77Da5o0aRKdOnWKPn36RLNmzRLd77uK8hnWr18fjz/+ePzzn/+Mzz77bJt97bvvvtGrV6/o27dvkR+UKGxOvm9Hv2e22t5cFtbHzJkzi9RvWVi/fn2MGTMmxowZE++9915s3Lhxm+fWrFkzjj322Ojdu3ccd9xxO7FKAACgKGwjDwAAUAxjx46NM844I0aMGLHdoD0i4t///ndce+210bt375g7d+5OqpDS9Prrr0fXrl3jrrvu2uGDCJ9//nncdttt0b1795g+fXqR+m/evHkcffTRBdq2bNkSjz/+eLFr/q6RI0dmtPXo0WOnBu15eXnxhz/8Ic4666wYN27cNoP2iIgNGzbESy+9FD/+8Y/jhhtuiHXr1u20OneWCRMmxHnnnRennHJKDB48OCZMmFCkoD3i24D+n//8Z5xxxhlxzTXXxKpVq8qkxunTp8eZZ54Zt95663aD9oiI+fPnx/Dhw+O0006Ld955p0zq2dVt2bIlRo0aFZ07d44bb7wxpk6dut2gPeLbh3yef/756Nu3b/Tv3z8+//zznVQtAABQFMJ2AACAhP72t7/FoEGD4ptvvkl03QcffBDnnntukQNYyodnnnkmLrnkkli0aFGi6+bMmRMXXnhhvPDCC0U6/4ILLshoGzVq1A7DuB2ZP39+TJ48OaO9d+/eJeo3iTVr1sQll1wSf/vb32Lz5s2Jrn3yySejT58+sWbNmjKqLh0TJkyIDz74oER9bN68OcaMGRPnnntufPHFF6VU2bcmTJgQP/nJT2L27NmJrluyZElcfPHF8cYbb5RqPbu6VatWxeWXXx6//vWvY8mSJcXqY9KkSdG7d28PMwAAQDkibAcAAEhgwoQJ8cc//jGjvW7dutGmTZvo0KFDNGvWLCpXrlzo9StWrIh+/frFrFmzyrpUSsG0adPiuuuuywi8a9euHa1bt44OHTpE8+bNo0qVKoVev2HDhrjyyivjzTff3OG9TjnllKhfv36BtsWLF8crr7xS/A8QEY8//nhGwH3kkUfGQQcdVKJ+i2rTpk1x5ZVXbjd83XvvveOwww6Lo446Kpo0aRIVKxb854pp06bFNddcU9allhv77LNPtGrVKo466qjo2LFjtGnTJurWrbvN8z///PO4+OKLEz8AtC1vvvlmXHXVVRm7D9SvXz/atGkTHTt2jNatW29zZ4R169bFNddcEytWrCiVenZ1ubm58bOf/SxeeumlbZ5Tp06daN26dXTs2DEOPfTQqFevXqHnffPNN9G3b18PMwAAQDnhne0AAABFtHz58rjppptiy5Yt+W3du3ePn/70p3H44YcXODc3Nzeee+65GDZsWMY287m5uTFo0KB44oknolKlSjuj9ESGDx8eGzZsyP968eLF8Ytf/KLAOfXr19/hu9b33nvvAtuXP/744/HEE08UOOecc86Jc889d4c1FfXd56Vpw4YNcf3110deXl5+2wknnBB9+/aNo48+ukAgvGbNmnjllVdi2LBhGSuM8/Ly4pprronx48dHrVq1tnm/ypUrxznnnBP33ntvgfaRI0fGqaeeWqzPsGnTphg1alRG+85c1f7QQw/FxIkTM9orVqwYP/7xj6N3797RokWLAscWLlwYY8aMiXvvvTdWr14dEd++d760wuTypEKFCtGmTZvo3LlzHH300dGyZcuoWbNmoed+/fXX8fzzz8cjjzyS8UqKefPmxY033hh33313iepZunRpXHXVVfnf93vttVdcdNFF0aNHj2jevHmBc9etWxcvvfRS3HnnnRmvV1iyZEnceeedceutt27zXpdddlmcf/75+V8X9n1Z2CsQCrPffvsV6bydbcuWLXHttdfGhx9+mHGsZs2a8eMf/zi6desWLVq0iAoVKhQ4/p///CceeeSRGDVqVGzatCm/ff369TFo0KAYO3Zs/OAHPyjzzwAAAGybsB0AAKCIPv300/z/zs7OjqFDh24zBK1du3b07t07unTpEldffXXGNt4zZsyIv/3tb9G/f/8yrbk4Dj744AJff/XVVxnnZGdnZzxgUJjvnvPaa69lHG/QoEGR+knD4sWL8x+UqFixYtx8883bDKmrVasW3bp1i1NOOSV+//vfZwTcixcvjiFDhsTtt9++3Xv27t077r///gLB2uuvvx7z5s2LRo0aJf4MEydOjIULFxZoq127dpxxxhmJ+yqOL7/8stDwt3bt2nHvvfdGu3btCr1un332if79+0e3bt1i4MCB8Z///CciIqZOnVqm9e5M1atXj5/+9Kfxs5/9LJo0aVKkaxo2bBh9+vSJCy64IO6888546KGHChx//vnnY/r06dG2bdti1/XdXTdatWoV9913XzRs2LDQc6tWrRrdunWLY489Nvr06ZM/T1uNGTMmrr322m0+PLDffvvtMCQvr78fiupvf/tboQ+bHH/88fHf//3fkZOTs81rW7VqFbfeemucddZZMXDgwAI7BSxdujR+85vfxH333VcGVQMAAEVlG3kAAICEKlSoEH/605+KtNq4Tp06MXz48EIDo7/85S+2Wd5F3HjjjUVaDV6lSpUYPHhwnH766RnHRo0alRFGfl/Dhg3jxBNPLNC2efPmePzxx5MV/P977LHHMtp69OixzW3vS9udd94Za9euLdBWpUqVuO+++7YZtH/XvvvuGyNGjIjGjRuXVYmpufnmm+PGG28sctD+XVWqVIlf//rXcdFFF2Uc+34AX1zNmzePRx55ZJtB+3fl5OTE0KFDM16fsW7duhg/fnyp1LMr+vLLL+Ouu+7KaD/jjDPigQce2G7Q/l1HHnlkPPTQQxk/t6+88kqhK+YBAICdR9gOAACQ0FlnnRVdunQp8vl77bVXDBkyJCOIWrt2bTz11FOlXB2lrVOnTnHhhRcW+fyKFSvGrbfeWug7tv/1r3/t8PoLLrggo+3720gXxddff13obgI7awv5JUuWxIsvvpjRfskll8SRRx5Z5H7q168fgwcPLs3SyoXvbxleHFdffXU0aNCgQNvzzz9f4DUQxZGVlRV33XVX1KhRo8jXNG/evNCHTN57770S1bIre+ihhwq8hiIi4qCDDoo//OEPiee/VatWcdVVVxV6DwAAID3CdgAAgASys7Pj6quvTnzd/vvvX+DdxFsVtvKY8uWGG25IfE2tWrUy3nMfETF27NhYs2bNdq89/vjjM7bWXrRoUbzyyiuJanjiiScyAvp27drFgQcemKif4nryySczgsb69etHv379Evd1zDHHxA9/+MPSKm23UbVq1YyAOy8vLz766KMS9dulS5do2bJl4usKez1BSWvZVa1YsSLjdRIREddee22xd5a44IILMt7R/uyzz+7wdwoAAFB2hO0AAAAJ/PCHP4x69eoV69pzzjkno23WrFnx5ZdflrQsysjhhx9e7HD6Rz/6UWRnZxdoW7VqVUybNm2711WoUKHQ1edJHszYtGlToUHfzlrVHhGFvqf6Rz/6UVStWrVY/RX280PEoYcemtH2wQcflKjP4o71IYccktE2e/bsEtWyq3rllVcyQvBmzZrFCSecUOw+q1SpkrGrSl5eXonnGwAAKD5hOwAAQAKFbZNcVK1atYoDDjggo3369OklKYkyVJL5rlWrVhx33HEZ7UUJxnr16pUR1L/22msxf/78It170qRJ8fXXXxdoq1OnTok+TxKbNm2KGTNmZLQXtvK5qE488cSoXr16ScraLX1/pXNExNy5c4vdX1ZWVhx++OHFunafffbJWLWdl5cX69evL3Y9u6q33347o+20004rcb9HHXVURtuOHuABAADKTlbaBQAAAOxKCltFmvT6zz//vEDb9OnTo1u3biXql7JR0vk+5JBDMrZ/L8rDFXXr1o3TTz89xowZk9+2efPmePzxx+OXv/zlDq8fOXJkRluPHj2KvX11Up9++mmsXbu2QFvlypWjVatWxe5z6/XvvvtuScsrt6ZNmxbvvPNOfPLJJ/HZZ5/FihUrYvXq1bF69erYuHFjkfv55ptvil1Dw4YNo1q1asW+vkaNGhnh+sqVK3fa91558c4772S0FbbyP6lGjRpltM2cObPE/QIAAMUjbAcAACiiGjVqRJMmTUrUR6tWreLpp58u0GYb+fKrJOHwtq4v6ur0Cy64oEDYHhExatSo+MUvfhGVKlXa5nULFiyISZMmZbTvzC3kC1tZvf/++2es1k+qdevWu13YvmbNmvjb3/4WTz75ZMybN69U+ly5cmWxr61du3aJ7l3YawL2tJXtGzZsiDlz5mS0r127Nt5///0S9V3Y74/c3NwS9QkAABSfsB0AAKCIivuu9h31UZJgjLKTnZ0dNWrUKFEfdevWzWgr6qrjI488Mlq2bFlg1erChQtj4sSJcfLJJ2/zuieeeCI2bdpUoO2oo46K5s2bF7HqkivsM9avX7/E/ZbGz2B58uqrr8bvfve7jC3/S+r77wpPoiSr2rdly5Ytpd5nebZ8+fJC26+77royuZ+wHQAA0uOd7QAAQLlR2oFMafdXGu+LLiy8FZSUTyUN2iMiatasmdGWZL4vuOCCjLbHHntsm+dv3rw5nnjiiYz2nbmqPaLwB0hKYzxLo4/yYvz48XHZZZeVetBO+nb273QPbAEAQHqsbAcAAHa6bW0lvW7dulK9z/ffGb29exdFYdsjl0Yfpf25KR2VK1cucR+Ffb/l5eUV+fozzzwz/vu//ztWr16d3/baa6/F119/HQ0bNsw4f9KkSRnhbZ06deL0009PUHXJFfY9XRrv7C6Nn8HyYMaMGTFo0KCMHQgiIipUqBD7779/HHHEEbHffvtFgwYNIicnJ7Kzs6NKlSpRsWLBdRMfffRR3HLLLTurdIqgqLtXlJbNmzfv1PsBAAD/j7AdAADY6WrVqlVo+3cDxdJQWH8leR9xSbZm3qqwmnan1bq7k9L4fly1alVGW2Gr3belevXq0aNHj3j00Ufz2zZt2hRPPPFEXHHFFRnnjxw5MqOtZ8+eJX5XelKF7QJRVj8/u6Jbbrml0KD9nHPOiX79+sX+++9f5L5KY1wpXVlZ/rkNAAD2FP70DwAA7HRVq1aN7Ozs2LBhQ4H2woLJkiisv20F/cXtrzT6KElNlJ01a9bE5s2bM1YSJ1HY9s5J5/uCCy4oELZHRIwaNSouu+yyqFSpUn7bwoUL49VXX824/rzzzkt0v9JQ2Gcsq5+ftGzcuLFY13344Ycxbdq0jPabb7650NcG7IjXUJQ/23qAavz48dG8efOdXA0AAFCWvLMdAABIRWErzL/44otSvUdh/ZVkZfuCBQsSbQFemK+++iqjrSQ1UXY2b94cc+fOLVEfs2fPzmirU6dOoj5atGgR7dq1K9D29ddfx6RJkwq0PfHEExmrpdu3b59KuFfY93Rh3/tJlaSP7z6YsFVhq8uLasWKFcW67uWXX85o69SpU7GC9oiI5cuXF+s6yk6DBg0KbTdXAACw+xG2AwAAqWjZsmVG2yeffFJq/S9cuLDQFZ8tWrQodp95eXkxa9askpQV//nPfzLaDjrooBL1Sdn5+OOPS/36Vq1aJe6nsCD2u1vGb968OUaNGpVxTu/evRPfqzQU9j09b968Eq9ML8l8FLa1fUm2pV+4cGGxrvvoo48y2nr06FHsOmbMmFHsaykbNWrUKDRwnz9/fgrVAAAAZUnYDgAApOKII47IaJs7d24sXry4VPp/9913C20/8sgjy6Tfoti0aVO8//77Ge2HHnpoCSradVSoUCHtEhJ78803S3T9lClTMtratm2buJ8uXbpE3bp1C7RNmjQpP/B97bXXYt68eQWO16lTJ7p06ZL4XqWhcePG8YMf/KBA25YtW+Kdd94pdp8rVqwo0cMuNWvWzGhbsmRJsft77733inVdYfcsye4DJRlTys7hhx+e0fbWW2/t/EIAAIAyJWwHAABS8f1tsSO+XZ377LPPlkr/48aNy2irXLlyiYPtsWPHFvvaN954IyNoq1ChQrHC111RdnZ2Rltx33u9szz33HOxYcOGYl07ffr0QreRL+xBkx3Jzs6Os88+u0Dbpk2b4vHHH4+IgqvctzrrrLMKHfOdpbDv65L8/Dz77LMleo3D3nvvndE2c+bMYvW1evXqQh+kKIrCVvdXq1atWH29++67pf76jTQV9v1a0ld3pOWHP/xhRturr75a7N8nAABA+SRsBwAAUtGuXbuoX79+RvvIkSNLHK58+eWXGe+zjojo3LlzVKlSpUR9T5s2LT788MNiXfuPf/wjo+3YY4+NnJycEtW0qyhsG+81a9akUEnR5ebm5gfaSY0YMSKj7dBDD40DDjigWP317t07KlYs+Nf4J554IhYsWBCvvvpqxvnnnXdese5TWs4444yMthdffDEWLFiQuK9NmzbFo48+WqJ6Dj744Iy2d999N9atW5e4ryeeeCJWrlxZrDpq1KiR0bZo0aJi9fXXv/61WNeVV4X9jli7dm0KlZTcKaeckvEQxeLFiwt9MAYAANh1CdsBAIBUZGdnx4UXXpjR/tlnn8WDDz5Yor5vvvnmQgP7Pn36lKjfrQYPHhxbtmxJdM2kSZNi4sSJGe1pB6I7U61atTLavr/1eXn05z//OfF245MnT47nn38+o70k71Bv0qRJdOrUqUDb119/HYMGDcrYIaBDhw7FDvVLy+mnnx516tQp0LZu3br44x//mLivf/3rX/HJJ5+UqJ6WLVtG5cqVC7StXr06xo8fn6ifL7/8MoYNG1bsOgpbYV/Yw0E7Mnbs2HjppZeKXUd5VLt27Yy2XeF3RGFq1KhR6O/3u+++u0SvQwAAAMoXYTsAAJCa888/v9Dtk//85z/Hk08+mbi/zZs3x0033RSTJ0/OOHbEEUeU+H3tW02bNi3+8Ic/FPn82bNnx/XXX5/R3qhRozj55JNLpaZdwYEHHpjRNn369MQPLuxsubm5cckllxS6/Xdh/vOf/8SVV16Z0d6gQYPo3r17iWr58Y9/nNH29ttvZ7SVJNQvLVWqVCk0bHzmmWfi4YcfLnI/77zzTrEC+u/Lzs6Ozp07Z7QPHTo0li1bVqQ+Fi1aFJdddlmxV7VHRBx11FEZbf/85z/j66+/LnIfU6dOjd/97nfFrqG8Kuzd9dOmTUuhktIxcODAjAdOvvnmm+jfv3+pBO6zZ8+Op556qsT9AAAAxSdsBwAAUpOTkxO33HJLRvvGjRvj17/+dfz6178u8qrG9957L37605/GY489lnGsevXqcccdd5S43goVKuT/94MPPhg333zzDrdBnzp1avTp0yeWLl2acex3v/tdxkrb3dmBBx6Y8U7mxYsXx7/+9a+UKtq+KlWq5G/b/tFHH0Xv3r1j+vTp273mqaeeiosuuii++eabjGM333xz7LXXXiWq6cQTT4xGjRpt95ycnJw47bTTSnSf0jJw4MBC673tttti+PDhGSvyv2/8+PExYMCA/K3ev7+NflLff+99xLffgz/72c9i9uzZ2732xRdfjPPOOy9/hX1x57Jz584FfpdEfLvCvl+/fjF37tztXrt1O/3+/fvH6tWrIyKiUqVKxaqjPGrTpk1G29///vcSPdyQpjp16sRtt92W0T5v3rw4++yz4//+7/8Sb5O/evXqeO6552LAgAFx+umnx9ixY0urXAAAoBiy0i4AAADYs/3oRz+Kd999N/75z38WaN+yZUuMGjUqxowZE4cddlh07NgxmjVrFrVr145q1arFypUrY8WKFTFjxoyYMmXKdreYHjx4cOy///4lrvWII46ItWvXxscffxwR365GffXVV+Pss8+Ozp07R8OGDaN69eqxaNGimDFjRowdOzZeeOGFQldud+/ePU488cQS17QrqVy5cpx88snx7LPPFmi/+eab49VXX40TTjghmjRpEtWrV88IVbOzswt953ZZqlevXpx88snx97//PSK+fcXBeeedF+3bt4+TTz45mjRpErVq1YolS5bEZ599FuPHj4/PP/+80L5+9KMfxQ9/+MMS11SxYsU477zz4q677trmOWeddVbGQw1pqVatWvz+97+Pfv36FWjfsmVLDBs2LJ599tk4++yz4/jjj48GDRpEVlZWLFq0KKZNmxajR4+OKVOm5F9TqVKlOP/88+ORRx4pdj0nnHBCdOjQIaZOnVqg/ZNPPonu3btHly5d4rjjjosGDRpExYoVY9myZfHxxx/HxIkTC/yO2WuvveKaa64p9GGhHdl///2ja9eu8cwzzxRo/+yzz6JHjx5x9tlnx6mnnhotWrSImjVrxjfffBMLFiyIyZMnx5gxY+LTTz/Nv6ZChQpxySWXxL333pu4jvLo9NNPj7vvvrtA2xdffBHdunWLHj16RJs2bSInJyeqVKmSce1+++0XdevW3VmlFtkpp5wSv/zlL+PPf/5zgfa1a9fGHXfcEffcc0907do1jjrqqGjdunXk5ORErVq1YsOGDbFq1arIzc2NWbNmxcyZM+Pf//53vPXWW7Fhw4aUPg0AAPB9wnYAACB1N954Y1SuXDk/1PyuvLy8eOedd+Kdd95J3G/VqlXjlltuia5du5ZGmZGVlRV33nln9O7dO3+l5fz582PYsGGJ3uF88MEHFyuk2x389Kc/jeeeey7jAYRXXnklXnnllW1e16hRo3j55ZfLurwM11xzTXz44Yfx3nvvRcS3IfHUqVMzwtrtOfLII2Pw4MGlVtM555wTw4cPj7y8vEKPF7Z1e5qOP/74+K//+q+MEDXi24D5D3/4Q5Fey/CrX/0q6tWrV6JaKlSoELfddlv07Nkzf2X4Vnl5eTFu3LgYN27cdvvIysqKu+66q9BXYBTVtddeG1OnTo3FixcXaF+zZk08/PDDRd5m/1e/+lUcccQRu03Y3rx58zjuuOPi9ddfL9C+cOHCuP/++7d77R133BG9evUqy/KK7bLLLouKFSsW+pBMbm5u/POf/8x44AwAANg12EYeAABIXVZWVvzmN7+J//7v/45atWqVSp/NmjWLf/7zn9GjR49S6W+r5s2bx3333VfsOo844oh48MEHo3r16qVa166iXbt20b9//7TLKLLs7Oy4//77o0OHDsW6vnPnzvHXv/41qlatWmo11atXL0499dRCj3Xo0KFUdnEobZdffnn88pe/zNg+vaj69esXl1xySanUst9++8WDDz6Y8S7toqhRo0bcc889Jd6loEGDBnHPPfcUq4aIbx8auOKKK2LAgAElqqM8uv3228vlCvWSGjBgQPzv//5viR8Y+b496VUkAABQHgnbAQCAcuPMM8+MV155JQYNGhT169cvVh+tW7eOoUOHxvjx48ts2/GjjjoqHn/88WjXrl2Rr8nOzo5LL700Hn744WIHbLuLq6++Om655ZZdZhxq1qwZDz74YFx99dVRs2bNIl1Tr169uPXWW+Pee+8t0QrobbngggsKbT///PNL/V6l5bLLLov7778/GjduXORrcnJy4k9/+lNcc801pVrLYYcdFo899lh07ty5yNd07tw5xowZU2qvf2jbtm2MGjUqjjzyyETXNWnSJO6///74xS9+USp1lDcNGjSI0aNHR6dOndIupdSddNJJ8fzzz8eAAQNK9PuvcuXKccIJJ8Rdd92VsT09AACwc1XYUtjLAwEAAFK2adOmmDFjRrz77rvx7rvvxrx582LFihWRm5sb69atixo1akTt2rWjTp06ccABB0S7du2iffv20axZs1K5/1tvvRUXXXRRgbYOHTpkbO/8+uuvx+jRo+PNN9+MJUuWFDhWoUKFaN68eZxyyilx/vnnR8OGDUultp1tyZIlcd111xVoq1evXpG2/t6eDRs2xEsvvRRTp06N//znPzFv3rxYvXp1rF27NjZt2lTg3LS2kf++VatWxXPPPReTJ0+OmTNnxsKFC2PdunVRpUqV2GeffaJNmzbxwx/+ME477bQyfW/6Cy+8kBG21q1bN1599dVy8772bdmwYUM888wzMWbMmHj33Xdj/fr1BY5XqVIlDjvssOjSpUv06tWrwMMKTz75ZNxwww0Fzj/rrLNiyJAhxa7no48+ipdeeinefPPNWLBgQSxbtiw2bdoUtWvXjgMOOCCOOuqo6NatWxx44IHFvseOvP766zFq1Kh46623Mn6PRET84Ac/iPbt28fpp58ep556amRl/b+3Ai5cuDBeeOGFAufvs88+29z9YFfyxRdfxHPPPRczZsyITz/9NHJzc2P16tUZ3zMR5Xsb+cKsW7cuJk6cGBMnToz3338/5syZE5s3by703L333jsOOOCAOPjgg6Njx47Rvn37MnmIBwAASE7YDgAAUIiihu3ftWzZsliyZEmsW7cuqlWrFvvuu69AhDLRv3//mDRpUoG2vn37ZjwUUd5t2rQp5s+fH998801UrFgxatasGfvuu29UrFj4RnxlEbaXN0uXLo0VK1bEmjVrYq+99or69etH7dq10y6LMpaXlxcLFy6MVatWxYYNG2KvvfaK6tWrR506dfx/BAAAyrGsHZ8CAABAUdStW3e3fNcw5cu8efNi8uTJBdoqVKgQvXv3Tqmi4qtUqVI0adIk7TLKlR/84Afxgx/8IO0y2MkqV66c6BULAABA+eCd7QAAALALeeyxxzK2m+7YsWOpvUIBAAAAKBphOwAAAOwiVq1aFf/6178y2n/yk5+kUA0AAADs2YTtAAAAsIsYMWJErFixokBbo0aN4oc//GE6BQEAAMAeTNgOAAAAu4A33ngjRowYkdE+YMCAqFSpUgoVAQAAwJ4tK+0CAAAAgP9n7ty5sWzZsoiIWL9+fcybNy8mTZoUzz33XGzZsqXAuU2bNo1evXqlUSYAAADs8YTtAAAAUI7cc889MXr06B2eV6FChbjlllsiK8tf7QEAACANtpEHAACAXdDAgQOjY8eOaZcBAAAAeyyPvwMAAMAupHLlynHFFVfEpZdemnYpAAAAsEcTtu/A8uXL0y6hRGrXrh25ublpl7HHMv7pMwfpMv7pMwfpMv7pMwfp2tXHf+XKlRlteXl5u9TfEXb1OdjVFXf8169fX+DrSpUqRfXq1aNJkyZx1FFHRY8ePWLffffdpb4XS8vq1asz2tavX7/NsfAzkC7jnz5zkC7jnz5zkC7jnz5zkC7jnz5zkK7dYfxzcnJ2eI6wfTdXsaI3BaTJ+KfPHKTL+KfPHKTL+KfPHKRrVx//du3axZQpU9Iuo0R29TnY1RV3/H/729/Gb3/721KuZvfQvXv36N69e5HP9zOQLuOfPnOQLuOfPnOQLuOfPnOQLuOfPnOQrj1l/PeMTwkAAAAAAAAApUjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABIKCvtAgAAAAAAANjzdDppc9olbNPkidarlifjxo2LwYMHx4033hjdu3fPb+/Zs2dERDz11FMFzl+6dGkMGTIk3njjjViyZEls3rw5XnjhhahZs2ax7t+xY8c44ogj4t577y3uR6AQSee1PBK2AwAAAAAAQCn66quv4uSTT46IiLp168aYMWMiKyszlvviiy/iggsuiIiIBg0a7BLh4q7g1ltvjbfeeitOPfXUaNKkSUREZGdn71Ih7u5g/vz50atXr+jatWv89re/TbucMiFsBwAAAAAAgDJQqVKlWLZsWbzxxhtxwgknZBwfO3ZsVKxoFX1xDR8+PKMtLy8vpk6dGscee2zccsstKVRFUZ100klxyCGHRL169dIupdj89AIAAAAAAEAZaNu2bdSoUSPGjRuXcWzjxo3x3HPPRfv27Qtd9c6ONW7cOBo3blygbenSpbF58+bYe++9U6qKoqpRo0Y0a9YsatSokXYpxSZsBwAAAAAAgDJQpUqVOPXUU+P111+PZcuWFTi2te2776r+vi1btsTYsWOjf//+0blz5zjxxBOjT58+MXbs2IxzFy9eHA888EBcfPHFccYZZ8Txxx8fPXv2jD/+8Y8Z946IuOWWW6Jjx44xf/78GDlyZPTu3Tv/mhEjRsTmzZuL9Bnffffd6NixYzzwwAMZx+bPnx8dO3bMWGHes2fP6NmzZ6xcuTKGDBkSXbt2jRNOOCEuuuiimDBhQpHu+91+tho4cGD+16NHj46OHTvm379jx46xYMGCWLBgQX77turelkWLFsVNN90UXbp0iRNPPDH69+8fU6dOLXDO7373u+jYsWN89NFHhfZx//33R8eOHYv8Od9///0YOHBgnHTSSXHaaafFb37zm1i4cGEMHDgwOnbsWODc787p9z3wwAPRsWPHePfdd/Pb8vLy4rHHHotf/vKXceaZZ8bxxx8fZ5xxRlx33XUxc+bMjD7GjRsXHTt2jHHjxsVbb70V/fv3jxNPPDFOO+20uOWWWyI3Nzf/3CeffDJ69eoVERHjx48vMOZba/huf0WR5OdhZ/GYDAAAAAAAAJSR7t27x+jRo+PZZ5+NCy+8ML997NixUatWrTjxxBPj1ltvzbhuy5Yt8bvf/S4mTJgQTZo0iS5dukRWVlZMnTo1brvttvjiiy/iv/7rv/LPf//99+PRRx+No446Ktq0aRNZWVnxySefxJNPPhlvvfVWPPTQQ4WuIB42bFhMmzYtjjvuuDj66KNj0qRJMWLEiMjLy4uBAweWzaDEtyv7r7jiili7dm2cccYZsXbt2njppZfit7/9baxYsSLOO++8xH1269YtWrRoESNHjoxWrVrFcccdFxERLVq0iIYNG8bIkSMjIqJ379751xx55JFF6nvlypVxySWXRJ06deLMM8+MFStWxIsvvhhXXnll3H777XHiiSdGRMRZZ50Vzz//fIwZMybatGlToI9NmzbFuHHjonbt2nHSSSft8J5vv/12XHnllVGxYsU45ZRTol69evHOO+/EJZdcEjVr1ixS3dvzzTffxP/8z//EYYcdFscee2zUrFkz5s+fH6+99lpMmTIl7r333jj44IMzrnvttdfijTfeiE6dOsWhhx4a77//fowfPz6++uqruP/++yMionXr1tG7d+8YOXJkHHTQQQVeo9CwYcPEtSb9edhZhO0AAAAAAABQRtq0aRPNmzePZ555Jj9sX7p0abz55pvRq1evyM7OLvS6p59+OiZMmBDdu3eP66+/Pn+r+by8vLjhhhvi0UcfjdNOOy1atWoVERHt2rWLZ555JqpVq1agn/Hjx8ctt9wSjz/+ePz85z/PuM/MmTPjH//4R/57s/v27RvnnntuPP7449GvX7+oXLlyqY3Fdy1ZsiSaNGkSDzzwQP49+vTpExdddFEMHz48TjrppMRbwXfv3j1/pX7r1q2jf//++cdOPPHEeOaZZyIiCrQX1WeffRannXZa/P73v48KFSpERMR5550Xffv2jSFDhsTRRx8dVatWjcMPPzz233//eOGFF+JXv/pV7LXXXvl9TJkyJRYtWhTnn3/+Nud9q82bN8eQIUNi06ZNMXz48Dj88MMjomDoXFI1a9aMp556KmOcP//88+jXr1/ce++9MWzYsIzrJk+eHPfcc08cdthhEfHtQwRXXHFFvPfee/Hhhx/GIYcckhG2F2fMvyvpz8POYht5AAAAAAAAKEPdu3ePzz//PD788MOIiHjmmWdi06ZN8aMf/Wib1zzxxBOx1157xaBBgwq8071y5coxYMCAiIgCgWvdunUzgvaIiDPOOCOqV68eb7/9dqH36du3b37QHhFRp06dOP7442PNmjUxZ86cZB80oQEDBhQI8/fee+8477zzYsOGDfHCCy+U6b2TqlSpUgwcODA/aI+IOOigg+L000+P5cuXxxtvvJHf3rNnz1izZk3GZxgzZkxERPTo0WOH9/vggw9i3rx5cdxxx+UH7RERFSpUiIEDB0alSpVK+IkisrOzC32g4YADDogjjzwy3n///di4cWPG8S5duuQH7RHfjk3Xrl0jImLGjBklrqswSX8edhYr2wEAAAAAAKAMnX766fGXv/wlxo0bF4ccckg888wz0aJFi2jRokWh569bty5mzZoV9erVi4cffjjj+NYA9Pth+CuvvBJPPfVUzJw5M1auXBmbNm3KP7ZkyZJC79WyZcuMtq0B7KpVq4r2AYuhUqVKceihh2a0bw2WP/nkkzK7d3Hss88+hW5/fvjhh8fYsWPjk08+ic6dO0dERNeuXeOee+6Jp59+Os4888yI+HY3g8mTJ8ehhx4a+++//w7v9+mnn+b3/30NGzaMvffeO77++usSfKJvffLJJ/GPf/wjPvjgg1i6dGlGuL5ixYoCD2NE7PzvmeL+POwMwnYAAAAAAAAoQzk5OdGpU6d44YUXonPnzjFnzpy4+uqrt3n+N998E1u2bInFixfHX//6122et3bt2vz/fuSRR2LYsGGRk5MTHTp0iL333juqVKkSEREjR46MDRs2FNpH9erVM9q2rpr+blhf2urUqRMVK2Zuwl23bt2IKNugvzi21rWt9u/WW7NmzTj55JNj/PjxMWvWrPzXCGzatKlIq9q/219OTs4271vSsH369Onxi1/8IiIiOnToEJ07d87fHWHSpEnx6aefFvp9s7O/Z4rz87CzCNsBAAAAAACgjJ155pkxceLEuPXWW6NKlSrRpUuXbZ67Ncxs1apV/N///d8O+964cWM8+OCDUa9evfj73/9eIBjesmVL/OMf/yhx/duyNTAvLGRdvXr1Nq9bsWJFbN68OSNwX7ZsWURE1KhRoxSrLLmtdW2r/fv19urVK8aPHx9PP/10XHXVVTF27NioXr16nHLKKUW639b+li9fXuR6ks7F//3f/8WGDRvivvvuy1hB/9FHH+Wvrk9b0p+Hnck72wEAAAAAAKCMHX300VG/fv1YvHhxnHDCCVGrVq1tnlu9evVo1qxZzJ49O1auXLnDvnNzc2PVqlVxyCGHZKzA/vjjj2P9+vUlrn9batasGRERixcvzjg2c+bMbV63adOm+Pe//53R/v7770dEbHOL/ZKoVKlSbN68uVjXLly4sNCV5Nuq95BDDokDDzwwnnvuuXjrrbfiyy+/jC5dukTVqlWLdL+DDjqoQP/f9fXXX8eiRYsy2pPOxbx586JWrVoZQfu6deu2O3dFtXW1e3HHfKukPw87k7AdAAAAAAAAylilSpXij3/8Y/zhD3+IgQMH7vD88847L9atWxd33HFHodtjz58/P+bPnx8R3241XqVKlZg5c2asW7cu/5xvvvkm7rzzztL7EIVo2rRpVKtWLV577bXIzc3Nb1+6dOkOVyHfd999kZeXl//1okWL4rHHHovs7Ow49dRTS73WWrVqRW5ubrEePti0aVPce++9sWXLlvy2Tz/9NJ577rnIycmJY489NuOanj17xjfffBODBw+OiCjyFvIREYcddljsu+++8frrrxcI3Lds2RL33ntvoavXDz744IiIeOaZZwq0v/zyyzFt2rSM8xs0aBArV66Mzz//vMDnvPvuu7e5oj6JmjVrRoUKFWLhwoUl7ivJz8POZBt5AAAAAAAA2Alat24drVu3LtK5Z511Vnz44Ycxfvz4mD59erRv3z7q1asXy5Ytizlz5sRHH30Ut9xyS+y7775RsWLFOPvss+PRRx+Nn/zkJ9GpU6dYvXp1TJkyJRo0aBD169cvs89UuXLlOPfcc+Ohhx6Kn/3sZ3HCCSfEmjVrYvLkyXHEEUfEV199Veh19erVi7Vr1+bXu3bt2njppZciNzc3rrrqqth7771LvdZ27drFxx9/HFdeeWUcfvjhkZWVFUcccUQcccQRO7z2wAMPjOnTp8fPf/7zaN++faxYsSJefPHF2LRpU1x//fWFrlg/44wz4i9/+UssXrw4WrVqFS1btixyrRUrVozrr78+rrrqqviv//qvOOWUU6JevXrxzjvvxNKlS+PAAw+Mzz77rMA1xx9/fDRu3DieeeaZWLhwYbRs2TJmz54d77zzThx77LHxxhtvFDj/3HPPjbfeeisuvfTSOPnkkyM7Ozvee++9WLx4cRx55JHx3nvvFbnewlSrVi1at24d77//ftx8883RpEmTqFChQpxxxhnRsGHDRH0l+XnYmYTtAAAAAAAA7HSTJ9qAeXsqVKgQv/3tb+PYY4+Np59+Ol5//fVYs2ZN5OTkRJMmTeKKK66I9u3b559/2WWXRa1ateKZZ56JJ598MurWrRunnnpq9OvXL3784x+Xaa2XXnppVK5cOcaOHRujR4+Ohg0bxs9//vM4/vjj45VXXin0mqysrLj77rvjnnvuiWeffTZWrVoVTZs2jauvvjpOO+20Mqmzb9++sXLlynj99dfjgw8+iE2bNsXFF19cpLC9Zs2aMXTo0Lj77rvj6aefjvXr10eLFi2iX79+cfTRRxd6TfXq1ePEE0+M5557LtGq9q06dOgQw4cPj//93/+Nl156KapUqRLt27eP22+/PX7/+99nnF+1atW4++67489//nO8/fbb8dFHH0WbNm3ivvvui8mTJ2eE7Z06dYrbb789HnrooXjuueeiatWq0a5du/jDH/4Qf/3rXxPXW5ibb745/ud//idef/31WLVqVWzZsiUOO+ywxGF70p+HnaXClu/udUCG0tgiIU05OTm7/GfYlRn/9JmDdBn/9JmDdBn/9JmDdBn/9JmDdBn/9JmDdBn/9JmDdBn/9JmDdBn/9JmDdBn/7evZs2dERDz11FNldo/yMgcXXnhhzJ8/P8aNGxfVq1cvtX4HDhwY06ZNiylTppRan6WpvIx/SeTk5OzwHI8MAQAAAAAAAJSyN954I2bNmhVdunQp1aCd8sM28gAAAAAAAAClZNSoUbFo0aIYM2ZMVKlSJS666KK0S6KMCNtT1umkzWV8h6Vl2rv3qQAAAAAAAMD/8/DDD8fixYtjv/32i9/85jex7777pl0SZUTYDgAAAAAAAOw0Zfmu9vJgZ3y+e++9t8zvwY5ZlgwAAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASykq7gO2ZPn16DBs2LKZNmxYbN26MFi1aRJ8+faJr165Fuv7JJ5+MG264YZvH//73v8fRRx9dWuUCAAAAAAAAsIcot2H7lClTol+/fpGdnR3dunWL6tWrx4QJE+LKK6+MBQsWRN++fYvc18knnxytW7fOaG/UqFFplgwAAAAAAADAHqJchu0bN26Mm266KSpUqBCPPPJIflB++eWXxznnnBNDhw6NLl26FDksP+WUU6JXr15lWTIAAAAAAAAAe5By+c72KVOmxNy5c6N79+4FVqTXrFkzBgwYEHl5eTF69OgUKwQAAAAAAABgT1YuV7ZPnTo1IiI6deqUcWxr29tvv13k/mbMmBErVqyIjRs3RuPGjeOYY46JnJyc0ikWAAAAAAAAgD1OuQzbZ8+eHRERTZs2zThWv379qFatWsyZM6fI/T388MMFvq5atWpcfvnlcckll5SoTgAAAAAAAAD2TOUybF+1alVEfLttfGFq1KgRK1eu3GE/jRs3jptuuik6deoUDRo0iNzc3HjzzTdj6NChceedd8Zee+0VP/3pT7fbR+3ataNixbLcbX9pGfZd9uwQsGPGKH3mIF3GP33mIF3GP33mIF3GP33mIF3GP33mIF3GP33mIF3GP33mIF3GP33mIF3GP33mIF17wviXy7C9tHTo0CE6dOiQ/3XVqlWjZ8+e0aZNmzj77LNj+PDhccEFF0RW1raHITc3d2eUustavnx52iWUazk5OcYoZeYgXcY/feYgXcY/feYgXcY/feYgXcY/feYgXcY/feYgXcY/feYgXcY/feYgXcY/feYgXbvD+BflYYGyXLJdbDVq1IiI2Obq9VWrVm1z1XtRHHTQQdGuXbtYsWJFzJo1q9j9AAAAAAAAALBnKpdhe7NmzSIiCn0v++LFi2PNmjWFvs89ia1PIqxdu7ZE/QAAAAAAAACw5ymXYXv79u0jImLy5MkZx7a2bT2nODZt2hQffvhhRETsu+++xe4HAAAAAAAAgD1TuQzbjznmmGjSpEmMGzcuPv744/z2lStXxn333ReVK1eOnj175rcvWrQoZs2albHt/NZA/bs2bdoUf/rTn2LOnDlx9NFHx957711mnwMAAAAAAACA3VNW2gUUJisrKwYPHhz9+vWLCy+8MLp16xbVq1ePCRMmxLx58+K6666Lxo0b558/dOjQGD16dNxxxx3Rq1ev/Pazzz47WrZsGS1btox99tkncnNzY+rUqTF79uxo0KBB3HbbbWl8PAAAAAAAAAB2ceUybI+I6NixYzz66KNx9913x/jx42Pjxo3RokWLGDRoUHTt2rVIffTt2zfef//9eOONNyI3NzcqV64c++23XwwcODB+/vOfR+3atcv4UwAAAAAAAACwOyq3YXtERNu2bWPEiBE7PG/IkCExZMiQjPbrrruuLMoCAAAAAAAAYA9XLt/ZDgAAAAAAAADlmbAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACRUrsP26dOnR//+/eOoo46Kww8/PM4777wYP358sfvLzc2N448/Plq2bBkXX3xxKVYKAAAAAAAAwJ4kK+0CtmXKlCnRr1+/yM7Ojm7dukX16tVjwoQJceWVV8aCBQuib9++ifu85ZZbYtWqVWVQLQAAAAAAAAB7knK5sn3jxo1x0003RYUKFeKRRx6JW2+9Na6//vp4+umno1mzZjF06NCYN29eoj6ff/75GDduXAwaNKiMqgYAAAAAAABgT1Euw/YpU6bE3Llzo3v37tG6dev89po1a8aAAQMiLy8vRo8eXeT+li1bFjfffHP06NEjTjzxxLIoGQAAAAAAAIA9SLkM26dOnRoREZ06dco4trXt7bffLnJ/v/vd76JSpUrxm9/8pnQKBAAAAAAAAGCPVi7f2T579uyIiGjatGnGsfr160e1atVizpw5Rerr6aefjgkTJsRf/vKXqF27dqxcubI0SwUAAAAAAABgD1Quw/ZVq1ZFxLfbxhemRo0aRQrNFy5cGLfddlt07949TjnllGLVUrt27ahYsSw3AFhahn2XvZycnLRLKPeMUfrMQbqMf/rMQbqMf/rMQbqMf/rMQbqMf/rMQbqMf/rMQbqMf/rMQbqMf/rMQbqMf/rMQbr2hPEvl2F7abnxxhsjKyurRNvH5+bmlmJFu5/ly5enXUK5lpOTY4xSZg7SZfzTZw7SZfzTZw7SZfzTZw7SZfzTZw7SZfzTZw7SZfzTZw7SZfzTZw7SZfzTZw7StTuMf1EeFiiXYXuNGjUiIra5en3VqlVRu3bt7fYxevTomDRpUvz5z3+OunXrlnqNAAAAAAAAAOy5ymXY3qxZs4iImDNnThxyyCEFji1evDjWrFkTbdu23W4fM2bMiIiIX/7yl4Uenzx5crRs2TJatWoVTz/9dMmLBgAAAAAAAGCPUS7D9vbt28f//u//xuTJk6Nbt24Fjk2ePDn/nO054ogjYs2aNRnta9asifHjx0eDBg2iU6dO0bBhw9IrHAAAAAAAAIA9QrkM24855pho0qRJjBs3Li666KJo3bp1RHy7rfx9990XlStXjp49e+afv2jRoli5cmXsvffeUbNmzYiI6Nq1a3Tt2jWj76+++irGjx8fBx54YNx222075fMAAAAAAAAAsHupmHYBhcnKyorBgwfHli1b4sILL4ybbrophgwZEj169IjZs2fHVVddFY0bN84/f+jQodG1a9d44YUXUqwaAAAAAAAAgD1FuVzZHhHRsWPHePTRR+Puu++O8ePHx8aNG6NFixYxaNCgQlesAwAAAAAAAMDOUm7D9oiItm3bxogRI3Z43pAhQ2LIkCFF6rNx48Yxc+bMkpYGAAAAAAAAwB6sXG4jDwAAAAAAAADlmbAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJJSVdgGQpk4nbS7jOywt094nT/S8DAAAAAAAAKRBUgcAAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABIKCvtAoA9W6eTNpfxHZaWae+TJ3pmCQAAAAAAYE8kJQIAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAllpV3A9kyfPj2GDRsW06ZNi40bN0aLFi2iT58+0bVr1yJd/+qrr8ZTTz0VH3/8cSxZsiTy8vKiYcOGceSRR0b//v1j//33L+NPAAAAAAAAAMDuqNyG7VOmTIl+/fpFdnZ2dOvWLapXrx4TJkyIK6+8MhYsWBB9+/bdYR+TJk2KDz74INq2bRt77713ZGVlxeeffx5PPfVUjB07Nu6///445phjdsKnAQAAAAAAAGB3Ui7D9o0bN8ZNN90UFSpUiEceeSRat24dERGXX355nHPOOTF06NDo0qVLNGrUaLv9XHvttXHTTTdltL/55pvRp0+f+NOf/hSjRo0qk88AAAAAAAAAwO6rXL6zfcqUKTF37tzo3r17ftAeEVGzZs0YMGBA5OXlxejRo3fYT5UqVQptP+aYY6J27doxd+7cUqsZAAAAAAAAgD1HuQzbp06dGhERnTp1yji2te3tt98udv/Tpk2L3NzcOOigg4rdBwAAAAAAAAB7rnK5jfzs2bMjIqJp06YZx+rXrx/VqlWLOXPmFLm/yZMnx7Rp02LDhg0xZ86ceOWVVyInJyduuOGG0ioZAAAAAAAAgD1IuQzbV61aFRHfbhtfmBo1asTKlSuL3N/rr78ef/vb3/K/btq0aQwdOjQOOeSQHV5bu3btqFixLDcAWFqGfZe9nJyctEsoIeOfPnOwuzNG6TMH6TL+6TMH6TL+6TMH6TL+6TMH6TL+6TMH6TL+6TMH6TL+6TMH6TL+6TMH6doTxr9chu2l7brrrovrrrsuVq9eHbNmzYq//OUvccEFF8Ttt98eP/rRj7Z7bW5u7k6qcte0fPnytEvYoxn/9JmD7cvJyTFGKTMH6TL+6TMH6TL+6TMH6TL+6TMH6TL+6TMH6TL+6TMH6TL+6TMH6TL+6TMH6dodxr8oDwuUy3e216hRIyJim6vXV61atc1V79tTvXr1aNu2bfzlL3+JAw44IH7729/GsmXLSlQrAAAAAAAAAHuechm2N2vWLCKi0PeyL168ONasWVPo+9yLKisrK44++uhYs2ZN/Pvf/y52PwAAAAAAAADsmcpl2N6+ffuIiJg8eXLGsa1tW88prkWLFkVEROXKlUvUDwAAAAAAAAB7nnIZth9zzDHRpEmTGDduXHz88cf57StXroz77rsvKleuHD179sxvX7RoUcyaNStj2/ltrVp/7bXX4sUXX4xatWrF4YcfXhYfAQAAAAAAAIDdWFbaBRQmKysrBg8eHP369YsLL7wwunXrFtWrV48JEybEvHnz4rrrrovGjRvnnz906NAYPXp03HHHHdGrV6/89nPOOSdatGgRLVq0iAYNGsTatWtj5syZ8c4770TlypXj9ttvj2rVqqXxEQEAAAAAAADYhZXLsD0iomPHjvHoo4/G3XffHePHj4+NGzdGixYtYtCgQdG1a9ci9XHVVVfFW2+9FW+//XYsW7YsKlasGA0bNozevXvHz372s2jevHkZfwoAAAAAAAAAdkflNmyPiGjbtm2MGDFih+cNGTIkhgwZktF+6aWXxqWXXloWpQEAAAAAAACwByuX72wHAAAAAAAAgPJM2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkFBW2gUAkJ5OJ20u4zssLdPeJ0/0zBgAAAAAAJAOKQUAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgoay0CwCAPVmnkzaX8R2Wlmnvkyd6bg8AAAAAgD2TfyEHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABLKSrsAAIC0dDppcxnfYWmZ9j55oucmAQAAAADS4l9oAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISy0i5ge6ZPnx7Dhg2LadOmxcaNG6NFixbRp0+f6Nq16w6v3bJlS0yaNClefvnleO+992L+/PmxcePGaNq0aXTt2jV+/vOfR5UqVXbCpwAAAAAAAABgd1Nuw/YpU6ZEv379Ijs7O7p16xbVq1ePCRMmxJVXXhkLFiyIvn37bvf6DRs2xCWXXBLZ2dnRoUOH6NSpU2zYsCEmT54cd911V7z44ovx8MMPx1577bWTPhEAAAAAAAAAu4tyGbZv3LgxbrrppqhQoUI88sgj0bp164iIuPzyy+Occ86JoUOHRpcuXaJRo0bb7KNixYrxq1/9Kn784x9H7dq189vz8vLiiiuuiFdeeSUeeeSR6NevX5l/HgAAAAAAAAB2L+Xyne1TpkyJuXPnRvfu3fOD9oiImjVrxoABAyIvLy9Gjx693T4qV64cAwcOLBC0b22/9NJLIyLi7bffLv3iAQAAAAAAANjtlcuwferUqRER0alTp4xjW9tKEpRnZX27oL9SpUrF7gMAAAAAAACAPVe5DNtnz54dERFNmzbNOFa/fv2oVq1azJkzp9j9jxo1KiIijjvuuGL3AQAAAAAAAMCeq1y+s33VqlUR8e228YWpUaNGrFy5slh9v/rqqzFy5Mho3rx5nHvuuTs8v3bt2lGxYlk+k7C0DPsuezk5OWmXUELGP33mIF3GP33mIF3Gf09gnNJl/NNnDtJl/NNnDtJl/NNnDtJl/NNnDtJl/NNnDtJl/NNnDtK1J4x/uQzby8r06dPjyiuvjJo1a8af//znyM7O3uE1ubm5O6GyXdfy5cvTLmGPZvzTZw7SZfzTZw7StTuMf6eTNqddQolMnlguN4oqN3JycnaL79NdmTlIl/FPnzlIl/FPnzlIl/FPnzlIl/FPnzlIl/FPnzlI1+4w/kV5WKBc/utgjRo1IiK2uXp91apV21z1vi3//ve/4+KLL46KFSvGiBEj4qCDDipxnQAAAAAAAADsmcpl2N6sWbOIiELfy7548eJYs2ZNoe9z35Z///vf0bdv39i8eXP89a9/jbZt25ZWqQAAAAAAAADsgcpl2N6+ffuIiJg8eXLGsa1tW8/Zka1B+6ZNm2LEiBFx2GGHlV6hAAAAAAAAAOyRymXYfswxx0STJk1i3Lhx8fHHH+e3r1y5Mu67776oXLly9OzZM7990aJFMWvWrIxt5z/88MPo27dvbNy4MR544IE44ogjdtZHAAAAAAAAAGA3lpV2AYXJysqKwYMHR79+/eLCCy+Mbt26RfXq1WPChAkxb968uO6666Jx48b55w8dOjRGjx4dd9xxR/Tq1SsiIlasWBF9+/aNb775Jo4//vh444034o033ihwn5o1a0afPn125kcDAAAAAAAAYDdQLsP2iIiOHTvGo48+GnfffXeMHz8+Nm7cGC1atIhBgwZF165dd3j9qlWrIjc3NyIiXnvttXjttdcyzmnUqJGwHQAAAAAAAIDEym3YHhHRtm3bGDFixA7PGzJkSAwZMqRAW+PGjWPmzJllVRoAAAAAAAAAe7By+c52AAAAAAAAACjPhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJZaVdAAAAkI5OJ20u4zssLdPeJ0/07DAAAAAA6fGvUwAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAIKGstAsAAADYU3U6aXMZ32FpmfY+eaLntwEAAIA9l38ZAQAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQllpFwAAAABp6HTS5jK+w9Iy7X3yRM/PAwAAQJr8zRwAAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQEJZaRcAAAAA7Jk6nbS5jO+wtEx7nzzRGgYAAIA9mb8VAgAAAAAAAEBCwnYAAAAAAAAASEjYDgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEgoK+0Ctmf69OkxbNiwmDZtWmzcuDFatGgRffr0ia5duxbp+rlz58bTTz8dH330UXz00UexaNGiaNSoUbz88stlXDkAAAAAAAAAu7NyG7ZPmTIl+vXrF9nZ2dGtW7eoXr16TJgwIa688spYsGBB9O3bd4d9vPPOOzF8+PCoVKlSNG/ePJYsWbITKgcAAAAAAABgd1cuw/aNGzfGTTfdFBUqVIhHHnkkWrduHRERl19+eZxzzjkxdOjQ6NKlSzRq1Gi7/bRv3z5GjhwZrVq1iqpVq8ahhx66M8oHAAAAAAAAYDdXLt/ZPmXKlJg7d2507949P2iPiKhZs2YMGDAg8vLyYvTo0Tvsp0mTJnH44YdH1apVy7JcAAAAAAAAAPYw5TJsnzp1akREdOrUKePY1ra33357p9YEAAAAAAAAAFuVy23kZ8+eHRERTZs2zThWv379qFatWsyZM2en1FK7du2oWLEsn0lYWoZ9l72cnJy0Sygh458+c5Au458+c5Au458+c5Au458+c5Au458+c7C7M0bpMwfpMv7pMwfpMv7pMwfpMv7pMwfp2hPGv1yG7atWrYqIb7eNL0yNGjVi5cqVO6WW3NzcnXKfXdXy5cvTLmGPZvzTZw7SZfzTZw7SZfzTZw7SZfzTZw7SZfzTZw62LycnxxilzByky/inzxyky/inzxyky/inzxyka3cY/6I8LFAut5EHAAAAAAAAgPKsXIbtNWrUiIjY5ur1VatWbXPVOwAAAAAAAACUtXK5jXyzZs0iImLOnDlxyCGHFDi2ePHiWLNmTbRt2zaFygAAAAB2D51O2lzGd1hapr1Pnlgu15AAAAB7kHL5t5L27dtHRMTkyZMzjm1t23oOAAAAAAAAAOxs5TJsP+aYY6JJkyYxbty4+Pjjj/PbV65cGffdd19Urlw5evbsmd++aNGimDVr1ja3nQcAAAAAAACA0lQut5HPysqKwYMHR79+/eLCCy+Mbt26RfXq1WPChAkxb968uO6666Jx48b55w8dOjRGjx4dd9xxR/Tq1Su/fdmyZfHHP/4x/+uNGzfG8uXL4/rrr89vu/baa6Nu3bo754MBAAAAAAAAsFsol2F7RETHjh3j0UcfjbvvvjvGjx8fGzdujBYtWsSgQYOia9euRepjzZo1MXr06O22/eIXvxC2AwAAAAAAAJBIuQ3bIyLatm0bI0aM2OF5Q4YMiSFDhmS0N27cOGbOnFkWpQEAAAAAAACwByuX72wHAAAAAAAAgPJM2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJBQVtoFAAAAAMCeqNNJm8v4DkvLtPfJE63jAQBgz+ZPxAAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASCgr7QIAAAAAAHa2TidtLuM7LC3j/iMmT7SWCgAgTf40BgAAAAAAAAAJCdsBAAAAAAAAICFhOwAAAAAAAAAkJGwHAAAAAAAAgISE7QAAAAAAAACQkLAdAAAAAAAAABIStgMAAAAAAABAQsJ2AAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAAAAAAkJ2wEAAAAAAAAgIWE7AAAAAAAAACQkbAcAAAAAAACAhITtAAAAAAAAAJCQsB0AAAAAAAAAEhK2AwAAAAAAAEBCwnYAAAAAAAAASCgr7QIAAAAAANjzdDppcxnfYWmZ9j55orVsALCn86cBAAAAAAAAAEhI2A4AAAAAAAAACQnbAQAAAAAAACAhYTsAAAAAAAAAJCRsBwAAAAAAAICEhO0AAAAAAAAAkJCwHQAAAAAAAAASErYDAAAAAAAAQELCdgAAAAAAAABISNgOAAAAAADw/7F353FRlX0fx7+DYIKgouKuYGah5prihvuumUtgVm65lCmmqblUpmlmm9sdmuWSGpUCJWpibqWBmqi4ZOLtCpKomZKJGxjz/NHDFDeojMEcnPm8X6/n9dycuRi/XYeZ65zzO+e6AACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKzkYHAAAAAAAAAAAAtuXfMj2P/4WLefz+UvRWnicEABgrXxfbDx48qA8//FD79u3TrVu39PDDD2vAgAHq3Llzjt8jNTVVn3zyidasWaOzZ8+qaNGiatWqlUaNGqUSJUrkYXoAAAAAAAAAAAAAgL3Kt8X2H3/8UYMHD1bBggXVpUsXFS5cWBs3btTLL7+sc+fOaeDAgXd9j/T0dL344ouKjo5WnTp11L59eyUkJCgsLEw7d+5UaGioihcvboP/GgAAAAAAAAAAAACAPcmXxfZbt25p0qRJMplM+vzzz1WtWjVJ0vDhwxUQEKBZs2apQ4cOKl++/B3fZ9WqVYqOjtbjjz+uDz74QCaTSZL05ZdfasqUKZozZ46mTp2a5/89AAAAAAAAAAAAAAD7ki8XNPnxxx91+vRpPf7445ZCuyR5eHho6NChSktL06pVq+76PmFhYZKk0aNHWwrtktS7d29VrFhRa9eu1Y0bN3L/PwAAAAAAAAAAAAAAYNfyZbE9JiZGkuTv75/ltYxtu3fvvuN73Lx5UwcOHFDlypWzPAFvMpnUpEkTXbt2TYcOHcql1AAAAAAAAAAAAAAAR5Evp5GPj4+XJHl7e2d5zcvLS25ubkpISLjje5w+fVrp6eny8fHJ9vWM7fHx8apfv/5t36do0aJycsq7exJ+PpBnb40coP+Nxz4wFv1vPPaBseh/47EPjEX/G499YCz633jsA2PR/8ZjHxiL/jce+8BY9L/xatS+mMf/Qt6+/88HSuTp++e1+73/JfbB3fEZuJP7vf+l/LEP8mWxPSUlRdJf08Znx93dXVeuXLnje2S87u7uftv3+Oe/dTuXL1++4+v5naenp5KTk42O4bDof+OxD4xF/xuPfWAs+t947ANj0f/GYx8Yi/43HvvAWPS/8dgHxqL/jcc+MBb9b//Yv8ZjHxiL/jdeXu8DT0/Pu7bJl9PIAwAAAAAAAAAAAACQn+XLYnvGU+e3e3o9JSXltk+9Z8h4/XZPrmdsv92T7wAAAAAAAAAAAAAA3E6+LLZnrKee3brsFy5c0LVr17Jdz/2fKlasKCcnJ8v67/8rY/vt1nQHAAAAAAAAAAAAAOB28mWxvUGDBpKk6OjoLK9lbMtoczuFChVSrVq1dOrUKZ05cybTa2azWTt27JCbm5seffTRXEoNAAAAAAAAAAAAAHAU+bLY3rhxY1WsWFHffPON4uLiLNuvXLmiBQsWyMXFRd27d7ds//XXX3XixIks08736tVLkjRr1iyZzWbL9hUrVigxMVFdu3ZVoUKF8vY/BgAAAAAAAAAAAABgd5yNDpAdZ2dnvfXWWxo8eLCeffZZdenSRYULF9bGjRt15swZjR8/XhUqVLC0nzVrllatWqUZM2aoZ8+elu09evRQZGSkvvnmG/3yyy9q0KCBTp8+rY0bN6pChQoaNWqUAf91AAAAAAAAAAAAAID7Xb58sl2SGjVqpC+++EL16tVTZGSkvvzyS5UoUUKzZ8/WwIEDc/QeTk5O+uijjzRixAhdunRJS5cuVWxsrAICArRy5UoVL148j/8rAAAAAAAAAAAAAAD2KF8+2Z6hVq1aWrRo0V3bvfPOO3rnnXeyfa1gwYIKCgpSUFBQbscDAAAAAAAAAAAAADiofPtkOwAAAAAAAAAAAAAA+RXFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwErORgcAAAAAAAAAAABwNNFb8/Z5SE9PTyUnJ+fpvwEAjo4n2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALCSs9EBAAAAAAAAAAAAAFuK3pq3z6N6enoqOTk5T/8NAMbjyXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsJKz0QGyk5KSog8//FAbN27UhQsXVKpUKXXo0EFBQUEqXLhwjt/ns88+0+HDh3Xo0CGdOHFCf/75p5YvX66GDRvmYXoAAAAAAAAAAAAAgL3Ld8X2a9euqU+fPoqLi5O/v7+6dOmiuLg4LVmyRLt379bnn3+uBx54IEfv9dZbb0mSvLy8VLx4cV24cCEvowMAAAAAAAAAAAAAHES+m0Z+0aJFiouL05AhQ7R48WKNHTtWixcv1pAhQ/TTTz9p6dKlOX6vjz/+WNHR0YqOjlbr1q3zLjQAAAAAAAAAAAAAwKHkq2K72WxWWFiY3NzcNGzYsEyvDRs2TG5ubgoLC8vx+7Vs2VJeXl65HRMAAAAAAAAAAAAA4ODyVbE9Pj5ev/76q+rVqyc3N7dMr7m5ualevXpKTEzU2bNnDUoIAAAAAAAAAAAAAEA+W7M9ISFBkuTj45Pt6z4+PoqOjlZ8fLzKli1rk0xFixaVk1O+uifBap6enkZHcGj0v/HYB8ai/43HPjAW/W889oGx6H/jsQ+MRf8bj31gLPrfeOwDY9H/xmMfGIv+Nx77wFj0/91cNDrAv3L/79/7u/+l/LEP8lWx/cqVK5Ikd3f3bF/P2J6SkmKzTJcvX7bZv5UXPD09lZycbHQMh0X/G499YCz633jsA2PR/8ZjHxiL/jce+8BY9L/x2AfGov+Nxz4wFv1vPPaBseh/47EPjEX/2z/2r/Hyeh/kpJifJ8X2d955R6mpqTlu369fv9s+zQ4AAAAAAAAAAADAvkRvzduZpbnhAbaQJ8X2lStX6tq1azlu36FDB/n4+MjDw0PS7Z9cz9h+uyffAQAAAAAAAAAAAACwhTwptu/bt++efs/b21uSFB8fn+3rGdt5Ch4AAAAAAAAAAAAAYKS8nZ/BSj4+PipVqpRiY2OzPBl/7do1xcbGqkKFCipbtqxBCQEAAAAAAAAAAAAAyGfFdpPJpMDAQF27dk3z58/P9Nr8+fN17do19erVK9P269ev68SJE0pKSrJlVAAAAAAAAAAAAACAA8uTaeT/jcGDB2vLli1auHCh4uLiVL16dR0+fFjR0dGqWbOm+vfvn6n9wYMH1a9fP/n5+emzzz7L9Nonn3yikydPSvp7avtPPvlEq1atkiS1bdtWbdu2tcF/FQAAAAAAAAAAAADAnuS7Yrubm5tCQkL04YcfauPGjdq1a5e8vLw0cOBADR8+XIUKFcrxe0VFRSkmJibTtujoaMv/Ll++PMV2AAAAAAAAAAAAAIDV8l2xXZI8PDz06quv6tVXX71r24YNG+q///1vtq/975PuAAAAAAAAAAAAAADkhny1ZjsAAAAAAAAAAAAAAPcDiu0AAAAAAAAAAAAAAFiJYjsAAAAAAAAAAAAAAFai2A4AAAAAAAAAAAAAgJUotgMAAAAAAAAAAAAAYCWK7QAAAAAAAAAAAAAAWIliOwAAAAAAAAAAAAAAVqLYDgAAAAAAAAAAAACAlSi2AwAAAAAAAAAAAABgJYrtAAAAAAAAAAAAAABYiWI7AAAAAAAAAAAAAABWotgOAAAAAAAAAAAAAICVKLYDAAAAAAAAAAAAAGAliu0AAAAAAAAAAAAAAFiJYjsAAAAAAAAAAAAAAFai2A4AAAAAAAAAAAAAgJUotgMAAAAAAAAAAAAAYCWK7QAAAAAAAAAAAAAAWIliOwAAAAAAAAAAAAAAVqLYDgAAAAAAAAAAAACAlSi2AwAAAAAAAAAAAABgJYrtAAAAAAAAAAAAAABYiWI7AAAAAAAAAAAAAABWotgOAAAAAAAAAAAAAICVKLYDAAAAAAAAAAAAAGAliu0AAAAAAAAAAAAAAFiJYjsAAAAAAAAAAAAAAFai2A4AAAAAAAAAAAAAgJUotgMAAAAAAAAAAAAAYCWK7QAAAAAAAAAAAAAAWIliOwAAAAAAAAAAAAAAVqLYDgAAAAAAAAAAAACAlSi2AwAAAAAAAAAAAABgJYrtAAAAAAAAAAAAAABYiWI7AAAAAAAAAAAAAABWotgOAAAAAAAAAAAAAICVKLYDAAAAAAAAAAAAAGAliu0AAAAAAAAAAAAAAFiJYjsAAAAAAAAAAAAAAFai2A4AAAAAAAAAAAAAgJUotgMAAAAAAAAAAAAAYCWK7QAAAAAAAAAAAAAAWIliOwAAAAAAAAAAAAAAVqLYDgAAAAAAAAAAAACAlSi2AwAAAAAAAAAAAABgJYrtAAAAAAAAAAAAAABYiWI7AAAAAAAAAAAAAABWotgOAAAAAAAAAAAAAICVKLYDAAAAAAAAAAAAAGAliu0AAAAAAAAAAAAAAFiJYjsAAAAAAAAAAAAAAFai2A4AAAAAAAAAAAAAgJUotgMAAAAAAAAAAAAAYCWK7QAAAAAAAAAAAAAAWIliOwAAAAAAAAAAAAAAVqLYDgAAAAAAAAAAAACAlSi2AwAAAAAAAAAAAABgJYrtAAAAAAAAAAAAAABYiWI7AAAAAAAAAAAAAABWotgOAAAAAAAAAAAAAICVKLYDAAAAAAAAAAAAAGAliu0AAAAAAAAAAAAAAFiJYjsAAAAAAAAAAAAAAFai2A4AAAAAAAAAAAAAgJUotgMAAAAAAAAAAAAAYCWK7QAAAAAAAAAAAAAAWIliOwAAAAAAAAAAAAAAVqLYDgAAAAAAAAAAAACAlSi2AwAAAAAAAAAAAABgJYrtAAAAAAAAAAAAAABYiWI7AAAAAAAAAAAAAABWotgOAAAAAAAAAAAAAICVKLYDAAAAAAAAAAAAAGAliu0AAAAAAAAAAAAAAFiJYjsAAAAAAAAAAAAAAFai2A4AAAAAAAAAAAAAgJUotgMAAAAAAAAAAAAAYCWK7QAAAAAAAAAAAAAAWIliOwAAAAAAAAAAAAAAVqLYDgAAAAAAAAAAAACAlSi2AwAAAAAAAAAAAABgJYrtAAAAAAAAAAAAAABYiWI7AAAAAAAAAAAAAABWotgOAAAAAAAAAAAAAICVKLYDAAAAAAAAAAAAAGAliu0AAAAAAAAAAAAAAFiJYjsAAAAAAAAAAAAAAFZyNjpAdlJSUvThhx9q48aNunDhgkqVKqUOHTooKChIhQsXztF7xMfH69tvv1VUVJQSEhL0+++/q0SJEmrYsKFeeOEFValSJY//KwAAAAAAAAAAAAAA9irfFduvXbumPn36KC4uTv7+/urSpYvi4uK0ZMkS7d69W59//rkeeOCBu77P3LlzFRkZqYcfflht2rSRu7u7jh49qtWrV2vDhg1atGiRGjRoYIP/IgAAAAAAAAAAAADIP6K35u0E6J6enkpOTs7TfyM/yHfF9kWLFikuLk5DhgzR2LFjLds/+OADLVy4UEuXLtULL7xw1/dp1qyZhgwZourVq2favm7dOo0ePVpTpkzRunXrcj0/AAAAAAAAAAAAAMD+5as1281ms8LCwuTm5qZhw4Zlem3YsGFyc3NTWFhYjt6rZ8+eWQrtktSlSxf5+Pjo+PHjunTpUq7kBgAAAAAAAAAAAAA4lnxVbI+Pj9evv/6qevXqyc3NLdNrbm5uqlevnhITE3X27Nl/9e+4uLhIkpyd892D/QAAAAAAAAAAAACA+0C+KrYnJCRIknx8fLJ9PWN7fHz8Pf8bBw8e1LFjx1SzZk0VKVLknt8HAAAAAAAAAAAAAOC48tWj3VeuXJEkubu7Z/t6xvaUlJR7fv/x48fLyclJr7zySo5+p2jRonJyylf3JFjN09PT6AgOjf43HvvAWPS/8dgHxqL/jcc+MBb9bzz2gbHof+OxD4xF/xuPfWAs+t947ANj0f/GYx8Yi/43HvvAWI7Q/3lSbH/nnXeUmpqa4/b9+vW77dPsueXGjRsaPny4Tp48qZdfflkNGzbM0e9dvnw5T3PlNU9PTyUnJxsdw2HR/8ZjHxiL/jce+8BY9L/x2AfGov+Nxz4wFv1vPPaBseh/47EPjEX/G499YCz633jsA2PR/8ZjHxjLHvo/JzcL5EmxfeXKlbp27VqO23fo0EE+Pj7y8PCQdPsn1zO23+7J99u5efOmhg0bpl27dumFF17Q0KFDrfp9AAAAAAAAAAAAAAD+KU+K7fv27bun3/P29pZ0+zXZM7Zb8xT8jRs3NGzYMG3fvl2DBw/W6NGj7ykbAAAAAAAAAAAAAAAZ8tVi5D4+PipVqpRiY2OzPBl/7do1xcbGqkKFCipbtmyO3u+fhfaBAwfmeJ12AAAAAAAAAAAAAADuJF8V200mkwIDA3Xt2jXNnz8/02vz58/XtWvX1KtXr0zbr1+/rhMnTigpKSnT9oyp47dv367nnntO48ePz/P8AAAAAAAAAAAAAADHkCfTyP8bgwcP1pYtW7Rw4ULFxcWpevXqOnz4sKKjo1WzZk31798/U/uDBw+qX79+8vPz02effWbZPnnyZG3fvl1eXl4qXLiwPvzwwyz/Vo8ePVShQoU8/28CAAAAAAAAAAAAANiXfFdsd3NzU0hIiD788ENt3LhRu3btkpeXlwYOHKjhw4erUKFCOXqfM2fOSJIuXLig4ODgbNv4+flRbAcAAAAAAAAAAAAAWC3fFdslycPDQ6+++qpeffXVu7Zt2LCh/vvf/2bZ/s+n3AEAAAAAAAAAAAAAyE35as12AAAAAAAAAAAAAADuBxTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsBLFdgAAAAAAAAAAAAAArESxHQAAAAAAAAAAAAAAK1FsBwAAAAAAAAAAAADAShTbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACtRbAcAAAAAAAAAAAAAwEoU2wEAAAAAAAAAAAAAsJLJbDabjQ4BAAAAAAAAAAAAAMD9hCfbAQAAAAAAAAAAAACwEsV2AAAAAAAAAAAAAACsRLEdAAAAAAAAAAAAAAArUWwHAAAAAAAAAAAAAMBKFNsBAAAAAAAAAAAAALASxXYAAAAAAAAAAAAAAKxEsR0AAAAAAAAAAAAAACs5Gx0AuB8lJSX96/coUqSI3N3dcyENYHtt2rT51+/Rv39/9evXLxfSOKaJEyf+6/do27ZtruxLR0T/AzAax6PG2r17979+j/Lly6tcuXK5kAawvdw4ju/Zs6e6d+/+78M4KMYBYwUHB//r92jYsKEaNGiQC2kcU0RExL9+D19fX/n6+v77MA6IccB4jAPG4tqo8RiLjcVnIDOK7fepatWq/ev3GD58uIKCgnIhjeNp3bq1TCbTv3oP+v/f4TNgrDNnzsjDw0MeHh739Ptnz57VH3/8kcupHMuqVav+1e+bTCaVL1+eYu89ov+NxzhgLPrfeByPGqtv3770v8H4HjJWTEzMv/p9k8kkPz+/XErjmBgHjBUcHCyTySSz2XxPv5+x77jAf+8mTJhwz58Bs9ksk8mk4cOHU2y/R4wDxmMcMBbXRo3HWGwsPgOZUWy/T5nNZpUrV07ly5e/p9/PjScxHN0jjzxyTxd4zGZzrtx96+j4DBivf//+93xAzsls7rjXu//MZrPatm2bB4kcC/1vLMYBY9H/+QPHo8Zq0KDBPV0kNpvNmjdvXh4kcix8DxkvKCiI8wGDMQ4Yq3v37urRo4fVv2c2m9W/f/88SOR42rRpc083MJvNZr366qt5kMixMA4Yj3HAWFwbNR5jsbH4DPyNYvt9rGfPnvwhG6ht27b33P8czOQOPgNwdB4eHvd8gRn/Hv1vPMYBY9H/xuN41Fh+fn733P8U23MH30NwdIwDxipfvjxP5hrM19f3nooskii2wy4wDsDRMRYjv6DYDtyDkiVLqnDhwob9PmC0yMhIeXp6Gvb7kKZMmaJHH33UsN93dPQ/AKNxPGqs2rVrq0yZMob9PmC0hQsXytvb27DfB+OA0YYMGaLHHnvMsN+H1LlzZz388MOG/b6jYxwwHuOAsbg2ajzGYmPxGcjMZL7XBQ1gqNTUVBUoUEAFChQw5PcBo/EZAADHxjhgLPofgNH4HgIAAAAA5AcU2wEAAAAAAAAAAAAAsJKT0QEAe3bkyBGdP3/e6BhAnlizZo0uXLhgdAz8Q2JioqKiohQZGan169crJiZGKSkpRsdyaEFBQfriiy+MjgEAAJDr9u7dq9TUVKNjAADuE7///ruSkpKMjgHkGq6N3h9mzJih9evXGx0Ddo4n2x1ISkqK/vjjD5UrV87oKA6jWrVqCgwM1NSpU42OAkmxsbE6ffq0unfvbnQUu+Dr6ytnZ2e1aNFCAQEBatGihZycuIfL1tLS0rR06VKtWLEi25NWJycnNWvWTKNGjZKvr68BCR2br6+vAgMDNW3aNKOjQIwDeeHmzZv69ttvlZycrIYNG6patWqSpKSkJC1YsECHDx9WwYIF1ahRIz333HPy8PAwOLF9ef3119WsWTO1adNGzs7ORsfB/zObzdqyZYv27t2r69evq3z58urYsaMqVqxodDSHcunSJR08eFDXrl1ThQoVVLNmTZlMJqNj2RVfX18VLVpU3bp105NPPqlHHnnE6EgOh3Hg/vLuu+9q06ZN2rx5s9FR7Eb79u3VrFkzBQQEWI5DkX9NnDhRq1ev1uHDh42OYndOnDihhIQEVa1a1XLMmZ6ertDQUMXExMjZ2VktW7ZU586dDU5qX7g2en/g2lzeunTpkubNm2f5rvH399egQYNUrFixLG2Dg4M1f/58uxwHKLbf506dOqV333030x/ySy+9JB8fnyxtg4ODNW/ePMXFxdk+qB26ePHiXds0bdpUXbt21YQJEyzbSpQokZexcAcTJ05UREQEn4Fc4uvrK5PJJLPZLJPJJC8vL/Xo0UMBAQFcTLaRmzdvauDAgYqNjZXZbFbRokV1+fJlSVKVKlVUsWJFHTt2TGfOnJGzs7OmT5+ubt26GZzafkyZMuWubVasWKEqVaqoQYMGkiSTyaTJkyfncTLcDuNA7kpJSdHTTz+t48ePy2w2y8nJSdOmTVPjxo0VGBiY6VjJZDLJx8dHoaGhFNxzUcZYXKxYMXXv3l0BAQGqUqWK0bEcxsSJE9W2bVu1adPGsu3SpUsaOnSofvrpJ/3zVNvFxUWTJk1Sr169jIhqtyIiIuTr65vphkKz2az33ntPn332mf7880/Ldh8fH73//vt69NFHjYhql/7Z7yaTSTVr1lRgYKA6d+6swoULG5jMcTAO3F84Fs19GZ8B6e8HXrp27Sp3d3eDkyE7fAbyxhtvvKGwsDBJf43Hw4cP1/DhwzVixAht2rTJ0s5kMqlTp06aNWuWUVHtDtdGjbdw4cK7tpk5c6Zq1aqldu3aWbYNGTIkL2M5jCtXrujJJ59UYmJipvPfkiVLavbs2ZbroRnsuUZJsf0+dv78efXo0UOXLl1SoUKF5OzsrJSUFLm6umratGl6/PHHM7W35z9kI9zLHbMmk8ku79q5X3BQn7t8fX01dOhQVa9eXWFhYdq+fbvS09NlMpnk5+enwMBAtW/fXgULFjQ6qt36z3/+o/nz5+vZZ5/VqFGj5OHhoZSUFM2ZM0ehoaFaunSp6tWrp7179+r1119XYmKiwsPDecI9l/zzpOp2/vd1k8nEd5CBGAdy14IFCzRnzhy1adNGLVu21Pfff6/du3erbdu2ioqK0ptvvqmGDRsqOTlZc+fO1TfffKMhQ4ZozJgxRke3G76+vipdurQuXryoW7duyWQyqU6dOgoMDFSnTp3k6upqdES75uvrq6CgIAUFBVm2DRkyRFFRUWrQoIF69eolT09P7d+/X4sXL1ZqaqpWrFihmjVrGpjavmS3D9555x0tXbpUxYsXV5s2bSz7ICYmRkWLFtWaNWtUunRpA1PbD19fX/Xp00fly5dXWFiYTp48KZPJpEKFCqlTp04KCAhQvXr1jI5p1xgH7i8ci+Y+X19f1atXT1euXNGxY8cs30EdOnTQk08+meUiP4zFZyD3bdq0SSNGjFCVKlXUrFkz7dy5U0ePHtW4ceM0a9YsjRo1Sk2bNtX58+c1e/Zs/fe//9Xs2bPVsWNHo6PbBa6NGo9rc8b64IMPtGjRIj399NMaNmyYnJ2dFR4ervnz5ys9PV3/+c9/1KJFC0t7e65RMsfUfWzBggW6dOmSxo4dq4EDB8pkMmn9+vWaPn26xo0bp+vXryswMNDomHbLbDbLzc1NNWrUuG2b3bt3q2TJkqpcubINkzkOa9d5unr1ah4lcVzOzs5q37692rdvr/Pnzys8PFxff/21du3apZiYGE2bNk1du3ZVQEAABd48sG7dOtWpU0eTJk2ybHN3d9frr7+uQ4cOac6cOVq+fLkee+wxLV26VJ07d9bChQs1c+ZMA1PbD1dXV5lMpttO0W82m9W/f3+1bNlSAwcONCCh/WMcMNb69etVrVo1zZs3T5IUGBiobt26KSIiQrNmzbI87evu7q733ntPR44c0ZYtWyi257LAwEA9/fTT+vrrrxUeHq59+/Zp//79mj59urp06aKAgADVqlXL6JgO4ejRo4qKilKLFi20YMECy5N2/v7+atKkiZ599lktX75c77//vsFJ7df58+cVEhKiKlWqaNmyZSpZsqTltWXLlmnGjBlaunSpxo8fb2BK+1KsWDE999xzeu6557Rv3z6FhYXp22+/1ddff61Vq1apSpUqCggI0BNPPKHixYsbHdcuMQ4YZ+LEiVa137t3bx4lcWxNmjRRUFCQDh48qLCwMEVGRioiIkKrV6+Wt7e3AgIC1KNHD2aazAP/nN0nJ5KTk/MoieP6/PPPVbJkSYWFhcnNzU03b95Ux44dNWvWLI0YMUKDBg2S9FdBsnbt2mrVqpUiIiIotuciro0ay2QyydXVVS+88IJKlSqV5XWz2axXX31VDRo0UM+ePQ1IaN+2bNmi6tWrZ5rFc8iQIfL399fzzz+vESNGaO7cuWrVqpWBKW2DYvt9LOOJicGDB1u2de7cWXXr1tXzzz+vyZMn688//1Tv3r0NTGm/nnrqKa1cuVIlSpTQG2+8ke2FA19fX7Vq1Yr1QPJI69atWXcxHyldurRlqqqdO3cqPDxcmzdvVkhIiD7//HPVqFFDgYGBeuqpp4yOajeSkpLUunXrbF+rW7euVqxYYfm5dOnSatOmjXbu3GmreHZvzZo1mjBhgt577z0NHTpUQ4cOzXatTC8vL/n5+RmQ0P4xDhgrKSlJTz75ZKZtjRo10tGjR9WkSZNM252cnNSoUSPL9IbIXSVKlNCQIUM0ZMgQ7dmzR+Hh4dqwYYNCQ0MVFhamqlWrKiAgQN26dVPRokWNjmu3YmNjZTKZNGzYsCzfTfXq1VPTpk0ptOSxH3/8UX/++afGjBmTqdAuSf3799fq1av1ww8/UGzPI3Xr1lXdunX1+uuva926dfrqq6+0f/9+vfvuu5o5c6Zat26twMBA+fv7Gx3V7jAOGGPVqlV3fZruf3Hsmndq1aqlWrVq6dVXX9X69esVHh6u2NhYzZw5U3PmzFHLli0VGBio5s2bsx9yyZkzZ+Tk5JTteXB2bt26lceJHM+pU6fUqlUrubm5SZIeeOABNW/eXKGhoVlmvS1WrJhatmyp3bt3GxHVIXBt1Pa++OILTZgwQYsXL9bEiRPVo0ePLG1effVV+fj4ZPsa/p0zZ87o2WefzbK9WrVq+uKLL9SvXz+99NJLllkR7RnF9vvY+fPn1aFDhyzby5Ytq88++0z9+/fXm2++qfT0dD3zzDMGJLRvb775ptq3b6/XXntNXbp00aRJk9S5c2ejYzkUk8mkokWL5njdxaNHj+rChQt5nAqS1LhxYzVu3Fh//PGHVq9erfDwcB06dEg///wzB5S5qHDhwvrtt9+yfe23336Tk5NTpm1ly5bV77//boNkjqFixYoKCQnRp59+qrlz52rz5s2aMWPGPS0zgnvDOGCse7lIyQpWea9+/fqqX7++pdgVFhamQ4cOacaMGfrggw/Url07ZjjJI5cvX5YkVa1aNdvXq1atql27dtkyksM5f/68JKlOnTrZvl67dm1FRETYLpCDcnNzU2BgoAIDA3XixAmFhYVpzZo12rBhgzZu3GiX00bmJ4wDtuPu7q7SpUvr7bffzlH7+fPn64cffsjjVHB1dVXPnj3Vs2dPnTp1yvIdtHnzZm3ZskWlS5fW1q1bjY5pF0qVKqVixYppzZo1OWo/YcIErV69Oo9TOZZLly5leQAsYxaHsmXLZmlfrlw5rgvZCNdGbaNu3bpavXq13n//fcvNVtOmTWPZKBtxdXW97XWeihUravny5erXr59GjRql2bNn2zidbVFsv495eHgoNTU129eKFSumZcuWqX///po2bRoXNvNI06ZN9c033+itt97S6NGj9e2332ry5MlMTWUjPj4+Sk1N1aJFi3LUPmNtKNhOkSJF1LdvX/Xt21eHDh3SV199ZXQku1K3bl1t3LhRAwcOzFTgjYuL04YNG1S3bt1M7S9evMiTLLnMZDJp4MCBatGihSZMmKDAwEANHjxYw4cPl4uLi9Hx7B7jgLEqVKigmJiYTNtiYmJkMpm0c+fOTFMTms1m7dq1K9sLPsgb7u7ueuqpp/TUU0/p6NGjlgvNkZGRFFnyiKenpyQpLS0t29fT0tIYG/LYAw88IEmWp7v+l6urq9LT020ZyeFVqVJFEyZM0NixY7VlyxbOB2yIcSDvVa9eXT/99JNq1aqVo5sQWUrB9ipXrqxx48ZpzJgx+v777xUeHq6oqCijY9mNGjVqKCoqSqmpqTlak5oZBXJfkSJFLDd8ZsiYcSO7/r5586YKFSpkq3gQ10ZtoVChQpo0aZLatWunV199VY8//rjGjRvHEss2UL58eR0+fPi2r/9vwT2nD8vcj5zu3gT5VcWKFXXw4MHbvp5RcH/44Yf11ltvaf369TZM5zjc3d31zjvvaP78+YqNjVXnzp21du1ao2M5hOrVqyspKUl//PGH0VGQA48++mim9Vvw7w0dOlR//vmnevXqpdGjR2vmzJl6+eWX1atXL6WlpWVaZkT6a43ARx55xKC09q1KlSpauXKlhg0bpkWLFqlnz553HKOROxgHjNW1a1cdPnxYL730ksLCwvTSSy/pyJEjGjRokN566y1t3bpV165d0y+//KJXX31Vx48fV7NmzYyO7ZAefvhhvfbaa4qOjtasWbOMjmNXVq1apX79+qlfv3768ssvJUnx8fHZtj137hw35eaBmJgYBQcHKzg4WD/99JOkv6YzzM758+dVrFgxG6ZDBmdnZ3Xo0EGffPKJ0VEcEuNA3qhRo4Zu3LihkydPGh0Fd1GgQAG1bdtWCxYs0Pfff290HLtRvXp13bp1S0eOHMlRe7PZzANhuax8+fJKTEzMtO3ZZ5+97bXppKQkeXl52SIassG10bzVqFEjrV27Vu3bt9ekSZM0aNAgJSUlGR3Lrvn5+Sk2Nva2M69Kfxfcvby8tH//ftuFszGK7fexxo0b6+DBg1kG1H/KKLg/8sgjOnHihA3TOZ7WrVvrm2++UePGjTVu3DgNHTqUOzbzWI0aNWQ2m/Xzzz/nqH2xYsV4oi4XNWjQQBUqVDA6hkOrXbu2Zs2aJXd3d0VGRmrhwoVav369HnjgAU2bNi1TUSslJUVPPPGEhgwZYmBi++bk5KRhw4YpPDxcTk5OevrppxkH8hjjgLGeeeYZ1apVSxs3btQbb7yhjRs3qm3btho9erRq1qypF198UY899pjatWunVatWqWTJknrhhReMju3QXFxc1KlTJ6Nj2JUzZ84oJiZGMTExiouLk9ls1oYNG7K0u3XrFje95ZF/Ftu/+eYbmc3m2xZSDh06pMqVK9s4of0qV66cihQpYnQMWIFxIHe1adNG3bt3140bN3LUPiAgIMdTziPvlCpVyugIdqN79+6aMWNGjmdtGD9+vLZs2ZLHqRzLo48+qgMHDmS6iaF48eLZLmt069YtxcbGqnbt2raMaNe4Npr/FC5cWNOnT9fHH3+sY8eO6fHHH+faXB5q166dihUrdtdZJDMK7uXKlbNNMAOYzNxOdt86cuSIJk+erCeeeELPPvvsHdtevnxZQUFBOnPmjL777jsbJXRckZGRmjp1qn7//XcFBgZq2rRpRkeySzdu3NDFixfl6el526kiAUdw8+ZNy12Enp6eqlevHp8Jg6Wlpenjjz9WXFycmjZtqmeeecboSHaJccB4t27d0qZNm5SYmKiHH35YLVu2lPTXvvnoo48UFRWltLQ01atXT0OHDuVmh1wWHByshg0bqkGDBkZHwV0cPXpUn376qdq0aaO2bdsaHcdu/O9SFhmKFy+uhx56KNO2n3/+WSNGjNAzzzyTZfYf4H7FOABHFxMTo/Lly6t8+fJGRwEMcfHiRZ09e1bVqlVTgQIF7tj2yJEjWrZsmbp166ZGjRrZKCFgnD/++EMzZsxQXFyc2rdvr2HDhhkdCXaMYjuQRy5fvqyzZ8+qWLFiKlOmjNFxAAAAAAAAAAAAAOQiiu0AgFxx/vx5xcfH68qVK5IkDw8P+fj4qHTp0gYnc1wpKSm6ceOGihcvLicnVo4BAABA3jGbzTpz5oxSUlIkSe7u7ipXrhzHoQAMlZKSooIFC6pgwYJGR7F7jAMAgP918+ZNOTk5ycXFxegoeYpi+33s/PnzFLEAGCo1NVVLly5VeHi4EhMTs21ToUIF9erVS/379+fkNpedP39eZ86cUZ06dTKdvK5YsUKffvqpTp8+LUlydXVV+/bt9corr6hEiRJGxbVbaWlpOnr0qAoUKKBHHnnktmtBHTlyREeOHFH37t1tGxDIY2lpabp27ZqKFi2aafu+fft0+PBhFSxYUH5+fvL29jYooeNJTU3Vhg0bdOjQId24cUPly5dXhw4d2AcG6NGjh9q1a8eUhbBrkZGRCg0NVWxsrNLS0jK95uLioscee0yBgYHq3LmzQQnt39mzZ5WcnKyHHnrIcs5lNpu1bt06y1jcsGFDNW7c2OCk9uXatWu6cuVKlmtzUVFR+vTTTzONw507d9aQIUNUqFAhg9I6rmrVqikwMFBTp041OordYhzIv5KTk3Xo0CE5Ozurbt26fAfZyLlz57R48WLFxsbq+vXrKl++vLp27aonnnjC6Gh2h7HYeBcvXtSSJUt0+vRpPfzwwxowYIA8PDx09OhRTZo0ST/99JNMJpMaN26sN954Q5UqVTI6cp6g2H4f8/X1VdWqVRUQEKAnnnhCnp6eRkdyODdv3tTnn3+umJgYOTs7y9/fX08++WS2d+ksW7ZMy5cv15YtWwxI6lh+/vlnzZs3L8sBzaBBgyj25qJr165pwIABOnjwoNzc3FSvXj35+PiocOHCkqSrV68qPj7esh9q1aqlTz/9lHWVc9GYMWO0b98+fffdd5Zt7733nj799FOZTCZVrFhRHh4eOn36tP744w9VqFBBoaGhKl68uIGp7cv69es1ZcoU/fHHH5KkUqVKaezYseratWuWtsHBwZo3b57i4uJsHRP/b+LEiVq9erUOHz5sdBS7MW/ePC1atEg3btxQtWrVNGfOHFWoUEFjxozRt99+a2lnMpn03HPP6ZVXXjEwrf358ssvtXXrVn300UeWm66OHj2qF198UUlJSfrnqV6BAgU0atQoDRkyxKi4DsnX11eBgYGaNm2a0VHs2k8//aQ9e/aoQIECatKkSZb12jNs3rxZW7Zs0YwZM2yc0D7dunVLI0eO1HfffSez2azKlSvL29tb7u7ukv56mjQhIUGnTp2SyWRS69atNXfuXDk7Oxuc3H6kp6fr9ddf16pVqyRJXl5eCg4O1iOPPKIBAwZo//79lrHAZDKpQ4cOmj179m1vDoV1Jk6cqKioKEVHR1u2LV26VO+++67MZrMKFiyowoULKzk5WSaTSTVq1NBnn30mV1dXA1M7HsbivMM4kD/s2rVLH3zwgaXQNXHiRFWvXl3r1q3TpEmTdP36dUlSkSJF9Pbbb6tNmzYGJ7Yfbdq0Uf/+/dWvXz/LtkOHDmnQoEG6fPmypL/GX7PZLJPJpCeeeELvvvuuUXHtEmOxsS5fvqwePXro7NmzlmPOGjVqaOHCherRo4eSk5NVpUoVXbhwQb/99pvKlCmjNWvWqEiRIgYnz32MbPe5Y8eO6Z133tHMmTPVpk0bBQYGqkmTJkbHcgipqanq27evfvrpJ8sXyZYtW/T5559rzpw5qlKlSqb2V65cUVJSkhFR7Va1atUUFBSk4cOHW7ZFR0dr2LBhSk1N1QMPPCAPDw+dPHlS//nPf7R7924tXryYCwu5JDg4WAcPHtSQIUM0bNiw2x6kXL9+3VKMmTdvHoWWXLR//375+flZfj59+rSWLl2qBx98UHPmzFHVqlUl/XUC/PHHH+vDDz/U/Pnz9frrrxsV2a4cPHhQY8aMkZOTk5o0aSIXFxft2LFD48aN0549e/Tmm28aHRHZ4D7T3PPdd9/pww8/VOHChVWnTh0dPXpUo0aNUs+ePbV+/Xq1bdtWDRs21MWLF7Vy5UotWbJE1atXV5cuXYyObjdWr14tNzc3S6E9LS1Nw4cPV1JSkjp27KjWrVurSJEiOnbsmJYvX65Zs2bpwQcf5AJbLsnpjQvR0dGWtiaTSZ988klexnI4b731lj7//HNJf33HOzk56cknn9Srr76a5fj0yJEjioiIoNieSxYtWqQtW7aoS5cuGjNmjMqVK5dtu6SkJM2cOVORkZFavHixXnjhBRsntV9r167V119/rXLlyqlevXqKjY3V2LFj1a1bNx08eFD9+vWzjMVLlizRhg0b9OWXX+qZZ54xOrpdiI2NVcOGDS0/nz9/XjNnzpSXl5feeustNWvWTCaTSZcuXdKsWbMUHh6ujz/+WKNGjTIutJ2pXbv2XduYTCatWrVKa9assfy8f//+PE7mGBgHjBcfH68hQ4YoNTVVRYsW1e7duzVkyBAtXLhQEydO1IMPPqiGDRvq/Pnz2rx5s0aNGqXVq1frwQcfNDq6XThz5ozl4Qvpr2PRsWPHKiUlRcOGDdNTTz0lT09PHThwQG+++abWrFmjVq1aqWPHjgamti+Mxcb67LPPlJSUpBdffFEdO3bU1q1bNXv2bI0bN04eHh5auXKlypQpI0n68MMPNW/ePC1fvlxBQUEGJ899FNvvc0888YSKFCmitWvXav369fr2229VtmxZPfnkk3ryySctf8jIfZ9++qkOHjyoVq1a6YUXXpCzs7PCw8MVGhqqZ599VosXL1aNGjWMjmnXzGZzpqJJWlqaJk6cqAIFCmj69Onq0aOHnJyclJSUpAkTJmjnzp0KDw9XYGCggantx7fffit/f3+NGTPmju1cXV01duxYxcXFaf369RTbc9GFCxdUqlQpy887duyQ2WzW1KlTLYV2SXJ2dtbw4cO1e/dufffddxTbc8miRYvk5OSkZcuW6bHHHpP010WEcePGKTQ0VDdv3tSMGTO4wQd2KyQkREWKFNHq1atVtmxZJSUlqXv37po3b56ee+45jR8/3tL2qaeeUpcuXbRy5UqK7bno1KlTmWbSiIqKUmJiooYPH64RI0ZYtrdo0ULdunVT9+7dtXTpUortuSQqKsrypMrtmEwmnT17VmfPnrX8jNyzbt06hYSEqFy5curdu7ecnZ21atUqhYWF6fDhw1qyZEmWJS6QeyIiIlSnTh3NnDnzju3KlSunmTNn6pdfftGqVasosuSilStXysvLS2vWrJG7u7v++OMPde7cWYsWLcoym0mHDh3UsWNHRUREUGzPJefPn1f79u0tP0dHR+vWrVuaNm2amjdvbtlevHhxvfXWWzp69KjWr1/PBf5cdPPmTRUqVOiOs7clJSWpYMGCKlasmO2COQjGAeMtXLhQ6enpWrp0qRo1aqR9+/apf//+evnll9WkSRPNmzdPBQoUkPTXseuQIUO0fPlyTZkyxdjgdmr37t2Kj49X//799dJLL1m2N2jQQIsXL1bHjh311VdfUWzPRYzFxtq0aZPq1KmjkSNHSpIeeeQRRUdHa/v27froo48y1SdHjBihyMhIff/99xTbkf9UqlRJQUFBGjdunDZs2KDw8HDFxMQoODhY8+fPV9OmTRUYGKhWrVoxRU8ui4yMlI+Pj4KDgy0HLY8++qhatWqll19+WQMHDtSiRYtUs2ZNg5M6jp07d+rChQsaOXKknnzyScv2cuXKKTg4WO3bt9eaNWsotueSCxcu6PHHH89x+xo1aigmJiYPEzkeV1dXXb161fJzxt201atXz7Z9tWrVtHfvXptkcwSxsbFq06aNpdAu/fV9s3TpUo0fP14RERH6888/9d5771FcySP/nKotJ06ePJlHSRzT8ePH1a5dO5UtW1bSX3//bdu21apVq/Tss89malu2bFm1a9dO33//vRFR7db169cty7dIf/2Nm0wmPfXUU1naenl5qU2bNvrmm29sGdGueXl56erVqxo7dqxatGiR5XWz2ay2bduqS5cuGj16tAEJ7d+KFStUtGhRhYeHWwotAwYM0Jw5c/TJJ5+of//++vTTT1lyLY8kJSVlurh5N35+flq2bFkeJnI8CQkJat++vWXK5iJFiqhNmzYKDQ3Nsi5skSJF1Lp1a61fv96IqHbJxcVFqamplp8vXrwo6a+iSnYee+wxhYSE2CSbo2jWrJm2b9+uTp06aeTIkdkuHejr66suXbowjXweYBwwXmxsrJo1a6ZGjRpJkurWrauWLVtq06ZN+uCDDyzXrKW/Pi/169fXrl27jIpr9+Li4m57Pla6dGm1bNmS/s9ljMXGSkpKUo8ePTJte/TRR7Vnzx7VqVMnS/v69evb7bEo1Vc7UbBgQXXt2lVdu3bVL7/8ovDwcEVEROiHH35QVFSUihcvrm7duikgIIBpYnJJQkKCAgICMh20SH89ObR06VINGjRIgwYN0qJFi1SrVi2DUjqWjAvM2RWAixQpombNmumHH34wIJl98vLysmrt6Z9//lleXl55mMjxVK9eXdHR0Za1n3x8fCT99VnIbmaNU6dOcTd/Lvr9998tff5Pzs7O+uCDD+Ti4qKIiAilp6fr/ffft31ABxATE3PXp0r/Fzc+5J7Lly+rRIkSmbaVLFlSkrL9vvfy8tK1a9dsks1RlC1bVidOnLD8XKhQIUm67U22zs7OLKWQi9atW6c333xT06ZN008//aTXXnvNUvD6Jzc3N5UvX96AhPbvyJEj6tChQ6YnGp2cnDR69GiVLVtWU6dOVf/+/bVs2TIK7nmgSJEiSkhIyHH7hIQEu1yf0UjXrl3L8r3j4eEhSdn2dZEiRXTz5k2bZHMEVatWzVQ0yXh669y5c9leezt37ly24wTu3cKFCxUaGqp3331X33//vd5+++1sL+4jbzAOGO/s2bNZZq3KuE7x0EMPZWn/yCOP6KuvvrJFNId048YNSVKFChWyfb1ChQratGmTLSPZPcZiY926dUsPPPBApm0ZDwRkdw3a09PT8jmxN05GB0Duq1ChgkaNGqXvv/9eH3/8sdq2bavLly9ryZIlVj2FijtzdnbO8kWSoVatWlqyZInMZrMGDRqkffv22TidY8q4i6106dLZvl62bNlMTwHj32nXrp2io6M1e/bsOw6SN27c0KxZs7Rjxw6r7njG3T3zzDNKSEjQ9OnTlZ6erpYtW8rb21tTp07Vb7/9lqltWFiYtm3bpmbNmhmU1v54eXnp0qVL2b5mMpk0Y8YMdevWTevWrdPYsWN169YtGye0f56enqpataqio6Nz9H+dOnUyOrJdKVOmjOLj4zNty/j51KlTWdqfPHmSi2u5rEWLFtq6dauOHTsmSWrSpIlMJpNlTdJ/unLlir7//vtsL7rh3hQpUkQzZ87UnDlztG3bNnXq1InZG2wsNTU1y00/GZ5++mlNnTpVx44dU79+/W47ZuPeNW/eXJs2bVJoaOhd265YsUKbN29Wy5Yt8z6YAylXrpz++9//ZtqW8fORI0eytI+Li7vjdNuwTs+ePXXkyBEtXrxYktSmTRuVLFlS7777bpabGnbs2KFNmzbJz8/PiKh2rVevXlq9erVKliypZ599Ntv+R95gHDCei4tLlmsNGTM8uLq6Zmnv6uqq9PR0m2RzFP+8oT/jBtvLly9n2/by5cuZZibDv8dYbCxPT88s16BLlSp121lXf/vtN7td5osn2+2YyWRSixYt1KJFC126dEkRERHcuZaLypUrp6NHj9729Zo1a2rJkiUaOHCgBg8enGmaYeSelJQUJSUlSfr7rqnk5ORsC+6XLl2y3OWPf2/EiBHatWuXPv74Y4WEhKhevXry9va29PGVK1eUkJCg2NhYXb16Vb6+vna5HouR2rVrp169eikkJERRUVFq3bq12rRpo6VLl6pdu3Z69NFH5eHhoRMnTuj06dMqUaKEZQ0d/HsPPvjgHZdGMJlMeueddyRJq1ev5oQqD1SvXl27d++Wp6dnlplmspPx1C9yR7169bR27Vp9//33atasmbZt26bvvvtOjz76qD744APNmzfPcmPi9u3btXXr1kxrpuHfGzp0qNauXasBAwZo7NixateunUaMGKGZM2fq3LlzatWqlYoUKaLjx4/rk08+0blz5xgH8kCHDh3UoEEDTZ48WcOGDdPjjz+u119/3W4vIuQnZcqUUWJi4m1fDwwMlNls1uTJk9W/f3/OyXLZyy+/rB07dmjy5MlatGiRmjRpIh8fH8vTQikpKYqPj9eOHTuUmJioMmXKsD5mLmvcuLG++OILhYSEqHnz5tq2bZu2b9+uZs2a6e2339bHH39sKa6HhYVp586d3HyYi5588klt3rxZH3zwgbZu3aqOHTvq6aef1rx589SuXTs1adLEcj62c+dOFSpUKNMavsg9FSpU0PLly7V8+XLNnj1b3333naZPn6769esbHc2uMQ4Yr2TJkvr1118zbatbt64GDBiQbftz585x01UuCw4OVnBwcKZthw8fznaZqTNnzqhUqVK2iuYQGIuNVbVq1Swz3/bq1Uu9evXKtn1CQoIqVqxoi2g2ZzIzj+B9K6NwRfHKGJMnT1ZERISio6PvWMD96aefNGjQIF25ckWSrJp2G3fm6+ub7XTAc+bMUYcOHbJs79u3r1JSUrRq1SpbxHMI169f18KFCxUeHp7l4D5DqVKlFBgYqMGDB2d7Vy3+vWXLlmn+/Pm6fPnybafUbtq0qaZMmWK3BzRGWLp0qd555x2FhITc8SKO2WzWxIkTFRERIZPJxDiQi2bNmqWFCxfq66+/VrVq1e7afsKECVq9ejX7IJckJCSoW7duunnzpuW7p2TJklq5cqWeeuopFShQQLVq1VJycrJiY2OVnp6uJUuWqHHjxkZHtytxcXEaNmyYzp07J5PJpOLFiys5OTnLEytms1nPPfecxo8fb1BSx7B69Wq9/fbbcnFx0RtvvKGXXnpJgYGBrBObR0aNGqVdu3YpKirqtssnSFJoaKgmT55s+ZlxIPf89ttvev/997V+/XrLTGMZ52gZx6QuLi7q0qWLxowZw7JSuezXX3/VE088kekJOh8fH61YsUK9e/e2TKGanJyss2fPqkCBAlqxYoUeffRRA1Pbl9TUVH3wwQf64osv9Oeff0r6+2//n+dmVapU0YwZM1hm0Abi4+M1YcIEHTx4UM8884xCQkIYi/MQ44CxRo8erQMHDmjLli05at+1a1eVKlXK8hQw/p2+fftmu71t27bq379/pm2XL19W8+bN1alTJ8uDGcgdjMXGWb58ub766iuFhYVZZtW4nfPnz6tNmzZ67rnnNGbMGBsltB2K7fcxiu3G2rZtm1544QW9/PLLeuGFF+7Y9tChQxo4cKCuXLnChZ1cNHHixGy3N2jQQD179sy0LePLvGfPnpo6daot4jmc+Ph4JSQkWG4s8fDwkLe3d7ZrWiP33bx5U9HR0fr555918eJFmc1mubu7q3LlymrUqBFF9jxw/vx5hYSEqHbt2mrbtu0d25rNZgUHByspKUkzZsywUUL7d+TIEW3evFmdOnVSlSpV7tr+5MmT+u2335gyLBcdOHBAwcHB+uWXX1S1alWNGjVKDz74oA4ePKiXX35ZZ86ckSS5u7tr3Lhxt727Gf9OSkqKvvjiC0VGRurYsWOWCwzSX8vrNGrUSL1791bdunUNTOk4zp8/r9dff11RUVGSxAX+PLR69WqNHz9e77//vrp27XrHtmFhYXrjjTckUWzPC1evXtX+/fsVHx+vlJQUSX999/v4+Kh27dqsjZmHEhMTtXjxYstYPHjwYJUoUUKnT5/W+PHjLcvaVa5cWRMnTmSWmTxy/vx5ffvttzp8+HC252N+fn5ycmI1T1sxm81auHChgoODlZqaylhsA4wDxvjhhx/0ww8/aNy4cXctdB06dEgBAQEaPXq0nn/+eRslRIZffvlFu3fvVvXq1fXII48YHccuMRbnbxcuXNCpU6f04IMPqmTJkkbHyXUU24F/ITU1VU5OTnd8iiLD5cuXlZKSYlm7Bbb122+/6eTJk6pUqZLKlCljdBwAAOzerVu3dPLkSaWlpalq1ap3vfiD3JGWlqbLly8rPT1dHh4ezCpjoFWrVikuLk516tRR586djY5jl65fv649e/bIy8tLvr6+d23/448/6uzZs+rRo4cN0gH5w9WrV5WWlqZixYoZHQWwufj4eB0/flwVKlTI0TgBAABwLyi2AwAAAAAAAAAAAABgpbs/jgvgni1fvlxVq1ZlbVLYtW3btun06dOqWrWqGjVqJOmvpycWLFigmJgYOTs7q0WLFhowYABPNQIAAAAOavPmzTpy5AhL4eUhs9msM2fOZJrCuVy5ckyZamOpqanasGGDDh06pBs3bqh8+fLq0KGDvL29jY7mkIKCgtSkSRM988wzRkexa7///rucnZ3vOF18UlKSzpw5owYNGtgwGZD3UlJSdObMGVWsWFFubm6W7VFRUZZro82bN2dZrzywd+9e1axZk2vO9wl7Ph/gyfb72HPPPadmzZqpe/fuKl68uNFxkA1fX1/WhbKBEydOKCEhQVWrVrWsS52enq7Q0FDLAU3Lli2ZvjOX3bp1S0OHDtX27dtlNptlMpn05JNPaurUqerTp49iY2MtbU0mk+rXr69ly5ZxoSeXXbp0SfPmzbP8rfv7+2vQoEHZThMZHBys+fPn6/Dhw7YP6uASExM1YMAAmUwmbd682eg4dictLU1Hjx5VgQIF9Mgjj8hkMmXb7siRIzpy5Ii6d+9u24CQ9Nd6ybGxsZoxY4bRURzWJ598oujoaC1fvtzoKA6J/jeePV/cuR9MnDhRERERiouLMzqK3YmMjFRoaKhiY2OVlpaW6TUXFxc99thjCgwM5Jw4l3355ZfaunWrPvroI8t57tGjR/Xiiy8qKSlJ/7zkWqBAAY0aNUpDhgwxKq7D4tpc3tqzZ4/efPNNHT9+XJJUq1YtvfLKK6pfv36WtsHBwZo3bx7jQC5q3769mjVrpoCAAFWrVs3oOA7p448/VnBwsG7duqVChQpp0qRJ6tmzp6ZPn66QkBDLWGAymTRo0CCNHTvW4MT2xdfXV0WLFlW3bt305JNP6pFHHjE6Eu7Ans8HeLL9PrZz5079+OOPmjVrllq3bq2AgAA1a9bstheYkbsiIyNz1C4xMTFTW05uc9cbb7yhsLAwSX8dtAwfPlzDhw/XyJEjtWnTJku7tWvXavPmzZo1a5ZRUe3OmjVrFB0dLT8/P7Vr104//PCDvvrqKxUtWlTHjx/XnDlz5O/vr/Pnz2vGjBnavn27vvrqKwUGBhod3W5cuXJFvXv3VmJiouXgPS4uTqtWrdLs2bOzvVuce+yMkZaWpjNnzjBG54H169drypQp+uOPPyRJpUqV0tixY9W1a9csbTdv3qx58+ZRbDdIbGysIiIiKLYb6NSpU9q9e7fRMRwW/W+8LVu2KCIigmI77MatW7c0cuRIfffddzKbzapcubK8vb0tT5ampKQoISHBcv1o3bp1mjt3rpyduRyYG1avXi03NzdLoT0tLU3Dhw9XUlKSOnbsqNatW6tIkSI6duyYli9frlmzZunBBx9UmzZtDE5uP6ZMmZKjdrGxsZa2JpNJkydPzrtQDuTkyZMaPHiwbty4IR8fH7m4uOjAgQPq37+/Ro4cqeeff97oiHbv9OnT+uKLL/TFF1+oWrVqCgwMVNeuXe84wwByz86dOzV79myVKFFC9erV0/79+/XGG2/IxcVFISEhevrpp9W0aVOdP39en3zyiRYvXqwmTZqoSZMmRke3K5cvX9by5cv12WefqWbNmpYbDAsXLmx0NDgQjq7vcw899JAuXLigjRs3atOmTSpTpox69uypnj17qnz58kbHs2ujR4++a9HEZDJp165d2rVrl+XJX4rtuWfTpk0KDQ1VlSpV1KxZM+3cuVPBwcFyc3PT1q1b9corr1gOaGbPnq3169erffv26tixo9HR7UJYWJjKly+vpUuXysnJSX369FGXLl306aef6o033rD0s7u7u4KDg9WyZUutW7eOYnsu+vjjj3X69Gk9/fTTGjZsmJydnRUeHq758+dr8ODB+s9//qMWLVoYHROSKlWqpC1bthgdw+4cPHhQY8aMkZOTk5o0aSIXFxft2LFD48aNszxhAQAA8oa1N49cuHAhj5I4rkWLFmnLli3q0qWLxowZo3LlymXbLikpSTNnzlRkZKQWL16sF154wcZJ7dOpU6cy3eAZFRWlxMREDR8+XCNGjLBsb9Gihbp166bu3btr6dKlFNtz0YoVK2Qyme54U7nJZNKJEyd04sQJy88U23PHxx9/rBs3bmjWrFmW650HDx7U+PHjNXv2bF27dk2jRo0yNqQDqFu3rq5cuaLDhw9r6tSpeu+999ShQwc9+eSTTNmfx5YtWyYPDw9FRETIy8tLycnJ6ty5s6ZMmaKBAwfqlVdesbRt0aKFOnbsqJUrV1Jsz2V9+vRR+fLlFRYWpoMHD+qnn37S22+/rU6dOikgIED16tUzOqLd4nzgbxTb73MdOnTQCy+8oE2bNik8PFw//vij5s2bp48++kiNGzdWQECA2rZtKxcXF6Oj2iVXV1f17t0701osGcxms+bNm6fq1aurdevWBqSzf59//rlKliypsLAwubm56ebNm+rYsaNmzZqlESNGaNCgQZL+mk6mdu3aatWqlSIiIii255LExES1a9fOche/yWRS48aNderUKbVq1SpT20KFCql58+aKiooyIqrd2rJli6pXr57pQsGQIUPk7++v559/XiNGjNDcuXOz7A/YnrOzMzfB5YFFixbJyclJy5Yt02OPPSbpr4vJ48aNU2hoqG7evKkZM2Ywo0AeiYiIsKp9QkJC3gRxYMHBwVa1t8ep2oxE/xuPizvG6tu3r1VjbMYN6Mg9ERERqlOnjmbOnHnHduXKldPMmTP1yy+/aNWqVRTbc8n169czPTV38uRJmUwmPfXUU1naenl5qU2bNvrmm29sGdHuubq6ymQyadSoUfL19c3yutlsVv/+/dWyZUsNHDjQgIT2bdeuXWrRokWmB4tq1aqlsLAwDRs2TB9//LHS09M1evRoA1PavyZNmigoKEgHDx5UWFiYIiMjFRERodWrV8vb21sBAQHq0aOHSpQoYXRUu3P06FG1adNGXl5ekiRPT0+1bt1aX3/9tXr16pWpbfny5dW8eXMdOHDAiKh2rVixYnruuef03HPPad++fQoLC9O3336rr7/+WqtWrVKVKlUUEBCgJ554guWYcxnnA3+j2G4HXFxc1LlzZ3Xu3FlJSUn66quv9PXXX2v79u3asWOHZc2KgIAAVa1a1ei4dmPWrFmaOnWqNm7cqOnTp6thw4ZZ2sybN081atRgmsI8klHUzbjZ4YEHHlDz5s0VGhqqxx9/PFPbYsWKqWXLlkzdmYv++OMPFSlSJNO2jHXCS5cunaV96dKldeXKFVtEcxhnzpzRs88+m2V7tWrV9MUXX6hfv3566aWXNGfOHJ6egF2KjY1VmzZtLIV26a+LyUuXLtX48eMVERGhP//8U++9957dHswbacKECZxUGSw4OPiuT3P9L/ZB7qH/jcfFHWMVKFBAxYsXz/HN5bt27eLGq1yWlJSk9u3b57i9n5+fli1bloeJHEvZsmUtT0tLf91kLum20/Q7OzuzrFcuW7NmjSZMmKD33ntPQ4cO1dChQ7Ptfy8vL/n5+RmQ0L799ttv2S7f5e7uroULF+rFF1/UwoULlZ6ezjrVNlCrVi3VqlVLr776qtavX6/w8HDFxsZq5syZmjNnjlq2bKnAwEA1b96c46FccuHChSzXQEuVKiVJ2T5wUalSJf3www82yeao6tatq7p16+r111/XunXr9NVXX2n//v169913NXPmTLVu3VqBgYHy9/c3Oqpd4HzgbxTb7Uy5cuU0YsQIBQUFafv27QoLC9N3332nZcuWafny5apdu7ZWrFhhdEy70LlzZ/n5+en111/XgAED9NRTT2ncuHHZPuWOvHHp0qUsd6Nl3KVZtmzZLO3LlSun33//3RbRHELRokWVnJycZfvtLh6kpKSwVk4uc3V1vW1/V6xYUcuXL1e/fv00atQozZ4928bpHEtqaqp++uknJSQkWG4q8fDwkLe3t2rWrKmCBQsanNA+/f777/Lx8cmy3dnZWR988IFcXFwUERGh9PR0vf/++7YPaOdcXFxUqlSpbJ/eys63337Lk725zNXVVaVKldLIkSNz1P7LL7/Unj178jiV46D/jcfFHWNVqVJFv//+e46XbZk4cSL9n8uKFCliVZ8mJCRkuWEa965Fixb64osvdOzYMVWtWlVNmjSRyWTSmjVrNGDAgExtr1y5ou+//14PPfSQMWHtVMWKFRUSEqJPP/1Uc+fO1ebNmzVjxgxVq1bN6GgOwdPTUykpKdm+9sADD2jBggUaOnSoFi9erPT0dK6Z2oirq6tlmdlTp04pLCxMa9as0ebNm7VlyxaVLl1aW7duNTqmXXB3d8/yGShQoICk7G+8Sk9PZwZiG3Fzc1NgYKACAwN14sQJy+dgw4YN2rhxI9cmcgnnA3+j2G6nTCaT/P395e/vr99//10RERH66quvmKYkl5UsWVILFizQ119/rRkzZuiHH37QW2+9xborNlKkSBFdvnw507aMp4uyu0Pz5s2bljvN8e95e3vr1KlTmbYNHTrUMn3//zpz5ozl7k7kjvLly+vw4cO3ff1/C+6PPvqoDdM5huTkZM2ZM0dr167V9evXJf19w0nG95Crq6ueeOIJjRw5Up6enoZltUdeXl66dOlStq+ZTCbNmDFDZrNZq1evltlsVqVKlWyc0L49/PDDOnv2rJ5//vkctT916hQntLnM19dXx48fzzR1551ERUVR7M1F9L/xuLhjrBo1aigiIkIXL15kalqDNG/eXBEREQoNDc0yXe3/WrFihTZv3qyePXvaKJ39Gzp0qNauXasBAwZo7NixateunUaMGKGZM2fq3LlzatWqlYoUKaLjx4/rk08+0blz53J8gxZyzmQyaeDAgWrRooUmTJigwMBADR48WMOHD6eolce8vb21d+/e275esGBBffTRR3rxxRf16aefqmTJkjZMB0mqXLmyxo0bpzFjxuj7779XeHg4SzzmojJlyujMmTOZtj3++OO3vf529uxZPgcGqFKliiZMmKCxY8dqy5Yt+uqrr4yOZDc4H/gbxXYHUKxYMQ0YMEADBgzQwYMHjY5jl3r27KnGjRvrtdde06BBgxQQEKDx48cbHcvulS9fXomJiZm2Pfvss7ddkz0pKcmyhg7+vRo1amjlypW6deuW5W5NFxeXbE9mb9y4ob1796pLly62jmnX/Pz8FBISot9+++22B+v/LLjv37+fqcJy0aVLl9S7d2+dPn1aFStWVJMmTeTj4yN3d3dJf83mEB8frx07dmjFihWW/8/6ULnnwQcfVExMzG1fN5lMeueddyRJq1evZnaNXFajRg0dPnxYZ8+ezXZGGeS9GjVqaP/+/Tp9+jQ3kxiA/jceF3eMVb16da1atUqHDh1SixYt7tq+cuXKql+/vg2SOY6XX35ZO3bs0OTJk7Vo0aI7Ho8mJiaqTJkyGjVqlLGh7Ujx4sW1ZMkSDRs2TK+++qpee+01FS9eXOnp6Vq2bFmmKfvNZrOee+45de/e3bjAdq5KlSpauXKlFixYoPnz52vLli2aPn260bHsmr+/v+bOnasjR47I19c32zYPPPCApeC+Y8cOrkkYpECBAmrbtq3atm2rX3/91eg4dqNGjRravHlzpm0+Pj7ZzsAnSQcOHFC9evVskAzZcXZ2VocOHdShQwejo9gNzgf+RrHdwdSqVcvoCHarbNmyWrJkib744gu9//77ioqK4gAyjz366KNas2ZNpifZixcvnm0h69atW4qNjVXLli1tnNJ+jRkz5rbrof2vM2fO6LnnnlOrVq1skMxxtGvXTt98840iIiI0ePDg27bLKLj3799fZ8+etWFC+zZnzhwlJiZqypQp6t279x3bfvnll5o6darmzJmjqVOn2iih/WvWrJneeecd7dmz57YH6xkFd5PJpIiICMbmXFS/fn1FR0crPj4+R8V2LirkvqZNm+q///2vLly4kKNib5s2bbJdOxD3hv43Hhd3jNW3b1/17ds3x+2ff/75HM+Ggpzx8vJSeHi43n//fa1fv96ybGDG8U7GjEsuLi7q1q2bxowZwxN1uaxatWpau3atvvjiC0VGRurYsWP6888/La+XLl1ajRo1Uu/evVW3bl0DkzoGJycnDRs2TK1bt9b48eP19NNPc/yfhzp16qSjR4/esdgu/T2l/BtvvJHlKWDYHrNO5p5BgwapWbNmSktLu+tMGj///LMqVaqkTp062SidYyhXrhxL5BiI84G/mcy3W+wV+d6qVatUrVq1Ox7MwBiJiYl69dVXdeTIEXXv3l2vvfaa0ZHs0sWLF3X27FlVq1bNsh7O7Rw5ckTLli1Tt27d1KhRIxslBGDPmjVrprp16+o///lPjtq/9NJL2rdvH1O25aLz588rJCREtWvXVtu2be/Y1mw2Kzg4WElJSZoxY4aNEgIAANjG1atXtX//fsXHx1vWj3V3d5ePj49q165tedodeSstLU2XL19Wenq6PDw85OrqanQkh5WWlqaPP/5YcXFxatq0qZ555hmjIwG5LiYmRuXLl+eGTgAwGMV2AACAe1CrVi0NGDBAo0ePzlH7mTNnatmyZSzpAgAAAAAAAAB2gmnkAQAA7kHZsmXvuF74/9q9ezfrWgMAAAB2ymw268yZM5lmFihXrpycnJwMTuZY0tPTdfXqVUlS4cKF6X8bOXfunGJiYpSQkKArV65Ikjw8POTt7a0GDRpwLgy7l5qaqp9++inbz0DNmjVVsGBBgxM6BsZiGIViOwAgzyUmJmrAgAEymUzavHmz0XEcUnJysj7//HOZTCYNHz7c6Dh2oWvXrgoODtYrr7yi0aNH3/biwdmzZzVz5kwdOHBAQUFBNk4JAABgvLNnz2r8+PEymUxatmyZ0XEc0p9//qnz589L+mt9U+SeyMhIhYaGKjY2VmlpaZlec3Fx0WOPPabAwEB17tzZoIT278CBAwoNDdXu3bt15swZpaenS5JMJpMqVKggPz8/BQQEqE6dOsYGtUOnT5/W1KlTtX37dkl/Fbr+yWQySZL8/f31+uuvy9vb2+YZHcG1a9e0adMm7d69O9tir5+fn9q2bSs3NzeDk9qf5ORkzZkzR2vXrtX169cl/f05yPj7d3V11RNPPKGRI0fK09PTsKz2jLE4/7P38wGmkXcQFLqMdfLkSXXp0kUmk0mHDx82Oo5Dsvcv8/zu5MmT6ty5s0wmk+Li4oyO45DYB7kvNTVVL774orZv3y6TyaTKlSvL29tbHh4ekqQrV64oISFBp06dktlslr+/vz766CO5uLgYnNwxcSxkLPrfeByPGov+Nx7nA8biWNR4GfvAycmJ76FccuvWLY0cOVLfffedzGaz5XzA3d1dkpSSkmI5HzCZTGrdurXmzp0rZ2eefcpNb731lj7//HOZzWa5urqqQoUKmfbBL7/8ouvXr8tkMqlPnz567bXXDE5sPxITExUYGKjff/9dfn5+8vf3l4+PT6b+j4+PV1RUlHbv3i1PT0+FhoaqYsWKBie3Lxs3btSUKVOUnJyc5WaHDCaTScWLF9fkyZPVvn17Gye0X5cuXVLv3r11+vRpVaxYUU2aNMn2M7Bjxw4lJiaqUqVKWrFihYoXL25wcvvBWHz/sPfzAf6iHERaWprOnDljuZsKtmc2m297wIO8d/36dcXExPAZMEilSpW0ZcsWo2M4NE9PTw0fPpzPQC4qWLCgFi1apK+//lphYWE6ePCgTp48mamNk5OTateurV69eqlHjx70v4E4FjIW/Z8/cDxqLPrfWJwPGKtcuXJavny50TEcmouLC0+057JFixZpy5Yt6tKli8aMGXPb/k1KStLMmTMVGRmpxYsX64UXXrBxUvv15ZdfKiQkRPXr19fIkSP12GOPZZkqOD09XXv27NHcuXMVEhKiKlWqqHfv3gYlti9z5szR1atX9cknn6h58+a3bff8889r27ZtCgoK0pw5czRz5kwbprRvO3fu1MiRI1WsWDENHz5czZo1y7bQGBUVpZCQEI0aNUpLlixRo0aNDE5uH+bMmaPExERNmTLlrt8rX375paZOnao5c+Zo6tSpNkpo/xiL7x/2fj7Ak+0O4tatW5bpwsqXL29wGsD2bty4oYMHD0qS/Pz8DE4DwB6lpqbq9OnTmaZrq1ixoh544AGDk0HiWMho9D8Ao3E+ACC3dezYUcWKFdOKFSty1P6pp57S5cuX9e233+ZxMsfRrVs3paena9WqVXd9SjEtLU09e/aUk5OTVq9ebaOE9q1x48Zq3ry53n333Ry1HzdunKKiorRz5848TuY4+vXrpxMnTujrr79W6dKl79j23Llz6tmzp6pWrcosP7mkWbNmqlu3rv7zn//kqP1LL72kffv2KSoqKo+TOQ7GYuQXTndvAnvg7Oys8uXLc3ETDqtQoULy8/PjwhqAPFOwYEE99NBDqlu3rurWrauHHnqIQns+wrGQseh/AEbjfABAbktKSrLqO8XPz09JSUl5mMjxxMfHq2XLljmaDtjFxUUtWrRQfHx83gdzENeuXVOpUqVy3L5UqVK6du1aHiZyPD///LM6dep010K7JJUpU0adO3fWoUOHbJDMMVy+fFk+Pj45bu/t7a3Lly/nXSAHxFiM/IJp5AEA/1pqaqp++uknJSQkZHqq19vbWzVr1lTBggUNTug40tPTdfXqVUlS4cKFs0yhBwAAAOSF8+fPKz4+PtP5gI+PT44KAMD9qEiRIkpISMhx+4SEBBUpUiQPEzkeV1dXXbhwIcftL1y4IFdX1zxM5FgqVaqkrVu3auTIkTmaWWDbtm2qVKmSjdI5hnuZtJiJjnNP2bJlFRMTk+P2u3fvVtmyZfMwkeNhLM5fHPl8gGK7naDQZaxz584pJiYm2/5v0KABg6iNOPKXuVGSk5M1Z84crV27VtevX5f090F7xnqYrq6ueuKJJzRy5Eh5enoaltWeHThwQKGhodq9e7fOnDmj9PR0SX/tgwoVKsjPz08BAQGqU6eOsUGBPMSxkLHof+NxPGos+j9/4HzA9lJTU7V06VKFh4crMTEx2zYVKlRQr1691L9/f8aDPLRnzx7t3r37tt9D9evXNzih/WnevLkiIiIUGhqqXr163bHtihUrtHnzZvXs2dNG6RxDw4YNFRkZqccff1z+/v53bPvDDz8oMjJSbdq0sVE6+9erVy9Nnz5dAwcO1MiRI1WvXj3LtaAMZrNZe/fu1dy5c3X8+HG99tprBqW1T9WrV9f69ev1/PPP33WWgfPnzysyMlI1atSwUTr717VrVwUHB+uVV17R6NGjb3vMf/bsWc2cOVMHDhxQUFCQjVPaN8Zi43E+8BfWbL/PUegy1unTpzV16lRt375dUtY7AzP2gb+/v15//XV5e3vbPKO948vcOJcuXVLv3r11+vRpVaxYUU2aNJGPj4/c3d0lSSkpKYqPj9eOHTuUmJioSpUqacWKFSpevLjBye3LW2+9pc8//1xms1murq6qUKFCpn3wyy+/6Pr16zKZTOrTpw8ntrA7HAsZi/43HsejxqL/jcf5gHGuXbumAQMG6ODBg3Jzc1O9evXk4+OjwoULS5KuXr2q+Ph4xcbG6vr166pVq5Y+/fRTubm5GZzcvuzbt0+TJk3SiRMnbvu0oslk0kMPPaRp06ZxA24uunDhggIDA3X+/PkcnROXKVNGYWFhKlmypMHJ7Ud8fLwCAgJ09epVNWrU6Lb7YPv27dq1a5c8PDwUGhpq1bTPuD2z2axJkyYpPDxcJpPJck3Cw8NDknTlyhXLNQmz2azAwEBNmzbN4NT2JSoqSkOGDFHx4sXVt29fNW3aVN7e3pn2QUJCgqKjoxUSEqLk5GQtXLjwrjenIGdSU1P14osvavv27TKZTKpcuXK2/X/q1CmZzWb5+/vro48+kouLi8HJ7QdjsbE4H/gbxfb7GIUuYyUmJiowMFC///67/Pz85O/vn23/R0VFaffu3fL09FRoaKgqVqxocHL7wZe5sd544w2FhYVp8uTJ6t279x3bfvnll5o6daoCAwM1depUGyW0f19++aXefPNN1a9fXyNHjtRjjz2WZdr49PR07dmzR3PnzlVsbGyO9hdwv+BYyFj0v/E4HjUW/W88zgeM9d5772nJkiUaMmSIhg0bdtupma9fv6558+Zp0aJFGjRokF555RUbJ7Vfhw8fthzbd+nSRc2aNZO3t3em76GEhARFRUVp3bp1MplMWrlypXx9fY2MbVd+++03vf/++1q/fr1SU1Ml/X2jVcYlVxcXF3Xp0kVjxoyRl5eXYVnt1fHjxzVlyhTt2bNHkrJ9slqSGjRooMmTJ+uhhx6yeUZ79+OPPyosLEwxMTFZpvX38vKSn5+fevXqpYYNGxqU0L6tXr1a06dP1x9//JHl7z+D2WyWh4eHJk2apCeeeMLGCe2b2WzW119/rbCwMB08eNAy22QGJycn1apVS7169VKPHj1uu49w7xiLjcP5wN8ott/HKHQZa8yYMdq4caPmzZun5s2b37Httm3bFBQUpPbt22vmzJk2Smj/+DI3VrNmzVS3bl395z//yVH7l156Sfv27VNUVFQeJ3Mc3bp1U3p6ulatWpWj9dF69uwpJycnrV692kYJgbzFsZCx6H/jcTxqLPrfeJwPGKt169Z68MEHtWjRohy1HzRokE6dOqXvvvsuj5M5jqFDh2rPnj0KCQm5awE9Li5Offr0UYMGDbRgwQIbJXQcV69e1f79+xUfH6+UlBRJkru7u3x8fFS7dm3LDRDIO/Hx8YqJicl2HzRo0ECVK1c2OKFjuH79eqalLG43NiN3/fHHH1q/fv1tlzXy8/NTp06dWKs6j6Wmpur06dOZ+r9ixYp64IEHDE7mGBiLbY/zgb+xZvt97Pvvv1e7du1y9ITi008/rZ07d+r777+3QTLHsGPHDnXu3PmuF9YkqUWLFurUqRNFxlz27bffyt/fX2PGjLljO1dXV40dO1ZxcXFav349F9dyyeXLl62aes3b21tbt27NszyOKD4+Xv369btroV366w7OFi1a6LPPPrNBMsA2OBYyFv1vPI5HjUX/G4/zAWNduHBBjz/+eI7b16hRQzExMXmYyPHExsaqc+fOOXpSvVq1aurcubM2bNhgg2SOp3DhwmratKmaNm1qdBSH5ePjw/Tw+YCrqysFdgMUKVJETz31lJ566imjozi0ggULMnuGgRiLbY/zgb853b0J8qt7KXRdvnw57wI5mGvXrqlUqVI5bl+qVCldu3YtDxM5ngsXLqh69eo5bl+jRo0s01nh3pUtW9aqwXH37t0qW7ZsHiZyPK6urlb9TV+4cIGTXtgVjoWMRf8bj+NRY9H/xuN8wFheXl6Ki4vLcfuff/6ZaTtzWVpammXZhJxwd3dXWlpaHiYCAACAo+B84G8U2+9jFLqMValSJW3dulW3bt26a9u0tDRt27ZNlSpVskEyx8GXubG6du2q/fv365VXXtHZs2dv2+7s2bMaO3asDhw4wLpQuaxhw4aKjIxUdHT0Xdv+8MMPioyMVKNGjWyQDP8rIiJCa9eutUwlhtzBsZCx6H/jcTxqLPrfeJwPGKtdu3aKjo7W7NmzdePGjdu2u3HjhmbNmqUdO3aoffv2Nkxo/x566CFt3LhRV69evWvblJQUbdiwgSfuDPLnn38qKSlJSUlJRkcBDJGcnKzg4GDNmzfP6Ch269y5c1qzZo0+/PBDvf3223r77bf14Ycfas2aNXe8bgfbSElJUUREhCIiIoyO4rAYi3Mf5wN/Yxr5+1jXrl0VHBysV155RaNHj77txcuzZ89q5syZOnDggIKCgmyc0n716tVL06dP18CBAzVy5EjVq1dPJpMpUxuz2ay9e/dq7ty5On78uF577TWD0tqndu3aafny5Zo9e7ZefPFFFSpUKNt2N27c0Pz587Vjxw7179/fxint1/PPP699+/Zp7dq1+uabb1S5cmV5e3vLw8NDknTlyhUlJCTo1KlTMpvN8vf31/PPP29wavvy8ssva/v27RoyZIgaNWqkJk2ayMfHx7IGUUpKiuLj47V9+3bt2rVLHh4eGjVqlLGhHdSECRNkMplUuHBhPf300xowYIBKlChhdKz7HsdCxqL/jcfxqLHof+NxPmCsESNGaNeuXfr4448VEhKievXqZXs+EBsbq6tXr8rX15dxIJf17dtX48aNU2BgoIYOHaqmTZtmOca8ePGioqOjtWDBAp09e1ajR482KK1jS0hIUOfOneXk5KTDhw8bHcchnTx5Ul26dJHJZGIfGCCj2G4ymTR8+HCj49iV06dPa+rUqdq+fbukv44//ynj+NTf31+vv/66vL29bZ4R0q+//mq5NtS9e3ej4zgkxuLcx/nA30zm//32xX0jNTVVL774orZv3y6TyZSjQtdHH30kFxcXg5PbB7PZrEmTJik8PFwmk0murq6qUKFCpv7/5ZdfdP36dZnNZgUGBmratGkGp7YvKSkp6tOnj44cOaLChQvn6Ms8JCTEUojEv2c2m/X1118rLCxMBw8eVHp6eqbXnZycVKtWLfXq1Us9evTIcgEa/97x48c1ZcoU7dmzR5KyvcgvSQ0aNNDkyZN5ksUgEyZMkNls1rFjx3TkyBG5uLjowIEDRse673EsZCz633gcjxqL/jce5wPGu379uhYuXKjw8HD9+uuv2bYpVaqUAgMDNXjwYJY0ygMfffSR5s2bpz///FOS5ObmlukzkLF8RYECBRQUFKShQ4caltWRJSYmWm72+e677wxO45hOnjypzp07S5KOHDlicBrHk5ycrJCQEJlMJrsttBghMTFRgYGB+v333+Xn5yd/f/9sH8KIiorS7t275enpqdDQUFWsWNHg5I7nwoULmjlzpkwmk2bMmGF0HIfEWJw3OB/4C8X2+xyFLuP9+OOPCgsLU0xMTJb1/7y8vOTn56devXqpYcOGBiW0b3yZ5x+pqak6ffq0ZZpsDw8PVaxYUQ888IDByRxDfHy8YmJiFB8fr5SUFEl/rcno4+OjBg0aqHLlygYnRIaUlBTFxsaqefPmRkexCxwLGYv+zx84HjUW/W8szgfyj/j4eCUkJGQ6H/D29paPj4+xwRxAQkKCvvrqK8XExGS7D/z8/NSzZ0/2BQDYmTFjxmjjxo2aN2/eXa8xbNu2TUFBQWrfvr1mzpxpo4QAHIkjnw9QbLcjFLqMd/369Uz9z4Uc23LkL3MAAMdCRqP/8weOR41F/xuL8wEAAOBIGjdurObNm+vdd9/NUftx48YpKipKO3fuzONkAOBYWLPdjhQsWJDpgQ3m6urKBTUD+fj4cCENABwYx0LGov/zB45HjUX/G4vzAQAAjJWenq6rV69KkgoXLiwnJyeDE9m3a9euqVSpUjluX6pUKcvyIgCQl44cOaIjR46oe/fuRkexCYrtAAAANhAbG6vTp087zEEmAAAA4Cj27Nmj3bt3Zzu7RoMGDVS/fn2DE9q/c+fO3XYphQYNGqhs2bIGJ7RfBw4cUGhoqHbv3q0zZ85YlpYymUyqUKGC/Pz8FBAQoDp16hgb1A5VqlRJW7du1ciRI+XsfOdST1pamrZt26ZKlSrZKJ3jOHv2rFatWnXbccDPz0/dunVTuXLlDE5q3xiL85fNmzdr3rx5DnMdlGnkAQAAbGDixImKiIhQXFyc0VEAAAAA5IJ9+/Zp0qRJOnHihG53idVkMumhhx7StGnTKDbmgdOnT2vq1Knavn27JGXZDyaTSZLk7++v119/Xd7e3jbPaM/eeustff755zKbzXJ1dVWFChXk7u4uSUpJSdEvv/yi69evy2QyqU+fPnrttdcMTmxfPvvsM02fPl1+fn4aOXKk6tWrZ/mbz2A2m7V3717NnTtXe/bs0WuvvaY+ffoYlNj+LF26VLNmzVJqaqokyc3NLdNnIGMmgYIFC2r06NEaMGCAUVHtFmNx/hQcHKx58+Y5zHVQnmwHAAAAAAAAACscPnxY/fv3lyR1795dzZo1k7e3d6YiS0JCgqKiorRu3Tr1799fK1eulK+vr5Gx7UpiYqJ69eql33//XX5+fvL395ePj0+mfRAfH6+oqChFRUWpd+/eCg0NVcWKFQ1Obh++/PJLhYSEqH79+ho5cqQee+yxLNPGp6ena8+ePZo7d65CQkJUpUoV9e7d26DE9qdPnz7673//q/DwcPXp08dyw4OHh4ck6cqVK5YbHsxmswIDAym056L169frnXfekY+Pj4YOHSp/f3+VLFkyU5vffvtNUVFRWrBggd59912VKVNGHTt2NCix/WEsRn7Bk+0AAAD3ICkpyar277zzjjZt2uQwd3QCAAAA9mzo0KHas2ePQkJC7nrRPi4uTn369FGDBg20YMECGyW0f2PGjNHGjRs1b948NW/e/I5tt23bpqCgILVv314zZ860UUL71q1bN6Wnp2vVqlU5msK8Z8+ecnJy0urVq22U0HH8+OOPCgsLU0xMjC5cuJDpNS8vL/n5+alXr15q2LChQQnt01NPPaXffvtNq1evthR3b+fKlSvq1q2bvLy8tHLlShsltH+MxfkXT7YDAADgrlq3bp1lejYAAAAAjiE2NladO3fO0dNx1apVU+fOnbVhwwYbJHMcO3bsUOfOne9aaJekFi1aqFOnToqKirJBMscQHx+vfv363bXQLkkuLi5q0aKFPvvsMxskczyNGjVSo0aNJEnXr1/PtF61q6urkdHs2tGjR9W7d++7Ftqlv/ZFhw4dtGLFChskcxyMxflX+fLlVb9+faNj2AzFdgAAgHtgMplUtGhRPfroozlqf/To0Sx3mAMAAAC4P6Wlpalw4cI5bu/u7q60tLQ8TOR4rl27plKlSuW4falSpSzrJ+Pfc3V1teoc98KFCxR+bcDV1ZV+thFnZ2ddvXo1x+2vXr2ao5tTkHOMxflXjx491KNHD6Nj2AyfbABAnouIiFCBAgXUsmVLy7pRwP3Ox8dHqampWrRoUY7aT5w4UREREXkbCgAAIB/avXu3ChQooDp16mRZzxe4Xz300EPauHGjgoKC7nqhPyUlRRs2bNBDDz1ko3SOoVKlStq6datGjhyZo2nMt23bpkqVKtkonf1r2LChIiMj9fjjj8vf3/+ObX/44QdFRkaqTZs2NkoH5L06deooMjJSzz77rB555JE7tj1y5IjWrVunxx57zEbpHANjMfILiu0OgkKXsYKDg+Xs7KxOnTrJ29vb6DgOiYs7xpowYYJMJpMKFy6sp59+WgMGDFCJEiWMjuVQqlWrpgIFCqhLly56/vnnVaVKFaMj3feqV6+uyMhI/fHHHypSpIjRcXAXHAsZi/43HsejxqL/jcf5gLH69u0rk8mk8uXLa/DgwerZs6cKFixodCyHMnHiRDk7O6tLly6WqYbx7/Tt21fjxo1TYGCghg4dqqZNm2Y5z7148aKio6O1YMECnT17VqNHjzYorX3q1auXpk+froEDB2rkyJGqV69elqW+zGaz9u7dq7lz5+r48eN67bXXDEprf15++WVt375dQ4YMUaNGjdSkSRP5+PhYptROSUlRfHy8tm/frl27dsnDw0OjRo0yNrQDS05O1ueffy6TyaThw4cbHccujBgxQs8884x69eqlrl27Wj4DGee8V65csXwGvvnmG6Wnp2vEiBEGp7YvjMXIL0xms9lsdAjkPV9fXwpdBsrofycnJ3Xo0EHPP/98jtYRQe7J2Adc3DHGhAkTZDabdezYMR05ckQuLi46cOCA0bEcyj+/c5ycnNSmTRt9+OGHBia6/y1ZskTvvfeePv30UzVu3Piu7d99911t2LBB3333nQ3S4X9xLGQs+t94HI8ai/43HucDxurbt6/lfODy5csqWbKkoqOjjY7lUDK+c0wmk2rVqqUXXnhBrVu3NjjV/e+jjz7SvHnz9Oeff0qS3NzcMhVZMqYsL1CggIKCgjR06FDDstojs9msSZMmKTw8XCaTSa6urqpQoUKmffDLL7/o+vXrMpvNCgwM1LRp0wxObV+OHz+uKVOmaM+ePZKU7c0OktSgQQNNnjyZJ0oNdPLkSXXu3Fkmk0lxcXFGx7EbP/74oyZNmqTExMQsf/8ZzGazKlasqLfeeksNGza0cUL7x1iM/IBiu4Og0GWs4OBgpaen69ixY9q7d6+Sk5M5qLExLu7kHykpKYqNjVXz5s2NjuJwzGazjh49qt27d2vv3r2aPXu20ZHuazdu3NDFixfl6ekpNzc3o+PgLjgWMhb9bzyOR41F/xuP84H84+jRo9q7d6+efvppo6M4lFWrVlm+h2JiYnT06FEdOnTI6Fh2ISEhQV999ZViYmKUkJCgK1euSJI8PDzk7e0tPz8/9ezZUz4+PsYGtWM//vijwsLCFBMTk2UNcS8vL/n5+alXr14UufJQfHy8YmJiFB8fr5SUFEl/rY3s4+OjBg0aqHLlygYnRHJyskJCQmQymRQUFGR0HLvy559/6scff7zjZ6Bx48YqUKCAwUntF2MxjEax3QFR6DLeiRMnmMLZQFzcAQDHxrGQsej//IHjUWPR/8bifACQrl69ete1TYH70fXr1zMVWVxdXQ1OBAAA7B3FdgAAAAAAAAAAAAAArORsdADkrZSUFBUsWJC16ADkqZiYGP3444+Kj4/XH3/8IScnJ5UoUUKPPvqo2rdvLy8vL6MjOqygoCA1adJEzzzzjNFRAAAAYEfWrFmjxo0bc6wPAEA+kp6erqtXr0qSChcuLCcnJ4MTOabg4GDNnz9fhw8fNjqKw1q1apVWrVql5cuXGx0FDoBiu51r0KCBAgMDNXXqVKOjOLzNmzfryJEjrImTi7i4Y7yDBw/qtdde0/HjxyX9tSa4yWRSxqQpERERmjFjhvr27avRo0fLxcXFyLgOafPmzfL09DQ6BiRNnDhRq/+PvXuPy/n8/wD+ujtqKhPlVKrFijCnDsj5NJFDKjaHOYzZZBmbwzCbU+xgDjUb5mxO6aAJU0gLHYSYYugkxFA66aD794ef+7t2Fx3u7kv3/Xo+Ht/Hd133dX96dV3u7j73+/O5rqAgnmgpWEFBAY4ePYrHjx/DwcEBrVq1AgDcuXMHP//8M65evQodHR04Ojpi4sSJMDAwEJxYdWzYsAFOTk5o27at6ChUhoSEBMTFxSEvLw/NmjVDjx49oK+vLzqW2uD4KwfPB8SaM2cOtLS00LNnT7i5uaFnz578QP81d+DAAcTFxcHb21t0FCIiUqBLly5h//79iImJQXp6OkpKSgAAEokEpqamsLe3h5ubG9q3by82qJrhotJipaenIyYmRnQM+n937tyBpqYmGjVqJDpKjWCxXcVJpVL+Un9NhIWFITAwkMV2BeKHO2LduHEDH3zwAQoLC9G3b1+Ympri9u3bOHXqFFq0aIGpU6fi5s2bOHz4MLZt24bk5GRs2LBBdGyV8vXXX1eoX1xcnKyvRCLB4sWLay4UvRTfkxUrJycH7733Hm7cuAGpVAoNDQ0sXboUXbp0gbu7Ox4+fCjre+HCBRw5cgT79+9nwV1B1q5di3Xr1sHa2hpubm4YOnQoDA0NRcdSKz4+PnBwcICdnZ2sLT8/H3PnzsXx48cB/O9CuHr16mHlypXo1auXoLSqh+MvHs8HxHv27BnCwsJw4sQJGBsbY8SIEXBzc4OZmZnoaFSGuLg42QXRRESkGpYtW4bdu3dDKpVCT08Pb731luwiz5ycHNy+fRt+fn44ePAgxo4diwULFghOTETqqE+fPpBIJOjUqRM++ugjdO/eXXQkhWKxvRZ75513XtlHIpEgICAAhw4dkn198eLFGk5GpDz8cEecdevW4dmzZ/jtt99K/T66dOkSxo4di7t372LGjBmYPn06Vq5ciZ07d+LgwYMYOXKkwNSqZe/evaVWEiiLRCLBzZs3cfPmTdnXLLaTqti1axf+/vtv9O3bF7169cLJkyexcuVK9OvXDxKJBL6+vnBwcMDjx4+xdu1a/P7779i4cSNmz54tOrrKqFOnDhITE7F8+XJ899136N+/P9zd3eHg4CA6mlrw8fEBgFLF3sWLF+OPP/6ApaUlhg0bhvr16+PixYsICgqCl5cXAgMDYWlpKSqySuH4vx54PiDWRx99hNatW+PAgQOIjIzEL7/8go0bN8Le3h7u7u4YMGAAt7UjIiKqIXv27MGuXbvQuXNneHl5oVOnTnIXHpaUlCA2NhZr167Frl27YGVlhdGjRwtKTETqqmnTppBKpYiLi8PUqVPRqlUr+Pv7i46lMCy212IFBQWoU6cOjIyMyu1z584d6Ojo4M0331ReMDVR2SVIHjx4UENJ1Bs/3BEnJiYGAwYMkLvw55133sGAAQOwb98+TJ48GRoaGpg/fz7+/PNP+Pn5sdiuQHp6epBIJJg5cyZsbGzkHpdKpfjggw/Qq1cvTJo0SUBC1TZ+/PhK9b9161YNJVFfR44cQatWreDr6wsAcHd3x7BhwxAYGIjVq1ejb9++AAB9fX18++23SExMRFhYGIvtCjR58mT07t0bBw4cwOHDh/H777/j8OHDMDU1hZubG0aMGAETExPRMdVGWloagoOD0b59e2zbtg116tQBAIwaNQq9e/fGp59+iq1bt3KLqRrC8ReD5wNiaWlpYcCAARgwYAAyMjLg5+cHf39/REVFITo6GkuXLoWLiwvc3NzK/HuVqicwMLBS/VNSUmomCBERCbF37160bNkS27Ztg5ZW2aUeDQ0N2NvbY9u2bXB1dcWePXtYbFcCrjhMVNqJEycAANnZ2YiNjcX58+cFJ1IsFttrse7duyMyMhKDBg2Cl5dXmR8g2NjYYPDgwVi6dKmAhKpt3LhxkEgkFe7/YglJUix+uCNOTk5OuftjmpiY4O7du7KvJRIJnJycVOpqtdfBoUOHMG/ePHz77beYNm0apk2bVubJlbGxMezt7QUkVG3R0dGvXFngv/g+oFh37tyRu4DH0dER169fR9euXUu1a2howNHREQcOHFBmRLVga2sLW1tbzJ8/H0eOHMHBgwcRGxuLNWvWYP369ejevTvc3NzQu3dvLu9cw6KiogAAM2fOlBV6XxgwYAA6deqEc+fOiYimFjj+YvB84PXRqFEjTJ8+HdOnT8fZs2fh5+eH0NBQ7Nq1C7t374atrS3c3d0xatQo0VFVxrx58/i5BBGRGktOTsb48ePLLbT/m7a2Nnr27ImdO3cqIRlNmDABrq6uomOotX79+qFZs2aiY9B/GBgYoHfv3ujdu7foKArFYnsttmnTJuzfvx+rVq3CyZMnsWLFCrRv3150LLWhqakJIyMj9OnTp0L9o6KieBV5DeOHO8rVpEmTcreluHTpktyqG9ra2iguLlZCMvVhZmaGXbt2YevWrVi7di1CQ0Ph7e2NVq1aiY6mFurXrw9jY2Ns2bKlQv2XL1+Oo0eP1nAq9VKVD4t5ZXnN0dXVxfDhwzF8+HCkpqbCz88PgYGBOHnyJE6dOoUGDRrA1dUVs2bNEh1VZT18+BDA8wsgytK6dWvs379fmZHUCsdfPJ4PvD66dOmCLl264MmTJwgKCoKfnx+uXLmCv/76i+OvQNra2jAxManwmB49ehQJCQk1nIqIiJRFT0+vUqupPnjwAHp6ejWYiF4wMDCAgYGB6BhqzcbGhhfbktKw2F7LeXh4oGvXrvjyyy8xZswYjB8/HjNnzoSurq7oaCrPysoKmZmZ+OabbyrUf/78+Sy2KxE/3Kl5ffv2xbZt2/Dtt99ixowZ0NPTQ35+Pnx8fHDhwgW4ubmV6n/79m0uJVwDJBIJJk2ahJ49e2LevHlwd3fHhx9+iOnTp0NbW1t0PJXWunVrxMTEoH79+tDU1Hxl///e5UjVZ2pqiujo6FJtL1YcOHv2LN59911Zu1QqRVRUFJo0aaLsmGqpefPmmDVrFmbOnIlTp07Bz88Pp0+fxqZNm1hsr0H6+voAyr8QRVNTk6sL1CCO/+uF5wOvB0NDQ4wbNw7jxo3DlStXcPDgQdGRVMrbb7+Nu3fvYurUqRXqn5SUxGK7IPPnz4eWlhYGDx4MR0dH0XHUko+PD7S0tDBo0CCYm5uLjqN2WrVqBU1NTQwePBhTp06FlZWV6EgqwcHBASEhIRgyZAicnJxe2vf06dMICQmRbbdGRESKw2K7CjA1NcWOHTuwY8cO/Pjjjzhx4gSWL1+Ozp07i46m0mxtbREYGIiHDx+iQYMGouNQOfjhTs35+OOPceLECWzduhXbt29H/fr18fjxYzx79gzGxsaYMWOGrG9BQQEiIyPRr18/gYlVm5WVFfbt24eff/4ZP/30E8LCwrB8+XLRsVSara0tzpw5g+vXr1doNQHeUa14Li4uWLVqFT799FN0794dERERSExMxIcffohly5ahTp06sLe3x6NHj+Dr64sbN25gzJgxomOrFQ0NDfTp0wd9+vTBw4cPERAQIDqSygkLC0N6ejoA4P79+wCe7x1e1u+le/fuoX79+krNp+o4/q8/ng+8Ptq0aYM2bdqIjqFSbG1tcfXqVdy9e5cXFL7mXvwN5Ofnh3bt2uGjjz6q8EqJpBg+Pj6QSCRYv349Bg4ciKlTp/KORyWSSqUoLi5GUFAQgoOD0bdvX6xfv150rFrvs88+Q2RkJKZMmQJHR0d07doVFhYWsotAc3JykJycjMjISERFRcHAwAAzZ84UG5qIVEpBQQF2796N6OhoaGlpwcnJCSNHjizzJrDt27djx44dCAsLE5C0ZrHYrkLGjx+PHj16YN68eRg/fjzef/990ZFUWuvWrREQEIArV66gZ8+er+xvaWnJCyAE44c7imVoaIh9+/Zh3bp1OHHiBP755x/Ur18fPXr0gJeXV6m72DU1NXH48GHZH/tUMzQ0NPDJJ5+gT58+mDt3Lt577z3uyViDnJ2doaOjAx0dnQr1nzp1KvfrUrD3338fR44cwR9//IHjx49DKpWif//+mDVrFm7cuIGPP/5Y1lcqlcLY2BgfffSRwMTqrUGDBvjwww9Fx1A5CQkJcncphoaGllnsvXjxIt5++21lRVMLHP/ahecDimVnZwdTU1PRMdRa586d8eeffyI5OblCxfaOHTsqIRWVxdvbGyUlJfj7778RHR2NTz/9FFeuXBEdS614enrK5uDcuXM4cuQIV3pQosTEREilUly/fh0xMTE4f/686EgqwcLCAnv37sXXX3+Ns2fP4uzZs3KfA7248N/Ozg6LFy+GhYWFgKREpIoKCwsxbtw4XL58Wfa7JiwsDLt378aaNWvkVjHJzs7GnTt3REStcRIpb7NSOVKpFJs2bYKPjw8KCwvh7u6OpUuXio5FpHDjxo3DyJEjMXz4cNFRiF47RUVF+OWXX5CQkIBu3brxAixSWcXFxTh+/DjS0tLw9ttvo1evXgCAp0+fYsOGDYiIiEBRURE6duyIadOm8a4vBZo/fz769evHZQgFenFH9X/p6enByMioVFtCQgJWrFiBYcOGyW31QlXD8ReP5wNEVFvl5uaibt26omOotZs3b3Ipc1IpycnJiI6ORnJyMnJycgA83+bIwsICdnZ2sLS0FJyQiFTNL7/8gh9//BG9e/fGRx99BC0tLfj5+WH//v0wNDTEr7/+CltbW1l/Hx8f+Pr6quTFbiy2q7Dk5GTcuHEDpqamXBaJiIiIiIiIiIiIiIiIiKpt2LBhKCgowOHDh6GpqSlrDw8Px2effQZtbW1s3rwZbdu2BaDaxXYN0QGo5lhYWKBfv34stBOR0sXFxWHHjh3YuHEjQkJCkJ2dLToSEREREREp0b179xAeHo6zZ88iNzdXdBwiIlKyZ8+e4datW0hLSxMdRS3l5OSo7HLNRPR6SElJgZOTU6lCOwD07NkT27ZtQ0lJCSZPnoz4+HhBCZWHe7YT1ZDc3Fw8ffoU9evXh4YGr2tRhoyMDCQnJ8sKuwYGBrCwsECjRo0EJ1NNR48exdmzZ7F48WLZv/GMjAx4eXnh0qVLAJ5vayGRSKCvr4+vv/4agwcPFhlZZRUVFeH69evQ1NSEtbV1ufu0JyYmIjExkUutKhjHX7yioiLk5eWhXr16pdovXLiAq1evQkdHB/b29jA3NxeUUP3ExcXhypUrePr0KUxNTdG9e3cYGBiIjqWWPD090bVrV24nQmqB5wPKFxgYCF9fXzx69Ahdu3bF119/jQYNGuD777/Htm3b8OzZMwBAnTp18Pnnn2PMmDGCE6uHf/75B35+frL34mbNmmHQoEFwdHQUHU2lTJw4Ed27d8fw4cPltg+h11NoaCgSExPh6ekpOorKuHnzJtavX4/U1FS8/fbbmDFjBpo1a4aoqCjMnTsXGRkZAJ7fFLZq1Sq0a9dOcGL1sW3bNpW9g5SIXg9aWlrQ1dUt87F27dphy5YtmDRpEiZPnoyNGzcqOZ1ycRl5FXDs2DHExMRAU1MTTk5O6N69e5n9AgICEBAQgB07dig5oWq6c+cODA0Noa+vX6r95MmTWLNmDa5fvw7g+Z6Nzs7O+OKLL+SKAFR9hYWF2LZtG/z8/Mq9UtbU1BQeHh744IMPoKOjo+SEqmv8+PEoLi7Gb7/9BuB5YX3kyJG4evUq3nnnHfTu3RsGBga4ceMGAgMDUVhYiO3bt6Nz586Ck6uWI0eO4Ouvv8aTJ08AACYmJvj888/h4uIi11eVl+oRheMvnq+vLzZv3oynT5+iVatWWLNmDUxNTTF79mwcPXpU1k8ikWDixIn44osvBKZVLbzoqnawsbGBu7s7li5dKjqKyuL5mFg8HxAnNjYWY8eOhUQigbGxMR48eABHR0cMHz4cc+fOha2tLezs7PDo0SMcO3YMhYWF2LRpE5ycnERHVxk+Pj44fvw4AgICZO/F0dHR8PT0RHZ2Nv79kZ9EIsHo0aOxePFiUXFVjo2NDSQSCTQ1NdGnTx+4ubmhe/fu5V58S+LNnz8fgYGBPCdTkIyMDLi4uMjOhwGgefPm+PXXX+Hq6gpdXV20b98e9+/fR3x8PAwNDREcHMyL4JSEn0G8XsaPHw8tLS0MHjwYw4YNg5YW74NVNh8fH2hpaWHQoEG8GUNBhg4dikaNGmHTpk3l9rl8+TImTZqEkpISdOrUCRERESr5e4mv6FqspKQE06dPx6lTp2QnUDt27ECXLl3w7bffomHDhqX6p6enIyYmRkRUldS3b194enpi+vTpsrbAwEB8+eWXkEqlaN68OerXr4+///5bdkX5/v37+eGOAuXl5WHChAmIj4/HG2+8gW7dusHCwgJ169YF8Hx1geTkZMTFxWH16tUIDQ3F1q1b8cYbbwhOrhpu3ryJAQMGyL4+d+4crl69Cg8PDyxZsqRU37Fjx8Ld3R2//PILi+0KFB8fj9mzZ0NDQwNdu3aFtrY2zpw5gzlz5iA2NhbffPON6IgqjeMv3okTJ7B+/XrUrVsX7du3x/Xr1zFz5ky4urriyJEj6NevHxwcHPDw4UPs27cPW7ZsQevWrVnwVZDffvsNxcXFsg/3pVIpPv7443IvupozZw4aNWrE9wEF+vrrryvULy4uTtZXIpGw0KIgPB8Tj+cDYm3ZsgV6enr47bff0KpVK/z1118YM2YMUlNTMWTIEHz33XeyouPEiRPh4eGBHTt2sNiuQCdOnECTJk1k78V5eXmYOXMm8vPzMXnyZPTp0weGhob4+++/8csvv2Dv3r1o06YNRo4cKTi56mjRogUePHiAP/74A8ePH0fjxo3h6uoKV1dXNGvWTHQ8ohq1ZcsWZGdnY/ny5Rg4cCBOnTqFuXPnYtasWbCyssLmzZtlNyn5+flh4cKF2LZtG+bOnSs4OZHyRUdHAwDOnj0LHx8fTJo0CePGjROcSr34+PhAIpFg/fr1GDhwIKZOncotmKupQ4cOCAwMRHZ2drmrGbZt2xZbtmzB5MmTERERoeSEysNiey22b98+nDx5Em3atMHEiROhpaUFPz8/REREYPTo0di+fTv/sK9BUqm01FXieXl5WLFiBQwMDLBmzRp06dIFAJCfn4+FCxciJCQEu3fvxsSJE0VFVjk+Pj6Ij4/HlClT8Mknn0BPT6/Mfvn5+bI7H319fXlXo4I8efIEhoaGsq8TEhIgkUgwbdo0ub5WVlYYOHAgQkNDlRlR5W3evBkaGhrYvn07OnXqBOD5qhtz5szB/v37UVBQAG9vb95ZUUM4/uLt2rULhoaGCAoKQpMmTXDnzh0MHz4cvr6+mDhxYqkPcUaNGoXBgwdj3759LLYrCC+6Em/v3r2QSCR42WJlEokEN2/exM2bN2Vfs9iuGDwfE4/nA2IlJiaiX79+aNWqFQDA1tYWffv2RUhICDZv3lzqb6BWrVqhb9++OHfunKi4KiktLQ12dnayr0+fPo1Hjx5h0aJFpZbsb9GiBbp3745hw4Zhz549LLYr0MCBA/HRRx/h+PHj8PPzw7lz5+Dr64sNGzagS5cucHNzQ79+/aCtrS06qkqq7EVsDx48qKEk6ikyMhKOjo6y3ylDhgzBoUOHEBERge3bt5daDdTNzQ2//fYb/vzzTxbbSS3t2LEDJSUl+PvvvxETE4NffvmFxXYl8/T0lM3BuXPncOTIEZW8w1qZ+vTpg3379uG3337DRx99VG6/FwX3SZMmybb8UjUsttdiAQEBaNSoEXbt2oU6deoAeP5H/r59+7B06VKMGzcO27dvh5mZmeCk6uHMmTN48uQJFi1aJCu0A8+XkV+xYgXOnz+Po0ePstiuQEePHoWTkxNmz5790n56enr4/PPPkZCQgCNHjvDDNQUxNjbG7du3ZV+/uJuivKvY9PX1UVhYqJRs6iIuLg59+/aVFXoBoGnTprIrxQMDA/Hs2TN8++23LPjWAI6/eDdu3ED//v3RpEkTAM/Hv1+/fggICJDbE7ZJkybo378/Tp48KSKqSuJFV+Lp6elBIpFg5syZZV6RL5VK8cEHH6BXr16YNGmSgISqjedj4vF8QKyHDx/K3oNfeHGBSVkXmpiamiInJ0cp2dRFUVFRqdXzUlNTIZFIyrywUF9fH7169cLBgweVGVEtaGtrw9nZGc7Ozrhz5w4OHjwIf39/REZG4syZM6hXrx6GDRsGNzc3tGzZUnRclTJu3LhKnWu92OKIFCM9PV1u+5yWLVsiIiICrVu3luvftm1bBAcHKyue2vvvjWIklr29PQDA0dGRRXZBPD09S3394oJ0qrqePXsiPj5eVhd4mTZt2uD48eMqez7AYnstduPGDQwdOlT2wc4Lo0aNgomJCby8vDB+/Hjs2LGDH/AoQUpKCiQSCXr37i33mK6uLrp06YLjx48LSKa6Hjx4gCFDhlS4v62trWzJHqq+rl274vDhw8jIyJAtCyyVShEWFobhw4eX6ltYWIg///wTzZs3FxNWRWVmZsLCwkKuXUtLC99//z20tbURGBiIkpISfPfdd8oPqOI4/uJlZWWhQYMGpdpeLNtsbGws19/Y2Bh5eXlKyaYOeNGVeIcOHcK8efPw7bffYtq0aZg2bVqZe/8ZGxvLPtwhxeH5mHg8HxCrYcOGuHv3bqm2F1+np6fD0tKy1GN37tyRLfFPimFmZoarV6/Kvn7xHlxQUFBm/8LCQmhqaiolm7pq2rQpZsyYAU9PT0RGRuLAgQM4ceIEtm/fjh07duCdd97B3r17RcdUGZqamjAyMkKfPn0q1D8qKgopKSk1nEp9SCQSuYsXXqwy8++72l+oV68eioqKlJKNgBkzZmDGjBmiYxC9tqysrERHUAmV2Ta5Xr16qFevXg2mEYfF9lpMKpWW+2Fm7969sX79esyYMQNjx47F9u3blZxO/ZSUlACA3N6MLzRs2BBPnz5VZiSVZ2xsXKmlXv76668yiy9UNdOmTcPhw4cxYcIEfPPNN7C3t4eHhweWLl2K7Oxs9O7dG4aGhrhx4wZ8fHyQnJyMefPmiY6tUoyNjfHo0aMyH5NIJPD29oZUKkVQUBCkUikvdlAwjr94jRs3RnJycqm2F18nJSXJ3el769atUndiU/XwoivxzMzMsGvXLmzduhVr165FaGgovL29ZUs6U83i+Zh4PB8Qy9bWFqGhobh27Rqsra2RmJiI48ePo3nz5tiwYQO+/fZbWd9r167h+PHjpVYEourr378/fv75Z8TExMDOzg69e/eGt7c3fvvtN3z22Wel+mZkZOD48eNl3m1KiieRSODk5AQnJydkZmYiMDAQBw8exKVLl0RHUylWVlbIzMzEN998U6H+8+fPZ7FdgRo0aCC3NL+VlRX69+9fZv+MjAy8+eabSkhG9PrYsWMHWrZsWWolXCJ1oi6vgVff20+vrSZNmiApKancx3v27Il169bh8ePHGDdu3Ev7UtWkp6cjJiYGMTExsju1ytv/6Z9//lHZq3ZE6d+/P/7880/8+OOPL72Q4enTp1i9ejXOnDlTam9Zqh5TU1P4+PjgwYMH+OCDD9ClSxckJCTg6dOnWLFiBfr37w8HBweMGTNGNvZcJkmx3nrrrZfenSWRSLBy5UoMGzYMISEh2LlzpxLTqT6Ov3gdO3bEiRMncPLkSRQXFyMsLAwnTpxAmzZt8P3335e6qysyMhKnTp1Cu3btBCZWLS+Wi58wYQKio6PRpk0b2UVXO3fuxO3bt/HkyRPExcVh2rRpSE5Ohpubm+DUqkcikWDSpEnw9/eHtrY23N3dsWbNGt41pAQ8HxOP5wNiffTRRygoKMCIESPQs2dPuLq6QktLC2vXrsWJEyfg7u6OVatWYd68eRg9ejSKi4sxatQo0bFVyuTJk9GsWTNMnToVPj4+yM7Oxty5c/Hrr79ixowZ8Pf3R2hoKH7++WeMHDkSWVlZmDx5sujYaufNN9/EhAkTEBwcjH379omOo1JsbW3x4MEDPHz4UHQUtWRtbY2//vqrVNugQYOwbt26MvvfunWrzNXhiFTZihUrEBISIjqGWsjMzHzlEuV37txBTEyMkhIRoD6vAYmUG3fUWnPnzkVoaCgiIyPlli78t1OnTuHTTz+VfeBWmSv/qXw2Njallkp6se/TihUrMGLECLn+Hh4eAID9+/crLaOqy8nJwdixY5GYmIi6deuiY8eOMDc3l91hlJ2djZSUFMTFxSE3Nxc2NjbYtWtXmUtZUdXdvXsXGzZswLFjx5CVlVXqMU1NTXTo0AHvvfdemfsGUvVs27YNK1euxK5du9C5c+dy+0mlUsyfPx+BgYGQSCR8H1AQjr94KSkpGDZsGAoKCiCRSCCVStGwYUPs27cPo0aNgqamJtq1a4fHjx8jLi4OJSUl2LJli8pfTatMkZGR8PLyQm5uLt58802Ympri6tWrshV/XpBKpRg4cCB+/PHHCu3lRVVTUlKCn3/+GT/99BMsLS2xfPlyeHh4wN3dHUuXLhUdT+XwfEw8ng+IFxoaitWrV+P27dto2bIl5s+fj86dO+PUqVP44osvkJ2dDeD5ecGHH34od7c1Vd/du3fh6emJv/76q9y9qKVSKXR0dDBnzhyMHTtWyQlVl42NDTw9PeX2gCXl2blzJ5YvX45ffvkFPXv2fGX/jRs3IiIighdCK0hwcDAOHz6MdevWvXIZ4aSkJDg7O2P69Ol8zZDKqEgBcdasWXB0dJTVBgDA2dm5JmOpndjYWHzzzTe4ceMGAKBdu3b44osvyvyszsfHB76+vjwnUxC+Bv6HxfZa7NixY/Dy8sLixYvx3nvvvbRveHg4PD09UVxczF8kCuLj41Nmu42NDfr161eqLTk5GYMGDcKYMWOwcOFCZcRTG/n5+di0aRP8/Pxw//79MvuYmJjA3d0dH374oWzvKKoZaWlpePToEUpKSmBgYIDmzZtXat8WqpyMjAzs2rUL77zzjtzvnf+SSqXw8fHBnTt34O3traSEqo3j/3q4dOkSfHx8ZB/yz5w5E2+99Rbi4+Px2WefIT09HcDzPQPnzJlT6o97UgxedPX6SUxMxNy5c3Hjxg2UlJTAzc2NxfYawPOx1wPPB15fmZmZuHDhAoqKivDOO++gUaNGoiOprGfPnuHo0aMICQnB1atX8fDhQ9k5maWlJRwdHeHq6gpTU1PRUVVKQEAAWrVqJbd1ERHJy83NRWZmJoyMjPheTCrjvzfjvcqLm/V4PqA4t27dgqurK54+fQoLCwtoa2vj77//hqamJry8vDB16tRS/VlsVyy+Bv6HxfZarLi4GKmpqahbt26FTlpv3bqFf/75B/b29kpIR//24g/KevXq8S6KGpScnIyUlBTZ3RMGBgYwNzfnElVERGqquLgYt27dQlFREVq2bMmLf5SAF129PoqKivDLL78gISEB3bp1w/vvvy86ksrh+djrh+cDRERERKQsNjY2eOONNzB69Gi88cYbco9LpVL4+vqidevW6NOnj6ydqzsozty5cxEUFITVq1fL7paOj4/H3LlzkZycjI8++ggzZ86U9WexXbH4GvgfFtuJiIiIiIiIiIiIiIiIKigkJARLliyBvr4+li9fDgcHB7k+NjY23NarBvXq1QvW1tb45ZdfSrXn5OTgk08+QUxMDKZMmYJZs2YBYLFd0fga+B8t0QGoZoWFhaFZs2Zc0oqIakxRURGuX78OTU1NWFtbl7t0TGJiIhITEzF8+HDlBiQiIiIiohpz9+5dBAQEICYmpsyVBezt7TFs2DA0bdpUcFL1kpGRgStXrqCgoADNmjVD27ZtoaGhITqW2rG3t8fw4cPx5Zdfio6i8u7du4fo6Ogyfw/Z2dmhSZMmghOqrvDwcKSmpqJly5ZwdHQE8HyVz59//hnR0dHQ0tJCz549MWHCBK56RSrF2dkZ9vb2WLhwISZMmIBRo0Zhzpw5Zd7hSzXjn3/+gYuLi1y7vr4+Nm3ahI8//hibNm1CSUkJPv/8cwEJVRtfA//DYruKmz59Ojw8PLBkyRLRUVQW/6AUj3MgzpEjR/D111/jyZMnAJ7vh/n555+X+UdOaGgofH19WWwXJC0tDRMmTIBEIkFoaKjoOGqH4/96OHDgAOLi4uDt7S06ilri+IvHORCL4y8e50Dxtm3bhtWrV6OwsBAA8MYbb8i2TsvMzMSdO3dw9uxZbNiwAbNmzcKECRMEplU90dHRuHDhAqZMmSIrpOfk5OCrr77C0aNH8e/FLE1NTbFixQrY2dmJiquWnjx5gvz8fNExVFpqaiqWLFmCyMhIAMB/F3F9cUOAk5MTFi5cCHNzc6VnVFXFxcWYNm0aIiMjZfvwjhw5EkuWLMGUKVMQFxcn6xsXF4eIiAhs376dF/6QSmnYsCF+/vln+Pv7w9vbG6dPn8ayZcvQtWtX0dHUQv369ZGTk1PmY7q6uvj5558xbdo0/PrrrygpKVHLInBN42vgORbba7H4+PgK9Xv48GGpvu3ataupSGqFf1CKxzkQKz4+HrNnz4aGhga6du0KbW1tnDlzBnPmzEFsbCy++eYb0RHpX4qKipCenl7uygNUszj+r4e4uDgEBgayyCIIx188zoFYHH/xOAeKdeTIEaxcuRIWFhaYNm0anJyc0LBhw1J9/vnnH0RERODnn3/GqlWr0LhxY7z77ruCEqueTZs24eHDh/joo49kbV5eXoiMjETTpk3RrVs3GBgY4MaNG4iIiMCUKVOwb98+WFtbC0ytOl7sDfsqx44dw/nz5wE8L/wePny4JmOplbS0NHh4eCAzMxP29vZwcnKChYWF7KKfnJwcJCcnIyIiAhERERg9ejT2798PMzMzwclVw6FDh/Dnn3/C3t4e/fv3x+nTp3Hw4EHUq1cPN27cwJo1a+Dk5ISMjAx4e3sjMjISBw8ehLu7u+joaqlv377Q0tLC4MGDMX78eLz55puiI6kUV1dXdOnSBQsWLMDkyZPh5uaGuXPnio6l8szNzWXvsWXR0dHBhg0b8PHHH2Pr1q1yf6uS4qj7a4DF9lrMw8PjlR/aSyQSnDhxAidOnJC1cT8KxeAflOJxDsTavHkzNDQ0sH37dnTq1AkAcOfOHcyZMwf79+9HQUEBvL29WVx8TTRv3hxhYWGiY6gtjj8RERGpmm3btqFZs2bw8/OTFbb+q2HDhhgxYgT69euHYcOGYevWrSy2K1BiYiJ69+4t+/rChQuIjIxE37598eOPP5Za2S06OhqTJk2Cr68v1q1bJyKuyrl16xYkEoncndT/JpFI8OTJE9lqcKRYa9asQW5uLjZu3IgePXqU22/q1KkIDw+Hp6cn1qxZgx9++EGJKVXXgQMH0KxZM2zbtg0aGhoYO3YsBg8ejK1bt+Krr76S/b7X19eHj48PevXqhcOHD/NzOUHS09MBAD/99BO2bt2KUaNGYd68eYJTqZYmTZpgy5Yt+O233/Ddd98hIiKCn4vWMCcnJ6xduxaJiYnlbqWsq6srK7ifOXOGc1KD1Pk1wGJ7Laenp4d+/fpBU1NT7jGpVIrAwECYm5ujY8eOAtKpNv5BKR7nQKy4uDj07dtXVmgHgKZNm2Lbtm2YO3cuAgMD8ezZM3z7Gg/MvAABAABJREFU7bdq86b6OtPS0kKzZs1Ex1BbHP+aERgYWKn+KSkpNRNETXH8xeMciMXxF49zINb169cxevTocgvt/2ZgYICBAwdi7969SkimPjIzM1G/fn3Z15cuXYJEIsHnn38ut4Wavb09BgwYgDNnzig7psqytrZGWloaPv/8c7z//vtl9rGxsYG7uzuWLl2q5HTq4cyZM3B2dn5pof2Fnj17YtCgQYiIiFBCMvWQlpaG/v37y1aQlEgk6NKlC5KSkkpdCAQAderUQY8ePTj+AoWFhaGkpAR///03YmJiXno3MFXP+++/j+7du+PLL79Ebm4u6tSpIzqSyho0aBCuX7/+0mI78L8l5b/66ivZhSdUc9TxNcBiey02a9Ys+Pj4IDU1FcuXL4eVlZVcn8DAQNjb2/OP+hrAPyjF4xyIlZmZCQsLC7l2LS0tfP/999DW1kZgYCBKSkrw3XffKT8gEam8efPmVepinhdbjpBicPzF4xyIxfEXj3MglpaWFnJzcyvcPzc3F1pa/BhKkerXr4/79+/Lvn727BkAwMTEpMz+JiYmyMvLU0o2deDn5wcfHx8sX74cx44dw/Lly2Fqaio6llrJy8sr9997WfgaUKwnT57A0NCwVNuLpckbNWok179Ro0bIzs5WRjQqw4sbAMzMzNCnTx/BaVSfmZkZdu7cKTqGyjM3N8fq1asr1FdHRwcrV66s4UT0grq9BniWU4tNnToVvXr1wrx58+Dq6gpPT098+OGH/PBASfgHpXicA7GMjY3x6NGjMh+TSCTw9vaGVCpFUFAQpFIpmjdvruSE6qWwsBCXL19GSkqK7N+5gYEBzM3N0bZtW7k7W0ixOP5iaGtrw8TEBKNGjapQ/6NHj3I7HQXi+IvHORCL4y8e50Cs9u3bIyQkBGPGjHnlHuCJiYk4fPhwqVWxqPrs7Oxw8uRJ5OTkQF9fH23btoVUKkV0dLTcBehSqRQxMTFo0qSJoLSqR1tbG5999hn69u2LuXPnwsXFBbNnz8bYsWNFR1MbzZs3x6lTp+Dl5fXKi3mKiooQHh7OzyYUqF69enj8+LFce3lbK+Tk5KBu3bo1HYuIiEjpWGyv5d5++23s378fGzZswNq1a3H8+HF4e3uXeZc7KRb/oBSPcyDWW2+9hejo6HIfl0gksqsFg4KCOPY15PHjx1izZg2Cg4ORn58P4H+vgRcXX+np6WHo0KHw8vIqtcwkVR/HX6y3334bd+/exdSpUyvUPykpiUUWBeL4i8c5EIvjLx7nQKwZM2bg/fffh4eHB1xcXNC1a1dYWFjAwMAAAJCdnY3k5GRERkbi999/R0lJCWbMmCE4tWqZMmUKjh49iilTpuDbb7+Fvb09evXqhUWLFmHJkiXo2bMnNDU1kZGRgR9//BFXr17FJ598Ijq2ymnXrh2CgoLwww8/YMWKFTh69ChWrFjBoq4SeHh4YPny5Zg0aRK8vLzQsWNHuZuQpFIpzp8/j7Vr1+LGjRtYsGCBoLSqx9zcHElJSaXapk2bhsmTJ5fZPz09vVIrERDVVtevX8fOnTtx5coVPH36FM2aNYOzszNGjBjBGyWV7PHjx7hy5Qq0tLTQoUMHtVjOnMRgsV0FaGlpYcaMGejTpw/mzp2LESNG4JNPPsGUKVNER1Np/INSPM6BWN27d8fKlSsRGxuLzp07l9nnRcFdIpEgMDCQf1Aq2KNHjzB69GikpqbCzMxM9gHni30zc3JykJycjDNnzmDv3r2y/zcyMhKcXDVw/MWztbXF1atXcffuXd6lJQDHXzzOgVgcf/E4B2K1a9cOmzdvxqJFi+Dn54eDBw+W2U8qlcLMzAzLli1D27ZtlZxStdnY2GD58uVYuHAhBg4ciNatW6Nx48Z4/Pgxpk+fDk1NTdSpUwe5ubmQSqXo0KFDhS9OocrR0dHB/Pnz0a9fP8yfP192sS3VrLFjx+LatWvw8/PD2LFjoaenB1NT01IX/dy+fRv5+fmQSqVwd3fnygMKZGtri3379qG4uFi2soC2tja0tbXl+j59+hTnz5/H4MGDlR1Tpdna2qJ79+5wc3ND7969oampKTqSWlmyZAmOHDmCyMhI2TanISEhmDt3LoqKimT9kpKSEBkZiT/++AM//fSTrC8pRlRUFL7//nukpqbi7bffxvz589G6dWscPnwYixYtkt0cY2hoiBUrVqBv376CE6unW7duYfDgwZBIJLh69aroOArHYrsKsbW1hb+/P9auXYt169bhjz/+YGGrBvEPSvE4B2INGjQIDx8+RGZm5kv7vVhSvlmzZrhz545ywqmJNWvWIC0tDV9//TVGjx790r579uzBkiVLsGbNGixZskRJCVUbx1+8zp07488//0RycnKFiiwdO3ZUQir1wfEXj3MgFsdfPM6BeI6Ojjh69CjOnTuH6OhoJCcnIycnBwCgr68PCwsL2NnZoUuXLiwA1JDhw4ejRYsW+PHHH3HmzBlcuXJF9lhxcTFycnLQtGlTjB49GhMmTOD2RjXMzs4OwcHBWLlyJVatWiU6jsqTSCRYtmwZhgwZggMHDiA6OhrXr18v1cfY2Bi9e/eGh4cHHBwcBCVVTbNnz8a0adNeuYQ/8PwGmIkTJ8ptcUHV8+zZM4SHhyM8PBwNGjTA8OHD4ebmBgsLC9HR1EJMTAzs7OxkxfPMzEwsXLgQurq6+PLLL9GnTx8YGhri77//xvr16xEeHo5t27Zh0qRJgpOrjuTkZEyZMgWFhYWoV68eYmJiMGXKFGzatAnz58/HW2+9BQcHB2RkZCA0NBQzZ85EUFAQ3nrrLdHR1ZJUKi13VeLaTiJV1Z9MzV24cAHz5s1DSkoK3N3dsXTpUtGRVE5hYSFyc3MrtCTwzZs3ceTIEfTu3Ru2trZKSKceOAek7rp3744OHTpg3bp1Fer/6aef4sKFC4iIiKjhZOqB409EREREr5Ps7Gz89ddfePToEUpKSmBgYABLS0suZy5IVFQUEhMT8fbbb6NLly6i46iN/Px8ZGdnAwAMDAygp6cnOBFRzbGxsUGvXr0AABEREXj27BkkEgk6d+6MkSNHYtCgQdDV1RUbUoV17NgRo0ePxpw5cwAAhw4dwpw5c/D9999jyJAhpfoWFRXB1dUVABAcHKz0rKpqwYIFCAoKwubNm+Ho6IgLFy7ggw8+QJMmTWBpaQlfX1/ZBZ8RERGYMmUKRo8eja+//lpscFI5vLNdRXXo0AEhISHIy8vjVcs1REdHp8Jja2VlBU9PzxpOpH44B6TusrKyKnW1srm5OU6dOlVjedQNx5+IiIiIXicGBgZwdHQUHYP+n4ODA++kFkBPT48FdlIrbdq0gaenJ+7fvw9/f38cPHgQMTExiI2NxfLlyzFkyBC4ubnx5iMluHfvHiQSiewCiH/T1tZGly5dsHfvXuUHU2FxcXHo3r277O+fDh06oFevXjh+/Di+//77Uisrde/eHZ07d0ZUVJSouKTCuDmECtPU1ISBgQGvXiMiUlFNmjRBdHR0hfvHxMRwP1MF4vgTEREREdHLeHt748iRI6JjENWIQ4cO4cGDB6Jj0P8zMTHBtGnTcPz4cezYsQNDhgxBUVER9uzZAzc3N4wYMQK7d++WrfxA1WdpaYmLFy/KvjYyMgLw/OaMsjx58oQXAynY3bt3YWVlVartxY0xLVq0kOtvbW2Nu3fvKiMaqRkW24mIqMalpaWhb9++6Nevn+goKsXFxQUXL17EF1988dI/FO/evYvPP/8cly5dwtChQ5WYULVx/ImIiIgqhucDNevu3bv46aefMHHiRPTp0wd2dnaws7NDnz59MHHiRGzYsAF37twRHVMtbd++HWfOnBEdQ+VdvnwZW7duxY4dO3Djxo1y+4WGhmL+/PlKTKba5syZg969e2P69Ok4efIkSkpKREei/2dvb4/vvvsOf/75JxYtWoRWrVohISEBS5cuRY8ePUTHUxlDhgzBhQsXEBISAgDo27cv6tatCx8fH7m+169fx7Fjx/DOO+8oO6ZK09bWRnFxcam2FyvhlnVhg56eHn9X1ZB79+7h0KFDWL9+PVasWIEVK1Zg/fr1OHTokFpc4MBl5NVEWloaJkyYAIlEgtDQUNFx1A7HXzzOgVhFRUVIT0+HRCIRHUWlTJ06FRcuXEBwcDB+//13WFpawtzcHAYGBgCe79mYkpKCpKQkSKVSODk5YerUqYJTqw6Of+3C9wGxOP7icQ7E4viLxzkQi+cDNWfbtm1YvXo1CgsLAQBvvPEG9PX1AQCZmZm4c+cOzp49iw0bNmDWrFmYMGGCwLSqZdOmTRXqd+3atVJ9p0yZUlOR1NKyZcuwe/duAIBUKoWGhgZGjhyJL7/8Uq7QkpiYiMDAQHh7e4uIqpKePXuGsLAwnDhxAsbGxhgxYgTc3NxgZmYmOhoB0NfXx5gxYzBmzBgkJibiwIED+P3330XHUhljx45FSEgIPv/8c0RERGDgwIHw9PTEd999h2vXrqF3794wMDDAzZs3ERwcjOLiYnz88ceiY6uUhg0b4v79+6XaOnToUO7fO/fu3ZOtQECKkZqaiiVLliAyMhLA8/fif3vx97+TkxMWLlwIc3NzpWdUBhbb1QRPbMXi+IvHORCrefPmCAsLEx1D5ejo6GDz5s3w9/fHgQMHEB8fj1u3bpXqo6GhgXfeeQceHh4YMWIEXwMKxPGvXfg+IBbHXzzOgVgcf/E4B2LxfKBmHDlyBCtXroSFhQWmTZsGJycnNGzYsFSff/75BxEREfj555+xatUqNG7cGO+++66gxKrlhx9+gEQikftQ+d8kEgni4+MRHx8v+5rFdsU5fPgwdu3ahaZNm2L06NHQ0tJCQEAADhw4gKtXr2LLli2oV6+e6Jgq7aOPPkLr1q1x4MABREZG4pdffsHGjRthb28Pd3d3DBgwQHaXKYllY2ODRYsWYe7cuaKjqAxtbW38+uuvmD9/PgICAhAYGAjgebExISEBCQkJsq/r16+PpUuXokOHDgITq55WrVrh0qVLpdq6deuGbt26ldn/2rVrcsvOU9WlpaXBw8MDmZmZsLe3h5OTEywsLGQXfubk5CA5ORkRERGIiIjA6NGjsX//fpW8IEsifdlfhKQyiouLkZGRAQBo1qyZ4DTqh+MvHueA1EFhYSFSU1Nl+28ZGBjAzMwMurq6gpOpB47/643vA2Jx/MXjHIjF8RePc0CqaNSoUfjnn38QFBQk+1CzPNnZ2Rg2bBiMjY2xb98+JSVUba1atYKenh4++ugjmJiYyD0ulUrx5Zdfws7ODq6urrL2ESNGKDOmShs3bhyuX7+OI0eOyO5ULCkpwZo1a7Bx40bY2Nhg69atqF+/PgDAx8cHvr6+sgIYVY+NjQ08PT3h6ekJAMjIyICfnx/8/f1lF7gZGhrCxcUFbm5usLGxEZxY9fx3DkicS5cu4fDhw7h69SoePnyIkpISGBgYwNLSEo6Ojhg4cOAr36up8k6fPo3Tp09jzpw5r7yw58qVK3Bzc8OsWbO48qSCzJ49G3/88Qd8fX1fuUVFeHg4PD09MWDAAPzwww9KSqg8LLYTERERERERERHVMh06dMDo0aMrfJfiqlWrsHfvXly4cKGGk6mHCxcuYN68eXj8+DHmz59fZhHdxsYG7u7uWLp0qYCEqs/Ozg4DBw7EsmXL5B7bs2cPlixZgpYtW2L79u2oX78+i+0K9rJC79mzZ+Hn54fQ0FAUFBRAIpHA1tYW7u7uGDVqlIC0qik9PR2Ghoay7eyIiJSpS5cu6NGjB1atWlWh/nPmzEFERATOnj1bw8mUj8vIExFRtRUWFuLy5ctISUkpdVevubk52rZtyyXDiIiIiIhUGM8HxNDS0kJubm6F++fm5kJLix8FKkqHDh0QFBSE7777Dl9++SWOHDmCpUuXolGjRqKjqY3CwkI0aNCgzMfee+89aGlp4auvvsL48eOxfft2JadTb126dEGXLl3w5MkTBAUFwc/PD1euXMFff/3FYrsCcbUeIhIpLy+vzNV9ymNiYoK8vLwaTCQO/8JWETyxFYvjLx7nQIzHjx9jzZo1CA4ORn5+PgDI9qt7sR+mnp4ehg4dCi8vL9nSbVR9kydPhpeXF9q1a1fp5+bl5WHXrl2oW7cuxowZUwPpVB/H//XD9wGxOP7icQ7E4viLxzkQg+cDYrVv3x4hISEYM2YMrK2tX9o3MTERhw8fRqdOnZSUTj3UqVMHixYtQv/+/fHll19iyJAhmDNnDtzd3UVHUwuNGzdGWlpauY+7u7tDKpVi8eLF+OCDD/jvXwBDQ0OMGzcO48aNw5UrV3Dw4EHRkYgUJiMjgxdYkVpr3rw5Tp06BS8vr1de0FlUVITw8HA0b95cSemUi8X2Wo4ntmJx/MXjHIjz6NEjjB49GqmpqTAzM0PXrl1hYWEh238oJycHycnJOHPmDPbu3Sv7/xf7qFH1PH78GKNGjULnzp0xfPhwDBgw4JXLhl28eBGHDh3C4cOHUVBQgJUrVyoprerh+L8++D4gFsdfPM6BWBx/8TgH4vB8QLwZM2bg/fffh4eHB1xcXGRz8OLv0uzsbCQnJyMyMhK///47SkpKMGPGDMGpVZOjoyOCg4OxYsUKLFq0CEePHuXS8UrQqlUrnD17FsXFxeV+yO/h4QEAWLx4MW7cuKHMePQfbdq0QZs2bUTHUBsJCQmIi4tDXl4emjVrhh49enDPcAXr2bMnWrZsCTc3NwwdOpR/Z9YCGzduxJ9//okdO3aIjqISPDw8sHz5ckyaNAleXl7o2LGj7BzsBalUivPnz2Pt2rW4ceMGFixYIChtzeKe7bVYZU5s09LS0Lx5c57YKhDHXzzOgVhfffUVDhw4gMWLF2P06NEv7ftirzR3d3csWbJESQlVX0BAAHx8fJCeng4NDQ1YWlrC1tYWDRo0gKGhIQoKCpCVlYWkpCRcuXIFubm50NTUhLOzM2bOnImmTZuK/hFqNY6/eHwfEIvjLx7nQCyOv3icA7F4PvB6OHfuHBYtWoS0tDS5DzdfkEqlMDMzw7Jly+Dg4KDkhOonPDwcixYtQk5ODvLz8+Hm5sbCew0JCgrC3Llz8d1338HFxeWlfQ8cOICvvvoKALhnu4KMGzcOI0eOxPDhw0VHUVs+Pj5wcHCAnZ2drC0/Px9z587F8ePHATx/D5BIJKhXrx5WrlyJXr16CUqremxsbAA8v8BTW1sbffv2hbu7O7p27So4GZVn/vz5CAwM5PuAgkilUixatAh+fn6QSCTQ09ODqalpqQs/b9++jfz8fEilUri7u6vs30QsttdiPLEVi+MvHudArO7du6NDhw5Yt25dhfp/+umnuHDhAiIiImo4mXqRSqUIDw+Hv78/oqKikJWVJddHQ0MD1tbW6NevH9zd3Su1lw69HMdfLL4PiMXxF49zIBbHXzzOgVg8H3h9PHv2DOfOnUN0dDSSk5ORk5MDANDX14eFhQXs7OzQpUsXaGpqCk6qPp48eQJvb28kJCRgwIAB+OSTT0RHUkn5+fmIjY2FsbGxrOj1MufOncPdu3cxYsQIJaQjqnk2Njbw9PSEp6enrG3OnDk4dOgQLC0tMWzYMNSvXx8XL15EUFAQtLW1ERgYCEtLS4GpVYeNjQ2GDh0KQ0NDBAcHIysrCxKJBE2aNMHIkSMxcuRING7cWHRM+hcW22vGuXPncODAAURHR+PBgwelHjM2Noa9vT08PDxU+qJPLiNfi508eRL9+/d/5YcKAPDee+/h7NmzOHnypBKSqQeOv3icA7GysrJgYWFR4f7m5uY4depUjeVRVxKJBL169ZJdmXzz5k3cu3cPmZmZ0NXVhZGREVq2bPnKJc6pajj+YvF9QCyOv3icA7E4/uJxDsTi+cDrQ1NTE926dUO3bt1ER6H/Z2hoCG9vb9ExVJ6enh66d+9e4f6Ojo41mIZIvLS0NAQHB6N9+/bYtm0b6tSpAwAYNWoUevfujU8//RRbt27lhYcK1Lx5c3h6emLOnDk4duwY/Pz8EB0dDR8fH/z000/o1q0b3N3d0bt371fuaU2V5+PjU6n+LLLXDEdHR9l7bH5+PrKzswEABgYG0NPTExlNafjqrsV4YisWx188zoFYTZo0QXR0dIX7x8TEoEmTJjWYiADAysoKVlZWomOoLY6/cvF9QCyOv3icA7E4/uJxDsTi+QAREf1bRkYGkpOTSxVZLCws0KhRI8HJ1EdUVBQAYObMmbJC+wsDBgxAp06dcO7cORHRVJ6Ojg5cXFzg4uKC27dvw8/PD4GBgTh9+jQiIiJgZGSEYcOGwc3NDW+99ZbouCrDx8cHEokElVnAu7xtd0gx9PT01KbA/m8sttdiPLEVi+MvHudALBcXF/j4+OCLL77ArFmzyh3bu3fv4ocffsClS5dKLWtFRFRdfB8Qi+MvHudALI6/eJwDsXg+QPTc3bt3ERAQgJiYGKSkpJQqNJqbm8Pe3h7Dhg1D06ZNBSdVXZwDcQoLC7Ft2zb4+fkhLS2tzD6mpqbw8PDABx98AB0dHSUnVC8PHz4EANja2pb5eOvWrbF//35lRlJLpqammDlzJry8vHD69Gn4+fnh5MmT2LJlC7Zt24arV6+Kjqgy9PT0YGJiAi8vrwr137NnD2JjY2s4FQFAaGgowsLC1GalHxbbazGe2IrF8RePcyDW1KlTceHCBQQHB+P333+HpaUlzM3NZctlZ2dnIyUlBUlJSZBKpXBycsLUqVMFpyYiVcL3AbE4/uJxDsTi+IvHORCL5wO1S1paGiZMmACJRILQ0FDRcVTGtm3bsHr1ahQWFgIA3njjDejr6wMAMjMzcefOHZw9exYbNmzArFmzMGHCBIFpVRPnQJy8vDxMmDAB8fHxeOONN9CtWzdYWFigbt26AIDc3FwkJycjLi4Oq1evRmhoKLZu3Yo33nhDcHLV9eLffnl37mpqakJDQ0OZkdSaRCJBz5490bNnTzx69AiBgYE4ePCg6FgqxcbGBjdu3ICzs3OF+kdERLDYriSJiYkIDAxUm2K7RFqZ9RXotVJYWIiPP/4YkZGRkEgkFTqx3bBhA7S1tQUnVw0cf/E4B+JJpVL4+/vjwIEDiI+PR0lJSanHNTQ00K5dO3h4eGDEiBFcpoeIFIrvA2Jx/MXjHIjF8RePcyAezwdqj1u3bsHZ2RkSiYT7lSrIkSNH8Nlnn8HCwgLTpk2Dk5MTGjZsWKrPP//8g4iICPz8889ITU3Fjz/+iHfffVdQYtXDORDr22+/xZYtWzBlyhR88skn5S4bnJ+fD19fX2zevBmTJ0/GF198oeSkqsvGxgatWrWCjY0NAOD+/fs4c+YM/P390apVK7n+M2fORHx8PE6cOKHsqCrJxsYGnp6evJhToGXLlmH37t04duwYmjdv/sr+8+fPR2BgIP8WUgIfHx/4+vqqzViz2F7L8cRWLI6/eJyD10dhYSFSU1NLLddmZmYGXV1dwcmISJXxfUAsjr94nAOxOP7icQ5eHzwfeL0VFxcjIyMDANCsWTPBaVTDqFGj8M8//yAoKEh2N2l5srOzMWzYMBgbG2Pfvn1KSqj6OAdi9enTB2+99RY2b95cof6TJ09GUlISC70K9KLI/l/Tp0/HjBkz5Np79eqFt99+Gxs3bqzpaGqBxXbxXizPP3PmTHTq1OmV/UNDQ5GYmMg5UwIW26nW4omtWBx/8TgHRETqje8DYnH8xeMciMXxF49zQETK1KFDB4wePRpz586tUP9Vq1Zh7969uHDhQg0nUx+cA7Hatm2LiRMnYtasWRXqv3r1amzduhWXL1+u4WTqIz09vcx2PT09GBkZlWpLSEjAihUrMGzYMLi5uSkjHhGpMXUrtnPPdhWio6ODFi1aiI6htjj+4nEOiIjUG98HxOL4i8c5EIvjLx7ngIiUSUtLC7m5uRXun5ubCy0tfhSrSJwDsYyNjStVRPnrr79gbGxcg4nUT2VWKmnVqhV27txZg2mIiP7H3t5edASl0hAdgIiIap/JkycjPj6+Ss/Ny8vDxo0bsXv3bgWnIiIiIiIiZeD5wOunsLAQ58+fh7+/P7Zv347t27fD398f58+fR2Fhoeh4Kql9+/YICQnBtWvXXtk3MTERhw8fRocOHZSQTH1wDsTq378//vzzT/z44494+vRpuf2ePn2K1atX48yZMxgwYIASExIpX0lJCbKzs5GdnS23vRGROrG3t1er5fq5jHwtNXnyZHh5eaFdu3aVfm5eXh527dqFunXrYsyYMTWQTvVx/MXjHIjl6uqKhIQEdO7cGcOHD8eAAQNgYGDw0udcvHgRhw4dwuHDh1FQUICVK1fi3XffVVJiIlI1fB8Qi+MvHudALI6/eJwDsXg+8Pp4/Pgx1qxZg+DgYOTn5wMAXnzUJ5FIADxfTnjo0KHw8vJC/fr1hWVVNfHx8Xj//fehqakJFxcXdO3aFRYWFrLXQnZ2NpKTkxEZGYnff/8dJSUl+O2339C2bVvByVUH50CsnJwcjB07FomJiahbty46duwIc3PzUuOfkpKCuLg45ObmwsbGBrt27YK+vr7g5Orj2bNnSElJgba2NszMzETHUVmXLl3C/v37ERMTg/T0dFmRXSKRwNTUFPb29nBzc0P79u3FBiWiGsNiey3FE1uxOP7icQ7ECwgIgI+PD9LT06GhoQFLS0vY2tqiQYMGMDQ0REFBAbKyspCUlIQrV64gNzcXmpqacHZ2xsyZM9G0aVPRPwIR1WJ8HxCL4y8e50Asjr94nAPxeD4g3qNHjzB69GikpqbCzMxMVmh8UcjKyclBcnIyzpw5g7S0NDRv3hx79+6V28eXqu7cuXNYtGgR0tLSZBc3/JdUKoWZmRmWLVsGBwcHJSdUfZwDsfLz87Fp0yb4+fnh/v37ZfYxMTGBu7s7PvzwQ+jp6Sk5oeq7efMm1q9fj9TUVLz99tuYMWMGmjVrhqioKMydOxcZGRkAAAsLC6xatapKFypS+ZYtW4bdu3dDKpVCT08Ppqampd6Hb9++jfz8fEgkEowdOxYLFiwQnFh93bp1C4MHD4ZEIsHVq1dFx6n1ePFzaSy212I8sRWL4y8e50A8qVSK8PBw+Pv7IyoqCllZWXJ9NDQ0YG1tjX79+sHd3R0mJiYCkhKRKuL7gFgcf/E4B2Jx/MXjHIjH8wGxvvrqKxw4cACLFy/G6NGjX9p3z549WLJkCdzd3bFkyRIlJVQPz549w7lz5xAdHY3k5GTk5OQAAPT19WFhYQE7Ozt06dIFmpqagpOqLs7B6yE5ORkpKSnIzs4GABgYGMDc3BwWFhZig6mwjIwMuLi44MmTJ7K25s2b49dff4Wrqyt0dXXRvn173L9/H/Hx8TA0NERwcDAaNWokMLXq2LNnD7755ht07twZXl5e6NSpEzQ0Su/cXFJSgtjYWKxduxZxcXEVes+mmnHr1i04OzsDeL61CFUPL34ujcX2Wo4ntmJx/MXjHLxebt68iXv37iEzMxO6urowMjJCy5YtX/lGS0RUVXwfEIvjLx7nQCyOv3icg9cLzweUq3v37ujQoQPWrVtXof6ffvopLly4gIiIiBpORkREyuDt7Y0dO3Zg2bJlGDhwIE6dOoW5c+eidevW0NTUxObNm2V3Wfv5+WHhwoWYOHEi5s6dKzi5ahg2bBhKSkoQEBAALS2tl/YtKiqCq6srNDQ0EBQUpKSERDWLFz//D4vtKoYntmJx/MXjHBARqTe+D4jF8RePcyAWx188zgGpk3bt2mHChAmYNWtWhfr/8MMP2L59O+Lj42s4GRGpq5KSEuTm5gIA6tatK3eXLynWkCFDYGxsjK1bt8rapk6dioiICGzfvh329val+ru6uqKoqAjBwcHKjqqS3nnnHYwfPx6zZ8+uUP/vv/8eO3fuxKVLl2o4GZHy8OLn515+uQ3VOlZWVrCyshIdQ21x/MXjHBARqTe+D4jF8RePcyAWx188zgGpkyZNmiA6OrrC/WNiYtCkSZMaTERE6ujSpUvYv38/YmJikJ6ejpKSEgCARCKBqakp7O3t4ebmhvbt24sNqoLS09PRvXv3Um0tW7ZEREQEWrduLde/bdu2LLQrkJ6eHh48eFDh/g8ePICenl4NJiJSPolEgl69eqFXr14A1PfiZxbbiYiIiIiIiIiIahkXFxf4+Pjgiy++wKxZs8otpN+9exc//PADLl26BE9PTyWnJABIS0vDhAkTIJFIEBoaKjqOWuIc1Ixly5Zh9+7dkEql0NPTw1tvvSVbtjwnJwe3b9+Gn58fDh48iLFjx2LBggWCE6sWiUQCiURSqu1FMffFPPxbvXr1UFRUpJRs6sDBwQEhISEYMmQInJycXtr39OnTCAkJQd++fZWUTv3cu3cP0dHRSElJQXZ2NgDAwMAA5ubmsLOz4wWHSqKuFz+z2E5ERERERERERFTLTJ06FRcuXEBwcDB+//13WFpawtzcXHbnUHZ2NlJSUpCUlASpVAonJydMnTpVcGr1VFRUhPT0dLmiGCkP50Dx9uzZg127dqFz587w8vJCp06d5JaNLykpQWxsLNauXYtdu3bBysoKo0ePFpRY9TRo0EDuzmorKyv079+/zP4ZGRl48803lZBMPXz22WeIjIzElClT4OjoiK5du8LCwqLUBSfJycmIjIxEVFQUDAwMMHPmTLGhVVBqaiqWLFmCyMhIAM+XNf+3F7/3nZycsHDhQpibmys9I6k+7tlORERERERERERUC0mlUvj7++PAgQOIj4+XLd/8goaGBtq1awcPDw+MGDGChUZBiouLkZGRAQBo1qyZ4DTqiXOgeMOGDUNJSQkCAgKgpfXye/qKiorg6uoKDQ0NBAUFKSmh6vP09MStW7cQEhJSof7u7u6oU6cOdu7cWcPJ1MeNGzfw9ddfIzY2FgDk3mdflN/s7OywePFitGjRQukZVVlaWhrc3d2RmZkJe3t7ODk5lXnBQ0REBGJiYlC/fn3s378fZmZmgpOTquGd7URERERERERERLWQRCLByJEjMXLkSBQWFiI1NbXU0qlmZmbQ1dUVnJK0tLRY4BWMc6B4ycnJGD9+/CsL7QCgra2Nnj17ssirYAMHDsThw4dRWFgIHR2dl/ZNSkrClStXMH36dCWlUw8tWrTArl27kJycjOjoaCQnJyMnJwfA86X8LSwsYGdnB0tLS8FJVdOaNWuQm5uLjRs3okePHuX2mzp1KsLDw+Hp6Yk1a9bghx9+UGJKUgcsthMREREREREREdVyOjo6vGOOiJRGT09Pbgnzl3nw4IFsP3FSDBcXF7i4uFSor4mJCUJDQ2FkZFTDqdSThYUFLCwsRMdQO2fOnIGzs/NLC+0v9OzZE4MGDUJERIQSkpG6YbGdiIiIiIiIiIiIqIoKCwtx+fJlpKSklFpZwNzcHG3btn3lHadUfZwD5XNwcEBISAiGDBkCJyenl/Y9ffo0QkJC0LdvXyWlo/+qW7cu6tatKzoGkULl5eXBxMSkwv1NTEyQl5dXg4lIXXHPdiIiIiIiIiIiolpk8uTJ8PLyQrt27Sr93Ly8POzatQt169bFmDFjaiCd+nj8+DHWrFmD4OBg5OfnA/jf/rwv9u3V09PD0KFD4eXlhfr16wvLqqo4B+IkJyfDzc0Nubm5cHR0RNeuXcvcKzkyMhJRUVEwMDDA/v37efdvDSspKUFubi6A5wV2DQ0NwYmIas6LlR0CAgJeuaVFUVERXF1dAQDBwcE1no3UC4vtREREREREREREtYirqysSEhLQuXNnDB8+HAMGDICBgcFLn3Px4kUcOnQIhw8fRkFBAVauXIl3331XSYlVz6NHjzB69GikpqbCzMys3ELjmTNnkJaWhubNm2Pv3r1cwlmBOAfi3bhxA19//TViY2MB/O8ChxdelB7s7OywePFibnVRQy5duoT9+/cjJiYG6enpKCkpAfB8PkxNTWFvbw83Nze0b99ebFA1duvWLQwePBgSiQRXr14VHUdl7Ny5E8uXL4e9vT28vLzQsWPHMn8PnT9/HmvXrkVsbCwWLFiAsWPHCkpMqorFdiIiIiIiIiIiolomICAAPj4+SE9Ph4aGBiwtLWFra4sGDRrA0NAQBQUFyMrKQlJSEq5cuYLc3FxoamrC2dkZM2fORNOmTUX/CLXaV199hQMHDmDx4sUYPXr0S/vu2bMHS5Ysgbu7O5YsWaKkhKqPc/D6SE5ORnR0NJKTk5GTkwMA0NfXh4WFBezs7GBpaSk4oepatmwZdu/eDalUCj09PZiampa64OT27dvIz8+HRCLB2LFjsWDBAsGJ1dOtW7fg7OwMAEhMTBScRnVIpVIsWrQIfn5+kEgkstfAiwsQs7OzZa8BqVQKd3d3LF26VHBqUkUsthMREREREREREdVCUqkU4eHh8Pf3R1RUFLKysuT6aGhowNraGv369YO7u3ul9jal8nXv3h0dOnTAunXrKtT/008/xYULFxAREVHDydQH54DU3Z49e/DNN9+gc+fO8PLyQqdOneSWjS8pKUFsbCzWrl2LuLi4Cl2cQlTbnDt3DgcOHEB0dDQePHhQ6jFjY2PY29vDw8MDDg4OghKSqnv5JgZERERERERERET0WpJIJOjVqxd69eoFALh58ybu3buHzMxM6OrqwsjICC1btnzlEvNUeVlZWZXae9rc3BynTp2qsTzqiHNA6m7v3r1o2bIltm3bVu5+1RoaGrC3t8e2bdvg6uqKPXv2sNhOKsfR0RGOjo4AgPz8fGRnZwMADAwMoKenJzIaqQkW24mIiIiIiIiIiFSAlZUVrKysRMdQC02aNEF0dHSF+8fExKBJkyY1mEj9cA5I3SUnJ2P8+PHlFtr/TVtbGz179sTOnTuVkIxIHD09PRbYSek0Xt2FiIiIiIiIiIiIiF5wcXHBxYsX8cUXX+Du3bvl9rt79y4+//xzXLp0CUOHDlViQtXHOag9bt26hVatWqF169aio6gUPT09uSWzX+bBgwcsQtaQe/fu4dChQ1i/fj1WrFiBFStWYP369Th06NBLfz9RzQkNDcX8+fNFxyA1wTvbiYiIiIiIiIiIiCph6tSpuHDhAoKDg/H777/D0tIS5ubmsiX7s7OzkZKSgqSkJEilUjg5OWHq1KmCU6sWzkHtIpVKIZVKRcdQKQ4ODggJCcGQIUPg5OT00r6nT59GSEgI+vbtq6R06iE1NRVLlixBZGQkAMj9G5dIJAAAJycnLFy4EObm5krPqK4SExMRGBgIb29v0VFIDUikfIcjIiIiIiIiIiIiqhSpVAp/f38cOHAA8fHxKCkpKfW4hoYG2rVrBw8PD4wYMUJWdCHF4RyQOktOToabmxtyc3Ph6OiIrl27wsLCAvr6+gCAnJwcJCcnIzIyElFRUTAwMMD+/fthYWEhNriKSEtLg7u7OzIzM2Fvbw8nJ6cyxz8iIgIxMTGoX78+9u/fDzMzM8HJ1YOPjw98fX2RkJAgOgqpARbbiYiIiIiIiIiIiKqhsLAQqampyM7OBgAYGBjAzMwMurq6gpOpD84BqaMbN27g66+/RmxsLADIXVDyovxjZ2eHxYsXo0WLFkrPqKpmz56NP/74A76+vujRo8dL+4aHh8PT0xMDBgzADz/8oKSE6o3FdlImLiNPREREREREREREVA06OjosYgnGOSB11KJFC+zatQvJycmIjo5GcnIycnJyAAD6+vqwsLCAnZ0dLC0tBSdVPWfOnIGzs/MrC+0A0LNnTwwaNAgRERFKSEZEysZiOxERERERERERERERVcm9e/cQHR2NlJSUUisLmJubw87ODk2aNBGcUPVZWFhweXgly8vLg4mJSYX7m5iYIC8vrwYT0b/Z29uLjkBqhMvIExEREREREREREVXQ5MmT4eXlhXbt2lX6uXl5edi1axfq1q2LMWPG1EA69cA5eD2kpqZiyZIliIyMBPC/JctfeLGkuZOTExYuXAhzc3OlZySqKS4uLgCAgIAAaGm9/L7WoqIiuLq6AgCCg4NrPBsRKRfvbCciIiIiIiIiIiKqoMePH2PUqFHo3Lkzhg8fjgEDBsDAwOClz7l48SIOHTqEw4cPo6CgACtXrlRSWtXEORAvLS0NHh4eyMzMhL29PZycnGBhYQF9fX0AQE5ODpKTkxEREYGIiAiMHj0a+/fvh5mZmeDkRIrh4eGB5cuXY9KkSfDy8kLHjh1lF5i8IJVKcf78eaxduxY3btzAggULBKUloprEO9uJiIiIiIiIiIiIKiEgIAA+Pj5IT0+HhoYGLC0tYWtriwYNGsDQ0BAFBQXIyspCUlISrly5gtzcXGhqasLZ2RkzZ85E06ZNRf8ItR7nQKzZs2fjjz/+gK+v7yv3rA4PD4enpycGDBiAH374QUkJ6d9u3bqFwYMHQyKR4OrVq6LjqASpVIpFixbBz88PEokEenp6MDU1lV34k52djdu3byM/Px9SqRTu7u5YunSp4NSqgyuc0OuExXYiIiIiIiIiIiKiSpJKpQgPD4e/vz+ioqKQlZUl10dDQwPW1tbo168f3N3dK7W/L70a50CcLl26oEePHli1alWF+s+ZMwcRERE4e/ZsDSejsty6dQvOzs4AgMTERMFpVMu5c+dw4MABREdH48GDB6UeMzY2hr29PTw8PODg4CAooWpydXVFQkJCtVc4effdd5WUmFQZi+1ERERERERERERE1XTz5k3cu3cPmZmZ0NXVhZGREVq2bPnKD/9JcTgHyvPOO+9g/PjxmD17doX6f//999i5cycuXbpUw8mIxMnPz0d2djYAwMDAAHp6eoITqTaucEKvCxbbiYiIiIiIiIiIiIiowlxcXAA8L3ZpaWm9tG9RURFcXV0BAMHBwTWejYjUB1c4odcBi+1ERERERERERERERFRhO3fuxPLly2Fvbw8vLy907NgREomkVB+pVIrz589j7dq1iI2NxYIFCzB27FhBiYmUJzQ0FGFhYfD29hYdRe1whRMSgcV2IiIiIiIiIiIiIiKqMKlUikWLFsHPzw8SiQR6enowNTWVFbSys7Nx+/Zt5OfnQyqVwt3dHUuXLhWcWnXdu3cP0dHRSElJKbWMubm5Oezs7NCkSRPBCdWLj48PfH19kZCQIDoKESnBy9d3ISIiIiIiIiIiIiIi+heJRIJly5ZhyJAhOHDgAKKjo3H9+vVSfYyNjdG7d294eHjAwcFBUFLVlpqaiiVLliAyMhLA84sg/u3FagNOTk5YuHAhzM3NlZ6RiEjVsdhORERERERERERERESV5ujoCEdHRwBAfn5+qbuq9fT0REZTeWlpafDw8EBmZibs7e3h5OQECwsL6OvrAwBycnKQnJyMiIgIREREYPTo0di/fz/MzMwEJyciUi0sthMRERERERERERERUbXo6emxwK5Ea9asQW5uLjZu3IgePXqU22/q1KkIDw+Hp6cn1qxZgx9++EGJKYmIVB+L7UREREREREREREREpBChoaEICwuDt7e36Cgq7cyZM3B2dn5pof2Fnj17YtCgQYiIiFBCMrK3txcdgYiUSEN0ACIiIiIiIiIiIiIiUg2JiYkIDAwUHUPl5eXlwcTEpML9TUxMkJeXV4OJ6AV7e3t4enqKjkFESsJiOxERERERERERERERUS3SvHlznDp1CsXFxa/sW1RUhPDwcDRv3lwJyYiI1AuL7URERERERERERERERLWIh4cH/v77b0yaNAnnz5+HVCqV6yOVShEbG4tJkybhxo0bGDVqlICkqmfy5MmIj4+v0nPz8vKwceNG7N69W8GpiEgU7tlORERERERERERERERUi4wdOxbXrl2Dn58fxo4dCz09PZiamsLAwAAAkJ2djdu3byM/Px9SqRTu7u4YO3as4NSq4fHjxxg1ahQ6d+6M4cOHY8CAAbJxL8/Fixdx6NAhHD58GAUFBVi5cqWS0hJRTZNIy7rciYiIiIiIiIiIiIiIqJKio6MRHR3NPauV5Ny5czhw4ACio6Px4MGDUo8ZGxvD3t4eHh4ecHBwEJRQNQUEBMDHxwfp6enQ0NCApaUlbG1t0aBBAxgaGqKgoABZWVlISkrClStXkJubC01NTTg7O2PmzJlo2rSp6B+BiBSExXYiIiIiIiIiIiIiIqJaLj8/H9nZ2QAAAwMD6OnpCU6k2qRSKcLDw+Hv74+oqChkZWXJ9dHQ0IC1tTX69esHd3d3mJiYCEhKRDWJxXYiIiIiIiIiIiIiIiKiarh58ybu3buHzMxM6OrqwsjICC1btnzlEvNEVLux2E5ERERERERERERERBUyefJkeHl5oV27dpV+bl5eHnbt2oW6detizJgxNZCOACA0NBRhYWHw9vYWHYWISOVpiA5ARERERERERERERES1w+PHjzFq1CiMGzcOBw8elC1b/jIXL17EkiVL0Lt3b/z0009o0KCBEpKqr8TERAQGBoqOQUSkFnhnOxERERERERERERERVVhAQAB8fHyQnp4ODQ0NWFpawtbWFg0aNIChoSEKCgqQlZWFpKQkXLlyBbm5udDU1ISzszNmzpyJpk2biv4RVJqPjw98fX2RkJAgOgoRkcrTEh2AiIiIiIiIiIiIiIhqjxEjRmD48OEIDw+Hv78/oqKicOjQIbl+GhoasLa2Rr9+/eDu7g4TExMBaYmIiGoOi+1ERERERERERERERFQpEokEvXr1Qq9evQAAN2/exL1795CZmQldXV0YGRmhZcuWMDAwEBuUiIioBrHYTkRERERERERERERE1WJlZQUrKyvRMQiAvb296AhERGqDe7YTERERERERERERERERERFVkoboAERERERERERERERERERERLUNi+1ERERERERERERERES1xOTJkxEfH1+l5+bl5WHjxo3YvXu3glMREakn7tlORERERERERERERERUSzx+/BijRo1C586dMXz4cAwYMAAGBgYvfc7Fixdx6NAhHD58GAUFBVi5cqWS0hIRqTbu2U5ERERERERERERERFSLBAQEwMfHB+np6dDQ0IClpSVsbW3RoEEDGBoaoqCgAFlZWUhKSsKVK1eQm5sLTU1NODs7Y+bMmWjatKnoH4GISCWw2E5ERERERERERERERFTLSKVShIeHw9/fH1FRUcjKypLro6GhAWtra/Tr1w/u7u4wMTERkJSISHWx2E5ERERERERERERERFTL3bx5E/fu3UNmZiZ0dXVhZGSEli1bvnKJeSIiqjoW24mIiIiIiIiIiIiIiIiIiCpJQ3QAIiIiIiIiIiIiIiIiIiKi2obFdiIiIiIiIiIiIiIiIiIiokpisZ2IiIiIiIiIiIiIiIiIiKiSWGwnIiIiIiIiIiIiIiIiIiKqJBbbiYiIiIiIiKhGzZs3D9bW1oiKiirVPm7cOFhbW+P27duCkhERERERERFVHYvtRERERERERFQtffr0gbW1tegYRERERERERErFYjsRERERERER1ahZs2YhJCQE7dq1Ex2FiIiIiIiISGG0RAcgIiIiIiIiItVmYmICExMT0TGIiIiIiIiIFIp3thMREREREREJEhYWhlGjRuGdd96Bg4MDZsyYgaSkJKxfvx7W1tbw9/eX9bW2tkafPn3KPI6/vz+sra2xfv36Uu0pKSlYv349Ro0ahW7duqFNmzbo0aMH5syZg6SkpDKP9eL7PHv2DBs3bsTAgQPRpk0b9OzZE9999x0KCwtlfaOiomBtbY309HTZc1/8799Zy9uz/WUyMzPxww8/wNnZGe3atUOnTp0wfvx4nDx5ssLHICIiIiIiIqpJvLOdiIiIiIiISIA9e/bg66+/hkQiQefOnWFsbIxLly7B3d0dvXv3Vsj3OHDgADZv3oyWLVuibdu20NHRwY0bNxAUFISwsDDs3r0bNjY2ZT539uzZCA8Ph4ODAywtLREbG4vNmzcjIyMD33//PQCgYcOGGDFiBI4dO4a8vDyMGDFC9vz69etXOXdSUhImTpyIu3fvolmzZnByckJubi4uXbqEadOmYc6cOZg8eXKVj09ERERERESkCCy2ExERERERESlZeno6vL29oa2tjQ0bNqB79+4AgKKiIsyfPx+HDh1SyPfp168fRo0aBTMzs1LtBw8exJdffokVK1Zgx44dZearU6cO/vjjDxgbGwMA0tLS4OrqiuDgYHz66ado3rw5rKyssHLlSkRHRyMvLw8rV66sduZnz57h008/xd27d/HFF19g0qRJ0NB4vjBfSkoKJk2ahB9++AHdu3fH22+/Xe3vR0RERERERFRVXEaeiIiIiIiISMkOHjyIgoICDB48WFZoBwBtbW0sWLAAenp6Cvk+7du3lyu0A8DIkSPRsWNHREdHIzs7u8znLly4UFZoBwAzMzMMHToUABAbG6uQfGU5efIkrl+/joEDB+LDDz+UFdoBwNzcHPPmzcOzZ8+wf//+GstAREREREREVBG8s52IiIiIiIhIyV4Uq52dneUeq1+/Prp164bQ0FCFfK/c3FycPHkSCQkJyMrKQnFxMQDgwYMHkEqlSE1Nha2tbannaGtrw8HBQe5YFhYWsufWlD///BMA0L9//zIf79SpEwDg8uXLNZaBiIiIiIiIqCJYbCciIiIiIiJSsvv37wMAmjVrVubj5bVX1tmzZzFr1iw8evSo3D65ublybQ0bNoSmpqZce926dQEAhYWFCslXlvT0dADA559/js8//7zcfo8fP66xDEREREREREQVwWI7ERERERERUS1XUlIi15abm4uZM2ciKysL06dPx+DBg9G0aVPUqVMHEokEs2fPxu+//w6pVCr33H8v3a5sL36W7t27o2HDhuX2q1+/vrIiEREREREREZWJxXYiIiIiIiIiJTM2NkZSUhLS09PRokULucfv3Lkj16atrV3mXegAcO/ePbm22NhYZGZmYuDAgfj000/lHk9LS6tC8prXuHFjAIC7uzsGDhwoOA0RERERERFR+cRdqk5ERERERESkpjp37gwAOHr0qNxjmZmZiIyMlGs3NjZGZmZmmcunnzlzRq7tyZMnAP5XvP63lJQUXL16tdK5y6OtrQ0Asv3gq6Nbt24AgOPHj1f7WEREREREREQ1icV2IiIiIiIiIiVzdXWFjo4OgoODSxXKi4qK4O3tjby8PLnn2NnZAQA2bNhQqn3Tpk04f/68XH8LCwsAz4vW/96z/cmTJ1iwYAGKiooU8aMAAExMTAAASUlJ1T7WgAED0KJFCwQHB8PX11duf3ipVIrz58+X+TMTERERERERKROXkSciIiIiIiJSMjMzM8ybNw9LlizB5MmT0blzZxgbG+PixYt48uQJXFxcEBwcXOo5U6ZMwbFjx7B9+3ZER0ejefPmuHbtGu7du4f3338fv/32W6n+bdu2Rbdu3RAZGYmBAwfC3t4eABAdHY369eujb9++CAsLU8jP06dPH0RHR2PChAlwcHCAnp4e6tevj88//7zSx9LS0oKvry8mT56MdevWYffu3bC2toaRkREyMzORkJCAhw8fYv78+ejUqZNC8hMRERERERFVBe9sJyIiIiIiIhJgzJgx8PX1Rdu2bREfH48///wTNjY22LdvH8zNzeX6t2zZEtu3b4e9vT2Sk5MRGRmJ5s2bY9++fWjbtm2Z3+Onn37CtGnTYGRkhNOnT+Ovv/6Cs7Mz9u3bB0NDQ4X9LOPGjcPHH3+MN954A3/88Qf8/PwQEhJS5eNZWFggMDAQM2fOROPGjXHx4kUcP34cSUlJaNWqFb766isMHTpUYfmJiIiIiIiIqkIilUqlokMQERERERER0f+sX78ePj4+8Pb2hqurq+g4RERERERERFQG3tlORERERERERERERERERERUSSy2ExERERERERERERERERERVRKL7URERERERERERERERERERJXEPduJiIiIiIiIiIiIiIiIiIgqiXe2ExERERERERERERERERERVRKL7URERERERERERERERERERJXEYjsREREREREREREREREREVElsdhORERERERERERERERERERUSSy2ExERERERERERERERERERVRKL7URERERERERERERERERERJXEYjsREREREREREREREREREVElsdhORERERERERERERERERERUSSy2ExERERERERERERERERERVRKL7URERERERERERERERERERJXEYjsREREREREREREREREREVElsdhORERERERERERERERERERUSSy2ExERERERERERERERERERVRKL7URERERERERERERERERERJXEYjsREREREREREREREREREVElsdhORERERERERERERERERERUSSy2ExERERERERERERERERERVRKL7URERERERERERERERERERJXEYjsREREREREREREREREREVElaYkOQERERERERCTauHHjEB0dXaptx44dcHBwEJTo9eHv74/58+eXahsxYgRWrlwpKBFR2aytreXarl27VqHnrl+/Hj4+PqXaPD09MWPGjCrnSUtLw+HDh3Hx4kXcuHEDT548QXZ2NkpKSkr18/X1Rb9+/ar8fYiIiIiISBwW24mIiIiIqFZJS0tDamoq7ty5g9zcXOTn50NbWxuGhoYwNDREw4YNYWNjA319fdFRiYhIDWVlZeGbb77BkSNH5ArrRERERESkWlhsJyIiIiKi11pWVhbCwsJw/PhxxMXFITMz85XPkUgksLS0RLt27dC/f3/06NEDOjo6NR+WiIjU2oMHDzB69Gjcvn1bdBQiIiIiIlICFtuJiIiIiOi1dOfOHWzatAkBAQHIz8+v1HOlUilu3bqFW7duITAwEG+++SYGDRqEyZMnw8zMrIYSE4mVkZEht2R2o0aNylxam4hqxqxZs6pVaL927RoyMjJKtVlbW6NRo0bVjUZERERERDWAxXYiIiIiInqtFBcXY+PGjfjll1/w9OlThRwzMzMTe/bsgZ+fH9577z18/PHHMDIyUsixiV4XkZGR3FudSKAzZ84gOjparv3tt9/G8OHD0bJlS+jr60NDQ6PU45aWlrL/3rp1KwICAko97u3tDVdX15oJTURERERE1cJiOxERERERvTbu37+Pzz77DLGxsa/sa2RkhCZNmqBu3brQ1NREXl4e7t+/j4yMjHL3yC0qKsKOHTtw/fp1bN++XdHxiYhIje3fv1+urW/fvli3bh20tPgRHBERERGRKuJf+kRERERE9FpIS0vDhAkTyl1+t06dOhg4cCAGDBiAjh07lntnen5+Pi5evIjIyEiEhIQgPT1drk95xXgikufq6sq7aknlzZgxAzNmzKjWMc6fPy/XNmfOHBbaiYiIiIhUGP/aJyIiIiIi4R4+fIgPPvigzMK4pqYmxo4di2nTplVo6Xc9PT106dIFXbp0wezZs3HixAn8/PPPiI+Pr4noRERE+Oeff3D//v1SbSYmJrCwsBATiIiIiIiIlILFdiIiIiIiEqq4uBiffPJJmYV2Y2NjrF+/Hh06dKjSsSUSCfr27Ys+ffogKCgI3t7eyMzMrGZiIiKi0h4/fizX1rhxYwFJiIiIiIhImTREByAiIiIiIvW2YcMGXLx4Ua69cePG2LNnT5UL7f8mkUgwfPhwBAUFoVOnTtU+HhER0b9lZ2fLtdWpU0dAEiIiIiIiUiYW24mIiIiISJjU1FT88ssvcu2amppYv349zMzMFPr9GjdujG3btmHw4MEKPS4REam3oqIi0RGIiIiIiEgALiNPRERERETCrF27tswCxZQpU9CuXbsa+Z46OjoYPXp0jRz7dZCSkoKEhATcu3cP+fn50NPTQ5MmTfDOO+9UeknjoqIiJCYm4u+//8bjx4/x7NkzGBkZoVmzZujUqRN0dHRq6KdQDSUlJbh9+zZu3bqF+/fvIycnBwUFBTAwMEC9evXQsGFDtG3bFvr6+qKjqr38/HxcvXoVaWlpePToEZ4+fQpDQ0M0aNAAjRs3Rtu2baGlxY9QqqO4uBhXr17FzZs38ejRIxQUFEBfXx9mZmZ45513YGRkJDoiERERERFRpUmkUqlUdAgiIiIiIlI/GRkZ6N27N549e1aqvVmzZjh27Bi0tbUFJQPWr18PHx+fUm2enp6YMWNGlY53+/Zt9O3bt1Rbs2bNcOLECYU8Nz8/H3v27MG+ffuQnJxc7rE6d+6M6dOno2vXri/9nunp6di0aROOHDlS7h73devWxcCBAzFr1iwYGxu/8uf4L39/f8yfP79U24gRI7By5cpKH+sFa2trubZr165V6Lnjxo1DdHR0qbYdO3bAwcGhUhni4+MRERGB6OhoXLx4EU+fPn1pfw0NDdjY2KB///4YM2YM6tWrV6nvV9bPXFXljVVl5+r06dOYMmVKqbY33ngDkZGReOONN6qdc+/evVi8eHGpNlNTU4SGhkIikVT4OAUFBTh06BAOHTqEuLg4FBcXl9vXwMAAXbt2xahRo9CtW7cqZ1cERf1bfaE6r8WKPDctLQ2bN2/GkSNHkJWVVeZxNDQ0YGdnh4kTJ6J3795V+Cmeq87vgMr+3lfUa2/Hjh0YP368Qo5lb2+PnTt3KuRYRERERERUMbwsm4iIiIiIhPDz85MrtAPAqFGjhBbaa5u4uDh88cUXuH379iv7xsbGYuLEiXjvvfewaNEiaGpqlnpcKpVi69atWL169SuXRM7NzYW/vz/++OMPfPvtt3IXBKibDRs24ODBg0hLS6vU80pKSnD16lVcvXoVmzdvxpQpUzBt2rRKFY1fN926dYOxsTEePHgga8vLy8Mff/yB4cOHV/v4gYGBcm3Dhw+v8JhJpVL4+/tj9erV+Oeffyr0nOzsbBw7dgzHjh1Djx49MH/+fLz11luVia2Wtm7dih9//BEFBQUv7VdSUoKoqChERUWhR48eWLlyJRo0aKCklERERERERFXHPduJiIiIiEiI48ePy7Vpa2vDzc1NQJra6cSJE/jggw8qVGj/tz179sjdjfrs2TPMmzcPq1atqtTewzk5OfDy8sKpU6cqlUHV7Nmzp9KF9v/Kzc3FmjVr8MknnyAnJ0dByZRPU1MTQ4cOlWsvq0heWUlJSbhw4UKpNolEUuEifk5ODqZPn44vv/yywoX2/zp9+jRGjRqF2NjYKj1fXSxbtgwrV658ZaH9v06fPg13d3ekpKTUUDIiIiIiIiLFYbGdiIiIiIiU7v79+0hISJBrt7e3592MFRQfH4+ZM2eisLCwVPuL/dnt7e3x1ltvlXu3b1BQEPbu3Sv7eunSpXLFUG1tbVhZWcHe3h4dOnQod7n4oqIizJ07F48ePareD6WCNDU1YWZmBltbWzg4OMDOzg42NjYvXU79xIkTmDt3rhJTKp6rq6tcW1RUFO7evVut45ZVsO/cuTPMzMxe+dysrCx88MEHCAsLK7fPm2++iVatWsHR0RFt27ZFw4YNy+z35MkTTJo0CWfOnKlwdnWybdu2MpczNzExQbt27WRzpqFR9sdS6enpmDhxYpUviCAiIiIiIlIWLiNPRERERERKFx8fX2Z727ZtlZykdiooKMDs2bNld4zq6elhwoQJcHV1RfPmzUv1ffDgAbZu3Yrt27fL7Un9448/YsiQIQgNDcWePXtk7VZWVpg+fTp69uwJfX19WbtUKsWlS5ewatUqxMXFlTpWZmYmVq9ejWXLlin6x61VdHR0YG9vjz59+qB9+/Zo2bIldHR05PqVlJTg+vXrCA4Oxt69e+XuZA8NDcWuXbswduzYl36/ffv2yf771KlT2LBhQ6nHe/bsiU8++aQaP1HVtGjRAm3atMGVK1dkbSUlJQgKCsK0adOqdEypVIpDhw7JtVfkrnapVIo5c+aUyvOCgYEB3n//fQwePBhvv/223AUqiYmJ2L17Nw4ePFhq64uCggJ8/vnnCA4O5kVC/5KUlITDhw/LvtbQ0MB7772HUaNGye1zfv/+fQQHB+Onn36Sew2kp6dj0aJFcv+mXxf/fu0BwF9//YUlS5aUamvdujUWL1780uO0aNGi1LF++uknhIeHl+rz8ccfo1evXq/M9O/f10REREREpBwsthMRERERkdJdvXq1zHYW2yvm33d7WlpaYvPmzTA1NS2zr7GxMebMmYM2bdpg1qxZkEqlsscyMzOxefPmUoX2cePGYf78+XL7uQPPl+tu3749du7cCU9PT5w8ebLU48HBwZg3b55aFnyaNm2K8ePHY9SoUTAwMHhlfw0NDdjY2MDGxgYffPABvvjiC5w7d65Un/Xr18PNzQ116tQp9zjt27eX/fetW7fkHjcyMirVR5lcXV3litsBAQFVLrafO3cOd+7cKdWmp6eHd99995XP3bJlS5lbHXTv3h3fffcd6tevX+5zbWxssHTpUowYMQIff/wxMjMzZY89fPgQCxYswM8//1zhn0PVXbx4Ufbf9erVw4YNG9CpU6cy+5qYmGDy5MlwdnbG9OnT8ddff5V6/MSJEwgJCYGzs3NNRq6S/76uylouX19fv0Kvv3/3MTIyknu8efPmwl7HRERERET0clxGnoiIiIiIlK68va1bt26t5CS1W+PGjfHbb7+VW2j/N2dn5zL30d6wYYOsePj+++9j4cKFZRba/01LSwsrVqyAoaFhqfanT5/iyJEjFf8BVMiePXvw4YcfVqjQ/l8mJib45Zdf5IppmZmZZd7JXVsMHjwY2trapdqSk5NLFWMro6wl5Pv37//KizvS0tLw448/yrUPGjQImzZtemmh/d86duyI7du3Q1dXt1T7yZMny7xjXt3p6uri559/LrfQ/m9NmjTBpk2b5FbmAIBVq1bJrcpBRERERET0umCxnYiIiIiIlO7evXtltle06EXPrVy5ssy7IMszceLEch976623MG/evAofy8jICMOGDZNrj42NrfAxVMl/lx6vrDp16uCbb76Raw8ODq7WcUV688030adPH7n2gICASh8rLy8Pf/zxh1x7WXvD/9f27dtRVFRUqq1ly5ZYtWpVpefNxsYGs2bNKvN7UGlTp05Fx44dK9y/QYMGZW5Dce/evTJXJSAiIiIiInodsNhORERERERK9+TJE7k2bW1t6OnpCUhTO3Xs2BFdunSp1HNatWqFJk2alPnYhx9+KHfH7qv07dtXrq28LQLo1WxsbORWd7h8+XKpfcJrm7L2Uz9y5AgKCwsrdZw//vgDeXl5pdqaNGkCBweHlz4vMzMTBw8elGufM2dOpf+9v/Dee+/J7dF+5MgRuXzqzNjYGB9++GGln+fg4FDmBRr/3R+diIiIiIjodcFiOxERERERKd3Tp0/l2tRxn+/qGDlyZJWeZ21tLdemo6ODIUOGKORYSUlJVcpFz7Vt27bU1/n5+bh27ZqgNNXXo0cPucJ0VlYWTpw4UanjlHU3/LBhw6Ch8fKPNU6ePClXBLewsECPHj0q9f3/TVdXFwMHDizVVlRUhEuXLlX5mKrGxcUFderUqdJz3dzc5NrOnj1b6Qs0iIiIiIiIlIHFdiIiIiIiUrqy7tTV0dERkKT26ty5c5We17RpU7k2W1vbKt3la2RkJLcaQVFREQoKCqqUjVDmtgCpqakCkiiGlpYWXFxc5NrL2n+9PHfu3EFUVJRc+4gRI1753JiYGLm2AQMGVPh7l6es19+FCxeqfVxVMWjQoCo/t0ePHnIXXxUVFXHVDCIiIiIiei1piQ5ARERERETqp6zCbnZ2toAktZOWlhYsLCyq9Ny6devKtVlZWVU5S926dZGfn1+qLTs7u8pLdKuKwsJCREZG4vLly7h27RqSk5ORnZ2NnJwc5OXlQSqVVvhYtf21MWLECGzbtq1UW0REBB4+fCh313tZgoKC5MarQ4cOFXoNxMbGyrW1adPmlc97lWbNmsm11eYVCBRJW1sbNjY21X7+f+cuPj4e7du3r2Y6IiIiIiIixWKxnYiIiIiIlK6svdnz8vLw7NkzaGpqCkhUuxgaGlb5uWUVwevVq6fQ46nzne137tzBhg0bcPToUTx58kQhx1TUcUSxsbFBq1atkJCQIGsrLi5GcHAwJkyY8Mrnl3UXfEXuai8sLERKSopce35+Pi5evPjK57/MnTt35NqysrKqdUxVYWlpWe2VSsoqtqelpVXrmERERERERDWBxXYiIiIiIlK6hg0bltmenZ2NN998U7lhaqGyLlZ4nY5Xmbu2VcmmTZvg6+srd6d/dSn6eCKMGDGiVLEdeL4P+6uK7RcuXEBycnKpNl1dXTg7O7/yez5+/LjM9rlz577yuVXBYvtzxsbG1T5GWe8RtX2FByIiIiIiUk3cs52IiIiIiJSuSZMmZbbfvn1byUmIFGPZsmX4/vvva6QwrgoXL7i4uEBbW7tUW2JiIhITE1/6vICAALm2fv36wcDA4JXfU9nFbxaDn/vvfuuKOgYvZiAiIiIiotcR72wnIiIiIiKla9GiRZnt8fHxCtlPmUiZdu7ciZ07d5b5mLa2Nlq1aoV33nkHzZo1Q6NGjVC3bl3o6upCV1cXEomkVP8DBw7Az89PGbGVysjICD169EBYWFip9oCAAMyfP7/M5xQWFuLIkSNy7RVZQh5Q/vL7JSUlSv1+r6uytpaorDp16si1PX36tNrHJSIiIiIiUjQW24mIiIiISOnKK6hfvnxZyUmIqufhw4dYu3atXHudOnXwySefYNSoUZXaGuHkyZMKTPd6GTFihFyx/ffff8cXX3wBLS35jyfCwsLkCuYmJibo2rVrhb5fWcekmpeXl1ftY+Tm5sq1VWQ1AyIiIiIiImXjmScRERERESld69atYWBgILfsckxMDKRSqdzdvrVdcXGx6Agqr6ioSMj3DQoKkvt3rKenh927d8PW1rbSx1P23djK1KtXL9SvX7/UXur//PMP/vzzT/Tq1Uuuf2BgoFzbsGHDoKmpWaHvV95y5iEhIbCysqrQMdSBon8/5eTk1MgxWGwnIiIiIqLXEfdsJyIiIiIipdPW1oaTk5Nce1paGs6ePSsgUWllFfOqU5DKzMysRhrVpCpjfOLECbm2Tz75pEqFdgClCtGqRltbG0OGDJFrL2tf9hdF+P+q6BLyANC4ceMy22v7GJf12nn27FmVj6fo187t27dr5Bj16tWr9nGJiIiIiIgUjcV2IiIiIiISYtiwYWW27927V8lJ5NWtW1eurTpLI2dkZFQnjkpSlTH+66+/5NrK+7ddEVevXq1OnNdeWcXyEydOICsrq1RbcHCw3MUX7dq1q9Qd6fr6+mUW3O/cuVPhY7yOXvfXTnp6erXvbk9MTJRra9myZbWOSUREREREVBNYbCciIiIiIiF69OiBpk2byrWHhYUJLziWtVzxP//8U+XjxcXFVSeOSlKFMc7Ly5MrctatWxeNGjWq0vEePHiAlJSUKuepDdsv2Nra4u233y7VVlhYiJCQkFJtZd3tPnz48Ep/v/bt28u1RUVFVfo4r5OyXjsPHjyo8vEU/dqRSqWIjY2t8vOzsrJw48YNufZ27dpVJ1atURtex0RERERE9D8sthMRERERkRCampr45JNP5NqLi4sxd+5cFBYW1tj3ftUy0iYmJnJt165dq9L3kkqlOHXqVJWeq8rKGuO///4bJSUlVTpeWcu517T/7tUOAG+88UaVj+fn51edONDR0ZFrE7WX/cuUVTT/9/7sCQkJcq83HR0dDB48uNLfq3fv3nJt4eHhNfr7paYp8vdTenp6lZ/7MsHBwVV+7pEjR+T+3RoYGOCtt96qbqxaQVtbW66tOltsEBERERFRzWKxnYiIiIiIhHF1dYW1tbVc+/Xr1/Htt9/WyPc8efIk5s+f/9I+rVu3lmu7desW7t69W+nvFxYWhuTk5Eo/T9VZWFjILYedl5dXpbtsExMTcfbsWUVFq7Cy7jDOzMysUiE3Ly8Pe/bsqVaespYXz8/Pr9Yxa8LQoUPl9h2/ePEikpKSAJR9V3vv3r3x5ptvVvp79evXT+4CiAcPHmDfvn2VPtbroqzfT2fOnKnSsbZv316t/d7LExoainv37lX6eSUlJfjtt9/k2gcNGqQ2d3wrepsAIiIiIiKqWSy2ExERERGRMJqamvj222/LvJNv586d+P777yGVShXyvQoLC/Htt9/i448/Rm5u7kv7GhkZoVmzZqXapFJppe88zsrKwvLlyyudVR1IJBLY2trKtVd2jAsLC/Hll18qKlalvPHGG9DX1y/VVlRUVKXCv7e3d7X3zjY0NJRrS09Pr9Yxa4KxsTGcnJzk2gMDA1FcXIzff/9d7rGy9nqvCH19fXh4eMi1r1u3Djdv3qzSMUVr06aNXFtKSkqll8e/dOkSdu/erahYpTx9+rRKF0zt27evzDvty5pDVVWvXj25ttfxdUxERERERM+x2E5ERERERELZ2Njgq6++KvOxTZs2Ydq0adUuQoaHh8PFxQW//vprhYv3AwcOlGv79ddfZXffvkpOTg5mzJiBO3fuVCqrOilrjAMDAxETE1Oh5xcVFWH+/Pn466+/FB2twjp37izXtn79+kot375lyxbs37+/2llatGgh13bz5k3k5ORU+9iKVlbx/NChQwgPD8fDhw9LtTds2BDdu3ev8vf6+OOP5e6Kf/LkCaZMmaKQgntycnKpZfBrmqmpaZkXqixbtqzCKxncvHkTXl5eNbo8+eHDh7Fz584K979w4QJWrVol196hQwe0bdtWkdFea2W9ji9evKj8IEREREREVCEsthMRERERkXAeHh5l7t8OAKdOncK7776LVatWIS0trcLHzMnJgb+/P1xdXTF16tRKL+Xu5uYm15afn48JEybg8uXLL31udHQ03nvvPdmdpnp6epX63urCxcUFurq6pdqkUik+/vhjREREvPS5CQkJ+OCDD2R3QYsa4379+sm1Xb58GbNnz37lCgrZ2dlYsmRJqQLjf5dXrwxDQ0OYmZmVaisqKsIvv/xS5WPWlL59+8rdwXvnzh2sWLFCrq+Liwu0tLSq/L3efPPNMleYSE9Px8iRI7Ft27ZKL7efm5uLo0ePYtq0aXj33XertUd5VZT1++n69ev46KOPcP/+/XKf9+zZM/j5+eG9996TbYuh6NfOv5d7X758OXx8fF5Z1D927Bg++ugjuXnQ0tLC119/rdB8r7uytgmIj4/H6dOnBaQhIiIiIqJXqfrZKhERERERkQJ5eXlBT08Pq1evlrv7PC8vD1u2bMGWLVvQqlUrdOrUCVZWVmjatCnq1q0LDQ0N5Ofn4/79+0hKSsLFixdx8eLFKu2d/YKVlRWGDx8ud8fqvXv34OHhgd69e6Nnz55o1qwZdHR08OjRI9y4cQPh4eGIj4+X9dfQ0MCCBQuwcOHCKmdRVfXq1cOHH34IX1/fUu3Z2dn48MMP4ejoiL59+8Lc3Bx169bF48ePkZycjIiICERHR5f6d7Jo0SIhy8kPGzYMGzZskFvm+dixY7h06RLGjBkDJycnNG/eHLq6unj06BFSU1Nx4sQJBAUFlbqL28jICAMGDMDevXurnGfgwIHYvHlzqbaNGzfi4sWL6NevHywsLKCvr19mUb99+/ZV/r6VpaOjA2dnZ7l96m/fvi3Xt6pLyP9bv3794OXlhbVr15Zqz8/Ph7e3N3766Sc4Ozujc+fOaNWqFerXrw9DQ0MUFhYiJycHWVlZuHnzJq5du4bLly8jKiqqWr9fqmvkyJHYsWOH3EobUVFRGDhwIAYPHgwHBwcYGxtDKpXi4cOHuHTpEk6ePFnqoqWGDRvigw8+wA8//KCwbH379sXly5eRkZEBqVSK9evX48iRIxg5ciScnJzQuHFj6Ojo4P79+4iLi0NQUFC5e85/+OGHsLGxUVi22qBp06Zo165dqfcR4PkKDe+++y4cHR3RrFkz6Onpye1jr6+vX+ad8UREREREVHNYbCciIiIiotfG1KlTYW1tjXnz5uHRo0dl9klISEBCQkKVv4e+vj4GDRpUob5ffvklzp49K7eMfUlJCcLCwhAWFvbKY3z11Vfo0qVLlbKqg2nTpiEsLAyJiYlyj507dw7nzp175TGmTPk/9u47Psvq/v/460pCgCSMsPcSUJThYk8RUHAB1lm17tFKXW1/2vbbof22ftuqdeJeOKo4UEAUcLEEXIATVIYCCghhhpXk/P64gBCZgey8no9HHnCda9znDsnhvq/3fT7nMk4//fRiCduTk5P561//yhVXXEF2dnaefT/88AO33XbbfgWZycnJ3HHHHftdQn9Pzj77bEaMGMHmzZvztM+cOZOZM2fu9dzdrZVdmIYMGbJL2P5Thx9+OIceemiBPN4vf/lLEhISuOOOO3bZt2bNGp599tl99qekqFixIn//+985//zzd5k1npmZyciRIxk5cuRer5GSksLw4cP5+uuvC7RvVapU4d///jcXX3zxjuUUvv76a/7v//5vt2Xi96Rnz54MGzasQPtWWlxwwQX85je/ydOWlZXFmDFjdlTz2J1OnTrlq3S/JEmSpINnGXlJkiRJJUrv3r0ZN24c5557LhUqVCiw6yYnJ3PBBRcwYcIEzj333P06p1q1aowYMYKGDRvm+/EqVKjA3//+d84555x8n1ueJCcn89hjj+22dPK+RFHENddcs0soVdR69uzJn//85wMuAZ+amso999xDly5dDrovjRs3LpYPHRyIDh060KJFi70eUxCz2nd25ZVX8sADD1CrVq0CvW5BjlX76+ijj+buu+/eZSmG/VG7dm2eeOIJ2rdvXwg9i0Pf22+/neTk5AM6//jjj+fee+89qOUDSrNTTjmFk046qbi7IUmSJGk/GLZLkiRJKnGqV6/On//8ZyZOnMjll19OgwYNDvha7du3509/+hOTJk3iD3/4AzVq1MjX+U2bNuW5555j6NChJCTs31uoY489lhdffJHTTz/9QLpc7tSoUYMRI0Zw0UUX7XdoeeihhzJixAh++ctfFnLv9s9ZZ53FI488Qv369fN1XqdOnXjhhRfo3bt3gfXl7LPP5t5776Vu3boFds3CsrcwvUKFCpx88skF/ph9+vThjTfe4Morr6R69eoHfJ0KFSrQq1cv7rjjjl3K0xeVvn378uyzz3Lsscfu1/GJiYkMHTqU0aNHF1rQvt2AAQN4+umnad269X6fk5aWxk033cS99957QB8iKEv+9a9/cc0115CSklLcXZEkSZK0F1H46WKIkiRJklQCffbZZ3z44Yd88sknfPfddyxdupR169axefNmKlSoQNWqValWrRq1atXi8MMPp127dnTo0OGggvqfmj9/PhMnTmTq1KksXryYVatWsXXrVtLS0mjWrBlHHXUUAwcOLPQQqyz7/vvvmTBhApMnT2bhwoWsWrWKTZs2kZqaSqNGjejQoQMDBgwosaX5t2zZwquvvsq4ceP46KOPyMzMzLM/iiIaN25Mt27dOO200zj66KPz7J8zZ84uazW3b9/+gH6msrOzmTJlClOnTuWLL75g8eLFrF+/nszMzF1Kj0PRl5EHWLFixR7XqK9Xrx5nnHFGoT7+pk2beOedd3jnnXeYNWsWixYtIicnZ7fH1qlThxYtWnD44YfTpUsXOnbsWKKC0Pfff5+3336bmTNnsnz5cjIyMgBIT0+nZcuWdOnShZNOOumAKnXsyUsvvcRNN92Up23IkCHceuutO7ZzcnKYMGECo0ePZubMmaxZsybP8QkJCbRp04YTTzyRn/3sZ/n+QFRJ8eWXX/Kvf/0rT9uhhx7K7373u4O67oYNG3jjjTf46KOP+PLLL/nhhx/IzMxk48aNu/ysWkZekiRJKnqG7ZIkSZIkFYKsrCxWrlxJRkYG2dnZpKSkUL9+fSpVqlTcXdMebN26lWXLlrF+/Xq2bNlC5cqVSU1NpXr16iUqWC8p9ids/6kVK1awatUqtmzZQmpqKg0bNiz3s9glSZIklV7lc/ErSZIkSZIKWVJSEnXr1i0V5dwVq1ChAo0aNSrubpRptWvXpnbt2sXdDUmSJEkqEK7ZLkmSJEmSJEmSJElSPhm2S5IkSZIkSZIkSZKUT4btkiRJkiRJkiRJkiTlk2G7JEmSJEmSJEmSJEn5ZNguSZIkSZIkSZIkSVI+GbZLkiRJkiRJkiRJkpRPhu2SJEmSJEmSJEmSJOWTYbskSZIkSZIkSZIkSflk2C5JkiRJkiRJkiRJUj5FIYRQ3J0oyTIyMoq7C2VWtWrVWLNmTXF3Q5LKFcdeSSp6jr2SVPQceyWp6Dn2SlLRc+wtXOnp6fs8xpntKjYJCf74SVJRc+yVpKLn2CtJRc+xV5KKnmOvJBU9x97i57+AJEmSJEmSJEmSJEn5ZNguSZIkSZIkSZIkSVI+GbZLkiRJkiRJkiRJkpRPhu2SJEmSJEmSJEmSJOWTYbskSZIkSZIkSZIkSflk2C5JkiRJkiRJkiRJUj4ZtkuSJEmSJEmSJEmSlE+G7ZIkSZIkSZIkSZIk5ZNhuyRJkiRJkiRJkiRJ+WTYLkmSJEmSJEmSJElSPhm2S5IkSZIkSZIkSZKUT4btkiRJkiRJkiRJkiTlk2G7JEmSJEmSJEmSJEn5ZNguSZIkSZIkSZIkSVI+GbZLkiRJkiRJkiRJkpRPhu2SJEmSJEmSJEmSJOWTYbskSZIkSZIkSZKkEmvMmDF06dKFMWPG5GkfPHgwgwcP3uX4lStXcvPNN3PqqafSrVs3unTpwrp16w748bt06cJVV111wOdr9/L771oSJRV3ByRJkiRJkiRJkqSyZOnSpQwdOhSAGjVq8Oqrr5KUtGsst2DBAs455xwA6tWrx6hRo4qym2XWLbfcwowZM+jfvz+NGzcGIDk5eUeA6/e5aGz/PRg0aBB/+tOfirs7hcKwXZIkSZIkSZIkSSoEiYmJrFq1imnTptGrV69d9o8ePZqEBAtRH6h77rlnl7atW7cyc+ZMOnbsyM0331wMvdL+6tOnD23btqVWrVrF3ZUD5m+vJEmSJEmSJEmSVAjat29PWlraLmWyAbKysnj99dfp2LHjbme9a98aNWpEo0aN8rStXLmSnJycUh3glhdpaWk0a9aMtLS04u7KATNslyRJkiRJkiRJkgpBxYoV6d+/P1OnTmXVqlV59m1vO/nkk/d4fgiB0aNHc9lll9G3b1969+7NhRdeyOjRo3c5dsWKFTz00ENccsklDBw4kJ49ezJ48GD++c9/7vLYADfffDNdunRh6dKlPPfcc5x11lk7znn44YfJycnZr+f44Ycf0qVLFx566KFd9i1dupQuXbrsMsN8+5rc69at49Zbb2XQoEH06tWLCy64gPHjx+/X4+58ne2uuuqqHduvvfYaXbp02fH4Xbp04YcffuCHH37Y0b6nfu/J8uXL+Z//+R9OOOEEevfuzWWXXcbMmTPzHPPnP/+ZLl268Nlnn+32Gg8++CBdunTZ7+c5a9YsrrrqKvr06cOAAQP4wx/+wLJly7jqqqs49NBD8xy787/pTz300EN06dKFDz/8cEfb1q1bef7557nmmms49dRT6dmzJwMHDuT//b//x9y5c3e5xs5rrM+YMYPLLruM3r17M2DAAG6++WbWrFmT59jtSyns/G+xcx/2tGb7nuTn96Go+DEZSZIkSZIkSZIkFakQAps2FXcv9qxSJYiiqECudfLJJ/Pyyy8zbtw4fv7zn+9oHz16NFWrVqV3797ccsstu5wXQuDPf/4z48ePp3HjxpxwwgkkJSUxc+ZM/vd//5cFCxbw61//esfxs2bN4plnnuHYY4/liCOOICkpiXnz5vHSSy8xY8YMnnjiid3OIL777rv5+OOP6d69O507d2bSpEk8/PDDbN26lauuuqpAvge7k5WVxbBhw9i4cSMDBw5k48aNvPnmm/zpT39i9erVnHnmmfm+5kknnUTr1q157rnnaNWq1Y7S/a1bt6Z+/fo899xzAJx11lk7zjn66KP369rr1q3j8ssvp3r16px66qmsXr2aiRMnct111/H3v/+d3r17AzBkyBDeeOMNXn31VY444og818jOzmbMmDFUq1aNPn367PMx33//fa677joSEhLo168ftWrV4oMPPuDyyy+nSpUq+9XvvVm7di3/+c9/6NChA926daNKlSosXbqUyZMnM336dIYPH87hhx++y3mTJ09m2rRp9OjRg3bt2jFr1ixee+01Fi9ezIMPPgjE3/Ozzjprl38LgPr16+e7r/n9fSgqhu2SJEmSJEmSJEkqMiEEfjks8Mmnxd2TPWvXFu67u2AC9yOOOIJDDjmEsWPH7gjbV65cyXvvvcfQoUNJTk7e7XmvvPIK48eP5+STT+bGG2/cUWp+69at3HTTTTzzzDMMGDCAww47DIBjjjmGsWPHkpKSkuc6r732GjfffDMjR47koosu2uVx5s6dy1NPPbWj7PrFF1/MGWecwciRI7n00kupUKHCQX8PdufHH3+kcePGPPTQQzse48ILL+SCCy7gnnvuoU+fPtSpUydf1zz55JN3zNRv1aoVl1122Y59vXv3ZuzYsQB52vfX119/zYABA/jrX/+64+fizDPP5OKLL+bWW2+lc+fOVKpUiSOPPJLmzZszYcIErr32WipXrrzjGtOnT2f58uWcffbZe/x33y4nJ4dbb72V7Oxs7rnnHo488kggb+h8sKpUqcKoUaN2+T7Pnz+fSy+9lOHDh3P33Xfvct6UKVO477776NChAxB/iGDYsGF89NFHfPrpp7Rt25bWrVuTlpa223+LA5Hf34eiYhl5SZIkSZIkSZIkqRCdfPLJzJ8/n08/jT9hMHbsWLKzsznllFP2eM4LL7xA5cqV+c1vfpNnTfcKFSpw5ZVXAuQJXGvUqLFL0A4wcOBAUlNTef/993f7OBdffHGe9c2rV69Oz549yczMZNGiRfl7ovl05ZVX5gnz69Spw5lnnsmWLVuYMGFCoT52fiUmJnLVVVfl+QBGq1atOPHEE8nIyGDatGk72gcPHkxmZuYuz+HVV18F4LTTTtvn482ePZslS5bQvXv3HUE7xB8Aueqqq0hMTDzIZwTJycm7/UBDixYtOProo5k1axZZWVm77D/hhBN2BO0Qf28GDRoEwOeff37Q/dqd/P4+FBVntkuSJEmSJEmSJKnIRFHEfXdTbsrIA5x44once++9jBkzhrZt2zJ27Fhat25N69atd3v8pk2b+Oabb6hVqxYjRozYZf/2APSnYfjbb7/NqFGjmDt3LuvWrSM7O3vHvh9//HG3j/XTdb+BHQHs+vXr9+8JHoDExETatWu3S/v2YHnevHmF9tgHom7durstf37kkUcyevRo5s2bR9++fQEYNGgQ9913H6+88gqnnnoqEFczmDJlCu3ataN58+b7fLyvvvpqx/V/qn79+tSpU4fvv//+IJ5RbN68eTz11FPMnj2blStX7hKur169Os+HMaDof2YO9PehKBi2S5IkSZIkSZIkqUhFUcRO1bXLvPT0dHr06MGECRPo27cvixYt4oYbbtjj8WvXriWEwIoVK3jkkUf2eNzGjRt3/P3pp5/m7rvvJj09nU6dOlGnTh0qVqwIwHPPPceWLVt2e43U1NRd2rbPmt45rC9o1atXJyFh1yLcNWrUAAo36D8Q2/u1p/ad+1ulShWOP/54XnvtNb755psdywhkZ2fv16z2na+Xnp6+x8c92LB9zpw5XH311QB06tSJvn377qiOMGnSJL766qvd/twU9c/Mgfw+FBXDdkmSJEmSJEmSJKmQnXrqqbzzzjvccsstVKxYkRNOOGGPx24PMw877DAef/zxfV47KyuLxx57jFq1avHkk0/mCYZDCDz11FMH3f892R6Y7y5k3bBhwx7PW716NTk5ObsE7qtWrQIgLS2tAHt58Lb3a0/tP+3v0KFDee2113jllVe4/vrrGT16NKmpqfTr12+/Hm/79TIyMva7P/n9t3j88cfZsmUL999//y4z6D/77LMds+uLW35/H4qSa7ZLkiRJkiRJkiRJhaxz587Url2bFStW0KtXL6pWrbrHY1NTU2nWrBkLFy5k3bp1+7z2mjVrWL9+PW3btt1lBvYXX3zB5s2bD7r/e1KlShUAVqxYscu+uXPn7vG87OxsPvnkk13aZ82aBbDHEvsHIzExkZycnAM6d9myZbudSb6n/rZt25aWLVvy+uuvM2PGDL777jtOOOEEKlWqtF+P16pVqzzX39n333/P8uXLd2nP77/FkiVLqFq16i5B+6ZNm/b6b7e/ts92P9Dv+Xb5/X0oSobtkiRJkiRJkiRJUiFLTEzkn//8J//3f//HVVddtc/jzzzzTDZt2sQ//vGP3ZbHXrp0KUuXLgXiUuMVK1Zk7ty5bNq0accxa9eu5bbbbiu4J7EbTZs2JSUlhcmTJ7NmzZod7StXrtznLOT777+frVu37thevnw5zz//PMnJyfTv37/A+1q1alXWrFlzQB8+yM7OZvjw4YQQdrR99dVXvP7666Snp9OtW7ddzhk8eDBr167lb3/7G8B+l5AH6NChAw0aNGDq1Kl5AvcQAsOHD9/t7PXDDz8cgLFjx+Zpf+utt/j44493Ob5evXqsW7eO+fPn53med9111x5n1OdHlSpViKKIZcuWHfS18vP7UJQsIy9JkiRJkiRJkiQVgTZt2tCmTZv9OnbIkCF8+umnvPbaa8yZM4eOHTtSq1YtVq1axaJFi/jss8+4+eabadCgAQkJCZx++uk888wznHfeefTo0YMNGzYwffp06tWrR+3atQvtOVWoUIEzzjiDJ554gl/84hf06tWLzMxMpkyZwlFHHcXixYt3e16tWrXYuHHjjv5u3LiRN998kzVr1nD99ddTp06dAu/rMcccwxdffMF1113HkUceSVJSEkcddRRHHXXUPs9t2bIlc+bM4aKLLqJjx46sXr2aiRMnkp2dzY033rjbGesDBw7k3nvvZcWKFRx22GEceuih+93XhIQEbrzxRq6//np+/etf069fP2rVqsUHH3zAypUradmyJV9//XWec3r27EmjRo0YO3Ysy5Yt49BDD2XhwoV88MEHdOvWjWnTpuU5/owzzmDGjBlcccUVHH/88SQnJ/PRRx+xYsUKjj76aD766KP97u/upKSk0KZNG2bNmsVf/vIXGjduTBRFDBw4kPr16+frWvn5fShKzmyXJEmSJEmSJEmSSpgoivjTn/7E3/72N5o3b87UqVN59tlnmTlzJsnJyQwbNoyOHTvuOP6Xv/wlV155JVEU8dJLL/H+++/Tv39/7rzzzh3lvAvLFVdcwaWXXkoIgZdffnlHKD1s2LA9npOUlMRdd93FUUcdxbhx4xgzZgx16tTh5ptv5swzzyyUfl588cWcdtppfPvttzzxxBM8+OCDfPDBB/t1bpUqVXjwwQdp1KgRr7zyCuPHj6dly5bccccd9O7de7fnpKam7tiXn1nt23Xq1Il77rmHI444gjfffJNRo0ZRv359HnjggR0l43dWqVIl7rrrLnr37s3nn3/OSy+9xObNm7n//vt3+yGPHj168Pe//50GDRrw+uuvM378eJo2bcqjjz5KvXr18t3f3fnLX/5C165dmTp1Kg8//DAPPvjgAc1Az+/vQ1GJws61DrSLgiiRoN1LT0/3+ytJRcyxV5KKnmOvJBU9x15JKnqOvZLyY/DgwQCMGjWqWPtRFH7+85+zdOlSxowZQ2pqaoFd96qrruLjjz9m+vTpBXZN5ZWenr7PYywjL0mSJEmSJElSKRZCICuLHV/Z2ZCVve3v29uz2eWYnBxISYEqVaBKGqSlQVJSVNxPR5LKjGnTpvHNN98wePDgAg3aVXIYtkuSJEmSJEmSypWfhtNZ2dsC6n2E0/k/58BC8Pyck50F2TkF971JSQmkpeUG8FWq7PSVFu3avu3vqWkW0ZWk7V588UWWL1/Oq6++SsWKFbnggguKu0sqJIbtkiRJkiRJkqQit3lz4MeV8OOPsHJV/Oe6dYUfghd0OF1SJSZAYhIkJkJS0ravbX9P3LadEMGGTFi3DjIz4/MyM+Ov5ct3d9W9BeqrqFQpd4Z83pAeqlSJdmynpeWG9FW3tVWs6Ix6SWXHiBEjWLFiBU2aNOEPf/gDDRo0KO4uqZC4Zvs+uMZM4XENH0kqeo69klT0HHslqeg59krFa3uIvnIluWH6yl2D9fXri7uneSUkxGH09iB6d+H0ju2dAuw8YfZezsk9NsrXOdvP29M5O877yeMkJOQvvM7KCmzYEAfv69Zv+3PdTtvrw65t2/6+YQMcbNKQXIG8YfwuM+ujPQb5lStDFBnWSyp/fN1buFyzXZIkSZIkSZJUIDZvDjuC8h1h+o95g/WVK+PwdX8lJ0OtWlCrJtSsCdWqQlKFn4bNewmnE/ceUO8tnE5MzNuW33C6rElKiqhWDapV29MRe/7+5OQEKlSozneLV+8hkI+D+vXrdw3y16+PKw1s2Rp/EGPlqj09yp7T/MREqFIl7DJrfufy91X3EOSnphrUS5IOnGG7JEmSJEmSJJVjO4foubPRdw3WDyREr1lj5zA9yhOs16oZB58GnaVfQkJE1aoJNKgfQf3dHbHnf+MQApmZPwnn8wTyYcf2+vW7BvnblxJYvTr+2sOj7KXvkJYWdoTveWbO/6T8fZWfBPmpqZCY6M+vJJVnhu2SJEmSJEmSVAZtD9FXrtw5NN+pnPu2YD2/Ifr2oLxWre1/j/IE6zVrxoGkIbr2RxRFpKbGwXW93R+xx3NDCGzalBu+r//JrPndlr7f6ZgtWyAnB9aujb/28Ch76TukpoQ8s+jzzqyP8syiT0uDenWhRg1/PySprDBslyRJkiRJkqRSZPPmwKpV/GQN9J3KuW9r23N4uKudQ/SaNbfPRo92CdYN0VWSRFFE5crxmu116uz2iL2ev3lzyBO+r99lZn3YZab99mM2borXqV+/If76/ofdPcLug/qqVaFF80CzZtCieUTzZtCiOVSr5u+WJJU2JTJs37x5M7fffjuffvopixYtYs2aNVStWpXGjRtzxhlncOqpp1KhQoX9ulZOTg5PP/00zz//PIsWLSIlJYVu3bpx3XXX0bhx40J+JpIkSZIkSZK0f7ZsCXnWPt9Rzn1l3mA9XyF6BahZK2+IXrPGT8q51zJEV/lUsWJExYrx78Lu7fl3YuvWsCN4X7tTIL9+56D+JzPt166Lf4/XroVZs+OvnQP5GumB5s2hefPcEL55M0hL83dTkkqqKISw5xooxWTVqlX06dOH9u3b06xZM2rUqMGaNWuYPHkyS5YsoUePHjz00EMkJCTs81p//OMfGTlyJK1ataJ3794sX76ccePGkZqaynPPPUezZs32en5GRkYBPSv9VHp6ut9fSSpijr2SVPQceyWp6Dn2qqTZHqLnXQM95FkP/ceVBxmi725NdEN0FSHH3v2zeXNg0bewYAEsWBiYvwAWLITvv9/zOXVqxwF8PAM+onlzaNYUKlf2d1sq7xx7C1d6evo+jymRM9urV6/OBx98QHJycp72rKwsLrroIqZMmcKkSZPo06fPXq8zffp0Ro4cSceOHXn00Ud3XO/kk0/m8ssv55ZbbuGRRx4prKchSZIkSZIkqQz7aYgeh+Zhp9LuBxii75iBvr18e/STNdLj9Z8N0aXSp2LFiNatoHUr2HnmfGZmHMLPXwALFsQh/MKFsHxF7teMmbDzTPj69QMtdg7hm0GTJvFjSJKKRokM2xMSEnYJ2gGSkpLo378/M2fOZNGiRfu8zsiRIwG45ppr8lyvd+/edOrUiSlTprB06VIaNGhQcJ2XJEmSJEmSVOpt3BhYtAiWLd8emv+knPtKWJOPEL1Chbyz0HcJ0bcF64boUvmUkhLR5jBocxjsHMKvWxdYuGhbCL8wxDPiF8CqjHg2/Pffw9RpsD2ET0iAhg1zQ/jm20P4xpCU5NgiSQWtRIbte5KTk8PkyZMBaN269T6PnzFjBikpKRx99NG77OvZsyczZ85k5syZDB48uKC7KkmSJEmSJKkUyMoKfPsdzJ8P8xfEQdY3C+IAa38W4PxpiB7PSo92CdYN0SUdiCpVItq1hXZtYecQfvXqwIKFeUP4+QviteG/+y7+encSbA/hk5KgcaNtIfy2UvTNm0HDBpCY6NgkSQeqRIftW7Zs4YEHHiCEwOrVq3nvvfeYP38+Q4cOpWvXrns9NzMzkxUrVtC6dWsSExN32d+0aVOA/ZohL0mSJEmSJKl0y8kJ/LBse6geB+vz58O330FW1u7PSU+Pg6jc0DzaMQN9e5hetaohuqSiV716xFFHwlFHwvYQPoTAylXsmP2+85rwmZnxnwsWAm/nfpIoORmaNolD+GbNom1hPNSrCwkJjm2StC8lOmzfunUr99xzz47tKIq4+OKLueGGG/Z57rp16wBIS0vb7f7t7duP25Nq1aqRkJCwv11WPqWnpxd3FySp3HHslaSi59grSUXPsbf8isOmwFdfZfHV19l8/XU2877K5utvsti4cffnpKZGtGqZSMuWibRumUjLlkm0aplIjRreF5Tyw7G3+NWoAa1a5m0LIfD9Dzl88012PC5+k83XX2fxzfxsNm2Cr76Ov3ZeD75yZTikRQKtWibR8pB4fGzZMpG6dRL8gJFUwjj2Fq8SHbanpqYyd+5ccnJyWL58OW+99RZ33HEHs2bN4qGHHtpjkF6Q1qxZU+iPUV6lp6eTkZFR3N2QpHLFsVeSip5jryQVPcfe8mPDhrBtljosWBD4Zn48m3P1Hm7pVagATZuwo4zyIS3iv9etC1GUA+QAW3cc74+RtP8ce0u2ypWg7RHx13Y5ORHff0+ecvTzF8C338LGjfDpZ9l8+ll2nuukpcYz3+My9NGOteHT063yIRUHx97CtT8fZCjRYft2CQkJ1KtXj3PPPZf09HSuvfZahg8fzm9/+9s9nlOlShUA1q9fv9v929u3HydJkiRJkiSpZNq8OfDttzuVf98WsC9btvvjowgaNoyD9BbNoUWLOBBq1BCSkgyDJAniMvENG8bjZY/usL0cfVZWYMmS3LLz8xfE68N/9y2s3wCffBp/7TwTvno1aNYsd0347SF81aqOuZLKtlIRtu+sR48eAMycOXOvx6WkpFC7dm0WL15Mdnb2Luu2b1+rffva7ZIkSZIkSZKKV3Z2YMnSeHb6/AXwzfzAggWweDFk5+z+nNq14hmWLZrDIS0imjeHZk2hUiUDHkk6EElJEU2bQtOm0Kc3bA/ht24NfPdd3lnwCxbAkqVxRZFZs+OvnUP4mjUDzZttqyjSLNo2Iz5evkOSyoJSF7YvX74cgKSkfXe9U6dOjB07lo8++oiOHTvm2Td58mSAXdolSZIkSZIkFa4QAitWsGOG+vbZ6gsXwpYtuz8nLY247HsLaLF91mRzqFrFwEaSikKFClE8BreA7QE8wKZNgUXf5s6CX7gg/vv3P8DKlfHXBx/CziF83bpxCB8H8RHNm8XhfuXKjumSSpcSGbZ//fXXNGzYkMqVK+dp37hxI//4xz8A6N279472VatWkZGRQXp6OjVq1NjRfuaZZzJ27FjuvPNOHn30UZKTkwF49913mTlzJj169KBhw4ZF8IwkSZIkSZKk8mnt2tyy7/Pn5/59D6s/UrFiPDN95/LvLZpDrVquByxJJVGlShGHtoZDW8POIXxmZmDhotyZ8Au2zYRf8WO8DMiyZTB9BmwP4aMI6tcPO0rQby9H36QxJCc7/ksqmUpk2D5u3Dgee+wxjjnmGBo2bEhaWhrLli1j0qRJrF69mmOPPZYLL7xwx/FPP/0099xzD1dffTXDhg3b0d6lSxfOOOMMRo4cydChQ+nduzcrVqzgtddeo3r16vzxj38shmcnSZIkSZIklT2bNgUWLtxW/n1B2FEK/scfd398YgI0bpw7U317KfgG9SEx0VBFkkq7lJSIw9vA4W1g5xB+7brc/y8Wbi9HvxAyMmDp0vhrylTYHsInJkCjRttmwm9bE755M2jcKC55L0nFqUSG7X369GH58uV8/PHHzJo1i8zMTNLS0jj00EM56aSTOP300/erjDzAzTffTOvWrXn++ed58sknSUlJoX///lx33XU0adKkkJ+JJEmSJEmSVLZkZQW+Wwzz5+eWf9++Zm8Iuz+nXt3tofq2EvAtnKkoSeVV1SoR7dtB+3awcwifsTp39vuCnUL4detg0bfx1zuTYHsIn5QETRqHbevA5y4v4oe2JBWlKIQ9vQQWQEZGRnF3ocxKT0/3+ytJRcyxV5KKnmOvJBU9x96CkZMTWLYMvtkWfMxfEJg/Pw47srJ2f071auxYz3fHuurNIDXV0EMq6xx7VRhCCKxcuX09eFiwIDeE37hx9+ckJ8fLkTRvDq1aRnTrCk0a+/+QyibH3sKVnp6+z2NK5Mx2SZIkSZIkSUUnIyMOL76ZHwcZ38zfe5BRuTI71lJv3jzikG2z1tPTDTMkSQUniiJq1YJataDjsbB9JnwI8QfCdoTw22bCL1oEmzfDvK/irzfGB+65D5o1C/TsAb17RBx6aHxdSSoIhu2SJEmSJElSOZGZGYcR87fNVF+wLWBfvXr3xyclQdOmO5V/3xaw160LCQkGFZKk4hFFEfXqQb160LULbA/hs7MD33+fG8LPnhP48CNYuDD+GvFUoE5t6Nkj0KtnRIf2rvsu6eAYtkuSJEmSJEllzJYtgUXf5i3/Pn8B/LBs98dHETRsEJfcbdEcWrSIg/XGjQwhJEmlR2JiRKNG0KgR9OwBELFuXeC9GTBpcmDGDFi+Al58GV58OVClCnTvFujZI6JzR6hUyf/zJOWPYbskSZIkSZJUSmVnB5Z+v30dW/hmfjxb/bvvIDtn9+fUqrW9/Dscsm22etOmULmyAYMkqeypUiViQD8Y0C9i8+bABx/C5CmBKdPiyi6vvwGvvxGoWBE6HRvPeO/WFapV8/9FSftm2C5JkiRJkiSVAuvWBb74Mi77Pn9+XA5+4ba1aXcnLRVatMg7U715M8MDSVL5VbFiRPdu0L1bRHZ24JNP4+B90mT4/geYPBUmTw0kJkCHDnHw3qM71Kvr/52Sdi8KIYTi7kRJlpGRUdxdKLPS09P9/kpSEXPslaSi59grSUWvrIy9P64MzJ4Ds2cHZn8C8+fD7u7kJSdDs2a7rqteu3a8pq0kFYWyMvaqfAoh8PU3can5yVPg62/y7j+0NfTsEdGrZ/zBNf9/VUnh2Fu40tPT93mMM9slSZIkSZKkYhZCYPESmD0H5syJQ/YlS3c9rmEDaNUKDtk+U7153JaY6E1/SZIOVBRFtGoJrVpGXHIRLFkamDI1Dt/nfAJz58HceYGHH4VGDaFXz3id9yMOh4QE/w+WyjNntu+DnwYpPH7aRpKKnmOvJBU9x15JKnqlYezNzg7Mnw+zP4HZcwJz5sDKVXmPiSJoeQh0aA/t20d0aAc1a3pDX1LJVBrGXulAZGQEpk6Lg/cPPoQtW3P31UiHHj2gV4+Io4+C5GT/n1bRcuwtXM5slyRJkiRJkkqALVsCX86NZ67PnhOvEbthQ95jKlSAww6Nw/UOHSLaHQFpad60lySpOKWnR5x8Epx8UkRmZmD6zHid92nvwaoMeHU0vDo6kJoKXTrH67x37QwpKf4fLpUHhu2SJEmSJElSAcvMjAP12XPi8rOff553JhxASgq0PQI6tI/o0B7aHAYVK3pjXpKkkiolJaJvH+jbJ2Lr1sDHs7at8z4VVq6EN9+CN98KVKgAxx4Tl5rv0Q1q1PD/d6mssoz8Plh6ofBY2kKSip5jryQVPcdeSSp6xTH2ZmTEofrsOYFZc+DrryEnJ+8x1atvm7XeLqJ9+7hEfFKSN98llQ2+7lV5lpMT+PyLeMb7pCnw3Xe5+6Io/nBdr54RvXpAw4b+36+C49hbuPanjLxh+z74A1p4HAAkqeg59kpS0XPslaSiV9hjbwiB73+IS8LPmROYPQe+/W7X4+rXgw4d4nC9Q3to3BiiyBvsksomX/dKsRACCxfB5CnxrPcv5+bdf0gL6NkjDt9btfS1gQ6OY2/hcs12SZIkSZIk6SDl5AQWLoTZ22auz54NK37c9bgWzaF9+21l4dtBnTrePJckqbyJoojmzaB5M7jgvIhlywNTpsCkKYFZs+Cb+fHX408G6tWFnj3idd7btbXijVQaObN9H/w0SOHx0zaSVPQceyWp6Dn2SlLRO9ixNysrMHdePHN99px47fW1a/Mek5gIh7beVha+Q0T7tlC1qjfIJZVfvu6V9m3t2sC06fGM9xkzYfPm3H3VqkL37tCrR0THY6FiRV9XaN8cewuXM9slSZIkSZKkfdi4MfDZ53GwPucT+Oxz2LQp7zGVKsERh2+btd4eDm8DlSt7E1ySJO2/qlUjThwAJw6I2LQp8P4HcfA+9T1YsxZeGwevjQtUqgSdOwV69Yjo2hWqVvE1h1RSGbZLkiRJkiSpXFm7Ng7VZ29bb33uPMjOzntM1arQvh2037be+qGtLe0qSZIKTqVKET17QM8eEVlZ8WuTSVMCk6fAsmXw7iR4d1IgMRGOOjIuNd+zO9Su7esRqSSxjPw+WHqh8FjaQpKKnmOvJBU9x15JKno/HXuXLY9D9TnbwvUFC3c9p05t6NABOrSLaN8emjWFhARvZkvS/vJ1r1QwQgjM+yqe8T55CsxfkHd/mzZxqflePaBpU1+rlHeOvYVrf8rIG7bvgz+ghccBQJKKnmOvJBU9x15JKlohBFavqcbkKWvisvBz4Psfdj2uaRNo335bWfh2UK8eRJE3rCXpQPm6Vyoc3y2OQ/fJUwKffgY7p3pNGkOvnvHs+DaH+UHB8sixt3AZthcAf0ALjwOAJBU9x15JKnqOvZJUuLKyAl9/A3PmwKxta66vXp33mIQEaNUSOrSHDh0i2reD9OrejJakguTrXqnwrVwZmDItDt4/+BCysnL31aoFPbpD754RR3aAChV8rVMeOPYWLsP2AuAPaOFxAJCkoufYK0lFz7FXkgrW5s2Bz78gLgv/SeCTT2HjxrzHJCfD4W22hevtI9oeASkp3nCWpMLk616paG3YEHhvehy8vzcDMjNz96WlQreu0KtnRKeOvg4qyxx7C9f+hO1JRdAPSZIkSZIk6YCsXx8H6rO3rbf+5VzYujXvMWmp0K4dtG8X0aE9dO2SzoYNq4ulv5IkSUUhNTWi3/HQ7/iILVsCH34cr/M+ZSpkZMD4iTB+YiC5AnTsGOjZI6J7N6v7SAXNme374KdBCo+ftpGkoufYK0lFz7FXkvJn5crA7E9g9uw4XP9mft61SQFq1oAOHaBDu4j27aFFc0hMzL1x7NgrSUXPsVcqGbKzA599Hs94nzQZlizN3ZeQAO3bQa8eET17QP36Bu+lnWNv4bKMfAHwB7TwOABIUtFz7JWkoufYK0l7FkJgyRLicH1OYM4cWLxk1+MaNYT220rCd2gHDRtCFO355rBjryQVPcdeqeQJITB/AUyeEs96n/dV3v2tWkLPHhG9esIhLfb++kolk2Nv4bKMvCRJkiRJkkqM7Oz4hu+cOTD7k3jm+sqVeY+Jovhmb4f20KFDRPt2UKumN34lSZLyK4oiDmkRv7a68IKIH34ITJoSz3qfPQe++hq++jrw6OPQoAH07BHo1SOi7RF5qwZJ2jNntu+DnwYpPH7aRpKKnmOvJBU9x15J5dnWrYEv58Ks2TDnk8Ann8D6DXmPSUqCNodtC9fbxzd3q1Q5uJu7jr2SVPQce6XSZfXqwLT3YNKUwMz3YcuW3H3p6dCjWzzr/ZijoWJFg/eSyrG3cDmzXZIkSZIkSUUmMzPw6WdxSfjZc+DzL/LeuAWoXBnatYX27SI6tIfD23gDV5IkqahVrx4xaCAMGhixcWMcuE+aHJj6HmRkwOixMHpsoHJl6NI50KtnRNfOkJbm6zZpZ4btkiRJkiRJOiBr1wY+ng1ztoXrX30F2Tl5j6leHdq3gyPbR7RvDy0PgaQkb9JKkiSVFJUrR/TuBb17RWRlBT6eFZeanzwFVvwIb78Db78TSEqCo4+KS8336OFSPxJYRn6fLL1QeCxtIUlFz7FXkoqeY6+ksubbbwNTpsHUaYFPPoWcn4Tr9etB+20l4Tu0gyZN4vVCi5JjryQVPcdeqezJyQnMnRfPeJ88BRYuyrv/iMOhV8+Inj2gSWOD9+Lg2Fu49qeMvGH7PvgDWngcACSp6Dn2SlLRc+yVVNplZQXmfBKH61Pfg8WL8+5v1gyObA/t28dl4evWKf4brY69klT0HHulsu/bbwOTpsTh++df5N3XrBn07AFDTo2oUwJeD5YXjr2FyzXbJUmSJEmSlG9r1wWmz4gD9hkzYf363H1x+VDo3jWiW1eoX9+bqZIkSeVBkyYR550L550bsWJFXO1o0uTARx/DwoXx1wsvBC66EM78mUsHqXwwbJckSZIkSRLffheYur08/Cd5116vXg26doHu3SI6dYSUFG+cSpIklWe1a0cMOQ2GnBaxbl3gvenw0qjAp5/BffcHxr0O118LRx3p60aVbYbtkiRJkiRJ5VBWVrzm+vby8N99l3d/82bQvVscsB/eBhITvVEqSZKkXVWpEjGgP/Q7Hsa9AcPvDyxYCMOuDZwwIPCrKyNq1PC1pMomw3ZJkiRJkqRyYt26uCz81PfiMvHr1uXuS0qCIzvE4Xq3rtCwgTdEJUmStP8SEiJOGgg9u8MDDwVeHQNvjIepUwOXXQKDT/MDnCp7DNslSZIkSZLKsMWL45nrU6cFZs+B7OzcfdWqQpdt5eE7d4TUVG9+SpIk6eBUrRrx2xsiThoU+PcdgXnz4I67AmNfhxuuhSMO9zWnyg7DdkmSJEmSpDIkKyvw2efbysNPg0Xf5t3frCl06wbdu0a0PcLZRZIkSSoch7eJeGg4vDIaHnwoDt2v/FXglJMDV1waUa2ar0NV+hm2S5IkSZIklXLr1wdmvA/TpgXemwFr1+buS0zcVh6+a0T3btCwoTc1JUmSVDQSEyOGDoY+veC+BwKvvwGvjoZ33w1cdQUMGhiXn5dKK8N2SZIkSZKkUmjJ0njm+tRpgVmz85aHr1IFunaOy8N36ghVqngDU5IkScWnRo2IP94UcfKgwG13BBYshFv/FRjzWlxavlUrX6+qdDJslyRJkiRJKgWys3cqD/8eLFyYd3+TxtC9Wxywtz0CkpK8YSlJkqSS5cgOEY89DCNfhEcfC3z6GVxyReD0IYFLL45ITfU1rEoXw3ZJkiRJkqQSasOGwMz3Yep7genTYfWa3H2JCdC+fRyud+8GjRt5Y1KSJEklX1JSxDlnwfHHwd33Bd5+Jw7f33o7cPWvoF9fiCJf26p0MGyXJEmSJEkqQZZ+n7c8fFZW7r60NOiyrTx8505Q1fLwkiRJKqXq1Im45S8RM98P3H5nYPFi+OstgdFj4PproVlTX+uq5DNslyRJkiRJKkbZ2YHPv9hWHn4aLFiYd3/jxtC9axywt2treXhJkiSVLZ06Rjz5KDzzX3jyqcBHH8OFlwTOPjPwi/MjKlf29a9KLsN2SZIkSZKkIpaZua08/LTAezNg9ercfYkJ0K4ddOsa0aMbNGnizUVJkiSVbcnJERdeAP37wZ13BaZNh6eegQlvBq65Gnr2sLS8SibDdkmSJEmSpCLwww/bysO/F/h4FmzdmrsvLRU6bysP36UTVK3qjURJkiSVPw0bRPzfP2DKVLjz7sAPy+D3/xPo2gWu/XW8XypJDNslSZIkSZIKQU7OtvLw7wWmTYNv5ufd36ghdO8WB+zt21keXpIkSYJ4BnvPHtDxWHjiqcCz/4X3psOHHwbOPw/OPRsqVvS1s0oGw3ZJkiRJkqQCkpkZeP/DbeXhp0NGRu6+hARo1zYO17t3hSZNLIUpSZIk7UmlShFXXBpxYv/A7XcGPvwIHnks8Mb4eJZ7l86+llbxM2yXJEmSJEk6CMuWbysPPy3w8cewZafy8Kmp0LkTdO8a0aUzVKvmDUFJkiQpP5o2jfjPbfDmW3D3fYHFS+A3/y/Qp1dg2NURdev4GlvFx7BdkiRJkiQpH3JyAl/OjcP1qdPg62/y7m/QALp3jWewd2gPFSp480+SJEk6GFEU0e946Nolnt3+4kvwziSYMTNw0YVw5s9clknFw7BdkiRJkiRpHzZuDHywU3n4laty9yUkwBGHbysP3w2aNbU8vCRJklQYUlMjfn11xMATA7f/J/DJp3Df/YFxr8P118JRR/o6XEXLsF2SJEmSJGk3li8PTHsPpr4X+PDDvOXhU1KgU8c4YO/aGapX96aeJEmSVFRatYy49y4Y9wYMvz+wYCEMuzZwQv/AL6+MqFnT1+cqGobtkiRJkiRJxOXh582Lw/Wp02DeV3n3168H3bvFAfuRHSwPL0mSJBWnhISIkwZCz+7wwEOBV8fAGxPialSXXQKDT4PERF+zq3AZtkuSJEmSpHJr06bABx/FN+SmvQcrV+bui6KdysN3hebNLQ8vSZIklTRVq0b89oaIk08K/Pv2wNx5cMddgbGvww3XwhGH+xpehcewXZIkSZIklSsrVgSmvgfT3ovXYd+yJXdf5crbysN3jejaBdLTvTEnSZIklQZtDot4cDi8MhoefCiuWnXlrwInnxS48rKIatV8ba+CZ9guSZIkSZLKtBDi2S1Tp8Uh+7x5effXrQvdu8Yz2I86EpKTvQknSZIklUaJiRFDB0OfXnDfA4HX34DRY2DSpMBVV8CggXH5eamgGLZLkiRJkqQyZ/PmeNb61Pfi8vA//pi7L4qgzWHbysN3g0NaWB5ekiRJKktq1Ij4400RJw8K3HZHYMFCuPVfgTGvxaXlW7Xy9b8KhmG7JEmSJEkqE9auC0yaBJOnxkH75s25+ypXgmOPjQP2bl3im2+SJEmSyrYjO0Q89jCMfBEefTzw6WdwyRWBoUMCl14UkZbm+wIdHMN2SZIkSZJUam3ZEnhvOoyfGM9g37o1d1+dOtCtK/TYVh6+YkVvpEmSJEnlTVJSxDlnwfHHwd33Bd5+B154Ed5+O3D1r6BfXytd6cAZtkuSJEmSpFIlJycw5xN4Y0J8o2z9+tx9LZpD3+MiuneFli29aSZJkiQpVqdOxC1/iZj5fuD2OwOLF8NfbwmMHgPXXwvNmvreQfln2C5JkiRJkkqF+QsCEyYGxk+EZcty22vXgv79YED/iJaHeINMkiRJ0p516hjx5KPwzH/hyacCH30MF14SOOuMwIUXRFSu7HsK7T/DdkmSJEmSVGL9+GNgwpswfkLgq69z21NToU9vOKF/RIf2kJjoDTFJkiRJ+yc5OeLCC2BAf/jPXfGSVE8/CxPfClxzNfTsYZUs7R/DdkmSJEmSVKJs2BCYNDkuE//hRxBC3J6YCF27xDPYu3d1DXZJkiRJB6dB/Yh//iNiytTAf+4K/LAMfv8/ga5d4NpfQ8MGvufQ3hm2S5IkSZKkYpeVFZgxE8ZPDEyZCps35+5r1zaewX5cH6hWzZtdkiRJkgpWj+4Rxx4DTzwVePa/8N50+PDDwPnnwbln+0Ff7ZlhuyRJkiRJKhYhBD77PC4R/9bbsHpN7r4mjeMZ7P37OZtEkiRJUuGrVCniiksjTuwfuP3OuMrWI48FXn8DrrsGunT2fYl2ZdguSZIkSZKK1HeLA+MnBMZPgCVLc9trpEO/42FAv4hDD3WNREmSJElFr2nTiP/cBm+9DXfdG1iyFH7z/wJ9egWGXR1Rt47vU5TLsF2SJEmSJBW6jIzAm2/H67B/8UVue6VK0LtnPIv9mKMhKckbV5IkSZKKVxRFHN8XunSGRx8PvPAivDMJZswMXHQhnPkz37soZtguSZIkSZIKxaZNgclT4zLxM2dCdk7cnpgAHTvGM9h7dIeUFG9SSZIkSSp5UlMjhv0qYuCJgdvuCHzyKdx3f+C11+GGa+GoI30vU94ZtkuSJEmSpAKTlRX46ON4BvukybBxY+6+NofFM9iPPw5q1PCmlCRJkqTSoeUhEffeBa+/EYftCxfCsGsDJ/QP/PLKiJo1fX9TXhm2S5IkSZKkgxJCYN5X8Qz2iW/CylW5++rXhxP6x7PYmzTxBpQkSZKk0ikhIWLQQOjRHR54KPDqGHhjAkydFrjsEhh8GiQm+p6nvDFslyRJkiRJB+T77wPjJ8KEiYGFi3Lbq1WFvn3hhP4RRxwer3coSZIkSWVB1aoRv70h4uSTAv++PTB3HtxxV2DsttLyRxzu+5/yxLBdkiRJkiTtt7VrA2+9E89in/NJbntycjzDY0D/iM4doUIFbzBJkiRJKrvaHBbx4HB4dQw88GBg3jy48leBk08KXHlZRLVqvicqDwzbJUmSJEnSXm3eHHhverwO+3vTISsrbo8iOPqoeAZ7716QmurNJEmSJEnlR2JixJDToHdPuO+BwOtvwOgxMGlS4KorYNDAuPy8yi7DdkmSJEmStIucnMCs2fEM9nfehfUbcve1PCSewd7/eKhd2xtHkiRJksq3GjUi/nhTxCknBW67IzB/Adz6r8CY1+LS8q1a+b6prDJslyRJkiRJO8yfH3hjQmDCm7B8eW57nTowoB8M6BfRooU3iiRJkiTppzq0j3j0IRj5Ijz6eODTz+CSKwJDhwQuvSgiLc33UmWNYbskSZIkSeXc8uWBiW/FZeK/+Sa3PS0VjusTz2Lv0N7yh5IkSZK0L0lJEeecBccfB3ffF3j7HXjhRXj77cDVv4J+fSGKfG9VVhi2S5IkSZJUDq1fH3h3clwm/qOPIYS4PSkJunaJ12Hv2gUqVvQmkCRJkiTlV506Ebf8JWLm+4Hb7wwsXgx/vSUwegxcfy00a+p7rbLAsF2SJEmSpHJi69bAjJkwfmJgylTYsiV3X4f28Qz243pD1are9JEkSZKkgtCpY8STj8Iz/4Unn4o/7HzhJYGzzghceEFE5cq+/yrNDNslSZIkSSrDQojXCXxjQuCtt2Ht2tx9zZrGAXv/46F+fW/wSJIkSVJhSE6OuPACGNAf/nNXYNp78PSzMPGtwDVXQ88elpYvrQzbJUmSJEkqg779NjB+YmD8RFi6NLe9Zg3o1y8uE9+qpTd0JEmSJKmoNKgf8c9/REyZGvjPXYEflsHv/yfQtQtc+2to2MD3Z6WNYbskSZIkSWXEqlWBiW/F67B/OTe3vXJl6N0rDtiPPgoSE72BI0mSJEnFpUf3iGOPgSeeCjz7X3hvOnz4YeD88+Dcs6FiRd+zlRaG7ZIkSZIklWIbNwYmT4nLxH/wAWTnxO2JCdC5E/TvH9GjG64DKEmSJEklSKVKEVdcGjFwQOC2/wQ+/AgeeSzw+htw3TXQpbPv4UoDw3ZJkiRJkkqZrKzABx/GM9gnT4GNm3L3Hd4mnsHe9zhIT/fmjCRJkiSVZE2aRPznNnjrbbjr3sCSpfCb/xfo0ysw7OqIunV8X1eSGbZLkiRJklQKhBCYOzeewT7xLcjIyN3XqCH07wcD+kc0buSNGEmSJEkqTaIo4vi+0KUzPPp44IUX4Z1JMGNm4KIL4cyfQVKS7/VKIsN2SZIkSZJKsCVLAxMmxrPYv/0ut716NTi+bxywH94mvjkjSZIkSSq9UlMjhv0qYuCJgdvuCHzyKdx3f+C11+GGa+GoI33fV9IYtkuSJEmSVMKsWRN46504YP/k09z2ihWhZw8Y0C+iU0dnNkiSJElSWdTykIh774LX34jD9oULYdi1gRP6B355ZUTNmr4XLCkM2yVJkiRJKgE2bw5MfS8O2N+bDtnZcXtCAhxzdDyDvXdPSEnxpookSZIklXUJCRGDBkKP7vDgw4FXRsMbE2DKtMDll8Dg04q7hwLDdkmSJEmSik12dmDW7Hgd9ncnwYYNuftat4oD9n59oVYtA3ZJkiRJKo+qVo34zfURJw0K/Pv2wNx5cMddgbHj4O+3ZFGvXnH3sHwzbJckSZIkqYh9/U1g/IR4LfYVP+a216sL/fvHZeKbNzNglyRJkiTF2hwW8eBweHUMPPBQYN5XcP3v1vHMk8Xds/LNsF2SJEmSpCKwbHkcrk+YGPhmfm57Whr0PQ5O6B/Rrm1cKlCSJEmSpJ9KTIwYchr06QXP/DfQsmVlYGNxd6tcM2yXJEmSJKmQZGYG3no7LhM/azaEELdXqADdu0L//hFdO0NysgG7JEmSJGn/pKdH/OqqiPT0SmRkGLYXJ8N2SZIkSZIK2MJFgZdeDrw+HjIzc9uP7BDPYO/dG6pWMWCXJEmSJKk0M2yXJEmSJKkAZGUFpk6Dl0YFPvwot71JYxh4YkT/flCvrgG7JEmSJEllhWG7JEmSJEkHISMj8OoYeOXVwPIVcVtCAnTvBkMHRxx7DESRIbskSZIkSWWNYbskSZIkSfkUQuCzz+GllwNvvQNZWXF79Wpwyslw2qmRs9glSZIkSSrjDNslSZIkSdpPmzcHJrwZh+zzvsptP7wNnD4k4rg+kJxsyC5JkiRJUnlg2C5JkiRJ0j4sWRJ4+ZXA2HGwbl3cllwB+vWLS8UfdqgBuyRJkiRJ5Y1huyRJkiRJu5GTE5jxfjyLffoMCCFur18fhpwWcdJAqFbNkF2SJEmSpPLKsF2SJEmSpJ2sXRvPYB/1SmDJ0tz2zp3iWexdOkNioiG7JEmSJEnlnWG7JEmSJEnAvK8CL70cr8m+eXPclpYGJw2EwadFNG5kwC5JkiRJknIZtkuSJEmSyq2tWwNvvwsvjwp88mlue8tDYOiQiP7HQ+XKhuySJEmSJGlXhu2SJEmSpHJn+fLAK6MDr46BjIy4LTER+vSG04dEtGsLUWTILkmSJEmS9sywXZIkSZJULoQQ+HgWvPhyYMoUyM6J22vVgsGnRpxyEtSsacAuSZIkSZL2j2G7JEmSJKlMy8wMjHsDXn4lsHBhbvtRR8LQwRE9e0BSkiG7JEmSJEnKH8N2SZIkSVKZtHBR4KWX46B948a4rXIlOOEEGHpaRIsWBuySJEmSJOnAGbZLkiRJksqMrKzA1Gnw0qjAhx/ltjdpDEOHRJw4ANLSDNklSZIkSdLBM2yXJEmSJJV6q1YFRo+FV14NLF8RtyUkQPducPqQiGOOhigyZJckSZIkSQXHsF2SJEmSVCqFEPjsc3jx5cDb70BWVtxevTqcchKcdmpEvboG7JIkSZIkqXAYtkuSJEmSSpVNmwIT34xLxc/7Krf9iMNh6OCI4/pAcrIhuyRJkiRJKlyG7ZIkSZKkUmHJksDLrwTGjoN16+K25GTod3wcsh92qAG7JEmSJEkqOobtkiRJkqQSKycnMGNmPIt9+gwIIW6vXx+GnBZx0kCoVs2QXZIkSZIkFT3DdkmSJElSibN2bTyD/eVXAkuX5rZ37gSnD4no3AkSEw3ZJUmSJElS8TFslyRJkiSVGHPnBV4aFZgwEbZsidvS0uCkQTDk1IhGjQzYJUmSJElSyWDYLkmSJEkqVlu2BN55Ny4V/+lnue0tD4lnsffvB5UqGbJLkiRJkqSSxbBdkiRJklQsli0PvPJqYPRYyMiI25KSoE9vGDo4ol1biCJDdkmSJEmSVDIZtkuSJEmSikwIgY8+jmexT5kC2Tlxe+1acNqpEaecBDVrGrBLkiRJkqSSz7BdkiRJklToNmwIvD4eXh4VWLgot/2oI+NZ7D17QFKSIbskSZIkSSo9DNslSZIkSYVmwcLAS6MCr78BGzfGbZUrwQknxCF7i+YG7JIkSZIkqXQybJckSZIkFaisrMCUqXGp+I8+zm1v2iQO2E88AVJTDdklSZIkSVLpZtguSZIkSSoQq1YFXh0Dr44OLF8RtyUkQI/ucch+zNEQRYbskiRJkiSpbDBslyRJkiQdsBACn34Wz2J/+x3Iyorbq1eHU06G006JqFfXgF2SJEmSJJU9hu2SJEmSpHzbtCkw8c04ZJ/3VW77EYfHs9iP6wPJyYbskiRJkiSp7DJslyRJkiTttyVLAi+/Ehg7Dtati9uSk6Hf8XHIftihBuySJEmSJKl8MGyXJEmSJO1VTk5g+ox4FvuMmRBC3F6/Pgw5LeKkgVCtmiG7JEmSJEkqXwzbJUmSJEm7tXZtYMxrMOrVwNKlue2dO8HpQyI6d4LEREN2SZIkSZJUPhm2S5IkSZLymDsv8NKowISJsGVL3JaWBicNgiGnRjRqZMAuSZIkSZJk2C5JkiRJYsuWwDvvxqXiP/0st71Vy3gt9v79oFIlQ3ZJkiRJkqTtDNslSZIkqRxbtjzwyquB0WMhIyNuS0qCPr3jkL1dW4giQ3ZJkiRJkqSfMmyXJEmSpHImhMBHH8OLLwemTIWcnLi9di047dSIU06CmjUN2CVJkiRJkvbGsF2SJEmSyonNmwPjXocXXgosXJTbftSRcPqQiB7dISnJkF2SJEmSJGl/GLZLkiRJUhmXmRkY9So893xg5aq4rXJlOPEEGHJaRIvmBuySJEmSJEn5ZdguSZIkSWXU2nWBF1+CkS8G1q6N2+rUgXPOihh0IqSmGrJLkiRJkiQdqBIZti9btoxx48YxadIk5s+fz48//ki1atU4+uijufTSS+nQocN+XWfGjBlccMEFe9z/j3/8g6FDhxZUtyVJkiSpRFi1KvDcyMDLr0BmZtzWqBGcd27ECf2hQgVDdkmSJEmSpINVIsP2ESNG8NBDD9GkSRO6d+9OjRo1WLRoERMnTmTixIncdtttDBo0aL+v16lTJzp16rRLe5s2bQqy25IkSZJUrJYtDzz738CrY2DLlrjtkBZw/s8jjusDiYmG7JIkSZIkSQWlRIbt7du3Z8SIEbsE5B988AEXXnghf/nLX+jXrx/Jycn7db1OnToxbNiwwuiqJEmSJBW7xYsDTz0TeH08ZGXFbW3awC/Oi+jWFRISDNklSZIkSZIKWokM2wcMGLDb9mOPPZbOnTszZcoU5s6dS7t27Yq4Z5IkSZJUcnwzPzDi6cBbb0NOTtx21JFwwXkRxx4DUWTILkmSJEmSVFhKZNi+N0lJSXn+3B8LFy7k8ccfZ/PmzdStW5euXbtSt27dwuqiJEmSJBWqz78IPPlUYMrU3LauXeKQvV1bA3ZJkiRJkqSiEIUQQnF3Yn8tXbqUE044gWrVqvHuu++SmJi41+NnzJjBBRdcsEt7UlIS5513Hr/73e/2eY2cnBwSEhIOqt+SJEmSdLBCCLz/QRYPPryR96ZvBSCKYED/ZC67pDJtDit1n6WWJEmSJEkq1UrN3ZitW7fyu9/9ji1btvCb3/xmnyE5QI0aNbjhhhs47rjjaNiwIRs3buTjjz/mtttu4/HHHyeKIm688ca9XmPNmjUF9RT0E+np6WRkZBR3NySpXHHslaSid7BjbwiB6TPgyacCn3watyUmwID+cN65EU2bZgHrcHiXpFy+7pWkoufYK0lFz7G3cKWnp+/zmFIRtufk5HDjjTfy/vvvc+aZZzJ48OD9Oq9Vq1a0atVqx3ZKSgr9+vWjQ4cOnHrqqYwYMYLLLruMmjVrFlLPJUmSJOnA5OQE3p0EI54OzPsqbkuuAIMGwc/Pjqhf33LxkiRJkiRJxanEh+05OTn8/ve/Z8yYMZx66qn89a9/Pehr1q5dm+OPP56RI0cye/Zs+vbtWwA9lSRJkqSDl5UVmPAmPPV0YNG3cVvlSnDaqXD2WRG1ahqyS5IkSZIklQQlOmzPycnhpptuYtSoUZx88snceuutBbZ++vZp/xs3biyQ60mSJEnSwdi8OTDudXj62cD3P8RtaWnws6FwxukR1aoZskuSJEmSJJUkJTZs3zloHzRoEP/85z/3a532/TV79mwAGjZsWGDXlCRJkqT8yswMvDIa/vt8YOXKuK16dTjrjIihgyE11ZBdkiRJkiSpJCqRYfv20vGjRo3ixBNP5F//+tdeg/ZVq1aRkZFBeno6NWrU2NH+6aef0rZt212Of+KJJ5gxYwbNmjWjXbt2hfIcJEmSJGlv1q0LvPgyjHwhsGZt3FanNpx7TsTJg6BSJUN2SZIkSZKkkqxEhu333nsvL7/8MikpKTRr1ozhw4fvcky/fv1o06YNAE8//TT33HMPV199NcOGDdtxzK9//WuSkpJo27YtdevWZePGjcyePZvPP/+cqlWr7jPElyRJkqSClpEReG5k4KVRkJkZtzVqCOedG3HCAKhQwZBdkiRJkiSpNCiRYfuSJUsAyMzM5P7779/tMQ0bNtwRtu/J2WefzZQpU3j//fdZvXo1CQkJNGjQgF/84hdcfPHF1KtXr8D7LkmSJEm7s3x54JnnAqPHwObNcVuL5nD+eRHH9YakJEN2SZIkSZKk0iQKIYTi7kRJlpGRUdxdKLPS09P9/kpSEXPslaSit3ZdVYbfv5pxb0BWVtzW5jC44LyI7t0gIcGQXZIKmq97JanoOfZKUtFz7C1c6enp+zymRM5slyRJkqTSbv78wIhnAm++tZqcnLjtyA7wi/Mjjj0GosiQXZIkSZIkqTQzbJckSZKkAvTFl4EnRwQmT81t69I5nsnevp0BuyRJkiRJUllh2C5JkiRJBymEwKzZ8ORTgfc/iNuiCHr3gquvqka9euuKt4OSJEmSJEkqcIbtkiRJknSAQghMnwlPjgh88mnclpgA/fvDeedGNGsakZ6ehMunSZIkSZIklT2G7ZIkSZKUTzk5gUmT4cmnA/PmxW0VKsBJA+HccyIa1LdcvCRJkiRJUlln2C5JkiRJ+ykrKzDxLXjq6cDCRXFbpUpw2qlwzpkRtWoZskuSJEmSJJUXhu2SJEmStA+bNwfGvQFPPxv4/vu4LS0VTh8KZ5weUb26IbskSZIkSVJ5Y9guSZIkSXuwcWPgldHw7HOBlSvjturV4awzIoacBmlphuySJEmSJEnllWG7JEmSJP3EunWBF1+GkS8E1qyN2+rUhnPOjjjlJKhUyZBdkiRJkiSpvDNslyRJkqRtMlYHnh8ZeGkUbNgQtzVsAOedG3HCAEhONmSXJEmSJElSzLBdkiRJUrm3fHng2ecCr46BzZvjtubN4PzzIvr2gaQkQ3ZJkiRJkiTlZdguSZIkqdxasiTw1LOBca9DVlbcdtihcMF5ET26Q0KCIbskSZIkSZJ2z7BdkiRJUrkzf0HgqacDE9+CnJy47cgOccje8ViIIkN2SZIkSZIk7Z1huyRJkqRy48svA088FZg8JbetS2c4/+cRHdobsEuSJEmSJGn/GbZLkiRJKvNmzQ48+VRg5vvxdhRB757xmuyHtjZklyRJkiRJUv4ZtkuSJEkqk0IIzJgJTz4VmPNJ3JaYAP36wXnnRjRvZsguSZIkSZKkA2fYLkmSJKlMycmJy8Q/+VRg7ry4rUIFGHQinHtORMMGhuySJEmSJEk6eIbtkiRJksqErKzAm2/BiGcCCxfGbZUqwWmnwNlnRtSubcguSZIkSZKkgmPYLkmSJKlU27IlMO4NePrZwNKlcVtaKgwdAmf8LCK9uiG7JEmSJEmSCp5huyRJkqRSaePGwKtj4NnnAj/+GLdVrwZnnRkx5DRISzNklyRJkiRJUuExbJckSZJUqqxbF3hpFIx8IbB6TdxWuxacc3bEqSdDpUqG7JIkSZIkSSp8hu2SJEmSSoWM1YHnXwi89DJs2BC3NWgA550bceIASE42ZJckSZIkSVLRMWyXJEmSVKKtWBF49rm4ZPymTXFbs2Zwwc8j+h4HSUmG7JIkSZIkSSp6hu2SJEmSSqQlSwNPPxsY9zps3Rq3HdoaLjg/omd3SEgwZJckSZIkSVLxMWyXJEmSVKLMXxB4+pnAxDchOydu69AeLjgvolNHiCJDdkmSJEmSJBU/w3ZJkiRJJcKXcwNPPhWYNDm3rXOnOGTv0N6AXZIkSZIkSSWLYbskSZKkYjV7TuCJEYGZ7+e29e4F5/884rBDDdklSZIkSZJUMhm2S5IkSSoW8xcE7n8gMG16vJ2YAP2Oh/N+HtG8mSG7JEmSJEmSSjbDdkmSJElF6seVgUceDYwdBzk5kJgIgwbCeedGNGxgyC5JkiRJkqTSwbBdkiRJUpHIzAw8+1zg2edg06a4rVdPuPLyiCaNDdklSZIkSZJUuhi2S5IkSSpUWVnxLPZHHwusXBW3HXE4/PLKiA7tDdklSZIkSZJUOhm2S5IkSSoUIQSmvQfDHwgsXBS3NWwAV1wecVxviCKDdkmSJEmSJJVehu2SJEmSCtyXXwbuvT/w8ax4u2pVuPCCiCGnQYUKhuySJEmSJEkq/QzbJUmSJBWY778PPPhIYMLEeDu5AvzsZ3D+uRFVqhiyS5IkSZIkqewwbJckSZJ00NauC4x4KvDCS7B1a9x2Qn+47JKIevUM2SVJkiRJklT2GLZLkiRJOmBbtgRefgUefzKwbl3cdszR8MsrIw5tbcguSZIkSZKkssuwXZIkSVK+hRB46224/6HA99/Hbc2bxSF7l84QRQbtkiRJkiRJKtsM2yVJkiTly+w5gXuGB774It6uWRMuvShi4ImQlGTILkmSJEmSpPLBsF2SJEnSfvn228DwBwKTp8bblSvBuedEnH0mVK5syC5JkiRJkqTyxbBdkiRJ0l6tWhV49InA6NGQnQMJCXDKSXDxhRE1axqyS5IkSZIkqXwybJckSZK0W5s2Bf77PDz9bGDjxriteze46oqIZk0N2SVJkiRJklS+GbZLkiRJyiM7OzDuDXj40cCPP8Zthx0Kv7wy4uijDNklSZIkSZIkMGyXJEmStE0IgRkzYfgDgW/mx23168Hll0UcfxwkJBi0S5IkSZIkSdsZtkuSJEniq68C994f+ODDeDstDX5xfsTpQyA52ZBdkiRJkiRJ+inDdkmSJKkcW7Y88NAjgTfGQwhQoQIMHQK/OC+ialVDdkmSJEmSJGlPDNslSZKkcmj9+sBTzwSefwG2bInbju8LV1wW0aC+IbskSZIkSZK0L4btkiRJUjmydWvgldHw+BOB1WvitiM7wC+vjDi8jSG7JEmSJEmStL8M2yVJkqRyIITAu5Pg/gcDi5fEbU0axyF7924QRQbtkiRJkiRJUn4YtkuSJEll3KefBe4dHvjk03g7PR0uvjDilJMgKcmQXZIkSZIkSToQhu2SJElSGbV4ceD+BwPvTIq3K1aEc86Cc8+OSEkxZJckSZIkSZIOhmG7JEmSVMasXh14/MnAy69AdjYkJMCgE+HSiyNq1TJklyRJkiRJkgqCYbskSZJURmzeHBj5Iox4OrBhQ9zWuVO8LvshLQzZJUmSJEmSpIJk2C5JkiSVcjk5gfET4cGHA8uXx22tWsYhe8djDdklSZIkSZKkwmDYLkmSJJVi738QuO/+wFdfx9t16sBll0Sc0B8SEgzaJUmSJEmSpMJi2C5JkiSVQt/Mj0P2GTPj7dRUOO/ciDN/BhUrGrJLkiRJkiRJhc2wXZIkSSpFfvwx8PCjgddeh5wcSEyEIafBLy6ISK9uyC5JkiRJkiQVFcN2SZIkqRTIzAw889/Af5+HTZvitj694IrLIxo3MmSXJEmSJEmSipphuyRJklSCZWUFxoyFRx4PZGTEbW2PgF9dFdGurSG7JEmSJEmSVFwM2yVJkqQSKITA1Gkw/IHAom/jtkYN4crLI3r3gigyaJckSZIkSZKKk2G7JEmSVMJ88WXg3uGBWbPj7WpV4aILI047BSpUMGSXJEmSJEmSSgLDdkmSJKmEWPp94IGHAm++FW8nJ8OZP4Pzzo1ISzNklyRJkiRJkkoSw3ZJkiSpmK1dG3jiqcBLL8PWrRBFcMIAuOySiLp1DNklSZIkSZKkksiwXZIkSSomW7YEXnwZnhgRWL8+bjv2GPjVlRGtWhmyS5IkSZIkSSWZYbskSZJUxHJyAm++DQ8+FPj+h7itRXP45ZURnTtBFBm0S5IkSZIkSSWdYbskSZJUhD6eFbh3eODLufF2rVpw6cURA0+AxERDdkmSJEmSJKm0MGyXJEmSisDCRYHhDwSmTou3K1eGn58TcdYZULmyIbskSZIkSZJU2hi2S5IkSYVo5crAo48HxoyF7BxITIBTToGLfxFRo4YhuyRJkiRJklRaGbZLkiRJhWDjxsB/n4dnng1s3BS39ewOV14e0bSpIbskSZIkSZJU2hm2S5IkSQUoOzvw2jh4+LHAypVxW5s28KsrI47sYMguSZIkSZIklRWG7ZIkSVIBCCEwfQbcd39gwcK4rX59uPKyiL7HQRQZtEuSJEmSJElliWG7JEmSdJDmzgvcd3/gw4/i7SpV4MILIoacBsnJhuySJEmSJElSWWTYLkmSJB2gH5YFHno48MaEeLtCBfjZUDj/vIiqVQzZJUmSJEmSpLLMsF2SJEnKp3XrAiOeCbzwAmzZGrf17weXXxJRv74huyRJkiRJklQeGLZLkiRJ+2nr1sDLr8ATTwbWrI3bjjoSfnVlxGGHGbJLkiRJkiRJ5YlhuyRJkrQPIQTefhceeDCwZGnc1qwpXHVFRLeuEEUG7ZIkSZIkSVJ5Y9guSZIk7cWcTwL3Dg989nm8XSMdLrk44qSBkJRkyC5JkiRJkiSVV4btkiRJ0m58+13g/gcDkybH25UqwTlnwTlnRaSkGLJLkiRJkiRJ5Z1huyRJkrST1asDjz0RGPUqZGdDQgKcNAguuSiiVk1DdkmSJEmSJEkxw3ZJkiQJyMkJvPY63Hd/YO3auK1rl3hd9hbNDdklSZIkSZIk5WXYLkmSpHJv/vzAv+8IzPkk3j6kBfz66ohjjjZklyRJkiRJkrR7hu2SJEkqtzZuDDz+ZOC/z8cl4ytXgosvijjjdEhKMmiXJEmSJEmStGeG7ZIkSSqXpk4L3HFn4Idl8XbPHnDNsIh6dQ3ZJUmSJEmSJO2bYbskSZLKlWXLA3feHZg0Od6uWxeu+3VEj+6G7JIkSZIkSZL2n2G7JEmSyoWsrMALL8EjjwY2boLERDjrTLjogojKlQ3aJUmSJEmSJOWPYbskSZLKvE8/C/z79sDX38Tb7drCb66POKSFIbskSZIkSZKkA2PYLkmSpDJr7brAAw8GXh0DIUDVqvDLKyIGDYSEBIN2SZIkSZIkSQfOsF2SJEllTgiB8RPg7vsCq1fHbYNOhKuujEivbsguSZIkSZIk6eAZtkuSJKlM+fbbwL/vCHz0cbzdrCnccF3EUUcaskuSJEmSJEkqOIbtkiRJKhM2bw6MeDrw9LOwdSskJ8NFv4g4+0yoUMGgXZIkSZIkSVLBMmyXJElSqTdjZuD2/wSWLI23u3SG666JaNjAkF2SJEmSJElS4TBslyRJUqn148rA3fcE3nw73q5VC64dFtG7F0SRQbskSZIkSZKkwmPYLkmSpFInOzsw6hV48JHAhg2QkAA/GwqXXBSRmmrILkmSJEmSJKnwGbZLkiSpVPlybuBftwXmzou32xwGv70honUrQ3ZJkiRJkiRJRcewXZIkSaXC+vWBhx8NvDQKcnIgLRWuuDzi1JMhMdGgXZIkSZIkSVLRMmyXJElSiRZC4K134K57AitXxm39+8HVV0XUrGnILkmSJEmSJKl4GLZLkiSpxFqyJHDbfwIz34+3GzWCG66N6HisIbskSZIkSZKk4mXYLkmSpBJny5bAM/+FJ58KbNkCFSrA+T+P+Pk5ULGiQbskSZIkSZKk4mfYLkmSpBLlo48D/7498O138faxx8D110Y0aWzILkmSJEmSJKnkMGyXJElSiZCREbhneOCN8fF2jXQYdnVEv74QRQbtkiRJkiRJkkoWw3ZJkiQVq5ycwOixcP+DgXXrIIpg8Glw+SURVaoYskuSJEmSJEkqmQzbJUmSVGy++jpw2x2BTz+Lt1u1hN/eEHF4G0N2SZIkSZIkSSWbYbskSZKKXGZm4NHHAyNfgOwcqFwZLrskYuhgSEoyaJckSZIkSZJU8hm2S5IkqUhNmhz4z12B5Svi7T694JphEbVrG7JLkiRJkiRJKj0M2yVJklQkfvghcMddganT4u369eD6ayO6djFklyRJkiRJklT6GLZLkiSpUGVlBZ4bCY89Edi0CZKS4Jyz4RfnRVSqZNAuSZIkSZIkqXQybJckSVKhmT0ncNsdgfkL4u0jO8AN10U0b2bILkmSJEmSJKl0M2yXJElSgVuzJjD8gcCY1+LtalXh6l9GnHgCRJFBuyRJkiRJkqTSz7BdkiRJBSaEwLjX4d7hgTVr47aTB8FVV0RUq2bILkmSJEmSJKnsMGyXJElSgViwMC4ZP2t2vN2iOfzm+oj27QzZJUmSJEmSJJU9hu2SJEk6KJs2BZ4YEXjmv5CdDZUqwcUXRpz5M0hKMmiXJEmSJEmSVDYZtkuSJOmAvTc9cPt/At//EG937wbX/TqiXj1DdkmSJEmSJEllm2G7JEmS8m358sBd9wTemRRv16kN1/46omcPiCKDdkmSJEmSJElln2G7JEmS9ltWVuCll+GhRwMbN0JiApzxs7hsfEqKIbskSZIkSZKk8sOwXZIkSfvl8y8C/7ot8NXX8fYRh8Nvro9o1dKQXZIkSZIkSVL5Y9guSZKkvVq3LvDAw4FXXoUQIC0Nrroi4pSTICHBoF2SJEmSJElS+WTYLkmSpN0KITDhTbjn3sCqjLjthAFw9VUR6emG7JIkSZIkSZLKN8N2SZIk7eK7xYHb7gh88GG83aRxXDL+6KMM2SVJkiRJkiQJDNslSZK0k82bA089E3jqGdi6FZIrwAXnR5x7NiQnG7RLkiRJkiRJ0naG7ZIkSQLg/Q/i2eyLl8TbnTrC9ddENGpkyC5JkiRJkiRJP2XYLkmSVM6tXBm4+77AxDfj7Zo14ddXR/TtA1Fk0C5JkiRJkiRJu2PYLkmSVE5lZwdeHQMPPBhYvwESEmDoYLj04oi0NEN2SZIkSZIkSdobw3ZJkqRyaN5XgX/dHvjii3j70Nbw2+sjDjvMkF2SJEmSJEmS9odhuyRJUjmyYUPg4UcDL74MOTmQkgJXXBox+DRITDRolyRJkiRJkqT9ZdguSZJUDoQQeOdduPOewI8/xm3HHwfDfhVRq5YhuyRJkiRJkiTll2G7JElSGbf0+8Addwbemx5vN2wA118b0bmTIbskSZIkSZIkHSjDdkmSpDJq69bAf5+Hx54IbNkCSUlw3rlw/s8jKlY0aJckSZIkSZKkg2HYLkmSVAZ9PCtw2x2BhYvi7aOPghuujWja1JBdkiRJkiRJkgqCYbskSVIZkrE6cN/wwLg34u3q1WHYLyMG9IcoMmiXJEmSJEmSpIJSIsP2ZcuWMW7cOCZNmsT8+fP58ccfqVatGkcffTSXXnopHTp02O9r5eTk8PTTT/P888+zaNEiUlJS6NatG9dddx2NGzcuxGchSZJUdHJyAq+Ng/seCKxdG7eddgpccXlE1SqG7JIkSZIkSZJU0Epk2D5ixAgeeughmjRpQvfu3alRowaLFi1i4sSJTJw4kdtuu41Bgwbt17X+9Kc/MXLkSFq1asX555/P8uXLGTduHFOnTuW5556jWbNmhftkJEmSCtk38wP/vj3wyafx9iGHwG+vj2h7hCG7JEmSJEmSJBWWKIQQirsTPzV+/HiqV69Op06d8rR/8MEHXHjhhaSkpDBlyhSSk5P3ep3p06fzi1/8go4dO/Loo4/uOP7dd9/l8ssvp0ePHjzyyCN7vUZGRsbBPRntUXp6ut9fSSpijr1ly8aNgceeDDz3PGRnQ+VKcMnFET8bCklJBu1SSeHYK0lFz7FXkoqeY68kFT3H3sKVnp6+z2NK5Mz2AQMG7Lb92GOPpXPnzkyZMoW5c+fSrl27vV5n5MiRAFxzzTV5gvnevXvTqVMnpkyZwtKlS2nQoEHBdV6SJKkITJkWuOPOwLJl8XavnnDNsIi6dQzZJUmSJEmSJKkoJBR3B/IrKSkpz597M2PGDFJSUjj66KN32dezZ08AZs6cWbAdlCRJKkQ/LAvc9Mccbvx9HLTXqwu3/j3i77ckGLRLkiRJkiRJUhEqkTPb92Tp0qVMmzaN2rVr07p1670em5mZyYoVK2jdujWJiYm77G/atCkAixYtKpS+SpIkFaSsrMDIF+HRxwIbN0FiIpx9Jlx4QUTlyobskiRJkiRJklTUSk3YvnXrVn73u9+xZcsWfvOb3+w2QN/ZunXrAEhLS9vt/u3t24/bk2rVqpGQUOoKAJQa+7PWgSSpYDn2lj6z52zlL7dsYN68bACOOjKJP/8xlVatSs1LOancc+yVpKLn2CtJRc+xV5KKnmNv8SoVd2hzcnK48cYbef/99znzzDMZPHhwkT32mjVriuyxypv09HQyMjKKuxuSVK449pYuW7cGHn0i8PQzkJMDVavCL6+MGHRiNgkJ6/CfUiodHHslqeg59kpS0XPslaSi59hbuPbngwwlPmzPycnh97//PWPGjOHUU0/lr3/9636dV6VKFQDWr1+/2/3b27cfJ0mSVJIsWhS4+X8Dc+fF2yf0h2G/iqhe3ZLxkiRJkiRJklQSlOiwPScnh5tuuolRo0Zx8sknc+utt+53SfeUlBRq167N4sWLyc7O3qXs/Pa12rev3S5JklQShBB4+RW4d3hg82aoUgV+e0NE3z6G7JIkSZIkSZJUkpTYxch3DtoHDRrEP//5z32u0/5TnTp1IjMzk48++miXfZMnTwagY8eOBdJfSZKkg7VyZeC3NwZu/08ctB97DDz5qEG7JEmSJEmSJJVEJTJs3146ftSoUZx44on861//2mvQvmrVKr755htWrVqVp/3MM88E4M4772TLli072t99911mzpxJjx49aNiwYeE8CUmSpHyYNDnwi4sD02dAcgX49dURt/8ronZtg3ZJkiRJkiRJKolKZBn5e++9l5dffpmUlBSaNWvG8OHDdzmmX79+tGnTBoCnn36ae+65h6uvvpphw4btOKZLly6cccYZjBw5kqFDh9K7d29WrFjBa6+9RvXq1fnjH/9YZM9JkiRpdzIzA3ffGxg9Nt5ueQj86Q8RLVoYskuSJEmSJElSSVYiw/YlS5YAkJmZyf3337/bYxo2bLgjbN+bm2++mdatW/P888/z5JNPkpKSQv/+/bnuuuto0qRJgfZbkiQpPz79LHDL/waWLIUognPOgksvjkhONmiXJEmSJEmSpJIuCiGE4u5ESZaRkVHcXSiz0tPT/f5KUhFz7C0ZsrICT4wIPDkCsnOgTh34400RRx9lyC6VRY69klT0HHslqeg59kpS0XPsLVzp6en7PKZEzmyXJEkqq75bHLj5fwNffBFv9+8H118TUaWKQbskSZIkSZIklSaG7ZIkSUUghMCrY+DuewObNkFaKtxwfUT/4w3ZJUmSJEmSJKk0MmyXJEkqZBkZgVv/FZg6Ld4+6kj4w00R9eoatEuSJEmSJElSaWXYLkmSVIimvRf4xz8DGRlQoQJcfmnEWWdAQoJBuyRJkiRJkiSVZobtkiRJhWDjxsC9wwOjXo23mzeDP/0xolVLQ3ZJkiRJkiRJKgsM2yVJkgrYF18Gbv7fwHffxdtnnRHPaK9Y0aBdkiRJkiRJksoKw3ZJkqQCkpUVeOoZeOyJQHY21K4Fv78xouOxhuySJEmSJEmSVNYYtkuSJBWAJUsCt/w98Oln8Xbf4+A310VUrWrQLkmSJEmSJEllkWG7JEnSQQghMHYc3Hl3YONGSE2F66+JGNAfosigXZIkSZIkSZLKKsN2SZKkA7R6deBftwfenRRvd2gPf7wpon59Q3ZJkiRJkiRJKusM2yVJkg7AjJmBv98aWLkKkpLgkosizj0bEhMN2iVJkiRJkiSpPDBslyRJyofNmwP33R948eV4u1lT+J8/RBza2pBdkiRJkiRJksoTw3ZJkqT9NHde4Jb/DSxcFG//bChcdUVExYoG7ZIkSZIkSZJU3hi2S5Ik7UN2duCZ/8IjjwWysqBmDfj9jRGdOxmyS5IkSZIkSVJ5ZdguSZK0F99/H/jbPwKz58TbvXrC726IqF7doF2SJEmSJEmSyjPDdkmSpN0IIfDGBLj9P4HMTKhcGa79dcSgEyGKDNolSZIkSZIkqbwzbJckSfqJtWsD/74j8Nbb8Xa7tvDH30c0bGDILkmSJEmSJEmKGbZLkiTt5P0PAn+/NbDiR0hMhIt+EXHeuZCUZNAuSZIkSZIkScpl2C5JkgRs3hx48OHAcyPj7caN4U9/iGhzmCG7JEmSJEmSJGlXhu2SJKnc++rrwC3/G5i/IN4efCr86qqIypUN2iVJkiRJkiRJu2fYLkmSyq2cnMB/n4eHHgls3Qrp6XDT7yK6dTVklyRJkiRJkiTtnWG7JEkql5YtD/zvPwIffRxvd+8GN/42Ij3doF2SJEmSJEmStG+G7ZIkqdyZ+Gbg33cE1q+HSpXg11dHnHISRJFBuyRJkiRJkiRp/xi2S5KkcmPdusDtdwYmTIy327SBP/0honEjQ3ZJkiRJkiRJUv4YtkuSpHLho48Df/tHYPlySEyAC86HX5wfkZRk0C5JkiRJkiRJyj/DdkmSVKZt2RJ4+NHAs89BCNCwAfzPHyLaHmHILkmSJEmSJEk6cIbtkiSpzJq/IHDz3wJffxNvn3ISDPtVREqKQbskSZIkSZIk6eAYtkuSpDInJyfwwktw/wOBLVuhejX4f7+N6NnDkF2SJEmSJEmSVDAM2yVJUpmyYkXg7/8XeP+DeLtLZ7jpdxE1axq0S5IkSZIkSZIKjmG7JEkqM95+J/DP2wLr1kHFivCrqyKGnAZRZNAuSZIkSZIkSSpYCQdzcps2bfj973+/z+P++Mc/cvjhhx/MQ0mSJO3Rhg2Bv/0jh//5Sxy0H9oaHn0wYujgyKBdkiRJkiRJklQoDmpmewiBEMJ+HytJklTQZs8J/O3vge9/gIQEOO9cuOgXERUqGLJLkiRJkiRJkgpPkZSRX7duHcnJyUXxUJIkqZzYujXw6BOBp5+BnByoXx/+5/cR7dsZskuSJEmSJEmSCl++w/alS5fm2c7MzNylbbvs7Gzmz5/P1KlTadKkyYH1UJIk6ScWLQr89X8D8+bF24NOhGuGRaSmGrRLkiRJkiRJkopGvsP2vn375ln7dPz48YwfP36v54QQOOOMM/LfO0mSpJ2EEHhpFNx3f2DzZqhaFX53Q0Sf3obskiRJkiRJkqSile+wvWPHjjv+/v7771OzZk2aN2++22OTk5OpU6cOffv2pX///gfeS0mSVO6tXBn4xz8D02fE2x2PhT/cGFGrlkG7JEmSJEmSJKno5StsX7p0KXfffTfVq1cH4LDDDqNnz5784x//KIy+SZIkAfDu5MA//xVYsxaSK8BVV0acPgQSEgzaJUmSJEmSJEnFIyE/Bx9//PH885//3LE9ZMgQWrduXeCdkiRJAsjMDNz6zxz+8D9x0N6qJTz8YMQZp0cG7ZIkSZIkSZKkYpWvsD2EQAhhx/bLL7/MvHnzCrxT/7+9+473cz78//+8skQS4yCCGCl1gtojdtX40NKh1KhaVVSr9khEEiIitiJGdaBKS9qqT5XSqiJWkNSM6scIQgkiQkTW6/fH+SXfpknIyTjzfr/d3Hqu8b6u1/vteN3SPN7XdQEAPPNsyaGHl9x+R1JVyXe+nfzkyiprfk5kBwAAAACg8dXrNvJLLbVU3nzzzcU1FgCATJtWcv0NJdffkMyYkXTrlvQ7rcomG4vsAAAAAAA0HfWK7RtssEEeeeSRnHbaaenevXuS5Pnnn8/QoUM/87VVVeXoo49esFECAK3Cq6+VDBpcMvr5uuXd/ic54bgqXboI7QAAAAAANC1V+c/7wn+GZ599NkcddVTGjRtX/xNVVUaPHl3v1zW28ePHN/YQWqyamhqfL0ADa6pzbykl/3t7cvkVJZMnJ126JKecWGXnnUR2oPlrqnMvQEtm7gVoeOZegIZn7l28ampqPnOfel3Z/oUvfCF//vOf8/TTT+ff//53+vTpk8022yzf+ta3FniQAEDrNn58yZDzSx56uG55s02T0/tUWXFFoR0AAAAAgKarXrE9STp37pytttoqSdKnT5+svvrq+eY3v7nIBwYAtHwPPlRy7gUl48cn7dsn3z+iyr7fStq0EdoBAAAAAGja6h3b/9M999yTTp06LaqxAACtxMcflwy9suS2P9Ytr7Vm0v/0Kp9fS2QHAAAAAKB5WKjY3r1790U1DgCglRj9fMnAs0tef71ueb99kyO/V2WJJYR2AAAAAACaj3rF9j/84Q9Jkl122SVdunSZtTy/9txzz3rtDwC0HNOmlfzqpuTa60qmz0i6rpCcflqVzTcT2QEAAAAAaH7qFdv79OmTqqqy0UYbpUuXLrOWP0spJVVVie0A0EqNHVsy6JySZ56tW955x+SkE6ssvZTQDgAAAABA81Sv2H700UenqqrU1NTMtgwAMDellPzpzuTSy0s+/jjp3Dk56fgq/7NL/BkCAAAAAIBmrV6x/ZhjjvnUZQCAmd5/v+S8C0seGF63vPFGSb/Tqqy0ksgOAAAAAEDzV6/YDgAwPx55tGTIeSXvvpe0a5cc8b0q+++btG0rtAMAAAAA0DKI7QDAIjN5cslVPyn53a11yz16JANOr1K7tsgOAAAAAEDLUq/YPnTo0AU+UVVVOfrooxf49QBA0/bPF0rOOrtkzKt1y9/aO/nBkVWWWEJoBwAAAACg5al3bK+qKqWUep9IbAeAlmn69JKbfpP87Bcl06cnyy+fnN6nSq8tRHYAAAAAAFquesX2IUOGLK5xAADN0Jtvlgw6p+Spp+uWv/TF5JSTqiyzjNAOAAAAAEDLVq/Y/s1vfnNxjQMAaEZKKfnz3ckll5ZMmpQsuWRy4nFVvrxb3d1sAAAAAACgpatXbAcAmDix5PyLSu79e93yBusn/fpW6b6KyA4AAAAAQOuxyGL7W2+9lSeeeCJvv/12kmTFFVfMpptumpVWWmlRnQIAaGQvvlRyev+S18cmbdsm3/tule98O2nbVmgHAAAAAKB1WejY/tZbb2XQoEH529/+llLKbNuqqsqOO+6Y/v37i+4A0Mz99Z6Scy8omTw5WalbMmhglXXXEdkBAAAAAGidFiq2v/XWW9l///3z5ptvZskll8y2226b7t27J0neeOONDB8+PPfcc0+effbZ3HzzzenWrdsiGTQA0HCmTSu56iclNw+rW95i8+SMflWWXVZoBwAAAACg9Vqo2H7JJZfkzTffzNe+9rWcfvrpWXbZZWfbPmHChJxzzjm57bbb8uMf/zhDhgxZmNMBAA3svfdKBgws+ceTdcsHfSc5/LDKbeMBAAAAAGj1Fiq233///Vl11VVz7rnnpm3btnNsX2aZZXLOOefkiSeeyN///veFORUA0MCeebak3xkl77yTdOqUnH5alR22F9kBAAAAACBJ2izMiydNmpSNNtporqF9prZt22ajjTbKxx9/vDCnAgAaSCklf7it5EfH1YX2HmskP71KaAcAAAAAgP+0UFe2r7nmmnn77bc/c7+33347a6655sKcCgBoAJ98UnLRJSV3/Llu+Us7JH17V+nUSWgHAAAAAID/tFBXth9yyCF5/PHH88ADD8xzn+HDh+fxxx/PwQcfvDCnAgAWszffLPnBMXWhvU2b5IdHVRl0ptAOAAAAAABzs1BXtm+xxRY54IAD8oMf/CC77757dt9996yyyipJkjfeeCN33nln7rjjjnznO99Jr1698sYbb8z2+pn7AgCN67HHS844q+SDD5Jll0nOHFBl881EdgAAAAAAmJeqlFIW9MXrrLNOqqpKKSVVNfe/kJ/Xtqqq8txzzy3oqRvM+PHjG3sILVZNTY3PF6CB/ffcW0rJr25KfvrzkhkzknV6JmefVWWlbkI7wKLiz70ADc/cC9DwzL0ADc/cu3jV1NR85j4LfWU7ANA8ffRRydlDSh4YXrf8tT2S44+tssQSQjsAAAAAAHyWhYrtN9xww6IaBwDQgF5+peT0/iWvvpa0b5+ccFyVr39VZAcAAAAAgPm1ULEdAGh+7v17yTnnlXz8cbJi17rbxq+3rtAOAAAAAAD1Ua/YPnTo0M/cp6qqdOrUKd26dctmm22Wbt26LfDgAIBFZ9q0kgsv+SjXXleSJJtukgwcUKWmRmgHAAAAAID6qndsr6r5/wv5Nm3aZNddd82AAQPm6wHyAMDiMf79kjPPKnli5OQkyQH7J0ceXqVdO6EdAAAAAAAWRL1i+5577vmZsb2Uko8//jivvfZann/++fz5z3/OSy+9lJtvvjkdO3ZcqMECAPU3+vmS0weUvP12suSSyWm9q+z0JZEdAAAAAAAWRr1i+7nnnluvg7/55pvp27dvHnnkkdx000057LDD6vV6AGDh/PH2kosvLZk6NVlttWTopctk+eUmNvawAAAAAACg2WuzOA++8sor57LLLkuXLl1y1113Lc5TAQD/YcqUkvMunJHzLqwL7dtvm/z0qiqfX6te37MDAAAAAADmYbH/jftSSy2VzTbbLE888cTiPhUAkOStt0v6DSgZ/XxSVckR36ty4AFJmzZuHQ8AAAAAAItKg1ze1qVLl3z88ccNcSoAaNWeGFlyxsCS9yckSy+dnNGvypa9RHYAAAAAAFjUGiS2v/7666mpqWmIUwFAq1RKya9vTq6+pmTGjKR27WTwWVVWXlloBwAAAACAxWGxx/annnoqTz31VHbaaafFfSoAaJUmTSoZcn7JvX+vW/7KbsnJJ1ZZYgmhHQAAAAAAFpfFEts/+eSTvPbaa/n73/+en/70pymlZP/9918cpwKAVu3VV0v69i95ZUzSrl1y3DFV9vx6UlVCOwAAAAAALE71iu3rrrtuvU9QSskRRxyR7bbbrt6vBQDm7f4HSs4eUjJpUrLCCsnZA6us/wWRHQAAAAAAGkK9YnspZb737dixYzbddNMcfPDB+dKXvlTfcQEA8zB9esnPri254Vd1yxtvlAwcUGX55YV2AAAAAABoKPWK7ffcc89n7lNVVTp27Jhll102bdq0WeCBAQBzmjChZODZJSMeq1ve91vJD4+q0q6d0A4AAAAAAA2pXrG9e/fui2scAMBn+OcLJaf3L/n3W0nHjknvU6r8z84iOwAAAAAANIZ6xXYAoHHc+eeSCy4umTIl6b5Kcs7ZVdZaU2gHAAAAAIDGIrYDQBM2dWrJpUNL/nBb3fI2Wyf9+1ZZaimhHQAAAAAAGpPYDgBN1LhxJf3OKHn2uaSqksMOrXLIQUmbNkI7AAAAAAA0NrEdAJqgfzxZ0v/MkvHjky5dkjP6Vdl6K5EdAAAAAACaCrEdAJqQUkqG/Ta54qqS6TOStdZKzjmrSvfuQjsAAAAAADQlYjsANBEff1xy7gUl9/ytbnnXXZJTT67SsaPQDgAAAAAATY3YDgBNwOuvl/TtX/LSy0nbtskxR1fZ+5tJVQntAAAAAADQFIntANDIHnyoZNDgkg8/SpZfLjnrzCobbSiyAwAAAABAUya2A0AjmTGj5NrrS669vm55g/WTQWdWWWEFoR0AAAAAAJo6sR0AGsEHE+uuZn/4kbrlvb+Z/OiHVdq3F9oBAAAAAKA5ENsBoIH96/9KTh9Q8sYbSYcOyaknV/nyriI7AAAAAAA0J2I7ADSgu+4uOf+ikk8+SVZeOTnnrCprry20AwAAAABAcyO2A0ADmDatZOiVJb/9fd3ylr2SM/pVWXppoR0AAAAAAJojsR0AFrN33i0ZcGbJU0/XLR96cPLdQ6q0bSu0AwAAAABAcyW2A8Bi9NTTJf3PKHn3vaRz56R/3yrbbSuyAwAAAABAcye2A8BiUErJ729NLruiZPr05HM9ksGDqqy+mtAOAAAAAAAtgdgOAIvY5MklF1xcctfddcs775j0PqVKp05COwAAAAAAtBRiOwAsQmPfKDm9f8n/vZi0bZP84Kgq++2TVJXQDgAAAAAALYnYDgCLyMOPlpx1dsnEicmyyyZnnVFl001EdgAAAAAAaInEdgBYSDNmlPzyV8nPry0pJVlv3eTsgVVWXFFoBwAAAACAlkpsB4CFMHFiydlDSh58qG75G19LjjumSocOQjsAAAAAALRkYjsALKCXXirp27/k9bFJh/bJSSdW2eMrIjsAAAAAALQGYjsALIB7/lYy5PySyZOTbt2SwWdVWaen0A4AAAAAAK2F2A4A9TBtWslVPym5eVjd8uabJWf2r7LsskI7AAAAAAC0JmI7AMyn994rGTCw5B9P1i0feEByxPeqtG0rtAMAAAAAQGsjtgPAfHjm2ZL+Z5SMeydZcsmk32lVdviiyA4AAAAAAK2V2A4An6KUktv+N/nx5SXTpiVrrJ6cM6jKGmsI7QAAAAAA0JqJ7QAwD598UnLRj0vuuLNueYcvJqf3qdKpk9AOAAAAAACtndgOAHPx73+X9B1Q8sILSZs2yZGHV/nOt5OqEtoBAAAAAACxHQDm8NjjJWeeVTLhg2SZpZOBZ1TZfDORHQAAAAAA+H/EdgD4/5VS8qubkp/+vGTGjKRnbTL4rCorrSS0AwAAAAAAsxPbASDJRx+VDD635P4H6pa/untywnFVllhCaAcAAAAAAOYktgPQ6r0ypqRvv5JXX0vat6+L7F//qsgOAAAAAADMm9gOQKv29/vqrmj/+OOk6wrJ2WdV+cJ6QjsAAAAAAPDpxHYAWqVp00qu+XnJTb+uW95k4+SsM6rU1AjtAAAAAADAZxPbAWh1xr9fcuZZJU+MrFv+9n7J94+o0q6d0A4AAAAAAMwfsR2AVmX08yWnDyh5++1kyY5Jn95Vdt5RZAcAAAAAAOpHbAeg1bj9TyUX/bhk6tRk1VWTcwZVWfNzQjsAAAAAAFB/YjsALd6UKSU/vrzkf/9Yt7z9tsnpp1Xp0kVoBwAAAAAAFozYDkCL9tbbJf3OKBk9Oqmq5PDDqhz0naRNG6EdAAAAAABYcGI7AC3WyFElAwaWvP9+stRSyZn9q2zZS2QHAAAAAAAWntgOQItTSsmvb06uvqZkxoxk7c8ngwdVWWVloR0AAAAAAFg0xHYAWpRJk0qGnF9y79/rlr+8W3LKiVWWWEJoBwAAAAAAFh2xHYAW49VXS/oOKHnllaRt2+S4Y6p88xtJVQntAAAAAADAotVkY/ttt92WJ554Is8880xeeOGFTJ06NUOGDMlee+0138d49NFHc/DBB89ze32PB0DTdf8DJWcPKZk0KVl++eTsgVU2WF9kBwAAAAAAFo8mG9svvfTSjB07NjU1NVlxxRUzduzYBT5Wr1690qtXrznWr7vuugszRACagFJKrr0++cV1JUmy0YbJWWdUWX55oR0AAAAAAFh8mmxsP/vss7PGGmuke/fuueaaa3LRRRct8LF69eqVY445ZhGODoCmYNq0kgsuLvnTHXXL++ydHP2DKu3aCe0AAAAAAMDi1WRj+zbbbNPYQwCgCZs0qaT/mSWPjkjatElOPL7Knl8X2QEAAAAAgIbRZGP7ovTKK6/kuuuuyyeffJJu3bpl6623Trdu3Rp7WAAsoPfeKzmlT8k/X0iWWCIZeEaV7bYR2gEAAAAAgIbTKmL77bffnttvv33Wcrt27XLggQfm1FNPTdu2bRtxZADU16uvlZx0asmbbybLLpOcN6TKF9YT2gEAAAAAgIbVomP7csstl5NOOik77rhjunfvno8//jijRo3KRRddlOuuuy5VVaVPnz6feoxlllkmbdq0aaARtz41NTWNPQSgGXnyqan54TET8/77yWqrtslPrlw6a6zhS1P1Ze4FaHjmXoCGZ+4FaHjmXoCGZ+5tXC06tq+99tpZe+21Zy136tQpu+yySzbaaKN8/etfzw033JAjjjgiyy+//DyPMWHChIYYaqtUU1OT8ePHN/YwgGZi+IMlZ5xV8sknyTo9k/OHlCy99AcxjdSPuReg4Zl7ARqeuReg4Zl7ARqeuXfxmp8vMrTKS7a7du2anXfeOdOmTcuTTz7Z2MMB4DPceltJ3/51oX3rrZLLf1xlueXcOh4AAAAAAGg8LfrK9k8z85sIH3/8cSOPBIB5KaXkmp+X3PCruuWv7ZGcdEKVdu2EdgAAAAAAoHG12tg+84r27t27N/JIAJibqVNLzruw5M931S0fdmiV7x6SVJXQDgAAAAAANL4WcRv59957Ly+++GLee++92dY/88wzc93/+uuvz6OPPpoePXpkgw02aIghAlAPH31UcuppdaG9bZukzylVDju0EtoBAAAAAIAmo8le2T5s2LA88cQTSZIXXnhh1roRI0YkSTbbbLPss88+SZIbb7wxQ4cOzY9+9KMcc8wxs45x7LHHpl27dll//fXTrVu3fPzxx3nyySfz3HPPZemll84FF1yQtm3bNvA7A+DTvPNuySm9S/71f0nHjsmgM6tsvZXIDgAAAAAANC1NNrY/8cQTufXWW2dbN3LkyIwcOXLW8szYPi/7779/hg8fnsceeyzvv/9+2rRpk1VWWSWHHHJIDjvssKy00kqLZewALJhXxpScfGrJv99KamqSC4ZUWWcdoR0AAAAAAGh6qlJKaexBNGXjx49v7CG0WDU1NT5fYJanni7p3bdk4sRk1VWTi86v0n0VoX1RM/cCNDxzL0DDM/cCNDxzL0DDM/cuXjU1NZ+5T4t4ZjsAzdt995ccf2JdaF9v3eSqoUI7AAAAAADQtDXZ28gD0Dr89vcll15eUkqy3bbJmf2rdOwotAMAAAAAAE2b2A5Ao5gxo+Tqa0pu+k3d8p5fT44/tkq7dkI7AAAAAADQ9IntADS4KVNKhpxf8pe/1i0feXiVg76TVJXQDgAAAAAANA9iOwAN6sMPS/r2Lxk5KmnbNulzSpWvfFlkBwAAAAAAmhexHYAGM25cycm9S158KVlyyWTwWVV6bSG0AwAAAAAAzY/YDkCDeOnlkpNPLXl7XLL8cskF51WpXVtoBwAAAAAAmqc2jT0AAFq+Uf8o+eExdaF99dWSq68Q2gEAAAAAgOZNbAdgsbrn3pITTyn58MNkg/WTq4ZWWXlloR0AAAAAAGje3EYegMXm5mEll19RkiRf3D45o1+VJZYQ2gEAAAAAgOZPbAdgkZsxo+SKq0puHla3vPc3k2N/VKVtW6EdAAAAAABoGcR2ABapTz4pGXxuyd/urVv+wferHLB/UlVCOwAAAAAA0HKI7QAsMh9MLOnbr+QfTybt2iV9+1TZdReRHQAAAAAAaHnEdgAWibfeLjnp1JJXXkk6d04Gn1Vl882EdgAAAAAAoGUS2wFYaP/3YsnJvUveeSdZYYXkwvOqfH4toR0AAAAAAGi52jT2AABo3p4YWXL0sXWhvUeP5OorhHYAAAAAAKDlE9sBWGB3/7Xu1vEffZRsvFFy5eVVVuomtAMAAAAAAC2f28gDUG+llNz0m+Sqn5QkyU47Jqf3qbLEEkI7AAAAAADQOojtANTL9Okll19R8tvf1y3vt09y9A+qtGkjtAMAAAAAAK2H2A7AfPvkk5KzBpfcd3/d8jFHV9lvH5EdAAAAAABofcR2AObLhAklfU4vefqZpH37pN9pVXbeSWgHAAAAAABaJ7EdgM/05pslJ51a8uprSZfOyTlnV9l0E6EdAAAAAABovcR2AD7VC/8qOaV3ybvvJSt2TS48v8qanxPaAQAAAACA1q1NYw8AgKZrxGMlRx9bF9rXWjO5+gqhHQAAAAAAIHFlOwDzcOddJeeeXzJ9erLpJsk5g6p06SK0AwAAAAAAJGI7AP+llJIbbkyu+VlJkuyyc9K3d5UOHYR2AAAAAACAmcR2AGaZPr3kkktL/vC/dcsH7J8cdWSVNm2EdgAAAAAAgP8ktgOQJJk8ueTMQSXDH0yqKjnumCrf2ktkBwAAAAAAmBuxHYC8/35J774lzz6XdGifDOhX5Us7CO0AAAAAAADzIrYDtHJj3yg56dSS119PlloqOXdwlY02FNoBAAAAAAA+jdgO0Io9/3zJKaeVjB+frNQtufD8Kj3WENoBAAAAAAA+S5vGHgAAjePhR0uOOb4utK/9+eTqK4V2AAAAAACA+eXKdoBW6PY7Si64sGT6jGSLzZOzB1bp3FloBwAAAAAAmF9iO0ArUkrJtdcnv7iuJEm+vFvS++Qq7dsL7QAAAAAAAPUhtgO0EtOmlVx0Sckf/1S3fNCByZHfq1JVQjsAAAAAAEB9ie0ArcDHH5ecMbDkoUeSNm2SE46r8s1viOwAAAAAAAALSmwHaOHGjy85pU/J8/9MOnRIBg6osv12QjsAAAAAAMDCENsBWrDXXy856dSSsW8kyyydnDekyvpfENoBAAAAAAAWVpvGHgAAi8ezz5UcdXRdaF955eSqK4R2AAAAAACARUVsB2iBhj9UcuwJJe9PSHrWJj+5osrqqwntAAAAAAAAi4rbyAO0MH/435KLf1wyY0ayZa9k0JlVOnUS2gEAAAAAABYlsR2ghSil5Ge/KLn+hrrl3b+SnHpSlXbthHYAAAAAAIBFTWwHaAGmTSs5/8KSO/5ct/zdQ5LDDq1SVUI7AAAAAADA4iC2AzRzkyaV9DujZMRjSds2yUknVvn6V0V2AAAAAACAxUlsB2jG3n235JTTSl54IenYMTnrjCrbbC20AwAAAAAALG5iO0Az9eqrJSedWvLmv5Nll03OH1JlvXWFdgAAAAAAgIbQprEHAED9Pf1MyVE/qgvtq3ZPrh4qtAMAAAAAADQksR2gmbnvgZLjTiz54INk3XWTq66osuqqQjsAAAAAAEBDcht5gGbkd7eW/PiyklKSbbZOBg6osuSSQjsAAAAAAEBDE9sBmoEZM0p+8tOSG39dt/z1ryUnHlelXTuhHQAAAAAAoDGI7QBN3NSpJeeeX3LXX+qWDz+syiEHJVUltAMAAAAAADQWsR2gCfvoo5LTB5Q8/kTStk1y6ilV9viKyA4AAAAAANDYxHaAJuqdd0pO6l3y4ovJkh2TQQOrbLWl0A4AAAAAANAUiO0ATdDLr5Sc3LvkrbeS5WqS88+tsk5PoR0AAAAAAKCpaNPYAwBgdk8+VfKDH9WF9tVWS66+UmgHAAAAAABoasR2gCbk3r+XnHBSyYcfJut/Ibnq8iqrrCy0AwAAAAAANDVuIw/QRNzy25LLrygpJdl+u+SMflU6dhTaAQAAAAAAmiKxHaCRzZhRcuXVJb+5pW75m3smxx9TpW1boR0AAAAAAKCpEtsBGtGUKSWDzy255291y98/osqBByRVJbQDAAAAAAA0ZWI7QCOZOLGkb/+SUf9I2rZNTutd5cu7iuwAAAAAAADNgdgO0AjeervklN4lL72cdOqUDD6ryhabC+0AAAAAAADNhdgO0MBefKnk5FNLxr2TLL98cuG5VdZeW2gHAAAAAABoTto09gAAWpORo0qOPqYutPdYI/nJFUI7AAAAAABAcyS2AzSQv95TctKpJR9+lGy4QXLl5VVWWkloBwAAAAAAaI7cRh5gMSul5De3JFdcVZIkX/pi0v/0KkssIbQDAAAAAAA0V2I7wGI0fXrJ0CtLhv2ubvlbeyfH/LBK27ZCOwAAAAAAQHMmtgMsJp98UjJocMnf769bPvoHVfbfN6kqoR0AAAAAAKC5E9sBFoMPPig5rV/Jk08l7dolp59W5X92FtkBAAAAAABaCrEdYBF7772SY08seeWVpHPnZMjZVTbdRGgHAAAAAABoScR2gEVo/Pslx/3/oX2FFZKLzq+y1ppCOwAAAAAAQEsjtgMsIhMmlBx/UsnLr9SF9qE/rrLqqkI7AAAAAABAS9SmsQcA0BJ88EFdaH/xxWT55ZLLLhbaAQAAAAAAWjKxHWAhTZxYcsLJJf/6v6SmJrn0kiqrry60AwAAAAAAtGRiO8BC+PDDkhNPLfnnC8myyySXXlSlxxpCOwAAAAAAQEsntgMsoEmTSk7uXTJ6dLL00sklF1VZc02hHQAAAAAAoDUQ2wEWwMcfl5zSp+SZZ5MuXZJLLqyy9ueFdgAAAAAAgNZCbAeop8mTS049reTJp5IunZMfX1ilZ63QDgAAAAAA0JqI7QD18MknJb37loz6R9KpU3LRBVXWWUdoBwAAAAAAaG3EdoD59MknJaf1K3liZLLkkslF51f5wnpCOwAAAAAAQGsktgPMhylTSvqdUTLisaRjx+TC86pssL7QDgAAAAAA0FqJ7QCfYerUkgEDSx5+JFliieT8IVU22lBoBwAAAAAAaM3EdoBPMW1ayRlnlQx/MOnQITl3cJVNNxHaAQAAAAAAWjuxHWAepk0rGXh2yf0PJO3bJ0POrrLF5kI7AAAAAAAAYjvAXE2fXnL2kJJ7/560a5cMPqvKlr2EdgAAAAAAAOqI7QD/Zfr0knPOK/nrPUnbtsnZA6tss7XQDgAAAAAAwP8jtgP8hxkzSs67sOSuu5O2bZKzzqiy3bZCOwAAAAAAALMT2wH+fzNmlFxwcckddyZt2iQD+lfZ4YtCOwAAAAAAAHMS2wGSlFJy8aUlf7y9LrT361tl5x2FdgAAAAAAAOZObAdavVJKLr285A+3JVWVnNa7yq67CO0AAAAAAADMm9gOtGqllAy9quS3v69b7n1Kla/sJrQDAAAAAADw6cR2oNUqpeSqa0puvqVu+ZSTqnx1d6EdAAAAAACAzya2A61SKSU//XnJTb+uWz7x+Crf+JrQDgAAAAAAwPwR24FW6drrk1/+qu7n446psteeQjsAAAAAAADzT2wHWp3rbyj5xXUlSfKjH1bZZ2+hHQAAAAAAgPoR24FW5Vc31d0+PkmOOrLK/vsK7QAAAAAAANSf2A60Gr+5peTqa+pC+xHfq3LgAUI7AAAAAAAAC0ZsB1qFYb8rGXplXWj/7iHJIQcJ7QAAAAAAACw4sR1o8X7/h5JLL68L7QcfmBx2qNAOAAAAAADAwhHbgRbttj+WXPzjutB+wLfrbh9fVWI7AAAAAAAAC0dsB1qs2+8oueCiutC+3z7JD44U2gEAAAAAAFg0xHagRbrzrpLzLqgL7d/aK/nRD4V2AAAAAAAAFh2xHWhx7v5ryZDzSkpJ9vxGctwxQjsAAAAAAACLltgOtCj33Fty9jklM2YkX/tqcuJxQjsAAAAAAACLntgOtBj33V9y1qC60L77V5JTTqzSpo3QDgAAAAAAwKIntgMtwgPDSwYMLJk+I9lt16T3yUI7AAAAAAAAi4/YDjR7Dz1c0v/MkunTk112Tvr2rtK2rdAOAAAAAADA4iO2A83aoyNKTh9QMm1asuOXkn6nCe0AAAAAAAAsfmI70Gw99njJaaeXTJ2afHH75Ix+Vdq1E9oBAAAAAABY/MR2oFkaOaqkz+klU6Ym226TDBwgtAMAAAAAANBwxHag2fnHkyWnnlbyySfJ1lslg86s0r690A4AAAAAAEDDEduBZuXpZ0pO6V0yeXLSa4vk7IFVOnQQ2gEAAAAAAGhYYjvQbDz7XMlJp5Z8PDnZbNNkyNlVllhCaAcAAAAAAKDhie1As/D88yUnnlIyaVKyycbJeecI7QAAAAAAADQesR1o8v75QsnxJ5d89FGy4QZ1ob1jR6EdAAAAAACAxiO2A03av/6v5ISTSz78MFn/C8mF51Xp1EloBwAAAAAAoHGJ7UCT9dJLJSecVPLBB8m66yYXnS+0AwAAAAAA0DSI7UCT9MqYkuNOKnl/QtKzNrn4/CqdOwvtAAAAAAAANA1iO9DkvPpqyXEnlIwfn6z9+eSSC6sstZTQDgAAAAAAQNMhtgNNyuuvlxx7Ysm77yVrrZX8+KIqSy8ttAMAAAAAANC0iO1AkzH2jZJjTyh5553kcz3qQvsyywjtAAAAAAAAND1iO9AkvPlmXWh/e1yyxurJpRdXqVlWaAcAAAAAAKBpEtuBRvfW23W3jn/rrWS11ZJLL6my3HJCOwAAAAAAAE2X2A40qnHjSo49vuTNN5PuqySXXVxlheWFdgAAAAAAAJo2sR1oNO+8W3LMCSVj30hWXjm57MdVunYV2gEAAAAAAGj6xHagUbz3XslxJ5S8/nrSrVvdFe3dVhTaAQAAAAAAaB7EdqDBjX+/5LgTS8a8mqzYNbnskiorryy0AwAAAAAA0HyI7UCDmjCh5PiTSl5+JVlhheTSS6p0X0VoBwAAAAAAoHkR24EG88EHdaH9xReT5Zeru3X8aqsK7QAAAAAAADQ/7Rp7APNy22235YknnsgzzzyTF154IVOnTs2QIUOy11571es4M2bMyI033phbbrklY8aMSadOnbLNNtvkhBNOyGqrrbaYRg/8t4kTS044ueRf/5fU1CQ/vrjK6qsL7QAAAAAAADRPTTa2X3rppRk7dmxqamqy4oorZuzYsQt0nAEDBmTYsGFZe+21c9BBB+Xtt9/OnXfemQcffDA333xzevTosWgHDszhww9LTjy15J8vJMsuk1x6UZXP9RDaAQAAAAAAaL6a7G3kzz777Pztb3/LI488kv3333+BjvHII49k2LBh2WKLLfL73/8+p5xySi644IJcccUVef/99zNo0KBFPGrgv02aVHJy75LRo5Oll04uuajKmmsK7QAAAAAAADRvTfbK9m222WahjzFs2LAkyXHHHZcOHTrMWr/DDjukV69eGT58eN54442sssoqC30uYE4ff1xySp+SZ55NunRJLrmwytqfF9oBAAAAAABo/prsle2LwqOPPppOnTpl0003nWPb9ttvnyQZMWJEQw8LWoXJk0tOPa3kyaeSzp3rQnvPWqEdAAAAAACAlqHFxvZJkyZl3LhxWXXVVdO2bds5tq+xxhpJkjFjxjT00KDF++STkt59S0b9I+nUKbno/CrrriO0AwAAAAAA0HI02dvIL6yJEycmSbp06TLX7TPXz9xvXpZZZpm0adNiv5PQ6Gpqahp7CCxidaF9Yp4YOTVLLpn85Mqls+km7Rt7WMB/MPcCNDxzL0DDM/cCNDxzL0DDM/c2rhYb2xeVCRMmNPYQWqyampqMHz++sYfBIjRlSsnpA0oefiTp2DG54Nwqn+vxYfxrhqbD3AvQ8My9AA3P3AvQ8My9AA3P3Lt4zc8XGVrsJdtLLbVUkuTDDz+c6/aZ62fuByycqVNLBgysC+1LLJGcP6TKxhu5dTwAAAAAAAAtU4uN7Z06dUrXrl3z+uuvZ/r06XNsn/ms9pnPbgcW3LRpJWecVTL8waRDh+TcwVU23URoBwAAAAAAoOVqsbE9SXr16pVJkyZl5MiRc2x74IEHkiRbbLFFQw8LWpRp00oGnl1y/wNJ+/bJkLOrbLG50A4AAAAAAEDL1iJi+3vvvZcXX3wx77333mzr99133yTJpZdemilTpsxaf99992XEiBHZbrvt0r179wYdK7Qk06eXnD2k5N6/J+3aJYPPqrJlL6EdAAAAAACAlq9dYw9gXoYNG5YnnngiSfLCCy/MWjdixIgkyWabbZZ99tknSXLjjTdm6NCh+dGPfpRjjjlm1jG22mqr7LPPPhk2bFj22muv7LDDDhk3blzuuOOOLLvssunXr18DvytoOaZPLznnvJK/3pO0bZsMOrPKNlsL7QAAAAAAALQOTTa2P/HEE7n11ltnWzdy5MjZbgk/M7Z/mrPOOiu1tbW55ZZb8stf/jKdOnXK//zP/+SEE07I6quvvsjHDa3BjBkl511YctfdSds2ycABVbbfTmgHAAAAAACg9ahKKaWxB9GUjR8/vrGH0GLV1NT4fJuhGTNKLri45I+3J23aJGf0r7LzjkI7NBfmXoCGZ+4FaHjmXoCGZ+4FaHjm3sWrpqbmM/dpEc9sBxpGKSUXX/r/Qnu/vkI7AAAAAAAArZPYDsyXUkouvbzkD7clVZWc1rvKrrsI7QAAAAAAALROYjvwmUopGXpVyW9/X7fc+5QqX9lNaAcAAAAAAKD1EtuBT1VKyVXXlNx8S93yKSdV+eruQjsAAAAAAACtm9gOzFMpJT/9eclNv65bPvH4Kt/4mtAOAAAAAAAAYjswT9den/zyV3U/H3dMlb32FNoBAAAAAAAgEduBebj+hpJfXFeSJD/6YZV99hbaAQAAAAAAYCaxHZjDr26qu318khx1ZJX99xXaAQAAAAAA4D+J7cBsfnNLydXX1IX2I75X5cADhHYAAAAAAAD4b2I7MMuw35UMvbIutH/3kOSQg4R2AAAAAAAAmBuxHUiS/P4PJZdeXhfaDzowOexQoR0AAAAAAADmRWwHctsfSy7+cV1oP+DbyZHfq1JVYjsAAAAAAADMi9gOrdztd5RccFFdaN9vn+QHRwrtAAAAAAAA8FnEdmjF7ryr5LwL6kL7t/ZKfvRDoR0AAAAAAADmh9gOrdTdfy0Zcl5JKcme30iOO0ZoBwAAAAAAgPkltkMrdM+9JWefUzJjRvK1PZITjxPaAQAAAAAAoD7Edmhl7ru/5KxBdaF99y8np5xUpU0boR0AAAAAAADqQ2yHVuSB4SUDBpZMn5HstmvS+xShHQAAAAAAABaE2A6txEMPl/Q/s2T69GSXnZO+vau0bSu0AwAAAAAAwIIQ26EVGDmq5PQBJdOmJTt+Kel3mtAOAAAAAAAAC0NshxbutdfrQvvUqcn22yVn9KvSrp3QDgAAAAAAAAtDbIcW7IOJJaeeVjJxYrLeusmZ/YV2AAAAAAAAWBTEdmihpk0r6X9GyWuvJSuumAw5u8oSSwjtAAAAAAAAsCiI7dBCXTq05ImRyZIdk/MGV1l+eaEdAAAAAAAAFhWxHVqg3/2+5NY/JFWV9D+9ytprC+0AAAAAAACwKInt0MKMeKzk0qElSfL9I6p8cXuhHQAAAAAAABY1sR1akFfGlPQ/s2TGjOQruyXf+XZjjwgAAAAAAABaJrEdWogJE0pOPa3ko4+SDdZPTjmpSlW5qh0AAAAAAAAWB7EdWoCpU0tOH1DyxhvJyisl55xdpUMHoR0AAAAAAAAWF7EdmrlSSi68pOQfTyadOiXnnVOlZlmhHQAAAAAAABYnsR2auZuHJX+6I2nTJhk4oMqaawrtAAAAAAAAsLiJ7dCMPfhQyRVXlSTJj35QZeuthHYAAAAAAABoCGI7NFMvvlRy5qCSUpKvfTXZ51uNPSIAAAAAAABoPcR2aIbGjy/pfVrJxx8nm2ycnHR8lapyVTsAAAAAAAA0FLEdmplPPinp27/k328lq3ZPBp9VpV07oR0AAAAAAAAaktgOzUgpJedfWPL0M0mXzsn5Q6osvbTQDgAAAAAAAA1NbIdm5Fc3JXf9JWnbJhk0sMrqqwvtAAAAAAAA0BjEdmgm7ru/5Cc/LUmS446tssXmQjsAAAAAAAA0FrEdmoEX/lUy6Jy60L73N5O99hTaAQAAAAAAoDGJ7dDEvfNuSe/TSiZPTnptkRxztNAOAAAAAAAAjU1shybsk09KTju9ZNw7yRqrJwMHVGnXTmwHAAAAAACAxia2QxNVSsngc0tGP58svXRy3jlVllpKaAcAAAAAAICmQGyHJuoX15X87d6kbdtk8FlVVl1VaAcAAAAAAICmQmyHJuiv95Rce33dz6ecWGWTjYV2AAAAAAAAaErEdmhinhtdcs55JUmy377JV/cQ2gEAAAAAAKCpEduhCXnr7ZLTTi+ZMiXZZqvkh98X2gEAAAAAAKApEtuhifj445I+fUvefS9Z83PJGf2rtG0rtgMAAAAAAEBTJLZDEzBjRslZg0v+9X/Jsssm551TpXNnoR0AAAAAAACaKrEdmoCf/rzkgeFJ+/bJOYOqrLyy0A4AAAAAAABNmdgOjezOu0puuLHu596nVNlwA6EdAAAAAAAAmjqxHRrRU0+XnH9hSZIc9J3ky7sK7QAAAAAAANAciO3QSN58s6Rv/5KpU5Mvbp8c8T2hHQAAAAAAAJoLsR0awUcflfTuW/L++8nan0/6963Spo3YDgAAAAAAAM2F2A4NbPr0koGDSl56OVl+ueS8c6osuaTQDgAAAAAAAM2J2A4N7MqflDz0SNKhQzJkcJUVVxTaAQAAAAAAoLkR26EB/fH2kptvqfv59D5V1ltXaAcAAAAAAIDmSGyHBjJyVMmFl5QkyWGHVtl5J6EdAAAAAAAAmiuxHRrA66+X9DujZPr0ZOcdk+8e0tgjAgAAAAAAABaG2A6L2cSJJb37lnzwQbLuOknfPlWqylXtAAAAAAAA0JyJ7bAYTZtWMmBgyZhXk64rJEMGV1liCaEdAAAAAAAAmjuxHRajy68oeezxpGPH5LwhVVZYXmgHAAAAAACAlkBsh8Xk938o+d2tdT/3P71K7dpCOwAAAAAAALQUYjssBo89XnLpZSVJ8v0jquywvdAOAAAAAAAALYnYDovYmDEl/c8omT4j2W3X5MADGntEAAAAAAAAwKImtsMiNGFCyamnlXz4UbLB+knvk6tUlavaAQAAAAAAoKUR22ERmTq1pN8ZJWPfSFbqlpwzqEqHDkI7AAAAAAAAtERiOywCpZRcfGnJqH8kSy6ZnDekSk2N0A4AAAAAAAAtldgOi8Cw3yZ/vD2pquTM/lXWWlNoBwAAAAAAgJZMbIeF9PAjJUOvKkmSo39QZdtthHYAAAAAAABo6cR2WAgvvVRyxlklM2YkX9092W+fxh4RAAAAAAAA0BDEdlhA48eX9O5bMmlSsvFGyUknVKkqV7UDAAAAAABAayC2wwKYMqWkb/+SN/+ddF8lGXxWlfbthXYAAAAAAABoLcR2qKdSSs6/qOTpZ5IunZPzh1RZZhmhHQAAAAAAAFoTsR3q6cZfJ3++K2nbJjnrzCprrCG0AwAAAAAAQGsjtkM93P9AyU9+WpIkxx5TpdcWQjsAAAAAAAC0RmI7zKcX/lVy1uCSUpJv7pns/U2hHQAAAAAAAForsR3mw7vvlvTpWzJ5crL5ZslxPxLaAQAAAAAAoDUT2+EzfPJJSZ9+JW+PS1Zfre457e3aie0AAAAAAADQmont8ClKKTnnvJLRo5OllkrOG1Jl6aWEdgAAAAAAAGjtxHb4FNf9Mrnnb0nbtsngs6qstqrQDgAAAAAAAIjtME/33Fvy82tLkuSkE6psuonQDgAAAAAAANQR22EuRj9fMnhIXWjfb5/k618V2gEAAAAAAID/R2yH//L22yV9Ti+ZMiXZeqvkh0cJ7QAAAAAAAMDsxHb4Dx9/XNKnX8m77yaf65Gc2b9K27ZiOwAAAAAAADA7sR3+fzNmlJw9pOSFF5Jll0nOG1Klc2ehHQAAAAAAAJiT2A7/v5/9ouS++5P27ZPBg6qssrLQDgAAAAAAAMyd2A5J7rq75Je/qvv51JOqbLSh0A4AAAAAAADMm9hOq/fMsyXnXlCSJN/5dvKVLwvtAAAAAAAAwKcT22nV/v3vktP6lUydmmy/XfL9I4R2AAAAAAAA4LOJ7bRakyaV9O5bMn588vm1kv59q7RpI7YDAAAAAAAAn01sp1WaPr3kzEElL76ULFeTnDekSqdOQjsAAAAAAAAwf8R2WqWrryl56OGkQ/tkyOAq3VYU2gEAAAAAAID5J7bT6tx+R8mvb677+bQ+Vb6wntAOAAAAAAAA1I/YTqsy6h8lF15ckiTfPST5n52FdgAAAAAAAKD+xHZajbFjS/oNKJk2LdnxS8l3DxHaAQAAAAAAgAUjttMqfPhhSe++JRM+SNbpmZzep0qbNmI7AAAAAAAAsGDEdlq8adNKBgwseWVM0nWF5NzBVTp2FNoBAAAAAACABSe20+INvapkxGPJEksk52WgLi0AACq1SURBVJ5TZYUVhHYAAAAAAABg4YjttGh/uK3kt7+r+7l/3yo9a4V2AAAAAAAAYOGJ7bRYjz1ecsmlJUlyxPeqfGkHoR0AAAAAAABYNMR2WqRXXy3pf2bJ9BnJrrskBx/Y2CMCAAAAAAAAWhKxnRbngw9KTu1b8uGHyfpfSHqfUqWqXNUOAAAAAAAALDpiOy3KtGl1V7S//nrSrVtyzqAqSywhtAMAAAAAAACLlthOi1FKycWXljwxMllyyeS8c6ost5zQDgAAAAAAACx6YjstxrDfJf/7x6SqkjP6V/n8WkI7AAAAAAAAsHiI7bQIDz9aMvTKkiT5wferbLeN0A4AAAAAAAAsPmI7zd5LL5ecMbBkxoxkj92Tb+/X2CMCAAAAAAAAWjqxnWZt/PslvfuWTJqUbLxRcvIJVarKVe0AAAAAAADA4iW202xNmVJyev+SN99MVlklOXtglfbthXYAAAAAAABg8RPbaZZKKbnw4pKnnk46d07OO6fKsssK7QAAAAAAAEDDENtpln59c3LHn5M2bZKBA6p8rofQDgAAAAAAADQcsZ1mZ/iDJVf9pCRJjv1Rla22FNoBAAAAAACAhiW206z86/9KBg4qKSXZ8+vJ3t9s7BEBAAAAAAAArZHYTrPx7rslvfuWfDw52WzT5Phjq1SVq9oBAAAAAACAhie20yx88klJ3/4lb7+drLZaMmhglXbthHYAAAAAAACgcYjtNHmllJx7QcmzzyVLLZWcd06VpZcS2gEAAAAAAIDGI7bT5F1/Q/KXvyZt2yZnD6yy+mpCOwAAAAAAANC4xHaatHv/XvKzX5QkyQnHVdlsU6EdAAAAAAAAaHxiO03W88+XnD2kLrTvs3ey59eFdgAAAAAAAKBpENtpksaNK+nTr+STT5IteyVH/0BoBwAAAAAAAJoOsZ0mZ/Lkkj6nl7zzTtKjRzJwQJV27cR2AAAAAAAAoOkQ22lSZsyou3X8P19Ill0mOe+cKl26CO0AAAAAAABA0yK206T84rqSv9+XtGuXDB5UpfsqQjsAAAAAAADQ9IjtNBl3/7Xkul/W/XzqSVU22lBoBwAAAAAAAJomsZ0m4ZlnS849ryRJDtg/2f0rQjsAAAAAAADQdIntNLp/v1XSt1/JlKnJdtsm3z9CaAcAAAAAAACaNrGdRjVpUknvviXvjU/WWisZcHqVtm3FdgAAAAAAAKBpE9tpNDNmlJw1uOTFF5OamuS8c6p06iS0AwAAAAAAAE2f2E6jueTSSRn+YNKhfTLk7CordRPaAQAAAAAAgOahXWMP4NM89dRTufzyyzNq1KhMmzYttbW1OfTQQ7P77rvP1+t///vf57TTTpvn9l/+8pfZcsstF9VwqYe/3FPyi+smJ0n69K6y/heEdgAAAAAAAKD5aLKx/ZFHHsnhhx+eDh06ZI899kjnzp1z991354QTTsi///3vHHbYYfN9rJ133jnrrrvuHOu7d+++KIdMPQx/sCRJDjko2XUXoR0AAAAAAABoXppkbJ82bVr69++fqqpy4403zgrlRx99dL71rW/l4osvzm677TbfsXyXXXbJXnvttTiHTD0de3SVb+/XJT1rP2zsoQAAAAAAAADUW5N8ZvsjjzySV199NV/96ldnuyJ9qaWWylFHHZWpU6fm1ltvbcQRsrCWX77K1lt1SFW5qh0AAAAAAABofprkle0jRoxIkmy33XZzbJu57rHHHpvv4z333HN5//33M23atKy66qrZeuutU1NTs2gGCwAAAAAAAECr0yRj+yuvvJIkWWONNebY1rVr13Tq1CljxoyZ7+PdcMMNsy137NgxRx99dI488sjPfO0yyyyTNm2a5A0AWgRfegBoeOZegIZn7gVoeOZegIZn7gVoeObextUkY/uHH9Y9x3uppZaa6/YuXbpk4sSJn3mcVVddNf379892222XlVZaKRMmTMjDDz+ciy++OBdddFGWXHLJHHTQQZ96jAkTJtT/DTBfampqMn78+MYeBkCrYu4FaHjmXoCGZ+4FaHjmXoCGZ+5dvObniwwt+pLtXr165cADD0yPHj3SsWPHdOvWLXvuuWd+/vOfZ4kllsjQoUMzbdq0xh4mAAAAAAAAAM1Mk4ztXbp0SZJ5Xr3+4YcfzvOq9/mx9tprZ7PNNsv777+fF198cYGPAwAAAAAAAEDr1CRje48ePZJkrs9lHzduXCZNmjTX57nXx8zL/j/++OOFOg4AAAAAAAAArU+TjO1bbLFFkmT48OFzbJu5buY+C2L69Ol55plnkiSrrLLKAh8HAAAAAAAAgNapScb2rbfeOquttlpuv/32jB49etb6iRMn5uqrr0779u2z5557zlr/9ttv58UXX5zjtvMzg/p/mj59ei688MKMGTMmW265ZVZcccXF9j4AAAAAAAAAaJnaNfYA5qZdu3Y5++yzc/jhh+c73/lO9thjj3Tu3Dl33313xo4dm969e2fVVVedtf/FF1+cW2+9NUOGDMlee+01a/3ee++dnj17pmfPnunWrVsmTJiQESNG5JVXXslKK62UwYMHN8bbAwAAAAAAAKCZa5KxPUm22mqr3HTTTbnssstyxx13ZNq0aamtrc3JJ5+c3Xfffb6Ocdhhh+Uf//hHHnrooUyYMCHt27fP6quvnh/84Af57ne/m2WWWWYxvwsAAAAAAAAAWqKqlFIaexBN2fjx4xt7CC1WTU2NzxeggZl7ARqeuReg4Zl7ARqeuReg4Zl7F6+amprP3KdJPrMdAAAAAAAAAJoysR0AAAAAAAAA6klsBwAAAAAAAIB6EtsBAAAAAAAAoJ7EdgAAAAAAAACoJ7EdAAAAAAAAAOpJbAcAAAAAAACAehLbAQAAAAAAAKCexHYAAAAAAAAAqCexHQAAAAAAAADqSWwHAAAAAAAAgHoS2wEAAAAAAACgnsR2AAAAAAAAAKgnsR0AAAAAAAAA6klsBwAAAAAAAIB6EtsBAAAAAAAAoJ7EdgAAAAAAAACoJ7EdAAAAAAAAAOpJbAcAAAAAAACAehLbAQAAAAAAAKCexHYAAAAAAAAAqCexHQAAAAAAAADqSWwHAAAAAAAAgHqqSimlsQcBAAAAAAAAAM2JK9sBAAAAAAAAoJ7EdgAAAAAAAACoJ7EdAAAAAAAAAOpJbAcAAAAAAACAehLbAQAAAAAAAKCe2jX2AGhdnnrqqVx++eUZNWpUpk2bltra2hx66KHZfffdG3toAM3WW2+9lTvvvDP3339/XnrppbzzzjtZZpllsummm+bwww/PRhttNMdrPvzww1x++eW5++67M27cuKy44orZbbfd8qMf/SidO3duhHcB0DJcc801ueiii5IkN998czbeeOPZtpt/ARaNv/zlL7npppvy3HPPZdKkSenatWs23njjnHLKKVl55ZVn7WfeBVh4pZT85S9/yQ033JCXX345EydOzEorrZQtt9wyRxxxRFZbbbXZ9jf3Asy/2267LU888USeeeaZvPDCC5k6dWqGDBmSvfbaa67713eOnTFjRm688cbccsstGTNmTDp16pRtttkmJ5xwwhzzNwumKqWUxh4ErcMjjzySww8/PB06dMgee+yRzp075+67787YsWPTu3fvHHbYYY09RIBm6cILL8xPf/rTrL766unVq1eWW265jBkzJn/9619TSslFF10025eaJk2alAMOOCCjR4/Odtttl3XXXTejR4/O8OHDs8EGG+TGG2/MEkss0YjvCKB5euGFF7L33nunXbt2mTRp0hyx3fwLsPBKKTnjjDNy8803Z/XVV892222Xzp075+23385jjz2WCy64IJtvvnkS8y7AonLuuefm2muvTdeuXbPzzjunS5cuef755/Pggw+mU6dO+c1vfpPa2tok5l6A+tppp50yduzY1NTUpFOnThk7duw8Y/uCzLH9+vXLsGHDsvbaa2eHHXbI22+/nTvvvDOdO3fOzTffnB49ejTQO225XNlOg5g2bVr69++fqqpy4403Zt11102SHH300fnWt76Viy++OLvttlu6d+/eyCMFaH423HDD3HDDDenVq9ds6x9//PEceuihOfPMM7PLLrukQ4cOSZKf/exnGT16dI444oicfPLJs/afGe2vu+66fP/732/Q9wDQ3E2dOjV9+vTJuuuumzXWWCP/+7//O8c+5l+AhffLX/4yN998cw444ID069cvbdu2nW37tGnTZv1s3gVYeOPGjcv111+f7t2757bbbstSSy01a9t1112XIUOG5Nprr82QIUOSmHsB6uvss8/OGmuske7du892t7y5qe8c+8gjj2TYsGHZYost8otf/GLW3w9/9atfzZFHHplBgwbl5z//+eJ7c62EZ7bTIB555JG8+uqr+epXvzortCfJUkstlaOOOipTp07Nrbfe2ogjBGi+dt111zlCe5Jsvvnm2XLLLTNhwoT885//TFJ3JdCwYcPSqVOn/PCHP5xt/x/+8Ifp1KlThg0b1iDjBmhJrr766vzrX//KOeecM0f4Scy/AIvC5MmTc8UVV2S11VbL6aefPtf5tl27uutKzLsAi8bYsWMzY8aMbLLJJrOF9iT50pe+lCQZP358EnMvwILYZptt5utC1AWZY2cuH3fccbNCe5LssMMO6dWrV4YPH5433nhjEbyL1k1sp0GMGDEiSbLddtvNsW3muscee6xBxwTQGsz8y8aZ//vKK6/k7bffzqabbppOnTrNtm+nTp2y6aab5rXXXsubb77Z4GMFaK6effbZXH311fnRj36Uz3/+83Pdx/wLsPCGDx+eCRMmZJdddsmMGTNy991355prrsmvf/3rjBkzZrZ9zbsAi8Yaa6yR9u3bZ9SoUfnwww9n2/b3v/89SbLVVlslMfcCLE4LMsc++uijs7b9t+233z7J/+t3LDi3kadBvPLKK0nq/nD237p27ZpOnTrN8X+MAVg4b7zxRh566KF07dp11rPTZs6183oWT48ePTJ8+PC88sorWXnllRtqqADN1pQpU9K7d++ss846Ofzww+e5n/kXYOE9++yzSZI2bdrka1/72qy/a5i57tBDD03v3r2TmHcBFpWampqcfPLJOffcc/PlL395tme2P/rooznggANy4IEHJjH3AixO9Z1jJ02alHHjxqW2tnaud4Sa2eu0uYUnttMgZn7r8b9vNTRTly5dMnHixIYcEkCLNnXq1Jx66qmZMmVKTj755Fl/oJo513bp0mWur5u5/r+/rQ7A3F166aV55ZVX8vvf/36u/+d1JvMvwMJ79913k9Q9I3i99dbLsGHDstZaa2X06NHp379/fvGLX2S11VbLAQccYN4FWIQOPfTQrLjiiunXr19+85vfzFq/2Wab5atf/eqsu+mZewEWn/rOsfO7vza38NxGHgBamBkzZqRPnz557LHHsu+++2bPPfds7CEBtEijRo3KL37xi/zgBz+YdQcRABafUkqSpH379rniiiuy4YYbpnPnztl8881z6aWXpk2bNrn22msbeZQALc/QoUNz6qmn5qijjsp9992XkSNH5sYbb8wnn3ySgw8+OPfcc09jDxEAGo3YToP4rG/IfPjhh/O86h2A+Tdjxoz07ds3t99+e77+9a9n4MCBs22fOdfO61vkM9fP6xuPANSZNm1a+vTpk549e+bII4/8zP3NvwALb+Ycuf7666dbt26zbautrc1qq62WV199NR988IF5F2AReeihh3L55ZfnO9/5To488sistNJKs77odPXVV6ddu3Y577zzkvgzL8DiVN85dn731+YWntvI0yBmPkNizJgxWX/99WfbNm7cuEyaNCkbbrhhI4wMoOWYMWNGTjvttPzhD3/IV7/61Zx77rlp02b279XNfBbPfz7f8j/NXD+vZ/8AUGfSpEmz5sz//vPtTPvtt1+S5Iorrshaa62VxPwLsDDWXHPNJPP+C8GZ6ydPnuzPvQCLyP33358k2XLLLefY1rVr16y55pp57rnn8tFHH5l7ARaj+s6xnTp1SteuXfP6669n+vTpczz6buaz2mcelwUnttMgtthii/zkJz/J8OHDs8cee8y2bfjw4bP2AWDB/Gdo33333XP++efP9dnBPXr0yIorrpiRI0dm0qRJ6dSp06xtkyZNysiRI7Pqqqtm5ZVXbsjhAzQ7HTp0yLe+9a25bnv88cfzyiuvZKeddspyyy2X7t27m38BFoGZoeell16aY9vUqVPz6quvplOnTlluueXStWtX8y7AIjB16tQkyXvvvTfX7e+9917atGmT9u3b+zMvwGK0IHNsr1698qc//SkjR46co8E98MADSbS5RcFt5GkQW2+9dVZbbbXcfvvtGT169Kz1EydOzNVXX5327dt7pjDAApp56/g//OEP+fKXv5wLLrhgrqE9Saqqyj777JNJkyblyiuvnG3blVdemUmTJmXfffdtiGEDNGsdO3bM4MGD5/rPJptskiT5/ve/n8GDB2fdddc1/wIsAquvvnq22267jBkzJsOGDZtt2zXXXJMPPvggu+yyS9q1a2feBVhENt100yTJddddN8cjQn/961/n3//+dzbeeON06NDB3AuwGC3IHDtz+dJLL82UKVNmrb/vvvsyYsSIbLfddunevfviH3wLV5VSSmMPgtbhkUceyeGHH54OHTpkjz32SOfOnXP33Xdn7Nix6d27dw477LDGHiJAs3T55Zdn6NCh6dSpUw4++OC0azfnjWt22WWXrLvuuknqvun47W9/O88//3y22267rLfeennuuecyfPjwbLDBBvnVr36Vjh07NvTbAGgx+vTpk1tvvTU333xzNt5441nrzb8AC+/VV1/N/vvvn3fffTdf+tKXZt2++JFHHkn37t1z8803p2vXrknMuwCLwvTp03PIIYfksccey/LLL5+ddtopSy211Ky5t2PHjrnhhhtmPSLU3AtQP8OGDcsTTzyRJHnhhRfy7LPPZtNNN511e/fNNtss++yzT5IFm2P79euXYcOGZe21184OO+yQcePG5Y477kjnzp3zm9/8Jp/73Oca9g23QGI7Deqpp57KZZddllGjRmXatGmpra3Nd7/73ey+++6NPTSAZmtm1Pk0Q4YMyV577TVreeLEibn88stz991355133knXrl3z5S9/OUcffXS6dOmyuIcM0KLNK7Yn5l+AReHNN9/MZZddlgceeCDvv/9+Vlhhhey00045+uijs/zyy8+2r3kXYOFNmTIl1113Xe688868/PLLmTp1apZffvlsueWWOeqoo7LWWmvNtr+5F2D+fdbf7X7zm9/MueeeO2u5vnPsjBkz8qtf/Sq33HJLxowZk06dOmWbbbbJCSeckNVXX32xvKfWRmwHAAAAAAAAgHryzHYAAAAAAAAAqCexHQAAAAAAAADqSWwHAAAAAAAAgHoS2wEAAAAAAACgnsR2AAAAAAAAAKgnsR0AAAAAAAAA6klsBwAAAAAAAIB6EtsBAAAAAAAAoJ7EdgAAAAAAAACoJ7EdAACAuerZs+ds/6yzzjrZfPPNc8ABB2TYsGEppTT2EGlk7733Xk499dRst912WXfdddOzZ8/8/ve/b+xhNbiePXtmp512WuznefTRR9OzZ8/06dNnsZ8LAACAz9ausQcAAABA0/bNb34zSTJ9+vS89tprGTlyZJ544ok8/PDDufjiixt5dA1vp512ytixY/PPf/6zsYfS6Pr27Zt77703PXv2zFZbbZV27dpl9dVXb+xhNVuXX355hg4dmiFDhmSvvfZq7OEAAADwGcR2AAAAPtW555472/KDDz6YI488Mn/605/yta99LTvuuGMjjYzGNGXKlNx///3p3r17/vCHP6RNGzfPW9w23HDD3HHHHVlqqaUaeygAAADEbeQBAACop2233TZf//rXkyR//etfG3k0NJZ33nkn06dPT/fu3YX2BrLkkktmrbXWyoorrtjYQwEAACBiOwAAAAtgvfXWS5L8+9//nm39k08+mWOPPTbbbbdd1l9//Xzxi1/M6aefnjfeeGOOY1x++eWznvH91FNP5fvf/3623HLL9OzZM6NHj57tmCeccEK23377rL/++tluu+1yyCGH5JZbbpnjmB9//HF+8pOfZM8998wmm2ySTTbZJPvuu29uvfXWub6Pmc/anj59eq655prstttuWX/99bPDDjvkggsuyJQpU2btO/N52WPHjp312pn//OfzuseMGZPLL788++23X7bddttZn8Opp56al19+eZ6f6YgRI3LwwQdnk002yRZbbJEjjjgiTz/9dH7/+9+nZ8+eufzyy+d4zbRp03LTTTdlv/32y6abbpoNN9ww3/jGN3Lddddl2rRp8zzXvNx333357ne/my222CIbbLBBdtttt1x44YX54IMPZttvp512mnVHgxEjRsz1c5iX//z3/uSTT+Z73/teNt9882y66ab57ne/m3/84x8LPb4FPc+nfdZJctBBB6Vnz555/fXXP/N9llJy++2354QTTshuu+2WjTfeOJtsskm+9a1v5cYbb8yMGTNm23+nnXbK0KFDkySnnXbabL9fjz76aJJPf2b7tGnTcsMNN2Svvfaa9bv/rW99KzfddFOmT5/+qe/lr3/9a/bdd99svPHG6dWrV0488cQ5/tsGAABgTm4jDwAAQL199NFHSZL27dvPWnfjjTfm7LPPTpJssMEG2WyzzfLyyy/nt7/9bf72t7/lV7/6VdZaa605jvXYY49lwIAB6dGjR7bddtu8/fbbqaoqSXL99dfn3HPPzYwZM/KFL3whW2yxRcaPH59//vOfOf/887PvvvvOOs67776b7373u/nnP/+Zrl27ZosttkgpJaNGjUqfPn3yzDPPpH///nN9PyeddFLuu+++bLnllvnc5z6Xxx9/PD/72c/y1ltv5cILL0ySrLDCCvnmN7+Zu+66K5MmTZr1LPskqampmfXzsGHD8rOf/Sxrr712Nthgg3To0CH/93//l9tuuy333HNPbrzxxqyzzjqznf/uu+/O8ccfn+nTp2fjjTdO9+7d88ILL+SAAw6Y57O7J0+enCOPPDKPPvpoll122Wy88cbp0KFDnnrqqQwZMiSPPvporrjiivm+6vwnP/lJLr744rRr1y5bbLFFampqMnLkyPz0pz/NX/7yl9x4441ZYYUVkiS77bZbxo4dm7vuuisrrLBCtt9++zk+h88yatSoDBgwIGussUa++MUvZsyYMXnooYfy2GOP5eqrr8522223wONbmPMsKlOmTMlJJ52UZZddNp///Oez3nrr5f3338+oUaNy1lln5emnn57tEQ277bZbHnrooTz//PPZdNNNs8Yaa8zaNrf39Z+mT5+eH/7wh7nvvvvSpUuXbLPNNiml5JFHHsnAgQPz0EMP5bLLLpvr78JNN92U6667Lptttlm++MUv5qmnnsqf/vSnPPvss7ntttvSsWPHRfehAAAAtDQFAAAA5qK2trbU1tbOsX7GjBllv/32K7W1teXiiy8upZQyatSosu6665btt9++PP3007Ptf8stt5Ta2tqyzz77zLb+sssum3WOa665Zo7zjBgxovTs2bNssskm5aGHHppt29SpU8vf//732dYdccQRpba2tpx99tnlk08+mbV+3LhxZa+99iq1tbXlvvvum+t7/MpXvlLefvvtWetfffXVsvnmm5fa2toyZsyY2V6z4447zvVzmWnUqFHl1VdfnWP9b3/721JbW1sOOuig2dZPnDix9OrVq9TW1pb//d//nW3bj3/841ljvOyyy2bbduaZZ5ba2tpy/PHHlw8++GC24838LG666aZ5jvM/Pfnkk2WdddYpG2+8cfnHP/4xa/0nn3xSjj322FJbW1uOOeaY2V7z2muvldra2nLggQfO1zlm+s9/7xdffHGZMWPGrG033nhjqa2tLdtuu235+OOPF2p8C3Ke3/3ud3P9rGc68MADS21tbXnttddmW19bW1t23HHH2dZNnTq1/OUvfylTpkyZbf2777476/dxxIgRcx3z7373u7me/5FHHim1tbWld+/es63/+c9/Xmpra8see+xRxo0bN2v9W2+9VXbbbbdSW1tbbrjhhrm+l4022qiMHDly1vpJkybN+u972LBhcx0HAAAAddxGHgAAgPkyffr0vPLKK+nbt29GjRqVDh06ZO+9906SXHPNNZk+fXoGDhyY9ddff7bX7bPPPtlpp53y5JNP5rnnnpvjuLW1tTn88MPnWH/NNdeklJKjjjoqW2+99Wzb2rVrlx122GHW8ujRo3Pfffdlgw02yGmnnZYOHTrM2rbCCitk0KBBSZJf//rXc31v/fr1S9euXWctr7baarOeS//4449/6ufy3zbeeOOsttpqc6zfe++9s+mmm2bEiBGZOHHirPV33nln3n///Wy99db52te+Nttrjj766HTv3n2OY7377rsZNmxYVl555QwZMiRLLbXUrG1dunTJ4MGD0759+3m+3/8287bmBx10UDbaaKNZ6zt06JABAwakY8eO+ctf/pI333xzvo43P7p3755jjjlm1l0MkuSAAw7IRhttlHHjxuWuu+5aJOOrz3kWpXbt2mWXXXaZ7e4PSbLccsvlpJNOSpLcc889i+RcN9xwQ5KkT58+s10Fv+KKK+bUU09Nkvzyl7+c62sPOeSQbLLJJrOWl1xyyXz3u99NUv/ffQAAgNbGbeQBAAD4VD179pxjXefOnXPeeedl9dVXz4wZM/Lwww9nySWXnOctuTfffPP87W9/y1NPPTXree8z7bjjjrOF0KTu+dMjRoxIkuy3336fOcbhw4cnSXbZZZe53ip7vfXWS6dOnfL000/Psa19+/bZcsst51jfo0ePJMm4ceM+8/z/7aOPPsq9996b0aNHZ8KECbOenz5u3LiUUvLqq6/mC1/4QpJk5MiRSZIvf/nLcxynXbt22XXXXXPttdfOtv7RRx/N1KlTs/3228/1Nt9du3ZNjx498sILL2Ty5MmfeSvwmVH1v2N/kiy//PLZdtttc88992TkyJHZY4895uMT+Gy77rpr2rWb868l9thjjzz55JN54okn8o1vfGOhx1ef8ywOo0ePzvDhw/PGG29k8uTJKaXMegzDK6+8stDHf+ONN/LGG29kueWWm+t/fzvuuGOWXnrpjBkzJuPGjZvtSyVJ5vqahfndBwAAaE3EdgAAAD7VzGeTV1WVLl26pLa2NrvuumuWWWaZJMn48eMzadKkJJnjqvb/Nn78+DnWrbzyynOse//99zN58uQsu+yys87zacaOHZskueSSS3LJJZfMc78pU6bMsW6FFVZI27Zt51jfuXPneb7m0zz88MM58cQT8957781zn5mxNUnefvvtJHP/HOa1fub7veWWW3LLLbd86ngmTJjwmbF95hjmdhX9f65/6623PvU49bHKKqt86rlmjmlhx1ef8yxKU6ZMyWmnnZbbb799nvv85+/Bgpo5/nm9z6qqssoqq+SDDz7IW2+9NUdsX2mlleZ4zYL+7gMAALQ2YjsAAACf6txzz/3U7TNmzEiSdOrUKbvtttun7rv22mvPsW6JJZZY8MH91xg222yzrL766vV67dyuhF9QH330UY4//vhMmDAhRx99dPbYY4+sssoq6dixY6qqykknnZTbb789pZSFOs/M16+77rpZZ511PnXf/76N+YL47zsPNDUNNb6Zv2fz47rrrsvtt9+e2tranHLKKfnCF76QpZdeOu3bt8/LL7881zsZLC6f9vk09X+3AAAATZnYDgAAwEKpqanJEksskTZt2mTIkCGLJN7V1NSkY8eOef/99/PBBx9k6aWX/tT9Z16du8suu+Swww5b6PMvqMcffzzvv/9+dttttxx77LFzbH/ttdfmWLfiiismyTyfh/7vf/97jnXdunVLUvflgv79+y/MkGeN4fXXX88bb7yRz3/+83Nsn3kl/czzLgpvvPHGp66f+bks7Pjqc56ZX0yYeaeG/1afZ9b/5S9/SZJcfPHFc3zJZG6/Bwtq5vjn9T7/c9ui/PcHAABAsui+vg8AAECr1K5du/Tq1SsffvhhHn744UVyzLZt26ZXr15Jkptvvvkz9992222T/L/AuTjNDLIzn8P+nz744IMkc78195gxY/Lcc8/NsX7TTTdNktx9991zbJs+ffpc12+11VZp27Zt7r333kydOrV+b2AuNt988ySZ6y3P33vvvQwfPjxVVc0a66Jw9913Z/r06XOsv+OOO5JktnMtzPjqc56Zt1h/+eWX59j/5Zdfrlds/7TfhTvvvHOur5n5uzW38c7LKqusklVWWSXvvffeXP/7+/vf/54JEyZkjTXWmOMW8gAAACwcsR0AAICFdtRRR6VNmzY57bTT8uijj86x/aOPPspvf/vbTJ48eb6PecQRR6Sqqlx99dV55JFHZts2bdq03HfffbOWN9poo2y77bYZOXJkBg4cmA8//HCO4z3//PO5//776/Gu5m7mlcRzC7I9evRIUhf9//OZ7R988EFOP/30uYbxL3/5y1l22WXz4IMP5k9/+tNs26666qq8/vrrc7ymW7du2XvvvTN27NicdNJJeeedd+bYZ8yYMbnrrrvm6z195zvfSZs2bXLDDTfk6aefnrV+ypQpGTRoUCZPnpxdd911ns+VXxBjx47N0KFDZ1t38803Z9SoUVlhhRVmeyTBwoyvPufZYIMNsuSSS+aBBx7IM888M2v9e++9l379+tXrNvIzfxd+/etfz7b+z3/+c2677ba5vmbm79ZLL7003+dJkgMPPDBJMmTIkNl+78aNG5fzzz8/SXLwwQfX65gAAAB8NreRBwAAYKFtvvnmGTBgQAYNGpSDDz44tbW16dGjR9q1a5exY8dm9OjRmTJlSnbdddd07Nhxvo7Zq1evnHLKKbngggtyyCGHZP3110+PHj0yfvz4PP/885kyZUoef/zxWftfcMEFOfzww3PTTTfl9ttvzzrrrJMVV1wxH374Yf75z3/mzTffzMEHH5wvfvGLC/Ved9ppp4wYMSKHHnpottxyyyy55JKpqanJySefnA022CDbbrttHnzwwey2226zrs4fMWJEampqsvPOO+eee+6Z7XhLLbVUBg0alOOPPz4nnnhibrjhhnTv3j0vvPBCXn755ey33365+eab53j2+umnn56xY8fmrrvuygMPPJB11lknq6yySiZNmpQXX3wxY8aMyc477zxbTJ6XDTfcMMcdd1wuueSS7L///unVq1dqamoycuTIvPnmm+nRo0cGDBiwUJ/bf9t3333z05/+NH/5y1/Ss2fPjBkzJk8//XTat2+fIUOGZMkll1wk46vPeTp37pzDDjssV1xxRQ444IBsscUWqaoqTz31VNZcc81ssskmGTVq1Hy9v8MPPzwPPPBALrroovz5z3/O5z73ubzyyit55plncthhh+UXv/jFHK/Zdttts8QSS+T666/Pv/71r6y44oqpqirf+973suaaa87zXIceemgeeeSR3H///dl1112z1VZbpZSShx9+OB999FF22WWXHHDAAfM1bgAAAOaf2A4AAMAi8e1vfzsbb7xxrr/++owYMSL33ntvllxyyXTr1i1f+9rXsuuuu2appZaq1zG/973vZaONNsp1112XkSNH5p///GeWXXbZ1NbWZo899pht3+WXXz6/+c1vcsstt+RPf/pTRo8ePevq5dVWWy0HHXTQHK9ZEAcddFAmTJiQP/3pT7n77rszderUdO/ePSeffHKS5Morr8xVV12VP//5z7n//vuz/PLLZ/fdd8/xxx+f8847b67H3HXXXXPttddm6NCheeaZZ/Kvf/0rG2+8cQYPHpwHH3wwSbLsssvO9pqOHTvmpz/9af74xz/m1ltvzfPPP5+nn346NTU16d69e77+9a/X6/0eddRRWWeddXLdddfl6aefzuTJk7PKKqvk8MMPz5FHHplllllmwT6wedhkk02y11575dJLL829996bUkq23nrrHHvssXO9HfyCjq++5znmmGPSuXPn3HzzzXn00Uez/PLLZ++9986xxx6bI488cr7f3xZbbJGbbropl1xySUaPHp1XXnkltbW1ufzyy7PeeuvNNbZ369YtV155Za644oo88cQTs54d//Wvf/1TY3vbtm1z1VVX5aabbsqtt96a4cOHJ0nWWmut7LXXXtl///3Tpo2bGwIAACxqVSmlNPYgAAAAgLn73ve+l+HDh+eWW27JRhtt1NjDWWiXX355hg4dmiFDhmSvvfZq9ucBAACg9fK1ZgAAAGhkb7311hzPXZ8xY0auu+66DB8+PD169MiGG27YSKMDAAAA5sZt5AEAAKCRPf744znllFOy7rrrpnv37pkyZUpeeOGFjB07NksuuWQGDx6cqqoae5gAAADAf3BlOwAAADSyL3zhC/nGN76RiRMnZvjw4Rk+fHhmzJiRb3zjG/ntb3+bzTffvLGHCAAAAPwXz2wHAAAAAAAAgHpyZTsAAAAAAAAA1JPYDgAAAAAAAAD1JLYDAAAAAAAAQD2J7QAAAAAAAABQT2I7AAAAAAAAANST2A4AAAAAAAAA9SS2AwAAAAAAAEA9ie0AAAAAAAAAUE//H6nKPBCPfDuSAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%time\n", + "# Using constant g\n", + "xlearner_mf = XLearner(\n", + " X=X,\n", + " y=y,\n", + " treated=treated,\n", + " model=HistGradientBoostingRegressor(),\n", + " propensity_score_model=DummyClassifier(strategy=\"most_frequent\"),\n", + ")\n", + "\n", + "summarize_learner(xlearner_mf)\n", + "xlearner_mf.summary(n_iter=100)" + ] + }, + { + "cell_type": "markdown", + "id": "6a499cc5-2fcf-4016-978b-c3c28c861d5a", + "metadata": {}, + "source": [ + "# DR-learner\n", + "\n", + "The *doubly-robust learner*, also known as the *DR-learner*, takes its name from the property that it is unbiased if either the propensity score estimator or the outcome regressions are correctly specified and it was first introduced in [[2]](https://arxiv.org/abs/2004.14497).\n", + "\n", + "The DR-learner first splits the set of observations $S = (Y, X, W)$ randomly into two parts $S_i = (Y_i, X_i, W_i), i=1,2$ of equally many observations, finds the estimates $\\hat{\\mu}_{\\operatorname{treated}}$, $\\hat{\\mu}_{\\operatorname{untreated}}$ and $g$ on $S_1$. Then it constructs \n", + "\n", + "$$\\varphi(X) = \\frac{W - g(X)}{g(X)(1 - g(X))}(Y - \\hat{\\mu}_{W}(X)) + \\hat{\\mu}_{\\operatorname{treated}} - \\hat{\\mu}_{\\operatorname{untreated}}$$\n", + "called the *pseudo-outcome*, where $\\hat{\\mu}_W(X) = (1 - W)\\hat{\\mu}_{\\operatorname{untreated}} + W\\hat{\\mu}_{\\operatorname{treated}}$. Finally, regressing $\\varphi(X_2)$ on $X_2$ yields the CATE estimator $\\hat{\\tau}_{DR}$. Optionally, one may perform a *cross-fitting step* by swapping the roles of $S_1$ and $S_2$ obtaining a second estimator. Averaging the two estimators usually results in a better one." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "687aa584-b8af-4863-a7cf-570e86080057", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Actual average treatement effect: 0.11803778255762709\n", + "MSE: 0.04268581526973136\n", + "CPU times: total: 22min 8s\n", + "Wall time: 3min 51s\n" + ] + }, + { + "data": { + "text/html": [ + "
Conditional Average Treatment Effect Estimator Summary
Number of observations 5000
Number of treated observations 1822
Average treatement effect (ATE) 0.14
95% Confidence interval for ATE (0.12, 0.15)
Estimated bias -0.0
Base learners
Model R^2
treated HistGradientBoostingRegressor 0.84
untreated HistGradientBoostingRegressor 0.81
propensity HistGradientBoostingClassifier 0.77
pseudo_outcome HistGradientBoostingRegressor 0.1
" + ], + "text/plain": [ + " ╔════════════════════════════════════════════════════════╗\n", + " ║ Conditional Average Treatment Effect Estimator Summary ║\n", + " ╚════════════════════════════════════════════════════════╝\n", + " \n", + " ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┱───────────────────────────────┐\n", + " ┃ Number of observations ┃ 5000 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃ Number of treated observations┃ 1822 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃Average treatement effect (ATE)┃ 0.14 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃95% Confidence interval for ATE┃ (0.12, 0.15) │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃ Estimated bias ┃ -0.0 │\n", + " ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┹───────────────────────────────┘\n", + " ╔═══════════════╗\n", + " ║ Base learners ║\n", + " ╚═══════════════╝\n", + " \n", + " ╔═══════════════════════════════╦═══════════════════════════════╗\n", + " ║ Model ║ R^2 ║\n", + " ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╚═══════════════════════════════╩═══════════════════════════════╝ \n", + " ┃ treated ┃ HistGradientBoostingRegressor │ 0.84 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┼───────────────────────────────┤\n", + " ┃ untreated ┃ HistGradientBoostingRegressor │ 0.81 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┼───────────────────────────────┤\n", + " ┃ propensity ┃ HistGradientBoostingClassifier│ 0.77 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┼───────────────────────────────┤\n", + " ┃ pseudo_outcome ┃ HistGradientBoostingRegressor │ 0.1 │\n", + " ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┹───────────────────────────────┴───────────────────────────────┘" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%time\n", + "drlearner = DRLearner(\n", + " X=X,\n", + " y=y,\n", + " treated=treated,\n", + " model=HistGradientBoostingRegressor(),\n", + " propensity_score_model=HistGradientBoostingClassifier(),\n", + ")\n", + "\n", + "summarize_learner(drlearner)\n", + "drlearner.summary(n_iter=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ea54609b-9f4f-4282-b60c-498de1af106b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Actual average treatement effect: 0.11803778255762709\n", + "MSE: 0.024034992448110002\n", + "CPU times: total: 48min 25s\n", + "Wall time: 9min 13s\n" + ] + }, + { + "data": { + "text/html": [ + "
Conditional Average Treatment Effect Estimator Summary
Number of observations 5000
Number of treated observations 1822
Average treatement effect (ATE) 0.14
95% Confidence interval for ATE (0.12, 0.15)
Estimated bias -0.0
Base learners
Model R^2
treated HistGradientBoostingRegressor 0.85
untreated HistGradientBoostingRegressor 0.81
propensity HistGradientBoostingClassifier 0.77
pseudo_outcome HistGradientBoostingRegressor 0.1
" + ], + "text/plain": [ + " ╔════════════════════════════════════════════════════════╗\n", + " ║ Conditional Average Treatment Effect Estimator Summary ║\n", + " ╚════════════════════════════════════════════════════════╝\n", + " \n", + " ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┱───────────────────────────────┐\n", + " ┃ Number of observations ┃ 5000 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃ Number of treated observations┃ 1822 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃Average treatement effect (ATE)┃ 0.14 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃95% Confidence interval for ATE┃ (0.12, 0.15) │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┤\n", + " ┃ Estimated bias ┃ -0.0 │\n", + " ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┹───────────────────────────────┘\n", + " ╔═══════════════╗\n", + " ║ Base learners ║\n", + " ╚═══════════════╝\n", + " \n", + " ╔═══════════════════════════════╦═══════════════════════════════╗\n", + " ║ Model ║ R^2 ║\n", + " ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╚═══════════════════════════════╩═══════════════════════════════╝ \n", + " ┃ treated ┃ HistGradientBoostingRegressor │ 0.85 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┼───────────────────────────────┤\n", + " ┃ untreated ┃ HistGradientBoostingRegressor │ 0.81 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┼───────────────────────────────┤\n", + " ┃ propensity ┃ HistGradientBoostingClassifier│ 0.77 │\n", + " ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╋───────────────────────────────┼───────────────────────────────┤\n", + " ┃ pseudo_outcome ┃ HistGradientBoostingRegressor │ 0.1 │\n", + " ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┹───────────────────────────────┴───────────────────────────────┘" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%time\n", + "drlearner_d = DRLearner(\n", + " X=X,\n", + " y=y,\n", + " treated=treated,\n", + " model=HistGradientBoostingRegressor(),\n", + " propensity_score_model=HistGradientBoostingClassifier(),\n", + " cross_fitting=True,\n", + ")\n", + "\n", + "summarize_learner(drlearner_d)\n", + "drlearner_d.summary(n_iter=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3552a561-8051-4a51-832a-5e088a106689", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def compute_mse(learner, m):\n", + " l = learner(X, y, treated, m)\n", + " return mean_squared_error(treatment_effect, l.cate)\n", + "\n", + "\n", + "models = [\n", + " (\"Random forest\", RandomForestRegressor()),\n", + " (\"Hist gradient boosting\", HistGradientBoostingRegressor()),\n", + " (\"AdaBoost\", AdaBoostRegressor()),\n", + " (\"XGBoost\", XGBRegressor()),\n", + " (\"SVR\", SVR()),\n", + "]\n", + "\n", + "learners = [\n", + " (\"S-learner\", SLearner),\n", + " (\"T-learner\", TLearner),\n", + " (\"X-learner\", XLearner),\n", + " (\"DR-learner\", DRLearner),\n", + " (\"Cross-fitted DR-learner\", lambda *args: DRLearner(*args, cross_fitting=True)),\n", + "]\n", + "bench = pd.DataFrame(\n", + " {\n", + " m_name: {\n", + " learner_name: compute_mse(learner, m) for learner_name, learner in learners\n", + " }\n", + " for m_name, m in models\n", + " }\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7eed6094-c940-4b5b-8294-bd2ffeab2eac", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(10, 10))\n", + "sns.heatmap(bench, annot=True, ax=ax)" + ] + }, + { + "cell_type": "markdown", + "id": "57ed3040", + "metadata": {}, + "source": [ + "Bibliography:\n", + "\n", + "[1] Künzel, S. R., Sekhon, J. S., Bickel, P. J., and Yu, B. Metalearners for estimating heterogeneous treatment effects using machine learning. Proceedings of the national academy of sciences 116, no. 10 (2019): 4156-4165.\n", + "\n", + "[2] Kennedy, E. H. Optimal doubly robust estimation of heterogeneous causal effects. arXiv preprint (2020) arXiv:2004.14497.\n", + "\n", + "[3] Alves, M. F. Causal Inference for The Brave and True. [https://matheusfacure.github.io/python-causality-handbook](https://matheusfacure.github.io/python-causality-handbook)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml index 662ec608..e8d0024f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -35,10 +35,11 @@ dependencies = [ "pandas", "patsy", "pymc>=5.0.0", + "pymc-bart", "scikit-learn>=1", "scipy", "seaborn>=0.11.2", - "xarray>=v2022.11.0", + "xarray>=v2022.11.0" ] # List additional groups of dependencies here (e.g. development dependencies). Users