diff --git a/econml/_ortho_learner.py b/econml/_ortho_learner.py index 272842947..b14e9c20e 100644 --- a/econml/_ortho_learner.py +++ b/econml/_ortho_learner.py @@ -543,11 +543,21 @@ def const_marginal_effect_interval(self, X=None, *, alpha=0.1): return super().const_marginal_effect_interval(X, alpha=alpha) const_marginal_effect_interval.__doc__ = LinearCateEstimator.const_marginal_effect_interval.__doc__ + def const_marginal_effect_inference(self, X=None): + self._check_fitted_dims(X) + return super().const_marginal_effect_inference(X) + const_marginal_effect_inference.__doc__ = LinearCateEstimator.const_marginal_effect_inference.__doc__ + def effect_interval(self, X=None, *, T0=0, T1=1, alpha=0.1): self._check_fitted_dims(X) return super().effect_interval(X, T0=T0, T1=T1, alpha=alpha) effect_interval.__doc__ = LinearCateEstimator.effect_interval.__doc__ + def effect_inference(self, X=None, *, T0=0, T1=1): + self._check_fitted_dims(X) + return super().effect_inference(X, T0=T0, T1=T1) + effect_inference.__doc__ = LinearCateEstimator.effect_inference.__doc__ + def score(self, Y, T, X=None, W=None, Z=None): """ Score the fitted CATE model on a new data set. Generates nuisance parameters diff --git a/econml/cate_estimator.py b/econml/cate_estimator.py index 2f4053d3d..efd46fb7c 100644 --- a/econml/cate_estimator.py +++ b/econml/cate_estimator.py @@ -12,7 +12,7 @@ from .inference import BootstrapInference from .utilities import tensordot, ndim, reshape, shape, parse_final_model_params, inverse_onehot from .inference import StatsModelsInference, StatsModelsInferenceDiscrete, LinearModelFinalInference,\ - LinearModelFinalInferenceDiscrete + LinearModelFinalInferenceDiscrete, InferenceResults class BaseCateEstimator(metaclass=abc.ABCMeta): @@ -197,6 +197,30 @@ def effect_interval(self, X=None, *, T0=0, T1=1, alpha=0.1): """ pass + @_defer_to_inference + def effect_inference(self, X=None, *, T0=0, T1=1): + """ Inference results for the quantities :math:`\\tau(X, T0, T1)` produced + by the model. Available only when ``inference`` is not ``None``, when + calling the fit method. + + Parameters + ---------- + X: optional (m, d_x) matrix + Features for each sample + T0: optional (m, d_t) matrix or vector of length m (Default=0) + Base treatments for each sample + T1: optional (m, d_t) matrix or vector of length m (Default=1) + Target treatments for each sample + + Returns + ------- + InferenceResults: object + The inference results instance contains prediction and prediction standard error and + can on demand calculate confidence interval, z statistic and p value. It can also output + a dataframe summary of these inference results. + """ + pass + @_defer_to_inference def marginal_effect_interval(self, T, X=None, *, alpha=0.1): """ Confidence intervals for the quantities :math:`\\partial \\tau(T, X)` produced @@ -221,6 +245,28 @@ def marginal_effect_interval(self, T, X=None, *, alpha=0.1): """ pass + @_defer_to_inference + def marginal_effect_inference(self, T, X=None): + """ Inference results for the quantities :math:`\\partial \\tau(T, X)` produced + by the model. Available only when ``inference`` is not ``None``, when + calling the fit method. + + Parameters + ---------- + T: (m, d_t) matrix + Base treatments for each sample + X: optional (m, d_x) matrix or None (Default=None) + Features for each sample + + Returns + ------- + InferenceResults: object + The inference results instance contains prediction and prediction standard error and + can on demand calculate confidence interval, z statistic and p value. It can also output + a dataframe summary of these inference results. + """ + pass + class LinearCateEstimator(BaseCateEstimator): """Base class for all CATE estimators with linear treatment effects in this package.""" @@ -324,6 +370,18 @@ def marginal_effect_interval(self, T, X=None, *, alpha=0.1): for eff in effs) marginal_effect_interval.__doc__ = BaseCateEstimator.marginal_effect_interval.__doc__ + def marginal_effect_inference(self, T, X=None): + X, T = self._expand_treatments(X, T) + cme_inf = self.const_marginal_effect_inference(X=X) + pred = cme_inf.point_estimate + pred_stderr = cme_inf.stderr + if X is None: + pred = np.repeat(pred, shape(T)[0], axis=0) + pred_stderr = np.repeat(pred_stderr, shape(T)[0], axis=0) + return InferenceResults(d_t=cme_inf.d_t, d_y=cme_inf.d_y, pred=pred, + pred_stderr=pred_stderr, inf_type='effect', pred_dist=None, fname_transformer=None) + marginal_effect_inference.__doc__ = BaseCateEstimator.marginal_effect_inference.__doc__ + @BaseCateEstimator._defer_to_inference def const_marginal_effect_interval(self, X=None, *, alpha=0.1): """ Confidence intervals for the quantities :math:`\\theta(X)` produced @@ -346,6 +404,26 @@ def const_marginal_effect_interval(self, X=None, *, alpha=0.1): """ pass + @BaseCateEstimator._defer_to_inference + def const_marginal_effect_inference(self, X=None): + """ Inference results for the quantities :math:`\\theta(X)` produced + by the model. Available only when ``inference`` is not ``None``, when + calling the fit method. + + Parameters + ---------- + X: optional (m, d_x) matrix or None (Default=None) + Features for each sample + + Returns + ------- + InferenceResults: object + The inference results instance contains prediction and prediction standard error and + can on demand calculate confidence interval, z statistic and p value. It can also output + a dataframe summary of these inference results. + """ + pass + class TreatmentExpansionMixin(BaseCateEstimator): """Mixin which automatically handles promotions of scalar treatments to the appropriate shape.""" @@ -454,6 +532,18 @@ def coef__interval(self, *, alpha=0.1): """ pass + @BaseCateEstimator._defer_to_inference + def coef__inference(self): + """ The inference of coefficients in the linear model of the constant marginal treatment + effect. + + Returns + ------- + InferenceResults: object + The inference of the coefficients in the final linear model + """ + pass + @BaseCateEstimator._defer_to_inference def intercept__interval(self, *, alpha=0.1): """ The intercept in the linear model of the constant marginal treatment @@ -472,6 +562,43 @@ def intercept__interval(self, *, alpha=0.1): """ pass + @BaseCateEstimator._defer_to_inference + def intercept__inference(self): + """ The inference of intercept in the linear model of the constant marginal treatment + effect. + + Returns + ------- + InferenceResults: object + The inference of the intercept in the final linear model + """ + pass + + @BaseCateEstimator._defer_to_inference + def summary(self, alpha=0.1, value=0, decimals=3, feat_name=None): + """ The summary of coefficient and intercept in the linear model of the constant marginal treatment + effect. + + Parameters + ---------- + alpha: optional float in [0, 1] (default=0.1) + The overall level of confidence of the reported interval. + The alpha/2, 1-alpha/2 confidence interval is reported. + value: optinal float (default=0) + The mean value of the metric you'd like to test under null hypothesis. + decimals: optinal int (default=3) + Number of decimal places to round each column to. + feat_name: optional list of strings or None (default is None) + The input of the feature names + + Returns + ------- + smry : Summary instance + this holds the summary tables and text, which can be printed or + converted to various output formats. + """ + pass + class StatsModelsCateEstimatorMixin(LinearModelFinalCateEstimatorMixin): """ @@ -568,6 +695,23 @@ def coef__interval(self, T, *, alpha=0.1): """ pass + @BaseCateEstimator._defer_to_inference + def coef__inference(self, T): + """ The inference for the coefficients in the linear model of the + constant marginal treatment effect associated with treatment T. + + Parameters + ---------- + T: alphanumeric + The input treatment for which we want the coefficients. + + Returns + ------- + InferenceResults: object + The inference of the coefficients in the final linear model + """ + pass + @BaseCateEstimator._defer_to_inference def intercept__interval(self, T, *, alpha=0.1): """ The intercept in the linear model of the constant marginal treatment @@ -588,6 +732,49 @@ def intercept__interval(self, T, *, alpha=0.1): """ pass + @BaseCateEstimator._defer_to_inference + def intercept__inference(self, T): + """ The inference of the intercept in the linear model of the constant marginal treatment + effect associated with treatment T. + + Parameters + ---------- + T: alphanumeric + The input treatment for which we want the coefficients. + + Returns + ------- + InferenceResults: object + The inference of the intercept in the final linear model + + """ + pass + + @BaseCateEstimator._defer_to_inference + def summary(self, T, *, alpha=0.1, value=0, decimals=3, feat_name=None): + """ The summary of coefficient and intercept in the linear model of the constant marginal treatment + effect associated with treatment T. + + Parameters + ---------- + alpha: optional float in [0, 1] (default=0.1) + The overall level of confidence of the reported interval. + The alpha/2, 1-alpha/2 confidence interval is reported. + value: optinal float (default=0) + The mean value of the metric you'd like to test under null hypothesis. + decimals: optinal int (default=3) + Number of decimal places to round each column to. + feat_name: optional list of strings or None (default is None) + The input of the feature names + + Returns + ------- + smry : Summary instance + this holds the summary tables and text, which can be printed or + converted to various output formats. + """ + pass + class StatsModelsCateEstimatorDiscreteMixin(LinearModelFinalCateEstimatorDiscreteMixin): """ diff --git a/econml/drlearner.py b/econml/drlearner.py index 0abba2890..12f6107ff 100644 --- a/econml/drlearner.py +++ b/econml/drlearner.py @@ -638,6 +638,7 @@ def __init__(self, fit_cate_intercept=True, min_propensity=1e-6, n_splits=2, random_state=None): + self.fit_cate_intercept = fit_cate_intercept super().__init__(model_propensity=model_propensity, model_regression=model_regression, model_final=StatsModelsLinearRegression(fit_intercept=fit_cate_intercept), @@ -837,6 +838,7 @@ def __init__(self, tol=1e-4, min_propensity=1e-6, n_splits=2, random_state=None): + self.fit_cate_intercept = fit_cate_intercept model_final = DebiasedLasso( alpha=alpha, fit_intercept=fit_cate_intercept, diff --git a/econml/inference.py b/econml/inference.py index 50e8bc283..c8d7aa762 100644 --- a/econml/inference.py +++ b/econml/inference.py @@ -3,10 +3,15 @@ import abc import numpy as np +import scipy from scipy.stats import norm +import pandas as pd +from collections import OrderedDict +from statsmodels.iolib.table import SimpleTable from .bootstrap import BootstrapEstimator from .utilities import (cross_product, broadcast_unit_treatments, reshape_treatmentwise_effects, - ndim, inverse_onehot, parse_final_model_params) + ndim, inverse_onehot, parse_final_model_params, _safe_norm_ppf, Summary) + """Options for performing inference in estimators.""" @@ -80,20 +85,42 @@ def fit(self, estimator, *args, **kwargs): self._est = estimator self._d_t = estimator._d_t self._d_y = estimator._d_y + self.d_t = self._d_t[0] if self._d_t else 1 + self.d_y = self._d_y[0] if self._d_y else 1 def const_marginal_effect_interval(self, X, *, alpha=0.1): if X is None: X = np.ones((1, 1)) elif self.featurizer is not None: X = self.featurizer.fit_transform(X) - X, T = broadcast_unit_treatments(X, self._d_t[0] if self._d_t else 1) + X, T = broadcast_unit_treatments(X, self.d_t) preds = self._predict_interval(cross_product(X, T), alpha=alpha) return tuple(reshape_treatmentwise_effects(pred, self._d_t, self._d_y) for pred in preds) + def const_marginal_effect_inference(self, X): + if X is None: + X = np.ones((1, 1)) + elif self.featurizer is not None: + X = self.featurizer.fit_transform(X) + X, T = broadcast_unit_treatments(X, self.d_t) + pred = reshape_treatmentwise_effects(self._predict(cross_product(X, T)), self._d_t, self._d_y) + if not hasattr(self.model_final, 'prediction_stderr'): + raise AttributeError("Final model doesn't support prediction standard eror, " + "please call const_marginal_effect_interval to get confidence interval.") + pred_stderr = reshape_treatmentwise_effects(self._prediction_stderr(cross_product(X, T)), self._d_t, self._d_y) + return InferenceResults(d_t=self.d_t, d_y=self.d_y, pred=pred, + pred_stderr=pred_stderr, inf_type='effect', pred_dist=None, fname_transformer=None) + def _predict_interval(self, X, alpha): return self.model_final.predict_interval(X, alpha=alpha) + def _predict(self, X): + return self.model_final.predict(X) + + def _prediction_stderr(self, X): + return self.model_final.prediction_stderr(X) + class GenericSingleTreatmentModelFinalInference(GenericModelFinalInference): """ @@ -123,6 +150,26 @@ def effect_interval(self, X, *, T0, T1, alpha=0.1): ub = np.max(intrv_pre, axis=0) return lb, ub + def effect_inference(self, X, *, T0, T1): + # We can write effect inference as a function of const_marginal_effect_inference for a single treatment + X, T0, T1 = self._est._expand_treatments(X, T0, T1) + if (T0 == T1).all(): + raise AttributeError("T0 is the same as T1, please input different treatment!") + cme_pred = self.const_marginal_effect_inference(X).point_estimate + cme_stderr = self.const_marginal_effect_inference(X).stderr + dT = T1 - T0 + einsum_str = 'myt,mt->my' + if ndim(dT) == 1: + einsum_str = einsum_str.replace('t', '') + if ndim(cme_pred) == ndim(dT): # y is a vector, rather than a 2D array + einsum_str = einsum_str.replace('y', '') + e_pred = np.einsum(einsum_str, cme_pred, dT) + e_stderr = np.einsum(einsum_str, cme_stderr, np.abs(dT)) + d_y = self._d_y[0] if self._d_y else 1 + # d_t=1 here since we measure the effect across all Ts + return InferenceResults(d_t=1, d_y=d_y, pred=e_pred, + pred_stderr=e_stderr, inf_type='effect', pred_dist=None, fname_transformer=None) + class LinearModelFinalInference(GenericModelFinalInference): """ @@ -148,6 +195,23 @@ def effect_interval(self, X, *, T0, T1, alpha=0.1): X = self.featurizer.transform(X) return self._predict_interval(cross_product(X, T1 - T0), alpha=alpha) + def effect_inference(self, X, *, T0, T1): + # We can write effect inference as a function of prediction and prediction standard error of + # the final method for linear models + X, T0, T1 = self._est._expand_treatments(X, T0, T1) + if (T0 == T1).all(): + raise AttributeError("T0 is the same as T1, please input different treatment!") + if X is None: + X = np.ones((T0.shape[0], 1)) + elif self.featurizer is not None: + X = self.featurizer.transform(X) + e_pred = self._predict(cross_product(X, T1 - T0)) + e_stderr = self._prediction_stderr(cross_product(X, T1 - T0)) + d_y = self._d_y[0] if self._d_y else 1 + # d_t=1 here since we measure the effect across all Ts + return InferenceResults(d_t=1, d_y=d_y, pred=e_pred, + pred_stderr=e_stderr, inf_type='effect', pred_dist=None, fname_transformer=None) + def coef__interval(self, *, alpha=0.1): lo, hi = self.model_final.coef__interval(alpha) lo_int, hi_int = self.model_final.intercept__interval(alpha) @@ -159,6 +223,29 @@ def coef__interval(self, *, alpha=0.1): self.fit_cate_intercept)[0] return lo, hi + def coef__inference(self): + coef = self.model_final.coef_ + coef_stderr = self.model_final.coef_stderr_ + intercept = self.model_final.intercept_ + intercept_stderr = self.model_final.intercept_stderr_ + coef = parse_final_model_params(coef, intercept, + self._d_y, self._d_t, self._d_t_in, self.bias_part_of_coef, + self.fit_cate_intercept)[0] + coef_stderr = parse_final_model_params(coef_stderr, intercept_stderr, + self._d_y, self._d_t, self._d_t_in, self.bias_part_of_coef, + self.fit_cate_intercept)[0] + if coef.size == 0: # X is None + raise AttributeError("X is None, please call intercept_inference to learn the constant!") + + if callable(self._est.cate_feature_names): + def fname_transformer(x): + return self._est.cate_feature_names(x) + else: + fname_transformer = None + return InferenceResults(d_t=self.d_t, d_y=self.d_y, pred=coef, + pred_stderr=coef_stderr, + inf_type='coefficient', pred_dist=None, fname_transformer=fname_transformer) + def intercept__interval(self, *, alpha=0.1): if not self.fit_cate_intercept: raise AttributeError("No intercept was fitted!") @@ -172,6 +259,50 @@ def intercept__interval(self, *, alpha=0.1): self.fit_cate_intercept)[1] return lo, hi + def intercept__inference(self): + if not self.fit_cate_intercept: + raise AttributeError("No intercept was fitted!") + coef = self.model_final.coef_ + coef_stderr = self.model_final.coef_stderr_ + intercept = self.model_final.intercept_ + intercept_stderr = self.model_final.intercept_stderr_ + intercept = parse_final_model_params(coef, intercept, + self._d_y, self._d_t, self._d_t_in, self.bias_part_of_coef, + self.fit_cate_intercept)[1] + intercept_stderr = parse_final_model_params(coef_stderr, intercept_stderr, + self._d_y, self._d_t, self._d_t_in, self.bias_part_of_coef, + self.fit_cate_intercept)[1] + return InferenceResults(d_t=self.d_t, d_y=self.d_y, pred=intercept, pred_stderr=intercept_stderr, + inf_type='intercept', pred_dist=None, fname_transformer=None) + + def summary(self, alpha=0.1, value=0, decimals=3, feat_name=None): + smry = Summary() + try: + coef_table = self.coef__inference().summary_frame(alpha=alpha, + value=value, decimals=decimals, feat_name=feat_name) + coef_array = coef_table.values + coef_headers = [i + '\n' + + j for (i, j) in coef_table.columns] if self.d_t > 1 else coef_table.columns.tolist() + coef_stubs = [i + ' | ' + j for (i, j) in coef_table.index] if self.d_y > 1 else coef_table.index.tolist() + coef_title = 'Coefficient Results' + smry.add_table(coef_array, coef_headers, coef_stubs, coef_title) + except Exception as e: + print("Coefficient Results: ", str(e)) + try: + intercept_table = self.intercept__inference().summary_frame(alpha=alpha, + value=value, decimals=decimals, feat_name=None) + intercept_array = intercept_table.values + intercept_headers = [i + '\n' + j for (i, j) + in intercept_table.columns] if self.d_t > 1 else intercept_table.columns.tolist() + intercept_stubs = [i + ' | ' + j for (i, j) + in intercept_table.index] if self.d_y > 1 else intercept_table.index.tolist() + intercept_title = 'Intercept Results' + smry.add_table(intercept_array, intercept_headers, intercept_stubs, intercept_title) + except Exception as e: + print("Intercept Results: ", str(e)) + if len(smry.tables) > 0: + return smry + class StatsModelsInference(LinearModelFinalInference): """Stores statsmodels covariance options. @@ -216,6 +347,10 @@ def fit(self, estimator, *args, **kwargs): self._d_t = estimator._d_t self._d_y = estimator._d_y self.fitted_models_final = estimator.fitted_models_final + self.d_t = self._d_t[0] if self._d_t else 1 + self.d_y = self._d_y[0] if self._d_y else 1 + if hasattr(estimator, 'fit_cate_intercept'): + self.fit_cate_intercept = estimator.fit_cate_intercept def const_marginal_effect_interval(self, X, *, alpha=0.1): if (X is not None) and (self.featurizer is not None): @@ -223,6 +358,19 @@ def const_marginal_effect_interval(self, X, *, alpha=0.1): preds = np.array([mdl.predict_interval(X, alpha=alpha) for mdl in self.fitted_models_final]) return tuple(np.moveaxis(preds, [0, 1], [-1, 0])) # send treatment to the end, pull bounds to the front + def const_marginal_effect_inference(self, X): + if (X is not None) and (self.featurizer is not None): + X = self.featurizer.fit_transform(X) + pred = np.array([mdl.predict(X) for mdl in self.fitted_models_final]) + if not hasattr(self.fitted_models_final[0], 'prediction_stderr'): + raise AttributeError("Final model doesn't support prediction standard eror, " + "please call const_marginal_effect_interval to get confidence interval.") + pred_stderr = np.array([mdl.prediction_stderr(X) for mdl in self.fitted_models_final]) + return InferenceResults(d_t=self.d_t, d_y=self.d_y, pred=np.moveaxis(pred, 0, -1), + # send treatment to the end, pull bounds to the front + pred_stderr=np.moveaxis(pred_stderr, 0, -1), inf_type='effect', + pred_dist=None, fname_transformer=None) + def effect_interval(self, X, *, T0, T1, alpha=0.1): X, T0, T1 = self._est._expand_treatments(X, T0, T1) if np.any(np.any(T0 > 0, axis=1)): @@ -235,6 +383,25 @@ def effect_interval(self, X, *, T0, T1, alpha=0.1): lower, upper = np.repeat(lower, T0.shape[0], axis=0), np.repeat(upper, T0.shape[0], axis=0) return lower[np.arange(T0.shape[0]), ..., ind], upper[np.arange(T0.shape[0]), ..., ind] + def effect_inference(self, X, *, T0, T1): + X, T0, T1 = self._est._expand_treatments(X, T0, T1) + if (T0 == T1).all(): + raise AttributeError("T0 is the same with T1, please input different treatment!") + if np.any(np.any(T0 > 0, axis=1)): + raise AttributeError("Can only calculate inference of effects with respect to baseline treatment!") + ind = inverse_onehot(T1) + pred = self.const_marginal_effect_inference(X).point_estimate + pred = np.concatenate([np.zeros(pred.shape[0:-1] + (1,)), pred], -1) + pred_stderr = self.const_marginal_effect_inference(X).stderr + pred_stderr = np.concatenate([np.zeros(pred_stderr.shape[0:-1] + (1,)), pred_stderr], -1) + if X is None: # Then const_marginal_effect_interval will return a single row + pred = np.repeat(pred, T0.shape[0], axis=0) + pred_stderr = np.repeat(pred_stderr, T0.shape[0], axis=0) + # d_t=1 here since we measure the effect across all Ts + return InferenceResults(d_t=1, d_y=self.d_y, pred=pred[np.arange(T0.shape[0]), ..., ind], + pred_stderr=pred_stderr[np.arange(T0.shape[0]), ..., ind], + inf_type='effect', pred_dist=None, fname_transformer=None) + class LinearModelFinalInferenceDiscrete(GenericModelFinalInferenceDiscrete): """ @@ -249,12 +416,66 @@ def coef__interval(self, T, *, alpha=0.1): assert ind >= 0, "No model was fitted for the control" return self.fitted_models_final[ind].coef__interval(alpha) + def coef__inference(self, T): + _, T = self._est._expand_treatments(None, T) + ind = inverse_onehot(T).item() - 1 + assert ind >= 0, "No model was fitted for the control" + coef = self.fitted_models_final[ind].coef_ + coef_stderr = self.fitted_models_final[ind].coef_stderr_ + if coef.size == 0: # X is None + raise AttributeError("X is None, please call intercept_inference to learn the constant!") + if callable(self._est.cate_feature_names): + def fname_transformer(x): + return self._est.cate_feature_names(x) + else: + fname_transformer = None + return InferenceResults(d_t=1, d_y=self.d_y, pred=coef, pred_stderr=coef_stderr, + inf_type='coefficient', pred_dist=None, fname_transformer=fname_transformer) + def intercept__interval(self, T, *, alpha=0.1): + if not self.fit_cate_intercept: + raise AttributeError("No intercept was fitted!") _, T = self._est._expand_treatments(None, T) ind = inverse_onehot(T).item() - 1 assert ind >= 0, "No model was fitted for the control" return self.fitted_models_final[ind].intercept__interval(alpha) + def intercept__inference(self, T): + if not self.fit_cate_intercept: + raise AttributeError("No intercept was fitted!") + _, T = self._est._expand_treatments(None, T) + ind = inverse_onehot(T).item() - 1 + assert ind >= 0, "No model was fitted for the control" + return InferenceResults(d_t=1, d_y=self.d_y, pred=self.fitted_models_final[ind].intercept_, + pred_stderr=self.fitted_models_final[ind].intercept_stderr_, + inf_type='intercept', pred_dist=None, fname_transformer=None) + + def summary(self, T, *, alpha=0.1, value=0, decimals=3, feat_name=None): + smry = Summary() + try: + coef_table = self.coef__inference(T).summary_frame( + alpha=alpha, value=value, decimals=decimals, feat_name=feat_name) + coef_array = coef_table.values + coef_headers = coef_table.columns.tolist() + coef_stubs = coef_table.index.tolist() + coef_title = 'Coefficient Results' + smry.add_table(coef_array, coef_headers, coef_stubs, coef_title) + except Exception as e: + print("Coefficient Results: ", e) + try: + intercept_table = self.intercept__inference(T).summary_frame( + alpha=alpha, value=value, decimals=decimals, feat_name=None) + intercept_array = intercept_table.values + intercept_headers = intercept_table.columns.tolist() + intercept_stubs = intercept_table.index.tolist() + intercept_title = 'Intercept Results' + smry.add_table(intercept_array, intercept_headers, intercept_stubs, intercept_title) + except Exception as e: + print("Intercept Results: ", e) + + if len(smry.tables) > 0: + return smry + class StatsModelsInferenceDiscrete(LinearModelFinalInferenceDiscrete): """ @@ -279,3 +500,532 @@ def prefit(self, estimator, *args, **kwargs): super().prefit(estimator, *args, **kwargs) # need to set the fit args before the estimator is fit self.model_final.cov_type = self.cov_type + + +class InferenceResults: + """ + Results class for inferences. + + Parameters + ---------- + d_t: int + Number of treatments + d_y: int + Number of outputs + pred : array-like, shape (m, d_y, d_t) or (m, d_y) + The prediction of the metric for each sample X[i]. + Note that when Y or T is a vector rather than a 2-dimensional array, + the corresponding singleton dimensions should be collapsed + (e.g. if both are vectors, then the input of this argument will also be a vector) + pred_stderr : array-like, shape (m, d_y, d_t) or (m, d_y) + The prediction standard error of the metric for each sample X[i]. + Note that when Y or T is a vector rather than a 2-dimensional array, + the corresponding singleton dimensions should be collapsed + (e.g. if both are vectors, then the input of this argument will also be a vector) + inf_type: string + The type of inference result. + It could be either 'effect', 'coefficient' or 'intercept'. + pred_dist : array-like, shape (b, m, d_y, d_t) or (b, m, d_y) + the raw predictions of the metric using b times bootstrap. + Note that when Y or T is a vector rather than a 2-dimensional array, + the corresponding singleton dimensions should be collapsed + fname_transformer: None or predefined function + The transform function to get the corresponding feature names from featurizer + """ + + def __init__(self, d_t, d_y, pred, pred_stderr, inf_type, pred_dist=None, fname_transformer=None): + self.d_t = d_t + self.d_y = d_y + self.pred = pred + self.pred_stderr = pred_stderr + self.inf_type = inf_type + self.pred_dist = pred_dist + self.fname_transformer = fname_transformer + + @property + def point_estimate(self): + """ + Get the point estimate of each treatment on each outcome for each sample X[i]. + + Returns + ------- + prediction : array-like, shape (m, d_y, d_t) or (m, d_y) + The point estimate of each treatment on each outcome for each sample X[i]. + Note that when Y or T is a vector rather than a 2-dimensional array, + the corresponding singleton dimensions in the output will be collapsed + (e.g. if both are vectors, then the output of this method will also be a vector) + """ + return self.pred + + @property + def stderr(self): + """ + Get the standard error of the metric of each treatment on each outcome for each sample X[i]. + + Returns + ------- + stderr : array-like, shape (m, d_y, d_t) or (m, d_y) + The standard error of the metric of each treatment on each outcome for each sample X[i]. + Note that when Y or T is a vector rather than a 2-dimensional array, + the corresponding singleton dimensions in the output will be collapsed + (e.g. if both are vectors, then the output of this method will also be a vector) + """ + return self.pred_stderr + + @property + def var(self): + """ + Get the variance of the metric of each treatment on each outcome for each sample X[i]. + + Returns + ------- + var : array-like, shape (m, d_y, d_t) or (m, d_y) + The variance of the metric of each treatment on each outcome for each sample X[i]. + Note that when Y or T is a vector rather than a 2-dimensional array, + the corresponding singleton dimensions in the output will be collapsed + (e.g. if both are vectors, then the output of this method will also be a vector) + """ + return self.pred_stderr**2 + + def conf_int(self, alpha=0.1): + """ + Get the confidence interval of the metric of each treatment on each outcome for each sample X[i]. + + Parameters + ---------- + alpha: optional float in [0, 1] (Default=0.1) + The overall level of confidence of the reported interval. + The alpha/2, 1-alpha/2 confidence interval is reported. + + Returns + ------- + lower, upper: tuple of arrays, shape (m, d_y, d_t) or (m, d_y) + The lower and the upper bounds of the confidence interval for each quantity. + Note that when Y or T is a vector rather than a 2-dimensional array, + the corresponding singleton dimensions in the output will be collapsed + (e.g. if both are vectors, then the output of this method will also be a vector) + """ + if np.isscalar(self.pred): + return _safe_norm_ppf(alpha / 2, loc=self.pred, scale=self.pred_stderr),\ + _safe_norm_ppf(1 - alpha / 2, loc=self.pred, scale=self.pred_stderr) + else: + return np.array([_safe_norm_ppf(alpha / 2, loc=p, scale=err) + for p, err in zip(self.pred, self.pred_stderr)]),\ + np.array([_safe_norm_ppf(1 - alpha / 2, loc=p, scale=err) + for p, err in zip(self.pred, self.pred_stderr)]) + + def pvalue(self, value=0): + """ + Get the p value of the z test of each treatment on each outcome for each sample X[i]. + + Parameters + ---------- + value: optinal float (default=0) + The mean value of the metric you'd like to test under null hypothesis. + + Returns + ------- + pvalue : array-like, shape (m, d_y, d_t) or (m, d_y) + The p value of the z test of each treatment on each outcome for each sample X[i]. + Note that when Y or T is a vector rather than a 2-dimensional array, + the corresponding singleton dimensions in the output will be collapsed + (e.g. if both are vectors, then the output of this method will also be a vector) + """ + + return norm.sf(np.abs(self.zstat(value)), loc=0, scale=1) * 2 + + def zstat(self, value=0): + """ + Get the z statistic of the metric of each treatment on each outcome for each sample X[i]. + + Parameters + ---------- + value: optinal float (default=0) + The mean value of the metric you'd like to test under null hypothesis. + + Returns + ------- + zstat : array-like, shape (m, d_y, d_t) or (m, d_y) + The z statistic of the metric of each treatment on each outcome for each sample X[i]. + Note that when Y or T is a vector rather than a 2-dimensional array, + the corresponding singleton dimensions in the output will be collapsed + (e.g. if both are vectors, then the output of this method will also be a vector) + """ + return (self.pred - value) / self.pred_stderr + + def summary_frame(self, alpha=0.1, value=0, decimals=3, feat_name=None): + """ + Output the dataframe for all the inferences above. + + Parameters + ---------- + alpha: optional float in [0, 1] (default=0.1) + The overall level of confidence of the reported interval. + The alpha/2, 1-alpha/2 confidence interval is reported. + value: optinal float (default=0) + The mean value of the metric you'd like to test under null hypothesis. + decimals: optinal int (default=3) + Number of decimal places to round each column to. + feat_name: optional list of strings or None (default is None) + The input of the feature names + + Returns + ------- + output: pandas dataframe + The output dataframe includes point estimate, standard error, z score, p value and confidence intervals + of the estimated metric of each treatment on each outcome for each sample X[i] + """ + + ci_mean = self.conf_int(alpha=alpha) + to_include = OrderedDict() + to_include['point_estimate'] = self._array_to_frame(self.d_t, self.d_y, self.pred) + to_include['stderr'] = self._array_to_frame(self.d_t, self.d_y, self.pred_stderr) + to_include['zstat'] = self._array_to_frame(self.d_t, self.d_y, self.zstat(value)) + to_include['pvalue'] = self._array_to_frame(self.d_t, self.d_y, self.pvalue(value)) + to_include['ci_lower'] = self._array_to_frame(self.d_t, self.d_y, ci_mean[0]) + to_include['ci_upper'] = self._array_to_frame(self.d_t, self.d_y, ci_mean[1]) + res = pd.concat(to_include, axis=1, keys=to_include.keys()).round(decimals) + if self.d_t == 1: + res.columns = res.columns.droplevel(1) + if self.d_y == 1: + res.index = res.index.droplevel(1) + if self.inf_type == 'coefficient': + if feat_name and self.fname_transformer: + ind = self.fname_transformer(feat_name) + else: + ct = res.shape[0] // self.d_y + ind = ['X' + str(i) for i in range(ct)] + + if self.d_y > 1: + res.index = res.index.set_levels(ind, level=0) + else: + res.index = ind + elif self.inf_type == 'intercept': + if self.d_y > 1: + res.index = res.index.set_levels(['intercept'], level=0) + else: + res.index = ['intercept'] + return res + + def population_summary(self, alpha=0.1, value=0, decimals=3, tol=0.001): + """ + Output the object of population summary results. + + Parameters + ---------- + alpha: optional float in [0, 1] (default=0.1) + The overall level of confidence of the reported interval. + The alpha/2, 1-alpha/2 confidence interval is reported. + value: optinal float (default=0) + The mean value of the metric you'd like to test under null hypothesis. + decimals: optinal int (default=3) + Number of decimal places to round each column to. + tol: optinal float (default=0.001) + The stopping criterion. The iterations will stop when the outcome is less than ``tol`` + + Returns + ------- + PopulationSummaryResults: object + The population summary results instance contains the different summary analysis of point estimate + for sample X on each treatment and outcome. + """ + if self.inf_type == 'effect': + return PopulationSummaryResults(pred=self.pred, pred_stderr=self.pred_stderr, d_t=self.d_t, d_y=self.d_y, + alpha=alpha, value=value, decimals=decimals, tol=tol) + else: + raise AttributeError(self.inf_type + " inference doesn't support population_summary function!") + + def _array_to_frame(self, d_t, d_y, arr): + if np.isscalar(arr): + arr = np.array([arr]) + if self.inf_type == 'coefficient': + arr = np.moveaxis(arr, -1, 0) + arr = arr.reshape((-1, d_y, d_t)) + df = pd.concat([pd.DataFrame(x) for x in arr], keys=np.arange(arr.shape[0])) + df.index = df.index.set_levels(['Y' + str(i) for i in range(d_y)], level=1) + df.columns = ['T' + str(i) for i in range(d_t)] + return df + + +class PopulationSummaryResults: + """ + Population summary results class for inferences. + + Parameters + ---------- + d_t: int + Number of treatments + d_y: int + Number of outputs + pred : array-like, shape (m, d_y, d_t) or (m, d_y) + The prediction of the metric for each sample X[i]. + Note that when Y or T is a vector rather than a 2-dimensional array, + the corresponding singleton dimensions should be collapsed + (e.g. if both are vectors, then the input of this argument will also be a vector) + pred_stderr : array-like, shape (m, d_y, d_t) or (m, d_y) + The prediction standard error of the metric for each sample X[i]. + Note that when Y or T is a vector rather than a 2-dimensional array, + the corresponding singleton dimensions should be collapsed + (e.g. if both are vectors, then the input of this argument will also be a vector) + alpha: optional float in [0, 1] (default=0.1) + The overall level of confidence of the reported interval. + The alpha/2, 1-alpha/2 confidence interval is reported. + value: optinal float (default=0) + The mean value of the metric you'd like to test under null hypothesis. + decimals: optinal int (default=3) + Number of decimal places to round each column to. + tol: optinal float (default=0.001) + The stopping criterion. The iterations will stop when the outcome is less than ``tol`` + + """ + + def __init__(self, pred, pred_stderr, d_t, d_y, alpha, value, decimals, tol): + self.pred = pred + self.pred_stderr = pred_stderr + self.d_t = d_t + self.d_y = d_y + self.alpha = alpha + self.value = value + self.decimals = decimals + self.tol = tol + + def __str__(self): + return self.print().as_text() + + def _repr_html_(self): + '''Display as HTML in IPython notebook.''' + return self.print().as_html() + + @property + def mean_point(self): + """ + Get the mean of the point estimate of each treatment on each outcome for sample X. + + Returns + ------- + mean_point : array-like, shape (d_y, d_t) + The point estimate of each treatment on each outcome for sample X. + Note that when Y or T is a vector rather than a 2-dimensional array, + the corresponding singleton dimensions in the output will be collapsed + (e.g. if both are vectors, then the output of this method will be a scalar) + """ + return np.mean(self.pred, axis=0) + + @property + def stderr_mean(self): + """ + Get the standard error of the mean point estimate of each treatment on each outcome for sample X. + The output is a conservative upper bound. + + Returns + ------- + stderr_mean : array-like, shape (d_y, d_t) + The standard error of the mean point estimate of each treatment on each outcome for sample X. + Note that when Y or T is a vector rather than a 2-dimensional array, + the corresponding singleton dimensions in the output will be collapsed + (e.g. if both are vectors, then the output of this method will be a scalar) + """ + return np.sqrt(np.mean(self.pred_stderr**2, axis=0)) + + @property + def zstat(self): + """ + Get the z statistic of the mean point estimate of each treatment on each outcome for sample X. + + Returns + ------- + zstat : array-like, shape (d_y, d_t) + The z statistic of the mean point estimate of each treatment on each outcome for sample X. + Note that when Y or T is a vector rather than a 2-dimensional array, + the corresponding singleton dimensions in the output will be collapsed + (e.g. if both are vectors, then the output of this method will be a scalar) + """ + zstat = (self.mean_point - self.value) / self.stderr_mean + return zstat + + @property + def pvalue(self): + """ + Get the p value of the z test of each treatment on each outcome for sample X. + + Returns + ------- + pvalue : array-like, shape (d_y, d_t) + The p value of the z test of each treatment on each outcome for sample X. + Note that when Y or T is a vector rather than a 2-dimensional array, + the corresponding singleton dimensions in the output will be collapsed + (e.g. if both are vectors, then the output of this method will be a scalar) + """ + pvalue = norm.sf(np.abs(self.zstat), loc=0, scale=1) * 2 + return pvalue + + @property + def conf_int_mean(self): + """ + Get the confidence interval of the mean point estimate of each treatment on each outcome for sample X. + + Returns + ------- + lower, upper: tuple of arrays, shape (d_y, d_t) + The lower and the upper bounds of the confidence interval for each quantity. + Note that when Y or T is a vector rather than a 2-dimensional array, + the corresponding singleton dimensions in the output will be collapsed + (e.g. if both are vectors, then the output of this method will also be a vector) + """ + + return np.array([_safe_norm_ppf(self.alpha / 2, loc=p, scale=err) + for p, err in zip([self.mean_point] if np.isscalar(self.mean_point) else self.mean_point, + [self.stderr_mean] if np.isscalar(self.stderr_mean) + else self.stderr_mean)]),\ + np.array([_safe_norm_ppf(1 - self.alpha / 2, loc=p, scale=err) + for p, err in zip([self.mean_point] if np.isscalar(self.mean_point) else self.mean_point, + [self.stderr_mean] if np.isscalar(self.stderr_mean) else self.stderr_mean)]) + + @property + def std_point(self): + """ + Get the standard deviation of the point estimate of each treatment on each outcome for sample X. + + Returns + ------- + std_point : array-like, shape (d_y, d_t) + The standard deviation of the point estimate of each treatment on each outcome for sample X. + Note that when Y or T is a vector rather than a 2-dimensional array, + the corresponding singleton dimensions in the output will be collapsed + (e.g. if both are vectors, then the output of this method will be a scalar) + """ + return np.std(self.pred, axis=0) + + @property + def percentile_point(self): + """ + Get the confidence interval of the point estimate of each treatment on each outcome for sample X. + + Returns + ------- + lower, upper: tuple of arrays, shape (d_y, d_t) + The lower and the upper bounds of the confidence interval for each quantity. + Note that when Y or T is a vector rather than a 2-dimensional array, + the corresponding singleton dimensions in the output will be collapsed + (e.g. if both are vectors, then the output of this method will also be a vector) + """ + lower_percentile_point = np.percentile(self.pred, (self.alpha / 2) * 100, axis=0) + upper_percentile_point = np.percentile(self.pred, (1 - self.alpha / 2) * 100, axis=0) + return np.array([lower_percentile_point]) if np.isscalar(lower_percentile_point) else lower_percentile_point, \ + np.array([upper_percentile_point]) if np.isscalar(upper_percentile_point) else upper_percentile_point + + @property + def stderr_point(self): + """ + Get the standard error of the point estimate of each treatment on each outcome for sample X. + + Returns + ------- + stderr_point : array-like, shape (d_y, d_t) + The standard error of the point estimate of each treatment on each outcome for sample X. + Note that when Y or T is a vector rather than a 2-dimensional array, + the corresponding singleton dimensions in the output will be collapsed + (e.g. if both are vectors, then the output of this method will be a scalar) + """ + return np.sqrt(self.stderr_mean**2 + self.std_point**2) + + @property + def conf_int_point(self): + """ + Get the confidence interval of the point estimate of each treatment on each outcome for sample X. + + Returns + ------- + lower, upper: tuple of arrays, shape (d_y, d_t) + The lower and the upper bounds of the confidence interval for each quantity. + Note that when Y or T is a vector rather than a 2-dimensional array, + the corresponding singleton dimensions in the output will be collapsed + (e.g. if both are vectors, then the output of this method will also be a vector) + """ + lower_ci_point = np.array([self._mixture_ppf(self.alpha / 2, self.pred, self.pred_stderr, self.tol)]) + upper_ci_point = np.array([self._mixture_ppf(1 - self.alpha / 2, self.pred, self.pred_stderr, self.tol)]) + return np.array([lower_ci_point]) if np.isscalar(lower_ci_point) else lower_ci_point,\ + np.array([upper_ci_point]) if np.isscalar(upper_ci_point) else upper_ci_point + + def print(self): + """ + Output the summary inferences above. + + Returns + ------- + smry : Summary instance + this holds the summary tables and text, which can be printed or + converted to various output formats. + """ + + # 1. Uncertainty of Mean Point Estimate + res1 = self._res_to_2darray(self.d_t, self.d_y, self.mean_point, self.decimals) + res1 = np.hstack((res1, self._res_to_2darray(self.d_t, self.d_y, self.stderr_mean, self.decimals))) + res1 = np.hstack((res1, self._res_to_2darray(self.d_t, self.d_y, self.zstat, self.decimals))) + res1 = np.hstack((res1, self._res_to_2darray(self.d_t, self.d_y, self.pvalue, self.decimals))) + res1 = np.hstack((res1, self._res_to_2darray(self.d_t, self.d_y, self.conf_int_mean[0], self.decimals))) + res1 = np.hstack((res1, self._res_to_2darray(self.d_t, self.d_y, self.conf_int_mean[1], self.decimals))) + metric_name1 = ['mean_point', 'stderr_mean', 'zstat', 'pvalue', 'ci_mean_lower', 'ci_mean_upper'] + myheaders1 = [name + '\nT' + str(i) for name in metric_name1 for i in range(self.d_t) + ] if self.d_t > 1 else [name for name in metric_name1] + mystubs1 = ["Y" + str(i) for i in range(self.d_y)] if self.d_y > 1 else [] + title1 = "Uncertainty of Mean Point Estimate" + text1 = "Note: The stderr_mean is a conservative upper bound." + + # 2. Distribution of Point Estimate + res2 = self._res_to_2darray(self.d_t, self.d_y, self.std_point, self.decimals) + res2 = np.hstack((res2, self._res_to_2darray(self.d_t, self.d_y, self.percentile_point[0], self.decimals))) + res2 = np.hstack((res2, self._res_to_2darray(self.d_t, self.d_y, self.percentile_point[1], self.decimals))) + metric_name2 = ['std_point', 'pct_point_lower', 'pct_point_upper'] + myheaders2 = [name + '\nT' + str(i) for name in metric_name2 for i in range(self.d_t) + ] if self.d_t > 1 else [name for name in metric_name2] + mystubs2 = ["Y" + str(i) for i in range(self.d_y)] if self.d_y > 1 else [] + title2 = "Distribution of Point Estimate" + + # 3. Total Variance of Point Estimate + res3 = self._res_to_2darray(self.d_t, self.d_y, self.stderr_point, self.decimals) + res3 = np.hstack((res3, self._res_to_2darray(self.d_t, self.d_y, + self.conf_int_point[0], self.decimals))) + res3 = np.hstack((res3, self._res_to_2darray(self.d_t, self.d_y, + self.conf_int_point[1], self.decimals))) + metric_name3 = ['stderr_point', 'ci_point_lower', 'ci_point_upper'] + myheaders3 = [name + '\nT' + str(i) for name in metric_name3 for i in range(self.d_t) + ] if self.d_t > 1 else [name for name in metric_name3] + mystubs3 = ["Y" + str(i) for i in range(self.d_y)] if self.d_y > 1 else [] + title3 = "Total Variance of Point Estimate" + + smry = Summary() + smry.add_table(res1, myheaders1, mystubs1, title1) + smry.add_extra_txt([text1]) + smry.add_table(res2, myheaders2, mystubs2, title2) + smry.add_table(res3, myheaders3, mystubs3, title3) + return smry + + def _mixture_ppf(self, alpha, mean, stderr, tol): + """ + Helper function to get the confidence interval of mixture gaussian distribution + """ + done = False + mix_ppf = scipy.stats.norm.ppf(alpha, loc=mean, scale=stderr) + lower = np.min(mix_ppf, axis=0) + upper = np.max(mix_ppf, axis=0) + while not done: + cur = (lower + upper) / 2 + cur_mean = np.mean(scipy.stats.norm.cdf(cur, loc=mean, scale=stderr), axis=0) + if np.isscalar(cur): + if np.abs(cur_mean - alpha) < tol or (cur == lower): + return cur + elif cur_mean < alpha: + lower = cur + else: + upper = cur + else: + if np.all((np.abs(cur_mean - alpha) < tol) | (cur == lower)): + return cur + lower[cur_mean < alpha] = cur[cur_mean < alpha] + upper[cur_mean > alpha] = cur[cur_mean > alpha] + + def _res_to_2darray(self, d_t, d_y, res, decimals): + arr = np.array([[res]]) if np.isscalar(res) else res.reshape((d_y, d_t)) + arr = np.round(arr, decimals) + return arr diff --git a/econml/sklearn_extensions/linear_model.py b/econml/sklearn_extensions/linear_model.py index 9821e96ea..b4957351c 100644 --- a/econml/sklearn_extensions/linear_model.py +++ b/econml/sklearn_extensions/linear_model.py @@ -606,10 +606,10 @@ class DebiasedLasso(WeightedLasso): selected_alpha_ : float Penalty chosen through cross-validation, if alpha='auto'. - coef_std_err_ : array, shape (n_features,) + coef_stderr_ : array, shape (n_features,) Estimated standard errors for coefficients (see ``coef_`` attribute). - intercept_std_err_ : float + intercept_stderr_ : float Estimated standard error intercept (see ``intercept_`` attribute). """ @@ -682,14 +682,14 @@ def fit(self, X, y, sample_weight=None, check_input=True): self.coef_ += coef_correction # Set coefficients and intercept standard errors - self.coef_std_err_ = np.sqrt(np.diag(self._coef_variance)) + self.coef_stderr_ = np.sqrt(np.diag(self._coef_variance)) if self.fit_intercept: - self.intercept_std_err_ = np.sqrt( + self.intercept_stderr_ = np.sqrt( self._X_offset @ self._coef_variance @ self._X_offset + self._mean_error_variance ) else: - self.intercept_std_err_ = 0 + self.intercept_stderr_ = 0 # Set intercept self._set_intercept(X_offset, y_offset, X_scale) @@ -698,6 +698,29 @@ def fit(self, X, y, sample_weight=None, check_input=True): self.alpha = 'auto' return self + def prediction_stderr(self, X): + """Get the standard error of the predictions using the debiased lasso. + + Parameters + ---------- + X : ndarray or scipy.sparse matrix, (n_samples, n_features) + Samples. + + Returns + ------- + prediction_stderr : array like, shape (n_samples, ) + The standard error of each coordinate of the output at each point we predict + """ + # Note that in the case of no intercept, X_offset is 0 + if self.fit_intercept: + X = X - self._X_offset + # Calculate the variance of the predictions + var_pred = np.sum(np.matmul(X, self._coef_variance) * X, axis=1) + if self.fit_intercept: + var_pred += self._mean_error_variance + pred_stderr = np.sqrt(var_pred) + return pred_stderr + def predict_interval(self, X, alpha=0.1): """Build prediction confidence intervals using the debiased lasso. @@ -754,8 +777,8 @@ def coef__interval(self, alpha=0.1): """ lower = alpha / 2 upper = 1 - alpha / 2 - return self.coef_ + np.apply_along_axis(lambda s: norm.ppf(lower, scale=s), 0, self.coef_std_err_), \ - self.coef_ + np.apply_along_axis(lambda s: norm.ppf(upper, scale=s), 0, self.coef_std_err_) + return self.coef_ + np.apply_along_axis(lambda s: norm.ppf(lower, scale=s), 0, self.coef_stderr_), \ + self.coef_ + np.apply_along_axis(lambda s: norm.ppf(upper, scale=s), 0, self.coef_stderr_) def intercept__interval(self, alpha=0.1): """Get a confidence interval bounding the fitted intercept. @@ -774,8 +797,8 @@ def intercept__interval(self, alpha=0.1): lower = alpha / 2 upper = 1 - alpha / 2 if self.fit_intercept: - return self.intercept_ + norm.ppf(lower, scale=self.intercept_std_err_), self.intercept_ + \ - norm.ppf(upper, scale=self.intercept_std_err_), + return self.intercept_ + norm.ppf(lower, scale=self.intercept_stderr_), self.intercept_ + \ + norm.ppf(upper, scale=self.intercept_stderr_), else: return 0.0, 0.0 @@ -917,10 +940,10 @@ class MultiOutputDebiasedLasso(MultiOutputRegressor): selected_alpha_ : array, shape (n_targets, ) or float Penalty chosen through cross-validation, if alpha='auto'. - coef_std_err_ : array, shape (n_targets, n_features) or (n_features, ) + coef_stderr_ : array, shape (n_targets, n_features) or (n_features, ) Estimated standard errors for coefficients (see ``coef_`` attribute). - intercept_std_err_ : array, shape (n_targets, ) or float + intercept_stderr_ : array, shape (n_targets, ) or float Estimated standard error intercept (see ``intercept_`` attribute). """ @@ -966,12 +989,53 @@ def fit(self, X, y, sample_weight=None): # Set selected_alpha_ attribute self._set_attribute("selected_alpha_", condition=(self.estimators_[0].alpha == 'auto')) - # Set coef_std_err_ - self._set_attribute("coef_std_err_") - # intercept_std_err_ - self._set_attribute("intercept_std_err_") + # Set coef_stderr_ + self._set_attribute("coef_stderr_") + # intercept_stderr_ + self._set_attribute("intercept_stderr_") return self + def predict(self, X): + """Get the prediction using the debiased lasso. + + Parameters + ---------- + X : ndarray or scipy.sparse matrix, (n_samples, n_features) + Samples. + + Returns + ------- + prediction : array like, shape (n_samples, ) or (n_samples, n_targets) + The prediction at each point. + + """ + pred = super().predict(X) + if self.flat_target: + pred = pred.flatten() + return pred + + def prediction_stderr(self, X): + """Get the standard error of the predictions using the debiased lasso. + + Parameters + ---------- + X : ndarray or scipy.sparse matrix, (n_samples, n_features) + Samples. + + Returns + ------- + prediction_stderr : array like, shape (n_samples, ) or (n_samples, n_targets) + The standard error of each coordinate of the output at each point we predict + """ + n_estimators = len(self.estimators_) + X = check_array(X) + pred_stderr = np.empty((X.shape[0], n_estimators)) + for i, estimator in enumerate(self.estimators_): + pred_stderr[:, i] = estimator.prediction_stderr(X) + if self.flat_target: + pred_stderr = pred_stderr.flatten() + return pred_stderr + def predict_interval(self, X, alpha=0.1): """Build prediction confidence intervals using the debiased lasso. diff --git a/econml/tests/test_dml.py b/econml/tests/test_dml.py index e56266017..2aa143e69 100644 --- a/econml/tests/test_dml.py +++ b/econml/tests/test_dml.py @@ -69,19 +69,31 @@ def make_random(is_discrete, d): d_t_final = 2 if is_discrete else d_t effect_shape = (n,) + ((d_y,) if d_y > 0 else ()) + effect_summaryframe_shape = (n * (d_y if d_y > 0 else 1), 6) marginal_effect_shape = ((n,) + ((d_y,) if d_y > 0 else ()) + ((d_t_final,) if d_t_final > 0 else ())) + marginal_effect_summaryframe_shape = (n * (d_y if d_y > 0 else 1), + 6 * (d_t_final if d_t_final > 0 else 1)) # since T isn't passed to const_marginal_effect, defaults to one row if X is None const_marginal_effect_shape = ((n if d_x else 1,) + ((d_y,) if d_y > 0 else ()) + ((d_t_final,) if d_t_final > 0 else())) + const_marginal_effect_summaryframe_shape = ( + (n if d_x else 1) * (d_y if d_y > 0 else 1), + 6 * (d_t_final if d_t_final > 0 else 1)) fd_x = featurizer.fit_transform(X).shape[1:] if featurizer and d_x\ else ((d_x,) if d_x else (0,)) coef_shape = Y.shape[1:] + (T.shape[1:] if not is_discrete else (2,)) + fd_x + + coef_summaryframe_shape = ( + (d_y if d_y > 0 else 1) * (fd_x[0] if fd_x[0] > 0 else 1), + (d_t_final if d_t_final > 0 else 1) * 6) intercept_shape = Y.shape[1:] + (T.shape[1:] if not is_discrete else (2,)) + intercept_summaryframe_shape = ( + (d_y if d_y > 0 else 1), (d_t_final if d_t_final > 0 else 1) * 6) model_t = LogisticRegression() if is_discrete else Lasso() @@ -170,6 +182,102 @@ def make_random(is_discrete, d): with pytest.raises(AttributeError): self.assertEqual(shape(est.intercept__interval()), (2,) + intercept_shape) + if inf in ['statsmodels', 'debiasedlasso', 'blb']: + const_marg_effect_inf = est.const_marginal_effect_inference(X) + T1 = np.full_like(T, 'b') if is_discrete else T + effect_inf = est.effect_inference(X, T0=T0, T1=T1) + marg_effect_inf = est.marginal_effect_inference(T, X) + # test const marginal inference + self.assertEqual(shape(const_marg_effect_inf.summary_frame()), + const_marginal_effect_summaryframe_shape) + self.assertEqual(shape(const_marg_effect_inf.point_estimate), + const_marginal_effect_shape) + self.assertEqual(shape(const_marg_effect_inf.stderr), + const_marginal_effect_shape) + self.assertEqual(shape(const_marg_effect_inf.var), + const_marginal_effect_shape) + self.assertEqual(shape(const_marg_effect_inf.pvalue()), + const_marginal_effect_shape) + self.assertEqual(shape(const_marg_effect_inf.zstat()), + const_marginal_effect_shape) + self.assertEqual(shape(const_marg_effect_inf.conf_int()), + (2,) + const_marginal_effect_shape) + np.testing.assert_array_almost_equal( + const_marg_effect_inf.conf_int()[0], + const_marg_eff_int[0], decimal=5) + const_marg_effect_inf.population_summary()._repr_html_() + + # test effect inference + self.assertEqual(shape(effect_inf.summary_frame()), + effect_summaryframe_shape) + self.assertEqual(shape(effect_inf.point_estimate), + effect_shape) + self.assertEqual(shape(effect_inf.stderr), + effect_shape) + self.assertEqual(shape(effect_inf.var), + effect_shape) + self.assertEqual(shape(effect_inf.pvalue()), + effect_shape) + self.assertEqual(shape(effect_inf.zstat()), + effect_shape) + self.assertEqual(shape(effect_inf.conf_int()), + (2,) + effect_shape) + np.testing.assert_array_almost_equal( + effect_inf.conf_int()[0], + est.effect_interval(X, T0=T0, T1=T1)[0], decimal=5) + effect_inf.population_summary()._repr_html_() + + # test marginal effect inference + self.assertEqual(shape(marg_effect_inf.summary_frame()), + marginal_effect_summaryframe_shape) + self.assertEqual(shape(marg_effect_inf.point_estimate), + marginal_effect_shape) + self.assertEqual(shape(marg_effect_inf.stderr), + marginal_effect_shape) + self.assertEqual(shape(marg_effect_inf.var), + marginal_effect_shape) + self.assertEqual(shape(marg_effect_inf.pvalue()), + marginal_effect_shape) + self.assertEqual(shape(marg_effect_inf.zstat()), + marginal_effect_shape) + self.assertEqual(shape(marg_effect_inf.conf_int()), + (2,) + marginal_effect_shape) + np.testing.assert_array_almost_equal( + marg_effect_inf.conf_int()[0], marg_eff_int[0], decimal=5) + marg_effect_inf.population_summary()._repr_html_() + + # test coef__inference and intercept__inference + if (isinstance(est, + LinearDMLCateEstimator) or + isinstance(est, + SparseLinearDMLCateEstimator)): + if X is None: + cm = pytest.raises(AttributeError) + else: + cm = ExitStack() + # ExitStack can be used as a "do nothing" ContextManager + with cm: + self.assertEqual( + shape(est.coef__inference().summary_frame()), + coef_summaryframe_shape) + np.testing.assert_array_almost_equal( + est.coef__inference().conf_int() + [0], est.coef__interval()[0], decimal=5) + + if fit_cate_intercept: + cm = ExitStack() + # ExitStack can be used as a "do nothing" ContextManager + else: + cm = pytest.raises(AttributeError) + with cm: + self.assertEqual(shape(est.intercept__inference(). + summary_frame()), + intercept_summaryframe_shape) + np.testing.assert_array_almost_equal( + est.intercept__inference().conf_int() + [0], est.intercept__interval()[0], decimal=5) + + est.summary() est.score(Y, T, X, W) @@ -219,14 +327,19 @@ def make_random(is_discrete, d): d_t_final = 1 if is_discrete else d_t effect_shape = (n,) + ((d_y,) if d_y > 0 else ()) + effect_summaryframe_shape = (n * (d_y if d_y > 0 else 1), 6) marginal_effect_shape = ((n,) + ((d_y,) if d_y > 0 else ()) + ((d_t_final,) if d_t_final > 0 else ())) - + marginal_effect_summaryframe_shape = (n * (d_y if d_y > 0 else 1), + 6 * (d_t_final if d_t_final > 0 else 1)) # since T isn't passed to const_marginal_effect, defaults to one row if X is None const_marginal_effect_shape = ((n if d_x else 1,) + ((d_y,) if d_y > 0 else ()) + ((d_t_final,) if d_t_final > 0 else())) + const_marginal_effect_summaryframe_shape = ( + (n if d_x else 1) * (d_y if d_y > 0 else 1), + 6 * (d_t_final if d_t_final > 0 else 1)) model_t = LogisticRegression() if is_discrete else WeightedLasso() @@ -288,6 +401,69 @@ def make_random(is_discrete, d): (2,) + const_marginal_effect_shape) self.assertEqual(shape(est.effect_interval(X, T0=T0, T1=T)), (2,) + effect_shape) + if inf in ['statsmodels', 'debiasedlasso', 'blb']: + const_marg_effect_inf = est.const_marginal_effect_inference(X) + T1 = np.full_like(T, 'b') if is_discrete else T + effect_inf = est.effect_inference(X, T0=T0, T1=T1) + marg_effect_inf = est.marginal_effect_inference(T, X) + # test const marginal inference + self.assertEqual(shape(const_marg_effect_inf.summary_frame()), + const_marginal_effect_summaryframe_shape) + self.assertEqual(shape(const_marg_effect_inf.point_estimate), + const_marginal_effect_shape) + self.assertEqual(shape(const_marg_effect_inf.stderr), + const_marginal_effect_shape) + self.assertEqual(shape(const_marg_effect_inf.var), + const_marginal_effect_shape) + self.assertEqual(shape(const_marg_effect_inf.pvalue()), + const_marginal_effect_shape) + self.assertEqual(shape(const_marg_effect_inf.zstat()), + const_marginal_effect_shape) + self.assertEqual(shape(const_marg_effect_inf.conf_int()), + (2,) + const_marginal_effect_shape) + np.testing.assert_array_almost_equal( + const_marg_effect_inf.conf_int()[0], + const_marg_eff_int[0], decimal=5) + const_marg_effect_inf.population_summary()._repr_html_() + + # test effect inference + self.assertEqual(shape(effect_inf.summary_frame()), + effect_summaryframe_shape) + self.assertEqual(shape(effect_inf.point_estimate), + effect_shape) + self.assertEqual(shape(effect_inf.stderr), + effect_shape) + self.assertEqual(shape(effect_inf.var), + effect_shape) + self.assertEqual(shape(effect_inf.pvalue()), + effect_shape) + self.assertEqual(shape(effect_inf.zstat()), + effect_shape) + self.assertEqual(shape(effect_inf.conf_int()), + (2,) + effect_shape) + np.testing.assert_array_almost_equal( + effect_inf.conf_int()[0], + est.effect_interval(X, T0=T0, T1=T1)[0], decimal=5) + effect_inf.population_summary()._repr_html_() + + # test marginal effect inference + self.assertEqual(shape(marg_effect_inf.summary_frame()), + marginal_effect_summaryframe_shape) + self.assertEqual(shape(marg_effect_inf.point_estimate), + marginal_effect_shape) + self.assertEqual(shape(marg_effect_inf.stderr), + marginal_effect_shape) + self.assertEqual(shape(marg_effect_inf.var), + marginal_effect_shape) + self.assertEqual(shape(marg_effect_inf.pvalue()), + marginal_effect_shape) + self.assertEqual(shape(marg_effect_inf.zstat()), + marginal_effect_shape) + self.assertEqual(shape(marg_effect_inf.conf_int()), + (2,) + marginal_effect_shape) + np.testing.assert_array_almost_equal( + marg_effect_inf.conf_int()[0], marg_eff_int[0], decimal=5) + marg_effect_inf.population_summary()._repr_html_() est.score(Y, T, X, W) diff --git a/econml/tests/test_drlearner.py b/econml/tests/test_drlearner.py index 72fd973cf..89f6f2517 100644 --- a/econml/tests/test_drlearner.py +++ b/econml/tests/test_drlearner.py @@ -1,653 +1,804 @@ -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. - -import numpy as np -import unittest -import pytest -from sklearn.base import TransformerMixin -from numpy.random import normal, multivariate_normal, binomial -from sklearn.exceptions import DataConversionWarning -from sklearn.linear_model import LinearRegression, Lasso, LogisticRegression -from sklearn.pipeline import Pipeline -from sklearn.preprocessing import OneHotEncoder, FunctionTransformer -from sklearn.model_selection import KFold -from sklearn.preprocessing import PolynomialFeatures -from econml.drlearner import DRLearner, LinearDRLearner, SparseLinearDRLearner, ForestDRLearner -from econml.utilities import shape, hstack, vstack, reshape, cross_product -from econml.inference import BootstrapInference, StatsModelsInferenceDiscrete -from contextlib import ExitStack -from sklearn.ensemble import GradientBoostingClassifier, GradientBoostingRegressor, RandomForestRegressor -from sklearn.linear_model import LinearRegression, LogisticRegression -from econml.utilities import StatsModelsLinearRegression -import scipy.special -import econml.tests.utilities # bugfix for assertWarns - - -class TestDRLearner(unittest.TestCase): - - @classmethod - def setUpClass(cls): - # Set random seed - cls.random_state = np.random.RandomState(12345) - # Generate data - # DGP constants - cls.d = 5 - cls.n = 1000 - cls.n_test = 200 - cls.beta = np.array([0.25, -0.38, 1.41, 0.50, -1.22]) - cls.heterogeneity_index = 1 - # Test data - cls.X_test = cls.random_state.multivariate_normal( - np.zeros(cls.d), - np.diag(np.ones(cls.d)), - cls.n_test) - # Constant treatment effect and propensity - cls.const_te_data = TestDRLearner._generate_data( - cls.n, cls.d, cls._untreated_outcome, - treatment_effect=TestDRLearner._const_te, - propensity=lambda x: 0.3) - # Heterogeneous treatment and propensity - cls.heterogeneous_te_data = TestDRLearner._generate_data( - cls.n, cls.d, cls._untreated_outcome, - treatment_effect=TestDRLearner._heterogeneous_te, - propensity=lambda x: (0.8 if (x[2] > -0.5 and x[2] < 0.5) else 0.2)) - - def test_cate_api(self): - """Test that we correctly implement the CATE API.""" - n = 20 - - def make_random(is_discrete, d): - if d is None: - return None - sz = (n, d) if d > 0 else (n,) - if is_discrete: - while True: - arr = np.random.choice(['a', 'b', 'c'], size=sz) - # ensure that we've got at least two of every element - _, counts = np.unique(arr, return_counts=True) - if len(counts) == 3 and counts.min() > 1: - return arr - else: - return np.random.normal(size=sz) - - for d_y in [0, 1]: - is_discrete = True - for d_t in [0, 1]: - for d_x in [2, None]: - for d_w in [2, None]: - W, X, Y, T = [make_random(is_discrete, d) - for is_discrete, d in [(False, d_w), - (False, d_x), - (False, d_y), - (is_discrete, d_t)]] - - if (X is None) and (W is None): - continue - d_t_final = 2 if is_discrete else d_t - - effect_shape = (n,) + ((d_y,) if d_y > 0 else ()) - marginal_effect_shape = ((n,) + - ((d_y,) if d_y > 0 else ()) + - ((d_t_final,) if d_t_final > 0 else ())) - - # since T isn't passed to const_marginal_effect, defaults to one row if X is None - const_marginal_effect_shape = ((n if d_x else 1,) + - ((d_y,) if d_y > 0 else ()) + - ((d_t_final,) if d_t_final > 0 else())) - - for est in [LinearDRLearner(model_propensity=LogisticRegression(C=1000, solver='lbfgs', - multi_class='auto')), - DRLearner(model_propensity=LogisticRegression(multi_class='auto'), - model_regression=LinearRegression(), - model_final=StatsModelsLinearRegression(), - multitask_model_final=True)]: - - # TODO: add stratification to bootstrap so that we can use it even with discrete treatments - infs = [None] - if isinstance(est, LinearDRLearner): - infs.append('statsmodels') - - for inf in infs: - with self.subTest(d_w=d_w, d_x=d_x, d_y=d_y, d_t=d_t, - is_discrete=is_discrete, est=est, inf=inf): - est.fit(Y, T, X, W, inference=inf) - # make sure we can call the marginal_effect and effect methods - const_marg_eff = est.const_marginal_effect(X) - marg_eff = est.marginal_effect(T, X) - self.assertEqual(shape(marg_eff), marginal_effect_shape) - self.assertEqual(shape(const_marg_eff), const_marginal_effect_shape) - - np.testing.assert_array_equal( - marg_eff if d_x else marg_eff[0:1], const_marg_eff) - - T0 = np.full_like(T, 'a') - eff = est.effect(X, T0=T0, T1=T) - self.assertEqual(shape(eff), effect_shape) - if inf is not None: - const_marg_eff_int = est.const_marginal_effect_interval(X) - marg_eff_int = est.marginal_effect_interval(T, X) - self.assertEqual(shape(marg_eff_int), - (2,) + marginal_effect_shape) - self.assertEqual(shape(const_marg_eff_int), - (2,) + const_marginal_effect_shape) - self.assertEqual(shape(est.effect_interval(X, T0=T0, T1=T)), - (2,) + effect_shape) - - est.score(Y, T, X, W) - - # make sure we can call effect with implied scalar treatments, no matter the - # dimensions of T, and also that we warn when there are multiple treatments - if d_t > 1: - cm = self.assertWarns(Warning) - else: - cm = ExitStack() # ExitStack can be used as a "do nothing" ContextManager - with cm: - effect_shape2 = (n if d_x else 1,) + ((d_y,) if d_y > 0 else()) - eff = est.effect(X, T0='a', T1='b') - self.assertEqual(shape(eff), effect_shape2) - - def test_can_use_vectors(self): - """ - TODO Almost identical to DML test, so consider merging - Test that we can pass vectors for T and Y (not only 2-dimensional arrays). - """ - dml = LinearDRLearner(model_regression=LinearRegression(), - model_propensity=LogisticRegression(C=1000, solver='lbfgs', multi_class='auto'), - fit_cate_intercept=False, - featurizer=FunctionTransformer(validate=True)) - dml.fit(np.array([1, 2, 1, 2]), np.array([1, 2, 1, 2]), X=np.ones((4, 1))) - self.assertAlmostEqual(dml.coef_(T=2).reshape(())[()], 1) - - def test_can_use_sample_weights(self): - """ - TODO Almost identical to DML test, so consider merging - Test that we can pass sample weights to an estimator. - """ - dml = LinearDRLearner(model_regression=LinearRegression(), - model_propensity=LogisticRegression(C=1000, solver='lbfgs', multi_class='auto'), - featurizer=FunctionTransformer(validate=True)) - dml.fit(np.array([1, 2, 1, 2]), np.array([1, 2, 1, 2]), W=np.ones((4, 1)), - sample_weight=np.ones((4, ))) - self.assertAlmostEqual(dml.intercept_(T=2), 1) - - def test_discrete_treatments(self): - """ - TODO Almost identical to DML test, so consider merging - Test that we can use discrete treatments - """ - dml = LinearDRLearner(model_regression=LinearRegression(), - model_propensity=LogisticRegression(C=1000, solver='lbfgs', multi_class='auto'), - featurizer=FunctionTransformer(validate=True)) - # create a simple artificial setup where effect of moving from treatment - # 1 -> 2 is 2, - # 1 -> 3 is 1, and - # 2 -> 3 is -1 (necessarily, by composing the previous two effects) - # Using an uneven number of examples from different classes, - # and having the treatments in non-lexicographic order, - # Should rule out some basic issues. - dml.fit(np.array([2, 3, 1, 3, 2, 1, 1, 1]), np.array([3, 2, 1, 2, 3, 1, 1, 1]), np.ones((8, 1))) - np.testing.assert_almost_equal(dml.effect(np.ones((9, 1)), - T0=np.array([1, 1, 1, 2, 2, 2, 3, 3, 3]), - T1=np.array([1, 2, 3, 1, 2, 3, 1, 2, 3])), - [0, 2, 1, -2, 0, -1, -1, 1, 0]) - dml.score(np.array([2, 3, 1, 3, 2, 1, 1, 1]), np.array([3, 2, 1, 2, 3, 1, 1, 1]), np.ones((8, 1))) - - def test_can_custom_splitter(self): - """ - TODO Almost identical to DML test, so consider merging - """ - # test that we can fit with a KFold instance - dml = LinearDRLearner(model_regression=LinearRegression(), - model_propensity=LogisticRegression(C=1000, solver='lbfgs', multi_class='auto'), - n_splits=KFold(n_splits=3)) - dml.fit(np.array([1, 2, 3, 1, 2, 3]), np.array([1, 2, 3, 1, 2, 3]), np.ones((6, 1))) - dml.score(np.array([1, 2, 3, 1, 2, 3]), np.array([1, 2, 3, 1, 2, 3]), np.ones((6, 1))) - - # test that we can fit with a train/test iterable - dml = LinearDRLearner(model_regression=LinearRegression(), - model_propensity=LogisticRegression(C=1000, solver='lbfgs', multi_class='auto'), - n_splits=[([0, 1, 2], [3, 4, 5])]) - dml.fit(np.array([1, 2, 3, 1, 2, 3]), np.array([1, 2, 3, 1, 2, 3]), np.ones((6, 1))) - dml.score(np.array([1, 2, 3, 1, 2, 3]), np.array([1, 2, 3, 1, 2, 3]), np.ones((6, 1))) - - def test_can_use_statsmodel_inference(self): - """ - TODO Almost identical to DML test, so consider merging - Test that we can use statsmodels to generate confidence intervals - """ - dml = LinearDRLearner(model_regression=LinearRegression(), - model_propensity=LogisticRegression(C=1000, solver='lbfgs', multi_class='auto')) - dml.fit(np.array([2, 3, 1, 3, 2, 1, 1, 1]), np.array( - [3, 2, 1, 2, 3, 1, 1, 1]), np.ones((8, 1)), inference='statsmodels') - interval = dml.effect_interval(np.ones((9, 1)), - T0=np.array([1, 1, 1, 1, 1, 1, 1, 1, 1]), - T1=np.array([2, 2, 3, 2, 2, 3, 2, 2, 3]), - alpha=0.05) - point = dml.effect(np.ones((9, 1)), - T0=np.array([1, 1, 1, 1, 1, 1, 1, 1, 1]), - T1=np.array([2, 2, 3, 2, 2, 3, 2, 2, 3])) - assert len(interval) == 2 - lo, hi = interval - assert lo.shape == hi.shape == point.shape - assert (lo <= point).all() - assert (point <= hi).all() - assert (lo < hi).any() # for at least some of the examples, the CI should have nonzero width - - interval = dml.const_marginal_effect_interval(np.ones((9, 1)), alpha=0.05) - point = dml.const_marginal_effect(np.ones((9, 1))) - assert len(interval) == 2 - lo, hi = interval - assert lo.shape == hi.shape == point.shape - assert (lo <= point).all() - assert (point <= hi).all() - assert (lo < hi).any() # for at least some of the examples, the CI should have nonzero width - - interval = dml.coef__interval(T=2, alpha=0.05) - point = dml.coef_(T=2) - assert len(interval) == 2 - lo, hi = interval - assert lo.shape == hi.shape == point.shape - assert (lo <= point).all() - assert (point <= hi).all() - assert (lo < hi).any() # for at least some of the examples, the CI should have nonzero width - - def test_drlearner_all_attributes(self): - from sklearn.ensemble import GradientBoostingClassifier, GradientBoostingRegressor, RandomForestRegressor - from sklearn.linear_model import LinearRegression, LogisticRegression - from econml.utilities import StatsModelsLinearRegression - import scipy.special - np.random.seed(123) - controls = np.random.uniform(-1, 1, size=(5000, 3)) - T = np.random.binomial(2, scipy.special.expit(controls[:, 0])) - sigma = 0.01 - y = (1 + .5 * controls[:, 0]) * T + controls[:, 0] + np.random.normal(0, sigma, size=(5000,)) - for X in [controls]: - for W in [None, controls]: - for sample_weight in [None, 1 + np.random.randint(10, size=X.shape[0])]: - for sample_var in [None, 1 + np.random.randint(10, size=X.shape[0])]: - for featurizer in [None, PolynomialFeatures(degree=2, include_bias=False)]: - for models in [(GradientBoostingClassifier(), GradientBoostingRegressor(), - RandomForestRegressor(n_estimators=100, - max_depth=5, min_samples_leaf=50)), - (GradientBoostingClassifier(), GradientBoostingRegressor(), - RandomForestRegressor(n_estimators=100, - max_depth=5, min_samples_leaf=50)), - (LogisticRegression(solver='lbfgs', multi_class='auto'), - LinearRegression(), StatsModelsLinearRegression())]: - for multitask_model_final in [False, True]: - if (not isinstance(models, StatsModelsLinearRegression))\ - and (sample_var is not None): - continue - with self.subTest(X=X, W=W, sample_weight=sample_weight, sample_var=sample_var, - featurizer=featurizer, models=models, - multitask_model_final=multitask_model_final): - est = DRLearner(model_propensity=models[0], - model_regression=models[1], - model_final=models[2], - featurizer=featurizer, - multitask_model_final=multitask_model_final) - if (X is None) and (W is None): - with pytest.raises(AttributeError) as e_info: - est.fit(y, T, X=X, W=W, - sample_weight=sample_weight, sample_var=sample_var) - continue - est.fit(y, T, X=X, W=W, sample_weight=sample_weight, sample_var=sample_var) - np.testing.assert_allclose(est.effect(X[:3], T0=0, T1=1), 1 + .5 * X[:3, 0], - rtol=0, atol=.15) - np.testing.assert_allclose(est.const_marginal_effect(X[:3]), - np.hstack( - [1 + .5 * X[:3, [0]], - 2 * (1 + .5 * X[:3, [0]])]), - rtol=0, atol=.15) - for t in [1, 2]: - np.testing.assert_allclose(est.marginal_effect(t, X[:3]), - np.hstack([1 + .5 * X[:3, [0]], - 2 * (1 + .5 * X[:3, [0]])]), - rtol=0, atol=.15) - assert isinstance(est.score_, float) - assert isinstance(est.score(y, T, X=X, W=W), float) - - feat_names = ['A', 'B', 'C'] - out_feat_names = feat_names - if featurizer is not None: - out_feat_names = featurizer.fit(X).get_feature_names(feat_names) - np.testing.assert_array_equal(est.featurizer.n_input_features_, 3) - np.testing.assert_array_equal(est.cate_feature_names(feat_names), - out_feat_names) - - if isinstance(models[0], GradientBoostingClassifier): - np.testing.assert_array_equal(np.array([mdl.feature_importances_ - for mdl - in est.models_regression]).shape, - [2, 2 + X.shape[1] + - (W.shape[1] if W is not None else 0)]) - np.testing.assert_array_equal(np.array([mdl.feature_importances_ - for mdl - in est.models_propensity]).shape, - [2, X.shape[1] + - (W.shape[1] if W is not None else 0)]) - else: - np.testing.assert_array_equal(np.array([mdl.coef_ - for mdl - in est.models_regression]).shape, - [2, 2 + X.shape[1] + - (W.shape[1] if W is not None else 0)]) - np.testing.assert_array_equal(np.array([mdl.coef_ - for mdl - in est.models_propensity]).shape, - [2, 3, X.shape[1] + - (W.shape[1] if W is not None else 0)]) - if multitask_model_final: - if isinstance(models[2], RandomForestRegressor): - np.testing.assert_equal(np.argsort( - est.multitask_model_cate.feature_importances_)[-1], 0) - else: - true_coef = np.zeros((2, len(out_feat_names))) - true_coef[:, 0] = [.5, 1] - np.testing.assert_allclose( - est.multitask_model_cate.coef_, true_coef, rtol=0, atol=.15) - np.testing.assert_allclose( - est.multitask_model_cate.intercept_, [1, 2], rtol=0, atol=.15) - else: - for t in [1, 2]: - if isinstance(models[2], RandomForestRegressor): - np.testing.assert_equal(np.argsort( - est.model_cate(T=t).feature_importances_)[-1], 0) - else: - true_coef = np.zeros(len(out_feat_names)) - true_coef[0] = .5 * t - np.testing.assert_allclose( - est.model_cate(T=t).coef_, true_coef, rtol=0, atol=.15) - np.testing.assert_allclose( - est.model_cate(T=t).intercept_, t, rtol=0, atol=.15) - - def test_drlearner_with_inference_all_attributes(self): - np.random.seed(123) - controls = np.random.uniform(-1, 1, size=(10000, 2)) - T = np.random.binomial(2, scipy.special.expit(controls[:, 0])) - sigma = 0.01 - y = (1 + .5 * controls[:, 0]) * T + controls[:, 0] + np.random.normal(0, sigma, size=(10000,)) - for X in [None, controls]: - for W in [None, controls]: - for sample_weight, sample_var in [(None, None), (np.ones(T.shape[0]), np.zeros(T.shape[0]))]: - for featurizer in [None, PolynomialFeatures(degree=2, include_bias=False)]: - for models in [(GradientBoostingClassifier(), GradientBoostingRegressor()), - (LogisticRegression(solver='lbfgs', multi_class='auto'), - LinearRegression())]: - for est_class,\ - inference in [(ForestDRLearner, 'blb'), - (LinearDRLearner, 'statsmodels'), - (LinearDRLearner, StatsModelsInferenceDiscrete(cov_type='nonrobust')), - (SparseLinearDRLearner, 'debiasedlasso')]: - with self.subTest(X=X, W=W, sample_weight=sample_weight, sample_var=sample_var, - featurizer=featurizer, models=models, - est_class=est_class, inference=inference): - if (X is None) and (est_class == SparseLinearDRLearner): - continue - if (X is None) and (est_class == ForestDRLearner): - continue - if (featurizer is not None) and (est_class == ForestDRLearner): - continue - - if est_class == ForestDRLearner: - est = est_class(model_propensity=models[0], - model_regression=models[1]) - else: - est = est_class(model_propensity=models[0], - model_regression=models[1], - featurizer=featurizer) - - if (X is None) and (W is None): - with pytest.raises(AttributeError) as e_info: - est.fit(y, T, X=X, W=W, sample_weight=sample_weight, sample_var=sample_var) - continue - est.fit(y, T, X=X, W=W, sample_weight=sample_weight, - sample_var=sample_var, inference=inference) - if X is not None: - lower, upper = est.effect_interval(X[:3], T0=0, T1=1) - point = est.effect(X[:3], T0=0, T1=1) - truth = 1 + .5 * X[:3, 0] - TestDRLearner._check_with_interval(truth, point, lower, upper) - lower, upper = est.const_marginal_effect_interval(X[:3]) - point = est.const_marginal_effect(X[:3]) - truth = np.hstack([1 + .5 * X[:3, [0]], 2 * (1 + .5 * X[:3, [0]])]) - TestDRLearner._check_with_interval(truth, point, lower, upper) - else: - lower, upper = est.effect_interval(T0=0, T1=1) - point = est.effect(T0=0, T1=1) - truth = np.array([1]) - TestDRLearner._check_with_interval(truth, point, lower, upper) - lower, upper = est.const_marginal_effect_interval() - point = est.const_marginal_effect() - truth = np.array([[1, 2]]) - TestDRLearner._check_with_interval(truth, point, lower, upper) - - for t in [1, 2]: - if X is not None: - lower, upper = est.marginal_effect_interval(t, X[:3]) - point = est.marginal_effect(t, X[:3]) - truth = np.hstack([1 + .5 * X[:3, [0]], 2 * (1 + .5 * X[:3, [0]])]) - TestDRLearner._check_with_interval(truth, point, lower, upper) - else: - lower, upper = est.marginal_effect_interval(t) - point = est.marginal_effect(t) - truth = np.array([[1, 2]]) - TestDRLearner._check_with_interval(truth, point, lower, upper) - assert isinstance(est.score_, float) - assert isinstance(est.score(y, T, X=X, W=W), float) - - if X is not None: - feat_names = ['A', 'B'] - else: - feat_names = [] - out_feat_names = feat_names - if X is not None: - if (featurizer is not None): - out_feat_names = featurizer.fit(X).get_feature_names(feat_names) - np.testing.assert_array_equal(est.featurizer.n_input_features_, 2) - np.testing.assert_array_equal(est.cate_feature_names(feat_names), - out_feat_names) - - if isinstance(models[0], GradientBoostingClassifier): - np.testing.assert_array_equal(np.array([mdl.feature_importances_ - for mdl - in est.models_regression]).shape, - [2, 2 + len(feat_names) + - (W.shape[1] if W is not None else 0)]) - np.testing.assert_array_equal(np.array([mdl.feature_importances_ - for mdl - in est.models_propensity]).shape, - [2, len(feat_names) + - (W.shape[1] if W is not None else 0)]) - else: - np.testing.assert_array_equal(np.array([mdl.coef_ - for mdl - in est.models_regression]).shape, - [2, 2 + len(feat_names) + - (W.shape[1] if W is not None else 0)]) - np.testing.assert_array_equal(np.array([mdl.coef_ - for mdl - in est.models_propensity]).shape, - [2, 3, len(feat_names) + - (W.shape[1] if W is not None else 0)]) - - if isinstance(est, LinearDRLearner) or isinstance(est, SparseLinearDRLearner): - if X is not None: - for t in [1, 2]: - true_coef = np.zeros(len(out_feat_names)) - true_coef[0] = .5 * t - lower, upper = est.model_cate(T=t).coef__interval() - point = est.model_cate(T=t).coef_ - truth = true_coef - TestDRLearner._check_with_interval(truth, point, lower, upper) - - lower, upper = est.coef__interval(t) - point = est.coef_(t) - truth = true_coef - TestDRLearner._check_with_interval(truth, point, lower, upper) - for t in [1, 2]: - lower, upper = est.model_cate(T=t).intercept__interval() - point = est.model_cate(T=t).intercept_ - truth = t - TestDRLearner._check_with_interval(truth, point, lower, upper) - - lower, upper = est.intercept__interval(t) - point = est.intercept_(t) - truth = t - TestDRLearner._check_with_interval(truth, point, lower, upper) - - @staticmethod - def _check_with_interval(truth, point, lower, upper): - np.testing.assert_allclose(point, truth, rtol=0, atol=.2) - np.testing.assert_array_less(lower - 0.05, truth) - np.testing.assert_array_less(truth, upper + 0.05) - - def test_DRLearner(self): - """Tests whether the DRLearner can accurately estimate constant and - heterogeneous treatment effects. - """ - DR_learner = DRLearner(model_regression=LinearRegression(), - model_final=LinearRegression()) - # Test inputs - # self._test_inputs(DR_learner) - # Test constant treatment effect - self._test_te(DR_learner, tol=0.5, te_type="const") - # Test heterogeneous treatment effect - outcome_model = Pipeline([('poly', PolynomialFeatures()), ('model', LinearRegression())]) - DR_learner = DRLearner(model_regression=outcome_model, - model_final=LinearRegression()) - self._test_te(DR_learner, tol=0.5, te_type="heterogeneous") - # Test heterogenous treatment effect for W =/= None - self._test_with_W(DR_learner, tol=0.5) - - def test_sparse(self): - """SparseDRLearner test with a sparse DGP""" - # Sparse DGP - np.random.seed(123) - n_x = 50 - n_nonzero = 1 - n_w = 5 - n = 1000 - # Treatment effect coef - a = np.zeros(n_x) - nonzero_idx = np.random.choice(n_x, size=n_nonzero, replace=False) - a[nonzero_idx] = 1 - # Other coefs - b = np.zeros(n_x + n_w) - g = np.zeros(n_x + n_w) - b_nonzero = np.random.choice(n_x + n_w, size=n_nonzero, replace=False) - g_nonzero = np.random.choice(n_x + n_w, size=n_nonzero, replace=False) - b[b_nonzero] = 1 - g[g_nonzero] = 1 - # Features and controls - x = np.random.normal(size=(n, n_x)) - w = np.random.normal(size=(n, n_w)) - xw = np.hstack([x, w]) - T = np.random.binomial(1, scipy.special.expit(xw @ b)) - err_Y = np.random.normal(size=n, scale=0.5) - Y = T * (x @ a) + xw @ g + err_Y - # Test sparse estimator - # --> test coef_, intercept_ - sparse_dml = SparseLinearDRLearner(featurizer=FunctionTransformer()) - sparse_dml.fit(Y, T, x, w, inference='debiasedlasso') - np.testing.assert_allclose(a, sparse_dml.coef_(T=1), atol=2e-1) - np.testing.assert_allclose(sparse_dml.intercept_(T=1), 0, atol=2e-1) - # --> test treatment effects - # Restrict x_test to vectors of norm < 1 - x_test = np.random.uniform(size=(10, n_x)) - true_eff = (x_test @ a) - eff = sparse_dml.effect(x_test, T0=0, T1=1) - np.testing.assert_allclose(true_eff, eff, atol=0.5) - # --> check inference - y_lower, y_upper = sparse_dml.effect_interval(x_test, T0=0, T1=1) - in_CI = ((y_lower < true_eff) & (true_eff < y_upper)) - # Check that a majority of true effects lie in the 5-95% CI - self.assertTrue(in_CI.mean() > 0.8) - - def test_drlearner_clipping(self): - X = np.linspace(0, 1, 200).reshape(-1, 1) - T = np.random.binomial(1, X) - Y = np.random.normal(size=T.shape) - X[0] = -1000 # one split will have only X values between 0 and 1, - # so the predicted propensity for this point will be extremely low - learner = DRLearner() - learner.fit(Y, T, X) - effect = learner.const_marginal_effect(np.array([[0.5]])) - assert not(np.any(np.isnan(effect))) - - def _test_te(self, learner_instance, tol, te_type="const"): - if te_type not in ["const", "heterogeneous"]: - raise ValueError("Type of treatment effect must be 'const' or 'heterogeneous'.") - X, T, Y = getattr(TestDRLearner, "{te_type}_te_data".format(te_type=te_type)) - te_func = getattr(TestDRLearner, "_{te_type}_te".format(te_type=te_type)) - # Fit learner and get the effect - learner_instance.fit(Y, T, X) - te_hat = learner_instance.effect(TestDRLearner.X_test) - # Get the true treatment effect - te = np.apply_along_axis(te_func, 1, TestDRLearner.X_test) - # Compute treatment effect residuals (absolute) - te_res = np.abs(te - te_hat) - # Check that at least 90% of predictions are within tolerance interval - self.assertGreaterEqual(np.mean(te_res < tol), 0.90) - - def _test_with_W(self, learner_instance, tol): - # Only for heterogeneous TE - X, T, Y = TestDRLearner.heterogeneous_te_data - # Fit learner on X and W and get the effect - learner_instance.fit(Y, T, X=X[:, [TestDRLearner.heterogeneity_index]], W=X) - te_hat = learner_instance.effect(TestDRLearner.X_test[:, [TestDRLearner.heterogeneity_index]]) - # Get the true treatment effect - te = np.apply_along_axis(TestDRLearner._heterogeneous_te, 1, TestDRLearner.X_test) - # Compute treatment effect residuals (absolute) - te_res = np.abs(te - te_hat) - # Check that at least 90% of predictions are within tolerance interval - self.assertGreaterEqual(np.mean(te_res < tol), 0.90) - - def _test_inputs(self, learner_instance): - X, T, Y = TestDRLearner.const_te_data - # Check that one can pass in regular lists - learner_instance.fit(list(Y), list(T), list(X)) - learner_instance.effect(list(TestDRLearner.X_test)) - # Check that it fails correctly if lists of different shape are passed in - self.assertRaises(ValueError, learner_instance.fit, Y, T, X[:TestDRLearner.n // 2]) - self.assertRaises(ValueError, learner_instance.fit, Y[:TestDRLearner.n // 2], T, X) - # Check that it fails when T contains values other than 0 and 1 - self.assertRaises(ValueError, learner_instance.fit, Y, T + 1, X) - # Check that it works when T, Y have shape (n, 1) - self.assertWarns(DataConversionWarning, - learner_instance.fit, Y.reshape(-1, 1), T.reshape(-1, 1), X - ) - - @classmethod - def _untreated_outcome(cls, x): - return np.dot(x, cls.beta) + cls.random_state.normal(0, 1) - - @classmethod - def _const_te(cls, x): - return 2 - - @classmethod - def _heterogeneous_te(cls, x): - return x[cls.heterogeneity_index] - - @classmethod - def _generate_data(cls, n, d, untreated_outcome, treatment_effect, propensity): - """Generates population data for given untreated_outcome, treatment_effect and propensity functions. - - Parameters - ---------- - n (int): population size - d (int): number of covariates - untreated_outcome (func): untreated outcome conditional on covariates - treatment_effect (func): treatment effect conditional on covariates - propensity (func): probability of treatment conditional on covariates - """ - # Generate covariates - X = cls.random_state.multivariate_normal(np.zeros(d), np.diag(np.ones(d)), n) - # Generate treatment - T = np.apply_along_axis(lambda x: cls.random_state.binomial(1, propensity(x), 1)[0], 1, X) - # Calculate outcome - Y0 = np.apply_along_axis(lambda x: untreated_outcome(x), 1, X) - treat_effect = np.apply_along_axis(lambda x: treatment_effect(x), 1, X) - Y = Y0 + treat_effect * T - return (X, T, Y) +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +import numpy as np +import unittest +import pytest +from sklearn.base import TransformerMixin +from numpy.random import normal, multivariate_normal, binomial +from sklearn.exceptions import DataConversionWarning +from sklearn.linear_model import LinearRegression, Lasso, LogisticRegression +from sklearn.pipeline import Pipeline +from sklearn.preprocessing import OneHotEncoder, FunctionTransformer +from sklearn.model_selection import KFold +from sklearn.preprocessing import PolynomialFeatures +from econml.drlearner import DRLearner, LinearDRLearner, SparseLinearDRLearner, ForestDRLearner +from econml.utilities import shape, hstack, vstack, reshape, cross_product +from econml.inference import BootstrapInference, StatsModelsInferenceDiscrete +from contextlib import ExitStack +from sklearn.ensemble import GradientBoostingClassifier, GradientBoostingRegressor, RandomForestRegressor +from sklearn.linear_model import LinearRegression, LogisticRegression +from econml.utilities import StatsModelsLinearRegression +import scipy.special +import econml.tests.utilities # bugfix for assertWarns + + +class TestDRLearner(unittest.TestCase): + + @classmethod + def setUpClass(cls): + # Set random seed + cls.random_state = np.random.RandomState(12345) + # Generate data + # DGP constants + cls.d = 5 + cls.n = 1000 + cls.n_test = 200 + cls.beta = np.array([0.25, -0.38, 1.41, 0.50, -1.22]) + cls.heterogeneity_index = 1 + # Test data + cls.X_test = cls.random_state.multivariate_normal( + np.zeros(cls.d), + np.diag(np.ones(cls.d)), + cls.n_test) + # Constant treatment effect and propensity + cls.const_te_data = TestDRLearner._generate_data( + cls.n, cls.d, cls._untreated_outcome, + treatment_effect=TestDRLearner._const_te, + propensity=lambda x: 0.3) + # Heterogeneous treatment and propensity + cls.heterogeneous_te_data = TestDRLearner._generate_data( + cls.n, cls.d, cls._untreated_outcome, + treatment_effect=TestDRLearner._heterogeneous_te, + propensity=lambda x: (0.8 if (x[2] > -0.5 and x[2] < 0.5) else 0.2)) + + def test_cate_api(self): + """Test that we correctly implement the CATE API.""" + n = 20 + + def make_random(is_discrete, d): + if d is None: + return None + sz = (n, d) if d > 0 else (n,) + if is_discrete: + while True: + arr = np.random.choice(['a', 'b', 'c'], size=sz) + # ensure that we've got at least two of every element + _, counts = np.unique(arr, return_counts=True) + if len(counts) == 3 and counts.min() > 1: + return arr + else: + return np.random.normal(size=sz) + + for d_y in [0, 1]: + is_discrete = True + for d_t in [0, 1]: + for d_x in [2, None]: + for d_w in [2, None]: + W, X, Y, T = [make_random(is_discrete, d) + for is_discrete, d in [(False, d_w), + (False, d_x), + (False, d_y), + (is_discrete, d_t)]] + + if (X is None) and (W is None): + continue + d_t_final = 2 if is_discrete else d_t + + effect_shape = (n,) + ((d_y,) if d_y > 0 else ()) + effect_summaryframe_shape = ( + n * (d_y if d_y > 0 else 1), 6) + marginal_effect_shape = ((n,) + + ((d_y,) if d_y > 0 else ()) + + ((d_t_final,) if d_t_final > 0 else ())) + marginal_effect_summaryframe_shape = (n * (d_y if d_y > 0 else 1), + 6 * (d_t_final if d_t_final > 0 else 1)) + + # since T isn't passed to const_marginal_effect, defaults to one row if X is None + const_marginal_effect_shape = ((n if d_x else 1,) + + ((d_y,) if d_y > 0 else ()) + + ((d_t_final,) if d_t_final > 0 else())) + const_marginal_effect_summaryframe_shape = ( + (n if d_x else 1) * (d_y if d_y > 0 else 1), + 6 * (d_t_final if d_t_final > 0 else 1)) + + for est in [LinearDRLearner(model_propensity=LogisticRegression(C=1000, solver='lbfgs', + multi_class='auto')), + DRLearner(model_propensity=LogisticRegression(multi_class='auto'), + model_regression=LinearRegression(), + model_final=StatsModelsLinearRegression(), + multitask_model_final=True)]: + + # TODO: add stratification to bootstrap so that we can use it even with discrete treatments + infs = [None] + if isinstance(est, LinearDRLearner): + infs.append('statsmodels') + + for inf in infs: + with self.subTest(d_w=d_w, d_x=d_x, d_y=d_y, d_t=d_t, + is_discrete=is_discrete, est=est, inf=inf): + est.fit(Y, T, X, W, inference=inf) + # make sure we can call the marginal_effect and effect methods + const_marg_eff = est.const_marginal_effect( + X) + marg_eff = est.marginal_effect(T, X) + self.assertEqual( + shape(marg_eff), marginal_effect_shape) + self.assertEqual( + shape(const_marg_eff), const_marginal_effect_shape) + + np.testing.assert_array_equal( + marg_eff if d_x else marg_eff[0:1], const_marg_eff) + + T0 = np.full_like(T, 'a') + eff = est.effect(X, T0=T0, T1=T) + self.assertEqual(shape(eff), effect_shape) + if inf is not None: + const_marg_eff_int = est.const_marginal_effect_interval( + X) + marg_eff_int = est.marginal_effect_interval( + T, X) + const_marg_effect_inf = est.const_marginal_effect_inference( + X) + T1 = np.full_like(T, 'b') + effect_inf = est.effect_inference( + X, T0=T0, T1=T1) + marg_effect_inf = est.marginal_effect_inference( + T, X) + self.assertEqual(shape(marg_eff_int), + (2,) + marginal_effect_shape) + self.assertEqual(shape(const_marg_eff_int), + (2,) + const_marginal_effect_shape) + self.assertEqual(shape(est.effect_interval(X, T0=T0, T1=T)), + (2,) + effect_shape) + + # test const marginal inference + self.assertEqual(shape(const_marg_effect_inf.summary_frame()), + const_marginal_effect_summaryframe_shape) + self.assertEqual(shape(const_marg_effect_inf.point_estimate), + const_marginal_effect_shape) + self.assertEqual(shape(const_marg_effect_inf.stderr), + const_marginal_effect_shape) + self.assertEqual(shape(const_marg_effect_inf.var), + const_marginal_effect_shape) + self.assertEqual(shape(const_marg_effect_inf.pvalue()), + const_marginal_effect_shape) + self.assertEqual(shape(const_marg_effect_inf.zstat()), + const_marginal_effect_shape) + self.assertEqual(shape(const_marg_effect_inf.conf_int()), + (2,) + const_marginal_effect_shape) + np.testing.assert_array_almost_equal(const_marg_effect_inf.conf_int() + [0], const_marg_eff_int[0], decimal=5) + const_marg_effect_inf.population_summary()._repr_html_() + + # test effect inference + self.assertEqual(shape(effect_inf.summary_frame()), + effect_summaryframe_shape) + self.assertEqual(shape(effect_inf.point_estimate), + effect_shape) + self.assertEqual(shape(effect_inf.stderr), + effect_shape) + self.assertEqual(shape(effect_inf.var), + effect_shape) + self.assertEqual(shape(effect_inf.pvalue()), + effect_shape) + self.assertEqual(shape(effect_inf.zstat()), + effect_shape) + self.assertEqual(shape(effect_inf.conf_int()), + (2,) + effect_shape) + np.testing.assert_array_almost_equal(effect_inf.conf_int() + [0], est.effect_interval( + X, T0=T0, T1=T1) + [0], decimal=5) + effect_inf.population_summary()._repr_html_() + + # test marginal effect inference + self.assertEqual(shape(marg_effect_inf.summary_frame()), + marginal_effect_summaryframe_shape) + self.assertEqual(shape(marg_effect_inf.point_estimate), + marginal_effect_shape) + self.assertEqual(shape(marg_effect_inf.stderr), + marginal_effect_shape) + self.assertEqual(shape(marg_effect_inf.var), + marginal_effect_shape) + self.assertEqual(shape(marg_effect_inf.pvalue()), + marginal_effect_shape) + self.assertEqual(shape(marg_effect_inf.zstat()), + marginal_effect_shape) + self.assertEqual(shape(marg_effect_inf.conf_int()), + (2,) + marginal_effect_shape) + np.testing.assert_array_almost_equal(marg_effect_inf.conf_int() + [0], marg_eff_int[0], decimal=5) + marg_effect_inf.population_summary()._repr_html_() + + est.score(Y, T, X, W) + + # make sure we can call effect with implied scalar treatments, no matter the + # dimensions of T, and also that we warn when there are multiple treatments + if d_t > 1: + cm = self.assertWarns(Warning) + else: + cm = ExitStack() # ExitStack can be used as a "do nothing" ContextManager + with cm: + effect_shape2 = ( + n if d_x else 1,) + ((d_y,) if d_y > 0 else()) + eff = est.effect(X, T0='a', T1='b') + self.assertEqual( + shape(eff), effect_shape2) + + def test_can_use_vectors(self): + """ + TODO Almost identical to DML test, so consider merging + Test that we can pass vectors for T and Y (not only 2-dimensional arrays). + """ + dml = LinearDRLearner(model_regression=LinearRegression(), + model_propensity=LogisticRegression( + C=1000, solver='lbfgs', multi_class='auto'), + fit_cate_intercept=False, + featurizer=FunctionTransformer(validate=True)) + dml.fit(np.array([1, 2, 1, 2]), np.array( + [1, 2, 1, 2]), X=np.ones((4, 1))) + self.assertAlmostEqual(dml.coef_(T=2).reshape(())[()], 1) + + def test_can_use_sample_weights(self): + """ + TODO Almost identical to DML test, so consider merging + Test that we can pass sample weights to an estimator. + """ + dml = LinearDRLearner(model_regression=LinearRegression(), + model_propensity=LogisticRegression( + C=1000, solver='lbfgs', multi_class='auto'), + featurizer=FunctionTransformer(validate=True)) + dml.fit(np.array([1, 2, 1, 2]), np.array([1, 2, 1, 2]), W=np.ones((4, 1)), + sample_weight=np.ones((4, ))) + self.assertAlmostEqual(dml.intercept_(T=2), 1) + + def test_discrete_treatments(self): + """ + TODO Almost identical to DML test, so consider merging + Test that we can use discrete treatments + """ + dml = LinearDRLearner(model_regression=LinearRegression(), + model_propensity=LogisticRegression( + C=1000, solver='lbfgs', multi_class='auto'), + featurizer=FunctionTransformer(validate=True)) + # create a simple artificial setup where effect of moving from treatment + # 1 -> 2 is 2, + # 1 -> 3 is 1, and + # 2 -> 3 is -1 (necessarily, by composing the previous two effects) + # Using an uneven number of examples from different classes, + # and having the treatments in non-lexicographic order, + # Should rule out some basic issues. + dml.fit(np.array([2, 3, 1, 3, 2, 1, 1, 1]), np.array( + [3, 2, 1, 2, 3, 1, 1, 1]), np.ones((8, 1))) + np.testing.assert_almost_equal(dml.effect(np.ones((9, 1)), + T0=np.array( + [1, 1, 1, 2, 2, 2, 3, 3, 3]), + T1=np.array([1, 2, 3, 1, 2, 3, 1, 2, 3])), + [0, 2, 1, -2, 0, -1, -1, 1, 0]) + dml.score(np.array([2, 3, 1, 3, 2, 1, 1, 1]), np.array( + [3, 2, 1, 2, 3, 1, 1, 1]), np.ones((8, 1))) + + def test_can_custom_splitter(self): + """ + TODO Almost identical to DML test, so consider merging + """ + # test that we can fit with a KFold instance + dml = LinearDRLearner(model_regression=LinearRegression(), + model_propensity=LogisticRegression( + C=1000, solver='lbfgs', multi_class='auto'), + n_splits=KFold(n_splits=3)) + dml.fit(np.array([1, 2, 3, 1, 2, 3]), np.array( + [1, 2, 3, 1, 2, 3]), np.ones((6, 1))) + dml.score(np.array([1, 2, 3, 1, 2, 3]), np.array( + [1, 2, 3, 1, 2, 3]), np.ones((6, 1))) + + # test that we can fit with a train/test iterable + dml = LinearDRLearner(model_regression=LinearRegression(), + model_propensity=LogisticRegression( + C=1000, solver='lbfgs', multi_class='auto'), + n_splits=[([0, 1, 2], [3, 4, 5])]) + dml.fit(np.array([1, 2, 3, 1, 2, 3]), np.array( + [1, 2, 3, 1, 2, 3]), np.ones((6, 1))) + dml.score(np.array([1, 2, 3, 1, 2, 3]), np.array( + [1, 2, 3, 1, 2, 3]), np.ones((6, 1))) + + def test_can_use_statsmodel_inference(self): + """ + TODO Almost identical to DML test, so consider merging + Test that we can use statsmodels to generate confidence intervals + """ + dml = LinearDRLearner(model_regression=LinearRegression(), + model_propensity=LogisticRegression(C=1000, solver='lbfgs', multi_class='auto')) + dml.fit(np.array([2, 3, 1, 3, 2, 1, 1, 1]), np.array( + [3, 2, 1, 2, 3, 1, 1, 1]), np.ones((8, 1)), inference='statsmodels') + interval = dml.effect_interval(np.ones((9, 1)), + T0=np.array( + [1, 1, 1, 1, 1, 1, 1, 1, 1]), + T1=np.array( + [2, 2, 3, 2, 2, 3, 2, 2, 3]), + alpha=0.05) + point = dml.effect(np.ones((9, 1)), + T0=np.array([1, 1, 1, 1, 1, 1, 1, 1, 1]), + T1=np.array([2, 2, 3, 2, 2, 3, 2, 2, 3])) + assert len(interval) == 2 + lo, hi = interval + assert lo.shape == hi.shape == point.shape + assert (lo <= point).all() + assert (point <= hi).all() + # for at least some of the examples, the CI should have nonzero width + assert (lo < hi).any() + + interval = dml.const_marginal_effect_interval( + np.ones((9, 1)), alpha=0.05) + point = dml.const_marginal_effect(np.ones((9, 1))) + assert len(interval) == 2 + lo, hi = interval + assert lo.shape == hi.shape == point.shape + assert (lo <= point).all() + assert (point <= hi).all() + # for at least some of the examples, the CI should have nonzero width + assert (lo < hi).any() + + interval = dml.coef__interval(T=2, alpha=0.05) + point = dml.coef_(T=2) + assert len(interval) == 2 + lo, hi = interval + assert lo.shape == hi.shape == point.shape + assert (lo <= point).all() + assert (point <= hi).all() + # for at least some of the examples, the CI should have nonzero width + assert (lo < hi).any() + + def test_drlearner_all_attributes(self): + from sklearn.ensemble import GradientBoostingClassifier, GradientBoostingRegressor, RandomForestRegressor + from sklearn.linear_model import LinearRegression, LogisticRegression + from econml.utilities import StatsModelsLinearRegression + import scipy.special + np.random.seed(123) + controls = np.random.uniform(-1, 1, size=(5000, 3)) + T = np.random.binomial(2, scipy.special.expit(controls[:, 0])) + sigma = 0.01 + y = (1 + .5 * controls[:, 0]) * T + controls[:, + 0] + np.random.normal(0, sigma, size=(5000,)) + for X in [controls]: + for W in [None, controls]: + for sample_weight in [None, 1 + np.random.randint(10, size=X.shape[0])]: + for sample_var in [None, 1 + np.random.randint(10, size=X.shape[0])]: + for featurizer in [None, PolynomialFeatures(degree=2, include_bias=False)]: + for models in [(GradientBoostingClassifier(), GradientBoostingRegressor(), + RandomForestRegressor(n_estimators=100, + max_depth=5, min_samples_leaf=50)), + (GradientBoostingClassifier(), GradientBoostingRegressor(), + RandomForestRegressor(n_estimators=100, + max_depth=5, min_samples_leaf=50)), + (LogisticRegression(solver='lbfgs', multi_class='auto'), + LinearRegression(), StatsModelsLinearRegression())]: + for multitask_model_final in [False, True]: + if (not isinstance(models, StatsModelsLinearRegression))\ + and (sample_var is not None): + continue + with self.subTest(X=X, W=W, sample_weight=sample_weight, sample_var=sample_var, + featurizer=featurizer, models=models, + multitask_model_final=multitask_model_final): + est = DRLearner(model_propensity=models[0], + model_regression=models[1], + model_final=models[2], + featurizer=featurizer, + multitask_model_final=multitask_model_final) + if (X is None) and (W is None): + with pytest.raises(AttributeError) as e_info: + est.fit(y, T, X=X, W=W, + sample_weight=sample_weight, sample_var=sample_var) + continue + est.fit( + y, T, X=X, W=W, sample_weight=sample_weight, sample_var=sample_var) + np.testing.assert_allclose(est.effect(X[:3], T0=0, T1=1), 1 + .5 * X[:3, 0], + rtol=0, atol=.15) + np.testing.assert_allclose(est.const_marginal_effect(X[:3]), + np.hstack( + [1 + .5 * X[:3, [0]], + 2 * (1 + .5 * X[:3, [0]])]), + rtol=0, atol=.15) + for t in [1, 2]: + np.testing.assert_allclose(est.marginal_effect(t, X[:3]), + np.hstack([1 + .5 * X[:3, [0]], + 2 * (1 + .5 * X[:3, [0]])]), + rtol=0, atol=.15) + assert isinstance(est.score_, float) + assert isinstance( + est.score(y, T, X=X, W=W), float) + + feat_names = ['A', 'B', 'C'] + out_feat_names = feat_names + if featurizer is not None: + out_feat_names = featurizer.fit( + X).get_feature_names(feat_names) + np.testing.assert_array_equal( + est.featurizer.n_input_features_, 3) + np.testing.assert_array_equal(est.cate_feature_names(feat_names), + out_feat_names) + + if isinstance(models[0], GradientBoostingClassifier): + np.testing.assert_array_equal(np.array([mdl.feature_importances_ + for mdl + in est.models_regression]).shape, + [2, 2 + X.shape[1] + + (W.shape[1] if W is not None else 0)]) + np.testing.assert_array_equal(np.array([mdl.feature_importances_ + for mdl + in est.models_propensity]).shape, + [2, X.shape[1] + + (W.shape[1] if W is not None else 0)]) + else: + np.testing.assert_array_equal(np.array([mdl.coef_ + for mdl + in est.models_regression]).shape, + [2, 2 + X.shape[1] + + (W.shape[1] if W is not None else 0)]) + np.testing.assert_array_equal(np.array([mdl.coef_ + for mdl + in est.models_propensity]).shape, + [2, 3, X.shape[1] + + (W.shape[1] if W is not None else 0)]) + if multitask_model_final: + if isinstance(models[2], RandomForestRegressor): + np.testing.assert_equal(np.argsort( + est.multitask_model_cate.feature_importances_)[-1], 0) + else: + true_coef = np.zeros( + (2, len(out_feat_names))) + true_coef[:, 0] = [.5, 1] + np.testing.assert_allclose( + est.multitask_model_cate.coef_, true_coef, rtol=0, atol=.15) + np.testing.assert_allclose( + est.multitask_model_cate.intercept_, [1, 2], rtol=0, atol=.15) + else: + for t in [1, 2]: + if isinstance(models[2], RandomForestRegressor): + np.testing.assert_equal(np.argsort( + est.model_cate(T=t).feature_importances_)[-1], 0) + else: + true_coef = np.zeros( + len(out_feat_names)) + true_coef[0] = .5 * t + np.testing.assert_allclose( + est.model_cate(T=t).coef_, true_coef, rtol=0, atol=.15) + np.testing.assert_allclose( + est.model_cate(T=t).intercept_, t, rtol=0, atol=.15) + + def test_drlearner_with_inference_all_attributes(self): + np.random.seed(123) + controls = np.random.uniform(-1, 1, size=(10000, 2)) + T = np.random.binomial(2, scipy.special.expit(controls[:, 0])) + sigma = 0.01 + y = (1 + .5 * controls[:, 0]) * T + controls[:, + 0] + np.random.normal(0, sigma, size=(10000,)) + for X in [None, controls]: + for W in [None, controls]: + for sample_weight, sample_var in [(None, None), (np.ones(T.shape[0]), np.zeros(T.shape[0]))]: + for featurizer in [None, PolynomialFeatures(degree=2, include_bias=False)]: + for models in [(GradientBoostingClassifier(), GradientBoostingRegressor()), + (LogisticRegression(solver='lbfgs', multi_class='auto'), + LinearRegression())]: + for est_class,\ + inference in [(ForestDRLearner, 'blb'), + (LinearDRLearner, 'statsmodels'), + (LinearDRLearner, StatsModelsInferenceDiscrete( + cov_type='nonrobust')), + (SparseLinearDRLearner, 'debiasedlasso')]: + with self.subTest(X=X, W=W, sample_weight=sample_weight, sample_var=sample_var, + featurizer=featurizer, models=models, + est_class=est_class, inference=inference): + if (X is None) and (est_class == SparseLinearDRLearner): + continue + if (X is None) and (est_class == ForestDRLearner): + continue + if (featurizer is not None) and (est_class == ForestDRLearner): + continue + + if est_class == ForestDRLearner: + est = est_class(model_propensity=models[0], + model_regression=models[1]) + else: + est = est_class(model_propensity=models[0], + model_regression=models[1], + featurizer=featurizer) + + if (X is None) and (W is None): + with pytest.raises(AttributeError) as e_info: + est.fit( + y, T, X=X, W=W, sample_weight=sample_weight, sample_var=sample_var) + continue + est.fit(y, T, X=X, W=W, sample_weight=sample_weight, + sample_var=sample_var, inference=inference) + if X is not None: + lower, upper = est.effect_interval( + X[:3], T0=0, T1=1) + point = est.effect(X[:3], T0=0, T1=1) + truth = 1 + .5 * X[:3, 0] + TestDRLearner._check_with_interval( + truth, point, lower, upper) + lower, upper = est.const_marginal_effect_interval( + X[:3]) + point = est.const_marginal_effect( + X[:3]) + truth = np.hstack( + [1 + .5 * X[:3, [0]], 2 * (1 + .5 * X[:3, [0]])]) + TestDRLearner._check_with_interval( + truth, point, lower, upper) + else: + lower, upper = est.effect_interval( + T0=0, T1=1) + point = est.effect(T0=0, T1=1) + truth = np.array([1]) + TestDRLearner._check_with_interval( + truth, point, lower, upper) + lower, upper = est.const_marginal_effect_interval() + point = est.const_marginal_effect() + truth = np.array([[1, 2]]) + TestDRLearner._check_with_interval( + truth, point, lower, upper) + + for t in [1, 2]: + if X is not None: + lower, upper = est.marginal_effect_interval( + t, X[:3]) + point = est.marginal_effect( + t, X[:3]) + truth = np.hstack( + [1 + .5 * X[:3, [0]], 2 * (1 + .5 * X[:3, [0]])]) + TestDRLearner._check_with_interval( + truth, point, lower, upper) + else: + lower, upper = est.marginal_effect_interval( + t) + point = est.marginal_effect(t) + truth = np.array([[1, 2]]) + TestDRLearner._check_with_interval( + truth, point, lower, upper) + assert isinstance(est.score_, float) + assert isinstance( + est.score(y, T, X=X, W=W), float) + + if X is not None: + feat_names = ['A', 'B'] + else: + feat_names = [] + out_feat_names = feat_names + if X is not None: + if (featurizer is not None): + out_feat_names = featurizer.fit( + X).get_feature_names(feat_names) + np.testing.assert_array_equal( + est.featurizer.n_input_features_, 2) + np.testing.assert_array_equal(est.cate_feature_names(feat_names), + out_feat_names) + + if isinstance(models[0], GradientBoostingClassifier): + np.testing.assert_array_equal(np.array([mdl.feature_importances_ + for mdl + in est.models_regression]).shape, + [2, 2 + len(feat_names) + + (W.shape[1] if W is not None else 0)]) + np.testing.assert_array_equal(np.array([mdl.feature_importances_ + for mdl + in est.models_propensity]).shape, + [2, len(feat_names) + + (W.shape[1] if W is not None else 0)]) + else: + np.testing.assert_array_equal(np.array([mdl.coef_ + for mdl + in est.models_regression]).shape, + [2, 2 + len(feat_names) + + (W.shape[1] if W is not None else 0)]) + np.testing.assert_array_equal(np.array([mdl.coef_ + for mdl + in est.models_propensity]).shape, + [2, 3, len(feat_names) + + (W.shape[1] if W is not None else 0)]) + + if isinstance(est, LinearDRLearner) or isinstance(est, SparseLinearDRLearner): + if X is not None: + for t in [1, 2]: + true_coef = np.zeros( + len(out_feat_names)) + true_coef[0] = .5 * t + lower, upper = est.model_cate( + T=t).coef__interval() + point = est.model_cate( + T=t).coef_ + truth = true_coef + TestDRLearner._check_with_interval( + truth, point, lower, upper) + + lower, upper = est.coef__interval( + t) + point = est.coef_(t) + truth = true_coef + TestDRLearner._check_with_interval( + truth, point, lower, upper) + # test coef__inference function works + est.coef__inference( + t).summary_frame() + np.testing.assert_array_almost_equal( + est.coef__inference(t).conf_int()[0], lower, decimal=5) + for t in [1, 2]: + lower, upper = est.model_cate( + T=t).intercept__interval() + point = est.model_cate( + T=t).intercept_ + truth = t + TestDRLearner._check_with_interval( + truth, point, lower, upper) + + lower, upper = est.intercept__interval( + t) + point = est.intercept_(t) + truth = t + TestDRLearner._check_with_interval( + truth, point, lower, upper) + # test intercept__inference function works + est.intercept__inference( + t).summary_frame() + np.testing.assert_array_almost_equal( + est.intercept__inference(t).conf_int()[0], lower, decimal=5) + # test summary function works + est.summary(t) + + @staticmethod + def _check_with_interval(truth, point, lower, upper): + np.testing.assert_allclose(point, truth, rtol=0, atol=.2) + np.testing.assert_array_less(lower - 0.05, truth) + np.testing.assert_array_less(truth, upper + 0.05) + + def test_DRLearner(self): + """Tests whether the DRLearner can accurately estimate constant and + heterogeneous treatment effects. + """ + DR_learner = DRLearner(model_regression=LinearRegression(), + model_final=LinearRegression()) + # Test inputs + # self._test_inputs(DR_learner) + # Test constant treatment effect + self._test_te(DR_learner, tol=0.5, te_type="const") + # Test heterogeneous treatment effect + outcome_model = Pipeline( + [('poly', PolynomialFeatures()), ('model', LinearRegression())]) + DR_learner = DRLearner(model_regression=outcome_model, + model_final=LinearRegression()) + self._test_te(DR_learner, tol=0.5, te_type="heterogeneous") + # Test heterogenous treatment effect for W =/= None + self._test_with_W(DR_learner, tol=0.5) + + def test_sparse(self): + """SparseDRLearner test with a sparse DGP""" + # Sparse DGP + np.random.seed(123) + n_x = 50 + n_nonzero = 1 + n_w = 5 + n = 1000 + # Treatment effect coef + a = np.zeros(n_x) + nonzero_idx = np.random.choice(n_x, size=n_nonzero, replace=False) + a[nonzero_idx] = 1 + # Other coefs + b = np.zeros(n_x + n_w) + g = np.zeros(n_x + n_w) + b_nonzero = np.random.choice(n_x + n_w, size=n_nonzero, replace=False) + g_nonzero = np.random.choice(n_x + n_w, size=n_nonzero, replace=False) + b[b_nonzero] = 1 + g[g_nonzero] = 1 + # Features and controls + x = np.random.normal(size=(n, n_x)) + w = np.random.normal(size=(n, n_w)) + xw = np.hstack([x, w]) + T = np.random.binomial(1, scipy.special.expit(xw @ b)) + err_Y = np.random.normal(size=n, scale=0.5) + Y = T * (x @ a) + xw @ g + err_Y + # Test sparse estimator + # --> test coef_, intercept_ + sparse_dml = SparseLinearDRLearner(featurizer=FunctionTransformer()) + sparse_dml.fit(Y, T, x, w, inference='debiasedlasso') + np.testing.assert_allclose(a, sparse_dml.coef_(T=1), atol=2e-1) + np.testing.assert_allclose(sparse_dml.intercept_(T=1), 0, atol=2e-1) + # --> test treatment effects + # Restrict x_test to vectors of norm < 1 + x_test = np.random.uniform(size=(10, n_x)) + true_eff = (x_test @ a) + eff = sparse_dml.effect(x_test, T0=0, T1=1) + np.testing.assert_allclose(true_eff, eff, atol=0.5) + # --> check inference + y_lower, y_upper = sparse_dml.effect_interval(x_test, T0=0, T1=1) + in_CI = ((y_lower < true_eff) & (true_eff < y_upper)) + # Check that a majority of true effects lie in the 5-95% CI + self.assertTrue(in_CI.mean() > 0.8) + + def _test_te(self, learner_instance, tol, te_type="const"): + if te_type not in ["const", "heterogeneous"]: + raise ValueError( + "Type of treatment effect must be 'const' or 'heterogeneous'.") + X, T, Y = getattr( + TestDRLearner, "{te_type}_te_data".format(te_type=te_type)) + te_func = getattr( + TestDRLearner, "_{te_type}_te".format(te_type=te_type)) + # Fit learner and get the effect + learner_instance.fit(Y, T, X) + te_hat = learner_instance.effect(TestDRLearner.X_test) + # Get the true treatment effect + te = np.apply_along_axis(te_func, 1, TestDRLearner.X_test) + # Compute treatment effect residuals (absolute) + te_res = np.abs(te - te_hat) + # Check that at least 90% of predictions are within tolerance interval + self.assertGreaterEqual(np.mean(te_res < tol), 0.90) + + def _test_with_W(self, learner_instance, tol): + # Only for heterogeneous TE + X, T, Y = TestDRLearner.heterogeneous_te_data + # Fit learner on X and W and get the effect + learner_instance.fit( + Y, T, X=X[:, [TestDRLearner.heterogeneity_index]], W=X) + te_hat = learner_instance.effect( + TestDRLearner.X_test[:, [TestDRLearner.heterogeneity_index]]) + # Get the true treatment effect + te = np.apply_along_axis( + TestDRLearner._heterogeneous_te, 1, TestDRLearner.X_test) + # Compute treatment effect residuals (absolute) + te_res = np.abs(te - te_hat) + # Check that at least 90% of predictions are within tolerance interval + self.assertGreaterEqual(np.mean(te_res < tol), 0.90) + + def _test_inputs(self, learner_instance): + X, T, Y = TestDRLearner.const_te_data + # Check that one can pass in regular lists + learner_instance.fit(list(Y), list(T), list(X)) + learner_instance.effect(list(TestDRLearner.X_test)) + # Check that it fails correctly if lists of different shape are passed in + self.assertRaises(ValueError, learner_instance.fit, + Y, T, X[:TestDRLearner.n // 2]) + self.assertRaises(ValueError, learner_instance.fit, + Y[:TestDRLearner.n // 2], T, X) + # Check that it fails when T contains values other than 0 and 1 + self.assertRaises(ValueError, learner_instance.fit, Y, T + 1, X) + # Check that it works when T, Y have shape (n, 1) + self.assertWarns(DataConversionWarning, + learner_instance.fit, Y.reshape(-1, + 1), T.reshape(-1, 1), X + ) + + @classmethod + def _untreated_outcome(cls, x): + return np.dot(x, cls.beta) + cls.random_state.normal(0, 1) + + @classmethod + def _const_te(cls, x): + return 2 + + @classmethod + def _heterogeneous_te(cls, x): + return x[cls.heterogeneity_index] + + @classmethod + def _generate_data(cls, n, d, untreated_outcome, treatment_effect, propensity): + """Generates population data for given untreated_outcome, treatment_effect and propensity functions. + + Parameters + ---------- + n (int): population size + d (int): number of covariates + untreated_outcome (func): untreated outcome conditional on covariates + treatment_effect (func): treatment effect conditional on covariates + propensity (func): probability of treatment conditional on covariates + """ + # Generate covariates + X = cls.random_state.multivariate_normal( + np.zeros(d), np.diag(np.ones(d)), n) + # Generate treatment + T = np.apply_along_axis( + lambda x: cls.random_state.binomial(1, propensity(x), 1)[0], 1, X) + # Calculate outcome + Y0 = np.apply_along_axis(lambda x: untreated_outcome(x), 1, X) + treat_effect = np.apply_along_axis(lambda x: treatment_effect(x), 1, X) + Y = Y0 + treat_effect * T + return (X, T, Y) diff --git a/econml/utilities.py b/econml/utilities.py index 87704ba50..640db1216 100644 --- a/econml/utilities.py +++ b/econml/utilities.py @@ -21,6 +21,10 @@ from collections.abc import Iterable from sklearn.utils.multiclass import type_of_target import numbers +from statsmodels.iolib.table import SimpleTable +from statsmodels.iolib.summary import summary_return +from statsmodels.compat.python import lmap +import copy MAX_RAND_SEED = np.iinfo(np.int32).max @@ -844,12 +848,14 @@ def predict(self, Xt): def _safe_norm_ppf(q, loc=0, scale=1): - prelim = loc.copy() - if hasattr(prelim, "__len__"): + if hasattr(loc, "__len__"): + prelim = loc.copy() if np.any(scale > 0): prelim[scale > 0] = scipy.stats.norm.ppf(q, loc=loc[scale > 0], scale=scale[scale > 0]) elif scale > 0: prelim = scipy.stats.norm.ppf(q, loc=loc, scale=scale) + else: + prelim = loc return prelim @@ -1224,3 +1230,113 @@ def fit(self, X, Y): def predict(self, X): predictions = self.model.predict(X) return reshape(predictions, (-1, 1)) if self.needs_unravel else predictions + + +class Summary: + # This class is mainly derived from statsmodels.iolib.summary.Summary + """ + Result summary + + Construction does not take any parameters. Tables and text can be added + with the `add_` methods. + + Attributes + ---------- + tables : list of tables + Contains the list of SimpleTable instances, horizontally concatenated + tables are not saved separately. + extra_txt : str + extra lines that are added to the text output, used for warnings + and explanations. + """ + + def __init__(self): + self.tables = [] + self.extra_txt = None + + def __str__(self): + return self.as_text() + + def __repr__(self): + return str(type(self)) + '\n"""\n' + self.__str__() + '\n"""' + + def _repr_html_(self): + '''Display as HTML in IPython notebook.''' + return self.as_html() + + def add_table(self, res, header, index, title): + table = SimpleTable(res, header, index, title) + self.tables.append(table) + + def add_extra_txt(self, etext): + '''add additional text that will be added at the end in text format + + Parameters + ---------- + etext : list[str] + string with lines that are added to the text output. + + ''' + self.extra_txt = '\n'.join(etext) + + def as_text(self): + '''return tables as string + + Returns + ------- + txt : str + summary tables and extra text as one string + + ''' + txt = summary_return(self.tables, return_fmt='text') + if self.extra_txt is not None: + txt = txt + '\n\n' + self.extra_txt + return txt + + def as_latex(self): + '''return tables as string + + Returns + ------- + latex : str + summary tables and extra text as string of Latex + + Notes + ----- + This currently merges tables with different number of columns. + It is recommended to use `as_latex_tabular` directly on the individual + tables. + + ''' + latex = summary_return(self.tables, return_fmt='latex') + if self.extra_txt is not None: + latex = latex + '\n\n' + self.extra_txt.replace('\n', ' \\newline\n ') + return latex + + def as_csv(self): + '''return tables as string + + Returns + ------- + csv : str + concatenated summary tables in comma delimited format + + ''' + csv = summary_return(self.tables, return_fmt='csv') + if self.extra_txt is not None: + csv = csv + '\n\n' + self.extra_txt + return csv + + def as_html(self): + '''return tables as string + + Returns + ------- + html : str + concatenated summary tables in HTML format + + ''' + html = summary_return(self.tables, return_fmt='html') + if self.extra_txt is not None: + html = html + '

' + self.extra_txt.replace('\n', '
') + return html diff --git a/notebooks/Double Machine Learning Examples.ipynb b/notebooks/Double Machine Learning Examples.ipynb index 2611f2991..cf9046d8f 100644 --- a/notebooks/Double Machine Learning Examples.ipynb +++ b/notebooks/Double Machine Learning Examples.ipynb @@ -42,7 +42,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -62,7 +62,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -113,7 +113,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -124,7 +124,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -173,7 +173,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -193,7 +193,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -214,7 +214,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -236,7 +236,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -265,12 +265,12 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -306,19 +306,19 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'DML default': 3.1627949174866945,\n", - " 'DML polynomial degree=2': 2.5474269412280446,\n", - " 'DML polynomial degree=10 with Lasso': 3.2675102573467165,\n", - " 'ForestDML': 3.9378482922121463}" + "{'DML default': 1.8232573949078739,\n", + " 'DML polynomial degree=2': 1.7052571853668774,\n", + " 'DML polynomial degree=10 with Lasso': 2.1530239340849437,\n", + " 'ForestDML': 1.7657955605139215}" ] }, - "execution_count": 36, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -334,7 +334,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -351,19 +351,19 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'DML default': 0.1921791643128576,\n", - " 'DML polynomial degree=2': 0.030107565825366556,\n", - " 'DML polynomial degree=10 with Lasso': 0.270549915512218,\n", - " 'ForestDML': 0.13621133188807513}" + "{'DML default': 0.35920075038929977,\n", + " 'DML polynomial degree=2': 0.21518984313847153,\n", + " 'DML polynomial degree=10 with Lasso': 0.195600010017266,\n", + " 'ForestDML': 0.13690181421352374}" ] }, - "execution_count": 38, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -379,14 +379,14 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "best model selected by MSE of TE: DML polynomial degree=2\n" + "best model selected by MSE of TE: ForestDML\n" ] } ], @@ -425,7 +425,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -473,7 +473,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -489,7 +489,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -506,7 +506,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -533,12 +533,12 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -576,6 +576,450 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.4. Other Inferences\n", + "#### 2.4.1 Effect Inferences\n", + "Other than confidence interval, we could also output other statistical inferences of the effect include standard error, z-test score and p value given each sample $X[i]$." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
point_estimatestderrzstatpvalueci_lowerci_upper
00.3810.1462.6050.0090.1400.621
10.4090.1632.5120.0120.1410.677
20.3080.1701.8110.0700.0280.588
30.4160.1502.7800.0050.1700.662
40.5620.1523.7000.0000.3120.811
50.5380.1393.8790.0000.3100.766
60.4360.1243.5310.0000.2330.639
70.5890.1543.8250.0000.3360.842
80.4460.1263.5300.0000.2380.653
90.4870.1623.0110.0030.2210.753
\n", + "
" + ], + "text/plain": [ + " point_estimate stderr zstat pvalue ci_lower ci_upper\n", + "0 0.381 0.146 2.605 0.009 0.140 0.621\n", + "1 0.409 0.163 2.512 0.012 0.141 0.677\n", + "2 0.308 0.170 1.811 0.070 0.028 0.588\n", + "3 0.416 0.150 2.780 0.005 0.170 0.662\n", + "4 0.562 0.152 3.700 0.000 0.312 0.811\n", + "5 0.538 0.139 3.879 0.000 0.310 0.766\n", + "6 0.436 0.124 3.531 0.000 0.233 0.639\n", + "7 0.589 0.154 3.825 0.000 0.336 0.842\n", + "8 0.446 0.126 3.530 0.000 0.238 0.653\n", + "9 0.487 0.162 3.011 0.003 0.221 0.753" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "est.effect_inference(X_test[:10,]).summary_frame(alpha=0.1, value=0, decimals=3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We could also get the population inferences given sample $X$." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Uncertainty of Mean Point Estimate
mean_point stderr_mean zstat pvalue ci_mean_lower ci_mean_upper
3.369 0.14 24.056 0.0 3.138 3.599
\n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Distribution of Point Estimate
std_point pct_point_lower pct_point_upper
1.724 0.691 6.067
\n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Total Variance of Point Estimate
stderr_point ci_point_lower ci_point_upper
1.73 0.682 6.065


Note: The stderr_mean is a conservative upper bound." + ], + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "est.effect_inference(X_test).population_summary(alpha=0.1, value=0, decimals=3, tol=0.001)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.4.2 Coefficient and Intercept Inferences\n", + "We could also get the coefficient and intercept inference for the final model when it's linear." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
point_estimatestderrzstatpvalueci_lowerci_upper
X05.9580.22726.2110.0005.5846.332
X1-0.0580.216-0.2670.789-0.4130.297
X2-0.3260.218-1.4910.136-0.6850.034
X30.2170.2111.0290.304-0.1300.564
\n", + "
" + ], + "text/plain": [ + " point_estimate stderr zstat pvalue ci_lower ci_upper\n", + "X0 5.958 0.227 26.211 0.000 5.584 6.332\n", + "X1 -0.058 0.216 -0.267 0.789 -0.413 0.297\n", + "X2 -0.326 0.218 -1.491 0.136 -0.685 0.034\n", + "X3 0.217 0.211 1.029 0.304 -0.130 0.564" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "est.coef__inference().summary_frame()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
point_estimatestderrzstatpvalueci_lowerci_upper
intercept0.470.2182.1540.0310.1110.829
\n", + "
" + ], + "text/plain": [ + " point_estimate stderr zstat pvalue ci_lower ci_upper\n", + "intercept 0.47 0.218 2.154 0.031 0.111 0.829" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "est.intercept__inference().summary_frame()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Coefficient Results
point_estimate stderr zstat pvalue ci_lower ci_upper
X0 5.958 0.227 26.211 0.0 5.584 6.332
X1 -0.058 0.216 -0.267 0.789 -0.413 0.297
X2 -0.326 0.218 -1.491 0.136 -0.685 0.034
X3 0.217 0.211 1.029 0.304 -0.13 0.564
\n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Intercept Results
point_estimate stderr zstat pvalue ci_lower ci_upper
intercept 0.47 0.218 2.154 0.031 0.111 0.829
" + ], + "text/plain": [ + "\n", + "\"\"\"\n", + " Coefficient Results \n", + "========================================================\n", + " point_estimate stderr zstat pvalue ci_lower ci_upper\n", + "--------------------------------------------------------\n", + "X0 5.958 0.227 26.211 0.0 5.584 6.332\n", + "X1 -0.058 0.216 -0.267 0.789 -0.413 0.297\n", + "X2 -0.326 0.218 -1.491 0.136 -0.685 0.034\n", + "X3 0.217 0.211 1.029 0.304 -0.13 0.564\n", + " Intercept Results \n", + "==============================================================\n", + " point_estimate stderr zstat pvalue ci_lower ci_upper\n", + "--------------------------------------------------------------\n", + "intercept 0.47 0.218 2.154 0.031 0.111 0.829\n", + "--------------------------------------------------------------\n", + "\"\"\"" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "est.summary()" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -608,7 +1052,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -649,7 +1093,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -667,16 +1111,16 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 22, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -688,7 +1132,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ @@ -697,7 +1141,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -713,12 +1157,12 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 30, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -769,7 +1213,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ @@ -782,7 +1226,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -797,7 +1241,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -968,7 +1412,7 @@ "4 0.376927 " ] }, - "execution_count": 27, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -979,7 +1423,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -995,7 +1439,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ @@ -1015,7 +1459,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ @@ -1033,12 +1477,12 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 37, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1071,7 +1515,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 38, "metadata": {}, "outputs": [], "source": [ @@ -1082,12 +1526,12 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 39, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmkAAAGDCAYAAABwRoerAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeXzcZ3X3/c+lfZ2RZUmWJe+2vMpJCG5ICElIEyAJBApNl5SlWWia5y6Fp0CbhtAWWqBQQiEt99OwpuUmUNLQwAOklKSQQoEAduJE8r7EsjWjfZlFy2iWc//xGzmyI9kjWaPR8n2/XnpJM/Ob3+/MSLaOznVd53JmhoiIiIjML3m5DkBEREREXkpJmoiIiMg8pCRNREREZB5SkiYiIiIyDylJExEREZmHlKSJiIiIzENK0kRkXnDOXeWcOzTH1/xn59xHsnDeB51zf5HBcf/hnPv92b6+iCwOStJE5jnn3G3OuRbn3LBzrtM590/Ouapcx5WJdOz/k8mxZvYTM9syy9df55wz51z0rI/fmcVrvOQ1mtndZvY353uumd1oZv8y1XnmmnPu1c659lzGICIvUpImMo85594HfAL4U8APXA6sBZ5wzhVN8ZyCuYtwwagys4oJH9/IdUAiIuejJE1knnLO+YAPA39sZt83s7iZnQB+Gy9Re1v6uA855x51zn3VORcGbnPOXeac+7lzbtA51+Gc++zEpC5dXbrbOXfEOTfgnPvfzjmXfizfOfcp51yvc+4F59y70scXpB/3O+e+lD5vwDn3EedcfoavyZxzmybcPj3ceHYVxzm32jn37865Hudcn3PusxMeu8M5dyAd+38659bO+I1+8ZzLnHPfTV9vIP31qgmP3+acO+6ci6Tfl7c657YBDwJXpCt0g2e/rvTtNznn9jrnws65Y865G9L3P+Wce+dk53HO/Zpzrmti0u2c+03n3N5JYr88XWXNn3Dfm51zz6e/vsw5tzt9/S7n3N9n+J485Zz7G+fcT9Ov+wfOuZoJj7/KOfezdLynnHO3pe/3O+e+kn4v25xzH3TO5U14H3/qnPt0+nnHnXOvTN9/yjnX7SYMATvnip1z9zvnTqZjf9A5V5pJ/CILnZI0kfnrlUAJ8O8T7zSzKPAfwGsm3P0m4FGgCngYSAJ/AtQAVwDXAf/rrPO/Afg14GK8xO916fv/ALgRuAS4FPiNs573L0AC2AS8DHgt8M6ZvcTJpZON7wJtwDqgEfjX9GO/AXwAeAtQC/wE+PosXDYPeAgvAV4DjACfTV+zHPgH4EYzq8T73uw1swPA3cDP0xW6lwxDO+cuA76CVw2tAq4GTkw8ZrLzmNmvgD7O/D6/Dfg/Z1/DzJ4GhoBfn3D37wFfS3/9APCAmfmAjcAjGb4n4+e5HagDioD3p1/XGryfw3/E+z5cAownkP+IV/ndAFwDvCN9jnGvAJ4Hlqdj/Fe8n8VN6df4WedcRfrYTwCb0+ffhPez8JfTiF9kwVKSJjJ/1QC9ZpaY5LGO9OPjfm5m3zKzlJmNmNkeM3vazBLp6tvn8H5ZTvRxMxs0s5PAj/B+CYKXsD1gZu1mNgB8fPwJzrkVeAnc/2tmQ2bWDXwa+N1ZeL0TXQY0AH+avs6omY3P1/pD4G/N7ED6vfkYcMl5qmm96arN+Me2sw8wsz4z+6aZDZtZBPgoZ75nKaDZOVdqZh1mti/D13In8GUzeyL9/QmY2cEMn/svvFgxrcZLpL82xbFfB25NH1sJ3MSLyWsc2OScqzGzaDqpy9RDZnbYzEbwkrvxn5O3Ak+a2dfTVd4+M9ubTrB/B7jXzCLpn79PAW+fcM4XzOwhM0sC3wBWA39tZjEz+wEwlo7X4f3R8Cdm1p/+vnyM2f95E5mXlKSJzF+9QI2bfI7ZyvTj405NfNA5tzk9XNfpvCHQj3FmUgfQOeHrYWC8ctFw1vkmfr0WKAQ6xhMevASwLsPXlKnVQNsUCepa4IEJ1+8HHF6FZSo16erU+MeBsw9wzpU55z6XHp4LAz8Gqpxz+WY2hJd43I332r/nnNs6jddyLMNjz/ZV4OZ0Vem3gZ+YWccUx34NeItzrhivyviMmbWlH7sTrxp10Dn3K+fcG6YRw1Q/J1O9rhq8ilvbhPvaOPP70zXh6xEAMzv7vgq8Cl0ZsGfC9/v76ftFFj0laSLz18+BGN4v3NPSQ283Av814W4767n/BBwEmtJDXB/AS2Qy0QGsmnB79YSvT6Vjmpj0+MxsR4bnHsb7pTuuforjTgFrpkhQTwF/eFbSVWpmP8swhqm8D9gCvCL9nl2dvt8BmNl/mtlr8BLkg8AX0o+f/d5PFu/GDK7/kvOYWQDv5+DNeJWolwx1Tjh2P14ydCNnDnViZkfM7Fa8ZPoTwKPpn6MLMdXr6sWr3E2sbK4BAjO4Ri9ewrZjwvfab2YV53uiyGKgJE1knjKzEN7CgX90zt3gnCt0zq0D/g1o5xy/sIFKIAxE0xWf/2cal34EeI9zrtF5rT7umRBTB/AD4FPOOZ9zLs85t9E5d/ZQ6lT2Ar/nvMUJN/DSIdhxv8RLFj/unCt3zpU4565MP/YgcK9zbgecnqT+W9N4fVOpxEsIBtNDi381/oBzboVz7o3pxCYGRPHm/YFXFVrlplhtC3wJuN05d136/Wqcogo31Xm+AvwZsBN47Dyv4WvAu/ESzH+bEP/bnHO1ZpYCBtN3Jyd5/nQ8DFzvnPtt51yBc265c+6S9BDmI8BHnXOV6WHo9+JVBaclHe8XgE875+rSr6XROfe6cz9TZHFQkiYyj5nZ3+FVwe7HS7p+gVfBuM7MYud46vvxqikRvF9y02k58QW8ROx54FngcbyFAuO/1N+BN5y1HxjAW7Cw8lwvY8LX7wFuxksU3gp8a9IneL/ob8abKH4SLyn9nfRjj+FVg/41PSzZilc9OpdBd2aftPdOcsxngFK86s3TeMNq4/LwKm1BvOHVa3hxIcYPgX1Ap3Nu4hD0+Gv5Jd6k+U8DIeC/ObPKNG6q8zyWPv6x9LDruXwdeDXwQzObeI4bgH3OuSjeIoLfNbPR85zrnNJzGW/Ce1/68RLwi9MP/zHeQobjwP/gJY9fnuGl7gGOAk+nv99P4lU8RRY9Z3a+Sr2ILGXOuRuBB81s2m0unHPvBn7dzM5eISrT4Jw7hjfE+2SuYxGRuaNKmoicwTlX6py7KT2E1Yg37He+YbbJzlOC1xpk92zHuJQ4534Trxr5w1zHIiJzS0maiJzN4c2FG8Ab7jzANPtSOed24q0KDJPuNSbT55x7Cm8RyB+l52eJyBKi4U4RERGReUiVNBEREZF5KCdJmnPuk865g865551zj6WX+U91bL5z7lnn3HfnMkYRERGRXMrJcKdz7rV4S8QTzrlPAJjZPVMc+15gF+Azs4y6ZNfU1Ni6detmK1wRERGRrNmzZ0+vmb1kJ43JunlnXXpvtnFPA7dMdpxzbhXwerw99CbrazSpdevWsXu3FpSJiIjI/Oeca5vs/vkwJ+0O4D+meOwzeJ22z7uqyTl3l3Nut3Nud09Pz2zGJyIiIjLnspakOeeedM61TvLxpgnH3IfXyfzhSZ7/BqDbzPZkcj0z+7yZ7TKzXbW12ntXREREFrasDXea2fXnetw59/vAG/C2t5lsYtyVwBudczcBJYDPOfdVM3vb7EcrIiIiMr/kZE5aemPle4BrzGx4smPM7F7g3vTxrwberwRNRETkwsTjcdrb2xkdvaDtW2UGSkpKWLVqFYWFhRkdn5MkDa8DeTHwhHMO4Gkzu9s51wB80cxuylFcIiIii1p7ezuVlZWsW7eO9O9gmQNmRl9fH+3t7axfvz6j5+RqdeemKe4PAi9J0MzsKeCp7EYlIiKy+I2OjipBywHnHMuXL2c6ixvnw+pOERERmUNK0HJjuu+7kjQRERGZU+3t7bzpTW+iqamJjRs38p73vIexsTEAnnrqKd7whpf2rn/qqafw+/1ccsklpz+efPJJACoqKmYUx2c+8xmGh1+cGn/TTTcxODg45fEPPvggX/nKVwD453/+Z4LB4IyumyklaSIiIjJnzIy3vOUt/MZv/AZHjhzh8OHDRKNR7rvvvvM+96qrrmLv3r2nP66//pyNJM7r7CTt8ccfp6pqyp0qufvuu3nHO94BKEkTERGRReaHP/whJSUl3H777QDk5+fz6U9/mi9/+ctnJEwzEY1Gue6667j00kvZuXMn3/72twEYGhri9a9/PRdffDHNzc184xvf4B/+4R8IBoNce+21XHvttYC3Y1Fvby8AX/nKV7jooou4+OKLefvb3w7Ahz70Ie6//34effRRdu/ezVvf+lYuueQSvve97/HmN7/5dBxPPPEEb3nLWy7otUDuVneKiIhIjn34O/vYHwzP6jm3N/j4q5t3TPn4vn37ePnLX37GfT6fjzVr1nD06NFznvsnP/kJl1xyyenb3/zmN9m4cePp2yUlJTz22GP4fD56e3u5/PLLeeMb38j3v/99Ghoa+N73vgdAKBTC7/fz93//9/zoRz+ipqbmJTF+9KMf5ac//Sk1NTX09/ef8fgtt9zCZz/7We6//3527dqFmfG+972Pnp4eamtreeihh04noRdClTQRERGZM2Y26QT6qe6f6OzhzokJ2vg5PvCBD3DRRRdx/fXXEwgE6OrqYufOnTz55JPcc889/OQnP8Hv95/zOj/84Q+55ZZbTidv1dXV5zzeOcfb3/52vvrVrzI4OMjPf/5zbrzxxnM+JxOqpImIiCxR56p4ZcuOHTv45je/ecZ94XCYU6dOsXHjRvr6+mZ87ocffpienh727NlDYWEh69atY3R0lM2bN7Nnzx4ef/xx7r33Xl772tfyl3/5l1Oex8xIGSRTRn5eZisyb7/9dm6++WZKSkr4rd/6LQoKLjzFUiVNRERE5sx1113H8PDw6VWSyWSS973vfdx2222UlZVd0LlDoRB1dXUUFhbyox/9iLa2NgCCwSBlZWW87W1v4/3vfz/PPPMMAJWVlUQikTPOEU+k+LVXXs0jjzxCT483P+3s4c7JntvQ0EBDQwMf+chHuO222y7odYxTkiYiIiJzxjnHY489xr/927/R1NTE5s2bKSkp4WMf+xgAiUSC4uLiSZ87Pidt/OPRRx894/G3vvWt7N69m127dvHwww+zdetWAFpaWrjsssu45JJL+OhHP8oHP/hBAO666y5uvPFGrr32WsYSKVIGAyNjbNi8lfe8/x6uu+5aLr74Yt773ve+JJbbbruNu+++m0suuYSRkZHT11+9ejXbt2+fnfdq8r3NF7Zdu3bZ7t27cx2GiIjIvHPgwAG2bduW6zCm9MADDxAIBPi7v/u7ObneWCJJNJYknky95LHqsiIKCzKvZ73rXe/iZS97GXfeeeeUx0z2/jvn9pjZrrOP1Zw0ERERmRfuvPNOWltbeeSRR7J+rVgiydAUydlMvPzlL6e8vJxPfepTs3I+UJImIiIi88SXvvSlrF8jFk8yNJYgnpzdkcQ9e/bM6vlASZqIiIgscmZGLJFiKJYgkVo407yUpImIiMiitFCTs3FK0kRERGRRMTNG40mGxpIkF2ByNk5JmoiIiCwKZsZIPMlwLElyEXSvUJ80ERERmVN33HEHdXV1NDc3n/O4Bx54gObmZnbs2MFnPvOZ0/c/99xzXHHFFezcuZObb76ZUCjE8FiC7z35FLsufRnXX/NKXjh2DIDQ4CC/++abmarlWDwe5yN/9UGueFkz11z+cm649lX81xP/CUDTpg2nN1zPBVXSRERElrBPP3F4Vs/3J6/ZfN5jbrvtNt71rnfxjne8Y8pjWltb+cIXvsAvf/lLioqKuOGGG3j9619PU1MT73znO7n//vu56uqr+dznv8hff/Tj/NkH/4p/+ofP8KX/83VOtbXxz1/+PB/+6Cf4+0/+Le9+359NuS/oJz7yYbq6Onnq6T0UFxfT093Fz/7nJzN+/bNJlTQRERGZU1dfffV5Ny0/cOAAl19+OWVlZRQUFHDNNdfw2GOPAXDo0CEufcUr6Y3GeMVVr+Y7//+3ACgoLGR0ZISRkWEKCwo5cfw4ncEgr3zVVZNeY3h4mIf/5SE+9nd/f3qXg9q6FbzpLbfM4qudOSVpIiIiMu80Nzfz4x//mL6+PoaHh3n88cc5efIk0dE4W7Zt598f+xZm8J1v/TvBQDsA737vn/L+9/wRn/+nz3LHXXfzt3/zV9zzwb+a8honjh+jcdVqKn2+uXpZ06IkTUREROadbdu2cc899/Ca17yG191wA9ubdxI3x9BYkk//78/x0Bc+x2uvfiXRaJSiwiIAmi+6mMf/68f8+3f/k7YTJ6hfuRIz467b3sYf/cHt9HR35fhVTY+SNBEREcm5U6dOnd44/cEHHwTgtttv56mf/oJHv/sDKnxVrN+wCYCmzVv4xre+yw9+/DPefMtvs3b9+jPOZWZ85pMf50/+9F4+9fGP8qcf+At+83du5YsP/n9nHLduw0YC7aeIRiJz8yKnSUmaiIiI5Nzq1avZu3cve/fu5Z1/cBfhkTgHXmhnJJ6k/dRJHv/Ot3nzLb8NQE9PNwCpVIpPf/LjvOOOPzjjXN/42le5/nU3ULVsGSMjw+Tl5ZHn8hgZGT7juLKyMm59++9z3z3vY2xsDICuzg4e/cbX5+AVn59Wd4qIiMicuvXWW3nqqafo7e1l1apVfPjDH+bOO+8kkUwxNJZgNO5tev7Ot99Kf38/hYWF/O39n6Fq2TIAvvXoIzz0hc8BcNPNb+LWt724SnR4eJhHvv5VvvHYdwH4wz96N3e+/VaKCov4py//y0ti+fO/+BAf/5sPcfVlL6O4pISysjL+7AN/me23ICNuqr4hC9muXbts9+7duQ5DRERk3jlw4ADbtm3LdRhniCe9rZtiiVSuQzlDdVkRhQWzO+g42fvvnNtjZrvOPlaVNBEREcmJsYRXORubZ8nZfKEkTUREROZULJFkKJYknlRydi5K0kRERCTrzIxYunKWSC6+qVbZoCRNRERkiTGzKbdJysa1YglvzlkitbSTs+muA1ALDhERkSWkpKSEvr6+aScM02VmjIwl6BsaIzQSV4JmRl9fHyUlJRk/R5U0ERGRJWTVqlW0t7fT09OTlfObGfGkVz1b6B0keooLyM+bvYpjSUkJq1atyvh4JWkiIiJLSGFhIevP6tA/G2KJJM+3h3j25ABDseSsnz8Xbr1sDfX+zCtfs01JmoiIiMzYyFiSZ08OsLd9kFhcqzVnk5I0ERERmbZoLMGetgFaAyH1OcsSJWkiIiKSsdBwnF+d6OdAR3jJLwbINiVpIiIicl690Ri7T/RzqDNKaoEvCFgolKSJiIjIlDpDo/zyRD/He6IoN5tbStJERETkJU72DfPLE/2c6h/OdShLlpI0ERERAbweZ8d6hth9op+O0Giuw1nylKSJiIgscamUcbAzwp62fnqjY7kOR9KUpImIiCxRiWSKfcEwu9sGCI/Ecx2OnEVJmoiIyBKzGHcHWIyUpImIiCwRw2MJnj05yHPaHWBBUJImIiKyyIVG4jzTNsC+YIh4Un00FgolaSIiIotUXzTGr04McKgzoga0C5CSNBERkUWmIzTCr04MqAHtAqckTUREZJE40TvEr0700z4wkutQZBYoSRMREVnAzIwj3VF+daKf7nAs1+HILFKSJiIisgAlkin2d4TZ0zbA4LB6nC1GStJEREQWEPU4WzqUpImIiCwAQ7EEe0+px9lcCo3EqfeX5Oz6StJERETmscHhMfa0DbA/GCaR0lLNbEskUxzpjtISCPHwL9r4+b3XUZifl5NYlKSJiIjMQ93hUXa3DXCkK6oeZ3Ogf2iMlkCIAx1hYokUVWWFvP3ytSRTRmF+bmJSkiYiIjKPnOwbZndbP219w7kOZdFLpFIc7Y7SGggTGBwhz8Gm2gqaG/2sWlbK771iLSW5ytBQkiYiIpJzZsbR7ii/OjFAV3g01+EsegPDY7QGQhzoiDAST+IvLeTKjcvZ3uCjrGj+pEY5icQ590ngZmAMOAbcbmaDkxx3AogASSBhZrvmMk4REZFsSiRTHOiIsKetnwG10ciqZMo41uPNNWsfGME52FhTQXOjjzXVZTjnch3iS+QqXXwCuNfMEs65TwD3AvdMcey1ZtY7d6GJiIhk12jca6Ox95TaaGRbaCROayDEvmCYkXiSypICrtiwnB0NPsqL50/VbDI5ic7MfjDh5tPALbmIQ0REZC5FRuM8e3KQlkCIsYTaaGRLMmW80DtESyDEyf5hHLC+ppydjX7WLC8jbx5WzSYzH1LIO4BvTPGYAT9wzhnwOTP7/NyFJSIiMjv6ojF2tw1wqDNCUm00siY8EmdfMMy+YIihsSQVxQW8Yn01Oxp8VJYU5jq8actakuacexKon+Sh+8zs2+lj7gMSwMNTnOZKMws65+qAJ5xzB83sx1Nc7y7gLoA1a9ZccPwiIiIXKjA4wu4T/bzQO4S6aGRHyowT6arZifSK2HXLy/j1Rj/rlpeTl7cwqmaTyVqSZmbXn+tx59zvA28ArjOb/EfXzILpz93OuceAy4BJk7R0le3zALt27dI/BRERyQkzb4L6nrYBgoNaqZkt0dEErUFvrlk0lqC8KJ/L1nlVM1/pwquaTSZXqztvwFsocI2ZTdoIxjlXDuSZWST99WuBv57DMEVERDI2vlLzmZMD9A+N5TqcRSllxsm+YVoCIV7o86qTa6rLuGZzLetryslfwFWzyeRqTtpngWK8IUyAp83sbudcA/BFM7sJWAE8ln68APiamX0/R/GKiIhMSis1s28olmBfMExrMERkNEFpYT6XrlnGzkY//kVSNZtMrlZ3bpri/iBwU/rr48DFcxmXiIhIpsLplZqtWqmZFWbGyf5hWgNhjvdGSRmsWlbKqzbVsLG2YtFVzSYzH1Z3ioiILBjdkVGeaRvgUKf21MyG4bEE+4NhWoNhQiNxSgrzuGR1Fc2NfpaVFeU6vDmlJE1ERCQDbX1D7Gkb0J6aWWBmtA+M0BIIcazHq5o1VpVyxYblbKwrpyAvL9ch5oSSNBERkSmkUsbh7gi7TwzQE4nlOpxFZySe5EAwTEswxOBwnOKCPC5aVcXORj/V5UurajYZJWkiIiJniSWStAbCPHtygMhoItfhLCpmRnBwlJZgiKPdUZIpY6W/hMu2V9NUV0FB/tKsmk1GSZqIiEhaNJbg2ZMDtARCxOJaDDCbRuNJDnZGaAmE6B8aoyg/j+YGH82NfmoqinMd3rykJE1ERJa8nkiMZ05q26bZZmZ0hkdpCYQ43OVVzVb4irl+Wx2bV1RSqKrZOSlJExGRJUuLAbIjlvCqZq2BEL3RMQrzHdtWVrKz0U9dZUmuw1swlKSJiMiSkkwZhzq9nQG0GGD2mBldkRitgRCHOiMkUkZdZTG/vrWOLSsqKSpQ1Wy6lKSJiMiSMBpP0hoIsffUoBYDzKKxRIpDXd5cs55IjII8x5Z6r2q2wqeq2YVQkiYiIotaaCTO3lPaGWC29URitARCHOwME08aNRVFvHpLLVvrKykuyM91eIuCkjQREVmUOkOj7Gkb4Gi3dgaYLfFkisPpqllXOEZ+nmPzigp2Nvqp95WQ3m9bZomSNBERWTTMjGM9QzzTNkBgcCTX4SwavdF01awjwlgyRXV5Edds9qpmJYWqmmWLkjQREVnw4skU+4Je89nB4Xiuw1kUEskUR7qjtARCdIRGyc9zNNVV0Nzop8GvqtlcUJImIiILVjSW4LlTgzzfHmI0nsx1OItC/9AYLYEQBzrCxBIpqsoKuaqphm0rfZSqajanlKSJiMiC0x0Z5Zm2QQ53qfnsbEikUhztjtIaCBMYHCHPwaY6b65ZY1WpqmY5oiRNREQWBDPjhd4hnjk5yKl+NZ+dDQPDY7QGQuzvCDMaT+EvLeTKTcvZvtJHWZFShFzTd0BEROa1eDLFgY4wz54cpH9oLNfhLHjJlHGsx5tr1j7gVc021FSwc5Wf1ctUNZtPlKSJiMi8pPlmsys0EqclEGJ/MMxIPEllSQFXbFzOjpU+youVDsxH+q6IiMi80h0e5ZmTA6c35JaZS6a8IeKWQIiT/cM4YH1NOTsb/axZXkaeqmbzmpI0ERHJufH+Zs+eHKB9QP3NLlR4JE5rMMS+YJjhsSQVxQVcvr6aHQ1+Kkr0q3+h0HdKRERyZiyRYl/Q209T/c0uTCplnOjzqmYn+ryFFeuWl7Gz0c+65eXk5alqttAoSRMRkTk3vp/mvmCIWFz7aV6IyGicfcEw+4JhorEE5UX5XLaumh0NPnylhbkOTy6AkjQREZkzgcERnj05wLHuIe2neQFSZpzsG6YlEOKF3iEMWFtdxjWba1lfU06+qmaLgpI0ERHJqmTKONwV4dmTg3SFR3MdzoI2FEuwLximNRgiMpqgtDCfl69dRnOjH7+qZouOkjQREcmK4bEEz7eHaGkPEY0lch3OgmVmnOx/sWqWMli9rJSrNtWwobZCVbNFTEmaiIjMqu7IKHtPDnKoM0JCLTRmbHgswf5gmNZgmNBInNLCfC5ZXUVzo59lZUW5Dk/mgJI0ERG5YF4LjSjPnhxUC40LYGa0D4zQEghxrCdKyqCxqpQrNixnY105BXl5uQ5R5pCSNBERmbHReJJ9wTDPnRokNKIWGjM1MpbkQEeYlmCIweE4xQV5XLSqip2NfqrLVTVbqpSkiYjItPUPjbH31AAHOiKMJdRCYybMjODgKC2BEEe7oyTNWOkv4bLt1TTVVVCQr6rZUqckTUREMmJmnOgbZu+pAdr6hlEHjZkZjXtVs9ZAmP7hMYoK8mhu9NHc6KemojjX4ck8oiRNRETOKZZIsj89pDmgXQFmxMzoCI3SGghxuNvbk7TeV8L12+rYvKKSQlXNZBJK0kREZFKDw2M8e2qQ/cGwhjRnKJZIcrAjQkswRF90jKL8PLav9LGz0U9tpapmcm5K0kRE5DQzo61vmL2nBjnRN6QhzRkwM7rCMVoCIQ53eW1I6iqLuW6rVzUrKlDVTDKjJE1ERDSkOQvGEikOdUZoCYToicYoyHNsqa+kudFPva8k1+FJhiqKC9hYV87G2jFv9mwAACAASURBVArqclztVJImIrKE9Q+N8dypQfZ3aEhzprrD3grNQ10R4kmjpqKIV2+pZWt9JcUF+bkOTzJQVVbIproKNtVVUO8rwbn5sYuDkjQRkSXGzDjeO8RzpwY52a9VmjMRT6Y41BWhNRCiKxwjP8+xeUUFO9NVs/nyS16mVltZfDoxm6+ras+bpDnndgMPAV8zs4HshyQiItngNZ4N8dypkBrPzlBv1JtrdrAjwlgyRXV5Edds9qpmJYWqms1nzkGDv5SNdRVsqq3AXzb/N6TPpJL2u8DtwK8mJGw/MNPfXiIiC0FPJMbeU4Mc6gwTT+q/7ulKJFMc6Y7SEgjRERolP8+xqa6CnQ1+GqpUNZvP8vMcq6tL2VRbyYbacsqLF9YA4nmjNbOjwH3Oub8A3gB8GUg5574MPGBm/VmOUUREpimZMo52R3mufZCA9tKckf6hMVoCIQ50hIklUlSVFXJVUw3bVvooVdVs3irMd6xdXs6mugrW15Qv6ApnRimlc+4ivGraTcA3gYeBVwE/BC7JWnQiIjIt0ViClvYQrYEQ0Vgi1+EsOIlkiqM9XtUsODhKnoNNtRU0N/pZtaxUVbN5qrgwjw01XmK2dnn5omkOnMmctD3AIPAl4M/NLJZ+6BfOuSuzGZyIiGSmfWCY506FONbjdbOX6RkYHqM1EGJ/R5jReAp/aSFXblrO9pU+yooW1hDZUlFWlM/GWm/i/+rqMvLzFl8CnclP3m+Z2fGJdzjn1pvZC2b2lizFJSIi5zGWSHGwM8xz7SF6I7HzP0HOkEwZx9JVs/aBEfIcbKipoLnRx5rqMlXN5qHKkoLTKzIbqxZ/ZTOTJO1R4NJJ7nv57IcjIiLn0z80xnPt2q5ppkIjcVoCIfYHw4zEk/hKCrhi43J2rPQtuInlS8GyskI21VV6Pcz8S6sp8JQ/jc65rcAOwO+cm1gx8wFL610SEcmxVLrq81x7iFP9w7kOZ8FJpowXeodoCYQ42T+Mc7B+eTk7G/2sWV5G3iKvyCw0NZXFbKqtoGnF/O1hNhfO9SfDFrzVnFXAzRPujwB/kM2gRETEE40laA14CwEio1oIMF3hkTitwRD7gmGGx5JUFBdw+fpqdjT4qShR1Ww+qfeXeEOZtRUsKy/KdTjzwpQ/oWb2beDbzrkrzOzncxiTiMiSd6p/mOfaBznWPURKbSmnJZUyTvQN8XwgRFvfMA5Yu7yMnY1+1tWUq2o2T4w3l920wptj5iuZ/81l59q5hjv/zMz+Dvg959ytZz9uZu/OamQiIkvMaDzJgY4wLYEQfdGxXIez4ERG4+wLhtkXDBONJSgvzueyddXsaPQpAZgn8pyjcVkpTenJ/5oDeG7nencOpD/vnotARESWqu7wKM+1hzjcFdFCgGlKmdHWN0xrIMQLvUMYsLa6jFdvqWX98nLyFmFbhoVmvOt/U10lG2srKC1auM1l59q5hju/k/78L3MXjojI0pBIb9D9fHuIztBorsNZcIZiCfYFw7QGvbl6pYX5vHztMpob/fhLVTXLtYI8x5rlZTTVedsxLeSu/7mUSTPbJ/B6pQ2mby8D/tXMXpft4EREFpv+oTGebx/kQEeE0Xgy1+EsKGbGyf5hWtJVs5TB6mWlXLWphg21FYuymelCMr4dU9MKbzum4gIlZhcqk8Hg2vEEDcDMBpxzdVmMSURkURlvmvq82mfMyPBYgv3BMK3BMKGROKWF+bxs9TJ2NPpYVqZVgLlUVJDHunRitm55OUUFi2M7pvkikyQt6ZxbY2YnAZxzawEtNRIROY/QSJzWQIh9wRBDMVXNpsPMaB8YoSXgbXWVMmisKuWKDcvZWFdOQZ6SgVwpKvD2yWxasbj2yZyPMknS7gP+xzn33+nbVwN3ZS8kEZGFK5UyXugboqU9xIm+IdQ9Y3pGxtIrXIMhBofjFBfkcfGqKpob/VSrd1bOeBuYe81l11aXUaDEbE6cN0kzs+875y4FLgcc8Cdm1pv1yEREFpDx9g9qOjt9ZkZwcJSWQIij3VGSZqz0l3DZ9mqa6iqUEORISWE+G2rLaarzKmaa8zf3zrktlJkdTCdoAMH05zXp4c9nsh+eiMj8ZWac6EtPZO9R09npGu8L1xoI0z88RlFBHs2NPpob/Ut6K6BcKinMZ2NtOZtXVLK6ukyJWY6dq5L2XrxhzU9N8pgBv56ViERE5rloLMG+QIjWYJjwSDzX4SwoZkZneJSW9hCHu6MkU0a9r4Trt9WxeUWl5jflQGlRPhtrK2iqq2BNdZl6y80j5+qTNj7v7EYzO6OJj3PugjZYd859Em8/0DHgGHD7xBWkE46rAr4INOMlhndoiyoRyQVLN019XlWzGYklkhzsiNAS9HZTKMrPY/tKHzsb/dRWqmo218YTs80rKli9TInZfJXJwoGfAZdmcN90PAHca2YJ59wngHuBeyY57gHg+2Z2i3OuCCi7gGuKiEybqmYzZ2Z0hWO0BLzdFBIpo66ymOu2elUztWuYWyWF+WyqU2K2kJxrTlo90AiUOudehrdoAMDHBSZLZvaDCTefBm6Z5Po+vJWkt6WfM4ZXeRMRySrNNbswY4kUhzq9qllPJEZhvmNLfSU7G/2s8F3QQIxM08Q5ZhrKXHjOVUl7HV6CtApvXtr4dzYCfGAWY7gD+MYk928AeoCHnHMXA3uA95jZ0GQncc7dRbo1yJo1a2YxPBFZKiKjcVoDYfYFtUJzJrrD3grNQ10R4kmjpqKIa7fUsqW+Ut3n59B4YtaUTsw0+X/hcnaevxCdc79pZt+c9omdexKon+Sh+8zs2+lj7gN2AW+xswJxzu3Cq7JdaWa/cM49AITN7C/Od+1du3bZ7t3aF15Ezi+VMo73DrEvGOJE77CqZtMUT+9B2tIeojsSoyDP0bSigosaq1jhK8Y5JQhzobgwLz3HTInZQuSc22Nmu86+P5M5aavSQ48R4At4c9H+/Kwhy5cws+vPE9DvA28Arjs7QUtrB9rN7Bfp248Cf55BvCIi5xUajtMaDLE/GCYaU9VsunoiMVoDIQ52RhhLpqguL+KazbVsq6+kWJtpz4migrzTQ5nqY7Y4ZZKk3WFmDzjnXgfUAbcDDwHnTNLOxTl3A95CgWvMbNKN7Mys0zl3yjm3xcwOAdcB+2d6TRGRZMo42h2lNRDi1MCwdgOYpkQyxeH0+9cRGiU/z9FUV0Fzo58Gf4mqZnOgqCCP9TVeYrZuuTr/L3aZJGnj/+puAh4ys+fchf9L/CxQDDyRPtXTZna3c64B+KKZ3ZQ+7o+Bh9MrO4/jJYgiItPSF43RGgxzoCPMyJj20JyuvmiM1kCYA51hYokUy8oKuaqphm0rfZSqapZ1hfmOdTXlbFlRyboa7ZW5lGSSpO1xzv0AWA/c65yrBFIXclEz2zTF/UG8ZHD89l68OWsiItMylkhxuCvCvmCI4ODo+Z8gZ0gkUxztidIS8N6/PAeb6irY2einsapUVbMsK8hzrK0pZ/OKCjbUVKhdyRKVSZJ2J3AJcNzMhp1zy1FFS0TmqY7QCPsCYQ51RRhLXNDfk0vSwNAYLcEQB4JhRhMp/KWFvGpTDdtWVlJWlMmvDJmp/DzHmuoyNq+oZENtOSWqUi55mWywnnLOvQBsvtCdBkREsmFkLMmBzjD7AiF6o2qnOF3JlHEsXTVrHxghz8GGWq9qtnqZqmbZlOccq5aVsnlFJU0rKpSYyRnOm6Q5594JvAevX9pe4HLg52jvThHJITPjZP8wrYEwx3uiJFJaBTBdg8NjtAbD7A+GGYkn8ZUU8MqNy9m+0kd5sapm2eIcNPhL2VxfSVNdhd5rmVImPxnvAX4Nb3L/tc65rcCHsxuWiMjkQiNx9qVbZ6jh7PQlU8YLvUO0BEKc7B/GOdhQU05zo5+11WWqmmXRCl8JW+q9XmaVJYW5DkcWgEyStFEzG3XO4ZwrNrODzrktWY9MRCRtfBL7vkBYrTNmKDzi9YXbFwwzPJakoriAy9dXs6PBT0WJKjnZUlNRxOYVlWypr6SqrCjX4cgCk8m/zHbnXBXwLbyWGQNAMLthiYh42wy1Br2GqbG4FgFMVyplvNDnVc3a+oZxwLqacpobfaxbXk6eqmZZ4S8tZEt9JZtXVFJbWZzrcGQBy2ThwJvTX37IOfcjwA98P6tRiciSNb4IYH8wTE8klutwFqTIaPz0XLNoLEF5cT6Xra9mR4MPn4bZsqKiuICmFRVsrfdR79caO5kdUyZpzrnqSe5uSX+uAPqzEpGILDmplHGib4j9HWGO9wyR1CKAaUuZ0dY3TEsgxIneIQxYu7yMV2+pZf3ycvK0ZdCsKynMp6mugi31lazSKljJgnNV0vYAxos7DjDhtgEbshiXiCwB/UNj7E/vBKD9M2cmGkuwPximNRgiMpqgrCifl69dRnOjH3+pqmazraggjw015Wyp136Zkn1TJmlmtn4uAxGRpSGWSHK4M8r+Du0EMFPj7UdaAiGO9w5hBquXlXLVpho21FYocZhl+XmOtcvL2FrvY0OttmWSuXOu4c63mdlX019faWY/nfDYu8zss3MRoIgsfGbGqf4R9neEONodJZ7UcOZMDMUS7O8Isy8YJjQSp7Qwn0tXL6O50aeVg7PMOWisKmVrvU9NZiVnzjXc+V7gq+mv/xG4dMJjd+Btki4iMqXBYW84c3+HeprNlJlxamCE1kCIYz1RUgarqkq5YsNyNtaVU5Cnqs5sqvMVszW9MlO9zCTXzpWkuSm+nuy2iAjgDWce6YqyPxgmMDiS63AWrJGxJPs7wrQGQgyOxCkuyOPiVVU0N/qpLlfVbDZVlXktM7bW+/TeyrxyriTNpvh6stsisoRpOHN2mBnBwVGeDwxyrHuIpBkr/SVctr6aproKCjQXataUF+fTtKKSrfWVrPSX5jockUmdK0nb6px7Hq9qtjH9NenbWtkpIgwMjbG/w1udqeHMmRuNJznQEaY1EKZ/eIyigjyaG33sbPSzvELNUGdLUUEeG2sr2FpfyZrqMrUlkXnvXEnatjmLQkQWjNF4ksNdEfYHw3SEtDpzpsyMjtAoLYEQR7qjJFNGva+E12xbQdOKCq0gnCVamSkL2blacLTNZSAiMn9NbDb7Qs8QCTWbnbFYPMnBzggtgRB9Q2MU5eexfaVXNdMWQrOnoaqErfU+Nq+opLRIKzNlYdKuuiIype7wKPs7whzqjDA8lsx1OAuWmdEVjtESCHG4K0IiZdRVFnPd1jo2r6ikqEDVndlQXV7ElvpKttX78JdpZaYsfErSROQM0ViCgx1hDnRG6NXemRdkLJHiYKc316wnGqMw37G1vpLmRj8rfNrfcTaUFeWzOZ2Yac9MWWwyStKcc6XAGjM7lOV4RCQH4skUR7ujHOwMc7JvhJRpOPNCdIVHaQ2EONQVIZ40aiqKuHZLLVvqKyku0NDbhSrMd94CgJU+1moBgCxi503SnHM3A/cDRcB659wlwF+b2RuzHZyIZM+LbTPCHOuJMpZI5TqkBS2eTHEoPdesOxKjIM+xeUUlOxv9rPAVa/PtC+QcrF5WxtaVlWyqq1CyK0tCJpW0DwGXAU8BmNle59y6rEUkIlnVG41xID3PTG0zLlxPJEZrIMTBzghjyRTLy4t49eZattZXUqythC5YTWUx21dWsqXeR0WxZujI0pLJT3zCzEL6K1Bk4RqKJTjYGeFAR5gezTO7YIlkisPdUVoDITpCo+TnOZrqKtjZ6Gelv0RVswtUUVzgLQBY6dOKV1nSMknSWp1zvwfkO+eagHcDP8tuWCJyocYSKY71aJ7ZbOqLxmgNhDnQGSaWSLGsrJCrm2rYttKnDbgvUGG+Y1NdBVvrfWo0K5KWSZL2x8B9QAz4GvCfwEeyGZSIzEwqZZwaGOZAR5hjPUOaZzYLEskUR3uitARCBAdHyXeOjXXl7Gz001hVqqrZBXAOVi0rY9vKSprq1IpE5GznTdLMbBgvSbsv++GIyEx0hUc50BHmcFeEoZj6mc2GgaExWoIhDnSEGY2n8JcW8qpNNWxbWUlZkeZGXYjq8iK2rfSxdWUlvhL1MxOZSiarO58AfsvMBtO3lwH/amavy3ZwIjK10EicQ50RDnaG6YuO5TqcRSGRSnGse4jWQIj2wRHyHGysraC50c/qZaqaXYjSony2rPDmmamfmUhmMvlzsGY8QQMwswHnXF0WYxKRKYzvm3mwI0IwNIKmmc2OweExWoNh9gfDjMST+EoKeOXG5Wxf6aNcKwpnLD/Psa6mnO0rK1lfU0G+5pmJTEsm//uknHNrzOwkgHNuLaBfDSJzJJ5M8ULvEAc6wrT1DZPUvpmzIpkyjvdGaQ2EOdk/jHOwocaba7amukxVswtQ5ytm+0ofW+t92jdT5AJkkqTdB/yPc+6/07evBu7KXkgi8uICgIgazc6y8Eic1mCIfcEww2NJKooLuHx9NTsa/FSUqGo2U+XF+Wyt97G9wUdNhdpmiMyGTBYOfN85dylwOeCAPzGz3qxHJrIEdYZGOdipBQCzLZUyXugboiUQoq1vGAesqymnudHHuuXl5KlqNiMFeY4NtRVsb9D2TCLZMGWS5pzbamYH0wkaQDD9eU16+POZ7IcnsvgNDI1xoDPM4c4IA8PxXIezqERG46fnmkVjCcqL87lsfTU7GnxaVXgB6v0lbF/pY0t9pfrDiWTRuSpp78Ub1vzUJI8Z8OtZiUhkCYjGEhzqjHCoM0JXeDTX4SwqKTPa+oZpCYQ40TuEAWuXl/HqLbWsX16uas8MVRQXsHVlJdtX+liu4UyROTFlkmZmd6U/Xzt34YgsXqPxJEe6vB0AAoNamTnborEE+9JzzSKjCcqK8tm1bhnNDX58paqazUR+nmNDbTnbV6aHhZXgisypTPqkvWOy+83sK7MfjsjiEk+mON4zxMFOrczMBjPjZL9XNTveO4QZrK4u5aqmGjao5cOMaXWmyPyQyVKmX5vwdQlwHfAMoCRNZBLJlNHWN8ShzgjHe7U1UzYMxRLs7wjTGggRHk1QWpjPpWuW0dzgo6qsKNfhLUilRflsra9ke4OPuko1mxWZDzJZ3fnHE2875/zA/8laRCILkJnRPjDCoc4IR7qjjMa1MnO2mRmnBkZoDYQ41hMlZbCqqpQrN9Wwobacgjzt+zhdec6xrqaMHQ0+NZsVmYdm0hRoGGia7UBEFqKOUDox64oSjSVyHc6iNDyW4EBHhJZAiNBInJKCPC5eXcXOBj/LylU1m4nq8iK2N/jYttJHhXZUEJm3MpmT9h1e3GEgD9gOPJLNoETms55IjMNd3srM0IhaZmSDmREYHKElEOJY9xBJMxr8JVy+vppNdRUU5KtqNl1FBXk01VWwo9FPY1VprsMRkQxk8ifU/RO+TgBtZtaepXhE5qXB4TEOdkY40hWhV5uZZ81oPHl6rtnAcJyigjyaG33sbPSr7cMMNVSVsKPBz+YVlRQVKLkVWUgymZP23+c7RmQxCo/GOdIV4VBnVL3MssjM6AiN0hIIcaQ7SjJl1PtKeM22appWVFCoqtm0lRfns22ljx0Nfqo1JCyyYJ1rx4EIU2+kHgOOAfeZ2X9lIzCRXBiKJTjcFeFwV4SO0Kh6mWVRLJ7kQGeE1kCIvqExivLz2LHSR3Ojn9pKVc2m68VFAH421KinmchicK5mtpVTPeacyweagYfTn0UWrJGxJEe7oxzqihAYGCGlzCxrzIyucIyWQIjDXRESKaOuspjrttZpOG6GqsoK2dHgZ3uDFgGILDYz+hdtZkngOefcP85yPCJzYjSe5FhPlMNdEU72KTHLtrFEioOdYVoCIXqjYxTmO7bWV9Lc6GeFTz25pqsgz9G0ooIdDX5WLSvFaYN4kUXpgv7sMrPPzVYgItkWSyQ53jPE4a6Iuv/Pke6wN9fsUFeEeNKorSjm2i21bKmvpLhAneynq7aymOZGP1u1sbnIkqDauCxq8WSKF3q97v8neodIKDHLurFEisNdXl+z7kiMgjzH5hWV7Gz0s8JXrKrPNBUV5KnqKLJEZZSkOefWAk1m9qRzrhQoMLNIdkMTmZl4MsWJ3iEOd0U50adtmeZKT8Sba3aoM8JYMsXy8iJevbmWrfWVFKvqM21qnSEimTSz/QPgLqAa2AisAh7E28NTZF5IJFOc6BvmSJf2y5xL8WSKI11RWgIhOsOj5Oc5muoq2NnoZ6W/RFWzaSopzGfbSq9qVqO+cCJLXiaVtD8CLgN+AWBmR5xzdVmNSiQDiWSKtn4vMTvWo8RsLvVFvarZwc4IsUSKZWWFXN1Uw7aVPs2VmoFVy0rZucrPplrtpiAiL8okSYuZ2dj4X8TOuQKm7p8mklXJlNHW5w1lHu+NEosrMZsriWSKo91e1SwYGiXfOTbWlbMzvc2QqmbTU1aUz/YGH83ag1REppBJkvbfzrkPAKXOudcA/wv4TnbDEnmRErPc6h8aozUQ4kBHmNFECn9pIa/aVMO2lZWUFWnt0XQ4B6uXlbFzlZ+NtRXkq+GsiJxDJv/D/jlwJ9AC/CHwOPDFbAYlkkwZJ/uHOdwV4ViPErO5lkilONY9RGsgRPvgCHkONtZW0NzoZ7X6ck1beXE+21f62dnox19WmOtwRGSByGTvzhTwhfSHSNaMV8yOdEeVmOXI4PAYrYEw+zvCjMST+EoKeOXG5Wxf6aNc3eynZbxqdtEqPxtUNRORGchkdWcLL52DFgJ2Ax8xs75sBCZLg4Yycy+ZMo73RGkJhjjVP4JzsKHGm2u2prpMVbNpKivKZ0eDn+ZGH1VlmmsmIjOXyZ/G/wEkga+lb/9u+nMY+Gfg5tkPSxazF1dlKjHLpdBInNZAiP0dYYbHklQUF3D5hmp2NPi1B+Q0OQer0lUzzTUTkdmSyf/EV5rZlRNutzjnfmpmVzrn3jaTizrnPomX3I0Bx4DbzWzwrGO2AN+YcNcG4C/N7DMzuabk1ngfs6PdapeRS6mU8ULfEC2BEG19wzhgXbpqtnZ5GXmqmk1LaVE+21f62NmoFZoiMvsySdIqnHOvMLNfADjnLgMq0o8lZnjdJ4B7zSzhnPsEcC9wz8QDzOwQcEn6mvlAAHhshteTHIgnU6eHMl9Qg9mciozGaQ2G2RcMMRRLUl6cz2Xrq2lu8FFZoons09VY5fU1a6pTXzMRyZ5MkrR3Al92zlUADm+Y853OuXLgb2dyUTP7wYSbTwO3nOcp1wHHzKxtJteTuTO+V+YRbcmUcykz2vqGaQmEONE7hAFrl5dx7RY/65eXk6chuWkpLsxjW72Pnau0G4CIzI1MVnf+CtjpnPMD7qxhyUdmIYY7OHNYczK/C3x9Fq4lWRBLJE8nZm19Q8ST6nWcS9FYgn3BEPuCYSKjCcqK8tm1bhnNDX58paqaTdcKXwkXrfKzpb6SQlXNRGQOZbK6sxj4TWAdUDC+0svM/vo8z3sSqJ/kofvM7NvpY+7DGzJ9+BznKQLeiDckeq7r3YW3xyhr1qw516EyC0bjSY73DHGkO8LJvmESKSVmuWTm9ZVrCYQ43juEGaypLuOqpho21Ggi+3QV5js2r6jk4tVVrPCV5DocEVmiMhnu/DZey409QCzTE5vZ9ed63Dn3+8AbgOvM7Fy/4W8EnjGzrvNc7/PA5wF27dqljCELRsaSHOuJcqQ7wqn+EZJKzHJuKJZgf0eY1kCI8GiC0sJ8Ll2zjOYGtX+YieryIi5a5dcepCIyL2SSpK0ysxtm86LOuRvwFgpcY2bD5zn8VjTUmTNDsQRHu6Mc7Y7SPjBC6pz5tMwFM+PUwIhXNeuJkjJYVVXKlZtq2FBbTkGehuSmIz/PsbG2gotW+VldXZbrcERETsskSfuZc26nmbXM4nU/CxQDT6SHT582s7udcw3AF83sJgDnXBnwGrztqGSOhEfjXmLWFSUYGkF52fwwPJbgQEeElkCI0EickoI8Ll5dxU5t0D0jlSUFNDd6WzVpNwURmY8y+Z/pVcBtzrkX8IY7HWBmdtFML2pmm6a4PwjcNOH2MLB8pteRzA0Oj3G0O8qR7iidodFchyNpZkZg0KuaHeseImlGQ1UJl2+oZlOt2j9Ml3PeXL2LVlWxoUYrXEVkfsskSbsx61FITvRGY6eHMnsiGU83lDkwGk+enms2MBynuCCPnY3eVkPL1f5h2ooL89jR4OciNZ0VkQUkkxYcbQDOuTpAy5wWuO7wKEfSiVn/0Fiuw5EJzIyO0CgtgRBHuqMkU8ZKfwmv2V5NU12F2j/MQJ2vmItXVal9hogsSJm04Hgj8CmgAegG1gIHgB3ZDU1mg5kRDI2erpiFR+K5DknOEosnOdAZoTUQom9ojKL8vNNbDdVWqmo2XQV5jqYVFVy8uoqV/tJchyMiMmOZDHf+DXA58KSZvcw5dy3eikuZp1Ipo31ghCPdEY71RBmKJXMdkpzFzOgKx2gJhDjcFSGRMuoqi7luax2bV1RSVKCqz3T5Sgu5aJWfHQ0+yoq0EEBEFr5M/ieLm1mfcy7POZdnZj9K77cp80gimaKtf5ij3VGO9/zf9u48ONK7vvP4+9vdakkt9an7PjyX5/DcYwPBBtsBQrEYNk7iVFjOwMJSgSW1u4EyVZvaKrJLSIWqLEtYlgCBUEBsQmEvYY2xMcluMMEQjDQePJcxtubQHJ7WMTq7f/vH88hujyVNj9Sn+vOqUk33008/8/31r1v91e95fr/vNLMLSswq0dxihifPeDM0z0/NUxc0tnVG2dUTp12Lpl6zpYkAu/u8iQCmAvEisoHkk6Rd8ut2/gPwFTMbZ+2F1aWA5hYz/PK8l5ipTmZlOzsxy+hYmifPTrKQcbQ11/PqrW1s7YxSH9Kiqdeqvi7A9V0x9vQmNBFARDasfJK0O4AZ4EPA7wFxYNWSUFI8S6v+nzg3pXJMFW5+McvRs96o2fjkHKGAV2poV0+cjli9Rn3WoLU5zO6+BBcxngAAHDdJREFUBNs6YzolLCIb3qpJmpkFgW/5JZ6ywF+XJCp5kcmlxWXHpzh1aVar/le4c5PetWZPnplkPpOlpSnMq7a0sa0zSr1KDV2zgBnDbU3s6UuoIoCI1JRVkzTnXMbMLptZ3DmXLlVQAhen5zlxzkvMzk7MatX/CreQyXLs7BQjY2nOTMwSDBhb2pvZ2ROnK96gUbM1aAwH2dUTZ1dvnFhDXbnDEREpuXxOd84CI2b2IDC9tNE594GiRVWjzk54S2WcODfFhSmtYVYNLkx5o2ZHzkwyv5glGanj5s2tKtC9Dh2xBnb3xdnaEVVFBRGpafkkad/2f6TAslmv5M/xc1OcGJ9iclbzMarBYibLsXFv1Ox0epagGde1N3FDT4LuhEbN1iIYMDa3e2ubdSe0tpmICOSXpH0d2AQ44IRzToUd12FpqYwT41OcPD/NzLyWyqgWF6fnGR1L88TpCeYWsyQa6/i1Ta1s74rRGNao2Vo01QfZ1ZNgV2+cZhU5FxF5kRV/K5pZCPgT4J3A00AA6DWzLwB3O+e0dH2eZhcy/PLCNMfHp3j6wmUtlVFFFrNZToxPMzKWZuzSDAGD69qa2dUTpzfZqFGzNeqMN7CnL8GWjihBFTkXEVnWan+6fgKIAkPOuUkAM4sBf+b/fLD44VWvqblFTvoX/j/73AwZLZVRVS5dnmd0bIInTk8ws5Ah1hDi5de1sL0rRpNGfNYkGDC2qFyTiEjeVvu2eQOwxbkX5hU65ybM7H3AL1CS9hLP5czIPKMZmVUnk3WcPOdda/bMczOYwXBrE7t64vSnIho1W6Om+iA7e+Ls7k0owRURuQar/cZ0uQlazsaMmSn94IX6i0uLy2pGZnWamFlg9FSaw6cmuDyfIdoQ4mXDLWzvjuk6qXXoiHmnNLd26pSmiMharPYN9ISZvdU596XcjWb2FryRtJqVyTp+cHSck+emNSOzSmWzjqcueNeaPX3hMgYM+qNmAy0RAho1W5OAGZvam9nbr1maIiLrtVqS9n7g78zsncBP8GZ3HgQagTeXILaKtZDJ8vgzWtu3Gk3OLjB6aoLDp9JMz2Voqg9yaCjFzu4YUS2YumZLC8/e0BvX6ygiUiArJmnOuTHgRjO7FdgBGPAd59xDpQpOpBCyzvHLC9OMjk3wy/PTOGCgJcKrt8YZamkioFNxa9baHGZPX5JtXVHqtPCsiEhBXfWCG+fcw8DDJYhFpKCmZhc5fCrN6KkJpuYWiYSDHBhMsrM7TqxRoz1rZQZDrU3s7UvS36JamiIixaKromVDcc7x9MXLjI6lOXl+GuegPxXh5i2tDLc26wL2dQiHAmzvjrGnN0GyKVzucERENjwlabIhTM8t8sTpCUbH0kzMLtJYF2Rff5Kd3TESESUU6xFrrGNPX4Id3apHKiJSSkrSpGo553jmuRlGxtKcPDdF1kFvspFXbGpluK2JUEDXSK1HT7KRff0Jhlubdd2eiEgZKEmTqnN5fpEjpycZGUuTnlmgIRRgT1+CnT1xkho1W5elqgB7+5N0xBrKHY6ISE1TkiZVwTnH2CVv1OzE+DQZ5+hONHDTcIpNbc2ENLNwXZaW0Njdl9ACviIiFUK/jaWizS5knr/W7LnLC9SHAuzqibOzJ0ZLc325w6t6Lc1h9moJDRGRiqQkTSqOc45T6VlGx9IcG58ik3V0xhr49e0pNrc3K5kogIGWCPv6kwy0qCapiEilUpImFWNuIcORM5OMjqW5MD1POBhgR1eMnT1x2qIaNVuvUMDY1hVjb3+CVo1CiohUPCVpUlbOOc5MzDIylubY2SkWs46OWD23Xd/O1g6dgiuESDjIDb0JdvfFiYT1kRcRqRb6jS1lMbeY4ckz3gzN81Pz1AWNbZ1RdvXEadeswoJobQ6ztz/Jts6oJlaIiFQhJWlSUmf9UbOjZydZyDjaovXcurWdrZ1RwiElEoWwdL3ZYGtTuUMREZF1UJImRTe/mOXoWW/UbHxyjlDA2NLhjZp1xOp14XoBhALG1s4o+waSut5MRGSDUJImRXNuco6RsTRPnplkPpOlpSnMq7a0sa0rSn1I5YUKoTEc5AZ/fbMmrW8mIrKh6Le6FNRCxhs1Gx2b4MzErLeCfXszO3vidMUbNGpWIMlIHfsGklzfFdPkChGRDUpJmhTEhSlv1OzImUnmF7MkI3XcvLmV67tUlLuQepKN7B9IMtzapIRXRGSDU5Ima7aYyXJsfIqRsTSn07MEzdjU3syunjjdCY2aFUrAjM0dzezrT9IZ18xXEZFaoSRNrtnF6XlGx9I8cXqCucUsicY6XrnJGzVrDGvUrFDCoQA7umPs7U8Sb6wrdzgiIlJiStIkL4vZLCfGpxkZSzN2aYaAwXVt3qhZb7JRo2YFFG0Isacvwc6euE4Vi4jUMCVpsqrnLnujZkdOTzKzkCHWEOLl17WwvSum2YQF1hqtZ39/kq2dUYIBJb0iIrVO37LyEpms4+Q571qzZ56bwQyGW5vY1ROnP6WC3IU20BJh/0CSgRYtPisiIi9QkibPS88sPH+t2eX5DNGGEC8bbmFHt0bNCi3oL+i7fyCp4vEiIrIsffPWuEzW8dT5aUbH0jx98TIGDPqjZgMtEQIaNSuocCjArp44e/sTRBs0GUBERFamJK1GTcwucHhsgsOn0kzPZ2iuD3HjUIod3TElD0WwNBlgV29c1RZERCQvStJqSNY5fnnem6H59IXLOGCwJcKtPXEGW5oI6GL1gmttDrNvIMm2zpgmA4iIyDVRklYDpmYXGT2V5vCpCabmFomEgxwc9EbNYlp/qyj6Ut5kgKFWTQYQEZG1UZK2QWWd41cXLjMyluapC9M4B/2pCLdsaWOotUmjOkUQ8CsuHBhM0hFTZQAREVkfJWkbzPTcIodPTTB6Ks3k7CKNdUH29yfZ2RPXqvVFUhc0dnTH2defJB7RaywiIoWhJG0DcM7xq4uXGR2b4OT5KbIOepON/NqmVq5ra9aoWZE0hoPs7k2wpy+hclgiIlJwStKq2OX5RZ44PcHo2ATpmQUa6gLPlxNKRsLlDm/DijfWsW8gyY7uGHXBQLnDERGRDUpJWpVxzjF2aYaRsTTHx71Rs+5EAzcNp9jU1kxISUPRtMfqOTCQYnN7s2bCiohI0SlJqxIzCxmOnJ5gdCzNc5cXqA8FuKE3wc7uGC3NWrG+mPpTEQ4OpuhviZQ7FBERqSFK0iqYc45T6VlGx9IcG58ik3V0xRt4zXZvNEejZsUTMGNzRzMHBpK0a6amiIiUgZK0CjS7kOEXZyYZHUtzYXqecDDAju4YO7vjqvNYZHVBY3t3jP39Kc3UFBGRslKSViGcc5yZmGVkLM2xs1MsZh0dsXpuu76drR1RXaBeZA11QXb3xtnTnyAS1sdCRETKT99GZTa3+MKo2fmpeeqCxrauKLt64rRHdZqt2KINIfYNJNnZHSccUiIsIiKVQ0lamZz1R82Onp1kIeNoi9Zz69Z2tnZGlSyUQGtzmP0DKbZ2RrWOnIiIVKSyJGlm9gngXwHzwAngHc65S8vs9yHg9wEHjPj7zZYy1kKaX8xy9OwkI2NpxifnCAWMrZ1RdvbE6YjWY6Zkodh6Eo3sH0wy3Nqk11tERCpauUbSHgQ+4pxbNLOPAx8B/ih3BzPrAT4AbHfOzZjZ3wJ3AV8sdbDrdW5yjpGxNE+emWQ+k6WlOcyrtrSxrStKfUgr1RebGQy1NnFgMEVPorHc4YiIiOSlLEmac+67OXcfBe5cYdcQ0GhmC0AEOFXs2AplIfPCqNnZiTmCAWNLezM7e+J0xRs0ilMCATO2djZzYDBFq9aSExGRKlMJ16S9E/j6lRudc2Nm9mfAr4AZ4LtXJHcvYmbvAd4D0N/fX6RQr+781ByjY2mOnJlkfjFLKhLm5s2tXN8Vo6FOo2al8HzB84GkisqLiEjVKlqSZmbfAzqXeehu59y3/H3uBhaBryzz/CRwBzAEXALuMbO3OOf+Zrn/zzn3WeCzAAcOHHAFaUSeFjNZjo1PMTKW5nR6lqAZm9qb2dUTpzuhUbNSqa8LsKc3oWU0RERkQyjaN5lz7vbVHjeztwFvAG5zzi2XVN0OPOWcO+fv/3fAy4Flk7RyuDg9z8hYmiOnJ5hbzJKI1PHKTd6oWWNYo2al0lwfYt+AV1he1/iJiMhGUa7Zna/Dmyhwi3Pu8gq7/Qq4ycwieKc7bwMeK1GIK3LOcf/jp7j3J88ydmmGgMGmNu9as95ko0bNSigZqePAYIrru2JaRkNERDaccp0T+hRQDzzoJzWPOufea2bdwOecc693zv3IzO4Ffop3SvRf8E9nlpOZ8aUfPs3U3CKvuK6F7d0xnVorsfZYPQcHvfqlSopFRGSjsuXPNFa3AwcOuMceK96g2zMXL3PPY88oQSix3mQjh4ZSDLQ0lTsUERGRgjGznzjnDly5XUNAa9CmhWdLxgyG25o5OJikK641zkREpHYoSZOKpDXORESk1ilJk4oSChg7emLsH0hpjTMREalpStKkIoRDAXb3Jtjbn6CpXm9LERERfRtKWUXCQfb0Jdjdl1BFBhERkRxK0qQsog0h9g8k2dkTpy4YKHc4IiIiFUdJmpSUFqAVERHJj5I0KYm2aD2HhrQArYiISL6UpElR9SQaOTiUYqhVC9CKiIhcCyVpUhQDLREODaXoTUbKHYqIiEhVUpImBWMG17U1c2goRUesodzhiIiIVDUlabJuXnWAKAcHk7SoOoCIiEhBKEmTNQsFjO3dMQ4MpIhHVB1ARESkkJSkyTULhwLs6omzbyBJs6oDiIiIFIW+YSVvDXVBdvfF2duXpDGs6gAiIiLFpCRNrioSDrJvIMkNvXHqQ0rORERESkFJmqxIpZtERETKR0mavEQiUsdBlW4SEREpKyVp8ryW5jAHB1Ns7YgSUHImIiJSVkrShPZYPTcOpbiuTXU1RUREKoWStBrWnWjg0FCL6mqKiIhUICVpNagvFeHGoRR9KdXVFBERqVRK0mrIUGsTh4ZSdCcayx2KiIiIXIWStA1uqej5jUMp2lX0XEREpGooSdugAmZs6Wjm0FBKRc9FRESqkJK0DSYYMLZ1Rjk0lCIRCZc7HBEREVkjJWkbRChg7OiJsX8gRbyxrtzhiIiIyDopSatydUFjZ0+cA4MpmuvVnSIiIhuFvtWrVDgUYHdvgn0DCSJhdaOIiMhGo2/3KlNfF2BPX4J9/Uka6oLlDkdERESKRElalWgMB9nXn2R3X5z6kJIzERGRjU5JWoVrqg+yfyDJrp4E4VCg3OGIiIhIiShJq1DRhpCfnMUJBZWciYiI1BolaRUm1ljHwcEkO7rjBANW7nBERESkTJSkVYhEpI6Dgymu74opORMRERElaeWWagpzcDDFts4oASVnIiIi4lOSViatzWEODbWwpaMZMyVnIiIi8mJK0kqsLVrPTcMprmtTciYiIiIrU5JWIp3xBg4NecmZiIiIyNUoSSuy7kQDh4ZaGGptKncoIiIiUkWUpBVJT7KRm4Za6G+JlDsUERERqUJK0gqsLxXhxqEUfSklZyIiIrJ2StIKZKAlwo3DLfQkGssdioiIiGwAStLWaai1iRuHU3TFlZyJiIhI4ShJW6PhtiZuGm6hI9ZQ7lBERERkA1KStgYNdUHu2NNT7jBERERkAwuUOwAREREReSklaSIiIiIVSEmaiIiISAVSkiYiIiJSgZSkiYiIiFQgJWkiIiIiFUhJmoiIiEgFUpImIiIiUoGUpImIiIhUoLIkaWb2CTP7hZn93My+aWaJFfb7oJmNmtlhM/v3pY5TREREpFzKNZL2ILDTOXcDcBT4yJU7mNlO4N3AIWA38AYz21zSKEVERETKpCxJmnPuu865Rf/uo0DvMrtdDzzqnLvs7/sD4M2lilFERESknCrhmrR3At9ZZvsocLOZtZhZBHg90FfSyERERETKJFSsA5vZ94DOZR662zn3LX+fu4FF4CtX7uScO2JmH8c7NToFPO7vu9L/9x7gPQD9/f3rjl9ERESknMw5V57/2OxtwHuB25xzl/PY/0+AZ51zn85j33PA0+uPclWtwPki/x+VqpbbDrXd/lpuO9R2+9X22lXL7S9V2wecc21XbixLkmZmrwP+HLjFOXdulf3anXPjZtYPfBd4mXPuuVLFuRoze8w5d6DccZRDLbcdarv9tdx2qO32q+212Xao7faXu+3luibtU0AUeNDMfmZmnwEws24z+/uc/b5hZk8A9wPvr5QETURERKTYinZN2mqcc5tW2H4Kb4LA0v1XliwoERERkQpSCbM7q9Vnyx1AGdVy26G221/LbYfabr/aXrtquf1lbXvZJg6IiIiIyMo0kiYiIiJSgZSkrcLMfsuvG5o1sxVnd5jZ68zsSTM7bmYfztk+ZGY/MrNjZvZ1MwuXJvL1M7OUmT3ox/6gmSWX2efV/sSPpZ9ZM3uT/9gXzeypnMf2lL4Va5dP+/39MjltvC9n+0bv+z1m9kP/8/FzM/udnMeqru9X+gznPF7v9+Nxv18Hcx77iL/9STN7bSnjLoQ82v6HZvaE388PmdlAzmPLvv+rSR7tf7uZnctp5+/nPPY2/3NyzF9Wqqrk0fZP5rT7qJldynmsqvvezD5vZuNmNrrC42Zmf+G/Nj83s305j5Wu351z+lnhB6801VbgEeDACvsEgRPAMBDGW3R3u//Y3wJ3+bc/A7yv3G26hrb/KfBh//aHgY9fZf8UcBGI+Pe/CNxZ7nYUu/3A1ArbN3TfA1uAzf7tbuA0kKjGvl/tM5yzz78DPuPfvgv4un97u79/PTDkHydY7jYVuO2vzvlcv2+p7f79Zd//1fKTZ/vfDnxqmeemgJP+v0n/drLcbSpk26/Y/w+Az2+gvr8Z2AeMrvD46/GqIRlwE/CjcvS7RtJW4Zw74px78iq7HQKOO+dOOufmga8Bd5iZAbcC9/r7/TXwpuJFW3B34MUM+cV+J/Adl8fCxFXiWtv/vFroe+fcUefcMf/2KWAceMlCjFVi2c/wFfvkvib3Arf5/XwH8DXn3Jxz7inguH+8anHVtjvnvp/zuV6p1nK1yqfvV/Ja4EHn3EXnLQ/1IPC6IsVZDNfa9t8FvlqSyErAOfcPeAMLK7kD+JLzPAokzKyLEve7krT16wGeybn/rL+tBbjkXigkv7S9WnQ4504D+P+2X2X/u3jpB/hj/jDxJ82svhhBFlG+7W8ws8fM7NGlU73UWN+b2SG8v8RP5Gyupr5f6TO87D5+v6bx+jmf51aya43/Xby41vJy7/9qkm/7f9N/P99rZks1pGum7/1T3EPAwzmbq73vr2al16ek/V6WddIqieVRY/Rqh1hmm1tle8VYre3XeJwuYBfwQM7mjwBn8L68Pwv8EfBf1hZpcRSo/f3OuVNmNgw8bGYjwMQy+23kvv8y8DbnXNbfXPF9f4V8PqtV+zm/irzjN7O3AAeAW3I2v+T975w7sdzzK1Q+7b8f+Kpzbs7M3os3onprns+tZNcS/13Avc65TM62au/7q6mIz3zNJ2nOudvXeYhngb6c+73AKbxaXwkzC/l/eS9trxirtd3MzppZl3PutP9FPL7KoX4b+KZzbiHn2Kf9m3Nm9gXgPxQk6AIqRPv9U304506a2SPAXuAb1EDfm1kM+DbwUf90wNKxK77vr7DSZ3i5fZ41sxAQxztVks9zK1le8ZvZ7XgJ/C3Oubml7Su8/6vpi/qq7XfOXci5+7+Aj+c891VXPPeRgkdYPNfy3r0LeH/uhg3Q91ez0utT0n7X6c71+zGw2bzZfGG8N/N9zrvC8Pt412oBvA3IZ2SuUtyHFzNcPfaXXKvgf7kvXZ/1JmDZGTQV7KrtN7Pk0qk8M2sFXgE8UQt977/Xv4l3zcY9VzxWbX2/7Gf4in1yX5M7gYf9fr4PuMu82Z9DwGbgn0sUdyFcte1mthf4n8AbnXPjOduXff+XLPLCyKf9XTl33wgc8W8/ALzGfx2SwGt48dmESpfP+x4z24p3gfwPc7ZthL6/mvuAt/qzPG8C0v4foKXt92LNSNgIP8Cb8bLmOeAs8IC/vRv4+5z9Xg8cxfsr4u6c7cN4v7CPA/cA9eVu0zW0vQV4CDjm/5vytx8APpez3yAwBgSueP7DwAjeF/TfAM3lblOh2w+83G/j4/6/76qVvgfeAiwAP8v52VOtfb/cZxjvFO0b/dsNfj8e9/t1OOe5d/vPexL4jXK3pQht/57/+2+pn+/zt6/4/q+mnzza/1+Bw347vw9sy3nuO/33xHHgHeVuS6Hb7t//Y+C/XfG8qu97vIGF0/7vsWfxrrd8L/Be/3ED/of/2oyQs8JDKftdFQdEREREKpBOd4qIiIhUICVpIiIiIhVISZqIiIhIBVKSJiIiIlKBlKSJiIiIVCAlaSIiIiIVSEmaiFQ8M7vbzA779RN/ZmY3XuPzB83sqovqmlmXmf1v//arlm5XCjP7mpltLnccIlIaNV8WSkQqm5m9DHgDsM959RNb8eqCFsMf4pX+qVR/Cfwn4N3lDkREik8jaSJS6bqA886vGemcO++8ws4HzeyfzOxxM/tnM4v6I2b/aGY/9X9efuXBzCxoZp8wsx/7I3P/Nufh3wT+zzLP+WMz+7yZPWJmJ83sAzmPvdU/zuNm9mV/24CZPeRvf8jM+v3tXzSzvzSz7/vHucU/7hEz+2LOMV9jZj/023CPmTX7D/0jcLtfP1RENjglaSJS6b4L9JnZUTP7tJ/YhIGvAx90zu0Gbgdm8IrB/7pzbh/wO8BfLHO8d+HV4TsIHATe7dcvHAKeczkFxK+wDXgtcAj4z2ZWZ2Y78MpC3erH8UF/30/h1TW9AfjKFXEkgVuBDwH3A58EdgC7zGyPP1L4UeB2vx2P4Y3w4ZzL4pWi2Z3/yyci1Up/jYlIRXPOTZnZfuCVwKvxkrOPAaedcz/295kAMLMm4FNmtgfIAFuWOeRrgBvM7E7/fhyvMPoUcG6VUL7tJ3BzZjYOdOAlW/c65877cVz0930Z8K/9218G/jTnOPc755yZjQBnnXMjfuyH8Wrh9gLbgf/n1agnTE5xa7xEtBv4ySqxisgGoCRNRCqecy4DPAI84ic37weWKzz8Ibxi4LvxzhTMLrOPAX/gnHvgRRvN9uIVUl9J7ghbBu/3p60Qx0uasMxxslccM+sfMwM86Jz73RWO1YA3aigiG5xOd4pIRTOzrVfMaNwDHAG6zeygv0/Uv04rjjfClgX+DRBc5pAPAO8zszr/uVv8EbijeCNZ1+Ih4LfNrMU/Vsrf/k/AXf7t3wP+7zUc81HgFWa2yT9mxMxyRwS3AIevMU4RqUIaSRORStcM/HczSwCLeNdkvQf4gr+9EW9k6Xbg08A3zOy3gO8D08sc73N4ydhPzTufeA54k3MubWYnzGyTc+54PoE55w6b2ceAH5hZBvgX4O3AB4DPm9l/9I//jnwb65w7Z2ZvB75qZvX+5o8CR82sA5hxzp3O93giUr3MuXxG6kVENj4zezOw3zn30XLHshwz+xAw4Zz7q3LHIiLFp5E0ERGfc+6bS6cuK9QlvIkIIlIDNJImIiIiUoE0cUBERESkAilJExEREalAStJEREREKpCSNBEREZEKpCRNREREpAL9f2goXp7v1mfDAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -1138,7 +1582,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 40, "metadata": {}, "outputs": [], "source": [ @@ -1148,7 +1592,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 41, "metadata": {}, "outputs": [], "source": [ @@ -1183,7 +1627,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 42, "metadata": {}, "outputs": [], "source": [ @@ -1203,18 +1647,9 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 43, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\vasy\\documents\\econml\\econml\\utilities.py:942: UserWarning: Co-variance matrix is undertermined. Inference will be invalid!\n", - " warnings.warn(\"Co-variance matrix is undertermined. Inference will be invalid!\")\n" - ] - } - ], + "outputs": [], "source": [ "est = LinearDMLCateEstimator(model_y=MultiTaskElasticNetCV(cv=3, tol=1, selection='random'),\n", " model_t=MultiTaskElasticNetCV(cv=3),\n", @@ -1233,12 +1668,12 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 44, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABCwAAAKUCAYAAADPW6myAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeZyN9fvH8ddlqbGLRLLLbhZLdoYsiaypRDRKC1K00ip966dkqVSi0KKNIqVUskShbGXfUhFFyr6O+fz+uM+cjjEzZsaMc8a8n4/HeXDucy/XfZ9zrnvu63w+n9ucc4iIiIiIiIiIhJJswQ5ARERERERERCQhFSxEREREREREJOSoYCEiIiIiIiIiIUcFCxEREREREREJOSpYiIiIiIiIiEjIUcFCREREREREREKOChYiInJOmFkrM/vCzPaY2VEz22hmz5rZRcGOLaOZ2a9m9k4al3VmNiSdQ0pue5N820zsMT3BfL9mwPYLmtkQM6uZyGvzzGxeKtc3xMxcwPMk1x+KzKyM79j3DnYsIiIi51qOYAcgIiLnPzN7GHgamA70Bv4BagEPAdeaWTPn3LYghhjK6gPbz/E2dwPtE5n+zznYdkHgCbx9Xp7gtb5pWN/rwKwUrl9ERERCiAoWIiKSocysGfA/YLRzbmDAS/PNbBqwDHgLaJbMOrID5pyLzdBgQ5BzbnEQNns8SNtNlnNubRqW2c65L/iIiIhIOlCXEBERyWgP4v0yPzjhC865rcAwoKmZ1Y2f7msC/7SZDTKzrcBxINzMwsxslJmtNrODZvanmX1qZpUD12tmMb511DOzyWa238x2mNmLZhaWYN5yZva5mR02s11mNsLMbvctXybBvLeZ2U++Li1/m9kbZlYotQckIL6E6z+l+0LAsRiSYFqkmU3zda85YmYbzGxwgnk6m9li337tNbMpZlYqtbGmhpk9aWbLzWyf7/jMMbN6CebJa2YvmdnvZnbMzP4ys9lmVtl3PLb6Zh0f0BUlxrfsaV1CzKyImb1iZtt869tmZm+b2YW+1/3HNLn1m9kYXyw5E4n3gJn9XxL7fKGZ/WNmIxJ57Qbf+qN8z68ws69979thM/vFzF5J+RH2r3eIb70VzGym77vwm5k9bmbZEsyb7PHxzdPazBb5Pkv7zGy6mVVKsJ55ZrbQN+9K37wrzKyumeUws2fMbKfvWEwyszwJls9tXhewrWZ23PfvIwnjFRERCaSThIiIZBgzywFEA187544mMdsM379XJpgeA7QF7vf9uwO4EMiH12KjLdAHCAMWm1mxRNb9NrAF6Ay8CvQjoHBiZhcAXwOReN0NYoCywCOJ7Msw4BVgNl53iQeA1sAX5rUAOSfMrA6wCCgPDMQ7DiOBEgHz3Al8BKwFugB3ANXxWrXkS+F2ciTysDMsdhkwCuiIdyx3Ad+aWUTAPKOA64EngZbAncBKvK4aO/HeK4D/w+sOUx+YmUSMFwHfAzf4jkEbvAJZTuCCRBZJbv2vAJcAnRIs0x3IA4xPLAbn3DHgQ6BbIp+Dm4DVzrmVZpYX+BI4iXds2gBDObvWrtOAOXjHezreMb05/sWUHB8za423/wd98/XB+6wsNLPLEmzvcmA4XpHxOrzv4wy879alvv0ainfMngiII4dv33sDLwBX43XVecy3PhERkcQ55/TQQw899NAjQx5AUcAB/5fMPGG+eV4JmObwChS5zrD+7EBu4AAwMGB6jG8dTyaY/zNgY8Dz233z1QmYZsBPvullfNPK4F1oPp5gfQ1983U8Q5y/Au8kEl+ZBPMN8U7Np0xzwJCA598C24DcSWwrL7APmJBgehm8lioDzhDrJN82E3vcn2C+X8/w3uQANgAvBExfDYxMZrkyvm31TuS1ecC8gOdDfe9LjWTWd8oxTcH6v0kwbTkw6wzHLP5zcFXAtCLACeBB3/PavnkiUvkdOi3e+H0CeiWYdxXwVSqPz1JgE5AjYFpZX+wjA6bN800rFzCtvS+O2QnW+TGwNeB5D998TRLM94jvM3lJao6JHnrooYceWeehFhYiIpKRzvSLfHJmOeeOnLZCs+vNbImZ7QVigUN4F+mVEs7L6b/MrwICu0XUA353zv0QP8E55/BaJwRqidcqcXJgiwNgCbAfaJK6XUsbM8uNd3E82Tl3OInZ6gP5E4l1O7A+hbHuAq5I5PH2GeJrYWZzzWwP3ntzAqjIqe/Nj0CMmT1sZrXPsnVKK+BH59yKs1hHoFeAZmZWAbwuHEAN4LXkFnLOfYfXkqdHwOSu+D4zvuebgL3Aa2Z2k5mVTId4E36+V3Pq5zvZ4+PrtlET+MAFjA/jvK5a3+G1jgq00Tn3S8Dz9b5/v0ww33qgRECLnNbAb8D3CT6TX+G19qiHiIhIIlSwEBGRjPQ3cATvV+KkxL+W8C4hOxPOaGbtgA+AdUA3oC7ehfRuvJYaCSW8q8UxvGbs8S7FuzhP6K8Ezy/x/bsZ7yI88JEfKJzIOjLCRXjn7uQGkYyPdTanxxpOymI94Zxbmsgj4XHxM+82oZ/jdS24Fe8i9Aq81iqB701/vALALXjFi13mjUuSOwVxJVSY9B1QcxrwJ14XGvC6q+wAPk3Bsu8AHX1dP8ArXsxxzv0B4Jzbhzew7A68wsjv5o3Fcu1ZxJvY5zvwWJ/p+FyEV1Q87buGdxwSjs/yb4Lnx5OZngOvlQ14n8nSnP55jC8Unqvvj4iIZDK6S4iIiGQY51ysmX0LtDSzMJf4OBbxt8+ck3DxRObtCmx2zsXET/ANkpjqgS99dgJVE5leNMHzPb5/W3H6xVng6ykVfxwSjrNwpgu3f4E4vLEikhIfSwywJpHXD5wpuDS6Fq9VRWfn3In4ib5xFPbGP3fOHcQbR2SwmZXGG2NjGN5F7kOp3ObfJH8sUsU5d8LMXgf6mtlzeJ+3ES5ld6d5G2/chk5mtgSvWHNz4AzOuZV4t/HNgddFZDDwoZlFOudWp9d+BDjT8fkX73uW2PgvxUj95zope/AGO70+idd/TaftiIjIeUYtLEREJKMNx7sQfybhC2ZWFu8i9Vvn3JIUrCs33kVxoB7890tuai0GSvkGsoyPyfAuvgN9jVcoKJVEy4OtpM5vvn+rB2w3B15BJEm+biALgZvMLFcSs32PV5S4PIlYN6Qy1pTKjTdegr/QZGZXcmoXhVM4535zzo3A66oTfyyO+f5Nav8CfQXUMbPIVMR5pvW/BhQApuC1xkl0sM2EnHNb8AZD7eF7HMIbyyGxeWOdd9vYx/D+FquS0uBTKdnj45w7hHdb4esCu+b4CkkNgPnpFMcsoCRwMInP5N/ptB0RETnPqIWFiIhkKOfcN2b2ODDUvNtKvoX3y25NYBDeAJE9klzBqWbhNbsfhTeAZi3gbgJ+wU+lSXgFk4/N7BG8riW98ZrKg1ekwDm3xcyeBcb4bvc4H6+VREm88S1ed87NPcO2AluM/Ig35sFw320dj+HdpeTCxBZM4H7f9heZdyvN7UA5IMo51985t9/MHgBeNrMiwBd4x/gyvDEJ5jnn3j3DNi6wBLcj9TnsnPs5iWVmAQOASWY2EW/siseAPwJnMrNFeHeWWIXXfSQa7y4tb/pm+QvvF/muZvYz3oX/VudcYr/2j8LrGjTbzP7nW+fFQAfgTudcYq1Jkl2/c+4PM/sU724hnzrnEnZVSs5bwMt4XW+m+VqTxO/3NXiDvE7Ha22QB++zewCv0JERUnJ8HsMbC+Mz826xmhfvbiP7gNNu1ZpGk4FewDe+z+xPeK2LyuO1sOqYzJgsIiKShamFhYiIZDjn3FN4tzLMA0zE++W3L94FXm3n3O8pXNV44Gm82y9+indLz3Z4F1dpies4XquGn4GxeBfN2/AuOglcr3PuYbwLziZ4t7H8BK/Y8S/egIrJycV/v+zj62LQwbetSb7tfe37/5li/hFv4M1twEt440Y8QMBYBc651/AuBCvhdVX4Au8iNAfeLUTPpAjeRXTCR5KFDufcl3gX4A3xikm3AD3xxv0I9C1e14DJeBfKXfDu8PKCbz1x/Fc0mo1X3GmXxDb3+rY3Da/4NQvvIjuW/8ZXSLhMStY/xfdvsoNtJuID37aLcfoApZvwxnN5DO/9mOibt6VzLj3H4fBLyfFxzs3C+x4VxPtcj8UbI6aRc25HOsVxArgK7/t7O95ndjJel5nvSeK9EhERMW8wdBEREYlnZp8BVZxz5dNhXRfhtdwY4pz731kHJxnOzCbjXeiX8xU4REREJAjUJURERLI0M7sXr2vCJiAfcB3eL859znK9+YE6eHeagCTGM5DQ4esGE4XXgudeFStERESCSwULERHJ6o4BA/EGh8wObAB6O+feOMv11sTrtrIOaO+cW3uW65OMtwivePUm3q1HRUREJIjUJUREREREREREQo4G3RQRERERERGRkKOChYiIiIiIiIiEHBUsRERERERERCTkqGAhIiIiIiIiIiFHBQsRERERERERCTkqWIiIiIiIiIhIyFHBQkRERERERERCjgoWIiIiIiIiIhJyVLAQERERERERkZCjgoWIiIiIiIiIhBwVLEREREREREQk5KhgISIiIiIiIiIhRwULEREREREREQk5KliIiIiIiIiISMhRwUJEREREREREQo4KFiIiIiIiIiISclSwEBEREREREZGQo4KFiIiIiIiIiIQcFSxEREREREREJOSoYCEiIiIiIiIiIUcFCxEREREREREJOSpYiIiIiIiIiEjIUcFCREREREREREKOChYiIiIiIiIiEnJUsBARERERERGRkKOChYiIiIiIiIiEHBUsRERERERERCTkqGAhIiIiIiIiIiFHBQsRERERERERCTkqWIiIiIiIiIhIyFHBQkRERERERERCjgoWIiIiIiIiIhJyVLAQERERERERkZCjgoWIiIiIiIiIhBwVLEREREREREQk5KhgISIiIiIiIiIhRwULEREREREREQk5KliIiIiIiIiISMhRwUJEREREREREQo4KFiIiIiIiIiISclSwEBEREREREZGQo4KFiIiIiIiIiIQcFSxEREREREREJOSoYCEiIiIiIiIiIUcFCxEREREREREJOSpYiIiIiIiIiEjIUcFCREREREREREKOChYiIiIiIiIiEnJUsBARERERERGRkKOChYiIiIiIiIiEHBUsRERERERERCTkqGAhIiIiIiIiIiFHBQsRERERERERCTkqWIiIiIiIiIhIyFHBQkRERERERERCTo5gB3AuXHzxxa5MmTLBDkNE5BTLli372zlXJNhxnAvKwyISqpSLRUSCK7k8nCUKFmXKlGHp0qXBDkNE5BRm9luwYzhXlIdFJFQpF4uIBFdyeVhdQkREREREREQk5KhgISIiIiIiIiIhRwULEREREREREQk5WWIMi8ScOHGC7du3c/To0WCHIpLphYWFUaJECXLmzBnsUERCls47IsGlc5WkhnK2SPpLSx7OsgWL7du3ky9fPsqUKYOZBTsckUzLOceePXvYvn07ZcuWDXY4QbHxrwMcOxFHeIkCwQ7l/LL5GyhaDfIVC3Yk6ULnHZHg0bkqbQ4eP8iSP5dwZckrs1zeUs4WSV9pzcNZtkvI0aNHKVy4sBKQyFkyMwoXLpwlf4HYue8ID079idajv+WZz9cFO5zzS+wx+Ph2eLEGzHkajh0IdkRnTecdkeDJyueqs/HRpo8YMHcAPb7owfK/lgc7nHNKOVskfaU1D2fZggWgBCSSTrLad2nfkRMM+2I9TYfPY/qKHfRqWJZXutcMdljnlxwXwq1fQYVW8O1z8EIULHkNYo8HO7KzktW+KyKhRN+/1OtepTtP1H+CHQd3cPOsm+k/pz9b9m4JdljnjD4zIukrLd+pLNslREQktY6eOMnbi35jzNzN7D96go5Rl3Fvy4qULJQ72KGdnwqXh+vfhO3LYPYT8MWDsPgVuPIxqNYZsmXpmruISIbLkS0HXSp2oW25tryz9h0mrJ5A5xmd6Xh5R/pG9qVonqLBDlFEznP6ay+Itm/fTocOHahQoQLly5fnnnvu4fhx79fDefPmcc0115y2zLx58yhQoABRUVH+x+zZswHImzdvmuIYPXo0hw8f9j9v06YNe/fuTXL+sWPH8tZbbwEwadIkduzYkeJtderUiaioKC6//PJT9uP7779PU+yBpk2bxvDhw896Pam1fPlyZs2aleL5P//8c/9+582bl0qVKhEVFUWvXr3SJZ4WLVpw5MiRdFmXeE7GOT5atp3mI+bz9OfriCxZkM/6N2LUDVEqVpwLJWrBzZ9C96mQMw98dCuMbwa/zA92ZJlOVjzvADRt2pRSpUrhnPNP69ixoz/+HTt20KVLl1StM9D06dNZu3ZtmpdPi8BjEujXX3+levXqiU5/9913U7z+VatW+d/vQoUKUbZsWaKiomjRosVZxR2vV69ebNiwIV3WJRkvV45c3BZxG593/pxulbsxY8sM2k5ry+hlo9l/fH+wwztvZeWcXalSJSIiIqhcuTJ33XVXsttLjRkzZjBs2LBk50nJOaFMmTL8/fffqd5+ao9Hv379iIqKomrVquTKlcv/nk6dOjXV205oyZIlDBw48KzXk+Gcc+f9o1atWi6htWvXnjbtXIqLi3NXXHGFmzBhgnPOudjYWHfLLbe4+++/3znn3Ny5c13btm1PWy6p6c45lydPnjTFUrp0abd79+40LRsdHe1+/PHHVC+X3H4459yJEyfSFE8wjB8/3t1zzz1pWrZhw4ZuxYoVib6WmY6Bc8H/TmWEuLg4N3f9X+6qUfNd6Yc+c9e8uMAt3JS270pigKUuBHLkuXgklofT5GSscyvedW5EVeeeyO/cW52c2/FT+qw7gwX7O5KVzzvR0dEuPDzcLViwwDnn3L///uvq1KmT5vgTuvnmm92UKVPSZV1na+vWra5atWqnTT/TeTc5ye3f+XCuUi5OvW37t7mHvn3IVZ9U3TV8r6GbtHqSOxZ7LF3WHSqUs/8TjJwdv8yxY8fcvffe65o0aZKm7WeUtB6TtF47JZXb42WmXJzaPKwWFkEyZ84cwsLC/L+qZ8+enVGjRjFhwoRTKphpcfDgQZo3b07NmjUJDw/nk08+AeDQoUO0bduWyMhIqlevzgcffMCLL77Ijh07aNasGc2aNQNOrRi+9dZbREREEBkZSY8ePQAYMmQIzz//PFOnTmXp0qV0796dqKgoZs6cSadOnfxxfP3113Tu3DnFcZcoUYKnnnqKhg0bMm3aNJYvX07dunWJiIjg2muvZd++fQA0atSIAQMGUL9+fcLDw1m6dCkAr7/+OgMGDADgzz//pEOHDv7YlyxZAkC7du2oVasW1apV4/XXXwcgNjaWggULMmjQICIjI6lfvz67du0C4JNPPqFu3brUqFGDVq1a+afHO3LkCEOHDmXy5Mn+aufff/9N+/btiYiIoEGDBqxevTrFx2Ds2LF069aNtm3bcs011xAXF8eAAQOoXr06ERERTJs2DYBZs2bRvHlzOnToQJUqVbj77rvxvutQrFgxDh48CMAbb7xBeHg4kZGR9O7dG4CPP/6YunXrEhUVRevWrf3v9aBBg7jtttto0qQJ5cqVY+zYsf642rRp4z9ukyZNSvH+ZGY/b99Lt/FLiJn4I4ePn+TFG2vwSb+GNLz84mCHlrVlyw5RN0L/ZdDyKfhjGbzWxBug89/fgh1dSMvq552uXbvy/vvvA14eDJwvsFXCpEmT6Ny5M61bt6ZChQo8+OCD/vkCf52cOnUqMTExfP/998yYMYMHHniAqKgotmzZwpYtW2jdujW1atWicePGrF+//rR4Jk2aRMeOHWnXrh1ly5ZlzJgxjBw5kho1alCvXj3++ecfAMaPH88VV1xBZGQk1157rf+9ij8mAMuWLfOfv15++eVE93/QoEEsWLCAqKgoRo0axdGjR+nVqxfh4eHUqFGDuXPnJv7mJmL27Nm0aNGCrl27UqNGDQCee+45qlevTvXq1XnppZcA2Lx5M9WqVaNHjx6Eh4dz/fXX+1sANmrUiJUrVwIwc+ZMatasSWRkJK1atQJg8eLF1K9fnxo1atCwYUM2bdoEeOf6Ll26cNVVV1GhQgUGDx7sj+v222+ndu3aVKtWjaFDh6Z4fyT1SuQrwbDGw/jwmg+pVrgazy99nnbT2vHplk+Jc3HBDu+8kNVzdrwLLriA5557jt9//52ffvoJgJEjR/rzzejRowEvj1euXJnevXtTvXp1unfvzuzZs2nYsCEVKlTghx9+ALzce9dddwEQExPD3XffTYMGDShXrpy/1ULgOeHkyZPcf//9hIeHExER4c9v8Y4cOULr1q0ZP358oscvUMLjceTIEb755htq1KhBeHg4t9xyC8eOHUvx+9ioUSMeeeQRmjRpwpgxY9i6dSvNmjUjIiKCli1bsn37dgBuuukm+vTpQ+PGjalYsSJffPEF4OXyjh07AnDgwAFuvvlm/35Onz4dSDqvlihRgiFDhlCjRg0iIiLYuHEjkHTuPhsawwJ48tM1rN2Rvs3ZqhbPzxPtqiX5+po1a6hVq9Yp0/Lnz0+pUqXYvHlzsuuO/4Mj3kcffUT58uX9z8PCwpg2bRr58+fn77//pl69erRv355Zs2ZRvHhxZs6cCcC+ffsoUKAAI0eOZO7cuVx88akXYmvWrOHpp5/mu+++4+KLL/b/8RSvS5cujBkzhueff57atWvjnOO+++5j9+7dFClShIkTJ6a6m0OePHn47rvvAKhatSrjxo2jUaNGPPzwwzz11FP+P86OHTvGokWLmDNnDr179/b/0ROvX79+tGzZkrvuuovY2Fh/Yn/zzTcpVKgQhw8fpnbt2lx77bXky5ePffv2ER0dzbBhw7j33nuZMGECgwYNokmTJrRv3x4zY+zYsYwYMYJnn33Wv51cuXLx+OOPs3r1an/C7NOnD3Xr1mXGjBl89dVXxMTE+IsqKbFo0SJWrFhBwYIFmTx5Mps3b+bnn3/mzz//pE6dOjRu3BjwEsK6desoXrw4zZs3Z+bMmac0DVy+fDkjRozgu+++46KLLvK/f02bNqVTp06YGWPGjGHUqFE8/fTTAGzatIlvvvmGPXv2UL16de644w7MjHfeeYdChQpx6NAhateuTefOncmfP3+q3tvM4te/DzH8qw3M/HknhfJcwJB2VelWtzQX5Dj/6rtm1hp4AcgOvO6cG5bg9TuBfsBJ4CBwu3NurZmVAdYB8e25Fzvn7jxXcQOQMwwa3g01e8DCUd6AnGumwRW3QZP7IXehcxpOqn0xCP5clb7rLBYOVyfdzDWrn3eaN2/ObbfdxsmTJ3n//fcZN24cTz31VKLzrly5khUrVnDhhRdSqVIl+vfvT8mSJROdt0GDBrRv355rrrnG34S4efPmjB07lgoVKrBkyRL69u3LnDlzTlt29erVrFixgqNHj3L55Zfz7LPPsmLFCgYOHMhbb73FgAED6Ny5M7fddhsAjz76KG+88Qb9+/c/ZT29evXipZdeIjo6mgceeCDROIcNG8bzzz/PZ599BsCIESMAr+vH+vXradWqFRs3biQsLCzR5RNavHgxa9eupVSpUvzwww9MnjyZH374gZMnT1KnTh2io6PJnTs3a9eu5Y033qBevXr07NmT1157zf/jAng/MPTp04cFCxZQunRp/3tepUoVFi5cSPbs2Zk1axaPPvqo/4//n376ieXLl5MjRw4qVqxI//79KV68OMOGDaNQoULExsbSrFkzunTpQtWqVVO0P5I2VQpX4bWWr7FoxyJGLRvFwwsf5s01bzKg1gAaFm943gxa+ewPz7L+n9MLj2ejcqHKPFTnoSRfz+o5O1D27NmJjIxk/fr1xMbGMnHiRJYsWYJzjrp16xIdHc1FF13E5s2bmTJlCuPGjeOKK67g3XffZeHChcyYMYNnnnnGfxEeaOfOnSxcuJD169fTvn3707qCjBs3jq1bt7JixQpy5Mhxyj4ePHiQrl270rNnT3r27MlHH3102vFL7ngcPXqUmJgYvvnmGypWrEjPnj159dVXT8mRZ7J//36+/fZbAK6++mp69+5N9+7dGTduHAMGDPAXYbZt28b8+fPZtGkTLVq0OO0zNGTIEIoUKcKqVatwzvm74CSXV4sWLcqKFSt48cUXGTlyJGPHjk02d6fV+fcXeCbhnEs0iSc1PVDjxo1ZuXKl/xGYgOLX8fDDDxMREUGLFi34448/+OuvvwgPD2f27Nk89NBDLFiwgAIFCiS7nTlz5tClSxd/cipUKPkLADOjR48evPPOO+zdu5dFixZx9dVXJ7tMQjfccAMAe/bs4ejRozRq1AiAm2++2f9lBLjxxhsBuPLKK9m1a5e/RUG8efPmcccddwCQI0cO/8X1qFGj/L9Cbd++nS1bvJGuc+XK5Y+1Vq1a/PrrrwD8/vvvtGrVivDwcEaOHMmaNWvOuA8LFy70V5hbtWrFjh07OHToUIqPQevWrSlYsKB/Xd26dSNbtmwUL16c+vXrs3y5d1uxhg0bUqpUKXLkyMENN9zAwoULT1nPN998w4033shFF10E/Pf+/fbbb7Rs2ZLw8HBeeOGFU/apXbt25MyZk2LFipEvXz727NmDc44RI0YQGRlJgwYN2L59O7/88kuK9yez+PvgMR7/ZDUtRs5n7vpd3N28AvMfaEpMw7Lna7EiO/AycDVQFbjRzBL+Zf+ucy7cORcFPAeMDHhti3Muyvc4t8WKQLkugpZDvRYXEdfDklfhhUhYMAKOn90vUOebrH7eyZ49O40aNeKDDz7gyJEjlClTJsn1Nm/enAIFChAWFkbVqlX57beUt945ePAg33//Pddddx1RUVHccccd7Ny5M9F5mzVrRr58+ShSpAgFChSgXbt2AISHh/vPQ6tXr6Zx48aEh4czefLk085D+/btY+/evURHRwP4zz9nEniuqly5MqVLl/b/QpYS9evXp1SpUoB3cXTttdeSO3du8uXLR8eOHf3npLJly1KvXj3A+5Uv4blq0aJFNGvWjNKlSwP/ved79+6lc+fOVK9enfvvv/+U/W7RogX58uUjV65cVK5cmd9//x2A9957j5o1a1KzZk3WrVt3zrK3EosAACAASURBVMcVycrqF6/P+9e8z7ONn+XgiYP0md2H2766jTV/n/nvJklcVs/ZCcW3JF64cCGdOnUiT5485M2bl86dO7NgwQLAyzfh4eFky5aNatWq0bx5c8zslJyaUMeOHcmWLRtVq1blr7/+Ou312bNnc+edd5IjR47T9rFDhw706tWLnj17AqT6+G3YsIGyZctSsWJF4PTrnZTo2rWr//9LlizxP+/Zs6f/uABcf/31ZMuWjUqVKlGyZMnTWj7Mnj2bfv36Ad77FH/9kFxejW8dE3jtlFzuTiu1sIBkW0JklGrVqvHRRx+dMm3//v1s27aN8uXLs2fPnjSve/LkyezevZtly5aRM2dOypQpw9GjR6lYsSLLli3j888/Z/DgwbRq1YrHH388yfWkJCEm1KtXL9q1a0dYWBjXXXed/8udUnny5PFvOzkJ40oszoTTZs+ezbfffsvixYvJlSsXjRo18t8H+IILLvDPlz17dmJjYwGvpcbDDz9MmzZtmD179hkH6Uks9jPtS0Lxx+BMy57pGCT1/vXp04ehQ4fSqlUrZs2a5W8ZAnDhhRf6/x9/HL788ksWLVrEkiVLCAsLo169eufVfewPHYtl/IJfGP/tLxyNjaPrFSW5p0UFLsmXsl8ZM7E6wGbn3C8AZvY+0AHwn4mcc4FNz/IAqfswn0sFSkCHl6FeP/hmqPf4YTw0HQxR3SF7iJ3ukmkJkVF03vH+sOvUqRNDhgxJdp2J5UI4Nc8mlQfj4uIoWLDgaS3/zrSdbNmy+Z9ny5bNv82YmBimT59OZGQkkyZNYt68eaesIy3HLH65s5HR56pHHnmEq666ir59+7J582Zat27tfy2x92fTpk288MIL/PDDDxQsWJCbbropU5yrUtDS7V6gNxAL7AZucc79FvB6frwWb9Occ3eds8ATkc2y0aZcG1qWbsmHGz/ktZ9eo+vMrrQu05q7a9xNyfyJt1LKDJJrCZFRlLP/c/LkSVatWkWVKlWSLABDynJqcssklsuS28eGDRvyxRdf0K1bN8wsTcfvbAXm4uSkJRefKa/GH7vA82RyuTutQuZnQzMbbmbrzexnM5tmZgWTmG+gma0xs9Vm9p6ZZcqriubNm3P48GH/CLonT57kvvvuIyYmhty5z+6uA/v27eOSSy4hZ86czJ071//L0I4dO8idOzc33XQT999/v/+X+nz58nHgwIFEY/zwww/9CTFhM6/Eli1evDjFixfnf//7HzExMWneh4svvphcuXL57x7y9ttv+389AvxNi+bNm0fRokVP+7I2a9bMPwbDyZMn2b9/P/v27aNQoULkypWLNWvW8OOPP54xjn379nHZZZfhnOPNN99MdJ6Ex6BJkyZMnjwZ8IokJUqUSHEySahJkya89957xMXFsXPnThYvXuxvHvjdd9+xfft2YmNj+fDDD/2tUeK1aNGCd999l3///Rf47/1LyT4F2rdvH4ULFyYsLIxVq1b5PzeZ3YmTcby96Feih89l9OxNNKlYhK8HNuHpTuFZoVgBcBmwLeD5dt+0U5hZPzPbgtfC4u6Al8qa2Qozm29mjRPbgJndbmZLzWzp7t270zP2pBWtCt3eh5jPvSLGp3fDqw1g/UxIhz8MMjOdd7xfHQcPHuxvpZdaRYsWZd26dcTFxfnHFEoYU/78+SlbtixTpkwBvD8C4/tdp8WBAwe49NJLOXHihP/cEqhgwYIUKFDA33IhsXkSxginnqs2btzI77//TqVKldIUY5MmTZg2bRpHjhzh4MGDfPLJJ/7ui1u3bvWfb997773TzlUNGzZkzpw5/s9MwnMVkKKxk/bv30++fPnInz8/O3fu5Msvv0zTvpxLKWzptgKo7ZyLAKbi5eJATwEhdcuknNlz0r1Kdz7v/Dm3R9zO/O3zaT+9Pc8seYY9R9J+kZ3VKGd7Tpw4weDBgylZsiQRERE0adKE6dOnc/jwYQ4dOsS0adP8+SYjtGrVirFjx/ovyAP3cejQoRQuXJi+ffsCSR+/QIHHo3Llyvz666/+7hkJr3dSq169enz44YcAvPPOOzRp0sT/2pQpU3DOsXHjRrZt20aFChVO288xY8YA3nnr33//TVNeTW3uTomQKVgAXwPVfQl5IzA44QxmdhneH8y1nXPV8arRXRPOlxmYGdOmTWPKlClUqFCBihUrEhYWxjPPPAN4A0EGVvwCxfdLS+q2Nt27d2fp0qXUrl2byZMnU7lyZcDrp1qnTh2ioqJ4+umnefTRRwFvMJWrr77aP5BOvGrVqvHII48QHR1NZGQk995772mxxMTEcOedd/oHjonffsmSJc+63+jbb7/NwIEDiYiIYO3atf54wfuDsEGDBvTv35/x48eftuyYMWP48ssvCQ8Pp3bt2qxfv562bdty+PBhIiMjGTp0KHXr1j1jDEOGDKFTp05ER0dTtGji9xq/8sor+emnn6hRowZTp05l6NChfP/990RERPD4448zceLENB+Drl27Uq5cOSIiIrjqqqt48cUXKVy4MPDf4KPxg+O0adPmlGVr1qzJwIEDady4MZGRkQwaNAjwkus111xDdHQ0xYsXP2MM7dq1Y+/evURGRvL0009zxRVXpHl/QoFzjs9X7aTVqG957JM1lCuSl4/7NuDVm2pRrkjabveVSSX2c8FpV/TOuZedc+WBh4D4L+FOoJRzrgZwL/Cu71e+hMuOc87Vds7VLlKkSDqGngJlGsKtX8P1b4M7Ce93gwmt4fcl5zaOEKLzjncM7r///tP6YafUsGHDuOaaa7jyyiu59NJL/dO7du3K8OHDqVGjBlu2bGHy5Mm88cYbREZGUq1aNf+AdjNmzEj217bEPPXUU9StW5eWLVv6j2tCEydOpF+/ftSvX59cuXIlOk9ERAQ5cuQgMjKSUaNG0bdvX06ePEl4eDg33HADkyZNSvL9P5M6depw4403csUVV1CvXj369OlDeHg44L2n48ePJyIigkOHDnH77befsmzRokV59dVX6dChA5GRkXTv3h2Ahx56iAceeICGDRumKIaaNWtStWpVqlevzm233Zbi5YLM39LNOXcciG/p5uecm+uci+/fthgoEf+amdUCigJfnaN4UyXvBXnpX6M/MzvNpFOFTny44UPafNyGV396lcMn1GXvTLJ6zu7evTsRERFUr16dQ4cO+fNozZo1iYmJoU6dOtStW5fevXv7B//NCL1796ZUqVL+gUUT3h569OjRHD16lAcffDDJ4xco8Hg455g4cSLXXXedvyvLnXemvZftmDFjGDduHBEREXzwwQeMGjXK/9rll19OkyZNaNeuHePGjTuldTnAE088wV9//UX16tWJiopiwYIFacqrqc3dKZLU7UOC+QA6AZMTmR7/i2AhvO4snwGtzrS+ULyt6ZmMHj3aPfDAA8EOI0369evnXn/99Qxbf3K3As0qvvjiC3fttdcGO4xThPp3yjnnFm3523UYs9CVfugz12rkfDd77Z8uLi4uaPEQxFvpAfWBLwOeDwYGJzN/NmBfEq/NwyskpyoPnzOxx5378Q3nhlfwboX6Xjfndm0452GE+ndE5x1Jb5s2bXKRkZHBDuMUoXRbU6ALXjeQ+Oc9gDHJzD8GeNT9l5PnASWBmDMsdzuwFFhaqlSpdDqSqffL3l/cgDkDXPVJ1V30+9Hu/XXvu+MnjwctnjNRzs44ytnnVvfu3d20adOCHYZfavNwiHXq9bsFOG04UefcH2b2PPA7cAT4yjmXaFXZzG7HS9D+QaEyi1tvvZXVq1f7m/RkJrVq1SJPnjz+0cdFQsH6P/fz3KwNzFm/i0sLhDG8SwSda5Yge7bzY/TyNPoRqGBmZYE/8FqrdQucwcwqOOfiR2VqC2zyTS8C/OOcO2lm5YAKQOiOxJo9J9S+BSJugEWvwHcvwIZ63h1Gmg6GfMWCHWHQ6bwjEhQpaukGYGY3AbWB+PbifYHPnXPbzjSGgHNuHDAOoHbt2kHrG1e2QFlGNRvFT7t/YuTSkfxvyf94e93b3F3jblqWbnne3FHkXFDOlqzEvILGOdqY2Wwgsb8MH3HOfeKb5xG8hNzZJQjOzC4CPgJuAPYCU4Cpzrl3kttu7dq1XcLbSq5bt44qVaqkdVdEJIFQ/E79sfcII7/ayMcrtpPvwhz0a3Y5NzcoQ1jO7MEODQAzW+acqx3E7bcBRuN1r5vgnHvazIbiVblnmNkLQAvgBPAvcJdzbo2ZXQsMxRsE7iTwhHPu0+S2lVgeDppDf8O3w+HHN7xiRr2+3i1Sw5IfzftsheJ3RCSrSex7GKxcbGb1gSHOuat8zwcDOOf+L8F8LYCXgGjn3C7ftMlAYyAOyAtcALzinBuU3DZDJRc755i/fT6jl41my74tRFwcwcBaA6ldLGinxNMoZ4tkjNTm4XPawsI51yK5183sZuAaoHnCYoVPC2Crc263b/6PgQZAsgWLZOJRNVckHZzLwmdK7D18nFfnbWHi978CcFvjcvRtWp6CuS9IfsEsxjn3OfB5gmmPB/z/niSW+wiveJw55bkYrn4W6t4Bc56GBc/D0gkQ/aDXEiNH2vrxp4TOOyLBE2rnKlLW0q0G8BrQOr5YAeCc6x4wTwxet7xkixWhxMxoWrIpjS9rzIwtMxizcgy9vuxFkxJNGFBzABUuqnDmlZwDytki6SsteThkBt303dbpIaC9+29woYR+B+qZWW7zskdzvFs5pVpYWBh79uwJxZOXSKbinGPPnj2EhQX/zhpHT5xk7PwtNHluLuMW/MI1EZcy9/6mPNymiooVcrpC5aDLG3D7fLg0AmYNgjFXwM9TIC4u3Ten845I8ITSuSqecy4WuAv4Eu/v2Q99rdiGmll732zD8VpQTDGzlWY2I0jhZojs2bLTqUInZnaayYCaA1jx1wq6fNqFx757jD8P/RnU2JSzRdJXWvPwOe0Skhwz2wxcCMTf72ixc+5OMyuONyBRG998T+J1CYnFu9VTb+fcseTWnVjztxMnTrB9+/ZMcY9ukVAXFhZGiRIlyJkzZ1C2fzLO8dHy7Yz6eiM79x2lWaUiPHR1ZSoXO+3GFSEl2F1CzqVQaYacrC1z4Osn4M+foVgEtHwSyl+ZbqvXeUckuJI6VykXh459x/Yx/ufxvLv+XQyje5Xu3Bp+KwUuzNgue4lRzhZJf2nJwyFTsMhIoZ6cRSRtnHPM3bCLZ7/YwIa/DhBZsiCDWlemfvnCwQ4tRfRHcgiKi4PVU2HOU7D3dyjXFFo8CcWjgh2ZiGQQ5eLQs+PgDsasGMNnv3xG3gvyclv4bXSr0o0Ls2dclz0RCZ7k8nDIdAkREUmNldv20nXcYm6ZtJRjsSd5uVtNpvdtkGmKFRKismWDiOvhrqVw1TOw82cYFw0f9YZ/tgY7OhGRLKF43uI80/gZprSbQmSRSEYuG8k1065h+ubpnIw7GezwROQcSlPBwsyWmlk/3107RETOmV92H6Tv5GV0fPk7tuw+yFMdqvH1vdG0jbg0Sw6MpXycQXJcCPX7wT0rofF9sO4zb3yLLx7y7jIiIhJAuThjVCpUiVdbvMobrd6gcFhhHvvuMa777Dq+3f6txpYQySLS2sKiK1Ac+NHM3jezqywrXimIyDmz68BRHpm2ipajvmXeht0MaFGBeQ80o0f9MuTMnqUbiykfZ6SwAtD8cbh7BUR1gx/GwQtRMH84HD8U7OhEJHQoF2egOpfW4b227zE8ejhHY4/S75t+3PLlLazavSrYoYlIBjurMSzMLBvebUhfxbsP9ATgBefcP+kTXvrILP31ROR0B4/FMm7+FsYv2MqJk3HcWKcUdzevQJF8mb8fa3r2mw71fHze5OHdG2D2k7BhJuQtBk0HQY0ekP2c3iVcRNKRcnHmcuLkCaZumsrYn8byz9F/aFm6JffUvIfS+UsHOzQRSaMMGcPCzCKAEXi3W/oI6ALsB+akdZ0iIvGOx8bx5ve/Ev3cXF6cs5krK1/C1/dG81TH6udFsSI9KR+fQ0UqwY3vwi1fwkWl4bMB8Eo9WPcpqHmySJamXHxu5Myekxsr38jnnT+nT2QfFv6xkI7TO/K/xf/j7yPqsidyvknTT0JmtgzYC7wBDAq4regSM2uYXsGJSNYTF+eYuWonz3+1gd/2HKZeuUJMuLoKkSULBju0kKR8HCSl6nlFiw2fw+wh8MFNUKIOtBwKpesHOzoROceUi8+9PDnz0DeqL9dXup6xP43lo40fMWPLDG6udjMx1WLIkzNPsEMUkXSQpi4hZlbOOfdLgmllnXMhOYT6+dD8TSQr+H7z3wybtZ6ft++jcrF8PHR1ZZpWLHLeDqaZHs2QM0s+Pq/z8MlYWPkOzBsGB3ZCpTbQ/Am4pHKwIxORFFAuPj/8tv83Xlz+Il/99hWFwgpxR8QdXFfxOnJmzxns0ETkDDKiS8jUFE4TETmjtTv203PCD3R7fQl/HzjGiOsimXl3Y5pVuuS8LVakI+XjYMueA2rFQP/l3gCdvy6EV+vDJ3fBvj+CHZ2InBvKxUFWOn9pRjQdwbtt3qVcgXL83w//R4dPOjBr6yzdUUQkE0tVlxAzqwxUAwqYWeeAl/IDYekZmIic/7b/e5gRX21k+so/yB+Wk0faVKFH/dKE5cwe7NBCnvJxCLogt3cL1JoxsGAE/DgeVk2BundCo4GQS92aRM43ysWhJ7xIOBOumsCCPxYwatkoHvj2ASatmcS9te6lzqV1gh2eiKRSasewqIQ38nFBoF3A9APAbekVlIic3/49dJyX527mrUW/YQZ3NClPn6blKZBLzTZTQfk4VOUpDK2fgbp3wNyn4bsXYPmb0Ph+uKI35NQ1jMh5RLk4BJkZTUo0oWHxhnz2y2eMWTmGW7+6lUaXNWJAzQFUKlQp2CGKSAqldQyL+s65RRkQT4Y4n/vriWQmR0+cZMJ3W3l13hYOHYulS60SDGxZkUsL5Ap2aEGRTv2mM0U+ztJ5eOfPMPsJ2DIHCpSEKx+F8Osgm1oSiYQC5eLz37GTx3hv3XuMXzWeA8cP0K58O/pF9aN43uLBDk1ESD4Pp7ZLyIPOueeAbmZ2Y8LXnXN3pzFGETmPxZ6M46Pl2xn19Sb+3H+UFlUu4cHWlalYNF+wQ8u0lI8zkUsjoMc0+GUefP04TLsDvn8JWjwJlzcHjdMikmkpF2cOF2a/kJjqMXSq0Ik3Vr/B5LWTmbV1FjdWvpHe4b0pGKYueyKhKrVdQtb5/s16pVkRSTXnHLPX7eK5WevZtOsgNUoV5IWuUdQtVzjYoZ0PlI8zm3JN4bZ5sOZj+GYoTL4WyjbxCheX1QxycCKSRsrFmUiBCwtwb6176Va5Gy+vfJm31r7Fx5s+5tbwW+lepTthOdRlTyTUpKlLSGaTVZu/iQTTst/+ZdgX6/jx138pd3EeHmxdiauqFdNdPwKkRzPkzEJ5OIHY47B0Anz7HBzeA9U6Q/PHoFC5YEcmkuUoF2ddm/7dxAvLX2D+9vlckvsS7oq6i/bl25NdXfZEzql0v62pmX1tZgUDnl9kZl+mNUAROX9s3nWQO95eyrWvfs+vew7zdKfqfDWwCa2rX6piRQY4m3xsZq3NbIOZbTazQYm8fqeZrTKzlWa20MyqJni9lJkdNLP7z35PspgcF0C9O+HuldDkAdg4C8ZcAZ8/AAd3Bzs6EUkl/W2cOVW4qAJjmo9h4lUTKZa7GI9//zjXzriWedvm6VaoIiEiTQULoIhzbm/8E+fcv8Al6ROSiGRGu/YfZfDHq7hq9Ld8t3kP97WsyPwHmtK9bmlyZE9rqpEUSFM+NrPswMvA1UBV4MaEBQngXedcuHMuCngOGJng9VHAF2cTfJYXlt8bhPPuFVCjB/z4BrwYBfOehWMHgx2diKRcWnPxmQrH95rZWjP72cy+MbPSvulRZrbIzNb4XrshXfcmi6ldrDbvtHmHkU1HEuti6T+nPzGzYli5a2WwQxPJ8tJ6FXHSzErFP/ElT5UhRbKgA0dP8PyXG4gePo+py7bRo15p5j/QlP7NK5D7gtQOkyNpkNZ8XAfY7Jz7xTl3HHgf6BA4g3Nuf8DTPIHrNbOOwC/AmrOIXeLlKwbtRkO/JVC+Gcx7Bl6sAT++DidPBDs6ETmzVOfiFBaOVwC1nXMRwFS84jHAYaCnc64a0BoYHdjCQ1LPzGhZuiXTOkzj0bqP8tv+3+jxRQ8Gzh3I1n1bgx2eSJaV1quJR4CFZjbf97wJcHv6hCQimcGx2JNMXvw7L83ZxL+HT9A+sjj3tapI6cJ5gh1aVpPWfHwZsC3g+XagbsKZzKwfcC9wAXClb1oe4CGgJZBkdxAzuz0+llKlSiU1mwS6uALc8A5s+8G7o8jM+2DRK9D8cajaQXcUEQldacnF/sIxgJnFF47Xxs/gnJsbMP9i4Cbf9I0B8+wws11AEWAvclZyZsvJDZVvoF35dry59k0mrZ7E3G1z6VyhM30i+1Akd5FghyiSpaSpYOGcm2VmNYF6gAEDnXN/p2tkIhKS4uIcn/68g+e/2sC2f47Q8PLCDGpdhfASBYIdWpZ0Fvk4sSvf034NdM69DLxsZt2AR4GbgSeBUc65g8mNS+KcGweMA2+gtxTEJPFK1oFeX3hjW8weAlNuhstqQcuhUKZRsKMTkQTSmItTVDgOcCuJdMMzszp4ReUtiS2k4nHa5M6Zmz6Rfbi+4vW89vNrTNkwhc9++YweVXvQq1ov8l6QN9ghimQJqeoSYmaVff/WBEoBO4A/gFK+aSJyHluwaTftxizknvdXkvfCnLx5Sx3eubWuihVBkA75eDtQMuB5Cd86kvI+0NH3/7rAc2b2KzAAeNjM7krVDsiZmUGlq6HP99B+DOzfCZPawuTr4a+1Z15eRDLcWebiFBWOfeu/CagNDE8w/VLgbaCXcy4usWWdc+Occ7Wdc7WLFFHrgNQqnKswD9d9mE86fkJ0iWjG/TyONh+3YfK6yZxQlz2RDJfaFhb34lVoRyTymsPXXFhEzi+r/9jHs7PWs2DT31xWMBejb4iifWRxsmVT8/QgOtt8/CNQwczK4v1x3RXoFjiDmVVwzm3yPW0LbAJwzjUOmGcIcNA5NyYN+yApkS071OwB4V1gyWuwYCS82gCiukGzh6FAiWBHKJKVnU0uTlHh2Mxa4HU5iXbOHQuYnh+YCTzqnFuc+tAlNUrlL8Xw6OHEVIth1LJRDPthGG+vfZu7a9xN67KtyWYaYFwkI6SqYOGci++Ld7Vz7mjga2YWlm5RiUhI2PbPYZ7/agOfrNzBRblz8tg1VbmpXikuzKH7kwfb2eZj51ysr1XEl0B2YIJzbo2ZDQWWOudmAHf5/lA+AfyL1x1EgiVnLmg0AGr2hAUj4IdxsGoq1L0DGt8LuS4KdoQiWc5Z5uKUFI5rAK8BrZ1zuwKmXwBMA95yzk05u72Q1Kh2cTXGtxrP9zu+Z9SyUTy04CEmrZnEwFoDqV+8frDDEznvWFruMWxmy51zNc80LVTUrl3bLV26NNhhiGQa/xw6zktzNvHO4t/Ins24pWFZ7mxanvxhOYMd2nnFzJY552qf5ToyRT5WHs4Ae3+Huc/AT+97t0dtfB/Uud0rbIhIigUzF5tZG2A0/xWOnw4sHJvZbCAc2Olb5HfnXHtfF5GJnHqnphjnXLL34VQuTl9xLo6Zv8xkzIox7Di0gwbFGzCg5gCqFK4S7NBEMpXk8nCqWliYWTG8AYJy+Sq+8e3B8wO5zypKEQm6w8djmbBwK2Pn/8Lh47FcX7skA1pUpFgBNaAKNcrHQsFS0Gks1L/LG5jz68dhyTivm0hkV68riYhkqLPNxc65z4HPE0x7POD/LZJY7h3gnTSGLekkm2WjXfl2tCrTig/Wf8C4VeO4/rPraVuuLf1r9OeyvJcFO0SRTC+1Y1hcBcTg9bEbwX9J+QDwcPqFJSLnUuzJOD5cup3Rszey68AxWlUtyoOtK3H5JfmCHZokTflYPMWqw01TYeu38PUT8ElfWDQGWgyBCq10K1SRjKVcLFyY/UJ6VutJxwodmbh6Im+vfZuvfv2KGyrdwO0Rt3NRmLrsiaRVWruEXOuc+ygD4skQav4mkjjnHF+u+YvhX65ny+5D1Cp9EYOvrkztMoWCHVqWkE7NkDNFPlYePkecgzXT4Juh8O9WKN3IuxVqiVrBjkwkZCkXS3r769BfvPLTK0zfPJ3cOXJzS/VbuKnqTeTKoS57IolJLg+ndTjbEmaW3zyvm9lyM2t1FjGKyDm29Nd/6DJ2EXe+swyAcT1qMfXO+ipWZD7Kx/IfM6jeGfr9AG2eh93r4fUr4cOesGdLsKMTOZ8pF4tf0TxFebLBk3zc/mNqF6vNiytepO3HbZm6cSqxcbHBDk8kU0lrweIW59x+oBVwCdALGJZuUYlIhtn01wF6v7mULmMXsf3fwwzrHM6XA5rQqloxTE3HMyPlYzldjgugzm1wz0qIHgSbZsPLdWDmfXBw15mXF5HUUi6W05QvWJ6XrnyJSa0nUTxvcZ5c9CSdZ3Tmm9+/IS2t3EWyorQWLOKvatoAE51zPwVME5EQ9Oe+owz66GeuGv0tS37ZwwNXVWLe/c3oWqcUObLr3uGZmPKxJO3CfNBssFe4qBUDyybBC1He3UWOHQh2dCLnE+ViSVKtorV4++q3Gd10NM45BswdwM2zbmbFrhXBDk0k5KV20M14y8zsK6AsMNjM8gFx6ReWiKSX/UdPMHbeFiZ8t5WTcY6YBmW568rLKZTngmCHJulD+VjOLO8l0HYE1OvrjW8x/1lYOgGiH4KaN3stMkTkbCgXS7LMjOalmxNdMpppm6fx6spX6flFT5qVbMaAmgMoV7BcsEMUCUlpHXQzGxAF/OKc22tmhYHLnHM/pzkQs+FAO+A4sAXo5Zzbm8h89wC34VWtxzvnRp9p3RpgSLKiY7EneXvRb4yZu5m9h0/QMao4ACnrEwAAIABJREFU97WqRMlCuuNlqEingd7SPR9nBOXhELN9mXcb1N8WwkVlofljULUTZFNrK8l6lIslGA6fOMzkdZOZsHoCh2MP0+nyTvSN6ssluS8Jdmgi51xyeThNLSycc3FmthWoaGZhZxXdf74GBjvnYs3sWWAw8FDgDGZWHa9YUQevsDHLzGY69//s3Xd4VNXWx/HvSkIIvUjvLfTeREQ6CIg0UQFFURGRKlw7167Xgq90lCJ2AQsoRUA6ooL0Kr2DCIr0nqz3jxm8czGEyWSSc2ayPs+TJzOnzW/OxOVhzz576/YgZTAm5MXHK9+sPcj/fb+Ng8fPcUtsLp5qUZaKBbM5Hc2kgBSqxybcFaoB3WbA9rkw70X46kEoMMIzo0jx+k6nMybkWC02SZUxXUYervwwHUt3ZOz6sUzaOomZu2Zyb/l7ebDig2SJtqnljYEAx7AQke7AEmAO8JL394vJCaKq36vqlWFzl+GZz/pq5YBlqnrWu+1ioH1yXteYcKGqLN52lNtGLGXgF+vIkSkdnz50I588dKM1VoSxlKjHJo0QgdLNoecP0O49OH0UProdPr0DDm90Op0xIcVqsQlUjpgcPFX7Kaa1m0ajIo0Yv2E8Lae05ONNH3Mx7qLT8YxxXKB9P/sDtYC9qtoIqAYcDVoqeBCYlcDyjUB9EblBRDLiGdiocEIHEJEeIrJSRFYePRrMaMa4z/oDx7ln/HLun/ALZy5cZnjnakzrXY96sbmcjmZSXkrXYxPuIiKhamfouwqavQIHVsJ79WDKI3B8n9PpjAkVVotNshTOUpi36r/F5NaTKZ+zPINXDub2qbczfed04tWGQzFpV6ANFudV9TyAiKRX1S1AmevtJCLzRGRjAj9tfbYZBFwGPrt6f1X9FXgTz+0js4F13m3/QVXHqmpNVa2ZO3fuQN6jMa63988z9Pl8NW1G/siWw6d44fbyzBvYgDZVChARYYOTpxEB1WNj/iFdDNzczzOjyM39YNNUGFED5gyCs8ecTmeM21ktNkFR/obyjG0+ljHNxpAtfTaeXfosd8+4mx8P/mhToZo0KdBZQg6ISHbgG2CuiPwFHLreTqraNLH1InI/0Bpootf4L1JV3wfe927/H+BAErMbE/L+OH2BkQt28NnyvURFRNC3cSl61C9Blph0TkczqS+gemzMNWXI4RnLonYPWPg6LBsNqz+Beo9BnUchXQanExrjRlaLTVDVLVCXOvnr8N3u7xi5ZiQ95/Xkxvw3MqDGACrcUMHpeMakmoBmCfmfA4g0ALIBs1U14ButRKQF8A7QQFWv2YVORPKo6hERKQJ8D9ykqn8ldmwbEdmEizMXLvP+0t2MWbyT85fjubtWYR5rEkuerDa+VygKxsj0Vx0vKPU4JVgdDmG/b4b5L8G22ZClADR6Bqp0gchAv/Mwxl2sFhu3uxh3kS+2fsGY9WM4fuE4LYu1pG/1vhTOkuCd8caEnKDNEiIiORNYvMH7OzOQnD6jI4H0eFqlwTO4Zk8RKQCMV9VW3u2+9k4VdQnofb3GCmPCwaW4eCat2M+wedv54/QFWlbMx+O3lqFk7sxORzMOSeF6bMx/5S0PXSbDnh89U6FO6ws/j4ImL0CZlp7BO41Jo6wWm9QQHRnNveXvpW2ptnyw8QM+2fwJc/fN5a7Sd/FIlUfIGZPQn6Ex4SFJPSy80zUp4Ht1cuW5qmqJ4MYLDmtNNqFKVZm18TCD52xl9x9nqF0sJ0+1LEuNojmcjmaCIDnf6oVaPbY6HCZU4ddpMO8lOLYTitzkuX2kcG2nkxkTMKvFJtQcOXuEd9e9y9TtU4mJiqFbhW7cV/4+MqbL6HQ0YwIStB4Wqlo8OJGMMdezbNefvD5rC+v2Hyc2T2bG31eTJuXyIPZtpsHqsXGICJRvC2VaweqPYdEb8H4zKNva0+Mid2mnExqTqqwWGyfkyZiHF256ga7luzJ89XBGrR3FpC2T6FW1F+1j25MuwsY0M+EjSbOEiMi9Po9vvmpdn2CFMiYt23L4JA9+uIJOY5dx5OR53upYmdmP1adp+bzWWGH+Fox6LCItRGSriOwQkacTWN9TRDaIyFoRWSoi5b3La3uXrRWRdSLSPrnvx4SYyHRQ6yHotwYaDYJdi2B0HZjeH04ddjqdMakmubXYjzo8UEQ2i8h6EZkvIkV91t0vItu9P/cn972Y0FMiWwmGNhrKJy0/oUjWIryy7BU6fNuBuXvn2owiJmwk9ZaQ1apa/erHCT13E+v+ZkLBoePneGfuNr5efYDM6aPo1bAUD9xcjJh0kU5HMykkmd2Qk1WPRSQS2AY0wzPb0gqgs6pu9tkmq6qe9D5uA/RS1RYikhG4qKqXRSQ/nimmC6hqgtNMg9XhsHf6KCwZDCsneBoz6vSCm/tDTFankxlzXU7VYj/rcCNguaqeFZFHgYaqerd37IyVQE08t6CsAmrYQPRpl6qyaP8ihq4eyq4Tu6icqzIDagygZr6gjSdrTIpJrA4nqYcF/3t/3tVf9dpXv8YE4MTZS7w+61cavr2IaWsP0b1ecX54shGPNixpjRUmMcmtx7WBHaq6yzuK/SSgre8GVxorvDLhuShGVc/6NE7EXFlu0rDMuaHVW9DnF89AnD+8DcOrwrJ34bKrJkkwJtiSU4v9qcMLVfWs9+kyoJD38a3AXFU95m2kmAu0COQNmPAgIjQq0oiv23zNy3Vf5vCZwzww5wH6zO/Djr92OB3PmIAltcFCr/E4oefGmEScvxTH2CU7qT94IWOX7KJ15fwseLwBg24rT/aM0U7HM+6X3HpcENjv8/yAd9n/EJHeIrITeAvo57P8RhHZhGc0/J4J9a4QkR4islJEVh49es3Zqk04yVkCOk6AhxdC3gow+2kYWRM2fAXx8U6nMyYlJKcW+1WHfTwEzErqvlaL05aoiCjax7ZnRocZ9K/en9W/r+aO6Xfw/I/Pc/iM3bJnQk9SJ1EvKyLr8bQYl/Q+xvvcVaMgG+NWcfHK1DUHeef7rRw6cZ6GZXLzVIuylMtvXadNkiS3Hif0zd8/Lq5VdRQwSkS6AP8G7vcuXw5UEJFywEciMktVz1+171hgLHi6Ifv3tkxYKFgd7psGO+fD3Bfh64fgp+HQ9CUo2cjpdMYEU3JqsV91GP4eK6Mm0CCp+1otTpsyRGWge6XudIztyLgN45i4ZSLf7f6OLuW60L1Sd7JG23WnCQ1JbbAolyIpjEkDVJWFW4/w5qytbP39FJULZePtu6pQt2Qup6OZ0JTcenwAKOzzvBBwKJHtJwHvXr1QVX8VkTNARTz3UxvjIQKlmkKJxrDhS1jwKnzSDko2hqYvQv4qTic0JhiSU4v9qsMi0hQYBDRQ1Qs++za8at9FychiwlT2mOw8UesJ7il3DyPXjOTDjR/y9bav6VG5B53KdiJ9ZHqnIxqTqCQNuhmqbIAh47Q1+/7ijVlbWL77GEVvyMgTt5bhtkr5bdaPNC45A70F4bWj8Az21gQ4iGewty6quslnm1hV3e59fDvwgqrWFJHiwH7voJtFgZ+Byqr6x7Vez+qw4fIFWDEelrwN545Bpbug8SDIUczpZCaNc6oW+1mHqwFfAS2u1GPv8px4Btq8MqjnajyDbh5L7DWtFputx7YyZPUQfjz4I/kz5adPtT7cVvw2IiNs3DTjnMTqcFJ7WBhjkmD3H2d4e85WZm74jRsyRfNSmwp0rl2E6KikDh9jTHB5Gxv6AHOASGCCqm4SkZeBlao6Dejj/WbvEvAX3ttBgHrA0yJyCYjHM3vINRsrjAEgKj3c1Buq3QtLh8Ky0bD5G6jVHW55HDLd4HRCY1KVn3V4MJAZ+NL7Jcc+VW2jqsdE5BU8jRwAL1+vscIYgDI5y/Be0/dY/tty3ln1DoOWDuLDTR8yoPoA6hWsZ1+mGdexHhbGpICjpy4wfP52Jv6yj+ioCB6+pQQP1y9B5vTWRmj+y8keFqnN6rD5h5OHYOF/YO1nEJ3ZMw1qnV4QndHpZCaNsVps0qp4jef7Pd8zbPUwDpw+QK18tRhYYyAVc1V0OppJY4I5ranvQTOISJnAYxkTfk5fuMw7c7fRYPBCJv6yj861i7DoiYYMaFbaGitMirF6bEJS1gLQdiQ8+jMUqwcLXoHh1WDVhxD3j0lnjHE9q8Um1ERIBC2Kt2Bau2k8U/sZdh7fSeeZnfnXon+x7+Q+p+MZAwTYYOG9l3ktMNv7vKqITAtmMGNCycXL8Xz88x4aDl7I8PnbaVQmD3MHNuCVdhXJkyXG6XgmjFk9NiEvT1noPBEemA3Zi8D0/vDuTfDrDEgDvUBNeLBabEJZush0dCnXhZntZ9KzSk9+OPgDbb9py6vLXuWPc3bHp3FWoD0sXgRqA8cBVHUtUCw4kYwJHarKjPWHaDZkMc9/u4mSuTMztVddRt1TneK5Mjkdz6QNL2L12ISDojfBQ9/D3Z96Giom3wMTboV9y5xOZow/XsRqsQlxmaMz07tqb77r8B0dYjvw1bavaDWlFaPXjubMpTNOxzNpVKANFpdV9URQkxgTYn7a+QdtR/1In8/XEBMVyQfdajGpRx2qFcnhdDSTtlg9NuFDBMrdDr2Wwe3D4K+9nkaLiZ3hyBan0xmTGKvFJmzkypCL5256jm/afkO9gvV4d927tJrSiklbJnEp/pLT8UwaE2iDxUYR6QJEikisiIwAfgpiLmNc69ffTnL/hF/oMm45f5y6wNt3VuG7/rfQqGweG1nZOMHqsQk/kVFQoxv0Ww2N/w27f/DcJvJtH89gnca4j9ViE3aKZSvGOw3f4dNWn1I8W3FeW/4a7b5px+w9s0kLEzcYdwi0waIvUAG4AHwOnAAeC1YoY9zowF9nGfjFWloN/4G1+4/zTMuyLHi8IR1rFCIywhoqjGOsHpvwFZ0J6j8B/ddB7Udg3STPwJzzXoRzx51OZ4wvq8UmbFXJXYUPbv2AUU1GER0ZzROLn6DLzC6sOLzi+jsbk0w2rakx1/HXmYuMXrSDj37aCwIP3FyMXg1KkS1jOqejmRBnU+kZk0R/7YEFr8KGLyFDDk9jRq3uEJXe6WQmhFktNsZ/cfFxTN81nZFrRvL72d+pV7Aej1V/jDI5bYIcE7igT2sqInNFJLvP8xwiMifQgMa40flLcYxetIP6gxfy/tLdtK1agEWPN+SZluWsscK4htVjk6bkKAZ3jIdHlkCBajDnWRhRE9ZNhvh4p9OZNMxqsUkrIiMiaVeqHTPaz2BgjYGsO7qOO6ffyaClg/jt9G9OxzNhKNBbQnKp6t99MVX1LyBPcCIZ46y4eOWLFftpOHgRb83eSu1iOZnVvz6D76xCgewZnI5nzNWsHpu0J38V6DoVun4DGbLD1B4wpj5sn2dToRqnWC02aUpMVAwPVHyAWR1m0a1CN2bvnk3rqa15e8XbnLhg48+a4Am0wSJeRIpceSIiRQG7QjAhTVWZt/l3WgxdwpNfrydfthgm96jD+91qUSZfFqfjGXMtVo9N2lWyEfRYDHe8DxdOwmd3wMdt4NAap5OZtMdqsUmTsqXPxsCaA5nZYSYti7fk480f03JKSyZsnMD5y+edjmfCQFSA+w0ClorIYu/z+kCP4EQyJvWt3vcXb3y3hV/2HKNErky8e091WlTMZ7N+mFBg9dikbRERUKmjZzrUlR/AkrdgbEOo2NEzw0jO4k4nNGmD1WKTpuXLlI9X673KfRXuY9jqYQxZNYTPf/2c3lV706ZkGyIjIp2OaEJUwINuikguoA4gwM+q+kcwgwWTDTBkrmXn0dMMnr2V2ZsOkytzevo3jaVTrcKkiwy085Ex/gvWQG+hUI+tDptUc/4k/DQcfh4FcZeg5oPQ4EnIlMvpZMalrBYbE3wrDq9gyKohbPhjA6Wyl+Kx6o9Rv1B9+zLQJCixOpykBgsRKauqW0SkekLrVXV1gBlTlBVnc7UjJ88zdP52Jq/YT0xUBI80KMlD9YqTKX2gnY6MSbrkXCSHWj22OmxS3anDsOgNWP0xpMsIN/eDm3p7pko1xofVYmNShqoyb988hq0ext6Te6mRtwYDagygSu4qTkczLpNYHU7qv84G4une9n8JrFOgcRKPZ0yqOnX+EmOX7GL8D7u5HB9P1zpF6dO4FLky25R4JuRYPTYmMVnywe1DoU4vmP8SLHwNVoyHBk9B9fsg0mZ7MkFhtdiYaxARmhVtRsPCDZmybQrvrnuXe7+7l2ZFm9GvWj+KZSvmdEQTAgK+JSSUWGuyuXg5ns+W72XEgh0cO3OR1pXz88StZSh6g33TZpwTrG7IocDqsHHc/l9g7vOw72e4oRQ0eR7KtQHrnpzmWS02JnWcvXSWjzZ/xIcbP+RC3AXuiL2DnlV6kjtjbqejGYcFs4fFlQPel9ByVf04kOMZk1Li45Xp6w/x9vdb2X/sHHVL3sDTLctSuVD26+9sTAiwemyMnwrXhgdmwbbZMO9F+OI+KFgTmr0MxW52Op0JcVaLjbm+jOky8miVR7mz9J2MWTeGr7Z9xfRd07mv/H10q9CNzNGZnY5oXCjQG/Zr+TyOAZoAqwErysY1lm7/gzdm/8rGgycplz8rHz1YifqxuWywHxNuAq7HItICGAZEAuNV9Y2r1vcEegNxwGmgh6puFpFmwBtANHAReEJVFwThvRiTskSgTEso1QzWTYSF/4EPW0HpFtDkBchb3umEJnTZtbExfsqVIReD6gyia/muDF8znDHrx/Dlti/pUbkHd5W+i3R2y57xEZRbQkQkG/CJqrZJfqTgs+5vacvGgyd4c/YWftj+BwWzZ+DxW0vTtkpBIiKsocK4S0p0Q/a3HotIJLANaAYcAFYAnVV1s882WVX1pPdxG6CXqrYQkWrA76p6SEQqAnNUtWBir2d12LjSxbOw/D1YOhQunoIqXaDRM5CtkNPJTCpyuBZfr+G4PjAUqAx0UtWvfNa9BdwGRABzgf56nQt7q8XGjTb+sZEhq4bwy+FfKJS5EP2q9+PWYrcSITZrX1qRWB0O1l/BWSA2SMcyJiD7j53lsUlraD1iKRsOnuDft5Vj/r8a0L5aIWusMGmJv/W4NrBDVXep6kVgEtDWd4MrjRVemfAMIIeqrlHVQ97lm4AYEbGRa03oic4ItwyE/ms9g3Nu+AJG1PCMdXHuL6fTmdB23VrsbTgeBbQEygOdReTqbj77gG7A51ftWxe4GU9DRkU8PTwaBCO4MamtYq6KjG8+ntFNRpMxXUaeXPIknWd2Ztlvy5yOZlwg0DEspuO9cMXT6FEe+CJYoYxJimNnLjJywQ4+XbYXEXi0YUl6NihJtgzWncyEv2TU44LAfp/nB4AbEzh+bzyj4EeT8Gj3dwBrVPVCAvv2wDN6PkWKFPEjkjEOyZgTbn0NbnwEFrwGPw6HVR/BLf+C2j0gXYzTCY3LBViL/2449h7jSsPx3z3dVHWPd138VfsqnltPogEB0gG/J+tNGOMgEeGWQrdQt0Bdvtv9HSPWjODh7x/m5gI381iNxyibs6zTEY1DAh3D4m2fx5eBvap6IDlBROQVPEU6HjgCdPP5Bs93u/uBf3ufvqqqHyXndU3oOnvxMhOW7mbM4l2cuXiZu2oW5rGmpcmXzS4sTZoSaD1OqNvRP7oSq+ooYJSIdMFTe+//+wAiFYA3geYJvYCqjgXGgqcbsh+ZjHFW9iLQYQzU7eMZmHPuc7B8DDQeBJXvhohIpxMa9wqkFvvVcJwQVf1ZRBYCv+Gp5yNV9deEtrXGYxNKIiMiub3k7TQv1pxJWyYxdv1Y7pp+F7eVuI0+1fpQMHOid6CaMBRQg4WqLg52EGCwqj4HICL9gOeBnr4biEhO4AWgJp4L61UiMk1Vrd9mGnI5Lp4vVx1gyNxtHDl1gWbl8/LkrWWIzZvF6WjGpLpk1OMDQGGf54WAfzQS+5gEvHvliYgUAqYC96nqzgAzGONO+SrBvV/DrsUw7wX45lH4aSQ0fRFim9lUqOYfAqzFfjUcJ7ijSCmgHJ7aDTBXROqr6pIEslnjsQk56SPTc3+F+2kf2573N7zPZ79+xpw9c7i7zN30qNyDHDE5nI5oUkmSxrAQkVMicvIaP0dFZJmINAkkyLXulb7KrcBcVT3mbaSYC7QI5PVM6FFVvt90mFuHLuGZKRsolCMDX/a8iXH31bTGCpPmBKEerwBiRaS4iEQDnYBpV72G7/3XtwHbvcuzAzOBZ1T1x+C+M2NcpEQD6L4AOn4Al87C53fCR7fDwVVOJzMukcxanNSGY1/tgWWqelpVTwOzgDqBvxNj3ClrdFYG1BjAjPYzaF2iNZ9v+ZxWU1oxfsN4zl0+53Q8kwqS1MNCVa/5r0LvwEEVgc+8v5NMRF4D7gNOAI0S2CShrnMJ9guy7m/hZeWeY7w+awur9v5FidyZGNO1Bs3L57UpSk2aldx6rKqXRaQPMAfP6PQTVHWTiLwMrFTVaUAfEWkKXAL+4r+3g/QBSgHPichz3mXNVfVIEN6aMe4SEQEVO0DZ1rD6I1j0BoxrDOXbQZPn4YaSTic0DkpmLf674Rg4iKfhuIufL70PeFhEXsfTU6MBntlEjAlL+TLl4+WbX+a+8vcxbM0whq0exsRfJ9Krai/almpLVESgIx0YtwvKtKb/c0CRR1R1zDXWzQPyJbBqkKp+67PdM0CMqr5w1f5PAOlV9VXv8+eAs6r6f4llsimcQteOI6d4Y9ZW5v36O3mypOexpqW5q2YhoiJtmiMT+lJiKr2rjn/NepzarA6bsHHhlOf2kJ9GQNwFqNENGjwFmfM4ncwEyMlaLCKt8DQ0XGk4fs234VhEauG5/S4HcB44rKoVvI0ho4H6eHolz1bVgdfLYrXYhItVv69iyKohrDu6jhLZStC/en8aFW5kX2aGqMTqcNAbLIJBRIoCM1W14lXLOwMNVfUR7/MxwCJVnZjY8aw4h57fT55nyNxtfLFyPxmjo+jZoAQP1itOxmhrPTXhI6Uvkt3E6rAJO6d+h8VvwqoPISoG6vb1DNaZ3m5RDDVWi40JTarKgn0LGLp6KHtO7qFanmoMrDGQqnmqOh3NJFFiddg1X1Nfda90G2BLApvNAZqLSA4RyYFnZPo5qZHPpI4T5y7x1uwtNBi8kK9XH6Bb3eIsebIRfRrHWmOFMcYY98iSF1q/A71/gdimsPgNGF4NfhkHcZecTmeMMWFPRGhStAlT207l+ZueZ/+p/XSd1ZX+C/qz68Qup+OZIAm4wUJEinrvbUZEMohIcr9SeENENorIejwNEf29x64pIuMBVPUY8Aqee/5WAC97l5kQd+FyHON/2EWDwQsZvWgnLSrkY8G/GvL87eXJmSna6XjGuFoK1GNjjL9ylYK7Pobu8yFXGfjucRhVGzZNBRf2YjUpx2qxMc6IiojiztJ3MrP9TPpW68vyw8vp8G0HXvzpRY6cteG1Ql1At4SIyMN4BrTMqaolvb0j3lPVgGYISWnW/c294uOVb9cd5O052zh4/By3xObiqRZlqVgwm9PRjElxweiGHCr12OqwSRNUYftcz1SoRzZDgerQ7GUofovTyUwirBYbE16OnT/G2PVjmbx1MlESRdfyXXmg4gNkibY2RLdKiVtCegM3AycBVHU7YKNNGb+pKou3HeW2EUsZMHkd2TOm49OHbuSTh260xgpjksbqsTFuIQKlm0PPpdDuXTh9BD5qDZ92hMMbnU5nUpbVYmNcImdMTp6u/TTT2k2jcZHGjNswjlZTWvHp5k+5GHfR6XgmiQJtsLigqn9/2iIShWeEYmOua8OBE9z7/nLun/ALp85fYlinqkzvU496sbmcjmZMKLJ6bIzbRERC1S7Qd5Wnh8WBX+C9ejC1Jxzff/39TSiyWmyMyxTOUpg367/J5NaTKZuzLG+ueJM237Rhxq4ZxGu80/GMnwJtsFgsIs8CGUSkGfAlMD14sUw42vvnGfpOXMPtI5ey+dBJnm9dnvn/akDbqgWJiLApiIwJkNVjY9wqXQzc3B/6r/PMIrJxCoyoAXMGwVkbgivMWC02xqXK31Cecc3HMabpGLJEZ+GZH57h7hl389Ohn5yOZvwQ6BgWEcBDeAbHFDwzdYxXN86Rit2v57Q/T19gxIIdfLZ8L5ERQvd6JejRoARZY9I5Hc0YRwXpvumQqMdWh43B07ti0euw9nNInxVuGQA39oR0GZxOlqZZLTYm7YjXeGbtnsWINSM4ePogdfLXYUCNAZS/obzT0dK0xOpwQA0WocaKszPOXLjM+0t3M3bJLs5diuOumoV5rGksebPGOB3NGFcIxkVyqLA6bIyP3zfBvJdg+xzIWhAaPQtVOntuJTGpzmqxMWnPxbiLTN46mbHrx3L8wnFaFm9J32p9KZylsNPR0qTE6nBUgAfcwD/vyzsBrAReVdU/AzmuCQ+X4uKZvGI/Q+dt54/TF2hePi9PtihLqTyZnY5mTNixemxMCMpbAe75AvYshbnPw7e94aeR0PQFKN3CM3inCSlWi40JLdGR0XQt35V2pdrxwcYP+GTzJ8zdO5e7y9xNj8o9yBmT0+mIxiugBgtgFhAHfO593sn7+yTwIXB78mKZUKSqzN54mMFztrLrjzPULJqDMV2rU6Oo/QdvTAqyemxMqCpWD7rPh83fwvyXYWInKFLXM1Bn4VpOpzNJY7XYmBCUJToL/ar3o1PZToxeO5qJWybyzY5veKDCA3Qt35WM6TI6HTHNC3QMix9V9eaElonIBlWtFLSEQWDd31LeL7uP8fqsX1mz7zil8mTmqRZlaVouD2LfEhlzTUG6bzok6rHVYWOuI+4SrP4IFr0JZ45AuduhyQuQK9bpZGHParEx5opdx3cxbPUwFuxfQK4MuXi0yqN0iO1AVESg3/MbfyRWhwOdJSSziNzo8wK1gSv9/S8HeEwTgrb9foqHPlzBXWN+5rfj53nzjkrM7n8LzcoK70m5AAAgAElEQVTntcYKY1KH1WNjwkFkOqjVHfqtgYbPws6FMOpGmP4YnDrsdDpzfVaLjQkDJbKXYFjjYXzc8mMKZynMK8teof237Zm3dx5pYexHNwq0qag7MEFEMuMZCfkk0F1EMgGvByucca/fTpzjne+38fXqA2RKH8WTLcrwQN3iZIi2AcOMSWVWj40JJ+kzQ8OnoOaDsOQtWDkB1k+Gm3pD3X4Qk9XphCZhVouNCSPV8lTjoxYfsWj/IoauHsqARQOonLsyA2sMpEbeGk7HS1OSNUuIiGTzHuN48CIFn3V/C54TZy8xevEOPvxxD6pwf92i9GpYihyZop2OZkzICebI9G6vx1aHjQnQnzthwauwaQpkvAHqP+lpzIiy/+8Gi9ViY0xiLsdfZtrOaYxaM4oj547QsFBD+lfvT6kcpZyOFjZSYpaQ9MAdQDEg6krXf1V9OcCMxuXOX4rj45/3MGrhTk6ev0T7qgUZ2Lw0hXLYQDTGOMnqsTFh7oaScOcHULcPzH0BZj8Fy9+Fxs9BhQ4QEejdvSaYrBYbE76iIqLoENuBlsVb8tmvn/H+hve5Y/odtC3Zll5Ve5EvUz6nI4a1QG8J+RbPVE2rgAvBi2PcJi5e+WbNQd6Zu42Dx8/RoHRunmpRlvIFrEuqMS5h9diYtKBgDbh/Ouyc72m4+Poh+Gk4NH0JSjZyOp2xWmxM2MsQlYHulbrTMbYjYzeMZdKWSXy3+zvuKXcPD1V6iKzR9u+jlBBog0UhVW0R1CTGVVSVRduO8uasLWw5fIrKhbIxuGNl6pbK5XQ0Y8z/Crgei0gLYBgQCYxX1TeuWt8T6I1nqr7TQA9V3SwiNwBfAbWAD1W1T3LegDHGTyJQqimUaAwbvvDcKvJJOyjZ2NNwkb+y0wnTsoBqsR91uD4wFKgMdFLVr3zWFQHGA4UBBVqp6p6A34Exxi/ZY7LzZK0nuafcPYxcM5IPNn7A19u/5uFKD9O5bGeiI+2WvWAKtB/hTyLiiumZTPCt23+cLuOW88AHKzh3KY4RnavxTa+brbHCGHcKqB6LSCQwCmgJlAc6i0j5qzb7XFUrqWpV4C3gHe/y88BzwOOBxzbGBCwiAqp0gj4r4db/wKE1MKY+TOkBf+11Ol1aleRa7Gcd3gd0Az5P4BAfA4NVtRxQGziS1NDGmMAVzFyQ1295nS9u/4KKN1Tk7ZVvc/vU25m+czpx8XFOxwsbgTZY1ANWichWEVkvIhtEZH0wg5nUt+ePM/T+bDVtR/3Itt9P8VKbCswd0IDbqxQgIsKmKDXGpQKtx7WBHaq6S1UvApOAtr4bqOpJn6eZ8HyDh6qeUdWleBoujDFOSRfjmT2k31qo9xhs/hZG1oTZz8LZY06nS2sCqcX+1OE9qroeiPdd7m3YiFLVud7tTqvq2aC9G2OM38rmLMt7zd5jXPNxZI/JzrNLn+WuGXex9OBSmwo1CAK9JaRlUFMYRx09dYHh87cz8Zd9REdF0K9JLD3qlyBz+kD/PIwxqSjQelwQ2O/z/ABw49UbiUhvYCAQDTROyguISA+gB0CRIkUCjGmMua4M2aHpi1C7Byz8j2dQzjWfeBoxbnwUom2A7FQQSC32qw5fQ2nguIhMAYoD84CnVfUfX+taLTYmddTJX4eJt03k+z3fM2z1MB6d9yi189VmYI2BVMhVwel4ISugHhaquldV9wLn8HzjduXHhJDTFy4zZO42GgxeyOe/7KNT7cIseqIhA5uVtsYKY0JEMupxQt2m/rGfqo5S1ZLAU8C/k5htrKrWVNWauXPnTsquxphAZC0AbUfCoz9DsXow/2UYUR1WfQRxl51OF9YCrMV+1eFriAJuwXNrXi2gBJ5bRxLKZrXYmFQSIRG0KN6Cae2m8XTtp9n+13Y6zezE44sfZ9/JfU7HC0kBNViISBsR2Q7sBhYDe4BZQcxlUtCluHg+/nkPDQcvZNj87TQonZu5A+rzartK5MkS43Q8Y0wSJKMeH8AzUNsVhYBDiWw/CWgXYExjTGrKUxY6T4QHZkG2QjC9H7xbF7bMBOuenCICrMVJrcNX77vGezvJZeAboHqSQhtjUky6yHTcU+4evuvwHT0q92DJgSW0/aYtry17jT/P/el0vJAS6BgWrwB1gG2qWhxoAvwYtFQmRagqM9Yfotk7i3n+202UyJ2Zqb3q8u69NSiRO7PT8YwxgQm0Hq8AYkWkuIhEA52Aab4biEisz9PbgO3BiWyMSRVF68JDc+HuT0HjYVIXmNAC9i1zOlk4CqQWX7cOX2ffHCJypctEY2Bz0mMbY1JS5ujM9K3Wl5ntZ9IhtgNfbvuSVlNa8e66dzl7yYad8UegDRaXVPVPIEJEIlR1IVA1iLlMkP2880/ajfqRPp+vIX1UJBO61WRyjzpUK5LD6WjGmOQJqB57v5HrA8wBfgW+UNVNIvKyiLTxbtZHRDaJyFo841jcf2V/EdmDZ9aQbiJyIIGR7Y0xbiAC5W6HXsug9VD4azdMuBUmdoGjW51OF06SXIv9qcMiUktEDgB3AmNEZJN33zg8t4PMF5ENeG4vGZdSb84Ykzy5M+bmuZueY2rbqdxc8GZGrx1NqymtmLxlMpfiLzkdz9UkkJFLRWQenq7BrwO58EyjVEtV6wY3XnDUrFlTV65c6XQMR/z620nenL2FRVuPkj9bDAOaleaO6oWItFk/jHGciKxS1ZrJPEZI1OO0XIeNcZWLZ+Dn0fDjMLh0BqrdCw2fhaz5nU7mGKvFxpjUtu7oOt5Z+Q6rj6ymaNai9K3Wl+ZFmyOSNv+NllgdDrTBIhOeQYUigHuAbMBn3pZl10mLxfng8XP83/dbmbrmIFnSR9G7USnur1uMmHSRTkczxngF6SI5JOpxWqzDxrjamT9gyWBY8T5EREGdRz2zisRkczpZqrNabIxxgqqy5MAShq4eyo7jO6iUqxIDagygVr5aTkdLdUFtsBCRSGCOqjYNRrjUkJaK8/GzFxm9aCcf/rQHgAfqFqNXw1Jky5jO2WDGmH9I7kVyKNXjtFSHjQkpx3bDwtdgw5eQISfUfwJqPQRR6Z1OlmqsFhtjnBQXH8e0ndMYtXYUv5/9nfqF6tO/en9K5yjtdLRUk1gdTvIYFt575s6KSNprgnex85fieG/xTuq/tZBxP+yiTZUCLHy8Ic+0KmeNFcaEKavHxphky1kc7hgPPRZD/sow5xkYWRPWfwHx8U6nCwlWi40xyREZEUn72PbMaD+DATUGsObIGjpO68igpYP47fRvTsdzXFSA+50HNojIXODMlYWq2i8oqYzf4uKVr1cfYMjcbfx24jyNyuTmqZZlKZsvq9PRjDGpw+qxMSb5ClSF+76FnQtg7gsw5WH4aTg0fQlKNvYM3mkSY7XYGJMsMVExPFjxQe6IvYPxG8bz+a+fM3v3bLqU60L3St3Jlj5ttokG2mAx0/tjHKKqLNhyhDdnb2Hb76epUjg7Q+6uSp0SNzgdzRiTuqweG2OCp2RjKN4QNn4NC16GTztA8QbQ7CUoUM3pdG5mtdgYExTZ0mfjXzX/ReeynRm1dhQfbfqIr7d/TfdK3elStgsxUTFOR0xVgQ66GQOUAhTYqarngx0smMLtfr3V+/7ijVlb+GX3MYrnysQTt5ahZcV8aXZUWWNCVZAGeguJehxuddiYNOHyBVg5ARa/BeeOQcWO0PjfnttIwojVYmOMm237axtDVw3lh4M/kDdjXnpX7U2bkm2IjAifyRSCNoaFiESJyFvAAeAj4FNgv4i8JSI2UEIK23X0NI9+uooOo39i19HTvNKuIt8PqE+rSvmtscKYNMbqsTEmxUWl98we0n8t3PIv2DITRtaCWU95ZhkxVouNMSmudI7SjG46mgm3TiB3htw8/9PzdJzekSUHlhBI54NQk9RBNwcDOYHiqlpDVasBJYHswNvBDmc8jpw8z6CpG2g2ZAlLth1lQNPSLH6iEV3rFCVdZJLHTTXGhAerx8aY1BGTDZo8D/3WQLV74JdxMKwqLB4MF89cf//wZrXYGJMqauWrxee3fc7bDd7mYtxFes/vzYNzHmT90fVOR0tRSbolRES2A6X1qp280zltUdXYgIOIvAK0BeKBI0A3VT2UwHazgTrAUlVt7c+xQ7X726nzlxi3ZBfjftjNpbh47rmxCH2bxJIrc9qZasyYcJacbsgpWY9TQqjWYWNMAo5ug/kvwZYZkDkvNHwaqt0HkYEOjeYsq8XGmFBzKf4SX2/7mnfXvcux88doVrQZ/ar1o1i2Yk5HC0gwpzXVqwuyd2Ecnnv2kmOwqlZW1arADOD5a20HdE3ma7naxcvxfPjjbhoMXsTwBTtoXC4P8wY24KW2Fa2xwhhzRUrWY2OMubbcpaHTZ/DQXMhZAmYMgNE3wuZpkAa6J1/FarExJtWli0hHp7KdmNVhFr2q9GLpwaW0+7Ydry57lT/Ohdcte0ltsNgsIvddvVBE7gW2JCeIqp70eZqJaxR5VZ0PnErOa7lVfLwybd0hmr6zmBenb6ZM3ix82/tmRnWpTrFcmZyOZ4xxlxSrx8YY45fCteGBWdBpIkgkfNEV3m8Ge39yOllqslpsjHFMxnQZebTqo3zX4TvuLH0nX2/7mlZTWjFq7SjOXAqPW/aSektIQWAKcA5YhadRoRaQAWivqgeTFUbkNeA+4ATQSFWPXmO7hsDjid0SIiI9gB4ARYoUqbF3797kREtxP+74gzdmbWHDwROUzZeFp1uWpUHp3DaYpjFhLJndkFO0HgebdUM2JszFXYa1n8Gi1+HUb1C6BTR9EfKUczrZdVktNsaEi30n9zF8zXDm7JlDzpicPFL5Ee4sfSfpIt09BnBidTjQaU0bAxUAATZ5ez34s988IF8Cqwap6rc+2z0DxKjqC9c4TkOu02Dhy83FedOhE7w5eytLth2lYPYMDGxWmnbVChIZYQ0VxoS7IE2lF1A9Tm1ursPGmCC6eBaWvwtLh8LF01C1CzR8FrIVdDrZNVktNsaEmw1HNzBk9RBWHF5B4SyF6VetH82LNSdC3DlhQ9AbLFKaiBQFZqpqxWusb0iIN1jsP3aWd+Zu45u1B8kak44+jUrR9aaixKQLn/l0jTGJC8ZFcqhwYx02xqSgs8dgyduwYhxIBNzYE+oNgAzZnU72D1aLjTHhSFVZenApQ1YPYftf26lwQwUG1BjAjflvdDraPyRWh10znLOIxKrqdu/TNoTpfX/Hzlxk1MIdfPLzXkTgkfolebRhSbJlcHc3HWOMMcYYv2XMCS3+Azc+Agtfgx+HwaoPof7jUOthSBfjdEJjjAlrIsIthW6hboG6zNw9kxFrRtD9++7cXOBmBtQYQJmcZZyO6Bc39Ql5Q0Q2ish6oDnQH0BEaorI+CsbicgPwJdAExE5ICK3OhM3ac5djGPUwh00eGshH/y4m3bVCrDoiYY83bKsNVYYY4wxJjzlKAodxsIjS6BgDfj+3zCyJqydCPFxTqczxpiwFxkRSZuSbZjRfgb/qvEvNvyxgTun38mzPzzLodOHnI53Xa68JSTYnOz+djkunq9WHWDIvG38fvICTcvl4ckWZSmdN4sjeYwx7mHdkI0xac6uRTD3BfhtLeSt6BmYs1RTcHCQcSdrsYi0AIYBkcB4VX3jqvX1gaFAZaCTqn511fqswK/AVFXtc73Xs1psjDlx4QQTNk7gs18/I17j6Vy2Mw9XepjsMc7dspdYHXZTD4uwoqp8v+kwLYb9wNNTNlAgewa+eOQmxt9fyxorjDGuICItRGSriOwQkacTWN9TRDaIyFoRWSoi5X3WPePdb2uo9HQzxrhAiYbw8ELoOMEzKOdnHeGj2+HgKqeTpToRiQRGAS2B8kBn3zrrtQ/oBnx+jcO8AixOqYzGmPCTLX02BtQYwIz2M7itxG18+uuntJrSivEbxnPu8jmn4/2DNVikgJV7jnHnez/T45NVxMcr791bnSmP1qV28ZxORzPGGMDvC+XPVbWSqlYF3gLe8e5bHuiEZ0T8FsBo7/GMMeb6IiKg4h3QewW0fAuO/ArjGsOX3eDPnU6nS021gR2quktVLwKTgLa+G6jqHlVdD8RfvbOI1ADyAt+nRlhjTHjJlykfr9z8Cl/d/hU18tZg2OphtJ7aminbp3A5/rLT8f5mDRZBtOPIKR7+eCUd3/uZvcfO8lr7inw/oD4tKuZHHOzqaIwxCfDnQvmkz9NMwJV7CNsCk1T1gqruBnZ4j2eMMf6LivYMytlvDdR/ErbNgVG1YebjcPqI0+lSQ0Fgv8/zA95l1yUiEcD/AU/4sW0PEVkpIiuPHj0aUFBjTPiKzRHLiCYj+ODWD8iXKR8v/PQCHad1ZOG+hbhh+AhrsAiC30+e55kp62k+ZAk/7/yTx5uXZvETDbnnxqJERdopNsa4kl8XyiLSW0R24ulh0S+J+9pFsjHm+mKyQuNB0G8tVL8PVk6A4dVg0Rtw4bTT6VJSQt9m+fuvg17Ad6q6/3obqupYVa2pqjVz586dpIDGmLSjZr6afNryU4Y0HEKcxtFvYT+6ze7G2iNrHc1l/5pOhpPnLzF4zhYaDF7IV6sOcH/dYix+oiF9GseSMdo1M8YaY0xC/LpQVtVRqloSeAr4dxL3tYtkY4z/suSF1kOg9y9QsjEseh2GV4VfxkHcJafTpYQDQGGf54UAf4fsvwnoIyJ7gLeB+0TkjcR3McaYxIkITYs2ZUrbKTxX5zn2ndpH11ld6b+gP7tO7HIkk/2rOgAXLsfx6bJ9jFywnb/OXqJNlQI83rwMRW7I6HQ0Y4zxV1IvlCcB7wa4rzHG+C9XKbj7E9i/Aua9AN89DstGQ5PnoXw7R2cUCbIVQKyIFAcO4hkbqIs/O6rqPVcei0g3oKaq/mPwZGOMCUS6iHTcVeYuWpdozcebP+bDTR/S4dsOtI9tT68qvcidMfW+iLIeFkkQH698s+YgTf5vMa/M2EyFAtmY0bcewztXs8YKY0yo+ftCWUSi8VwoT/PdQERifZ7eBmz3Pp4GdBKR9N4L7Vjgl1TIbIxJSwrXgm4zofNkiEzvGZRzfBPYs9TpZEGhqpeBPsAcPFOTfqGqm0TkZRFpAyAitUTkAHAnMEZENjmX2BiT1mRMl5GeVXryXYfv6FS2E9/s+Ibbpt7G8NXDOX0xdW7ZEzcMpJHSgjHn9A/bj/LGrC1sOnSSCgWy8nTLstwSa12cjTGBS2zO6VR6/VbAUCASmKCqr4nIy8BKVZ0mIsOApsAl4C+gj6pu8u47CHgQuAw8pqqzEnutYNRhY0waFh8H6ybBwtfg5EGIbQ5NX4S8FZJ9aKdrcWqyWmyMSY79J/czYu0IZu2eRY70OehRuQd3lbmL6MjoZB03sTpsDRbXsfHgCd6YtYWlO/6gUI4MPHFrGW6vXICIiLDpjmiMcYhdJBtjTBJdOgfLx8DSd+D8SajaBRo9C9kKBXxIq8XGGJM0m/7cxJBVQ1j+23IKZi5I32p9aVm8JRES2A0cidVhuyXkGvb9eZZ+E9fQesRSNh06wfOtyzP/Xw1oW7WgNVYYY4wxxjghXQao95hnRpG6fWHDVzC8Onz/HJw95nQ6Y4xJEyrcUIFxzcYxpukYskRn4ekfnqbTjE78fOjnoL+WNVgkYMrqAzR5ZxHfbz5Mn0alWPxkIx6sV5z0UZFORzPGGGOMMRlzQvNXoO8qqNQRfhrhmVHk4CqnkxljTJogItQtWJfJrSfz+i2vc/LiSXrM7cGzPzwb1NexWUISULNoTu6sWZj+TWLJmzXG6TjGGGOMMSYh2QtDu9FwU2/4eRTkSf6YFsYYY/wXIRG0LtGa5kWbM3nrZLKnzx7U41uDRQKK3JCR/7Sv5HQMY4wxxhjjj7wVPA0XxhhjHBEdGU3X8l2Dfly7JcQYY4wxxhhjjDGuYw0WxhhjjDHGGGOMcR1rsDDGGGOMMcYYY4zrWIOFMcYYY4wxxhhjXMcaLIwxxhhjjDHGGOM6oqpOZ0hxInIU2JvE3XIBf6RAnKSyHO7KAO7I4YYM4I4cbsgAgeUoqqq5UyKM2wRYh8Edn68bMoDlcFsGcEcON2QAd+QINIPV4sS54bMFy+G2DOCOHG7IAO7I4YYMEORr4jTRYBEIEVmpqjUth3tyuCGDW3K4IYNbcrghg5tyhBs3nFc3ZLAc7svglhxuyOCWHG7IEI7ccl4th7syuCWHGzK4JYcbMqREDrslxBhjjDHGGGOMMa5jDRbGGGOMMcYYY4xxHWuwuLaxTgfwshz/5YYM4I4cbsgA7sjhhgzgnhzhxg3n1Q0ZwHL4ckMGcEcON2QAd+RwQ4Zw5Jbzajn+yw0ZwB053JAB3JHDDRkgyDlsDAtjjDHGGGOMMca4jvWwMMYYY4wxxhhjjOtYg4UxxhhjjDHGGGNcJ003WIjInSKySUTiReSaU6+ISAsR2SoiO0TkaZ/lxUVkuYhsF5HJIhIdYI6cIjLXe5y5IpIjgW0aichan5/zItLOu+5DEdnts65qSmTwbhfn8zrTfJan5rmoKiI/ez+79SJyt8+6gM/FtT5nn/Xpve9th/e9FvNZ94x3+VYRuTXp7zxJOQaKyGbve58vIkV91iX4+aRAhm4ictTntbr7rLvf+/ltF5H7A83gZ44hPhm2ichxn3XBOhcTROSIiGy8xnoRkeHejOtFpLrPuqCdi3Dmhlrshjrsbw7vdilWi52sw979Ha/FbqjDfuZI8VpsdThtcEMd9h7H8Vrshjrsb46UqsVuqMN+5rBr4v+uD99arKpp9gcoB5QBFgE1r7FNJLATKAFEA+uA8t51XwCdvI/fAx4NMMdbwNPex08Db15n+5zAMSCj9/mHQMdkngu/MgCnr7E81c4FUBqI9T4uAPwGZE/OuUjsc/bZphfwnvdxJ2Cy93F57/bpgeLe40QG+P79ydHI57N/9EqOxD6fFMjQDRh5jb/NXd7fObyPc6RUjqu27wtMCOa58B6nPlAd2HiN9a2AWYAAdYDlwT4X4f6DC2qxP7Xnqu2DXoeTkuNaf9+pdS5IgTp8vc/ZZ5sUrcV+ZkjROpyEHN1IwVrsT4artrc6HKI/uKAOe/d1vBb7m+Faf9+peS6wa2K7Jk54+7CqxWm6h4Wq/qqqW6+zWW1gh6ruUtWLwCSgrYgI0Bj4yrvdR0C7AKO09e7v73E6ArNU9WyArxeMDH9L7XOhqttUdbv38SHgCJA7wNe7IsHPOZFsXwFNvO+9LTBJVS+o6m5gh/d4KZJDVRf6fPbLgEIBvlbAGRJxKzBXVY+p6l/AXKBFKuXoDEwM8LWuSVWX4LkYupa2wMfqsQzILiL5Ce65CGsuqcVuqMOB5Phbap6LFKrD4I5a7IY67FeORASr/lgdTiNcUofBHbXYDXXYrxx2TWzXxNcQVrU4TTdY+KkgsN/n+QHvshuA46p6+arlgcirqr8BeH/nuc72nfjnH+Fr3q43Q0QkfQpmiBGRlSKyTLzd73DwXIhIbTwtjTt9FgdyLq71OSe4jfe9nsDz3v3Z119JPdZDeFoyr0jo80mpDHd4z/NXIlI4ifsGMwfeLoDFgQU+i4NxLvxxrZzBPBcm5WuxG+pwUnKkZC12qg6DO2qxG+pwUnKkZC22Omx82TXx/7JrYuya2MuuiT1SpBZHBSWai4nIPCBfAqsGqeq3/hwigWWayPIk5/Ajg+9x8gOVgDk+i58BDuMpUmOBp4CXUyhDEVU9JCIlgAUisgE4mcB2qXUuPgHuV9V472K/zkVCh0tg2dXvISh/C0HI4dlQ5F6gJtDAZ/E/Ph9V3ZnQ/snMMB2YqKoXRKQnnlb2xknJH6QcV3QCvlLVOJ9lwTgX/kiNv4uQ54Za7IY6HMQcyarFLq3D4I5a7IY67G+OlK7FVofDiBvq8PVy+JHB9zh2Tfzf49g1sV0TXxF2tTjsGyxUtWkyD3EAKOzzvBBwCPgDTzeXKG/L4pXlSc4hIr+LSH5V/c1bcI4kkucuYKqqXvI59m/ehxdE5APg8ZTK4O1uhqruEpFFQDXga1L5XIhIVmAm8G9vl6Mrx/brXCTgWp9zQtscEJEoIBueblH+7Osvv44lIk3x/M+sgapeuLL8Gp9PUgvSdTOo6p8+T8cBb/rs2/CqfRcl8fX9zuGjE9D7qozBOBf+uFbOYJ6LkOeGWuyGOhysHMmtxS6tw+COWuyGOuxXjlSoxVaHw4gb6vD1ctg1cdJz2DWxXRNfJexqsd0Scn0rgFjxjPgbjeePYJqqKrAQz71zAPcD/rROJ2Sad39/jvOPe5K8RezKfXPtgARHbk1uBhHJcaU7mYjkAm4GNqf2ufB+DlPx3CP15VXrAj0XCX7OiWTrCCzwvvdpQCfxjJhcHIgFfvHzdZOcQ0SqAWOANqp6xGd5gp9PCmXI7/O0DfCr9/EcoLk3Sw6gOf/7zUdQc3izlMEzgM/PPsuCdS78MQ24TzzqACe8FwnBPBcm5WuxG+qwXzlSoRY7VYfBHbXYDXXY3xwpXYutDhtfdk3839exa2K7Jr7yWnZN/F8pU4s1CCOGhuoP0B5Pi88F4Hdgjnd5AeA7n+1aAdvwtEQN8lleAs9/hDuAL4H0Aea4AZgPbPf+zuldXhMY77NdMeAgEHHV/guADXgK0adA5pTIANT1vs467++HnDgXwL3AJWCtz0/V5J6LhD5nPF3n2ngfx3jf2w7vey3hs+8g735bgZbJ/Lu8Xo553r/XK+992vU+nxTI8DqwyftaC4GyPvs+6D1HO4AHUvJceJ+/CLxx1X7BPBcT8Yy6fQlPvXgI6An09K4XYJQ34wZ8RlcP5rkI5x9cUItxQR32N0dif9+pdS5IoTp8rc+ZVK7FfmRI8TrsZ44Ur8XXy+B9/iJWh0P6BxfUYe9xHK/F/mRI7O87Nc8Fdk1s18RpoBaL9wDGGGOMMcYYY4wxrmG3hBhjjDHGGGOMMcZ1rMHCGJuhvjkAACAASURBVGOMMcYYY4wxrmMNFsYYY4wxxhhjjHEda7AwxhhjjDHGGGOM61iDhTHGGGOMMcYYY1zHGiyMMcYYY4wxxhjjOtZgYUKGiAwSkU0isl5E1orIjUncv5iIbPRju/wiMsP7uOH/s3ffYVFdWwOHf5uiIAqK2FERG6JUQbF3xN6NSmJJTGKMxlhyY7qfxsQUa0zitfdubLFrNDbsJbHF2EUTAbErKrC/P2aYiwiItKGs93nmYeaUfdYMzDqHfXaJe55VKKUWK6UqmjsOIUTuI3nYQPKwEMKcJBcbSC7OHazMHYAQKaGUqgW0Bny11o+VUk5Angw63BBgWgaVnR5+Bv4DvGnuQIQQuYfk4WdIHhZCmIXk4mdILs4FpIWFyC5KABFa68cAWusIrfV1pZS/UmqvUuq4UuqAUqqAsdZ4l1LqiPFRO2FhSilLpdR3SqmDxtrpt+Ot7gRsTGSfEUqpmUqpHUqpC0qp9+Kt62ks57hSap5xWVml1Dbj8m1KqTLG5bOVUj8rpbYby2lgLPe0Ump2vDIDlVIhxvewTCmV37hqF9BUKSUVjkKIzCR5WPKwEML8JBdLLs5dtNbykEeWfwD5gWPAWeAnoAGG2uQLgL9xG3sMrYbyATbGZRWBQ8bnLsAJ4/O3gE+Nz/MCh4ByxsfheMdtCPxqfD4C2Gvc3gm4CVgDVYG/ACfjdo7Gn2uBXsbnrwOrjM9nA4sBBbQD7gIeGCoQDwPexvJ3AnbGfT4EPo8X1xagurl/L/KQhzxyz0PysORhechDHuZ/SC6WXJzbHlIbJbIFrfV9pVR1oB7QCFgCjAb+0VofNG5zF0ApZQdMVkp5AzFApUSKDAQ8lVKdja8dMCTy+0B4MqGs04Ya7cdKqTCgGNAYWK61jjDGEWncthbQ0fh8HvBtvHLWaq21UupP4IbW+k9j7CcxnEScAXdgj1IKDCeikHj7hwElMSRzIYTIcJKHJQ8LIcxPcrHk4txGKixEtqG1jgF2ADuMSe1dQCey6WDgBuCFoYY2KpFtFDBQa73pmYVK+QA2yYTxON7zGAzfIZVEHM+9hUTKiU1QZqyxzBhgi9a6exJl2QCPUnBMIYRIN5KHnyF5WAhhFpKLnyG5OIeTMSxEtqCUqqyeHQXYGzgNlFRK+Ru3KWDsw+aAoZY5FngNsEykyE3AO0opa+O+lYy10Gcx1Oa+jG1AV6VUYWNZjsble4FuxufBwO6XKHMfUEcpVcFYZj6lVPxa8UrAyZeMUwghUk3ysORhIYT5SS6WXJzbSAsLkV3kB35QShUEooFzGPrczTIut8VQu9oUQ3++FUqpLsB24EEi5U3HkISPKEP7snCgvdb6jlLqvFKqgtb6XEoC01qfVEqNBn5XSsUAR4HewHvATKXUB8by+6T0zWqtw5VSvYFFSqm8xsWfAmeVUsWAR1rrf1JanhBCpAPJw5KHhRDmJ7lYcnGuorROSasdIXIPpVQHDIP3fGruWBKjlBoM3NVazzB3LEIIkREkDwshhPlJLhZZQa6osHByctIuLi7mDkMIIZ5x+PDhCK11EXPHkRkkDwshsirJxUIIYV7J5eFc0SXExcWFQ4cOmTsMIYR4hlLqsrljyCySh4UQWZU5c7FSKgiYiGFsgela6zEJ1pcFZgJFgEjgVa11qHFdLwxN4wG+1FrPedHxJBcLIbKi5PKwDLophBBCCCFEJlNKWQI/Ai0wTNvYXSnlnmCz74G5WmtPYCTwtXFfR+ALoCZQA/hCKVUos2IXQojMIhUWQgghhBBCZL4awDmt9QWt9RNgMdAuwTbuGGZeAMOgiXHrm2OY6jFSa30L2AIEZULMQgiRqaTCQgghhBBCiMxXCrga73WocVl8x4FOxucdgALGKSNTsi8ASqm3lFKHlFKHwsPD0yVwIYTILLliDIvc7unTp4SGhhIVFWXuUITIlWxsbHB2dsba2trcoWQpkpuEyJ4kp6UblciyhKPhDwMmG6d13AlcwzCVZUr2NSzUeiowFcDPzy/nj7afgJxrhMg6UnP+kAqLRETfvMmdVasoFByMhY2NucNJs9DQUAoUKICLiwuG6ZWFEJlFa83NmzcJDQ2lXLly5g4nS5HcJET2k1Vz2qN7Tzi56zq+QWWxsMg2+SQUKB3vtTNwPf4GWuvrQEcApVR+oJPW+o5SKhRomGDfHekd4IPbtzi1azvezVthnSdvehefKeRcI0TWkNrzR4Z1CVFKzVRKhSmlTiSx3k0pFaKUeqyUGhZveWml1Hal1Gml1Eml1KB46xyVUluUUn8bf2bI4EL3Nm8m7LvvOR/UgtsrfkHHxGTEYTJNVFQUhQsXliQthBkopShcuLDc2UmE5CYhsp+sltOePo7h4LqLzPsshAO/XuTGxbvmDullHAQqKqXKKaXyAN2ANfE3UEo5KaXirtc/wjBjCMAmIFApVch4PRxoXJauzu7bzc75M5n1fj9O7NhKbGz2uyaWc40QWUNqzx8ZOYbFbJIf/CcSeA/D6MfxRQNDtdZVgADg3XgjJg8HtmmtK2IYgGh4ukZsVKh7d8rMmYNV0aL888knXGzfnnvbt6N19m1FJ0laCPOR71/S5LMRIvvJCt/bmJhYTuy8xvzPQjiw9iKl3Rzp/nkNSpR3MHdoKaa1jgYGYKhoOA0s1VqfVEqNVEq1NW7WEPhLKXUWKAaMNu4bCYzCUOlxEBhpXJaufILa0OWzr8jnUJBNP09g3n/e48KRg9numjgr/M0KIVL3XcywLiFa651KKZdk1ocBYUqpVgmW/wP8Y3x+Tyl1GsMgQqcwjIzc0LjpHAxN3z5M59ABsKtZA5cli7m3aTPh48cT+k5/8vn5UXTYUGy9vTPikEIIIYQQIhlaay4cC2ffqgvcvvGQEhUcaNHPg+Ku2aeiIj6t9XpgfYJln8d7vhxYnsS+M/lfi4sMU6aaJ8FfjePsvt3sXjSXld/8H87u1agf3IcSFSpn9OGFELlclp4lxFjh4QPsNy4qZqzQiKvYKJrMvmkeEVkphX1Qc1x/XUvxLz7n8cWLXOrWndD3BvH4wsVUlZlbhYaG0q5dOypWrEj58uUZNGgQT548AWDHjh20bt36uX127NiBg4MD3t7epsfWrVsByJ8/f6rimDBhAg8fPjS9btmyJbdv305y+ylTpjB37lwAZs+ezfXr15PcNqEOHTrg7e1NhQoVnnkfe/fuTVXs8a1cuZLvvvsuzeW8rCNHjrBx48aX2mfr1q0opZgzZ45p2cGDB1FKMWHCBAA++eQTtm/fnqqYIiMjmTJlSqr2Ta2YmBjq1auX6LpXX32VVatWZWo8IvVyY24CaNiwIWXKlHnmLmn79u1N8V+/fp3OnTu/VJnxrVq1ilOnTqV6/9SI/5nEd+nSJapVq5bo8oULF77UMS5duoRSis8++8y0LCIiAmtrawYMGJBsHCn11VdfpXrf1Erq723EiBF8/33ChrDmc/3v26z49jAb/3sCpaDlOx50GOqbbSsrshOlFJVr1aP3uJ9o/Ho/boZeZeEnQ1k77mtu/XPN3OFlebn5XFO5cmU8PT1xc3NjwIAByR7vZaxZs4YxY8Yku01KzmUuLi5ERES89PFT83n07t2bfPnyce/ePdOyQYMGoZQyxVC7du2XjiXOjh070uX/jJeR3O8htX+nz9FaZ9gDcAFOvGCbEcCwRJbnBw4DHeMtu51gm1spiaN69eo6PcTcv6/Dfpisz/j46lPuVfX1L77QT27cSJeyM9KpU6fMevzY2Fjt7++vZ86cqbXWOjo6Wr/++ut62LBhWmutt2/frlu1avXcfkkt11prOzu7VMVStmxZHR4enqp9GzRooA8ePPjS+yX3PrTW+unTp6mKxxymTZumBw0a9FL7bNmyRXt4eOigoCDTsiFDhmgvLy89fvz4NMf0999/ay8vrzSXk16Cg4P1ypUrn1ue2PcQOKQzMAdnpUdieVhy0/9kdm5q0KCB9vDw0Lt27dJaa33r1i1do0aNVMefUK9evfSyZcvSpay0unjxoq5atepzy1+Um5Mqy9XVVXt7e5uW/fTTT9rLy0u/++67aY5V69T/DWWEL774Qn/33XeJrsvM72/EtXv61x+P68lvb9Oz/rNLn9x9TcdEx6Rb+bk9F6fG44cP9J6l8/XE1zrpcd3b6i3TftT3b0WmS9npTc41/2OOc03cPo8fP9ZDhgzR9evXT9XxM0pqP5PUfB69evXSHh4eet68eVprrWNiYrSHh4cuVapUqn8v8SWXs80hqb/Tl70mzpItLJRS1sAKYIHW+pd4q24opUoYtykBhGVmXBZ2dhQZ8C7lt2ymULdu3F6+gvPNgwifNImY+/czM5Rs5bfffsPGxoY+ffoAYGlpyfjx45k5c+Yztbypcf/+fZo0aYKvry8eHh6sXr0agAcPHtCqVSu8vLyoVq0aS5YsYdKkSVy/fp1GjRrRqFEj4Nla1blz5+Lp6YmXlxevvfYa8L+7S8uXL+fQoUMEBwfj7e3NunXr6NChgymOLVu20LFjxxTH7ezszKhRo6hTpw4rV67kyJEj1KxZE09PTzp16sSdO3cAqFu3Lu+//z61atXCw8ODQ4cOATB9+nTef/99AP7991/atWtnin3/fkODpDZt2lC9enWqVq3K9OnTAYiOjqZgwYIMHz4cLy8vatWqRViY4Wu0evVqatasiY+PD4GBgablcR49esTIkSNZsGAB3t7eLF++nIiICNq2bYunpye1a9fmxIlEx9jF1dWVu3fvEhERgdaaLVu20Lx5c9P6+K0SnJ2dGTFiBD4+Pnh6enL27FkAPv30U1OLDAA3NzdCQ0MZPnw4f/31F97e3gwfbhjWZsyYMdSoUQNPT09GjhyZ5O/gk08+ISAgAH9/f44cOUJgYCDly5dn2rRpANy9e5fGjRvj6+uLp6cnv/766zOfI0BsbCz9+/fH3d2dNm3apKqWXphHbs9N3bp1Y/HixQD88ssvz2wXv1XC7Nmz6dixI0FBQVSsWJH//Oc/pu3i3z1Zvnw5vXv3Zu/evaxZs4YPPvgAb29vzp8/z/nz5wkKCqJ69erUq1ePM2fOPBfP7Nmzad++PW3atKFcuXJMnjyZcePG4ePjQ0BAAJGRhu7506ZNw9/fHy8vLzp16mT6XcVvDXD48GFTjvvxxx8Tff/Dhw9n165deHt7M378eKKioujTpw8eHh74+Pgk2erL1taWKlWqmPLxkiVL6Nq1q2l9/DgaNmzIhx9+SI0aNahUqRK7du0yvde4FhkArVu3ZseOHQwfPpxHjx7h7e1NcHAwAPPnz6dGjRp4e3vz9ttvE5PIQOANGzZk8ODB1K9fnypVqnDw4EE6duxIxYoV+fTTT03btW/f3nRemDp1qml5/L+30aNHU7lyZZo2bcpff/2V6GeQWe7fimLb3NMsGXWA63/fJqC9K8GjauFepyQWllnyEjbXyGObj9pdgnlj0jQ8mgTx52+bmPHem+xZuoAnj9KWP3Oa3H6uiZMnTx6+/fZbrly5wvHjxwEYN24c1apVo1q1aqZrvEuXLuHm5kbfvn2pVq0awcHBbN26lTp16lCxYkUOHDgAPJtHe/fuzXvvvUft2rVxdXVl+fLlprLizmUxMTEMGzYMDw8PPD09+eGHH56J79GjRwQFBTFt2rREP7/4En4ejx49Ytu2bfj4+ODh4cHrr7/O48ePE/0cunfvbipvx44d1KlTByur/43SEHde3bFjBw0bNqRz5864ubkRHByM4f/6Z39vhw4domHDhly6dIkpU6Ywfvx4vL292bVrF+Hh4XTq1Al/f3/8/f3Zs2fPc/Hs2LGDBg0a0LVrVypVqsTw4cNZsGABNWrUwMPDg/PnzwOwdu1a0/8JTZs25caNG8/9Hi5evEitWrXw9/d/piViWmW5aU2VYSSOGcBprfW4BKvXAL2AMcafqzM5PACsChem+Gef4tjzNcImTCDip5+5tXgJTu+8Q6FXuqLy5DFHWCny71df8fj08xeKaZG3ihvFP/44yfUnT56kevXqzyyzt7enTJkynDt3Ltmy4y4m46xYsYLy5cubXtvY2LBy5Urs7e2JiIggICCAtm3bsnHjRkqWLMm6desAuHPnDg4ODowbN47t27fj5OT0XIyjR49mz549ODk5mS6M43Tu3JnJkyfz/fff4+fnh9aaoUOHEh4eTpEiRZg1a5bpRJRSdnZ2psTh7u7O1KlTqVu3Lh9//DGjRo0yXfA+fvyYkJAQfvvtN/r27cuxY8eeKefdd9+lWbNmDBgwgOjoaNPJb86cOTg6OvLw4UP8/Pzo1KkTBQoU4M6dOzRo0IAxY8YwZMgQZs6cyfDhw6lfvz5t27ZFKcWUKVMYO3Ys33zzjek4tra2fP7555w4ccJ0UnnnnXeoWbMma9asYfPmzfTu3dt0EZ9Qp06dWL58OVWqVKFmzZrJzr9crFgxjh49yqRJkxg3blyyXT7GjBnDuXPnTJ/L+vXruXLlCvv370drTcuWLdm7d2+iTexcXFzYt28fAwcO5I033mD37t3cv38fLy8v3nzzTWxtbVm9ejUFChQgLCyMOnXqPNdsc/ny5Vy8eJETJ05w/fp13N3d6devX5LxisTtWnqWiKvpW/HrVDo/9bpWSnJ9bs9NTZo04c033yQmJobFixczdepURo0alei2x44d4+jRo+TNm5fKlSszcOBASpcunei2tWvXpm3btrRu3drUFLdJkyZMmTKFihUrsn//fvr3789vv/323L4nTpzg6NGjREVFUaFCBb755huOHj3K4MGDmTt3Lu+//z4dO3bkzTffBAwVmTNmzGDgwIHPlNOnTx9++OEHGjRowAcffJBonGPGjOH77783VUSOHTsWgD///JMzZ84QGBjI2bNnsUlkevO4yp7ixYtjaWlJyZIlk2waHB0dzYEDB1i/fj3/93//Z2rSnVRMkydPNuWz06dPs2TJEvbs2YO1tTX9+/dnwYIF9OzZ87l98+TJw86dO5k4cSLt2rXj8OHDODo6Ur58eQYPHkzhwoWZOXMmjo6OPHr0CH9/fzp16kThwoVNZRw+fJjFixdz9OhRoqOj8fX1fe47khmiHjzlyKbL/LE9FK01nk1K4xfkgk3+pM8bwjzsChai6RvvUL1lW3Yvnse+FYv4Y+sGAjp1w7NJcyytstbvbPvsqYRdvpCuZRYt60qj3m8luT63n2vis7S0xMvLizNnzhAdHc2sWbNM12s1a9akQYMGFCpUiHPnzrFs2TKmTp2Kv78/CxcuZPfu3axZs4avvvoq0a63//zzD7t37+bMmTO0bdv2ua4gU6dO5eLFixw9ehQrK6tn3uP9+/fp1q0bPXv2pGfPnqxYseK5zy+5zyMqKorevXuzbds2KlWqRM+ePfn5559NNxfjq1ixIqtXr+bWrVssWrSIV199lQ0bNiT6eR09epSTJ09SsmRJ6tSpw549e6hbt26i27q4uNCvXz/y58/PsGGGCTh79OjB4MGDqVu3LleuXKF58+acPn36uX2PHz/O6dOncXR0xNXVlb59+3LgwAEmTpzIDz/8wIQJE6hbty779u1DKcX06dP59ttvTefNOIMGDeKdd96hZ8+eSd4sSI2MnNZ0ERACVFZKhSql3lBK9VNK9TOuL26cQ3oI8KlxG3ugDvAa0Fgpdcz4aGksdgzQTCn1N9DM+Nps8pQti/P48bgsW0reihW5MXo051u15s66dejYWHOGlqVorRMdETap5fHVq1ePY8eOmR7xk3RcGR9//DGenp40bdqUa9eucePGDTw8PNi6dSsffvghu3btwsEh+f6tv/32G507dzYlcEdHx2S3V0rx2muvMX/+fG7fvk1ISAgtWrRIdp+EXnnlFQBu3rxJVFSUKQH16tWLnTt3mrbr3r07AI0bNyYsLIz7CVrz7Nixg7fffhsAKysr7O3tARg/frzpDmNoaKiphtTW1tYUa/Xq1bl06RIAV65cITAwEA8PD8aNG8fJkydf+B52795tqoUPDAzk+vXrPHjwIMn3u3TpUhYtWmR6T0mJq6WPH19Kbd68mQ0bNuDj44Ovry/nzp0ztdJIqG1bwyDsHh4eBAQEYGdnR7FixbCwsOD+/ftorfnwww/x9PQkMDCQq1evPteCYufOnXTv3h0LCwucnZ1p2LDhS8UrzCe35yZLS0vq1q3LkiVLePToES4uLkmW26RJExwcHLCxscHd3Z3Lly8nG0d89+/fZ+/evXTp0sXUSuCff/5JdNtGjRpRoEABihQpgoODA23atAEM39G4XHDixAnq1auHh4cHCxYseC5X3blzh9u3b9OgQQMAU456kfj5zM3NjbJlyyaZO4KCgtiyZQuLFi0y5fKkpCWfbdu2jcOHD+Pv74+3tzfbtm3jwoXE/9mKn8+qVq1KiRIlyJs3L66urly9ehWASZMm4eXlRUBAAFevXuXvv/9+poxdu3bRoUMH8uXLh729vanMzBL9NIajW64w/7MQjm65QgXfogSPCKBu54pSWZHFFSpRijaDh9Nj9FgcSznz28wpzB7Sn79CdpnuCudWuf1ck1Dc38Pu3bvp0KEDdnZ25M+fn44dO5paoZUrVw4PDw8sLCyoWrUqTZo0QSn1zLkgofbt22NhYYG7u7vp7n98W7dupV+/fqbWDPHfY7t27ejTp4+pMvhlP7+//vqLcuXKUamS4SZJwmv5hDp27MjixYvZv39/kmOiAdSoUQNnZ2csLCzw9vZ+6XPI1q1bGTBgAN7e3rRt25a7d+8+M35GHH9/f9M5o3z58gQGBgLPnntDQ0Np3rw5Hh4efPfdd4n+n7Bnzx7TNX5Kz70pkZGzhCT7H4nW+l/AOZFVu4FEv71a65tAk7RHl75sPTwoM3sWD3bvJuz7sVwfOozImbMoOmwodrVqmTu8ZyTXEiKjVK1alRUrVjyz7O7du1y9epXy5ctz8+bNVJe9YMECwsPDOXz4MNbW1ri4uBAVFUWlSpU4fPgw69ev56OPPiIwMJDPP/88yXJSctJIqE+fPrRp0wYbGxu6dOnyTHOulLCzszMdOzkJ40oszoTLtm7dys6dO9m3bx+2trbUrVvXNOdxnngtgCwtLYmOjgYMLTU+/vhjWrZsydatW184kFFisSf3XkqVKoXWmt9//52ffvop0burcfLmzftcfFZWVsTGqwhMag5nrTWffvopb7zxxgvjjzuOhYWF6Xnc6+joaBYvXsydO3c4cuQIVlZWODs7J3pcmS4t7ZJrCZFRJDcZWgp06NCBESNGJFtm/O9H/O9l/NiS+k7GxsZSsGDB51qHveg48b+Xcd9JMDT9XbVqFV5eXsyePZsdO3Y8U0ZqPrO4/VIqT548VK9enbFjx3Ly5EnWrl2b5LZpzWe9evXi66+/fmFML8pnO3bsYOvWrYSEhJAvXz4aNmyYZfJZbKzm7IF/2b/mAvcjH1PG3ZGADuUpUrpApsci0qZEhcp0/fxrLh47xK6Fc/h1wjcUc/2F+sG9KVPNy9zhJdsSIqPIueZ/YmJi+PPPP6lSpUqSFdeQsnNBcvskls+Te4916tRhw4YN9OjRA6VUqj6/l9GtWzd8fX3p1asXFhZJtx9I6twb/xyS1PkDDOffkJAQbG1tk40nJZ/3wIEDGTJkCG3btmXHjh1JXjdkxDlEOgCmE6UU+evVo9zKXyj5zRiib0Vypc/rXOn7JlGJNL3JTZo0acLDhw9NowzHxMQwdOhQ00i5aXHnzh2KFi2KtbU127dvN931u379Ovny5ePVV19l2LBhHDlyBIACBQokWrPYpEkTli5dajppJGwKl9i+JUuWpGTJknz55Zf07t071e/ByckJW1tb06i+8+bNM90ZBJ7p51asWDFTRUecRo0ambpMxMTEcPfuXe7cuYOjoyO2tracPHmSgwcPvjCOO3fumCoV4s/oEV/Cz6B+/fosWLAAMFSSODs7PxdffKNGjeKbb75JNjknxcXFhcOHDwNw4MAB0x3DhDE1b96cGTNmmFp6hIaGpnpcibi/LysrK7Zs2cK1a8+PhF6/fn0WL15MbGws165d4/fff0/VsUTmk9xkuHv30UcfvbDVU1KKFSvG6dOniY2NZeXKlYnGZG9vT7ly5Vi2bBlguLCL67+cGvfu3aNEiRI8ffrUlH/iK1iwIA4ODuzevRsg0W0SxgjP5rOzZ89y5coVKldOesrGoUOH8s033zzTpSKlXFxcOHbsGLGxsVy9etXUJxvA2tqap0+fAobf//Lly01jCkVGRr5U65b47ty5Q6FChciXLx9nzpxh3759z21Tv359Vq5cyaNHj7h3716yFTHpQWvN5RM3WTr6INtmn8Y2fx7ave9Nm/e8pbIiG1NK4erjz2vfTCSo/2Ae3rnNslGfsOLrLwi7lL7dMbIDOdcYPH36lI8++ojSpUvj6elJ/fr1WbVqFQ8fPuTBgwesXLky2dYGaRUYGMiUKVNM/4DHf48jR46kcOHC9O/fH0j684sv/ufh5ubGpUuXTF18El7LJ1SmTBlGjx5tOt7Lin9NHL8yLOHvKDAwkMmTJ5tep+TGQVLi/k8Akvw/oU6dOqaxsZI696aGVFikM2VhgUO7dpTfsIGiH35I1J9/crFDR6598B+ehObOaZ+UUqxcuZJly5ZRsWJFKlWqhI2NjWnqtujo6Gdq9uKL67sX94gbRCdOcHAwhw4dws/PjwULFuDm5gYY+iDHDVI2evRo06Bjb731Fi1atDANNhSnatWqfPLJJzRo0AAvLy+GDBnyXCy9e/emX79+psF14o5funRp3N3d0/QZzZs3j8GDB+Pp6cmpU6eeGSTN3t6e2rVrM3DgQNNgkPFNnjyZTZs24eHhgZ+fH2fOnKFVq1Y8fPgQLy8vRo4cSc2aNV8Yw4gRI+jQoQMNGjSgWLFiiW7TuHFjjh8/jo+PD8uXL2fkyJHs3bsX/4JNKwAAIABJREFUT09PPv/8c2bNmpXsMerWrZvqJsZdunThxo0b+Pj4MGPGDFxdXQHDP0x+fn54eHgwfPhwWrZsSefOnQkICMDDw4OuXbuautE0b978ucFEk/Paa6+xd+9e/Pz8TH+/CXXu3JkyZcpQrVo1BgwYQP369VP1/kTmk9xk+AyGDRv2XH/mlBozZgytW7emcePGlChRwrS8W7dufPfdd/j4+HD+/HkWLFjAjBkz8PLyomrVqqaB4dasWZPsXavEjBo1ipo1a9KsWTPT55rQrFmzePfdd6lVq1aSd5Y8PT2xsrLCy8uL8ePH079/f2JiYvDw8OCVV15h9uzZSf7+wfC76dWr10vFHqdOnTqmJs/Dhg3D19fXtO6tt97C09OT4OBg3N3d+fLLLwkMDMTT05NmzZqZ7kr27ds3yTGDEhMUFER0dDSenp589tlnBAQEPLeNr68vr7zyCt7e3nTq1ClD/3m4cekuqycc5dfJx3n6OJrAN6rSZbgfzm7JN0UX2YeFhSVVGzTh9Qn/pf6rr/Pv338xb/ggNkwey93wTB0336xy+7kmODgYT09PqlWrxoMHD0z539fXl969e1OjRg1q1qxJ37598fHxSclHmip9+/alTJkypoFFE05rPWHCBKKiovjPf/6T5OcXX/zPQ2vNrFmz6NKli6kry4vGM3v77bef6+KTUl988QWDBg2iXr16WFpampa3adOGlStXmgbdnDRpEocOHcLT0xN3d3fTDc5Dhw7Rt2/flzrmiBEj6NKlC/Xq1UvymmHixIn8+OOP+Pv7PzfuR1qo3NCvzM/PT7/MST09xdy9y81p04mcOxdiYynUozuF+/XDqlChTIvh9OnTVKlSJdOO97ImTpzItWvX+Pbbb80dyksbMGAAPj4+Kep+kBp169Zl8uTJzwy4JLKnxL6HSqnDWms/M4X0HKXUKKAdEIthFqbeWuvrCbZpBIyPt8gN6Ka1fn4ErHgSy8OSmzJORucmIVL7/b0d9pB9qy5w/kgYtgWs8WtZjqr1SmJpZb57aFktF2ckc14TR92/z4HVyziyYQ1ojXfz1tTs0BXbAvYZelw512QcOdeI1HjZa+IsN0tITmNpb0/RoUMoFNyD8B9+IHLefG6v+IXCffvi2KsnFi/oU5TTvfHGG5w4cYKlS5eaO5SXVr16dezs7J4bIVeIbOw7rfVnAEqp94DPgWduEWittwPexm0cgXPA5kyOM8NJbhIifT28+4RD6y5yctd1LKwt8Gvlgk+zMuSxkUvR3MImf37qB/fBu3lr9i5bwJH1azixfQv+7Trj26IN1nmfn5Enp5NzjRAvJmeJTGJdvDglR4+mcO/ehI0bT/iECdxauBCngQMo2KED6iUHbMwpZsyYYe4QUi2u71hGiuuDLURm0FrfjffSDnhRE7zOwAatddomks+CJDcJkT6eREVzbOtVjm25QvTTWKrWLYlfKxfsHJLubiNyNnunIgS98z5+rdqza9Ecdi+aw7FNv1K7SzBVGzbBwsLyxYXkEHKuEeLFcud/yWaUt2JFSv/8Ew8PHSLsu+/597PPiZw9h6JDBpO/ceMMG507taOmCyHSLjt1vVNKjQZ6AneARi/YvBswLpmy3gLeAsMAU4mR3CRE9pOSnBYTE8upXdc5uO4ij+49pbxPEQLal6dgsbQNMihyDqcyLnT48AtCT51g54JZbP7vJA6vW0W9Hr1w9a2RrucGOdcIkTWk5ppYBt00k3x+fpRdvIhSkyZCbCyh7w7gcvCrPDxyNN2PZWNjw82bN7PVP01C5BRaa27evImNTdZo6qqU2qqUOpHIox2A1voTrXVpYAEwIJlySgAewKakttFaT9Va+2mt/YoUKfLceslNQmQ/L8ppWmvOHQ5j0Yj97Fx8lkLF7ej0YXWC3vaQygqRKGf3anT/8nvaDPmI2JgYVn07iiUjhnP9bPrMsifnGiGyhtReE8ugm1mAjo7m9opfiJg8mejwcPI3bULRIUPIa5wFIa2ePn1KaGhosvP0CiEyjo2NDc7OzlhbWz+zPCsP9KaUKgus01pXS2L9IKCq1jpFk9onloclNwmRPSWV0679dYu9v5wj7PI9HEvaUatDecpWK5zl72xn5Vyc3rL6NXFMdDQntm8hZPlCHty+RcUatanbvSeOJZ1TXaaca4TIOlJzTSxdQrIAZWVFoVe64tCmNZFz53Jz2nQutGlLwY4dcRowAOtiRdNUvrW1NeXKlUunaIUQOZVSqqLW+m/jy7bAmWQ27w58lJbjSW4SImeICL3PvlXnuXziJvkL5aVxzypUDiiOhUXWrqgQWY+llRVezVpQpV5DjqxbzcG1Kzh3aB8ejQOp1bkH+Qu9/LS3cq4RInuTCossxCJfPpz69aNg165E/DyFW4sXc2ftWhx79aJw3zewLFDA3CEKIXK2MUqpyhimNb2McYYQpZQf0E9r3df42gUoDfxunjCFEFnBvcgoDqy5wJn9/5LX1opaHcvj2dAZqzy5Z9BEkTHy2NgS0Kkbns1asG/FYo5v2cCpXdvxa9UevzadyJtPuhcJkVu8sEuIUuoQMAtYqLW+lSlRpbOs3vwtKU+uXiV8wkTurluHZcGCOL3Tj4Ldu2ORJ4+5QxNCpIO0NEPObrk5u+ZhIcTzoh485fDGy/y5PRQAz0bO+AaVxcbO+gV7Zk3p0SUku+Tk7JqLb//7D7sXz+WvkF3YFrAnoFM3vJq1wNIqe/7NCSGelVweTsmgm92AksBBpdRipVRzldU7I+YQeUqXptTY73FZsRwb9yrc+HoMF1q05M7atejYWHOHJ4QwL8nNQohMFf0khiObLjP/sxCObb1CRf+iBI8MoHanCtm2siIdSU7OQAWLl6D1+x8S/NV4ipR1Yfvsqcwa3I/Te36Xa2IhcrgUD7qplLIAWgM/Y2guPBOYqLWOzLjw0kd2rU1O6P6ePYSNHcvjU6fJW6UKRYcNJX+dOuYOSwiRSul0Vy9b5OackoeFyI1iYzV/7fuHA2svcv/WY8pWK0xA+/I4Oec3d2jpIj0H3czqOTkn5GKtNZePH2HnwtmEX75I0XLlqd+jD2U9vc0dmhAildI86KZSyhPoA7QEVmCY7q4u8Bsg2SGT5K9TB7tatbi7bj3hEyZw9Y2+2NWuRZEhQ7GtVtXc4QkhMpnkZiFERtJac/nPm4SsOk/k9QcUdbGnaW93SlUuZO7QsiTJyZlDKYWLd3XKevpwes/v7Fkyj+WjP6Wspw/1evSmWLny5g5RCJGOXlhhoZQ6DNwGZgDDtdaPjav2K6Xk9n4mUxYWOLRpTYHmgdxevJiIn37mUufO2LdqRZH3B5GndGlzhyiEyASSm4UQGenfC3cIWXme63/fxqGoLc3frEZ53yJZfopSc5GcnPmUhQXu9RpRKaAuxzevY98vS5g/fBBudRpQt9trOBQtbu4QhRDpICWDbrpqrS8kWFZOa30xQyNLRzmh+VtSYu7d4+b0GUTOmYOOiaFQt244vdMPK8eXn/ZJCJG50jjoZrbKzTk5DwuRk9z69wH7Vl/gwtFwbO3zUKOVC1XqlsTSMiXDnmVP6dQ9L1vk5Jycix8/fMCB1cs5sn4NsTExeAe2pGbHV8hn72Du0IQQL5BcHk5JhcURrbVvIgVWT8cYM1ROTs5xnt4II2LyZG6vWIGFrS2F+76BY69eWMi0T0JkWWmssMhWuTk35GEhsrMHdx5zcN0lTu2+jpW1Bd7NyuDdtDR5bFLUezhbS6cKi2yRk3NDLr4XGUHIsoWc2L4Vaxsb/Nt2onrLdljb2Jg7NCFEElI1hoVSyg2oCjgopTrGW2UPyDc+i7EuVpQSo0bi2Kc34ePHEz5xEpELF1Lk3QEU7NwJZZXzLziEyA0kNwsh0tOTR9Ec3XKFY1uvEButqVa/FH4tXchnL1Oop0R65GSlVBAwEbAEpmutxyRYXwaYAxQ0bjNca71eKWUNTAd8MVzTz9Vaf53Gt5TtFXB0IvDt96jeqj27Fs1lz5J5HNu8jtpdelCtYTMsLC3NHaIQ4iUk919sZQyjHBcE2sRbfg94MyODEqmX19UV5x9+4OGRo4R9/z3/jhhB5Jw5FBn8PgWaNZO+p0Jkf5KbhRBpFhMdy4md1zi0/hJR959SoXpRarZzpWBRaZn5ktKUk5VSlsCPQDMgFMO0qGu01qfibfYpsFRr/bNSyh1YD7gAXYC8WmsPpVQ+4JRSapHW+lLa31b2V9i5DO0/+JTQMyfZtWA2W6ZO5vCvq6jbvScV/GvJNbEQ2USSFRZa69XAaqVULa11SCbGJNJBPl8fyi6Yz/3ffiNs7DiuvTcIWy8vin4wjHx+6TJzlxDCDCQ3CyHSQsdqzh0OY9/q89yNiKJU5YLU6lCBYi725g4tW0qHnFwDOBc3/oVSajHQDohfYaExtNgAcACux1tup5SyAmyBJ8DdVMSQozm7VaXbyG85d2gfuxfOYc3YryhRyY36wX1wdpNZ9oTI6pLrEvIfrfW3QA+lVPeE67XW72VoZCLNlFIUaNKE/A0acHvlSiJ+mMzlV18jf6NGFB06hLwVKpg7RCHES5LcLIRIratnIgn55TzhV+5RuFR+Wg/wokxVR7nTnAbpkJNLAVfjvQ4FaibYZgSwWSk1ELADmhqXL8dQufEPkA8YrLWOTCTGt4C3AMqUKfOit5QjKaWo6F+L8r41OLFjC3uXLWTJFx9S3q8m9br3orBz7vxchMgOkusSctr4M2ePzJMLKCsrCnXpgkPr1kTOm8/NqVO50LYdDh3aU2TgQKyLy7RPQmQjkpuFEC8lIvQeIb+c58qpSPI75qVp7ypUrFEcCwupqEgHac3Jif0SEo6I3x2YrbUeq5SqBcxTSlXD0DojBigJFAJ2KaW2JpytRGs9FZgKhkE3UxlnjmBhaYlnkyCq1GnIkQ1rOLB6OXOGDaBao6bU6tKDAo5O5g5RCJFAcl1C1hp/zsm8cERGsrC1xemtNynYpTM3p/yXWwsXcvfXdTj2fI3Cb76Jpb00BxUiq5PcLIRIqbsRj9i/9gJnD9wgbz4r6nSuQLUGpbCylkEH00s65ORQoHS81878r8tHnDeAIONxQpRSNoAT0APYqLV+CoQppfYAfsAFRLKsbWyo2aErHk2as3/lUo5tWsfp3b/j27ItNdp1Jm8+O3OHKIQweuGk2kqpLUqpgvFeF1JKbcrYsERGsipUiGIfDcd1wwbsg5pzc/oMzjUL5ObMWcQ+fmzu8IQQKSC5WQiRlKj7T9m97G8WjNjH+SPh+AaW5bVRtfBuWkYqKzJIGnLyQaCiUqqcUioP0A1Yk2CbK0ATY7lVMMw+Em5c3lgZ2AEBwJm0v5vcI5+9A416vcnrE6ZQwT+AA6uWMX1gXw6vW0X006fmDk8IQQoqLIAiWuvbcS+01reAohkXksgseZxLUfKbbyi38hdsPTwI+/Zbzrdowe1Vq9AxMeYOTwiRPMnNQohnPH0Sw+GNl5j36V7++O0qlWsW59WRAdTqUJ68+azNHV5Ol6qcrLWOBgYAmzB0L1mqtT6plBqplGpr3Gwo8KZS6jiwCOittdYYZhfJD5zAUPExS2v9R3q+qdzCoWhxWr33Aa+OmUgx1wrsmDudWYPf5tSu7ejYWHOHJ0SultwYFnFilFJltNZXAJRSZXm+b91zlFIzMUzzFKa1rpbIejdgFoa5oz/RWn//on2VUiMwTBEVblz0sdZ6fQreg0iGjZsbZaZP40FICGHfj+Wf4R8ROWs2RYcOwa5ePRmMS4isKVW5WQiR88TGxHIm5F8OrL3AgztPcPF0IqC9K4VL5jd3aLlJqnOy8Vp2fYJln8d7fgqok8h+9zFMbSrSSbFy5en8ySgu/XGUXQtms2HyWA6t/YX6PXpT1stXromFMIOUVFh8AuxWSv1ufF0f40jDLzAbmAzMTWJ9JPAe0P4l9x0fv3JDpB+7WrVwWbaUuxs2ED5hIlffept8NWtSdNhQbD08zB2eEOJZqc3NQogcQmvNxeMR7Ft1nlv/PqRYOXsC+1ajZMWCL95ZpDfJyTmIi6cPZat5cWbvTnYvnseKr7+gTDUv6gf3oZirzLInRGZ6YYWF1nqjUsoXQ784hWHKpIgU7LdTKeWSzPowDAMEtXrZfUXGURYWOLRqhX2zZtxaspSIn37iUpeuFGgRRNH33ydP2bLmDlEIQepzsxAiZ/jn/B1CVp7jn3N3KFgsHy3e9qCct5PcATYTyck5j7KwoErdhlSsWYc/tqwn5JclzP/ofSrXqkfdbj0pWLyEuUMUIldIssJCKeWmtT5jTL7wvxGLyxibvB3J+PASNUAp1RPD9FFDjX0EnyNzTqeNypMHx9dexaFDeyJnzuTmrNnc27KVQl274vRuf6wKFzZ3iELkSlk4NwshMsGtfx8QsvI8F49HkM8+Dw2DK1OldgksLFMyLJlIb5KTcz4ra2t8W7ajasOmHFzzC4fXreLvAyF4NWtBQMdXyOcgLZqEyEjKMGZPIiuUmqq1fksptT2R1Vpr3fiFhRtaSfya2BgW8bYZAdxP2M0jsX2VUsWACAx9AkcBJbTWr78oDj8/P33oUGqnxxYAT8PCiPjxJ24vX45F3rw4vvE6hXv3xsJOpn0SIrWUUoe11n4vuU+ac3MyZY8C2gGxQBiGgd0STq+HUupboBWGgZu3AIN0UicTI8nDQqTNg9uPOfDrRU7vuY5VXkt8A8vi1aQ01nll1o+0Sk0ujrdvhuXkjCC5OO3uR94kZMUi/vxtM1Z58uLftiPVW7Unj42tuUMTIttKLg8nWWERb2cbrXXUi5Ylsa8L6Vhh8bJlx5HknH4eX7hI+IQJ3Nu8GUsnJ4q825+CnTujrGX0cSFeVhovklOdm5Mp015rfdf4/D3AXWvdL8E2tYHvMPTPBtgNfKS13pFc2ZKHhUidx4+iObrpMse3XSU2VlOtfin8WrpgWyCPuUPLMdKSi+OVke45OSNILk4/N69dZc/iefx9YC92BQtRq3N3qjUKxNIqJUMECiHiSy4Pp6T94N4ULstwSqn4ncU6YJjGSWSivK7lcJ40EZcli8nr4sK//zeS861bc3fjRl5U+SWESFfpnpvjKiuM7Eh8hHsN2AB5gLyANXAjLccVQjwv5mksx7ddZf6nIRzeeJly3kXoMSKAeq9UksqKrCnLXC+LzFG4VGnaDv2Y7qO+o2DxEmyd/hNzhr3L2f175JpYiHSU3BgWxYFSgK1SygfDAEIA9kC+FxWslFoENASclFKhwBcYLmzRWk8xln/IWF6sUup9DHfz7ia2r9Z6BvCtUsobwwXzJeDtl37HIl3YenlRZt5c7u/YQfi4cVx7fzA2np4UHToUu5o1zB2eEDlWWnNzCsofDfQE7gCNEq7XWocYmz7/Yzz2ZK316STKkrGEhHhJOlZz9uAN9q+5wL2bUTi7FaJWh/IULWtv7tBEIjI6J4usr2SlKrwy4hvOHz7AroWzWTvua0pUqEz94D44u7+wIbgQ4gWSG8OiF9Ab8AMO8r8EfA+YrbX+JTMCTA/S/C1j6ZgY7qxaTfgPPxD977/YNahP0SFDsalcydyhCZGlpXIMizTlZqXUVqB4Iqs+0VqvjrfdR4CN1vqLBPtXACYCrxgXbQE+1FrvTO64koeFeLErp24SsvI8EVfv41Q6P7U7VKC0u6O5w8rx0tg9L1tdL0suzlixMTGc/H0be5fO5/6tSFx9/anXvRdOZVzMHZoQWVpax7DopLVekSGRZRJJzpkjNiqKW/PnEzF1GrH37uHQrh1F3huIdcmS5g5NiCwpjRfJGZqblVJlgXUJxwlSSn2AoSJjlPH150CU1vrb5MqTPCxE0sIu3yVk5XlCz9yiQGEbarZ1pZJ/MZSFTFGaGdJpDItscb0suThzPH0cxdGNv3Jg1TKePHqEe4PG1O4SjL1TEXOHJkSWlNYxLJyVUvbKYLpS6ohSKjCdYxQ5gIWNDYX79qXC5k049unD3fXrOR/UghvffkfM7dvmDk+InCbdc7NSqmK8l22BM4lsdgVooJSyUkpZAw2ARLuECCGSdyf8EZtnnGTZ14eIuHqful0qEjwigMo1i0tlRfYj18vCxDqvDTXadeaNSdPwbdmWM7t3MOv9t9m5YBZR9++bOzwhspWUVFi8bhyILRAoCvQBxmRoVCJbsyxYkGL/+YDyGzdg37IlkbNmcS6wOTenTyc2KksNli1EdpYRuXmMUuqEUuoPY7mDAJRSfkqp6cZtlgPngT+B48BxrfXaNB5XiFzl0b0n7FpyloUj9nHxWDjVg8ry6pe18GpSGkvrlFyaiSxIrpfFc2wL2NOwZ19enzCVSrXqcnDtL8x4ry8H1/5C9JMn5g5PiGwhJfPuxFXxtwRmaa2PK6Wk2l+8kHXJkpQc8zWOffoQNm4sYd+PJXL+AooMHIhD+3YoS5k7Xog0SPfcrLXulMTyQ0Bf4/MYZMBjIVLl6eMYjm+7wpHNV4h+EkuVOiWo0aocdgXzmjs0kXZyvSySZF+kKC3eHUL1Vu3ZtWgOO+fP5OiGtdR55VWq1GuIhYVcEwuRlJRU4x9WSm3GkIA3KaUKALEZG5bISWwqV6LMf/9LmTlzsCpShH8++YSL7dtzb/t2mfZJiNST3CxENhEbE8vJXdeY/3kI+9dcxLlyIbp9VoNGwW5SWZFzSE4WL1TUxZVOH/0fXT4bTT6Hgmz8aTzzPhzEhaMH5ZpYiCSkZNBNC8AbuKC1vq2UKgyU0lr/kRkBpgcZYCjr0Fpzb9MmwsaP5+nlK+Tz86PoB8Ow9fIyd2hCZLo0DrqZrXKz5GGRG2mtuXgsgpBV57l94yElyjtQq2MFSpR3MHdoIp50GnQzW+RkycVZh46N5a99u9m9eC53bvxLaXcP6gf3oXgFmWVP5D7J5eEXdgnRWscqpS4ClZRSNukenchVlFLYBwVRoEkTbi1bRsSPP3HplW4UCAykyOD3yVuunLlDFCJbkNwsRNZ2/dxtQn45x78X7lKoeD5avuOBi6cT0ksgZ5KcLF6WsrDArXZ9KtaoxR9bNxKyYjELPhlCpYC61O3ek0LFZZY9ISAFFRZKqb4YBl5zBo4BAUAI0DhjQxM5mbK2xrFHDxzatiNy1ixuzprFvW3bKNi1C0X698eqiEz7JERyJDcLkTVFXn9AyKrzXPojAjuHPDR61Q23WsWxsJTBNHMyyckitSytrPEJaoN7/SYc+nUlh39dybmDIXg0CaJWp27YFSxk7hCFMKuUnD0HAf7AZa11I8AHCM/QqESuYZnfjiIDB1Bh8yYKvdKV28uWc655EOGTfiDm/gNzhydEVia5WYgs5P6tKH6be5rFo/Zz/ewtAtq7EjyqFu51S0plRe4gOVmkSd58+ajTNZg3Jk3Do3Egf2zdwIz33mTvsgU8efTQ3OEJYTYpmSUkSmsdpZRCKZVXa31GKVU5wyMTuYqVkxPFP/8cx549CZswkYiffuLW4sU49e9Poa5dUHnymDtEIbIayc1CZAGPHz7lyKbLHP8tFK01no1LU71FWWzzy3krl5GcLNKFXcFCNO37Lr4t27Nn8VxCli/i+JYNBHTqhmeTICytUvLvmxA5R0r+4kOVUgWBVcAWpdQt4HrGhiVyqzwuLjhPGM+jP/oQ9v1Ybnz5JZFz51L0/UEUCApCWchdKiGMJDcLYUbRT2M48fs1Dm24xOOH0VSqUYyabVyxd7I1d2jCPCQni3TlWLIUbYZ8xD9//8XOBbP4beYUjqxfTd1uvagUUEfGwxG5xgtnCXlmY6UaAA7ARq31kwyLKp3JiMjZk9aaB7t2Efb9WB6fPYtNtWoUHTYUu4AAc4cmRLpIj5HpjeVk+dwseVjkFLGxmr8P/Mu+NRe4H/mY0u6O1OpQniKlC5g7NJFK6ZWL45WXZXOy5OLsSWvNxaOH2LVwNhFXL1O8fEXqB/ehdFVPc4cmRLpI1SwhSinHRBb/afyZH4hMh9iESJJSivz162NXpw531q4lfNIkrvTug129ehQdOgQbNzdzhyhEppPcLIR5aK25cjKSkJXnuXntPkXKFKBxzyqUdkvsKylyC8nJIjMopXD19cfF25dTO7ezZ+l8lo78mHLe1anXozdFysoseyLnSq5LyGFAA/HbG8W91oBrBsYlhImytKRg+/bYt2jBrQULifjvf7nYoSP2bVpT5L1B5HEuZe4QhchMkpuFyGQ3Lt0lZOU5rv11G3snG5q94U7F6sVQFtIkW0hOFpnHwsKSag2bUrl2PY5t/JX9q5Yy98P3cK/XiDqvvIq9U1FzhyhEukuywkJrLVV1IkuxyJuXwq/3oWCnjtycNo3IefO5t2EjhXr0oHC/t7EqJNM+iZxPcrMQmed22EP2r77AucNh2OS3pt4rFalarxSWVjKekjCQnCzMwTpPXvzbdqJa40AOrFrG0Y1r+StkF97NW1OzQ1ds80sXNZFzJHnGVUq9Gu95nQTrBmRkUEIkx9LBgaLDhlF+4wbs27Yhct48zgc2J2LqNGIfPTJ3eEJkKMnNQmS8h3efsHPRXywasZ9Lf0bg19KF10bVwrNRaamsEM+QnCzMyTZ/ARq8+jqvT5iKW+0GHF63ihkD+3Jg9XKePnls7vCESBfJnXWHxHv+Q4J1r2dALEK8FOsSJSg5ejSuq1eRz8+P8HHjON88iFvLlqGjo80dnhAZRXKzEBnkSVQ0B369yPzPQjix6zpV6pbk1VG1qNnWlTy2MpWgSFSacrJSKkgp9ZdS6pxSangi68sopbYrpY4qpf5QSrWMt85TKRWilDqplPpTKWWT+rchsjN7pyIE9X+fXt/+QCk3d3YtnM3MQW/x5/bNxMbGmDs8IdIkubOvSuJ5Yq+FMJu8FStS+uefeHjoEGHffc+/n31O5Jw5FB0yhPyNGsm0TyKnkdwsRDqLiYnl1K7rHFx3kUf3nuLqU4QH4HheAAAgAElEQVSAdq4UKm5n7tBE1pfqnKyUsgR+BJoBocBBpdQarfWpeJt9CizVWv+slHIH1gMuSikrYD7wmtb6uFKqMPA0je9FZHNOZVzo8OEXXD31JzsXzGLzlEkc/nUV9Xr0wtW3hlwTi2wpuQoLncTzxF4LYXb5/Pwou3gR97ZsIXzceEL7v4tt9eoUHTqUfL4+5g5PiPQiuVmIdKK15vyRcPatPs+dsEeUqOBAy3cqUNzVwdyhiewjLTm5BnBOa30BQCm1GGgHxK+w0IC98bkDcN34PBD4Q2t9HEBrffPlQxc5VWl3D3p8OZa/D+xl96I5rPp2FKXcqlI/uDclK1Uxd3hCvJTkKizclFJ/YKgdLm98jvG1jHgssiSlFPaBgRRo1IjbK1YQPvlHLvfoQf6mTSg6ZAh5XeVPV2R7kpuFSAfXzt4iZOV5bly8i2NJO1r196SsR2G5AyleVlpycingarzXoUDNBNuMADYrpQYCdkBT4/JKgFZKbQKKAIu11t8mdhCl1FvAWwBlypRJyXsSOYBSiko161C+ek3+/G0zIcsXsuizD6hYozZ1u/fEsaSzuUMUIkWSq7CQ6jeRbSlrawp164ZDmzbcnDOHyBkzudCmLQU7dcJpwLtYF5Vpn0S2JblZiDS4ee0+IavOc/nPm+QvlJfGPd2oHFACC5miVKROWnJyYn90CVtldP9/9u47PKo67f/4+04HQkJCQu9NQDqhVwERUJqg0gRs6NoLa392XV2fn7uCZdVdRUUUQVSkCopYQamhSBGldzChSwsl9++POTw7YsqQzGROMvfrunIxc86ZM59M8MPxm3POF5igqmNFpA0wUUQa4DmGbw+0AE4CX4nIClX96g87VB0HjANISUmxM/FCTHhEBE2696J+xytYMWcGy2dNY3PqEhp1vYo2A4dQopTNsmfcLadpTXcUZBBjAiGsRAmS77yThEGDOPCf1zk8ZQpHZ88mccRwSt9yC+ElbdonU7hYNxuTN78dOs2y2Vv5ecl+ootF0KZ/TRpdUYmIqPBgRzOFWD47eTdQ2et5Jf57yccFtwA9nPda7NxYM8l57XeqegBAROYCzYA/DFgYAxAVU4w2AwbTuFtPFn8yhTVffsb6BV+Tck1/Uq65lujixYMd0Zgs2dxcJiREJCZS7onHqTnnU0p26cLB199gy5XdOfTuu2SeORPseMa4gog849yFfrWIfCEiFbLZ7h8iss75uqGgcxpzKU6fOMuiTzYz6S9L2LQ8jSbdqjDsmTY0u6qqDVaYYFsO1BaR6iISBQwCZl20zU6gK4CI1ANigHRgHtBIRIo7N+DsxO/vfWFMlorHl6LrzXcw8oX/ULNZS5Z8MoW377uNlZ/N5vw5u2+rcR9RLfpnhqWkpGhqamqwYxgXObVuPWljx3By8RIiK1Ui+b77iLu6FxJmY3im4Din76YEO8cFIhKnqsecx/cC9VX1jou2uRq4H+gJRAPfAV0uvC471sOmoJ07c5413+5m5ec7yDh1jrqtytGyTw1KJtrMj+b3gtnFzjSlLwHhwHhVfVZEngZSVXWWMzPIm0AsnstFHlbVL5zXDgMec5bPVdWHc3s/62Jzsf1bNrFw8jvsXLeG+LLlaH/DjVzWpoMdE5sClVMP+zRgISLFgCqq+ou/wxUEK2eTFVXlxA+LSBs7lowNG4iuX48yDz1EbLt2wY5mQkR+D5ID2c0i8piz7z9dtPzPQLSq/t15/jYwT1U/yml/1sOmoGRmKr8s2c+y2Vs5fjiDKpeXpk3/miRVig12NONS/hqwKAzHy9bFJiuqyo4fV7Jg8gTSd2yjbI1adBgykqoNmwQ7mgkROfVwrkNnItIbWA187jxvIiIXn66W1evGi0iaiKzLZn1dEVksIhkiMtqX14pIoojMF5FNzp92lxiTZyJCbPt2VP9kKhWe/yeZR4+x65Zb2XnzLZxavz7Y8YzJUV672Yf9Pisiu4ChwF+y2ORHoKdzGnIScAW/vwbbe1+jRCRVRFLT09PzG82YHKkq29ce4MO/L+Pr9zZQPC6Kfg80pfc9jW2wwgRcoDrZmIIgIlRr0pxhz71Ejzsf4OSxo0z9+5NMffZ/SNu+NdjxTIjL9QwLEVkBdAG+VdWmzrI1qtool9d1BI4D76lqgyzWlwGqAv2Aw6o6JrfXisg/gUOq+pyIPAokqOojuX2TNppsfJF55gyHJ0/m4OtvcP7IEeKuuYbk++8jqpJN+2QCIz+/1ctHN38JlMti1ROqOtNru8eAGFX9axb7eAK4Ds911GnAMlV9Oaf3tR42gbR/21EWT9vC3k1HiE8uRqu+NajVvIxNUWp84o8zLPLayQXNutj44tyZM6ye9ylLp3/E6RPHqde+M+1uuJH4MmWDHc0UUTn1cE7Tml5wTlWPXuo/+qq6QESq5bA+DUhzrof29bV9gc7O43eBb4FcByyM8UVYVBSlR46k1IABHHzzLQ699x7H5s0jYfAgku64g4jExGBHNMZbXru5m4+bTgbmAH8YsFDVZ4FnAURkMrDpkkIY4ydHfj3Jkhlb2LIqnWIlI+k4qA71O1QgPNyuvTYFLk+dbIwbRURFkdL7Whp06c6ymVNZNXcWG5d8T+PuV9Oq//UUj4sPdkQTQnwZsFgnIkOAcBGpDdwLLApsrGyVVdV9AKq6zzlLI0siMgoYBVClSpUCimeKgvCSJSnz4AMkDB3CgVdf5fD7kzj6yTRK33YricOHE2bTPhl38Hs3i0htVb0w+NAH+DmLbcKBUqp6UEQaAY2AL/LzvsZcqhNHM0ids5313+8lPDKMFldXo8mVVYiK8eWwxpiAcNPxsjF+EVMilo5DRtL0qmtY9PEkVn02m3XfzKdl34E069WHyGi7ibEJPF9+BXEPcDmQgec3bkfx3CHe1VR1nKqmqGpKcnJysOOYQiiybFnKP/MMNWbPonjr1qS/9DJbrurB4Q8/Qs+dC3Y8YwLRzc85U5WuAboD9wGISIqIvOVsEwksFJGfgHHAMFW1/yBMgThz+hxLZ2/l/b8s4afv99KgQwVufKYNLXvXsMEKE2yF8njZGF+ULJ3EVXfcx/DnX6Hy5Q35fsp7jL9vFGu++pzM8+eDHc8UcQGd1tS5rOPTrO5h4bXNU8Bx73tYZPdaEfkF6OycXVEez3WCl+WWw67XM/5wcuVK0saM5dTKlURVr07ygw9Qsls3u0ba5JnbpjUNJOthkx/nz2WyfuFeUudu49RvZ6nZrAyt+9agVFk7483kn3WxMZdm94Z1LJg8gX0bfyaxYmU6DB5BzZRWdkxs8iy/s4TMF5FSXs8TRGSePwNeglnACOfxCGBmDtsa41fFmzWj6qT3qfTaqyDCnnvuZcfgIZxcsSLY0UwIclk3GxMQmqlsSv2VyX9bysIPN5JYvgQDH02hx6gGNlhhXMU62YSSSvUaMPjp5+nz0OOoKjPH/J0pf32EPT//FOxopgjy5fzJJFU9cuGJqh7O6d4RF4jIB3hukJkkIrvx3Lgt0tnH6yJSDkgF4oBMEbkfqK+qx7J6raq+DTwHfCQitwA78dyl3pgCIyKU7NqV2E6dODJ9OgdeeZUdQ4cR26ULZR58gOhatYId0YSOPHWzMYXF7p8PsXj6FtJ2/EbpiiW45u7GVLk80X6DZ9zKOtmEFBGhdsu21GzeinXfzGfRx5OY8teHqZnSmg6DR1C6UpYznhtzyXwZsMgUkSqquhNARKoCuV5HoqqDc1m/H8hyvsjsXquqB4GuuSY2JsAkIoKE664j/pprOPTeRA6++SZb+/Ql/tr+JN9zD5FlbdonE3B56mZj3O7A7t9YPG0LO386RGxiNF1H1qNOy3KEhdlAhXE162QTksLCw2nUrQf12ndmxdyZLJ81lXdH30WDK7rR9rqhxCaWDnZEU8j5MmDxBPC9iHznPO+IM/uGMaEurFgxkm4fRanrr+Pg629wePJkjs3+lMThwyl9262Ex8UFO6IpuqybTZFy7MApls7eysZlvxJdLIK2A2rRsHNFIiLDgx3NGF9YJ5uQFhkTQ+trb6BRtx4snfYhq7+Yy4bvv6P51X1p0WcA0cVLBDuiKaR8uummiCQBrQEBFqvqgUAH8ye7wZApKGd27yH9Xy9zbPanhMfFUfr220kYOoSw6OhgRzMulN8bvRWmbrYeNtk5ffwsqZ9vZ+23uxERGnepRNPuVYkpERnsaCZE+Oumm4Whk62LTUE58ut+fvhwIj//8B0xJeNo3f8GGnfvRUSkdbv5o5x6ONsBCxGpq6o/i0izrNar6ko/ZgwoK2dT0E5v2EDamLGc+OEHIiqUp8x99xHXuzcS5stMwiZU5OUgubB2s/Wwudi5M+f58etdrJy3k7Onz3FZm/K0vKY6JRNjgh3NhJj8DFgUtk62LjYF7detm1kweQI7164mLrks7W8YRt12neyY2PxOXgcsxqnqKBH5JovVqqpd/BkykKycTbCcWLSItDFjOf3TT0TXrUuZhx6kRPv2dtM4A+R5wKJQdrP1sLkg83wmPy/Zz7LZ2zhxJINqDUvTul9NSleMDXY0E6LyOWBRqDrZutgEy/Y1q1g4aQJp27eQXK0GHYeMpFrjLMf5TAjK04BFUWLlbIJJMzM5Nvcz0l96ibO7d1O8dWvKPPQQxRo2CHY0E2T+Og25MLAeNqrK9jUHWDxjK4f3naBs9TjaXluTCrUTgh3NhDjrYmMKhmZm8vOiBXw/ZSLH0n+lSsMmdBwykrI1bJa9UJdTD+d6000RGZ7VclV9L7/BjAkFEhZG/DVXE9f9Sg5P+ZAD//kP26+7jrhePUm+/36iqlQJdkRTCFk3m8Jk/9ajLJq2mX2bj1KqbHF6jGpAjabJdraZKTKsk43JnYSFUa99Z2q3asea+XNZPO1D3n/sfuq260S7G26kVNlywY5oXMiXWUJaeD2OwTOt6ErACtiYSyBRUSQOv5H4a/tzaPx4Dr4zgWNfzCfhhhtIuvNPRJS2aZ/MJbFuNq53eP8JlszYytbV6RSLi6LTkMuo16484eF27bIpcqyTjfFRRGQkzXr15fLO3Vg+axor5sxg45IfaNy9J62vHUTxuPhgRzQucsmXhIhIPDBRVfsEJpL/2elvxo3OpqVx4LV/c2TqVMKio0m89RZKjxhBWAmb9ilU+PM0ZLd3s/VwaDlxJINlc7ax4Yd9RESG0bR7FRp3rUxUjC+/JzGmYAXikhC3drJ1sXGj44cOsnjqB6z95gsio6Np0XsAza/uR2SM3YQ5VOTrkpAsnARq5y+SMSayTBnK/+0pEkeMIP3FFznwr1c4PPkDku+6k1IDByI27ZO5NNbNJugyTp1j1Rc7+PHLXWRmKg06VSSlZzWKx0UFO5oxBc062RgfxSaW5spRd9Ps6r58/8G7/PDR+6z+Yg5tBg6hYZfuhIWHBzuiCSJf7mExG7hwGkYYUB/4KJChjAkl0TWqU+mVf3Fq9Wp+HTOG/X97mkMT3iX5gQcoeVV3u8bbZMm62bjJ+bOZrFuwh9S52zl94iy1UsrQum8N4pOLBzuaMQXCOtmY/CtdsTJ9Rz/Jnl82sGDSO3z51musmDODDoNHUKtlGzsmDlG5XhIiIp28np4Ddqjq7oCm8jM7/c0UFqrK8W+/Jf2FF8jYtJmYxo0oO3o0xVu0yP3FptDJ51R6haqbrYeLJs1UNqX+ytJZWzl24DSV6ibQpn9NylSNC3Y0Y3zmj0tCCksnWxebwkJV2bJiGQsnT+DQnl2Ur30ZHYfeRKV6NsteUZSvS0JU9Tv/RzLGZEVEKHnFFcR27MjRGTNJf+UVdtw4nNhOnUh+6EFi6tQJdkTjEtbNJth2/XSIRdM3c2DXcUpXiqX3PY2pXD/RfgNmQpJ1sjH+JSLUSmlFjaYprP/uKxZ99D4fPvUoNZq3pMPgESRVrhrsiKaAZDtgISK/8d9T2y6WAWwBnlDVrwIRzJhQJuHhlBpwLXFX9+LQxIkcHPcm2/r2I75fP5LvvYfI8uWDHdEEiXWzCbb0nb+xePpmdm04TMnEGLrdVJ86LcoiYTZQYUKPdbIxgRUWHk7DLt2p264jK+fOYtnMqbz353u4vHNX2l43lJKlk4Id0QRYtgMWqloyu3UiEg40ACY5fxpjAiAsJoak224j4brrOPDGOA6//z7H5swh4cZhJI0aRXi8TfsUaqybTbAcO3CKJTO3smn5r8SUiKT9dbVp0LEi4ZE2RakJXdbJxhSMyOgYWvW/nkbderB0+kesnvcpP3//HU179aFl34HElIgNdkQTIHmaX0xVzwM/isgrfs5jjMlCeKlSlH3kYRKHDSX9X69waPw7HPl4Kkm3jyJh2DDCoqODHdG4gHWzCYRTv50h9bPtrPtuD2FhQvMeVWl6VVWii9kUpcbkxDrZGP8rVjKOzsNvpWmP3vzw0fssn/UJa7/8nFb9r6fJVdcQEWWzUhU1+fq1iKq+4a8gxpjcRVasSIV/PEf1GdMp1qQxac+PYUuPnhyZNh09fz7Y8YxL5LebRWS0iKiIZHmepYiMEJFNzteI/LyXca+zGedJnbudif+zmLXf7KZu63IMfboNrfvVtMEKYy5Bbp0sIj1E5BcR2Swij2axvoqIfCMiq0RkjYj0ymL9cREZ7e/sxrhVfJmy9Lr7IW587mXK1arDd++PZ/wDt7P+u6/IzLRj4qIk11lCigK7I7Ipqk4sWUramDGcXreO6Dp1KPPQg5To2NFueldI+OPO9P4mIpWBt4C6QHNVPXDR+kQgFUjBc932Cme7wznt13q48Mg8n8mGRftY9uk2Th49Q/XGSbTuV5PE8iWCHc2YgAhmFzuXjWwErgR2A8uBwar6k9c244BVqvofEakPzFXVal7rPwEygaWqOian97MuNkXVjrWrWTh5Ar9u3UxylWp0GDKSak2a2zFxIZFTD/t0hoWIVBWRbs7jYiKS7fV6xpiCU6J1K6p9/BEVX3yBzNOn2XX7HewcPoJTP/4Y7GimAASom18EHib7m8hdBcxX1UPOIMV8oIcf3tcEmaqydVU6U55ZxreTfiGudDH6j25Grz81ssEKY3yQx05uCWxW1a2qegaYAvS9aBsFLswVHA/s9XrPfsBWYH1+8xtTmFVt2IShz77A1fc9zJmM00x77ik+fuYJ9m/ZFOxoJp9yHbAQkduAqcCF09kqATMCGcoY4zsRIa5nT2rO+ZSy//MkGVu3sv2GQey+734ytm0LdjwTIIHoZhHpA+xR1ZxGvCoCu7ye73aWZbW/USKSKiKp6enp+YlmAmzv5iNMe34ln72xFoCedzTk2j83o0KtUkFOZkzhkI9O9qVTnwKGichuYC5wj/OeJYBHgL/lks262IQECQujbtuO3PTCf+hy0+0c2LWDSY8/wOyX/sHh/Xtz34FxJV8uQr0Lz+jvUgBV3SQiZQKayhhzySQyksShQ4nv249DEyZwcPx4fvvyS0pdfx3Jd91FRJJN+1TE5KmbReRLoFwWq54AHge657aLLJZleTaGqo4DxoHnNOTcspmCd2jvCRbP2ML2NQcoHh9F56GXUa9tecLCbeYPYy5RXo+XfenUwcAEVR0rIm2AiSLSAM9AxYuqejyn096ti02oCY+IpGmP3tTv2JXUT6eT+uk0Ni9bRKNuPWkzYBDF420wvjDxZcAiQ1XPXChCEYkg+1OFjTFBFh5bguS77yJh0A0c+Pe/OfzRxxydOYvSN91E4k03ER5rp3YXEXnqZlXtltVyEWkIVMdzR3vw/HZwpYi0VNX9XpvuBjp7Pa8EfJuH/CaIjh/OYNmnW/l50T4io8Np1bcGjbtWJjIqPNjRjCms8nq8vBuo7PW8El6XfDhuwbn0TlUXi0gMkAS0AgaKyD+BUkCmiJxW1Vfz9Z0YU0REFy9Ou+uH0qR7LxZP/YAf589l/XdfkXJNf1J69ycqpliwIxof+DJg8Z2IPA4UE5ErgTuB2YGNZYzJr4ikJMr95S8kDh9O2ksvc+C11zj8wQck3XknCddfh9i0T4WdX7tZVdcC//fbQBHZDqRcfNNNYB7wvyKS4DzvDjyW1/c1BSvj5FlWfrGTNV/tIlOVRldUpnmvqhSLtT4wJp/y2snLgdoiUh3YAwwChly0zU6gKzBBROoBMUC6qna4sIGIPAUct8EKY/6oRKkEut16J8169eX7Ke+yeOpkfpw/lzYDh9CwS3fCI2zmKzfLdZYQEQnDM7LbHc9pa/OAt7QQTS9id0Q2Bk6tWUPamLGcXLaMyCpVKHP/fZTs0QMJs1O/gyU/d6YPdDd7D1iISApwh6re6qy7Gc/lIwDPquo7ue3Peji4zp/NZO13u0n9bDsZJ85Rp2VZWvWpQVyS/XbJGH/MEpKfTnamKX0JCAfGq+qzIvI0kKqqs5yZQd4EYvGctfGwqn5x0T6ewjNgYbOEGJOLvRt/ZuHkCezesI6E8hVoP2g4tVu1sxlFgiinHrZpTY0JIarKiQULSBszloxNm4hp0IAyox+iROvWwY4Wktw4rWmgWA8Hh2YqG5ftZ+msbfx26DSV6yfSpl9NkqvYZF/GXGBdbEzoUVW2rlzOwskTOLh7J+Vq1aHj0JuoXL9hsKOFpJx6ONfzX0RkLX+8Bu8okAr8XVUPZvO68cA1QJqqNshifV3gHaAZ8IT3iLCI9ABexjPS/JaqPucsnwB0ct4fYKSqrs7tezDGeIgIsZ06UaJ9e47Omk36v/7FzpE3UaJDB8qMfoiYyy4LdkTjo7x2swkNqsqunw6xaPoWDu4+TnKVklxxY10q10sMdjRjiiTrZGMKFxGhZvOWVG/anJ+++5ofPp7ER397jOpNU+gwZCTJVaoFO6Jx+HLBzmfAeWCy83yQ8+cxYALQO5vXTQBeBd7LZv0h4F6gn/dCEQkHXgOuxHMjouUiMktVf3I2+bOqTvUhtzEmGxIeTqn+/Yjr1ZPD70/iwBtvsK1ff+L79Cb53nuJrJjlLJXGXfLazaaIS9txjEXTtrDnl8PEJcVw5S31qd28LBJmp7oaE0DWycYUQmFh4TS44koua9eRVZ/NZtnMj3nv4Xu4vGMX2l4/lLgkmxwz2HwZsGinqu28nq8VkR9UtZ2IDMvuRaq6QESq5bA+DUgTkasvWtUS2KyqWwFEZArQF/gJY4xfhUVHU/qWmyk1cAAH33yTQ+9N5Njcz0gYNozSo24jIiEh952YYMlTN5ui62j6SZbM3Mrm1DRiYiNpf31tGnSsSHiE3afGmAJgnWxMIRYZFU3LvgNp2PUqls34mFWfz+bnRQto2qM3LftdR7FYu5QyWHw5iokVkVYXnohISzw3/QE4F4BMFYFdXs93O8sueFZE1ojIiyISnd1ORGSUiKSKSGp6enoAYhpTdITHx1Nm9GhqzvucuN69OTRhAlu6X8WBcW+Sefp0sOOZrBV0NxuXOnnsDAumbGTyX5eyfc0Bmvesyo3PtKFxl8o2WGFMwbFONqYIKBZbkk7Dbubml96gbtuOpH46nbfvvZVlM6dy9kxGsOOFJF/OsLgVGC8isXjuenwMuFVESgD/LwCZsjpn9cI1gY8B+4EoYBzwCPB0VjtR1XHONqSkpBT9O4sa4weR5ctT4X+fJXHkCNLHvkD6Cy9weNIkku+9h/h+/ZDw8GBHNP9V0N1sXObM6XP8+NUuVn2xk3NnM6nfrjwtrqlOifhsx/KNMYFjnWxMERKXVIYedz5A82v6s3DyBBZOnsDqeXNoe/1Q6ne8grAwOyYuKLkOWKjqcqChiMTjmVXkiNfqjwKQaTdQ2et5JWCvk2WfsyxDRN4BRgfg/Y0JeTF16lD5jdc5sWwZaWPHsu+JJzn4zjuUefAhYq/obNM+uUAQutm4xPnzmWz4YR/LPt3GqWNnqNE0mdZ9a5BQrkSwoxkTsqyTjSmakqtU49pHn2LX+jUsmPQO8/7zEqmzp9FhyEhqNGthx8QFwJdZQqKBAUA1IOLCD0VVszyzwQ+WA7VFpDqwB89Ni4Y4Wcqr6j7xhOgHrAtQBmMMUKJlS6pNmcJvX8wn/cUX2X3nnRRLaU6Zhx6ieNOmwY4X0oLQzSbIVJWtq9JZMnMrR349Sfla8fS6oyHlasQHO5oxIc862ZiirfLljRjy7AtsXPID3095lxn/fJpK9RrQcehNlK9ts+wFki+XhMzEMy3TCsDnC3dE5AOgM5AkIruBvwKRAKr6uoiUwzPVUxyQKSL3A/VV9ZiI3A3MwzOt6XhVXe/sdpKIJOM51W41cIeveYwxeSMixF3VnZJdruDIJ5+Q/tpr7Bg8hJJXdiP5gQeIrlEj2BFDVZ662RROezcdZtG0Lfy67RgJ5Utw9Z2NqNqwtP1mxxj3sE42pogTES5r055aLVqz9usvWDx1MpOffIjardrSftAIEivYLHuBIKo5395BRNapaoMCyhMQKSkpmpqaGuwYxhQJmSdOcPDddzn01ttkZmRQasAAku6+i8gyNu3TpRKRFaqaksfXFqputh7Om4N7jrN4xhZ2rD1IbEI0LXtX57LW5QmzKUqN8Zv8dLHXPgpFJ1sXG+M/Z06fYsWnM1g+exrnzmTQqOtVtB4wmNiExGBHK3Ry6mFfzrBYJCINVXWtn3MZYwqhsBIlSL7zThJuuIED/3mdwx9+yNHZs0kcMZzSt95KeGxs7jsx/mDdXIT9dug0y2Zv5ecl+4mKiaBN/5o0uqISEVF2ky9jXMo62ZgQExVTjDYDB9OoWw+WTJvCmi8/Z/2Cr0m5pj8tel9LVLHiwY5YJPhyhsVPQC1gG55T3ARQVW0U+Hj+YaPJxgTOmZ07SX/pZY7NnUt4QgJJf/oTCYNuQKKigh3N9fJ5hkWh6mbrYd+cPnGWlZ/vYM03uwFo2LkizXtWI6ZEZJCTGVN0+ekMi0LRydbFxgTO4f17+X7KRDYuXkixuHjaDBhEo249CI+wf8Nzk1MP+zJgUTWr5QC0XaYAACAASURBVKq6ww/ZCoSVszGBd2rtOtLGjuXkkiVEVqpE8v33E9erJxIWFuxorpXPAYtC1c3Wwzk7d/Y8a7/Zw4rPt5Nx6hyXtSpHy97ViStdLNjRjCny/DRgUSg62brYmMDbv3kjCyZPYNf6NZQqW552g27kstbt7Zg4B/kasPDaSRkg5sJzVd3pn3iBZ+VsTMFQVU58/wNpY8eS8fPPxNSvT5nRD1GibdtgR3MlPx0kF4puth7OWmamsnHpfpbO2srxwxlUubw0bfrXIKlSyWBHMyZk+KOLvfbl6k62LjamYKgq21evYOHkCaTv3E7ZGrXoOPQmqjRoHOxorpSve1iISB9gLFABSAOqAhuAy/0Z0hhT+IkIsR3aU6JdW47Nnk36y/9i5823UKJdO8o89CAx9esHO2KRYd1cuKkqO9YdZMmMLRzcc4IyVUvSdUQ9KtW1G3UZUxhZJxtjvIkI1ZumULVxU37+/ju+/3AiHz/zBNUaN6PDkJGUqWaz7PnKl/NSngFaAxtVtTrQFfghoKmMMYWahIUR37cvNT7/jLKPPcrpdevYdu0A9vz5Yc7s3hPseEWFdXMh9eu2Y8x4YRVzXlvDuTOZXHVbAwY+mmKDFcYUbtbJxpg/CAsLp37HLtz84ht0GnYz+zdvZOKj9/HZq2M5mvZrsOMVCr7MEnJWVQ+KSJiIhKnqNyLyj4AnM8YUemFRUSSOGEF8//4cfOttDr37Lr99/jkJQwZT+o47iEhICHbEwsy6uZA58utJlszcwpaV6RQrGUnHQXWo36EC4eF2TasxRYB1sjEmWxFRUaT0vpYGXbqzbOZUVs2dxS+LF9Lkqmto1f96ipWMC3ZE1/JlwOKIiMQCC4BJIpIGnAtsLGNMURIeF0eZBx8gYegQ0l95hUMT3+fIJ9MofeutJI4YTlgxu7FgHlg3FxInj51h+Zxt/LRwL2GRYaRcXY2mV1YhKsaXf4KNMYWEdbIxJlcxJWLpOGQkTbpfzeKpk1k5dxZrv/6Cln0H0qxXHyKjY3LfSYjxZZaQEsApPJePDAXigUmqejDw8fzDbjBkjLtkbN5M2gsvcvzrr4lITibpnrspde21SERo/Q9cPmcJKVTdHIo9fOb0OVbP38mqL3eReTaT+u0rkHJ1NUrERwc7mjHGi59ugFwoOjkUu9gYNzuwczsLP3iXrSuXE5tYmrbXDeXyTl0JCw8PdrQCledZQkQkHJinqt0CFa4gWDkb404nV6wgbcxYTq1aRVTNmpR58AFiu3RBRIIdrUDk9SA50N0sIqOB54FkVT2QxfrP8Vyr/b2qXuPLPkOph8+fz+SnhXtZPmcbp347S81mZWjdtwalyhYPdjRjTBbyO2BRmI6XQ6mLjSlMdv+0jgWT32Hfpl8oXakK7QePoGbzlnZMTC433VTV88BJEYkPSDJjTEgr3rw5VSdPotKrr0BmJrvvupsdQ4ZycuXKYEdztUB2s4hUBq4EcpqK73ngRn+/d2GnqmxekcYHTy1lwZSNJJQrwcBHUugxqoENVhhThNnxsjEmvyrVb8DgZ8bQ58HHyTx/npnPP8OHTz3Cnl82BDta0Ply/vVpYK2IzAdOXFioqvcGLJUxJmSICCW7dSO2c2eOfDKNA6++yo4hQ4nt0oUyDz1IdM2awY7oVoHq5heBh4GZ2W2gql+JSOd8vk+RsueXwyyatpm0Hb+RWKEEV9/ViKoNSofMb0aMMXa8bIzJHxGhdqu21GjeknXfzGfx1MlM+cufqdWiNe0Hj6B0xcrBjhgUvgxYzHG+jDEmYCQigoQbrie+9zUceu89Dr75Flt796HUgGtJuvtuIsuWDXZEt/F7N4tIH2CPqv7oj//RFpFRwCiAKlWq5Ht/bnRg93EWT9/CzvUHiU2IpuvIetRpWY6wMBuoMCbE2PGyMcYvwiMiaHxlT+p3uIIVc2awfPYnvDv6Lhpe0Z02AwcTm1g62BELlC833YwBagEKbFHV0wURzJ/sej1jCp9zhw9z8PXXOTT5AyQ8nMThwyl9262ElywZ7Gh+k8+bbuapm0XkS6BcFqueAB4HuqvqURHZDqRkdQ8LZz+dgdGheg+L3w6dZumsrfyydD/RxSJo1qMqja6oRERkaN0ky5iiwE833SwUx8tFrYuNCQUnjx1lybQp/PjFZ4SFh9P86n606HMt0cVLBDua3+TpHhYiEiEi/wR2A+8C7wO7ROSfIhIZmKjGGOMRkZBA2cceo+ZncynZrRsHx41jS7crOThhAplnzgQ7XtDkt5tVtZuqNrj4C9gKVAd+dAYrKgErRSSrwY2QdfrEWX6YuolJf1nC5tQ0mnarwrBn2tCse1UbrDAmBOW3k0Wkh4j8IiKbReTRLNZXEZFvRGSViKwRkV7O8itFZIWIrHX+7OLv780Y4w7F4+LpMvJ2bnrxdWq1aM3S6R/y1r23sWLOTM6dPRvseAGX0003nwcSgeqq2lxVmwI1gVLAmIIIZ4wxUZUqUXHM81Sf9gkxl19O2nP/YGuPnhydNQvNzAx2vGAISDer6lpVLaOq1VS1Gp6D72aqut8foQu7c2fOs3LeDiY+uZjVX+2idsuyDH26NW0H1CKmhI3hGxPC8tzJzuwirwE9gfrAYBGpf9FmTwIfOfsdBPzbWX4A6K2qDYERwEQ/fT/GGJcqVbYcV9/7Z4b9v5coU60G3773Ju88cAcbFn5TpI+JcxqwuAa4TVV/u7BAVY8BfwJ6BTqYMcZ4i6lfnyrj36bK+LcJKxXP3ocfYdu1Azi+8Htyu7StiCnwbhaRFBF5y+v5QuBjoKuI7BaRqwLxvm6Qman89MNe3v/LEhZP30KFWvEMerIlXYfXo2RiTLDjGWOCLz+d3BLYrKpbVfUMMAXoe9E2CsQ5j+OBvc57rFLVvc7y9UCMiETn6zsxxhQKZWvU4ron/86Ax58mukQJ5r46lomP3c/2NauCHS0gcrrppmoW/xegqudFJKT+78AY4x4l2ral+tSpHJszl/SXXmLXbbdRvE1ryjw0mmINLg92vIJQIN3snGVx4XEqcKvX8w7+eh+3UlW2rz3I4ulbOLzvBGWqxXHlzfWpWCch2NGMMe6Sn06uCOzyer4baHXRNk8BX4jIPUAJoFsW+xkArFLVjKzeJBRugGxMKKrWuBlVGzbh50UL+H7KRD559n+o2qgpHYaMpGz1ojPLXk5nWPwkIsMvXigiw4CfAxfJGGNyJmFhxPe+hhqfzaXs44+TseFntg8cyJ4HH+LMrl2576Bws24OsP1bjzJ97Erm/nsNmecz6TGqAQMfaW6DFcaYrOSnk7OaTujiQY7BwARVrYTnjI2JIvJ/x+8icjnwD+D27N5EVcepaoqqpiQnJ+cSyRhTmEhYGPXad+amF1/nihG38eu2Lbz/6H3M+dfzHE0rGlf15nSGxV3ANBG5GViBp0BbAMWA/gWQzRhjchQWFUXi8BuJ79+Pg+PHc2jCuxybP5+EG24g6c4/EZGYGOyIgWDdHCCH959gycytbF2VTrG4KDoNuYx67coTHp7T2L4xJsTlp5N3A5W9nlfCueTDyy1ADwBVXezMRpIEpIlIJWA6MFxVt+T3GzHGFF4RkZE069WXyzt3Y/msaayYM4ONS36gSfdetLr2BorHxQc7Yp75Mq1pF+ByPKPA61X1q4II5k82hZMxoeFsWhoHXn2NI598QlhMDIm33EzpkSMJK1482NGylM9pTQtVN7u5h08czWD5p9v46Yd9RESG0bR7FRp3rUxUTE5j+saYosJP05pecieLSASwEegK7AGWA0NUdb3XNp8BH6rqBBGpB3yF51KSeOA74GlV/cTXnG7uYmOM/xw/dJBFUyez7uv5RMZE06LPQJr36ktkjDvvv5VTD+c6YFEUWDkbE1oytm4l7YUXOP7lV4QnJ5F8112UGjAAiXTXbA7+OEguLNzYw2dOnWPV/J2s/nInmeeUyztVJKVnNYrHRQU7mjGmAAWzi51pSl8CwoHxqvqsiDwNpKrqLGfWkDeBWDxnbzysql+IyJPAY8Amr911V9W0nN7PjV1sjAmcg7t38f2Ud9m8fAklEhJpO3AIDa64krBwd03FbgMWVs7GhKSTK1eRNmYMp1auJKpaNZIfeICS3a9EJKvLhgueDVgEx/lzmaxbsIfUuds5ffwstVPK0KpvDeKT3XkmjjEmsKyLjTFF3Z6ff2LBpHfYu3EDCRUq0WHwcGq1aFMojontfFdjTJFVvFlTqk56n+PffEPaCy+w5777iGnciLKjR1O8RYtgxzMFTDOVzSvSWDJzC8cOnKbiZQm0vbYmZarG5f5iY4wxxphCqmLd+gx6+p9sTl3C95PfZdbY/6V8nbp0HHoTleq6e5Y9G7AwxhRpIkLJLl2I7diRozNmkP7Kq+y4cTixnTuT/OADxNSpE+yIpgDs2nCIxdO3kL7zN0pXjOWaexpTpX6ia36zYIwxxhgTSCJC7RZtqNmsJeu+/ZLFH0/iw78+Qo3mLek4ZCSlK7lz2uOA3vpcRMaLSJqIrMtmfV0RWSwiGSIy+qJ1PUTkFxHZLCKPei2vLiJLRWSTiHwoInaxsTEmVxIRQamBA6n5+WckP/ggJ1esYFu//ux9/AnO7i8a0z6ZP0rf+Ruz/rWaWS+v5tTxM3QbWY8bnmhB1ctL22CFMcYYY0JOWHg4jbpexc0vj6P9oOHs/mkd746+m3mvv8xvBw8EO94fBHqutgk4UzFl4xBwLzDGe6GIhAOvAT2B+sBg56ZD4Jlr+kVVrQ0cxjPdkzHG+CSsWDGSRt1GzS/mkTh8OMdmz2bLVT1IGzOG80ePBjue8ZNjB04xf/x6Pvrf5aTtOEa7gbUY+rfWXNa6PBJmAxXGGGOMCW2R0TG06n89t/zrTZr27M2Ghd8w/r5RLJg8gdMnjgc73v8J6ICFqi7AMyiR3fo0VV0OnL1oVUtgs6puVdUzwBSgr3h+HdYFmOps9y7Qz//JjTFFXURCAmUffYSan39GXI+rOPj2eDZ39/yZmZER7Hgmj04dP8P3H21i0lNL2LIqnWZXVeXGZ9rQpFsVIiLddUdsY4wxxphgKx4XzxUjbuOmF9+gdqu2LJ85lbfvvY3UT6dz7syZYMcL+BkWeVUR2OX1fLezrDRwRFXPXbT8D0RklIikikhqenp6QMMaYwqvyIoVqfCPf1B9+jSKNWpE2vPPs6VnT47MmIGePx/seMZHZ8+cJ/Wz7bz/5GLWfLOLy1qVY9jTbWjTvybRxd01na0xxhhjjNvElylLr3tGM+y5lylboxbfTXyb8Q/czvrvviIzM3jHxG4dsMjqfF3NYfkfF6qOU9UUVU1JTk72azhjTNETU7cuVd4cR5UJ7xCRWJp9jz7GtmsHcHzBAkJh+ufCKvN8JusX7mHS/yxm6cytVKiTwKD/aUWXG+sRmxAd7HjGGGOMMYVK2eo1GfjEMwx84u8UKxnH5/9+kfcfuY9tq1cE5ZjYrbOE7AYqez2vBOwFDgClRCTCOcviwnJjjPGLEq1bU+2jD/nt889Je/Eldo26neItW1Lmz6Mp1rBhsOMZh6qy7ccDLJmxhcP7T1KuRhzdb2tAhVqlgh3NGGOMMabQq9qoCcMavMjPixfyw5T3mPb//kqVBo3oMOQmytWsXWA53DpgsRyoLSLVgT3AIGCIqqqIfAMMxHNfixHAzODFNMYURRIWRlyvXpTs1o3DH3/Mgdf+zfbrrqdkjx6Uuf8+oqpVC3bEkLZv8xEWTdvC/q1HKVW2OD1vb0j1Jkk264cxxhhjjB9JWBj12nWiTqu2/Dj/M5Z8MoVJjz/AZW060H7QcEqVKx/wDAEdsBCRD4DOQJKI7Ab+CkQCqOrrIlIOSAXigEwRuR+or6rHRORuYB4QDoxX1fXObh8BpojI34FVwNuB/B6MMaFLoqJIHDqU+L79ODR+PAcnTOC3L78k4frrSLrzTiKSkoIdMaQc2neCJTO2sO3HAxSPi6LTkMuo3648YeFuvbrRGGOMMabwC4+IpFnPPlzeqRupsz8hdc4MNi1bRKNuPWkzYBDF4wN3hquEwrXZKSkpmpqaGuwYxphC7lx6Oun//jdHPvqYsOhoEm++mcSRIwmPLZGn/YnIClVN8XNMV8pPDx8/nMHyT7eyYdE+IqLDada9Co27ViEy2mb9MMbkn3WxMcZcmuOHD7F46mTWfv0FEVHRtOhzLc2v7kdUTLE87S+nHrYBC2OMuUQZ27aR/tLL/DZvHuGlS5N0150kXHcdEnlps1HYQXLOMk6dY+W8Haz5aheZmUqDThVJ6VmNYiWjApTSGBOKrIuNMSZvDu3dzfcfvMemZYsoHl+KNgOH0LBLd8IjLu1Cjpx62K33sDDGGNeKrl6dSi+/xKkffyRtzFh+ffoZjn/zLVXeHBfsaEXG+bOZTHl6KccPZ1C7RVla9alBfHLeRu2NMcYYY4z/JVaoRJ+HHmfvxp9ZMOkdvnr732xbtZz+j/zVb+9hAxbGGJNHxRo3psp773JiwQIIKzqXJ4jIaOB5IFlVD1y0rgnwHzz3HjoPPKuqH/o7Q3hkGC17VyepUkmSq5T09+6NMcYYY4yfVKhTlxueeo6tK5df8tkVubEBC2OMyQcRIbZTp2DH8BsRqQxcCezMZpOTwHBV3SQiFYAVIjJPVY/4O0u9thX8vUtjjDHGGBMAIkLN5i39vl+7tboxxhhvLwIPA1ne4EhVN6rqJufxXiANSC64eMYYY4wxJlTYgIUxxhgARKQPsEdVf/Rx+5ZAFLAlm/WjRCRVRFLT09P9mNQYY4wxxoQCuyTEGGNCiIh8CZTLYtUTwONAdx/3Ux6YCIxQ1cystlHVccA48NyZPk+BjTHGGGNMyLIBC2OMCSGq2i2r5SLSEKgO/CgiAJWAlSLSUlX3X7RtHDAHeFJVlwQ4sjHGGGOMCVE2YGGMMQZVXQuUufBcRLYDKVnMEhIFTAfeU9WPCzSkMcYYY4wJKaJa9M/SFZF0YMclviwJOJDrVoFnOdyVAdyRww0ZwB053JAB8pajqqq68oaV3gMWIpIC3KGqt4rIMOAdYL3X5iNVdXUu+8tLD4M7fr5uyACWw20ZwB053JAB3JEjrxlc28X+ZsfEfuGGHG7IAO7I4YYM4I4cbsgAfj4mDokBi7wQkVRVTbEc7snhhgxuyeGGDG7J4YYMbspR1Ljhc3VDBsvhvgxuyeGGDG7J4YYMRZFbPlfL4a4MbsnhhgxuyeGGDIHIYbOEGGOMMcYYY4wxxnVswMIYY4wxxhhjjDGuYwMW2RsX7AAOy/FfbsgA7sjhhgzgjhxuyADuyVHUuOFzdUMGsBze3JAB3JHDDRnAHTnckKEocsvnajn+yw0ZwB053JAB3JHDDRnAzznsHhbGGGOMMcYYY4xxHTvDwhhjjDHGGGOMMa5jAxbGGGOMMcYYY4xxnZAesBCR60RkvYhkiki2U6+ISA8R+UVENovIo17Lq4vIUhHZJCIfikhUHnMkish8Zz/zRSQhi22uEJHVXl+nRaSfs26CiGzzWtckEBmc7c57vc8sr+UF+Vk0EZHFzs9ujYjc4LUuz59Fdj9nr/XRzve22fleq3mte8xZ/ouIXHXp3/kl5XhQRH5yvvevRKSq17osfz4ByDBSRNK93utWr3UjnJ/fJhEZkdcMPuZ40SvDRhE54rXOX5/FeBFJE5F12awXEfmXk3GNiDTzWue3z6Ioc0MXu6GHfc3hbBewLg5mDzuvD3oXu6GHfcwR8C62Hg4NbuhhZz9B72I39LCvOQLVxW7oYR9z2DHxf9cX3S5W1ZD9AuoBlwHfAinZbBMObAFqAFHAj0B9Z91HwCDn8evAn/KY45/Ao87jR4F/5LJ9InAIKO48nwAMzOdn4VMG4Hg2ywvsswDqALWdxxWAfUCp/HwWOf2cvba5E3jdeTwI+NB5XN/ZPhqo7uwnPI/fvy85rvD62f/pQo6cfj4ByDASeDWbv5tbnT8TnMcJgcpx0fb3AOP9+Vk4++kINAPWZbO+F/AZIEBrYKm/P4ui/oULutiX7rloe7/38KXkyO7vd0F9FgSgh3P7OXttE9Au9jFDQHv4EnKMJIBd7EuGi7a3Hi6kX7igh53XBr2Lfc2Q3d/vgvwssGNiOybOevsi1cUhfYaFqm5Q1V9y2awlsFlVt6rqGWAK0FdEBOgCTHW2exfol8cofZ3X+7qfgcBnqnoyj+/njwz/p6A/C1XdqKqbnMd7gTQgOY/vd0GWP+ccsk0Fujrfe19giqpmqOo2YLOzv4DkUNVvvH72S4BKeXyvPGfIwVXAfFU9pKqHgflAjwLKMRj4II/vlS1VXYDnYCg7fYH31GMJUEpEyuPfz6JIc0kXu6GH85Lj/xTkZxGgHgZ3dLEbetinHDnwV/9YD4cIl/QwuKOL3dDDPuWwY2I7Js5GkerikB6w8FFFYJfX893OstLAEVU9d9HyvCirqvsAnD/L5LL9IP74l/BZ59SbF0UkOoAZYkQkVUSWiHP6HUH8LESkJZ6Rxi1ei/PyWWT3c85yG+d7PYrne/fltb661H3dgmck84Ksfj6ByjDA+ZynikjlS3ytP3PgnAJYHfjaa7E/PgtfZJfTn5+FCXwXu6GHLyVHILs4WD0M7uhiN/TwpeQIZBdbDxtvdkz8e3ZMjB0TO+yY2CMgXRzhl2guJiJfAuWyWPWEqs70ZRdZLNMcll9yDh8yeO+nPNAQmOe1+DFgP56SGgc8AjwdoAxVVHWviNQAvhaRtcCxLLYrqM9iIjBCVTOdxT59FlntLotlF38Pfvm74Iccng1FhgEpQCevxX/4+ajqlqxen88Ms4EPVDVDRO7AM8re5VLy+ynHBYOAqap63muZPz4LXxTE34tCzw1d7IYe9mOOfHWxS3sY3NHFbuhhX3MEuouth4sQN/Rwbjl8yOC9Hzsm/u9+7JjYjokvKHJdXOQHLFS1Wz53sRuo7PW8ErAXOIDnNJcIZ2TxwvJLziEiv4pIeVXd5xROWg55rgemq+pZr33vcx5miMg7wOhAZXBON0NVt4rIt0BT4BMK+LMQkThgDvCkc8rRhX379FlkIbufc1bb7BaRCCAez2lRvrzWVz7tS0S64fnHrJOqZlxYns3P51ILKdcMqnrQ6+mbwD+8Xtv5otd+e4nv73MOL4OAuy7K6I/PwhfZ5fTnZ1HouaGL3dDD/sqR3y52aQ+DO7rYDT3sU44C6GLr4SLEDT2cWw47Jr70HHZMbMfEFylyXWyXhORuOVBbPHf8jcLzl2CWqirwDZ5r5wBGAL6MTmdllvN6X/bzh2uSnBK7cN1cPyDLO7fmN4OIJFw4nUxEkoB2wE8F/Vk4P4fpeK6R+viidXn9LLL8OeeQbSDwtfO9zwIGieeOydWB2sAyH9/3knOISFPgDaCPqqZ5Lc/y5xOgDOW9nvYBNjiP5wHdnSwJQHd+/5sPv+ZwslyG5wY+i72W+euz8MUsYLh4tAaOOgcJ/vwsTOC72A097FOOAujiYPUwuKOL3dDDvuYIdBdbDxtvdkz83/exY2I7Jr7wXnZM/F+B6WL1wx1DC+sX0B/PiE8G8Cswz1leAZjrtV0vYCOekagnvJbXwPMf4WbgYyA6jzlKA18Bm5w/E53lKcBbXttVA/YAYRe9/mtgLZ4ieh+IDUQGoK3zPj86f94SjM8CGAacBVZ7fTXJ72eR1c8Zz6lzfZzHMc73ttn5Xmt4vfYJ53W/AD3z+fcytxxfOn9fL3zvs3L7+QQgw/8D1jvv9Q1Q1+u1Nzuf0WbgpkB+Fs7zp4DnLnqdPz+LD/Dcdfssnr64BbgDuMNZL8BrTsa1eN1d3Z+fRVH+wgVdjAt62NccOf39LqjPggD1cHY/Zwq4i33IEPAe9jFHwLs4twzO86ewHi7UX7igh539BL2LfcmQ09/vgvwssGNiOyYOgS4WZwfGGGOMMcYYY4wxrmGXhBhjjDHGGGOMMcZ1bMDCGGOMMcYYY4wxrmMDFsYYY4wxxhhjjHEdG7AwxhhjjDHGGGOM69iAhTHGGGOMMcYYY1zHBixMoSEiT4jIehFZIyKrRaTVJb6+mojkOge1iJQXkU+dx50vPHYLEZkiIrWDncMYE3qshz2sh40xwWRd7GFdHBoigh3AGF+ISBvgGqCZqmaISBIQFaC3exB4M0D79of/AA8DtwU7iDEmdFgP/471sDEmKKyLf8e6OATYGRamsCgPHFDVDABVPaCqe0WkhYgsEpEfRWSZiJR0Ro0XishK56vtxTsTkXAReV5Eljuj07d7rR4AfJ7Fa54SkfEi8q2IbBWRe73WDXf286OITHSWVRWRr5zlX4lIFWf5BBH5j4h84+ynk7PfDSIywWuf3UVksfM9fCwisc6qhUA3EbEBR2NMQbIeth42xgSfdbF1cWhRVfuyL9d/AbHAamAj8G+gE57R5K1AC2ebODxnDRUHYpxltYFU53E1YJ3zeBTwpPM4GkgFqjtfK7zetzPwqfP4KWCRs30ScBCIBC4HfgGSnO0SnT9nAyOcxzcDM5zHE4ApgAB9gWNAQzwDiCuAJs7+FwAlnNc8AvzFK9d8oHmwfy72ZV/2FTpf1sPWw/ZlX/YV/C/rYuviUPuy0ShTKKjqcRFpDnQArgA+BJ4F9qnqcmebYwAiUgJ4VUSaAOeBOlnssjvQSEQGOs/j8RT5cSA9hyhz1DOinSEiaUBZoAswVVUPODkOOdu2Aa51Hk8E/um1n9mqqiKyFvhVVdc62dfj+UekElAf+EFEwPMP0WKv16cBFfCUuTHGBJz1sPWwMSb4rIuti0ONDViYQkNVzwPfAt86pXYXoFls+gDwK9AYzwjt6Sy2EeAeVZ33u4UiTYGYHGJkeD0+j+e/Ickmxx++hSz2k3nRPjOdfZ4H5qvq4Gz2FQOc8uE9jTHGb6yHf8d62BgTFNbFv2NdXMTZPSxMoSAil8nv7wLc0F6WVgAAIABJREFUBNgAVBCRFs42JZ1r2OLxjDJnAjcC4Vnsch7wJxGJdF5bxxmF3ohnNPdSfAVcLyKlnX0lOssXAYOcx0OB7y9hn0uAdiJSy9lncRHxHhWvA6y/xJzGGJNn1sPWw8aY4LMuti4ONXaGhSksYoFXRKQUcA7YjOeau3ec5cXwjK52w3M93ycich3wDXAii/29haeEV4rn/LJ0oJ+qHhWRLSJSS1U3+xJMVdeLyLPAdyJyHlgFjATuBcaLyJ+d/d/k6zerqukiMhL4QESincVPAhtFpCxwSlX3+bo/Y4zxA+th62FjTPBZF1sXhxRR9eWsHWNCh4j0x3PznieDnSUrIvIAcExV3w52FmOMCQTrYWOMCT7rYuMGdkmIMRdR1enA9mDnyMER4N1ghzCFmzNtWJqIrMtm/VDxTD+2RjzTpDV2llcWz/RjG0RkvYjcV7DJTSiwHjbGmOCzLjZuEBJnWCQlJWm1atWCHcMYY35nxYoVB1Q1ORjvLSId8dwB/D1VbZDF+rbABlU9LCI9gadUtZWIlAfKq+pKESmJ567c/VT1p5zez3rYGONWwezigmZdbIxxo5x6OCTuYVGtWjVSU1ODHcMYY35HRHYE671VdYGIVMth/SKvp0vwTCuGc53oPufxbyKyAagI5DhgYT1sjHGrYHZxQbMuNsa4UU49bJeEGGOMyc0twGcXL3QGPJoCS7N6kYiMEpFUEUlNT89pKvf/z959h0dVpQ8c/570HpJQQwgJhN4lFAXpIlUEgWUFFRAR7IXVdXEVy1oQsSw2VNDF+lsVwYKSkIQixRBJ6Go6IQRCCOltZs7vjwmzARJKJsmkvJ/n4SFzz7n3vnMh79w59xQhhGhalFLPlQ+5i1VKbVZK+VdRz1heJ1YptbHC9k+VUr8rpQ6WD/FzrLvohRCi7kiDhRBCiCoppUZibrB4/ILtHsDXwENa69zK9tVar9Zah2qtQ1u0aBK9rYUQ4kq9orXurbXuC3wPPFVFvSKtdd/yPzdV2P4p0BXoBbgCC2o3XCGEsI0mMSRECCHE1VNK9ca83Nl4rXVWhe2OmBsrPtVaf2Or+IQQoqG6oKHXHbiqSeW01j+e+1kp9Svlw/aEEKKxabINFmVlZaSlpVFcXGzrUIRoVFxcXAgICMDRUXqnNmRKqUDgG+A2rfUfFbYr4EPME3KutOYckoeFqD8kd9c9pdS/gNuBHGBkFdVclFJ7AQPwktb62wuO4QjcBlS5YpNSaiGwECAwMPCicsnFQtQuya/WabINFmlpaXh6ehIUFIT5/lsIYS2tNVlZWaSlpREcHGzrcOqENpjI330CO1cH3Pu3snU4V0wp9TkwAmiulEoDngYcAbTW72LunuwHvF2eIw1a61BgCOab4wNKqdjyw/2j4tO+KyV5WIj6oTHk7oyMDHbv3s3EiRPrzZcCpVQ40LqSoqVa6w1a66XAUqXUE8B9mPPwhQK11ulKqQ5AhFLqgNY6oUL528A2rfX2quLQWq8GVgOEhoZe1JNDcrEQtacx5NcrZTKVkJb2KY6OPrRpM7XGjttkGyyKi4slMQtRw5RS+Pn50RQmWNQmTVFcJjmbkzFml+Dat0WDarDQWv/1MuULqGRMtNZ6B1AjiVPysBD1Q0PO3WfPniUyMpK4uDhcXFwYMGAAbdu2tXVYAGitx1xh1c+AH6ikwUJrnV7+d6JSKgrzRMcJAEqpp4EWwN3WxCm5WIja05Dz65XS2kTGyY0kJq6kuPg4rVvfLA0WNUUSsxA1ryn8XhX/kU3OpiTKThTg6O+Oz7ROuHTysXVYDVJT+P8iREPQ0H4XCwsL2bFjB3v2mBcpuu6667j++utxdXW1cWRXRinVSWv9Z/nLm4CjldTxAQq11iVKqeaYe7gtLy9bANwIjNZam2ogHmsPIYSoQmP9/dJac+bMduITlpOffwRPjx506/sivr5DavQ8TbrBQgghrkbp8XxyNiVREn8Wex9nfGd1wbV3C5Rd4/wgEkKI+qasrIw9e/awfft2SkpK6Nu3LyNGjKBZs2a2Du1qvaSU6gKYgBRgEYBSKhRYVN7LrRvwnlLKhHllv5e01ofL93+3fL9d5V+GvtFaP1vH70EI0UTl5h4gPmE52dk7cXFpR4/ur9Gq1SSUqvlFSGVZUxtKS0tjypQpdOrUiY4dO/Lggw9SWloKQFRUFJMmTbpon6ioKLy9venbt6/lT3h4OAAeHh7ViuP111+nsLDQ8nrChAmcPXu2yvrvvvsu//nPfwD46KOPSE9Pv+JzTZ06lb59+xISEnLe+9i5c2e1Yq9o/fr1vPLKK1Yf52r99ttv/PTTT1e1T3h4ON7e3vTr14/OnTszfPhwfvzxqqcAqNKNN95IXl7eJessXbqUyMjIKss/+OADHnrooRqLqSEzZBWR9flRTv17H2Xp+XhP6kDrR0Nx69tSGisauKaYhwFGjBhBYGAgWv9vOPvNN99siT89PZ3p06df1TEr+vbbbzl8+PDlK9agitekouTkZHr27Fnp9s8+++yqzpGcnIyrqyv9+vWjW7duDBw4kI8//rjaMV9owYIFl71uVb3Pc6r6f9vQmUwmfvvtN958803Cw8MJDAxk8eLF3HzzzQ2xsQKt9S1a657lS5tO1lofL9++t7yxAq31Tq11L611n/K/P6ywv4PWumOFJU8bdGNFU87FXbp0oXfv3nTt2pX77rvvkue7Ghs3buSll166ZJ0ryfVBQUGcPn36qs9fnesxd+5cgoOD6dOnD507d+b222/n+PHjV33uyuzdu5cHHnjgsvWuu+66S5aPGDGCvXv31khMDVFhYQoHDz5I9N6byc8/SqdOT3Lt4J9p3fqmWmmsAMxdORr7n/79++sLHT58+KJtdclkMukBAwboNWvWaK21NhgMev78+XrJkiVaa60jIyP1xIkTL9qvqu1aa+3u7l6tWNq3b68zMzOrte/w4cN1dHT0Ve93qfehtdZlZWXViscW3n//ff3ggw9e1T5hYWF6ypQpltcxMTE6MDBQR0VF1XR41Vad93WOrX+/aoohr0Rnb4jXx/6xXac9uUOf/SlJG4tq7v8msFfXgxxZF38kD19aXefh4cOH6169eunt27drrbXOzs7WAwcOrHb8F7rjjjv0f//73xo5lrWSkpJ0jx49Ltp+uc+hKzlWQkKC7tOnj+X/UH1Qnfd1jq1/JytjMpn00aNH9apVq/TTTz+tV69erZOSkmr0HJKLJRefY4tcfG6fkpIS/cgjj+hhw4ZV6/y1pbrXpDrXo+Jnh8lk0itXrtSdOnXSJSUlV33+2lLd7z62/j2zVklJpj76+zK9JaKLjojsoeMTXtVlZbk1dvxL5WEZEgKc/S6B0vSCGj2mk787zSZ3rLI8IiICFxcX5s2bB4C9vT2vvfYawcHBPPPMM1adOz8/nylTppCdnU1ZWRnPP/88U6ZMoaCggJkzZ5KWlobRaOSf//wnJ0+eJD09nZEjR9K8eXMiIyMJCgpi7969NG/enP/85z+sWLECpRS9e/dm3bp1LFu2DA8PD0u92bNn4+rqyr/+9S8++OAD1q9fD0BYWBjvvPMO33zzzRXFHRAQwN13381PP/3EQw89RMeOHVm8eDFFRUV06tSJNWvW4O3tzdChQwkNDWXPnj3k5+ezdu1aQkND+eCDDzh48CCvv/46GRkZ3H333SQlJaGUYvXq1QwaNIjJkyeTnp5OcXExDz/8MAsWLMBgMNC8eXMWLVrEpk2bcHNzY8OGDbRs2ZINGzbwwgsvUFpaSosWLfjkk09o2bKlJeaioiKeffZZioqKiIqK4sknn2TEiBHMnz+f5ORkPDw8WL16daVP9yq65pprWLp0KatWrWL48OEkJSUxf/58srKyaNWqFWvXriUgIIA5c+bg7e3N4cOHSU1NZe3atXz44Yfs2bOHIUOG8OGHH1qu5cGDBzl9+jQ333wzgwYNYvfu3QQGBrJ+/XpcXFyYM2cO06dP5+abb2bPnj089NBDFBYW4uLiclHPi40bN/Lyyy/z3XffsXnzZp5//nns7e3x9fW9ZC+NhspUaiR/x3HytqahS424D2iN15hA7L2cbR1ao7Vp0yYyMjJq9JitW7dm/PjxVZY39Tw8a9YsvvjiC4YOHco333zDtGnTOHToEGDuSTBp0iQOHjzIRx99xMaNGyksLCQhIYGpU6eyfPlywPwUMz8/H4CvvvqK77//noULF7Jx40a2bt3K888/z9dffw3AvffeS2ZmJm5ubrz//vt07dr1vHg++ugjvv32W4xGIwcPHuTRRx+ltLSUdevW4ezszI8//oivry/vv/8+q1evprS0lJCQENatW4ebm5vlmixZsoSYmBjmz5+Pm5sbQ4cOrfTf6O9//ztHjhyhb9++3HHHHSxevJjFixezd+9eHBwcWLlyJSNHVrXSpFmHDh1YuXIljz76KPPmzePMmTPMnz+fxMRE3NzcWL16Nb1792bZsmUkJSVx4sQJ/vjjD1auXMnu3bvZtGkTbdu25bvvvsPR0ZERI0awYsUKQkND8fDw4MEHH+T777/H1dWVDRs20KpVq/PeZ3x8PIsWLSIzMxN7e3v++9//nhdfdHQ0Cxcu5Ouvv+bYsWM8+KB55UulFNu2bcPT0/OS78/Wjh07RlhYGKmpqfj6+jJjxgy6d+/eaMeD1wd//PEceflHavSYnh7d6Nz5n1WWN/VcfI6TkxPLly8nJCSEuLg4+vTpw8qVK1mzZg1g7oH10EMPkZyczLhx4xg6dCi7d++mT58+zJs3j6effppTp07x6aefMnDgQD766CP27t3LqlWrmDt3Ll5eXuzdu5eMjAyWL1/O9OnTz8v1RqORxx9/nJ9//hmlFHfddRf333+/Jb6ioiKmTp3KLbfcwq233nrR9fvLX/5iqfvVV1+ddz127drFzp07WbJkCQaDgQEDBvDOO+/g7Fz1fZVSiocffpj169ezadMmpkyZwueff84LL7yA1pqJEyfy8ssvA+bPonvvvZfw8HB8fHx44YUXeOyxx0hNTeX111/npptuIioqihUrVvD999+zbNkyUlNTSUxMJDU1lYceesjS+6Li59ry5ctZt24ddnZ2jB8//rweKyaTiXnz5tGuXTueeeYZ7rzzTvbu3YtSivnz5/Pwww9f7X/XeslgKODYsTWkpL6PyVSMf5uZBAc/gLNzy8vvXENkSIiNHDp0iP79+5+3zcvLi8DAQOLj4y+57/bt28/r/paQkHBeuYuLC+vXr+e3334jMjKSRx99FK01P/30E/7+/sTFxXHw4EHGjRvHAw88gL+/P5GRkRd98Tx06BD/+te/iIiIIC4ujjfeeOO88unTpxMaGsqnn35KbGwsEyZM4MiRI5ZZcNeuXWv58LlS7u7u/PLLL8yYMYM5c+bw6quvsn//frp06cJzzz1nqVdSUsKuXbt44403WLDgooUMuPfee7nhhhvYv38/MTExdOvWDYCPP/6YmJgYoqOjWblyJdnZ2QDk5OQwfPhw4uLiuPbaay0fDsOGDWP37t3s27ePadOm8eqrr553HldXV5566ilmz55NbGws06dP55///CeDBg1i//79LFu2jLlz517Re7/mmms4etQ859Y999zDggUL2L9/PzNmzDhvaEZOTg6RkZEsX76cyZMn8/jjj3P48GFiYmI4ePDgRcf9/fffeeihhzh06BCurq58++15S7hTXFzMrFmzeOutt4iLi2Pz5s3nfYB89dVXrFixwvJl4ZlnnmHLli3ExcVZPogbC23U5O85QcYre8ndnIJzx2a0erg/PtM6SWNFI9TU8/Do0aPZtm0bRqORL7744rybzQvFxsby5ZdfcuDAAb788kuOHTtWZd3rrruOm266iVdeeYXY2Fg6duzIwoUL+fe//01MTAwrVqzgnnvuqXTfgwcP8tlnn/Hrr7+ydOlS3Nzc2LdvH9dee62l2/W0adOIjo4mLi6Obt26WRpqK5o3bx5vvvkmu3btqjLOl156ieuvv57Y2Fgefvhh3nrrLQAOHDjA559/zh133EFxcXGV+59TMXc//fTT9OvXj/379/PCCy9w++23W+olJCTwww8/sGHDBubMmcPIkSM5cOAArq6u/PDDDxcdt6CggMGDBxMXF8ewYcN4//33L6oze/Zs7r33XuLi4ti5cydt2rSxlO3cuZNFixaxYcMGOnTowIoVK3jrrbeIjY1l+/bt9XpyytOnT/Pll1/y4YcfkpWVxcSJE7n33nvp0aOHNFY0Qk09F1dkb29Pnz59OHr0KDExMaxdu5Y9e/awe/du3n//ffbt2wdAfHw8Dz74IPv37+fo0aN89tln7NixgxUrVvDCCy9UeuwTJ06wY8cOvv/+e/7+979fVL569WqSkpLYt28f+/fvZ/bs2Zay/Px8Jk+ezK233spdd91V6fW71PVQSjF37lzL54jBYOCdd9657PWA/+XY9PR0Hn/8cSIiIoiNjSU6OtpyT1tQUMCIESOIiYnB09OTJ598krCwMNavX89TTz1V6XGPHj3Kzz//zK+//sozzzxDWVnZeeWbNm3i22+/Zc+ePcTFxfHYY49ZygwGA7Nnz6Zz5848//zzxMbGcvz4cQ4ePMiBAweu+vtPfWQylZF2/DN27R5FYtLr+PoOYdDAn+ja9fk6bawAmXQT4JI9IWqL1rrSD92qtld0/fXX8/3331/y2P/4xz/Ytm0bdnZ2HD9+nJMnT9KrVy+WLFnC448/zqRJk7j++usveZ6IiAimT59O8+bNAfD19b1kfaUUt912G5988gnz5s1j165dlxxnW5lzN8xZWVkUFxdbnozdcccd3HbbbZZ6f/2reUXGUaNGcerUKUtL6DlRUVF88cUXADg4OODl5QXAa6+9xsaNGwHzeMmEhAT69u2Lq6ur5Uls//792b7dvJx5amoqM2fOJCMjg5KSEjp37nzZ97Bjxw7LzefYsWOZO3cuBQUFuLu7X3I/c28osz179lj+jW+//Xb++c//PZmYPHkyAL169cLf35/u3bsD0L1790rHaoeEhNCrVy/Le0tOTj6v/MiRIwQGBnLNNdcA4O3tbSkLCwvj119/ZfPmzZbxoEOGDOH2229nxowZTJs27bLXoyHQWlN8KIucn5MxZBbh1N4L7zndcG7vZevQmoxL9YSoLU09D9vb2zN06FC+/PJLioqKCAoKqvK4o0ePtuSG7t27k5KSQrt27S4Zyzn5+fns3LmTGTNmWLaVlJRUWnfkyJF4enri6emJt7f3eflu//79gLlR48knn+Ts2bPk5+dz4403nneMnJwczp49y/DhwwG47bbb2LRp02Xj3LFjh+VpYteuXWnfvj1//PEHvXv3vuR+FXP3jh07LD1KRo0aRVZWFjk5OYD5/7ijoyO9evXCaDRabvB79ep1UV4G89PWc+P2+/fvT1hY2HnleXl5HD9+nKlTzUvHubi4WMqOHDnCwoUL2bx5M/7+/oA5dz/yyCPMnj2badOmERAQcNlrUtfy8vKIiorit99+s/Q4ufbaay/5FFbUrEv1hKgtTT0XVxYzmPPJ1KlTLfeP06ZNY/v27dx0000EBwdb7u169OjB6NGjUUpVmU/APE+RnZ0d3bt35+TJkxeVh4eHs2jRIhwcHC56j1OmTOGxxx6zNGJc7fX7/fffCQ4OttxH33HHHbz11ltXNFfauesRHR3NiBEjaNGiBWBusN22bRs333wzTk5O5+VUZ2dnS76t6npMnDgRZ2dnnJ2dadmyJSdPnjwvL4aHhzNv3jzc3Nwuuh533303M2fOZOnSpYC5t11iYiL3338/EydOZOzYsZd9X/WV1prMzJ9JSFxBYWES3t6h9O71Dt7e19gsJulhYSM9evS4aMKW3Nxcjh07RseO1jWgfPrpp2RmZhITE0NsbCytWrWiuLiYzp07ExMTQ69evXjiiSd49tlLz890JR8UF5o3bx6ffPIJn3/+OTNmzLAkvSt1LilXvAGszIVxVRbnhdvCw8PZtm0bu3fvJi4ujt69e1uenjk5OVnq2dvbYzAYAHNPjYcffpgDBw7w9ttvX9HTtgtjv9x7OWffvn2WniCXcu7Gzc7O7rybODs7O0vcldWH899bxfiq+ncOCQkhJyeHP//807Lt/fff55lnniE5OZk+ffpYeqk0VCVJOWS+E0fWJ0dAgd/t3WmxqLc0VjQBkofNw0Luv/9+Zs6cecljVpVHKsZWVX40mUw0a9aM2NhYy58jRyrvcn5hTquY786dc+7cuaxatYoDBw7w9NNPX3Te6lyzc/tVR8XcXdkxzsVS8b04OjpatleVuyvWqSp3V6VNmza4uLhYnsaCeQjMBx98QFFREYMHD7b0CqkPiouLiYiI4M0332Tfvn2EhobywAMPMGLECGmsaAIkF/+P0WjkwIEDdOvW7ZK/41eSKy+1T2XHvtR7HDJkCJs2bbLsV53rV13ncuyljnFhTr3a63G198fXXXcdkZGRls8fHx8f4uLiGDFiBG+99Valvb8bguzsX9kbM4MDB+9FKQd693qP/td8YdPGCrBRg4VSapxS6nelVLxS6qI+SUopZ6XUl+Xle5RSQRXKeiuldimlDimlDiilXC7cvyEYPXo0hYWFltZWo9HIo48+yty5cy0tedWVk5NDy5YtcXR0JDIykpSUFMA8E7Cbmxtz5sxhyZIl/PbbbwB4enpWuqLE6NGj+b//+z+ysrIAOHPmzEV1LtzX398ff39/nn/++SseClGZ5s2b4+rqalk9ZN26dZanZQBffvklYO5J0apVq4t6L4wcOZJ3330XMF/b3NxccnJy8PX1xdXVlUOHDhEdHX3ZOHJycmjbti1a6ypngr/wGgwbNoxPP/0UMDeSBAQEXLZ3RWxsLC+88AL33nsvAIMHD+b//u//APjkk08YNmzYZWOtrh49epCSkmL5/5Cbm4vRaAQgODiY//73v8yePdvyBSMxMZHBgwfz3HPP4ePjU2OzN9e1spMFnP74EJnv7cdwtgSfaZ1o9WB/XLv7SZfjJkLysPnp5BNPPGHptXa1WrVqxZEjRzCZTOcNEasYk5eXlyWXgPkmMC4urlrnA/NT+DZt2lBWVmbJtRU1a9YMb29vduzYAVBpnQtjhPNz9x9//EFqaipdunS5ZCzJycksWbLE0jOj4jGioqJo3ry5pYdfTfPy8iIgIMDSJbqkpMSyukGzZs344Ycf+Mc//kFUVBRgHpLSq1cvHn/8cUJDQ+tFg4XBYGDPnj28+eabbNu2jc6dO3PvvfcyceLEaq/yIBoeycVmZWVlPPHEE7Rr147evXszbNgwvv32WwoLCykoKGD9+vWX7clgjbFjx/Luu+9avrhXfI/PPvssfn5+luF8VV2/iipej65du5KcnGwZ4nPhfX1ltNa8+eabnDhxgnHjxjFo0CC2bt3K6dOnMRqNfP7555c9hjXGjh3LmjVrLHm14vW48847mTBhAjNmzMBgMHD69GlMJhO33HILzz33XKXXoz7Lz/+duLi7+G3fXykpOUG3ri8xaOAPtGgxpl7cE9f5kBCllD3wFnADkAZEK6U26v+tKw1wJ5CttQ5RSs0CXgb+opRyAD4BbtNaxyml/IAyGiClFOvXr+eee+7hueeew2QyMWHCBMu4M4PBUOVThXPj9c558sknz1uSaPbs2UyePJnQ0FD69u1rmdjswIED/O1vf7M83Tk3dmzhwoWMHz+eNm3anDdmr0ePHixdupThw4djb29Pv379+Oijj86LZe7cuSxatMgyoY6rqyuzZ88mMzPTMlShutatW2eZdDMkJIS1a9dayry8vLjuuuvIy8s7b/s5q1at4q677uK9997DwcGB9957j4kTJ7J69Wr69OlD165dGTRo0GVjWLZsGVOnTiUgIICBAwdy4sSJi+qMGjWKV155hX79+rF06VKeffZZ5s2bR+/evfHw8Kg0PoDIyEj69etHYWEhrVq14u2337Yk3lWrVnHnnXfy4osvWibdrC3Ozs58/vnnLF68mOLiYlxdXYmIiLCUd+/enXXr1nHLLbfwww8/8PDDD5OUlITWmrFjx152QtH6xpBTQm5YCoUxJ1FO9njdGITHEH/snOxtHZqoY5KHzddgyZIlV37RLvDSSy8xadIk2rVrR8+ePS3D82bNmsVdd93Fm2++yVdffcWnn37K4sWLef755ykrK2PWrFn06dOHjRs3snfv3ss+navoueeeY9CgQbRv355evXpV+uVi7dq1lkk3Lxwyck7v3r1xcHCgT58+zJ07l3vuuYdFixbRq1cvHBwc+Oijjyr9909ISKBfv34UFxfj6enJ/fffbxmvvGzZMkv+d3Nzq9ElTyuzbt067r77bp566ikcHR3Pm3SzVatWfPfdd4wfP541a9bwySefEBkZib29Pd27d7fJMKxzTCYThw4dIiIiguzsbIKCgrjhhhto27atzWISttPUc/Hs2bNxdnampKSEMWPGsGHDBsA8d8PcuXMZOHAgYJ50s1+/flUOcbDWggULLMPgHB0dueuuu7jvvvss5a+//jrz58/nscceY/To0ZVev4ouvB5r1661fMEfMGAAixYtqjSOv/3tbzz33HMUFhYyePBgIiMjcXJyok2bNrz44ouMHDkSrTUTJkxgypQptXItAMaNG0dsbCyhoaE4OTmd938S4JFHHiEnJ4fbbruNv//978ybNw+TyQTAiy++WGtx1aTi4nQSE1/nRMY3ODh40LHjY7QLuAN7+/rVH0BZ00WnWidU6lpgmdb6xvLXTwBorV+sUOfn8jq7yhspMoAWwHjgVq31nKs5Z2hoqL6wq9mRI0euqPu9rbzxxhscP37cMhN7Q3LffffRr18/7rzzzlo5/tChQ1m1atV5H1CifqmPv1+mIgN5UcfI+yUdtMZjcBs8RwVi7+5os5iUUjFa61CbBVAAL05OAAAgAElEQVSHJA/XrdrOw6JxqovfyYSEBMLDwzlx4gStWrVizJgxhISE2PQpnuRiycW1RXKxOKc+/Z6VleWQkvIux9I+RmtNu4DbCApajKOjj81iulQetsWkm22BitOLpwEXPuq21NFaG5RSOYAf0BnQ5Q0aLYAvtNaVZi+l1EJgIUBgYGCNvoHaduedd3Lw4EHLkICGpH///ri7u1+0moYQtqLLTOTvSic38hi62IBb35Z43dAeB9/61Xos6hfJw0LUrBMnThAeHk5CQgLe3t5MnTqVXr16YWcn06mJqkkuFqLmGI0lpB3/D8nJ72Aw5NK69RQ6BD+Cq2v97t1miwaLyprQL+zmUVUdB2AoMAAoBLaUt8Zsuaiy1quB1WBuTbYq4jpW2RJtDUVMTEytn+PcuGQhLkWbNIWxp8jdnILxbAnOnZrhPS4Yp7YyLlpcnuRhIWpGdnY2ERERliVcx44dy4ABA3B0tF3vNtFwSC4WwnpaG8nI+JaExNcoKTmBn+8wOnZ8DE/P+tHj43Js0WCRBlRcCy0ASK+iTlr5kBBv4Ez59q1a69MASqkfgWuAixosrkR1ZxIXQlStroeZVXb+kj+yydmUTFlGAY5tPfCZ3gmXENt1cxNVkzwsRP1Q07m7oKCA7du3Ex0djVKKoUOHMmTIEFxdXWv0PKJmSC4WovbY6t5Ya01WVhQJCa+QX/A7np696N5tOb6+19kknuqyRYNFNNBJKRUMHAdmAbdeUGcjcAewC5gORGitzw0FeUwp5QaUAsOB16oThIuLC1lZWfj5yYoAQtQUc2LMwsXFNsMtStPyyNmURElCDva+Lvj+tQuuvVqg7OR3vD6SPCxE/VCTubu0tJQ9e/awY8cOSktL6du3LyNGjMDb27sGIhW1QXKxELXHVvfGOblxxMe/zNmze3B1DaRnjzdp2XJCg/wdr/MGi/I5Ke4DfgbsgTVa60NKqWeBvVrrjcCHwDqlVDzmnhWzyvfNVkqtxNzooYEftdY/VCeOgIAA0tLSyMzMrIF3JYQ4x8XFhYCAgDo9pyGriJyfkynafxo7dweaTe6A+6A2KAcZG12fSR4Wov6wNncbjUZiY2OJiooiLy+Pzp07M2bMGFq2bFmDUYraILlYiNpVl/fGhYVJJCS8yqnMTTg6+tK58zLa+v8FOzunOjl/bbBFDwu01j8CP16w7akKPxcDM6rY9xPMS5taxdHRkeDgYGsPI4SwIWN+KblbUinYk4GyV3iOaofnsADsXGyS2sRVkjwsRMOntebo0aNs2bKF06dPExAQwPTp02nfvr2tQxNXSHKxEA1fSelpkpL+TXr6F9jZOREc9ACBgXfi4NDw526Tu3ohRINjKjGSvz2NvG3H0QYj7gNa4zW6PfZeDbf1WAghGprU1FTCwsI4duwYfn5+zJw5k27dujXILsdCCNEQGQz5pB5bQ2rqB5hMJfj7zyI46D6cnVvYOrQaY1WDhVJqL7AW+ExrnV0zIQkhROW00URBdAa54amY8stw7emH141BOLZws3VoNiN5WAhR1zIzMwkPD+f333/Hw8ODSZMm0a9fP+zt7W0dWq2QPCuEqG9MpjLS078kMelNysqyaNliPB07PoqbW+PrLWVtD4tZwDwgukIy36xtvUyAEKJR0VpTdPA0uT+nYDhdhFOwF963d8c50MvWodUHkoeFEHUiNzeXqKgo9u3bh6OjI6NGjWLw4ME4OTX63m2SZ4UQ9YLWmlOnfiQh8VWKilJo1mwQISHv4+3Vx9ah1RqrGiy01vHAUqXUP4FJwBrApJRaA7yhtT5TAzEKIZqw4oSz5PyUTNmxPBxaueF3R3dcuvpKl+NykoeFELWtuLiYX375hV27dmEymRg4cCDDhg3D3d3d1qHVCcmzQoj64Ez2LhLil5Obtx9398706f0Bfn4jGv09sdVzWCilemNudZ4AfA18CgwFIoC+1h5fCNE0lWUUkLMpieLfs7H3dsJnemfcrmkpS5RWQvKwEKI2GAwGoqOj2bZtG0VFRfTs2ZNRo0bh6+tr69DqnORZIYSt5OUfJSFhOVlZW3F2bkP3bstp3fpmlGqcw/AuZO0cFjHAWczLkP5da11SXrRHKTXE2uCEEE2P4WwxuZtTKNx3CuXsgPf4IDyu80c5No2kfLUkDwshaprJZOLgwYNERERw9uxZOnTowJgxY/D397d1aDYheVYIYQvFxekkJK4kI+NbHBw8Cen4OAEBd2Bv72zr0OqUtT0sZmitEytuUEoFa62TtNbTrDy2EKIJMRWWkRt1jPyd6QB4XN8WrxHtsHNztHFk9Z7kYSFEjYmPjyc8PJyMjAxat27NnDlzCAkJsXVYtiZ5VghRZ8rKzpKc/DZpx9cBEBi4gKD2i3F09LZxZLZhbYPFV8A1lWzrb+VxhRBNhC4zkr/zBLmRx9AlBtz6tcRrbHscmrnYOrSGQvKwEMJq6enphIeHk5iYSLNmzZg2bRo9e/bEzs7O1qHVB5JnhRC1zmgs5ljax6SkvIPBkE+b1lPp0OFhXFyaZu+2c6rVYKGU6gr0ALyVUhVblr0A+ZYhhLgsbdIU/naK3LAUjDkluHTxwWtcME5tmsYkbtayNg+XTxY3CTilte5ZSfls4PHyl/nAYq113JXsK4RoOM6cOUNERAQHDx7E1dWVcePGERoaioOD1dOcNXhyvyuEqAtaGzlx4hsSk16npCSD5n6j6NhxCR4eXWwdWr1Q3U+jLphvVpsBkytszwPusjYoIUTjpbWm+PdscjYlYThZiGOABz4zO+PSsZmtQ2torM3DHwGrgP9UUZ4EDNdaZyulxgOrgUFXuK8Qop4rKChg27ZtREdHY2dnx/XXX8+QIUNwcZHv4RXI/a4QotZorTmdFUFCwisUFPyJl1dfenRfiY/PoMvv3IRUq8FCa70B2KCUulZrvauGYxJCNFIlqbnkbEqiNCkXBz8XfG/timuv5o1+OabaYG0e1lpvU0oFXaJ8Z4WXu4GAK91XCFF/lZaWsmvXLn755RfKysro168fI0aMwMvLy9ah1TtyvyuEqC05OfuIj3+ZsznRuLoG0bPnKlq2GCf3xJWo7pCQx7TWy4FblVJ/vbBca/2A1ZEJIRqNssxCcn9OpuhgFnYejjSb0hH3ga1R9jI2urrqOA/fCWy62p2UUguBhQCBgYE1GI4Q4moZjUb27dtHVFQU+fn5dO3aldGjR9OiRQtbh1Zvyf2uEKKmFRQkkpC4gszMn3Fyak6Xzs/i7z8TOzuZZL4q1R0ScqT87701FYgQovEx5pWSG55CQXQGysEOrzGBeFwfgJ2zLFFaA+okDyulRmJusBh6tftqrVdjHkpCaGioruHQhBBXQGvNkSNH2LJlC1lZWbRr146ZM2dKI+KVqdU8q5R6DpgCmIBTwFytdXol9YzAgfKXqVrrm8q3fwiEAgr4o3z//NqIVQhhnZKSUyQl/5v09C+xs3OhQ/BDtGs3HwcHmbvtcqo7JOS78r8/rtlwhBCNganEQN624+RvT0MbNO4D2+A1OhB7Tydbh9Zo1EUeVkr1Bj4Axmuts2rrPEKI2pGSkkJYWBhpaWk0b96cWbNm0aVLF+lyfIXqIM++orX+J4BS6gHgKWBRJfWKtNZ9K9n+sNY6t3z/lcB9wEu1FKsQohoMhjxSUt8nNXUNWpfRtu2tBAfdh5NTc1uH1mBYNQW0UioM89rUZ8tf+wBfaK1vrInghBANizaYKPg1g9yIVEz5Zbj2bo7X2CAcm7vaOrRGq7bysFIqEPgGuE1r/Yf1kQoh6sqpU6cIDw/njz/+wNPTk8mTJ9O3b1/s7aV3W3XUVp4919hQzh24qp5oFRorFOB6tfsLIWqPyVTK8eOfk5S8irKyM7RsOZGOHR7Fza29rUNrcKxds6rFueQNUD6bfMvL7aSUGge8AdgDH2itX7qg3Bnz7PP9gSzgL1rr5PJJ3o4Av5dX3a21rqwlWghRh7TWFO0/Tc7mZIxZxTh38Mb7jmCc2nnaOrSmoLp5+HNgBNBcKZUGPA04lh/jXcxP+vyAt8ufxhq01qFV7au1/rAm35QQ4url5OQQFRVFbGwsTk5OjB49mkGDBuHkJL3brFStPHsllFL/Am4HcoCRVVRzUUrtBQzAS1rrbyvsvxaYABwGHq3iHDKfkBB1RGsTJ0/9QGLCSoqKU/HxuZaQjo/h5dXb1qE1WNY2WBiVUoFa61QApVR7LtO6q5SyB94CbgDSgGil1Eat9eEK1e4EsrXWIUqpWcDLwF/KyxKq6BYnhLCB4viz5PyURFlaPo6t3Wg2rwcunX2ky3Hdueo8DKC1vmgCuQvKFwALqrOvEKJuFRUVsWPHDvbs2YPWmsGDB3P99dfj5uZm69Aai2rl2fK64UDrSoqWaq03aK2XAkuVUk9gHtLxdCV1A7XW6UqpDkCEUuqA1joBQGs9r/ze+t+Y75XXXrizzCckRN04c+YX4hOWk5d3EA+PbvTtswZf32FyT2wlaxsslgI7lFJby18Po7wF9xIGAvFa60QApdQXmCccqthgMQVYVv7zV8AqJf/SQtQrpen55PyUTMkf2dh7O+MzozNu/Vqi7ORXtY5VJw8LIRqBsrIyoqOj2bZtG8XFxfTu3ZuRI0fi4+Nj69Aam2rnWa31mCs8x2fAD1TSYHFuIk6tdaJSKgroByRUKDcqpb4E/kYlDRZCiNqVl3eY+ITlnDmzHReXtnTv/iqtW92EUrIaXk2wqsFCa/2TUuoaYDDmGYof1lqfvsxubYFjFV6nAYOqqqO1NiilcjB3TQYIVkrtA3KBJ7XW2ys7iXR/E6J2GLKLyd2cQmHsKZSLA94TgvG41h/lKEnZFqqZh4UQDZjJZGL//v1ERkaSk5NDSEgIY8aMoXXryh7kC2vVVp5VSnXSWv9Z/vIm4GgldXyAQq11iVKqOTAEWF7+IK+j1jq+/OfJle0vhKg9RUVpJCauJOPkBhwcmtEpZCkBAbOxs3O2dWiNSrUaLJRSXbXWR8uTN8C5JZgCy7vM/Xap3SvZdmH3tKrqnMDcLS5LKdUf+FYp1eOCSYvMlaX7mxA1ylhQRl7kMfJ3pYNSeA4LwHN4AHZusm60LViZh4UQDZDWmvj4eMLDwzl58iRt2rRhypQpdOjQwdahNUp1kGdfUkp1wbysaQrlK4QopUKBReVD87oB7ymlTIAd5jksDivzo9uPlVJemO+b44DFVsYjhLgCpaVnSE55h7S0T1BK0b79ItoH3o2jo5etQ2uUqtvD4hHMvRderaRMA6MusW8a0K7C6wD+9wFwYZ00pZQD4A2c0VproARAax2jlEoAOlNL62MLIcBUaiR/Zzp5UcfQJUbc+rfCa0x7HJpJ67GNWZOHhRANzPHjxwkLCyM5ORkfHx+mT59O9+7dsbOT3m21qFbzrNb6liq276V8DiGt9U6gVyV1TJh7Wwgh6ojRWMSxYx+RnPIuRmMh/m2mE9zhQVycpXdbbapWg4XW+ty4vfFa6+KKZUopl8vsHg10UkoFA8eBWcCtF9TZCNwB7AKmAxFaa62UaoG54cJYPvFQJyCxOu9BCHFp2qgp/O0kuWEpGHNLcenqi/e4IBxbu9s6NIHVeVgI0UBkZWURERHBoUOHcHNzY/z48fTv3x8HB2unIROXI3lWCAFgMhk4kfE1SYlvUFJ6kubNx9Cx4xI83DvZOrQmwdpPu53ANVewzaJ8Tor7gJ8xL2u6Rmt9SCn1LLBXa70R+BBYp5SKB85gbtQA8yRHzyqlDIARc3e5M1a+ByFEBVprio+cIeenZAynCnFq54nvrC44d2hm69BE5a46Dwsh6r/8/Hy2bt1KTEwM9vb2DB8+nGuvvRYXF/mebAOSZ4VogrTWnD4dTnzCCgoL4/H26kePnm/g02yArUNrUqo7h0VrzBNjuiql+vG/OSe8gMuuoaW1/hH48YJtT1X4uRiYUcl+XwNfVydmIcTllaTkkrMpidLkXByau+I3pxsuPfxkOaZ6yNo8LISon0pKSti1axc7d+6krKyM/v37M3z4cDw9PW0dWpMjeVaIputsTgzx8S+TkxODm1sHevV6mxbNx8o9sQ1Ut4fFjcBczPNPvMr/Enge8A/rwxJC1KWyzEJyfkqm+FAWdp6ONJsagntoa5S9JOV6TPKwEI2I0WgkJiaGrVu3UlBQQLdu3Rg9ejTNmze3dWhNmeRZIZqYgoJ44hNe4fTpcJycWtC1y/O0aTMDOzsZhmcr1Z3D4mPMMxPfUt7rQQjRABlzS8kNT6FgbwbK0R6vG9rjcX1b7JzsbR2auAzJw0I0DlprDh8+zJYtWzhz5gzt27dn1qxZtGvX7vI7i1oleVaIpqO4JIOkpDdJT/8v9vZudOjwCIHt5mFvL52pbM3apqKA8uWU8oD3MY/l+7vWerPVkQkhao2p2EDe1jTydxxHmzQeg/3xHNUOew8nW4cmrp7kYSEaqKSkJMLCwkhPT6dFixb89a9/pXPnztLluP6RPCtEI2Uw5JGc8h7Hjq1FayPtAm4nKOgenJz8bB2aKGdtg8V8rfUbSqkbgZbAPGAtIAlciHpIG0zk7z5BXkQqpkIDrn1a4D22PQ5+rrYOTVSf5GEhGpiMjAzCw8OJj4/Hy8uLKVOm0KdPH1mitP6SPCtEI2MylZCW9ilJyW9hMJylVaub6NjhEVxdpXdbfWNtg8W5RwATgLVa6zgljwWEqHe0SVO0P5OczSkYzxTjHNIM73FBOAXIJG6NgORhIRqIs2fPEhkZSVxcHC4uLtxwww0MHDgQR0dHW4cmLk3yrBCNhNYmMk5uJDFxJcXFx/H1GUpIyGN4evawdWiiCtY2WMQopTYDwcATSilPwGR9WEKImlL8ZzY5m5IoSy/AsY07PvN74typmXQ5bjwkDwtRzxUWFrJjxw727NkDwHXXXcfQoUNxc5Ox0Q2E5FkhGjitNWfObCc+YTn5+Ufw9OhB174v4Oc71NahicuwtsHiTqAvkKi1LlRK+WHuJieEsLHS4/nk/JREyZ9nsW/mjM9fuuDWpwXKThoqGhnJw0LUU2VlZezZs4cdO3ZQXFxMnz59GDlyJM2aNbN1aOLqSJ4VogHLzTtIfPzLZGfvxMUlgB7dX6NVq0koJcPwGgKrGiy01ialVBLQWSnlUkMxCSGsYDhTTM7mZIpiM7Fzc8B7Ugc8BrdBOUhSbowkDwtR/5hMJuLi4oiMjCQ3N5dOnToxZswYWrVqZevQRDVInhWiYSoqSiUhcSUnT36Ho6MPnTo9SUDbW7Gzc7Z1aOIqWNVgoZRaADyIeX3qWGAwsAsYZX1oQoirYSwoIy8ilfzdJ1B2Cs8R7fAcEYCdi6wb3ZhJHhai/tBa8+effxIeHs6pU6fw9/dn6tSpBAcH2zo0YQXJs0I0LKWlWSQlv8Xx45+hlD1B7e+hffuFODjI3G0NkbXfZB4EBgC7tdYjlVJdgWesD0sIcaVMpUbydxwnb2sautSIe2hrvMYEYu8trcdNhORhIeqBY8eOER4eTkpKCr6+vsyYMYPu3bvLfEGNg+RZIRoAo7GQ1NQ1pKS+j8lURJs2M+gQ/ADOztK7rSGztsGiWGtdrJRCKeWstT6qlOpSI5EJIS5JGzUFMRnkhqViyivFpbsf3uOCcGwpk7g1MZKHhbCh06dPs2XLFo4cOYK7uzsTJkygf//+2Nvb2zo0UXMkzwpRj5lMZaSf+C9JSW9SWppJixZj6dhhCe7uHW0dmqgB1jZYpCmlmgHfAmFKqWwg3fqwhBBV0VpTfDiLnJ+SMWQW4dTeC+/ZXXEO8rZ1aMI2JA8LYQN5eXls3bqVmJgYHBwcGDFiBNdeey3OztK7rRGSPCtEPaS1JjNzMwmJr1BYmIS3d3969XqLZt79bR2aqEHWTro5tfzHZUqpSMAb+MnqqIQQlSpJziHnxyRKU/NwaOGK323dcOnuJ12OmzDJw0LUrZKSEn755Rd27dqF0WgkNDSU4cOH4+HhYevQRC2RPCtE/ZN9Npr4+JfJzd2Hm1sIvXu9S/PmY+SeuBGqVoOFUsq3ks0Hyv/2AM5UOyIhxEXKThaQ81MyxUfOYOflhM+0Trj1b4Wyl6TcVEkeFqJuGQwGYmJi2Lp1K4WFhfTo0YNRo0bh5+dn69BELZE8K0T9k5//BwmJKzh9egvOTq3o1vVFWreehp2dTDLfWFX3XzYG0EDFb0vnXmugg5VxCSEAQ04JuWEpFMacRDnZ43VjEB5D/LFzkrHRQvKwEHXBZDJx+PBhtmzZQnZ2NkFBQdxwww20bdvW1qGJ2id5Voh6orj4BIlJb3DixNfY27vRscPfaNfuDuztXW0dmqhl1Wqw0FpbvT6XUmoc8AZgD3ygtX7pgnJn4D9AfyAL+IvWOrlCeSBwGFimtV5hbTxC1CemIgN5W4+RtyMdtMbjOn88RwVi7+5o69BEPVETeVgIcWmJiYmEhYVx4sQJWrZsyezZswkJCZEux02E5FkhbK+sLJeUlHc5lvYRWmvatZtLcNA9ODr62Do0UUeqOyRkjtb6k/Kfh2itf6lQdp/WetVl9rcH3gJuANKAaKXURq314QrV7gSytdYhSqlZwMvAXyqUvwZsqk78QtRX2mAif1c6eZHHMBUacO3bAu+xQTj4utg6NFHPWJuHhRBVy8jIICwsjISEBLy8vLj55pvp3bs3dnZ2tg5N1CHJs0LYjtFYQtrxdSQnv43BkEvr1lPoEPwwrq4Btg5N1LHqDgl5BPik/Od/A9dUKJsPXC6BDwTitdaJAEqpL4ApmHtMnDMFWFb+81fAKqWU0lprpdTNQCJQUM34hahXtElTGJdJ7s/JGM+W4NypGd7jgnFqK5O4iSpZm4eFEBfIzs4mMjKS/fv34+LiwtixYxkwYACOjtK7rYmSPCtEHdPaSEbGBhITX6O4JB0/32F07PgYnp7dbB2asJHqNlioKn6u7HVl2gLHKrxOAwZVVUdrbVBK5QB+Sqki4HHMvTOWVBmgUguBhQCBgYFXEJIQdU9rTcmfZ8nZlETZiQIc/d3xuaUTLp2km5u4LGvzsBCiXGFhIdu2bSM6OhqlFEOGDGHo0KG4usrY6CZO8qwQdURrTdaZrSTELye/4Hc8PXvSrdtL+PoOsXVowsaq22Chq/i5steVqSzJX7hfVXWeAV7TWudfagyp1no1sBogNDT0SmISok6VpuWRsymJkoQc7H1d8J3VBdfeLVB2cg8krohVeVgptQaYBJzSWvespHw25sZhgHxgsdY6rrzsknMQCdFQlJWVsXv3bnbs2EFpaSl9+vRh5MiReHt72zo0UT9Ye78rhLgCubn7+TP+Jc6e3YOrSyA9e7xBy5YTUEqG4YnqN1h0VUrtx9yo0LH8Z8pfX8mMyWlAuwqvA4D0KuqkKaUcMK95fQZzT4zpSqnlQDPApJQqlnGEoqEwZBWRszmForhM7Nwd8J7cAY9BbVAOkpTFVbE2D3+EuTvzf6ooTwKGa62zlVLjMTcAD7rCOYiEqNeMRiNxcXFERkaSl5dH586dGT16NK1atbJ1aKJ+sTbPCiEuobAwmYTEVzl16kccHX3p3Plp2vrPws7OydahiXqkug0W1g4iigY6KaWCgePALODWC+psBO4AdgHTgQittQauP1dBKbUMyJfGCtEQGPNLyYs4Rv6eEyg7heeodngOC8DORdaNFtViVR7WWm9TSgVdonxnhZe7MTcsw5XNQSREvaS15vfff2fLli1kZmYSEBDALbfcQlBQkK1DE/WTDJoXohaUlp4mKWkVx9M/x87OiaCg+2gfuAAHB09bhybqoeoua5pizUnL56S4D/gZc5fiNVrrQ0qpZ4G9WuuNwIfAOqVUPOaeFbOsOacQtmIqNZK//Th5W9PQBiPuA1rjNbo99l7Seiyqz9o8fJXu5H+rMl3JHESAzCUk6pdjx44RFhZGamoqfn5+zJw5k27duskSpaJKdZxnhWj0DIYCUo99SGrqB5hMxfj7zyI46H6cnVvYOjRRj9ns0a7W+kfgxwu2PVXh52JgxmWOsaxWghOiBmijiYLok+SGp2DKL8O1hx9e44JwbOFm69CEuGJKqZGYGyyGnttUSbVKx3LLXEKiPsjMzGTLli0cPXoUDw8PJk2aRL9+/bC3t7d1aKKJU0o9h7mHmgk4BczVWl84RBqllBE4UP4yVWt90wXl/wbmaa1laTFRL5lMZaSnf0li0puUlWXRssV4OnZ8FDe3YFuHJhoA6YsuRA3TWlN0MIvcn5MxnC7CKcgL79u649zey9ahCXFVlFK9gQ+A8VrrrPLNVzIHkRA2l5uby9atW/ntt99wdHRk5MiRXHvttTg5Se82UW+8orX+J4BS6gHgKWBRJfWKtNZ9KzuAUioU85xuQtQ7WmtOZf5EQsIKioqSadZsICEdV+PtXel/ZyEqZXWDhVLKFQjUWv9eA/EI0aCVJOaQsymJ0mN5OLR0w+/27rh085Uux6JW1UYeVkoFAt8At2mt/6hQdCVzEAlhM8XFxfzyyy/s2rULk8nEwIEDGTZsGO7u7rYOTTRgtZFntda5FV66c5Urj5RPgvwK5hw8tabiEqImZGfvJj5hObm5cbi7d6ZP7w/w8xsh98TiqlnVYKGUmgysAJyAYKVUX+DZC7uqCdHYlWUUkPNTMsVHz2Dv5YTPLZ1w699KligVta66eVgp9TkwAmiulEoDngYcAbTW72J+0ucHvF1+c2HQWodWNQdRrbw5Ia6CwWAgOjqabdu2UVRURM+ePRk1ahS+vr62Dk00cLV5v6uU+hdwO5ADjKyimotSai9gAF7SWn9bvv0+YKPW+sSlvgTKfEKiLuXlHyUhYTlZWVtxdm5Nt24v06b1VMzta0JcPWt7WCzDPGN8FIDWOvZSs84L0dgYzpaQG5ZC4W8nUc72eI0LwnOIP8pRkrKoM8uoRh7WWv/1MuULgAVVlC80TOcAACAASURBVF00B5EQtmIymTh48CARERGcPXuW4OBgbrjhBvz9/W0dmmg8llHN+12lVDjQupKipVrrDVrrpcBSpdQTmBsgnq6kbqDWOl0p1QGIUEodAIowz/U24nIxyHxCoi4UF6eTmPgaJzLW4+DgSUjHxwkIuB17exdbhyYaOGsbLAxa6xzp2iOaGlNhGblb08j/JR20xmNIWzxHtsPe3dHWoYmmR/KwaLISEhIICwsjIyOD1q1bM2fOHDp27ChdjkVNq3ae1VqPucKqnwE/UEmDxbmJOLXWiUqpKKAf5gaLECC+PC43pVS81jrkqoMUwgplZWdJTnmHtLT/ABAYeCdB7Rfj6ChTq4iaYW2DxUGl1K2AvVKqE/AAsNP6sISon3SZifyd6eRGHkOXGHDr2xKvse1x8JHWY2EzkodFk5Oenk54eDiJiYk0a9aMadOm0bNnT+zs7GwdmmicaiXPKqU6aa3/LH95E3C0kjo+QKHWukQp1RwYAizXWh+mQs8NpVS+NFaIumQ0FpOW9jHJKe9iMOTRpvU0OnR4CBcX6d0mapa1DRb3A0uBEswtwz8Dz1sblBD1jTZpCvedIndzCsacEly6+OA1LhinNjKJm7A5ycOiycjOziYiIoIDBw7g6urKjTfeyIABA3BwkEXPRK2qrTz7klKqC+ZlTVMoXyGkfOWPReVD87oB7ymlTIAd5jksDtfAuYWoFq2NnMhYT2Lia5SUZODnN4KQjo/h4dHF1qGJRsqqT3itdSH/396dh8d1lucf/z7ad1m2vNuy5X2JEydx4qxOHDsrkIVsTkpDSiiFQtNCN/gFKBeUNgkBCoSWpmQptEBLWkooJMGS7dixncTGWUxWS9ZieZNX7fs8vz/muEwcyZY0kuZIuj/XNZdmznnPmXvOyI+PX7/nPdECft/AxBEJF3en9e1j1D9TQceBZlKn5VBw2zwyZmuYm4SD6rCMBk1NTWzcuJFt27aRlJTEJZdcwiWXXEJGhka3yeAbrDrr7jf3sHw7wRxC7r4FWNKLfeUMZDaRk7k7R45soKz8QZqa3iEv7ywWL/o6BQUXJDqajHDx3iVkLXCrux8PXhcAP3H3qwcinEgitVXXU/d0Je0VdSSPy2DsnQvIXFKoa6MlVFSHZSRrb2/nhRde4Pnnn6ejo4Ozzz6byy+/nLy8vERHk1FEdVZGu7q6lykrf5Djx18iM3MGZ5zxMBPGX6NzYhkS8Y6hLDxRvAHc/ZiZTYhznyIJ1XG4hfpnK2nZeZik7FTG3DCb7PMmYSm6NlpCSXVYRpyuri5efvllNmzYQGNjI/Pnz2f16tWMHz8+0dFkdFKdlVGpqWk35bu/zqFDz5CWVsj8eV9mypTbSErSJPMydOLtsIiYWZG7VwOY2QxAt0uSYamroZ360mqaXjqApRi5q4rIXTGVpHRdGy2hpjosI4a789Zbb1FSUsKRI0eYPn06t912G0VFRYmOJqOb6qyMKm1ttVRUfod9+/6DpKQMiov/lKLp95CSornbZOjF+y+x+4Dnzey54PUK4GNx7lNkSEXaOmnYuJfGTTV4Z4Ts8yeTt6qI5Ny0REcT6Q3VYRkRqqqqWLt2LTU1NRQWFrJmzRrmz5+vIccSBqqzMip0djZQVf19qqsfxb2DqVPvZObMT5GeVpjoaDKKxTvp5jNmdg5wAWDAp9398IAkExlk3hWh6aUD1JdWE2nsIHNJIXlXzyS1MDPR0UR6TXVYhrva2lpKS0t5++23yc3N5QMf+ABLly4lOTk50dFEANVZGfkikXb27v0xFZUP09FxlAkT3sfsWZ8hK2tmoqOJ9K/DwswWuPtbQfEG2Bf8LAqGzO0YmHgiA8/dadl5mPpnK+k80kpacT75d80kvUiTuMnwoTosw11dXR0bNmzglVdeIS0tjVWrVrF8+XLS0jS6TcJBdVZGOvcIB2t/ye7yb9DSWk3BmAuYM+evycs7M9HRRP5Pf0dYfIboULivd7POgSv6nUhkELWWH6fu6Qo6ahpJmZjFuLsXkzG/QEOOZThSHZZhqaWlhc2bN/PCCy/g7ixfvpwVK1aQlZWV6GgiJ1OdlRHr6NHNlJU/SEPDb8nJWcDSsx5j7NgVOieW0OlXh4W7fyz4ubK/b2xm1wDfApKB77v7/SetTwd+AJwLHAFud/dKMzsfeOREM+BL7v6z/uaQ0aF9fxP1z1TQ+vYxkvPTKbh1HllnT8CSVJRleBqIOiwylDo7O3nppZfYtGkTLS0tLFmyhCuuuIKCgoJERxPpluqsjEQNDW9SVv4AR49uIiN9CosWPsSkSTdgprvhSTjFNYeFmd3V3XJ3/8FptksGvgtcCdQA28zsKXd/I6bZPcAxd59jZmuAB4Dbgd8Cy9y908wmA6+a2S/cvTOezyIjU+exVurXVtH8ci2WkUL+dcXkXDgZS9W10TIy9LcOiwyVSCTCzp07WbduHXV1dcyePZvVq1czefLkREcT6RXVWRkJWlpq2L37mxw4+HNSUvKYM+dzTJv6+yQnpyc6msgpxXuXkPNinmcAq4AdREdGnMr5QJm77wYws58ANwCxHRY3AF8Knj8JPGxm5u7NJ72nbisl7xFp7qB+/R4at+wDg5xLp5F3+TSSsnTfaBlx+luHRQaVu1NWVkZJSQkHDx5k8uTJ3HDDDcyaNSvR0UT6SnVWhq2OjmNUVP4jNTX/hpkxo+hjzJjxcVJTNXebDA/x3iXkT2Jfm1k+8MNebDoV2BPzugZY3lObYDRFHTAOOGxmy4HHgBnA73c3usLMPkZwyyndv3308I4uGjbvo2HDHryti6xzJpJ35QxSxqj3WEamOOqwyKDZu3cvJSUlVFRUUFBQwM0338zixYtJStKQYxl+VGdlOOrqamHPnieorPoeXV3NTJ58M7OK/5SMDI1uk+El3hEWJ2sG5vaiXXcTB5w8UqLHNu7+IrDYzBYC/2pmT7t767sauj9CMNfFsmXLNApjhPOI0/ybg9SvraKrvp2MBWPJv2YmqZOyEx1NZKj1tg6LDLijR49SWlrK66+/TlZWFtdeey3nnnsuKSkDfbohklCqsxJakUgnBw78N7srvkVb2wEKC1cxe9ZfkJMzL9HRRPol3jksfsHvOhqSgEXAf/Zi0xpgeszrafzuVlEnt6kxsxQgHzga28Dd3zSzJuAMYHufP4AMe+5O65tHqXumks7aZtKm5zJ2zXzSZ41JdDSRIRFHHRYZMI2NjWzcuJHt27eTnJzMihUruOiii8jIyEh0NJG4qc7KcODuHD5cSvnuh2hq2kVe3lIWL/omBQXnJzqaSFzi/S+Ph2KedwJV7l7Ti+22AXPNrBjYC6wB7jypzVPAh4GtwC3AOnf3YJs9wWUiM4D5QGV8H0OGo7aqeuqerqC9sp6UwkzG/t5CMs8Yp9sxyWjT3zosEre2tja2bt3Kli1b6Ojo4Nxzz+Wyyy4jNzc30dFEBpLqrITa8brfUFb2AHV1vyErq5glZ/wj48dfpXNiGRHincPiuX5u12lmnwKeJXpb08fc/XUz+zKw3d2fAh4FfmhmZURHVqwJNr8E+KyZdQAR4I/d/XA8n0OGl45DzdQ/U0nL60dIykllzI1zyD5vIpasa6Nl9OlvHRaJR1dXFzt27OC5556jsbGRhQsXsmrVKgoLCxMdTWTAqc5KWDU1lVNe/jUOHV5LWtp45s//ClMm30pSkiaZl5GjXx0WZtZAz3fnaAPKgfvcvbSnfbj7r4BfnbTsizHPW4Fbu9nuh2iio1Gpq76d+tIqmrYdwFKSyVtdRM6l00hK1y1KZfQZiDos0lfuzptvvklpaSlHjhyhqKiI22+/nenTp59+Y5FhRnVWwqqt7SC7K77N/v0/JSkpk1nFn6ao6CMkJ2clOprIgOtXh4W79zjW08ySic4p8e/BT5G4RFo7adhYQ+OmvXjEyV4+mbxVRSTnpCU6mkjCqA7LUKusrGTt2rXs3buX8ePHc8cddzBv3jwNOZYRS3VWwqazs4Gqqkeo3vMY7l1Mnfohimd+krS0cYmOJjJoBnzabnfvAl41s+8M9L5ldPHOCI0v7qdhXTWRpk4yzywk/+qZpIzLTHQ0kVBTHZaBdPDgQUpKSti1axd5eXnccMMNnHXWWbpFqYxqqrMylCKRNmr2/ojKyu/S0XGMiRM/wOxZnyEzsyjR0UQG3aDdZ8zd/3mw9i0jm0ecltcOUffrKrqOtpI+K5/8a4tJm65J3ET6QnVY4lFXV8f69et55ZVXSE9PZ/Xq1SxfvpzUVF0bLXKC6qwMJvcIBw/+gvLd36C1tYaCgouYM/uvyMtbkuhoIkNGN0aXUGnddYy6Zyrp2NtI6uRsCj5yBulzx2jIsYjIEGlpaWHTpk28+OKLAFx00UVccsklZGXp2mgRkaFy5MgmysofpLHxDXJyFrH0rCcYN+7SRMcSGXJxd1gEtxad6+4lZpYJpLh7Q/zRZDRp39dI3dMVtO06TvKYdApum0fW0glYkjoqRE5HdVgGQkdHBy+99BKbNm2itbWVs846i5UrVzJmzJhERxNJONVZGSr19TspL/8aR49tJiNjGosXfZOJE9+PmS7Dk9Eprg4LM/tD4GPAWGA2MA34HrAq/mgyGnQebaX+15U0v3KIpKwU8t9XTM4FU7BUFWWR3uhvHTazx4D3A7Xu/p4J48xsAfA4cA7RWfAfiln3p8AfAgb8i7v/w8B8GkmESCTCa6+9xrp166ivr2fOnDmsXr2aSZMmJTqaSCjofFeGQktLNeW7v8HBg78gNbWAuXM/z7Spd5KUlJ7oaCIJFe8Ii08C5wMvArj7LjObEHcqGfG6mjpoWFdN4wv7wYzcy6eRe9l0kjJ1lZJIH/W3Dj8BPAz8oIf1R4F7gRtjF5rZGUQ7K84H2oFnzOyX7r6rX+klYdydXbt2UVJSQm1tLVOmTOGmm26iuLg40dFEwkbnuzJo2tuPUlH5MHv3/gizZGbO+AQzZvwRKSmau00E4u+waHP39hPzC5hZCj3fr1qESHsXjZv30rChBm/vIuvcieRfOYPkfPUei/RTv+qwu280s5mnWF8L1JrZ+05atRB4wd2bg/d7DrgJeLBf6SUhampqWLt2LVVVVYwdO5Zbb72VRYsWab4gke7pfFcGXFdXM9V7Hqeq6hEikRYmT76VWcX3kp4+MdHRREIl3g6L58zs/wGZZnYl8MfAL+KPJSONdznNvzlIXUkVkfp2MhaOJf+amaROzE50NJHhbqjr8G+Br5rZOKAFuA7Y3l1DM/sY0WHUFBXp1mthcOTIEUpLS3njjTfIzs7muuuu49xzzyU5OTnR0UTCTOe7MmAikU727/8puyu+TXt7LeMLr2T27L8kO3t2oqOJhFK8HRafBe4BdgJ/BPwK+H68oWTkcHda3zhK3bMVdNa2kFaUS/6dC0ifmZ/oaCIjxZDWYXd/08weANYCjcCrQGcPbR8BHgFYtmyZ/jcygRobG9mwYQM7duwgOTmZyy+/nAsvvJD0dI1uE+mFAa+zZvYV4AYgAtQCd7v7vm7adQXvC1Dt7tcHy58ALgPqgnV3u/sr8WSSweXuHDr8a8rLH6K5eTf5+eeyZMnDjMk/N9HRREItrg4Ld48A/xI8RN6lrbKOuqcraa+qJ2V8JuN+fyEZi8ZpyLHIAEpEHXb3R4FHAczs74CaoXpv6Zu2tja2bNnCli1b6Orq4txzz+Wyyy4jJycn0dFEho1BqrNfc/cvAJjZvcAXgY93067F3Zf2sI+/dPcnBzCTDJLjx7dTVnY/dfUvk5U1hzOX/DOFhat0TizSC/HeJWQn772Gr47o8OC/dfcj8exfhqeO2mbqnqmk9Y0jJOWmMeamOWQvm4QlqyiLDLRE1GEzm+DutWZWBHwQuHCg30Pi09nZyY4dO3juuedoampi0aJFrFq1inHjxiU6msiwMxh11t3rY15md7N/GQEam3ZRXv4Qhw+XkJ42kYUL/p5Jkz5IUpImmRfprXj/tDwNdAE/Cl6vCX7WE52B/gNx7l+Gka66NupLqmnafgBLSybvqhnkXDKVpDRdGy0yiPpVh83sx8DlQKGZ1QB/A6QCuPv3zGwS0ZPxPCBiZn8GLApOsv8rmMOiA/ikux8bhM8l/RCJRHjjjTcoLS3l2LFjzJgxgzvuuINp06YlOprIcDYo57tm9lXgLqKdHyt7aJZhZtuJXnp3v7v/T8y6r5rZF4FS4LPu3tbD+2g+oSHW2naAit3fYt/+J0lOzmL2rL9g+vS7SU7OTHQ0kWHH3PvfoWtmm9394u6WmdlOd18Sd8IBsGzZMt++vds54WQARFo7adhQQ+PmvXjEyblgMrlXFJGcnZroaCKhZma/cfdlce5DdVgAqKioYO3atezbt48JEyawevVq5s6dqyHHIqdxulrc3zprZiXApG5W3efuP49p9zkgw93/ppt9THH3fWY2C1gHrHL3cjObDBwA0ojOFVTu7l8+3WdVLR5cHR31VFV9jz01T+DuTJv2IWbO+ARpaWMTHU0k1E5Vh+MdYZFjZsvd/cXgjc4HTlwY2+0kbDJyeGeExq37aVhfTaS5k8yl48m/aiYpYzMSHU1kNFEdHuUOHDhASUkJZWVl5OXlceONN3LmmWeSlJSU6GgiI0W/6qy7r+7l/n8E/JLoSLeT97Ev+LnbzDYAZxPtnNgfNGkzs8eBv+jle8kg6OpqY+/ef6Oi8h/p7Kxj0sQbmDXr02RmanSbSLzi7bD4KPCYmeUARnRo3EfNLBv4+542MrNrgG8BycD33f3+k9anAz8AzgWOALe7e2VwK6n7ifYmtxOdbGhdnJ9B+sgjTvOrh6h/tpKu422kzxlD/rXFpE3VJG4iCdCvOizD3/Hjx1m3bh2vvfYaGRkZXHnllZx//vmkpmp0m8gAG/A6a2Zz3X1X8PJ64K1u2hQAze7eZmaFwMXAg8G6ye6+36JDqG4kestpGWLuXRw48BS7d3+D1rZ9jB17KXNm/xW5uYsSHU1kxIj3LiHbgCVmlk/08pLjMav/s7ttzCwZ+C5wJdGZ5beZ2VPu/kZMs3uAY+4+x8zWAA8AtwOHgQ8EQ+POAJ4FpsbzGaT33J22Xcepe7qCjv1NpE7JpuDmuWTMLUh0NJFRqz91WIa35uZmNm3axEsvvQTAxRdfzCWXXEJmpq6NFhkMg1Rn7zez+URva1pFcIcQM1sGfNzdPwosBP7ZzCJAEtE5LE6cL/+7mY0n2oHyCt3fYUQGibtz9OhGysofpLHxLXJzF7Nw4f2MHXvx6TcWkT6J9y4h6cDNwEwg5cR1sqe5hu58oMzddwf7+AnR+1DHdljcAHwpeP4k8LCZmbu/HNPmdaITEaX3NMmQDJz2mgbqnqmkrew4yWMzGLtmPplnjseSdG20SCL1sw7LMNTR0cELL7zA888/T1tbG0uXLmXlypXk5+cnOprIiDYYddbdb+5h+XaiIzpw9y1At/NjuPsV/X1viU99/WuUlT/IsWNbycwoYvHif2DihPdhpsvwRAZDvJeE/JzozMa/AXrbaTAV2BPzugZY3lMbd+80szpgHNERFifcDLysGZEHV+eRFup+XUXLq4dIykoh//2zyLlgMpaioiwSEv2pwzKMdHV18eqrr7J+/XoaGhqYN28eq1atYuLEiYmOJjJaqM4Kzc2VlO/+OrW1vyI1dSzz5n6BqVPvJCkpLdHRREa0eDssprn7NX3cprv/kj/5ViWnbGNmi4leJnJVT2/i7o8QnTWZZcuW6d7WfdTV2E7Duj00vrgfSzJyV04n97JpJGXovtEiIdOfOizDgLvz9ttvU1payqFDh5g6dSo333wzM2fOTHQ0kdFGdXYUa28/TEXFw+zd92PMUpk585PMKPpDUlJyEx1NZFSI91+fW8xsibvv7MM2NcD0mNfTgH09tKkxsxQgHzgKYGbTgJ8Bd7l7eb+TS7ci7V00btpLw8YavKOL7GWTyFtdRHJeeqKjiUj3+lOHJeSqq6spKSmhurqacePGcdttt7Fw4ULdolQkMVRnR6HOziaq9zxKdfX3iURamTLldopn/gnp6RMSHU1kVIm3w+IS4G4zqyA6RM4Ad/czT7HNNmCumRUDe4E1wJ0ntXkK+DCwFbgFWOfubmZjiN726XPuvjnO7BLDuyI0bTtIfWkVkYYOMhaPI//qmaROyEp0NBE5tf7UYQmpw4cPU1JSwltvvUV2djbve9/7OOecc0hOTk50NJHRTHV2FIlEOti37z+pqPw27e2HGT/+GmbP+nOys2clOprIqBRvh8W1fd0gmJPiU0Tv8JEMPObur5vZl4Ht7v4U8CjwQzMrIzqyYk2w+aeAOcAXzOwLwbKr3L02zs8xark7ra8foe6ZSjoPt5A2I4/8Dy0ifUZeoqOJSO/0uQ5L+DQ0NLBhwwZ27NhBamoqK1eu5IILLiA9XaPbREJAdXYUcHdqDz1DeflDtLRUMib/PM5c8j3y889OdDSRUS3e25pWAZjZBCCjD9v9CvjVScu+GPO8Fbi1m+3+Fvjb/uaVd2urqKPu6QraqxtImZDJuLsWkbFwrIYciwwj/a3DEg6tra1s2bKFrVu30tXVxXnnnceKFSvIyclJdDQRCajOjnzHjr1IWfkD1Ne/Snb2XM46818YN26lzolFQiDe25peD3wdmALUAjOAN4HF8UeTwdJxsIm6ZyppffMoSXlpFNw8l6xzJmLJKsoiw43q8PDU2dnJ9u3b2bhxI83NzSxevJhVq1YxduzYREcTkZOozo5cjY1vU1b+NY4cWU96+iQWLrifyZM/iJkuwxMJi3gvCfkKcAFQ4u5nm9lK4I74Y8lg6Kxro/7XVTTvOIilJ5N39UxyLp5CUpqKssgwpjo8jEQiEV5//XVKS0s5fvw4xcXFrF69mqlTpyY6moj0THV2hGlt3cfu3f/A/gP/TUpKDrNn/xXTp32Y5GQNoBEJm3g7LDrc/YiZJZlZkruvN7MHBiSZDJhIcwf1z9XQuHkfuJNz8VRyV04nOTs10dFEJH6qw8NEeXk5JSUl7N+/n4kTJ/KhD32I2bNna8ixSPipzo4QHR3Hqaz6HjU1/wpAUdE9zJzxCVJTxyQ4mYj0JN4Oi+NmlgNsBP7dzGqBzvhjyUDwjgiNW/dRv34P3tpJ1tIJ5F01g5QC9R6LjCCqwyG3f/9+SkpKKC8vJz8/n5tuuoklS5aQlJSU6Ggi0juqs8NcV1crNTU/oLLqn+jsbGDSpBuZVfxpMjM1uk0k7OLtsLgBaAE+DfwekA98Od5QEh+POM0v11L/6yq66tpIn1dA/jUzSZuiSdxERiDV4ZA6duwY69atY+fOnWRmZnL11Vdz3nnnkZIS71+9IjLEVGeHKfcu9h/4Gbt3/wNtbfsZN3YFs+f8Nbk5CxIdTUR6qd9nTRadjebn7r4aiAD/OmCppF/cndZ3jlH/dAUdB5pJnZpDwa3zyJijYW4iI5HqcDg1NTWxadMmtm3bhplxySWXcPHFF5OZmZnoaCLSR6qzw5O7c+TIBsrKH6Sp6R3ycs9k0aKvMbbgwkRHE5E+6neHhbt3mVmzmeW7e91AhpK+a9/TQN3TFbTtriN5XAZj71xA5hmFWJKujRYZqVSHw6W9vZ0XXniBzZs3097eztKlS7n88svJz89PdDQR6SfV2eGnru4Vysof5PjxF8nMnMEZZ3yHCeOv1XxBIsNUvONSW4GdZrYWaDqx0N3vjXO/0ksdh1uof7aSlp2HScpOZcz1s8k+fxKWomujRUYJ1eEE6+rq4pVXXmH9+vU0NjYyf/58Vq1axYQJExIdTUQGhursMNDcXEF5+depPfQ0qanjmDfvS0ydsoakJE0yLzKcxdth8cvgIUOsq6Gd+tJqml46gCUbuauKyF0xlaR0XRstMsqoDieIu/PWW29RWlrK4cOHmT59OrfeeiszZsxIdDQRGViqsyHW1naIisrvsG/fT0hKSqd45r0UFd1DSormbhMZCeL91+1/AHMAB8rdvTX+SHIqkbZOGjftpWHjXryzi+zzJ5O3qojk3LRERxORxFAdToDq6mrWrl3Lnj17KCws5Pbbb2fBggUaciwyMqnOhlBnZyPV1d+nes+jRCLtTJlyB8XFf0J6WmGio4nIAOpXh4WZpQB/B3wEqAKSgGlm9jhwn7t3DFxEAfCuCE0vHaC+tJpIYweZSwrJu2oGqeOzEh1NRBJAdTgxamtrKS0t5e233yYnJ4f3v//9nH322SQnJyc6mogMMNXZcIpE2tm77ydUVHyHjo6jTJhwHbNnfYasrOJERxORQdDfERZfA3KBYndvADCzPOCh4PGnAxNP3J2WnYepf7aSziOtpBXnkX/XItKL8hIdTUQSS3V4CNXX17NhwwZefvllUlNTueKKK7jgggtIS9PoNpERTHU2RNwj1Nb+ivLdX6elpZoxY5YzZ85fk593VqKjicgg6m+HxfuBee7uJxa4e72ZfQJ4CxXwAdFafpy6Zyrp2NNAysQsxt29mIz5BRpyLCKgOjwkWltb2bx5M1u3biUSiXD++eezYsUKsrOzEx1NRAaf6mxIHD26hbLyB2lo2ElO9nzOOutRxo29TOfEIqNAfzssPLZ4xyzsMrP3LJe+ad/fRP0zFbS+fYzk/DQKbplL1jkTdYtSEYmlOjyIOjs72bZtGxs3bqSlpYUlS5ZwxRVXUFBQkOhoIjJ0VGcTrKHhTcrLH+TI0Y2kp09m0cIHmTTpRsx0GZ7IaNHfDos3zOwud/9B7EIz+xDRHudTMrNrgG8BycD33f3+k9anAz8AzgWOALe7e6WZjQOeBM4DnnD3T/Uzfyh1Hm+l/tdVNL9ci6WnkH9tMTkXTcZSVZRF5D3iqsPSvUgkws6dO1m3bh11dXXMmjWLK6+8ksmTJyc6mogMPdXZBGlp2cvuim9w4MDPSUnJY86czzJt6l0kJ6cnOpqIDLH+Tdk32AAAFxRJREFUdlh8EvhvM/sI8BuisyafB2QCN51qQ4t2iX4XuBKoAbaZ2VPu/kZMs3uAY+4+x8zWAA8AtxO9D/YXgDOCx4gQae6gfsMeGrfsAyDn0mnkXT6NpCzdN1pEetTvOgxgZo8RHe5c6+7vqadmtgB4HDiH6ORyD8Ws+zTw0eA9dwJ/MNxnzXd3ysvLWbt2LQcPHmTSpElcf/31zJ49O9HRRCRx4qqz0ncdHceorPwn9tT8EDNjRtHHmDHjj0hNzU90NBFJkH51WLj7XmC5mV0BLAYMeNrdS3ux+flAmbvvBjCznwA3ALEdFjcAXwqePwk8bGbm7k3A82Y2pz+5w8Y7umjcso/69TV4WydZ50wk78oiUsZkJDqaiIRcnHUY4AngYaKj2bpzFLgXuDF2oZlNDZYvcvcWM/tPYE2wv2Fp3759rF27loqKCsaMGcMHP/hBzjjjDJKSkhIdTUQSaADqrPRSV1cre/Y8QVX19+jsbGLy5JuZVXwvGRlTEh1NRBKsvyMsAHD3dcC6Pm42FdgT87oGWN5TG3fvNLM6YBxwuLdvYmYfAz4GUFRU1MeIg8sjTvOOg9SvraKrrp2M+QXkX1tM6iRN4iYifdPPOoy7bzSzmadYXwvUmtn7ulmdAmSaWQeQBezr6/uHwdGjR1m3bh2//e1vycrK4pprrmHZsmWkpMT1V6OIjDD9rbNyepFIJwcO/De7K75FW9sBCgtXMXvWn5OTMz/R0UQkJBJxVtbdzJEnT1zUmzan5O6PAI8ALFu2LBQTI7k7rW8dpe6ZSjoPNpM6PZext88nfdaYREcTEekVd99rZg8B1UAL8Gt3/3V3bcPacdzU1MRzzz3H9u3bSU5OZsWKFVx00UVkZGh0m4jIUHB3Dh8upXz3QzQ17SIv72wWL/omBQXnJzqaiIRMIjosaoDpMa+n8d7/nTvRpsbMUoB8osOTh6226nrqnq6gvaKelMJMxv7eAjLPKNTtmERkWDGzAqKX7RUDx4GfmtmH3P3fTm4bto7j9vZ2tm7dyubNm+no6OCcc87h8ssvJzc3N9HRRERGjbq6HZSVPcjxum1kZRWz5IzvMn781TonFpFuJaLDYhsw18yKgb1Er32+86Q2TwEfBrYCtwDrurut1HDQcaiZ+mcrafntEZJyUhlz42yyz5uEJevaaBEZllYDFe5+CMDM/hu4CHhPh0VYdHV1sWPHDp577jkaGxtZsGABq1evprCwMNHRRGSUMrOvEO38jQC1wN3u/p7L68ysi+jkxgDV7n59sNyAvwVuBbqAf3L3bw9F9v5qatpN+e6vcejQr0lLG8/8+V9hyuRbSUrSJPMi0rMh77AI5qT4FPAs0duaPubur5vZl4Ht7v4U8CjwQzMrIzqyYs2J7c2sEsgD0szsRuCqk+4wEgpd9e3Ul1bRtO0AlpJE3uoici6dRlK6blEqIsNaNXCBmWURvSRkFbA9sZG65+68+eablJaWcuTIEYqKirj99tuZPn366TcWERlcX3P3LwCY2b3AF4GPd9Ouxd2XdrP8bqKjkRe4e8TMJgxa0ji1tdWyu+Jb7N//U5KSMphV/GcUFd1DcnJWoqOJyDCQkJnF3P1XwK9OWvbFmOetRHuMu9t25qCGi1OktZOGjTU0btqLdznZyyeTd0URyblpiY4mIvJ/zOzHwOVAoZnVAH8DpAK4+/fMbBLRjog8IGJmf0b0ziAvmtmTwA6gE3iZ4LKPMKmsrGTt2rXs3buX8ePHc8cddzBv3jwNORaRUHD3+piX2fRxrjbgE8Cd7h4J9lc7UNkGSmdnA1VVj1C953HcO5g69fconvlJ0tI0uk1Eek9ToQ8Q74zQ9OJ+6tdVE2nqJPPMQvKvmklKYWaio4mIvIe733Ga9QeIzjHU3bq/IdrBEToHDx6ktLSUd955h9zcXK6//nrOOusskpM1uk1EwsXMvgrcBdQBK3tolmFm24l2EN/v7v8TLJ8N3G5mNwGHgHvdfVcP7zOkEyBHIm3U7P0RlZXfpaPjGBMmvI/Zs/6crKwZg/7eIjLyqMMiTh5xWnYeou7ZKrqOtpI+K5/8a4tJm65J3EREhkpdXR3r16/nlVdeIT09nVWrVrF8+XLS0jS6TUQSw8xKgEndrLrP3X/u7vcB95nZ54BP0X1HcJG77zOzWcA6M9vp7uVAOtDq7svM7IPAY8Cl3eUYqgmQ3SMcPPi/lO/+Bq2teygouJA5s/+KvLwzB+stRWQUUIdFHFrLjlH3dCUdextJnZRNwR8sJn1egYYci4gMkZaWFp5//nlefPFF3J0LL7yQSy+9lKwsXRstIonl7qt72fRHwC/ppsPixESc7r7bzDYAZwPlRO+o919Bs58Bj8ebNx5Hj26mrPwBGhpeJydnIUvPepyxYy/VObGIxE0dFv3Qvq+RuqcraNt1nOQx6RTcOo+ssydgSSrKIiJDoaOjg5deeolNmzbR2trKmWeeycqVKykoKEh0NBGR0zKzuTGXcFwPvNVNmwKg2d3bzKwQuBh4MFj9P8AVREdWXAa8M/ip36uh4XXKyh7k6LHnyciYyqJFX2fSxOsx093wRGRgqMOiDzqPtlK/tormV2qxjBTyrysm58IpWKqKsojIUIhEIrz22musW7eO+vp65syZw+rVq5k0qbtR1yIioXW/mc0nelvTKoI7hJjZMuDj7v5RYCHwz2YWAZKIzmFx4s549wP/bmafBhqBjw5l+JaWPZTv/gYHDz5FSsoY5s79PNOm3klSUvpQxhCRUUAdFr3Q1dRBw/o9NG7dB2bkrphG7uXTScrU4RMRGQruzq5duygpKaG2tpYpU6Zw4403MmvWrERHExHpM3e/uYfl2wk6H9x9C7Ckh3bHgfcNWsAetLcfobLyH6nZ+++YJTNzxieYMeOPSEnR3G0iMjj0L+5TiLR30bh5Hw0b9uDtXWSdO5G8K2eQkq/eYxGRoVJTU0NJSQmVlZUUFBRwyy23sGjRIpKSNLpNRGQodHU1U73ncaqqHqGrq5kpk2+heNafkpGu0W0iMrjUYdEN73Kaf3OQupIqIvXtZCwYS/61M0mdmJ3oaCIio8aRI0coLS3ljTfeICsri+uuu45zzjmHlBT91SUiMhQikU727/8puyu+TXt7LYWFq5k9+y/IyZ6b6GgiMkrorK8bjVv3Ufe/u0kryiX/jgWkF+cnOpKIyKjS2dnJo48+SkdHB5dddhkXXXQR6eka3SYiMpRqav6VXWV/R37+OSw54zuMGbMs0ZFEZJRRh0U3ss+bSEpBOhmLxul2TCIiCZCSksLNN9/MhAkTyM3VtdEiIokwZcptZGYWUVi4WufEIpIQ6rDoRlJ6CpmLCxMdQ0RkVJs9e3aiI4iIjGopKbmMH39lomOIyCimGctEREREREREJHTUYSEiIiIiIiIioaMOCxEREREREREJHXVYiIiIiIiIiEjoqMNCRERERERERELH3D3RGQadmR0Cqvq4WSFweBDi9JVyhCsDhCNHGDJAOHKEIQP0L8cMdx8/GGHCpp91GMLx/YYhAyhH2DJAOHKEIQOEI0d/M6gWn1oYvltQjrBlgHDkCEMGCEeOMGSAAT4nHhUdFv1hZtvdfZlyhCdHGDKEJUcYMoQlRxgyhCnHSBOG4xqGDMoRvgxhyRGGDGHJEYYMI1FYjqtyhCtDWHKEIUNYcoQhw2Dk0CUhIiIiIiIiIhI66rAQERERERERkdBRh0XPHkl0gIBy/E4YMkA4coQhA4QjRxgyQHhyjDRhOK5hyADKESsMGSAcOcKQAcKRIwwZRqKwHFfl+J0wZIBw5AhDBghHjjBkgAHOoTksRERERERERCR0NMJCREREREREREJHHRYiIiIiIiIiEjqjusPCzG41s9fNLGJmPd56xcyuMbO3zazMzD4bs7zYzF40s11m9h9mltbPHGPNbG2wn7VmVtBNm5Vm9krMo9XMbgzWPWFmFTHrlg5GhqBdV8z7PBWzfCiPxVIz2xp8d6+Z2e0x6/p9LHr6nmPWpwefrSz4rDNj1n0uWP62mV3d90/epxyfMbM3gs9eamYzYtZ1+/0MQoa7zexQzHt9NGbdh4Pvb5eZfbi/GXqZ45sxGd4xs+Mx6wbqWDxmZrVm9tse1puZfTvI+JqZnROzbsCOxUgWhlochjrc2xxBu0GrxYmsw8H2Ca/FYajDvcwx6LVYdXh0CEMdDvaT8Fochjrc2xyDVYvDUId7mUPnxL9bP3JrsbuP2gewEJgPbACW9dAmGSgHZgFpwKvAomDdfwJrguffAz7RzxwPAp8Nnn8WeOA07ccCR4Gs4PUTwC1xHoteZQAae1g+ZMcCmAfMDZ5PAfYDY+I5Fqf6nmPa/DHwveD5GuA/gueLgvbpQHGwn+R+fv7e5FgZ891/4kSOU30/g5DhbuDhHn43dwc/C4LnBYOV46T2fwI8NpDHItjPCuAc4Lc9rL8OeBow4ALgxYE+FiP9QQhqcW9qz0ntB7wO9yVHT7/fQ3UsGIQ6fLrvOabNoNbiXmYY1Drchxx3M4i1uDcZTmqvOjxMH4SgDgfbJrwW9zZDT7/fQ3ks0Dmxzom7bz+iavGoHmHh7m+6+9unaXY+UObuu929HfgJcIOZGXAF8GTQ7l+BG/sZ5YZg+97u5xbgaXdv7uf7DUSG/zPUx8Ld33H3XcHzfUAtML6f73dCt9/zKbI9CawKPvsNwE/cvc3dK4CyYH+DksPd18d89y8A0/r5Xv3OcApXA2vd/ai7HwPWAtcMUY47gB/387165O4biZ4M9eQG4Ace9QIwxswmM7DHYkQLSS0OQx3uT47/M5THYpDqMISjFoehDvcqxykMVP1RHR4lQlKHIRy1OAx1uFc5dE6sc+IejKhaPKo7LHppKrAn5nVNsGwccNzdO09a3h8T3X0/QPBzwmnar+G9v4RfDYbefNPM0gcxQ4aZbTezFywYfkcCj4WZnU+0p7E8ZnF/jkVP33O3bYLPWkf0s/dm297q677uIdqTeUJ3389gZbg5OM5Pmtn0Pm47kDkIhgAWA+tiFg/EseiNnnIO5LGQwa/FYajDfckxmLU4UXUYwlGLw1CH+5JjMGux6rDE0jnxu+mcGJ0TB3ROHDUotThlQKKFmJmVAJO6WXWfu/+8N7voZpmfYnmfc/QiQ+x+JgNLgGdjFn8OOEC0SD0C/DXw5UHKUOTu+8xsFrDOzHYC9d20G6pj8UPgw+4eCRb36lh0t7tulp38GQbkd2EAckQbmn0IWAZcFrP4Pd+Pu5d3t32cGX4B/Njd28zs40R72a/oS/4BynHCGuBJd++KWTYQx6I3huL3YtgLQy0OQx0ewBxx1eKQ1mEIRy0OQx3ubY7BrsWqwyNIGOrw6XL0IkPsfnRO/Lv96JxY58QnjLhaPOI7LNx9dZy7qAGmx7yeBuwDDhMd5pIS9CyeWN7nHGZ20Mwmu/v+oODUniLPbcDP3L0jZt/7g6dtZvY48BeDlSEYboa77zazDcDZwH8xxMfCzPKAXwKfD4Ycndh3r45FN3r6nrtrU2NmKUA+0WFRvdm2t3q1LzNbTfQvs8vcve3E8h6+n74WpNNmcPcjMS//BXggZtvLT9p2Qx/fv9c5YqwBPnlSxoE4Fr3RU86BPBbDXhhqcRjq8EDliLcWh7QOQzhqcRjqcK9yDEEtVh0eQcJQh0+XQ+fEfc+hc2KdE59kxNViXRJyetuAuRad8TeN6C/BU+7uwHqi184BfBjoTe90d54Ktu/Nft5zTVJQxE5cN3cj0O3MrfFmMLOCE8PJzKwQuBh4Y6iPRfA9/IzoNVI/PWldf49Ft9/zKbLdAqwLPvtTwBqLzphcDMwFXurl+/Y5h5mdDfwzcL2718Ys7/b7GaQMk2NeXg+8GTx/FrgqyFIAXMW7/+djQHMEWeYTncBna8yygToWvfEUcJdFXQDUBScJA3ksZPBrcRjqcK9yDEEtTlQdhnDU4jDU4d7mGOxarDossXRO/Lv30TmxzolPvJfOiX9ncGqxD8CMocP1AdxEtMenDTgIPBssnwL8KqbddcA7RHui7otZPovoH8Iy4KdAej9zjANKgV3Bz7HB8mXA92PazQT2Akknbb8O2Em0EP0bkDMYGYCLgvd5Nfh5TyKOBfAhoAN4JeaxNN5j0d33THTo3PXB84zgs5UFn3VWzLb3Bdu9DVwb5+/l6XKUBL+vJz77U6f7fgYhw98DrwfvtR5YELPtR4JjVAb8wWAei+D1l4D7T9puII/Fj4nOut1BtF7cA3wc+Hiw3oDvBhl3EjO7+kAei5H8IAS1mBDU4d7mONXv91AdCwapDvf0PTPEtbgXGQa9Dvcyx6DX4tNlCF5/CdXhYf0gBHU42E/Ca3FvMpzq93sojwU6J9Y58SioxRbsQEREREREREQkNHRJiIiIiIiIiIiEjjosRERERERERCR01GEhIiIiIiIiIqGjDgsRERERERERCR11WIiIiIiIiIhI6KjDQoYNM7vPzF43s9fM7BUzW97H7Wea2WnvQW1mk83sf4Pnl594HhZm9hMzm5voHCIy+qgOR6kOi0giqRZHqRaPDimJDiDSG2Z2IfB+4Bx3bzOzQiBtkN7uM8C/DNK+B8I/AX8F/GGig4jI6KE6/C6qwyKSEKrF76JaPApohIUMF5OBw+7eBuDuh919n5mdZ2ZbzOxVM3vJzHKDXuNNZrYjeFx08s7MLNnMvmZm24Le6T+KWX0z8Ew323zJzB4zsw1mttvM7o1Zd1ewn1fN7IfBshlmVhosLzWzomD5E2b2T2a2PtjPZcF+3zSzJ2L2eZWZbQ0+w0/NLCdYtQlYbWbqcBSRoaQ6rDosIomnWqxaPLq4ux56hP4B5ACvAO8A/whcRrQ3eTdwXtAmj+iooSwgI1g2F9gePJ8J/DZ4/jHg88HzdGA7UBw8fhPzvpcD/xs8/xKwJWhfCBwBUoHFwNtAYdBubPDzF8CHg+cfAf4neP4E8BPAgBuAemAJ0Q7E3wBLg/1vBLKDbf4a+GJMrrXAuYn+XvTQQ4/R81AdVh3WQw89Ev9QLVYtHm0P9UbJsODujWZ2LnApsBL4D+CrwH533xa0qQcws2zgYTNbCnQB87rZ5VXAmWZ2S/A6n2ghbwQOnSLKLz3ao91mZrXAROAK4El3PxzkOBq0vRD4YPD8h8CDMfv5hbu7me0EDrr7ziD760T/EpkGLAI2mxlE/yLaGrN9LTCFaDEXERl0qsOqwyKSeKrFqsWjjTosZNhw9y5gA7AhKGqfBLybpp8GDgJnEe2hbe2mjQF/4u7Pvmuh2dlAxilitMU87yL6Z8h6yPGej9DNfiIn7TMS7LMLWOvud/SwrwygpRfvKSIyYFSH30V1WEQSQrX4XVSLRzjNYSHDgpnNt3fPArwUeBOYYmbnBW1yg2vY8on2MkeA3weSu9nls8AnzCw12HZe0Av9DtHe3L4oBW4zs3HBvsYGy7cAa4Lnvwc834d9vgBcbGZzgn1mmVlsr/g84PU+5hQR6TfVYdVhEUk81WLV4tFGIyxkuMgBvmNmY4BOoIzoNXePB8szifauriZ6Pd9/mdmtwHqgqZv9fZ9oEd5h0fFlh4Ab3b3OzMrNbI67l/UmmLu/bmZfBZ4zsy7gZeBu4F7gMTP7y2D/f9DbD+vuh8zsbuDHZpYeLP488I6ZTQRa3H1/b/cnIjIAVIdVh0Uk8VSLVYtHFXPvzagdkdHDzG4iOnnP5xOdpTtm9mmg3t0fTXQWEZHBoDosIpJ4qsUSBhphIXISd//ZiaFsIXWc6IRFIiIjkuqwiEjiqRZLGGiEhYiIiIiIiIiEjibdFBEREREREZHQUYeFiIiIiIiIiISOOixEREREREREJHTUYSEiIiIiIiIioaMOCxEREREREREJnf8PCI0GLW30CNgAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -1282,18 +1717,9 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 45, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\vasy\\documents\\econml\\econml\\utilities.py:942: UserWarning: Co-variance matrix is undertermined. Inference will be invalid!\n", - " warnings.warn(\"Co-variance matrix is undertermined. Inference will be invalid!\")\n" - ] - } - ], + "outputs": [], "source": [ "est.fit(Y, T, X, W, inference='statsmodels')\n", "te_pred = est.const_marginal_effect(X_test)\n", @@ -1302,12 +1728,12 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 46, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1335,13 +1761,6 @@ "plt.suptitle(\"Orange Juice Elasticity vs Income\",fontsize=16)\n", "plt.show()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -1361,7 +1780,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.1" + "version": "3.7.5" } }, "nbformat": 4, diff --git a/notebooks/Doubly Robust Learner and Interpretability.ipynb b/notebooks/Doubly Robust Learner and Interpretability.ipynb index 9a8c7b68c..38f91b7f9 100644 --- a/notebooks/Doubly Robust Learner and Interpretability.ipynb +++ b/notebooks/Doubly Robust Learner and Interpretability.ipynb @@ -88,7 +88,8 @@ "T = np.random.binomial(1, scipy.special.expit(X[:, 0]))\n", "# Generating an outcome with treatment effect heterogeneity. The first binary feature creates heterogeneity\n", "# We also have confounding on the first variable. We also have heteroskedastic errors.\n", - "y = (-1 + 2 * X[:, 0]) * T + X[:, 0] + (1*X[:, 0] + 1)*np.random.normal(0, 1, size=(n,))" + "y = (-1 + 2 * X[:, 0]) * T + X[:, 0] + (1*X[:, 0] + 1)*np.random.normal(0, 1, size=(n,))\n", + "X_test = np.random.binomial(1, .5, size=(10, d))" ] }, { @@ -106,7 +107,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 5, @@ -135,7 +136,7 @@ { "data": { "text/plain": [ - "array([1.03520242])" + "array([1.02346725])" ] }, "execution_count": 6, @@ -156,7 +157,7 @@ { "data": { "text/plain": [ - "(array([0.67541139]), array([1.39499346]))" + "(array([0.66350818]), array([1.38342633]))" ] }, "execution_count": 7, @@ -173,16 +174,79 @@ "cell_type": "code", "execution_count": 8, "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
point_estimatestderrzstatpvalueci_lowerci_upper
01.0230.1845.5730.00.6641.383
\n", + "
" + ], + "text/plain": [ + " point_estimate stderr zstat pvalue ci_lower ci_upper\n", + "0 1.023 0.184 5.573 0.0 0.664 1.383" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Other inference for effect, including point estimate, standard error, z score, p value and confidence interval\n", + "est.effect_inference(np.array([[1, 0, 0, 0]])).summary_frame(alpha=.05)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[['A' '2.061139572108528']\n", - " ['B' '-0.004465889924987356']\n", - " ['C' '-0.1337951361150851']\n", - " ['D' '0.07875870641906009']]\n", - "-1.0259371477652297\n" + "[['A' '2.0632770380417136']\n", + " ['B' '-0.002140800202909638']\n", + " ['C' '-0.13075241808534419']\n", + " ['D' '0.0860397486668373']]\n", + "-1.0398097870143197\n" ] } ], @@ -194,12 +258,12 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAD7CAYAAABqvuNzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAV2klEQVR4nO3dfXBU5d3G8Wuzm4SQDdkGY4qDCw9IgJFSXjqChYA0RmAwxTYhIaGBqp3iUHSgHQSRSTsVSLCj09ohUqWDDnYsiPCYgBZfYEAQocDwKvgEkKgVMUQW2ATIZvc8f3DMuCVCsmTPLtnvZ8aRve895/z0R3LlnPucjc0wDEMAgJgXF+kCAADRgUAAAEgiEAAAJgIBACCJQAAAmByRLuBGBAIB+f2h3SRlt9tC3hbhQU+iE32JPjfak/h4e4vjN3Ug+P2GPJ6GkLZ1uTqHvC3Cg55EJ/oSfW60J+npKS2Oc8kIACCJQAAAmAgEAIAkAgEAYCIQAACSCAQAgIlAAABIIhAAAKaYDITpq/Zryt93RroMAIgqMRkIAICrEQgAAEkEAgDARCAAACQRCAAAE4EAAJBEIAAATAQCAEASgQAAMBEIAABJBAIAwEQgAAAkEQgAABOBAACQFIOB8NaR0zp46rx2nTyr3Bd26q0jpyNdEgBEhZgKhLeOnNbit6vl8xuSpC8vXNbit6sJBQBQjAVCxfsndakpEDR2qSmgivdPRqYgAIgiMRUIpy9cbtM4AMSSmAqEjJTENo0DQCyxLBB8Pp/mzJmj4uJi5efn67333gua37Rpk/Ly8lRYWKjVq1eHpYYZWT3VyRH8n9zJEacZWT3DcjwAuJk4rDpQZWWlXC6X/vSnP+ns2bP62c9+puzsbElXwqKsrExr1qxRUlKSioqKNGbMGKWnp7drDeP7Z0iSntr4f/L5DX0/JVEzsno2jwNALLMsEMaNG6exY8c2v7bb7c1/Pn78uNxut1JTUyVJQ4cO1e7duzV+/Phr7tNut8nl6tymOoru/h+t/+gr2Ww2vfLQXW3aFuFlt8e1uZ8IP/oSfcLVE8sCITk5WZLk9Xr12GOPadasWc1zXq9XKSkpQe/1er3X3affb8jjaWhzLU1NATkccSFti/BxuTrTkyhEX6LPjfYkPT2lxXFLF5VPnTqlqVOnauLEicrNzW0edzqdqq+vb35dX18fFBAAgPCzLBDOnDmjhx56SHPmzFF+fn7QXO/evVVTUyOPx6PGxkbt3r1bgwcPtqo0AIAsvGS0bNkynT9/XhUVFaqoqJAkTZo0SRcvXlRhYaHmzZunhx9+WIZhKC8vTxkZLPQCgJVshmEYkS4iVD6fP6TraNNX7ZfDEaeleT8IQ1UIFdeqoxN9iT4dYg0BABC9CAQAgCQCAQBgIhAAAJIIBACAiUAAAEgiEAAAJsseTIsmfyv8IfdWA8B/4QwBACCJQAAAmAgEAIAkAgEAYCIQAACSCAQAgIlAAABIIhAAACYCAQAgiUAAAJgIBACAJAIBAGAiEAAAkggEAICJQAAASCIQAAAmAgEAIIlAAACYCAQAgCQCAQBgIhAAAJIiEAj79+9XSUnJVeMrVqzQhAkTVFJSopKSEp04ccLq0gAgpjmsPNiLL76oyspKJSUlXTV3+PBhLVmyRAMGDLCyJACAyWYYhmHVwTZu3Ki+ffvq8ccf1+rVq4Pmxo8frz59+qi2tlb33HOPpk+fft39BQIB+f2hlW+3x8nvD4S0LcKDnkQn+hJ9brQn8fH2FsctPUMYO3asPv/88xbnJkyYoOLiYjmdTs2cOVObN2/WmDFjrrk/v9+Qx9MQUi0uV+eQt0V40JPoRF+iz432JD09pcXxqFhUNgxD06ZNU1pamhISEjR69Gh99NFHkS4LAGJKVASC1+vV/fffr/r6ehmGoZ07d7KWAAAWs/SS0X+rqqpSQ0ODCgsLNXv2bE2dOlUJCQm6++67NXr06EiWBgAxx9JF5fbm8/lZQ+hA6El0oi/Rp0OvIQAAIo9AAABIIhAAACYCAQAgiUAAAJgIBACAJAIBAGAiEAAAkggEAICJQAAASCIQAAAmAgEAIIlAAACYCAQAgCQCAQBgIhAAAJIIBACAiUAAAEgiEAAAJgIBACCJQAAAmAgEAIAkAgEAYCIQAACSCAQAgIlAAABIuk4gfPLJJ1bVAQCIsGsGwhNPPCFJ+s1vfmNJMQCAyHFca9LtdmvEiBE6d+6cRo4cGTS3bdu2sBYGALDWNc8Qnn76aW3fvl2TJk3Stm3bgv4J1f79+1VSUnLV+KZNm5SXl6fCwkKtXr065P0DAEJzzTOEb/zud7/Tn//8Z3311Ve655571LdvX/Xo0aPNB3vxxRdVWVmppKSkoHGfz6eysjKtWbNGSUlJKioq0pgxY5Sent7mYwAAQtOqQJg/f75GjRqlXbt26ZZbbtGTTz6pV155pc0Hc7vd+utf/6rHH388aPz48eNyu91KTU2VJA0dOlS7d+/W+PHjr7k/u90ml6tzm+u4sm1cyNsiPOhJdKIv0SdcPWlVIHg8HuXn56uyslJDhgyRYRghHWzs2LH6/PPPrxr3er1KSUlpfp2cnCyv13vd/fn9hjyehpBqcbk6h7wtwoOeRCf6En1utCfp6Sktjrf6OYTjx49Lkr788kvFxbXv4wtOp1P19fXNr+vr64MCAgAQfq36zr5gwQLNnz9fH330kR577DHNmzevXYvo3bu3ampq5PF41NjYqN27d2vw4MHtegwAwLW16pJRZmamli1bps8++0zdu3dXWlpauxy8qqpKDQ0NKiws1Lx58/Twww/LMAzl5eUpIyOjXY4BAGgdm9GKBYE333xTf/nLX9S7d29VV1dr5syZmjhxohX1XZPP52cNoQOhJ9GJvkSfcK0htOoM4eWXX9batWubF3unTZsWFYEAAGg/rVpDsNlsSk5OlnRlATgxMTGsRQEArNeqMwS3263y8nL96Ec/0p49e+R2u8NdFwDAYq06QygoKFBqaqo++OADrV27VlOmTAl3XQAAi7UqEMrLy5WTk6PS0lKtWbNG5eXl4a4LAGCxVgWCw+HQHXfcIUm6/fbb2/3BNABA5LVqDeG2227Ts88+q0GDBunAgQO69dZbw10XAMBirfpRv6ysTGlpadqyZYvS0tJUVlYW7roAABZr1RlCYmKifvnLX4a5FABAJLEYAACQRCAAAEwEAgBAEoEAADARCAAASQQCAMBEIAAAJBEIAAATgQAAkEQgAABMBAIAQBKBAAAwEQgAAEkEAgDARCAAACQRCAAAE4EAAJBEIAAATAQCAEASgQAAMDmsOlAgENAf/vAHffzxx0pISNDChQvVo0eP5vmFCxdq7969Sk5OliRVVFQoJSXFqvIAIOZZFgjvvvuuGhsbtWrVKu3bt0/l5eV6/vnnm+cPHz6s5cuXKy0tzaqSAADfYlkg7NmzR1lZWZKkQYMG6dChQ81zgUBANTU1Ki0t1ZkzZ5Sfn6/8/Pzr7tNut8nl6hxSPXZ7XMjbIjzoSXSiL9EnXD2xLBC8Xq+cTmfza7vdrqamJjkcDjU0NOgXv/iFHnzwQfn9fk2dOlUDBgxQv379rrlPv9+Qx9MQUj0uV+eQt0V40JPoRF+iz432JD295cvxli0qO51O1dfXN78OBAJyOK7kUVJSkqZOnaqkpCQ5nU4NHz5cR48etao0AIAsDIQhQ4Zo69atkqR9+/YpMzOzee7kyZMqLi6W3++Xz+fT3r17deedd1pVGgBAFl4yysnJ0fbt2zV58mQZhqHFixdrxYoVcrvdys7OVm5urgoKChQfH6+JEyeqT58+VpUGAJBkMwzDiHQRofL5/KwhdCD0JDrRl+hz068hAACiG4EAAJBEIAAATAQCAEASgQAAMBEIAABJBAIAwEQgAAAkEQgAcFOZvmq/pvx9Z1j2TSAAACQRCAAAE4EAAJBEIAAATAQCAEASgQAAMBEIiArhvJUOQOsQCAAASQQCAMBEIAAAJBEIAAATgQAAkEQgAABMBAIAQBKBAAA3jbeOnNbBU+e16+RZ5b6wU28dOd2u+ycQAHwnHhiMHm8dOa3Fb1fL5zckSV9euKzFb1e3aygQCABwE6h4/6QuNQWCxi41BVTx/sl2OwaBAAA3gdMXLrdpPBQEAgDcBDJSEts0HgoCAQBuAjOyeqqTI/hbdidHnGZk9Wy3Y1gWCIFAQKWlpSosLFRJSYlqamqC5levXq2f//znKigo0ObNm60qC1Eg3HdOAB3B+P4Zmn9fH8XbbZKk76ckav59fTS+f0a7HcPRbnu6jnfffVeNjY1atWqV9u3bp/Lycj3//POSpNraWq1cuVKvv/66Ll++rOLiYo0YMUIJCQlWlYcI+a47JyS16190oCMY3z9D/3vgSzkccVqa94N2379lZwh79uxRVlaWJGnQoEE6dOhQ89yBAwc0ePBgJSQkKCUlRW63W0ePHrWqNESQFXdOAGgdy84QvF6vnE5n82u73a6mpiY5HA55vV6lpKQ0zyUnJ8vr9V53n3a7TS5X55DqsdvjQt4W7edad07Qn8hzOOJks4X+dYb2F86eWBYITqdT9fX1za8DgYAcDkeLc/X19UEB8V38fkMeT0NI9bhcnUPeFu0nIyVRX7YQChkpifQnCjQ1BeRwxNGLKNIePUlPb/n7q2WXjIYMGaKtW7dKkvbt26fMzMzmuYEDB2rPnj26fPmyLly4oOPHjwfNo+Oy4s4JAK1j2RlCTk6Otm/frsmTJ8swDC1evFgrVqyQ2+1Wdna2SkpKVFxcLMMwNHv2bCUmtt+9tYhe3ywcP7Xx/+TzG/p+SqJmZPVkQRmIAMsCIS4uTn/84x+Dxnr37t3854KCAhUUFFhVDqJIuO+cANA6PJgGAJBEIAAATAQCgBbxBHnsIRAAXMWKz95H9CEQAFyFJ8hjE4EA4CpWfPY+oo9lt50CuHlc6wlyRNbfCn8Ytk9a4AwBwFV4gjw2cYYA4Co8QR6bCAQALeIJ8tjDJSMAgCQCAQBg4pIRokI475wA0DqcIQAAJBEIAAATgQAAkEQgAABMBAIAQBKBAAAwEQgAAEkEAgDARCAAACTxpDKAa+AJ8tjCGQIAQBKBAAAwEQgAAEkEAgDARCAAACQRCAAAk2W3nV66dElz5sxRXV2dkpOTtWTJEqWlpQW955FHHpHH41F8fLwSExO1fPlyq8oDgJhnWSC8+uqryszM1KOPPqoNGzaooqJCCxYsCHrPp59+qg0bNshms1lVFgDAZNkloz179igrK0uSNGrUKO3YsSNo/syZMzp//rweeeQRFRUVafPmzVaVBgBQmM4QXnvtNb388stBY127dlVKSookKTk5WRcuXAia9/l8euihhzR16lSdO3dORUVFGjhwoLp27fqdx4mPtys9PSXkOm9kW4QHPYlO9CX6hKMnYQmESZMmadKkSUFjM2fOVH19vSSpvr5eXbp0CZq/5ZZbNHnyZDkcDnXt2lX9+/fXJ598cs1AAAC0H8suGQ0ZMkRbtmyRJG3dulVDhw4Nmv/ggw80a9YsSVcCo7q6Wr169bKqPACIeTbDMAwrDnTx4kXNnTtXtbW1io+P1zPPPKP09HQ9/fTTGjdunAYOHKhFixZp//79iouL069+9Svde++9VpQGAJCFgQAAiG48mAYAkEQgAABMBAIAQFKMB0Jtba2WL1+u+++/P9KlAEDExdyv0PT5fHrvvfe0bt06bd++XU1NTbLb7ZEuC4hadXV1crlcfJ3EgJg5Qzh06JCeeuopjRw5UrNnz9aWLVvkcrk0ffp0vfPOO5EuD6YLFy7I6/VGuoyY88orryg3N1dNTU1XzS1evFhZWVl66aWXrC8MlurQZwh1dXV64403tG7dOh07dkyGYTR/cN6jjz6q6dOny+Ho0P8Loo5hGNq6dauOHTum22+/XT/5yU/kcDi0Y8cOLVy4UCdOnJAk9e/fX7/97W81cuTICFfcsRmGoblz56qyslKpqan64osv5Ha7g97TvXt3xcXFacmSJTpw4ICeffbZCFUbey5evKjXX39d77//vo4ePSqPxyObzaa0tDT17dtX9957r3Jzc5WQkNAux+twzyE0NTVp06ZNWrt2rbZt26ampiYlJCToxz/+sXJyctS3b1/l5+dr6dKlys7OjnS5MeX8+fP69a9/rf379+ubv3YDBgxQaWmppkyZoqSkJA0bNkyBQEAffvihLl26pBUrVuiuu+6KcOUd1+rVq1VaWqri4mLNnTtXiYmJLb7v8uXL+v3vf6833nhDZWVleuCBByyuNPb8+9//1qxZs1RXV6eEhAS53W516dJFTU1N8ng8+uyzz2QYhrp166ZnnnlGQ4YMueFjdrhAuPvuu+XxeOR0OjVy5Ejl5ORo9OjRSk5OliT95z//UXZ2NoEQAQsXLtSaNWs0d+5cDRs2TKdOndKiRYt06tQpde/eXStXrpTL5ZJ05dNvCwoKlJmZqWXLlkW48o5r0qRJ6tSpk1auXHnd9wYCAeXl5SkxMVH//Oc/Lagudh07dkx5eXlyOp2aO3euxo0bd9VZgNfr1b/+9S8999xz8nq9WrdunXr06HFDx+1wawhnz55VUlKScnNzNW7cOA0fPrw5DBBZmzZt0uTJk1VUVKRevXppxIgRWrBggS5evKgpU6Y0h4F05cMOCwoKdPDgwQhW3PEdO3as1T8YxcXFaezYsfr444/DXBVeeOEFJSUlae3atfrpT3/a4iUhp9Op/Px8rVmzpt1+oViHu4D+0ksvaf369Vq/fr1effVV2Ww2DRo0SPfdd59ycnIiXV5Mq62tVe/evYPG7rjjDknSbbfddtX7u3XrpnPnzllSW6yy2+1tuv78ve99T3FxHe7nyKiza9cu5eXlKSMj47rvvfXWW/XAAw9o27ZtN3zcDhcIw4cP1/Dhw1VaWqotW7aoqqpKW7Zs0d69e7VkyRL17NlTNptNDQ0NkS415vh8PnXq1CloLD4+Pujf32az2eT3+y2pLVb16NFDhw4davX7Dx482GJ4o33V1dW16fJPr1699Nprr93wcTts1CckJCgnJ0fPPfectm/frkWLFmnYsGH69NNPm++sePDBB7VhwwY1NjZGulwgIiZMmKCqqipVV1df973V1dWqqqrSqFGjLKgstvl8PiUlJbX6/YmJic2/b+ZGdLgzhJY4nU7l5eUpLy9PtbW12rBhg6qqqrRjxw59+OGH6tKli3bu3BnpMmOCx+PRF1980fz6m0tCX3/9ddC4dGU9COFVWFioVatWqaSkRPPnz9eECROuegAtEAjozTffVHl5uZKTkzVt2rQIVYtw63B3GbVFTU2NKisrtX79em3cuDHS5XR4/fr1a34O5Nu+/XxIS44cORLOsmLeiRMnNGPGDNXU1Khz58668847lZ6erkAgoLq6Oh0+fFgNDQ3q1q2bli5dqv79+0e65A6vX79+evLJJ1u94P/OO++ovLz8hr9WYjoQYK0nnngipO3KysrauRL8t8bGRv3jH//Qhg0bdPTo0eYnluPj45tvyigsLGy3B6Bwbd/1w9P1EAgA2t3XX38tu92u1NTUSJcSkyL1wxOBAACQ1IHvMgIAtA2BAACQRCAAAEwEAgBAkvT/vlPT2jwGfnIAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -228,6 +292,228 @@ " plt.show()" ] }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
point_estimatestderrzstatpvalueci_lowerci_upper
A2.0630.14314.4310.0001.8282.298
B-0.0020.142-0.0150.988-0.2360.232
C-0.1310.143-0.9160.359-0.3650.104
D0.0860.1430.6030.546-0.1490.321
\n", + "
" + ], + "text/plain": [ + " point_estimate stderr zstat pvalue ci_lower ci_upper\n", + "A 2.063 0.143 14.431 0.000 1.828 2.298\n", + "B -0.002 0.142 -0.015 0.988 -0.236 0.232\n", + "C -0.131 0.143 -0.916 0.359 -0.365 0.104\n", + "D 0.086 0.143 0.603 0.546 -0.149 0.321" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Getting the inference of the coefficients of the CATE model\n", + "# together with the corresponding feature names.\n", + "est.coef__inference(T=1).summary_frame(feat_name=['A', 'B', 'C', 'D'])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
point_estimatestderrzstatpvalueci_lowerci_upper
intercept-1.040.146-7.1140.0-1.28-0.799
\n", + "
" + ], + "text/plain": [ + " point_estimate stderr zstat pvalue ci_lower ci_upper\n", + "intercept -1.04 0.146 -7.114 0.0 -1.28 -0.799" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Getting the inference of the intercept of the CATE model\n", + "est.intercept__inference(T=1).summary_frame()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Coefficient Results
point_estimate stderr zstat pvalue ci_lower ci_upper
A 2.063 0.143 14.431 0.0 1.828 2.298
B -0.002 0.142 -0.015 0.988 -0.236 0.232
C -0.131 0.143 -0.916 0.359 -0.365 0.104
D 0.086 0.143 0.603 0.546 -0.149 0.321
\n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Intercept Results
point_estimate stderr zstat pvalue ci_lower ci_upper
intercept -1.04 0.146 -7.114 0.0 -1.28 -0.799
" + ], + "text/plain": [ + "\n", + "\"\"\"\n", + " Coefficient Results \n", + "=======================================================\n", + " point_estimate stderr zstat pvalue ci_lower ci_upper\n", + "-------------------------------------------------------\n", + "A 2.063 0.143 14.431 0.0 1.828 2.298\n", + "B -0.002 0.142 -0.015 0.988 -0.236 0.232\n", + "C -0.131 0.143 -0.916 0.359 -0.365 0.104\n", + "D 0.086 0.143 0.603 0.546 -0.149 0.321\n", + " Intercept Results \n", + "===============================================================\n", + " point_estimate stderr zstat pvalue ci_lower ci_upper\n", + "---------------------------------------------------------------\n", + "intercept -1.04 0.146 -7.114 0.0 -1.28 -0.799\n", + "---------------------------------------------------------------\n", + "\"\"\"" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "est.summary(T=1,feat_name=['A', 'B', 'C', 'D'])" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -237,16 +523,16 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 10, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -268,12 +554,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -302,6 +588,209 @@ " plt.show()" ] }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
point_estimatestderrzstatpvalueci_lowerci_upper
01.1920.2924.0810.0000.7111.672
1-1.0570.189-5.5850.000-1.368-0.746
21.0650.2534.2020.0000.6481.482
3-1.0570.189-5.5850.000-1.368-0.746
4-1.0810.177-6.0950.000-1.372-0.789
50.8610.2773.1070.0020.4051.318
60.9260.2733.3970.0010.4781.375
7-0.8920.186-4.7840.000-1.199-0.585
80.9260.2733.3970.0010.4781.375
90.8610.2773.1070.0020.4051.318
\n", + "
" + ], + "text/plain": [ + " point_estimate stderr zstat pvalue ci_lower ci_upper\n", + "0 1.192 0.292 4.081 0.000 0.711 1.672\n", + "1 -1.057 0.189 -5.585 0.000 -1.368 -0.746\n", + "2 1.065 0.253 4.202 0.000 0.648 1.482\n", + "3 -1.057 0.189 -5.585 0.000 -1.368 -0.746\n", + "4 -1.081 0.177 -6.095 0.000 -1.372 -0.789\n", + "5 0.861 0.277 3.107 0.002 0.405 1.318\n", + "6 0.926 0.273 3.397 0.001 0.478 1.375\n", + "7 -0.892 0.186 -4.784 0.000 -1.199 -0.585\n", + "8 0.926 0.273 3.397 0.001 0.478 1.375\n", + "9 0.861 0.277 3.107 0.002 0.405 1.318" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Getting the inference of the CATE at different X vector values\n", + "est.effect_inference(X_test[:,:4]).summary_frame()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Uncertainty of Mean Point Estimate
mean_point stderr_mean zstat pvalue ci_mean_lower ci_mean_upper
0.175 0.243 0.719 0.472 -0.225 0.574
\n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Distribution of Point Estimate
std_point pct_point_lower pct_point_upper
0.982 -1.07 1.135
\n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Total Variance of Point Estimate
stderr_point ci_point_lower ci_point_upper
1.012 -1.25 1.389


Note: The stderr_mean is a conservative upper bound." + ], + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Getting the population inference given sample X\n", + "est.effect_inference(X_test[:,:4]).population_summary()" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -311,16 +800,16 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 12, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -349,12 +838,12 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -392,12 +881,12 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -444,6 +933,216 @@ " plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### CATE(x) inference" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
point_estimatestderrzstatpvalueci_lowerci_upper
01.7140.4843.5410.0000.9182.511
1-1.3190.268-4.9240.000-1.759-0.878
21.6920.8901.9010.0570.2283.156
3-1.3190.268-4.9240.000-1.759-0.878
4-1.1780.268-4.3990.000-1.619-0.738
51.0350.3033.4210.0010.5381.533
61.1030.4762.3180.0200.3201.886
7-1.0780.267-4.0390.000-1.517-0.639
81.1030.4762.3180.0200.3201.886
91.0350.3033.4210.0010.5381.533
\n", + "
" + ], + "text/plain": [ + " point_estimate stderr zstat pvalue ci_lower ci_upper\n", + "0 1.714 0.484 3.541 0.000 0.918 2.511\n", + "1 -1.319 0.268 -4.924 0.000 -1.759 -0.878\n", + "2 1.692 0.890 1.901 0.057 0.228 3.156\n", + "3 -1.319 0.268 -4.924 0.000 -1.759 -0.878\n", + "4 -1.178 0.268 -4.399 0.000 -1.619 -0.738\n", + "5 1.035 0.303 3.421 0.001 0.538 1.533\n", + "6 1.103 0.476 2.318 0.020 0.320 1.886\n", + "7 -1.078 0.267 -4.039 0.000 -1.517 -0.639\n", + "8 1.103 0.476 2.318 0.020 0.320 1.886\n", + "9 1.035 0.303 3.421 0.001 0.538 1.533" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Getting the inference of the CATE at different X vector values\n", + "est.effect_inference(X_test[:,:4]).summary_frame()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Uncertainty of Mean Point Estimate
mean_point stderr_mean zstat pvalue ci_mean_lower ci_mean_upper
0.279 0.441 0.632 0.527 -0.447 1.005
\n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Distribution of Point Estimate
std_point pct_point_lower pct_point_upper
1.25 -1.319 1.704
\n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Total Variance of Point Estimate
stderr_point ci_point_lower ci_point_upper
1.326 -1.55 2.163


Note: The stderr_mean is a conservative upper bound." + ], + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Getting the population inference given sample X\n", + "est.effect_inference(X_test[:,:4]).population_summary()" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -453,16 +1152,16 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 15, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -490,12 +1189,12 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -542,6 +1241,216 @@ " plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### CATE(x) inference" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
point_estimatestderrzstatpvalueci_lowerci_upper
01.2140.3883.1320.0020.5771.852
1-1.1570.184-6.2950.000-1.459-0.854
21.4040.3004.6840.0000.9111.897
3-1.1570.184-6.2950.000-1.459-0.854
4-1.1500.177-6.5080.000-1.440-0.859
51.0940.3353.2680.0010.5441.645
61.0110.3412.9650.0030.4501.572
7-0.9260.204-4.5370.000-1.261-0.590
81.0110.3412.9650.0030.4501.572
91.0940.3353.2680.0010.5441.645
\n", + "
" + ], + "text/plain": [ + " point_estimate stderr zstat pvalue ci_lower ci_upper\n", + "0 1.214 0.388 3.132 0.002 0.577 1.852\n", + "1 -1.157 0.184 -6.295 0.000 -1.459 -0.854\n", + "2 1.404 0.300 4.684 0.000 0.911 1.897\n", + "3 -1.157 0.184 -6.295 0.000 -1.459 -0.854\n", + "4 -1.150 0.177 -6.508 0.000 -1.440 -0.859\n", + "5 1.094 0.335 3.268 0.001 0.544 1.645\n", + "6 1.011 0.341 2.965 0.003 0.450 1.572\n", + "7 -0.926 0.204 -4.537 0.000 -1.261 -0.590\n", + "8 1.011 0.341 2.965 0.003 0.450 1.572\n", + "9 1.094 0.335 3.268 0.001 0.544 1.645" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Getting the inference of the CATE at different X vector values\n", + "est.effect_inference(X_test[:,:4]).summary_frame()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Uncertainty of Mean Point Estimate
mean_point stderr_mean zstat pvalue ci_mean_lower ci_mean_upper
0.244 0.289 0.844 0.399 -0.232 0.72
\n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Distribution of Point Estimate
std_point pct_point_lower pct_point_upper
1.102 -1.157 1.319
\n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Total Variance of Point Estimate
stderr_point ci_point_lower ci_point_upper
1.139 -1.334 1.65


Note: The stderr_mean is a conservative upper bound." + ], + "text/plain": [ + "" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Getting the population inference given sample X\n", + "est.effect_inference(X_test[:,:4]).population_summary()" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -551,7 +1460,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ @@ -560,16 +1469,16 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 18, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -582,7 +1491,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -592,7 +1501,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -602,12 +1511,12 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 31, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -634,7 +1543,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -643,16 +1552,16 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 23, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -669,7 +1578,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -679,7 +1588,17 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ[\"PATH\"] += os.pathsep + 'D:/Program Files (x86)/Graphviz2.38/bin/'" + ] + }, + { + "cell_type": "code", + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ @@ -689,12 +1608,12 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 37, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -721,16 +1640,16 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 27, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" } @@ -750,12 +1669,12 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 39, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -781,12 +1700,12 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 40, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdsAAADcCAYAAAA4CAs4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3dZ3gc1fn38e+t5t4LGBu3YDDEhHZMKAm9B4cecKghlISW8A8lIUAoIfT6JPTQAyTElBhsagIBQhsMBtOMARsb94a7ZO2e58WMrJW8knalXe1o9ftc11yamZ09c8/sau45Z87OmPceERERyZ+SQgcgIiJS7JRsRURE8kzJVkREJM+UbEVERPJMyVZERCTPlGxFRETyTMlWRETaHDObbmaj6s0LzGw3M7vMzI7MoIxLzOy6/EVZq6w1ViIiItJavPcXFzqG+lSzFRGRomJm95nZGdF4DzMbZ2afmtlLZvZAvdrsQDObEL3+jJl1zkdMbaVmq9tcSZs1fvx4AMaMGVPgSERyxvJT6qHpj/X+8YbW908zW5MyvWmaZS4GlnjvR5pZb+BdYFzK6w4YDXwLPAccDdyVZeRNaivJVkREil7WOfxw7/2Ude82C9IssztwJoD3frGZPVnv9ee890uj978FfCfbIDKhZmQREYkJa2BocaGNtY6m1owT5KkSqmQrIiIxUdLA0CL/AY4HMLNewEEtLbA5lGxFRKSYXQb0N7OPgIeA1wmvz7YqXbMVEZGYyLz+570fmmaei0ZfTpm9EhjrvV9jZt2B14D7o+Uvqff+OtO5pGQrIiIxkZdOzr2AiWZWCnQEHvbev5iPFTVGyVZERGIi91c2vffzge1yXnCWlGxFRCQm8vPz3ThQshURkVjwDSTbYkjBSrYiIhITxZBW01OyFRGRWPANXLMthhSsZCsiIjFRDGk1PSVbERGJhYZqtsVAyVZERGKhmB/vpmQrIiKxoJqtiIhI3umarYiISF6pZisiIpJnDd3Uohgo2YqIFLO11VDeNg71SrZFIJH0dLk5QWUivCow7SRjeM9SALwP+8CZ1f2gqxKegbclWLgmnB7RE94+poSeHYu3qUNEisjIM+Cz2eG4Gw7vXFfYeJpUvMm23WSNwXeEiRbC7uUj7g4T7Nn/rqbk+gQl1ycova6aLjdV88JX4YLbPVCbaAE+Xwpb3Zds5chFRBpxyq0w8CQYcCJs8DO4clw4/++v1SZagOBL+OfrhYkxQ56StEMxKI6tyMDslXWna1LmTZPqzltVDfuMCxPxlEXrl/P1iryEJyKSvf0vh7tehNmLYe5SmP8tXPA3+N+n8OcJ6y9/9ROtH2MWPJZ2KAbtphlZRKToPPte+vkXPATVifXnL4x3baFYEms67aZmKyLSbsxYAGvTJNuYV6/UjCx1PPRxgrsmVxc6DBEpZstXw9Jm1kTLS2HFqvXnd+8CPr43RVQzcht27dvVfLk0t2UeOyH8sp7+QjVV5xT9LhSR1rbdb2DSV+H4kH5QXgJfzINh/eHzW6GkiXrS6iroWLH+/ElfQclhUFYKlX9vupxWViyJNZ2izhR9/l81iyvzV/5aoLq6mrKyot6NItLaahIthE3CNb6cD6WHw//+BDuObPj9pQaJNM3INaoTsNmZ8PlfWh5rThVvso3XaU2O5TPR1qhshXWIiNSx0wWNv96vJ2zYq/Flps3JXTw5kqQk7VAMimMrCsiK90RMRNqq6rbap8QaGNo+tX+KiBSbJSvB4tsRqiHJIkms6WRVs3XOXeic88654/IVUFsT4459ItJejRwEVW3xbnfFW7PNONk650qAnwOLgVPzFpGIiLTMmkqoKC90FFnTNdvQvsAg4DhgJ+fcqPyEJCIiLfLZbCgrjiRVLLL5NE4FJgZB8AwwGTglPyGtb/ny5c0eb1gmTSxNL7Nixepmx6bx9jNeUVGR1fIa13gmGjpCVS9bDRv2yPi9+YitOYq5Zms+g4uOzrmNgBnAEUEQPOmcOwu4FNgoCILVjb87J5p1ZdSua7xHnj+nrMFlGnst1crToHNn9TOTho0fPx6AMWPGFDgSaTPs0KaX8Y83vNyIDSHpwxthNFVG8+TlQup8uzjtsb6/v6zNX7jN9JSh5lrt09H0Q0An4Mh8BNWWqIOUiMRO5wro2bXQUWQtiaUdikGTyTbqGHUS0BOY5ZybC3wMlNKKTckiIpKhOUthy0GFjiJrxXxv5ExqtvsRdozaCdg6ZfgRsKNzbsv8hSciIlmrqKh7m8c2opif+pPJxcZTgSeDIHi33vy5zrk3otfPyHlkbYTuICUira6p404ZtMUbBBbzVbkmk20QBAc18tpOuQ0nt/p1hAVr8ruODh2UbUWklb17XeOvd+oAi5t4PN9Om+YunhwpllpsOsW7ZcD8M8q4cy84zzXv/U2l0Q4GpaWlzStcRKQhx+5aO77HKBg1ODxaf3fjsAfxNsMbf/+CZdCzU8Ov9+4Kr1+Vk1BzqZiv2Rb9b1ZO3jrcxGuC7G/MXQKke0jVUwcbldVwxEglWhHJgwd+FQ7NVV0Na9McvQb3gRl3Nb/cPCuWnsfpFH2ybYmGngb5402UZEUkxjzQucP686vi/TSgYqnFplPUzcgiIkWtc0X6+QN6w+qq9eeXx/uQX8zNyPHe8wVWHB+xiBStR3+Tfv6tJ8P2aTpAWbwP+XFNtma2uZldZGZ/iaZHmtn3sikj3ns+h+p3Gu4aNaA/d6jRqQzKLNwZncrgmUPChbfuu345Q7vlN04RkYyNGQ0z7oCHz4bvDYE+XeGmE2H378FJe62//GVHtX6MWYjjvZHN7AjgFWAgcGw0uytwQ1blZHJv5BhocZALVyXY8FZPgjDxzj29lJ4dGz9jWptIMuC2JIuinw/tPAD++9NSSvTjWsmC7o0sBfOru+GWCeH4rpvDy1fkquS8HAQ/t2vTHutH+HMLdtA1s0+Asd77981sife+l5mVA7O99/0yLafddJDq27mU6nOye095aQkLz2g3lX8RKTY3nxQObURMf2fbn/BJd1Bb8fNkWQmM5ZaJiEj7E9MHEbxLbfNxjaOAt7MppN3UbEVEJN7i0BkqjbOA583s50AXM3sO2BTYJ5tClGxFRCQWYlCLXY/3/lMzGwkcSPiY2ZnA0977Ju6HWZeSrYiIxEJMa7Z471cB/2hJGUq2IpnyHq4aB2WlcO4hhY5GpOjEsWZrZq/SQGco7/0umZajZCuSqfLDIRH9z130CKxp0YmuiNQT05rt3fWmNwR+DjyUTSFKtiKZ8L420QJUxvsesyJtURxrtt77++vPM7NxwL3AZZmWo2QrkolEQ4+lEJFciWnNNp1vgKxu16hkK5KJtnGnNZE2LY43tTCzE+vN6gwcCryZTTlKtiIiEgsxPaWtf0OLlcD/gBuzKUTJVqQx85fCzEXwnTS3QK2sgh9fBe9Og2N2hZt+3qxVJL3n3bmeoT2gX+faM/vKas/78z2j+sLErzxlJXDwiNpnKd/ybjWfLYardymha4f41QhEshXTa7a756IcJVsRgJkLYPCp4XgJcOlRcNGjjb+nY8oTVG5+Br6cB/+6IKvVVieSVNyYXHdGf9bWSW7eq4zdHqnmlW/WX75zaTVLzipl8O0J5q0O5906OUnV2eG9vEXasrgkWzMbnsly3vsvMy1TyVYEahMtQJKmE20644Os37Ljw8k6TWe3vA+PfFzNgjTP/QZYlYAON67fWeukiUnuP1DJVtq2uCRbYBphq3ZjAXmgtJHX61CyFSmgYN768xpKtI15aXqLQxEpuLj0Rvbe5/zMVclWpAhUx7RniUg2YlSzzTklW5EiULyHKGlP4lKzTWVmZcBpwK5AX1L+3fJ2u0bnnAMuBHYGOgBzgQnA1UEQzMmmLBHJHVVspRjEtGZ7I7AHcCdwBfB74JdAVh07Mm6Xds7tDbwGfAZsHQRBd8JMvyj6KyIFUhLLY5RIdjyWdiiwQ4H9vfc3A9XR34OBrH4SlE3N9lbg4SAIzq+ZEdVmL89mhSKSB6raShGIac22M+EzbAFWm1nn6Bm322RTSEY1W+fcpsAmwMPZxZgby5cv17jG8zqeba5qaPmGyq+oqEg7H3LzQINqX9lkDBrXeK7G8yWmNdtPgNHReABcYmYXEt4fOWPmM7jnq3NuZ8Im5C2CIPgky0BzQeftkl92aG7K8Y+vN2v8+PEAjBkzZv3VXpebZDugE8w+Xf0dpdXkJQM+V/pA2mP9vonjCpZxzWw0kPDeTzKzEcBtQDfgHO/9q5mWk+l/54Lo70DCLC8iMZLUE/+kCPiCV2LX571/J2X8c2Cv5pSTUTNyEARTCe+oMbY5KxGR/DLdPEqKQLLM0g6FZGaTzexcM9u4JeVk8y96GnC0c+5PzrmNAJxz/Z1zv3POHdmSIESkhWJYIxDJli+1tEOBXUJ4zfYTM3vFzE41s97ZFpJxsg2C4AXgB8AWwIfOueXA60B/4JVsVywi0K9jbsoZ3is35YgUUqLM0g6F5L1/wnv/E2AAcA9wCDDTzP6VTTlZ9agIgiAg/H2RSHE5a3+4ZWLtdLcOsLyy4eXT6VLR9DL1vHIUbHFf7fSAzvDh8dD3tobfc+mO8Ic36s57+MCsVy0SOz7GPxj33i83s4eBpUA5cEA279eVHhGAm0+GZ34PR/8Q3r4alj0C1x4Lm20E2w2H8w9a/z1/+mnteJnBwvuzXu3mfct4Yyy4/nDmNjD7tDL6dCnDn1PGb0fDBp3h8BEwrDts0gPm/9K4eOcyFp9ubNAZOpXCffvBkB7qiSxtX7LU0g6FZKE9zeyvwDzCZuVngWFZlZPJT39ioE0EKUWsqgo6HFV3Xpqf+aTT2E9/RNqovGTAf27waNpj/eHzjirkT3/mACsIb8/4sPe+Wb/I0emwSCZK1Agkkm9x/OkPcLD3/q2WFqJkK5KJttECJNKmJWJ4zTYXiRaUbEUyY/E7CIgUmzh3kGopJVuRTJTpX0Uk35JFnGx1IUokUx9cD726QJ9u8MWthY5GpOgkLf1QDHS6LpKpLYfB4gcLHYVI0YprzdbM9gaOAvp778eYmQO6e+//nWkZqtmKiEgsJM3SDoVkZmcSPunnc2CXaPZq4I/ZlKNkKyIisZAssbRDgf0a2Mt7fxWQjOZ9CmyWTSFqRhYRkVjw8ez13w2YGY3X/AawHKjKphDVbEVEJBbieLtG4L/Ab+vNOwv4TzaFqGYrUgiVVTDyTJi/DI7dFT6YDgd/H847pNCRiRRMTGu2ZwLjzexkoJuZfQYsA7K6/6qSrUghdPkpJKLLP3c8H/59Yyo89z68dGnh4hIpIF8ay8bWeYTPsx0NDCFsUn7be59s9F31KNmKFEKigf/Tf3/YunGIxEjc7iBlZqWEDyHo6b1/G3i7uWUp2YqISCwkS0oLHUId3vuEmU0F+gCzW1KWkq2IiMRC3Gq2kb8BT5vZzcAsUh75ms1NLZRsRUQkFmKabH8Z/b2k3nwPDM+0ECVbkQxUVie57f0kW/Y19hxayokTq/nHZ7CqGrqUwopEuFzXMph/egmdylvQ0cN7+PMz8NeX4JR94LT9c7MRIjEXx97I3vthuShHyVakCWsTSTreVNOhydOltJqVidrXV6SOV0Pnm5Mkf2OMHZ9g1go4uayMQ8/+Oxz5NzjrR3Dafo2vsNtYWBn9Xv70u2DaHLjhxJxuk0gcJePZGzknlGxFmnDo43V7Dqcm2oZ0uDHB2uht+05cSLfZy8KJq58Ih8asrHdjmhufVrKVdiGONVszm0nKddpU3vvBmZajZCvShH/PyP49a1Py84EfT8pdMCJFLFkSy5rtMfWmBwC/Ah7NphAlW5EmJI0Gzmsz02/VspzFIlLM4liz9d6/Un+emb0MPAvcnGk5TSZb59zLwI6EN11OAouA14GbgiB4N9MVibRVLf33n96zD4OWLclJLCLFrA1ds60Esuo4lWnN9vIgCP4I4JwbApwMvOmc+0kQBE1cgBJp23wLarUAKzp2yU0gIkUujjVbM7us3qzOwAHAxGzKyfo0IgiCGUEQXAg8APw/51z89o5IDrX0/3/ThXNyE4hIkUuWlKQdCmzjekNH4Abg+GwKaclWPAoMJMsH6DbH8uXLNa7xgo23tGY7cbOt6kxnW1xqX+i47BONt+/xfIlpsv2d9/5nKcMZ3vu7gV7ZFGK+iSNJdM32xZpm5JT5mwMfAz8IguD17GLPWgsPdyLN1+WGalZl9XyPujqsrWL+JSfRvWpN8wvxjzf/vSK5l5cWzT/u/WbaY/2FL+xQsBZUM1vmve+eZv5i733vTMtpySnDoOjvohaUIRJ71S1ItACV5RV80btvboIRKWLJEks7FNh6AZhZd+o2OjWpJT/9ORL4BvisBWWIxF5pC3/6g/cMW6pzUpGmxKmDVMrNLDqZ2df1Xu4DPJJNeVknW+fcxsBJwAnAkUEQqIlXiloyB99wbwW/7iQSe4l4/Z8cQ1irnQAcmzLfA/O891lVNDNNthc5586PVrII+B+wUxAEzX6Qrkhb0bEMKqtbVsaq0vLselOItENxqtnW3MzCzPp671e1tLwmk20QBLu1dCUibdnJW8F1Wd6+ZWRP+HRpOD5k8VwGrlha+2Lncli1NvPCCn/NSqRVxKDn8Xq896vMbGvgh0BfUq7heu8vzrSc+G2ZSMxcu3sZnUprp3fdqPHlOxt8clIZ/xtrPDbGuGXH9/n4p1vD7ltCcA0se7jxAnbZvO70e9c3L3CRNsZb+qGQzOwUwrsm7gGcD2wJ/AbYJJtydG9kkQysOruMFVWeTmVQWmK8PivBvVM8K9bCqD7wp7dgTQKO3wLuPSD8t9pxYJihx0+FL47ahi3GjMlsZa9cAWuq4KOZMGowdCjP12aJxEoihjVb4DxgP+/9q2a2xHt/iJntDxyVTSFKtiIZ6lpRe4q986BSdh5U+9qFO+V4ZR0rYLvv5LhQkXiL0zXbFP29969G40kzK/HeTzSzv2VTiJKtiIjEQiKe/RNmmdlQ7/10YCpwkJktJHw4T8aUbEVEJBZ8fm5M1VLXAJsD04HLgH8CFcBZ2RSiZCsiIrEQx2u23vv7UsYnmlkvoMJ7vyKbcuK3ZSLtwRaD0s9/6retG4dIjHiztEOhmVkfMzvWzM7z3lcB3c2sgX/i9FSzFSmEj26BcW/ApC/gvINh7rcwuC906lDoyEQKJo7XbM1sV2AcEAA7EzYrjwDOATL8iYGSrUjhHLZjOAD06FrYWERiIBnPa7Y3AUd6718ysyXRvLeA7bMpRMlWRERiIY41W2Co9/6laLzmTulVZJk/dc1WRERiIWmWdiiwj81s33rz9gI+zKYQ1WxFRCQWYlqz/Q3wtJk9Q/i4vTsIr9UelE0hqtmKiEgseCztUNCYvH8T+B7wEXAP8BWwvff+nWzKUc1WJA+WrUlw8i/fYJ8pk1jSpQubnN2v0CGJxF51jH5na2Ybeu/nAnjvZxP2Qm42JVuRPDj6dx/x6N/+Qpe1lQA8scTBQT8ucFQi8ZaMVyvyVKB7zYSZPe69P7S5hSnZiuTBplM/59wDj+G1YSP50SeTOGjK24UOSST2Ehafmi2s1369W0sKU7IVyYPHvrcjM/v0B+DDAUOY0aM3OxQ4JpG4i1nN1je9SOaUbEXyYFmnzuz/ySTGvv86HwwYwgubfLfQIYnEXnW8arZlZrY7tTXc+tN47/+dcWE5Dk6kXZk5fw0dulTQvxNw8l9g8Up48CwO+eBN7nzir5QnE8CrvL7xCLjp6vBNy1bBvG9ZM2xDOpYZK6uSXPFWki37wtiRpVBVrQfGS7uUiFfNdj5h7+Mai+pNe2B4poUp2YpkYcnqJB3LjE5Va7jkx//kwdG7s6q8nDduuYChy6I7uXU7htGj94gSbWib2dOh40+47keHcffwHZjRqy9rKhL0W76EirVrmd+9F71XrWCP689hg1XLoUsHWPFIYTZSpECqY/Q7W+/90FyWF6s6u0ic9by5mt5/SdL55gS37nUPL222FSe99SJbz/mafqtW1ll2q7lfU1laCoSnv8Gg4XzZuSfn7XAIn20wkDUV4QMHFnTrRZ/Vq1hbVs5/brskTLQAKyvhl7e15uaJFNxaK0k7FAPzPqfXgPOlTQQpxetfU6s56F+10z+Y9hGv3HHpurNVT92ui/Wnp/QfyF4nX8S8nr0bXMea88fSIaU2TKdyWPX3lgcvknt5qYLueerstMf6l+7YKD5V3mZSM7JIBm6od6+Y0954rtFmIQNeG7IZ3SpX0yGxllHzv+Gz635Nz8vvh5p7vXrP2f8dz8j5c1jQtTsl9U98q6pzuQkisVdV+Psg542SrUgGKtfWnR66ZGGd6Wm9+7OmvIIt580CYNKAIez09dR1CfSrXv0YtmQBZ7w6kT/vcgAAndZWcckL/6R75RoAllZ0pGfVmpRS1aAj7UsMHjqQNxk3hjvnXnbOVTrnVkTDNOfcr/MZnEhc1K90WjJZZ3ptSSn3jN593fT/hmxWp6a6qrwCgGPef3XdvD6rljO/a4910xXJBHXqssq10s5UmqUdikG2V54vD4KgaxAEXYFjgCucc/vkIS6ReCmtO7nh8qV1pmf36M3P33l53fSuX33CBxsOBmBZh07gPW8PGs4ZB5/I92ZP54BPJrGwS3dGn3UlM3v0AWBmz75cvcchtYUWxzFGJGMJs7RDMWh2N68gCN4EPgZG5S4ckXiqX7O9dO/D60xPGjiMjzcYuG56xMI5dF+zileGbc7qsnJ6VK5mZYdO7Dx9Ku/ddD7P3HMV/7n9UlZWdOTtwZuwurScs398HPe63VJWmscNEomhNWZph2LQrGTrnDPn3M7ASOCN3Ia0vuXLl2tc4wUdL62X+O7ffg8mbrIlRx79K4786a94bMsduHe73Xhg212YsNnW4D1Dly7kh199Sv+Vyxi0bAm7f/ERF740bl3z8g5ff46bOY1tZ31Jp8Ra/vDCOCqj5mZgXUeqQm+7xjVefzxf1lr6oRhk/NMf59zLwPeBSqAC6ATcAZweBEGikbfmgs7xpaC2v7eadxalzPCeEu9JRo8E++OEh/n9f54MX6LhFuA5XXswYMW3ACzt2Jkve/Vj2zkzAJgwchvO238sU248L1zYgOTjud8YkZbLSwrc6KyFaY/1s2/p2+ZTbra9ka8IguCPAM65QcDDhLevOj7XgYnESf2WrA5Va6js0Gnd9PkvP1W7LA0n3E/7DeDOHfZm428XctuO+7DRt0v4wwuPMb9rD35x6MlsOXdG7cIxupuOSGtYVSRNxuk0+6c/QRDMcs79A7gSJVtpZxKl5fRd8S0Lo97EpfVaiD7qsyGjFs1d733um6846Yhf0imxlo/7DyLYuIR/jRq97vXBS1N+UmRq0JH25Vsl2/U55zYEjgAm5y4ckXgqr9cbubq0dF2iBUhglKVc7dh88Txm9OjNkG8X13lfp6pKPrnu/6hIJnhqC8chx59D57VVrOzQEYBDp7xVu3DdXxeJFL/izbVZJ9uLnHO/jcZXAq8A5+Q2JJH4OWIkvD6vdrr3yuWUJxPM694LgEVdurLBytoOJKXeM6tnHx7edhf2mTqZ7b75CoDq0jI6JsJf0x70ccCouTO5+IXH+Kz/QIYvmsuSjl1qV1Kue85IO6OaLQRBsFse4xCJtbNcKb9+pbYf4ClvPMuDrvYmFn1Wraiz/Ge9+7PLaZeTLCnhkn2O4O1bLmCrOTOY3aM3wxfPB2BNWTnbz5jKoR+9Q8mUt/nHqNHc8/09Oe2tF8NCDtgu/xsmEidKtiLtm5lR/X+l3PZ+giHdjTFH78vzV87nm559wYzZ3XoxeFnYZOyB63cds66nclVZOa8MG8lWc2Zw7/d3Z9N5s9lo2RJu/OGPOHjym9yy0768sOlWTNh8WzafNzNaITDuvMJsrEihKNmKSGmJcca2Nf8yfXj3hp5MeH0RPQb3YvAx18A250BlFTbhIgZc+E54Jwwz8J6Rc2eBf5zLgar3pzP7o3kcu9W2HDBiNB/NqebPzxt79zSePWVDOPXPMGKjQm6qSGEUb67VI/ZE8mGj389lTq++66YP+vAtnrx/5wJGJJJTeUmLdt6ytMd6f033Np+GVbMVyYMlXbrVmZ40cFiBIhFpQ9p8Sm1Ys++NLCIN67C2ss704CULChSJSBtiln4oAkq2InkwYtViyqrDh+B2XbOS/aa+X+CIRNoAa2AoAmpGFsmDiX8YxmH/9yHliSQjFnzDVj/r1vSbRNq7IqnFpqNkK5IHfTuX8srtW5P0nmee/gYoL3RIIvGnZCsizVFSxAcPkZwr4n8XJVsREYmJ4s22SrYiIhIPRdxlV8lWRETioYgvuxTxeYSIiEg8qGYrIiLxUKKarYiIiDSTarYiIhIPRXzNVslWRETioXhzrZKtiIjERBEnW12zFRERyTPVbEVEJB7UG1lERESaSzVbERGJB/VGFhERybPizbVKtiIiEhNFnGx1zVZERNocM5tuZqMKHUemVLMVEZF4UM1WREQkz8zSDxm/3Uab2Rtm9kH0d3Q0/0ozOzca/4mZJc2sfzQ9wcz2ycv2pMbmvc/3OlrMzJ4F+hY6jqaUlZX1ra6uXljoOOJA+6Iu7Y9a2hd1tdH9sdB7v18hAzCz6cCB3vsp0XQFMA040Xv/opntCdwLbALsApzjvd/PzO4AtgRuAcYBc4GNvfer8hlvm2hGLvSHminnXBAEgSt0HHGgfVGX9kct7Yu6tD9yZjOgynv/IoD3/iUzq4rmvw78I0rIOwPnAIcD3wAf5jvRgpqRRUSkOBiQrqnWe+9XA5OBscAc4D/AjsCewL9bIzglWxERKQafAh3MbHeA6G85MDV6/SXgUuAl730lMAs4IZqfd22iGbkNubPQAcSI9kVd2h+1tC/q0v5ovhfNrDpl+hDgFjPrAqwEDvfeV0WvvQRcTm1yfYmwSfnt1gi0TXSQEhERacvUjCwiIpJnSrYiIiJ5pmu2LeCcOwY4D9gC+HUQBH9uZNmTgfMJe8xNBM4KgiDZKoG2AudcZ8LftG0HVAPnBEHwdJrldgMmUNtpoTIIgu+3Vpz55JzbFLgf6AMsAo4LguDzesuUEv6+b/XPTn0AAAw8SURBVD/CnpNXBUFwd2vHmm8Z7otLgNOA2dGs14MgOL0142wNzrnrgMOAocCWQRBMSbNMu/hetGeq2bbM+8BRwMONLeScGwb8gbCr+YhoOCbv0bWuc4DlQRBsAowB7nbOdW1g2Y+DINg6Gooi0UZuB/4SBMGmwF+AO9IsczThj+xHEH4fLnHODW21CFtPJvsC4IGU70LRJdrIk4Q3VZjRyDLt5XvRbinZtkAQBFOCIPgYaKqGejjwZBAEC6La7F3AkXkPsHUdSXiAJarBBMD+BY2oFTnn+gPbAo9Esx4BtnXO9au36JHAXUEQJIMgWEB4ID6i9SLNvyz2RbsQBMFrQRDMbGKxov9etHdKtq1jMHXPar8GNi5QLPmSzTZu6pyb5Jx7yzl3fP5DaxUbA98EQZAAiP7OZv190B6+C5nuC4CjnHMfOOeed87t2JpBxkx7+F60a7pm2wjn3CTCf4J0Nqg5mLQHTe2LLIqaBGwcBMG3UfP6i865b4IgeLHFQUpbcztwRRAEa51zewNPOec2D4JgUaEDE8k1JdtGBEGwbY6K+hoYkjI9GGiqWSlWmtoXzrmabVwQzRpMeEu0+uUsSxn/yjn3JOEPy9t6sp0JDHTOlQZBkIg6vGzE+p9zzX56J5quX6MpBhntiyAI5qaMv+CcmwmMAl5p1WjjoT18L9o1NSO3jnHAwc65fs65EuBk4B8FjinXHgNOBXDOjQBGA8/WX8g5N8A5Z9F4b2Afwo5mbVoQBPMJt2NsNGss8F50/S3VY8DJzrmS6BrmwYTfj6KR6b5wzg1MGd+asLfuZ60UZtwU/feivVOybQHn3Fjn3CzCjgyXO+dmOee2iF67zDn3C4AgCL4kvE3Ym8DnwJfAQwUKO1+uBXo656YBTwOnBEGwHOruC8KfQExxzr0P/Bd4MAiCpwoSce79AjjTOTcVODOaxjk3wTlX81SXBwk//88Jvw+XRd+PYpPJvviTc26Kc24yYafBY1Nru8XCOXdLdJwYRHjZ5KNofnv8XrRbul2jiIhInqlmKyIikmdKtiIiInmmZCsiIpJnSrYiIiJ5pmQrIiKSZ0q2kjdmNtTMvJkNyvN6fmFmD6ZMTzSz8/K5TknPzKaZ2QkZLtsq34/WYGYdzOxzMxtZ6FgknpRsY8DMhpvZY2Y218xWmNlMM3vCzCqi108ws2lp3tfQ/GOig9jFaV572cwqo/V8a2bvmdlh+dmy/DOzLsBlwCU187z3+3vvrylYUE2IPpsfFDqO9iAf+9rMdjOz6tR53vtK4DrC35uLrEfJNh4mAHOAzYBuhI/Yeo7w2bfNcQqwGDjJzErTvH65974r4bNGHwH+bmabNnNdhXYM8KH3/otCByLt3iPAHma2SaEDkfhRsi0wM+tDmGRv995/60OzvPe3R2fL2Za3OfBD4HhgAI085s57Xw3cCpQCW6Yp6wwze6/evGFmljCzodH0vVFNfLmZfWxmP20ktkvM7MV68142swtTpkeZ2XNmttDMvjazK82svJFNPhh4oaEyU5oqj4/iW2lmE8ysl5ldZWbzoxaF01Pef0LUHHq+mc2Jlrk+NY6mttvMvmdmz5rZAjNbbGYvRPMnR4s8H7UupH1AuJl1NrObo3UsNLMnzWxwyusvRzGNi2L4wswOamgnpWzT2WY2K3rPdWbWJypjmZl9mloLNLMyM7vYzL6MtuElMxuV8nq5md2Qsg/PT7PeH5rZa9H7vzCz35hZxieRZnaYmU2OWmEmm9kh9bep3vL31ezThva1mU2Ptuu1aH5gZqPTlZEyb7qFLUYbAROB0ui9K8zseADv/TLCexv/ONPtk/ZDybbAvPeLgI+Au83sODPbIpuDURqnEtb0niasMZ/S0IIWNlOfDqwFJqdZ5G/A5ma2dcq8E4CXvffTo+nXgK2BnoTNufeZ2RbNCdzM+hPehP5xwhvX7wjsDfyukbdtC3ycQfGHAT8gvMH7UOAt4ItoPT8DbkpNZoQ3hR8MDI/iGAOck/J6g9ttZgOi7XglWteGwNUA3vutovfv473v6r0/qYF4bwR2iIYhwEJgvNVtqTgeuAHoAfwZuN/MOjeyD4ZE8Q6P9sWZhInjWqAX4X6/N2X5c4HjgAMIT9xeBV4ws+7R678FDgR2AoZF27rugRtm9l3C7+C1QD/gR8AZwLGNxLiOme1I+B38LWErzAXAI2b2/Uze38S+/gXwK6A38E9gQsp2NVbmbMIT2ERUZlfv/f0pi3xI+J0UqUPJNh52A14Gfk14A/d5ZnZRvaQ7zMyWpg6EtdJ1zKwj4YHsnmjWX4EDbP0OKL+P3j8LOAg4zHu/3rVf7/0S4CnCZEQUz/Ep5eO9/6v3fpH3PuG9fxT4INqe5jgOmOy9v8N7X+W9/wa4MprfkF7AskZer3G5935xdHLzNLDWe3+X977aez8RWAJsk7J8EjjXe786aqK+hmg/QJPbfSwwzXt/pfd+ZbQtGT/VyMxKCLf5Qu/9N977lYTfjc2B7VMW/bv3/nXvfRK4kzDpjmik6NXApVE8kwlPsN7x3r/pvU8Q3q97EzPrES3/M+Bq7/2nUSvLZUCCMGkSxXi1936a93414clI6v1ffwk85r1/KtpPnxKeFDT2eab6GTDOez8x+pyeAZ4ATszw/Y35q/f+Xe99FeGJ0GrCE4eWWkaYwEXqULKNAe/9Qu/9Bd77bQlrHucBF5NycAe+8t73TB2A0+oVdQTQldqHHEwA5gP1a09XRGX0997v5L0f30h49wJHR7XgPaL4HocwKZjZZWb2WdTMtxTYirAW0xzDgJ3rnVDcQ1gzbMgSoMkaCeE18Rqr6k3XzOuWMj3fe78qZXo64Y3kM9nuocDUDGJqSD+gI+GN6QHw3q8g/CxTHyg+J+X1ldFo6jbUNz9KzDXq74ea7a0pY+N6MSQJ90NNDIOi6dQY5qeUNwwYW+/z/ANhLTkTddYf+YLcPFR9es2ID28Q/zXR59tC3Qn7S4jUoWQbM977Vd77+whrSls3sXh9pxJef51iZnMJa669gZ9b+o5SmXgeWEN41n8C8GhUi4Hw0WknETbR9opOACbTcMeuFUCXevM2ShmfAbxY76SiR9SZqyHvAc1qtm5C/3pNskMJ9yc0vd3TabyG2dTTPxYAlYTJCgAz6wr0p3WfgzyzXgwlhPuhJoZvouma17sQxlhjBnBPvc+zu/f+u81Zf2R4yvqb+j5Bw/s6NW4jvGRQ8/nWKdfMyqi7XaknLPWNIvxOitShZFtgFnbUudLCjkHlUaeUwwj/aV/NopwtCB/Cfghhkq4ZtiesGR7QnPii2swDwFnAoaQ0IROexVcTJocSMzuRsIbXkADY1sy2i7bzDOoeTB8AnJmdaGYdoxrkcDPbr5EynwT2yn7LmlQCXGVmncxsOGETac21uaa2+yFgMws7WHWOPtc9U16fSyPJOGWfX25mG0VJ/3rgU+DtHG1fJu4DzjOzTaOWjd8DZcAz0esPAuea2XfMrBNhU3vqidatwFFmNiblu72Fme2axfoPM7N9zazUzPYn/A7WXFd+j/Ck6MDou3IIsEu9Mhra1yea2bYWdno7F+icsl0BsKeFnQE7AFcAqZ305hJ2kKpzImBm3Qj/3/6V4fZJO6JkW3hVhGfNjxM2Py0ALgTO9N4/lkU5pwKTvPfjvfdzU4YPSHmwezPdC+xK2JSderC/n7Cj0TTCWs4WNHKC4L1/mTBpPEvYfLkB8HrK63OB3Ql7GE8nbCJ+grA205AHga2ihJhLMwi36SvCbXyWMJlAE9sddaLZjbBz1yxgHpDaU/f3wGVmtsTM7mhg/WcTHvTfIWziHAD8OLq22lquJfw5y/OE27AHYWejmmvkVxL+RO1Nwv30NeF+A8B7P4WwReTXhJ/3fMIEmtFlBu/9/wj7CFxH+F24BjjGe/9m9PoXhJ2c7iT839mP9R+43tC+vhO4JSr3SOBH3vtvo9f+RpgwJxE2W39N+DnXxDWV8ETi7ah5vKbD11jgP977zzPZPmlf9DxbafPM7BfAzt77jHq5ZlDeCYSdk/R7ySJkZtMJP9+Hmlo2izI7AFMIT4g+yVW5UjzKCh2ASEt5728Hbi90HNJ+Rb21G7tOL+2cmpFFRETyTM3IIiIieaaarYiISJ4p2YqIiOSZkq2IiEieKdmKiIjkmZKtiIhInv1/JWHsRk7KGFUAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -800,13 +1719,6 @@ "source": [ "shap.summary_plot(shap_values, Xdf)" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -825,7 +1737,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.4" + "version": "3.7.5" } }, "nbformat": 4, diff --git a/setup.cfg b/setup.cfg index a4ba60d0b..6e52a36e2 100644 --- a/setup.cfg +++ b/setup.cfg @@ -38,7 +38,7 @@ setup_requires = sphinx_rtd_theme install_requires = numpy - scipy + scipy != 1.4.0 scikit-learn ~= 0.21.0 keras sparse @@ -48,12 +48,12 @@ install_requires = statsmodels >= 0.9 graphviz matplotlib < 3.1 + pandas test_suite = econml.tests tests_require = pytest pytest-xdist pytest-cov - pandas jupyter seaborn