Repository: N-Wouda/ALNS (language: python)

Issue:
Weight updating scheme
The updating scheme currently used is overly restrictive: it updates the weights using a convex combination of the current weight, and whatever outcome the operator resulted in. That is how it was done (more or less) in the original ALNS paper, but does not reflect recent use of the ALNS metaheuristic in literature. We should also accommodate those cases.

In particular, we need to allow finer control over the weight updating scheme: 
- [x] Allow resets after a certain number of iterations;
- [x] Allow specification of the initial weights, and those after resets;
- [x] Allow for different updating mechanisms: aside from the convex combination scheme we currently use, a simple addition rule (`new_weight = old_weight + <performance outcome>`) is also commonly used.
- [x] Track statistics on operator weights over iterations.
Criteria autofit?
Fairly often I see things like 

>The starting temperature of the simulated annealing procedure is set such that, in the first iteration, a solution with an objective up to 5% worse than the current solution is accepted with probability 0.5, and the cooling rate is set such that the temperature in the last iteration is 0.2 percent of the start temperature. - Hornstra et al, 2020, in a paper on the VRPSPD-H.

This sort of 'autofit' is interesting to add, and not too hard to do either.


Discussion / hints:
I might call this `AdaptiveStrategy` or similar.
@N-Wouda I would like to know any progress on `AdaptiveStrategy`, thank you very much for an amazing package.
@ZhiWeiCui hi, thanks for reaching out!

There is no progress on this yet - I have been quite busy the past year or so. If you want, you can open a PR that I'd be happy to review. Otherwise, I might get to it in a few weeks.

Out of curiosity, can you tell me a little more about your use case?
I want to solve Dynamic Pickup and Delivery Problem based on ALNS.

The main ideas are as follows: 
1. update scores after in each iteration.
2. update weights after in each segment(a segment is a number of iterations of the ALNS heuristic; here we define a segment as
100 iterations.) based one (1).
![Snipaste_2021-03-05_09-32-49](https://user-images.githubusercontent.com/22850130/110054327-dd388500-7d95-11eb-96af-c38aa5601817.png)
πi is the score of heuristic i obtained during the last segment and θi is the number of times we have attempted
to use heuristic i during the last segment. 

reference:
[1] Ropke, Stefan, and David Pisinger. “An Adaptive Large Neighborhood Search Heuristic for the Pickup and Delivery Problem with Time Windows.” Transportation Science 40, no. 4 (2006): 455–72.

@ZhiWeiCui you might also like https://github.com/N-Wouda/OR-Analysis then!
Roozbeh et al. (2018) show how to do this for the starting temperature, but it's easy to derive for yourself as well. Once you know the starting and end temperatures, the cooling rate `r` can be computed from the following equivalence: `T_end = r ** n * T_start`, with `n` the number of iterations.

Roozbeh et al. (2018). An Adaptive Large Neighbourhood Search for asset protection during escaped wildfires. _Computers & Operations Research_ 97: 125 - 134.



Fix patch:
diff --git a/.travis.yml b/.travis.yml
index d7d24db..21b4b4c 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -8,9 +8,15 @@ python:
   - "3.7"
   - "3.8"
   - "3.9"
+  - "3.10"
 
 # TODO eventually I want a better build matrix here, i.a. for numpy versions
 
+cache:
+  pip: true
+  directories:
+    - "$HOME/.cache/pypoetry"
+
 install:
   - pip install poetry
   - poetry install
diff --git a/README.md b/README.md
index b8d390f..4d6d516 100644
--- a/README.md
+++ b/README.md
@@ -17,16 +17,35 @@ may be used to run the ALNS algorithm, the second may be subclassed to
 store a solution state - all it requires is to define an `objective`
 member function, returning an objective value.
 
-The ALNS algorithm must be supplied with an acceptance criterion, to
-determine the acceptance of a new solution state at each iteration.
-An overview of common acceptance criteria is given in [Santini et al.
-(2018)][3]. Several have already been implemented for you, in
-`alns.criteria`,
-
-- `HillClimbing`. The simplest acceptance criterion, hill-climbing
-  solely accepts solutions improving the objective value.
-- `RecordToRecordTravel`. This criterion only accepts solutions when
-  the improvement meets some updating threshold.
+The ALNS algorithm must be supplied with a _weight scheme_ and an _acceptance
+criterion_.
+
+### Weight scheme
+The weight scheme determines how to select destroy and repair operators in each
+iteration of the ALNS algorithm. Several have already been implemented for you,
+in `alns.weight_schemes`:
+
+- `SimpleWeights`. This weight scheme applies a convex combination of the 
+   existing weight vector, and a reward given for the current candidate 
+   solution.
+- `SegmentedWeights`. This weight scheme divides the iteration horizon into
+   segments. In each segment, scores are summed for each operator. At the end
+   of each segment, the weight vector is updated as a convex combination of 
+   the existing weight vector, and these summed scores.
+
+Each weight scheme inherits from `WeightScheme`, which may be used to write 
+your own.
+
+### Acceptance criterion
+The acceptance criterion determines the acceptance of a new solution state at
+each iteration. An overview of common acceptance criteria is given in
+[Santini et al. (2018)][3]. Several have already been implemented for you, in
+`alns.criteria`:
+
+- `HillClimbing`. The simplest acceptance criterion, hill-climbing solely
+  accepts solutions improving the objective value.
+- `RecordToRecordTravel`. This criterion accepts solutions when the improvement
+  meets some updating threshold.
 - `SimulatedAnnealing`. This criterion accepts solutions when the
   scaled probability is bigger than some random number, using an
   updating temperature.
@@ -36,7 +55,7 @@ be used to write your own.
 
 ### Examples
 The `examples/` directory features some example notebooks showcasing
-how the ALNS library may be used. Of particular interest are,
+how the ALNS library may be used. These include:
 
 - The travelling salesman problem (TSP), [here][2]. We solve an
   instance of 131 cities to within 2.1% of optimality, using simple
@@ -45,6 +64,12 @@ how the ALNS library may be used. Of particular interest are,
   180 beams over 165 distinct sizes to within 1.35% of optimality in
   only a very limited number of iterations.
 
+Finally, the weight schemes and acceptance criteria notebook gives an overview
+of various options available in the `alns` package. In the notebook we use these
+different options to solve a toy 0/1-knapsack problem. The notebook is a good
+starting point for when you want to use the different schemes and criteria 
+yourself. It is available [here][5].
+
 ## References
 - Pisinger, D., and Ropke, S. (2010). Large Neighborhood Search. In M.
   Gendreau (Ed.), _Handbook of Metaheuristics_ (2 ed., pp. 399-420).
@@ -57,3 +82,4 @@ how the ALNS library may be used. Of particular interest are,
 [2]: https://github.com/N-Wouda/ALNS/blob/master/examples/travelling_salesman_problem.ipynb
 [3]: https://link.springer.com/article/10.1007%2Fs10732-018-9377-x
 [4]: https://github.com/N-Wouda/ALNS/blob/master/examples/cutting_stock_problem.ipynb
+[5]: https://github.com/N-Wouda/ALNS/blob/master/examples/weight_schemes_acceptance_criteria.ipynb
diff --git a/alns/ALNS.py b/alns/ALNS.py
index e17e083..a55f922 100644
--- a/alns/ALNS.py
+++ b/alns/ALNS.py
@@ -1,29 +1,25 @@
-import warnings
-from collections import OrderedDict
+from typing import Callable, Dict, List, Optional, Tuple
 
-import numpy as np
 import numpy.random as rnd
 
-from .Result import Result
-from .State import State  # pylint: disable=unused-import
-from .Statistics import Statistics
-from .criteria import AcceptanceCriterion  # pylint: disable=unused-import
-from .select_operator import select_operator
-from .tools.warnings import OverwriteWarning
+from alns.Result import Result
+from alns.State import State
+from alns.Statistics import Statistics
+from alns.criteria import AcceptanceCriterion
+from alns.weight_schemes import WeightScheme
 
-# Weights
-_IS_BEST = 0
-_IS_BETTER = 1
-_IS_ACCEPTED = 2
-_IS_REJECTED = 3
+# Potential candidate solution consideration outcomes.
+_BEST = 0
+_BETTER = 1
+_ACCEPT = 2
+_REJECT = 3
 
-# Callbacks
-_ON_BEST = 0
+_OperatorType = Callable[[State, rnd.RandomState], State]
 
 
 class ALNS:
 
-    def __init__(self, rnd_state=rnd.RandomState()):
+    def __init__(self, rnd_state: rnd.RandomState = rnd.RandomState()):
         """
         Implements the adaptive large neighbourhood search (ALNS) algorithm.
         The implementation optimises for a minimisation problem, as explained
@@ -31,7 +27,7 @@ def __init__(self, rnd_state=rnd.RandomState()):
 
         Parameters
         ----------
-        rnd_state : rnd.RandomState
+        rnd_state
             Optional random state to use for random number generation. When
             passed, this state is used for operator selection and general
             computations requiring random numbers. It is also passed to the
@@ -39,78 +35,80 @@ def __init__(self, rnd_state=rnd.RandomState()):
 
         References
         ----------
-        - Pisinger, D., and Røpke, S. (2010). Large Neighborhood Search. In M.
-          Gendreau (Ed.), *Handbook of Metaheuristics* (2 ed., pp. 399-420).
-          Springer.
+        [1]: Pisinger, D., and Røpke, S. (2010). Large Neighborhood Search. In
+             M. Gendreau (Ed.), *Handbook of Metaheuristics* (2 ed., pp. 399
+             - 420). Springer.
         """
-        super().__init__()
+        self._destroy_operators: Dict[str, _OperatorType] = {}
+        self._repair_operators: Dict[str, _OperatorType] = {}
 
-        self._destroy_operators = OrderedDict()
-        self._repair_operators = OrderedDict()
-        self._callbacks = {}
+        # Optional callback that may be used to improve a new best solution
+        # further, via e.g. local search.
+        self._on_best: Optional[_OperatorType] = None
 
         self._rnd_state = rnd_state
 
     @property
-    def destroy_operators(self):
+    def destroy_operators(self) -> List[Tuple[str, _OperatorType]]:
         """
         Returns the destroy operators set for the ALNS algorithm.
 
         Returns
         -------
-        list
-            A list of (name, operator) tuples. Their order is the same as the
-            one in which they were passed to the ALNS instance.
+        A list of (name, operator) tuples. Their order is the same as the one in
+        which they were passed to the ALNS instance.
         """
         return list(self._destroy_operators.items())
 
     @property
-    def repair_operators(self):
+    def repair_operators(self) -> List[Tuple[str, _OperatorType]]:
         """
         Returns the repair operators set for the ALNS algorithm.
 
         Returns
         -------
-        list
-            A list of (name, operator) tuples. Their order is the same as the
-            one in which they were passed to the ALNS instance.
+        A list of (name, operator) tuples. Their order is the same as the one in
+        which they were passed to the ALNS instance.
         """
         return list(self._repair_operators.items())
 
-    def add_destroy_operator(self, operator, name=None):
+    def add_destroy_operator(self, op: _OperatorType, name: str = None):
         """
         Adds a destroy operator to the heuristic instance.
 
         Parameters
         ----------
-        operator : Callable[[State, RandomState], State]
+        op
             An operator that, when applied to the current state, returns a new
             state reflecting its implemented destroy action. The second argument
             is the random state constructed from the passed-in seed.
-        name : str
+        name
             Optional name argument, naming the operator. When not passed, the
             function name is used instead.
         """
-        self._add_operator(self._destroy_operators, operator, name)
+        self._destroy_operators[op.__name__ if name is None else name] = op
 
-    def add_repair_operator(self, operator, name=None):
+    def add_repair_operator(self, op: _OperatorType, name: str = None):
         """
         Adds a repair operator to the heuristic instance.
 
         Parameters
         ----------
-        operator : Callable[[State, RandomState], State]
+        op
             An operator that, when applied to the destroyed state, returns a
             new state reflecting its implemented repair action. The second
             argument is the random state constructed from the passed-in seed.
-        name : str
+        name
             Optional name argument, naming the operator. When not passed, the
             function name is used instead.
         """
-        self._add_operator(self._repair_operators, operator, name)
+        self._repair_operators[name if name else op.__name__] = op
 
-    def iterate(self, initial_solution, weights, operator_decay, criterion,
-                iterations=10000, collect_stats=True):
+    def iterate(self,
+                initial_solution: State,
+                weight_scheme: WeightScheme,
+                crit: AcceptanceCriterion,
+                iterations: int = 10_000) -> Result:
         """
         Runs the adaptive large neighbourhood search heuristic [1], using the
         previously set destroy and repair operators. The first solution is set
@@ -119,24 +117,16 @@ def iterate(self, initial_solution, weights, operator_decay, criterion,
 
         Parameters
         ----------
-        initial_solution : State
+        initial_solution
             The initial solution, as a State object.
-        weights: array_like
-            A list of four non-negative elements, representing the weight
-            updates when the candidate solution results in a new global best
-            (idx 0), is better than the current solution (idx 1), the solution
-            is accepted (idx 2), or rejected (idx 3).
-        operator_decay : float
-            The operator decay parameter, as a float in the unit interval,
-            [0, 1] (inclusive).
-        criterion : AcceptanceCriterion
+        weight_scheme
+            The weight scheme to use for updating the (adaptive) weights. See
+            also the ``alns.weight_schemes`` module for an overview.
+        crit
             The acceptance criterion to use for candidate states. See also
-            the `alns.criteria` module for an overview.
-        iterations : int
-            The number of iterations. Default 10000.
-        collect_stats : bool
-            Should statistics be collected during iteration? Default True, but
-            may be turned off for long runs to reduce memory consumption.
+            the ``alns.criteria`` module for an overview.
+        iterations
+            The number of iterations. Default 10_000.
 
         Raises
         ------
@@ -145,9 +135,8 @@ def iterate(self, initial_solution, weights, operator_decay, criterion,
 
         Returns
         -------
-        Result
-            A result object, containing the best solution and some additional
-            statistics.
+        A result object, containing the best solution and some additional
+        statistics.
 
         References
         ----------
@@ -159,191 +148,78 @@ def iterate(self, initial_solution, weights, operator_decay, criterion,
         class of vehicle routing problems with backhauls. *European Journal of
         Operational Research*, 171: 750–775, 2006.
         """
-        weights = np.asarray(weights, dtype=np.float16)
-
-        self._validate_parameters(weights, operator_decay, iterations)
-
-        current = best = initial_solution
+        if len(self.destroy_operators) == 0 or len(self.repair_operators) == 0:
+            raise ValueError("Missing at least one destroy or repair operator.")
 
-        d_weights = np.ones(len(self.destroy_operators), dtype=np.float16)
-        r_weights = np.ones(len(self.repair_operators), dtype=np.float16)
+        if iterations < 0:
+            raise ValueError("Negative number of iterations.")
 
-        statistics = Statistics()
+        curr = best = initial_solution
 
-        if collect_stats:
-            statistics.collect_objective(initial_solution.objective())
+        stats = Statistics()
+        stats.collect_objective(initial_solution.objective())
 
         for iteration in range(iterations):
-            d_idx = select_operator(self.destroy_operators, d_weights,
-                                    self._rnd_state)
-
-            r_idx = select_operator(self.repair_operators, r_weights,
-                                    self._rnd_state)
+            d_idx, r_idx = weight_scheme.select_operators(self._rnd_state)
 
             d_name, d_operator = self.destroy_operators[d_idx]
-            destroyed = d_operator(current, self._rnd_state)
-
             r_name, r_operator = self.repair_operators[r_idx]
-            candidate = r_operator(destroyed, self._rnd_state)
 
-            best, current, weight_idx = self._consider_candidate(best,
-                                                                 current,
-                                                                 candidate,
-                                                                 criterion)
+            destroyed = d_operator(curr, self._rnd_state)
+            cand = r_operator(destroyed, self._rnd_state)
 
-            # The weights are updated as convex combinations of the current
-            # weight and the update parameter. See eq. (2), p. 12.
-            d_weights[d_idx] *= operator_decay
-            d_weights[d_idx] += (1 - operator_decay) * weights[weight_idx]
+            best, curr, s_idx = self._consider_candidate(crit, best, curr, cand)
 
-            r_weights[r_idx] *= operator_decay
-            r_weights[r_idx] += (1 - operator_decay) * weights[weight_idx]
+            weight_scheme.update_weights(d_idx, r_idx, s_idx)
 
-            if collect_stats:
-                statistics.collect_objective(current.objective())
-                statistics.collect_destroy_operator(d_name, weight_idx)
-                statistics.collect_repair_operator(r_name, weight_idx)
+            stats.collect_objective(curr.objective())
+            stats.collect_destroy_operator(d_name, s_idx)
+            stats.collect_repair_operator(r_name, s_idx)
 
-        return Result(best, statistics if collect_stats else None)
+        return Result(best, stats)
 
-    def on_best(self, func):
+    def on_best(self, func: _OperatorType):
         """
         Sets a callback function to be called when ALNS finds a new global best
         solution state.
 
         Parameters
         ----------
-        func : callable
+        func
             A function that should take a solution State as its first parameter,
             and a numpy RandomState as its second (cf. the operator signature).
             It should return a (new) solution State.
-
-        Warns
-        -----
-        OverwriteWarning
-            When a callback has already been set.
-        """
-        self._set_callback(_ON_BEST, func)
-
-    @staticmethod
-    def _add_operator(operators, operator, name=None):
-        """
-        Internal helper that adds an operator to the passed-in operator
-        dictionary. See `add_destroy_operator` and `add_repair_operator` for
-        public methods that use this helper.
-
-        Parameters
-        ----------
-        operators : dict
-            Dictionary of (name, operator) key-value pairs.
-        operator : Callable[[State, RandomState], State]
-            Callable operator function.
-        name : str
-            Optional operator name.
-
-        Warns
-        -----
-        OverwriteWarning
-            When the operator name already maps to an operator on this ALNS
-            instance.
         """
-        if name is None:
-            name = operator.__name__
+        self._on_best = func
 
-        if name in operators:
-            warnings.warn("The ALNS instance already knows an operator by the"
-                          " name `{0}'. This operator will now be replaced with"
-                          " the newly passed-in operator. If this is not what"
-                          " you intended, consider explicitly naming your"
-                          " operators via the `name' argument.".format(name),
-                          OverwriteWarning)
-
-        operators[name] = operator
-
-    def _consider_candidate(self, best, current, candidate, criterion):
+    def _consider_candidate(
+            self,
+            crit: AcceptanceCriterion,
+            best: State,
+            curr: State,
+            cand: State
+    ) -> Tuple[State, State, int]:
         """
         Considers the candidate solution by comparing it against the best and
-        current solutions. Returns the new solution when it is better or
-        accepted, or the current in case it is rejected. Candidate solutions
-        are accepted based on the passed-in acceptance criterion.
-
-        Parameters
-        ----------
-        best : State
-            Best solution encountered so far.
-        current : State
-            Current solution.
-        candidate : State
-            Candidate solution.
-        criterion : AcceptanceCriterion
-            The chosen acceptance criterion.
+        current solutions. Candidate solutions are accepted based on the
+        passed-in acceptance criterion. The (possibly new) best and current
+        solutions are returned, along with a weight index (best, better,
+        accepted, rejected).
 
         Returns
         -------
-        State
-            The (possibly new) best state.
-        State
-            The (possibly new) current state.
-        int
-            The weight index to use when updating the operator weights.
-        """
-        if criterion.accept(self._rnd_state, best, current, candidate):
-            if candidate.objective() < current.objective():
-                weight = _IS_BETTER
-            else:
-                weight = _IS_ACCEPTED
-
-            current = candidate
-        else:
-            weight = _IS_REJECTED
-
-        if candidate.objective() < best.objective():
-            # Is a new global best, so we might want to do something to further
-            # improve the solution.
-            if _ON_BEST in self._callbacks:
-                callback = self._callbacks[_ON_BEST]
-                candidate = callback(candidate, self._rnd_state)
-
-            # Global best solution becomes the new starting point for further
-            # iterations.
-            return candidate, candidate, _IS_BEST
-
-        # Best has not been updated if we get here, but the current state might
-        # have (if the candidate was accepted).
-        return best, current, weight
-
-    def _validate_parameters(self, weights, operator_decay, iterations):
+        A tuple of the best and current solution, along with the weight index.
         """
-        Helper method to validate the passed-in ALNS parameters.
-        """
-        if len(self.destroy_operators) == 0 or len(self.repair_operators) == 0:
-            raise ValueError("Missing at least one destroy or repair operator.")
-
-        if not (0 <= operator_decay <= 1):
-            raise ValueError("Operator decay parameter outside unit interval"
-                             " is not understood.")
+        w_idx = _REJECT
 
-        if any(weight < 0 for weight in weights):
-            raise ValueError("Negative weights are not understood.")
+        if crit(self._rnd_state, best, curr, cand):  # accept candidate
+            w_idx = _BETTER if cand.objective() < curr.objective() else _ACCEPT
+            curr = cand
 
-        if len(weights) < 4:
-            # More than four is not explicitly problematic, as we only use the
-            # first four anyways.
-            raise ValueError("Unsupported number of weights: expected 4,"
-                             " found {0}.".format(len(weights)))
+        if cand.objective() < best.objective():  # candidate is new best
+            if self._on_best:
+                cand = self._on_best(cand, self._rnd_state)
 
-        if iterations < 0:
-            raise ValueError("Negative number of iterations.")
-
-    def _set_callback(self, flag, func):
-        """
-        Sets the passed-in callback func for the passed-in flag. Warns if this
-        would overwrite an existing callback.
-        """
-        if flag in self._callbacks:
-            warnings.warn("A callback function has already been set for the"
-                          " `{0}' flag. This callback will now be replaced by"
-                          " the newly passed-in callback.".format(flag),
-                          OverwriteWarning)
+            return cand, cand, _BEST
 
-        self._callbacks[flag] = func
+        return best, curr, w_idx
diff --git a/alns/Result.py b/alns/Result.py
index 3e25984..7f703da 100644
--- a/alns/Result.py
+++ b/alns/Result.py
@@ -1,75 +1,59 @@
+from typing import Any, Dict, List, Optional
+
 import matplotlib.pyplot as plt
 import numpy as np
-from matplotlib.pyplot import Axes, Figure  # pylint: disable=unused-import
+from matplotlib.pyplot import Axes, Figure
 
-from .State import State  # pylint: disable=unused-import
-from .Statistics import Statistics  # pylint: disable=unused-import
-from .tools.exceptions import NotCollectedError
+from alns.State import State
+from alns.Statistics import Statistics
 
 
 class Result:
 
-    def __init__(self, best, statistics=None):
+    def __init__(self, best: State, statistics: Statistics):
         """
         Stores ALNS results. An instance of this class is returned once the
         algorithm completes.
 
         Parameters
         ----------
-        best : State
+        best
             The best state observed during the entire iteration.
-        statistics : Statistics
-            Statistics optionally collected during iteration.
+        statistics
+            Statistics collected during iteration.
         """
         self._best = best
         self._statistics = statistics
 
     @property
-    def best_state(self):
+    def best_state(self) -> State:
         """
         The best state observed during the entire iteration.
-
-        Returns
-        -------
-        State
-            The associated State object
         """
         return self._best
 
     @property
-    def statistics(self):
+    def statistics(self) -> Statistics:
         """
         The statistics object populated during iteration.
-
-        Raises
-        ------
-        NotCollectedError
-            When statistics were not collected during iteration. This may be
-            remedied by setting the appropriate flag.
-
-        Returns
-        -------
-        Statistics
-            The statistics object.
         """
-        if self._statistics is None:
-            raise NotCollectedError("Statistics were not collected during "
-                                    "iteration.")
-
         return self._statistics
 
-    def plot_objectives(self, ax=None, title=None, **kwargs):
+    def plot_objectives(self,
+                        ax: Optional[Axes] = None,
+                        title: Optional[str] = None,
+                        **kwargs: Dict[str, Any]):
         """
         Plots the collected objective values at each iteration.
 
         Parameters
         ----------
-        ax : Axes
+        ax
             Optional axes argument. If not passed, a new figure and axes are
             constructed.
-        title : str
+        title
             Optional title argument. When not passed, a default is set.
-        kwargs : dict
+        kwargs
             Optional arguments passed to ``ax.plot``.
         """
         if ax is None:
@@ -91,19 +75,22 @@ def plot_objectives(self, ax=None, title=None, **kwargs):
 
         plt.draw_if_interactive()
 
-    def plot_operator_counts(self, figure=None, title=None, legend=None,
-                             **kwargs):
+    def plot_operator_counts(self,
+                             fig: Optional[Figure] = None,
+                             title: Optional[str] = None,
+                             legend: Optional[List[str]] = None,
+                             **kwargs: Dict[str, Any]):
         """
         Plots an overview of the destroy and repair operators' performance.
 
         Parameters
         ----------
-        figure : Figure
+        fig
             Optional figure. If not passed, a new figure is constructed, and
             some default margins are set.
-        title : str
+        title
             Optional figure title. When not passed, no title is set.
-        legend : list
+        legend
             Optional legend entries. When passed, this should be a list of at
             most four strings. The first string describes the number of times
             a best solution was found, the second a better, the third a solution
@@ -112,52 +99,39 @@ def plot_operator_counts(self, figure=None, title=None, legend=None,
             than four strings are passed, only the first len(legend) count types
             are plotted. When not passed, a sensible default is set and all
             counts are shown.
-        kwargs : dict
+        kwargs
             Optional arguments passed to each call of ``ax.barh``.
-
-        Raises
-        ------
-        ValueError
-            When the legend contains more than four elements.
         """
-        if figure is None:
-            figure, (d_ax, r_ax) = plt.subplots(nrows=2)
-
-            # Ensures there is generally sufficient white space between the
-            # operator subplots, and we have some space to put the legend. When
-            # a figure is passed-in, these sorts of modifications are assumed
-            # to have been performed at the call site.
-            figure.subplots_adjust(hspace=0.7, bottom=0.2)
+        if fig is None:
+            fig, (d_ax, r_ax) = plt.subplots(nrows=2)
+            fig.subplots_adjust(hspace=0.7, bottom=0.2)
         else:
-            d_ax, r_ax = figure.subplots(nrows=2)
+            d_ax, r_ax = fig.subplots(nrows=2)
 
         if title is not None:
-            figure.suptitle(title)
+            fig.suptitle(title)
 
         if legend is None:
             legend = ["Best", "Better", "Accepted", "Rejected"]
-        elif len(legend) > 4:
-            raise ValueError("Legend not understood. Expected at most 4 items,"
-                             " found {0}.".format(len(legend)))
 
-        self._plot_operator_counts(d_ax,
-                                   self.statistics.destroy_operator_counts,
-                                   "Destroy operators",
-                                   len(legend),
-                                   **kwargs)
+        self._plot_op_counts(d_ax,
+                             self.statistics.destroy_operator_counts,
+                             "Destroy operators",
+                             min(len(legend), 4),
+                             **kwargs)
 
-        self._plot_operator_counts(r_ax,
-                                   self.statistics.repair_operator_counts,
-                                   "Repair operators",
-                                   len(legend),
-                                   **kwargs)
+        self._plot_op_counts(r_ax,
+                             self.statistics.repair_operator_counts,
+                             "Repair operators",
+                             min(len(legend), 4),
+                             **kwargs)
 
-        figure.legend(legend, ncol=len(legend), loc="lower center")
+        fig.legend(legend[:4], ncol=len(legend), loc="lower center")
 
         plt.draw_if_interactive()
 
     @staticmethod
-    def _plot_operator_counts(ax, operator_counts, title, num_types, **kwargs):
+    def _plot_op_counts(ax, operator_counts, title, num_types, **kwargs):
         """
         Internal helper that plots the passed-in operator_counts on the given
         ax object.
diff --git a/alns/State.py b/alns/State.py
index 48de59f..46c20d8 100644
--- a/alns/State.py
+++ b/alns/State.py
@@ -4,21 +4,19 @@
 class State(ABC):
     """
     State object, which stores a solution via its decision variables. The
-    objective value is evaluated via its ``objective()`` member, and should
-    return a numeric type - e.g. an ``int``, ``float``, or comparable.
+    objective value is evaluated via its ``objective()`` member.
 
     The State class is abstract - you are encouraged to subclass it to suit
     your specific problem.
     """
 
     @abstractmethod
-    def objective(self):
+    def objective(self) -> float:
         """
         Computes the state's associated objective value.
 
         Returns
         -------
-        float
-            Some numeric value, e.g. an ``int`` or ``float``.
+        Some numeric value, e.g. an ``int`` or ``float``.
         """
         return NotImplemented
diff --git a/alns/Statistics.py b/alns/Statistics.py
index 914cd56..edfffc4 100644
--- a/alns/Statistics.py
+++ b/alns/Statistics.py
@@ -1,4 +1,5 @@
 from collections import defaultdict
+from typing import DefaultDict, List
 
 import numpy as np
 
@@ -16,14 +17,14 @@ def __init__(self):
         self._repair_operator_counts = defaultdict(lambda: [0, 0, 0, 0])
 
     @property
-    def objectives(self):
+    def objectives(self) -> np.ndarray:
         """
         Returns an array of previous objective values, tracking progress.
         """
         return np.array(self._objectives)
 
     @property
-    def destroy_operator_counts(self):
+    def destroy_operator_counts(self) -> DefaultDict[str, List[float]]:
         """
         Returns the destroy operator counts, as a dictionary of operator names
         to lists of counts. Such a list consists of four elements, one for
@@ -32,13 +33,12 @@ def destroy_operator_counts(self):
 
         Returns
         -------
-        defaultdict
-            Destroy operator counts.
+        Destroy operator counts.
         """
         return self._destroy_operator_counts
 
     @property
-    def repair_operator_counts(self):
+    def repair_operator_counts(self) -> DefaultDict[str, List[float]]:
         """
         Returns the repair operator counts, as a dictionary of operator names
         to lists of counts. Such a list consists of four elements, one for
@@ -47,50 +47,49 @@ def repair_operator_counts(self):
 
         Returns
         -------
-        defaultdict
-            Repair operator counts.
+        Repair operator counts.
         """
         return self._repair_operator_counts
 
-    def collect_objective(self, objective):
+    def collect_objective(self, objective: float):
         """
         Collects an objective value.
 
         Parameters
         ----------
-        objective : float
+        objective
             The objective value to be collected.
         """
         self._objectives.append(objective)
 
-    def collect_destroy_operator(self, operator_name, weight_idx):
+    def collect_destroy_operator(self, operator_name: str, s_idx: int):
         """
-        Collects a weight (index) for a used destroy operator. This maintains
+        Collects a score (index) for a used destroy operator. This maintains
         count of the number of times this operator was used, and what result
         came from its use.
 
         Parameters
         ----------
-        operator_name : str
+        operator_name
             Operator name. This was set when the operator was passed to the
             ALNS instance.
-        weight_idx : int
-            Weight indices used for the various iteration outcomes.
+        s_idx
+            Score indices used for the various iteration outcomes.
         """
-        self._destroy_operator_counts[operator_name][weight_idx] += 1
+        self._destroy_operator_counts[operator_name][s_idx] += 1
 
-    def collect_repair_operator(self, operator_name, weight_idx):
+    def collect_repair_operator(self, operator_name: str, s_idx: int):
         """
-        Collects a weight (index) for a used repair operator. This maintains
+        Collects a score (index) for a used repair operator. This maintains
         count of the number of times this operator was used, and what result
         came from its use.
 
         Parameters
         ----------
-        operator_name : str
+        operator_name
             Operator name. This was set when the operator was passed to the
             ALNS instance.
-        weight_idx : int
-            Weight indices used for the various iteration outcomes.
+        s_idx
+            Score indices used for the various iteration outcomes.
         """
-        self._repair_operator_counts[operator_name][weight_idx] += 1
+        self._repair_operator_counts[operator_name][s_idx] += 1
diff --git a/alns/criteria/AcceptanceCriterion.py b/alns/criteria/AcceptanceCriterion.py
index ce71a16..41daca7 100644
--- a/alns/criteria/AcceptanceCriterion.py
+++ b/alns/criteria/AcceptanceCriterion.py
@@ -1,7 +1,8 @@
 from abc import ABC, abstractmethod
 
-from ..State import State  # pylint: disable=unused-import
-from numpy.random import RandomState  # pylint: disable=unused-import
+from numpy.random import RandomState
+
+from alns.State import State
 
 
 class AcceptanceCriterion(ABC):
@@ -10,25 +11,28 @@ class AcceptanceCriterion(ABC):
     """
 
     @abstractmethod
-    def accept(self, rnd, best, current, candidate):
+    def __call__(self,
+                 rnd: RandomState,
+                 best: State,
+                 current: State,
+                 candidate: State) -> bool:
         """
         Determines whether to accept the proposed, candidate solution based on
         this acceptance criterion and the other solution states.
 
         Parameters
         ----------
-        rnd : RandomState
+        rnd
             May be used to draw random numbers from.
-        best : State
+        best
             The best solution state observed so far.
-        current : State
+        current
             The current solution state.
-        candidate : State
+        candidate
             The proposed solution state.
 
         Returns
         -------
-        bool
-            Whether to accept the candidate state (True), or not (False).
+        Whether to accept the candidate state (True), or not (False).
         """
         return NotImplemented
diff --git a/alns/criteria/HillClimbing.py b/alns/criteria/HillClimbing.py
index 1f13a61..a8bde38 100644
--- a/alns/criteria/HillClimbing.py
+++ b/alns/criteria/HillClimbing.py
@@ -1,4 +1,4 @@
-from .AcceptanceCriterion import AcceptanceCriterion
+from alns.criteria.AcceptanceCriterion import AcceptanceCriterion
 
 
 class HillClimbing(AcceptanceCriterion):
@@ -7,5 +7,5 @@ class HillClimbing(AcceptanceCriterion):
     that result in a worse objective value.
     """
 
-    def accept(self, rnd, best, current, candidate):
+    def __call__(self, rnd, best, current, candidate):
         return candidate.objective() <= current.objective()
diff --git a/alns/criteria/RecordToRecordTravel.py b/alns/criteria/RecordToRecordTravel.py
index 591b019..15a042a 100644
--- a/alns/criteria/RecordToRecordTravel.py
+++ b/alns/criteria/RecordToRecordTravel.py
@@ -1,10 +1,14 @@
-from .AcceptanceCriterion import AcceptanceCriterion
-from .update import update
+from alns.criteria.AcceptanceCriterion import AcceptanceCriterion
+from alns.criteria.update import update
 
 
 class RecordToRecordTravel(AcceptanceCriterion):
 
-    def __init__(self, start_threshold, end_threshold, step, method="linear"):
+    def __init__(self,
+                 start_threshold: float,
+                 end_threshold: float,
+                 step: float,
+                 method: str = "linear"):
         """
         Record-to-record travel, using an updating threshold. The threshold is
         updated as,
@@ -17,24 +21,24 @@ def __init__(self, start_threshold, end_threshold, step, method="linear"):
 
         Parameters
         ----------
-        start_threshold : float
+        start_threshold
             The initial threshold.
-        end_threshold : float
+        end_threshold
             The final threshold.
-        step : float
+        step
             The updating step.
-        method : str
+        method
             The updating method, one of {'linear', 'exponential'}. Default
             'linear'.
 
         References
         ----------
-        - Santini, A., Ropke, S. & Hvattum, L.M. A comparison of acceptance
-          criteria for the adaptive large neighbourhood search metaheuristic.
-          *Journal of Heuristics* (2018) 24 (5): 783–815.
-        - Dueck, G., Scheuer, T. Threshold accepting: A general purpose
-          optimization algorithm appearing superior to simulated annealing.
-          *Journal of Computational Physics* (1990) 90 (1): 161-175.
+        [1]: Santini, A., Ropke, S. & Hvattum, L.M. A comparison of acceptance
+             criteria for the adaptive large neighbourhood search metaheuristic.
+             *Journal of Heuristics* (2018) 24 (5): 783–815.
+        [2]: Dueck, G., Scheuer, T. Threshold accepting: A general purpose
+             optimization algorithm appearing superior to simulated annealing.
+             *Journal of Computational Physics* (1990) 90 (1): 161-175.
         """
         if start_threshold < 0 or end_threshold < 0 or step < 0:
             raise ValueError("Thresholds must be positive.")
@@ -55,22 +59,22 @@ def __init__(self, start_threshold, end_threshold, step, method="linear"):
         self._threshold = start_threshold
 
     @property
-    def start_threshold(self):
+    def start_threshold(self) -> float:
         return self._start_threshold
 
     @property
-    def end_threshold(self):
+    def end_threshold(self) -> float:
         return self._end_threshold
 
     @property
-    def step(self):
+    def step(self) -> float:
         return self._step
 
     @property
-    def method(self):
+    def method(self) -> str:
         return self._method
 
-    def accept(self, rnd, best, current, candidate):
+    def __call__(self, rnd, best, current, candidate):
         # This follows from the paper by Dueck and Scheueur (1990), p. 162.
         result = (candidate.objective() - best.objective()) <= self._threshold
 
diff --git a/alns/criteria/SimulatedAnnealing.py b/alns/criteria/SimulatedAnnealing.py
index 189f17e..378b965 100644
--- a/alns/criteria/SimulatedAnnealing.py
+++ b/alns/criteria/SimulatedAnnealing.py
@@ -1,13 +1,16 @@
 import numpy as np
 
-from .AcceptanceCriterion import AcceptanceCriterion
-from .update import update
+from alns.criteria.AcceptanceCriterion import AcceptanceCriterion
+from alns.criteria.update import update
 
 
 class SimulatedAnnealing(AcceptanceCriterion):
 
-    def __init__(self, start_temperature, end_temperature, step,
-                 method="linear"):
+    def __init__(self,
+                 start_temperature: float,
+                 end_temperature: float,
+                 step: float,
+                 method: str = "exponential"):
         """
         Simulated annealing, using an updating temperature. The temperature is
         updated as,
@@ -20,23 +23,23 @@ def __init__(self, start_temperature, end_temperature, step,
 
         Parameters
         ----------
-        start_temperature : float
+        start_temperature
             The initial temperature.
-        end_temperature : float
+        end_temperature
             The final temperature.
-        step : float
+        step
             The updating step.
-        method : str
+        method
             The updating method, one of {'linear', 'exponential'}. Default
-            'linear'.
+            'exponential'.
 
         References
         ----------
-        - Santini, A., Ropke, S. & Hvattum, L.M. A comparison of acceptance
-          criteria for the adaptive large neighbourhood search metaheuristic.
-          *Journal of Heuristics* (2018) 24 (5): 783–815.
-        - Kirkpatrick, S., Gerlatt, C. D. Jr., and Vecchi, M. P. Optimization
-          by Simulated Annealing. *IBM Research Report* RC 9355, 1982.
+        [1]: Santini, A., Ropke, S. & Hvattum, L.M. A comparison of acceptance
+             criteria for the adaptive large neighbourhood search metaheuristic.
+             *Journal of Heuristics* (2018) 24 (5): 783–815.
+        [2]: Kirkpatrick, S., Gerlatt, C. D. Jr., and Vecchi, M. P. Optimization
+             by Simulated Annealing. *IBM Research Report* RC 9355, 1982.
         """
         if start_temperature <= 0 or end_temperature <= 0 or step < 0:
             raise ValueError("Temperatures must be strictly positive.")
@@ -57,22 +60,22 @@ def __init__(self, start_temperature, end_temperature, step,
         self._temperature = start_temperature
 
     @property
-    def start_temperature(self):
+    def start_temperature(self) -> float:
         return self._start_temperature
 
     @property
-    def end_temperature(self):
+    def end_temperature(self) -> float:
         return self._end_temperature
 
     @property
-    def step(self):
+    def step(self) -> float:
         return self._step
 
     @property
-    def method(self):
+    def method(self) -> str:
         return self._method
 
-    def accept(self, rnd, best, current, candidate):
+    def __call__(self, rnd, best, current, candidate):
         probability = np.exp((current.objective() - candidate.objective())
                              / self._temperature)
 
@@ -88,3 +91,64 @@ def accept(self, rnd, best, current, candidate):
             return probability >= rnd.random()
         except AttributeError:
             return probability >= rnd.random_sample()
+
+    @classmethod
+    def autofit(cls,
+                init_obj: float,
+                worse: float,
+                accept_prob: float,
+                num_iters: int) -> "SimulatedAnnealing":
+        """
+        Returns an SA object with initial temperature such that there is a
+        ``accept_prob`` chance of selecting a solution up to ``worse`` percent
+        worse than the initial solution. The step parameter is then chosen such
+        that the temperature reaches 1 in ``num_iters`` iterations.
+
+        This procedure was originally proposed by Ropke and Pisinger (2006),
+        and has seen some use since - i.a. Roozbeh et al. (2018).
+
+        Parameters
+        ----------
+        init_obj
+            The initial solution objective.
+        worse
+            Percentage (between 0 and 1) the candidate solution may be worse
+            than initial solution for it to be accepted with probability
+            ``accept_prob``.
+        accept_prob
+            Initial acceptance probability for a solution at most ``worse``
+            worse than the initial solution.
+        num_iters
+            Number of iterations the ALNS algorithm will run.
+
+        Raises
+        ------
+        ValueError
+            When ``worse`` not in [0, 1] or when ``accept_prob``not in (0, 1).
+
+        Returns
+        -------
+        An autofitted SimulatedAnnealing acceptance criterion.
+
+        References
+        ----------
+        [1]: Ropke, Stefan, and David Pisinger. 2006. "An Adaptive Large
+             Neighborhood Search Heuristic for the Pickup and Delivery Problem
+             with Time Windows." _Transportation Science_ 40 (4): 455 - 472.
+        [2]: Roozbeh et al. 2018. "An Adaptive Large Neighbourhood Search for
+             asset protection during escaped wildfires." _Computers & Operations
+             Research_ 97: 125 - 134.
+        """
+        if not (0 <= worse <= 1):
+            raise ValueError("worse outside [0, 1] not understood.")
+
+        if not (0 < accept_prob < 1):
+            raise ValueError("accept_prob outside (0, 1) not understood.")
+
+        if num_iters < 0:
+            raise ValueError("Negative number of iterations not understood.")
+
+        start_temp = -worse * init_obj / np.log(accept_prob)
+        step = (1 / start_temp) ** (1 / num_iters)
+
+        return cls(start_temp, 1, step, method="exponential")
diff --git a/alns/criteria/update.py b/alns/criteria/update.py
index 31395b3..7c7d2e3 100644
--- a/alns/criteria/update.py
+++ b/alns/criteria/update.py
@@ -1,4 +1,4 @@
-def update(current, step, method):
+def update(current: float, step: float, method: str) -> float:
     """
     Updates the passed-in criterion threshold parameter. This is done in one of
     two ways, determined via ``method``. If ``method`` is linear, then ``step``
@@ -7,17 +7,21 @@ def update(current, step, method):
 
     Parameters
     ----------
-    current : float
+    current
         The current criterion threshold.
-    step : float
+    step
         The chosen step size.
-    method : str
+    method
         The updating method, one of {'linear', 'exponential'}.
 
+    Raises
+    ------
+    ValueError
+        When the method is not understood.
+
     Returns
     -------
-    float
-        The new criterion threshold.
+    The new criterion threshold.
     """
     method = method.lower()
 
diff --git a/alns/select_operator.py b/alns/select_operator.py
deleted file mode 100644
index 4084084..0000000
--- a/alns/select_operator.py
+++ /dev/null
@@ -1,24 +0,0 @@
-import numpy as np
-
-
-def select_operator(operators, weights, rnd_state):
-    """
-    Selects an operator from the list of operators, using a distribution
-    inferred from the given weights.
-
-    Parameters
-    ----------
-    operators : array_like
-        The list of operators.
-    weights : array_like
-        The operator weights.
-    rnd_state : rnd.RandomState
-        Random state to draw the choice from.
-
-    Returns
-    -------
-    int
-        Index into the operator array of the selected method.
-    """
-    return rnd_state.choice(np.arange(0, len(operators)),
-                            p=weights / np.sum(weights))
diff --git a/alns/tools/exceptions.py b/alns/tools/exceptions.py
deleted file mode 100644
index 37cf2ed..0000000
--- a/alns/tools/exceptions.py
+++ /dev/null
@@ -1,6 +0,0 @@
-class NotCollectedError(Exception):
-    """
-    Raised when statistics are accessed from an ALNS result instance, but
-    statistics were not collected during iteration.
-    """
-    pass
diff --git a/alns/tools/warnings.py b/alns/tools/warnings.py
deleted file mode 100644
index 8c132a3..0000000
--- a/alns/tools/warnings.py
+++ /dev/null
@@ -1,6 +0,0 @@
-class OverwriteWarning(UserWarning):
-    """
-    Raised when a new operator has the same name as an already existing operator
-    of that type, and the old is about to be overwritten.
-    """
-    pass
diff --git a/alns/weight_schemes/SegmentedWeights.py b/alns/weight_schemes/SegmentedWeights.py
new file mode 100644
index 0000000..48de926
--- /dev/null
+++ b/alns/weight_schemes/SegmentedWeights.py
@@ -0,0 +1,72 @@
+from typing import List
+
+import numpy as np
+
+from alns.weight_schemes.WeightScheme import WeightScheme
+
+
+class SegmentedWeights(WeightScheme):
+
+    def __init__(self,
+                 scores: List[float],
+                 num_destroy: int,
+                 num_repair: int,
+                 seg_decay: float,
+                 seg_length: int = 100):
+        """
+        A segmented weight scheme. Weights are not updated in each iteration,
+        but only after each segment. Scores are gathered during each segment,
+        as:
+
+        ``seg_weight += score``
+
+        At the start of each segment, ``seg_weight`` is reset to zero. At the
+        end of a segment, the weights are updated as:
+
+        ``new_weight = seg_decay * old_weight + (1 - seg_decay) * seg_weight``
+
+        Parameters
+        ----------
+        (other arguments are explained in ``WeightScheme``)
+
+        seg_decay
+            Decay parameter in [0, 1]. This parameter is used to weigh segment
+            and overall performance of each operator.
+        seg_length
+            Length of a single segment. Default 100.
+        """
+        super().__init__(scores, num_destroy, num_repair)
+
+        if not (0 <= seg_decay <= 1):
+            raise ValueError("seg_decay outside [0, 1] not understood.")
+
+        if seg_length < 1:
+            raise ValueError("seg_length < 1 not understood.")
+
+        self._seg_decay = seg_decay
+        self._seg_length = seg_length
+        self._iter = 0
+
+        self._reset_segment_weights()
+
+    def select_operators(self, rnd_state):
+        self._iter += 1
+
+        if self._iter % self._seg_length == 0:
+            self._d_weights *= self._seg_decay
+            self._d_weights += (1 - self._seg_decay) * self._d_seg_weights
+
+            self._r_weights *= self._seg_decay
+            self._r_weights += (1 - self._seg_decay) * self._r_seg_weights
+
+            self._reset_segment_weights()
+
+        return super().select_operators(rnd_state)
+
+    def update_weights(self, d_idx, r_idx, s_idx):
+        self._d_seg_weights[d_idx] += self._scores[s_idx]
+        self._r_seg_weights[r_idx] += self._scores[s_idx]
+
+    def _reset_segment_weights(self):
+        self._d_seg_weights = np.zeros_like(self._d_weights)
+        self._r_seg_weights = np.zeros_like(self._r_weights)
diff --git a/alns/weight_schemes/SimpleWeights.py b/alns/weight_schemes/SimpleWeights.py
new file mode 100644
index 0000000..7b5d7aa
--- /dev/null
+++ b/alns/weight_schemes/SimpleWeights.py
@@ -0,0 +1,41 @@
+from typing import List
+
+from .WeightScheme import WeightScheme
+
+
+class SimpleWeights(WeightScheme):
+
+    def __init__(self,
+                 scores: List[float],
+                 num_destroy: int,
+                 num_repair: int,
+                 op_decay: float):
+        """
+        A simple weighting scheme, where the operator weights are adjusted
+        continuously throughout the algorithm runs. This works as follows.
+        In each iteration, the old weight is updated with a score based on a
+        convex combination of the existing weight and the new score, as:
+
+        ``new_weight = op_decay * old_weight + (1 - op_decay) * score``
+
+        Parameters
+        ----------
+        (other arguments are explained in ``WeightScheme``)
+
+        op_decay
+            Decay parameter in [0, 1]. This parameter is used to weigh the
+            running performance of each operator.
+        """
+        super().__init__(scores, num_destroy, num_repair)
+
+        if not (0 <= op_decay <= 1):
+            raise ValueError("op_decay outside [0, 1] not understood.")
+
+        self._op_decay = op_decay
+
+    def update_weights(self, d_idx, r_idx, s_idx):
+        self._d_weights[d_idx] *= self._op_decay
+        self._d_weights[d_idx] += (1 - self._op_decay) * self._scores[s_idx]
+
+        self._r_weights[r_idx] *= self._op_decay
+        self._r_weights[r_idx] += (1 - self._op_decay) * self._scores[s_idx]
diff --git a/alns/weight_schemes/WeightScheme.py b/alns/weight_schemes/WeightScheme.py
new file mode 100644
index 0000000..e50d726
--- /dev/null
+++ b/alns/weight_schemes/WeightScheme.py
@@ -0,0 +1,92 @@
+from abc import ABC, abstractmethod
+from typing import List, Tuple
+
+import numpy as np
+from numpy.random import RandomState
+
+
+class WeightScheme(ABC):
+
+    def __init__(self, scores: List[float], num_destroy: int, num_repair: int):
+        """
+        Base class from which to implement a weight scheme.
+
+        Parameters
+        ----------
+        scores
+            A list of four non-negative elements, representing the weight
+            updates when the candidate solution results in a new global best
+            (idx 0), is better than the current solution (idx 1), the solution
+            is accepted (idx 2), or rejected (idx 3).
+        num_destroy
+            Number of destroy operators.
+        num_repair
+            Number of repair operators.
+        """
+        self._validate_arguments(scores, num_destroy, num_repair)
+
+        self._scores = scores
+        self._d_weights = np.ones(num_destroy, dtype=float)
+        self._r_weights = np.ones(num_repair, dtype=float)
+
+    @property
+    def destroy_weights(self) -> np.ndarray:
+        return self._d_weights
+
+    @property
+    def repair_weights(self) -> np.ndarray:
+        return self._r_weights
+
+    def select_operators(self, rnd_state: RandomState) -> Tuple[int, int]:
+        """
+        Selects a destroy and repair operator pair to apply in this iteration.
+        The default implementation uses a roulette wheel mechanism, where each
+        operator is selected based on the normalised weights.
+
+        Parameters
+        ----------
+        rnd_state
+            Random state object, to be used for number generation.
+
+        Returns
+        -------
+        A tuple of (d_idx, r_idx), which are indices into the destroy and repair
+        operator lists, respectively.
+        """
+
+        def select(op_weights):
+            probs = op_weights / np.sum(op_weights)
+            return rnd_state.choice(range(len(op_weights)), p=probs)
+
+        return select(self._d_weights), select(self._r_weights)
+
+    @abstractmethod
+    def update_weights(self, d_idx: int, r_idx: int, s_idx: int):
+        """
+        Updates the weights associated with the applied destroy (d_idx) and
+        repair (r_idx) operators. The score index (s_idx) indicates the
+        outcome.
+
+        Parameters
+        ----------
+        d_idx
+            Destroy operator index.
+        r_idx
+            Repair operator index
+        s_idx
+            Score index.
+        """
+        return NotImplemented
+
+    @staticmethod
+    def _validate_arguments(scores, num_destroy, num_repair):
+        if any(score < 0 for score in scores):
+            raise ValueError("Negative scores are not understood.")
+
+        if len(scores) < 4:
+            # More than four is not problematic, but we only use the first four.
+            raise ValueError("Unsupported number of scores: expected 4, "
+                             "found {0}".format(len(scores)))
+
+        if num_destroy <= 0 or num_repair <= 0:
+            raise ValueError("Missing at least one destroy or repair operator.")
diff --git a/alns/weight_schemes/__init__.py b/alns/weight_schemes/__init__.py
new file mode 100644
index 0000000..8e6bb76
--- /dev/null
+++ b/alns/weight_schemes/__init__.py
@@ -0,0 +1,3 @@
+from .SegmentedWeights import SegmentedWeights
+from .SimpleWeights import SimpleWeights
+from .WeightScheme import WeightScheme
diff --git a/examples/cutting_stock_problem.ipynb b/examples/cutting_stock_problem.ipynb
index a5081c3..3d35e7f 100644
--- a/examples/cutting_stock_problem.ipynb
+++ b/examples/cutting_stock_problem.ipynb
@@ -1,557 +1,557 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import copy\n",
-    "\n",
-    "from functools import partial\n",
-    "\n",
-    "import matplotlib.pyplot as plt\n",
-    "import numpy as np\n",
-    "import numpy.random as rnd\n",
-    "\n",
-    "from alns import ALNS, State\n",
-    "from alns.criteria import HillClimbing"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%matplotlib inline"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "SEED = 5432"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# The cutting-stock problem\n",
-    "\n",
-    "The [cutting-stock problem (CSP)](https://en.wikipedia.org/wiki/Cutting_stock_problem) is well-known problem in operations research. In simple terms, it asks how many pieces of material are needed to cut an ordered amount of differently-sized beams, such that the wastage is minimised. Many different formulations exist, e.g. for the one-, two-, and even three-dimensional case. Here we solve an instance of the one-dimensional problem, obtained from the data [here](http://www.math.tu-dresden.de/~capad/cpd-ti.html#1D). It is known that the optimal solution for this problem requires the use of only 74 beams."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "OPTIMAL_BEAMS = 74"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Each available beam is of length: 1000\n",
-      "Number of beams to be cut (orders): 180\n"
-     ]
-    }
-   ],
-   "source": [
-    "# The first line lists the number of lines for beam orders.\n",
-    "# The second line is the length of the available beams. Each\n",
-    "# following line is an order of (length, amount) tuples.\n",
-    "with open('640.csp') as file:\n",
-    "    data = file.readlines()\n",
-    "\n",
-    "NUM_LINES = int(data[0])\n",
-    "BEAM_LENGTH = int(data[1])\n",
-    "\n",
-    "# Beams to be cut from the available beams\n",
-    "BEAMS = [int(length)\n",
-    "         for datum in data[-NUM_LINES:]\n",
-    "         for length, amount in [datum.strip().split()]\n",
-    "         for _ in range(int(amount))]\n",
-    "\n",
-    "print(\"Each available beam is of length:\", BEAM_LENGTH)\n",
-    "print(\"Number of beams to be cut (orders):\", len(BEAMS))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Operators and solution state\n",
-    "\n",
-    "To use the ALNS meta-heuristic, we need to have destroy and repair operators that work on a proposed solution, and a way to describe such a solution in the first place. The ALNS package exposes the class ``State`` to describe a solution, with an ``objective()`` member that computes this solution's objective value. Using it, we may compute a simple initial solution, and then apply the ALNS algorithm."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Solution state"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class CspState(State):\n",
-    "    \"\"\"\n",
-    "    Solution state for the CSP problem. It has two data members, assignments\n",
-    "    and unassigned. Assignments is a list of lists, one for each beam in use.\n",
-    "    Each entry is another list, containing the ordered beams cut from this \n",
-    "    beam. Each such sublist must sum to at most BEAM_LENGTH. Unassigned is a\n",
-    "    list of ordered beams that are not currently assigned to one of the\n",
-    "    available beams.\n",
-    "    \"\"\"\n",
-    "\n",
-    "    def __init__(self, assignments, unassigned=None):\n",
-    "        self.assignments = assignments\n",
-    "        self.unassigned = []\n",
-    "        \n",
-    "        if unassigned is not None:\n",
-    "            self.unassigned = unassigned\n",
-    "\n",
-    "    def copy(self):\n",
-    "        \"\"\"\n",
-    "        Helper method to ensure each solution state is immutable.\n",
-    "        \"\"\"\n",
-    "        return CspState(copy.deepcopy(self.assignments),\n",
-    "                        self.unassigned.copy())\n",
-    "\n",
-    "    def objective(self):\n",
-    "        \"\"\"\n",
-    "        Computes the total number of beams in use.\n",
-    "        \"\"\"\n",
-    "        return len(self.assignments)\n",
-    "\n",
-    "    def plot(self):\n",
-    "        \"\"\"\n",
-    "        Helper method to plot a solution.\n",
-    "        \"\"\"\n",
-    "        _, ax = plt.subplots(figsize=(12, 6))\n",
-    "\n",
-    "        ax.barh(np.arange(len(self.assignments)), \n",
-    "                [sum(assignment) for assignment in self.assignments], \n",
-    "                height=1)\n",
-    "\n",
-    "        ax.set_xlim(right=BEAM_LENGTH)\n",
-    "        ax.set_yticks(np.arange(len(self.assignments), step=10))\n",
-    "\n",
-    "        ax.margins(x=0, y=0)\n",
-    "\n",
-    "        ax.set_xlabel('Usage')\n",
-    "        ax.set_ylabel('Beam (#)')\n",
-    "\n",
-    "        plt.draw_if_interactive()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def wastage(assignment):\n",
-    "    \"\"\"\n",
-    "    Helper method that computes the wastage on a given beam assignment.\n",
-    "    \"\"\"\n",
-    "    return BEAM_LENGTH - sum(assignment)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Destroy operators\n",
-    "\n",
-    "We will consider two simple destroy operators, **random_removal** and **worst_removal**. Random removal randomly removes currently assigned beams, whereas worst removal removes those beams that are currently cut with the most waste. Both remove a fixed percentage of the current solution state, controlled by a degree of destruction parameter."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "degree_of_destruction = 0.25\n",
-    "\n",
-    "def beams_to_remove(num_beams):\n",
-    "    return int(num_beams * degree_of_destruction)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def random_removal(state, random_state):\n",
-    "    \"\"\"\n",
-    "    Iteratively removes randomly chosen beam assignments.\n",
-    "    \"\"\"\n",
-    "    state = state.copy()\n",
-    "\n",
-    "    for _ in range(beams_to_remove(state.objective())):\n",
-    "        idx = random_state.randint(state.objective())\n",
-    "        state.unassigned.extend(state.assignments.pop(idx))\n",
-    "\n",
-    "    return state"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def worst_removal(state, random_state):\n",
-    "    \"\"\"\n",
-    "    Removes beams in decreasing order of wastage, such that the\n",
-    "    poorest assignments are removed first.\n",
-    "    \"\"\"\n",
-    "    state = state.copy()\n",
-    "\n",
-    "    # Sort assignments by wastage, worst first\n",
-    "    state.assignments.sort(key=wastage, reverse=True)\n",
-    "\n",
-    "    # Removes the worst assignments\n",
-    "    for _ in range(beams_to_remove(state.objective())):\n",
-    "        state.unassigned.extend(state.assignments.pop(0))\n",
-    "\n",
-    "    return state"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Repair operators\n",
-    "\n",
-    "We define two equally simple repair operators, **greedy_insert** and **minimal_wastage**. The first considers each currently unassigned ordered beam, and finds the first beam this order may be inserted into. The second does something similar, but finds a beam where its insertion would result in the smallest beam wastage."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def greedy_insert(state, random_state):\n",
-    "    \"\"\"\n",
-    "    Inserts the unassigned beams greedily into the first fitting\n",
-    "    beam. Shuffles the unassigned ordered beams before inserting.\n",
-    "    \"\"\"\n",
-    "    random_state.shuffle(state.unassigned)\n",
-    "\n",
-    "    while len(state.unassigned) != 0:\n",
-    "        beam = state.unassigned.pop(0)\n",
-    "\n",
-    "        for assignment in state.assignments:\n",
-    "            if beam <= wastage(assignment):\n",
-    "                assignment.append(beam)\n",
-    "                break\n",
-    "        else:\n",
-    "            state.assignments.append([beam])\n",
-    "\n",
-    "    return state"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def minimal_wastage(state, random_state):\n",
-    "    \"\"\"\n",
-    "    For every unassigned ordered beam, the operator determines\n",
-    "    which beam would minimise that beam's waste once the ordered\n",
-    "    beam is inserted.\n",
-    "    \"\"\"\n",
-    "    def insertion_cost(assignment, beam):  # helper method for min\n",
-    "        if beam <= wastage(assignment):\n",
-    "            return wastage(assignment) - beam\n",
-    "\n",
-    "        return float(\"inf\")\n",
-    "\n",
-    "    while len(state.unassigned) != 0:\n",
-    "        beam = state.unassigned.pop(0)\n",
-    "\n",
-    "        assignment = min(state.assignments,\n",
-    "                         key=partial(insertion_cost, beam=beam))\n",
-    "\n",
-    "        if beam <= wastage(assignment):\n",
-    "            assignment.append(beam) \n",
-    "        else:\n",
-    "            state.assignments.append([beam])\n",
-    "\n",
-    "    return state"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Initial solution"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Initial solution has objective value: 81\n"
-     ]
-    }
-   ],
-   "source": [
-    "rnd_state = rnd.RandomState(SEED)\n",
-    "\n",
-    "state = CspState([], BEAMS.copy())\n",
-    "initial_solution = greedy_insert(state, rnd_state)\n",
-    "\n",
-    "print(\"Initial solution has objective value:\", initial_solution.objective())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 864x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "initial_solution.plot()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Heuristic solution"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "alns = ALNS(rnd_state)\n",
-    "\n",
-    "alns.add_destroy_operator(random_removal)\n",
-    "alns.add_destroy_operator(worst_removal)\n",
-    "\n",
-    "alns.add_repair_operator(greedy_insert)\n",
-    "alns.add_repair_operator(minimal_wastage)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "criterion = HillClimbing()\n",
-    "\n",
-    "result = alns.iterate(initial_solution, [3, 2, 1, 0.5], 0.8, criterion,\n",
-    "                      iterations=5000, collect_stats=True)\n",
-    "\n",
-    "solution = result.best_state\n",
-    "\n",
-    "objective = solution.objective()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 864x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "_, ax = plt.subplots(figsize=(12, 6))\n",
-    "result.plot_objectives(ax=ax)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Having obtained a reasonable solution, we now want to investigate each operator's performance. This may be done via the `plot_operator_counts()` method on the `result` object, like below. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 864x432 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "figure = plt.figure(\"operator_counts\", figsize=(12, 6))\n",
-    "figure.subplots_adjust(bottom=0.15, hspace=.5)\n",
-    "result.plot_operator_counts(figure=figure, title=\"Operator diagnostics\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Several conclusions follow,\n",
-    "\n",
-    "* The destroy operators are about equally good, so there is little to be gained changing these around.\n",
-    "* The repair operators, however, are not created equal: the `minimal_wastage` operator is significantly better than the simple `greedy_insert`. This makes intuitive sense, as minimising wastage exploits the assignment structure much better than a simple insertion heuristic does. It follows that the `greedy_insert` operator is actually not all that useful, and may be dropped from the ALNS heuristic altogether."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Heuristic solution has objective value: 75\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(\"Heuristic solution has objective value:\", solution.objective())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 864x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "solution.plot()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Number of beams used is 75, which is 1 more than the optimal value, which was 74.\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(\"Number of beams used is {0}, which is {1} more than the optimal value, which was {2}.\"\n",
-    "      .format(solution.objective(), solution.objective() - OPTIMAL_BEAMS, OPTIMAL_BEAMS))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Conclusions\n",
-    "\n",
-    "In the code above we implement a simple ALNS-based heuristic for the CSP. Although the operators are simple and few, we do find very good results in limited time: we require just one more beam than optimal solution does, a result that is **1.35%** above optimal.\n",
-    "\n",
-    "This notebook offers another case where the ALNS library may be put to use to construct powerful, efficient heuristic pipelines from simple, locally greedy operators."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import copy\n",
+    "\n",
+    "from functools import partial\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import numpy.random as rnd\n",
+    "\n",
+    "from alns import ALNS, State\n",
+    "from alns.criteria import HillClimbing\n",
+    "from alns.weight_schemes import SimpleWeights"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "SEED = 5432"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# The cutting-stock problem\n",
+    "\n",
+    "The [cutting-stock problem (CSP)](https://en.wikipedia.org/wiki/Cutting_stock_problem) is well-known problem in operations research. In simple terms, it asks how many pieces of material are needed to cut an ordered amount of differently-sized beams, such that the wastage is minimised. Many different formulations exist, e.g. for the one-, two-, and even three-dimensional case. Here we solve an instance of the one-dimensional problem, obtained from the data [here](http://www.math.tu-dresden.de/~capad/cpd-ti.html#1D). It is known that the optimal solution for this problem requires the use of only 74 beams."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "OPTIMAL_BEAMS = 74"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Each available beam is of length: 1000\n",
+      "Number of beams to be cut (orders): 180\n"
+     ]
+    }
+   ],
+   "source": [
+    "# The first line lists the number of lines for beam orders.\n",
+    "# The second line is the length of the available beams. Each\n",
+    "# following line is an order of (length, amount) tuples.\n",
+    "with open('640.csp') as file:\n",
+    "    data = file.readlines()\n",
+    "\n",
+    "NUM_LINES = int(data[0])\n",
+    "BEAM_LENGTH = int(data[1])\n",
+    "\n",
+    "# Beams to be cut from the available beams\n",
+    "BEAMS = [int(length)\n",
+    "         for datum in data[-NUM_LINES:]\n",
+    "         for length, amount in [datum.strip().split()]\n",
+    "         for _ in range(int(amount))]\n",
+    "\n",
+    "print(\"Each available beam is of length:\", BEAM_LENGTH)\n",
+    "print(\"Number of beams to be cut (orders):\", len(BEAMS))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Operators and solution state\n",
+    "\n",
+    "To use the ALNS meta-heuristic, we need to have destroy and repair operators that work on a proposed solution, and a way to describe such a solution in the first place. The ALNS package exposes the class ``State`` to describe a solution, with an ``objective()`` member that computes this solution's objective value. Using it, we may compute a simple initial solution, and then apply the ALNS algorithm."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Solution state"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class CspState(State):\n",
+    "    \"\"\"\n",
+    "    Solution state for the CSP problem. It has two data members, assignments\n",
+    "    and unassigned. Assignments is a list of lists, one for each beam in use.\n",
+    "    Each entry is another list, containing the ordered beams cut from this \n",
+    "    beam. Each such sublist must sum to at most BEAM_LENGTH. Unassigned is a\n",
+    "    list of ordered beams that are not currently assigned to one of the\n",
+    "    available beams.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    def __init__(self, assignments, unassigned=None):\n",
+    "        self.assignments = assignments\n",
+    "        self.unassigned = []\n",
+    "        \n",
+    "        if unassigned is not None:\n",
+    "            self.unassigned = unassigned\n",
+    "\n",
+    "    def copy(self):\n",
+    "        \"\"\"\n",
+    "        Helper method to ensure each solution state is immutable.\n",
+    "        \"\"\"\n",
+    "        return CspState(copy.deepcopy(self.assignments),\n",
+    "                        self.unassigned.copy())\n",
+    "\n",
+    "    def objective(self):\n",
+    "        \"\"\"\n",
+    "        Computes the total number of beams in use.\n",
+    "        \"\"\"\n",
+    "        return len(self.assignments)\n",
+    "\n",
+    "    def plot(self):\n",
+    "        \"\"\"\n",
+    "        Helper method to plot a solution.\n",
+    "        \"\"\"\n",
+    "        _, ax = plt.subplots(figsize=(12, 6))\n",
+    "\n",
+    "        ax.barh(np.arange(len(self.assignments)), \n",
+    "                [sum(assignment) for assignment in self.assignments], \n",
+    "                height=1)\n",
+    "\n",
+    "        ax.set_xlim(right=BEAM_LENGTH)\n",
+    "        ax.set_yticks(np.arange(len(self.assignments), step=10))\n",
+    "\n",
+    "        ax.margins(x=0, y=0)\n",
+    "\n",
+    "        ax.set_xlabel('Usage')\n",
+    "        ax.set_ylabel('Beam (#)')\n",
+    "\n",
+    "        plt.draw_if_interactive()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def wastage(assignment):\n",
+    "    \"\"\"\n",
+    "    Helper method that computes the wastage on a given beam assignment.\n",
+    "    \"\"\"\n",
+    "    return BEAM_LENGTH - sum(assignment)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Destroy operators\n",
+    "\n",
+    "We will consider two simple destroy operators, **random_removal** and **worst_removal**. Random removal randomly removes currently assigned beams, whereas worst removal removes those beams that are currently cut with the most waste. Both remove a fixed percentage of the current solution state, controlled by a degree of destruction parameter."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "degree_of_destruction = 0.25\n",
+    "\n",
+    "def beams_to_remove(num_beams):\n",
+    "    return int(num_beams * degree_of_destruction)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def random_removal(state, random_state):\n",
+    "    \"\"\"\n",
+    "    Iteratively removes randomly chosen beam assignments.\n",
+    "    \"\"\"\n",
+    "    state = state.copy()\n",
+    "\n",
+    "    for _ in range(beams_to_remove(state.objective())):\n",
+    "        idx = random_state.randint(state.objective())\n",
+    "        state.unassigned.extend(state.assignments.pop(idx))\n",
+    "\n",
+    "    return state"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def worst_removal(state, random_state):\n",
+    "    \"\"\"\n",
+    "    Removes beams in decreasing order of wastage, such that the\n",
+    "    poorest assignments are removed first.\n",
+    "    \"\"\"\n",
+    "    state = state.copy()\n",
+    "\n",
+    "    # Sort assignments by wastage, worst first\n",
+    "    state.assignments.sort(key=wastage, reverse=True)\n",
+    "\n",
+    "    # Removes the worst assignments\n",
+    "    for _ in range(beams_to_remove(state.objective())):\n",
+    "        state.unassigned.extend(state.assignments.pop(0))\n",
+    "\n",
+    "    return state"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Repair operators\n",
+    "\n",
+    "We define two equally simple repair operators, **greedy_insert** and **minimal_wastage**. The first considers each currently unassigned ordered beam, and finds the first beam this order may be inserted into. The second does something similar, but finds a beam where its insertion would result in the smallest beam wastage."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def greedy_insert(state, random_state):\n",
+    "    \"\"\"\n",
+    "    Inserts the unassigned beams greedily into the first fitting\n",
+    "    beam. Shuffles the unassigned ordered beams before inserting.\n",
+    "    \"\"\"\n",
+    "    random_state.shuffle(state.unassigned)\n",
+    "\n",
+    "    while len(state.unassigned) != 0:\n",
+    "        beam = state.unassigned.pop(0)\n",
+    "\n",
+    "        for assignment in state.assignments:\n",
+    "            if beam <= wastage(assignment):\n",
+    "                assignment.append(beam)\n",
+    "                break\n",
+    "        else:\n",
+    "            state.assignments.append([beam])\n",
+    "\n",
+    "    return state"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def minimal_wastage(state, random_state):\n",
+    "    \"\"\"\n",
+    "    For every unassigned ordered beam, the operator determines\n",
+    "    which beam would minimise that beam's waste once the ordered\n",
+    "    beam is inserted.\n",
+    "    \"\"\"\n",
+    "    def insertion_cost(assignment, beam):  # helper method for min\n",
+    "        if beam <= wastage(assignment):\n",
+    "            return wastage(assignment) - beam\n",
+    "\n",
+    "        return float(\"inf\")\n",
+    "\n",
+    "    while len(state.unassigned) != 0:\n",
+    "        beam = state.unassigned.pop(0)\n",
+    "\n",
+    "        assignment = min(state.assignments,\n",
+    "                         key=partial(insertion_cost, beam=beam))\n",
+    "\n",
+    "        if beam <= wastage(assignment):\n",
+    "            assignment.append(beam) \n",
+    "        else:\n",
+    "            state.assignments.append([beam])\n",
+    "\n",
+    "    return state"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Initial solution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Initial solution has objective value: 81\n"
+     ]
+    }
+   ],
+   "source": [
+    "rnd_state = rnd.RandomState(SEED)\n",
+    "\n",
+    "state = CspState([], BEAMS.copy())\n",
+    "init_sol = greedy_insert(state, rnd_state)\n",
+    "\n",
+    "print(\"Initial solution has objective value:\", init_sol.objective())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 864x432 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "init_sol.plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Heuristic solution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "alns = ALNS(rnd_state)\n",
+    "\n",
+    "alns.add_destroy_operator(random_removal)\n",
+    "alns.add_destroy_operator(worst_removal)\n",
+    "\n",
+    "alns.add_repair_operator(greedy_insert)\n",
+    "alns.add_repair_operator(minimal_wastage)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "criterion = HillClimbing()\n",
+    "weights = SimpleWeights([3, 2, 1, 0.5], 2, 2, 0.8)\n",
+    "\n",
+    "result = alns.iterate(init_sol, weights, criterion, iterations=5000)\n",
+    "solution = result.best_state\n",
+    "objective = solution.objective()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 864x432 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "_, ax = plt.subplots(figsize=(12, 6))\n",
+    "result.plot_objectives(ax=ax)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Having obtained a reasonable solution, we now want to investigate each operator's performance. This may be done via the `plot_operator_counts()` method on the `result` object, like below. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 864x432 with 2 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "figure = plt.figure(\"operator_counts\", figsize=(12, 6))\n",
+    "figure.subplots_adjust(bottom=0.15, hspace=.5)\n",
+    "result.plot_operator_counts(figure, title=\"Operator diagnostics\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Several conclusions follow,\n",
+    "\n",
+    "* The destroy operators are about equally good, so there is little to be gained changing these around.\n",
+    "* The repair operators, however, are not created equal: the `minimal_wastage` operator is significantly better than the simple `greedy_insert`. This makes intuitive sense, as minimising wastage exploits the assignment structure much better than a simple insertion heuristic does. It follows that the `greedy_insert` operator is actually not all that useful, and may be dropped from the ALNS heuristic altogether."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Heuristic solution has objective value: 75\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Heuristic solution has objective value:\", solution.objective())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 864x432 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "solution.plot()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of beams used is 75, which is 1 more than the optimal value, which was 74.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Number of beams used is {0}, which is {1} more than the optimal value, which was {2}.\"\n",
+    "      .format(solution.objective(), solution.objective() - OPTIMAL_BEAMS, OPTIMAL_BEAMS))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Conclusions\n",
+    "\n",
+    "In the code above we implement a simple ALNS-based heuristic for the CSP. Although the operators are simple and few, we do find very good results in limited time: we require just one more beam than optimal solution does, a result that is **1.35%** above optimal.\n",
+    "\n",
+    "This notebook offers another case where the ALNS library may be put to use to construct powerful, efficient heuristic pipelines from simple, locally greedy operators."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
\ No newline at end of file
diff --git a/examples/travelling_salesman_problem.ipynb b/examples/travelling_salesman_problem.ipynb
index 5c089aa..57a6cf1 100644
--- a/examples/travelling_salesman_problem.ipynb
+++ b/examples/travelling_salesman_problem.ipynb
@@ -1,697 +1,681 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from alns import ALNS, State\n",
-    "from alns.criteria import HillClimbing\n",
-    "\n",
-    "import copy\n",
-    "import itertools\n",
-    "\n",
-    "import numpy.random as rnd\n",
-    "\n",
-    "import networkx as nx\n",
-    "\n",
-    "import tsplib95\n",
-    "import tsplib95.distances as distances\n",
-    "\n",
-    "import matplotlib.pyplot as plt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%matplotlib inline"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "SEED = 9876"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# The travelling salesman problem\n",
-    "\n",
-    "The travelling salesman problem (TSP) is a classic problem in operations research. It asks how to construct the minimum distance tour between a number of cities, such that each city is visited once and the tour concludes at the starting city (that is, it forms a cycle). It is perhaps the best-known problem in the class of [NP-hard](https://en.wikipedia.org/wiki/NP-hardness) problems.\n",
-    "\n",
-    "### Data\n",
-    "There are a considerable number of test data sets available for the TSP, varying in size from a hundred or so locations to many hundreds of thousands. For the sake of exposition, we shall use one of the smaller data sets: the data from the XQF131 VLSI instance, made available [here](http://www.math.uwaterloo.ca/tsp/vlsi/index.html#XQF131). It consists of 'only' 131 cities, with an optimal tour length of 564."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Total optimal tour length is 564.\n"
-     ]
-    }
-   ],
-   "source": [
-    "data = tsplib95.load('xqf131.tsp')\n",
-    "\n",
-    "# These we will use in our representation of a TSP problem: a list of\n",
-    "# (city, coord)-tuples.\n",
-    "cities = [(city, tuple(coord)) for city, coord in data.node_coords.items()]\n",
-    "\n",
-    "solution = tsplib95.load('xqf131.opt.tour')\n",
-    "optimal = data.trace_tours(solution.tours)[0]\n",
-    "\n",
-    "print('Total optimal tour length is {0}.'.format(optimal))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def draw_graph(graph, only_nodes=False):\n",
-    "    \"\"\"\n",
-    "    Helper method for drawing TSP (tour) graphs.\n",
-    "    \"\"\"\n",
-    "    fig, ax = plt.subplots(figsize=(12, 6))\n",
-    "\n",
-    "    if only_nodes:\n",
-    "        nx.draw_networkx_nodes(graph, data.node_coords, node_size=25, ax=ax)\n",
-    "    else:\n",
-    "        nx.draw_networkx(graph, data.node_coords, node_size=25, with_labels=False, ax=ax)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAArMAAAFbCAYAAADGGAZpAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAGChJREFUeJzt3U+LFOfaB+C7nWHCuPAonGNQThI3ItHFCTlN3Cr5HAFx7cdxHQQ/iG4T2sNsFMRNjEHB94UZZqFksKfeRZyXnh7b09VT1fX8ua5l0eBzP131zC+h7rtHTdMEAADk6MzQCwAAgFUJswAAZEuYBQAgW8IsAADZEmYBAMiWMAsAQLaEWQAAsiXMAgCQLWEWAIBsbbb58N///vfmypUrPS0FAAAinjx58r9N0/xjmc+2CrNXrlyJyWSy2qoAAGAJo9Ho5bKf9ZoBAADZEmYBAMiWMAsAQLaEWQAAsiXMAgCQLWEWAIBsCbMAAGRLmAUAIFvCLAAA2RJmAQDIVqufs4VaTA+bePz8bTx9vR83Lp+LW9cuxsaZ0dDLYgA13AtqBHImzMKc6WETP/38S+y82ov3B9PY3tqI7746Hw/v3vTHrzI13AtqLKNGqJnXDGDO4+dvY+fVXrw7mEYTEe8OprHzai8eP3879NJYsxruBTUCuRNmYc7T1/vx/mB67Nr7g2k8e7M/0IoYSg33ghqB3AmzMOfG5XOxvbVx7Nr21kZcv3RuoBUxlBruBTUCuRNmYc6taxfju6/Ox9mtjRhFxNmP79fdunZx6KWxZjXcC2oEcjdqmmbpD4/H42YymfS4HEjDUefzszf7cf2Szuea1XAvqBFIzWg0etI0zXipzwqzAACkpE2Y9ZoBAADZEmYBAMiWMAsAQLaEWQAAsiXMAgCQrc2hF0CejsbcPH29HzcuG3NDuWq419UI5EyYpbXpYRM//fxL7Lzai/cH09j+OID84d2b/jhQlBrudTWWUSPUzGsGtPb4+dvYebUX7w6m0UTEu4Np7Lzai8fP3w69NOhUDfe6GoHcCbO09vT1frw/mB679v5gGs/e7A+0IuhHDfe6GoHcCbO0duPyudje2jh2bXtrI65fOjfQiqAfNdzragRyJ8zS2q1rF+O7r87H2a2NGEXE2Y/vn926dnHopUGnarjX1QjkbtQ0zdIfHo/HzWQy6XE55OLgw2Hcf/QiJr/txvjKhbh3+2psbfpvI8pz1AX/7M1+XL80XBd8n934qdTYpxpqhJKMRqMnTdOMl/qsMEtbOoNhvTxzQG3ahFn/K43WdAbDennmABYTZmlNZzCsl2cOYDFhltZ0BsN6eeYAFhNmaU1nMKyXZw5gMQ1gc0r//e6u6iu9M7j0+4D8lP7MAcwyzWBFpXcMl15fV+wTAAzLNIMVld4xXHp9XbFPAJAPYXZG6R3DpdfXFfsEAPkQZmeU3jFcen1dsU8AkA9hdkbpHcOl19cV+wQA+dAANqf0juHS6+uKfQKA4ZhmQO+MrgIA+tImzG72vRjKY3QVAJAK78zSmtFVAEAqhFlaM7oKAEiFMEtrRlcBAKkQZmnN6CoAIBUawGht48woHtz5Ie4/ehGT33ZjfOVC3Lt9VfNXT0yOAGY5E+A4YZbWpodN3Hnw6/9PM9j5Yy8mL3dNM+iByRHALGcCnOQ1A1ozzWB97DUwy5kAJwmztGaawfrYa2CWMwFOEmZpzTSD9bHXwCxnApwkzNKaaQbrY6+BWc4EOGnUNM3SHx6Px81kMulxOeTiqJv22Zv9uH6pvG7alLqFS99roB1nAjUYjUZPmqYZL/VZYRaO0y0MAMNqE2a9ZgBzdAsDQD6EWZijWxgA8iHMwhzdwgCQD2EW5ugWBoB8JP1ztil1lHNcyd/NxplRPLx7U7cwcEyf517JZyr0Ldkwq6M8XTV8NxtnRvHjt1/Gj99+OfRSgAT0ee7VcKZCn5J9zUBHebp8N0Bt+jz3nKlwOsmGWR3l6fLdALXp89xzpsLpJBtmdZSny3cD1KbPc8+ZCqeTbJjVUZ4u3w1Qmz7PPWcqnE7SP2fr96fT5bsBatPnuedMhePa/Jxt0mEWMLIHWB/nDaloE2aTHc0FGNkDrI/zhlwl+84sYGQPsD7OG3IlzELCjOwB1sV5Q66EWUiYkT3AujhvyJUwCwkzsgdYF+cNuTLNYE7pnZxd1Vf6PqXEyB6o17rPWucNqTCaa0Wld3J2VV/p+wSQAmctNWsTZr1mMKP0Ts6u6it9nwBS4KyF5QizM0rv5OyqvtL3CSAFzlpYjjA7o/ROzq7qK32fAFLgrIXlCLMzSu/k7Kq+0vcJIAXOWliOBrA5pXdydlVf6fvEcky1gH45a6mVaQZA73RaA9AX0wyA3um0BiAFwiywEp3WAKRAmAVWotMagBQIs8BKdFoDkILNoRcA5GnjzCge3r2p0xqAQQmzrMRIJma1GIoC2erz3HOmwuqEWVozkokI9wF16fN+9yzB6XhnltaMZCLCfUBd+rzfPUtwOsIsrRnJRIT7gLr0eb97luB0hFlaM5KJCPcBdenzfvcswekIs7RmJBMR7gPq0uf97lmC0xk1LdqQx+NxM5lMelwOuTjqvC11JFMNncVd1Hjw4TDuP3oRk992Y3zlQty7fTW2Nv03MmXq89xL5Uyt4ewjD6PR6EnTNOOlPivMwnE1dBZ3UWMN+wQ18UyTkjZh1v9CgTk1dBZ3UWMN+wQ18UyTK2EW5tTQWdxFjTXsE9TEM02uhFmYU0NncRc11rBPUBPPNLkSZmFODZ3FXdRYwz5BTTzT5EoDGCspveM1lc7iPnVRYw37BENa91nrmSYVphnQKx2vAP1z1lIz0wzolY5XgP45a2E5wiyt6XgF6J+zFpYjzNKajleA/jlrYTnCLK3peAXon7MWlqMBjJXoeAXon7OWWplmAKxF6SPaYF08S3BcmzC72fdigDIZGwTd8CzB6XhnFliJsUHQDc8SnI4wC6zE2CDohmcJTkeYBVZibBB0w7MEpyPMAisxNgi64VmC0zHNYE7pHaVd1Vf6PvVp0d61uR4RSey/sUHQDc8SHGc014pK7yjtqr7S96lPi/buwZ0f4s6DX5e6/q9//i1GMYqdP+w/AGVqE2a9ZjCj9I7SruorfZ/6tGjv7j96sfT1//y+F09+37X/ABDC7DGld5R2VV/p+9SnRXs3ebm79PU/PxzGnx8OT3zW/gNQI2F2RukdpV3VV/o+9WnR3o2/ubD09S82z8QXm2dOfNb+A1AjYXZG6R2lXdVX+j71adHe3bt9denr3399Pv799QX7DwChAeyE0jtKu6qvln3qY1rAor1rcz0iTr3/JlIAkCrTDOAUapjWUEONAOTLNAM4hRqmNdRQIwB1EGZhTg3TGmqoEYA6CLMwp4ZpDTXUCEAdhFmYU8O0hhpqBKAOGsDgE0qf1hBRR40A5Mk0A3qX8linlNf2OYvWnWs9UJoansUaaiQPbcLsZt+LoTwpj3VKeW2fs2jdD+78EHce/JpdPVCaXM+WNmqokTJ5Z5bWUh7rlPLaPmfRuu8/epFlPVCaXM+WNmqokTIJs7SW8linlNf2OYvWPXm5m2U9UJpcz5Y2aqiRMgmztJbyWKeU1/Y5i9Y9/uZClvVAaXI9W9qooUbKJMzSWspjnVJe2+csWve921ezrAdKk+vZ0kYNNVIm0wxYScpjnQ4+HMb9Ry9i8ttujK9ciHu3r8bWZrv/bhuio3fRnqa811CTGp7FGmokD0ZzUa0uunF19ALAsNqEWa8ZUJQuunF19AJAPoRZitJFN66OXgDIhzBLUbroxtXRCwD5EGYpShfduDp6ASAfSTeA+Y3odKX83XTRjaujtwwp36cAKRv6/CximoGO8nT5bsiB+xRgNSmcn0VMM9BRni7fDTlwnwKsJrfzM9kwq6M8Xb4bcuA+BVhNbudnsmFWR3m6fDfkwH0KsJrczs9kw6yO8nT5bsiB+xRgNbmdn8k2gEVEHHw4jPuPXsTkt90YX7kQ925fja3NZPN3VVLu9h+6A/O/WbS+ttf571K+TwFSNvT5aZoB1Ur9vlm0vgd3fog7D35d+noq9QBAH0wzoFqp3zeL1nf/0YtW11OpBwCGlmyYza2TjjSkft8sWt/k5W6r66nUAwBDSzbM5tZJRxpSv28WrW/8zYVW11OpBwCGlmyYza2TjjSkft8sWt+921dbXU+lHgAYWrINYBHDd9KRp9Tvm0Xra3sdAEpVxDSDoZQ+Bqmr+krfJxjSp56viPDMAdVoE2Y3+15MTlIf63RaXdVX+j7BkD71fP3rn3+LUYxi5w/PHMC8ZN+ZHULqY51Oq6v6St8nGNKnnq///L4XT37f9cwBfIIwOyP1sU6n1VV9pe8TDOlTz9efHw7jzw+Hx6555gD+IszOSH2s02l1VV/p+wRD+tTz9cXmmfhi7qe8PXMAfxFmZ6Q+1um0uqqv9H2CIX3q+fr+6/Px768veOYAPsE0gzmlj0Hqqr6U98mkBXL3qecrIpJ95mpRw9lSQ43kwWguqmXSAtCHGs6WGmokH23CrNcMKIpJC0AfajhbaqiRMgmzFMWkBaAPNZwtNdRImYRZimLSAtCHGs6WGmqkTMIsRTFpAehDDWdLDTVSJg1grCTljteDD4dx/9GLmPy2G+MrF+Le7auxtem/2/qQ8n0AXUt5iktXaqiRPJhmQK9S7nhNeW2lsdcA9MU0A3qVcsdrymsrjb0GIAXCLK2l3PGa8tpKY68BSIEwS2spd7ymvLbS2GsAUiDM0lrKHa8pr6009hqAFGgAYyUpd7ymvLbS2GsA+tCmAWyz78VQpo0zo/jx2y/jx2+/HHopC7X47zSWsGgMV8r3gdFh62OvgaEIsxTFuKh+5LivOa45V/YaGJJ3ZimKcVH9yHFfc1xzruw1MCRhlqIYF9WPHPc1xzXnyl4DQxJmKYpxUf3IcV9zXHOu7DUwJGGWohgX1Y8c9zXHNefKXgNDMpqLlaTcuWxcVD9y3Ncc15wre72clM9OSEmb0VzCLK3pXAZoz9kJy2sTZr1mQGs6lwHac3ZCP4RZWtO5DNCesxP6IczSms5lgPacndAPYZbWdC4DtOfshH5oAGMlpXcu19BxXEON0KUunpnUz07nAqkwzQBOoYaO4xpqhC7V8MzUUCP5MM0ATqGGjuMaaoQu1fDM1FAjZRJmYU4NHcc11AhdquGZqaFGyiTMwpwaOo5rqBG6VMMzU0ONlEmYhTk1dBzXUCN0qYZnpoYaKZMGMPiE1DuOu1BDjdClGp6ZGmokD6YZnELpY0m6qq/0fQIAhtMmzG72vZiclD6WpKv6St8nACAf3pmdUfpYkq7qK32fAIB8CLMzSh9L0lV9pe8TAJAPYXZG6WNJuqqv9H0CAPIhzM4ofSxJV/WVvk8AQD5MM5hT+liSruorfZ8AgOEYzQUAQLbahFmvGQAAkC1hFgCAbAmzAABkS5gFACBbfs6WlRxNM3j6ej9uXDbNYN3sPzDPuUCthFlamx428dPPv8TOq714fzCN7Y9zZh/evengXAP7D8xzLlAzrxnQ2uPnb2Pn1V68O5hGExHvDqax82ovHj9/O/TSqmD/gXnOBWomzNLa09f78f5geuza+4NpPHuzP9CK6mL/gXnOBWomzNLajcvnYntr49i17a2NuH7p3EArqov9B+Y5F6iZMEtrt65djO++Oh9ntzZiFBFnP76bdevaxaGXVgX7D8xzLlAzP2fLSo66Zp+92Y/rl3TNrpv9B+Y5FyhJm5+zFWbhE2oYcVNDjXCki/vdMwPr0ybMGs0Fc2oYcVNDjXCki/vdMwPp8s4szKlhxE0NNcKRLu53zwykS5iFOTWMuKmhRjjSxf3umYF0CbMwp4YRNzXUCEe6uN89M5AuYRbm1DDipoYa4UgX97tnBtJlmgErSbmrt8uu5XWOuFm07r722hgfatLF/e6ZgfUxmotepdzVm/LaPmfRuh/c+SHuPPg1u3oA4DTahFmvGdBayl29Ka/tcxat+/6jF1nWAwDrIszSWspdvSmv7XMWrXvycjfLegBgXYRZWku5qzfltX3OonWPv7mQZT0AsC7CLK2l3NWb8to+Z9G6792+mmU9ALAuGsBYScpdvSmv7XMWrTvXegBgVaYZAACQLdMMAACogjALAEC2hFkAALIlzAIAkK3NoRfwOX39Jn1q/+Y6dVVf6fsElMWZBeVKNswu+q36Pn+Tfoh/c526qq/0fQLK4syCsiX7msGi36rv8zfph/g316mr+krfJ6AsziwoW7JhdtFv1ff5m/RD/Jvr1FV9pe8TUBZnFpQt2TC76Lfq+/xN+iH+zXXqqr7S9wkoizMLypZsmF30W/V9/ib9EP/mOnVVX+n7BJTFmQVlS/rnbIf4Tfoh/s116qq+0vcJKIszC/LS5udskw6zAPzFaKnh+Q5gfdqE2WRHcwHwF6Olhuc7gHQl+84sAH8xWmp4vgNIlzALkDijpYbnO4B0CbMAiTNaani+A0iXMAuQOKOlhuc7gHSZZsBKUu7qTXltsCqjpU6ni3PBdwDrYzQXvUq5qzfltQHDcC5AftqEWa8Z0FrKXb0prw0YhnMByibM0lrKXb0prw0YhnMByibM0lrKXb0prw0YhnMByibM0lrKXb0prw0YhnMByqYBbE0WddK2uR4RyXTpp9zVm/LagGGkfi7k+rcA+mKaQWIWddI+uPND3Hnw61LX//XPv8UoRrHzh25cgJK0+RvhbwG1MM0gMYs6ae8/erH09f/8vhdPft/VjQtQmDZ/I/wtgJOE2TVY1Ek7ebm79PU/PxzGnx8OT3xWNy5A3tr8jfC3AE4SZtdgUSft+JsLS1//YvNMfLF55sRndeMC5K3N3wh/C+AkYXYNFnXS3rt9denr3399Pv799QXduACFafM3wt8COEkD2Jos6qRtcz0iku7GBWA1/hbAcaYZULVFI24AgDy0CbObfS8G1mnRiBtjawCgTN6ZpSiLRtwYWwMAZRJmKcqiETfG1gBAmYRZirJoxI2xNQBQJmGWoiwacWNsDQCUSQPYnNI74Uuvb+PMKB7evWlsDQBUQpidUXonfOn1Hdk4M4ofv/0yfvz2y6GXAgD0zGsGM0rvhC+9PgCgPsLsjNI74UuvDwCojzA7o/RO+NLrAwDqI8zOKL0TvvT6AID6jJqmWfrD4/G4mUwmPS5neEfd/qV2wpdeHwCQv9Fo9KRpmvFSnxVmAQBISZsw6zUDAACyJcwCAJAtYRYAgGwJswAAZEuYBQAgW5tDLwCgL0ej6J6+3o8bl42i60qt+1pD3TXUSHmEWaBI08Mmfvr5l9h5tRfvD6ax/fFHQh7evemP8ynUuq811F1DjZTJawZAkR4/fxs7r/bi3cE0moh4dzCNnVd78fj526GXlrVa97WGumuokTIJs0CRnr7ej/cH02PX3h9M49mb/YFWVIZa97WGumuokTIJs0CRblw+F9tbG8eubW9txPVL5wZaURlq3dca6q6hRsokzAJFunXtYnz31fk4u7URo4g4+/H9v1vXLg69tKzVuq811F1DjZRp1DTN0h8ej8fNZDLpcTl8ji7TOvneV3e0d8/e7Mf1S/auK7Xuayp193kmpFIjjEajJ03TjJf6rDCbB12mdfK9A7OcCdSiTZj1mkEmdJnWyfcOzHImwEnCbCZ0mdbJ9w7McibAScJsJnSZ1sn3DsxyJsBJwmwmdJnWyfcOzHImwEkawDKiy7ROvndgljOBGphmAABAtkwzAACgCsIsAADZEmYBAMiWMAsAQLaEWQAAsiXMAgCQLWEWAIBsCbMAAGRLmAUAIFvCLAAA2RJmAQDIljALAEC2hFkAALIlzAIAkC1hFgCAbAmzAABkS5gFACBbwiwAANkSZgEAyJYwCwBAtoRZAACyJcwCAJAtYRYAgGxtDr2ALk0Pm3j8/G08fb0fNy6fi1vXLsbGmVG16wAAKF0xYXZ62MRPP/8SO6/24v3BNLa3NuK7r87Hw7s31xokU1kHAEANinnN4PHzt7Hzai/eHUyjiYh3B9PYebUXj5+/rXIdAAA1KCbMPn29H+8PpseuvT+YxrM3+1WuAwCgBsWE2RuXz8X21saxa9tbG3H90rkq1wEAUINiwuytaxfju6/Ox9mtjRhFxNmP76reunaxynUAANRg1DTN0h8ej8fNZDLpcTmnczRF4Nmb/bh+afhpBkOvAwAgR6PR6EnTNOOlPltSmAUAIH9twmwxrxkAAFAfYRYAgGwJswAAZEuYBQAgW8IsAADZEmYBAMiWMAsAQLaEWQAAsiXMAgCQLWEWAIBstfo529Fo9D8R8bK/5QAAQHzTNM0/lvlgqzALAAAp8ZoBAADZEmYBAMiWMAsAQLaEWQAAsiXMAgCQLWEWAIBsCbMAAGRLmAUAIFvCLAAA2fo/UMdugfngTrQAAAAASUVORK5CYII=\n",
-      "text/plain": [
-       "<Figure size 864x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "draw_graph(data.get_graph(), True)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Operators and solution state\n",
-    "\n",
-    "To use the ALNS meta-heuristic, we need to have destroy and repair operators that work on a proposed solution, and a way to describe such a solution in the first place. The ALNS package exposes the class ``State`` to describe a solution, with an ``objective()`` member that computes this solution's objective value. Using it, we may compute a simple initial solution, and then apply the ALNS algorithm."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Solution state"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class TspState(State):\n",
-    "    \"\"\"\n",
-    "    Solution class for the TSP problem. It has two data members, nodes, and edges.\n",
-    "    nodes is a list of node tuples: (id, coords). The edges data member, then, is\n",
-    "    a mapping from each node to their only outgoing node.\n",
-    "    \"\"\"\n",
-    "\n",
-    "    def __init__(self, nodes, edges):\n",
-    "        self.nodes = nodes\n",
-    "        self.edges = edges\n",
-    "\n",
-    "    def copy(self):\n",
-    "        return copy.deepcopy(self)\n",
-    "\n",
-    "    def objective(self):\n",
-    "        \"\"\"\n",
-    "        The objective function is simply the sum of all individual edge lengths,\n",
-    "        using the rounded Euclidean norm.\n",
-    "        \"\"\"\n",
-    "        return sum(distances.euclidean(node[1], self.edges[node][1])\n",
-    "                   for node in self.nodes)\n",
-    "    \n",
-    "    def to_graph(self):\n",
-    "        \"\"\"\n",
-    "        NetworkX helper method.\n",
-    "        \"\"\"\n",
-    "        graph = nx.Graph()\n",
-    "\n",
-    "        for node, coord in self.nodes:\n",
-    "            graph.add_node(node, pos=coord)\n",
-    "\n",
-    "        for node_from, node_to in self.edges.items():\n",
-    "            graph.add_edge(node_from[0], node_to[0])\n",
-    "\n",
-    "        return graph"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Destroy operators\n",
-    "\n",
-    "Destroy operators break parts of a solution down, leaving an incomplete state. This is the first part of each iteration of the ALNS meta-heuristic; the incomplete solution is subsequently repaired by any one repair operator. We will consider three destroy operators: **worst removal**, **path removal** and **random removal**. We will also use a separate parameter, the degree of destruction, to control the extent of the damage done to a solution in each step."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "degree_of_destruction = 0.25\n",
-    "\n",
-    "def edges_to_remove(state):\n",
-    "    return int(len(state.edges) * degree_of_destruction)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def worst_removal(current, random_state):\n",
-    "    \"\"\"\n",
-    "    Worst removal iteratively removes the 'worst' edges, that is,\n",
-    "    those edges that have the largest distance.\n",
-    "    \"\"\"\n",
-    "    destroyed = current.copy()\n",
-    "\n",
-    "    worst_edges = sorted(destroyed.nodes,\n",
-    "                         key=lambda node: distances.euclidean(node[1],\n",
-    "                                                              destroyed.edges[node][1]))\n",
-    "\n",
-    "    for idx in range(edges_to_remove(current)):\n",
-    "        del destroyed.edges[worst_edges[-idx -1]]\n",
-    "\n",
-    "    return destroyed"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def path_removal(current, random_state):\n",
-    "    \"\"\"\n",
-    "    Removes an entire consecutive subpath, that is, a series of\n",
-    "    contiguous edges.\n",
-    "    \"\"\"\n",
-    "    destroyed = current.copy()\n",
-    "    \n",
-    "    node_idx = random_state.choice(len(destroyed.nodes))\n",
-    "    node = destroyed.nodes[node_idx]\n",
-    "    \n",
-    "    for _ in range(edges_to_remove(current)):\n",
-    "        node = destroyed.edges.pop(node)\n",
-    "\n",
-    "    return destroyed"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def random_removal(current, random_state):\n",
-    "    \"\"\"\n",
-    "    Random removal iteratively removes random edges.\n",
-    "    \"\"\"\n",
-    "    destroyed = current.copy()\n",
-    "    \n",
-    "    for idx in random_state.choice(len(destroyed.nodes),\n",
-    "                                   edges_to_remove(current),\n",
-    "                                   replace=False):\n",
-    "        del destroyed.edges[destroyed.nodes[idx]]\n",
-    "\n",
-    "    return destroyed"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Repair operators\n",
-    "\n",
-    "We implement a simple, **greedy repair** strategy. It determines a set of nodes that are currently not visited, and then links these up to the tour such that it forms one cycle."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def would_form_subcycle(from_node, to_node, state):\n",
-    "    \"\"\"\n",
-    "    Ensures the proposed solution would not result in a cycle smaller\n",
-    "    than the entire set of nodes. Notice the offsets: we do not count\n",
-    "    the current node under consideration, as it cannot yet be part of\n",
-    "    a cycle.\n",
-    "    \"\"\"\n",
-    "    for step in range(1, len(state.nodes)):\n",
-    "        if to_node not in state.edges:\n",
-    "            return False\n",
-    "\n",
-    "        to_node = state.edges[to_node]\n",
-    "        \n",
-    "        if from_node == to_node and step != len(state.nodes) - 1:\n",
-    "            return True\n",
-    "\n",
-    "    return False"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def greedy_repair(current, random_state):\n",
-    "    \"\"\"\n",
-    "    Greedily repairs a tour, stitching up nodes that are not departed\n",
-    "    with those not visited.\n",
-    "    \"\"\"\n",
-    "    visited = set(current.edges.values())\n",
-    "  \n",
-    "    # This kind of randomness ensures we do not cycle between the same\n",
-    "    # destroy and repair steps every time.\n",
-    "    shuffled_idcs = random_state.permutation(len(current.nodes))\n",
-    "    nodes = [current.nodes[idx] for idx in shuffled_idcs]\n",
-    "\n",
-    "    while len(current.edges) != len(current.nodes):\n",
-    "        node = next(node for node in nodes \n",
-    "                    if node not in current.edges)\n",
-    "\n",
-    "        # Computes all nodes that have not currently been visited,\n",
-    "        # that is, those that this node might visit. This should\n",
-    "        # not result in a subcycle, as that would violate the TSP\n",
-    "        # constraints.\n",
-    "        unvisited = {other for other in current.nodes\n",
-    "                     if other != node\n",
-    "                     if other not in visited\n",
-    "                     if not would_form_subcycle(node, other, current)}\n",
-    "\n",
-    "        # Closest visitable node.\n",
-    "        nearest = min(unvisited,\n",
-    "                      key=lambda other: distances.euclidean(node[1], other[1]))\n",
-    "\n",
-    "        current.edges[node] = nearest\n",
-    "        visited.add(nearest)\n",
-    "\n",
-    "    return current"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Initial solution"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Initial solution objective is 851.\n"
-     ]
-    }
-   ],
-   "source": [
-    "random_state = rnd.RandomState(SEED)\n",
-    "state = TspState(cities, {})\n",
-    "\n",
-    "initial_solution = greedy_repair(state, random_state)\n",
-    "\n",
-    "print(\"Initial solution objective is {0}.\".format(initial_solution.objective()))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 864x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "draw_graph(initial_solution.to_graph())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Heuristic solution"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "alns = ALNS(random_state)\n",
-    "\n",
-    "alns.add_destroy_operator(random_removal)\n",
-    "alns.add_destroy_operator(path_removal)\n",
-    "alns.add_destroy_operator(worst_removal)\n",
-    "\n",
-    "alns.add_repair_operator(greedy_repair)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# This is perhaps the simplest selection criterion, where we only accept\n",
-    "# progressively better solutions.\n",
-    "criterion = HillClimbing()\n",
-    "\n",
-    "result = alns.iterate(initial_solution, [3, 2, 1, 0.5], 0.8, criterion,\n",
-    "                      iterations=5000, collect_stats=True)\n",
-    "\n",
-    "solution = result.best_state\n",
-    "\n",
-    "objective = solution.objective()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Best heuristic objective is 606.\n",
-      "This is 7.4% worse than the optimal solution, which is 564.\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 864x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "print('Best heuristic objective is {0}.'.format(objective))\n",
-    "print('This is {0:.1f}% worse than the optimal solution, which is {1}.'\n",
-    "      .format(100 * (objective - optimal) / optimal, optimal))\n",
-    "\n",
-    "_, ax = plt.subplots(figsize=(12, 6))\n",
-    "result.plot_objectives(ax=ax, lw=2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Having obtained a reasonable solution, we now want to investigate each operator's performance. This may be done via the `plot_operator_counts()` method on the `result` object, like below. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4gAAAGwCAYAAADrBksnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xe4XVWd//H3JwUIJiRAUDqhyAAWUEFFEUEcy4jKOFhRQR0dUbGMZeyCjopl1FEU2yCoqKg4iugo/EBAEOklKFako/QUCJDy/f2x18WTy829N5Cbk+S+X89znrPLWnt9994nN/d719rrpKqQJEmSJGlCvwOQJEmSJK0aTBAlSZIkSYAJoiRJkiSpMUGUJEmSJAEmiJIkSZKkxgRRkiRJkgSYIEqStMpLcmWSp7bldyf5ar9jWh5J5ifZpt9xSJJGZoIoSVqtJDkoyewkdyb5a5Ijk8zoYzyVZLuV1V5VfaSq/nVltbe8kpyWZKn4qmpqVV3Rr5gkSaNngihJWm0keSvwMeDtwHTg8cBWwMlJ1hqD9iat6GOuzONLkrS8TBAlSauFJOsBhwGHVNXPqmphVV0JvIAuSXxpK3doku8nOS7JvCQXJtm55zibJjk+yU1J/pLkjT37Bup+M8lc4KAkj01ydpLbk9yQ5IiBZDTJGa3qJW0Y5Qvb9lcn+VOSW5OckGTTnjYqyeuT/BH44zLO9WVJrkpyS5L3DNp3aJJv9qx/r/WkzklyRpKH9ezbMMmPk8xNcl6S/0xy5qBYXpvkj0luS/L5JGn7JiR5b4vjxiRfTzK97VunXaNb2nU5L8lDknwYeBJwRLseR/S0s11bnpLkv9px5yQ5s20b8pij+nBIklYYE0RJ0uriCcA6wA96N1bVfOD/gH/s2fxc4HvABsC3gB8mmZxkAvBj4BJgM2Af4M1Jnj6o7veBGcCxwGLgLcBMYPdW53Wt7T1bnZ3bMMrjkjwF+Chd4roJcBXwnUHnsh/wOGCnwSeZZCfgSOBlwKbAhsDmw1yX/wMeCjwYuLDFPODzwB3AxsCB7TXYvsBuwM4t5oFrcVB77Q1sA0wFjmj7DqTrwd2ixfdaYEFVvQf4JfCGdj3eMER7nwQeQ3c/NwDeASxZ1jGHOW9J0hgwQZQkrS5mAjdX1aIh9t3Q9g+4oKq+X1ULgU/RJZaPp0uENqqqD1bVPe25uK8AL+qpe3ZV/bCqllTVgqq6oKp+XVWLWo/ll4AnDxPnAcBRVXVhVd0NvAvYPcmsnjIfrapbq2qoBGh/4MSqOqPVfx9dAjWkqjqqqua1socCOyeZnmQi8C/AB6rqzqr6LXDMEIc4vKpur6qrgV8Au/Scx6eq6oqWhL8LeFEbFruQLonbrqoWt2s0d5hrAnS9ksArgTdV1XWt7q9a7PfrmJKkFctnHyRJq4ubgZlJJg2RJG7S9g+4ZmChqpYkuZauN66ATZPc3lN2Il2v133qAiTZni7J3BVYl+7/zguGiXNTup68gfbnJ7mFrsfyyqHaGKJ+b/x3tPr30ZLADwPPBzbi74nkTGBKi7W3raHa/WvP8p10PYUDcVzVs++qdryHAN+g6+n7Tpsg6JvAe1pCPpyZdMn6n4fYd3+PKUlagexBlCStLs4G7gae17sxyYOAZwKn9Gzeomf/BLohmtfTJUh/qaoZPa9pVfVPPXVrULtHAr8DHlpV6wHvBjJMnNfTPRPZG9+GwHXDtNHrhkHxr9vqD+UldENin0o3PHPWQDXgJmARSw9P3YLRW+o8gC3b8f7Wnv88rKp2ohsqui/w8lZuuHO7GbgL2HbwjhGOKUlaSUwQJUmrhaqaQzdJzeeSPKM9UziL7lnDa+l6oAY8Jsnz2nDIN9Mllr8GzgXmJvmPNjHKxCQPT7LbME1PA+YC85PsABw8aP/f6J7RG/At4BVJdkmyNvAR4Jw2PHU0vg/sm2SPNhnOB1n2/9fT2rndQte7+ZGBHVW1mO55zUOTrNtiX56E69vAW5JsnWRqO/ZxVbUoyd5JHtF6MOfSDQ9d3OoNvh73qqolwFHAp9JNFjQxye5J1h7hmJKklcQEUZK02qiqj9P14H2SLok4h65XcJ/2HNuAHwEvBG6jm+zlea2HajHwbLrn7P5C16P1Vbret2V5G11P3Ty65xWPG7T/UOCYNvPmC6rqFLrnBo+n6w3clqWfcRzpHH8DvJ4u0byhncO1yyj+dbqhn9cBv6VLgnu9ge7c/kqXQH+bLqEcjaNanTPortVdwCFt38Z0iexc4HLgdLohoQD/DezfZkX97BDHfRswGzgPuJXua0smjHBMSdJKkqrhRoJIkrR6SXIo3UQnL+13LKuaJB8DNq6qoWYzlSTJHkRJktZUSXZI8sh0Hgu8CvjffsclSVp1OYupJElrrml0w0o3BW4E/otu+K0kSUNyiKkkSZIkCXCIqSRJkiSpMUGUJEmSJAEmiJIkSZKkxgRRkiRJkgSYIEqSJEmSGhNESZIkSRJggihJkiRJakwQJUmSJEmACaIkSZIkqTFBlCRJkiQBJoiSJEmSpMYEUZIkSZIEmCBKkiRJkhoTREmSJEkSYIIoSRrnklyZZEGSeUluT/KrJK9N8oD/j2zHfuqKiHN1kmRWkkoyqd+xSJKWjwmiJEnw7KqaBmwFHA78B/A/Y93o6ppAJZk4xsdfLa+LJK0JTBAlSWqqak5VnQC8EDgwycMBkqyd5JNJrk7ytyRfTDKl7ZuZ5MTW+3hrkl8mmZDkG8CWwI+TzE/yjp6etVcluRo4tR3jOUl+045xWpId2/a3Jzm+N8Ykn0vymaHiT7Jjq397O95zevYd3eI+ufWWnp5kq579O7R9tyb5fZIXDKp7ZJKfJrkD2DvJs5JclGRukmuSHNoTyhnt/fZ27ru3a/LeJFcluTHJ15NMb8e/z3VJsk6Sbya5pZ3PeUkecn/uqyRp9EwQJUkapKrOBa4FntQ2fQzYHtgF2A7YDHh/2/fWVnYj4CHAu7tD1MuAq+l6J6dW1cd7mngysCPw9CTbA98G3tyO8VO6pHIt4JvAM5LMgHt71l4IfGNwzEkmAz8GTgIeDBwCHJvkH3qKHQB8CJgJXAwc2+o+CDgZ+Far+2LgC0ke1lP3JcCHgWnAmcAdwMuBGcCzgIOT7NfK7tneZ7RzPxs4qL32BrYBpgJHDDqNe68LcCAwHdgC2BB4LbBg8HlLklYsE0RJkoZ2PbBBkgCvBt5SVbdW1TzgI8CLWrmFwCbAVlW1sKp+WVU1wrEPrao7qmoBXcL3k6o6uaoWAp8EpgBPqKob6Hrjnt/qPQO4uaouGOKYj6dLug6vqnuq6lTgRLpkb8BPquqMqrobeA+we5ItgH2BK6vqa1W1qKouBI4H9u+p+6OqOquqllTVXVV1WlXNbuuX0iW5Tx7mnA8APlVVV1TVfOBdwIsGDSftvS4L6RLD7apqcVVdUFVzh7+skqQHygRRkqShbQbcSterty5wQRvqeDvws7Yd4BPAn4CTklyR5J2jOPY1PcubAlcNrFTVkrZ/s7bpGOClbfmlDNF72HOca1r9AVf1HGepdluSdmurtxXwuIHza+d4ALDxMmImyeOS/CLJTUnm0PXwzVz2KS99nm15El2v61BtfAP4OfCdJNcn+XjrJZUkjSETREmSBkmyG11idSZwM93QxodV1Yz2ml5VUwGqal5VvbWqtgGeDfx7kn3aoZbVk9i7/Xq6BG2g7dANq7yubfoh8Mj2POS+tGGhQ7ge2GLQ7Ktb9hyHdtyBdqYCG7R61wCn95zfwNDQg5cRM3TDUU8Atqiq6cAXgSyj7H3Os8W2CPjbUG203tjDqmon4Al05/7yoU9dkrSimCBKktQkWS/JvsB3gG8ODKEEvgJ8OsmDW7nNkjy9Le+bZLuW2M0FFrcXdMnPNiM0+13gWUn2aT1kbwXuBn4FUFV3Ad+nS8jOraqrl3Gcc+ieC3xHkslJ9qJLWL/TU+afkuzRnm/8EHBOVV1DNxR1+yQva3UnJ9ltYLKcZZgG3FpVdyV5LN0zigNuApYMOvdvA29JsnVLTj8CHFdVi4Y6eJK9kzwi3Yypc+mGnC4eqqwkacUxQZQkqZsUZh5dT9p7gE8Br+jZ/x90w0h/nWQu8P+AgclfHtrW5wNnA1+oqtPavo8C723DNt82VMNV9Xu6oaOfo+utfDbdxDb39BQ7BngEyx5eSiv/HOCZ7ThfAF5eVb/rKfYt4AN0Q0sfQzeMlPZc5dPonqu8Hvgr3cQ8ay+rPeB1wAfbdXs/XaI7EMuddBPanNXO/fHAUS3+M4C/AHfRTaSzLBvTJcZzgcuB0+km7ZEkjaGM/By9JEnqpyRbAr8DNr6/E7UkORq4tqreuyJjkyStWexBlCRpFdaeKfx34DvO4ilJGmuTRi4iSZL6oX0/4d/oZvx8Rp/DkSSNAw4xlSRJkiQBDjGVJEmSJDUmiJIkSZIkwGcQ1wgzZ86sWbNm9TsMSZIkSauoCy644Oaq2mikciaIa4BZs2Zx/vnn9zsMSZIkSauoJFeNppxDTCVJkiRJgAmiJEmSJKkxQZQkSZIkAT6DuEaYfd0cZr3zJ/0OQ3rApu34zn6HIEmSNK7ZgyhJkiRJAkwQJUmSJEmNCaIkSZIkCTBBlCRJkiQ1JoiSJEmSJMAEUZIkSZLUmCBKkiRJkgC/B1G6j5t/+hkW/Pk8Jq47nU1f9YWl9s055wfcftpRbH7IsUxcd3qfIlzzLLjiAm495ctMmHQT6++5Phvtu1G/Q5Kk+6glxZ8P/TOT15/MVm/Ziis+cgVLFiwBYNG8RUzZegpbvWmrPkcpSQ+MPYjSIFMf8VQe/PzD7rN90dybuOvKi5i4nsnLilRLFnPryUfy4OcfxnYf2Y4558zhruvu6ndYknQft5x0C2tvuva969u8exu2+9B2bPeh7Vh323VZb9f1+hidJK0Yq02CmOTKJDP7HcfKlOTQJG/rdxzjzTpbPJyJU6bdZ/ttp3yF9fd+BZCVH9Qa7J4b/sCkGZswecbGTJg0gemPm868i+b1OyxJWsrCWxcy75J5rL/n+vfZt3jBYuZfPp/1Hm2CKGn1t1ISxHRWi2Q0icNudR93/vEcJk7bkLUevE2/Q1njLJp3C5N6emUnrT+Jhbct7GNEknRfN3zrBjZ+4cZD/o1w7oVzmbrTVCZOmbjyA5OkFWzMkrYks5JcnuQLwIXA/yQ5P8lvkhzWU+7KJIcluTDJ7CQ7tO0bJjkpyUVJvkTPj+Qk/57ksvZ6c097v0vy1bb92CRPTXJWkj8meewwsR6a5MtJTgK+nmRikk8kOS/JpUn+rZXbK8npSb6b5A9JDk9yQJJzW+zbtnJbJTml1T0lyZZJprdzndDKrJvkmiSTk7y6tXVJkuOTrDuK6/uadj3PX3znnPtzizRKSxbexZyzj2PGk17a71AkSX0w9+K5TFpvElNmTRly/5xfz2H643wuXdKaYax79f4B+HpVPQp4a1XtCjwSeHKSR/aUu7mqHg0cCQwMqfwAcGarewKwJUCSxwCvAB4HPB54dZJHtTrbAf/d2tgBeAmwRzvmu0eI9THAc6vqJcCrgDlVtRuwW2tj61ZuZ+BNwCOAlwHbV9Vjga8Ch7QyR7TzfiRwLPDZqpoDXAI8uZV5NvDzqloI/KCqdquqnYHLW/vDqqovV9WuVbWrk6WMrUW3/5VFc/7G9UcdwrVHvpLF827mhqPfzOL5t/U7tDXCpGkbsmjuTfeuL7ptEZPXn9zHiCRpaXf+8U7mXjSX37/191x75LXMv3w+13zpGgAWzV/EgisWMG3n+z6aIEmro7EeTnlVVf26Lb8gyWtam5sAOwGXtn0/aO8XAM9ry3sOLFfVT5IM/Da+B/C/VXUHQJIfAE+iSyL/UlWz2/bfAKdUVSWZDcwaIdYTqmpBW34a8Mgk+7f16cBDgXuA86rqhtbGn4GTWpnZwN5tefee8/gG8PG2fBzwQuAXwIuAgSkyH57kP4EZwFTg5yPEqpVorY1mscUhx967fu2Rr2STAz/tLKYryFqbbM+i265n4e1/ZcmiJcw5Zw6bv3bzfoclSffa+Pkbs/HzNwZg/uXzueVnt7DFv20BwNxz5zJtl2lMWGu1eJJGkkY01gniQBK3NV0v3m5VdVuSo4F1esrd3d4XD4qphjjmcDOE3N2zvKRnfQkjn+sdg9o4pKqWStSS7HU/2xg4jxOAjybZgK7H8tS2/Whgv6q6JMlBwF4jxKoxdNMJH+fuq2ezeMFcrv38gUzf4wCm7fy0foe1xsqEiWzwj6/lxu++n5t+cBPrP2l91tlsnZErStIq4PZzbmejZzm7taQ1x8qakGU9ugRsTpKHAM8EThuhzhnAAcB/JnkmsH7P9qOTHE6XyP0z3VDPFennwMFJTq2qhUm2B65bjvq/oush/AbdOZwJUFXzk5xLNwz2xKpa3MpPA25IMrmVX562tIJt9Jx3DLt/84OPWkmRjB9Ttt2NzbbdjWk7vrPfoUjSsKbuOJWpO069d32bdzl5maQ1y0pJEFvP2EXAb4ArgLNGUe0w4NtJLgROB65ux7qw9UCe28p9taouSjJrBYb8VbohqRcmCXATsN9y1H8jcFSSt7e6r+jZdxzwPZbuJXwfcA5wFd1QVR9kkCRJkrTSpWqoUZxanay9yUNrkwM/0+8wpAfMHkRJkqSxcdlBl13QJg0dlk9US5IkSZKAlfcM4iohySvovqKi11lV9fp+xCNJkiRJq5JxlSBW1deAr/U7DkmSJElaFTnEVJIkSZIEOEnNGmHXXXet888/v99hSJIkSVpFJXGSGkmSJEnS6JkgSpIkSZIAE0RJkiRJUmOCKEmSJEkCTBAlSZIkSY0JoiRJkiQJMEGUJEmSJDUmiJIkSZIkwARRkiRJktSYIEqSJEmSABNESZIkSVJjgihJkiRJAkwQJUmSJEmNCaIkSZIkCRhFgphkQpIXrIxgJEmSJEn9M2KCWFVLgDeshFgkSZIkSX002iGmJyd5W5Itkmww8BrTyCRJkiRJK9WkUZZ7ZXt/fc+2ArZZseFIkiRJkvplVAliVW091oFIkiRJkvprVAliksnAwcCebdNpwJeqauEYxSVJkiRJWslGO8T0SGAy8IW2/rK27V/HIihJkiRJ0so32gRxt6rauWf91CSXjEVAkiRJkqT+GG2CuDjJtlX1Z4Ak2wCLxy4sLY/Z181h1jt/0u8wVogrD39Wv0OQJEmSxq3RJohvB36R5AogwFb8fWZTSZIkSdIaYLQJ4pnAQ4F/oEsQfzdmEUmSJEmS+mLCKMudXVV3V9WlVXVJVd0NnD2WgUmSJEmSVq5hexCTbAxsBkxJ8ii63kOA9YB1xzg2SZIkSdJKNNIQ06cDBwGbA5/q2T4PePcYxSRJkiRJ6oNhE8SqOgY4Jsm/VNXxKykmSZIkSVIfjGqSmqo6PsmzgIcB6/Rs/+BYBaZVSy1ZzA3HvIVJ0zbkwft/YIUf//ZffYc5Z32Hyf8F++yzDz/72c9WeBuSJEmShjeqSWqSfBF4IXAI3XOIz6f7qguNE/POP4HJG24xJsdesuge5pz1bR78wg9x2223cfrpp3PCCSeMSVuSJEmSlm20s5g+oapeDtxWVYcBuwNjky2sYEn2S7JTv+O4P5KclmTXfsexaO7NLLjiPKbu/LQxOf4dl53ChLXWZcqWj2Dq1KnsueeefP7znx+TtiRJkiQt22gTxLva+51JNgUWAluPTUj3T5KJy9i1HzDqBDHJaL8bcty47ZQvM2OvV5Jk5ML3w8Jbr2PClPXuXd9666254YYbxqQtSZIkScs22gTxx0lmAJ8ALgSuBL69ooJI8o4kb2zLn05yalveJ8k3k7w4yewklyX5WE+9+Uk+mOQcYPckhyf5bZJLk3wyyROA5wCfSHJxkm2X0f5pST6S5HTgTUk2SnJ8kvPa64mt3KFJjklyUpIrkzwvycdbbD9LMrkn7ova9qOSrJ3kmUm+29PmXkl+3JaPTHJ+kt8kOWxFXdcV4c4/ncuEB81g7Y23G7tGauwOLUmSJGn0RuwtSzIBOKWqbgeOT3IisE5VzVmBcZwBvBX4LLArsHZLtvYA/gh8DHgMcBtwUpL9quqHwIOAy6rq/Uk2AP4H2KGqKsmMqro9yQnAiVX1/RFimFFVT27n/C3g01V1ZpItgZ8DO7Zy2wJ70/VKng38S1W9I8n/As9K8jPgaGCfqvpDkq8DBwNHAF9K8qCquoPumc7j2jHfU1W3tl7QU5I8sqouHS7YJK8BXgMwcb2NRji1++/u637Lgj+ew7V/Pp9afA919wJu/vEnmfnst62wNiZvuBl3XHbKvet/+ctf2GSTTVbY8SVJkiSNzog9iFW1BPivnvW7V3ByCHAB8Jgk04C76RKvXYEnAbcDp1XVTVW1CDgW2LPVWwwMfP3GXLqhsF9N8jzgzuWM4bie5acCRyS5GDgBWK/FBvB/VbUQmA1MBAam25wNzAL+AfhLVf2hbT8G2LPF/jPg2W0Y67OAH7UyL0hyIXAR3UyxIw6JraovV9WuVbXrxHWnL+epjt76Tz6IzV9/DJsffBQbPecdrLPVI1docgjwoIfvw5K772TB1bOZP38+Z5xxBq973etWaBuSJEmSRjbaIaYnJfmXjNFDaC3huhJ4BfAr4Jd0vXTbAlcPU/WuqlrcjrEIeCxdwrgff0/cRuuOnuUJwO5VtUt7bVZV89q+u1t7S4CFVTUwQHIJXY/scNfoOOAFwFOA86pqXpKtgbfR9Tg+EvgJPV8lMh5MmLQW05/wQm487r2sv/767LHHHjz3uc/td1iSJEnSuDPaBPHfge8B9ySZm2RekrkrOJYz6BKlM+gSxNcCFwO/Bp6cZGYbgvli4PTBlZNMBaZX1U+BNwO7tF3zgGmDy4/gJOANPcfeZZiyg/0OmJVk4KG9l/XEexrwaODV/L3Hcj265HROkocAz1zOWFeadbZ85Jh8ByLAjD1ewlZv/xELFy7k5JNPHpM2JEmSJA1vVAliVU2rqglVNbmq1mvr641cc7n8EtgEOLuq/kY3XPSXVXUD8C7gF8AlwIVV9aMh6k8DTkxyKV1C9pa2/TvA29ukMUNOUjOENwK7tslufkuXrI5KVd1F1xP6vSSz6XoWv9j2LQZOpEsCT2zbLqEbWvob4CjgrNG2JUmSJEkrUv4+QnKYQt3Q0gOAravqQ0m2ADapqnPHOkCNbO1NHlqbHPiZfoexQlx5+LP6HYIkSZK0xklyQVWN+B3rox1i+gVgd+AlbX0+4DeZS5IkSdIaZLRfCv+4qnp0kosAquq2JGuNYVxjIsnngScO2vzfVfW1fsQjSZIkSauS0SaIC9sEMQWQZCO6Z+tWK1X1+n7HIEmSJEmrqtEOMf0s8L/AQ5J8GDgT+MiYRSVJkiRJWulG1YNYVccmuQDYp23ar6ouH7uwJEmSJEkr22iHmAKsCwwMM50yNuHo/njEZtM539k/JUmSJD1AoxpimuT9wDHABsBM4GtJ3juWgUmSJEmSVq7R9iC+GHhU+xJ4khwOXAj851gFJkmSJElauUY7Sc2VwDo962sDf17h0UiSJEmS+ma0PYh3A79JcnJbfypwZpLPAlTVG8ciOEmSJEnSyjPaBPHnwCl03324GPjFmEUkSZIkSeqLYRPEJJPovu/wlcBVdENStwC+Bry7qhaOeYSSJEmSpJVipGcQP0E3c+nWVfWYqnoUsA0wve2TJEmSJK0hRkoQ9wVeXVXzBjZU1VzgYMAv3pMkSZKkNchICWJVVQ2xcTFwn+2SJEmSpNXXSAnib5O8fPDGJC8Ffjc2IUmSJEmS+mGkWUxfD/wgySuBC+h6DXcDpgD/PMaxSZIkSZJWomETxKq6DnhckqcADwMC/F9VnbIygpMkSZIkrTyj+h7EqjoVOHWMY5EkSZIk9dFIzyBKkiRJksYJE0RJkiRJEmCCKEmSJElqTBAlSZIkSYAJoiRJkiSpMUGUJEmSJAEmiJIkSZKkxgRRkiRJkgSYIEqSJEmSmkn9DkAP3Ozr5jDrnT/pdxhSX0zb8Z1j3sbsA2ePeRuSJEmrAnsQJUmSJEmACaIkSZIkqTFBlCRJkiQBJoiSJEmSpMYEUZIkSZIEmCBKkiRJkhq/5kIapZt/+hkW/Pk8Jq47nU1f9QUAbj/zWOZf8nMmrDsdgPX3fDlTtt2tn2GOGwuuuIBbT/kyEybdxPp7rs9G+240bPl7brmH675yHYvmLILA+nutz8ynzVxJ0UqSJK0eTBClUZr6iKcy7dH7cstPPrXU9mm77sf0xz2vT1GNT7VkMbeefCQPfuF/MmO3T3HFYVcw7VHTWGezdZZZJxPDxi/amCmzprB4wWL+fOifmfqwqcPWkSRJGm/WmCGmSQ5KsmnP+pVJVuvugSSHJnlbv+NQZ50tHs7EKdP6HYaAe274A5NmbMLkGRszYdIEpj9uOvMumjdsnckzJjNl1hQAJk6ZyNqbrs2i2xatjHAlSZJWG2tMgggcBGw6UqGRJLFXVctl3oUncv1Rb+Dmn36GxXfN73c448Kiebcwab2/DymdtP4kFt62cNT177npHu666i6mbDtlLMKTJElaba2yCWKSWUl+l+SYJJcm+X6SdZO8P8l5SS5L8uV09gd2BY5NcnGSgd/6DklyYZLZSXYYpq1D27FOAr6eZGKST7R2Lk3yb63cXklOT/LdJH9IcniSA5Kc29rYtpXbKskpre4pSbZMMr31ak5oZdZNck2SyUle3dq6JMnxSdYd26urFWXao/6Jzf7tK2zyis8yceoG3HbqV/sdkkaw+K7FXH3E1Wz8ko2ZOGViv8ORJElapayyCWLzD8CXq+qRwFzgdcARVbVbVT0cmALsW1XfB84HDqiqXapqQat/c1U9GjgSGGmo5mOA51bVS4BXAXOqajdgN+DVSbZu5XYG3gQ8AngZsH1VPRb4KnBIK3ME8PUW97HAZ6tqDnAJ8ORW5tnAz6tqIfCDdk47A5e39oeV5DVJzk9y/uI754xUXGNk4oPWJxMmkkxg2s5P554b/tDvkMaFSdM2ZNHcm+5dX3TbIiavP3nEerWouOaIa5ix+wym7zp9LEOUJElaLa3qCeI1VXVhvmLZAAAgAElEQVRWW/4msAewd5JzkswGngI8bJj6P2jvFwCzRmjrhJ7E8mnAy5NcDJwDbAg8tO07r6puqKq7gT8DJ7Xts3va2B34Vlv+Rosb4DjghW35RW0d4OFJftnO6YARzgmAqvpyVe1aVbtOXNdfdPtl0fxb712+8w9nM3nmVn2MZvxYa5PtWXTb9Sy8/a8sWbSEOefMYdqjhn8+tKq47qjrWHuTtZn5jNX68WRJkqQxs6o/b1dDrH8B2LWqrklyKDDcFIR3t/fFjHyud/QsBzikqn7eWyDJXj3HBFjSs75kmDYGzuME4KNJNqDrsTy1bT8a2K+qLklyELDXCLGqD2464ePcffVsFi+Yy7WfP5DpexzA3dfM5p6/XQEJk6Y/mA2e/oZ+hzkuZMJENvjH13Ljd9/PTT+4ifWftP6Is5He+cc7uf1Xt7P25mvzp/f9CYCH7P8Qpu3sxEOSJEkDVvUEccsku1fV2cCLgTOBJwA3J5kK7A98v5WdB6yo3/R+Dhyc5NSqWphke+C65aj/K7oewm/Q9QieCVBV85OcC/w3cGJVLW7lpwE3JJncyi9PW1pJNnrOO+6zbdrOT+tDJAKYsu1ubLbtbkzb8Z2jKv+g7R/Ew49++BhHJUmStHpb1RPEy4EDk3wJ+CPds4Tr0w3nvBI4r6fs0cAXkyygG+L5QHyVbrjohUkC3ATstxz13wgcleTtre4revYdB3yPpXsJ30c3lPUqunOzS0OSJEnSSpeqwaM4Vw1JZtH1svkn/xGsvclDa5MDP9PvMKS+GG0P4gMx+8DZY96GJEnSWEpyQVXtOlK5VX2SGkmSJEnSSrLKDjGtqiuBFdp7mOQVdF9R0eusqnr9imxHkiRJklZHq2yCOBaq6mvA1/odhyRJkiStihxiKkmSJEkCTBAlSZIkSc24GmK6pnrEZtM5//Bn9TsMqU/87EuSJK0o9iBKkiRJkgATREmSJElSY4IoSZIkSQJMECVJkiRJjQmiJEmSJAmAVFW/Y9ADlGQe8Pt+x6G+mQnc3O8g1Dfe//HN+z++ef/HN+//+HZ/7v9WVbXRSIX8mos1w++ratd+B6H+SHK+93/88v6Pb97/8c37P755/8e3sbz/DjGVJEmSJAEmiJIkSZKkxgRxzfDlfgegvvL+j2/e//HN+z++ef/HN+//+DZm999JaiRJkiRJgD2IkiRJkqTGBFGSJEmSBJggrtaSPCPJ75P8Kck7+x2PxlaSo5LcmOSynm0bJDk5yR/b+/r9jFFjJ8kWSX6R5PIkv0nyprbdz8A4kGSdJOcmuaTd/8Pa9q2TnNPu/3FJ1up3rBo7SSYmuSjJiW3d+z9OJLkyyewkFyc5v23z5/84kWRGku8n+V37PWD3sbz/JoirqSQTgc8DzwR2Al6cZKf+RqUxdjTwjEHb3gmcUlUPBU5p61ozLQLeWlU7Ao8HXt/+zfsZGB/uBp5SVTsDuwDPSPJ44GPAp9v9vw14VR9j1Nh7E3B5z7r3f3zZu6p26fnuO3/+jx//DfysqnYAdqb7OTBm998EcfX1WOBPVXVFVd0DfAd4bp9j0hiqqjOAWwdtfi5wTFs+BthvpQallaaqbqiqC9vyPLr/HDbDz8C4UJ35bXVyexXwFOD7bbv3fw2WZHPgWcBX23rw/o93/vwfB5KsB+wJ/A9AVd1TVbczhvffBHH1tRlwTc/6tW2bxpeHVNUN0CUQwIP7HI9WgiSzgEcB5+BnYNxowwsvBm4ETgb+DNxeVYtaEf8fWLN9BngHsKStb4j3fzwp4KQkFyR5Tdvmz//xYRvgJuBrbYj5V5M8iDG8/yaIq68Msc3vLJHWcEmmAscDb66quf2ORytPVS2uql2AzelGkew4VLGVG5VWhiT7AjdW1QW9m4co6v1fcz2xqh5N92jR65Ps2e+AtNJMAh4NHFlVjwLuYIyHE5sgrr6uBbboWd8cuL5Psah//pZkE4D2fmOf49EYSjKZLjk8tqp+0Db7GRhn2tCi0+ieRZ2RZFLb5f8Da64nAs9JciXdIyVPoetR9P6PE1V1fXu/Efhfuj8S+fN/fLgWuLaqzmnr36dLGMfs/psgrr7OAx7aZjBbC3gRcEKfY9LKdwJwYFs+EPhRH2PRGGrPG/0PcHlVfapnl5+BcSDJRklmtOUpwFPpnkP9BbB/K+b9X0NV1buqavOqmkX3//2pVXUA3v9xIcmDkkwbWAaeBlyGP//Hhar6K3BNkn9om/YBfssY3v9UORphdZXkn+j+gjgROKqqPtznkDSGknwb2AuYCfwN+ADwQ+C7wJbA1cDzq2rwRDZaAyTZA/glMJu/P4P0brrnEP0MrOGSPJJuEoKJdH/c/W5VfTDJNnQ9ShsAFwEvraq7+xepxlqSvYC3VdW+3v/xod3n/22rk4BvVdWHk2yIP//HhSS70E1QtRZwBfAK2v8FjMH9N0GUJEmSJAEOMZUkSZIkNSaIkiRJkiTABFGSJEmS1JggSpIkSZIAE0RJkiRJUmOCKEmrsSTz2/usJC9Zwcd+96D1X63I4y9nLAclOaJf7Y+lJG9Osm6/4xhKktOS7NqW3z1S+SHqD3nfkjwnyTuX4zgzkryuZ32vJCcuo+xXk+y0vLGOMo4V/u/s/krn1CTrDdr+0XZ99uu9xkk+meQpKz9SSasbE0RJWjPMApbrF9ckE0coslRCUFVPWM6YVhmjONexbDtJhvv/9s3AciWIw51PkknLc6zlsNwJ4rJU1QlVdfhyVJkBvG7EUt2x/7Wqfnv/IhvRLJbz39kY+ifgkqqaO2j74+i+H/XJdN+dOuBzwKiTcknjlwmiJK0ZDgeelOTiJG9JMjHJJ5Kcl+TSJP8G9/a8/CLJt4DZbdsPk1yQ5DdJXtO2HQ5Macc7tm0b6K1MO/ZlSWYneWHPsU9L8v0kv0tybJIMHC/Jb1ssnxwcfDvOjHbsW5K8vG3/RpKntmKbJvlZkj8m+XhP3aclOTvJhUm+l2Rq235lkvcnORN4fpJtW/0LkvwyyQ5DxLFBux6XJvl1+4J6khzaYjm1tf/qnjpv77nOh7Vts5JcnuQLwIXAFkmOTHJ+u84D5d4IbAr8Iskv2rYXt+txWZKP9bQzP8kHk5wD7D4o7tOSfCTJ6cCbkmyU5PgW13lJntjKPbnd04uTXJRkWgb1xiU5IslBg44/1OfhpUnObdu+NJC0JnlFkj+0WJ44+Bq3Mvf2LCY5Oslnk/wqyRVJ9h+iyuHAtq2tT7RtU5fxWTstya7p/g0c3fM5fcsQcWyV5JR2705JsmVPTPv3lJvfE8fgf2efbMe/NMkhrfw+7frOTnJUkrXb9ivbfTq7fRYeneTnSf6c5LU97d3nMzWEA4Af9dT5RJJLgd2As4F/BY5M8n6AqroK2DDJxss4niR1qsqXL1++fK2mL2B+e98LOLFn+2uA97bltYHzga1buTuArXvKbtDepwCXARv2HnuItv4FOBmYCDwEuBrYpB17DrA53R8gzwb2ADYAfg+k1Z8xxHl8EXgW8HDgPOArbfsfganAQcAVwHRgHeAqYAtgJnAG8KBW/j+A97flK4F39LRxCvDQtvw44NQh4vgc8IG2/BTg4rZ8KHBJu0YzgWvoErunAV8G0s75RGBPup6mJcDjh7jOE4HTgEf2xDmzLW/arudGwCTgVGC/tq+AFyzjc3Aa8IWe9W8Be7TlLYHL2/KPgSe25amtjb1Y+rNzBHBQz3F3Hfx5AHZsx5rc1r8AvLx9DgbiXws4CzhiiHgPGtgOHA18r12/nYA/DVF+FnBZz/peDPFZ640ZeAxwck+doT53PwYObMuvBH7YE9P+o/h3djBwPDBp4B7TfT6vAbZv274OvLnnXh/clj8NXApMa9frxrZ9yM/UELFfBUwbtO2xdJ/hycBZQ9T5CvAv/f655cuXr1X7NVbDUCRJ/fU04JE9vSDTgYcC9wDnVtVfesq+Mck/t+UtWrlbhjn2HsC3q2ox8LfWU7QbMLcd+1qAJBfT/WL/a+Au4KtJfkL3C+9gv6RLrK4CjgRek2Qz4Naqmt86h06pqjnt2L8FtqIbergTcFYrsxZdsjDguFZ+KvAE4HutHHSJ81Dn9i8AVXVqkg2TTG/7flRVC4AFrbfvsa3804CLWpmp7fpdDVxVVb/uOfYL0vXQTqJLpHaiSxB67QacVlU3tbiPbdflh8BiumRkWY7rWX4qsFPPua6XZBpdwvapdtwfVNW1PWWWxz50Cdh5rf4U4Ea6xLs3/uOA7UdxvB9W1RLgt0keMsoYhvqsndmz/wpgmySfA34CnDTEMXYHnteWvwF8fIgyw3kq8MWqWgRQVbcm2Rn4S1X9oZU5Bng98Jm2fkJ7nw1Mrap5wLwkdyWZQfd5GuozdcagtjdodXs9CrgY2AEYapjtjXR/hJCkZTJBlKQ1U4BDqurnS21M9qLrQexdfyqwe1XdmeQ0uh6QkY69LHf3LC+m61lZlOSxdEnFi4A30PXO9TqD7pfoLYH3AP8M7M/Sz1Dd59gtlpOr6sXLiGfgXCcAt1fVLsPEDkOfWw16790e4KNV9aWlDpLMYunrvDXwNmC3qrotydEMfZ2Hu7Z3taR8We7oWZ5Ad08XDCpzeEvS/wn4dbrhu4tY+pGTke7/QJzHVNW7ltqY7Md9r9No9N7b0WasQ30e7tWu887A0+k+Wy+g6yUczkDs916TNnR1rWWUD/c935HiH4h7CUufwxL+/pm+z2dqCIuSTKiqJUl2oev13By4me6Z1rTEufdzsA4w+DMhSUvxGURJWjPMoxuqNuDnwMFJJgMk2T7Jg4aoNx24rSWHOwCP79m3cKD+IGcAL2zPX21E18N17rICa71306vqp3QTstwnSauqa+iGbj60qq6g6wl6G0sniEP5NfDEJNu1ttZNcp8eq+om8vhLkue3cmnJw1DndkArsxdwc/19EpDnJlknyYZ0Qw3Po7vOr8zfn3vcLMmDhzjuenQJ3JzWQ/bMnn299+4c4MlJZqZ7pu/FwOkjXIOhnESXiNPi2qW9b1tVs6vqY3TDjneg67XdKcnarbd0n2Ucs/fzcAqw/8C5pnt2c6sW/16t53Uy8Pz7EftQBn++R5RkJjChqo4H3gc8eohiv6L7owV0932gB/JKuh5SgOfSDdkcKo6TgNemTQyUZAPgd8Csgc8k8DKW7x6O9jP1e2AbgKq6uP3x4w90PdOnAk+vql0G/ZFge7ph5JK0TPYgStKa4VK6HoVL6HoS/ptuyN2FrQfkJmC/Ier9jO4X3EvpfuHsHRL5ZeDSJBdW1QE92/+XbmjeJXS9J++oqr9miElfmmnAj5KsQ9c7cp/JQppz6J7Pgy4x/ChLDxm8j6q6Kd2EKt8emAgEeC/dL8qDHUA3acd76X7h/047h16HAl9r1+NO4MCefefSDVXcEvhQVV0PXJ9kR+DsNtRyPvBSuh6t3jgvSXIR8Bu6oY9n9ez+MvB/SW6oqr2TvAv4Bd21+mlV/Yjl90bg8+08JtElvq8F3pxk7xbfb4H/q6q7k3yX7jP0R/4+tHGwpT4P7TqelG6G1oXA66vq10kOpRvmewPdBD0PeAbZqrolyVlJLgP+j+4+jGQzuns58Mfwdw1R5o3AUUneTvdv5BVt+1foPrPn0iXDA72zg/+dfY4u6bo0yUK6Z2ePSPIKuuHMk+j+kPDF5TjXk5bxmbpxUNGf0P2h4k8A7Y81t7UexR1q0EyuLWHfju4PA5K0TAMTBkiSpGVoSc/8qrrPDKxSPyTZBPh6Vf3jKMv/M/Doqnrf2EYmaXXnEFNJkqTVTFXdAHwlyXqjrDIJ+K8xDEnSGsIeREmSJEkSYA+iJEmSJKkxQZQkSZIkASaIkiRJkqTGBFGSJEmSBJggSpIkSZIaE0RJkiRJEmCCKEmSJElqTBAlSZIkSYAJoiRJkiSpMUGUJEmSJAEmiJIkSZKkxgRRkiRJkgSYIEqSJEmSGhNESZIkSRJggihJkiRJakwQJUlaBSTZMsn8JBP7HYskafwyQZQkqUeSK5MsaMnaX5McnWTqWLdbVVdX1dSqWjzWba1oSWYlqSST+h2LJOmBMUGUJOm+nl1VU4FdgEcB7+pnMOn07f/sse7VNLGUpFWHCaIkSctQVX8Ffk6XKAKQZO0kn0xydZK/Jflikilt315Jrk3y7iQ3t97IA3rqPivJRUnmJrkmyaE9+5bqhUtyWpIPJzkLuBPYZnB8SXZs5W5P8pskz+nZd3SL7eQk85KcnmSrnv07tH23Jvl9khcMqntkkp8muQPYe7jYgTPa++2t53X3JBOSvDfJVUluTPL1JNMHneurklwNnJpknSTfTHJLO5/zkjzk/tw3SdL9Z4IoSdIyJNkceCbwp57NHwO2p0satwM2A97fs39jYGbbfiDw5ST/0PbdAbwcmAE8Czg4yX7DhPAy4DXANOCqQbFNBn4MnAQ8GDgEOLanLYADgA+1eC4Gjm11HwScDHyr1X0x8IUkD+up+xLgw63tM0eIfc/2PqMNkz0bOKi99qZLbqcCRww6vycDOwJPb9dqOrAFsCHwWmDBMNdGkjQGTBAlSbqvHyaZB1wD3Ah8ALqhnsCrgbdU1a1VNQ/4CPCiQfXfV1V3V9XpwE+AFwBU1WlVNbuqllTVpcC36ZKkZTm6qn5TVYuqauGgfY+nS7oOr6p7qupU4ES6ZG/AT6rqjKq6G3gPsHuSLYB9gSur6mvt2BcCxwP799T9UVWd1WK9637EfgDwqaq6oqrm0w3TfdGg4aSHVtUdVbUAWEiXGG5XVYur6oKqmjvM8SVJY8AEUZKk+9qvqqYBewE70PXAAWwErAtc0IZB3g78rG0fcFtV3dGzfhWwKUCSxyX5RZKbksyh6yWbybJdM8y+TYFrqmrJoLY2G6p+S9JubfW2Ah43cA7tPA6g6/0csu37EfumLN3reRUwCegdNtrbxjfohvN+J8n1ST7eekklSSuRCaIkScvQegCPBj7ZNt1MN+zxYVU1o72mtwltBqzfhnAO2BK4vi1/CzgB2KKqpgNfBDJcCMPsux7YYtDkNVsC1/WsbzGw0GZi3aDVuwY4veccBoaGHjxM28PFPlSc19Mlor2xLQL+NlQbVbWwqg6rqp2AJ9D1cr586FOXJI0VE0RJkob3GeAfk+zSeuu+Anw6yYMBkmyW5OmD6hyWZK0kT6JLdL7Xtk8Dbq2qu5I8lu45v/vrHLrnAt+RZHKSvYBnA9/pKfNPSfZIshbds4jnVNU1dENRt0/yslZ3cpLdkuw4THvDxX4TsISlJ9L5NvCWJFu35PQjwHFVtWiogyfZO8kj2oypc+mGnK52X/khSas7E0RJkoZRVTcBXwfe1zb9B92kNb9OMhf4f0DvxDB/BW6j60E7FnhtVf2u7Xsd8MH2fOP7ge8+gLjuAZ5DN4nOzcAXgJf3tAVdr98H6IaWPoZuGCnt2cmn0T07eX2L+WPA2sM0uczYq+pOugltzmpDVh8PHEU3bPQM4C/AXXQT6SzLxsD36ZLDy4HTgW+OdB0kSStWqoYbvSJJkkar9eJ9s6o2XwViORq4tqre2+9YJEmrD3sQJUmSJEmACaIkSZIkqXGIqSRJkiQJsAdRkiRJktRM6ncAeuBmzpxZs2bN6ncYkiRJklZRF1xwwc1VtdFI5UwQ1wCzZs3i/PPP73cYkiRJklZRSa4aTTmHmOr/t3fnYXJU5eLHv+9kspIdQgIkkkSzELZAWBS3yHZBonhBFAVZvCqrCj+Ri4CK4HW5gAtw5SK4YC6bLCoCKruIspiEEAJJWIMsSUggZIEQMjPv74+qgSZMVqank8n38zz9dNXpqjpvn67p6bfPqdOSJEmSBJggSpIkSZJKJoiSJEmSJMAEUZIkSZJUcpKaduCh5xYw+JQbax2GJFVNj61OqXUIkiRtEOxBlCRJkiQBJoiSJEmSpJIJoiRJkiQJMEGUJEmSJJVMECVJkiRJgAmiJEmSJKlkgihJkiRJAkwQJUmSJEklE0RJkiRJEmCCKEmSJEkqmSBKkiRJkgATREmSJElSyQRRkiRJkgSYIEqSJEmSSiaIkiRJkiTABFGSJEmSVDJBlCRJkiQBJoiSJEmSpJIJoiRJkiQJMEGUJEmSJJVMECVJkiRJgAmiJEmSJKlkgihJkiRJAkwQJUmSJEklE0RJkiRJEmCCKEmSJEkqmSBKkiRJkgATREmSJElSyQRRkiRJkgSYIEqSJEmSSiaIkiRJkiTABFGSJEmSVDJBlCRJkiQBJoiSJEmSpJIJoiRJkiQJMEGUJEmSJJWqliBGRF1EfKpax5ckSZIkta6qJYiZ2QQcX63jS5IkSZJaV7WHmN4SESdFxKCI6Nt8q3KdkiRJkqS1UF/l43++vD+uoiyBoVWuV5IkSZK0hqqaIGbmkGoeX5IkSZLUeqqaIEZER+AY4ENl0Z3ARZm5rJr1SpIkSZLWXLWHmF4IdAR+Vq5/riz7QpXrlSRJkiStoWoniDtn5vYV67dHxINVrlOSJEmStBaqPYtpY0S8u3klIoYCjVWuU5IkSZK0Fqrdg/h14I6IeBIIYEvenNlUkiRJkrQOqXaCeDcwDBhBkSBOr3J9kiRJkqS1VO0hpvdk5tLMnJKZD2bmUuCeKtcpSZIkSVoLVelBjIgBwBZA14jYgaL3EKAn0K0adUqSJEmS3plqDTH9N+AIYCDwo4ryRcCpVapTkiRJkvQOVCVBzMxLgUsj4sDMvLYadUiSJEmSWldVJ6nJzGsjYj9ga6BLRfmZ1axXkiRJkrTmqpogRsT/Ulxz+BHgEuCTwP3VrFNS68mG15l9+X+SDcugqYluI95P7w8ewrybfsrrsx8DoGOfzdl4vxOp69S1xtGqPVry5EReuu3n1NXPpc+H+tBvXL9ahyQJyKbkiTOeoGOfjmx54pYsfmQxs6+aTTYkXQd3ZYvPb0F0iFUfSNI6p9o/c7FbZm4XEVMy8zsRcS5wXZXrlNRaOnSk/8Hfo65TV7KxgdmXnUzXoWPou8cXqetczDf10m0Xs2jSDfR670E1DlbtTTY18tItF7Lpp79L751/xJPfeZIeO/SgyxZdVr2zpKp68eYX6bx5Z5qWNJFNybOXPMuQk4fQeUBn5lw3h/l3z6fvh/vWOkxJa6HaP3PxWnn/akRsDiwDhlS5ztUSEXdGxE61jqNZRHw8Ik6pdRxSpYh4o2cwmxqgqREi3kgOM5NseJ03JyqWWs/rsx6lvvdmdOw9gLr6Onrt2otFDyyqdVjSBm/ZS8tY9OAi+nyoDwCNixupq6+j84DOAHTfujsLJy6sZYiS3oFq9yD+MSJ6A2cDk4AELn6nB42I+sxseKfHeYcxBBCZ2dQax8vM64HrW6in5s9VG7ZsamTWpSfQMH8WPXbcj86bjwBg3o0/YcmTE+i4ySD67P4fNY5S7VHDohep7/nmkNL6PvUseXJJDSOSBDDr8lkM+PQAGpc0AtChRweyMVny1BK6DunKwgkLWfbSshpHKWltVa0HMSLqgNsy8+VyJtMtgZGZ+a3V2PebETE9Im6JiCsi4qSyx+97EfFX4KsR0S8iro2If5a395f7bhQRvyzLHoiI/cvyrhFxZURMiYirgK5l+X9ExI8r6v5iRPxoBXENjohpEfEzioR3UETsHRH3RMSkiLg6IrqX286MiB9GxP3l7T1l+cci4r4ytlsjon9ZfkREXFAu/zoifhQRdwA/XEEsX4qICRExofHVBavzkkhrJeo6sPmR5zPw2F+zdNajvD53JgCb7HcCA4+7lI4bD+LVaX+rbZCSpDaxcPJC6nvW03Xwm9edRwSDjhnErCtm8cR3nqCuSx1R58gSaX1VtR7EzGwqrzl8X7m+FFi6qv3KYZ8HAjuU8U0CJpYP987MD5fbXQ78ODPvjoh3AX8BtgJOA27PzM+XvZf3R8StwFHAq+U1kduVxwW4EpgSESdn5jLgyHLbFRkBHJmZx0bEJsDpwJ6Z+UpE/Cfw/4DmWVoXZuYuEXEY8BNgHHA38N7MzIj4AnAy8LUW6hleHrexpSAy8+fAzwE6bzYsVxKv1CrqunSny6BtWfLkJDr1GwwUyeNGIz/Iwvuvo/t2e9U2QLU79T02pmHh3DfWG+Y30LFPxxpGJOnVx15l4QMLWfTgInJZ0vhaI89c9AyDjhrE0FOHArBo6iKWzl7lRz5J66hqDzG9OSIOBK7LzNVNYj4A/CEzlwBExB8rHruqYnlPYFQx0hOAnhHRA9gb+HhEnFSWdwHeBXwIOA8gM6dExJRy+ZWIuB0YFxHTgI6Z+dBK4ns6M+8tl98LjAL+XsbRCbinYtsrKu6beykHAldFxGbl9k+toJ6rV5QcSm2l8dUFRF0H6rp0p2nZUl57ejI9dz2QZfOfp2OfzclMljx+Px37Dqx1qGqHOm02nIb5z7Ps5dk0NTSx4L4FDDzac02qpQEHDWDAQQMAWDxtMS/++UUGHTWIhoUN1Pesp2lZE/NunEe/jznjsLS+qnaC+P+AjYDGiFhCMZNFZmbPleyzsjEJr1Qs1wHva04k39i5yNQOzMwZy5VDcQ1kSy4BTgWmA79aSf3LxxDALZn5mRVsmy0snw/8KDOvj4ixwBmrUY9UE42LX2LejT+GbIJsotvID9L13Tsz57L/pGnpq0DScdMhbLz3cbUOVe1Q1HWg715H88Jvv8Xc6+bS54N9nMFUWkfNu2le0auYSd+P9KX7qO61DknSWqpqgpiZPdZit7uBiyLi+xTx7UfLE9vcDBxPMQEOETE6MydTDDX9ckR8uRzGuUNmPgDcBRwC3BER2wDbVcR5X0QMAnasLF8N9wL/ExHvyczHI6IbMDAzHy0f/zTwg/K+uWexF/BcuXz4GtQltblOmw5h8yPPe1v5gEPPrkE02hB1fffObPHunemxlZM8S+ua7lt1p/tWRSI44OABDDh4QI0jktQaqvozF1E4NHUgqHoAABySSURBVCK+Wa4PiohdVrZPZv6TYjbPByl+M3EC0NIsLF8BdionnXkEOLosPwvoSHFd4dRyHeBCoHs5tPRk4P7ljvdb4O+ZOX91n19mzgWOAK4oj3svMLJik84RcR/wVeDEsuwM4OqI+Bswb3XrkiRJkqRqi9W/NHAtDh5xIdAE7J6ZW0VEH+DmzNx5Fft1z8zFZY/cXcCXMnPSyvZphVhvoJj05rZWOt5MYKfMrHoS2HmzYbnZ4T+pdjWSVDP2IEqS9M5MPWLqxMxc5e/AV7UHEdg1M48DXgMoe+c6rcZ+P4+IyRQzjV5bzeQwInpHxKPAktZKDiVJkiRpfVTtSWqWRUQHyglaIqIfRY/iSmXmZ6scV2VdL1P8pMQbImJjoKVkcY/MfHE1jzv4nUcnSZIkSW2n2gniecDvgP4R8V/AJyl+N3CdViaBo2sdhyRJkiS1pWrPYnpZREwE9iiLPpGZ06pZpyRJkiRp7VS7BxGgG9A8zLRrG9QnSZIkSVoL1f6Zi28BlwJ9gU2AX0XEOj/EVJIkSZI2RNXuQfwMsENmvgYQET+gmJn0u1WuV5IkSZK0hqr9MxczgS4V652BJ6pcpyRJkiRpLVS7B3Ep8HBE3FKu7wncHRHnAWTmV6pcvyRJkiRpNVU7QfwLxe8JNgGNwB1Vrk+SJEmStJaqkiBGRD3wPeDzwNMUQ1kHAb8CTs3MZdWoV5IkSZK09qp1DeLZFDOXDsnMMZm5AzAU6FU+JkmSJElax1QrQRwHfDEzFzUXZOZC4BhgvyrVKUmSJEl6B6qVIGZmZguFjcDbyiVJkiRJtVetBPGRiDhs+cKIOBSYXqU6JUmSJEnvQLVmMT0OuC4iPg9MpOg13BnoCvx7leqUJEmSJL0DVUkQM/M5YNeI2B3YGgjgT5l5WzXqkyRJkiS9c1X9HcTMvB24vZp1SJIkSZJaR7WuQZQkSZIkrWdMECVJkiRJgAmiJEmSJKlkgihJkiRJAkwQJUmSJEklE0RJkiRJEmCCKEmSJEkqmSBKkiRJkgATREmSJElSyQRRkiRJkgSYIEqSJEmSSiaIkiRJkiTABFGSJEmSVDJBlCRJkiQBJoiSJEmSpJIJoiRJkiQJMEGUJEmSJJVMECVJkiRJgAmiJEmSJKlkgihJkiRJAkwQJUmSJEklE0RJkiRJEmCCKEmSJEkqmSBKkiRJkgATREmSJElSyQRRkiRJkgSYIEqSJEmSSiaIkiRJkiTABFGSJEmSVDJBlCRJkiQBJoiSJEmSpJIJoiRJkiQJgMjMWsegd2innXbKCRMm1DoMSZIkSeuoiJiYmTutajt7ECVJkiRJgAmiJEmSJKlkgihJkiRJAkwQJUmSJEklE0RJkiRJEuAspu1CRCwCZtQ6jg3UJsC8WgexgbLta8e2ry3bv3Zs+9qx7WvHtq+t1mz/LTOz36o2qm+lylRbM1Znylq1voiYYNvXhm1fO7Z9bdn+tWPb145tXzu2fW3Vov0dYipJkiRJAkwQJUmSJEklE8T24ee1DmADZtvXjm1fO7Z9bdn+tWPb145tXzu2fW21efs7SY0kSZIkCbAHUZIkSZJUMkGUJEmSJAEmiOu1iNgnImZExOMRcUqt42nvIuKXEfFCREytKOsbEbdExGPlfZ9axtheRcSgiLgjIqZFxMMR8dWy3PavsojoEhH3R8SDZdt/pywfEhH3lW1/VUR0qnWs7VVEdIiIByLihnLdtm8DETEzIh6KiMkRMaEs8z2njURE74i4JiKml+/977P9qy8iRpTnfPNtYUScYNu3jYg4sfxfOzUirij/B7f5e74J4noqIjoA/wPsC4wCPhMRo2obVbv3a2Cf5cpOAW7LzGHAbeW6Wl8D8LXM3Ap4L3Bceb7b/tW3FNg9M7cHRgP7RMR7gR8CPy7bfj7wHzWMsb37KjCtYt22bzsfyczRFb9B5ntO2/kp8OfMHAlsT/E3YPtXWWbOKM/50cAY4FXgd9j2VRcRWwBfAXbKzG2ADsDB1OA93wRx/bUL8HhmPpmZrwNXAvvXOKZ2LTPvAl5arnh/4NJy+VLgE20a1AYiM2dl5qRyeRHFB4UtsP2rLguLy9WO5S2B3YFrynLbvkoiYiCwH3BJuR7Y9rXke04biIiewIeAXwBk5uuZ+TK2f1vbA3giM5/Gtm8r9UDXiKgHugGzqMF7vgni+msL4JmK9WfLMrWt/pk5C4okBti0xvG0exExGNgBuA/bv02UQxwnAy8AtwBPAC9nZkO5ie8/1fMT4GSgqVzfGNu+rSRwc0RMjIgvlWW+57SNocBc4Ffl8OpLImIjbP+2djBwRbls21dZZj4HnAP8iyIxXABMpAbv+SaI669ooczfLFG7FhHdgWuBEzJzYa3j2VBkZmM53GggxeiFrVrarG2jav8iYhzwQmZOrCxuYVPbvjren5k7UlzKcVxEfKjWAW1A6oEdgQszcwfgFRzS2KbK69w+Dlxd61g2FOV1nfsDQ4DNgY0o3n+WV/X3fBPE9dezwKCK9YHA8zWKZUM2JyI2AyjvX6hxPO1WRHSkSA4vy8zrymLbvw2VQ7zupLgOtHc5BAZ8/6mW9wMfj4iZFJcR7E7Ro2jbt4HMfL68f4HiGqxd8D2nrTwLPJuZ95Xr11AkjLZ/29kXmJSZc8p127769gSeysy5mbkMuA7YjRq855sgrr/+CQwrZzbqRDEM4Poax7Qhuh44vFw+HPhDDWNpt8rrrn4BTMvMH1U8ZPtXWUT0i4je5XJXin9g04A7gE+Wm9n2VZCZ38jMgZk5mOI9/vbMPATbvuoiYqOI6NG8DOwNTMX3nDaRmbOBZyJiRFm0B/AItn9b+gxvDi8F274t/At4b0R0Kz/3NJ/3bf6eH5mOTFlfRcRHKb5N7gD8MjP/q8YhtWsRcQUwFtgEmAN8G/g98FvgXRR/2Adl5vIT2egdiogPAH8DHuLNa7FOpbgO0favoojYjuKi+A4UXyr+NjPPjIihFL1afYEHgEMzc2ntIm3fImIscFJmjrPtq69s49+Vq/XA5Zn5XxGxMb7ntImIGE0xOVMn4EngSMr3IGz/qoqIbhTzXAzNzAVlmed+Gyh/SurTFLO3PwB8geKawzZ9zzdBlCRJkiQBDjGVJEmSJJVMECVJkiRJgAmiJEmSJKlkgihJkiRJAkwQJUmSJEklE0RJWo9FxOLyfnBEfLaVj33qcuv/aM3jr2EsR0TEBbWqv5oi4oRyWvl1TkTcGRE7lcunrmr7FvZv8XWLiI9HxClrcJzeEXFsxfrYiLhhBdteEhGj1jTW1Yyj1f/O1lYUbo+InsuVf79sn09UtnFEnBMRu7d9pJLWNyaIktQ+DAbW6INrRHRYxSZvSQgyc7c1jGmdsRrPtZp1R0Ss7P/tCcAaJYgrez4RUb8mx1oDa5wgrkhmXp+ZP1iDXXoDx65yq+LYX8jMR9YuslUazBr+nVXRR4EHM3PhcuW7UvxG7Icpfj+22fnAaiflkjZcJoiS1D78APhgREyOiBMjokNEnB0R/4yIKRFxFLzR83JHRFwOPFSW/T4iJkbEwxHxpbLsB0DX8niXlWXNvZVRHntqRDwUEZ+uOPadEXFNREyPiMsiIpqPFxGPlLGcs3zw5XF6l8d+MSIOK8vHR8Se5WabR8SfI+KxiPjvin33joh7ImJSRFwdEd3L8pkR8a2IuBs4KCLeXe4/MSL+FhEjW4ijb9keUyLi3ojYriw/o4zl9rL+L1bs8/WKdv5OWTY4IqZFxM+AScCgiLgwIiaU7dy83VeAzYE7IuKOsuwzZXtMjYgfVtSzOCLOjIj7gPctF/edEfG9iPgr8NWI6BcR15Zx/TMi3l9u9+HyNZ0cEQ9ERI9YrjcuIi6IiCOWO35L58OhEXF/WXZRc9IaEUdGxKNlLO9fvo3Lbd7oWYyIX0fEeRHxj4h4MiI+2cIuPwDeXdZ1dlnWfQXn2p0RsVMUfwO/rjhPT2whji0j4rbytbstIt5VEdMnK7ZbXBHH8n9n55THnxIRXy6336Ns34ci4pcR0bksn1m+TveU58KOEfGXiHgiIo6uqO9t51QLDgH+ULHP2RExBdgZuIfiB7YvjIhvAWTm08DGETFgBceTpEJmevPmzZu39fQGLC7vxwI3VJR/CTi9XO4MTACGlNu9Agyp2LZved8VmApsXHnsFuo6ELgF6AD0B/4FbFYeewEwkOILyHuADwB9gRlAlPv3buF5/C+wH7AN8E/g4rL8MaA7cATwJNAL6AI8DQwCNgHuAjYqt/9P4Fvl8kzg5Io6bgOGlcu7Are3EMf5wLfL5d2ByeXyGcCDZRttAjxDkdjtDfwciPI53wB8iKKnqQl4bwvt3AG4E9iuIs5NyuXNy/bsB9QDtwOfKB9L4FMrOA/uBH5WsX458IFy+V3AtHL5j8D7y+XuZR1jeeu5cwFwRMVxd1r+fAC2Ko/VsVz/GXBYeR40x98J+DtwQQvxHtFcDvwauLpsv1HA4y1sPxiYWrE+lhbOtcqYgTHALRX7tHTe/RE4vFz+PPD7ipg+uRp/Z8cA1wL1za8xxfn5DDC8LPsNcELFa31MufxjYArQo2yvF8ryFs+pFmJ/GuixXNkuFOdwR+DvLexzMXBgrd+3vHnztm7fqjUMRZJUW3sD21X0gvQChgGvA/dn5lMV234lIv69XB5UbvfiSo79AeCKzGwE5pQ9RTsDC8tjPwsQEZMpPtjfC7wGXBIRN1J84F3e3ygSq6eBC4EvRcQWwEuZubjsHLotMxeUx34E2JJi6OEo4O/lNp0okoVmV5Xbdwd2A64ut4MicW7puR0IkJm3R8TGEdGrfOwPmbkEWFL29u1Sbr838EC5Tfey/f4FPJ2Z91Yc+1NR9NDWUyRSoygShEo7A3dm5twy7svKdvk90EiRjKzIVRXLewKjKp5rz4joQZGw/ag87nWZ+WzFNmtiD4oE7J/l/l2BFygS78r4rwKGr8bxfp+ZTcAjEdF/NWNo6Vy7u+LxJ4GhEXE+cCNwcwvHeB9wQLk8HvjvFrZZmT2B/83MBoDMfCkitgeeysxHy20uBY4DflKuX1/ePwR0z8xFwKKIeC0ielOcTy2dU3ctV3ffct9KOwCTgZFAS8NsX6D4EkKSVsgEUZLapwC+nJl/eUthxFiKHsTK9T2B92XmqxFxJ0UPyKqOvSJLK5YbKXpWGiJiF4qk4mDgeIreuUp3UXyIfhdwGvDvwCd56zVUbzt2GcstmfmZFcTT/FzrgJczc/RKYoeWn1sud19ZHsD3M/OitxwkYjBvbechwEnAzpk5PyJ+TcvtvLK2fa1MylfklYrlOorXdMly2/ygTNI/CtwbxfDdBt56ycmqXv/mOC/NzG+8pTDiE7y9nVZH5Wu7uhlrS+fDG8p23h74N4pz61MUvYQr0xz7G21SDl3ttILtg7c/31XF3xx3E299Dk28eU6/7ZxqQUNE1GVmU0SMpuj1HAjMo7imNcrEufI86AIsf05I0lt4DaIktQ+LKIaqNfsLcExEdASIiOERsVEL+/UC5pfJ4UjgvRWPLWvefzl3AZ8ur7/qR9HDdf+KAit773pl5k0UE7K8LUnLzGcohm4Oy8wnKXqCTuKtCWJL7gXeHxHvKevqFhFv67HKYiKPpyLioHK7KJOHlp7bIeU2Y4F5+eYkIPtHRJeI2JhiqOE/Kdr58/HmdY9bRMSmLRy3J0UCt6DsIdu34rHK1+4+4MMRsUkU1/R9BvjrKtqgJTdTJOKUcY0u79+dmQ9l5g8phh2PpOi1HRURncve0j1WcMzK8+E24JPNzzWKaze3LOMfW/a8dgQOWovYW7L8+b1KEbEJUJeZ1wLfBHZsYbN/UHxpAcXr3twDOZOihxRgf4ohmy3FcTNwdJQTA0VEX2A6MLj5nAQ+x5q9hqt7Ts0AhgJk5uTyy49HKXqmbwf+LTNHL/clwXCKYeSStEL2IEpS+zCFokfhQYqehJ9SDLmbVPaAzAU+0cJ+f6b4gDuF4gNn5ZDInwNTImJSZh5SUf47iqF5D1L0npycmbOjhUlfSj2AP0REF4rekbdNFlK6j+L6PCgSw+/z1iGDb5OZc6OYUOWK5olAgNMpPigv7xCKSTtOp/jAf2X5HCqdAfyqbI9XgcMrHrufYqjiu4CzMvN54PmI2Aq4pxxquRg4lKJHqzLOByPiAeBhiqGPf694+OfAnyJiVmZ+JCK+AdxB0VY3ZeYfWHNfAf6nfB71FInv0cAJEfGRMr5HgD9l5tKI+C3FOfQYbw5tXN5bzoeyHW+OYobWZcBxmXlvRJxBMcx3FsUEPe94BtnMfDEi/h4RU4E/UbwOq7IFxWvZ/GX4N1rY5ivALyPi6xR/I0eW5RdTnLP3UyTDzb2zy/+dnU+RdE2JiGUU185eEBFHUgxnrqf4IuF/1+C53ryCc+qF5Ta9keKLiscByi9r5pc9iiNzuZlcy4T9PRRfDEjSCjVPGCBJklagTHoWZ+bbZmCVaiEiNgN+k5l7reb2/w7smJnfrG5kktZ3DjGVJElaz2TmLODiiOi5mrvUA+dWMSRJ7YQ9iJIkSZIkwB5ESZIkSVLJBFGSJEmSBJggSpIkSZJKJoiSJEmSJMAEUZIkSZJUMkGUJEmSJAEmiJIkSZKkkgmiJEmSJAkwQZQkSZIklUwQJUmSJEmACaIkSZIkqVRf6wAkaX01ceLETevr6y8BtsEv3KR1RRMwtaGh4Qtjxox5odbBSNL6xgRRktZSfX39JQMGDNiqX79+8+vq6rLW8UiCpqammDt37qjZs2dfAny81vFI0vrGb7wlae1t069fv4Umh9K6o66uLvv167eAomdfkrSGTBAlae3VmRxK657y79LPOJK0FnzzlCRJkiQBXoMoSa1m8Ck3jmnN4838wX4TV7VNhw4dxgwbNmxJZtKhQ4f86U9/+q+99trrlTWt68wzz9z0xBNPnNejR4+mtYt2Jc7o1artwhkLWr1d5s2b1+GSSy7pe8opp8wFmDFjRqc77rij+9FHH/1Sa4a+pra9dNtWbbuHDn9olW3X7De/+U3vww8//N2TJk16eIcddnitNeNoydqcgzfccEOPc889t/8dd9zxeDVjk6QNiT2IkrQe69y5c9P06dMfmTFjxiNnnXXWc6eeeurAtTnORRdd1H/x4sXt5n/CmrbLiy++2OEXv/jFps3rjz32WOerrrqq75rU2dDQsLbhrpOuvPLKvjvuuOPi8ePHr1E7rK32dg5K0vrKN2JJaicWLFjQoVevXm9kKd/85jf7b7PNNlsNHz581Iknnrg5wMKFC+vGjh37nhEjRowaNmzY1hdffHGf7373u5u+8MILHT/84Q8P33XXXYfX7hlUx+q0y9e+9rWBzzzzTOeRI0eOOuqoowaedtppW0yYMKH7yJEjR33nO9/ZtKGhgaOOOmpg835nn332JlD0YO26667DP/axjw0ZMWLE1rV6jq1twYIFdRMmTOj+q1/9aubvfve7Ps3lp59+ev/hw4ePGjFixKhjjz12C4CpU6d23m233YaPGDFi1KhRo7Z6+OGHO0PL7TxjxoxOQ4YM2fqAAw4YPHz48FH77LPP0EWLFtW1dA5ed911PUePHj1y1KhRW+27775DFyxYUAdwzTXX9BwyZMjWY8aMGXHNNdf0bvvWkaT2zSGmkrQeW7p0ad3IkSNHLV26NObNm9fxpptuehSKD9ePP/54lylTpkzLTPbcc8/3/OlPf+o+Z86c+gEDBiy78847H4ei52zjjTduvPDCC/v/9a9/fXSzzTZrF91ga9ou55577rPjxo3rOn369Efg7UMXzznnnE169erVOHXq1GlLliyJnXfeeeTHPvaxhQBTpkzZ6IEHHnh45MiRr9fuGbeuyy67rPfYsWMXbLfddkt79+7dePfdd3d7/vnn62+88cY+EydOnN6jR4+mOXPmdAD47Gc/O+Skk06afdhhh7386quvRmNjY6yonYcOHfr6zJkzu1x00UUz995771cOOuigwWeffXa/M888c07lOThr1qz6733ve5vdddddj/bs2bPptNNOG3DWWWf1P/PMM2cff/zxg2+55ZYZW2+99dJx48YNrXVbSVJ7Y4IoSeux5qGUALfeeutGRx555JBHH3304T//+c8977rrrp6jRo0aBfDqq6/WTZ8+vcsee+yx6LTTTht0zDHHbLH//vsv2GeffRbX9hlUx5q2y9ChQ1ea3N166609p0+f3u3666/vA7Bo0aIOjzzySJdOnTrldttt90p7Sg4Bfvvb3/b96le/+gLAgQce+NL48eP7NjU1ceihh75xjWD//v0b58+fXzdnzpxOhx122MsA3bp1SyBX1s4DBgx4fe+9934F4HOf+9yL55133qbAnMr677zzzo2eeOKJLrvssstIgGXLlsWYMWMWT548ucvAgQOXbrvttksBDjnkkBcvueSSfm3VLpK0ITBBlKR2Ys8993xl/vz59bNmzarPTE444YRZX//61+ctv92kSZMeufbaa3uddtppW9x6660LzznnnFm1iLetrE67zJgxo9PKjpGZce655/7rwAMPXFhZfsMNN/To1q1b60/sU0OzZ8/ucO+99/Z89NFHux5//PE0NjZGRORHP/rRlyPiLdtmtvwrLytr5+WPsfx68/4f+MAHFv7xj398qrL8H//4R9eWtpcktR6vQZSkduKBBx7o0tTURP/+/Rv23XffhePHj9+k+bqtp556quNzzz1XP3PmzI49evRoOvbYY1864YQT5kyePLkbwEYbbdTYvG17szrt0qtXr8ZXXnnljeffq1evxsWLF3doXt9rr70WXHjhhf2WLl0aAFOmTOm8cOHCdtle48eP73PAAQe8+Pzzzz/03HPPPTR79uwpAwcOfL1v374N48eP32TRokV1AHPmzOnQt2/fpgEDBrw+fvz43gBLliyJRYsW1a2onQFmzZrV6dZbb90I4PLLL++72267LYa3noNjx459ZcKECd2nTp3aGWDRokV1U6ZM6Tx69OjXnn322U7N1zleeeWVbTKBjiRtSOxBlKRWsjo/S9Hamq+1g6LX5cILL5xZX1/PAQccsPDhhx/usvPOO48E6NatW9Nll1321PTp0zt/4xvfGFhXV0d9fX3+7Gc/exrg8MMPn7fvvvsO23TTTZfdd999j7ZqkKvxsxStbU3bZeutt146ZsyYxcOGDdt69913X3Deeec9V19fnyNGjBj12c9+dt7pp5/+wsyZMztvu+22W2Vm9O3bd9lNN930RLWfx5r8LEVrufrqqzc++eST39KrvP/++8+fNm1al3333ffl0aNHb9WxY8fcc889F1xwwQXP/d///d9TX/ziF7c866yzNu/YsWNeffXVT6yonevr63Po0KGv/fKXv9z42GOP3XLIkCFLTzrppLnw9nPwoosumnnwwQcPff311wPg29/+9nPbbbfd0vPPP//pcePGvadv374Nu+666+Jp06Z1bes2kqT2LFY0PESStHIPPvjgzO233/5tQzgltWzGjBmdxo0bN+yxxx57uNp1Pfjgg5tsv/32g6tdjyS1N+1yeIwkSZIkac2ZIEqSpDYxYsSI19ui91CStPZMECVp7TU1NTU5paK0jin/LtvV7LKS1FZMECVp7U2dO3duL5NEad3R1NQUc+fO7QVMrXUskrQ+chZTSVpLDQ0NX5g9e/Yls2fP3ga/cJPWFU3A1IaGhi/UOhBJWh85i6kkSZIkCfAbb0mSJElSyQRRkiRJkgSYIEqSJEmSSv8fl4FsY+hyMacAAAAASUVORK5CYII=\n",
-      "text/plain": [
-       "<Figure size 1008x432 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "figure = plt.figure(\"operator_counts\", figsize=(14, 6))\n",
-    "figure.subplots_adjust(bottom=0.15, hspace=.5)\n",
-    "result.plot_operator_counts(figure=figure, title=\"Operator diagnostics\", legend=[\"Best\", \"Better\", \"Accepted\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Several conclusions follow.\n",
-    "\n",
-    "* Of the destroy operators, `random_removal` and `path_removal` perform similarly: while `random_removal` results in more accepted solution states, both find globally best states at about the same rate. Observe that `worst_removal` does not actually result in many better or equivalent states, which suggests it is inferior to the other two destroy operators. \n",
-    "* The `greedy_repair` repair heuristic leads to many solution states that are inferior to the current best state, and are thus rejected by the ALNS algorithm. This is unfortunate, and suggests a better repair heuristic should be found. Ideally, such a heuristic would better exploit the problem structure."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 864x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "draw_graph(solution.to_graph())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Post-processing\n",
-    "\n",
-    "It is not difficult to see the above solution can easily be improved upon: there are plenty of inefficiencies in small subpaths near both the center and the various corners of the tour. We will partially remedy this with a single pass over all nodes, optimally choosing a subpath of length ``k`` starting at each of these nodes. Since such a process is computationally demanding, we select ``k = 7``."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "k = 7"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def fix_bounds(permutation, start_node, end_node):\n",
-    "    \"\"\"\n",
-    "    Fixes the given permutation to the start and end nodes, such that\n",
-    "    it connects up to the remainder of the solution.\n",
-    "    \"\"\"\n",
-    "    return (start_node,) + permutation + (end_node,)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def optimal_subpath(nodes, start_node, end_node):\n",
-    "    \"\"\"\n",
-    "    Computes the minimum cost subpath from the given nodes, where the \n",
-    "    subpath is fixed at start_node and end_node.\n",
-    "    \"\"\"\n",
-    "    def cost(subpath):\n",
-    "        path = fix_bounds(subpath, start_node, end_node)\n",
-    "        \n",
-    "        return sum(distances.euclidean(path[idx][1], path[idx + 1][1])\n",
-    "                   for idx in range(len(path) - 1))\n",
-    "\n",
-    "    subpath = min(itertools.permutations(nodes, k), key=cost)\n",
-    "\n",
-    "    return fix_bounds(subpath, start_node, end_node)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def post_process(state):\n",
-    "    \"\"\"\n",
-    "    For each node in the passed-in state, this post processing step \n",
-    "    computes the optimal subpath consisting of the next k nodes. This\n",
-    "    results in a run-time complexity of about O(n * k!), where n is\n",
-    "    the number of nodes.\n",
-    "    \"\"\"\n",
-    "    state = state.copy()\n",
-    "\n",
-    "    for start_node in state.nodes:\n",
-    "        nodes = []\n",
-    "        node = start_node\n",
-    "\n",
-    "        # Determine the next k nodes that make up the subpath starting\n",
-    "        # at this start_node.\n",
-    "        for _ in range(k):\n",
-    "            node = state.edges[node]\n",
-    "            nodes.append(node)\n",
-    "        \n",
-    "        end_node = state.edges[node]\n",
-    "\n",
-    "        optimal = optimal_subpath(nodes, start_node, end_node)\n",
-    "        \n",
-    "        # Replace the existing path with the optimal subpath.\n",
-    "        for first, second in zip(optimal, optimal[1:]):\n",
-    "            state.edges[first] = second\n",
-    "\n",
-    "    return state"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "New heuristic objective is 576.\n",
-      "This is 2.1% worse than the optimal solution, which is 564.\n"
-     ]
-    }
-   ],
-   "source": [
-    "new_solution = post_process(solution)\n",
-    "new_objective = new_solution.objective()\n",
-    "\n",
-    "print(\"New heuristic objective is {0}.\".format(new_objective))\n",
-    "print('This is {0:.1f}% worse than the optimal solution, which is {1}.'\n",
-    "      .format(100 * (new_objective - optimal) / optimal, optimal))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 864x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "draw_graph(new_solution.to_graph())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Conclusions\n",
-    "\n",
-    "In the code above we implemented a very simple heuristic for the TSP, using the ALNS meta-heuristic framework. We did not tinker too much with the various hyperparameters available on the ALNS implementation, but even for these relatively basic heuristic methods and workflow we find a very good result - just 2.1% worse than the optimal tour.\n",
-    "\n",
-    "This notebook showcases how the ALNS library may be put to use to construct powerful, efficient heuristic pipelines from simple, locally greedy operators."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from alns import ALNS, State\n",
+    "from alns.criteria import HillClimbing\n",
+    "from alns.weight_schemes import SimpleWeights\n",
+    "\n",
+    "import copy\n",
+    "import itertools\n",
+    "\n",
+    "import numpy.random as rnd\n",
+    "\n",
+    "import networkx as nx\n",
+    "\n",
+    "import tsplib95\n",
+    "import tsplib95.distances as distances\n",
+    "\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "SEED = 9876"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# The travelling salesman problem\n",
+    "\n",
+    "The travelling salesman problem (TSP) is a classic problem in operations research. It asks how to construct the minimum distance tour between a number of cities, such that each city is visited once and the tour concludes at the starting city (that is, it forms a cycle). It is perhaps the best-known problem in the class of [NP-hard](https://en.wikipedia.org/wiki/NP-hardness) problems.\n",
+    "\n",
+    "### Data\n",
+    "There are a considerable number of test data sets available for the TSP, varying in size from a hundred or so locations to many hundreds of thousands. For the sake of exposition, we shall use one of the smaller data sets: the data from the XQF131 VLSI instance, made available [here](http://www.math.uwaterloo.ca/tsp/vlsi/index.html#XQF131). It consists of 'only' 131 cities, with an optimal tour length of 564."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Total optimal tour length is 564.\n"
+     ]
+    }
+   ],
+   "source": [
+    "data = tsplib95.load('xqf131.tsp')\n",
+    "\n",
+    "# These we will use in our representation of a TSP problem: a list of\n",
+    "# (city, coord)-tuples.\n",
+    "cities = [(city, tuple(coord)) for city, coord in data.node_coords.items()]\n",
+    "\n",
+    "solution = tsplib95.load('xqf131.opt.tour')\n",
+    "optimal = data.trace_tours(solution.tours)[0]\n",
+    "\n",
+    "print(f\"Total optimal tour length is {optimal}.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def draw_graph(graph, only_nodes=False):\n",
+    "    \"\"\"\n",
+    "    Helper method for drawing TSP (tour) graphs.\n",
+    "    \"\"\"\n",
+    "    fig, ax = plt.subplots(figsize=(12, 6))\n",
+    "\n",
+    "    if only_nodes:\n",
+    "        nx.draw_networkx_nodes(graph, data.node_coords, node_size=25, ax=ax)\n",
+    "    else:\n",
+    "        nx.draw_networkx(graph, data.node_coords, node_size=25, with_labels=False, ax=ax)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 864x432 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "draw_graph(data.get_graph(), True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Operators and solution state\n",
+    "\n",
+    "To use the ALNS meta-heuristic, we need to have destroy and repair operators that work on a proposed solution, and a way to describe such a solution in the first place. The ALNS package exposes the class ``State`` to describe a solution, with an ``objective()`` member that computes this solution's objective value. Using it, we may compute a simple initial solution, and then apply the ALNS algorithm."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Solution state"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class TspState(State):\n",
+    "    \"\"\"\n",
+    "    Solution class for the TSP problem. It has two data members, nodes, and edges.\n",
+    "    nodes is a list of node tuples: (id, coords). The edges data member, then, is\n",
+    "    a mapping from each node to their only outgoing node.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    def __init__(self, nodes, edges):\n",
+    "        self.nodes = nodes\n",
+    "        self.edges = edges\n",
+    "\n",
+    "    def objective(self):\n",
+    "        \"\"\"\n",
+    "        The objective function is simply the sum of all individual edge lengths,\n",
+    "        using the rounded Euclidean norm.\n",
+    "        \"\"\"\n",
+    "        return sum(distances.euclidean(node[1], self.edges[node][1])\n",
+    "                   for node in self.nodes)\n",
+    "    \n",
+    "    def to_graph(self):\n",
+    "        \"\"\"\n",
+    "        NetworkX helper method.\n",
+    "        \"\"\"\n",
+    "        graph = nx.Graph()\n",
+    "\n",
+    "        for node, coord in self.nodes:\n",
+    "            graph.add_node(node, pos=coord)\n",
+    "\n",
+    "        for node_from, node_to in self.edges.items():\n",
+    "            graph.add_edge(node_from[0], node_to[0])\n",
+    "\n",
+    "        return graph"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Destroy operators\n",
+    "\n",
+    "Destroy operators break parts of a solution down, leaving an incomplete state. This is the first part of each iteration of the ALNS meta-heuristic; the incomplete solution is subsequently repaired by any one repair operator. We will consider three destroy operators: **worst removal**, **path removal** and **random removal**. We will also use a separate parameter, the degree of destruction, to control the extent of the damage done to a solution in each step."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "degree_of_destruction = 0.25\n",
+    "\n",
+    "def edges_to_remove(state):\n",
+    "    return int(len(state.edges) * degree_of_destruction)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def worst_removal(current, rnd_state):\n",
+    "    \"\"\"\n",
+    "    Worst removal iteratively removes the 'worst' edges, that is,\n",
+    "    those edges that have the largest distance.\n",
+    "    \"\"\"\n",
+    "    destroyed = copy.deepcopy(current)\n",
+    "\n",
+    "    worst_edges = sorted(destroyed.nodes,\n",
+    "                         key=lambda node: distances.euclidean(node[1],\n",
+    "                                                              destroyed.edges[node][1]))\n",
+    "\n",
+    "    for idx in range(edges_to_remove(current)):\n",
+    "        del destroyed.edges[worst_edges[-(idx + 1)]]\n",
+    "\n",
+    "    return destroyed"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def path_removal(current, rnd_state):\n",
+    "    \"\"\"\n",
+    "    Removes an entire consecutive sub-path, that is, a series of\n",
+    "    contiguous edges.\n",
+    "    \"\"\"\n",
+    "    destroyed = copy.deepcopy(current)\n",
+    "    \n",
+    "    node_idx = rnd_state.choice(len(destroyed.nodes))\n",
+    "    node = destroyed.nodes[node_idx]\n",
+    "    \n",
+    "    for _ in range(edges_to_remove(current)):\n",
+    "        node = destroyed.edges.pop(node)\n",
+    "\n",
+    "    return destroyed"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def random_removal(current, rnd_state):\n",
+    "    \"\"\"\n",
+    "    Random removal iteratively removes random edges.\n",
+    "    \"\"\"\n",
+    "    destroyed = copy.deepcopy(current)\n",
+    "    \n",
+    "    for idx in rnd_state.choice(len(destroyed.nodes),\n",
+    "                                edges_to_remove(current),\n",
+    "                                replace=False):\n",
+    "        del destroyed.edges[destroyed.nodes[idx]]\n",
+    "\n",
+    "    return destroyed"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Repair operators\n",
+    "\n",
+    "We implement a simple, **greedy repair** strategy. It determines a set of nodes that are currently not visited, and then links these up to the tour such that it forms one cycle."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def would_form_subcycle(from_node, to_node, state):\n",
+    "    \"\"\"\n",
+    "    Ensures the proposed solution would not result in a cycle smaller\n",
+    "    than the entire set of nodes. Notice the offsets: we do not count\n",
+    "    the current node under consideration, as it cannot yet be part of\n",
+    "    a cycle.\n",
+    "    \"\"\"\n",
+    "    for step in range(1, len(state.nodes)):\n",
+    "        if to_node not in state.edges:\n",
+    "            return False\n",
+    "\n",
+    "        to_node = state.edges[to_node]\n",
+    "        \n",
+    "        if from_node == to_node and step != len(state.nodes) - 1:\n",
+    "            return True\n",
+    "\n",
+    "    return False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def greedy_repair(current, rnd_state):\n",
+    "    \"\"\"\n",
+    "    Greedily repairs a tour, stitching up nodes that are not departed\n",
+    "    with those not visited.\n",
+    "    \"\"\"\n",
+    "    visited = set(current.edges.values())\n",
+    "  \n",
+    "    # This kind of randomness ensures we do not cycle between the same\n",
+    "    # destroy and repair steps every time.\n",
+    "    shuffled_idcs = rnd_state.permutation(len(current.nodes))\n",
+    "    nodes = [current.nodes[idx] for idx in shuffled_idcs]\n",
+    "\n",
+    "    while len(current.edges) != len(current.nodes):\n",
+    "        node = next(node for node in nodes \n",
+    "                    if node not in current.edges)\n",
+    "\n",
+    "        # Computes all nodes that have not currently been visited,\n",
+    "        # that is, those that this node might visit. This should\n",
+    "        # not result in a subcycle, as that would violate the TSP\n",
+    "        # constraints.\n",
+    "        unvisited = {other for other in current.nodes\n",
+    "                     if other != node\n",
+    "                     if other not in visited\n",
+    "                     if not would_form_subcycle(node, other, current)}\n",
+    "\n",
+    "        # Closest visitable node.\n",
+    "        nearest = min(unvisited,\n",
+    "                      key=lambda other: distances.euclidean(node[1], other[1]))\n",
+    "\n",
+    "        current.edges[node] = nearest\n",
+    "        visited.add(nearest)\n",
+    "\n",
+    "    return current"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Initial solution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Initial solution objective is 851.\n"
+     ]
+    }
+   ],
+   "source": [
+    "random_state = rnd.RandomState(SEED)\n",
+    "state = TspState(cities, {})\n",
+    "\n",
+    "init_sol = greedy_repair(state, random_state)\n",
+    "print(f\"Initial solution objective is {init_sol.objective()}.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 864x432 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "draw_graph(init_sol.to_graph())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Heuristic solution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "alns = ALNS(random_state)\n",
+    "\n",
+    "alns.add_destroy_operator(random_removal)\n",
+    "alns.add_destroy_operator(path_removal)\n",
+    "alns.add_destroy_operator(worst_removal)\n",
+    "\n",
+    "alns.add_repair_operator(greedy_repair)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "criterion = HillClimbing()\n",
+    "weight_scheme = SimpleWeights([3, 2, 1, 0.5], 3, 1, 0.8)\n",
+    "\n",
+    "result = alns.iterate(init_sol,\n",
+    "                      weight_scheme,\n",
+    "                      criterion,\n",
+    "                      iterations=5000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Best heuristic objective is 606.\n",
+      "This is 7.4% worse than the optimal solution, which is 564.\n"
+     ]
+    }
+   ],
+   "source": [
+    "solution = result.best_state\n",
+    "objective = solution.objective()\n",
+    "pct_difference = 100 * (objective - optimal) / optimal\n",
+    "\n",
+    "print(f\"Best heuristic objective is {objective}.\")\n",
+    "print(f\"This is {pct_difference:.1f}% worse than the optimal solution, which is {optimal}.\")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 864x432 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "_, ax = plt.subplots(figsize=(12, 6))\n",
+    "result.plot_objectives(ax=ax, lw=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Having obtained a reasonable solution, we now want to investigate each operator's performance. This may be done via the `plot_operator_counts()` method on the `result` object, like below. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 1008x432 with 2 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "figure = plt.figure(\"operator_counts\", figsize=(14, 6))\n",
+    "figure.subplots_adjust(bottom=0.15, hspace=.5)\n",
+    "result.plot_operator_counts(figure, title=\"Operator diagnostics\", legend=[\"Best\", \"Better\", \"Accepted\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Several conclusions follow.\n",
+    "\n",
+    "* Of the destroy operators, `random_removal` and `path_removal` perform similarly: while `random_removal` results in more accepted solution states, both find globally best states at about the same rate. Observe that `worst_removal` does not actually result in many better or equivalent states, which suggests it is inferior to the other two destroy operators. \n",
+    "* The `greedy_repair` repair heuristic leads to many solution states that are inferior to the current best state, and are thus rejected by the ALNS algorithm. This is unfortunate, and suggests a better repair heuristic should be found. Ideally, such a heuristic would better exploit the problem structure."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 864x432 with 1 Axes>",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqsAAAFUCAYAAAADN3WgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAB3GklEQVR4nO3dd1QUZxcH4N8uHRRRERVLLGDDDgqWKFYE7ChgrFHs2DXqZ+wxsYu9YcFOU0wURSBiBTuooKBGQYpiQ5S6Zb4/DAR0qe7uzM7e5xzOSVaYue/szLuX4b13BAzDgBBCCCGEEC4Ssh0AIYQQQgghRaFklRBCCCGEcBYlq4QQQgghhLMoWSWEEEIIIZxFySohhBBCCOEsSlYJIYQQQghnaRb3j8bGxky9evWUFAohhBBCCFFXd+7cecswTLWvXy82Wa1Xrx5u376tuKgIIYQQQggBIBAI4mW9TssACCGEEEIIZ1GySgghhBBCOIuSVUIIIYQQwlmUrBJCCCGEEM6iZJUQQgghhHAWJauEEEIIIYSzKFklhBBCCCGcRckqIYQQQgjhLEpWCSGEEEIIZxX7BCtC1IlEyiAsNhXRyemwMDWEbWMTaAgFbIdFWKAO5wKNkRCiKihZJQRfPtRG7r+ByJdpyMqVQE9bA63rGOHwWGv6cFMz6nAu0Bj5MUZC1AUtAyAEQFhsKiJfpiEzVwIGQGauBJEv0xAWm8p2aETJ1OFcoDESQlQJJauEAIhOTkdWrqTQa1m5EsSkpLMUEWGLrHMhI1sEJ7cZEAgEvPhycpuJjGxRoTHy4XxnGAaxsbE4ePAg/th9BJk5/BsjIeqIlgEQAsDC1BB62hrILJCk6GlroFlNQxajImyQdS4Y6Gphv+dm9Gh6gsXI5Cf00WtMO3FP5c/39PR03Lx5ExEREQgPD0dERAQqVqwIGxsbWLTpgcRPQmQX+L1DFcdICKFklRAAgG1jE7SuY4TIl2nIyBbBQFcLresYwbaxCduhESVTh3NBFccolUoRFxeXn5SGh4fj2bNnaNOmDTp06IBx48Zh7969MDU1BVB4zaqqjJEQIpuAYZgi/9HKyoq5ffu2EsMhhD15lcNObjPg77mZKofVmDqcC1wfY3p6Om7cuFHormmlSpVgY2ODDh06oEOHDmjVqhW0tbWL3AbXx0gIKUwgENxhGMbqm9cpWSWkMIFAgOKuC6I+1OFc4MIYpVIpYmNjC901ff78Odq2bZufnNrY2KBmzZrl2j4XxkgIKVlRySotAyCEEKJUHz9+LHTX9MaNGzAyMspPTCdMmIBWrVpBS0uL7VAJIRxAySohhBCFkUqlePz4caG7pi9evEDbtm3RoUMHTJw4EQcOHECNGjXYDpUQwlGUrBJCCJGbtLQ03LhxIz85vXHjBqpUqZJ/13TSpElo2bIl3TUlhJQaJauEEELKRSqV4tGjR4XumiYkJMDS0hI2NjaYPHkyvLy8UL16dbZDJYSoMEpWCSGElMqHDx++uWtqbGycf9d0ypQpaNGiBd01JYTIFSWrpFTyWsBEJ6fDwtSQWsAQXss73yt1dEXoo9e8PN9LGqNUKkVMTAzCw8Pzk9OXL1/CysoKNjY2mDp1Kg4fPgwTE+72LVWH95EQdUCtq0iJCjbXzsqVQE9bA63rGOHwWGteTvzU5ka9FdVMnk/nu6wxNq9RAaN/SMeNiAhERETg5s2bqFatWqG+pi1atICmpmrc41CH95EQvqHWVaTcwmJTEfkyLf/RjJm5EkS+TENYbCp6NKW1aIRfCp7vAqGQl+e7rDHeePoK8cHn0aOJCaZNmwYbGxtUq1aN7VDLTR3eR0LUBSWrpETRyenIKvAMcQDIypUgJiWdJn3CO7LO94wcEeau8oBttWy0bt0arVq1QrNmzYp9ehKXyRqjUFsPI9znY1p3c5aiki+atwjhD0pWSYksTA2hp62Rf2cVAPS0NdCspiGLURGiGLLOd31tTfxk3wXSxPsICgrC2rVr8c8//6BRo0Zo1aoVWrVqlZ/EGhsbsxh96ajDNa0OYyREXVCySkpk29gEresYfbP2y7YxdwsrCCmvgud7wTXas4dZQ0Non/99WVlZiI6ORlRUFCIjI3H69GlERUWhQoUK+YlrXhJrZmYGDQ0NFkdVWFFj5NM1XWjeyhFBT1PIuzESoi6owIqUSq5Yim0Xn2DNfj/MHzsE7t3Moa0pZDsshaACK5JXRR6Tko5mNUvf/YJhGLx48QJRUVH5X5GRkUhNTYWFhUWhO7AtW7ZExYoVSxWHIrpwlHeMqiRvjHt8A/ExPgZn967l3RgJ4ZOiCqwoWSUlUreqWkpWibylp6fj/v37iIyMzE9io6OjUbNmzW+WEdStWxcCgUDtunAo0sePH1G/fn1ERkaibt26bIdDCCkCJauk3EIfvca0E/e+WsOnga2ubXhZqEDJKlEGsViMJ0+e5N99zUtis7Ky0LJlS9Ro2xN39VpDxPz3Fww+X3eKNmfOHADAhg0bWI6EEFIUal1FyoVhGFy49QiZOWJA8N/dHKqqJeT7aGpqomnTpmjatClcXV3zX09NTUVUVBQ8w5MgyhQABW6i0nVXfjNmzECbNm2wZMkSVKpUie1wCCFlwM9Fh+S7JSYmYvXq1bCwsIDv3k3QFEgL/TtV1RKiGCYmJujVqxcmDLWHvk7h+wl03ZVf3bp1YWdnB09PT7ZDIYSUESWrJF9GRgaOHDmCXr16oWXLlnj+/Dn27t2LuLBTaN/QBPraGmCkUujzsHKYEK7Jq2bX1xKCkUqhp0XV7N9rzpw52Lx5M0QiEduhEELKgJJVNSeVShEWFoaff/4ZtWvXxvHjx+Hm5oakpCTs3r0bnTp1gqaGEIfHWmOraxt8vHoUW13bUJEHIQqmIRR8ue6GtUW1VzfwU70cuu6+k6WlJRo0aABfX1+2QyGElIHaJ6sSKYPQR6+xJfQJQh+9hkTKv8IaWWN88uQJFi9ejAYNGmD69Olo3rw5Hj16hLNnz8LFxQV6enqFtqEhFKBH0+r4eN0bPZpW5+UHZt5xqtTRlbfnAlEtedfdyLbVEH/9DC+vO2WbO3cu1q9fT0WUhKgQte4GoA6tYb4eo6ZACsH7eKSfXoWfhg3DqFGj0Lp161Jvj6+V8urWnouolri4OHTr1g2JiYkQCOh8/B5SqRTNmjXDzp070a1bN7bDIYQUUFQ3ALW+sxoWm4rIl2nIzJWAAZCZK0HkyzSExaayHZrcfD1GESOEoGo9eAXfwcaNG8uUqPJZweMkEAp5eS4Q1WVubg49PT3cv3+f7VBUnlAoxJw5c7B+/Xq2QyGElJJaJ6vRyenIKtA7FAAyskVwcpsBgUDAiy8nt5nIyC5cTJArFSAuNUOZh5rzZJ0LeW2CCGGbQCCAvb09zp07x3YovDBy5EjcuXMHjx49YjsUQkgpqHWyamFqCD3tws/rNtDVgr/nZjAMw4svf08PGOhqFRojtb/5lqxzgY4T4RIHBwdKVuVEV1cXU6ZMwcaNG9kOhRBSCmqdrOa3huFxS6aCYxQAvByjPKjDuUBUm62tLe7du4e0tDS2Q+GFyZMnw8/PD69fv2Y7FEJICdS6wAr4UlgTFpsKJ7cZ8PfcDNvGJrwrqMkbY0xKOprVNCzXGP87TjPh7+nB6+PE53OBqDYHBweMHTsWQ4YMYTsUXpg0aRJMTEywYsUKtkMhhKDoAiu1T1bz8LXKXR7UrVKezgXCVVu3bsW9e/ewf/9+tkPhhdjYWPz444948eIF9PX12Q6HELVH3QBIuVGlPCHckFdkRb9MyUfjxo3RoUMHeHl5sR0KIaQYlKySElGlPCHcYGZmhooVKyIyMpLtUHhj7ty52LhxIyQSScnfTAhhBSWrpERUKU8Id1ALK/nq3LkzKleujL/++ovtUAghRaBklZSIKuUJ4Q4HBwcEBgayHQZvCAQCzJkzBxs2bGA7FEJIEShZJSXSEApwcEx7uHWuj+yE+3DrXB8Hx7TnZXEVF0ikDEIfvcaW0CcIffQaEimtTyT/6dq1K+7fv48PHz6wHQpvODk54eXLl7hx4wbboRSJ5gWizjTZDoBwn0TKYMzBm4h8mQbdui3hefU5bsd/4G03ADYV7LyQlSuB3r93selYkzy6urro0qULLly4ABcXF7bD4QVNTU3MnDkTGzZsgI+PD9vhfIPmBaLu6M4qKRF1A1CegseaAehYE5lo3ar8jRs3DqGhoXj+/DnboXyD5gWi7ihZJSWibgDKQ8ealIa9vT3Onz8PqVTKdii8UbFiRbi5ucHDw4PtUL5B8wJRd5SskhJRNwDlkXWsNQVSOtakkAYNGsDIyAj37t1jOxRemT59Og4fPsy59cA1dERgRNmFXtPRFNC8QNQGJaukRNQNQHm+Pta6mgJIXj/FiU2LkZOTw3Z4hEMcHBxoKYCc1apVC3379sXu3bvZDiVfWloaVkx2RS1dMfS1NSAAoCWQIiMhGsLXj9gOjxCloGSVlEhDKMDhsdbY6toGH68exVbXNrSwX0G+Ptbbf7LE3Y3j8P7dO3Tt2hWJiYlsh0g4wt7enlpYKcCcOXOwdetW5Obmsh0KsrOzMWDAAPTs0R2Xlg/FVtc2mN2rEXaNbA/P4a3g6uICT09PtsMkROEExT22z8rKirl9+7YSw2EPPQ++dPh8nCRSBmGxqXBymwl/Tw/YNjZhNSEveKwZhsGaNWuwZcsWHD9+HF27dmUtLsINOTk5qFatGp4/f46qVauyHQ6v9OrVCyNGjMDo0aNZi0EikcDZ2RlaWlo4duwYhMJv7y3FxcWhX79+cHBwwLp166CpSQ1+iGoTCAR3GIax+vp1urNKCP5rDTPtxD1U6vwTpp24h5H7b3Cml6FAIMCCBQtw8OBBODs7Y/Pmzbz9pYGUjo6ODmxtbXHhwgW2Q+GdvIcEsHWNMQwDd3d3fPz4EV5eXjITVQBo1KgRIiIi8PDhQ/Tr1w8fP35UcqSEKAclq4RAddpz9e7dGxEREThw4ABGjhyJzMxMtkMiLKIWVophZ2cHhmEQHBzMyv5XrlyJGzdu4OTJk9DR0Sn2eytXroxz587BzMwMNjY2ePr0qZKiJER5KFklBLJbw2TkiLB69xGEh4dz6i5m/fr1cf36dQBAp06dONkXkigHtbBSDIFAgNmzZ7PyCNa9e/fCy8sLgYGBMDQsXbW/pqYmtm7dihkzZqBz5864ePGigqMkRLkoWSUEsltG6WtpokEVbYwZMwZNmjTBqlWrEB8fz1KEhenr6+Pw4cP4+eefYWNjQ38KVlP16tWDsbEx7ty5w3YovPPTTz/hwYMHuH//vtL2efr0aSxduhRBQUGoUaNGmX9+0qRJOHbsGFxdXTnV0YCQ70XJKiGQ3Z6rzQ+VseNXdzx+/BiHDh1CUlISLC0t0b17d3h5eeHz58+sxiwQCDB9+nT4+vpizJgx+OOPPzh1B5goh4ODA3UFUAAdHR24u7tj48aNStnftWvXMH78ePz5558wMzMr93a6d++Oq1evYtOmTZg+fTrEYrEcoySEHZzrBpBXkR2dnA4LU0OlVWTzucpdHrhWKa8I/41xBvw9N8scY05ODs6cOQMvLy9cvnwZ/fv3x+jRo2FrawsNDY0itlw+ZTknExMTMWTIEJiamsLLywsVK1aUayyEu0JDQ7Fo0SJERESwHQrvvH//Hg3NzLDnr2tIydaU62dSwc+6iuI0LBjdD4cPHULv3r3lEPmX/qwuLi4AAG9vbxgZGcllu4QoUlHdADiVrOZVZEe+TENWrgR6/zafV0ZPT0pWi1bwfcnIFsFAV0tp7wsbSnsupKam4vjx4/Dy8sKbN28wcuRIjBo1Ck2aNFFqHHlycnIwbdo0XLlyBQEBAWjcuLFc4iDclpOTAxMTEzx79gzGxsZsh8MrEikD6/mHkKZZGRJoyO0z6evPOqkoGw2NNBD8vwFynVPFYjHmzJmDoKAg/PXXXzA3N5fbtglRBJVoXVWwIpsBOFuRrW5UpVJe2UxMTDBjxgzcvXsXgYGBEIlE6N69O6ytrbFjxw68e/dOqfHo6Ohgz549mD17Njp37ozTp08rdf+EHTo6OujWrRuCgoLYDoV3wmJTkaFbDWJoyPUz6evPOoGWLl6JdOU+p2pqamLz5s35c0JoaKhct0+IsnAqWZVVkZ2ZK8aDxDR2AiIAgPsvPyAzp/C6p6xcCWJS0lmKiHtatGiBdevWISEhAcuXL8eVK1fQsGFDODk54fTp0xCJREqLZfz48Thz5gymTZuGxYsXQyKRlPxDRKXRo1cVIzo5Hdniwn/dkMfcJ+uzTpFz6oQJE3DixAkMHz4cO3bsUMg+CFEkTiWrsiqyBRIRNiyehXXr1iEtLY2dwNTYs2fPcGDTSgilhZMtPW0NNKtZurYq6kRTUxN9+vTB8ePHER8fD3t7e6xfvx61atXCjBkzcOfOHaUsN7G2tsatW7dw+fJl9OvXDx8+fFD4Pgl77O3tERQURL+YyJmszyR5zH2K2m5xunXrhqtXr2Lbtm1wd3enwiuiUjiVrBasyAYYCKUidGhUEye3r8T9+/fRoEEDTJ8+Hc+ePWM7VLXg4+ODDh06YGwfa9g0qgl9bQ0IAOj/u27LtrEJ2yFyWqVKleDm5oYrV64gPDwclStXxtChQ9GiRQusXbsWycnJCt1/9erVERISgsaNG8PKykqpLXiIctWpUwfVq1eHujweW1lkdQmRx9xXcLsCAExuNppW01P4nGpmZobw8HD8888/sLe3p19iiepgGKbIL0tLS0bZxBIpExLzill/7iFTu30f5uq1a/n/lpiYyCxcuJAxNjZmBg4cyFy+fJmRSqVy2e+XQ0EYhmEyMzOZiRMnMg0bNmRu377NMMx/78uW0DgmJOYVI5bI57hzkSLPBYlEwly+fJkZN24cU7lyZcbOzo45evQok5GRkf89ece6UkdXuR3rI0eOMMbGxszx48e/e1uEm+bNm8csWbKE7TB457/r0UWuc1/BOdVl1kpm7i+/yGW7pdq3WMzMmjWLMTc3Zx4/fpwfy+YQ/s/vhNsA3GZk5KOc6gbwtUOHDmHnzp24fv06BIL/KiQzMjJw6NAhbNq0CYaGhpg9ezaGDh0KLS2tcu+LugF88ejRI7i4uKB58+bYtWtXqZ+gwifKOhcyMzNx+vRpeHl54ebNmxg8eDBGjByJPXE6iEyUf+eFyMhIDB48GIMGDcKaNWugqakpp5EQLrh48SLmz5+Pmzdvsh0KLylyXnj+/DmsrKzw4sULpbad8/T0xP8WLULbOQeQkCFUehceQr6mEt0AvjZixAjk5ubC29u70OsGBgaYPHkyHj9+jGXLlsHT0xP169fHmjVr6M8a5cQwDA4cOIAuXbpgxowZOHr0qFomqsqkr6+PYcOG4fz583j48CEaN26MScu34npskkI6L7Ru3Rq3b99GdHQ0evfujTdv3shhFIQrOnXqhLi4OKSmqneXDlVUv3599OzZE/v27VPqft3c3LBo2zE8Ss2iLjyE0zidrAqFQmzatAkLFixAVlaWzH/v27cv/v77b5w5cwYxMTFo0KAB3N3d8eTJExYiVk2fPn3CyJEjsX79eoSFhWHcuHGF7mQTxTM1NcW8efMwedHvEGjpFvo3eVYJV6lSBWfPnkWHDh1gZWWFW7duyWW7hH3a2tro3r07tbBSUXPmzIGHh4fSC58EVepCqMA5hxB54HSyCgBdunSBpaUlNm/eXOz3tW7dGl5eXoiOjoaRkRE6duyIAQMGICwsjP68X4zIyEhYWlpCT08Pt27dgoWFBdshqbXmppUUXiWsoaGBVatWwcPDAw4ODti/f7/ctk3YRY9eVV3t27dHnTp14O/vr9T9stGZgJCy4nyyCgBr1qzB+vXr8fr16xK/19TUFL/99lt+26BJkybB0tIShw8fRm5urhKiVQ0Mw2D79u3o3bs3li9fjr1790JfX5/tsNTe11XCiuy8MGjQIFy+fBlr167FpEmTkJOTI/d9EOXq06cPLly4QC2sVNTcuXOxYcMGpd5gUVTHA0LkidMFVgXNmTMHnz9/xu7du8v0c1KpFOfOncOmTZvw6NEjuLu7Y+LEiahSpUqh71OnAqsPHz5g3LhxiI+Ph7e3N8zMzNgOiVPYPhfynhkek5KOZjXl9yzyoqSnp2PUqFF4/fo1/P39YWpqqrB9EcVr1aoVdu3ahQ4dOrAdCq8oY16QSqVo0qQJPD090aVLF4Xuq6C8OcfJbQb8PTcrfM4hpCgqWWBV0K+//oqAgAA8ePCgTD8nFArh6OiIkJAQBAYGIi4uDg0bNsSUKVMQFxcHiZRB6KPXqNTRFaGPXkMi5V/CmjfGLaFPsP3UJbSxtETdunVx/fr1UieqBbfB1+PEFRpCAXo0rY5p3c3Ro2l1hX9oGBoa4uTJk+jbty/atWuHK1euKHR/RLHs7e1pKYCKEgqFmDlrNpbu9lXqXJs353y87q2UOYeQslKZO6sAsG3bNvz5558ICgr6rgKgV69eYceOHdi1ezeqOa+AuFJtZIukcm0TxBUSKYOR+2/8+xxqMRhRDhpV1cb5+X1LPcaC21CH1iZs31ll07lz5zBmzBj8+uuvcHd3p0I7FXT58mXMnj2bHhAgZ8qYFyRSBsP3hiP8SQqEWrpKn2vVee4j3KDyd1YBYOLEiUhISPjuZ2DXqFEDK1aswMELt5Fb0RQ5Esi9TRBXhMWm/puoSgAIINDSRVK2VpnGWHAb1NqE3+zt7XH9+nXs3bsXo0ePltmFg3Bbhw4d8OzZM7x69YrtUEgZhcWm4n5yOgRaujTXElKASiWrWlpaWL9+PebMmQORSFTyD5Tg6dtsiJnCh4BvLTuik9ORlVu42CIjWwQntxkQCASl+nJym4mM7MLHm2/HifynYcOGCA8Ph1gsRqdOnfDixQu2QyJloKWlhR49elALKxUka76muZYQFUtWAcDR0RG1a9fG3r17v3tb6tCyQ9YYDXS14O+5udhH7Rb88vf0gIFu4aeD8e04kcIMDAxw9OhRjBw5EjY2NggJCWE7JFIG1MJKNVmYGkJLUPjP8DTXEqKCyapAIMCGDRuwfPlypKWlfde2lNkmiC3yGCO1NlFPAoEAs2bNwokTJzBy5EisXbuW1rOpiD59+iA4OFjpDebJ9+naqBokb55BRwjefiYRUh4qVWBV0Pjx42FkZIR169Z913aU3SaIDfIYozq1NqEig2+9fPkSTk5O+OGHH7DXcx/uJGchOjkdFqb8vGb4oE2bNti6dSs6d+7Mdii8oIx5ITQ0FO7TpmOLXygev/qk9M8kmvsI24oqsFLZZPXVq1do3rw5bty4gYYNG7IdjtpQh8lMHcZYHtnZ2Zjq7o6LaA7tmo2QI2Z43xlClf3vf/+DQCDAqlWr2A6FF5QxLzg4OMDJyQnjxo1T6H6KQnMfYRsvugEUVKNGDcyePRsLFixgOxRC1IKuri6GzfkNGiYNkS1mqFqZ42jdqmqJjo7G3bt3MXz4cLZDIYRzVDZZBYBZs2bh5s2b1MScECWJSf7E+w4afGFjY4P4+HikpKSwHQophY0bN8Ld3R26urpsh0II56h0sqqnp4c//vgDs2fPhlQqZTscQnhPHTpo8IWmpiZ69eqF8+fPsx0KKcGrV69w8uRJTJ48me1QCOEklU5WAWDYsGHQ0NDAsWPH2A6FEN6jzhCqhR69qhq2bduGn376CVWrVmU7FEI4SeWTVYFAgI0bN2LhwoXIzMxkOxzekkgZhD56jUodXZX2vGrCPRpCAQ6OaQ+3zvWRnXAfbp3r4+CY9lRcxVF9+vRBSEiIXB6ioq4UNfflbXf9+Wh4BkZg+oyZctkuIXykst0Avubi4oLmzZtj8eLFbIfCOxIpg5H7byDyZRoyskUw0NXidQU4VcQWTd3OBT6wtLTEpk2b0KVLF7ZDUTmKOt8LbjczVwyhVAwb8xqsX0c09xG28a4bwNdWr14NDw8PJCcnsx0K74TFpv47qUogEAqpAlyN0bmgehwcHHDu3Dm2w1BJijrfC24XEEAq1KLriJBi8CZZrV+/PsaPH093VhWAnldNACA+Ph47jv+JzJzCf1Kmc4HbaN1q+Slq7qM5lZCy4U2yCgALFy7E2bNnce/ePbZD4RWqAFdfnz59wsGDB9GtWzdYWloCaUnQ1Sw8bdC5wG3W1tZITExEUlIS26GoHEXNfTSnElI2vEpWK1WqhGXLlmHOnDm07kaOqAJcvUgkEgQHB2PkyJGoU6cOTp48CXd3dyQlJcHHYyna1qtK54IK0dDQQO/evWkpQDkoau6jOZWQMmIYpsgvS0tLRtWIRCLGwsKCOX36NNuh8IpYImVCYl4xlTq6MCExrxixRMp2SHL33xhdeT/GzSFx34wxJiaGWbBgAVO7dm2mTZs2jIeHB/P69etvtpEjkjAbLjxmTFx/YzZceMzkiCTKHAIpBy8vL2bw4MFsh6GSFDX3cWlOVYe5j6gGALcZGfkob7oBFBQUFIRp06bh4cOH0NbWZjscXuFrtag6VLkXHGNWrgR62hqwqGGAH8VROHL4EBITEzF8+HCMGjUKLVq0KHEbfD1OfJSamopGjRohNTWV5sRyUtTcx/acStc04RLedwMoyM7ODg0bNsTOnTvZDoWoCHWoci84RgZAZq4EN5+mIvDeC6xYsQIJCQlYt25dkYnq19vg63HiIxMTE5ibm+P69etsh0I4hq5pogp4mawCwPr167Fq1Sq8f/+e7VCIClCH6lxZYxRq68JxxET06dMHmpqa5doG344TX1ELKyILXdNEFfA2WbWwsMCQIUOwYsUKtkMhKkAdqnPlMUZ1OE58RS2siCx0TRNVwNtkFQCWLVuGI0eOIC4uju1QCMepQ3WuPMaoDseJr9q1a4dXr17h5cuXbIdCOISuaaIKeFlgVdDatWtx/fp1BAQEsB0KL7BdDKBIEimDsNhUOLnNgL/nZtg2NuFdgYE8xqgOx4mvhg8fjq5du2LChAlsh6Jy+FpgBdA1TbijqAIr3ier2dnZaNasGfbt24du3bqxHY7K+m8ymwl/Tw9eT2Zc+PBQNHmMUR2OE98cPXoUfn5+OHXqFNuhqBxlJat5c210cjosTA2VOtfSNU3YprbJKgD4+vri999/x+3bt6GhoVHyD5BC1K21iTpM2JSsqqe3b9+iYcOGePPmDbWwKiNlJKuy2sspc66la5qwTa1aV31tyJAh0NfXx6FDh9gORSVRaxNC+MHY2BhNmjTB1atX2Q6FyCCrvRzNtYSoSbIqEAiwadMm/Prrr/j8+TPb4agcam1CCH84ODhQVwCOepj8EZk54kKv0VxLiJokqwDQvn17dOvWDWvXrmU7FJVDrU0I4Q97e3vqt8pBYrEYpw9sg1SUXeh1mmsJUaNkFQB+//13bN++nVq3lBG1NiGEP6ysrPDmzRvEx8ezHQr5V0ZGBnr16oXr/p4wr6IFfW0NCACaawn5l1olq3Xr1sXkyZOxaNEitkNRKRpCAQ6PtcZW1zb4ePUotrq24W1xFSmZRMog9NFrVOroitBHryGRUkGGKhEKhbCzs6O7qywreB21HzQOd+7ehcemjbiwsD+2urbB7F6NaK4l5F9q0Q2goM+fP6NRo0b4888/YWX1TcEZKYE6VIvSGIumbp0h+Or48eM4ceIETp8+zXYoKkOe80LedXQv/j0ycyWAJBem2rm4+psrq9eROsx9hNvUuhtAQRUqVMDKlSsxa9YsuigJKSPqDMEPvXv3RlhYGHJyctgORS2Fxabi7ot3yBIzEAiFEGjp4qNWZbqOCCmC2iWrADBmzBh8+vQJJ0+eZDsUQlQKdYbgh6pVq8LCwgJXrlxhOxS1dDLsFrLE0kKv0XVESNHUMlnV0NDAhg0b8Msvv9CdBULKgDpD8Ie9vT21sGLBnj17ELB/K/Q0C3/80nVESNHUMlkFgB49esDCwgJbt25lOxRCVEbBzhBUrazaHBwcqMhKiRiGwZIlS7B27Vr8fXQb2tarStcRIaWkyXYAbFq3bh06de6MBj/2R+JngdKfw6ws8njWdN428irA+XicFEnWewBA5vtS1PvF5jPD8+R1hgiLTUVMSjqa1eTnNaMO2rRpg/fv3+P58+eoX78+2+HwmkgkwsSJE/Hw4UNcv34dJiYmOGxmRtcRIaWkdt0ACpJIGVjPP4wPGpUgFWgq/TnMyiCPZ02rWwW4vCtiZb0HrWpXggACRCYWfl8OjmmPMQdvfvN+FfV6ed8DqvolADB69GhYW1tjypQpbIfCeeW9Zj5//oyhQ4dCQ0MD3t7eMDAwUEB08kHzAmEbdQOQISw2FRl61SARaPL2OczyeNY0VYB/H1nvwd2ENNxJ+PDN+7Lt4hOZ71dRr9N7QL4HPXpVsV69eoWuXbuiTp06CAgI4HSiSgiXqXWyGp2cjmwRvysyZVVvZ2SL4OQ2AwKBoFRfTm4zkZEtKrQNvh0nRZL1HmTnipEt+vZ9WbPf75tjXdTr9B6Q79WrVy9cvnwZ2dnZJX8zKZPY2Fh07NgRAwYMwO7du6Gpqdar7gj5LmqdrNbUFYMRF+4GwLeKTFnV2wa6WvD33AyGYUr15e/pAQNdrULb4NtxUiRZ74GutiZ0tb59X+aPHfLNsS7qdakoG0e2rcHBgwfx6dMnxQRPeK1KlSpo2bIlLl26xHYovBIeHo6uXbvi119/xZIlSyAQ8G+5FCHKpLbJ6qNHjzBvhANq6eTyuiKzYPU2I5WWa4xUAf59Cr0HjBS6mgK0rWsEy7qVvzmm7t3MZR5rWa93bFQTc3+yx6lTp1CnTh2MHDkSISEhkEgkJUREyH/s7e2pK4AcBQQEoH///jhw4ADGjh3LdjiE8IJaFlhdvXoVTk5OWLduHYaPGMn7isy8KnIntxnw99z8Xd0A+Hyc8iiiyCDv+O3yPoOs5Cc4vesPAJB5TIs61sW9B6mpqTh+/Di8vLzw5s0bjBgxAqNHj0aTJk2UNkaimu7duwcXFxfExcWxHQqnleaa2blzJ1auXKmyj/OmeYGwragCK7VLVv39/TF58mQcOXIEvXv3ZjscpaKJqHj/JfUz4e/poZCE/MOHD2jYsCEePHiAWrVqyXXbeR48eIBDhw7h6NGjqFOnDkaNGgVXV1dUrVpVKWMkqoVhGJiamuLq1ato2LAh2+FwVnHzJ8MwWLRoEfz8/HD+/Hk0aNBAydHJB31GELZRsgpgy5YtWLt2Lc6cOYPWrVuzHY7S0URUNGW255oxYwb09PSwevVquW73a2KxGCEhITh06BACAwPRrXsPfG43BknZWmrRgoyU3tixY9G2bVu4u7uzHQpnFTV/5ubmws3NDU+ePMFff/0FY2NjFqKTD/qMIGxT69ZVUqkU8+bNw86dO3H16lW1TFRJ8ZTZnmvmzJnw9PRUeFGUpqYm+vTpg2PHjiE+Ph6Nug7E0w9iakFGvkGPXi2f9PR0ODo64uPHjwgNDVXpRJUQLuN9spqTk4Phw4cjPDwc165dQ7169dgOiXCQrPZSimoNVb9+fXTr1g379++X+7aLUqlSJdRqbgNoaBd6ndpfEeBLC6urV68iKyuL7VBURnJyMrp06QIzMzP4+/tDX1+f7ZAI4S1eJ6tpaWmwt7dHbm4ugoODUaVKFbZDIhwlq72UIttzzZ07Fx4eHhCLxQrZvizKHiNRHUZGRmjdujXCwsLYDkUlPHr0CB07doSzszN27NhBPVQJUTDeJquJiYn48ccf0bx5c/j4+EBPT4/tkAiHyaPFV1lYW1ujVq1aOHnypEK2Lwu1ICPFcXBwoBZWpXD16lXY2tpixYoV+N///kc9VAlRAl7+Ovjw4UM4OjrC3d0dc+fOpclEDvKqyKOT02Fhyr3WVd8bn4ZQgMNjrfNbfO0vZ4uvspg9Zy6W7/FFStXWaG5a6ZsWVfI+1gXHqA4tyEjZ2Nvbw8nJCVu2bGE7FE7Jux4rdXTFyn2nsPV/k3Dk8GFedZMpOMbQR69pXiCcw7tuAJcuXYKzszM2bdqEn376ie1wOKW8lZ4FK+WzciXQ+/eOHFeqyOUdnzIqYiVSBiP3ReB6bDIEWrr5MR8c0x5jDt7k7LEm/MUwDGrXro2wsDCYm5uzHQ4nfN0lBJJctKxliIAZPXlzPSqzEwohJVGLbgDe3t4YOnQojh8/TomqHBWslGcAzlWRcz0+WcJiUxGZ+BHQ0i0U87aLT1RuLIQfBAIBdQX4ytddQgRauniWJuHV9ajMTiiElBdvktWNGzdi7ty5CAkJQffu3dkOh1dkVcpnZIvg5DYDAoGA9S8nt5lf7noUkJkjRljUU2UepjIp6piu2e/3zVioYp8oCz16tTBldglhizqMkag+lU9WpVIpZs2ahX379uHatWto2bIl2yHxjqwqcgNdLfh7bgbDMKx/+Xt6wEBXq1B8mpDi4KbfYGVlha1bt+LNmzfKPGQlKuqYzh875JuxUMU+UZaePXvi2rVryMzMZDsUTlCHDhrqMEai+lQ6Wc3Ozoarqyvu3r2Lq1evom7dumyHxEvKrpQvK1lV7u3NTPDs6l/4448/cOPGDZibm2PgwIE4efIkcnJy2A65yMp8927mnD7WhN8qVaoES0tLXLx4ke1QOEEdOmhwfX4nBFDhAqsPHz5g4MCBqFGjBry8vKCrq8t2SJz3PYVD/z1Tfgb8lVApX1a5Yim2XXyC2y8+wKpeZbh3M4e25n+/i3369Al+fn7w8vJCdHQ0XFxcMGrUKLRr1y6/W8R/Y5wJf08PhY8xb39fV+Zz/VgTflu7di0SEhKwbds2tkPhhKKuUz6hOYdwRVEFViqZrCYkJMDe3h52dnZYv349hEKVvkGsNPKocufis6PL2g3gxYsXOHz4MA4dOgRNTU2MHj0aw34ajoUXkjhVEcvFY03478GDBxgwYACePXtGbf/UDM05hG286QZw//59dOrUCW5ubti4cSMlqqTM3QDq1auHxYsXIy4uDvv27cPz58/RbsAYhMelUEUsUXvNmzeHSCRCXFwc26EQQggAFUtW//77b/Ts2RMbNmzArFmz2A6HcISsatbMXDHuPi8+0RQIBOjYsSN2796NBau3gdEoXNhEFbFEHVELK0II16hMsnrs2DEMGzYMvr6+cHZ2ZjscwiGyqlmFEhFWz3dH7969sXPnTqSkpBS7jVZ1q0Bfu/AD3agilqgrevQqIYRLOJ+sMgyDtWvXYuHChfj777/RtWtXtkMiHCOrmtWmUU38c+0MJkyYgKtXr6JZs2bo2LEj1q1bh6dPv+2/qg5Vv4SUVo8ePRAeHo7Pnz+zHQohhHC7wEoikWDmzJm4dOkSAgMDUbt2bdZi4QO+FlgBJVez5ubm4uLFizh16hROnz4NY2NjDBo0CIMGDULr1q0hEAg4V/XL1WNN1EP37t0xa9Ys9OvXj+1QiJLQnEPYpjLdAPIShsiEdwg8shvSpIcIOHUSlSpVUmocfCSf1lXKaetUXqUZo1QqRUREBE6dOoVTp05BIpFg4MCBGDx4MDp27AgNDY1if15Z6IOjfPLO1ejkdFiYsv9Lh6pav349nj17hp07d7IdClESmnPUGxfmTpVIVvNaEN1L+ICsXDGEjATWDU1wxK0DfdjIQXknooKtobjS1qkoZR0jwzB48OBBfuKakpKC/v37Y9CgQejRowd0dHQUGG3x6IOj7MraxowULTo6Go6Ojnj+/Dm1sFITNOeoL67MnSrRuiqvBVGWSAoIhJAKtRCVlE7tg1hWsDUU39o6CQQCtGzZEkuXLkVkZCTCw8PRtGlT/PHHH6hevTpcXV3h7e2NT58+sR0qKYWw2FTcffGu1G3MSNGaNWsGhmHw6NEjtkMhhChAdnY2oqOjERAQAPffd+a3b+Ti3MmpZFVWCyJqH8Q+dXpfGjRogNmzZ+PKlSuIjY1Fjx494OXlhVq1asHR0RH79u3Dmzdv2A6TyPD582es3++NLLG00Ot8PVcVLa+FFXUFIER15ebmIjY2FmfOnMHGjRsxefJk9OzZEz/88AOMjIzQp08fzJgxA74h4ZAKC3fE4dLcyalkVVYLImofxD51fV+qV6+O8ePHIzAwEC9fvsSIESMQFBQEc3NzdO3aFR4eHnjx4gXbYRIAgYGBaN68OTQ+JlMLMjmiFlaEcJ9YLMbTp09x7tw5bNmyBdOmTUOfPn3QsGFDGBoawtHREdu3b8eLFy/QtGlT9OnTB126dIGRkRGqVauGyZMnw2PpXBjoFO41zqW5k5NrVlVhbaQqojWr8pGdnY2QkBCcOnUKf/75J+rUqZPfWcDCwkJu6/to/VjJXr9+jZkzZ+LmzZvYvXs3unXvoTLnqir4/PkzatasieTkZFSsWJHtcIiC0ZzDXRKJBAkJCXjy5Mk3XwkJCahZsybMzc2/+apfvz40NDQQEREBHx8f+Pr6omrVqnBxccHQoUPRqFGjL9vn+JpVTiWrAJArlmLbxSdYs98P88cOgXs3c2hrcuoGsMqSTzcA2a2h2MZWtwKxWIxr167lF2hpa2vnJ67W1tb5jwOWVWUJQGblpap0XmATwzDYv38/Fi5ciLFjx2LJkiXQ19cHwP1zVdX06tUL7u7uGDBgANuhEAWjZJVdUqkUiYmJMhPSFy9eoFq1ajIT0gYNGnxTDMwwDG7evJmfoFasWDE/QW3atKnM/XOhfaNKJKuqdAdPFfG1zypXzhuGYXD37t38xPXDhw8YOHAgBgwciIPxFRGV+DH/N9ZWtStBAAEiEwv/FntwTHuMOXiT9bFwWVxcHCZMmIDMzEzs3bsXrVq1kvl9XDxXVdHGjRsRGxuL3bt3sx0KUTC6ZhSPYRgkJyfLTEj/+ecfVK5cWWZC2rBhQ+jp6ZW47Tt37sDHxwc+Pj7Q0dGBi4sLXFxcYGFhoaQRfh+VSFZDH73GtBP3kFmgmEdfWwNbXdugR9PqSouDr/iarHL1vImLi8OpU6dw/PJDfGgyEAJt3fx/0/n3rwU5BYqB9LU14Na5PjyvPufcWLggNzcXa9euhYeHBxYvXgx3d/die+Jy8VxVRY8fP0bv3r0RHx9PLax4jq4Z+WAYBqmpqYUS0bi4ODx58gTPnj2DgYFBfhLaqFGj/P82MzODgYFBmfcVFRUFb29v+Pj4QCAQwMXFBc7OzmjZsqXKXbNFJauasr6ZLbKqzjNyRFiwZhv6N9RGhw4d0L59exgacmPBL+GG4roVsJngNWrUCPPnz4ee1RNsColDwY+A7FwxIBAUmkgyskVYs98PunVbQiD8b+kLF8bCtuvXr2P8+PGoX78+7t69i7p167Idktpo3LgxNDQ0EB0djebNm7MdDiGcwDAM3r17J/MO6ZMnT6CtrV3ozuiQIUPy//t7cxiGYfDw4cP8BFUkEsHFxQW+vr5o06aNyiWopcGpZDWv6rzwXSVN9O9iiU+Pr2P58uW4d+8e6tevjw4dOuR/NWrUKH9tIFE/ss4bLlUxyopP99+K9YJ3Vg10tTBj7JBv7qxyaSzK9vHjRyxcuBABAQHYvHkzhgwZwsuJmMsKtrCiZJWomw8fPhSZkAIolJD269cv/78rV64s91hiYmLg4+MDb29vZGZmwtnZGUePHoWVlRXv50VOJau2jU3Quo7RN9Vo/xtjDQ3hQABf/hQYFRWFiIgIBAcHY8WKFfj48SOsra3zk9f27dvT41nVSMHzpuA6z7wiJrbJOq+LWrPq3s0ct+M/fHMNcGUsynTq1ClMmzYNDg4OiI6OVsjkT0rHwcEBGzZswLx589gOhRC5S09PLzIhzc3NLZSQ2tnZwd3dHebm5qhatarCk8TY2Nj8NagfPnzA0KFDceDAAVhbW/M+QS2IU2tWgfJVo7169Qrh4eGIiIhAeHg47t69i3r16hW6+9q4cWOZd1+58CxcRZNHdTnXK9S5XgEu67wGIPNc50JFJpuSkpLg7u6OR48eYc+ePejSpUu5tqNK6++Kmoe4Mj9lZGSgRo0aSEpKomVYPKZK10xZff78GU+fPpWZkGZkZMDMzExmYZOJiYnSk8KnT5/mJ6ipqakYMmQIXFxc0KFDB97/FVklCqzkRSQS5d99DQ8PR3h4OD58+FDo7qu1tTUqVDTkRF8xRZJHpTxXqu1Lg8+TLd9JpVLs2rULS5cuxdSpU7Fw4cJv2rGUhaqcC0X1NyzYGYIL85OdnR0mTpyIwYMHK33fRDlU5ZopSlZWVpEJaVpaGho0aPBNUZO5uTlq1qzJ+l3K58+f5yeoiYmJGDJkCJydndG5c+diC0n5RiUKrORFS0sLVlZWsLKygru7O4Avd18jIiIQERGBVatW4c6dO6jVvg/E7UZC8u8jxgo+C5cvxSxhsamIfJmGzFwJBEJhucYoj20QUpyHDx9iwoQJEAqFuHTpEpo1a8Z2SEpT8PoC/puHtl18IvN1tq67vHWrlKwSNuXk5OCff/6RmZCmpqaifv36+UmolZUVhg0bBnNzc9SuXZtzdyUTEhLyE9QXL15g8ODBWLduHbp27apWCWpp8DJZlaVGjRoYOHAgBg4cCODL3dfFJ67jRMynQt/Ht8preVTKc7Xanqi+7Oxs/Pbbb9i9ezd+++03jB8/nnMfKIoWdv8ZMnO+dIfIw8XOEA4ODli/fj0YhmH9LhThN5FIhOfPn8tMSFNSUlC3bt38hLRFixYYPHgwzM3NUbduXc4neYmJifDz84O3tzeePHmCQYMGYdWqVejWrRs0NdUmJSsztT0yWlpa6GXVBH8+vcfrymt5VMpzvdqeqKawsDBMmDABrVq1QlRUFExNTdkOSWnEYjFOnz6NHTt24HG6JvR6ToUY/33IFtUZQpqbjYunDsOx3hg0aNBAqTGbm5tDR0cHDx48QMuWLZW6b8I/YrEY8fHxMhPSxMRE1KpVKz8hbdy4Mfr27Qtzc3P88MMP0NLSKnkHHJKSkpKfoMbExGDgwIFYunQpevTooXJjYYvaJqsA96vI5UEeY1SH40SU5/3795g3bx6Cg4Oxbds29O/fn+2QlCYlJQV79+7Fnj17UL9+fUydOhUDBg7CuCP3vlmbKqszhEWdajBPkqJ9+/aws7PDggUL0KJFC6XELhAI4ODggHPnzlGySkpFIpHg5cuXMhPS+Ph41KhRo9Da0d69e+c/z15bW5vt8L/L69ev4e/vDx8fH0RFRaFfv35YuHAhevXqpfJjYwMvC6zKgutV5PIgjzGqynFS9QIBPmMYBidOnMDs2bMxdOhQ/PbbbwqtLOfKucAwDK5cuYLt27fjwoULcHFxwZQpUwolfEV1gCjq9fT0dOzcuRObNm2CtbU1Fi5cCBsbG4WPJTAwEGvWrMGlS5cUvi+ifOW5ZqRSaf7jQ/Oe0pT39fz5cxgbGxf5PHtdXd2Sd6BC3rx5g5MnT8LHxwd37tyBo6MjXFxc0Lt3b96NVVHUqhtAeXDlg02R+Pq4VYD7rbXU3YsXLzBlyhQkJiZi7969sLa2Vvg+2T5XP336hCNHjmDHjh0Qi8WYMmUKRo0aJdce0FlZWdi/fz/WrVuHBg0a4H//+x969OihsDWlmZmZqFGjBl6+fKk2vay50j5MkUqaPxmGwatXr2TeIX327BkMDQ1lJqRmZmbQ19dncWSK9/79e5w6dQre3t64ceMG7O3t4ezsDHt7e+jp6bEdnsqhZLUEbH+wKQNfk1VVaq2lbsRiMbZs2YLff/8dc+bMwdy5c5W2RoutczU6Oho7duzA8ePH0b17d0ydOhW2trYKLUoSiUQ4fvw4Vq9eDQMDA/zvf//DgAEDFFKsZm9vj3HjxmHIkCFy3zbXFNVWjE9zy9fzp66WEKY6ubDJuo1nT78kpE+fPoWenl6RCWnFihXZHoZSffjwAadPn4aPjw+uXbuG3r17w9nZGY6OjrxPzhVNrVpXEfVCrbW46e7duxg/fjyMjIwQHh4Oc3NztkNSGJFIhICAAOzYsQOxsbEYP348Hjx4gFq1aill/1paWhg1ahRGjBiB06dP4/fff8eiRYuwcOFCuLq6yvUXhLwWVuqQrBbVVoxPc8vX82eOBIj/LEBDXRMMGtQ8PylVlzvpRUlPT89PUC9fvowePXpg1KhR8PHxQYUKFdgOj/fUq0cM4aXiWmsR5cvIyMC8efNgb2+P6dOnIyQkhLeJalJSEpYtW4Z69eph+/btmDx5MuLj47F8+XKlJaoFCYVCDBo0CDdv3sTmzZtx4MABmJubY8eOHcjKypLLPvKKrLj2FxZFUIe5RdYYGaEWWnV1wLBhw2BlZaW2ieqnT59w7NgxDBw4EHXq1IGvry9cXV3x8uVLnDx5Eq6urpSoKgklq0Tl5bXWKohaa7EjKCgIzZs3R0pKCh48eIDRo0fzricnwzC4ePEihg4dihYtWuDNmzcICgpCWFgYnJ2dOdGKRiAQoFevXvj7779x4sQJBAUFoUGDBlizZg3S078v0TIzM4OBgQGioqLkFC13yZpbdDQFvJpbaP4sLCMjA97e3nByckLt2rVx9OhRDB48GPHx8fjzzz8xfPhweuQwCyhZJSovr7WWvrYGGKkU+v+uK6PWWsqTmpqK4cOHY/Lkydi1axeOHDkCExN+Hf/09HRs27YNFhYWcHd3R7du3RAfH4/t27ejefPmbIdXJBsbG5w+fRoXLlzA/fv30aBBA/z666948+ZNubfp4OCAwMBAOUbJTV/PLVoCKbKTHqOpEX/uKhccowBQy/kzMzMT/v7+cHZ2hqmpKQ4cOABHR0c8f/4cZ8+exahRo2BkZMR2mOqNYZgivywtLRl18eVQ8Nv3jFEskTIhMa+YSh1dmZCYV4xYIpVjZN8vRyRhNlx4zJi4/sZsuPCYyRFJ2A6Jt/LOhc0hcUxwTAqzb/8BxsTEhJk3bx7z+fNntsPLJ69r+v79+8ykSZOYypUrM87OzkxYWBgjlXLr/C+Lp0+fMhMnTmQqV67MzJgxg0lISCjzNs6dO8d07txZAdFxz39znwsTEvOK+XXxEqZt27ZMeno626HJTd4Yt4TGcXJ+V4SsrCzm1KlTjKurK1OpUiWmZ8+ezJ49e5g3b96wHZpaA3CbkZGPUjeAf3Gxyl3eyjtGrlfbcz0+Pvm6OhqSXGimvcTxiZ1hZdmW7fAK+Z5rOjc3FydPnsSOHTvw7NkzTJw4EW5ubrx6ylZycjI2bdqEffv2YdCgQZg/fz4aNWpUqp/NyspC9erVER8fj8qVKys4Um7IO58YhsHEiRPx4sULnDlzhhq8q5CcnBxcuHABPj4+OHPmDFq3bg0XFxcMHjyYd38JUlVFdQOgZQCkRMVV23MB1+Pjk4LHmgHAaGhDq2YjfNRXfjGRIiQmJmLx4sX44YcfsGfPHsyYMQMvXrzAkiVLeJWoAoCpqSnWrVuHp0+fom7duujcuTOcnZ1x7969En9WT08PP/74I4KDg5UQKbcIBALs2LEDenp6+PnnnyGVStkOiRQjNzcXgYGBGDNmDGrWrIl169bBxsYGjx49wsWLFzFp0iRKVFUAJaukRFyviOV6fHwSnZyOzFxxoddU/VgzDIPQ0FAMHjwYrVq1wsePH/H333/j77//hpOTEycKphSpSpUqWLp0Kf755x/Y2Nigb9++cHBwwJUrV4r9ubyuAOpIU1MTJ06cQHx8PObNm8d2OOQrIpEIFy5cwLhx41CzZk2sWrUKbdq0wYMHD3D58mVMnToVNWrUYDtMUgaUrJIScb1aVFZ8uppCzsTHJzmvnoIR5RR6jUvnQlmkpaVhy5YtaNq0KWbNmgU7OzvEx8fnv6ZuKlSogNmzZ+Off/7BoEGD8PPPP+PHH38ssk1VXr9Vdb2zqKenhz///BPnz5/H+vXr2Q5H7YnFYoSGhmLChAkwNTXFkiVLYGFhgcjISFy7dg0zZsxgpZ0ckQ9KVkmJuF5t/03FLqTISYlFy2r0zAt5unXrFtbNHoPmNQxUunI4KioKEyZMQP369REeHg5PT09ERUVh4sSJ1DMRgI6ODsaPH4/Hjx9jypQpmD9/Ptq2bQsfHx9IJP/9BaNBgwYwMjJCZGQke8GyrEqVKjh//jy2bt2Kw4cPsx2O2pFIJAgLC8OUKVNQq1YtLFiwAObm5rh16xYiIiIwe/Zs1KlTh+0wiRxQgdW/qMCqeP89O3oG/D03c+752LliKbZdfII1+/0wf+wQJAbtxY3wcAQHB9Pj78qp4DPRK+MzfhnpiN27dsGxbz+ExaYiJiUdzWpy71npsp5zLhblwt/fHzt27EB8fHx+wRT9KbBkDMPg7Nmz+P333/H27VvMnz8fI0eOhLa2NmbOmoXMSvXR/Ed7WJhy71yQp+Lmz5iYGHTr1g1eXl7o06ePkiNTL1KpFNeuXYOPjw/8/PxQs2ZNODs7Y+jQoWjYsCHb4ZHvVFSBFSWr/6JkVXnbkDeZ3QBqG0FwaTs+pX/EyZMnoalJd1nL4uuqf0aUjXqGAoT+OojTycjX54K+tiYMxe8Rf3AuWjRvjilTpqBfv350PpQDwzC4fPkyfv/9d8TExGD2nLk4l90QT96JAE1t6P17l52vXThKmvuuXbuGgQMHIjAwEO3atVNiZPwnlUoREREBHx8f+Pr6wtjYOD9BLW0HC6IaqBsA4S2Z3QAS0zBq/mrk5ORg0qRJnEuwue7rqn9o6SJVos/5DgtfnwtZYineMhWw5vBZBAcHY9CgQZSolpNAIEDXrl0RFBSEgIAAnL33HLFvc8BoaoMB1L4LR6dOnbBv3z70798fT548YTsclccwDG7evIk5c+agXr16GD9+PKpUqYKQkBBERUVh0aJFlKiqEUpWicorqhtA3JsvTyWJiorCkiVLWIpONalqhwVZcUsFmkgXVmQpIn6ytLRE/1FTIdTSLfS6KpwjitS/f3+sXLkSdnZ2ePXqFdvhqByGYXDnzh388ssvqF+/PkaOHAkDAwOcO3cO0dHRWLJkiVoWPxKAbjEQlZfXDSCzQJKSV6FeoUIFnD17Fp07d0bNmjUxZcoUFiNVHU1rVoRAKgIj/K9tkypU/Rd3LhD5omMtm5ubG1JSUmBvb49Lly7Rc+RLwDAMoqKi4OPjAx8fHwCAi4sL/vzzT7Ro0QICAf+WlJCyo2SVqLy8bgB56yv1vqpQNzExwfnz5/Hjjz/CxMQEQ4YMYTlibmMYBn/t/gNauY2gYdJQ5jHlqpLOBSI/dKyL9uuvv+LVq1cYNGgQAgMDoaOjw3ZInMIwDB4+fJifoIpEIjg7O8PHxwdt2rShBJV8gwqs/sXFwiF5k083gP8qrLlURJEXX3EV6vfu3UPv3r3h6+sLW1tbdgJVAatXr8axY8dwMewSIl/ncrbqvyilOReIfKjTsS7r/CmRSODi4gINDQ0cOXoMl5+8RXRyOu+7JhTn0aNH8Pb2ho+PDzIyMuDs7AxnZ2dYWVlRgkoAUDeAElGyWjSZ1fYqWvX7999/w9XVFSEhIWjZsiXb4XDOwYMHsWzZMly/fp13jxcl5HuUZ/7Mzs5Gb7s+yGw/Fpn6JoXuQKvi/FkecXFx+Qnqhw8f8hNUa2trSlDJN6gbACk3mdX2Klr12717d2zduhUODg548eIF2+FwytmzZ7FgwQKcP3+eElVC5EBXVxdzN+zHW1TI76yhyvNnaT19+hR//PEHWrduDVtbW7x58wa7du1CQkICNm7cCBsbG0pUSZnQmlVSouIqw3s0rc5SVOXn4uKC169fw87ODteuXYOxsTHbIbEuIiICY8aMwV9//YUmTZqwHQ4hvPHiowQCTR0UvCeryvNnUZ4/fw5fX194e3sjKSkJTk5O2LJlCzp16gQNDY2SN0BIMShZJSXiY9Xv9OnTkZKSAkdHR/z9998wMDBgOyTWPH78GAMHDsTBgwdhY2PDdjiE8Aof5888CQkJ8PX1hY+PD54/f47Bgwdj3bp16Nq1KyWoRK5oGQApUV7Vr762BhipVCWfBy/L77//jmbNmmHo0KEQiURsh8OKpKQk9OnTB6tXr4ajoyPb4RDCOwXnTwEARpSNBoYClZ0/k5KS4OHhgY4dO6Jt27Z4/PgxfvvtNyQnJ2PXrl3o3r07JapE7qjA6l9UYFW8/7oBzIC/52beVLOKRCIMHDgQ1apVw4EDB9RqHVVaWhq6dOmCYcOGYeHChWyHQwinyWP+jElJR0ZSHDx+cUPYxYsqs+QmJSUFfn5+8PHxQUxMDAYMGABnZ2f06NEDWlpaJW+AkFKibgAloGRVedvgmoyMDPTo0QNdu3VD71Ezed1eJu9DMyrhPY7vXAebuhWwZfNmtUrSCSkLRbTty+u6ce3aNdSqVUtOkZZf3hgLzn1v36Ti5MmT8Pb2RlRUFPr16wcXFxf06tUL2trabIdMeIqS1RLwMQn7GiWrRXud+gY2C49As7oZxIyQl+1lCrYgy8wRQ8iIYWNWA4fH8WeMhMiTItv2rV69GkePHsWVK1dgZGQkn4DLoeAYs3Il0BRIoZn2EinHF8HRwQEuLi7o3bs3dHV1S94YId+JWlcRUoyH76TQNW0MESPkbXuZgi3IIBBAKtRCZCK/xkiIPCmybd/8+fPRvXt3DBgwANnZ2XKItnzCYlNxL+FDfmstESOEpHJdHAu7j6NHj6J///6UqBLWUbJKCL6058oWF75jnNdehi+Ka0FGCPmWIq8ZgUCATZs2oUaNGhg+fDgkEknJP6QAkQnvkJUrLvSaSCrAs3fsJdCEfI2SVULwpb2MkCk8YfOlvUyevBY6BfFtjITIk6KvGaFQiEOHDiEtLQ3Tpk1T+hIrsViMs4d3QcgUTpRpXiBcQ8kqIQDqan1GTlIs9LSEEAC8ac9VEF9bkBGiKMq4ZnR0dHDq1CmEh4fjt99+k9t2S8IwDKZOnQrh68ewbmiS31qL5gXCRWr/UIC8KshKHV0R+ug1ryvAv2eMfD9Oy5YuwTjzRuji0hYxKeloVpN/3QA0hAIcHmud34JsP49akBGiCMq6ZgwNDXHu3Dl07NgRNWrUwPjx4+W6fVlWrFiBW7duISwsDAYVKua31uLj3EdUn1p3A1BkpSdXyGOMfD9Od+/ehaOjI+Li4lCxYkW2w1EKvnZ1IERRlHHNPHnyBF26dMGuXbswYMAAhe1n9+7dWLt2La5fv47q1fnzyFei+qgbgAyKrPTkCnmMke/HacGCBVi8eLHaJKqEEG4yNzfHX3/9hfHjx+PatWsK2UdAQACWL1+OoKAgSlSJylDrZFUdqqPlMUY+H6fg4GA8f/5cKX92I4SQklhZWeHIkSMYPHgwoqOj5brtK1euYMKECfjrr79gZmYm120TokhqnayqQ3W0PMbI1+MklUoxf/58/P777/TIQEIIZ/Tu3RsbNmyAvb09Xr58KZdtPnz4EEOGDMHRo0dhaWkpl20SoixqnayqQ3V0wTEKADCibDSoJCzTGPl6nE6cOAFNTU0MGTKE7VAIIaSQESNGYPr06bCzs8P79++/a1sJCQmwt7eHh4cHevXqJacICVEetS6wAgo+93kG/HlaHZ03xpiUdLx9GgnvTUtx7+4d6OnplXkbfDlOOTk5aNq0Kfbv3w9bW1u2w1E6KrAipGzYumbmzJmDGzduIDg4uExzdp53796hc+fOmDBhAmbNmqWACAmRn6IKrNQ+Wc2jLh/eDMPAxcUFdevWxfr168v883w5Tps3b0ZQUBACAwPZDoUVfHkfCVEWtq4ZqVSKUaNG4dOnT/D394emZuk7TmZmZqJnz57o1KkT1q1bp8AoCZEPSlZLoE4f3m/fvkXLli3h4+ODzp07l+ln+XCcPn78iEaNGiE4OBgtW7ZkOxxW8OF9JESZ2LxmcnNz0a9fP9StWxd79uyBQFDyX7XEYjEGDRoEIyMjeHl5QShU61V/REVQ6yqSz9jYGDt27MDPP/+MjIwMtsNRunXr1sHe3l5tE1VCiGrR1taGn58f7t27h6VLl5b4/QzDYOLEiRCJRNi/fz8lqkTl0RmspgYOHAgbGxssWLCA7VCUKiUlBTt37sSKFSvYDoUQQkqtYsWKCAwMxPHjx7Fz585iv3fx4sV48OAB/Pz8qNMJ4QW1f9yqOtuyZQtatGiBQYMGoXv37myHoxTLli3D2LFjUbduXbZDIYSQMjExMUFQUBB+/PFHmJiYwMnJ6Zvv2bZtG3x8fHDt2jVUqFCBhSgJkT9KVtVY5cqVsXfvXowdOxb379+HoaFq900tyePHj3Hy5EnExsayHQohhJRLgwYNcObMGdjZ2cHY2Bhdu3bN/zdfX1/88ccfuHr1KqpVq8ZilITIFy0DUHP29vbo2bMn5syZU+z3SaQMQh+9RqWOrgh99BoSqeoV5/zvf//DvHnzUKVKFbZDKZe892BL6BOVfQ8IId+vTZs2OHbsGIY6O2PfuRvYEvoEHj4hmOrujrNnz6J+/fpsh0iIXFE3gH+pc3V0eno6WrZsiZ07d8Le3v6bf5dIGYzcfwORL9OQkS2Cga4WWtcxwuGx1irTazU8PBzOzs6Ii4srV69CthV8D7JyJdD798EM5X0P1Pl8J6Q8uHbNSKQMev/xJ55+EEOgpQtGlI1mJvo4M7ePyszLhHyNugGQIhkaGmL//v2YMGECPnz48M2/h8WmIvJlGjJzJRAIhcjMlSDyZRrCYlNZiLbsGIbBL7/8ghUrVqhkogoUfg8YQOXeA0KIfIXFpiIlVwcCLV0AgEBLF/EZApoTCC9RskoAAN27d8eAAQMwY8aMb/4tOjkdWbmSQq9l5UoQk5KurPC+y5kzZ/DhwweMGjWK7VDKTdZ7kJkjwv5TF/D27VuWoiKEsEXV52VCyoKSVZJvzZo1uH79Ok6fPl3odQtTQ+hpaxR6TU9bA81qcr8gSywWY8GCBVi9ejU0NDRK/gGOsjA1hJARF3pNR0OI98/uw8zMDIMGDcKpU6eQm5vLUoSEEGVS5XmZkLKiZJXkMzAwwMGDBzF58uRCd+tsG5ugdR0j6GtrgJFKof/veknbxiYsRls6hw4dQtWqVeHo6Mh2KN+lWWUgO+kx9LSEEADQ19aAZf2qOLN3LRISEtCvXz94eHigVq1amDZtGm7dusWp9XWEEPkqOC/nzQmqMi8TUlZUYPUvri2eZ9OcOXOQmJgIb2/v/NckUgZhsalwcpsBf8/NsG1swvlF/JmZmWjcuDF8fX1hY2NT4vfnjTE6OR0WpoacGuOyZcuQnJICl5krEJOSjmY1Zcf3zz//4MiRIzh06BC0tbUxevRoDB8+HLVr1wZQ8H2cCX9PD06NkRB5k8c1zeVrJi+24uYEQlRJUQVWlKz+i5LV/2RlZaFt27ZYtmwZXFxcCv2bKh2nNWvW4NatW/Dz8yvxe+VdbS9PWVlZ+OGHH3D58mU0adKkVD/DMAyuX78OLy8v+Pn5wcrKCiNHjcaZjHp4kPxJZbs6EFJa8rim+dAJhRBVQt0ASKnp6enh4MGDmD59Ol69esV2OOXy7t07rF+/HqtWrSrV94fFpiIygZvV9ocOHYKNjU2pE1Xgyy8VnTp1wp49e5CUlIRx48Zhz19XERGXorJdHQgpC3l00FD1TiiE8AUlq0Qma2truLm5YeLEiSpzJ7WgP/74A0OGDEHjxo2L/T6GYXD16lX8vuswMnJEhf4tI0eERet3YfXq1bh06RIyMjIUGbJMUqkUGzduLPGhDcXR09ODi4sLhk6YDaF24dZdVD1M+EpWtXxGtghObjMgEAhK9eXkNhMZ2YXnBbpmCFE+SlZJkZYsWYLnz5/j8OHDbIdSJvHx8Thw4ACWLFlS5Pc8f/4cy5cvh5mZGSZMmIBG1fShr1P46cP6WproY22BV69eYf78+TAxMYGlpSXc3d1x5MgRPHv2TOGJ/JkzZ1CxYkV06dLlu7dF1cNEncg63w10teDvuRkMw5Tqy9/TAwa6WoW2QdcMIcqnWfK3EHWlo6ODQ4cOoXfv3ujevXt+kQ7XLVmyBFOnTkXNmjULvZ6eng5fX18cOnQIMTExcHV1hbe3NywtLSFlIHN92+KxfaAhHAIAyM7Oxt27dxEeHo6AgADMnz8fYrEYNjY26NChA2xsbNCuXTsYGBjIbSwbNmzA3LlzIRB8//q4vOrhr8dI1cOEjwqe7wXXm5blfKdrhhBuoAKrf6lS4ZCyrVixAteuh2PepgMY4jaLcxWxwH9VsaF343Bw00pEh/iislElSCQShISEwMvLC4GBgejWrRtGjx4NBwcHaGtry9xGWSprX758ifDw8PyvBw8eoHHjxvnJa4cOHdCwYUOZyWZRlcp5r1+49Qgndq5D3KUA6Ghrydh7+Y8TVQ8TdSCPLiZ0zRCiPNQNoASUrBYtOycXLabtAozrI1cCzlXEFqzYzcwRQUsINKuuD/OkIBw/ehSmpqYYPXo0XF1dYWxsrNBYsrOzce/evfzkNSIiAjk5ObCxsclPXtu1awc9fQOZd3IPjmmPMQdv/jsWMbQEDNo1rMaZY02IKqL5nRDVUFSySssASImu/fMBGtXNkC1mIBAWrqrt0bQ62+EVqtiFQAgRA0S+TIOhpjGCg4PRrFkzpcWiq6uLDh06oEOHDvmvJSYm5ievixYtQlRUFOp16ofstsMgEXy5BPOO6baLTwqMRQARBJw61oQQQoiyUYEVKVF0cjpyxIXvSnCpIlZW1a9QSxftew9SaqJalNq1a2Po0KHYuHEjrl+/jvfv38Nh+ARIBIWLPzKyRViz34+qjwkhhJACKFklJeJ6FTnX4/uajo4O+rS3gL524T9sGOhqYf7YIVR9TAghhBRAySopEdefQc31+GQpKmb3buYqNxZCCCFEkajA6l+0AL94XK+I5Xp8shQVsyqOhRAuo/mdENVA3QBKQJMZIYTwE83vhKiGopJVWgZACCGEEEI4i5JVQgghhBDCWZSsEkIIIYQQzqJklRBCCCGEcBYlq4QQQgghhLM4l6xKpAxCH73GltAnCH30GhKpYis48/ZXqaOrUvbHBnkcU2W/L4QQ8r3UYX4nRB1wqnWVRMpg5P4biHyZhqxcCfT+bYh+eKy1QvpMFtxfRrYIBrpaCt0fG+RxTJX9vhBCyPdSh/mdEL5RidZVYbGpiHyZhsxcCRgAmbkSRL5MQ1hsqsL3JxAKFb4/NsjjmCr7fSGEkO+lDvM7IeqCU8lqdHI6snIlhV7LyBbByW0GBAKB3L+c3GYiI1tUaH9ZuRLEpKQrc9gK9TD5IzJzxYVeK+sxVYfjRAjhF1mfJzRvEaKaOJWsWpgaQk9bo9BrBrpa8PfcDIZh5P7l7+kBA12tQvvT09ZAs5qGyhy2wmRnZ+OC9z5AnFvo9bIeU74fJ0II/8j6PKF5ixDVxKlk1baxCVrXMYK+tgYEAASSXOh+foWujaopZX/6/67FtG1sopD9KdOrV6/QrVs36Ke9gI1Zje8aY8HjxEilvDpOhBB+onmLEP7gVIEV8GVRfFhsKmJS0lHfSAtLxg9B/359sWzZMoXvr1lNQ9g2NlH5xfeRkZEYMGAAfv75ZyxZsgQMBN89xrzj5OQ2A/6em3lxnAjhurzrLjo5HRam/JiflEke8xa9B4QoT1EFVpxLVr/2+vVrdOrUCXPnzsWkSZNYjUUVnDx5EhMnTsT27dvh7Ows9+0LBAIUd84QQuSDunDIT3nnLXoPCFEulegGIEv16tURFBSEFStW4NSpU2yHw1kMw2DVqlWYPn06zp07p5BElRCiPNSFg330HhDCDZxPVgGgYcOGOHPmDCZOnIjLly+zHQ7nZGVlYcSIEQgICMCNGzdgZfXNLyWEEBUTnZz+TScPqmZXnoSEBOw48Rcyc77thBKdTO8BIcqkEskqALRt2xbHjh3D0KFD8eDBA7bD4YyUlBTY2tpCIpHg0qVLqFWrFtshEUK+U3Z2Nq7+dRwQ5RR6narZFevz58/w8vJC9+7d0bZtW+BDInQ1C39MMqJsbF+1EGvWrEFSUhJLkRKiXlQmWQWAnj17YvPmzXBwcEB8fDzb4bDu7t27sLa2Rt++fXH8+HHo6+uzHRIh5DvFxcWhQ4cOkCQ+QHuz6oW7o2QorjuKupJIJAgNDcWoUaNQu3Zt+Pv7Y+rUqUhKSoKPx1K0rVe1UDeVjk1qYe/yGXj69ClatGgBOzs7HD16FJmZmWwPhRDe4nyBlSweHh7YvXs3rl69iqpVq7IdDiv8/f0xadIk7Ny5E0OGDFHafqnAihDFOXLkCGbNmoUVK1Zg0qRJkDLI7+RRr5ImlowfgoED+mPp0qVsh6pSZM1bjx8/xqFDh3D48GFUq1YNo0ePxrBhw2BiUri1VXEdY7KysnD69Gl4eXkhIiICgwcPxqhRo/Djjz9CKFSpe0GEcEJRBVbFNoO3tLRkuOqXX35hbGxsmIyMDLZDUSqpVMosX76cqVOnDnPnzh2l7VcskTIhMa+YSh1dmZCYV4xYIlXavksjL77NIXGcjI+Q4nz+/Jn5+eefmUaNGjGRkZFFft+rV6+YBg0aMLt27VJidKrr63nrdeobZvv27Uz79u2ZmjVrMnPnzmXu378vl30lJycz69atY5o3b87Uq1ePWbx4MfPkyRO5bJsQdQHgNiMjH1XJO6sAIJVKMWbMGHz48AGnTp2CpqYm2yEpXFZWFsaOHYt//vkHAQEBqFmzplL2W7B9S0a2CAa6Wpxq30LtZYgqe/DgAVxcXNCuXTts374dFSpUKPb7nz59ii5dumDHjh0YOHCgcoJUQV/PWxqQICc5Fj+KozBm9Cj07NlTIZ8bDMMgMjISXl5eOH78OMzMzDB69Gg4OzvDyMhI7vsjhE9UtnVVUYRCIfbt2wexWIyJEyfy/k/TycnJ6Nq1KwQCAcLCwpSWqAKF27cIhELOtW+h9jJEFTEMgz179qB79+5YsGABvLy8SkxUAcDMzAx//fUXJkyYgCtXrighUtX09bwlFWrBsH5LjF+yCX369FHYDQ6BQIA2bdrAw8MDiYmJWLBgAS5cuIB69erB1dUVgYGBEIvFJW+IEJJPZZNVANDS0oKvry8ePHiAX3/9le1wFOb27duwtrbGgAEDcPToUejp6Sl1/9HJ6cjKlRR6LSNbBCe3GRAIBKx/ObnNREb2t+1lqMUP4aqPHz/C1dUV27dvx5UrVzBq1Kgy/bylpSWOHj2KIUOG4OHDhwqKUrXJmreyRVKlzgtaWlro168f/Pz88M8//6Br165YuXIl6tSpgzlz5uD+/ftKi4UQVabSySoAVKhQAWfPnoWfnx+2bt3Kdjhy5+PjA3t7e2zevBmLFi2CQKD8P2tbmBpCT1uj0GsGulrw99xc7JpnZX35e3rAQFerUHzU4odw1a1bt9C2bVtUrVoVERERaNKkSbm206tXL3h4eMDe3h4JCQlyjlL1yZq32JwXqlSpgsmTJyM8PBxhYWHQ1dVF37590aZNG2zatAmvX79mJS5CVIHKJ6sAUK1aNZw/fx5r1qyBr68v2+HIhVQqxbJlyzBv3jwEBwdj8ODBrMVi29gEresYFWrf0rqOEWwbm5T4s8pQMD5GKuVcfIQAX/7sv2nTJjg6OmLNmjXYsWPHd/+VZNiwYZg9ezb69OmD9+/fyylSfuDyvNW4cWOsWrUKL168wIYNGxAVFYUmTZqgb9++8PX1RXZ2NtshEsIpKltgJUtUVBR69eoFb29vdOvWje1w8lueRCenw8L0v5Ynsl4HkP+aWVUdHPh9HhJfJsDP/yQefxR+sw22xiKrfQsX5MXn5DYD/p6bORcfUW/v3r3DmDFjkJqaihMnTqB+/fpy3f68efNw7do1hISEUL/lArg8b339OWBVSx+nA07hoNchPHzPoGVXBwzqaoWJ/X+EpoawyM8TQvikqAIrXiWrAHDx4kW4uLggODgYrVq1Yi2OoirUD45pjzEHbxZ6vVXtShBAgMjEL68x4hxUEn/AlZXDMOnEfapyLwPqA0u45sqVKxg+fDhcXFywatUqaGtry30fUqkUo0ePRlpamtp0R1FlJX0+3Iv/gCyxBBDlQvAhHqN/yMD9Kp3x+E02fRYQXuNdN4CidOvWDdu3b4eDgwOeP3/OWhxFVahvu/jkm9fvJqThTsKH/NegqQORYS14hr+kKndCVJREIsFvv/2GoUOHYteuXVi3bp1CElXgS3eU/fv3QyQSqUV3FFVX0udDllgKQABo6UC7ZiNc+WCAOy/e0WcBUVu8S1YBYOjQoVi4cCHs7Ozw5s0bVmIoqoJ+zX6/byrXs3PFyBaV7nupyp0Q7ktJSUHv3r0REhKCO3fuwMHBQeH71NLSgp+fHx48eIDFixcrfH+k/Mry+ZArAapbdIBQS7fQ6/RZQNQJL5NVAHB3d8fQoUPh6OiIz58/K33/sipRtTWAakgHJLmFXtfV1oSu1rfV9vPHDqEqd0JUTFBQECwtLfHjjz8iNDQUtWrVUtq+87qj+Pj4YNu2bUrbLymbxib633wOFDfnW/1Q+ZvPE10tIX0WELXB22QVAH777Te0aNECQ4cOhUgkKvkH5EhWJWq7BtVw9/AfaFO3MjQhAcNIAXEOjPEJzWsYfFO16t7NnLPVrISQwkQiERYuXIhx48bh6NGjWLZsGTQ0NEr+QTmrVq0agoKC8Mcff8DPz0/p+yfFk0qlOPjHLzDIflPsnM9IpdDTEsr8LNBgxJCm/gPruhXZHg4hSsG7AquvicViDBo0CFWqVMHBgweV2qe0qErU/6o6P0L6LgGR547i9OnTaNHbFU079sJA23bo3bxWoe/lYjUrl/zXDWAm/D096DgRpYqPj8ewYcNQqVIleHl5wcSE/V8oIyMj0bt3b/j4+MDW1pbtcAi+tC+bM2cObt26hXPng3Aj4VORnw/Tl67F5GH9MHlA128+C5rUqIh9K2cjJzsLfn5+rPxSRIgiqE03AFkyMzPRs2dP/Pjjj1izZg3b4ciUkZGBU6dOwcvLC3fv3sWQIUMwatQodOzYkZUHAaiSr58BbqCrRZWyRGkCAgIwceJEzJ07F3PmzIFQyJ0/WHGlOwr5Yv369Th48CCuXLmCypUrF/u9bm5usLS0xOTJk2X+e05ODhwdHWFmZoadO3fS5wThBbXpBiCLvr4+/vrrL/z555/w8PBgOxyZDAwMMGLECAQHByMyMhL169eHm5sbGjVqhJUrV+LFixdsh8hZXz8DnCpliTLk5ORg+vTpmDVrFk6fPo158+ZxKlEFvnRH2bZtGxwdHWkOYdnhw4exdetWnDt3rsREFQBatmxZ7ONYdXR0cPLkSdy8eRMrVqyQZ6iEcA63ZlYFqlq1KoKCgrBhwwYcP36c7XCKVadOHSxYsAAxMTE4duwYXr9+DSsrK9ja2uLAgQP49OkT2yFyiqzKWqqUJYr05MkTdOjQAUlJSbh79y5sbGzYDqlIzs7OmD9/PqvdUdTd+fPnMXfuXJw7dw516tQp1c+0atWq2GQVAAwNDREYGIhDhw5h9+7d8giVEE5Sm2QVAOrWrYvAwEDMnDkTwcHBbIdTIoFAgHbt2mHbtm1ISkrCjBkzcPr0adSpUyf/LqxEIil5Qzwnq/OCNDcbV/46gcTERJaiInx17NgxdOzYEW5ubvDz8yvVXTK2TZs2DU5OTujbty8yMjLYDket3Lp1CyNHjsSpU6fQrFmzUv9cixYt8ODBA0il0mK/r0aNGggKCsKyZcsQEBDwndESwk1qlawCXyYAX19fDB8+HHfv3mU7nFLT0dHBoEGDEBAQgCdPnsDa2hoLFy7EDz/8kH8XVl3J7LzQsBrqaHxEy5YtMWXKFCQkJLAdJlFxGRkZGDduHJYvX47g4GBMmTJFpdYJrlq1ChYWFqx0R1FXcXFx6N+/P/bt24eOHTuW6WerVKmCSpUqIT4+vsTvNTMzw19//YXx48fj6tWr5Q2XEM5Su2QVALp06YLdu3ejb9++ePbsGdvhlFm1atUwbdo03L59G0FBQWAYBr169UK7du2wdetWvH37lu0QlUpDKMDhsdbY6toGs3s1wlbXNvCe9CM2rF+Px48fw9DQEG3atMHEiRNp3R4pl4cPH6Jdu3YQiUS4c+cOWrduzXZIZSYQCLBnzx4IhUK4ubnRU64ULCUlBX369MHKlSvRv3//cm2jpHWrBVlZWeHo0aNwcnLCw4cPy7U/QrhKLZNVABg0aBCWLl2K3nZ94B8eiy2hTxD66DUkUtWawC0sLLBmzRokJCTgt99+Q0REBMzMzDBo0CCcOnUKubm5kEgZhD56rbJjLA0NoQA9mlbHtO7m6NG0en4XABMTE6xevRqxsbGoVq0aLC0tMW7cOJX8JYUoH8Mw2Lt3L7p164b58+fj0KFDqFChAtthlZumpiZ8fHwQFxeHhQsXsh0Ob338+BH29vYYO3Ys3Nzcyr2dli1bIioqqtTf37t3b2zcuBEODg701yTCK2rRuqooEimDzr+eQIpIBwJNHej925hZ1Vsepaenw8/PD15eXoh59Ag/jF6HzzrGyJGAN2Msr/fv32Pz5s3Yvn07HB0dsWjRIjRq1IjtsAgHpaenY8KECYiJiYG3tzeaNm3Kdkhy8+7dO3Tu3BmTJk3CjBkz2A6HV3JycuDg4ICmTZti69at37VU5Pjx4/D39y/zwx02btwIT09PXL16FVWqVCn3/glRNrVuXVWUsNhUfNSqDGjqgAF40/LI0NAQY8eOxaVLl+DhHYw0zcrIloBXYyyvKlWqYPny5Xj69CnMzMzQqVMnjBgxAo8ePWI7NMIht2/fRtu2bVG5cmXcuHGDV4kq8KU7yvnz57F+/XqcOHGC7XB4QyqVYtSoUahcuTI2b9783Wuay7IMoKDZs2fD0dERffv2RWZm5nfFQAgXqHWyqg4tj95K9SBmCr/NfBtjeRgZGWHx4sV49uwZLCws0LVrV7i6utJaLzXHMAw2bdoEBwcH/PHHH9i5cyf09PTYDkshfvjhBwQGBmL69OkICQlhOxyVxzAMZs6cidevX+PIkSNyeapU48aNkZiYWK4ODmvWrEGDBg3g6uoKsVj83bEQwia1TlYtTA2hq1n4N189bQ00q2nIUkTydz/sLCDJLfQa38b4PQwNDbFw4UI8e/YMbdu2Rc+ePTF06NAyrRMj/PDu3TsMGDAAx48fR0REBIYOHcp2SArXokUL+Pn54aefflKp7ihctHr1aoSFhSEgIAC6urpy2aampiaaNGmC6OjoMv+sUCjE/v37kZOTg0mTJlFBHVFpap2s2jY2QRV8ggYjzm951LqOEWwbs/9cb3nYtWsXLp3YiXb1jQu1deLTGOWlYsWK+OWXX/Ds2TN06NABffr0waBBg+gDXE1cvXoVbdq0QaNGjXD16lU0aNCA7ZCUpkuXLti1a5fKdkfhggMHDmDPnj04f/48jIyM5Lrt8i4FAABtbW34+/sjKioKS5YskWtchCiTJtsBsElDKEBW4DpM/eUPaFWrh2Y1DWHb2IQXhUenTp3CypUrcfnyZdSr3wBhsamISUnn1RgVwcDAALNnz8bkyZOxd+9e9OvXD23btsWSJUvQrl07tsMjciaRSLB69Wps3boV+/btg6OjI9shsWLw4MFITU2FnZ0drl+/DhMT+mW2tM6ePYuFCxfi0qVLMDU1lfv2vydZBYAKFSrg7Nmz6Ny5M2rWrIkpU6bIMTpClIRhmCK/LC0tGT578uQJU716dUYsFrMdilxdunSJqVatGnPnzh22Q1F5WVlZzLZt25jatWsz9vb2zPXr19kOichJSkoK06NHD6ZLly7My5cv2Q6HE5YsWcJYWloy6enpbIeiEsLDw5lq1aoxERERCttHcHAw06VLl+/ezrNnzxhTU1PG19dXDlERohgAbjMy8lG1Xgbg4+MDJycnuSyE54oHDx5g6NChOHbsGNq2bct2OCpPV1cXU6dOxdOnTzFgwAAMGzYMvXv3pqfEqLjg4GC0bdsWnTp1QmhoKGrXrs12SJywbNkyWFpawsnJCbm5uSX/gBp7/PgxBg4cCC8vL1hbWytsP3l3VpnvXHPaoEEDnDlzBlOmTEFYWJh8giNESdQ+WXVxcWE7DLmJj4+Hg4MDNm/ejJ49e7IdDq/o6Ohg4sSJiIuLg4uLC0aNGoXu3bvTpK9iRCIR/ve//+Hnn3/G0aNHsXz5cmhqqvVqqEIEAgG2b98OfX19/PzzzyU+l15dJSUloU+fPlizZg3s7e0Vui8TExPo6uoiMTHxu7fVpk0bnDhxAi4uLt+1tIAQZVPbZDU2NhZv3rxB586d2Q5FLt69e4c+ffpgzpw5cHV1ZTsc3tLW1sa4ceMQGxuLUaNGYfz48ejatStCQ0Op2pbjEhISYGtri7t37+Lu3bvo1q0b2yFxkqamJo4fP474+HjMmzeP7XA4Jy0tDX369MHkyZMxevRopezze9etFtS9e3ds3boVDg4O9PhpojLUNln19vbGkCFDIBSq/iHIzMxE37590b9/f8ycOZPtcNSClpYWxowZg0ePHmH8+PGYOnUqOnfujKCgIEpaOej06dNo164dBgwYgMDAQCogKoGenh7+/PPP/AcHkC+ys7MxYMAAdO/eHb/88ovS9ivPZBUAnJ2d8csvv8DOzg5v376V23YJURS1/fuXj48P9uzZw3YY300sFsPFxQWNGjXC6tWr2Q5H7WhqamLEiBEYNmwYfH19MXv2bFSsWBFLliyBvb39dz/BhpSdRMogLDYV0cnpaFRND4H71uHP06cREBCADh06sB2eyqhSpQrOnz+Pzp07w6R6DdSy6oXo5HRYmKpXR5G88+lBUhr+OrQTNWqaYtOmTUq9tlu2bInAwEC5bnP69OlISUmBo6MjgkNCcSsxQy3fX6IaBMXdBbKysmJu376txHCUIzo6Gn369EF8fLxK31llGAZubm5ISUnB6dOnoaWlxXZIak8qlcLf3x8rV66EtrY2lixZgn79+lHSqiQSKYOR+28g8mUasnIlYMQ5qJjzFheXDoFxVXpGenk8eBgNh3WB0K/dDLnSLw8VaV3HCIfHWvM+oSl4PmXmiCGQimBjVh1H3DoodexRUVEYNmwYYmJi5LpdhmHw89ixuGVgA6bqD8jKlajV+0u4RyAQ3GEYxurr11U3U/sOPj4+cHZ2VulEFQB+/fVXPHz4EL6+vpSocoRQKMTQoUMRGRmJRYsWYenSpWjbti1OnjxJxSoKwjAMPn/+jBcvXmDvmWu48/wdMnMlYABAUweSynURlSpiO0yVlaphDP06zZAjBRgAmbkSRL5MQ1hsKtuhKVxYbOqXRDVXAggEYDS0EZWUrvSxN2nSBM+fP0d2drZctysQCDBszipk6pvkXzPq9P4S1aF2ywAYhoG3tze8vLzYDuW7bN26FX5+frh27RoMDAzYDod8RSgUYtCgQRg4cCDOnDmDFStWYNmyZVi8eDGcnJxU/hclRcrNzcW7d+/w9u1bvH37Fm/evMn/76//P++/NTQ0YGxsDIP2Q5DT0BYQ/Hd8s3IliElJR4+m1dkblAqLTk5HrqTwaxnZIji5zcDH697sBKUklTq6olLnnyAQsns+6ejowNzcHDExMXJpSZiZmYmwsDBcuHABZ15IIG3SGwXvodI1Q7hG7ZLV+/fvIycnB+3bt2c7lHLz8fHBmjVrcPXqVRgbG7MdDimGQCBAv3790LdvX5w7dy4/af3111/h7OzMqx6/skilUnz8+LHIJFPW/2dkZKBq1aowNjaGsbExqlWrlv/fZmZmsLGxKfRvVatWhb6+PgAg9NFrTDtx78udsH/paWugWU1Dtg6ByrMwNYSetkahY2qgq4X9npvRo+kJFiNTPC6dT3lFVuVJVhmGwYMHDxAUFISgoCDcuHEDbdu2hZ2dHeb16IrNtz9xYoyEFEXtktW8JQCquobw4sWLcHd3R3BwMOrVq8d2OKSUBAIBHBwcYG9vj+DgYCxfvhzLly/HokWLMGzYMJXp9ZmZmVniXc6C///+/XsYGBgUSjjzksxq1aqhadOm3ySklSpVKvedZ9vGJmhdxyh/zWre+jvbxlT9X17qfEy5NPaydgR4+/YtgoODERQUhAsXLkBPTw92dnaYNm0aTp48CUPDL8moRMrg0usbnBgjIUVRqwIrhmFgbm4Ob29vWFpash1OqRSsbNbPeYf//TwAPt7esLW1ZTs08h0YhsHFixexfPlyJCcnY9GiRRg+fDi0tLQKveeKrMwVi8V4//59sXc5v/5/iUSSn1jKSkC//v8qVapAW1tb7rEXJ+/4xaSko1lNqmyWB3U+plwZe+C5c1jpeRLDpvwic14QiUSIiIjIv3saFxeHrl27ws7ODnZ2djAzMyty21wZIyFFFVipVbJ69+5dODs748mTJypxZ/XrymapKBvmVbQQtKAfTSQ8cunSJaxYsQLPnz/HgoX/w0WmGaKS0stUmcswDNLT08t01zM9PR2VK1culGSWlIAaGBioxLVDCJ9IpAycd17G7edvIdTSzZ8XVnQzQUjwBQQFBeHixYto0KBBfnLasWNHpf+iSMj3KipZVY2/PcqJt7e3Si0BKFSJCkCgpYvkHA2ExabSwnceyXsC1tWrVzF/82Ek/VAZ0NIF8KUy986Ld1jh6Ydqua+LTUB1dXWLTDLNzMy++TcjIyPer5klhA/CYlPxKDULAi3d/Ir964+T8OOuJejZtDqcnJywa9cuVK9OnwuEn9QmWWUYBj4+PggICGA7lFKLTv5yd60gqtLkr86dO8Mlpzo2hcSh4N87csRShN6JRWutVzA2Npa5ztPY2Bg6OjqsxU4IURxZnwUCLV0sXLMN03s0YikqQpRHbZLVW7duQVtbGy1btmQ7lFKzMDWEBiQQ47+7X1SlyW+yKq/1dbSwfOZ4+gWFEDUla17Q09aAhWklFqMiRHnUptmjt7c3XFxcVGYJAADovH+KnORY6GkJIQCgT1WavJdXfayvrUHvOSEEAM0LhKhFgZVUKkW9evVw7tw5WFhYsB1OqXz8+BGtW7fGxk0eMGxsQ1WaaoQqcwkhX6N5gagDte4GcP36dYwfPx7R0dFsh1IqDMPgp59+QpUqVbB9+3a2wyGEEEIIUTi17gbg4+MDFxcXtsMotUOHDuHBgwe4desW26EQQgghhLCK98mqVCqFr68vQkND2Q6lVJ48eYK5c+fi77//hp6eHtvhEEIIIYSwivcFVlevXoWxsTGaNGnCdiglys3NxbBhw7Bs2TK0aNGC7XAIIYQQQljH+2TVx8cHzs7ObIdRKosXL4apqSmmTJnCdiiEEEIIIZzA62UAEokEfn5+uHLlCtuhlCgkJARHjx5FZGSkSrXXIoQQQghRJF4nq5cvX4apqSnMzc3ZDqVYb968wejRo3Ho0CEYGxuzHQ4hhBBCCGfwehlA3oMAuIxhGIwdOxYjRoxAjx492A6HEEIIIYRTeHtnVSwW4+TJk7hx4wbboRRr+/btePXqFfz9/dkOhRBCCCGEc3ibrF68eBH16tVD/fr12Q6lSPfv38fy5csRHh4ObW1ttsMhhBBCCOEc3i4D4PoSgKysLAwbNgzr16+HmZkZ2+EQQgghhHASL5NVkUiEgIAADB06lO1QijRnzhy0atUKo0aNYjsUQgghhBDO4uUygJCQEDRq1Ah169ZlOxSZAgICcP78edy7d4/aVBFCCCGEFIOXySqXHwSQlJSEiRMnIiAgAJUqVWI7HEIIIYQQTuPdMoCcnBycPn2ak0sAJBIJRo4ciWnTpqFDhw5sh0MIIYQQwnm8S1YvXLiA5s2bo1atWmyH8o21a9dCIpFg4cKFbIdCCCGEEKISeLcMgKtLAG7cuAEPDw/cvn0bGhoabIdDCCGEEKISeHVnNTs7G2fOnMGQIUPYDqWQ9PR0DB8+HDt37kSdOnXYDocQQgghRGXwKlk9f/48WrdujRo1arAdSiFTp05Fjx49MHjwYLZDIYQQQghRKbxaBsDFBwEcOXIEt2/fxu3bt9kOhRBCCCFE5fDmzmpmZibOnTvHqbuXz549w6xZs3DixAkYGBiwHQ4hhBBCiMrhTbIaGBiIdu3awcTEhO1QAHx5itZPP/2EX3/9Fa1atWI7HEIIIYQQlcSbZJVrSwCWLl2KqlWrYvr06WyHQgghhBCisnixZvXz58+4cOECdu3axXYoAICLFy/i4MGDiIyMpMepEkIIIYR8B17cWT1z5gw6duyIqlWrsh0K3r17h1GjRuHAgQOcWZJACCGEEKKqVPrOqkTKICw2FZtDYmHrMAISKQMNofLvZObF8TD5IwIObMNQZ2fY2dkpPQ5CCCGEEL5R2WRVImUwcv8NRCZ8QEbVtgh4o4n4/TdweKy1UhPW/DhepiEzVwzUtEUN8xqsJc6EEEIIIXyisssAwmJTvySIIikEQiGyRFJEvkxDWGwqO3HkSgAIAE0dRCWlKz0OQgghhBA+UtlkNTo5HVm5kkKvZWSL4OQ2AwKBQGlfTm4zkZEtKhRHVq4EMSnpyjwchBBCCCG8pLLJqoWpIfS0NQq9ZqCrBX/PzWAYRmlf/p4eMNDVKhSHnrYGmtU0VObhIIQQQgjhJZVNVm0bm6B1HSPoa2tAAEBfWwOt6xjBtrFyK/C5EgchhBBCCB8JGIYp8h+trKwYLj/TPq8KPyYlHc1qGsK2sQmr3QDYjoMQQgghRFUJBII7DMNYffO6KierhBBCCCGEH4pKVlV2GQAhhBBCCOE/SlYJIYQQQghnUbJKCCGEEEI4i5JVQgghhBDCWZSsEkIIIYQQzqJklRBCCCGEcBYlq4QQQgghhLMoWSWEEEIIIZxFySohhBBCCOEsSlYJIYQQQghnFfu4VYFA8AZAvPLCIYQQQgghauoHhmGqff1isckqIYQQQgghbKJlAIQQQgghhLMoWSWEEEIIIZxFySohhBBCCOEsSlYJIYQQQghnUbJKCCGEEEI46/8g8s8Vk2kkWQAAAABJRU5ErkJggg==\n"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "draw_graph(solution.to_graph())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Post-processing\n",
+    "\n",
+    "It is not difficult to see that the above solution can easily be improved upon: there are plenty of inefficiencies in small subpaths near both the center and the various corners of the tour. We will partially remedy this with a single pass over all nodes, optimally choosing a subpath of length ``k`` starting at each of these nodes. Since such a process is computationally demanding, we select ``k = 7``."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "k = 7"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimal_sub_path(nodes, start_node, end_node):\n",
+    "    \"\"\"\n",
+    "    Computes the minimum cost sub-path from the given nodes,\n",
+    "    where the sub-path is fixed at start_node and end_node.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    def fix_bounds(permutation):\n",
+    "        return (start_node,) + permutation + (end_node,)\n",
+    "\n",
+    "    def cost(sub_path):\n",
+    "        path = fix_bounds(sub_path)\n",
+    "        return sum(distances.euclidean(path[idx][1], path[idx + 1][1])\n",
+    "                   for idx in range(len(path) - 1))\n",
+    "\n",
+    "    opt_path = min(itertools.permutations(nodes, k), key=cost)\n",
+    "    return fix_bounds(opt_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def post_process(state):\n",
+    "    \"\"\"\n",
+    "    For each node in the passed-in state, this post-processing step\n",
+    "    computes the optimal sub-path of the next k nodes. The run-time\n",
+    "    complexity is about O(n * k!), with n the number of nodes.\n",
+    "    \"\"\"\n",
+    "    state = copy.deepcopy(state)\n",
+    "\n",
+    "    for start_node in state.nodes:\n",
+    "        nodes = []\n",
+    "        node = start_node\n",
+    "\n",
+    "        # Determine the next k nodes that make up the sub-path starting\n",
+    "        # at this start_node.\n",
+    "        for _ in range(k):\n",
+    "            node = state.edges[node]\n",
+    "            nodes.append(node)\n",
+    "\n",
+    "        end_node = state.edges[node]\n",
+    "        opt_path = optimal_sub_path(nodes, start_node, end_node)\n",
+    "\n",
+    "        # Replace the existing path with the optimal sub-path.\n",
+    "        for first, second in zip(opt_path, opt_path[1:]):\n",
+    "            state.edges[first] = second\n",
+    "\n",
+    "    return state"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "New heuristic objective is 576.\n",
+      "This is 2.1% worse than the optimal solution, which is 564.\n"
+     ]
+    }
+   ],
+   "source": [
+    "new_solution = post_process(solution)\n",
+    "new_objective = new_solution.objective()\n",
+    "pct_difference = 100 * (new_objective - optimal) / optimal\n",
+    "\n",
+    "print(f\"New heuristic objective is {new_objective}.\")\n",
+    "print(f\"This is {pct_difference:.1f}% worse than the optimal solution, which is {optimal}.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 864x432 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "draw_graph(new_solution.to_graph())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Conclusions\n",
+    "\n",
+    "In the code above we implemented a very simple heuristic for the TSP, using the ALNS meta-heuristic framework. We did not tinker too much with the various hyperparameters available on the ALNS implementation, but even for these relatively basic heuristic methods and workflow we find a very good result - just 2.1% worse than the optimal tour.\n",
+    "\n",
+    "This notebook showcases how the ALNS library may be put to use to construct powerful, efficient heuristic pipelines from simple, locally greedy operators."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
\ No newline at end of file
diff --git a/examples/weight_schemes_acceptance_criteria.ipynb b/examples/weight_schemes_acceptance_criteria.ipynb
new file mode 100644
index 0000000..9ecc948
--- /dev/null
+++ b/examples/weight_schemes_acceptance_criteria.ipynb
@@ -0,0 +1,738 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import copy\n",
+    "from dataclasses import dataclass\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "from alns import ALNS, State\n",
+    "from alns.criteria import *\n",
+    "from alns.weight_schemes import *"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "outputs": [],
+   "source": [
+    "SEED = 42"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "outputs": [],
+   "source": [
+    "np.random.seed(SEED)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "# Weight schemes and acceptance criteria\n",
+    "\n",
+    "The `alns` package offers a number of different weight schemes and acceptance criteria. In this notebook, we show all of these in action solving a toy knapsack problem. Along the way we explain how they work, and show how you can use them in your ALNS heuristic.\n",
+    "\n",
+    "In our toy [0/1-knapsack problem](https://en.wikipedia.org/wiki/Knapsack_problem), there are $n = 100$ items $i$ with profit $p_i > 0$ and weight $w_i > 0$. The goal is to find a subset of the items that maximizes the profit, while keeping the total weight below a given limit $W$. The problem then reads follows:\n",
+    "\\begin{align}\n",
+    "      \\text{maximise } & \\sum_{i=1}^n p_i x_i \\\\\n",
+    "    \\text{subject to } & \\sum_{i=1}^n w_i x_i \\le W \\text{ and } x_i \\in \\{0, 1\\}.\n",
+    "\\end{align}\n",
+    "\n",
+    "First we quickly set up everything required for solving the problem with ALNS. In particular, we define a solution state, and a few destroy and repair operators. Our goal is not to solve this problem very well, so we set up only the bare minimum needed to get the ALNS algorithm going."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "outputs": [],
+   "source": [
+    "n = 100\n",
+    "p = np.random.randint(1, 100, size=n)\n",
+    "w = np.random.randint(10, 50, size=n)\n",
+    "W = 1_000\n",
+    "\n",
+    "# Percentage of items to remove in each iteration\n",
+    "destroy_rate = .25"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "outputs": [],
+   "source": [
+    "@dataclass\n",
+    "class KnapsackState(State):\n",
+    "    \"\"\"\n",
+    "    Solution class for the 0/1 knapsack problem. It stores the current\n",
+    "    solution as a vector of binary variables, one for each item.\n",
+    "    \"\"\"\n",
+    "    x: np.ndarray\n",
+    "\n",
+    "    def objective(self) -> int:\n",
+    "        # Negative p since ALNS expects a minimisation problem.\n",
+    "        return -p @ self.x\n",
+    "\n",
+    "    def weight(self) -> int:\n",
+    "        return w @ self.x"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "### Destroy operators\n",
+    "\n",
+    "We implement two operators:\n",
+    "- A simple random destroy operator, which removes items from the knapsack at random.\n",
+    "- A destroy operator that removes items based on their relative merits, that is, for an item $i$ currently in the knapsack, it removes those whose $p_i / w_i$ values are smallest."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "outputs": [],
+   "source": [
+    "def to_destroy(state: KnapsackState) -> int:\n",
+    "    return int(destroy_rate * state.x.sum())"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "outputs": [],
+   "source": [
+    "def random_remove(state: KnapsackState, rnd_state):\n",
+    "    state = copy.deepcopy(state)\n",
+    "\n",
+    "    to_remove = rnd_state.choice(np.arange(n),\n",
+    "                                 size=to_destroy(state),\n",
+    "                                 p=state.x / state.x.sum())\n",
+    "\n",
+    "    state.x[to_remove] = 0\n",
+    "\n",
+    "    return state"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "outputs": [],
+   "source": [
+    "def worst_remove(state: KnapsackState, rnd_state):\n",
+    "    state = copy.deepcopy(state)\n",
+    "\n",
+    "    merit = state.x * p / w\n",
+    "\n",
+    "    by_merit = np.argsort(-merit)\n",
+    "    by_merit = by_merit[by_merit > 0]\n",
+    "\n",
+    "    for item in by_merit[:to_destroy(state)]:\n",
+    "        state.x[item] = 0\n",
+    "\n",
+    "    return state"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "### Repair operators\n",
+    "\n",
+    "We implement only the random repair operator. The focus of this notebook is not on solving the knapsack problem very well, but rather to showcase the different weight schemes and acceptance criteria."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "outputs": [],
+   "source": [
+    "def random_repair(state: KnapsackState, rnd_state):\n",
+    "    while True:\n",
+    "        unselected = np.argwhere(state.x == 0)\n",
+    "        rnd_state.shuffle(unselected)\n",
+    "\n",
+    "        for item in unselected:\n",
+    "            if state.weight() + w[item] <= W:\n",
+    "                state.x[item] = 1\n",
+    "                break\n",
+    "        else:\n",
+    "            return state"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "### ALNS"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "outputs": [],
+   "source": [
+    "def make_alns() -> ALNS:\n",
+    "    rnd_state = np.random.RandomState(SEED)\n",
+    "    alns = ALNS(rnd_state)\n",
+    "\n",
+    "    alns.add_destroy_operator(random_remove)\n",
+    "    alns.add_destroy_operator(worst_remove)\n",
+    "\n",
+    "    alns.add_repair_operator(random_repair)\n",
+    "\n",
+    "    return alns"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "outputs": [],
+   "source": [
+    "# Terrible - but simple - first solution, where only the first item is\n",
+    "# selected.\n",
+    "init_sol = KnapsackState(np.zeros(n))\n",
+    "init_sol.x[0] = 1"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "# Weight schemes\n",
+    "\n",
+    "We now have everything set-up for solving the problem. We will now look at the weight schemes the `alns` package offers. Here, we use the `HillClimbing` acceptance criterion, which only accepts better solutions."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "outputs": [],
+   "source": [
+    "crit = HillClimbing()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Simple weights\n",
+    "\n",
+    "The `SimpleWeights` weight scheme updates operator weights according as a convex combination of the current weight, and the new score.\n",
+    "\n",
+    "When the algorithm starts, all operators $i$ are assigned weight $\\omega_i = 1$. In each iteration, a destroy and repair operator $d$ and $r$ are selected by the ALNS algorithm, based on the current weights $\\omega_i$. These operators are applied to the current solution, resulting in a new candidate solution. This candidate is evaluated by the ALNS algorithm, which leads to one of four outcomes:\n",
+    "\n",
+    "1. The candidate solution is a new global best.\n",
+    "2. The candidate solution is better than the current solution, but not a global best.\n",
+    "3. The candidate solution is accepted.\n",
+    "4. The candidate solution is rejected.\n",
+    "\n",
+    "Each of these four outcomes is assigned a score $s_j$ ($j = 1,...,4$). After observing outcome $j$, the weights of the destroy and repair operator $d$ and $r$ that were applied are updated as follows:\n",
+    "$$ \\omega_d = \\theta \\omega_d + (1 - \\theta) s_j, $$\n",
+    "$$ \\omega_r = \\theta \\omega_r + (1 - \\theta) s_j, $$\n",
+    "where $0 \\le \\theta \\le 1$ (known as the _operator decay rate_) is a parameter."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Found solution with objective 2876.0.\n"
+     ]
+    }
+   ],
+   "source": [
+    "weights = SimpleWeights(scores=[5, 2, 1, 0.5],\n",
+    "                        num_destroy=2,\n",
+    "                        num_repair=1,\n",
+    "                        op_decay=0.8)\n",
+    "\n",
+    "alns = make_alns()\n",
+    "res = alns.iterate(init_sol, weights, crit)\n",
+    "\n",
+    "print(f\"Found solution with objective {-res.best_state.objective()}.\")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 864x432 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "_, ax = plt.subplots(figsize=(12, 6))\n",
+    "res.plot_objectives(ax=ax, lw=2)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Segmented weights\n",
+    "\n",
+    "Simple weights continuously updates the weights of the destroy and repair operators. As a consequence, it might overlook that different operators are more effective in the neighbourhood of different solutions.\n",
+    "\n",
+    "The `SegmentedWeights` weight scheme attempts to fix this, by fixing the operator weights $\\omega_i$ for a number of iterations (the _segment length_). Initially, all weights are set to one, as in `SimpleWeights`. A separate score is tracked for each operator $d$ and $r$, to which the observed scores $s_j$ are added in each iteration where $d$ and $r$ are applied. After the segment concludes, these summed scores are added to the weights $\\omega_i$ as a convex combination using a parameter $\\theta$ (the _segment decay rate_) as in `SimpleWeights`. The separate score list is then reset to zero, and a new segment begins."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Found solution with objective 2887.0.\n"
+     ]
+    }
+   ],
+   "source": [
+    "weights = SegmentedWeights(scores=[5, 2, 1, 0.5],\n",
+    "                           num_destroy=2,\n",
+    "                           num_repair=1,\n",
+    "                           seg_decay=0.8,\n",
+    "                           seg_length=500)\n",
+    "\n",
+    "alns = make_alns()\n",
+    "res = alns.iterate(init_sol, weights, crit)\n",
+    "\n",
+    "print(f\"Found solution with objective {-res.best_state.objective()}.\")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 864x432 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "_, ax = plt.subplots(figsize=(12, 6))\n",
+    "res.plot_objectives(ax=ax, lw=2)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "# Acceptance criteria\n",
+    "\n",
+    "We have just looked at the different weight schemes, using a fixed acceptance criterion. Now we flip this around: we fix a weight scheme, and look at the various different acceptance criteria the `alns` package offers."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "outputs": [],
+   "source": [
+    "weights = SegmentedWeights(scores=[5, 2, 1, 0.5],\n",
+    "                           num_destroy=2,\n",
+    "                           num_repair=1,\n",
+    "                           seg_decay=0.8,\n",
+    "                           seg_length=500)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "# Hill climbing\n",
+    "\n",
+    "This acceptance criterion only accepts better solutions. It was used in the examples explaining the weighting schemes, so we will not repeat it here. You might also be interested in the other example notebooks for the cutting stock and travelling salesman problems, which also rely on this acceptance criterion."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "# Record-to-record travel\n",
+    "\n",
+    "This criterion accepts solutions when the improvement meets some updating threshold.\n",
+    "\n",
+    "In particular, consider the current best solution $s^*$ with objective $f(s^*)$. A new candidate solution $s^c$ is accepted if the improvement $f(s^c) - f(s^*)$ is smaller than some updating threshold $t$. This threshold is initialised at some starting value, and then updated using a step value $u$. There are two ways in which this update can take place:\n",
+    "- _linear_: the threshold is updated linearly, as $t = t - u$.\n",
+    "- _exponential_: the threshold is updated exponentially, as $t = t \\times u$.\n",
+    "Finally, the threshold $t$ cannot become smaller than a minimum value, the end threshold."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Found solution with objective 2772.0.\n"
+     ]
+    }
+   ],
+   "source": [
+    "crit = RecordToRecordTravel(start_threshold=255,\n",
+    "                            end_threshold=5,\n",
+    "                            step=250 / 10_000,\n",
+    "                            method=\"linear\")\n",
+    "\n",
+    "alns = make_alns()\n",
+    "res = alns.iterate(init_sol, weights, crit)\n",
+    "\n",
+    "print(f\"Found solution with objective {-res.best_state.objective()}.\")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 864x432 with 1 Axes>",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuEAAAGBCAYAAADIXG9VAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAABUuElEQVR4nO3dd5xU1fnH8c8zW1lggYVdOixdEGkiiEQEu6JGE2PUqNFoMNH402hUYhRbjMYWTTQxxhZriiXR2BWxojQpIkWQ3vvStp/fH/fOMDs7szsLu7Ozu9/36zUv5p7bnpkLwzNnnnuOOecQEREREZHECdR3ACIiIiIiTY2ScBERERGRBFMSLiIiIiKSYErCRUREREQSTEm4iIiIiEiCKQkXEREREUkwJeEi0iCY2RFm9q6ZfWRmn5nZP82sR9j6l82s0MzGxti/u5mtMbPMOojtjVjnTSQzG2Fms81seX3Hkghm9mcz225mF8a5/blm9lgdh1VdDPlm9nV9xiAiyUFJuIgkPT/BfQ643Dk3xjl3BPBP4BMz6wTgnPsesD7WMZxzK4CBzrnCA4zlFjN7KqL5bODDAzlubXDOTQOuqo9zm9lTZnZLIs/pnLsMmF2DXf5J2PuTiJjNbHn4FzTn3HLgiLo8p4g0DErCRSSpmVkAeBT4nXNucbDdOfcy8Anwu3iP5ZzbVvsRgnOuwGnms6TnnCtzzu1Kgji213cMIlL/lISLSLIbCvQB3o2y7i3gdD9RDxplZm+a2Twz+4OZpfiPKWbmzCwfwMzSzOwev7TlEzO72cwseBAzu8bMPjezD/xyk2Fm9kPgQuBE/3i/MbNrzWy930M+wsxWmtk6M7vSP87TZrYlWDLhb/+5mX1sZn8ys/TIF2VmE8yswMwWmNlRZpZjZjP9XtUhZnaGmb1vZu/55Tmjo71xfvnF8mDPvZn9PBhr2Da9zOwdM/vQjylmL62ZTTKzyf7jf8FfIfzXeiJwof++XBxj/xPMbKp/rteC+/vr/uy/pilm9oKZZUfE+Ka/31QzuzXi0L3M7N9mttjMon4pM7NDwkt1YsVsZof67+mHfjwHhV2T5Wb2DzP7m3+sKWbWwsyeMa9U6mMz+4uZpfr7PAl0AB7wtz3UP2asv4efmdm9ZpbmrwuWWF1vZv8xsyVmdlms6yMiDYxzTg899NAjaR/ADwEHpEVZd7y/Ls9fXo5XtmJAJjAHmBC2vQPy/ee/ASYDKUAa8Blwnr/uXOArIMtf/hVwi//8FuCpiDieClt/GrAobN1g4A7/+Y+ABUCWH+O/gBtjvO77gUfDlq8EjvOfnwfk+M/zgZVh240FloctV4g3ItZUP56f+MuDgM1AyxgxXQGY//xC4Jlox42xbw9gJ9DPX74ceC9s/f9FxHy7/zwF+Br4sb/cClgdtu0U4H/++9kRKAE6xYgh8r2pELN/7E3A0f7yeGAREAiLaz2Qi9eJ9XsgJ/j3JuyYF4ctLwfGRsQR/vfwJuA9/3WmAG8DN0Xs/2f/+QhgF5Ba3/8u9dBDjwN/qCdcRBqbF52nEHgRr147mguBvzuvRKEE+Ddwvr/uIuBfzrk9/vLf/GPF402gjZmN8pfPB54OO+c/nHN7nHMOeCHsnJGeBs6yfTeSjgPe95/PAZ40s0/wkr6uZpYXZ3zhRgK9gGcAnHNzgTXAKTG2XwV8YGYf4dVWH1qDc50LzHDOLfKXnweOMbOO/nKh35P8Id41Cx77cKA33pcrnHM78L6YhXvHv+br8L5E5NcgrnCnALucc5P9c72O15M9Mmybqc65Tc65cufc9cA2oLt5v6ZMwUv0a/K+XAA87f89LMO77hdFbPOW/+dcoDmwP9daRJJMan0HICJSjaX+n52AFRHrOgPb8RKvoPC67y14vaPRdAGuNrNgwtPCP1Zw3abghn7ityOeYJ1zJWb2D+ACM5sG9ApLPLsA55rZOH85EyiPcZzZZrYS+K6ZzQMWOueC274KPOycuxfAzBxe73pNdcHrlX3X9lXiZOD1CFdgZn3weu5HO+emm3ez4VM1PNcAP1ENWgG0N7N+wH3AIc655X7pzoVh+21zzpUGd3LOfRpx7IKw50VApRKfGsSYExHjJqBt2HLk34MfA5cCQ5xzW/1Sn/wannNT2PImvy1cAYBzrtC/Tvv7+kQkiSgJF5FkNwtYAhwHRA4vdwJez3d4IpsT9rwdsC7GcVcBv3XO/RtCN4C2DluXG9zQzJoDXcKS6eo8DbyD14P5XsQ533XO3RN27HbVHOfHeD3fz/jb5+EleW/5y2nVxFKMl1gHtY6Ip8Q5NzYsnuZE/2IwFChwzk33l6s7b6RVeD3h48PO1QYvwbwGr4RneZRjr8L7ZSE1mIibWX+8spK9NYwhnhhXR7wf2UBVI+qMAKY557b6y/vzvuSGLecCq2t4DBFpgFSOIiJJzU+wfwrc4PfGAmBm38UrVbgxYpcfmqcZ8APgHzEO/RRer3SKv/xjvDrx4LqzzCzYu3wV3k184NU1Z/nneCVGzDPwkv8HIs7/FPCDYImJ3yP+1xjxgVeCcTQw2Dk332/bgtdjHyyRODHKfuGW4fVAm5nlULG04gtgpZl9z48nFfgP0DfKcZbgJcPBdZHnDb4vzc3suSj7vwCMNLPu/rny8Oq5A/6xe5tZsMf5hIgYl+CVs+C/hn8BpRy4yJj/B7Qzs8P8czUHPiDKLwNhlgCDzSzDf/+OiXGOcf7NoJGeAs4z7+bhAF69/5MH9KpEpGGo76J0PfTQQ494HsCReDXRH+HdRPkC0DVs/ct4PZa3442k8hVeEpwStk34DXFpwF3A53iJ1jP4N2L666/x132IVxOe6rf3BuYDU4Fr/cd6vBvowm/Iux54JcrruAYvsZyMl/DmVfO63wSujGg7HfgW7ya+3/qv63O8XtnZ/vvwb3/bZv4xZuEl/P8IjxWvJvwt/3V+jH+TZoxYbvf3/a9/rEK8emaAUcBCYBpwboz9jwc+xUu+JwOH++0BvF85lvjX8Wm8Lxp3h8X4ZliMR/ntd/vbLfTP/2c/ptnAgIhzHxLlvakUM1499xT/XB8Bp/jt5/qvfX3wNfvtzYFX8G5w/bf/fD1wtb/+F3g3ln4OHIz3dzh4vTrj/T38Pd7f6c+Ae/FvQvbfh+Dr6eG/N8F9c+r736QeeuhxYI/gXe4iIo2aecW05UB359zK+o5HRESaNpWjiEijZmYP+3W9fYE9xK4RFxERSRjdmCkijd189k0pP8F5wxGKiIjUK5WjiIiIiIgkmMpRREREREQSTEm4iIiIiEiCNcma8Hbt2rn8/Pz6DkNEREREGrmZM2duds7lRrY3ySQ8Pz+fGTNm1HcYIiIiItLImdmKaO0qRxERERERSTAl4SIiIiIiCaYkXEREREQkwZpkTbiIiIiIVK2kpITVq1dTWFhY36E0CJmZmXTp0oW0tLS4tm8USbiZHQt8D9gIOOfcrfUckoiIiEiDtnr1alq2bEl+fj5mVt/hJDXnHFu2bGH16tX06NEjrn0afBJuZlnAI8DBzrkiM3vJzI5xzr1f37GJiIiINFSFhYVKwONkZrRt25ZNmzbFvU9jqAkfBaxwzhX5y58C4+sxHhEREZFGQQl4/Gr6XjX4nnAgD9gZtlzgt1VgZhOACQDdunVLTGQiIiIickDWrVvHPffcQ5s2bSguLmb+/PmMGzeOK664IuGxTJkyhdatWzNkyJADPlZjSMI3Ai3DlrP9tgqcc48CjwIMHz7cJSY0EREREdlfRUVFnHbaabzyyit06dIFgA0bNnDmmWfWWxKen5+vJNw3FehuZhl+Scpo4M/1HJOIiIhIo5E/8fU6Oe7yu6quIP7f//5Hfn5+KAEHaN++Pc8//zwXXnghAE899RSPPvoov/vd71i+fDmvvfYav/zlLzn11FPZuXMnb7/9Nrfddhu//vWv+dnPfsbSpUtZtGgRn332GVdddRV5eXns2LGDIUOGcP7553PPPfdw6623cuuttzJz5kx27NjBq6++ytKlS0M94cuXL2fixIlkZmbu92tv8DXhzrk9wM+BP5rZb4G5uilTREREpOFbsmQJHTp0qNTetWvXUBIOMGHChNDzU089le985zv06dOHxx57jFdeeYWLLrqIgw46iBEjRvDMM8/w5z//mccff5zi4mImTZrEvffeyx133MHGjRu59tpradeuHaeccgrPP/88ALNnz6Zv376MHTuW008/nVtuueWAEnBoHD3hOOfeBd6t7ziqsmTOJ2z6/AXSugxh+Pif1nc4IiIiInGrrse6rnTp0oUZM2bs1779+/cHYPjw4VHbnnzySdatW8ddd90FwMCBA1m/fj15ed6thX379gUgNzeXnTvDbz+sHQ2+J7yh2LZ8LqPWPQuL3q7vUEREREQahDPOOIPFixezZs2aUNuiRYs47bTTaNmyJQUFBQCsXLmy0r7RRisJbxs8eDB9+vRh4sSJTJw4kR/96Efk5+dXuX9KSgrOOdauXVuj4QijaRQ94SIiIiLS+GRlZfHmm29y//33k52dTXFxMevXr+cvf/kLHTp0oLy8nNtvv538/Hx27NjBCy+8QK9evZg7dy7PPPMMXbp0oXfv3rz77rusWLGChx56iOuvv57c3FwuvvhirrvuOm6++WZSU72U+IwzzuDf//43O3bs4IknnmDIkCGhY40ePZqjjjqK+++/n8mTJ4d60PeXOdf0BgoZPny429+fNvbX9P/+mcO+/DUzso9j+NUvJvTcIiIiIjW1YMGCUPmGxCfae2ZmM51zwyO3VTmKiIiIiEiCKQkXEREREUkwJeEiIiIiIgmmJDzhml4NvoiIiIhUpCQ8QaINcyMiIiIiTZOScBERERGRBNM44SIiIiKSlKZNm8Z1111HcXExxx9/POvXr2fLli0899xzpKenx32cKVOm0Lp1a4YMGVJ3wdaQesJFREREJCmNGDGCsWPHcsQRR3DLLbfwyCOPsHnzZt56660aHWfKlCnMnj27boLcT+oJFxEREZGq3dKqjo67o0abl5eXs2XLFnJzc/n444954oknGDBgAIsWLeKuu+6iXbt2/OIXv6Bz587s2LGDzp07c8IJJ4R6wpcvX87EiRPJzMysm9dTA0rCRURERCSpTZs2jbvuuosvv/ySwYMHM2zYMHr27Mm0adPo3LkzTz31FHfccQeTJk3i1VdfZerUqXTu3JnPPvuMvn37MnbsWPLz87nwwgvr+6WEKAlPGI2OIiIiIg1UDXusa9uIESOYOHEiAHfeeSdXX301W7du5ZlnngFg69atpKSk0KZNGx588EEuueQS9u7dy4033lifYVdJSbiIiIiINBgdO3Zk1qxZ5Obmcumll9KmTRu2bNnC1KlT2b59O7m5ubz55pvMnz+fc845h7lz55KSkoJzjrVr15KWlkZubm59vwwl4SIiIiKSnGbMmMFHH31EcXExd9xxB6WlpcybN4/bbruN7du3c/3119OzZ09WrlzJFVdcQVlZGQ888ACffPIJmzdv5qqrrgLgqKOO4v7772fy5Mncdddd9fuifErCRURERCQpDR8+nMmTJ8dcf8QRR1Rqe/HFFyu1jRkzhjFjxtRqbAdKQxSKiIiIiCSYknARERERkQRTEp5oztV3BCIiIiJSz5SEJ4ppiEIRERFpWJw6D+NW0/dKSbiIiIiIVJKZmcmWLVuUiMfBOceWLVtqNBOnRkcRERERkUq6dOnC6tWr2bRpU32H0iBkZmbSpUuXuLdXEi4iIiIilaSlpdGjR4/6DqPRUjmKiIiIiEiCKQlPMEN1VSIiIiJNnZLwRNHoKCIiIiLiUxIuIiIiIpJgSsJFRERERBJMSbiIiIiISIIpCRcRERERSTAl4SIiIiIiCaYkPOE0RKGIiIhIU6ckPFE0RKGIiIiI+JSEi4iIiIgkmJJwEREREZEEUxIuIiIiIpJgSsJFRERERBJMSXiiOY2OIiIiItLUKQlPEEOjo4iIiIiIR0m4iIiIiEiCKQkXEREREUkwJeEiIiIiIgmmJFxEREREJMGUhIuIiIiIJJiS8AQzNEShiIiISFOXWt8BhDOzW4CxYU13OOfe9dddC2QDbYB3nHOv+u1DgMuBZUAe8CvnXGnioo6TaYhCEREREfEkVRIO4JwbG9lmZiOBcc65k80sFVhgZh8CBcCzwLHOufVmdh/wY+DxRMYsIiIiIlITSVeOYma/MbNfmdn1ZpblN58CTAXwe7kXAEcBPYFmzrn1/nafAuMTHbOIiIiISE0kvCfczN4G2kdZNQn4N7DcObfbzC4D/gRcjFdmsiBs2wK/bROwM0p7tPNOACYAdOvW7QBfhYiIiIjI/kt4Eu6cOyHOTScD1/rPNwItw9Zl+22x2qOd91HgUYDhw4fr7kgRERERqTdJVY5iZveELfYBlvrPXwdG+dukAf2Bj4Bvgb1m1sHfbrS/bRJT/i8iIiLS1CXbjZmlZvYgXm/2IcBlAM65z83sAzP7Hd7oKNc457YDmNl5wB1mtgJIAf5eL5FXK6m+74iIiIhIPUqqJNw59+sq1t0To302Xt24iIiIiEiDoO5ZEREREZEEUxIuIiIiIpJgSsJFRERERBJMSbiIiIiISIIpCU80jVAoIiIi0uQpCU8Qs/qOQERERESShZJwEREREZEEUxIuIiIiIpJgSsJFRERERBJMSbiIiIiISIIpCU84DY8iIiIi0tQpCU8UDY8iIiIiIj4l4SIiIiIiCaYkXEREREQkwZSEi4iIiIgkmJJwEREREZEEUxIuIiIiIpJgSsITzDREoYiIiEiTpyQ8QUxDFIqIiIiIT0m4iIiIiEiCKQkXEREREUkwJeEiIiIiIgmmJFxEREREJMGUhIuIiIiIJJiS8ERzGqJQREREpKlTEp4gTm+1iIiIiPiUGYqIiIiIJJiScBERERGRBFMSLiIiIiKSYErCRUREREQSTEl4wml0FBEREZGmTkl4gphZfYcgIiIiIklCSbiIiIiISIIpCRcRERERSTAl4SIiIiIiCaYkXEREREQkwZSEi4iIiIgkmJJwEREREZEEUxIuIiIiIpJgSsJFRERERBJMSbiIiIiISIIpCRcRERERSTAl4SIiIiIiCaYkPMEMV98hiIiIiEg9UxKeIGZ6q0VERETEo8xQRERERCTBlISLiIiIiCRYaqJPaF5dxk+B24GjnXNfha07DxgKlAFLnXN/9dvzgZuAJUA+cI1zbpd/rN8BO/32x51znyfsxYiIiIiI7IeEJ+HAYOALYE94o5l1AX4FDHXOOTObbmaTnXPfAI8Ak5xz08zsCuB6vKT8LCDbOTfRzHKAz82sv3OuLKGvSERERESkBhJejuKc+9I5NzvKqhOAmc654PAhU4GTzCwNGAdM99s/Bcb7z8f72+Gc2woUAgfXUegiIiIiIrWiTnrCzextoH2UVZOcc6/G2C0Pr6wkqMBvawfsDUvOg+1V7RMtpgnABIBu3brF8SrqiNMQhSIiIiJNXZ0k4c65E/Zjt41A77DlbLwa8M1AMzMzPxHP9rcN7tMyYp+NROGcexR4FGD48OGJz4TNEn5KEREREUlOyTQ6ytvAoWahbHUU8KZzrgT4ADjMbx8NvO4/f93fDr8mPBOYn7CIRURERET2Q32MjtIGuBxoBUwws+edc58751ab2b3AH8ysDHjMvykT4GfAJDM7HugGXO23/wsYamY3++0X6KZMEREREUl2CU/CnXPbgN/6j8h1zwLPRmlfDvwkSns53kgpIiIiIiINRjKVo4iIiIiINAlKwhPM0OgoIiIiIk2dkvBE0egoIiIiIuKrtibczHoA9+GNx/06sNo591ldByYiIiIi0ljF0xN+A/AgsAz4D/CDugxIRERERKSxiycJX+ic+xDY45wrBtbXcUwiIiIiIo1aPEn4IDM7HMg0s4FUnNVSRERERERqKJ5xwn8PPAYMAo4HLqnTiEREREREGrlqk3Dn3NfAEcFlM2tWpxE1ehqiUERERKSpi2d0lDERTecDP62bcBovjVAoIiIiIkHxlKM8CHwJGNANKKvTiEREREREGrl4kvAJzrnpwQUz+1kdxiMiIiIi0uhVOzpKRALeAhhZpxGJiIiIiDRy8dSEbwO24ZWjFAAP1XVQIiIiIiKNWTzlKD9zzv2zziNpKpxGRxERERFp6uIpR6mQgJvZD+sunMYsnnmRRERERKQpiNkTbmbL2DeotfnPDcgG1DMuIiIiIrKfqipHuds595fIRjP7eR3GIyIiIiLS6MWskYiWgPsW1lEsIiIiIiJNQjyjowwGfgO0Y9+EPb3qOC4RERERkUYrnrsFrwbuBKYBE4CX6jQiEREREZFGLp4kfJ5z7ktgh3PuG6CojmNq1Ky+AxARERGRehdPEj7azIYArc3sRmBM3YbUSJnSbxERERHxxFuOsgm4D8gBbqjTiEREREREGrl4kvCfOufWOOc2Oueuds59WudRiYiIiIg0YvEk4QPN7CEzu8LMWtZ5RCIiIiIijVy1QxQCP3TO7TWzfsB9ZlbsnPtFXQcmIiIiItJYxdMTfoyZDQUmAkcD6+s2pMbO1XcAIiIiIlLP4ukJfxaYAzyMVx9eWrchNU6mwQlFRERExBdPEn6Tc+5PdR6JiIiIiEgTUW05ihJwEREREZHaFU9NuIiIiIiI1CIl4SIiIiIiCRZPTThmdiqQDcwGljnn9tRlUCIiIiIijVm1PeFmdjfwPWAMkA7cWddBNW4aolBERESkqYunHGW7c+4i4Fvn3JfAujqOqXEyDVEoIiIiIp54kvB2/p/BLtzcOopFRERERKRJiKcmfLGZfQ2Um9mZwF/rOCYRERERkUYtniT8eWAKMBCY55xbVKcRiYiIiIg0cvGUo/wD2Ouce1EJuIiIiIjIgYunJ/wz4Idm1gV4xTn3QR3HJCIiIiLSqFWbhDvnfgtgZmnAo2b2R+fcIXUeWSNlTkMUioiIiDR11SbhZnYTsBv4KTAPuKyug2qMTEMUioiIiIgvnnKUX+CNiHKsc25NHccjIiIiItLoxZOEn+ucez+4YGYdnXOasEdEREREZD/FTMLNbLBzbg7Q2cwuCFt1KvCDOo9MRERERKSRqmqIwv/z/7wI6BH2yDmQE5pZwMwuNbONZjYwYt1yM5viP54La883s8fN7Ndm9lczaxF2rLvM7Ddm9jczO/xAYhMRERERSYSYPeHOuYv9p//nnJsHYGbNgZcP8JyDgS+APVHWPeWcuyVK+yPAJOfcNDO7ArgeuAk4C8h2zk00sxzgczPr75wrO8AY65BGRxERERFp6uKZrOeksOftgWsP5ITOuS+dc7NjrD7SzK4zs9vN7AgIDY04Dpjub/MpMN5/Ph6Y6h93K1AIHHwg8dUZjY4iIiIiIr6qasK7AfnAQWY2xm8OEEfibmZv4yXskSY5516tYtdf+73dWcAsMzsFb3jEvc6FBtguAPL853nAzrD9w9dFxjQBmADQrVu36l6CiIiIiEidqWp0lKHA6cAQINiNWwa8Vt1BnXMn7E8wzrlp/p97zGw2MBp4HmhmZuYn4tnARn+XjUDLsEOEr4s89qPAowDDhw9XTYiIiIiI1JuqasL/C/zXzA5zzk2PtV1tMbNjgDTn3Ft+U29gqXOuxMw+AA4DpuEl5q/727wOjAGe8WvCM4H5dR2riIiIiMiBiGec8EPMrI9z7nkzOx+Y5Zzb70TXzNoAlwOtgAlm9rxz7nO8HuxbzGwY0Al42Tn3ib/bz4BJZnY80A242m//FzDUzG722y9I7psyRURERETiS8JH4M2aCfBv4E7gl/t7QufcNuC3/iO8fR7w/Rj7LAd+EqW9HG+kFBERERGRBiOe0VG+cc6VAjjnCoH1dRtS42YaolBERESkyYunJ3yAmZ0JLAF6AX3rNqTGKp7vOyIiIiLSFMSThN8I3AcMAmZzgOOEi4iIiIg0ddUm4c65dcC5YUMEioiIiIjIAYhn4p1hZjYLeMPMzjOz0+s+LBERERGRxiueQuUJwBnAh865Z4Ej6jYkEREREZHGLZ4kfIlzbgVQ7i9vqcN4REREREQavXiS8EPM7Gygo5mdgjeTpdSQWX1HICIiIiLJIp7RUX4N3Is3OkouGh1FREREROSAxDM6ylrg3ATEIiIiIiLSJMRMws3sGufcfWb2RJTVe4EnnHMz6y40EREREZHGqaqe8LX+nwY8FbEuDbgc+EkdxCQiIiIi0qjFTMKdcy/4T3/hnNsdvs7M0oAz6zIwEREREZHGKp7RUfqY2TQz2+X/OQzoDHxQx7E1SqZJR0VERESavHhGR7kV+AWwBOgH3O6cGw8sr8O4Gh+NUSgiIiIivniS8OnOuWn+86lmppsxRUREREQOQFWjo3Tznxab2dHAt0DPqvYREREREZHqVZVQT8ErOTHgpLD2bsANdReSiIiIiEjjVlUS/gvn3BuRjWZ2ch3GIyIiIiLS6FU1ROEbZpYFfB/oDawG/hEtMZea0OgoIiIiIk1dzCEKzaw78ClwNJAOHAF8amZdExRb46LRUURERETEV1U5yjXACc65jcEGM2sPXOevExERERGR/VDVZD1bwhNwAOfcBqCgbkMSEREREWncqkrCYxUvq6hZREREROQAVJWEtzazTuENZtYZaF2nEYmIiIiINHJV1YTfA7xlZouAdUAnoA8VxwwXEREREZEaqmqIwnVmdjjwPaA7MA142Tm3N1HBNU6q5hERERFp6qqcgt5PuJ9LUCyNmlVZ+SMiIiIiTYkyQxERERGRBFMSLiIiIiKSYErCRUREREQSTEm4iIiIiEiCKQlPMKvvAERERESk3ikJTxRT+i0iIiIiHiXhIiIiIiIJVuU44VI31mzfy+dLt7B8y26WbNzF5eN6M7Bzq/oOS0REREQSREl4PTjmvikUlpSHljNSAzxw9tB6jEhEREREEklJeILtLCypkIAD/Gf2WppnpPLL4/rSrkVGPUUmIiIiIomimvAk8dwXK7nzjYX1HYaIiIiIJICS8CSybU9xfYcgIiIiIgmgJDxBLOC91YaLuY1zsdeJiIiISOOhJDxBAua91YGqkvBEBSMiIiIi9UpJeKIEgkl4ecxNlm7aRUlZ7PUiIiIi0jgoCU8Uf8bMqnrCV23dy4SnZyQqIhERERGpJ0rCEyQQSPGfVV108sGiTXUfjIiIiIjUKyXhCWJx1ISLiIiISNOgJDxR4ihHCdq6W0MVioiIiDRmCZ8x08z+AOwBdgGDgaucc+v9ddcC2UAb4B3n3Kt++xDgcmAZkAf8yjlXamaZwL3AGqAPcJdzbnFiX1F8atIT/sQny/jVCf3qOiQRERERqSf1MW39bufcjQBmdj3wG+AKMxsJjHPOnWxmqcACM/sQKACeBY51zq03s/uAHwOPA1cBK51zd5vZIX7bkYl/SdUzvya8qnHCgzYUFNZ1OCIiIiJSjxJejhJMwMPOv8t/fgow1d+mFFgAHAX0BJoFe8uBT4Hx/vPxYfvMAwabWXadvoD9FAh45SjRkvCnfzIi0eGIiIiISD2qk55wM3sbaB9l1aSwEpPWwPHA9/11eXiJd1CB37YJ2BmlPbhPtHUFUWKaAEwA6NatW41eT62w2OOEp/oJuoiIiIg0DXWShDvnTqhqvZm1Ah4GfuKc2+o3bwRahm2W7bfFaq9qn2gxPQo8CjB8+PCED1ESnDFT6baIiIiIJLwcxcza4SXg1znnlplZsCf8dWCUv00a0B/4CPgW2GtmHfztRvvbRu5zCDDHOVepFzwp+DXh0XrCI78RmDJ1ERERkUatPm7MfMc/73PmZZs7gZecc5+b2Qdm9ju80VGucc5tBzCz84A7zGwFkAL83T/Wg8C9ZnYj0Bu4OKGvpAaqqgkvdxo7XERERKQpSXgS7pwbVsW6e2K0zyZKgu2c24s3dGHyq2KIQuXgIiIiIk2LJutJkEAgWBPuOLR7mwrr1BMuIiIi0rQoCU8Yrya8e2Ajvzy2b6j1V8f3VU+4iIiISBOjJDxBMlq0Cj3fvnFV6Pl5h3fHRZSozFixjWWbdycsNhERERFJLCXhCdIur2PoeVrpntDzQMAojxgw5dtNuxl37xQWri+gqLQMp65yERERkUZFSXgCLSnvBIC5klBbwGJPZP/3z1ZwyM3v8OMnpycgOhERERFJlPoYorDJKvHrwlMoDbVlpAZi3pj5wrSVAHy0eFPdByciIiIiCaMkPIFKQ0l4OReNzicjNYW0lEBc5SZvzlvHSYd0rHY7EREREUl+KkdJoDI/CW+2Zx03H9mSiaOyYPtKMnatoT1bq9z358/NYm9xWSLCFBEREZE6pp7wBCr23+6R0/4Ppu1rHwd8kQl/LD2d+0vPir1/aTnN0lPqOEoRERERqWvqCU+gogFnsTGlAy67C7TqGnoUZeQAcIgtq3J/TeojIiIi0jioJzyBjjz7V8CvKrXPfPdFjvj0YtLCbtiMRim4iIiISOOgnvAkUG5pAKRZ1TXfGi9cREREpHFQEp4EyvwkPL2anvDyiBx8V1Eplz8/i8ufm8XOwpLoO4mIiIhI0lE5ShIoM+8yDA0sYW7GxVxUfB0zXT8A2mSlsW2Pl2BHTm8/bdkWXp+7DoDTh3YmYPDIh0txDi45sicnDuyQwFchIiIiIvFSEp4EDh8xktUfd6SLW0e27eWwwCJmlnlJeLecLFJTCtm0s6hSUXhp2b6G+Wt38MB734SWU1OWKQkXERERSVIqR0kCWS1a0fmmr5nZ9ccAWNg6Mwst7yoqZc32vaHa8PDylPAEHLzhDEVEREQkOSkJTxIWCBC8HMa+BDpgEDAvDT/6vg8Zfddk7n57kb+28o2ag7u0AmDWyu38a/qqOo1ZRERERPaPylGSSJnf5x0IS64DZphV3O4vU7y678+/3VLpGMcNaM+c1TsAuO6luQAM7daaPu1b1lHUIiIiIlJT6glPIuWuchI+tl8uFmXbRz5cyuxV2yu1Z6ZVnFHzupfmcs7fPqe0rJw35q1j866i2gxZRERERPaDkvAkUh7sCbd95SjnHd4di+wKr0JGWuVp7TfvKuafM1Zx2XOzOPb+Dw88UBERERE5ICpHSSLBJNzCesIz01IqlKPktcxgUJdWTF++jR17K48Nnpka/XvV9GVbAdi+p4R/z1jFt5t386/pq9i2p5hrju/HOSO68fE3myh3jpE92tKpdbNafGUiIiIiEk5JeBLZVez1gIeXo6QGKtaEnzOiG788ri8AR9z5Pmt3FFY4Rk7z9KjHzkjd10N+7YtzK6y75+1FfL2uIDTmOMBbVx3JQR2yq435llfns2zzbp688DACgeg99ss372bGim18b2hn9pSUsXlnEfntmkfddsG6AiYv3Mj8tTv4dMkW7jhjIKcM6lRhm2Wbd9M8I4W8lpnVxiciIiKSjJSEJ5Eif9b6AOVc/J0e9G3fgtSUQGh0FIALj8gPPQ8vU7nnzEE4B4O6tI567H/OqHqklPAEHODEBz7m8R8P55j+7QEoLCnjN698RfvsDAZ3bc1Xa3bwwrSVbN5VDMBV/5zNzacO4L0FG3j36w1s31PCtj3FDOnahpdmrQagVbM0bnhlHpt2FvHe1UfRO68FxaXl3PSfr9hTUsatpx3MhU9OY0PBvrr1Xzz/JScc3IG0FK+Hf97qHZz60Ce0zkpj5o3HAZDiJ/83/ecrvt28i2d+MjL0hWDHnhJemL6SbjlZnHxIx0qve/7aHXz+7VbOGdGVtJQASzftoneu976LiIiI1BUl4Ukk/MbMm04ZEGoP71+O1dv8g+FdQ88fPncYlz8/64DjufjvM2iWlsIXvzmGuat2hJLpaF6ds5b8tln8cfKSCu1LN+0OPd+6u8ibdAiYtmwrvfNaMGf19tAXhLF9cysk4EFX/2sO1x7fj827i/jenz8DvLKaY+//kJSA8fZVY0gJGM98vgKAnje8wY9GduOycb3535y13PXmQgC+N7QzbZqnM6ZvLss376Z1VhqT/js/VNbz4eJNfLR4E8cNaM/fLhi+v2+biIiISLWUhCeRaDXhULHHO557NMcP6sjlz9dOTHtLyjj63g/pmlN9jfjKrXuqXH/9S/NCz8v9CYcKS8pCbXe/vTDqfq/NWctrc9Zy4/j+FdqXbfYS/J2FJbTOqliG89wXK0kJGM0z9v0Vf/nLNQA8/smySudYtnkXHy3eBMCnSzZX+TpEREREDpSS8CRS7g9WE6iUhIc9389j/+GHg/nv7LVMWbSpxvtu3lUU19CG/5m9tsJyp1aZlWrWgyb99yuWbNzF5IUbQ23ResHDvRZRMhN0+sOf0iqrci3801NXcNbwLtWFDcCzn68MPY8c5lFERESktqnwNYmEhiik4pTzFcpRajBcYbi+7VtSVl55hs2g9NQA/Q5gQp++7VvQsdW+GyX/ev6hMUtnAModPPXZ8mp7z8PNW709avvyLXuYE2XMdIB/zYhdQhNLRowRZkRERERqi3rCk0i0yXqgYuJdoVe8Bvm4YbgYOfjC208M9f7mT3w9/oOGefPKMaEbJIPufGNBzO1bZqZy9XF9ufW1r+M+RxXfIWpVVnrFnvDi0nLO/dvnrNtRyCPnHcrs1dtJDRjnjOiWmIBERESk0VESnkScxaoJD3tOzerDgwKBfXXYkQ60/KJPXotKCTgQtQ3ggR8O4fShnQEo2FvKH95bfEDn3x8/Gd2DJz6tXBsO3s2k89fu4OBOrQBYtH4nM1ZsA+C1uWt59KNvATh5YEdaZaVFPcaN/5kXKnHpmbtvOMb0lAA3nNyfMX1za+21iIiISMOjJDyJBHvCBwRWwBd/DbV/t2gJG1KK+Kh8UI0S73ABM7q0qZsJeDrHOG5qoHJZx6iebRndu11oecKYnuQ0T+Om/86vsF1GaoCi0vLI3Wvs4+vGcfKDH7OzqDQsLqO6EQg/XLyJ3nktKCwu59SHPgm1Pz11eeh5QWFJ1CS8vNxVqDH/NmyEGID/fLlGSbiIiEgTpyQ8ibTNaQ3bYGRgIbx5Xaj9coA0mF3eE7OL9uvYAYOrju1Lq2Zp/O3jfT3Ao3q2rXK/6088iN+/tW/UkubpKewuLquwTawyl2g94S9MOLzCcrP0FM4flV8pCa+typOuOVm0b5XJzo27Qm1m1dfW3/3WIu5+axFPXnhYhfbCkn1fDC59ZibN0lM47/Bu9M5tyZ1vLqCwpIxZK7dX2OecEV25+Ds9mbJoI799fUGVXy6c/2ba/n7bEhERkQZBSXgSGXfGT5nx7430zS4lu9m+HtZdO7bSYtGL5LCzYn14DcZKMTM6tW7Gb8YPqJCEP35h1eNhp6VUPMcJAzvw8qw1cZ1z257iuOOrpBay8CcvOizmuqpuGg130VPTY677el0BALuLSjksP4fPlm6Jul1uiwx657Vg6Sbvi0BhSRkfLt5E/44tadc8IxTL9OVbuejJ6WSkBvj4+nFkpeufp4iISGOl/+WTSGaLNgy/6N5K7btWLKLFohcJmKuQdteoJjzGxtUlepEjhYw/pGPcSfjPjurFza/Or37Danx83TiOvPuDGu83rFsbAJaE9YKD9+Ulzhy8Sg+ePYQr/zGbhet3snD9TgCuPKYPUxZtZM7qHaHtUvyynHT/vXx/4UbeX7iRnObplJaVc/rQztz23YG8+/UGdhWVsqsIfv3yPB48e+iBBykiIiJJSWOxNQCBFK9XPJWy/S5T2N+c84iw+m2AQV1aV9omVqd1vL3Nkf50TsXks3WMmx+rE+vG0FMHdyKlBu9jVnpKpRFTAIZ2bVOp7YSDO9Arr0VEHN6frZtVfB1bdxdTUFjK01NXMOHpGaEbPgEK/Fk8RUREpHFSEt4ABFK8BDCF8go9uHVdNdy9bRbdc7IqtOW2zGBot9Zx7V+TRDfoNyf359TBnSq0tczczyQ8yvl/dlQvbjj5oKhfZp6IUZpjRK97T40o1Xn8x8MZ0Cm70nmD5xrStTV3nDGQ4we0r3Ssd77eUGG5pCxB4zGKiIhIvVAS3gAEAsEkfP97wvfHdSccRGqUYUTu/v4gfjK6R7X7709HePDluQMsCu+WkxV10p1LjuxB2xYZlXrJHzx7CK2aRU/2I29EDUqLeG+Co8REXqLwmy1/NLI7153Yr9r4S8oOfGQYERERSV5KwhsA88tRUkhcYnb/WYMZP6hj1HV92rdk0qkDqj3Glt0HcGPmAZh547G888sxUcthgr3UkUn4d4d0rvKY0b4URJaoBIdkjOw1n7+2oMJyPLOeKgkXERFp3JSENwDml6NEzqRZk17xmnag16QExMUYo3BvjB7keGSk+r3/MbrTbxzfP+a+LTJTY05AFEzMj6rhON3RXmLzjFSahZ0n1T92TvP0CttdcmTFXw1ivaZws1Zup7gWxkkXERGR5KQkvAEIpHgjmKRTCpsWhR7dy1fRy9bQy9ZUaGfTInrZGlqyZ7/PGZ5IjsjPASqPlFKdyBk6R/euekxy2De75A0ne0n2TTGS7UuO7BnzGFUN3RjMfwd2bsWzF4+sNp6g7m0r1sb39m++PCXs14Jgch0+vOSSO07i0O45ETHE943og0Ub445PREREGhYNUdgApPjlKBlWAg+PCLU/BZDhLzxccZ/3M6DAZTG66I/stizatsggHk9edBgL1hUwLOzmyxcmHM68NTs4uFN21H12FpZGbS8Py8GvPaEf3x3SKep2AG9eeSSzV21nXL88wJvgZmy/XDq2yowr7nCRY5vf/f1BXPfSXGD/J8H52wXDue+dxZwyqCNfrdnByX7yHd6rHXmjptdW+YtLvKPGxHpfRUREpOFTEt4ANG/enC/afZ9eu2bQLiKZLi13pAQq9/0WbfqWbNvD+f1T+OEpY2mRUflSnzuyW6W2cf3yQolwUErAGNK1dcz4YpVNhJepXD6ud8z9Afp3zKZ/x31JfnByoapcOqYnfw0b1i9833BnHdZ1XxIe1t4iM/6//t3bNueP/tCJxx/cIdQenigHS3iqy/PjvWE18pcEERERaTyUhDcQI3/xRNT2WBfwm0mDGWjLyc0yurdtXneBAWXl0ZPF2kwin7hwOD95akaFtl+f3D9qEl6V8BFNBndpxc/H9uKgDi2B6HXf1Sks2Vf3HvyiU91MpnEP3agcXEREpNFSEt5IFeFP8FO2F8oqTvySSimlpOxX0hlNcYyRPGLk5vvl6IPak52ZSkFEicbVx/Vl485Cnv18ZZX7v/izURSXlYdmrQSvx/z6Ew86oLjKoryJ1eXYkT31/dq3ZNEGb8bNXrnNaZ2VzswV29QTLiIi0ojpxsxGqth5Sfj5C38Ot7er8FiSeQGT068htbzogM7Rs53Xw96vfcuo60/zJ905bXDsWvCaiFbP/X/H9OHG8dUPlzg8P4cjerWrcpv9KReP9StAVSJHRznNr5U/uFM2718zlj7+TZ+1+SVGREREkot6whspO+gkir75hvSAq1wcUV5Kz8B62hatAqLPEhmPP/xwCH+ZspSJJ0XvTR7ctTWfTjyavJbx3RRanVhDIYYnz3d/f9ABHL/icqdWmazdUVjlPtHq4avL5SPLUX4yugftszMZ2cMbRSX4ZeNAJywSERGR5KUkvJE6/EeTgElR182adCjDAkv4zuZ/weT5+32OwcAjnYG5b8bcpuopcGrmtuw1rCzdQ05WOkz+MtSeUl7O1alLAThr55cwef+O32n7Xn6Zuoa3yw7jxkt+yCffbObPU5ZWuc+GgspJenU96tnNKv6za5aewpmHdqm0/wcLN7FgXQGXjulF15yKQyTG4pxjb0kZmakpzFixjYzUAP06tIw5brqIiIjUj4Qn4Wb2B2APsAsvj7vKObfezPKBt4D1/qYznXPX+PsMAS4HlgF5wK+cc6VmlgncC6wB+gB3OecWJ/DlNEjFme2geAnDt70BH71R3+HE7XTw/sYWAx/ta08F/i/4N/kj9lsn4MpUOCowlyG9LufzpVuq3WdUr7Ys37KHbmFJcnU3ZpoZB3fKrjSTZlCwWuW9BRsAePbzlSy8/cS4EumfPj2TDxdv5JRBnXjlyzWh9jevPLLC6DM1VVpWzqINOykrd3RolUley8xK67fu8WZIzUxLIbsGkz2JiIg0RfXRE77bOXcjgJldD/wGuMJfd5dz7qnwjc37bf5Z4Fg/Wb8P+DHwOHAVsNI5d7eZHeK3HZmQV9GAdTv7D8z74gUGdGgR1+yNDUG588pu9ncccIANG9bR/usnaMUuryGOY111bF/aZKVz1vCuobaMtOpvtahqwp5o62597WtaZOxLwg/t3oYTB3ZkycZd7Ni778bbYOIenoADfL22oFISfsMr8/j3jFU8fO6w0LCLBYUlnPanT1i1bW+FbcNr39NSjE+uP5r22V4i7pzjlD99wsL13s2lKQHjbxccytEHtY/9BoiIiDRxCU/Cgwm4LwDBjAeAU80sF2gFPO+c+xroCTRzzgV7yD8FzsNLuMcDN/jHnWdmg80s2zkXvYtRAOjUcwCdet5e32HUqtq4w3j9/K9o//UT3qRIcWqfncl1ESOsnHloF16dvZbxYbNpRqrqu0+0VS9Mqzj6y1OfLeehc41Ln5kZV5yl5ftq13cWlvD12gKe/8I75tNTV4SS8EXrd7J8S+yZVtNTAhSXlfOjx76geUYqnVtncvVxfVm4fidmkJmawt6SMuavKVASLiIiUoU6ScLN7G0g2v/Ak5xzr/rbtAaOB77vr9vkr59vZu2Bz81sKF75yc6wYxT4bVSxrlISbmYTgAkA3bpVnqRGxKV4N5C2pQCeP5vvbtrFIWm7+WfZONjcL+7jZAEv/iAPKIPNS6Juc/MRGVzz73Vc/J0elbZpV7SKHArYSsWe657tmnP2iK7c985iikrLmb9mBwC5LTPo0sab2OjLldujnm9PcRl7ir3hHc97fBpzVm0PW1fKmX/5zEue/RKZ5ukpzLn5+ArHCJhxxxsLePyTZSzZ6H13nrMKiku9XvKM1AAXf6cHD32wRLeUioiIVKNOknDn3AlVrTezVngTrf/EObfV32c3MN9/vsHMNuDVjK8GwsfAywY2+s83VrEuMqZHgUcBhg8frhxBKunSoT0FLots2wOL36QX0CsFjkuZBQ/dV6vnGgZ8kAFM9x9hrgAuyzC+X3wrs92+mUbz2zVnwphe/GnyEopKy/lkyWYAzhrehWtP8Hrj/zJlKb9/a2Gl89362tfc+trXUWOZFSVx311cRmpK5d8Xbji5P2cM7UxJWTm3vPY1c1ZtZ1eR98vBkX1yQxU8VQ1x7pxjzuodoTKanu2a0zUni+LScpZv2Q1Ay8xUmqWl8M3GXQzt2jpqLCIiIg1ZfdyY2Q54ALjOObfGzL7vnHvJzC4AvvTLStKALsByYCWw18w6+CUpo4HX/cO9DowCPvZrwueoFEX2V7vW2ay64H3Y+Q3ZmWkUbF5F8eR7SMtsRqsE3mhYtH0dGeV76B1Yw+yyfUl4WoqX4e70JywKJs+tmqVV2iaatBSjpMzLjjtkZ/Knc4fyg0emhtYfP6A9yzbv5puNu2IdgpSAMbBzKwDaNk8HvF52gP4dWobq6MMnGlq2eTf/+XJNqK78vQUbQvXjAM3SUphx47Fc9OR0pi3fWumc3xvW2fvFIE5dc7Ji3hj68TebWBFWbpMaMIbn55Djv5agrPQUjSgjIiJ1qj5uzHzHP+9z/k10O4GX8Hq8bzSz2UBv4Cbn3AoAMzsPuMPMVgApwN/9Yz0I3GtmN/r7XJzA1yGNUNdeAwBv8p9sgO9cmvAYFj50LoM3v45FFHWkRfQGZ6WncPZh3fjesH3DGzbPiP1P+rbvDuSYg/KYv66AAR2zaZGRSv+O2azeuof8ds154Owh/OzZWVUm4RXj8RLu3UXel4L01EAoyQ+P/J63F/LGvPWRuwNeCcvekjK27i4OzRraPD2F3X5iD/DyrDW8PGtN1P2jadcinU8nHk1GasUketXWPZz/+LS4jtE8PYU3rjyS7m2bs2rrHjq1blbtTczbdhczbflWnPNKhIZ1a31ANwqLiEjjVh83Zg6L0T6ZGCM8O+dmEyXBds7txRu6UKTRcOYl2ylUnAgoPSIJP/HgDkw6teJsoScf0pGVW/ewY29J6MbLoGZpKeRlZ5KXvW94wTevrDiYUE1SxuCXgrXbC0PLZf4NoBt2FPLkp8tITw2wxl9/5qFd6O4P5ZiVkcpZw7tw2kOfsmzzbkrKykMTH037zbGkBIz1Owq54ZV5bNsT/42yC9YVsHlXMf1ufIuc5umUlpVTWu4oLXeh42emBfjesC6s2baXDxdvArzyl1Q/yd5VVMru4jIWb9jFnNU7+L8XvDHpO7duFjpPr7wWHNU3l4M6tGR0b28m1ite+DJUIgTw8mVHMKxbmxq8oyIi0pRosh6RJLOzyOtHjkzCTzqk4mgrudmVZyJt1SyN6/3RWl6YtjJUm50aMA7q2LLS9pFq0nHbwU/m95Z4vdYdWmWGSj3+OWNVpe2/P6wLo3q1rdAW/GJRXFZOSZn3etNSAqSnBshv15znf3p4/AEBx//hQxZv8Hryt+4ujrpNYUk5vzvjED5YuDGUhL/4syPo18F7f3769Aze/XoDhSVlTF26L6les31vhecf+fvOufl4WjVLC63PzkyloLCU1dv2MrBTK1IDRiABQ4E659TzLiLSgCgJF0kym3d7Pb+BiCT8uAHegEN/Omco/529louOiL9Oetak4+KaQCey5KUqVx/fl8N65FBcWk52szRG92rLX6qYYTRavXpaqtf21lfrKfVrxquqa6/OPWcO5v2FGzlnRFfSUwKkBgKkpJj3JeSmtypsG56vBqI8v+KFfbOynjOiK5eP641zcOTdH1Q4zp7iUlo1S6PI/zIysHMrPlu6JdSDntcyg7euGsPr89bxj7AvRt3bZvHHc4ZWes/Xbt/Lq3PWUlpWTu+8lpw4sEO1r3vb7mJOevBjzhjWOfQlTEREkpuScJEkU070cpSgUwd34tTBnWp0zHhnsLxxfH8Wb9jJFUf3qXbbrPRUTji4YoJYVY9vtBFOstK9j6AH3vsG8GqxD6Q3d3DX1gzu2jrqujF9c0O910CFGu/wc0ar/e7ZrgVd2nilNJNOGcBt/9s30ky5g//NXcvaHV7ZTV7Lir9QbNxZxOxV23j8428rjMH+9boCFqwrYFCXivHe+/YiXg6bbOnuMwcxskcO32zYxZi+uaSnBrj37UU8PXU5DmiZkcphPXJYX1DIX6YsDSXhc1ZtZ9Kr89nrD03ZLac55x3uDc8aMGNY9za0qOIeAhERqVv6BBZJMmV+Eh7AkZ4aCNUyJ0L3ts358NpxdXLs1CjJ7bUn9OOf01eFRlM5qm9unZwbKte7h89MGh5atC8B6amBqM8Byssd1784N7Tu8nG9+c/stRW2+clTM0LPn/7JCH7/1kLmry1gb9gNqEHb91asgb/OPzbAbd89mAtG5fPqnLUU+KPk7Cws5b9h5zv3b58D8NnSLRWOs3jDrtCMqgDH9s/jsR8fVun8IiKSGErCRZJMeSgJL8dVNeB2EgpU0YsdmbwCHJafw2H5OXUZUkhkaBXLUSzq86CuOftuysyITMKdY49fivKvS0fRp31LrjymDw++/03UOAZ3bR0aEnHBugIO6phNq2Zp/P6thXy1ZkeVX7r+8+UaLhiVT6lfP/+bk/tzxxsLKmwTmXxfNrYXfw4rExrRI4dpy7by3oKNrNyyh25tsyps75zjmn/NYfaq7Vx7Qr9K9yIErd62h8ufm8XWPdFr771jeV8cXvlyLau37cHwfjlwzlHuoKzcUe4cznnvY7nfXu4chleCdergTgTMMPN+pQiYETD8P/1HwFtukZka968+IiL1TUm4SJIpCytHOZAcvHduC77ZuIue7ZrXUmTVi8xfW2am0rVNFr3zWtArt0XC4ohHrMQ7Wkn6kK77Rjk5vGdbeue1CM0aWlruQtdpcBdvDPVYde0tM1NpHjYG+S2vfc1fP/qWT68/OlRPX9VQiMHynWD9/LED2ldKwp+7ZCT/mL6K1+Z4veNdc/Yl2R1bZfLURYcxYNLbAPxv3louG9ubJRt3MXf1dsb1y+P9hRtD5TAvf7kmZhL+yTebmbN6R8xYg8J/Baipv328jL99vCzu7VMDxnOXjGRkz7bVbywiUs+UhIskmfAkvPwAsvA7zjiEP77/DVcc3bv6jWvJhoLCCssv/PTw0OQ+9a2qcpRYveJBqWFJddecLN67+iiOvncK3/rDK4KXPAdLWaLVvwcMXv75EaSmBDjv8O5s3V3Mlyu3sW5HIZt3F4W2C05qFM3grq0qbBPZKz+iRw6je7dj2rJ9kx5FDm2ZlZ7Kj0d15+9TV/DmvPWs31HI01NXANAiI5Vd/rjvQOi1RROcpOn7w7pw5TGV7yGYuXIrT326nBVb97DdH2bypZ+Pwqxib7aF9WqnBLxyoCUbd3HpMzMB74tDTvN0ysr39ZiX+b3n4T3p2/YUs6e4jAXrCpSEi0iDoCRcJMmUOy+RMxwHUowyokcOz14ysnaCitO67fuS8DZZaRV6Yetb66yKs2KGdzjHukkzKFo9e/Am1FJ/gqKUsP3Ct7/kOz147JNlPP/Tw+nT3hsG8ai+uRzVN5dht7/L1t3F/GNa5SEdgzq2ymRDQSHlDlIDXkJdGiMJX7FlN+D1uAc1z6g88+fgrq1h6grmrdnBvDX7erPDE3CAKYs2MfS2d6LGFRyaMi87o1JJC0C3tlmcMdSbSGr2qu3ktcygU9hY61UJL8O6bFxvzj+8e7X73Pba1zzx6TKmLN5Er7x9v7qkBIxh3dpoBlQRSTpKwkWSTPjoKO1aZLBpZxHtWqRXs1dyCO+5n/rrY5Iq8bl8XG+mL9/KL8Z5vwxYjHKUaHX40UpEgk3Ffm9xICwfDh928Odje3Htif0qzeAJ3gRKAH+aXLF+PKd5emic87H98ujUKpP73l1MqT8ZUrAnPC0iCQ+G/t0hnVmxZQ/pqQHGhN3sGnwVpwzy6qx3+DeB3vzq/ArHufaEftzz9iKAKidLSgkYQ2OMRhNuSBzbhGvbfN8IMx3CJpeqSvAtn7JoE1MWbaqw7ofDu/L7MwdRVu5YumlXlb82BMzondei2hlSRUQOlJJwkSQTKkexcm459WAe/mAJl49LXEnJgQjPbZIpAQfondeCT64/OrQcbWxwgLIoSXhqIFp5Seye8JE9c+jcuhk92jWnTVZ6zKEbD+/ZlpdmraakzJGeEuDBs4cwsmdbWmSk0vfGN/2tHCl+Oczc1Tt4Zupyikq9Xui0iLiCkee2zOD20wdGPSd4N8mePrRzaHntjr389cNvQ8vZYT3pN50ygDPCtg2XkRqgeR0Mc9imeTr/unQUm3cVMa5ffCPmhL/Ho3u3xTC27y3mqzUFrNrmDQ35m1fm8Y/psX91CDrz0C7c+4PB+xe8iEiclISLJJmysNFRxg/qyPhB0W+MS04NZzSXijXh+55H6yWN3hMeTMKDPeH7tjmoQzafTjy60j6R7jtrMLecNgCHV7sd64tLcDzvj7/ZzMffeLN4pqVYhVp1iN6LH9x/V1EpeTF6lU8d1Ilpy7ayt7iM/LbNOTisjr9Vs7TQaC6JNKJHzUbNsbCq/+cu8WZanb58Kz94ZCpF/ogzwZtpu+VkkZVe+b3eW1LGii17QttF+v1bC0M3vEYzrFsbHjx7SKWSpgXrCpgaMWpNVdJSLGnupThQ/Tq0DN1QLCIV6V+GSJIJT8Ibmip+5U86scYJr3wjY/TEONgJXRx2Y+b+aFntkHrGdwd3Zv2OQgoK95WGjOjRttJsm7Hu4330gkN5Z/4Gzjy0S9T1Azu34pXLRoeWF6wrCD2PVg+fjKLdQRGsmd+2u5jpy7cyY8U2AP7ww8Ec2r1ykj9n1Xa++/CnobKfSM9MXVGpbj7c6m17ueW0gyt9abn0mZms3Lonxl6N26AurXj1F9+p7zBEkpKScJEkU+736B0VmAuvX1PP0dTMjzZvYHiq8VjpyfUdSrVijYhywRH5rNm+lxMO7sDQbq1j9gIHy09e9XtGU6Lc0FlbWmWlcV0c09HH+g50RK92HNGrXdznC0/uI3vbk1W0LyDBXxa+3bybHzwyNdQeazz74GvdXVRGYUnFiZScgz3+7KNTfjW20peu0x76hG17SqL+krLNr+8/d2S3Sl/yIi3dtCs0EVNDVlZezldrCli+eXd9hyKStJSEiySZ7l26wkoYGFgO0x+r73Bq5BjgmFTY7poD59R3OFUKH0EkI21fYjSka2v+eemoavcP1kK/PMsbU7tFZv18nP58bK/QGOO1NblTeKLYUHrCy6Mkv71zW/DD4V1ZumkXxWXlzPXHNY+VhAe/fCzbvJuDbnor6jbpKQHyo4y9HxyWMtqwosH7DG44uX+otKix21VUysCb36agsJQH3/sGMzi2f3sGdMqu79BEkkbT+DQQaUCOP+f/mDM5h4PauKgjaiSzmZNf4tDCqbS25O/96t62OXefOYjszLT9qlmddOoAXpuzNlSCc8xBebUcYXyuP/GgfUl4LR0zLTVs8qIoN6Umo74dvOEfe+buS5ADAeP3Zw4CYGNBISN+9z4Qu3Qo/AtHekqg0uRTAONjTF4U/CUkWk94sK0ufy1JNuHv5R/eWwzAu19v4LUrVJoiEqQkXCTJZDZrzuDxl9Z3GPvl60+XcmjhVE5P+QSeOqW+w6nWWcEn+zGp40H+I2T9AYdTwQtpW0i3EtZtPgmmfV7ltuenfMUK1545bnitnDu9AZajnDmsCz3bNadHjBliwxPv6nrCAaZcOzbucc3Djx8tCQ/2jjeQ7zO1ItovKNv2FNdDJCLJS0m4iNSaAYcMhU+gk22F5R/XdzgN2qjgjyBrv4HYA3IAcHvw3k4H3Hrgv57kAEszvQMG/tEwkvAAUNVXkBxgSYbj+bJjCASOjL5N83TSUwIEAtR4RJhggh2tIqgp9oRH+7WhqhlYRZoiJeEiUmsOPeYsVnbKp1NGYYOpJU5W6xZPZ9OKhRzcsWW1I68UfvkvMkv9EU1cWZXbxsOAUCrfgEa8qYoBqQbHp8xgZ4xkuHlGKh9eN5aAWY3HuQ+Vo0Rk4c65UMlSU5oAKNrMs8WlSsJFwikJF5HaY0a3ASPrO4pGoWOPMcQ7Qnzm+PsoLy2lCeV4NbZ3x0aa/bE/6ZTEnDwJoGOr+EtQwgVi1IQHF82iJ6aNWcuMVHYWlWLm/UKwbU8Jw3/7btRtB3VpzWMXDK/y2sRrQ0Ehny7ZHHPIzoYuNcUY2zePVlnVDW8qyU5JuIhIIxBI1cd5VQIZWQCkUxqzJvyAju8nj5GjozTFUpSgh380jE+WbGZ073bc+cYCFq7fyeZd0evCJy/cyJJNu+jQKvqEUkEt0lOrTdT/74Uv+WLZ1v2OuyE4a3gX7j5Ts7o2dPrUFhGRRi813evhzqKI3Pd/CbU8VOB1e9ezIjWDDYuakbJhXyJZUlbOAFtOWiAA6+bW6jmT3ZiWMGYowDpG/6AVBYVZUbeb+NJcVm/by1UPLK/2mK079+O5y4+p8leFTTuLADhuQHtaNrIhIdcXFPLZ0i1sKCiq71CkFjSuv50iIiJRBFLS2OpakGO7aLHgn7V+/OPB+x918huV1r2R4T/5a62ftsFIxbs5NppHATJirIywYmMeJaULSa+iZj84i+2kUwbQNSd64t9QfbZkM58t3UJR6YHf+yH1T0m4iIg0ehYIUHD2f9m5Zibd20YfxvBArPvsBfZsXUusO1mzM9PIbRFnpilRla//iu6Bjews3E16WuxJf4KjsKRVMztpQ5Se6r2mbbtLmLliWz1Hk9yapaXQv2PLpL4XQ0m4iIg0Cfn9h0P/2hlLPVLHoefVyXFln523dKYVu9i9YwvpabHTF1dSRDolpLliKE3eBGx/NAuUkk4JyzZs5Zy/fFjf4SS9kwZ24Ecju4WWe+S1JrdV8vw6oiRcREREkl4R3tjtHR4bUuV20wAygQfqOKB6cDCwuOp7VyXcEv/hmz70TnK/e1m9hRNJSbiIiIgkvWV5x9B6wytxbWtmpKYYjasfXOLlgNKyyqVhLTJrNglXXVMSLiIiIklv5GWPAY/VdxjSABgQbRT1/okOpBqN764FEREREZEkpyRcRERERCTBlISLiIiIiCSYknARERERkQRTEi4iIiIikmBKwkVEREREEkxJuIiIiIhIgikJFxERERFJMCXhIiIiIiIJpiRcRERERCTBlISLiIiIiCSYknARERERkQRTEi4iIiIikmDmnKvvGBLOzDYBK+rp9O2AzfV0bkkMXeOmQde5adB1bhp0nRu/+rzG3Z1zuZGNTTIJr09mNsM5N7y+45C6o2vcNOg6Nw26zk2DrnPjl4zXWOUoIiIiIiIJpiRcRERERCTBlIQn3qP1HYDUOV3jpkHXuWnQdW4adJ0bv6S7xqoJFxERERFJMPWEi4iIiIgkWGp9B9BUmNmxwPeAjYBzzt1azyFJnMysF/BbYBbQBdjinLvNzHKAu4BvgT7ADc65Df4+1wLZQBvgHefcq377EOByYBmQB/zKOVea2FckVTGzZsAXeNftV2aWCdwLrMG7znc55xb7254HDAXKgKXOub/67fnATcASIB+4xjm3K8EvRWIws37AOcBe4CjgFrzP5krXzMwCwO+AnX774865z/3j6HM9Sfmfwfl4Q9L1AS4GmqHP7AbPzDrg/Z882Dl3mN9Wa5/TVf2br3XOOT3q+AFk+Rc5w19+CTimvuPSI+7rdxjw3bDlr4FDgUeAs/y2U4Fn/OcjgTf856nAN0ArwICvgA7+uvuAi+v79elR6XrfB/wduNdfnghc5z8/BPjYf94FmM2+sr7pQB//+VvACP/5FcDt9f269Ahd3xTgdSDgL3cEcmNdM+Bs4M/+8xxgsX8Mfa4n6QPoAGwNu8b/BX6kz+zG8QDO9K/fjLC2WvucjvVvvi5ei8pREmMUsMI5V+QvfwqMr8d4pAacc9Odc/8NawoAu/Gu4VS/LfyanhJsd16PyQK83raeQDPn3Poo+0gSMLPz8a7LsrDm0HV2zs0DBptZNnACMNP5n9T+NieZWRowDu/DHnSdk81heMnVFWb2a7z/zLcT+5qFX/+tQCFwMPpcT2Z7gGK8nm2AFsB89JndKDjnXsTrpQ5Xm5/Tsf7N1zqVoyRGHhX/whT4bdLAmNkZwNvOuYVmFn5dC4A2ZpaKd20XhO0WvN6b0N+DpGVmA4D+zrkbzGxQ2KpY/35jtbcD9oZ96Os6J5fueAn0Oc65HWb2LNCW2Ncs1nXOjdEu9cw5V+CXl/zTzNYBq/F+tdBnduNVm5/TCcvZ1BOeGBuBlmHL2X6bNCBmNg7vm/Mv/abw65oNbPN7UWJdb/09SG5nAIVmNhH4DjDCzK6i5tdzM9DMzCyiXZJDAbDQObfDX/4EGEjsa6Z/zw2MX8d9LTDeOXch3r/JSegzuzGrzc/phF13JeGJMRXobmYZ/vJovJpEaSDMbDzez1pXAh3MbBTeNRzlbxJ+TUPt/k9e/YGP8G4G2uvfVBK5j9Qz59wdzrnbnHN34SVm05xzD1Dxeh4CzHHOFQBvA4eGfYiPAt50zpUAH+CVPYCuc7L5AmhrZin+cne8UoVY1yz8+ucAmf72+lxPXp2BrW7fDZTr8K6bPrMbr9r8nI71b77WaZzwBDGz4/BuJtgElDjdRd9gmNmhwIfADL+pOfAw8Crwe2AF0AuY6Cread/Gf7zpKt5pf4W/Tw660z7pmNn38UZDSMe7zv/Bu+t+HdAb+J2reNf9cLy77he7infdT8L7T7wbcLXT6ChJwy8rOxrv87gb3r/J9kS5Zv5ICXfi1Rl3A/7m9o2Oos/1JOR/wfojXi3vdrxfOq4CitBndoNnZkcBFwAnAn/Bu2EWaulzuqp/87X+WpSEi4iIiIgklspRREREREQSTEm4iIiIiEiCKQkXEREREUkwJeEiIiIiIgmmJFxEREREJMGUhIuISEKFjdFdK9uJiDRESsJFRBoIMxthZlPM7DMzG+O3XVUH57kq7Hm2mX1Yi8fuB9wR0WZmNtd//qaZdfdXdTGzu/2pxUVEGhUl4SIiDYRzbhowBfjMOfeR33xVHZwqdEx/1rmxtXFQv2f778DvIlYNAr72k+2OzrkV/rlXAJ8Dt9TG+UVEkol6F0REGigzOwtobWa3AAudc/8ws9vwPtvLgJ3OubvN7CK8GeAewZspsB9wNnA/8BlwCHCfc262mU0IO+bnQB7e7IOt/XNOAPrizUSYC1wNnAz8AXgNaAkMAM51zi2PCHkcsN5P7DGzTOBFvGnCt/jnyzKz/wHXOee+Bt4EHjazSc658tp550RE6p9mzBQRaUD85LiFc+5X/vJy51y+//wE4Brn3PH+8hTgKj+5ngLc7Zx7w8yGA+uBPOfcLDMbBvzaOfeDyGOGL5tZf+CfzrlBfvtfgC+dc4+a2VPAVOfcX/0pwMudc8HppIPHuRLo65y7PKL9LeAS4KfAHOfcyxHrNwKDnXPrDuzdExFJHuoJFxFpPAbh9SRP9JdX4fVWBy0AcM7NMLP2wNlmdhKQHbFdLAOB5WHLS4DBYcuL/T83AflR9s8ASoMLZnY5cBIwAngIGA1MN7Pezrm7w/YrAZrFEZ+ISIOhJFxEpGErMzPDS8DnAKOcc3cBmNnReIlyUPhPnxOBbc65O8ysLzAybF25v/9g59ycsPZ5QI+w5T7AzBjHj2YVXumLt7FzD5vZV3ilMdcC7znnTg7fwX9tLYC11RxbRKRBURIuItJA+GUkY4B0M/uOc+4T4HXgXgDn3DX+CCp3AjuBNsBEMzsO6A78wsx+75zbBLwE3GlmGUA60N3MjnHOvQ/M9I+xy8wGAq3M7GfOuUfM7E9m9gCwAygGnjCzEXhfAs43s0XAqUAbv0c7/EvAW8CvI17WaOBjYBTwRZSXPRiY4pwrPJD3TkQk2agmXEREEsa/SbS5c+6hOLbNBP4G3BTlJk8RkQZNSbiIiCSUmQ1yzs2NY7vOwF7n3NYEhCUiklBKwkVEREREEkyT9YiIiIiIJJiScBERERGRBFMSLiIiIiKSYErCRUREREQSTEm4iIiIiEiC/T+N4++v6HDEBgAAAABJRU5ErkJggg==\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "_, ax = plt.subplots(figsize=(12, 6))\n",
+    "res.plot_objectives(ax=ax, lw=2)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "# Simulated annealing\n",
+    "\n",
+    "This criterion accepts solutions when the scaled probability is bigger than some random number, using an updating temperature that drives the probability down. It is very similar to the `RecordToRecordTravel` criterion, but uses a different acceptance scheme.\n",
+    "\n",
+    "In particular, a temperature is used, rather than a threshold, and the candidate $s^c$ is compared against the current solution $s$, rather than the current best solution $s^*$. The acceptance probability is calculated as\n",
+    "$$ \\exp \\left\\{ \\frac{f(s) - f(s^c)}{t} \\right\\}, $$\n",
+    "where $t$ is the current temperature."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Found solution with objective 2874.0.\n"
+     ]
+    }
+   ],
+   "source": [
+    "crit = SimulatedAnnealing(start_temperature=1_000,\n",
+    "                          end_temperature=1,\n",
+    "                          step=1 - 1e-3,\n",
+    "                          method=\"exponential\")\n",
+    "\n",
+    "alns = make_alns()\n",
+    "res = alns.iterate(init_sol, weights, crit)\n",
+    "\n",
+    "print(f\"Found solution with objective {-res.best_state.objective()}.\")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 864x432 with 1 Axes>",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuEAAAGBCAYAAADIXG9VAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAABcmElEQVR4nO3dd5xcZfXH8c/ZkmwS0iukQxI6CZDQolQpShEsqIgIotGfiCIdpUqLVEEpoiCC0qUpHUKoCSSBBAghkJDesymbspttz++PubN7Z3b6ztyZnf2+fc0rM7c+U1jPnDn3POacQ0REREREglOS7wGIiIiIiLQ3CsJFRERERAKmIFxEREREJGAKwkVEREREAqYgXEREREQkYArCRUREREQCpiBcRNoEMzvIzF4xszfN7F0ze9TMhvvWP2lmNWZ2aJz9h5rZMjOryMHYno933iCZ2X5mNtPMFuZ7LEEwszvNbIOZnZ7i9qeY2d9zPKxkYxhmZp/mcwwiUhgUhItIwfMC3H8DZznnDnbOHQQ8CrxtZjsAOOe+BayMdwzn3CJgD+dcTSvHcqWZ3R+1+PvAG605bjY4594HzsnHuc3sfjO7MshzOud+CcxMY5dH8b0+QYzZzBb6v6A55xYCB+XynCLSNigIF5GCZmYlwD3Adc65z8PLnXNPAm8D16V6LOfc+uyPEJxzVU4znxU851yDc25zAYxjQ77HICL5pyBcRArd3sBI4JUY614ETvQC9bADzewFM/vYzG41s1LvNtnMnJkNAzCzcjO70SttedvMrjAzCx/EzM4zs6lm9rpXbrKPmX0POB04xjve783sAjNb6WXI9zOzxWa2wsx+4x3nATOrDJdMeNtPNbO3zOzPZtYh+kmZ2QQzqzKzOWZ2iJn1MrMZXlZ1jJmdZGavmdmrXnnO+FgvnFd+sTCcuTez/wuP1bfNTmb2spm94Y0pbpbWzC43s0ne7X/hXyG853oMcLr3upwZZ/+jzWyKd67/hvf31t3pPafJZvawmXWLGuML3n5TzOyqqEPvZGaPm9nnZhbzS5mZ7ekv1Yk3ZjPb13tN3/DGs4vvPVloZo+Y2d+8Y002s+3M7EELlUq9ZWZ3mVmZt88/gAHAn7xt9/WOGe9z+K6Z3WRm5d66cInVRWb2tJnNM7Nfxnt/RKSNcc7ppptuuhXsDfge4IDyGOuO8tb18x4vJFS2YkAFMAuY4NveAcO8+78HJgGlQDnwLnCqt+4U4BOgs/f4fOBK7/6VwP1R47jft/4EYK5v3WjgWu/+D4E5QGdvjI8Bl8Z53rcA9/ge/wY40rt/KtDLuz8MWOzb7lBgoe9xxHijxlrmjecn3uO9gLVA1zhjOhsw7/7pwIOxjhtn3+HAJmBn7/FZwKu+9b+OGvPV3v1S4FPgx97j7sBS37aTgf95r+f2QB2wQ5wxRL82EWP2jr0GONx7fCwwFyjxjWsl0JdQEuuPQK/w58Z3zDN9jxcCh0aNw/85vAx41XuepcBLwGVR+9/p3d8P2AyU5fu/S9100631N2XCRaTYPOFCaoAnCNVrx3I68E8XKlGoAx4HfuStOwN4zDm31Xv8N+9YqXgB6GlmB3qPfwQ84DvnI865rc45BzzsO2e0B4CTrflC0sOA17z7s4B/mNnbhIK+wWbWL8Xx+e0P7AQ8COCc+whYBhwXZ/slwOtm9iah2up90zjXKcB059xc7/FDwBFmtr33uMbLJL9B6D0LH/sAYAShL1c45zYS+mLm97L3nq8g9CViWBrj8jsO2Oycm+Sd6zlCmez9fdtMcc6tcc41OucuAtYDQy30a8pkQoF+Oq/LacAD3uewgdD7fkbUNi96/34EdAEyea9FpMCU5XsAIiJJzPf+3QFYFLVuILCBUOAV5q/7riSUHY1lEHCumYUDnu28Y4XXrQlv6AV+G1MZrHOuzsweAU4zs/eBnXyB5yDgFDM7zHtcATTGOc5MM1sMfNPMPgY+c86Ft30WuMM5dxOAmTlC2fV0DSKUlX3FmitxOhLKCEcws5GEMvfjnXPTLHSx4f1pnms3L1ANWwT0N7OdgZuBPZ1zC73SndN9+613ztWHd3LOvRN17Crf/W1AixKfNMbYK2qMa4DevsfRn4MfAz8Hxjjn1nmlPsPSPOca3+M13jK/KgDnXI33PmX6/ESkgCgIF5FC9wEwDzgSiG4vdzShzLc/kO3lu98HWBHnuEuAa5xzj0PTBaA9fOv6hjc0sy7AIF8wncwDwMuEMpivRp3zFefcjb5j90lynB8Tynw/6G3fj1CQ96L3uDzJWGoJBdZhPaLGU+ecO9Q3ni7E/mKwN1DlnJvmPU523mhLCGXCj/WdqyehAPM8QiU8C2McewmhXxbKwoG4me1KqKykOs0xpDLGpVGvRzcgUUed/YD3nXPrvMeZvC59fY/7AkvTPIaItEEqRxGRguYF2D8DfudlYwEws28SKlW4NGqX71lIJ+C7wCNxDn0/oax0qff4x4TqxMPrTjazcHb5HEIX8UGorrmzd46n4ox5OqHg/09R578f+G64xMTLiP81zvggVIJxODDaOTfbW1ZJKGMfLpE4JsZ+fgsIZaDNzHoRWVrxHrDYzL7ljacMeBoYFeM48wgFw+F10ecNvy5dzOzfMfZ/GNjfzIZ65+pHqJ67xDv2CDMLZ5yPjhrjPELlLHjP4TGgntaLHvP/gD5mNs47VxfgdWL8MuAzDxhtZh291++IOOc4zLsYNNr9wKkWuni4hFC9/z9a9axEpG3Id1G6brrpplsqN+CrhGqi3yR0EeXDwGDf+icJZSyvJtRJ5RNCQXCpbxv/BXHlwERgKqFA60G8CzG99ed5694gVBNe5i0fAcwGpgAXeLeVhC6g81+QdxHwVIzncR6hwHISoYC3X5Ln/QLwm6hlJwJfErqI7xrveU0llJWd6b0Oj3vbdvKO8QGhgP8R/1gJ1YS/6D3Pt/Au0owzlqu9fZ/xjlVDqJ4Z4EDgM+B94JQ4+x8FvEMo+J4EHOAtLyH0K8c87318gNAXjRt8Y3zBN8ZDvOU3eNt95p3/Tm9MM4Hdos69Z4zXpsWYCdVzT/bO9SZwnLf8FO+5rww/Z295F+ApQhe4Pu7dXwmc663/FaELS6cCuxP6DIffr4GEPod/JPSZfhe4Ce8iZO91CD+f4d5rE963V77/m9RNN91adwtf5S4iUtQsVEzbCAx1zi3O93hERKR9UzmKiBQ1M7vDq+sdBWwlfo24iIhIYHRhpogUu9k0Tyk/wYXaEYqIiOSVylFERERERAKmchQRERERkYApCBcRERERCVi7rAnv06ePGzZsWL6HISIiIiJFbsaMGWudc32jl7fLIHzYsGFMnz4938MQERERkSJnZotiLVc5ioiIiIhIwBSEi4iIiIgETEG4iIiIiEjA2mVNuIiIiIgkVldXx9KlS6mpqcn3UNqEiooKBg0aRHl5eUrbF0UQbmZfA74FrAacc+6qPA9JREREpE1bunQpXbt2ZdiwYZhZvodT0JxzVFZWsnTpUoYPH57SPm0+CDezzsDdwO7OuW1m9h8zO8I591q+xyYiIiLSVtXU1CgAT5GZ0bt3b9asWZPyPsVQE34gsMg5t817/A5wbB7HIyIiIlIUFICnLt3Xqs1nwoF+wCbf4ypvWQQzmwBMABgyZEgwIxMRERGRVlmxYgU33ngjPXv2pLa2ltmzZ3PYYYdx9tlnBz6WyZMn06NHD8aMGdPqYxVDEL4a6Op73M1bFsE5dw9wD8DYsWNdMEMTERERkUxt27aNE044gaeeeopBgwYBsGrVKr7zne/kLQgfNmyYgnDPFGComXX0SlLGA3fmeUwiIiIiRWPYxc/l5LgLJyauIP7f//7HsGHDmgJwgP79+/PQQw9x+umnA3D//fdzzz33cN1117Fw4UL++9//8tvf/pbjjz+eTZs28dJLL/GHP/yBSy65hF/84hfMnz+fuXPn8u6773LOOefQr18/Nm7cyJgxY/jRj37EjTfeyFVXXcVVV13FjBkz2LhxI88++yzz589vyoQvXLiQiy++mIqKioyfe5uvCXfObQX+D7jdzK4BPtJFmSIiIiJt37x58xgwYECL5YMHD24KwgEmTJjQdP/444/nK1/5CiNHjuTvf/87Tz31FGeccQa77LIL++23Hw8++CB33nkn9957L7W1tVx++eXcdNNNXHvttaxevZoLLriAPn36cNxxx/HQQw8BMHPmTEaNGsWhhx7KiSeeyJVXXtmqAByKIxOOc+4V4JV8jyORebPeZs3UhykfNIaxx/4s38MRERERSVmyjHWuDBo0iOnTp2e076677grA2LFjYy77xz/+wYoVK5g4cSIAe+yxBytXrqRfv9ClhaNGjQKgb9++bNrkv/wwO9p8JrytWL/wIw5c8S+Y+1K+hyIiIiLSJpx00kl8/vnnLFu2rGnZ3LlzOeGEE+jatStVVVUALF68uMW+sbqV+JeNHj2akSNHcvHFF3PxxRfzwx/+kGHDhiXcv7S0FOccy5cvT6sdYSxFkQkXERERkeLTuXNnXnjhBW655Ra6detGbW0tK1eu5K677mLAgAE0NjZy9dVXM2zYMDZu3MjDDz/MTjvtxEcffcSDDz7IoEGDGDFiBK+88gqLFi3iL3/5CxdddBF9+/blzDPP5MILL+SKK66grCwUEp900kk8/vjjbNy4kfvuu48xY8Y0HWv8+PEccsgh3HLLLUyaNKkpg54pc679NQoZO3asy/SnjUxNe+ZOxn14CdO7HcnYc58I9NwiIiIi6ZozZ05T+YakJtZrZmYznHNjo7dVOYqIiIiISMAUhIuIiIiIBExBuIiIiIhIwBSEB6blFbYiIiIi0j4pCBcRERERCZiCcBERERGRgKlPuIiIiIgUpPfff58LL7yQ2tpajjrqKFauXEllZSX//ve/6dChQ8rHmTx5Mj169GDMmDG5G2yalAkXERERkYK03377ceihh3LQQQdx5ZVXcvfdd7N27VpefPHFtI4zefJkZs6cmZtBZkiZcBERERFJ7MruOTruxrQ2b2xspLKykr59+/LWW29x3333sdtuuzF37lwmTpxInz59+NWvfsXAgQPZuHEjAwcO5Oijj27KhC9cuJCLL76YioqK3DyfNCgID1z7m6FUREREpDXef/99Jk6cyIcffsjo0aPZZ5992HHHHXn//fcZOHAg999/P9deey2XX345zz77LFOmTGHgwIG8++67jBo1ikMPPZRhw4Zx+umn5/upNFEQHhRTi0IRERFpo9LMWGfbfvvtx8UXXwzA9ddfz7nnnsu6det48MEHAVi3bh2lpaX07NmT2267jZ/+9KdUV1dz6aWX5nPYCSkIFxEREZE2Y/vtt+eDDz6gb9++/PznP6dnz55UVlYyZcoUNmzYQN++fXnhhReYPXs2P/jBD/joo48oLS3FOcfy5cspLy+nb9+++X4aCsJFREREpDBNnz6dN998k9raWq699lrq6+v5+OOP+cMf/sCGDRu46KKL2HHHHVm8eDFnn302DQ0N/OlPf+Ltt99m7dq1nHPOOQAccsgh3HLLLUyaNImJEyfm90l5FISLiIiISEEaO3YskyZNirv+oIMOarHsiSeeaLHs4IMP5uCDD87q2FpLLQpFRERERAKmIDxgpu4oIiIiIu2egvCgqDmKiIiIiHgUhIuIiIhITM7pF/xUpftaKQgXERERkRYqKiqorKxUIJ4C5xyVlZVpzcSp7igiIiIi0sKgQYNYunQpa9asyfdQ2oSKigoGDRqU8vYKwkVERESkhfLycoYPH57vYRQtlaMEzPSTjoiIiEi7pyA8MKH2KArBRURERERBeGDUo1BEREREQhSEi4iIiIgETEG4iIiIiEjAFISLiIiIiARMQbiIiIiISMAUhAfM1B9FREREpN1TEB4YdUcRERERkRAF4SIiIiIiAVMQLiIiIiISMAXhIiIiIiIBUxAuIiIiIhIwBeEiIiIiIgFTEB4UU3cUEREREQlREC4iIiIiEjAF4SIiIiIiAVMQLiIiIiISMAXhIiIiIiIBUxAeMMPlewgiIiIikmcKwoOi5igiIiIi4inL9wD8zOxK4FDfomudc6946y4AugE9gZedc896y8cAZwELgH7A+c65+uBGLSIiIiKSnoIKwgGcc4dGLzOz/YHDnHPfMLMyYI6ZvQFUAf8CvuacW2lmNwM/Bu4NcswiIiIiIukouHIUM/u9mZ1vZheZWWdv8XHAFAAvyz0HOATYEejknFvpbfcOcGzQYxYRERERSUfgmXAzewnoH2PV5cDjwELn3BYz+yXwZ+BMQmUmc3zbVnnL1gCbYiyPdd4JwASAIUOGtPJZiIiIiIhkLvAg3Dl3dIqbTgIu8O6vBrr61nXzlsVbHuu89wD3AIwdOzZ/LUqcuqOIiIiItHcFVY5iZjf6Ho4E5nv3nwMO9LYpB3YF3gS+BKrNbIC33Xhv2wKk9igiIiIiElJoF2bWm9lthLLZewK/BHDOTTWz183sOkLdUc5zzm0AMLNTgWvNbBFQCvwzLyMXEREREUlRQQXhzrlLEqy7Mc7ymYTqxkVERERE2oSCKkcREREREWkPFISLiIiIiARMQbiIiIiISMAUhAdOLQpFRERE2jsF4QFxalEoIiIiIh4F4SIiIiIiAVMQLiIiIiISMAXhIiIiIiIBUxAuIiIiIhIwBeEB0+WZIiIiIqIgPDAKv0VEREQkREF44NQnXERERKS9UxAeEDNlwkVEREQkREG4iIiIiEjAFISLiIiIiARMQbiIiIiISMAUhIuIiIiIBExBuIiIiIhIwBSEi4iIiIgETEG4iIiIiEjAFISLiIiIiARMQbiIiIiISMAUhAfMnKatFxEREWnvFIQHxGnaehERERHxKAgPmPLgIiIiIqIgPCDKg4uIiIhImIJwEREREZGAKQgXEREREQmYgvCAmarCRURERNo9BeGBUVW4iIiIiIQoCBcRERERCZiCcBERERGRgCkIFxEREREJmIJwEREREZGAKQgPmLqjiIiIiIiC8IA4dUcREREREY+CcBERERGRgCkIFxEREREJmILwgJiqUURERETEoyBcRERERCRgCsJFRERERAKmIFxEREREJGAKwgOjonARERERCVEQLiIiIiISsLKgT2hmJcDPgKuBw51zn/jWnQrsDTQA851zf/WWDwMuA+YBw4DznHObvWNdB2zylt/rnJsa2JPJwKqqGhobHSUlyoyLiIiItFf5yISPBt4DtvoXmtkg4HzgfOfchcBPzWykt/pu4K/OueuBT4CLvOUnA92cc9d6yx4ws9IAnkOrvD53db6HICIiIiJ5FHgQ7pz70Dk3M8aqo4EZzjnnPZ4CfN3MyoHDgGne8neAY737x3rb4ZxbB9QAu+do6Fmzsbou30MQERERkTzKSTmKmb0E9I+x6nLn3LNxdutHqKwkrMpb1geo9gXn4eWJ9ok1pgnABIAhQ4ak8Cxyw3A0PRMRERERaZdyEoQ7547OYLfVwAjf426EasDXAp3MzLxAvJu3bXifrlH7xKz1cM7dA9wDMHbs2MDDYFcAU2a+O38td02ezx+/vRc79OiU7+GIiIiItFuF1B3lJWBfs6Zo9UDgBedcHfA6MM5bPh54zrv/nLcdZtYLqABmBzbiDOUrHj/lb+/x1hdruezpT5JvLCIiIiI5k4/uKD2Bs4DuwAQze8g5N9U5t9TMbgJuNbMG4O/OuS+83X4BXG5mRwFDgHO95Y8Be5vZFd7y05xzDYE+oRx4bc4qFqzdwplfGY7lIGJfv7U268cUERERkdQFHoQ759YD13i36HX/Av4VY/lC4CcxljfS3CmloPlD6WQ14Wf+czoAD723mEnnH5qzMYmIiIhIfhRSOYpE+XLtlnwPQURERERyQEF4wIz81YTHc/cb83nyg6UJt2lsDL6ly7OzlnPg9a8xZ0VV4OcWERERySUF4YFJLfKub2jM8TgirdhYzcQXPuPcx2bF3eaTZRsZdekL3P/OggBHBr9++ENWbKzh4ic/DvS8IiIiIrmmIDwPEtWEL1q3Nf7KHNham/w61mue+5T6RseV//00gBG1VGA/HIiIiIi0moLwPNpWn/1GLn9/60vueH1e1o+bT6UlCsNFRESkuCgIzwMzuPGlz9j50hf5YPH6rB77mufmcONLc6mpix/gt7UJOxWDi4iISLFREJ4HzsEdr88H4E7v31yco5DU1jfSkOHFnSWFdiWriIiISCslDcLNbLiZPWlm/zSzk83soCAGVswaE0TIscLN9VtquezpT/h0efa7hKQS3lqMrdIJqOsaGhl91cscecsbaYysmYJwERERKTapZMJ/B9wGLACeBr6bywEVO8OxcmNNWvtc+d/ZPDh1Ed+4/a2U93E5LDr544ufMerSF1iS4kWkazZto7quIeO+5yX6vUZERESKTCrhzWfOuTeArc65WmBljsdUpJqzuSW+IudUkrwLK4PtmJLMXZPn09Do+Mc7CwM5nzLhIiIiUmxSCcL3MrMDgAoz2wMYkeMxSZR8h6CZxMCPTlvMEzMSTwCUKgXhIiIiUmzKUtjmj8Dfgb2Ao4Cf5nREktDf3/qSvYf0YN+hvVqsc75a8/DdxkbH39/+kv2H926xrrXe/GJNzOV1DY1c9J/QBDvf2XdQq8+j7igiIiJSbJIG4c65T4GmizHNrFNOR1SkGlOo0XYpRMfXPDcHgIUTj42xv+983oPnP1nBdc9/Fvd41oos87zVm2Muz7QLSjzqEy4iIiLFJpXuKAf7b8DtAYyr6DT6ZqP3x73hu39/60vGXfsqyzZUp3S8qpq6hOvDYfCSdakdL5FpC9e1+hitoyBcREREiksqNeG3AacDZwBXAENzOaBi1eBlpg3HmME9Wqy/5rk5rN1cy18mtZztMlay+qaX5rZY5s8/h7Piz85annC7VNQ1pLeHf7zPzFzG1tr6NM8Y/3giIiIixSCVmvAJzrlp4Qdm9oscjqdo+XuDx+q7na6l61tmuCPKWby7c1Zkv7d49Dl//uAMdujRiStP2N1b1rz+N4/M5PjRO+R0DCIiIiJtTdJMeFQAvh2wf05HVKSyXCYdU0QmPEt9wpPVqS9dX83Ln67i/ncXxt3mvzGy8elQIlxERESKTdJMuJmtB9YTioWqgL/kelDFzh8gR5dapBo6xwqOIxLhWYjBa+oaOOrWNxNuk2j2TxERERGJLZVylF845x7N+UiKnYt9v0UMG/XYORczE5ws9M1GcPzegnUsTnFWzKA8Nn0JHy3dwNXf3KNVnV1ERERE8imVcpSIANzMvpe74RSvODF4C9HB87hrX+ODxRtaHi/GQfwZ9oQheBaz19mob096Dt8pLnziI/41dTHvL1iHc463vljDmk3bcj4GERERkWyKmwk3swU0x3Lm3TegG6DMeJr8L+RyXxvC6GRueWnk96K1m2MHmOHjbdhay4K1W9h7SM+MylEShdCZhtdBVKhsrWvg9bmr+cn90+ncoZRP/3BM7k8qIiIikiWJylFucM7dFb3QzP4vh+MpWv649IInPsracQ+9aTIbttbx6IQDGO1rfbh28zb6du3YqmNnWu2RrYtCk5m2cD0AW2sbAjmfiIiISLbELUeJFYB74k+/KK2WagAbvjBzw9bQpD1Tv1wXkYH++m1vcf87C7I+vkLif77jJ07i1U9X5W8wIiIiImlIZcbM0Wb2mJlNMrPXgb8HMK7ikyC2XlS5pXmzLCaRJ77Yuu9LmdZ7p/ocnv5wGT/953Rq6hJnsmOOI+ocyzZU89MHpqc4QhEREZH8SmXGzHOB64H3gQnAf3I6onbGMLZsaw5CU29RGPXY+182ZV6OkppzHp3Jq3NW8cSMpRmcQ60RRUREpO1KJQj/2Dn3IbDROfcFoFYUGUg5ZMwwtnQO6jOYEai1Xf5i7Z9sgp9odQ2NaZ9DREREpC1LJQgfb2ZjgB5mdilwcG6H1P74s7rvL1yX0j6xJvn5zl3vRi6LEwvHC5E/XLw+8hwpjCPd8plYAXpJhlG2suEiIiLSVqVajrIGuBnoBfwupyMqVl68aFGBo8Nxx+vzsnKKz1dtbtX+J90ZGcRn2qMwUWisCTZFREREUpsx82fOuXDgfW4uB1PM4sWeL3+6KqPA9K0v1kZOUhNrGvtUxtXKoDh2OUqC87XudCIiIiJFIZVM+B5m9hczO9vMuuZ8REUqXvDZmiD4O3c3Z64/WrYxo2MkOn0uZsOMVY6SrIY8XqBf35Dai7d6Uw3nPTaLTzJ8jURERESyLZVM+Pecc9VmtjNws5nVOud+leuBFZtclGEsqtzadH/y3DUxTpp8LIkC4IwviAwo3f3u/MqUtrv0qU94+dNV/OeDpSyceGyORyUiIiKSXCqZ8CPMbG/gYuBwYGVuhyS5Vlvf3I0km/HyNO+i0jsmx69xz+b5Uu3CsnR9dRbPKiIiItJ6qQTh/wL+BLwA7OKcuyanIypShVQLXVPv60ueYGDpJsK/e/cU1m7exj1vfhl3m0x+EWhtWYxaHIqIiEihSSUIv8w5d4hz7jHnXH3OR1S0QtFndHeU3J4x9rmqaxsitorHMoheIy4WjeHyZz5J+5giIiIixSZpEO6c+3MQAyl2LgcXOSY9Z5z42h+ER29TVVOXwxHBI9OWtFiW9GuJMtkiIiJSZFLJhEsbFW8GzS21zT9oRG8xY+F6WiOTcpOg9hEREREpFArCg1JAQWOqs9unUo2iemsRERGR9KXSohAzOx7oBswEFjjntibeQ9qK6N7Z6U4FH52RDnIq+Uxq1kVEREQKQdJMuJndAHwLOBjoAFyf60EVoyCD02SO3K0/AB8uXs+5j82KWJePMo+Pk0yiEyvUrqqpozHFlH50rP7B4vUc9+e3mLlkQ2oDFBEREcmyVMpRNjjnzgC+dM59CKzI8ZiKUiHVMI8e1B2AqV+ua7Hu5pc/p6HRce/bC/ju3VOSHuvLtVtaPZ6nPlzG2s2Ju6pEO/exWcxdtSmj833/nql8sqyK0+59L6P9RURERForlSC8j/dvOIzsm6OxFLcCKp1wDv730XL++OJnLdZ9uqKKpz9cxtX/+zSlY/3uyY+zMqZlAU6oE56sqKqmnmNvf4vPVlYFdm4RERERSC0I/9zMPgVOM7P3gdSiM4lQQIlwAH710Idx162sqkn5OMs2RAbPmWb8t/lm8YxWubmWe99ewMbq7LdPnL28KuFrISIiIpILqVyY+RAwGdgD+Ng5NzenIypShVSOkmwoqU4H3xovfrIy4nFtgiB8ypeVTPmykukLW5bPRFtdVcPD7y/hhwcMoc92HVMaS+TkRSIiIiK5l0om/BGg2jn3hALw1iigKDyJIL4w/OJfMyIe1zYkD4TfnV+ZdJufPjCdW1/9nF8/rOy2iIiIFK5UgvB3ge+Z2e1mdliuByS5lyzIznUMXt/QMuu9rS5+JjwslQz9R0tDnVamL2qedMhSmHLTOce6LbVJtxMRERHJhlSmrb/GOXcDcB6huvBWXYlnZiVm9nMzW21me0StW2hmk73bv33Lh5nZvWZ2iZn91cy28x1ropn93sz+ZmYHtGZsuRSOH60NZcQzkUoWfcTvX2ixrDZGYN7i2JkMiBRaIBr87qlP2OfqV3h97uoMzyIiIiKSulT6hF9mZucCHwFdgF+28pyjgfeAWBP+3O+cO9S7/dC3/G7gr86564FPgIu85ScD3Zxz13rLHjCz0laOLydcCtnYoCTrBpKP+vVUzpnWuNLY1gwefn8xAPe9vSCNk4iIiIhkJpVylF8BPYCvOedOds691ZoTOuc+dM7NjLP6q2Z2oZldbWYHAZhZOXAYMM3b5h3gWO/+scAU77jrgBpg99aML3cKJwP+QtRFkdFaM7FQpvs2phBhZ3rB6A7dK7I6DhEREZHWSqU7yinOudfCD8xse+dcwgl7zOwloH+MVZc7555NsOslzrn3zawz8IGZHQdsIXRhaDg6qgL6eff7Af4ZW/zrosc0AZgAMGTIkETDzwnFdq2X6UtYWpr4Vwh/zXhj8qoYERERkVaLG4Sb2Wjn3CxgoJmd5lt1PPDdRAd1zh2dyWCcc+97/241s5nAeEItEjuZmXmBeDcgXLi7GujqO4R/XfSx7wHuARg7dqxC4gRa84XhhL+8k7Nzbk2jlWA2MvLVtQ10KCuhtKRwSolERESkOCQqR/m19+8ZwHDfrVcuBmJmR5jZMb5FI4D5zrk64HVgnLd8PPCcd/854EBv/15ABTA7F+NrrbYU9edjrNkuA/EfLtmh/ZOZNv3cUlPHrpe/yDfveDur4xIRERGBBJlw59yZ3t1fO+c+BjCzLsCTrTmhmfUEzgK6AxPM7CHn3FRCGewrzWwfYAfgSedcOAL6BXC5mR0FDAHO9ZY/BuxtZld4y09zzmnmldbKQ+1MLs+YNAiP2Da08awlGwD4ZJmmtBcREZHsS6Um/OtAuC1hf+AC4LT4myfmnFsPXOPd/Ms/Br4dZ5+FwE9iLG+kuVNKYWtDLQrzMsICeVkaC2QcIiIiUtwS1YQPAYYBu5jZwd7iElLrqCJRnLWduuJEmePN2+pzcs7PV21KvlEa6n3RdDpdVdQdRURERIKQKBO+N3AiMIbmX+wbgP/mdkjFqTVt/4KWaKx7XPFSTs7597cXcOlxu+Xk2MmY7wuSYnAREREJQqKa8GeAZ8xsnHNuWrztJEVtKLhrb4ForJrwZNZvqeXSpz/hhwcM4aCd+uRmYCIiIlK0Uikt2dPMTgEwsx+ZWYFOhlPY2lJc21BkUXg6z6axqXY/cfnQDS/N5bmPV3DK397LfGAiIiLSbqUShO9HqAsJwOPAT3M3nCLWhuLahoY2NNgUpPOdItWyoXVbtmU4GhEREZHUgvAvnHP1AM65GiDxnOeSUFu4PHPKl5X5HkJWJQ2sfW9KqjNmJsuUx9LY6KhryO6UnM45Xp+7mpUba7J6XBEREcmtVFoU7mZm3wHmATsBo3I7pOLUlnLLs5fnvzd2fRaD1XT6hKfaHSWTZjfH/fltFqzdwqwrjqJDWXaaDE3+fA1n/GMaJQZfXn9sVo4pIiIiuZdKEH4pcDOwFzCTUJ9wSVNbCsILwVvz1ublvMli8OUbqjNup/jpitCXm8XrtjKi33YZHSPah4vWA+pvLiIi0tYkDcKdcyuAU8zMXDoNlyWCXrj01GepLn1bfQOrN6Vevx3OhMfLdB80cRIAvbp0aMWo9GkQERFp75L+Jm5m+5jZB8DzZnaqmZ2Y+2FJezR35aam2uZs1c7/452FSbfx9wkPB+HJvm6u21LbmmFljcJ5ERGRtimVwtQJwEnAG865fwEH5XZIxUm/ISR39J/e5IDrX+P8x2dl7Zifr0xeOuIP+Oev2cJLs9vOtcf+z1W2L/oUERGR3EklCJ/nnFsEhP8fvrhaZwTMlLtM6okZSzO68DFaQ6OLyHKn6ucPzsjK+WvqGmJO/pPNL2T+zi8fLd2QvQOLiIhITqU6Wc/3ge3N7DhgRI7HVJRcm2hOWDiyEQRPmV9JSQrH+WL15tafLMqyDdXsctmLnPtY9rL6IiIiUjxSCcIvAU4AjgS+D1ye0xEVKyXAA1ff2EhJNqJ5Qv24P1i8PuXtn525HICnPlzW8lhZGZF3LH2uRERE2qRUuqMsB04JYCwiTbZsa2j1MUrMUp4BM5nHZyzlwic+Snn77TqWxl2nwFlERETiBuFmdp5z7mYzuy/G6mrgPufcjNwNrbhkKxhsL85++MNWH2Py3DU8Nn1pFkYDz3+8Iq3ty0vj/8iUzc+CPlUiIiJtU6JM+HLvXwPuj1pXDpwF/CQHYxLJivveWZDxvtFFLGWpFJfHsXFrHd07l2e8fyLKqouIiLRNcdN1zrmHvbu/cs694b8BbwCF0Si5jVCs1LZEv1+lrQjC73xjXsTjxgw7CcbstOIbqQJyERGRtiOVCzNHmtn7ZrbZ+3cfYCDweo7HVpTUI6VtmONNMR9WlqC8JBZ/PPzXN76MWFebQT/vCQ9M56Q736VR89OLiIgUhVQii6uAXwFDgN8AVzvnFjrnHs3pyIqMspRtyzXPzYl4XN6KTHi0bXUtLzq99rlPGXvNK2yrj31B6sufrmLmkg2s3bwtcoU+VyIiIm1SKkH4NOfc+865dc65KYAuxsyAgvC2Ld1MeKKQffWmbS2W/e2tBazdXMtB109K6zz6WImIiLRNibqjDPHu1prZ4cCXwI6J9pH4FCy1banmwZ0LzdKZ6P2uT1AUXrkl80st9BkTERFpOxIF1JOBhYTij6/7lg8Bfpe7IYm0TfNWb+Lbd03h/KNGJcycW2uuDIjaNdbFmiIiIlL4EgXhv3LOPR+90My+kcPxFC31CW+7nEvt3bv++c/YWF3HZc/M5vpv7Rl3u8bWBM76GImIiBSFRC0Knzezzmb2IzO7ysx+ZmZdYwXmkjozRVGpGDO4R86Ovf/wXmltn2pDEvNlqRPF2dlMXisRLiIi0jbFDcLNbCjwDnA40AE4CHjHzAYHNLai4pyaE6ZjaO/OOTu2pflWOOdSDHbjH3jql5XNx4taV10buyNKmqcQERGRNiRROcp5wNHOudXhBWbWH7jQWyeSMw0F1A87k0x4tA8Xb4i77qs3JO6IElH3HTUWF7FdwsO0SmNjqCSnNZMWiYiISLNEfdcq/QE4gHNuFVAVZ3tJINkFdOWlkcHNgG4VuRxOwctlQJnuhZHJKsJve/UL77jx1fkm6In+LKzdHNkR5Z4357O4cmvTY/+XgOgvBEGUozjnOOKWNzj85sm6EFRERCRLEgXh8f7fVv8vnIFkL1p0YDh2WM/cDaYNaNXFiwnMW7057X2SDeXWVz/3WhM2L1uwNvI8/kl4kh3vuuc/4+u3vdn02P9aRH8hyPUFv5c9/Qljr3mVBWu3sKhya0H9QiEiItKWJSpH6WFmOzjnlocXmNlAoEfOR1WEkgVe6dYpF7tcBeHvzl+b9j4rN9Yk3aah0UV8kfrbWwsi1tfWN2fCU3luW2pjB+1Bx8APTl0U8VghuIiISHYkCsJvBF40s7nACmAHYCSRPcMlZaHwJd40LtFBeEk7j8rrG3IT7j394TK+SDMbvqqqJmnGub7RJfwiFRmEp3X6yEx4VAAfdHWIqlFERESyI1GLwhXAAcAzwCrgaeBAb7mkqTFJHXJ0OUo7j8F57bPVyTfKwAeLN7Cppj6tfbbWNvDkB8sSbtOQLAj31YQ3pBnJRlyXmbD1oaO+oZHPV23KWe22+t2LiIhkR8Ip6J1z1cC/AxpLUUsWE1XXRbapa+cxeEG56eW5SbdpcC7hBZ/+zH66AbI/Ex5dyuIi6sXh6v99yj+nLOKG7+zFyWOz301UmXAREZHsSHRhpmRV4uhl++6R3VCsvafCC8js5ckbAo2/fhLPfRz/R6JVm7Y13W9Msx4lshwlcp0/q+8c/HNKqIb7gSkL0zqHiIiIBEtBeECSXpgZ/TjgGPyo3foHe8IsOP2gYfkeQpNN2xKXuLz5+Zqm++nWhPs3j86Er9rUfNGoPyte3+B478tKLnh8Fptq6tI7YaKxKBMuIiKSFQrCA5Ju7JJuL+vWKitte5n340dvn+8hZCTdzi+u0Xc/at3gnp1jrnMOvnfPVB6fsZS/TJqX/iDjjUU14SIiIlmhIDxg+5d8xkklb9GlQ2nE8ujyk6Az4UEH/dnQVjvIpBuEvzR7ZdP96HryMYN7xDyu//6KFFospkqZcBERkexQEB6Qr+43run+rR3uYktt4vKFwMPLNhjPttUp1NMtR7nwPx/F3TfetPX+IHzJ+q1ki2JwERGR7FAQHpDdd92NDb9oDqb6siFifXRSN/hMuASlNRMRRe8aL/vtD9ZLs/hh0rT1IiIi2aEgPEA9BgxlndsOgJIkOcVclFp8dWSfrB8z2k+/Mjzn5wjr2blD0/0OZW3no/zOvPRn7Qxr2aIw9v0Fa7c03c/mR0khuIiISHa0ncilSGwjFDhGz5wZRCZ8h+6d4q7LVkvEvl07ZuU46frqiNx/wciWd+ZVZrzv+Y/PosbXU97/KVq6obrpvr9UZ9rC9RFBeWv4LxIVERGRzCkID1g4aIrOhLe8MDL7UfihO/eNuy5bZ8tXprSNXqOZUL03y+buO3RrWjZ7eRX/fHdh80a+9Lf/Yt/ol+OwmyZnZUzqjiIiIpIdCsID5rzwKDoTHi3b1xx+ctXRHJQgWzxzyYasnGdE3+2ycpz0FV8UHu5qcuxeka0Y125unvjH/yl6d35zhr0+3as/U6SScBERkexQEB6wpiDcWleO8o8zxiXeIMp2Hcvo3qmcDy47Mub6xevid9D40QFDUz7PEbv244Zv78XIfsEG420pE94vxZKdWi8THv0rSWOcOvAnZixt9diSUQwuIiKSHWVBn9DMbgW2ApuB0cA5zrmV3roLgG5AT+Bl59yz3vIxwFnAAqAfcL5zrt7MKoCbgGXASGCic+7zYJ9RepwzsBg14VHbJerbvefA7hy2c7+Mzt+rS4eYy8tKLG72dM9B3VM+vplx8rjBvPH5Gr5YvTmjMaZ+Lth1+27MWVHFoJ7x690L2aPTFsddV98Qej+iS0DidUQJgrqjiIiIZEc+MuFbnHO/d85dD3wI/B7AzPYHDnPOXQacA9xsZt0tdMXgv4DLnHPXAQ3Aj71jnQMs9o51K3BvoM8kA41N5SiR0pmsJ1mpyjfH7JD2uMpLY38URg/uwQmj0z9eUNUhv//Grpw8dhC/PXJUMCfMAv93nYv+83Hc7eq8THh03PuPdxayrb4h5rpcS/V0X67ZzB9f/IzlvotFRUREpFngQbhz7tKo84fTpccBU7xt6oE5wCHAjkCncLYceAc41rt/rG+fj4HRZtZ8FVsBCpejlJC4zUSiFoXJAqEbvzM6rTFd/609405b/8xZ46koL425LpGgZrP8ysg+3PCd0XSrKA/kfNmQajY5HITH8uInof8cqmrqsn7exMdIbbvzH5/FXZPnM/GFz1p9ThERkWKUkyDczF4ys5kxbif4tukBHAXc6C3qB2zyHabKWxZveaJ9Yo1pgplNN7Ppa9asacWza524mfA0jpHt7OfX9xgQNxOeqejn8+19BmX1+G1ZqiUkdeFylBjbh0tV/vTqFxHLE/1KUpsgqE9Vqt1RPli8AYAZi9a3+pwiIiLFKCdBuHPuaOfcmBi3cI13d+AO4CfOuXXebquBrr7DdPOWxVueaJ9YY7rHOTfWOTe2b9/4rfpyLdVMeKJEcrJAKJMkdHmcTHimosdwxK7xa9h/fsiOWT13oUu1cUl9nHIUiP9rSGmCKHxbfRaafKcw9i3b6pvud+6Q/q8oIiIi7UHg5Shm1odQAH6hc26BmX3bW/UccKC3TTmwK/Am8CVQbWYDvO3Ge9tG77MnMMs5VxXIE8m26O4oCXLjyRKp6YbThlFWkt2PQnQ5SqIxHbhj76yeO1Xf2mcgY4f2DPy8qWbCw5nrdH74SFQGtK0uG5nw5PwtFPca1KPV5xQRESlG+bgw82VgL+DfZjYZOB3AOTcVeN3MrgNuB85zzm1wod/iTwWuNbPLgVLgn96xbgOGmtmlwHnAmUE+kUw0ei95smnrE2bCkwXhSVLhv/3aKHbs28W3AyzL8gV0u20fWZqfaEgdy/KTLS3NU1/DVMuJmstRWq47//FZTRdn+iXKdmelHMUby9baep7+cBkbt7asSfe3u8z2LywiIiLFIvAWhc65fRKsuzHO8pnECLCdc9WEWhe2GeF4KnmLwuTHiCdZ2PObr43k10eMYPglz4e2t9CsjLOXZ+9HhFMPGMqmbfXc/lq4Zjn+qPYf3iujc0R/2fjloTtx5+T5Ke8f1MWj0TZvq+fi/3zEb742MuF2TeUocd7xyXPTu7ZhW13LoD1d4bHc8fo87nh9Pt8bO5g/fmeviG1uerm5S2iuJg0SERFp6zRZT8DCmfAWQXhUQFiSoLY3WZeLVGJL//mcy/5kN506lHKur21gwpaLWZoe9MJjdklr+5KSZPOW5s4j05bw8wdnJNxm6frQrxPx3u6GNAPcbNSEh8fy6LQloX+nL2mxzdyVzV/m0h2jiIhIe6EgPGDhkCS6HKU13VKiJStHiblPjht7Jzv6IxMOyMp5Ljh655S3zXJDmLR9tHRjwvXhtzFeGJtulvm0+95vdZvC5nr2+O+o/7OkIFxERCQ2BeGBCwUop+4/uKDa9uW6MiPZF4MDduxN3xSnc0/krMNG8Okfjk5p2+6dygt6Bsim1yzOGOvSzGyv2bSNjdWp9xWPJTyURG/nvr6LXRWEi4iIxKYgPGDhPuE79e3CzSfHn1Qn3vTykINZEl1m2fN0pHL0VLZ5+bcHJ92mc4fULnWwFkVBhSX8BSHeGBf5LoBMVWuD4qYgPME2/hr/5z5e0arziYiIFCsF4QEL9wl3LjKLGR0DH59gqvhUJ0xJfUwux8UoUF6W/KOW7HvAN/YcwKj+XRNvlIYSg8YCztSGA+Z4X7o2pTFbZlhrL5R8fW7LNvyfLIssq9HFmCIiIskpCA9Y04yZLnEpQceooPWgnZp7aeeigiIbifArj9+txbLzjxrFkbv1z7gDil/0805nyDGfnxmbfRPL5EKiL1PJhGPZeF+6unZMv7nRK5+uyng8ALVeCYz/9fzu3VMitkm1D7qIiEh7piA8YOGcc2nDNqjdSgXbsBizZ0aXh/zW12kkF7KRCT99/PAWy351+Ej+dtpYKsqT9wJPdnFodGyXTqg3qGenmMuH9u4Sc3k27DKgK98fNzjj/cPBbLyYNpMSoo+TXAyaTIM3GP97VR3V+lCZcBERkeQUhAcsHISPm3wqXLc9n1WcwTMdLkuaGffP7BgOcXbq27oA8tQDhnDcXtvTo3OHmAHdfaePbdXx05WlToVxjt3y4Jbjc+4/vFfSXxi+OrJP3HVN5Shx1mfScrC1pUzhMSV6XrFKfOav2cy9by/I+S8PIiIibUXgk/W0dxuHHk31kvuoKPNyifXV7FWygM7UxN3n/KNGRfX1DgU5z//mqzzw7iKufX5O07rRg3ukPJZrTtyz6X6sYPTwXfqnfKxsSJbZjQ4go0t2Eh47xrLjR2/Pyo3xX/fWMrOks3LWN8QPihud46OlG1gRZzbTWDNmJtPaJHVTEB613DnX9P7FyoSf9e8P+GzlJqqq63L+q46IiEhboEx4wA4583o6XbkKu3QlXLqSDS6UzS6NKklJZcbMjmWllPqi51lXHMWT/3dQRuPKdZ9wgEcnHECXDvHLUi6PUVPu18Wrgf7jt/fkomN2oc92qbc0jA7wx4/ozYh+XbnwmNT7igMM69055W1LzJJORDTly8q466YtXMcJf3mHp2cuj7k+k0z4dmnUkcfqpFLflAm3mMtj7bdm0zY+W7kJgJlLNjQtf/XTVdw1eT4bt7aubaKIiEhbpCA8z8IXapYkKEdpkSH2xTidfUFt907lEUF5WgKYwX3/HXsz+w/H0K0idiB49O4DePDM/eLuf/HXQzNifm/cEP7v0J3SOnf00zts534A9N6uIz06l6d8nAfP3D/lbUtL0it3Oe3AoRGP35kXP0AHeG1O6CLLsjROctgu/SIeb6yuoybOdPaLKre0WNbQGPtzWuv7QhAdhE/1fdEIr6mpa+CnD0znjy9+xqPTF6cydBERkaKiIDzPGry3oCTGxZnx+EOck/YZyI8PHMpDP0s9OIylR6fIQHTPgd1bdbxEElVEfHVk37iT7fTrWpH5SaPi1B8fNKzpfrKSEYC/nzaWWVccxeBeaWbCU7x48qJjduF339g15WMDrKraBkBZaepBuH/LNZu2Me7aVzny1jdi1nHPW7256f7oQaHPQ+XmWn5073ssiyqRqfK1S4wuR/F3SwmXUm2ra/68b96WflmNiIhIW6cgPM8aw0G4tewbHi59OHhk34h1/lkeO5aVctU39+CgneJf4Pe1XZPXdl/1zd2b7h8/egdu/8HeSfc53RfIpsUXo7178eEtVqc62U6mvjqyD+W+Oet/87WRAJzj/RtLaYnRvVPqGXOAkpLUg/CuFWURY0pHeUnq+/nD48XrtlJb38iSddUxS1vCwfNRu/XnG3tuD8Aj05bw1hdrW2w7ee6a5v2ignB/d5fwMRtiBOYiIiLtiS7MzLNEmfAXfnMwq6pqGNYnsgtKuiHL307bN+k223dvbuF3+kHDGN4neeeVK47fjUenLaG6roHbvj8m5fH4x79Dj9itA7PNXy5RGxVwnrr/UMYN68Wo/l3593uLqa1vbPX07hAqRUk1CP/6HgNSKl3Zb1gvDtypN7e99kXTsnQy4f6A15+hrm1opBOR9foN3stUWmLUNST+paa+0TFzyQYWVW5pkQn3X1DrHCzbUM35j82KWCYiItLeKAjPs3AmvDSqJrystIROHUpbBOCZyNWU9GbWVDqSzjnSyXzefeo+3PDiXK44YffkGyfgz/TWRgWUJSXGrtt3A2DKxYfT6GDUpS9EbJNJa79SM1JNUvdO4SLTPtt14OaTR/PkB8silq9P48JG/7PwZ6zrYwTZj0wL1Wpv3lbPfsN7t1gfcVznOPGOdwCaXsvm8/i3g1te/jziglRN7iMiIu2RylHyrNF5F2ZGZcITdREppJjFzNIO8rfUpl4DvMfA7kw6/1AOGdU3+cYJ+AP/6Ey4X1lpCeUxMsuZvOaWRk142HUn7Rl33akHDGVwr85EV6386IChsXeIxfc8/CUhsdoKhstO3vpiLRXlif9U+C/GnLOiCmi+YDQi8HeOL1ZvithXc/uIiEh7pCA8z8LlKP4JJU8eOyhhYNvaCVeSCyYqSvRFI9t+sN+QpvvJSitivfaxgvBv7zOIa07cI+5x0rkwM+yU/YdETMzkN8S7KDS67WE6teTRpSFhyV6TDkl6sscKpMP7OBd5zujMd+4/zyIiIoVHQXiehctRyqw5ELnhO6MT7pNO0JWjSpQWJQeZ6JjKVPZZegK/PiL+RZfp+uO392Ts0J5cccJunHrAULbvHrtrS2kJLbLWrdG1InRhaHQ3l/RqwpvvN0SUoyQOhJN95mJ1VwlfLOw/56crqojuclhIv+yIiIgERUF4noWD8IkbLuCNDudwQMmncbe9/4xx7NS3C39OoXNJWADtvzNWkcKMl13j9BRP5paTR1NWYjz8swNYOPHYtDuPPPCT/fjH6eOaHvvjxO+NG8IT/3cQ3byg+KlfjucP32xZs55JqU70ufzCCfDo7Ho6veFjdSqB5JnwXp07JFwfnd2+9Nhd6en1X79z8rym5QO6V7TMhCsKFxGRdkgXZubZ0i67MbJ6Gd1cFd1Kqjim5P242x66cz8O3blf3PVBykZwX5ogg/v0WePZsq2+KdBN17f2GcSJYwYmnbEynoPTqEEf0L2C0w4cxuXPzI5YXppGi0K/LnFmtQwfKvqQqcyCOahnJ5aur25Rnx1WlywTnmY5yv7De/PFqlCf8YWVW5uWNzS6Fpl81YSLiEh7pCA8zw694DFqq1bxxpN/5cjFt/LN0nfhrwe3+rj/7bCRdxt354bGU7MwytxIFKCOGdyj9cfPdPbQLCmx1CYCivaLQ3bkzc/XtFgezqpHZ74bGx1jBveImBLeb1jvzozo15Wl66sjAm9/Wcjs5RvZbYf4JUbJZuVsdI4encvZsLWO9393BP26VcQsharcvI2qmvqIZUqEi4hIe6QgPM+spIQOPbZn+D6Hw+Jb6WmbYcWs5DsmsWcJ7FmykCc6n5b2vqkERdko1c4kQM2XTEomSswyep1G9e8a93j+f8NGD+6BGTGD8AHdKnh4wgFNWfqImvA0MuFJg/BGxwavVWL4y0+s5+4c7Ny/K3NXNXdIUYtCERFpjxSEF4gRYw6msu8H9HBVWbmYb/Nfj2E7q+GKr49Ie9/tMqzDTlcbisEz6t9RYpZSNn7csMhuKPF+IQgv9R/znYsPZ2CPTvz7vUVNy/p27ciaTaEp7UcP7s723TuxYWstAB8uXs8xewwA4k/cE0uyuvPV3vkAungznsaqh69vdHTpGFxXHBERkUKlILyA9B64U9aOVUMHtqOGPmlMSHnnD/fhyzWb2WVA8s4n2QigU5mgJhcySbxmsk+scpTDd+nHpM9WRyy784eRM5rG+4WgORPevGygN+PoS7NXNS3z7z2gW6hzy7SF6wH465tfcsk3dgWaZ8SE5Jn+ZBeYPji1+UtAJ6/1ZKw9qusa+GDxhohlyoSLiEh7pCC8SNV6b22ndZ/Bqm1Jtg75Rj+gH7Bqdot11x1UwnsLK/lsxSbWua4Y3TMe2+O/OJDbX/si4cQ0xaBDWWmLLyu/P3ZX9tihG7dPau4Y0me7yM4jFueXkHDwnayMx59JP/fIneNuF1EfniAO/urIPgnOFX/fVL+oKQgXEZH2SEF4kdrmysFg6PM/zMrxTvFueMnrmVWj4aWvZnSsccCDg4Bpz2ZlbKn6XdkC5jQO4RO+nva+mQSK39pnIFXVkVPK1zU0skOPyJ8norPMcctRwpnwNC447d45dneZJeu2RrQljPX8BvfqxJJ11Vx67G4AnDB6B56dtTxim0TBe6qdYRSDi4hIe6QgvEgtGfVjKpY8wYDuFdntFb461Md8TN0smNL6C0iDNMH7tH+38cC0923IoI9eRXkpG6OC8L7bdUyaIY4XY1uKmfAjdu3Hv99bHHf9lPmV/OBvU+ngu/gg1tMLd0/p7JWX3P6DvfnJV4Zz4h3vNG1z+XG7sXR9Nfe9s6DleBOO0nceBeEiItIOKQgvUgef+nvg91k/buWalSx76wF279exTXU3Adjw8kR62BYqqEl731Qy4aUl1iJY9+/WpUMpvbfrmLS+Ol4GuakmPMmFuyeM3iFhEP7otNC6Wl8mPFZNePg5+zPv0V8QfnzQMEpLjO+NG8zXb3uT40fv0LQu9YmKFIWLiEj7oyBc0tK77wB6f+vCfA8jI1Uv3U4P25LRvqlkwmMF4X67bh+64DVZaBpvds9wANwnxgWth4zqyxteb/GyZFPMx8p6xwjCw8/F/2XL/wVh++4VTV1Tdh7Qlfd+9zV6dWmub08Wgx+71/Y899GKFtPYi4iItAeatl7ajUbv426kH/XVpxCEx+ql3cNXkx0OYMPdQ+IpLTF+eWjLTjnhzPJXRvThN0eM5P4zxjWtu/CY5gswyxPMRAqx886JAnN/e0L/7Jx7D+kRsX3frh0jtrUEXzeuO2lPDvYu+HTKhIuISDukTLi0G41eUGgZXAnYmEIQfuoBQ7nnzS8jllWUNwfcZV5wPKLfdkmP9YtDd+K/Hy1nybrqpmXN09Ybvz1yVMT24d7cAGVJ6lUSZb39wl88/IH1sD5d+NP3xrBsQzXf3XdQwvNEZ8If+un+bGtoZJ/BPeneuZzHpi3xxpPwMCIiIkVJmXBpN5wXhJdkkHlNJRN+wdE78+MDh7ZYftv3xzCkV2euPnEPILWZQrtVlPPmBYfRM0YmPZYyX/a7a5LJlmrrW/4SEKsmPFY5CsCJew/krMNG0M/rQR5P9A8Dg3t15rCd+zV1bAkfVt1RRESkPVImXNqNTMpRDtu5L6/PXcORu/VPum15aQnjhvfin1MWRSz/5piBfHPMwKbHqV6waGZs2dbQ9DhRZ8KBPTrx7X0G0bdrRwb36sy5R45iQPfYQfIrn65qsSx2d5TwhZkpDbeFVC9ATTZRkIiISDFSEC7tRmMGmfD7Th9HTV1j0jrudKTR5juig0nPzh3ibmdm3Hzy6KbHvz5iZMT6Lh1K2VLbEL1bk1glKuHtk01ZH3dMLcYY+7Em6xERkfZI5SjSbjTXhKeeCTezrAbgkPokNn7dO5UzuFfnjM856fxDE66PrnmvqWsO2DMOwqOeZ7xJiRSCi4hIe6QgXNoN14ruKKlK1BEkLJMgfPyI3pkMp0n/bhXsMqBr3PVvz1sb8XjD1uZJhjqWZfYlJNnTbM6EZ3R4ERGRNk1BuLQbmZSj5EImcxxlErhHS5TR3qFHp4jH9V7z7h3i1JWnokU5SvTjFGrCX5q9kiufnc2qqvQnWBIRESlkqgmXdqOpHCWHmfBUlGRQ3pHrIHxbVMeU8AQ6pUl6jicSPeYWNeHev4lKwn/+4Awg1Fv9omN2yXgsIiIihUaZcGk3moPw/GbC/bFwqrF1hmXZUceIf5A1m7ZFPA5nwlNppxhPy6A7dk34cx+vYOqXlQmP5S+PERERKQYKwqUdKYwg3B/YXv3NPRJuO8DrxZ3KBD9Jzxsjkg/3FJ+5ZAN1vk4s4Y4lmWTtw6L3jG516A/Sv3/P1ITHUhtDEREpNgrCpd0olEy4v0tIss4j9/9kHFedsDtnjB/e6vPGOtUp+w1pur/V15M8PDlRWWuC8KhUeHRWfc+B3Zvu9+3aMeGx1MZQRESKjWrCpd0IT9azf/0MmPVITs4xev1WTir5nC4dS2HWppjbVNTUcWLJp0xp3C1pmckuA7qxy4BuWRlbrMlzulaU0b1TORur63C+Lyfh2TJbU4sevWtZVCp8cK/OXP+tPbnkyY85fOd+CY+1YmMN78xbS1mJsc/QnpSXKn8gIiJtm4JwaTcaSjuCgx/VPgZPPZaTcwwCbu1AqPn1U7G36Qr8yZt3552Vf4I5fXIylmj718xli3VithvWtKxjWWnMVoGVm2sBKGvFhZktasBjxM3h7HiyTPdbX6zlrS9CbRTPGD+MK47fPeNxiYiIFAIF4dJudD/mcmZMvY9RfTvRtaI8b+Oo37SasgWvAzB+xjkwI5jzngec1xG+su1PLHWhzPNeg7r7upSEAuFt9Q2cdt/7QMvsdTqis/ydO7T8c5OoV7h/AqGDdupN5eZa5q7axIoNalcoIiJtn4JwaTd22f8o2P+ofA+DMmDqA5fRde2HjOrfNbDSis1z32A7t4n+rGcp/fjbaWPZf8feTSUnjS4UiM9Z0VxGc8b4YRmfr0vH5j8vr513SMz695I4vcK/WLWJu96Y3/T4oZ8dwIufrOQX/5qh+nARESkKgQfhZnYrsBXYDIwGznHOrTSzYcCLwEpv0xnOufO8fcYAZwELgH7A+c65ejOrAG4ClgEjgYnOuc8DfDoiGTngtKsDP+ey68azc+0nlHp90vcaFLowMpyNHnftqxHbl5YY3xwzMOPzfXvfQVTXNTCwRyd26hu7u0s40R4dWN/79gKe/GBZ5LaaYVNERIpIPjLhW5xzlwKY2UXA74GzvXUTnXP3+ze20NVk/wK+5gXrNwM/Bu4FzgEWO+duMLM9vWVfDeRZiLQxjRaafr7UGsE1Z6Fr6mJPXnT07v1bdb7unco567ARCbfxZ+H9Nm2rb7p/wdE7R2yrdoUiIlIMAm8xEA7Afeff7Ht8vJldYGbXmNlu3rIdgU7OuXCG/B3gWO/+scAU77gfA6PNLDutJESKjLPQf+7hTHi4/WCtrz/4aQcObbpfUVaa8zFZnAsza70ZPO/50b5NgXy8rLnf8x+v4O435rNsQ3UORisiIpI9OcmEm9lLQKw02uXOuWe9bXoARwHf9tat8dbPNrP+wFQz25tQ+Ym/11uVt4wE66pijGkCMAFgyJAh0atFil44E15GqB94eEp6/yQ9/paEQdSqh0tM/HH10x8u45VPVwHQoax5DBYnax62dP1WfvnvDwCYu3ITt35vTNbHKyIiki05CcKdc0cnWm9m3YE7gJ8459Z5+2wBZnv3V5nZKkI140sJdXUL6was9u6vTrAuekz3APcAjB07Vr9nS7vTSCgILyFySvpwAFxWYhG9vf0BcK6UxMiEX/b0J033B3SvSLitX1V1cwnLUx+G6skv/vou9O9WEXN7ERGRfAq8HMXM+hAKwC90zi0ws297y0/z6roxs3JCLZcXAl8C1WY2wDvEeOA57/5zwIHePnsCs5xzLbLgIhIjEx7VraS+0UXMalkfwBWQze0Rm5dt80pRHvjJfhETFcXKmvs1RI33qQ+X8dxHK7I1VBERkazKx4WZL3vn/bf38/Im4D+EMt6XmtlMYARwmXNuEYCZnQpca2aLgFLgn96xbgNuMrNLvX3ODPB5iLQpzgvCf1z6MpMbx7SYkv7gUX0p8S379j6Zd0ZJVaya8PD9A3fqHbFtskx4Q4zl9Y2xLzoVERHJt8CDcOfcPnGWTwImxVk3kxgBtnOumlDrQhFJoq48VLk1vnQ2l7iHKF02ADD2sc9Z4AZg9I2oCe/WKfcTGsVqOxgOskui5r1vntgnThAeI+BWO0MRESlUmqxHpJ0YfNKV8I/nATij7CW47yUAnuwIla4rF/JoxCyXncpz3x0lVtvBcOAcPbdPvHaGYeHrSzuVl7KtvsGbfCirwxUREckaBeEi7cT2Q3dm0fcmUfX0+fTpWM/23gWL9Uum09s20dnVsGbTtqbtu1bk/s9DuO3gO/PXcvANr9Ojc3P23aIy4cn6hIdLT0YP7s7owT346xtf4lAULiIihUlBuEg7MnTXfWHX1yOWbbhiMH2oopQG1m+tbVreo3OHnI9nxz7b0aG0hJq6Rhav28ridaHlMWa4TzpjZrgapbTEMCI7v4iIiBQaBeEi7Vwj4Ul8GgLpiOI3rE8Xpl36NTZsreWWVz7nmZnLgZb14BB5Eeeiyi08Mm0JdfXNdeBL14cm6CktKSHG7iIiIgVFQbhIO1dP80ya9Q3Bp467dyqne6dyevguBI0dhIf+dQ5ue+0LnvxgWczj9ehU3pw115WZIiJSoBSEi7RzDa4ULBSEl5XmL4VcWuKfHbPl+nBgPnPJBmYt3QDAKfsPYXjvLr5jGN/Yc3v+NXURgCrCRUSkYCkIF2nnGrxMeBkN/PzgnZi+cD2/OnxE4OPwfwGInkgIYMe+XdihewXLN9bgHPTr2pHzj9qZXl1a1q77s+YiIiKFSEG4SDvX4CtHOXCn3nx0xVERk/YExR94xypH6VZRztsXHU6ddwVmeUlJ3HE2zcSpXLiIiBQoBeEi7Vw4CP/RmpvgwX9RkmT7XDl57RZ2LTeuqjuNWusdc5uSEqNjSQr9y03dUUREpLApCBdp57Z02h62LWOnmtkwf3bexjEcGF4KJ5RO4aCa21t1rJKmchRF4SIiUpgUhIu0cyN++ThfzH6Tnfp0iVkGEpSlr/yZQasnA/Buxa/hwWcyPtaJlVsZUe5Ytu33wM7ZGaCIiEgWKQgXaee6du9F14NOzPcw6D/0q0z96885oPKp0IL5r2V8rGHAsFKYVDkJODgbwxMREckqBeEiUhDKO3Rk/7Pu4/OZp7N9h2q6dixPvlMc8168gxGVkyhtrMviCEVERLJHQbiIFAwrKWHUPoe2+jgb3/BKWVxj4g1FRETyJF+NEEREcsdCHVQMBeEiIlKYFISLSNFx4dk3lQkXEZECpSBcRIpQ6E+bNTbkeRwiIiKxKQgXkaLjmspR1CdcREQKk4JwESk6zrxMuFMmXERECpO6o4hI8bHc14QvWbeV5z9eQacOpXx338F06lCas3OJiEjxURAuIsWnxCtHyWEQft3zc3jhk5UAXP7MbA7aqXdWj3/i3gM5eezgrB5TREQKh4JwESk6jtyXo1Ruro14/O78yqwe/935ldz00tysHjMo21WUcfv392aPgd3zPRQRkYKlIFxEik64JnyHtW8z/ZbvZOWY5hpg1xOwEgNg5/XL6FVSyw/2G0z/bhVZOQdAo3Pc/tq80IMtWTtsoDZv6cTkOf0VhIuIJKAgXESKTlm3/gAMbVzK0Kql2Tvw+5Oa7u4D0AGYmb3Dh93dIfvHDNoLy0uAXfM9DBGRgmXOtb8WXmPHjnXTp0/P9zBEJEfq62r55M0nqdu8LivHa1w6g/Ktq1os365jGSP7b4dl5SzFYd2Sz+i1+Qs20oUqUyY8XdtKOlFy0l3suMf++R6KiGSJmc1wzo2NXq5MuIgUnbLyDow54vv5Hka7tPztZ+nxyml0ty10d220niafGmDKtCcVhIu0AwrCRUQka/b4ygmsHfEx1Zuy8ytEe7L8pdvYf+1/QDO9irQLCsJFRCSr+gwYDAPUXjFdS9/uC2uBxvp8D0VEAqAZM0VERAqB198ezfQq0i4oCBcRESkAZt4kUypHEWkXFISLiIgUglKvQlSZcJF2QUG4iIhIIWjKhKsmXKQ90IWZIiIiBcDCmfDGOrbVbM3vYESKUFlZB0rLCif0LZyRiIiItGclof9L3r/yGZj4TJ4HI1J8pu19PeO++ct8D6OJgnAREZEC0G/3Q1gz+y90d5vyPRSRomRWWFXYCsJFREQKwPDdxsGVC/M9DJGi1WLe+DwrrK8EIiIiIiLtgIJwEREREZGAKQgXEREREQmYgnARERERkYApCBcRERERCZiCcBERERGRgCkIFxEREREJmIJwEREREZGABT5Zj5n9BtgT+BwYD0x0zk3x1l0AdAN6Ai875571lo8BzgIWAP2A851z9WZWAdwELANGesf6PNhnJCIiIiKSnnzMmNkRONs5V21mJwF/AI40s/2Bw5xz3zCzMmCOmb0BVAH/Ar7mnFtpZjcDPwbuBc4BFjvnbjCzPb1lX83DcxIRERERSVng5SjOuRucc9XewxHAp97944Ap3jb1wBzgEGBHoJNzbqW33TvAsd79Y337fAyMNrNuOX8SIiIiIiKtkJNMuJm9BPSPsepy59yzZjYAuATYG/iWt64focA7rMpbtgbYFGN5eJ9Y66pijGkCMAFgyJAhaT4jEREREZHsyUkQ7pw7Osn6lcBvzOxw4HlgP2A10NW3WTdvWbzlJFkXfc57gHsAxo4d61J9LiIiIiIi2ZaPCzMvcM7d6D1cQKjcBOA54HJvm3JgV+BNYCNQbWYDvOB9vLdteJ8Dgbe8mvBZzrkWWfBoM2bMWGtmi7L1nNLUB1ibp3NLMPQetw96n9sHvc/tg97n4pfP93horIXmXLBJYTP7M1BL6IUYDTzinHvaW3cBoc4oPYEXorqjnA0sAnrR3B2lE6HuKCsI1ZdfV+jdUcxsunNubL7HIbmj97h90PvcPuh9bh/0Phe/QnyPA8+EO+fOTrDuxjjLZwJnxlheTah1oYiIiIhIm6HJekREREREAqYgPHj35HsAknN6j9sHvc/tg97n9kHvc/EruPc48JpwEREREZH2TplwEREREZGA5WPa+nbJzL5GaGKi1YBzzl2V5yFJisxsJ+Aa4ANgEFDpnPuDmfUCJgJfAiOB3znnVnn7XECob31P4OWoTj9nEWrP2Q+v00+wz0gS8bouvUfofTvfzCoIdWFaRuh9nhjuwmRmpxKadKwBmO+c+6u3fBhwGTAPGAac55zbHPBTkTjMbGfgB0A1oZmZryT0t7nFe2ZmJcB1hCaGGwbc65yb6h1Hf9cLlPc3eBihTmwjCTV36IT+Zrd53oSP1wCjnXPjvGVZ+zud6L/5rHPO6ZbjG9DZe5M7eo//AxyR73HplvL7Nw74pu/xp8C+wN3Ayd6y44EHvfv7A89798uAL4DugAGfAAO8dTcDZ+b7+enW4v2+GfgncJP3+GLgQu/+nsBb3v1BwEyay/qmASO9+y8C+3n3zwauzvfz0q3p/S0lNMdEifd4e6BvvPcM+D5wp3e/F/C5dwz9XS/QGzAAWOd7j58Bfqi/2cVxA77jvX/Tfcuy9nc63n/zuXguKkcJxoHAIufcNu/xO8CxeRyPpME5N80594xvUQmwhdB7OMVb5n9Pjwsvd6GMyRxC2bYdgU4uNOlU9D5SAMzsR4TelwW+xU3vs3PuY2C0mXUDjgZmOO8vtbfN173Jxg4j9Mce9D4XmnGEgquzzewSQv9nvoH475n//V8H1AC7o7/rhWwroflIunmPtwNmo7/ZRcE59wShLLVfNv9Ox/tvPutUjhKMfkR+YKq8ZdLGmNlJwEvOuc/MzP++VgE9zayM0Hs7x7db+P1egz4HBcvMdgN2dc79zsz28q2K999vvOV9gGrfH329z4VlKKEA+gfOuY1m9i+gN/Hfs3jvc984yyXPnHNVXnnJo2a2AlhK6FcL/c0uXtn8Ox1YzKZMeDBWA119j7t5y6QNMbPDCH1z/q23yP++dgPWe1mUeO+3PgeF7SSgxswuBr4C7Gdm55D++7kW6GRmFrVcCkMV8JlzbqP3+G1gD+K/Z/rvuY3x6rgvAI51zp1O6L/Jy9Hf7GKWzb/Tgb3vCsKDMQUYamYdvcfjCdUkShthZscS+lnrN8AAMzuQ0Ht4oLeJ/z1tWu795LUr8Cahi4GqvYtKoveRPHPOXeuc+4NzbiKhwOx959yfiHw/9wRmOeeqgJeAfX1/xA8EXnDO1QGvEyp7AL3PheY9oLeZlXqPhxIqVYj3nvnf/15Ahbe9/q4XroHAOtd8AeUKQu+b/mYXr2z+nY7333zWqU94QMzsSEIXE6wB6pyuom8zzGxf4A1gureoC3AH8CzwR2ARsBNwsYu80r6nd3vBRV5pf7a3Ty90pX3BMbNvE+qG0IHQ+/w0oavuVwAjgOtc5FX3Ywlddf+5i7zq/nJC/yc+BDjXqTtKwfDKyg4n9Pd4CKH/JvsT4z3zOiVcT6jOeAjwN9fcHUV/1wuQ9wXrdkK1vBsI/dJxDrAN/c1u88zsEOA04BjgLkIXzEKW/k4n+m8+689FQbiIiIiISLBUjiIiIiIiEjAF4SIiIiIiAVMQLiIiIiISMAXhIiIiIiIBUxAuIiIiIhIwBeEiIhIoX4/urGwnItIWKQgXEWkjzGw/M5tsZu+a2cHesnNycJ5zfPe7mdkbWTz2zsC1UcvMzD7y7r9gZkO9VYPM7AZvanERkaKiIFxEpI1wzr0PTAbedc696S0+JwenajqmN+vcodk4qJfZ/idwXdSqvYBPvWB7e+fcIu/ci4CpwJXZOL+ISCFRdkFEpI0ys5OBHmZ2JfCZc+4RM/sDob/tDcAm59wNZnYGoRng7iY0U+DOwPeBW4B3gT2Bm51zM81sgu+YU4F+hGYf7OGdcwIwitBMhH2Bc4FvALcC/wW6ArsBpzjnFkYN+TBgpRfYY2YVwBOEpgmv9M7X2cz+B1zonPsUeAG4w8wud841ZueVExHJP82YKSLShnjB8XbOufO9xwudc8O8+0cD5znnjvIeTwbO8YLrycANzrnnzWwssBLo55z7wMz2AS5xzn03+pj+x2a2K/Coc24vb/ldwIfOuXvM7H5ginPur94U4I3OufB00uHj/AYY5Zw7K2r5i8BPgZ8Bs5xzT0atXw2Mds6taN2rJyJSOJQJFxEpHnsRyiRf7D1eQihbHTYHwDk33cz6A983s68D3aK2i2cPYKHv8TxgtO/x596/a4BhMfbvCNSHH5jZWcDXgf2AvwDjgWlmNsI5d4NvvzqgUwrjExFpMxSEi4i0bQ1mZoQC8FnAgc65iQBmdjihQDnM/9PnxcB659y1ZjYK2N+3rtHbf7RzbpZv+cfAcN/jkcCMOMePZQmh0pfQxs7dYWafECqNuQB41Tn3Df8O3nPbDlie5NgiIm2KgnARkTbCKyM5GOhgZl9xzr0NPAfcBOCcO8/roHI9sAnoCVxsZkcCQ4FfmdkfnXNrgP8A15tZR6ADMNTMjnDOvQbM8I6x2cz2ALqb2S+cc3eb2Z/N7E/ARqAWuM/M9iP0JeBHZjYXOB7o6WW0/V8CXgQuiXpa44G3gAOB92I87dHAZOdcTWteOxGRQqOacBERCYx3kWgX59xfUti2AvgbcFmMizxFRNo0BeEiIhIoM9vLOfdRCtsNBKqdc+sCGJaISKAUhIuIiIiIBEyT9YiIiIiIBExBuIiIiIhIwBSEi4iIiIgETEG4iIiIiEjAFISLiIiIiATs/wGQ9IQKIrm5+wAAAABJRU5ErkJggg==\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "_, ax = plt.subplots(figsize=(12, 6))\n",
+    "res.plot_objectives(ax=ax, lw=2)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "# Conclusions\n",
+    "\n",
+    "This notebook has shown the various weight schemes and acceptance criteria that can be used with the `alns` package. The `alns` package is designed to be flexible, and it is easy to add new weight schemes and acceptance criteria yourself, by subclassing `alns.criteria.AcceptanceCriterion`, or `alns.weight_schemes.WeightScheme`.\n",
+    "\n",
+    "Acceptance criteria and weight schemes have many parameters that influence the performance of the ALNS metaheuristic. These parameters should all be tuned for your specific problem. This notebook has not attempted to do this, and instead just presents _which_ parameters there are."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "outputs": [],
+   "source": [],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
index 56b9ae3..1d808d8 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "alns"
-version = "1.4.2"
+version = "2.0.0"
 description = "A flexible implementation of the adaptive large neighbourhood search (ALNS) algorithm."
 authors = ["Niels Wouda <n.wouda@apium.nl>"]
 license = "MIT"
@@ -18,6 +18,7 @@ classifiers = [
     "Programming Language :: Python :: 3.7",
     "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
     "Intended Audience :: Developers",
     "Intended Audience :: Science/Research",
     "Development Status :: 5 - Production/Stable",


Test patch:
diff --git a/alns/criteria/tests/test_hill_climbing.py b/alns/criteria/tests/test_hill_climbing.py
index f142d87..b9d6421 100644
--- a/alns/criteria/tests/test_hill_climbing.py
+++ b/alns/criteria/tests/test_hill_climbing.py
@@ -10,7 +10,7 @@ def test_accepts_better():
     Tests if the hill climbing method accepts a better solution.
     """
     hill_climbing = HillClimbing()
-    assert_(hill_climbing.accept(rnd.RandomState(), One(), One(), Zero()))
+    assert_(hill_climbing(rnd.RandomState(), One(), One(), Zero()))
 
 
 def test_rejects_worse():
@@ -18,7 +18,7 @@ def test_rejects_worse():
     Tests if the hill climbing method accepts a worse solution.
     """
     hill_climbing = HillClimbing()
-    assert_(not hill_climbing.accept(rnd.RandomState(), Zero(), Zero(), One()))
+    assert_(not hill_climbing(rnd.RandomState(), Zero(), Zero(), One()))
 
 
 def test_accepts_equal():
@@ -27,4 +27,4 @@ def test_accepts_equal():
     same objective value.
     """
     hill_climbing = HillClimbing()
-    assert_(hill_climbing.accept(rnd.RandomState(), Zero(), Zero(), Zero()))
+    assert_(hill_climbing(rnd.RandomState(), Zero(), Zero(), Zero()))
diff --git a/alns/criteria/tests/test_record_to_record_travel.py b/alns/criteria/tests/test_record_to_record_travel.py
index 7bd2288..7890dfc 100644
--- a/alns/criteria/tests/test_record_to_record_travel.py
+++ b/alns/criteria/tests/test_record_to_record_travel.py
@@ -83,7 +83,7 @@ def test_end_threshold():
 
 def test_accepts_better():
     record_travel = RecordToRecordTravel(1, 0, 0.1)
-    assert_(record_travel.accept(rnd.RandomState(), One(), Zero(), Zero()))
+    assert_(record_travel(rnd.RandomState(), One(), Zero(), Zero()))
 
 
 def test_rejects_worse():
@@ -91,7 +91,7 @@ def test_rejects_worse():
 
     # This results in a relative worsening of plus one, which is bigger than
     # the threshold (0.5).
-    assert_(not record_travel.accept(rnd.RandomState(), Zero(), Zero(), One()))
+    assert_(not record_travel(rnd.RandomState(), Zero(), Zero(), One()))
 
 
 def test_accepts_equal():
@@ -99,7 +99,7 @@ def test_accepts_equal():
 
     # Even a the strictest threshold, this should be accepted since the
     # relative improvement is zero (they are equal).
-    assert_(record_travel.accept(rnd.RandomState(), Zero(), Zero(), Zero()))
+    assert_(record_travel(rnd.RandomState(), Zero(), Zero(), Zero()))
 
 
 def test_linear_threshold_update():
@@ -109,10 +109,10 @@ def test_linear_threshold_update():
     # worsening is plus one, so this should be accepted (lower or equal to
     # threshold).
     for _ in range(5):
-        assert_(record_travel.accept(rnd.RandomState(), Zero(), Zero(), One()))
+        assert_(record_travel(rnd.RandomState(), Zero(), Zero(), One()))
 
     # Threshold is now zero, so this should no longer be accepted.
-    assert_(not record_travel.accept(rnd.RandomState(), Zero(), Zero(), One()))
+    assert_(not record_travel(rnd.RandomState(), Zero(), Zero(), One()))
 
 
 def test_exponential_threshold_update():
@@ -121,6 +121,6 @@ def test_exponential_threshold_update():
     # The relative worsening is plus one, so this should be accepted initially,
     # as the threshold is 5, resp. 0.5. In the second case, 1 > 0.5, so the
     # second should be rejected.
-    assert_(record_travel.accept(rnd.RandomState(), Zero(), Zero(), One()))
-    assert_(not record_travel.accept(rnd.RandomState(), Zero(), Zero(), One()))
+    assert_(record_travel(rnd.RandomState(), Zero(), Zero(), One()))
+    assert_(not record_travel(rnd.RandomState(), Zero(), Zero(), One()))
 
diff --git a/alns/criteria/tests/test_simulated_annealing.py b/alns/criteria/tests/test_simulated_annealing.py
index aca7b46..df4cf24 100644
--- a/alns/criteria/tests/test_simulated_annealing.py
+++ b/alns/criteria/tests/test_simulated_annealing.py
@@ -1,23 +1,24 @@
+import numpy as np
 import numpy.random as rnd
-from numpy.testing import assert_, assert_equal, assert_raises
+from numpy.testing import (assert_, assert_almost_equal, assert_equal,
+                           assert_raises)
+from pytest import mark
 
 from alns.criteria import SimulatedAnnealing
 from alns.tests.states import One, Zero
 
 
-def test_raises_negative_parameters():
+@mark.parametrize("start,end,step",
+                  [(-1, 1, 1),  # negative start temp
+                   (1, -1, 1),  # negative end temp
+                   (1, 1, -1)])  # negative step
+def test_raises_negative_parameters(start: float, end: float, step: float):
     """
     Simulated annealing does not work with negative parameters, so those should
     not be accepted.
     """
-    with assert_raises(ValueError):  # start temperature cannot be
-        SimulatedAnnealing(-1, 1, 1)  # negative
-
-    with assert_raises(ValueError):  # nor can the end temperature
-        SimulatedAnnealing(1, -1, 1)
-
-    with assert_raises(ValueError):  # nor the updating step
-        SimulatedAnnealing(1, 1, -1)
+    with assert_raises(ValueError):
+        SimulatedAnnealing(start, end, step)
 
 
 def test_raises_explosive_step():
@@ -53,43 +54,41 @@ def test_raises_start_smaller_than_end():
 
 def test_does_not_raise():
     """
-    This set of parameters should work correctly.
+    These sets of parameters should work correctly.
     """
-    SimulatedAnnealing(10, 5, 2)
+    SimulatedAnnealing(10, 5, 1, "exponential")
+    SimulatedAnnealing(10, 5, 2, "linear")
 
 
-def test_step():
+@mark.parametrize("step", range(10))
+def test_step(step: int):
     """
     Tests if the step parameter is correctly set.
     """
-    for step in range(100):
-        assert_equal(SimulatedAnnealing(1, 1, step).step, step)
+    # Linear because exponential does not take explosive step parameters.
+    assert_equal(SimulatedAnnealing(1, 1, step, "linear").step, step)
 
 
-def test_start_temperature():
+@mark.parametrize("start", range(1, 10))
+def test_start_temperature(start: int):
     """
     Tests if the start_temperature parameter is correctly set.
     """
-    for start in range(1, 100):
-        assert_equal(SimulatedAnnealing(start, 1, 1).start_temperature, start)
+    assert_equal(SimulatedAnnealing(start, 1, 1).start_temperature, start)
 
 
-def test_end_temperature():
+@mark.parametrize("end", range(1, 10))
+def test_end_temperature(end: float):
     """
     Tests if the end_temperature parameter is correctly set.
     """
-    for end in range(1, 100):
-        assert_equal(SimulatedAnnealing(100, end, 1).end_temperature, end)
+    assert_equal(SimulatedAnnealing(10, end, 1).end_temperature, end)
 
 
 def test_accepts_better():
     for _ in range(1, 100):
         simulated_annealing = SimulatedAnnealing(2, 1, 1)
-
-        assert_(simulated_annealing.accept(rnd.RandomState(),
-                                           One(),
-                                           Zero(),
-                                           Zero()))
+        assert_(simulated_annealing(rnd.RandomState(), One(), Zero(), Zero()))
 
 
 def test_accepts_equal():
@@ -98,10 +97,7 @@ def test_accepts_equal():
     for _ in range(100):
         # This results in an acceptance probability of exp{0}, that is, one.
         # Thus, the candidate state should always be accepted.
-        assert_(simulated_annealing.accept(rnd.RandomState(),
-                                           One(),
-                                           One(),
-                                           One()))
+        assert_(simulated_annealing(rnd.RandomState(), One(), One(), One()))
 
 
 def test_linear_random_solutions():
@@ -109,7 +105,7 @@ def test_linear_random_solutions():
     Checks if the linear ``accept`` method correctly decides in two known cases
     for a fixed seed.
     """
-    simulated_annealing = SimulatedAnnealing(2, 1, 1)
+    simulated_annealing = SimulatedAnnealing(2, 1, 1, "linear")
 
     state = rnd.RandomState(0)
 
@@ -117,8 +113,8 @@ def test_linear_random_solutions():
     # respectively. The acceptance probability is 0.61 first, so the first
     # should be accepted (0.61 > 0.55). Thereafter, it drops to 0.37, so the
     # second should not (0.37 < 0.72).
-    assert_(simulated_annealing.accept(state, Zero(), Zero(), One()))
-    assert_(not simulated_annealing.accept(state, Zero(), Zero(), One()))
+    assert_(simulated_annealing(state, Zero(), Zero(), One()))
+    assert_(not simulated_annealing(state, Zero(), Zero(), One()))
 
 
 def test_exponential_random_solutions():
@@ -131,8 +127,8 @@ def test_exponential_random_solutions():
 
     state = rnd.RandomState(0)
 
-    assert_(simulated_annealing.accept(state, Zero(), Zero(), One()))
-    assert_(not simulated_annealing.accept(state, Zero(), Zero(), One()))
+    assert_(simulated_annealing(state, Zero(), Zero(), One()))
+    assert_(not simulated_annealing(state, Zero(), Zero(), One()))
 
 
 def test_accepts_generator_and_random_state():
@@ -148,11 +144,53 @@ def random_sample(self):  # pylint: disable=no-self-use
             return 0.5
 
     simulated_annealing = SimulatedAnnealing(2, 1, 1)
-    assert_(simulated_annealing.accept(Old(), One(), One(), Zero()))
+    assert_(simulated_annealing(Old(), One(), One(), Zero()))
 
     class New:  # new Generator interface mock
         def random(self):  # pylint: disable=no-self-use
             return 0.5
 
     simulated_annealing = SimulatedAnnealing(2, 1, 1)
-    assert_(simulated_annealing.accept(New(), One(), One(), Zero()))
+    assert_(simulated_annealing(New(), One(), One(), Zero()))
+
+
+@mark.parametrize("worse,accept_prob,iters",
+                  [(1, 0, 10),  # zero accept prob
+                   (1, 1.2, 10),  # prob outside unit interval
+                   (1, 1, 10),  # unit accept prob
+                   (-1, 0.5, 10),  # negative worse
+                   (0, -1, 10),  # negative prob
+                   (1.5, 0.5, 10),  # worse outside unit interval
+                   (1, .9, -10)])  # negative number of iterations
+def test_autofit_raises_for_invalid_inputs(worse: float,
+                                           accept_prob: float,
+                                           iters: int):
+    with assert_raises(ValueError):
+        SimulatedAnnealing.autofit(1., worse, accept_prob, iters)
+
+
+@mark.parametrize("init_obj,worse,accept_prob,iters",
+                  [(1_000, 1, .9, 1),
+                   (1_000, .5, .05, 1)])
+def test_autofit_on_several_examples(init_obj: float,
+                                     worse: float,
+                                     accept_prob: float,
+                                     iters: int):
+    # We have:
+    # prob = exp{-(f^c - f^i) / T},
+    # where T is start temp, f^i is init sol objective, and f^c is the candidate
+    # solution objective. We also have that f^c is at worst (1 + worse) f^i.
+    # Substituting and solving for T, we then find:
+    # T = -worse * f^i / ln(p).
+    sa_start = -worse * init_obj / np.log(accept_prob)
+    sa_end = 1
+
+    # We have end = r ** iters * start, so r = (end / start) ** (1 / iters).
+    sa_step = (sa_end / sa_start) ** (1 / iters)
+
+    sa = SimulatedAnnealing.autofit(init_obj, worse, accept_prob, iters)
+
+    assert_almost_equal(sa.start_temperature, sa_start)
+    assert_almost_equal(sa.end_temperature, sa_end)
+    assert_almost_equal(sa.step, sa_step)
+    assert_equal(sa.method, "exponential")
diff --git a/alns/tests/test_alns.py b/alns/tests/test_alns.py
index 5a6053b..b8a5f6b 100644
--- a/alns/tests/test_alns.py
+++ b/alns/tests/test_alns.py
@@ -1,10 +1,11 @@
 import numpy.random as rnd
 from numpy.testing import (assert_, assert_almost_equal, assert_equal,
-                           assert_no_warnings, assert_raises, assert_warns)
+                           assert_raises)
+from pytest import mark
 
 from alns import ALNS, State
 from alns.criteria import HillClimbing, SimulatedAnnealing
-from alns.tools.warnings import OverwriteWarning
+from alns.weight_schemes import SimpleWeights
 from .states import One, Zero
 
 
@@ -42,24 +43,6 @@ def objective(self):
 
 # CALLBACKS --------------------------------------------------------------------
 
-def dummy_callback():
-    return None
-
-
-def test_overwrite_warns_on_best():
-    """
-    There can only be a single callback for each event point, so inserting two
-    (or more) should warn the previous callback for ``on_best`` is overwritten.
-    """
-    alns = get_alns_instance([lambda state, rnd: Zero()],
-                             [lambda state, rnd: Zero()])
-
-    with assert_no_warnings():  # first insert is fine..
-        alns.on_best(dummy_callback)
-
-    with assert_warns(OverwriteWarning):  # .. but second insert should warn
-        alns.on_best(dummy_callback)
-
 
 def test_on_best_is_called():
     """
@@ -73,7 +56,8 @@ def test_on_best_is_called():
     # should then also be returned by the entire algorithm.
     alns.on_best(lambda *args: ValueState(10))
 
-    result = alns.iterate(One(), [1, 1, 1, 1], .5, HillClimbing(), 1)
+    weights = SimpleWeights([1, 1, 1, 1], 1, 1, .5)
+    result = alns.iterate(One(), weights, HillClimbing(), 1)
     assert_equal(result.best_state.objective(), 10)
 
 
@@ -142,27 +126,6 @@ def repair_operator():  # placeholder
     assert_(operator is repair_operator)
 
 
-def test_add_operator_same_name_warns_per_type():
-    """
-    Adding an operator with the same name as an already added operator (of the
-    same type) should warn that the previous operator will be overwritten.
-    """
-    alns = ALNS()
-
-    with assert_no_warnings():
-        # The same name is allowed for different types of operators.
-        alns.add_destroy_operator(lambda state, rnd: None, "test")
-        alns.add_repair_operator(lambda state, rnd: None, "test")
-
-    with assert_warns(OverwriteWarning):
-        # Already exists as a destroy operator.
-        alns.add_destroy_operator(lambda state, rnd: None, "test")
-
-    with assert_warns(OverwriteWarning):
-        # Already exists as a repair operator.
-        alns.add_repair_operator(lambda state, rnd: None, "test")
-
-
 # PARAMETERS -------------------------------------------------------------------
 
 
@@ -172,8 +135,12 @@ def test_raises_missing_destroy_operator():
     """
     alns = get_alns_instance(repair_operators=[lambda state, rnd: None])
 
+    # Pretend we have a destroy operator for the weight scheme, so that
+    # does not raise an error.
+    weights = SimpleWeights([1, 1, 1, 1], 1, 1, 0.95)
+
     with assert_raises(ValueError):
-        alns.iterate(One(), [1, 1, 1, 1], 0.95, HillClimbing())
+        alns.iterate(One(), weights, HillClimbing())
 
 
 def test_raises_missing_repair_operator():
@@ -182,55 +149,12 @@ def test_raises_missing_repair_operator():
     """
     alns = get_alns_instance(destroy_operators=[lambda state, rnd: None])
 
-    with assert_raises(ValueError):
-        alns.iterate(One(), [1, 1, 1, 1], 0.95, HillClimbing())
-
-
-def test_raises_negative_operator_decay():
-    """
-    Tests if the algorithm raises when a negative operator decay parameter is
-    passed.
-    """
-    alns = get_alns_instance([lambda state, rnd: None],
-                             [lambda state, rnd: None])
+    # Pretend we have a destroy operator for the weight scheme, so that
+    # does not raise an error.
+    weights = SimpleWeights([1, 1, 1, 1], 1, 1, 0.95)
 
     with assert_raises(ValueError):
-        alns.iterate(One(), [1, 1, 1, 1], -0.5, HillClimbing())
-
-
-def test_raises_explosive_operator_decay():
-    """
-    Tests if the algorithm raises when an explosive operator decay parameter is
-    passed.
-    """
-    alns = get_alns_instance([lambda state, rnd: None],
-                             [lambda state, rnd: None])
-
-    with assert_raises(ValueError):
-        alns.iterate(One(), [1, 1, 1, 1], 1.2, HillClimbing())
-
-
-def test_raises_insufficient_weights():
-    """
-    We need (at least) four weights to be passed-in, one for each updating
-    scenario.
-    """
-    alns = get_alns_instance([lambda state, rnd: None],
-                             [lambda state, rnd: None])
-
-    with assert_raises(ValueError):
-        alns.iterate(One(), [1, 1, 1], .5, HillClimbing())
-
-
-def test_raises_negative_weights():
-    """
-    The passed-in weights should all be non-negative.
-    """
-    alns = get_alns_instance([lambda state, rnd: None],
-                             [lambda state, rnd: None])
-
-    with assert_raises(ValueError):
-        alns.iterate(One(), [1, 1, -5, 1], .5, HillClimbing())
+        alns.iterate(One(), weights, HillClimbing())
 
 
 def test_raises_negative_iterations():
@@ -241,64 +165,50 @@ def test_raises_negative_iterations():
                              [lambda state, rnd: None])
 
     initial_solution = One()
+    weights = SimpleWeights([1, 1, 1, 1], 1, 1, .5)
 
     # A negative iteration count is not understood, for obvious reasons.
     with assert_raises(ValueError):
-        alns.iterate(initial_solution, [1, 1, 1, 1], .5, HillClimbing(), -1)
+        alns.iterate(initial_solution, weights, HillClimbing(), -1)
 
     # But zero should just return the initial solution.
-    result = alns.iterate(initial_solution, [1, 1, 1, 1], .5, HillClimbing(), 0)
+    result = alns.iterate(initial_solution, weights, HillClimbing(), 0)
 
     assert_(result.best_state is initial_solution)
 
 
-def test_does_not_raise():
-    """
-    This set of parameters, on the other hand, should work correctly.
-    """
-    alns = get_alns_instance([lambda state, rnd: One()],
-                             [lambda state, rnd: One()])
-
-    alns.iterate(Zero(), [1, 1, 1, 1], .5, HillClimbing(), 100)
-
-    # 0 and 1 are both acceptable decay parameters (since v1.2.0).
-    alns.iterate(Zero(), [1, 1, 1, 1], 0., HillClimbing(), 100)
-    alns.iterate(Zero(), [1, 1, 1, 1], 1., HillClimbing(), 100)
-
-
 # EXAMPLES ---------------------------------------------------------------------
 
 
 def test_trivial_example():
     """
     This tests the ALNS algorithm on a trivial example, where the initial
-    solution is zero, and any other operator returns one.
+    solution is one, and any other operator returns zero.
     """
     alns = get_alns_instance([lambda state, rnd: Zero()],
                              [lambda state, rnd: Zero()])
 
-    result = alns.iterate(One(), [1, 1, 1, 1], .5, HillClimbing(), 100)
+    weights = SimpleWeights([1, 1, 1, 1], 1, 1, .5)
+    result = alns.iterate(One(), weights, HillClimbing(), 100)
 
     assert_equal(result.best_state.objective(), 0)
 
 
-def test_fixed_seed_outcomes():
+@mark.parametrize("seed,desired", [(0, 0.01171), (1, 0.00011), (2, 0.01025)])
+def test_fixed_seed_outcomes(seed: int, desired: float):
     """
     Tests if fixing a seed results in deterministic outcomes even when using a
     'random' acceptance criterion (here SA).
     """
-    outcomes = [0.01171, 0.00011, 0.01025]
-
-    for seed, desired in enumerate(outcomes):  # idx is seed
-        alns = get_alns_instance(
-            [lambda state, rnd: ValueState(rnd.random_sample())],
-            [lambda state, rnd: None],
-            seed)
-
-        simulated_annealing = SimulatedAnnealing(1, .25, 1 / 100)
+    alns = get_alns_instance(
+        [lambda state, rnd: ValueState(rnd.random_sample())],
+        [lambda state, rnd: None],
+        seed)
 
-        result = alns.iterate(One(), [1, 1, 1, 1], .5, simulated_annealing, 100)
+    weights = SimpleWeights([1, 1, 1, 1], 1, 1, .5)
+    sa = SimulatedAnnealing(1, .25, 1 / 100)
 
-        assert_almost_equal(result.best_state.objective(), desired, decimal=5)
+    result = alns.iterate(One(), weights, sa, 100)
+    assert_almost_equal(result.best_state.objective(), desired, decimal=5)
 
 # TODO test more complicated examples?
diff --git a/alns/tests/test_result.py b/alns/tests/test_result.py
index c6d113b..faaeb8a 100644
--- a/alns/tests/test_result.py
+++ b/alns/tests/test_result.py
@@ -5,7 +5,6 @@
 
 from alns.Result import Result
 from alns.Statistics import Statistics
-from alns.tools.exceptions import NotCollectedError
 from .states import Sentinel
 
 try:
@@ -125,20 +124,6 @@ def test_result_state():
     assert_(get_result(best).best_state is best)
 
 
-def test_raises_missing_statistics():
-    """
-    Accessing the statistics object when no statistics have been passed-in
-    should raise.
-    """
-    result = Result(Sentinel())
-
-    with assert_raises(NotCollectedError):
-        result.statistics  # pylint: disable=pointless-statement
-
-    result = Result(Sentinel(), Statistics())
-    result.statistics  # pylint: disable=pointless-statement
-
-
 @pytest.mark.matplotlib
 @check_figures_equal(extensions=['png'])
 def test_plot_objectives(fig_test, fig_ref):
@@ -204,22 +189,6 @@ def test_plot_operator_counts(fig_test, fig_ref):
                       result.statistics.repair_operator_counts)
 
 
-def test_plot_operator_counts_raises_legend():
-    """
-    Tests if the ``plot_operator_counts`` method raises when the passed-in
-    legend is of insufficient length.
-    """
-    result = get_result(Sentinel())
-
-    with assert_raises(ValueError):
-        # Legend should be of length at most four.
-        result.plot_operator_counts(legend=["test"] * 5)
-
-    # This should work.
-    result.plot_operator_counts(legend=["test"] * 2)
-    result.plot_operator_counts(legend=["test"] * 4)
-
-
 @pytest.mark.matplotlib
 @check_figures_equal(extensions=['png'])
 def test_plot_operator_counts_title(fig_test, fig_ref):
diff --git a/alns/tests/test_select_operator.py b/alns/tests/test_select_operator.py
deleted file mode 100644
index b7686d0..0000000
--- a/alns/tests/test_select_operator.py
+++ /dev/null
@@ -1,25 +0,0 @@
-from numpy.random import RandomState
-from numpy.testing import assert_equal
-
-from alns.select_operator import select_operator
-
-
-def test_single_choice():
-    """
-    When there is only a single choice, the method should return the same
-    operator index every time, regardless of the weights and random state.
-    """
-    for _ in range(100):
-        assert_equal(select_operator([None], [1], RandomState()), 0)
-
-
-def test_all_weight_on_one_operator():
-    """
-    When all weight is assigned to a single operator, that operator must be
-    selected every time.
-    """
-    for _ in range(100):        # all weigt is now on the first operator.
-        assert_equal(select_operator([None, None], [5, 0], RandomState()), 0)
-
-    for _ in range(100):        # and now on the second.
-        assert_equal(select_operator([None, None], [0, 5], RandomState()), 1)
diff --git a/alns/tools/__init__.py b/alns/weight_schemes/tests/__init__.py
similarity index 100%
rename from alns/tools/__init__.py
rename to alns/weight_schemes/tests/__init__.py
diff --git a/alns/weight_schemes/tests/test_segmented_weights.py b/alns/weight_schemes/tests/test_segmented_weights.py
new file mode 100644
index 0000000..34d6ab0
--- /dev/null
+++ b/alns/weight_schemes/tests/test_segmented_weights.py
@@ -0,0 +1,62 @@
+from typing import List
+
+import numpy as np
+from numpy.testing import assert_almost_equal, assert_raises
+from pytest import mark
+
+from alns.weight_schemes import SegmentedWeights
+
+
+@mark.parametrize("seg_decay", [1.01, -0.01, -0.5, 1.5])
+def test_raises_invalid_seg_decay(seg_decay: float):
+    with assert_raises(ValueError):
+        SegmentedWeights([0, 0, 0, 0], 1, 1, seg_decay)
+
+
+@mark.parametrize("seg_decay", np.linspace(0, 1, num=5))
+def test_does_not_raise_valid_seg_decay(seg_decay: float):
+    SegmentedWeights([0, 0, 0, 0], 1, 1, seg_decay)
+
+
+@mark.parametrize("scores,seg_decay,expected",
+                  [([5, 3, 2, 1], 0, [3, 3]),  # 1 * 0 + (0 + 3) * 1 = 3
+                   ([5, 3, 2, 1], 1, [1, 1]),  # 1 * 1 + (0 + 3) * 0 = 1
+                   ([5, 3, 2, 1], .5, [2, 2]),  # .5 * 1 + (0 + 3) * .5 = 2
+                   ([5, 5, 5, 5], 0, [5, 5]),  # etc. etc.
+                   ([5, 5, 5, 5], 1, [1, 1]),
+                   ([5, 5, 5, 5], .5, [3, 3])])
+def test_update_weights(scores: List[float],
+                        seg_decay: float,
+                        expected: List[float]):
+    rnd_state = np.random.RandomState(1)
+    weights = SegmentedWeights(scores, 1, 1, seg_decay, 1)
+
+    # TODO other weights?
+    weights.update_weights(0, 0, 1)
+    weights.select_operators(rnd_state)
+
+    assert_almost_equal(weights.destroy_weights[0], expected[0])
+    assert_almost_equal(weights.repair_weights[0], expected[1])
+
+
+@mark.parametrize("scores,num_destroy,num_repair,seg_decay,seg_length",
+                  [
+                      ([5, 3, 2, -1], 1, 1, 0, 1),  # negative score
+                      ([5, 3, 2], 1, 1, 0, 1),      # len(score) < 4
+                      ([5, 3, 2, 1], 0, 1, 0, 1),   # no destroy operator
+                      ([5, 3, 2, 1], 1, 0, 0, 1),   # no repair operator
+                      ([5, 3, 2, 1], 1, 1, -1, 1),  # seg_decay < 0
+                      ([5, 3, 2, 1], 1, 1, 2, 1),   # seg_decay > 1
+                      ([5, 3, 2, 1], 1, 1, .5, 0),   # seg_length < 1
+                  ])
+def test_raises_invalid_arguments(scores: List[float],
+                                  num_destroy: int,
+                                  num_repair: int,
+                                  seg_decay: float,
+                                  seg_length: int):
+    with assert_raises(ValueError):
+        SegmentedWeights(scores, num_destroy, num_repair, seg_decay,
+                         seg_length)
+
+
+# TODO test select weights, at iteration start
diff --git a/alns/weight_schemes/tests/test_simple_weights.py b/alns/weight_schemes/tests/test_simple_weights.py
new file mode 100644
index 0000000..67b8ba0
--- /dev/null
+++ b/alns/weight_schemes/tests/test_simple_weights.py
@@ -0,0 +1,37 @@
+from typing import List
+
+import numpy as np
+from numpy.testing import assert_raises, assert_almost_equal
+from pytest import mark
+
+from alns.weight_schemes import SimpleWeights
+
+
+@mark.parametrize("op_decay", [1.01, -0.01, -0.5, 1.5])
+def test_raises_invalid_op_decay(op_decay: float):
+    with assert_raises(ValueError):
+        SimpleWeights([0, 0, 0, 0], 1, 1, op_decay)
+
+
+@mark.parametrize("op_decay", np.linspace(0, 1, num=5))
+def test_does_not_raise_valid_op_decay(op_decay: float):
+    SimpleWeights([0, 0, 0, 0], 1, 1, op_decay)
+
+
+@mark.parametrize("scores,op_decay,expected",
+                  [([0, 0, 0, 0], 1, [1, 1]),  # scores are not used
+                   ([0, 0, 0, 0], 0, [0, 0]),  # initial weights are not used
+                   ([.5, .5, .5, .5], .5, [.75, .75])])  # convex combination
+def test_update_weights(scores: List[float],
+                        op_decay: float,
+                        expected: List[float]):
+    weights = SimpleWeights(scores, 1, 1, op_decay)
+
+    # TODO other weights?
+    weights.update_weights(0, 0, 1)
+
+    assert_almost_equal(weights.destroy_weights[0], expected[0])
+    assert_almost_equal(weights.repair_weights[0], expected[1])
+
+
+# TODO test select weights