diff --git a/examples/overlapping_gaussians.py b/examples/overlapping_gaussians.py
index 2d244b0..49f9d52 100644
--- a/examples/overlapping_gaussians.py
+++ b/examples/overlapping_gaussians.py
@@ -20,6 +20,7 @@
 
 color_dict = {
     "HonestRF": "#F41711",
+    "Iso-HonestRF": "#ce406b",
     "RF": "#1b9e77",
     "SigRF": "#377eb8",
     "IRF": "#fdae61",
@@ -40,6 +41,18 @@
             n_jobs=n_jobs,
         ),
     ),
+    (
+        "Iso-HonestRF",
+        CalibratedClassifierCV(
+            base_estimator=HonestForestClassifier(
+                n_estimators=n_estimators // clf_cv,
+                max_features=max_features,
+                n_jobs=n_jobs,
+            ),
+            method="isotonic",
+            cv=clf_cv,
+        ),
+    ),
     (
         "IRF",
         CalibratedClassifierCV(
@@ -168,3 +181,4 @@ def likelihood(X):
 # ax.set_title("Posterior probabilities")
 plt.tight_layout()
 plt.savefig("./figures/overlapping_gaussians.png")
+
diff --git a/honest_forests/estimators/adapted_forest.py b/honest_forests/estimators/adapted_forest.py
new file mode 100644
index 0000000..7ce9732
--- /dev/null
+++ b/honest_forests/estimators/adapted_forest.py
@@ -0,0 +1,961 @@
+"""Module for forest-based estimators"""
+"""I'm just using this version to facilitate future changes -Audrey"""
+# Authors: Ronan Perry
+# Adopted from: https://github.com/rflperry/ProgLearn/blob/UF/
+# License: MIT
+# and https://github.com/scikit-learn/scikit-learn/
+# License: BSD 3 clause
+
+import numpy as np
+from sklearn.utils.validation import check_X_y
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.ensemble._forest import ForestClassifier
+from sklearn.utils.multiclass import check_classification_targets
+from sklearn.utils.validation import check_is_fitted
+from joblib import Parallel, delayed
+from sklearn.ensemble._base import _partition_estimators
+# from sklearn.utils.fixes import _joblib_parallel_args
+import threading
+
+
+class HonestTreeClassifier(DecisionTreeClassifier):
+    """
+    A deecision tree classifier with honest predictions.
+
+    Parameters
+    ----------
+    honest_fraction : float, default=0.5
+        Fraction of training samples used for estimates in the leaves. The
+        remaining samples will be used to learn the tree structure. A larger
+        fraction creates shallower trees with lower variance estimates.
+
+    criterion : {"gini", "entropy"}, default="gini"
+        The function to measure the quality of a split. Supported criteria are
+        "gini" for the Gini impurity and "entropy" for the information gain.
+
+    splitter : {"best", "random"}, 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
+        the best random split.
+
+    max_depth : int, default=None
+        The maximum depth of the tree. If None, then nodes are expanded until
+        all leaves are pure or until all leaves contain less than
+        min_samples_split samples.
+
+    min_samples_split : int or float, default=2
+        The minimum number of samples required to split an internal node:
+
+        - If int, then consider `min_samples_split` as the minimum number.
+        - If float, then `min_samples_split` is a fraction and
+          `ceil(min_samples_split * n_samples)` are the minimum
+          number of samples for each split.
+
+    min_samples_leaf : int or float, default=1
+        The minimum number of samples required to be at a leaf node.
+        A split point at any depth will only be considered if it leaves at
+        least ``min_samples_leaf`` training samples in each of the left and
+        right branches.  This may have the effect of smoothing the model,
+        especially in regression.
+
+        - If int, then consider `min_samples_leaf` as the minimum number.
+        - If float, then `min_samples_leaf` is a fraction and
+          `ceil(min_samples_leaf * n_samples)` are the minimum
+          number of samples for each node.
+
+    min_weight_fraction_leaf : float, default=0.0
+        The minimum weighted fraction of the sum total of weights (of all
+        the input samples) required to be at a leaf node. Samples have
+        equal weight when sample_weight is not provided.
+
+    max_features : int, float or {"auto", "sqrt", "log2"}, default=None
+        The number of features to consider when looking for the best split:
+
+            - If int, then consider `max_features` features at each split.
+            - If float, then `max_features` is a fraction and
+              `int(max_features * n_features)` features are considered at each
+              split.
+            - If "auto", then `max_features=sqrt(n_features)`.
+            - If "sqrt", then `max_features=sqrt(n_features)`.
+            - If "log2", then `max_features=log2(n_features)`.
+            - If None, then `max_features=n_features`.
+
+        Note: the search for a split does not stop until at least one
+        valid partition of the node samples is found, even if it requires to
+        effectively inspect more than ``max_features`` features.
+
+    random_state : int, RandomState instance or None, default=None
+        Controls the randomness of the estimator. The features are always
+        randomly permuted at each split, even if ``splitter`` is set to
+        ``"best"``. When ``max_features < n_features``, the algorithm will
+        select ``max_features`` at random at each split before finding the best
+        split among them. But the best found split may vary across different
+        runs, even if ``max_features=n_features``. That is the case, if the
+        improvement of the criterion is identical for several splits and one
+        split has to be selected at random. To obtain a deterministic behaviour
+        during fitting, ``random_state`` has to be fixed to an integer.
+        See :term:`Glossary <random_state>` for details.
+
+    max_leaf_nodes : int, default=None
+        Grow a tree with ``max_leaf_nodes`` in best-first fashion.
+        Best nodes are defined as relative reduction in impurity.
+        If None then unlimited number of leaf nodes.
+
+    min_impurity_decrease : float, default=0.0
+        A node will be split if this split induces a decrease of the impurity
+        greater than or equal to this value.
+
+        The weighted impurity decrease equation is the following::
+
+            N_t / N * (impurity - N_t_R / N_t * right_impurity
+                                - N_t_L / N_t * left_impurity)
+
+        where ``N`` is the total number of samples, ``N_t`` is the number of
+        samples at the current node, ``N_t_L`` is the number of samples in the
+        left child, and ``N_t_R`` is the number of samples in the right child.
+
+        ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum,
+        if ``sample_weight`` is passed.
+
+    class_weight : dict, list of dict or "balanced", default=None
+        Weights associated with classes in the form ``{class_label: weight}``.
+        If None, all classes are supposed to have weight one. For
+        multi-output problems, a list of dicts can be provided in the same
+        order as the columns of y.
+
+        Note that for multioutput (including multilabel) weights should be
+        defined for each class of every column in its own dict. For example,
+        for four-class multilabel classification weights should be
+        [{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of
+        [{1:1}, {2:5}, {3:1}, {4:1}].
+
+        The "balanced" mode uses the values of y to automatically adjust
+        weights inversely proportional to class frequencies in the input data
+        as ``n_samples / (n_classes * np.bincount(y))``
+
+        For multi-output, the weights of each column of y will be multiplied.
+
+        Note that these weights will be multiplied with sample_weight (passed
+        through the fit method) if sample_weight is specified.
+
+    ccp_alpha : non-negative float, default=0.0
+        Complexity parameter used for Minimal Cost-Complexity Pruning. The
+        subtree with the largest cost complexity that is smaller than
+        ``ccp_alpha`` will be chosen. By default, no pruning is performed. See
+        :ref:`minimal_cost_complexity_pruning` for details.
+
+    honest_prior : {"ignore", "uniform", "empirical"}, default="empirical"
+        Method for dealing with empty leaves during evaluation of a test
+        sample. If "ignore", returns numpy.nan.
+        If "uniform", the prior tree posterior is 1/(number of
+        classes). If "empirical", the prior tree posterior is the relative
+        class frequency in the voting subsample.
+
+    Attributes
+    ----------
+    classes_ : ndarray of shape (n_classes,) or list of ndarray
+        The classes labels (single output problem),
+        or a list of arrays of class labels (multi-output problem).
+
+    feature_importances_ : ndarray of shape (n_features,)
+        The impurity-based feature importances.
+        The higher, the more important the feature.
+        The importance of a feature is computed as the (normalized)
+        total reduction of the criterion brought by that feature.  It is also
+        known as the Gini importance [4]_.
+
+        Warning: impurity-based feature importances can be misleading for
+        high cardinality features (many unique values). See
+        :func:`sklearn.inspection.permutation_importance` as an alternative.
+
+    max_features_ : int
+        The inferred value of max_features.
+
+    n_classes_ : int or list of int
+        The number of classes (for single output problems),
+        or a list containing the number of classes for each
+        output (for multi-output problems).
+
+    n_features_ : int
+        The number of features when ``fit`` is performed.
+
+        .. deprecated:: 1.0
+           `n_features_` is deprecated in 1.0 and will be removed in
+           1.2. Use `n_features_in_` instead.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    n_outputs_ : int
+        The number of outputs when ``fit`` is performed.
+
+    tree_ : Tree instance
+        The underlying Tree object. Please refer to
+        ``help(sklearn.tree._tree.Tree)`` for attributes of Tree object and
+        :ref:`sphx_glr_auto_examples_tree_plot_unveil_tree_structure.py`
+        for basic usage of these attributes.
+
+    empirical_prior_ : float
+        Proportion of each class in the training labels y
+
+    structure_indices_ : numpy.ndarray, shape=(n_structure,)
+        Indices of training samples used to learn the structure
+
+    honest_indices_ : numpy.ndarray, shape=(n_honest,)
+        Indices of training samples used to learn leaf estimates
+
+    Notes
+    -----
+    The default values for the parameters controlling the size of the trees
+    (e.g. ``max_depth``, ``min_samples_leaf``, etc.) lead to fully grown and
+    unpruned trees which can potentially be very large on some data sets. To
+    reduce memory consumption, the complexity and size of the trees should be
+    controlled by setting those parameter values.
+
+    The :meth:`predict` method operates using the :func:`numpy.argmax`
+    function on the outputs of :meth:`predict_proba`. This means that in
+    case the highest predicted probabilities are tied, the classifier will
+    predict the tied class with the lowest index in :term:`classes_`.
+
+    References
+    ----------
+
+    .. [1] https://en.wikipedia.org/wiki/Decision_tree_learning
+
+    .. [2] L. Breiman, J. Friedman, R. Olshen, and C. Stone, "Classification
+            and Regression Trees", Wadsworth, Belmont, CA, 1984.
+
+    .. [3] T. Hastie, R. Tibshirani and J. Friedman. "Elements of Statistical
+            Learning", Springer, 2009.
+
+    .. [4] L. Breiman, and A. Cutler, "Random Forests",
+            https://www.stat.berkeley.edu/~breiman/RandomForests/cc_home.htm
+
+    .. [5] S. Athey, J. Tibshirani, and S. Wager. "Generalized
+            Random Forests", Annals of Statistics, 2019.
+
+    Examples
+    --------
+    >>> from sklearn.datasets import load_iris
+    >>> from sklearn.model_selection import cross_val_score
+    >>> from honest_forests import HonestTreeClassifier
+    >>> clf = HonestTreeClassifier(random_state=0)
+    >>> iris = load_iris()
+    >>> cross_val_score(clf, iris.data, iris.target, cv=10)
+    ...                             # doctest: +SKIP
+    ...
+    array([0.93333333, 0.93333333, 1.        , 1.        , 0.93333333,
+           0.8       , 0.8       , 0.93333333, 1.        , 1.        ])
+    """
+
+    def __init__(
+        self,
+        honest_fraction=0.5,
+        criterion="gini",
+        splitter="best",
+        max_depth=None,
+        min_samples_split=2,
+        min_samples_leaf=1,
+        min_weight_fraction_leaf=0.0,
+        max_features=None,
+        random_state=None,
+        max_leaf_nodes=None,
+        min_impurity_decrease=0.0,
+        class_weight=None,
+        ccp_alpha=0.0,
+        honest_prior="empirical",
+    ):
+        super().__init__(
+            criterion=criterion,
+            splitter=splitter,
+            max_depth=max_depth,
+            min_samples_split=min_samples_split,
+            min_samples_leaf=min_samples_leaf,
+            min_weight_fraction_leaf=min_weight_fraction_leaf,
+            max_features=max_features,
+            max_leaf_nodes=max_leaf_nodes,
+            class_weight=class_weight,
+            random_state=random_state,
+            min_impurity_decrease=min_impurity_decrease,
+            ccp_alpha=ccp_alpha,
+        )
+        self.honest_fraction = honest_fraction
+        self.honest_prior = honest_prior
+
+    def fit(self, X, y, sample_weight=None, check_input=True):
+        """Build an honest tree classifier from the training set (X, y).
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The training input samples. Internally, it will be converted to
+            ``dtype=np.float32`` and if a sparse matrix is provided
+            to a sparse ``csc_matrix``.
+
+        y : array-like of shape (n_samples,) or (n_samples, n_outputs)
+            The target values (class labels) as integers or strings.
+
+        sample_weight : array-like of shape (n_samples,), default=None
+            Sample weights. If None, then samples are equally weighted. Splits
+            that would create child nodes with net zero or negative weight are
+            ignored while searching for a split in each node. Splits are also
+            ignored if they would result in any single class carrying a
+            negative weight in either child node.
+
+        check_input : bool, default=True
+            Allow to bypass several input checking.
+            Don't use this parameter unless you know what you do.
+
+        Returns
+        -------
+        self : HonestTreeClassifier
+            Fitted estimator.
+        """
+        if check_input:
+            X, y = check_X_y(X, y)
+
+        # Account for bootstrapping too
+        if sample_weight is None:
+            sample_weight = np.ones((X.shape[0],), dtype=np.float64)
+
+        nonzero_indices = np.where(sample_weight > 0)[0]
+
+        self.structure_indices_ = np.random.choice(
+            nonzero_indices,
+            int((1 - self.honest_fraction) * len(nonzero_indices)),
+            replace=False,
+        )
+        self.honest_indices_ = np.setdiff1d(nonzero_indices, self.structure_indices_)
+
+        sample_weight[self.honest_indices_] = 0
+
+        # Learn structure on subsample
+        super().fit(
+            X,
+            y,
+            sample_weight=sample_weight,
+            check_input=check_input,
+        )
+
+        if self.n_outputs_ > 1:
+            raise NotImplementedError(
+                "Multi-target honest trees not yet \
+                implemented"
+            )
+
+        # update the number of classes, unsplit
+        # self.n_samples_, self.n_features_in_ = X.shape
+        if y.ndim == 1:
+            # reshape is necessary to preserve the data contiguity against vs
+            # [:, np.newaxis] that does not.
+            y = np.reshape(y, (-1, 1))
+        check_classification_targets(y)
+        y = np.copy(y).astype(int)
+        # Normally called by super
+        X = self._validate_X_predict(X, True)
+        # Fit leaves using other subsample
+        honest_leaves = self.tree_.apply(X[self.honest_indices_])
+
+        self.tree_.value[:, :, :] = 0
+        for leaf_id, yval in zip(honest_leaves, y[self.honest_indices_, 0]):
+            self.tree_.value[leaf_id][0, yval] += 1
+
+        # preserve from underlying tree
+        # https://github.com/scikit-learn/scikit-learn/blob/1.0.X/sklearn/tree/_classes.py#L202
+        self._tree_classes_ = self.classes_
+        self._tree_n_classes_ = self.n_classes_
+        self.classes_ = []
+        self.n_classes_ = []
+        self.empirical_prior_ = []
+
+        y_encoded = np.zeros(y.shape, dtype=int)
+        for k in range(self.n_outputs_):
+            classes_k, y_encoded[:, k] = np.unique(y[:, k], return_inverse=True)
+            self.classes_.append(classes_k)
+            self.n_classes_.append(classes_k.shape[0])
+            self.empirical_prior_.append(
+                np.bincount(y_encoded[:, k], minlength=classes_k.shape[0]) / y.shape[0]
+            )
+        y = y_encoded
+
+        self.n_classes_ = np.array(self.n_classes_, dtype=np.intp)
+
+        if self.n_outputs_ == 1:
+            self.n_classes_ = self.n_classes_[0]
+            self.classes_ = self.classes_[0]
+            self.empirical_prior_ = self.empirical_prior_[0]
+            y = y[:, 0]
+
+        return self
+
+    def _empty_leaf_correction(self, proba, normalizer):
+        """Leaves with empty posteriors are assigned values"""
+        zero_mask = proba.sum(axis=1) == 0.0
+        if self.honest_prior == "empirical":
+            proba[zero_mask] = self.empirical_prior_
+        elif self.honest_prior == "uniform":
+            proba[zero_mask] = 1 / self.n_classes_
+        elif self.honest_prior == "ignore":
+            proba[zero_mask] = np.nan
+        else:
+            raise ValueError(f"honest_prior {self.honest_prior} not a valid input.")
+
+        return proba
+
+    def _impute_missing_classes(self, proba):
+        """Due to splitting, provide proba outputs for some classes"""
+        new_proba = np.zeros((proba.shape[0], self.n_classes_))
+        for i, old_class in enumerate(self._tree_classes_):
+            j = np.where(self.classes_ == old_class)[0][0]
+            new_proba[:, j] = proba[:, i]
+
+        return new_proba
+
+    def predict_proba(self, X, check_input=True):
+        """Predict class probabilities of the input samples X.
+
+        The predicted class probability is the fraction of samples of the same
+        class in a leaf.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The input samples. Internally, it will be converted to
+            ``dtype=np.float32`` and if a sparse matrix is provided
+            to a sparse ``csr_matrix``.
+
+        check_input : bool, default=True
+            Allow to bypass several input checking.
+            Don't use this parameter unless you know what you do.
+
+        Returns
+        -------
+        proba : ndarray of shape (n_samples, n_classes) or list of n_outputs \
+            such arrays if n_outputs > 1
+            The class probabilities of the input samples. The order of the
+            classes corresponds to that in the attribute :term:`classes_`.
+        """
+        check_is_fitted(self)
+        X = self._validate_X_predict(X, check_input)
+        proba = self.tree_.predict(X)
+
+        if self.n_outputs_ == 1:
+            proba = proba[:, : self._tree_n_classes_]
+            normalizer = proba.sum(axis=1)[:, np.newaxis]
+            normalizer[normalizer == 0.0] = 1.0
+            proba /= normalizer
+            if self._tree_n_classes_ != self.n_classes_:
+                proba = self._impute_missing_classes(proba)
+            proba = self._empty_leaf_correction(proba, normalizer)
+
+            return proba
+
+        else:
+            raise NotImplementedError(
+                "Multi-target honest trees not yet \
+                implemented"
+            )
+            # all_proba = []
+
+            # for k in range(self.n_outputs_):
+            #     proba_k = proba[:, k, : self._tree_n_classes_[k]]
+            #     normalizer = proba_k.sum(axis=1)[:, np.newaxis]
+            #     normalizer[normalizer == 0.0] = 1.0
+            #     proba_k /= normalizer
+            #     proba = self._impute_missing_classes(proba)
+            #     proba_k = self._empty_leaf_correction(proba_k, normalizer)
+            #     all_proba.append(proba_k)
+
+            # return all_proba
+
+
+class HonestForestClassifier(ForestClassifier):
+    """
+    A random forest classifier with honest leaf estimates.
+
+    A random forest is a meta estimator that fits a number of decision tree
+    classifiers on various sub-samples of the dataset and uses averaging to
+    improve the predictive accuracy and control over-fitting.
+    The sub-sample size is controlled with the `max_samples` parameter if
+    `bootstrap=True` (default), otherwise the whole dataset is used to build
+    each tree.
+
+    Read more in the :ref:`User Guide <forest>`.
+
+    Parameters
+    ----------
+    n_estimators : int, default=100
+        The number of trees in the forest.
+
+    honest_fraction : float, default=0.5
+        Fraction of training samples used for estimates in the trees. The
+        remaining samples will be used to learn the tree structure. A larger
+        fraction creates shallower trees with lower variance estimates.
+
+    criterion : {"gini", "entropy"}, default="gini"
+        The function to measure the quality of a split. Supported criteria are
+        "gini" for the Gini impurity and "entropy" for the information gain.
+        Note: this parameter is tree-specific.
+
+    max_depth : int, default=None
+        The maximum depth of the tree. If None, then nodes are expanded until
+        all leaves are pure or until all leaves contain less than
+        min_samples_split samples.
+
+    min_samples_split : int or float, default=2
+        The minimum number of samples required to split an internal node:
+
+        - If int, then consider `min_samples_split` as the minimum number.
+        - If float, then `min_samples_split` is a fraction and
+          `ceil(min_samples_split * n_samples)` are the minimum
+          number of samples for each split.
+
+    min_samples_leaf : int or float, default=1
+        The minimum number of samples required to be at a leaf node.
+        A split point at any depth will only be considered if it leaves at
+        least ``min_samples_leaf`` training samples in each of the left and
+        right branches.  This may have the effect of smoothing the model,
+        especially in regression.
+
+        - If int, then consider `min_samples_leaf` as the minimum number.
+        - If float, then `min_samples_leaf` is a fraction and
+          `ceil(min_samples_leaf * n_samples)` are the minimum
+          number of samples for each node.
+
+    min_weight_fraction_leaf : float, default=0.0
+        The minimum weighted fraction of the sum total of weights (of all
+        the input samples) required to be at a leaf node. Samples have
+        equal weight when sample_weight is not provided.
+
+    max_features : {"sqrt", "log2", None}, int or float, default="sqrt"
+        The number of features to consider when looking for the best split:
+
+        - If int, then consider `max_features` features at each split.
+        - If float, then `max_features` is a fraction and
+          `round(max_features * n_features)` features are considered at each
+          split.
+        - If "auto", then `max_features=sqrt(n_features)`.
+        - If "sqrt", then `max_features=sqrt(n_features)`.
+        - If "log2", then `max_features=log2(n_features)`.
+        - If None, then `max_features=n_features`.
+
+        .. versionchanged:: 1.1
+            The default of `max_features` changed from `"auto"` to `"sqrt"`.
+
+        .. deprecated:: 1.1
+            The `"auto"` option was deprecated in 1.1 and will be removed
+            in 1.3.
+
+        Note: the search for a split does not stop until at least one
+        valid partition of the node samples is found, even if it requires to
+        effectively inspect more than ``max_features`` features.
+
+    max_leaf_nodes : int, default=None
+        Grow trees with ``max_leaf_nodes`` in best-first fashion.
+        Best nodes are defined as relative reduction in impurity.
+        If None then unlimited number of leaf nodes.
+
+    min_impurity_decrease : float, default=0.0
+        A node will be split if this split induces a decrease of the impurity
+        greater than or equal to this value.
+
+        The weighted impurity decrease equation is the following::
+
+            N_t / N * (impurity - N_t_R / N_t * right_impurity
+                                - N_t_L / N_t * left_impurity)
+
+        where ``N`` is the total number of samples, ``N_t`` is the number of
+        samples at the current node, ``N_t_L`` is the number of samples in the
+        left child, and ``N_t_R`` is the number of samples in the right child.
+
+        ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum,
+        if ``sample_weight`` is passed.
+
+    bootstrap : bool, default=True
+        Whether bootstrap samples are used when building trees. If False, the
+        whole dataset is used to build each tree.
+
+    oob_score : bool, default=False
+        Whether to use out-of-bag samples to estimate the generalization score.
+        Only available if bootstrap=True.
+
+    n_jobs : int, default=None
+        The number of jobs to run in parallel. :meth:`fit`, :meth:`predict`,
+        :meth:`decision_path` and :meth:`apply` are all parallelized over the
+        trees. ``None`` means 1 unless in a :obj:`joblib.parallel_backend`
+        context. ``-1`` means using all processors. See :term:`Glossary
+        <n_jobs>` for more details.
+
+    random_state : int, RandomState instance or None, default=None
+        Controls both the randomness of the bootstrapping of the samples used
+        when building trees (if ``bootstrap=True``) and the sampling of the
+        features to consider when looking for the best split at each node
+        (if ``max_features < n_features``).
+        See :term:`Glossary <random_state>` for details.
+
+    verbose : int, default=0
+        Controls the verbosity when fitting and predicting.
+
+    warm_start : bool, default=False
+        When set to ``True``, reuse the solution of the previous call to fit
+        and add more estimators to the ensemble, otherwise, just fit a whole
+        new forest. See :term:`the Glossary <warm_start>`.
+
+    class_weight : {"balanced", "balanced_subsample"}, dict or list of dicts, \
+            default=None
+        Weights associated with classes in the form ``{class_label: weight}``.
+        If not given, all classes are supposed to have weight one. For
+        multi-output problems, a list of dicts can be provided in the same
+        order as the columns of y.
+
+        Note that for multioutput (including multilabel) weights should be
+        defined for each class of every column in its own dict. For example,
+        for four-class multilabel classification weights should be
+        [{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of
+        [{1:1}, {2:5}, {3:1}, {4:1}].
+
+        The "balanced" mode uses the values of y to automatically adjust
+        weights inversely proportional to class frequencies in the input data
+        as ``n_samples / (n_classes * np.bincount(y))``
+
+        The "balanced_subsample" mode is the same as "balanced" except that
+        weights are computed based on the bootstrap sample for every tree
+        grown.
+
+        For multi-output, the weights of each column of y will be multiplied.
+
+        Note that these weights will be multiplied with sample_weight (passed
+        through the fit method) if sample_weight is specified.
+
+    ccp_alpha : non-negative float, default=0.0
+        Complexity parameter used for Minimal Cost-Complexity Pruning. The
+        subtree with the largest cost complexity that is smaller than
+        ``ccp_alpha`` will be chosen. By default, no pruning is performed. See
+        :ref:`minimal_cost_complexity_pruning` for details.
+
+    max_samples : int or float, default=None
+        If bootstrap is True, the number of samples to draw from X
+        to train each base estimator.
+
+        - If None (default), then draw `X.shape[0]` samples.
+        - If int, then draw `max_samples` samples.
+        - If float, then draw `max_samples * X.shape[0]` samples. Thus,
+          `max_samples` should be in the interval `(0.0, 1.0]`.
+
+    honest_prior : {"ignore", "uniform", "empirical"}, default="empirical"
+        Method for dealing with empty leaves during evaluation of a test
+        sample. If "ignore", the tree is ignored. If "uniform", the prior tree
+        posterior is 1/(number of classes). If "empirical", the prior tree
+        posterior is the relative class frequency in the voting subsample.
+        If all trees are ignored, the empirical estimate is returned.
+
+    honest_score : bool, default=False
+        Whether to use the honest samples to make estimate on the training
+        data.
+
+    Attributes
+    ----------
+    base_estimator_ : DecisionTreeClassifier
+        The child estimator template used to create the collection of fitted
+        sub-estimators.
+
+    estimators_ : list of DecisionTreeClassifier
+        The collection of fitted sub-estimators.
+
+    classes_ : ndarray of shape (n_classes,) or a list of such arrays
+        The classes labels (single output problem), or a list of arrays of
+        class labels (multi-output problem).
+
+    n_classes_ : int or list
+        The number of classes (single output problem), or a list containing the
+        number of classes for each output (multi-output problem).
+
+    n_features_ : int
+        The number of features when ``fit`` is performed.
+
+        .. deprecated:: 1.0
+            Attribute `n_features_` was deprecated in version 1.0 and will be
+            removed in 1.2. Use `n_features_in_` instead.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    n_outputs_ : int
+        The number of outputs when ``fit`` is performed.
+
+    feature_importances_ : ndarray of shape (n_features,)
+        The impurity-based feature importances.
+        The higher, the more important the feature.
+        The importance of a feature is computed as the (normalized)
+        total reduction of the criterion brought by that feature.  It is also
+        known as the Gini importance.
+
+        Warning: impurity-based feature importances can be misleading for
+        high cardinality features (many unique values). See
+        :func:`sklearn.inspection.permutation_importance` as an alternative.
+
+    oob_score_ : float
+        Score of the training dataset obtained using an out-of-bag estimate.
+        This attribute exists only when ``oob_score`` is True.
+
+    oob_decision_function_ : ndarray of shape (n_samples, n_classes) or \
+            (n_samples, n_classes, n_outputs)
+        Decision function computed with out-of-bag estimate on the training
+        set. If n_estimators is small it might be possible that a data point
+        was never left out during the bootstrap. In this case,
+        `oob_decision_function_` might contain NaN. This attribute exists
+        only when ``oob_score`` is True.
+
+    honest_decision_function_ : ndarray of shape (n_samples, n_classes) or \
+            (n_samples, n_classes, n_outputs)
+        Decision function computed on each sample, including only the trees
+        for which it was in the honest subsample. It is possible that a sample
+        is never in the honest subset in which case `honest_decision_function_`
+        might contain NaN. This attribute exists when `honest_score_` is True.
+
+    structure_indices_ : list of lists, shape=(n_estimators, n_structure)
+        Indices of training samples used to learn the structure
+
+    honest_indices_ : list of lists, shape=(n_estimators, n_honest)
+        Indices of training samples used to learn leaf estimates
+
+    Notes
+    -----
+    The default values for the parameters controlling the size of the trees
+    (e.g. ``max_depth``, ``min_samples_leaf``, etc.) lead to fully grown and
+    unpruned trees which can potentially be very large on some data sets. To
+    reduce memory consumption, the complexity and size of the trees should be
+    controlled by setting those parameter values.
+
+    The features are always randomly permuted at each split. Therefore,
+    the best found split may vary, even with the same training data,
+    ``max_features=n_features`` and ``bootstrap=False``, if the improvement
+    of the criterion is identical for several splits enumerated during the
+    search of the best split. To obtain a deterministic behaviour during
+    fitting, ``random_state`` has to be fixed.
+
+    References
+    ----------
+    .. [1] L. Breiman, "Random Forests", Machine Learning, 45(1), 5-32, 2001.
+
+    .. [2] S. Athey, J. Tibshirani, and S. Wager. "Generalized
+            Random Forests", Annals of Statistics, 2019.
+
+    Examples
+    --------
+    >>> from honest_forests.estimators import HonestForestClassifier
+    >>> from sklearn.datasets import make_classification
+    >>> X, y = make_classification(n_samples=1000, n_features=4,
+    ...                            n_informative=2, n_redundant=0,
+    ...                            random_state=0, shuffle=False)
+    >>> clf = HonestForestClassifier(max_depth=2, random_state=0)
+    >>> clf.fit(X, y)
+    HonestForestClassifier(...)
+    >>> print(clf.predict([[0, 0, 0, 0]]))
+    [1]
+    """
+
+    def __init__(
+        self,
+        n_estimators=100,
+        honest_fraction=0.5,
+        criterion="gini",
+        max_depth=None,
+        min_samples_split=2,
+        min_samples_leaf=1,
+        min_weight_fraction_leaf=0.0,
+        max_features="sqrt",
+        max_leaf_nodes=None,
+        min_impurity_decrease=0.0,
+        bootstrap=False,
+        oob_score=False,
+        n_jobs=None,
+        random_state=None,
+        verbose=0,
+        warm_start=False,
+        class_weight=None,
+        ccp_alpha=0.0,
+        max_samples=None,
+        honest_prior="empirical",
+    ):
+        super().__init__(
+            base_estimator=HonestTreeClassifier(),
+            n_estimators=n_estimators,
+            estimator_params=(
+                "honest_fraction",
+                "criterion",
+                "max_depth",
+                "min_samples_split",
+                "min_samples_leaf",
+                "min_weight_fraction_leaf",
+                "max_features",
+                "max_leaf_nodes",
+                "min_impurity_decrease",
+                "random_state",
+                "ccp_alpha",
+                "honest_prior",
+            ),
+            bootstrap=bootstrap,
+            oob_score=oob_score,
+            n_jobs=n_jobs,
+            random_state=random_state,
+            verbose=verbose,
+            warm_start=warm_start,
+            class_weight=class_weight,
+            max_samples=max_samples,
+        )
+        self.honest_fraction = honest_fraction
+        self.criterion = criterion
+        self.max_depth = max_depth
+        self.min_samples_split = min_samples_split
+        self.min_samples_leaf = min_samples_leaf
+        self.min_weight_fraction_leaf = min_weight_fraction_leaf
+        self.max_features = max_features
+        self.max_leaf_nodes = max_leaf_nodes
+        self.min_impurity_decrease = min_impurity_decrease
+        self.ccp_alpha = ccp_alpha
+        self.honest_prior = honest_prior
+
+    def fit(self, X, y, sample_weight=None):
+        """
+        Build a forest of trees from the training set (X, y).
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The training input samples. Internally, its dtype will be converted
+            to ``dtype=np.float32``. If a sparse matrix is provided, it will be
+            converted into a sparse ``csc_matrix``.
+
+        y : array-like of shape (n_samples,) or (n_samples, n_outputs)
+            The target values (class labels in classification, real numbers in
+            regression).
+
+        sample_weight : array-like of shape (n_samples,), default=None
+            Sample weights. If None, then samples are equally weighted. Splits
+            that would create child nodes with net zero or negative weight are
+            ignored while searching for a split in each node. In the case of
+            classification, splits are also ignored if they would result in any
+            single class carrying a negative weight in either child node.
+
+        Returns
+        -------
+        self : object
+            Fitted estimator.
+        """
+        super().fit(X, y, sample_weight)
+        classes_k, y_encoded = np.unique(y, return_inverse=True)
+        self.empirical_prior_ = np.bincount(
+            y_encoded, minlength=classes_k.shape[0]
+        ) / len(y)
+
+        # Compute honest decision function
+        self.honest_decision_function_ = self._predict_proba(
+            X, indices=self.honest_indices_, impute_missing=np.nan
+        )
+        return self
+
+    def predict_proba(self, X):
+        """
+        Predict class probabilities for X.
+
+        The predicted class probabilities of an input sample are computed as
+        the mean predicted class probabilities of the trees in the forest.
+        The class probability of a single tree is the fraction of samples of
+        the same class in a leaf.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The input samples. Internally, its dtype will be converted to
+            ``dtype=np.float32``. If a sparse matrix is provided, it will be
+            converted into a sparse ``csr_matrix``.
+
+        Returns
+        -------
+        p : ndarray of shape (n_samples, n_classes), or a list of such arrays
+            The class probabilities of the input samples. The order of the
+            classes corresponds to that in the attribute :term:`classes_`.
+        """
+        return self._predict_proba(X)
+
+    def _predict_proba(self, X, indices=None, impute_missing=None):
+        """predict_proba helper class"""
+        X = self._validate_X_predict(X)
+        n_jobs, _, _ = _partition_estimators(self.n_estimators, self.n_jobs)
+
+        # avoid storing the output of every estimator by summing them here
+        posteriors = np.zeros((X.shape[0], self.n_classes_), dtype=np.float64)
+        lock = threading.Lock()
+
+        if indices is None:
+            indices = [None] * self.n_estimators
+        Parallel(
+            n_jobs=n_jobs,
+            verbose=self.verbose,
+            # new version of joblib no longer uses **_joblib_parallel_args
+            # **_joblib_parallel_args(require="sharedmem")
+            require="sharedmem"
+        )(
+            delayed(_accumulate_prediction)(tree, X, posteriors, lock, idx)
+            for tree, idx in zip(self.estimators_, indices)
+        )
+
+        # Normalize to unit length, due to prior weighting
+        zero_mask = posteriors.sum(1) == 0
+        posteriors[~zero_mask] /= posteriors[~zero_mask].sum(1, keepdims=True)
+        if impute_missing is None:
+            posteriors[zero_mask] = self.empirical_prior_
+        else:
+            posteriors[zero_mask] = impute_missing
+
+        return posteriors
+
+    @property
+    def structure_indices_(self):
+        check_is_fitted(self)
+        return [tree.structure_indices_ for tree in self.estimators_]
+
+    @property
+    def honest_indices_(self):
+        check_is_fitted(self)
+        return [tree.honest_indices_ for tree in self.estimators_]
+
+
+def _accumulate_prediction(tree, X, out, lock, indices=None):
+    """
+    See https://github.com/scikit-learn/scikit-learn/blob/95119c13af77c76e150b753485c662b7c52a41a2/sklearn/ensemble/_forest.py#L460
+    This is a utility function for joblib's Parallel.
+    It can't go locally in ForestClassifier or ForestRegressor, because joblib
+    complains that it cannot pickle it when placed there.
+    """
+
+    if indices is None:
+        indices = np.arange(X.shape[0])
+    # predict = DecisionTreeClassifier.tree_.predict
+    proba = tree.tree_.predict(X[indices])
+    proba = proba[:, : tree._tree_n_classes_]
+    normalizer = proba.sum(axis=1)[:, np.newaxis]
+    normalizer[normalizer == 0.0] = 1.0
+    proba /= normalizer
+
+    if tree._tree_n_classes_ != tree.n_classes_:
+        proba = tree._impute_missing_classes(proba)
+    proba = tree._empty_leaf_correction(proba, normalizer)
+
+    with lock:
+        out[indices] += proba
diff --git a/honest_forests/estimators/forest.py b/honest_forests/estimators/forest.py
index 3019cc7..1b6a5ed 100644
--- a/honest_forests/estimators/forest.py
+++ b/honest_forests/estimators/forest.py
@@ -12,7 +12,8 @@
 from sklearn.utils.validation import check_is_fitted
 from joblib import Parallel, delayed
 from sklearn.ensemble._base import _partition_estimators
-from sklearn.utils.fixes import _joblib_parallel_args
+# new version of joblib doesnt work in the following format
+# from sklearn.utils.fixes import _joblib_parallel_args
 import threading
 
 
@@ -446,7 +447,9 @@ def _predict_proba(self, X, indices=None, impute_missing=None):
         Parallel(
             n_jobs=n_jobs,
             verbose=self.verbose,
-            **_joblib_parallel_args(require="sharedmem")
+            # new version of joblib no longer uses **_joblib_parallel_args
+            # **_joblib_parallel_args(require="sharedmem")
+            require="sharedmem"
         )(
             delayed(_accumulate_prediction)(tree, X, posteriors, lock, idx)
             for tree, idx in zip(self.estimators_, indices)
diff --git a/honest_forests/estimators/tests/__init__.py b/honest_forests/estimators/tests/__init__.py
index e69de29..8b13789 100644
--- a/honest_forests/estimators/tests/__init__.py
+++ b/honest_forests/estimators/tests/__init__.py
@@ -0,0 +1 @@
+
diff --git a/honest_forests/estimators/tests/isotonic_calibration_test.ipynb b/honest_forests/estimators/tests/isotonic_calibration_test.ipynb
new file mode 100644
index 0000000..783c536
--- /dev/null
+++ b/honest_forests/estimators/tests/isotonic_calibration_test.ipynb
@@ -0,0 +1,540 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "e5686827",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "import os"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "9c65cb44",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "module_path = '/Users/audreina17/Desktop/honest-forests/honest_forests/estimators'\n",
+    "if module_path not in sys.path:\n",
+    "    sys.path.append(module_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "e44aaaac",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from sklearn import datasets\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "from sklearn.calibration import CalibratedClassifierCV, calibration_curve\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.metrics import brier_score_loss, precision_score, recall_score, f1_score\n",
+    "\n",
+    "from adapted_forest import HonestForestClassifier\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib import cm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "10de6b10",
+   "metadata": {},
+   "source": [
+    "## Verifying Isotonic Calib can be used with HF"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "4afba662",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_estimators = 100\n",
+    "n_jobs = -2\n",
+    "clf_cv = 5\n",
+    "max_features = 1.0\n",
+    "reps = 5\n",
+    "hfc = HonestForestClassifier(\n",
+    "            n_estimators=n_estimators // clf_cv,\n",
+    "            max_features=max_features,\n",
+    "            n_jobs=n_jobs)\n",
+    "clf = CalibratedClassifierCV(\n",
+    "            base_estimator=hfc,\n",
+    "            method=\"isotonic\",\n",
+    "            cv=clf_cv)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "a6eb344b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_samples = 60000\n",
+    "n_bins = 3  # use 3 bins for calibration_curve as we have 3 clusters here\n",
+    "\n",
+    "# Generate 3 blobs with 2 classes where the second blob contains\n",
+    "# half positive samples and half negative samples. Probability in this\n",
+    "# blob is therefore 0.5.\n",
+    "centers = [(-5, -5), (0, 0), (5, 5)]\n",
+    "X, y = datasets.make_blobs(\n",
+    "    n_samples=n_samples, centers=centers, shuffle=False, random_state=42\n",
+    ")\n",
+    "\n",
+    "y[: n_samples // 2] = 0\n",
+    "y[n_samples // 2 :] = 1\n",
+    "sample_weight = np.random.RandomState(42).rand(y.shape[0])\n",
+    "\n",
+    "# split train, test for calibration\n",
+    "X_train, X_test, y_train, y_test, sw_train, sw_test = train_test_split(\n",
+    "    X, y, sample_weight, test_size=0.9, random_state=42\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a105b3e4",
+   "metadata": {},
+   "source": [
+    "## I want to compare the performance of HF+Isotonic Calib vs just HF vs naive RF\n",
+    "### The metric used is Brier Loss, the mean squared difference between the predicted probability and the actual outcome"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "id": "3c30a200",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Brier Loss with HF + Isotonic calibration: 0.084\n"
+     ]
+    }
+   ],
+   "source": [
+    "clf = clf.fit(X_train, y_train)\n",
+    "class_one_probs = clf.predict_proba(X_test)[:, 1]\n",
+    "clf_score = brier_score_loss(y_test, class_one_probs, sample_weight=sw_test)\n",
+    "print(\"Brier Loss with HF + Isotonic calibration: %1.3f\" % clf_score)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "id": "e33076db",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Brier Loss with HF + no calibration: 0.086\n"
+     ]
+    }
+   ],
+   "source": [
+    "naive_hf = HonestForestClassifier(\n",
+    "            n_estimators=n_estimators,\n",
+    "            max_features=max_features,\n",
+    "            n_jobs=n_jobs)\n",
+    "naive_hf = naive_hf.fit(X_train, y_train)\n",
+    "class_one_probs_hf = naive_hf.predict_proba(X_test)[:, 1]\n",
+    "naive_hf_score = brier_score_loss(y_test, class_one_probs_hf, sample_weight=sw_test)\n",
+    "print(\"Brier Loss with HF + no calibration: %1.3f\" % naive_hf_score)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "id": "c054d55b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Brier Loss with naive rf: 0.099\n"
+     ]
+    }
+   ],
+   "source": [
+    "naive_rf = RandomForestClassifier(\n",
+    "            n_estimators=n_estimators,\n",
+    "            max_features=max_features,\n",
+    "            n_jobs=n_jobs)\n",
+    "naive_rf = naive_rf.fit(X_train, y_train)\n",
+    "class_one_probs_rf = naive_rf.predict_proba(X_test)[:, 1]\n",
+    "naive_rf_score = brier_score_loss(y_test, class_one_probs_rf, sample_weight=sw_test)\n",
+    "print(\"Brier Loss with naive rf: %1.3f\" % naive_rf_score)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "id": "fe89b863",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Brier Loss with HF + no calibration: 0.084\n"
+     ]
+    }
+   ],
+   "source": [
+    "naive_rf_for_calib = RandomForestClassifier(\n",
+    "            n_estimators=n_estimators // clf_cv,\n",
+    "            max_features=max_features,\n",
+    "            n_jobs=n_jobs)\n",
+    "iso_rf = CalibratedClassifierCV(\n",
+    "            base_estimator=hfc,\n",
+    "            method=\"isotonic\",\n",
+    "            cv=clf_cv)\n",
+    "iso_rf = iso_rf.fit(X_train, y_train)\n",
+    "class_one_probs_isorf = iso_rf.predict_proba(X_test)[:, 1]\n",
+    "iso_rf_score = brier_score_loss(y_test, class_one_probs_isorf, sample_weight=sw_test)\n",
+    "print(\"Brier Loss with HF + no calibration: %1.3f\" % iso_rf_score)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9d9905a",
+   "metadata": {},
+   "source": [
+    "## Seems like on small scaled toy tests, HF+Isotonic Calib slightly outperforms naive HF. \n",
+    "## However, the performance is almost idential to naive RF+Isotonic Calib.\n",
+    "### All of them outperform RF though."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d4eda774",
+   "metadata": {},
+   "source": [
+    "## Let's see how the plots look like:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "6f30d63d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def likelihood(X):\n",
+    "    lik1 = np.prod(np.exp(-0.5 * (X) ** 2), axis=1) + np.prod(\n",
+    "        np.exp(-0.5 * (X - np.asarray([5, 5])) ** 2), axis=1\n",
+    "    )\n",
+    "    lik0 = np.prod(np.exp(-0.5 * (X) ** 2), axis=1) + np.prod(\n",
+    "        np.exp(-0.5 * (X - np.asarray([-5, -5])) ** 2), axis=1\n",
+    "    )\n",
+    "    return lik1 / (lik1 + lik0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "9297ca43",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x7fca10aa2a60>"
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x216 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axes = plt.subplots(1, 2, figsize=(10, 3))\n",
+    "y_unique = np.unique(y)\n",
+    "colors = cm.rainbow(np.linspace(0.0, 1.0, y_unique.size))\n",
+    "\n",
+    "for this_y, color in zip(y_unique, colors):\n",
+    "    this_X = X_train[y_train == this_y]\n",
+    "    this_sw = sw_train[y_train == this_y]\n",
+    "    axes[0].scatter(\n",
+    "        this_X[:, 0],\n",
+    "        this_X[:, 1],\n",
+    "        s=this_sw * 50,\n",
+    "        c=color[np.newaxis, :],\n",
+    "        alpha=0.5,\n",
+    "        edgecolor=\"k\",\n",
+    "        label=\"Class %s\" % this_y,\n",
+    "    )\n",
+    "axes[0].legend(loc=\"best\")\n",
+    "axes[0].set_title(\"Data\")\n",
+    "axes[0].set_xticks([])\n",
+    "axes[0].set_yticks([])\n",
+    "\n",
+    "\n",
+    "order = np.lexsort((class_one_probs,))\n",
+    "axes[1].plot(\n",
+    "    np.linspace(0, y_test.size, 51)[1::2],\n",
+    "    class_one_probs[order].reshape(25, -1).mean(1),\n",
+    "    c=\"#ce406b\",\n",
+    "    label=\"Iso-HonestRF\",\n",
+    ")\n",
+    "\n",
+    "true_class_one_probs = likelihood(X_test)\n",
+    "true_order = np.lexsort((true_class_one_probs,))\n",
+    "axes[1].plot(\n",
+    "    np.linspace(0, y_test.size, 51)[1::2],\n",
+    "    true_class_one_probs[order].reshape(25, -1).mean(1),\n",
+    "    \"k\",\n",
+    "    linewidth=2,\n",
+    "    ls=\"--\",\n",
+    "    label=r\"Truth\",\n",
+    ")\n",
+    "\n",
+    "axes[1].set_ylim([-0.05, 1.05])\n",
+    "axes[1].set_xlabel(\"Instances sorted by true P(y=1|x)\")\n",
+    "axes[1].set_ylabel(\"P(y=1|x)\")\n",
+    "axes[1].legend(loc=\"upper left\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f7cbde40",
+   "metadata": {},
+   "source": [
+    "## Comparing with other RF family classifiers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "11671ce4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "color_dict = {\n",
+    "    \"HonestRF\": \"#F41711\",\n",
+    "    \"Iso-HonestRF\": \"#ce406b\",\n",
+    "    \"RF\": \"#1b9e77\",\n",
+    "    \"SigRF\": \"#377eb8\",\n",
+    "    \"IRF\": \"#fdae61\",\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "id": "26b856b2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "clfs = [\n",
+    "    (\n",
+    "        \"HonestRF\",\n",
+    "        HonestForestClassifier(\n",
+    "            n_estimators=n_estimators,\n",
+    "            max_features=max_features,\n",
+    "            n_jobs=n_jobs,\n",
+    "        ),\n",
+    "    ),\n",
+    "    (\n",
+    "        \"Iso-HonestRF\",\n",
+    "        CalibratedClassifierCV(\n",
+    "            base_estimator=HonestForestClassifier(\n",
+    "                n_estimators=n_estimators // clf_cv,\n",
+    "                max_features=max_features,\n",
+    "                n_jobs=n_jobs,\n",
+    "            ),\n",
+    "            method=\"isotonic\",\n",
+    "            cv=clf_cv,\n",
+    "        ),\n",
+    "    ),\n",
+    "    (\n",
+    "        \"IRF\",\n",
+    "        CalibratedClassifierCV(\n",
+    "            base_estimator=RandomForestClassifier(\n",
+    "                n_estimators=n_estimators // clf_cv,\n",
+    "                max_features=max_features,\n",
+    "                n_jobs=n_jobs,\n",
+    "            ),\n",
+    "            method=\"isotonic\",\n",
+    "            cv=clf_cv,\n",
+    "        ),\n",
+    "    ),\n",
+    "    (\n",
+    "        \"SigRF\",\n",
+    "        CalibratedClassifierCV(\n",
+    "            base_estimator=RandomForestClassifier(\n",
+    "                n_estimators=n_estimators // clf_cv,\n",
+    "                max_features=max_features,\n",
+    "                n_jobs=n_jobs,\n",
+    "            ),\n",
+    "            method=\"sigmoid\",\n",
+    "            cv=clf_cv,\n",
+    "        ),\n",
+    "    ),\n",
+    "    (\n",
+    "        \"RF\",\n",
+    "        RandomForestClassifier(\n",
+    "            n_estimators=n_estimators, n_jobs=n_jobs, max_features=max_features\n",
+    "        ),\n",
+    "    ),\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "9c4612a1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class_one_probs = {}\n",
+    "for name, clf in clfs:\n",
+    "    clf = clf.fit(X_train, y_train)\n",
+    "    class_one_probs[name] = clf.predict_proba(X_test)[:, 1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "id": "04adb61f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x7fca40e66040>"
+      ]
+     },
+     "execution_count": 53,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABG0AAAGECAYAAACMHd0qAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdd3xV9f3H8dc5d2fvPSEJG0IIeyPDgYioxVEUrbjqqK1WW+uoHfpT66paW6sCVkXEjYhsCZsAAcLKIHvvcfe95/z+OJcoEhRl6/f5ePAgufeM70ku4eR9P9/PV1JVFUEQBEEQBEEQBEEQBOHcIp/tAQiCIAiCIAiCIAiCIAjHEqGNIAiCIAiCIAiCIAjCOUiENoIgCIIgCIIgCIIgCOcgEdoIgiAIgiAIgiAIgiCcg0RoIwiCIAiCIAiCIAiCcA4SoY0gCIIgCIIgCIIgCMI5SIQ2giAIgiAIgiAIgiAI5yAR2gjCz4QkSaWSJNklSeqQJKlVkqRNkiTdJknS9/4ckCQpRZIkVZIk/ZkYqyAIgiAIgiAIgiBCG0H4ublUVdVAIBl4EngAeP3sDkkQBEEQBEEQBEHojghtBOFnSFXVNlVVPwVmAzdIktRfkqRLJEnaJUlSuyRJFZIkPfaNXdb7/m6VJKlTkqSRkiT1lCRpjSRJTZIkNUqS9LYkSSFn+loEQRAEQRAEQRB+qkRoIwg/Y6qqbgMqgbGAFbgeCAEuAW6XJGmmb9Nxvr9DVFUNUFV1MyABTwBxQB8gEXjsTI1dEARBEARBEAThp06ENoIgVANhqqquU1V1r6qqiqqqe4B3gfHH20lV1SJVVVeqqupUVbUBePa7thcEQRAEQRAEQRB+GNFUVBCEeKBZkqThaH1u+gNGwAS8f7ydJEmKAl5Eq9IJRAuBW077aAVBEARBEARBEH4mRKWNIPyMSZI0FC202QC8A3wKJKqqGgy8ijYFCkDtZvcnfI8PVFU1CPjlN7YXBEEQBEEQBEEQTpIIbQThZ0iSpCBJkqYDi4D/qaq6F61apllVVYckScOAa7+xSwOgAD2+8Vgg0InWnDgeuP/MjF4QBEEQBEEQBOHnQVLV7t5AFwThp0aSpFIgGvCgBTD7gf8Br6qq6pUk6UrgH0AY8BVQitZ4+Je+/R8HbgcMwIVAB7AQ6AUUAW8B96qqmnDmrkoQBEEQBEEQBOGnS4Q2giAIgiAIgiAIgiAI5yAxPUoQBEEQBEEQBEEQBOEcJEIbQRAEQRAEQRAEQRCEc5AIbQRBEARBEARBEARBEM5BIrQRBEEQBEEQBEEQBEE4B4nQRhAEQRAEQRAEQRAE4Ryk/yEbR0REqCkpKadpKIIgCIIgnG07duxoVFU18myPQ/iauP8SBEEQhJ++492D/aDQJiUlhdzc3FM3KkEQBEEQzimSJJWd7TEIRxP3X4IgCILw03e8ezAxPUoQBEEQBEEQBEEQBOEcJEIbQRAEQRAEQRAEQRCEc5AIbQRBEARBEARBEARBEM5BP6inTXfcbjeVlZU4HI5TMZ6fFLPZTEJCAgaD4WwPRRAEQRCEnxBx/3XuEfd9giAIwulw0qFNZWUlgYGBpKSkIEnSqRjTT4KqqjQ1NVFZWUlqaurZHo4gCIIgCD8h4v7r3CLu+wRBEITT5aSnRzkcDsLDw8UNw7dIkkR4eLh4B0wQBEEQhFNO3H+dW8R9nyAIgnC6nJKeNuKGoXvi6yIIgiAIwuki7jPOLeL7IQiCIJwOP4lGxLW1tVx99dX07NmTvn37cvHFF1NQUEBpaSn9+/c/Led0Op3Mnj2btLQ0hg8fTmlp6Wk5jyAIgiAIwrkoICDgqM/nz5/PnXfeeUbO/fzzz2Oz2bo+T0lJYcCAAQwcOJDx48dTVlbW9ZxOpyMzM7Prj7hnEwRBEM4n531oo6oql19+ORMmTKC4uJj9+/fz97//nbq6utN63tdff53Q0FCKioq49957eeCBB07r+QRBEARBEATNt0MbgLVr17Jnzx4mTJjAX//6167HLRYLeXl5XX9SUlLO8GgFQRAE4cc770ObtWvXYjAYuO2227oey8zMZOzYsUdtV1paytixY8nKyiIrK4tNmzYBUFNTw7hx48jMzKR///7k5OTg9XqZO3cu/fv3Z8CAATz33HPHnPeTTz7hhhtuAODKK69k9erVqKp6Gq9UEATh9Ovo6GDTpk2sWbWKsrIy8XNNEH4gSZLekCSpXpKk/OM8L0mS9KIkSUWSJO2RJCnrTI/xTCgrK+OCCy5g4MCBXHDBBZSXlwMwd+5c7r77bkaNGkWPHj1YsmRJ1z5PP/00Q4cOZeDAgTz66KMAWK1WLrnkEgYNGkT//v157733ePHFF6murmbixIlMnDjxmHOPHDmSqqqqM3OhgiAIgnCanfTqUT+UoigUFRVRU1NDbGwsaWlpyPKPz47y8/MZMmTI924XFRXFypUrMZvNFBYWcs0115Cbm8s777zDtGnTeOihh/B6vdhsNvLy8qiqqiI/X7vfam1tPeZ4VVVVJCYmAqDX6wkODqapqYmIiIgffS2CIAhnU0FBAR8/9xx97Hb8gU+BhKlTmXnNNedkrwZVVSkrK6Pk8GHMFgv9+vUjKCjobA9LEOYDLwELj/P8RUC6789w4F++v887drudzMzMrs+bm5uZMWMGAHfeeSfXX389N9xwA2+88QZ33303H3/8MaC9YbZhwwYOHjzIjBkzuPLKK1mxYgWFhYVs27YNVVWZMWMG69evp6Ghgbi4OD7//HMA2traCA4O5tlnn2Xt2rXd3nctX76cmTNndjvO1NRUPvroo9Py9RAEQRCE0+GMhjaKovDWG+9RkNNOGD1pZi0ZY3cw56bZJxXcnAi3282dd95JXl4eOp2OgoICAIYOHcpNN92E2+1m5syZZGZm0qNHDw4fPsxdd93FJZdcwtSpU485XnfvPp+Lv9QIgiCcCI/HwyevvMK1FgsJ0dEAjPV6eWP5cg5kZtK3b9+zPMKjeTwe3n/zTZo2bqQv0Aj8y2DgwjvuYNDgwWd7eMLPmKqq6yVJSvmOTS4DFqrajcQWSZJCJEmKVVW15see0/nwH1Dyuy3s+dHk/v0x/eWJ79zmyLSjI+bPn09ubi4Amzdv5sMPPwRgzpw5/P73v+/abubMmciyTN++fbums69YsYIVK1Yw2Pfvt7Ozk8LCQsaOHct9993HAw88wPTp04+ppP6miRMnUldXR1RUVLfTowRBEM40VVWP+3vjkd8dFUVBUZTjHkOv//pXdrfbfczxj9DpdOh0OgC8Xi8ej+e4xzQajV3nd7vdqKqKJEnIstw1tnPtd9sj13q8v3U63VHX9O2v6ZFrkmW56+t0vjijoU1RUREFOe1MSr4ZnazDq0xkTc5/KRpXREZGxo86Zr9+/Y4qrT2e5557jujoaHbv3o2iKJjNZgDGjRvH+vXr+fzzz5kzZw73338/119/Pbt37+bLL7/k5ZdfZvHixbzxxhtHHS8hIYGKigoSEhLweDy0tbURFhb2o65BEAThbCsrKyO8vZ2EpKSuxww6HUMtFg5s337OhTabN2xAWb+e21NT0flC/5E2G6+/8gopzzxDcHDwWR6hIBxXPFDxjc8rfY/96NDmfPDNm3+TydT18Tdvuv/whz9w6623HrPvjh07WLZsGX/4wx+YOnUqjzzySLfnWLt2Lf7+/sydO5dHHnmEZ5999hRfhSAIPwczLp/Ol6vXaj+fVBj7+C3ozUYAdr7yAS1FFaA9BaoKqooKxAzuxYC5lwBgrWtm4+OvH/cc2ffMJixDu+c69OFaylbndrudX1QoYx69uevz1b99Hq/T3e22GZePJ2XyMABqcg+w982lxz3/pH/c03VN259fREthRbfbxQzpzcCbLtWuqb6FTX99AyQJCeDIz3VJQpIg644rCU1LAKDwk/WUrd3x9YGO/KwH/CJCGP3wTV1PrbnvRTwO15ENj/or4/IJpEweevqu6Zvfp67/piTfpUkMueuqru9T4SfrcbZbeek3d3P57HnHHcfpcEZDm5qaGsLoiU7Wki2drCOMntTW1v7o0GbSpEn88Y9/5LXXXmPePO2Lt337dmw2G8nJyV3btbW1kZCQgCzLLFiwAK/XC2i/qMTHxzNv3jysVis7d+7k4osvxmg0csUVV9CzZ0/mzp17zHlnzJjBggULGDlyJEuWLGHSpEnnXBopCIJwomRZprv3eBRVRTrNlZA/xu5Vq7g8MrIrsAGI8POjX309+Xv3MnrMmLM4OkH4Tt3dLBzzNqwkSbcAtwAkfSNM7c73VcScDaNGjWLRokXMmTOHt99+mzHf829y2rRpPPzww1x33XUEBARQVVWFwWDA4/EQFhbGL3/5SwICApg/fz4AgYGBdHR0HDM9ymKx8PzzzzNgwAD+9Kc/iTfUBEH4QfY2VLJ02QpU19fBSESAC4NF+9Ete53HDU2MOg+Rgdpzps5vVbl86yd/sOXrbSuMKpLc/e+Reh1d2wHodDKK7uj7siN7BpjVrm2tFi+y/vjVJN+8JpMBJJ3sC6COrt4xGZRvXJML1avdLXbX8TDY7Oratlx2o7i7r/SRVe9R14SqdIU63xZg/npbq/kbxzuSF339wTHXJOvkr4MlX7CGqmI28Y1r+uY4vv5AG4561PepXHajyh6MTaXdjvV0OqOhTWxsLM2sxatM9FXaeGmmmJiYY5vInShJkvjoo4/4zW9+w5NPPonZbCYlJYXnn3/+qO3uuOMOrrjiCt5//30mTpyIv78/AOvWrePpp5/GYDAQEBDAwoULqaqq4sYbb+wqqXriiWNvhn71q18xZ84c0tLSCAsLY9GiRT/6GgRBEM62pKQk2sLCONzSQo/QUAAcHg9bnU6mDP9h7Taqqqq0kD4sjB49epyO4eK0Wgn4xrv1RwQATofjtJxTEE6RSiDxG58nANXf3khV1f8A/wHIzs4+7zqCv/jii9x00008/fTTREZG8uabb37n9lOnTuXAgQOMHDkS0JYT/9///kdRURH3338/sixjMBj417/+BcAtt9zCRRddRGxsLGvXrj3qWLGxsVxzzTW8/PLLPPzww6fnAgVB+Mlxej3c8s6LqC43caH+7NjyFZIkER4W2tXKo3PCPBRFOWYqkSxL6HS6rqlMqqrCzY+d2Jv6039zwmNcWHmC204H/vq9W33n+Y+EN0euQVVVXNc/5Jvy9fXUL1VVURQFPz9L1/U7p9yOx+Pt2leSpK78RJZljEZj13leL/v1UdOxjvc304G/ndw1dXudN//5qKrPb/7R6/Vd33vX1DtQVRVTaOwJH/tUkX7IyiDZ2dnqkbnKRxw4cIA+ffqc0P7H9rQpJmNs0BnpaXO2/JCvjyAIwtlUWlrK4mefJaWjA3/gINBv5kymzZhxwpWEuVu38tWrr5IuSZR5vfT+xS+YcolWKuxyuWhtbSUwMBCLxXJSY/1g4UJi169nVEJC12OKqvJqWRkXPvLIaQuLfg4kSdqhqmr22R7H+czX02apqqr9u3nuEuBO4GK0BsQvqqo67LuOd7L3X8KZI74vgnD++nvuFzzz75dp+e/nXJrVl0937DvbQxJ+Zo53D3ZGK21kWWbOTbMpGldEbW0tMTETT3r1KEEQBOHUSElJ4e6nnuLAgQM4HA7m9OxJVFTUCe+vKApfvvkmt0dFEWaxYHe7eXHJEoaOHs2urVvZ9sknBDiddMgyfS64gIuvuAKDwfCjxjruoouYv307VFTQPyoKq8vFV/X1BI4cSWpq6o86piCcCpIkvQtMACIkSaoEHgUMAKqqvgosQwtsigAbcOPZGakgCIJwxLa6Uv61dz3JBTW0ANljx53tIQlClzO+5Lcsy2RkZPzoHjaCIAjCj6eqKkVFRZQUFGAwmeg3cOBRwYzZbO5aveWH8nq9qA4HIb7VpywGA/6SRM7atdR9+CG3JyQQZDLh8HhYumwZn6sqM6+55kedKzIykhsefpj1X3zBxp07Mfn5MejGGxk9bpzoLyacVaqqfueL2rdq1K/P0HAEQRCE79HpdnJvzmISA0K4JzGc7TP6M+3qOWd7WILQ5YyHNoIgCMLZ4XK5eOfVV3Hu3ElfScIBLHz7bbKvvZYJU6ac9PENBgNJ2dks276doZGRHGptRU1M5MD69dwQHU2QrweNWa/n0qQknlu9GuuMGV09xn6oqKgorrzhBrjhhpMeuyAIgiAIP0+Pb/uc8o4WFve/kAEjD3GpqQd+I0ad7WEJQhcxL0kQBOFnYt2KFQTk5nJLcjJjk5OZkpzM7bGx7H77bUpLS0/JOa761a9wT53KErOZ6uHDueauu3C2tBD1rWDGpNcTiraynyAIgiAIwtmwquIA7xRs47b+4xiwPhdzNCgByd+/oyCcQaLSRhAE4WdAVVXyVq5kXmzsUdOH/I1GRhgM7Nq4kZSUlJM+j8Vi4fLrrjvqvMFxcVR1dJAQFNT1uNXlokWWCfWtVCUIgiAIgnAmNTk6uX/jB/QJjeG+rCl89fgLHE7oYMy0cRzTRV4QziJRaSMIgvAzYW9vJ9hsPubxULMZW3PzaTmnJEmMmTWLjxsbqe7oAKDZbmdJRQWDp08/6VWkBEEQBEEQfihVVXlw00e0Oe28MG42RrudD8uLuf3VTXyw49DZHp4gHOUnEdrU1tZy9dVX07NnT/r27cvFF19MQUEBpaWl9O9/enLS9evXk5WVhV6vZ8mSJaflHIIgCKeKJEnEpqdT3E04U9jZSdxpXKI2KzubkXfdxWK9nifKyviv3U7y9dczZfr003ZOQRBOv4CAgJM+Rnf3ao899hjPPPPMSR/7RPz9738/6nOdTkdmZib9+/fn0ksvpbW1tWucFouFzMzMrj8ul+uMjFEQhFPvg+JdfFG2j/uyptI3LBZvznryfW8uZY8Yc5ZHJwhHO++nR6mqyuWXX84NN9zAokWLAMjLy6Ouro7ExMTTdt6kpCTmz59/xm4qBEEQTtbYyy9n6ZNP8guDgfigIBRVJa+2lgPBwdw6fPhpPfeQoUPJys7G6XRiNBqR5Z/EewaCIJzn/v73v/PHP/6x63OLxUJeXh4AN9xwAy+//DIPPfQQAD179ux6ThCE81dVZysPb/mEYdEp3NpvLAD2L5azp0Z7Y2vIkCFnc3iCcIzz/q557dq1GAwGbrvttq7HMjMzGTt27FHblZaWMnbsWLKyssjKymLTpk0A1NTUMG7cuK53VXJycvB6vcydO5f+/fszYMAAnnvuuWPOm5KSwsCBA8UvHoIgnDf69OnDBffey2K9nufLynimvJxd6enM+cMfMBgMfPHxxzxz773847e/Zfmnn+J0Ok/p+SVJwmw2/+x+bqqqSllZGcs++oilS5ZQVFSEtuqzIPw0dHcvBfDuu+8yYMAA+vfvzwMPPPCjjp2Xl8eIESMYOHAgl19+OS0tLQBMmDCBBx54gGHDhpGRkdF1Tq/Xy/3338/QoUMZOHAg//73v487xgcffBC73U5mZibXfaMX1xEjR46kqqrqR41bEIRzk6Iq3JuzGEVVeW7sVehkGVVV2bcjlw6Hm9iIUGJiYs72MAXhKGe80kZRFIqKiqipqSE2Npa0tLSTuoHPz88/oTQ0KiqKlStXYjabKSws5JprriE3N5d33nmHadOm8dBDD+H1erHZbOTl5VFVVUV+fj5AV2msIAjC+W5gZib9Bw6kubkZo9FIUFAQqqry5vPPE75rFzfFxgKw/oMPeLekhBvuvvuoxsXCD7f6iy/Yt3gx2TodOklixWefEXfhhVx29dXiayv8JHR3L1VdXc0DDzzAjh07CA0NZerUqXz88cfMnDnzmP2Li4vJzMzs+ry2tpb77rsPgOuvv55//vOfjB8/nkceeYQ///nPPP/88wB4PB62bdvGsmXL+POf/8yqVat4/fXXCQ4OZvv27TidTkaPHs3UqVP58MMPjxnj2LFjeemll7qtnvF6vaxevZpf/epX3Y5z9OjRvPzyy6fqSygIwhnyxv5NbKo9zFOjZ5EcGA6AemA/eWjTHYcMyTqbwxOEbp3R0EZRFN574w3ac3LoCawFdowdy+ybbjrt77y63W7uvPNO8vLy0Ol0FBQUADB06FBuuukm3G43M2fOJDMzkx49enD48GHuuusuLrnkEqZOnXpaxyYIgnAmybJMRERE1+dlZWU4du9mRmpqV4hwWUoKL+/aRUVFBUlJSWdrqCesrq6O9cuXM/GSS466trOttraW3e+/zx3x8VgMBgCGeL38Z/lyiocOJS0t7SyPUPgpqHxpCfaiylN6TEtaAgl3XnlC23Z3L7VmzRomTJhAZGQkANdddx3r16/vNrT59rSjxx57DIC2tjZaW1sZP348oE1Xuuqqq7q2mzVrFqBNZSgtLQVgxYoV7Nmzp6vfYFtbG4WFhd2OsTtHKm9KS0sZMmQIU6ZMOe44BUE4vxS01vHEjuVMSezDNelDux73rF5FvmIHYIjoZyOcg85ojXpRURHtOTncnJzM5NRUbk5Opj0nh6Kioh99zH79+rFjx47v3e65554jOjqa3bt3k5ub29U8bty4caxfv574+HjmzJnDwoULCQ0NZffu3UyYMIGXX36Zm2+++UePTxAE4VzX1NREgiwfVfUhSRLxskxTU9NZHNmJKyosZN/SpZSUlJztoRyl4NAhBqhqV2ADYNDpGKzXc2jPnrM4MkE4dbq7lzreFMCtW7d2NfL99NNPT+q8JpMJ0JoHezweQJuO+M9//pO8vDzy8vIoKSlh6tSp3Y6xO0d62pSVleFyuUQ1jSD8RLi8Hu5Zvxh/vYmnRs866p7HvWoVkr9MoMUo+tkI56QzWmlTU1NDT0Dnq6rRyTI90d6JzMjI+FHHnDRpEn/84x957bXXmDdvHgDbt2/HZrORnJzctV1bWxsJCQnIssyCBQvwer2A9g5zfHw88+bNw2q1snPnTi6++GKMRiNXXHEFPXv2ZO7cuSdz2YIgCOe0mJgYNqoqiqoi+25ivIpCmaoy4jyZ1z1i5Eji4uOP+rl/LpB1OjzdPO4FdPrzfi0A4RxxohUxp0t391IPPPAA99xzD42NjYSGhvLuu+9y1113MXz48KOqVY5UyHQnODiY0NBQcnJyGDt2LG+99VZX1c3xTJs2jX/9619MmjQJg8FAQUEB8fHxNDY2HjPG66+/HoPBgNvtxvCNYPXIuV988UUuu+wybr/99pP58giCcA54Yfca9jZV8dqkXxJpCex6XG1rw1ZUwvOPD+PJ++/EdMFFZ3GUgtC9M3rHGBsby1pgoqKgk2W8ikIxMPEkfimQJImPPvqI3/zmNzz55JOYzWZSUlK65jsfcccdd3DFFVfw/vvvM3HiRPz9/QFYt24dTz/9NAaDgYCAABYuXEhVVRU33ngjiqIA8MQTTxxz3u3bt3c1xPvss8949NFH2bdv34++DkEQhLMlLi6OyFGjWPTVV4yJjERVVTY0NRE7YQKxvh435yqPx0Perl0c2rYNgObhwxmUmYneF4i4XC5qamrQ6/XExsae8SbIffv25b86HaMcDkLMZgBsbje5Xi9XDh58RsciCKdLd/dSsbGxPPHEE0ycOBFVVbn44ou57LLLfvCxFyxYwG233YbNZqNHjx68+eab37n9zTffTGlpKVlZWaiqSmRkJB9//HG3YwS45ZZbGDhwIFlZWbz99ttHHWvw4MEMGjSIRYsWHbPAhSAI54+dDeW8tGcdV6VlcVFy/6Oe8361FqVHHJIMpoxs9Ho9qqrS0OEEsWaA0I1Aix6L8cy+8Sb9kBUssrOz1dzc3KMeO3DgAH369Dmh/b/d06YYCDpDPW3Olh/y9REEQThbPB4PmzdsYN/69UiSRL9x4xg5Zgw6ne57921oaODTBQtoLC0lskcPLrvhBsLDw7vdtra2luLiYkwmEwMGDMBkMqGqKoWFhRzavRuDycSAIUOIj4//3vO63W7eeuklDLt2kR0YiArkdnSgZGdz3e23s2XDBja9/z7hDgdOVcUTE8PFN91Eenr6D/3ynJRtmzez7vXX6efxoAPyJYkh11zDxHO0X5okSTtUVc0+2+MQvnay91/CmSO+L4JwbrG5XUz79EVcXg8rZ/6GIKP5qOed9/yaCk8DCeMtmGb+C5dk4v53d7Gt+PyYHi6ceX+Y0Y/LhiSclmMf7x7sjEZEsiwz+6abKBo3jtraWibGxJz06lGCIAgC2Gw2ZFnGbDZ//8bd0Ov1jJ0wgbETJvyg/VwuF//7xz8Y29xMn4gI8g8e5H/PPsuv//znrmqXIwoKCvjk6acZ4HZTqapsTUvjpvvuY8Unn1D1xRdkGQy4FIVFH33E2FtuYdjIkd957p07dmDauZNre/TompveJyKC/23fzltmM66cHG6NjyckKgqAkpYWljz1FNf9+c/ExcX9oOs8GcNGjiS9d28OHDiA1+vlht69u5qzCoIgCIJw+vwtdxkl7Y28d+G8YwIbVVHwrFnDPyMNvPqfffzj+WGUho5kW3ETvxrfk6jgH3dPJfy0DUoKOePnPOMT6mVZJiMj40f3sBEEQTjXtba2UlVVRXh4ODFnoCfMqmXL2L5kCaokMenGGxkx5sytfNDQ0IBfQwPZiYkADI+LI7e8nMbGxmOu/cuFC7nSz4/U0FAAPiws5POlS9n37rtcHRBAWEAAkZGRDLDb+ff8+QzIzMRisRz33Ac2bmR0SMgxDZSzg4J4+p13eCI7u2tKEkBqaChjrVY2r1rFFddffyq/DN8rNDSUUaNGndFzCoIgCMLP2bqqAhYc3MK8fmMYHdvzmOeVvXtwdLjYq7bh8ih8Veamor6B+y/pwxXDzv2VM4WfD9EFURAE4RSqrKzknSeeIMlupwoYf+utZA8fftQ2qqpSUlJCaGgoob4AA8Dr9bJnzx4ObduGzmCg/8iR9O7d+6hQ4tsaGxvZ/f77/CYuDrei8PL8+QwaMuQ7w44T1d7ezsGDBwHo06cPgYGBx2xjNpvpUBRcXi9GnQ6nx4NVVbut+LG1thIVFNT1eZRez1vLljEwPx9TYCAlqop98GCSUlKIb2igvLycXr16HXd8qqJ0NU7+JqvLhdlmIzog4JjnMsLD2bJ37wldvyAIgiAI56cWp43f5bxPRkgUD2RN63Yb7+qVuJLiyNul9cUrckfwuxkZIrARzjmnJLRRVfU7f6n4ufoh/YIEQfhpyFm6lCkeD4OTkmiwWnnznXeOCW3WLF/OgXffxRYUxC1//SshISFaz6/XX8e5YQPZ/v54FIV169ZRMnMmF8+addzzeTwedKqKQadDkiQkRelqon6iVFWlqKiI9vZ20tPT8fPz4+P332fJU08R7HAQHRXFmkGDmPfooxgMBvbk5WG32Ujr1YuUlBR6X3IJb376KT1lmUJFYcDllxMSEnLMeVKzsljz1VdcnJxMm9PJDq8XW20tERYLKSEhRLpc7Dl0iMTkZDpU9XuDp4wRI9ixdy89QkO7/g9SVZV9ViumyEjcXi+Gb/XkaXc6sRyn344gCIIgCD8Nf9r8CU0OKwumzMWsN3S7jXf1SsqTI2nJcaH3D+G26cP45ZjUMzxSQfh+Jx3amM1mmpqaCA8PF8HNN6iqSlNT04/uLyEIwvnpmyG2LEnQTXjbVFNDD0WhoKODjo4OQkJCKCwspGPjRualpnZVj/T1eHjps8/IHjOGKF9flm+Ljo4m8YILeHnNGlyKgj49nflPPonb6aTn0KGMmTz5qGqe7qz98ksOvPsusZLEuogIEgYM4PC//81DXi/J4eGsbm0lf+dOFr/5Jh3FxfRzOAgAPldVki6+mOlXXsmBPn1obGxkQlQU6enprPjsM0rz8ohOT+fCyy/HZDJx6TXX8JHbzd+3bUNvMjHp1lvpfOcd9tfVUWy3EyFJoNeztboaNSWFRN+Uq+PJHjaMvTk5fHDwINlhYaiqyvbmZpyDBpHp58f23bsZlfB1ozhVVdnY1MTAq676zuOqqsqhQ4fIW78el9VKz+xshg4fjtFo/M79BEEQBEE4+z45vJtPSnbz+6yp9A/vfmEDtakJ784d/GvcDADS+gzglklndqECQThRJx3aJCQkUFlZSUNDw6kYz0+K2WwmIeH0dJYWBOHcNPrii3lvzx6KysspV1XGz5t3zDaTZ85krV5PdlJS18+I4v37GaDXHzXdx6TX0xsoLi4+bmgjSRKzfvlLqiZO5MP584k+dIgxkZGY9Hr2fvEF/87J4ZJ580hISMBgMFBbW0twcPBRjXB3fPEFN8fEEGqx8GFxMauKipjj50e810uQXs+lISHk1tez+fPPeWTAANKioylva6OjpobVb75J36ws+vXr13W8dStXUrt4MRdHRrJ92TI+d7uZNWcOFouFa2+9FWXePK0qSJIwmc0srq/nqUOHUO12ovv2JSk9nWtuvvl73wgwmUzc+LvfsX3LFlZt2gRA71mzuGzECKxWK/MrKmgoLSW4tZWa8nIOmkzEX3klQ79V+XSE3W5HlmU2rFnDwXffZbTFwvqiIl575RW+vPhiHn7mGQyG7t+tEwRBEATh7KuxtvHHzR+RFZnEHQPGH3c771dreWfwLFZUtQMwa+pYUYAgnLNOOrQxGAykpooyMkEQBIDk5GRu/tvfqKysZGR4eLdLV4eFhR3TCNccEIC1m6qcTiDueyr2JEmira0N/8JCfvGNlZT6h4fzyfLlLNq7F6vBgFOvZ2RsLI2KQtTQoVx5002YzWYCIiIoqazEoNNR7fVilCRi4uIoz8sjyLckd4vdjgHoGRpKRVsb7331FUO9XqJaWnjt2Wf5zcMPs3fXLvyDgqg4dIihQUEkBAVhdblYmJPDoFGjSE1NRZblo1YMzMzKIvaf/6S2thadTkdsbCzBwcHs3LmTstJSEpOSyMrKOm6Vi8lkYsz48YwZP/6Yx2999FFefeUVtr72GqOjowkLDiY6IeGYVa1cLhdL5s+nbPNmHG43lTU1vDh8OCa9nk+2bmW22czyrVvZs3s3Q7LFStiCcERAQACdnZ2UlpbSp08fevXqhcvlIjs7m9dffx2DwcC6deu47LLLuu4VIyIiWLVq1VkeuSAIP0WqqnLfhiW4FC/Pj/0Fell33G2XbCzmjaFXYl50LwDZ4v934RwmGhELgiB8B4/H0xUoxMTEnNC7MGFhYYSFhf2g8wwcPJg33nuPQVYrUf7+gLZEdVlAAJf16fO9+xft3ctAo/Go8S3ft48rZBlnczNGr5cNOh2X9O9PqMXC51u3siwoiEEjR5IxahTrVq/my9ZWBs+ejenQIRqKigjp04dNhYWUOxyogwaRGhaGW1HYX1dHutWKobOTITYb//joIx49cIDZiYnktrWxQ1HY2d5OJFBeWUlaUhJr/vpXrDExXHXnnccEWdHR0URHRwNaI+c/zpuHOS+PdGC908lz8fFceuutTJk+vWu776KqKhvXryfnk0/YuXYtWW43Q5xOjFFRlLS3H7P96s8/x7RhA79PSaG6ro7XysrYl5rKsIQEpg0eTEFtLZdERFCany9CG0E4jp49e5KXl4fX62XKlCksXryY6667DoCxY8eydOnSszxCQRB+6hYc3MJX1YX8feRMegRHHHe7pTsreD4gk6Guam67qy875bmMOYMrbwrCDyVCG0EQhOPYvWsXKxcsIKC9HbeqQkICl82bR1LSqV9VICIigovuvps3//1vYpua8ADNoaFcdeedJ9QbS2804vpWA+L2zk7iDQbym5sZFB5OocdDh8tFmMXCpLg4fjt/PlVffkmMXo83OJib//xnIiMjaWho4O3nniPA40EaNIjm0FD+eO+9bF65ki+/+gqPx8P2+nruMRopNBhICg5mcFkZZR4PUkcHw6xW5KAgtpSWMqV/f2ZkZqKqKpWtrbz7j39w95NPHlM54/V6+XzJEt555hkyDx1iuNFIi9vNJIOB/KIidrzyCjXbtnHFAw/Qo0ePY67f5XKxf/9+qqqqWPH++9g3bGBScDD+ra0cMJt5r6WFUEXhV1OnHrNv1YEDTA0PRyfLBJjN9JJlqpqbISGBEcnJjEhO5qvycrzf0xtIEATQ6XQMGzaMqqqqsz0UQRB+RorbGvjr9mVMiM9gTq/up0EDrNlXy98/2U9W5V4eSCojNi6IvjPuQdKbzuBoBeGHEaGNIAhCN0pLS1n94ov8MjycmKQkVFWloKmJ955+mtv+/vdul78+WQMGDiTj2WcpLS1Fp9ORkpKCXq9HVVWqqqqorq7Gz8+PXr16HdNbpf+QIXz8yScM8Xgw+6b/9IiN5b3t2+np58d+h4PWgAB0Dgfbd+2itamJsqoqfj9rFj0TE8mpqGDL2rVc+otfEBkZyV1/+QtlZWV4vV5SU1PR6/VEXnstn8kyX779NqrBwN+AyPh4rujXj+3bttF+4AD3pqRQEh4OqsplKSk8V1BATHMz4Xo9Nr0eY0QE+/btY/DgwUeNP2ftWpo//ZTk1lZusFhQXS4aXS4UvZ7RBgOFDgfjvV5WvPMOtz700FEVRU1NTSx8+mliamspLi6Gw4eZpKr0MRpxmUx0GI1kX3stN91zD0HfWHL8iODYWEqLi0kKDiY4OJgys5kwh6OrqXRtZyfbZZlfHqcXzolobW1l+8aNtNTUEJeezpBhw07JsuyCcK5xOBxs3bqVF154oeuxnJwcMjMzAbjqqqt46KGHztLoBEH4qXpw00eY9QaeGXPlcauiNxU08MgHe+grd/Lompcw3zsZjxqKSQQ2wjlOhDaCIAjd2LJyJROMRmICAgCtb0yviAj6lpWxc/t2xk+adErPp6oqDocDg8FAr169uh53OBy899prtO3YQU9ZpkVV+SI4mCvuvrur4kRVVQry8ymy2fjzli1cmpyMRa+n1mikfuxY6h0O1OJi7hw0iPJt2+hrMFCg1xNkNFK9YwedqsqqfftoqK3F5XBwwYwZhISEHFPRYjabuWruXGQ/P/w++ojJaWnoff1ptpWXY6ivp9xioXdmJitWrqShuZk4t5tQg4GsoCDsbje7CwrYu3cvgwcPRlVVqqurcTgcbPrkE26IjqZQp8OrqnjcbvoajWx2OjHLMjpVpdluZ/fmzRQXF5OWltY1rmXvvsuIpiaGJSWxqKGBYWFhrKmupqO1lYpevfjFXXcxfebMo3rpfNOUyy9nfmEhpWVluADL5ZfjkiT+WVaGGShwu4lPT2fV4sUkDRjAkGHD8PdNYTsRtbW1vPW3v5FptdLXbKYgJ4f/rlnDrx54AD8/vxM+jiAcj7LnHWirOLUHDU5EHnjtCW9eXFxMZmYmhYWFXHnllQwcOLDrOTE9ShCE06mgtY7NtYf5U/bFxPgd++YMwI6SZv7wXh49owJ54pPnUPsO4Z38A+xerefm5FzR00Y4p4nQRhAEoRtNZWUkdFOVkWAyUVxZeUrPtXfPHr5asoSOigpUvZ7e48czdeZMAgICWPree4Tn5nJ9SkrXO0dlra28949/cMf//R8BAQGUl5dz8P33eTAxkf+oKoeyswn29ydr0CDm9OuH1+tlwfPPs3j5cnp3dFBiMlFkMjE1K4ulBw9Su2wZkyMjuTk1lcPr1jH/4EHufPzxYxr2Ahw+fJjtH31EzeHDjE5JIchkQlFVzP7+hA0ezIjx48kpKSGvvp4sm40KSWJvRwfZQUFYDAZqVJVtixbRUV1NTUkJ0U4ngbLMro0bGTx4MKmJiRywWkno6KDT68Xm8bDa62VlZydqdTWBqsrzc+Yw7PrruXbePBRFoWjrVvStrazesYNWlwurzUZUaChLzGb+9PjjjBkz5jt7EYWEhHDbI49QXl6OLMukpKSg0+moqanhs8WLSd2xg1HV1fg3NnJw505e/fxzbnjwQSIijj9f/pvWfvop4x0Ohvmm1fUHPikpYdvmzUy44IIf/oIRhHPQkZ42NTU1TJgwgU8//ZQZM2ac7WEJgvAz8F5BLnpJ5sq0rG6fz69s5f53dhIXauG5i5IwPbaV9utu5uM1W1mRV8WU68tEaCOc00RoIwiC0I3w5GQqc3O7mgIfUel0Eu5bpvtU2LVjB+tfeIHLwsJITkrC4fGwcfVq3iws5Lp77qFo/XruTUw8KnRIDgmhd2kpeTt3MmbcOAwGAx5JosPlIjgwkAtnziQ2NrZre71ez02/+x3/VBS+fPttgpxOQmWZmIAASqOjGWa3c+WFF+LxeEh3udh94AAHDhxgwIABeDweNuXk8Plbb1FXXIwSHEysy0V037683NCAp76ewooKPCYTstvN0IMHWVdQwK9CQ7F1dOAnSWxuaMAeHc3b9fXkt7aSlJ9P3qFDTNbpGDJkCBHR0RicTnK++AJTdDQHVZU0WSbF6WQjsNfp5G5VRXY68Y+LI8ZqZelbb7EqLo5JF11EQUEBmW1tzPV6cbndrFRVKqKimHnppYwdO/aEvg9ms5mMjIyjHmtra0PduZNbU1O7KooywsPZWl3Nsnff5fq77jqhY1fs3cul31hiHaBvUBBb8vNBhDbCKfBDKmJOt9jYWJ588kmeeOIJEdoIgnDaubwelhTvZEpSHyIsAcc8X1jbwW//t4OwACMvXp9N4LIPcQEEetl5uBGAIUOGnNlBC8IP1H2tuCAIws/c8MmTWedyUdvZCWhTkA41NrLf35/Bp+jdGEVRWPfee1wVGUlKSAiSJGExGJicnExkWRlbNm8mVJLQyTIVbW3UW62ovmXBYw0GWmprAYiLi2PMrbeyPT2dcbfddlRgc4Rer2fA0KEY7XYej47mvpAQCgoKqHK56J2RQXNTE3vXrKFj+3Zse/fywcKFuN1u3p8/n6+eeorQLVu4pK6O0A0b2LRxI7LBQFR2NkZJ4v4hQ3hz8mRu7N+ff+7aRV5tLaUeD7sBWZYpttv5XVkZ8+vqGOn1EmW3M7ilhbjOTg5s28bKd94hqbWV/nY7B4qKGNnWRqHXy/MmEx8BV+j1FEgSq4ClLS2E+vmR5Xaz+8svaWhoQGpqIrKmhuDOTuI8Hi6129l38CCJ35ie8WPs2bCBEX5+XYHNEUNiYqjZtYtO32vj+wRHR1NvtR71WL3dTnBMzEmNTxDOVTNnzsRms5GTk3O2hyIIwk/cqoqDNDmsXJ0+9Jjnyhqt3L0wF7NBz4vXDyUyyIx39UrU6DjqnTU0tjsJDQ0lOTn5LIxcEE6cqLQRBEHoRmpqKhfcfTf/W7CAwPJyXL7Vo2bPm9dtM9sfo7m5GbmxkbhuVqPqZ7GQV1pKYVsbz+zdS6jLhV1V8Y+M5BdDhlDl8RAVF9e1/dARIxg6YsR3ni8hIYHo5GR2NjcTCJRZrSTMmsWew4dpXLGCWI+HEp2OlsBAelVU8Nmnn9K0YQO6pibim5vZ0NbGBOByRWH7ihWsWb+eFy66iIjgYAAuSE1lWFwcN65cSY6iENvRQaXbjSRJtLe3M9BqpcVXMTTTYiFaVVlWWckQf396BgaSaDLxcXMzS202sFj4xcSJfLFtG42dnfTyepkrSazweHi/qoqxffpgcDopKCigubWVjxWFj9raiNfrSTEaCTCbaTrJaWzOzk4CvrXKFYBeljEBTqeTgIBj39X7tlEzZrD0mWeYKcvEBQZyqLGRTbLMnPHjT2p8gnC2HQkuU1JSyM/P73pckiR2797d9fmECRPO9NAEQfiZWFS4nWi/IMbHpx/1eHWLnbsW5ALwzxuyiQu1oHo8eL9ai2v8pRy0HgC0KpvvmkItCOcCEdoIgiAcx6DBg+k3YAA1NTXo9XpiYmJO6X/sBoMBF6CoKvK3jmv3eNBbLHS2tHBReztjIyNZ3tjI8l27WJ6fj9KjB38JCTnmmF6vl+LiYtxuN2lpaZhMX6+I0KNHD8IvuIDi/Hysdjspgwbx64ce4s5rrmFnaysDzWby7XYcXi8h9fVU79xJltvNO1VVqDYbqsdDhSSxX1Vx1NUxNDaWtro6IoKDURSF0uJiOpqamBwezhduN9tkmXK7nQGKQqIkMUuSCNPp+D+bjf0uF0kBAQSoKqV2O+0uFzq9niCLhWaPh0CzmSv69mV9YSHrm5rordPRqqokSRJ7FIWY3r0pLy9n1T330LO9ndk6HdEmE6V6PZ8pCgkJCezdsIGDEyeSkpJyQsumf1vSwIEc3L2btLCwox6v6+zEGxpK6AkuAT5g4EC8v/kNn370ES3V1cRlZHDlVVcRIyptBEEQBOFHq7G2sa6qgF8PmIBe1nU93tjh5O6F27G7PLxy41CSI7Sp7krudmhvx5WQxN58rRJQTI0SzgcitBEEQfgOer2exMTE03Ls4OBgwvr2ZU9REZnf+AXe7fWS63IRExLCBXFxRPv58fLevRhbW/mdwcA/2tuJKivjjd/+lrv+/W9SU1MBaG9vZ8E//oF/eTkmSeJTi4U+U6YQGhJC5uDBBAcHc9N997Fv3z4A+vfvT319PX0tFiLi4znY3MwMoxGz08maPXsodTppl2X6WyxsbGzkDlVlDDBfVWmXJLxOJx63G4DKigra9+4lymDg0OHDpPTsiSUmhhFOJxfo9Wxqa2O7xcJkVaWPovC+y0WS3U6g0Yjk9ZKpKLxit5MSHs5FGRksKy3l9Y0bkWtqCAY+URSGGww0hIYybvRolldVUVlVxSSbjVGBgThdLmocDkwWC5l6Pe+Xl5Nis5H71FN8bDQy+cYbyf6BS3ZnDx/Oq59/Tkx1NYNjYtDJMvVWK0vq6hh7xx3HXY2qO5lZWWRmdd8gURAEQRCEH25J0U4UVWV2+tfT1lutLu5asJ3mThcv3pBNeszX1dHe1StBr0cx2Nkh+tkI5xER2giCIPxAbrebPbt3U5qfj19ICINHjPjRVRMXX3cd/3vySerLy8kICqLD6WSz1UrMtGkEBARQ43TSPyuLZTU1XBEcTLjRiFxczE3R0bxVU0NdXR2pqakoisLS998nvaSEC31Ldf9j3Tpyv/qKgRkZvJKYyD1PPIHD4SAyMpKoqCiMRiMulwt/g4ESo5EpXi/99HpqVJXBksTgujqeq6/nwchI6kNDKWhqor8sIwO9AgNZ6vVypa8KxdbRgb2jg+2trextbcW1Zw/xqsqtkkSmyUQQsMLh4H9mM9GShEFV+bvTSaqiEKjT8SFw2Gzm7yNHEhQby2v19YyqreWm4GDqgGKXi3VAhyRRmJ9PVUAAMR0dpCsKdR4PPYxGwv38aJYkEmWZDKuVCxMS6GMwoBiNLHr1VWITEoiPjwe0fkL79+/nYG4uOr2e/sOHk5aWdlQlVUBAANc/+CDL3nmHNXv2YAbcISGMveMOho4YgaqqeDwe9Hq9KK0WBEEQhDNIURUWFeYyMqYHKUHhAHQ63Nzz1g6qW+w8+8sh9E8IOWof7+qVSENHoPPUMjQtinZTklg1SjgviNBGEAThB3C5XCx44QUse/cywM+PNreb/y1dyrS772bAj2h8Gxsbyy2PP87WDRtYk5+POSiIUWPHEhQUxIJHHqFg1y4yAgIwm0zo9XpaXS6GpKbyksNBfVQU9/Tvz9ZNm9j44Yfs+fJLkiSJmsZGUiIj2VJQwCybjZ56PVvz8/lDRwexXi9hOh2dERH88r77SEpKokSnI9jpZER6OlaHg+qWFtINBrJiY/mspYVXysu5wGhks17PGq+XMIsFyd+fsJEjeauujstlmQ6Hg50NDWy32cgE4j0eGlWVMqC0qYn9skyZ14vTZuMmVeUaYIvHwx6DgTS9niajkUlxcex2OKhpaCArPZ0pERE0lpWR6HbTNyqKwbW1/Ke0lOGxsSzfupU8u53hksSEgACqbDaqdDrcsoxOVXED7spKWhsaaAYSIyPZuWkT8VddhaqqfPDWW7SuXk22xYJHUfhy5UpKrrqKqdOnH/X9iYqKYu5vfkNHRwdWq5W2tjZkWaagoICl//0vtoYG/KOimHXHHaSkpJz060sQBEEQhO+3pbaEso4m7s3UVmG0uzz89u2dFNd38NTVgxmSevTUZqW6CmX/Pjx3PYhfaAF/uvZCHr/s72dj6ILwg4nQRhAE4QfYsX07gXv3Mjs1tau6IqOzk7def50+//gHev33/1itr6+no6ODmJgYOjs7MZvNTL3kErjkkq5tdu3aRbzbTXiPHsyvrychOJj/O3iQMWFhZA0aRLvTydX33ENebi75b7zBtVFRTE5KYvv+/ezdsoWDioLFbme9Xk+aLGPQ66n74gumJSSQOXgw5U1NLHv7bebeey/T5szhy9xcdtjteCQJKSaG5cXFvN/QQEV7OyOMRjoliRH+/gSHh+PMyGCDzUZQeTk7yspYJ0lIOh0WnY5LZZnRXi8mVeU9YC8QAVynKBRIEjZVZSkwEvBHW2r7t9HRLG1qwmm3s62sjNG//z3WdetISkwk6RtT0xzt7Rg8Htbv2MEFbjeqquIFgl0ukCS2Op1EBQTQbLNRKkmEmUz0CQ7G7fWyuKyMhqIiAA4fPkzDmjXckpLStTLUAI+Hf37wAVkjRhAREXHM96ympoZPXnmFiPZ23C4Xq/PyuHHQIKalpXG4pYXFTz/NbU88ccqaVAuCIAiCcHzvFeYSaDBxSUp/AB77cC/5Fa389apBjMqIPGZ775pVADjDEwmLOAjRvc7oeAXhZIjQRhAE4Qco3rmT7KCgo6bDxAQEEFReTk1Nzff2v8lZs4Ztb71FR1MTBdXVDOndG8VoJHLQINKGDOHwjh14XS4yRo0ietYsvB4P10ydSnV1NUWFhTQXFZEny4waMwa/gADef/FF7o+NJcxioTQ8nMr2di4HNlut9DGbsVss/LO1FZ1eTx+nk8jDh2l0OGi1WKi2WADIzs5mU3Y2af7+5G3YwL7iYqSODlKdTgySxMSAAIyhobzhcGDS6YhITyflwAGS6uuZo9ezq6aG/7nddHi9BAMeQAVGAX8DfgFsBZplmQZFQVZVNgEJkoTJ4eCvLS1Iqsq2ujr0ksShhx7CrNMR2LcvVw8Zgk6nw+VykV9VRVVzM382GNApCrmSRBnwhdtNb48HvcFAraqy1OMh08+PddXVRJlMJJlMNHi9qLKMoijs2LqVDI/nqKW8zXo9vdECnW+HNu3t7Xz87LNc6+dHQlIS9fX19AK2HjhAdnw8PcPCSKqooLKykr59+57kK+z7eb1eJEn6QT11BEEQBOGnot3l4PPSfK5Ky8KiN3Kwuo2vDtRzy6Q0JvXrfrq6d/UqpPgE3J117LU1ows109c3xVkQznXijk8QBOEHMAcGYnW5jnpMVVVsqvq9KxQ5HA5y3n6bMXo9rfv20beyEktREbODgrCtWMHiX/+aIQcPMraigsJXX8Xr8TBj9mwURWH7ypVs/fhjduzfT4ss88HLL7P8T3/CtnkzS/fuxaMoHKqvRzGZ2KUoJAKdQKfRiL29nTkWCzadjnZFQafTsbmujrLqahwOBwcOHCB00CBe2LWLmsJCbA4HZpeLTiAfeK25mZcqKvA4HCQGBxPfowelNTVUlJTQVF7OxS4XIxWFS4HPgFbgU9/HKqADvgJ2KQrZOh3jAQdwSFVpd7tpb2oioLWVILsdk83G1ZWVzKyqYumKFTzyn/9QVlvL8u3b2WK1MiAsDLskUWI2k2kyYZcklisKj8gyi/R63GFhzLVYCHe7Uex2PqyrY0lLC9XBwfTo2ZP/vfIKOQsXsnPbNspLS1FVlbq6OjauXcvmHTs4eOAAHo/nqO9b7rZtxNfVYXI6cbvd6HQ6AnU6BisKeVVVqKpKh9eLsZvlwU8lVVX54uOP+fstt/DE7bezbdOm03o+QTgRf/vb3+jXrx8DBw4kMzOTrVu3cvPNN7N///7v3O+xxx4jPj6ezMxM+vbty7vvvtv13Ny5c0lNTSUzM5PMzExefPHF030ZgiCcRz45nIfD6+bqjKEA/G9jKf4mPb8YntTt9qrTiXf9V8iTJiO1lfCnd3YwaPLVfPDBB2dy2ILwo4loURAE4QfIHDOGZevWke50EmQyoaoqm6urCejTp9tpNd/k9XqRvF7mb9xI/9ZWRsgy9XV1vLt+Pc0eD1eqKtE6HSFBQcT6+fHyihWMmTKFBc88g27FChoPHsTkcvEuMD0wkPToaFKcTioLClgVEkJ+XR0DnU6uCwqi1uVCZzRS7HKxtKODFUVF6Dwe/urxoMvPJ8rPj/I1a5iWmEigTkd0ZCSFHg+bnU4URcGgqkwG7lFVDgAVLheelhZyc3OxmM30czjY6naTpiislWVCFQUzoACLgMnAhWjTo7YCPYDRqkq110tf4D7gH2iBzlCgErgVLWjaBjxkMOBUFHJsNm794gvCExK4dcIEFn3yCVs9HkZIEgVOJyP8/Xnf5SINuCk+nqHx8ZQYDDRWVPClw4FaX08EoEtJwRIUROtnn/HYwIH8q7aWnbm52K1Wavfupby2lr2A/p13+F9bG3N+/WsOHz7MulWr+GT+fGY0NFBbWsohWSZl0CCIjqa1pIS6+nradDrkzMyuVbxOl3379lHx4Yfcn5SEw+Ph9f/+l+SePYmOjj6t5xWE49m8eTNLly5l586dmEwmGhsbcblc/Pe//z2h/e+9917uu+8+CgsLGTJkCFdeeSUGgwGAp59+miuvvPJ0Dl8QhPPUosJceofGMDA8nspmG2v21XLtqBQCzIZut1e2bQFrJ8rQMZjLvmBncTMgVo4Szh8itBEEQfgB0tLSyJo7l1feeYd4j4c2VUWXlsbV8+Z1TZlyuVx88vbbHN6xg+i0NGbddBNBQUH4+/sTlpnJro8+4nKjEY/BQP+YGKIcDp5raCDY35/Vy5djcDoJDAykKSiIffv2UbV9O/rCQqa43cwwm3nCbsff5cJVWUmAx0Ok0ch7W7bQ0NnJYKuVfYC/yYQsSYS6XJhdLiZ5PPSWJByyzB6Ph6jOTjJVlQEWC006HR9brQSazWTJMns9HiqAeKAKCJAkrlJVPgTSVJWCrVvxpKWhBAayob2dK/V6RtrtPA60AEVACNAEmIHtaMFMEeBSVRxANJABlKP9R+QCYgE/oAEocDiok2V+kZTEh04nzvZ2mrZtY09HByO8XoJlmUOKQlVnJ9FAjSyzrrWVfK+X/IYG6u12moEoWSastZWmqiq2rVtHOhDu58elw4fz57VrSd61izi9nmVeLzE6Hbrycja89RZVlZX4lZbi3rCB0U4ne91uJlos9AwJYffOnWSMHctKVUUeNYrQ0aO5dMIEdDrdSb22bDYbTqeT0NDQbp9vbm4mVZIw6/WY9XpiJYmWlhYR2ghnTU1NDREREZhMJoCu4HrChAk888wzZGdn8/rrr/N///d/xMXFkZ6ejslk4qWXXjrqOOnp6fj5+dHS0kJUVNQZvw5BEM4f+5tr2N1YyWPDpiNJEu9sKkUnS1w9MuW4+3hWrQSjEbslgg5LB7WtNoKCgujhW21TEM51IrQRBEH4gcZMmEDWsGFUVlbi5+dHfHz8UT1u1q9aBWvWcGdiIlt272bpu+9yxdy5GI1GRkycSPl//4vD6yUhNBSj0UhoWxsdbW1sbW4mUlHoazRS6HLhUBQ2Ll3Kxp076dnRQTyQ4/Fgl2VsbjfT9HpC/fx43+UizmqlrKODoUYjhzo6CAgPxxIQwP66OvSAFdiu19PucpEB3KSqlACtdjuhkkSEqpLX2ckKIFyWsUgSLapKKhAqSRSpKo2yjFNRuFFV6ef1Eut2s8j3Z5hej+zxMBIoBdYCewAJSEObDqUDLgCSgTK0BsVBwES0gGgHWoPibUCOqmICsltacLrd9A8P50BDA/f4+5PT1sbfvF7agUBVRQImGI2stFqZ1tnJGJcLE1og1GAwMDExkQ5J4v2cHHQjR7KwrIwOVWXcr36FvH07PYxG7E4nox0OpOZmPqiooNpm47qYGAx2O30sFl52uXi3qopL9Xr0Xi9v5eUROn06N/3ud6dkPnxRUREfPPMMstPJ4KuuYvLFFx+zTWpqKu/pdCQ2NmJ3u6ny82N6XNxJn1sQfqypU6fy+OOPk5GRweTJk5k9ezbjx4/ver66upq//OUv7Ny5k8DAQCZNmsSgQYOOOc7OnTtJT08/KrC5//77+etf/wrAW2+9xYABA07/BQmCcM57rzAXo6zjip6Dae508vmuKi4aFEdEoOm4+3jXrEI3ajSOw0XsqW8CICsrS/SGE84bIrQRBEH4gVwuFzqdjoyMjG6fb62rI8PfH0mSqGhoYOV//kPJ5s2EJCczaPJkrAkJFJWWEgUoDgc7amtJDAxkUWsrkyWJcpeLFa2t3Dp+PGvz8jC6XEyTJA4BXwDBBgNOYJnHg9fhoDk0lPEpKWzIyyM/IIDgiAhCBw0iKiqKg2vXUm+1skFV6elyYfcFMS7AADQCfqpKAlqIYgX8FIUS4CPgISBOlvkUqJIkpkkSqqLQVlHBZJeLIGAJ8IXHQwRaGHM5WjBTCOgkiQZVJR4YAZjQpkJVALuA8UAUUAOsR6vKKQbGABWqSk5nJ6MjI5k2bBh/e/995losFLvdRNrtXKWqOCWJvWYzL9ntjEKr7OmQJPQ6HdGyzIzAQN5ubmZ6bCzhTicTLr+ckJAQzGYzqqqy4uBBWlpaCG1rI9vPjwCjkbyWFpqbmui0WEiSZfwNBq6wWHhVlvlDSQn+ZjOmuDj+fccd6HQ6mpubUVWVsLCwo8I7gJKSEj77739xdHQw/LLLiEtK4suFC/G6XIyfPZvMrCwAtq9axUWSRFpcHP/46KNuQ5vExESm//73bF22DL3ZzLWXXSZWqxIAeO6LAxTUdpzSY2bEBHLvRX2+c5uAgAB27NhBTk4Oa9euZfbs2Tz55JNdz2/bto3x48cTFqYtvXvVVVdRUFDw9bife47XXnuNw4cPs3z58qOOLaZHCYLwbU6vhw+KdzEtqR+hZn/+vboQl1fhutHHn56slJWhFhagu34uamkBO4sbATE1Sji/iNBGEAThBLW2trLsvfco3bYNVJWEzEwuue46wsPDj9quz9ChfLF2Le9u3050aysPDRtGn+RkSltbee3xx6lrb2d+Zye5djvtbjf5qsrwnj2pKiigzG4nQlGYYjBw8MABKlWV5KgoGisrmSjLeCWJ3orCcq+XTklisF5PhMnEwcZG0qdO5cPKSi4IDiY5MZESm423W1oYLstker2gqqhooUg9WnAyAG21JxvQBkwB+qKFH8+ihTYBHg8Oo5FwgwG3w0GYy4XF5cIsSWQC1WhBTD7wG2CgLLNLUYjX6ShWFJrRQqJ/A+lo1Tcb0BoWZwMFQC5aZ/wRwATfNoeATToddyckUFJbi97PjwWtrXgdDgaqKgGyTJskccDpZJJvP5ck0azT0TMwkDqDAbeioLjdvNXYSJFOx3vPPENSaioDL7iAsZMmofTsSe4HHxAsy9iARoeDfbLMrMBA/IOCqNLrsTid7DOb6WG3c1FQEEFBQXzS0MD9v/41JqcTc0cH4eHh+PfsyfQbbyQ5ORkAt9vN+889xywg3GJhwRtvsFRVuT0yErNezzsvv0zcE08QFRVFdEoKuRs2UNrZSXT//qiqSklJCRUVFfj5+dG/f38sFgu9e/emd+/ep+5FLQgnSafTMWHCBCZMmMCAAQNYsGBB13Oqqn7nvkd62nz44Ydcf/31FBcXf29Dd0EQfr5WlO+n1WljdkY2NqeHD7aXM653FMkR/sfd58hS3+rwMRirdrJD9LMRzkMitBEEQTgBXq+Xt557jkGVlVwVF4ckSeTu3cuCp57izr/85aiVg/r170/xlVdSW1SEJT6edVVV7LVaGd6jB+PsdgxuNxMuuIDlFguhiYnM3bsXyeXCr6iIG0NCaAHqXS6SDAZyGxvp268feR4PexsaSPJ4qPaFNztUlSa7nUE6HYeNRnr16sW8N95g64YNbDh0iCa7nWCjkWskiVBVpQkt2FgFfAiMA/yB5Wh9ZPzQpispaBUx6Wi9Zz6RZaTAQDyShM3ppJ8kaQGQb+nuALRGw4clCaNOxwceDxuBOq+XAcB0Pz822mzEACVozYmjgUuBlcBraL1wRvued6JV/cQoCgXAF7t2MUqSiDAYyLXZmAuEGI20AdWqSqokofd4cCgKMUC1ohAgywQFBdEiSexpaKC1qoosVSWjo4PekkTZO+/w9sGDXPPrX/PQli34t7byjNUKRiNyYiLJfn60Go1sCwlhUU0NVa2tXCvLeA0GDjU0MMjt5pV9+7g/IYHUwECaGhowyTKLn3qKeX/7GyEhIdhsNuSODnomJSFJErFeL1VWKz0yMihubqa5qoqcnBxmzpzJhKlT2REejq2zk3GDB/PWyy/TmZtLL7RpXmv8/bnyt7+lZ8+ep+HVLZzvvq8i5nQ5dOgQsiyTnp4OQF5eHsnJyeTn5wMwbNgw7r33XlpaWggMDOSDDz7odprTrFmzWLBgAQsWLODWW289o9cgCML5Y1FhLnH+wYyNTeP9reW02z3M+Y4qGwDv6pVIKanYO1X8Yr0cqNKqEkVoI5xPRGgjCIJwAg4dOkRgeTnjfFUUACPi4ykrKyM/P58s3zSXIwr37MHU2MiwwEDiTCaqqqr4sLycPklJlNbUsKC8nMlz53LB1Kks/MMfaN+/n1sSEthfV8em1lZUo5HRssz41FSWVFRglmXKgQMeD/6SRJKqkiDLtCsK2xwOfjlyJJ8WFbFk4UJ2rViBzW6nyetlCFBpNNLmdtMPrZqllyTxiqryTyAJrermZrTqlgIgBW2a0x60HjOSJOHw92eKJPFFczPpkkSUqlKEViHTx/dnuaryjKLQKEmEGI3M8HjYJcv4qSrT0YIYGS0cakar6KkDEnyf34QW2OwCNgF2wGm1Eg0UyjJ1djsmnY5dikJvj4c6ScIoy1QrCoMUhc3AZWg9eTbZbPTw86PJYKDGZmO0x8PVRiOyw0FTfj5jxo/n07w8GhoauPLuu6n+97+ZGxVFWFgYOWVlzM/JweTxkNTezmjgS48H2eul0mjEX5JI1elIBvqrKhanE3+Xi4pDh+jXuzc7tm7lgmnTCAoKIqh3bz7bt48wvZ6SkBAikpJ4futWagoLSTCZaF2yhPeamrhm3jyGDtWWLl31xRdYtm7llz16IPumW5W3tbHohRf4zTPPnPalxQXhRHV2dnLXXXfR2tqKXq8nLS2N//znP13TmuLj4/njH//I8OHDiYuLo2/fvgQHB3d7rEceeYRrr72WefPmnclLEAThPFHV2cr6qkLuyZyEqsK7m8sYnBxK/8SQ4+6j2u14N+agv3YOrfmHiI5Q2f/5vzio60NaWtqZG7wgnCQR2giCIJyA1tZWlPZ21pWUEGKxMDA6GlmSiFFVWpubj9rW6XRSvHEjt5hMZAYGAhBjNJLsdvNadTXuiAgmBwXRsno1naNGYerdm+0ffcQwWUYfFMSg3r3JGDCAKpuNPV9+ydVmM+EeD4WSxBZZ5hZJ4mOvl3v0etp1Og673Xy0cyeNikLGgQNMdbko83j4qKaGHIeDeKAd2InWFDhWp6MvkOfxUAtMQ5uuNApwA8+hTXUagBayWLxeXOXl6NFWfKoCrLJMql5PpMtFo+/YFuACRSHCYCBHklgrSRgNBjY4nYQAM4BaoDewGq3xsNF3zpm+5wKBa9AaFv8HGOI79kRFoRKo8nqxA5KqMspgoMztpg34F1qFUCMwy2KhUFHYY7ezob0dq8HAICBSlmlSVWJ1OrZt3EhzWxsPVVQwcNQo9pWWsnvPHmIMBtx9+1KakUHv/fvp7XDQy8+PNqORIkUh0umkVZJ4y+UizuvFWVODQadDNplwW634p6TQUF0NaGHXlF/8gjdfeIH6gwdJSk9nyIQJfFpQwPUDBjAwIwOjycTLmzZRM306cb6mwntWr2ZOTExXYAOQFBxMXFkZhYWF9OvX78e/kAXhFBoyZAibNm065vF169Z1fXzttddyyy234PF4uPzyy5k6dSoAjz322DHHOnToEADz588/XUMWBOE8tbgoFxWV2WlDWJlfS12bg99P7/ud+3g3bwS7Hd0Fk/Gu3YQUCYbYPgyMGXiGRi0Ip4YIbQRBEE5AZWkpO/LySA4IYCdQkJzMhIQEcltamPSNnjYtLS3k5OQQ7HZT7vXSz+vF4FsKOsJgwNjYiKl3b/z8/emUJGpra+HgQS7s148eHR20e730HjWKsLAwXl+4kIt1OgbHxGCtqEB1OolVVYokCYsk0eBy4Wc0UtnUxKaWFm5PSSFGUdjf3k5UWxsZDgcdQBZadUs12rSoYR4Py4FbLRZ2ShLXmc3YrVaWOp1UoVW+VANeYAtakDIMrUlxBtoUpoGKQpLbTS5ab5ytaKFMLODyernWz4+NHg+JikIPQNbpeMXrRe87LmgVPi60psUdQCfaVCurb7wBQE+03jefAWHAJLSqngrgv14vMZKE3WSi2OHgWsDPz48VJhNb7HamWyzcHxLCo+XlNOp0tBmN+IeHs6m0lChZJkKvJ+7QIbbn5XFDRgaO/v0pbWvjoN2OX1MTVklil8lEVkICF1ss7Ojs5M3iYvJdLqaFhxPc2kqKwYAMdDqd4PVS1N5OekqKdn319Sx55hkudbvpm5VFu9PJ6nffxWa10ic7G4vJhKqqmCQJj8fT9Rpy2e34dVON4CdJuFyuH/bCFYSz7LHHHmPVqlU4HA6mTp3KzJkzz/aQBEE4zyiqwuLCHYyJTSMhIJQHN2yiZ1QAo9IjvnM/7+pVYLEgZQ1Dt2KJ9mCYmGYsnH9EaCMIgvA9FEXh0Nq1XNOjB2H19QzQ63ly0yb2BwRQFxGB6z//wXTXXRzKy2P/F19Quns31tJS6mWZ1Q0NzIuLI9Zkosnlokav54Z770UG4nU6HA4H/m43A/v0YVVuLgO8XlwuF1a3m7K2NiabTKitrVgcDgJUlWBgMxBnNPKh202ax8Nyg4HxkZFkuVx82dxML1mml9uNjDbNaD3aVKQoIBFYh9aDxt9uJ8BopMxqZUhAALP8/XmzuZlS3/MdQB5agJKL1nfmCrS+N08DsqpiQ2tkDBAKDAZqFIX9HR3EG41kOp30U1XeQwt8eqOFMBa0ypog35g8vjGGAE1AL7TqoCPTtbYDY33nAIiXJCyyzBJVpafDQTSQAyRbrUheL51eLxJg8vNjTFoamysriQoOxm2zEQr0CQ5mo8fD7KAg3mxpYfX+/UxoaiLebGZ9eTn39e1Lj6AgPq6poVhV6e1200eWiTcaqTQYuC89nYfz8tjg9TJGr0dSVbY6nbRHRzPbN81pw5dfMtrpZGhCAgD+RiNX+/uTW13Nm0VFTI2KotRqxZuW1lVlA5CalcXezZsZ4dsPwOHxUARM9AVCgnC+eOaZZ872EARBOM9tqjlMRWcLDwyZxubCRorrO3l01oBjVmz8JlVV8a5agW70WOxl9fhFefjlC1uoePZCnnvuObKzs8/gFQjCyRGhjSAIwvdQFAU8HoYOG0ZVWRkb16+nQ1EYkpnJg/3702Sz8cQDDzA0MJB+Lhf9VJVMPz9kVeVzr5ePvV5mhIfjDQoiOCiIYcOG8fnixRxet476ykp25uWRazTSbjKx0mRitNWK6nZjS0qiva0Ne0cHGI0oHg9NioLVd/xwWeZTj4cpQ4agNjWRZjBQ0NTEKrudSlWlAq2hsAOtisWLVq1iQeslswtoURQWyTIVLS3EAS5ZZrokUa/TYfN6mer18iVa4FIG7EZrWnwZWv+ZDcCTwBNoq1LZ0QKYUkUh3OEgGK3xcG8gDjjsO38G2tSrpWhh0JVo05t6AxvRpmhF+R4rRvvPagxalU8KkBYUhFuSWNLaih240Hf8ckkiRqejn9FItdvNap2OP194IS9t3swqVaVtzx4sXi9vtrcTYzDwWW0tDS4XvzcY6Ak06fXkGwx42ttp1OkIMpn4qqSECkWhTlFY5fVi9PNje3s783r25N3Dh1nqclGrKJSEh/PhE08QEBAAQOW+fYzzLXV8hF6WGZOUROeYMeS5XARHRzP3wgvR67/+73jC9OkszMvDVVFB77AwWh0O1rW1MfCKKwgNDUUQBEEQfk7eLdxOsNHChUn9uHfhLqKDzUzpH/Od+6iHi1HLStHd9mta9xYRFqOQc6CWyvoD+Psff7UpQTgXidBGEAThe+j1ejLGjuWzdesYEBBAmcnEwNRUZg8ciF6WiQsMxFhcTL/Ro9lQVsYvg4IwGgy0V1czQFF4z+nEER/PRo+Hi2+5hU1ffYWyejX9XS6qa2q4JDCQ0qYmFJ2OQyEhRIwYwZybbiJn9Wq2/u1vGJ1O9AYDLrudPJ2OAlXlRZuN/mYzvfv0YVyvXny4YweH7HbiFYVYh4NWtOWz16L1qklEW4VoOVrFyiVo/WSsHg//kWWWAjZFIUuvJzE2llhZpqKsjCFAEVoT4QS0XjQetIoXB1rz4ibAgLZE95GAKBfoBxQCB4DhQClacPQLtIBF5/v6rkOb/pTlO0Y+Wr+bP6EFNv/zbVsHxPiOoSgKdXY7sWhh0hVogU+UJLHe46GXTseImBi2KArtTifVdjtby8qI6eigr6pyyOlkYmgoPWSZ14E8t5sOmw1LaChJffqwp7oaS0QEi91uIl0uDgMdOh2D4uNJcTp5s6OD7MBA0pOTOehwkBAYyKiZM4mJ+fom0q6qbM/LY2h6OhGRkV2PtwITxo8/bhPE6Ohobnz0UTauWsXiPXvwi4pi2JQpDBo06PtfrIIgCILwE9LqtLG8bB/XZAylqMbKrrIWfnNhL/Q6+Tv3865eCYBu0mRcby6hOdlOZX0L/v7+ZGRknImhC8IpI0IbQRCEE3D5L3/JmrAwVuXlsTs2lmdHjEAvazcMHo8Hu9tNpL8/Qf7+NLW20isoCIPBwP6KCsr0egqHDOGyadPo0aMHz953H5eFhPDcypX0qK+nzWZjuKpS0tJCu6Lw3p/+xK6lS5k0ezZRs2fzytNP08fhQNXpMDgc/EJV2SlJJFgsVNbUkNPejq2picdbWxnrdOJEC09eQ1sdyh+t4mYLWr+YMCAYraFwPVp/mu1APBDm50e0vz87SkqIRpui1IkW1CShNQjejRam1PiO8RJab5on0SpvtgG/851TDwxEq6YJAfqj9csx+sYSgxbIrEGbxgVahU028Aygoi1NXgAsAcajBUSNHR1sQAts3GgrXbUDuxWFTpeLnarKhY2NRAcE8PCqVQTa7fR0ubjcaCTZ68Xg8fC/1lauMBiQVRWLTofTYmHg4MEMi4jgt8uWkdvYiN5m4+bAQExhYTQpCrJOR67XS4LZzLChQzHq9WTKMqs7Opgwa1bX66W9vZ2aoiKchw+jr6tjzIUXYjab2VVbiy0hgR49enzn6y0iIoLLrr4arr76e16ZgiAIgvDT9VFxHk6vh6vTs3lrZQlBFj0zshK+dz/vmlVI6RlICYnQVsrOw00ADB48GJ1O9z17C8K5RYQ2giAIJ8BoNHLhzJkwcybvxMayefNmJicmopMkttXW0h4VpU196dWLzzZsoK29HYMk8anFwvWPPsrFM2ZQUVFBXV0d9Y2NvLZrF+bqaoJtNkoliTpZxurxENrRwUNmM56KCtyrVtHUrx9xAweSum8frU4ntZJEm9HIpcAyr5fx7e2Mt9kweL28pqp8KEnoJQlZUZiFNp3oKbSKmAbgIt/1fIHWYHgQWkWMB60h8Ir2dgZ2dtKqKCT59rEDs9B63JT4tr3Nd5zfoS3XnYEW1shoFTk9gH1ozYQvAN70PYdvLAfRqn8K0XrbBABtaAFPGVp1Tk+05saS7/hPolX1DPBt64cWNO1FC32GooVVLarKOK+X9fX1dNjteENDmZ2aSoLHQ5OqgtVKHVCrqrzgdhNsMDAnOprk8HCKDh6kwGCgrLiYOWFh1CgKoW1tfNHSwhSzmU3+/lhCQmjW6/msuZmU4GDqzWbG3nzzUas6eTwe4oKCiO/fnzf376e0ogKXyQQpKVxzxx3I8ne/QygIgiAIArxXmEv/sDgC1RDWH8xn7tge+Jm++1dY1WrFu2kj+pvm4SitwRLuYMeBVkBbqU4QzjcitBEEQfiBLr/+ej7V63lm0yYkRSF20CBumj2bT956i1/ExnLVhAlsLSlhb0MDwdOnExYVxZ9vv50+aE16iwsLmedwoPj6qPSUJD7weNgsSTxusVCu0xGmKARKEvvy80kIDmZwaiq5Xi+m5mYcBgND9Hpe6OggU1U5qCiYdDqMqooZ8CoK09AqbAah9YgJAy4FMtF6wiQC76P1gilGm3I0HW157ZcUBT1aE+Jg3+ORaBUx5WhTpdoAM1oVjhttSlM42rQpGa2yphkt9An0PRaKNj0rAS2cWYoWuJjQlvlOBN5Fq5iJR6uw2Y8W4vij9cIJRguOAoBo4BbgcWAy2vSoD3zX3OH1cp3Xy3+amhhstfJ+XR1+bjcRioKsqlRKEqGSRJjBQKlezwttbWQrCm6Dga02GxOioxkZGMiiujpQFCweD+FWKy5VRQkLI3jgQGb/6U+YzWbi4+MxmUyAr/8R2ipW0WPHUrZvHzfeeivJPXtisVhISEj4zsaJgnA+0el0DBgwAI/HQ2pqKm+99RYhISGUlpbSp08fevXq1bXttm3bMBqNZ3G0giCcb/KbqshvruavIy7j7Y0lGHUyVw1P+t79vBtzwOVCP3kKzXuK8I9V2LXCDojQRjg/idBGEAThe6iqCtD1y7bFYmH2r36F47rrUBQFPz8/VFXFz2LhzSVLMHZ0YI+IIGDgQJwVFXz1xBP0LCkhPSyMlMhIytvaCE9KotJqpaC1FZPXS09ZRlYUKlQVndOJta6Oum3bcERHY0tMxCrLZBgMVJpMjDYaKW9uZrAksUmWaVAUenm97JAk7kULQ4LRQpYOtBWapgHpaJUqHrTqmRBgJdCIFnisQatqOYDWD6cRrf9NENqUpny0vjQD0KZV5fu2T0VrarwOLUhp9u0TjRYGbebrcCYX+Mg3vhHAL9EaGuei9bQxoa1AFQT8FZgKzEWr4umFNr3qSLPjw3xdLWRFm5p1vW/Mr6EFRsHAcIeDareb0bKMSVEYZjJh1+l40ukk1mhkEhATFMTijg5K09LICgtDtlrpYTbTYbFQ3N6ODnhTVTF6vbQajUy++GL69u171Otk68aNrFq4EEVVsUsSAx0O/IGw8HAxf/5nRJKkC4EX0P4J/ldV1Se/9XwwWqumJLT7sGdUVX3zjA/0FLBYLOTl5QFwww038PLLL/PQQw8B0LNnz67nBEEQfox3C3Ix6fSMi+rDDe9v49KsBMICTN+7n3fVSvAPQB42AtvT8wnvq7KzuB6ArKys0z1sQTjlRGgjCIJwHE1NTaz88EMKt25F1unoN2ECU2bM6Fp1wGw2d20rSRIjx45l6MiRtLW14XK5WPjww/w6KordXi+d9fX0lSSW5OcTHBJC1qhRBCUns3z5ctxtbQQZDDRarZR7PFwcFES+qjIoNJR3a2owJiTwcl4e0R0dWBWFjWhTivqYzZS63Rz2fW5VVfRoYciraIFGPVqwIqMFOGa00CMerfrmC7TgJBmtP00tWjgS5TvOOrRAxIoW+hjRKnRWolW7BPqO1YkWomShTYvaixawKGi9dFxoVTbXASt8+/REa5K83bfPx2i9a4ajBTmXo4U+i9DCokC0BsZ90UKbJWhhURJadY7BN+7dvmvd7BvvaiDA6yXc60UBShwO+kgSkarKCEWh3WRCCg1lstHIPw8cQPb3R9erF/9qacEYGcm/3W7irFaMqkqhqjJtyhRm+HrNuN1uioqKkGWZr954g19HRtLmcPDw55/z8KxZFHd0kL9rF0OGDTvBV51wPpMkSQe8DEwBKoHtkiR9qqrq/m9s9mtgv6qql0qSFAkckiTpbVVVXWdhyKfMyJEj2bNnz9kehiAIPxF2j5uPD+/iwuR+fLGzHq+icu2olO/dT1VVvKtXohs3HgwG1LoC1D4qf7r/LnYX19G7d+/TP3hBOMVEaCMIgtANq9XK/CeeYGRrK7NiY/EoCuu//JKFhw9zy4MPHtXETlVVNuXk0DMjg5iYGMLDw9m6dSt9PB7CLBaGJybyRnk5BxobWe92MyU6Grei8FF+PvrAQKr8/EjR64lpa2N5ezvVDgfRYWFsdrkICAhA2byZUI+HAQYDJpcLm6qSC3Q6HBiBGFkmRlGIRQsuNqBNg+qPFrrIaOFHJFooMxitcmY72pSmQ2hTntajTUWKQFu9aQha498Gvq62+RKIRetxk4AW5Kzy7dsLbaUpI9pUqFi0sOZK4FO0sKgSbfWkZLTpV618Hfb0RgttaoCr0IKY/mglC51oQc9FaNOxVLQKnHvQKoaqgD5oQU4r2pQvCfgNWtiTixb25AOJqopBkpABo9tNsF5PVEMDaVFRrDYYONTWxrCwMKYOGcIHeXlMNZlwd3ZCZCS909J4Zf16Hr3lFhJTU6ltbSWpoYEqjwe7zUZQQgIBRiNKYCDvlZTQbrEwKjOT9vZ2GhsbMRqNREZGdk2nEn5yhgFFqqoeBpAkaRFwGdpMvyNUIFDSSvcC0IrTPGd6oKeS1+tl9erV/OpXv+p6rLi4mMzMTABGjx7Nyy+/fJZGJwjC+ejL8n20uRzMTB7Mk+9UMLFvDAlhft+7n3roIGpVJbp7f4e7rgWTfztIMr+68z4kvfl79xeEc5EIbQRBELqxc/t20hobGZWSAoBRp6NfaCifLV3KH/LziU9OZtCUKYwZPx5Zltm3cSMGk6lryWdZlvH6jtVgteL2eHADEUYjm6qqmFxdrR3XYKDP4MEUNjXhSUjA09ZGZGwsicHBGDo62LJqFQmKwhUuFwadjiw/P7BaGYAWUPxRlvm9qnKpLGNTFP6KFqZcghbWDEULZragVdk4ga98nx9ZxnsrWkPg3WjTk0ajBTUr0aY+RfueLwZsaAGLA+23zG1o/WYuRAuBpqD1pmlCq56ZitYHx43W52a17+Otvv3y0XrVhPuO3xutEicfLaRxogVGTb5x1Pm296I1M64HKnzj7kALiUD7z20W2rSwWrReOePRqntaAL3BgE2S2ATMMhjAauXTqip6+fnRw2bjpdWrqYiMZFdtLb8MDychPZ3Y1FQOb9nC0M5OqktLGaiq7Fu/nuFDh9IvIIDFJhMLSktRgQlz5tBvzBgCAwPZn5vL6488gq28HCMQ0KsXl9xyCxdcdJHob/PTE4/2kjyiEq147JteQssxq9Eyxdmqqionc9JHt37GvubqkznEMfqFxfHn4Zd+5zZ2u53MzExKS0sZMmQIU6ZM6XpOTI8SBOFkLCrIJSkgjJoKI1anhzljUk5oP883lvpu3VuMX6yCao4RgY1wXhOhjSAIQjfqSkrIsFi6Pi9rbWVxTg4XdXTQo0cPwjwe1s2fz6KCAq677TbmPfjgUb+A9+rVi/91dlK0ahW7iosZaTZzWVAQbbGxNCUl8ZetW5mUkUFLezvrOzowDxzIhQMGsOrNN/lq716igoMprKtjpNFImdNJsNeLx+PBYDTiRPvNMAAIMxrp6XazyOtFQqtg6YsWpsSgTX9KQgtY3kYLSlrQph5NRws/gtCmH/mjVdpc6NvPgFbF8iFa9UoaWgVNONrUo4NowVAZWlXMMLT+Mu1o055cwFq0wOUQWuXOxWhNjPejVeRkoK0ClYcWCDnRgpUq3zjfQ2ucHAPkoFUJlQGfoP22G4PWeycELZyJRQuq1qKVM6z0HXck8B++nrJ1yOkkRJLIByo8HlBVJiUmMtFgoESnY2lHByvcblrcbpqCghg3ZAg716+nn9nMe7W19C0pYX1nJ1enpvJGbi4pI0Zw04MPIvlWherVqxc6nY5Vy5ax/+23GVRdzbXh4RhUlU1FReS/9hoWf39Gjx//XS9D4fzTXQqnfuvzaWgv+UloL/eVkiTlqKraftSBJOkWtF7bJCV9f+PNs+FIT5u2tjamT5/Oyy+/zN133322hyUIwnmuvKOZDTVF3DtoMovXlJPdI4zeccEntK939Srkvv2Q4+KxvvcVMXEK/8ttxNjyDhdddBGhoaGnefSCcOqJ0EYQBKEbobGx1DqdDPR9vvbAAS6UJPDzIzQggJiAAH7h78+rW7eyc9gwWhsb6WhsJCo5mcysLDauWUOc00lwdTVz7HYUl4s3bTauv+QSYhwOUux2Xs/NpZeiYLHbKdqzh0sOHuTZ4cNp79mT1Tt3ctjrpcxoxN9qxanT4XW7qXY6WYdWiXIQWOBwUIsWcozzjXUUWqixCi2waUMLUv4rSdSqKn9Ga9YbjBacJKGFNsFogca7aEFOItq0pwFoYUgpWmCyH7gWLSjZjtZnZilalUyxb9udaJUvOWghTyxfL9V9ZCrVpWjVM21ov7kuRQttytECoiK0VaY2oU3tikbrp3MQuBstoIr2XetWtEqaz9CqhDrQwqJevm0k39doKVpQdRkwTFXZp9dT7PEwzmQi1OMhLDqa96qrSffzw6QoyJLEsgMHkDs7CZQkWsPDqQMm+/nRrKoMGT6cQ0FBJN5wA/369z/mdZS3ciXG1lamBwQQpNf+y+1tMmF0Otn2+ecitPnpqUT7p3NEAlpFzTfdCDypah3OiyRJKkH757PtmxupqvoftKyR7Ozsbwc/R/m+ipjTLTg4mBdffJHLLruM22+//ayORRCE8997hblISES44mnsKOfhy4/9/7U7ans7yrYtGG6/EwB36UF0KfD4a0spqfgPe/bsEaGNcF4SoY0gCEI3soYP57VPPiG5sZG0sDDK6uq4QJap9Penb1QUALIkEdnQwL//+Eeuio8n2WCgzOXiqYULobWVPwwaRJm/P+ru3fhbLFS3t/PvjRu51mDAZrUyrqODS71eegQF8V51NZUOB2p6OvEJCVxsNlO7bBkrW1q4xmLhoMNBsNvNV2hBxjS0ypYytKClF9pvh/vRuqCa0XrJpKMFGIuAParKx2gBzia0ipw2tBBkAFrI82u0fjgetGqaerS5HYFolT1b0KYiJaEFIM1ANlowU4lWFVODVgGzxbffXcBC3/7laAFNNNr0LH+0MgSVr1excvquq8Q3PjdaQJSCFhKl+Y4f47vO0WiBkoRWZfMuWgXPUt+4EtCqcIr4umrnMFrw1KKqvAVEmEzEW61sr63lM6+X6wwGsu12UoOCeMHp5O36etwuF4lWKzN690YJC+OapCTMBgPmkBBiY2O7fR25nU5cTifhvubVAHpJIlCW6Whq6nYf4by2HUiXJCkVLSe8Gu2l9k3lwAVAjiRJ0Wj/fA+f0VGeBoMHD2bQoEEsWrSIsWPHnu3hCIJwnvIqCu8X7WBcXBrLtjeRERvIsB7hJ7bv+nXg8aC7YAqedit6tY7mDiclFdVYLBb69OlzegcvCKeJfLYHIAiCcC4KDQ1l9oMPsioigufLy9lnt1MeGsrAUaO6mhDbbDZKCguZGR7OlKQkBsfGMjM5mT7Nzfjt348OLVApdblYUF1NakcH4TU1rGpspLizkylmMzFGIx5FIUmvJ0RVKdi9G1VVCQ8Pxz8ggGCDgXKDgTy0t9yb+Xq6kR0YA9yAFk50ogUaTrRpSv6AnyzjjxaQfIQW4tyAtqz39cAzaCFQkO85J7AHrV/OILQQ5MiUqFq0KUt7gb8Dn6NNdxqN1hR4JVqFTRBaEFSDFv7U+/bzQ6uGsaOFLZ18vTJVs+/rbkELd0ALndJ8z6Wh/Qbc5NveiBYIedH63MT6zpWFtoJUCtpUqhXAAuC/aD12vGirZu0E/iFJ7NLr6W0wEBQSwtsuF/+qrcXocnGwvZ3X3W72ejxM9vfnFn9/QiSJaGB0WxsRVVVEm0zUdXZSYbGQnp7e7euo16hRuI1G9ttsACiqSpXbTbPFQlI3lTnC+U1VVQ9wJ1rP7gPAYlVV90mSdJskSbf5NvsLMEqSpL1obZ4eUFW18eyM+OR0dnYe9flnn33GnDlzSElJIT8//yyNShCE81lOTRHV1jYGBfSirNHKnNGpJ9z/zbtmFQQFIWcPxbrvMP6xCjvLrAAMGjQIvV7UKwjnJ/HKFQRBOI7k5GTuePRRWlpaiP34YzrWr8fP7+uVCwpLSqgCbk5MPGq/1NBQim021n/xBWEeDzqrlebmZnqaTLTqdLzU0UEfvZ5dikJyYCBhMTGUVVYSaLHgamrC4XBgMJnw9OuHf0QEE3Q6thQXs6WkhCS05sAlaNOhYtDepl+DFoh8ghZqFKOFLtWKggctcJkG9EOrkhmAVpXTjFb1UsbXy31vRpu6FIjWh+Yj33nWojUazkYLVgrRpiNdhxbIhPq26fSNcRxax9VH0Xrw7Eer0umH9hutA61ayB9tGlUsWrByje/jp3xfz55oIRJoAdE+tOXD3Wgh0ya0kKbDdx19fde3C62qyOP7WhjRwqQytNCoBHApCn4mE9ubmwm127lKVZkly1R5vXiAxR0dzLZY6OdbCazUaGSXouBtbOSpVatoT0nh+ocfPu5qUFMuu4wDeXm8tHQpkzs68NPr6YyMpDosjGuvvLJrO0VROHz4MK2trcTHxx+3ckc496mqugxY9q3HXv3Gx9VoPboFQRCEb1lUsJ1Qkx8HD8jEhVqY2Df6hPbTlvpehW7CJCS9ns69hwmLVdi1XZtdOmTIkNM5bEE4rURoIwiC8B0kSSIsLIzLZs9mQVUVbxcV0dtkot3j4aP6eob17UvYNxoWA/QKD+fvbW1cotczKC4OT1AQ+UVFvNrUxBZJIjAmBo/NRrGfH69aLER6vVj69sXa3s6G9nas5eUUGY3EX3QR+sZGXnj2WUIaGkhGm6qUjFatEolWLqmiBR96tGWvC9HCis1owctKtH41EWhVMApaNcoBtIbD+9ECkFq0Rr0laFOlTL5zDEULORrRwpdwQOf7uA54C61Cpsk3hg7fMWrRKmQUtKCkGm2Kkj/aNKh1vvM40QKceLTQyA+tmqcNuN835nVoDZE9aOHLDrTmyH3QGid/ihbImHzXuhOtAXE8WsUOQA+0fjfP+64hS5bpFR7O5pYWVjidxAIXyzIRikKgLFMETDKZ6LDZqHe5aDKb+fXEiawpKmJlcTEpTU0E22ys//xz+g8YcNQy8EcEBgby4P/9H1tnzWLz2rXQ2UnPgQOZO2kS0dHajajVauWtF15ALiwkRpLIURSSJ09m5rXXIsuiIFYQBEH4eWh2WPmyfD8XxWWyc0MH913cB73uxP4fVPblo9bVortAW8XOceggpjEqO0taAcjKyjpdwxaE006ENoIgCCfA39+feQ8+yL59+yg/eBBLUBBTXS6Ujz8+Ztt2pxOd2cyXej3O9nbCDAbiIiJY6XJxhb8/V110EeWbN+NvMLBUkpg7fjwxAQEcamzkn42NDLj2WsampvLBwoXkvPkmVpuNTo+HoWgNiBPRQhIbWiizBS1cOdIfJhaYiNZc4yu0cGMSWt8XE1pgUY82tWo3WmXKf9EqcDYBM4DJvnMtQQttDGjhSbZv307f9q1oAYqKFsyY0PrJ9EALlFaihTX3ooVGn/jGPwSYgBbw2H3n74cWSIUDH6NV+6ShrSC11/fxPuBvwINoVULNaFU6rb7xXIIW9jyB1jRkAFrgNBAtHDKgrZz1JYCfH7vq6siUZZrRusDuURSCZJlosxlVVcn3ejEbDLS43Shxcbi9Xnbs30+q08kvjUaCnE4WL1lC8VVXkZGR0e1rR6fTMWrUKEaNGtXt8ys//ZTUwkKmJiUhSRKdLhfzP/uMvL59xU2mIAiC8LPxYfEu3IoXZ204IX4wfXD8Ce/r9S31rZ90AYrLjdRZDsCOg6WAqLQRzm8itBEEQThBBoOBzMxMMjMzAa1C4pXVqylqbiYtLAzQynPXV1bSJy6OX4waxa6KCg7ZbDQFBjIXSNHrCfD3x5KYCBUV9FEUdldX0xYWxrKODuY98ACDBg/my88+w7ZoEXc4nSx0OklSVSLR+sQsRQsiHEABWsXMdLSql1VoIYwZLci5Csj1fRyHFnr4o0132oUWrAT7ntOjBSUWtOqbKLQqliOrUznQghU/oAJtCpYXbYpTMFp1zwG0cCUQLXwZg1Ylk4xWcWMArkCrxGlB66MTgtaj5z20cKkAbT3kS4HX0AKhS9EaHW8AXkSb0nUYLQgyoQVSQ3yf7/Z9vwb6xip944/TN7YIWabYbqdQVZG9XqahTfn6AghTFJY6HBTLMhZJokVRKLBY6Ghu5t7Fiwl1OnFJEotsNtKdTmpsNjo7O/l08WLKdu0iJC6OcTNmkJyc/F0vpy77v/qKe2JjaXc6+WLfPkoqK+m023n1D3/gzv/7Pwb6Xm+CIAiC8FOlqiqLCnPpHRzLvt1u5k3sidl4bAXr8XhXrUAemIkUGYV1TxF+kW6c/8/efYfHUV57HP/OzPai3nuzim25926MMbYxpndCDaQHEpKQ3OQmIZUUyA0JCSSh9w62AfdeJVdZsiyr9962l5m5f8zi2GDAEDAmzOd5eLB2d2ZeSWtr9dtzzhuC2PhEovoGGTly5Ke4ep3u06WHNjqdTvcx2e12rvze93jxgQeIa2oiQRBoUhSU0lJMVivJDgcXj9E2DX/t0CGSe3oIGo3YbDZGT5hAc1wc3kOHeKmpidLsbCzp6ex64w12bdrEto0bCXd20hUOMwQcUFVi0AKJ8WhbXJvR2oOmoAUd+9GqXXLQwo0CtKqTTLSKm1K0ACQGrXLlCFrVSRAtBIlBC0ai0YKbbrRg5J3hwga04MWNVl0zB3gMbX7NFOARtJAmGy0s6UQLelLQWppa0UKTd2bREDlWjjzGjxbWxKIFQGVoQ5G/H/kcEtGqiFS0kKo18vXIRqvuqUILqOrQwiFjZJ0T0dqqJLTqpHLAq6pkh8Pkoc3QMaG1d8WizdIpAmaqKrvNZtzBINmyzEhVJUNRCKK1edlCIXrDYY5JEmuef54JXV1cmZhIZ1UVL1RUcN3Pf35as2kkgwFfOMwzu3Yx1uXiEqeTflHksCyz4b77EL/3PUaXln7oeXQ6nU6n+7w62NtK9UAns6xTCBslLpuSddrHKt1dKOVlGO/6AQDuijrsqQqm+BzKyh4hHA7rQ4h1n2v6s1en031hKYpCS0sLfr+f9PR0HA7HBz5+17ZtbHrxRa7//vdJT9dKdrOysrjjt7+ltrYWl8vF2KQkMjMzWf3GGzz74ossTUkhyW4nLIpsdbu5OtLu4nK5SE1PJ8FgYP60afTv3s30vj7CPT1s3LaNTreb7HCY2apKH1qFTCtaq9IGtOCkEC3UqOTfYc29aHNbHkULXixoFSTRaDspudFaiobQQpd6tBBjElpwsQW4Cy3wqUKrfpHRts0WgJ+hhR/9aPNv4tCCkOeB6WhtSgraD5cCtBYrM1ro885cnV2RtSmR8/SgtWWJaNVCRZFz7Yrc1ok2r2YQrZUqG22K6+ORNVjQQqxotL2U29HCnafQqn16Il+jdx7nAZaoKgNoAVhv5HPIkSRSBYGDwKKoKHZ6vYgeD7NEkV2KQgpay1UtYFFV1qkqYUlipCSx67nnmDJ7Ngk2G0l2O/1NTezcuJFLrjl5t+dgMMjK558n6PdzwdVX43A4KD3nHB77179IGxpibmwsIVmmJRxmTGEh+UYjb770EqNGjz7t3TN0Op1Op/u8ee5YOWbJQFONhcsnpRNtM532sfKbq0BVMSxdBoDncC0JE1WEpCIAPbDRfe7pz2CdTveF1NzczKt//zvmjg4cgsCrosjYpUtZtHz5+w5/9bhc+IeHCQQCJ90uSRJFRUUn3bbowgvZERPD0ytW4GpqwpaTQ7fBwDGXi8a33sIaDnM0EGBbZibZ1dVc6XCQaDRyYNcuZooiXqBAVclA+4daQqswmYfW/vQgWvBxO1qwsQatMiYJbZ7MAFp1zWVogUU+2qyaA2jtUWvQQp8otKHAHrTKFBPwcuQxrZFzh9DCjtTIMdvQKnu60apzctFCoxlolS33oAUraWjVPCVo7UudaEHRa2iVNulooVENWhDSi1bxkxZZ13y0AcN/QWub6kILgsJo25+7IutpRQuURkY+9+1obV1mtEqcssi6ZEEgpKoUoIVHJrQqI1fka5QjywgGA12CwBtDQ8xTFEqABEVhHFqIVIE2O+dltOqfZdHRRMXFURcM0lpRwduhEKNSU3ltxw7aDxxg5IQJFBcXH39eVFZWMrx6NXZZpryggHnz57Ng6VI2rFhBwrFjHBJFhoHUUaNITEwkERhqbiYQCGCxWNDpzhZ9fX0sWLAAgM7OTiRJIjExEYA9e/ZgMr3/L1yDg4M888wzfO1rXwNg06ZN/OEPf2DlypWf/sJ1Ot1ZxxcO8nr9AfJN2XhUA1fPyPlIx4dXrUDIL0AoKkZVFJTOY4iSSq8aT6Kq6m966D739NBGp9N94bhcLp7//e9ZDhRG5o74QiGef+UVtjgczFu48JTHnXP++cyYNw/ru3aLcrvdlO3cSV9rKxnFxUyYOBGTycTMuXOZOXcusiwjSRLV1dXcc911lPj92AwGjElJxIgiLYcPkz1tGl19fRx2u2nwetnr95OCVh0CWriRilZJYkGrILkKLawYQKuU6URrkcpHC3feBP6FFvjcEjk2AMyO3LYVLURJRKs0+TNaW1MmWugyBFyDVt1ybuTxr6EFIv1oVTtfRQtsCtDClxsj5ziANssmDW0b8BS0QMaMVmFTgVbVY4hcOxUYF7kvGy2ACaPN6ImLXM8ZOc8Q2g5ZP0arADqIVi0UhRYwZaLNzJkPJEkSoiBwo93OKx4PFeEwqcB6tECqCi3oiUcLmDoVBdVoZJGqMkJVcaNV8AwBE9DCq2PAkCBwodnM6NxcqgIBrGYz0y0WHj12jAGfj8zeXjKNRt588UVM115L2YYNDLS2Ijgc1AkCcU4nEyPPPbPZzMJLL0X2+0mLj6fI6Ty+hbgnGASTCaPRiE53NomPj+fAgQMA/OxnP8PhcHDXXXcdv/+D2hEGBwd58MEHj4c2Op3ui21V42FcoQDDHTEsGp1Caoz1ww+KUPv7UXZsw/j1byEIAr6GdiyxPgBmX/ZVurp7KC8vp6Cg4NNavk73qdNDG51O94Wzv7ycErf7eGADYDUaWZaayiMrVzL7nHNOuX2zIAjvCWxcLhf//OUvKezqotBqpXLjRirHjuXGO+44fo53/u92u7ls9GjOSUlBUVUa+/t5futWuvr7edXppKu/H3FoiGyvFyvaUFwrWoXJbkFgtKoyCW3no0K0uS8yWuhRgRZ6tKEFGZVo4UcmWpgjo4U9PWjBzVjgabR5NX1ooUgrWohTG3n8PLRgwxQ5R3zkfOvRwhdb5NiByH+5aOFLN1oQ0hp5rA2t2qUKLXRpQ6saynznax85vidyvWG0gGd95Joj0KqAEiPHrEKrkGlFa5nqR5tFI0b+uypyW58gkGyxMM5goNxoZEs4jCWy9t7IdZaizePpifzXCEwymXD6/URF1tUWOX9b5PvQBlxhsWCyWjkYDJIyciT5CQnUlJfjdrnYEAwSLCrCJEnMSE7mjXvuYbbZTJrDQWdHB25VZfRFFxEXF8c/7r2X/pYWRsyeTb3VyqwTAhtVVdnU3s7oxYtP+XzU6c42N954I3Fxcezfv58JEybgdDpPCnNGjx7NypUrufvuu6mrq2PcuHEsXLiQpUuXav8+XnYZhw8fZuLEiTz11FP6u+M63RfEc8fKiDdGobqdXDcz9yMdG179FsgyUqQ1yl1Rjz1VYUi2UXOsFpPJRFbW6c/H0enORnpoo9PpvnB6mpooiPxifKJ4mw2htxev14vT6Tytc5Xt3ElRVxdLcnIAKFVVHjl0iJqaGkpKSk56rNVqxSsIxETaXF6uq2O5JDGYkcHT5eXMiY5mhijSoijMRatg6UarHllmt/OmxcLv+vuxqCqpqko12tDd6WgtSOvRQodytEAiD61yRUQLObaiBSRPog0MtqK1SfnR5t4sjxxvipxjClqVSztatU0yWptSHFqosw2tAmgI7YfJIFqI8878m11o1TI5aEHQjWjhzyVoVTkVwP+g7URVg7YrVgFalY4NrcKlK3LOKyNrzEcLUI6iVfKURtYfE7l/V2T9g0CqJIHDgU8QeEFRyBAEvquqjIx8fr+KfI1KItcKAlMVhQafjw5VZXpk/eWR+9sliSi7nTlOJ0IohGXUKNIyM2mpqkIyGJi+aBHlNTVc9ZOfkJeXx9DQEI//+Md8NTWVqMjzLdXpZEQwyIMvv0xnUxP51dVcnpzMo2+/TfFFF/HQG28wVpZxSBLVskyopIQvXXghOt3nRU1NDevWrUOSJH72s5+d8jG//e1vOXz48PFKnU2bNrF//34qKytJS0tj5syZbN++nVmzZp25het0us9Ew3AvuzobSPaMYHpBIiNSTu/11zvkVSsQMjIRx4wFwHPoGKl5Kjv6tJ+7paWlH9iuqdN9HuihjU6n+8KJTk6mOxh8z+2uQICw2fyeapoP0tvcTMkJjxcEgUxBoK+v7z2PLSwsZG1qKpubmxmblETYYODNQIBRhYXI0dEcqa0lsb+fMNo/zmnAXMAqSfwzFGJ8dja9qspIn492YDgc5pJgkEy0KhoLcD9aiHIbWpjjA+5Da2tSgalolSob0QIQB1oIk8S/K1YWoM3MkdAqXJIj6x8P7ERri7oVrcKnFW0Y8H7+3X5lQAubVOBrkfsmolUHWdBm3yiRx4Yj14yKnDeEVgXkQ6uIuQgt3HkNLfx5Hi2wEYBXgbWRz2EU2mDiQORzSXM4GDlmDOmFhaxvasI2OMhyt5tYv5/9isIOtCBGjqwvADgNBqLCYYLhMIOSxGFRJB3IEUWO2WzsMhopSUriWCCALz6eL0+cSEdtLbbhYXpbWxETE5EzMykpKUEURQ4ePEhJOHw8sHmHw2RitCyzs66OLEXBZjQiAeMnTWLazJlUHDjAkMfDtBEjKCoq0qtsdKflg6pSHnroIW677TYAHn74YW6//fb3fayqqv/ROi6//PKP9ZydMmUKGRkZAIwbN47GxkY9tNHpvgCeP1aOgIDYn8j1Sz9alY3qGkbesgnDTbcc/zcwUH8M42iFfVVeACZOnPiJr1mnO9P00Ean033hTJg6lX+++iqlbjcpkR2jFFVldVsbYy+++CPtMpBRXMyRLVsYHRl0F1YUalSVpZHdpU5kNBpZeO21/Ou3v+XRHTtIHz2aomuuoW9wkAscDv52zz1kCQIlkVYeh6piEgS6gJpQiJ8B681mNrjdzE5Npby9nelGI30GA4PhME5BYHwwSCv/Hpo7ln/v2DSENpAXtDalqWgzWkahVbMcRat4aUKrQKlAa01yogUrbrSqk1Fo1TEDaAOLC9Dajc4FnkOrerGiVfPEoLV5TY9csyayhl60dqOtaOHOOy1VVWi7RzWiBVZFaIOF09EClhi0lqkioFuSmKGqZBuNDAoCI2WZNYpCR3IyEzMy6DSZ2OlysejOOznyox8hWCyYBIG3PR6+ihZSRUU+lxhRZIbDQZnHQ30ohCrLVAoCRkkiHmgSRe659FKSHQ4e6+5m1CWX8NjrrzPB4SA8YgRuu52NPh9jFi3i5cceQ1UUXIJApqK853kwPDxMW2UljQ4H/+zr4+HqapZ++cukpaUhCALzzz33A55xOt3ZzW63H/+zwWBAOeHvgN/vf9/jzCeEm5IkEQ6HP50F6nS6s0ZYkXnx2D6iQwmUpiQxISf2Ix0vr1sLweDxXaOCXf2YTAMA7KvpAPTQRvffQQ9tdDrdF05cXBxLv/UtHn/wQXL6+nACNapK0syZLL/ggo90romTJ3N4+3YeP3KEDLTgI+2888iJtEudaGhoiDf//neut9mIHj+eFT09VO7YwcRAgByTCVMwyGFBQLZYaA6HccgyL0SCoGRRxBsbS3pCArGyTKeiUJSXR19vL/1eL0WCQGcwyBG09qN5aMHIm2gVMDPRApN3KlF2orU9xQkCfkkiMRymBi14KUPbUnsDWvtUMlrlS1fkPAG03absaNUqvWiBThba8F8bWotSVuR2D1rw0oFWmTMbLcA5Fvm6zEQLb1LR2rpa0Sp8no583IS21fk7w5GnRW5PkWUcgBgIUIAWwky3WNgQDrO9q4t+r5eh5GQSGxpITk5mY0cHBpMJn9dLXWQ+0Fto1T8TRJHVPh87wmHOQauuaVRVLpZlWiSJ12SZ7s5O1ksSxVdeydLly3myp4dXN28mb9IkRowfT3xTE63PPstkmw1REFjd1cXh9nYWZGcfrzzwer0c2rKFXpeLH0+dSn5sLAe6uth46BCDg4PExn60F6w63TtOt0LmtttuO15182nLyck5viPUvn37aGhoAMDpdOJyuc7IGnQ63dlrc9sxunzDxA+M5rplOR95jlV45RsIScmIk6YA4K6ow56qoIom9lZUA3poo/vvoIc2Op3uC2nU6NHk33cf1dXV+P1+rsjKIi0t7SOfx2w2c8tdd1FdXU1fXx+LMzLIzc095QuPxsZGcj0exkcG4o1uaqKtvp4rzj8fgCV5eVT39XGp2UxyTAyVQ0PUBIOYFIUddjuV4TAFLhc/SUrixe5utogiPaEQU1SVI6rKbrS2oQvRBvaG0YKSXWjzX8agVbz0CQIuVaXTYKBJFNkT2QZbRdtBKTly7FK0uTUPRI4bhxagzOTfg3xltNk3+9Fm6mSgVdlk8u/hvQXA22iB0JfQQqNBtEqcBLSQZxFagDIDbeDwi5H7JkeOr0Cbh7M88ngP2m5O9sjjCyWJELDd72dvMMg0h4PlI0fyN6+XjrffprKiAkt/Pz5VZQBtUHMSWgvYBiDTaCRBlklTVQqBsYrCIbQQbrUk0SRJPHz0KMVFRTRVVHC4pITh7du5zGymLiaGrIICWl9+mZtzcpAiW8aPSkzkG83NPLV/P1eNG4fZYKCutpZjQ0Mk5ORQGB+PIAhMSktjsLmZ3Vu3cr4+v0b3X+TSSy/liSeeYNy4cUyePJnCwkJA23lq5syZjB49msWLF7N06dLPeKU6ne6z8GxNGUbVRIE1k7nFyR9+wAlUrxd5w3oMV1yFEPm566moJzZNxW1Jp6amBqPRyOjRoz+Npet0Z5Qe2uh0us8tVVWpr6+nr6+PmJgYCgoKECM/uE+HxWJh3Lhxn8g6FEXBOzREm6oSHx9PdHT0ex5ns9nolWVkRUESRZp6e8mMtGcBXD5lCrcePcpX+vuJBvyKQowk0W4w8KO0NNbW1/Pt4mKah4c5Pz+fmqoqbAYD5X4/JoOBSlEkIRCgDy28MaMFK4oksTwujrL+flbIMp2qSgfaoN5pGRn4rVbWVVVRpCjY0QKNAFobVBtaG5UDrXWpHa3apQstQAkA/0TbYvsIcEXkOH/k41VoLU1pwBK0ap9atGAnCW277m606p52tAqdYcCF1rpUi7b99+HI8csi16qNPGY6WsWOT5YxR67jUhRsHg+NjY2EkpJ4a+dORrvdnBepRDiINiPHazAg2WxM9PlICIVQFAUfUCcIHBIE9qgqBw0Ges1mxsfE8OXJk5mYkcHBzk7K1q/HHxdHeX8/owsLObJnD5Os1uOBDYAkinxl0iQec7vp7OwkRlXZ2djIjLw8rps06aRgrzA6mjWHD0MktPF6vZTv3k1tWRmiwUDJjBlMmDhR3/pbd1Z6v4HDVquVNWvWnPK+Z5555qSP582bd/zPf/nLXz6ppel0urPUscFu1rYcwTqczvWz8pDEj1ZlI2/aAD4vhguWHb/Nc+QYaefLyKnF7N69m4aGhpNaL3W6zys9tNHpdJ9L/f39PPPnP2NqaiJdEDikqryVlsbV3/42SUlJZ2wdw8PDPHH//UQ1NlIgigwoCn83GFj89a8z5l2BUEFBAQfOOYe/bdyIKRRim91OMTAcCGA3GjGKInGxsUwIhxkZCvGi30+p0YjZbueF4WECgQCHBgYYslgIDA5iCofJV1ViALfBQLSqckhReCoUYhIQFEXeNpkYn5KCvaeHccAraK1TI4D9gQCbGhvJiInhIouFWK+XN9ACFTdayxJoIU0iWvvSuWjbhL+zg1M/2jychWihy7rIcQVoVThzI+fajDYbx4XWjuRE260pD223KB9wLVoFTRfa0OEOtLk5dZFj3GiDiH2Rc+8BiiPHAFgFgQpVJQi8LQi81d/PEZ8PYXiY7xuN9JtMdIVCzFdVpggCjxuNTB01ip3NzTzW0cGlksT/CAK9JhN7VJVL4uMZlmWOqSrLDAaGKyp4sKqKqaNH4+nq4qu/+AVDQ0OkpaXx4r/+hXiK6iqr0cj4iRO59LbbGBwcRHj6aWY3NWF7V/gy6Pdjj4sDtG3kH7n3XrJbWpgXE4OsKJQdOMCh0lJu+Pa39V0wdDqdTve5JisKd217CUk1kBnOZ/HYj17pHF61AmJjEafP1D52eRF97QgCGJOKmJwyhsmTJ3/SS9fpPhOn/5a0TqfTnSVUVeWZBx5gakcHt2VnszQri1uzs5nf38/T992HLMtnbC2vPPEE/evWMXjsGF6/nyVZWdwcE8NbDz7I8PDwSY8VBIFLr78e58yZ7Ovuprivj76KCr76xBPc8OST/N/rr9MyOIgDyM7IwGgwEK+qXOtwMAQE58zhSauVQ+Ewa10uwhYLXzKZyBcEyj0eUv1+smSZMuAJg4GHTCaazWaOBIMYUlNJMRiYgFa5cgAtHDlfUbAMDtIvy9SgtSCNB36EtkV3OzBZEBiOPP6faAHO7WhBzSK0AGY/WqgyAy2MyYxcx4PWmtUF7EBrpSoBJqHNzRlGq+DxRc7TGjl/UuTYS9HasRLR5vMkRj72Rdb5eOS8m4AHVZVytHcjVkkSNYqC2eUiRlXZK8vsVxTqVJUqtCqkdJ+P8KFDXDQ0hCCK7IqK4oDJRIUsc8RoxCZJeIaHuSk7m3yjkaVRUdxkMvHqzp0409JwOBykp6cjCAJFkyezz+tFOWGuiKqq7B0aomj6dOx2O+np6UxfvJgtLheBE4as+sNhtnm9jJs7F4ANq1Yxqq2Ni3JzyYuNZUR8PFfn5hJTUcHuHTtO96mp0+l0Ot1Z6fHqneztacbek8/1UwsxGz/ajnNqIIC85m0MixYjRDaP8Byux54Sef0Xl/dJL1mn+0zplTY6ne5zp76+HmNDA5Oys0+6fUxyMvsaGzl69CgjR4781Nfh8XjY9uqrLB4aYo7DwcuHD5MeE0NJYiKjeno4dOAAs+bMOemY8j176H79da7p6qLYbCaYksLq2lqqjUbOmz2blN5eaisrOdLZyfV5eRQKAtUuF0WpqQw7naTKMvV1dXS53VgtFt7yetmvKMwDJisK0wWB9cA6RSFaklgK7HC5+IfLhT0UwowWmkxHa1vaqqrMURQ6QiF2CQIeVaUH+IMgEC8IGFWVQVXFhjbzJhlt2PAg2rDgnMh5lqBt1+1Ha816JfLnNLQwZgxaZcx4tHarFrRZO+7IbW1o83KsaNU4B9GqaJqAsaLIPKBfUehHG6wcz78HFveitTtNiayrE4gPBPiKIOBVVZ4D1ssyd6FVDT0LjIjMtun2+xkTFcUNJhNPhkKUZWVR1dNDtMXCs93d/CA6mhy/nxqPhx6Ph7jYWLLsdtJGjABAURS2bdvGuhde4Eh1NXuOHOGKkSNJj4qifGgI75gxTDhhCOLo0aNpvugi/vLGG5RGvqYVgsCYyy+nuLgYVVWp3LSJb6WmnvS8EQSBafHxrNy0idkntJHodDqdTvd50uoe4Dd7V+MMJjDGkc9V03M+8jnkbVvA5UJa+u85cJ7DddjTFLCn8OWv3UFCQgJ33303MTExn9zidbrPiB7a6HS6z52+vj7SBeGUw34zBIG+vr5P9frv7NLi8/kwhEJkGQwkmkwkejy4g0EAYkURz7t2R6mpqeHR3/yGosZGSu12Yq1Whvx+RprN5BkMNHi9GAIBpgUCWADz4CAD0dGMSU3l+Z4eZqemkt/fj91goFMQ2Ob1stdkQlEUMg0GjLIMJhPFfj8Gi4VBoDYYpMnvp1BVcaBVxohobUlFaFUxfYJAtqKQLAjH58+IqsqrqopfkmiXZY6iVdb0oc2gEQAvcAgtxFHRApRkYDTwKtr8mWK0napktB2j3gYeRptXk482SLgHbejwGiAObfjwZLTWqLlAlqLgFEX2iyJFisLraC1Yc9FaturRgqGVaIHUhWhtWk1os3Ca0WbvrEOr0DmENqNnJOCVZf7mdvOvcePY19lJ3I03cvm0aaz/y18IHTnC4vh4TKLIiOho9vf1EV1SwmSzGb+ioKoqv//5z+l6+mnOMxpZLIqUu1w85HJRumwZ51577Xvm0AiCwNJLLmHSzJkcra4GQeBLxcXHW/pUVSUcDGI5xbbzVqORoM/3/k9M3ReOqqofebcV3afndHfw0um+qFRV5Qc7XiUUVojrGcFPbxmDyfDRGz/kVSvA6USaM/f4be5DtSTOAo89k0cfvRdRFN933pZO93mjhzY6ne5zJzY2lkPvc1+HqjLuU3pXZXBwkLdffJFju3cjGY2MPuccorOzeevwYfYPDeGPiWFxUhIhWWbr4CCzThhG3Nvby+u//z3jjx6lub+fpvR0Yq1WjJJESBBIFAS2d3dT5PNxQBQ5VxCYZjZTOTjIep+PRlHkWpeLnGCQtIQEYiSJIy0t2KxWGoJBHMnJ1Pp8uAcGGOlw8ILXiysUIlZRKEKrhmkEctF2hgoBClpwUqYoCMBVqkqNJJFiNvOG10uGwcAcUSReEPhTOIwDLWQ5hlZhE0abaWNCa4cy8O/Wq1Foc3OOoQUmDfy7wqcObWcqqyTRJsvcg9Y+lQhcjRYkdaDNzLk2sk4ij+8CihWFSrTg5RhaaGONrOcG/r09+bOqyiWRP5dErtuNtmvVaLQWrWYgHApxzf79pDidFCUm4u7t5bzoaOozMzna20upw4FBFCmOiuJwUxM1I0YwMy+PXbt20fz009ybnIwjEsxMiosjv6+PrV1dTJw0CcMpwheA5ORkkpPfu1OGIAhklZZypKaG0nfdX9XXR+55553yfLovHovFQl9fH/GRXch0ny1VVenr68NisXzWS9Hpzlov1+1jc1sNMX0juH3WaApToz7yOdRwmPDbbyItXIQQGTIse3yEOxqQTDIHOxQURaG0tFT/+6j7r6GHNjqd7nMnPz+fN9PTOdjVxdgTfrGt7u2lOzGRkpKST/yaR44c4f677mJSRwfLMjKIz8igbMUKHMnJRIdCTI20RSmqyo/ffhs5FGL744+TlpZGXl4eLpeLqFCIMUlJBN1ujrjdlDqdWAwGfCYTB2UZr89HlCDQl5jI82431S4XvYrCBkli2rJldG7ZwpykJFRVJS06GoPfj5CYSLeqstXp5ObzzmPnypX8o6ODnHCYJarKPrRApQT4qcFARTjMVLR2pDDa3BiByPBhQaBAkuhQVfokiZusViSDASEqirFNTaxC2277YrSwR0GbJ1OPVrkjARuB6sjHlWhB0QS0Ch0X2vba89EqbZplmVq0ocVT0dqktkX+bwJ2R87tBzJUFXcoRJEgIKNtAT4lcq79aIHPC5Hjq9ECnRsi1xcEgZtVlZAg8KSqclVkLc1o1UL5gCscJtHn4+i2bUhjxlBos5FZXMyLmzcjuN1EhcP0BQKsDgRIXb6coqIifvmDH7BQko4HNgBGSWK81cru+nrq6+spLCykoaGBhro6LDYb48ePx2q1fuBzbd7FF/PiL36BsbeXwvh4VFXlYFcXu61Wblqw4PSesLr/ehkZGbS2ttLT0/NZL0UXYbFYyMjI+KyXodOdlXp8Lv5310pswRgmOUv40uzcj3UeZdcO6O/HsOSC47e59tdgS9Jmxe2t16qtJ57QmqzTfd7poY1Op/vcEUWRq7/1LZ65/372NzaSIQh0AN0JCVx9553vW93wcW1et463HniAkbW1XBUXh6u1lebmZiZNmEBdXx8F11zDmvXr2dzWRl8wiMto5L4FC9jb3c3Rigry8vLIysrCPnUqL/T0MBAfz20ZGWxrbwdVJWbMGN7q76c6EKAvGOT2hQvJiYriYGMjA34/9tJSpixZwuMbNmDr62NVZyedHg+q0cg3fT4GBgZYC1SsWUOH308oHOYHqopJFClVFIbQ5rwsliTWShKJgQD9wGq0uTLdgE8QmGUwEGUyMSTLKIoCfj/toshwOIwdrYomFhgUBO5XVVxogUoz8C+0ypoutPaqZWjByT1oQ4JL0AKWt4hst402DNiGtjNUNNqcmnloIUwuWkuVmciAYlXFDvhVlS1AVuQxcZHjt6C1b60CrgPyBQFFVYkDxqkqfxdFrolsaV4TOS4aSEerBGoD8lSVyq1b6evuxmo0cuW4cVw6Zw7P7tlDZV0dZlWlp6CAl779bURRJDA8jOMUW8ybJAljOEwoFGJvWRlb/vpXxgOdisI/c3O59e67PzC4ycnJ4ZIf/Yj1zz/Pa8eOoQDp48Zx3RVXkJCQ8GFPV90XhNFoJDf34/3So9PpdGfaT3a9gTsUIK1/LD+9ZQwG6ePthxNetRKsVqT5/34Tw1V2BEcGYLSxr7IW0EMb3X8XPbTR6XSfS0lJSXzzl7/k6NGj9PX1MS4mhpKSkk88sOnr62PPM89wTlQUWK1Emc1Emc3Eh8OUHzhAdGkpJaWlnLdkCYODg5hMJp64/37eqK+nVRRZXFjI0NAQ+8vLccbEcOFddzHY3c3W1asZkZhIWFFY29iI0+nk2xkZVB84wJu7d3PRjBlMKyriL5WVpI8cyfgJE3ht+nTue+015gYClKoq2xSFweFhEm02rrHZ6E5MpNXtJl1VGQckKwoBtKG+DWgVJZ1xcfyluxuvLGNBqzjpF0XiJIk9gkCa10ucKDLVbGa1308hEB8MMigIuFSV2wFFVTmA1uK0B62SphNYgRaYXAc0SRJHZZlYItUuaC1TccBPge1ogUkNcAVa5U0lWoUNaAODpwIvAYvRZuUMRh6zG616qB/th5gHMAgCXarKLLRwyY3WXmWOfHxIUdiJFvC8AvwErTKoP7KWfLSBwNMzMjg3N5efr1tHcVwcDoeDmKgoYp1O0oDi888/Xm49as4cdq9fz4J3zRVp8fnoy8oiIyODB3/0I25LSiLeZgPgtfp6ysvKmP2uAdXvlp+fT/6PfoTX60UURb3EW6fT6XSfW281HWZlYwVRA7l8Y/ZYcpMcH+s8qqIgv7kS6ZwFCHa7dpuqMrznCEnLRIjLZ9++RwA9tNH9d9FDG51O97klSdKnvkvU4UOHGKOqjIiL401ggaoiCQIWgwFLKMTR4WGuT0nBYDAcr4K4+Xvfo7q6mmkJCQQCAR76wQ8oDQTIMBppCAZpTkri0v/5H/r7+2lqamLUyy/z9REjMIgioxwO9u/bxy/Xr0e2WCiJi0Nev54Htm3DlJDAZOBWSSLVYCDK6+WlQIAlSUk0Dg/T2NBAtCwTB4REkYCqgqqShrZ193PBIC2KghITwxKLhf29vXwpKYl6VaWqt5ejkkRIkvAGAhwJhagFeoxGjIpCOVolDbLMK8BFaK1OI9AqdTKAc9C28O4wmwkoCm5Z5gha6JIO/A1tto4XbYBwIXAErcpFQNsF6nDkMYXABWjtTs9FjkkCxgF3A+vRWqeS0FqlZFXlKFpb1v7ILliZaG1fA0QCK7SZPHbgochaB9GGIMcDlbKM2WqlIC6Oy8eO5dd1dUS1tzMbiFVVDhcW8sAddxx/blx08cV87ZFHeLKpiQvi4zFLEjUuFy8As6+9FrvdTtjrJe6E6pgEgwGv233azz9bJOzR6XQ6ne7zaCjg44c7XsMccjA9agxXz8j52OdS9pahdnViWLLs+G2B1m7w9WC0+vE5C6iqqkKSJMaMGfMJrF6nOzvooY1Op9N9gIDXi10QyImJIS4zkyebm5lsMhFQFF7yesmfP/89rS42m40JEyYQDoe5/667uNpqJTMlBYCJwK62NravWsWXvvUt2uvqmB4ZdAuQlZNDano66199lflFRVw8ahQAfV4vd+3YwYKSEnYcOkRMMMiQqhJls2E3GIhzuRgNDJlMtAUCvCiKXC2KhEMhBlQVGagRBEpcLmoCAapjYphttRJUFDp6e/mqLFMP+EIhbECqLNMP3GazEQyFSDabqRAE3h4cxKco+NHCkGRgAVoFy1toLVdtwSAJqkotWgATiDz2CrSqFgdaiFKA1kbVATyGVvUyBy2wGY0WrpwPbEZryxoFRAkCFlUlEW2w8BD/ruQ5hhbqzDIaORAMIqHNuvGjBTzj0Vq5DIBRFGlSFOYAywGT0ci86Gi6WltZFxPDtIwM3na7uXHaNIpiY4mKiuKJtjYGBwePh3M2m417n3mGv/7qV9y5ZQtWRUHMzGTxLbew9OKLEUWR1FGj2FJVxZzMTIYDAfaFwyzKz/9Yz0WdTqfT6T5vfln2Jn1+D+kDk/jprWOQxI8/OD28aiUYjUgLFx2/zVV2hKgcGQC3I48bbrgBl8v1ofPjdLrPEz200el0ug+QmZfHDllmJnDF+PEcSEnhYHs7BoMBU1YWS5cvf99j6+vrSRweJjMr66TbJ6WmsunAATweD8ZIVcqJfD4faijE2JQUwuEwBoOBeJuNMU4njYEAxtRUWgcGqJdl8oNBtrS30+/zcYnJhCyKzDMYOBIfz0M+HwmqSqPXS5ssk6co3BgMUi3L/G1gAKKjaRoYoDAY5GnAFxlSPAatYqUMbQcmRZbxeb2MtFrZIgioaCHIIHAp2g8SEbhSENgPlKkqxaLIBEVhDFqYcgBtq+1RkoQsy/wZOBetdcmINr9mEjBaEAgLAmJk/sww2nbiIbSqnCsNBvYBz4ZCSIJAmsHAyNhYDg0NcUsgQK0o4lcUYtGGH7ejBUl1kf9S0ObffMVgQAyHuU5RqAFiLRZSoqOZHh3Ng8eOEetw4EhIQDKZiIuLQ1FVfIrCvrIy1j39NBkjR7L4kktITk7mnj//GbfbjdfrJSYmBpPpnSYvuPzLX+aFhx5iW1UVqsnEObfeSlFR0SmfL8FgEFVVMUd2w9DpdDqd7vNsW3stzx4rwzmUxXfmTiIr3v6xz6WqKvKqFUhz5iFE/XvXqeGyIySVSOBMIDl3FI888sgnsXSd7qyihzY6nU73AYqKithUWMiGujrmpKczMT2d0cnJrGttJW/8eLLeFcicKBQKcapfvyVBwKCqhMNhxkyezAtvvMEYv5/oyNySva2tNHq9tG7dSpsgEJWSQsHo0YyIj+fxpiaMXV3E+3x8TRQxhMNkmEy8oqq8Lct4ZRmH2cxNBQWEgWafj50DA9R1dDAnGGSyzUbA7ydNEGgzGukLh0lRVa4QBA4Dz6LNjbGhhSWHh4dZAsQbjWTJMvmSxM9kmUG0mTAGtCqXIIAoYlJVElSVXwFEqmLygFq0GTVzJYkoWeZNYCvaTJ2xwNeA3wFZqsp4tB2gBOCvaIFOL1qItB4oGD+eRIeDK1tbWZqQQGVdHYOqSoHFQlogwCOyTDRaBY+IVq1zDdruUhlAORAIhYgSReItFqIDAToNBs5LTsZmMKAGg2x0u7nwK19hxSOP0FBTg9toJFxYSMfbb3NpfDwbX3+dsowMpk2fDoDD4cDheG+PfnR0NF/+/vcJBAIYjUbEUwwuDofDvPnyyxxetw5kmdxp01h+3XV6a5ROp9PpPre8oSDf3fYyxrCNudETuGzK+79eOh1KxSHUlmakO7/779uCIbyVNdgmByBl7H+6ZJ3urKWHNjqdTvcBRFHk+m9/mxXPPMP9u3YRKwj0A/nz53PVlVeeNID23XJyclghSbiDQRwnVF/UDwxgzcqiv7+f/du24Y2J4YdHjjA9JgaPqrKpqYnM6GhSTSbyrVY6urrY2d/P27GxnJeYyGGrla9arch+P4OCQHkoREFUFFIgQE18POUWC9bubkqdTjb09LAyGGQoN5e1tbUM+nxUqiqG6GgMVis2VSXX5WJQVRmNFm4Y0FqTjqHtsOQEzjGZaAmF2B4KcYEk0aoouFSVXWhtTmagXJY5CFwGpCgKg4KAH/gn2u5RicCBYBADME0Q2KSqWNF2gWpGm0/zJOCJDD2+N3JbcWQdl1osPJGUxC+efpr+3l4euOEG1O5uhgMB6gwGrnI46B8e5lJZZpskscnv5xuR9RFZQxWQLIqMNBp5XZapU1VcNhtiTAytHg994TAHVJWbrr2WQxs2EB8Os93jYcYVVzB17FjKfv970pxO4np78Xk8H/jcURQFQRAQBOEDq2c2rl6Nd+VKvpOdjSQIrN2xgxWSxJW33PKB59fpdDqd7mz1+31raPMMkDE4kf+9dSzif9AWBSC/uRIkCcOiJcdv81TUY0/2IQgqQso41qxZQ2FhIdnZ2R/4+kyn+7zRQxudTqf7EA6Hg6tvu43hq65iaGiI2NjYU1ZVvJvdbmf6lVfy+BNPcI7TSZLdTsPgIJsUhby5c3ntnnuYaTBQYjJRbrfTnJTEiEmTuEhVmRQbyyu7dpEzNIQVeKu/H8OoUeSEQnRERWEPBnGmp5NjtyMCCTk5qHv2cExRcADP9fbyh9ZWjKLI9dHRDHg8PJeczIFQiNl+P4WhEIPBIE8NDdGFNpsmD62dqAToAS4EVkkSNlGkORzGD3gliamiyGB0NBsHB/mromjzZ0SRKlUlpKpYAKcgYEGrbrGiDR7ORqt8iRUEtqsq8UApMCwI2FWV7wBfBVZZLDR7vRQKAjcAGSYTLaJIrShS6naz5q23+No3v8mi73+fbf/6F4WyzM02Gw+2tuKTZcKAz2aj3+9nF9qMnBi0EKoGiLXZ2GQwIPt8PKsojLJauWjZMpp7e9nY388t3/wmJouFxMpKMltbmWCzsXnTJi65/HL2TprE3evW0ePxMOL11+lpbmbOkiWkRGYWgdYWt+mVV2iprMRosTDm3HM5Z/Hi962cqdy8mWtSUrBEdj47NzOT3+3YQfiGGz7x3dB0Op1Op/u07etp5p9V27EPp3H3/Gmkxf7n82XCq95AnD4TIT7++G3DZUeIylNQjTb81jSWLBmp7SY1PIzd/vFbsXS6s43+alCn0+lOU1RUFFEn9FGfjjkLFpCQmsru1asZ7uoiecoULjnnHF66/35uTkwkIfKLfHFCAk82NNDW2EjH4cM0mc3cMGcOHS4XQVnmIr+fqqIi2g4dwhQdTYrTiVEUaRkeJjorixGFhRzq6aHz4EESwmEuFgRaTSb2hcMUiyKy08nKwUEuSkwkq7eXgoQE3EYj/nCYjf399MgyG9AG/grATrRqG8VoZIfVSnZqKmG3m47eXpImTmTR+PFkrl1LXEcH/wyFiAqFmBMO0w7sVVX2qSpjBIE24GrgUbRWqFSDgQazmWqPhzi07chvBESTideDQcJArM+HEbhWVZkhSSSZTEwTRd4MhXjO6yXK48Hj8TBrwQIEWWb9P//J27W15IZClNjtxKWkcKSrC9FsRg2HeUCWGRQEeoEZaWn837XXUt3VxYP19bRGRREQBPpcLkhMZO5ttzFjzhw2rluH3+XCOTxMp8tFID0dg8FA0fjx9O3cyS2ZmSTb7RzduZMnysu58Wc/Iykpibq6Ol799a9ZbDZzQ2Ym3lCIrStW8Hh1Nbd+//sYjcb3PEdMViv+4eHjHwfCYSST6ZStVDqdTqfTnc2Ccpg7Nr+IFDZxbuwUlk/M+I/PqRytRj12DOPNt510+3BZFQWLVISUMVQcrkSWZUaNGqUHNrr/Onpoo9PpvjAqKyspW70a7+Ag+VOmMGv+/E/9B7sgCIwaNYpRkV2gADo6OnB6vSSc8G6RIAiMtFhY63Yz4PWSAMiKwvjUVABeamxk8syZHAqH6amt5c3ubvJVlVZRZGJ6OkFZptJoJC4mhtudTnKsVvoDAbp7e/mTy0XIYiGnoID8oSGm5eVhkiQ6AgG8osgyq5VjHg+XR0dj93g4LMsUqSpZgsAmWcZpNvP7zk7ajUaKL76YbkCy2cgeM4Y3urpIi4rCOTBAiyDwFUnibVXlyXCYaarKMWAGMNlupzc6msrEREYVFDCnsZGOjg4ODw1xRzCITVWRTSbyZZmrFIVtaC1RTbKM4PeTYLGQCdQrCkuys/nLXXcREwwyaDIx7aab8Lz4IsvS0oiPj6dyxw6meb3sdbsxRkcz22zm/1wuOnJzkWJjeai+nnq3m9nXXssNt96Kqqr4fD5sNhuSJAEwccoU9pSU8IbXi8tqZckNN6AoCltffJGbMjKOh21T09ORW1vZtmYNl1x3HRtfeomlFgsliYkAOM1mFmdn81RNDZWVlYwbN+49z5EpS5ey8oEHOF9RMEkS67q7mXjllXpoo9PpdLrPnQcObqTe1UOGaxw/vXLcJ9KmFF61AgBp8b9bo0K9g4jeFiSjjJAylr1v7AVg4sSJ//H1dLqzjR7a6HS6D9Tc3Mzm11/H73ZTOHUqc+bP/1z2Ce/ZsYM9Dz3EuU4nUWYz+198kcf27eO2H/7wlNUPnya73c6wqhKSZYyRkACgLxRi/NSp9Le20nv4MDvq61lYXEx1Xx/NSUlcMGkSEydN4vW8PB744Q+ZGggwxW7ntXXr6CoqIuvCC6m6/34cgCccpjkQ4Ctz5rAqECBm2TK2/eMfrO3spMxkQg6FkIBWVUUQBFoFAYvRiCUmBrfLxRFV5W1FwRYXx0VmM5LBwN7YWM658UbCHg9/Xb2akNNJ/wUXYO7sZPPWrZQajSyOi2O+qnJDfz89qsowsNdgID81leKcHIwGAx3HjtGhqoy56Sa6Dh2i9fBhxgUCVPX3ky4IqKqKPRjEBXQBDaEQJkWhWRAwZWfTsG0bN9hspCUn0zo8zN1PPsk9kyaRFxdHX18fznAYu9HIJFHkab+fsYEApT4fK6uryZs+nUyvl6nhMP7Nm3m4t5cbv/MdnE7nSd+j6OhovvXrX9PU1ITT6SQjI4P+/n6MLhcJsbEnPTY/JoYDR48SCoXoqK6m6F3DqQVBYJTFQsPhw6cMbSZOnox4xx2se/ttwsEgYy68kBlz5nwizzWdTqfT6c6UowNd/PngRqzuZH66YA5JUZZP5LzymysRJ09BTEk9fttweTVRuTIqIkJSKXv3PgzooY3uv5Me2uh0uvfV09PDc7/+NTPcbporG3n6X89T8Y1b+MYd3/ysl/aRKIrClhde4IakJBIjlTVpTidP1ddTVVXF2LFndseBqKgocmfNYtXmzZyfmYlZkqjp6+OgxcKXZ86kYutWEg0G6ioqWNnXx7lXXsmXrroKS2R3KWM4zN1z52KXJJq6u5EUBXd8PNfecguN+/ZxqKYGXyCAITub1Ph4jh09SsKKFYzt68PoduPy+/GYTFzjdFIH/EVRaDeZ+G4gQInRSHZKCiKQNWUKzuZmSj0eMux2Olpbue+uu/jD008zZ+FCtm/ejCAIlG/eTH5/P4ONjZRFWqS+kZuLUZa5f2iIjcEgQ6EQh9vbmS7LNBiNFEZFceC11xhRWIioqnR4PCy1WHjB7cYpy+xEG06cjrZL1SyDgWOiyPTLLkPq6iItUsmSERUFfj+yLAPa4OgwYI+Kot9kos/tpk1VaQdsioJj2zayUlPJtVqJNhppOnqUbRs3snDJEoLBIEaj8XgoabPZKCkpOf59s9vt+I1GPMEg9hMGS3e63cTk5yNJEqLRSCAcxvquINAbDmN6n5k2giAwYeJEJugvNHU6nU73OSUrCt/c9AKqLLEkfhrnj0n98INOg9LUiHK4AtPPfnHS7cNlR0guACFhBILJxt69eqWN7r+XHtrodLr3VV1dzVifD2ufh2JpNFmxBv74+Mt89ZtfO95G8nng8/lQhoZIzM4+6fZsQaCnsxPOcGgDsPzaa3nLYuH+jRsRw2GicnO54ktfIjY2FjEc5pxp0+gYHiZp1Ciu/8Y3Tjq2q7aWaQkJpDmdTI9Udfy+uRm/38/y22/nH9/7Hkl9fWQPDvI/lZWEEhP56ejRdCoKjS0tTDQYOBIOs83rZYbRyChJoujGG8nNyqJy505cZjPzL7yQZRdfzJdmz+Yo0OvzcdhgwNndzbHKSvasW0fc3r2oqkpNZyd3T5vGC4LAof5+Sq1W8i0WNrpcWOPj+fmkSYjd3fxo926MJSWkJiYi1tezUBAYkZrKr44exdnayhZgaTjMy8B4YDrazlVdwEOSxNRx47AIAmJWFrvb2hiXnMz+ri7iRo9mT3c32dHRxMTE4DOb6envp1xVkVUVGfAJAhdJEmMVhd6ODtpTUshLTSUuKoq39u7lcGYmr/7pTyQXFnLLXXed8vltNpsZt3gxr778MhdmZOA0mWgZHmZ9IMBFixYhiiIlc+awff16zj3hueYLhSiXZS6ZNOnTeTLpdDqdTvcZ+2fldqoG20h3l/K/V034xKqywyvfAEBafMHx21RZwV99GMvoMELKOLxeL5WVlYiieMqKVp3u804PbXQ63XuoqkpNTQ1HjhzBHgiQbjExGBqiO6xgirV87mZtWK1WpLg4Ot1uUiK7PqmqSr2iMCEt7TNZk9ls5qJrrmHJZZcRDAax2+3HX+AsueUWnnvoIUxJSVxx1VXvOTY+P59Nzz/P1JgYomNjcUsShoQE7HY7ufn5xMXGcqHVikFRkGSZqpYWnEYjfQYDeSkp+N1uEoaHeTIQID4tjQtGjuRoZia3fP/777nWpDlz8DQ0YDCZOCccZoXfT2ZBAS/efz83qCqpOTl4hoZ4cf9+shISCCUl0eLxUOb10gjE5uVRHQySmZZGTEkJBpOJLRUVnG82I5hM2K1WphcWsqq2FmcwyEhBoFpVyQXigdi0NEYmJWHzeKgdHmb3mjXMvfpqtiUlsa6nh+isLBL7+3l70yZaDh7kgmnT8EgST7a0sDMQYASwThSZbDJhEwQIhRipqjSFw5jMZjr9fuzx8dRXVTHG5+NwVRVer/c97VLvWLhsGRuMRh5ctQrB58Oamsp5N99MXl6edv/y5Tx27Bi9DQ2MtNnwhELsCYUYefnlZL2rbUqn0+l0uv8GTa4+frt3NRZvPL869xziHeZP7NzymysRx4xFPOHNEG9NM/YEt/ZBylgOHDiAyWSitLRUH0Ks+6+khzY6ne499u7Zw64HHyQlFOKV5mYMmZn4Y7rYHlL4yi9+SmVlJR6Ph+zs7JO2Oj5biaLI/Kuv5rkHHuAcj0ebadPfj3/kyJPaXz4LJpMJ0wmtNgAlI0dS8n//d8rHd3R0UL1zJx3NzXTU1BBUVWpTU/nuQw8hiiKBQIDkqCjGjx6N1+tlx5tv4u7oYM/69cRnZzMgSQhpaaRmZpLl9XL+hRdS1dODLSbm+DX6+vro6uoiJiYGTzDI6sFBxKEhYrxeRufm8tsvfQn/0BAvDQ8zfOQI/uRkMiSJzIEBjkkSSmoq/rY2FttsqDYbR9LTsU+eTJ7ZjGHrVsb391MpCIhTpuBwOLiitJTyujp2VVRQrqpMA606xmIhB4gxGIjp66PNYOCy2bPJrqlhrSgy+rzz2LdjB1GHD1NqsXBoYIC1a9YgWa1MiYkhzu0m6HaTriikqipOUeQFVWWSKCKEQlQ0N3MwIYHlixYRGxvLeq+XBSNGvG9gAyBJEguXLmX+okUEg0GsVutJ7yY6nU5u+9GPOHTwIEcrKrA4nSyfMoXsd1V56XQ6nU7330BVVb658UXCsspFCTM5d/Qn0xYFoLS3oewtx/jDH590u6vsCFG5CqotCdGZwowZKXR2dtLW1vaJXVunO5vooY1O9xkJBoN0d3djsVhISEj4rJdzkvqKCubYbIxJTqZVkjAuX44QDHJ7UREHy6rZ8Gg9UVIKvdIWbrprGcXFxZ/1kj/UhEmTcP74x5StW6ftHnXBBSyeNQuD4bP9Z1CWZQ4fPkwgEDitbSrfevppLlRVRl10EUf7+vCFQsS63fj9fgASEhIw5Oezpq4OoaODfq8XJS4Os8vFK5WVDHZ2UiRJVCoK1rw8grLMNp+PBXPnAlpL3Ir77iNTlmlSVWSbDXtKCnkdHUx1OrGEw4wJhfiH30+i1UocYLbZuGDOHBorKyns7eVvVVXkxcay5Nxz6Q4EODg4iDMxkVB7O8WlpXSYTIz2+WiMfE5Dg4OcGxfHpvh4VFmmbXiYGaJIvySxf2iIuGCQfeEwhqwsFhcVYTUaqS8rY9N999Hc1sYkn48b8/KIz8zk5d5edtjtHOnuZshoZJIkMU2WsYTDtITDJIsih+Li2BoMMi45meu/8x3y8/MBuPymm077+2YwGN73uWM2m5k8ZQqTp0w57fPpdDqdTvd59MzRMvb1NZLuHcnPrv5k24DlN1cBYFi67KTbXXsPkzBHQUgbd/w2p9P5uXg9qtN9HHpoo9OdYaqqsnH9Fta+sgtjIJaA4iatyMFVNy0nOTn5s14eAIUTJrBh2zaONjYyGB2NUlaGobub6pdf5kBdkCvn/5Xk6Cw6B0fzyhOv86Nffz5+SI4YMYIRI0Z81ss4yStPPol7wwaigJ1ZWdz+4x8fHzj8bsFgkI7KSsZkZSEKAqOTkgAwd3VRvW8fEyZMQJIkrr/jDjasWsX2t98mSVG4Nj2d3775JrNFketSU2nu6MAhCOzo7uZnR49y/q23kp6ezqpXXuGZ3/6WiwIBRuXlMTk1ladCIdoPHeIal4s0WWZXUxP5wSA2r5dYi4WpBgMbVJWo6Ggmzp5NMBgk2NTEGz4fb/b1saehAYOq8tA3v0mm14vkdIIs83BnJ0VxcTR2drJ982aqFYVzrVb2dHUxyWKhLRgk2e/HbzSyQZbxZmXx4/POOz7gN9lspn9wkExZZrTRiBwIUOPxMCovj5lZWXxtxQoWWa20eDx0KwoZqkqO0Yhgt3M0KorckSP5n//7PxyRdjmdTqfT6XQfTZd3mJ/uWonJH83vFi4i2mb68IM+gvCqFQiFRYgF/37tFnZ7Eb0NiKKKkDKOqqoq8vPzMZs/uZYsne5so4c2Ot0ZtmXzdjY8XsPM9K/gsESjqAp1jQd58N4n+f4vvnpW9OKOmzCB6J/+lIaGBgxPP81yUSQvK4vu7m5WV9WxY8cfOH/Br4myxuFx+T/r5Z4R3d3dvPjggwQ8Hi68/XYKCgr+43MGg0GObt7M3Tk5GESRx5uaaG5uprCw8JSPlyQJwWTCFwqdtHuRJxTCckJLj8Ph4MIrr2Te4sU8cd99bGtsJJyUxJT0dPoUhcTRo8mwWokeGqJ93jwCwSB3XHwxmcEgRYrCNIsFtbGRPVVVVKgq1kCAHo8He38/QUXhqCSRKknMEAQ2ut0kxcYe37rcZDJhNptZePHFZBcUMLR1KxWPPsp5oRAzp0yhr7aWkQYDgfR09sbGcm9TE6nR0Vw/eTJrd+5kqLsbg6pyAIiTJOplGbfdzs35+aw5fBiP18uE/HyGHQ6EkhImdnczsbgY9+AgTpuNjMxMJEmi2G5nqLeXuSkplPl8tHq9EArxhsdD9KRJ/Py++/TARqfT6XS6/8C3N76MXwlzZeIc5hZ/sm88qj09KLt3Yvz2d0663b33KNHZIVTRjBKTy/kTR+DxeNizZ8/xylmd7r+NHtrodGeQLMuse3Unk1NvxmGJBkAUREakjKevsYm95fuZM3fWZ7xKTW5uLjWHDzNDVcmPiwMgJiaGjCiV7sEm9tWtQzb5mXDBZ19l4/P5kGX5pGG+n7RNK1YwrqWFRJuN1U88QcE99/zH5zQajZhjY6nt7yfOaqUXbTvw9yNJEqULFvD2ypUsy87GJEl0ezzsVBQunzHjPY+Pioria//7v7jdbgJ33sn41FTMJ7T0DHd1sX7fPoZWrOCKlhaOyjJrPR5cJhPnOhxsbm9nZGkpV44bx69eeomJwSDpdjuPhEIIokizKNJnNPKLE4JGTzDIXkXhyunTSU9PJzU1lcqVK1k0YQIZ6emECgoIBoNMsFpxtbaSOnMmeTt3Uhgfz/aYGOY4neyVZaySxHSDAWdyMj3p6byxbx/nDQ6SKAg8tHcvwTlzuODqq0nbsIG0tDSIDJSWZZm21laGenuxmkwsyshgsSRxxOOh3+/H4Hbzvd///vjgYJ1Op9PpdB/d63UH2dZ9lDRfIT+/5pNvBw6vfhMUBemCC0+6fbisiuQ8BSFlDOs2bKKlpYW8vDxyc3M/8TXodGcLPbTR6c6goaEhwi4j0bHx77kv2VZAU+0RmPsZLOwEhysq2PPWWyjhMJ0DA1xyQquO2Wxm8qwxtO4oZ1PgdZZfeTlLli08I+uqq6tj1+rVDLS1kVJYyMzzzsNisfDqc29SVdaMoIqkFcRw8bWLyMnJ+cSvb4+NpS0QwBUOY/+E3skRBIEr77iDFf/6FwG3m9m33fahg50XXXQRK/x+7t+8GSfgcTg49+tfJzMz85SPF0WRqKgoimbMYOeOHcyLPC6sKOxyufC43cxUVQSLBaGzk68qCrssFnZYLMxNTqZJURiVlMRN+fn09/WxY2CAbEUhLj+f66ZM4Wh3Nw8dOYIrMREVqBBFJl93Henp6YA2+yUnPZ2M9HQEQThp8LJZECidMoW3y8tRW1rwGY10xMbyjRkzaAsEGAiHWR4by58OHOBSp5NMUcQhSVwSDvNGOEz+yJHsXrOGaaqKKAiEQiEO7NxJqLOTQChEjyDw3NGjLMnJIdNioSIUYlpeHt0dHTBmzCfyPdTpdDqd7otmIODl+9tewxhw8KfzLsBhMX7i15BXrUDIzkEcOer4baqqEqo7hDFfRUgbxyP3/QmAm2666XO3s6lO91HooY1OdwZZrVZk0U9IDmKUTu77dQcGyIq1ndH1KIpCIBDAbDYjiiKVhw+z9g9/4IKoKIySxKMVFaw2mRgZmZ0C2qA3R1EuX/7yrUyfOfOMrLPi0CHW3ncfCywWUp1O6rdu5bGtW+k3pZETPJ/z069AEg20dBzlod+8yLd/fv3H3tUqGAxiNBrfU7Fz7tKlbDGbCfh8XHLeeZ/EpwVAVlYWX//5z0/78SaTiUu/9CVcF1+Mx+PRBg+fxjDl8y+7jCeam2lobCROlqkVBLIWLiR582ZUnw9XOEwckCiKTLRY6LFayQsG6YjMkIkxm2lTFGYpCrmSxLbhYWRVZX5+PpWJiZgjW5PfMGoUiYmJx68bFxeHkJxM89AQ2SfsUNU6PEw4IYHRo0eT8L//y95t20jw+egtK+OI283IlBSsXi9rvF6y0tIo8PsxtLaS7XAQ9PspdDiw2+3Yp07lpZ07OSc1leH2doY7OqiWJCYlJnJ+XBx/b23l5cZG5hUUMHnsWOJEEYvtzP490+l0Op3uv8mdG17BI/u5KnkpM0YkffgBH5E6NIS8dQvG27560uuxQHMXtpgBVAT6DWm89tprCILAjTfe+ImvQac7m+ihjU53BlmtVkqn53J4+1bGZy04frs34KJNKePSaVedsbXsKy9n03PPEezrwxQfzznXXMPhbds43+FgRLxWCXRjSQk/3rWLg52dlCYno6gq+zo7aUhIYPGECR/5mrIsU1tbi9vtJisr66Rf7t+Poiise+oproiLIyPSOhRjsbB361Y2NFYRPS6fdkscmfFFZCUUM9zax9YNu7j8mos+8vpaWlp47Je/JH/CBK65/faT7jObzSxcuvQjn/OjamxsxOv1Ulxc/IHvGjmdzg/cmvrdoqOjWX7LLfzrD3+grK6O6Lg4RsXEMOWii9jw8MMk+f2UAdsNBnJjYlick8PqnTsZP3YsiqqyX5bZ3tlJSThMEKgSBKbLMmXd3Uy5+GLmzpt3yusKgsCiG27gxd//njkeD5lRUbS6XKz1eBixfDmyLJOWlkbaFVcA4L70UnZt3cr6gwdxJiVx+Zw5vPrAA2RKEsNRUTQODJBQXIxfkkhMTOSqL3+ZrQUFPPbWW+yrrGR0VBSLxoxBbWrihYoKpqsqw4rC9JISRicn81BPD7eXln6E74hOp9PpdLp3rGk6wrrOw6QG8rlnybRP5RrhNW9DOIx0wcm7Rg2XHSEqVwZnDs++9AbBYJDzzz+fjIyMT2UdOt3ZQg9tdLoz7KIrlvD31ifY3NBGoqEIv+yiSzjAkhumabM5TtDW1sajf3kR16CXC66ex+w5751b8nEcO3aMLQ88wNUJCaRmZ9PucvH8n/+MkpV10jsaVouFUdOnU56dzVtVVahA+rhxfOnqq7FarR/pmt3d3Tx9333EdHURJwhsVBQKFi3iwiuv/MBwYnh4GKWnh4zsbAC8oRCP7dgBDY0sHhIY0bKdvQ0baMpbwMwx15ESnUvjsYqP9XXx+XxIPh+u/v6Pdfx/6tDBg2y4/37sikL9smVccPnln9i5A4EAz99/P5eHw4yaNAlPKMTLL71Ezk03sfBnP+OFf/wDR10dC1NSSLLb2efxsD8jgxkWC7tbWjAMDPDjuDhW9fVRaTAw2uHg6bIy8pYu5dYFC066Vl1dHUcPHWLslCmkp6dTXFyM4+c/Z9e6dexraiJ+9GjE6moan3mG3ampzJo9+/ixDoeDcxcvhsWL8fl8mEwm5l51FS889BBz4uOxJCWxcXiYoiVLiI2NBeCc887jnPPO41+/+x1zWloYER9Pm9WK68AB5gBt4TDr6uvZJYrMv/VWYk6o+NHpdDqdTnd6PKEAd2x6GUPIxgPnLcdm/nR+lZRXrUBITUUcd/IbhJ4DB0iYqCJkTeKR7/0IgJtvvvlTWYNOdzbRQxud7gxzOp3c+T+3U1VVRUNtC1a7hesn3HDKqpMXH19F6uA5jIvOZsVjDzG6tITY2FhcLheHDh7EPThIalYWI0eOPK0WmXeUb9jAfKuV1EilRprTyVy3m02SxGqXC5MkYRRF3uztZc4ttzBr3jy8Xi+CIHzksAa0HuQXHnyQc4aGGBsJX0KyzFNvvsne/HwmT3n/AXZWq5WgwYAvFMJqNLKpro6s/n7G2W3s8qmUOtMoURWeqV9HU+pEZCVEfGH0R14jQGFhITfde+9Jv9T39/fT0NBAQkIC2ZG1f1paGxoYB2TGxLCuuvo993d2drJj7VoEUWT2okUkJCSc9rmPHj1KxuAgoyOfg8Nk4rykJF5cu5bbfvpTbvnud+no6KCrtpb+cJhREydybloabzz6KLteeomrVJWumBjGpqVhFATcHg8VgsCoefOwWCz09/djs9lQVZUXf/c7pgUCPLV5M9+//34EQSAjI4PLTihfXrtiBfsDAdLf592xwxUVvP6nPxGbm8ttd99NTHw8+zdvJhQIMG7aNMafotJr7Pz5bPnzn8mOiSE1Npbc0lL+VlPDQaeTi66/nvOXLSM5+ZPd3UKn0+l0ui8CVVW5+e1nGZbdXJW8mGn5n3xbFIDqcSNv2oDh2i8hnPCmnhIIInmOAdBvyiIUChEXF8eFF174fqfS6f5r6KGNTvcZMBgMjBkzhjEfMgw1FAhjMdowGSwIqoQsyxw9epTX7r+fkYEAcYLAAUVhc3Y2N3z3ux+489CJ/MPDOEwnz9RxmkzEO52Mu/NO1q9ahSLLlF58MdMjVRC2U8wBCYfDNDc3k5GRcXy47Km0t7cjNDcz5oRhuUZJYm5cHBs2bPjA0MZsNlMyfz6rV6/mguxsDjc0cLPdTvPwMFKcGZdvAKc1lklGG1vq1kCKwJfPXfa+5/swqampx//c2dnJE7/4BYVeL1tVlRm3386U6dM/9rk/zMTp03ly2za2u1wsv+iik+5zu908+ZvfMNvjIaSqPH7gAN/45S8xm82nPFcoFOKx++9n7KxZTJkxg1AoxLH2dh5rayPG6WRBYSFGScLtdvP3e+4hprOTXmD2rbcy9YSdqG7/0Y/obW8nx+8nKz6e4aEh6srKKBBFctxu1v3udzz9u98xOj2dsMlEwZw5KEBIURAj24CfysJly1i47P2/T821tRR5PByrrcXr9VJYWPi+W6GD1kbXUFnJ9u5uqrq6mJmRgZqRgVxSwu++/W1GjBjxvsfqdDqdTqf7YH/au5ntvdXkhYv55ZJPb6dTef068PsxLD35NYL7UB1RmUEUKYa47JFUVFTQ1tb2vq+DdLr/Jnpoo9OdxS66biGP/Oklgm0K8y4cj91u518//SnX2WykRwbtzgQ2Njfz5vPPc9WXv3xa5y2YPJnyQ4fIi41FEAQUVaV8aIiCyZMZO24cY8eNO63zvPTsG5S/1cSoucncdPs1APT29tLb20tcXBxJkQHGgUAAK7xnuK/VYCDg8XzodRZfeimv+Xzcv307h4eGOGSxkDlqFHOTk6kor6Zn0ER/0Ee9uZXvfOV/yf+Ednfav3s307xe5kRayF5ZufJTDW2Sk5P57u9/j6IoSO8KPDo7O0l2u5kWCb6qWlro7e09vkvTu6mqiqqqxz/uaGpiqKGBcXY7Pd3dPN7XR1JGBlJhIUV1dSzOzWXA5+PvTz3FlOnTj3+vBEFg3Dnn0LZyJflGI7Xl5UywWvEBCnB+dzdHg0HGZ2UxJjGR19esIX32bNT0dK6fMOFjb8E+a8ECNgYCLMzNfd8wUlVV2tvb8fl82ue4cSN/HDeO3zU3k3777YyJjycvL0/fUUKn0+l0uv/A9rYG7ju0GmcwgWevvAKL8f3flPlPhVetgPgExKknz8txlR0iOVNBzPj3awt9lo3ui0IPbXS6s9iIESO450/fJRwOY7Va2bBhA+rhI9SFTdSiIAsh1KCE2WFh/9DbLL/uuuPtS319fZRt305LdTVuVaWotJTp06cTGxvL1BkzePrAAR4+cIBsQaBRVbFOnsyUaac/UK6np4fdm9ZRW1ZBb6eDxEQLfR0d9JaXkyZJdMgyiZMmcdnNN5ORkUGP1Uqv10vCCRU7B3p7KTiNuS1ms5krb7mFgUsu4Ym//AV7QwMjsrIAmLNwGkNDQ7Q0N3P7V7/KtOnvX7XzUVkdDrrDYRRVpcvjwfoxd6T6KARBeE9gA5CQkECnwUBNXx8hWWbIaj0+0+VUTCYTt/3gB8c/bty7l1tmzaJj/368fX2sb2tj/LRpTJsyhVBtLQCyqp5UivyO2eeey79276a9ooIEr5dKVWWbojAqIYG8vj4ynE62tbQwNTOTpenp/GXfPq6/5Zb/KCyJiopi+VXvP5hbVVVWvPACDW+9RYwo0hEVhd9i4c3OTtKKipg8ebIe1uh0Op1O9x/q8bq4ac0TiLKZv59zNemf4k6nqt+PvG4thosvQXjXayG5+QBiKlQM2XHU1X1ib9DpdJ8Hemij052m3t5e+vr6SExMJC4u7oxd12g0YjQaaW9v54m/vsLodguJCaNobmrB4x/CHAVxahZNLeUcPXqUcePG0djYyAv33kvB0BCNVVVkeTwcEkV2TJ3K1++9l9TUVG789repq6uju7ubhcnJ5OXlnXZVRH9/P//6+c9ZHnKTM78Eq8PBn/74RxICAb69eDEGSUJRVVaXlfGa0cjVt93Gwptu4om//pUZkkSsxcIRl4umzExueZ9dh04lNjaWS2+6iWfuuQdLZyejk5IIyjL7h4YYKCri8k94C/Lps2bxXFUVv963D3tyMldff/0nev6PIiYmhovvuovNL7+MKElcecUVp2xZez+22Fj6GxsJezw4h4eJVRTa1q/Hungx1Tk5/KO5mQFB4LyvfvU9z4Po6Ghu+9//5anHHmN/ZydTk5OZIAgEmpro8XhwxsYer+qxm0zIfj+yLH+qoUlTUxPNb73F1zIzMUoSO1pbOTpmDKXz5pGfn68HNjqdTqfT/YdkReGy1x/Dqwa4o+AS5haeurr3E7velk3gcSO9qzUq2D2A1d6Lohr5/m/+xpq1a3nppZe49NJLP9X16HRnCz200ek+RDAY5NnHX6ZqRztOMYUhpY1JCwq47Orlp6yIeLf29naio6Ox2+3/0TreeH4No23L6bE/TTAoY5JjSHAU0umrpM03iNUxmr07KomJieHvv/kNy8NhKtvamNbby4K0NPyCwIrDh1n38stc/41vIAgCBQUFFBQUfKR1DAwM8Osf3UPChh34LFHUWFVSclOJ8niYJcsMDgyQkJCAKAgszMrivl27GLrySiZMmkTCz3/Ovm3bqO3tJau0lPOmTn1P8BAOhynfs4fKLVtQZJmiGTOYOmPG8Z7ljIwMrv7JT9jwyiu8fuAAosFAyTnncNOFF36kEON0mM1mbvjmNwkGgxiNxo/d6vNJGTFiBCPuvvtjHbvo6qv5n9deI7OvD6vZzC2pqQx6vWx89lnu/vOf6ezsxOl0vm/1jsPh4NobbuCB/ftJqasjeWAASzhMW28vb3o8zB01CoCKri7SRo3CaDR+7M/zdHg8HhIkCWPk72Cq3U61z/ehc6J0Op1Op9OdnjvXv0Gdv43Ztql8d97ET/168soVEB2NNHP2Sbe79lQRlaPQGEhm7bp/YDabmT9//qe+Hp3ubKGHNjrdh3hr5Vratpo5L+cOJFEiLIfYvvoFNiZv4dyF7/2BEQwGKduzh4DPR35hIX/6+aOUThnBzV+59kOvVVdXx9qV22g40oY9ysqMheOYO28W4XCYY4faWZJ7Pev6arhv7+OYhoexSRYURJpVgRnn3kPloa30bluFo6yMLU4nHW1tTFYUOpuaiEpMIiocoqG19WN/LXw+H3+59zF6dg0wW8zF1z2IFLaxtaYWj9hJXHIcQ5HQBsAgisQJAsPDw0RHR5OVlUXWNde87/kVReG5f/wDduxgflwckiBQ/uijPLZ7Nzd/97vHg4DMzExu+Pa3URQFQRA+9TDlg4Ysf16kp6czduZMEmSZkS4X2WYzhw0Gwj4fRqORrEi72QdxOp2MWLiQZzZv5hqnE7vZzG67nb2BAAUuF280NnI0OpprP+B7/EnJysriTbudA52dJNhsrO/vp/jiiz/16+p0Op1O90XwbOUBXmnZRaqSySOXLPvUX2upoRDhNW9hWHg+wrted/kry4ktVHl6ayeqqnLxxRef0ap3ne6zpoc2Ot0HUBSFNa9sJ991KbVH68nJy8JsNjMmZSHbVz91ytDmuYcfxrxrF7GSxAvx8cxZMo+S0UUfeq3Kyiqe+MNbFFnOY0HClXgCw+x8YhN1R57m2psvA1UgEPbhG25lrDWKuGEXdkWmTVBoVg20u48ihOq5JjWFZrsdmyDwJ1HkJbebKSEFqxvWmkLMLi5+z7V3b9/O+qefxq0oJKWnYzYamTBvHhMmTiQYDNLb24vD4eBodQ1SZxYORxetLTuYap+FwWIiyj9AtedNarv6KTqhLaXf62VXayuD99+PJIoUzpjB7HPPfc9gWY/Hw97y/ezcUsbQuhXcNa6U2JgYBEEgKzqaZ6uqOHjgAJMmTz7pOL0F5qMpmDgRb0sLhuFhmnw+hmJjyZ848SO9ECsZPZreSZPwAgPBIAumTMHY1YVr/nyyx47lq+PH43A4Pr1PIsLpdHLt3Xez7sUX8Q0NUbxkCTPnzv3Ur6vT6XQ63X+7o309/HD3y1hkBy9ecj1W06f/K6O8fSsMDiJdcHJrlCrLSJ4aZFnlsVfWAnDLLbd86uvR6c4memij032AtrY2KvbUkmVPpE8N0d1xgBlzJ2E1OfD0+qirq8Nmsx3fJjoYDNJcXs6P8vMRBYGe5mZKRhdSXPz+oU0gEGBvWRl/u+dPpDANNV+lc7AJk8HMjNxL2bT3UVoWtpBVnMC2nS9R7Grn/JxZDMYM0dh8DLu3iSn+fjbUPkVRUTYNLS1IDgflTU24PH4GVJEVahi3r4/OsMTgo48yccYMRowYQVVVFZvX7Gbb048whiCBthYkRSE2NpZVL77IU4WFJFsspEkS/bLMwe4hTL1ZtLbsock3iGRoxRUeYig8yKBs4IUA3CnLAPR4PPzP2rWMj4nhckkiHApR8frr/GvPHr70ve8hyzLR0dEMDAzwt989ha1/BD3dZgo7rOwbOkr2yEQKRmhzdkrtdo4cPPie0Eb30Zy3fDnP9/SwrrwcgyBgys/n2htv/EjnyMrKwp2QQL4gUBAXR01fH/7MTG684QacTuens/D3kZaWxpe+/e0zek2d7sMIgnA+8H+ABPxTVdXfnuIx84A/AUagV1VVPXHU6XRnBV8oxGUrHkFWFf4682py4k+9g+MnTX5zJdjsSHNPfkPUW92EIy3AhuoAjU3NZGVlcc4555yRNel0Zws9tNHpPkB9fT0pUbkEGCDLMZaGoQE8Hg8tw5Uk5tl5+BevI1iD/Pj338DhcGA0GrGnpLCvo4N4q5UOUXxP+eb+fQco33aYwjE5TJg4lsf+8Aeiq6uZdqweJdDA6u33ojrSKE4egzeugPSs2VQerGHZFQv4/svfYJoSg6zIeJRefMowcdYM4gWBTY3NrG8Z4Kjixaq20hgc4OumOOZHJbFvsJEYeZgSh4N/7d/P3TfdxHV3fp+yN1rJNk/BN2DD29PAzNAQU9JSSU9O5u26OrY1N+PLzSU9P58xDge1+3eT4y5nqiGBflnipZ4XsCORKBhwodIal86Dg4NkVFfT6vNRFB/PV2bMQBAEdu/axYicHJrKy/nh9dczJjUVl8FAk1tiovM2RuSM44CyHlN7GblR6TRU7iUhMY7Y2FjcoRCWSCCgqirbNm3iyLZtxGZksPjyy49Xdni9Xnw+H7GxsXoVzimYzWau/9rXGBgYQFEU4uLiPvLXKSoqiiu//31ee+ghBpqbicvI4KrbbjvjgY1OdzYSBEEC/gosBFqBMkEQ3lBVteqEx8QADwLnq6raLAhC0meyWJ1OpzuFq157mgF1gJuzzmfpyDOzQ5Mqy4TfXIV07kKEyC6o73CX7SMxWeHxFW0A3HTTTfprPN0Xjh7a6HQfICoqirScZGob32KgrxWvPERFZyuB5FouXbqQZ5rewmI3YDBof5UEQeCaO+/k7Wefxe9ycf6tt5KU9O/X411dXTz3l/WMsi1ldfkGqvaXUdTURKYsc3SwA2NQ5gJEnhpqJt1oxy4ZWV/rIkeaS15eHjMXTUDeupva4Q7aOztxGhzgbseumhGUfmJDoxhh+xoH/M+RatpGunkER0L9hEUDpSYHFl+AeX4/m3bv5Rd33s8tC39DcfpkDiSPIXm4DV/IjclioaO7h+6eHmaYTOxsacEQDPKHnh7OdXkwevwERQ9RcpibkDgiWrhGiqfXIPDQcBtVnclgmULlwZcpEbysGw6ihiRCSphwazvpHW24Y2M5xxZNn8tFc3ULLROmMeTuJayG2auqjJWDREsZtDV3YrTb2R0Oc3FkO/KDBw9S9cgjLElIoKqujtd8Pq649VZefWElezfVIMpmfIYeSkYlkZWdTemkSWRmZp7297y3t5f+/n5iY2NJTEz8ZJ9QZwFBEP7jPvCsrCy+9atfoSiK/sJJpzvZFKBWVdV6AEEQngOWA1UnPOYa4BVVVZsBVFXtPuOr1Ol0ulP45ZZN7HVXM848kp+fe+YKAJU9u6G3B8OSC957X9t+1CgVa3waVquVGz9ihbBO999AD210ug8wduxYpl/UwJZV+2gdeJmRY0Yw+ZwpTJtxG1FRUeT8LgeTyYTFYjl+THJyMjfccccpz+f3+5EUC8nR2dQNOqjZvoErsrOpOniQHIsRXyBMqsnGAkFk03ALC5JG0dO9g5LRWu/ujAsuoL65mQuzs3n+n0+TGVCJk6OoVxVGk86QvI+a0DMohhBWBbKixzDk78ETbKQn6CYdCTMSoiCRq06jrGILhWkTSHCkMCr3HPpbytjWVIOKmagwFIsiB4IhZkdF8ceqKjJCCoWiRK/s4yg+ZiFRrhhQRUhSVZYoIn+p7maor5pRPQKSr4umVg9RlnjMJoXaY0dIcprpcYdx+0dCQKKg/wirNj/E5Mxf4lNdVLuN/LrnCIWCH7MyjDnOwYwbbiA7OxuAzpYWSk0mMqOjsQgCD1dU8MYrb1G7RmVB5h3sqXoRpXoboa3rME0q5KXXX2fi9dczZ8GCD/1+b9qwlbee3o2DFFxqJ+ddOZFzF33w7gRut5u1r79O7Z49OOLimLF8OWPHjTu9J9jnnB7Y6HTvkQ60nPBxKzD1XY8pBIyCIGwCnMD/qar6xJlZnk6n053a2tp6Hjq2hljief7Sq87ojpnhN1eA2Yx07sKTbx9yY7F2o6h2/vn4I/z5b97/eDdWne7zSA9tdLoPIIoiV153CRddvhRJko5X1LwjOjr6tM7T3NzM4OAgaWlpTDg/g7Xr/0jxjGxa9zgI+XxEA0nJcRwZrCMYljCrYFLC1HXvJbogjhEjRgAwfsIEDo4axVN79iAofhSfygHVyC7RzHTDFPr9e2hS9zE96xfsaNpBb2gQUQniU23skRViBIkdqorbXsjYqKn4Qz30uztJSptEVVcFiWEr9pSpKKpMdFsZx0QTSTLs7u0lMRTGiIgNiWizhfhAkEFkrPjw0UdyVAZJQ2aEsErioJcpplLW+VtZLnsokhMxBw0cDKvs6enDZLLSK/biDQ5idKtIFrAKsVj7C8j2mPA6m6lS+3CbDvCdS65g9vz5uFwufD4fWfn5rPB4aFi9iUPdw9SmFrBt3/PcMvMP9Ay3EG5Yx21Jo+gZspMETEtL48Gnn6Zw1Cja29sZHBwiLS2VwsLCk0KHlpYW3n6ynHmpX8FqcuAPeVn3zD8oKMolJyfnlN9XVVV56s9/Jq+mhttSUhgYGOD1++7DePfdjBw58uM85XQ63efbqX7LUd/1sQGYCCwArMBOQRB2qapac9KJBOE24DbgtHZ30+l0uo+rfdjFVzc9jSQYeH7ZjdjNZ27XTFVVkd9ciTTvHATHya3WrvJKnBkyStwoBEHQAxvdF5Ye2uh0p8FsNr/ntra2Nvbv3EnI76d44kSKi4tP+a7EmrfWs+H5w0SL6QwZ3+bW713CZVctB+BJeZDa3bsxqipJ0dE0JMTQPuxif0jGYjJTm2bg0q/fjsFgoKOjg6rKI8y84ALWGgwcPHiQDYO9JApRjDPkInOMRFM2OYIfq9mGM30cj/dvZJzHQ4F9FEp0Gu0egX5LNufH34pH6KK6ewdjuieASeSF1t2M9nRydfY1DA/0sz4cxhVSuFh2sK+lhQmorEdEUBSKFIkeUWKHojJKAEWVaR3qoCzowaPm0GhQSJM76VJDbJIMhAUVv3+ANbJMmmCmODTAQKcLq83JIF4UfxPHqr6LYL2UYucV7AqWEZ9h4+qZ97Pmxcdoramic98+YgwG/NHRVIQsNBimkz1hKjfmnMOLrz/Fhv2vkh6fyBgkDIKIQTQRCnpxmExkeb38+Du/Jsc0E7uaxCZhO3HFm7ntW9djs9kA6OzsJE4owGrS5uNYjDYSxEI6OjreN7RpaWlBra1lYXY2giAQbbGwKBxm9+rVemij030xtQIn9mNmAO2neEyvqqoewCMIwhZgLHBSaKOq6sPAwwCTJk16d/Cj0+l0n4iwrHDxK4/hF73cO/FqRiad2dZwZf8+1LY2pO//6D33BY/spE4YotIdYNmsEEaj8YyuTac7W+ihjU53Gurr63n0zy8xY8F4Fi9bSOXhw7x9//1MEwTMosimtWtpufxyzrvg5F7c/v5+Xn50LfNTv0JyTDZt/bW8/sw6vvu/BQDMu+ginq2oINNiIWZoiIzERF7w+lijKBjjovnSN7/J4osvZnh4mAd++SS2/iJ21D1OfHwsViGFGbES/qEA8XYJu1hE38AArXIPXUNvc+Hcr7Ol4hleq93N9CQ77YNeGoQgE+KWIIoSu5pew5Gq8Gr5A4Q9+/hmSRovVbv4cd0hbMFkOtWJ5Cp17Am4ORTwk4NAumBmnWDgDdnPkMGCXQkyFJY5hIwraGGrmogiZdEWtvJ3eSPLDTZmxS3kkLsaWbFQIBTQrR7Fpw7RHTqG7E6kjDAXSCOxhAZ4m+c5IAr44ltYPPMnJEVnUr/uII5NR5gRnUJ8sh2nKFK+5yCGuPPxuJIob6nAarZxpOJJOqx+6v39eMI+UsQhcpPyUFWVI0ebSMu/mFmFVwKgqvMoq36Lt1as49IrLwS0LaSH5QMoqoIoiKiqyrDSidP5/vNwAoEANjgprLMZjfjd7k/4GajT6T4nyoARgiDkAm3AVWgzbE70OvAXQRAMgAmtfer+M7pKnU6ni7j1jddoU9u4KHUG144dc8avL7+5EgwGDIsWn3S7qqpI3lr+uvkoD7z5Ct+tauUPf/jDGV+fTnc20EMbne40tLa0MdgoUF1Rz7RZAzx8zy+5NBhkbEEeDoeD0eEwf3jhBSbNmHF8yGtXVxf/+tWvUPbvZn9NJ9asWYwesRSfJ3D8vJmZmVz9k5+w+oUX+J8nn6KnvhWzOY2wIw6DSWDX2o2kZmdztLqa7uYhgj2HEFtTyIyfQDAjHlP/MeRAOQ1D5fSGjBzAS6OQgtqzhcG3XiTXZsAZl0nVsJlRsT8nXVDpNJThMbdgjzZx+9KfEGtP4r5VS9kz0E93WKLd46RYWEiJIYV2ZR+PqdsIyoN0Ucl3VDMLxFQQFDySn/sZ4DHRT5w1B0t4CkZKKJFiyY2aTpVrDKHA/yH72pio5GEzJOJVBxiyJPCqawsdQjKpUdOxhOIZIWcx7HfRrZQhRW2lIHk0NnMUfa5Ogi2HWJIxl5SYNFq7qlGlDsYPyzQYOijIvoqmoYMMtTzPBfRQZEpkyOWnvXUz7enxOPYOMCCKHPAIfKXw34GaIAiUps1h08Y/c8kVyxAEgcLCQnKmlbFlx9MkmPLpCzaQPlmgpKTkfZ8X2dnZvOpwUD8wQF5sLCFZZmtvLyUXXvjpPRl1Ot1ZS1XVsCAI3wBWo235/YiqqpWCIHwlcv/fVVU9IgjC28AhQEHbFvzwZ7dqnU73RfW3XXtZN1BGnjmTB85fdsavr6oq4VUrkGbNRoiJOek+f0M7xng3z2xtAODqq68+4+vT6c4Wemij052G6TOmYXfYiIuL4w8/+zs9+/owOdLZ1XqQqXPH0OjxUL9rF/f94Ad8/49/JCoqilf+8Q8WBQLIucl4O71srn6dlb5qrvve0pPOnZmZyc133klrO2R4FnKg4knGursptkRTs6ecP+65DXNnJx57FL3dLjIEO+7y9fiKzuNg4ki8/mE66nbRLHhJNacwLf1WjL0vcV50GkWlCbQeCLK/r4V9w69SEn07GanjySlKpWWgCn/Qw5amV6jvHKTNFyLaLZMg13KQhzCSSqnpEiYYHuJI8A26w3/keVFkgujGIho5rIgogpmhWBvx/qtxB46QzPMkCCGOBh5DMc+hSjGR76klizgGhGbCpjbU4BA9mCl2/ITMhFy8hmqe7nyG9mAFigDpoWM01bXRWDQHk8FCtBokPjoBQRAwiXb83l6ckog/1AxAx/BapoVdxNmHSSpMJz48goTWFp7qbMcYjGO/omDJPQ+r6eQ+aKNkJhQMA9qAaFmWufHLV7Nv4j56uvqZnFTAxIkTkSRJu05HB9u27CYxKY5Zs2dgMBgwmUxcfuedvPLXv2JtbsYN5C9cyIzZsz/9J6VOpzsrqar6JvDmu277+7s+/j3w+zO5Lp1OpzvR7qYOfnv4dWyijVcuvumMDh5+h3qkCrWhHumr33jPfZ7yHWyobqbP5WXMmDFMmDDhjK9Ppztb6KGNTncaDAYDKSkpbN26DWtPMfEJXbgDLmzBVFqa2jgc8DBJVRGGh2ltbaWkpITuujrGZ2WhJCbSUN9ESdsAlilWFiycB8Dw8DArXl5N/dFWWjpr6NpbQ1VgJ47eZtKsxZgcYYb9ErPFAG67nSSbFVVxMWS0QDiRTTV7Gbv0Z/hSJ7BvKAonZqKtuQx4ylguxRAlubDZrHQP1zDWXEptqJoGzx5SQ/F0q1W4rMf47RPfRPQ7CIcMLBD9XCAtpUdu4nX6OAykS5PolNfQJ/8TGTPVyiABwUCMJQqfkkgH+fi8nQyoO5jPQRYIZqIEieHwEP8I/5MqIYldkoJTcmNS27AF+1gn+LGKMrL/LxzuK2V23nep5xUuic1H8PdQ524n3RzDmg3/Q/LYqQh5idQPVRAlxeI1dJKekoCvwUe71Mn+wVep6nqcBcE2SuKd+JqaSBgzhvETJ7BjyxYOmc0UjxyJS02h19VOgjPt+Pf0aHsZWcWJPP3ggzTv3YuoKMQWFLDwmmuYMmXKSd//Y8eO8YNrvoJp0ETIZKD2W5dy6+03ApCbm8sd995Ld3c3NpvttIdT63Q6nU6n030W+tw+blzzJIoU5rGFt5AQme93poVXvgGCgGHxkvfe2X6AR9dro75uueWWzyRU0unOFnpoo9N9CFmWeerRF6je1kN/t5v6ujokQeLv3TWUyoPkO2JpTU2kY+xYMktK6O3tJRAIEJWURPPQEDkxMYwozKfaKDJx1gwEQSAYDPL3+55AbCykfPvj5HXuZUooSLyYhqQEeNu/l+JeG/vkY/ywIIUGtxt1sAurYKQl1MuThClOvoeDNbtZOPUyTDYBAS+2oV3Eeo+yG5Ul5mTM5lRSEzPxDnXh9HiosR6k3dVJZsCG1ZPFCNsCAn6REHWkKC/jUrtJooAUWtlJN1t8l5BHL+cjk4qIG5m3FJW+YJjW8CBhORlJiMavbmQREvGqgkyARBRmIVEhhdllSqUu5MYg+8nCikv2cItkwmy286Z6mJ0D/yA3WENMaJCyUAcLDQoWeYhnXA0csSlExcSxVm1jUXKIMYXFHBscZL3Jw/iRC0mJiWJv/RBWA1j8Igafn/2bd2KLiiaqoICvfu1rjBw5kubmFp760zNkDE3HJsWw68BGqobWE7WrnZsy4/ne5IkYRJGazk5e/s1vuPqnPyUjIwMAj8fDU/feyzJ3mHlps6gcbOD5x5/giqsvISoqCgBJkkhNTX3Pc0dVVf1Fhk6n0+l0urNGWFa4/KXncBn6uWvkUmZkZn8m61BDIcIr30CcOh0hMemk+2RfgD5fPWsOtGMymbj22ms/kzXqdGcL8cMfotN9sZWVldOwOcy5WV/notI7iXKVEOy1U5B6L+WOubwdnczSn/2M7/zxjwjNzbQ//DCvPPYYy778ZV7w+Xi9qYmnGhpoGTGCmfPmAdoW4O4GC2YsjBhq5GZrIokKiOEBRoX7Geer51jQQ1CWWFnXwP7hYeoRMJsTmGTKQEagKHYJvoCHo+1lZEw0YZBqGCc1MELtQaKNgw6FDW1tlHnbEJOy6bCGqXftwqXupeFIJS3t+6jteZCa0EP04qIBJ27VSyvNHGCAML2cTytfRcGLAT8h2lGYr7oZG+xknNyGgS5KhauIBmLwYcGPEwUBhUOEmBYeYLSvgTlKN1EEMKJgAl6WXbQae3CkJeIJtBAf7KVZDRIvKOSJNkoROV9W8Da1ktpzBU2hxTzcbuTOskM8PjhItkHl6IHfsXf4RdxGgZ2mKAymNKzGRExCEg+8vok1B1t57eGd/PaHf6OtuYOv//RKUs7tZX37XzBEB1ky7mbmhRKRjg7QUFuHIAgUJSQwXxDYvnr18e9/S0sL0T09xEk+Kto3Y6KTKfEOWlpa3vc5EwgEePbhh/nFrbfypx/+kKampk/3SarT6XQ6nU53Gr6zcj016lFmxY3ijqmfTTu3vGcXvoXzUGuOYrjiqvfc79l3kJcO16CoKsuXLyc+Pv4zWKVOd/bQK210ug/R3dFHknkEkihhtVoZXzKdDceeILc0kVzbLXjzyygtLWXz5s24m5owG43U1tdTUFDAzb/6FU1NTRiNRoqLizGZTPj9ft54+S327qzH7injEtsIeo1hBE/o/9k77/A4qnP/f87M9qbeu1xky93GFVMMxphueg2hBEiB9NwkN7+Um5t7k5sEEiAFCL03U42NsXHFvduybNmSrd7brlZbZ+b8/hjh4GB6CzCf59lnd2fOOfOuNFrtfud9vy8+2UVfNMhMYAWH6MWGphmcpAgiaoLXjQ6yZACv6mdtywPUybU0haooLS2h34hz2OikwgmdMR1t924y3W7Gu70srVnI9niC0dLBJD2NA/EWKqXCNCYQJJ0n2cZW0mkGQnTSr47Fpe8kiaAOhf0k6SBBGSCBdGkwERvZHGSDcSsOYqxHcjoSO7AJGAUkEEyXSQJGO5OVbA7IdHJQ2SfqeSS8FUdbK81hQSDZxmwErRhE4mFaMTgEqHYPo3yn4SiYyoTJv2HDoRfZV/sHrrTlsd/eR0OundlTv8PWnQ+xs3sfbqDfmYHdeTxTfFdwWtFpDMaDbHxyMcG+AU6dfyJbltYxv/h7PLfi50zqOUiJUNizdj0lpSU4nU6Gp6ezproaMDNlFr+4jL1V3cz0jWFA6UJ1R7ClBI7ZBv5Nli9ahOuNN/hpSQn1/f08/ac/8d0//MFqVWlhYWFhYWHxmfHoln08372abEc6D571drHkk0b29pL4za/QHn8UUVCA88FHsc1/e2lUcv86ctM8jBxWxnXXXfepx2lh8e+GJdpYWLwHOfmZbIvvp8KYiqqoeHI1XJFBOr2b6E7W8bVzL2DXjh1seughnIbBtt5eqK9nx7ZtTJoyhczMzKPWW/jky4R35aDYq2kfqKZKT+BNT8dQgxTEFWIEOIxCMyHGI8hEYBcqFSjYlQR/MLoZ8Dnp9L+EO5RPpessDlZtobMzgzf0AVrtklSh8UOfl+54nFYMRkmDfKljt/koE166pc7pRImyE8EYvAzSzAApzKWNXs7Mu5ldvX+mIbKeGuKci046cAIQRvJnzJYnZ5PBKhpxYfAKsAo4EVgPlAFFCLYAs2SSfUYcvzyMn16+IiUqkopwK48kkoxAxY1OJwaPAQ4Ea1AhEaUusQpXbRqH6xoorywibMtgXV6CAVce6D6CzZuZoql02tOJiyTxuEZWagVG2IFhGPhcqRxfcjGvLf8zU2aMR6IjkUS0KA4khc4AvcYg4XAYp9NJXzSKNysLMDOi6rb0Ys8/mTW9tVT68tnUtR91ZhZlZWXveM501NZySno6dlVlREYG9sZGQqGQdaXIwsLCwsLC4jNhT3MPv9i+EJtd8OzZ1+GyfXoXkqRhoD31BIn//iWEQti/eQv2H/wI4fUdc7wtVsdXZo/h2jtWf2oxWlj8O2OJNhYW78HUqcdxYM5hlq29E6fiw1Y4wF/++9ds3bKdjhfguUeXondVc/bAAFlFReTl5zOg6zzw4IOMHT8eu93Otq07WPbiekpG5rBtzX784XymaS1oyf10JULs6LRTluanLyopF6kclC6iQAoeHJSwRxzgULKf/Nws7KEwmcNn0Lc3gNeeQZ+tE3sshdHqOZTrr+PQ25mDgdvlZFhBAf1xDXdLJ+faMrhXGORIiUqCGlSm4uE1aukjlxx81PMC47xXkZDduGyCZuKcB8QAASSxYUNnBrCGBN00cgoJZmHDhUYnpnBzPLADJ1uBXiRRbFRKgzzCDAfGAKm6walSpQXJK2hcgsIcoApoRVJBGjUOO7X1t5GifBWXzKa19xBtqUl++8KfycvL4yff/AklrdX4ZR6FWpwReoRG7Lzc9TR2dwGKopDUE9R37qW/NcaWLVson5jJ1u1LGDV8Pi/ufx7vYBP+shwCgQCDiQQvtrQwc6it5KIXl1C3vYcsWcnL0QYOleXjq5jIrJkFR7pKHYuC0aPZVFVFuttNfX8/enq6ZVBsYfE5QghRCFyGqVXnA1HMt6dXgCVSSuMzDM/CwsLiA9E/mOAri54g4Qxz5+wrKU/LfO9JHxPGvmriP/khxqaNKNOm4/y/W1FGV77j+HhrO57MCAnbSByK5eRhYQGWaGNh8Z4oisJV115Cx5kdJBIJcnJycDqd7NpeTRajOXxgHbbqdWS63ehSsqWmhozCQpoPH+aBO+9k7oIFPHHXYqb6v8KepUvpjrQTPrSX+QNtlHrSaVJVXtIHOM3lYo8jyZ5YL2tkgEHKkBwmT3QTU1NoVuJ4MnJRpIsK7XI6EgaFcjIbe/+EQwZo014jzhaKjEGcOIhE/fTGnAhPKiEJzWgcMmI8oIdIoNGIxhYE1ShMJ8EYvOwnxKbBF3HEg4x3pbIXgR9JCFgE5KPjQCUPQTcqGjqzEfTjYQdhNAyagF4gjMF57gnskI20xfrJIoSTJE4UdqDjMQwi6DgwvxH1YJAKXA6sx87jDFBuq2BMrJvlLMenzMUb9ZMY9POzH/yGM888A2OglTxDpV7v5wJ7GpqRpACdNVofItBNZ6iJ9RtuozTWz5jwYTqf2Eq0vJz0GeM5VNWB+5RTWNxdyxmFBbxUV8djO3aQnZJCyubNjBg5kp0rG8gOzmKYbS558kR21N5H+SQnI0bNftdz5pQzzuCVwUHu3riRQFERV1x7LTab9XZrYfF5QAjxAFCA+bb3f0An4AJGAvOBnwkhfiKlXPPZRWlhYWHx/tB0g688/SLdzmauKJ/F+SPGfSrHlYODJG/7A8m7/waBAI7b7sB22RWI9xBiOlcv5v6XdnL5Nacz8lOJ1MLi3x/rW4SFxftACEFubu5R2+adMQen6w0Ce/Opr4Zcvx+nEByoqcHW1UWK18uYvXt5prqahJFFZ7ARTY1QMaGYxa89y4xYGBcgkAwE3Dxpt7HTpZFSdDqip5RhoT10JJuAfjKMJGER57k9u2hyTSKgd2HXCjkc34Jd5LGXx5hh7GEWBstJspM4XZ1hmhJRWl299EiDxUY3s4EJKGQi2IlkDZLj8XARDloZ5DhyqKeVSVoer4d3Mw9JJWDHfLO4DYUT8eBlkCQOQmisQjKcMHMwsAM+YDkwEp3O6E52kobDeSaPJ1ZxgoywC0kTcCaSfUNrjwEmAy1AEChCIyQUEoaHKj2K4oiRZaxBiQySqaQQPOhE2TuBrubHiHnCxPsEByWkEuaQESOkeBlZPIz1G27jAmmQ682hUW3mpDFj2HjoEE/UN3PuDTdw3NTrsdvtPPrAA6x7+WXKEgkuice54x//YNjEiUR6JYWpZfQOHsCOjz6tmZZYO6NH//Bdzxe73c6Cyy+HoYwdCwuLzxW3SimrjrG9CnhOCOEAij/lmCwsLCw+FD9/ZQM7jB2MTinityec/akcU3t1MYmf/QTZ0ozt8itx/L9fId5nifhzi5/hV0/uYFXb31l5+qWfcKQWFp8PLNHGwuJD4vV6OfPs0zFiAyjFxTzW0cFoXWcgGqXG52PqiBEMs9tJBoNUTxhO7rA+phfP4qF7HmWULYWlRpQumaQenYoBNz3xMJ5JYynMHk39wSbKIjVk2XzcK7px6DG88QQpUmF+tIG9+t/oMCYSoJwuYx9+djMOmAAsBF4CyqUk3tfHzS4X98sEVwLTEbQgSSA5HskSbARQgARJ6vFzIgla6aSbYRicCCSAAWAcsASDBkI0IqhlEBfwFWABkkEgBbOMKgA8hZMM/JzjmcE+12k027J4IfYM8/QQYwV0SMkw4KvArZi1B8cBOxG4kEjVTb5jPpsjuxgZW0+qms94ZSIDNLEoKCnJqmT66G9RH/05p5SncM+e3biScQKKpFdIVlY9RmVfIwPuFCLeJOXjclm/djP9TRrJkMbD9RtZNm4LU04rxb59O3dOmcLjus66YJBJ6emse/JJBtUISVcfBekV7Ot/nZklJ2Ev6MUw/lkZEYvFOHDgAG63m+HDh1stvi0sPue8KdgIIbKllJ1v3SeEqJBS1gC1n0lwFhYWFh+ARzfV8HjHa/gcLp48+6uon3C5kdHUROL//QR96RJExShcLy5GnT7j/c9Pajy+YRsA111//ScVpoXF5w5LtLGw+IhMnjWLvcuW4XW5uPfAAVSXi7OGDSP90CF6Dx8mnkiwtb2dOxfdQl1dHcFDCm7dj0GSJ+khFUlSGyTONPIbZhPNGCDs2EXSE2RKWhq9Ay6+6stEO9RAk4R+GSQzEeJRuRIYQTe7uQxJNzZuI0Y5cBHQCvQBi2Ix2oFpqKSgEwa2AzZs5GOwj0HuRQJOxhNnkBgz0VlBkgwgE6jBFFWOR9ILXIZkB4I3kGQAHYBnaF03UAIE0ClG5UC0kf7IfWg0YidEDQaaNEWg84FtQBeQDgygMICDegw6NQ8piR2c6/FwYVxHaN08qb/GMLUYd8zL5gPLmF5xJn9reZQ1vgHGZ6RyptNJ3OFgwOnhnv1bEUYKgzGNYLCe/lAv9KfgTuRRZB+kLVxJamsmT/3xV3w900W/DjfNnk0wkSDT4+HFhgbE3NFsev4VBp01lI0vJTU1nWRZ1ZHOUfF4nDv+717ihzOIyj5mLqjlnPPP+HROPAsLi0+atUKIn0spnwYQQvwAuB54ZzMGCwsLi38TNh/u5Bc7ngWnxlNn3kCG69imvx8HMpkkedffSN72BwDsP/8V9hu/gfiAXTO3P/cUm+u68HtcXHjhhZ9EqBYWn0ss0cbC4iOSn5/P1b/6FTs2bmR2Rwe9r75KZn09U30+HKrKwZZWlEPN3PKVWxg2cRTx7kEc8R4yZZDpSDw4aEOlU4TZ272T2M4+JnbX0IXOaiEYlUjgdzrZqkCXoePDhktKiohQzy5SSaGMLDqJMIYYUxCcgmALBgXA7Zidng6gMwkYBHIBHY1cYCoqYzB4jSiPsZMi7GTSSyWSV4HpmKLMYiANCCF4FRvHkcSBafzQCJRiijW9QB5gw6CHNPbL/ShoTEdjOmb5VAwzI+hGQEFQhooLncUIOlE4KEYw2nMGatoWpsgcwh3tDCNBJQZ1RhM2+xx6+7sIx/oZNWEyuTlJKux28tPTCQQCbFyzg7muElaHgwT0QrQoxGJBCh0jsStpNCcPoibsGINOBtvCGFEvjV0hPL4u8vPzzd+rzYY6opyy745g6/KDxEQ9kcJGbvjGFUd+94cOHSJWn8KJpZcTT0Z57ZU/cvaC+Va2jYXFF4OTgXuEEBcDOcA+YNpnGpGFhYXF+6CtP8K1Sx8j4RjgztlXMCGr8BM7lr5xA/Ef/wBZsx91/pk4fvM7lMIPd7yHHr4HgMsuugiPx/Nxhmlh8bnGEm0svtT09PSw6Lll2GwqZ18w70N3+MnLyyPv/PMxDIP/qa9n+Z49qEJQ0xdk8wAUugtYs3IDB9fVEg8f5hLnOOz6HubiJmL0U4NkdDKFdm0Hfc0dnGJIEnaVW7t76cHAF4/j9PlwBW3Y7aMQyV7cMsA41/m0Ket5JbIJBwncKByHTj0SBTPTJoApvKzHFG+iQCGm0GIDBEl2Y6MIhXT66SLJOgwmAqnAVqAa04nzDKAASReS5SgMYtAM5KASQicTSKJgw0Y/Bk/TxTThI1V2c87Q8SZhZgHtGIqnGxUPTv5AnCZsQCGj1Bsw1Cgxdwa7GpdzJgptio19MkmYBL2RjQxos3lk4/9jyqkFHDxwAG99PYPbtqFFo4RiGmFG0m/PpC7RS57NiySBltQ5KFvoVyvwBwWpE7wozal0xIOUuFKO6gjVpGkUFxczbfp0zjx3gHg8TltbG888sojejhAlI3MZObaUiOwhHOunZ6CNlHSvJdhYWHxBkFK2CSFeBX6K+Xb1Uyll+DMOy8LCwuJdiSV0Ln7mSYLODr41ei7njxj/iRxH9vSQ+O9foj35OKKwCOfDj2ObN/9Dr5dMJnly7RYArv/mzR9XmBYWXwgs0cbiS80TD7yAXj0cTU/wXPwVrv36Fe896V1QFIWzLrmEFfv30+9w0L7tAG6pU9TVzEWGmyR2NmrdrFW28EN7JpF4E14gA0Ez9UyUfhbLVgYUO92GwhnSQRsxHAhOH1ZOdVUd9Ym99GGnRZSRT4hibS/jcFBKnA7gdczsl27My8J7gW8Au4AHgQpgNaYB8NmYYk41GhOAS1AIIvBhtu7+LqAAO4EpwOnAWiCORjYgsfEwGuej48XM4rFh8ChJQmQyiJsC2YECODC/9UhABUJAGGhAowuNDBRORcVFK3u033AwEsDenksiESPF6aFfCqZkZjILG/d1tHFgx60UORUC4TzCPT2s6enhCiE4PiWF1dE+HontJeI6g8di68gVglGuCg7re7FnzGVs4Fp6EnXU9r5EXLSwIhHkKl8ZKSnjkFKyu7OT+owMzp4wAQC/38+WTdtZ9nAVFf45jPFm07r+EAvXr2L83CLWb7wbX6qba79+8Uc6fywsLP59EEIsA9qAsZha9/1CiDVSynd3IrewsLD4jJBScu2zL1NvO8Cc7LH8ZPqpH/8xDAPtiUdJ/Oa/YGAA+83fwf69HyK83o+07ouPPUL3QJRRBTlMm2YlNVpYvBVLtLH4UhMNx8lyZ5HQYkQGm9/XnGAwiKIo+P3+Y+7Py8uj0eGkKNhPJJZkYiRKluImpowi21GBI7STZ40eNsV7qAAy8SBxUkCSZoKUk8I+1YtbD3KGorJV2liYiBM+3Mj8MeXU7j3A6/EEmjKJ2uT/cqO/mMKMkznQvpYc2Y0d+DkwHtNE2AB+DxQBccCLDScSGzpOzHKmUmAeUIUgDYVh6GjADcBEzAybXZgikAfwYgo/XWicypvtwM3Sp8NAO5JRuDhIG30kEcDfgeOHjrcTaAZmAWcCS4GLgVKi+LFTTx9/1PrpjOVQKG2cBRQU5lFUkEdfMIjo6aDcIfhVURFr29o4IRBgC3BXWxsbolHwuAnFwwjaOE5NZbuaS1ycTo+7mgmZw+lJ7md7x/9xWqSbu0+ZTIuAx9as4emnniZr5AgoLOTMSy894l0TDod59akNzCm8GbfDrAlP8WTi60ml9dDr/M+d/2Fl2FhYfPH4q5TyhaHH/UKIWZhZNxYWFhb/lvz6tQ2sjW2izJPHffMv+1g/m0gpMdavI/G732Bs2YwyYybO3/0RZdToj2X9zGATF80qZcbsC6zPVBYW/4Il2lh8qbnoq2fw2N0vYrOrfOWyC95zfHd3N3/8+b2oNsFP/vebbxNuIpEIt/36HqJ9E3ikbSMdvc2UiQIc/mmIiEIw0YZOlMmodCK5FINDRBnATj6wiwHKlXxOcc+hO7mGPq2XUbrOM4bB7X19LEEny+kjalOw22tIRhKE1C7uD+4moWg4dRvZaJQDlwAaZqbN85iZNwY2qrFzKpLtGDyCpB24AEEjNsCNkzg+FE7C4GWgbmhu09BrvBA4hGke7MM0Hh6PWT7Vh1mKNQ64lSbKh8beADgxS62WAO3A1cDlmEJSH+DAoBKF7WgUITgZhVdlM4fsHpLOVAa6wzQbrRwM9rJL07gmGmVLXR11mkZVLEa2EBQ5nShOJ7MDAbbHVDqdAaoTDcyU2SSNtSgodKo7ONxUw/H0MN07jAM7DhEeHGD2QAZPxDvpGKzm64EAB++/n2B7O+deein19fWk6KVHBJs3KUwfwe7DLxAOh486F0KhEOtWrqS5qopATg4zTjuNkpKS9zy/LCws/n14i2Dz5nMN+O/PJhoLCwuLd+fZnQe5r2kJAZuPFxd8DYf68XzNk4aBvvw1krffhrFtKyIrG8ef/4Lt0ss/VnHluNQIj37jVOyX/f5jW9PC4ouCJdpYfCHQNI14PI7b7Ub5AO0M09PTmX3aOPra2qitqcHv9xMIBN5xvK7rSE2gSZ2amhqi0SipqamMGjUKVVV57qmnaH19OSd6htOpBHjZ7SakA4pEOqI0DG6hXA0QVO3sJspjiQGmIuknwsuig+02DwXSAUkbsUQffj3Ms8TQMJgonfT09tGFSr5IJ6LuIKIFebEHbkAgkTyJQQtmHn8SB0vRmILBXGAdcACDEBpP4MBPLpuIk0mUDhIIHCSx48aFSpQOBsjGFH/6MAWXAUwvmghmuVQ1sAW4ALgUs933MmAPMBqz9OpkQAf8mIJODvAUplkxmGVTfkyByY6BAGwo2IF81U5EZPOz0GFmiwS2wX6q0TFUOyuDIVKBdptKWjzO1enpHLDZyBgxguy8PEJ9OznTq1MmsogGq3DbShire3hi/0FSxGQqAHsoj5ZwCy49lzE5uL8chQABAABJREFU08iPPcWMQYVyCWeUlHDH0qX0zJ2LzWZDI/G288GQOlLo2Gz/fCsdGBjg3t/8hnFdXcxPTaWrsZFn16/nzB/+kLLycg4ePEgymWT48OHveq5ZWFh8NgghHsCs5HwvXpBSvvRJx2NhYWHxXuxu6eY/Nj+JYoOF53yNdNdHK1UCkJqG/tILJO74E3L/PkRRMY7f/gHbZVcg3O6PIep/YmgJnK5uIuEcnDb1vSdYWHzJsEQbi881iUSC5YsWsXvZMpR4HBEIMPWsszjx1FPfVbyJx+Ps3buX5ffcw9h4nDKnk5Z4nLueeYbzv/99RowYccx5OTk53PTTi3nu3nvZ+de/UgpsTib5Q0cHvW2d9B86zHibm2FFRVSqOn252ezvD5IRqcYj03FiJ6qrtNo9/GTcxSytWcVToWraFTv1mZP5wfxf8/CL36Yv9AQVspcnkUwGvo9CG0makGxFIyIV8rUQkzHYA2QPxVeC2dpkL4In0DkHG8ORCJL4AInBHOysIcpmEkwmjTxcOBQXWYZOD4M0ImlEQwBZmKVQIzFLmW7H9MR5GTODx4EpyJwJZAw9TwN+h/nmIjHNIEZjllZpwGRMX5wlQ881zPKoryJIIBFAH4L1GGQm2umkmSI5kgYZ4bDRAiQo05ykYyMFG8dpCYJo/LS3F09qKmUFBdzX3EzbYCeKu4AGLcyCjDJ2h9uIGklmGrlsVNzESWMg2k9A5IPuIhQbwBCCgMgiHApjV1U8QpBIJBg2bBhJ30t0hVrIChQcOR9q2rYw+rgi3G43jY2NNDY2UrVjByM7OjitrAyAopQU0vr6eOgvfyVOEZ5oCXbh5EmxjDOunMmcU058P6e6hYXFp8eD73Nc/ScYg4WFhcX7oicc5fJXHiJhi3DXCV9hdEbOR1pPxmJoTz9J8q93IBvqESMrcP7lLtTzzv/ALbzf1/Gk5JtXXcpZw8LMnj73Y1/fwuKLgCXaWHxukVLy2N//Tur27XwzP5+A00lPJMLihx/m5Z4ezrvssnece+8f/8iKxx/nD3PmUJ6bC5jeLeODQZ64806++8c/4nA4jjl3y8qVTGxr49TiYiRw+/LlHFdVgx4xGImPxniYxw4v4ptzTuL7I07huqXL6dWTjNA6abNH6DDiXOE5ieRAnDnlEyjqTbBaZHPBWX+hNKuSgoIxNAbb6MDNKcT5GhIXAg2NF4A2BK1otKCTwPSYeQjTfLgMiCEYhotHiDOcJDHMP/QkoKESRnAOBhEMTqSTBuAZA+YCxbzZ1huWYwo2vZhijB3oB36IKRKdPbRmE/AS8C3MEigHZslTA6aHzUFg/tCcOkzBJjA0rhrTc2ck8BCSvUAP0IrBxTipkAZBdN6glwQBUlUPJ+lxBDqjEQyQ4DlgKjZK7HbWeDzcu2sXwwcGuCI5SHPLenIUN7cNtFBpy6LAMRot3oVTJNljTyE92Y5f0XGoNg4n6qhX3NR4DfIcdh7es4fe0lKys7Ox2Wx85Vvn8cBtj5HZNx6/PYuexGH0nCa+ddlX2bxpKwv/voZsxrJt72YucLRglJQcEQ7zPR52Pvcal5/5Y7KziohGowzGZvHqg09QUlpIeXn5e57rSxcvZ8Pru0lJ93LptedQUFDwrnMsLCw+HFLK1Z91DBYWFhbvB003OP+ZRwnau/jO6PmcPaLyQ68lwwNoDz9I8q6/ITs7UCZNxvFfv0GdNx/xAbLYPyjr16/n7qde4KU0N3XfevgTO46FxeeZT+4v0MLiE6a2tpbEjh0sKC0lMGQYm+HxcFlpKQeWLqWnp+cd5+p2OxPdbkrS0o7aXpSSQmEoxP79+485LxqNcmj9ek4sLEQIwaHeXsJ1DZxjzyHNiIAe4jQhGa4ZbNq+g46+PjzePBZcupDcc+9gyiWP4y47kTpjH7s6VhP0tzBYWUR3VioBdwZdoRZcPQe53DUKIQRzsOPBSRIIIigDdCRtdOMDTsIsOUpgijYFgIINB9MI4uIVVBpx0o9ZspSFzlnoFCEYhVmW1AKciynKLB+6tWJm7FwDbMMUW54G5mBmzlwwNHcWMAJTFNqEWTa1ENOzphQz+6YD+A1mZs1rwEZgJnAeZonVScAFuJiKjYUItiL4Kn7yyGQngmzczKCHlVSTr/fQg4GfJCloZKMwAcFq3SC/fASz5szhnECAjI4uIokkDj3OLiNMvqqQyB5GdmYJnTjoNroo8H6P5xUfjxiN3C8OsKmshPln/4bqUYX8o7OdhrY2RFcXtbW1AFRUVPCT/7uRSVc6yZjTzClfL+JH//UNUlNTWfjAaxyfcw1TSucxrvQ89rfGqGlsREqzwmJfYyMOWyEZ3nx2bN3D+td2sWdtI8GqFFYtW/eO5+mbbN++g7VP1DPFfi1prbO557Yn0DTtPedZWFh8vAghfvFZx2BhYWHxJtc+/yKHqGNu1kR+NOPkD7WG7Okh8X//S+S4CSR+/UtExShcz76Aa/EybPPP/EQFG4D77rsPgMumjcadn/ceoy0svpxYmTYWn1vq9u9njKK8zQTNrqpUAHV1dWRkZBxz7uRZs4hUV6Oqb6+bTReCwcHBY85LJBI4DAPH0LyOUIiMhIGuhchRHfTqcQ5IcAonkYFB/rFzJyllJ5GbWkpB+jAASs6vZGPVEzyz/y4qMn3kjx3LhSNHs2vbwxw8cIgco5tE1jASbVCtxclFkATsSFQghpkRcy1wGmZ50V0ImhGkYRDHySq2MQ4VcPEcMRQgCvwMCCPoQkGi0wikYgov2ZheOJswO0H1YpZHjcXs9OTHzOopB4YBtSjUYOAeGvs3TJ+aesxuU4Ghddsw25CXDu3vGFo3b2jeIDZ6MNAROJCA4FViDGMQL5IXMdg4NGcKZrZPEFAQuLExGtgok6xqbSO6Pkr8YB3lusFVEgqkwWtGgkahs6hzBz2BXlpFIx55iMW9l+BKGY0/eyLp5SpFw4eRUdzHTWNupPuJJ7iipITdHR3sWrOGUaNGEY/HaW1tJTsnk+kzpuLzmabE0WgUPS4IuNNp6jlAS/MGmnqb6FnRTHlZGZOHDWNZdzd5xWdQd/Aw4WYbw1JnIIQg0hFm5ZJnue6mrxzzfHuT9tZO8pxjCLjTCbjT2d+4lMHBQVJSUt51noWFxcfO14Bff9ZBWFhYWPxu1XpWhjYzzFXIfWde8oHnG60tJO/6K9ojD0M0gnrm2dhv+S7qpMmfQLTHJhwO8/RTTwFw+ZzTP7XjWlh83rBEG4vPLarNhiaP7RWpwTEFmTfJy8tjGaaxcG9vL/F4HL/fj9/v55CUnDFUMvWv+P1+1JwcmkMhCgMB8v1+Fho6J2tJBpCc4E5Dakn+kQyT6s8iUFzM6OPHUHtwBxX5x5lruNOIISnOy+CMQABfUxM1jY0EioooGJlC7ZZBpg/UcW2ggAP9DaQZcXzAILAChSAGZw+9xiSmCJKPpAbJY0A3kkoc5CE5BZWxONhMLweA1QjGkMSFID70mnRgFab/TBxYgCnaLMH0sMkEVmCWSo3BFGWKgAmk0EyQDgy6h9bZCNwITBhaywBSANdQnM2YopMcuo8Ag0haMIhicDGwC8Es4Dg8SAZpx8wkqscsqZqBmbGzGh03URpQ2Y1C26Akq7uBsNRZgEEW0IMggGS61FkT7ye9N06xy8tZmTl02nTW57Tznd//lmnTpmKz2Th48CBrV2+kqq2DkYrC/kSC/OJidu/ew5N3L8YVKUDFTlB9hfmXzeSUuSfhcrnILU/hjern6du/iAWKjVh+GelZcLi7m3tCIU797nfZu6KPzvoeMjyVCCGQUhJ1dJBMaGiadpSZ8b9SNqyYtdrrpPfl0hNuIbXA/o4t5y0sLD4aQojQO+3CbJhnYWFh8ZnyUvVB/lr3CilKgBcvuB71A2TDGHW1JP96B9ozT4FhYLvgYuw3fxulYtQnGPGxeeaZZxiMRJg9OofRc87/1I9vYfF5wRJtLD63jB43joVPPcXxuo79LQJNOJHggKoyr6LiHeeWl5czWFjI3196iZlAQAgapWSP14ty7rmUlpYec56iKJxy+eU8c9ttzI/HKUtLQ01L4fbmZmY4A1QZSZYbcRqEgpBxQs3NXHnSJF5pW0V/fQupjgLq+rbR1fAQv587i9zUVABOkJI/vLCEjd1eZg8YjFD68Iscqh2p/D7WwSggHehEYgAeFKIYrMfsxvSmAXADKnEMKhikH51MPLShYwCVwHIkUSAPQSGwCMHxSJr4ZxlTMaYgNAzTlyYVmI0pEK3F7B7Vh51e+hiL2Q68EzPrZw1wEaY4k4FZcrUXU7x5DDNTpxjzjUcd2q6hU4tZMtWJiyIMjkOnjigZSFox/Xbuw2xdfvXQz8I5tF4tOiehsiMWIk4KPrqpRicLwSAqOQh2onESgjZSKNRG4uhIpdCRwN9Ty5pVazn++Fm8tuR1Vj65nyL7FOyu8/ndgZeYeMpkZo4YwT2/fY7pqdeQnmWa+0UTYZY9/CC5+VlUVlZy7Tcv5ftXf4MZkXqkz8fE4ysoLCwwy8daWqg3DCbNLeKFOxZRGtXIMApoim0nEWiluLjoXQVGgMrKSi78VoSNK1eRkuHlqgu/8oG6pFlYWHwg+oGpUsqOf90hhGj69MOxsLCw+Cf7Orr5zvrHsQkbz53zNVJd709L1qv2kLzjT+gvvwhOJ7arvor9GzejFBd/whG/M2+WRl05rQLPxImfWRwWFv/uWKKNxeeWgoICiufN45ElS5iTnk6210tTKMTyYJBZ1157pHzlnbDb7fR6vayKRMgRgnagUdM4vbKSxsZGDMOgqKjobRkQ4ydMwPmf/8m6l1/mhbo60s8/m1XPLSEeitMWiyD0EN9TBLZQiOf2HeC2H/yUPz7xEFu3bKO/Zz+ZzR2c4xtzRLABMz00qzMMPW0UUUiVVsdwRxASIU4ELsQUahJksIY+XkRjAuYl32ZMsaQCKETnRaJswRQ01jCAHzPbxYagBclWYAIGh4EYkjpM4WUiZrZMENMgeDOmp81+TOFGAo9iZsfsQWEAQS0qLeh8C5XFaKQAjUPHS8UsybJjZuC4MVuHh4fGnIXpm7MT0zMnBMRJkoNBAuhFoR1JLmZZ1DLM0qw3haWRmB2pKoBSkmQYksfppRAbLjRqeLODlQ0VSEOlS2oU2aYS00PEIoNUekbwzCOvcd3XrmH5wi3MKbgFt8NLZeEMnlwXYsVTO5DiafLlTNJ9OcTjcTo7OwkEAlT4T2HNa1uorKwkIyODiqJ0rhxTis/lOkpQGZmRwdrdu/nerbfiS3Px9/+9B3+imILCYhxpkgu+evrbSvyOxdRpxzF12nHvOc7CwuIj8zBmM763iTbA459yLBYWFv/GSCnRdR1d13EO+SsC9PX1oes6hmFgGAZSyiOPA4HAkfLmcDhMa2vrMceBedHGPtSxqa2tja5giIteepC4Gub3My8jXUJvby9OpxOv13tUTG9eEDLWvUHyb3eir1gOPh/2m7+D/cavI7Ky+ahIKYnFYgghcLlcADQ1NbFp0yb6+/sJBoNvuz377LOoqsrAwAC7du3C67JxxrjpKI6PvzOVhcUXBUu0sfjcIoTgvMsuY9vw4Sx99VVCXV1klpYy54wzGDNmzLvO7enpQW9o4OennUZ3JEJ/LEaa201TMMgf//d/OXH0aFQh6E9N5fxvfYtAIMCubduIDQ4yrLKSiooKKn74wyPrnXjhhfzP5ZcTjoX4gRCMM2xEhYsodp7btZ9f33ILI9xuDvX00GsYnFRSAoBhGCSTSWpr6hmeMQFHcAVOxUmO6zSqbfW06HHOjCdpRSUbDRsDnI7GamA9gkYk6cAk4BzMkqZCTB8ZJ6bYcRhTNJmLpB6BiqAOiQtJP6bw4cD0mIkBVZhiy0xM4cWLKajYMUunXICdOFl42IhGGTZcSFLQKMds3z0F0wtnENPPJhX4I2aJ01bMy9h1CHYiaUUwFxiNJAedBxHsR8GJAhh4kOwAcode42agFtN0+WrMDCOJJJMkG4C9qFyKwhTMrKBc1UW9HmEzkhGGEz0OCBXD0Gk0DFSbk3A4jMNIwe3wHvmdxqNxFN3B1lX7OWfkmQBs27QbrdtHwt7ImJlFtHT8s4rC5fMRl5LAv2TAhBMJXH4/iqJw9tlnMWXKZDZv2E4yoTF24omMGvXppyNbWFi8M1LK//cu+378acZiYWFxNMFgkIULFzI4OIimaSSTSZLJJJqm8aMf/QiPxwPA3/72N/bu3XvU/jfvp06dyo9/bP4pt7W1cckll6Bp2jFv9913HyeeeCIA//3f/82tt9561H5d1wEoKSmhvr7+SJwjRox4x4YYv/nNb/jZz34GwNKlS7nooove8fV2dHSQnW2KK9dccw2vvfbakX1f4S9HHi9YsIDnn38eMEWTkqHPmQIzs1kVAsVmQwkneH7aTE4bEmx+97vfcfvtt6MoCoqioKrqkccFBQWsXv3PZnpz5swhGAwCEAqFjogwyWSSW2+9le9///sArF27liuvvPIdX1MoFCItLQ2/38/UMcOZkqcRKJ/2juMtLCws0cbic46u6zQebiekZzF23gzmnzX3fZWNJJNJnJgmsv0t7UTDMZQ0Ly/vreLsZJLLh/7ZNfT385f//E9S3W5mCEGmqrL2pZfYdcIJXHLddUeO5XK5seWOJtixA13G6caGx55NmmInGG1m2sGDSLebBfE4uzo7ubuuDm3CJMINPaDbaOtowa6mowfyWBcO0RM8hEaMgJGkEJVWYWePVMjCho0kPnQygBMwxRYds6SpBlPYCGN2hYohmIikAfgDkIHEC5yORGCaA4cwPWiah342ZZjdn7oxLzOPwRQ/UjB9akowM2bKSdKMYB8xXsA0Ct4HjAPuHorHObTWgqEYxdAag4ADSSkwA4kH6EFBw2AEkkfR+QoSiYNNJDiAZDLwHHAYQSaSGUOx9Q2tl4NplnwAG/+HzlR0PEh26UH22P0cTMJw4afNeBXFyKBW1djhNrjxh9+kuLiY3kQDB+qrGFFiCn7doTYml8yjwbaKjnAdw5lAbDBOurOUnmSIlt5aSibnHDmnJsydy9rHH+f8srIjmTNSSt7o7mbCeecdGZeXl8d5F5z1nueohYXFZ48QIiClDL15/1nHY2HxZef73/8+999//zH3feMb3zgi2rz88su8+uqrxxz31u6LmqbxxhtvvOPxwuHwkceJROKIaPFW3hQ63kp6ejpgltULIY4IIYqiHOVJ5/f7GTFixNvGvPk5wuFwHBlbm4ihZgRwYifF4TiS4aPr+pHscqOzg9jf/jJ02cvMktbA9IBMJiGZPNLZEkwBpb29/T1/TgC7d++mt7f3beMcDgeJROLI82HDhnHBBReQkpJy1C01NZWUlBTc7n+Wcz317TMJGG3I42YfMwYLCwsTS7Sx+FyzasVa9i6KMCZ7ARueWkJ23naOO+69S0iys7NpUxRefHUDpWoZLjWTDQfqGehoYOyJs46MK/T78bz6KiPHjaMsP58sj4epdjsPrF1L1bRplJWVkUwmeeYfyzhv3J9Z0voML3b8ndO0QfRYHc8JhV7FTXQwwXyHg2np6RTpOuGGRu5/eSmn2nJRbAX49NG8kKwibB9guDC4Qg+SaVP5L2kKFuVSpw8fBip9xOgAnOgsR7AASR+mQNIFrEQgkMxHZSR2OonRh8ICDNYBESR2zLKiJszMmVzMzJVHMDNsvMAizDYpdsw3ChtmhosDMxPnABreofKlNMzypRpgPXAJpofOU0M/x4yh7QcBFYULMIhglnUpQ/sTGDhRmYhkJ/AQkm4UBCehs4kIMfpRSeDhEBFq0ajAFKjcmCJVFlBLnEHs1KNwEIM9QjC8+Hi8WikvNr3AaGOQDg5RpQT45g9+yleuvpKlS5ZQu+YVNkaXMWfmDXgzbEyan0dJWZJzxlzFaws3UNu+i7HHjeTQ/kY8vhhd7m1cetplgCn+TZ4+nYVVVTyyZw8TPR4MKdkeiaBOncr0Wf88pywsLD5XrAImv+XewsLiMyISifD0008D8PWvfx2Xy4XNZsNut2Oz2Y4SA775zW9yzjnnHLXfbrdjt9spKCg4Mi47O5s1a9Zgs9mOecvPzz8y9qc//Sk/+MEPjtqvquoxS5wPHDjwvl7TvHnz3tfY37/xBvGrZ3K87TJWXnnT20Qifc9u4t/+FtoLCylIJBi86jJsN9wEs2ZjGMZRpVpv/Tn99Kc/5ZZbbnnbGMMw3naMlStXomkaUkr8fv8RMebNsqg3mT59OgsXLnzH1yLjIWRLFbK7hjRHB6FGL2mFOe843sLCwhJtLD7n9HT2k+MeToY/j7TuUnp7+t/XPEVRCKvZrNJDnKLayRAKB6SDAXwY4p81tcFgEHVggNW7djFYW0unzcZ506dTEArxh//8P9JSKqhv30cgXInL0YU/PJEDMo+VHMCLh0o1QIfdx8HeLgxVUtPew+7BEErUoFP106p6aYnV0aB6aFFGMT6+AV2NYHic9AtJQIM3gE0IhtGPBPYAczC9ZzQEfwOyEbyKSgsGEoUMkkw50ircvMqyB4V6DLzASkwBphlTNFmM2SVKYpoNXwicCbyAaUhcgynUXD807iDgRLIG2I2ZnXMKZqvvpYAPGMA0MF4FrAMKURiGwjo07sMUi2oxTYzPwhSK8jHLn0oxmILCa8BBkuTiJE6MODpuYkzAz7300TEUXwzoRCEfswbcgU4PsMAZoEeFQEUFlanzqHnjIJXdXeSqPjxF09m8ci9rp6+jdt8+jhN2dvns5MwOcfrppzNu3Dh279xJd0cHX/v+Jbz45Gsc2NePUmwjkK9y3dXnUlRURENDA3//3RNIA6793gJic+eyf+tWhKoy9bjjqKysfE+jYQsLi3973tt4ysLC4hPF4/FQXV3N66+/zjXXXPOuY88555z3tabT6eSEE05438d/M5Pn0+SVAwe4s2YxKaTz8sXXHhFTpK6jv/YqyXvuwtiwDjxe01z4+htQhg1/X2u/2Tn1/TB+/PgPFLeRSKL1DZDsaIau/YiBw9i0VmzqgLlfFwy2KsTsk96Xt5+FxZcZS7Sx+Fwz7fiJ3LN2IT2Nh2lXduHfl8lf1qwkvaiIWfPnv2MXqL6+PpyJTAonn8LCTX/C0BKUj7kU3eGlsaWdCRPNcb0DA2wfGOBPhYXkSEltMMRdL79MLtmQMwu1pZ6xA/3saHmBAXuMDMdkhtnzOVcMR+h+3pC1KCLJlkSQWxt6OFX46de87Jc6Z3hOJMefSc1ADQl5KurgToIigU11sk2TVCXDXC68xIXCXiPE65gCxTnAVMxyooeRjEPiw0uSBI0oBLHRgcJ/IZiBRhQPrUTQUMjHSRM6cxCUYnAhOqswxZOLMUWb+4FNmKVHszBFFx2zDKseUwAKY5ZPHcLsKjUbU6jJxhRQ9gLHY3afasT0uCnCYDsGUaAXMysoY2itx4HjUNiJny5iTMTOSGxk4uA3bOdkBBVIioEVJFlDPwaCN4B+JJUIMoC9CIJIsoFu7AQNBylug5LyJO2sYF2ylm3JPnxiJKNiE2k/vJnX7jxMt7ODgqvPYmxUp2eXi1cja6isrOT5O+5AtLbSfd11XPSVs/B4POi6Tnp6+pEPGPv3HSAjPJlkXOP5hS8z59QTOOvyy/F6vWiaRm1tLaqqMmzYMOtDiYWFhYWFxUegqKjoPQWbLxI1Xd3cvPYxbNLBwnOvI+ByIQdCaE88RvLee5CNDYiCQhy//DW2K76CGDI4/qSQuo4ejpLsHSDZG0TrDZHsDZn3PeZjoj043X2406P4CgzcqWY5lp6AwVaFaI+XWCQVXc3Enp5GzpWnf6IxW1h8EbBEG4vPNeXl5fzgf65h+/btbHmimQl7OyhNTaVlxw4Wbt7M2f/xH1Qcw+jVbreT0KMcqn6aH2WOJqYneaZrL+VjLuepff+Dq6EBFVjZ10dqVhbh9g4GuuPYDS+9iSBVrixGOxu5KaeSpMNPSXMLexJVRFPGczDUz+vaAWrppUIfJD9qJyJ8iILvsSJ+kJ6BNtribYyMhsDhIBmoxB/JIKbUcoHNyWQFiEWokxobGWQMTmJIZmOKIglM75hUDFyAQOUQMUYgWIBgAB/1ZPIGsJFG/EicKFyMEx86GzHYjWAYDrqIswuDGZjeNjpmh6YHge0oJDDIAkajEkDnRczOTa2YGTIOTJPhqZhizU7ebC1uZuCMB07F9JpZgynsTOKfLbufH/p9uIAITvy4mYcbCTgIYUOQgkYmNnJQSEMyFUkVAhcFCLrZQJw6VPxoNCGI4ecFwlQiqdYG8dg8vLF8Oba2bm7QnSiaxoDSxoGeP5H0jcdWOxZ7wse2lhe49PpzqGrpJxEbQErJABDp62P0K6/wxGuvceKNNzJ1xoyjzqWJk8bz0lN/onrHIU6Q57Oipo3X8tZz84+v4cWHH0bu3ElcSvacfjrnX3HFRzjbLSwsLCwsvpwEg0H8Q6b+XxZCsRgXLPoHGhp3zb6GkdEw8Z/fivbEYxAOo0ybjuPnv0I94yyE7b2/0hmJJPpgDCMSQw9H0Qej6IMx8z78z8fGW7cfuY9iDMYwYol/WVXiSJH4SwUppQJPeRK7O2keTzrQlEJivhJEZgVq/khS0lNJtVnZxxYWHxRLtLH43JOVlUVHTQ3nuFxMyM0FINvrJdDby9KnnmLkL37xtgwHv9/PsIk5bNi4Hp8nC7tQ0eL9xG0hLvzlT7EFvBiGwSV5efz9O99l+fpdVCjZdKJTjZuAPpuyvhpc+XYGtRg2esnWo7weegqbfSIbkouYhEYAlUwpmEwmB3t3YM87jz6tmon2MSxOLKGY0VRknsSKuvvJFW3scHlZHWpAIskClmCwgShBzNKjfZg+NHswRY8I0I6OFxhFOnkkKWGAIgaIYcNDMTHCnEYvbhQKEaSgswydduJ0o+BDIY5BDgZJbAQxOB8DF4JWBN1IQkjaEaQjcWC2B7dhCkhNmCbH1w49rwbyUZiNQTpmJs4AZpaQHzNTqBooGtr+FJCKF4GTdDqpx046TnqJsYMkbpwUIoAo/QiWoxBEYEfDTj4N9NKBgzQilCDw4MCB4FKS+LBzaCDGoXA9P/ZkMs6RR2/SQafLYIwrhdcHg7jz/UxJPZ+Wlp2EBvq56EdTUFWVZ59+mqnJJJedeSZCCPpjMe6+7z5GjRlzVCpxdnY2Kb5Ubj79djL8eUgpWbbjCX79i/+lsLORH4wejS4lf1y2jMHzziORSHDw4EFUVaWysvKo2nILC4t/W+R7D7GwsPikuPnmm9m4ceNR3Zw+70hdP1ocCf9TMEmGI1zQtZWgPci1XcWM/fHvaaivR6o2GHs2onw4+AMYG9qQa+5CJjWMpIZMasik/i/PNYx4EpnU3jMmxeVA8bpQvS5Unxub34Ez14/N50TxOFA9DmxeBZdnALvaiZpoRiTNciecAcioRGRWQOZI1EABNvHlEdksLD5JLNHG4gtBy759XJyRcdS28rQ0eg8fRtM07Hb72+Zcdf3F7N2xk19sXIUqPDhHjGHYHBvnnHsWtqErFvF4nLB/BIvcfVTbhtMmDaTSgzQ6aRnoIRTp5XDrPvTEAINC0mu0MzYwj1y9iRMSKayTK0hTwmQaQRKDq1hRu4ZUm4seUUxxxinURpbTsvd3pBiQJyO0hBRSkORjCjK5mB2iHsX0hTkB85tDFPOPtxz4JjY8GKyknz1IZiIoG8qe2UA9ETQycbAFnfUkKERnJPAqEhWN2UAYO7dikIHGWKAOWITObOBEwInBOgSbMcuexmF2kxqGKcrcBfxgaFsPEMOgC7MsqgbTV2cA+OpQ/O2YZVMG4MNPL5Kt9FGApACdPmLEsNGPmxQc7MaOhwT7iTMJwTDgIH0kgBGk0ouDmWSQzQBlxDmEjRHo1MkIvXGVDI+DUX47HV212GxuRngL2TTYxwxHETsGNpLrGUG6vYRDBw+xf89h6tZupr+3hbOVOG1eH/n5eaS6XGQYBn19ffj9furq6njpyddxulX6uoOkj8xFSslra15mzfZVhJU2sm1VnO12k5qVhXQ66ezs5Nlbb6UiHCYmJW8UFXH9T35ypOuDhYXFvx3iX+4tLCw+ZXp6enjmmWdIJBIUFRV91uEcEyOWYLD6EInOLmQkjBGJYEQHkdEIMh5DJqLIRAyScaQWBy0BUkOxgWKTCBvmY9V8/ANvHg2+BCcFA/zAuR1OlgilFFQFoUhQas0Lkoo4+l5wjG0CFBuKakeoIIQERSKEeTM/jRkIaYCMgDEAUn/3FxwDXKmQ86ZIUwG+XKsM3MLiE8ISbSy+EASysugaGKD4LbW8fbEYjkDgiADzr6SkpPCXh+6gqqqKgYEBysvLycvLO2pMd3c3JRkTcYwZTnroOLT+1zg5uQEZbeUlo4nUqigVxhgiio1tRgRDT6cr2Moow4VTcVEmPSgkKaOXEnRSCVBo6CxSaoiEwsS1CGNkCjNECqPlYdYRJRO4AdMkeCtmVk0hMBz4CqYxcQWwC5iNYBh2fCSwo/M0cAhJEabnzFSibAOeJ8mZmF2WNmCKMlOQvNk/IQWN/KFMmnWYXZimYYozlUNrjUBlGxrjgdGYLbYzMNuCT8Qsl0rHFJIOYoozuwAPcBWmN84TmNk44zHffLaiIIlTiMZVqBxCYy8q69GpwMZ3RR73yiA2KqmiHkkLCpLRKKSgUaWkM98Is5B2ehFciQ9wswONlYTR0VmHjojEiXR2kuew0x8PE01GsNtcDCQHaAyux5Aq1QPLcG8Ko9Q0cbGSTpPmJBjrZNXilZx/5fkkFYUeIUhNTcUwDO778zOMkufTH+mgu2899V17SbUXsG3vGnKT00lz5LM1+leufmkN006axE2//hWrX3iB03Wd8UNeS6/W17N+1SrmnX32+znNLSwsPn0u/Zd7CwuLT5mHHnqIeDzO/PnzKSsr+9SPLw0NYkGI9Q/dBzHCPWhtTej9nRALoqpxPG6JV8EUTrxDt/d7DGyg2JEo3NnjZZVIUBYOcJ+jCnt2FiI9HZQ3F+ef9+Itj8EUaDjWNgGKCkI17xUVUyl6h22Kinhzu1DfVJTMxzYHpJaBN8sSaSwsPiUs0cbiC8H0s89m8Z13cqnDQZrbzUA8zkutrUy7+up3/YeiKMq7uuF7vV7iDHD6tMtZsuFJWptXc4bDTUTpwTMgWK6PYbOAbpuHhG5DjfWwQz7FIIMEcOCwK+QbPnJElPVSIQeNMYqLOiFocHbgSyY4XwmQMBpwYdCP2VO2GbOUqBDTZ2YdMANTAGkBrsT0jClEECWJho5zaOx+TH+a/ZgZLvrQOtMA15Bh70+RnISTqdh5jDAqEj92diNxoVGJaUT8poATAXajUYqCZ6hDUy1m56lWTLGmCNO/phK4D1O8WY+ZqdMJTMcUnOqHXkcXsBaDGSTYgaAGjVNR8GEQxmw9rhMiA5UAA0zFz058JNDwAM0k8Rm15KGRjZm904NKNkXEGGQ3OpkIRmNjG0lq4hrTFZU0RbIt1Eyy5CTWNm1jbDIH2fMy2Uof+7s9nOoeS5prFCVOF8v1tSzqqiW2ezfBnBxOvP56AoEAmqaRiGqkZ+ZiSJ2JU8bQEFvKzkOSuvAGJopR5HoqKJXHU5h+LT5vO0lNJ9zdjRqL0dTURHZ2NjlOJ/X9/e96bltYWHw2CCHOxmyuh5Ty/fXvtbCw+FiRUnLPPfcAcNNNN33860d6IdJ9RJCRbwoz8beINInwMSYCEZARBUN4MLzZGIE8bGkZCJcHxe1BOFygOoZu9n/eK2997kAKFda/QfL+e1l9oJrbrj0Nf9TLwlHTcM79qSWMWFhYWKKNxReDKVOnEr3uOu559llcXV1EHQ6mXHYZJ5566kdaNzU1lZFTcmnZdoBLT7mZ13ySmuaNKDGNbqLM8F3NwcHHKQ1uY4YRBTQ2INkpCllKkEk6pNr8LJeCoExwCgm8MkK+1NgXVfHqEqcRJ1sI0tGJYV4bycL840wC/Zj+NUnMrk4RTEEmCziMwXAkuTioJUErMIgp/NyA6YFzCLPF9z5M4+AwUIxgA3bGksAGPIVgLpImFAoxy6/GgGnGjCnK9AEJFGIIoujowEbMLBwvZmlU8i3x60AJZrbNDEyRpxzTjHgzprA0D/Nzz24ky1FZik4pZrvxJDH2y3bq8DBL8ZMlE1TLBPcTZg2CYRhciw0dwXIcVCJYRIhyWihhgNNQyMFNv2JHGiEWGRrRuCDT46DdobK6exsz3TayHf0MF4LLbZn8qKWH5tBWupO97BICvz2PfUaE8ilTueqqK6ioqADAZrNx0XXzePaBO3F7HVx/wyXk5OSwfPly9uyswKHHqZWLKHSPZVhZKTmZk1i1eBm6w81jq6uZ5yul2ltPXVkOM45hlG1hYfFvwWXA7UKIhcADUsp9n3VAFhZfNlavXk1NTQ35+fmc/TFkpcpkFLr2ITv3QmcVDHYdPUCo4EpB2v1oMSeJvgyirU6iTQMkwwI9rmLLL8Y9ugLfhJF4x5Sjup0fLpaBENrTD5J88D7kwQO0FBfxzRvORTVUHjnnBrKLcz7y67WwsPhiYIk2Fl8IhBCcMGcOM2bPJhQK4ff7cTgc7zpHSsm+fftwuVyUl5e/47hLr17AfQOPs2b/fjIKhrPf1s6g3U5WZx4tjRvJD63iFsNODgZu3Mymnz/KFjarUzmkt/N6sotTUDgVQY6AmJ6kTgVd0yi0qaxNxCmTgiiSBqAKwWSgSUCblGwB4phlRXFMgWQpcAUqj6EPlUMpLETgQHIGpoDShplp48Fs070FmItgCwqF6GwgyQ/RkCicBLhwkMRAxxRiOjHLqSZjlkMdwvSr2Y2CEx3/UEz9wArg65i+NTHgMKb/zh5M0+F6zEwYD5AGnIxZWlWDKe7YgEp0IkAQeBhT0NmNQQ5Rtss+cmSMeqKcj0Gn+VvnRSEJIhgmVVLx00c3W+jheCAFFxp2dOnhBBSesce5B0mWw0nx9GnEWls5b8IEmquqGOfIYtuBOqYA6cJGcaKbCgnPJDrRXKOp3dnCfS0vEsh2ctYlJzF5yiRmzJrG1OlTUBTlyFWw3NxcTph6Gq7uEcQiCTJyUxg9ZiQ6Sara+yksK6C57Dye7q2ltbeZy755BpOmTHnX89TCwuKzQUp5lRAiAFwOPCBM84cHgCeklAOfbXQWFl8O7r77bgCuv/76dyx3fzekNKC/ATqqTKGmt870a1GdkDUaMWwu+PLQNTuDB3sY2NNCeFct0UOtICXCbsNbWYpv8gjSJwzHW1mG4nr3z5fvhVGzn+QD96E98xQMhlEmTka//S9cHm8hkeznv8ZewnGWYGNhYfEWLNHG4guF3W4n418Mid+JrVu2sPnOO4nbbCz4+c/fJtwYhsHalSvZ/uqrJBMJhs8YTdFwP70L/aQPXkxV91Z2dT7Mj3QVt7AjZByNGD7gZNxEXGNI40fsiP6ZXjZRq6jU6gmqkDRKlbN8XoKKoDgZIiphMyptqCwUCq+jkyFAQ+J0+JDxIABzMcWP+4AnhjJz9gPrMJiJShcaMzC9cLZimv36Mb9xPAyoGFQOmQS/RpICYBIGY4A84qShsBrTYDgLUyCyY7bwzgIq0FgCuBEYSNyYAk89sBazJfnfMDN1ajHfYEZhCkg+4DTMUq0VmP48ZcASzIyeM4AJQzE/NLTe+YCCzh7ZwePYmIuDk4AYCSIovCjtXKtmsk/24JQx7NJBBA9NDNCDhg0Fn5pNuwhTkhIgmJ7DzBtP42s3Xsdjf/4zWmcnabm5NDU0ENTixFSBTTrpE8OJKj7KtXrWa40sGH4fuamldIVaeOr2Z7H/yM64cWNR1aPbVubk5JDwbOTkEy47Kp25ufMARSNyGDt5BM27ovjyzyU3v47zL7nESnu2sPg3RkoZGsq0cQPfxXxb+pEQ4g4p5Z2faXAWFl9wEokEmzZtQlEUvva1r73veTLaB51VyI690FX9z/Km1BJk6akkKSAW8pJo6iO2oZPBqs3EDrcBIJx2vGPKybvmTHwTRuAZXYLieHsziw+K1DT0VxeTfOA+jHVrwenEdu752K69HmXSZC5+6UE6Ij0syJjDddPHfeTjWVhYfLGwRBuLLy3xWAyPZrY/jMfjb9u/etkyGh59lCtzc3G43axcv55V+2rIjc7nuPLTmVAwjwO7HyM22ENMphIjgg1JAjvpahqajJDiT6fMVUlqvJ1dyWb8vuHk2OEGDBR7iEf6ujFUD6UadKGRmnIRo3LnEbKvoKd9OcPjIepjUWZhetgEgZGY4sgWoBfIwMZp2JiGgxeJ0kaCNMBAIoCpmKbBk4HjUbAj2YjCJJzsIcZhTB+aLnSqkcSBxzG9c44DXsFs6z0Rsz33CcBFSKowS62OAyZhlkYxtFYxppdNF/A88A1MI+IszB4F+4GXh16TwCzFGjG0XhpmedQzKIzDRScJ5qDRgcYhNM5BpQ0FF5IAOl2KhgM3ZTJGFX6meCtZFdyIhs4kdAZscXZI6EkESRjg0uN0d3dzyqWX8o8f/Qdlbb3EgoNsSiQo9bgJqHnki1HYpIu2UAcFmdnkppYCkBUoYIJ+Dq+98Brjxo192zlTVFREySQ/m7cvYkLhqThtbtr769kXeZUbzzmPYcOGkZGVRn9/P2PHnoLT+eFSqi0sLD55hBDnANdh6tiPANOklJ1CCA9mxakl2lhYfII4HA4OHDjA5s2bKS4ufsdxUk9A9wFkZxV0VMFAKwAGbmLRDAY78xk4ZBBp6EcPvXHUXNXnxjOqhLRTjzNFmopiFPvH9/VIdnWSfPRhtEceRLa2IgoKsf/sl9ivuAoxdJHxv9YtZWNvDaOo5M/nnPaxHdvCwuKLgyXaWHzhMAyDXbt20d8fpKSk+B1Ln2bMmgWA0+Vi1L/4ikgp2bxoETfm55PmdgNwTmkpy9auJ6P4XFp669iwZxlCTWWbrYex+iCZ9gI04jg0hfXoOG2TsTsV0rxjCSSrmO62MzJ1NgORLmKtW8hSFQYdaahphbzY10PYNZIFFb+lObSPXlnE7Ju+SVdLDT0LFzJG18gzDIKYXjDVmBkrs3DyFCkcBgroB5I8h2AuBgKzBGktZgnSFqBzyOw4F4M84uRjMAtTWCkFLsXAwPScOQz8GlP0+S3/9LcpA14dWrMPM8tmytB9CqaoVIKZodMBBIAdQ2N3Ywo6Jw3tj2OWXuVhijX60OuLAlEc2MhEp41hwChUqlF5FQcJkmzGgd+eySERRdFCrHOqxFWDs3MzmZ4zl6frNvIHPYpdC5MmYpyYksUFUyvQ6ur4xy3fptGVRaS5hLB3BvbhOl2e17h6eAB/OE7j3q3YpJeDrk5mHve9o86NnJRitjX8Sw38EEIIrrnpMha9sJTly2+jvraFWDLMrHkTyc01W2FWVlYec66FhcW/HRcDf5JSrnnrRillRAhx3WcUk4XFlwqbzcasoc9rb5LsDZE4XA3te1Aih7ArXSiKgaHDYIvCQKOdgQaVWA8IewhHjoojL5O0k8tx5GXiyMvAOXRv83s+9pillBjbtpC8/170l1+EZBL15DnYfvsH1LnzEG/J0n2pdg//qFlJWiKPp668BJuqfOzxWFhYfP6xRBuLLxRSSh69/2nqVsdIVYt5lRe5+FsnctzUt/uG2Gw2Zp944juulYhG8bylhbgqBDlpAXb3LmZwm5dK+3mMTReEnP9g4UAzU0QPaa4MlvS3s00ZyURXBXYvgM5GMcjM0UV0tVWTQCfoiLMpHkd15RFLhikTIdKSh3h6+3RGCjs2EWHdy4UYA3FELEmNYRwx+k3F7No0CgUvLsKEeAmdXnTGYyOK5D4MzgDygW2YGSznYnrInIRpDPwcOg5MsaUNs3RJx8yqacEUWeKY2TF1mGVWLkxj4a9htiBvxSyDehlTIEoOjZmIaV58aCje6ZiCzr2Y9QUzMQWcDkwRqBUz+6YEs/zrRcCGA5UMNLo4SJKaIfebFdjoFMMZkXYlh/q30mcspQ+Nr6uZlGtR2gYOEnBmcnJ+IYdEH4UuLz8YNYmRI4ahOp3cvWQZwcYuqqMG80ufpqZrJYZnkHT3DO5pXM0Nk0dTkJvB7v5+6lqGMW/EmUedF12hZnIL3rkEz+VycdFl5yGlxBspY1LBPOoO7+CJB5/jhpuvfsd5FhYW/x4IIYQ0ebc/2BWfWkAWFl9C6uvr8fl8ZGZmHrV9YO0a7Icewh2QAMRCgr5OD/FYJrqrGEduNu7TMkgdEmXsGSmIT0kIkZEI2gsL0R64D2PPbvD7sV1zHfZrrkcZNvxt4/f3dvDttU/hSPp46MwryfC7PpU4LSwsPn9Yoo3FF4qOjg6q13VwWtnNqIpKb7iSRU89fkzR5t0QQlAxaxZr1q5lbnExQgh2d3SQMW4cJN20NeUg3HFmj5lHn17A7l2P8Fj7RvDE6fLnEo8G2KU/htrhJNWfgZE1gieSISZX5EEwyKpkgKq2frzRRr6dXsLoUQt4tWUblYleMoQfmzKajfuq6cGg0D6N9cl1HERHYgodo4BU3KzCIBWN6WSQTowDRIij0YSZsZIJLAD2AtkINCSrgX1IWjBFkpcwS5Q2YpZFZWK2TCkFXgc2YPrjFAz9bHKGHkeAwzjYi84gOnVDcdVi1hJ4MH1sRmF2tCobOp5t6DgVQ8eoAsZhCjW9mObGGuBggHvYTwEKb2CjCjceppDDXHJEmFB8Dx6RRVKcSkIsJ+jwkOdMoS08gEfNZmM8hrO8iDM9ToYPK8Pn83H/unV4Djdzs7uAQOgwWzrvoIBzKUhOwumJsUyrwX3llYS6u5lRVkZq1WF2r36dKUVn4rJ76B/sYlfPK1zy1ePf8xxqPNjB2NyzSfVmMdZxAiur//yBzkELC4vPjJVDPjYvSikb39wohHAAs4GvYiYePvjZhGdh8cXnRz/6ES+99BJPPPEEF1xwwZHtevVi3OmSWMppKMWTcBWV43F+NGPgj4oMBkne/w+S/7gLensRoytx/P42bBdehPD6jjmnLx7hokX3YugKvxp/IZOLM485zsLCwgIs0cbiC4au66jYUYR5VcVhc6FH9Q+11pmXXMKTPT3cXl2NQwiSeXlc+o1vcN+fn+aMeeeQ4nnzH2wZ48pPZVnN/Zx+00jmzp3L4488yer7W5mQeQZuj4v2lm52NCxiuXIAI5iOnhjFSZnTGWj8M0pMx25zEonFmWrLJxIPk1AUso0A7TJCY3IPcXTCmFkvTqANFwexkUUSHzo19DMJB51IJAKBZBlm2VIjMAdIQ7II03NmLPASgvPw0EyEi5Akh8amYZZHFWCWLV0JLMM0Jd6PmWGzeuiVr0TjdCS9QBwHe7ERJ879GGQiSQcuwcz0acIUhJpRyMZgNKbnzeOoePDSxiD56IwcWrsLSStxVgI7CeCkgHQCdPECxxshygeD1Ao3B21nEmMiW/Py2RHpQetoo61/H91GOr5aF73eGG90bMfpF2zcV83XEgopLoOpdierwnsozvgfhGZHSQry0kqYMGnSETPrSZMn85JvCStfvwNFc2EPaJxz02wmTpzwnudPaUUeNa9sxu2YQ23ndkon5H2Is9DCwuIzYD6ml80TQohyzMRDF2aV6GuYJVM7P7vwLCy+2LS3t/PCCy8gpWT69OlHtid7+nD7uohr+XhPufwzjNBEdneTvOfvJB+4FwYGUOfOw/7NW1BmznrXJgOaoXPpogfo18JclH4618wc/SlGbWFh8XnEEm0svlDk5uaSVaGyed8isjylHApv4oTLJ32otXw+H9f/8Id0dnaiaRp5eXkoikJOYTo9e9veItqY4pDDJxk1ahRCCPZvb+bs6dej6A42rtpFBsOZoF7Jc2t/RtnwDEYHziLHPYKdPY8SjTRwqH03uWSyItFICRp+m5edyUxqjN346GMOZueoYsy22yuJsZ4E5wLjkcTReYowU5BMxRRVmjGzYuZgZrEIzPKn12FIZFF4ENOzJgE8g1n2dBymZ84TmKLPmybGm4eOrwzdvAh82PGRBCSdJBlAwYubSiStDFKLaV6sArUIOnFRhin+ZOBAYKMbjR14SUejnwguGMquUVBRGY+TbgYoVhqYZCSopZ0sspiMnXHSzq36CgLecVxy+h9ZsvEOqpq3kx2JMV7Y2BgL8fqAhtvhJcNeSoFnOA2RVhx9nRx0qug2B9sGHyNLjCLgSlI+PptAIHDk92q327nw0nM5e8HpRCIRAoHA2zpGvRNnLzideOxltu6+n6Ljsrn4qgvee5KFhcVnjpQyhtkI729CCDum3hyVUvZ/poFZWHxJeOCBB9A0jfPOO4+CgoIj28MrFpHikVA25zOMDozWFpJ//wvaow9DLIZ69rnYv/N91LHvr+vTD1e/QHWoibHGJH5/7juX6VtYWFi8iSXaWHyhUFWVm75zNSuXr6Gncz9njR7HjJnT3nWOpmns2bOHvdtrUW0KE6aOZtSoUSiKghCCnJwcAJqamnj1xVVsWb+Lpj2rmV95E+NHTUE3NHY3ryZvjJPCwkIA4tEELp+H5tZW6A/QH40zGEtij6XR3dmFL7CTfFGJFqikStvNSRkK2YabPXom24UHt+Em3fFtktGbcAM3YPrD9GGWRw0DtmMQwxRcBtE5G4VyoBSdYuB+THFmHXALpldMJvAH4AB56PQxGpXtSGZhZt+swcy0yQYkZlZNA2Zb7/WYHZ7uB64C/EimEmfDUGwVSOLEmYMNA4NMBOuQLMVOHoLReBnARyMSAx/PM8ghuhmFk9OYSisxXmYlGhIvChqCm3GQIhIYUueQ1066JqmMQj+Z1NFDlH7sOBkz/DjW77iftD2P8+1kmCZcdJHDD5QJ/Elfz4bBEKd4BBVGLsvo555EJ62qlyvP/AWra54hmFLL6BMmc+WNX8Vuf3trT6fT+YE7PTmdTq746kUfaI6FhcVnjxDCBXwd8y1wN3C/lFL7bKOysPhyYBgG//jHPwD4+te/fmS7lBLatqLnKjjGfTZCh1F/mORfbkd76gmQEtuFF2O/5bsow0e87zUe2LuBZ+u3kBkt4eGrzsNhs4yHLSws3htLtLH4wuF2uznznNPf19h4PM49dzxMT5WTQvcEDKnz+Ip1jDhhF1dde8mRrIqmpib++t9PMlw5jQvLLmK3spZXtv2NjR1pFJZnUzmjiIuvvPxIOuy4acM5sGEbsT4XoR6dYt8o9iVeJ6oHifUlyBznZkfvQwymhqhXM6E0j4PRepzeWUxULkaL2GhrayVCknRgJ2ZHpQim/0sHZtaLgUKqw0FjIsZUdHQUkgicSAoxvWR2YWa6DAI52AgAFzGWCGEeZRunAuMxy6Ekprvmm/22+jGzatYCp2J60izD9KEZxDQqPogp5pwA7EIyEY0uNEYCEQQamVSQRRZ9lGFnC01E6aAEg0IknThwUsM4JNV4uAINOzYeIoiXGH4EOcA6I0FHSpJVsSSzZQsOVwF9eoAOZ5gppSVUrfoVl4b7KMNLCTaekV0IzaDQVspmJU51tIOSlHLc2WeTK4ah6dvZF13C//7je0yePOldU5ktLCy+VDyE6au+FjgTGAN85zONyMLiS8KyZcs4fPgwpaWlzJs378j26IHD+LIHSNqHY1fffnHlk8TYv4/EnX9Gf34h2O3YrvgK9m99G+Vd2pAfiw1th/jl5pdxRdO574xLyA5YxsMWFhbvD0u0sfhSs2rFWgb2ZHJS2YIjX9qHGRNYvfoRdkzcyXHHmQbGS19azTAxl+G5EwGYOnwe40pO4OVDv+WWX11O8Vv+cUspGTt5JH9+5S+0VOt4jEraIzvYqy0iSxnDoNpILJLgrFlXsHjDH9EVwSnXfA3tke3UH2xl28DD5Obnc0Buwt6p4oybQk0S0+RX483W2HaiwsAtBDZhY7HUmIdBC172McheIBcYiWARgmJgKSq9pNBNDyop+HAynQSpmB2jgpilVd3AVzD9czZjZt/0YQpACzAFmvBQLKcC9wyNUYEGkgxgMFyoLJCSx+jHQKGfLLqpZxs62SiciMJk4HGSxAiRBRgkWIvO8cBIbLym6OQA64WgNBBgtUuhOJDF4aigSmukxZ7C5Ivnsqn2SQKag7jqo00L4yRCmEFelitoNTLx2ScgGMac0X9EYrBt4AkumXodB/VXmTRpoiXYWFhYvJVKKeU4ACHEfZhvgxYWFp8Cd911FwA33HADivLPLJTImsWkZ4KYOO+dpn7s6Lt2krz9NvTFi8DjxXbjN7B/41soObkfeK3mcB/XvPYwStLJzycsYErZO3ehtLCwsPhXLNHG4kvNphV7GJ9z1VFf2lVFZUTqLDavXn9EtKmrbuakzKM9SVx2NwXucQSDwSPbpJQsef55al96iat9BmvYym5vDeH0sYyyj0IKnYywn+rdtxJsuR+Rn8HX//Nn7Fx3iFNKbyR1TBavVP2NlPF9ZDRMZcvCA9gTTl6UcY4DBoA2BNuxMyAU+oTKnZqBpqjEdYUmJG5ilCHIQLIBUJAEURAYJDAwiPM0B5mHG50oezEzZbIwM22SmCVXz2KKNwXAJSgsx6B5aJwds/OThpkB5AeWYPrmtKGQgk5caoSBFqLMoIVcIrQQIRUnLlQMkkg0etAIYtBOiFk4WUKcDmLMx6DVMFgF5Kt2ZigKG1WV2SlpKPZUdOHgcb2Nmq2tiGAa0n0C28OPMZcEXdjJBArookNIegPNCGeC9eG7MNQ4YyonUZgxksbBFZZgY2Fh8a8k33wgpdSs9wgLi08HXdeJx+PY7Xauu+66I9uNpIYarkJPsWMr+XA+hR8ojo0bSN5+K/rKFZCSgv17P8R+w9cR6ekfar1IMsGli+8nomlcmDqfq2e9/3IqCwsLC7BEG4svCYODg+zatQuAiRMn4vF4AIhG4jhTPG8b77J76RyMH3keSPUyEO3DZT96bFT24fV6jzxvbm7m4Esv8fXCQpw2GwUxjenVSZa4bJx9+n+zbMOt+FtfZVKGnaxsN878TFY98wyUjae+fQ95ieHUNlQzQo5nTvn5aKM0Sg9vYkf3DjbICAagYcdu8zGCBLtkgsHsCXhxovf20RPfz1fR8QMFCPJQeBQHqWiMAE7FTgiDHSSoJEkInYeBeswSqTZMv5w5mKVPfiAPhXxUehBsRqcS0+TYhvnNphezRMoFnALEBGRIwUgUapHkY7AJmEofh1AJIhhHkscxWI5BHgr76eV0IBUdD7CUAAcJUolgPCr5ukFDXx+6zU5Z+kS8+SkYhs60gTRWdKeS4Smg0DeO0OBWFsfasMtBKkjBYQtwckaUrUU9eMMJcDVwyUm/pL6rmmc2/orx8wsJhUKkpKR8pPPLwsLiC8UEIURo6LEA3EPPBSCllIF3nmphYfFhUVWVxYsX09nZSXZ29pHtofXb8Rcm0AITsSvvrxnAB0VKib5qBcnbb8PYuAEyMrH/7BfYr7kO4f/wf/KGNLjp9cdpCHcxQZvB7xbMtC4WWVhYfGAs9yuLLzzRaJR7f/tbuu66i8677uLe3/2OeNwUZComlNDYve9tc5r79zFqYsmR5yfMn8KermUk9QRg/nM/2L4DT2GM0tLSI+MO1tQwDnDaTD20bFgJ/vQw9uB+Xtl+L01VD3Ky0cOpGemM0XW0qiomRSJk+STpM7vYHL2PrMwczhp3E+m+HM44+Sf0jpuPNnwOB7PL2BEYS5oznXMUhYnedE5LzyLL5yav5BR6khHm4mKq8KECNiSj0ZlLlH40rrTlMVIJMBwYQGe7UFmPoAg7e4FFmJ2pmjBbfw9DIYCKJIcoblx46EOwBYWRmH43m4CHAYdQKBEKqQjSpEYlDqqBpUjmA7MwzSHSkWSi8So6Kj7ipBLFyQQ09pCgD40R6FyuOJDAPJxc7E4h3+Gi0+GgJRqhX4vidPhQHF5ahErAmcuA7KCxdTMTEpmc4ZnOjZOvZeq4uWSWupl2/DiGxaPcfcYcdG0Tf12ygLr13+Yc535GVO3g9u98h71VVR/b+WZhYfH5RkqpSikDQze/lNL2lseWYGNh8QnzVsEGIL5tGYoNHJPen1/hB0EaBtriRcTmzyV++cXIxgYcv/ktni07cdzy3Y8k2AD8cdtyVrbtJyc8kn9cMg+X45MRnSwsLL7YWJk2Fl94amtryW5p4bxy0173kYYGDh06xOjRozntrBP5y7bHcXS6KMmqxDB0ajt20hfYyfEnfu3IGrOOn0Fnew/LlvyZVFFK1OjDW5zgazdfflTNtcPpJPiWYzudTmaeOIXVu3YRHt1K+d44x5cMwzZkcDzcMNjZ2Um0u5sbfvhD7ks+jur4p8eKlAZjRp/PrCk3sa7zAaLRLUzZo5KmuElJ93Ha5FE07N7DjugmYrQTJU6ThAoggMCLwl4EPgzsWicONQ2HEEipUiejXAh40KkbysqpQXIxCs0YBJH0ICgjRj0xXgYCpHAvg6zGwAfUIVAdDu6022mMGtwrI3Qj2IaDPOFlhEwiSJKCRj8aGUgiGOQBCgZukUmUbnKlk1yi+HFxPgFeN/opQOG/STA8lsTh8jKhoBSlt4O/HF5MSmsOgexxpI84m9rG14h3Omkf6GCEIcmNxmhpbKc/2YK70EDY7USKiniwu5v0EaV8xeFgXmkph+vqqd3bTEVC43c33cKdrzxPamrqJ3kqWlhYWFhYWByD7du3E4vFmDnz6EyUZN8ATqUeTXdjz/p4y4r09euI/+d/IPfvQ5SW4bj1z9guvgzhcHws679yeA937FmBN5zLX884h/y0t2d2W1hYWLwfLNHG4guP0+lkwDDQDQMJhA0Dx9A/5JycHG748YUseW4Vr+x9EaFA5ZRSbr7o6qO+wCuKwgUXn8OcubNpaWnB6/VSWlr6thTXwqIinursxtnWw/C8THJysnl56zaWN/RR6MjFoaooQiClpLurB82u0qrrZA8bBoBEoutJDrbtYOfBxXQfeJmR3iyC/kK08ixmnDqHEq+H4/PzCYVCbN+yheqGRvoiDk532IklEqiGhgJ4UOlWbTRJFcWI00YSXQ+zUSiUqAoX6ZI2BAkkGUheR2cOKm5s6PhYRgjQ2I1kH3nU4EOlB6+tgBW0M5oEp0k7fRj8x2CQQcAADiOpwMZcsmihlw4MmtDoRDCA4Fwk4xAcIsnjooexhkoGHlJJUoyHlwiTQYLpODiIykGbjzm5UyiSftbYgxS4EuyMtJATkgSTgut+fAHP3bkJ3R5mUctuXDLAKC2DzIxMQslUHq+q49t3/5mUlBT6b72Vk/LyCIVCHKrqoNw/A1WxsbX+NX7yw59x/kXnM2HiWHJz/2ky2NraSvXu3eiaxsgxY475e7ewsLCwsLD48Pzyl79k0aJF3H333dx4441Htve//gbphTp63nEI8fEUCMi+PhK//gXaE48hiktw/u0e1HMXIGwf39eivT2t3Lz6KRyxAD+ecBYzRmR9bGtbWFh8+bBEG4svPMOHD2fnySdz55o1SCkpnjuX8vJy1q1ezcpHHkEoCqdffz1fu+VKhBBHBJ1jkZaWRlpa2jH37d1bzcO3L8LjXMAjtStJOdRE6+A6GhJupmf8htDONmptb/CP1lauyMkhHImxWSbZNXYst5xupvyOnzqS2x+5g0DTbur6G/iFN49EsoFGXWdFqIczLriFh/bto+fwYdq2baMHOD0jnYbegzgUBRcKzyHIQuJHp0EXpOBEF7BWRrED9SLBfF2jE0kREj924kiq0NiDgRODcSTII4sXETi4nDymcxqltKvb2Gd7BpdbJat/P2ERZ2lSMhLJSZieOPOBDfTxjIziEIIUGeN4BOUIUnCwhgSluDhVOKmWcQ4CXkK8jEEaEUZjcDKpNDPAbAJMU3J5oHELma4U9mgDOFNy+G7RMFKcUTaHOnC5XIwYOZw5lZezds1qtvbvpis9gd/to9/uI9QfZPHvfocjNZXm9nachYX0R6M4RQBVsVHfsQ/6Y/RuzmCfobDi6cc455qZHH/CTF5fsoTdTz/NJCFwCsErzzxD7qmncsFVVx2VYWVhYWHxJkKI+cDtmA317pVS/u4dxk0FNgKXSimf/RRDtLD4t6KpqYnFixdjt9tZsGDBUfu06lWIcWAfc+pHPo6UEn3hM8R/+f+gvw/7zd/B/v0fITwfbwZMdzTMVUsfxEiqnJ82h2tPGP6xrm9hYfHlwxJtLL7wKIrCxddcQ+eZZyKEICsri2AwyLqHHuI7OTlohsFd995L5e23HzEo/qDE43Ee+9vLTA98lfT8XPRx19Dac5glS14h4N6FzSlxqCrZJdPZl2Vw2Zo1uFSV0hmzueHnPz/SMnzixAmoKb149zbjlgIlpuFODtKU2MPYS68mKyuLG3/9a158/nka2tsZ19FBsqaGEzWNbcAY1UaOtHFYSlYgKLYXkG0bzkjZQnNsPxcTZ8CQiCHD32wUkoADB5VInsPBGAqJksBPCi68FHAS2Yyhj1pUzyZmDNZzKNbKFBKUKC5eN2KMBbqA72N+SxkP/JoYJ0qF45HsBgoVJ8OkHaRkMQYDMsEIksRxs5Y481EYJEIjbvbjoZ8YbtWJOxGmjQFSIgnO8RczqBsUpw8nx+GjqmkVhw4eZtb5lTz4l3twy8mcN/e/yClKwzB03tjyVy4PBZjm8ZKXn8+Pd+9mZX095T4f2yOHqQ2HcfUmaVPyOaFyAeOKJzMifhwvPXQXvoCHXU88wek+Hz6nk+KUFGZKyUPLl7N7/HgmTpz4kc9NCwuLLxZCCBX4K3Aapmf7FiHES1LK6mOM+z9g6acfpYXFvxf33nsvhmFw8cUXH+VnE6ltxpveg0YK9pSij3QMo/4w8R//AGP1KpRJk3E8/RzqmLEfNfS3kdA1rln2MN2xMBOSx/M/50+1snMtLCw+MpZoY/GlQAhBTk7OkeeJRAKHlHjsdgwpUTUNTdM+9PoHDhzAHSkiPcssq1EVG/np5aS7i2jvXUWjuAe7O538ogKGF7gYbxh0Aqd861uMGjXqyDoOh4Pf3v8Xvnf9DbjX7+CeWBseVeWgu4DLis1a7kAgwLz581l3992kNDSQomk8o+s4HA6KsJHrS8Uz0ElUKeCSnEsIKC729yxlqnCRg5McBFHZTwyJgoGKioGgFkk3Gn7S6CbBdhEnJIsYJ8qwKTai9q3MHuyj11DRFS/dRhRVjxMFDmO2I/diuptnYLYDD2PQhAO7zUtQxlGlYARulgqdZplKJ23sQSMLNzpe6gnjoYRUMYVBNhPxlHAosgO/Die4jifdn0JddCevtGxlTu546r3FqAd6+d4P5zEQ6ePp2zawpVEnrT+dyrIpDPbXU+RU8frc+J1OTior4y/79jEqFGIikv3ttWxIuMgZ+zXGVphtRL3OABlaJY/edx/atm1scTpJAoNeLxdPm8Ysv58tq1dboo2FhcWxmAbUSikPAQghngTOA6r/ZdwtwEJg6qcbnoXFvxeapnHvvfcCcNNNNx21r3/ZKnLyDWTZrA8tfMhkkuRdfyV56+/BZsPxv7/H9tVrEerHbwgspeQn619gZ08jef3j+OvVJ+N1Wl+1LCwsPjrWO4nFl5KsrCzyTjiBu9esQQdGnn46fr//Q6+XSCRw4D1qW3+kk0hyIXMGaxmXUkRX8iD7DrcR7PJx84QJNPT38+ry5UybOfOoeQUFBfzl4Qf5+oKbyGIEvswKLiuYSrhn85ExOTk5RFJTWWQYhAyDAJCeSLJNMRjmSLBeEexRnaTFWhhUbXR5RrAtWsskw8YMVyZ3xoIoSIqAEEnWolMH9JDFc9Tis+cSyDqPYOcmBo0uXHYPkeQesmSSg0LnaiONJgaptQlytUEuAf4GPIJpgrwSswX4BKAAjcNaCJ+aShCDHECVcTppYT+SExQnLajUGk5q8ZkGx44deGwJ9NTo/2fvLgPjuM6Fj/9nllEracXMki3ZMjMnThyHmamhQsp8C2/vLaW33N5ww4nD6NixHTPKlmzLFksW8wpWyzQz7wenbhynbcChZn75Eg2cOTszsnaeec55qJEi5MtOchMq8MdcTM5ewKbRVhRHLkVFi9jX9QRrX1nH5qeOgDsOjZCBIZDNlt43GPX10x8fZEFKKVFJol+jIcPh4Ly4OGLj4xhTBVIjqTTbTv7yFgh76d+1i+9ptUx9qxx4cyDA03v3csHMmUSDwQ98r6hUqv9oGRwvwvd3vcCct28gCEIGcBGwHDVoo/qcW7t2Lf39/RQXF7N06dITy+VoDHr2I6SCWLj4A7UtVe8n/O1voDQ1oll9Lvqf/xoxLf009fxUDzfu4dm2amzuHH53zpnkOC3/fieVSqV6D9SgjepzSRAELrvxRnpWrEAQBLKysj5U+mpOTg6jyhZiUhStRgdAw7GNrDRpsOfGM2V2Bg7HZNonJvjNoUM0pqfT6vWSOG3au7aXlJTE9MWLSXUvJ9tZQk33BkoKU07aZtrixbTvrcIUlpgky4RFDU+jUGIS6bKls3zqz5kYitI72kLQd4A2UyI/C4YxEcSrTeTFmJdthNEg4kBkBA0WIczX7GX4NF7WRF8lbFSoDtxHnJSOj3Y242JIGWMXAtMxo9dqmUDh9VgAN9AOvAwsA74ItAAVyJQCrZKXZrRUE+EoMXRADlAm+5mKnZd0Ecy2mXgkkedMB1kyYxIdJhNGziT7YDPuQBdpaZm0CB6mVN7A0um3sG7telqH2/nLD3/NYl0uC40CjeNHODJhIz3xPPoc8dRPSkEeGGAoEqHdZmNRMMisykq0Wi1DQ0Mc3tHB1mNbeUWfzhnTL0cUNLSMb2ZVaipKfz+KoiAIAiVmM/vdbjZ0d1P+jjH3KpVK9ZZ3+0OivOPnPwLfUxRF+ld/dwRBuA24DTgxhFal+k9z3333AcezbN7+++CpasCeHUDSJqOzpvyz3d+V4vEQ+cV/E3vsYYS0NAyPPon2rFWntd/vtHewnf9XtRZjwMnXKlawuDT53++kUqlU75EatFF9bomiSE5ODgCDg4MMDAzgdDrJzMx83wEcp9PJ7LOL2fn6GqamnEW8JZmBgRpKIv2Uzy0mMzMTgElmMynj41QXF2NPSWH1BRe8a3uCIHD1bRfw1IMv0TryOmUL8zjn/IuA49WMDldVYRQE9msMzE0tZqunF7vWwFezFuAJNZI4bzKtR6rJtc1A6HuR6xQ/DfIIWw0pLM19gm7fFgZd9xMWgySgx2KOcWFOOrvHR5lU4sQXszLdbOQHt9zCj774B8TRDDJjNqZKA2ShAbxsRYczZGSqIBNDQ1gQyRAVcqQYVwFHADciG1E4C4F4IvQQoREtt6EjA5nXEQEdAkEmRSWGwz1UJH0BcWYm37//Jxw+eISafUepGnTR09dDkmxk0JrGstKLkGSJSEo7CYKbC8bNLLQ5GBjpxi77SRZGqDVtYVn5ZSy8OYn4+HjqH36ZYEOMpuZ6XmldT1p6Ks5UBxHDBOPuGIY2Dc8H/0pSnh6rU0LpCuGz22kYHyfLYkEUBNw+H91JSdz8juwolUqleksv8PbJNzKB/ndsMxN4+q2/M07gHEEQYoqivPz2jRRFuR+4H2DmzJnvDPyoVJ95iqIwZcoUjh49yg033HDSOs+2rWROlqF4yftqT1r7KpEf/QDFNYz2ltvQf++HCNYPnkn9Xgz4J7j1zScQoybOti/k1uWntzS5SqVSqUEb1eeaLMs8++RLHNrcTbyYy4S8i4LZDm649Up0Ot37auviy88jKXU3215/Ene3l2DKKNaMOLJz/vH9vcvtprCiguu+9rV/2k4oFOKVJ5+kY88e9LJM0aRJnHfJSoxGI7u3b2ffI48wSxRZbDDQYTbT6nNxed4yCs1JNHsH2GgQuesnP6a66iCP//pPnCX4SRf8pGWlkiboeXbwJkoMGcTbLJijCosykrn87IVUHevg1bDEX441YlYUEgsKGO3o4O5n/odbL76Z+RMhzFjwaqwQFihUYhwRrAiilhppnEsUCRM6YkgMIhJA4Hwxjk34eFSOMYSAHh1zMFGMggmBpYQ5KGo5S4F0RcNAbJyGwd+xovxmDh88yuZHWknVTSPBFqRjcg3jmmSKbYtoGzqIS6in9GwbmnV2ct0C7V2tOLVFJOkcpMb8VLUf4IjBxgrDpQQCASyjk5mdk8vLNRvJnUhF1KUzPBag2utGlz0JTcIIOUs1ZGancvg1HTUDvRgFN0qWk/FgAFkQaMvL49s//ekHnrBapVL9xzsAFAmCkAf0AVcCV799A0VR8v7+/4IgPAKsfWfARqX6PBAEgbvuuotf/vKXaN42x0zU7UXra0RRQMye8y9a+Ae5t5fID76DtGkDYnkFhkefRFP57tnMp1NEinHzm4/jiYQpD8/nl9fNQCOqEw+rVKrTSw3aqD7XDh8+TP3GCVbm3YlG1CIrMrv3Pseu0j0sW/7e3+7A8cydJUsXsWTpIhRFob+/n6d+9jMyBgcpSEig3+vldY+Hlbfd9i/bWffcc5h37OBb2dloRJH9LS08c/fdXHLbbex99FFuT03FZjAA8PWzlvPSm9U8PtpCpsaEN0HPzd//Gfn5+eTn59O0+Q2uss4gEgxiMpnwbd3K8lSFUoOPI4MTjAbGeG1gArklmaOhKFqdidtnVFCRkoJFp+P/tm/npd27WWCRmOILoVO0JMQtwe0bod2/hxZNKsfEMJOUXB6QD1Aix5CAOCQyERknQLkoEi+LvIRAOnq0QhxeRcJBBJEQoqjHLkeoUYJoon1kGTSUTCqgZlc9gQEPXSMPkg+M+JqZddt0SmaaEUUNRUWXIQgCT+3exIi7niLDmZi1dgCMGhsZZLO59SgDAwtITExEK+ipP1ZDWepPWDv0DEcjHgSLmb7EeSy9opzZs2czd94c7v/jE5iJpzrswDsxwSJZT1AbpDPNyLnf+AZZWR+ugoVKpfrPpShKTBCEr3C8KpQGeEhRlHpBEO54a/29n2gHVapPIc07JgUef/MAjqIoijUXwZTwL/dVYjFif7ufyF2/AkVB/9P/RnvrHQjaj+cR5yf7XuPoWC+p4xX85drF2E3v74WfSqVSvRdq0Eb1uXZ4XxP5tjloxOO/CqIgUuycx8Hd69930ObtBEEgIyODK370I7a/8gobW1uJz8xk1QUXnFQt6p0kSaJxxw6+lZWF7q0vMXPS0znQ3s7WTZuYDicCNgDpGelcsXo+HYfryDh/CqsvPJPi4uIT67MmT6a5vp75mZl0tLfT7/eTmZ+Pd2iIr2SnEq+ksKWvjzVtbXzv0UfZ9sQTWAeH2bfxACjQ5O3hnLISbAvm0bZtO5OHRjg68iJ6Ww79Rj1RsRiDqEcWjpIr20nUahkMualXopSgI86ajFnUsNPbxzYpyh3MJMNQxGBkO6LsZT8KJZjZqfjZIkJqnBVPejKVlZXs33ov8Z11XJ0xh0BogkqTE3ddHcHCQqbMmkUwGCQjI4POQBB9OMp4YBTZJGA0mhgYd9Ea85EVP4f1fztK2cIk/IleGne3sci8CGvRLRRPS8dmcTDmG0DjaGDR4oUAZJck8cp9rzEr/uv40jvpTvYjaHT4hB5S1YCNSqX6NxRFWQese8eydw3WKIpy48fRJ5Xq02bz5s00NzdzzTXXEPfWhP9/59+7A+dCBaFo0b9sQ6o9TOQ730A+UotmxZnof/W/iB/j/E/Pt9XwREsV1oks7jp7BQUpH+0wLJVK9fmlBm1Un2sGkw6/FD5pWTQWxmA8PW9KsrOzue7OO09LWyGPB8e7DNlyOp3MKCmg8rzlJwVsAC688Uae+OMfOdzdTUt7O0kpKWjGx7kgFsMZjWI2mzkrOxt3MEh3YyP65GReWVvFFWlL8UtR2jqacYoaihISWKfoGTPFI0XCHJM11DuTmbEyidZDvbS4kzG5R5mHwEjUz4uKnhJBR6VWz5ioJZBYSK6nnzX0sUwPOoODRwJDuDV69ghuRmxmKpYsZNbq1XzvvPNISkrCEhpnbqpCu2cfGr3C9NmT0Fks/OCRx9jxShc6zASsXbi9eewSOkjSS0T9/Qx73OwVw6Sn34AuTsv0zAq6Gw+y8tYKRkZdmHwjTCmejeGt4Feraz9Ts53/OM++GCvnXEGOo5j4+Dlo33pb1zFcx/4dtVRUVJyW66lSqVQq1efVXXfdxaZNm4jFYnz1q189sTzQ1ovJ2I+CgJA+8133Vfw+Inf9ktiD9yM4kzDc9zc051/4oQpKvF91o318Z9eLGIIOvjxpBSsmp35sx1apVJ8/atDmU0ySJDZv3EZrXTeJqXGsvvDMD1WWWnWqOYum8eC210kN5mI3JRAIe2l0b+HiGz9YFdZoNEp7ezsA+fn573teHI1GQ+miRby5eTNn5+SgEQT2Dwwg5uYyacYM2vbvZ/o7jylJ9CgKq9LSTmkvPj6eL/74x7hcLvbs3MnI/Q9QU9+GUZfIYMRDINqDXw9KYhwHtm5l2tmrOJw0jz/7hxG1JhLzVtLp7kHf3MXFSYvpSpR52j9IxdQbcUbCDHr28Y2f38CeJwZIN/+YI/VP4+rYwu0GO36lH2tyEgVGC2V5qfQrlbxotNPjBZNRyxcv+iEFBfnEYjEqKipOBEcAYrEYGkVh+fK5xKJRdDodoigiKwqDnYNckn8xVl0id710Mz+47CGeDPyGF7sHMBhijHkSyE67iNLkBRyKPUaW81LCgwHGR8b50ndu5PH/3cigx4nDkkz3aAPe+HrmzP3HkLWAL0xiXDJJSUknnUujzsKI7+QA39tJkoQgCIii+L6uuUqlUqlUnydtbW1s2rQJo9HIddddd9K6sQ37cJZIkFiGYDj1O6/c2UHokgtQ+nrRXn8j+v/6KcI7MnU+auPhADduegw5qmWlZSFfOqPkYz2+SqX6/FGDNp8At9vN0aN1RMIRCosKyM7Ofte3A6++tJ7aV9yUJCylv+EY97Y/xjf+6/aTHm5VH05hYSHn3zqHtWseQBixENP6OOOa2Uyf/v4nr4tEIjzyhz+gbWxEALaVlnLTN7+JXq9/X+2svvxyXg6H+d2+fYiyTFxJCbNXrGDENcr+WIzsnh5mZ2YiCgLhWIzXurspOOMMHA7Hu7an1WpJTU3F5wvz6IEOJkfi6fJLpGjMxEQDjb5OvFGBwa07qfH5sKRPY3XpL9Bp9GxsfJDd4XEaGzspttipQUbvmMJQmx+nUMLocBvf3/ZfGKUhHMYEotpExjxufJKAw5SEgJcll83FZrOxv7GRzKmFnF0xhamV5SQkJPDkw89zdG87OuN6rrztHKZNrzzR5/RJk2js6KA8+R9lMxtdLlInFdMyspewR8ZhS8Ckt3Dp4q+wdvfjmP256BUFl7+HQORxls05D73WgDvWx7SUDDIy0pm2Ko2De59CH7FQsayYq1fdhN1uP3GMkim5vLm7njzKTzqP3RP1TF+d+67nOBwO85ef/hST1cqX/uu/Pta3fSqVSqVSfZY88MADAFxxxRXEx8efWK7EJEK1e9CvUhBy57/rvtG//gllbBTjq+vQzJ77sfT37SRZ5o7NTzEU8FAWmsdvrpmtTjysUqk+curT/0eop6eHkZERkpKSTpR8rqk+yLP3vUlidDJaxcSbwqtMXprCVdddcspEbNXbG5ifeQcWg51URy5vdjUzMjJCauq/TsGUJImGhgZqDzQBUDm7jEmTJn3sGQCKonBgfw1HDjRjsRs5Y9XiU7IXPg3mL5zLrDkzcLvd2O32E8Nm3q/a2lrs9fVckXe8MMiz9fUcPnyY2bNnv692jEYjV956K76rrkKSJA4dPMILf91LqjAFfWQFfx54iemRCEkGAwOKQslZZ3Hu5Zf/yzbr6urY+lwdRWnfZHBkL38ce5NFMS8JwDAxOvRWzrPkk2EwsEZqZPPAnwCRkmWphGLLeGL/79jnO4rOkkaSbiFzU24iEPWwf/S3XCukY5cFQqFBQhoN27UOtmJgniaZ0LjMwZqjCE4HzzT0M09XSkODyPonHkCX7CfSkM0Z5V9DFsOsufshcn6TTULC8UkHz7ziCtb84hd01NdTkpTEUDjMHq2WC2+9gb7eflAgtLEAgHhLMpcv+xKtA4fZVfcao7E6Fk/5NnZTPAe73kRO6yE5uZIHf/xjyrxeFgLN8fEsW3kziYmJJ52radMq2Zlfzf721ylJmYsoiLQNHySS2sq8+be+6/lVFAU5FkOKRt/XtVapVCqV6vMkEonw8MMPA3D77beftM5TVY893YeCBiHt1JdnittN7IXn0F586ScSsAH47cFN7B5qI8ldyv9dvYw48/t7MadSqVQfhBq0+YhseXM7G588hEPIwa1s4+zrZ1I5rYJn7t3EwsRbsb81G74kL2bH5iepLqthzpyTH+4tNiPewDgWg52oFCai+DEajf/yuJIk8cj9a+jcGybHPBNQeGbbPgoXH+W6m6/4WAM3u3fuZd2DtZTalzEWGuPPBx/h2z+77ZQJ5z4NdDrdhw4oRSIRbIJwIsvCLopEIpF/u18sFiMUCmG1Wk9abrVa8fl8vP7EbpZnfAWT3gosZV+7k8xVIWbPmUFSUtJ7GjJXvbuOHMt0xo0aitP/H9s9vXTERmhkhCR8GAQRHRbiNRoyEx1c8OVLeOrBl3nmgfuYPtbLL3UKBv8E+9x9NFg01MVK6HU1UR4eokxXSkRjoF8aZZFjOa6JPRyLdhKTBhgVovyiXkSXlsPFS+6hIKWChp79DNRK9A73M8OxiH2DR8ibnIbFkMz4+DiNR46w7fnnufEHPyB36Zk8fvc6DGO9XHb7taRPTNDy2GMYAbmykswKG7WtW6nIXIxea8RhcZI33cEPvvg/HNzXQHt/PUXzs1h2xk28+Le/sTIWY+pbQbUD/f28+cILXP3FL550rgwGA1/+zk1s2bSd6h2PIksyleeUsGLlzadco78zGo18/Ze/RBRFNctGpVKpVKp/4qWXXsLlclFRUcHcuScHXkY37COzVEZIm4agM52yb+zpJyEYRHvTLR9Xd0+yqbuBvxzditmbyl1nrKQoVZ2yQKVSfTzUoM1HYGJigvVP7WN52lcw6S0EIz7WPfF/hCNBnLHyEwEbAI2opTh+IVVbt50StLnkhrN4+HfPEufJxyP3seySyn86BObvjhw5QtfeKMvybkIUjgdo8uQKtu14mPo59ScmUZUkiebmZtqaOzGaDVROqyApKYlDhw6z441qQv4wU+cVs+yMxf82UPR3jY1NvPHiDpavnsvUyinsfvMw05wXkGTPAMDbOUxzc/P7zjz5rJg0aRIPxsVh7epCAOrsdr4wadKJ9VW7d9NcU8Oqq646KUD09P3303bwIHfeddcpWR9erxcjcW8FbI5LNGUiSJ3k5+e/r/6lxefTqduCNKFlqhzPmeIUhoRajMpReiJB2v2dRINFZC1cyNpntxA7lomjo5cv2LUU5KbT09XP/ICC1dfFq777QTBQqctHVHT4o270RiMmnQ2FKOfoTMwsWU1MiPCz4T3kFp1NQUoFY74h9h3cwZK4r3Mg9AI+sY8C0yxqarYTLa8jMfFCutvaiIZCxGIx7DY7+dkzseaEWXXRRfz69tv5XnY2OlHkr0eOcO4Pf8iuLQd4o+q3iIqOhCwDt954Kfn5+UydOvXkc+lykfG2YVDpVisHXa53PVdms5lzL1jFuReses/n9/0Og1OpVCqV6vPmvvvuA45n2bz9JUdswofcU4t2moyQdWoWjSLLRB/+G+KcuWjKP/6CAB2eEb609Wl0YSt3FJ/JyinpH3sfVCrV55catPkI+Hw+TIIDk94CgElvRY8Nz4QHrZJwyvYGnYlQ4NQJTktKSvj2L2+ir6+PuLgZ5ObmnrS+p6eHtc9vZmLUT8nUHFZfsJJDexvJs84+EbAB0IgacsyzOFzVSEVFBaFQiAf+8jiuOg2WWCodrkM8ID9D6ex0Yt1JlCecjUlv4fBz++hofYovfv2m95Q9sP2NKoYO6Nkk7WFq5RS0Og0x6R+ZJjEl8h89H098fDw3/vjHHNi1C4AbFiw4MdQHYMdzz2Fsa+NIWRkrzjzzxHJnWhrjGRnvOiwrPj6emMHDiLcfpy0dSZboDzZQmp170naxWIwXH3uM7tpaKlasYOV55510zWYuKOfpPbtZMms1z266FwMdFMidmI0GFM00Nvl24I25maQU8Yerr+aBPz1Jx0AtMwC9ojAyOIiWKDaTjM0/RpIlQFCTjRgaI16bykS4Ha1WQ/9EK6FIGJ8s4RkNoo3XoLXq0JhlYlKUtoEjpDEdg2glzVKEudDD4Z5HafLvJ67TyMP3PM2XvnkTC5cvR6fTkZmZSW5BFunp6Wi1WowOB8fGxrAZDAS0WlJSUrjp9qvxX+snEongcDj+6b2aUVZG9datnJWdjQLUjI6SPveTSa9WqVQqlerzRlEUvvCFLyCKItdee+1J68Y3V+MoiKCIBoTUKafsK23ZjNLVif4HP/q4untCIBrhug2PEo7KrDAu5Ktnln3sfVCpVJ9v/7lP0J8gp9OJEOely9VItrOUTlcD2vggldOmcmjdBiR5CRrxH/PXdI4eoWJZ4T9ty+l0nrLc5XJxzy/XUMgqcg12jry8l4nx55FlGZ1w6hAoUTheeQdg4/ot+OtSiJNt1DbUkKpUYpOns+Huh5lcZmJpTjoGnYm5lgt4s/Yeuru7ycnJ+befe8W589kQ28nSVYsAWHnhAp74/UuMeOfgj42hyR2krOy893QOP6uSkpI456KL3nXdmddfT2ttLdNnnlzC8uyLLuLsf7KP0Wjk+jsv4NE/PYHVnUFQclO0MJ75C04ONhw5coTQ1q3ckpHBYy++yKRp08jKyjqxvry8nEVXDLLlpbVk5idxcNxCtRhhsphAncdPt7mYyWk5SOECenp6uOKm86ip/RGu5iAiBsz+EEatliAxvHiRdHqSbUuo8f+NeMIoujCSrDAa7URDApt0Fib8w9SMN1P5pYupmFLB7jeexT8RQ4lm0eOuJ7M4hUnliynLmYHv9SBzky5grLmK/v5+8t4awqTRaCgr+8eXoyu+/nVef+QRosEg59x444kJhC0WCxaL5V9em1WXXsqTQ0P8uaEBWVFwTJ/OVeefjyzLtLS0IMsyJSUlp8wtpVKpVCqV6sMTBIFrrrmGa6655pR1Yxv3kr9cQciciaA5tfJm7KEHEFJS0Zxz7sfR1RMUReFr25+j0+uiKDiTP9w8H61GrRKpUqk+XmrQ5iNgMBi47VtX8dg9L3C46zlSsuK57YtXkZaWxqQlh9ix5QmK4xdi0JnoHD1CMLWRhUve3/jc+voGRFc6dZ4DDLkGURSZvS2N3PK9i6nbX022s/RExoGsyHT5a7hoViWKorB38xEKTKvYtXcbC+xfxKCxIMkxxnuCMDRBVdNGCjLKaes9ykQsQE9PD411LbTW9WCNMzFn8VTKyspOyWgoKiqi6DtFJ36uqCjn9h+baaxvwWyxMWfuLZhMp45R/ryonD6dyunvLNj975WVlfKDu9IYHBzEZDKRlZV1yrnX6XSEAXcoREwQTsloEgSBs1efycIl82hqauLJ/xNwhioZ8ngZPHqEM0sKWT3nBpoHqmlr6eDc81fx1/t/z21LD1Lb0cHquDgisoxLEGi3aBmyBJFMh2nRjOMV+6kQdciKmU6jnX3hcRxpM2hOTKA4+VxSkrRccuX57EzfzavPbKSzp47zKr9MTk42ADZTAn5dH+1sIskpkPy2alHvlJ2dzRd/8pP3fQ7h+JCnL3zrW4yOjiIIAomJiQiCwKvPPMPg66+jAeqXL+eyG2/8QO2rVCqVSqV6/4LtfWijXWh0MkLmnFPWyx3tSFveRPft7yF8zEORH6jfxfqeoyR4Crj3ipU4LOpQaJVK9fFTgzYfkYyMDH7w868iSdJJb+6vuv4SqifVsG/rVkKBCBXLCli05BasVivV1TVU76xDp9cyf/n0kzIM3snlcnHwSBXz7LdRbp+ErMjsG3qSva834sw3s739SfLtM1EUhQ7vATLniCfmswn5w3SNt5KtmYdBczw7QRQ0GIxG4sii/tgLtHY0kqMsoc79Eo/d00+J/iwy4pbj7/TwxJ7tzLmwgwsuXv1vz0N+fv77nntFdbJoNMreXfvpbhskPTeJlJSUU4ZSTZ48mZZVq1hz4ACLbryRtLS0d23LarUyc+ZMnD918sqaTfj7R9B5Xcwv/wqCIOCKtDIr5fh9FxcXxzfvvZf/uuQSNg4OkoxAl8UMC+dTbl5AadwKFk1bybrdz7Bn9GXioiJOtCxKySAar5BfsoRJOYvZ1PJbNBoNS5ctZtHiBdz350fpPViF2SuiEbUcG6lhwfklrL5sOQUFBf82Y+aDnD9JkjAajYiieMqE0/XbtvHVzEwMWi2/2L4d5YYb1MmEVSqVSqU6jV544QU2btzInXfeSXl5+UnrxjZUEV8qo+isCEmnfveNPvI30GrRXnfDx9VdAKoGO/j5gXUYA07uWnYOJWn2f7+TSqVSfQTUoM1H7J1DLTQaDXPmzD5l0uH1azex6+lOShyLkeQoj+5/k4u/5Gf2nJOH0vzdYNcYGbppmJREAmEfo4EeKkpnYtRVoE1uYMrqUg7vrQYBzp03malTpyDLMhqNhvT8BPa8uIcyUlEUhZgcZXC8C3/EjTfqosNfT6IlmwxrBIvOQUp4FjOKzjpx7KxYCVtevYeZc/rIyMh41/6Fw+EPXDpbdbI1j75A9w4NuXFzOVJTx0DPM9zy5etOCiwMDw9Ts6sXbaCc2uo2Fixe/C8DD7m5uXztB8fLVx+sOcSzf3ucyITEvHMqmDXrH/dca10dScYEohYDXbEovToj5Zl5XHvbmezadBDPmJ/V3yriwNMprOg3MTdjDhqNBm8szEu1j3Eg4iEu7x+TKGs0Gm758rXs2b2P6h3rkCSZyjOKWbTkDsxm82k/d7u2bWP7E08gSBKFixdzyfXXn/I7mVlezoZ9+9AKAunl5WrARqVSqVSq0+xPf/oTO3fuZPr06ScFbZSYhHtrFSlXyAiZsxDEk/9GK34/sTVPojn3fMSU1I+tv4MBDzdtehwxauTWvJWsmvru33dVKpXq46AGbT4FwuEw216rYWn2nScmL7Z7E3njhadPCtr4/X5kWcZisdDROMjqlXfS0dLLmKcLt+Qm1GUiU59Ey8EOvvCl6048fEciEe794yMcq+vHkaFlqCWEdyjGXv+L9CTW4wgXogk4yLZVok+I0TW+DjmzC1fyK9A3wsKSC0/qr15rIEkpZ+OGzdxw47VEo1GGhoaw2WzEx8fT1dXFxrXbuOHWq9SKOh9SJBKhdvcxzsn9PhpRQ3pCAetq/he/339S+emuri7s/hJm5ZzL2iO/IhwOv+eqX9NnTGPa9MoTQT2/38+R2lo6jh3j1d/9lW/a55KaebxKQlCK8OuNWxm95Fzu/O4XAHj+0Ue5qSCfcKiPUMyPRWPHpjWwypzEr2rv56t3/NdJx9Pr9SxdtpilyxafprP07vr6+jjw6KN8NTUVk07H01u2UFVUxPyFC0/a7rIvfIG9JSXIsszVCxZ8pH1SqVQqlerzpqGhgZ07d2K1Wrn66qtPWuc50IA5YQJRfPehUbEXnwOPB93NH1+Z74gU44YNj+KNhFmiW8a3zir/9zupVCrVR0gN2nwKBINBiOgw6v6RaeCwJDHe60FRFPr6+nhpzQa6GlwIiKTm2wgE/BhTDUybVcHhmjqM/kwSrWk0N+0gXBk6qf2+vj4G6yRyWMKbz73M16/8DSOJo2x9vYrBoU6G2cMZOV/EFKfhsP85Ll1+B+NyJ8tvzeGlv21Hqzk18DIw1sHep/ZjtZqp2dKGIeokqIxTsSCbS68+n7PPX64GbE4DjUaDoFEIRwOYDTYisRCIEjrdyZP0FRYW8nrCDjZ1/ZWpC/Lfd5aTIAhoNBp6e3tZ85vfUOTxIPX0kNTTTXV6FufY0hAFAZNGz3xNIru27OSMM84AoK++nmUpKWC3c7jqCFp3HBp0BBkjO1Vicvm/rrLw93vc5XLhcDjIzc09LdkuY2NjZIoitrfORZHBgGtw8KRtotEo0WiUpStWqBk2KpVKpVJ9BO6//34Arr76amw220nrxt6oImEyYEyAxJOLciiKQvShBxHLKxBnnRrQ+aj8aM9r1Lv7yAtU8pebF6sTD6tUqk+cGrT5iHk8Hu7+7SOsumQpU6eeWsIQjs8dEpeuo3eslcyEIiYCIzT276N4djYjIyPc/as1FMhncU52OQICPUMt7Bq4i0PKNuaVnnNSW72BOjISBV56fi35RVlMnjyZYDBI+9hBNhx9hcXpN6PT6ElLS+OcS5ey7uU3qXY/Q4v+RcLRMSqnzqU8ex7Hhix0tbaSPzmVrmMN5KdUnDiGJMfA7uXsC+aw//VOFqfejs0UjyTHqNr+Kpvit3L+xf/ol9fr5f57HuLQzhYKS3NZsmo28xfMVYdPvQcajYbzrl3KG488TKJQxKh8jLOuOvXcJSYm8oNffgW3201KSsoHCkAoisLaRx5hVSxGeW4ubZEIOTod1eMdtNozKbEcnyA4IkcwW/6RxWO02fCOjpKbmMjSs+YxOjpKLBbDbE2nxu3+l8Oe/H4/T997L4GjR8nSaKiSZaTcXK66886TyqV/EBkZGazXamkZHcWq11MdDrO4uPjEZ924fjNbX60mFhZIK7BzzS0XkZr68aVeq1QqlUr1ebB27VoAbr755pOWxyZ8+GqOkH1zFLJmI7yj+qm8by9KYwO63//pY3ux8lxrDU+1VRHnzeaBS1cRr048rFKpPgXUoM1HpLe3ly1v7KanfYCu7k4ikfkASJJEfX09fr+f3Nxc0tLSjpdAvO0Cfvf/7uOZXWPEvBoEQxTjUIjXntmIOZBNauXxrBtRFMl2lrA493p29z2BoUtPanYRR0YaOND3BN3CToqGrmFwQzKHXz3EM0mvEHNZWZh0EzHHa0THdXR2dpObm43D4aCsopiOBieLFiwmNT4Xvfb4w3go6ifBamDxGWdy9y/WEOz1kplQQiDsoXF0O2lTtAz2uojzTcFiiANAI2qpzDiTnW/+lfMuWoUgCPh8Pn75X3+i/XUDeYbriHnc7BkaoXb/I3zpmze952wcRVFwu91Eo1GcTiei+Pl567Fk6UKystMZHBwkOflsCgvfvTy8yWT6UNW5fD4fnmPHmJx9vKpTSloarXYzBRNe2j29FJuTcAVc7NOM8YMLzkNRFJqbmxmKiDyx/xC3TJ1ESnLyiepPe/v6yJw5819OLPziI4+QU1fHipwcBEFAURQO9PWx5i9/4Us/+cmH+pKWkJDAJd/9Lm+uWUM0GGT6rbdS/tZk3AcPHmLnmg6WZH0Fo87Csd5aHvzjGn74y699ru4tlUqlUqk+ShMTExw7dgyDwcD0d1TQHN9Sgz03giAo7zo0KvrQA+BwoL3wko+lrw1j/Xxn14voQw5+veg8StPjPpbjqlQq1b/zmQvayLJMZ2cnfr+ftLQ0nE7nJ92lU/T29vLX/15DHsspsS3CqK1j0yu7KS+fzJMPP09PlYRNTOFlzRPc9O3zKC0txWq1YtJbWVG6mmR7Fq/tfRgOZiKEothSzBzYV8PwWB9nTL8CgNL0WXRrt1FwTpgdGx8mNjlKxrQoMz1fwW5MYm/tZsxGC517B1k5/zImZ88jEgvTUtNPW10XWVkZaDQaIqZhxDgfzT2HqO+oYUrhHBKsqfTK+zl/zsVkZWXx9Z/dwLZNu6mt3Y/FaUQ2DNNZZWSk1491fBy99zAz5kxFo9Gg1eiIRGMnzsWuHXuxuCZRnJCMENaT4sxlUl4JOxue5tChw8yaNZOJiQm0Wu0pKbN/19PTwwtPrGegxYtW1KOLj3LelUuZMfP9l8/+rPo4qnDpdDokUcTt9dLb2kpxeTnF8+fy4pZtNHnqmJD7aDZrOft7X2Ly5Mm88MyrHFzXT6b+DA6LHn61YQdLcm1UTC6h0eulLTmZG6+88p8eb3R0lKHqaq5+WwlzQRCYlZbGwc5OOjs7ycvL+1CfqaCggIIf/eiU5TW76imOW4RJf3xeoMLUSjq79tHb20v2W0ErlUqlUqlUH05tbS0AFRUVpwztHttQRcZMDVhTIe7kv73yQD/SurVob70D4SMoVPBO7nCAa9Y/ghLTcmPmSs6blvWRH1OlUqneq89U0Karq4vH7n6R6LAVk+hgXN5A2dx0rrrh4vc86erHYdvGPeSxjJL0GQA4bens6hjnjTfeoLMqyPLcWxAFkUF3GS8/uZbv/08pu3dUkRCoJCM1m25XM3JvCqnayRyKvEhgIB5bnJWtB9ZSkjONrMRighEf8fFxRCMxdOF44sR4dldtoGS6k2371lHsv5wedwMjwQM0ddUQb05hzOOiQ9lOy6CItSWAbPLhT21BGAxQu6+VBF02h1p+S8nsVC64cTGtze1sWb+HpDQH51+yCtO1JtavX8+vbqkiP7SaiDJAr9BMqr6Mvr5+srOzaOjfw/TFpScewo/sa6U0/UJMmXH4/X6cTieCIJBrn0b1rt3s31FLb4MHmRhzzirl4svPOynTYWRkhHt+tYYiVjM1exKCIDDqHeDZPz+H5hsaKqdN/USu8X8io9FI4cKFbF6/ntxwGFmWsWdkEFq6mOWrV2O327lu5kwyMjLo6uqi5o0ulufcgU6jpyR9JscGD/PMkf+l3Wpl9sUXc/vs2f8yy2ZiYoIkjQbNOzJbBEEgVRRxu90f2WfVm3REYuETPyuKgkTklC+UKpVKpVKpPrjU1FS+//3vk5aWdtLyYEc/kd5OTCtDCJkrT8msjT32CMgyuhtPHlL1UZAVmS9sehJX2MsCzWJ+eE7lR35MlUqlej8+M0Ebj8fDA//7LGXiRWTkHB8eIskS1XvX87TwEjfedtUHaldRlNM6TnZ8fJz9ew6T58km4AicmM/DKqQy4mrFpLEjvjVm12p0EPSFURSF1198k7HDFo5p+2ga3U26sJgm7wbm6O4gJkdIlNJRgkbeqHqSW1b9PxqHd5GxOJ5D6wc4I/tLaDU6fC1xbN7/Iq5+L0lBH5KiRYlpOFx7kNb2JrQhB2I4GbfYRLX7aVaduYi+Y1qifQ6Wp92MJzDKcPQQK6+aQW/nIN27RLJtU6jb007z0Uf44jdv5H+++wdyfddTHnc+ESnILvfd7Bj6G4ONxaTJVjr91ZR2FfDX//0bJVPziMQiyLKExWY58QAvSRIxKUrdkUYKhDM4O+csolKEV9b8gc6uTiaXlzF95lRSUlLYuW0fKeHZ5GVNPnGOE21pTJcvZP0LrzC1coo6gezb+P1+GhsbiUQiFBYWnhiq9F6de+WVvBAMsq26moMuF+MmE6u//W2mzzxeiczlcnHPHx5m1/a9WHtnEEoMo7Pp0YgaitNnEJW+RuasMRYvW/Zvj5WYmMiQLBOVJHRvK8OtKArdksTMpKT39+Hfh4XLZ/LAntcwjVmxmxJoGtxHRoVZndNGpVKpVKrTqLi4mF/96lenLB/bUIWjREYQgHcMjVLCYaKPP4pmxZmIuR8u4/a9+PWBTVS5jpEVmMTdNy5XJx5WqVSfOp+ZoM3+qhoc/vITARsAjahhZvbZbNjzB0YuHnlfQ6UmJiZ44sHnaavrJT7JxjW3X0BBQcGH6uPQ0BB/+cVj+NotHO46yliHRP40J+3DRzjYvYFV02fgMbbR3F/NaF+AqtbXWXJLJk1NTYw2CczR30qSLRsxaKdxbC/5xqXEaZz0j7cy7O7BoKRwtP51Hjf/D9PPS6eouJjx3X60Gh2xWAyLmEBN8w40ERsh/d+wah0kWJLReZJp9a5nse3rpBvLiTqGKEy3s/mlv1BiX0xFQTwDQ4ewWJ3oQiLHGrsZaAyxMvfraEQNOc4ytrU9zObNmxHHkzAYdWhFPVpRzzz77WyP/ZzyyzW4xwdpeXQI4fAMTDoTrWnH8Dg68IsbWWm/mXA4zJ59u6hqfIPhWDPplUbOnDYNQRCobt3MYEMYkycXbbOObS8+xrVfX0XLkW4KHRfh8vQRiYVw2tIx6Ewk27M40B0gEAj8y2yOz5OmxkZe+fOfKQqFMCoKjwkCFRdfzMpzz33PgS2TycS1X/oSY2Nj+P1+UlNTT2Sf+P1+/u/Xj5HmXUKFOZUOr5vqXUeYt2zGiUy3qBJGb3hv2SpxcXHkL1nC2i1bWJ2djV6jQZJltvb2YqmoICMj44OdiPegsLCQ679zFhtf3kzLqJeKVYWsOu8qNQCoUqlUKtVHTJEkxjbup/BiHTjSEGwnvzCRXn8NRlxoP4Yy35u6Grm7fitWfyoPXng+iVa1SIZKpfr0+cwEbbpaBki2nDqHiUbU4tBkMzQ09L6CNo/e9yw0l3Be9k0Mubv422+f4/t33YHdbv/AfXzj1a1khpayYG4Zr0oPU9+zma0vd1Ect5BZeVcQrImhcYwSyT/Elv2bKctdiBTUcPhAA9OzV+JrGyVRyaQ0fjH7+14kKHkY8fZh0ThRNFEUKUqMMB6xh1UXXoMoirzgfwbxcAoj/W4GBnsxK4nolUSGIg3E9OmszLyTpq4DKBMCLqUZ2TxCjnE6dlMijMWj0ztZOfNcatt3Eo0Oc3HKLTR1vYSIDVEQiUaj1FQfYm9LDYeG+zFqUhiO1dEYtJOsLaU/XMeIsY5Zcy7lv268m8tS/ozdmISgaOgeqSUpLoOG8CvsaDfibtVzrLsJe6QQmykDV88+9llfZ27RapqaG5hkOJ+CnARys3NInyji/37zRwIRD9uPHiVJW4xJE49fHGTapLlMzp4LmlNLX7/TxMQEfX19mEwmcnJy/mMnmQ2FQrzy179yndlMekoKAMtjMR58/nkKysr+6eTF/0xCQsIp1Zs6OjrQjmVQkjOTicAIDY0PEwvkMzY2Rnp6OoGwlwGlhiumX/2ej3P+VVfxKvCH7dtJFUVckkTKzJlceeONH3kAZfLkSUyePOkjPYZKpVKpVJ9XoVCIRx55hBkzZjBr1qwTyz0HmhDlCQyWEELm6lP2iz70AEJePpqlyz/S/vX53NyxdQ26sJVfzruIyZmOj/R4KpVK9UF9ZoI2DqeVwdD4KcsVRSEgj7+vbAtJkuhoGOD8nFsQBIG0+Dzaeo5X5/kwQRvPWIAkcxImvZWLF9/Og2/8lHzdTM496wLi4+MRBIG9HSGmXpxEQXEO1TvrWXnBYtqaO7E7rEi5Ojo7D+HQZZAdP5nqwYeokGTiyEAjiCjGALmmGQSGR7n/L4+RnZ1N61ANrQP9uMcnkEJgkpNYpvlv2tiAqAnRNLyLAamFIlaTHplBVf+9tAf2Mtw8iSF3L2Oep6nr2ouAwLSyeSiKTG5xJpFwhH1H1tJZ7cPVP86QMoh+mw1RlogaJjim20hD4FWCmmGWXTCNzZu2Io2Z2eF9HBRwmFPIsU7DFEonNTmb2VckcvfPnsWZV8hgbwta0ci0jLM45t+Fu7mLsM9CXCFkZWXiC02w9dBL9HQrBCSZ1PHFxFlyyM8sw2AwUF37JP0TbUy9oOCfVp+SJImXn3+dfRsacZBDSPFgSA1w45cvJTMz8wNf40+r1tZWsoNB0t82pMio1TJbr6du//73HbT5ZxQUAOLMTubNWMorOx4iOjCLnkgSo5pGzr1xwSnj1v8VvV7PpTfcwMSFFzI6OkpcXByJiYmnpa8qlUqlUqk+OXV1dXzxi1+krKyMhoaGE8vH3thHwpS3hkVnzD5pH6n2MHL1AfT//QuEj/BFm6zI3PDGE0QkievSzuTiGTkf2bFUKpXqw/rMpB3MmldJT6yKUDRw0vKe0WZM6WFyct77P7aiKGKLNzHi7QMgEgvhl13/tHrRe1UyJYfmsT3EpCiiIDLhG2NG+VwSEhJOZA0kmfLobO1lbMRNNBJj40u7cDgt9Mh7ScqxkFeZwJj9ILHUTsRUN+2aDQwLtRyLbaMzUENCYCqtra0oRycxtjUda+9MCnMms3LJ+Vi0TqxCKg3ic/SwB4uShBzS4tV14hV6iSh+UsxFlMevoqWmH/1APoM9o+RGVjJHfwcHDhxg58DDnHX+Ym75yjW44vbS6NlE1Oai0LSEKxMfolxzCaVxSwkpHjR6mJp8NsFRkT0bakmLLGCx/rssMXyflNBsqgdeISC5EQUNWVmZpKQmMSluJWXmVcywXUmo14rJpsWaEyFiHiItMxlRFNl86HnCAyZEyUiBZR5TUs7AEkunuesQwVAAR6yIprHtnHfJWf/0WmzeuI2jaz2szPgGC7KvZEXObWR7V3Hf/64hGAx+qOv8aSRJElpFOWW5VhSRotHTcoz8/HwU5wDNAwfwhSbQaXVMWZHO2d/IZckdSfzgt7eyeMmCD9R2XFwc+fn5asBGpVKpVKr/EIcOHQJg2rRpJ5bFPH4m9hwhoVyAxGIE88lZvbGHHwSTGe0V7z1r94O4q2oLTd5eypnCz1bP+vc7qFQq1SfoM5Npk52dzYorp/Dm0/eRpZ2N1RDPcKAdj62RO774/uaiEASBa+44n4d//xS2iSy88hCLL578vjIE3s3yM5cwPvYq6968CwGB7Blm9AaJ3t5eRocnMJr0dEVrqX36FfSuHFISsqkePMqrT20lPkvLhmPriXqgaEYaCy+cQt72SuqGhsgXVyBJMYhp6QptI107lYrc+fi8PgqUVPq79lG2OAtN8jjegQg6U4RFiZfiEPI46G0k5g0R1A3Ta9tKWcJiRkN9ZIqzEbQyVosJIXmY8ZBCUkI6U1elnCgtnWBL4bxZ53PwUDXpynyisTBOWya2PB+BkQq0cWGuXHojT1X/jGLTcjw6O5FoEKPOSpKmhOTwFNom9hAz9PDYbzcy4Qrx6tFHmG2/ATEJJkytdB4dYprpSoZNu1i/7SXyy9LZWf0GufIKRJ2dDl8DCel5ZOfMJjQ4SL90ENEookinBij+TpIktq+rYW76reg0/8jEyXaW0NdZwOHDtcybN/dDXetPm8LCQt7QanGHQjjeml9GkmVqgkHmzZhxWo5hNpv50veu5/kn1nKgawfJhfF889pb1cl7VSqVSqVSneLdgjbjW2ow2KPodCGEd05APDZG7OUX0V5+JUJc3EfWr4ODvdzdsAV7JInHrr4AnfYz8w5bpVJ9Tn1mgjYAZ569nNLJRRzYdxjveC+zClOZOeuOD5QhU1JSwvd+feuJIVGnY9JTrVbLxZefR2l5AYqioNVq+d5NvyVt/AycunwGo43sG30EQmZmGmbT0LGXEv25KEhIYTeBWDWCbGewtZGacA9KZxZRjYc+eT8WJY0B5SjdsV2Upcylx3OU3gYPMY+daCSOjXtfIGtyAlm5JhzDM9H4bBwYfo3GyGbCoRhmvcT8SavJycnCE05if/ObDA4NoGi8LJzzZcZH3bQf3cJAn0hra+vx4TS6GENSPT5zB13DGuy2ZOx2M45ELalxVjp89bx84P/oGqnnispL8BoVWg/swho5Plmw05HClt4HODf7epbmXIk3eZy/9v8XHaGtKBNBZs+ZgadqAm9ggrNmX8n22hd5qepuymJXkGEpJ0aQaESkffgwibnZJCemMxAaw65Lxaik89LT67jpjlPfxASDQaJ+AVti/Cnr4rQZuAZGP/S1/rSxWq2s+MIXePD++5kBGAWB2liM+GXLmDTp9M3b4nQ6uePrN5629lQqlUqlUv1neregzdiGKpLmmECIQMbJL5Wia56AUAjdTR/dBMShaJTr1z+BIGu454wrSLIbP7JjqVQq1enymQraAGRlZZGVlXVa2oqPjyc+/tQH+w9qdHSUP/78flprXBj0RiTbGKmWUiZGexmeOIZea2CSdAWDNBGnySRNnsFk62paxnchhXTk2+cR1HpJdhqZmjWLx2vuwSgl0qpswKDEMU4P6MPoFTv1W0fo9zVQFD8PRfQzpD3MH35/H8NDIzz/6DreeHkHYKJScw0WfTrH5C0cbt2JEl5K4aRsCtLLaRrZidWs44+v3QlBE5kZWTj7lvLQzzdQuGAX3Y0jBJtMZGhncdjwEknmRHQYkEXolQ6Q5MjAHLViV7J54/XNVBTMpnJZLp7RAJGwm5jgItGTwNKyKxEFEYshjvLimQhDqRDVMTTWwVCkge7GEkY8WzDbzJQmLSRuMAOHkoso6DgW2Yc2kkz7eA0ppgJiSohOaSeTi2cS8PsJh8M0NjYSCoXIzMwkIyMDk8mE1izjDY5jM518fT1SP0kfMqPq02rW3Llk5+VxpKaGsVCI5eXlFBUVqRWRVCqVSqVSfawkSaK2thb4R9Am2DlAoKmT/DNFSJ6EYPjHPJKKJBF75CHEeQsQyz66IgE3vvo8btzckruKJYX/eXMcqlSq/0yfuaDNp9lLz6xj/6ZWJFccOmMQzAJxY3Eszb8Gi8FOS+8hfGKUEaGdA97HkRUZaUgi0zaZCdGDy9+IT9NHadxk6hqO4hRK8MRc2IRMinUr8Vm66fBXkTA0D6vBgSVSTOPwS8gmHwatmW3btnFkfyvHGrrw+z0kBvIQJTthIUCyUkHTyAv0jbWR0pbHhDRAvnguZUX5rG38Py4o/xb52UWkp6dRqFTyh/tu47zyr2Jbmkp7Uw9jkZm0xD3BnDlzMKaZSdpfyHllXyMcihBot9MeaaC/dYKoT2T2sslYbGZeqNmE3m9k7d5H8EZG6OpvQ0YmMzkHr8/LpGk2zpk2h63Pv0G2mIXW5kMTLKEkbRY+VwyzwUFZ4jL2jT7BnqFXyMspwGccYGxslL6WRJZOmsaPvvq/xEUKMSh2xthPwex4rr/lCpacM4O9a15nQe7lJ4ZI9Yy24Le3MXXqP58L57MuJSWFM88555PuhkqlUqlUqs+x5uZmgsEg2dnZJ6pRjm2owpwOGsF/ytAoafMmlJ5u9D/52UfWpwcPHGLXRC2lhgJ+umLxR3YclUqlOt3UoM1p4vP5uO9Pj6LvLcEZLWZcPIY/sRdjoByz/vjwLVlWENDgFo6RrVuEIepEikrsm3iYeEcC9pmDJGjN9DX2USFeiSQeY6ZjCsNKPZLOhSOUS5LsZ0LpZSLYg0UbT5+8nwxLHrFBG//75ecoEM9ADqRTJi9gjGMEGCNXWYafQYjoSWAKg6FGerQ7sdqS2LKrlTh7Pnb3ZNqHhxhIHWbmnErCEyIHdzRj0Q9jshix6uMJWS1MeN3s2L6LsuCV7HcfJiUjgVRhCtasZPb0rsHnnkzgaBPGnAnkpEGszWUE3Qns6HuGObYbEAUttSNPkT8pjWmz53L++edz+51DxGIxDh06xIPVu3AkOBBFHxMj/URiYcLaERJKICETFujuoDxnLv7oOA8/cxeVznOYv+JsBEFAQaGq6lXWOjdwwSXn4PWsZePGP+Agl7DiQZfi47YvX4nZbP6E7xaVSqVSqVSq/1x9fX3ExcUxffp04Hgmzdim/WSdYQcxCmnTT9o+9tADCGlpaM7+aF48NQ6O8YvDr2LUmHn6omvULGSVSvWZogZtTpMnH3qe4KAOu5yIT9tPmraMholmOjSb8UevRpYUXOP9tHp3EiJKoiOXbvkgPmmEcMSHy9PAbP80smY7YBTkwAQmg4VoKEaioZhDo88TLwmMcQwLacTwM6o9wqLUa+mdqGdsfIiFuh+gj9gRBQOD1GEhGRf1eOhDgw4DdpIppVg8CySFbu8RtBhJFJIxGc3YjWUc7dxMZ1oHIcnHoKeTXCmfqDPCcKyVriovsR2p9MpVjGqfxTV4FgnNqRAy4rAkkRqfh5RyjIILCrnyqut4/N4XGWhOpau9j1xlKYW6FYwEunH6ZzDQ2sqhl8c4uu8PzF5WjtFowmQyYUmTOOB+glzDfDpM2zk2eoCQwUWiQYdSP5mgOYF9x2rRZIwwyXQOylg8WzfuJBZSMJoNpOeXUfXmi6y+YCWXXnkBZ5y9hL6+PkwmE7m5uYgfYflIlUqlUqlUKhWceeaZjI+P4/P5APBUNxEbm8CaKkDqVASd6cS2clsr0rat6L73QwSd7rT3JRCOcd2rTxPVBrl78U041Zd3KpXqM0YN2ryN3+9n0xtbqdnZgKARKJmWxbz5s8nJyUGj0fzT/SYmJmiu7kevMVIhXIFNyKQmcj+yVqJ4iYUXmu5EGrUjSHqCplFkf5QJ9wRlXI5DzKRBXssxeS2pveexq3UNGoeP7PglyIqELzqGO9qJIOlIFSoxKU4aeIExWnCKWRSI5YQCYbI0c0nS5+OJuEnUFBCU3HSykwgB9vMX8lhOBrMJ48VKKjnCYrrlXZQaz6JrYh9rGr+HGDMgBTVUDTyHJsfHgL+aYeEITm0SISlIsmYympgZG+mYI0kcibxCWeQcUuw5BP0h6sY3kxJnprchiV3bq6iYU8ib6x+iIdBEgjSZ3okmTLFErKSTnmoj0T2Lmn07qVr/CmdMv4x+pZa4DJGsjATa+9bSF+jirMxv0hM6xLb6v7AobxEp5nyisSjb6+4h3zwft8tLSiSXosxCwtEAPUeaGcqYIBAIYDAYcDgcOByOj+8meofBwUF2bauir91FSlYCi5bPOS2TXn+UYrEYB/ZXU1fdhtVhYv6SmeTk5HzS3VKpVCqVSvUZIgjCiWIhY29UYS/WIyoTpwyNij7yN9Dp0F17/Wnvg6Io3P78BgZ13VyUNZtVhSWn/RgqlUr1UVODNm+RJIm7f/8Izds89Pb2MDwywOZHHKwtPUjxnCTOvHge+fn5pKWlnZJSGQ6HERU96c58ImMu/JJEMDZMSUkJl14xl+FBF8899jqTtBcx6hpF40/AKZdiIYWwEsAqJFNuvIhjI4cpUC6iy/g8m5oewBzMYTTaw4TSRS7LaFM2EcaDj0HihTwmQgPsdj1MglTOqNTNoKYOFBP7o/fhYxgBHWEmENCSwSxaWEsmc9DIBiboQcRAmnEScYY09nruwRftplS7mv5oFWF5nKmVM5idcwGusQG8jXb2x9YywCHyOZMwHnrZj0ay4PL20Gt4CpvJQUL3PEyWmTx76A16/Yex+8uYHl9Bw/B2NgV+SqlwPiNiA8XNZ9PU6kWI5jFk2INUKTEl7gKea/wJXvNrGK0pGM16/JpBgrZu5H4N+3teQasRyXCUohcstI3tIy22GKvJgSiImPRW4k3p7OrtwGQy/ZMr/fFpbW3lb795mUxlPqm2aYx29PPnbWu47hurKC+f/El3710pisLD9z1F/z4NeXGz8ES83LPtBa795lmf2j6rVCqVSqX69FAUhWg0il5/fE7BmDfAxO4jFFxvB20YUqf8Y1ufl9gza9CcfyFCUvJp78u92xvZHtxHmimR3y47/7S3r1KpVB8HNWjzlqamJlr3DRMejMMwkcF5xh8Qi4UZ6qjFJ4n8dN19ZOVlkJAv8vXv3UF2dvaJfRMSEvDEBlDCWlqjG5GjAmHjCP6QwMbn9jLdeSmrSwt4YcuDBD1Ryu0X4g32MBHrYlzpRKczkC5XMBxpZLIzn96IDb97gtHYYWIESWMGOiyEmKCLHVQariRBk4M9L8bRkY0oAQOjNOIKFdEmvUkui8hlGTECeMlgiKNs4nss5DuYhHg6lG30sJcy8Xxagm8yLLUiyRIh3LTHtuFQsuluFdnXXUVddRtRjY8U3zyEiJlpXIYeKwB+hgloBygyLsMiJVLjfoIiTQ6eboHO4TFMunKmJV9LTImRbJzD7tg99Gh2s0j3bVLFCiLRMKk6I/3BQ/z2ma+SnzCdHMtMZi+YSatnN6nzxzg28CS+TiOLnbfhCE4mVVdGnetlGuWtjHqHmCJbifRPoDFMZdjdTWN4PXFFZiRJ+pfXOxaL0dLSgs/nIy8vj6SkpNN6PymKwnOPrGeK+RLS4/MBSInLJsmTxfMPP03Zb0r/ZfbWJ6W9vZ3OA35W5N+OKBwfSuaYSObVp15m8i8mqWPAVSqVSqVS/Uvd3d0UFRWxdOlSNm7ciHtrDchRzLYRSJuG8FaBCIDY88+B14vu5tNf5ruqbYTf168Ds8Rjq67FoFEfe1Qq1WeT+q/XW1wuF8FxEW00jmSlmHGpGxkJn9dPyng5+bFVRJsD9LWM89Oh3/Hb+35CYmIiAOte3YghmII1LsBEQMIXcRGLxOjo66BE/DpFpTM5eOwoiUopQU0QC07s6VZqBzeSL6xAFqK0yRtQtFG0iV76mjqZLXyFPvEg8eSTKlTilnrx0k8a0+gPV6PR60kz5pFiz6LBU01KtBxbLJ0IPhIpxUkxEfwkUIiVZFwcZb/2LygSRPCTKy5iRFeHLmInS15AhqGSvdLd2MggWZqMTrailbXMM9zCLt+faAttp5yr0GHBSDxRgiRSzJHQEyRRRoo0C23sBdrl7fhcBbiiLUyP3Uyo34SiKEQi4ziUAjyxXvRaGxqNjuHIQQaDjbSxGa1sxzE0GxJsVOYtZbI0nzd7/4I1Z4wlU79GcEJi55tVNHv6kIIa/JEwJcqFjNHO8EQjB+uexWDQE2eLI86u+5eZNuPj49zz28eI9sdjJJ77J14AXYTC4nwuu/EcCgoKPvT9NDo6indAJi0r76TlSfYMYt1mBgcHP5XDpIaHh4kX8k4EbACS7VlUdXmIxWLoPoKx5iqVSqVSqf5zHDp0iGg0euJnz4FG4istCPLISUOjFEUh+tADiFMqEafPPK196B8Pcufr6wnaR/jetLMpS0g7re2rVCrVx0kN2rwlOTmZiHacYNiI1zeAPZqDgkK/cICphsWM+GwYzVqSzbmM+LwcOXKE6dOnIwgCO18/ynnlX2Mie5zfPf49cgxLGdM0YZAsaCNxuFwuotEwsaCATcmkJ3QEs8tGmjyHdO0MdAYdMgGaNC9S5XkUPVYkSUZGIks3F0EWcSrF+ORBUpnCkP4ADn06m+vXoBdNiGEr7fJ2GlmLjXSspBBkHINgRYeJVM1kkimlKGcyisdCm3cXLZF1pIVnkEYeY+Z6yhwL0A/rCce8eBmgTzmAUylmk/sXSHKMIepIp4148vHQi0QUO1kIaOgP1QE6bGTiUwbojuwkkWKschr6qAOtqCMkhxmhkRghDoeeZSBcg0bRE2KCVCqRiZDHcsZ9TQwNDZGamkpcLJ/GkS4SslLABhdfvZrm5maadg+TOFZEftx04kKFNIbX0aR9jvTYTGJiiKWrZtPZ2cnB/UeJhmNMnlbE5MmTT2S2vPzMemyDM6jIWUhUinDkyGEc/knEmfJ46I/P899//Pa7ZsEoikJnZydHDzeiKAqTKoopLCx81+wTURSRlVOzfRRFQVZin8osGzj+e+BWalEU5cTncnl6SUyzodWq/1yoVCqVSqX61w4dOgTAtGnTUBQFf107uReKoLdC8qQT28m7d6G0NKP7419PayZvKCrxtWd2MWhtYlpiDl+eqpb3VqlUn23qU9hbSkpKqFiSxYsPbCUcMnEGlxNS3HQbtjEh9TKqbUAXNVDneh05NM66B+NZE9mAZJxAO5aGmK7BbLBj1sSToa0gIA1gllMYj/QRixUSCcrMy7+QuuFN+P0TDChtFCu5DEp1xKQJwuYRkos0zF+Vyxv3+9COS5iCcfhig/ikUaIEieClg20MRZsYijSTx3ISKUYmhgY99TzHILXISDg0KRg1NhRBwSN5iIgedrn+RtgfQ4cZq5KGEQd6LBhDNjYN/5Y0pjNEA3U8ixYjmfJ80sWp9Co1+BimlfWYcZJAIQoKTbyClwE89JPBbPTY8CsuwlKQLJbQxmYkWWGIw4zQip0svPRRz7OUK1eQQAFNvEoey+hmJzJRrJpkGuta0Gg0RDRuzDY9vpAbq9GBXq/HYDCiiVjRGTS0BDeREOuhj/2EmaBd2kpWuoWU5BU88N+vk6WbjU7U8/zmavbPreXs85cxMjLCni01XF58KQDRWBhB0pNumIoQjhESJKLR6ClBFUVReOHZV6lZ1026djoiIlWvvEnp4hquufGyU7aPj48ntchKe89RClL+MXa7Z7QFeyakpKR89Df1B5Cfn0/WdCM7q5+hwDETf9hDe2Q7V3/9DHVolEqlUqlUqn/r7UGbcO8wss+L2R6FjIUI4j8ePaIPPwAJCWgvuOi0HVtRFH79ah01SjUGnYZ7ll95UvawSqVSfRapQZu3aDQavvXDL1Gz7xBHqlrZEfofEowZ5MdV0m/ewYhhHwoyiUoOl8/7fxxs30ZsQEfMXUCL5yBPjP6e1fOvJSezgO3H/oBZZycQ9iEoecASDFIi2YmT0epFNg//AZNeoXXkRQrNC8gvzSWUJLH6i7chyRLrHq5mIjxIRApxUHmYDOaRyRzC+DjMwyQrU3DTQQErCTKGlRQM2FGQGeIoh3mMEulczFICBhy08gajdGGNFJBCOjbSiKeQGH6GOIJRjsct9xPCiw8XMjEKOBM/LnrlGgCKOZ/9/JVe9jNOOxIRrKQznVsYpw0tZnJYjJlE3HQioKWMizjKGozEMYevEGQcN10k0UKAMVKYQiazCDGOkzJ62YclnIym1UZD52OkrxrhwktXsv/ZtczPuRS91giCQp1vHXZ9BrpgImE5iF3MJtWay1C0G9exBtb85U1umv8rDG+Vk8yKlnDfo99h3/pmCpIq6T7i5UXXvZw39yZMeisFeYXsP/oQCWMiq2+ahdFoPOX+aG5u5uDr/SzPuR3dW2OxS+XZ7Nj2OIemHmbmzBknbS8IAlfedD733PUkI11dJBqyGAv34bE0cNutV3xqAyCCIHDzF6+hat9+jh7YjTXOxG3LLiA/P/+T7ppKpVKpVKrPgLcHbfxH27HnSwjEThoaJff2Iq1fh+5LdyKcxuIRL+zv4bnO/UQSJvjDvMvItMaftrZVKpXqk6IGbd7GZDJRWjyJbGERvWOtGDDiCbQix/Wx1HkNBw7tpdR8HnVdVUgDCSxy3IgSp2BtKEA7GuHF7feikayclfx9lJCeavkxxixHaRupoWW0k90Dj+GljwWzV7C0/FJer/kbBzqeR7AWkp7qxB/wcM8vnsE2UcSAUotVl0R/tBq30sMw9cjE8NLHBL3YScdDL2EmABDRocWIGScRPLSxHhAZoxURA06KMJJAJdczQjMKEklMxssA9TxHAkVU8gXW8WWclBJklAQKMJNIjDBhBslkLjksJswEiZQSYAgj8fgYoJtd2Egjjel0swcv3YQpAAQmcRkxgnjowUgccWQgAGEmsJPJUeFpJhnOpTO8l1G5jdSxMkStyNChfmYunkTcFDebmv4AXiv7a3fTqWulQFyOGT16rRm9YmKa/WLcyhi7Incx1h1hm/kVHLZEKvLmsr/5TZzu2ZQ6K5mRPZV4/xSqanbxonQPOSmljHmH0BcN8rVffZWpU6ficrl4/aU3qa8+hsVqYuHZ0+nvHibPNPdEwAZAI2oodMxn/449pwRtANLS0vjuz++gpvoQg70dFKQnMGPm7djt9o/nhv6AdDodCxctYOGiBZ90V1QqlUqlUn2GuFwuent7sVgsFBUV0fPKGuKKBDDYIbHoxHaxxx8BQHv9Taft2LXd49y1uRpvWgersidzaeH009a2SqVSfZI+V0GbcDjM2NgYDofjn05Umz81lRdfP4pRb6V8xnR6NXuwyyspcs5kyBwigSJ2Nmzg3MyfIAgCgiCQnpxLr6+OkX4vebZSkuJTaHPVUJI8l2ixSGt0LWP+JKY4VhHWj9PcUE19+3dJCleSpCtC9pjo2BVm/TO/w2nNQPFFESU9rdr1xIv5RJUQUcWHgBYzSRRol9Ee28Y4HRiw4WeIKMHjJbgxUMZFBHGjIDFGGz76yNFdDDKIiohG1iMRZYJubGRgJB4/Q+zk14gY0GEmhBstZmSk41WiGEFApJ8qTDgZ4nm89GIjFR02JCLECOGmC4NgZkipQ4MRkAnhxksvCgo2UhEFAZfSSDX3kScuZkXCNznqXktY8aEgY1ASCMkjBBuSefUnvZQscGIv8tN7ZAhzMJs0s5Ym7xtU6C8nJLkIKuMc8j6HpJ9AHzMi9mUy4o6jXelis2kdeqvCIsvX0Yo+AIqKC+gaqWfdgVcIJVmx2ayk55bT0tBBYWEhf/3Vo6R4FnJm6kUEIz52P76BYd1h5pinnnK/GLQmRgKRf3rPWa1WlixddFruX5VKpVKpVKpPs79n2UydOhVRFPHXtZG2WoakMoS3hikpoRDRxx9Fs/JsxLdVY/0wXJ4Q33/mIBPJjSQYzdy14OJPbVazSqVSvV+fm6BN1b4DvPzYFrThOCIaN2ddPo/lZyw5Zburr7mCzpY+XANjZC0PsqT0PN64vxGdRk9E8ROVQ0SkCJ0DTbi9o+i1BswWC0UVWQx26BmT2lBSKkhNMtDt6mJ4tJuc1FIWLjmPN6texOLJxKnMZuvE70lKnUth8jyOje3C4S8nPH4QRbKT7shH63di01iJk/No8L+OGNOSQCFOSnBYHByaeJwwXqZzKzpMdLOHYWqZzGWYScJEImE8OMhlmHoC0XFCTBBgAj8uQCCJMiboIYEi8llBFztx006UEFO5HgN2XDTgpIxRjuFnkDxW4KKBERqYxhfQYaSXffgYIpUpBJlgQunDSAIuGhEQieAnicnoMNFPNRpFh0SUREpwKc0c9HoJxULM4HbCwhgD2iq0aHGGpkB/AkJHFm8eeoMi5yy6h3aTKs0kQ7JzlFdJooRUYQrj/l5C+mEqxWsICSGKzcvQiga6/QfZNPYzphYMkJd1vCqUIAq4gh0sz7yDOYunkZKSgqxIbNz4FzT6TZjHSpiUOxcAvdbIvJxLeerwQdrs+8lKLDnexltfBLrGjzL17A9fbUqlUqlUKpXqs66yspKnnnoKk8lEdNyL4hlCq48iOEtObBN77RUYGz1tZb6jMZkfPltLr7GFgMbLPQtvJMFoOS1tq1Qq1afB5yJo09/fz4v37WBB8q3YkxMIhL1sevwRsnLSiY+Pp6WlBUVRKCoqIjk5mV/89sfA8cnM1r22gbaRA4xPjDCkdBOLynS5j+AIN5GhnUFY8dA50kbUaiVkHEJWYnT4quh3dWMP52MKF9I81krRLA/xllTydWfhGfeQIy7koPtFEuw6csoS6WzaQhA39lgBh/1rSZbL6VWqSJCHiUhRxqjiGJtJopToRJAwPpKpoJd9uOnEywB5LMVOBj6GsJOBBh1BRnGQSUAzTAAXx+Q3iFcKsJOFDjPD1DGJi1GQyGQ2E3QxRC21PIaTMuLJJ8gYwxyhgDOJIwcjdpyUYCMdJ8WYSaKFtbSyAQ/d6LHipoMyLmaMVnrYTQFnYSIRBYEgHmRiFHMencpWYmEJEwl0sY0izqInJiGKFjz044n1UuAqotfVxXinxDL+mzjyCeOjj2r28FtWG3/DEf2jKJFMFPSkJMfTGz6IlVQsmgR0UhwD2oOckXQ8EBOK+An4QqSabCQmJiIIAhpBS4KQx75dBxC7pnN4tI60zCSSk5PRaw2kxOVRP7qJvQ/txywkkpVWQHKODSG/k/kLbv0kb2+VSqVSqVSqT4Xk5GSuuuoqANy7arFmysdXOEtPbBN76AGEwiLERae+PP0g/vhGE9XDnbjTurimeDYrskr//U4qlUr1GfK5CNrU1zWSyjTspgQAzAYbmdpZ/O3uJ5DdVpKUyaAIvCo+zsyVBVxyxfmIosjg4CA7XmhkWcbtNMgvcvsXVvGzb/yZQvksvJpeokoZ8eQSEyNsPnoPMxdMobJgMU9s+B3ZseUkldnpHoPhDi/reZQC3SoU0yiSN8r0lPPpidNSUl7IqjsLmTRpEufMu4aJnj6C0XFiej9KSMSnDFH41oTDTbyKhVQSKGCQQ7ioJ4PZFHEObjppZxMKAtksRCaGh35kYphJJos5mIR4upUqDvEQ6cxCQSKbRTjIRkFBIoKFZIKMISDSwWbGaEWHHj0WQMMYLVhIIcAIh3mEMi4gicnEkY2bTiq4mhQq2cNvaeZlUpiOhx6q+CM20nHThYkE8liBmQSyWYgeMzosdLOHNmUTLqmJC3R/Ybv8GyQhSKP4IpIQwRzKIl6bT0yJAQK5LOEIT9Jh2IgeK6FYlIhxgqKMhYTDIUYmBtDpdaQKWXQo2xmaOJeUuGx8oQmGws3MKT4bnU4HHA/QNfZVM9E+hGNwjBRbEg3dfbgKxsgtzOBQ/T5ynZMJi15MwQwOtGzCIQb548/+B6vV+snd3CqVSqVSqVSfQv6jx7BmyWCIA+vxqpnSwRrkQwfR/+Ku0zJ8ae2hPp6r7iCc30q2OZGfzF79odtUqVSqT5vPRdBGr9cRU/wAeIPjdI80sbvlVQRZw/VL78SgO14tKCadwc51T5GStofFSxdit9sxJkp0jexn5tIpJCYmYg6nMzX+PMKCl+7QXo5JLggZsBodpCRkUp41n+kFh4kfnUlN+9NME25CE5zKzoZf0ai0UKI/i3GlnRx7KYIxSt9YM3t2jOP3hbjj+1dz13fvwyIl44uMEhG9ZAqz0GohprhJCVcwg1uJEcBFA2H8JFBABrOIJxcDDmq4lxEaMZOAFhNTuI4udhKTYtiELPKwME43TspIoRwzTjToMBJPBB+gkMMiBjiEgIgBG5m66RyIPsQAByjhfHRYUJAp50p62I0WEwKgx4JTKOCI8gQKMlO4nl72IQBW0pCR8TFEFguQCL81B04nk7mEZtYyThvjdCCixxcZp8x8DuR10N87QJp3GT55mPbITrLFeehFM1E5iIiGRu9GojofNrODKanzQBIZ6wugV9IIii56AofJsyRzSHqUcJdCQrKdS+5cQE/VXuJHLBh0JhoGdzLs7eTWBX9g3b4nGPLXk2GuoLlpNwdGniY9oYB4fTZ5KTNJM5fQ7qlkxLKXvdsOUlZW9ond2yqVSqVSqVSfBj6fj+9+97vMmjWLm266Cd/RYyQtBpJKTwRoYg//DSxWtJdf8aGP19Q/wW/WNqDN6cYn+3l88XVYdIYP3a5KpVJ92vzHB20ikQh93QNsrnuN2pYq5JCIxp1E68AgZouBXbH9FE3KIys7E61Gx9SUs9j6+lMsWrIAi8XCt/7fbQwPD5Obm8t///jX2ML5BKQAU8tnUyHMYcQ1SnhUy5Hwc4QiARRFoTinnIOu/QwNDTIoDxJVgugEM/FKAdFoDL92hNqhN5D7FYKym607NaTY9xIy98OYk3L5WlBEBqllmDoMsUS8jGAggTgy0GJGIoyDLEZpRYG3slWMFHAWMYKUcCESYSTCRPAxRD3DSgPpzCKOLIY4SiIFxAhhIhGZGN3sRkAgjUrCTFDASqr4Mx3RrTgpY5wO+qkmiJsKriKRQvSYaGYtXvoZph5FAR8DzOKL9HGASq5Hi5koXo7yLAbsBBmnnmfQYCSPZbSzBSelZDIXLwMc5EFa5A2k63Ppam+nMnwrI7F2QkzQxCvkyEtQNEEaeRkvfRhMGgrKsrDE6/C4mukZMaOX0zAYzBxwv45gD1BSVsJXvnst6enpBAIBRFGkfUk7OzftxeUPkz/FhLD9TOKtSVyw8GYOtm3jSP8TjBq6icsIsMTxVVq7Gmga24Yck+mPHWZq9kyaDm/7pG9xlUqlUqlUqk9cbW0t99xzD3v37uWGq65BGu5Ga4idmM9GGRkh9sqLaK++DsH24SppjvsjfP/pwwiOcbrp4s6KZcxIzjkdH0OlUqk+df7jgzbPP/0qHW9quHzaj3h2890oow6yjRlMNV5GQByEsJG2miEAsrIzkUNamtvbOXToEBUVFdjt9hMlmmfMncKOJ1/GHTxG+6CBeFsSkiwyFGmjKbIOX0sOo67fsKDybExpIUZb2tko/RABgWSmEMRDQKmlkDMgtZfxbhlRNhCTgkRCE7iFXuYrN2AW45lQ+pnJrXSygxoewM8wNtIZo400ZpJEOcMcJYlybKQTZpwIgbdKgAsoRIkSoJd9BHBhJpF4CuhiOx76kIixjaPEk4cWIxH8TNDLfL5OJ9vpYz/xFFDGJVRzLylU4KSEVKYSZJxRWojgQQF62Us6s7AyRjIVGLETRw6dbMNBLoPUYsaJg2zCTDBANclUYCcDKyk08Dyz+SpBRjGTSJYwm1ZhPQHvVMKyB688RLwui/7oOBN0s5n/QpEkIvhw6DJZmn0l8ZkS+zpexW15CY28Hd+oHl/YhTU/xJon/0pqaiqCIPDFG75FT/MY6dlJnH/Ncm7/2nU0Nzezc8s+6jr3UxK3mLT4PBaXX0BXSiPP7/0TPc1jPDr4J/JN80HWUzX8DHNmzyHbWYoruveTu7lVKpVKpVKpPiX+Xjlq2rRp+Ju6sKRGj694az6b6FOPQySC7qYvfKjjxCSZHz9Xy3DQy0RyI+W2dL5RueJDtalSqVSfZv+RQZvx8XFefX4DdQfaqNlXyzlTbic3vZhZUxbTuHsQi5LMqG8Ut+zBpR2lInsBLXWH6G7vxz3iZTQS47d3vMpg6FfMXVHJpdedw7RplUyaVIY28Un0Yxr8YxFcrgZCGhdHg2spM5/DsqRrqevbzl/X/JTRcCdaxU4iBYzSxgQ96LFiJQVTJJmoS0QjDzCJS9AIenYov8CipNHGJkblJjQY6WAHs7mDbOYTYJxhjrCZH2HEwTgdmHHipY92NqLFTIzgW8sTaWH9iWpNOqwEGMXPKHos5LAYBYVe9mIjEydFeBkkwAhb+W8MWEhlOhP0ECOIgOatGW+86LFhIQkTTnwM4mMIDUZSqUQmhgkHLuroYAtRQgxTh5VUUiinh93ks5xBjjJMPWYScdNJjDANPEsyFdhIp0epIk2ZgYhIn3IQsyaJYnHV8UCSkINLaQCgLGEplQmr2TV0H7nR6YRH4wAHhqwQM6+IY/Wll7Jo0SKMxuPD37715R8R3juZRQkLaeh8id3PttPU8Ee8rTay9NNJDYk8+fr/sXTuKmwmB+u2Pk9B/Aqy0/OpOdZKIOYhPTmH6ebz8Y0eo9G2m7mXVXyCd7pKpVKpVCrVp8NJQZu6Y1gzJRS9HcGaghKLEXv0YcSFixFLPtxEwfdsbuVAxygJU3oZ8kf585Ir0Gv+Ix9pVCqVCvgPDNrEYjHu+d1j2Aamc2bahQiGLRypaUQj6shNKeFpzz0IchyKRmZQOUTeyBKGhFH6pSGKUmfhlhtIpoJp8qWE9GPUbnuKZ4Z34r8twI4N1Vwy81vUNOwi4PVjjCbT7T2EpLjJdU6mY7AOadSGMzgdUXKQy1JENOSwCC8DDHGUTOagw0y+7ixqeZ0YERRFwE0PYSaQiVLGJaQwhZ38gmruw0g8pZzPMEcI4SHACDIyYfx0sJVp3IjprRLbMUKkMwsRHcmUosdCgBFGaMNNB2lMZZx2FCCdmUhIaNBjIoEMZjJMPWfwawREhjmKm058DBJkHIBe9pHJXHzUYyaJQQ6SQAFHeAInpchEsZBMK69jJJHDPEopF9BPNQYc6LCSxzL6qGKEJpIpZx7fIsAIPeyil31M0EM+Z2ITkhmU6+iO7WUk1oooCMzVfYVR2hAlPSXSMra6fo8u5KRf7qBMvgwpJhPuGmVc6eBofhMrVqxg394qutsHqK1qZK75AlLNJTRPmND4Ezm8bR+3zP89GlFLfvJUao/U8tqB34A2xtLcLzJv5iJ6untJjc8kEpSpHXgZXbqBFu96lqzKZ/kZN3yyN7xKpVKpVCrVp8BJQZu1tWRNBSG5DEEQiG3agNLXi/5/fvmhjrGnxcWTuzspLQ+z2dPJ/5t9LsWOlNPRfZVKpfrU+o8L2jQ3NxPti6ciZxEAs2bPYt9OgQ3VT5KSmYgpSWZsopEC02KMsbNoDr6MxZ1ESBxBUvrBIFNhuowEawqQQp97EonE8+Bfn0QvxTF7UiUpcTkcaHuDYLSDKfpJCH0D5Jc4qNnWBOEUxuR2JgmXYFTiGaUVE04m6CaCjzE6MAsJyLKCGSfDHMXDAGE82EgnhSlE8eOmg2LOpY/9aDEyTD3x5FPKhWgxMMhROtlGNguJEWKCLuLJQ4+VQQ6TSDGjtDHAQWJEMRGHmRlM5wuM0MJRnmCCTmQkHGShxYCJBAzYqGMNAiJ2MjEQRzYLaeZV5vJ19vFH/AxhJ5sD3HuiJLiFFGIECONBQSaP5TjIp4XXkJAw4sBOJgFcgIwWA4v5EU5KEBDfqnKVwEEeJJ5ChqljRBKZK3yVmBBmUDiAXmtif/Re0piJR+nH6SumX2klSSsR9dkIShGs2iQC0hhpwbm8/Lc/EI6ECbY4yTRPIUmYxNq+nzNFWEJqlpPBQAuZliloxOO/BjqdjpkzZjJhP4sBXytLK89AEATiExwY7SOkJ+bQN5JAg+4Z5l2az5e/dfOJ6lMqlUqlUqlUn1eRSIS6ujoEQWBKeQX9d7+Ido50Yj6b6EMPImRkoFl59gc/Rkzm9+ubSE6CvaEaFqQVcPOk+afrI6hUKtWn1qcqaCPLMm1tbQwPD5OYmEhxcTEajeZ9teH3+zEJ8Sd+TkpKYunKhYy0vkFOcRyTk7/PCxseRZbnk66rICiM0q5Zj90az7kr7qKxqgc7iSf2j/lFNh14EYMUh0yIvzR/B41sIV+/EHDQLO0me66DdUf/jGtUQyQaI4ibJKGMIeowaI2EYuOI6DFgp4+9JFqTCMkZBBmhi124aCKdWcTwU8DZ+BkiSoBM5qEg46KRTrazkG9jJoljvEkcmaRQjhYDMhIWUkljGs28hp9hLCQxTjsumljG/1DPGlKoZIw2Argo4XySKaeeZxjiKE5K6WAbWcwlgUJ8DDFMIxE82MnCzwi1PIoWMxnMIZFixmglyBjFrCaObEZoZIxjgEIPe4ngJ4wXL91M4kpCjBIjQhc70GMnnjwEBEQ0aDGQyVwO8jdspJPODBLIB0HCI/fhFYYpFc5mSFNHNK4Pj+8YO2K/wiQ70EtxuKU+LGIKTn0e0ZgXgFRTCRvXVPP9ix7GoDNRcPZUHnz9f/DFH0VKKqS40IrQknzqfaiJoDUK9A300Nk0iKIoOHONuPpa8Oo7WXnpFL7yjVvVgI1KpVKpVCoVUF9fTzQapaioCN2oD1NC4PgKZylySzPyzu3ofvhjBO0Hf/R4dl8XPWN+rFNa0IZEfr/wMkRBPE2fQKVSqT69PjVBm0AgwP1/eZzRRhEHOXiFVix5W7jjG9djs9neczv5+fk8z3aCkeWY9BYA+r0tzFs2DUWBtvoecnPyaBt/BqNoIz4hnhLNZPxRN4m2NKxxowx1dRIMBAlG/TR69jA35yqMJj1mh45N1c+Qr51HUdFSNKKW8HAI9/CbRMZM5DrLODywESSZAeEwsiZEnCUBT2CchGgBg2INU8un4bD7eGXPV7GRQxKTyWQeHWzFQzc+BklnOnqsTNCNn2HC4jhG2U4ipXSxgzDHgxJpzKKFV8nnDBIoJEoAD70I6DjK04joMJFAPc8RZJxOtpDDEkS0tLOJIGM4yMdNO828hp10RmjGQgqpTMFKKod5BIkoxZyLmQSaeIV6nsVOJoMcJoKfci7HSgpaDNTyOE6K0YsmDsoPAAJBRnHRjAEbMUIEGEUiQivriKeARIr5e6BHQGSQgyQzmWNswCQnoBesRJUgY0ILOp0eeywbpzwLr+xC1IBH04mkBGhSXkEKn8kE/bT2HyQlIxFNMJE+Vyf56WVoNBpmVSyi+LJZLFu2FEmS+PX37qV/vJzBsW7ae5rwRcfImK0wvbCY1/74FAsTbkcUNQz01JM0Cc4smsq3f/CVE6UrVSqVSqVSqT7vIpEIixYtori4GF9d+/H5bHQ2BGsK0Sf/Cno9uquv+8Dtj3rDPLTjGOkFPg54+vnT4ivIsDpO3wdQqVSqT7FPTdDmjdc3E2nMYnnOqhMPxIc7t/DKc+u59ubL33M7TqeTs66axcan7sWpTCIieIkkdPOlq65jw4aNtDW1sSjpNhqt60krtFNVvZOQT8Jrb2H70RfIdk6nbl8dmdqZdAY3E4x6iAYlSiszMMYpWOviMYWSaRrYi8VhYOasWTy0/ymSRhZjE4uYpLVwVP84w8IB5lq+QMgwTHJyKgf6XiYpKY7SggqqDu/ASgqzuBU3PQQYwUISAhp62Ucv+0ggHw0GBqmlUFxOv3yYGu5nhBYSKWSCboZpwMsA3ezCTScadAhvVY4S0eFlAOWt/7KZzxBH6KcGDVpsZCKiIYSbBIoQ0GDAjpNSspiLlTScSIQYZy9/JJ3pKMQo5UIaeI4JeongIUaURl4iRphhjqIgkWudgRzSEpDdAMjEKOZcbKRTwwPoMGEigQEOoseKmw60mBnkMEbiiSMTF/UEGCOdeEKKB4kINcGnKRFWky0uxWKNZ8jbRrF9GYejT5DhLODo2Bv0y/uwa1LJludjaE+nT9jC1je3MFYSJr8snSHhCBdNvpBwOMwDf3qSAXcHDaM/RjqWQb5hIWazESnSy+TKYt6IP8TB8JPEC3l0+g6Qbgjy/77yHTVgo1KpVCqVSvU2c+bMYceOHQB0/vxh0vIUhJRJCIKAtGkDmgWLEJzOD9z+vZtbCcckhk0dlOvTuTi/8jT1XKVSqT79PjVBmwNb61iUdnIGw6T0BWzY/b9ceX0M7ftIp1xx5lLKp5TR1taGyZTCpEnnYzQaSUtNIz3Vz4R/GI9ngkO71pETXEl53DS6g/vYUPcwKY7NmOxlHA7V0qUcotJ8JVanjrz8HELRALYUDUnReDQpMHPONA7X1RD2y0zEhojTjdMTqyLOkIVoCbHO+wN0XisZWen4UhoxWnTs27MfbTCVqNBDlOCJYUxTuQ4PvRiIQyJCB1voYS9hvIzF2tBiIEaEVCrRYiCL+YzSjJ9BZvNlmniFcboAiVFaSWYySZThooF0phPCTT5n4CAHGYkW1hJPAYMcIoEC/Ljw0EslNxAlwDgdyMT4/+zdd3gd1Zn48e/c3u/VVe+9S5bcu427jQ2mhd4hBNKTTbIpv03Z3bRNLxBIAqH3DgZs44J7l2xLsqzee729zvz+kGNwbFooxnA+z8Nj35kzM+/MHaPRO+e8R4sZJ7mUcDlNrKeNLYQJkkg5VhLxMUIPh2jjDTQYsBudjNGOKZJNEhWU8DmO8jB9VNFHFeO0o8dOGVdgxEkHO2nhdRxkocOKAQe5LKVOehqNoiOVGdhII5WZbOO/SVWm4fN7CCs+0EVo9u4gXlfM9tHfkmufyZLYbzHQNYombCGs96OEIwSt/Wxuup+dPjff+umtZGVlsXnTFmo3D+PuSaBf6WHtpFWU5U3HbDazpfNvmEwm8svTSWcKbv8IrkCAb/3wDuI+wAOHIAiCIAjCp12o7TjaUhkprhC5pRmlpRn1Lbf92/s71j3Oy9XdzJis4pmRYf688ErxAk0QhM+UT0zSJhqVUalOrV+jklSg/Hv7S0xMJDHxzWryw8PD2B02nDOGGe1az0DLXuYnX0akz4lv1EeCvpxk8jgSvofcSRXMyLmBxq5Kuo/4SUiOR5IkFEVGMoZ4pfn/yHVPo8/dzOG+DeSmlrJvcCcd/v04pCzSwtM5PvoSJsmJwWSk3XWIVGsxt634EVte3YF5tAAT8XR4tmGWk9Dj4BjPosFIPCWYiSOFqSeGEYXx0osaAxqMGLCjwcgxnkWLGRtpvMH/YsKJg0xyWMIWfsxkbiSEm1qeoZ8aFvA9YimgnyMYcVLCpbTwOgrQSxWx5NHLIUZpxYgTFeoTM0YpGHHSxW4ymYeTbI7zEomUEkshITxks4hOduKmB4/SRpd8gDgipDKDAY4QQy51PE0eK0miggzmMkYbeuyo0OIkjxyW0ctBogTxMYRdlUQgGsBJLjrJhKKE0GAgSaqkI7oDSyAevexkXGpD0segMci0jx/moGcDRl8SQY2LMW0jTkMaF86+magmwKP7fsLj97zKxmd3UTEvl57x45QZr8JggJ6RVmZZFuEJjBNQjZGdnc21X1/Fy49vQZYVvnjZFWRlZf3b97cgCILw2SBJ0krgD4Aa+LuiKL/4l/XXAP954qMHuENRlMMfb5SC8OGRZZmamhqKi4tRRj3oDWMTK+KKiD72HADqpcv/rX0risJvX63HYdLRrq4n1exgdVb5hxS5IAjCueETk7SZPLeI+q17qcxYdHJZQ98BSqdlv69eNmdSX1/P/b99CXMkGdmo5vYfr+He34aZG7Ocg9vqiLEXEGtNBiSOdj+JOrWf1pFqImofNdKTqDtCNDU0cmz0DRJVJRSlx2NP0tA5eITW0WqCA7NZpvwMneKgSdnAMI0URi/iCI+TG72KPq8WQ4KePzz5HcYGfGhkM4XWJbRqdtIS2koac6jgeiRU1PI0VlJIZgqNvMoYbeSylFFaqeQGQngAhQwWUMXfMRBDHiuIp5QWNtLDIdRoGKQeCelEUWMPBhz4GUGDkW4OoMeGiy60mOhkJ+nMQY+Nau6ngNWYScRNN2N0EMTNTC7DTgZd7GEKiQzTSJQQZhLQoMdNJv0cJTWwgDGplSwW081e/IxiwIEOK4PUEU8JRVxEO2/QwMsEGaeSmwjjo4i11PIkfVQTjUZx0c4gdVhJpE9XhVWOx0Ub2oiJSDSCQSWRZ5tHgGFUUT0ZplIOee4nRZoJITVSWMWIoZ3XDt3P0Hgf8ZH5LIm7mqM11dyz/lEyJzsIBfeTZNVgsHazoeOPRFQ+pi3N45lH1zE66KZkag4LF8/F4XB8oHtQEARB+PSTJEkN3AksA7qA/ZIkvagoSt1bmrUCCxVFGZUkaRXwV2Dmxx+tIHw4mpqaqKioICcnhwN/e2Kino3GgmRJJPL6BqT8AlSZmf/Wvjcc7eVo5xhXL43l/5ra+fGMNWhV72+SEkEQhHPdJyZpc/7apdzZcD872vqJUWcyHu0mktDBl6644QPv+9VntlFuuIRUZy61XbvZvGE7tUeO0x+8n8HBAUocS4m3pRGM+EEd4Svfu5nu7m7a2trY32lkX8tzeD1enKESIgY9kydPIzbDQFtnEwZvCrnKaiSdmjh9FjGRW3khfAcx2kxSqCCS0YCtJ54jtduZrf4ak+Q8xiN9dLq3k6SaRDeHiaMAPVYsJGPETgg3YbyYiSeRyfRTjZ9hgriwk4GNNLQYOcYzmIhHJkqIibovdTxLCZcwSB1DHCNKGJkoPRxEj40AYyjISKgI4sVEAhVcRzvbsJKKiy5qeJIYsvEwQBgfSZRjIhYXnbjpxk4GoOA9sd7LAPmsQULDGK2EFB9V3Ec5V5HMZDrZTTpzGaWJNrZSxpWkMpMIIfqoIoQbFTq0mIkhBx1WangCE7G0sZWQyoVOrSMcDlLDU6SzgDRmoRAm7JZoUG0n2TiVLHsZreMHqY0+iwYzakVNtn8xQwctjKvVpNiTOLinGqM/jSma6+lq30jx+bHMmj8Fs9lMXFwcrS3tPHf3DoIDRpBVdO5t5dCOY3zzR5/Hbrd/8BtdEARB+DSbATQpitICIEnS48Ba4GTSRlGUXW9pvwdI+1gjFIQPWVVVFQAlJSV4appJSJOREkvA60HevQvt52//t/brD0X488YGilJs1ITrsesMXFkw/cMMXRAE4ZzwiUna2O12vvXDOzhy5Ch93QPEJ2VQUbEGg8Hwgfet1qgIR4MA+MNuDmw4zKKULxBqS2ByUgybOu5GJWkYCB9nxqp8MjIyyMjI4IkHXsI+PJk1ebexs+thskOrUEW17N22Ebe9jhLtJfRKbpKVyQQiIzRGNmGT0jETh8UQQ4wqlY7+rdSNvkIxl5JnWIZGrUXnjiEYdnFEegSZCF3sJZZCPAzgZZAkptLLQeIoZpwO4iigla30UnWipo0OF10YiWGQOuIoPFFuOEo2C2ljC0acBBhDjx0rKajQkMF83HQxQC1uusjiPAzYiBCgiItpZgNaDLjpQouBIi6lkx0MUMswjQQYJUoEP6MEGCeMDz+jZLMIDXpMJ0oXj9CEgyyCuOmlChVqQCaPVfRSdWKo1CpkIgTxcZC/YiWFIB70WPEzQggXTnJJZy7Hoy9QIq/FqkmnM7yHozyBR+rBKNnx0Eeqago2XQzIXuJ0WRBRYyfzRD2cFEbkFtSKiVilkO6meqbkTsYXHCAUDLH+kQNEGtOIKCFc2lcZHu8j2pmCaSSVsEdNQ3gb5r4QW+dtZ+0laz7wvSgIgiB8qqUCnW/53MU796K5BXj1I41IED5i/0zaTJ48mVDLcbTpClJ8EdE3tkI4/G8PjXpoRyuDriBfWp3BbXte5I6yhVi0+g8xckEQhHPDJyZpA6DT6Zg2bSpM+3D3u/bKZfz110/Q1LkVl66DvNhpzMhZwFGljqHOdtIcBdQZHmLmBSV8+7/+k2g0yvbt29n68j4usd+JDjNqSYciy4T9CnJAjyqahCzZ0comWthMvrzqRNJliD6OMsNxMUFLN0n+bJpG9qGWtahVGlSSCqvJgeSFUaWVTBYzQDWb+AE2UkljNp3spJ3tFLKWMD7iKCSDeTTwMhH8WElllCY0mAgwRid7GKYBJwWkMh1Q0cEb+BlFh400ZtPOG4zQjJk4+qgmgIs5fBMT8RzmQYJ4iKOIEB7spGPAyTD1FHMpG/gPOthBMpU4yGSQGjrYSSEX0Uc1zWwgljxiKWCUZvwMo8d6ckasMD6CjOOhDwdZuOllG/9DhCAWkvEyxCD15LGSDOagw0qEIA28RDMbSWYyyboyPKFRzCRRymX0SVXYSCFRKsErD9IV2k7K2CR6A/VksYhB6ggwhp9hALQqPS2e3STYMzjcu54ezR7ksIrlpV9jesZUAPqHu7hr3/ewq4w4vKmkqotwqgrZ1fl7Xnxyg0jaCIIgCO/mTNVRz1idT5KkRUwkbea9zfrbgNsAMjIyPqz4BOFD98+kTUVxCZrdWycWxhURff2nYLOhmj7jfe+zZ9TPIzvbWF6ezPbRI2gkFTeXzPkQoxYEQTh3fKKSNv+OkZERXn1xEzX7m9EbdcxdXsmixQtOqYOTmZnJ//u/rzA2Nobb7ebBn29GpVJRObUcT6GHfU3dzL9wBdffdC3j4+PccOkX6T+iIjxoYnRYwWdqIxoxcdSziTxlBRZVMiOhRqyaTOJURfTLR/DQzwjN6LGQpJ6ER9eBX9eJcTSXGCmLFjaT51lGnC4XjzxAs7QJmyqZInkVM5U7GKGFjfwnnOiVokZLPc8TxIWBGLJYCEg0sf7ETEtmejhAKjOo5AYkJFz0MEQdMWRyjEEkNCcSMDbiKUeFxCit2MkkHisyUWp5il6qAIU0ZhLGxySuJYQLL0NUcR82MmhlM14GUYgiEyFKmG72TQyHwssILejYjgYDWiyM0UEBF9JPFUbiMOBghBZ62I+fMUwkYCaObvahx0Y6s5nOHajQYiERH0OE8XGUhzETT3NgO2pTBK/sQi9ZGQ43EZUnih1rsaBRW9kfeQSzFEsYH6nMZIRmPPRhIwWtpKNXdQC39QBSwhBeV4AlmV+juLSQcDiMVqvFaUskQzOb6qGXmWS4A7M2hqFgI6n6Moa6qpBlGZVKdZbudEEQBOEc0AWkv+VzGtDzr40kSZoE/B1YpSjK8Jl2pCjKX5mod8O0adP+zWkZBOGjpSjKyaRNgSkOS0oUWW1GZYonuul11OctRtJq3/d+/7zhOJIkcc2CVFa/9hQX504m0WT7sMMXBEE4J5zTSRuv18sff/YPYkdnMjtuKUfbdvDHbz/DQznPcu3tFzNv/mxMJhMARqMRo9FIUlIScYVb2HdsHblxUxh29xBObmH1hTcjSRK/+MnvUR2dwudSbuDR8e/g8QwQGDczovTRLR/EwyBp0ZlE1QGalNeQJJl8aQVtyhtIyCRJFXhVvRzoe5YC7Sq8Yz4ihFBpYKvyE5zhfNxSF9YUNeXeNUiRAH2+A+jkGGLIJIYcQrhIZw6D1CKhIpnJKERJoOREseInT6Q2pqBGhxodMhFAwUkeavQYiUNLgGGOk8E8DFiJIRsZmX6OnCh0/Ao6zEziGoZpoJM9qNEySgsSEs1sxMsganRYSSWWQiL40WIgSphhGoiemCXKQy8RAgQYI8AYPoYYpwMziSQxGelEwkhBxk4GHvrQoCWBEjz0AaoTA7wCyITRYsJMAmYSCeECdQinM5aMhAKqOzehVmmQpQDqiBZJo5BumIw71IUckshjOQHcuOniPH7IMI0oBPE6j1I+N4Ev/e+l/PL792AdimP3pmoUFBLTYyidVERhfhFVo8+wP/Q34snHQy8Z9lICKV1n9V4XBEEQzgn7gXxJkrKBbuBK4Oq3NpAkKQN4FrhOUZSGjz9EQfjw9PT0MDg4SExMDLFDPixpMlJ8MUrNUZSB/n9raNTB1hE21/Vz26I8XumpIhAN84Wy+R9B9IIgCOeGczJp43a7OXigii3rd9BzRGFyZRGbq54h0mdjgfHbdDYcZs8/RqjadS9f/e6tGI3Gk9tKksRtX72OzRvf4NihF0goiuHL519DXFwcLpeL+r29zHfchk5joDT+PNoCuxkMdZCnWo6DHI7yOI2sI1VfxFHpfiSdGiWgo9R8AVE5k0bvBsaibRg8cYzjYZQm0pmPXjYybKilU7UNRYpS4biOuuFN5KoXodObqPc/zxidgIpJXI0WEx56MRILKHjoJ0qQLBbgpQ8ALWbUaNBhRY+VMVo5xvMoRElhCilMo4Ynqec54illgDp8DDBKG2E8qNEzmVsI4sJCIhnMoZoHOcS9OMlhgBoKWE0fh/HQhxYDIcaR0ZDFQhRkDMRQw2PosZFIBX1UYyIRPRaquZ8EiokSxMsgQzSQzRIaeQU76WSxgDABejmEn2EaWEcaM3DRjQEHAUaxk46PAZrlzUTHp5GSGsATW0d2tAy/N0iZczado8fpjuwnJHuJ0xQiqaKEI2688hBRQoTxYjLrGLC0MBz28eBdz1FdXUU0MIXpKReBotDd3kitupYRVSNx2SZ62/dhNVjJiy1HSepmzgUzRS8bQRAE4R0pihKRJOnLwHomus7epyhKrSRJt59YfzfwQyAWuEuSJICIoigf8sBwQfh4HDp0CIDKykpCLfVopylISSWEn90AkoRm8dL3tb+orPC7V4+R5DBwycxUFj7/KEvSiihwJH4U4QuCIJwTzrmkTVdXF3f/32PY3MUEWotQ9wa5r+uXmOQElifegiRJBEIeimITaWrbyZ7d+1i0eCHhcJgtr29jZGicBUtmsWbtKtasPXXf4+PjOAyJ9Pa3MTDci1WTjle/Fa3fSJw2l7B6nDztLA7KdZSVTqKiaAZjrWr6evvY2/MkyeFZ5KuWIakkGkPb8DPCIuknRJQgHrkfnc/BEG2ECbCp/gGM0Xg6tQfQYsLPMElMQo+NKBGsOBg/Md22kRgUZPRYAYUQHvQ4iKWABEqp4XFUqPExSDylBBjHyyCjNJPFeTSyjja2kkQlJuLQ4yCFaQxQg5k44ig40WsmRA6L6WQPMhF0WMhmEaO00ks13exHi4FJXMcITdjJwEgM6cymjyMYsJFIGQHGiRBCJkwQL8d4nniKqeRGmlmP/0Qyxk0PNjLIYwUtbKaFjRiwkkglPoZpYRNRgijIGM0SIVsvlpwYzi++iiMH6+h17eLp/m+ihFTES0V4pVFMzlaKkm8n4i8h1NvLHs/vUKlUBDXtlMSWMcfxeWzBWA6PhznsfplUewFpljLspjie3/UjHNYELp3zA3qcHWyte4q+wHZmZlQyddbis3K/C4IgCOcWRVFeAV75l2V3v+XvtwK3ftxxCcJHYdWqVdTU1OD3eFE9/sDEwrgioq//L6opU5Hi4t7X/l482EVTv4efXV7By+2HGQ54ub18wUcQuSAIwrnjnEraKIrCo39/gbzoarIyS2iJtNI3FkE3Hsdx3ybkxCgqRU1QcWMyZZOtreTIntdZtHghr6/fwr7Hh4k3ZHP3oUf4r//7Otp/GWPrcDgIqEYYHOnFFE3AoLESRyF95ho8dGKyaYhKI2QmJlGcX0Z55lyO+xoJDWuJ1eVgDMQSwY9ZlXBi2u1aJNRoMWIjDT12jvI4MeTiiw5TxMVEwgFMxDBEKxVcj5EYOtjBGC0nky/5rEKHGQ/9DNNACB9jtGImgRwWUcD57OQ3FLAaE/HYkNFgoIYniKMIOxmUcAlqdOixYySGJtYDEmN0YCGREF56qSaMHxOxjNGBBh2v8R9IqEhlKgPUkMo01GgwEkP4RBwOshigjgGOYCaJMG4ihJjJl3CSTw8HqeVJooQZp4NSLqWCGxmjlcM8RDwlJ2aOslPFP07Wu5EJoTlR0ScSHmHA00YgmElyTCbD/k7SIvOIIZcRVTPOOAfl0mJqIs+zbvCHmL3ZjAZ60dgCnH/eFeyu2UC59kqy4ktQFIX8uOkk68pY1/UzpiVdxPGhHejCTj635AtYrRYGj0dZ7vgvaqNPkexZwN9/+jJrb53NnHmzzs7NLwiCIAiC8Amj0WgoLS3FW99OIDGELJlQ+SXk6iq03/ne+9qXyx/m7s2NTM6KYUFRPIuef5iKuDRmJWZ/RNELgiCcG8560mZgYICGhgbMZjOTJk1CrVa/bdv+/n5G26NMzygGIDUthfaGA2gVM/pIDL2e4ygRFbHpFsxmM6PDPWj1GqLRKM31bcRpKyhInkJL51aCweBpSRur1YreptAbPUx+dA36WIV8cyWZyWbWH/gdskfBaY+lOGkum5sm3iZkJpVzoGYnrWOHmCrPQIWRMXqxkIwshQkoY+ixESGICg1+RpGJkMNiclhCDY8zQA1uejEQg4NsYslHQaaBV3iDn3KMZ7GRcWIqbjOJlNNDgEFqqOIfxFNCHIVoMBBglByWEsZDhCCjtOA8MbOTHjsyYcbpJMA4HnoZoZFaniTAGF76yWMVHqx4GaKYizDixIATmTD1PE8IL+N0nZgRyoWdDCRUGLCTrppNo7yBMTowk4CfMQapxUQcBmLw0IcOGyYScNONGj1RQozRgYMMBjhKlCiTuQmFKCG81PMcPewj3TMHZ7AYqSuThw/9iSL1BUS1eqbnLWJ8bCrbXH8gtySHS5Jv4543vo5eE0uapZSAsxWzOoZC8yJCYyrC4TA6nY60vCT6jwVI0+WTWKhn/0gX1y29jeTkJA7sqcYeySE2NhnPaA8alZ75STfzwoN/oXLKpJN1kgRBEARBEATwHm3CnipDXCHRzZtAUd53PZt7tzbh9of5xsoiNnYdo9U1xF/Ou5oTwwgFQRA+s85q0qazs5M7f/oYFlc+raPriS18mpu+cC2FhYVnrB/S0dFBU20HVG/DZDGQV5zB9PkVHNxbzejhDtr9+5haPpf8ggJkRaZpbDdLZuTx51/fS/3+burrNpE5kMmsVQUMDQ2h1+tPS9wsWDaLew8+T5Wrmzxm0j1Ug9E6TmKhngLPlThUGRw/soM+n48XvXeSnBaPK8YFkoyXXrJYyBgdHOFREpRSZEIc5yXGaGWIBjz0k8MifAzjIIsyrmQLP0aDDhedJDEJFWpkoozRikwYDwO46MKI80Qfl2zSmUUID37G6KOaNrbhZ5RMFuJjkFFaMOIgTBA7aScKFOtOFAOOYiGRFKbiof/EDE3JBBgnjA8VGqIEGeI4NtKwkMQIbYTx08EOzMSTxiwMpKMQoZ86EiijR646MeRqYvanah4gh8V46MeAk1Sm0cUeFGR6OIiRGLSYSGMaSUzBzyi7+Q0q9MgEUaM9MWRrKenMJRAeYajTi+xyMKAMkagvYqhnHJVORqPVYIkxkZ9TSEJdAnnKFOTeRFrGuuiu8dE11IUuPu7kfVVYlIda3cyOI834kwxklyRSUFBAJBJhpM9Fnn0SAGpJiyxHsRjs2MI5NDY2UlFR8dH/4xAEQRAEQfgEGx0dZc2aNcyZM4evxmSgLVaQUssJ3n8/UlIyqrLy97yv1gEPT+/rZO3UNAqSbXxn3XYyLE5WZZZ+hGcgCIJwbjirSZvtm/aiGUinob2BmMgUeht7ua/vdZLLt3Lb167DYrGcbDs2NsYz920i4leRZC1GEzFQu/cYk+ZmM31eJUfUD2FPGUU2jdLUX0VXsJqsOQai0Qje2jguL/08fWnt/H3HN0nem8F9Bzdiyw1zxzduwGw2nzzOpVddQF/XMC01fVQdfZxpBWvIiivlqdf/RkJuCc1je0gMTyNfupRRdxUZsSqOSq8wPXkRXSP1bA9tJxDx4mMQL/30cxgtFjJZgBYLo7SQywqO8DANvEwuyzHhxEYajbxMlAB2sumjina2k0QF+axmkKPoceChBzsZ6LFiIQkX3djJoJM99FODDhPNrMdNDylMZpDjDNFIBgsIMo6LThRkBjlGkHHUGDDixEYqFhKIJQ8LKbjoQo2OERpQoWGMNpKpoJi1J4ZvtWMlhQGOYiIOI/E08BIWEslmEYPUA1EUIIFyFKK0s+3kkCorqYzQjEwEC6lECWIhgUwWsIv/I5kpDNOAEQfp0mwC0jA9cjXy+CTyVStpYQv2SBqBMZluaR+WuDiC7Q5eG3yOtMIYjlW/ilcTYFrcZSRb8tk3+BQObzzhcBiNRoNKpUK2jnHZrUu5/Rs3cu9dD9NSfZTchDcTMlElwoBSw/S4S08sUcTbHkEQBEEQBKCqqopdu3YRiUT42nkTw8cVRx7RN7agufCi9/zMpCgKv3+tHqNOzW2L8znQ386BgXb+Z+aFaFRv3wNfEAThs+KsJm08Xg9HamtYGvufWCyxtEh7mZVWTlPzPp58+AVuvv2ak20PHqgiPjiZrJmx7N3/OIX65dg1KRw8vAd1Tg9f+O7lZOdmcOTQMSLhKPOnzKGoqIhNr29BL9mQJInuoSZso2UszvgCGo2Gg83r2fjaVi66dDUwMfxq2+bdaNVakvJNzFOt4pKKb3KkupYs1XwaxrYR8EbJ05bgCY/gHQ0Tacmms3+YZNUoVouDRNcUBiKNtLIFF734GSeNGcRRhJl4jvEcQ9TjZ5Q6nqGd7bjpIZ25RPDTyV7a2IYGPWECJ6f+NpNIJ7vJYA4WEtFiAhS0mBngKHbSiRCmkAsZp4ND3IeLXgpYQxe7qeYBDDjQY6GRV9FjIYP5xFNMDNl0c4AeasjnfPwMkcUiUpnB63yPTnYxi68SYAwn+bjpY4w2xuhkNt9kmEaO8Ah2MjBgR4UGO6nEU0wi/3zLokKLiQFqGaGFQerJYB4ZzMdLPxbiiRDESgqx5NPGFvJZRSrTSZdmY1RiMPAivdIhzEosw8pxxpRWjkQew6lLY4b1QjyqHmrGXiMvPYlvX/ET3P4RjjTvZji4j/PmLuPI8X1srtZQlFPBYKCFgLOZL117PQDnX7yEP9c9TKjXhz42SkP/HkZUx8nMTSPOmorbP4pL20pe3gUf878SQRAEQRCET56qqioAKgqLMcb4kDEi1bSA2/2+hkbtbBhkb/Mw31hZRIxZx1/2vIFDb+KKfDGpmiAIApzlpI3VYcSqSsblG2FY6SQh24bZbKbctID1+37L+FXj2O12ANzjXkzqOIrTpmPSW6hu2EnvUAd+dTs/+sbXmDy5EkmSyM/PP+UYU6ZWsun5e3jw1SN0equZmrX25JCoBHM2Q70HgImhV3/5+ROkhueQY59BZ18z+48+TG3MHiIhE7LRTdXI61gDuXiUfzAud5KsL2W8LZOQy8xe+RHiI+VMkmdiVY9jUBvRR8wUyRcxQivNrJ8oUkw8R3iYCm7AThpD1DNALc1sxEwCAcbQYsDP2Ml6MVH8BHFhwIkOG1GCGHBgwE6EEDosmIhlhGYO8zBh/NhPDF0CBSMxjNPOADXYSCVCGDUhdFgZ5BgxZOOhD5kQQxzHhJM4ignjwUEmY7TjZxQTCfgZIYIfL4PksYJu9iGhxkEmiVTQzHp62EcFN6DDjEwUJ3mM0UY8JTTxKkWsJcAYZuKRiRIliIsuArjo5yg+BkmgjCIuRo2GTnkf2SwgjmIGlBq62E+aNAs9VjRqHV7bcfos2ynNmU5uMIPOtk4ebf4DRoOJ+ZNXkRk/UQMpISaVsZSdmIpMzM1JYuq05ZhMJlwuFx0dHZy3tpL+7m56Ta3UBI6REzOV3NQ5HOvZQ0dkN5d8YYmoZyMIgiAIgsCbSZsiRyKWtEEURz7RTRtBp0O9YOF72kc4IvP7146TGWfm0hnptIwPsqHjGF+tWIRJq/sowxcEQThnnNWkjSTrmD1zLjFaCzqdk7i4OCRJQi1pMKpicLvdJ5M2hSW5HHhxO4XyNDLji8mML+ZA22vkXziDKVMmv+0xYmNjufzWlfz8+D04EhTU9mGCYT8qlZqW8f0sKE4H4IXHN1IgrSLekQVAZd48wi4tT+/+A+lpmbRFD7M8+Vu4eqJY/NloMHLE9yjVodfQm80URy/icOQpzOokjFo7pdqL6Qwdwa7OIFdejk/TjxIBvTIx65IRB35G0GImmcm46SaJCkJ46WYPWiwMU08cBSRSSS1PokZHN3tJogILKsL4kYkQxE2AcZbyC+p4muO8hJM8XHShwcB8fkA7b1DHM9iZjR4bPRwkxDgGnAQYQ4UaG+kkUIIGIwYceOglnhJ0WBimkUZew0YKcRTTyS7G6SCeYmyk4aGPVKYxTifd7EWLCT02gicSMRO1efpRUEhlOio07OGP2EijiIswYKebffRxCA1GrKQRZJxRWuhgF8d5gXTm4mOQAGPkq1cQKxfSoxxANnpYMvUL9PuaGfN0ER20URBzARbZyabdj3PxklhizAkEVaOsvmgFs2bNPHl/NDY2cu9vniUmUESUCD5bB1/8z+uw2Wzs3XOAtvr9JCRYuWDu50hPT//o/jEIgiAIgiCcQ04mbbQatGYgs5Lwpv9EPWcuktnyzhuf8MSedrpGfPz+uqlo1Cr+WrsDnVrNjcWzP8LIBUEQzi1nNWmTkhFPuzRAWeqp0ygHw3780jBOp/PkssLCQkqX1LJp893EUohX6sOQPc6S5Te+63EmT57M9399O3FxcRytrmPjC79BlhVmn1/OwvPm4Xa7aa7pYr7jIvZsOgzA1AUlTJ8yk2HLHFJnAsMxxEYzGdfWM+ppw0Yq8ZRQFb2fHO9CgrohpKiOYbkVsyoWX3SMIeoZjOahRk84HECDngheFGR0WNBhpoOdaDFSyU0kMxk1OtrZznb+FzUaujmAARuFXEgPB9Fi4hjPkMlCYsljkHr2cxdJVKLDRDpzGKaRRMrwMcAgx+hhP+N0ks4ckpmMl0EaeJUaniSdeRiw0s528jmfOIrwM8oQ9SRQShd7sJJCDkvYxW8p5lKquI9EJmHAwRit1PM8FVzHIMeIp5A2NtPEemykks4cjDgYoYUIQWSiuOnFTBxqDDTzGp4Tn7WSAZuSiho9ozQzTDogMZ/vMEYHNTyBSgIVGlxKNz3yYTrU2yhLzOWo8jiWRBPefTYyVfPZ3fY05amLcGrzGRjrYMjdTSiuncrKNSiKQjQaRaVS8fi966g0XIHFEsfAwCAdzQbu/fOj/PDn32bZ8sXw/iY+EARBEARB+NTz+XzU19ejVqspMvgmFoYsKI2NqG+4+T3tY9gd5L5tzcwtiGdWXhxDfg9PNR3k0twpxButH2H0giAI55azmrSZOm0yG565i46h42TEFQIQiYbZ3/kys9aUnjIURaVSceV1lzJ7QTudnZ3ExEymqKgIjebdT0GSJCZPnuiNk56ezorzl6IoCmq1mnUvrmfzc/s5uPco1qQqgh49Or2elpY2BrpGqA4cRpWUznkzLwWvida+KA5zPOPhDjRBE2nKTOxyNiFfPLE041TycEd7iZETyOd8OtlDD9UUsBotZjSYqOVJtJhIZTojNOMkjwh++jmCmUSiBEmTZjGibqAicgMgkc1C1OgZoIYx2gmyjghBXHQQRzEKCq/xTcJ4AWhjGwlU4KLzxHTiDpzk0MZWwvgp4WLGaKONLWgwYiQeH0NYSMJM/IkeP/sJ4SGOYup4ljB+xmhDjZYiLsJFF3os6HGwn7+ixYCTXOxkYiYePVZqeYJSrmKQGvo4TAIlNLOeKEHC+NFgIpnJxKvzMCtJHFU/wqCqlnDIRRd7KeJC1Bo1Tm0KSiACkgaLKpEG5WX0RiOXFnyXVUvOZ33TnQwP+pmVcA2OYBG5xrms7/sVRocK37CJkulZfPGW6wgEAvz5V/fR3TxESm4MQ51uEqMRauqPYCYJnVLEa8cfIjn1QW66/erTZhcTBEEQBEH4rDt69CiyLFNaUoLd6iGqGGHHRMmB91rP5u5NjYQiMl9bOfE7wP31uwlFo3yhbP5HFrcgCMK56KwmbcxmM7d/5yruv+tpGtu3YlQ5GFPambw0lwsuXnlae0mSyMrKIisr6wMdV62eqETf1tbGzucaWZn2bbqsP2LfoZ0Uxc4lqB3BVaNjeHyQYfUY+7aPkliyiDRbEhmJ+Qx0jSP7pIneIZhJV2YzSD0KUfpOJGimcwdjtOKmn3FaaWETEhJB3ITw0MkuvPQxQC2xFOIkHy/9DHGMEF50ipWhSDMyYZKZjAotIVzEU4adDHSYCeJmOrfjZ5hRWhniGNkswUQ83exnlBbUaDnMA8RRQitbMeFkEtcyTjsOMrGQxD7uxEISYfxs46eYiGWQY0QJYiODbvYRSwE+BtnJL1Ghw8cweZxPExsZop4wPlI4DwkNldxICDegEMTNS9yKgkIKUyjkAozEMEIjXdoddKi20BrdwIhyjBGlDZfSRpwqhzA++jhEVAoS1Y2jcfrwe5ux6hNxK70kRNNI1VbQ5j3InmNq4g0lNAwcYNKUEta/vo6ekTYGw8cpKU7myi+vZd68eeh0Oh75x1NoWku4MHMh+xrX0dT5EJrhVkpiF6FWaRjwt1DqmMfgfjMbszZz/gUrPtC9JgiCIAiC8Gljs9n40pe+REwILGk+FGsO8pMbkfLyUWVlv+v2x7rHebm6m6vnZJERa8YfCfHAsd0szygm1x7/MZyBIAjCueOsJm0A0tLS+P7/fpWOjg58Ph/JycuJiYn5SI8pyzIHDx5i3dObOF7XRZa2FsI6MPlwmRpxjwUY9ndi0BuZG3cDreqXaHBtI8NZiiyFMGBlSOoiwDhhfPiVcUAhrB8lEAyQxXn0KlXs406ihJnMzUQJEiFEHc/iJBcfQ+Rrl+MLD6MQQYuJPqoZoA4ryYzRThqz2c0fcZCOmQSKuZhhGklhCjqs+BnBTTdu+vExjAYTsRTgppcIPszE4mcUCQ0x5DBMA2r06LFhJx0VWsL4UKGhgFVoJSP1ysv0U4N8ojywQgez+SZjtJDGLGLJx8cQBmLYx5/IYiEz+TIS6pOJIjtp5LCUIB56qcJMAolMIo1Z7OMvhPESZBxF72bxspl4qpNo6KiiWHMRBi5kb+BvOMjhkrivMW6poymwFbe6jUVTLsLmLsYzFqSh9yBdwTquS/8jh1ofJLswA8UxQlXPRlxKD5mmqaTYChg91s4Pb7uTqQu3cMvXLsc95sdpSkKSJGKMKWj1WtqiOzC6LchE6JL2smTaGmKtSexYfw8rVy9DpVJ9pPejIAiCIAjCuaS4uJg///nP9P39YbTmzSgpJYR3/QrNTbe+67aKovDbV+txmHTcvCAXgCcaDzIa9HF72YKPOnRBEIRzzllP2sDE0KcP2nvm/XjmiRc58soIDmUanp4e7mv5DWHDKDPSLiW7KI3tHfdjCKkx+7LpUe0lOdPJrFU57N/yGB69nfGoAa+uh87QfqxKKsfll3CpOpC0MhnWYlzjLQSiXpAVUqQpjCpNdLIHFTpKuQwvvRiJpSH8CrEUUcezJ6bznkc5VxFknCjBEwV5k2ljC2q0aDAiIzNMw4lhSOm08QYhXMSSSzd7CTCOkRjiKKKBdchEMeIghclISAzTwABHAQUDdtz0MU4HHartaBQjWSzAxwgBxqjjOSQkAoyiIGPAgYNsWtlMMlPpowoJiWSmYCIOgB724aKXXqpOFFo2UsTFeOkjhBcTsWRzCfHGTMLObo7VP0Tn+CYSlHnowzG08AZTuRW/aogazzoWxd+MTmViMNrAlOylxFlT2X74ZdTuEJ7hEZ6s/z7OdBOe4Voyc1N5bfN9VKqvIyHdweGWI0SCEuZwIa37x3n4Ty9z6a1LeLbmZXo66hnTNJKfn0d+9gUMjPagUqm5MO1q4qwpAAT7o4TDYfR6/cd2bwqCIAiCIJwzBushFpR2F4RCaJa9ew/lDUd7Odo5xg/WlmI2aIjKMn+r3c6U+AymJWR+DEELgiCcWz4RSZt/hyzLbH79DeoOtRCXbOeCS1ZgtZ5etExRFPx+PwaDAZVKxeDgIPs3NLE862s8seXPzI6/jkF3J0c095N9oQeNqp2ff/f/0d87yMbndqI36vncTasoKyulcW4j2zbu5pF7H6GvdRxtNBZ1SE+MLgmVFCUQ6mOIFrJjh0iOtdPS7SXq8tOh7GAS1+JnjGM8g4Ukiqkgl2W0suVEomQUDXrCeEmglFyWsYP/I4YsAlTioZ9qHiBKlHFaWaL6byxKAigSDjJRo0WLCZkotTyJmXic5OKim0wWUM1DeOnHSR4eBk4URQ7TzT5UqHDJE4mkf9a/mfjTToAxFBRiKURCopcqetjPMMcxEcswx+nmAEYchPCgRn+iKHENGgwUcAHjtBPBTgfbKeNyTJKTeFsmfpWG2JGZoIvBq/EwFmklQS7DShIpmjKOhJ6gpn07iiRjsWQy6h1k39E3yIos44rcm+myN7Ou638ZlNu5MO6rFFqn0aj5P+J1uYRU43g9fpZYv09A42H74M+JjljR6bR87X+upq+vj7S0OWx4eSvePQrzSi845b4Zdvdijzei07236SZbWlro7e0lIyNDzDIlCIIgCMKnViQS4fHHH6eyvJwU9QDRqAF58y6wWlHNnPWO2/pDEf68sYGiFBurK1MBeLWjlnb3CD+Ydj6SJH0cpyAIgnBOOWeTNps2bGXbw+2Uxi2lt6GJv3U9zDe+f/sp/7NXFIVHH3iag1saSM5z8KX/uIm+vj5iVJlo1FqCQT92XQoah44+KYs1ly2jtLQUgPJyWLp80SnHLCgooKCggPMvXsbt13yL44c78NkiBLRmSp2ziAlpaA1up82/Hae8lkR7FgNj7cSQh50s9IwSTymD1AIqFBS8DDBKC0WsRUKFQhQjTiRUxFFEE6+SIc3Goo5HiWhpZQvpzKFN3k4jG3DTwzANyEQI4GKQY6QzhywWnCwm3MU+MlmAiw7iKaORlwkwhhEnOuws53e46CSicnFMfhkT8ZRxBRIQIUA3e0llGlEidLCDKCHMxJPOXFx008rrlHE1YXxoMHCAv1DIhWgwECGAkRhGaWOUFmQiuKUeujx+tJowMYZE2ob34dQUMapqwh90o8NEIDTOqNROljMfs97BiNREIKzFEsgiw1EBQFZiIdP9l9MQfIGZBSvRqLWkJ+Ri8jpo72oCRUKFhkBkHJPRgl8exWKxkJKSQkrKRG+a+Utmctf2p0n0ZuIwT4yhDoR9VA2sY9UXZr2nh4eqQ9U88aetxFPMS6onufHbqykqKvrgN7kgCIIgCMInzLFjx7juuuvISk2j/hfLkE25RF9/EPXCRUjvMoHDQztaGXQF+ennKlCpJBRF4e6j28iyxrIio+RjOgNBEIRzyzmbtKk92ExZ/AoS7Rkk2jN4tfkQbrcbm812ss3IyAiHt3awOvO77Gp6iuPHj5OYmMh4tAdZkUmzl/Ji1c8w24xkTLGfnL4wLS0Ni8Vy2jHHx8fZvWMfO7ftRelLYJ5zBSkVOlo66ql1PYvBZEAatoGkoke3h7bBvRjVuSTLFRxTnkIGEpmETJhOdtDOTiRU5EvL0aDDoLIQiI7TyGsYsdPFHlSoaFC9iF52oFEbGJKPY1FSMRHPOJ2ATCKTGaYeP2PksZKp3IqFRAKMo0JNA+tIohwNGtrZQhozSWMmCjKtbKWRdWQyH7fsJYyfRErRY0OHhViKcNFBD4eQUDGJa6niXmbxDVx0EMJ9Yhryp9BiYQZf5iiP0sArlHARGoz4GKSNzdjJwEISJjkWl7+LIaWdcbkTfzSAUUqgX65HZfVzyH0fBsnB5LgLibOnMGo+SjjSR4xpMj5CAITlIKP+HsLRAFZjPBE5jEatZVrJQrbtfhUDiaisfl4Z/QFhtQdjQgDJaWff9mqGhoaZOnUKOp2OzMxMrvzKEp669z70w8lo0DGuamPxlVOZM/ed3xb9065NVZRb15DqzKO5P5m92w6LpI0gCIIgCJ9KVVVVAJSmpKI1Q0SfiNLX+66zRvWM+nlkZxvLy5OZlDFRv3JvfyvVQ538bPZFqEUNQUEQhDM6Z5M2ccl2+lpaSLRnMOzpRW2MYjQaT2ljsVgwxiocaHsVj66ThIT5JCcnkzfDya7dz+Ib0LIq+5vsHL4P2ezi2Tv3YFI5Cdte5ovfvZakpKST+3K5XPzuv/9OuCOBsD+V4aEGBvTPEeqchuyxEBkyM66EKJIuwqwk4XbVEmtvQVZHSfRn44gkMuBrRYOeAWoJMEaEICZiGDHVgl/PQv13CEdDDITq8Sh9DNOISpLIUM8hXZpBu7KD1MRMAuMSw97OE4WCI3SzmxA+bKSQwRwM2PEzggotiVRQx7N46GecTkq5kiDjxFOKm25yWEYTr2EiDh8DKEQxEIOPIXwM4SSPQtYyTANm4jHgQDlRV8dCAhoMhPGTQBl5rEKNGjuZuOkmhlwGqKWOZ3GQhZUUqvgHhdIaYtTpDCpufNpe8vTzMEXspAdnU+N5EpuShUajYt/YQ8gBLyuvnEFmNIFoWKZudBOugSAt/l2oJQ1eXQ9xejt6zcR3n5tUDnMUnqn6FeWTCxjx9WG1WBkbiZIUnIl/Xz4btx7jUEUtt3/9RtRqNZOnVFJaVkJLSwvRaJTMzDVnTNq9HUechYG6dpIc2Qz5OiiKe+/bCoIgCIIgnEv+mbQpizVNLKjrBkCzZOk7bnfnxuNIksSXlxWcXHZPzXacejOfy5v60QQrCILwKXDOJm0uuHQF93Q+xKttB1EZw1z/lYvQ/kuXTL1ez9d+cDN1dXWkp19OaurE2Nnrb72CzZlv8HTgVTY0PkrJyjRM7iyWZt2BWqXheO9BnnnkZW776g0n97l3zwFGj+sZ6xoiJpqLiVhaB7pI8GqIp4AFhmsISz62jv6eQtYQG51JQ3QPXmcj3aHdZElLCKnDjEQ7sJJMLAU0Sa9wc+mT1HlfY3zIR536MYL+ECqNkYC2n2L/BeSwlOrwA/gkN4naMnzRZqxqB25pmBxlEUlMZoBauthDGB9h/CgoWJhIOPVyEAtJHOYhtBjJZQVBxgnhIYYchjiOEQeHuBe3qhOHPFEALkqIYRpJohIbKbjoIoyPYzyPFuuJRE8sPRwiiTLsZDLEMUzE0c9hRmnmZe44UTw5RDrzmB53KXWuDQxoDtCr7KFL3seShC/iHQ3i8wUwyE7UspERGkmNTCdPsxI1URo3tVG+0seO7ntp7O+jIVRFGVeS5MzAZathxLCP3rFWkh3ZDLm72dv2IudfOZcvf/12AHbu2MUbf+9jTtYlAKSFCvjHC9+nt+uXlE0pYvVFy7Barf9275gLLl3BP/of5+XjOyiYnMGylVf8W/sRBEEQBEH4pPtn0mZyqoFoRE/0tTdQVU5Bik94220Oto6wqbaf2xblkWA3ANA4NsDGzmN8s3IpRs07D6sSBEH4LDtnkzZ2u51v/dcXcbvdGI1vXzDW6XQyb968U5bpdDpWrl7GytXLAKitreWF39agVmnw+Xy01w2yf98W2hsGmb+yktVrVzDUN8ZQ/zCTdNcS6NNTEImhT+4gjdmoAzYGom2kWUoxSfHIjmFslgxKhy6hxvso3Qmv0DKynqBKIUU1nXL9alpUmyh1ziDemUzEFcIo2RhW6onKaszYiPgVPFIfEZWXJLmCiBLAHI6ja6gZCYkK5SYUFNz0YCWJDObSxW6aWE88JVhIoJM9NLEBCRUpTKVfqsaAmaBiZJAabCemEo8SZoAjFDrm4RuJ0MF28jifCq7jIH870aNH5hjPkkQlSUwijBcPfZiJw0U3uZIVRZFoZiNBPFhJw046oGKcNtx04Qr3EaPkYJETKbDP45XgfzA01oPdX4xaEyIQ9WLEiQYzWsykGsqZUjIXGZmdW/9MZ3CA64vuYm/f4yQEMvCq+pk3fx7j6Qod0VfY0zRMTU0txc6FdB4Msmf3PmbNnsFA7wgx2jQAZEXmtf2PYOgpJTapjN5xH39peYBvfP8LpyX93iubzcbXvnsbiqKIAnqCIAiCIHxqKYpCdXU1ADMrbURUSciHnkT7rf98222issLvXj1GksPA1XOzTi6/p2YberWGG4rf23B0QRCEz6pzNmkDE1OF2+32D7yf9PR0fKZXaOo7TGN1F+3Dx1g+4yaKHTN4/o938fyTr2GxmujzdJMQbcURqiCicRPWjWIzxRAJGAmH1dT5XmFQqoWQB/W4Bbs2lVhtFiUFi5l2uZPe7m7WP3qYlqHnyc0twGIooqZ3Pb7IKP2Ro8w3f5kR3zBWUlBj4JjyPINSHV7VEOqIgZDkIarykyHNJUaTwkCwmX6OYCKOUVqIo4AeDrGJ75HFQmSiSEikMYOwapweKUC/VE2eZhndkUP0RqqJEqSfoxRwIdpRAyXqqWyP/op6nieBiYJwh3kEJ3lECGEhiQh++jlKPIV0Sy2oVWo6tJsxqWOQAiFK5YvQSkacukyOBp7DRhod7CLeXUS2soShcD27lXtRJQaoHXyJ+EgXNjmDUZqIIYciLqKWJxmRGpE0szGrraR6plHv24ZPP0ZZwlIOdr6KWhOmVeriC9ddRk5ODgcOHODVO/NYkHUN3SNNVO3eyazZM8gpSKfqpYMUKtMY8w4yOuAlzTSTnNQS7HY7m9ta6erqIjs7+wPdRyJhIwiCIAjCp1lrayvj4+MkOBxkpJoIenSgKO9Yz+ahHa009Xv42eUVGLRqAAZ8bp5truLKgunEGsSwckEQhHdyTidtPiw2m407vns1D9zzJIf9R1ky42qm5C7i4J7DxPTPZjiwjzkzL6fJ/D+sb/0ZtkgmmHxUlExHCQ9ijGajiqhp9m9livlyYpRcjrieJ6LegS07TJwtBbNZRVJqEnGZdbitEWr7txCVIwR9EULhIHm6NQyFWnApYzhVOWg1FkrVa9kTvgufNIhGp+VopApFVrArPbhsTeg1aqRwhIzILLzyABGVF5XNg06jJ+AaJFmeSpnuQiJygKrgY0zT3EqXspe+YC02JQMjTvo5gp0M4ihgWGmiNvo8idoSHOEcVOiYws3s5x5CqlFkOcBh9T9QyRqiSgQ3nSRTQSqzcGuamJq1kq2ND+GIphNSuZFkDUFcGHGix8ox+XlGpGaC6jG86k5C3n7y9BfSEarCGx0hX1pGSPJTqzyJix4C7lGeOvLfhDTjSLKGmAwb9brHiA2VYc3zMv2iFG669XoSExPp7Oyk+kAdNb07iVFlMhBoYtIcO4qiUFZWRtW8Wl7f+Rc0IRs93jpmTlmJzWZDURQUoiLhIgiCIAiC8C5aWlrQ6/WUpUwMhZIONiIlJKIqn3RaW0VRuHtTIw9sb2VxSSKLShJPrvvHsV2EZZnPl847bTtBEAThVCJpc0Jqaio33n4Fnk4t0zKWMDY2hmcgSqI1C5++jkRHJl9d8Sf+tP1m8qzTWDbpOiQkNlc9Q51vG209xzGqnUzPW0kkJNPaGkOtYR2VpZ8jmtFMYyNsvqeLMsMNBE09mHQNOPz5JBfFs7fteWKDqWQV2uk5Dm5/IxqfA41iZFRqId6QRbe0lyRdEbHRAnqD9USUELnJkwn0jVAfeQEdViRdkFWXzaO7fYjh+jG8oXpGAhLtvkOEFA862YopkkIzGwjgwkIyk7gWFRpa2coozVhIIlOZQ2J8BntG78cXGcOj7iQ2NwV1SCLRv5QE7wz0sgOTnEij+kWi5h7CHj+PNH8RVcSIQ8nBLCXgk4YIqEZIlCdRzMU0SC+h0kdZXHoxft0A3Z5j5AxdSDxFBN0KKllPk/I8ElqKWItChB7PAQIKpKknU9PyAOEcH5G4Aa7/4qVccsnFqFQqRkdH+cvPHiM9ch75JjUb2u7EYY4n+Fo6DUf+yNWfv5AbPn8VbcvaGBgYwLJhhLGmOjqHJXrdjcQWQ1pa2tm+BQVBEARBED7Rli5ditvtpvWXXyAS0hJ9ZT2a1Rcg/cvMT5GozC9fquOlqm4umprGt1YXn3xB5g0HebB+DyszS8i2xZ2N0xAEQTiniKTNWyQnJxObq+Zo63acqmyiUYXj/o1Ulk0GQK81kp9WQZQhwpEgDnM8a2bdSH9xB89U/ZLenj729z2LQW9AV9rJg7+6k7S0NKxWKzet/RZzbd8hxZ7Hk/U/YHby1cQ4MjhU/TpqjROvO0TN/mZiY+IoL5hGa1cjvf3H0UsWpIieoHGEnMQVJErl9LXUMRRppMA4CachnQzmUedbR5djPy21FuzeYlLHMhkN9FKvbCZFmc6IaiNHlMdAJaGWdYTxUcRaLCQiIVHIaoK4OcxDDFDDSPAwqeophKNhvOZGziu/nINVe8gwTiXOkE8g7AWvTG50GfvH/4aXQZymDIaDfSRrK4k1puGNDOOQUpmkX8Ogv414YzqZ040sn7Ocu174PpUFc2kZqQdFQ4e0BZuSzShtLOa/MRGPRUpAg5Z6Xqae57GZbeSEzsc0ZGGww4PqxANCT08PllAmxekzsKtS2XH0Fb5w2f9g1tvoGW3hb79+kv/3q6+QnZ1NdnY2kydPZtOGrXS17qckPZalK65HoxH/FARBEARBEN7VmIfMLIgE7eBynTY0KhCK8v+ePsyO44PcvDCHzy/KO6VH8+ONBxgP+bm9bOHHHLggCMK5Sfym+haSJHHLl6/imUdfZuf216iPtHD+lFspSZsJwLhvGJNTxcU3rObpe+/FMpyJCg1j6mZmrMznyE4Nx2tfxDvupqQ4hbi4OFJSUujs7CTFnotvdIjWUR8BxU2KpYjO1h4MUgyu8BBeJUhucCXDQ220qesIjuoYkhtRK3p6pWpKEhYwompCihtG8vfj0xzljdFuvOMqNIqeHvVBfL4ukuuvJRJIRIOWbNV5JFLK0ciT5OnOoyd4lCzHVOpHt+AghyTK0WBkkHq89JHFeWznF4StXThNyfhDPmINuZSlzacwYQYuuw7zeAa9A21EpAAhn4xNlcKo3IGkAqeSQrYul165ihzzZIxhC3GefI6GniUshxgNNNN1KEjPeBOxk/wcOb6TntAAAZ+MnzFa1FvQRe0YsKNSQ0TjwizHEoq6sCSquX7Zf3K4fg/Hhndy7fSvnPzekpKScGnX0dB7iAPVO8lKKMVimKh1lOrMpa09m4aGBiorK4GJQtSr1rz92GtBEARBEAThdLIs4ztyCKsZok1h0GpRLzzv5PpxX4hvPVpFTdcY31pdzGUzMk7ZPiJH+XvtDmYkZjE1IQNBEATh3Ymkzb9wOBzc8sVrufomP3/4zZ0c3b6eiBLEbo6jPbyLS25fxLTp0ygrL6OxsRFZljEYJvHnHz6JNJDMDNtS4mJzaTm6j19/82HW3jaHaTMnY47RMjkjn4A/QEtVEq7gEJFwlOPBDSRIkzEarNQHn8WpyWb30MP0+ZrRK2acUj4D4WOoXHGsWLQIyo/yk0tv4+F/PMXOpxtxZsWBJojfZUM1kEViZB46ycyIqgG/ehij5ERWZDKji/DjxR0aJF+9gtbodnbwawpYg58hokQ4yF9xSe1UFC4h2VbA1r3rMNoiXLbgei5wDHYAADHhSURBVJzWJMaj7agDyUghI1qMZOun0xHeQ6IjnTzzfHb2P8SyuO9QM/4Krwz9kGSpEiWqolZ+Fl1sGCWgZkbBUqyJWlIyrdS93kBiaBo5lsUMB9up0T7MsLaObu82JpkvJiqHGOYgtrggyyuvIdWZgzt3gKmXO5g3f87J7yw2Npbbv3s5OzbvxyT1UBFee8p3KhNBrVZ/3LeSIAiCIAjCp0ZfXx8FBQXMzk7j1R/Pgu0HUc2eg2SxAtA/7ufrDx2ka8THTz9XweLSpNP2sa6thk7PKD+ZecHHHb4gCMI5SyRtziAQCHDnb/5BqCGVTEM6h9o3Ur4oiTtuvZKsrCwADAYD5eXlAGzfvp3eJhflXE2mY2IolS5qQ68ZYevTmymdVERaqZ2BhiaKU2dS4ZvJkUPP0TBaR5gAiarJmEglxzSXceNxOoObyVBdyCLT9wiGfOyJSJiG8tm99RDJlm66OrtpqGln2bQrmJK7mIHxTu56/H9I1GQTK+eiURmwqRNoCmzBqcvHrknBr4zQrRwkIZpHvNqJNZqEjwG28zO0mPHRj8oYoawsj86hBnwBDzm2GUyKWcVYZ4T0Shs6u0R7x0HyzCvwhEYIaAYZ0R2lwDmHBfMXcODVf2DMclHatZTx8XE80UF8mh5WFN6Iiw7cXSqCAzoClgaOPxnFEE4nSzOf5ORkCm2FODxR2uOfRVH2saOpikg0jDpxjOtvvgAp6qNzfB0lM5NZvfb6076zrKwssm7OYsa8Cu776aske7JwmBNo7j9MxNlDQcGlH9v9IwiCIAiC8GlTVVWF2+3G7R0nEtCg7KtB+98/BaB1wMPXHjqINxjh99dNZWp27GnbK4rC3TXbyLXHszS96OMOXxAE4ZwlkjZnsO2NnUQa01iQcyEAs4Pn80bfXcTGnv4DCCaGVbnHPaSlvFk5Pyh7SLQ5kFTTqDpwlKtvvpi7f/MQb7Q1YNOk0RTdjEpJJ1MzhU52Uqq/EK1soStUzeyi1Rw5WMfx0CsEIl5smhRSlekcCv2B9lc7GdzpwNudw27zIWqa95OeksWot48sdT5NykZs4QyUSAQZhb2hvxI09NFkeJ5R93FQe/BFh5mv/z6GcCzDcjO7+Q3JmbEsvmAGDW3H0A3ZsEVj8Ru85Nhn0tvZRL2ukezEEnydTVS57sWjGyDJUMTkpNX43UFe2/oC8bEJbDh+L3p3MimGciRJIqDrJzZpEowm4rAlYM+V6TJ2E69OQWuKQ+3XIcug1WoJ4SXGlMR//fF2du3cw+vP7iPfdCnB/VaGOEbmVDMXXLwSnU53yvVXFIXnn1nH7o2HyS9P58LbZrLx+UcZbXeTV5bGHddei16v/+huGEEQBEEQhE+5qqoqAKbkOgiN6ZEA9dLlHOkY5VuPHkKrVvGXm6ZTkGw74/a7+lo4OtzNL+dcgkpSnbGNIAiCcDqRtDmD4f5x4ow5Jz+b9Fb0OHC5XFit1tPaZ2RkYLLr6BlvwKqLwxseQ7aMkpySS2h4BK97AKfTyXd+8iXq6uro7xvgsCuZNSv/k87WHhpbDfS4tmO2G4gz6ihOnYHdW8ymY38jVlVEmjSNA8o9RDQjZLrOJyU4nVBQIuIPcbjvMY407EMdsNEgbyOMn3xWEacU4Za6GFO1gBwh1pzIJRefj1orsemhOsbkVvS6QdD5SNSnMu0KI0uWz2T37fVcmforvJERXvX9N3WuDRTZltDWtp+kSfFoNO2cV3o5MVkSO6s20Omppq5vN9mFadyx4Df8+vFvkqtZhikSR0pKEsvjb+Zox4vEZ8dT7dlCSkUB0+1T2NXSQaqmmKOeJ8jxTaNjJETI3k1cmg1Zljnyei+XFvwYs37iB7+sLGTP/udZn76JCy5adcr17+7uZt/LLSxO/QZ7975A5Uw1P/y/b6AoyslixYIgCIIgCMK/72TSpsCJ0jaOKieXnWEr/+/RA8RbDfzx+qmkxJjedvu7j24jzmDh0tzJH1fIgiAInwoiaXMGKRnxbNt4nBxlEipJxZh3kJBmjJiYmDO2T05OpmB6AjFjIUKuPhJjzKRnTEGr1dIXqGdFcR4AGo2GSZMmoZQrvPbUbmw2G5OnJjB5aiUAsiLzzLH/ZkTdyKrFdzDi7yXa5yBWl0SCNZYqz1OkRmehDdhxmJy4XGNkyPOoHm9iquYqmuUtZLGUMZoZoxVZiVKpuoY2aQvmyR384e5HURSFb7h/QrrLiDpsoK9/FP/AAIc3qdi3/m6GRscYsrcRkN0UpFegNY+yvetPePwuXF493oxGtInZdDdocUQKqQ+9SlFlLtct+j4t/UfJ0E4nxzILgxSDRhXEqLVQYl3B/t6/UjalgK9/9wsEAgEa63/F4Z1PkJU5lZQ8CKPg02m48Kq5HNx7hAz17JMJGwCVpKIidSk7Nt7F+RcsP1mjZmxsjEAggKwOMTDeSVhyYzAYkCTplJkKBEEQBEEQhH/fyaRNTiw8spf153+RXz9eTUGSld9cMwWn5e17NdeP9rGl+zjfnrwMg0b7cYUsCILwqSCSNmcwfcZUnntiHb9/ZjcGHGiSR/ja/16LyXT624NwOExDQwNls7M4tnEXM8s+h9XgZHhkiIamfUgFfVRUXHLKNpIkMWVuEXXb9lCZcd7J5bVt++gebEVSwfP9f2Dy1GnsO7gHs5RHYmYse/Z5CYdDJDuT0Kg1jLkHQVIwyvGoZT0mEnCShZ8BYtW5xOjScEmdJGmKKMhJODms6LZvX8F9v3qe2jf6GRztR5ZCpHovIkkdw6j3KV7q+xFzSlaxtOJzxJgT6Mtr5/WeP/CNX9xIXFwcr69/g4fvegJvxIctScW1876PWqXBG3SRYi3CFerGINkI+kMAmNQx9PS3ct6s83A4HAD8+b7/o6qqil2bquhtryMhJYZLLlhMRcUk/vqHh7AZS0+71ma9jbBPIRwO43K5ePjvz9BZNwYoaJ0BhmO3sGhtEWVlZR/KfSAIgiAIgiDA+Pg4zc3N6DVqcmOcPB43h3ulImZkO/n5FZWY9e/8K8Vfa7Zj1Gi5vmjWxxSxIAjCp4dI2vwLRVF44K9PEOuZSsGsDMKRAMP+LnZuOsjUqVPQaN68ZJFIhLt/fz/DNTpCih9t5gg7hu6idn0nQV8EvR1sQYl7fv8AFTOLmTFzGgaDAYA1Fy/nzw3/YEdbP7HabFzhXna1PMfczKspS5/DM8f+G1NlJ+XpBga6NtKvtqNOcNHdtZtczVQUFCQNDFKLT+6jl0NI6ihRlRdNVIdJ5cQmpRGSffijbhRk7r/ncYxmPVNnlTPs76DP1U26dhYRn5qRYDcWVRazlG+wceA/SV+cS4w5gWDYz/GRnay5fDFer5eaw/UkJsfy0Mt/wmAw8OP/+C3e4Dh2UyxOSxJ1mkYKU6bR1HEAnWRAM+anN3QUR47MlddffPLaqdVqpk2bxrRp0077DtJzEzl2uI202HwAwtEQLX1HaeuvY8zSSygU4v6/PIG2pZyVGbMBqO3aCUnHWbx0oehhIwiCIAiC8CE6fPgwACXpDu7snsrzM/NYXprIf10yCa3mnYei93rHea6lmmsLZxJjMH8c4QqCIHyqiKTNv2hpaaG7OsiSnBtP/vKvKApbjz/AsWPHTs4YBdDZ2clgHSzKuh5ZifJq529IK44l3jeTBFsGW/a8jOl4Ft0uPa6afg7s+Adf/vYt6HQ67HY73/rRHRw+fISezgEmJcajbJxK0nAWeq2RBEcGl1y1mrS0NBRFIRgM0tS0lmtWfB2fe4BEXSFNyk6CumHmJ1xDq3cfw65eMlTTkfxqesNH8UZGUJQoI7Z6hhoykUOljET8/NdDv6atxsdC43cwBBNBMaJTWahW7iddPQM5onDXC/+P0tIiMvJSOO+CaQwOjHDwxX6SdaXURnrZnPhXvvK9m5i/cgp7H9nE3JzLSIvNRx+7hZ6hamwJZjJKnMiaMXqDx/jBD7+C0Wh8T9/BrLnT2b7ub3QNZ2EzxvLy7geRxpyE/VGchRX86Gu/xe+OckXpF05+R6Vpc1lft5+RkZG3LRgtCIIgCIIgvH/5+fn84b9+wKbmXp4P5fE59zG+cdlyVKp3flGmKAq/OrSBqCLz+dJ5H1O0giAIny4iafMvent7iSHnlN4akiQRp86ju6vvlKSN0WgkiJtA2Ecw7EOlk2mp6+HCrFt4dd/D5KtWkZRQSJtnD3Oy57H9+ONUVx9mxozpAOj1+om/z5jYX1JyIvf+7mmOdChMX1pAamrqyeMbDAbsdjvLLp3BS49tpju8i+SMdHQRPUFLN1My5lPTcIAjw49RYFhJXLQUCQ3V0UcYjDYwL+s7ZCdODBvadvQ5krylaPQ61GEj3RxmJNLCqNJJQ+R1EplCgj8f06gLa4xMdl4ah17uZXH2rSer/Ve1b2Lrph2svnAFHS2P8/reu0lUlZGSlMaewFMYjHqw5GKKlbjhihVUVla867Xv6Oig/lgDRqOBq764ihcfe4V9W2qJHZ5Fii2H3MlpZGVn0txTy+P1PydaHEWjnriFJSQkVMiy/MFvAkEQBEEQBOEkW0w8x6zT6M8zcmvtc1x/8bx3TdgAPFi/hyebDvKVSYvIsDo/hkgFQRA+fUTS5l/ExMTgkVpOW+6Se3HGZp2yLCkpieVXT+HVJ36HRqfimjvW8MpTbzDs6aV/qIcicz6+oBuTZaIwbqKhgI7mLmbMOPOxc3Nz+fFvv0EoFMJisZyyrq2tjbt/+hT50qV8belVtHe20hk4SOZ5sGjZVNqaOzn+eC+lhvkcH9pAH0dRoaGDN8iyTKap9+jJpI1ZH0NENmC1WhlzjdDPYdKUeRiJZ4h6KnSfw6JKoKdnN3JHmO3bdxInlZ8yPWNaTBHNNS+jvVTLLXdcS+vKVo7XN6HRGLmx/H9xOBwEg0FsNtt7msFpy6ZtrH/4EElUElTGcFt3c+PXLqa7eYjF0y7AYY85OTQtN6UUqyaRfc2vMadgDYqi0NhXRVy2jri4uHc9liAIgiAIgvDeDHuCfOPhgzR59HwvcS9L73kSzV0/edft9vS18KO9L7EkrYhvT1n2MUQqCILw6SSSNv+isLAQberrHO3aQUnKLECiqa+KcFwHkyZdcFr7JcvO47zF85EkCZVKhUqt4uHfPUVQ8dA4tB+dXkXFtInaLGOhboqS3/ktg06nO1kw+K3WPb2ZQu0q8FqpPdRGIKCjKHcpoz07qKgsZ/mKpTgTbPzth6+SFJ9CZ38zoUiQUtsqJK+RfdU7sJvi6BvupLHjCP6Illm2CxgdasIXGkOHiTBe1OhI1pUzHGnGrHMw2tVNlk5HP12nxDPo7kJKCHHP7x8kGAhTObuIlauWndJD6b0Oh/J4PLz62C4WJX8Zo24iWdXYm8q6ZzdhMdmJdcad1vOppLiUAdtONrZ3AArWdJmbb79C1LMRBEEQBEH4kHSN+PjKP3Zx4Lm/cktJhEUmG6pJlagSEt9xu27PGF/Y8giZtlj+tPDKU178CYIgCO+PSNr8C41Gwx3/cT3PPraOVw5sQ1Ikcicl8cVrrjtZRPhf/XP6aYDy8jK+/BM7zz3zEnteeJZ5mVejM6s43PEG/rhGpk2//X3HJMsyTbVdrEm/gZ21u3EPhLFKGXia/PT1w8GDB4lxOOlqGEZl9ZNmTySs8jHHdAeJlhyOdG1FrSvnhc0Pk2WcwXTL9RzgYbb03Um6eS7J7knsVf2JcVUncbp02pXtRDVBClPL2DT+NN9Z/kOeGXiVPc0vkm4vZdTXR63/JbSHTUxxLsGuNbHh76/jGh9n2owpOJ3OMyae3k5/fz8WJRmjzoKiKACkxxWyte01YlIt9I21kRyTfbK9P+QhbBnkf3/9A8bGxgBITU0VCRtBEARBEIQPSX2Pi288fJDRzia6dj7Fk+12vrpoFoal79xrxh8JccumBwlFI9y7+DpsujM/PwuCIAjvjUjanEFMTAy3fPFaAoEAiqK8a48RWZbp7+9HURSSkpJIT0/nq1//IstX1rNp3W6ODuykYEkG1626CbP5/VfNlyQJvVGLP+jBOxYixZ6HWqUnMTmfrv5t/O1PDzElfi05jsWszp/CC9vuJeo2EU2VafMcoGJuLja7lY51B9EnBJk/ZybeI7UcbF/PgHKAQfMgCcZscg0r6PM0ciB8JwWJszksV5MxyUpOTg5f/vbN7Ni+m8Yj20lMdaAZLEBVW0lWfAmKojDQNZXffP/nzJ3Zhmxwc+G1i5g1+23Ggf2L2NhYxiPdHD58hIGOMVQqCXWch5iZZsqm5/LyA39nsv9SUpw5jHj6qXdtYsV1s7BYLKcNIxMEQRAE4b0ZGA+w/fjA2Q5D+AQKhKPcu7UZq1HL2uwwe4HK7FhUtZ2ov7HibbdTFIVv73yW2pFe/rH0evIcCR9f0IIgCJ9SImnzDt6uZ81bNTU18cR96/D2qlFJKrSxAS67cSWlpSUUFRVRVFT0geOQJIlZS8qpfnYTauLJzMoCYDTYzVC0GctQIvNmTAwNSnWCogmx7fVdSHEjzJk++WSiqKAkh/bQHuoHdtHQfoSvnPdXxuQOmnUv01cTJdqtY17CrfRwgJKKAsKSm9nXxwMTQ52WLV/MsuUTMT1831METnR17e3tpfuYmxTDJJamfxGXf4Tn//ogSckJZJ2I9Z04HA7C+jE2H3mSSbYLCYRdbD38VxJGrYQ6YtErNrb23kO6Np30rBSuWjmfsrKyD3xdBUEQBOGzrG3Iy6/WHTvbYQifULmJFn53zVR+/L0nAJiU6kRb40ZVUfm229xTs53nW6r5zpTlLE0v/pgiFQRB+HQTSZsPYGBggHt/9RyTDJeRnDkxfGfQ1cWDv32cr/zERlpa2od2rJWrl9LZ8hAHjm5nvHcIrVHFsLoOtU5mUsa8U4YG5SSXsTtuM+NjLkwmEwCBsA85sYdbr7sQ15iXNjmJiM7FmLuXhavn8HTPK1h7pqAKGVEF7BzqeI0Faydx3uJLzhjPjHkV/H3byxhGLByvb6M3Uk9Z/lQAbEYnGepZHNhz+D0lbUZGRtCH4rlg2XI6+poIBvrID88h1VfBrORFaNI1NPQdwJ20ny996yYxDEoQBEEQPgSVmTGs+/Z5ZzsM4RPKYdKhVklUVVUBUGy0o1k8A+ltJpjY2t3Azw6+yuqscr4yadHHGaogCMKnmkjafAA7t+0jOTLzlHor8bY0stwLeGPjbq656XMf2rE0Gg1rr1hBTkkKTz2wDslvIc7uIDwapjxr3iltzXobc6cs5ckdfyCxDdRoGVAdYdmVk1myZDEA5RUlbF63m7LUGErLC+hY0spjB58jJ7SSbvaTaItw6TXno9frzxhPQUEBy6+t4Pf//WOikQiVhWuYUbD85Hq1SkM0MjH99uDgIHV1x1AUhZKSYhISTu0qGwgE0KvM5CVVkJdUwbq9D1JiPg9/ZJxoNIpWq6UgaRqvt+yjq6uL9PT0D+26CoIgCMJnlU6jItZy5p/zggAQjUY5cvgwAKU+CfXFy8/YrtU1xJe2PkqBI5HfzrtMvGATBEH4EImkzQfQ1TxAgvX0YTqJ9kwaWw58aMepra3j8b+tA5eVkOJl1txpLFuzkJiYGLa8voOu9fXEWpNO2UavM3LRTfOZOtdKNBqluPgakpLebJOXl4flCgv33/UUB9d10d8SwqZNQEpv45apX2fUN8DhQzXv2FtozpzZRL4XRavVsO2BLmCiiHAg7KMtuJcbpy/lja07eOXBPcTL5UhIvCI9yIqrp7Fk2XlvXq/ERHSxAXpGW0iJycHv92EKhTHHak8mjSRJwqCy4/f7P7TrKgiCIAiCILy9hoYGfH4/GXFmYtqHUS88vQeNJxzklk0PIkkq7ltyPWatSAQKgiB8mETS5gOIT3Ew0tRPkiPrlOUjnj7ic+wfyjFGRkZ48A8vM916LXEZKciKTFX1RnaY9nPD569k0dJ5/HbHvRzvsZCXVIkkqWgfPEZTdANfvOYKMjIyzrjfUCjEPb95hHTvcmZmlFE7Xk+ey0yvv4qm7hpiY969cJzJZGLlquVEo1GG+l5g/abfYVUl4aKbZVdOx263c+8vX+K8xC9g0lsB8IfmsuHReyguLSAlJQWYmH3rui9ezL2/e4qmjhTG1M2My14un3LbyTc1/pAHt6qL1NSLP5TrKgiCIAiCILwzl8tFRVYS+QkGDMkZSDbbKetlReZr256geXyIR5bfTIbVeZYiFQRB+PQSSZsPYM7Cady1+WnS/PnYjBM/pDyBcZr8b3DLslUfyjGOHD5KfGgScdaJBIeiKEgRHQ/+6XkO7zlOdmEaKz43i4aj9bxyYD3IkFWaxBcuu+xtEzYAtbW1qAZTyMkqByA9M4X97TUkKuXsqPsTRQudXDnztjfjOHKU7esPkFWYwqo1y1C9ZTyzWq3mimsvYdn5IwwPD5OUlITVamXzpi0kyhUnEzYARp2ZJCqpOVp3MmkDkJ2dzQ9//XWamprw+Yp46bEtNIzsIkMpxRMYp8GzlZXXz/63Zt8SBEEQBEEQ3r8ZM2aw7+dr8DYG0MXPOm39Hw5vZn1HHT+esYZ5KXlnIUJBEIRPP5G0+QAyMjK47IsLefrev2IezECFCpemjQtuWUB+fv7bbufz+di9ay81+5rRG7XMWFhOZWXlKYmQfwqFwmikiVmsFEVhU9WTjLZHKYtexeLYxYx09PByzWtc8sU5XHfr5SiK8rZ1aN5qoH8Iu/Tm0Ce73c70BWV0d/aRMGrjyttWkpiYCIDb7eaRP75CufEStu1/nfrjfyI0psYRa2HBiumUlpYC4HQ6cTrffMMiywoSp5+TSlIjy9HTlut0OkpKSoCJmjk7tu3m2KF12Jxmrlu8iOJiMQuBIAiCIAjCx0UZ7UKjjxJpcaG+6tR6Nuvba/lN1etcmjuZW0rmnqUIBUEQPv1E0uYDmjZ9KmXlpTQ3N6MoCjk5F56cselMvF4vf/zFvUgdWWTFLCMUCfB81U7ql7Zw1XWXnla4rbikkM3KMwTDMxnx9NHXOUKJ9iIiCX1YTFYspkLspjhefORepkytRKfTvae4Y+NicCutpyyz2+1YrGZaO82nJJ2i0SiKLKFCS2NNB+FABvMKLsHdPMJDv3ydC29zM2fe6W9fSsuK2chjBMNz0GuNKIqC2z9CR2gvl5Rd9Y7x2Ww2zl+zgvPXvKfTEQRBEARBED5EiqLQ8PqL5GsUpP4gUu6bPWkaxvr56rYnqIhL4xdzLhGFhwVBED5CImnzITAYDCd7m7ybHdt2o+rIYWb2m9mIVGcumzbfTfuC9tOmyE5PT2fxFeW8/uSdDHcGwJuKJ76daZWTTraxm2LRDsXR2dlJTk7Oe4qjrKyMF+xb6B5pItU58UNYURSqOzdTOjsdh8Nxsq3D4eCimxdw3x//iCXWwurKz6NWaXBaEnGYE1j3xL3MmDUNjebU2yk5OZnFl09iy1P3EC+XUdWwne7BVhIyLezbXUVqauoZexcJgiAIgiAIZ1dnZyfFV3yZvEQb1de/WWdwLOjj5tcfxKTV8bfF12HUaM9ypIIgCJ9uImnzMTu6r4mc2FO7j6hVGhKkcuqPNZ6WtAFYvmoJk6dN4pGHH2Nkq535k2aiVqtPaaMgv6+3HAaDgc//xxXc+4cnaWpPwEQso0orqeVGLr/29F4wc+bNouZgI6amWahVb942dlMsypCB8fFxYmNjT9tuxflLKSkv5N67H8TWGcela76O2WJix0uPkpZxgJmzZrznmAVBEARBEISPx6FDhwBIs5jRnz9RqzEqy3z5jcfp9o7x5MrPk2L+cCbeEARBEN6eSNp8zLQ6DeFo6LTlUUJotW//dcTHx3PpZRdzZ/WzKMjAm0mbEU8fim2M9PT09xVLRkYG//XLr3P8+HE8Hg9JSWVkZGS8bfInIS2GjiO9pMW+OXTKH/IS1fqwWCxve5z09HRibckUTVpMjCMGgFTjJDpbu5h5+qgqQRAEQRAE4Sw7tGcbAKUmK+rZEzVrfnFwPVu7G/jFnIuZnph1FqMTBEH47BBjUz5m0xeU0jCyC1mRTy7zhzz0S4cpn/TOQ6zS0tKYvDydN9oeome0BU9gjMbeKvYNP8qlNy0/bXjSe6HRaCgtLWXmzJlkZma+Y2+dOfNn0KvdS9tgHbIi4/aPsrfzWeavqnzX4seJaTH0jDcBE8OwBvzNxCXFvO94BUEQBEEQhI/eoV07AJgUk4yk1/N8SzV/qXmD6wpncm3hzLMcnSAIwmeH6GnzMZsxczrHjjSzac/fSNFMIiT76aOK1TfMIiEh4R23lSSJz111ETkFh9ix4XUaRjxkTk7iCysuJjs7+yOPPSEhgS9893O8+MRGXjr2NCarnvOumc7iZQvfddtVFy7l7qYH2dzeSlQJkz7NyNx5sz/ymAVBEARBEIT3r7q2HoBp551HzXA339rxDDMSs/jJzAvOcmSCIAifLZKiKO+58bRp05QDBw58hOF8NsiyTFNTE/W1TegMWionl5OUlHS2w3pfIpEIarX6fdXRCYfDdHd3o1arRRFiQRCETyhJkg4qijLtbMchvEk8fwkft8HBQRISEjDrNDTV17J2/7PIisIrF36ZeKP1bIcnCILwqfR2z2Cip81ZoFKpKCgooKCg4GyH8m/7d4ZiabXaMxZaFgRBEARBED45qnZtAqDYGcOX67cwFPDw7Pm3i4SNIAjCWSCSNp9xXq+XF55+lepdx7HYTSy/eC6zZp8+o1MoFGLzxjfYt7UGRYHpC0tYsvy8d61lIwiCIAifJZIkrQT+wMSMAX9XFOUX/7JeOrH+fMAH3KgoyqGPPVBBeAeznQq7frGG37db2dnXyh8WXEFFXNrZDksQBOEzSSRtPuMe+vtTeKqSWJL6TbzBcV74y9NYbWZKS98siqwoCvff8xiD+y1MSrwWSSVR/dR22psf5fav3fi+hkgJgiAIwqeVJElq4E5gGdAF7Jck6UVFUere0mwVkH/iv5nAX078+bFTxtpRap48G4cWPuGMvU00JWWwM8HKbaXzuDR38tkOSRAE4TNLJG0+w8bHx2mpHmRl5vWoJBV6rZEC3yL2bK0+JWnT1dVF60EXy7OvP5mgmZ19ERur76K9vV0MeRIEQRCECTOAJkVRWgAkSXocWAu8NWmzFnhQmSgquEeSJIckScmKovR+3MEOVB3k7qc2sq+mE0kCaSJopInYsZr13HDh1JPt//H8AQLB8FvacPK5YHppGpOLUwFo7R5h4+5GFEVBUUABOFFDUQFuWjsNo0ELwItb6mjrHQVFQTnR7J/1FnPTY7nwvBIAXN4A979wkH++JpJOxMCJGFbPLyIzZWJWyv01nVTV95xoBxISkjSxb7NRx1XnV548pwdePIgvED55/IlQJ4KeOSmDaaUTvUuaOoZYt72et5aCfOs1u+Xi6ZiNOgBefuMYHX1jp1zPf7bPTnWyfM7E8HiPL8gTrx2eWHEGy2fnk57kAOBAXReHj5/5FjEbdVy5suLk50fWVREIRc7YdkpxKpOLUgBo6xll096mM7aLTY7llbnTmJ+Sy/enrTpjG0EQBOHjIZI2n3EKysTDyYnnBUWRkVSnPjwMDQ1hV6Wd0qNGkiTsqnSGhoZE0kYQBEEQJqQCnW/53MXpvWjO1CYVOOU3ckmSbgNuA8jIyPjQAwU41Ovl1x0ePNvrz7he7bSy9dLlJz/3bj+O7PGfse16iwPbpFgA/MNDjGw8+rbH3XPhItRaMwBDNb0Ea1rP2M4wOZ/nlk3sMxJ10f/Gsbfd5/ZJxRgyJ9qOt9TieZvjq51WNqxd8uY5vVH/tue0OSYWW+WJcxobYmTbma8TwIGLl7x5Tkd63vGcHls4MXtmJOKif/2Rt93n60X5GNInju9qrsX92uG3Paf1Fyx+85y2HEN2+87Y9hWjDVv5iXMaGmbkbfapy0slbjDEXU//CI1K/bYxCoIgCB89kbT5DLPb7RROS+bAvlcpS1mANzBOg3cLNy5afkq7hIQExuQ3kBUZlTQx45OsyIzJ7SQmiu6ygiAIgnDCmbpM/Os0ne+lDYqi/BX4K0zMHvXBQzvdjJWr+Y0/REPJPBSUid4mJ3q6KCgYjUZWF6852f6FLyoEAoEztq2oqKCsuByATksn20md6A1zokvORG+XiVO/sGItBoMBgJ3Xx9Lf339aO0mCpORkZhRP5Lx8Xi+v/YfpZC+cN2OYiGP+ggUkJycDcHhNJrVZU05ro1JJmMxmLi5ee/KcnrsjSjAYPOW4MPFyqqS0jJLiiZ4+PbZu9pryTrb753n/8zqsrliD3jBR52/btQ76evvebAMn26WmpbKgeCEAHo+H525/+6928dzFpKZN9PSpWpVBTVrFGduZzWYuecs5PXVLgEAgeMa2FZWVTCqeBECHqZ03oolve/wLV68hRm962/WCIAjCx0NM+f0Z5/f7WffCBqp2HsfqMLH8orlMmXpqIkZRFB7422N07FBRHDcfgGODO0iZHeKWO64VNW0EQRA+RcSU3/8+SZJmAz9WFGXFic/fA1AU5edvaXMPsFVRlMdOfD4OnPdOw6PE85cgCIIgfPqJKb+FMzIajVx25Vouu/Lt20iSxLU3X872vJ3s3/oCiqIwb3Up8xfMFQkbQRAEQXjTfiBfkqRsoBu4Erj6X9q8CHz5RL2bmcD42ahnIwiCIAjCuUEkbYT3RKPRsGjxQhYtXni2QxEEQRCETyRFUSKSJH0ZWM/ElN/3KYpSK0nS7SfW3w28wsR0301MTPl909mKVxAEQRCETz6RtBEEQRAEQfiQKIryChOJmbcuu/stf1eAL33ccQmCIAiCcG5Sne0ABEEQBEEQBEEQBEEQhNOJpI0gCIIgCIIgCIIgCMInkEjaCIIgCIIgCIIgCIIgfAKJpI0gCIIgCIIgCIIgCMInkEjaCIIgCIIgCIIgCIIgfAKJpI0gCIIgCIIgCIIgCMInkEjaCIIgCIIgCIIgCIIgfAKJpI0gCIIgCIIgCIIgCMInkEjaCIIgCIIgCIIgCIIgfAJJiqK898aSNAi0f3ThCIIgCIJwlmUqihJ/toMQ3vQBnr/igKEPORzhVOIaf/TENf7oiWv80RPX+KP3abjGZ3wGe19JG0EQBEEQBOHcIEnS/2/v3oOtrOowjn8fwbySeEkldcTQxtRGzCImLPGS4dgklk6SqaTjpXTSykwrrewyGmXZdcYLYUoqeUGjvJBCJCmCCHG8jSRYhCOmmbeksKc/3nVqs9nncIB9OJtzns/Mmf2+633X2uv9wTDD7/zWeufYfmdPz6M3S4y7X2Lc/RLj7pcYd7/eHOMsj4qIiIiIiIiIaEFJ2kREREREREREtKAkbSIiIiJ6p8t7egJ9QGLc/RLj7pcYd7/EuPv12hhnT5uIiIiIiIiIiBaUSpuIiIiIiIiIiBaUpE1ERERELyJplKTHJS2UdF5Pz6fVSRovaZmktpq2bSRNlfRE+dy65tr5JbaPS/pATfv+khaUaz+QpNK+iaQbSvssSYPX6wO2AEm7SJom6VFJD0s6q7Qnzk0iaVNJD0iaX2L8tdKeGDeRpH6SHpI0pZwnvk0maXGJzzxJc0pbn45zkjYRERERvYSkfsCPgcOBvYAxkvbq2Vm1vAnAqLq284C7be8B3F3OKbE8Fti79PlJiTnAT4FTgT3KT/uYJwN/t7078D3gkm57kta1Avic7bcBw4EzSiwT5+ZZDhxse19gKDBK0nAS42Y7C3i05jzx7R4H2R5a8wrvPh3nJG0iIiIieo9hwELbT9r+F3A9cGQPz6ml2Z4BPF/XfCRwdTm+Ghhd03697eW2FwELgWGSBgFvtH2fqw0jf17Xp32sG4FD2n/j21fYftr23HL8EtV/encicW4aV14upxuXH5MYN42knYEjgCtrmhPf9aNPxzlJm4iIiIjeYyfgLzXnS0pbrJkdbD8NVcIB2L60dxTfncpxfftKfWyvAP4BbNttM29xZSnCfsAsEuemKkt35gHLgKm2E+Pm+j5wLvCfmrbEt/kM3CXpQUmnlrY+Hef+PT2BiIiIiGiaRr8tzKtCm6ej+HYW9/yZFJK2BG4Czrb9Yie/3E6c14Lt14GhkgYCt0jap5PbE+M1IOmDwDLbD0oa2ZUuDdoS364ZYXuppO2BqZIe6+TePhHnVNpERERE9B5LgF1qzncGlvbQXDZkz5TyesrnstLeUXyXlOP69pX6SOoPbMWqy7F6PUkbUyVsJtq+uTQnzt3A9gvAdKo9PBLj5hgBfEjSYqplpwdLupbEt+lsLy2fy4BbqJb99uk4J2kTERER0XvMBvaQtJukN1Bt0HhbD89pQ3QbcGI5PhG4tab92PL2kd2oNrd8oJTrvyRpeNkb4YS6Pu1jHQ3cU/ZY6DNKTK4CHrV9ac2lxLlJJL2pVNggaTPgUOAxEuOmsH2+7Z1tD6b6d/Ue2x8n8W0qSVtIGtB+DBwGtNHH45zlURERERG9hO0Vks4E7gT6AeNtP9zD02ppkq4DRgLbSVoCfAW4GJgk6WTgz8AxALYfljQJeITqjUhnlCUpAJ+kehPVZsDt5QeqZMU1khZS/Tb32PXwWK1mBHA8sKDsuQLwRRLnZhoEXF3enLMRMMn2FEn3kRh3p/wdbq4dqJb2QZWr+IXtOyTNpg/HWS2eVIqIiIiIiIiI6JOyPCoiIiIiIiIiogUlaRMRERERERER0YKStImIiIiIiIiIaEFJ2kREREREREREtKAkbSIiIiIiIiIiWlCSNhERERERERERLShJm4iIiIiIWGeSXl7LfqMl7dXs+fQUSWdL2nwN+4yUNKVB+1hJP1rLeQyU9Km16dvF8cdKelbSPEmPSDql5tpoSReu4/jbSpom6eX6GEiaIGnkavp/R9LB6zKHiFaQpE1ERERERPSk0UCvSNpI6gecDaxR0qabDAQaJm3KPJvhBttDgZHAtyTtUNrPBX6yjmO/BlwAnLOW/X8InLeOc4jocUnaRERERERE05SqkemSbpT0mKSJklSuXVyqMv5YKiHeA3wIGFcqNoZIOkXSbEnzJd3UXrVSqit+IOkPkp6UdHTNd54raUHpc3FpGyLpDkkPSvq9pD1L+zGS2sq9MxrMf5CkGWU+bZLeW9rHlO9ok3RJzf0vS7pI0izgS8CbgWmSppXrh0m6T9JcSb+UtGVpH1Xicy/w4U5Cukt5jsclfaX0/bqks2rm8E1Jn67rdzEwpDzHuPLnMk3SL4AFkgZLaqsZ4xxJX+0sdh2xvQz4E7CrpLcCy23/TdIASYskbVzGfaOkxe3nqxnzFdv3UiVvOiTpVkknlOPTJE0s/Z8CtpW04+q+K6KV9e/pCURERERERK+zH7A3sBSYCYyQ9AhwFLCnbUsaaPsFSbcBU2zfCCDpBdtXlONvACdTVU0ADAIOAPYEbgNulHQ4VbXOu22/Kmmbcu/lwOm2n5D0bqrKj4OBC4EP2P6rpIEN5v4x4E7b3ywVKZtLejNwCbA/8HfgLkmjbU8GtgDabF9Y5nwScFBJWmwHfBk41PYrkr4AfFbSt4ErynwWAjd0EsthwD7Aq8BsSb8GrgJuBi6TtBFwbLmv1nnAPqUShrKcaFhpWyRpcCff2VHsGpL0FuAt5VmOBOYC2H5J0nTgCGBymedNtv8t6fPAcQ2Gm2G7PgHVmVOBmZIWAZ8DhtdcmwuMAG5ag/EiWkqSNhERERER0WwP2F4CIGkeMBi4n6pq4sqSeFhlD5din5KsGQhsCdxZc22y7f8Aj9QsxTkU+JntVwFsP1+qWd4D/LIU+QBsUj5nAhMkTaJKfNSbDYwv1SCTbc9TtTfKdNvPlmeaCLyPKhHxOh0nBYZTLf2aWebxBuA+qqTTIttPlPGupUo+NDLV9nPlvpuBA2x/X9JzkvYDdgAear9nNR6wvaizG1YTu3oflXQAsBw4rcR+EPBszT1XUi2Xmgx8AjgFwPY4YFwX5twp28+o2j9nGnCU7edrLi+jqnyK2GAlaRMREREREc22vOb4daC/7RWShgGHUFVcnEnj6o0JwGjb8yWNpdovpdG4qvl03RgbAS+0V5nUsn16qR45ApgnaWhtwsP2DEnvK9evkTQOeLGTZ33N9usdXBNV0mXMSo3S0AZz7kj9fe3nVwJjgR2B8V0c65Wa4xWsvF3GpuWzw9g1cIPtM+va/gls9b/J2jPLUqwDgX622wCaWGkD8HbgOVZN0Gxa5hOxwcqeNhERERER0e1KBcdWtn9DtVnv0HLpJWBAza0DgKdLpUuj/9TXuws4Sf/f+2Yb2y8CiyQdU9okad9yPMT2rLKc6W/ALnXz3BVYVpZoXQW8A5gFHChpu7Jkagzwuw7mU/s891MtDdu9jL152fPlMWA3SUPKfWNWHeZ/3i9pG0mbUS0Dm1nabwFGAe9i5WqkRvNo5Blge1VvadoE+CBAZ7HrokeB3evafg5cB/ysvcH2ONtDG/ysUcKmJAIPp1qSd46k3WouvxVoa9gxYgORpE1ERERERKwPA4Apkv5IlfD4TGm/Hvi8pIdKEuMCqiTJVKrkRqds30G1v82cshSr/W1DxwEnS5oPPEy11wpUmx4vKJvwzgDm1w05kqoC5yHgI8Bltp8GzqdagjMfmGv71g6mdDlwu6RpZTnVWOC68tz3U+3p8xrVcqhfq9qI+KlOHvFe4BpgHtV+MHPKc/+rzGdSo0qfUj00U9XGyassQ7L9b+AiqlhPYeVYdxS7rpgB7KeatVXARGBrqsRNl0laDFwKjJW0RHWvhi/JpiuAk2wvpdrTZnxJNG1MlTyasybfGdFqZHe1Ki8iIiIiIiJaQdmAeC5wTPveOK1C0mXAr2z/tpwfDRxp+/gmjT8BmGB7eif3HAW8w/YFzfjOiJ6SSpuIiIiIiIgNSKk4WQjc3WoJm+JbQPtytR9SvX786+t5Dv2B767n74xoulTaRERERERExAZD0mhgnu3FPTyViG6XpE1ERERERERERAvK8qiIiIiIiIiIiBaUpE1ERERERERERAtK0iYiIiIiIiIiogUlaRMRERERERER0YKStImIiIiIiIiIaEH/BcPL+7tF6DsOAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 1440x432 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axes = plt.subplots(1, 2, figsize=(20, 6))\n",
+    "y_unique = np.unique(y)\n",
+    "colors = cm.rainbow(np.linspace(0.0, 1.0, y_unique.size))\n",
+    "\n",
+    "for this_y, color in zip(y_unique, colors):\n",
+    "    this_X = X_train[y_train == this_y]\n",
+    "    this_sw = sw_train[y_train == this_y]\n",
+    "    axes[0].scatter(\n",
+    "        this_X[:, 0],\n",
+    "        this_X[:, 1],\n",
+    "        s=this_sw * 50,\n",
+    "        c=color[np.newaxis, :],\n",
+    "        alpha=0.5,\n",
+    "        edgecolor=\"k\",\n",
+    "        label=\"Class %s\" % this_y,\n",
+    "    )\n",
+    "axes[0].legend(loc=\"best\")\n",
+    "axes[0].set_title(\"Data\")\n",
+    "axes[0].set_xticks([])\n",
+    "axes[0].set_yticks([])\n",
+    "\n",
+    "\n",
+    "order = np.lexsort((class_one_probs,))\n",
+    "for clf_name, probs in class_one_probs.items():\n",
+    "    order = np.lexsort((probs,))\n",
+    "    axes[1].plot(\n",
+    "        np.linspace(0, y_test.size, 51)[1::2],\n",
+    "        probs[order].reshape(25, -1).mean(1),\n",
+    "        c=color_dict[clf_name],\n",
+    "        label=clf_name,\n",
+    "    )\n",
+    "\n",
+    "true_class_one_probs = likelihood(X_test)\n",
+    "true_order = np.lexsort((true_class_one_probs,))\n",
+    "axes[1].plot(\n",
+    "    np.linspace(0, y_test.size, 51)[1::2],\n",
+    "    true_class_one_probs[order].reshape(25, -1).mean(1),\n",
+    "    \"k\",\n",
+    "    linewidth=2,\n",
+    "    ls=\"--\",\n",
+    "    label=r\"Truth\",\n",
+    ")\n",
+    "\n",
+    "axes[1].set_ylim([-0.05, 1.05])\n",
+    "axes[1].set_xlabel(\"Instances sorted by true P(y=1|x)\")\n",
+    "axes[1].set_ylabel(\"P(y=1|x)\")\n",
+    "axes[1].legend(loc=\"upper left\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "124e7712",
+   "metadata": {},
+   "source": [
+    "## If observing closely, one will find the two lines for Isotonic Calib + naive RF vs Isotonic Calib + HF are almost overlapping."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c9806aa4",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}