diff --git a/econml/_cate_estimator.py b/econml/_cate_estimator.py
index 0621e9609..4400195e6 100644
--- a/econml/_cate_estimator.py
+++ b/econml/_cate_estimator.py
@@ -181,6 +181,54 @@ def marginal_effect(self, T, X=None):
         """
         pass
 
+    def ate(self, X=None, *, T0, T1):
+        """
+        Calculate the average treatment effect :math:`E_X[\\tau(X, T0, T1)]`.
+
+        The effect is calculated between the two treatment points and is averaged over
+        the population of X variables.
+
+        Parameters
+        ----------
+        T0: (m, d_t) matrix or vector of length m
+            Base treatments for each sample
+        T1: (m, d_t) matrix or vector of length m
+            Target treatments for each sample
+        X: optional (m, d_x) matrix
+            Features for each sample
+
+        Returns
+        -------
+        τ: float or (d_y,) array
+            Average treatment effects on each outcome
+            Note that when Y is a vector rather than a 2-dimensional array, the result will be a scalar
+        """
+        return np.mean(self.effect(X=X, T0=T0, T1=T1), axis=0)
+
+    def marginal_ate(self, T, X=None):
+        """
+        Calculate the average marginal effect :math:`E_{T, X}[\\partial\\tau(T, X)]`.
+
+        The marginal effect is calculated around a base treatment
+        point and averaged over the population of X.
+
+        Parameters
+        ----------
+        T: (m, d_t) matrix
+            Base treatments for each sample
+        X: optional (m, d_x) matrix
+            Features for each sample
+
+        Returns
+        -------
+        grad_tau: (d_y, d_t) array
+            Average marginal effects on each outcome
+            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.marginal_effect(T, X=X), axis=0)
+
     def _expand_treatments(self, X=None, *Ts):
         """
         Given a set of features and treatments, return possibly modified features and treatments.
@@ -303,6 +351,101 @@ def marginal_effect_inference(self, T, X=None):
         """
         pass
 
+    @_defer_to_inference
+    def ate_interval(self, X=None, *, T0, T1, alpha=0.1):
+        """ Confidence intervals for the quantity :math:`E_X[\\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
+        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(type of :meth:`ate(X, T0, T1)<ate>`, type of :meth:`ate(X, T0, T1))<ate>` )
+            The lower and the upper bounds of the confidence interval for each quantity.
+        """
+        pass
+
+    @_defer_to_inference
+    def ate_inference(self, X=None, *, T0, T1):
+        """ Inference results for the quantity :math:`E_X[\\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
+        -------
+        PopulationSummaryResults: 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_ate_interval(self, T, X=None, *, alpha=0.1):
+        """ Confidence intervals for the quantities :math:`E_{T,X}[\\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
+        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(type of :meth:`marginal_ate(T, X)<marginal_ate>`, \
+                             type of :meth:`marginal_ate(T, X)<marginal_ate>` )
+            The lower and the upper bounds of the confidence interval for each quantity.
+        """
+        pass
+
+    @_defer_to_inference
+    def marginal_ate_inference(self, T, X=None):
+        """ Inference results for the quantities :math:`E_{T,X}[\\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
+        -------
+        PopulationSummaryResults: 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."""
@@ -457,6 +600,79 @@ def const_marginal_effect_inference(self, X=None):
         """
         pass
 
+    def const_marginal_ate(self, X=None):
+        """
+        Calculate the average constant marginal CATE :math:`E_X[\\theta(X)]`.
+
+        Parameters
+        ----------
+        X: optional (m, d_x) matrix or None (Default=None)
+            Features for each sample.
+
+        Returns
+        -------
+        theta: (d_y, d_t) matrix
+            Average constant marginal CATE of each treatment on each outcome.
+            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.const_marginal_effect(X=X), axis=0)
+
+    @BaseCateEstimator._defer_to_inference
+    def const_marginal_ate_interval(self, X=None, *, alpha=0.1):
+        """ Confidence intervals for the quantities :math:`E_X[\\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
+        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(type of :meth:`const_marginal_ate(X)<const_marginal_ate>` ,\
+                             type of :meth:`const_marginal_ate(X)<const_marginal_ate>` )
+            The lower and the upper bounds of the confidence interval for each quantity.
+        """
+        pass
+
+    @BaseCateEstimator._defer_to_inference
+    def const_marginal_ate_inference(self, X=None):
+        """ Inference results for the quantities :math:`E_X[\\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
+        -------
+        PopulationSummaryResults: 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
+
+    def marginal_ate(self, T, X=None):
+        return self.const_marginal_ate(X=X)
+    marginal_ate.__doc__ = BaseCateEstimator.marginal_ate.__doc__
+
+    def marginal_ate_interval(self, T, X=None, *, alpha=0.1):
+        return self.const_marginal_ate_interval(X=X, alpha=alpha)
+    marginal_ate_interval.__doc__ = BaseCateEstimator.marginal_ate_interval.__doc__
+
+    def marginal_ate_inference(self, T, X=None):
+        return self.const_marginal_ate_inference(X=X)
+    marginal_ate_inference.__doc__ = BaseCateEstimator.marginal_ate_inference.__doc__
+
     def shap_values(self, X, *, feature_names=None, treatment_names=None, output_names=None, background_samples=100):
         """ Shap value for the final stage models (const_marginal_effect)
 
@@ -524,6 +740,18 @@ def effect(self, X=None, *, T0=0, T1=1):
         return super().effect(X, T0=T0, T1=T1)
     effect.__doc__ = BaseCateEstimator.effect.__doc__
 
+    def ate(self, X=None, *, T0=0, T1=1):
+        return super().ate(X=X, T0=T0, T1=T1)
+    ate.__doc__ = BaseCateEstimator.ate.__doc__
+
+    def ate_interval(self, X=None, *, T0=0, T1=1, alpha=0.1):
+        return super().ate_interval(X=X, T0=T0, T1=T1, alpha=alpha)
+    ate_interval.__doc__ = BaseCateEstimator.ate_interval.__doc__
+
+    def ate_inference(self, X=None, *, T0=0, T1=1):
+        return super().ate_inference(X=X, T0=T0, T1=T1)
+    ate_inference.__doc__ = BaseCateEstimator.ate_inference.__doc__
+
 
 class LinearModelFinalCateEstimatorMixin(BaseCateEstimator):
     """
diff --git a/econml/cate_interpreter/__init__.py b/econml/cate_interpreter/__init__.py
new file mode 100644
index 000000000..d0aa3700d
--- /dev/null
+++ b/econml/cate_interpreter/__init__.py
@@ -0,0 +1,7 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+from ._interpreters import SingleTreeCateInterpreter, SingleTreePolicyInterpreter
+
+__all__ = ["SingleTreeCateInterpreter",
+           "SingleTreePolicyInterpreter"]
diff --git a/econml/cate_interpreter.py b/econml/cate_interpreter/_interpreters.py
similarity index 92%
rename from econml/cate_interpreter.py
rename to econml/cate_interpreter/_interpreters.py
index c61e92d98..f3147f373 100644
--- a/econml/cate_interpreter.py
+++ b/econml/cate_interpreter/_interpreters.py
@@ -13,6 +13,7 @@
 class _SingleTreeInterpreter(metaclass=abc.ABCMeta):
 
     tree_model = None
+    node_dict = None
 
     @abc.abstractmethod
     def interpret(self, cate_estimator, X):
@@ -156,7 +157,7 @@ def export_graphviz(self, out_file=None, feature_names=None,
             exporter = self._make_dot_exporter(out_file=out_file, feature_names=feature_names, filled=filled,
                                                leaves_parallel=leaves_parallel, rotate=rotate, rounded=rounded,
                                                special_characters=special_characters, precision=precision)
-            exporter.export(self.tree_model)
+            exporter.export(self.tree_model, node_dict=self.node_dict)
 
             if return_string:
                 return out_file.getvalue()
@@ -249,7 +250,7 @@ def plot(self, ax=None, title=None, feature_names=None,
         check_is_fitted(self.tree_model, 'tree_')
         exporter = self._make_mpl_exporter(title=title, feature_names=feature_names, filled=filled,
                                            rounded=rounded, precision=precision, fontsize=fontsize)
-        exporter.export(self.tree_model, ax=ax)
+        exporter.export(self.tree_model, node_dict=self.node_dict, ax=ax)
 
 
 class SingleTreeCateInterpreter(_SingleTreeInterpreter):
@@ -261,7 +262,7 @@ class SingleTreeCateInterpreter(_SingleTreeInterpreter):
     include_uncertainty : bool, optional, default False
         Whether to include confidence interval information when building a
         simplified model of the cate model. If set to True, then
-        cate estimator needs to support the `effect_interval` method.
+        cate estimator needs to support the `const_marginal_ate_inference` method.
 
     uncertainty_level : double, optional, default .05
         The uncertainty level for the confidence intervals to be constructed
@@ -270,6 +271,11 @@ class SingleTreeCateInterpreter(_SingleTreeInterpreter):
         in a leaf have similar target prediction but also similar alpha
         confidence intervals.
 
+    uncertainty_only_on_leaves : bool, optional, default True
+        Whether uncertainty information should be displayed only on leaf nodes.
+        If False, then interpretation can be slightly slower, especially for cate
+        models that have a computationally expensive inference method.
+
     splitter : string, optional, default "best"
         The strategy used to choose the split at each node. Supported
         strategies are "best" to choose the best split and "random" to choose
@@ -335,6 +341,7 @@ class SingleTreeCateInterpreter(_SingleTreeInterpreter):
     def __init__(self,
                  include_model_uncertainty=False,
                  uncertainty_level=.1,
+                 uncertainty_only_on_leaves=True,
                  splitter="best",
                  max_depth=None,
                  min_samples_split=2,
@@ -346,6 +353,7 @@ def __init__(self,
                  min_impurity_decrease=0.):
         self.include_uncertainty = include_model_uncertainty
         self.uncertainty_level = uncertainty_level
+        self.uncertainty_only_on_leaves = uncertainty_only_on_leaves
         self.criterion = "mse"
         self.splitter = splitter
         self.max_depth = max_depth
@@ -370,20 +378,23 @@ def interpret(self, cate_estimator, X):
                                                 min_impurity_decrease=self.min_impurity_decrease)
         y_pred = cate_estimator.const_marginal_effect(X)
 
-        assert all(d == 1 for d in y_pred.shape[1:]), ("Interpretation is only available for "
-                                                       "single-dimensional treatments and outcomes")
-
-        if y_pred.ndim != 2:
-            y_pred = y_pred.reshape(-1, 1)
-
-        if self.include_uncertainty:
-            y_lower, y_upper = cate_estimator.const_marginal_effect_interval(X, alpha=self.uncertainty_level)
-            if y_lower.ndim != 2:
-                y_lower = y_lower.reshape(-1, 1)
-                y_upper = y_upper.reshape(-1, 1)
-            y_pred = np.hstack([y_pred, y_lower, y_upper])
-        self.tree_model.fit(X, y_pred)
-
+        self.tree_model.fit(X, y_pred.reshape((y_pred.shape[0], -1)))
+        paths = self.tree_model.decision_path(X)
+        node_dict = {}
+        for node_id in range(paths.shape[1]):
+            mask = paths.getcol(node_id).toarray().flatten().astype(bool)
+            Xsub = X[mask]
+            if (self.include_uncertainty and
+                    ((not self.uncertainty_only_on_leaves) or (self.tree_model.tree_.children_left[node_id] < 0))):
+                res = cate_estimator.const_marginal_ate_inference(Xsub)
+                node_dict[node_id] = {'mean': res.mean_point,
+                                      'std': res.std_point,
+                                      'ci': res.conf_int_mean(alpha=self.uncertainty_level)}
+            else:
+                cate_node = y_pred[mask]
+                node_dict[node_id] = {'mean': np.mean(cate_node, axis=0),
+                                      'std': np.std(cate_node, axis=0)}
+        self.node_dict = node_dict
         return self
 
     def _make_dot_exporter(self, *, out_file, feature_names, filled,
diff --git a/econml/_tree_exporter.py b/econml/cate_interpreter/_tree_exporter.py
similarity index 79%
rename from econml/_tree_exporter.py
rename to econml/cate_interpreter/_tree_exporter.py
index b8547eb78..b4232493e 100644
--- a/econml/_tree_exporter.py
+++ b/econml/cate_interpreter/_tree_exporter.py
@@ -47,9 +47,10 @@ def __init__(self, *args, title=None, **kwargs):
         self.title = title
         super().__init__(*args, **kwargs)
 
-    def export(self, decision_tree, ax=None):
+    def export(self, decision_tree, node_dict=None, ax=None):
         if ax is None:
             ax = plt.gca()
+        self.node_dict = node_dict
         anns = super().export(decision_tree, ax=ax)
         if self.title is not None:
             ax.set_title(self.title)
@@ -65,6 +66,10 @@ def __init__(self, *args, title=None, **kwargs):
         self.title = title
         super().__init__(*args, **kwargs)
 
+    def export(self, decision_tree, node_dict=None):
+        self.node_dict = node_dict
+        return super().export(decision_tree)
+
     def tail(self):
         if self.title is not None:
             self.out_file.write("labelloc=\"t\"; \n")
@@ -83,16 +88,17 @@ def __init__(self, include_uncertainty=False, uncertainty_level=0.1, *args, **kw
         super().__init__(*args, **kwargs)
 
     def get_fill_color(self, tree, node_id):
+
         # Fetch appropriate color for node
         if 'rgb' not in self.colors:
             # red for negative, green for positive
             self.colors['rgb'] = [(179, 108, 96), (81, 157, 96)]
 
         # in multi-target use first target
-        tree_min = np.min(tree.value, axis=0, keepdims=True)[(0,) * tree.value.ndim]
-        tree_max = np.max(tree.value, axis=0, keepdims=True)[(0,) * tree.value.ndim]
+        tree_min = np.min(np.mean(tree.value, axis=1))
+        tree_max = np.max(np.mean(tree.value, axis=1))
 
-        node_val = tree.value[(node_id,) + (0,) * (tree.value.ndim - 1)]
+        node_val = np.mean(tree.value[node_id])
 
         if node_val > 0:
             value = [max(0, tree_min) / tree_max, node_val / tree_max]
@@ -102,27 +108,64 @@ def get_fill_color(self, tree, node_id):
         return self.get_color(value)
 
     def node_replacement_text(self, tree, node_id, criterion):
-        if tree.n_outputs == 1:
-            value = tree.value[node_id][0, :]
-        else:
-            value = tree.value[node_id]
 
         # Write node mean CATE
-        node_string = 'CATE mean = '
-        value_text = np.array2string(value[0, 0] if self.include_uncertainty else value[0], precision=self.precision)
-        node_string += value_text + self.characters[4]
+        node_info = self.node_dict[node_id]
+        node_string = 'CATE mean' + self.characters[4]
+        value_text = ""
+        mean = node_info['mean']
+        if hasattr(mean, 'shape') and (len(mean.shape) > 0):
+            if len(mean.shape) == 1:
+                for i in range(mean.shape[0]):
+                    value_text += "{}".format(np.around(mean[i], self.precision))
+                    if 'ci' in node_info:
+                        value_text += " ({}, {})".format(np.around(node_info['ci'][0][i], self.precision),
+                                                         np.around(node_info['ci'][1][i], self.precision))
+                    if i != mean.shape[0] - 1:
+                        value_text += ", "
+                value_text += self.characters[4]
+            elif len(mean.shape) == 2:
+                for i in range(mean.shape[0]):
+                    for j in range(mean.shape[1]):
+                        value_text += "{}".format(np.around(mean[i, j], self.precision))
+                        if 'ci' in node_info:
+                            value_text += " ({}, {})".format(np.around(node_info['ci'][0][i, j], self.precision),
+                                                             np.around(node_info['ci'][1][i, j], self.precision))
+                        if j != mean.shape[1] - 1:
+                            value_text += ", "
+                    value_text += self.characters[4]
+            else:
+                raise ValueError("can only handle up to 2d values")
+        else:
+            value_text += "{}".format(np.around(mean, self.precision))
+            if 'ci' in node_info:
+                value_text += " ({}, {})".format(np.around(node_info['ci'][0], self.precision),
+                                                 np.around(node_info['ci'][1], self.precision)) + self.characters[4]
+        node_string += value_text
 
         # Write node std of CATE
-        node_string += "CATE std = "
-        value_text = np.array2string(np.sqrt(np.clip(tree.impurity[node_id], 0, np.inf)), precision=self.precision)
-        node_string += value_text + self.characters[4]
-
-        # Write confidence interval information if at leaf node
-        if (tree.children_left[node_id] == _tree.TREE_LEAF) and self.include_uncertainty:
-            ci_text = "Mean Endpoints of {}% CI: ({}, {})".format(int((1 - self.uncertainty_level) * 100),
-                                                                  np.around(value[1, 0], self.precision),
-                                                                  np.around(value[2, 0], self.precision))
-            node_string += ci_text + self.characters[4]
+        node_string += "CATE std" + self.characters[4]
+        std = node_info['std']
+        value_text = ""
+        if hasattr(std, 'shape') and (len(std.shape) > 0):
+            if len(std.shape) == 1:
+                for i in range(std.shape[0]):
+                    value_text += "{}".format(np.around(std[i], self.precision))
+                    if i != std.shape[0] - 1:
+                        value_text += ", "
+            elif len(std.shape) == 2:
+                for i in range(std.shape[0]):
+                    for j in range(std.shape[1]):
+                        value_text += "{}".format(np.around(std[i, j], self.precision))
+                        if j != std.shape[1] - 1:
+                            value_text += ", "
+                    if i != std.shape[0] - 1:
+                        value_text += self.characters[4]
+            else:
+                raise ValueError("can only handle up to 2d values")
+        else:
+            value_text += "{}".format(np.around(std, self.precision))
+        node_string += value_text
 
         return node_string
 
diff --git a/econml/inference.py b/econml/inference.py
index a59c0a808..56f023387 100644
--- a/econml/inference.py
+++ b/econml/inference.py
@@ -35,6 +35,24 @@ def fit(self, estimator, *args, **kwargs):
         """
         pass
 
+    def ate_interval(self, X=None, *, T0=0, T1=1, alpha=0.1):
+        return self.effect_inference(X=X, T0=T0, T1=T1).population_summary(alpha=alpha).conf_int_mean()
+
+    def ate_inference(self, X=None, *, T0=0, T1=1):
+        return self.effect_inference(X=X, T0=T0, T1=T1).population_summary()
+
+    def marginal_ate_interval(self, T, X=None, *, alpha=0.1):
+        return self.marginal_effect_inference(T, X=X).population_summary(alpha=alpha).conf_int_mean()
+
+    def marginal_ate_inference(self, T, X=None):
+        return self.marginal_effect_inference(T, X=X).population_summary()
+
+    def const_marginal_ate_interval(self, X=None, *, alpha=0.1):
+        return self.const_marginal_effect_inference(X=X).population_summary(alpha=alpha).conf_int_mean()
+
+    def const_marginal_ate_inference(self, X=None):
+        return self.const_marginal_effect_inference(X=X).population_summary()
+
 
 class BootstrapInference(Inference):
     """
@@ -1028,11 +1046,11 @@ def __init__(self, pred, pred_stderr, d_t, d_y, alpha, value, decimals, tol,
         self.treatment_names = treatment_names
 
     def __str__(self):
-        return self.print().as_text()
+        return self._print().as_text()
 
     def _repr_html_(self):
         '''Display as HTML in IPython notebook.'''
-        return self.print().as_html()
+        return self._print().as_html()
 
     @property
     def mean_point(self):
@@ -1067,11 +1085,15 @@ def stderr_mean(self):
             raise AttributeError("Only point estimates are available!")
         return np.sqrt(np.mean(self.pred_stderr**2, axis=0))
 
-    @property
-    def zstat(self):
+    def zstat(self, *, value=0):
         """
         Get the z statistic of the mean point estimate of each treatment on each outcome for sample X.
 
+        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 (d_y, d_t)
@@ -1080,14 +1102,19 @@ def zstat(self):
             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
+        value = self.value if value is None else value
+        zstat = (self.mean_point - value) / self.stderr_mean
         return zstat
 
-    @property
-    def pvalue(self):
+    def pvalue(self, *, value=0):
         """
         Get the p value of the z test of each treatment on each outcome for sample X.
 
+        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 (d_y, d_t)
@@ -1096,14 +1123,19 @@ def pvalue(self):
             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
+        pvalue = norm.sf(np.abs(self.zstat(value=value)), loc=0, scale=1) * 2
         return pvalue
 
-    @property
-    def conf_int_mean(self):
+    def conf_int_mean(self, *, alpha=.1):
         """
         Get the confidence interval of the mean point estimate of each treatment on each outcome for sample X.
 
+        Parameters
+        ----------
+        alpha: optional float in [0, 1] (default=.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 (d_y, d_t)
@@ -1112,14 +1144,17 @@ def conf_int_mean(self):
             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)])
+        alpha = self.alpha if alpha is None else alpha
+        mean_point = self.mean_point
+        stderr_mean = self.stderr_mean
+        if np.isscalar(mean_point):
+            return (_safe_norm_ppf(alpha / 2, loc=mean_point, scale=stderr_mean),
+                    _safe_norm_ppf(1 - alpha / 2, loc=mean_point, scale=stderr_mean))
+        else:
+            return np.array([_safe_norm_ppf(alpha / 2, loc=p, scale=err)
+                             for p, err in zip(mean_point, stderr_mean)]),\
+                np.array([_safe_norm_ppf(1 - alpha / 2, loc=p, scale=err)
+                          for p, err in zip(mean_point, stderr_mean)])
 
     @property
     def std_point(self):
@@ -1136,11 +1171,16 @@ def std_point(self):
         """
         return np.std(self.pred, axis=0)
 
-    @property
-    def percentile_point(self):
+    def percentile_point(self, *, alpha=.1):
         """
         Get the confidence interval of the point estimate of each treatment on each outcome for sample X.
 
+        Parameters
+        ----------
+        alpha: optional float in [0, 1] (default=.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 (d_y, d_t)
@@ -1149,70 +1189,108 @@ def percentile_point(self):
             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
+        alpha = self.alpha if alpha is None else alpha
+        lower_percentile_point = np.percentile(self.pred, (alpha / 2) * 100, axis=0)
+        upper_percentile_point = np.percentile(self.pred, (1 - alpha / 2) * 100, axis=0)
+        return lower_percentile_point, upper_percentile_point
 
-    @property
-    def stderr_point(self):
+    def conf_int_point(self, *, alpha=.1, tol=.001):
         """
-        Get the standard error of the point estimate of each treatment on each outcome for sample X.
+        Get the confidence interval of the point estimate of each treatment on each outcome for sample X.
+
+        Parameters
+        ----------
+        alpha: optional float in [0, 1] (default=.1)
+            The overall level of confidence of the reported interval.
+            The alpha/2, 1-alpha/2 confidence interval is reported.
+        tol:  optinal float(default=.001)
+            The stopping criterion. The iterations will stop when the outcome is less than ``tol``
 
         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.
+        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 be a scalar)
+            (e.g. if both are vectors, then the output of this method will also be a vector)
         """
-        return np.sqrt(self.stderr_mean**2 + self.std_point**2)
+        if self.pred_stderr is None:
+            raise AttributeError("Only point estimates are available!")
+        alpha = self.alpha if alpha is None else alpha
+        tol = self.tol if tol is None else tol
+        lower_ci_point = np.array([self._mixture_ppf(alpha / 2, self.pred, self.pred_stderr, tol)])
+        upper_ci_point = np.array([self._mixture_ppf(1 - alpha / 2, self.pred, self.pred_stderr, tol)])
+        return lower_ci_point, upper_ci_point
 
     @property
-    def conf_int_point(self):
+    def stderr_point(self):
         """
-        Get the confidence interval of the point estimate of each treatment on each outcome for sample X.
+        Get the standard error 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.
+        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 also be a vector)
+            (e.g. if both are vectors, then the output of this method will be a scalar)
         """
-        if self.pred_stderr is None:
-            raise AttributeError("Only point estimates are available!")
-        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
+        return np.sqrt(self.stderr_mean**2 + self.std_point**2)
 
-    def print(self):
+    def summary(self, alpha=0.1, value=0, decimals=3, tol=0.001, output_names=None, treatment_names=None):
         """
         Output the summary 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.
+        tol:  optinal float (default=0.001)
+            The stopping criterion. The iterations will stop when the outcome is less than ``tol``
+        output_names: optional list of strings or None (default is None)
+                The names of the outputs
+        treatment_names: optional list of strings or None (default is None)
+            The names of the treatments
+
         Returns
         -------
         smry : Summary instance
             this holds the summary tables and text, which can be printed or
             converted to various output formats.
         """
+        return self._print(alpha=alpha, value=value, decimals=decimals,
+                           tol=tol, output_names=output_names, treatment_names=treatment_names)
+
+    def _print(self, *, alpha=None, value=None, decimals=None, tol=None, output_names=None, treatment_names=None):
+        """
+        Helper function to be used by both `summary` and `__repr__`, in the former case with passed attributes
+        in the latter case with None inputs, hence using the `__init__` params.
+        """
+        alpha = self.alpha if alpha is None else alpha
+        value = self.value if value is None else value
+        decimals = self.decimals if decimals is None else decimals
+        tol = self.tol if tol is None else tol
+        treatment_names = self.treatment_names if treatment_names is None else treatment_names
+        output_names = self.output_names if output_names is None else output_names
 
         # 1. Uncertainty of Mean Point Estimate
-        res1 = self._res_to_2darray(self.d_t, self.d_y, self.mean_point, self.decimals)
+        res1 = self._res_to_2darray(self.d_t, self.d_y, self.mean_point, decimals)
         if self.pred_stderr is not None:
-            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)))
+            res1 = np.hstack((res1, self._res_to_2darray(self.d_t, self.d_y, self.stderr_mean, decimals)))
+            res1 = np.hstack((res1, self._res_to_2darray(self.d_t, self.d_y, self.zstat(value=value), decimals)))
+            res1 = np.hstack((res1, self._res_to_2darray(self.d_t, self.d_y, self.pvalue(value=value), decimals)))
+            res1 = np.hstack((res1, self._res_to_2darray(self.d_t, self.d_y,
+                                                         self.conf_int_mean(alpha=alpha)[0], decimals)))
+            res1 = np.hstack((res1, self._res_to_2darray(self.d_t, self.d_y,
+                                                         self.conf_int_mean(alpha=alpha)[1], decimals)))
 
-        treatment_names = self.treatment_names
         if treatment_names is None:
             treatment_names = ['T' + str(i) for i in range(self.d_t)]
-        output_names = self.output_names
         if output_names is None:
             output_names = ['Y' + str(i) for i in range(self.d_y)]
 
@@ -1223,9 +1301,11 @@ def print(self):
         title1 = "Uncertainty of Mean Point Estimate"
 
         # 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)))
+        res2 = self._res_to_2darray(self.d_t, self.d_y, self.std_point, decimals)
+        res2 = np.hstack((res2, self._res_to_2darray(self.d_t, self.d_y,
+                                                     self.percentile_point(alpha=alpha)[0], decimals)))
+        res2 = np.hstack((res2, self._res_to_2darray(self.d_t, self.d_y,
+                                                     self.percentile_point(alpha=alpha)[1], decimals)))
         metric_name2 = ['std_point', 'pct_point_lower', 'pct_point_upper']
         myheaders2 = [name + '\n' + tname for name in metric_name2 for tname in treatment_names
                       ] if self.d_t > 1 else [name for name in metric_name2]
@@ -1243,9 +1323,11 @@ def print(self):
             # 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)))
+                                                         self.conf_int_point(alpha=alpha, tol=tol)[0],
+                                                         self.decimals)))
             res3 = np.hstack((res3, self._res_to_2darray(self.d_t, self.d_y,
-                                                         self.conf_int_point[1], self.decimals)))
+                                                         self.conf_int_point(alpha=alpha, tol=tol)[1],
+                                                         self.decimals)))
             metric_name3 = ['stderr_point', 'ci_point_lower', 'ci_point_upper']
             myheaders3 = [name + '\n' + tname for name in metric_name3 for tname in treatment_names
                           ] if self.d_t > 1 else [name for name in metric_name3]
diff --git a/econml/tests/test_ate_inference.py b/econml/tests/test_ate_inference.py
new file mode 100644
index 000000000..bd66a2d0c
--- /dev/null
+++ b/econml/tests/test_ate_inference.py
@@ -0,0 +1,81 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+import numpy as np
+import unittest
+from sklearn.preprocessing import PolynomialFeatures
+from sklearn.linear_model import LinearRegression, LogisticRegression
+from econml.dml import LinearDML
+from econml.inference import BootstrapInference
+
+
+class TestATEInference(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        np.random.seed(123)
+        # DGP constants
+        cls.n = 1000
+        cls.d_w = 3
+        cls.d_x = 3
+        # Generate data
+        cls.X = np.random.uniform(0, 1, size=(cls.n, cls.d_x))
+        cls.W = np.random.normal(0, 1, size=(cls.n, cls.d_w))
+        cls.T = np.random.binomial(1, .5, size=(cls.n, 2))
+        cls.Y = np.random.normal(0, 1, size=(cls.n, 3))
+
+    def test_ate_inference(self):
+        """Tests the ate inference results."""
+        Y, T, X, W = TestATEInference.Y, TestATEInference.T, TestATEInference.X, TestATEInference.W
+        for inference in [BootstrapInference(n_bootstrap_samples=5), 'auto']:
+            cate_est = LinearDML(model_t=LinearRegression(), model_y=LinearRegression(),
+                                 featurizer=PolynomialFeatures(degree=2,
+                                                               include_bias=False))
+            cate_est.fit(Y, T, X=X, W=W, inference=inference)
+            cate_est.ate(X)
+            cate_est.ate_inference(X)
+            cate_est.ate_interval(X, alpha=.01)
+            lb, _ = cate_est.ate_inference(X).conf_int_mean()
+            np.testing.assert_array_equal(lb.shape, Y.shape[1:])
+
+            cate_est.marginal_ate(T, X)
+            cate_est.marginal_ate_interval(T, X, alpha=.01)
+            cate_est.marginal_ate_inference(T, X)
+            lb, _ = cate_est.marginal_ate_inference(T, X).conf_int_mean()
+            np.testing.assert_array_equal(lb.shape, Y.shape[1:] + T.shape[1:])
+
+            cate_est.const_marginal_ate(X)
+            cate_est.const_marginal_ate_interval(X, alpha=.01)
+            cate_est.const_marginal_ate_inference(X)
+            lb, _ = cate_est.const_marginal_ate_inference(X).conf_int_mean()
+            np.testing.assert_array_equal(lb.shape, Y.shape[1:] + T.shape[1:])
+
+            summary = cate_est.ate_inference(X).summary(value=10)
+            for i in range(Y.shape[1]):
+                assert summary.tables[0].data[1 + i][4] < 1e-5
+
+            summary = cate_est.ate_inference(X).summary(value=np.mean(cate_est.effect(X), axis=0))
+            for i in range(Y.shape[1]):
+                np.testing.assert_almost_equal(summary.tables[0].data[1 + i][4], 1.0)
+
+            summary = cate_est.marginal_ate_inference(T, X).summary(value=10)
+            for i in range(Y.shape[1]):
+                for j in range(T.shape[1]):
+                    assert summary.tables[0].data[2 + i][1 + 3 * T.shape[1] + j] < 1e-5
+
+            summary = cate_est.marginal_ate_inference(T, X).summary(
+                value=np.mean(cate_est.marginal_effect(T, X), axis=0))
+            for i in range(Y.shape[1]):
+                for j in range(T.shape[1]):
+                    np.testing.assert_almost_equal(summary.tables[0].data[2 + i][1 + 3 * T.shape[1] + j], 1.0)
+
+            summary = cate_est.const_marginal_ate_inference(X).summary(value=10)
+            for i in range(Y.shape[1]):
+                for j in range(T.shape[1]):
+                    assert summary.tables[0].data[2 + i][1 + 3 * T.shape[1] + j] < 1e-5
+
+            summary = cate_est.const_marginal_ate_inference(X).summary(
+                value=np.mean(cate_est.const_marginal_effect(X), axis=0))
+            for i in range(Y.shape[1]):
+                for j in range(T.shape[1]):
+                    np.testing.assert_almost_equal(summary.tables[0].data[2 + i][1 + 3 * T.shape[1] + j], 1.0)
diff --git a/econml/tests/test_inference.py b/econml/tests/test_inference.py
index 9cf16b193..cc4f6e936 100644
--- a/econml/tests/test_inference.py
+++ b/econml/tests/test_inference.py
@@ -260,7 +260,8 @@ def test_degenerate_cases(self):
 
             pop = PopulationSummaryResults(np.mean(predictions, axis=0).reshape(1, 2), np.std(
                 predictions, axis=0).reshape(1, 2), d_t=1, d_y=2, alpha=0.05, value=0, decimals=3, tol=0.001)
-            pop.print()  # verify that we can access all attributes even in degenerate case
+            pop._print()  # verify that we can access all attributes even in degenerate case
+            pop.summary()
 
     def test_can_summarize(self):
         LinearDML(model_t=LinearRegression(), model_y=LinearRegression()).fit(
diff --git a/notebooks/Double Machine Learning Examples.ipynb b/notebooks/Double Machine Learning Examples.ipynb
index 9d18e8ae0..351af6f33 100644
--- a/notebooks/Double Machine Learning Examples.ipynb	
+++ b/notebooks/Double Machine Learning Examples.ipynb	
@@ -1495,7 +1495,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1536,7 +1536,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1553,16 +1553,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<econml.dml.dml.LinearDML at 0x1adf97376a0>"
+       "<econml.dml.LinearDML at 0x1c6352f1b38>"
       ]
      },
-     "execution_count": 30,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1574,7 +1574,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1583,7 +1583,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1649,12 +1649,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1080x432 with 2 Axes>"
       ]
@@ -1696,6 +1696,62 @@
     "plt.show()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.4 Tree Interpreter\n",
+    "\n",
+    "Interpreting heterogeneity via a tree based rule."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<econml.cate_interpreter.SingleTreeCateInterpreter at 0x1c640f3e9e8>"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from econml.cate_interpreter import SingleTreeCateInterpreter\n",
+    "\n",
+    "intrp = SingleTreeCateInterpreter(include_model_uncertainty=True, max_depth=2)\n",
+    "intrp.interpret(est, X)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(15, 5))\n",
+    "intrp.plot()\n",
+    "plt.show()"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
diff --git a/notebooks/Doubly Robust Learner and Interpretability.ipynb b/notebooks/Doubly Robust Learner and Interpretability.ipynb
index 9277f3689..55fea5201 100644
--- a/notebooks/Doubly Robust Learner and Interpretability.ipynb	
+++ b/notebooks/Doubly Robust Learner and Interpretability.ipynb	
@@ -1,1800 +1,1814 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<table border=\"0\">\n",
-    "    <tr>\n",
-    "        <td>\n",
-    "            <img src=\"https://ictd2016.files.wordpress.com/2016/04/microsoft-research-logo-copy.jpg\" style=\"width 30px;\" />\n",
-    "             </td>\n",
-    "        <td>\n",
-    "            <img src=\"https://www.microsoft.com/en-us/research/wp-content/uploads/2016/12/MSR-ALICE-HeaderGraphic-1920x720_1-800x550.jpg\" style=\"width 100px;\"/></td>\n",
-    "        </tr>\n",
-    "</table>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Doubly Robust Learner and Interpretability\n",
-    "\n",
-    "Double Machine Learning (DML) is an algorithm that applies arbitrary machine learning methods\n",
-    "to fit the treatment and response, then uses a linear model to predict the response residuals\n",
-    "from the treatment residuals."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Helper imports\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "import matplotlib\n",
-    "%matplotlib inline\n",
-    "\n",
-    "import seaborn as sns"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Generating Data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import scipy.special\n",
-    "\n",
-    "np.random.seed(123)\n",
-    "n=2000 # number of raw samples\n",
-    "d=10 # number of binary features + 1\n",
-    "\n",
-    "# Generating random segments aka binary features. We will use features 0,...,3 for heterogeneity.\n",
-    "# The rest for controls. Just as an example.\n",
-    "X = np.random.binomial(1, .5, size=(n, d))\n",
-    "# Generating an imbalanced A/B test\n",
-    "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,))\n",
-    "X_test = np.random.binomial(1, .5, size=(10, d))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Applying the LinearDRLearner"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<econml.drlearner.LinearDRLearner at 0x2720433d710>"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from sklearn.linear_model import LassoCV\n",
-    "from econml.drlearner import LinearDRLearner\n",
-    "from sklearn.linear_model import LogisticRegressionCV\n",
-    "from sklearn.dummy import DummyClassifier\n",
-    "\n",
-    "# One can replace model_y and model_t with any scikit-learn regressor and classifier correspondingly\n",
-    "# as long as it accepts the sample_weight keyword argument at fit time.\n",
-    "est = LinearDRLearner(model_regression=LassoCV(cv=3),\n",
-    "                      model_propensity=DummyClassifier(strategy='prior'))\n",
-    "est.fit(y, T, X=X[:, :4])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([1.02346725])"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Treatment Effect of particular segments\n",
-    "est.effect(np.array([[1, 0, 0, 0]])) # effect of segment with features [1, 0, 0, 0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(array([0.66350818]), array([1.38342633]))"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Confidence interval for effect. Produces the (alpha*100/2, (1-alpha)*100/2)% Confidence Interval\n",
-    "est.effect_interval(np.array([[1, 0, 0, 0]]), alpha=.05) # effect of segment with features [1, 0, 0, 0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>point_estimate</th>\n",
-       "      <th>stderr</th>\n",
-       "      <th>zstat</th>\n",
-       "      <th>pvalue</th>\n",
-       "      <th>ci_lower</th>\n",
-       "      <th>ci_upper</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>1.023</td>\n",
-       "      <td>0.184</td>\n",
-       "      <td>5.573</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>0.664</td>\n",
-       "      <td>1.383</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "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.063277038041713']\n",
-      " ['B' '-0.0021408002029092827']\n",
-      " ['C' '-0.1307524180853436']\n",
-      " ['D' '0.08603974866683765']]\n",
-      "-1.0398097870143193\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Getting the coefficients of the linear CATE model together with the corresponding feature names\n",
-    "print(np.array(list(zip(est.cate_feature_names(['A', 'B', 'C', 'D']), est.coef_(T=1)))))\n",
-    "print(est.intercept_(T=1))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Getting the confidence intervals of the coefficients of the CATE model\n",
-    "# together with the corresponding feature names.\n",
-    "feat_names = est.cate_feature_names(['A', 'B', 'C', 'D'])\n",
-    "point = est.coef_(T=1)\n",
-    "lower, upper = np.array(est.coef__interval(T=1))\n",
-    "yerr = np.zeros((2, point.shape[0]))\n",
-    "yerr[0, :] = point - lower\n",
-    "yerr[1, :] = upper - point\n",
-    "\n",
-    "with sns.axes_style(\"darkgrid\"):\n",
-    "    fig, ax = plt.subplots(1,1) \n",
-    "    x = np.arange(len(point))\n",
-    "    plt.errorbar(x, point, yerr, fmt='o')\n",
-    "    ax.set_xticks(x)\n",
-    "    ax.set_xticklabels(feat_names, rotation='vertical', fontsize=18)\n",
-    "    ax.set_ylabel('coef')\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>point_estimate</th>\n",
-       "      <th>stderr</th>\n",
-       "      <th>zstat</th>\n",
-       "      <th>pvalue</th>\n",
-       "      <th>ci_lower</th>\n",
-       "      <th>ci_upper</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>A</th>\n",
-       "      <td>2.063</td>\n",
-       "      <td>0.143</td>\n",
-       "      <td>14.431</td>\n",
-       "      <td>0.000</td>\n",
-       "      <td>1.828</td>\n",
-       "      <td>2.298</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>B</th>\n",
-       "      <td>-0.002</td>\n",
-       "      <td>0.142</td>\n",
-       "      <td>-0.015</td>\n",
-       "      <td>0.988</td>\n",
-       "      <td>-0.236</td>\n",
-       "      <td>0.232</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>C</th>\n",
-       "      <td>-0.131</td>\n",
-       "      <td>0.143</td>\n",
-       "      <td>-0.916</td>\n",
-       "      <td>0.359</td>\n",
-       "      <td>-0.365</td>\n",
-       "      <td>0.104</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>D</th>\n",
-       "      <td>0.086</td>\n",
-       "      <td>0.143</td>\n",
-       "      <td>0.603</td>\n",
-       "      <td>0.546</td>\n",
-       "      <td>-0.149</td>\n",
-       "      <td>0.321</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "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(feature_names=['A', 'B', 'C', 'D'])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>point_estimate</th>\n",
-       "      <th>stderr</th>\n",
-       "      <th>zstat</th>\n",
-       "      <th>pvalue</th>\n",
-       "      <th>ci_lower</th>\n",
-       "      <th>ci_upper</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>cate_intercept</th>\n",
-       "      <td>-1.04</td>\n",
-       "      <td>0.146</td>\n",
-       "      <td>-7.114</td>\n",
-       "      <td>0.0</td>\n",
-       "      <td>-1.28</td>\n",
-       "      <td>-0.799</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "                point_estimate  stderr  zstat  pvalue  ci_lower  ci_upper\n",
-       "cate_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": [
-       "<table class=\"simpletable\">\n",
-       "<caption>Coefficient Results</caption>\n",
-       "<tr>\n",
-       "  <td></td>  <th>point_estimate</th> <th>stderr</th>  <th>zstat</th> <th>pvalue</th> <th>ci_lower</th> <th>ci_upper</th>\n",
-       "</tr>\n",
-       "<tr>\n",
-       "  <th>A</th>      <td>2.063</td>      <td>0.143</td> <td>14.431</td>   <td>0.0</td>    <td>1.828</td>    <td>2.298</td> \n",
-       "</tr>\n",
-       "<tr>\n",
-       "  <th>B</th>     <td>-0.002</td>      <td>0.142</td> <td>-0.015</td>  <td>0.988</td>  <td>-0.236</td>    <td>0.232</td> \n",
-       "</tr>\n",
-       "<tr>\n",
-       "  <th>C</th>     <td>-0.131</td>      <td>0.143</td> <td>-0.916</td>  <td>0.359</td>  <td>-0.365</td>    <td>0.104</td> \n",
-       "</tr>\n",
-       "<tr>\n",
-       "  <th>D</th>      <td>0.086</td>      <td>0.143</td>  <td>0.603</td>  <td>0.546</td>  <td>-0.149</td>    <td>0.321</td> \n",
-       "</tr>\n",
-       "</table>\n",
-       "<table class=\"simpletable\">\n",
-       "<caption>CATE Intercept Results</caption>\n",
-       "<tr>\n",
-       "         <td></td>        <th>point_estimate</th> <th>stderr</th>  <th>zstat</th> <th>pvalue</th> <th>ci_lower</th> <th>ci_upper</th>\n",
-       "</tr>\n",
-       "<tr>\n",
-       "  <th>cate_intercept</th>      <td>-1.04</td>      <td>0.146</td> <td>-7.114</td>   <td>0.0</td>    <td>-1.28</td>   <td>-0.799</td> \n",
-       "</tr>\n",
-       "</table><br/><br/><sub>A linear parametric conditional average treatment effect (CATE) model was fitted:<br/>$Y = \\Theta(X)\\cdot T + g(X, W) + \\epsilon$<br/>where $T$ is the one-hot-encoding of the discrete treatment and for every outcome $i$ and treatment $j$ the CATE $\\Theta_{ij}(X)$ has the form:<br/>$\\Theta_{ij}(X) = \\phi(X)' coef_{ij} + cate\\_intercept_{ij}$<br/>where $\\phi(X)$ is the output of the `featurizer` or $X$ if `featurizer`=None. Coefficient Results table portrays the $coef_{ij}$ parameter vector for each outcome $i$ and the designated treatment $j$ passed to summary. Intercept Results table portrays the $cate\\_intercept_{ij}$ parameter.</sub>"
-      ],
-      "text/plain": [
-       "<class 'econml.utilities.Summary'>\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",
-       "                       CATE Intercept Results                       \n",
-       "====================================================================\n",
-       "               point_estimate stderr zstat  pvalue ci_lower ci_upper\n",
-       "--------------------------------------------------------------------\n",
-       "cate_intercept          -1.04  0.146 -7.114    0.0    -1.28   -0.799\n",
-       "--------------------------------------------------------------------\n",
-       "\n",
-       "<sub>A linear parametric conditional average treatment effect (CATE) model was fitted:\n",
-       "$Y = \\Theta(X)\\cdot T + g(X, W) + \\epsilon$\n",
-       "where $T$ is the one-hot-encoding of the discrete treatment and for every outcome $i$ and treatment $j$ the CATE $\\Theta_{ij}(X)$ has the form:\n",
-       "$\\Theta_{ij}(X) = \\phi(X)' coef_{ij} + cate\\_intercept_{ij}$\n",
-       "where $\\phi(X)$ is the output of the `featurizer` or $X$ if `featurizer`=None. Coefficient Results table portrays the $coef_{ij}$ parameter vector for each outcome $i$ and the designated treatment $j$ passed to summary. Intercept Results table portrays the $cate\\_intercept_{ij}$ parameter.</sub>\n",
-       "\"\"\""
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "est.summary(T=1, feature_names=['A', 'B', 'C', 'D'])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Polynomial Features"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<econml.drlearner.LinearDRLearner at 0x27207722e10>"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from econml.sklearn_extensions.linear_model import WeightedLassoCV\n",
-    "from econml.drlearner import LinearDRLearner\n",
-    "from sklearn.linear_model import LogisticRegressionCV\n",
-    "from sklearn.dummy import DummyClassifier\n",
-    "from sklearn.preprocessing import PolynomialFeatures\n",
-    "\n",
-    "# One can replace model_y and model_t with any scikit-learn regressor and classifier correspondingly\n",
-    "# as long as it accepts the sample_weight keyword argument at fit time.\n",
-    "est = LinearDRLearner(model_regression=WeightedLassoCV(cv=3),\n",
-    "                      model_propensity=DummyClassifier(strategy='prior'),\n",
-    "                      featurizer=PolynomialFeatures(degree=2, interaction_only=True, include_bias=False))\n",
-    "est.fit(y, T, X=X[:, :4])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Getting the confidence intervals of the coefficients of the CATE model\n",
-    "# together with the corresponding feature names.\n",
-    "feat_names = est.cate_feature_names(['A', 'B', 'C', 'D'])\n",
-    "point = est.coef_(T=1)\n",
-    "lower, upper = np.array(est.coef__interval(T=1, alpha=0.05))\n",
-    "yerr = np.zeros((2, point.shape[0]))\n",
-    "yerr[0, :] = point - lower\n",
-    "yerr[1, :] = upper - point\n",
-    "\n",
-    "with sns.axes_style(\"darkgrid\"):\n",
-    "    fig, ax = plt.subplots(1,1) \n",
-    "    x = np.arange(len(point))\n",
-    "    plt.errorbar(x, point, yerr, fmt='o')\n",
-    "    ax.set_xticks(x)\n",
-    "    ax.set_xticklabels(feat_names, rotation='vertical', fontsize=18)\n",
-    "    ax.set_ylabel('coef')\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>point_estimate</th>\n",
-       "      <th>stderr</th>\n",
-       "      <th>zstat</th>\n",
-       "      <th>pvalue</th>\n",
-       "      <th>ci_lower</th>\n",
-       "      <th>ci_upper</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>1.192</td>\n",
-       "      <td>0.292</td>\n",
-       "      <td>4.081</td>\n",
-       "      <td>0.000</td>\n",
-       "      <td>0.711</td>\n",
-       "      <td>1.672</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>-1.057</td>\n",
-       "      <td>0.189</td>\n",
-       "      <td>-5.585</td>\n",
-       "      <td>0.000</td>\n",
-       "      <td>-1.368</td>\n",
-       "      <td>-0.746</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>1.065</td>\n",
-       "      <td>0.253</td>\n",
-       "      <td>4.202</td>\n",
-       "      <td>0.000</td>\n",
-       "      <td>0.648</td>\n",
-       "      <td>1.482</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>-1.057</td>\n",
-       "      <td>0.189</td>\n",
-       "      <td>-5.585</td>\n",
-       "      <td>0.000</td>\n",
-       "      <td>-1.368</td>\n",
-       "      <td>-0.746</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>-1.081</td>\n",
-       "      <td>0.177</td>\n",
-       "      <td>-6.095</td>\n",
-       "      <td>0.000</td>\n",
-       "      <td>-1.372</td>\n",
-       "      <td>-0.789</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>5</th>\n",
-       "      <td>0.861</td>\n",
-       "      <td>0.277</td>\n",
-       "      <td>3.107</td>\n",
-       "      <td>0.002</td>\n",
-       "      <td>0.405</td>\n",
-       "      <td>1.318</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>6</th>\n",
-       "      <td>0.926</td>\n",
-       "      <td>0.273</td>\n",
-       "      <td>3.397</td>\n",
-       "      <td>0.001</td>\n",
-       "      <td>0.478</td>\n",
-       "      <td>1.375</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>7</th>\n",
-       "      <td>-0.892</td>\n",
-       "      <td>0.186</td>\n",
-       "      <td>-4.784</td>\n",
-       "      <td>0.000</td>\n",
-       "      <td>-1.199</td>\n",
-       "      <td>-0.585</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>8</th>\n",
-       "      <td>0.926</td>\n",
-       "      <td>0.273</td>\n",
-       "      <td>3.397</td>\n",
-       "      <td>0.001</td>\n",
-       "      <td>0.478</td>\n",
-       "      <td>1.375</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>9</th>\n",
-       "      <td>0.861</td>\n",
-       "      <td>0.277</td>\n",
-       "      <td>3.107</td>\n",
-       "      <td>0.002</td>\n",
-       "      <td>0.405</td>\n",
-       "      <td>1.318</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "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": [
-       "<table class=\"simpletable\">\n",
-       "<caption>Uncertainty of Mean Point Estimate</caption>\n",
-       "<tr>\n",
-       "  <th>mean_point</th> <th>stderr_mean</th> <th>zstat</th> <th>pvalue</th> <th>ci_mean_lower</th> <th>ci_mean_upper</th>\n",
-       "</tr>\n",
-       "<tr>\n",
-       "     <td>0.175</td>      <td>0.243</td>    <td>0.719</td>  <td>0.472</td>    <td>-0.225</td>         <td>0.574</td>    \n",
-       "</tr>\n",
-       "</table>\n",
-       "<table class=\"simpletable\">\n",
-       "<caption>Distribution of Point Estimate</caption>\n",
-       "<tr>\n",
-       "  <th>std_point</th> <th>pct_point_lower</th> <th>pct_point_upper</th>\n",
-       "</tr>\n",
-       "<tr>\n",
-       "    <td>0.982</td>        <td>-1.07</td>           <td>1.135</td>     \n",
-       "</tr>\n",
-       "</table>\n",
-       "<table class=\"simpletable\">\n",
-       "<caption>Total Variance of Point Estimate</caption>\n",
-       "<tr>\n",
-       "  <th>stderr_point</th> <th>ci_point_lower</th> <th>ci_point_upper</th>\n",
-       "</tr>\n",
-       "<tr>\n",
-       "      <td>1.012</td>         <td>-1.25</td>          <td>1.389</td>    \n",
-       "</tr>\n",
-       "</table><br/><br/>Note: The stderr_mean is a conservative upper bound."
-      ],
-      "text/plain": [
-       "<econml.inference.PopulationSummaryResults at 0x272735aa208>"
-      ]
-     },
-     "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": {},
-   "source": [
-    "### Polynomial Features and Debiased Lasso Inference"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<econml.drlearner.SparseLinearDRLearner at 0x2720774d278>"
-      ]
-     },
-     "execution_count": 18,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from econml.sklearn_extensions.linear_model import WeightedLassoCV\n",
-    "from econml.drlearner import SparseLinearDRLearner\n",
-    "from sklearn.linear_model import LogisticRegressionCV\n",
-    "from sklearn.dummy import DummyClassifier\n",
-    "from sklearn.preprocessing import PolynomialFeatures\n",
-    "\n",
-    "# One can replace model_y and model_t with any scikit-learn regressor and classifier correspondingly\n",
-    "# as long as it accepts the sample_weight keyword argument at fit time.\n",
-    "est = SparseLinearDRLearner(model_regression=WeightedLassoCV(cv=3),\n",
-    "                            model_propensity=DummyClassifier(strategy='prior'),\n",
-    "                            featurizer=PolynomialFeatures(degree=3, interaction_only=True, include_bias=False))\n",
-    "est.fit(y, T, X=X[:, :4])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Parameter Intervals"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Getting the confidence intervals of the coefficients of the CATE model\n",
-    "# together with the corresponding feature names.\n",
-    "feat_names = est.cate_feature_names(['A', 'B', 'C', 'D'])\n",
-    "point = est.coef_(T=1)\n",
-    "lower, upper = np.array(est.coef__interval(T=1, alpha=0.05))\n",
-    "yerr = np.zeros((2, point.shape[0]))\n",
-    "yerr[0, :] = point - lower\n",
-    "yerr[1, :] = upper - point\n",
-    "\n",
-    "with sns.axes_style(\"darkgrid\"):\n",
-    "    fig, ax = plt.subplots(1,1) \n",
-    "    x = np.arange(len(point))\n",
-    "    plt.errorbar(x, point, yerr, fmt='o')\n",
-    "    ax.set_xticks(x)\n",
-    "    ax.set_xticklabels(feat_names, rotation='vertical', fontsize=18)\n",
-    "    ax.set_ylabel('coef')\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### CATE(x) intervals"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1440x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import itertools\n",
-    "# Getting the confidence intervals of the CATE at different X vector values\n",
-    "feat_names = np.array(['A', 'B', 'C', 'D'])\n",
-    "lst = list(itertools.product([0, 1], repeat=4))\n",
-    "point = []\n",
-    "lower = []\n",
-    "upper = []\n",
-    "fnames = []\n",
-    "for x in lst:\n",
-    "    x_test = np.array([x])\n",
-    "    fnames.append(\" \".join(np.array(feat_names)[x_test.flatten()>0]))\n",
-    "    point.append(est.effect(x_test)[0])\n",
-    "    lb, ub = est.effect_interval(x_test, alpha=.05)\n",
-    "    lower.append(lb[0])\n",
-    "    upper.append(ub[0])\n",
-    "\n",
-    "fnames = np.array(fnames)\n",
-    "point = np.array(point)\n",
-    "lower = np.array(lower)\n",
-    "upper = np.array(upper)\n",
-    "yerr = np.zeros((2, point.shape[0]))\n",
-    "yerr[0, :] = point - lower\n",
-    "yerr[1, :] = upper - point\n",
-    "\n",
-    "with sns.axes_style('darkgrid'):\n",
-    "    fig, ax = plt.subplots(1,1, figsize=(20, 5)) \n",
-    "    x = np.arange(len(point))\n",
-    "    stat_sig = (lower>0) | (upper<0)\n",
-    "    plt.errorbar(x[stat_sig], point[stat_sig], yerr[:, stat_sig], fmt='o', label='stat_sig')\n",
-    "    plt.errorbar(x[~stat_sig], point[~stat_sig], yerr[:, ~stat_sig], fmt='o', color='red', label='insig')\n",
-    "    ax.set_xticks(x)\n",
-    "    ax.set_xticklabels(fnames, rotation='vertical', fontsize=18)\n",
-    "    ax.set_ylabel('coef')\n",
-    "    plt.legend()\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### CATE(x) inference"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>point_estimate</th>\n",
-       "      <th>stderr</th>\n",
-       "      <th>zstat</th>\n",
-       "      <th>pvalue</th>\n",
-       "      <th>ci_lower</th>\n",
-       "      <th>ci_upper</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>1.198</td>\n",
-       "      <td>0.274</td>\n",
-       "      <td>4.370</td>\n",
-       "      <td>0.000</td>\n",
-       "      <td>0.747</td>\n",
-       "      <td>1.648</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>-1.087</td>\n",
-       "      <td>0.271</td>\n",
-       "      <td>-4.009</td>\n",
-       "      <td>0.000</td>\n",
-       "      <td>-1.533</td>\n",
-       "      <td>-0.641</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>1.129</td>\n",
-       "      <td>0.280</td>\n",
-       "      <td>4.033</td>\n",
-       "      <td>0.000</td>\n",
-       "      <td>0.669</td>\n",
-       "      <td>1.590</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>-1.087</td>\n",
-       "      <td>0.271</td>\n",
-       "      <td>-4.009</td>\n",
-       "      <td>0.000</td>\n",
-       "      <td>-1.533</td>\n",
-       "      <td>-0.641</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>-1.095</td>\n",
-       "      <td>0.269</td>\n",
-       "      <td>-4.065</td>\n",
-       "      <td>0.000</td>\n",
-       "      <td>-1.537</td>\n",
-       "      <td>-0.652</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>5</th>\n",
-       "      <td>0.725</td>\n",
-       "      <td>0.291</td>\n",
-       "      <td>2.491</td>\n",
-       "      <td>0.013</td>\n",
-       "      <td>0.246</td>\n",
-       "      <td>1.204</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>6</th>\n",
-       "      <td>0.882</td>\n",
-       "      <td>0.272</td>\n",
-       "      <td>3.239</td>\n",
-       "      <td>0.001</td>\n",
-       "      <td>0.434</td>\n",
-       "      <td>1.330</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>7</th>\n",
-       "      <td>-0.803</td>\n",
-       "      <td>0.273</td>\n",
-       "      <td>-2.941</td>\n",
-       "      <td>0.003</td>\n",
-       "      <td>-1.251</td>\n",
-       "      <td>-0.354</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>8</th>\n",
-       "      <td>0.882</td>\n",
-       "      <td>0.272</td>\n",
-       "      <td>3.239</td>\n",
-       "      <td>0.001</td>\n",
-       "      <td>0.434</td>\n",
-       "      <td>1.330</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>9</th>\n",
-       "      <td>0.725</td>\n",
-       "      <td>0.291</td>\n",
-       "      <td>2.491</td>\n",
-       "      <td>0.013</td>\n",
-       "      <td>0.246</td>\n",
-       "      <td>1.204</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "   point_estimate  stderr  zstat  pvalue  ci_lower  ci_upper\n",
-       "0           1.198   0.274  4.370   0.000     0.747     1.648\n",
-       "1          -1.087   0.271 -4.009   0.000    -1.533    -0.641\n",
-       "2           1.129   0.280  4.033   0.000     0.669     1.590\n",
-       "3          -1.087   0.271 -4.009   0.000    -1.533    -0.641\n",
-       "4          -1.095   0.269 -4.065   0.000    -1.537    -0.652\n",
-       "5           0.725   0.291  2.491   0.013     0.246     1.204\n",
-       "6           0.882   0.272  3.239   0.001     0.434     1.330\n",
-       "7          -0.803   0.273 -2.941   0.003    -1.251    -0.354\n",
-       "8           0.882   0.272  3.239   0.001     0.434     1.330\n",
-       "9           0.725   0.291  2.491   0.013     0.246     1.204"
-      ]
-     },
-     "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": [
-       "<table class=\"simpletable\">\n",
-       "<caption>Uncertainty of Mean Point Estimate</caption>\n",
-       "<tr>\n",
-       "  <th>mean_point</th> <th>stderr_mean</th> <th>zstat</th> <th>pvalue</th> <th>ci_mean_lower</th> <th>ci_mean_upper</th>\n",
-       "</tr>\n",
-       "<tr>\n",
-       "     <td>0.147</td>      <td>0.277</td>    <td>0.531</td>  <td>0.595</td>    <td>-0.308</td>         <td>0.602</td>    \n",
-       "</tr>\n",
-       "</table>\n",
-       "<table class=\"simpletable\">\n",
-       "<caption>Distribution of Point Estimate</caption>\n",
-       "<tr>\n",
-       "  <th>std_point</th> <th>pct_point_lower</th> <th>pct_point_upper</th>\n",
-       "</tr>\n",
-       "<tr>\n",
-       "    <td>0.965</td>       <td>-1.091</td>           <td>1.167</td>     \n",
-       "</tr>\n",
-       "</table>\n",
-       "<table class=\"simpletable\">\n",
-       "<caption>Total Variance of Point Estimate</caption>\n",
-       "<tr>\n",
-       "  <th>stderr_point</th> <th>ci_point_lower</th> <th>ci_point_upper</th>\n",
-       "</tr>\n",
-       "<tr>\n",
-       "      <td>1.004</td>        <td>-1.359</td>          <td>1.388</td>    \n",
-       "</tr>\n",
-       "</table><br/><br/>Note: The stderr_mean is a conservative upper bound."
-      ],
-      "text/plain": [
-       "<econml.inference.PopulationSummaryResults at 0x27207bfdb00>"
-      ]
-     },
-     "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": {},
-   "source": [
-    "# Non-Linear Models with Forest CATEs"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<econml.drlearner.ForestDRLearner at 0x1db5f107748>"
-      ]
-     },
-     "execution_count": 23,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from econml.drlearner import ForestDRLearner\n",
-    "from sklearn.ensemble import GradientBoostingRegressor\n",
-    "\n",
-    "est = ForestDRLearner(model_regression=GradientBoostingRegressor(),\n",
-    "                      model_propensity=DummyClassifier(strategy='prior'),\n",
-    "                      cv=5,\n",
-    "                      n_estimators=4000,\n",
-    "                      min_samples_leaf=10,\n",
-    "                      verbose=0, min_weight_fraction_leaf=.01)\n",
-    "est.fit(y, T, X=X[:, :4])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([0.97557292, 0.00818908, 0.00800918, 0.00822882])"
-      ]
-     },
-     "execution_count": 24,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "est.feature_importances_(T=1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 576x223.2 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import shap\n",
-    "import pandas as pd\n",
-    "# explain the model's predictions using SHAP values\n",
-    "shap_values = est.shap_values(X[:100, :4], feature_names=['A', 'B', 'C', 'D'], background_samples=100)\n",
-    "shap.summary_plot(shap_values['Y0']['T0'])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### CATE(x) intervals"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1440x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import itertools\n",
-    "# Getting the confidence intervals of the CATE at different X vector values\n",
-    "feat_names = np.array(['A', 'B', 'C', 'D'])\n",
-    "lst = list(itertools.product([0, 1], repeat=4))\n",
-    "point = []\n",
-    "lower = []\n",
-    "upper = []\n",
-    "fnames = []\n",
-    "for x in lst:\n",
-    "    x_test = np.array([x])\n",
-    "    fnames.append(\" \".join(np.array(feat_names)[x_test.flatten()>0]))\n",
-    "    point.append(est.effect(x_test)[0])\n",
-    "    lb, ub = est.effect_interval(x_test, alpha=.05)\n",
-    "    lower.append(lb[0])\n",
-    "    upper.append(ub[0])\n",
-    "\n",
-    "fnames = np.array(fnames)\n",
-    "point = np.array(point)\n",
-    "lower = np.array(lower)\n",
-    "upper = np.array(upper)\n",
-    "yerr = np.zeros((2, point.shape[0]))\n",
-    "yerr[0, :] = point - lower\n",
-    "yerr[1, :] = upper - point\n",
-    "\n",
-    "with sns.axes_style('darkgrid'):\n",
-    "    fig, ax = plt.subplots(1,1, figsize=(20, 5)) \n",
-    "    x = np.arange(len(point))\n",
-    "    stat_sig = (lower>0) | (upper<0)\n",
-    "    plt.errorbar(x[stat_sig], point[stat_sig], yerr[:, stat_sig], fmt='o', label='stat_sig')\n",
-    "    plt.errorbar(x[~stat_sig], point[~stat_sig], yerr[:, ~stat_sig], fmt='o', color='red', label='insig')\n",
-    "    ax.set_xticks(x)\n",
-    "    ax.set_xticklabels(fnames, rotation='vertical', fontsize=18)\n",
-    "    ax.set_ylabel('coef')\n",
-    "    plt.legend()\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### CATE(x) inference"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>point_estimate</th>\n",
-       "      <th>stderr</th>\n",
-       "      <th>zstat</th>\n",
-       "      <th>pvalue</th>\n",
-       "      <th>ci_lower</th>\n",
-       "      <th>ci_upper</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>1.191</td>\n",
-       "      <td>0.361</td>\n",
-       "      <td>3.296</td>\n",
-       "      <td>0.001</td>\n",
-       "      <td>0.597</td>\n",
-       "      <td>1.785</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>-1.139</td>\n",
-       "      <td>0.192</td>\n",
-       "      <td>-5.928</td>\n",
-       "      <td>0.000</td>\n",
-       "      <td>-1.455</td>\n",
-       "      <td>-0.823</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>1.411</td>\n",
-       "      <td>0.304</td>\n",
-       "      <td>4.637</td>\n",
-       "      <td>0.000</td>\n",
-       "      <td>0.910</td>\n",
-       "      <td>1.911</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>-1.139</td>\n",
-       "      <td>0.192</td>\n",
-       "      <td>-5.928</td>\n",
-       "      <td>0.000</td>\n",
-       "      <td>-1.455</td>\n",
-       "      <td>-0.823</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>-1.170</td>\n",
-       "      <td>0.184</td>\n",
-       "      <td>-6.365</td>\n",
-       "      <td>0.000</td>\n",
-       "      <td>-1.472</td>\n",
-       "      <td>-0.868</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>5</th>\n",
-       "      <td>1.082</td>\n",
-       "      <td>0.341</td>\n",
-       "      <td>3.173</td>\n",
-       "      <td>0.002</td>\n",
-       "      <td>0.521</td>\n",
-       "      <td>1.644</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>6</th>\n",
-       "      <td>0.922</td>\n",
-       "      <td>0.340</td>\n",
-       "      <td>2.713</td>\n",
-       "      <td>0.007</td>\n",
-       "      <td>0.363</td>\n",
-       "      <td>1.481</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>7</th>\n",
-       "      <td>-0.906</td>\n",
-       "      <td>0.202</td>\n",
-       "      <td>-4.484</td>\n",
-       "      <td>0.000</td>\n",
-       "      <td>-1.239</td>\n",
-       "      <td>-0.574</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>8</th>\n",
-       "      <td>0.922</td>\n",
-       "      <td>0.340</td>\n",
-       "      <td>2.713</td>\n",
-       "      <td>0.007</td>\n",
-       "      <td>0.363</td>\n",
-       "      <td>1.481</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>9</th>\n",
-       "      <td>1.082</td>\n",
-       "      <td>0.341</td>\n",
-       "      <td>3.173</td>\n",
-       "      <td>0.002</td>\n",
-       "      <td>0.521</td>\n",
-       "      <td>1.644</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "   point_estimate  stderr  zstat  pvalue  ci_lower  ci_upper\n",
-       "0           1.191   0.361  3.296   0.001     0.597     1.785\n",
-       "1          -1.139   0.192 -5.928   0.000    -1.455    -0.823\n",
-       "2           1.411   0.304  4.637   0.000     0.910     1.911\n",
-       "3          -1.139   0.192 -5.928   0.000    -1.455    -0.823\n",
-       "4          -1.170   0.184 -6.365   0.000    -1.472    -0.868\n",
-       "5           1.082   0.341  3.173   0.002     0.521     1.644\n",
-       "6           0.922   0.340  2.713   0.007     0.363     1.481\n",
-       "7          -0.906   0.202 -4.484   0.000    -1.239    -0.574\n",
-       "8           0.922   0.340  2.713   0.007     0.363     1.481\n",
-       "9           1.082   0.341  3.173   0.002     0.521     1.644"
-      ]
-     },
-     "execution_count": 26,
-     "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": 27,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table class=\"simpletable\">\n",
-       "<caption>Uncertainty of Mean Point Estimate</caption>\n",
-       "<tr>\n",
-       "  <th>mean_point</th> <th>stderr_mean</th> <th>zstat</th> <th>pvalue</th> <th>ci_mean_lower</th> <th>ci_mean_upper</th>\n",
-       "</tr>\n",
-       "<tr>\n",
-       "     <td>0.226</td>      <td>0.289</td>    <td>0.781</td>  <td>0.435</td>     <td>-0.25</td>         <td>0.701</td>    \n",
-       "</tr>\n",
-       "</table>\n",
-       "<table class=\"simpletable\">\n",
-       "<caption>Distribution of Point Estimate</caption>\n",
-       "<tr>\n",
-       "  <th>std_point</th> <th>pct_point_lower</th> <th>pct_point_upper</th>\n",
-       "</tr>\n",
-       "<tr>\n",
-       "    <td>1.083</td>       <td>-1.156</td>           <td>1.312</td>     \n",
-       "</tr>\n",
-       "</table>\n",
-       "<table class=\"simpletable\">\n",
-       "<caption>Total Variance of Point Estimate</caption>\n",
-       "<tr>\n",
-       "  <th>stderr_point</th> <th>ci_point_lower</th> <th>ci_point_upper</th>\n",
-       "</tr>\n",
-       "<tr>\n",
-       "      <td>1.121</td>        <td>-1.337</td>          <td>1.629</td>    \n",
-       "</tr>\n",
-       "</table><br/><br/>Note: The stderr_mean is a conservative upper bound."
-      ],
-      "text/plain": [
-       "<econml.inference.PopulationSummaryResults at 0x177e08252b0>"
-      ]
-     },
-     "execution_count": 27,
-     "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": {},
-   "source": [
-    "# Tree Interpretation of the CATE Model"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from econml.cate_interpreter import SingleTreeCateInterpreter"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<econml.cate_interpreter.SingleTreeCateInterpreter at 0x177e088db70>"
-      ]
-     },
-     "execution_count": 29,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "intrp = SingleTreeCateInterpreter(include_model_uncertainty=True, max_depth=2, min_samples_leaf=10)\n",
-    "# We interpret the CATE models behavior on the distribution of heterogeneity features\n",
-    "intrp.interpret(est, X[:, :4])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# exporting to a dot file\n",
-    "intrp.export_graphviz(out_file='cate_tree.dot', feature_names=['A', 'B', 'C', 'D'])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# or we can directly render. Requires the graphviz python library\n",
-    "intrp.render(out_file='dr_cate_tree', format='pdf', view=True, feature_names=['A', 'B', 'C', 'D'])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Matplotlib is currently using agg, which is a non-GUI backend, so cannot show the figure.\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAABYEAAAEeCAYAAADcsNowAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAADyLUlEQVR4nOzdd3wVVf7G8c+5Lb2HEEI6EErovVdRbKhYAHvdtZefbnFd6+66rrrqqthWXQHFjlgQUJr03ntvoSUhIb3P748bb4wkSAlcCM97X/Pa3Jkzc78Tw2TukzPnGMuyEBEREREREREREZH6yebtAkRERERERERERETk1FEILCIiIiIiIiIiIlKPKQQWERERERERERERqccUAouIiIiIiIiIiIjUYwqBRUREREREREREROoxhcAiIiIiIiIiIiIi9ZhCYBEREREREREREZF6TCGwiIiIiIiIiIiISD2mEFhERERERERERESkHlMILCIiIiIiIiIiIlKPObxdgIiIiIicGYwxgUBXIMDbtchJKwM2WZa11duFiIiIiIj3GcuyvF2DiIiIiHiRMcYEBga+WFpaek/z5s2LwsLCMMZ4uyw5CSWlJaxZs8ZlWdbW3JzcIZZlpXm7JhERERHxHvUEFhERETnHORyOO+Pi4u6cOn2qT1RUlI+365G6UV5ezr+e+1eLF55/YYYxprml3h8iIiIi5yz1BBYRERE5x4WHh6/9aNxHrQafP9jbpUgdsyyLxo0a56enp/e0LGuVt+sREREREe/QxHAiIiIi57j8/PwmXbp28XYZcgoYY+jarWs50MrbtYiIiIiI9ygEFhERETnHVVRU2Fwul7fLkFPEx8fHBji9XYeIiIiIeI9CYBERERE5owwaOIgGEQ0oLi72ah2HDh3iqmFXERIUQpOkJnw87uNa247+YDQ+Th9Cg0M9y08zfzqN1YqIiIiI1E4hsIiIiIicMXbs2MGc2XMwxvDtN9+e8HEOHDhw0rXcf+/9uFwu0valMXrsaO69517Wrl1ba/vuPbqTnZPtWfr173fSNYiIiIiI1AWFwCIiIiJyxvhw7Id0696NG2+6kbFjxh7XvgUFBXz04UcMPm8wgwed3CR3+fn5jB8/nqeeeYrAwEB69+7NJZdewkcffnRSxxURERER8QaFwCIiIiJyxvhw7IeMvHYkI68dyQ8//HBMPXrnz5/Pnb+/k4S4BMaOGcvNN9/MwsULPdvvvedeIsMja1w6tO9Q4zE3bdqE3W4nJSXFs65du3asW7uu1jpWLF9BdFQ0rVq04h9//wdlZWXHceYiIiIiIqeOw9sFiIiIiIgAzJkzh507d3L11VcTGRlJkyZN+Pjjj3nwwQdrbP/5Z5/z9FNPY1kWN9x4A8tWLCMuLu6Idq+Pep3XR71+XLXk5+UTEhJSbV1wcDC5ebk1tu/Ttw8rVq0gISGBtWvXct3I63A4HPzpz386rvcVERERETkV1BNYRERERM4IY8eMZfDgwURGRgIwYuSIow4JsSdtD3v27KFt27a0bduWRo0a1VktAYEB5OTkVFuXm5tLUGBQje2Tk5NJSkrCZrPRpk0bHvvrY3z55Zd1Vo+IiIiIyMlQCCwiIiIiXldYWMgXn3/BrFmziI2JJTYmlv+88h9WrVzFypUra9znoYceYteeXQw6bxD//Oc/SYxP5OH/e5jly5dXa3f3XXcTGhxa49KuTbsaj52SkkJZWRmbN2/2rFu5ciWtUlsd0/kYY7As6xjPXkRERETk1FIILCIiIiJe9/WEr7Hb7axas4oly5awZNkSVq9dTe8+vflw7Ie17hccHMztd9zO7DmzmTZjGr6+vlxx2RWcP/h8T5s33nyD7JzsGpeVq2sOmAMCArjiiit4+smnyc/PZ+7cuXz7zbdcd/11NbafPGmyZ/ziDRs28Ow/nmXo0KEn8R0REREREak7CoFFRERExOvGjhnLTTffRHx8PNHR0Z7l7rvv5uNxHx/TJGvNmzfnH8/+g207tvH0M0+fdE2vjXqNwsJCYqJjuOG6G3h91OukpqYCsGvXLkKDQ9m1axcA06dPp2P7joQEhTD0kqFcfsXl/PnRP590DSIiIiIidcHoMTURERGRc5vT6SzJzMp0+vv7e7sUOQWGXzM8b/yX4++2LKv2AZZFREREpF5TT2ARERERERERERGRekwhsIiIiIiIiIiIiEg9phBYREREREREREREpB5TCCwiIiIiIiIiIiJSjykEFhEREZGzzq233MoTjz/h7TJERERERM4KCoFFRERERE7CH//wR1o2b0lYSBitW7Vm7Jix1bavWLGCrl26EhwYTNcuXVmxYkW17a+88gqxMbFEhEVw+223U1xc7Nl26NAhrhp2FSFBITRJasLH4z4+HackIiIiIvWMQmARERERkZMQEBDAV19/RWZWJu/97z3+76H/Y968eQCUlJRw5RVXcu1115Kemc4NN97AlVdcSUlJCQA/TPmBF/71AlN+nMKWbVvYvn07Tz/1tOfY9997Py6Xi7R9aYweO5p777mXtWvXeuU8RUREROTspRBYRERERI7LC8+/QEJcAmEhYaS2TGX6tOkALFq0iN69ehMZHklc4zjuv+9+T9gJ4LQ7efPNNz29Zp984km2bt1K7169CQ8NZ+TwkZ72P838icT4RJ7753NER0XTNLkp4z4aV2tNE7+bSKeOnYgMj6RP7z6sWrXqN+utK08+9SQtWrTAZrPRrVs3evfuzcIFCz3nUVZWxgMPPICPjw/33XcflmUxY/oMAMaOGcstt95CamoqYWFhPPbYY4wZPQaA/Px8xo8fz1PPPEVgYCC9e/fmkksv4aMPP6rT+kVERESk/lMILCIiIiLHbOPGjbwx6g3mL5xP1uEsJk6aSEJiAgB2u50X//0i+w/uZ/bc2cyYPoM333yz2v4/TP6BhYsXMmfeHF584UXuuvMuxowdw/ad21m7di2ffPyJp+3+/fvJyMhg5+6dvP+/97nrzrvYuHHjETUtW7aMO26/gzfefIMD6Qe44447GHb5MIqLi49a7689/6/niQyPrHU5FoWFhSxZsoRWrVoBsHbdWtq0aYMxxtOmTZs2rFu3zrO9bdu2nm1t27XlwIEDZGZmsmnTJux2OykpKZ7t7dq1Y93adcdUi4iIiIjIzxQCi4iIiMgxs9vtFBcXs37dekpLS0lMTKRJkyYAdOrUie7du+NwOEhMTOT2393O7J9mV9v/kT8+QnBwMKmpqaS2TmXw4MEkJycTEhLCBUMuOGK83KefeRofHx/69uvLRRddxBeff3FETe+9+x53/O4OunXrht1u58abbsTHx4eFCxYetd5f++Of/kjGoYxal2Nx911307ZtW86/4HwA8vPyCQkJqdYmOCSY3NzcGrf//HVubm7N+wYHk5uXe0y1iIiIiIj8TCGwiIiIiByzpk2b8u+X/s0zzzxDTHQM1428jr179wKwadMmLrv0MmJjYgkPDefxxx4nI7N6eNqwYUPP135+fkRFRVV7nZeX53kdFhZGQECA53V8QrznvX5p185dvPzSy9V67e7evZu9e/cetd669qc//om1a9fy8acfe3r+BgQGkJOTU61dbk4uQUFBNW7/+eugoKCa983NJSgw6JTULyIiIiL1l0JgERERETkuI68dyU+zfmLr9q0YY3j0z48CcO8999K8RXPWb1zPoexD/O0ff8OyrBN+n6ysLPLz8z2vd+/aTUxMzBHtYuNiefQvj1brtZuTl8OIkSOOWu+vPffP5wgNDq11OZqnn3qaKZOnMGnyJIKDgz3rU1ulsnr16mrfh9WrV3uGi0htlVpt/OJVK1fRsGFDIiIiSElJoaysjM2bN3u2r1y5klaprY5ai4iIiIjIrykEFhEREZFjtnHjRmZMn0FxcTG+vr74+vlit9sBdy/V4OBgAgMD2bBhA++89c5Jv9/TTz1NSUkJc2bPYeLEiVx51ZVHtLnt9tt45+13WLhwIZZlkZ+fz/cTvyc3N/eo9f7anx/9M9k52bUutfnXc//ik48/YdKUSURERFTb1q9/P+x2O6+99hrFxcWMGjUKgAEDBwBw/Q3X87/3/8e6devIysri2Wef5cabbgQgICCAK664gqeffJr8/Hzmzp3Lt998y3XXX3ci30oREREROYcpBBYRERGRY1ZcXMxf/vIXoqOiiY2JJf1gOn//x98BeP755/nk408ICwnjzt/fydXXXH1S7xUdHU1YWBjxsfHceMONjHpjFC1atDiiXefOnXnr7bd44P4HaBDRgBYpLRgzesxv1ltX/vrYX9m1axctm7f09Bp+7p/PAeByufhi/Bd8OPZDIsMj+eB/H/DF+C9wuVwAXDDkAh7+w8MMHjSYJklNiI+P58mnnvQc+7VRr1FYWEhMdAw3XHcDr496ndTU1DqtX0RERETqP3Myj+iJiIiIyNnP6XSWZGZlOv39/b1disdPM3/iphtvYseuHd4u5aw3/JrheeO/HH+3ZVljvV2LiIiIiHiHegKLiIiIiIiIiIiI1GMKgUVERERERERERETqMYXAIiIiInLG6de/n4aCEBERERGpIwqBRUREREREREREROoxhcAiIiIiIiIiIiIi9ZhCYBERERGp0cfjPqZb126EBocS1ziOSy66hDlz5lRrM/qD0TjtTj7/7HMA5syeQ2hwKKHBoYQEheC0Oz2vQ4ND2bVrF4MGDiLQP7Da+suHXu6FM/SOj8d9TJOkJoQEhXDlFVdy6NChWtvu2LGD8wadR3BgMK1btWba1GmebTNnzKR9u/ZEhkfSsEFDrhp2FWlpaafjFERERETkLKMQWERERESO8PLLL/Pw/z3Mn//8Z9L2pbFtxzbuvOtOvv3m22rtxo4dS3h4OGPHjAWgd5/eZOdkk52TzcrVKwHIOJThWRcfHw/Af179j2dddk42E76ZcFrPz1vWrl3L3XfdzQejPyBtXxr+/v7cd899tba//rrrad++PQfSD/DM355h+DXDSU9PB6Blq5Z8P+l7Mg5lsGvPLpo2a8q9d997uk5FRERERM4iCoFFREREpJrDhw/z9JNP8+prr3LFsCsICAjA6XRyyaWX8K/n/+Vpt3PnTmb9NIs333qTH374gQMHDtR5LaM/GE3fPn15+P8eJjI8kpSmKcybN4/RH4wmKSGJmOgYxowe42lfXFzMH//wR5ITk2ncqDF333U3hYWFAGRlZXHZpZfRqGEjGkQ04LJLL2PPnj2efQcNHMSTTzxJ3z59CQsJ48ILLiQjI6NOz+fjcR9zySWX0KdvHwIDA3nqmaf46quvyM3NPaLtpk2bWL5sOU8+9SR+fn4Mu3IYrdu0ZvyX4wFo2LAhMTExnvZ2u52tW7fWab0iIiIiUj8oBBYRERGRahbMX0BRURGXX3H5Udt9OPZDOnXuxLArh9GiZQvGjRt3SupZtHARbdq04UD6AUaMHMH1117PkiVL2LBpA6PHjOaB+x8gLy8PgEf//CibN21myTL39r1pe/n73/4OQEVFBTfdfBNbt29l245t+Pn58cB9D1R7r08+/oR333uXvfv3UlJawkv/fqnGmnbt2kVkeGSty8fjPq5xv3Vr19G2XVvP6yZNmuByudi0aVONbZOTkwkKCvKsa9u2LevWrTuijqCAIF7690s8/MjDx/hdFREREZFziUJgEREREakmMzOTyMhIHA7HUdt9OPZDRowcAcDIkSM9Q0Ici4cefKhaaPrkE0/W2jYpKYmbb7kZu93O1ddcze7du/nr43/Fx8eHwecPxuVysWXLFizL4r133+PFl14kPDycoKAg/vTon/js088AiIiIYNiVw/D39ycoKIg//+XPzJo1q9p73XTzTaSkpODn58dVV1/FyhUra6wpPj6ejEMZtS4jrx1Z4355+XkEBwdXWxcSEkJebt6RbfPyCA45su0vew3/XMf+g/t55m/P0LxF81q/jyIiIiJy7jr6nb2IiIiInHMiIiLIyMigrKys1iB47ty5bN++neHDhwMwYuQIHv/r46xYsYL27dv/5nu8/MrL3Hb7bcdUT1TDKM/Xfn5+gHsohF+uy8vLIz09nYKCArp16ebZZlkW5eXlABQUFPDw/z3MD1N+ICsrC4Dc3FzKy8ux2+1HHNffz5+8/CPD2ZMRGBB4xNAPOTk5BAYFHtk2MJDcnCPb/rJn8M/Cw8O54cYb6NShEzt37/zNAF9EREREzi3qCSwiIiIi1XTv0R1fX1++nvB1rW3GjhmLZVl07tiZ2JhYevXoBbh7B3tLZGQkfn5+rFy90tMjNzMrk+ycbABefullNm3axNz5czmUfYjpM6cD7qD4eO3atYvQ4NBal3Ef1Tw0RqvUVqxcWdW7eNu2bRQXF5OSklJj223btlULjVetWkWrVq1qPHZZWRkHDx4kJyfnuM9HREREROo3hcAiIiIiUk1ISAhPPv0k9993P19P+JqCggJKS0uZPGkyf/7TnykqKuKLz7/gzbfeZMmyJZ7llVdf4eNxH1NWVuaVum02G7fdfhuP/N8jHDx4EIC0tDR+mPID4O716+frR2hoKIcOHeLvz/z9hN8rPj6e7JzsWpdrr7u2xv1GXjuSid9NZM7sOeTn5/PUk09xxRVX1Ni7NyUlhXbt2/G3Z/5GUVERE76awOpVqxl25TAAvhr/FRs3bqSiooL09HT+8PAfaN+hPeHh4Sd8XiIiIiJSPykEFhEREZEjPPTQQ7zw4gs8++yzNGrYiKSEJN4Y9QZDLxvK1xO+xs/PjxtuvIHo6GjPcuutt1JeXs6UyVN+8/gP3P9AtZ6zXbt0rZO6//ncP2nStAm9e/YmPDScIecPYeOmjQDc/8D9FBYVEh0VTe+evTn/gvPr5D2PR2pqKqPeGMWNN9xITHQMebl5vDbqNc/2u++6m7vvutvz+qNxH7F06VIaRDTgsb88xqeffUqDBg0ASNubxiUXXUJYSBgd2nXAZrPxxZdfnPZzEhEREZEznzmRx99EREREpP5wOp0lmVmZTn9/f2+XIqfA8GuG543/cvzdlmUd+8x9IiIiIlKvqCewiIiIiIiIiIiISD2mEFhERERERERERESkHlMILCIiIiIiIiIiIlKPKQQWERERERERERERqccUAouIiIjIOcNpd7JlyxZvlyEiIiIiclopBBYRERGRY/LxuI/p1rUbocGhxDWO45KLLmHOnDnV2oz+YDROu5PPP/scgDmz5xAaHEpocCghQSE47U7P69DgUHbt2sWggYMI9A+stv7yoZcfd33eCnhHjRpFt67dCPAL4NZbbv3N9q+88gqxMbFEhEVw+223U1xc7Nm2fv16Bp83mIiwCFqktGDCVxOq7fveu+/RIqUFocGhXHzhxezdu7euT0dERERE6iGFwCIiIiLym15++WUe/r+H+fOf/0zavjS27djGnXfdybfffFut3dixYwkPD2fsmLEA9O7Tm+ycbLJzslm5eiUAGYcyPOvi4+MB+M+r//Gsy87JZsI3E07r+Z2MmEYx/OUvf+HmW27+zbY/TPmBF/71AlN+nMKWbVvYvn07Tz/1NABlZWVcecWVXHTxRRzMOMibb73JTTfexKZNmwCY9dMsHv/r43z51ZcczDhIYlIi1193/ak8NRERERGpJxQCi4iIiMhRHT58mKeffJpXX3uVK4ZdQUBAAE6nk0suvYR/Pf8vT7udO3cy66dZvPnWm/zwww8cOHCgzmvZsmULAwcMJCIsguioaK4dcS0AA/oPAKBTh06EBofy2aefAfDvF/9NXOM44mPj+d/7/6vzegCuGHYFl11+GREREb/ZduyYsdxy6y2kpqYSFhbGY489xpjRYwDYsGEDe/fu5cEHH8RutzNg4AB69uzJRx9+BMB3333HlVddSWpqKi6Xi8f++hizZ81m69atp+S8RERERKT+UAgsIiIiIke1YP4CioqKuPyKy4/a7sOxH9KpcyeGXTmMFi1bMG7cuDqv5aknnmLw4MGkZ6azY9cO7r73bgBmzJwBwNLlS8nOyeaa4dcwZfIUXvr3S0yaMon1G9czfdr0ox773nvuJTI8ssalQ/sOdVL/2nVradu2red123ZtOXDgAJmZmViWdUR7y7JYu2at5+tftvn565+3i4iIiIjURiGwiIiIiBxVZmYmkZGROByOo7b7cOyHjBg5AoCRI0d6hoQ4Fg89+FC10PXJJ56ssZ3D6WDnzp3s3bsXX19fevfuXesxP//8c266+SZat25NQEAAjz/5+FFreH3U62QcyqhxWb5i+TGfy9Hk5+UTEhLief3z17m5ubRo0YKoqCj+/eK/KS0t5ccffmTWrFkUFBQAcOGFF/LF51+watUqCgsL+fvf/o4xxrNdRERERKQ2CoFFREREzlHGmHBjzDDAfrR2ERERZGRkUFZWVmubuXPnsn37doYPHw7AiJEjWLN6DStWrDimWl5+5eVqoevTzzxdY7vn/vUclmXRs3tP2rVpd9QhHvbt3UdsXKzndUJCwjHVcioFBAaQk5Pjef3z10FBQTidTr4Y/wXff/89sTGxvPzSy1x19VU0jm0MwMBBA3niqScYfvVwmiQ1ITExkaCgIGJjY2t8r5+Vl5f7AucZY1oZY8wpOzkREREROWMpBBYRERE5RxhjAo0xQ4wxLxhjlgI7gDt+a7/uPbrj6+vL1xO+rrXN2DFjsSyLzh07ExsTS68evQB37+C6FB0dzdvvvM2uPbsY9eYo7rv3PrZs2VJz20bR7Nm9x/N6165dRz323XfdTWhwaI1Luzbt6qT+1FaprFq1yvN61cpVNGzY0DOecNu2bZk+YzoH0g/w/eTv2b59O126dKmq8e67Wb9xPXv37+WKYVdQVlZGauvUo76nzdjKgARgIrDXGPORMeZWY0xinZyUiIiIiJzxFAKLiIiI1FPGGB9jTF9jzNPGmNnAfuBRIBd4AIi0LOtCoPxoxwkJCeHJp5/k/vvu5+sJX1NQUEBpaSmTJ03mz3/6M0VFRXzx+Re8+dabLFm2xLO88uorfDzu46P2ID5eX3z+BXv2uIPdsLAwjDHY7e6OzA0bNmT7tu2etldffTVjRo9h3bp1FBQU8Ldn/nbUY7/x5htk52TXuKxcvbLW/crKyigqKqK8vJzy8nKKiopqPefrb7ie/73/P9atW0dWVhbPPvssN950o2f7qlWrKCoqoqCggJf+/RL79+3npptvAqCoqIg1a9ZgWRa7du3irjvv4r777yMsLOyo52Vspgx4z7KsJKAnMAM4D1hgjNlqjPmvMWaEMabhUQ8kIiIiImcthcAiIiIi9YQxxm6M6WyM+ZMxZgqQAfwb8AH+BkRZltXPsqxnLMuaY1lWybEe+6GHHuKFF1/g2WefpVHDRiQlJPHGqDcYetlQvp7wNX5+ftxw4w1ER0d7lltvvZXy8nKmTJ7ym8d/4P4HqvW87dqla43tlixZQq8evQgNDmXY5cN46eWXSEpKAuDxJx7n1ltuJTI8ks8/+5whFw7h/gfu5/zzzqdFSgsGDBhwrKd7XJ79x7MEBQTx/L+eZ9xH4wgKCOLZfzwLuHsfhwaHenohXzDkAh7+w8MMHjSYJklNiI+P58mnqsY//ujDj4hrHEdMdAzTp01n0pRJ+Pj4AO4Q+IbrbyA0OJSe3XvSvXv3WofNqI1lWdsty3rXsqxrgUbAUGA1MALYYIxZbYz5jzFmqDEm5KgHExEREZGzhqlpFmIREREROfNVju/aEhgEDAT6AfuAacB04CfLsrJ+6zhOp7MkMyvT6e/vfyrLFS8Zfs3wvPFfjr/bsqyjztRnjHEAHaj6eeoBrMP9szQNmGtZVuGprldERERE6t7Rp3gWERERkTNK5TiuP4d0A4Ei3AHd58BdlmXt9151cjazLKsMWFy5PGeM8QG64/55ewpoZ4xZQlUovNiyrFIvlSsiIiIix0EhsIiIiMgZrHKc1p8D30GAP+4QbjrwV8uyth9ld5ETZllWMfBT5fKEMSYI6I375/B1oIkxZg5VofAqy7IqvFWviIiIiNROIbCIiIjIGcQYEwr0xR20DQIa4w7hpgOvAOssjeclXmBZVi4wqXLBGBMB9Mf9c3oHEGmMmUFVKLxZP6siIiIiZwaFwCIiIiJeZIzxB3pSNcRDK2A+7iDtFmB55WP6ImcUy7IygS8rF4wxscAA3D/Lf6lc93Ov9WmWZe3xUqkiIiIi5zyFwCIiIiKnkTHGCXShqqdvZ2AF7qDsj8CCysfwRc4qlSHvWGBs5aSFTXH/YeNi4EVjTBZVkxbOsCwrw2vFioiIiJxjFAKLiIiInELGGBvQjqpxfXsDW3EHYf8C5lQ+Zi9Sb1QOA7G5cnm78t9BG9z/Bm4C3jXGbKcqFJ6lfwciIiIip45CYBEREZE6VNkDshlVPX37A5m4w673gRsrH6MXOWdUThi3snJ5ubJHfGfcofDDwCfGmNVUhcLzLcsq8la9IiIiIvWNQmARERGRk2SMiaOqp+8gwMIdZn0NPKixUEWqsyyrFPfY1/OBfxhj/HCPjT0Q+CeQaoxZSFUovFRjY4uIiIicOIXAIiIiIsfJGBNJ1QRYA4EwYAbuwOrvwJbKx+FF5BhYllWI+9/PNOAxY0wI0Bf3v6//AnHGmFlUTjIHrNW/MREREZFjpxBYRERE5DcYY4KoCqQGAUnAbNxh1JvA6srH3UWkDliWdRj4tnLBGBOF+w8vA4H7gCBjzHSqQuHtCoVFREREaqcQWERERORXjDG+QA+qQt+2wCLcYdNdwJLKx9lF5DSwLOsg8GnlgjEmgaohWJ4GSowxPw8dMd2yrH3eqlVERETkTKQQWERERM55xhgH0Imq0LcbsBZ3oPQ4MK/ycXUROQNYlrUT+B/wv8rJGJvj/rc7DHjVGHOAqvGEZ1qWleW1YkVERETOAAqBRURE5JxTGRq1pir07Qvswh0Y/QeYVfk4uoic4SqHgdhQuYwyxtiBdrj/bf8OGG2M2URVKDzHsqx8b9UrIiIi4g0KgUVERKTeqwx9k6kKfQcAubgDoY+A2ysfNxeRs5xlWeXAssrlBWOMC+iK+9/+X4COxpjlVIXCCy3LKvFWvSIiIiKng0JgERERqZeMMTG4w95BuMNfF+7AZwrwp8rHyUWknqsMeOdULk8bYwKAXrivDS8BzY0x86gKhVdUBskiIiIi9YZCYBEREakXjDHhQD+qQt9oYCbuYOcFYEPlY+Micg6rHArih8oFY0wYVdeOMUAjY8xMqkJhXTtERETkrKcQWERERM5Klb35elMV+qYAP/fmuwH15jsuyrjqL/23PbrKSeMmVC4YYxpR9RTBHwCXMWY6laGwniIQERGRs5FCYBERETkrVI7r2Y2q0Lcj7jE/pwEPoXE9T5jT6Sw6dOiQMyAgwNulyCmQnp5eAeR4u46zhWVZ+4BxlQvGmJ/HEz8feM4Y8/N44tOAGRpPXERERM4GRj0DRERE5ExkjLED7akKfXsCm6h6RHtO5WPdcpJCQ0MnPPHUE5fdf//93i5F6lhmZiYJcQnFxcXFMZZlHfJ2PWe7ykkmU6maZLIvsJuqUHiWZVmHvVehiIiISM0UAouIiMgZoTJcaUFV6Nsf2E9V6Duz8rFtqWPGmA7+/v6zHvvrY/4XX3KxLTQ0FPd/DjlblZaWsmzpMh7/6+MFaWlp7+Tm5j7k7ZrqI2OMA/dTCT+Hwt2BtVSFwvMsyyr0XoUiIiIibgqBRURExGuMMQlUhb4DgRKqQt/plY9ly2lgjGkbFBT0R2BQeXm5n7frkZNjs9nKnU7n1qysrDeBDzSx2elhjPEBelAVCrcFFlMVCi+xLKvUexWKiIjIuUohsIiIiJw2xpgoqgLfQUAglYEv7oBku8IqEakvjDFBQB+qrnnJwGyqrnmrLcuq8F6FIiIicq5QCCwiIiKnjDEmBOhHVQASB/xEVQCyVqGviJwrjDGRuIe6+fkJiHBgBlXXxC26JoqIiMipoBBYRERE6owxxg/oRVXo2wpYQFXAscyyrDLvVSgicuYwxsRS/ekIqBoSZ5plWWneqk1ERETqF4XAIiIicsKMMU6gC1UBRhdgJVWh7wLLsoq8V6GIyNmhcnLMprivpYOAAUAmVaHwDMuyMr1XoYiIiJzNFAKLiIjIMTPG2HBPdPRz6Nsb2EZV6Dvbsqxc71UoIlI/HOV6+3MoPMuyrDzvVSgiIiJnE4XAIiIiUqvKnmnNqAohfu6Z9nPoO9OyrAzvVSgicm44ypMXP4fC8y3LKvZehSIiInImUwgsIiIi1fxijMqfJy4yuEOGabgfR97txfJERISjjsH+cyi81LKscu9VKCIiImcShcAiIiLnuBpmq4/APVv9z0HCZs1WLyJyZjPGhAD9qAqFY4FZVF3L1+paLiIicu5SCCwiInKOMcYEAX2oCn2TgTlUBQWrLMuq8F6FIiJysowxDXEP4fNzKBxI1VA+0y3L2ubF8kREROQ0UwgsIl5XOcbdUH+X6yq7zRZjDMbbNclpVVFWXr6zoKT0U2Cywse6Z4zxBbpTFfq2AxZTFfoutiyr1HsViojIqWaMScT9O+DnULiIqlB4hmVZ+7xXXf1njGkAjHQF+FyIMQG62a2/LADLOlySX/wN8JllWYe9XJKICKAQWES8zBjj9HM5J0aHBPe4sF1qYIOgANzzUMm5osKy2J+dY32zbHXB4YLCLwtLS2/W46onxxjjADpSFfp2B9ZRFfrOtSyr0HsVioiIN1VO+tmCqt8T/YF9VIXCP1mWleW1AusZY0yy3eVY2Lh9gn/jjgn+Tl8X6vJQj1lQkl/MroVb8w9u3JdeVlzazbKsg94uS0REIbCIeJUx5uqkBhHvv3rj1YFOu93b5YgXFRSXcMd74/Iz8/KHWJY1x9v1nE0qP8ynUvVhvi+wh6rQ9yf1QhERkdoYY+xAe6p+j/QENlIVCs+1LCvfawWe5Vz+Pl+1uLDt0DaXd7Z5uxY5vRa+/1Ppjnmb3iwrLnvA27WIiOiXkIh4VYCP65pL2rdWACz4+7g4v00LX6fdNtTbtZzpjFuyMeYOY8zHwH7ga9xB8MdAC8uy2liW9aBlWd8oABYRkaOxLKvcsqyllmU9b1nWECAS+D+gEPgrcMAY85Mx5kljTG9jjMurBZ9lykvLhjTt30qfvc9BzQa2ctrstiu9XYeICIDD2wWIyLnNbrM1igwK9HYZcoaICg6yuxyOWG/XcSYyxjSi+liOPrh7Z/0IPGpZ1g7vVSciIvWJZVklwOzK5SljTADQG/fvn/8AzYwxc6nqKbzSsqxyb9V7JjPGODH4+Ib4ebsU8QL/8EAqyipCvV2HiAgoBBYR79MQwOJhjMFg1FMGMMaE4R6j8efQNxqYifsD94vABo2dLCIip0PlUBBTKheMMeFU/Y76EGhojJlJVSi8Ub+jPIwxxjK64z0nGWOwNAK0iJwhFAKLiBzFjW+NIbugAJsxOGx2WjaO5v7z+9EgOMgr9eQWFvHy5Oks3bGbED9fbunbgwGtUmps+8Pq9bwyeQYuR9VQG09feQnt4hufrnLlOPyil9XPoW8KMA/3B+obgBXqZSUiImcCy7IOAeMrF4wxMVQ9rfJHwGGMmU5lKGxZ1i5v1SpHt2PeZjZMXkXOviwcvi7CEiJIvbQjUc0bnfZaykvLWfzBLHYt3obDx0HLi9rT8sJ2NbY9sD6Nac99i8NVFWl0vrEPyX2an65yRUTOOgqBRUR+w1PDLqZjYhwlZWW8/uNPvDF1Nk8Ou+i4j5OVX0BYgP9J1fL6j7Nw2Ox8cs8tbD2YwRNfTCQpKoLEyIga27eIieal64ad1HvKqVE5nmI3qkLfjsAy3B+YHwIWVj6OKyIickazLGsv7h7BH1b2eE3G/bvtAuBfxpgcqiYrnW5ZVrrXihWP9ZNWsu675XS9uS+N2sZhs9vYu3o3act2HHcIXHi4AL+Qk7vPXf3VEnIPHObyl6+nMLuAac99Q0jjMGLaxtfY3i80gCv+c8NJvaeIyLlEj9yKiBwjl8NB75Qm7Mo8dMz7FJWWMm3tRv70yQT+9MmEk3r/opJS5m7ayo19uuHnctE6NobuTROZvnbTSR1XTg9jjN0Y08kY8wdjzGQgA3gZCAD+ATS0LKuvZVlPWZY1WwGwiIicjSy3rZZlvWNZ1gjcwxldAawHrgM2G2NWGmNeNsZcaowJ9mrB56iSgmJWj19Ml5v6ENclGYePE5vDTmyHRDqM7HFMx6goK2f30u389PJkvv3Dxydd0/a5G2l9WSdcAT6ENA6jSb+WbJu98aSPKyIibuoJLCJyjIpKS5m1YQstYqJ/s+26tP38uHo9szdupVl0A85v05LeKU0821//4SdmrK85vG0QHMRbt4w4Yv2erGxsNkNseKhnXXJUJKt37621jq0H07nmtfcI8vVhYGpzRnTvhN2mv/+dDpU9oVpQ1dO3P7Afdy+ot4FrKx+nFRERqbcsy6oAVlcurxhjHEAn3L8bHwDGGWPWUtVTeJ5lWYXeqvdckbHlAOWl5cR2SjrufbN3Z7J11kZ2zNtEYFQIyX1S6PG7AZ7ta79dzrqJy2vd/+q3bj1iXUl+MYVZBYTGVz3dFhYfwZ5lO2o9TnFOIePvHY3d5SC2UyLtruqKw8d53OcjInKuUAgsIvIbnvnqe+w2G4UlpYT6+/GPa4bW2nbWhs2MmbMIy4LBrZvz5i3Daxw/+N7z+3Hv+f2Oq46iklICfFzV1gX4uCgoqbnDaJu4GN6+ZSRRIUHszDjEP7+Zgt1mY0T3Tsf1vnLsjDEJVIW+A4FS3B9qvwTurXxcVkRE5JxlWVYZsLByedYY4wv0wP27829AG2PMIiqHjgAWV+4jdag4rwifIF9s9mPvHLB/XRorPllAUU4Bib1SGPzXywluFHpEu9RLO5B6aYfjqqe0qBQAl1/Vva7T30VZUc33ucGNwrjw71cR3CiM/Mxc5r8zg2Xj5tH1luO7vxYROZcoBBYR+Q1PXHERHRPjKK+oYP6W7fzh469459aRhAcGHNE2PTefjNw8uiQnkBQVWWObE+XrclJQXFptXUFxCf4uV43tG4WGeL5OahDBtT278MWi5QqB65AxJgoYQFXoG0zVzOhPAts0O7qIiEjtLMsqAmZULlQOD9EH9+/WN4EkY8xsqnoKr67sXSwnwSfQl+LcIirKK445CC7KKST34GEimzYkLC6CgIjAOqvH6evuwVtaVIq9crK30sJSHL413+f6hfrjF+oegziwQTAdhndn5r+/VwgsInIUCoFFRI6R3Wajd0oTXpsyk7Vp++jTvOkRba7s0p4hbVsxa8NmPpm/lFcmT6d/ixQGtW5O04YNPO1enTKT6etqHuMsKjiId2679oj1sWGhlFdUkHYom8aVQ0JsS88kITL8mOo3gPLIk2OMCQH6UhX6xgOzcH8wfQ1Yo9BXRETkxFmWlQNMrFwwxjTAPaTSIOAuINQYM4OqnsJb9Lv3+EU2bYjdaWfP0u3Ed23y2zsAid2bEtcxkd1Lt7N11gYWj55NXOckkno3p0FKNO6RsGDtN8tY++2yWo9zzX9vP2KdK8AHv1B/snZl0Kh1HADZuzIJaRx2bCdkjq2ZiMi5TCGwiMgxsiyLBVu2k1tUTFxE7TekAT4uLmyXyoXtUtmdmcWPazbw1JcTiQ0P5bkRlwNw/wX9uf+C/sf1/r4uJ71SkhkzZxEPDRnA1oMZzN+8nZeuH1Zj+8XbdtK0YQPCAvzZnZnFuPlL6NP82G7yxc0Y4wf0pCr0TcX9+Oo04A5gqR5RFREROXUsy0oHPq9cMMbEU/UUzhNAuTHm56dwpluWleatWs8mLn8f2gzrwpIxczB2G41ax2Kz29i/No0D69PoMKLmyeHsLgeJPZqR2KMZ+Zl5bJ+7kYXvzsSyLIa+6O7EkDq0I6lDOx53TUm9Ulj79TIikqIoPFzAlpnr6X5H/xrbHlifRmCDYPwjAik4lM+KzxYS2zHxuN9TRORcohBYROQ3PDV+IjZjMBiiQoJ45KJBJEZG/PaOQFxEGLf268HNfbuzYe+Bk67l3sH9eGnSdIaPep9gX1/uO7+fp5aDObn87r1xvHPbtUQFB7Fi5x7+/f00CktLCfP3Z2CrFA0F8RuMMU6gM1Whb1dgFe4Plo8C8ysfWxUREREvsCxrFzAaGF05CWsK7t/Zl+GeeC6dqqEjZmgS1tq1vLAdviF+rP16GfPenIbTz0l4YoNjDnADIgJpPbQTrYd24uDGfSddT5thXVj8wSwmPPQhDpeDlhe3J6ZtvGf7Z3e8S/9HLiaqeSMO7chg3lvTKMkvwSfQh9iOSbS7uutJ1yAiUp8ZPTkjIt4U4u8395GLBvXs2iTR26XIGWDyqnW8O2Pep7lFRSNOx/sZY2xAG6pC3z7Adqo+PM6yLCv3dNQiIiIiJ6fy93o7qiZp7Q1soer3+mzLsvJOc00uYzOFIz/4/bHPwCb1RnFuEV89OLagvKSs7iYKERE5QeoJLCIi54zKHkNNqQp9BwBZuD8YjgZutiwrw3sVioiIyImqnDBueeXy78onfLri/r3/J+BzY8wKqkLhBZZlFXupXBERkdNKIbCIiNRrxpjGVIW+AwEb7g9/E4GHLcva7cXyRERE5BSxLKsUmFu5PGOM8Qd64b4veAFoaYyZT1UovMyyrHJv1SsiInIqKQQWEZGzRmWgu/dos4AbYyJw9/D9+VHQSGAG7g94zwKbNYu4iIjIuceyrALgx8oFY0wo0A/3/cL/gMbGmJ+oCoXX6Z5BRETqC4XAIiJyVjDG3AI8BzQDcn6xPhDoS1Xo2wSYjfvD23+BlZWPh4qIiIh4WJaVDXxduWCMicb9h+RBwEOAvzFmOpWhsGVZ22s6jjHmIsBhWdY3p6NuERGRE6EQWESkDr34/TQigwK4uU93b5dSb1SO4/sUcD3usLfYGNOfqtC3HbAE9we0e4FFlY9/ioiIiBwzy7L2Ax9XLhhjkqi63/iHMaYA9x+ZpwEzKtsD7AImG2OaAK+cC72H578zHf/wQNpd1dXbpYiIyDFSCCwiUk/N2rCZr5asYtvBDFIaRfHCyCuqbd96IJ2XJ89gd2YWcRFhPDRkAE0aNgBgR3om78yYy5YD6eQUFjH5j/dU2ze3sIiXJ09n6Y7dhPj5ckvfHgxolVLn52CMcQHvAp1wfyB7HegOrMP9IewpYG7l450iIiIidaay5+97wHuVf5RuhTsUHg68YYxJoyoUHgJ8AiQZYx7S2MKnT8GhPBaPnkP6pn3YXQ5aX9aRZgNTPdv3LN/Bys8Wkp+RS2hcBN1u60dI43DP9g2TV7Ju4grKS8qJ65xEl5v7YnfavXEqIiKnlM3bBYiIyKkR6OvLFZ3bck23jkdsKy0v5+mvvmdgqxQ+v/92zmvdnKe/+p7ScvfnFbvNRt8WTXloyIAaj/36j7Nw2Ox8cs8t/PGSwbz2w0/syMg8FaexArgBCAaicYfAcZZldbMs61HLsn5UACwiIiKnmuW21rKs1yzLuhz3nAO3AGnAPcB8oBi4DJhljAn2WrHnmHlvTyewQRDDXruR/g9fyMrPF3FgXRoAOfuzmffmNLrc3Jer3rqVxh0S+OnlyVSUu0cK27tqN+u+W8HAP13KZS9dR156DqvHL/bm6YiInDLqCSwi9cZnC5fx9dJVFBSXEB4YwL3n96VDQhwb9x3gzWmz2Z2ZhcvhoHdKE343sBdOu/sv/EOeH8U9g/vy1eKVZOUXcHnndgxu3YLnJ/7IroxDdEqK54+XDMZpt7NyVxovfPcjl3RozfglK/F1Orm5TzcGpjavsaaFW3Ywes4CDhzOJT4inPvO70dyVORR660rHRPdx5q0ct0R21btSqO8wuKKzu0wxnB5p3Z8uWgFK3fuoXNyAnERYcRFhLE3K/uIfYtKSpm7aStv3ToSP5eL1rExdG+ayPS1m7i1X486q7/S07h7Aafi/lB1IbDQGPMHy7K21vWbiYiIiByLyp6+i40xK4GpQC/c9ymJuJ9auhv3XAZ1bt13y9n442pKC0vxC/Wny019iE6NJWPrAZZ+OI+cfVnYnQ7iuiTR8dqe2B3ue95xN75F5xt7s2HKKooOF9L8/DYk92nOvLemczjtEDFt4+hx5yDsDjsH1qcx763ppAxKZcPkVTh8HbS9qitJPWt+8itt+U5WfrmI/IxcQmLC6HJzX8LiI45ab10oLSrl4Pq99L5nMDaHnbD4SOK6JLN11gYatmrMvtV7iGreiKjmjQBodXEH1kxYysENe4lOjWX7nI0k92tBaKy7Z3Dryzox761ptB+uod1EpP5RCCwi9cLuzCy+WbaaV2+4moigAPYfzqGiwj0cm80Yfj+wNynRUaTn5vH459/x3fI1XNG5nWf/Jdt28dpN15Cem8t9oz9jfdo+/nTJYIL9fHnowy+ZuX4zg1u3AOBQfgGHC4v48K6b2bB3P49/+R3NoqOIiwirVtPm/em8NHk6Tw+7iGbRUUxft4mnxn/Pu7dfx4HDObXW+2ufLljKZwuX1XruXz5wx3F/v3ZmHCKpQQTuJxvdkhpEsDPjEJ2TE466756sbGw2Q2x4qGddclQkq3fvPe46fotlWZ8Cn4JnbOAk3KFwztH2ExERETlN3gC6AYuAr4BHgTWWZZWdijfL2ZfNpqlruOCpK/EPCyAvPQfr53tem41O1/UkPKkBBYfymPni92yeupYWQ9p69t+3ejcXPnMV+Zl5TH7iCzK2HKDXXYNwBfrwwzMT2Dl/C8l93J0big4XUJRbxOX/uYGMrQeY+eL3RCRFEdwotFpNh3aks+DdGfT7vwsJT2rAjrmbmfXKJC7510jyM3JrrffX1n67nHUTl9d67le/deuRK2saftmyOLznkOfrXw7RbGFhAdl7DhGdGsvhtCxiOyZ6tofGR1B0uJDi3CJ8gnxrrUVE5GykEFhE6gW7zVBaXs7OzEOE+PsSHVL1BF6z6CjP19EhwVzUPpXVu9OqhcDXdOtIgI+LAJ8IEiIj6JgUT6PQEAA6J8Wz9UC6JwQGuKl3N1wOO23jG9M1OYFZG7dwXc8u1WqavGotF7VLpUVMNACDW7fgk/lL2bB3P5FBAbXW+2vDu3diePdOJ/cN+pXC0lICfFzV1gX4uCgo+e351IpKatu3pE5r/LXKSVa2VS4iIiIiXmdZ1u2n8/2MzVBeWk5OWha+Qb4ENqi6hwxPauD5OrBBME0HtOLgxr3VQuBWF7fH6eciNDackNhwGrWOJTDKfYyYtnFk7cyAPlVPuLW7qgt2p52GLWJo3D6enQu30uby6velW2aup+mAVkQ2aQhAcp/mrP12GRlbD+AfFlBrvb+WemkHUi/tcFzfD6efiwbNolkzYSkdRnTn8N4sdi/Z7glwo1vHsuKzhRxYn0Zks2jWfbeCirJyykvcGX1ZcSlO/6r7Wpef++vSohKFwCJS7ygEFpF6ISYslDsH9ubDuYsrh3CI43cDehMRFMCeQ9m8M30Omw8cpLi0jPIKi6bRDartHxbg5/na5XAQ6v+L104HWXlVw84G+frg63J6XkcFB3EoL/+Img7m5DJ1zUa+WbbKs66svILMvHzaxjeutd7Twc/pPCK0LSgpxf8X51UbX5eTguLqYXFBcQn+Llcte4iIiIhIXQhqGEKn63qx+qslZKcdolGbODpe2xP/sABy9mWzbNw8Du1Ip6y4DKvCIjwxstr+viH+nq8dTge+IVX3vHaXg6LDVfe8rgAfHD5V94YBEUEUZh95z5ufkcv2OZvYNHWNZ11FWQWFWfk0bBFTa711peddg1g8ejYTHvqQwAbBJPZoxuG9WQCExITR43cDWDJmDoXZBST2akZITBj+4YHu74GPk9LCqnvi0kL3Pa7TV/e1IlL/KAQWkXpjQKsUBrRKIb+4hFenzOS9n+bxx0sG8/oPM2nSsAF/vvR8/H1cfLVkJbM3nvhwsrlFxRSVlHqC4PScPBIahB/RLjIokBE9OjGyR+fjqvfXPpm/hE8WLK21ngkP/f64zyEhMpzxi1dgWZZnSIjt6Rlc2qH1b+4bGxZKeUUFaYeyaVw5JMS29EwSIo/8HoiIiIhI3Urs2YzEns0oLSxh0f9mseLTBfS80x2EhiVE0uvu83D6udgweRW7F5/4A1Ql+cWUFZd6guD8zDxCYo+83wuICCR1aAdaD635ybXa6v21td8sY+23tQ+Bds1/a+50HRAZRP+HL/K8nvvGVCKSq54EjO/ahPiuTTznNGHWRk+v6ZDGYWTvyiShW1MAsnZn4hvip17AIlIvKQQWkXphd2YWmXn5tGrcCJfDjo/Tzs/Djbl7uLrwcznZnZnFd8vXEPKLnr4nYuzcRdzctzsb9x5g4bYd3NC76xFtLmybyjMTJtEhIZbmjRpSXFrGyt1ptImNITMvv9Z6f21Ej86MqCVIPpryigrKKyqoqKjAsixKysqwGYPD7h7GwmYzfL10FRe1b83kVWsBaJfgnqTDsixKy8sprZw5uaSsDDC4HHZ8XU56pSQzZs4iHhoygK0HM5i/eTsvXT/suGsUERERkWOXsy+bgqx8GjSLxua0Y3faPWPelhaV4PRz4vB1cnhvFpunr8U36OTueVeNX0K7q7uSufUgaSt20mbYkfekTfq1ZParU4hOjSUiOYrykjIOrN9LVPNGFGYX1Frvr6UO7Ujq0I7HXePhtCz8wwOwOe3sWriV/Wv2cPFzwz3bD21PJzQhgpK8YpaMmUPj9gmExLjn8kjqncKC/84gsWcz/EIDWPv1UpJ71zzhs4jI2U4hsIjUC6Xl5bz/03x2Z2Zht9toFRPNAxcMAOCOAb34z5QZfL5oGU0aNqBfi6as2JV2wu8VHuBPoK8P173xAT4OB/ed3/+ISeEAUhpF8eAF/Rk1dTZ7s7JxORykxjaiTWzMUeutK9PWbuSlSdM9r4e+9DbntW7BIxcNwmm388QVF/HK5Bm8P2s+ceFhPHHFRTjt7tmjD+TkcvPbY6vtGxUcxJg7bwTg3sH9eGnSdIaPep9gX1/uO78fiZERdVq/iIiIiFRXXlrOis8WkLM3G5vdRmTThnS9tR8AHUf0YNH/ZrF+4grCEiJJ6NaUA+tO/J7XN8QfV4CLCfePxe5y0PWWvp7w9JcikqPoems/loyZQ+6Bw9idDhqkRBPVvNFR660r+1bvZu23yygrLiM8IZL+j1yEb3BV+L30w7lk7c7EZrcR3zWZjtf29GyLaRtPy4vaM+2f31JWUkZ8l2TaDOtS09uIiJz1TG1/hRMROR1C/P3mPnLRoJ5dmyR6u5RjsnJXGi989yMf3n2zt0uplyavWse7M+Z9mltUNMLbtYiIiIicLGOMy9hM4cgPfm/zdi3H48D6NOa9NZ0r/nODt0s5qxXnFvHVg2MLykvKTs/EHyIiR3FW/SISERERERERERERkeOjEFhERERERERERESkHlMILCJyHNrFN9ZQECIiIiJSrzVs2VhDQYiI1DMKgUVERERERERERETqMYXAIiIiIiIiIiIiIvWYw9sFiIjUZMa6TYxfvILdh7Lwc7loEhXJiB6daB0b42nzw+r1vDRpOn8Zej59WzRjze69/PWLbwGwgOLSMnydVZe5d267lhcmTmXD3gPYbcazvl18LE9fefFpO7czyejZC5m/eRu7MrMY2aMzN/TuWmtby7J4/6f5TF61DoAL2rbitn49MMb9vfzjxxPYmZFJaXk5DUOCubF3V3o0S/bs//XSVYxfsoLcwiIah4Xy+0G9q/33FBERETmX7Ji3mQ2TV5GzLwuHr4uwhAhSL+1IVPNGnjbbZm9gwX9n0uue80jo1pSDG/cx88WJAFgWlJeU4fCput+9+J/Dmf/OdDK2HsT2i/vdqJaN6f9/F56+k/OSwux8Fv1vFoe2p1OYXcDQf19LYIPgWtuv/GIRe5btIGdvFqlDO9J2WJdjPlbBoTwWj55D+qZ92F0OWl/WkWYDU0/p+YmInAyFwCJyxvly8Qo+W7iM+87vR+fEeBx2G0u272L+5u3VQsOpazYS5OvDj2s20rdFM1rHxTDhod8DsP9wDje/PZYvH7gDu636Qw93n9eXC9u1Oq3ndKaKCQvhtv49mbhizW+2/X7lWuZt3s4bt4zAAH/57BsahQRzcYfWANw5qDcJkeHYbTY27N3Po59+w7t3XEdEYAAb9u7n/VnzeXHkFTRt2ICJK9byt68mMe6eW4747yMiIiJS362ftJJ13y2n6819adQ2Dpvdxt7Vu0lbtqN6CDxnE64AH7bP2URCt6ZENW/ENf+9HYC89By+eXgcV711KzZ79fupzjf0pmn/lqf1nM4IxtCoTRytLunAj3+b8JvNgxqG0GF4dzZPX3fcx5r39nTC4iLoc99gDu/NYto/vyU4OpSGrRqf/HmIiJwCCoFF5IySX1zM2DkL+b8LB9E7pYlnffemSXRvmuR5feBwDqt3p/HYZUN49pspZOUXEBbgX6e1/LB6PZNXraN5dEN+WLOeIF9f/njJeew5lM2YOYsoLS/n9v49Gdy6BQAlZeWMnr2AWRu2UFpeTs9myfx+YG98nA5yi4p44bupbNx3gPIKi1aNo7nvgv40CAoE4A8ff0Xr2BhW7trD9oOZtGwczZ8uGUyIv1+dntOv/Vz79HWbfrPt1DUbubJLe0/Nw7q0Z/LKdZ4QODkq0tPWGENZRQUZuXlEBAZw4HAuCRHhNIuOAuC81Oa8/uNPZBcUEhEYUNenJSIiInLGKikoZvX4xXS/YwBxXaqemortkEhsh0TP6/yMXA5u2Evve89n7qgfKTxcgF9I3d7vbpu9gS0z1xORHMW22RtxBfjQ885B5O7PZtWXiykvLafDiB4k92kOQHlpOSu/WMSuhVupKCsntlMSHa/ricPloCS/mHlvTSNz20Eqyito0Cyarrf0xT/cfe849dmvaZDSiAPr08jefYjIpg3pedcgfIPq7n7XL8SflPNaU1FecUztfz6vHfM3H9exSotKObh+L73vGYzNYScsPpK4LslsnbVBIbCInLEUAovIGWV92n5KysrplZJ81HZT126kWXQUvZs3IT4ijOnrNnFll/Z1Xs+GvQcY0rYVn913G2PnLuKf3/xAt6aJvH/H9azencbfJ0ymd0oyfi4X7/80j33ZObxx83DsNhv/+u5HPpq3mFv79cCy4Pw2LfnLZRdQUWHx0uTpvPHjLJ4cdpHnvWau38TfrrqUBkGB/PWLb/ly8Qpu7dfjiJoO5uRy1/8+qbXmewf3Y0CrlDr/XuzMOERyVITndXKDSHZmHKrW5okvvmP5zj2UlpfTKSneE/p2Tk7g80XL2bB3P82io5iyej1NoiIJr+PgXkRERORMl7HlAOWl7gD1aLbN2UR4UgPiuySzOiaMHfM20/LCdnVeT+bWgzTp15Ir37iZ1eOXMHfUVBp3SODSF67l4Ia9zH7tB+K6JOP0dbLi0wXkpedw4d+vwma3MffNaayZsJT213TDqrBI7tuC3vcOxqqwWPDuTJaMmUPfB4d43mvngi30f/gi/CMCmfniRDZ8v5L2w7sfUVN+Ri7f//XzWmvucmMfEns2q/PvxTGzrBrXHd5z6Mj1IiJnCIXAInJGySksIsTf9zeHCJi2ZiOXdmwDQP9WKUxds+GYQ+C3ps3m3ZlzPa+HdmzLTX261dg2OiSY89u4H6Xr16IZn8xfynU9u+By2OmU5B6qYm/WYZKjIpm0ah1v3jyCID9fAIZ378S/vvuBW/v1INjPl97Nq3o2j+zeiT998nW19xrcuiWx4aEA9G3RlAVbdtRYU1RwEF8+cMcxnWtdKiotJcDHx/M6wMdFYWkplmV5xgV+5qpLKCsvZ/nOPezOzMJWud7f5aR3SjIPj/sKy7II9PXhb1dd4tlPRERE5FxRnFeET5DvEUM4/Nr2uRtJGeR+4iqxR1O2z9l0zCHw0g/nsvyT+Z7XKee1pt1VNc/9ENAgiCZ93U+HJXRrwtpvltH68k7YnXYatXEPVZF34DCh8RFsmbmei/5xNT6B7vvd1Es7MO/NabS/phs+Qb7E/6Jnc+uhHZn6z2+qvVdyn+YENwoFIL5rE9KW76y5psggrn7r1mM6V29w+rlo0CyaNROW0mFEdw7vzWL3ku34BPl6uzQRkVopBBaRM0qwny+HC4oor6ioNQheu2cf+w/n0K9FUwAGtGzG6FkL2HognSYNG/zme9w5qM8xjwkc+oueqj4OO0C1YSd8HA4KS0s5XFBIcWkZ9435zLPNsqDCcj8+VlRaytvT57B0+y7yiooBKCgprXaeRxy3pPSYajxWv3tvHAdzcgH4+1WX0jru+CZl83U6KSgp8bwuKCnBz+k8Ish12O10SU5gwtJVNAoNoUezJCavWseU1et5+9aRxISFsGz7Lp78ciKjbhpORJCGgxAREZFzh0+gL8W5RVSUV9QaBKdv2kd+ei4J3d33u4k9mrHyi0Vk7cwgLCGyxn1+qdP1vY55TGC/4Kp7ULvLHRH8ctgJu8tBaVEpxblFlJeUMfnJL6t2tsCqcN/vlhWXsmzcPPau2k1Jvvt+t6yolIqKCmyV97u+vziuw8dBWVHd3u+eTj3vGsTi0bOZ8NCHBDYIJrFHMw7vzfJ2WSIitVIILCJnlJaNo3E57MzbvI0+zZvW2Gbqmg0A3DP60+rr1248phD4VAj298PH4eDtW0cSWTlm7i99uXgFew5l88r1VxEeGMDWA+ncM/qzGo702w7m5PK798bVuv3+8/szMLX5Eevfue3aE3q/nyVEhrPtYAbNGzUEYNvBDBIiw2ttX15Rwb7sw5VtM+neJMnT07lzcgLhgf6s27uv1v/OIiIiIvVRZNOG2J129izdTnzXJjW22TZnE1gw6fHPj1jf6RhC4FPBJ9AXu8vBxc9e4xnn95fWT1pFzr5sLnhyGH6h/mTtzGDS419ADSMn/Jb8jFwmPvpprdu73NKXpJ51P/zZ8QiIDKL/w1VDu819YyoRyVFerEhE5OgUAovIGSXAx4cbendj1I+zsNtsdEyMw2GzsXznHlbuSuPG3l2ZtXEL91/Qn67JCZ795mzaxrh5i7m9f8/fHEriVLAZw5B2rXh7+hzuOa8voQH+ZOTmsSPjEJ2T4iksKcXH4SDQ14fcwiI+mrf4hN8rKjiICQ/9vk7qLisvp8KysCyLcquCkrIy7DZbjd/D81KbM37xSrokJ2AwfLl4BZd1bAvA7sws9h/OoW1cY+w2w08btrBm915u69cTgJRGUXwyfwlDO7UhOiSY5Tv3kHboMImREUe8j4iIiEh95vL3oc2wLiwZMwdjt9GodSw2u439a9M4sD6NtsO6sGvRVrre2peYdlX3u7uXbPMMP/BbQ0mcCsZmaNK/BcvGzaPzjX3wDfaj4FAe2XuyiGkbR1lRCXaXA5e/i+K8IlZPWHLC7xUQGcQ1/739hPYtLynDqhyzt6KsgvKSMk8P51+rKCvHqrA8S3lJGcZh8/RcPtqxDqdl4R8egM1pZ9fCrexfs4eLnxt+QjWLiJwOCoFF5IxzZZf2hPn78fG8Jfzrux/xdzlp2jCKkT06MW/zdlwOB+elNsdht3v2GdK2JR/OXcSSbbvo1jTxqMd/Y+os3p4+2/M6NjyM12+65qTrvq1fDz6at5gHP/ySnMJCIgIDubhDKp2T4rmiUzue++4HrnntPSICAxjWpT3zNm8/6fc8Wa9MmenpWQ3wyfyl/N+FAzm/TUvW7N7LX7/41hM4X9Q+lX2Hc7izclK6IW1bcVH7VAAsLD6cu4hdGVnYbIaYsFAeHXoBzaLdPbPPS23OvqzD/PHjCeQVFRMZFMh9F/QnLiLsNJ+xiIiIiPe1vLAdviF+rP16GfPenIbTz0l4YgNSh3Zk97Id2J0OknqlYHNU3e826duC1eOXsG/Vbhp3SDjK0WHJ2Dks+6hqDoygRqFc+MxVJ113h2u6s/rrpUx5ejzFuUX4hwXQbFAqtI2j+QVtmffmVL685wP8QgNocWE79izdcdLvebw+vf1dz9ff/cl933rtmDsBWPS/WQB0vaUvAAvf/4ntczZ52q/9Zhnd7+hPcp8Wv3msfat3s/bbZZQVlxGeEEn/Ry7CN9jvVJ2WiMhJM1ZNs1qKiJwmIf5+cx+5aFDPrk0SvV2KnAEmr1rHuzPmfZpbVDTC27WIiIiInCxjjMvYTOHID35/+rvuitcV5xbx1YNjC8pLyjQJhoh4nX4RiYiIiIiIiIiIiNRjCoFFRERERERERERE6jGFwCIiIiIiIiIiIiL1mEJgERERERERERERkXpMIbCIiJcNeX4Ue7OyvV2GiIiIiEidGnfjW+QeOOztMkREBHB4uwARkZMxY90mxi9ewe5DWfi5XDSJimREj060jo3xtPlh9XpemjSdvww9n74tmrFm917++sW3AFhAcWkZvs6qy+E7t13LCxOnsmHvAew241nfLj6Wp6+8+LjqG/L8KN6/4zpiwkJP6jyPV25hES9Pns7SHbsJ8fPllr49GNAqpca2O9IzeWfGXLYcSCensIjJf7yn2vbLX3672uuSsnIu6dCau8/ry86MQ7w4cSr7snMAaBrdgLsG9SEhMvzUnJiIiIjIOWLHvM1smLyKnH1ZOHxdhCVEkHppR6KaN/K02TZ7Awv+O5Ne95xHQremHNy4j5kvTgTAsqC8pAyHT9V97sX/HM78d6aTsfUgtl/c50a1bEz//7vwuOobd+NbXPrCSIIahpzkmR6f4rwiFr43k32r9+AT5Ev7q7uR2LNZjW2z9xxi2bh5ZO3IoDiviGvH3Flte156DotHzyZjywHsTjtxXZLpdF0vbHZ3f7mdC7ewevwSCrLy8Q8PpN3VXYnrlHTKz1FE5FRQCCwiZ60vF6/gs4XLuO/8fnROjMdht7Fk+y7mb95eLQSeumYjQb4+/LhmI31bNKN1XAwTHvo9APsP53Dz22P58oE7sNuqPxxx93l9ubBdq9N6TnXl9R9n4bDZ+eSeW9h6MIMnvphIUlQEiZERR7S122z0bdGUSzu05umvJh2x/efvFUBRSSkjRr1Pn+ZNAYgIDOCxy4fQMDiICsvi2+Wr+ee3P/DWLSNO3cmJiIiI1HPrJ61k3XfL6XpzXxq1jcNmt7F39W7Slu2oHgLP2YQrwIftczaR0K0pUc0bcc1/bwfcAec3D4/jqrdu9YSaP+t8Q2+a9m95Ws+priwZMweb3c6w128ia2cGP700idD4CEJjj+yEYLPbSOjWhJRBqcz6z5Qjti8ePRvfYD+GvXojJQUlTH/+OzZPW0vz89tQcCiP+W9Np++DQ2jUNo69K3cx5/Ufueyl6/AN9jsdpyoiUqcUAovIWSm/uJixcxbyfxcOondKE8/67k2T6N606q/zBw7nsHp3Go9dNoRnv5lCVn4BYQH+dVrL3qxsXp40g60HM3DYbbSPj+Uvl13AI+PGA3DXB59igIeGDKRfy2Z8vnAZ45esxAA39elWp7WAO6idu2krb906Ej+Xi9axMXRvmsj0tZu4tV+PI9rHRYQRFxF2TENSzN60lVB/f1rHuj98BPr6EOjr495oWdiMjX1ZeuRPRERE5ESVFBSzevxiut8xgLguyZ71sR0Sie2Q6Hmdn5HLwQ176X3v+cwd9SOFhwvwC6nb+9zcA4dZ+O5MsnZlYrPbaNiqMb3vHcyP//gagO8f+xxjoNtt/Uno3pR1E1ewYfIqjIG2V3at01oAyopL2b14Gxc9ew1OXydRzRvRuEMCO+Zuov3w7ke0D24USnCj0FqHpMhPzyVlcGvsLgd+LgcxbeI4nHYIgIKsfJz+LmLaxQPQuH0CDh8HuQcOKwQWkbOSQmAROSutT9tPSVk5vVKSj9pu6tqNNIuOonfzJsRHhDF93Sau7NK+TmsZPXsRHZPi+NfIyykrL2fT/oMAvHjtMIY8P4o3bx7uGQ5iybadfLl4Bc8Nv4zokGBemTLjqMd+/YefmLF+U43bGgQH1djjdk9WNjabITY81LMuOSqS1bv3ntgJ/sLUNRsYlNocY0y19Vf+578UlpRiWRY39K77YFtERETkXJGx5QDlpeXE/sawA9vmbCI8qQHxXZJZHRPGjnmbaXlhuzqtZdWXi4luE8ugR4dSUVZO5vZ0AAY/dhnjbnyLi/5xtWc4iL2rdrFh0koG/vlSAhsEsfC9n4567MUfzGLHgi01bguICOSif1xzxPqcfYcxNkNwo1DPurD4CA5s2HdC59f8gjbsXLCVhi1iKMkvZu+qXZ7wOjypASExYexZtoOY9vGkLd+JzWEnLP7IJ+tERM4GCoFF5KyUU1hEiL/vEUM4/Nq0NRu5tGMbAPq3SmHqmg3HHAK/NW02786c63k9tGPbGnvuOuw2Dh7OJTMvnwZBgdWGovi1WRu3cH6bliQ2cN88Xt+rKzPXb661/b3n9+Pe8/sdU70/KyopJcDHVW1dgI+LgpKS4zrOrx3MyWX17r08NGTgEdu+fOAOikpK+XHtBqKCg07qfURERETOZcV5RfgE+R4xhMOvbZ+7kZRBrQFI7NGU7XM2HXMIvPTDuSz/ZL7ndcp5rWl31ZE9d43dRn5GHoXZ7jFxfzkUxa/tWriV5D7NPcMytLmiMztrCXkButzcly439z2men9WVlyK07/6fa7Tz0VZ0Ynd50Y1j2HLzPV8/vv3sSosknqnENspEQCbzUZS7xTmvTmV8tJybA47ve8djMPHeULvJSLibQqBReSsFOzny+GCIsorKmoNgtfu2cf+wzn0a+Eev3ZAy2aMnrWArQfSadKwwW++x52D+hzTmMC39evBmDmLeGDM5wT6+nBll/Zc0Lbm/TLzCmjaMMrz+lQEpr4uJwXFpdXWFRSX4O9y1bLHsZm6ZiOpjRsRHRpc6/te3L41w197j//edi2hdTzshoiIiMi5wCfQl+LcIirKK2oNgtM37SM/PZeE7u773MQezVj5xSKydmYQlhD5m+/R6fpexzQmcIfh3Vn15SKmPDUeV4APLYa0o0m/FjW2LcwuIDyp6h47ILLu73MdPk5KC6vf55YWleLwPf77XKvCYsYLE2k6sCXnP34FZUWlLHh3Jis+XUCHET3Yv2YPyz9ZwKBHhxKe2IBDO9L56eXJDHjkomP6HouInGkUAovIWall42hcDjvzNm/zTFL2a1PXbADgntGfVl+/duMxhcDHKjwwgAeHDABgzZ69PPrpN7SJi/EMAVGtbYA/Gbl5ntfpOblHPfarU2Yyfd3GGrdFBQfxzm3XHrE+NiyU8ooK0g5l07hySIht6ZkkRB45WcbxmLZ2A9d063jUNpZlUVxWRkZevkJgERERkRMQ2bQhdqedPUu3E9+1SY1tts3ZBBZMevzzI9Z3qsOA0i/Un2639Qfg4MZ9TH/+O6JaNPIMAfHrtgWZVfe5+ZlHv89d9L9Z7JhX87BnAZFBXPzP4UesD24UglVeQc7+bIKjQwHI2pVJaOOwYzyjKsX5RRQcyiPlvNbYnXbsTjvJfZuz6otFdBjRg6xdGUS1aEREsrsDR0RyFJFNoti/do9CYBE5KykEFpGzUoCPDzf07saoH2dht9nomBiHw2Zj+c49rNyVxo29uzJr4xbuv6A/XZMTPPvN2bSNcfMWc3v/nr85lMSxmrVhCy0bR9MgKJBAXx+MAZtxHzsswI992TmeQLhvi6a8NGkag1Kb0zAkiA/nLT7qse+/oD/3X9D/uOrxdTnplZLMmDmLeGjIALYezGD+5u28dP2wGttblkVpeTml5RUAlJSVAQaXw+5psy5tHxl5+UcE7st27CbYz5ekBhEUlZYxevYCAn18iI84/htxEREREQGXvw9thnVhyZg5GLuNRq1jsdlt7F+bxoH1abQd1oVdi7bS9da+xLSrus/dvWQbayYspcOI7r85lMSx2rVoK5FNG+IfHogrwAcDGJt7bgjfED/yDuZ4AuH4rk1Y8O4MknqnEBAZxJoJS4967K639KXrLcc3HITDx0ls5yRWj19Ct9v6kbUzg7RlOxj8+OU1trcsi4rScirKygEoLykDY7A77fgG+RHQIIjN09bR8qJ2lBWVsn3ORkIrx/wNT45i3XcrPL2rD+3I4ODGfTQblHpcNYuInCkUAovIWevKLu0J8/fj43lL+Nd3P+LvctK0YRQje3Ri3ubtuBwOzkttjsNeFWYOaduSD+cuYsm2XXRrmnjU478xdRZvT5/teR0bHsbrNx05QcWm/Qd5e/oc8ouLCQvw586BfTxDJlzfsysvfj+NkrIyHrigP31bNOPyTu3486cTMBhu6tONGetq7gFxMu4d3I+XJk1n+Kj3Cfb15b7z+5EY6b6hPZiTy+/eG8c7t11LVHAQB3JyufntsZ59h770NlHBQYy580bPuh/XbKBXs2T8fzXWcF5RMW9MnUVGbh4+DgcpjaL4+9WX4nLo14uIiIjIiWp5YTt8Q/xY+/Uy5r05Daefk/DEBqQO7cjuZTuwOx0k9UrB9os/2jfp24LV45ewb9VuGndIOMrRYcnYOSz7qGrui6BGoVz4zFVHtMvcdpClH82ltKAE3xB/Ol3fi8AG7vvcNld0Zv47MygvLaPrLX1J6NaU5ue3Zdpz32KMoe2VXdkxr/a5L05Ul5v6sPDdmXx5z2h8An3pclMfzzjE+Rm5THz0Uy7+53ACIoPIz8jlm4fHefb99PZ3CYgM5LKXrgeg7/0XsPSjuaybuBybzUZUyxg6XdcLgIYtYmh9RWdmv/YDRTmF+AT5kjq0I43axNX5OYmInA7Gsixv1yAi57AQf7+5j1w0qGfXJoneLkXOAJNXrePdGfM+zS0qGuHtWkREREROljHGZWymcOQHv6+brrlyVinOLeKrB8cWlJeUBXi7FhER/SISERERERERERERqccUAouIiIiIiIiIiIjUYwqBRUREREREREREROoxhcAiIiIiIiIiIiIi9ZhCYBEREREREREREZF6TCGwiIiIiIiIiIiISD2mEFhERERERERERESkHlMILCIiIiIiIiIiIlKPKQQWERERERERERERqccUAouIiIiIiIiIiIjUYwqBRUREREREREREROoxhcAiIiIiIiIiIiIi9ZhCYBEREREREZFTwwcL4+0ixKscxhiHt4sQEVEILCJeZVmWn7drkDOLheXv7RpEREREToYxxmmM+T2wDhQCn+McwHpjzLXGGGUwIuI1ugCJiFcYY5KMMR9UWFYbb9ciZ5byiooLjDGvGmOivV2LiIiIyPEwxtiNMTcAG4ArgeEYKrxclnhXEXAncD+w0hhzuTFGfxgQkdNOIbCInFbGmBhjzBvAEmCX3WZb5u2a5Mxit9m+ByqAdcaY54wx4d6uSURERORojNuVwCrcgd9tlmWdj/ueV85xlmVNA3oAfwGeBhYaY85XGCwip5NCYBE5LYwxkcaYF4E1QAHQwrKsJ4CS8grLu8XJGaO8ogIgz7KsB4F2QDiwyRjzhDEm2Ju1iYiIiPxaZfh7Ie6w9zHgD0Bvy7JmVjapsCosY1m63z0XVVRUYCp7gltu3wIdgH8DrwEzjTG9vVmjiJw7FAKLyClljAkxxjwDbAT8gTaWZT1iWVY6QGlZ+cbdh7L0iJwAsCP9UElRSelmAMuydluW9TugO5ACbDbGPGKM0TjSIiIi4nXGmH7AbNyB3j+BzpZlfW/9IvG1LKvM7nIczt1/2Ftlihfl7M3C5rDv++U6y7IqLMv6FEgFPgA+NMZMMsZ08kaNInLuUAgsIqeEMSbAGPNnYAsQj/um+G7LstJ+2a6wtHTchCUrC7PzC7xSp5w59mUfZuraDeXllvXFL9dblrXFsqzrgYG4H6PbYoy52xjj8kqhIiIick4zxnQxxvwAvA+8jbuTwxeWZdXYscHYzGdrJiwttvT02zmloqycNROWFpYVlX5Q03bLssosy/of0Bz4DvjWGPOlMabV6axTRM4deixFROqUMcYH+B3wKDAHeNKyrPVHaW98HI5/2Ix5qHuzJKtRSLCfhsY6t1RYFdbuzOyCxdt22iusikdKyspHHa19ZS+JvwMtcI+p9qFlWWWno1YRERE5dxlj2gB/AzpX/v/7lmWVHsN+wQ5f5wyfQJ+U2I5JPk5/l/NU1yreVZRTWLJn6fbSsuKyeWVFpZdallX8W/sYY/yBe3APKTIZeNqyrK2nulYROXcoBBaROmGMcQA3A48Dq4HHLctafhz7JwEXAg0ApcDnlgpgHzDRsqy9x7qTMaYP8A8gCngCqLUHjoiIiMiJMsY0w/2H50HAc8BblmUVHucxbLiHuOqNe4g0qd9ygRnAcus4Q5fKeTAeAu4DvgT+ZlnWnrovUUTONQqBReSkVN7QjsB9Y7wb+KtlWfO8W5WcKypnVD4fd89gJ/BX3GGyfrmJiIjISTHGxOP+Q/PlwCvAfyzLyvVmTXLuMMZEAH8E7gBGA/+0LOugd6sSkbOZxgQWkRNSORPyZcBK4H7gTsuyBioAltOpcpblKUBX4Cnck7LMM8YM9GphIiIictYyxkQbY14FlgMHgGaWZf1dAbCcTpZlZVqW9SfcE8g5gPXGmH8YY8K8XJqInKUUAovIURljehhj7L94bYwx5wMLgWeAvwA9LMua5q0aRSrD4AlAe+A14G1jzDRjTPdftjPG+BpjOnuhRBERETmDGGMijDEtf7Uu3BjzHLAWKAdaWpb1mGVZWV4pUgSwLGufZVn3AR2BaGCTMeYvxpjAX7YzxrT/9ToRkV9SCCwitTLGDAa+wP2YPcaY3sBM3CHbv4EOlmV9q0fv5UxhWVa5ZVnjgFbAx8BnxphvjTHtK5sEA5OMMe28VaOIiIh4V2UHhy+BwZWvg40xTwCbgDCgvWVZD+nRezmTWJa107Ks24BeQBtgizHmIWOMb2WTEcC7RrNsi0gtFAKLSI2MMVHAB8CNQCtjzPfAh5XrUi3L+lSTcMmZyrKsUsuy3gVSgKm4g99PcX+wexD4xBgT4MUSRURExHseBSzgPWPMI8Bm3PcM3S3L+r1lWbu9Wp3IUViWtcmyrJG458XoD2w2xvwO94TJqbgn6xYROYImhhORI1RO9vYdsAcIB3oAzwLvWpZV7M3aRE5EZeB7H/Aw7p/tICDLsqw7vFqYiIiInFbGmF64ewH/B7gXWAA8YVnWWq8WJnKCjDHdcE+SnAT8F3gE6G1Z1kavFiYiZxyFwCJyBGPM34B7gArgdWAMUArs0dAPcjaq/MNGLOAP3A7chnuCjYcty3rHm7WJiIjI6WGMiQA24u4FvBJ4HlgH5FiWlePN2kROVOVEcQG4J0r+E5AAFOAe01odeETEQyGwiFRTOYZUPu7hYgpwh79llf9/hWVZy71YnsgJqZzM8F3cwa8D9zjX/rg/9DXwZm0iIiJyehhjXgPuAgqBItz3uGXAVMuybvFmbSInqnLYvja4728dgC/gB/zBsqyXvFmbiJxZ6k0IbIxx4R7r0e7tWkTkjGDhfty/yNuF1EfGGH8g1Nt1iMgZoxzItCyrzNuFnAsqJwEKAzT5j8i54bBlWfneLuJcZYwJwj2UmIjUfxXAIcuySrxdyKlw1ofAxpiGAT4+7xaXlQ12OewVNmPO7hMSkTpRYVmmpLTM4etyLsgrKv69ZVnrvV1TfWCM6R7g43q9uLSsrcthLzXKH0QEqLAqTFlFBU67fUJBSemdeqz61DDGpDj9Xe+UFZf1sLvs5Qbd94rUdxYW5SVlLoePc01pQcm9lmXN9XZN5wpjs13s8nO9WFZc2sTu49B9r8g5wLIsU15aZnO4nNNKCorvsCxrr7drqktndQhsjHH6uZwbL+ncPvba3t2dIQH+3i5JRM4ghcUlfL98lfXu1J8OF5eWtbAs64C3azqbGWOa+zjsS+7u3yOwd9NEXA6Ht0sSkTNIZl4Bo+cvLV6wbdeqwtLSbhpDvm4ZYyLsLvumlpd3CE3s29zm9HN6uyQROU3KS8vZu3Qny0fPzS8vKe+mSexOPWNMX6eva3K/+4b4xbZLxGa3ebskETlNinILWTNxWdm6ySv2lRWXNqtPY2uf7VeygQ1DQyLvumCgAmAROYKfj4sru3c2PVKauoBrvF3P2c5lt99+UZsWPgNbNFUALCJHiAj058Hzevu4HPZWQGtv11MPXRWV2tin2QWtFQCLnGPsTjtx3ZNpOjjVx+6y/97b9ZwLXP4+j3S5trdffMdkBcAi5xjfID86j+jlCGkUFgKc7+166tLZfjXr1rN50wBvFyEiZ7ZuKcn+QX6+53m7jrOdj9MxsENcYyUPIlIrmzG0i21kgO7erqW+cfq5BjRsE6v7XpFzWFRqjMPmtA/0dh3nAquionuj1nHeLkNEvCi+U3KQsZke3q6jLp3VIbDdZvP3c7nO6nOQY/Ovryby3rRZ3i5DzlK+TufPE5nJyfH1daoH8Lng5amzGbtgmbfLkLOUv8tpwz0zudQhYzMBDh9dg+ujpe/NZt14XXPlt9l9HGDp+no6WJblcvqo70N9M+vNKSz9dJ63y5CzhMPXaWwOe6C366hLupMUOUE5BYXc9Np/iYsM59Xbrvesn7dxC+9O/Yn92YdJbtiAR4ZeSGJUJACTl6/mxa8n4fpFkPbstVfRPin+tNd/LjFGkziInK1enjqbWZu24/jFo5if3HEtdpv79evT57Fm7372Zudw/6BenNeymafd1PWbeW36PFwOu2fdExcPok1so9N3AuckXXNFznYlecX8+Nh4AqND6PfoRZ716ev3sfqzxeQfzMUV6EPKRW1I6tfcs33LD2vZNGk15aXlxHRMoP0NPbA77TW9hYjIOW3Wm1PYNncjtl/cp17//l3YKu9x5/x3KvvXp5GzP4s+vx9Ms36p1fZf8/0yVn+zhLKSMhK7NqXnbQOxq8OO/Ab9hIicoHd+nEl8gwh+Oe/NnsxDPPvlt/zzuqtpFRvDp3MX8tePv2T0vXdgrwwwWsXFVAuNRUTk6IZ1bM0N3TvWuC0pMow+zRL5YN7SGrc3j27A81deVOM2ERGp2ZovlhDUKLTafW5FWQULRk2n9VWdSeyXQvaOTGa/MJnw5AaExIVzYE0amyatpvcjF+Ab6s/CUdNZ//VyWl/V2YtnIiJy5mpzaWc6De9Z47bwhAYk90hh8bg5R2zbs3IHq75ewoV/vRL/sACmvfQty75YQJeRvU91yXKWUwgsv+nj2QsYv3ApBcUlRAQF8uAlg+mYnMj6PXsZNWkaOzMy8XE46NOqOXdfMBBn5V+yBj75Lx64eDBfzF/Cobx8ruzeiQs6tOGfX37HjvQMujRN4i/DLsXpsLNi+y6eHf8tl3XpyOfzF+PncnLboL6c1za1xprmb9zC+9Nnsz/7MAkNInjokgtoEh111Hrr0trdaew4mMHFndsxadkqz/rFW7bTJj6WNgmxAIzo3Z0xP81j5c5ddV6DiNRPXyxdzber1lNYUkJ4gD939etOu7gYNh1I551Zi9iTlY3L4aBnkwRu690Fp919zb309Q+4s193vl6xluyCQoa2a8Wglk359w+z2XUom44JjXl4cB+cdjur9+zj3z/O5qI2LZiwYi1+Tgc3dO9I/+ZNaqxp0fbdfLhwGQdz8ogLD+Xu/j1Iigw/ar2ny8VtWwLgdKw4be8pIvXHpu9Xs3XaesoKS/AN9afd9d2JahXDoW3prPp4EXn7srG5HDTulECb4V08Pba+uu0D2l3XnS0/rqX4cCFNBrcivldTlvx3Nrl7s2nYujGd7+iDzWEnfcM+lrw7m+QBLdjyw1ocPg5aDetIXPear7n7Vu5m/VfLKMjIIygmlPY39CAkLvyo9dalzC0HyUnLJqlfCjtmb/asL8kvpqywlLgeTTDGEJYUSVCjEHL2ZhMSF86ueVtI6N2M4MZhADS/pB1L/jtLIbCIALDqm8Wsm7yCksIS/MMC6XnrAGJax5O+ZT8LxszkcNoh7C4HiV2b0fWGvtgrr7fvj3yFHrcMYO2k5RRk55N6YQea9WvFT6Mmk73nEI3bJtDv3iHYHXb2rdvNT6Om0HJwW9ZMXIbT10mn4b1o0rtFjTXtWraNZZ/NIy89h9DGEfS8bSDhCQ2OWu/p0ur8dgDYXUfGdltmrSdlQCphcREAtB/WjZ9en6wQWH6TQmA5ql0ZmUxYtIw3f3cjkcFB7M86TLlVAYDdZuPuIQNpHtOI9Jxc/vzhZ3y9eBlX9eji2X/Rlu289fubOJiTw51vjWbt7r385cpLCfb34753xzJ9zTouaN8GgEN5+RwuKOCzh+9m/Z69PPrhF6TERBMfGVGtpk179/PC15P4x7VXkhITzdRVa929be+7g/3Zh2ut99fGzV7Ax3MW1Hru3z76YI3ryysq+M/EH3lk6BC2HUivts2ywPrl68r/bT+Q4QmBt+w7yOX/epVgP18Gt03l2j49PL2EReTctifrMBNXr+elqy8hItCfAzm5VFT2wrIZw+19utAsKpKMvHye+nYq36/ewGXtq/5YtmxnGq8Mv5T03Hwe/PRb1u9P55Hz+xLk68MfvpjIrE3bGdSyKQBZBYXkFBYx+pZr2LA/nae/nUrTqEhiw0Kq1bTlYCavTp/L4xcPomlUBDM3buPvE6fx1vXDOJCTV2u9v/b50lV8uXR1ref+ye+uq3Xb96s38P3qDTQMDuLqTm3o1TTxWL+lbEs/xLXvfkyQjw8DWjTh6k5tPENJiMi5LXf/YbZNX0//v16CX5g/+Rm5WBXua5ixGdqO6EJoYiSFWfnMe2Uq22ZsoOngqmvugTVpDHjiUgoP5TPjmW85tCWdLr/riyvAh5+encjuhdtJ6OW+5hYfLqQ4t4ghL15D1rZ05r0yldDESIKiq19zs3dmsux/c+lx/yDCEiPYNX8bC16bxnn/GEZBZl6t9f7axu9Xsfn72q+5l7xe8zXXqqhg5UcL6HBTT3L2ZFXb5hviR2y3JHbN3UxS/+Yc2pZBQWY+Ec0aApCTlk2j9lUBSUhcOMU5RRTnFeETqGFsRc5lh/ceYv2UlQz9+0j8wwPJTT9c7Xrb7YZ+RCY3JP9QLj88N4ENP6wk9aKqp8D2rNzJ0H+MJD8zj6//Mo6Dm/bR754L8Q3y5bsnPmXb3I0069cKgMLsfIpyCxnxxu0c3LyfH5+fQGRyFCEx4dVqyth+kDlv/8h5fxhKZHJDts7ewNQXv+HKl24iLz2n1np/beXXi1n9zeJaz/369+6uddv6H1ey/seVBEWF0O6yLiR2a1Zr21/K2pNJfOdkz+vw+AYUHi6gKLcQ3yC/YzqGnJsUAstR2Y2N0vJydqZnEhrgT/QvwoGUmGjP19FhIVzSuT0rd+yuFgKP7N2NAF8fknwbkBgVSecmicSEhwLQtWkym/cd8ITAALcM7IPL4aBdYjzdUpL5ac0Gbujfq1pNE5eu5JJO7WgZ6+71cEH7Nnw0awHr9+wlMiio1np/7do+3bm2z/FPXj5+wVJaNm5ESkz0ESFw5yaJvDv1J1Zs30VqXGM+mbOAsvJyiktLAWibEMd799xKw5AQdqRn8LfPv8Zus3Ft33o14aSInCCbMZSWV7A7K5sQP18aBgd5tjWtHFscoGFwEENSU1iz90C1EPjKTq3xd7lIiHCREBFGh7gYokPcx+iUEMu2jEwG0dTT/vruHXDa7bRpHE3nxFjmbNnBiC7tqtX0w7pNDElNoXm0u1fEoJZN+XzpKjbsTyciwL/Wen/t6k5tubpT2+P+nlzathW39epCgI+L5bv28vyUmYQF+NGqUcPf3Ld1TDSvX3sZUUGB7MrM5vkpM7Ebw9Wdj78OEal/jDGUl1WQuy8bnyBfAiKrrmFhiVXX3IDIIJL6pZCx8UC1EDjlwtY4/Vw4G7sIbhxGVGoMAQ3cx2jYJpbDuzKhV9U1t9UVHbA77UQ2jya6bSxpi3fQ4tLq19wdszaR1C+F8GT3NTehV1M2TVxF1rZ0fEP9a63315pf1JbmFx3/tW7r1PWEJzcgLDHyiBAYILZrMstHz2XVx4sAaHd9D/zDAwAoLy7D6Vc1kZbTzwVAWVGpQmCRc5yx2SgvKycr7RC+wX4ENaj6nB6ZXHVPF9QghBaD2rBvfVq1ELjt0M64/H1w+fsQFhdB47bxBDd0H6Nxu0Qydxz0hMAAHa/uid3poFGrWGLbJ7F9wWbaD+tWraZN01fTfFAbopq654po1q8VK79ezMHN+wkID6y13l9rd1kX2l3WpdbttWk1pANdr++Ly9+HtFU7mfHq9/iFBtCw+W8/3VFWVIrLz8fz2uXvvt6WFpUoBJajUggsR9U4Iox7hgxi9Mw57DjoHsLhrgsGEhkcxO6MQ7w5ZTob9+6nuLSU8ooKUhpFV9s/LCDA87WP00FYYNVrl9NBVl6+53WQry9+LpfndcOQEDJy846o6cDhHH5YuYavFlXNolxWXk5Gbh7tEuNrrbcuZOTk8tXCpbz1+5tq3B7fIII/XXERr37/I4dy8zivbSoJDSKJrAxhfg7AAZIbNuCGfj35dO4ihcAiAkBMaDC39+7KuEUr3EM4xMdwW6+uRAT6k5Z1mHfnLGZLegbFpeWUWxU0bVD9SYlQv6qbPpfDTqi/b7XXWQUlnteBPi58nVUf1qOCAjiUX3BETQdz85i2YQvfrVrvWVdaUcGh/ALaNI6utd660jSq6hw7J8bSLyWZ+Vt3HVMI/HMADpAYGcaILu0Yv3ytQmARASCwYTBtR3Rl/dcryN2bTVRqDG2Gd8UvzJ/c/YdZ/elisndkUF5SjlVRQWhC9WuuT3DVNdfmtOMTXHXNtTvtFOVUXXOd/i4cPlXXXL+IAIqyj7zmFmTmsWveFrZNq7rmVpRXUJhdQGTz6FrrrQuFWQVsnbaeAY9fWuP23H3ZLH57Jt3uGUhUqxjyDuYw/z9T8Qv1I7pdHHYfB6VFpZ72pUXu83f4Oms8noicO4KjQ+l2Yz+Wf7mAGXsyadw2gW7X98U/PJDD+7JYNHYWGdsOUFZSRkV5BZFJUdX29wupus7ZXY5qrx0uB4WHq3IFnwBfnL+47gQ2CKYg68hcIS8jl82z1rN+ygrPuvKyCgqy8mjUKrbWeuvKL88xrkMSTXq1YMeiLccUAjt8nZQUVv2O+flrp6+rtl1EAIXAcgwGtW3FoLatyC8q5qVvp/DOjz/xlysv4ZXvfqBpoyj+etWl+Pv48MX8xcxat/GE3ye3qIjCkhJPEHzwcA5Jv+j59rOo4CCu69OD6/vVPIB6bfX+2kez5vPR7Pm11vP9Y/93xLoNafvIzMvjllHvAVBSWkpxWRlXvvA6nz18N3abjX6pLeiX6h5zKK+wiEnLV9MipuaZ6I0x1PxQiYicq/o3T6Z/82QKSkoYNWM+H8xfwsOD+/LGTwtIjgznDxf0w9/l5OsVa5m7decJv09ecQlFpaWeIDg9N5+EiLAj2kUGBnBN57YM79zuiG1Hq/fXPluyis+XrqrhCG6f//7YJsw0xlSbqOh4uK+5uuqKSJW47snEdU+mtLCEFWPms/aLJXS+oy8rxy4gJD6cLr/rh9PPyZYf15K25MSvuaUFJZQVl3qC4MJD+Z6xc3/JLzyA5he3pfklNV9za6v31zZOXMXGibVfc4e+ceQ1N2t7OkXZBUx9/CsAykvLKS8p5/uHPuHCf19DTlo2gQ1DaNi6MQBB0SFEt43lwJo0otvFEdw4lMO7s4jtkgRAzu4sfIJ91QtYRABo0qsFTXq1oKSgmLnvTmPxx3Pod88Q5r03nYjEBvS/70Kcfi7Wfr+M7Yu2nPD7FOcXUVpU6gmC8zNyCIs7MlcIiAik3eVdaX9F1+Oq99dWTljEygm1Dwdx4wf3HFPdxgDHeJ8aFhvBoV3pJPdIAeDQzgz8QvzVC1h+k0JgOapdGZlk5OTROr4xLocDH6fD8+G7oKSEAB8f/FwudqVn8s3iFYQGnNxF54MZc7h9UD/Wp+1lwaat3DzgyIHNL+7Ujic++YpOTRJp0bgRRaWlrNyxm7YJsWTk5tVa769d17cH1x1nD9yuzZL5+ME7Pa9nrNnAtNXr+PvIYZ4xJjft3U+T6ChyC4t4deKP9GjehPjK3noLN2+lWaNowgMD2JWeydif5tGvVfPjqkFE6q89WYfJzC+gVaMonHY7LofdM8ZuYUkp/i4nfk4Hu7OymbRmI8F+J/fB+qOFK7ixR0c2Hchg8Y49XNut/RFtLmiVwrOTptM+NoaUhpEUl5WxOm0/qTHRHMovqLXeX7umc1uuOYEeuHO37KBjfGN8nA5W7N7LzI1befziQZ7tpeXl7uu8BeUVFiVlZTjsdmzGsGTnHpo0iCDM34/dWdl8snglvY9jPGERqd9y9x+mKKuA8KZR2J12bE67e4IHoKy4FKefE4evg9x92WyfsRFX0Mldc9dPWEHqlR05tC2D/Sv30PKy9ke0SeybwsLXp9OgVQxhSZGUl5SRsWE/ESnRFB0uqLXeX2t+cVuaX3x819yGbWK54PmrPK/3LNrBnoXb6H7fQIzNRkh8OHkHc0hfv4/IFtHkp+eyf9Uemg1xD+0W36MJS9+fQ1z3ZHxD/Njw3UrifzEchoicuw7vPUT+oXwaNm+E3eXA4ar6nF5aVILTz4XD10l22iHWT12Nb/DJ5QrLv5hPpxG9SN+yn93Lt9PhqiM/9zcf0IZpL31LTJs4GjSJpqy4jP3r9hDdsjEFWXm11vtr7S7vSrvLaw6Sj2b7ws3EtkvA4XKyd80utszZwOA/DPVsLy8rd49DbFlUlFVQVlKG3WHH2AxN+7Rk9ls/0KRXC/xDA1j51UKa/mI4DJHaKASWoyotK+e/U39iV3omDruN1LjG/N+lFwBw5/kDeOnbyXwydyHNohsyoHULlm8/8R4S4YEBBPn6cvW/R+HrdPDgped7wtNfat64EQ8PHcKrE39kz6EsfBwOWsfH0jYh9qj11gWXw0F4UNUjIAG+PjjstmrrXp80la3703HYbfRr1Zy7hgz0bFu2bSfPf/U9hSWlhAX6c17b1OMOokWk/iotL2f0vKXsycrGbrPRIjqKewe4n3q4tVdnXp8xj/HL15AcGU7vZkms2rPvhN8rzN+PQF8XN/3vM3wcDu7u34O4sNAj2jVrGMm9A3ry1qwF7MvOweVw0KpRFKkx0Uett658s3Idr06fi2VBw+BA7h3QkzaxVU9XPPH1D6zZewCA9fsP8vqMeTx7+QW0iW3Eyt37+M/UORSWlhHq70v/5k1OaFxiEamfKkrLWfvlUnL3ZmPsNsKbRtHhRvc1rPXVnVk+Zh6bJq8hND6cxl2TSF9/4tdcnxA/XAEuJj38GXaXg/Y39CCoUegR7cISI+lwU09WfrSA/AM52FwOIppGEZESfdR664Ldacf+i0esnX5OjN2Gb+W6wKhgOt7Si5XjFlKYmYfD30Vct2QS+7gnMmrYJpZmQ9ow54XJlJeUE9MpgZaXdaiz+kTk7FVeWs6ST+aQnXYIm91Gw5QYet3u/qN+1+v6MPfdaaz+dikRiQ1I7pHC3rW7T/i9/EIDcAX48sld/8Xh46TnbYMIbRx+RLvIJg3pdcd5LPjfTHL2Z2F3OWjYvDHRLRsftd66sm7Scua8/SPgHrKi9x3n0ahVnGf7lGfHs399GgAHN+1j7rvTuPDxK2nUKo7Y9om0ubQzk/72JeWlZSR2bUrHq45/viM595gTfaTyTOCw25+7eUDvPylEO/ut2L6LZ8d/y2cPH9ujEiLHY9a6jbz07ZSph/MLBnu7lrNZsJ/v2scvHtSqZaOo324sZ7TVe/bx7x9n88Et13i7FKmHRs2YXzR57cY/Wpb1mrdrqU98An2/bXttt0viuif/dmM5o6Rv2MeSd2dz4Yu65srJydqRwdx//7C1JL9YXaxPMaevM/uql24OqcsxYOXU27duNz+NmsKIUbd7uxSpB1Z/t5Rln89/ray49P7/b++uw6O60geOf8cn7kbclWBBgrtbW2iLtIW6bW27bfe31rVut7J1NyoUCoVCcYcASbCQQAIJEeLuntHfHwMThiQQWgqUns/z8DzMvWfOPXcm886d95773us9lqtFer0HIAiCIAiCIAiCIAiCIAiCIPxyRBJYEARBEARBEARBEARBEAThJiaSwMINoX+gnygFIQiCcI309fESpSAEQRCuEbcIL1EKQhAE4RrwivIVpSAE4RJEElgQBEEQBEEQBEEQBEEQBOEmJpLAgiAIgiAIgiAIgiAIgiAINzH59R6A8MvbdeIUq5OOUFhdg7VSSYinO4tGD6evv4+5zdbjJ3ll3Wb+On82Y2MiOVFQxAvfrDatNEK7VotaqTC3/+Kx+3n5h42cKi5FJu08l9A/wI+XFs27Zvt2Iymva+CVdZs5XVKKu4M9T0yfxKDggG7bNre18+6WXRzOyQNg9uABLBk30rx+wRsfUNfcilQqASDa15tX774DgOUJSSzfn2RuazAY0ep1rP3D73Cwsf6F9k4QhN7am5XH+tQMiusbsFIoCHR15va4WKL7eJjb7DydzVu7DvLclDGMCg0ko7SCFzfsAMBohA6dDrWi8yv6vYVzeWPHfrIqqixibl9vT/46c+K127kbyDfJKSTnFVJU18AdcbEsHDqgx7YnistYeSSN3KoabFVKPrtn/hX11dDWzscJhzhWUAwSCXH+Pjw7efQvsl+CIPw0Rcl55GzPoKm8AblagaOvM2EzY3EN7Yy9BQeySfniIIMfHoPP4ECqz1SQ+KYp9mIEvUaHTNUZeyf+cy7HPttPbW4VElln7HWL8CT+iZs/9rbXt3L8qyTq86tpb2hj8n9vw8bVrsf2p35Ioex4IU1lDYTPjCVyTmcszdp0gqxNJ8yPjQYjBp2e6W/cicpOTVtdC6nfJFNzpgKZSk7EzFgCx0b8ovsnCMJPk3swk/RNKTSU1qGwUuDs70a/uUPwjPA2t8nel8H+D3cw9onpBMWHUZ5ZwvaX151ba0TXoUOu6swv3PraXSS8v42qnHIkFxzrekX7MOkPc67Rnl0/rXUtHPx0F9V5FbTVtzD/7aXYuTn02L6pqoH9H+6gKqccW1c7hi0Zh3dfP/P6tsZWDn25j+LUsyCR4NM/gLGPTwPgyPL95CVmoWnToLRRET6+L/1vGfKL76NwYxBJ4Jvc6sTDrDhwiKdmTmZwSCAKmYzDOWc5mJltkQTenpqOvZWabanpjI2JJNbfl81/egYwJTcXvvkhG154CpnMcvL4E9MnMWNQv2u6Tzeqf33/I1G+ffjP4nkcys7jxVXr+PqJB3HsJjH73tZdtGu1fPvUw9S3tPL7L1fi4WjPtAGx5jb/Xnhbt0nkRaPjWTQ63vx42Z4DnCgoEglgQbgBrDuewfcpJ3l0bDwD/fogl8pIKSzh0NlCiyTw7sxc7FQqdmfmMio0kOg+Hqx+aDEAFY1N3P/VGlY+sNAi4Qvw0OhhTIkOu6b7dKPycrBnyYg4tqZnXbatWiFnYmQoo0MDWX3sRJf1l+vrpc27CXV35bN75qOSyymorfvZ4xcE4erJ3pbBmS0n6X9XPB4xfZDKZFSkl1B2vNAiCVyYmIvCRkXhwVx8BgfiGubB7PdNsbeluontz69h5jsLkV50vNtv0TACRv8GY69EgkeMN2HT+5Lwn82XbW7jbk/0/DjO7u0aS8NnxBI+o/M49/T641SfqUBlpwbg6Cf7cfB1Yugj42gqq2f/K1ux9XTALcLr6u2PIAg/W/qmFE78eITh903AO9YfmVxKcVoBhcfyLJPACadR2arJSThFUHwYnhHe3L3MdA+gpqoGVj/xBYs/e6RLvB22ZBzh42Ou6T7dCCQS8OnnT785cWz826rLtt/7zhbcQ72Y/Pxcio+fZc+bG7ntjSVY2ZtyArv/txHXYA9uf+c+5Eo5dUU15ueGjYum/23DUKgVtNQ2s+2ltTh6OxMwJOQX2z/hxiGSwDex5vYOvthzgOfmTmd0VLh5+fDwEIaHd37Ay+sbSCso5G+3z+Ufq9dT29yCs63NVR3L1uMn2XQsjQhvL7amnsTeSs0fb51JcU0dX+zej1av56HJY5nSvy8AGp2Oz3YlsC8jE61Oz8jIMB6dOh6VQkFTWzv/WbuR08Wl6A0GYvx8eHrmZNwc7AF4+otv6evnw/GzheRVVBHl24c/3zbrF02SFlXXkl1WwSt3345KoWB0VDhrko6ScCqL2YO7zk5LOpPLy4vno1Yq8FQ6MH1gLFtTTlokgXvDaDSyIy2Du8cOv1q7IgjCT9TSoWH54eM8OWEkw4P9zcuHBPoyJNDX/LiysZn0knKenzqWV7bto661DSdrq6s6lp2ns9mekU2ohyu7Tmdjq1bx+0mjKalvYPmh42j1BpYOj2NCpOm7QKvX81VSCgdy8tHp9QwL8uP+UUNQyeU0t3fw+o79nKmoQm80EunpzmPj4nE99z3xx7VbiO7jwYnicvJragn3dOfZyaNxsFJf1X262Pmx78vKu2zbMA83wjzcSC0qveK+UgpLqG5u4aVbppqT8sFuLj912IIgXGXaVg2n1x9n0NKReA/qjL1e/X3x6t8Ze1urm6k+U86Qh8dy5KN9tDe0oXa4urG34EA2+fuzcQp0pfBANgobFXEPjKa5vIHT646j1xmImR+H/whTzNFr9Zxam0LJ0XwMOj1eA/yIvXMIMqUcTUsHRz/dT11eFUaDEecQdwbcFY+Vsyn27n9lCy6hHlRlltNYVItzsDtxD442J1WvBrWDFUHjIzDoDb1qf36/ipMvHZeNRiNFSXmEzzJNJNG1a6nOKmfII2ORyqU4+DrjHRdAwf5skQQWhBuIprWDlNVJjHp4kkXC0G9QEH6DgsyPm6saKT9dzPgnZ7Dn7c201bdg5Xh18wvZ+zLI2p2OW7An2fsyUNqqGfPYVBrL6khZlYRep2fwwlGEjokCQK/Vcey7RM4mZ6PX6vEfHMzQu8cgV8rpaG43z0I2GAx4hPVh+H3jsXExXfmw+R+r8YjwpiyjiNrCatxDvRj7+DTU9lfvO8TK0YbIyf16FW8byuqoOVvF1D/eilwpJ2BoKBlbjlNwKIeISbGUnCigpaaJaX+dh/TcsatLoLv5+Q59nC36k0glNJbXX7V9EW5sIgl8EztVVIJGp2NUxKVnLuxITSesjxejo8Lxd3Vh14kM5g+/+pcDnC4pZfqgWNY9/wTL9hzgX9//SHxYCF8/+SBp+UW8+N06RkeGY6VS8vGOvZTVNfDxw0uRy6T86/sNfLU3kQcmjcFgNDJ1QF/+On8OBqOBV9Zt4e3NO/nnglvN29p18jQvL56Pu4MdL3yzmu8SD/PgpLFdxlRR38j9H3ze45ifmjGZCbFRl923/KpqvJwcsFapzMuCPN3Jr6zu8TlGo9Hi/2crqyzWv7RmAwajkRAvDx6ePI5gT/eLu+BEQTF1LS2Mjgzvsk4QhGsrs7wSjU5PfJDfJdvtzsolxN2VESEB+B5OZV9WHnMHRF/18WRVVDE5KpTl9y/g28OpvLJtH0MCffn4rts4WVLOy1v2MDzYHyulgmWJRylvaObtO2cjk0p5bfs+Vh5O457hgzAYjUyMDOH5qWMxGI28vesAH+5L5s8zJpi3te/MWV6cNRFXOxte/HEHPxxPZ8nwuC5jqmxq5okV63sc88Nj4hkbHtTj+ushq7wKb0cH3tx5gGMFJXg42HLviMH09fa83kMTBAGoza3EoNXjNfDSsbcwKRenAFe84wLI/DGVouQ8Qqdc/dhbl1dFwKhQZry9gNPrUjny0T48+/ky6T+3UZ1VzuH39+A9yB+5WkHG90dpqWpm/N9mI5FJOfrJPjI3pBF92yCMRiP+I0IY8vBYjAYjKV8cIG15MsN+1xl7iw+dJf6piVg725D45g6yt6UTM69r7G2taWb333qOvf0Wx+M77NrF3pozFbQ3tpmT9uZD4ouOjRtL6q/ZmARBuLzKM2XotTr8B196xmjO/tO4BnkQMDQUR29ncg9mETNj4FUfT1VOOWHjYlj4ycMcX53M3re34DswkHlvLqH8dAm73thIwNAQFGolR749QFNlI3NfXoRUJmXvu1tIXZNM3IKRGI1GQsdEMe7J6RgNRvZ/tIOkZXuY+PvZ5m3lHcxi8gtzsXGxY/vLP3By0zEGLxjZZUzN1Y2se/6bHsccf+94gkf8vFI3dcU12Lnbo7BSmpc5+7tRV2ya7VuZXYZDHyf2v7+d4rR87NwdGLxoFF5RnVeCp60/QtoPh9F1aLF1tyd4hMgn/FaIJPBNrLGtDQdr6y4lHC62PS2DOUNMs1Un9I1iW2p6r5PA727ZyYfb95gf3zJkIPdO6L5Oopejo3mm67iYSJYnJHHX2BEo5fJzpSqklNTWEezpzuZjJ/jk0aXYn5sdt2h0PP/+fgMPTBqDg7WVxczmxaPjeWbZCottTR3QF19X0xmusdERJGbldDsmD0d7NvzxqV7t66W0aTTYqFUWy2xVKqqbmrptPyQkkBUHDvHCLdOpa25ly/GTdGh15vV/um0WoV4eGI2wNvkoz329ii8fvx/bi2bWbU89yZgoU+JcEITrq6m9A3srVZcSDhfbnZnDjL6mg78xYUHsyszpdRL44/2H+OLgEfPjmbGRLB7W/UG1h70tE6NCARgVEsiqoye4c3A/FDIZA/28kUtllDU0EujqzLaMbN5ZMBu7c3Hs9kGxvLo9gXuGD8LeSs2IkABzv7fHxfJ/67ZZbGtiZAjeTqa6ZSNDAzl8trDbMbnb2bLywUW92tcbRU1zK8eLSvnd+OE8OWEkibn5/HvTLj6667ZffLazIAiXp2npQGmr6nJJ8cUKE3MIGm+KvT5DgyhMzOl1EvjEikOkr+qMvUETIom6pfvYa+1qi/9IU+z1HhJI1qYTRMzqh0whwyPGG4lcRnNlIw6+zuQnZDP+77NR2ppib9j0WI5+kkD0bYNQ2arxjgsw9xs+M5YDr1rGXr8RIdh5mmKvd1wgZWndx15rF1tmvnvjxN7CxFxzIhww1RQNcSdzQxoxt8fRVNpA6bGCqzqrWRCEn6+juR21ndVl423O/tNETjL97g8aHk52wqleJ4GTv9zLkeUJ5seRU/oz6Pbur3q1c3cgbKwpjgfGh5G27jADbh2KTCE/V6pCRmN5Pc7+bpzZk87c/y5GZWuKK/3mDGbvu1uJWzAStZ0VAUNDzf32mzuYLf9aY7Gt0DFROHg5mbY1LIzCY91f8WDras/izx7t1b7+VLp2LUpry9yDwlpJa20zAC21zZScKGTkgxMZ9fAk8g/nsOv1H5n3xlLz7OV+cwYTOzuO2vwqCo7mdulPuHmJJPBNzN7KiobWVvR6Q4+J4PTCYsrq6xkfEwnA+NgoPtudQE5ZBSFeHt0+50KPT5vY65rATrad5RhUctOf3oVlJ5QKOW0aLfUtrbRrtTz80ZedTzYa0Z+bHdCu0fL+1l0czjlLc3s7AK0dGvQGgzn5cmG/KoWCNo2mV2PsraXvfkpFQyMALy+ej5VSSWuH5TZaOjqwUnafnH182kTe2byTu97+BHsrNeP7RrL75Gnz+hi/zrN0C0fHsy0tnROFxRZlPDq0WvadyrKYAS0IwvVjp1bR2NZhEYsudqqsgorGZkaHBgKmJPDXySnkVdUQ1IsSAw+OGtrrmsCOF5SYUMplABZlJ5RyGW1aHQ1t7XTodDz93QbzOiNgOB9ztTo+PXCYlMISmttNca5Nq7XYzwu3pTrX79X06LfrqGoyHdi+OGuSRX3lX5pSLsPdzpbJUabXfXRYEKuOnuB0WSXDLjPrWxCEX57SRoWmuQOD3tBjYqImu4LW6mZ8hphir+/QIE79kEJ9YQ2OfpePvbELhva6JrDqgsuDZQpT7L2w7IRMKUPXoUPT1I5eo2PvPyxjr9Fgir26Dh0nvztMxckStK2m2Ktr12I0GMw3TerSb/vVjb2/BL1GR8nRfIb9brzF8sEPjCZ1eTJbn12NjZsdvsOCaCptuE6jFAShOypbNe1NbZeMtxVZpTRVNhA43DRpK3hEBMdWJVKTX4lLQNcrWy827J6xva4JrHbozC/Ilab8woVlJ2RKOdp2Le2Nbeg6dPz4f9+a1xmNF8ZbLYe+3kdxWgGalg4AtG0aDAaDuZzChf3KVXK0HdpejfGXIFcr0LZZ5h60rRoUalPuQa6UY+tmT9g40+sYNDyctHWHqThTin9csPk5EokEl0B3ik8UkPJ9EkPvGnPtdkK4bkQS+CYW5euNUi7nQOYZxkR3f8nBttR0MMIDHy6zWL49Lb1XSeBfgoO1NSqFnM8fuw83+653IF6deJiimlref+AunO1sySmr4MEPl5mOnK9QRX0jS9/7tMf1z8yawsTYrrNEvnj8fovHRdW1lNbV09rRYS4JkVtRyYS+3ZeSsLe24k/zZpkff7pzHxHePdc8k2BZPgJg/+kz2Fmp6R8gkhCCcCOI8HRHKZeRnFdoMXP2QrtP5wLwxHc/Wi7PzO1VEviXYG+lRimX8d7Cubh0Uw9+XWoGJXUNvD5vBk421uRV1fDkBQnjK1HZ1Mxj367rcf1jY+MZGx7cZfn7C+f+pO1dDQGuThzOL7pu2xcE4dKcg92RKmSUHS+0mDl7ocLEXIxG2P3ij12W9yYJ/EtQ2qqRKWVM+OdcrJy6xt6c7Rk0lzcw9s8zUDtYU19Yw56/b8BoNB0XXonWmmZ2/mVdj+sH3B2P77CusfeXUJpSgNJGiWu4ZUkda1dbhj850fz4yMf7cApyvSZjEgShd9zDvJAp5BQczSXwgpmzF8pOOAVGWP/CcovlOftP9yoJ/EtQ21khU8q55dW7sXG27bI+fVMKDaV1zPrnnVg72lCTX8n6P377k/ILzdWNrH326x7Xj7h/AsEjf145CCcfF5oqG9C2acwlIWoLqwk+l3h39nOlMOXy98w4z6g30FQhTrr9Vogk8E3MVq1i6biRvL1pBzKplLjgQOQyKcfy8kk9W8jScaPYm5HJM7OmMCys88Av4dQZvt53kIcmjbtsKYlfglQqYcbAfry/dRdPTJ+Ek60NVY1N5FdWMTgkiFaNBpVcjq1aTWNrG1/uPfiTt+XhaM/mPz3zs8fs6+pMiKc7X+49yH3jR3MoJ4+8iir+fkf3tXVKauuwVauxVas4mnuWjcfSeGPpAsCUmK5qbCS8jxdGo5G1h47R0NpmMTsYTAn8yf1ikEiu9KeAIAi/BBuVkkVDBvDhvmSkUgkDfL2RS6WkFpdysricRUP7cyDnLI+Ni2ewf+fnOTG3gJVH0lg6Iu6ypSR+CVKJhClRYXxy4AgPjx6Ko7UVNc0tFNTUM9DfmzaNFqVcjo1KSVN7ByuOpP3kbbnb2bL6ocVXZdw6vQGD0YDh3JUiGp0OmVTa7WtoMBrR6fXoDAaMmG4+KpFIUMhkl+0rPsifzw8eZdfpHMaGB5GcV0hNSyuRXtfnh4wgCJYU1koi5wwgbXkyEqkE92hvpDIpladLqc4sJ3Juf0qOnGXAPfF4xnbG3tJjBabyA/PjLntp8y9BIpUQMCqMkyuP0G/RUFT2VrTVtdBYUo9HjDe6di0yhRyFtRJNcweZP/702GvtYsvs939a7NVrdebZcgadAb1Wh0zR/U9Ig86A0WjAaDRi1BvRa3VIZVLzzGWAwoO5+A4P6XL82lhaj5WTDTKFlOIj+VRmlDLxX7f8pDELgvDLUFqrGDg/nqTP9yCVSvCO9Ucqk1KSXkh5RjED5seTn3yGEQ9MwGdAoPl5+YdzSF1ziMELR123eBs+PoZDX+0jfuk4rBysaaltpq6oGp9+AWjbNMiUcpTWKjqa2zm+5tBP3patqz13L3vsJz1Xp7kg3mr16DQ68wznCzl4OeHs78bxNckMvH04xWn51BVW4f/0DAD8B4dwePl+svedInhUBAVHcmmpbcYjrA9Gg5Gs3ScJHBaG0kZFdW4Fp3ekETtn8E/eZ+HXRSSBb3Lzhw/BydaGbxKSeGnNRqxUSsK8PFg0Op4DmWdQyeVM7h+D/NwPYYDpA2NZtvcAh3PyiA+/dNH3tzfv4L2tu8yPfV2c+ejhJT973A9OGstX+w7y+Kdf09DahqudLbMHD2BwSBC3DYvj32s2MPeVt3G1s2V+/BAOZmb/7G3+XH+ZN4f/rtvE7Jffwt3Bnhdvn4ujjekSlRMFRbzwzWpzwjm7tJz3tu6mub0dHxdn/nTbTALd3QBo1XTw5sbtlNbWo5TLCPb04OXF83G44HLrqsYmjp8t4KkZk6/9jgqC0KO5A6JxtFaz6sgJXt++HyulnBA3V26PiyU5rxClXM748BDkFxwAT4oKZfnhVI4VlDAk0PcSvcNHCcl8euCw+bG3owNv3jHrEs/onSXDB7HySBrPfr+JxrYOXGytmRYTzkB/b2b3i+K17ftY9NlKnK2tmTsgmuS87utOXkvv7DnI7sxc8+NVR0/w5IQRTIwMJaO0ghc37DAnnDNKyi3qGN/24TfE9PHgP7dOu2xfdmoVf5kxgQ/2JvFhQjI+jg78ecYEUQ9YEG4goVOiUTuoydp4gqOf7EeuluPo70r4zFjKUgqRKuX4xYcglXfGXv9RoZxen0pFegle/S4de9OWJ3NiZWfstfN0YNxff37sjZ4/iMwf09j7701omjtQO1kTNDYcjxhvgidGcfSTfWx6ciVqR2tCJ0dTdvzax94fH+68wdHOP/0AwC2fLQHg+FeJAAy421Sv8/iXBylM7IylWZtOMHDpCHON5La6Fqoyy+i3eFiX7VRmlJC18QR6jR4HP2eGPz1J1AQWhBtQzIyBWDlYk/rDYfa9txWFWolLoDv9bhlC4dFcZEo5IaMikco78wthY6M5vjqJ4rR8/AZe+iaUycv2cOirfebHDn2cmPPSwp897rgFI0lde4gNf11JR1M71k42REyKxadfANHTBrD33S18++BHWDvZEDNjIIVHcy/f6VX21T3vmv+/5vdfAXDviqcAOPipKecy4n7TzUHHPjGN/R9sZ/n9H2Djas+4p2ZiZW/KPahs1Ux8djZJn+8m6Ys9OPRxYuKzs1HbW2E0GCk4ksvRlQcx6AxYO9kQNaU/UVP6X7sdFa4rycWXmP+ayGWyl5eMG/n8otHx13sogiDcwBJOZfG/Ddt2NrS0TrreY/k1s7dSZ/xlxoQoMQNSEIRLeW9PUvvWjKznjEbjO9d7LDcTla16Q+zCoTN9h136B7QgCDevuvxqDr6+PVfT0nHpmTrCz6ZQK+rn/W+Jg3U35QMEQfhtOLnxGCmrk97RdWifuN5juVqu/Vx8QRAEQRAEQRAEQRAEQRAE4ZoRSWBBEARBEARBEARBEARBEISbmEgCC4IgCIIgCIIgCIIgCIIg3MREElgQBEEQBEEQBEEQBEEQBOEmJpLAwk1l/N/+S0lN3fUehiAIwm/CrHeXUVrfeL2HIQiCcNP74b5lNFeIeCsIgnAtfL7gTRrL66/3MAThqpNf7wEIN45dJ06xOukIhdU1WCuVhHi6s2j0cPr6+5jbbD1+klfWbeav82czNiaSEwVFvPDNatNKI7RrtaiVCnP7Lx67n5d/2Mip4lJk0s5zDv0D/Hhp0bwrGt/4v/2Xr594EG8Xp5+3o1eosbWNV9dv4VhuPvbWVjwwcQwTYqO6bXu2oooPtu3mTFkFja1t7P778+Z1Gp2OtzZu51heAU1t7Xg7O3LfxNEMDQ02t9mbfpplew5Q1diMu4Md900YzcjIsF98HwVBuPb2ZuWxPjWD4voGrBQKAl2duT0ulug+HuY2O09n89augzw3ZQyjQgPJKK3gxQ07ADAaoUOnQ63o/Cp/b+Fc3tixn6yKKouY29fbk7/OnHhF45v17jI+WnwrfRztf+aeXpmm9g7e3n2Q44Wl2FupuHvYIMaGB3XbtqCmjs8OHCGnqoam9g42PL7EYv38j76xeKzR6ZkeE85DY4ZR0djE/V+tsXj9bhvYlzsH97vq+yQIwvVVlJxHzvYMmsobkKsVOPo6EzYzFtfQznhbcCCblC8OMvjhMfgMDqT6TAWJb5riLUbQa3TIVJ3xYuI/53Lss/3U5lYhkXXGW7cIT+KfuLJ4+8N9y5j00q3YelzbeKtp7iBl2UEqM0pR2qqIvm0QvsO6j7cAOdszOLPlJHqtnj4D/el/VzwyhQyAxtJ60pYnU19Qg8pOTcz8OPoM9AfAoNNz5OME6vOraa1pYeQfpuAW4XVN9lEQhGsv92Am6ZtSaCitQ2GlwNnfjX5zh+AZ4W1uk70vg/0f7mDsE9MJig+jPLOE7S+vO7fWiK5Dh1zVmVe49bW7SHh/G1U55UguOMb1ivZh0h/mXNH4Pl/wJvPeWIK9p+PP2Msr19Hczv6PdlB6sgCVnRVxd44geEREt22z953i1LZUGsvrUVgpCR4ezqA7RyCVSdFrdSR+vofS9EI6mtux93Bk0J3D8e0faH5+XtIZjn+fREttM7Yudgy6Yzj+g0Ou1a4KNzCRBBYAWJ14mBUHDvHUzMkMDglEIZNxOOcsBzOzLZLA21PTsbdSsy01nbExkcT6+7L5T88AUF7XwMI3P2TDC08hk1lOMn9i+iRmDPp1/rB+a9MOFDIZa/7wODnllfzf8tUEeboR6O7Wpa1MJmVsdARzhgzkLyvWWqzTGwy4Odjz5tKFuDvYcyg7l3+s+pHPHr0XTycHqhqbeGntRv654FaGhARxKDuPv69ax7dPPYyTrc212l1BEK6Bdccz+D7lJI+OjWegXx/kUhkphSUcOltokQTenZmLnUrF7sxcRoUGEt3Hg9UPLQYwJzFXPrDQIuEL8NDoYUyJ/nWeQPpwXzJyqZSv772DvOpa/rFxJ4GuTvh3cwJQJpUyMjSA6X0j+Pfm3V3Wn3+twHSS8q7Pv2NESIBFm+5eP0EQbh7Z20yJy/53xeMR0wepTEZFegllxwstksCFibkobFQUHszFZ3AgrmEezH7fFENaqpvY/vwaZr6zEOlFx7j9Fg0jYPSvM96mLU9GKpcy/Y07qC+qJemtnTj4OmHv3TXeVqSXcGbLSUY+OwW1ozWH3tvN6fXHiZkXh0FvIPnd3QSOCWfk7ydTnVVB0tu7GPc3R+w8HQBwCXUneFIUhz/Ye433UhCEayl9UwonfjzC8Psm4B3rj0wupTitgMJjeZZJ4ITTqGzV5CScIig+DM8Ib+5e9hgATVUNrH7iCxZ/9kiXmDtsyTjCx8dc0326WhI/341MLmXBhw9Sk1/FjlfW4+znhpOvS5e2Oo2WoXePwS3Ek/bGNna+9iPKjcfoN2cwBr0RGxdbpv91HrYu9hSlnmXPW5u55ZXF2Lk50FLbTMJ7W5nw7Cx8+gVQfDyf3W9t4va378XKwfo67LlwIxFJYIHm9g6+2HOA5+ZOZ3RUuHn58PAQhod3ni0qr28graCQv90+l3+sXk9tcwvOVzk5WVJTx6vrt5BbXoFMJmNgoD9/vX0OT36+HIAHPvgCJPCHOdMYFxPJygOH+D7pCBKJhHvHj7qqYwFo02jYfzqLzx69DyuVkr7+PsSHh7IjLYMHJ43t0t7P1QU/V5duS1JYKZUsGTfS/Dg+PAQvJwfOlJXj6eRAdWMTtmq1eWbwsLBg1AoFpXX1IgksCDeRlg4Nyw8f58kJIxke7G9ePiTQlyGBvubHlY3NpJeU8/zUsbyybR91rW04WVtd1bGU1jfy9u6DnK2uRSaV0s/Hi+enjuWFtVsAeGLlj0gk8MT4EYwKDWRtSjrrUjOQAIuHDbyqYwFTojYxt4B3F8zBSqkguo8HQwJ92ZOVy5LhcV3a+zg54OPk0KuSFAdzCnCwUlsk2QVBuLlpWzWcXn+cQUtH4j2oM9569ffFq39nvG2tbqb6TDlDHh7LkY/20d7Qhtrh6sbb5opGUpYdpKGoFqlMilukF0MeHkvCy6Z4u/vFH0ECA5eMwGdIIGe2ppOz3RRvI2+5+vFW16Gl5FgBE/4xB7lagWuoB179fClMyiVmXtd4W5iYg//IUHOCOHxmP45+kkDMvDiayxpor28lZHIUEokEt0gvXELcKUrKJeqWgUjlMkImRQMgkUqu+r4IgnBj0LR2kLI6iVEPTyJgSGcewW9QEH6DOq8yaK5qpPx0MeOfnMGetzfTVt+ClePV/b3bWF7PgY92UFNQhVQmpU+ML+OenMGmv5uuYl73wjeAhJEPTSQoPpyTG46SvjkFkDDo9uFXdSwA2nYtBYdzuOXVu1ColXhGeOM3KIicA6cZvGBkl/aRkzon0Nk42xI8IoKyU0UAKNQKBs6LN6/3GxiEnZsDNXmV55LATShtVOaZwb4DA1GoFDRV1IsksCCSwAKcKipBo9MxKuLSsxh2pKYT1seL0VHh+Lu6sOtEBvOHD7mqY/l8937iggP435IF6PR6skrLAXjr3kWM/9t/+eSRpeZyEIez81ideJjX7rkTTycHXv9x6yX7fnPjdnadPNXtOg8Hez599N4uy4tr6pBKpPi6OpuXBXu6kZZf9FN30ay2uYWimloC3FwBCOvjiZ+rCwczsxkWFkxSVg4KuYwgj64zjgVB+PXKLK9Eo9MTH+R3yXa7s3IJcXdlREgAvodT2ZeVx9wB0Vd1LMsPHWeAXx9eumUqOr2e7MoaAF6+dRqz3l3G23fONpeDOFZQzA/H0/nX3Cl42Nvyzu7ES/b9/t4kEs7kdbvOzc6WdxZ0vXSvpL4RqUSCt5ODeVmgizPp574Lfo7dmTmMDw9GIrFMQNz75fdIgP6+fVg6Ig4HK/XP3pYgCDeG2txKDFo9XgMvHW8Lk3JxCnDFOy6AzB9TKUrOI3TK1Y23p9cdxyO6D6P+MBWDXk9dvinejn5hGj/ct4zxL842l4OoOFlMzrZ0Rv5+CtZuthz/8tLxNvXrJIoPdR9vrVxsmfD3rvG2ubwRiVRinqkL4ODrTPWZ7uNtY0k9Xv39LNp2NLbT0dyOsZv2Row0ltRfctyCINxcKs+UodfqLlt2IGf/aVyDPAgYGoqjtzO5B7OImXF1T3YdW5VIn1h/pv1lHnqdnuq8CgBm/G0+ny94k7kvLzaXgyhOzefkxhSm/flWbN0cOPjJzkv2nfjZbvISM7tdZ+Nizy2vLO6yvLGsDolUgoNX55UWzv5ulJ8u7tX+lGcW4+jTdcYwQFt9C43ldeb1rkEeOPZxpvBoLj4DAyk6lodUIcPJT+QVBJEEFoDGtjYcrK27lHC42Pa0DOYMGQDAhL5RbEtN73US+N0tO/lw+x7z41uGDOTeCaO7tJPLpFQ0NFLT1ISbg71FKYqL7c3IZMqAvgSeS5LeM3Yku0+e7rH9UzMn89TMyb0a73ltGg02apXFMhuVijaN5or6uZhOr+elNRuY0i8GPzdTsJZJpUzuF82/12xAo9OhkMn42+1zsVIqf9a2BEG4sTS1d2BvpbpsCYLdmTnM6GuqEzYmLIhdmTm9TgJ/vP8QXxw8Yn48Mzay25m7MqmUqsYWaltacbW1ueQs2QM5+UyIDDGXZVg4pD8J2Wd7bP/o2HgeHRvf4/rutGt1WF9Q/w3ARqWkTaO9on4uVtnUTHppBb+bMMK8zF6t5n/zZxLk5kxjewcf7kvm9e0J/GPOlX1PCIJw49K0dKC0VXW5nPhihYk5BI03xVufoUEUJub0Ogl8YsUh0ld1xtugCZFEdTNzVyKT0lrTQnt9K1bONhalKC5WfCQfvxEh2PuY4m3E7P4UH+o53va/K57+d11ZvNV16FBYWcZbuZUSXXv38VZ/UXuFlen4VNeuxc7TAZWdmuyt6YRMiqYqs4zqrArcIjyvaEyCIPy6dTS3o7azumzMzdl/mshJsQAEDQ8nO+FUr5PAyV/u5cjyBPPjyCn9u525K5XLaK5upLWuGRsXO4tSFBc7m3yG0LFROPmaJmcNmDeMvMSsHtsPv288w+8b36vxnqft0KK0tswrKK2UaNsun1c4szeD6rxKRj4wqcs6g07P3ve2EjI6Ekdv08Q1qVRKyOhI9r67Fb1Wh1QuY/yTM1CoFV2eL/z2iCSwgL2VFQ2trej1hh4TwemFxZTV1zM+JhKA8bFRfLY7gZyyCkK8Ln9p7ePTJvaqJvBDk8by+e79PPrJ19iqVdw+fAjTBsZ227amqZkwr86DS49f4OZFVkolrR0dFstaOzQ/KzFrMBj5z9qNyGUynpjRGciP5ebz8Y69vLFkAaFenpwpK+fP367h5cXze/UaC4Lw62CnVtHY1oHeYOgxEXyqrIKKxmZGh5ou4xoTFsTXySnkVdUQ5Nb9LIALPThqaK9qAi8dPohvDh3n96s2YqNWcUv/aCZFhXbbtrallZALtu1ub3vZ/q+UWiGn9aKEb6tGg5Xy5x207snMJdLLHU97O/MyK6WCUA/Twb6TtRUPjx7K3V+solWjwVqcfBOEm4LSRoWmuQOD3tBjUqImu4LW6mZ8hpy7bHZoEKd+SKG+sAZHv8vH29gFQ3tVEzhm/iBO/XCcvf/aiMJGRcjkaAJGdR9v2xtacQro3La1y9WPt3KVvEvCV9euQd5DkkCmkqO9oL223ZS4kKsVSOVShj0+nrRvD3FmSzpOAS74DA5AKpdd9XELgnDjUtmqaW9qu2TMrcgqpamygcDhpjKUwSMiOLYqkZr8SlwC3C+7jWH3jO1VTeDBC0eSsiqJH/+8EpWNipgZgwgb1/3Jvda6FlyCOn9v27raddvu51CoFGguSvhq2jTmE2o9KTiSw9EVB5n6p1tR21uWKTIajOx7fxsyuYz4JePMy0tOFnLk2wNM/8s8XALdqT5bwc7XfmTy83N79RoLNzeRBBaI8vVGKZdzIPMMY6K7vzvlttR0MMIDHy6zWL49Lf2qJiid7Wx5ds40AE4WFPPsVyuJ9fc1l4CwaGtrQ2VjZx3IyoZL14R8Y8M2dpzI6Hadh4M9Xzx+f5flPi5O6A0Gimtq8XExnVnLragkwN211/t0IaPRyKvrN1PX3Mp/Fs9DLus8OM4pr6Cvvy/h3qa7JUd4exHp04djefkiCSwIN5EIT3eUchnJeYVdblJ23u7TuQA88d2Plsszc3uVBO4tJxtrfjfeNDs2o7SCv6zfRnQfD3MJCIu21tZUNbeYH1c1tXRpc6H39iSy9xLlIN5fOLfLcm9HewwGI6X1jeYxnK2uw8/ZsZd71L3dmbnMG9T30o3OlYkwdnddsyAIv0rOwe5IFTLKjhfiHRfQbZvCxFyMxnM1eS9a3pskcG+pHawZuMQUb6uzKzj42jZcwzzMJSAubtta2xlj22ovHW+Pf5VIUXL38dbaxZaJ/5zbZbmtpz0GvZHmikbzGBqK6rDr49htP/bejjQU1eEz2JQsbyyqQ2WvRmVrKqHj4OvM6Oenmdvve2kTfsPFnegF4bfEPcwLmUJOwdFcAod2f5IrO+EUGGH9C8stlufsP31VE5TWjjaMfHAiAOWZJWx7aS2ekd7mEhAWbZ1saKlpMj9urm7q0uZCBz/dRe6B7stB2Lracetrd3dZbu/lhFFvoKGszlwSorawuscSD2AqU3Hwk11Mem4Ozn6W+Qej0ciBj3fQ1tDK5OfnWpx0qy2owiPCG9dgUw7BLdgTtxBPStOLRBJYEElgAWzVKpaOG8nbm3Ygk0qJCw5ELpNyLC+f1LOFLB03ir0ZmTwzawrDwoLNz0s4dYav9x3koUnjLltKorf2ZmQS7dMHNwd7bK1USJAgPXcDCSdbG0rr6s0J4bExEbyybguT+8Xg6ejAV3sPXrLvp2dN4elZU65oPFZKJaMiw/hi9wGenTOV3PJKEjOzefv+rnV+wBSMtTo9Wr0eAI1WBxJQyk0ftTc3bqewuobX7r4TlcJypkWEtxcrDhwyz67OLqvgZEERswcPuKIxC4JwY7NRKVk0ZAAf7ktGKpUwwNcbuVRKanEpJ4vLWTS0PwdyzvLYuHgGX1ASJzG3gJVH0lg6Iu6ypSR660BOPhGebrja2mCrUlrEXEdrNeWNTeZk7MjQAN7adYDxESG429my4nDqJft+bNxwHht3ZTfWUCsUxAf7sfzQcX43fjh51bUcOlvIK7dN77a90WhEq9ejMxgA0Oh0SCQSFBecYDtdVklNS2uXhHtWeRU2KiV9HO1pbu/g44RD9PX2xEYlZgELws1CYa0kcs4A0pYnI5FKcI/2RiqTUnm6lOrMciLn9qfkyFkG3BOPZ2xnvC09VkDmhjRi5sdd9rLm3io5ko9zsBtWzjYorZUgkZhvkqayV9NS1WROxnoPDiDl8wP4DQ/B2sWWzB9TL9n3gLuHM+DuK4u3cpWCPgP9OL3uOAOWDKehsJay1ELG/LH7eOsXH8yxzw/gOywItYMVmRvT8BvRmeRtKKrF1tMeowHO7smkvaHNYr1eq4dz1YMNOoP5EuWL67QLgvDrpbRWMXB+PEmf70EqleAd649UJqUkvZDyjGIGzI8nP/kMIx6YgM+AQPPz8g/nkLrmEIMXjrpqMfds8hncQ72wcbFDZWM6WXU+5lo5WNNU2WBOCAcMC+XAhzsIGRWJnZs9qWsOXbLvEfdPYMT9E65oPAq1Av8hIaSsTmLkg5OoLaii8GguM/9+R7ftS9OL2PfeViY8MxO3kK6ldRI/2019SS1T/3QrcqVlWs81yIMT64+YZ1fXnK2kIrPU4mZzwm+XSAILAMwfPgQnWxu+SUjipTUbsVIpCfPyYNHoeA5knkEllzO5f4zFzNXpA2NZtvcAh3PyiA+/9Jn+tzfv4L2tu8yPfV2c+ejhJV3aZZWU8d6WXbR0dOBkY8Pj0ybg5eQIwD1jR/DfHzbRodPx+1lTGBsTyW3D4vj9lyuRSiTcO34UO090f+O3n+PJGZN5df0WbnvlXeyt1Tw1cwqB7qY6xBX1jSx971O+eOx+PBztqahvZOGbH5qfO/Vfr+PhaM+Kpx+hvL6BDUdTUchl3Pbau+Y2z8yawsTYaPoF+HHP2BG8uGoddc2tONpYsXBUPINDAruMSRCEX7e5A6JxtFaz6sgJXt++HyulnBA3V26PiyU5rxClXM748BDkFxwIT4oKZfnhVI4VlDAk0PcSvcNHCcl8euCw+bG3owNv3jGrS7vsimo+2X+YVo0GRysrHhg1xFwyYeGQ/ry58wAanY7Hxg1nVGggs/tF8ad1W5EiYfGwgT3O9P05HhkTz1u7DrD4s++wU6t4ZEy8uQ5xZVMzj327jvcWzsXdzpbKpmbu/2qN+bm3ffgN7nY2fHbPfPOyXZk5xAf7YX1RSYnyxia+Skqhoa0da6WC/r59+MPkrrXqBUH4dQudEo3aQU3WxhMc/WQ/crUcR39XwmfGUpZSiFQpxy8+BKm8M976jwrl9PpUKtJL8Op36XibtjyZEys7462dpwPj/to13tblV3Ni5WG0bRrU9lbELhiCjZsp3kbO6c+xzw9g0Ojof89wfAYHEjwpigOvbkUikRB5y8AeZ/r+HP0Xx5PyxQE2P/UdSlsV/RfHY+9tiretNc3s/Ms6Jv5zLtYutnj09SF0al8OvLoVvUZPn0H+RM7pnKhQmJRLwf5sDHoDrqEejHhmMjJF5++GnX9aS2uNaUZz4hs7AJj839uw+QUuuxYE4fqJmTEQKwdrUn84zL73tqJQK3EJdKffLUMoPJqLTCknZFSkxczVsLHRHF+dRHFaPn4Dgy7Zf/KyPRz6ap/5sUMfJ+a8tLBLu+rcCg59tQ9NqwYrB2uG3jMWO3fTjTAH3DaMhA+2odfoGH7/RILiw4iaNoCt/1oDEgmDbh9O7sHuZ/r+HMPvHc/+j7az4uGPUNlaMfy+8Tj5mmYCN1c3svbZr7n1tbuwdbUn9YdDaFo72P7f9ebne0T0YcoLt9Bc1UjWrpPIFDJWPPyJef2I+ycQPDICrygfBswbxu43N9HW0Gr6zpkzGO9Y/6u+T8Kvj8T4K77uUS6Tvbxk3MjnF42+shshCILw25JwKov/bdi2s6GltWs1faHX7K3UGX+ZMSEq0ktcRiQIQs/e25PUvjUj6zmj0fjO9R7LzURlq94Qu3DoTN9hl/6BLAjCzasuv5qDr2/P1bR0iFobvzCFWlE/739LHKydr35NbkEQfh1ObjxGyuqkd3Qd2ieu91iulqsz114QBEEQBEEQBEEQBEEQBEG4IYkksCAIgiAIgiAIgiAIgiAIwk1MJIEFQRAEQRAEQRAEQRAEQRBuYiIJLAiCIAiCIAiCIAiCIAiCcBMTSeBfoQVvfMCx3Pyf3c8bG7bx9d6DP39AP9NnuxKY+9+3ue3Vd6/3UH5x/1z9IwdOn7new7hprU0+ysc79l7vYQg3kfu+XE1qUenP7ue9PYmsPJJ2FUb083ydnMLCT1dw1+crr/dQfnGvbttHUl7B9R7GTevHtFMsSzx6vYch3OS2PbeaylM/PwYf/yqRzA3XPwafWpvCpidXsPnpmz8GH/loH6UpIgb/FA1Ftex7adP1HobwG7Tqd59RcrLwZ/dz8NNdpK49dBVG9PMc+y6R5Q98yIqHP77eQ/nF7Xl7MwVHcq73MH6Vaguq2PjX7673MK4Z+fUewC9hwRsfUNPUzOrfP4aDjbV5+QMffEFueSXfPvUwnk4O12w8qWcL+f2XK1ApFBbLX737DqJ9va/ZOC729KwpvW773x824Wpvx30TRl/VMVQ2NLI68Qgrnn4YJ1ubbttsOpbGigPJ1Da30NfPhz/MmYarvR0ARqORT3bsY3OK6cB+2sBYHpw0FolEgl5v4KW1Gzicc5Zonz789fY5WKtUAHyzLxGVQsH84YMvOb4jOXl8k5BETlklSrkMfzdX5g8fzIiIULYeP8nmlDTevm9xr/Y1t7ySvIpK/jxvVo9tPt+VwMHMbAqqa1g8ejhLxo3sse3KA4fYnpZORX0jDtZWzB48gDtHDjWvzymr4J3NO8mrqMRKpWTmoP7cPXaEeX19SyvvbtnJoew8JMDQ0GD+dImxXYpGp+PNjdtJOJWFSqHgzhFDmD98SI/tL7XtD7btJjEzh9rmFlztbVk0Kp7J/WPMz03JK+DD7Xsora3DwdqKBSOHMTOuPwAzB/Vn8dsfMT9+cI9/T8LVdd+Xq6ltaWPZ0ttxsFKblz+xcj1nq+v49O7b8Dj3eb0WThaX8ad121ApLL/e/jl7MhFe7tdsHBd7bNzwXrd9Y+d+XG1tuGvYwKs6hqqmFtYdz+Cze+bhaG3VbZttGWdYk3KSutY2orzceWL8SFxsTd+jRqORL5OOsT0jG4BJUaEsGT7IFG8NBl7fkUBKQQnhnu48P3Us1krTd953R9NQyeXM7R99yfGlFJSw6tgJ8qpqUMhk+Do7csuAaIYG+rHzdDbbT2Xzym3Te7WvZ6trOVtdy7OTe/7O+iY5heS8QorqGrgjLpaFQwdctl+tXs/vVqynXatj2dLbzcv/74etFNTUodUb8LC3ZdHQAQwL8gOgtqWV9/YkkVNZTW1r28/+TGj1et7fm8TBnAJUChm3DejL3AE9v7Yb0k6zLjWDpvYOvB3tuX/UEKL7ePSqr3d3J5JeWk5pfSNPTBjBxMhQ87qp0WE8+PVa5vaP7vHvSfjlbXtuNW31bUx7/XZUdp0xePeL62koqmPyf2/DxvXaxeCqzDIOvLYNmdIyBo94ZjIuIdcvBg+4u/cx+Nhn+7FysiHq1qsbg1trW8jensHUV+ahsu/+M5OfcIYzW07S3tCGS6g7A5eMxMqpMwZnfH+M/P2mGBwwKpToeaYYbNAbOPpJApXpJTgHuzP44bEorEwxOGtjGjKlnJDJl47BFeklZG08QUNhDVKFDLs+joROicarvx8FB7LJ35/NmD/2LgY3FNXSUFRL3IOdMbgoOY+MNcfQNHfgHuXFwKUjUdqqun3+tudW097YjkQqAcAl2J0Rv58MdP831m/RMPxHhACw8y/raK1pNq8zaPV49PUm/omJlx13Y3EdJ1cdob6gBk1zB7d8tuSS7atOl3Fy1RFaKptQ2qoIm96XwDHh5vU52zM4s+Ukeq2ePgP96X9XPDKFDIDcXacpPJhDY0kdPkMCGXTfKPPzHHydUVgrKUstwqu/72XHLVw7q373Ga11Ldz5/gOoL/gcr3vhG2oLqpn/9lLs3K5dnqHsVBFb/rUGudIyzzD1/27BPazPNRvHxUbcP6HXbRM+2IaNsx2D7uh9nO6N5pom0jcd4/Z37sPKwbrbNlm70znx4xHa6lvxCO/DqIcmYe1sC5hi7tEVBzizJwOAsLHRxC0caY65+97bSklaPm6hXox/cgYKKyUAqT8cRq6SEzP90t8hxWn5pK07Qk1+JXKFHEdvZ2JmDMQvLpjsfRlk7clg5ou3X7KP82oLqqgrrMbvd9PMy3IPZnJ05UE6mtro09ePUQ9NRmWr7vb5q373GW0NrUikpjmi7mFeTP2/WwEoyygi+cu9tNQ0IZFK8YjwJn7pOGzOvU6Hv0mg8FgerfUt2DjbEjtnMKGjo3o17rqiag5/k0B1XiUdze3cu+KpS7b/fMGbyFVywPTdEDQ8jJEPTgJAr9VxdMVB8pLOoNfqCIoPZ9g9Y5DKZRZ9NJTVse75bwgYEsqYx6cC4OzvhtJGReGxPPwGBfVq7L9mN2USGMDT0ZFdJ09z67BBAORVVNGh1V238bjY2bLq949dt+3fqCrqG7G3VveYsEvLL+SzXQm8vuROfJydeXfLTv71/QbevHchABuPpnEgM5tPHlkKEgnPffUdXk6OzB48gP2nswAJ6557gn+v2cCGo6ncMWIoZXX1JJ3J4e17L5283ZeRyavrt/DIlPH8e2EE1kolJwuL2JGWwYiI0Es+tzsbj6YyoW8UEomkxzbeLk48OHksG46k9qrPF26ZQbCHOyV1dTz31SrcHewY39cUdP+9ZgMjI8L439IFlNc38ORnywn2dDeP/W8rfyDc25MVTz+CWiHnbGX1Fe/TeV/uOUhJTR0rnn6E2uZmnlm2En83V4aEdh9EL7VtK4WCfy+8DR8XZ7JKy3j+61X0cXYkxs8HnV7P31au5cFJ45gZ14+s0nKeWbaCSJ8+BHu6o1TIGRISxPa0dO4YMbTbbQtXn4e9LQlnzjKrXyQA+dV1aHT66zYeZxtriwSdYFLZ1IydWtVjwu5kSTlfJ6fw77lT6ONozyf7D/Pq9n28fKvpgHJrxhmS8wp5e8FsJMBf1m/H08GWaTERJOYWIEHC8vsX8Nr2BLamZ3HrwBjKG5s4craI/14meXswJ5+3dh3kvpGD+cuMCVgpFWSUVrA3K5ehgX5XvK9bM84wJjzokvHWy8GeJSPi2Jqe1et+1x5Px9HaivKGJovlD4wagp+zIzKplKzyKv6yfhsfLr4VZxtrJBIJA/29mT+oL39Ys/mK9+Vi3x5KpbS+kc/vmUddaxv/t24rvs4ODPL36dI2q7yKL5OO8fKtUwl2c2FLehYvbd7NV/fegUwqvWxfga5OjAoNYFnisS59K+VyBvl7szszl1sHxnRZL1w7Nq62FB8+S/AEUwxuKK5Dr7l+MVjtaM2010QMvlhrTTNKW1WPCeDqrHIy1qYw6g9TsPWw58SKwxz5eB+jnzfF4Px9Zyg7XsiEF2eDBA6+vh0bN1sCx0ZQmlKARCJh+lsLOPpJAvn7sgidGkNLVRNlaUWMfuHSMbjkaD4pXxyk7x2D8X5iAnK1gprsCgqTcvHqf+Ux+Oy+M/gO64zBjSV1pH6VSPyTE3H0d+H4V4mkfpPEkIfH9thH/BMTcI/qPol1qb+xif+ca/6/0Whk+wtr8I4L6NW4JXIp3oMDCBwXwaF3d1+yrUFnIPm93cTMiyNgTBj1+TXsf3UrzkFuOPg6U5FewpktJxn57BTUjtYcem83p9cfJ2ZenHkfwmfGUplRil7T9Teq77Agzu7LEkngG5CtuwN5iVlETe0PQG1hNbrrGHOtnWy58737r9v2b1TNVY2o7Kx6TACXnSrm2HcHmfbnedh7OXLoy73sfWcL0/82H4CsXScpOJrH3JcXgUTCtpfWYufuQMSkWPIPm2bcLvz4Yfa9u4XMXSfpO3MQTZUNFKXkMeMyyduzh7I58NEOhiwezaQ/zEahVlKeWULugUz84oKveF8zd50kaESEOebWFdVw8NNdTH5uDi6B7hz8ZBeJn+9m3BM9fxdM/MMcvPt2jfeO3s5MeeEWrJ1t0Wt1pKxKIvGz3Uz6w2wA5CoFE5+djYOXE1V55Wx/eR32no549OIkhFQmJXBYGBGT+rHr9Q292te5Ly/G3tOxy/IT649SnVfBra/ehcFgYOerP5L6w2EGzo+3aJf0xR5cgzy6PD94RARZu06KJPCv2aR+0exISzcngbelnmRyv2g+373f3Eaj0/HZrgT2ZWSi1ekZGRnGo1PHo1IoaGpr5z9rN3K6uBS9wUCMnw9Pz5yMm4M9AE9/8S19/Xw4fraQvIoqonz78OfbZlnMPO6ty/W1PS2dz3ftp12jYV685czVZXsOkF9ZhVQi5VB2Ht4uTjw/dzrBnqbZFgVV1by5cTs55ZW42tly/8Qx5iTghbN7U88W8tLaDcwbNpiVBw8hlUi4b+Jopg2IZePRVHaeOIVEAmuSj9I/wI+XFs1jxf5k1h46RmuHBhc7W56aOYmBQQFd9q+5vYN3Nu/gcHYeKoWCGYP6sWhUPMfPFvCnb9eg1euY/u//MSYqnOdvmWHx3MSsHMZEhRPo7gbAXWOGc/vr71NSW4e3sxPb0k5y+/DB5vdlfvxgNqWkMXvwAMrqGugf4IdMJqV/oB95FVUAvLN5Jw9PHo9M1nM1FKPRyAfbdrN49HBmDOpnXt4vwI9+AVd+MAxwOCePF26Zeck2U/r3BWDXiVOX7e/CWb9+ri6MiAglvbDEnAQur29gQmwUMqkUb2cnYvx8KKisZkREKEdyzlLZ2Mj/li5Adu6MX6hX12DYW9vT0nlu7nTsrNTYWamZMTCWbaknu00CX27bS8Z3zoSI9OlDX39fThWVEuPnQ2NbOy0dGib1i0YikRDh7YW/qwv5VdXmv/n+gX5sPnZCJIGvoXHhwezOyjEngXdl5jAuIphvko+b22j1er5KSuFATj46vZ5hQX7cP2oIKrmc5vYOXt+xnzMVVeiNRiI93XlsXDyu504O/XHtFqL7eHCiuJz8mlrCPd15dvJoi5nHvXW5vnZn5vLNoRTaNTrmDLA8i/3toeMU1NYjlUg4VlCMl6M9T00YSaCrMwBFtfW8vzeJs9W1ONvacE/8QHMC88LZvSeLy3h9x37m9I9iTUo6UomEu4cNZGJUKFvTs9h3Jg8JEn5MO0Vfb0/+OnMi3x87yYYTp2nTaHC2seaRMcPo59v14KqlQ8NHCYc4VlCMSiFnSlQY8+NiOVFcxj837kKr1zP/o28YHuzP0xNHWTz38NkiRoQE4O/iBMAdcf1YsmwVZQ2NeDnYszszh7n9o83vy9wB0WzPOMO0mAgqGpuJ8fZEJpUS6+PJ2eo6AD5OOMTSEYPNn/XuGI1GPj1whDsH92NKdJh5eV9vT/p6e17R+3vesYLiLvt3sQmRpllj+7LyetVneWMTe7PyuG/kYN7dnWix7vzfAIBEAjqDgermFpxtrHGytmJG3wj0BsMV7kX3dmfl8uSEEdiqVdiqVUyJCmNXZk63SeDKpmb8nB0JcXcFYHxEMB/sS6ahrR1nG+vL9jUj1vSZVshTux1LX29Ptp/KFkng68w3PpjCxBxzErjwYA5+w4M59UNnDNZr9Zxam0LJ0XwMOj1eA/yIvXMIMqUcTUsHRz/dT11eFUaDEecQdwbcFY+Vs+mzvv+VLbiEelCVWU5jUS3Owe7EPTjaYuZxb12ur8LEXE79kIKuQ0foZMsYfHr9cRpL6pFIJVScKMbGw55B947Ewdf0+WssrSftmyQaCmtRO9kQfdtAcwLzwtm9VZllHP10PyGTojizJR2JVEL0rQPxHxnK2X1ZFB3KAyTk7DyFW4Qn8U9M5Mzmk+TuOo2uTYPa0Zp+i4d1m6DUtmpI+/YQFSeLkSnlBIwOI3xGLFWZZSS9vQuDTs+Pj36D9yB/i5mfAGWpRXjHBWDvbYrB4TP7sfXZVTRXNmLrbk9hYg4hU6LN70vIlGjyE84QODaC1qpmXMM9kcqkuEV40lBkisEnVhwi5vbBSC9zzHvyuyOEz+pHwOjOGOwa7olr+E+LwRUnixl0f+f+FSXn4dnf19xf5NwB7PzzOrRtWvOM5V9CzZkKOpra6TPIv1ft7TwdsPN0oLmi8bJtNS0d6Nq0+MYHI5FIcAp0xc7LgcbSehx8nSlMzMF/ZKjF+3n0kwRzEtj73Jjq82to6yYJ7BruScqyRPRavXn2sHBjCBkZQc7+0+YkcE7CKUJGRZKyqvPYQK/Vcey7RM4mZ6PX6vEfHMzQu8cgV8rpaG4n4f1tVOWUYzAY8Ajrw/D7xmPjYrpqY/M/VuMR4U1ZRhG1hdW4h3ox9vFpFjOPe+tyfeXsP82xVYno2rVEXzRzNeX7JOqLapBIJRSl5uPg6cjIhyfj4m/6XV5fUkviZ7uoLajC2smWuDtHmBOYF87uLTtVxL73thE9bQAnNxxFIpUw6I4RhI2NJnPXSXIPZiEBMrYcxyvah0l/mMOJH49wamsqmjYN1k62DL93HH1iuv4G17R2kLRsLyWp+chUcsLHxdBv7hBKM4rY+ep69Do9Xy15j4ChIYx+xPIq6KKUPAKGhuLk6wJA/1uGsvKxT2msqMfew5GchNPEzBhofl9iZgwka3c6EZNiaa5qwCvKB6lMileUL7WFpglNyV/uZfCiUZeNuYe/TqD/LUMIH995/OQV5YNXVNdjud4oTsu32L/cg5n4DQzCM9LU38Db41n7+6/QtmnMM5Z7y8rRcrKeRCqhqaLe/PjCJKt7iBce4d5UninrVRLYoY8zDn2caSyvv2zbyylMySN2dpx5tnPU1P4c/faAxfjyErNQWqtwDPOiqbzB4vmeUT4c+HgHeq0OmeKmTZMCN3FN4CifPrR0aCioqkZvMLA3PZOJ/Swvg/p4x16Ka+r4+OGlfP3kg1Q1NvHVXlPwNhiNTB3QlxVPP8LKZx5BKZfz9uadFs/fdfI0z82dztrnHken1/Nd4uGfPN6e+sqvNCVx/3jrTFY9+xiNbW1UNVrOQDqYmcOY6HDWv/AEE/pG8pcVa9Hp9ej0ev707RriggNZ+4ff8bvpk3hpzUYKq2u6HUNtcwstHR2s+v2jPDtnGm9v2kFTWzsz4/ozMTaKO0YMZfOfnuGlRfMorK5h3eEUPnjwbjb96Wleuet2PBy7v/Tlnc07aGnvYPlTD/Hm0oXsSEtn6/ETDAoO4OXF83Gxs2Xzn57pkgAGwAhGy4fm1wWgoLIz+QcQ7OlOfqVp/wI93Dh+tgCtTk/q2UIC3FzZf/oMDtZW9O3mx/KFiqprqWxoYkx0+CXbXejNjdt5c+P2bte1aTSU1TXge0Gi4GoyGo2cLCgi4NwPfYDbhsWxPS0dnV5PYXUNp4pLGBgcAMDp4lJ8XZz57w+bmPvyWzzy0Zek5f+0+k9Nbe3UNDV38z50P7P4SrbdodWSVVJm3i9nWxvG941k6/GT6A0GMopKqGhopK9f5/vp5+pCbkXlT9oX4acJ93SjTaOlqLYevcHAgZyzjAuzPIu9LPEopfWNvH3nbD666zZqWlpZedhUxsVgNDIxMoTP7pnP5/fMRyWX8eG+ZIvn7ztzlicnjODr++5Ep9fzw/H0nzzenvoqrK3ng31JPDNxFF/eeztNbR1UN7daPPfQ2UJGhgTw7f0LGRMaxL827UanN6DTG/jnpl0M8PPm6/vu5KHRQ3l9ewLFdQ3dDYG61jZaNFqWLbmdJ8aP4IOEZJrbO5gaE86YsCBuHRjD6ocW89eZEymua2DTydP8b/5MVj20mL/PnoS7vW23/X6UcIhWjYZP7p7Hf26Zyu7MXHaezqa/bx9enDURZxtrVj+0uMcEqdHYNeIW1NSbX58Lk52BLs4U1prW+bs4cqK4DK1ez4nicvydHUnKLcBerTaXHuhJcX0D1c0tDA/p3Y90gPf3JvH+3qRu17VrtVQ0NuNzlcs+fbTvEHcPG4hK1v2P8b9v2MmtH3zF71dvoq+3pznxejU1t3dQ29Jq+T64OlN47j262CB/bwxGI1nlVegNBnacyiHI1Rkna6sr7qs7Pk6OnK2u/am7I1wlzsFu6Nq0NJbWYzQYKDlyFt9hljE44/ujNFc0Mv5vs5n00m2017eaa+QajUb8R4Qw5ZX5THllPjKFjLTlljG4+NBZBi4dwfQ378Sg15O97afH4J76aiytJ/WbJOLuH8W012+no7mDtjrLGFyWWoh3XAAz3l6I79Agkt/djUFnMM3KfGcX7tHeTH/zTvotHMrRjxO6/Mg7r6OhDW2blmmv3c7AJSNIW56MpqWDwDHh+A4NImxqDLPfX0z8ExNpKm8gb/dpxv55JrPeX8zwZyZh7dp9DE779hDaNg2TX57HqOenUpiUS8HBbNyj+jD8qYmoHa2Z/f7iLglgs25icGNJvfn1OZ/wBlPJgKZz6+y9HanKLMOg01OVWY69tyOlKQUobdW4hl46BjeXN9BW22JOSvZG6tdJpH7dfQzWdWhprW7GzrMzBjeW1uPg0zl2W3d7pHIpzRXdvz8ARz9JYNOTKzj4+nYaiizjTEdjO5ufXsm257/nxMrD6Dq03fZRcDAH70H+yFVXP9GsdrDCZ2gghQezMRoM1ORU0lrTgsu517uxpOv71dHYTkdze6/6t3KyQSqT0tzD37Bw/biFeqFp01BfUovBYOBs0hlCRkZYtDny7QEayuqZ+/Ii5r+5hNa6ZlLXmOKq0WgkdEwUt79zL3e8cx8ypZykZXssnp93MItRD09m4UcPYdDpObmp6xU5vdVTX3XFNSR+tpsxj07hzvfvp6O5jZbaZovnFhzLI2BYGIs/eZigERHsen0DBp0eg07PjlfX4x3rz4KPHmLYknHsfW8rDaXdHxO01begbdNw53v3M/LBSSR9sYeO5nYiJvQleEQ4fWfFcfeyx5j0hzk0lNZyelsas/+1gLu/eIwpf5yLrZt9t/0mLduLtrWD+W8tZfpf55Gz/zTZ+zLw7uvH5BfmYu1ky93LHuuSAIZz4faCkHv+v3VFNebXx9m/81jO2c+NumLTOicfV8oyitDr9JSdKsLR14X8Izmo7azwjLh0uc+G0jpaapoIGNr7K4sTP9tN4mfdX52gbdfSXNmIQx8n87L6i8Zu7+GIVC6joayux23se3cr3z74EVtfWktNQZXFuubqRr65732+vOddTm5Koe+sQd32odPoqM4rx8nHpdf7dqU2/X01Kx7+mF3/20BTlWV8vPgrtKW2GU1rB2A6YZCyOokhd3VfKs7G2db0GpX2/BrdLG7aJDCYZgNvT83gWG4+fq7OuNl11kQzGo1sPnaCR6eOx97aCmuVikWj49mTfhoAB2srRkeFo1YqsFapWDw6vkuiauqAvvi6OqNSKBgbHUFuec+Jp5qmZmb9502Lf20azWX7SjiVRXxYMP0CfFHK5SwdPwrpRZe3hvXxYEx0BHKZjPnxQ9DodJwqLuVUcSltGi0LRg5DIZcxMMifYWHB7D55utsxyqUy7h4zArlMxrCwYKyUSop6SBjLJFK0ej0FVTXo9Ho8nRzwdnbq0u58Av7+iWOwVqnwdHJgfvwQdpzI6PG1utDQsCD2ZmSSW15Jh1bL13sPIpGYfuQDtGm02Kg664nZqFW0aTQYjUaGhgbh6eTAIx9/iY1axbi+kXy19yAPThrLZzsTePLz5by5cTvabi5bb2xrA8DFtvuD/O48NXMyT82c3O265nZT8LFWXtmZt976cs8B84mL84aFBZNwKoup/3qdJe98yvQBsUR4ewFQ1djE0dx8+gf48f0fHmf+8MH8ecVaGlpae9pEj87/Hdte9D60XvD3faEr2fYbG7YT7OnO4JBA87LxfaP4et9BpvzzNZ78fDn3jh+Fu0PngYG1SknLuddbuHbGhQezOzOX1KJSfJwczHVkwRRvt2Vkc/+owdipVVgrFdw+KJaE7LMA2FupGRESgFohN62LiyW9tMKi/4mRIXg7OaCSyxkZGnjJxFNtSyt3frzc4t/5mHGpvg7m5DM4wIcYb08UMhmLhw3oEm9D3FwYERKAXCZl7oBotHo9WRVVZFVU0abVMm9QXxQyGf18vBgc4EvCme5nmcqlUhYM7odcJiUuwAcrhYLi+u5/6EklErR6A0V19ej0Bjzs7fBy6HowrDcY2J99lrvjB2GtVOBhb8fcAdHsyczt8bW6UJy/Nwdy8jlbXUuHTseKI2lIgA6daYZSu1aH9QU/pG1UStq0OoxGI3H+PnjY2/LMqo3YKJWMCg1kxZFUlgwfxFdJKbywdgvv701Cq+8ab5vOfV6dr6Cu7KNj43l0bHy361o6TLHH6iqexU/KLcBgNBAf3HOS5G+zJrLqwcX8bdZEBvh5d/nbuRrazpW1srmg9p+1UkmbtvsEiJVCwfBgf55fu5lbP/iaFUdSeWzccCQSyRX31R1rpYJWTe/bC78c3/hgipJyqcwoxdbLAbWTZQzOT8im752DUdqqUFgpCJseS/FhUwxW2arxjgtArpKjsFIQPjOW6jOWMdhvRAh2ng7IlHK84wK7JOUu1F7fysbHl1v8uzBJ11NfpUfz8Yz1wTXcE5lCRtQtA0xT6y/g6O+Cd1wAUrmUkMnR6LV6avOqqM2rQteuJWxaX6RyGW6RXnj286X4UPcxWCKTEjGrH1K5FM9YH2QqRY/JNolEgl5noKmsHoPOgI2rHbbuXWPw+QR89G2DUFgpsHG1I3RyNEVJvYvBHn29KTmaT0NRLXqNzpSkl2AuFaBr11nMmlVYKdF1mGKwR6wP1q627PnnRhRWSryHBJL5Yyox8waRsTaFhJe3kPp1EoZujnk1zaYYrHbsfQzuf1c8/e/qPgZrW00xWK7ujMH6dh0Ka8tErMJKia69+/gR98Bopvx3HlNemY9rhCcH/7fd/EPezsuB8S/OZtrrdzDy2SnU59dw8rsjXfrQdegoPVaA37lawb8EnyFBZG5IY/1DX7P/v1uIumUg1udmaus7ur5fQI/73B25WmF+PYUbS8jICHISTlF6ohCHPs7mOrJgirln9qQz9O7RqGzVKKyU9JszmLwk083B1XZWBAwNRa5SmNbNHUz56RKL/kPHROHg5YRcKSdwWBi1+ZZJuQu11jXzzX3vW/zTXvB31lNf+Yey8R0YiGekDzKFnIHzh3cpo+Ua6E7g0FCkchkx0wei1+qozCmnMqccXbuW2NmDkcll9InxxXdAILmJ3ZfYksqk9L91KFK5DN8BgSjUih4TkhKpFL1OT11JLQadHjs3B+w9HLu0O5+AH3TnCBRWSuzcHIiZMZCc/d3nOi7mOyCAs8lnqC2oQqfRkbo2GSSYv6907VqUVp2/bxXWpphlNBrxGRCArbsDP/7fChTWKoLiw0hdk0zcgpEc/e4gm/6+msTPdqPvJuaePxF08QzbSxl+33iG3ze+23XnY6NC3Zln0F40dgCltRJte/fxZMzj07j9nXu5/Z178YryYft/fqCjpfOEla2rPYs/e5RFHz/MoNvjcejT/cS2xE934eznhne/3p9UvBLT/zqP29+5l1tfvxtrJ1t2vPIjBr3pSjuffgGc2nqctsZWWutbyNhquhpK12H6Dk1ZnUTYuGhsXXq+T4JCrTC/njezm3qe86R+0Tz1+beU19czqb/lpYr1La20a7U8/NGXnQuNRvTnTh+0a7S8v3UXh3PO0txu+gC0dmjQGwzmy1qdL6hjq1IoLJK6F7tcTeCe+qppasbNvvNA00qpxN7K8iDtwvVSqQQ3eztqmkxn8dzt7ZBKO4O5h6M91RfNJD7P3lptUSJBpZDT1sOPO28XJx6bOoEv9x4gv7KawSGBPDJlvPmGbec1tLah1evxcOwco2kMzRd32a2BQQEsGTuSF79bR0tHB/OGxWGtVOJ2bjtWSgUtHZ0f1NYODVZKpfkL7MFJY3lw0lgAPty2h1lx/ckqLSertIw3ly7k9R+3suX4CWYPtrwh0PnXuKa5GS8nx16N9VJs1aYg3KrRoDyXmFj67qdUNJguN3t58Xxi/X9aza8fDh1je1oGb927EKXc1HdjaxsvfLOaJ6ZPYkLfKGqbm3lx1TqcbG2YM2QgKrkcT0cHpp8rdTG+bxTLE5JILyq5bL3jNzZsMyfxF42KN792LR0d5n1r7dD0mPDu7bY/3LaHs5VV/G/JAvP7WVhVwz9Xr+cfd97CoKBAimtr+dPyNbja2zHs3MzT1g4NNurubzQi/HLGhQfzwg9bqGhqYly45Q+uhrZ2OnQ6nv6us9aTEdMMYDAlFz89cJiUwhKazx2ctGm1FvH2wjq2KrnMnMDqzuVqAvfUV21Lq7nUAYBaocDuor+lC9dLJRJcbK2pPXcCw9XWxiLx52ZnQ00PJ1bs1CqLEgkquYz2Hvapj6M9948cwreHUymsrWegXx/uGzHEItEO0Njegc5gwN2uc4zulxjDxfr59mHRkP78Z8seWjVa5vSLwkqpMO+z+qLvhFaNBiuF3Pz5XDI8jiXDTZe5fn7wCNNiwsmprCGnspr/3DKVd/YksvN0NtNiLGfLnH+Na1vb8LwKNxG0UZliT5tWZ46Jj367jqpz34svzpp02dnJF2rXavki8Sgvzpp02bZymZQ4fx82pJ3Cy8HuJ9UzvtB7exLZe+5EwvxBsUyPMV2d0qrRmvfN9D50P8tt+6lsdp7O5r0Fc/FytOd4YQn/3LiTN++YbU6S97av7rRqtOYbAArXl198MAn/3UJLVRN+8ZYxWNPUjl6jY+8/LGOw0WCKwboOHSe/O0zFyRJzwknXrsVoMJhvEqN26IybMqUMXXvPMfhyNYF76qutvtVc6gBMdQYvvnGYlVPneolUgpWTNe31phhn5WxjvpEYgJWLTZeZxOcpbVUWl+vKlTLzD8WL2XrYE3vnEE6vT6WptB736D70vWOI+YZt53U0dWDQGbB26Ryj9SXGcDH3qD5EzunPoff3oG3TEjIpCrlaYd5nuVqOtq0zBmvbNMhVnTE4Zl6cudTAyVVHCBwbTl1+DfX51Yx6firHv0yk4EA2gWMtY/D517i9vg0bt58fgxXW55OdnZfUyi4aO4CuTYNc3X38cLlg9nL4jFgKE3OoOVOJV39f1A7WqM/V+LRxsyNm/iAS39rV5eZ/pSkFKG2UP7mkxeU0ldVz5KO9DH1sPO5RfWiubCTprZ1YOVrh2c8XmUpukYg7n3zpaZ+7o2vXml9P4cYSMiqSTf9YTVNVIyGjIy3WtTe2oevQ8eP/fWteZjReGHO1HPp6H8VpBWhaTL9jtW0aDAYD0nMx98IEoVwlR9vDbHe4fE3gnvpqrWsxlzoAUwLs4jI/F66XSCXYONvRWtdsXndhzLV1s6e1tqXbMajsrC6KuZafjwvZezoy9O4xHF+TzJ7iGrxj/Rm6eLRFoh2go7ENg06PrWtnnsHW1Z7Wuu7HcLE+MX4MmB/P7jc3oWntIHraABRqpXmf5WoF2rbO/I72XMw6H3MHLxjJ4AWmm7gfXr6fiAmxVOdVUJNXwfS/zuPgJzvJ3pNBxKRYy9fiXLmCtvoW7Nx//lVrSmtTDNe2a5Cfu2GmQq1A02aZm9K0aSwSxRfyCO8s3dBv7hBy9p+mIrO0S31cla2akNFRrHt+OXe+f7/Fe3p4+X7qimuY9ufbLnlPjp/jfHkLmVzG0HvG8M2971NfUouznyv9bhmCprWD9S8sR6qQET4uhtr8KtQOVtTkV1J6spA5Ly+6ZP/adq359byZ3dRJYE9HB7ycHDiUncezc6ZZrHOwtkalkPP5Y/eZE4oXWp14mKKaWt5/4C6c7WzJKavgwQ+XWdYmuAacbW0syje0a7TmWarnVTV21q0yGIxUNTbhYmcKkpWNTRgMRnMiuLKhER+Xq1OSYEJsFBNio2hp7+B/G7bx8Y59/N9tljVvHaytkMukVNQ3mi/pr2xoxLWHS5m7M3foQOYONdUoKqqu5ZuEJHONYH93V3LLK4n0MQWu3PJKAty7Xn5wtqKKjKISHpw0lu8OHiKsjycSiYTwPl7dlg7wdXXG3cGOhFNZV6W2rJVSSR9nR4pranE8V+v5i8d/fgH/LSknWHEgmTeXLjLXRQYoqzPVLZ187uSHm4M942IiOZSdx5whAwnycCPpTM5P2ubTs6bw9CzLS2pc7GzJragkztY0Y9f0PnR/KXRvtr1s934O5+TxxtKFFgnds5VV+Lo4MzjE9IXk5+rC0LAgDmXnmZPAhdU1BHtcvzuQ/1a529viYWfL0fwSnhg/wmKdvZUapVzGewvn4tLNTSDXpWZQUtfA6/Nm4GRjTV5VDU9+17ubA1xNzjbWFNXVmx+3a3XmWarnVTd3HlgajEZqmltxPveZrm5uwWA0mhPBVU0teDt2f/napUjoeuA0NjyIseFBtGo0vLcniWVJR/n9JMvLmezVKuRSKZVNLfg5O5rH4HIFtepnxEaa68CW1DXw3dET+J/ry8/ZkbPVdYR5mOLv2eo683YuVFBTR2ZZFUuGx7E2JZ0QdxckEgmh7q7dzuD2cXTA1daGxJyCq1JbVq1Q4OVgR0l9g7nW8/sL5/7k/krrG6lsaub5taabuun0Blo1Wu76fCWvzZuBRzfHEHqDkbKG7k+4XonHxg3nsXGWiQ1nayvOVtcxwM+USDtbU4efi2O3zz9bXcvgAF+8z5XGGOTvg5ONFZnllYwICbiivrpTXGdZIkS4fqxdbbFxs6XiZAkDl1rGYKWtGplSxoR/zrVIop6Xsz2D5vIGxv55BmoHa+oLa9jz9w0YjXQTjX45agdrmsrqzY91HTrzLNXz2i74cW80GGmra0XtaIpxbbUtGA1Gc1KirbYFW48rj8EXzz4G0026fIcFoW3TkPpVEhnfHyXuAcsYrLJTIZFJaa1pwb6PIwCttS1dksWXEjQ+kqDxphjcVN5A1sYT2Hub+rLv40hDUR3OQaYY3FBUh925dRdqLK6jNreKmHlxZG9Nx9HfFIOdAly7ncFt6+mAlbMNpccKCJ3682OwXKXAxt2O5vIGc0Lp/NjPa6lqQq8zYOvRywSIREKPP8IkkouuATYpTMzBd3jIL5aMaCypx9bDAY8Y06Xfdp4OeMb6UJFegmc/X+y9TfvsM9h0bNxYVIfKXm1OAF1OW12rKcHl+fOTRMLVZ+tmj52bPcWp+Yx80PIksdrOCplSzi2v3o2Nc9ffvOmbUmgorWPWP+/E2tGGmvxK1v/x22ueZ7B2tKH+gvINug4tHU2W5UpaajqPZYwGIy21TVg72ZrXXRhzW6qbsPdyvOJxdPcZDR4RQfCICDStHRz8dBdHVhxgzGNTLdqo7E2J5ebqRnP5geaaJqy7+Z7rSdTkfkRNNk1MaiirI23dYXNfTj4u1BZU4RZiOpFUW1DdbZmDuqJqKs+UMnjBSE5uPIpLoAcSiQTXIA9qC7qWR3To44SNix35h3PoO7P7sgpXQqFWYOfhQGNZPVb2pu8bRx8Xags7Z483VjRg0Opx8Op65XaPuomrAEa9gfbGVrRtGnM8S1mdRHFqPtP/Ou8aJ1E7479cKSd+6Tjil44DTDfLcwlyRyqVUn6qmObqRlY9/hlgSvYaDQbq/1jDnP+YEsOttc0YdHqLsho3q5u6HATAs3Om8fo9d2J10axEqVTCjIH9eH/rLurO/aivamziSI5pxk2rRoNKLsdWraaxtY0v9x685mMHGB0dTtKZXE4WFKPV6fliz37z7LnzzpRWkHAqC73ewJrkIyjkMqJ8+hDp3Qe1QsHKg4fQ6U11cZOychkfE9nD1nrmZGtD2QXJkcLqGlLyCtDoTDOtVAo5MmnXAC6TShkbHcFnuxJo7eigvL6B1UlHmBgb3aVtdzRaHWcrqjAajVTUN/K/DVu5ddgg7M79sJ/cL4bvk45Q1dhEdWMTqxIPm2+udp7RaOStTTt4fNoEpFIJXk4OnCw0vZ5pBYV4dVM3UiKR8MiU8XyzL5Etx0/Q0t6BwWDkZEExr/+49QpeuU5DQ4NJyy+6ZBudXo9Gq8NgNKI3GNBodT3eTGjniQw+3ZXAq3ffQZ+LEjE+Ls4YMd1gzmAwUtvUzN70THNydGRkGE1t7WxLNdXW3ZeRSXVTMzG+pgPZZXsO8PQX39Jbk/pF882+JJra2imsqmHTsbQu78N5l9v2twlJ7Dp5mlfvvgOHiy4PD/HyoLi2jpS8AoxGIyW1dSSfySX4XFIKIC2/qNsb0gm/vCcmjODfc6egvmgmoVQiYUpUGJ8cOEJ9q+kkVk1zCykFpkvf2s7NRLRRKWlq72DFkbRrPnaA4cH+HMkvJqO0Aq1ez/JDx7vE25yqGhJzC9AbDPyYegqFTEq4hxthHq6o5QrWpJxEpzdwsriMI/lFjAoL7GFrPXO0VlN+QQKxuK6BtHP1dhUyGUq5rNtSAzKplJEhAXydnEKrRktlYzPrUjMYG967uwxrdDoKauowGo1UNjXz7p5EZveLNF/JMD4imHWpGdQ0t1DT3MoPqRnmm6udZzQa+WBfMg+MGoJUIsHD3pZTZZVo9XrSS8q7nekrkUi4f+Rgvjuaxs5T2bRqNBiMRjJKK7rcgK23Bvn7kF5Scck2Or0Bje5cvDUa0ei6j7f+Lk58cc983r5jNm/fMZvfjR+Bo5Wat++YjautDUV19RwtKKZDp0OnN7AnK5eM0gpi+nTOPtPodOZSGNpz2z3v20PH+ePaLb3et3ERwXx3NI3m9g6K6urZnnGGCRHdX+4c6u7K0fxiyhuaMBqNHC8spaS+0ZzovVxfWr3eNFajKbF9/vU6L72kgkH+l659J1w7A5aMYOQfpnSpfyqRSggYFcbJlUfoaDTF4La6FirSTTFY165FppCjsFaiae4g88frE4O94/wpP1FMdXYFBp2e0+uOd/kRWl9QQ8mxAgx6Azk7TiGTS3EOcsM5yBW5SsGZrScx6AxUZZZRnlqEz5Arj8EqezUt1Z0xuKm8garTZeYbdEkVMovZb+dJpFJ8Bgdwam0K2jZTXdyc7Rld6jP3RK/V0VhsisGtNc2kfpVI8MRIlDamGOw3PJicHRm01bXQVtdKzvYM/Ed0jcGpy5OJXTAEiVSCtZstNdmVGHR6qs+UdzvTVyKR0PeOwWRuTKPgQDbaNg1Gg5Hq7AqOf/nTYrBHXx+LkiK+w4IoTyui+kwFug4tp9cdp89Av25vCtda00zNub8BvVbHma3paJracQ4xHcNWZZbRWtNsep1qW8j4/hheAyyvumirbaE6sxy/4V1f+23PrabgQHa34zYajei1OvPlxXqtDr226+XcAA5+zjRXNlJ1ugyj0UhzZSPlJ4qxP1f72C8+mIL9Z2gsrUfT0kHmxjSL0hQGvQH9uZJKRoPldgGqs8pxi/QSN4W7gY18aBLT/nQbCnXXmBs+PoZDX+2jrcF0JUBLbTPFafmAaUapTClHaa2io7md42sOXeuhAxAwNJSilLOUZ5ag1+lJWZ100b0hoPpsJfmHczDoDWRsOY5MLsM9xBO3EE/kKgUnNhzFcK4ubmFKHkHxvb+fznlqB2uaKjvL8TSU1lKaXmS6QZdSjlwp7zbmSqVSAoeFcey7RLRtGpqrGsnYnELwyN7lOnQaHXVF1abPb3UjBz/ZSdTUAebEZsioSNI3p9BS20xrbTPpm44ROtryhqVGo5Gkz/cw7O6xSKQSbN0cqMgqRa/TU366BLtuTnRJJBKG3DWa1LWHOLM3A01rB0aDkfLMEg58srNL+97w7R9I+eli8+PgERHm91bbruX46iT8h4R0e1O45upG85h1Gh0nNxylo6kd93Ozg/MP59BQWms68drYyqGvE3AJcDO/TmnrDpOXmMXU/7sVtV3XskKrfvcZ2fu6LwVqNBrRaXTmshk6jQ59D1dG1hXVUJNficFgQNuu4fDXCVg72+LobYq5598no9FIZXYZaWsPMXCeqWxR+IS+zHtzKXNeXsSclxcRMbEvvgMCmfzHW8z9l50uxiva96a/KRzc5DOBgW7r1J734KSxfLXvII9/+jUNrW242tkye/AABocEcduwOP69ZgNzX3kbVztb5scP4WBm9wcMvVHT1Mz0f//PYtkLt8xgdNSlA2WguxtPzpjEv9f8SLtGy7z4wV1mLo+ICGFveib//WEz3s6O/P2OW5Cfu3HNvxbeylsbd7BifxKu9na8cOsM/NyuvFD39IGx/H3Vemb95036B/ixZNxIPtm5j8KqGuQyKdG+3jwzq2vBdYDfTZ/EO5t3sOjNj1DK5cwY1I9pA2K7bXsxjU7Hv9dsoLS2HiuVkqn9+7J0fOfNNGbF9aesrp773//cPM5Zcf0t+th6/CSB7q6En6uHOyoynP2nz3DrK28T6dOnS/vzxkRHYKVUsjwhiXc270QllxPg7trjzOA3NmwD6DJL9ryZg/rxj9XrWThqWI+zEl7/cSvbUjtvtrI8IYnn5k5n6oC+nCgo4oVvVrP5T88A8Pmu/TS2tvHIx1+Z20+KjebpWVOwUav4+x238MmOvby5cRtKhYL4sGAWjTYFQntrK/618Dbe2ridtzbtwM/VhX8uuBWHczMGqxoaifHt/d1Jl4wbyZsbt7PgjQ9QyeXcOXKoRSJ2+r//Zy55cbltf7orAYVMxl1vf2x+/qJR8SwaHY+3sxPPzZnGu1t2UlHfiI1aycS+0UwfaDqDq9HqOJSdy4cPLen12IWrx8vBHnqYsLJk+CBWHknj2e830djWgYutNdNiwhno783sflG8tn0fiz5bibO1NXMHRJOc99NuVAimsg7zP/rGYtlTE0YyIiTgks/zd3Hi4dHDeG17Ah1aHXMGROF6UcmFoYF+7M8+y5s79+PlYM8fp41Hfu5SqD/PGM8H+5L5/thJXGyseXriKHx/QjmZyVFhvLx1D3d+vJwYb08WDR3Al4nHKK6rRyaVEuHpzuMXzQ4976HRQ/ko4RAPfPU9SrmMyVFhTIrq3Y0nNHo9r21PoKyhCSulnIkRoSwa2lkqZ2p0OOUNzTy+Yr15nFMvunnmztM5+Ls4EephuhJgeLA/SXkFLP5sJeEebkyN6f4773xN6FVHT/DR/kMoZTL8nB17nBn83h5TYuLiWbKdYw3jv9v2MX9Q3x7j7Tt7DrL7gnrJq46e4MkJI5gYGUpGaQUvbtjB6ocWI5NKcbpgNrWdylRyyLzMCCsOp/JKrekKDC9He56bMoaQC65Kue3Dzr/HR5b/AMCGx5cAUN3cSqRX78tTLBo6gPf3JnHvl9+jksu4bWBfBl1ws9P5H31jLnkxPiKYssYm/vjDVlo6OnCxteGxscPNf5eX6+uv67eb63OfLq/k3T2JvDR3Cn19vNDodBwtKOaNYbN6PXbhl9VdndrzoucPIvPHNPb+exOa5g7UTtYEjQ3HI8ab4IlRHP1kH5ueXIna0ZrQydGUHf/pMbi9vpUfH7WMwYPuHYl3XMAln2fv7US/RcM4+nECug4doZOjusyi9ervR8mRs6R8th8bd3uGPjYeqdwUg4f9bjyp3yRzZvNJrBytGXT/KOx+wqy0gFFhHP5gDxsfX45ruCeRcweQseYYTaX1SGRSnEPcu5QeOC924VBOfHuI7S98j0whI2B0GP4jexeD9Vo9Rz5JoKWyCblajv/IUFNd5PPjGhNOS1Uzu/5qisEBo8MIGGMZUwsO5GDv7YRTgCkG9xnoT+mxAjY9tRLnILcu7c87XxM6a9MJ0r49hEwhw97bkdAp3cfg41+ZYnBPr0Pg6DAOf7SPsOmmGGzv7UT/u+I5+kkCmuYO3KK8GLR0ZLf96dq1pH6TTEtlE1KFDEdfZ4Y/PcmccKgvqOXoJ/vRtnagtFHhNcCPqFstZ9MVJuXiHOzW5TNh0OnRNHfgHOxGd1prmtn+/Brz4x8f/gZrFxumvDIfgMQ3duAS5kH4jFhs3e0ZuHQEad8eoq2mGbm1Et+hQQSMMr3fHn19CJ3alwOvbkWv0dNnkD+Rczrfz6yNaRYnXIqS84iY3c/cpig5j8CxV55QE64dew9H6OHrO27BSFLXHmLDX1fS0dSOtZMNEZNi8ekXQPS0Aex9dwvfPvgR1k42xMwYSOHR3tUO705rXTNfLXnPYtnoRyZf9sZjTr4uxC8dx753t6Lr0BI9fWCXmcv+g4I4m5RFwgfbsPdwZPwzs5DKTXmGic/OJunz3ZxYfwQbZ1tGPzrFnJC7EmFjo9nz1ia+ue99PKN8GDgvnqMrD1BfUotUJsUjrA8j7p/Q7XOHLRlL8rK9rH7yC2QKGWHjYwgb27vJZnqtjr3vbKWpsh6FWknomCgG3t5Z6zx8Yl+aKhv44bmvTY/HxRA+0XKSU/beUzj6uuAabPpDCBgSQsGRHL598CPcQz2JmND9pKjAoaEoVArS1h0medle5Eo5jj7O9J0Z1237g5/uAujxdQifEMOetzYTO2ew6RjV14Xh941n37tb6Whuo0+MH6Mentxtf9o2LYmf7aapsh6ZQo6zvxuTn59rTui21jZz+JsE2htbUaiVeEb5MOGZzmO/Y98lIpXL+P7pZeZl/eYOpt/cIeh1etqb23EL8ep23M3Vjax+4gvz46/ueRdbVztuf+c+ALa9/AOeEd70mzuEtoZWEj/fTWttE3KVAvcwLyb9Ybb577Gpop6E97fR1tiGjYsdcQtG4h1rqk0sVyksTpDL1QpkCrl55jRA7oHMHt+vm43k4rM9vyZymezlJeNGPn8+sfVbtGzPAUpr6/i/28SPsF+Df33/I2OjIxgZGXa9h3JJD3zwBa/dc2eXmbg3urXJx6hqbOShyeMsliecyuJ/G7btbGhpvXxRT6FH9lbqjL/MmBAV6fXbLLfx7aHjlDU08fvJ3d9VVrixvLptHyNDA4gP+mVuTnG1PLFyPf+aMwV7q95dInyj2JB2murmFpaO6PqD5b09Se1bM7KeMxqN71yHod20VLbqDbELh870HfbbvNrl9PrjtFQ2dSnDINyYjny8D++4APoMvHFicHV2BWd3ZzL4oTHXeyiX1FBcx/EvExn7pxld1tXlV3Pw9e25mpaOX+6OdwIACrWift7/ljhcXIv2tyLl+ySayhsY8/jUyzcWrru972whcFgo/oNvnNBQnlnC6e1pjHti+vUeyiXVFlZz8NOdzPrHnV3Wndx4jJTVSe/oOrRPXIeh/SJu+pnAgnAj+fO82dd7CL3yySNLr/cQfpJbh/38ukqCINwc/jDlxv6Rf97bd8653kP4SWb1u/LSUoIg/HYMfvDGi8GuoR64hvb+yovrxcHHqdsEsCAIQk/G/m7a5RtdY54R3nhG3Phlw5z9XLtNAN+sbvqawIIgCIIgCIIgCIIgCIIgCL9lYibwr9yScSMv30gQBEH42RZeUB9XEARBuLYurKcqCIIg/LLO31RLEISbi5gJLAiCIAiCIAiCIAiCIAiCcBMTSWBBEARBEARBEARBEARBEISbmEgCC4IgCIIgCIIgCIIgCIIg3MREElgQBEEQBEEQBEEQBEEQBOEmJpLAgiAIgiAIgiAIgiAIgiAINzGRBBYEQRAEQRAEQRAEQRAEQbiJiSSwIAiCIAiCIAiCIAiCIAjCTUwkgQVBEARBEARBEARBEARBEG5iIgksCIIgCIIgCIIgCIIgCIJwExNJYEEQBEEQBEEQBEEQBEEQhJuYSAILgiAIgiAIgiAIgiAIgiDcxEQSWBAEQRAEQRAEQRAEQRAE4SYmksCCIAiCIAiCIAiCIAiCIAg3MZEEFgThpmc0Gq/3EARBEH5DRMwVBEEQBEEQhBvNrzoJrDcYWts0GsP1HocgCDe2dq0Wo9HYer3HcRNob9fqrvcYBEG4wbVqtAag/XqP42ZjNBhbdB0iBgvCb5m+QwcSEV+vBYlEotF2aK/3MARBuI507VqjQadvvt7juJp+1Ulg4FBiVk7L9R6EIAg3tkNn8lqb2tp3Xu9x/Np1aHW7jxeViKNhQRB6ZDAaSS0qNQLJ13ssNxttm2ZPxclicdwrCL9hlRmlOoNWv/t6j+O3QCKVJJelF13vYQiCcB0VHstrMhqMSdd7HFfTrz0JvLuivqH6g227tQ0tYpKfIAiWWjs6WJN81Jh0JkcDrLre4/m10+j1n24+mdmxOzMHjU7MRhMEwVJNcwtv7jzQodUbTgHp13s8N6HvKzNKOrK3phu0bZrrPRZBEK4hvVZHUXIeOTsyOvQa/UfXezy/BZpWzWtHvj3QVpiSh0EvLj4WhN+S9qY2jq44oGsoq2sAtl/v8VxNkl97rUyJROJho1Z90qHVTVbIZAaZVPLr3iFBEK4Kg9Eo0Wh1crVSkdzc3vGQ0Wg8fb3HdDOQSCTDbFXKd9q1un5KuUwnQcRcQRBAbzRI9QaDQSGTrWvVaB8xGo2N13tMNyOJRBKmsFZ+rOvQxcuUMr2IwYJw8zNiRK/RKeUqxUltq+Z3RqPx4PUe02+FRCKZobRWvarr0IbIVHKtBMn1HpIgCL8wo9Eo0Wt1UplSvkvbqnnAaDSWXu8xXU2/+iTweRKJRAk4AbLrPRZBEG4IRqDOaDSKumm/AIlEYg04gDgaFgQBAB1QazQaxWUC14BEIlFjOu4VMVgQfhsajEajKAdznUgkEjvA7nqPQxCEa8KA6Zj2przs6qZJAguCIAiCIAiCIAiCIAiCIAhd/dprAguCIAiCIAiCIAiCIAiCIAiXIJLAgiAIgiAIgiAIgiAIgiAINzGRBBYEQRAEQRAEQRAEQRAEQbiJiSSwIAiCIAiCIAiCIAiCIAjCTUwkgQVBEARBEARBEARBEARBEG5iIgksCIIgCIIgCIIgCIIgCIJwExNJYEEQBEEQBEEQBEEQBEEQhJuYSAILgiAIgiAIgiAIgiAIgiDcxEQSWBAEQRAEQRAEQRAEQRAE4SYmksCCIAiCIAiCIAiCIAiCIAg3sf8HHEY5p5Qhs20AAAAASUVORK5CYII=\n",
-      "text/plain": [
-       "<Figure size 1800x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# or we can also plot inline with matplotlib. a bit uglier\n",
-    "plt.figure(figsize=(25, 5))\n",
-    "intrp.plot(feature_names=['A', 'B', 'C', 'D'], fontsize=12)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Tree Based Treatment Policy Based on CATE Model"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from econml.cate_interpreter import SingleTreePolicyInterpreter"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<econml.cate_interpreter.SingleTreePolicyInterpreter at 0x177e08990f0>"
-      ]
-     },
-     "execution_count": 34,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "intrp = SingleTreePolicyInterpreter(risk_level=0.05, max_depth=2, min_samples_leaf=1, min_impurity_decrease=.001)\n",
-    "# We find a tree based treatment policy based on the CATE model\n",
-    "# sample_treatment_costs is the cost of treatment. Policy will treat if effect is above this cost.\n",
-    "# It can also be an array that has a different cost for each sample. In case treating different segments\n",
-    "# has different cost.\n",
-    "intrp.interpret(est, X[:, :4],\n",
-    "                sample_treatment_costs=0.2)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# exporting to a dot file\n",
-    "intrp.export_graphviz(out_file='cate_tree.dot', feature_names=['A', 'B', 'C', 'D'])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "os.environ[\"PATH\"] += os.pathsep + 'D:/Program Files (x86)/Graphviz2.38/bin/'"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# or we can directly render. Requires the graphviz python library\n",
-    "intrp.render(out_file='dr_policy_tree', format='pdf', view=True, feature_names=['A', 'B', 'C', 'D'])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Matplotlib is currently using agg, which is a non-GUI backend, so cannot show the figure.\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1800x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# or we can also plot inline with matplotlib. a bit uglier\n",
-    "plt.figure(figsize=(25, 5))\n",
-    "intrp.plot(feature_names=['A', 'B', 'C', 'D'], fontsize=12)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# SHAP Interpretability with Final Tree CATE Model"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<econml.drlearner.DRLearner at 0x26fc1794278>"
-      ]
-     },
-     "execution_count": 22,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# We need to use a scikit-learn final model\n",
-    "from econml.drlearner import DRLearner\n",
-    "from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor, GradientBoostingClassifier\n",
-    "\n",
-    "# One can replace model_y and model_t with any scikit-learn regressor and classifier correspondingly\n",
-    "# as long as it accepts the sample_weight keyword argument at fit time.\n",
-    "est = DRLearner(model_regression=GradientBoostingRegressor(max_depth=3, n_estimators=100, min_samples_leaf=30),\n",
-    "                model_propensity=GradientBoostingClassifier(max_depth=3, n_estimators=100, min_samples_leaf=30),\n",
-    "                model_final=RandomForestRegressor(max_depth=3, n_estimators=100, min_samples_leaf=30))\n",
-    "est.fit(y, T, X=X[:, :4], W=X[:, 4:])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import shap\n",
-    "import pandas as pd\n",
-    "# explain the model's predictions using SHAP values\n",
-    "shap_values = est.shap_values(X[:, :4], feature_names=['A', 'B', 'C', 'D'], background_samples=100)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAABGoAAAEACAYAAADr4JCdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAvWklEQVR4nO3deXyU9b33/9d3sgNJ2IWIhFVBca0iKlqqR6V1o629S489tbYu55yetsf23AfrWe629ral7a+1y1FP7d6eX+niUloVrbtCRdyqVkFBiUAEBISEkD3X/ccMSZAEBszMXJm8no9HHpmZ65q5PnN9MyTXm+8SoihCkiRJkiRJuZfIdQGSJEmSJElKMqiRJEmSJEmKCYMaSZIkSZKkmDCokSRJkiRJigmDGkmSJEmSpJgwqJEkSZIkSYoJgxpJkiRJkqSYMKiRJEmSJEmKCYMaSZIkSZKkmDCokSRJkiRJigmDGkmSJElSfquYX5nrEqR0GdRIkiRJkvavYv5aKuZ/tJdt11Ix/w8H8Fo/pWL+D/uqtDT8nor5X65eWPtQ9cLaf8/icaUDZlAjSZIkSXpn6hZdT92iC3Jdxj58Avj4l5fcOiHXhUj7U5jrAiRJkiRJekcq5hcBpwEP7mu3S59ayrNV48fBRdmpqwfVC2uLahZUteasAMWeQY0kSZIkKV3jqZh/P3AysBa4krpFy6iY/0VgNnWL/gaAivljgFuAM4BNwELgh8BE6hatTb1WCRXzbwE+BDQAX6Zu0X93Hqli/unAV4EjgbeAG4FvUbcoomL+HOA+4DLgS8AoYHjqe0/GAnf+/qjjC24/+l3rvw1UL6w9BrgBOD71+j8GvlqzoKq9emHt94DimgVVV5Hc91FgfM2CqurU/QXAGTULqs5L3Z8H/AcwGXgD+ErNgqr/SW37OPDvwH8DnwV2AEelc7I1MBnUSJIkSZLS9QmS3VFWAt8EfgZM7WG//wG2A4cBpcBvetjnYuDDwFXAPODXVMxfQt2iGirmHwXcBXwU+GPqGHcDbwI/Tz2/AHgvyaCllbpFrcCWHquumP9bYPFn5v3dDIDqhbWVwJ+A76deYxJwJ9AMfINkCPTt1L5DgOOAt6oX1h5es6DqZeBvUvVRvbD2bOBHqfewFDgRuKd6Ye26mgVVj6QqmABUpd5H6LFGKcWgRpIkSZKUrv+mbtFfAVKTAf/zXisqVcwfB5wJTKZuUR1QR8X864B3v+21HqBu0eLU7duomL+dZCBSA/wD8FvqFv0+tX0lFfO/D3yMrqAG4BrqFu3o/qLVC2sDMKRmQVV9t4c/Qt2ijSysfSh1/zyghWTPlwh4qXph7ULgcySDmgeBw6oX1k4CpgMrgFeAs6sX1taQHGb1udRrfRb4Ts2CqkdT95+oXlj7y1Stu4OaVuCamgVVzUj7YVAjSZIkSUrXG91uN6S+l79tn0NT31/v9ljNfl5r9+vtfq2JwJlUzP9At+0JYF23+x1vu787pPlRat+Pd26oW7Txbcc6DFibCml2W5N6nJoFVXXVC2ufJNlzZjrJ3jergUtI9iaqq1lQ9Xy3Wt9TvbD2c91eqwB4tNv9NwxplC6DGkmSJElSX9qQ+j4eeLXb7QNRA/yYukWf2sc+EXWLOoOWbiHNiSR79OzLOqC6emFt6BbWTGLP4Oc+uoKay4DXgB8ALwP3v63Wn9YsqPrGPo7XsZ96pE4GNZIkSZKkvlO3aD0V8x8CvkbF/E8CZSQn0z0QNwIPUzF/CbAEiIDDgVHULXq4l+d8kGSgAvBm9cLa3l77aeB7JCcSvrZ6Ye03SPaKWUBywt/d7iM5rKkFeLpmQVVH9cLa10jOqfPP3fa7AfhJ9cLax4FlJHvTHA2EmgVVT6b5fqVOiVwXIEmSJEnKO38LDALWA48Bv009nt7wn7pFLwDnkwxE3gA2Az+l91WdAH4P3A48T7J3zKgevpYBb9UsqNoBnEOyx8wm4B6Sc998q9vr/ZnkNfMDNQuqdveIuQ+oSH0HoGZB1b3AlSTnttmSqvfbwJC03qv0NiGKov3vJUmSJEnSwaqYfy7JIKWs+3Clvla9sLYQWATU1yyoumx/+0txZFAjSZIkSepbFfOPJTlc6XmSw4p+DbxI3aJLM33oVFgztGZBVc9LdUsx5xw1kiRJkqS+Nhy4BRgL7ADuBj6fjQPXLKhqIzkESeqX7FEjSZIkSZIUE04mLEmSJEmSFBMOfVK6NgKH5LqIfmATMCbXRUiSJEl5JNvXIv5Nr5xy6JPS5Q9K+kKuC5AkSZLySC6uRfybXjnj0CdJkiRJkqSYMKiRJEmSJEmKCYMaHbQbbriBV199NddlHJSHHnqI2267LddlSJIkSToIW7Zs4eabb+b6669n+fLlrFmzhkWLFqX13FtuuYXNmzdnuELp4BnUSJIkSZL6laVLlzJhwgSuvfZaTj75ZO6//35mz56d1nNPPfVUHnzwwQxXKB08gxpJkiRJUr+yY8cORo8eDcCGDRtoampi3LhxaT33iCOOYO3atdTX12eyROmguTy33pENGzZw9913U19fz7Rp0zj//PMpLCyksbGR22+/nfXr19PR0cH48eM5//zzqaioAODZZ5/l4YcfpqGhgUGDBnHmmWdyzDHHAPDMM8+wdOlSdu7cyaGHHsoFF1zA0KFD9zr2L3/5Sw4//HBmzpzZ+dhNN93EnDlzmD59OnfffTcvvfQSzc3NDB8+nLlz51JdXb3X66xdu5bbbruNz33uc52P3XDDDVx44YVMmjSJKIpYunQpTz31FE1NTUyaNInzzz+fsrKyPj6bkiRJkvbnZz/7GWvXruX1119nyZIlnHbaaUyYMKFz+7p16/jVr37FVVddRWVlJRs3buSnP/0pl19+OSNHjqSwsJCxY8eyZs0ajjvuuJy9D6k39qjRO/L888/z0Y9+lM9+9rNs3bqVRx55BIAoijjuuOO4+uqrufrqqyksLOSuu+4CoKWlhbvvvptLLrmEa6+9lk9+8pOMGTMGgJUrV/Loo4/y4Q9/mH/913+lurqaW2+9tcdjH3300Tz//POd999880127NjB1KlTATj00EP5+7//exYsWMDRRx/Nb3/7W9ra2g74PS5fvpyVK1dy2WWX8fnPf57S0lLuvPPOA34dSZIkSe/cpZdeSnV1Ne973/u49tpr2bRpEyNGjOjcfthhh/Gud72LO+64g9bWVm6//XbOPPNMRo4c2bnPqFGj2LRpUy7Kl/bLoEbvyMyZM6msrKSsrIwzzjijMzgZNGgQRx55JEVFRZSUlHDGGWewdu3azueFENi8eTOtra2Ul5d3dlt88sknmT17NqNGjSKRSHD66aezceNGtm/fvtexp02btse25557junTp1NYmOwodswxxzBo0CASiQSnnnoqbW1tbNmy5YDf45NPPsmZZ55JRUUFhYWFzJkzhxdffJGOjo4Dfi1JkiRJfaupqYmSkpI9HpszZw5NTU3ccsstlJeXc9JJJ+2xvbi4mKampmyWKaXNoU96R3YPZQKorKzsHOfZ2trKkiVLWL16dec/gM3NzXR0dFBcXMzFF1/MsmXLWLx4MYcddhjnnnsuI0eOZMeOHSxZsoR7772383WjKKK+vn6v4U8lJSUcfvjhvPDCC8yePZsXXniBCy64oHP7smXLePrpp6mvryeEQHNzM7t27Trg97hjxw5+/etfE0LofCyRSLBz58493r8kSZKk7CsrK6O5uXmPxwoKCjjuuOO4++67Offcc/f4Wx6SvfxLS0uzWaaUNoMavSN1dXWdt3fs2EF5eTmQDEm2bt3KFVdcwZAhQ9i4cSM333xz575TpkxhypQptLa28sADD7B48WI+8YlPUFFRwemnn945X83+zJgxg4cffpjq6mra2tqYOHEiADU1NSxdupSPfexjjB49mhACX/va13p8jaKiIlpbWzvvd3R00NDQ0Hm/oqKCiy66iPHjx6d/YiRJkiRlxSGHHMLWrVv3eKyuro6HH36Y448/nnvvvZcrrriis+c9JKdNSPeaQ8o2hz7pHXniiSeoq6ujsbGRRx99lBkzZgDJhLqwsJDS0lIaGxt56KGHOp+zc+dOVq1a1blPcXExiUTyR/HEE0/kscceY/PmzUCyG+Nf//rXXo8/depUtm/fzoMPPshRRx3VmZS3tLSQSCQYPHgwHR0dPPzww3ul7LuNGDGCtrY2Xn75Zdrb23nkkUdob2/v3H7iiSfywAMPdA6xamhoYOXKlQd9ziRJkiT1nalTp1JTU9N5P4oi7rjjDo4//nguvPBChgwZssdy3G1tbbzxxhtMnjw5F+VK+2WPGr0jRx99NL/4xS+or6/niCOO4IwzzgBg1qxZ3HrrrXz961+nvLycU045pTPciKKIZcuWcdtttxFCYMyYMZx33nkATJ8+nZaWFn73u9+xY8cOSkpKmDx5MkcddVSPxy8sLGT69Ok888wznHXWWZ2PT548mSlTpvC9732PoqIiTjnlFCorK3t8jdLSUs477zwWL15MFEWcdtppewxpmjVrFkDn+xw8eDAzZsxg2rRp7/wESpIkSXpHxo4dS0lJCevXr2fcuHEsX76choYGzjzzTEIIzJs3j5tuuonDDz+c6upqVq1axYQJEzpHA0hxE6IoynUN6h/8QUlf2P8ukiRJktK032uRNWvWsGLFCubPn7/fF7vlllu46KKLOhc06YV/0ytnDGqULn9Q0uc/6pIkSVLfycW1iH/TK2eco0aSJEmSJCkmDGokSZIkSZJiwqBGkiRJkiQpJgxqJEmSJEm5tpHkXDQ9feVCb7VszFE9GkCcTFjp8gclfU48JkmSJB2Y/nS94d/7yih71Chdm3JdQD/heZIkSZIkHTR71EiSJEmScq0/XZjao0YZZY8aSZIkSZKkmDCokSRJkiTF1qJFizjhhBMoKytj+PDhXHzxxaxevXqfz2loaOC6665j+vTpDBo0iNGjR3PppZdSW1u7x34/+MEPePe73015eTkhBEIIPPTQQxl8N9L+OfRJkiRJkpRrPV6Y/uhHP+Lyyy8HYOLEiWzdupW6ujpGjx7NX/7yF8aMGdPji5111lk88MADhBCYMWMGGzZsYNu2bUycOJFnn32WiooKAObNm8e9997L2LFjefXVVwF48MEHmTNnzr5qdeiTMsoeNZIkSZKk2GlpaeGaa64B4IMf/CCvvvoqL730EuXl5WzevJnrr7++x+e9+OKLPPDAAwB885vf5LnnnmP16tUMGjSI1157jRtvvLFz3xtvvJG6ujq+853vZP4NSWkyqJEkSZIkxc6KFSvYsmULkAxqAKqqqpg1axYA99xzT4/P6+jo6LydSCQveUPo6gRz7733dt6uqqqisLCwbwuX3iGDGkmSJElS7Kxbt67z9ujRoztvH3LIIQC8/vrrPT5v+vTpHHvssQB8/vOf59hjj2XKlCns2rULgA0bNmSqZKlPGNRIkiRJkmKnt/lU9zfPakFBAXfddRcf//jHGTNmDGvWrGHGjBm8613vAqCoqKjPa5X6kn28JEmSJEmxM378+M7bmzdv3uv2YYcd1utzq6qq+MlPftJ5P4oipk2bBtD5XYore9RIkiRJkmLnpJNOYsSIEQDceuutANTW1vL4448DMHfuXCC5wtO0adP4whe+0Pncp59+mh07dnTe/+pXv8rLL78MwPz587NSv3SwDGokSZIkSbFTXFzcubLTrbfeyqRJk5g+fTr19fWMHDmyc0WoNWvWsGrVKt54443O5/785z/nkEMOYcaMGYwdO5Z/+7d/A+BDH/oQF198ced+CxYsYMqUKVx55ZWdj11yySVMmTKF7373u9l4m9JeDGrUL9XX10f19fX7HpwqSZIkqV+78sor+eUvf8lxxx1HbW0tIQTe//73s3TpUqqqqnp93kknncTUqVNZu3Yt27dv55hjjuHb3/42v/rVr/bYb9OmTaxZs2aPkKe2tpY1a9awbdu2jL0vaV/C/iZikuJod0hTXl4e9revJEmSpNjrTxemXoMoo+xRI0mSJEmSFBMGNZIkSZIkSTFhUCNJkiRJkhQTBjWSJEmSJEkxYVAjSZIkSZIUEwY1kiRJkiRJMWFQI0mSJEnKtU25LiBN/aVO9WNZCWpCCHNDCKtCCKtDCNf0sD2EEL6b2v5cCOGEbNQ1kKXRJtNCCH8OITSHEP4lFzUORGm0yyWpz8hzIYRlIYRjc1HnQJJGm1yUao9nQwhPhhBm56LOgWZ/7dJtv5NCCO0hhIuzWd9AlcbnZU4IYUfq8/JsCOE/c1HnQJLOZyXVLs+GEP4aQng42zUORGl8Vv53t8/JC6l/x4bnotaBJI12qQwh/CGE8JfU5+WyXNSZx8YAoftXCOG9IYSXQwhrQghf6GH78BDCHSGE50MIK0IIR+/eVl9fT319PW9/Th98jcn8qYivEMKPQwibQwgv9LLda/s+EKIoyuwBQigAXgbOBtYDK4CPRFH0Yrd93gd8GngfcDLwnSiKTs5oYQNYmm0yGqgG5gFvRVH0zRyU2qv6+voIoLy8POS6lr6SZrucCrwURdFbIYT3Al/0s5I5abbJEKAhiqIohHAM8JsoiqblpOABIp126bbfn4Am4MdRFP0u27UOJGl+XuYA/xJF0fm5qHGgSbNNhgLLgLlRFL0eQhgdRdHmXNQ7UKT7b1i3/S8Aro6i6MzsVTnwpPl5uRaojKJoQQhhFLAKGBNFUUsuas53abbJN4CdURR9KYQwDfivKIrOgvy8XoiDEMIZwE7g51EUzehhu9f2fSAbPWpmAqujKHo19Y/YIuCit+1zEcmGjqIoehwYGkIYm4XaBqr9tkkURZujKFoBtOaiwAEqnXZZFkXRW6m7jwPjslzjQJNOm+yMuhLvwUBm029Ber9XIPlHwq2AF53ZkW67KHvSaZO/BW6Louh1SP7+z3KNA9GBflY+AvwqK5UNbOm0SwSUhxACMATYBrRlt8wBJZ02ORK4HyCKopXAhBDCIdktc2CJougRkj/7vfHavg9kI6g5FFjX7f761GMHuo/6juc7ng60XT4J3J3RipRWm4QQ3h9CWAncCXwiS7UNZPttlxDCocD7gZuzWNdAl+6/Yaekhg3cHUI4KjulDVjptMnhwLAQwkMhhKdCCB/LWnUDV9q/70MIg4C5JENnZVY67fJ9YDpQCzwPfDaKoo7slDcgpdMmfwE+ABBCmElyRID/kZlbXmv2gWwENT11NXv7/zins4/6juc7ntJulxDCe0gGNQsyWpHSapMoim5PDXeaB1yX6aKUVrvcACyIoqg98+UoJZ12eRqojqLoWOB7wB2ZLmqAS6dNCoF3AecB5wL/EUI4PNOFDXAH8nfYBcDSKIr29b/X6hvptMu5wLNAFXAc8P0QQkVmyxrQ0mmTr5EMm58l2ZP2GezllGtea/aBwiwcYz1wWLf740im0Ae6j/qO5zue0mqX1DwoPwTeG0XR1izVNlAd0GcliqJHQgiTQwgjoyjakvHqBq502uVEYFGydzojgfeFENqiKLojKxUOTPttlyiK6rrdviuEcKOfl4xK92+wLVEUNQANIYRHgGNJzguhzDiQ3y3zcdhTtqTTLpcBX0sNeV4dQngNmAY8kZ0SB5x0f69cBslJbIHXUl/KHa81+0A2etSsAKaGECaGEIpJ/sJZ/LZ9FgMfS80QPQvYEUXRG1mobaBKp02UffttlxDCeOA24O+iKPKP6MxLp02mpP4wIDWrfTFggJZZ+22XKIomRlE0IYqiCcDvgH80pMm4dD4vY7p9XmaS/DvEz0vmpPP7/vfA6SGEwtQwm5OBl7Jc50CT1t9hIYRK4N0k20iZl067vA6cBZCaB+UI4NWsVjmwpPN7ZWhqG8DlwCPd/1NAOeG1fR/IeI+aKIraQgj/BNwDFJBceeOvIYS/T22/GbiL5KzQq4FdpFJRZUY6bRJCGAM8CVQAHSGEfwaO9B++zEnzs/KfwAjgxtS1TlsURSfmquZ8l2abfJDkL6NWoBH4cLfJhZUBabaLsizNdrkY+IcQQhvJz8t8Py+Zk06bRFH0UghhCfAc0AH8MIqiHpdcVd84gH/D3g/cm+rtpAxLs12uA34aQnie5PCOBfYIzJw022Q68PMQQjvwIsmpAZRBIYRfAXOAkSGE9cD/AYrAa/u+lPHluaVMcLk9SZIkSb3xekH9WTaGPkmSJEmSJCkNBjWSJEmSJEkxYVAjSZIkSZIUEwY1kiRJkiRJMWFQI0mSJEmSFBM5DWpCCFfm8vjqme0SP7ZJPNku8WObxJPtEk+2S/zYJvFku8ST7RI/tknfyXWPGhsynmyX+LFN4sl2iR/bJJ5sl3iyXeLHNokn2yWebJf4sU36SK6DGkmSJEmSJKWEKIp63Th37txoy5YtGTv4m2++yahRozL2+jo4/aFdOjo6AEgkBkbW2B/aZCCyXeLHNokn2yWebJf4sU3iyXaJp/21y0C7XogDPysH5qmnnroniqK5PW3bZ1AD7HOjlCv19fUAlJeX57gSSZIkSXHj9YL6gdDbBuNFSZIkSZKkmDCokSRJkiRJigmDGkmSJEmSpJgwqJEkSZIkSYqJwlwXIB0MJwWTJEmSJOUje9RIkiRJkiTFhEGNJEmSJElSTBjUSJIkSZIkxYRBjSRJkiRJUkxkPqjpiKCxOeOHkSRJkiRJXZpao1yXcNDaOyJa2+NVf7ZqytyqT+0d8MY2WLkemlrhlnsgXudYkiRJkpSP/uezAPztoi05LiR3RgxKcMVJ5WxpaOfRtU2s2tKW65IOyKzDSjh9Qgmrt7bx6NomtuzqyHVJnDq+hNOqSxhSEjisspDSopCR42R2ee71W6G0OPnV0gZLV2b0cJIkSZIk7ba0piXXJeTMp2YNAWDk4ALGlBfy46d25bii9BUm4IqThlCQCBwxqog7VzXmvC0LE3DVzHIKEoHGVmhsizIW1GRu6FNBAsYO67o/b1bGDiVJkiRJkpIqSgLvmVTaef/3LzbmsJoDN7u6hBGDCgDYuqudR9fmfjqVMyaUMKwsGaEUJqCyNDMhDWR6jpqxw2B37UeNhyMOzejhJEmSJEka6N57eBklhcmL8Ve2tPLXza05rujAzDuyrPP2nSubaMv9qCfmHTmo8/bIwQkSob8GNcVFMKqy6/68kzN6OEmSJEmSBrKiBJw3rSvo+P1L/as3zYxDipg8ogiA5raIJa/kvv5jxhQxcXhy5pgQYPigzEYpmV/1qWpE1+3ZR8Loyt73lSRJkiRJB+2MiV1DdLY0tPNYDIYNHYjuvWnuX9NEfXPuVyXqXtPwsgSFicz1poFsBDVDSqFycPJ2QQIumJnxQ0qSJEmSNBB1H6Lzh5WNxGyF632qKi/g5MNKOu/HYW6dcZUFnDSuq6aRgzMfo2T+CACHDu+6Pfd4KCvOymElSZIkSRoojhtbxIRhySE6ja0R97zSlOOKDsxF3XquPLGumdr69hxWk3TR9K6aKkpC59w/mZSdoGbYkK5wZnApnHN8Vg4rSZIkSdJA0b03zX2rG2lo6T/dacpLAmdN7lqp6o4Y9KZ5++pZ2ehNA9kKakKAQ7vNVXPRTMjwmC5JkiRJkgaK8ZUFvOvQZAeJjihicT+bRHju1K6VqtZsa+X5Tblfqar76lllRYHBxdnJMbIT1EBy9afC5DrojBkGp0zL2qElSZIkScpnF3YbNvT46y1s3BmDNa3TVJiA86d19VyJw9w0b189a+TgBCGDS3J3l72gpiABY4d13X//rKwdWpIkSZKkfFVZuucQnf62JPfpE0oYPijZsWPrrnYejcFKVd1XzypKwNDS7I0Kyl5QAzC226TCRx4GU8dm9fCSJEmSJOWbc6aUUVyQDBJe3dbGi5tzP2zoQFzQrefKkpebaItBZ6DuNQ0flL3eNJDtoKaxpet2Sxts2pHVw0uSJEmSlG821LV13h45OEFJQQ6LOQjr67pWd6qqiEfx3WtqzvIa59kNamq3dt2+/y9Qtyurh5ckSZIkKd88vq6FjamlrCtKEryn2+pJ/UH3OWlOn1DCiEHZjSp60r2m7Y0RrVkMa7L37htbYGt91/07lmft0JIkSZIk5auOiD1Webpoehn9aZ3lNdvaeH5jcgROYSJwfrdhR7nyytY2/tpt5aktDdkbj5W9oKZ2W9ftFa/Aui1ZO7QkSZIkSfnsvtVNNLQkw4RxlYWcmFqqu7+4o1sPlrlTSyktzGExKXe82DUKaNuuDjo6stOrJjtBTVs7bHqr6/7tj2flsJIkSZIkDQSNbRH3vNLUef+iI3PfK+VArFjfQm1qrp0hJQnOisHwrSfWt/BGakhZewTbGrPTqyY7Qc3Gt5J9sQBe2wTPvpaVw0qSJEmSNFD8cWUj7alr72PHFjNxWDwm5k1HxJ7Lil84fRCJHI/f6ojgD91q2tLQQRRlvldN5oOajmjPYU932JtGkiRJkqS+9mZDB0trmjvvX3TkoBxWc+DuX9NEfXOy10pVRQEzx+V++NZ9q5vYmRpS1tIO9c35ENRsrUsuxQ2wbSc8+ELGDylJkiRJ0kDUfa6XMyaUMLws9ysopau5DZa8HK/hW41tEfd0q+nNLEwqnNkWiyLY0G1J7jtXJOerkSRJkiRJfe6VrW28uDm5WlFRQeC8I3I/18uB+OPKRtpSw7dmHFLM1BG5n1W4+5CyhpaIXa2Z7VWT2aCmbhfsTCVPza1w51MZPZwkSZIkSQNd99WK5h5RRknus460bWvs4NHXug/fyn2vmi27Onis25CyLQ2Z7YCS2aBmQ7e5ae5/LhncSJIkSZKkjFm+roWNqdWKKkoSnDmpf/Wq6T6p8OzqEkYOyv3wre5DyrY3RrS2Z65XTebebWsbbN/Zdf/3yzN2KEmSJEmSlNQRweJuYcecfhbUrNnWxnMbW4iiiMa2iNMnlOS6JFZvbeOFTS2d97dncKnusJ+lpd5ZRNTSCpd+B+adDH9Z+45eSpIkSZKkdNR/YR4AP30+t3XkUkGAY8YU82ZDO795fhenVuc+7DgQw8sSDCoKPLq2mdkTigkhx2t1A4OKAhUlCSYNL2T0kMQ7ranXJ2d2pFpxEZQVQ+VgOOOojB5KkiRJkiSA8qWvsP7Blznyinm5LiWnmtsjKkoTjByc4MjRRbku56CMHlLACYeWMGFYP5po5x3K/DsNARK5H08mSZIkSRo4vBTt0p/PxSHlCVasbzao6VOJkOxzJUmSJElSlgQyvXpO/9Gfz8X4ygKWvd5CfXMH5SX99V0cmOxEUjEYSyZJkiRJGkBCst+AUkFNPz0XxQWBEWUJ/vJGC7Mn9K9JkQ9WloY+9dOfCEmSJElSv5QMJ7wWBQgh9OtzMWFYIU+sa+GU8SUUDIB8wTlqJEmSJEl5J+Dgjt36+7kYWpYgAl7d1sbUkf1zUuQDkYWgBnvUSJIkSZKyysEdXfLhXIyrKODJ9S0GNX0iH34iJEmSJEn9jpeiSfnQf2L80AIeeq2Z7Y0dDC3L71E7Dn2SJEmSJOUd+wx0yYdzkSgIHDKkgGffaGHOpPyeVNihT5IkSZKkvBMIhP48MUsfy4dzMWl4IU9taGH2hBIK8zhnyE6Pmjz4gZAkSZIk9S95fC1/QPKhRw1AZWmC4oLAK1vamD46f+eqceiTJEmSJCnv5Es40RfyaaDLxGEFrFjfbFDzjuTTT4QkSZIkqV/wUrRLPoVW4yoLeHFzG1sa2hk5uCDX5WSEqz5JkiRJkvJOwFk4dsunc1FYEBhXWcAzb7Rw9pSyXJeTEQ59kiRJkiTlnwBeiSYF8utcTB1RwCNrW3j3xFKKC/IkgerGoU+SJEmSpLwTgITXokByxad8OhflpQVUlgZWvdnK0WOKc11On3PokyRJkiQp74SQDGuUlG/nYtLwIp5c32JQc1DsUSNJkiRJyjIvRbvkY/+JcRUJnnsjYlN9O4eU59ekws5RI0mSJEnKS/kWThysvAytQmDi8AKerm3hvUfk16TCmQ9qCPkzvbQkSZIkqV9I9iLxWhTy91xMHl7In1Y3GdQcsLyM7iRJkiRJcRYIXoqm5OtleWlhoL0j11X0PYc+SZIkSZLyj4M7OoU8PRf5OmG0qz5JkiRJkvJOvvYiORj5ei4SgbxMahz6JEmSJEnKO8lLUa9FAUIIeXkuEvaoOUgOfZIkSZIkZZmDO7rka/8Je9QcLD8dkiRJkqQcyMNOJAcnj+eoyUfZGfqUr2dPkiRJkhRL9hnoks89avLwbWWpR02BQ58kSZIkSdmTr+HEwcjX0Cof3xM49EmSJEmStD8f/ga8tB5WfBNKivr+9X/2APxuGazaABecBP/fJ/a9/w//BDcvgeZWmHsCfOWSverqKah570/eZNuuDhKJQGECjh1bxL+/p4Ix5QV9+nZ2NHXwxfvq+PPrzQwrS/DpU4fwviPKet3/F8808NOndtHcFnHWlBL+bU4FxYV9dx3d07m4a1Ujv3xmF6+91c7gosARowq5/KTBHF9V3GfHbWmL+L8P1XHfK82UFgU+fsIg/u6Ewb3uf9eqRr63bCdvNXYwa3wJX/qbCipLe+/4kexRk395g0OfJEmSJEm9W7cFVrwC5WVw/3Nw3ol9f4xDhsKnz4dHXoCm1n1fQz78Atx8N/zqX5LPu/K/4IbFcM3Fe+7Xw0V8AL57wTBmjS+hORUiLHy4nhvOH9anb+erD9VTVBB48PLRrNzSxqcXv8URI4uYMmLvkGtpTTM/eXIXt3xgGKMHF3D1nW9x0/IG/vm08j6rJznnbte5+PnTDfz4qQb+/T0VnFpdTFEisLSmmYdebeaEqpI+O+7Ny3fy+vZ2llw2ii27Orj8tm1MHl7EaRP2Psbqra185YF6vn/hMKaPKuTLD9Rx/YP1fP29Q/f5vvIwp3HVJ0mSJEnSPtz+OJwwGY6bBLcugwtm9v0xzjsp+f35GnjjrX1fQ976Z/jwGTDtsOT9z14In/kBXPu/9titt6FPuwd9lBUFzplSytcfqevTQSC7Wju4b3UTt390JENKEpx4aDFzJpVw58omrp69d1Dzh5ca+cBRZRw+MrntqplDuOaeHXxudh8GNd0GutQ3d3Dj8p1cd3Yl50wt7dznzMmlnDm5tJdXODh/XNnIdWdXMrQswdCyBB+cUcbilY2cPnHvoObuVU28e2IJJ41L9uj59ClDuPAXW2hs7WBwcc8/D/k6eMehT5IkSZKk3t26DK44F06YBBd8BbbWwajKnvf9ws/hjsd73nboCLjvun0fa/dyy/u6hny5Fs49vmufGePhzTrY3gDDh+zxUj29TCJ1idrYGnHPK40cO7ao18N9+YEd3LWyqcdtYysKuP2jI/d6fN32dgoCTBredbk9bVQRK9a39HicNdvaOGtySee26aOL2Lqrg7qmDoaW9U2nh+7n4rmNrbS0RZw9pSTtS/VbVuzkRysaet3++D8estdjO5o62NzQwbRRhZ3HmTaqiAfXNPd6Ho7r1hbVwwopKgi8vr2dow7p+TwEJxM+SM7gJEmSJEn90/KXYf1WuGgmjCiH6lFwx3K46tye9194afLrYO2+8t7XNeSuJqgc1LVP5aDk98YmSHTrhRLC3i8T4DN/2E5BAna1RAwflOCHHxjW6+G+eFYlXzyrl1CqF42tEeUliT1es7wksKu1o8fjNLZGVJR27V9RElKPdzB8UB8FNd36T9Q1dTCsLEFxQfrX6VfNHMJVM4fsf8dumtoiACrf9t4a9nUe3n7eigONvewP+Rs1OPRJkiRJktSz3y6FOTO6etB88NTkY//w3swcL4T9X0MOLoWG5q59GpqT38sH7fG83qZL/f6FQzm1uoT2joj71zTzsd9s448fH8mowX0zofDgksDOlo49jt3QEjG4ONFjPYOKAg3d9m9ojVKv0/P+B2v3aw0rS/BWYwftUURhBpOOwcXJ125o7aC0KHluG1oiBhf1ch6KkyFO9207W6J9nofdPy75xqFPkiRJkqS9NbbA4iegvQNmfDr5WEsr7NgFL74OM6r3fs6//CQZ5PTksJHw2Nf2fczdl477uoacNg5eXAfvn5W8/9K6ZJA0smLPlwqQeNtVfCAQQiARAomCwNzDy/g/99XxTG0rcw/f+/L4P/+0g8UvNfZYRlVFAXd9fNRej08aXkh7B7y+vZ0Jw5KvuWpLG1NHFO5VD8DUkYWs2tLGedOS217e0sbIQQlGDOq7lah2v2eAEw4tpqQw8MCaZuYe3vtKVN3dtHwn/718Z6/bn/3MmL0eG1ZWwOjBCV5+s53TJiTPw8tb2pg6spfzMKKQVW+2dW57fXsbre0Rk4b3vD/kb9Tg0CdJkiRJ0t6WPAUFCXjsq1DU7dLxk99LhjHHTNj7Od/6RPLrQLW1J786ouRXSysUFiS/3m7+bPinH8CHToMxQ+Fbi+Ejp+913bm/OWqiKOK+Nc3UNXUwZURhj/t+5ZxKvnLOgQ19GlKc4JyppXx3WT3Xn1PJS2+2cf/qJn7ztyN6PMb7jypjwd07uGh6GaOHFHDT4zv5wIyyPr2M7n4uKksTfPa0IXzp/jqKEoHZE0ooTMCymmYeX9fCgndX7PX8T80awqdmHdjQJ4B5R5Vx4/KdHDO2iC0NHfzm+V18bW5lj+/toiPL+ND/v5WnNrRw1OhCvrusnnOmllJRsu/lufORPWokSZIkSXv79WNwyRkw/m29Rq44B675OXzpIz0HKQfjW7+Hhbd13f/tUljwAbjmg8nlwU/5V/jz15O9cs4+Dj5zPsz7v9DUklyF6tqLe7zu7OlS9Mrbt1EQkotVH1pZwDfeN5Rpo/ZejemduO7sShYs2c7JN21maGngurMrO4+xoa6dc3/8Jvd8YhSHVhTwnkmlXDmzjY/+ZhvNbRHnHl7K1aeV921Q87bL8itOGsKowQX81+M7+dxd2xlcFJgxpohPzRrSp8e9+rRy/uNPO3j3DzZTUhi4auZg3jOpa2WpGTds5McXD2fmuGKmjSriK2dX8rk732J7U8Rp1cV8fe7QfdaTyNPJhEMURfvavs+Nabn+t/CFi/e/nyRJkiRJfST66u+8Fk359mP1XN2Hy33HRUt7xC1PNPBPp/bL99ZrxpT5HjWQn7P7SJIkSZJiK4DXoinJSXfz71yE3cu55xmXY5IkSZIkSYoJgxpJkiRJkqSYMKiRJEmSJEmKCYMaSZIkSZKkmDCokSRJkiRJigmDGkmSJEmSpJgwqJEkSZIkSf1OUQL+cdaQXJfR50IURfvavs+NkiRJkiRJOmChtw32qJEkSZIkSYoJgxpJkiRJkqSYMKiRJEmSJEmKCYMaSZIkSZKkmDCokSRJkiRJigmDGkmSJEmSpJgwqJEkSZIkSYoJgxpJkiRJkqSYMKiRJEmSJEmKCYMaSZIkSZKkmDCokSRJkiRJigmDGkmSJEmSpJgwqJEkSZIkSYoJgxpJkiRJkqSYMKiRJEmSJEmKCYMaSZIkSZKkmDCokSRJkiRJigmDGkmSJEmSpJgwqJEkSZIkSYoJgxpJkiRJkqSYMKiRJEmSJEmKCYMaSZIkSZKkmDCokSRJkiRJigmDGkmSJEmSpJgwqJEkSZIkSYoJgxpJkiRJkqSYMKiRJEmSJEmKCYMaSZIkSZKkmDCokSRJkiRJigmDGkmSJEmSpJgwqJEkSZIkSYoJgxpJkiRJkqSYMKiRJEmSJEmKCYMaSZIkSZKkmDCokSRJkiRJigmDGkmSJEmSpJgwqJEkSZIkSYoJgxpJkiRJkqSYMKiRJEmSJEmKCYMaSZIkSZKkmDCokSRJkiRJigmDGkmSJEmSpJgwqJEkSZIkSYoJgxpJkiRJkqSYMKiRJEmSJEmKCYMaSZIkSZKkmDCokSRJkiRJigmDGkmSJEmSpJgwqJEkSZIkSYoJgxpJkiRJkqSYMKiRJEmSJEmKCYMaSZIkSZKkmDCokSRJkiRJigmDGkmSJEmSpJgwqJEkSZIkSYoJgxpJkiRJkqSYMKiRJEmSJEmKCYMaSZIkSZKkmDCokSRJkiRJigmDGkmSJEmSpJgwqJEkSZIkSYoJgxpJkiRJkqSYMKiRJEmSJEmKCYMaSZIkSZKkmDCokSRJkiRJigmDGkmSJEmSpJgwqJEkSZIkSYoJgxpJkiRJkqSYMKiRJEmSJEmKCYMaSZIkSZKkmDCokSRJkiRJigmDGkmSJEmSpJgwqJEkSZIkSYoJgxpJkiRJkqSYMKiRJEmSJEmKCYMaSZIkSZKkmDCokSRJkiRJigmDGkmSJEmSpJgo3M/2kJUqJEmSJEmSZI8aSZIkSZKkuDCokSRJkiRJigmDGkmSJEmSpJgwqJEkSZIkSYoJgxpJkiRJkqSYMKiRJEmSJEmKif8H92VSrZaAS2cAAAAASUVORK5CYII=\n",
-      "text/plain": [
-       "<Figure size 1440x216 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# visualize the first prediction's explanation (use matplotlib=True to avoid Javascript)\n",
-    "shap.force_plot(shap_values[\"Y0\"][\"T0\"][0], matplotlib=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 576x223.2 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "shap.summary_plot(shap_values[\"Y0\"][\"T0\"])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<table border=\"0\">\n",
+    "    <tr>\n",
+    "        <td>\n",
+    "            <img src=\"https://ictd2016.files.wordpress.com/2016/04/microsoft-research-logo-copy.jpg\" style=\"width 30px;\" />\n",
+    "             </td>\n",
+    "        <td>\n",
+    "            <img src=\"https://www.microsoft.com/en-us/research/wp-content/uploads/2016/12/MSR-ALICE-HeaderGraphic-1920x720_1-800x550.jpg\" style=\"width 100px;\"/></td>\n",
+    "        </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Doubly Robust Learner and Interpretability\n",
+    "\n",
+    "Double Machine Learning (DML) is an algorithm that applies arbitrary machine learning methods\n",
+    "to fit the treatment and response, then uses a linear model to predict the response residuals\n",
+    "from the treatment residuals."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Helper imports\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib\n",
+    "%matplotlib inline\n",
+    "\n",
+    "import seaborn as sns"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Generating Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import scipy.special\n",
+    "\n",
+    "np.random.seed(123)\n",
+    "n=2000 # number of raw samples\n",
+    "d=10 # number of binary features + 1\n",
+    "\n",
+    "# Generating random segments aka binary features. We will use features 0,...,3 for heterogeneity.\n",
+    "# The rest for controls. Just as an example.\n",
+    "X = np.random.binomial(1, .5, size=(n, d))\n",
+    "# Generating an imbalanced A/B test\n",
+    "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,))\n",
+    "X_test = np.random.binomial(1, .5, size=(10, d))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Applying the LinearDRLearner"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<econml.drlearner.LinearDRLearner at 0x2e3934ec710>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from sklearn.linear_model import LassoCV\n",
+    "from econml.drlearner import LinearDRLearner\n",
+    "from sklearn.linear_model import LogisticRegressionCV\n",
+    "from sklearn.dummy import DummyClassifier\n",
+    "\n",
+    "# One can replace model_y and model_t with any scikit-learn regressor and classifier correspondingly\n",
+    "# as long as it accepts the sample_weight keyword argument at fit time.\n",
+    "est = LinearDRLearner(model_regression=LassoCV(cv=3),\n",
+    "                      model_propensity=DummyClassifier(strategy='prior'))\n",
+    "est.fit(y, T, X=X[:, :4])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1.02346725])"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Treatment Effect of particular segments\n",
+    "est.effect(np.array([[1, 0, 0, 0]])) # effect of segment with features [1, 0, 0, 0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([0.66350818]), array([1.38342633]))"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Confidence interval for effect. Produces the (alpha*100/2, (1-alpha)*100/2)% Confidence Interval\n",
+    "est.effect_interval(np.array([[1, 0, 0, 0]]), alpha=.05) # effect of segment with features [1, 0, 0, 0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>point_estimate</th>\n",
+       "      <th>stderr</th>\n",
+       "      <th>zstat</th>\n",
+       "      <th>pvalue</th>\n",
+       "      <th>ci_lower</th>\n",
+       "      <th>ci_upper</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1.023</td>\n",
+       "      <td>0.184</td>\n",
+       "      <td>5.573</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.664</td>\n",
+       "      <td>1.383</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "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": 6,
+     "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": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[['A' '2.063277038041713']\n",
+      " ['B' '-0.0021408002029092827']\n",
+      " ['C' '-0.1307524180853436']\n",
+      " ['D' '0.08603974866683765']]\n",
+      "-1.0398097870143193\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Getting the coefficients of the linear CATE model together with the corresponding feature names\n",
+    "print(np.array(list(zip(est.cate_feature_names(['A', 'B', 'C', 'D']), est.coef_(T=1)))))\n",
+    "print(est.intercept_(T=1))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Getting the confidence intervals of the coefficients of the CATE model\n",
+    "# together with the corresponding feature names.\n",
+    "feat_names = est.cate_feature_names(['A', 'B', 'C', 'D'])\n",
+    "point = est.coef_(T=1)\n",
+    "lower, upper = np.array(est.coef__interval(T=1))\n",
+    "yerr = np.zeros((2, point.shape[0]))\n",
+    "yerr[0, :] = point - lower\n",
+    "yerr[1, :] = upper - point\n",
+    "\n",
+    "with sns.axes_style(\"darkgrid\"):\n",
+    "    fig, ax = plt.subplots(1,1) \n",
+    "    x = np.arange(len(point))\n",
+    "    plt.errorbar(x, point, yerr, fmt='o')\n",
+    "    ax.set_xticks(x)\n",
+    "    ax.set_xticklabels(feat_names, rotation='vertical', fontsize=18)\n",
+    "    ax.set_ylabel('coef')\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>point_estimate</th>\n",
+       "      <th>stderr</th>\n",
+       "      <th>zstat</th>\n",
+       "      <th>pvalue</th>\n",
+       "      <th>ci_lower</th>\n",
+       "      <th>ci_upper</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>A</th>\n",
+       "      <td>2.063</td>\n",
+       "      <td>0.143</td>\n",
+       "      <td>14.431</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>1.828</td>\n",
+       "      <td>2.298</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>B</th>\n",
+       "      <td>-0.002</td>\n",
+       "      <td>0.142</td>\n",
+       "      <td>-0.015</td>\n",
+       "      <td>0.988</td>\n",
+       "      <td>-0.236</td>\n",
+       "      <td>0.232</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>C</th>\n",
+       "      <td>-0.131</td>\n",
+       "      <td>0.143</td>\n",
+       "      <td>-0.916</td>\n",
+       "      <td>0.359</td>\n",
+       "      <td>-0.365</td>\n",
+       "      <td>0.104</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>D</th>\n",
+       "      <td>0.086</td>\n",
+       "      <td>0.143</td>\n",
+       "      <td>0.603</td>\n",
+       "      <td>0.546</td>\n",
+       "      <td>-0.149</td>\n",
+       "      <td>0.321</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "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": 9,
+     "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(feature_names=['A', 'B', 'C', 'D'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>point_estimate</th>\n",
+       "      <th>stderr</th>\n",
+       "      <th>zstat</th>\n",
+       "      <th>pvalue</th>\n",
+       "      <th>ci_lower</th>\n",
+       "      <th>ci_upper</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>cate_intercept</th>\n",
+       "      <td>-1.04</td>\n",
+       "      <td>0.146</td>\n",
+       "      <td>-7.114</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>-1.28</td>\n",
+       "      <td>-0.799</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                point_estimate  stderr  zstat  pvalue  ci_lower  ci_upper\n",
+       "cate_intercept           -1.04   0.146 -7.114     0.0     -1.28    -0.799"
+      ]
+     },
+     "execution_count": 10,
+     "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": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<table class=\"simpletable\">\n",
+       "<caption>Coefficient Results</caption>\n",
+       "<tr>\n",
+       "  <td></td>  <th>point_estimate</th> <th>stderr</th>  <th>zstat</th> <th>pvalue</th> <th>ci_lower</th> <th>ci_upper</th>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "  <th>A</th>      <td>2.063</td>      <td>0.143</td> <td>14.431</td>   <td>0.0</td>    <td>1.828</td>    <td>2.298</td> \n",
+       "</tr>\n",
+       "<tr>\n",
+       "  <th>B</th>     <td>-0.002</td>      <td>0.142</td> <td>-0.015</td>  <td>0.988</td>  <td>-0.236</td>    <td>0.232</td> \n",
+       "</tr>\n",
+       "<tr>\n",
+       "  <th>C</th>     <td>-0.131</td>      <td>0.143</td> <td>-0.916</td>  <td>0.359</td>  <td>-0.365</td>    <td>0.104</td> \n",
+       "</tr>\n",
+       "<tr>\n",
+       "  <th>D</th>      <td>0.086</td>      <td>0.143</td>  <td>0.603</td>  <td>0.546</td>  <td>-0.149</td>    <td>0.321</td> \n",
+       "</tr>\n",
+       "</table>\n",
+       "<table class=\"simpletable\">\n",
+       "<caption>CATE Intercept Results</caption>\n",
+       "<tr>\n",
+       "         <td></td>        <th>point_estimate</th> <th>stderr</th>  <th>zstat</th> <th>pvalue</th> <th>ci_lower</th> <th>ci_upper</th>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "  <th>cate_intercept</th>      <td>-1.04</td>      <td>0.146</td> <td>-7.114</td>   <td>0.0</td>    <td>-1.28</td>   <td>-0.799</td> \n",
+       "</tr>\n",
+       "</table><br/><br/><sub>A linear parametric conditional average treatment effect (CATE) model was fitted:<br/>$Y = \\Theta(X)\\cdot T + g(X, W) + \\epsilon$<br/>where $T$ is the one-hot-encoding of the discrete treatment and for every outcome $i$ and treatment $j$ the CATE $\\Theta_{ij}(X)$ has the form:<br/>$\\Theta_{ij}(X) = \\phi(X)' coef_{ij} + cate\\_intercept_{ij}$<br/>where $\\phi(X)$ is the output of the `featurizer` or $X$ if `featurizer`=None. Coefficient Results table portrays the $coef_{ij}$ parameter vector for each outcome $i$ and the designated treatment $j$ passed to summary. Intercept Results table portrays the $cate\\_intercept_{ij}$ parameter.</sub>"
+      ],
+      "text/plain": [
+       "<class 'econml.utilities.Summary'>\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",
+       "                       CATE Intercept Results                       \n",
+       "====================================================================\n",
+       "               point_estimate stderr zstat  pvalue ci_lower ci_upper\n",
+       "--------------------------------------------------------------------\n",
+       "cate_intercept          -1.04  0.146 -7.114    0.0    -1.28   -0.799\n",
+       "--------------------------------------------------------------------\n",
+       "\n",
+       "<sub>A linear parametric conditional average treatment effect (CATE) model was fitted:\n",
+       "$Y = \\Theta(X)\\cdot T + g(X, W) + \\epsilon$\n",
+       "where $T$ is the one-hot-encoding of the discrete treatment and for every outcome $i$ and treatment $j$ the CATE $\\Theta_{ij}(X)$ has the form:\n",
+       "$\\Theta_{ij}(X) = \\phi(X)' coef_{ij} + cate\\_intercept_{ij}$\n",
+       "where $\\phi(X)$ is the output of the `featurizer` or $X$ if `featurizer`=None. Coefficient Results table portrays the $coef_{ij}$ parameter vector for each outcome $i$ and the designated treatment $j$ passed to summary. Intercept Results table portrays the $cate\\_intercept_{ij}$ parameter.</sub>\n",
+       "\"\"\""
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "est.summary(T=1, feature_names=['A', 'B', 'C', 'D'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Polynomial Features"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<econml.drlearner.LinearDRLearner at 0x2e39fe94240>"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from econml.sklearn_extensions.linear_model import WeightedLassoCV\n",
+    "from econml.drlearner import LinearDRLearner\n",
+    "from sklearn.linear_model import LogisticRegressionCV\n",
+    "from sklearn.dummy import DummyClassifier\n",
+    "from sklearn.preprocessing import PolynomialFeatures\n",
+    "\n",
+    "# One can replace model_y and model_t with any scikit-learn regressor and classifier correspondingly\n",
+    "# as long as it accepts the sample_weight keyword argument at fit time.\n",
+    "est = LinearDRLearner(model_regression=WeightedLassoCV(cv=3),\n",
+    "                      model_propensity=DummyClassifier(strategy='prior'),\n",
+    "                      featurizer=PolynomialFeatures(degree=2, interaction_only=True, include_bias=False))\n",
+    "est.fit(y, T, X=X[:, :4])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Getting the confidence intervals of the coefficients of the CATE model\n",
+    "# together with the corresponding feature names.\n",
+    "feat_names = est.cate_feature_names(['A', 'B', 'C', 'D'])\n",
+    "point = est.coef_(T=1)\n",
+    "lower, upper = np.array(est.coef__interval(T=1, alpha=0.05))\n",
+    "yerr = np.zeros((2, point.shape[0]))\n",
+    "yerr[0, :] = point - lower\n",
+    "yerr[1, :] = upper - point\n",
+    "\n",
+    "with sns.axes_style(\"darkgrid\"):\n",
+    "    fig, ax = plt.subplots(1,1) \n",
+    "    x = np.arange(len(point))\n",
+    "    plt.errorbar(x, point, yerr, fmt='o')\n",
+    "    ax.set_xticks(x)\n",
+    "    ax.set_xticklabels(feat_names, rotation='vertical', fontsize=18)\n",
+    "    ax.set_ylabel('coef')\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>point_estimate</th>\n",
+       "      <th>stderr</th>\n",
+       "      <th>zstat</th>\n",
+       "      <th>pvalue</th>\n",
+       "      <th>ci_lower</th>\n",
+       "      <th>ci_upper</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1.192</td>\n",
+       "      <td>0.292</td>\n",
+       "      <td>4.081</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>0.711</td>\n",
+       "      <td>1.672</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>-1.057</td>\n",
+       "      <td>0.189</td>\n",
+       "      <td>-5.585</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>-1.368</td>\n",
+       "      <td>-0.746</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>1.065</td>\n",
+       "      <td>0.253</td>\n",
+       "      <td>4.202</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>0.648</td>\n",
+       "      <td>1.482</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>-1.057</td>\n",
+       "      <td>0.189</td>\n",
+       "      <td>-5.585</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>-1.368</td>\n",
+       "      <td>-0.746</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>-1.081</td>\n",
+       "      <td>0.177</td>\n",
+       "      <td>-6.095</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>-1.372</td>\n",
+       "      <td>-0.789</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>0.861</td>\n",
+       "      <td>0.277</td>\n",
+       "      <td>3.107</td>\n",
+       "      <td>0.002</td>\n",
+       "      <td>0.405</td>\n",
+       "      <td>1.318</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>0.926</td>\n",
+       "      <td>0.273</td>\n",
+       "      <td>3.397</td>\n",
+       "      <td>0.001</td>\n",
+       "      <td>0.478</td>\n",
+       "      <td>1.375</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>-0.892</td>\n",
+       "      <td>0.186</td>\n",
+       "      <td>-4.784</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>-1.199</td>\n",
+       "      <td>-0.585</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>0.926</td>\n",
+       "      <td>0.273</td>\n",
+       "      <td>3.397</td>\n",
+       "      <td>0.001</td>\n",
+       "      <td>0.478</td>\n",
+       "      <td>1.375</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>0.861</td>\n",
+       "      <td>0.277</td>\n",
+       "      <td>3.107</td>\n",
+       "      <td>0.002</td>\n",
+       "      <td>0.405</td>\n",
+       "      <td>1.318</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "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": 14,
+     "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": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<table class=\"simpletable\">\n",
+       "<caption>Uncertainty of Mean Point Estimate</caption>\n",
+       "<tr>\n",
+       "  <th>mean_point</th> <th>stderr_mean</th> <th>zstat</th> <th>pvalue</th> <th>ci_mean_lower</th> <th>ci_mean_upper</th>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "     <td>0.175</td>      <td>0.243</td>    <td>0.719</td>  <td>0.472</td>    <td>-0.225</td>         <td>0.574</td>    \n",
+       "</tr>\n",
+       "</table>\n",
+       "<table class=\"simpletable\">\n",
+       "<caption>Distribution of Point Estimate</caption>\n",
+       "<tr>\n",
+       "  <th>std_point</th> <th>pct_point_lower</th> <th>pct_point_upper</th>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "    <td>0.982</td>        <td>-1.07</td>           <td>1.135</td>     \n",
+       "</tr>\n",
+       "</table>\n",
+       "<table class=\"simpletable\">\n",
+       "<caption>Total Variance of Point Estimate</caption>\n",
+       "<tr>\n",
+       "  <th>stderr_point</th> <th>ci_point_lower</th> <th>ci_point_upper</th>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "      <td>1.012</td>         <td>-1.25</td>          <td>1.389</td>    \n",
+       "</tr>\n",
+       "</table><br/><br/>Note: The stderr_mean is a conservative upper bound."
+      ],
+      "text/plain": [
+       "<econml.inference.PopulationSummaryResults at 0x2e39f4f0358>"
+      ]
+     },
+     "execution_count": 15,
+     "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": {},
+   "source": [
+    "### Polynomial Features and Debiased Lasso Inference"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<econml.drlearner.SparseLinearDRLearner at 0x2e39fe94d30>"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from econml.sklearn_extensions.linear_model import WeightedLassoCV\n",
+    "from econml.drlearner import SparseLinearDRLearner\n",
+    "from sklearn.linear_model import LogisticRegressionCV\n",
+    "from sklearn.dummy import DummyClassifier\n",
+    "from sklearn.preprocessing import PolynomialFeatures\n",
+    "\n",
+    "# One can replace model_y and model_t with any scikit-learn regressor and classifier correspondingly\n",
+    "# as long as it accepts the sample_weight keyword argument at fit time.\n",
+    "est = SparseLinearDRLearner(model_regression=WeightedLassoCV(cv=3),\n",
+    "                            model_propensity=DummyClassifier(strategy='prior'),\n",
+    "                            featurizer=PolynomialFeatures(degree=3, interaction_only=True, include_bias=False))\n",
+    "est.fit(y, T, X=X[:, :4])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Parameter Intervals"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Getting the confidence intervals of the coefficients of the CATE model\n",
+    "# together with the corresponding feature names.\n",
+    "feat_names = est.cate_feature_names(['A', 'B', 'C', 'D'])\n",
+    "point = est.coef_(T=1)\n",
+    "lower, upper = np.array(est.coef__interval(T=1, alpha=0.05))\n",
+    "yerr = np.zeros((2, point.shape[0]))\n",
+    "yerr[0, :] = point - lower\n",
+    "yerr[1, :] = upper - point\n",
+    "\n",
+    "with sns.axes_style(\"darkgrid\"):\n",
+    "    fig, ax = plt.subplots(1,1) \n",
+    "    x = np.arange(len(point))\n",
+    "    plt.errorbar(x, point, yerr, fmt='o')\n",
+    "    ax.set_xticks(x)\n",
+    "    ax.set_xticklabels(feat_names, rotation='vertical', fontsize=18)\n",
+    "    ax.set_ylabel('coef')\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### CATE(x) intervals"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABJIAAAFlCAYAAACwQsIZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAA+HElEQVR4nO3de3gU9d3H/c8eSMgJIgYRVEQQklSsSEWiEiNIsAip0ADhoCi1kt7ccFesfVTkRlEM2KtSawstiAKPWm/kECFBCiqKQCEgVAQE5dDQKsITYgI5GJLNzvMHmmUMgQmwO5vd9+u6vExmZne/+3Wy89uP85txGIZhCAAAAAAAADgHp90FAAAAAAAAoGkgSAIAAAAAAIAlBEkAAAAAAACwhCAJAAAAAAAAlhAkAQAAAAAAwBKCJAAAAAAAAFjitruAC+H1elVba9hdxkXhcjlC5r1cKHphRj/M6IcPvTCjH2b0w4demNEPM/rhQy/M6IcPvTCjH2b0wyeUetGsmavBdU06SKqtNVRaWml3GRdFfHx0yLyXC0UvzOiHGf3woRdm9MOMfvjQCzP6YUY/fOiFGf3woRdm9MOMfviEUi9at45rcB1T2wAAAAAAAGAJQRIAAAAAAAAsIUgCAAAAAACAJU36GkkAAAAAAADnUlvrUUlJkTyear+9xtGjDhlG07rYttsdoUsuaS2Xy3o8RJAEAAAAAABCWklJkZo3j1ZMzOVyOBx+eQ2Xy6naWq9fntsfDMNQRcUJlZQUKSGhreXHMbUNAAAAAACENI+nWjExLRoVImUv2qHsRTv8WJW9HA6HYmJaNPosLYIkAAAAAAAQ8vx1JlJTdj49IUgCAAAAAAA4zao9R7Xz6xPa/uVxZcwt0Ko9Ry/6ayxduuis6w8c2K9PPtneqOcsLj6m3/9+xoWUdU4ESQAAAAAAAN9ZteeoctbsU03tqQtnHyk7qZw1+y56mLRw4atnXf/hh++rsPBgo57z0ksT9Oijj19IWefExbYBAAAAAAC+M3t9oao85otmV3m8mr2+UP2T25zXc/7734eUkzNVbrdbLpdL3bvfpBMnjuv3v5+h//qv8ZoxY5rKy8t0/HipMjIGq1ev27VqVb7c7mbq0iVJP/pR13rPWVJSoqeeekJer1e1tR49+ugkRUdH66mnJmnu3AXauHG9Xnnlr4qJiVVcXAt16nStHnww+7zqPx1BEgAAAAAAFmQv2iG326lZmdfbXQr86GjZyUYtt2Lr1gIlJiZpwoRHtGPHP3XJJZdo6dK39Oijj+vzz/eqb99+Skvro2PHijR+/FgNHjxE/fsP1KWXXnrGEEmS9uzZrZiYWD399DT961//UkVFuaKjoyVJtbW1evHF32vOnFfVqtWlmjp18nnX/kMESQAAAAAAAN9pExepI2cIjdrERZ73cw4ceI/eeGOhfvObCYqJiVV29n/Xrbv00kv11lt/07p1Hyg6OkYej8fSc6ak3Kovv/y3Hn/8N3K73br//gfr1pWWligmJkatWl0qSbrhhm4qLi4+7/pPxzWSAAAAAAAAvjMutYOau81xSXO3U+NSO5z3c27YsE433HCj/vjHv6h37zv1xhsLZRinrsH05puvqWvXH2vKlGfVp0/fuuVOp1Ner9Hgc/7zn9t06aUJ+sMfZun++x/UnDmz6tZdckkrVVZWqKSkRJK0e/eu8679hzgjCQAAAAAA4DvfXwfp2dVfqKbW0OVxkRqX2uG8r48kSUlJP9Izz/yvXC6XnE6nJkx4RF9/fVjPPPO/GjjwHv3+99O1Zs0qtWzZUi6XS9XV1UpMTNbs2X9Uhw7XqHv3m+o957XXdtaUKZP01ltvyul0asyYh+rWOZ1OTZz4/+i3v/21YmJiZRheXXnlVedd/+kIkgAAAAAAZ8Q1gRCu+ie30dufHpEkzcm64ZzbH/qmUnJIV18Sfcb1V1xxpebMmW9a9qc/zan7+W9/W1rvMbfe2ku33tqrwdds2TJef/zj7HrL585dIEnav/8LzZ49TxEREXrmmf/VZZedfxB2OoIkAAAAAACAH7ASIAXC/Pkva9u2rfWWT5r0lNq1u6LBx0VHRys7+wE1b95cl1/eTnfe2e+i1EOQBAAAAAAAEKTGjHnING3NqszMLGVmZl30erjYNgAAQJjIXrRDo14psLsMAADQhBEkAQAAAAAAwBKCJAAAAAAAgB9oOehutRx0t91lBB2CJAAAAAAAAFhCkAQAAAAAAHCayKVvqdm2rWr2jw1q1f06RS5964Kfc/Pmf2j58mV+2z5QuGsbAAAAAADAdyKXvqW4RybIcfKkJMn15X8U98gESdLJzGHn/bwpKbf6dftACXiQtGPHDv3+97/Xa6+9Zlo+f/58LVmyRK1atZIkTZ06VR07dgx0eQAAAAAAIIzFPDdVjm+/NS1zfPutYp6bekFB0jvv5Kmg4B86cuSILrusjb766kv96EfX6dFHn9Cnn36iP//5RbndbsXFxempp6bpww/X6tChQv3Xf03QggXz9NFHHyg+/hJVVVXpl7/8lbp3v+lC3+p5CWiQ9PLLL2vFihWKioqqt2737t16/vnn1bVr10CWBAAAAAAAUMf51ZeNWt5Y//nPv/WHP/xZkZHNNWzYPSouPqb169cpLa23Roy4Txs2fKQTJ8rqtt+37wtt3vwPvfzy/yuPp0ajRw+/KHWcr4BeI6l9+/b605/+dMZ1u3fv1ty5czVixAjNmTMnkGUBAAAAAABIkrxXXNmo5Y11xRVXKjo6Ri6XS5demqDq6mrdd98YlZSU6Ne//i99+OH7crt95/0cOvQvJSdfJ5fLpcjI5kpKSr4odZyvgAZJd911l6kZpxswYICefvppLVy4UNu2bdMHH3wQyNIAAAAAAABU8eRTMn4wk8qIilLFk09dlOd3OBz1lr377irdffdA/elPc3TNNR21YoXvItvXXNNJe/fultfrVXV1tb744vOLUsf5CoqLbRuGofvvv19xcXGSpLS0NH322Wfq3bv3WR/ncjkUHx8diBL9zuVyhsx7uVD0wox+mNEPH3phRj/M6IcPvfBxu51yOEJn/HQxsH/40Asz+nEKnxtm9KO+pvK3cvSoQy6XtXNpPMOGq8LpUMz/jJNOnpT3yqv07f8+Lc+QLLkaepBDcujsr+F0OuRwOORwqG6773++7rqueu65pxUVFa1mzZrp8ccn65//3Can06EuXbro1lt7KTt7jOLj49WsWTNFRERYfj/n0th9OiiCpPLycg0cOFDvvPOOoqOjVVBQoMzMzHM+rrbWUGlpZQAq9L/4+OiQeS8Xil6Y0Q8z+uFDL8zohxn98KEXPh6PV263k36chv3Dh16Y0Y9T+Nwwox/1NZW/FcMwVFvrtbz9t4OHKmLhfEnS8bffObXwbI83JMNx9tf46U8H6qc/HXjqqb7bbs6cBZKkyy67XK+88nq97SXp2LFjiomJ08svL/xuGtwwJSRc1qj3czaGUT9bad06rsHtbQ2S8vLyVFlZqaysLE2cOFGjR49WRESEbrnlFqWlpdlZGgAAABA2shftkNvt1KzM6+0uBQCCRl2AZLOWLeO1d+9n+uUvR8vhkAYOHKTLL7/ctnoCHiRdeeWVeuuttyRJGRkZdcsHDRqkQYMGBbocAAAAAACAoOV0OjVp0sW5PtPFENCLbQMAAAAAAKDpIkgCAAAAgNNkL9qhUa8U2F0GgIvMMAy7Swg659MTgiQAAAAAABDS3O4IVVScIEw6jWEYqqg4Ibc7olGPC4q7tgEAAAAAgKalKV2o/5JLWqukpEjl5aV+ef7yimpJDh052cwvz+8vbneELrmkdeMe46daAAAAAAAAgoLL5VZCQlu/Pf9TdaHatX57jWDB1DYAAAAAAABYQpAEAAAAAAAASwiSAAAAAAAAYAlBEgAAAAAAACwhSAIAAAAAAIAlBEkAAAAIS9mLdmjUKwV2lwEAQJNCkAQAAAAAAABLCJIAAAAAAABgCUESAAAAAAAALCFIAgAAAADgHFbtOaqdX5/QlsISZcwt0Ko9R+0uCbAFQRIAAAAAAGexas9R5azZp5paQ5J0pOykctbsI0xCWCJIAgAAAADgLGavL1SVx2taVuXxavb6QnsKAmxEkAQAAAAAqIepXD5Hy042ajkQygiSAAAAAAAmTOUyaxMX2ajlCC/hFroSJAEAAAAATJjKZTYutYOau81fn5u7nRqX2sGeghA0wjF0JUgCAAAAAJgwlcusf3IbTerXWc1cDknS5XGRmtSvs/ont7G5MtgtHENXt90FAAAAAACCS5u4SB05Q2gUzlO5+ie30dufHpHb7dSszOvtLgdBIhxDV85IAgAAAACYMJULsCYcr59FkAQAABAGwu1CoAAuDFO5AGvCMXRlahsAAECIa+hCoJL4UgigQUzlAs7t++Pos6u/UE2tocvjIjUutUNIH18JkgAAAELc2S4EGsoDXQAAAiHcQlemtgEAAIS4cLwQKAAA8I+AB0k7duzQfffdV2/52rVrlZmZqaysLL311luBLgsAACBkheOFQAEAgH8ENEh6+eWXNXnyZJ08af6/XzU1NZo+fbpeffVVvfbaa1q0aJGKiooCWRoAAEDICscLgQIAAP8IaJDUvn17/elPf6q3/MCBA2rfvr1atmypiIgI/eQnP9HHH38cyNIAAABCFndfAgAAF0tAL7Z911136csvv6y3vLy8XHFxcXW/x8TEqLy8/JzP53I5FB8ffVFrtIvL5QyZ93Kh6IUZ/TCjHz70wox+mNEPH3pxyohbrlH+Z/+fHA6HXv/FzXaXExTcbqccjtAZT14IemFGP3zohRn9MKMfPuHUi6C4a1tsbKwqKirqfq+oqDAFSw2prTVUWlrpz9ICJj4+OmTey4WiF2b0w4x++NALM/phRj986IWPx+OV2+2kH9+hHz70wox++NALM/phRj98Qq0XrVs3nMkExV3bOnXqpEOHDqm0tFTV1dX6+OOPdeONN9pdFgAAABDyVu05qp1fn9CWwhJlzC3Qqj1H7S4JABDEbD0jKS8vT5WVlcrKytLjjz+uBx98UIZhKDMzU23aMGcfAAAA8KdVe44qZ80+1dQakqQjZSeVs2afJHENLQDAGQU8SLryyiv11ltvSZIyMjLqlvfp00d9+vQJdDkAAABA2Jq9vlBVHq9pWZXHq9nrCwmSAABnFBRT2wAAAAAE3tGyk41aDgAAQRIAAAAQptrERTZqeTjgmlEAcHYESQAAAECYGpfaQc3d5q8Ezd1OjUvtYE9BNmvomlGESUB9hK7hiyAJAAAACFP9k9toUr/OauZySJIuj4vUpH6dw/b6SGe7ZhQAH0LX8GbrXdsAAAAA2Kt/chu9/ekRud1Ozcq83u5ybMU1owBruFB/eOOMJAAAAAAQ14wCrCJ0DW8ESQAAAAAgrhkFWEXoGt4IkgAAAABAXDMKsIrQNbxxjSQAAAAA+A7XjALO7ftw9dnVX6im1tDlcZEal9qB0DVMECQBAAAAAIBGIXQNX0xtAwAAAAAAgCUESQAAAAg7q/Yc1c6vT2hLYYky5hZo1Z6jdpcEAECTQJAEAACAsLJqz1HlrNmnmlpDknSk7KRy1uwjTAIAwAKCJAAAAISV2esLVeXxmpZVebyavb7QnoIAAGhCCJIAAAAQVo6WnWzUcgAA4EOQBAAAgLDSJi6yUcsBAIAPQRIAAADCyrjUDmruNg+Dm7udGpfawZ6CAABoQtx2FwAAAAAEUv/kNpKkZ1d/oZpaQ5fHRWpcaoe65QAAoGEESQAAAAg7/ZPb6O1Pj8jtdmpW5vV2lwMAQJNBkAQAAAAAgAVzsm5QfHy0Sksr7S4FsA3XSAIAAAAAAIAlBEkAAAAAAACwhKltAAAAAIAzYioXgB/ijCQAAAAAAABYwhlJAAAAAAAAFyCczt7jjCQAAAAAAABYQpAEAAAAAAAASwI2tc3r9erpp5/W559/roiICE2bNk1XX3113fr58+dryZIlatWqlSRp6tSp6tixY6DKAwAAAAAAwDkELEh67733VF1drUWLFumTTz7RjBkz9Je//KVu/e7du/X888+ra9eugSoJAAAAAAAAjRCwIGnbtm1KTU2VJHXr1k27du0yrd+9e7fmzp2roqIi3XHHHcrOzg5UaQAAAAAAALAgYEFSeXm5YmNj6353uVzyeDxyu0+VMGDAAI0cOVKxsbEaP368PvjgA/Xu3fusz+lyORQfH+3XugPF5XKGzHu5UPTCjH6Y0Q8femFGP8zohw+98HG7nXI4Qmf8dKHohw+9MKMfZnyOmtEPH/5WzMJl3whYkBQbG6uKioq6371eb12IZBiG7r//fsXFxUmS0tLS9Nlnn50zSKqtNULm1nrhcptAK+iFGf0wox8+9MKMfpjRDx964ePxeOV2O+nHd+iHD70wox9mfI6a0Q8f/lbMQmnfaN06rsF1AbtrW/fu3fXRRx9Jkj755BN16dKlbl15ebkGDhyoiooKGYahgoICrpUEAABwkc3JukFvPNjT7jIAAEATFrAzktLT07Vx40YNHz5chmEoJydHeXl5qqysVFZWliZOnKjRo0crIiJCt9xyi9LS0gJVGgAAAAAAACwIWJDkdDr1zDPPmJZ16tSp7udBgwZp0KBBgSoHAAAAAAAAjRSwqW0AAAAAAABo2giSAAAAAAAAYAlBEgAAAAAAACwJ2DWSAAAAAASnOVk3hNRtqwEA/sMZSQAAAAAAALCEIAkAAAAAAACWMLUNAAAAAE7DVD8AaBhBEgAAAAAAaDRC1/DE1DYAAAAAAABYQpAEAAAAAAAASwiSAAAAAAAAYAlBEgAAAAAAACwhSAIAAAAAAIAlBEkAAAAAAACwhCAJAAAAAAAAlhAkAQAAAAAAwBKCJAAAAAAAAFhCkAQAAAAAAABLCJIAAAAAAABgidvuAgAAAAA7zMm6QfHx0SotrbS7FAAAmgzOSAIAAAAAAIAlBEkAAAAAAACwhCAJAAAAAAAAlhAkAQAAAAAAwBKCJAAAAAAAAFhy1iDpX//6V6DqAAAAAAAAQJA7a5D0xBNPSJL++7//OyDFAAAAAAAAIHi5z7ayffv2uu2223T8+HH16tXLtG7Dhg2NeiGv16unn35an3/+uSIiIjRt2jRdffXVdevXrl2rWbNmye12KzMzU8OGDWvU8wMAAAAAAMC/zhok/e53v5MkTZ06VU899dQFvdB7772n6upqLVq0SJ988olmzJihv/zlL5KkmpoaTZ8+XUuWLFFUVJRGjBih3r17q3Xr1hf0mgAAAAAAALh4LF1s+ze/+Y1efPFFTZo0SWvWrNGhQ4ca/ULbtm1TamqqJKlbt27atWtX3boDBw6offv2atmypSIiIvSTn/xEH3/8caNfAwAAAAAAAP5z1jOSvjdp0iTdfvvt2rJlixISEvTkk0/q9ddfb9QLlZeXKzY2tu53l8slj8cjt9ut8vJyxcXF1a2LiYlReXn5OZ/T5XIoPj66UXUEK5fLGTLv5ULRCzP6YUY/fOiFGf0wox8+9MKMfpjRDx96YUY/fOiFGf0wox8+4dILS0FSaWmphgwZohUrVqh79+4yDKPRLxQbG6uKioq6371er9xu9xnXVVRUmIKlhtTWGiotrWx0LcEoPj46ZN7LhaIXZvTDjH740Asz+mFGP3zohRn9MKMfPvTCjH740Asz+mFGP3xCqRetWzecyVia2iadmn4mSUeOHJHTaflhdbp3766PPvpIkvTJJ5+oS5cudes6deqkQ4cOqbS0VNXV1fr444914403Nvo1AAAAAAAA4D+WzkiaPHmyJk2apAMHDuh//ud/zuvC2+np6dq4caOGDx8uwzCUk5OjvLw8VVZWKisrS48//rgefPBBGYahzMxMtWnTptGvAQAAAAAAAP+xFCR16dJFf/3rX/Wf//xHV155pVq1atXoF3I6nXrmmWdMyzp16lT3c58+fdSnT59GPy8AAAAAAAACw9IctXfeeUfDhw/XX//6V2VlZWn58uX+rgsAAAAAAABBxtIZSQsXLtSyZcvq7qZ2//3365577vF3bQAAAAAAAAgils5IcjgciomJkXTqDmuRkZF+LQoAAAAAAADBx9IZSe3bt9eMGTN00003adu2bWrfvr2/6wIAAAAAAECQsXRG0rBhw9SyZUv94x//0LJlyzRq1Ch/1wUAAAAAAIAgYylImjFjhtLT0zVlyhQtWbJEM2bM8HddAAAAAAAACDKWgiS3261rr71WknTVVVfJ6bT0MAAAAAAAAIQQS9dIateunWbOnKlu3brp008/1WWXXebvugAAAAAAABBkLJ1aNH36dLVq1Urr1q1Tq1atNH36dH/XBQAAAAAAgCBj6YykyMhIPfDAA34uBQAAAAAAAMGMix0BAAAAAADAEoIkAAAAAAAAWEKQBAAAAAAAAEsIkhBUshft0KhXCuwuAwAAAAAAnAFBEgAAAAAAACwhSAIAAAAAAIAlBEkAAAAAAACwhCAJAAAAAAAAlhAkAQAAAAAAwBKCJAAAAAAAAFhCkAQAaPKyF+3QqFcK7C4DAAAACHkESQAAAAAAALCEIAkAAAAAAACWECQBAAAAAADAEoIkAAAAAAAAWEKQBKDJ4ILKAAAAAGAvd6BeqKqqSr/97W9VXFysmJgYPf/882rVqpVpm2nTpmn79u2KiYmRJM2ePVtxcXGBKhEAAAAAAABnEbAg6c0331SXLl00YcIErVy5UrNnz9bkyZNN2+zevVvz5s2rFzABAAAAAADAfgGb2rZt2zalpqZKkm6//XZt2rTJtN7r9erQoUOaMmWKhg8friVLlgSqNAAAAAAAAFjglzOSFi9erIULF5qWXXrppXXT1GJiYlRWVmZaX1lZqXvvvVdjxoxRbW2tRo8era5duyopKckfJQIAAAAAAKCR/BIkDR06VEOHDjUtGz9+vCoqKiRJFRUVatGihWl9VFSURo8eraioKElSSkqK9u7de9YgyeVyKD4++iJXH3ijXimQw+HQ67+42e5SbOd2O+VwhMZ/14vF5XLSj++wf5ixb/iwb9TH/uFDL8zohxn98KEXZvTDh16Y0Q8z+uETLr0I2DWSunfvrnXr1unHP/6xPvroI/3kJz8xrS8sLNTEiROVm5srr9er7du3a/DgwWd9ztpaQ6Wllf4sOyA8Hq/cbmdIvJcLRS/qi4+Pph/fYf8wY9/wYd+oj/3Dh16Y0Q8z+uFDL8zohw+9MKMfZvTDJ5R60bp1wzc+C1iQNGLECD322GMaMWKEmjVrphdeeEGSNH/+fLVv31533nmnMjIyNGzYMDVr1kz33HOPOnfuHKjyAAAAAAAAcA4BC5KioqL00ksv1Vs+ZsyYup8feughPfTQQ4EqCQh62Yt2yO12albm9XaXAgAAAABA4O7aBgC4eLIX7dCoVwrsLgMAAABAmCFIAgAAAAAAgCUESQAAAAAAALCEIAkAAAAAAACWECQBAAAAAADAEoIkAAAAAAAAWEKQBAAAAAAAAEsIkgAAAAAAAGAJQRIAAAAAAAAsIUgCAAAAAACAJQRJAAAAAAAAsIQgCQCAEJO9aIdGvVJgdxkAAAAIQQRJAAAAAAAAsIQgCQAAAAAAAJYQJCForNpzVDu/PqEthSXKmFugVXuO2l0SAKCJY5ofAADAxUWQhKCwas9R5azZp5paQ5J0pOykctbsI0wCAAAAACCIECQhKMxeX6gqj9e0rMrj1ez1hfYUBAAAAAAA6iFIQlA4WnayUcsBAAAAAEDgESQhKLSJi2zUcgAAAAAAEHgESQgK41I7qLnbvDs2dzs1LrWDPQUBAAAAAIB63HYXAEhS/+Q2kqRnV3+hmlpDl8dFalxqh7rlAAAAAADAfgRJCBr9k9vo7U+PyO12albm9XaXA6CJWLXnqHZ+fUI1tYYy5hYQQgMAAAB+xNQ2AECTtWrPUeWs2aeaWkOSdKTspHLW7NOqPUdtrgwAAAAITQRJAIAma/b6QlV5vKZlVR6vZq8vtKcgAAAAIMQRJAFoEr6fvrSlsEQZcws44wSSpKNlJxu1HAAAAMCFIUgCEPSYvoSGtImLbNRyAAAAABeGIAlA0GP6EhoyLrWDmrvNh7LmbqfGpXawpyAAAAAgxAU8SHr33Xf1m9/85ozr3nrrLf385z/XsGHD9MEHHwS4MgDBiulLaEj/5Daa1K+zmrkckqTL4yI1qV9n7toGAAAA+Ik7kC82bdo0bdiwQcnJyfXWFRUV6bXXXtPSpUt18uRJjRw5UrfddpsiIiICWSKAINQmLlJHzhAaMX0J0qkw6e1Pj8jtdmpW5vV2lwMAAACEtICekdS9e3c9/fTTZ1z36aef6sYbb1RERITi4uLUvn177d27N5DlAQhSTF8CAAAAgODglzOSFi9erIULF5qW5eTk6O6771ZBQcEZH1NeXq64uLi632NiYlReXn7W13G5HIqPj77wgm3mdjvlcITGe7lQ9MKMfpwy4pZrFBMdqSdyd6m61qt2LZvrN+ld9LMb2tldmm3YN8zohxn98KEX9blcTvpxGvrhQy/M6IcPvTCjH2b0wydceuGXIGno0KEaOnRoox4TGxurioqKut8rKipMwdKZ1NYaKi2tPK8ag4nH45Xb7QyJ93Kh6IUZ/fC5/ep4dW0bZ5q+FM59Yd8wox9m9MOHXtQXHx9NP05DP3zohRn98KEXZvTDjH74hFIvWrduOI8Jmru2/fjHP9a2bdt08uRJlZWV6cCBA+rSpYvdZQEAAAAAAOA7Ab3Y9pnMnz9f7du315133qn77rtPI0eOlGEYmjhxoiIjuZAuwteqPUe18+sTqqk1lDG3QONSO3AnKgAAAACArQIeJPXs2VM9e/as+33MmDF1Pw8bNkzDhg0LdEm2IizAmazac1Q5a/apptaQJB0pO6mcNfskif0DfG4AAAAAsE3QTG0LRw2FBav2HLW5Mtht9vpCVXm8pmVVHq9mry+0pyAEDT43AAAAANiJIMlGhAVoyNGyk41ajvDB5wYAAAAAOxEk2YiwAA1pE3fm64M1tBzhg88NAAAAAHYiSLIRYQEaMi61g5q7zX+ezd1OjUvtYE9BCBp8bgAAAACwE0GSjQgL0JD+yW00qV9nNXM5JEmXx0VqUr/OXFAZfG4AAAAAsFXA79oGn+9DgWdXf6GaWkOXx0Vy9yXU6Z/cRm9/ekRut1OzMq+3uxwECT43AAAAANiJIMlmhAUAGovPDQAAAAB2YWobAAAAAAAALCFIAgAAAAAAgCUESQAAAAAAALCEIAkAgBCyas9R7fz6hLYUlihjboFW7Tlqd0kAAAAIIQRJAACEiFV7jipnzT7V1BqSpCNlJ5WzZh9hEgAAAC4agiQAAELE7PWFqvJ4TcuqPF7NXl9oT0EAAAAIOQRJAACEiKNlJxu1PNQxzQ8AAODiI0gCACBEtImLbNTyUMY0PwAAAP8gSAIAIESMS+2g5m7zob2526lxqR3sKchGTPMDAADwD7fdBQAAgIujf3IbSdKzq79QTa2hy+MiNS61Q93ycMI0PwAAAP8gSAIAIIT0T26jtz89IrfbqVmZ19tdjm3axEXqyBlCo3Cc5gcAAHAxMbUNAACEHKb5AQAA+AdnJCGozMm6QfHx0SotrbS7FABAE8Y0PwAAAP8gSAIAACGJaX4AAAAXH1PbAAAAAAAAYAlBEgAAAAAAACwhSAIAAAAAAIAlBEkAAAAAAACwhCAJAAAAAAAAlhAkAQAAAAAAwBJ3oF/w3Xff1d///ne98MIL9dZNmzZN27dvV0xMjCRp9uzZiouLC3SJAAAAAAAAOIOABknTpk3Thg0blJycfMb1u3fv1rx589SqVatAlgUAaOLmZN2g+PholZZW2l0KAAAAENICGiR1795dffv21aJFi+qt83q9OnTokKZMmaJjx45pyJAhGjJkSCDLAxDkCAsAAAAAwF5+CZIWL16shQsXmpbl5OTo7rvvVkFBwRkfU1lZqXvvvVdjxoxRbW2tRo8era5duyopKanB13G5HIqPj76otdvB7XbK4QiN93IxuFxOevEd9o362D9OYd+oj33Dh/3Dh17Ux9+KGf3woRdm9MOHXpjRDzP64RMuvfBLkDR06FANHTq0UY+JiorS6NGjFRUVJUlKSUnR3r17zxok1dYaIXFmgsfjldvtDIn3cjFwxokP+0Z97B+nsG/Ux77hw/7hQy/q42/FjH740Asz+uFDL8zohxn98AmlXrRu3fD1qoPmrm2FhYUaOXKkamtrVVNTo+3bt+u6666zuywAAAAAAAB8J+B3bfuh+fPnq3379rrzzjuVkZGhYcOGqVmzZrrnnnvUuXNnu8sDAAAAAADAdwIeJPXs2VM9e/as+33MmDF1Pz/00EN66KGHAl0SAAAAAAAALAiaqW0AAAAAAAAIbgRJAAAAAAAAsIQgCQAAAAAAAJbYfrFtAA2bk3VDSN1CEgAAAADQtBEkAUATRMgIAAAAwA5MbQMAAAAAAIAlBEkAAAAAAACwhKltQYApKgAAAAAAoCngjCQAAAAAAABYQpAEAAAAAAAASwiSAAAAAAAAYAlBEgAAAAAAACwhSAIAAAAAAIAlBEkAAAAAAACwxG13AQAA4OKak3WD4uOjVVpaaXcpAAAACDGckQQAAAAAAABLCJIAAAAAAABgCVPbAABAyGKaHwAAwMXFGUkAAAAAAACwhCAJAAAAAAAAlhAkAQAAAAAAwBKCJAAAAAAAAFhCkAQAAAAAAABLCJIAAAAAAABgCUESAAAAAAAALCFIAgAAAAAAgCUESQAAAAAAALCEIAkAAAAAAACWECQBAAAAAADAEoIkAAAAAAAAWOIwDMOwuwgAAAAAAAAEP85IAgAAAAAAgCUESQAAAAAAALCEIAkAAAAAAACWECQBAAAAAADAEoIkAAAAAAAAWEKQBAAAAAAAAEsIkgAAAMJMUVGR5s2bp4EDB9pdCgAAaGLcdhcA4OyKi4sVHx8vl8tldylA0PB4PDp+/LgcDodatGghtzs8D2fV1dWKiIiot/zgwYOKj49Xq1atbKjKXuwbDaupqdH777+v3Nxcbdy4UR6Ph2ML6jDeQEPKysrkcDgUGxtrdym24LhyCmOO+sJ53wifdwoEsddff12LFi1Sbm5uvQ+gnJwcbdq0SWPHjtUDDzxgT4EB9O2332rp0qVav3699u7dq9LSUjkcDrVq1UqJiYnq27evMjIyznggC0fhNLg7cuSIFi5cqPXr1+vAgQN1y10ulzp27Ki+fftq5MiRSkhIsLHKwKipqdELL7yg5cuX68MPP1RkZKRp/cyZM7Vu3TplZWXp0UcfVfPmzW2qNDDYN85u165dys3NVX5+vk6cOCHDMJSQkKDMzExlZWXZXZ5fcUwxY7xhxv5ximEY+uijj7R//35dddVV6tOnj9xutzZt2qRp06bp4MGDkqTk5GQ98sgj6tWrl80V+x/HFR/GHGbsG6c4DMMw7C4C4YmD96kD92OPPaYVK1aoZcuWWrx4sdq3b2/a5g9/+IOWLl2q4uJi9e/fXzNnzrSpWv/bunWrHn74YRUXFysiIkLt27dXixYt5PF4VFpaqv/85z8yDENt27bVCy+8oO7du9tdst8xuDtl5cqVevLJJ1VVVaV27dqpc+fOpn1j7969KikpUXR0tGbMmKF+/frZXbLfVFdXa+zYsdq8ebM6duyoefPmqV27dqZt3njjDS1evFh79+5Vjx49tGDBgpA9y4B948yKi4u1fPly5ebmav/+/TIMQw6HQ5I0fvx4ZWdnh/z/OeWY4sN4oz72j1NOnDihsWPHaseOHfr+a2HXrl01ZcoUjRo1SlFRUerZs6e8Xq82b96sqqoqzZ8/XzfffLPNlfsPxxUfxhxm7BunMQAbbNmyxbj11luNxMRE4/rrrzcGDBhgjBgxwhg6dKiRnp5uJCUlGYmJicYdd9xhbNu2ze5y/WbRokVGYmKiMXXqVKOqqqrB7aqqqozHHnvMSEpKMnJzcwNXYADt27fP+PGPf2zceuutxvLly42TJ0/W26asrMxYvHixkZqaatx4441GYWGhDZUGzvHjx42srKy6v4fExEQjMzPT2LFjh9G1a1ejR48exvjx441x48YZ3bt3N370ox8ZBQUFdpd90W3fvt1ITk427r77buPjjz9ucLt//OMfxs9+9jPjuuuuM3bv3h3ACgNr7ty5RmJiojFv3ryzbuf1eo0XX3zRSExMNBYsWBCg6gKLfcOspqbGWL16tZGdnW1cd911dcfY7OxsY8mSJcbOnTuNxMRE47333rO7VL/jmGLGeMOM/cPn2WefNW644Qbjb3/7m3HgwAFjw4YNRv/+/Y1u3boZAwcONEpKSuq2LSoqMnr37m1kZ2fbV7CfcVwxY8zhw75hRpCEgOPg7TNkyBDj3nvvtbRtbW2tMWjQICMrK8vPVdnjt7/9rdGzZ0/jyJEj59z26NGjRkpKijF58uQAVGYfBnenjB8/3ujdu7dRVlZ2zm3LysqM3r17G4888kgAKrNHRkaG8atf/cry9vfee68xePBgP1ZkH/YNs5SUFCMpKcm46aabjIcffthYuXKlUV5eXrf+yy+/DJsgiWOKGeMNM/YPn969exvTp083Ldu4caORmJhovPnmm/W2/8tf/mLceuutgSov4DiumDHm8GHfMOOubQi4uXPnKioqSsuWLdPPfvazM05di42N1ZAhQ7RkyRJFRkZq3rx5NlTqf/v379edd95paVun06m77rpLn3/+uZ+rsseWLVuUmZmpNm3anHPbyy67TIMGDdInn3zi/8JstHbtWg0fPlwjRoxQx44dddttt2ny5Mn69ttvNWrUKMXHx9dtm5CQoGHDhmnnzp32Fewn//znPzVo0CBL14GKjY1VRkaGPvvsswBUZo/CwsJGTWG844476qZAhhr2DbOSkhJFRUUpIyNDP/3pT5WSkqKYmBi7y7IFxxQzxhtm7B8+RUVF6tSpk2nZtddeK0n1pjBJUtu2bXX8+PGA1GYHjitmjDl82DfMCJIQcBy8fVwuV6OuAXXJJZfI6QzNP9vi4mJdffXVlrfv2LGjvv76az9WZD8Gd6eUlpaqbdu2lre/6qqrdOTIET9WZK/o6GjV1tZa3r558+Yhe6059g2zBQsW6O6771Z+fr4efvhh9erVSyNHjtSCBQv01Vdf2V1eQHFMMWO8Ycb+4VNTU1Pv4sjNmjUz/ft0DoejUcegpobjihljDh/2DbPQPUIgaHHw9rn66qu1a9cuy9vv3LnzjAFCKKipqVFUVJTl7SMjI1VRUeHHiuzH4O4Uj8fTqDuAREREqKqqyo8V2euaa67R9u3bLW+/bds2XXHFFX6syD7sG2YpKSmaNm2aNmzYoJdeekl9+/bV7t27NWPGDPXt21e//OUv5XA4VFlZaXepfscxxYzxhhn7BxrCccWMMYcP+4YZQRICjoO3z4ABA5SXl6d9+/adc9t9+/YpLy9Pt99+ewAqAxCsBg8erDVr1mjz5s3n3HbLli1as2aN7rrrrgBUhmARERGh9PR0vfTSS9q4caOee+459ezZU//+97/r7t41ZswYrVy5UtXV1XaXiwBgvIGzKS0t1eHDh+v++f4sim+++ca0/PDhwyopKbG5WgQSYw40JLTv+woEuaysLC1atEj33XefJk2apAEDBtS7XabX69U777yjGTNmKCYmRvfff79N1frf9wMZK8JlIPPDnnw/de37wd3pQrknBw8e1NatWy1te+DAAT9XY6/BgwdryZIl+tWvfqXs7GwNHTpUCQkJpm2OHTumpUuXas6cObriiis0cuRIm6r1P/aNs4uNjVVmZqYyMzNVVFSklStXKi8vT5s2bdLmzZvVokULFRQU2F2mX3BM8WG8UR/7h09OTo5ycnLqLX/00UdtqMZ+HFd8GHOYsW/4OAzDMOwuAuElKSlJTz75pOWLPr777ruaMWOG9uzZ4+fK7HHw4EGNGzdOhw4dUnR0tK677jq1bt1aXq9XxcXF2r17tyorK9W2bVvNmjVLycnJdpfsF0lJSXI4HI1+XKjuF1LDPTEM46y9CrWeNHbf+L4/odaH0x07dkwTJ07U1q1b5XA41K5dO9PnxuHDh2UYhrp166aZM2eG7BQV9o3zd+jQIa1YsUL5+flavXq13eVcdBxT6mO84cP+4fPEE0+c1+OmT59+kSsJDhxX6mPMcQr7hhlBEgKOg3d91dXVeuONN7Ry5Urt3btXHo9H0qnr4HTr1k39+vVTVlZWyF68TmIgcyb05JQ///nP5/W48ePHX+RKgs+aNWu0cuVKffbZZzp27JicTqcSEhLUvXt3paenq0+fPnaX6FfsG2gIn59nxnjjFPYPNITjSsMYc7BvnI4gCQHHwfvcvvnmG7lcLrVs2dLuUgAAQIhivAEAOB8ESQAAAAAAALCEu7YBAAAAAADAEoIkAAAAAMBZFRUVad68eRo4cKDdpQCwmdvuAgAAAAC7FBUVafny5Xr77beVn59vdzm2ox84XU1Njd5//33l5uZq48aN8ng8crlcdpcFwGYESQAAAAgrfDk2ox/4oV27dik3N1f5+fk6ceKEDMNQQkKCMjMzlZWVZXd5AGxGkASgySguLlZ8fDyDW9RTVlYmh8Oh2NhYu0sJCuHYj+rq6jPesvzgwYOKj49Xq1atbKgKwYYvx2b0o2HhOOYoLi7W8uXLlZubq/3798swDDkcDknShAkTlJ2dLbebr4/heIw9m3DsB2MOrpEEIMi8/vrrysjIkMfjqbcuJydHqampWrBgQeALg60Mw9C6dev0yiuvaM2aNXX7x6ZNmzRgwADdfPPN6tGjh37+859rw4YNNlfrf/TDp6amRjNmzFBaWppOnjxZb/3MmTOVlpamadOmqaqqyoYKYbfi4mK9+uqrysjI0NChQ/XGG2/oxIkTkk59Of7www81ceJEtWvXzuZKA4N++DDmkDwej9asWaNf/epXSktL0+9+9zsdOnRIaWlpeu6557R48WIZhqGkpKSwCZE4xprRDx/GHD7h8WkAIOgZhqHHHntMK1asUMuWLXX48GG1b9/etM2VV14pp9Op559/Xp9++qlmzpxpU7UIpBMnTmjs2LHasWOHDMOQJHXt2lVTpkzR2LFjFRUVpb59+8rr9Wrz5s3Kzs7W/PnzdfPNN9tcuX/QD5/q6mqNHTtWmzdvVseOHVVcXFzvy+8tt9yiL7/8Uq+//ro+//xzLViwIKzOMAhXHo9Ha9eu1bJly7RhwwZ5PB5FREQoLS1N6enpSkxM1JAhQ8LmyzH9MGPM4ZOamqrS0lLFxsYqPT1d6enpSktLU0xMjCTpq6++srnCwOIYa0Y/fBhz/IABAEFg0aJFRmJiojF16lSjqqqqwe2qqqqMxx57zEhKSjJyc3MDVyBs8+yzzxo33HCD8be//c04cOCAsWHDBqN///5Gt27djIEDBxolJSV12xYVFRm9e/c2srOz7SvYz+iHz9y5c43ExERj3rx5Z93O6/UaL774opGYmGgsWLAgQNXBTikpKUZSUpJx0003GQ8//LCxcuVKo7y8vG79l19+aSQmJhrvvfeejVUGDv0wY8zhk5iYaNx4443G1KlTjb///e9GcXGxaX247RscY83ohw9jDjOmtgEICosXL1aPHj00ZcoURUZGNrhdZGSkcnJylJSUpP/7v/8LYIWwy9q1azV8+HCNGDFCHTt21G233abJkyfr22+/1ahRoxQfH1+3bUJCgoYNG6adO3faV7Cf0Q+fvLw89e7dWw8++OBZt3M4HPr1r3+tHj16aPny5QGqDnYqKSlRVFSUMjIy9NOf/lQpKSl1Z1iEI/phxpjDZ8GCBbr77ruVn5+vhx9+WL169dLIkSO1YMGCsDsbSeIY+0P0w4cxhxlBEoCgsH//ft15552WtnU6nbrrrrv0+eef+7kqBIOioiJ16tTJtOzaa6+VpDNew6Nt27Y6fvx4QGqzA/3wKSwsVK9evSxvf8cdd+jgwYN+rAjBgi/HZvTDjDGHT0pKiqZNm6YNGzbopZdeUt++fbV7927NmDFDffv21S9/+Us5HA5VVlbaXWpAcIw1ox8+jDnMQn8SNIAmweVynfHuBw255JJL5HSShYeDmpoaNW/e3LSsWbNmpn+fzuFwqLa2NiC12YF++ERHRzfqvTVv3rxRnzNoulJSUpSSkqIpU6Zo3bp1ysvL07p167R9+3Y9//zz6tChQ1h9OaYfZow56ouIiKi7RlJ5eblWr16tvLw8bd26te6aUsuWLdOQIUOUnp4esp+lHGPN6IcPYw6z0P5EBNBkXH311dq1a5fl7Xfu3BkWd5QB0LBrrrlG27dvt7z9tm3bdMUVV/ixIgSb778cv/TSS9q4caOee+459ezZU//+97/rvhyPGTNGK1euVHV1td3l+h39OIUxx9nFxsYqMzNTCxYs0IcffqjHH39cycnJ2rRpkx599FGlpqbaXSIQcIw5zDgjCUBQGDBggP7whz9ozJgx6ty581m33bdvn/Ly8nTvvfcGqDrYrbS0VIcPH677/fvTpr/55hvTcunUtUBCHf04ZfDgwXr66ae1efNmpaSknHXbLVu2aM2aNRo/fnyAqkOw+f7LcWZmpoqKirRy5Url5eVp06ZN2rx5s1q0aKGCggK7ywyYcO4HYw7rWrdurQceeEAPPPCADh06pBUrVig/P9/usvyKY6wZ/TiFMYeZwzC+u48fANiooqJCP//5z3X8+HFNmjRJAwYMqHe7TK/Xq3feeUczZsyQ1+vV22+/rcsuu8ymihEoSUlJcjgc9ZYbhnHG5d/bs2ePP8uyDf3wqamp0ahRo/TFF18oOztbQ4cOVUJCgmmbY8eOaenSpZozZ45at26txYsXq0WLFjZVjGB0+pfj1atX212O7cKhH4w50BCOsWb0w4cxhxlBEoCgcfDgQY0bN06HDh1SdHS0rrvuOrVu3Vper1fFxcXavXu3Kisr1bZtW82aNUvJycl2l4wAeOKJJ87rcdOnT7/IlQQH+mF27NgxTZw4UVu3bpXD4VC7du1MnxuHDx+WYRjq1q2bZs6cGVbTUwA0jDEHzoRjrBn9MGPM4UOQBCCoVFdX64033tDKlSu1d+9eeTweSacu6NetWzf169dPWVlZIX3xOgCNt2bNGq1cuVKfffaZjh07JqfTqYSEBHXv3l3p6enq06eP3SUCCDKMOQCcD8YcBEkAgtw333wjl8ulli1b2l0KAAAIYYw5AMAagiQAAAAAAABY4rS7AAAAAAAAADQNBEkAAAAAADRCUVGR5s2bp4EDB9pdSlCgH+HFbXcBAAAAABCMioqKtHz5cr399tvKz8+3uxzYrKamRu+//75yc3O1ceNGeTweuVwuu8uyDf0IXwRJAAAAAPAdvhzjh3bt2qXc3Fzl5+frxIkTMgxDCQkJyszMVFZWlt3lBRz9AEESAAAIWWVlZXI4HIqNjbW7FABBji/HOF1xcbGWL1+u3Nxc7d+/X4ZhyOFwSJImTJig7Oxsud3h83WafpxbOI05wvu/NAAAaNIMw9BHH32k/fv366qrrlKfPn3kdru1adMmTZs2TQcPHpQkJScn65FHHlGvXr1srhhAMOHLMU7n8Xi0du1aLVu2TBs2bJDH41FERITS0tKUnp6uxMREDRkyRElJSWGxX9APM8YcPqH/XxsAAISkEydOaOzYsdqxY4cMw5Akde3aVVOmTNHYsWMVFRWlvn37yuv1avPmzcrOztb8+fN1880321w5ADvx5RgNSU1NVWlpqWJjY5Wenq709HSlpaUpJiZGkvTVV1/ZXGFg0Q8fxhxmfDICAIAm6aWXXtLevXs1ZcoU9ezZU19//bWee+453X///erQoYNee+01xcfHS5KOHTumYcOG6dVXXw3ZQR0Aa/hyjIaUlJQoOjpaGRkZ6tmzp3r06FG3X4Qj+uHDmMOMIAkAADRJa9eu1fDhwzVixAhJUseOHTV58mT94he/0KhRo+oGdJKUkJCgYcOG6bXXXrOpWgDBgi/HaMiCBQuUn5+v/Px8vfnmm3I4HOrWrZv69eun9PR0u8sLOPrhw5jDjCAJAAA0SUVFRerUqZNp2bXXXitJateuXb3t27Ztq+PHjwekNgDBiy/HaEhKSopSUlI0ZcoUrVu3Tnl5eVq3bp22b9+u559/Xh06dJDD4VBlZaXdpQYE/fBhzGFGkAQAAJqkmpoaNW/e3LSsWbNmpn+fzuFwqLa2NiC1AQhefDnGuURERNRNeywvL9fq1auVl5enrVu3yjAMPfbYY1q2bJmGDBmi9PR0RURE2F2yX9EPxhw/RJAEAAAAIOzw5RhWxMbGKjMzU5mZmSoqKtLKlSuVl5enTZs2afPmzWrRooUKCgrsLjNg6AckgiQAANCElZaW6vDhw3W/f38a+TfffGNaLp26LgoAnAlfjmFF69at9cADD+iBBx7QoUOHtGLFCuXn59tdlm3CrR+MOXwcxvf3rgMAAGhCkpKS5HA46i03DOOMy7+3Z88ef5YFIISc/uV49erVdpcDwCaMOcw4IwkAADRJgwcPtrsEACHu6quv1oQJEzRhwgS7SwFgI8YcZpyRBAAAAAAAAEucdhcAAAAAAACApoEgCQAAAAAAAJYQJAEAAAAAAMASgiQAAAAAAICLoKioSPPmzdPAgQPtLsVvuGsbAAAAAADAeaqpqdH777+v3Nxcbdy4UR6PRy6Xy+6y/IYgCQAAAAAAoJF27dql3Nxc5efn68SJEzIMQwkJCcrMzFRWVpbd5fkNQRIAAAAAAIAFxcXFWr58uXJzc7V//34ZhiGHwyFJmjBhgrKzs+V2h3bUEtrvDgAAAAAA4AJ4PB6tXbtWy5Yt04YNG+TxeBQREaG0tDSlp6crMTFRQ4YMUVJSUsiHSBJBEgAAAAAAQINSU1NVWlqq2NhYpaenKz09XWlpaYqJiZEkffXVVzZXGFgESQAAAAAAAA0oKSlRdHS0MjIy1LNnT/Xo0aMuRApHBEkAAAAAAAANWLBggfLz85Wfn68333xTDodD3bp1U79+/ZSenm53eQHnMAzDsLsIAAAAAACAYFZdXa1169YpLy9P69at08mTJ+VwONShQwcVFhbqd7/7nTIyMuwu0+8IkgAAAAAAABqhvLxcq1evVl5enrZu3ara2lo5nU717NlTQ4YMUXp6uiIiIuwu0y8IkgAAAAAAAM5TUVGRVq5cqby8PO3evVsOh0MtWrRQQUGB3aX5BUESAAAAAADARXDo0CGtWLFC+fn5Wr16td3l+AVBEgAAAAAAACxx2l0AAAAAAAAAmgaCJAAAAAAAAFhCkAQAAAAAAABLCJIAAAAAAABgCUESAAAAAAAALCFIAgAAAAAAgCX/P7OH/0CTBsJLAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 1440x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import itertools\n",
+    "# Getting the confidence intervals of the CATE at different X vector values\n",
+    "feat_names = np.array(['A', 'B', 'C', 'D'])\n",
+    "lst = list(itertools.product([0, 1], repeat=4))\n",
+    "point = []\n",
+    "lower = []\n",
+    "upper = []\n",
+    "fnames = []\n",
+    "for x in lst:\n",
+    "    x_test = np.array([x])\n",
+    "    fnames.append(\" \".join(np.array(feat_names)[x_test.flatten()>0]))\n",
+    "    point.append(est.effect(x_test)[0])\n",
+    "    lb, ub = est.effect_interval(x_test, alpha=.05)\n",
+    "    lower.append(lb[0])\n",
+    "    upper.append(ub[0])\n",
+    "\n",
+    "fnames = np.array(fnames)\n",
+    "point = np.array(point)\n",
+    "lower = np.array(lower)\n",
+    "upper = np.array(upper)\n",
+    "yerr = np.zeros((2, point.shape[0]))\n",
+    "yerr[0, :] = point - lower\n",
+    "yerr[1, :] = upper - point\n",
+    "\n",
+    "with sns.axes_style('darkgrid'):\n",
+    "    fig, ax = plt.subplots(1,1, figsize=(20, 5)) \n",
+    "    x = np.arange(len(point))\n",
+    "    stat_sig = (lower>0) | (upper<0)\n",
+    "    plt.errorbar(x[stat_sig], point[stat_sig], yerr[:, stat_sig], fmt='o', label='stat_sig')\n",
+    "    plt.errorbar(x[~stat_sig], point[~stat_sig], yerr[:, ~stat_sig], fmt='o', color='red', label='insig')\n",
+    "    ax.set_xticks(x)\n",
+    "    ax.set_xticklabels(fnames, rotation='vertical', fontsize=18)\n",
+    "    ax.set_ylabel('coef')\n",
+    "    plt.legend()\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### CATE(x) inference"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>point_estimate</th>\n",
+       "      <th>stderr</th>\n",
+       "      <th>zstat</th>\n",
+       "      <th>pvalue</th>\n",
+       "      <th>ci_lower</th>\n",
+       "      <th>ci_upper</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1.198</td>\n",
+       "      <td>0.274</td>\n",
+       "      <td>4.370</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>0.747</td>\n",
+       "      <td>1.648</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>-1.087</td>\n",
+       "      <td>0.271</td>\n",
+       "      <td>-4.009</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>-1.533</td>\n",
+       "      <td>-0.641</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>1.129</td>\n",
+       "      <td>0.280</td>\n",
+       "      <td>4.033</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>0.669</td>\n",
+       "      <td>1.590</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>-1.087</td>\n",
+       "      <td>0.271</td>\n",
+       "      <td>-4.009</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>-1.533</td>\n",
+       "      <td>-0.641</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>-1.095</td>\n",
+       "      <td>0.269</td>\n",
+       "      <td>-4.065</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>-1.537</td>\n",
+       "      <td>-0.652</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>0.725</td>\n",
+       "      <td>0.291</td>\n",
+       "      <td>2.491</td>\n",
+       "      <td>0.013</td>\n",
+       "      <td>0.246</td>\n",
+       "      <td>1.204</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>0.882</td>\n",
+       "      <td>0.272</td>\n",
+       "      <td>3.239</td>\n",
+       "      <td>0.001</td>\n",
+       "      <td>0.434</td>\n",
+       "      <td>1.330</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>-0.803</td>\n",
+       "      <td>0.273</td>\n",
+       "      <td>-2.941</td>\n",
+       "      <td>0.003</td>\n",
+       "      <td>-1.251</td>\n",
+       "      <td>-0.354</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>0.882</td>\n",
+       "      <td>0.272</td>\n",
+       "      <td>3.239</td>\n",
+       "      <td>0.001</td>\n",
+       "      <td>0.434</td>\n",
+       "      <td>1.330</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>0.725</td>\n",
+       "      <td>0.291</td>\n",
+       "      <td>2.491</td>\n",
+       "      <td>0.013</td>\n",
+       "      <td>0.246</td>\n",
+       "      <td>1.204</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   point_estimate  stderr  zstat  pvalue  ci_lower  ci_upper\n",
+       "0           1.198   0.274  4.370   0.000     0.747     1.648\n",
+       "1          -1.087   0.271 -4.009   0.000    -1.533    -0.641\n",
+       "2           1.129   0.280  4.033   0.000     0.669     1.590\n",
+       "3          -1.087   0.271 -4.009   0.000    -1.533    -0.641\n",
+       "4          -1.095   0.269 -4.065   0.000    -1.537    -0.652\n",
+       "5           0.725   0.291  2.491   0.013     0.246     1.204\n",
+       "6           0.882   0.272  3.239   0.001     0.434     1.330\n",
+       "7          -0.803   0.273 -2.941   0.003    -1.251    -0.354\n",
+       "8           0.882   0.272  3.239   0.001     0.434     1.330\n",
+       "9           0.725   0.291  2.491   0.013     0.246     1.204"
+      ]
+     },
+     "execution_count": 19,
+     "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": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<table class=\"simpletable\">\n",
+       "<caption>Uncertainty of Mean Point Estimate</caption>\n",
+       "<tr>\n",
+       "  <th>mean_point</th> <th>stderr_mean</th> <th>zstat</th> <th>pvalue</th> <th>ci_mean_lower</th> <th>ci_mean_upper</th>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "     <td>0.147</td>      <td>0.277</td>    <td>0.531</td>  <td>0.595</td>    <td>-0.308</td>         <td>0.602</td>    \n",
+       "</tr>\n",
+       "</table>\n",
+       "<table class=\"simpletable\">\n",
+       "<caption>Distribution of Point Estimate</caption>\n",
+       "<tr>\n",
+       "  <th>std_point</th> <th>pct_point_lower</th> <th>pct_point_upper</th>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "    <td>0.965</td>       <td>-1.091</td>           <td>1.167</td>     \n",
+       "</tr>\n",
+       "</table>\n",
+       "<table class=\"simpletable\">\n",
+       "<caption>Total Variance of Point Estimate</caption>\n",
+       "<tr>\n",
+       "  <th>stderr_point</th> <th>ci_point_lower</th> <th>ci_point_upper</th>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "      <td>1.004</td>        <td>-1.359</td>          <td>1.388</td>    \n",
+       "</tr>\n",
+       "</table><br/><br/>Note: The stderr_mean is a conservative upper bound."
+      ],
+      "text/plain": [
+       "<econml.inference.PopulationSummaryResults at 0x2e3a0351eb8>"
+      ]
+     },
+     "execution_count": 20,
+     "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": {},
+   "source": [
+    "# Non-Linear Models with Forest CATEs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<econml.drlearner.ForestDRLearner at 0x2e3a0353400>"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from econml.drlearner import ForestDRLearner\n",
+    "from sklearn.ensemble import GradientBoostingRegressor\n",
+    "\n",
+    "est = ForestDRLearner(model_regression=GradientBoostingRegressor(),\n",
+    "                      model_propensity=DummyClassifier(strategy='prior'),\n",
+    "                      cv=5,\n",
+    "                      n_estimators=1000,\n",
+    "                      min_samples_leaf=10,\n",
+    "                      verbose=0, min_weight_fraction_leaf=.01)\n",
+    "est.fit(y, T, X=X[:, :4])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.97459949, 0.00870163, 0.00810112, 0.00859776])"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "est.feature_importances_(T=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 576x223.2 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import shap\n",
+    "import pandas as pd\n",
+    "# explain the model's predictions using SHAP values\n",
+    "shap_values = est.shap_values(X[:100, :4], feature_names=['A', 'B', 'C', 'D'], background_samples=100)\n",
+    "shap.summary_plot(shap_values['Y0']['T0'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### CATE(x) intervals"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import itertools\n",
+    "# Getting the confidence intervals of the CATE at different X vector values\n",
+    "feat_names = np.array(['A', 'B', 'C', 'D'])\n",
+    "lst = list(itertools.product([0, 1], repeat=4))\n",
+    "point = []\n",
+    "lower = []\n",
+    "upper = []\n",
+    "fnames = []\n",
+    "for x in lst:\n",
+    "    x_test = np.array([x])\n",
+    "    fnames.append(\" \".join(np.array(feat_names)[x_test.flatten()>0]))\n",
+    "    point.append(est.effect(x_test)[0])\n",
+    "    lb, ub = est.effect_interval(x_test, alpha=.05)\n",
+    "    lower.append(lb[0])\n",
+    "    upper.append(ub[0])\n",
+    "\n",
+    "fnames = np.array(fnames)\n",
+    "point = np.array(point)\n",
+    "lower = np.array(lower)\n",
+    "upper = np.array(upper)\n",
+    "yerr = np.zeros((2, point.shape[0]))\n",
+    "yerr[0, :] = point - lower\n",
+    "yerr[1, :] = upper - point\n",
+    "\n",
+    "with sns.axes_style('darkgrid'):\n",
+    "    fig, ax = plt.subplots(1,1, figsize=(20, 5)) \n",
+    "    x = np.arange(len(point))\n",
+    "    stat_sig = (lower>0) | (upper<0)\n",
+    "    plt.errorbar(x[stat_sig], point[stat_sig], yerr[:, stat_sig], fmt='o', label='stat_sig')\n",
+    "    plt.errorbar(x[~stat_sig], point[~stat_sig], yerr[:, ~stat_sig], fmt='o', color='red', label='insig')\n",
+    "    ax.set_xticks(x)\n",
+    "    ax.set_xticklabels(fnames, rotation='vertical', fontsize=18)\n",
+    "    ax.set_ylabel('coef')\n",
+    "    plt.legend()\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### CATE(x) inference"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>point_estimate</th>\n",
+       "      <th>stderr</th>\n",
+       "      <th>zstat</th>\n",
+       "      <th>pvalue</th>\n",
+       "      <th>ci_lower</th>\n",
+       "      <th>ci_upper</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1.160</td>\n",
+       "      <td>0.336</td>\n",
+       "      <td>3.452</td>\n",
+       "      <td>0.001</td>\n",
+       "      <td>0.607</td>\n",
+       "      <td>1.713</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>-1.112</td>\n",
+       "      <td>0.198</td>\n",
+       "      <td>-5.610</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>-1.438</td>\n",
+       "      <td>-0.786</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>1.387</td>\n",
+       "      <td>0.282</td>\n",
+       "      <td>4.913</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>0.923</td>\n",
+       "      <td>1.851</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>-1.112</td>\n",
+       "      <td>0.198</td>\n",
+       "      <td>-5.610</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>-1.438</td>\n",
+       "      <td>-0.786</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>-1.173</td>\n",
+       "      <td>0.187</td>\n",
+       "      <td>-6.257</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>-1.481</td>\n",
+       "      <td>-0.865</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>1.132</td>\n",
+       "      <td>0.339</td>\n",
+       "      <td>3.342</td>\n",
+       "      <td>0.001</td>\n",
+       "      <td>0.575</td>\n",
+       "      <td>1.689</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>0.938</td>\n",
+       "      <td>0.320</td>\n",
+       "      <td>2.933</td>\n",
+       "      <td>0.003</td>\n",
+       "      <td>0.412</td>\n",
+       "      <td>1.464</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>-0.890</td>\n",
+       "      <td>0.219</td>\n",
+       "      <td>-4.071</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>-1.250</td>\n",
+       "      <td>-0.531</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>0.938</td>\n",
+       "      <td>0.320</td>\n",
+       "      <td>2.933</td>\n",
+       "      <td>0.003</td>\n",
+       "      <td>0.412</td>\n",
+       "      <td>1.464</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>1.132</td>\n",
+       "      <td>0.339</td>\n",
+       "      <td>3.342</td>\n",
+       "      <td>0.001</td>\n",
+       "      <td>0.575</td>\n",
+       "      <td>1.689</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   point_estimate  stderr  zstat  pvalue  ci_lower  ci_upper\n",
+       "0           1.160   0.336  3.452   0.001     0.607     1.713\n",
+       "1          -1.112   0.198 -5.610   0.000    -1.438    -0.786\n",
+       "2           1.387   0.282  4.913   0.000     0.923     1.851\n",
+       "3          -1.112   0.198 -5.610   0.000    -1.438    -0.786\n",
+       "4          -1.173   0.187 -6.257   0.000    -1.481    -0.865\n",
+       "5           1.132   0.339  3.342   0.001     0.575     1.689\n",
+       "6           0.938   0.320  2.933   0.003     0.412     1.464\n",
+       "7          -0.890   0.219 -4.071   0.000    -1.250    -0.531\n",
+       "8           0.938   0.320  2.933   0.003     0.412     1.464\n",
+       "9           1.132   0.339  3.342   0.001     0.575     1.689"
+      ]
+     },
+     "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": [
+       "<table class=\"simpletable\">\n",
+       "<caption>Uncertainty of Mean Point Estimate</caption>\n",
+       "<tr>\n",
+       "  <th>mean_point</th> <th>stderr_mean</th> <th>zstat</th> <th>pvalue</th> <th>ci_mean_lower</th> <th>ci_mean_upper</th>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "     <td>0.24</td>       <td>0.281</td>    <td>0.855</td>  <td>0.393</td>    <td>-0.222</td>         <td>0.702</td>    \n",
+       "</tr>\n",
+       "</table>\n",
+       "<table class=\"simpletable\">\n",
+       "<caption>Distribution of Point Estimate</caption>\n",
+       "<tr>\n",
+       "  <th>std_point</th> <th>pct_point_lower</th> <th>pct_point_upper</th>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "    <td>1.08</td>        <td>-1.145</td>           <td>1.285</td>     \n",
+       "</tr>\n",
+       "</table>\n",
+       "<table class=\"simpletable\">\n",
+       "<caption>Total Variance of Point Estimate</caption>\n",
+       "<tr>\n",
+       "  <th>stderr_point</th> <th>ci_point_lower</th> <th>ci_point_upper</th>\n",
+       "</tr>\n",
+       "<tr>\n",
+       "      <td>1.116</td>        <td>-1.326</td>          <td>1.607</td>    \n",
+       "</tr>\n",
+       "</table><br/><br/>Note: The stderr_mean is a conservative upper bound."
+      ],
+      "text/plain": [
+       "<econml.inference.PopulationSummaryResults at 0x2e39ec78d30>"
+      ]
+     },
+     "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": {},
+   "source": [
+    "# Tree Interpretation of the CATE Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from econml.cate_interpreter import SingleTreeCateInterpreter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<econml.cate_interpreter.SingleTreeCateInterpreter at 0x2e3a24956a0>"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "intrp = SingleTreeCateInterpreter(include_model_uncertainty=True, max_depth=2, min_samples_leaf=10)\n",
+    "# We interpret the CATE models behavior on the distribution of heterogeneity features\n",
+    "intrp.interpret(est, X[:, :4])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# exporting to a dot file\n",
+    "intrp.export_graphviz(out_file='cate_tree.dot', feature_names=['A', 'B', 'C', 'D'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# or we can directly render. Requires the graphviz python library\n",
+    "intrp.render(out_file='dr_cate_tree', format='pdf', view=True, feature_names=['A', 'B', 'C', 'D'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Matplotlib is currently using agg, which is a non-GUI backend, so cannot show the figure.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1800x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# or we can also plot inline with matplotlib. a bit uglier\n",
+    "plt.figure(figsize=(25, 5))\n",
+    "intrp.plot(feature_names=['A', 'B', 'C', 'D'], fontsize=12)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Tree Based Treatment Policy Based on CATE Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from econml.cate_interpreter import SingleTreePolicyInterpreter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<econml.cate_interpreter.SingleTreePolicyInterpreter at 0x2e3a2929358>"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "intrp = SingleTreePolicyInterpreter(risk_level=0.05, max_depth=2, min_samples_leaf=1, min_impurity_decrease=.001)\n",
+    "# We find a tree based treatment policy based on the CATE model\n",
+    "# sample_treatment_costs is the cost of treatment. Policy will treat if effect is above this cost.\n",
+    "# It can also be an array that has a different cost for each sample. In case treating different segments\n",
+    "# has different cost.\n",
+    "intrp.interpret(est, X[:, :4],\n",
+    "                sample_treatment_costs=0.2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# exporting to a dot file\n",
+    "intrp.export_graphviz(out_file='cate_tree.dot', feature_names=['A', 'B', 'C', 'D'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "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": [
+    "# or we can directly render. Requires the graphviz python library\n",
+    "intrp.render(out_file='dr_policy_tree', format='pdf', view=True, feature_names=['A', 'B', 'C', 'D'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Matplotlib is currently using agg, which is a non-GUI backend, so cannot show the figure.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1800x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# or we can also plot inline with matplotlib. a bit uglier\n",
+    "plt.figure(figsize=(25, 5))\n",
+    "intrp.plot(feature_names=['A', 'B', 'C', 'D'], fontsize=12)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# SHAP Interpretability with Final Tree CATE Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<econml.drlearner.DRLearner at 0x2e3a29294a8>"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# We need to use a scikit-learn final model\n",
+    "from econml.drlearner import DRLearner\n",
+    "from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor, GradientBoostingClassifier\n",
+    "\n",
+    "# One can replace model_y and model_t with any scikit-learn regressor and classifier correspondingly\n",
+    "# as long as it accepts the sample_weight keyword argument at fit time.\n",
+    "est = DRLearner(model_regression=GradientBoostingRegressor(max_depth=3, n_estimators=100, min_samples_leaf=30),\n",
+    "                model_propensity=GradientBoostingClassifier(max_depth=3, n_estimators=100, min_samples_leaf=30),\n",
+    "                model_final=RandomForestRegressor(max_depth=3, n_estimators=100, min_samples_leaf=30))\n",
+    "est.fit(y, T, X=X[:, :4], W=X[:, 4:])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import shap\n",
+    "import pandas as pd\n",
+    "# explain the model's predictions using SHAP values\n",
+    "shap_values = est.shap_values(X[:, :4], feature_names=['A', 'B', 'C', 'D'], background_samples=100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Matplotlib is currently using agg, which is a non-GUI backend, so cannot show the figure.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x216 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# visualize the first prediction's explanation (use matplotlib=True to avoid Javascript)\n",
+    "shap.force_plot(shap_values[\"Y0\"][\"T0\"][0], matplotlib=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Matplotlib is currently using agg, which is a non-GUI backend, so cannot show the figure.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdsAAADcCAYAAAA4CAs4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAn5UlEQVR4nO3deZwcVbn/8c8zM4EQAiEsMWwhhB1BEY7IooAiCGiuBOQiiIAIgrIoXhR+iogBRIULiKyyLwICItwgiywGBQUpwCBg2AMECGHLSraZeX5/VA3pmame6Zrpmq7u+b5fr3pNVXX16VM13fXUWaqOuTsiIiKSn6ZaZ0BERKTRKdiKiIjkTMFWREQkZwq2IiIiOVOwFRERyZmCrYiISM4UbEVEpO6Y2TQz26zLusjMdjKziWa2bwVpnGxmZ+aXy6VaBuJDREREBoq7n1TrPHSlkq2IiDQUM7vSzI5K5keY2R/MbKqZ3WdmV3cpza5pZnckr//JzIblkad6KdnqMVcyKEyaNAmA8ePH1zgnIj2yfFLdK/1c77eU+7ybzWxhyfKGKducBLzv7hub2crAY8AfSl4PwCeB2cDdwNeASzLmvFf1EmxFRKThZY7hX3H3pz58t1mUss1ngaMB3P09M7u1y+t3u/us5P2PAOtlzUQlVI0sIiIFYWWmfifaU+1oacm4jZwKoQq2IiJSEE1lpn75C3AQgJmNBL7c3wT7QsFWREQa2URglJk9DVwLPETcPjug1GYrIiIFUXn5z93HpqwLyezkktXzgf3cfaGZrQg8CFyVbH9yl/d3Wq4mBVsRESmIXDo5jwTuNLNmYChwnbvfm8cH9UTBVkRECqL6LZvuPhPYquoJZ6RgKyIiBZHP7btFoGArIiKF4GWCbSOEYAVbEREpiEYIq+kUbEVEpBC8TJttI4RgBVsRESmIRgir6RRsRUSkEMqVbBuBgq2IiBRCIw/vpmArIiKFoJKtiIhI7tRmKyIikiuVbEVERHJW7qEWjaBxLyP6yD1uom93Z/7iRm6uFxEpFsdSp0agkm1iSZsz+sI23lvYef0GI+C5w3SYRKSg5i2Az/8UHnkBmgyuPBq+vlOtc9VHjRFY06hkm9jp990DLcDzs+GXD7cOfIZERCox8utxoAVodzjw3Nrmpx+cptSpETTGXlTBI2+Uf+28JwYuHyIimbS2d1/30usDn48qUDXyIJDydf3QAhVsRaSetNVnf5NGCaxpBmXJ9pE32lj9/FaazmzlI+e3MmdhW49PLhnSPGBZExGpzD3/gk2OTn/N22HOB+D1FXQbuRp50JVsZy1oY5vrln4BZy6Akef1/IUcsUzeuRIRyeCBp2DXieVf3+R7navrXr0Y1l4t71z1m0q2DeSY+7sH1p6qkAHmLcknLyIifTL+9J5f73pSG/ft3LJSTWqzbSBPv539PW1t1c+HiEifzVuQbfu0TlSF1BiBNc2gK9n25Ss3TNXIIlIkfW2KbW2DR5+HD1LucyyAdppSp0bQ0CXbcHUrj82M5w/9KFyye0ufSqmL1BtZROrda2/DmMOXLl/ybTh0l9rlJ5VKtnVn0ZKlgRbg0qfjv31pfx29fHXyJCJSM+sc3nn5sAtrk48etGOpUyPIFGxDCCeGEDyEcGBeGaqWK59MXz96WPa0Vli2f3kREamqvsSfurgLyMpM9a/iYBtCaAK+CbwHHN7L5jW3aHH6+oV9aLR9/r3+5UVEpKoaI/5008httln24gvAWsCBwHYhhM3yyVK+lvSlzVa9kUWkSJobIwANJln+Y4cDd0ZR9CdgCvCtfLLU3dy5czPPt6eUYOfOnUtz6hVhz/Urbd63PGhe85rXfC7zS/p/K0/pWS9rHvLSyCVb8woe5xVCWAN4BdgniqJbQwjHAD8D1oiiKOMNX32SubXh7L+38v2/d0nkuBY2v6yVp97PltZay8Nr327ojttSEJMmTQJg/PjxNc6JFFrTXtVpg/Vb+vrOXCqyZ9pJqXs1yifWfcV5pZcMHW21tyfL1wLLAfvmkalqWL7cvbF9uCBcqGpkESmSuujslN2g7o2cdIw6FFgJmB5CmAE8AzQzgFXJWX3jE+n/oL50kNI4BCJS9+ogZjXy4xorKdnuRtwxajtgi5Lpi8C2IYTNc8pbvwxpbuYzayxd/u4W8d++tHRUoXlERKS23rys8/LvvlubfPRgsI/6czhwaxRFj3VZPyOE8I/k9aOqnrMq+Ov+3XdvmT40vY4eXoXMiIjU0kdGQtvN8PJbMGY1GFK8figNWjsOVBBsoyj6cg+vbVfd7ORvnRVgasYOUrOL+RhRERmsWprj5xxn1dQE661e/fxUSaOUYtM07p6Vsc6I7O9ZZWj18yEi0mcbjM62/ZhV8slHlQ32NtuGcvpnuq9bYUjP73lvUT55ERHpk4d+Xvm2Q4fA4/+bX16qaFD3Rm40Kw9r4R/7werDYFgzTFgP3j2q5/7Gi3Xrj4gUycgV4IPr4Ngvpb8+5cz4HtoFN8CC38MqKw5s/vqokUu2xWshHwDbrNnCG9+pfPu+POJRRCRXyw2Fsw6Bs2/v/trwpO1raH0Nxt0ogTXNoCvZljOyh+/k4kbuIicijaelPoNWI5dsFWwT5+9S/h+630YDmBERkSxaUk7jY4rb47gnRX02spntYmaXmdmkZDmY2eeypFH7vSiI/TZp5srdjC1W6/ygleVb4JLdB2Vtu4jUg/nXw46bQrPBiGHw9wydpwrGy0y1ZGZHAxcCzwM7JKsXAKdmSUdRpMRBmzVzUMnAgYvbnGXShwkSESmGZYbA5Ezn/cIq6H223wN2dvdpZnZ8sm4qkKnOU8G2Bwq0IiIDp6C3+awAvJbMdxS0hwCLsyRSyMsIEREZfAraQeqvwAld1h0D/CVLIirZiohIIRS0ZHs0MMnMDgNWMLNngTlApkGnFWxFRKQQClCK7cbd3zSzTwJbA2OIq5T/6e6ZxoNTsBXJ21vvwyk3xz1G99m+1rkRKayClmxxdwceSaY+UbAVydNb78Pob8bz598JW98Kj5zRp6SeeKuVQ+6CT3wELt9NP11pPEUs2ZrZa5S5A8ndx1Sajn6xInna4n86L//zxT4lM212K1teE8//623443OtvH+Mfr7SWApasj2gy/LqwHeBG7Ikol+rSJ5mzKpKMp++vvPyrEw3HYjUhyKWbN39ga7rzGwycBfw60rTUbAVqQOvz6t1DkTyV9CHWqRZBKyb5Q0KtiIiUgi1fjRjGjOb2GXVMGAP4M4s6SjYilTTwsWw7BCw/KvDWtsddxiiJ51Jgyhom+3aXZbnA2cB12RJRMFWpFKz5sHYI2DeAvj2bvCbwzq/vsxXYEly693QIbC4NT2dcUfAyzPjES+ePBs2W6fsR7o7Q89KH1B5SLJ+/RXh34c0M7ROh1UT6VDEYOvu36hGOgq2IpUaeeDS+fPuhJ03hz23iZd3OXlpoAVYuKR8Oi/PjP86sPmx4LeU3XTTy9t6HU/5hTmw3DltfHk9uHVCC4+90conr4uTH7UcvHWkfuZSH4oSbCsdPs/d7680Tf0KRfrq4HNhVhJs73syl4+Y+n7l296W3FUUrlu6buYC2G9SK9eP109diq9AvZEvq2AbB8ZVmqB+gSJ9NWfh0vki9uxI3PAsXJ/pKa4itVGUkq27Z+ppXAkFW5G+KnCAFalHBSrZVl2mYBtCCMCJwPbAssAM4A7gl1EUvVn97IkUWOOeF0Rqoigl21JmtiJwMrAjsColv/wsj2us+A7iEMIuwIPAs8AWURStmHz4u8lfkcFFJVuRqiroeLYXAFsCE4GViYfcexU4O0siWUq2FwDXRVF0fMeKpDR7SpYPFBERSVPEki2wK7CJu79rZm3ufpuZRcAkMgTcikq2IYQNgfWB63rbNg9z587VvOZrPt+tIGvdt8mqNM1yn9u/VHtPX/Oazzqfl4KWbJuA2cn8PDNbCXiTOCZWzOJh+noWQtieuAp50yiK/pMtn1WhCjupPdur+7qOe2TTXqtUyX22kyZNAmD8+Lj7sJ1Z5sEY5ZI6riX1PX6c+kJKVeUSAe9uvjr1XP+FtgNrFnHN7D7g5+5+n5ldD7QD84Ct3D1Umk6lbbZvJ3/XzJZNkQZWN89MF6kPbulTjR0GTEvmjwEWACsBB5bZPlVFp4soip4DXgD2y5K4SENr730TEalce4ulTjX2iru/CODub7v7oe6+r7s/kyWRLHVL3wEmhRDeAs6LouiNEMIo4JvAS1EU/T7LB4vUvZb6KNqOXq7WORCpjBdzUI0ZZnYTcJ27P9jXRCo+W0RRdA/waWBT4N8hhLnAQ8AooNvguiINb8LWS+fXWCmXjxjWXPm2HQWAL3QZ1+CpQwp5AhPppq3FUqca25W4jfY6M5tmZqeb2eZZE8nUayKKogjYM+uHiDSEn/43/OzGeH5IE9z4w6WvPXEWfOSQ7GkevUePLz91MIyr4CmtXxoHt02II/Nd+7TwwKttPPi6c+QnmlhpaH2UwEW8qeaBtRt3fwJ4Avihme1I3Jx6n5nNcPePVZqOuiiKVOrkr8KJ+8D8hTBi+c6vjVoJ3rwMJt4IO2wKX9kOPlgEIw7onk7bzfDESzB2FKyyYo8fue7IFt4/qp2R53VvID51e5izGE7foZmmLuPn7jimmR0rfraNSDG0F7MaudSzwH+A14ANsrxRwVYki5bm7oG2w+iRcMHhS5dXHJa+XVMTbFX5LXpxybR7sP3xtvr5SmNpK2CwTe6r3RvYH9gG+DPwS+D/sqSjX6uIiBRCAW7zSfMG8Hfihzrt5e6ze9k+lYKtSB1IL9uKNJa2ArbZAuu5e78H2lHPCZE8LTekKskctUVVkhEpNG+y1KmmeapCoAUFW5F8XXVM5+Vl+laZ9OvPt7DxyvF8k8G0w/qZL5ECam+y1KkRqBpZJE/7bA8/fRV+dSussTJM/U2fk/rPIfq5SmNrb4y4mkq/XpG8nbxfPIlIjxqlFJtG1cgiIlII7WapUy1Z7DAzu9/MnkzW7WBm/50lHQVbEREphIK22U4kHgPgt0DHo2KmA8dnSUTVyCIiUghe41JsGQcDn3D3d8zswmTdy8C4LIko2IqISCEU9HGNzcQDEQB0DG4/vGRdRVSNLDLAPndDK8uf08p+k1prnRWRQnGz1KnG7gTOMrNlIW7DBU4BJmVJRMFWZABtfFkrf5kOH7TCDc/CqHMzBNxtTwDbK56+d2l+mRSpEW9uSp1q7FhgdWA2MIK4RLsOGdtsa74XIoPJs+93Xn57Mbw2u4KA+/4cePi5pcu/vqO6GRMpgKI9QcrMmoGvEA+rN4Z4IIL13H2Cu8/NkpaCrUiN/eqfFWx07QO550Ok1tqbmlOnWnH3NuAsd1/o7jPd/VF3n9GXtBRsRWrs6Xcq2GiJ2nel8RWtZJuYZGbj+5uIeiOL1Ngb8yvYaPmhuedDpNYKEFjTDAVuNrN/EA8a39EjGXc/sNJEFGxFcvLkzDaOm+xMnwuvzoGtRqdvV1Gh9a1Z3ddNmQZbfL/zurGrwUsXQe17cIpkVoCex2meSqZ+UbAVycGNU1vZ9/bO6/76evq2oUwQ7uSnN3Vf1zXQAkx7G5b9b1icsr1IwbXXvudxN+7+s2qko2ArkoOugbYnY1eq8ocvaatygiIDo4glWzP7XLnX3P3+StNRsBWpsanv1joHIsXQ3lS8ki1wWZfl1YBliJ+PXPEjGxVsRWps6nu1zoFIMRSxZOvu65YuJ/fenghkus+212AbQpgMbAssBtqBd4GHgHOiKHosy4eJSHcjlq11DkSKoYhttl25e5uZnUZcsj2r0vdVumenRFG0QhRFI4DPAq8AD4cQJmTPqoiUWk71SyJAYZ+NnGYX4sJnxTL/zKMoegU4MYSwOvCbEMKtURR5b+8TkTL06xEBitlma2ad7q0FhhHfe3tklnT6s2c3AGsCG/UjjYrMnTtX85qvu/lKLWrrW5rlYnTp+iIcB8033nxe2puaUqcaOwD4esm0G7CGu1+VJRFz7/myOmmzvTeKolO7rN8EeAb4dBRFD2X50D7Qtb/UFTuz8scrnr4dnLBdXMk0aVI8atf48V2eDmd7ZcuA35Jte5FscqnbPXWXh1PP9Sfes03N6pLN7Dh3PzNl/ffdvepttmnWSv7qxgWRfnh6Vq1zIFIM7U2WOtXYSWXWn5glkf50zdgXeB14th9piAx6b+VfOydSF4rUGarkYRbNZvZZOpfmx1HtW3+6CiGsDRwKHAzsq85RIv3TUpzzi0hNtVnN22dLdTzMYihwecl6B2YAR2dJrNJg+5MQwvHJh7wL/B3YLoqiSkbiFJEeLNDTFUWAYpVsOx5mYWZXZxndp5xeg20URTv190NEBpsWoNIuUhuPzDMnIvWjAD2Pu6lGoAUNHi+Si5e+Vfm2sxb18UOGNKev33nzPiYoUltu6VMtmdmKZnaWmT1mZq+Y2asdU5Z0FGxFcrD2ii20fr+ZZ79h3D4BJqwP1+6evu3rlQwe/5uDu6+bcy2suTK0NMFH14JPbwyTT4F7qzIimMiAa2tqSp1q7AJgS2AisDJxW+2rwNlZEtGD4kRy0txkbLhKMxuuAl9cL153wJ3dK5dXGVpBYotT1g1dFqZf2q88ihRJkdpsS+wKbOLu75pZm7vfZmYRMIkMAVfBVqTGVh1WwUaLFuaeD5Faa6v9PbVpmoDZyfw8M1sJeBNYP0siCrYiNTa6kmC7xiq550Ok1jyfB1P11xRgR+A+4G/A+cA84LksidS8MlxksPtuqOBnuP+O+WdEpMYK2mZ7GDAtmT8GWACsBGTqpVzzvRAZTM7YofPyHmNh1WEV/AyHtMAZB4IZNDfB/SfnkT2RmiriEHvu/pK7v5jMv+3uh7r7vu7+TJZ0VI0sMoCO27qFcSNaufhJOOLjMGHDDD/B4/aMJ5EGVcQ2WzMz4qcm7ges6u4fM7MdgNHufmOl6SjYigywvTZqYa/cB6YUqT/txWyznUg8WPw5wEXJuunEPZEVbEVEpL4UsWRLPA7AJ9z9HTO7MFn3MvFgBBVTsBURkUJoL+Z9ts3EvY9h6djqw0vWVUQdpEREpBDamix1qrE7gLPMbFn4sA33FOKHWlRMwVZERArBsdSpxr4PrEH8YIsRxCXadYDjsySiYCuSl9Y2uOQeuOI+aG+HWfPhlZnxa1NfgxFfgyH7wA+uqig5d+ful9s4J2rjrfntH67b5/9aWfPCVn7810rHGRIpptamptSpFsxsNIC7z3H3PYExwDbAeu4+wd3zHTxeRCo0fH9YtCSeP+T8petXHwlvzYL2pPnnzNtguSEwcf+ySbk7w89p44Nk7NtjJzt/GN/OvrdDa5LMz/8Jqwxt5ftb62ct9am95oXYTp4DVixZvsjd9+prYirZiuTh0eeXBtqu3nx/aaDtcMrNPSZ36j+WBtoOe09aGmg7/OSh+O9/3m3nmPtauWmqSrtSP9qsKXWqka6hf6f+JKZLYJE8PPpiVZP7XYXPqvmgDf49s42PXR1H4d88Acv8qZUPjm2mufYdTUR6VLCSrfe+SeUUbEVy0db7Jhk8O6vybcf/sfM5YrHDPre1ccsE/dyl2FprV4pN02Jmn2VpCbfrMu5+f8WJVTlzIgLg1btEf2h6tqrg11O6bdw1rTp5EclTW7FKtjOBy0uW3+2y7GR4sIWCrUguqlcD9eTMyrc1oD1l/ZLqFrRFctFaoKYOdx9bzfQUbEXyUMVzhmeI217mo6va+CSSkyXFqkauKgVbkYJLK6lmVcyn4Il0VrAOUlWlYCuSh2pEyIRlLJambq6irdSBxQ18VahgK5KH5upVh2U9/zTRvS+0Yq3Ug4IORFAVFQfbEMJkYFug4079GcB5URSdU/1sidS59ur1SMrSZgvpgbWBz2HSQBY18Bc16+X3KVEUDY+iaDhwAHBaCGHXHPIlUucKdtJQ0VbqQJtZ6tQI+lzXFUXRw8AzwGbVy45Io6hdNXKaKjYhi+RmoVnq1Aj6dEYIIVgIYXtgY+Af1c1Sd3PnztW85utrvg/nh3JpLly4IGNK3UOr9ZC+5jWfdT4vSyx9agTmFTYIJW22nwIWAcsAywEXA0dGUZT3LfOqBJP6cuEd8J1Ls73Hb2HSpHg86vHjx3+4+oLHWjnyL5UlYaQ/2KLFYMn/qD+kVE0uIXCNY95JPde/ce6qdR9ys5ZsT4uiaKUoioYBawOb0vnxVSIC3Uf1GUCpZyVdrkod+MAsdWoE/WmznQ7cCPR5fD8R6V2Wc42THlcVa6UezDZLnRpBn+uVQgijgX2AKdXLjoh0VY1A2RinK2l4DfxFzRpsfxJCOCGZnw88ABxX3SyJNICsj33qgWfsEZF6vmrgk5g0kAYpxaapONhGUbRTjvkQaTDVO2lU5dnsqkeWeqBgKyKZVHE82ywMxVWpYwq2IpJJFauR1xlR+bblhtgr0DChIuU18Pe0cQcPFGkQu6/XnGn7kct2X/ex1aqUGZE8maVPDUDBVqTgmswYM7zy7S9OeVr53fvopy51wMpMDUC/QJE8bLVBVZP7wjqVbbeMwd4btXDxLsb6I2DXdWDeMc2svJx+6lIHVLIVkUw+tSEsU6b6d9UVu6/bcdMekzvn803dLvCPD90v+vffJP77rY838/xhLdy9TwvLL9MYJysZBBq4ZKsOUiJ5mXc9XHAntDTDEV+AWR/Ae3NhgzXgur/B186Ot9tiLEw+tcekhg1pYvbRcOrD7cxbAj/6VBNrrtDESdu1s9Hl7bw5H8JouGIP/aSljjVIKTZNxQMR1FhdZFIks9a2OBgn0gYiECmgXKKi/Xh+6rneT1u+7qOwLoNFaqklW09jkYZW9yG1PAVbEREpiMaNtgq2IiJSDA3cZVfBVkREiqGBO0g18HWEiIhIMahkKyIixdDAD/FWyVZERCRnKtmKiEgxNHCbrYKtiIgUQ+PGWgVbEREpiAYOtmqzFRERyZlKtiIiUgzqjSwiIiJ9pZKtiIgUg3oji4iI5KxxY62CrYiIFEQDB1u12YqISN0xs2lmtlmt81EplWxFRKQYVLIVERHJmVn6VPHb7UAz+7eZPWlmfzSzUcn6f5jZJ5P5C8zs6WS+xczeMbPlc9mfEnVRsjWzu4FVa52PgdDS0rJqa2vrO7XORy0N9mMw2PcfdAzqYP/vcvfdqp2o/6Clz2XbpEr5F8BW7v6mmZ0C/AbYF7gP2Bl4FPg0sMDMVgfGAv9x9/n9zXtv6iLY5vFPLaoQQhRFUah1PmppsB+Dwb7/oGMw2Pe/jz4L3OHubybLFwNTkvn7gR+Z2e+Ad4EHiIPvusSBOHeqRhYRkUZggHdZ17H8ELAl8EXi4NpR0t2ZOBDnTsFWREQawX3AHmY2Olk+DLgXwN0XAY8DJyTrHga2Bz6WzOeuLqqRB5nf1joDBTDYj8Fg33/QMRjs+1+pe82stWT5R8A9ZubAS8DhJa/dB3wSiNy91cxeAF5298UDkVFz71rqFhERkWpSNbKIiEjOFGxFRERypjbbGgshHAD8ENgU+F4URef1sO1hwPHEve7uBI6Joqh9QDKaoxDCMOAKYCugFTguiqLbU7bbCbgDeC5ZtSiKok8NVD6rKYSwIXAVsArxrQgHRlH0fJdtmoFzgd2Ie1X+IoqiSwc6r3mp8BicDHwHeCNZ9VAURUcOZD7zEkI4E9ib+F7PzaMoeiplm4b+DgwmKtnW3r+ArwLX9bRRCGFd4KfAtsAGyXRA3pkbIMcBc6MoWh8YD1waQhheZttnoijaIpnqMtAmLgLOj6JoQ+B84nsCu/oasD7x/3pb4OQQwtgBy2H+KjkGAFeX/M8bItAmbgV2AF7pYZtG/w4MGgq2NRZF0VNRFD0D9FZC/QpwaxRFbyel2UuIn4zSCPYlPvGSlGwiYPea5ihHIYRRxPf8XZ+suh7YMoSwWpdN9wUuiaKoPYqit4lPzvsMWEZzlOEYNKwoih6Moui1XjZr2O/AYKNgWz/G0PkK+FVg7Rrlpdqy7NuGIYTHQwiPhBAOyj9ruVgbeD2KojaA5O8bdN/nRv6fV3oMAL4aQngyhPDnEMK2A5nJAmjk78CgojbbnIUQHif+waT5SMfJppH1dgwyJPU4sHYURbOTavV7QwivR1F0b78zKUV1EXBaFEVLQgi7ALeFEDaJoujdWmdMJAsF25xFUbRllZJ6FVinZHkM0FsVVCH0dgxCCB379nayagzwl5R05pTMvxxCuJX4KTD1FmxfA9YMITRHUdSWdIJZg+7/z47j8miy3LWUU88qOgZRFM0omb8nhPAasBnxs20Hg0b+DgwqqkauH38A9gwhrBZCaCJ+FNmNNc5TtdxE8qSXEMIGxE95uavrRiGE1UMIlsyvDOxK3MGsrkRRNJM43/slq/YDnkja5ErdBBwWQmhK2jL3JP4e1L1Kj0EIYc2S+S2Ie+4+OyCZLIaG/Q4MNgq2NRZC2C+EMJ2408MpIYTpIYRNk9cmhhCOAIii6CXgFOLneD5P/Ciya2uU7Wo7A1gphPACcDvwrSiK5kLnY0B8m8RTIYR/AX8Fromi6LZaZLgKjgCODiE8BxydLBNCuCOE0DHayzXE/+fnif/vE5PvQaOo5Bj8PITwVAhhCnGnwK+XlnbrWQjh3OS3vxZxk8jTyfrB9B0YNPS4RhERkZypZCsiIpIzBVsREZGcKdiKiIjkTMFWREQkZwq2IiIiOVOwldyY2VgzczNbK+fPOcLMrilZvtPMfpjnZ0o6M3vBzA6ucNsB+X4MBDNb1syeN7ONa50XKSYF2wIws3FmdpOZzTCzeWb2mpn90cyWSV4/2MxeSHlfufUHJCexk1Jem2xmi5LPmW1mT5jZ3vnsWf7MbHlgInByxzp3393df1WzTPUi+d98utb5GAzyONZmtpOZtZauc/dFwJnE94yLdKNgWwx3AG8CGwErEA+ldTfxuLV98S3gPeBQM2tOef0Udx9OPI7o9cDvzWzDPn5WrR0A/NvdX6x1RmTQux74nJmtX+uMSPEo2NaYma1CHGQvcvfZHpvu7hclV8tZ09sE+AxwELA6PQxV5+6twAVAM7B5SlpHmdkTXdata2ZtZjY2Wb4iKYnPNbNnzGz/HvJ2spnd22XdZDM7sWR5MzO728zeMbNXzex0MxvSwy7vCdxTLs2SqsqDkvzNN7M7zGykmf3CzGYmNQpHlrz/4KQ69HgzezPZ5n9L89HbfpvZx8zsLjN728zeM7N7kvVTkk3+nNQupA4EbmbDzOzXyWe8Y2a3mtmYktcnJ3n6Q5KHF83sy+UOUsk+HWtm05P3nGlmqyRpzDGzqaWlQDNrMbOTzOylZB/uM7PNSl4fYmZnlRzD41M+9zNm9mDy/hfN7H/MrOKLSDPb28ymJLUwU8xsQtd96rL9lR3HtNyxNrNpyX49mKyPzOyTaWmUrJtmcY3RGsCdQHPy3nlmdhCAu88hfobxf1W6fzJ4KNjWmLu/CzwNXGpmB5rZpllORikOJy7p3U5cYv5WuQ0trqY+ElgCTEnZ5HfAJma2Rcm6g4HJ7j4tWX4Q2AJYibg690oz27QvGTezUcQPmL+F+KH02wK7AP+vh7dtCTxTQfJ7A58mfpD7WOAR4MXkc74BnFMazIgf/j4GGJfkYzzxIPcdyu63ma2e7McDyWeNBn4J4O4fT96/q7sPd/dDy+T3bGCbZFoHeAeYZJ1rKg4CzgJGAOcBV5nZsB6OwTpJfsclx+Jo4sBxBjCS+LhfUbL9D4ADgT2IL9z+BtxjZismr58AfAnYDlg32dcPB8sws48SfwfPAFYDvggcBXy9hzx+yMy2Jf4OnkBcC/Mj4Hoz+1Ql7+/lWB8BfBdYGbgZuKNkv3pK8w3iC9i2JM3h7n5VySb/Jv5OinSiYFsMOwGTge8RP5z9LTP7SZegu66ZzSqdiEulHzKzocQnssuTVZcBe1j3Dig/Tt4/HfgysLe7d2v7dff3gduIgxFJfg4qSR93v8zd33X3Nne/AXgy2Z++OBCY4u4Xu/tid38dOD1ZX85IYE4Pr3c4xd3fSy5ubgeWuPsl7t7q7ncC7wOfKNm+HfiBuy9Iqqh/RXIcoNf9/jrwgruf7u7zk32peGQiM2si3ucT3f11d59P/N3YBNi6ZNPfu/tD7t4O/JY46G7QQ9ILgJ8l+ZlCfIH1qLs/7O5txM/aXt/MRiTbfwP4pbtPTWpZJgJtxEGTJI+/dPcX3H0B8cVI6fNfvw3c5O63JcdpKvFFQU//z1LfAP7g7ncm/6c/AX8EDqnw/T25zN0fc/fFxBdCC4gvHPprDnEAF+lEwbYA3P0dd/+Ru29JXPL4IXASJSd34GV3X6l0Ar7TJal9gOEsHaDgDmAm0LX0dFqSxih3387dJ/WQvSuAryWl4M8l+bsF4qBgZhPN7Nmkmm8W8HHiUkxfrAts3+WC4nLikmE57wO9lkiI28Q7fNBluWPdCiXLM939g5LlacQPjK9kv8cCz1WQp3JWA4YSP4AeAHefR/y/LB04/M2S1+cns6X70NXMJDB36HocOva3I421u+Shnfg4dORhrWS5NA8zS9JbF9ivy//zp8Sl5Ep0+vzEi1Rn8PRpHTMePyD+VZL/bz+tSNxfQqQTBduCcfcP3P1K4pLSFhnffjhx++tTZjaDuOS6MvBNS+8oVYk/AwuJr/oPBm5ISjEQD4t2KHEV7cjkAmAK5Tt2zQOW77JujZL5V4B7u1xUjEg6c5XzBNCnautejOpSJTuW+HhC7/s9jZ5LmL2N/vE2sIg4WAFgZsOBUQzsGMavdclDE/Fx6MjD68lyx+vLE+exwyvA5V3+nyu6+0f78vmJcSWf39v3Ccof69J8G3GTQcf/t1O6ZtZC5/0qvWDpajPi76RIJwq2NWZxR53TLe4YNCTplLI38Y/2bxnS2ZR4IPUJxEG6Y9qauGS4R1/yl5RmrgaOAfaipAqZ+Cq+lTg4NJnZIcQlvHIiYEsz2yrZz6PofDK9GghmdoiZDU1KkOPMbLce0rwV+HzmHetdE/ALM1vOzMYRV5F2tM31tt/XAhtZ3MFqWPJ/3bnk9Rn0EIxLjvkpZrZGEvT/F5gK/LNK+1eJK4EfmtmGSc3Gj4EW4E/J69cAPzCz9cxsOeKq9tILrQuAr5rZ+JLv9qZmtmOGz9/bzL5gZs1mtjvxd7CjXfkJ4ouiLyXflQnADl3SKHesDzGzLS3u9PYDYFjJfkXAzhZ3BlwWOA0o7aQ3g7iDVKcLATNbgfj39n8V7p8MIgq2tbeY+Kr5FuLqp7eBE4Gj3f2mDOkcDjzu7pPcfUbJ9CQlg7P30RXAjsRV2aUn+6uIOxq9QFzK2ZQeLhDcfTJx0LiLuPryI8BDJa/PAD5L3MN4GnEV8R+JSzPlXAN8PAmI1fQK8T69TLyPdxEHE+hlv5NONDsRd+6aDrwFlPbU/TEw0czeN7OLy3z+scQn/UeJqzhXB/4raVsdKGcQ387yZ+J9+BxxZ6OONvLTiW9Re5j4OL1KfNwAcPeniGtEvkf8/55JHEAramZw978T9xE4k/i78CvgAHd/OHn9ReJOTr8l/u3sRveB1csd698C5ybp7gt80d1nJ6/9jjhgPk5cbf0q8f+5I1/PEV9I/DOpHu/o8LUf8Bd3f76S/ZPBRePZSt0zsyOA7d29ol6uFaR3MHHnJN0v2YDMbBrx//fa3rbNkOaywFPEF0T/qVa60jhaap0Bkf5y94uAi2qdDxm8kt7aPbXTyyCnamQREZGcqRpZREQkZyrZioiI5EzBVkREJGcKtiIiIjlTsBUREcmZgq2IiEjO/j8u9l815aVlNwAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 576x223.2 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "shap.summary_plot(shap_values[\"Y0\"][\"T0\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}