Repository: quaquel/EMAworkbench (language: python)

Issue:
Replace setup.py with pyproject.toml and implement optional dependencies
This PR does two things:
 - It migrates the project install commands and metadata from `setup.py` to `pyproject.toml`. It largely follows the [convention from setuptools](https://setuptools.pypa.io/en/latest/userguide/pyproject_config.html).
 - It moves the dependencies from `requirements.txt` to the `pyproject.toml` file, and thereby also defines a few sets of optional depenencies. Note that many dependencies that were defined in the `requirements.txt` are now optional.

This PR succeeds #151 and closes #130.

**To-do:**

 - Migrate to `pyproject.toml`:
   - [x] Project and Metadata 
   - [x] Dynamic version
   - [x] Dependencies and optional dependencies
   - [x] Version 
   - [x] Packaging
 - [x] Update CI to use appropriate install commands for each job
 - [x] Update installation docs
 - [x] Implement `"all"` extras which installs everything
 - [x] Test installing `"all"` extra on Linux and macOS (does Pythonnet error?)

The installation.rst docs are also updated to reflect the new options for installing extras.
Output Space Exploration using novelty search like optimization
OpenMole is a java package for exploring the behavior of simulation models. It contains an interesting [novelty search inspired way of exploring the model output space](https://openmole.org/PSE.html). It might be worthwhile to add a similar algorithm to the workbench.

In short, the n-dimensional output space is discretized (like with ε-archiving). For each grid cell, the total number of experiments in that box is tracked. For each generation of the evolution, selection proportionally favors grid cells with few solutions. The selected individuals are combined using a crossover operator and possibly mutated to create new experiments.

It should be relatively straightforward to set up this type of algorithm drawing on platypus-opt. It will involve a new method on the evaluator next to `perform_experiments`, `optimize`, and `robust_optimize`. In addition, a new custom selector to be used within a platypus-opt algorithm is required.


Discussion / hints:

Fix patch:
diff --git a/docs/source/api_index.rst b/docs/source/api_index.rst
index 96d5f1567..a4a7e8afd 100644
--- a/docs/source/api_index.rst
+++ b/docs/source/api_index.rst
@@ -12,6 +12,7 @@ Exploratory modeling framework
    ../../ema_documentation/em_framework/outcomes.rst
    ../../ema_documentation/em_framework/evaluators.rst
    ../../ema_documentation/em_framework/optimization.rst
+    ../../ema_documentation/em_framework/outputspace_exploration.rst
    ../../ema_documentation/em_framework/samplers.rst
    ../../ema_documentation/em_framework/salib_samplers.rst
    ../../ema_documentation/em_framework/experiment_runner.rst
diff --git a/docs/source/ema_documentation/em_framework/outputspace_exploration.rst b/docs/source/ema_documentation/em_framework/outputspace_exploration.rst
new file mode 100644
index 000000000..fee121eee
--- /dev/null
+++ b/docs/source/ema_documentation/em_framework/outputspace_exploration.rst
@@ -0,0 +1,6 @@
+******************************
+:mod:`outputspace_exploration`
+******************************
+
+.. automodule:: ema_workbench.em_framework.outputspace_exploration
+   :members:
diff --git a/ema_workbench/__init__.py b/ema_workbench/__init__.py
index b1372ad1a..f002b824e 100644
--- a/ema_workbench/__init__.py
+++ b/ema_workbench/__init__.py
@@ -20,6 +20,7 @@
     Constraint,
     ArrayOutcome,
     Samplers,
+    OutputSpaceExploration,
 )
 from .util import save_results, load_results, ema_logging, EMAError, process_replications
 
diff --git a/ema_workbench/em_framework/__init__.py b/ema_workbench/em_framework/__init__.py
index 34c6c6344..65fc4f866 100644
--- a/ema_workbench/em_framework/__init__.py
+++ b/ema_workbench/em_framework/__init__.py
@@ -39,6 +39,7 @@
     "ArchiveLogger",
     "ArrayOutcome",
     "Samplers",
+    "OutputSpaceExploration",
 ]
 
 from .outcomes import ScalarOutcome, TimeSeriesOutcome, Constraint, ArrayOutcome
@@ -73,6 +74,7 @@
     Samplers,
 )
 from .optimization import Convergence, HyperVolume, EpsilonProgress, ArchiveLogger
+from .outputspace_exploration import OutputSpaceExploration
 
 try:
     from .evaluators import IpyparallelEvaluator
diff --git a/ema_workbench/em_framework/evaluators.py b/ema_workbench/em_framework/evaluators.py
index 1ee6c415f..4c63e3511 100644
--- a/ema_workbench/em_framework/evaluators.py
+++ b/ema_workbench/em_framework/evaluators.py
@@ -236,6 +236,7 @@ def optimize(
         constraints=None,
         convergence_freq=1000,
         logging_freq=5,
+        variator=None,
         **kwargs,
     ):
         """convenience method for outcome optimization.
@@ -254,6 +255,7 @@ def optimize(
             constraints=constraints,
             convergence_freq=convergence_freq,
             logging_freq=logging_freq,
+            variator=variator,
             **kwargs,
         )
 
@@ -683,6 +685,7 @@ def optimize(
     constraints=None,
     convergence_freq=1000,
     logging_freq=5,
+    variator=None,
     **kwargs,
 ):
     """optimize the model
@@ -704,6 +707,9 @@ def optimize(
                         nfe between convergence check
     logging_freq : int
                    number of generations between logging of progress
+    variator : platypus GAOperator instance, optional
+               if None, it falls back on the defaults in platypus-opts
+               which is SBX with PM
     kwargs : any additional arguments will be passed on to algorithm
 
     Returns
@@ -736,7 +742,15 @@ def optimize(
         evaluator = SequentialEvaluator(models)
 
     return _optimize(
-        problem, evaluator, algorithm, convergence, nfe, convergence_freq, logging_freq, **kwargs
+        problem,
+        evaluator,
+        algorithm,
+        convergence,
+        nfe,
+        convergence_freq,
+        logging_freq,
+        variator=variator,
+        **kwargs,
     )
 
 
diff --git a/ema_workbench/em_framework/optimization.py b/ema_workbench/em_framework/optimization.py
index 30de81641..f555826a9 100644
--- a/ema_workbench/em_framework/optimization.py
+++ b/ema_workbench/em_framework/optimization.py
@@ -253,7 +253,7 @@ def to_dataframe(optimizer, dvnames, outcome_names):
     """
 
     solutions = []
-    for solution in platypus.unique(platypus.nondominated(optimizer.result)):
+    for solution in platypus.unique(optimizer.result):
         vars = transform_variables(solution.problem, solution.variables)  # @ReservedAssignment
 
         decision_vars = dict(zip(dvnames, vars))
@@ -577,7 +577,7 @@ def __init__(self, metrics, max_nfe, convergence_freq=1000, logging_freq=5, log_
             metric.reset()
 
     def __call__(self, optimizer):
-        nfe = optimizer.algorithm.nfe
+        nfe = optimizer.nfe
         super().__call__(nfe - self.i)
 
         self.generation += 1
@@ -743,52 +743,6 @@ def mutate_categorical(self, child, i, type):  # @ReservedAssignment
     }
 
 
-class CombinedMutator(CombinedVariator):
-    """Data type aware Uniform mutator
-
-    Overwrites the mutator on the algorithm as used by adaptive time
-    continuation.
-
-    This is a dirty hack, mutator should be a keyword argument on
-    epsilon-NSGAII. Would require separating out explicitly the algorithm
-    kwargs and the AdaptiveTimeContinuation kwargs.
-
-    """
-
-    mutation_prob = 1.0
-
-    def evolve(self, parents):
-        _logger.debug(parents)
-
-        problem = parents[0].problem
-        children = []
-
-        for parent in parents:
-            child = copy.deepcopy(parent)
-            for i, type in enumerate(problem.types):  # @ReservedAssignment
-                if random.random() <= self.mutation_prob:
-                    klass = type.__class__
-                    child = self._mutate[klass](self, child, i, type)
-                    child.evaluated = False
-
-            children.append(child)
-        return children
-
-    def mutate_categorical(self, child, i, type):  # @ReservedAssignment
-        child.variables[i] = [random.choice(type.elements)]
-        return child
-
-    def mutate_integer(self, child, i, type):  # @ReservedAssignment
-        child.variables[i] = type.encode(random.randint(type.min_value, type.max_value))
-        return child
-
-    def mutate_real(self, child, i, type):  # @ReservedAssignment
-        child.variables[i] = random.uniform(type.min_value, type.max_value)
-        return child
-
-    _mutate = {Real: mutate_real, Integer: mutate_integer, Subset: mutate_categorical}
-
-
 def _optimize(
     problem,
     evaluator,
@@ -797,6 +751,7 @@ def _optimize(
     nfe,
     convergence_freq,
     logging_freq,
+    variator=None,
     **kwargs,
 ):
     klass = problem.types[0].__class__
@@ -809,16 +764,17 @@ def _optimize(
         if len(eps_values) != len(problem.outcome_names):
             raise EMAError("number of epsilon values does not match number " "of outcomes")
 
-    if all(isinstance(t, klass) for t in problem.types):
-        variator = None
-    else:
-        variator = CombinedVariator()
-    mutator = CombinedMutator()
+    if variator is None:
+        if all(isinstance(t, klass) for t in problem.types):
+            variator = None
+        else:
+            variator = CombinedVariator()
+    # mutator = CombinedMutator()
 
     optimizer = algorithm(
         problem, evaluator=evaluator, variator=variator, log_frequency=500, **kwargs
     )
-    optimizer.mutator = mutator
+    # optimizer.mutator = mutator
 
     convergence = Convergence(
         convergence, nfe, convergence_freq=convergence_freq, logging_freq=logging_freq
@@ -837,7 +793,7 @@ def _optimize(
     convergence = convergence.to_dataframe()
 
     message = "optimization completed, found {} solutions"
-    _logger.info(message.format(len(optimizer.algorithm.archive)))
+    _logger.info(message.format(len(optimizer.archive)))
 
     if convergence.empty:
         return results
diff --git a/ema_workbench/em_framework/outputspace_exploration.py b/ema_workbench/em_framework/outputspace_exploration.py
new file mode 100644
index 000000000..80b35bf11
--- /dev/null
+++ b/ema_workbench/em_framework/outputspace_exploration.py
@@ -0,0 +1,414 @@
+""" Provides a genetic algorithm based on novelty search for output space exploration.
+
+The algorithm is inspired by `Chérel et al (2015) <https://doi.org/10.1371/journal.pone.0138212>`_. In short,
+from Chérel et al, we have taken the idea of the HitBox. Basically, this is an epsilon archive where one
+keeps track of how many solutions have fallen into each grid cell. Next, tournament selection based on novelty is
+used as the selective pressure. Novelty is defined as 1/nr. of solutions in same grid cell. This is then
+combined with auto-adaptive population sizing as used in e-NSGAII. This replaces the use of adaptive Cauchy mutation
+as used by Chérel et al. There is also an more sophisticated algorithm that adds auto-adaptive operator selection as
+used in BORG.
+
+The algorithm can be used in combination with the optimization functionality of the workbench.
+Just pass an OutputSpaceExploration instance as algorithm to optimize.
+
+
+
+"""
+
+import functools
+import math
+
+from .optimization import BORGDefaultDescriptor
+from ..util.ema_exceptions import EMAError
+
+from platypus import (
+    TournamentSelector,
+    Archive,
+    RandomGenerator,
+    Dominance,
+    AbstractGeneticAlgorithm,
+    default_variator,
+    AdaptiveTimeContinuation,
+    GAOperator,
+    SBX,
+    PM,
+    DifferentialEvolution,
+    SPX,
+    UM,
+    PCX,
+    UNDX,
+    Multimethod,
+)
+
+
+__all__ = ["OutputSpaceExploration", "AutoAdaptiveOutputSpaceExploration"]
+
+
+class Novelty(Dominance):
+    """Compares to solutions based on their novelty
+
+    Parameters
+    ----------
+    algorithm : platypus algorithm instance
+
+    """
+
+    def __init__(self, algorithm):
+        super().__init__()
+        self.algorithm = algorithm
+
+    def compare(self, winner, candidate):
+        """Compare two solutions.
+
+        Returns -1 if the first solution dominates the second, 1 if the
+        second solution dominates the first, or 0 if the two solutions are
+        mutually non-dominated.
+
+        Parameters
+        ----------
+        winner : Solution
+            The first solution.
+        candidate : Solution
+            The second solution.
+        """
+        w_score = self.algorithm.archive.get_novelty_score(winner)
+        c_score = self.algorithm.archive.get_novelty_score(candidate)
+
+        if w_score > c_score:
+            return -1
+        if w_score == c_score:
+            return 0
+        else:
+            return 1
+
+
+class HitBox(Archive):
+    """Hit Box archive
+
+    Parameters:
+    ----------
+    grid_spec : list of tuples
+                each tuple specifies the minimum value, maximum value, and epsilon
+
+    This class implements both the hit box for calculating novelty
+    as well as maintaining an archive of solutions. Per grid cell, the solution
+    closest to the centre of the cell is kept. This archive thus functions
+    very similar to an EpsilonArchive, including tracking epsilon progress.
+
+    TODO: you actually only need the epsilons and if available
+    TODO: any constraints
+
+    """
+
+    def __init__(self, grid_spec):
+        super().__init__(None)
+        self.archive = {}
+        self.centroids = {}
+        self.grid_counter = {}
+        self.grid_spec = grid_spec
+        self.improvements = 0
+        self.overall_novelty = 0
+
+    def add(self, solution):
+        key = get_index_for_solution(solution, self.grid_spec)
+
+        try:
+            self.grid_counter[key] += 1
+        except KeyError:
+            self.grid_counter[key] = 1
+            self.improvements += 1
+
+            centroid = [
+                self.grid_spec[i][0] + (entry + 0.5) * self.grid_spec[i][2]
+                for i, entry in enumerate(key)
+            ]
+            self.centroids[key] = centroid
+            self.archive[key] = solution
+        else:
+            centroid = self.centroids[key]
+
+            distance_s = [(a - b) ** 2 for a, b in zip(solution.objectives, centroid)]
+            distance_s = math.sqrt(sum(distance_s))
+
+            distance_c = [(a - b) ** 2 for a, b in zip(self.archive[key].objectives, centroid)]
+            distance_c = math.sqrt(sum(distance_c))
+
+            if distance_s < distance_c:
+                self.archive[key] = solution
+
+        self._contents = list(self.archive.values())
+        self.overall_novelty += 1 / self.grid_counter[key]
+
+        return True
+
+    def get_novelty_score(self, solution):
+        key = get_index_for_solution(solution, self.grid_spec)
+        return 1 / self.grid_counter[key]
+
+
+class OutputSpaceExplorationAlgorithm(AbstractGeneticAlgorithm):
+    def __init__(
+        self,
+        problem,
+        grid_spec=None,
+        population_size=100,
+        generator=RandomGenerator(),
+        variator=None,
+        **kwargs,
+    ):
+        if problem.nobjs != len(grid_spec):
+            raise EMAError(
+                "the number of items in grid_spec does not match the number of objectives"
+            )
+        super().__init__(problem, population_size, generator=generator, **kwargs)
+        self.archive = HitBox(grid_spec)
+        self.selector = TournamentSelector(2, dominance=Novelty(self))
+        self.algorithm = self  # hack for convergence
+
+        self.variator = variator
+        self.population = None
+
+        self.comparator = Novelty(self)
+
+    def step(self):
+        if self.nfe == 0:
+            self.initialize()
+        else:
+            self.iterate()
+
+        self.result = self.archive
+
+    def initialize(self):
+        super().initialize()
+
+        if self.archive is not None:
+            self.archive += self.population
+
+        if self.variator is None:
+            self.variator = default_variator(self.problem)
+
+    def iterate(self):
+        offspring = []
+
+        while len(offspring) < self.population_size:
+            parents = self.selector.select(self.variator.arity, self.population)
+            offspring.extend(self.variator.evolve(parents))
+
+        self.evaluate_all(offspring)
+
+        # do we want to compare, or just keep the new population
+        # novelty changes.
+        self.archive.extend(offspring)
+        offspring.extend(self.population)
+        offspring = sorted(offspring, key=functools.cmp_to_key(self.comparator))
+        self.population = offspring[: self.population_size]
+
+
+def get_index_for_solution(solution, grid_spec):
+    """maps the objectives to the key for the grid cell
+    into which this solution falls.
+
+    Parameters
+    ----------
+    solution : platypus Solution instance
+    grid_spec :
+
+    Returns
+    -------
+    tuple
+
+    """
+    key = [
+        get_bin_index(entry, grid_spec[i][0], grid_spec[i][2])
+        for i, entry in enumerate(solution.objectives)
+    ]
+    key = tuple(key)
+
+    return key
+
+
+def get_bin_index(value, minumum_value, epsilon):
+    """maps the value for a single objective to the index
+    of the grid cell along that diemnsion
+
+    Parameters
+    ----------
+    value
+    minumum_value
+    epsilon
+
+    Returns
+    -------
+    int
+
+    """
+    return math.floor((value - minumum_value) / epsilon)
+
+
+class OutputSpaceExploration(AdaptiveTimeContinuation):
+    """Basic genetic algorithm for output space exploration using novelty
+    search.
+
+    Parameters
+    ----------
+    problem : a platypus Problem instance
+    grid_spec : list of tuples
+                with min, max, and epsilon for
+                each outcome of interest
+    population_size : int, optional
+
+
+    The algorithm defines novelty using an epsilon-like grid in the output space.
+    Novelty is one divided by the number of seen solutions in a given grid cell.
+    Tournament selection using novelty is used to create offspring. Crossover
+    is done using simulated binary crossover and mutation is done using polynomial
+    mutation.
+
+    The epsilon like grid structure for tracking novelty is implemented
+    using an archive, the Hit Box. Per epsilon grid cell, a single solution closes
+    to the centre of the cell is maintained. This makes the algorithm
+    behave virtually identical to `ε-NSGAII <https://link.springer.com/chapter/10.1007/978-3-540-31880-4_27>`_.
+    The archive is returned as results and epsilon progress is defined.
+
+    To deal with a stalled search, adaptive time continuation, identical to
+    ε-NSGAII is used.
+
+    Notes
+    -----
+    Output space exploration relies on the optimization functionality of the
+    workbench. Therefore, outcomes of kind INFO are ignored. For output
+    space exploration the direction (i.e. minimize or maximize) does not matter.
+
+    """
+
+    def __init__(
+        self,
+        problem,
+        grid_spec=None,
+        population_size=100,
+        generator=RandomGenerator(),
+        variator=None,
+        **kwargs,
+    ):
+        super().__init__(
+            OutputSpaceExplorationAlgorithm(
+                problem,
+                grid_spec=grid_spec,
+                population_size=population_size,
+                generator=generator,
+                variator=variator,
+                **kwargs,
+            )
+        )
+
+
+class AutoAdaptiveOutputSpaceExploration(AdaptiveTimeContinuation):
+    """A combination of auto-adaptive operator selection with OutputSpaceExploration.
+
+    The parametrization of all operators is based on the default values as used
+    in Borg 1.9.
+
+
+    Parameters
+    ----------
+    problem : a platypus Problem instance
+    grid_spec : list of tuples
+                with min, max, and epsilon for
+                each outcome of interest
+    population_size : int, optional
+
+
+    Notes
+    -----
+    Limited to RealParameters only.
+
+    """
+
+    pm_p = BORGDefaultDescriptor(lambda x: 1 / x)
+    pm_dist = 20
+
+    sbx_prop = 1
+    sbx_dist = 15
+
+    de_rate = 0.1
+    de_stepsize = 0.5
+
+    um_p = BORGDefaultDescriptor(lambda x: x + 1)
+
+    spx_nparents = 10
+    spx_noffspring = 2
+    spx_expansion = 0.3
+
+    pcx_nparents = 10
+    pcx_noffspring = 2
+    pcx_eta = 0.1
+    pcx_zeta = 0.1
+
+    undx_nparents = 10
+    undx_noffspring = 2
+    undx_zeta = 0.5
+    undx_eta = 0.35
+
+    def __init__(
+        self,
+        problem,
+        grid_spec=None,
+        population_size=100,
+        generator=RandomGenerator(),
+        variator=None,
+        **kwargs,
+    ):
+        self.problem = problem
+
+        # Parameterization taken from
+        # Borg: An Auto-Adaptive MOEA Framework - Hadka, Reed
+        variators = [
+            GAOperator(
+                SBX(probability=self.sbx_prop, distribution_index=self.sbx_dist),
+                PM(probability=self.pm_p, distribution_index=self.pm_dist),
+            ),
+            GAOperator(
+                PCX(
+                    nparents=self.pcx_nparents,
+                    noffspring=self.pcx_noffspring,
+                    eta=self.pcx_eta,
+                    zeta=self.pcx_zeta,
+                ),
+                PM(probability=self.pm_p, distribution_index=self.pm_dist),
+            ),
+            GAOperator(
+                DifferentialEvolution(crossover_rate=self.de_rate, step_size=self.de_stepsize),
+                PM(probability=self.pm_p, distribution_index=self.pm_dist),
+            ),
+            GAOperator(
+                UNDX(
+                    nparents=self.undx_nparents,
+                    noffspring=self.undx_noffspring,
+                    zeta=self.undx_zeta,
+                    eta=self.undx_eta,
+                ),
+                PM(probability=self.pm_p, distribution_index=self.pm_dist),
+            ),
+            GAOperator(
+                SPX(
+                    nparents=self.spx_nparents,
+                    noffspring=self.spx_noffspring,
+                    expansion=self.spx_expansion,
+                ),
+                PM(probability=self.pm_p, distribution_index=self.pm_dist),
+            ),
+            UM(probability=self.um_p),
+        ]
+
+        variator = Multimethod(self, variators)
+
+        super().__init__(
+            OutputSpaceExplorationAlgorithm(
+                problem,
+                grid_spec=grid_spec,
+                population_size=population_size,
+                generator=generator,
+                variator=variator,
+                **kwargs,
+            )
+        )
diff --git a/ema_workbench/examples/lake_model_outputspace_exploration.py b/ema_workbench/examples/lake_model_outputspace_exploration.py
new file mode 100644
index 000000000..e441fd29a
--- /dev/null
+++ b/ema_workbench/examples/lake_model_outputspace_exploration.py
@@ -0,0 +1,129 @@
+"""
+An example of using output space exploration on the lake problem
+
+The lake problem itself is adapted from the Rhodium example by Dave Hadka,
+see https://gist.github.com/dhadka/a8d7095c98130d8f73bc
+
+"""
+import math
+
+import numpy as np
+from scipy.optimize import brentq
+
+from ema_workbench import (
+    Model,
+    RealParameter,
+    ScalarOutcome,
+    Constant,
+    ema_logging,
+    MultiprocessingEvaluator,
+    Policy,
+)
+
+from ema_workbench.em_framework.outputspace_exploration import OutputSpaceExploration
+
+
+def lake_problem(
+    b=0.42,  # decay rate for P in lake (0.42 = irreversible)
+    q=2.0,  # recycling exponent
+    mean=0.02,  # mean of natural inflows
+    stdev=0.001,  # future utility discount rate
+    delta=0.98,  # standard deviation of natural inflows
+    alpha=0.4,  # utility from pollution
+    nsamples=100,  # Monte Carlo sampling of natural inflows
+    **kwargs
+):
+    try:
+        decisions = [kwargs[str(i)] for i in range(100)]
+    except KeyError:
+        decisions = [
+            0,
+        ] * 100
+
+    Pcrit = brentq(lambda x: x**q / (1 + x**q) - b * x, 0.01, 1.5)
+    nvars = len(decisions)
+    X = np.zeros((nvars,))
+    average_daily_P = np.zeros((nvars,))
+    decisions = np.array(decisions)
+    reliability = 0.0
+
+    for _ in range(nsamples):
+        X[0] = 0.0
+
+        natural_inflows = np.random.lognormal(
+            math.log(mean**2 / math.sqrt(stdev**2 + mean**2)),
+            math.sqrt(math.log(1.0 + stdev**2 / mean**2)),
+            size=nvars,
+        )
+
+        for t in range(1, nvars):
+            X[t] = (
+                (1 - b) * X[t - 1]
+                + X[t - 1] ** q / (1 + X[t - 1] ** q)
+                + decisions[t - 1]
+                + natural_inflows[t - 1]
+            )
+            average_daily_P[t] += X[t] / float(nsamples)
+
+        reliability += np.sum(X < Pcrit) / float(nsamples * nvars)
+
+    max_P = np.max(average_daily_P)
+    utility = np.sum(alpha * decisions * np.power(delta, np.arange(nvars)))
+    inertia = np.sum(np.absolute(np.diff(decisions)) < 0.02) / float(nvars - 1)
+
+    return max_P, utility, inertia, reliability
+
+
+if __name__ == "__main__":
+    ema_logging.log_to_stderr(ema_logging.INFO)
+
+    # instantiate the model
+    lake_model = Model("lakeproblem", function=lake_problem)
+    lake_model.time_horizon = 100
+
+    # specify uncertainties
+    lake_model.uncertainties = [
+        RealParameter("b", 0.1, 0.45),
+        RealParameter("q", 2.0, 4.5),
+        RealParameter("mean", 0.01, 0.05),
+        RealParameter("stdev", 0.001, 0.005),
+        RealParameter("delta", 0.93, 0.99),
+    ]
+
+    # set levers, one for each time step
+    lake_model.levers = [RealParameter(str(i), 0, 0.1) for i in range(lake_model.time_horizon)]
+
+    # specify outcomes
+    # note that outcomes of kind INFO will be ignored
+    lake_model.outcomes = [
+        ScalarOutcome("max_P", kind=ScalarOutcome.MAXIMIZE),
+        ScalarOutcome("utility", kind=ScalarOutcome.MAXIMIZE),
+        ScalarOutcome("inertia", kind=ScalarOutcome.MAXIMIZE),
+        ScalarOutcome("reliability", kind=ScalarOutcome.MAXIMIZE),
+    ]
+
+    # override some of the defaults of the model
+    lake_model.constants = [Constant("alpha", 0.41), Constant("nsamples", 150)]
+
+    # generate a reference policy
+    n_scenarios = 1000
+    reference = Policy("nopolicy", **{l.name: 0.02 for l in lake_model.levers})
+
+    # we are doing output space exploration given a reference
+    # policy, so we are exploring the output space over the uncertainties
+    # grid spec specifies the grid structure imposed on the output space
+    # each tuple is associated with an outcome. It gives the minimum
+    # maximum, and epsilon value.
+    with MultiprocessingEvaluator(lake_model) as evaluator:
+        res = evaluator.optimize(
+            algorithm=OutputSpaceExploration,
+            grid_spec=[
+                (0, 12, 0.5),
+                (0, 1, 0.05),
+                (0, 1, 0.1),
+                (0, 1, 0.1),
+            ],
+            nfe=1000,
+            searchover="uncertainties",
+            reference=reference,
+        )
diff --git a/ema_workbench/examples/outputspace_exploration_lakeproblem.ipynb b/ema_workbench/examples/outputspace_exploration_lakeproblem.ipynb
new file mode 100644
index 000000000..8061d69c5
--- /dev/null
+++ b/ema_workbench/examples/outputspace_exploration_lakeproblem.ipynb
@@ -0,0 +1,479 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "a9a1d02c-6999-4491-81bd-8d1ec761e890",
+   "metadata": {},
+   "source": [
+    "# output space exploration\n",
+    "\n",
+    "Output space exploration is a form of optimization based on novelty search. In the workbench, it relies on the optimization functionality. You can use output space exploration by passing an instance of either `OutputSpaceExploration` or `AutoAdaptiveOutputSpaceExploration` as algorithm to `evaluator.optimize`. The fact that output space exploration uses the optimization functionality also implies that we can track convergence in a similar manner. Epsilon progress is defined identical, but evidently other metrics such as hypervolume might not be applicable in the context of output space exploration.\n",
+    "\n",
+    "The difference between `OutputSpaceExploration` and `AutoAdaptiveOutputSpaceExploration` is in the evolutionary operators. `AutoAdaptiveOutputSpaceExploration` uses auto adaptive operator selection as implemented in the BORG MOEA, while `OutputSpaceExploration` by default uses Simulated Binary crossover with polynomial mutation. Injection of new solutions is handled through auto adaptive population sizing and periodically starting with a new population if search is stalling. Below, examples are given of how to use both algorithms, as well as a a quick visualization of the convergence dynamics.\n",
+    "\n",
+    "For this example, we are using a stylized case study frequently used to develop and test decision making under deep uncertainty methods: the shallow lake problem. In this problem, a city has to decide on the ammount of polution they are going to put into a shallow lake per year. The city gets benefits from poluting the lake, but if an unknown threshold is crossed, the lake permenantly shifts to an undesirable poluted state. For further details on this case study, see for example [Quinn et al, 2017](https://doi.org/10.1016/j.envsoft.2017.02.017) and [Bartholomew et al, 2021](https://doi.org/10.1016/j.envsoft.2020.104699).\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "21a2c10e-2c97-415f-bf0d-c4f6e3dd5d89",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from lake_model_outputspace_exploration import lake_problem\n",
+    "\n",
+    "from ema_workbench import (\n",
+    "    Model,\n",
+    "    RealParameter,\n",
+    "    ScalarOutcome,\n",
+    "    Constant,\n",
+    "    ema_logging,\n",
+    "    MultiprocessingEvaluator,\n",
+    "    Policy,\n",
+    "    SequentialEvaluator,\n",
+    "    OutputSpaceExploration,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "ce97418a-a5c8-4b44-b0a0-6f4a75293379",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ema_logging.log_to_stderr(ema_logging.INFO)\n",
+    "\n",
+    "# instantiate the model\n",
+    "lake_model = Model(\"lakeproblem\", function=lake_problem)\n",
+    "lake_model.time_horizon = 100\n",
+    "\n",
+    "# specify uncertainties\n",
+    "lake_model.uncertainties = [\n",
+    "    RealParameter(\"b\", 0.1, 0.45),\n",
+    "    RealParameter(\"q\", 2.0, 4.5),\n",
+    "    RealParameter(\"mean\", 0.01, 0.05),\n",
+    "    RealParameter(\"stdev\", 0.001, 0.005),\n",
+    "    RealParameter(\"delta\", 0.93, 0.99),\n",
+    "]\n",
+    "\n",
+    "# set levers, one for each time step\n",
+    "lake_model.levers = [RealParameter(str(i), 0, 0.1) for i in range(lake_model.time_horizon)]\n",
+    "\n",
+    "# specify outcomes\n",
+    "# output space exploration\n",
+    "\n",
+    "lake_model.outcomes = [\n",
+    "    ScalarOutcome(\"max_P\", kind=ScalarOutcome.MAXIMIZE),\n",
+    "    ScalarOutcome(\"utility\", kind=ScalarOutcome.MAXIMIZE),\n",
+    "    ScalarOutcome(\"inertia\", kind=ScalarOutcome.MAXIMIZE),\n",
+    "    ScalarOutcome(\"reliability\", kind=ScalarOutcome.MAXIMIZE),\n",
+    "]\n",
+    "\n",
+    "# override some of the defaults of the model\n",
+    "lake_model.constants = [Constant(\"alpha\", 0.41), Constant(\"nsamples\", 150)]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c2467f90-29e6-498e-977f-9278eb6d9975",
+   "metadata": {},
+   "source": [
+    "Above, we have setup the lake problem, specified the uncertainties, policy levers, outcomes of interest and (optionally) some constants. We are now ready to run output space exploration on this model. For this, we use the default optimization functionality of the world bank, but pass the `OutputSpaceExploration` class. Below, we are running output space exploration over the uncertainties, which implies we need to pass a reference policy. We also rerun the algorithm for 5 different seeds. We can track convergence of the outputspace epxloration by tracking $\\epsilon$-progress.\n",
+    "\n",
+    "The `grid_spec` keyword argument, which is specific to output space exploration specifies the grid structure we are imposing on the output space. There must be a tuple for each outcome of interest. Each tuple specifies the minimum value, the maximum value and the size of the grid cell on this outcome dimension. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "54ee134a-24c9-49d4-842e-bad605aaafd0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[MainProcess/INFO] pool started with 10 workers\n",
+      "26625it [01:40, 265.19it/s]                                                    \n",
+      "[MainProcess/INFO] optimization completed, found 1375 solutions\n",
+      "28514it [01:47, 265.52it/s]                                                    \n",
+      "[MainProcess/INFO] optimization completed, found 1386 solutions\n",
+      "28336it [01:49, 259.12it/s]                                                    \n",
+      "[MainProcess/INFO] optimization completed, found 1372 solutions\n",
+      "28638it [01:49, 262.33it/s]                                                    \n",
+      "[MainProcess/INFO] optimization completed, found 1383 solutions\n",
+      "28227it [01:48, 259.60it/s]                                                    \n",
+      "[MainProcess/INFO] optimization completed, found 1374 solutions\n",
+      "[MainProcess/INFO] terminating pool\n"
+     ]
+    }
+   ],
+   "source": [
+    "from ema_workbench.em_framework.optimization import EpsilonProgress\n",
+    "\n",
+    "# generate some default policy\n",
+    "reference = Policy(\"nopolicy\", **{l.name: 0.02 for l in lake_model.levers})\n",
+    "n_seeds = 5\n",
+    "\n",
+    "convergences = []\n",
+    "\n",
+    "with MultiprocessingEvaluator(lake_model) as evaluator:\n",
+    "    for _ in range(n_seeds):\n",
+    "        convergence_metrics = [\n",
+    "            EpsilonProgress(),\n",
+    "        ]\n",
+    "        res, convergence = evaluator.optimize(\n",
+    "            algorithm=OutputSpaceExploration,\n",
+    "            grid_spec=[(0, 12, 0.5), (0, 0.6, 0.05), (0, 1, 0.1), (0, 1, 0.1)],\n",
+    "            nfe=25000,\n",
+    "            searchover=\"uncertainties\",\n",
+    "            reference=reference,\n",
+    "            convergence=convergence_metrics,\n",
+    "        )\n",
+    "        convergences.append(convergence)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "30395c91-95ae-48d3-b6e4-6194b4db19dd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "\n",
+    "sns.set_style(\"whitegrid\")\n",
+    "fig, ax = plt.subplots()\n",
+    "for convergence in convergences:\n",
+    "    ax.plot(convergence.nfe, convergence.epsilon_progress)\n",
+    "\n",
+    "ax.set_xlabel(\"nfe\")\n",
+    "ax.set_ylabel(\"$\\epsilon$-progress\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3c2a631a-582d-43d4-9f86-aeed8ad5d22e",
+   "metadata": {},
+   "source": [
+    "The figure above shows the $\\epsilon$-progress per nfe for each of the five random seeds. As can be seen, the algorithm converges to essentially the same amount of epsilon progress across the seeds. This suggests that the algorithm has converged and thus found all possible output grid cells. \n",
+    "\n",
+    "## auto adaptive operator selection\n",
+    "The foregoing example used the default version of the output space exploration algorithm. This algorithm uses Simulated Binary Crossover (SBX) with Polynomial Mutation (PM) as its evolutionary operators. However, it is conceivable that for some problems other evolutionary operators might be more suitable. You can pass your own combination of operators if desired using [platypus](https://platypus.readthedocs.io/en/latest/). For general use, however, it can sometimes be easier to let the algorithm itself figure out which operators to use. To support this, we also provide an `AutoAdaptiveOutputSpaceExploration` algorithm. This algorithm uses Auto Adaptive Operator selection as also used in the [BORG algorithm](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.469.9675&rep=rep1&type=pdf). Note that this algorithm is limited to RealParameters only."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "df75f95f-37b3-434a-9c8b-479854af12e6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[MainProcess/INFO] pool started with 10 workers\n",
+      "29556it [01:56, 252.85it/s]                                                    \n",
+      "[MainProcess/INFO] optimization completed, found 1437 solutions\n",
+      "30067it [01:58, 253.31it/s]                                                    \n",
+      "[MainProcess/INFO] optimization completed, found 1443 solutions\n",
+      "29957it [01:55, 259.12it/s]                                                    \n",
+      "[MainProcess/INFO] optimization completed, found 1458 solutions\n",
+      "30091it [01:57, 256.60it/s]                                                    \n",
+      "[MainProcess/INFO] optimization completed, found 1451 solutions\n",
+      "30167it [01:58, 254.13it/s]                                                    \n",
+      "[MainProcess/INFO] optimization completed, found 1443 solutions\n",
+      "[MainProcess/INFO] terminating pool\n"
+     ]
+    }
+   ],
+   "source": [
+    "from ema_workbench.em_framework.outputspace_exploration import AutoAdaptiveOutputSpaceExploration\n",
+    "from ema_workbench.em_framework.optimization import OperatorProbabilities\n",
+    "\n",
+    "\n",
+    "convergences = []\n",
+    "\n",
+    "with MultiprocessingEvaluator(lake_model) as evaluator:\n",
+    "\n",
+    "    for _ in range(5):\n",
+    "        convergence_metrics = [\n",
+    "            EpsilonProgress(),\n",
+    "            OperatorProbabilities(\"SBX\", 0),\n",
+    "            OperatorProbabilities(\"PCX\", 1),\n",
+    "            OperatorProbabilities(\"DE\", 2),\n",
+    "            OperatorProbabilities(\"UNDX\", 3),\n",
+    "            OperatorProbabilities(\"SPX\", 4),\n",
+    "            OperatorProbabilities(\"UM\", 5),\n",
+    "        ]\n",
+    "        res, convergence = evaluator.optimize(\n",
+    "            algorithm=AutoAdaptiveOutputSpaceExploration,\n",
+    "            grid_spec=[(0, 12, 0.5), (0, 0.6, 0.05), (0, 1, 0.1), (0, 1, 0.1)],\n",
+    "            nfe=25000,\n",
+    "            searchover=\"uncertainties\",\n",
+    "            reference=reference,\n",
+    "            variator=None,\n",
+    "            convergence=convergence_metrics,\n",
+    "        )\n",
+    "        convergences.append(convergence)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "7d9f99bc-1b61-450b-b7e2-4f436654b3b0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtkAAAHeCAYAAABOoBe7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAB2/ElEQVR4nOzdeXhU5cH+8e+Zfc1GAiRAIAHCIiA7WhTFDeu+YqEvra+1Vd/WFrVWa13aamttlWr91Wqt1hYXRK2tVXGtCgIiILsBAVkDhJB1ZjL7nN8fwSh1Q01yJuH+XFeuJJMzOffkIXjz+JznGKZpmoiIiIiISJuxWR1ARERERKSrUckWEREREWljKtkiIiIiIm1MJVtEREREpI2pZIuIiIiItDGVbBERERGRNuawOkB7WLlyJW63u8PPG4/HLTmvfDqNSfbRmGQfjUn20ZhkH41JdsmW8YjH44wcOfITv9YlS7bb7WbIkCEdft7KykpLziufTmOSfTQm2Udjkn00JtlHY5JdsmU8KisrP/VrWi4iIiIiItLGVLJFRERERNqYSraIiIiISBtTyRYRERERaWMq2SIiIiIibUwlW0RERESkjalki4iIiIi0MZVsEREREZE2ppItIiIiItLGVLJFRERERNqYSraIiIiISBtTyRYRERERaWMq2SIiIiIibUwlW0RERESkjalki4iIiIi0MZVsEREREZE25rA6gIiIiIjIwciYGZKZpNUxDopKtoiIiIh0qFgqRlOiicZ442e+b4o3Hfh5ogkbNn4+5OcMYYjVL+MzqWSLiIiIyBeWyqQIJUJfqizH0/FP/b42w0aOK4ccVw657lxyXDn0DvZu+dyVQ3d7Pv0i+SR27sTm9+PIz+/AV33wVLJFREREDlGmadKcav7ckvxJZTmcDH/q9zVMkzzTR5ERpMD009P0MSSTS26mBzlpJ4G0E3/Kji9lw5M08CRMXIkMzngaWyyJGY2SaW4mE42Saa4l09yMuf9zTBOAzYAtEGDQsqUd9NP6YlSyRURERDq5RDpxUCX5v8tyKNaIPZ7CkwR3AjzJ/W8JE3cS/Ek7eRkPJRk3gz8ox0kbvlQB7mQB7oSJM57BGU9hjycxogmIxiAWA0L73z6f4fGQ8flIer3YfD4MX8t7Z34+Np8P2/7HbX4fhtdLTVOI4rIy3P3L2/Xn+lWoZIuIiIhkgXQmTTgZpineRGOi8cD3sXqam+pobqojFmogFmkkGQmRjITIRJqxxRL7yzG4k+b+9y2fB5PQM2XHn7LhSdpaZo2TJs54Gkci/TmpMkCSD8qy4fVi+HwYviCmLwC+AOT7MT0eTJcHXG5MlxPTsf/N7sC028nYbJiGDdNmkOGjb5DJmGTSkE5lSKchnaLlfRrSaYN0xkY6bCPdZGv5OOMgbXYjs8lO+tUa0uZrHDOtgsOO7tXOI/TFqGSLiIiItJFMMklzUx1NTXtpaqghEqptKcehOuKhRuLhlnKcag6Tbm7GbI5iRGMQi+OIpfYX45ZZZE8SChJQnDRwZBxkbA5Mo+V965vhx7Tl7v/cScZwkLE7yLhbSq/p9mL4PJhOF6bDRdzuIOZwkrHZMW2OlveGnYxhI4OdDDYy2EhjI2PayJh20thIZ+ykTTtp00HG/IT6aALx/W9fgEEau5Hc/5bGZqSwGRmc9gx2Wwa7PYPDYeK2Z7A7MtjtYLcnSKYT+Pw+7MUlOIIF9KrIvnXZKtkiIiJySDJNEzMaJR0KkWlqankfCpGKNBNvChFubCAaChGNhKmv2cdubKRjCdLxJJlEGjNhQtLESBsYaRu2tB2DDwvwxwtxEMOWj8PmwLb/sbTdSdruwPQ7SQQdxG0OGmzOlucadkwcmIa9zV6zjf2FliR2M4k9k2r52EhityWw29I4bRlsRga73cQwMthsJtjBMEywgWkD04CMDdKGQdowSNLyFjdsxE2DmGkQNW1ETBvhtEEoY6MpZaMxbaPZdNBsOIjiJGY4MbHRUkkdgBu7zeDlKyZRXhT41NdRWVnJkCHaXURERESkzaWSaRINEeL1TcTrmkg0hok3REiEoiTCUZKROInmBPHmOPFonEQ8RSrVsgQhk3GQwUHa5iZjd5Oyu0nbXWTsbjI2N+AGCj9+0g+6oP8gApoZDKOlxNpI4jBSOD4otEYSly2Jw4i2fN1I7S+6H8zgmthttLx3GNgdYLeDzWHDsBsYNhumw4Zps5Gx28gYNtI2G0mbnZTNTgIbMcNBAjtRbERwEMk4CKcdhNIOQikbjSkfjUkbTQk7oZRBNJEmnsp8wusAUp/+Mj1OGz6XA6/Tjtdlx+ey43G2vP/gsZ5OO+WtnzsO+Jp3/7Ge/c8t8LnonuM5mD8CWU0lW0RERNqNaZqkkxmS8fSHb4n972NpEuEoicZmEqFmEuEYyUicZHOcRHOcVCxJMpEhlTRJpg1SGRsp00HacJI2XJi2T5vh9ex/+2iQNIYjAfY4JglMI07aiGMaEUxbHdjjYIths8dw2OM4HWlc9jRuZwa/3cRFmjy3i4DDTsBhx+VyYnPasDsd2J1O7C4nNpcDnE5Mm4OUw0HK5iKOkzguYqaT5oyTGD4iaQcR00kkZSeScdCUchBO2Qml7DQnM8SSaZoTaaKJNNFkmuZEquXjaJpk2vxCP3/DAN8HZdZlx+d0tJRZpx2v307+R0ruR0vyB2W4tQDvf39AgXbZ8Tjs2GzGl/qz0dWpZIuIiAhmxiSZSJNKZEjGUyTjLcU49d/F+IC3VMtscThKsjlGMppseU4iQzL1QSm2A7aDzmFkktjTH7wlsGXiYMYxiZMxWspxxpYgZYuTdCSIO+LEHAkSzjgZVxLDncTuzuDwZ3D77QR9TnLcLvI9fvLcuQRdeXideXicBdgdPYkbfppxEzE9hE0P4bST5nTLrG7T/rIbS6bZtbcWly/wYQFOpomGPijBHxbidOZgSnB6/xvYbUZrCf7vApvvc+0vxh8tyR9+fGABdnziDLLbYcMwVIKtoJItIiLSiWTSmZbZ3f8uvImWmeHUf5fh/Z+n4mmSsRTJWIJkLPmR8pwhmTBJpb5YEbOlE9jT8Za3zAcft7x3ffB4OoFhxjCNBBkjTsoeJ+5IEHUkiDjjRF0Joq4EEXeCsDtOxBMn5DVJe2w4/F5cfj8BT4CAI4DPnoPPkYvLlovTVoxhL8Aw8vFkgjhSPhIJB83JDJF4ikg8TSSeojmeItyUojmRJhxveX9gCU4BjZ/5Ol12G16XHaeRIceXaS23AbeDooC7tRB7nY6PfPzx0vzRMvzRZRIux8H/A0Q6F5VsERGRdpJOZ4iFkySiqdblEf89I5xKHPh4Kp6mrraRDfPeaSnE8dT+8txShtOft+Paf3GYMeyZOI5MvLUU29IJ7Kk4zmQCe6pltvijJdn+kZJsM+PgSJBxJEg5k8RdSSLuJGGPSYMb6r1pGjwmETc0eyDiNoh4Wj5udoPd5cPnCOKx5eCy5eA0CnCYfgzTD2kfmbSfdNJLMuElHvcSi7tpjtiJ1KWIJj/vxSaBOqAOr9OO3+3A77bjd7W8z/e76J3va3nM7cDvcuBzt8wG+1wfWTbh+u9lEvvfO+047C0luDNcaCfZRSVbRETkIJkZk3hziuZQglg4QXNTkmgosf9t/8dNUaJNcZrDKeLRg1s/a5DBYSRwEsNBHHsmSiLTUo59H5TfVBxbqqUUG8k4tkQCWyKJLZnA/ikl2ZZJYtgNTK+DtMdByusg7rUT9dqJ+Ow0eaDBbVLvSlPnTLLPGSPkzhDx0Fqak44PZ7gd+HGQgy0TgIwfM+1rKchJL4mEl1TSi5nyYzb6MOt8mCkfn1Q1bAatpdfvbpkVDrgc9Mh1fKQQ2z9yzEfLs+OA0ux3txRmu9YFS5bpkJK9atUqbr/9dmbPnt362L///W8efvhhHn/8cQDmzp3LnDlzcDgcXHbZZUyePJlYLMbVV19NbW0tfr+f2267jYKCgo6ILCIihwDTNEnG060lubkpQSycpDmUINrYTLShmWhjlGg4STSSIRo1MM1PKnMZPLZmPDTgMRvJyTRRlA7hSra82ZNRbB8U42QKI5GEeApbNN5SmDMpPrUi2m3Y/R7we0j5PCR8bqIBJxGPk0aPjUaXQYPLSYMTGpxQ58rQ4EzR4Iaw207SARgmLbO+yf2v24aZ9mKmfZhp//73PszU/tnluA+aP/yawwjgdwTxu1wE3C3LIvxuB36vA3/eh6X3gK+5DizDAXfLLHLA7dA6YTkktHvJvv/++3nmmWfwer2tj1VWVvLkk09i7r/3fE1NDbNnz+app54iHo8zffp0Jk6cyGOPPUZFRQWXX345zz33HPfccw/XX399e0cWEZFOLJVMfzirHEq2lOT6JqINYaKN0ZYCHU4TjUI0aied+eQdKlxE8Bgh3GYj3kwTeekQ7mQIZzKEM9GMIx7DEYtgj4SxhUIYqU9Z2mC3Q8BPxh8g7QuSzPcTdbuIuB2EnDZCLmh0mjQ40zQ6kzQ4E9Q5o4S9SZrcUWLOCKY9hmEkgKaPfXvTtGOmfB8pzHk4TD+OTBBPPEgwGcTnyCHgyCHHlUeeO48cV5Cgx4nP7Thg1viDktxSiFtml31uO0671g2LfFHtXrJLS0u5++67+clPfgJAfX09t99+O9dddx033HADAKtXr2bUqFG4XC5cLhelpaWsX7+e5cuXc/HFFwMwadIk7rnnnvaOKyIiWSaTzhCLpIg2xmiuayBa10C0vqUwR0NxoqEU0WaT5qiNaNxFMu38xO9jJ4GHRjxmE+5MCH+6CXcqjDMVxZmM4og344iEcUSasDXVY8988sbAGa+PZDCXmC+HhmAPmgrLqHU6qXEa7HOa7HOnqfekafQlCfkTRL0xDEcUw96MYd+JYf+MW+KZTuxmAHvGh8eRS66thJ72HALOXALOXHJdOeR78sn35lPky6fIW0A3X7C1IPvdLRfVaUs1Eeu1e8meMmUKO3fuBCCdTvOzn/2M6667Drfb3XpMOBwmGAy2fu73+wmHwwc87vf7CYVCB3XOeDxOZWVlG76KgxOLxSw5r3w6jUn20Zhkn44eEzOTId0cJd3YRCrUTCocJRmOk2xOk4hmSMQM4nEH8aSbWNJDPO3lk7aAM8jgIbq/NDeRm26mKB3BmWxumWmOhbFHQjjCjbiaG7Cn4x9bkmHabCT9QeK+IM1eP+FgHo3delHv9FHjtFPjMtjrzNDgyxD2pwn546TdzRiOMIY9hM2xB8PevH85xoHsuPAYQXJtQXz2PAL2PgQdQXKcQfKcQfLdORS4g+S7cgg6ggQdQdz2lv82xmIxPJ6DuBlHOgyhMPFQy92sa7/4cMhB0t9d2aUzjEeHXvi4bt06tm3bxs9//nPi8TibNm3iV7/6FUcccQSRSKT1uEgkQjAYJBAItD4eiUTIyck5qPO43W5LrgDWlcfZR2OSfTQm2ecrjUkqgdlcR7KxlmhtPdG6JqKNH8wyt6xjbm6GWMxBc8JNNOkllg6Qaf3Pj2//Wws3IdxmCLcZIZipoSAdxZVqxhmP4IiGcEQasDfW4oqHcKSaMTiw3JoeL6lgLolAkGZvDg05xTS6+lPr8FNjd7PLgN2ONI3eNE3+DDFvHJzhltLsCONwVmM4QpjGJxdnj81DriufQm8hPfx9KPIV0s3bjUJPy/uPfuxz+j72/IOl35PsozHJLtkyHp9V9Du0ZI8YMYLnnnsOgJ07d3LllVfys5/9jJqaGu68807i8TiJRILNmzdTUVHB6NGjeeONNxgxYgTz589nzJgxHRlXROTQkUlDrBGa6yBaTzpU17IsoyFMc2OUWChOczhNtBmiMTvRuIto0kM0FSSaySXFB/938sA77TmI4SGM22zGZTYSSO3BmYzgjIdxNDfiCNXhDNfhTIZxJsPYzI/c0tkwyARzSQVziPtziPiC1BaU0FA+gFqHj72Gh12Gi11GhkYfhHxpkp4oNnsYwxHCcIRxuvZid4bBHiZthOG/SrkLcNs85HsKKPIVUuQt/VhZ7ubtRjdPNwq9hV+pOIvIoSUrtvArKipixowZTJ8+HdM0ueKKK3C73UybNo1rrrmGadOm4XQ6ueOOO6yOKiKS3UwTEuH9ZbmlMNNcRyZST6wx1LJbRlOMaDhNc3OGWNRGJOZgS9JHNJNDNJNLNJNLwvQDRfvfPmQjhYcIbqK4MlHy0jUUJbbgjDW1zDI31eKKN+JKhHAmw9gzyQ+f7HKTzs0lGcgl5gsSyQuyr3sp9a4h7LN7qTY87MLDLtNBo89GxJPCdDVjOEKtxdntbsThqsLmCJO2hUjxYXF28OF/1Nx2N4XeD2aZ+3ysLKs4i0h765CS3bt3b+bOnfuZj02dOpWpU6cecIzX6+UPf/hDR0QUEclumQw0bIPqdVC7ETNSSzwUJtYYozmcJBoxiTYbROMOoulAa1luzuQSTecSM8v4tHXNLprxGHFcmSiBVIj8xG4c0Uac4Toc4drWwuxKhLCnY63rms1gDumcXJKBHKLeIOEeQRr79KfO4aNmf2muMj1UmW4a3V4S7lTrDLPhCGFzhPF6mnG567E7wpj2ECmjiYQZAky8/5XVY/d8pCz3+lhZ/uDjbt5u+Bw+bREnIpbKiplsERH5iOY62PsuVK8jtauS+u17qatOUhvvQV2qlLpkKZHMYR9Z13wglxHHRRR3Joo71UwgvgVntAFHaB+uaAPORAhXMtyyFV1y/7pmhwMzN59UTi4Jfw7N3gCh/CCNrsKWpRk2L3sMDztNN7tND00uHxkbLTtm7C/OdkcIny+Kx70PhyuC4QiTMZowacSVCeHi42ucXQcU54EfK8uF3kIVZxHplFSyRUSskorDvvegeh2Z3e/SuL2Kul0RasNB6pJ9qU2V0pg+DXP/DLRBmmC6nkBsL91C77bOMruSoY8U5zA2Mw2BAGZOLslgLnFfDs25QZp65LHLWUKt3cdeW8vSjJ2mmz14aHa4wTCADIY9guEI4XCGCfhjeD0RXO4abM4w2ELkGk24Mw1E002Y/1Wc00Da7iGvtTgP+FhZVnEWkUOBSraISHszTWjcAdXvYu5ZS3jHVmp3NFFXZ6c23ofaZCn1ma+RMVytx/sStfibdtI3sppAZBf+yC48tijpHj2JFnQn0iOXxtJCdjpL2Wf3tSzNwMPOjItqw0PK9tG/3luKs9MVJicQw+eN4vHU4HBF8NpD9EzVgjNKNN1AJNV4QHH+4B6BBy7VKP9YWf7okg0VZxERlWwRkbYVa4Tqd2HvOqI7NlK3rZaaXWn2RXpSlyqlgcEkbaNbD3fH6/GHd9E7Mh9/ZBc5jgj5RW4cvUvY26+QjY4KXkmOZH7ETa3Nu3+2GSCDyx0lLxAj4I/i9YRxuffS0xGmhy1EymgklmkkkmoglGxoLc7x/W8AHjx0c3Ujz+mjd0HZp65vLvQWqjiLiHxBKtkiIl9GOgn7NsLed4nvqGTf+ipqtiepDeVTZ/al0dabuKO89XBHMkIgsovukaXk2MPk5xrk9woQ6NcLV+lAIoWTWJX289zeOG9v3cf66t2YZj0OWy3FxVWU5kUY4G4inN5HU2IfTclGMmaGKBD94CQp8Jie1oLcz9vvU9c3f7Q4Z8t+syIiXYlKtojIZzFNaNqFuXst8cql1Kzdwb5dKWrDuTTSi0ZHH6Luia2H22xx/JE9FJpbyA1kyC9yUtg3n5wBvXGXHoezTx+SDoOVu7fyxPsbWbl7C5ve/w+NG/ZiOBuwOxuwBRvx5Xx4S+86IJEOUGwrpl+wmO6+wz+xOHfzdMPv9GvGWUQkC6hki4jsZ4brSa5ZQGzdUurfq2JftUl9cy6NRjEhdy+avRMwbV8DwPCm8Sf3UeBoIi+3mYKSAIUDu1MwpIxY0XiqE/vYFd7Fu5Hd7Arv4r265Wx9p4raRXtI0HjgiX0GeY58evqL6Z8/ll6BEooDxZT4S+jp70lJoISgK2jBT0RERL4slWwROaRkYjGS27aSWLeUeOUKmrbupq7WRkM8n0ZnMRF/CRHfRDJ2F3gBL/gyDeR5YvTrEaagXyGuch/NfWBPIsmuSIS1kZ3sCu9id2Q3uxfvJpKMHHhS00EmkUcmmYfbGEzfYAlDi0oZ16c/E3oPoGegBy67y5Kfh4iItA+VbBHpctKhEInt20lu305iYyWJjWuJ7KimrslFE0VE/CWE/SVE/JNJOf3QveV5HiNCrj9OQY8Y9DUI92imxruLjfGqlgId2U11pJrUeyl478Pz5bhyyXV2x0jn44n2panBQyLWUqpLgyWMLy1l/PBCxvcroE+BV8s5REQOASrZItLpmKZJuqGB5LZtJLZvJ7F9B4mt75Pc/B7RXTU0ZXL3l+gSIv5iIoHTiPfMg54tz7cbcdyBELaiJuJFNdT4drHd+R47k9uoi9W1HBQFtoLNsNHd150SfwmHFx1OSVkJuc7uNIb8VNV4qNxpp7IqTlXGxGbAkOIcpg4sYHxZAeP6FVAUdFv0UxIRESupZItIVjIzGVI1NSS2bSO5YweJbdtJ7NhOctt2Etu2kmqO0eztQcRfTDhQQnNOLyL542juXgjG/tuHG0lS/npCudXs9a9iu3Mze9xbibga+eDe4F6Hl2J3McX+Yo4LHEexv+XjkkAJxf5iuvu6U92UZOmWOt7eWsezy+rYuDcMgMuRZmTvIJcc04tx/QoY0zefoMdp0U9MRESyiUq2iFjGTKVI7tlzYJHevp3k9m0kduzEjMUwMYh5CggHehEtKCEUHEfTyDOJOnqC0fJXmEmakHcfNb4q6rzLqPXtpt63mybPPvK9+a2l+Wv+EZT4T24p0oGWMp3nzjtg+YZpmmyuCfP2lnoe3rqXt7esp6qhZZO8oNvB6L75nDWqF+PLChjeKxeP027Jz05ERLKbSraItKtMIkFy587WNdKsWsX2UKhlRnrXLkgmATCBhC+PcM9+NOSU0zBqAmFXT1JGCQae1u/X5K6lzrebOm8ljf5qjG5JgkUuinN7Uu4vZqL/yNYCXewvxuPwfEqyFql0hnW7Glm6tY63t9SxbFs9dZEEAIUBN+PL8rn46DLG9StgSHEOdpvWU4uIyOdTyRaRryzT3Exix44PLzZsnZHeTnL37pa9pvdLe5xU9yykpqA7tX36U+8qIm7viT1TgjsdaD2u2Rmi0bebZM4aHIUZAsVeinrlMLKgmGL/JIr9xRR6C7HbvthMciyZZsX2BpZurWPp1jre2VZPJJEGoLTAx+RB3ZlQVsC4sgL6ddNdDkVE5MtRyRaRg5bYuZPoqlX/tbRjO6mamgOOS+b4iBT62NvTzu6KCvZ6uhF29sBJCTnxYgKJ/NZjTSOGzVuLI38v3pImepSVUNqvJ317jiXHlfOVMzc2J1m2rWU99dItdaypaiSZNjEMGNQjyLljejOuX8uFij1yPnvWW0RE5GCpZIvIZ0rs3EnohRdomvcCsXXrWh/PFOazN99gZ2mKbYd5qA7mE/OUYNiLCSZKKGjuSW6sCAMb3WLQLZ7EGWjE1S1Maf8ApYMH0aO8J4F8d5vOFlc3xXh7S13r8o8N1SFME5x2g+G9crnoqDImlBUwprSAXJ8uUhQRkfahki0iH5PYWUXoxRdoeuFFYmvWAOAZPpz8q2ayrDTF0ztXkaj207O5hJ7h7uTFe5IfckIIIEPQF6Kou0m3XgYF/XvRrX8vcrv7sNltVFZWMmTIkDbJaZomW2ubeXtLLW9vqWfp1jq21zUD4HPZGdM3n1OGFzOuXwEj++ThdekiRRER6Rgq2SICQHLXLppeeJGmF14gtno1AJ5hw+h+9Y+JHjWSuaE3WPLW2wx4ZQKjQ98AwG/fR7dC6FaSoltZEQUVZeSX5OBopzKbzphU7m5qXU/99pZ69oXjABT4XYztm8+3juzL+LIChhbn4LDb2iWHiIjI51HJFjmEJXfvpumFFwm98ALRVasA8Bx2GEVXXUlwyhRWu6q5e+0cdj6zhBG7JjMpOhKXq55xwQcYfJgNz1m/grzSdssXS6ZZvfPDnT/e2VZPKJ4CoFeel6MHFu5fT51P/6KALlIUEZGsoZItcohJ7tlD6MUXaZr3AtGVKwFwDx1C0ZVXknPyFDIl3Xl+y/M8vvRa3Ot7MmLPMfRPBsnNaWC86/f0L9qM/ZRbYcgZ0MalNhRLsnxby7KPpVvqWbmzgUQqA8DA7gFOH1nSsvNHvwJK8rxtem4REZG2pJItcghIVle3FOsXXiT6zjsAuIcMoWjmTHJOnoKrXz92h3dzz4bHmffqK5RtG8PXar6NI+2kV2mCMem76J16A2PC9+C4R8Dz1Xf9AKgJxVtnqZduraNydxMZE+w2g2G9cvn2kX0Z16+Asf0KKPC72uScIiIiHUElW6SLSjc20vjsszQ9P4/o8uUAuAcNomjmjwhOmYK7rAzTNFlevZxHX/8Dq999j+G7juX02pnYDBsVhwcYaTxI4a7HoOcIOP1V6DXmS+cxTZMddVFe3hTioXWrWbq1jvf3RQDwOG2M6pPP5ccNZHxZAaNK8/C59NeTiIh0XvqvmEgXYmYyNL/9Ng1PPkXopZcwEwncAwdS9KMfEpxyMu7yMgBiqRhPb3yaR959hOYtNsbuOYmzG07D4bYx7LhiDs99hcDSWwADpvwaxl8C9i/210UmY/Le3hBLt9SxZP9MdXVTy0WKuV4n4/rlc8G4PowrK2BYSS4uhy5SFBGRrkMlW6QLSFZX0/j00zQ89Q+SO3Zgy8kh77zzyDvvXDxDh7Yetyeyh8c3PM4/1j9NYVU546svIBDuhi/PxchzShlatgf3KxfBurUw6BT4+m8hr89BZUikMqypaty/nrrl9uSN0ZZbpvfM8TChrBvjygoozDQw5YgR2HR7chER6cJUskU6KTOZJPzGGzQ88SThBQsgk8E3YQJFP7yc4IknYvN8ePfC6kg1962+j2cr5zG4+gjO2Xs1jqiXgl5+Rp9XyoDD3NjfuAUeeRCCxXDBIzDktM88fySe4p3t9Szd0nI3xZU7GoglWy5SLC/y8/VhPVvvpNg739u680dlZbMKtoiIdHkq2SKdTHzLFhqfeoqGf/6L9L59OIqK6HbxxeSdew6uvn0POLYh1sADax/gmVXPM7hqIt+q+QVG0kHvwfmMOrGUPkPyMd59Gu77KURq4IjLYPJ14A5+4rmT6Qyvrd/L3GU7eH1DDamMic2AoSU5TB/fl/Fl+YztV0BhwN0RPwoREZGspZIt0glkolGaXnyRhiefJLpsOdjtBI49lrxzzyUw6WgMx4G/ypFkhL+/+3ceXTWHwduO4vzd12LDzoAxPRh1YilFpUGo2wKPfg82vQLFI2H641Ay6hPP/35NmMeX7eCp5VXsC8fpHnRz0VFlTBxQyOjSPIIe3Z5cRETko1SyRbKUaZrE1q6j4aknaXr2OTLhMM6+pRRddSW5Z56Js3v3jz0nno7z+PrHeWDVg/TcMZjzdl2LI+5m8BE9GXd6GTndvJBOwoJZ8MZtYHPAybfB+O+C7cC7NDYnUjy/Zg9zl+7g7a112G0Gxw3uzgVj+3DsoCLdTVFEROQzqGSLZJl0QwON/36WhqeeIr5+PYbbTc7JU8g77zy8Y8d+4l0NU5kU/9r0L/606k+4qvI5o+pHeEK5lAzMY+J5A+jed/++1tuXwLMzYe+7MPi0lgsbc3u1fh/TNFm1s5HHl+7g36t2EY6nKCv0c83Jgzl3TC+6Bz0fO7eIiIh8nEq2SJZI1dWx97bbaJr3AmYigWfoUHredCM5p56KPeeTb/6SMTO8tO0l/rjijzTuiXHSrhnk1/Qht8jL1745gLLDC1tKebQeXvk5LH8IcnrDNx6Dwae0fp/6SIKnV1Qxd9kO1u8J4XHaOHV4ScsWe/3ydbtyERGRL0glWyQLRNesYecPf0S6tvYTt977b6Zp8mbVm9y94m62VO/ghOpv0HvncNweB2PP68fwY3tj/2Df6T1r4dELILQbjvwBHPtTcAfIZEwWbt7HnKU7eHldNYl0hsN75/Krs4dx+uEl5GidtYiIyJemki1isYYnn2TPL36Jo6iIvo89ivewwz7z+Heq3+Gud+5i1Z7VTKw9nWO3X4KRsjHs2F6MO7UMT+Aj5Xjjy/DEheDOgYtfgV6jqWqI8sSC93hi2U6qGqLk+ZxMn1DKBeP6MKS4bW6XLiIicqhTyRaxSCaRoPpXv6bh8cfxf+1ISu64A0d+/qceX1lbyR9W/IE3d77JyNAkLtnxWzJNdvqOKORr5/Qnv6f/wCe8fT/M+wn0GEZi6mO8vNPO4y++zYKNNZgmHDWgkGu+PpiThvbA47R/8klFRETkS1HJFrFAcs8edv7oR8RWrabbdy+maOZMDPsnF92tjVv548o/8sLWFyiLDeX/dt9GZo+H/N4BJl40gD6DCw58QiYNL10Pb91Dov9JPNjjev5yz3r2heMU53q4/LiBnD+mN30KfB3wSkVERA5NKtkiHSzy9ttUXXElZjRKr7vuImfKSZ943J7IHu5ddS//3PRP8pPduaT+Fxib8vDkuJgwo5zBRxZ//M6J8TD847uw4XkWdjuPizecQ3TdTo6pKOLCif2YNLAIu+62KCIi0u5UskU6iGma1M+eTfVtv8XVpw+9//YQ7gEDPnZcKBHiT6v+xOPrH8eRcvHt6I/xVvYCDEadUsqok0pxeT7+q2s27SL80Hn46yr5efLbPF79dc4Z3YuLJpYxsMcn38FRRERE2odKtkgHyESj7L7xJpr+/W8Cxx1HyW2/wR78ePHdULeBK1+/kqpQFVPN79F93WHEw2n6T+jOEWf2J1jw8X2qY8k0b8z/D6PfvBRvJswV9mvpf9w5LJpQSjfd3lxERMQSKtki7SyxYwc7L/8h8Q0bKPrRD+l2ySUYto/fLfHfm//NLxf/kpJEOT/adifN1RkKBgSYeN5AevT7+K4f+8JxZi/expbFT/Pr9CyiNj+Lj3mE306ajNuhCxlFRESspJIt0o7CCxZQ9eOrwTTpc9+9BCZN+tgxyXSS25bexuMbHuek2PkMXHs0eB1M+W4F/UcXfexGMBv2hHjgzff558pdXGC+wJ3Ov9NcMITCC5/gxI/cvVFERESso5It0g7MTIbaP/+Zmrv+gLuigt53/wFXaenHjtsT2cNVr1/Fur3vcnH99TjeK6JnRS4nfucw/LkfLvXIZEze2FjDg29uYcHGffic8FDPp/navieg4usEzv0LuAMd+RJFRETkM6hki7SxdCjErmt/SvjVV8k57TSKf/kLbL6Pb5e3ZPcSfjL/JzhCPr6//XYSew3GnNyX8aeXYbO3LCeJJdP8450qHly4hU17w3QPurnuhD5cuPsWXJtfhAmXwZRfgU3LQ0RERLKJSrZIG4pv2sTOH1xOYscOelz3U/JnzPjYcg/TNHlg7QPcveJuxkWPY1zlGRg2O6d+fyj9hhcCsDcUY/bibTyyZDt1kQTDeuXw+wsO59R+Bq7HvwHVa+GU22H8d614mSIiIvI5VLJF2kjTiy+x+6c/xfB6Kf3rg/jHj//YMaFEiJ+9+TPe2PYGUxsvJ299OQV9A0z57jByCr2kMyZ/W7SV21/aQDSZ5oQhPfjOUWVMKCvAqF4Lf70AYo0w7XGo+OT9tUVERMR6KtkiX5GZTlNz553U3v8XPIePoPddd+Hs2fNjx32wPV9DbZjLdv+G9C43w47pxVHnDcTutLG2qpHrnl7D6p2NHDuoiBtPG0p50f511u+9BE/+L7hz4KIXoOfwDn6VIiIi8kWoZIt8Ban6enZddRWRRYvJmzqVHtf/DJvL9bHjPtierzw8jDM3/hgzZePEiwZRMb4nzYkUv39uPQ8u3Eq+z8Xd00Zx2ojiD5eZLPkzvHAN9BgG0x+HnJIOfpUiIiLyRalki3xJ8S1b2PGdi0nV1NDz5l+Sf/75HzumdXu+9XM5reHb9NkwikAPLydfMpyCYj+vbdjL9U+vpaohyrTxfbj25CHk+pwtT86k4cWfwZI/QcXXQTuIiIiIdBodUrJXrVrF7bffzuzZs6msrOTmm2/Gbrfjcrm47bbbKCwsZO7cucyZMweHw8Fll13G5MmTicViXH311dTW1uL3+7ntttsoKCjoiMginykTibDzB5eTiUbp+8jDeEeM+NgxH2zPt2H3Jr675xfYd+YyYFwPjv3mIBqTaS5/bAX/XrWLAd0DzL3kSMaXfeTPdjwMT10M782DI/4PTrpFO4iIiIh0Iu1esu+//36eeeYZvF4vAL/61a+44YYbGDJkCHPmzOH+++/n4osvZvbs2Tz11FPE43GmT5/OxIkTeeyxx6ioqODyyy/nueee45577uH6669v78gin8k0TXZdfz2JLVsoffCBTyzYH2zPF6gr4rtbfk2m2cbR0ysYMrGYJ5bv5NfPVxJLZrjihAouPbb8wDs0Nu2CRy/QDiIiIiKd2Mfv7dzGSktLufvuu1s/nzVrFkOGDAEgnU7jdrtZvXo1o0aNwuVyEQwGKS0tZf369Sxfvpyjjz4agEmTJrF48eL2jivyuer//ndC816g6IqZ+I844oCvmabJX9b8he+99D2G75nEqWv/D6/Dy7lXj8EzOIdp9y/h2n+sYUhxDvNmHs2PThh4YMHevRruPx7q3m/ZQUQFW0REpFNq95nsKVOmsHPnztbPu3fvDsA777zDww8/zCOPPMKCBQsIBoOtx/j9fsLhMOFwuPVxv99PKBRq77gin6l5+XKqf3c7gROOp9vFFx/wtQ+253tz6yKm77mawPYS+g7vxlH/M4gH397OPa9vwudy8NtzR3D+2N4H7p+dTsLi/wev3wa+Au0gIiIi0slZcuHj888/z5/+9Cf+/Oc/U1BQQCAQIBKJtH49EokQDAYPeDwSiZCTk3NQ3z8ej1NZWdku2T9LLBaz5Lzy6dp0TOrr4aofQ1ER4QsvZP369a1f2ta8jTs23kGqwcb/bv4ltrCH8q8Faeyd4tQ/zmdnU5LJ5QG+N7Ybed7wAc/17ltNz2W34WncTFOvY6geczWpegfUd80/S/o9yT4ak+yjMck+GpPs0hnGo8NL9r/+9S8ef/xxZs+eTV5eHgAjRozgzjvvJB6Pk0gk2Lx5MxUVFYwePZo33niDESNGMH/+fMaMGXNQ53C73a1LUjpSZWWlJeeVT9dWY2Imk2z/34uIRqP0e+ghPIMqWr/2yrZXuGH5DQytPZIjNp2F2+ti4mUVPPjeHh5/aQd9Crz87aJRHFNRdOA3jdbDKz+H5Q9Bbh+YNoecQV/n4P4p2Xnp9yT7aEyyj8Yk+2hMsku2jMdnFf0OLdnpdJpf/epXFBcXc/nllwMwbtw4fvjDHzJjxgymT5+OaZpcccUVuN1upk2bxjXXXMO0adNwOp3ccccdHRlXpNXeWb+nedkySn732wMK9ktbX+La13/Kqbsvoue2IfQcmId5RDe++cwq6puTXHJMOTOPr8Dr+si6a9OENU/Ciz+F5jo48gdw7E+1PZ+IiEgX0iElu3fv3sydOxeAt99++xOPmTp1KlOnTj3gMa/Xyx/+8Id2zyfyWZpeeJG6v/6V/OnTyT399NbHX972Mte+/lPO2fJD8qv7MOCYEh5pbmT+v9dyeJ88/n7RcIaW/Ne8dO1meO4qeP816DUG/ucfUPzx3UlERESkc9PNaEQ+Q/z999l93XV4Dz+cHtde0/r4q9te5ZrXr+Ws7f9HfnUfbOMK+NG7W7AbBj8/fSgzjuyH3faRCxtTCVh0F7zxO3C4W7bmG3uR9r4WERHpolSyRT5FJhJh5+U/xPB46HXXnRj7b5f+6vZX+fHrV3PmjkvptquMHaUu5mys4sShPfjFGYdRkuc98BttWwT/ngn7NsDQs+Dk30BOcYe/HhEREek4Ktkin8A0TXbfcEPrDWecPXsC8J/t/+HHr/2Y03ZdTNHOAazJh1cjTdxy1jC+OaH0wG35muvg5RthxWzIK4XpT0DFSRa9IhEREelIKtkin6D+73+n6fl5FF15ZesNZ17f8TpXvX4Vp+y5kJ7bhrDcm2at32DOjCMZ0zf/wyebJqyaAy/9DGKNMHEmHHMNuHyWvBYRERHpeCrZIv+l9YYzxx9Pt++23HDmjR1vcMXrV3DS3m9SsmU4y10pQhV+nv2fMXQPej588r5N8NwVsGU+9B4Pp98JPQ6z5oWIiIiIZVSyRT4iVVND1cwrcPYqoeQ3t2IYBvN3zueK16/guJoLKN00mlWuFKXHl3DdqUNxOWz7nxiHN38PC+4AhxdO+z2MvhBsNktfj4iIiFhDJVtkPzOZpOqKK0mHQvT7y/3Yg0EW7FzAzNdmMnHfWZS/N5717jRTZgzh3LF9Pnzilvnw7BVQuwmGnQdTfg3BHta9EBEREbGcSrbIfq03nPntbXgGDeLNqjeZ+dpMxtScwuD3jmK7D753xTiG98lreUKkFl66HlY9Cvn9Wva8HnC8lS9BREREsoRKtggfveHMNHLPOIOFVQv50X9+xOC9x3P4xsnU59q5+roJFOZ6Wi5sXPlIS8GOh+HoH8OkH4PT+/knEhERkUOCSrYc8j644Yzn8BF0v/ZaFlUt4vL//JCy6qM5YtMUMkVurr7+CNxuR8tNZZ6d2VKyS4+E0+6E7oOtfgkiIiKSZVSy5ZDWesMZt5ved97Jkn3L+cF/LqdkzwSO2Xw6vmIf37p2PE63vWV5yNwZsG0hHPtTmPQTXdgoIiIin0glWw5ZB9xw5oG/sMzcymWv/IAee0dz0vvnkl/i54Krx7YU7Jr34NGp0LQLzn0Ahp9ndXwRERHJYirZcsiqnz275YYzV1zB8l4ml798OYX7RnDq+9MoLPZzzlWjcXkd8P7rMPdbYHfBhc9Bn3FWRxcREZEsp//XLYek5nfeofq3vyNw3HEsnlTBD/7zA/Jrh3L2lhl0K/Jx1sxRePxOWPZXmH0O5PSC7/5HBVtEREQOimay5ZCTqqmh6kczcZaU8NLUk7jzrSvp1jSYC7ZdRCDPzZkzR+EL2OGF6+CtP8KAE+G8B8GTY3V0ERER6SRUsuWQYqZSVF15FelQiH99exqzt/yCouYKpm27BLfPwZkzRxHwJWDOt+C9F2DCZXDSLWDXr4qIiIgcPDUHOaTsnfV7mpcu5anTzmSO/S/0SA5k2tb/w+6wcebMUeQ49sEDF0DNejj1Dhh3sdWRRUREpBNSyZZDRtOLL1H34IOsHDeeOYe9TB+zP1O3/IBMBs64aiR5yXfh79MgFYNvPqG7N4qIiMiXpgsf5ZAQf38Lu6+7jtjAQfzmqPfobpbyjfd/SCpmcsaPRtKt7iV46NSWuzZ+52UVbBEREflKVLKly8tEIuz84eXgdPHjrxXhssH/bJlJPJTm9B+MoGjLn+DJ/4WSUS07iOgOjiIiIvIVqWRLl1f929+ReH8Lc0+fSnXx25xXNZNEg8mplwym58qr4bVfwYhvwLf+Bf5Cq+OKiIhIF6A12dK1bdhAw9y5NJ16Lo/mvUHfyEACe4oYd0oRvRbPgB1L4Lgb4OirwDCsTisiIiJdhEq2dFlmKgX3/RlbYSEzu/lwBDZx9q7bcPgMhm/6FjTvhPP/BoedZXVUERER6WK0XES6rPpHH4MtW/j30ecRKnqe4emvkdrmYaTrcVyZEPzv8yrYIiIi0i40ky1dUrJ6LzV33UXdoOH8OX8zbmcDp2w9gZgRYnjv92DGfyC3t9UxRUREpIvSTLZ0SXtvu41MMslNg47CUzSfM+OjaNzdjVF9K3F99xkVbBEREWlXKtnS5UQWLaLp+edZNOFUdpUuxG3AqHXDcTuTDP/hFeAOWB1RREREujiVbOlSMokEe355M4keJfyuVz724Lt8d08+e+JjGHnKIFw+t9URRURE5BCgki1dSt0DD5DYupXfDj4VX98X6Y2H4l0n4/baGHGsloiIiIhIx1DJli4jsWMH++69j8pB41hRUU3SVs3M7U62x8cy8sR+uLy6zldEREQ6hkq2dAmmabLnlltIGTZ+PWAinqLXONaeT7L2rJZZ7MmaxRYREZGOo5ItXULo5ZeJvDGf2YOn4DlsKYaR4nvvRdkWG8vIE/tqFltEREQ6lEq2dHqZSITqX99KdVEfnh/Wi0b7Ei40g2wPfQOHG4ZP7mN1RBERETnEqGRLp1fzx3tI7dnDbYNPp/uAl+jpzues90JsjY6iz6gAbs1ii4iISAdTyZZOLfbee9T97W+8XHYEHBlhb3wLV4dTrIl+C7fXTp+RfqsjioiIyCFIJVs6LdM02fPzXxBxenls1PE0eP7NhGA5I7c0syUygsNPKMXh1h9xERER6XhqINJpNT79T6LvvMOfh5xCxRGriaYiXLt7O8uS38HtdWhHEREREbGMSrZ0SumGBnbf9lsqu/Wj6aShrKh/gWn5I8jdlWFL02GMOL4Pbp/T6pgiIiJyiFLJlk5pzx2zSDc18eC48zEL/0W+O4//e28Jy9KX4vI6OPw4zWKLiIiIdVSypdOJrlxJ45NP8s/yoxhzho1369ZwRXAo8ToP7zcM4vDjemsWW0RERCylki2diplKsfX6m6j15FB11nm8UfMQIwqGcsbq51hq/LBlFvt47YstIiIi1lLJlk5l3yOPwqb3eGTsORQftpy6WB3XGYXURbrx/r4yzWKLiIhIVlDJlk4jWb2XPb+/k6XdB3HExUfz9KbHOafvFA5bMZdl9itxeeyMOE6z2CIiImI93QpPOo33fn4LmUSSDVO/R3XjA3idXn5YV8++ZF827+3N2FP74PFrFltERESsp5ls6RTq5y/A9trL/Hv4SYw90WDJ7iVc3v98ClY/yTLHj3F57ByuWWwRERHJEirZkvUyiQSbfnYTVf5CxvzkUv605vdU5Fdw/sa3qDWGsnlXd0Ycp1lsERERyR4q2ZL11s36I4Ga3aw+97tstr3I7shuftr3DBwbX2Cp8yqcHrt2FBEREZGs0iEle9WqVcyYMQOAbdu2MW3aNKZPn85NN91EJpMBYO7cuZxzzjlMnTqV1157DYBYLMbll1/O9OnT+e53v0tdXV1HxJUsEt26jczsv/J239Gc/N2j+evav3JK2SmMXfYItc7RbN6ez+GaxRYREZEs0+4l+/777+f6668nHo8DcOuttzJz5kweffRRTNPk1VdfpaamhtmzZzNnzhweeOABZs2aRSKR4LHHHqOiooJHH32Us846i3vuuae940oWMU2TlT+5gZRho8dPr+XeNb/HbrNzZd7hsGMJSx1XahZbREREslK7l+zS0lLuvvvu1s/XrVvH+PHjAZg0aRKLFi1i9erVjBo1CpfLRTAYpLS0lPXr17N8+XKOPvro1mMXL17c3nEli+x5dh55q5cyf+LZ+Ac08NqO17hk+HfpseAuav0T2bzVz4jJvTWLLSIiIlmn3bfwmzJlCjt37mz93DRNDMMAwO/3EwqFCIfDBIPB1mP8fj/hcPiAxz849mDE43EqKyvb8FUcnFgsZsl5u6RolPAvb2Fvbgn9p5/MzQtvoNhdzPHb90HNeubb/4bdYeDr89k/c41J9tGYZB+NSfbRmGQfjUl26Qzj0eH7ZNtsH06eRyIRcnJyCAQCRCKRAx4PBoMHPP7BsQfD7XYzZMiQtg1+ECorKy05b1dUedMtBEL1LLrsKoLd1rF7627+dOxd9HvqB9QWTGFXZQ5jppQyYnT/z/4+GpOsozHJPhqT7KMxyT4ak+ySLePxWUW/w3cXGTp0KEuWLAFg/vz5jB07lhEjRrB8+XLi8TihUIjNmzdTUVHB6NGjeeONN1qPHTNmTEfHFQvENrxHZu5jvNr/SL7+zQncu+peju1zLEftXAtNVSzLXIbTZWfkCaVWRxURERH5RB0+k33NNddwww03MGvWLMrLy5kyZQp2u50ZM2Ywffp0TNPkiiuuwO12M23aNK655hqmTZuG0+nkjjvu6Oi40sHMTIbKn/yMuNNDwRVX8MC7d5POpPnJ8Mvgga9TV3I+m1aYjJ7SG09Aa7FFREQkO3VIye7duzdz584FoKysjIcffvhjx0ydOpWpU6ce8JjX6+UPf/hDR0SULLH30Tl4NqzlH5Mv5PTDYtz60vNcMuIS+qyaC7FGliX+F6crxcgTtKOIiIiIZK8On8kW+TTJ6mqqb7+DNUUD+fpVF/Lbpd+n2F/Md/qeAs8dSV3Zd9j4VpzRJ/XFG3BZHVdERETkU+mOj5I1tt74CzLJJGsvuIy9LGZD/QauHHMl3jfvhEyaZc1TcbjsjDxRs9giIiKS3VSyJSs0vfwyqTdeY87QKVz8jSO4+527GV44nCn+Mlgxm7rBP2Tj6ggjju2lWWwRERHJeirZYrl0KMSOm37B5twSSi7+Dq/ueoK90b1cNfYqjNduBqePZfWntsxia0cRERER6QRUssVy1bffAfV1PHr0DM77WjceXPsgk/tMZkwiA5X/pn7YT9i4spHhx/TCG9QstoiIiGQ/lWyxVPPy5TQ+/jhPlx/Nty6cwoPr7iOWinHF6Jnwyk3gL2JZ9bE4nDZGnahZbBEREekcVLLFMplEgp0/u4G9/gI2njqdit5RnnzvSc6rOI+yvZtg20LqR17PxndqGX5sb81ii4iISKehki2Wqb3vz6S3buH/jTyX684ZzV3v3IXH4eGy4ZfAKz+H/H4s2z4Gu2axRUREpJNRyRZLxDdtoua++3itz2gOO3MKYeM9/rPjP1w07CK6bXoV9q6jYfRNbFxWw/BjNIstIiIinYtuRiMdzsxk2H3DjTQ7PMwZdy7PHD+Q77/+v3T3dWfGkP+B+0+AHsNYunEQdmcNIzWLLSIiIp2MZrKlwzU8/jjRFSv409DTuOTMMbxV8x9W71vND0b+AG/1u7B3HbtL/4/33q5mxOQ++HI0iy0iIiKdi0q2dKgPbp2+rngwu8dP5pzRPblr+V0MzB/IGf3PgOUPkXEEeWN5OYF8N2O+3tfqyCIiIiJfmEq2dKg9N99MKpHk9mFn84uzhvHkxrnsDO/kqjFXYU9EYO1TrAlcRe2uKEdPrcDl0YomERER6XxUsqXDNL30EuFXXmX24JMY/7XhDCpxcN/q+ziy+Egm9poIa58kHPOw5P3DKT2sG2UjC62OLCIiIvKlaJpQOkS6qYnqm29hb4++PFtxLK+cMpi/rP4TTfEmrhp7VctByx9iYXImmYyNSd8YiGEY1oYWERER+ZI0ky0dYu8ds0jW1nLzkLO57PgKMvY6Hq58mNP7n86ggkGwawU7tppsahjOmK/3JbfIZ3VkERERkS9NJVvaXfOyZTQ8/jivDTuOePlALj66nD+88wdsho3LR10OQPrt2cwPXUJuoZtRJ2nLPhEREencVLKlXWUSCXbfeBOxwh78oXQy1586lM2N63l+y/PMGDqDnv6eEA+zYnGUhlQJk6YPxuG0Wx1bRERE5CtRyZZ2VXvvfSTef587Djub8UN6ceKQ7tyx/A7y3flcNOwiAJoW/4tljWfQf7Cd0qHdLE4sIiIi8tWpZEu7iW/cyL7772fzyKN5q9tAbjp9KAuqFrB0z1IuPfxSgq4gAAvmhTBscNS3xlucWERERKRtqGRLuzAzGXbfeBOm18fPSo7nW0f2o1+hl1nLZ9E3py/nDzofgC2vL2NrYwXjRzcSKPBanFpERESkbahkS7uonzOH6IoVPHXEeTjyC/jRCQN5etPTvN/4PleMvgKnzUkynmbBv/ZQ4NjOiAtOtDqyiIiISJtRyZY2l9yzh5o7ZhEZPoYHvIO5esognI4kf1zxR0Z1H8VxpccBsOzZjYSiPo4ZuQF7UGuxRUREpOtQyZY2ZZome26+BTOd5hcDTmd47zzOH9uHh9Y9RG2slqvGXoVhGNTtjrDy1SoGe1+l5IRTrY4tIiIi0qZUsqVNhV56mfCrr/LulG+wxgzw8zOGUhfbx0PrHuKkvidxeNHhmKbJ/DkbcBoxvla6APpOtDq2iIiISJtSyZY2k25qYs8tN2MbNJjr7Idx9qhejOlbwB9X/pFkJsnM0TMB2LismqoNDRzh/xve8eeBbp8uIiIiXYxKtrSZvbffQbquntkTv4nN4eDarw9mU/0mnt70NN8Y9A365PQhHk2x8IlNdM9rZKj/NRg53erYIiIiIm1OJVvaRPPSpTTMnUvzGefzcJ2XHxw3gB45HmYtn4Xf4eeSEZcA8PYz79McSnCM705sQ08Ff6HFyUVERETankq2fGWZeJzdN96Eo3dvrs//Gn27+fjOUWUs2b2EBVULuHjExeR58qjZHmLN6zsZfliM7pmVMOZCq6OLiIiItAuVbPnKau+7j8SWLaw6/1Iq6xLccOpQnHaDO5bdQbG/mG8O+SZmxuSNxzbgCTiZ4P4L5PeDfpOsji4iIiLSLlSy5StJNzRQ+5cHCJx6KrfuzeHogYUcP6Q7z73/HJV1lVw+6nLcdjeVi3ZTvaWJiSfl4K56FUZ/G2z64yciIiJdk1qOfCWNzzyDmUjw3uSzqI0kuOioMhKZBHevuJshBUM4tfxUouEEi57eRMnAPCoyT4DNASO/aXV0ERERkXajki1fmmma1M+di2fECB7Z56ZnjodJA4t4pPIRdkd2c9XYq7AZNhY/vZlkNM2kqWUYqx6FQV+HYA+r44uIiIi0G5Vs+dKiK1aS2LQZ22ln8vqGvZw3pjehRCN/Wf0Xju51NBOKJ7B7cyOVC3dz+Al96Nb4GjTXwugLrY4uIiIi0q5UsuVLa3jiCWw+H/OKhpMx4bwxvblv9X1EUhGuHHMlmXSGNx7dQCDfzdhT+sHyhyC3FPpPtjq6iIiISLtSyZYvJR0K0TRvHjmnncqctfuYUFaA3VXHnA1zOHvA2QzIH8Ca16uorQpz9NQKXM3bYcsbMPpbYLNbHV9ERESkXalky5fS9OyzmLEYO782ha21zVwwrg93vnMnTpuT74/8PpGGOEv+/T6lh3WjbGQhvPN3MGwwShc8ioiISNenki1fWMsFj0/gHjKEOY1+Am4HvXvW8NK2l7jwsAsp8hWx8MmNZFImk74xECOTghWPQMXJkFNidXwRERGRdqeSLV9YbO064pWVeM86m+fX7uG0EcX8v1W/p9BbyIWHXciOyjo2LtvLmK/3JbfIBxvmQWRvy97YIiIiIocAlWz5whqeeALD42F+37FEk2kGlG1lxd4V/N/I/8ONh/lz3iO3yMuok0pbnvDO3yCnFww4wdrgIiIiIh1EJVu+kEwkQtOzz5Lz9a8z5906Bvbw8c9tf6Y8t5yzB5zNile201DdzKRpFTicdqjfBptehVH/A3aH1fFFREREOoRKtnwhTfPmkWluJnzCqazY3sDEw5rY1rSN7434Hs11SZY9v5X+o7tTOrRbyxNWPNzyftQM60KLiIiIdDCVbPlC6uc+gWtAf56I5uGwGSQ87+B1eJncZzIL5m7EsBkcdf6AloPTKVgxu2WZSF4fa4OLiIiIdCCVbDlosQ0biK1eTc655/GPFbs4bnA3Fuz6D8f2OZbqdyNsXb2P8aeVEcj3tDxh08sQ2g1jLrQ0t4iIiEhHU8mWg9Yw9wkMp5MVg4+kNpJgRMVeGuINnNz76yx4fCMFJX5GHNf7wycsfwgCPaBiimWZRURERKygki0HJROL0fjvfxM86SQe39BEjxw3OxMLCbqCuFf1JlQX45jpg7Db9/+RaqyCjS/tv+DRaW14ERERkQ52UNs97N27l6amJux2O/fffz8zZsxgyJAhX/qkyWSSa6+9lqqqKmw2GzfffDMOh4Nrr70WwzAYOHAgN910Ezabjblz5zJnzhwcDgeXXXYZkydP/tLnlS8v9OKLZJqaME87i9de2svFk3rzrx2v8fWS01jzVBWDJvSkZEDeh09Y8TCYmZbbqIuIiIgcYg5qJvuaa65h3759/P73v2fixIn8+te//konfeONN0ilUsyZM4fvf//73Hnnndx6663MnDmTRx99FNM0efXVV6mpqWH27NnMmTOHBx54gFmzZpFIJL7SueXLqX/iCVx9+/IMPciY0Lf3dppTzYyJTCadyhy4TCSTbrmNevlkyO9nWWYRERERqxxUyU6lUowbN46mpiZOPfVUMpnMVzppWVkZ6XSaTCZDOBzG4XCwbt06xo8fD8CkSZNYtGgRq1evZtSoUbhcLoLBIKWlpaxfv/4rnVu+uPjmzUSXLSf3vPN4YnkV48sKWLbvPxR6C0lUesgv9lNUGvzwCZv/A007dcGjiIiIHLIOarlIMpnk1ltvZezYsbz11luk0+mvdFKfz0dVVRVf//rXqa+v595772Xp0qUYhgGA3+8nFAoRDocJBj8sb36/n3A4/LnfPx6PU1lZ+ZUyfhmxWMyS87a7v/4V7Hbm9+jPls0RTquAR3a8wcn+09mzuYn+E4MH/OOn95t343Xns9EsB4t/Hl12TDoxjUn20ZhkH41J9tGYZJfOMB4HVbJ/85vfsHDhQs4//3xeffVVfve7332lkz700EMcddRRXHXVVezevZtvf/vbJJPJ1q9HIhFycnIIBAJEIpEDHv9o6f40brf7K60Z/7IqKystOW97yiQSbJq/AN/xx7MoXkDAnaC0oo7kkiRHJE9mhxHlqNOGf7htX2gP7HoTvvYDhgwbYW14uuaYdHYak+yjMck+GpPsozHJLtkyHp9V9A9quYjP52PChAlUVVWxYMGCg5pN/iw5OTmtZTk3N5dUKsXQoUNZsmQJAPPnz2fs2LGMGDGC5cuXE4/HCYVCbN68mYqKiq90bvliwq+8QrqhAc/Z5/Lc6t2cfngxr+58iV7+XjSsMek9KP/Dgg37L3hMw+hvWxdaRERExGKWXPh44YUXsm7dOqZPn863v/1trrjiCm688UbuvvtuLrjgApLJJFOmTKGoqIgZM2YccJzb7f5K55Yvpv6JJ3D26sUr3lKiyTQnjwjy1q63+LrnHEK1MQYfWfzhwZlMywWP/Y6Gbv2tCy0iIiJisYNaLvLBhY/33nsvp556Ko8++uhXOqnf7+euu+762OMPP/zwxx6bOnUqU6dO/Urnky8nsX07zYvfouhHP2TuO1UM7B5gd2oJaTNN6Z4R7HXHKR9Z9OETtrwODdvg+BstyywiIiKSDQ5qJrutL3yUzqHhiSfBZqN+0km8s72BqWP7MG/LPAYGKti3Ns6AUUU43fYPn7D8b+AtgMGnWRdaREREJAscVMn+zW9+Q3l5OVOnTqW+vv4rX/go2c9MJml4+mkCxxzDE9sSOGwGEwfbeWfvO5xonkMilmbQET0/fEK4BtY/B4dPA6fn07+xiIiIyCHgoEr23r17efTRR/n2t7/Ne++9x1tvvdXeucRioddfJ71vH8HzzuMf7+zk+CHdWVrzOgCFO/oTyHfTqyL/wyesehQySRijCx5FREREDqpk33XXXTz88MMUFhZy6aWX8thjj7V3LrFYwxNP4OjRgyVFg9gXTjB1bB+e3/I8I/1jqXmvmUETemLYWvY1xzRbloqUHglFg6wNLiIiIpIFDqpk22w28vLyMAwDt9uN3+9v71xioWRVFZEFb5J37jk8sWIX3YNu+vVs5t3ad5kUOw3T5MClIlvfhLrNusOjiIiIyH4HVbJLS0u54447aGho4M9//jMlJSXtnUss1PDUPwBITTmN1zbUcO6Y3ry0/QUMDLybe9K9Xw75PT/yD63lD4EnF4aeaU1gERERkSxzUCX7F7/4BSUlJYwZMwav18vNN9/c3rnEImY6TcM//oF/4kT+udsknTE5f0xv5m2Zx1GeE2jcHWfwARc87oV3/7X/gkevdcFFREREsshB7ZO9bNkypk2b1t5ZJAuEFywgtWcPPX76U55YtoPx/QpI2qvY0riFs+KXELcbDBzb48MnLH+o5YLHcd+1LLOIiIhItjmomey77767vXNIlmh44knshYVs6D+S9/dFOH9sb57f8jxOXJgbg/QbXogn4Gw5OJ2EpQ9A/+OhcIC1wUVERESyyEHNZBuGwfe//33Kysqw2Vp6+ZVXXtmuwaTjJav3En79dbpd9L/cv2I3fpedU4b35Jx/v8DxtjOIhVIHXvD47r8gvAfO+IN1oUVERESy0EGV7HPPPRfDMNo7i1is8el/QDqN84yzeW72e5xxeAkbG9exK7KLb9QfSdrvoO+wbh8+4e0/Q34ZDDjRutAiIiIiWeigSvasWbOoq6sjPz+f+vp63G4399xzDzfddBMTJ05s74zSAcxMhoYnn8I3YQIvNThoTqQ5f2wf5m25l6CZS2yTk8Mm9sDu2L/CaNdK2LEEptwKtoNadSQiIiJyyDiodjRu3Dj+/e9/8+abbzJv3jxOOOEE7r//fu666672zicdJLJ4McmdO8k7/3zmLtvJgO4BRvQO8OLWFzkxfS6ZlMmgI4s/fMLbfwanH0Z907rQIiIiIlnqoEr2nj17KC8vB1r2zN69ezd9+/bFbre3azjpOA1PPIk9L4+9h09g+bZ6po7tzbLqZdTGaum7ZwT5PX107xtsOTiyD9Y8CYd/o2V/bBERERE5wEEtFykqKuL2229n1KhRrFixgsLCQhYuXIjT6WzvfNIBUrW1hF59lYLp03lwTQ0Om8HZo3pz9+q/0SPVm+gOg8PP6vnhuvzlD0E6DuO/Z2luERERkWx1UDPZv/3tb+nevTvz58+nuLiY3/zmN/h8PmbNmtXe+aQDNP7zn5BMEjj3XJ56ZyfHDe5Ors/glW2vcHz8XDCgYvz+XUXSKVj2IJQfC90HWxlbREREJGsd1Ey22+3mjDPOYPv27fTu3Ru3282oUaPaO5t0ANM0aXjiSbyjR7MwGWRfOMHUsX1YWLWQUCJE4fZyug/KJ1jgaXnC+mehqQpOud3a4CIiIiJZ7KBmsp9//nkuuOAC7r33Xi644AL+9a9/tXcu6SDNS5eS2Lq19YLHoqCbYwcVMW/LPAbEh5No4MC9sd/+M+SVQsUUyzKLiIiIZLuDmsn+29/+xj/+8Q/8fj/hcJhvf/vbnHnmme2dTTpAwxNPYgsGiU88htfuXMx3jy4nkYnx+s7XuSAyE4fLRvnIopaD96yBbQvhxJvBpoteRURERD7NQc1kG4aB3+8HIBAI4Ha72zWUdIx0QwOhF18k9/TTebqyjnTG5PyxvXl9x+skEkn823rSf1R3XJ79/xZbch84vDDqfyzNLSIiIpLtDmomu7S0lN/85jeMHTuWZcuWUVpa2t65pAM0PvMMZiJB7vnnMfe5HYzrl0//ogB3rp7HiMhE0vGPLBVproM1T7Rs2+crsDa4iIiISJY7qJnsM844gz59+rBo0SL69OnDzTff3N65pJ21XPD4BJ7hw1nn7cH7+yKcP7YPjfFG3tz1JmMbjyOQ76bXoPyWJ7zzd0jFtG2fiIiIyEE4qJnsP/3pTzzyyCPtnUU6UHTlSuIbN9Hzl7/gT8t24HfZOXV4MS9ufwZnzIu9Ko+KE3tisxmQScPSB6Df0dDjMKuji4iIiGS9gyrZhmHw/e9/n7KyMmy2lsnvK6+8sl2DSftqeOJJbD4f9hOm8Oydizl9RAl+t4PntzzPuPDxkIFBE/YvFdkwDxq3w5RfWRtaREREpJM4qJJ97rnntncO6UDpUIimefPIPe00XtjcRHMizdRxvdkX3cfSPUv57r5f071vkIKSlotdWXIv5PaBQadYG1xERESkkziokn322WeTyWSoq6ujW7duH95eWzqlpmefxYxGyZt6PnPf3EH/Ij+jS/N5dP2j5IV7YtR6GXTC/lns6ndh6wI44edgP6g/LiIiIiKHvIO68PHll1/mhBNO4OKLL+akk05i4cKF7Z1L2lH9E0/gHjyYnd37sWxbPVPH9sEwDOZtmceE0EnYbAYDx/VoOfjtP4PDA6O/bW1oERERkU7koKYm//jHP/LEE0/QrVs39u3bx6WXXsrEiRPbO5u0g9iGDcTfraTHDddz3zs7sdsMzh7di6pwFav3ruHI6m/Rd3g3vAEXROth9eMw/Dxt2yciIiLyBRzUTHZeXh7dunUDoLCwkEAg0K6hpP1EFiwAwHvc8Ty1vIrjBnene9DDvC3z6NVYAc2OD/fGXvEIJJth/CUWJhYRERHpfA5qJjsQCPCd73yHcePGsW7dOmKxGLNmzQK0y0hnE1m0CPfAAbxZb7AvHGfq2D4AzNsyjyOaTsbtc9BvWGHLtn1v/xlKvwbFIyxOLSIiItK5HFTJPv744wHIZDIcd9xx7RpI2k8mFqN52XLyp01j7rIdFAXdTB5UxOaGzWyp2cZxe8oZOLEHdqetZdu+hm1w4i+sji0iIiLS6Rz07iIA3/rWt/j73//eroGk/TQvW46ZSJAcNZb/zN/LxUeX4bDbmLdlHgPqRkHaYNCR+5eKLLkPgiUw+DRrQ4uIiIh0Qge1JvsDpmm2Vw7pAJFFizCcTubZiklnTM4f0wfTNJm3ZR6jG48jr4ePHv1yoGYDvP8ajLsI7E6rY4uIiIh0Ol+oZI8ZM6a9ckgHiCxciHf0aOasqWFs33wGdA/wbu271NeECe7rwaAJPVv2QH/7z2B3wegLrY4sIiIi0il9bsm+4IILWj+eOXMm4XCYd999t11DSdtL1dQQ37CB2OFj2VwT4axRvQB4fsvzDKodD0DFhB4Qa4SVj8Gw8yBQZGVkERERkU7rc0t2IpEA4NZbbwVadhr5xS90MVxnE1m8GIB3ug8EYPLg7mTMDC9seYERdUfTa1AeOd28sPJRSEZgwvesjCsiIiLSqX1uyTZNk9raWp555pnWNdmxWKzdg0nbiixchD0vj+djOQzsHqBXnpd3qt/B2OvDFQ4waEIxZDItS0V6j4eSUVZHFhEREem0Pnd3kSuvvJLp06dz2mmn8etf/5p+/fqRyWQ6Ipu0EdM0W/bHPuIIlmxtYMYRfYGWvbGH7jsSu9NG/9FFsPlVqHsfJv/M4sQiIiIindvnluxJkyYxadIkAFasWMELL7zAr371q3YPJm0nvnEjqZoaageMILEzwzEVRSQzSV7Z8irn1v6U/qOKcHkcsOReCPSAIWdYHVlERESkUzuofbI/MGrUKEaN0jKCziayaBEAC3LK8DijjC8rYMnuxeTt6Y096Wy5jfq+TbDpFTj2OnC4LE4sIiIi0rl9oS38pHOKLFyEq6yMeTUwoawbHqe9ZalI7ZH4cl30HlwAS+8HmxPGXGh1XBEREZFOTyW7i8skEjQvXYo5Zjzv10Q4pqKIWCrGwk1v0atuEIMm9MSWDMOKR+CwsyHYw+rIIiIiIp2eSnYXF33nHcxYjMpeQwA4ZlARC6oWULxnMIZpY9CEnrBqDiRCMOESi9OKiIiIdA0q2V1cZOEicDh4wVFC73wv5YX+1qUihX0CdCv2wZL7oGQ09B5rdVwRERGRLkElu4uLLFqE5/DDeWNnM5MqiogkI6zesIGCUAmDjyiG91+D2o0w4VKro4qIiIh0GSrZXViqvp7Yu+/SMGQU4XiKYyqKmL9zPv2qD8ewwcBxPVpuPuMvgsPOsjquiIiISJfxhbbwa0v33Xcf//nPf0gmk0ybNo3x48dz7bXXYhgGAwcO5KabbsJmszF37lzmzJmDw+HgsssuY/LkyVZF7nSaFy8G02Rp4UAczQZf69+NXyz+D4P3HUXpYd3wpargvRdh0tXgcFsdV0RERKTLsGQme8mSJaxYsYLHHnuM2bNns2fPHm699VZmzpzJo48+immavPrqq9TU1DB79mzmzJnDAw88wKxZs0gkElZE7pTCCxdiy8nhmVguo/vm43Jm2PhuFd5ETstSkaV/AZsdxl5kdVQRERGRLsWSkv3mm29SUVHB97//fS699FKOPfZY1q1bx/jx44GWu0wuWrSI1atXM2rUKFwuF8FgkNLSUtavX29F5E6n5Vbqi3GMGcfaPWGOqShiye4llOwdhOGAvgPd8M7slrs75hRbHVdERESkS7FkuUh9fT27du3i3nvvZefOnVx22WWYpolhGAD4/X5CoRDhcJhgMNj6PL/fTzgc/tzvH4/HqaysbLf8nyYWi1ly3k+0cyfs3s36r02BNJQ6wzy16inK64+loK+LfW/8P4rjjWzteTLRbMncDrJqTATQmGQjjUn20ZhkH41JdukM42FJyc7Ly6O8vByXy0V5eTlut5s9e/a0fj0SiZCTk0MgECASiRzw+EdL96dxu90MGTKkXbJ/lsrKSkvO+0nqli2nGlje63AK6xycfMQwHnywhopELqMm9ad42Y+h+HD6HTUV9v/jpivKpjGRFhqT7KMxyT4ak+yjMcku2TIen1X0LVkuMmbMGBYsWIBpmlRXVxONRjnyyCNZsmQJAPPnz2fs2LGMGDGC5cuXE4/HCYVCbN68mYqKCisidzqRRYtw9unDc/tsTBpYyNq6NRTuKQObSb/gBqiphPGXdOmCLSIiImIVS2ayJ0+ezNKlSznvvPMwTZMbb7yR3r17c8MNNzBr1izKy8uZMmUKdrudGTNmMH36dEzT5IorrsDt1i4Yn8dMJmlesoTkcVOob05yzKAiXt36GOV1h9NrUB7u1bPA1w2GnWt1VBEREZEuybIt/H7yk5987LGHH374Y49NnTqVqVOndkSkLiO6ahWZ5mbWFg/C2AcT+3fj0X+sZlJsNAOHeGDx8zBxJjg9VkcVERER6ZIsK9nSfsILF4LNxrP2Xgzv5aEutR3fjh6ASZl9PpgZGPU/VscUERER6bJ0x8cuKLJoEc7DhrF4b4JjKor4z/b/UFZ7OEX9A/jefwKKD4du/a2OKSIiItJlqWR3MenGRmJr1lIzaCTpjMkxFUUsfnc53aIlDBrigarlcNg5VscUERER6dJUsruYyFtLIJNhcX5/gh4H3fObyWzxA1DuXNBy0GFnW5hQREREpOvTmuwuJrJoETa/n3/E8jhqQDcW7HqDsroR5PZxE9wyB3qNhfy+VscUERER6dI0k93FRBYuJDNyDDtDSY6pKGLB+rfoEe7HkMEe2LMGhmmpiIiIiEh7U8nuQhLbt5PcuZPNpUMBGNnPSeg9E4D+rjdbDhp6lkXpRERERA4dWi7ShUQWLgTgZV8/BgYDbGh6m761w/F1t5O3/TEoPRJye1mcUkRERKTr00x2FxJZtAh7cTHzGpwcU1HE6+8toKSpP0OHeFpuo647PIqIiIh0CJXsLsJMpYi8tYTQsNEk0iZHDghS/W4zBjbKXYvAsMHQM62OKSIiInJIUMnuIqJr1pAJhVjZfRAep42kaz199g3FlWdQWPUw9DsKAt2tjikiIiJySFDJ7iIiixaBYfBPo5gjyrvx5tYF9GqsYPBgJ0bdJt2ARkRERKQDqWR3EZGFi7ANGsKasMHRAwt4f3UNdtPBQM8SMOww5AyrI4qIiIgcMlSyu4B0OEx01SqqBgwHoFthFT33DsQRMOmx+29Qfiz4u1kbUkREROQQopLdBTQvWQLpNAty+9M730tl7VuUNgxlQIUDo3GbbkAjIiIi0sFUsruAyMJFGF4v/4jlM2lgIZWrtuHMuKjwLgWbEwafZnVEERERkUOKSnYXEFm0iMSwkTSmDfr3biBvVymGJ0PJ3odgwAngzbM6ooiIiMghRSW7k0tWVZHYupUNvYbgsBk0ZFbSr34YZf3BHtqhpSIiIiIiFlDJ7uTCixYB8Ly7lDF983l37WbcaR+D/SvA4YFBX7c4oYiIiMihRyW7k4ssXIRRVMRrMT8jy1N4theCM0OffX+FgSeCO2h1RBEREZFDjkp2J2am0zQvXkz94JFgGBjetfSrH0GvfikczVW6AY2IiIiIRVSyO7HYu5WkGxtZVlRBYcDN9i2b8SWDHBZYDU4/VEyxOqKIiIjIIUkluxOLLFwIwJMUM2Ggg/T7PrBn6Fv/Vxh0Mrj8FicUEREROTSpZHdikUWLyJQPZFvGQ363TZTVjqCwdxxXbJeWioiIiIhYSCW7k8pEIjSvWMH28mEYBjTu20wwUcCI4Fpw57Tsjy0iIiIillDJ7qSaly2DZJLXAmUM6+UitsnANEzKGh+CQaeA02N1RBEREZFDlkp2JxVeuBDcbp7JFNGv90767htOXnEznuQu3YBGRERExGIq2Z1UZNEiooOGEbM5MeObyY/1YHjOu+DJg/LJVscTEREROaSpZHdCyepqEps2s7Z4MEEPxN9PAzCgaTYMOR0cLosTioiIiBzaVLI7ocjCllup/9vZh8P676XXvsH4isL4Mzu0VEREREQkC6hkd0KRRYsgv4Bl9gKCzq0URfowLLcSfIXQb5LV8UREREQOeSrZnYyZyRBZtIi9FSMwDWBHHICKyCMw9AywO6wNKCIiIiIq2Z1NfMMG0nV1vJU/gH699tFj7wBc+SFyzW26AY2IiIhIllDJ7mQii1rWYz9t60WvvO30DPVjaO56CPSAvl+zOJ2IiIiIgEp2pxNZuJBkaRl7XAG8NVEMbAxufhyGngU2u9XxRERERASV7E4lE4vRvGw575cOxePbR1F1X+yBCAXGZhh2rtXxRERERGQ/lexOpHnZcsxEgpf9/RhYvIOSxgEMzKvEyO0NvcdZHU9ERERE9lPJ7kQiixaB08krzhKKIs3YsDMs9hQcdhbYNJQiIiIi2ULNrBOJLFxI04ChJDxRCqp7greZ7vb1ugGNiIiISJZRye4kUvv2Ed+wgVXdKygufJ8+DYPpl1eJUdAPSkZbHU9EREREPkIlu5OILF4MwLPO3pTTjMN0Mir+TzjsbDAMa8OJiIiIyAFUsjuJyJsLyeTksjaYS1FNN0xXjJ7Od3UDGhEREZEspJLdCZimSWTRInaXD8MT3ERp/VCK8yqxFfaHnsOtjiciIiIi/0UluxOIb9xIqqaGN/P6c5g7givjYUzy2ZYLHrVURERERCTrqGR3Ah/cSv05dzHFjbmYjgR9XKu1VEREREQkS6lkdwKRhYuIF/ehvrCGvnVDKchdj71HBXQfbHU0EREREfkElpbs2tpajjnmGDZv3sy2bduYNm0a06dP56abbiKTyQAwd+5czjnnHKZOncprr71mZVxLZBIJmpcuZUPvIVS46/Gk/IxNz9MstoiIiEgWs6xkJ5NJbrzxRjweDwC33norM2fO5NFHH8U0TV599VVqamqYPXs2c+bM4YEHHmDWrFkkEgmrIlsi+s4KzFiMl7y9KYsEyNiSlLnf0Q1oRERERLKYZSX7tttu4xvf+Abdu3cHYN26dYwfPx6ASZMmsWjRIlavXs2oUaNwuVwEg0FKS0tZv369VZEt0bxsGaZhsKS7jb51gwnmvIezZAh06291NBERERH5FJaU7H/84x8UFBRw9NFHtz5mmibG/p0y/H4/oVCIcDhMMBhsPcbv9xMOhzs8r5Wia1YT6dmHbr5a/Mk8xvCyloqIiIiIZDmHFSd96qmnMAyDxYsXU1lZyTXXXENdXV3r1yORCDk5OQQCASKRyAGPf7R0f5p4PE5lZWW7ZP8ssVisbc9rmrBiJe/2HMKghJeMkabCtZRNnh+RtOD1dUZtPibylWlMso/GJPtoTLKPxiS7dIbxsKRkP/LII60fz5gxg5///Of87ne/Y8mSJUyYMIH58+dzxBFHMGLECO68807i8TiJRILNmzdTUVHxud/f7XYzZMiQ9nwJn6iysrJNz5vYWcXmpiaWDQzQr34Q3uAm3H2GMmDs8W12jq6urcdEvjqNSfbRmGQfjUn20Zhkl2wZj88q+paU7E9yzTXXcMMNNzBr1izKy8uZMmUKdrudGTNmMH36dEzT5IorrsDtdlsdtcPE1q4BYG+xi8HhQkZ4ntAFjyIiIiKdgOUle/bs2a0fP/zwwx/7+tSpU5k6dWpHRsoa0dVrSNsd+P15mGGTYa4lMPROq2OJiIiIyOfQzWiyWGzNGnYVFdOvqRx74H18ZUMht5fVsURERETkc6hkZykznSa6di1ri7rTLVrCUPt8GHau1bFERERE5CCoZGep+ObNmNEotYV9ARjlWgJDz7Q4lYiIiIgcDMvXZMsni61ZC0DGV0QqWUfOgEEQ6G5xKhERERE5GJrJzlLRNauJuz3kJfvgdW/QDWhEREREOhGV7CwVW7OWjT37Ekjk089RCYNPtTqSiIiIiBwklewslInHiW3YwPvdW9ZjD89v0lIRERERkU5EJTsLxdevh1SKSF4P0rY4PSr6WR1JRERERL4AXfiYhaKrW+706LSXYHNuxtbvSIsTiYiIiMgXoZnsLBRbu4aGYB55sV70cG6AvirZIiIiIp2JSnYWiq5ew/qSCmzYGebfDXl9rY4kIiIiIl+ASnaWSYdCJLZsobqwNwBlAwvBMCxOJSIiIiJfhNZkZ5nY2pab0KT8xaSMKjz9x1icSERERES+KM1kZ5nomrWYGPjSfcl1vwelWo8tIiIi0tmoZGeZ2JrV7OhehjvtZ4B7C3QfanUkEREREfmCVLKzTPPqNbxf3B+AoX28YNMQiYiIiHQ2anBZJLl3L+nqaprye5Gyh8gfollsERERkc5IJTuLfHDRo+Eoxe3ZiNH3axYnEhEREZEvQyU7i0RXrybmDOBP9aCXexOUjLI6koiIiIh8CSrZWSS2Zi3v9x4CwPAeGXC4LE4kIiIiIl+GSnaWME2T5jVr2F1USoY0vYb0szqSiIiIiHxJKtlZIrl9O2ZTE1F/KXi24SyfYHUkEREREfmSVLKzRHT1GjKGDTeldHNvgD7jrY4kIiIiIl+SSnaWiK1dQ31uX+ymiyH5TeAOWh1JRERERL4klews0bxqNVuKBwIwcFCxxWlERERE5KtQyc4CZjJJtLKS+oJSUs5aAoNGWx1JRERERL4ClewsEN+0CeJxMq5++N3vQekRVkcSERERka9AJTsLRNesIe7Ox2nm0y+4GwLdrY4kIiIiIl+BSnYWiK1ZQ3W3AQAM75drcRoRERER+apUsrNAeNUaqnqUk7HFKRp+mNVxREREROQrUsm2WCYaJblpI+FgP2yezdj6HWl1JBERERH5ilSyLRarrCRtOLHbetHTuw3y+1kdSURERES+IpVsi0VXryYULMXAzvDeDjAMqyOJiIiIyFekkm2x6Jq17C5queixdNgAi9OIiIiISFtQybZYaOVKarqVkXZX4Rk4weo4IiIiItIGVLItlG5owKzaRdLTj1zPZug+1OpIIiIiItIGVLItFF2zlmZfd2z4Gdg9ATYNh4iIiEhXoFZnodjaNTTm9gdgyOBeFqcRERERkbaikm2h8MrV7CoqJ20PkTdsjNVxRERERKSNqGRbxDRNwqtW0pRThsuzCaPXKKsjiYiIiEgbUcm2SGrPHtKRJDh60ju/HhxuqyOJiIiISBtRybZIdPUamnLKABjRv5vFaURERESkLalkWyS2dg31ueWYpCkZOdzqOCIiIiLShlSyLVK//B32FpZjerbiKBtvdRwRERERaUMq2RYwMxlilZXEvH0pCOwGT47VkURERESkDalkWyCxZQsxRxGG4eKwUo/VcURERESkjalkWyC6Zg2NOeUADBg52OI0IiIiItLWHFacNJlMct1111FVVUUikeCyyy5jwIABXHvttRiGwcCBA7npppuw2WzMnTuXOXPm4HA4uOyyy5g8ebIVkdtUZNUq6vL7k3buIzD0WKvjiIiIiEgbs6RkP/PMM+Tl5fG73/2O+vp6zj77bAYPHszMmTOZMGECN954I6+++iojR45k9uzZPPXUU8TjcaZPn87EiRNxuVxWxG4ze5cvpb77RXh9myHQ3eo4IiIiItLGLCnZJ598MlOmTGn93G63s27dOsaPb9llY9KkSSxcuBCbzcaoUaNwuVy4XC5KS0tZv349I0aMsCJ2mzATCdI7G8mU5NG3e8rqOCIiIiLSDiwp2X6/H4BwOMwPf/hDZs6cyW233YZhGK1fD4VChMNhgsHgAc8Lh8Of+/3j8TiVlZXtE/4zxGKxzz/vpk2EA30BKOkZtCTnoeSgxkQ6lMYk+2hMso/GJPtoTLJLZxgPS0o2wO7du/n+97/P9OnTOf300/nd737X+rVIJEJOTg6BQIBIJHLA4x8t3Z/G7XYzZMiQdsn9WSorKz/3vHUrVvBeTjkZI8bQk07BVlTeQekOTQczJtKxNCbZR2OSfTQm2Udjkl2yZTw+q+hbsrvIvn37uOiii7j66qs577zzABg6dChLliwBYP78+YwdO5YRI0awfPly4vE4oVCIzZs3U1FRYUXkNrNv+VLq8suxebdiKyyzOo6IiIiItANLZrLvvfdempqauOeee7jnnnsA+NnPfsYtt9zCrFmzKC8vZ8qUKdjtdmbMmMH06dMxTZMrrrgCt9ttReQ2U7dyDc0DTqFb3jLYvzxGRERERLoWS0r29ddfz/XXX/+xxx9++OGPPTZ16lSmTp3aEbHaXTocId3sA8POiIqeVscRERERkXaim9F0oNi6dTQFW9Zgl08YbXEaEREREWkvKtkdKLxqJY255WScu/D0HWZ1HBERERFpJyrZHWj7kgXU55bjzdkDNrvVcURERESknahkd6Do5loyDh/lvX1WRxERERGRdqSS3UFStbUkjWIARk443OI0IiIiItKeVLI7SHT1GhpzyjGNMPnDx1gdR0RERETakUp2B9m19E0acsuw+bZjOD1WxxERERGRdqSS3UF2LVtJ1NeTwh5pq6OIiIiISDtTye4ApmmSrmm578/hIzr3beFFRERE5POpZHeAZFUVMU9fTNL0/9qRVscRERERkXamkt0BGlYspTG3HMOxE0dOntVxRERERKSdqWR3gE1vvkpTsC+egkaro4iIiIhIB1DJ7gANldVk7C7KB/a0OoqIiIiIdACV7HZmplIQKwJg5DETLU4jIiIiIh1BJbudRTdtJBIoB2rJL+1jdRwRERER6QAq2e3s/cWv0JBbjt23x+ooIiIiItJBVLLb2faFS0i48yjo47M6ioiIiIh0EJXsdpasdgIw7IgxFicRERERkY6ikt2OMvE4GfqAGWPQ2GFWxxERERGRDqKS3Y6qV75FKKccm70Ku9NhdRwRERER6SAq2e2o8pV/EQ70wtUtbnUUEREREelAKtntqO7dGkzDTt+RQ62OIiIiIiIdSCW7PYVbbkIzevIEi4OIiIiISEdSyW4nkboaUq4ybJndFBT4rY4jIiIiIh1IJbudrH/tSRpzyrB5a62OIiIiIiIdTCW7nWxdsISU00du/x5WRxERERGRDqaS3U7ie9wADJ58lMVJRERERKSjqWS3A9M0MVKl2NIhhg8ttjqOiIiIiHQwlex2sHX9QmK+cmxGFXa7fsQiIiIihxo1wHZQOe8Jmn09cHQzrI4iIiIiIhZQyW4H+yqbAOhxpPbHFhERETkUqWS3h1APyKQYd/Rgq5OIiIiIiAVUsttYQ7gGbOU4U1X0yPdZHUdERERELKCS3cbWvP43Iv5SDE+j1VFERERExCIq2W1sy8J1ZOwuvP37Wh1FRERERCyikt3GkruDAAw86QiLk4iIiIiIVVSy25iRKsGRrGfkkO5WRxERERERi6hkt6FMJo1p64k9XY3bYbc6joiIiIhYRCW7DdXXbiDh7oHh0EWPIiIiIocylew2tHfNSjJ2N/Zcq5OIiIiIiJVUsttQ09Z6APL6l1qcRERERESspJLdhtINTgAqjjna4iQiIiIiYiWV7LYUL8CeilAxuLfVSURERETEQirZbaoIR7Iah10/VhEREZFDmdpgG0mnkqQcPTFs+6yOIiIiIiIWc1gdoKvYsPwNUq4cXLZmq6OIiIiIiMWyfiY7k8lw4403csEFFzBjxgy2bdtmdaRPtOHNpQB4engtTiIiIiIiVsv6kv3KK6+QSCR4/PHHueqqq/jNb35jdaRP1LSj5QY0paOHWpxERERERKyW9SV7+fLlHH10y5Z4I0eOZO3atRYn+mTpJjdGJsno40+0OoqIiIiIWCzr12SHw2ECgUDr53a7nVQqhcPx6dHj8TiVlZUdEa+VrUcS9975bN2mG9Fkk1gs1uF/FuSzaUyyj8Yk+2hMso/GJLt0hvHI+pIdCASIRCKtn2cymc8s2ABut5shQ4a0d7QDDLn111RWVnb4eeWzaUyyj8Yk+2hMso/GJPtoTLJLtozHZxX9rF8uMnr0aObPnw/AypUrqaiosDiRiIiIiMhny/qZ7BNPPJGFCxfyjW98A9M0+fWvf211JBERERGRz5T1Jdtms/HLX/7S6hgiIiIiIgct65eLiIiIiIh0NirZIiIiIiJtTCVbRERERKSNqWSLiIiIiLQxlWwRERERkTamki0iIiIi0sZUskVERERE2phKtoiIiIhIG1PJFhERERFpYyrZIiIiIiJtTCVbRERERKSNqWSLiIiIiLQxlWwRERERkTamki0iIiIi0sZUskVERERE2phhmqZpdYi2tnLlStxut9UxRERERKQLi8fjjBw58hO/1iVLtoiIiIiIlbRcRERERESkjalki4iIiIi0MZVsEREREZE2ppItIiIiItLGVLJFRERERNqYw+oAXUEmk+HnP/85GzZswOVyccstt9C3b1+rY3VpZ511FsFgEIDevXtz6aWXcu2112IYBgMHDuSmm27CZrMxd+5c5syZg8Ph4LLLLmPy5MnEYjGuvvpqamtr8fv93HbbbRQUFFj8ijqvVatWcfvttzN79my2bdv2lcdh5cqV/OpXv8Jut3PUUUfxgx/8wOqX2Ol8dEzWrVvHpZdeSr9+/QCYNm0ap5xyisakgySTSa677jqqqqpIJBJcdtllDBgwQL8nFvqkMenZs6d+TyyUTqe5/vrr2bJlC3a7nVtvvRXTNDv/74kpX9mLL75oXnPNNaZpmuaKFSvMSy+91OJEXVssFjPPPPPMAx675JJLzLfeess0TdO84YYbzJdeesncu3evedppp5nxeNxsampq/fjBBx80//CHP5imaZrPPvusefPNN3f0S+gy/vznP5unnXaaef7555um2TbjcMYZZ5jbtm0zM5mMefHFF5tr16615sV1Uv89JnPnzjUfeOCBA47RmHScJ5980rzllltM0zTNuro685hjjtHvicU+aUz0e2Ktl19+2bz22mtN0zTNt956y7z00ku7xO+Jlou0geXLl3P00UcDMHLkSNauXWtxoq5t/fr1RKNRLrroIr71rW+xcuVK1q1bx/jx4wGYNGkSixYtYvXq1YwaNQqXy0UwGKS0tJT169cfMF6TJk1i8eLFVr6cTq20tJS777679fOvOg7hcJhEIkFpaSmGYXDUUUdpfL6g/x6TtWvX8vrrr/PNb36T6667jnA4rDHpQCeffDI/+tGPWj+32+36PbHYJ42Jfk+sdcIJJ3DzzTcDsGvXLgoLC7vE74lKdhsIh8MEAoHWz+12O6lUysJEXZvH4+E73/kODzzwAL/4xS/48Y9/jGmaGIYBgN/vJxQKEQ6HW5eUfPB4OBw+4PEPjpUvZ8qUKTgcH646+6rj8N+/SxqfL+6/x2TEiBH85Cc/4ZFHHqFPnz788Y9/1Jh0IL/fTyAQIBwO88Mf/pCZM2fq98RinzQm+j2xnsPh4JprruHmm29mypQpXeL3RCW7DQQCASKRSOvnmUzmgP/ISdsqKyvjjDPOwDAMysrKyMvLo7a2tvXrkUiEnJycj41LJBIhGAwe8PgHx0rbsNk+/Cvly4zDJx2r8flqTjzxRIYNG9b68bvvvqsx6WC7d+/mW9/6FmeeeSann366fk+ywH+PiX5PssNtt93Giy++yA033EA8Hm99vLP+nqhkt4HRo0czf/58AFauXElFRYXFibq2J598kt/85jcAVFdXEw6HmThxIkuWLAFg/vz5jB07lhEjRrB8+XLi8TihUIjNmzdTUVHB6NGjeeONN1qPHTNmjGWvpasZOnToVxqHQCCA0+lk+/btmKbJm2++ydixY618SZ3ed77zHVavXg3A4sWLOeywwzQmHWjfvn1cdNFFXH311Zx33nmAfk+s9kljot8Ta/3zn//kvvvuA8Dr9WIYBsOGDev0vyeGaZpmh56xC/pgd5H33nsP0zT59a9/Tf/+/a2O1WUlEgl++tOfsmvXLgzD4Mc//jH5+fnccMMNJJNJysvLueWWW7Db7cydO5fHH38c0zS55JJLmDJlCtFolGuuuYaamhqcTid33HEHRUVFVr+sTuv/t3e/LLFEcRyHvypb/IOIG9Zg0eJ70GgQTBpsRsW42mSbuxgU0WSzGkQ0mgy+AxHMiphETCKLKN4mN9jucId1nyee9BsOw3zC4czj42M2NjZycnKSu7u7f96H6+vrbG9v5/PzMzMzM1lfXy/7ETvO33tye3ubZrOZSqWSarWaZrOZwcFBe/KftFqtXFxcZGJi4nut0Wik1Wp5T0ry057U6/Xs7u56T0ry9vaWzc3NPD8/5+PjIysrK5mcnOz474nIBgCAgjkuAgAABRPZAABQMJENAAAFE9kAAFAwkQ0AAAUT2QBd7ubmJvPz89nb2yt7FIBfwxV+AF3u8PAwQ0NDWV5eLnsUgF/Dv78BusjZ2Vmurq7Sbrfz8PCQxcXFnJ6eplKppFarZXh4OPv7++nr68v4+Hi2trZSqVTKHhug44hsgC7z+vqao6Oj3N/fZ21tLQsLC6lWq5mdnc3c3FyOj48zOjqag4ODnJ+fZ2lpqeyRATqOyAboMlNTU0mSsbGxvL+/f6+/vLzk6ekp9Xo9SdJutzM9PV3GiAAdT2QDdJmenp4f10dGRlKr1b7PaF9eXqa/v/8/TwfwO4hsAJIkvb29aTQaWV1dzdfXVwYGBrKzs1P2WAAdye0iAABQMPdkAwBAwUQ2AAAUTGQDAEDBRDYAABRMZAMAQMFENgAAFExkAwBAwUQ2AAAU7A/+6o85+uJ+SAAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.set_style(\"whitegrid\")\n",
+    "fig, ax = plt.subplots()\n",
+    "for convergence in convergences:\n",
+    "    ax.plot(convergence.nfe, convergence.epsilon_progress)\n",
+    "\n",
+    "ax.set_xlabel(\"nfe\")\n",
+    "ax.set_ylabel(\"$\\epsilon$-progress\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "02238a96-ecd0-4438-95a8-0f046e5e860d",
+   "metadata": {},
+   "source": [
+    "Above, you see the $\\epsilon$-convergence for the auto adaptive operator selection version of the outputspace algorithm. Like the normal version, it converges to essential the same number across the different seeds. Note also that the $\\epsilon$-progress is slightly higher, and also the total number of identified solutions (see log messages) is higher. That suggests that for even for a relatively simple problem, there is value in using the auto adaptive operator selection. \n",
+    "\n",
+    "In case of `AutoAdaptiveOutputSpaceExploration` it can sometimes also be revealing to check the dynamics of the operators over the evolution. This is shown below separately for each seed. For the meaning of the abbreviations, check the [BORG algorithm](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.469.9675&rep=rep1&type=pdf)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "bbfcbc88-0b34-466d-b5b1-466b83620d5e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsEAAAHRCAYAAACLj2RyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABxd0lEQVR4nO3deXwU9eE//tfM7H3kDpBwBAgJBBACeCt4goh4ooIi3lX81X4++vFCW6kHIn6w9Vvb6qdajxatomitWFsRpR4oqEDkMNw3CbmvvY+Z3x+zu9lNNidJdrP7ej4e+5jZmdmZ9+adwGvf+573W1AURQERERERURIRY10AIiIiIqK+xhBMREREREmHIZiIiIiIkg5DMBERERElHYZgIiIiIko6DMFERERElHQ0fX3BkpIS6PX6vr4sAMDtdsfs2tQa6yO+sD7iC+sjvrA+4gvrI77Ec3243W4UFxdH3dfnIViv16OoqKivLwsAKC0tjdm1qTXWR3xhfcQX1kd8YX3EF9ZHfInn+igtLW1zH7tDEBEREVHSYQgmIiIioqTDEExERERESafP+wRH4/V6cfToUbhcrl6/Tnt9Q2LBYDBgyJAh0Gq1sS4KERERUdKIixB89OhRWK1WDB8+HIIg9Np1nE4njEZjr52/qxRFQU1NDY4ePYoRI0bEujhERERESSMuukO4XC5kZmb2agCOR4IgIDMzs9dbwImIiIgoUlyEYABJF4CDkvV9ExEREcVSXHSHiBcvvfQSvvnmG4iiCEEQcO+99+KNN97Ajh07kJaWBo/Hg4KCAvz6179GXV0d5s2bh5dffhn5+fnw+/245ZZbcPvtt2PatGmxfitERERE1A6G4IC9e/fi888/x1tvvQVBEFBaWoqHHnoIY8eOxQMPPBAKtvfddx8+++wzzJw5E4sXL8b999+PlStX4rnnnsOUKVMYgImIiIj6gbgLwe9tOop3fjjSo+e89uShmDNlSLvHZGRkoKysDKtWrcK0adNQVFSEVatWYfHixaFj/H4/7HY7cnNzAQDnnnsu1q9fj5///Ofw+Xx45ZVXerTcRERERNQ74qZPcKxlZGTgxRdfxObNmzF37lzMnDkT69atAwAsX74cCxYswKxZs1BdXR0xksP8+fPx1Vdf4aqrroIo8sdJRERE1B/EXUvwnClDOmy17Q2HDh2CxWLB008/DQDYtm0b7rjjDkycODGiO8Tvfvc7LFu2DE899RS8Xi8WLVqExYsX47nnnsOpp56KgQMH9nnZiYiIiKhr2HQZsGvXLjz22GNwu90AgBEjRsBqtUKSpIjjcnJy4PV6AQDPPPMMpkyZguuvvx4LFy7E/fffD1mW+7zsRERERNQ1cdcSHCszZszAvn37cM0118BkMkFRFDz44INYu3Ytli9fjpdffhmiKEKWZSxduhRr1qzB1q1b8eabbwIArr32Wnz99dd44YUXcPfdd8f43RARERFRexiCw9x111246667IrZdeOGFUY8dOnQoZsyYEbHt+eef77WyEREREVHPYXcIIiIiIko6bAkmIiKi/sNjh+hpApz1sS4JBXRYH1ojoNH3WXk6iyGYiIiI4ovXCdTuB2r2AjX71EftPvW5vQqjY10+itBhfRgzgAf2AqLU0ZF9iiGYiIiI+p7fC9QdUoNtMODW7AVq9gONRyOPtQwEMkcBhTOBjBE4XtOIQRySNG4cr6hovz5ShwBC/PXAZQgmIiKi3iHLaqANb9ENht66Q4Dibz7WkKYG3eFnqcvMfCAjX13qrRGnrSstxaCior59L9Sm/lofDMFERETUfYoC2CqbW3Jr94V1YdgP+N3Nx2pNaqjNmQiMu6o57GaOAkwZsXsPlJQYggM2btyIe+65B6NGjQIAuN1uXHrppViwYAFWrlyJDz/8EKIowuv14t5778Vpp52G5557DtXV1XjqqacAAF9//TX+9Kc/4bXXXoNGwx8tERElEEdti366YYHXY2s+TtIB6SPUYFtwobrMCARd6yBAEGL3HojCMKmFOf300/Hcc88BADweD2bOnImMjAysX78er7/+OrRaLY4cOYIbbrgBf//73/GLX/wCN9xwAz7++GMUFxfj6aefZgAmIqL+y21rDrq1Yd0XavYBztrm4wQRSBumBtuhp4e16OYDqUPj7gYoomjiL62VvAVseaNnzznpBqD4ui69xGazQRRFvP3223j44Yeh1WoBqJNkfPDBB0hPTwcA/OY3v8FNN92E7Oxs/OpXv8KAAQN6tuxEREQ9yecGag+E3YwWNvpCU3nksdZcNdiOvby520JGPpA+HNDoYlJ8op4SfyE4hjZs2IAFCxZAEARotVo8+uijWLp0KYYOHRpxXDAAA8DgwYNRXFyMn376CaecckpfF5mIiKg1vw9oOKyOtBAx+sI+oOEIoMjNx5qy1ICbfz6QMTLsprSRgM4cu/dA1MviLwQXX9flVtueEt4dIugvf/kLysvLYbU235n69ddfY/To0cjOzsbatWtRUVGBSZMm4fnnn8f//M//9HWxiYgoGSkK0FgWvUW39gAge5uP1aeooXbIKcDEeWH9dEcCxvS2r0GUwOIvBMeZOXPm4IUXXsCzzz4LjUaDAwcO4Je//CXef/99HDlyBM888wxWrFiBlJQUzJkzB2eccQbOOOOMWBebiIgSgaIAjpoWN6LtbR55wetoPlZjUINu9mhg9KxAi26gVdeczRvSiFpgCO7AJZdcgqqqKlx//fXQarXw+/1Yvnw5rFYr7rjjDixatAiDBg0CADz77LO4++67sWrVKmRmZsa45ERE1G+4GlvfiBYMva6G5uNEjdofNyMfGHGO2pIbbNVNGQyI8TchAVG8YggOOO2003DaaadF3XfzzTfj5ptvbrX9vffei3g+btw4rFu3rjeKR0RE/V1oKuB9rcfTtVeGHSioIyxkjgROuqZ5eLHMfHVEBkkbs7dAlEgYgomIiHpKcCrg2pYtuvvVG9LCWQaqAbfwouaRFzJHqWPsag2xKT9REukwBMuyjMceewy7du2CTqfDkiVLkJeXF9q/detWLFu2DIqiIDs7G8uXL4der+/VQhMREcVMaCrgsIAbnC2t1VTAqWqwzTsz0G1hZPPSkBK790BEHYfgtWvXwuPxYOXKlSgpKcGyZcvw4osvAgAURcGjjz6K559/Hnl5eXj33Xdx7NgxjBw5stcLTkRR2KsBe5XawmRM540wRN0VnAo40KKbvXsj8GO9GnzrDgA+V/OxwamAB00ITAUcNp6uKYN/h0RxqsMQvGnTJkydOhUAUFxcjO3bt4f2HThwAGlpafjLX/6C3bt345xzzmEAJupLPg9wZCOw73Ng32dA+Y/N+0Steke4ZYAaii0DWqwPBMyBbXpr29cgSlR+H+CqB+oORhl9YT/gaQodmilqAn1z89WpgMP76VpzGHSJ+qEOQ7DNZoPFYgk9lyQJPp8PGo0GdXV12LJlCx599FHk5eVh4cKFGD9+fLtDhLndbpSWlkZs83q9cDqdJ/A2OkdRlD65Tld5vd5WP5Nk4HK5kvJ9nxBFgdZ2BJbj38F8fANMlZsh+RxQBAnOzPGwjb8DXssQSO46aFw10DhroHHXQlN1ANKRTdC46yCEf1UbIEt6jNRnwLE2C35DBnyGDPgMmYGHuu43ZsCnz4CiYV/FvsC/jy6Q/ZC8NoieBkjuRkieRkiehsCyEZK7jXVvU8RpFEGE15QDj3UoPHkz4bEMhcc6DB7rMDRJqTAYW0wc4QJwrAFAA6hv8e8jvvTX+ugwBFssFtjt9tBzWZah0agvS0tLQ15eHkaNGgUAmDp1KrZv395uCNbr9SgqKorYVlpaCqPR2K030BVOp7NPrtNVWq221c8kGZSWlibl++4yVyNw4Eu1pXfvZ0D9IXV7Wh5QPA/IvwDCiGkwGVJg6uhcsgw4awFbReBRCdgqIdoq4Crbg1TRpXanqNuujk0ajT4lskXZHN7CHNbibM7mXewnICn/PmS/OhyYs6754agNe14bfburAYDSxkkFtV+uKUPtIpQ5GDCepK4b09XtqUOBzFEQ0vOg0+gRbTLgpKyPOMb6iC/xXB/thfMOQ/DkyZOxbt06zJo1CyUlJSgsLAztGzp0KOx2Ow4dOoS8vDz88MMPuPrqq3um1H1s48aNuOeeezBq1CgoigKfz4cbb7wREyZMwGWXXYZx48ZFHP/6669DkqQYlZZixlalDk5vygB0lt75ClSWgfItwN7P1W4OR78DZB+gNQMjpgFn/qJ5etOuXl8UAXOW+hgY+TtdVlqK1PB/xPxeNRAHgnIoONurmgP08W3qz8TdRkuYKTPQ7SI7shuGpUVwNmZwfNNEIstqNwNnHeCsbzu8ttzebpiFGmaNGc0BNjM/sJ4RGWqD68Z09TUi/60motY6DMHTp0/H+vXrMW/ePCiKgqVLl2L16tVwOByYO3cunnrqKdx3331QFAWTJk3Cueee2wfF7h3h0ybb7XYsWLAATz31FEaNGoUVK1bEuHQUEx47cOgbYN86YP86oPKn5n2STv3P15TRvIxYz2y935AWPew1lqstvfs+V6/lrFW350wEzvwvYNQFwJBTAU20NqpeImmBlFz10RGvszks2yvDWpmbW5txZKO69EXpkiRIne+/bEhl/8u+IsvqB5xQUK3ruFXWWasG3w7DbHpzgE0fESXAtgi2DLNE1MM6DMGiKOKJJ56I2Jafnx9aP+OMM7Bq1aoeK9CH+z7E3/f8vcfOBwBXFlyJy/Iv69JrzGYz5s6di1deeaVHy0JxTvYDZSVq4N3/HzW4+T2ApAfyzgAmXKuGNUdN4D/+WnXpqAWqdzdvk33Rzy+IahAOD8n1h5rDtWWgOmZo/gXAyHMBS3bfvO8TpTUC6Xnqoz2KAnhskS3LtqrI7hn2SvXnYauI/nOU9IFw3KJ1OdTaHBaidebWr09Gsgy4G1uE1/qOuxq46gFFbvu8+lTAmNYcXtPz2mmVzWhumZU4RD0RxR7/JWpHZmYm6urqsHfvXixYsCC0fdy4cVi0aFEMS0Y9qvaAGnr3rVP73rrq1e2DTgJOWwjknwcMO0MNep2hKGrgaBmSQ+s1zeuNR9XwduHjamvvwPGJ3copCOpIFHqr+lV2e4JfqdtatCzbw7pn1B8Gjv6gdtGI1vKos0TpvxzeLSO7uZW5L1vZuyv4u9Wq9bWDrgbO+sixa1vSp0R2IUgb1naLbKibQRrDLBH1a3H3L9hl+Zd1udW2t5SVlWHKlCloampid4hE4qwL3GgW6OJQd1DdnjIYGDNbDb0jzul+K6wQuBHHkApgRE+VOvmIYnMXkwFj2j/W71M/XLQMyeH9mSt3ArYvmj/ktGRMj3KTX8u+zAPVFvwT/VpeUQB3UxtdCuoBZy1yjh8Etsitw257YVZnBUxhYTZ1aPutssZ0tSWXNzASURKKuxAcL2w2G95991387ne/w3/+859YF4dORHAs3WBrb3mJ+hWvzgqMmAqc/nO160FWQWK3wiYySQNYB6qPjvjckTf3Rbvxr2yzus1ja/16QQRMWS36LoeFZEHoXP/ZDsKsSWMGUgYERi8Y3MENYBkMs0REXcQQHGbDhg1YsGABRFGE3+/HL37xC+h0ulbdIQBg6dKlGDp0aIxKSu1y1qnTmB7eoIbeQ+vVER0ECRhyMjDtQbW1d/AUhoZkpNEDqUPUR0fctkDLchWijo5hqwCq96hLv7v163WWyG4GA8a2f/NXsJuBRod9cTzkEBFRImAIDjjttNPw7bffRt23efPmPi4NtUtR1OmBa/er05fW7o98OOuaj80cBRTPV0Pv8LMDXRSIOklvUR8ZHcyEqSjq8F62SrWFNxhu+0M/YyKiJMUQTPFJlgHb8bBweyByPWw6Uwii2vcxYwQw7ko1sGSMBAZNANLYWk99QBDU7gjGtFiXhIiIOokhmGLPUQvsWaNOvFB3sDnoho8nK2qA9OFquB12RnPQzRip3snOFjciIiLqAoZgio2afcjY9Tdgwybg8LfqjWoagzpofsbIwIxoI5qDbsoQDsdEREREPYapgvqGLKt33O/8J7DrY6BqJwYC6ri4U+8HRl8M5BRz6lwiIiLqEwzB1Hu8LuDAF2rw3f1v9Q56QQKGnwVMuQV7pQKMOuWCWJeSiIiIkhBDMPUsew2w5xM1+O5bB3jt6ni8BRcCoy9Rl8Z0AIC3tDTGhSUiIqJkxRAcsHHjRrz99tt47rnnQtueffZZjBw5Eo8++ihWrlyJ8ePHAwDeeustVFdX4xe/+AXOP/985OTkQBRFuN3u0JTKWq0WN910E+bMmYMrrrgCAELnvvfee/v8/fWqmn1qF4dd/2ru32vNBYqvU7s5DJ+qjs1KREREFCcYgjvBYrHg4YcfxnvvvQedrvUoBK+++ir0ejXkvfjii3juueewaNEiLF++HNdffz0mTZqE/fv3Y8uWLXjttdf6uvg9T5aBY5sCwVft3wsAGHiS2r93zCy1fy9nXyMiIqI4FXchuP6DD9Dw3vs9es7UOVchLdAa2x15eXk4+eST8dxzz+Ghhx5q99hbbrkFs2bNwqJFizBo0CA88sgjeOCBB+B0OvHqq69CkqRulyPmZD+wbimwZYXav1fUAHlq/16MvhhIz4t1CYmIiIg6Je5CcLwpKysDANxzzz24+uqr8cMPP7R7vMFggNvdPH3qOeecg6effhpnnnkmsrOze7WsvcrrBN67Hdj5ETBmNjD2ioj+vURERET9SdyF4LQrrjihVtvuMhgM8Hg8EdscDgdSU9VpdnU6HZ5++mncd999uPbaa9s8j81mg9lsDj1/9tlnMXPmTHz11Vf46quvMHXq1N55A73JUQu8NQ848h1w8XLgtDtiXSIiIiKiE8JBWQPy8/NRWlqKyspKAIDb7cb333+PGTNmhI4ZN24cZs+ejZdffrnN87z88su4+OKLAQCffvoptm7dinvvvRfLly/H4sWLUVVV1btvpKfVHwZevQgoKwGueZ0BmIiIiBJC3LUEx4rFYsGiRYtw5513wmAwwOv1YsGCBa368C5cuBDr1q2L2HbrrbdCFEXIsoyioiI8+OCDOHLkCJ5++mm88cYb0Gg0GD16NG677TY8+OCDeOWVVyD2h0khjm8D3rhanb54wd/V8X2JiIiIEgBDcJgZM2ZEtPwGvfPOO6F1jUaD9957L/T8888/j3quoUOHttp3ww034IYbbuih0vay/V8AK28A9Fbg1k+AAUWxLhERERFRj+kHzZHU57atAt6YA6QOAW77lAGYiIiIEg5DMEX65g/Ae7cBQ08FbvkXkDo41iUiIiIi6nHsDkEqWQbW/ArY8Ed1+LMr/wRoDbEuFREREVGvYAgmwOcGPrgL2P4ecNpC4KKngf5w4x4RERFRNzEEJztXA/D2fODgV8D0J4Az/4vTHRMREVHCYwhOZo3lwJtXA1U7gStfAibOjXWJiIiIiPoEQ3CYl156Cd988w1EUYQgCLj33nvxxhtvYMeOHUhLSwMA+P1+PP7440hNTcW8efPw8ssvIz8/H36/H7fccgtuv/12TJs2LbZvpDOqdqkjQDjrgPnvAvnnx7pERERERH2GIThg7969+Pzzz/HWW29BEASUlpbioYcewtixY/HAAw+Egu0XX3yB3/3ud/jDH/6AxYsX4/7778fKlSvx3HPPYcqUKf0jAB/eAPxtLiDpgFs+BnImxrpERERERH0q7kLwzg3lKF1f3qPnLDorB2NOz2n3mIyMDJSVlWHVqlWYNm0aioqKsGrVKixevDjiuIaGBphMJgDAueeei/Xr1+PnP/85fD4fXnnllR4td68o/UgdAi11CHDDe0D68FiXiIiIiKjPxV0IjpWMjAy8+OKLeOONN/DHP/4RBoMB9957LwBg+fLlePnllyGKIgYMGIAHHngg9Lr58+dj5syZWL58efxPhfz9n4GPHwByJwPXvwOYM2NdIiIiIqKYiLsQPOb0jltte8OhQ4dgsVjw9NNPAwC2bduGO+64AxMnTozoDhHO6/Vi0aJFWLx4MZ577jmceuqpGDhwYF8XvWOKAnz+JPDVb4DCmcDVrwE6U6xLRURERBQzcd502Xd27dqFxx57DG63GwAwYsQIWK1WSJLU5mueeeYZTJkyBddffz0WLlyI+++/H7Is91WRO8fvBf7xczUAT74JmPsmAzARERElvbhrCY6VGTNmYN++fbjmmmtgMpmgKAoefPBBrF27Nurxa9aswdatW/Hmm28CAK699lp8/fXXeOGFF3D33Xf3ZdHb5nUB7ywA9qwBzn0YOOchjgFMREREBIbgCHfddRfuuuuuiG0XXnhh1GNnzJiBGTNmRGx7/vnne61sXeZ1Am9fD+xbB8x+Djj51liXiIiIiChuMAQnIo8DePs6YP8XwOV/ACbdEOsSEREREcUVhuBE43EAb80DDnwJXPECUHx9rEtEREREFHcYghOJxwG8NRc48BVwxYtA8XWxLhERERFRXGIIThQeuzoL3KH1wJV/AibOjXWJiIiIiOIWQ3Ai8NiBN68FDn+jBuAJ18a6RERERERxjSG4v3PbgL9dCxz+FrjqZeCkq2NdIiIiIqK4x8kyAjZu3BiaJjno2Wefxfvvv4/Ro0fjpZdeiti3cOFCLFiwoC+L2JrbBrx5DQMwERERURcxBHfCsGHD8Mknn4Se19fX49ChQzEsEQB3E/Dm1cCRjcCcPzMAExEREXVB3HWH2PHFZ9j+n0979Jzjz52Ocedc0O3Xp6enIy0tDfv27UN+fj4+/vhjzJw5Ez/88EMPlrILXI1qAD76A3D1K8C4K2NTDiIiIqJ+ii3BHSgrKwMAXHLJJfjnP/8JAPjss8/anEmu17kagTfmBALwqwzARERERN0Qdy3B48654IRabbvLYDDA4/FEbHM4HEhNTQWgTp88f/58XHXVVcjOzobBYOjzMsLVoAbgsi3ANa8BYy/v+zIQERERJQC2BAfk5+ejtLQUlZWVAAC3243vv/8eM2bMAACYzWaMGDECy5cvx+zZs/u+gK4GYMVVgQD8OgMwERER0QmIu5bgWLFYLFi0aBHuvPNOGAwGeL1eLFiwAJIkhY659NJLsXjxYvz2t7/FwYMH+65wznrgjauA8q3AtX8FxlzSd9cmIiIiSkAMwWFmzJgRavkN98477wAAzj//fJx//vkA1JbjFStW9H6hnPXAiiuB49sCAXhW71+TiIiIKMExBMczZ10gAG8H5q4ARl8c6xIRERERJQSG4HjlqAVWXAFUlgJz3wBGz4x1iYiIiIgSBkNwPHLUAn+9HKjaCcx9Eyhs3UWDiIiIiLovbkaHUBQl1kWIiVbv21EL/PUyoGoXMO9vDMBEREREvSAuWoINBgNqamqQmZkJQRBiXZzepSiA7Af8Hih+D2pqa2GwHQb+/jug8RhQuVMdDm3e34CCGE3IQURERJTg4iIEDxkyBEePHkVVVVWvXsfr9UKr1fbeBRQFUGQ15Cp+QPaFrQcfPgDB1l8Fhob9GLLlWUBvBFJygbwzgVNuB0ZM7b1yEhERESW5uAjBWq0WI0aM6PXrlJaWoqioqOdOqCjAJ48AxzYDjWVAU1kg5IYRtWq4TRkcWIavDwbGTQRm3AmIUvRrEBEREVGPi4sQ3G/Zq4ENLwDZY4C8M6KHXVMWIMZN12siIiIiAkPwibFVqMtzHwbGXRHTohARERFR53UYgmVZxmOPPYZdu3ZBp9NhyZIlyMvLC+1/7bXXsGrVKmRkZAAAHn/8cYwcObL3ShxPgiHYMiC25SAiIiKiLukwBK9duxYejwcrV65ESUkJli1bhhdffDG0f8eOHXjmmWcwfvz4Xi1oXLIHbuSzDIxtOYiIiIioSzoMwZs2bcLUqepIBcXFxdi+fXvE/h07duCll15CVVUVzj33XNx55529U9J4xJZgIiIion6pwxBss9lgsVhCzyVJgs/ng0ajvvSSSy7B9ddfD4vFgrvvvhvr1q3Deeed1+b53G43SktLe6DoXedyuXr02gMO70S6pMeufUeARB/fuBf0dH3QiWF9xBfWR3xhfcQX1kd86a/10WEItlgssNvtoeeyLIcCsKIouOmmm2C1WgEA55xzDn766ad2Q7Ber+/ZYcq6oMeHSPvJB1gHoWjs2J47ZxLp8fqgE8L6iC+sj/jC+ogvrI/4Es/10V4473DsrsmTJ+PLL78EAJSUlKCwsDC0z2azYfbs2bDb7VAUBRs3bkyuvsG2CvYHJiIiIuqHOmwJnj59OtavX4958+ZBURQsXboUq1evhsPhwNy5c3HvvffixhtvhE6nwxlnnIFzzjmnL8odH+xVQEaSjIRBRERElEA6DMGiKOKJJ56I2Jafnx9av+KKK3DFFVf0eMH6BVsFMOz0WJeCiIiIiLqIU5l1l98LOGrYHYKIiIioH2II7i57tbo0Z8e2HERERETUZQzB3RUaI5gtwURERET9DUNwd9kq1SUnyiAiIiLqdxiCu8vOEExERETUXzEEd1ewO4SZIZiIiIiov2EI7i5bFaCzAjpTrEtCRERERF3EENxdtgp2hSAiIiLqpxiCu8tWyZEhiIiIiPophuDuslcCFo4RTERERNQfMQR3l62CLcFERERE/RRDcHd4XYCrgX2CiYiIiPophuDusFepSw6PRkRERNQvMQR3R2i2OHaHICIiIuqPGIK7IzhRBm+MIyIiIuqXGIK7w86WYCIiIqL+jCG4O4LdIcxsCSYiIiLqjxiCu8NWCRjSAI0+1iUhIiIiom5gCO4OjhFMRERE1K8xBHeHrZJjBBMRERH1YwzB3WFnCCYiIiLqzxiCu8NWye4QRERERP0YQ3BXeeyAx8aWYCIiIqJ+jCG4q0LDozEEExEREfVXDMFdxSmTiYiIiPo9huCu4pTJRERERP0eQ3BXccpkIiIion6PIbirbJUABMCUFeuSEBEREVE3MQR3la0SMGUCkibWJSEiIiKibmII7iqOEUxERETU7zEEd5WtgmMEExEREfVzDMFdxSmTiYiIiPo9huCuUJRAdwiGYCIiIqL+jCG4K9yNgM/FPsFERERE/RxDcFfYqtQlp0wmIiIi6tcYgrsiNFscQzARERFRf8YQ3BWh2eIYgomIiIj6M4bgrrBxymQiIiKiRMAQ3BW2CkCQAGNGrEtCRERERCeAIbgrbJWAORsQ+WMjIiIi6s+Y5rqCYwQTERERJQSG4K6wVbA/MBEREVECYAjuCnsVW4KJiIiIEgBDcGfJMrtDEBERESUIhuDOctUDspfdIYiIiIgSAENwZwXHCDZnx7YcRERERHTCGII7KzRlMluCiYiIiPo7huDOslepS/YJJiIiIur3GII7K9QSzBBMRERE1N8xBHeWrQKQdIAhLdYlISIiIqITxBDcWbYqwDwAEIRYl4SIiIiIThBDcGfZKtgVgoiIiChBMAR3lq2SI0MQERERJQiG4M6yVwIWjhFMRERElAgYgjtD9qtDpLElmIiIiCghMAR3hqMGUGSGYCIiIqIE0WEIlmUZixcvxty5c7FgwQIcOnQo6nGPPvoonn322R4vYFzglMlERERECaXDELx27Vp4PB6sXLkS9913H5YtW9bqmLfffhu7d+/ulQLGBU6ZTERERJRQOgzBmzZtwtSpUwEAxcXF2L59e8T+LVu24Mcff8TcuXN7p4TxgFMmExERESUUTUcH2Gw2WCyW0HNJkuDz+aDRaFBZWYk//OEP+MMf/oB//etfnbqg2+1GaWlp90t8AlwuV7eunbF/GwYC2HWsDnJlbMqeiLpbH9Q7WB/xhfURX1gf8YX1EV/6a310GIItFgvsdnvouSzL0GjUl/373/9GXV0d7rjjDlRVVcHlcmHkyJG46qqr2jyfXq9HUVFRDxS960pLS7t37cMAtCaMPmkKZ4zrQd2uD+oVrI/4wvqIL6yP+ML6iC/xXB/thfMOQ/DkyZOxbt06zJo1CyUlJSgsLAztu/HGG3HjjTcCAN5//33s37+/3QDcb9kq1ZviGICJiIiIEkKHIXj69OlYv3495s2bB0VRsHTpUqxevRoOhyOx+wGHs1XwpjgiIiKiBNJhCBZFEU888UTEtvz8/FbHJWQLcJCtEshs/Z6JiIiIqH/iZBmdYa/kyBBERERECYQhuCN+rzpjHLtDEBERESUMhuCO2KvVJVuCiYiIiBIGQ3BHgrPFmRmCiYiIiBIFQ3BHbJXqkt0hiIiIiBIGQ3BH7MEQnB3bchARERFRj2EI7gi7QxARERElHIbgjtgqAX0KoDPFuiRERERE1EMYgjsSnDKZiIiIiBIGQ3BHbJW8KY6IiIgowTAEd8RWwTGCiYiIiBIMQ3BHOGUyERERUcJhCG6P1wW4GhiCiYiIiBIMQ3B77FXqkn2CiYiIiBIKQ3B7grPFcYxgIiIiooTCENye4EQZ7A5BRERElFAYgtsTmjKZIZiIiIgokTAEtyfUHYKTZRARERElEobg9tgqAGM6oNHHuiRERERE1IMYgttjq+RNcUREREQJiCG4PTZOlEFERESUiBiC22Or4BjBRERERAmIIbg99iq2BBMRERElIIbgtnjsgMfGEExERESUgBiC2xIcHo3dIYiIiIgSDkNwWzhlMhEREVHCYghuC6dMJiIiIkpYDMFt4ZTJRERERAmLIbgttkoAAmDKinVJiIiIiKiHMQS3xVYBmLMASRPrkhARERFRD2MIboutijfFERERESUohuC22CrYH5iIiIgoQTEEt8VWyTGCiYiIiBIUQ3A0iqKODmHJjnVJiIiIiKgXMARH424EfC62BBMRERElKIbgaGxV6pIhmIiIiCghMQRHE5wtzszuEERERESJiCE4mtCUyWwJJiIiIkpEDMHR2IPdIThEGhEREVEiYgiOxlYBCBJgzIh1SYiIiIioFzAERxOcKEPkj4eIiIgoETHlRWOr4k1xRERERAmMITgaWwVviiMiIiJKYAzB0dirGIKJiIiIEhhDcEuyDNg4ZTIRERFRImMIbslVD8hetgQTERERJTCG4JZsleqSYwQTERERJSyG4JZCUyYzBBMRERElKobglkItwewOQURERJSoGIJbsgdDMG+MIyIiIkpUDMEt2SoASQcY0mJdEiIiIiLqJQzBLdkq1a4QghDrkhARERFRL2EIbslWySmTiYiIiBIcQ3BLwZZgIiIiIkpYDMEt2Ss5RjARERFRguswBMuyjMWLF2Pu3LlYsGABDh06FLH/k08+wZw5c3D11Vfj3Xff7bWC9gnZD9irGIKJiIiIEpymowPWrl0Lj8eDlStXoqSkBMuWLcOLL74IAPD7/fjNb36D9957DyaTCbNmzcIFF1yAjIyMXi94r3DUAIrM7hBERERECa7DELxp0yZMnToVAFBcXIzt27eH9kmShI8//hgajQY1NTUAALPZ3EtF7QOcMpmIiIgoKXTYHcJms8FisYSeS5IEn88Xeq7RaLBmzRpcfvnlOPnkk6HRdJir4xenTCYiIiJKCh0mVovFArvdHnouy3KroDtjxgxceOGFWLRoET744APMmTOnzfO53W6UlpaeQJG7z+VytXvt1AMlyAWwt6IJXkdsyphMOqoP6lusj/jC+ogvrI/4wvqIL/21PjoMwZMnT8a6deswa9YslJSUoLCwMLTPZrNh4cKFePXVV6HT6WA0GiGK7Tcu6/V6FBUVnXjJu6G0tLT9a9euAQCMmngGoLf2UamSV4f1QX2K9RFfWB/xhfURX1gf8SWe66O9cN5hCJ4+fTrWr1+PefPmQVEULF26FKtXr4bD4cDcuXNx6aWXYv78+dBoNBg9ejQuu+yyHi18n7JVAloToLN0fCwRERER9VsdhmBRFPHEE09EbMvPzw+tz507F3Pnzu35ksWCrUK9KY5TJhMRERElNE6WEc5WyZviiIiIiJIAQ3A4G2eLIyIiIkoGDMHh7JWcKIOIiIgoCTAEB/m96oxxbAkmIiIiSngMwUH2KnXJEExERESU8BiCg0JTJrM7BBEREVGi68dzHPewYAjm6BBERAnD45NRbXOjqskdZelBlc0Nn18GAAiB4TGDg2QGR8sUIMDhcMD0ZX3UfRHP29iO0OuEKOdo3hft+gg7V1evH75o+/1Fvz7CztX62Pav36Uyt7g+wo5v69ja2lpk7v8JFB9qatqvj5xUI245a3irOo41huAgW4W6ZHcIIqK45vXLqLV7UNXkRlW0YNvkCizdaHB6o54jxaBBllWPLIseZr0GiqJuV6CuhJ4HlqIIiIL6XAluV4KvaPEaBF+rtHjevI4o+9q7vhJ2PnT0mmjX70TZ2rt+l14Tsb/zP5uulFmWZYiiDRQfOqqP3DQjbj5zeNxNw8AQHGQPdodgCCYi6mt+WQkF26gttzY3qpvUlts6hwct8iAAwKLXINuqR5ZFh8KBFpyZn4lsix5ZVn3z0qpHplkHg1bqUvnieVrYZMT6iC/9tT4YgoNslYA+BdAaY10SIqKEIMsK6p3eqMG2KqLl1o1auxtylGBr1EqhYDs8y4STh6cHnutDywGBpVHXtWBLRMmNITiIE2UQEXVIURQ0On2osrlQFWiZrW5yRy4DAbfG5oEvSrLVacRQy+zgNCOKh6a2brENLM06Ke76ERJRYmAIDuKUyUSUpBRFgc3ti2iZbe9mMk/gRrJwGlEIa5k1YGxOSqsW2+xAdwSrXsNgS0QxxxAcZKsABo6LdSmIiHqMw+Nr0QWh7YDr8rYOtpIoINOsCwXYUQOsoa4J2YHW2mCwTTVqGWyJqF9hCA6yVwKW82NdCiKidrm8/iijIUS7icwNu8ff6vWCgIhgOzzTHBFsQy22Fj3STTqIIoMtESUmhmAA8LoAVwNgyY51SYgoCQXHsg0Psjv210HcsyN0E1mwv22Tyxf1HOkmbSjAThyS1qoLQjDkZph00EicJ4mIiCEYCBsejbPFEVHP8AXGsq1sedNYy5vJbG7UO9oay7YpdJNYUW4KpoW10oaH3AyzDjoNgy0RUVcwBAOArUpdMgQTUSfZ3D4crnHgcK0DR2rV5eFaB443uFBtc6O2nbFsg62yBQPUsWzDuyAEx7KtProfE8fzPgUiot7CEAw0zxZnZncIIlL5ZQXHG104XBMZcoOht8buiTg+1ajFsAwT8jLVsWwjuyJ0fSzbxnK27BIR9SaGYCBsymS2BBMlkyaXt1VL7uFaJ47UOnC0zgGvv7kpVyMKGJxuxLAMEy4aPwjDMkyhx9B0E1JN2hi+EyIi6iqGYACwB7pDsCWYKKH4ZQXlDc4WQVd9frjGjroWfXHTTGpr7tjcFMxsEXRzUg28oYyIKIEwBANqS7AxHdDoYl0SIuqiRpe3zS4Lx+qdrVpzh6QbMTTDhFkn5TS35AYeqUa25hIRJQuGYCAwZTK7QhDFI59fRnmDq1XIDT5ajqyQHmjNHT84tVXQZWsuEREFMQQDgSmT2RWCKFYanN6oLbmHax04VueET25uzdVKAoakq6F2wpDUVq25KQa25hIRUccYggG1O8TgKbEuBVHCCrbmRrTi1jSvNzgjW3MzzLpAyE3D7Ak5oZCr9s01QuIsZkREdIIYggH1xjh2hyA6IQ0Ob6uuCqHW3Hon/C1ac4cGWnOLh6ZFhNyhGUZY2ZpLRES9jCHYbQM8Nk6ZTNQBr19GeX2L1txae6hVt7HFdL6Zgdbc4qFpuGxibijo5mWaMDDFwNZcIiKKKYZgTplMBABQFAX1Dk/UltzDtQ6U1bsiWnN1koghGeq4uZOHpbdozTXBouc/L0REFL/4v1RoyuQBsS0HJTy/rOBwrQO7K5qwp6IJuyts2FNpg8fnD8wsZkC2JTjDmC4021i2VY9Ms75HWk69fhll9c6ofXMPVtlg9x6IOD7LorbmTh6WjiuKm0PusAwTBqUYILI1l4iI+imG4NCUyQzB1DNkWcHROid2VzRhd2UTdh9XA+++KhvcPjl03OA0IwoGWmDSSahu8mD7sQZUNblhc/tanVMUgAxzcyjOjpiSVw3MA6x6ZFsMkBWlndZcJ8Iac6HTiBgamAVtZAowMX+wGnIz1VnQzGzNJSKiBMX/4ThlckKRZQUHa+zYdqwBdrcfJp0Eo06CUSu1WNeE1nWa7o0bK8sKjtU7sadSDblqC68NeyttcHr9oeNyUg0oGGjFmfmZKBxoRcFACwoGWtvsLuDw+FDd5EGVzYWqJjeqbB51GXzY3NhXaUNVkxsevxz1HOGyLHoMyzDi5Lx0DJs0ONSam5dpxgCrPtSaW1paiqKikd36WRAREfU3DMH2KgACYMqMdUmoixRFwZFaJ7Yeq8e2ow3YerQB2481oClKS2p7NKLQIihrYNSKoaBsCuwLHlPZ5MaeiibsqbTB4WkOuwNT9CgcaMV1pw5DYSDoFgy0dHncWpNOg2GZGgzLNHX4/hudPlTZXKgMC8kAkJdpDo20YNLxz5yIiKgl/u9oqwDMWYDEH0U8UxQFZQ0ubDtaj61HG7DtmBp6g+PL6iQRRTlWXD4pFxMGp2H84FRkmHVweHxwePxwef1wePwt1n1tbA+u+1Bj98AZOIfT64fT40eaSYfCgRZce/JQFA60qoF3gBWppr4d1ksQBKSatEg1aTFqgLVPr01ERNTfMfnZOEZwPKpodKlh92g9th5rwLajDaixewCoLbdjcqyYddIgnDQ4DROGpKJwoLXb3RqIiIgo+TAE2yo4ZXIMKYqCyiY3dpQ1YNvRRmw7prb0Vga+1pdEAQUDLLigaABOGpKGCYNTMXqQFQatFOOSExERUX/GEGyrBDJHxboUSSHYh3d7WQN2lDVg4+5yHHzvGKptauAVBGBUtgVnF2RhwuBUnDQkDWNzUmDUMfASERFRz0ruEKwo6mQZHCO4x/n8MvZX27GjrAHbjzViR1kDdpQ1oikwq5hGFDAsVYtzRw/A+NwUjBucirE5KRySi4iIiPpEcicOdyPgcyVkCFYUBVuPNuD9zUdhc/uRYdYi3axDhkmnLs06pJvUZapRe0ITMbh9fuw+bgu18G4/1oidxxvh8qrDd+k1IopyUnB5cS7G5aZifG4qCgZacGDvbhQVFfXUWyYiIiLqtOQOwbbEmzK5wenFP0qO4a3vjqC0vBEGrYhMsx61dk/E2LXhBAFIM6ohOTMsHEeGZi3STeq+apsb24+pLbvbyxqxp6IJvsAMDFa9BmNzUzD/tDyMy03B+MGpGJllhkbiTWtEREQUPxiCgX7fEqwoCn44VIe3vjuMj7eVw+WVMX5wCpZcMR6XFeeGxql1evyoc3hQa/c0L+0e1Dq8gaX6/HCtAz8erUet3QOvX2nzuplmHcYNTsV5o7MxfnAqxuWmYGi6iVPpEhERUdxL8hDcv6dMrrV78P7mo3j7+yPYW2mDRa/BnMlDcN2pwzB+cGqr4406CUadEblpxk6dX1EU2D1+NSCHPVKNWowfnIqBKXoIAgMvERER9T9JHoL7X3cIWVbw7f4avPXdYazZUQGPX8bkYWn436snYPaEnB6dHUwQBFj0Glj0GgzNaH/2MiIiIqL+JLlDsL0SECTAmB7rknSostGFdzcdxcrvj+BwrQOpRi3mnz4M804ZhtGDOFsYERERUVckdwi2Vaj9gcX4vGnLLyv4cncV3vruMD7bWQm/rOD0kRm4b0YhLho3iBNGEBEREXVTkofgqri8Ke5YvRPvfH8E7/5wBGUNLmRZdLh96gjMO2UYRmSZY108IiIion4vyUNwRVzdFFfR6MLif2zHmp/UG/amFWRj8aVjcUHRQGg5xBgRERFRj0nyEFwJDBwf61IAAD7ZcRyL3tsKp9ePu88bhbmnDMWQdN6MRkRERNQbkjcEyzJgj313CIfHhyc/+glvfXcEJw1Oxf+bV4z8bEtMy0RERESU6JI3BLvqAdkb0xC89Wg97nm7BAdq7Ljr3Hzce2EhdBp2eyAiIiLqbckbgoMTZcQgBPtlBf/3xT489+luDLDq8bfbT8cZ+Zl9Xg4iIiKiZJXEITgwUUYf3xh3rN6Je1eW4LsDtbhkQg6WXnESUk3aPi0DERERUbJjCO7D2eJW/1iGR/6+DbKs4DfXTMRVkwdz2mEiIiKiGEjeEGwPhuDebwlucnnx63/swPtbjmHysDT8v7mTMCyTIz8QERERxUryhmBbBSDpAENqr15m06Fa3LOyBMfqnLjnwgLcfd4oaDjmLxEREVFMJXEIrlS7QvRSdwSfX8bzn+/FHz7fg8HpRry78AxMycvolWsRERERUdckeQjuna4Qh2rsuGdlCbYcrsdVkwfj8cvGwWrgzW9ERERE8SK5Q3DqkB49paIoeG/zMfz6H9shigJ+f90kXDoxt0evQUREREQnrsMQLMsyHnvsMezatQs6nQ5LlixBXl5eaP9HH32Ev/zlL5AkCYWFhXjssccgiv2gz6utAhg8ucdO1+Dw4pG/b8M/t5XjtBEZ+O3cYgxOM/bY+YmIiIio53SYVteuXQuPx4OVK1fivvvuw7Jly0L7XC4X/t//+3/461//irfffhs2mw3r1q3r1QL3CNkPOKp7bHi0b/ZVY+bvvsQnO47jwZmj8befnc4ATERERBTHOmwJ3rRpE6ZOnQoAKC4uxvbt20P7dDod3n77bRiNauDz+XzQ6/W9VNQe5KgBFPmE+wTLsoJn1+zCi1/sw4hMM97//87EhCFpPVNGIiIiIuo1HYZgm80Gi8USei5JEnw+HzQaDURRRFZWFgBgxYoVcDgcOOuss9o9n9vtRmlp6QkWu3tcLhdKS0uhr9uDkQCO1nvQ1M2yKIqC//uuBh/ubMRFBVYsPCUT2qZylJaW92yhE1iwPig+sD7iC+sjvrA+4gvrI7701/roMARbLBbY7fbQc1mWodFoIp4vX74cBw4cwO9///sOZ0DT6/UoKio6gSJ3X2lpqXrtvWUAgCGjJwN53SvLs5/swoc7G3H72SPwy0uKOPNbN4Tqg+IC6yO+sD7iC+sjvrA+4ks810d74bzDPsGTJ0/Gl19+CQAoKSlBYWFhxP7FixfD7XbjhRdeCHWLiHu2E5st7sX/7MMf1u3FvFOGMgATERER9UMdtgRPnz4d69evx7x586AoCpYuXYrVq1fD4XBg/PjxWLVqFU4++WTcdNNNAIAbb7wR06dP7/WCn5DQlMldvzFuxYZDeObfO3HpxFw8deVJDMBERERE/VCHIVgURTzxxBMR2/Lz80PrO3fu7PlS9TZbJaA1AXpLx8eG+fuWo1j8j+24sGgAfnvtREgiAzARERFRf9QPBvTtBbaKLneF+GTHcdz/7lacMTITf7h+MrRScv7oiIiIiBJBciY5W2WXukJ8tacKv/jbFpw0OBUv33gyDFqpFwtHRERERL0teUOwObtTh/5wsBZ3/HUTRmab8fotp8CsT96ZpomIiIgSRZKG4IpOtQRvP9aAW177HoNSDVhx22lIM+n6oHBERERE1NuSLwT7vYCztsMQvLeyCTe++h1SjFq8cftpyLb2g5nwiIiIiKhTki8E26vUpaXt7hBHah2Y/+eNEAUBb9x+Ggan9ZPxj4mIiIioU5IvBNsq1GUbLcHHG1y4/s8b4PLKeOP2UzEiy9yHhSMiIiKivpCEITjQEmxuPURard2DG17ZiFqbB3+59VSMGZTSx4UjIiIior6QfEMdhFqCI0Nwo8uLG1/diCO1Drx+y6koHprW92UjIiIioj6RfC3BoSmTm0Oww+PDra99j53lTfi/G6bgjPzMGBWOiIiIiPpC8oVgWyWgTwG06s1ubp8fd67YhM2H6/C7eZNw3piuzSRHRERERP1PcnaHCLQC+/wy/uutLfhqTzX+d84EXDIhJ8aFIyIiIqK+kIQtwVWAZSBkWcGDq7bikx0VWDx7LK49ZWisS0ZEREREfSQJQ3AFFHM2fv3hDry/5Rjum16IW88eEetSEREREVEfSsIQXIlNtTqs2HAId04bibvPHxXrEhERERFRH0uaPsH//L/nUb57L/baC/BTvRfzTx+GRRePgSAIsS4aEREREfWxpAjB9qYm7Fy3FoCMBhhh8mTggcvHMwATERERJamk6A5htlpRfNlVyMgvgggtfD4NynbXxbpYRERERBQjSRGCAeCC+Tfj9AW3wmSRAO8RrHllK9wOb6yLRUREREQxkDQhOGj4aWdCVprgaGjCVyv3xLo4RERERBQDSReCx549HQBgqf83dm08jn2bK2NcIiIiIiLqa0kXggeNLAAApFWWIHWAiP+8uQv2BneMS0VEREREfSnpQrDWYEBaTg7qTXpYlQ/h9fixbsVOKIoS66IRERERUR9JuhAMAHnjJ6HOYoBl/TqccWU+Dm2vwU9fl8W6WERERETUR5IyBOcUjIYsiLDWyrBkHcSQMen4etVeNFQ5Yl00IiIiIuoDSRmCcwvHAADqTHrsXvUazr+xCKIo4LPXSyHL7BZBRERElOiSMgSnDcqFwZqCYwOtMHy5GdYMA6bNK0T5vgZsWXMo1sUjIiIiol6WlCFYEATkFoyGIzUVg467sXfLOhSeOhD5k7Px3eoDqDrSFOsiEhEREVEvSsoQDAA5o0bD7fTALYrYveo1CIKAc68fA4NZi7Wv/QSf1x/rIhIRERFRL0neEFyg9gveW5AO85clkGUZBosW599YhNoyOzZ+eCDGJSQiIiKi3pK0IXjQqEJAEOAaNQoDqrzY/cOnAIC88ZkYNzUXJWsPo2xPXYxLSURERES9IWlDsN5kQtaQYdBYsuEXgH3v/TW078w5o5CSZcTa10vhcfpiWEoiIiIi6g1JG4IBIKdwDGqOHMGRwjSkfLUVsiwDAHQGDS68eSxstS58/e6eGJeSiIiIiHpacofggtFw2W2QzzodWbU+7NzwcfO+/FRMuigPpd+UY39JVQxLSUREREQ9LalDcG7g5rjsMafDJwIH3l8Rsf/U2SOQNdSC/7y5E45GTyyKSERERES9IKlDcEbuEOhNZjQcr8LRMRlIXb8j1CUCACSNiAtvHgu304f/vLkTitJ7s8kpioKD26rx0R9+xJcrd8NW5+61axERERElu6QOwYIoYtCoQpTv2Qn9jPORWefHji8/iDgmc7AFp1+ejwM/VmPnt8d7vAyyrGDPDxVY+dT3+Ocft6LqSBN2fHEMKx79Bl++zTBMRERE1BuSOgQDQG7hGFQfOYzxs2+GVwIO/eNvrY6ZeMFQ5Bak4at3dqOx2tkj1/X7ZZR+U4a3Ht+INX/eAb9XxgU3FeHGpWdi/hOnY8xpg7DjS4ZhIiIiot6giXUBYi2nYAwURYar3oajY7OQsX4n/H4fJKn5RyOKAi64qQhvL/kOn/2lFFfcOwmCKHTrej6PH6XflGPzmkOw1bqRNdSCi342HiMnZUMMnDMly4jzFhRhysXDselfB7Hjy2PY8fUxjDt7MCZflAdLur5H3jsRERFRsmIIHjUaAFC+ZxdMM6cjfflb2P6f9zDxgrkRx6VkGTH12gJ8/tedKPnsCCZNH9al63icPmz/8hhKPjsCZ6MHg0am4pzrRiNvfCYEIXqgZhgmIiIi6h1JH4INFgsycoegbHcpLvjZnTjw27dw9IO3W4VgABhzRg4O/FiNDf/Yh2FjM5A52NLh+V02L35cdwTb1h2F2+HD0LEZmDIzD7kFaW2G35YYhomIiIh6VtKHYEDtErF/83ewpg/EsZMGIGPDbvi8Hmi0uojjBEHAufPH4O0nN+LT137CNYtOhqSJ3q3a3uBGyaeHsf2rMvjcfoyYmIUpFw/HwOEp3S4nwzARERFRz0j6G+MA9eY4Z1MjGiqOwzJzJtKaZPz42cqox5pSdDjvhjGoOWrD9x8daLW/sdqJL/62Cyt++S1+/OwIRk7MwrxHT8WsuyacUAAOFwzDvIGOiIiIqHvYEgx15jgAKNuzE5OvvAN7n/0ryj98F5i5IOrxIyZmo+jMHGz+5BDyTspCTn4q6o7bsenfh7D7uwoIotp1YvKMYUjNNvVaudkyTERERNQ9DMEAMocOg9ZgRPmenRg79TwcmzAI2Rv3wutxQaszRH3N2dcU4OiuOqx9/SdkD7FgX0kVNBoRE84dguLpw/o0gDIMExEREXUNu0MAEEUJOaMKULZ7JwAgddYspNgVlKxpPWZwkM6owYU3F6Gx2okjO+swZWYeblx6Js6+tiBmobOtbhJfv7MHLps3JmUiIiIiikcMwQE5BWNQdegAvG4XJl/xMzh1QMWH77X7mtyCdMx79FTcuPRMnH55PoxWXbvH95XwMDz61EHYuu4I3lj8LbasOQyf1x/r4hERERHFHENwQE7BGCiyjIr9e2GypKGseDAGfn8AHrej3ddl5lqgN8Znr5KULCPOv7EIc391KgaOSMU37+/F3x7biN3fH4ciK7EuHhEREVHMMAQHhG6OC3SJSJ91CSxOBSUfr4hlsXpE5mALLv3FRFz238XQmzT49JWfsOqZH3Bsd12si0ZEREQUEwzBAaaUVKQNzEH5nl0AgJMv/xkceqDyow9iW7AeNLQoA9c+fAouuLkIjkYPPvjtFvzzha2oO26PddGIiIiI+hRDcJicwjEo37MTiqJAb7SgfPIwDNp0CB5n+10i+hNBFDDm9BzMf/x0nH7FSBzbXYe3nvgOX/xtFxyNnlgXj4iIiKhPMASHySkYDXt9HZqqqwAAWbMvg9mlYPM/X41xyXqeRidhyszhuOGJMzB+ai52fF2GNxZ/ix8+PgivhzfPERERUWJjCA6TWzAGgDppBgBMnnUL7AYBNR99GMti9SpTig7TrhuN6xafiiGj07Hxw/14c/EGlH5TDpk3zxEREVGCYggOkzVsODQ6PcoDN8fpjCYcPzkPOZuPwOlojHHpelf6IDNm3TUBV943GeZUHT7/ayneWfo9jvxUG+uiEREREfU4huAwkkaDgSNHhW6OA4ABl14JowfY/I9XYliyvpNbkIarHzoZM24bB4/Thw+fL8Hq50tQc8wW66IRERER9RiG4BZyC8eg4sA++DzqTWLFM2+AzSig/uOPYlyyviOIAgpOGYj5j52Os64ehYqDjVi55Dt8/tdS2OvdsS4eERER0QnrMATLsozFixdj7ty5WLBgAQ4dOtTqGKfTiXnz5mHfvn29Usi+lFMwGrLfh8qD6nvR6U2oOHUkckvKYG9Krq4BklZE8YXDcMOTZ2DCBUOx67vjeGPxt/jib7tweEcN/F451kUkIiIi6pYOQ/DatWvh8XiwcuVK3HfffVi2bFnE/m3btmH+/Pk4cuRIrxWyL+UEbo4L7xIx6LI5MHiBzR/8OVbFiimDWYuzry7A9b8+HSOLs7FzQzlW//5HvHL/V/j3S9uwc0M5nDYOr0ZERET9R4fz/W7atAlTp04FABQXF2P79u0R+z0eD/74xz/iwQcf7J0S9jFLegZSsgegbPdOTLlE3VY8Yz42mZej8V//AhYkxvvsjtRsI6bfOg4+jx9Hd9XhwNZqHNxajX2bqyAIwKD8VIyYkI0RE7OQNtAU6+ISERERtanDEGyz2WCxWELPJUmCz+eDRqO+dMqUKV26oNvtRmlpaReL2TNcLlenrm0ekIPDP22POPZo8VDkbzyMLd9/C4MlrRdL2U9ogEGTgYGTMtBU6UX1fjeq99vxzfsN+Ob9vTClS8gaaUDWCANSc7QQRKHVKTpbH9Q3WB/xhfURX1gf8YX1EV/6a310GIItFgvs9uZpdWVZDgXg7tDr9SgqKur2609EaWlpp67tPPlUrNvxI4YMzIY1I0vddu0C6Nc/hartn2PSLb/s7aL2L2MBnKuuNtY4cXBrDQ5uq8bRkjoc3mSHwaxF3kmZGDEhC0PHZkBnUH9/Olsf1DdYH/GF9RFfWB/xhfURX+K5PtoL5x2m2cmTJ2PdunWYNWsWSkpKUFhY2KOFi0fh/YKtp6kheOKF8/Cd9WnY/r0GYAhuU0qmERPOG4IJ5w2Bx+nD4Z9qcWBrFQ5urcauDcchagQMGZ2OEROy4DVyZjoiIiKKjQ5D8PTp07F+/XrMmzcPiqJg6dKlWL16NRwOB+bOndsXZexzA0aMhKTVonzPLhSedhYAQJI0qDljNIZ+VorG2uNIyRgU41LGP51Rg1FTBmDUlAGQ/TLK9zXg4NZqHPixGl+8tRsAsPvT7zBiQhZGTMxG1lALBKF1twkiIiKintZhCBZFEU888UTEtvz8/FbHrVixoudKFWOSRosBI/JRFpg5Lmjo5fOgW/NrbH7v/3Duzx6LTeH6KVESMbgwHYML03HmnFGor3Bg46c/wXFcxPcfH8T3/zwInUFC1lArsoZakD3UiqyhVqTnmCBJHM6aiIiIelb3O/cmuNyC0fhxzb/g93khabQAgPHnXoUNqU/A+clagCG42wRBQPogM/JOtqCoqAjOJg8O7ahBxf5GVB1pwk9fl8HnUccgFjUCMnMtzcF4iAWZQyyhfsVERERE3cEk0YacgiJs+uc/UHXwAAaNUvtBS5IG9WcWYdgn21FXdQTp2UNjXMrEYLTqMOb0HIw5PQcAIMsKGiodqDrShOrDNlQdacKBkmqUri9XXyAAaQNMyBpiiWg1NqXoYvguiIiIqD9hCG5DTsFoAEDZnl2hEAwAeVfNh/Svh7Fl1Z9w/l1LYlW8hCaKaktx+iAzCk9RtymKAnu9G1VHbKg+0oSqw02oONiIvZsqQ68zpeoCgdiCrCFWDByRAmuGIUbvgoiIiOIZQ3AbUrKyYcnIRPmencDFl4a2jz3rMnyT/ijcaz4H7ophAZOMIAiwpBtgSTdgxISs0HaX3Yvqo2owrj6ithof/qkWiqwAAKyZBgwuSENOQRpyC9KQmm3kzXdERETEENyenILRaggOI4oiGs4eh7yPfkRt+UFk5AyPTeEIgDql85DR6RgyOj20zefxo6bMjuP7GlC2tx4Ht9dg54bjANTW4tyCNOSOUkNxRo456kQeRERElNgYgtuRWzAGezZ+A3t9HcxpzSFr5FULgNU/Ysuq/8MFv1gWwxJSNBqdhIHDUzBweAomXjAUiqKgrtyBsr31KNtTj7Ldddj7g9qNQm/WhAJxbkEasoZYIHI0CiIiooTHENyO8EkzRp1yemj76NMuxteZi+D99D/AL2JUOOo0QRCQkWtGRq4Z46cNhqIoaKx2qYE4EIwP/FgNANAaJOTkp4ZaiwcMT4GkYSgmIiJKNAzB7RgwMh+iJKF8z86IECyKIpqmTsDwf2xG1dE9yB5SEMNSUlcJgoDUbCNSs40oOlMdkcJW50bZ3jqU7WlA2Z56bPhgPwBA0ooYNDIl1Fo8cGQqtDoplsUnIiKiHsAQ3A6tTo8Bw0eifM+uVvtGzbkJ8gebUfLunzD93mdjUDrqSZZ0PQpPGYTCU9SZAJ1NHpTvbQi1Fv/w8UEoCiBKAlKyjDBatTCl6GFK0cGUoq4bU3SB5zqYrDpIWrYgExERxSuG4A7kFIzBtnVrIPv9EKXmFsCCKRfiywE6yJ99BdwbwwJSrzBadRg5KRsjJ2UDANxOH8r31qN8bwMaq51wNHpQc8yGozs9cDt8Uc+hN2lgtDYH44iQHNxm1cGcqmM/ZCIioj7GENyBnMIx2PLv1ag+cggDho8MbRdFEY6pxch77zscP1SKQXlFMSwl9Ta9UYPhJ2Vh+ElZrfb5vH44m7xwNHrgaPTAGVg2P9yoPmqDo9EDj7N1YBYlAakDTMgYZEJ6jhnpg0xIH2RG2iATu14QERH1EobgDuQGJ83YvTMiBANA4dW3wPved9h/0wL4rrweWRfPhr6ggOPQJhmNVoI1Q+rUxBw+jx+Opsiw3FjtQt1xO2rK7Nj/Y3VojGMAsGYYkJ5jCkweoobkjEFmGCza3nxLRERECY8huAMp2QNhSk1D+Z6dKJ4xK2LfqEnn4h93z4T8wSdI/b+X0fTiy9Dl5cE6YzqsM2bAMH48AzFF0OgkpGQakZJpjLrf75VRX+VAXbkDdcftqDuuLst218PnlUPHGa3a5mAcFpAt6Xr+zhEREXUCQ3AHBEFATsGYqDfHAcDldz+HrXO34smPH0Du5qO48pgfWa+9jpqX/wxNTg6sF16IlBnTYZw8GYLEr7apfZJWRGauBZm5lojtiqygqdYVCsV15WpA3ru5Em57cxcLjV5S+xiLAkRJgCAKEMXIpboOCKKoHiOoXTKabE04+u2OqK8RRQGCFHxd9PO2viZaXLPluaKdB4EyCZHLKK8Plju0jeGfiIi6gCG4E3IKRmPfDxvgbGqE0ZrSav+E7Al49fq/438L/hf/3573MPmaAvzKPxOGr39E/cqVqFuxAlJmJqwXXADr9Okwn3YqBJ0uBu+E+itBVEelSMkyIm98Zmi7oihwNnmbW43L7XA0eaDIChQZkGUFiqxAlhXI/sC6T4ZPVqDIvrD9gNvphauuEYpfiXhd6yUiumzEDUEN3aGwHAjRgiRAFBA9eEcN3GjzQ0CboTzsNVq9BKNFC71ZC6NFC4NFpy7NWo4YQkQURxiCOyG3MDBpxt5dGDnplKjHmLQmPHbmY5g6ZCoe++YxXC+/jPv/635c/b/PwP7VV2j69FM0fvQR6t95B2JKCqznnasG4rPOgmiM/tU4UUcEQQiNNDG4ML3jF7SjtLQURUWdu8FTURQoCtoPzH4FihIM34h+nF+BrCgR5wkeK8uyuh5xntbXab4W2jym1TUDQT7iHGHn8ntlyP7m0B/1mq3OGXj42v6AoNVLMFi0oVBssGhbPNeFnrttfvi9MoMzEVEvYQjuhEEjCyAIIsp372wzBAddMOwCTMiagEfXP4olG5fgy2Nf4vFzH8fgiy+G7HbDvv4bNH36KZo+/xwN//gQgtEIy7RpsE6fDsu550CyWNo9P1E8EAS1OwJEAezkE8nvk+Gye+GyBR52L5y2aM89qK90wGXzwuPyRz3XelRCa5Bah2azDgaLRg3NoRbnwMOs5SyHRESdwBDcCVqDAVl5w1HWRr/glrJN2Xjhwhfw1s638Nsffos5H87BE2c+gXOGngPr+efBev55ULxeOL7/Ho2ffoqmtWvR9MknELRamM88E9aLZ8J64XRIFnMvvzMi6mmSRoQ5VQ9zqr7Tr2kZnJ02Lw7uPYw0ayZcNh+cdk9oX32FA06bF942gjMA6AxSKBCHd8do3fLc/JA4VjURJRmG4E7KLRiD0q/XQZb9EMWO275EQcT8ovk4bdBpeOirh3D353fj2sJrcf8p98OoMYYCr/nMMzHo0UfhLClB05pP0bRmDWxffIHjhsdhPf98pFx2KSxnnQVByyGxiBJVtODsNdWgqGhEm6/xewPBOaKl2dO65dnmQd1xO1w2L7zuTgTnToRmo0UHvVnD4ExE/RpDcCflFIzGj59+jNqjR5A1bHinXzcqfRTeuuQt/H7L7/H6jtfx3fHvsGzaMozLHBc6RhBFmCZPhmnyZAx46EE4t2xBw+rVaPr4X2j8+GNI6elIuXgmUi69FMbiYt4FT0SQtCLMaXqY07rQ4hwIzsHuGE6bF+6w0Bx87mj0oLbMDqfdC197wdmo6aCPc3Bd7evM4ExE8YQhuJOCN8eV7dnVpRAMADpJh/tOvg9nDz4bj3z9CG745w34+aSf45Zxt0Bq0aosCEIoEA96+GHYvl6Pxo9Wo/6991H3t7egHToUqZfORsrsS6Ef2XYrERFRS90Jzj6vHy6bDy67p42+zeq6o9GDmjIbXHZfu8FZb9K06N8c2Z/ZGLg5MHSMWcNpxYmoVzAEd1LaoFwYLFaU79mJCRdc1K1znJZzGt6/7H08ueFJ/G7z7/DV0a+wdOpSDLYMjnq8oNOF+hD7bTY0fboWjas/RPX//QnVL7wIw7hxSL3sUqTMmgVNdvaJvD0ioqg0WgmWdAmW9C4EZ4+/OSS36Ovc/NwDe70bNcdscNm88HnkNs8XHpyjdc1o2QqtNzE4E1HHGII7SZ00Y3Sbk2Z0Vqo+FcunLce0IdOwdONSXP3h1XjktEcwe+Tsdrs5SBYL0q68AmlXXgFvZSUaP/4YjR+uRsXTy1DxzP/CfMYZSLl0Nm+oI6KY0+gkWHQSLOkdTyUe5PX4Q63KbYVmp80LW70b1UcDwdnbQXBuFZqj93fWm9jiTJSMGIK7ILdgDA5s+QEuuw0Gc/eHMhMEAZflX4bJAybjka8fwSNfP4Kvjn6FX57+S6TqUzt8vXbAAGTefDMyb74Z7n370LB6NRpXf4TyRQ8331B36WxYzj6bN9QRUb+g1UnQZkiwZnQjOEcZfi78eTA4O21e+NsJzsGbA/WmQEgOtEDrzVo02OwQG8qhNwdCdOChM2kgirxPg6g/YgjugpwCtV/w8b27MXzi5BM+3xDrELx60at4ZdsrePHHF7GlaguWnr0UpwxqfyzicPr8fAy45x5k//d/w7mlBA2rP0TTv/4dcUOd5fwLYJpUDNHMFmIiShw9EZydNg9cdh/cjsA2hxcum/q8scoJl8MLt8MHKMCeLxtbn1AA9EaNGo4Drc8RITriuXpzoMGshd6ogcDwTBRTDMFdMGhUISAIKN+zq0dCMABoRA3unHgnzsw9Ew9//TBu++Q2XDHqCtx20m3IS8nr9HnUG+omwTR5UtQb6qDRwDh+PEynnqo+GIqJKAl1JzjLsoLtP/6EYYNHwGX3wm33hYanC3/utjeP5ex2+NTw3AZBAPRhoTj4CH/eep8WOoPEEYKIeghDcBfoTSZkDRmGsj07e/zcJ2WfhHdmv4Pfb/k93tn1Dv6x7x+Ynjcdt590O8ZkjOnSucJvqJPtdjg2b4Hju+/g+O471LzyCmpeeomhmIiok0RRgNYgIm2AqUuvk/0y3E4fXDa1NTnY0tw6RAeGpSu3w2VvfyIUQRRgCLYmB/oyBwOyGpY1EV02gkFaq2d4JmqJIbiLcgpGY8/Gb6DIMgSxZ2+iMGlNeOjUh3DbSbdhxU8rsHLXSnxy8BNMHTwVP5vwM0waMKnL5xTNZlimng3L1LMBQA3FW0qaQ/GrrzIUExH1AlESYbToYLTouvQ6v1+ObF22e+GK8tztCPR3Ptbx0HSiJEQE5VbB2RS2L6wLh0YrMjxTwmII7qKcwjHY9vka1B0vQ0bukF65RpYxC/dOuRe3nXQb3t75Nt746Q3c+K8bMXnAZPxsws9wVu5Z3f5HSTSbYTn7LFjOPgtAB6F43LjmUDx5EkMxEVEfkCQRphQdTCldDM9eWe3THArLvuhdNuxeNFa74DrUBLe9/VE2JI3YZuty1C4cJi0MFg002o5nViWKNYbgLsoN3BxXtntnr4XgoBRdCu6YcAduKLoBf9/7d7y2/TXctfYuFGUU4faTbscFwy5oNdlGV3UYil97DTUvvxwRinX5IyGlpEJKsUK0pkBKTYFktUIwmdhiQEQUI5K29fTbnaGO69zy5sDILhzB5/WVjlCwln1Km+fUaMWwFmWNelNgi5sDo4VoScNh6qjvMAR3UUbuEOhNZpTv2Ynx517YJ9c0aU2YXzQf1xZei4/2f4RXt7+K+764D8NThuPW8bdi9sjZ0Eo9MxRaZ0IxfG3c7KHRQLJaIaWkQExJCSytkAJBWbSq26QUK8SUVKCmBh6jUT3WauVwbkREMdA8rnPnw7OiKPB55Ih+zaEuG6EwHewP7VX7Ozt8cNu8kOW2w7NWL0VpWW4x0oZZg+pjLhz0VffE26ceUH2k/fqwpBuQNaT7Q8v2FobgLhJEEYNGFaJ8d8/fHNcRraTFlQVX4rL8y7D28Fr8edufsfibxXjhxxdw87ibcVXBVTBqjD16zVah2OmEr6oK/oZGyE2N8DeqD7mxEf7GJvgbGyA3NsHfpK57y8pCx8DrbXX+fWHrglYLwWCAoNdD1Osh6PUQDHqI+mjb9BD0Bgh6XfN+Q3Cbug5BBBQZUBQosqKuy7K6LsuAIkORZSCwr3k9+Dz8uLB1nx+K19v+w+cFvF4ong6O83oBQVDfe2ceuvB1XcQ+hK2Lej0EnV49Rq8LPNdF3xZYwumE4vNB0PCfBSJqnyAI0OolaPVdG2lDURR43f5Wo2xE7/vsg63OpoZqu0/9dzjMVtT19NuiE9BefYgaAXc+f27cjanN/+26IadgDDa+vxIepwM6Y9fuFu4JkijhouEXYUbeDKwvW4+Xt76MZd8tw0tbX8INRTdg7pi5SNGl9Mq1RaMRumHDuvw6RVGguFzwNzZBbmyAv6kJh7bvQG5aKvwNjfA3NkBxuSC73FDcbihuF2S3R93mdkFxe+BrbITscUMJHCO7g8e6e+GddqCtkKrRtNomWixthlkEAmcoEIcH5LAALTscgW2etgO1x6MG+BOwEwAkCYJOB1Gnaw7JgaAshoVmdamFqNOHbWsRuPXqOVpuE8PPq9VB1Le+FrvWECUeQRCgM2igM2iAzM6/TpEVeNz+UMvygf0HMHz4iN4rKHXJwYPt14cpVRd3ARhgCO6W3MIxUBQZx/ftxbDxE2JWDkEQcPbgs3H24LOxuWIz/rztz3h+y/N4dfurmDt6Lm4YewOyjFkxK184QRAgGI0QjUZg4AB1o9GI1KKiEz63oihqOHS5moOxywVFUdQRPAQBEER1YHpRBMTA3c6BdQiCelxwXYh+nCAI6rk0mrgNaIrfr75/jweyx6P+XALP1Q8OgW2ewDFuN5TAtoojR5CVlho4NvA6b+AYjzf0gUPxeOBvbIw8rzfsNT0QxoHANwNhgTsilAcDty4skAcDd4ttzcG97ZZxUa+Leq14rmuiZCKIgjopiVEDwIgahw4DR/ROYw91Xa2rf9YHQ3A35IwaDQAo37MzpiE43OSBk/HCwBews3Yn/rztz3h1+6t4o/QNXDnqSkzIngCv7IXH71EfsgdevxceWX3u9rvb3R++3eP3QBIkGDVGGDVGGDSGqOvtbpPUbZXuSgxwDggdJwrduyFCEAQIej2g1yPZ70cWJAmCyQSYTF3+WVSUliK7hz6UwOuNDOFut/rc7YHi9TS35Ae3hYfyYOCOEtQVj7v5GJcbvsamwLYW1wq0qp8wUYwewsNbwVsGboMRotkM0WRSl2YTRFP4MnyfGaLJ2OPDLRIRUccYgrvBYLEgI3dIr0yacaLGZIzBs+c8i4PFB/Hajtewas8qvL3r7ajHagQNdJJOfYg6aCVtaD243aQxIU2fBp2kg1ZU98uKDKfPGXrUuGrg8rlCz10+F1x+V+cK/GPzaqo+FdnGbAwwDUCWMQsDTANaPc8yZkEndW3YIOpbgiAAOh0kXWzrSfH7A8E5LFx7mluzQ+Ha62m9rWXgjgjlkYHbb2uCUlPTHMBdLrX7iquTfwMABJMpEIybAzMUBUcHDIgMzYGlZDZDMJkgRdknms28yZSIqBMYgrspp2AM9m/+Tv3KPQ6/Lh2eOhyPn/k47pl8Dxo9jVFDbndbXjtDVuRWwTi07nfB4XPgwOEDSBuQFtpe56pDlaMKVc4q7G/Yj2pHNXxK65Eo0vXpyDJlYYBxALJN2aGgnG3MRrZJXc80ZkIrMggkE0VR4Ff8oaWsyPBLfsgGQNZr4VdEKIoOfsUEWZFDj5avCd/emWMirqf4IQoiNKIGGlmA1u2Hxu2DxuWD1uWDxuWF5PJCdLohujwQnW4ITjdEpxtwugC7E3A41fWaGrhr6yDb7ZAdDsh2e6e7mQhabdTw3KqFuq19LZaCwRCX/84REZ0IhuBuyikYjR1frEVDxXGkDcqJdXHalG5IR7ohvc+vKwoiTFoTTNq2bxwsdZaiaEzbX7/LiqwGY2cVKh2VqHZWo9JRiSpHFSqd6nJP/R7UOGvgV1rPlGTUGKERNNBKWmgEDTRii3VRq4aVTqxrRW1oXRIlSELgEbYeDD+iILbaJ4mB/UJgf9g+QRAgK3LoPStQ1OcKIENW+zxDCS2Dx0R9riiQIXcr5FVWViLDldGl0NfyPJ29Xk+Hz+DPoF8RAJgCjyhEiNBJusDvogEawQyTX4LJK8HsEWD2SzC6BZi8AowewOAFDB7A4Jah9wB6twydR4bOZYfO0whthV8N4m41jGtcXoi+tidJCKeIAmA0QDEZIBiNgMkIwWQMC8tmSBZ1qbFYoTGbobGkQGOxQgp2AQkP3SYTBCnZOy8RUawxBHdTbqE6aUb5np1xHYL7M1EQkWnMRKYxE2MyxrR5nF/2o85dFwrIwdDs8Drglb3wyT74FB98sg9evxc+xQev7G3eJ/tg99lD6+Hbo61HC9yJQiwXIUIMBXUBghrwxbDtgeAeDP7BR7TtLY/RibqIY7pyrpbn6+xrO1OuE3lPLZ8riqL+rgR+58IfUX+3lMDvZdjvqU/24XjlcaRlpLX6XQ0/xil70RTlGpHHK/DJMnwy4JMBr6zAJwN+RYTkF2DwQA3RoaXSxjYXjB4XDN56GNyAwa60OEYN4p3l0Qpw60V49CK8egkevQSvXgOfQQOfUQu/XgufQQvZqIPfqINi0EM26iGb9KFADqNB7UpiNkHSGUIfXsMf4R9kgx+AW+4zSAboNXr1HgbJCI3IGyKJkgFDcDdlDh0GrcGIsj07UTT1vFgXJ6lJooQsY5Y6EkYXhtzpLkVRQq2RfsUPv+wPrcuKDJ/sU/eHbQ8eJysyfIovdFwwUAsQQt1TREGM+lwIjFwR3BfaFvYcgtqC2Cq4thVoRSm0vmvnLowdO7b3f4DUKaWlpSjqgRsV2xL8HQ0G9mhBvM1gHXacTfaiPnic1w3Z6YTicEJxONSuHQ4XBGfwoXYBCXYH0Tg9kFxeaFw+aNxemBw+aGvd0Lr90Ln90LtliJ1s4PeJgFMHuHTNS7tOiHiurgtwaQGnHnBp1W0eLeCRBPg0gEcDyBoJYmBsco3BCI3OCFkRkHYoDQbJAIMm8JAil8Ebf8MDtUFjgF7Sh24ADn998EMhEcUGQ3A3iaKEnFEFKN+zK9ZFoT4WbBmUEmwsCv5nnFxEQYQoiT0222RvUBRFvdkw0Cc6tLTbIdvVdZ/dBp+9CX67HX5bE3x2W+g4xeFU+1LXuqDYHYDTBcHTmeZqPwAPgKbQFlkEfBoRPo0Ar0aAVwN4JcAjKXBLMjyB5y4N0CSpYdqnATwSQseGv86rUZ8LuuahAEW9HqJOD8lgVB86AzRGI3QGM7QGE/R6EwzBMN1WCA8P3YHteknPv2+iKBiCT0BOwRh8/+F78Lpd0Oo7P2MOERF1TBAECAYDRIMByMjokXMGJ5+JCNQtRg+JNnxf1bEyDLJaI0cOCRspxO92Qfa44Xe5INvdoePgVofrU8N3tGZtP4DOjSQiIxiew4J0IHg3agCfBHiCQbvFMYpWA1mnAXTq7JIIG1dbNOgh6gyQ9GoA1xpM0BhM0OiN0BlN0Bmt0BvM0JksMBgsMGjbDuK9ecM1UU9jCD4BOQWjIfv9qNi3F0PGjo91cYiIqAOCVgspNRVSamqXXldVWoqBJ9A9RVEUdWbHiMlr2hm6r41xsv0uF3xuJ3wuJ3wuB/xuN/xuJ+TgLJse9Xg4m8O34PFB8PkheZwQFGe330OQVwKcGqBBat3a7deKgYcERasJhW9BqwV0OkCvhaDTQ9TrQsFbNBih0RuhMRigMZjUlm+jGTqDCXqjFXqTBXqjBQZjCgymFBiMFiiyDFnu3I2d1Ps6Ux9iHI6HzhB8AnIKxkAQRLz39K8xZOx45J1UjOETJiFzaB6/eiIiohBBENRZCGM4fraiKIDP1zyjpDs8fDcHb8Wthm2P2wGPwwavyw6vy9EcvF1OKG43RLcLGrcLoscNvdsDBKZ1F9xeCC4vhEYfRJ8HoscJySdD8snQeGVIXcyu3sDDFrZNAMDOiPGjo/qoS5Fw2rclkKT4ip3xVZp+xpSSimseXYI933+LQz9uwRcrXsEXAMzpGcgbPxF5Eycj76RimNP6fogyIiKicIIgAFptaBzpWAlNZON2w+92w+O0weVsgsvRBLdTDd3q0hEI32oA97td8Ltc8LudcNjtMJli9x4oksPRfn0YBg+BEIddZRiCT9DQcRMwdJw6dXJjdRUObduCQ1tLsL9kE376ah0AIGvYcORNmIThJxVjcNE49h8mIqKkJUiSOt600QgJgA4DYeniOXp79BTqmv5aHwzBPSglKxsnnTcDJ503A4oso/LgfhzaVoJDWzej5N+rsemjv0PSajF49FjkTZiEvAmTMCBvBIQ47CdDRERElMgYgnuJIIoYOHIUBo4chVMvvxpetwtHS3fg0NYtOLR1C7762+v46m+vw5iSiryTitXHhEmwZmbFuuhERERECY8huI9o9QaMKJ6CEcVTAAC2uloc3laCg4FQvHP9FwCAjMFDkZ4zGHqjETqTCTqjCXqTWV0GtumN5tA+ndEIvckESRO/Y30SERERxRuG4BixpGdg7LTzMXba+VAUBdWHD+LQ1i04vP1HNFYeh9vphMdhh9vpgNKJYWA0Wl0gGBtbBWetwQiNXg+tXg+t3gCNTl3XBJ5rdfqw/YF1nQEavR6ShtOHEhERUeJhCI4DgiAgO28EsvNG4ORLr4rYpygKfB43PE4n3A47PA4H3E4HPE5H1G1uR3CfIxCmHfC6XPB63PC53V0vmyiqwVjXHKL1ZgvMqWkwpaXBnJoOU1oaTKnpMKemwZyWDlNqGjQxHAaIiIiIqCMMwXFOEAS1tVZvOOGh1hRFgc/rgdflgs/jhtetBmOv26UuA0HZ63HD63I3H+NxwesKbnfBZW9C9ZFDcGz/ES67Leq1dEYTzGHhOFpgdtbXwefx9IvArCgK/D4f/F511idBFNWHIEIMrbPFnIiIqL9gCE4igiBAq9NDq9P32Dl9Xi8cDfVwNNTDXl8XsW5vqIejoQ7VRw7Bvr0Ebru91evXoTkwaw1GSJIGgiRBkiSIGg1ESQp7aCBJUmC/BqJG3RZ9v6QGV68XPq8Xfp83sO6B36uu+32Bfd4W+3xe+L2+Fs+9nfkBhwVidRl6HgjJ6nMpcp8gAIKgDqYfXAcAUYQAARDQYp8AiIFlxOsAAQIEUQAE9byCKEKA2qKvHiuGjhcEQb1GYL2xsREH09JaHIvAewk7Z/ARdVvw/YS9NrA9vKxtHiuq10WU4yJ+TqFtYuDn0/zayJ9ncHu0bWGvjShPW68NHtf2a0P1Lomh30l+OCIiik8MwXRCNFotUrKykZKV3eGxocAcCMj7dpYi1WQMBWaf2wW/zwdF9sPv88PndED2+8MePvh9fsiyH7LPF9om++XA0h/1uoIgQtJqodFqIQUfmsjnGp0OBosFkiZsW+A49bku8FwDCII6BaosB6aK9IfWFUWBHFyX/WHrMhS5jX2KAigKFCiAAiiKDEUBACXUHzx0TOABILBPgRJ4DRRAVmQo/uCxcqCcSuBc4dvk0DmUwLEetxv2irLQa4LHhq4bdmyonLIS2tbyOqQSBFH9wCZKrT7UhYdlURTVD36i+kHO5XZju9Ua+mAnioEPhqKo9tUXpcDrW35YDDxCx0udvH4nj2t1DXXJoR6JqL9hCKY+0zIwe0zWHh1cOxjU/H4fZJ8fgihAo9VBlKQeu0Yi6+nBzqMH5pbBuithO7g9cKzc/Lz1Nrn5w0GL1yqKArR4beh6cuRrox8bCPwtrqPIwevLLT68BT64RfnQpvj98Icvw46DywWv2wVP2DER5/P5IMtypz8M9jZBUFvAg9/UBL+RCQZ4SSNBEMO2RQTsQLgWo4X6DkJ4F8N68LjQN0qSFGr9V99H87cxarBXv2WxVVeitiwFgoDmb2RafBMDRH4r0/IbnsjzN3/Lg8A3OMFtkedvPm/4NxVEdOI6DMGyLOOxxx7Drl27oNPpsGTJEuTl5YX2f/755/jjH/8IjUaDOXPm4Nprr+3VAhO1RRCE0H+uiP9uxglP/U87+AGEH0S6qrsfSoJBXQ59a9J2CG/5TYvslwPHRg/r4cer39j41A+ewW9wgvsiwr1PDfCyHAjuLa/rh8/tjrx+G8e1LG9f+7LPr9iBdsN0yzAOtAzToa5X0T4EtBXWw0K6IKrbTvQ8kd27msvZ8sNE+Pntdjt+snR1njnqLTabrd36sGZmYfrP7o67b4w6DMFr166Fx+PBypUrUVJSgmXLluHFF18EAHi9Xjz99NNYtWoVjEYjrrvuOpx33nnIzu74q3EiIup5wQ8foi7xP3ioQbmtUB89rId/MAiFdUWG2qSPQLckJaJLkgLg2NFjGJybA3VzWLekiG8t1C5B4evqovlbA7Q8f6g7FFp1fwpfj9ZdqvPnCStHy/OE9rd+/8H31fL8Ee8/8PNBq3I2Xzf08414P63PE62cstKy25e63edywc0W8bjRUX3ojKY+LE3ndRiCN23ahKlTpwIAiouLsX379tC+ffv2YdiwYUhNTQUATJkyBT/88AMuvvjiXiouERGRShTVLg7Q9sFkQT3cXYhOTE9336IT01/ro8N2aZvNBktYE7ckSfD5fKF9Vqs1tM9sNsNmiz5kFhERERFRvOiwJdhiscAeNrSVLMvQaDRR99nt9ohQHI3b7UZpaWl3y3tCXC5XzK5NrbE+4gvrI76wPuIL6yO+sD7iS3+tjw5D8OTJk7Fu3TrMmjULJSUlKCwsDO3Lz8/HoUOHUF9fD5PJhB9++AG33XZbu+fT6/UxazLvr831iYr1EV9YH/GF9RFfWB/xhfURX+K5PtoL5x2G4OnTp2P9+vWYN28eFEXB0qVLsXr1ajgcDsydOxeLFi3CbbfdBkVRMGfOHAwcOLBHC09ERERE1NM6DMGiKOKJJ56I2Jafnx9aP//883H++ef3fMmIiIiIiHpJfA3YRkRERETUBxiCiYiIiCjpMAQTERERUdJhCCYiIiKipMMQTERERERJhyGYiIiIiJIOQzARERERJR2GYCIiIiJKOgzBRERERJR0GIKJiIiIKOkwBBMRERFR0mEIJiIiIqKkwxBMRERERElHUBRF6csLlpSUQK/X9+UliYiIiCgJud1uFBcXR93X5yGYiIiIiCjW2B2CiIiIiJIOQzARERERJR2GYCIiIiJKOgzBRERERJR0GIKJiIiIKOloYl2A3ibLMh577DHs2rULOp0OS5YsQV5eXqyLldCuuOIKWK1WAMCQIUOwcOFCLFq0CIIgoKCgAL/+9a8hiiLeeecdvP3229BoNLjrrrtw3nnnweVy4YEHHkBNTQ3MZjOeeeYZZGRkxPgd9U8//vgjnn32WaxYsQKHDh064TooKSnBU089BUmScPbZZ+Puu++O9VvsV8LrY8eOHVi4cCGGDx8OALjuuuswa9Ys1kcf8Hq9eOSRR3Ds2DF4PB7cddddGDVqFP8+YiRafQwaNIh/HzHi9/vxq1/9CgcOHIAkSXj66aehKEri/n0oCe6TTz5RHnroIUVRFGXLli3KwoULY1yixOZyuZTLL788Ytudd96pbNiwQVEURXn00UeVNWvWKJWVlcrs2bMVt9utNDY2htZfffVV5fnnn1cURVE++ugj5cknn+zrt5AQXnrpJWX27NnKNddcoyhKz9TBZZddphw6dEiRZVm5/fbble3bt8fmzfVDLevjnXfeUV555ZWIY1gffWPVqlXKkiVLFEVRlNraWuWcc87h30cMRasP/n3EzqeffqosWrRIURRF2bBhg7Jw4cKE/vtI+O4QmzZtwtSpUwEAxcXF2L59e4xLlNh27twJp9OJW2+9FTfeeCNKSkqwY8cOnHrqqQCAadOm4ZtvvsHWrVsxadIk6HQ6WK1WDBs2DDt37oyor2nTpuHbb7+N5dvpt4YNG4bf//73oecnWgc2mw0ejwfDhg2DIAg4++yzWTdd0LI+tm/fjv/85z+YP38+HnnkEdhsNtZHH5k5cyb++7//O/RckiT+fcRQtPrg30fsXHjhhXjyyScBAGVlZcjKykrov4+ED8E2mw0WiyX0XJIk+Hy+GJYosRkMBtx222145ZVX8Pjjj+P++++HoigQBAEAYDab0dTUBJvNFuoyEdxus9kitgePpa676KKLoNE093Y60Tpo+XfEuumalvUxYcIEPPjgg3jzzTcxdOhQ/PGPf2R99BGz2QyLxQKbzYb/+q//wj333MO/jxiKVh/8+4gtjUaDhx56CE8++SQuuuiihP77SPgQbLFYYLfbQ89lWY74z4h61ogRI3DZZZdBEASMGDECaWlpqKmpCe232+1ISUlpVS92ux1WqzVie/BYOnGi2Pyn3p06iHYs66b7pk+fjvHjx4fWf/rpJ9ZHHyovL8eNN96Iyy+/HJdeein/PmKsZX3w7yP2nnnmGXzyySd49NFH4Xa7Q9sT7e8j4UPw5MmT8eWXXwIASkpKUFhYGOMSJbZVq1Zh2bJlAICKigrYbDacddZZ2LhxIwDgyy+/xMknn4wJEyZg06ZNcLvdaGpqwr59+1BYWIjJkyfjiy++CB07ZcqUmL2XRDJ27NgTqgOLxQKtVovDhw9DURR8/fXXOPnkk2P5lvq12267DVu3bgUAfPvttxg3bhzro49UV1fj1ltvxQMPPICrr74aAP8+YilaffDvI3Y++OAD/OlPfwIAGI1GCIKA8ePHJ+zfh6AoihLrQvSm4OgQu3fvhqIoWLp0KfLz82NdrITl8Xjw8MMPo6ysDIIg4P7770d6ejoeffRReL1ejBw5EkuWLIEkSXjnnXewcuVKKIqCO++8ExdddBGcTiceeughVFVVQavV4je/+Q2ys7Nj/bb6paNHj+J//ud/8M477+DAgQMnXAclJSVYunQp/H4/zj77bNx7772xfov9Snh97NixA08++SS0Wi2ysrLw5JNPwmKxsD76wJIlS/Cvf/0LI0eODG375S9/iSVLlvDvIwai1cc999yD5cuX8+8jBhwOBx5++GFUV1fD5/PhZz/7GfLz8xP2/4+ED8FERERERC0lfHcIIiIiIqKWGIKJiIiIKOkwBBMRERFR0mEIJiIiIqKkwxBMREREREmHIZiIiIiIkg5DMBERERElHYZgIiIiIko6/z8wg6LUS4fhbwAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for convergence in convergences:\n",
+    "    fig, ax = plt.subplots()\n",
+    "    ax.plot(convergence.nfe, convergence.SBX, label=\"SBX\")\n",
+    "    ax.plot(convergence.nfe, convergence.PCX, label=\"PCX\")\n",
+    "    ax.plot(convergence.nfe, convergence.DE, label=\"DE\")\n",
+    "    ax.plot(convergence.nfe, convergence.UNDX, label=\"UNDX\")\n",
+    "    ax.plot(convergence.nfe, convergence.SPX, label=\"SPX\")\n",
+    "    ax.plot(convergence.nfe, convergence.UM, label=\"UM\")\n",
+    "    ax.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "165277f5-46e6-4fe3-b453-1abcb31b13d5",
+   "metadata": {},
+   "source": [
+    "# LHS\n",
+    "\n",
+    "for comparison, let's also generate a Latin Hypercube Sample and compare the results. Since the output space exploration return close to 1500 solutions, we use 1500 for LHS as well. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "029f17c4-1ba6-4d66-9360-21f648a054cd",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[MainProcess/INFO] pool started with 10 workers\n",
+      "[MainProcess/INFO] performing 1500 scenarios * 1 policies * 1 model(s) = 1500 experiments\n",
+      "100%|█████████████████████████████████████| 1500/1500 [00:05<00:00, 293.09it/s]\n",
+      "[MainProcess/INFO] experiments finished\n",
+      "[MainProcess/INFO] terminating pool\n"
+     ]
+    }
+   ],
+   "source": [
+    "with MultiprocessingEvaluator(lake_model) as evaluator:\n",
+    "    experiments, outcomes = evaluator.perform_experiments(scenarios=1500, policies=reference)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a1010857-33c5-42c8-91f5-ddeb448be318",
+   "metadata": {},
+   "source": [
+    "# comparison\n",
+    "Below we compare the LHS with the last seed of the autoadaptive algorithm. Remember, the purpose of output space exploration is to identify the kinds of behavior that a model can show given a set of uncertain parameters. So, we are creating a pairwise scatter plot of the outcomes for both output space exploration (in blue) and the latin hypercube sampling (in orange)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "ce53f0cb-1f6f-4f54-a730-7522ca166dfe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "outcomes = pd.DataFrame(outcomes)\n",
+    "outcomes[\"sampling\"] = \"LHS\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "8b2efa8f-4599-480a-8cb8-48e043daa856",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ose = res.iloc[:, 5::].copy()\n",
+    "ose[\"sampling\"] = \"OSE\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "21ac783c-4f88-4cce-a3f7-d748c77ace72",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = pd.concat([ose, outcomes], axis=0, ignore_index=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "bb89beec-78a5-4a0c-86d1-d2c15c9040dd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 777x720 with 20 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# sns.pairplot(data, hue='sampling')\n",
+    "sns.pairplot(data, hue=\"sampling\", vars=data.columns[0:4])\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "02fcb2e7-4b80-4c16-bb70-5b7991d61e3b",
+   "metadata": {},
+   "source": [
+    "As you can clearly see, the output space exploration algorithm has uncovered behaviors that were not seen in the 1500 sample LHS."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bffcbdfc-2ce1-4fc7-95d5-3a44b9609466",
+   "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
\ No newline at end of file
diff --git a/ema_workbench/util/ema_logging.py b/ema_workbench/util/ema_logging.py
index c7ac80044..47538eb9e 100644
--- a/ema_workbench/util/ema_logging.py
+++ b/ema_workbench/util/ema_logging.py
@@ -77,8 +77,8 @@ def filter(self, record):
 def temporary_filter(name=LOGGER_NAME, level=0, functname=None):
     """temporary filter log message
 
-    Params
-    ------
+    Parameters
+    ----------
     name : str or list of str, optional
            logger on which to apply the filter.
     level: int, or list of int, optional
diff --git a/pyproject.toml b/pyproject.toml
index 08ebb8c01..f66ac1051 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -34,7 +34,7 @@ recommended = ["ema_workbench[jupyter,dev,graph]"]
 all = ["ema_workbench[jupyter,dev,cov,docs,graph,parallel]"]
 
 jupyter = ["jupyter", "jupyter_client", "ipython", "ipykernel"]
-dev = ["pytest", "jupyter_client", "ipyparallel"]
+dev = ["pytest", "pytest-mock", "jupyter_client", "ipyparallel"]
 cov = ["pytest-cov", "coverage", "coveralls"]
 docs = ["sphinx", "nbsphinx", "myst", "pyscaffold", "myst-parser"]
 graph = ["altair", "pydot", "graphviz"]
diff --git a/todo.md b/todo.md
index 17ac00612..1ec0a8667 100644
--- a/todo.md
+++ b/todo.md
@@ -81,4 +81,10 @@
      save_results if no file_name is specified.
 * store the uncertainty specification also in the json metadata
   * so we need the class, dist, scale and loc?
-  * also add a way of getting the results metadata seperately
\ No newline at end of file
+  * also add a way of getting the results metadata seperately
+
+
+# optimization
+* modify CombinedVariator and turn it into a GAOperator with a CombinedVariotor
+  and a CombinedMutator were the CombinedMutator uses the different mutators
+  in PlatypusOpt
\ No newline at end of file


Test patch:
diff --git a/test/test_em_framework/test_outputspace_exploration.py b/test/test_em_framework/test_outputspace_exploration.py
new file mode 100644
index 000000000..1d4cacd0f
--- /dev/null
+++ b/test/test_em_framework/test_outputspace_exploration.py
@@ -0,0 +1,164 @@
+import pytest
+
+from ema_workbench.em_framework import outputspace_exploration
+from ema_workbench.em_framework.optimization import to_problem
+from ema_workbench.em_framework import Model, RealParameter, ScalarOutcome
+from ema_workbench.util import EMAError
+
+
+def test_novelty(mocker):
+    algorithm = mocker.patch(
+        "ema_workbench.em_framework.outputspace_exploration.HitBox.get_novelty_score",
+        return_value=1,
+    )
+
+    algorithm = mocker.Mock()
+    algorithm.archive.get_novelty_score.side_effect = [1, 2, 2, 2, 2, 1]
+
+    novelty = outputspace_exploration.Novelty(algorithm)
+    assert novelty.compare("a", "b") == 1
+    assert novelty.compare("a", "b") == 0
+    assert novelty.compare("a", "b") == -1
+
+
+def test_hitbox(mocker):
+    grid_spec = [
+        (0, 1, 0.1),
+        (0, 1, 0.1),
+    ]
+
+    # test first more central and then farther away
+    hitbox = outputspace_exploration.HitBox(grid_spec)
+
+    solution = mocker.Mock()
+    solution.objectives = [0.05, 0.05]
+    hitbox.add(solution)
+
+    key = (0, 0)
+    assert hitbox.grid_counter[key] == 1
+    assert hitbox.improvements == 1
+    assert hitbox.archive[key] is solution
+    assert hitbox.centroids[key] == [0.05, 0.05]
+    assert hitbox.overall_novelty == 1
+
+    solution2 = mocker.Mock()
+    solution2.objectives = [0.06, 0.06]
+    hitbox.add(solution2)
+
+    key = (0, 0)
+    assert hitbox.grid_counter[key] == 2
+    assert hitbox.improvements == 1
+    assert hitbox.archive[key] is solution
+    assert hitbox.centroids[key] == [0.05, 0.05]
+    assert hitbox.overall_novelty == 1.5
+
+    # test first farther away and then more central
+    hitbox = outputspace_exploration.HitBox(grid_spec)
+
+    solution = mocker.Mock()
+    solution.objectives = [0.06, 0.06]
+    hitbox.add(solution)
+
+    key = (0, 0)
+    assert hitbox.grid_counter[key] == 1
+    assert hitbox.improvements == 1
+    assert hitbox.archive[key] is solution
+    assert hitbox.centroids[key] == [0.05, 0.05]
+    assert hitbox.overall_novelty == 1
+
+    solution2 = mocker.Mock()
+    solution2.objectives = [0.05, 0.05]
+    hitbox.add(solution2)
+
+    key = (0, 0)
+    assert hitbox.grid_counter[key] == 2
+    assert hitbox.improvements == 1
+    assert hitbox.archive[key] is solution2
+    assert hitbox.centroids[key] == [0.05, 0.05]
+    assert hitbox.overall_novelty == 1.5
+
+    # test get_novelty_score
+    assert hitbox.get_novelty_score(solution2) == 1 / 2
+    assert hitbox.get_novelty_score(solution2) == hitbox.get_novelty_score(solution)
+
+
+def test_core_algorithm(mocker):
+    function = mocker.Mock()
+    model = Model("A", function)
+    model.uncertainties = [
+        RealParameter("a", 0, 1),
+        RealParameter("b", 0, 1),
+        RealParameter("c", 0, 1),
+    ]
+    model.outcomes = [
+        ScalarOutcome("x", kind=ScalarOutcome.MAXIMIZE),
+        ScalarOutcome("y", kind=ScalarOutcome.MAXIMIZE),
+    ]
+
+    def evaluate_all(jobs):
+        [job.run() for job in jobs]
+        return jobs
+
+    def some_callable(vars):
+        return min(vars), max(vars)
+
+    problem = to_problem(model, searchover="uncertainties")
+    problem.function = some_callable
+    grid_spec = [
+        (0, 1, 0.1),
+        (0, 1, 0.1),
+    ]
+    evaluator = mocker.Mock()
+    evaluator.evaluate_all.side_effect = evaluate_all
+    population_size = 100
+
+    # test only does minimum checking if code runs
+    # but we are not testing inner workings of platypus
+    algorithm = outputspace_exploration.OutputSpaceExplorationAlgorithm(
+        problem,
+        grid_spec=grid_spec,
+        evaluator=evaluator,
+        population_size=population_size,
+    )
+    algorithm.step()
+    algorithm.step()
+
+    assert algorithm.nfe <= 2 * population_size
+    assert len(algorithm.population) == population_size
+
+    with pytest.raises(EMAError):
+        grid_spec = [
+            (0, 1, 0.1),
+            (0, 1, 0.1),
+            (0, 1, 0.1),
+        ]
+        algorithm = outputspace_exploration.OutputSpaceExplorationAlgorithm(
+            problem,
+            grid_spec=grid_spec,
+            evaluator=evaluator,
+            population_size=population_size,
+        )
+
+
+def test_user_facing_algorithms(mocker):
+    function = mocker.Mock()
+    model = Model("A", function)
+    model.uncertainties = [
+        RealParameter("a", 0, 1),
+        RealParameter("b", 0, 1),
+        RealParameter("c", 0, 1),
+    ]
+    model.outcomes = [
+        ScalarOutcome("x", kind=ScalarOutcome.MAXIMIZE),
+        ScalarOutcome("y", kind=ScalarOutcome.MAXIMIZE),
+    ]
+
+    problem = to_problem(model, searchover="uncertainties")
+    grid_spec = [
+        (0, 1, 0.1),
+        (0, 1, 0.1),
+    ]
+
+    outputspace_exploration.OutputSpaceExploration(problem, grid_spec=grid_spec)
+
+    outputspace_exploration.AutoAdaptiveOutputSpaceExploration(problem, grid_spec=grid_spec)